* [PATCH net] vsock/virtio: bind uarg before filling zerocopy skb
From: malin (R) @ 2026-05-25 11:15 UTC (permalink / raw)
To: Arseniy Krasnov, tanjingguo, mst@redhat.com, jasowang@redhat.com,
xuanzhuo@linux.alibaba.com, eperezma@redhat.com,
stefanha@redhat.com, sgarzare@redhat.com, davem@davemloft.net,
edumazet@google.com, kuba@kernel.org, pabeni@redhat.com,
horms@kernel.org
Cc: Chenzhe, cenxianlong, cuirongzhen, virtualization@lists.linux.dev,
kvm@vger.kernel.org, netdev@vger.kernel.org,
linux-kernel@vger.kernel.org, tanjingguo
From 9eea4f61a4dca97f56c23e12267219bf791a20d1 Mon Sep 17 00:00:00 2001
From: Jingguo Tan <tanjingguo@huawei.com>
Date: Fri, 22 May 2026 19:53:45 +0800
Subject: [PATCH net] vsock/virtio: bind uarg before filling zerocopy skb
virtio_transport_send_pkt_info() allocates or reuses the zerocopy uarg
before entering the send loop, but virtio_transport_alloc_skb() still
fills the skb before it inherits that uarg. When fixed-buffer vectored
zerocopy hits MAX_SKB_FRAGS, io_sg_from_iter() may partially attach
managed frags and return -EMSGSIZE. The rollback path calls kfree_skb()
to free an skb that carries SKBFL_MANAGED_FRAG_REFS but no uarg, so
skb_release_data() falls through to ordinary frag unref.
Pass the uarg into virtio_transport_alloc_skb() and bind it immediately
before virtio_transport_fill_skb(). This keeps control or no-payload skbs
untouched while ensuring success and rollback share one lifetime rule.
Fixes: 581512a6dc93 ("vsock/virtio: MSG_ZEROCOPY flag support")
Signed-off-by: Lin Ma <malin89@huawei.com>
Signed-off-by: Rongzhen Cui <cuirongzhen@huawei.com>
Signed-off-by: Jingguo Tan <tanjingguo@huawei.com>
---
net/vmw_vsock/virtio_transport_common.c | 11 ++++++++---
1 file changed, 8 insertions(+), 3 deletions(-)
diff --git a/net/vmw_vsock/virtio_transport_common.c b/net/vmw_vsock/virtio_transport_common.c
index df3b418e0392..73f58925ff72 100644
--- a/net/vmw_vsock/virtio_transport_common.c
+++ b/net/vmw_vsock/virtio_transport_common.c
@@ -205,6 +205,7 @@ static u16 virtio_transport_get_type(struct sock *sk)
static struct sk_buff *virtio_transport_alloc_skb(struct virtio_vsock_pkt_info *info,
size_t payload_len,
bool zcopy,
+ struct ubuf_info *uarg,
u32 src_cid,
u32 src_port,
u32 dst_cid,
@@ -245,6 +246,11 @@ static struct sk_buff *virtio_transport_alloc_skb(struct virtio_vsock_pkt_info *
if (info->msg && payload_len > 0) {
int err;
+ /* Bind the zerocopy lifetime before filling frags so error rollback
+ * frees managed fixed-buffer pages through the uarg-aware path.
+ */
+ skb_zcopy_set(skb, uarg, NULL);
+
err = virtio_transport_fill_skb(skb, info, payload_len, zcopy);
if (err)
goto out;
@@ -364,6 +370,7 @@ static int virtio_transport_send_pkt_info(struct vsock_sock *vsk,
skb_len = min(max_skb_len, rest_len);
skb = virtio_transport_alloc_skb(info, skb_len, can_zcopy,
+ uarg,
src_cid, src_port,
dst_cid, dst_port);
if (!skb) {
@@ -371,8 +378,6 @@ static int virtio_transport_send_pkt_info(struct vsock_sock *vsk,
break;
}
- skb_zcopy_set(skb, uarg, NULL);
-
virtio_transport_inc_tx_pkt(vvs, skb);
ret = t_ops->send_pkt(skb, info->net);
@@ -1183,7 +1188,7 @@ static int virtio_transport_reset_no_sock(const struct virtio_transport *t,
if (!t)
return -ENOTCONN;
- reply = virtio_transport_alloc_skb(&info, 0, false,
+ reply = virtio_transport_alloc_skb(&info, 0, false, NULL,
le64_to_cpu(hdr->dst_cid),
le32_to_cpu(hdr->dst_port),
le64_to_cpu(hdr->src_cid),
--
2.53.0
^ permalink raw reply related
* Re: [PATCH net] vsock/virtio: fix skb overhead overflow on 32-bit builds
From: David Laight @ 2026-05-25 10:53 UTC (permalink / raw)
To: Stefano Garzarella
Cc: patchwork-bot+netdevbpf, netdev, xuanzhuo, horms, virtualization,
linux-kernel, kvm, kuba, eperezma, pabeni, mst, davem, jasowang,
stefanha, edumazet, stable
In-Reply-To: <ahQbVxvbBEJZ3TBU@sgarzare-redhat>
On Mon, 25 May 2026 11:57:45 +0200
Stefano Garzarella <sgarzare@redhat.com> wrote:
> On Sat, May 23, 2026 at 05:35:57PM +0100, David Laight wrote:
> >On Sat, 23 May 2026 02:20:29 +0000
> >patchwork-bot+netdevbpf@kernel.org wrote:
> >
> >> Hello:
> >>
> >> This patch was applied to netdev/net.git (main)
> >> by Jakub Kicinski <kuba@kernel.org>:
> >
> >Did anyone else notice that is isn't a bug?
> >
> >There is no way that a 'count of bytes of kernel memory' can overflow
> >the size of 'long'.
>
> It's more of an estimate than an actual calculation of memory usage if
> we queue the incoming packet. In theory, an overflow could occur if the
> user sets `buf_alloc` to 4GB. In practice, though, I think you're right:
> the memory should run out before we get to that check.
The calculation is:
u64 skb_overhead = (skb_queue_len(&vvs->rx_queue) + 1) * SKB_TRUESIZE(0);
skb_queue_len() will be the number of items on the queue.
SKB_TRUESIZE(0) is the memory taken up by a zero length skb (basically sizeof(skb)).
Unless you either corrupt the queue length or manage to allocate skb that use
less than the minimum about of memory that product can't overflow 'unsigned long'.
The later calculations might wrap - but the multiply can't.
-- David
>
> Thanks,
> Stefano
>
> >
> >-- David
> >
> >>
> >> On Thu, 21 May 2026 14:47:32 +0200 you wrote:
> >> > From: Stefano Garzarella <sgarzare@redhat.com>
> >> >
> >> > On 32-bit architectures, both skb_queue_len() and SKB_TRUESIZE(0) evaluate
> >> > to 32-bit values. The multiplication can overflow before being assigned to
> >> > the u64 skb_overhead variable, making the skb overhead check ineffective.
> >> >
> >> > Cast skb_queue_len() to u64 so the multiplication is always performed in
> >> > 64-bit arithmetic.
> >> >
> >> > [...]
> >>
> >> Here is the summary with links:
> >> - [net] vsock/virtio: fix skb overhead overflow on 32-bit builds
> >> https://git.kernel.org/netdev/net/c/4157501b9a8f
> >>
> >> You are awesome, thank you!
> >
>
^ permalink raw reply
* Re: [PATCH net] vsock/virtio: fix skb overhead overflow on 32-bit builds
From: Stefano Garzarella @ 2026-05-25 9:57 UTC (permalink / raw)
To: David Laight
Cc: patchwork-bot+netdevbpf, netdev, xuanzhuo, horms, virtualization,
linux-kernel, kvm, kuba, eperezma, pabeni, mst, davem, jasowang,
stefanha, edumazet, stable
In-Reply-To: <20260523173557.5cc4f4f6@pumpkin>
On Sat, May 23, 2026 at 05:35:57PM +0100, David Laight wrote:
>On Sat, 23 May 2026 02:20:29 +0000
>patchwork-bot+netdevbpf@kernel.org wrote:
>
>> Hello:
>>
>> This patch was applied to netdev/net.git (main)
>> by Jakub Kicinski <kuba@kernel.org>:
>
>Did anyone else notice that is isn't a bug?
>
>There is no way that a 'count of bytes of kernel memory' can overflow
>the size of 'long'.
It's more of an estimate than an actual calculation of memory usage if
we queue the incoming packet. In theory, an overflow could occur if the
user sets `buf_alloc` to 4GB. In practice, though, I think you're right:
the memory should run out before we get to that check.
Thanks,
Stefano
>
>-- David
>
>>
>> On Thu, 21 May 2026 14:47:32 +0200 you wrote:
>> > From: Stefano Garzarella <sgarzare@redhat.com>
>> >
>> > On 32-bit architectures, both skb_queue_len() and SKB_TRUESIZE(0) evaluate
>> > to 32-bit values. The multiplication can overflow before being assigned to
>> > the u64 skb_overhead variable, making the skb overhead check ineffective.
>> >
>> > Cast skb_queue_len() to u64 so the multiplication is always performed in
>> > 64-bit arithmetic.
>> >
>> > [...]
>>
>> Here is the summary with links:
>> - [net] vsock/virtio: fix skb overhead overflow on 32-bit builds
>> https://git.kernel.org/netdev/net/c/4157501b9a8f
>>
>> You are awesome, thank you!
>
^ permalink raw reply
* Re: [PATCH net] vsock/virtio: fix potential unbounded skb queue
From: Stefano Garzarella @ 2026-05-25 9:14 UTC (permalink / raw)
To: Demi Marie Obenour
Cc: Michael S. Tsirkin, Eric Dumazet, Arseniy Krasnov, Bobby Eshleman,
Stefan Hajnoczi, David S . Miller, Jakub Kicinski, Paolo Abeni,
Simon Horman, netdev, eric.dumazet, Arseniy Krasnov, Jason Wang,
Xuan Zhuo, Eugenio Pérez, kvm, virtualization,
virtio-comment@lists.linux.dev, Manuel Stoeckl, Alyssa Ross,
Spectrum Development, systemd development, Val Packett
In-Reply-To: <96977898-81a0-4c79-a95f-0b288e0572a6@gmail.com>
On Mon, 25 May 2026 at 04:37, Demi Marie Obenour <demiobenour@gmail.com> wrote:
>
> On 5/23/26 17:00, Demi Marie Obenour wrote:
> > On 5/8/26 06:11, Stefano Garzarella wrote:
> >> On Fri, May 08, 2026 at 05:58:06AM -0400, Michael S. Tsirkin wrote:
> >>> On Fri, May 08, 2026 at 11:41:21AM +0200, Stefano Garzarella wrote:
> >>>> On Thu, May 07, 2026 at 06:48:47PM -0400, Michael S. Tsirkin wrote:
> >>>>> On Thu, May 07, 2026 at 02:59:13PM +0200, Stefano Garzarella wrote:
> >>>>>> On Thu, May 07, 2026 at 07:45:10AM -0400, Michael S. Tsirkin wrote:
> >>>>>>> On Thu, May 07, 2026 at 11:09:47AM +0200, Stefano Garzarella wrote:
> >>>>
> >>>> [...]
> >>>>
> >>>>>>>> For now, we're already doing something:
> >>>>>>>> merging the skuffs if they don't have EOM set.
> >>>>>>>
> >>>>>>>
> >>>>>>> Right that's good. You could go further and merge with EOM too
> >>>>>>> if you stick the info about message boundaries somewhere else.
> >>>>>>
> >>>>>> This adds a lot of complexity IMO, but we can try.
> >>>>>>
> >>>>>> Do you have something in mind?
> >>>>>
> >>>>> BER is clearly overkill but here's a POC that claude made for me,
> >>>>> just to give u an idea. It's clearly has a ton of issues,
> >>>>> for example I dislike how GFP_ATOMIC is handled.
> >>>>
> >>>> Okay, I somewhat understand, but clearly this isn't net material
> >>>
> >>> I doubt we have many other options given reverting the regression was
> >>> ruled out.
> >>
> >> As Eric pointed out, we can't revert it.
> >
> > Could there be an option to disable the mitigation in guests, for the
> > situation where the host is trusted? There are VMMs that implement
> > AF_VSOCK in userspace with a backing AF_UNIX socket.
Here the main problem was an attack to the host from the guest.
Can the application set the max (IIRC 4G) of SO_VM_SOCKETS_BUFFER_SIZE ?
> >
> >>>> so for now
> >>>> I think the best thing to do is to merge the fixup I sent (or something
> >>>> similar):
> >>>> https://lore.kernel.org/netdev/20260508092330.69690-1-sgarzare@redhat.com/
> >>>
> >>> I reviewed that one, problem is it's a spec violation/change that we'll
> >>> have to support forever.
> >>
> >> I have a few points to make on this, but let's discuss them there.
> >>
> >>>
> >>>> This is a major change that should be merged with more caution.
> >>>> Could this have too much of an impact on performance?
> >>>>
> >>>> Thanks,
> >>>> Stefano
> >>>
> >>> It's really a POC, real patch is left as an excersise for the reader
> >>> :).
> >>
> >> eheh, I see, but honestly, this overcomplication scares me. I'll try to
> >> think it over.
> >>
> >>> The correct approach IMHO is to only start using this
> >>> when we wasted a lot of memory on small packets.
> >>>
> >>> For example, if sum(truesize) >= buf size.
> >>>
> >>> then we'll not see a perf impact unless it's already pathological.
> >>
> >> Agree on this, which is similar to what I'm doing in that patch.
> >> Reducing the advertised buf_alloc only in pathological cases (e.g.
> >> overhead > buf_alloc).
> >
> > This isn't enough to prevent data loss due to race conditions.
Yep, we didn't go in that direction.
> >
> > I'm CCing the virtio-comment list and a few others.
> >
> > Right now, any application that needs to send massive amount of
> > data over a vsock is simply broken. This isn't just theoretical.
> > It's causing real-world problems for users of Waypipe.
> > Waypipe forwards Wayland protocol messages over AF_VSOCK,
> > so it can send a large amount of traffic over the socket.
> > See https://gitlab.freedesktop.org/mstoceckl/waypipe/work_items/165.
> >
> > If one is willing to mutate the ring buffer in-place, or to maintain
> > an auxiliary counter, it's possible to store all messages with bounded
> > (in practice) overhead. Specifically:
> >
> > - If the first byte of a block of data is nonzero, it's a
> > variable-length length. 1 byte for messages less than 128 bytes.
> >
> > - If the first byte of a block of data is zero, the subsequent bytes
> > are a variable-length counter that stores the number of consecutive
> > zero-byte messages.
> >
> > That adds a lot of complexity, which is very unfortunate for something
> > that needs to be backported to stable kernels. I also suspect it
> > requires all access to the ring buffer to take a lock rather than
> > being lock-free. But it's the only approach that I can think of that
> > can work with the current spec.
Yep, we were discussing something like that in this thread, but we are
still working on that.
That said, any help on preparing patches for this would be more than welcome.
> >
> > Could there at least be a normative note stating that drivers and
> > devices should treat each message as consuming 1024 bytes + the size
> > of the message itself, and warning that anything that doesn't is
> > going to be broken in practice?
We would like to fix the issue. This is a transitive situation.
> >
> > I'm CCing Val Packet (of Invisible Things Lab) and Alyssa Ross
> > (of Spectrum) because both of them are working on systems that rely
> > critically on vsock.
>
> Update: I see that patches have been upstreamed (with CC: stable) that
> reset the connection instead of data loss.
Yep, hope that helps the situation. But again, can setting the max
SO_VM_SOCKETS_BUFFER_SIZE helps those applications?
Thanks,
Stefano
^ permalink raw reply
* Re: [PATCH RFC v3 2/6] rust/helpers: add virtio.c
From: Manos Pitsidianakis @ 2026-05-25 7:51 UTC (permalink / raw)
To: Eugenio Perez Martin
Cc: Miguel Ojeda, Manos Pitsidianakis, Peter Hilber,
Stefano Garzarella, Stefan Hajnoczi, Viresh Kumar,
Michael S. Tsirkin, Boqun Feng, Gary Guo, Björn Roy Baron,
Benno Lossin, Andreas Hindborg, Alice Ryhl, Trevor Gross,
Danilo Krummrich, Daniel Almeida, rust-for-linux, Jason Wang,
Xuan Zhuo, virtualization, linux-kernel
In-Reply-To: <CAJaqyWexdTrXcVoxxZb+frrfnr+xYCm67GGtWajWY-ygdyJfKw@mail.gmail.com>
On Thu, 21 May 2026 12:03, Eugenio Perez Martin <eperezma@redhat.com> wrote:
>On Sun, May 10, 2026 at 3:38 PM Manos Pitsidianakis
><manos@pitsidianak.is> wrote:
>>
>> Some internal kernel virtio API functions are inline macros, so define
>> their symbols in a helper file.
>>
>> Signed-off-by: Manos Pitsidianakis <manos@pitsidianak.is>
>> ---
>> MAINTAINERS | 6 ++++++
>> rust/helpers/helpers.c | 1 +
>> rust/helpers/virtio.c | 37 +++++++++++++++++++++++++++++++++++++
>> 3 files changed, 44 insertions(+)
>>
>> diff --git a/MAINTAINERS b/MAINTAINERS
>> index d1cc0e12fe1f004da89b1aa339116908f642e894..48c9c666d90b5a256ab6fae1f42508b789a0ce50 100644
>> --- a/MAINTAINERS
>> +++ b/MAINTAINERS
>> @@ -27930,6 +27930,12 @@ F: include/uapi/linux/virtio_*.h
>> F: net/vmw_vsock/virtio*
>> F: tools/virtio/
>>
>> +VIRTIO CORE API BINDINGS [RUST]
>> +M: Manos Pitsidianakis <manos@pitsidianak.is>
>> +L: virtualization@lists.linux.dev
>> +S: Maintained
>> +F: rust/helpers/virtio.c
>> +
>> VIRTIO CRYPTO DRIVER
>> M: Gonglei <arei.gonglei@huawei.com>
>> L: virtualization@lists.linux.dev
>> diff --git a/rust/helpers/helpers.c b/rust/helpers/helpers.c
>> index a3c42e51f00a0990bea81ebce6e99bb397ce7533..5dc0d2f2ee6bd2ae8e6abfe4baa247c1963967f6 100644
>> --- a/rust/helpers/helpers.c
>> +++ b/rust/helpers/helpers.c
>> @@ -61,6 +61,7 @@
>> #include "time.c"
>> #include "uaccess.c"
>> #include "usb.c"
>> +#include "virtio.c"
>> #include "vmalloc.c"
>> #include "wait.c"
>> #include "workqueue.c"
>> diff --git a/rust/helpers/virtio.c b/rust/helpers/virtio.c
>> new file mode 100644
>> index 0000000000000000000000000000000000000000..46aeeb063158823e66477777b3cd4bd1525df330
>> --- /dev/null
>> +++ b/rust/helpers/virtio.c
>> @@ -0,0 +1,37 @@
>> +// SPDX-License-Identifier: GPL-2.0
>> +
>> +#ifdef CONFIG_VIRTIO
>> +#include <linux/virtio_config.h>
>> +
>> +__rust_helper bool
>> +rust_helper_virtio_has_feature(const struct virtio_device *vdev,
>> + unsigned int fbit)
>> +{
>> + return virtio_has_feature(vdev, fbit);
>> +}
>> +__rust_helper void rust_helper_virtio_get_features(struct virtio_device *vdev,
>> + u64 *features_out)
>> +{
>> + return virtio_get_features(vdev, features_out);
>
>As a suggestion, perhaps an API that allows getting feature bits > 64,
>like VIRTIO_NET_F_GUEST_UDP_TUNNEL_GSO (65) or VIRTIO_NET_F_IPSEC (70)
>could save the need to add more functions in the future.
Yes, this will be needed indeed. I think however that as long as no
driver that uses features exists, this would be dead code so we should
not include it until it's needed.
I plan on dropping these helper bindings that have no user in my patches
in the next revisions.
>
>> +}
>> +
>> +__rust_helper int rust_helper_virtio_find_vqs(struct virtio_device *vdev,
>> + unsigned int nvqs,
>> + struct virtqueue *vqs[],
>> + struct virtqueue_info vqs_info[],
>> + struct irq_affinity *desc)
>> +{
>> + return virtio_find_vqs(vdev, nvqs, vqs, vqs_info, desc);
>> +}
>> +
>> +__rust_helper void rust_helper_virtio_device_ready(struct virtio_device *dev)
>> +{
>> + return virtio_device_ready(dev);
>> +}
>> +
>> +__rust_helper bool
>> +rust_helper_virtio_is_little_endian(struct virtio_device *vdev)
>> +{
>> + return virtio_is_little_endian(vdev);
>> +}
>> +#endif /* CONFIG_VIRTIO */
>>
>> --
>> 2.47.3
>>
>
^ permalink raw reply
* Re: [PATCH net] vsock/virtio: fix potential unbounded skb queue
From: Demi Marie Obenour @ 2026-05-25 2:37 UTC (permalink / raw)
To: Stefano Garzarella, Michael S. Tsirkin
Cc: Eric Dumazet, Arseniy Krasnov, Bobby Eshleman, Stefan Hajnoczi,
David S . Miller, Jakub Kicinski, Paolo Abeni, Simon Horman,
netdev, eric.dumazet, Arseniy Krasnov, Jason Wang, Xuan Zhuo,
Eugenio Pérez, kvm, virtualization,
virtio-comment@lists.linux.dev, Manuel Stoeckl, Alyssa Ross,
Spectrum Development, systemd development, Val Packett
In-Reply-To: <baf184f6-fefd-45ca-a437-1505533e3c81@gmail.com>
[-- Attachment #1.1.1: Type: text/plain, Size: 4667 bytes --]
On 5/23/26 17:00, Demi Marie Obenour wrote:
> On 5/8/26 06:11, Stefano Garzarella wrote:
>> On Fri, May 08, 2026 at 05:58:06AM -0400, Michael S. Tsirkin wrote:
>>> On Fri, May 08, 2026 at 11:41:21AM +0200, Stefano Garzarella wrote:
>>>> On Thu, May 07, 2026 at 06:48:47PM -0400, Michael S. Tsirkin wrote:
>>>>> On Thu, May 07, 2026 at 02:59:13PM +0200, Stefano Garzarella wrote:
>>>>>> On Thu, May 07, 2026 at 07:45:10AM -0400, Michael S. Tsirkin wrote:
>>>>>>> On Thu, May 07, 2026 at 11:09:47AM +0200, Stefano Garzarella wrote:
>>>>
>>>> [...]
>>>>
>>>>>>>> For now, we're already doing something:
>>>>>>>> merging the skuffs if they don't have EOM set.
>>>>>>>
>>>>>>>
>>>>>>> Right that's good. You could go further and merge with EOM too
>>>>>>> if you stick the info about message boundaries somewhere else.
>>>>>>
>>>>>> This adds a lot of complexity IMO, but we can try.
>>>>>>
>>>>>> Do you have something in mind?
>>>>>
>>>>> BER is clearly overkill but here's a POC that claude made for me,
>>>>> just to give u an idea. It's clearly has a ton of issues,
>>>>> for example I dislike how GFP_ATOMIC is handled.
>>>>
>>>> Okay, I somewhat understand, but clearly this isn't net material
>>>
>>> I doubt we have many other options given reverting the regression was
>>> ruled out.
>>
>> As Eric pointed out, we can't revert it.
>
> Could there be an option to disable the mitigation in guests, for the
> situation where the host is trusted? There are VMMs that implement
> AF_VSOCK in userspace with a backing AF_UNIX socket.
>
>>>> so for now
>>>> I think the best thing to do is to merge the fixup I sent (or something
>>>> similar):
>>>> https://lore.kernel.org/netdev/20260508092330.69690-1-sgarzare@redhat.com/
>>>
>>> I reviewed that one, problem is it's a spec violation/change that we'll
>>> have to support forever.
>>
>> I have a few points to make on this, but let's discuss them there.
>>
>>>
>>>> This is a major change that should be merged with more caution.
>>>> Could this have too much of an impact on performance?
>>>>
>>>> Thanks,
>>>> Stefano
>>>
>>> It's really a POC, real patch is left as an excersise for the reader
>>> :).
>>
>> eheh, I see, but honestly, this overcomplication scares me. I'll try to
>> think it over.
>>
>>> The correct approach IMHO is to only start using this
>>> when we wasted a lot of memory on small packets.
>>>
>>> For example, if sum(truesize) >= buf size.
>>>
>>> then we'll not see a perf impact unless it's already pathological.
>>
>> Agree on this, which is similar to what I'm doing in that patch.
>> Reducing the advertised buf_alloc only in pathological cases (e.g.
>> overhead > buf_alloc).
>
> This isn't enough to prevent data loss due to race conditions.
>
> I'm CCing the virtio-comment list and a few others.
>
> Right now, any application that needs to send massive amount of
> data over a vsock is simply broken. This isn't just theoretical.
> It's causing real-world problems for users of Waypipe.
> Waypipe forwards Wayland protocol messages over AF_VSOCK,
> so it can send a large amount of traffic over the socket.
> See https://gitlab.freedesktop.org/mstoceckl/waypipe/work_items/165.
>
> If one is willing to mutate the ring buffer in-place, or to maintain
> an auxiliary counter, it's possible to store all messages with bounded
> (in practice) overhead. Specifically:
>
> - If the first byte of a block of data is nonzero, it's a
> variable-length length. 1 byte for messages less than 128 bytes.
>
> - If the first byte of a block of data is zero, the subsequent bytes
> are a variable-length counter that stores the number of consecutive
> zero-byte messages.
>
> That adds a lot of complexity, which is very unfortunate for something
> that needs to be backported to stable kernels. I also suspect it
> requires all access to the ring buffer to take a lock rather than
> being lock-free. But it's the only approach that I can think of that
> can work with the current spec.
>
> Could there at least be a normative note stating that drivers and
> devices should treat each message as consuming 1024 bytes + the size
> of the message itself, and warning that anything that doesn't is
> going to be broken in practice?
>
> I'm CCing Val Packet (of Invisible Things Lab) and Alyssa Ross
> (of Spectrum) because both of them are working on systems that rely
> critically on vsock.
Update: I see that patches have been upstreamed (with CC: stable) that
reset the connection instead of data loss.
--
Sincerely,
Demi Marie Obenour (she/her/hers)
[-- Attachment #1.1.2: OpenPGP public key --]
[-- Type: application/pgp-keys, Size: 7253 bytes --]
[-- Attachment #2: OpenPGP digital signature --]
[-- Type: application/pgp-signature, Size: 833 bytes --]
^ permalink raw reply
* [syzbot] Monthly virt report (May 2026)
From: syzbot @ 2026-05-24 20:32 UTC (permalink / raw)
To: linux-kernel, syzkaller-bugs, virtualization
Hello virt maintainers/developers,
This is a 31-day syzbot report for the virt subsystem.
All related reports/information can be found at:
https://syzkaller.appspot.com/upstream/s/virt
During the period, 0 new issues were detected and 0 were fixed.
In total, 6 issues are still open and 61 have already been fixed.
There is also 1 low-priority issue.
Some of the still happening issues:
Ref Crashes Repro Title
<1> 20 No WARNING: refcount bug in call_timer_fn (4)
https://syzkaller.appspot.com/bug?extid=07dcf509f4c013e25dc5
<2> 3864 Yes INFO: rcu detected stall in do_idle
https://syzkaller.appspot.com/bug?extid=385468161961cee80c31
<3> 110 No KCSAN: data-race in virtqueue_disable_cb / virtqueue_disable_cb (5)
https://syzkaller.appspot.com/bug?extid=9d46c74b27b961b244a9
---
This report is generated by a bot. It may contain errors.
See https://goo.gl/tpsmEJ for more information about syzbot.
syzbot engineers can be reached at syzkaller@googlegroups.com.
To disable reminders for individual bugs, reply with the following command:
#syz set <Ref> no-reminders
To change bug's subsystems, reply with:
#syz set <Ref> subsystems: new-subsystem
You may send multiple commands in a single email message.
^ permalink raw reply
* Re: [PATCH net] vsock/virtio: fix potential unbounded skb queue
From: Demi Marie Obenour @ 2026-05-23 21:00 UTC (permalink / raw)
To: Stefano Garzarella, Michael S. Tsirkin
Cc: Eric Dumazet, Arseniy Krasnov, Bobby Eshleman, Stefan Hajnoczi,
David S . Miller, Jakub Kicinski, Paolo Abeni, Simon Horman,
netdev, eric.dumazet, Arseniy Krasnov, Jason Wang, Xuan Zhuo,
Eugenio Pérez, kvm, virtualization,
virtio-comment@lists.linux.dev, Manuel Stoeckl, Alyssa Ross,
Spectrum Development, systemd development, Val Packett
In-Reply-To: <af21ZGlANY6UUCKx@sgarzare-redhat>
[-- Attachment #1.1.1: Type: text/plain, Size: 4361 bytes --]
On 5/8/26 06:11, Stefano Garzarella wrote:
> On Fri, May 08, 2026 at 05:58:06AM -0400, Michael S. Tsirkin wrote:
>> On Fri, May 08, 2026 at 11:41:21AM +0200, Stefano Garzarella wrote:
>>> On Thu, May 07, 2026 at 06:48:47PM -0400, Michael S. Tsirkin wrote:
>>>> On Thu, May 07, 2026 at 02:59:13PM +0200, Stefano Garzarella wrote:
>>>>> On Thu, May 07, 2026 at 07:45:10AM -0400, Michael S. Tsirkin wrote:
>>>>>> On Thu, May 07, 2026 at 11:09:47AM +0200, Stefano Garzarella wrote:
>>>
>>> [...]
>>>
>>>>>>> For now, we're already doing something:
>>>>>>> merging the skuffs if they don't have EOM set.
>>>>>>
>>>>>>
>>>>>> Right that's good. You could go further and merge with EOM too
>>>>>> if you stick the info about message boundaries somewhere else.
>>>>>
>>>>> This adds a lot of complexity IMO, but we can try.
>>>>>
>>>>> Do you have something in mind?
>>>>
>>>> BER is clearly overkill but here's a POC that claude made for me,
>>>> just to give u an idea. It's clearly has a ton of issues,
>>>> for example I dislike how GFP_ATOMIC is handled.
>>>
>>> Okay, I somewhat understand, but clearly this isn't net material
>>
>> I doubt we have many other options given reverting the regression was
>> ruled out.
>
> As Eric pointed out, we can't revert it.
Could there be an option to disable the mitigation in guests, for the
situation where the host is trusted? There are VMMs that implement
AF_VSOCK in userspace with a backing AF_UNIX socket.
>>> so for now
>>> I think the best thing to do is to merge the fixup I sent (or something
>>> similar):
>>> https://lore.kernel.org/netdev/20260508092330.69690-1-sgarzare@redhat.com/
>>
>> I reviewed that one, problem is it's a spec violation/change that we'll
>> have to support forever.
>
> I have a few points to make on this, but let's discuss them there.
>
>>
>>> This is a major change that should be merged with more caution.
>>> Could this have too much of an impact on performance?
>>>
>>> Thanks,
>>> Stefano
>>
>> It's really a POC, real patch is left as an excersise for the reader
>> :).
>
> eheh, I see, but honestly, this overcomplication scares me. I'll try to
> think it over.
>
>> The correct approach IMHO is to only start using this
>> when we wasted a lot of memory on small packets.
>>
>> For example, if sum(truesize) >= buf size.
>>
>> then we'll not see a perf impact unless it's already pathological.
>
> Agree on this, which is similar to what I'm doing in that patch.
> Reducing the advertised buf_alloc only in pathological cases (e.g.
> overhead > buf_alloc).
This isn't enough to prevent data loss due to race conditions.
I'm CCing the virtio-comment list and a few others.
Right now, any application that needs to send massive amount of
data over a vsock is simply broken. This isn't just theoretical.
It's causing real-world problems for users of Waypipe.
Waypipe forwards Wayland protocol messages over AF_VSOCK,
so it can send a large amount of traffic over the socket.
See https://gitlab.freedesktop.org/mstoceckl/waypipe/work_items/165.
If one is willing to mutate the ring buffer in-place, or to maintain
an auxiliary counter, it's possible to store all messages with bounded
(in practice) overhead. Specifically:
- If the first byte of a block of data is nonzero, it's a
variable-length length. 1 byte for messages less than 128 bytes.
- If the first byte of a block of data is zero, the subsequent bytes
are a variable-length counter that stores the number of consecutive
zero-byte messages.
That adds a lot of complexity, which is very unfortunate for something
that needs to be backported to stable kernels. I also suspect it
requires all access to the ring buffer to take a lock rather than
being lock-free. But it's the only approach that I can think of that
can work with the current spec.
Could there at least be a normative note stating that drivers and
devices should treat each message as consuming 1024 bytes + the size
of the message itself, and warning that anything that doesn't is
going to be broken in practice?
I'm CCing Val Packet (of Invisible Things Lab) and Alyssa Ross
(of Spectrum) because both of them are working on systems that rely
critically on vsock.
--
Sincerely,
Demi Marie Obenour (she/her/hers)
[-- Attachment #1.1.2: OpenPGP public key --]
[-- Type: application/pgp-keys, Size: 7253 bytes --]
[-- Attachment #2: OpenPGP digital signature --]
[-- Type: application/pgp-signature, Size: 833 bytes --]
^ permalink raw reply
* Re: [PATCH net] vsock/virtio: fix skb overhead overflow on 32-bit builds
From: David Laight @ 2026-05-23 16:35 UTC (permalink / raw)
To: patchwork-bot+netdevbpf
Cc: Stefano Garzarella, netdev, xuanzhuo, horms, virtualization,
linux-kernel, kvm, kuba, eperezma, pabeni, mst, davem, jasowang,
stefanha, edumazet, stable
In-Reply-To: <177950282964.1445071.6600517211632117224.git-patchwork-notify@kernel.org>
On Sat, 23 May 2026 02:20:29 +0000
patchwork-bot+netdevbpf@kernel.org wrote:
> Hello:
>
> This patch was applied to netdev/net.git (main)
> by Jakub Kicinski <kuba@kernel.org>:
Did anyone else notice that is isn't a bug?
There is no way that a 'count of bytes of kernel memory' can overflow
the size of 'long'.
-- David
>
> On Thu, 21 May 2026 14:47:32 +0200 you wrote:
> > From: Stefano Garzarella <sgarzare@redhat.com>
> >
> > On 32-bit architectures, both skb_queue_len() and SKB_TRUESIZE(0) evaluate
> > to 32-bit values. The multiplication can overflow before being assigned to
> > the u64 skb_overhead variable, making the skb overhead check ineffective.
> >
> > Cast skb_queue_len() to u64 so the multiplication is always performed in
> > 64-bit arithmetic.
> >
> > [...]
>
> Here is the summary with links:
> - [net] vsock/virtio: fix skb overhead overflow on 32-bit builds
> https://git.kernel.org/netdev/net/c/4157501b9a8f
>
> You are awesome, thank you!
^ permalink raw reply
* Re: [PATCH net] vsock/virtio: fix skb overhead overflow on 32-bit builds
From: patchwork-bot+netdevbpf @ 2026-05-23 2:20 UTC (permalink / raw)
To: Stefano Garzarella
Cc: netdev, xuanzhuo, horms, virtualization, linux-kernel, kvm, kuba,
eperezma, pabeni, mst, davem, jasowang, stefanha, edumazet,
stable
In-Reply-To: <20260521124732.125771-1-sgarzare@redhat.com>
Hello:
This patch was applied to netdev/net.git (main)
by Jakub Kicinski <kuba@kernel.org>:
On Thu, 21 May 2026 14:47:32 +0200 you wrote:
> From: Stefano Garzarella <sgarzare@redhat.com>
>
> On 32-bit architectures, both skb_queue_len() and SKB_TRUESIZE(0) evaluate
> to 32-bit values. The multiplication can overflow before being assigned to
> the u64 skb_overhead variable, making the skb overhead check ineffective.
>
> Cast skb_queue_len() to u64 so the multiplication is always performed in
> 64-bit arithmetic.
>
> [...]
Here is the summary with links:
- [net] vsock/virtio: fix skb overhead overflow on 32-bit builds
https://git.kernel.org/netdev/net/c/4157501b9a8f
You are awesome, thank you!
--
Deet-doot-dot, I am a bot.
https://korg.docs.kernel.org/patchwork/pwbot.html
^ permalink raw reply
* Re: [PATCH 09/11] treewide: Convert custom kernel_param_ops .get callbacks to seq_buf via cocci
From: SeongJae Park @ 2026-05-23 0:45 UTC (permalink / raw)
To: Kees Cook
Cc: SeongJae Park, Luis Chamberlain, Pengpeng Hou, Petr Pavlu,
Richard Weinberger, Anton Ivanov, Johannes Berg,
Rafael J. Wysocki, Len Brown, Corey Minyard, Gabriel Somlo,
Michael S. Tsirkin, Jani Nikula, Joonas Lahtinen, Rodrigo Vivi,
Tvrtko Ursulin, David Airlie, Simona Vetter, Bart Van Assche,
Jason Gunthorpe, Leon Romanovsky, Laurent Pinchart, Hans de Goede,
Mauro Carvalho Chehab, Bjorn Helgaas, Hannes Reinecke,
James E.J. Bottomley, Martin K. Petersen, Daniel Lezcano,
Zhang Rui, Lukasz Luba, Greg Kroah-Hartman, Jiri Slaby,
Alan Stern, Jason Wang, Xuan Zhuo, Eugenio Pérez,
Jason Baron, Jim Cromie, Tiwei Bie, Benjamin Berg,
Ilpo Järvinen, David E. Box, Maciej W. Rozycki,
Srinivas Pandruvada, Peter Zijlstra, Heiko Carstens,
Vasily Gorbik, Sean Christopherson, Paolo Bonzini,
Thomas Gleixner, Ingo Molnar, Borislav Petkov, Dave Hansen, x86,
H. Peter Anvin, Vinod Koul, Frank Li, Daniel Gomez, Sami Tolvanen,
Aaron Tomlin, Alexander Potapenko, Marco Elver, Dmitry Vyukov,
Andrew Morton, John Johansen, Paul Moore, James Morris,
Serge E. Hallyn, Andy Shevchenko, Georgia Garcia, kvm, dmaengine,
linux-modules, kasan-dev, linux-mm, apparmor,
linux-security-module, linux-um, linux-acpi, openipmi-developer,
qemu-devel, intel-gfx, dri-devel, linux-rdma, linux-media,
linux-pci, linux-scsi, linux-pm, linuxppc-dev, linux-serial,
linux-usb, usb-storage, virtualization, linux-kernel, linux-arch,
netdev, linux-fsdevel, linux-hardening, damon
In-Reply-To: <20260521133326.2465264-9-kees@kernel.org>
+ damon@lists.linux.dev
On Thu, 21 May 2026 06:33:22 -0700 Kees Cook <kees@kernel.org> wrote:
> Using the following Coccinelle script, convert struct kernel_param_ops
> .get callbacks from "char *" to "struct seq_buf *" when the only write
> to the buffer is via a final call of scnprintf(), snprintf(), sprintf(),
> or sysfs_emit().
>
> Since seq_buf_printf() will return -1 on overflow, and struct
> kernel_param_ops .get callbacks are expected to truncate without error,
> we must ignore the return value from seq_buf_print() and always return 0
> (as the length is calculated in the common dispatcher code).
>
> @@
> identifier FN, BUF, KP;
> expression FMT;
> expression list ARGS;
> @@
> int FN(
> - char *BUF
> + struct seq_buf *BUF
> , const struct kernel_param *KP)
> {
> ... when any
> (
> - return scnprintf(BUF, PAGE_SIZE, FMT, ARGS);
> |
> - return snprintf(BUF, PAGE_SIZE, FMT, ARGS);
> |
> - return sprintf(BUF, FMT, ARGS);
> |
> - return sysfs_emit(BUF, FMT, ARGS);
> )
> + seq_buf_printf(BUF, FMT, ARGS);
> + return 0;
> }
>
> No struct kernel_param_ops initializations need changing since
> DEFINE_KERNEL_PARAM_OPS already routes the pointer to .get or .get_str
> via _Generic based on the function signature, so converted callbacks
> are automatically moved from the .get_str to the .get callback.
>
> Signed-off-by: Kees Cook <kees@kernel.org>
[...]
> mm/damon/lru_sort.c | 14 +++---
> mm/damon/reclaim.c | 14 +++---
> mm/damon/stat.c | 10 ++--
For the above DAMON changes,
Reviewed-by: SeongJae Park <sj@kernel.org>
Thanks,
SJ
[...]
^ permalink raw reply
* Re: [PATCH 04/11] treewide: Convert struct kernel_param_ops initializers to DEFINE_KERNEL_PARAM_OPS
From: SeongJae Park @ 2026-05-23 0:38 UTC (permalink / raw)
To: Kees Cook
Cc: SeongJae Park, Luis Chamberlain, Pengpeng Hou, Petr Pavlu,
Richard Weinberger, Anton Ivanov, Johannes Berg,
Rafael J. Wysocki, Len Brown, Corey Minyard, Gabriel Somlo,
Michael S. Tsirkin, Jani Nikula, Joonas Lahtinen, Rodrigo Vivi,
Tvrtko Ursulin, David Airlie, Simona Vetter, Bart Van Assche,
Jason Gunthorpe, Leon Romanovsky, Laurent Pinchart, Hans de Goede,
Mauro Carvalho Chehab, Bjorn Helgaas, Hannes Reinecke,
James E.J. Bottomley, Martin K. Petersen, Daniel Lezcano,
Zhang Rui, Lukasz Luba, Greg Kroah-Hartman, Jiri Slaby,
Alan Stern, Jason Wang, Xuan Zhuo, Eugenio Pérez,
Jason Baron, Jim Cromie, Tiwei Bie, Benjamin Berg,
Ilpo Järvinen, David E. Box, Maciej W. Rozycki,
Srinivas Pandruvada, Peter Zijlstra, Heiko Carstens,
Vasily Gorbik, Sean Christopherson, Paolo Bonzini,
Thomas Gleixner, Ingo Molnar, Borislav Petkov, Dave Hansen, x86,
H. Peter Anvin, Vinod Koul, Frank Li, Daniel Gomez, Sami Tolvanen,
Aaron Tomlin, Alexander Potapenko, Marco Elver, Dmitry Vyukov,
Andrew Morton, John Johansen, Paul Moore, James Morris,
Serge E. Hallyn, Andy Shevchenko, Georgia Garcia, kvm, dmaengine,
linux-modules, kasan-dev, linux-mm, apparmor,
linux-security-module, linux-um, linux-acpi, openipmi-developer,
qemu-devel, intel-gfx, dri-devel, linux-rdma, linux-media,
linux-pci, linux-scsi, linux-pm, linuxppc-dev, linux-serial,
linux-usb, usb-storage, virtualization, linux-kernel, linux-arch,
netdev, linux-fsdevel, linux-hardening
In-Reply-To: <20260521133326.2465264-4-kees@kernel.org>
On Thu, 21 May 2026 06:33:17 -0700 Kees Cook <kees@kernel.org> wrote:
> Using Coccinelle, rewrite every struct kernel_param_ops initializer that
> sets .get into a DEFINE_KERNEL_PARAM_OPS-family macro invocation,
> for example:
>
> @@
> declarer name DEFINE_KERNEL_PARAM_OPS;
> identifier OPS;
> expression SET, GET;
> @@
> - const struct kernel_param_ops OPS = {
> - .set = SET,
> - .get = GET,
> - };
> + DEFINE_KERNEL_PARAM_OPS(OPS, SET, GET);
>
> Using the macro for initialization means future changes can manipulate
> the struct layout and callback prototypes without having to change every
> initializer.
>
> Signed-off-by: Kees Cook <kees@kernel.org>
> ---
[...]
> mm/damon/lru_sort.c | 19 ++---
> mm/damon/reclaim.c | 19 ++---
> mm/damon/stat.c | 6 +-
[...]
> samples/damon/mtier.c | 6 +-
> samples/damon/prcl.c | 6 +-
> samples/damon/wsse.c | 6 +-
For the above DAMON part changes,
Reviewed-by: SeongJae Park <sj@kernel.org>
Thanks,
SJ
[...]
^ permalink raw reply
* Re: [PATCH net v2] vsock: keep poll shutdown state consistent
From: patchwork-bot+netdevbpf @ 2026-05-22 18:30 UTC (permalink / raw)
To: Ziyu Zhang
Cc: sgarzare, davem, edumazet, kuba, pabeni, horms, acking,
georgezhang, dtor, kys, haiyangz, wei.liu, decui, longli,
stefanha, mst, jasowang, xuanzhuo, eperezma, bryan-bt.tan,
vishnu.dasa, bcm-kernel-feedback-list, virtualization, netdev,
linux-kernel, linux-hyperv, kvm, baijiaju1990, r33s3n6, gality369,
zhenghaoran154, hanguidong02, zzzccc427
In-Reply-To: <20260519165636.62542-1-ziyuzhang201@gmail.com>
Hello:
This patch was applied to netdev/net.git (main)
by Jakub Kicinski <kuba@kernel.org>:
On Wed, 20 May 2026 00:56:36 +0800 you wrote:
> vsock_poll() reads vsk->peer_shutdown before taking the socket lock
> to set EPOLLHUP and EPOLLRDHUP, then reads it again after taking
> the lock to report EOF readability. A shutdown packet can update
> peer_shutdown while poll is waiting for the lock, so one poll invocation
> can report EOF readability without the corresponding HUP/RDHUP bits.
>
> For connectible sockets, take one peer_shutdown snapshot after
> lock_sock() and use it for all peer-shutdown-derived poll bits. For
> datagram sockets, which do not take lock_sock() in poll(), take one
> lockless READ_ONCE() snapshot and pair it with WRITE_ONCE() on the
> writer side.
>
> [...]
Here is the summary with links:
- [net,v2] vsock: keep poll shutdown state consistent
https://git.kernel.org/netdev/net/c/aae9d8a5528b
You are awesome, thank you!
--
Deet-doot-dot, I am a bot.
https://korg.docs.kernel.org/patchwork/pwbot.html
^ permalink raw reply
* Re: [PATCH 10/11] treewide: Manually convert custom kernel_param_ops .get callbacks
From: Rafael J. Wysocki @ 2026-05-22 17:05 UTC (permalink / raw)
To: Kees Cook
Cc: Luis Chamberlain, Pengpeng Hou, Petr Pavlu, Richard Weinberger,
Anton Ivanov, Johannes Berg, Rafael J. Wysocki, Len Brown,
Corey Minyard, Gabriel Somlo, Michael S. Tsirkin, Jani Nikula,
Joonas Lahtinen, Rodrigo Vivi, Tvrtko Ursulin, David Airlie,
Simona Vetter, Bart Van Assche, Jason Gunthorpe, Leon Romanovsky,
Laurent Pinchart, Hans de Goede, Mauro Carvalho Chehab,
Bjorn Helgaas, Hannes Reinecke, James E.J. Bottomley,
Martin K. Petersen, Daniel Lezcano, Zhang Rui, Lukasz Luba,
Greg Kroah-Hartman, Jiri Slaby, Alan Stern, Jason Wang, Xuan Zhuo,
Eugenio Pérez, Jason Baron, Jim Cromie, Tiwei Bie,
Benjamin Berg, Ilpo Järvinen, David E. Box,
Maciej W. Rozycki, Srinivas Pandruvada, Peter Zijlstra,
Heiko Carstens, Vasily Gorbik, Sean Christopherson, Paolo Bonzini,
Thomas Gleixner, Ingo Molnar, Borislav Petkov, Dave Hansen, x86,
H. Peter Anvin, Vinod Koul, Frank Li, Daniel Gomez, Sami Tolvanen,
Aaron Tomlin, Alexander Potapenko, Marco Elver, Dmitry Vyukov,
Andrew Morton, John Johansen, Paul Moore, James Morris,
Serge E. Hallyn, Andy Shevchenko, Georgia Garcia, kvm, dmaengine,
linux-modules, kasan-dev, linux-mm, apparmor,
linux-security-module, linux-um, linux-acpi, openipmi-developer,
qemu-devel, intel-gfx, dri-devel, linux-rdma, linux-media,
linux-pci, linux-scsi, linux-pm, linuxppc-dev, linux-serial,
linux-usb, usb-storage, virtualization, linux-kernel, linux-arch,
netdev, linux-fsdevel, linux-hardening
In-Reply-To: <20260521133326.2465264-10-kees@kernel.org>
On Thu, May 21, 2026 at 3:33 PM Kees Cook <kees@kernel.org> wrote:
>
> Convert struct kernel_param_ops .get callbacks from legacy "char *" to
> "struct seq_buf *".
>
> Since seq_buf_printf() will return -1 on overflow, and struct
> kernel_param_ops .get callbacks are expected to truncate without error,
> we must ignore the return value from seq_buf_print() and always return 0
> (as the length is calculated in the common dispatcher code).
>
> No struct kernel_param_ops initializations need changing since
> DEFINE_KERNEL_PARAM_OPS already routes the pointer to .get or .get_str
> via _Generic based on the function signature, so converted callbacks
> are automatically moved from the .get_str to the .get callback.
>
> Signed-off-by: Kees Cook <kees@kernel.org>
For ACPI:
Acked-by: Rafael J. Wysocki (Intel) <rafael@kernel.org>
> ---
> include/linux/dynamic_debug.h | 8 ++-
> arch/um/drivers/vfio_kern.c | 3 +-
> arch/um/drivers/virtio_uml.c | 12 ++--
> drivers/acpi/button.c | 19 ++++--
> drivers/acpi/sysfs.c | 83 +++++++++++-------------
> drivers/char/ipmi/ipmi_watchdog.c | 33 ++++------
> drivers/firmware/qemu_fw_cfg.c | 34 +++++-----
> drivers/gpu/drm/i915/i915_mitigations.c | 26 ++++----
> drivers/infiniband/ulp/srp/ib_srp.c | 7 +-
> drivers/media/usb/uvc/uvc_driver.c | 8 ++-
> drivers/pci/pcie/aspm.c | 17 +++--
> drivers/scsi/fcoe/fcoe_transport.c | 22 +++----
> drivers/thermal/intel/intel_powerclamp.c | 14 ++--
> drivers/tty/hvc/hvc_iucv.c | 18 ++---
> drivers/usb/storage/usb.c | 20 +++---
> drivers/virtio/virtio_mmio.c | 21 +++---
> lib/dynamic_debug.c | 10 ++-
> 17 files changed, 178 insertions(+), 177 deletions(-)
>
> diff --git a/include/linux/dynamic_debug.h b/include/linux/dynamic_debug.h
> index 05743900a116..999a25671b6a 100644
> --- a/include/linux/dynamic_debug.h
> +++ b/include/linux/dynamic_debug.h
> @@ -334,8 +334,10 @@ void __dynamic_ibdev_dbg(struct _ddebug *descriptor,
> extern int ddebug_dyndbg_module_param_cb(char *param, char *val,
> const char *modname);
> struct kernel_param;
> +struct seq_buf;
> int param_set_dyndbg_classes(const char *instr, const struct kernel_param *kp);
> -int param_get_dyndbg_classes(char *buffer, const struct kernel_param *kp);
> +int param_get_dyndbg_classes(struct seq_buf *buffer,
> + const struct kernel_param *kp);
>
> #else
>
> @@ -352,9 +354,11 @@ static inline int ddebug_dyndbg_module_param_cb(char *param, char *val,
> }
>
> struct kernel_param;
> +struct seq_buf;
> static inline int param_set_dyndbg_classes(const char *instr, const struct kernel_param *kp)
> { return 0; }
> -static inline int param_get_dyndbg_classes(char *buffer, const struct kernel_param *kp)
> +static inline int param_get_dyndbg_classes(struct seq_buf *buffer,
> + const struct kernel_param *kp)
> { return 0; }
>
> #endif
> diff --git a/arch/um/drivers/vfio_kern.c b/arch/um/drivers/vfio_kern.c
> index fb7988dc5482..7c1119d0d9c1 100644
> --- a/arch/um/drivers/vfio_kern.c
> +++ b/arch/um/drivers/vfio_kern.c
> @@ -623,7 +623,8 @@ static int uml_vfio_cmdline_set(const char *device, const struct kernel_param *k
> return 0;
> }
>
> -static int uml_vfio_cmdline_get(char *buffer, const struct kernel_param *kp)
> +static int uml_vfio_cmdline_get(struct seq_buf *buffer,
> + const struct kernel_param *kp)
> {
> return 0;
> }
> diff --git a/arch/um/drivers/virtio_uml.c b/arch/um/drivers/virtio_uml.c
> index f9ae745f4586..cea806540625 100644
> --- a/arch/um/drivers/virtio_uml.c
> +++ b/arch/um/drivers/virtio_uml.c
> @@ -1379,23 +1379,21 @@ static int vu_cmdline_get_device(struct device *dev, void *data)
> {
> struct platform_device *pdev = to_platform_device(dev);
> struct virtio_uml_platform_data *pdata = pdev->dev.platform_data;
> - char *buffer = data;
> - unsigned int len = strlen(buffer);
> + struct seq_buf *s = data;
>
> - snprintf(buffer + len, PAGE_SIZE - len, "%s:%d:%d\n",
> - pdata->socket_path, pdata->virtio_device_id, pdev->id);
> + seq_buf_printf(s, "%s:%d:%d\n",
> + pdata->socket_path, pdata->virtio_device_id, pdev->id);
> return 0;
> }
>
> -static int vu_cmdline_get(char *buffer, const struct kernel_param *kp)
> +static int vu_cmdline_get(struct seq_buf *buffer, const struct kernel_param *kp)
> {
> guard(mutex)(&vu_cmdline_lock);
>
> - buffer[0] = '\0';
> if (vu_cmdline_parent_registered)
> device_for_each_child(&vu_cmdline_parent, buffer,
> vu_cmdline_get_device);
> - return strlen(buffer) + 1;
> + return 0;
> }
>
> static DEFINE_KERNEL_PARAM_OPS(vu_cmdline_param_ops, vu_cmdline_set,
> diff --git a/drivers/acpi/button.c b/drivers/acpi/button.c
> index dc064a388c23..31c624bebc65 100644
> --- a/drivers/acpi/button.c
> +++ b/drivers/acpi/button.c
> @@ -715,19 +715,24 @@ static int param_set_lid_init_state(const char *val,
> return 0;
> }
>
> -static int param_get_lid_init_state(char *buf, const struct kernel_param *kp)
> +static int param_get_lid_init_state(struct seq_buf *buf,
> + const struct kernel_param *kp)
> {
> - int i, c = 0;
> + int i;
>
> - for (i = 0; i < ARRAY_SIZE(lid_init_state_str); i++)
> + for (i = 0; i < ARRAY_SIZE(lid_init_state_str); i++) {
> if (i == lid_init_state)
> - c += sprintf(buf + c, "[%s] ", lid_init_state_str[i]);
> + seq_buf_printf(buf, "[%s] ", lid_init_state_str[i]);
> else
> - c += sprintf(buf + c, "%s ", lid_init_state_str[i]);
> + seq_buf_printf(buf, "%s ", lid_init_state_str[i]);
> + }
>
> - buf[c - 1] = '\n'; /* Replace the final space with a newline */
> + /* Replace the final space with a newline. */
> + if (!seq_buf_has_overflowed(buf) && buf->len > 0 &&
> + buf->buffer[buf->len - 1] == ' ')
> + buf->buffer[buf->len - 1] = '\n';
>
> - return c;
> + return 0;
> }
>
> module_param_call(lid_init_state,
> diff --git a/drivers/acpi/sysfs.c b/drivers/acpi/sysfs.c
> index 5247ed7e05cc..dff7cc7da8bf 100644
> --- a/drivers/acpi/sysfs.c
> +++ b/drivers/acpi/sysfs.c
> @@ -89,53 +89,49 @@ static const struct acpi_dlevel acpi_debug_levels[] = {
> ACPI_DEBUG_INIT(ACPI_LV_EVENTS),
> };
>
> -static int param_get_debug_layer(char *buffer, const struct kernel_param *kp)
> +static int param_get_debug_layer(struct seq_buf *buffer,
> + const struct kernel_param *kp)
> {
> - int result = 0;
> int i;
>
> - result = sprintf(buffer, "%-25s\tHex SET\n", "Description");
> + seq_buf_printf(buffer, "%-25s\tHex SET\n", "Description");
>
> for (i = 0; i < ARRAY_SIZE(acpi_debug_layers); i++) {
> - result += sprintf(buffer + result, "%-25s\t0x%08lX [%c]\n",
> - acpi_debug_layers[i].name,
> - acpi_debug_layers[i].value,
> - (acpi_dbg_layer & acpi_debug_layers[i].value)
> - ? '*' : ' ');
> + seq_buf_printf(buffer, "%-25s\t0x%08lX [%c]\n",
> + acpi_debug_layers[i].name,
> + acpi_debug_layers[i].value,
> + (acpi_dbg_layer & acpi_debug_layers[i].value)
> + ? '*' : ' ');
> }
> - result +=
> - sprintf(buffer + result, "%-25s\t0x%08X [%c]\n", "ACPI_ALL_DRIVERS",
> - ACPI_ALL_DRIVERS,
> - (acpi_dbg_layer & ACPI_ALL_DRIVERS) ==
> - ACPI_ALL_DRIVERS ? '*' : (acpi_dbg_layer & ACPI_ALL_DRIVERS)
> - == 0 ? ' ' : '-');
> - result +=
> - sprintf(buffer + result,
> - "--\ndebug_layer = 0x%08X ( * = enabled)\n",
> - acpi_dbg_layer);
> + seq_buf_printf(buffer, "%-25s\t0x%08X [%c]\n", "ACPI_ALL_DRIVERS",
> + ACPI_ALL_DRIVERS,
> + (acpi_dbg_layer & ACPI_ALL_DRIVERS) == ACPI_ALL_DRIVERS
> + ? '*' : (acpi_dbg_layer & ACPI_ALL_DRIVERS) == 0
> + ? ' ' : '-');
> + seq_buf_printf(buffer, "--\ndebug_layer = 0x%08X ( * = enabled)\n",
> + acpi_dbg_layer);
>
> - return result;
> + return 0;
> }
>
> -static int param_get_debug_level(char *buffer, const struct kernel_param *kp)
> +static int param_get_debug_level(struct seq_buf *buffer,
> + const struct kernel_param *kp)
> {
> - int result = 0;
> int i;
>
> - result = sprintf(buffer, "%-25s\tHex SET\n", "Description");
> + seq_buf_printf(buffer, "%-25s\tHex SET\n", "Description");
>
> for (i = 0; i < ARRAY_SIZE(acpi_debug_levels); i++) {
> - result += sprintf(buffer + result, "%-25s\t0x%08lX [%c]\n",
> - acpi_debug_levels[i].name,
> - acpi_debug_levels[i].value,
> - (acpi_dbg_level & acpi_debug_levels[i].value)
> - ? '*' : ' ');
> + seq_buf_printf(buffer, "%-25s\t0x%08lX [%c]\n",
> + acpi_debug_levels[i].name,
> + acpi_debug_levels[i].value,
> + (acpi_dbg_level & acpi_debug_levels[i].value)
> + ? '*' : ' ');
> }
> - result +=
> - sprintf(buffer + result, "--\ndebug_level = 0x%08X (* = enabled)\n",
> - acpi_dbg_level);
> + seq_buf_printf(buffer, "--\ndebug_level = 0x%08X (* = enabled)\n",
> + acpi_dbg_level);
>
> - return result;
> + return 0;
> }
>
> static DEFINE_KERNEL_PARAM_OPS(param_ops_debug_layer, param_set_uint,
> @@ -247,16 +243,18 @@ static int param_set_trace_state(const char *val,
> return 0;
> }
>
> -static int param_get_trace_state(char *buffer, const struct kernel_param *kp)
> +static int param_get_trace_state(struct seq_buf *buffer,
> + const struct kernel_param *kp)
> {
> if (!(acpi_gbl_trace_flags & ACPI_TRACE_ENABLED))
> - return sprintf(buffer, "disable\n");
> - if (!acpi_gbl_trace_method_name)
> - return sprintf(buffer, "enable\n");
> - if (acpi_gbl_trace_flags & ACPI_TRACE_ONESHOT)
> - return sprintf(buffer, "method-once\n");
> + seq_buf_printf(buffer, "disable\n");
> + else if (!acpi_gbl_trace_method_name)
> + seq_buf_printf(buffer, "enable\n");
> + else if (acpi_gbl_trace_flags & ACPI_TRACE_ONESHOT)
> + seq_buf_printf(buffer, "method-once\n");
> else
> - return sprintf(buffer, "method\n");
> + seq_buf_printf(buffer, "method\n");
> + return 0;
> }
>
> module_param_call(trace_state, param_set_trace_state, param_get_trace_state,
> @@ -272,14 +270,11 @@ MODULE_PARM_DESC(aml_debug_output,
> "To enable/disable the ACPI Debug Object output.");
>
> /* /sys/module/acpi/parameters/acpica_version */
> -static int param_get_acpica_version(char *buffer,
> +static int param_get_acpica_version(struct seq_buf *buffer,
> const struct kernel_param *kp)
> {
> - int result;
> -
> - result = sprintf(buffer, "%x\n", ACPI_CA_VERSION);
> -
> - return result;
> + seq_buf_printf(buffer, "%x\n", ACPI_CA_VERSION);
> + return 0;
> }
>
> module_param_call(acpica_version, NULL, param_get_acpica_version, NULL, 0444);
> diff --git a/drivers/char/ipmi/ipmi_watchdog.c b/drivers/char/ipmi/ipmi_watchdog.c
> index 91a99417d204..2bfec85ef331 100644
> --- a/drivers/char/ipmi/ipmi_watchdog.c
> +++ b/drivers/char/ipmi/ipmi_watchdog.c
> @@ -197,11 +197,11 @@ static DEFINE_KERNEL_PARAM_OPS(param_ops_timeout, set_param_timeout,
> param_get_int);
> #define param_check_timeout param_check_int
>
> -typedef int (*action_fn)(const char *intval, char *outval);
> +typedef int (*action_fn)(const char *intval, struct seq_buf *outval);
>
> -static int action_op(const char *inval, char *outval);
> -static int preaction_op(const char *inval, char *outval);
> -static int preop_op(const char *inval, char *outval);
> +static int action_op(const char *inval, struct seq_buf *outval);
> +static int preaction_op(const char *inval, struct seq_buf *outval);
> +static int preop_op(const char *inval, struct seq_buf *outval);
> static void check_parms(void);
>
> static int set_param_str(const char *val, const struct kernel_param *kp)
> @@ -227,20 +227,11 @@ static int set_param_str(const char *val, const struct kernel_param *kp)
> return rv;
> }
>
> -static int get_param_str(char *buffer, const struct kernel_param *kp)
> +static int get_param_str(struct seq_buf *buffer, const struct kernel_param *kp)
> {
> action_fn fn = (action_fn) kp->arg;
> - int rv, len;
>
> - rv = fn(NULL, buffer);
> - if (rv)
> - return rv;
> -
> - len = strlen(buffer);
> - buffer[len++] = '\n';
> - buffer[len] = 0;
> -
> - return len;
> + return fn(NULL, buffer);
> }
>
>
> @@ -1154,12 +1145,12 @@ static int action_op_set_val(const char *inval)
> return 0;
> }
>
> -static int action_op(const char *inval, char *outval)
> +static int action_op(const char *inval, struct seq_buf *outval)
> {
> int rv;
>
> if (outval)
> - strcpy(outval, action);
> + seq_buf_printf(outval, "%s\n", action);
>
> if (!inval)
> return 0;
> @@ -1186,12 +1177,12 @@ static int preaction_op_set_val(const char *inval)
> return 0;
> }
>
> -static int preaction_op(const char *inval, char *outval)
> +static int preaction_op(const char *inval, struct seq_buf *outval)
> {
> int rv;
>
> if (outval)
> - strcpy(outval, preaction);
> + seq_buf_printf(outval, "%s\n", preaction);
>
> if (!inval)
> return 0;
> @@ -1214,12 +1205,12 @@ static int preop_op_set_val(const char *inval)
> return 0;
> }
>
> -static int preop_op(const char *inval, char *outval)
> +static int preop_op(const char *inval, struct seq_buf *outval)
> {
> int rv;
>
> if (outval)
> - strcpy(outval, preop);
> + seq_buf_printf(outval, "%s\n", preop);
>
> if (!inval)
> return 0;
> diff --git a/drivers/firmware/qemu_fw_cfg.c b/drivers/firmware/qemu_fw_cfg.c
> index c87a5449ba8c..4ebc1e327849 100644
> --- a/drivers/firmware/qemu_fw_cfg.c
> +++ b/drivers/firmware/qemu_fw_cfg.c
> @@ -860,7 +860,8 @@ static int fw_cfg_cmdline_set(const char *arg, const struct kernel_param *kp)
> return PTR_ERR_OR_ZERO(fw_cfg_cmdline_dev);
> }
>
> -static int fw_cfg_cmdline_get(char *buf, const struct kernel_param *kp)
> +static int fw_cfg_cmdline_get(struct seq_buf *buf,
> + const struct kernel_param *kp)
> {
> /* stay silent if device was not configured via the command
> * line, or if the parameter name (ioport/mmio) doesn't match
> @@ -873,22 +874,25 @@ static int fw_cfg_cmdline_get(char *buf, const struct kernel_param *kp)
>
> switch (fw_cfg_cmdline_dev->num_resources) {
> case 1:
> - return snprintf(buf, PAGE_SIZE, PH_ADDR_PR_1_FMT,
> - resource_size(&fw_cfg_cmdline_dev->resource[0]),
> - fw_cfg_cmdline_dev->resource[0].start);
> + seq_buf_printf(buf, PH_ADDR_PR_1_FMT,
> + resource_size(&fw_cfg_cmdline_dev->resource[0]),
> + fw_cfg_cmdline_dev->resource[0].start);
> + return 0;
> case 3:
> - return snprintf(buf, PAGE_SIZE, PH_ADDR_PR_3_FMT,
> - resource_size(&fw_cfg_cmdline_dev->resource[0]),
> - fw_cfg_cmdline_dev->resource[0].start,
> - fw_cfg_cmdline_dev->resource[1].start,
> - fw_cfg_cmdline_dev->resource[2].start);
> + seq_buf_printf(buf, PH_ADDR_PR_3_FMT,
> + resource_size(&fw_cfg_cmdline_dev->resource[0]),
> + fw_cfg_cmdline_dev->resource[0].start,
> + fw_cfg_cmdline_dev->resource[1].start,
> + fw_cfg_cmdline_dev->resource[2].start);
> + return 0;
> case 4:
> - return snprintf(buf, PAGE_SIZE, PH_ADDR_PR_4_FMT,
> - resource_size(&fw_cfg_cmdline_dev->resource[0]),
> - fw_cfg_cmdline_dev->resource[0].start,
> - fw_cfg_cmdline_dev->resource[1].start,
> - fw_cfg_cmdline_dev->resource[2].start,
> - fw_cfg_cmdline_dev->resource[3].start);
> + seq_buf_printf(buf, PH_ADDR_PR_4_FMT,
> + resource_size(&fw_cfg_cmdline_dev->resource[0]),
> + fw_cfg_cmdline_dev->resource[0].start,
> + fw_cfg_cmdline_dev->resource[1].start,
> + fw_cfg_cmdline_dev->resource[2].start,
> + fw_cfg_cmdline_dev->resource[3].start);
> + return 0;
> }
>
> /* Should never get here */
> diff --git a/drivers/gpu/drm/i915/i915_mitigations.c b/drivers/gpu/drm/i915/i915_mitigations.c
> index 6061eae84e9c..99cb38f355b6 100644
> --- a/drivers/gpu/drm/i915/i915_mitigations.c
> +++ b/drivers/gpu/drm/i915/i915_mitigations.c
> @@ -95,33 +95,37 @@ static int mitigations_set(const char *val, const struct kernel_param *kp)
> return 0;
> }
>
> -static int mitigations_get(char *buffer, const struct kernel_param *kp)
> +static int mitigations_get(struct seq_buf *buffer,
> + const struct kernel_param *kp)
> {
> unsigned long local = READ_ONCE(mitigations);
> - int count, i;
> bool enable;
> + int i;
>
> - if (!local)
> - return scnprintf(buffer, PAGE_SIZE, "%s\n", "off");
> + if (!local) {
> + seq_buf_printf(buffer, "%s\n", "off");
> + return 0;
> + }
>
> if (local & BIT(BITS_PER_LONG - 1)) {
> - count = scnprintf(buffer, PAGE_SIZE, "%s,", "auto");
> + seq_buf_printf(buffer, "%s,", "auto");
> enable = false;
> } else {
> enable = true;
> - count = 0;
> }
>
> for (i = 0; i < ARRAY_SIZE(names); i++) {
> if ((local & BIT(i)) != enable)
> continue;
> -
> - count += scnprintf(buffer + count, PAGE_SIZE - count,
> - "%s%s,", enable ? "" : "!", names[i]);
> + seq_buf_printf(buffer, "%s%s,", enable ? "" : "!", names[i]);
> }
>
> - buffer[count - 1] = '\n';
> - return count;
> + /* Replace the trailing comma with a newline. */
> + if (!seq_buf_has_overflowed(buffer) && buffer->len > 0 &&
> + buffer->buffer[buffer->len - 1] == ',')
> + buffer->buffer[buffer->len - 1] = '\n';
> +
> + return 0;
> }
>
> static DEFINE_KERNEL_PARAM_OPS(ops, mitigations_set, mitigations_get);
> diff --git a/drivers/infiniband/ulp/srp/ib_srp.c b/drivers/infiniband/ulp/srp/ib_srp.c
> index a81515f52a4f..4f53e939eec1 100644
> --- a/drivers/infiniband/ulp/srp/ib_srp.c
> +++ b/drivers/infiniband/ulp/srp/ib_srp.c
> @@ -161,14 +161,15 @@ static struct ib_client srp_client = {
>
> static struct ib_sa_client srp_sa_client;
>
> -static int srp_tmo_get(char *buffer, const struct kernel_param *kp)
> +static int srp_tmo_get(struct seq_buf *buffer, const struct kernel_param *kp)
> {
> int tmo = *(int *)kp->arg;
>
> if (tmo >= 0)
> - return sysfs_emit(buffer, "%d\n", tmo);
> + seq_buf_printf(buffer, "%d\n", tmo);
> else
> - return sysfs_emit(buffer, "off\n");
> + seq_buf_printf(buffer, "off\n");
> + return 0;
> }
>
> static int srp_tmo_set(const char *val, const struct kernel_param *kp)
> diff --git a/drivers/media/usb/uvc/uvc_driver.c b/drivers/media/usb/uvc/uvc_driver.c
> index 2338cab7fef9..1c5c40ce852d 100644
> --- a/drivers/media/usb/uvc/uvc_driver.c
> +++ b/drivers/media/usb/uvc/uvc_driver.c
> @@ -2451,12 +2451,14 @@ static int uvc_reset_resume(struct usb_interface *intf)
> * Module parameters
> */
>
> -static int uvc_clock_param_get(char *buffer, const struct kernel_param *kp)
> +static int uvc_clock_param_get(struct seq_buf *buffer,
> + const struct kernel_param *kp)
> {
> if (uvc_clock_param == CLOCK_MONOTONIC)
> - return sprintf(buffer, "CLOCK_MONOTONIC");
> + seq_buf_printf(buffer, "CLOCK_MONOTONIC");
> else
> - return sprintf(buffer, "CLOCK_REALTIME");
> + seq_buf_printf(buffer, "CLOCK_REALTIME");
> + return 0;
> }
>
> static int uvc_clock_param_set(const char *val, const struct kernel_param *kp)
> diff --git a/drivers/pci/pcie/aspm.c b/drivers/pci/pcie/aspm.c
> index 925373b98dff..af2dd668fe4d 100644
> --- a/drivers/pci/pcie/aspm.c
> +++ b/drivers/pci/pcie/aspm.c
> @@ -1572,16 +1572,19 @@ static int pcie_aspm_set_policy(const char *val,
> return 0;
> }
>
> -static int pcie_aspm_get_policy(char *buffer, const struct kernel_param *kp)
> +static int pcie_aspm_get_policy(struct seq_buf *buffer,
> + const struct kernel_param *kp)
> {
> - int i, cnt = 0;
> - for (i = 0; i < ARRAY_SIZE(policy_str); i++)
> + int i;
> +
> + for (i = 0; i < ARRAY_SIZE(policy_str); i++) {
> if (i == aspm_policy)
> - cnt += sprintf(buffer + cnt, "[%s] ", policy_str[i]);
> + seq_buf_printf(buffer, "[%s] ", policy_str[i]);
> else
> - cnt += sprintf(buffer + cnt, "%s ", policy_str[i]);
> - cnt += sprintf(buffer + cnt, "\n");
> - return cnt;
> + seq_buf_printf(buffer, "%s ", policy_str[i]);
> + }
> + seq_buf_putc(buffer, '\n');
> + return 0;
> }
>
> module_param_call(policy, pcie_aspm_set_policy, pcie_aspm_get_policy,
> diff --git a/drivers/scsi/fcoe/fcoe_transport.c b/drivers/scsi/fcoe/fcoe_transport.c
> index 88d85fc9a52a..aa10514ec46e 100644
> --- a/drivers/scsi/fcoe/fcoe_transport.c
> +++ b/drivers/scsi/fcoe/fcoe_transport.c
> @@ -23,7 +23,8 @@ MODULE_LICENSE("GPL v2");
>
> static int fcoe_transport_create(const char *, const struct kernel_param *);
> static int fcoe_transport_destroy(const char *, const struct kernel_param *);
> -static int fcoe_transport_show(char *buffer, const struct kernel_param *kp);
> +static int fcoe_transport_show(struct seq_buf *buffer,
> + const struct kernel_param *kp);
> static struct fcoe_transport *fcoe_transport_lookup(struct net_device *device);
> static struct fcoe_transport *fcoe_netdev_map_lookup(struct net_device *device);
> static int fcoe_transport_enable(const char *, const struct kernel_param *);
> @@ -595,22 +596,21 @@ int fcoe_transport_detach(struct fcoe_transport *ft)
> }
> EXPORT_SYMBOL(fcoe_transport_detach);
>
> -static int fcoe_transport_show(char *buffer, const struct kernel_param *kp)
> +static int fcoe_transport_show(struct seq_buf *buffer,
> + const struct kernel_param *kp)
> {
> - int i, j;
> struct fcoe_transport *ft = NULL;
>
> - i = j = sprintf(buffer, "Attached FCoE transports:");
> + seq_buf_printf(buffer, "Attached FCoE transports:");
> mutex_lock(&ft_mutex);
> - list_for_each_entry(ft, &fcoe_transports, list) {
> - if (i >= PAGE_SIZE - IFNAMSIZ)
> - break;
> - i += snprintf(&buffer[i], IFNAMSIZ, "%s ", ft->name);
> + if (list_empty(&fcoe_transports)) {
> + seq_buf_printf(buffer, "none");
> + } else {
> + list_for_each_entry(ft, &fcoe_transports, list)
> + seq_buf_printf(buffer, "%s ", ft->name);
> }
> mutex_unlock(&ft_mutex);
> - if (i == j)
> - i += snprintf(&buffer[i], IFNAMSIZ, "none");
> - return i;
> + return 0;
> }
>
> static int __init fcoe_transport_init(void)
> diff --git a/drivers/thermal/intel/intel_powerclamp.c b/drivers/thermal/intel/intel_powerclamp.c
> index 98fbc6892714..50ec1a0ff1ab 100644
> --- a/drivers/thermal/intel/intel_powerclamp.c
> +++ b/drivers/thermal/intel/intel_powerclamp.c
> @@ -101,15 +101,13 @@ static int duration_set(const char *arg, const struct kernel_param *kp)
> return ret;
> }
>
> -static int duration_get(char *buf, const struct kernel_param *kp)
> +static int duration_get(struct seq_buf *buf, const struct kernel_param *kp)
> {
> - int ret;
> -
> mutex_lock(&powerclamp_lock);
> - ret = sysfs_emit(buf, "%d\n", duration / 1000);
> + seq_buf_printf(buf, "%d\n", duration / 1000);
> mutex_unlock(&powerclamp_lock);
>
> - return ret;
> + return 0;
> }
>
> static DEFINE_KERNEL_PARAM_OPS(duration_ops, duration_set, duration_get);
> @@ -192,12 +190,14 @@ static int cpumask_set(const char *arg, const struct kernel_param *kp)
> return ret;
> }
>
> -static int cpumask_get(char *buf, const struct kernel_param *kp)
> +static int cpumask_get(struct seq_buf *buf, const struct kernel_param *kp)
> {
> if (!cpumask_available(idle_injection_cpu_mask))
> return -ENODEV;
>
> - return cpumap_print_to_pagebuf(false, buf, idle_injection_cpu_mask);
> + seq_buf_printf(buf, "%*pb\n", nr_cpu_ids,
> + cpumask_bits(idle_injection_cpu_mask));
> + return 0;
> }
>
> static DEFINE_KERNEL_PARAM_OPS(cpumask_ops, cpumask_set, cpumask_get);
> diff --git a/drivers/tty/hvc/hvc_iucv.c b/drivers/tty/hvc/hvc_iucv.c
> index 29612a4a32cb..b27c1dfbd249 100644
> --- a/drivers/tty/hvc/hvc_iucv.c
> +++ b/drivers/tty/hvc/hvc_iucv.c
> @@ -1256,36 +1256,32 @@ static int param_set_vmidfilter(const char *val, const struct kernel_param *kp)
>
> /**
> * param_get_vmidfilter() - Get z/VM user ID filter
> - * @buffer: Buffer to store z/VM user ID filter,
> - * (buffer size assumption PAGE_SIZE)
> + * @buffer: seq_buf to store z/VM user ID filter
> * @kp: Kernel parameter pointing to the hvc_iucv_filter array
> *
> * The function stores the filter as a comma-separated list of z/VM user IDs
> * in @buffer. Typically, sysfs routines call this function for attr show.
> */
> -static int param_get_vmidfilter(char *buffer, const struct kernel_param *kp)
> +static int param_get_vmidfilter(struct seq_buf *buffer,
> + const struct kernel_param *kp)
> {
> - int rc;
> size_t index, len;
> void *start, *end;
>
> if (!machine_is_vm() || !hvc_iucv_devices)
> return -ENODEV;
>
> - rc = 0;
> read_lock_bh(&hvc_iucv_filter_lock);
> for (index = 0; index < hvc_iucv_filter_size; index++) {
> start = hvc_iucv_filter + (8 * index);
> end = memchr(start, ' ', 8);
> len = (end) ? end - start : 8;
> - memcpy(buffer + rc, start, len);
> - rc += len;
> - buffer[rc++] = ',';
> + if (index)
> + seq_buf_putc(buffer, ',');
> + seq_buf_printf(buffer, "%.*s", (int)len, (char *)start);
> }
> read_unlock_bh(&hvc_iucv_filter_lock);
> - if (rc)
> - buffer[--rc] = '\0'; /* replace last comma and update rc */
> - return rc;
> + return 0;
> }
>
> #define param_check_vmidfilter(name, p) __param_check(name, p, void)
> diff --git a/drivers/usb/storage/usb.c b/drivers/usb/storage/usb.c
> index 71dd623b95c9..637e1b8f622f 100644
> --- a/drivers/usb/storage/usb.c
> +++ b/drivers/usb/storage/usb.c
> @@ -115,27 +115,22 @@ static int parse_delay_str(const char *str, int ndecimals, const char *suffix,
> * @val: The integer value to format, scaled by 10^(@ndecimals).
> * @ndecimals: Number of decimal to scale down.
> * @suffix: Suffix string to format.
> - * @str: Where to store the formatted string.
> - * @size: The size of buffer for @str.
> + * @s: Where to store the formatted string.
> *
> * Format an integer value in @val scale down by 10^(@ndecimals) without @suffix
> * if @val is divisible by 10^(@ndecimals).
> * Otherwise format a value in @val just as it is with @suffix
> - *
> - * Returns the number of characters written into @str.
> */
> -static int format_delay_ms(unsigned int val, int ndecimals, const char *suffix,
> - char *str, int size)
> +static void format_delay_ms(unsigned int val, int ndecimals, const char *suffix,
> + struct seq_buf *s)
> {
> u64 delay_ms = val;
> unsigned int rem = do_div(delay_ms, int_pow(10, ndecimals));
> - int ret;
>
> if (rem)
> - ret = scnprintf(str, size, "%u%s\n", val, suffix);
> + seq_buf_printf(s, "%u%s\n", val, suffix);
> else
> - ret = scnprintf(str, size, "%u\n", (unsigned int)delay_ms);
> - return ret;
> + seq_buf_printf(s, "%u\n", (unsigned int)delay_ms);
> }
>
> static int delay_use_set(const char *s, const struct kernel_param *kp)
> @@ -151,11 +146,12 @@ static int delay_use_set(const char *s, const struct kernel_param *kp)
> return 0;
> }
>
> -static int delay_use_get(char *s, const struct kernel_param *kp)
> +static int delay_use_get(struct seq_buf *s, const struct kernel_param *kp)
> {
> unsigned int delay_ms = *((unsigned int *)kp->arg);
>
> - return format_delay_ms(delay_ms, 3, "ms", s, PAGE_SIZE);
> + format_delay_ms(delay_ms, 3, "ms", s);
> + return 0;
> }
>
> static DEFINE_KERNEL_PARAM_OPS(delay_use_ops, delay_use_set, delay_use_get);
> diff --git a/drivers/virtio/virtio_mmio.c b/drivers/virtio/virtio_mmio.c
> index f6df9c76ee81..81a7455e4643 100644
> --- a/drivers/virtio/virtio_mmio.c
> +++ b/drivers/virtio/virtio_mmio.c
> @@ -728,24 +728,21 @@ static int vm_cmdline_set(const char *device,
>
> static int vm_cmdline_get_device(struct device *dev, void *data)
> {
> - char *buffer = data;
> - unsigned int len = strlen(buffer);
> + struct seq_buf *s = data;
> struct platform_device *pdev = to_platform_device(dev);
>
> - snprintf(buffer + len, PAGE_SIZE - len, "0x%llx@0x%llx:%llu:%d\n",
> - pdev->resource[0].end - pdev->resource[0].start + 1ULL,
> - (unsigned long long)pdev->resource[0].start,
> - (unsigned long long)pdev->resource[1].start,
> - pdev->id);
> + seq_buf_printf(s, "0x%llx@0x%llx:%llu:%d\n",
> + pdev->resource[0].end - pdev->resource[0].start + 1ULL,
> + (unsigned long long)pdev->resource[0].start,
> + (unsigned long long)pdev->resource[1].start,
> + pdev->id);
> return 0;
> }
>
> -static int vm_cmdline_get(char *buffer, const struct kernel_param *kp)
> +static int vm_cmdline_get(struct seq_buf *s, const struct kernel_param *kp)
> {
> - buffer[0] = '\0';
> - device_for_each_child(&vm_cmdline_parent, buffer,
> - vm_cmdline_get_device);
> - return strlen(buffer) + 1;
> + device_for_each_child(&vm_cmdline_parent, s, vm_cmdline_get_device);
> + return 0;
> }
>
> static DEFINE_KERNEL_PARAM_OPS(vm_cmdline_param_ops, vm_cmdline_set,
> diff --git a/lib/dynamic_debug.c b/lib/dynamic_debug.c
> index cf0405ba0dbd..123f061c2fb2 100644
> --- a/lib/dynamic_debug.c
> +++ b/lib/dynamic_debug.c
> @@ -17,6 +17,7 @@
> #include <linux/module.h>
> #include <linux/moduleparam.h>
> #include <linux/kallsyms.h>
> +#include <linux/seq_buf.h>
> #include <linux/types.h>
> #include <linux/mutex.h>
> #include <linux/proc_fs.h>
> @@ -787,7 +788,8 @@ EXPORT_SYMBOL(param_set_dyndbg_classes);
> * altered by direct >control. Displays 0x for DISJOINT, 0-N for
> * LEVEL Returns: #chars written or <0 on error
> */
> -int param_get_dyndbg_classes(char *buffer, const struct kernel_param *kp)
> +int param_get_dyndbg_classes(struct seq_buf *buffer,
> + const struct kernel_param *kp)
> {
> const struct ddebug_class_param *dcp = kp->arg;
> const struct ddebug_class_map *map = dcp->map;
> @@ -796,11 +798,13 @@ int param_get_dyndbg_classes(char *buffer, const struct kernel_param *kp)
>
> case DD_CLASS_TYPE_DISJOINT_NAMES:
> case DD_CLASS_TYPE_DISJOINT_BITS:
> - return scnprintf(buffer, PAGE_SIZE, "0x%lx\n", *dcp->bits);
> + seq_buf_printf(buffer, "0x%lx\n", *dcp->bits);
> + return 0;
>
> case DD_CLASS_TYPE_LEVEL_NAMES:
> case DD_CLASS_TYPE_LEVEL_NUM:
> - return scnprintf(buffer, PAGE_SIZE, "%d\n", *dcp->lvl);
> + seq_buf_printf(buffer, "%d\n", *dcp->lvl);
> + return 0;
> default:
> return -1;
> }
> --
> 2.34.1
>
^ permalink raw reply
* Re: [PATCH 09/11] treewide: Convert custom kernel_param_ops .get callbacks to seq_buf via cocci
From: Rafael J. Wysocki @ 2026-05-22 17:03 UTC (permalink / raw)
To: Kees Cook
Cc: Luis Chamberlain, Pengpeng Hou, Petr Pavlu, Richard Weinberger,
Anton Ivanov, Johannes Berg, Rafael J. Wysocki, Len Brown,
Corey Minyard, Gabriel Somlo, Michael S. Tsirkin, Jani Nikula,
Joonas Lahtinen, Rodrigo Vivi, Tvrtko Ursulin, David Airlie,
Simona Vetter, Bart Van Assche, Jason Gunthorpe, Leon Romanovsky,
Laurent Pinchart, Hans de Goede, Mauro Carvalho Chehab,
Bjorn Helgaas, Hannes Reinecke, James E.J. Bottomley,
Martin K. Petersen, Daniel Lezcano, Zhang Rui, Lukasz Luba,
Greg Kroah-Hartman, Jiri Slaby, Alan Stern, Jason Wang, Xuan Zhuo,
Eugenio Pérez, Jason Baron, Jim Cromie, Tiwei Bie,
Benjamin Berg, Ilpo Järvinen, David E. Box,
Maciej W. Rozycki, Srinivas Pandruvada, Peter Zijlstra,
Heiko Carstens, Vasily Gorbik, Sean Christopherson, Paolo Bonzini,
Thomas Gleixner, Ingo Molnar, Borislav Petkov, Dave Hansen, x86,
H. Peter Anvin, Vinod Koul, Frank Li, Daniel Gomez, Sami Tolvanen,
Aaron Tomlin, Alexander Potapenko, Marco Elver, Dmitry Vyukov,
Andrew Morton, John Johansen, Paul Moore, James Morris,
Serge E. Hallyn, Andy Shevchenko, Georgia Garcia, kvm, dmaengine,
linux-modules, kasan-dev, linux-mm, apparmor,
linux-security-module, linux-um, linux-acpi, openipmi-developer,
qemu-devel, intel-gfx, dri-devel, linux-rdma, linux-media,
linux-pci, linux-scsi, linux-pm, linuxppc-dev, linux-serial,
linux-usb, usb-storage, virtualization, linux-kernel, linux-arch,
netdev, linux-fsdevel, linux-hardening
In-Reply-To: <20260521133326.2465264-9-kees@kernel.org>
On Thu, May 21, 2026 at 3:33 PM Kees Cook <kees@kernel.org> wrote:
>
> Using the following Coccinelle script, convert struct kernel_param_ops
> .get callbacks from "char *" to "struct seq_buf *" when the only write
> to the buffer is via a final call of scnprintf(), snprintf(), sprintf(),
> or sysfs_emit().
>
> Since seq_buf_printf() will return -1 on overflow, and struct
> kernel_param_ops .get callbacks are expected to truncate without error,
> we must ignore the return value from seq_buf_print() and always return 0
> (as the length is calculated in the common dispatcher code).
>
> @@
> identifier FN, BUF, KP;
> expression FMT;
> expression list ARGS;
> @@
> int FN(
> - char *BUF
> + struct seq_buf *BUF
> , const struct kernel_param *KP)
> {
> ... when any
> (
> - return scnprintf(BUF, PAGE_SIZE, FMT, ARGS);
> |
> - return snprintf(BUF, PAGE_SIZE, FMT, ARGS);
> |
> - return sprintf(BUF, FMT, ARGS);
> |
> - return sysfs_emit(BUF, FMT, ARGS);
> )
> + seq_buf_printf(BUF, FMT, ARGS);
> + return 0;
> }
>
> No struct kernel_param_ops initializations need changing since
> DEFINE_KERNEL_PARAM_OPS already routes the pointer to .get or .get_str
> via _Generic based on the function signature, so converted callbacks
> are automatically moved from the .get_str to the .get callback.
>
> Signed-off-by: Kees Cook <kees@kernel.org>
For ACPI:
Acked-by: Rafael J. Wysocki (Intel) <rafael@kernel.org>
> ---
> arch/s390/kernel/perf_cpum_sf.c | 6 ++-
> arch/x86/kernel/msr.c | 5 +-
> arch/x86/kvm/vmx/vmx.c | 18 ++++---
> arch/x86/platform/uv/uv_nmi.c | 12 +++--
> drivers/acpi/ec.c | 14 ++++--
> drivers/acpi/sysfs.c | 6 ++-
> drivers/block/ublk_drv.c | 5 +-
> drivers/char/ipmi/ipmi_msghandler.c | 6 ++-
> drivers/firmware/qcom/qcom_scm.c | 12 +++--
> drivers/gpu/drm/drm_panic.c | 7 +--
> drivers/infiniband/hw/hfi1/driver.c | 7 +--
> drivers/infiniband/ulp/srpt/ib_srpt.c | 5 +-
> drivers/input/misc/ati_remote2.c | 10 ++--
> drivers/input/mouse/psmouse-base.c | 9 ++--
> drivers/md/md.c | 5 +-
> drivers/media/pci/tw686x/tw686x-core.c | 6 ++-
> drivers/nvme/host/multipath.c | 5 +-
> drivers/power/supply/test_power.c | 47 +++++++++++--------
> drivers/target/target_core_user.c | 12 +++--
> .../processor_thermal_soc_slider.c | 12 +++--
> drivers/ufs/core/ufs-fault-injection.c | 7 +--
> drivers/vhost/scsi.c | 5 +-
> fs/nfs/namespace.c | 6 ++-
> fs/ocfs2/dlmfs/dlmfs.c | 5 +-
> fs/overlayfs/copy_up.c | 5 +-
> kernel/locking/locktorture.c | 6 ++-
> kernel/rcu/tree.c | 6 ++-
> kernel/workqueue.c | 6 ++-
> lib/test_dynamic_debug.c | 6 ++-
> mm/damon/lru_sort.c | 14 +++---
> mm/damon/reclaim.c | 14 +++---
> mm/damon/stat.c | 10 ++--
> mm/memory_hotplug.c | 18 ++++---
> net/ceph/ceph_common.c | 5 +-
> net/sunrpc/auth.c | 6 ++-
> net/sunrpc/svc.c | 5 +-
> security/apparmor/lsm.c | 16 ++++---
> 37 files changed, 218 insertions(+), 131 deletions(-)
>
> diff --git a/arch/s390/kernel/perf_cpum_sf.c b/arch/s390/kernel/perf_cpum_sf.c
> index 76119542562b..75b0d441d238 100644
> --- a/arch/s390/kernel/perf_cpum_sf.c
> +++ b/arch/s390/kernel/perf_cpum_sf.c
> @@ -1991,11 +1991,13 @@ static int s390_pmu_sf_offline_cpu(unsigned int cpu)
> return cpusf_pmu_setup(cpu, PMC_RELEASE);
> }
>
> -static int param_get_sfb_size(char *buffer, const struct kernel_param *kp)
> +static int param_get_sfb_size(struct seq_buf *buffer,
> + const struct kernel_param *kp)
> {
> if (!cpum_sf_avail())
> return -ENODEV;
> - return sprintf(buffer, "%lu,%lu", CPUM_SF_MIN_SDB, CPUM_SF_MAX_SDB);
> + seq_buf_printf(buffer, "%lu,%lu", CPUM_SF_MIN_SDB, CPUM_SF_MAX_SDB);
> + return 0;
> }
>
> static int param_set_sfb_size(const char *val, const struct kernel_param *kp)
> diff --git a/arch/x86/kernel/msr.c b/arch/x86/kernel/msr.c
> index 5f4e1814dc4d..9f07f66c3cfc 100644
> --- a/arch/x86/kernel/msr.c
> +++ b/arch/x86/kernel/msr.c
> @@ -309,7 +309,7 @@ static int set_allow_writes(const char *val, const struct kernel_param *cp)
> return 0;
> }
>
> -static int get_allow_writes(char *buf, const struct kernel_param *kp)
> +static int get_allow_writes(struct seq_buf *buf, const struct kernel_param *kp)
> {
> const char *res;
>
> @@ -319,7 +319,8 @@ static int get_allow_writes(char *buf, const struct kernel_param *kp)
> default: res = "default"; break;
> }
>
> - return sprintf(buf, "%s\n", res);
> + seq_buf_printf(buf, "%s\n", res);
> + return 0;
> }
>
> static DEFINE_KERNEL_PARAM_OPS(allow_writes_ops, set_allow_writes,
> diff --git a/arch/x86/kvm/vmx/vmx.c b/arch/x86/kvm/vmx/vmx.c
> index 07f4c7209ac0..00317774a90b 100644
> --- a/arch/x86/kvm/vmx/vmx.c
> +++ b/arch/x86/kvm/vmx/vmx.c
> @@ -368,12 +368,16 @@ static int vmentry_l1d_flush_set(const char *s, const struct kernel_param *kp)
> return ret;
> }
>
> -static int vmentry_l1d_flush_get(char *s, const struct kernel_param *kp)
> +static int vmentry_l1d_flush_get(struct seq_buf *s,
> + const struct kernel_param *kp)
> {
> - if (WARN_ON_ONCE(l1tf_vmx_mitigation >= ARRAY_SIZE(vmentry_l1d_param)))
> - return sysfs_emit(s, "???\n");
> + if (WARN_ON_ONCE(l1tf_vmx_mitigation >= ARRAY_SIZE(vmentry_l1d_param))) {
> + seq_buf_printf(s, "???\n");
> + return 0;
> + }
>
> - return sysfs_emit(s, "%s\n", vmentry_l1d_param[l1tf_vmx_mitigation].option);
> + seq_buf_printf(s, "%s\n", vmentry_l1d_param[l1tf_vmx_mitigation].option);
> + return 0;
> }
>
> /*
> @@ -459,9 +463,11 @@ static int vmentry_l1d_flush_set(const char *s, const struct kernel_param *kp)
> pr_warn_once("Kernel compiled without mitigations, ignoring vmentry_l1d_flush\n");
> return 0;
> }
> -static int vmentry_l1d_flush_get(char *s, const struct kernel_param *kp)
> +static int vmentry_l1d_flush_get(struct seq_buf *s,
> + const struct kernel_param *kp)
> {
> - return sysfs_emit(s, "never\n");
> + seq_buf_printf(s, "never\n");
> + return 0;
> }
> #endif
>
> diff --git a/arch/x86/platform/uv/uv_nmi.c b/arch/x86/platform/uv/uv_nmi.c
> index a7ac80b5f8d9..c401369efe22 100644
> --- a/arch/x86/platform/uv/uv_nmi.c
> +++ b/arch/x86/platform/uv/uv_nmi.c
> @@ -111,9 +111,11 @@ module_param_named(dump_loglevel, uv_nmi_loglevel, int, 0644);
> * The following values show statistics on how perf events are affecting
> * this system.
> */
> -static int param_get_local64(char *buffer, const struct kernel_param *kp)
> +static int param_get_local64(struct seq_buf *buffer,
> + const struct kernel_param *kp)
> {
> - return sprintf(buffer, "%lu\n", local64_read((local64_t *)kp->arg));
> + seq_buf_printf(buffer, "%lu\n", local64_read((local64_t *)kp->arg));
> + return 0;
> }
>
> static int param_set_local64(const char *val, const struct kernel_param *kp)
> @@ -207,9 +209,11 @@ static const char * const actions_desc[nmi_act_max] = {
>
> static enum action_t uv_nmi_action = nmi_act_dump;
>
> -static int param_get_action(char *buffer, const struct kernel_param *kp)
> +static int param_get_action(struct seq_buf *buffer,
> + const struct kernel_param *kp)
> {
> - return sprintf(buffer, "%s\n", actions[uv_nmi_action]);
> + seq_buf_printf(buffer, "%s\n", actions[uv_nmi_action]);
> + return 0;
> }
>
> static int param_set_action(const char *val, const struct kernel_param *kp)
> diff --git a/drivers/acpi/ec.c b/drivers/acpi/ec.c
> index 45204538ed87..6478e5290faf 100644
> --- a/drivers/acpi/ec.c
> +++ b/drivers/acpi/ec.c
> @@ -2236,18 +2236,22 @@ static int param_set_event_clearing(const char *val,
> return result;
> }
>
> -static int param_get_event_clearing(char *buffer,
> +static int param_get_event_clearing(struct seq_buf *buffer,
> const struct kernel_param *kp)
> {
> switch (ec_event_clearing) {
> case ACPI_EC_EVT_TIMING_STATUS:
> - return sprintf(buffer, "status\n");
> + seq_buf_printf(buffer, "status\n");
> + return 0;
> case ACPI_EC_EVT_TIMING_QUERY:
> - return sprintf(buffer, "query\n");
> + seq_buf_printf(buffer, "query\n");
> + return 0;
> case ACPI_EC_EVT_TIMING_EVENT:
> - return sprintf(buffer, "event\n");
> + seq_buf_printf(buffer, "event\n");
> + return 0;
> default:
> - return sprintf(buffer, "invalid\n");
> + seq_buf_printf(buffer, "invalid\n");
> + return 0;
> }
> return 0;
> }
> diff --git a/drivers/acpi/sysfs.c b/drivers/acpi/sysfs.c
> index 3d32a5280432..5247ed7e05cc 100644
> --- a/drivers/acpi/sysfs.c
> +++ b/drivers/acpi/sysfs.c
> @@ -192,9 +192,11 @@ static int param_set_trace_method_name(const char *val,
> return 0;
> }
>
> -static int param_get_trace_method_name(char *buffer, const struct kernel_param *kp)
> +static int param_get_trace_method_name(struct seq_buf *buffer,
> + const struct kernel_param *kp)
> {
> - return sysfs_emit(buffer, "%s\n", acpi_gbl_trace_method_name);
> + seq_buf_printf(buffer, "%s\n", acpi_gbl_trace_method_name);
> + return 0;
> }
>
> static DEFINE_KERNEL_PARAM_OPS(param_ops_trace_method,
> diff --git a/drivers/block/ublk_drv.c b/drivers/block/ublk_drv.c
> index f7bf7ea2d088..ea35662381bf 100644
> --- a/drivers/block/ublk_drv.c
> +++ b/drivers/block/ublk_drv.c
> @@ -5868,10 +5868,11 @@ static int ublk_set_max_unprivileged_ublks(const char *buf,
> return param_set_uint_minmax(buf, kp, 0, UBLK_MAX_UBLKS);
> }
>
> -static int ublk_get_max_unprivileged_ublks(char *buf,
> +static int ublk_get_max_unprivileged_ublks(struct seq_buf *buf,
> const struct kernel_param *kp)
> {
> - return sysfs_emit(buf, "%u\n", unprivileged_ublks_max);
> + seq_buf_printf(buf, "%u\n", unprivileged_ublks_max);
> + return 0;
> }
>
> static DEFINE_KERNEL_PARAM_OPS(ublk_max_unprivileged_ublks_ops,
> diff --git a/drivers/char/ipmi/ipmi_msghandler.c b/drivers/char/ipmi/ipmi_msghandler.c
> index b5fed11707e8..45941605b88f 100644
> --- a/drivers/char/ipmi/ipmi_msghandler.c
> +++ b/drivers/char/ipmi/ipmi_msghandler.c
> @@ -90,7 +90,8 @@ static int panic_op_write_handler(const char *val,
> return 0;
> }
>
> -static int panic_op_read_handler(char *buffer, const struct kernel_param *kp)
> +static int panic_op_read_handler(struct seq_buf *buffer,
> + const struct kernel_param *kp)
> {
> const char *event_str;
>
> @@ -99,7 +100,8 @@ static int panic_op_read_handler(char *buffer, const struct kernel_param *kp)
> else
> event_str = ipmi_panic_event_str[ipmi_send_panic_event];
>
> - return sprintf(buffer, "%s\n", event_str);
> + seq_buf_printf(buffer, "%s\n", event_str);
> + return 0;
> }
>
> static DEFINE_KERNEL_PARAM_OPS(panic_op_ops, panic_op_write_handler,
> diff --git a/drivers/firmware/qcom/qcom_scm.c b/drivers/firmware/qcom/qcom_scm.c
> index ef57df53e087..1bdb497e354e 100644
> --- a/drivers/firmware/qcom/qcom_scm.c
> +++ b/drivers/firmware/qcom/qcom_scm.c
> @@ -2694,12 +2694,16 @@ static irqreturn_t qcom_scm_irq_handler(int irq, void *data)
> return IRQ_HANDLED;
> }
>
> -static int get_download_mode(char *buffer, const struct kernel_param *kp)
> +static int get_download_mode(struct seq_buf *buffer,
> + const struct kernel_param *kp)
> {
> - if (download_mode >= ARRAY_SIZE(download_mode_name))
> - return sysfs_emit(buffer, "unknown mode\n");
> + if (download_mode >= ARRAY_SIZE(download_mode_name)) {
> + seq_buf_printf(buffer, "unknown mode\n");
> + return 0;
> + }
>
> - return sysfs_emit(buffer, "%s\n", download_mode_name[download_mode]);
> + seq_buf_printf(buffer, "%s\n", download_mode_name[download_mode]);
> + return 0;
> }
>
> static int set_download_mode(const char *val, const struct kernel_param *kp)
> diff --git a/drivers/gpu/drm/drm_panic.c b/drivers/gpu/drm/drm_panic.c
> index c35d1adf2ce3..8b3b749284f0 100644
> --- a/drivers/gpu/drm/drm_panic.c
> +++ b/drivers/gpu/drm/drm_panic.c
> @@ -841,10 +841,11 @@ static int drm_panic_type_set(const char *val, const struct kernel_param *kp)
> return -EINVAL;
> }
>
> -static int drm_panic_type_get(char *buffer, const struct kernel_param *kp)
> +static int drm_panic_type_get(struct seq_buf *buffer,
> + const struct kernel_param *kp)
> {
> - return scnprintf(buffer, PAGE_SIZE, "%s\n",
> - drm_panic_type_map[drm_panic_type]);
> + seq_buf_printf(buffer, "%s\n", drm_panic_type_map[drm_panic_type]);
> + return 0;
> }
>
> static DEFINE_KERNEL_PARAM_OPS(drm_panic_ops, drm_panic_type_set,
> diff --git a/drivers/infiniband/hw/hfi1/driver.c b/drivers/infiniband/hw/hfi1/driver.c
> index 5b9b0b38b419..3c3f8d4db99d 100644
> --- a/drivers/infiniband/hw/hfi1/driver.c
> +++ b/drivers/infiniband/hw/hfi1/driver.c
> @@ -41,7 +41,7 @@ MODULE_PARM_DESC(cu, "Credit return units");
>
> unsigned long hfi1_cap_mask = HFI1_CAP_MASK_DEFAULT;
> static int hfi1_caps_set(const char *val, const struct kernel_param *kp);
> -static int hfi1_caps_get(char *buffer, const struct kernel_param *kp);
> +static int hfi1_caps_get(struct seq_buf *buffer, const struct kernel_param *kp);
> static DEFINE_KERNEL_PARAM_OPS(cap_ops, hfi1_caps_set, hfi1_caps_get);
> module_param_cb(cap_mask, &cap_ops, &hfi1_cap_mask, S_IWUSR | S_IRUGO);
> MODULE_PARM_DESC(cap_mask, "Bit mask of enabled/disabled HW features");
> @@ -101,14 +101,15 @@ static int hfi1_caps_set(const char *val, const struct kernel_param *kp)
> return ret;
> }
>
> -static int hfi1_caps_get(char *buffer, const struct kernel_param *kp)
> +static int hfi1_caps_get(struct seq_buf *buffer, const struct kernel_param *kp)
> {
> unsigned long cap_mask = *(unsigned long *)kp->arg;
>
> cap_mask &= ~HFI1_CAP_LOCKED_SMASK;
> cap_mask |= ((cap_mask & HFI1_CAP_K2U) << HFI1_CAP_USER_SHIFT);
>
> - return sysfs_emit(buffer, "0x%lx\n", cap_mask);
> + seq_buf_printf(buffer, "0x%lx\n", cap_mask);
> + return 0;
> }
>
> struct pci_dev *get_pci_dev(struct rvt_dev_info *rdi)
> diff --git a/drivers/infiniband/ulp/srpt/ib_srpt.c b/drivers/infiniband/ulp/srpt/ib_srpt.c
> index 9aec5d80117f..97c77d52a86a 100644
> --- a/drivers/infiniband/ulp/srpt/ib_srpt.c
> +++ b/drivers/infiniband/ulp/srpt/ib_srpt.c
> @@ -86,9 +86,10 @@ static int srpt_set_u64_x(const char *buffer, const struct kernel_param *kp)
> {
> return kstrtou64(buffer, 16, (u64 *)kp->arg);
> }
> -static int srpt_get_u64_x(char *buffer, const struct kernel_param *kp)
> +static int srpt_get_u64_x(struct seq_buf *buffer, const struct kernel_param *kp)
> {
> - return sprintf(buffer, "0x%016llx\n", *(u64 *)kp->arg);
> + seq_buf_printf(buffer, "0x%016llx\n", *(u64 *)kp->arg);
> + return 0;
> }
> module_param_call(srpt_service_guid, srpt_set_u64_x, srpt_get_u64_x,
> &srpt_service_guid, 0444);
> diff --git a/drivers/input/misc/ati_remote2.c b/drivers/input/misc/ati_remote2.c
> index 8b4ef7e163d3..d101fe1c2c4c 100644
> --- a/drivers/input/misc/ati_remote2.c
> +++ b/drivers/input/misc/ati_remote2.c
> @@ -63,12 +63,13 @@ static int ati_remote2_set_channel_mask(const char *val,
> return ati_remote2_set_mask(val, kp, ATI_REMOTE2_MAX_CHANNEL_MASK);
> }
>
> -static int ati_remote2_get_channel_mask(char *buffer,
> +static int ati_remote2_get_channel_mask(struct seq_buf *buffer,
> const struct kernel_param *kp)
> {
> pr_debug("%s()\n", __func__);
>
> - return sprintf(buffer, "0x%04x\n", *(unsigned int *)kp->arg);
> + seq_buf_printf(buffer, "0x%04x\n", *(unsigned int *)kp->arg);
> + return 0;
> }
>
> static int ati_remote2_set_mode_mask(const char *val,
> @@ -79,12 +80,13 @@ static int ati_remote2_set_mode_mask(const char *val,
> return ati_remote2_set_mask(val, kp, ATI_REMOTE2_MAX_MODE_MASK);
> }
>
> -static int ati_remote2_get_mode_mask(char *buffer,
> +static int ati_remote2_get_mode_mask(struct seq_buf *buffer,
> const struct kernel_param *kp)
> {
> pr_debug("%s()\n", __func__);
>
> - return sprintf(buffer, "0x%02x\n", *(unsigned int *)kp->arg);
> + seq_buf_printf(buffer, "0x%02x\n", *(unsigned int *)kp->arg);
> + return 0;
> }
>
> static unsigned int channel_mask = ATI_REMOTE2_MAX_CHANNEL_MASK;
> diff --git a/drivers/input/mouse/psmouse-base.c b/drivers/input/mouse/psmouse-base.c
> index f9ebb1fd0b6f..39a9b87e69d1 100644
> --- a/drivers/input/mouse/psmouse-base.c
> +++ b/drivers/input/mouse/psmouse-base.c
> @@ -44,7 +44,8 @@ MODULE_LICENSE("GPL");
>
> static unsigned int psmouse_max_proto = PSMOUSE_AUTO;
> static int psmouse_set_maxproto(const char *val, const struct kernel_param *);
> -static int psmouse_get_maxproto(char *buffer, const struct kernel_param *kp);
> +static int psmouse_get_maxproto(struct seq_buf *buffer,
> + const struct kernel_param *kp);
> static DEFINE_KERNEL_PARAM_OPS(param_ops_proto_abbrev, psmouse_set_maxproto,
> psmouse_get_maxproto);
> #define param_check_proto_abbrev(name, p) __param_check(name, p, unsigned int)
> @@ -1994,11 +1995,13 @@ static int psmouse_set_maxproto(const char *val, const struct kernel_param *kp)
> return 0;
> }
>
> -static int psmouse_get_maxproto(char *buffer, const struct kernel_param *kp)
> +static int psmouse_get_maxproto(struct seq_buf *buffer,
> + const struct kernel_param *kp)
> {
> int type = *((unsigned int *)kp->arg);
>
> - return sprintf(buffer, "%s\n", psmouse_protocol_by_type(type)->name);
> + seq_buf_printf(buffer, "%s\n", psmouse_protocol_by_type(type)->name);
> + return 0;
> }
>
> static int __init psmouse_init(void)
> diff --git a/drivers/md/md.c b/drivers/md/md.c
> index 8b568eee8743..ce3eb1396ad0 100644
> --- a/drivers/md/md.c
> +++ b/drivers/md/md.c
> @@ -10989,9 +10989,10 @@ static __exit void md_exit(void)
> subsys_initcall(md_init);
> module_exit(md_exit)
>
> -static int get_ro(char *buffer, const struct kernel_param *kp)
> +static int get_ro(struct seq_buf *buffer, const struct kernel_param *kp)
> {
> - return sprintf(buffer, "%d\n", start_readonly);
> + seq_buf_printf(buffer, "%d\n", start_readonly);
> + return 0;
> }
> static int set_ro(const char *val, const struct kernel_param *kp)
> {
> diff --git a/drivers/media/pci/tw686x/tw686x-core.c b/drivers/media/pci/tw686x/tw686x-core.c
> index a10e38221817..35a6ff8d77fc 100644
> --- a/drivers/media/pci/tw686x/tw686x-core.c
> +++ b/drivers/media/pci/tw686x/tw686x-core.c
> @@ -69,9 +69,11 @@ static const char *dma_mode_name(unsigned int mode)
> }
> }
>
> -static int tw686x_dma_mode_get(char *buffer, const struct kernel_param *kp)
> +static int tw686x_dma_mode_get(struct seq_buf *buffer,
> + const struct kernel_param *kp)
> {
> - return sprintf(buffer, "%s", dma_mode_name(dma_mode));
> + seq_buf_printf(buffer, "%s", dma_mode_name(dma_mode));
> + return 0;
> }
>
> static int tw686x_dma_mode_set(const char *val, const struct kernel_param *kp)
> diff --git a/drivers/nvme/host/multipath.c b/drivers/nvme/host/multipath.c
> index f7362377e427..e0c87447074d 100644
> --- a/drivers/nvme/host/multipath.c
> +++ b/drivers/nvme/host/multipath.c
> @@ -85,9 +85,10 @@ static int nvme_set_iopolicy(const char *val, const struct kernel_param *kp)
> return 0;
> }
>
> -static int nvme_get_iopolicy(char *buf, const struct kernel_param *kp)
> +static int nvme_get_iopolicy(struct seq_buf *buf, const struct kernel_param *kp)
> {
> - return sprintf(buf, "%s\n", nvme_iopolicy_names[iopolicy]);
> + seq_buf_printf(buf, "%s\n", nvme_iopolicy_names[iopolicy]);
> + return 0;
> }
>
> module_param_call(iopolicy, nvme_set_iopolicy, nvme_get_iopolicy,
> diff --git a/drivers/power/supply/test_power.c b/drivers/power/supply/test_power.c
> index 0bf2bef3383a..9dcd588ab5c9 100644
> --- a/drivers/power/supply/test_power.c
> +++ b/drivers/power/supply/test_power.c
> @@ -490,10 +490,12 @@ static int param_set_ac_online(const char *key, const struct kernel_param *kp)
> return 0;
> }
>
> -static int param_get_ac_online(char *buffer, const struct kernel_param *kp)
> +static int param_get_ac_online(struct seq_buf *buffer,
> + const struct kernel_param *kp)
> {
> - return sprintf(buffer, "%s\n",
> - map_get_key(map_ac_online, ac_online, "unknown"));
> + seq_buf_printf(buffer, "%s\n",
> + map_get_key(map_ac_online, ac_online, "unknown"));
> + return 0;
> }
>
> static int param_set_usb_online(const char *key, const struct kernel_param *kp)
> @@ -503,10 +505,12 @@ static int param_set_usb_online(const char *key, const struct kernel_param *kp)
> return 0;
> }
>
> -static int param_get_usb_online(char *buffer, const struct kernel_param *kp)
> +static int param_get_usb_online(struct seq_buf *buffer,
> + const struct kernel_param *kp)
> {
> - return sprintf(buffer, "%s\n",
> - map_get_key(map_ac_online, usb_online, "unknown"));
> + seq_buf_printf(buffer, "%s\n",
> + map_get_key(map_ac_online, usb_online, "unknown"));
> + return 0;
> }
>
> static int param_set_battery_status(const char *key,
> @@ -517,10 +521,12 @@ static int param_set_battery_status(const char *key,
> return 0;
> }
>
> -static int param_get_battery_status(char *buffer, const struct kernel_param *kp)
> +static int param_get_battery_status(struct seq_buf *buffer,
> + const struct kernel_param *kp)
> {
> - return sprintf(buffer, "%s\n",
> - map_get_key(map_ac_online, battery_status, "unknown"));
> + seq_buf_printf(buffer, "%s\n",
> + map_get_key(map_ac_online, battery_status, "unknown"));
> + return 0;
> }
>
> static int param_set_battery_health(const char *key,
> @@ -531,10 +537,12 @@ static int param_set_battery_health(const char *key,
> return 0;
> }
>
> -static int param_get_battery_health(char *buffer, const struct kernel_param *kp)
> +static int param_get_battery_health(struct seq_buf *buffer,
> + const struct kernel_param *kp)
> {
> - return sprintf(buffer, "%s\n",
> - map_get_key(map_ac_online, battery_health, "unknown"));
> + seq_buf_printf(buffer, "%s\n",
> + map_get_key(map_ac_online, battery_health, "unknown"));
> + return 0;
> }
>
> static int param_set_battery_present(const char *key,
> @@ -545,11 +553,12 @@ static int param_set_battery_present(const char *key,
> return 0;
> }
>
> -static int param_get_battery_present(char *buffer,
> +static int param_get_battery_present(struct seq_buf *buffer,
> const struct kernel_param *kp)
> {
> - return sprintf(buffer, "%s\n",
> - map_get_key(map_ac_online, battery_present, "unknown"));
> + seq_buf_printf(buffer, "%s\n",
> + map_get_key(map_ac_online, battery_present, "unknown"));
> + return 0;
> }
>
> static int param_set_battery_technology(const char *key,
> @@ -561,12 +570,12 @@ static int param_set_battery_technology(const char *key,
> return 0;
> }
>
> -static int param_get_battery_technology(char *buffer,
> +static int param_get_battery_technology(struct seq_buf *buffer,
> const struct kernel_param *kp)
> {
> - return sprintf(buffer, "%s\n",
> - map_get_key(map_ac_online, battery_technology,
> - "unknown"));
> + seq_buf_printf(buffer, "%s\n",
> + map_get_key(map_ac_online, battery_technology, "unknown"));
> + return 0;
> }
>
> static int param_set_battery_capacity(const char *key,
> diff --git a/drivers/target/target_core_user.c b/drivers/target/target_core_user.c
> index 676a12b44e88..5e8817a63726 100644
> --- a/drivers/target/target_core_user.c
> +++ b/drivers/target/target_core_user.c
> @@ -249,10 +249,11 @@ static int tcmu_set_global_max_data_area(const char *str,
> return 0;
> }
>
> -static int tcmu_get_global_max_data_area(char *buffer,
> +static int tcmu_get_global_max_data_area(struct seq_buf *buffer,
> const struct kernel_param *kp)
> {
> - return sprintf(buffer, "%d\n", TCMU_PAGES_TO_MBS(tcmu_global_max_pages));
> + seq_buf_printf(buffer, "%d\n", TCMU_PAGES_TO_MBS(tcmu_global_max_pages));
> + return 0;
> }
>
> static DEFINE_KERNEL_PARAM_OPS(tcmu_global_max_data_area_op,
> @@ -265,11 +266,12 @@ MODULE_PARM_DESC(global_max_data_area_mb,
> "Max MBs allowed to be allocated to all the tcmu device's "
> "data areas.");
>
> -static int tcmu_get_block_netlink(char *buffer,
> +static int tcmu_get_block_netlink(struct seq_buf *buffer,
> const struct kernel_param *kp)
> {
> - return sprintf(buffer, "%s\n", tcmu_netlink_blocked ?
> - "blocked" : "unblocked");
> + seq_buf_printf(buffer, "%s\n",
> + tcmu_netlink_blocked ? "blocked" : "unblocked");
> + return 0;
> }
>
> static int tcmu_set_block_netlink(const char *str,
> diff --git a/drivers/thermal/intel/int340x_thermal/processor_thermal_soc_slider.c b/drivers/thermal/intel/int340x_thermal/processor_thermal_soc_slider.c
> index 68275c3f2c9b..1a68721748d9 100644
> --- a/drivers/thermal/intel/int340x_thermal/processor_thermal_soc_slider.c
> +++ b/drivers/thermal/intel/int340x_thermal/processor_thermal_soc_slider.c
> @@ -77,10 +77,12 @@ static int slider_def_balance_set(const char *arg, const struct kernel_param *kp
> return ret;
> }
>
> -static int slider_def_balance_get(char *buf, const struct kernel_param *kp)
> +static int slider_def_balance_get(struct seq_buf *buf,
> + const struct kernel_param *kp)
> {
> guard(mutex)(&slider_param_lock);
> - return sysfs_emit(buf, "%02x\n", slider_values[SOC_POWER_SLIDER_BALANCE]);
> + seq_buf_printf(buf, "%02x\n", slider_values[SOC_POWER_SLIDER_BALANCE]);
> + return 0;
> }
>
> static DEFINE_KERNEL_PARAM_OPS(slider_def_balance_ops, slider_def_balance_set,
> @@ -109,10 +111,12 @@ static int slider_def_offset_set(const char *arg, const struct kernel_param *kp)
> return ret;
> }
>
> -static int slider_def_offset_get(char *buf, const struct kernel_param *kp)
> +static int slider_def_offset_get(struct seq_buf *buf,
> + const struct kernel_param *kp)
> {
> guard(mutex)(&slider_param_lock);
> - return sysfs_emit(buf, "%02x\n", slider_offset);
> + seq_buf_printf(buf, "%02x\n", slider_offset);
> + return 0;
> }
>
> static DEFINE_KERNEL_PARAM_OPS(slider_offset_ops, slider_def_offset_set,
> diff --git a/drivers/ufs/core/ufs-fault-injection.c b/drivers/ufs/core/ufs-fault-injection.c
> index 7d2873da7dc5..88f348b41614 100644
> --- a/drivers/ufs/core/ufs-fault-injection.c
> +++ b/drivers/ufs/core/ufs-fault-injection.c
> @@ -8,7 +8,7 @@
> #include <ufs/ufshcd.h>
> #include "ufs-fault-injection.h"
>
> -static int ufs_fault_get(char *buffer, const struct kernel_param *kp);
> +static int ufs_fault_get(struct seq_buf *buffer, const struct kernel_param *kp);
> static int ufs_fault_set(const char *val, const struct kernel_param *kp);
>
> static DEFINE_KERNEL_PARAM_OPS(ufs_fault_ops, ufs_fault_set, ufs_fault_get);
> @@ -31,11 +31,12 @@ MODULE_PARM_DESC(timeout,
> "Fault injection. timeout=<interval>,<probability>,<space>,<times>");
> static DECLARE_FAULT_ATTR(ufs_timeout_attr);
>
> -static int ufs_fault_get(char *buffer, const struct kernel_param *kp)
> +static int ufs_fault_get(struct seq_buf *buffer, const struct kernel_param *kp)
> {
> const char *fault_str = kp->arg;
>
> - return sysfs_emit(buffer, "%s\n", fault_str);
> + seq_buf_printf(buffer, "%s\n", fault_str);
> + return 0;
> }
>
> static int ufs_fault_set(const char *val, const struct kernel_param *kp)
> diff --git a/drivers/vhost/scsi.c b/drivers/vhost/scsi.c
> index fd52f2213e27..23ca63ebf3d2 100644
> --- a/drivers/vhost/scsi.c
> +++ b/drivers/vhost/scsi.c
> @@ -81,10 +81,11 @@ static int vhost_scsi_set_inline_sg_cnt(const char *buf,
> }
> #endif
>
> -static int vhost_scsi_get_inline_sg_cnt(char *buf,
> +static int vhost_scsi_get_inline_sg_cnt(struct seq_buf *buf,
> const struct kernel_param *kp)
> {
> - return sprintf(buf, "%u\n", vhost_scsi_inline_sg_cnt);
> + seq_buf_printf(buf, "%u\n", vhost_scsi_inline_sg_cnt);
> + return 0;
> }
>
> static DEFINE_KERNEL_PARAM_OPS(vhost_scsi_inline_sg_cnt_op,
> diff --git a/fs/nfs/namespace.c b/fs/nfs/namespace.c
> index f2fba60dc5ed..5b7debe5274b 100644
> --- a/fs/nfs/namespace.c
> +++ b/fs/nfs/namespace.c
> @@ -358,7 +358,8 @@ static int param_set_nfs_timeout(const char *val, const struct kernel_param *kp)
> return 0;
> }
>
> -static int param_get_nfs_timeout(char *buffer, const struct kernel_param *kp)
> +static int param_get_nfs_timeout(struct seq_buf *buffer,
> + const struct kernel_param *kp)
> {
> long num = *((int *)kp->arg);
>
> @@ -369,7 +370,8 @@ static int param_get_nfs_timeout(char *buffer, const struct kernel_param *kp)
> num = (num + (HZ - 1)) / HZ;
> } else
> num = -1;
> - return sysfs_emit(buffer, "%li\n", num);
> + seq_buf_printf(buffer, "%li\n", num);
> + return 0;
> }
>
> static DEFINE_KERNEL_PARAM_OPS(param_ops_nfs_timeout, param_set_nfs_timeout,
> diff --git a/fs/ocfs2/dlmfs/dlmfs.c b/fs/ocfs2/dlmfs/dlmfs.c
> index 5821e33df78f..8fd759d31ff9 100644
> --- a/fs/ocfs2/dlmfs/dlmfs.c
> +++ b/fs/ocfs2/dlmfs/dlmfs.c
> @@ -78,10 +78,11 @@ static int param_set_dlmfs_capabilities(const char *val,
> printk(KERN_ERR "%s: readonly parameter\n", kp->name);
> return -EINVAL;
> }
> -static int param_get_dlmfs_capabilities(char *buffer,
> +static int param_get_dlmfs_capabilities(struct seq_buf *buffer,
> const struct kernel_param *kp)
> {
> - return sysfs_emit(buffer, DLMFS_CAPABILITIES);
> + seq_buf_printf(buffer, DLMFS_CAPABILITIES);
> + return 0;
> }
> module_param_call(capabilities, param_set_dlmfs_capabilities,
> param_get_dlmfs_capabilities, NULL, 0444);
> diff --git a/fs/overlayfs/copy_up.c b/fs/overlayfs/copy_up.c
> index 13cb60b52bd6..d9a21b813b4f 100644
> --- a/fs/overlayfs/copy_up.c
> +++ b/fs/overlayfs/copy_up.c
> @@ -28,9 +28,10 @@ static int ovl_ccup_set(const char *buf, const struct kernel_param *param)
> return 0;
> }
>
> -static int ovl_ccup_get(char *buf, const struct kernel_param *param)
> +static int ovl_ccup_get(struct seq_buf *buf, const struct kernel_param *param)
> {
> - return sprintf(buf, "N\n");
> + seq_buf_printf(buf, "N\n");
> + return 0;
> }
>
> module_param_call(check_copy_up, ovl_ccup_set, ovl_ccup_get, NULL, 0644);
> diff --git a/kernel/locking/locktorture.c b/kernel/locking/locktorture.c
> index 38ae3b596ef2..9c9b6dc25888 100644
> --- a/kernel/locking/locktorture.c
> +++ b/kernel/locking/locktorture.c
> @@ -86,11 +86,13 @@ static int param_set_cpumask(const char *val, const struct kernel_param *kp)
> }
>
> // Output a cpumask kernel parameter.
> -static int param_get_cpumask(char *buffer, const struct kernel_param *kp)
> +static int param_get_cpumask(struct seq_buf *buffer,
> + const struct kernel_param *kp)
> {
> cpumask_var_t *cm_bind = kp->arg;
>
> - return sprintf(buffer, "%*pbl", cpumask_pr_args(*cm_bind));
> + seq_buf_printf(buffer, "%*pbl", cpumask_pr_args(*cm_bind));
> + return 0;
> }
>
> static bool cpumask_nonempty(cpumask_var_t mask)
> diff --git a/kernel/rcu/tree.c b/kernel/rcu/tree.c
> index e675d7f1b4ee..ffbbb7d4ff2a 100644
> --- a/kernel/rcu/tree.c
> +++ b/kernel/rcu/tree.c
> @@ -3970,9 +3970,11 @@ static int param_set_do_rcu_barrier(const char *val, const struct kernel_param *
> /*
> * Output the number of outstanding rcutree.do_rcu_barrier requests.
> */
> -static int param_get_do_rcu_barrier(char *buffer, const struct kernel_param *kp)
> +static int param_get_do_rcu_barrier(struct seq_buf *buffer,
> + const struct kernel_param *kp)
> {
> - return sprintf(buffer, "%d\n", atomic_read((atomic_t *)kp->arg));
> + seq_buf_printf(buffer, "%d\n", atomic_read((atomic_t *)kp->arg));
> + return 0;
> }
>
> static DEFINE_KERNEL_PARAM_OPS(do_rcu_barrier_ops, param_set_do_rcu_barrier,
> diff --git a/kernel/workqueue.c b/kernel/workqueue.c
> index 42562b811d94..3fe338d2ca64 100644
> --- a/kernel/workqueue.c
> +++ b/kernel/workqueue.c
> @@ -7157,9 +7157,11 @@ static int wq_affn_dfl_set(const char *val, const struct kernel_param *kp)
> return 0;
> }
>
> -static int wq_affn_dfl_get(char *buffer, const struct kernel_param *kp)
> +static int wq_affn_dfl_get(struct seq_buf *buffer,
> + const struct kernel_param *kp)
> {
> - return scnprintf(buffer, PAGE_SIZE, "%s\n", wq_affn_names[wq_affn_dfl]);
> + seq_buf_printf(buffer, "%s\n", wq_affn_names[wq_affn_dfl]);
> + return 0;
> }
>
> static DEFINE_KERNEL_PARAM_OPS(wq_affn_dfl_ops, wq_affn_dfl_set,
> diff --git a/lib/test_dynamic_debug.c b/lib/test_dynamic_debug.c
> index 30880b6c726a..70faf8ede76d 100644
> --- a/lib/test_dynamic_debug.c
> +++ b/lib/test_dynamic_debug.c
> @@ -18,10 +18,12 @@ static int param_set_do_prints(const char *instr, const struct kernel_param *kp)
> do_prints();
> return 0;
> }
> -static int param_get_do_prints(char *buffer, const struct kernel_param *kp)
> +static int param_get_do_prints(struct seq_buf *buffer,
> + const struct kernel_param *kp)
> {
> do_prints();
> - return scnprintf(buffer, PAGE_SIZE, "did do_prints\n");
> + seq_buf_printf(buffer, "did do_prints\n");
> + return 0;
> }
> static DEFINE_KERNEL_PARAM_OPS(param_ops_do_prints, param_set_do_prints,
> param_get_do_prints);
> diff --git a/mm/damon/lru_sort.c b/mm/damon/lru_sort.c
> index 5feb93c5262e..84e607f76126 100644
> --- a/mm/damon/lru_sort.c
> +++ b/mm/damon/lru_sort.c
> @@ -438,10 +438,11 @@ static int damon_lru_sort_enabled_store(const char *val,
> return damon_lru_sort_turn(enabled);
> }
>
> -static int damon_lru_sort_enabled_load(char *buffer,
> - const struct kernel_param *kp)
> +static int damon_lru_sort_enabled_load(struct seq_buf *buffer,
> + const struct kernel_param *kp)
> {
> - return sprintf(buffer, "%c\n", damon_lru_sort_enabled() ? 'Y' : 'N');
> + seq_buf_printf(buffer, "%c\n", damon_lru_sort_enabled() ? 'Y' : 'N');
> + return 0;
> }
>
> static DEFINE_KERNEL_PARAM_OPS(enabled_param_ops, damon_lru_sort_enabled_store,
> @@ -461,8 +462,8 @@ static int damon_lru_sort_kdamond_pid_store(const char *val,
> return 0;
> }
>
> -static int damon_lru_sort_kdamond_pid_load(char *buffer,
> - const struct kernel_param *kp)
> +static int damon_lru_sort_kdamond_pid_load(struct seq_buf *buffer,
> + const struct kernel_param *kp)
> {
> int kdamond_pid = -1;
>
> @@ -471,7 +472,8 @@ static int damon_lru_sort_kdamond_pid_load(char *buffer,
> if (kdamond_pid < 0)
> kdamond_pid = -1;
> }
> - return sprintf(buffer, "%d\n", kdamond_pid);
> + seq_buf_printf(buffer, "%d\n", kdamond_pid);
> + return 0;
> }
>
> static DEFINE_KERNEL_PARAM_OPS(kdamond_pid_param_ops,
> diff --git a/mm/damon/reclaim.c b/mm/damon/reclaim.c
> index 27e772b095fa..546bdf356a40 100644
> --- a/mm/damon/reclaim.c
> +++ b/mm/damon/reclaim.c
> @@ -340,10 +340,11 @@ static int damon_reclaim_enabled_store(const char *val,
> return damon_reclaim_turn(enabled);
> }
>
> -static int damon_reclaim_enabled_load(char *buffer,
> - const struct kernel_param *kp)
> +static int damon_reclaim_enabled_load(struct seq_buf *buffer,
> + const struct kernel_param *kp)
> {
> - return sprintf(buffer, "%c\n", damon_reclaim_enabled() ? 'Y' : 'N');
> + seq_buf_printf(buffer, "%c\n", damon_reclaim_enabled() ? 'Y' : 'N');
> + return 0;
> }
>
> static DEFINE_KERNEL_PARAM_OPS(enabled_param_ops, damon_reclaim_enabled_store,
> @@ -363,8 +364,8 @@ static int damon_reclaim_kdamond_pid_store(const char *val,
> return 0;
> }
>
> -static int damon_reclaim_kdamond_pid_load(char *buffer,
> - const struct kernel_param *kp)
> +static int damon_reclaim_kdamond_pid_load(struct seq_buf *buffer,
> + const struct kernel_param *kp)
> {
> int kdamond_pid = -1;
>
> @@ -373,7 +374,8 @@ static int damon_reclaim_kdamond_pid_load(char *buffer,
> if (kdamond_pid < 0)
> kdamond_pid = -1;
> }
> - return sprintf(buffer, "%d\n", kdamond_pid);
> + seq_buf_printf(buffer, "%d\n", kdamond_pid);
> + return 0;
> }
>
> static DEFINE_KERNEL_PARAM_OPS(kdamond_pid_param_ops,
> diff --git a/mm/damon/stat.c b/mm/damon/stat.c
> index 6eb548793802..70d6b477fc0b 100644
> --- a/mm/damon/stat.c
> +++ b/mm/damon/stat.c
> @@ -19,8 +19,8 @@
> static int damon_stat_enabled_store(
> const char *val, const struct kernel_param *kp);
>
> -static int damon_stat_enabled_load(char *buffer,
> - const struct kernel_param *kp);
> +static int damon_stat_enabled_load(struct seq_buf *buffer,
> + const struct kernel_param *kp);
>
> static DEFINE_KERNEL_PARAM_OPS(enabled_param_ops, damon_stat_enabled_store,
> damon_stat_enabled_load);
> @@ -306,9 +306,11 @@ static int damon_stat_enabled_store(
> return 0;
> }
>
> -static int damon_stat_enabled_load(char *buffer, const struct kernel_param *kp)
> +static int damon_stat_enabled_load(struct seq_buf *buffer,
> + const struct kernel_param *kp)
> {
> - return sprintf(buffer, "%c\n", damon_stat_enabled() ? 'Y' : 'N');
> + seq_buf_printf(buffer, "%c\n", damon_stat_enabled() ? 'Y' : 'N');
> + return 0;
> }
>
> static int __init damon_stat_init(void)
> diff --git a/mm/memory_hotplug.c b/mm/memory_hotplug.c
> index 42e0cf313281..887c18a193ac 100644
> --- a/mm/memory_hotplug.c
> +++ b/mm/memory_hotplug.c
> @@ -100,13 +100,17 @@ static int set_memmap_mode(const char *val, const struct kernel_param *kp)
> return 0;
> }
>
> -static int get_memmap_mode(char *buffer, const struct kernel_param *kp)
> +static int get_memmap_mode(struct seq_buf *buffer,
> + const struct kernel_param *kp)
> {
> int mode = *((int *)kp->arg);
>
> - if (mode == MEMMAP_ON_MEMORY_FORCE)
> - return sprintf(buffer, "force\n");
> - return sprintf(buffer, "%c\n", mode ? 'Y' : 'N');
> + if (mode == MEMMAP_ON_MEMORY_FORCE) {
> + seq_buf_printf(buffer, "force\n");
> + return 0;
> + }
> + seq_buf_printf(buffer, "%c\n", mode ? 'Y' : 'N');
> + return 0;
> }
>
> static DEFINE_KERNEL_PARAM_OPS(memmap_mode_ops, set_memmap_mode,
> @@ -147,9 +151,11 @@ static int set_online_policy(const char *val, const struct kernel_param *kp)
> return 0;
> }
>
> -static int get_online_policy(char *buffer, const struct kernel_param *kp)
> +static int get_online_policy(struct seq_buf *buffer,
> + const struct kernel_param *kp)
> {
> - return sprintf(buffer, "%s\n", online_policy_to_str[*((int *)kp->arg)]);
> + seq_buf_printf(buffer, "%s\n", online_policy_to_str[*((int *)kp->arg)]);
> + return 0;
> }
>
> /*
> diff --git a/net/ceph/ceph_common.c b/net/ceph/ceph_common.c
> index 633202a99e4a..583b11a2489c 100644
> --- a/net/ceph/ceph_common.c
> +++ b/net/ceph/ceph_common.c
> @@ -47,10 +47,11 @@ bool libceph_compatible(void *data)
> }
> EXPORT_SYMBOL(libceph_compatible);
>
> -static int param_get_supported_features(char *buffer,
> +static int param_get_supported_features(struct seq_buf *buffer,
> const struct kernel_param *kp)
> {
> - return sprintf(buffer, "0x%llx", CEPH_FEATURES_SUPPORTED_DEFAULT);
> + seq_buf_printf(buffer, "0x%llx", CEPH_FEATURES_SUPPORTED_DEFAULT);
> + return 0;
> }
> static DEFINE_KERNEL_PARAM_OPS(param_ops_supported_features, NULL,
> param_get_supported_features);
> diff --git a/net/sunrpc/auth.c b/net/sunrpc/auth.c
> index 64a3e894fd4c..5a2b64dcf9e5 100644
> --- a/net/sunrpc/auth.c
> +++ b/net/sunrpc/auth.c
> @@ -73,12 +73,14 @@ static int param_set_hashtbl_sz(const char *val, const struct kernel_param *kp)
> return -EINVAL;
> }
>
> -static int param_get_hashtbl_sz(char *buffer, const struct kernel_param *kp)
> +static int param_get_hashtbl_sz(struct seq_buf *buffer,
> + const struct kernel_param *kp)
> {
> unsigned int nbits;
>
> nbits = *(unsigned int *)kp->arg;
> - return sprintf(buffer, "%u\n", 1U << nbits);
> + seq_buf_printf(buffer, "%u\n", 1U << nbits);
> + return 0;
> }
>
> #define param_check_hashtbl_sz(name, p) __param_check(name, p, unsigned int);
> diff --git a/net/sunrpc/svc.c b/net/sunrpc/svc.c
> index 576fa42e7abf..26b85077ecc8 100644
> --- a/net/sunrpc/svc.c
> +++ b/net/sunrpc/svc.c
> @@ -148,7 +148,7 @@ sunrpc_get_pool_mode(char *buf, size_t size)
> EXPORT_SYMBOL(sunrpc_get_pool_mode);
>
> static int
> -param_get_pool_mode(char *buf, const struct kernel_param *kp)
> +param_get_pool_mode(struct seq_buf *buf, const struct kernel_param *kp)
> {
> char str[16];
> int len;
> @@ -162,7 +162,8 @@ param_get_pool_mode(char *buf, const struct kernel_param *kp)
> str[len] = '\n';
> str[len + 1] = '\0';
>
> - return sysfs_emit(buf, "%s", str);
> + seq_buf_printf(buf, "%s", str);
> + return 0;
> }
>
> module_param_call(pool_mode, param_set_pool_mode, param_get_pool_mode,
> diff --git a/security/apparmor/lsm.c b/security/apparmor/lsm.c
> index a6815b4bd0da..748d08c57f60 100644
> --- a/security/apparmor/lsm.c
> +++ b/security/apparmor/lsm.c
> @@ -1797,10 +1797,11 @@ static int param_set_debug(const char *val, const struct kernel_param *kp);
> static int param_get_debug(struct seq_buf *buffer, const struct kernel_param *kp);
>
> static int param_set_audit(const char *val, const struct kernel_param *kp);
> -static int param_get_audit(char *buffer, const struct kernel_param *kp);
> +static int param_get_audit(struct seq_buf *buffer,
> + const struct kernel_param *kp);
>
> static int param_set_mode(const char *val, const struct kernel_param *kp);
> -static int param_get_mode(char *buffer, const struct kernel_param *kp);
> +static int param_get_mode(struct seq_buf *buffer, const struct kernel_param *kp);
>
> /* Flag values, also controllable via /sys/module/apparmor/parameters
> * We define special types as we want to do additional mediation.
> @@ -2050,13 +2051,15 @@ static int param_set_debug(const char *val, const struct kernel_param *kp)
> return 0;
> }
>
> -static int param_get_audit(char *buffer, const struct kernel_param *kp)
> +static int param_get_audit(struct seq_buf *buffer,
> + const struct kernel_param *kp)
> {
> if (!apparmor_enabled)
> return -EINVAL;
> if (apparmor_initialized && !aa_current_policy_view_capable(NULL))
> return -EPERM;
> - return sysfs_emit(buffer, "%s\n", audit_mode_names[aa_g_audit]);
> + seq_buf_printf(buffer, "%s\n", audit_mode_names[aa_g_audit]);
> + return 0;
> }
>
> static int param_set_audit(const char *val, const struct kernel_param *kp)
> @@ -2078,13 +2081,14 @@ static int param_set_audit(const char *val, const struct kernel_param *kp)
> return 0;
> }
>
> -static int param_get_mode(char *buffer, const struct kernel_param *kp)
> +static int param_get_mode(struct seq_buf *buffer, const struct kernel_param *kp)
> {
> if (!apparmor_enabled)
> return -EINVAL;
> if (apparmor_initialized && !aa_current_policy_view_capable(NULL))
> return -EPERM;
> - return sysfs_emit(buffer, "%s\n", aa_profile_mode_names[aa_g_profile_mode]);
> + seq_buf_printf(buffer, "%s\n", aa_profile_mode_names[aa_g_profile_mode]);
> + return 0;
> }
>
> static int param_set_mode(const char *val, const struct kernel_param *kp)
> --
> 2.34.1
>
^ permalink raw reply
* Re: [PATCH 04/11] treewide: Convert struct kernel_param_ops initializers to DEFINE_KERNEL_PARAM_OPS
From: Rafael J. Wysocki @ 2026-05-22 17:01 UTC (permalink / raw)
To: Kees Cook
Cc: Luis Chamberlain, Pengpeng Hou, Petr Pavlu, Richard Weinberger,
Anton Ivanov, Johannes Berg, Rafael J. Wysocki, Len Brown,
Corey Minyard, Gabriel Somlo, Michael S. Tsirkin, Jani Nikula,
Joonas Lahtinen, Rodrigo Vivi, Tvrtko Ursulin, David Airlie,
Simona Vetter, Bart Van Assche, Jason Gunthorpe, Leon Romanovsky,
Laurent Pinchart, Hans de Goede, Mauro Carvalho Chehab,
Bjorn Helgaas, Hannes Reinecke, James E.J. Bottomley,
Martin K. Petersen, Daniel Lezcano, Zhang Rui, Lukasz Luba,
Greg Kroah-Hartman, Jiri Slaby, Alan Stern, Jason Wang, Xuan Zhuo,
Eugenio Pérez, Jason Baron, Jim Cromie, Tiwei Bie,
Benjamin Berg, Ilpo Järvinen, David E. Box,
Maciej W. Rozycki, Srinivas Pandruvada, Peter Zijlstra,
Heiko Carstens, Vasily Gorbik, Sean Christopherson, Paolo Bonzini,
Thomas Gleixner, Ingo Molnar, Borislav Petkov, Dave Hansen, x86,
H. Peter Anvin, Vinod Koul, Frank Li, Daniel Gomez, Sami Tolvanen,
Aaron Tomlin, Alexander Potapenko, Marco Elver, Dmitry Vyukov,
Andrew Morton, John Johansen, Paul Moore, James Morris,
Serge E. Hallyn, Andy Shevchenko, Georgia Garcia, kvm, dmaengine,
linux-modules, kasan-dev, linux-mm, apparmor,
linux-security-module, linux-um, linux-acpi, openipmi-developer,
qemu-devel, intel-gfx, dri-devel, linux-rdma, linux-media,
linux-pci, linux-scsi, linux-pm, linuxppc-dev, linux-serial,
linux-usb, usb-storage, virtualization, linux-kernel, linux-arch,
netdev, linux-fsdevel, linux-hardening
In-Reply-To: <20260521133326.2465264-4-kees@kernel.org>
On Thu, May 21, 2026 at 3:33 PM Kees Cook <kees@kernel.org> wrote:
>
> Using Coccinelle, rewrite every struct kernel_param_ops initializer that
> sets .get into a DEFINE_KERNEL_PARAM_OPS-family macro invocation,
> for example:
>
> @@
> declarer name DEFINE_KERNEL_PARAM_OPS;
> identifier OPS;
> expression SET, GET;
> @@
> - const struct kernel_param_ops OPS = {
> - .set = SET,
> - .get = GET,
> - };
> + DEFINE_KERNEL_PARAM_OPS(OPS, SET, GET);
>
> Using the macro for initialization means future changes can manipulate
> the struct layout and callback prototypes without having to change every
> initializer.
>
> Signed-off-by: Kees Cook <kees@kernel.org>
For ACPI and hibernation:
Acked-by: Rafael J. Wysocki (Intel) <rafael@kernel.org>
> ---
> mm/kfence/core.c | 7 +-
> arch/powerpc/kvm/book3s_hv.c | 5 +-
> arch/s390/kernel/perf_cpum_sf.c | 6 +-
> arch/um/drivers/vfio_kern.c | 6 +-
> arch/um/drivers/virtio_uml.c | 6 +-
> arch/x86/kernel/msr.c | 6 +-
> arch/x86/kvm/mmu/mmu.c | 12 +--
> arch/x86/kvm/svm/avic.c | 6 +-
> arch/x86/kvm/vmx/vmx.c | 6 +-
> arch/x86/platform/uv/uv_nmi.c | 12 +--
> block/disk-events.c | 6 +-
> drivers/acpi/sysfs.c | 25 +++----
> drivers/block/loop.c | 12 +--
> drivers/block/null_blk/main.c | 12 +--
> drivers/block/rnbd/rnbd-srv.c | 6 +-
> drivers/block/ublk_drv.c | 7 +-
> drivers/char/ipmi/ipmi_msghandler.c | 6 +-
> drivers/char/ipmi/ipmi_watchdog.c | 17 ++---
> drivers/crypto/hisilicon/hpre/hpre_main.c | 16 +---
> drivers/crypto/hisilicon/sec2/sec_main.c | 23 ++----
> drivers/crypto/hisilicon/zip/zip_crypto.c | 5 +-
> drivers/crypto/hisilicon/zip/zip_main.c | 21 ++----
> drivers/dma/dmatest.c | 20 ++---
> drivers/edac/i10nm_base.c | 6 +-
> drivers/firmware/efi/efi-pstore.c | 6 +-
> drivers/firmware/qcom/qcom_scm.c | 6 +-
> drivers/firmware/qemu_fw_cfg.c | 6 +-
> drivers/gpu/drm/drm_panic.c | 6 +-
> drivers/gpu/drm/i915/i915_mitigations.c | 5 +-
> drivers/gpu/drm/imagination/pvr_fw_trace.c | 6 +-
> drivers/hid/hid-cougar.c | 6 +-
> drivers/hid/hid-steam.c | 6 +-
> drivers/infiniband/hw/hfi1/driver.c | 5 +-
> drivers/infiniband/ulp/iser/iscsi_iser.c | 6 +-
> drivers/infiniband/ulp/isert/ib_isert.c | 6 +-
> drivers/infiniband/ulp/srp/ib_srp.c | 5 +-
> drivers/input/misc/ati_remote2.c | 13 ++--
> drivers/input/mouse/psmouse-base.c | 6 +-
> drivers/media/usb/uvc/uvc_driver.c | 6 +-
> drivers/misc/lis3lv02d/lis3lv02d.c | 5 +-
> drivers/net/wireless/ath/wil6210/main.c | 10 +--
> drivers/nvme/host/multipath.c | 12 +--
> drivers/nvme/host/pci.c | 18 ++---
> drivers/nvme/target/rdma.c | 5 +-
> drivers/nvme/target/tcp.c | 5 +-
> drivers/platform/x86/acerhdf.c | 5 +-
> drivers/power/supply/bq27xxx_battery.c | 6 +-
> drivers/power/supply/test_power.c | 75 ++++++++-----------
> drivers/scsi/sg.c | 6 +-
> drivers/target/target_core_user.c | 13 ++--
> .../processor_thermal_soc_slider.c | 12 +--
> drivers/thermal/intel/intel_powerclamp.c | 20 +----
> drivers/tty/hvc/hvc_iucv.c | 6 +-
> drivers/tty/sysrq.c | 6 +-
> drivers/ufs/core/ufs-fault-injection.c | 5 +-
> drivers/ufs/core/ufs-mcq.c | 18 ++---
> drivers/ufs/core/ufs-txeq.c | 5 +-
> drivers/ufs/core/ufshcd.c | 12 +--
> drivers/usb/core/quirks.c | 6 +-
> drivers/usb/gadget/legacy/serial.c | 5 +-
> drivers/usb/storage/usb.c | 5 +-
> drivers/vhost/scsi.c | 7 +-
> drivers/virt/nitro_enclaves/ne_misc_dev.c | 6 +-
> drivers/virtio/virtio_mmio.c | 6 +-
> fs/ceph/super.c | 10 +--
> fs/fuse/dir.c | 5 +-
> fs/nfs/namespace.c | 6 +-
> fs/nfs/super.c | 6 +-
> fs/ubifs/super.c | 6 +-
> kernel/locking/locktorture.c | 6 +-
> kernel/panic.c | 6 +-
> kernel/params.c | 44 +++--------
> kernel/power/hibernate.c | 6 +-
> kernel/rcu/tree.c | 18 ++---
> kernel/sched/ext.c | 11 +--
> kernel/workqueue.c | 12 +--
> lib/dynamic_debug.c | 6 +-
> lib/test_dynamic_debug.c | 6 +-
> mm/damon/lru_sort.c | 19 ++---
> mm/damon/reclaim.c | 19 ++---
> mm/damon/stat.c | 6 +-
> mm/memory_hotplug.c | 12 +--
> mm/page_reporting.c | 11 +--
> mm/shuffle.c | 6 +-
> mm/zswap.c | 14 ++--
> net/batman-adv/bat_algo.c | 6 +-
> net/ceph/ceph_common.c | 5 +-
> net/ipv4/tcp_dctcp.c | 6 +-
> net/sunrpc/auth.c | 6 +-
> net/sunrpc/xprtsock.c | 18 ++---
> samples/damon/mtier.c | 6 +-
> samples/damon/prcl.c | 6 +-
> samples/damon/wsse.c | 6 +-
> security/apparmor/lsm.c | 34 +++------
> sound/hda/controllers/intel.c | 5 +-
> sound/usb/card.c | 7 +-
> 96 files changed, 307 insertions(+), 660 deletions(-)
>
> diff --git a/mm/kfence/core.c b/mm/kfence/core.c
> index 655dc5ce3240..e14102c01520 100644
> --- a/mm/kfence/core.c
> +++ b/mm/kfence/core.c
> @@ -92,10 +92,9 @@ static int param_get_sample_interval(char *buffer, const struct kernel_param *kp
> return param_get_ulong(buffer, kp);
> }
>
> -static const struct kernel_param_ops sample_interval_param_ops = {
> - .set = param_set_sample_interval,
> - .get = param_get_sample_interval,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(sample_interval_param_ops,
> + param_set_sample_interval,
> + param_get_sample_interval);
> module_param_cb(sample_interval, &sample_interval_param_ops, &kfence_sample_interval, 0600);
>
> /* Pool usage% threshold when currently covered allocations are skipped. */
> diff --git a/arch/powerpc/kvm/book3s_hv.c b/arch/powerpc/kvm/book3s_hv.c
> index 61dbeea317f3..0c15f0426671 100644
> --- a/arch/powerpc/kvm/book3s_hv.c
> +++ b/arch/powerpc/kvm/book3s_hv.c
> @@ -114,10 +114,7 @@ module_param(one_vm_per_core, bool, S_IRUGO | S_IWUSR);
> MODULE_PARM_DESC(one_vm_per_core, "Only run vCPUs from the same VM on a core (requires POWER8 or older)");
>
> #ifdef CONFIG_KVM_XICS
> -static const struct kernel_param_ops module_param_ops = {
> - .set = param_set_int,
> - .get = param_get_int,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(module_param_ops, param_set_int, param_get_int);
>
> module_param_cb(kvm_irq_bypass, &module_param_ops, &kvm_irq_bypass, 0644);
> MODULE_PARM_DESC(kvm_irq_bypass, "Bypass passthrough interrupt optimization");
> diff --git a/arch/s390/kernel/perf_cpum_sf.c b/arch/s390/kernel/perf_cpum_sf.c
> index 7bfeb5208177..76119542562b 100644
> --- a/arch/s390/kernel/perf_cpum_sf.c
> +++ b/arch/s390/kernel/perf_cpum_sf.c
> @@ -2029,10 +2029,8 @@ static int param_set_sfb_size(const char *val, const struct kernel_param *kp)
> }
>
> #define param_check_sfb_size(name, p) __param_check(name, p, void)
> -static const struct kernel_param_ops param_ops_sfb_size = {
> - .set = param_set_sfb_size,
> - .get = param_get_sfb_size,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(param_ops_sfb_size, param_set_sfb_size,
> + param_get_sfb_size);
>
> enum {
> RS_INIT_FAILURE_BSDES = 2, /* Bad basic sampling size */
> diff --git a/arch/um/drivers/vfio_kern.c b/arch/um/drivers/vfio_kern.c
> index e6dab473cde4..fb7988dc5482 100644
> --- a/arch/um/drivers/vfio_kern.c
> +++ b/arch/um/drivers/vfio_kern.c
> @@ -628,10 +628,8 @@ static int uml_vfio_cmdline_get(char *buffer, const struct kernel_param *kp)
> return 0;
> }
>
> -static const struct kernel_param_ops uml_vfio_cmdline_param_ops = {
> - .set = uml_vfio_cmdline_set,
> - .get = uml_vfio_cmdline_get,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(uml_vfio_cmdline_param_ops, uml_vfio_cmdline_set,
> + uml_vfio_cmdline_get);
>
> device_param_cb(device, ¨_vfio_cmdline_param_ops, NULL, 0400);
> __uml_help(uml_vfio_cmdline_param_ops,
> diff --git a/arch/um/drivers/virtio_uml.c b/arch/um/drivers/virtio_uml.c
> index 7425a8548141..f9ae745f4586 100644
> --- a/arch/um/drivers/virtio_uml.c
> +++ b/arch/um/drivers/virtio_uml.c
> @@ -1398,10 +1398,8 @@ static int vu_cmdline_get(char *buffer, const struct kernel_param *kp)
> return strlen(buffer) + 1;
> }
>
> -static const struct kernel_param_ops vu_cmdline_param_ops = {
> - .set = vu_cmdline_set,
> - .get = vu_cmdline_get,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(vu_cmdline_param_ops, vu_cmdline_set,
> + vu_cmdline_get);
>
> device_param_cb(device, &vu_cmdline_param_ops, NULL, S_IRUSR);
> __uml_help(vu_cmdline_param_ops,
> diff --git a/arch/x86/kernel/msr.c b/arch/x86/kernel/msr.c
> index 4469c784eaa0..5f4e1814dc4d 100644
> --- a/arch/x86/kernel/msr.c
> +++ b/arch/x86/kernel/msr.c
> @@ -322,10 +322,8 @@ static int get_allow_writes(char *buf, const struct kernel_param *kp)
> return sprintf(buf, "%s\n", res);
> }
>
> -static const struct kernel_param_ops allow_writes_ops = {
> - .set = set_allow_writes,
> - .get = get_allow_writes
> -};
> +static DEFINE_KERNEL_PARAM_OPS(allow_writes_ops, set_allow_writes,
> + get_allow_writes);
>
> module_param_cb(allow_writes, &allow_writes_ops, NULL, 0600);
>
> diff --git a/arch/x86/kvm/mmu/mmu.c b/arch/x86/kvm/mmu/mmu.c
> index 24fbc9ea502a..996818ee9b09 100644
> --- a/arch/x86/kvm/mmu/mmu.c
> +++ b/arch/x86/kvm/mmu/mmu.c
> @@ -74,15 +74,11 @@ static int get_nx_huge_pages(char *buffer, const struct kernel_param *kp);
> static int set_nx_huge_pages(const char *val, const struct kernel_param *kp);
> static int set_nx_huge_pages_recovery_param(const char *val, const struct kernel_param *kp);
>
> -static const struct kernel_param_ops nx_huge_pages_ops = {
> - .set = set_nx_huge_pages,
> - .get = get_nx_huge_pages,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(nx_huge_pages_ops, set_nx_huge_pages,
> + get_nx_huge_pages);
>
> -static const struct kernel_param_ops nx_huge_pages_recovery_param_ops = {
> - .set = set_nx_huge_pages_recovery_param,
> - .get = param_get_uint,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(nx_huge_pages_recovery_param_ops,
> + set_nx_huge_pages_recovery_param, param_get_uint);
>
> module_param_cb(nx_huge_pages, &nx_huge_pages_ops, &nx_huge_pages, 0644);
> __MODULE_PARM_TYPE(nx_huge_pages, "bool");
> diff --git a/arch/x86/kvm/svm/avic.c b/arch/x86/kvm/svm/avic.c
> index adf211860949..7907f9addff9 100644
> --- a/arch/x86/kvm/svm/avic.c
> +++ b/arch/x86/kvm/svm/avic.c
> @@ -87,11 +87,7 @@ static int avic_param_get(char *buffer, const struct kernel_param *kp)
> return param_get_bool(buffer, kp);
> }
>
> -static const struct kernel_param_ops avic_ops = {
> - .flags = KERNEL_PARAM_OPS_FL_NOARG,
> - .set = avic_param_set,
> - .get = avic_param_get,
> -};
> +static DEFINE_KERNEL_PARAM_OPS_NOARG(avic_ops, avic_param_set, avic_param_get);
>
> /*
> * Enable / disable AVIC. In "auto" mode (default behavior), AVIC is enabled
> diff --git a/arch/x86/kvm/vmx/vmx.c b/arch/x86/kvm/vmx/vmx.c
> index a29896a9ef14..07f4c7209ac0 100644
> --- a/arch/x86/kvm/vmx/vmx.c
> +++ b/arch/x86/kvm/vmx/vmx.c
> @@ -465,10 +465,8 @@ static int vmentry_l1d_flush_get(char *s, const struct kernel_param *kp)
> }
> #endif
>
> -static const struct kernel_param_ops vmentry_l1d_flush_ops = {
> - .set = vmentry_l1d_flush_set,
> - .get = vmentry_l1d_flush_get,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(vmentry_l1d_flush_ops, vmentry_l1d_flush_set,
> + vmentry_l1d_flush_get);
> module_param_cb(vmentry_l1d_flush, &vmentry_l1d_flush_ops, NULL, 0644);
>
> static __always_inline void vmx_disable_fb_clear(struct vcpu_vmx *vmx)
> diff --git a/arch/x86/platform/uv/uv_nmi.c b/arch/x86/platform/uv/uv_nmi.c
> index 5c50e550ab63..a7ac80b5f8d9 100644
> --- a/arch/x86/platform/uv/uv_nmi.c
> +++ b/arch/x86/platform/uv/uv_nmi.c
> @@ -123,10 +123,8 @@ static int param_set_local64(const char *val, const struct kernel_param *kp)
> return 0;
> }
>
> -static const struct kernel_param_ops param_ops_local64 = {
> - .get = param_get_local64,
> - .set = param_set_local64,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(param_ops_local64, param_set_local64,
> + param_get_local64);
> #define param_check_local64(name, p) __param_check(name, p, local64_t)
>
> static local64_t uv_nmi_count;
> @@ -232,10 +230,8 @@ static int param_set_action(const char *val, const struct kernel_param *kp)
> return -EINVAL;
> }
>
> -static const struct kernel_param_ops param_ops_action = {
> - .get = param_get_action,
> - .set = param_set_action,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(param_ops_action, param_set_action,
> + param_get_action);
> #define param_check_action(name, p) __param_check(name, p, enum action_t)
>
> module_param_named(action, uv_nmi_action, action, 0644);
> diff --git a/block/disk-events.c b/block/disk-events.c
> index 074731ecc3d2..f2d4b48294c6 100644
> --- a/block/disk-events.c
> +++ b/block/disk-events.c
> @@ -416,10 +416,8 @@ static int disk_events_set_dfl_poll_msecs(const char *val,
> return 0;
> }
>
> -static const struct kernel_param_ops disk_events_dfl_poll_msecs_param_ops = {
> - .set = disk_events_set_dfl_poll_msecs,
> - .get = param_get_ulong,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(disk_events_dfl_poll_msecs_param_ops,
> + disk_events_set_dfl_poll_msecs, param_get_ulong);
>
> #undef MODULE_PARAM_PREFIX
> #define MODULE_PARAM_PREFIX "block."
> diff --git a/drivers/acpi/sysfs.c b/drivers/acpi/sysfs.c
> index a625de3c3c8b..3d32a5280432 100644
> --- a/drivers/acpi/sysfs.c
> +++ b/drivers/acpi/sysfs.c
> @@ -138,15 +138,11 @@ static int param_get_debug_level(char *buffer, const struct kernel_param *kp)
> return result;
> }
>
> -static const struct kernel_param_ops param_ops_debug_layer = {
> - .set = param_set_uint,
> - .get = param_get_debug_layer,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(param_ops_debug_layer, param_set_uint,
> + param_get_debug_layer);
>
> -static const struct kernel_param_ops param_ops_debug_level = {
> - .set = param_set_uint,
> - .get = param_get_debug_level,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(param_ops_debug_level, param_set_uint,
> + param_get_debug_level);
>
> module_param_cb(debug_layer, ¶m_ops_debug_layer, &acpi_dbg_layer, 0644);
> module_param_cb(debug_level, ¶m_ops_debug_level, &acpi_dbg_level, 0644);
> @@ -201,15 +197,12 @@ static int param_get_trace_method_name(char *buffer, const struct kernel_param *
> return sysfs_emit(buffer, "%s\n", acpi_gbl_trace_method_name);
> }
>
> -static const struct kernel_param_ops param_ops_trace_method = {
> - .set = param_set_trace_method_name,
> - .get = param_get_trace_method_name,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(param_ops_trace_method,
> + param_set_trace_method_name,
> + param_get_trace_method_name);
>
> -static const struct kernel_param_ops param_ops_trace_attrib = {
> - .set = param_set_uint,
> - .get = param_get_uint,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(param_ops_trace_attrib, param_set_uint,
> + param_get_uint);
>
> module_param_cb(trace_method_name, ¶m_ops_trace_method, &trace_method_name, 0644);
> module_param_cb(trace_debug_layer, ¶m_ops_trace_attrib, &acpi_gbl_trace_dbg_layer, 0644);
> diff --git a/drivers/block/loop.c b/drivers/block/loop.c
> index 0000913f7efc..147ad561e584 100644
> --- a/drivers/block/loop.c
> +++ b/drivers/block/loop.c
> @@ -1806,10 +1806,8 @@ static int max_loop_param_set_int(const char *val,
> return 0;
> }
>
> -static const struct kernel_param_ops max_loop_param_ops = {
> - .set = max_loop_param_set_int,
> - .get = param_get_int,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(max_loop_param_ops, max_loop_param_set_int,
> + param_get_int);
>
> module_param_cb(max_loop, &max_loop_param_ops, &max_loop, 0444);
> MODULE_PARM_DESC(max_loop, "Maximum number of loop devices");
> @@ -1836,10 +1834,8 @@ static int loop_set_hw_queue_depth(const char *s, const struct kernel_param *p)
> return 0;
> }
>
> -static const struct kernel_param_ops loop_hw_qdepth_param_ops = {
> - .set = loop_set_hw_queue_depth,
> - .get = param_get_int,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(loop_hw_qdepth_param_ops,
> + loop_set_hw_queue_depth, param_get_int);
>
> device_param_cb(hw_queue_depth, &loop_hw_qdepth_param_ops, &hw_queue_depth, 0444);
> MODULE_PARM_DESC(hw_queue_depth, "Queue depth for each hardware queue. Default: " __stringify(LOOP_DEFAULT_HW_Q_DEPTH));
> diff --git a/drivers/block/null_blk/main.c b/drivers/block/null_blk/main.c
> index f8c0fd57e041..332ad6ac838a 100644
> --- a/drivers/block/null_blk/main.c
> +++ b/drivers/block/null_blk/main.c
> @@ -149,10 +149,8 @@ static int null_set_queue_mode(const char *str, const struct kernel_param *kp)
> return null_param_store_val(str, &g_queue_mode, NULL_Q_BIO, NULL_Q_MQ);
> }
>
> -static const struct kernel_param_ops null_queue_mode_param_ops = {
> - .set = null_set_queue_mode,
> - .get = param_get_int,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(null_queue_mode_param_ops, null_set_queue_mode,
> + param_get_int);
>
> device_param_cb(queue_mode, &null_queue_mode_param_ops, &g_queue_mode, 0444);
> MODULE_PARM_DESC(queue_mode, "Block interface to use (0=bio,1=rq,2=multiqueue)");
> @@ -193,10 +191,8 @@ static int null_set_irqmode(const char *str, const struct kernel_param *kp)
> NULL_IRQ_TIMER);
> }
>
> -static const struct kernel_param_ops null_irqmode_param_ops = {
> - .set = null_set_irqmode,
> - .get = param_get_int,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(null_irqmode_param_ops, null_set_irqmode,
> + param_get_int);
>
> device_param_cb(irqmode, &null_irqmode_param_ops, &g_irqmode, 0444);
> MODULE_PARM_DESC(irqmode, "IRQ completion handler. 0-none, 1-softirq, 2-timer");
> diff --git a/drivers/block/rnbd/rnbd-srv.c b/drivers/block/rnbd/rnbd-srv.c
> index 10e8c438bb43..81961f7c883a 100644
> --- a/drivers/block/rnbd/rnbd-srv.c
> +++ b/drivers/block/rnbd/rnbd-srv.c
> @@ -49,10 +49,8 @@ static struct kparam_string dev_search_path_kparam_str = {
> .string = dev_search_path
> };
>
> -static const struct kernel_param_ops dev_search_path_ops = {
> - .set = dev_search_path_set,
> - .get = param_get_string,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(dev_search_path_ops, dev_search_path_set,
> + param_get_string);
>
> module_param_cb(dev_search_path, &dev_search_path_ops,
> &dev_search_path_kparam_str, 0444);
> diff --git a/drivers/block/ublk_drv.c b/drivers/block/ublk_drv.c
> index 8e5f3738c203..f7bf7ea2d088 100644
> --- a/drivers/block/ublk_drv.c
> +++ b/drivers/block/ublk_drv.c
> @@ -5874,10 +5874,9 @@ static int ublk_get_max_unprivileged_ublks(char *buf,
> return sysfs_emit(buf, "%u\n", unprivileged_ublks_max);
> }
>
> -static const struct kernel_param_ops ublk_max_unprivileged_ublks_ops = {
> - .set = ublk_set_max_unprivileged_ublks,
> - .get = ublk_get_max_unprivileged_ublks,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(ublk_max_unprivileged_ublks_ops,
> + ublk_set_max_unprivileged_ublks,
> + ublk_get_max_unprivileged_ublks);
>
> module_param_cb(ublks_max, &ublk_max_unprivileged_ublks_ops,
> &unprivileged_ublks_max, 0644);
> diff --git a/drivers/char/ipmi/ipmi_msghandler.c b/drivers/char/ipmi/ipmi_msghandler.c
> index 869ac87a4b6a..b5fed11707e8 100644
> --- a/drivers/char/ipmi/ipmi_msghandler.c
> +++ b/drivers/char/ipmi/ipmi_msghandler.c
> @@ -102,10 +102,8 @@ static int panic_op_read_handler(char *buffer, const struct kernel_param *kp)
> return sprintf(buffer, "%s\n", event_str);
> }
>
> -static const struct kernel_param_ops panic_op_ops = {
> - .set = panic_op_write_handler,
> - .get = panic_op_read_handler
> -};
> +static DEFINE_KERNEL_PARAM_OPS(panic_op_ops, panic_op_write_handler,
> + panic_op_read_handler);
> module_param_cb(panic_op, &panic_op_ops, NULL, 0600);
> MODULE_PARM_DESC(panic_op, "Sets if the IPMI driver will attempt to store panic information in the event log in the event of a panic. Set to 'none' for no, 'event' for a single event, or 'string' for a generic event and the panic string in IPMI OEM events.");
>
> diff --git a/drivers/char/ipmi/ipmi_watchdog.c b/drivers/char/ipmi/ipmi_watchdog.c
> index a013ddbf1466..91a99417d204 100644
> --- a/drivers/char/ipmi/ipmi_watchdog.c
> +++ b/drivers/char/ipmi/ipmi_watchdog.c
> @@ -193,10 +193,8 @@ static int set_param_timeout(const char *val, const struct kernel_param *kp)
> return rv;
> }
>
> -static const struct kernel_param_ops param_ops_timeout = {
> - .set = set_param_timeout,
> - .get = param_get_int,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(param_ops_timeout, set_param_timeout,
> + param_get_int);
> #define param_check_timeout param_check_int
>
> typedef int (*action_fn)(const char *intval, char *outval);
> @@ -259,17 +257,12 @@ static int set_param_wdog_ifnum(const char *val, const struct kernel_param *kp)
> return 0;
> }
>
> -static const struct kernel_param_ops param_ops_wdog_ifnum = {
> - .set = set_param_wdog_ifnum,
> - .get = param_get_int,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(param_ops_wdog_ifnum, set_param_wdog_ifnum,
> + param_get_int);
>
> #define param_check_wdog_ifnum param_check_int
>
> -static const struct kernel_param_ops param_ops_str = {
> - .set = set_param_str,
> - .get = get_param_str,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(param_ops_str, set_param_str, get_param_str);
>
> module_param(ifnum_to_use, wdog_ifnum, 0644);
> MODULE_PARM_DESC(ifnum_to_use, "The interface number to use for the watchdog "
> diff --git a/drivers/crypto/hisilicon/hpre/hpre_main.c b/drivers/crypto/hisilicon/hpre/hpre_main.c
> index 357ab5e5887e..1104184c2f63 100644
> --- a/drivers/crypto/hisilicon/hpre/hpre_main.c
> +++ b/drivers/crypto/hisilicon/hpre/hpre_main.c
> @@ -420,10 +420,8 @@ static int hpre_cluster_regs_show(struct seq_file *s, void *unused)
>
> DEFINE_SHOW_ATTRIBUTE(hpre_cluster_regs);
>
> -static const struct kernel_param_ops hpre_uacce_mode_ops = {
> - .set = uacce_mode_set,
> - .get = param_get_int,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(hpre_uacce_mode_ops, uacce_mode_set,
> + param_get_int);
>
> /*
> * uacce_mode = 0 means hpre only register to crypto,
> @@ -441,19 +439,13 @@ static int pf_q_num_set(const char *val, const struct kernel_param *kp)
> return hisi_qm_q_num_set(val, kp, PCI_DEVICE_ID_HUAWEI_HPRE_PF);
> }
>
> -static const struct kernel_param_ops hpre_pf_q_num_ops = {
> - .set = pf_q_num_set,
> - .get = param_get_int,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(hpre_pf_q_num_ops, pf_q_num_set, param_get_int);
>
> static u32 pf_q_num = HPRE_PF_DEF_Q_NUM;
> module_param_cb(pf_q_num, &hpre_pf_q_num_ops, &pf_q_num, 0444);
> MODULE_PARM_DESC(pf_q_num, "Number of queues in PF of CS(2-1024)");
>
> -static const struct kernel_param_ops vfs_num_ops = {
> - .set = vfs_num_set,
> - .get = param_get_int,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(vfs_num_ops, vfs_num_set, param_get_int);
>
> static u32 vfs_num;
> module_param_cb(vfs_num, &vfs_num_ops, &vfs_num, 0444);
> diff --git a/drivers/crypto/hisilicon/sec2/sec_main.c b/drivers/crypto/hisilicon/sec2/sec_main.c
> index 056bd8f4da5a..3d13f2faa3d0 100644
> --- a/drivers/crypto/hisilicon/sec2/sec_main.c
> +++ b/drivers/crypto/hisilicon/sec2/sec_main.c
> @@ -362,10 +362,8 @@ static int sec_pf_q_num_set(const char *val, const struct kernel_param *kp)
> return hisi_qm_q_num_set(val, kp, PCI_DEVICE_ID_HUAWEI_SEC_PF);
> }
>
> -static const struct kernel_param_ops sec_pf_q_num_ops = {
> - .set = sec_pf_q_num_set,
> - .get = param_get_int,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(sec_pf_q_num_ops, sec_pf_q_num_set,
> + param_get_int);
>
> static u32 pf_q_num = SEC_PF_DEF_Q_NUM;
> module_param_cb(pf_q_num, &sec_pf_q_num_ops, &pf_q_num, 0444);
> @@ -391,18 +389,13 @@ static int sec_ctx_q_num_set(const char *val, const struct kernel_param *kp)
> return param_set_int(val, kp);
> }
>
> -static const struct kernel_param_ops sec_ctx_q_num_ops = {
> - .set = sec_ctx_q_num_set,
> - .get = param_get_int,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(sec_ctx_q_num_ops, sec_ctx_q_num_set,
> + param_get_int);
> static u32 ctx_q_num = SEC_CTX_Q_NUM_DEF;
> module_param_cb(ctx_q_num, &sec_ctx_q_num_ops, &ctx_q_num, 0444);
> MODULE_PARM_DESC(ctx_q_num, "Queue num in ctx (2 default, 2, 4, ..., 32)");
>
> -static const struct kernel_param_ops vfs_num_ops = {
> - .set = vfs_num_set,
> - .get = param_get_int,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(vfs_num_ops, vfs_num_set, param_get_int);
>
> static u32 vfs_num;
> module_param_cb(vfs_num, &vfs_num_ops, &vfs_num, 0444);
> @@ -454,10 +447,8 @@ u64 sec_get_alg_bitmap(struct hisi_qm *qm, u32 high, u32 low)
> return ((u64)cap_val_h << SEC_ALG_BITMAP_SHIFT) | (u64)cap_val_l;
> }
>
> -static const struct kernel_param_ops sec_uacce_mode_ops = {
> - .set = uacce_mode_set,
> - .get = param_get_int,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(sec_uacce_mode_ops, uacce_mode_set,
> + param_get_int);
>
> /*
> * uacce_mode = 0 means sec only register to crypto,
> diff --git a/drivers/crypto/hisilicon/zip/zip_crypto.c b/drivers/crypto/hisilicon/zip/zip_crypto.c
> index 70adde049b53..8f8d57420fb4 100644
> --- a/drivers/crypto/hisilicon/zip/zip_crypto.c
> +++ b/drivers/crypto/hisilicon/zip/zip_crypto.c
> @@ -108,10 +108,7 @@ static int sgl_sge_nr_set(const char *val, const struct kernel_param *kp)
> return param_set_ushort(val, kp);
> }
>
> -static const struct kernel_param_ops sgl_sge_nr_ops = {
> - .set = sgl_sge_nr_set,
> - .get = param_get_ushort,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(sgl_sge_nr_ops, sgl_sge_nr_set, param_get_ushort);
>
> static u16 sgl_sge_nr = HZIP_SGL_SGE_NR;
> module_param_cb(sgl_sge_nr, &sgl_sge_nr_ops, &sgl_sge_nr, 0444);
> diff --git a/drivers/crypto/hisilicon/zip/zip_main.c b/drivers/crypto/hisilicon/zip/zip_main.c
> index 44df9c859bd8..e07d0cf8eca8 100644
> --- a/drivers/crypto/hisilicon/zip/zip_main.c
> +++ b/drivers/crypto/hisilicon/zip/zip_main.c
> @@ -394,10 +394,7 @@ static int perf_mode_set(const char *val, const struct kernel_param *kp)
> return param_set_int(val, kp);
> }
>
> -static const struct kernel_param_ops zip_com_perf_ops = {
> - .set = perf_mode_set,
> - .get = param_get_int,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(zip_com_perf_ops, perf_mode_set, param_get_int);
>
> /*
> * perf_mode = 0 means enable high compression rate mode,
> @@ -408,10 +405,8 @@ static u32 perf_mode = HZIP_HIGH_COMP_RATE;
> module_param_cb(perf_mode, &zip_com_perf_ops, &perf_mode, 0444);
> MODULE_PARM_DESC(perf_mode, "ZIP high perf mode 0(default), 1(enable)");
>
> -static const struct kernel_param_ops zip_uacce_mode_ops = {
> - .set = uacce_mode_set,
> - .get = param_get_int,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(zip_uacce_mode_ops, uacce_mode_set,
> + param_get_int);
>
> /*
> * uacce_mode = 0 means zip only register to crypto,
> @@ -429,19 +424,13 @@ static int pf_q_num_set(const char *val, const struct kernel_param *kp)
> return hisi_qm_q_num_set(val, kp, PCI_DEVICE_ID_HUAWEI_ZIP_PF);
> }
>
> -static const struct kernel_param_ops pf_q_num_ops = {
> - .set = pf_q_num_set,
> - .get = param_get_int,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(pf_q_num_ops, pf_q_num_set, param_get_int);
>
> static u32 pf_q_num = HZIP_PF_DEF_Q_NUM;
> module_param_cb(pf_q_num, &pf_q_num_ops, &pf_q_num, 0444);
> MODULE_PARM_DESC(pf_q_num, "Number of queues in PF(v1 2-4096, v2 2-1024)");
>
> -static const struct kernel_param_ops vfs_num_ops = {
> - .set = vfs_num_set,
> - .get = param_get_int,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(vfs_num_ops, vfs_num_set, param_get_int);
>
> static u32 vfs_num;
> module_param_cb(vfs_num, &vfs_num_ops, &vfs_num, 0444);
> diff --git a/drivers/dma/dmatest.c b/drivers/dma/dmatest.c
> index df38681a1ff4..a7bddadcc52d 100644
> --- a/drivers/dma/dmatest.c
> +++ b/drivers/dma/dmatest.c
> @@ -154,20 +154,15 @@ static struct dmatest_info {
>
> static int dmatest_run_set(const char *val, const struct kernel_param *kp);
> static int dmatest_run_get(char *val, const struct kernel_param *kp);
> -static const struct kernel_param_ops run_ops = {
> - .set = dmatest_run_set,
> - .get = dmatest_run_get,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(run_ops, dmatest_run_set, dmatest_run_get);
> static bool dmatest_run;
> module_param_cb(run, &run_ops, &dmatest_run, 0644);
> MODULE_PARM_DESC(run, "Run the test (default: false)");
>
> static int dmatest_chan_set(const char *val, const struct kernel_param *kp);
> static int dmatest_chan_get(char *val, const struct kernel_param *kp);
> -static const struct kernel_param_ops multi_chan_ops = {
> - .set = dmatest_chan_set,
> - .get = dmatest_chan_get,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(multi_chan_ops, dmatest_chan_set,
> + dmatest_chan_get);
>
> static char test_channel[20];
> static struct kparam_string newchan_kps = {
> @@ -178,9 +173,7 @@ module_param_cb(channel, &multi_chan_ops, &newchan_kps, 0644);
> MODULE_PARM_DESC(channel, "Bus ID of the channel to test (default: any)");
>
> static int dmatest_test_list_get(char *val, const struct kernel_param *kp);
> -static const struct kernel_param_ops test_list_ops = {
> - .get = dmatest_test_list_get,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(test_list_ops, NULL, dmatest_test_list_get);
> module_param_cb(test_list, &test_list_ops, NULL, 0444);
> MODULE_PARM_DESC(test_list, "Print current test list");
>
> @@ -292,10 +285,7 @@ static int dmatest_wait_get(char *val, const struct kernel_param *kp)
> return param_get_bool(val, kp);
> }
>
> -static const struct kernel_param_ops wait_ops = {
> - .get = dmatest_wait_get,
> - .set = param_set_bool,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(wait_ops, param_set_bool, dmatest_wait_get);
> module_param_cb(wait, &wait_ops, &wait, 0444);
> MODULE_PARM_DESC(wait, "Wait for tests to complete (default: false)");
>
> diff --git a/drivers/edac/i10nm_base.c b/drivers/edac/i10nm_base.c
> index 63df35444214..ab05e58faaa8 100644
> --- a/drivers/edac/i10nm_base.c
> +++ b/drivers/edac/i10nm_base.c
> @@ -1284,10 +1284,8 @@ static int set_decoding_via_mca(const char *buf, const struct kernel_param *kp)
> return ret;
> }
>
> -static const struct kernel_param_ops decoding_via_mca_param_ops = {
> - .set = set_decoding_via_mca,
> - .get = param_get_int,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(decoding_via_mca_param_ops, set_decoding_via_mca,
> + param_get_int);
>
> module_param_cb(decoding_via_mca, &decoding_via_mca_param_ops, &decoding_via_mca, 0644);
> MODULE_PARM_DESC(decoding_via_mca, "decoding_via_mca: 0=off(default), 1=enable");
> diff --git a/drivers/firmware/efi/efi-pstore.c b/drivers/firmware/efi/efi-pstore.c
> index a253b6144945..fd0f3579fd54 100644
> --- a/drivers/firmware/efi/efi-pstore.c
> +++ b/drivers/firmware/efi/efi-pstore.c
> @@ -43,10 +43,8 @@ static int efi_pstore_disable_set(const char *val, const struct kernel_param *kp
> return 0;
> }
>
> -static const struct kernel_param_ops pstore_disable_ops = {
> - .set = efi_pstore_disable_set,
> - .get = param_get_bool,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(pstore_disable_ops, efi_pstore_disable_set,
> + param_get_bool);
>
> module_param_cb(pstore_disable, &pstore_disable_ops, &pstore_disable, 0644);
> __MODULE_PARM_TYPE(pstore_disable, "bool");
> diff --git a/drivers/firmware/qcom/qcom_scm.c b/drivers/firmware/qcom/qcom_scm.c
> index 9b06a69d3a6d..ef57df53e087 100644
> --- a/drivers/firmware/qcom/qcom_scm.c
> +++ b/drivers/firmware/qcom/qcom_scm.c
> @@ -2725,10 +2725,8 @@ static int set_download_mode(const char *val, const struct kernel_param *kp)
> return 0;
> }
>
> -static const struct kernel_param_ops download_mode_param_ops = {
> - .get = get_download_mode,
> - .set = set_download_mode,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(download_mode_param_ops, set_download_mode,
> + get_download_mode);
>
> module_param_cb(download_mode, &download_mode_param_ops, NULL, 0644);
> MODULE_PARM_DESC(download_mode, "download mode: off/0/N for no dump mode, full/on/1/Y for full dump mode, mini for minidump mode and full,mini for both full and minidump mode together are acceptable values");
> diff --git a/drivers/firmware/qemu_fw_cfg.c b/drivers/firmware/qemu_fw_cfg.c
> index 87a5421bc7d5..c87a5449ba8c 100644
> --- a/drivers/firmware/qemu_fw_cfg.c
> +++ b/drivers/firmware/qemu_fw_cfg.c
> @@ -897,10 +897,8 @@ static int fw_cfg_cmdline_get(char *buf, const struct kernel_param *kp)
> return 0;
> }
>
> -static const struct kernel_param_ops fw_cfg_cmdline_param_ops = {
> - .set = fw_cfg_cmdline_set,
> - .get = fw_cfg_cmdline_get,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(fw_cfg_cmdline_param_ops, fw_cfg_cmdline_set,
> + fw_cfg_cmdline_get);
>
> device_param_cb(ioport, &fw_cfg_cmdline_param_ops, NULL, S_IRUSR);
> device_param_cb(mmio, &fw_cfg_cmdline_param_ops, NULL, S_IRUSR);
> diff --git a/drivers/gpu/drm/drm_panic.c b/drivers/gpu/drm/drm_panic.c
> index d6d3b8d85dea..c35d1adf2ce3 100644
> --- a/drivers/gpu/drm/drm_panic.c
> +++ b/drivers/gpu/drm/drm_panic.c
> @@ -847,10 +847,8 @@ static int drm_panic_type_get(char *buffer, const struct kernel_param *kp)
> drm_panic_type_map[drm_panic_type]);
> }
>
> -static const struct kernel_param_ops drm_panic_ops = {
> - .set = drm_panic_type_set,
> - .get = drm_panic_type_get,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(drm_panic_ops, drm_panic_type_set,
> + drm_panic_type_get);
>
> module_param_cb(panic_screen, &drm_panic_ops, NULL, 0644);
> MODULE_PARM_DESC(panic_screen,
> diff --git a/drivers/gpu/drm/i915/i915_mitigations.c b/drivers/gpu/drm/i915/i915_mitigations.c
> index def7302ef7fe..6061eae84e9c 100644
> --- a/drivers/gpu/drm/i915/i915_mitigations.c
> +++ b/drivers/gpu/drm/i915/i915_mitigations.c
> @@ -124,10 +124,7 @@ static int mitigations_get(char *buffer, const struct kernel_param *kp)
> return count;
> }
>
> -static const struct kernel_param_ops ops = {
> - .set = mitigations_set,
> - .get = mitigations_get,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(ops, mitigations_set, mitigations_get);
>
> module_param_cb_unsafe(mitigations, &ops, NULL, 0600);
> MODULE_PARM_DESC(mitigations,
> diff --git a/drivers/gpu/drm/imagination/pvr_fw_trace.c b/drivers/gpu/drm/imagination/pvr_fw_trace.c
> index 6193811ef7be..2df7274e21a8 100644
> --- a/drivers/gpu/drm/imagination/pvr_fw_trace.c
> +++ b/drivers/gpu/drm/imagination/pvr_fw_trace.c
> @@ -71,10 +71,8 @@ pvr_fw_trace_init_mask_set(const char *val, const struct kernel_param *kp)
> return 0;
> }
>
> -const struct kernel_param_ops pvr_fw_trace_init_mask_ops = {
> - .set = pvr_fw_trace_init_mask_set,
> - .get = param_get_hexint,
> -};
> +DEFINE_KERNEL_PARAM_OPS(pvr_fw_trace_init_mask_ops, pvr_fw_trace_init_mask_set,
> + param_get_hexint);
>
> param_check_hexint(init_fw_trace_mask, &pvr_fw_trace_init_mask);
> module_param_cb(init_fw_trace_mask, &pvr_fw_trace_init_mask_ops, &pvr_fw_trace_init_mask, 0600);
> diff --git a/drivers/hid/hid-cougar.c b/drivers/hid/hid-cougar.c
> index ad027c45f162..271048bdf7fc 100644
> --- a/drivers/hid/hid-cougar.c
> +++ b/drivers/hid/hid-cougar.c
> @@ -314,10 +314,8 @@ static int cougar_param_set_g6_is_space(const char *val,
> return 0;
> }
>
> -static const struct kernel_param_ops cougar_g6_is_space_ops = {
> - .set = cougar_param_set_g6_is_space,
> - .get = param_get_bool,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(cougar_g6_is_space_ops,
> + cougar_param_set_g6_is_space, param_get_bool);
> module_param_cb(g6_is_space, &cougar_g6_is_space_ops, &g6_is_space, 0644);
>
> static const struct hid_device_id cougar_id_table[] = {
> diff --git a/drivers/hid/hid-steam.c b/drivers/hid/hid-steam.c
> index 197126d6e081..962ed60492ea 100644
> --- a/drivers/hid/hid-steam.c
> +++ b/drivers/hid/hid-steam.c
> @@ -1840,10 +1840,8 @@ static int steam_param_set_lizard_mode(const char *val,
> return 0;
> }
>
> -static const struct kernel_param_ops steam_lizard_mode_ops = {
> - .set = steam_param_set_lizard_mode,
> - .get = param_get_bool,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(steam_lizard_mode_ops,
> + steam_param_set_lizard_mode, param_get_bool);
>
> module_param_cb(lizard_mode, &steam_lizard_mode_ops, &lizard_mode, 0644);
> MODULE_PARM_DESC(lizard_mode,
> diff --git a/drivers/infiniband/hw/hfi1/driver.c b/drivers/infiniband/hw/hfi1/driver.c
> index c7259cc39013..5b9b0b38b419 100644
> --- a/drivers/infiniband/hw/hfi1/driver.c
> +++ b/drivers/infiniband/hw/hfi1/driver.c
> @@ -42,10 +42,7 @@ MODULE_PARM_DESC(cu, "Credit return units");
> unsigned long hfi1_cap_mask = HFI1_CAP_MASK_DEFAULT;
> static int hfi1_caps_set(const char *val, const struct kernel_param *kp);
> static int hfi1_caps_get(char *buffer, const struct kernel_param *kp);
> -static const struct kernel_param_ops cap_ops = {
> - .set = hfi1_caps_set,
> - .get = hfi1_caps_get
> -};
> +static DEFINE_KERNEL_PARAM_OPS(cap_ops, hfi1_caps_set, hfi1_caps_get);
> module_param_cb(cap_mask, &cap_ops, &hfi1_cap_mask, S_IWUSR | S_IRUGO);
> MODULE_PARM_DESC(cap_mask, "Bit mask of enabled/disabled HW features");
>
> diff --git a/drivers/infiniband/ulp/iser/iscsi_iser.c b/drivers/infiniband/ulp/iser/iscsi_iser.c
> index 7df441685780..758e527ca7c4 100644
> --- a/drivers/infiniband/ulp/iser/iscsi_iser.c
> +++ b/drivers/infiniband/ulp/iser/iscsi_iser.c
> @@ -90,10 +90,8 @@ module_param_named(debug_level, iser_debug_level, int, S_IRUGO | S_IWUSR);
> MODULE_PARM_DESC(debug_level, "Enable debug tracing if > 0 (default:disabled)");
>
> static int iscsi_iser_set(const char *val, const struct kernel_param *kp);
> -static const struct kernel_param_ops iscsi_iser_size_ops = {
> - .set = iscsi_iser_set,
> - .get = param_get_uint,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(iscsi_iser_size_ops, iscsi_iser_set,
> + param_get_uint);
>
> static unsigned int iscsi_max_lun = 512;
> module_param_cb(max_lun, &iscsi_iser_size_ops, &iscsi_max_lun, S_IRUGO);
> diff --git a/drivers/infiniband/ulp/isert/ib_isert.c b/drivers/infiniband/ulp/isert/ib_isert.c
> index 348005e71891..bd91900a0ebf 100644
> --- a/drivers/infiniband/ulp/isert/ib_isert.c
> +++ b/drivers/infiniband/ulp/isert/ib_isert.c
> @@ -30,10 +30,8 @@ MODULE_PARM_DESC(debug_level, "Enable debug tracing if > 0 (default:0)");
>
> static int isert_sg_tablesize_set(const char *val,
> const struct kernel_param *kp);
> -static const struct kernel_param_ops sg_tablesize_ops = {
> - .set = isert_sg_tablesize_set,
> - .get = param_get_int,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(sg_tablesize_ops, isert_sg_tablesize_set,
> + param_get_int);
>
> static int isert_sg_tablesize = ISCSI_ISER_MIN_SG_TABLESIZE;
> module_param_cb(sg_tablesize, &sg_tablesize_ops, &isert_sg_tablesize, 0644);
> diff --git a/drivers/infiniband/ulp/srp/ib_srp.c b/drivers/infiniband/ulp/srp/ib_srp.c
> index b58868e1cf11..a81515f52a4f 100644
> --- a/drivers/infiniband/ulp/srp/ib_srp.c
> +++ b/drivers/infiniband/ulp/srp/ib_srp.c
> @@ -195,10 +195,7 @@ static int srp_tmo_set(const char *val, const struct kernel_param *kp)
> return res;
> }
>
> -static const struct kernel_param_ops srp_tmo_ops = {
> - .get = srp_tmo_get,
> - .set = srp_tmo_set,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(srp_tmo_ops, srp_tmo_set, srp_tmo_get);
>
> static inline struct srp_target_port *host_to_target(struct Scsi_Host *host)
> {
> diff --git a/drivers/input/misc/ati_remote2.c b/drivers/input/misc/ati_remote2.c
> index 8db2dca84975..8b4ef7e163d3 100644
> --- a/drivers/input/misc/ati_remote2.c
> +++ b/drivers/input/misc/ati_remote2.c
> @@ -89,19 +89,16 @@ static int ati_remote2_get_mode_mask(char *buffer,
>
> static unsigned int channel_mask = ATI_REMOTE2_MAX_CHANNEL_MASK;
> #define param_check_channel_mask(name, p) __param_check(name, p, unsigned int)
> -static const struct kernel_param_ops param_ops_channel_mask = {
> - .set = ati_remote2_set_channel_mask,
> - .get = ati_remote2_get_channel_mask,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(param_ops_channel_mask,
> + ati_remote2_set_channel_mask,
> + ati_remote2_get_channel_mask);
> module_param(channel_mask, channel_mask, 0644);
> MODULE_PARM_DESC(channel_mask, "Bitmask of channels to accept <15:Channel16>...<1:Channel2><0:Channel1>");
>
> static unsigned int mode_mask = ATI_REMOTE2_MAX_MODE_MASK;
> #define param_check_mode_mask(name, p) __param_check(name, p, unsigned int)
> -static const struct kernel_param_ops param_ops_mode_mask = {
> - .set = ati_remote2_set_mode_mask,
> - .get = ati_remote2_get_mode_mask,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(param_ops_mode_mask, ati_remote2_set_mode_mask,
> + ati_remote2_get_mode_mask);
> module_param(mode_mask, mode_mask, 0644);
> MODULE_PARM_DESC(mode_mask, "Bitmask of modes to accept <4:PC><3:AUX4><2:AUX3><1:AUX2><0:AUX1>");
>
> diff --git a/drivers/input/mouse/psmouse-base.c b/drivers/input/mouse/psmouse-base.c
> index 6ab5f1d96eae..f9ebb1fd0b6f 100644
> --- a/drivers/input/mouse/psmouse-base.c
> +++ b/drivers/input/mouse/psmouse-base.c
> @@ -45,10 +45,8 @@ MODULE_LICENSE("GPL");
> static unsigned int psmouse_max_proto = PSMOUSE_AUTO;
> static int psmouse_set_maxproto(const char *val, const struct kernel_param *);
> static int psmouse_get_maxproto(char *buffer, const struct kernel_param *kp);
> -static const struct kernel_param_ops param_ops_proto_abbrev = {
> - .set = psmouse_set_maxproto,
> - .get = psmouse_get_maxproto,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(param_ops_proto_abbrev, psmouse_set_maxproto,
> + psmouse_get_maxproto);
> #define param_check_proto_abbrev(name, p) __param_check(name, p, unsigned int)
> module_param_named(proto, psmouse_max_proto, proto_abbrev, 0644);
> MODULE_PARM_DESC(proto, "Highest protocol extension to probe (bare, imps, exps, any). Useful for KVM switches.");
> diff --git a/drivers/media/usb/uvc/uvc_driver.c b/drivers/media/usb/uvc/uvc_driver.c
> index 31b4ac3b48c1..2338cab7fef9 100644
> --- a/drivers/media/usb/uvc/uvc_driver.c
> +++ b/drivers/media/usb/uvc/uvc_driver.c
> @@ -2488,10 +2488,8 @@ static int param_set_nodrop(const char *val, const struct kernel_param *kp)
> return param_set_bool(val, kp);
> }
>
> -static const struct kernel_param_ops param_ops_nodrop = {
> - .set = param_set_nodrop,
> - .get = param_get_uint,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(param_ops_nodrop, param_set_nodrop,
> + param_get_uint);
>
> param_check_uint(nodrop, &uvc_no_drop_param);
> module_param_cb(nodrop, ¶m_ops_nodrop, &uvc_no_drop_param, 0644);
> diff --git a/drivers/misc/lis3lv02d/lis3lv02d.c b/drivers/misc/lis3lv02d/lis3lv02d.c
> index 21e8ad0a7444..6e40c14be51e 100644
> --- a/drivers/misc/lis3lv02d/lis3lv02d.c
> +++ b/drivers/misc/lis3lv02d/lis3lv02d.c
> @@ -103,10 +103,7 @@ static int param_set_axis(const char *val, const struct kernel_param *kp)
> return ret;
> }
>
> -static const struct kernel_param_ops param_ops_axis = {
> - .set = param_set_axis,
> - .get = param_get_int,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(param_ops_axis, param_set_axis, param_get_int);
>
> #define param_check_axis(name, p) param_check_int(name, p)
>
> diff --git a/drivers/net/wireless/ath/wil6210/main.c b/drivers/net/wireless/ath/wil6210/main.c
> index d5aec72ecdce..e566d94d5f5c 100644
> --- a/drivers/net/wireless/ath/wil6210/main.c
> +++ b/drivers/net/wireless/ath/wil6210/main.c
> @@ -62,10 +62,7 @@ static int mtu_max_set(const char *val, const struct kernel_param *kp)
> return ret;
> }
>
> -static const struct kernel_param_ops mtu_max_ops = {
> - .set = mtu_max_set,
> - .get = param_get_uint,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(mtu_max_ops, mtu_max_set, param_get_uint);
>
> module_param_cb(mtu_max, &mtu_max_ops, &mtu_max, 0444);
> MODULE_PARM_DESC(mtu_max, " Max MTU value.");
> @@ -91,10 +88,7 @@ static int ring_order_set(const char *val, const struct kernel_param *kp)
> return 0;
> }
>
> -static const struct kernel_param_ops ring_order_ops = {
> - .set = ring_order_set,
> - .get = param_get_uint,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(ring_order_ops, ring_order_set, param_get_uint);
>
> module_param_cb(rx_ring_order, &ring_order_ops, &rx_ring_order, 0444);
> MODULE_PARM_DESC(rx_ring_order, " Rx ring order; size = 1 << order");
> diff --git a/drivers/nvme/host/multipath.c b/drivers/nvme/host/multipath.c
> index 263161cb8ac0..f7362377e427 100644
> --- a/drivers/nvme/host/multipath.c
> +++ b/drivers/nvme/host/multipath.c
> @@ -30,10 +30,8 @@ static int multipath_param_set(const char *val, const struct kernel_param *kp)
> return 0;
> }
>
> -static const struct kernel_param_ops multipath_param_ops = {
> - .set = multipath_param_set,
> - .get = param_get_bool,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(multipath_param_ops, multipath_param_set,
> + param_get_bool);
>
> module_param_cb(multipath, &multipath_param_ops, &multipath, 0444);
> MODULE_PARM_DESC(multipath,
> @@ -55,10 +53,8 @@ static int multipath_always_on_set(const char *val,
> return 0;
> }
>
> -static const struct kernel_param_ops multipath_always_on_ops = {
> - .set = multipath_always_on_set,
> - .get = param_get_bool,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(multipath_always_on_ops, multipath_always_on_set,
> + param_get_bool);
>
> module_param_cb(multipath_always_on, &multipath_always_on_ops,
> &multipath_always_on, 0444);
> diff --git a/drivers/nvme/host/pci.c b/drivers/nvme/host/pci.c
> index 9fd04cd7c5cb..c77e9b848d03 100644
> --- a/drivers/nvme/host/pci.c
> +++ b/drivers/nvme/host/pci.c
> @@ -100,10 +100,8 @@ MODULE_PARM_DESC(sgl_threshold,
> #define NVME_PCI_MIN_QUEUE_SIZE 2
> #define NVME_PCI_MAX_QUEUE_SIZE 4095
> static int io_queue_depth_set(const char *val, const struct kernel_param *kp);
> -static const struct kernel_param_ops io_queue_depth_ops = {
> - .set = io_queue_depth_set,
> - .get = param_get_uint,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(io_queue_depth_ops, io_queue_depth_set,
> + param_get_uint);
>
> static unsigned int io_queue_depth = 1024;
> module_param_cb(io_queue_depth, &io_queue_depth_ops, &io_queue_depth, 0644);
> @@ -232,10 +230,8 @@ static int quirks_param_set(const char *value, const struct kernel_param *kp)
> }
>
> static char quirks_param[128];
> -static const struct kernel_param_ops quirks_param_ops = {
> - .set = quirks_param_set,
> - .get = param_get_string,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(quirks_param_ops, quirks_param_set,
> + param_get_string);
>
> static struct kparam_string quirks_param_string = {
> .maxlen = sizeof(quirks_param),
> @@ -257,10 +253,8 @@ static int io_queue_count_set(const char *val, const struct kernel_param *kp)
> return param_set_uint(val, kp);
> }
>
> -static const struct kernel_param_ops io_queue_count_ops = {
> - .set = io_queue_count_set,
> - .get = param_get_uint,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(io_queue_count_ops, io_queue_count_set,
> + param_get_uint);
>
> static unsigned int write_queues;
> module_param_cb(write_queues, &io_queue_count_ops, &write_queues, 0644);
> diff --git a/drivers/nvme/target/rdma.c b/drivers/nvme/target/rdma.c
> index e6e2c3f9afdf..dc544813300f 100644
> --- a/drivers/nvme/target/rdma.c
> +++ b/drivers/nvme/target/rdma.c
> @@ -147,10 +147,7 @@ module_param_named(use_srq, nvmet_rdma_use_srq, bool, 0444);
> MODULE_PARM_DESC(use_srq, "Use shared receive queue.");
>
> static int srq_size_set(const char *val, const struct kernel_param *kp);
> -static const struct kernel_param_ops srq_size_ops = {
> - .set = srq_size_set,
> - .get = param_get_int,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(srq_size_ops, srq_size_set, param_get_int);
>
> static int nvmet_rdma_srq_size = 1024;
> module_param_cb(srq_size, &srq_size_ops, &nvmet_rdma_srq_size, 0644);
> diff --git a/drivers/nvme/target/tcp.c b/drivers/nvme/target/tcp.c
> index 164a564ba3b4..2f336cd7e559 100644
> --- a/drivers/nvme/target/tcp.c
> +++ b/drivers/nvme/target/tcp.c
> @@ -46,10 +46,7 @@ static int set_params(const char *str, const struct kernel_param *kp)
> return param_store_val(str, kp->arg, 0, INT_MAX);
> }
>
> -static const struct kernel_param_ops set_param_ops = {
> - .set = set_params,
> - .get = param_get_int,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(set_param_ops, set_params, param_get_int);
>
> /* Define the socket priority to use for connections were it is desirable
> * that the NIC consider performing optimized packet processing or filtering.
> diff --git a/drivers/platform/x86/acerhdf.c b/drivers/platform/x86/acerhdf.c
> index 5ce5ad3efe69..bd59c3f3f2c5 100644
> --- a/drivers/platform/x86/acerhdf.c
> +++ b/drivers/platform/x86/acerhdf.c
> @@ -762,10 +762,7 @@ static int interval_set_uint(const char *val, const struct kernel_param *kp)
> return 0;
> }
>
> -static const struct kernel_param_ops interval_ops = {
> - .set = interval_set_uint,
> - .get = param_get_uint,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(interval_ops, interval_set_uint, param_get_uint);
>
> module_param_cb(interval, &interval_ops, &interval, 0000);
> MODULE_PARM_DESC(interval, "Polling interval of temperature check");
> diff --git a/drivers/power/supply/bq27xxx_battery.c b/drivers/power/supply/bq27xxx_battery.c
> index 45f0e39b8c2d..09829ee1a49d 100644
> --- a/drivers/power/supply/bq27xxx_battery.c
> +++ b/drivers/power/supply/bq27xxx_battery.c
> @@ -1133,10 +1133,8 @@ static int poll_interval_param_set(const char *val, const struct kernel_param *k
> return ret;
> }
>
> -static const struct kernel_param_ops param_ops_poll_interval = {
> - .get = param_get_uint,
> - .set = poll_interval_param_set,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(param_ops_poll_interval, poll_interval_param_set,
> + param_get_uint);
>
> static unsigned int poll_interval = 360;
> module_param_cb(poll_interval, ¶m_ops_poll_interval, &poll_interval, 0644);
> diff --git a/drivers/power/supply/test_power.c b/drivers/power/supply/test_power.c
> index 2c0e9ad820c0..0bf2bef3383a 100644
> --- a/drivers/power/supply/test_power.c
> +++ b/drivers/power/supply/test_power.c
> @@ -649,60 +649,47 @@ static int param_set_battery_extension(const char *key,
>
> #define param_get_battery_extension param_get_bool
>
> -static const struct kernel_param_ops param_ops_ac_online = {
> - .set = param_set_ac_online,
> - .get = param_get_ac_online,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(param_ops_ac_online, param_set_ac_online,
> + param_get_ac_online);
>
> -static const struct kernel_param_ops param_ops_usb_online = {
> - .set = param_set_usb_online,
> - .get = param_get_usb_online,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(param_ops_usb_online, param_set_usb_online,
> + param_get_usb_online);
>
> -static const struct kernel_param_ops param_ops_battery_status = {
> - .set = param_set_battery_status,
> - .get = param_get_battery_status,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(param_ops_battery_status,
> + param_set_battery_status,
> + param_get_battery_status);
>
> -static const struct kernel_param_ops param_ops_battery_present = {
> - .set = param_set_battery_present,
> - .get = param_get_battery_present,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(param_ops_battery_present,
> + param_set_battery_present,
> + param_get_battery_present);
>
> -static const struct kernel_param_ops param_ops_battery_technology = {
> - .set = param_set_battery_technology,
> - .get = param_get_battery_technology,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(param_ops_battery_technology,
> + param_set_battery_technology,
> + param_get_battery_technology);
>
> -static const struct kernel_param_ops param_ops_battery_health = {
> - .set = param_set_battery_health,
> - .get = param_get_battery_health,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(param_ops_battery_health,
> + param_set_battery_health,
> + param_get_battery_health);
>
> -static const struct kernel_param_ops param_ops_battery_capacity = {
> - .set = param_set_battery_capacity,
> - .get = param_get_battery_capacity,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(param_ops_battery_capacity,
> + param_set_battery_capacity,
> + param_get_battery_capacity);
>
> -static const struct kernel_param_ops param_ops_battery_voltage = {
> - .set = param_set_battery_voltage,
> - .get = param_get_battery_voltage,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(param_ops_battery_voltage,
> + param_set_battery_voltage,
> + param_get_battery_voltage);
>
> -static const struct kernel_param_ops param_ops_battery_charge_counter = {
> - .set = param_set_battery_charge_counter,
> - .get = param_get_battery_charge_counter,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(param_ops_battery_charge_counter,
> + param_set_battery_charge_counter,
> + param_get_battery_charge_counter);
>
> -static const struct kernel_param_ops param_ops_battery_current = {
> - .set = param_set_battery_current,
> - .get = param_get_battery_current,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(param_ops_battery_current,
> + param_set_battery_current,
> + param_get_battery_current);
>
> -static const struct kernel_param_ops param_ops_battery_extension = {
> - .set = param_set_battery_extension,
> - .get = param_get_battery_extension,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(param_ops_battery_extension,
> + param_set_battery_extension,
> + param_get_battery_extension);
>
> #define param_check_ac_online(name, p) __param_check(name, p, void);
> #define param_check_usb_online(name, p) __param_check(name, p, void);
> diff --git a/drivers/scsi/sg.c b/drivers/scsi/sg.c
> index 2b4b2a1a8e44..c075b567f84e 100644
> --- a/drivers/scsi/sg.c
> +++ b/drivers/scsi/sg.c
> @@ -1644,10 +1644,8 @@ static int def_reserved_size_set(const char *val, const struct kernel_param *kp)
> return 0;
> }
>
> -static const struct kernel_param_ops def_reserved_size_ops = {
> - .set = def_reserved_size_set,
> - .get = param_get_int,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(def_reserved_size_ops, def_reserved_size_set,
> + param_get_int);
>
> module_param_cb(def_reserved_size, &def_reserved_size_ops, &def_reserved_size,
> S_IRUGO | S_IWUSR);
> diff --git a/drivers/target/target_core_user.c b/drivers/target/target_core_user.c
> index edc2afd5f4ee..676a12b44e88 100644
> --- a/drivers/target/target_core_user.c
> +++ b/drivers/target/target_core_user.c
> @@ -255,10 +255,9 @@ static int tcmu_get_global_max_data_area(char *buffer,
> return sprintf(buffer, "%d\n", TCMU_PAGES_TO_MBS(tcmu_global_max_pages));
> }
>
> -static const struct kernel_param_ops tcmu_global_max_data_area_op = {
> - .set = tcmu_set_global_max_data_area,
> - .get = tcmu_get_global_max_data_area,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(tcmu_global_max_data_area_op,
> + tcmu_set_global_max_data_area,
> + tcmu_get_global_max_data_area);
>
> module_param_cb(global_max_data_area_mb, &tcmu_global_max_data_area_op, NULL,
> S_IWUSR | S_IRUGO);
> @@ -292,10 +291,8 @@ static int tcmu_set_block_netlink(const char *str,
> return 0;
> }
>
> -static const struct kernel_param_ops tcmu_block_netlink_op = {
> - .set = tcmu_set_block_netlink,
> - .get = tcmu_get_block_netlink,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(tcmu_block_netlink_op, tcmu_set_block_netlink,
> + tcmu_get_block_netlink);
>
> module_param_cb(block_netlink, &tcmu_block_netlink_op, NULL, S_IWUSR | S_IRUGO);
> MODULE_PARM_DESC(block_netlink, "Block new netlink commands.");
> diff --git a/drivers/thermal/intel/int340x_thermal/processor_thermal_soc_slider.c b/drivers/thermal/intel/int340x_thermal/processor_thermal_soc_slider.c
> index 91f291627132..68275c3f2c9b 100644
> --- a/drivers/thermal/intel/int340x_thermal/processor_thermal_soc_slider.c
> +++ b/drivers/thermal/intel/int340x_thermal/processor_thermal_soc_slider.c
> @@ -83,10 +83,8 @@ static int slider_def_balance_get(char *buf, const struct kernel_param *kp)
> return sysfs_emit(buf, "%02x\n", slider_values[SOC_POWER_SLIDER_BALANCE]);
> }
>
> -static const struct kernel_param_ops slider_def_balance_ops = {
> - .set = slider_def_balance_set,
> - .get = slider_def_balance_get,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(slider_def_balance_ops, slider_def_balance_set,
> + slider_def_balance_get);
>
> module_param_cb(slider_balance, &slider_def_balance_ops, NULL, 0644);
> MODULE_PARM_DESC(slider_balance, "Set slider default value for balance");
> @@ -117,10 +115,8 @@ static int slider_def_offset_get(char *buf, const struct kernel_param *kp)
> return sysfs_emit(buf, "%02x\n", slider_offset);
> }
>
> -static const struct kernel_param_ops slider_offset_ops = {
> - .set = slider_def_offset_set,
> - .get = slider_def_offset_get,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(slider_offset_ops, slider_def_offset_set,
> + slider_def_offset_get);
>
> /*
> * To enhance power efficiency dynamically, the firmware can optionally
> diff --git a/drivers/thermal/intel/intel_powerclamp.c b/drivers/thermal/intel/intel_powerclamp.c
> index ccf380da12f2..98fbc6892714 100644
> --- a/drivers/thermal/intel/intel_powerclamp.c
> +++ b/drivers/thermal/intel/intel_powerclamp.c
> @@ -112,10 +112,7 @@ static int duration_get(char *buf, const struct kernel_param *kp)
> return ret;
> }
>
> -static const struct kernel_param_ops duration_ops = {
> - .set = duration_set,
> - .get = duration_get,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(duration_ops, duration_set, duration_get);
>
> module_param_cb(duration, &duration_ops, NULL, 0644);
> MODULE_PARM_DESC(duration, "forced idle time for each attempt in msec.");
> @@ -203,10 +200,7 @@ static int cpumask_get(char *buf, const struct kernel_param *kp)
> return cpumap_print_to_pagebuf(false, buf, idle_injection_cpu_mask);
> }
>
> -static const struct kernel_param_ops cpumask_ops = {
> - .set = cpumask_set,
> - .get = cpumask_get,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(cpumask_ops, cpumask_set, cpumask_get);
>
> module_param_cb(cpumask, &cpumask_ops, NULL, 0644);
> MODULE_PARM_DESC(cpumask, "Mask of CPUs to use for idle injection.");
> @@ -252,10 +246,7 @@ static int max_idle_set(const char *arg, const struct kernel_param *kp)
> return ret;
> }
>
> -static const struct kernel_param_ops max_idle_ops = {
> - .set = max_idle_set,
> - .get = param_get_byte,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(max_idle_ops, max_idle_set, param_get_byte);
>
> module_param_cb(max_idle, &max_idle_ops, &max_idle, 0644);
> MODULE_PARM_DESC(max_idle, "maximum injected idle time to the total CPU time ratio in percent range:1-100");
> @@ -299,10 +290,7 @@ static int window_size_set(const char *arg, const struct kernel_param *kp)
> return ret;
> }
>
> -static const struct kernel_param_ops window_size_ops = {
> - .set = window_size_set,
> - .get = param_get_int,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(window_size_ops, window_size_set, param_get_int);
>
> module_param_cb(window_size, &window_size_ops, &window_size, 0644);
> MODULE_PARM_DESC(window_size, "sliding window in number of clamping cycles\n"
> diff --git a/drivers/tty/hvc/hvc_iucv.c b/drivers/tty/hvc/hvc_iucv.c
> index 37db8a3e5158..29612a4a32cb 100644
> --- a/drivers/tty/hvc/hvc_iucv.c
> +++ b/drivers/tty/hvc/hvc_iucv.c
> @@ -1290,10 +1290,8 @@ static int param_get_vmidfilter(char *buffer, const struct kernel_param *kp)
>
> #define param_check_vmidfilter(name, p) __param_check(name, p, void)
>
> -static const struct kernel_param_ops param_ops_vmidfilter = {
> - .set = param_set_vmidfilter,
> - .get = param_get_vmidfilter,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(param_ops_vmidfilter, param_set_vmidfilter,
> + param_get_vmidfilter);
>
> /**
> * hvc_iucv_init() - z/VM IUCV HVC device driver initialization
> diff --git a/drivers/tty/sysrq.c b/drivers/tty/sysrq.c
> index c2e4b31b699a..c6279c496279 100644
> --- a/drivers/tty/sysrq.c
> +++ b/drivers/tty/sysrq.c
> @@ -1074,10 +1074,8 @@ static int sysrq_reset_seq_param_set(const char *buffer,
> return 0;
> }
>
> -static const struct kernel_param_ops param_ops_sysrq_reset_seq = {
> - .get = param_get_ushort,
> - .set = sysrq_reset_seq_param_set,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(param_ops_sysrq_reset_seq,
> + sysrq_reset_seq_param_set, param_get_ushort);
>
> #define param_check_sysrq_reset_seq(name, p) \
> __param_check(name, p, unsigned short)
> diff --git a/drivers/ufs/core/ufs-fault-injection.c b/drivers/ufs/core/ufs-fault-injection.c
> index 55db38e75cc4..7d2873da7dc5 100644
> --- a/drivers/ufs/core/ufs-fault-injection.c
> +++ b/drivers/ufs/core/ufs-fault-injection.c
> @@ -11,10 +11,7 @@
> static int ufs_fault_get(char *buffer, const struct kernel_param *kp);
> static int ufs_fault_set(const char *val, const struct kernel_param *kp);
>
> -static const struct kernel_param_ops ufs_fault_ops = {
> - .get = ufs_fault_get,
> - .set = ufs_fault_set,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(ufs_fault_ops, ufs_fault_set, ufs_fault_get);
>
> enum { FAULT_INJ_STR_SIZE = 80 };
>
> diff --git a/drivers/ufs/core/ufs-mcq.c b/drivers/ufs/core/ufs-mcq.c
> index c1b1d67a1ddc..83100aad2a97 100644
> --- a/drivers/ufs/core/ufs-mcq.c
> +++ b/drivers/ufs/core/ufs-mcq.c
> @@ -43,10 +43,8 @@ static int rw_queue_count_set(const char *val, const struct kernel_param *kp)
> num_possible_cpus());
> }
>
> -static const struct kernel_param_ops rw_queue_count_ops = {
> - .set = rw_queue_count_set,
> - .get = param_get_uint,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(rw_queue_count_ops, rw_queue_count_set,
> + param_get_uint);
>
> static unsigned int rw_queues;
> module_param_cb(rw_queues, &rw_queue_count_ops, &rw_queues, 0644);
> @@ -59,10 +57,8 @@ static int read_queue_count_set(const char *val, const struct kernel_param *kp)
> num_possible_cpus());
> }
>
> -static const struct kernel_param_ops read_queue_count_ops = {
> - .set = read_queue_count_set,
> - .get = param_get_uint,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(read_queue_count_ops, read_queue_count_set,
> + param_get_uint);
>
> static unsigned int read_queues;
> module_param_cb(read_queues, &read_queue_count_ops, &read_queues, 0644);
> @@ -75,10 +71,8 @@ static int poll_queue_count_set(const char *val, const struct kernel_param *kp)
> num_possible_cpus());
> }
>
> -static const struct kernel_param_ops poll_queue_count_ops = {
> - .set = poll_queue_count_set,
> - .get = param_get_uint,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(poll_queue_count_ops, poll_queue_count_set,
> + param_get_uint);
>
> static unsigned int poll_queues = 1;
> module_param_cb(poll_queues, &poll_queue_count_ops, &poll_queues, 0644);
> diff --git a/drivers/ufs/core/ufs-txeq.c b/drivers/ufs/core/ufs-txeq.c
> index b2dc89124353..3bdd87b434ad 100644
> --- a/drivers/ufs/core/ufs-txeq.c
> +++ b/drivers/ufs/core/ufs-txeq.c
> @@ -23,10 +23,7 @@ static int txeq_gear_set(const char *val, const struct kernel_param *kp)
> return param_set_uint_minmax(val, kp, UFS_HS_G1, UFS_HS_GEAR_MAX);
> }
>
> -static const struct kernel_param_ops txeq_gear_ops = {
> - .set = txeq_gear_set,
> - .get = param_get_uint,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(txeq_gear_ops, txeq_gear_set, param_get_uint);
>
> static unsigned int adaptive_txeq_gear = UFS_HS_G6;
> module_param_cb(adaptive_txeq_gear, &txeq_gear_ops, &adaptive_txeq_gear, 0644);
> diff --git a/drivers/ufs/core/ufshcd.c b/drivers/ufs/core/ufshcd.c
> index 4805e40ed4d7..4e930710d9a6 100644
> --- a/drivers/ufs/core/ufshcd.c
> +++ b/drivers/ufs/core/ufshcd.c
> @@ -128,10 +128,8 @@ static int uic_cmd_timeout_set(const char *val, const struct kernel_param *kp)
> UIC_CMD_TIMEOUT_MAX);
> }
>
> -static const struct kernel_param_ops uic_cmd_timeout_ops = {
> - .set = uic_cmd_timeout_set,
> - .get = param_get_uint,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(uic_cmd_timeout_ops, uic_cmd_timeout_set,
> + param_get_uint);
>
> module_param_cb(uic_cmd_timeout, &uic_cmd_timeout_ops, &uic_cmd_timeout, 0644);
> MODULE_PARM_DESC(uic_cmd_timeout,
> @@ -145,10 +143,8 @@ static int dev_cmd_timeout_set(const char *val, const struct kernel_param *kp)
> QUERY_REQ_TIMEOUT_MAX);
> }
>
> -static const struct kernel_param_ops dev_cmd_timeout_ops = {
> - .set = dev_cmd_timeout_set,
> - .get = param_get_uint,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(dev_cmd_timeout_ops, dev_cmd_timeout_set,
> + param_get_uint);
>
> module_param_cb(dev_cmd_timeout, &dev_cmd_timeout_ops, &dev_cmd_timeout, 0644);
> MODULE_PARM_DESC(dev_cmd_timeout,
> diff --git a/drivers/usb/core/quirks.c b/drivers/usb/core/quirks.c
> index 0ffdaefba508..d52ecc886925 100644
> --- a/drivers/usb/core/quirks.c
> +++ b/drivers/usb/core/quirks.c
> @@ -160,10 +160,8 @@ static int quirks_param_set(const char *value, const struct kernel_param *kp)
> return 0;
> }
>
> -static const struct kernel_param_ops quirks_param_ops = {
> - .set = quirks_param_set,
> - .get = param_get_string,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(quirks_param_ops, quirks_param_set,
> + param_get_string);
>
> static struct kparam_string quirks_param_string = {
> .maxlen = sizeof(quirks_param),
> diff --git a/drivers/usb/gadget/legacy/serial.c b/drivers/usb/gadget/legacy/serial.c
> index 4974bee6049a..e34717e553da 100644
> --- a/drivers/usb/gadget/legacy/serial.c
> +++ b/drivers/usb/gadget/legacy/serial.c
> @@ -121,10 +121,7 @@ static int enable_set(const char *s, const struct kernel_param *kp)
> return ret;
> }
>
> -static const struct kernel_param_ops enable_ops = {
> - .set = enable_set,
> - .get = param_get_bool,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(enable_ops, enable_set, param_get_bool);
>
> module_param_cb(enable, &enable_ops, &enable, 0644);
>
> diff --git a/drivers/usb/storage/usb.c b/drivers/usb/storage/usb.c
> index fa83fe0defe2..71dd623b95c9 100644
> --- a/drivers/usb/storage/usb.c
> +++ b/drivers/usb/storage/usb.c
> @@ -158,10 +158,7 @@ static int delay_use_get(char *s, const struct kernel_param *kp)
> return format_delay_ms(delay_ms, 3, "ms", s, PAGE_SIZE);
> }
>
> -static const struct kernel_param_ops delay_use_ops = {
> - .set = delay_use_set,
> - .get = delay_use_get,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(delay_use_ops, delay_use_set, delay_use_get);
> module_param_cb(delay_use, &delay_use_ops, &delay_use, 0644);
> MODULE_PARM_DESC(delay_use, "time to delay before using a new device");
>
> diff --git a/drivers/vhost/scsi.c b/drivers/vhost/scsi.c
> index 9a1253b9d8c5..fd52f2213e27 100644
> --- a/drivers/vhost/scsi.c
> +++ b/drivers/vhost/scsi.c
> @@ -87,10 +87,9 @@ static int vhost_scsi_get_inline_sg_cnt(char *buf,
> return sprintf(buf, "%u\n", vhost_scsi_inline_sg_cnt);
> }
>
> -static const struct kernel_param_ops vhost_scsi_inline_sg_cnt_op = {
> - .get = vhost_scsi_get_inline_sg_cnt,
> - .set = vhost_scsi_set_inline_sg_cnt,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(vhost_scsi_inline_sg_cnt_op,
> + vhost_scsi_set_inline_sg_cnt,
> + vhost_scsi_get_inline_sg_cnt);
>
> module_param_cb(inline_sg_cnt, &vhost_scsi_inline_sg_cnt_op, NULL, 0644);
> MODULE_PARM_DESC(inline_sg_cnt, "Set the number of scatterlist entries to pre-allocate. The default is 2048.");
> diff --git a/drivers/virt/nitro_enclaves/ne_misc_dev.c b/drivers/virt/nitro_enclaves/ne_misc_dev.c
> index c91300a73f50..218ddd93f960 100644
> --- a/drivers/virt/nitro_enclaves/ne_misc_dev.c
> +++ b/drivers/virt/nitro_enclaves/ne_misc_dev.c
> @@ -86,10 +86,8 @@ struct ne_devs ne_devs = {
> */
> static int ne_set_kernel_param(const char *val, const struct kernel_param *kp);
>
> -static const struct kernel_param_ops ne_cpu_pool_ops = {
> - .get = param_get_string,
> - .set = ne_set_kernel_param,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(ne_cpu_pool_ops, ne_set_kernel_param,
> + param_get_string);
>
> static char ne_cpus[NE_CPUS_SIZE];
> static struct kparam_string ne_cpus_arg = {
> diff --git a/drivers/virtio/virtio_mmio.c b/drivers/virtio/virtio_mmio.c
> index 595c2274fbb5..f6df9c76ee81 100644
> --- a/drivers/virtio/virtio_mmio.c
> +++ b/drivers/virtio/virtio_mmio.c
> @@ -748,10 +748,8 @@ static int vm_cmdline_get(char *buffer, const struct kernel_param *kp)
> return strlen(buffer) + 1;
> }
>
> -static const struct kernel_param_ops vm_cmdline_param_ops = {
> - .set = vm_cmdline_set,
> - .get = vm_cmdline_get,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(vm_cmdline_param_ops, vm_cmdline_set,
> + vm_cmdline_get);
>
> device_param_cb(device, &vm_cmdline_param_ops, NULL, S_IRUSR);
>
> diff --git a/fs/ceph/super.c b/fs/ceph/super.c
> index c05fbd4237f8..dec8024b8ac7 100644
> --- a/fs/ceph/super.c
> +++ b/fs/ceph/super.c
> @@ -1684,10 +1684,8 @@ static int param_set_metrics(const char *val, const struct kernel_param *kp)
> return 0;
> }
>
> -static const struct kernel_param_ops param_ops_metrics = {
> - .set = param_set_metrics,
> - .get = param_get_bool,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(param_ops_metrics, param_set_metrics,
> + param_get_bool);
>
> bool disable_send_metrics = false;
> module_param_cb(disable_send_metrics, ¶m_ops_metrics, &disable_send_metrics, 0644);
> @@ -1695,9 +1693,7 @@ MODULE_PARM_DESC(disable_send_metrics, "Enable sending perf metrics to ceph clus
>
> /* for both v1 and v2 syntax */
> static bool mount_support = true;
> -static const struct kernel_param_ops param_ops_mount_syntax = {
> - .get = param_get_bool,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(param_ops_mount_syntax, NULL, param_get_bool);
> module_param_cb(mount_syntax_v1, ¶m_ops_mount_syntax, &mount_support, 0444);
> module_param_cb(mount_syntax_v2, ¶m_ops_mount_syntax, &mount_support, 0444);
>
> diff --git a/fs/fuse/dir.c b/fs/fuse/dir.c
> index b658b6baf72f..cc955c9952d1 100644
> --- a/fs/fuse/dir.c
> +++ b/fs/fuse/dir.c
> @@ -71,10 +71,7 @@ static int inval_wq_set(const char *val, const struct kernel_param *kp)
>
> return 0;
> }
> -static const struct kernel_param_ops inval_wq_ops = {
> - .set = inval_wq_set,
> - .get = param_get_uint,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(inval_wq_ops, inval_wq_set, param_get_uint);
> module_param_cb(inval_wq, &inval_wq_ops, &inval_wq, 0644);
> __MODULE_PARM_TYPE(inval_wq, "uint");
> MODULE_PARM_DESC(inval_wq,
> diff --git a/fs/nfs/namespace.c b/fs/nfs/namespace.c
> index af9be0c5f516..f2fba60dc5ed 100644
> --- a/fs/nfs/namespace.c
> +++ b/fs/nfs/namespace.c
> @@ -372,10 +372,8 @@ static int param_get_nfs_timeout(char *buffer, const struct kernel_param *kp)
> return sysfs_emit(buffer, "%li\n", num);
> }
>
> -static const struct kernel_param_ops param_ops_nfs_timeout = {
> - .set = param_set_nfs_timeout,
> - .get = param_get_nfs_timeout,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(param_ops_nfs_timeout, param_set_nfs_timeout,
> + param_get_nfs_timeout);
> #define param_check_nfs_timeout(name, p) __param_check(name, p, int)
>
> module_param(nfs_mountpoint_expiry_timeout, nfs_timeout, 0644);
> diff --git a/fs/nfs/super.c b/fs/nfs/super.c
> index 4cd420b14ce3..59d89a18aba6 100644
> --- a/fs/nfs/super.c
> +++ b/fs/nfs/super.c
> @@ -1419,10 +1419,8 @@ static int param_set_portnr(const char *val, const struct kernel_param *kp)
> *((unsigned int *)kp->arg) = num;
> return 0;
> }
> -static const struct kernel_param_ops param_ops_portnr = {
> - .set = param_set_portnr,
> - .get = param_get_uint,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(param_ops_portnr, param_set_portnr,
> + param_get_uint);
> #define param_check_portnr(name, p) __param_check(name, p, unsigned int)
>
> module_param_named(callback_tcpport, nfs_callback_set_tcpport, portnr, 0644);
> diff --git a/fs/ubifs/super.c b/fs/ubifs/super.c
> index 9a77d8b64ffa..e44f8e18f756 100644
> --- a/fs/ubifs/super.c
> +++ b/fs/ubifs/super.c
> @@ -36,10 +36,8 @@ static int ubifs_default_version_set(const char *val, const struct kernel_param
> return param_set_int(val, kp);
> }
>
> -static const struct kernel_param_ops ubifs_default_version_ops = {
> - .set = ubifs_default_version_set,
> - .get = param_get_int,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(ubifs_default_version_ops,
> + ubifs_default_version_set, param_get_int);
>
> int ubifs_default_version = UBIFS_FORMAT_VERSION;
> module_param_cb(default_version, &ubifs_default_version_ops, &ubifs_default_version, 0600);
> diff --git a/kernel/locking/locktorture.c b/kernel/locking/locktorture.c
> index e618bcf75e2d..38ae3b596ef2 100644
> --- a/kernel/locking/locktorture.c
> +++ b/kernel/locking/locktorture.c
> @@ -98,10 +98,8 @@ static bool cpumask_nonempty(cpumask_var_t mask)
> return cpumask_available(mask) && !cpumask_empty(mask);
> }
>
> -static const struct kernel_param_ops lt_bind_ops = {
> - .set = param_set_cpumask,
> - .get = param_get_cpumask,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(lt_bind_ops, param_set_cpumask,
> + param_get_cpumask);
>
> module_param_cb(bind_readers, <_bind_ops, &bind_readers, 0444);
> module_param_cb(bind_writers, <_bind_ops, &bind_writers, 0444);
> diff --git a/kernel/panic.c b/kernel/panic.c
> index 42e5ebde4585..8698374b0d21 100644
> --- a/kernel/panic.c
> +++ b/kernel/panic.c
> @@ -1214,10 +1214,8 @@ static int panic_print_set(const char *val, const struct kernel_param *kp)
> return param_set_ulong(val, kp);
> }
>
> -static const struct kernel_param_ops panic_print_ops = {
> - .set = panic_print_set,
> - .get = param_get_ulong,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(panic_print_ops, panic_print_set,
> + param_get_ulong);
> __core_param_cb(panic_print, &panic_print_ops, &panic_print, 0644);
>
> static int __init oops_setup(char *s)
> diff --git a/kernel/params.c b/kernel/params.c
> index 2cbad1f4dd06..e19fff2926bc 100644
> --- a/kernel/params.c
> +++ b/kernel/params.c
> @@ -297,11 +297,8 @@ void param_free_charp(void *arg)
> }
> EXPORT_SYMBOL(param_free_charp);
>
> -const struct kernel_param_ops param_ops_charp = {
> - .set = param_set_charp,
> - .get = param_get_charp,
> - .free = param_free_charp,
> -};
> +DEFINE_KERNEL_PARAM_OPS_FREE(param_ops_charp, param_set_charp, param_get_charp,
> + param_free_charp);
> EXPORT_SYMBOL(param_ops_charp);
>
> /* Actually could be a bool or an int, for historical reasons. */
> @@ -322,11 +319,7 @@ int param_get_bool(char *buffer, const struct kernel_param *kp)
> }
> EXPORT_SYMBOL(param_get_bool);
>
> -const struct kernel_param_ops param_ops_bool = {
> - .flags = KERNEL_PARAM_OPS_FL_NOARG,
> - .set = param_set_bool,
> - .get = param_get_bool,
> -};
> +DEFINE_KERNEL_PARAM_OPS_NOARG(param_ops_bool, param_set_bool, param_get_bool);
> EXPORT_SYMBOL(param_ops_bool);
>
> int param_set_bool_enable_only(const char *val, const struct kernel_param *kp)
> @@ -353,11 +346,8 @@ int param_set_bool_enable_only(const char *val, const struct kernel_param *kp)
> }
> EXPORT_SYMBOL_GPL(param_set_bool_enable_only);
>
> -const struct kernel_param_ops param_ops_bool_enable_only = {
> - .flags = KERNEL_PARAM_OPS_FL_NOARG,
> - .set = param_set_bool_enable_only,
> - .get = param_get_bool,
> -};
> +DEFINE_KERNEL_PARAM_OPS_NOARG(param_ops_bool_enable_only,
> + param_set_bool_enable_only, param_get_bool);
> EXPORT_SYMBOL_GPL(param_ops_bool_enable_only);
>
> /* This one must be bool. */
> @@ -381,10 +371,7 @@ int param_get_invbool(char *buffer, const struct kernel_param *kp)
> }
> EXPORT_SYMBOL(param_get_invbool);
>
> -const struct kernel_param_ops param_ops_invbool = {
> - .set = param_set_invbool,
> - .get = param_get_invbool,
> -};
> +DEFINE_KERNEL_PARAM_OPS(param_ops_invbool, param_set_invbool, param_get_invbool);
> EXPORT_SYMBOL(param_ops_invbool);
>
> int param_set_bint(const char *val, const struct kernel_param *kp)
> @@ -403,11 +390,7 @@ int param_set_bint(const char *val, const struct kernel_param *kp)
> }
> EXPORT_SYMBOL(param_set_bint);
>
> -const struct kernel_param_ops param_ops_bint = {
> - .flags = KERNEL_PARAM_OPS_FL_NOARG,
> - .set = param_set_bint,
> - .get = param_get_int,
> -};
> +DEFINE_KERNEL_PARAM_OPS_NOARG(param_ops_bint, param_set_bint, param_get_int);
> EXPORT_SYMBOL(param_ops_bint);
>
> /* We break the rule and mangle the string. */
> @@ -515,11 +498,8 @@ static void param_array_free(void *arg)
> arr->ops->free(arr->elem + arr->elemsize * i);
> }
>
> -const struct kernel_param_ops param_array_ops = {
> - .set = param_array_set,
> - .get = param_array_get,
> - .free = param_array_free,
> -};
> +DEFINE_KERNEL_PARAM_OPS_FREE(param_array_ops, param_array_set, param_array_get,
> + param_array_free);
> EXPORT_SYMBOL(param_array_ops);
>
> int param_set_copystring(const char *val, const struct kernel_param *kp)
> @@ -544,10 +524,8 @@ int param_get_string(char *buffer, const struct kernel_param *kp)
> }
> EXPORT_SYMBOL(param_get_string);
>
> -const struct kernel_param_ops param_ops_string = {
> - .set = param_set_copystring,
> - .get = param_get_string,
> -};
> +DEFINE_KERNEL_PARAM_OPS(param_ops_string, param_set_copystring,
> + param_get_string);
> EXPORT_SYMBOL(param_ops_string);
>
> /* sysfs output in /sys/modules/XYZ/parameters/ */
> diff --git a/kernel/power/hibernate.c b/kernel/power/hibernate.c
> index af8d07bafe02..aba1e4489447 100644
> --- a/kernel/power/hibernate.c
> +++ b/kernel/power/hibernate.c
> @@ -1528,10 +1528,8 @@ static int hibernate_compressor_param_set(const char *compressor,
> return ret;
> }
>
> -static const struct kernel_param_ops hibernate_compressor_param_ops = {
> - .set = hibernate_compressor_param_set,
> - .get = param_get_string,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(hibernate_compressor_param_ops,
> + hibernate_compressor_param_set, param_get_string);
>
> static struct kparam_string hibernate_compressor_param_string = {
> .maxlen = sizeof(hibernate_compressor),
> diff --git a/kernel/rcu/tree.c b/kernel/rcu/tree.c
> index 55df6d37145e..e675d7f1b4ee 100644
> --- a/kernel/rcu/tree.c
> +++ b/kernel/rcu/tree.c
> @@ -498,15 +498,11 @@ static int param_set_next_fqs_jiffies(const char *val, const struct kernel_param
> return ret;
> }
>
> -static const struct kernel_param_ops first_fqs_jiffies_ops = {
> - .set = param_set_first_fqs_jiffies,
> - .get = param_get_ulong,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(first_fqs_jiffies_ops,
> + param_set_first_fqs_jiffies, param_get_ulong);
>
> -static const struct kernel_param_ops next_fqs_jiffies_ops = {
> - .set = param_set_next_fqs_jiffies,
> - .get = param_get_ulong,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(next_fqs_jiffies_ops, param_set_next_fqs_jiffies,
> + param_get_ulong);
>
> module_param_cb(jiffies_till_first_fqs, &first_fqs_jiffies_ops, &jiffies_till_first_fqs, 0644);
> module_param_cb(jiffies_till_next_fqs, &next_fqs_jiffies_ops, &jiffies_till_next_fqs, 0644);
> @@ -3979,10 +3975,8 @@ static int param_get_do_rcu_barrier(char *buffer, const struct kernel_param *kp)
> return sprintf(buffer, "%d\n", atomic_read((atomic_t *)kp->arg));
> }
>
> -static const struct kernel_param_ops do_rcu_barrier_ops = {
> - .set = param_set_do_rcu_barrier,
> - .get = param_get_do_rcu_barrier,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(do_rcu_barrier_ops, param_set_do_rcu_barrier,
> + param_get_do_rcu_barrier);
> static atomic_t do_rcu_barrier;
> module_param_cb(do_rcu_barrier, &do_rcu_barrier_ops, &do_rcu_barrier, 0644);
>
> diff --git a/kernel/sched/ext.c b/kernel/sched/ext.c
> index 345aa11b84b2..fcf31e3e4965 100644
> --- a/kernel/sched/ext.c
> +++ b/kernel/sched/ext.c
> @@ -166,20 +166,15 @@ static int set_slice_us(const char *val, const struct kernel_param *kp)
> return param_set_uint_minmax(val, kp, 100, 100 * USEC_PER_MSEC);
> }
>
> -static const struct kernel_param_ops slice_us_param_ops = {
> - .set = set_slice_us,
> - .get = param_get_uint,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(slice_us_param_ops, set_slice_us, param_get_uint);
>
> static int set_bypass_lb_intv_us(const char *val, const struct kernel_param *kp)
> {
> return param_set_uint_minmax(val, kp, 0, 10 * USEC_PER_SEC);
> }
>
> -static const struct kernel_param_ops bypass_lb_intv_us_param_ops = {
> - .set = set_bypass_lb_intv_us,
> - .get = param_get_uint,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(bypass_lb_intv_us_param_ops,
> + set_bypass_lb_intv_us, param_get_uint);
>
> #undef MODULE_PARAM_PREFIX
> #define MODULE_PARAM_PREFIX "sched_ext."
> diff --git a/kernel/workqueue.c b/kernel/workqueue.c
> index 5f747f241a5f..42562b811d94 100644
> --- a/kernel/workqueue.c
> +++ b/kernel/workqueue.c
> @@ -7162,10 +7162,8 @@ static int wq_affn_dfl_get(char *buffer, const struct kernel_param *kp)
> return scnprintf(buffer, PAGE_SIZE, "%s\n", wq_affn_names[wq_affn_dfl]);
> }
>
> -static const struct kernel_param_ops wq_affn_dfl_ops = {
> - .set = wq_affn_dfl_set,
> - .get = wq_affn_dfl_get,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(wq_affn_dfl_ops, wq_affn_dfl_set,
> + wq_affn_dfl_get);
>
> module_param_cb(default_affinity_scope, &wq_affn_dfl_ops, NULL, 0644);
>
> @@ -7861,10 +7859,8 @@ static int wq_watchdog_param_set_thresh(const char *val,
> return 0;
> }
>
> -static const struct kernel_param_ops wq_watchdog_thresh_ops = {
> - .set = wq_watchdog_param_set_thresh,
> - .get = param_get_ulong,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(wq_watchdog_thresh_ops,
> + wq_watchdog_param_set_thresh, param_get_ulong);
>
> module_param_cb(watchdog_thresh, &wq_watchdog_thresh_ops, &wq_watchdog_thresh,
> 0644);
> diff --git a/lib/dynamic_debug.c b/lib/dynamic_debug.c
> index 18a71a9108d3..cf0405ba0dbd 100644
> --- a/lib/dynamic_debug.c
> +++ b/lib/dynamic_debug.c
> @@ -807,10 +807,8 @@ int param_get_dyndbg_classes(char *buffer, const struct kernel_param *kp)
> }
> EXPORT_SYMBOL(param_get_dyndbg_classes);
>
> -const struct kernel_param_ops param_ops_dyndbg_classes = {
> - .set = param_set_dyndbg_classes,
> - .get = param_get_dyndbg_classes,
> -};
> +DEFINE_KERNEL_PARAM_OPS(param_ops_dyndbg_classes, param_set_dyndbg_classes,
> + param_get_dyndbg_classes);
> EXPORT_SYMBOL(param_ops_dyndbg_classes);
>
> #define PREFIX_SIZE 128
> diff --git a/lib/test_dynamic_debug.c b/lib/test_dynamic_debug.c
> index 77c2a669b6af..30880b6c726a 100644
> --- a/lib/test_dynamic_debug.c
> +++ b/lib/test_dynamic_debug.c
> @@ -23,10 +23,8 @@ static int param_get_do_prints(char *buffer, const struct kernel_param *kp)
> do_prints();
> return scnprintf(buffer, PAGE_SIZE, "did do_prints\n");
> }
> -static const struct kernel_param_ops param_ops_do_prints = {
> - .set = param_set_do_prints,
> - .get = param_get_do_prints,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(param_ops_do_prints, param_set_do_prints,
> + param_get_do_prints);
> module_param_cb(do_prints, ¶m_ops_do_prints, NULL, 0600);
>
> /*
> diff --git a/mm/damon/lru_sort.c b/mm/damon/lru_sort.c
> index 8494040b1ee4..5feb93c5262e 100644
> --- a/mm/damon/lru_sort.c
> +++ b/mm/damon/lru_sort.c
> @@ -405,10 +405,8 @@ static int damon_lru_sort_addr_unit_store(const char *val,
> return 0;
> }
>
> -static const struct kernel_param_ops addr_unit_param_ops = {
> - .set = damon_lru_sort_addr_unit_store,
> - .get = param_get_ulong,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(addr_unit_param_ops,
> + damon_lru_sort_addr_unit_store, param_get_ulong);
>
> module_param_cb(addr_unit, &addr_unit_param_ops, &addr_unit, 0600);
> MODULE_PARM_DESC(addr_unit,
> @@ -446,10 +444,8 @@ static int damon_lru_sort_enabled_load(char *buffer,
> return sprintf(buffer, "%c\n", damon_lru_sort_enabled() ? 'Y' : 'N');
> }
>
> -static const struct kernel_param_ops enabled_param_ops = {
> - .set = damon_lru_sort_enabled_store,
> - .get = damon_lru_sort_enabled_load,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(enabled_param_ops, damon_lru_sort_enabled_store,
> + damon_lru_sort_enabled_load);
>
> module_param_cb(enabled, &enabled_param_ops, &enabled, 0600);
> MODULE_PARM_DESC(enabled,
> @@ -478,10 +474,9 @@ static int damon_lru_sort_kdamond_pid_load(char *buffer,
> return sprintf(buffer, "%d\n", kdamond_pid);
> }
>
> -static const struct kernel_param_ops kdamond_pid_param_ops = {
> - .set = damon_lru_sort_kdamond_pid_store,
> - .get = damon_lru_sort_kdamond_pid_load,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(kdamond_pid_param_ops,
> + damon_lru_sort_kdamond_pid_store,
> + damon_lru_sort_kdamond_pid_load);
>
> /*
> * PID of the DAMON thread
> diff --git a/mm/damon/reclaim.c b/mm/damon/reclaim.c
> index fe7fce26cf6c..27e772b095fa 100644
> --- a/mm/damon/reclaim.c
> +++ b/mm/damon/reclaim.c
> @@ -307,10 +307,8 @@ static int damon_reclaim_addr_unit_store(const char *val,
> return 0;
> }
>
> -static const struct kernel_param_ops addr_unit_param_ops = {
> - .set = damon_reclaim_addr_unit_store,
> - .get = param_get_ulong,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(addr_unit_param_ops,
> + damon_reclaim_addr_unit_store, param_get_ulong);
>
> module_param_cb(addr_unit, &addr_unit_param_ops, &addr_unit, 0600);
> MODULE_PARM_DESC(addr_unit,
> @@ -348,10 +346,8 @@ static int damon_reclaim_enabled_load(char *buffer,
> return sprintf(buffer, "%c\n", damon_reclaim_enabled() ? 'Y' : 'N');
> }
>
> -static const struct kernel_param_ops enabled_param_ops = {
> - .set = damon_reclaim_enabled_store,
> - .get = damon_reclaim_enabled_load,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(enabled_param_ops, damon_reclaim_enabled_store,
> + damon_reclaim_enabled_load);
>
> module_param_cb(enabled, &enabled_param_ops, &enabled, 0600);
> MODULE_PARM_DESC(enabled,
> @@ -380,10 +376,9 @@ static int damon_reclaim_kdamond_pid_load(char *buffer,
> return sprintf(buffer, "%d\n", kdamond_pid);
> }
>
> -static const struct kernel_param_ops kdamond_pid_param_ops = {
> - .set = damon_reclaim_kdamond_pid_store,
> - .get = damon_reclaim_kdamond_pid_load,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(kdamond_pid_param_ops,
> + damon_reclaim_kdamond_pid_store,
> + damon_reclaim_kdamond_pid_load);
>
> /*
> * PID of the DAMON thread
> diff --git a/mm/damon/stat.c b/mm/damon/stat.c
> index 3951b762cbdd..6eb548793802 100644
> --- a/mm/damon/stat.c
> +++ b/mm/damon/stat.c
> @@ -22,10 +22,8 @@ static int damon_stat_enabled_store(
> static int damon_stat_enabled_load(char *buffer,
> const struct kernel_param *kp);
>
> -static const struct kernel_param_ops enabled_param_ops = {
> - .set = damon_stat_enabled_store,
> - .get = damon_stat_enabled_load,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(enabled_param_ops, damon_stat_enabled_store,
> + damon_stat_enabled_load);
>
> static bool enabled __read_mostly = IS_ENABLED(
> CONFIG_DAMON_STAT_ENABLED_DEFAULT);
> diff --git a/mm/memory_hotplug.c b/mm/memory_hotplug.c
> index 2a943ec57c85..42e0cf313281 100644
> --- a/mm/memory_hotplug.c
> +++ b/mm/memory_hotplug.c
> @@ -109,10 +109,8 @@ static int get_memmap_mode(char *buffer, const struct kernel_param *kp)
> return sprintf(buffer, "%c\n", mode ? 'Y' : 'N');
> }
>
> -static const struct kernel_param_ops memmap_mode_ops = {
> - .set = set_memmap_mode,
> - .get = get_memmap_mode,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(memmap_mode_ops, set_memmap_mode,
> + get_memmap_mode);
> module_param_cb(memmap_on_memory, &memmap_mode_ops, &memmap_mode, 0444);
> MODULE_PARM_DESC(memmap_on_memory, "Enable memmap on memory for memory hotplug\n"
> "With value \"force\" it could result in memory wastage due "
> @@ -163,10 +161,8 @@ static int get_online_policy(char *buffer, const struct kernel_param *kp)
> * (auto_movable_ratio, auto_movable_numa_aware) allows for it
> */
> static int online_policy __read_mostly = ONLINE_POLICY_CONTIG_ZONES;
> -static const struct kernel_param_ops online_policy_ops = {
> - .set = set_online_policy,
> - .get = get_online_policy,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(online_policy_ops, set_online_policy,
> + get_online_policy);
> module_param_cb(online_policy, &online_policy_ops, &online_policy, 0644);
> MODULE_PARM_DESC(online_policy,
> "Set the online policy (\"contig-zones\", \"auto-movable\") "
> diff --git a/mm/page_reporting.c b/mm/page_reporting.c
> index 7418f2e500bb..61351e12b4d9 100644
> --- a/mm/page_reporting.c
> +++ b/mm/page_reporting.c
> @@ -23,15 +23,8 @@ static int page_order_update_notify(const char *val, const struct kernel_param *
> return param_set_uint_minmax(val, kp, 0, MAX_PAGE_ORDER);
> }
>
> -static const struct kernel_param_ops page_reporting_param_ops = {
> - .set = &page_order_update_notify,
> - /*
> - * For the get op, use param_get_int instead of param_get_uint.
> - * This is to make sure that when unset the initialized value of
> - * -1 is shown correctly
> - */
> - .get = ¶m_get_int,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(page_reporting_param_ops,
> + &page_order_update_notify, ¶m_get_int);
>
> module_param_cb(page_reporting_order, &page_reporting_param_ops,
> &page_reporting_order, 0644);
> diff --git a/mm/shuffle.c b/mm/shuffle.c
> index fb1393b8b3a9..114fe7467516 100644
> --- a/mm/shuffle.c
> +++ b/mm/shuffle.c
> @@ -23,10 +23,8 @@ static __meminit int shuffle_param_set(const char *val,
> return 0;
> }
>
> -static const struct kernel_param_ops shuffle_param_ops = {
> - .set = shuffle_param_set,
> - .get = param_get_bool,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(shuffle_param_ops, shuffle_param_set,
> + param_get_bool);
> module_param_cb(shuffle, &shuffle_param_ops, &shuffle_param, 0400);
>
> /*
> diff --git a/mm/zswap.c b/mm/zswap.c
> index 4b5149173b0e..ed3aa07c2f1d 100644
> --- a/mm/zswap.c
> +++ b/mm/zswap.c
> @@ -90,21 +90,17 @@ static DEFINE_STATIC_KEY_MAYBE(CONFIG_ZSWAP_DEFAULT_ON, zswap_ever_enabled);
> static bool zswap_enabled = IS_ENABLED(CONFIG_ZSWAP_DEFAULT_ON);
> static int zswap_enabled_param_set(const char *,
> const struct kernel_param *);
> -static const struct kernel_param_ops zswap_enabled_param_ops = {
> - .set = zswap_enabled_param_set,
> - .get = param_get_bool,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(zswap_enabled_param_ops, zswap_enabled_param_set,
> + param_get_bool);
> module_param_cb(enabled, &zswap_enabled_param_ops, &zswap_enabled, 0644);
>
> /* Crypto compressor to use */
> static char *zswap_compressor = CONFIG_ZSWAP_COMPRESSOR_DEFAULT;
> static int zswap_compressor_param_set(const char *,
> const struct kernel_param *);
> -static const struct kernel_param_ops zswap_compressor_param_ops = {
> - .set = zswap_compressor_param_set,
> - .get = param_get_charp,
> - .free = param_free_charp,
> -};
> +static DEFINE_KERNEL_PARAM_OPS_FREE(zswap_compressor_param_ops,
> + zswap_compressor_param_set, param_get_charp,
> + param_free_charp);
> module_param_cb(compressor, &zswap_compressor_param_ops,
> &zswap_compressor, 0644);
>
> diff --git a/net/batman-adv/bat_algo.c b/net/batman-adv/bat_algo.c
> index 49e5861b58ec..54d66a948298 100644
> --- a/net/batman-adv/bat_algo.c
> +++ b/net/batman-adv/bat_algo.c
> @@ -134,10 +134,8 @@ static int batadv_param_set_ra(const char *val, const struct kernel_param *kp)
> return param_set_copystring(algo_name, kp);
> }
>
> -static const struct kernel_param_ops batadv_param_ops_ra = {
> - .set = batadv_param_set_ra,
> - .get = param_get_string,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(batadv_param_ops_ra, batadv_param_set_ra,
> + param_get_string);
>
> static struct kparam_string batadv_param_string_ra = {
> .maxlen = sizeof(batadv_routing_algo),
> diff --git a/net/ceph/ceph_common.c b/net/ceph/ceph_common.c
> index 952121849180..633202a99e4a 100644
> --- a/net/ceph/ceph_common.c
> +++ b/net/ceph/ceph_common.c
> @@ -52,9 +52,8 @@ static int param_get_supported_features(char *buffer,
> {
> return sprintf(buffer, "0x%llx", CEPH_FEATURES_SUPPORTED_DEFAULT);
> }
> -static const struct kernel_param_ops param_ops_supported_features = {
> - .get = param_get_supported_features,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(param_ops_supported_features, NULL,
> + param_get_supported_features);
> module_param_cb(supported_features, ¶m_ops_supported_features, NULL,
> 0444);
>
> diff --git a/net/ipv4/tcp_dctcp.c b/net/ipv4/tcp_dctcp.c
> index 274e628e7cf8..2c9c3d0f3c3d 100644
> --- a/net/ipv4/tcp_dctcp.c
> +++ b/net/ipv4/tcp_dctcp.c
> @@ -64,10 +64,8 @@ static int dctcp_shift_g_set(const char *val, const struct kernel_param *kp)
> return param_set_uint_minmax(val, kp, 0, 10);
> }
>
> -static const struct kernel_param_ops dctcp_shift_g_ops = {
> - .set = dctcp_shift_g_set,
> - .get = param_get_uint,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(dctcp_shift_g_ops, dctcp_shift_g_set,
> + param_get_uint);
>
> module_param_cb(dctcp_shift_g, &dctcp_shift_g_ops, &dctcp_shift_g, 0644);
> MODULE_PARM_DESC(dctcp_shift_g, "parameter g for updating dctcp_alpha");
> diff --git a/net/sunrpc/auth.c b/net/sunrpc/auth.c
> index 68c0595ea2fd..64a3e894fd4c 100644
> --- a/net/sunrpc/auth.c
> +++ b/net/sunrpc/auth.c
> @@ -83,10 +83,8 @@ static int param_get_hashtbl_sz(char *buffer, const struct kernel_param *kp)
>
> #define param_check_hashtbl_sz(name, p) __param_check(name, p, unsigned int);
>
> -static const struct kernel_param_ops param_ops_hashtbl_sz = {
> - .set = param_set_hashtbl_sz,
> - .get = param_get_hashtbl_sz,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(param_ops_hashtbl_sz, param_set_hashtbl_sz,
> + param_get_hashtbl_sz);
>
> module_param_named(auth_hashtable_size, auth_hashbits, hashtbl_sz, 0644);
> MODULE_PARM_DESC(auth_hashtable_size, "RPC credential cache hashtable size");
> diff --git a/net/sunrpc/xprtsock.c b/net/sunrpc/xprtsock.c
> index 2e1fe6013361..e8d087798994 100644
> --- a/net/sunrpc/xprtsock.c
> +++ b/net/sunrpc/xprtsock.c
> @@ -3710,10 +3710,8 @@ static int param_set_portnr(const char *val, const struct kernel_param *kp)
> RPC_MAX_RESVPORT);
> }
>
> -static const struct kernel_param_ops param_ops_portnr = {
> - .set = param_set_portnr,
> - .get = param_get_uint,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(param_ops_portnr, param_set_portnr,
> + param_get_uint);
>
> #define param_check_portnr(name, p) \
> __param_check(name, p, unsigned int);
> @@ -3729,10 +3727,8 @@ static int param_set_slot_table_size(const char *val,
> RPC_MAX_SLOT_TABLE);
> }
>
> -static const struct kernel_param_ops param_ops_slot_table_size = {
> - .set = param_set_slot_table_size,
> - .get = param_get_uint,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(param_ops_slot_table_size,
> + param_set_slot_table_size, param_get_uint);
>
> #define param_check_slot_table_size(name, p) \
> __param_check(name, p, unsigned int);
> @@ -3745,10 +3741,8 @@ static int param_set_max_slot_table_size(const char *val,
> RPC_MAX_SLOT_TABLE_LIMIT);
> }
>
> -static const struct kernel_param_ops param_ops_max_slot_table_size = {
> - .set = param_set_max_slot_table_size,
> - .get = param_get_uint,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(param_ops_max_slot_table_size,
> + param_set_max_slot_table_size, param_get_uint);
>
> #define param_check_max_slot_table_size(name, p) \
> __param_check(name, p, unsigned int);
> diff --git a/samples/damon/mtier.c b/samples/damon/mtier.c
> index 775838a23d93..c8018a7ea891 100644
> --- a/samples/damon/mtier.c
> +++ b/samples/damon/mtier.c
> @@ -38,10 +38,8 @@ module_param(node0_mem_free_bp, ulong, 0600);
> static int damon_sample_mtier_enable_store(
> const char *val, const struct kernel_param *kp);
>
> -static const struct kernel_param_ops enabled_param_ops = {
> - .set = damon_sample_mtier_enable_store,
> - .get = param_get_bool,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(enabled_param_ops,
> + damon_sample_mtier_enable_store, param_get_bool);
>
> static bool enabled __read_mostly;
> module_param_cb(enabled, &enabled_param_ops, &enabled, 0600);
> diff --git a/samples/damon/prcl.c b/samples/damon/prcl.c
> index b7c50f2656ce..7cab9bd0f7bd 100644
> --- a/samples/damon/prcl.c
> +++ b/samples/damon/prcl.c
> @@ -22,10 +22,8 @@ module_param(target_pid, int, 0600);
> static int damon_sample_prcl_enable_store(
> const char *val, const struct kernel_param *kp);
>
> -static const struct kernel_param_ops enabled_param_ops = {
> - .set = damon_sample_prcl_enable_store,
> - .get = param_get_bool,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(enabled_param_ops,
> + damon_sample_prcl_enable_store, param_get_bool);
>
> static bool enabled __read_mostly;
> module_param_cb(enabled, &enabled_param_ops, &enabled, 0600);
> diff --git a/samples/damon/wsse.c b/samples/damon/wsse.c
> index 799ad4443943..56634853bd0b 100644
> --- a/samples/damon/wsse.c
> +++ b/samples/damon/wsse.c
> @@ -23,10 +23,8 @@ module_param(target_pid, int, 0600);
> static int damon_sample_wsse_enable_store(
> const char *val, const struct kernel_param *kp);
>
> -static const struct kernel_param_ops enabled_param_ops = {
> - .set = damon_sample_wsse_enable_store,
> - .get = param_get_bool,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(enabled_param_ops,
> + damon_sample_wsse_enable_store, param_get_bool);
>
> static bool enabled __read_mostly;
> module_param_cb(enabled, &enabled_param_ops, &enabled, 0600);
> diff --git a/security/apparmor/lsm.c b/security/apparmor/lsm.c
> index 3491e9f60194..8a253c743363 100644
> --- a/security/apparmor/lsm.c
> +++ b/security/apparmor/lsm.c
> @@ -1767,38 +1767,30 @@ static struct security_hook_list apparmor_hooks[] __ro_after_init = {
> static int param_set_aabool(const char *val, const struct kernel_param *kp);
> static int param_get_aabool(char *buffer, const struct kernel_param *kp);
> #define param_check_aabool param_check_bool
> -static const struct kernel_param_ops param_ops_aabool = {
> - .flags = KERNEL_PARAM_OPS_FL_NOARG,
> - .set = param_set_aabool,
> - .get = param_get_aabool
> -};
> +static DEFINE_KERNEL_PARAM_OPS_NOARG(param_ops_aabool, param_set_aabool,
> + param_get_aabool);
>
> static int param_set_aauint(const char *val, const struct kernel_param *kp);
> static int param_get_aauint(char *buffer, const struct kernel_param *kp);
> #define param_check_aauint param_check_uint
> -static const struct kernel_param_ops param_ops_aauint = {
> - .set = param_set_aauint,
> - .get = param_get_aauint
> -};
> +static DEFINE_KERNEL_PARAM_OPS(param_ops_aauint, param_set_aauint,
> + param_get_aauint);
>
> static int param_set_aacompressionlevel(const char *val,
> const struct kernel_param *kp);
> static int param_get_aacompressionlevel(char *buffer,
> const struct kernel_param *kp);
> #define param_check_aacompressionlevel param_check_int
> -static const struct kernel_param_ops param_ops_aacompressionlevel = {
> - .set = param_set_aacompressionlevel,
> - .get = param_get_aacompressionlevel
> -};
> +static DEFINE_KERNEL_PARAM_OPS(param_ops_aacompressionlevel,
> + param_set_aacompressionlevel,
> + param_get_aacompressionlevel);
>
> static int param_set_aalockpolicy(const char *val, const struct kernel_param *kp);
> static int param_get_aalockpolicy(char *buffer, const struct kernel_param *kp);
> #define param_check_aalockpolicy param_check_bool
> -static const struct kernel_param_ops param_ops_aalockpolicy = {
> - .flags = KERNEL_PARAM_OPS_FL_NOARG,
> - .set = param_set_aalockpolicy,
> - .get = param_get_aalockpolicy
> -};
> +static DEFINE_KERNEL_PARAM_OPS_NOARG(param_ops_aalockpolicy,
> + param_set_aalockpolicy,
> + param_get_aalockpolicy);
>
> static int param_set_debug(const char *val, const struct kernel_param *kp);
> static int param_get_debug(char *buffer, const struct kernel_param *kp);
> @@ -1879,10 +1871,8 @@ module_param_named(paranoid_load, aa_g_paranoid_load, aabool, S_IRUGO);
> static int param_get_aaintbool(char *buffer, const struct kernel_param *kp);
> static int param_set_aaintbool(const char *val, const struct kernel_param *kp);
> #define param_check_aaintbool param_check_int
> -static const struct kernel_param_ops param_ops_aaintbool = {
> - .set = param_set_aaintbool,
> - .get = param_get_aaintbool
> -};
> +static DEFINE_KERNEL_PARAM_OPS(param_ops_aaintbool, param_set_aaintbool,
> + param_get_aaintbool);
> /* Boot time disable flag */
> static int apparmor_enabled __ro_after_init = 1;
> module_param_named(enabled, apparmor_enabled, aaintbool, 0444);
> diff --git a/sound/hda/controllers/intel.c b/sound/hda/controllers/intel.c
> index c87d75dbd8aa..02bd61e67902 100644
> --- a/sound/hda/controllers/intel.c
> +++ b/sound/hda/controllers/intel.c
> @@ -164,10 +164,7 @@ MODULE_PARM_DESC(ctl_dev_id, "Use control device identifier (based on codec addr
>
> #ifdef CONFIG_PM
> static int param_set_xint(const char *val, const struct kernel_param *kp);
> -static const struct kernel_param_ops param_ops_xint = {
> - .set = param_set_xint,
> - .get = param_get_int,
> -};
> +static DEFINE_KERNEL_PARAM_OPS(param_ops_xint, param_set_xint, param_get_int);
> #define param_check_xint param_check_int
>
> static int power_save = CONFIG_SND_HDA_POWER_SAVE_DEFAULT;
> diff --git a/sound/usb/card.c b/sound/usb/card.c
> index f42d72cd0378..34cbb9d72315 100644
> --- a/sound/usb/card.c
> +++ b/sound/usb/card.c
> @@ -118,11 +118,8 @@ static int param_set_quirkp(const char *val,
> return param_set_charp(val, kp);
> }
>
> -static const struct kernel_param_ops param_ops_quirkp = {
> - .set = param_set_quirkp,
> - .get = param_get_charp,
> - .free = param_free_charp,
> -};
> +static DEFINE_KERNEL_PARAM_OPS_FREE(param_ops_quirkp, param_set_quirkp,
> + param_get_charp, param_free_charp);
>
> #define param_check_quirkp param_check_charp
>
> --
> 2.34.1
>
^ permalink raw reply
* Re: [PATCH v2 0/8] x86/msr: Consolidate native/paravirt MSR functions
From: Juergen Gross @ 2026-05-22 9:46 UTC (permalink / raw)
To: Dave Hansen, Thomas Gleixner, linux-kernel, Ingo Molnar,
Borislav Petkov
Cc: x86, virtualization
In-Reply-To: <e7c72dde-7e8e-457a-9f9f-c3799cbe28e2@suse.com>
[-- Attachment #1.1.1: Type: text/plain, Size: 1928 bytes --]
On 30.04.26 09:21, Jürgen Groß wrote:
> On 29.04.26 20:45, Dave Hansen wrote:
>> Changes from v1:
>> - Remove "raw_" names. Just use "paravirt_" in the generic code.
>>
>> I'm thinking I'll just apply this in the coming days if nobody
>> screams too loudly.
>>
>> --
>>
>> This is old cruft, but it appears that having two copies of these
>> MSR functions is enabling warnings to creep in[1].
>>
>> I know there's also been some work to pare down the XXL code, but
>> it's obviously not merged yet and this is a good baby step.
>>
>> Create helpers that both paravirt and native can use in common code
>> and remove the paravirt implementations of the helpers. This reduces
>> the amount of logic that is duplicated in the paravirt code.
>>
>> The wonky thing about this solution is that it has the common code
>> always make literal "paravirt_" calls, even when paravirt is not in
>> use for MSRs. In that case, the calls just go directly to the
>> "native_" functions via #defines.
>>
>> Conceptually:
>> - native: The bare-metal implementation. Might not be usable under
>> paravirt XXL.
>> - paravirt: Call the native version directly if paravirt is compiled
>> out. Call into paravirt ops when available, which might
>> ultimately call a native implementation.
>>
>> 1. https://lore.kernel.org/all/20260319152210.210854-1-aldocontelk@gmail.com/
>>
>> msr.h | 124 +++++++++++++++++++++++++++++++------------------------------
>> paravirt.h | 44 ---------------------
>> 2 files changed, 65 insertions(+), 103 deletions(-)
>
> Apart from the comment for patch 8:
>
> Reviewed-by: Juergen Gross <jgross@suse.com>
Is this going to be taken in near future?
Just asking to know whether I should base the MSR patches I'm working on
on current master or on these patches.
Juergen
[-- Attachment #1.1.2: OpenPGP public key --]
[-- Type: application/pgp-keys, Size: 3743 bytes --]
[-- Attachment #2: OpenPGP digital signature --]
[-- Type: application/pgp-signature, Size: 495 bytes --]
^ permalink raw reply
* Re: [PATCH v2] drm/virtio: abort virtqueue wait on device removal to avoid hung task
From: Ryosuke Yasuoka @ 2026-05-22 8:51 UTC (permalink / raw)
To: Dmitry Osipenko, David Airlie, Gerd Hoffmann, Gurchetan Singh,
Chia-I Wu, Maarten Lankhorst, Maxime Ripard, Thomas Zimmermann,
Simona Vetter
Cc: dri-devel, virtualization, linux-kernel,
syzbot+d6dd6f86d3aaf7eebe7406e45c1c6e549453f224,
syzbot+908bd910da5dd79b88de4cf7baf376cc873a922e
In-Reply-To: <4bc3709f-21bc-49f5-8fcf-972dec1397f7@collabora.com>
Hi Dmitry,
Thank you for your review and the comment.
On 21/05/2026 22:01, Dmitry Osipenko wrote:
> 21.05.2026 05:19, Ryosuke Yasuoka пишет:
>> virtio_gpu_queue_ctrl_sgs() and virtio_gpu_queue_cursor() use
>> wait_event() without any abort condition when waiting for virtqueue
>> space. If the host device stops processing commands, these waits block
>> indefinitely inside a drm_dev_enter/exit() critical section. Since
>> drm_dev_unplug(), which is called in device removal and system shutdown
>> call path, blocks on synchronize_srcu() until all critical sections
>> complete, device removal and system shutdown also hang.
>>
>> Add a vqs_released flag to virtio_gpu_device and include it in the
>> wait_event() condition. Set the flag and wake up both queues in a new
>> virtio_gpu_release_vqs() helper, called before drm_dev_unplug() in both
>> virtio_gpu_remove() and virtio_gpu_shutdown(). When the flag is set, the
>> wait returns immediately and the command is aborted, following the same
>> cleanup path as drm_dev_enter() failure.
>>
>> Reported-by: syzbot+d6dd6f86d3aaf7eebe7406e45c1c6e549453f224@syzkaller.appspotmail.com
>> Closes: https://syzkaller.appspot.com/bug?id=d6dd6f86d3aaf7eebe7406e45c1c6e549453f224
>> Reported-by: syzbot+908bd910da5dd79b88de4cf7baf376cc873a922e@syzkaller.appspotmail.com
>> Closes: https://syzkaller.appspot.com/bug?id=908bd910da5dd79b88de4cf7baf376cc873a922e
>> Signed-off-by: Ryosuke Yasuoka <ryasuoka@redhat.com>
>> ---
>> Changes in v2:
>> - Update the commit message.
>> - Replace wait_event_timeout() with wait_event() using a compound
>> condition that includes a new vqs_released flag.
>> - Add virtio_gpu_release_vqs() helper to set the flag and wake up
>> both queues, called before drm_dev_unplug() in remove and shutdown
>> paths.
>> - Remove the hardcoded 5-second timeout. Recovery is now driven by
>> the driver flag instead of an arbitrary timeout value.
>> ---
>> drivers/gpu/drm/virtio/virtgpu_drv.c | 15 +++++++++++++++
>> drivers/gpu/drm/virtio/virtgpu_drv.h | 1 +
>> drivers/gpu/drm/virtio/virtgpu_vq.c | 23 +++++++++++++++++++++--
>> 3 files changed, 37 insertions(+), 2 deletions(-)
>>
>> diff --git a/drivers/gpu/drm/virtio/virtgpu_drv.c b/drivers/gpu/drm/virtio/virtgpu_drv.c
>> index a5ce96fb8a1d..e4fe5e0780f9 100644
>> --- a/drivers/gpu/drm/virtio/virtgpu_drv.c
>> +++ b/drivers/gpu/drm/virtio/virtgpu_drv.c
>> @@ -119,10 +119,24 @@ static int virtio_gpu_probe(struct virtio_device *vdev)
>> return ret;
>> }
>>
>> +/*
>> + * Release pending virtqueue waits so the drm_dev_enter/exit() critical
>> + * sections complete before drm_dev_unplug() blocks on synchronize_srcu().
>> + */
>> +static void virtio_gpu_release_vqs(struct drm_device *dev)
>> +{
>> + struct virtio_gpu_device *vgdev = dev->dev_private;
>> +
>> + vgdev->vqs_released = true;
>> + wake_up_all(&vgdev->ctrlq.ack_queue);
>> + wake_up_all(&vgdev->cursorq.ack_queue);
>> +}
>> +
>> static void virtio_gpu_remove(struct virtio_device *vdev)
>> {
>> struct drm_device *dev = vdev->priv;
>>
>> + virtio_gpu_release_vqs(dev);
>> drm_dev_unplug(dev);
>> drm_atomic_helper_shutdown(dev);
>> virtio_gpu_deinit(dev);
>> @@ -133,6 +147,7 @@ static void virtio_gpu_shutdown(struct virtio_device *vdev)
>> {
>> struct drm_device *dev = vdev->priv;
>>
>> + virtio_gpu_release_vqs(dev);
>> /* stop talking to the device */
>> drm_dev_unplug(dev);
>> }
>> diff --git a/drivers/gpu/drm/virtio/virtgpu_drv.h b/drivers/gpu/drm/virtio/virtgpu_drv.h
>> index f17660a71a3e..0bd69a40857e 100644
>> --- a/drivers/gpu/drm/virtio/virtgpu_drv.h
>> +++ b/drivers/gpu/drm/virtio/virtgpu_drv.h
>> @@ -235,6 +235,7 @@ struct virtio_gpu_device {
>>
>> struct virtio_gpu_queue ctrlq;
>> struct virtio_gpu_queue cursorq;
>> + bool vqs_released;
>> struct kmem_cache *vbufs;
>>
>> atomic_t pending_commands;
>> diff --git a/drivers/gpu/drm/virtio/virtgpu_vq.c b/drivers/gpu/drm/virtio/virtgpu_vq.c
>> index 67865810a2e7..8057a9b7356d 100644
>> --- a/drivers/gpu/drm/virtio/virtgpu_vq.c
>> +++ b/drivers/gpu/drm/virtio/virtgpu_vq.c
>> @@ -396,7 +396,19 @@ static int virtio_gpu_queue_ctrl_sgs(struct virtio_gpu_device *vgdev,
>> if (vq->num_free < elemcnt) {
>> spin_unlock(&vgdev->ctrlq.qlock);
>> virtio_gpu_notify(vgdev);
>> - wait_event(vgdev->ctrlq.ack_queue, vq->num_free >= elemcnt);
>> + wait_event(vgdev->ctrlq.ack_queue,
>> + vq->num_free >= elemcnt || vgdev->vqs_released);
>> + /*
>> + * Set by virtio_gpu_release_vqs() to unblock
>> + * synchronize_srcu() wait in drm_dev_unplug().
>> + */
>> + if (vgdev->vqs_released) {
>> + if (fence && vbuf->objs)
>> + virtio_gpu_array_unlock_resv(vbuf->objs);
>> + free_vbuf(vgdev, vbuf);
>> + drm_dev_exit(idx);
>> + return -ENODEV;
>> + }
>> goto again;
>> }
>>
>> @@ -566,7 +578,14 @@ static void virtio_gpu_queue_cursor(struct virtio_gpu_device *vgdev,
>> ret = virtqueue_add_sgs(vq, sgs, outcnt, 0, vbuf, GFP_ATOMIC);
>> if (ret == -ENOSPC) {
>> spin_unlock(&vgdev->cursorq.qlock);
>> - wait_event(vgdev->cursorq.ack_queue, vq->num_free >= outcnt);
>> + wait_event(vgdev->cursorq.ack_queue,
>> + vq->num_free >= outcnt || vgdev->vqs_released);
>> + /* See comment in virtio_gpu_queue_ctrl_sgs(). */
>> + if (vgdev->vqs_released) {
>> + free_vbuf(vgdev, vbuf);
>> + drm_dev_exit(idx);
>> + return;
>> + }
>> spin_lock(&vgdev->cursorq.qlock);
>> goto retry;
>> } else {
>
> What about other wait_event in the driver? Why only these?
There are other wait_event() calls on vgdev->resp_wq in virtgpu_prime.c
and virtgpu_vram.c. These can also cause a stuck process when the host
device stops or does not respond and should be fixed. However, they are
not related to the issue being fixed here. I think they should be
addressed in a separate commit.
The wait_event(vgdev->resp_wq) calls wait for a host response, not for
virtqueue ring space. They are not inside a drm_dev_enter/exit()
critical section, so they don't block drm_dev_unplug() ->
synchronize_srcu() and are not part of the deadlock reported by syzbot.
However, if a process is stuck in wait_event(vgdev->resp_wq), there is
no way to recover other than host device recovery itself. We can still
remove the device and destroy the virtqueues while the process is stuck,
so the host response can never arrive. IIUC, the stuck thread holds a
drm_device reference, preventing vgdev from being freed; this is a
resource leak.
This can be fixed by adding a wake_up_all() and a vqs_released check
similar to what is done for ctrlq/cursorq. However, I think this should
be a separate commit since the root cause and problem are different.
Alternatively, the resp_wq wait_event() calls could be converted to
wait_event_interruptible() to fix the issue. But as you mentioned
earlier in the v1 comment, we need the wait_event_interruptible()
rework.
What do you think? Should I include the resp_wq fix as a separate commit
in this patch series, or leave it for the _interruptible() rework?
Best regards,
Ryosuke
^ permalink raw reply
* Re: [PATCH v2] drm/virtio: abort virtqueue wait on device removal to avoid hung task
From: syzbot @ 2026-05-22 8:51 UTC (permalink / raw)
To: ryasuoka
Cc: airlied, dmitry.osipenko, dri-devel, gurchetansingh, kraxel,
linux-kernel, maarten.lankhorst, mripard, olvaffe, ryasuoka,
simona, tzimmermann, virtualization
In-Reply-To: <18b1d7267ace8b76.329809b8dd1e13b3.4134c0f069791aa6@ryasuoka-thinkpadx1carbongen9.tokyo.csb>
> Hi Dmitry,
> Thank you for your review and the comment.
>
> On 21/05/2026 22:01, Dmitry Osipenko wrote:
>> 21.05.2026 05:19, Ryosuke Yasuoka пишет:
>>> virtio_gpu_queue_ctrl_sgs() and virtio_gpu_queue_cursor() use
>>> wait_event() without any abort condition when waiting for virtqueue
>>> space. If the host device stops processing commands, these waits block
>>> indefinitely inside a drm_dev_enter/exit() critical section. Since
>>> drm_dev_unplug(), which is called in device removal and system shutdown
>>> call path, blocks on synchronize_srcu() until all critical sections
>>> complete, device removal and system shutdown also hang.
>>>
>>> Add a vqs_released flag to virtio_gpu_device and include it in the
>>> wait_event() condition. Set the flag and wake up both queues in a new
>>> virtio_gpu_release_vqs() helper, called before drm_dev_unplug() in both
>>> virtio_gpu_remove() and virtio_gpu_shutdown(). When the flag is set, the
>>> wait returns immediately and the command is aborted, following the same
>>> cleanup path as drm_dev_enter() failure.
>>>
>>> Reported-by: syzbot+d6dd6f86d3aaf7eebe7406e45c1c6e549453f224@syzkaller.appspotmail.com
>>> Closes: https://syzkaller.appspot.com/bug?id=d6dd6f86d3aaf7eebe7406e45c1c6e549453f224
>>> Reported-by: syzbot+908bd910da5dd79b88de4cf7baf376cc873a922e@syzkaller.appspotmail.com
>>> Closes: https://syzkaller.appspot.com/bug?id=908bd910da5dd79b88de4cf7baf376cc873a922e
>>> Signed-off-by: Ryosuke Yasuoka <ryasuoka@redhat.com>
>>> ---
>>> Changes in v2:
>>> - Update the commit message.
>>> - Replace wait_event_timeout() with wait_event() using a compound
>>> condition that includes a new vqs_released flag.
>>> - Add virtio_gpu_release_vqs() helper to set the flag and wake up
>>> both queues, called before drm_dev_unplug() in remove and shutdown
>>> paths.
>>> - Remove the hardcoded 5-second timeout. Recovery is now driven by
>>> the driver flag instead of an arbitrary timeout value.
>>> ---
>>> drivers/gpu/drm/virtio/virtgpu_drv.c | 15 +++++++++++++++
>>> drivers/gpu/drm/virtio/virtgpu_drv.h | 1 +
>>> drivers/gpu/drm/virtio/virtgpu_vq.c | 23 +++++++++++++++++++++--
>>> 3 files changed, 37 insertions(+), 2 deletions(-)
>>>
>>> diff --git a/drivers/gpu/drm/virtio/virtgpu_drv.c b/drivers/gpu/drm/virtio/virtgpu_drv.c
>>> index a5ce96fb8a1d..e4fe5e0780f9 100644
>>> --- a/drivers/gpu/drm/virtio/virtgpu_drv.c
>>> +++ b/drivers/gpu/drm/virtio/virtgpu_drv.c
>>> @@ -119,10 +119,24 @@ static int virtio_gpu_probe(struct virtio_device *vdev)
>>> return ret;
>>> }
>>>
>>> +/*
>>> + * Release pending virtqueue waits so the drm_dev_enter/exit() critical
>>> + * sections complete before drm_dev_unplug() blocks on synchronize_srcu().
>>> + */
>>> +static void virtio_gpu_release_vqs(struct drm_device *dev)
>>> +{
>>> + struct virtio_gpu_device *vgdev = dev->dev_private;
>>> +
>>> + vgdev->vqs_released = true;
>>> + wake_up_all(&vgdev->ctrlq.ack_queue);
>>> + wake_up_all(&vgdev->cursorq.ack_queue);
>>> +}
>>> +
>>> static void virtio_gpu_remove(struct virtio_device *vdev)
>>> {
>>> struct drm_device *dev = vdev->priv;
>>>
>>> + virtio_gpu_release_vqs(dev);
>>> drm_dev_unplug(dev);
>>> drm_atomic_helper_shutdown(dev);
>>> virtio_gpu_deinit(dev);
>>> @@ -133,6 +147,7 @@ static void virtio_gpu_shutdown(struct virtio_device *vdev)
>>> {
>>> struct drm_device *dev = vdev->priv;
>>>
>>> + virtio_gpu_release_vqs(dev);
>>> /* stop talking to the device */
>>> drm_dev_unplug(dev);
>>> }
>>> diff --git a/drivers/gpu/drm/virtio/virtgpu_drv.h b/drivers/gpu/drm/virtio/virtgpu_drv.h
>>> index f17660a71a3e..0bd69a40857e 100644
>>> --- a/drivers/gpu/drm/virtio/virtgpu_drv.h
>>> +++ b/drivers/gpu/drm/virtio/virtgpu_drv.h
>>> @@ -235,6 +235,7 @@ struct virtio_gpu_device {
>>>
>>> struct virtio_gpu_queue ctrlq;
>>> struct virtio_gpu_queue cursorq;
>>> + bool vqs_released;
>>> struct kmem_cache *vbufs;
>>>
>>> atomic_t pending_commands;
>>> diff --git a/drivers/gpu/drm/virtio/virtgpu_vq.c b/drivers/gpu/drm/virtio/virtgpu_vq.c
>>> index 67865810a2e7..8057a9b7356d 100644
>>> --- a/drivers/gpu/drm/virtio/virtgpu_vq.c
>>> +++ b/drivers/gpu/drm/virtio/virtgpu_vq.c
>>> @@ -396,7 +396,19 @@ static int virtio_gpu_queue_ctrl_sgs(struct virtio_gpu_device *vgdev,
>>> if (vq->num_free < elemcnt) {
>>> spin_unlock(&vgdev->ctrlq.qlock);
>>> virtio_gpu_notify(vgdev);
>>> - wait_event(vgdev->ctrlq.ack_queue, vq->num_free >= elemcnt);
>>> + wait_event(vgdev->ctrlq.ack_queue,
>>> + vq->num_free >= elemcnt || vgdev->vqs_released);
>>> + /*
>>> + * Set by virtio_gpu_release_vqs() to unblock
>>> + * synchronize_srcu() wait in drm_dev_unplug().
>>> + */
>>> + if (vgdev->vqs_released) {
>>> + if (fence && vbuf->objs)
>>> + virtio_gpu_array_unlock_resv(vbuf->objs);
>>> + free_vbuf(vgdev, vbuf);
>>> + drm_dev_exit(idx);
>>> + return -ENODEV;
>>> + }
>>> goto again;
>>> }
>>>
>>> @@ -566,7 +578,14 @@ static void virtio_gpu_queue_cursor(struct virtio_gpu_device *vgdev,
>>> ret = virtqueue_add_sgs(vq, sgs, outcnt, 0, vbuf, GFP_ATOMIC);
>>> if (ret == -ENOSPC) {
>>> spin_unlock(&vgdev->cursorq.qlock);
>>> - wait_event(vgdev->cursorq.ack_queue, vq->num_free >= outcnt);
>>> + wait_event(vgdev->cursorq.ack_queue,
>>> + vq->num_free >= outcnt || vgdev->vqs_released);
>>> + /* See comment in virtio_gpu_queue_ctrl_sgs(). */
>>> + if (vgdev->vqs_released) {
>>> + free_vbuf(vgdev, vbuf);
>>> + drm_dev_exit(idx);
>>> + return;
>>> + }
>>> spin_lock(&vgdev->cursorq.qlock);
>>> goto retry;
>>> } else {
>>
>> What about other wait_event in the driver? Why only these?
>
> There are other wait_event() calls on vgdev->resp_wq in virtgpu_prime.c
> and virtgpu_vram.c. These can also cause a stuck process when the host
> device stops or does not respond and should be fixed. However, they are
> not related to the issue being fixed here. I think they should be
> addressed in a separate commit.
>
> The wait_event(vgdev->resp_wq) calls wait for a host response, not for
> virtqueue ring space. They are not inside a drm_dev_enter/exit()
> critical section, so they don't block drm_dev_unplug() ->
> synchronize_srcu() and are not part of the deadlock reported by syzbot.
>
> However, if a process is stuck in wait_event(vgdev->resp_wq), there is
> no way to recover other than host device recovery itself. We can still
> remove the device and destroy the virtqueues while the process is stuck,
> so the host response can never arrive. IIUC, the stuck thread holds a
> drm_device reference, preventing vgdev from being freed; this is a
> resource leak.
>
> This can be fixed by adding a wake_up_all() and a vqs_released check
> similar to what is done for ctrlq/cursorq. However, I think this should
> be a separate commit since the root cause and problem are different.
>
> Alternatively, the resp_wq wait_event() calls could be converted to
> wait_event_interruptible() to fix the issue. But as you mentioned
> earlier in the v1 comment, we need the wait_event_interruptible()
> rework.
>
> What do you think? Should I include the resp_wq fix as a separate commit
> in this patch series, or leave it for the _interruptible() rework?
>
> Best regards,
> Ryosuke
>
>
I see the command but can't find the corresponding bug.
The email is sent to syzbot+HASH@syzkaller.appspotmail.com address
but the HASH does not correspond to any known bug.
Please double check the address.
^ permalink raw reply
* Re: [PATCH v2] drm/virtio: abort virtqueue wait on device removal to avoid hung task
From: syzbot @ 2026-05-22 8:51 UTC (permalink / raw)
To: ryasuoka
Cc: airlied, dmitry.osipenko, dri-devel, gurchetansingh, kraxel,
linux-kernel, maarten.lankhorst, mripard, olvaffe, ryasuoka,
simona, tzimmermann, virtualization
In-Reply-To: <18b1d7267ace8b76.329809b8dd1e13b3.4134c0f069791aa6@ryasuoka-thinkpadx1carbongen9.tokyo.csb>
> Hi Dmitry,
> Thank you for your review and the comment.
>
> On 21/05/2026 22:01, Dmitry Osipenko wrote:
>> 21.05.2026 05:19, Ryosuke Yasuoka пишет:
>>> virtio_gpu_queue_ctrl_sgs() and virtio_gpu_queue_cursor() use
>>> wait_event() without any abort condition when waiting for virtqueue
>>> space. If the host device stops processing commands, these waits block
>>> indefinitely inside a drm_dev_enter/exit() critical section. Since
>>> drm_dev_unplug(), which is called in device removal and system shutdown
>>> call path, blocks on synchronize_srcu() until all critical sections
>>> complete, device removal and system shutdown also hang.
>>>
>>> Add a vqs_released flag to virtio_gpu_device and include it in the
>>> wait_event() condition. Set the flag and wake up both queues in a new
>>> virtio_gpu_release_vqs() helper, called before drm_dev_unplug() in both
>>> virtio_gpu_remove() and virtio_gpu_shutdown(). When the flag is set, the
>>> wait returns immediately and the command is aborted, following the same
>>> cleanup path as drm_dev_enter() failure.
>>>
>>> Reported-by: syzbot+d6dd6f86d3aaf7eebe7406e45c1c6e549453f224@syzkaller.appspotmail.com
>>> Closes: https://syzkaller.appspot.com/bug?id=d6dd6f86d3aaf7eebe7406e45c1c6e549453f224
>>> Reported-by: syzbot+908bd910da5dd79b88de4cf7baf376cc873a922e@syzkaller.appspotmail.com
>>> Closes: https://syzkaller.appspot.com/bug?id=908bd910da5dd79b88de4cf7baf376cc873a922e
>>> Signed-off-by: Ryosuke Yasuoka <ryasuoka@redhat.com>
>>> ---
>>> Changes in v2:
>>> - Update the commit message.
>>> - Replace wait_event_timeout() with wait_event() using a compound
>>> condition that includes a new vqs_released flag.
>>> - Add virtio_gpu_release_vqs() helper to set the flag and wake up
>>> both queues, called before drm_dev_unplug() in remove and shutdown
>>> paths.
>>> - Remove the hardcoded 5-second timeout. Recovery is now driven by
>>> the driver flag instead of an arbitrary timeout value.
>>> ---
>>> drivers/gpu/drm/virtio/virtgpu_drv.c | 15 +++++++++++++++
>>> drivers/gpu/drm/virtio/virtgpu_drv.h | 1 +
>>> drivers/gpu/drm/virtio/virtgpu_vq.c | 23 +++++++++++++++++++++--
>>> 3 files changed, 37 insertions(+), 2 deletions(-)
>>>
>>> diff --git a/drivers/gpu/drm/virtio/virtgpu_drv.c b/drivers/gpu/drm/virtio/virtgpu_drv.c
>>> index a5ce96fb8a1d..e4fe5e0780f9 100644
>>> --- a/drivers/gpu/drm/virtio/virtgpu_drv.c
>>> +++ b/drivers/gpu/drm/virtio/virtgpu_drv.c
>>> @@ -119,10 +119,24 @@ static int virtio_gpu_probe(struct virtio_device *vdev)
>>> return ret;
>>> }
>>>
>>> +/*
>>> + * Release pending virtqueue waits so the drm_dev_enter/exit() critical
>>> + * sections complete before drm_dev_unplug() blocks on synchronize_srcu().
>>> + */
>>> +static void virtio_gpu_release_vqs(struct drm_device *dev)
>>> +{
>>> + struct virtio_gpu_device *vgdev = dev->dev_private;
>>> +
>>> + vgdev->vqs_released = true;
>>> + wake_up_all(&vgdev->ctrlq.ack_queue);
>>> + wake_up_all(&vgdev->cursorq.ack_queue);
>>> +}
>>> +
>>> static void virtio_gpu_remove(struct virtio_device *vdev)
>>> {
>>> struct drm_device *dev = vdev->priv;
>>>
>>> + virtio_gpu_release_vqs(dev);
>>> drm_dev_unplug(dev);
>>> drm_atomic_helper_shutdown(dev);
>>> virtio_gpu_deinit(dev);
>>> @@ -133,6 +147,7 @@ static void virtio_gpu_shutdown(struct virtio_device *vdev)
>>> {
>>> struct drm_device *dev = vdev->priv;
>>>
>>> + virtio_gpu_release_vqs(dev);
>>> /* stop talking to the device */
>>> drm_dev_unplug(dev);
>>> }
>>> diff --git a/drivers/gpu/drm/virtio/virtgpu_drv.h b/drivers/gpu/drm/virtio/virtgpu_drv.h
>>> index f17660a71a3e..0bd69a40857e 100644
>>> --- a/drivers/gpu/drm/virtio/virtgpu_drv.h
>>> +++ b/drivers/gpu/drm/virtio/virtgpu_drv.h
>>> @@ -235,6 +235,7 @@ struct virtio_gpu_device {
>>>
>>> struct virtio_gpu_queue ctrlq;
>>> struct virtio_gpu_queue cursorq;
>>> + bool vqs_released;
>>> struct kmem_cache *vbufs;
>>>
>>> atomic_t pending_commands;
>>> diff --git a/drivers/gpu/drm/virtio/virtgpu_vq.c b/drivers/gpu/drm/virtio/virtgpu_vq.c
>>> index 67865810a2e7..8057a9b7356d 100644
>>> --- a/drivers/gpu/drm/virtio/virtgpu_vq.c
>>> +++ b/drivers/gpu/drm/virtio/virtgpu_vq.c
>>> @@ -396,7 +396,19 @@ static int virtio_gpu_queue_ctrl_sgs(struct virtio_gpu_device *vgdev,
>>> if (vq->num_free < elemcnt) {
>>> spin_unlock(&vgdev->ctrlq.qlock);
>>> virtio_gpu_notify(vgdev);
>>> - wait_event(vgdev->ctrlq.ack_queue, vq->num_free >= elemcnt);
>>> + wait_event(vgdev->ctrlq.ack_queue,
>>> + vq->num_free >= elemcnt || vgdev->vqs_released);
>>> + /*
>>> + * Set by virtio_gpu_release_vqs() to unblock
>>> + * synchronize_srcu() wait in drm_dev_unplug().
>>> + */
>>> + if (vgdev->vqs_released) {
>>> + if (fence && vbuf->objs)
>>> + virtio_gpu_array_unlock_resv(vbuf->objs);
>>> + free_vbuf(vgdev, vbuf);
>>> + drm_dev_exit(idx);
>>> + return -ENODEV;
>>> + }
>>> goto again;
>>> }
>>>
>>> @@ -566,7 +578,14 @@ static void virtio_gpu_queue_cursor(struct virtio_gpu_device *vgdev,
>>> ret = virtqueue_add_sgs(vq, sgs, outcnt, 0, vbuf, GFP_ATOMIC);
>>> if (ret == -ENOSPC) {
>>> spin_unlock(&vgdev->cursorq.qlock);
>>> - wait_event(vgdev->cursorq.ack_queue, vq->num_free >= outcnt);
>>> + wait_event(vgdev->cursorq.ack_queue,
>>> + vq->num_free >= outcnt || vgdev->vqs_released);
>>> + /* See comment in virtio_gpu_queue_ctrl_sgs(). */
>>> + if (vgdev->vqs_released) {
>>> + free_vbuf(vgdev, vbuf);
>>> + drm_dev_exit(idx);
>>> + return;
>>> + }
>>> spin_lock(&vgdev->cursorq.qlock);
>>> goto retry;
>>> } else {
>>
>> What about other wait_event in the driver? Why only these?
>
> There are other wait_event() calls on vgdev->resp_wq in virtgpu_prime.c
> and virtgpu_vram.c. These can also cause a stuck process when the host
> device stops or does not respond and should be fixed. However, they are
> not related to the issue being fixed here. I think they should be
> addressed in a separate commit.
>
> The wait_event(vgdev->resp_wq) calls wait for a host response, not for
> virtqueue ring space. They are not inside a drm_dev_enter/exit()
> critical section, so they don't block drm_dev_unplug() ->
> synchronize_srcu() and are not part of the deadlock reported by syzbot.
>
> However, if a process is stuck in wait_event(vgdev->resp_wq), there is
> no way to recover other than host device recovery itself. We can still
> remove the device and destroy the virtqueues while the process is stuck,
> so the host response can never arrive. IIUC, the stuck thread holds a
> drm_device reference, preventing vgdev from being freed; this is a
> resource leak.
>
> This can be fixed by adding a wake_up_all() and a vqs_released check
> similar to what is done for ctrlq/cursorq. However, I think this should
> be a separate commit since the root cause and problem are different.
>
> Alternatively, the resp_wq wait_event() calls could be converted to
> wait_event_interruptible() to fix the issue. But as you mentioned
> earlier in the v1 comment, we need the wait_event_interruptible()
> rework.
>
> What do you think? Should I include the resp_wq fix as a separate commit
> in this patch series, or leave it for the _interruptible() rework?
>
> Best regards,
> Ryosuke
>
>
I see the command but can't find the corresponding bug.
The email is sent to syzbot+HASH@syzkaller.appspotmail.com address
but the HASH does not correspond to any known bug.
Please double check the address.
^ permalink raw reply
* Re: [PATCH v4] drm/virtio: use uninterruptible resv lock for plane updates
From: Dmitry Osipenko @ 2026-05-22 8:26 UTC (permalink / raw)
To: Christian König, Deepanshu Kartikey, airlied, kraxel,
gurchetansingh, olvaffe, maarten.lankhorst, mripard, tzimmermann,
simona, sumit.semwal
Cc: dri-devel, virtualization, linux-kernel, linux-media,
linaro-mm-sig, syzbot+72bd3dd3a5d5f39a0271, stable
In-Reply-To: <1832e5a8-db85-4b66-a5f0-08043c4aed54@amd.com>
20.05.2026 14:00, Christian König пишет:
> On 5/20/26 10:12, Dmitry Osipenko wrote:
>> On 5/20/26 10:05, Christian König wrote:
>>> On 5/20/26 08:50, Dmitry Osipenko wrote:
>>>> On 5/19/26 11:27, Christian König wrote:
>>>>> On 5/19/26 10:22, Deepanshu Kartikey wrote:
>>>>>> virtio_gpu_cursor_plane_update() and virtio_gpu_resource_flush() lock
>>>>>> the framebuffer BO's dma_resv via virtio_gpu_array_lock_resv() and
>>>>>> ignore its return value. The function can fail with -EINTR from
>>>>>> dma_resv_lock_interruptible() (signal during lock wait) or with
>>>>>> -ENOMEM from dma_resv_reserve_fences() (fence slot allocation),
>>>>>> leaving the resv lock not held. The queue path then walks the object
>>>>>> array and calls dma_resv_add_fence(), which requires the lock held;
>>>>>> with lockdep enabled this trips dma_resv_assert_held():
>>>>>>
>>>>>> WARNING: drivers/dma-buf/dma-resv.c:296 at dma_resv_add_fence+0x71e/0x840
>>>>>> Call Trace:
>>>>>> virtio_gpu_array_add_fence
>>>>>> virtio_gpu_queue_ctrl_sgs
>>>>>> virtio_gpu_queue_fenced_ctrl_buffer
>>>>>> virtio_gpu_cursor_plane_update
>>>>>> drm_atomic_helper_commit_planes
>>>>>> drm_atomic_helper_commit_tail
>>>>>> commit_tail
>>>>>> drm_atomic_helper_commit
>>>>>> drm_atomic_commit
>>>>>> drm_atomic_helper_update_plane
>>>>>> __setplane_atomic
>>>>>> drm_mode_cursor_universal
>>>>>> drm_mode_cursor_common
>>>>>> drm_mode_cursor_ioctl
>>>>>> drm_ioctl
>>>>>> __x64_sys_ioctl
>>>>>>
>>>>>> Beyond the WARN, mutating the dma_resv fence list without the lock
>>>>>> races with concurrent readers/writers and can corrupt the list.
>>>>>
>>>>> Well why are you trying to add a fence on an atomic mode set in the first place?
>>>>>
>>>>> That is usually an illegal operation here.
>>>> That is pre-existing in the driver. It performs draw operation and in
>>>> some cases waits for the completion during atomic. Whether all that
>>>> syncing is correct is hard to say immediately as some of it may be
>>>> historical edge cases.
>>>
>>> I'm not not so deeply in the atomic mode setting stuff but it strongly sounds like that this is seriously broken.
>>>
>>> The background is that the atomic mode set framework allows an output dma_fence which is signaled when the commit is finished.
>>>
>>> So when you allocate a fence slot and add a new fence to finish the atomic commit it is trivially possible that this cycles back and waits for the atomic commit to finish. In other words you have a deadlock.
>>>
>>> You probably need specially crafted userspace with the right timing to trigger that, but such issues are usually a rather big no-no and need to be fixed in the long term.
>>>
>>> Try to add dma_fence_begin_signaling() and dma_fence_end_signaling() annotation and enable lockdep, the tool should be able to point out if and what exactly goes wrong.
>>>
>>> The usual fix is to prepare everything before commit_tail is called (alloc memory, create, reserve slot, add dma_fence etc....) and then just send out the prepared commands later on.
>>
>> We tried with moving resv alloc to prepare_fb() in a previous patch
>> version, it resulted in a non-trivial deadlocks. The goal of this patch
>> is to fix immediate problem with a minimal code change.
>
> Yeah, totally fine with me to get that fixed first.
>
>> What you're saying is correct, but it may require a rather big
>> refactoring of the code. In general, everything works okay today, so not
>> really an urgent problem.
>
> It's just a potential issue and when the AI bots keep evolving like they already do they will sooner or later start to point that out as well.
Don't mind if bots will produce something useful
--
Best regards,
Dmitry
^ permalink raw reply
* Re: [PATCH v3 02/41] x86/tsc: Add helper to register CPU and TSC freq calibration routines
From: David Woodhouse @ 2026-05-21 21:37 UTC (permalink / raw)
To: Sean Christopherson
Cc: Kiryl Shutsemau, Paolo Bonzini, K. Y. Srinivasan, Haiyang Zhang,
Wei Liu, Dexuan Cui, Long Li, Ajay Kaher, Alexey Makhalov,
Jan Kiszka, Dave Hansen, Andy Lutomirski, Peter Zijlstra,
Juergen Gross, Daniel Lezcano, Thomas Gleixner, John Stultz,
Rick Edgecombe, Vitaly Kuznetsov,
Broadcom internal kernel review list, Boris Ostrovsky,
Stephen Boyd, x86, linux-coco, kvm, linux-hyperv, virtualization,
linux-kernel, xen-devel, Michael Kelley, Tom Lendacky,
Nikunj A Dadhania, Thomas Gleixner
In-Reply-To: <ag92Ze_FADmL1llo@google.com>
[-- Attachment #1: Type: text/plain, Size: 1648 bytes --]
On Thu, 2026-05-21 at 14:17 -0700, Sean Christopherson wrote:
>
> > That seems reasonable. Where does the call to
> > native_calibrate_tsc()
> > happen; is that from determine_cpu_tsc_frequencies()?
>
> Yep.
Great, thanks.
> static bool __init determine_cpu_tsc_frequencies(bool early,
> unsigned int
> known_cpu_khz,
> unsigned int
> known_tsc_khz)
> {
> /* Make sure that cpu and tsc are not already calibrated */
> WARN_ON(cpu_khz || tsc_khz);
>
> if (early) {
> /*
> * Early CPU calibration can only use methods that
> are available
> * early in boot (obviously).
> */
> if (known_cpu_khz)
> cpu_khz = known_cpu_khz;
> else
> cpu_khz = native_calibrate_cpu_early();
> if (known_tsc_khz)
> tsc_khz = known_tsc_khz;
> else
> tsc_khz = native_calibrate_tsc();
> } else {
> cpu_khz = pit_hpet_ptimer_calibrate_cpu();
> }
If, after all that, we still end up in the case where we *do* have to
calibrate it against a legacy timer (which sadly IIRC is the case even
on some fairly modern AMD generations), could we round the answer?
We currently have *far* more precision than accuracy, leading to values
like 2399997kHz which change every boot (and end up being what gets
*advertised* to guests on such a host... and then unless we're careful
to avoid it, we end up trying to *scale* a different host's TSC down
from 2399998 to 2399997 for a guest which is migrated from the first
host...)
We should just fix them (e.g. to 2400000kHz) and let NTP sort them out.
Something like "round to the nearest MHz if that's within ±10PPM"?
[-- Attachment #2: smime.p7s --]
[-- Type: application/pkcs7-signature, Size: 5069 bytes --]
^ permalink raw reply
* Re: [PATCH v3 02/41] x86/tsc: Add helper to register CPU and TSC freq calibration routines
From: Sean Christopherson @ 2026-05-21 21:17 UTC (permalink / raw)
To: David Woodhouse
Cc: Kiryl Shutsemau, Paolo Bonzini, K. Y. Srinivasan, Haiyang Zhang,
Wei Liu, Dexuan Cui, Long Li, Ajay Kaher, Alexey Makhalov,
Jan Kiszka, Dave Hansen, Andy Lutomirski, Peter Zijlstra,
Juergen Gross, Daniel Lezcano, Thomas Gleixner, John Stultz,
Rick Edgecombe, Vitaly Kuznetsov,
Broadcom internal kernel review list, Boris Ostrovsky,
Stephen Boyd, x86, linux-coco, kvm, linux-hyperv, virtualization,
linux-kernel, xen-devel, Michael Kelley, Tom Lendacky,
Nikunj A Dadhania, Thomas Gleixner
In-Reply-To: <342098f6bfe1e4c7b233433df8f79713b4220614.camel@infradead.org>
On Thu, May 21, 2026, David Woodhouse wrote:
> On Thu, 2026-05-21 at 13:53 -0700, Sean Christopherson wrote:
> >
> > E.g. this is what I've got for the early flow. Testing now.
> >
> > void __init tsc_early_init(void)
> > {
> > unsigned int known_cpu_khz = 0, known_tsc_khz = 0;
> >
> > if (!boot_cpu_has(X86_FEATURE_TSC))
> > return;
> > /* Don't change UV TSC multi-chassis synchronization */
> > if (is_early_uv_system())
> > return;
> >
> > if (x86_init.hyper.get_cpu_khz)
> > known_cpu_khz = x86_init.hyper.get_cpu_khz();
> >
> > if (tsc_early_khz)
> > known_tsc_khz = tsc_early_khz;
> > else if (cc_platform_has(CC_ATTR_GUEST_SNP_SECURE_TSC))
> > known_tsc_khz = snp_secure_tsc_init();
> > else if (boot_cpu_has(X86_FEATURE_TDX_GUEST))
> > known_tsc_khz = tdx_tsc_init();
> >
> > /*
> > * If the TSC frequency is still unknown, i.e. not provided by the user
> > * or by trusted firmware, try to get it from the hypervisor (which is
> > * untrusted when running as a CoCo guest).
> > */
> > if (!known_tsc_khz && x86_init.hyper.get_tsc_khz)
> > known_tsc_khz = x86_init.hyper.get_tsc_khz();
> >
> > if (known_tsc_khz)
> > setup_force_cpu_cap(X86_FEATURE_TSC_KNOWN_FREQ);
> >
> > if (!determine_cpu_tsc_frequencies(true, known_cpu_khz, known_tsc_khz))
> > return;
> > tsc_enable_sched_clock();
> > }
>
> That seems reasonable. Where does the call to native_calibrate_tsc()
> happen; is that from determine_cpu_tsc_frequencies()?
Yep.
static bool __init determine_cpu_tsc_frequencies(bool early,
unsigned int known_cpu_khz,
unsigned int known_tsc_khz)
{
/* Make sure that cpu and tsc are not already calibrated */
WARN_ON(cpu_khz || tsc_khz);
if (early) {
/*
* Early CPU calibration can only use methods that are available
* early in boot (obviously).
*/
if (known_cpu_khz)
cpu_khz = known_cpu_khz;
else
cpu_khz = native_calibrate_cpu_early();
if (known_tsc_khz)
tsc_khz = known_tsc_khz;
else
tsc_khz = native_calibrate_tsc();
} else {
cpu_khz = pit_hpet_ptimer_calibrate_cpu();
}
...
^ permalink raw reply
* Re: [PATCH v3 02/41] x86/tsc: Add helper to register CPU and TSC freq calibration routines
From: David Woodhouse @ 2026-05-21 21:01 UTC (permalink / raw)
To: Sean Christopherson
Cc: Kiryl Shutsemau, Paolo Bonzini, K. Y. Srinivasan, Haiyang Zhang,
Wei Liu, Dexuan Cui, Long Li, Ajay Kaher, Alexey Makhalov,
Jan Kiszka, Dave Hansen, Andy Lutomirski, Peter Zijlstra,
Juergen Gross, Daniel Lezcano, Thomas Gleixner, John Stultz,
Rick Edgecombe, Vitaly Kuznetsov,
Broadcom internal kernel review list, Boris Ostrovsky,
Stephen Boyd, x86, linux-coco, kvm, linux-hyperv, virtualization,
linux-kernel, xen-devel, Michael Kelley, Tom Lendacky,
Nikunj A Dadhania, Thomas Gleixner
In-Reply-To: <ag9wz3RiJOtVZrK0@google.com>
[-- Attachment #1: Type: text/plain, Size: 1407 bytes --]
On Thu, 2026-05-21 at 13:53 -0700, Sean Christopherson wrote:
>
> E.g. this is what I've got for the early flow. Testing now.
>
> void __init tsc_early_init(void)
> {
> unsigned int known_cpu_khz = 0, known_tsc_khz = 0;
>
> if (!boot_cpu_has(X86_FEATURE_TSC))
> return;
> /* Don't change UV TSC multi-chassis synchronization */
> if (is_early_uv_system())
> return;
>
> if (x86_init.hyper.get_cpu_khz)
> known_cpu_khz = x86_init.hyper.get_cpu_khz();
>
> if (tsc_early_khz)
> known_tsc_khz = tsc_early_khz;
> else if (cc_platform_has(CC_ATTR_GUEST_SNP_SECURE_TSC))
> known_tsc_khz = snp_secure_tsc_init();
> else if (boot_cpu_has(X86_FEATURE_TDX_GUEST))
> known_tsc_khz = tdx_tsc_init();
>
> /*
> * If the TSC frequency is still unknown, i.e. not provided by the user
> * or by trusted firmware, try to get it from the hypervisor (which is
> * untrusted when running as a CoCo guest).
> */
> if (!known_tsc_khz && x86_init.hyper.get_tsc_khz)
> known_tsc_khz = x86_init.hyper.get_tsc_khz();
>
> if (known_tsc_khz)
> setup_force_cpu_cap(X86_FEATURE_TSC_KNOWN_FREQ);
>
> if (!determine_cpu_tsc_frequencies(true, known_cpu_khz, known_tsc_khz))
> return;
> tsc_enable_sched_clock();
> }
That seems reasonable. Where does the call to native_calibrate_tsc()
happen; is that from determine_cpu_tsc_frequencies()?
[-- Attachment #2: smime.p7s --]
[-- Type: application/pkcs7-signature, Size: 5069 bytes --]
^ permalink raw reply
* Re: [PATCH v3 37/41] x86/kvmclock: Use TSC for sched_clock if it's constant and non-stop
From: Sean Christopherson @ 2026-05-21 21:01 UTC (permalink / raw)
To: Dongli Zhang
Cc: kvm, Rick Edgecombe, Vitaly Kuznetsov,
Broadcom internal kernel review list, Boris Ostrovsky,
Stephen Boyd, x86, linux-coco, linux-hyperv, virtualization,
linux-kernel, xen-devel, Kiryl Shutsemau, Paolo Bonzini,
K. Y. Srinivasan, Haiyang Zhang, Wei Liu, Dexuan Cui, Long Li,
Ajay Kaher, Alexey Makhalov, Jan Kiszka, Dave Hansen,
Andy Lutomirski, Peter Zijlstra, Juergen Gross, Daniel Lezcano,
Thomas Gleixner, John Stultz, Michael Kelley, Tom Lendacky,
Nikunj A Dadhania, Thomas Gleixner, David Woodhouse
In-Reply-To: <c54fd01b-fe22-4c9c-8d5f-5b317de07a40@oracle.com>
On Thu, May 21, 2026, Dongli Zhang wrote:
> On 2026-05-15 12:19 PM, Sean Christopherson wrote:
> > Prefer the TSC over kvmclock for sched_clock if the TSC is constant,
> > nonstop, and not marked unstable via command line. I.e. use the same
> > criteria as tweaking the clocksource rating so that TSC is preferred over
> > kvmclock. Per the below comment from native_sched_clock(), sched_clock
> > is more tolerant of slop than clocksource; using TSC for clocksource but
> > not sched_clock makes little to no sense, especially now that KVM CoCo
> > guests with a trusted TSC use TSC, not kvmclock.
> >
> > /*
> > * Fall back to jiffies if there's no TSC available:
> > * ( But note that we still use it if the TSC is marked
> > * unstable. We do this because unlike Time Of Day,
> > * the scheduler clock tolerates small errors and it's
> > * very important for it to be as fast as the platform
> > * can achieve it. )
> > */
> >
> > The only advantage of using kvmclock is that doing so allows for early
> > and common detection of PVCLOCK_GUEST_STOPPED, but that code has been
> > broken for over two years with nary a complaint, i.e. it can't be
> > _that_ valuable. And as above, certain types of KVM guests are losing
> > the functionality regardless, i.e. acknowledging PVCLOCK_GUEST_STOPPED
> > needs to be decoupled from sched_clock() no matter what.
>
> Has it been broken for two years because of pvclock_clocksource_read_nowd()?
Yep. Because pvclock_clocksource_read_nowd() ignores PVCLOCK_GUEST_STOPPED, the
flag only ever gets recognized when the kernel reads WALL_CLOCK, which AFAICT
only happens at initial boot, and during suspend and resume.
^ permalink raw reply
page: next (older) | prev (newer) | latest
- recent:[subjects (threaded)|topics (new)|topics (active)]
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox