[PATCH v2 3/4] usb: gadget: f_hid: fix race between userspace report update and GET_REPORT response

From: Shunbo Shi

Date: Wed Nov 11 2026 - 03:16:36 EST


The GET_REPORT response is served by pointing get_req->buf at the
data[] array of a report_list entry and calling usb_ep_queue().
The request completes asynchronously, so the controller may still
be reading the entry's buffer after get_report_workqueue_handler()
drops get_report_spinlock.

At the same time, userspace can update that same entry via the
GADGET_HID_WRITE_GET_REPORT ioctl: f_hidg_get_report() copies new
report data into the entry while holding the spinlock, but the
transfer reading the entry is not serialized against that update
(the lock was already released by the work handler).

The result is that the host can receive a GET_REPORT response that
mixes bytes of the old and the new report (a torn write), with no
memory-safety violation but corrupted report data on the wire.

Serve the response from a dedicated buffer allocated at bind time:
the handler now copies the entry data into get_req_buf and zeroes
the rest of the buffer before queueing the request, so userspace
updates to the entry can no longer race with the asynchronous read
of the previous response, and no uninitialized slab memory is
exposed to the host.

The buffer lives from bind() to unbind(); hidg_disable() must not
free it, because hidg_set_alt() does not reallocate it and the next
GET_REPORT after a USB reset would use freed memory.

This also removes the now unused get_report member from struct
f_hidg.

Fixes: a139c98f760e ("USB: gadget: f_hid: Add GET_REPORT via userspace IOCTL")
Signed-off-by: Shunbo Shi <shishunbo@xxxxxxxxxxxxxxxxxxxx>
---
drivers/usb/gadget/function/f_hid.c | 36 +++++++++++++++++++++++++----
1 file changed, 32 insertions(+), 4 deletions(-)

diff --git a/drivers/usb/gadget/function/f_hid.c b/drivers/usb/gadget/function/f_hid.c
index d7ba30323414..426bc1743cbb 100644
--- a/drivers/usb/gadget/function/f_hid.c
+++ b/drivers/usb/gadget/function/f_hid.c
@@ -94,7 +94,7 @@ struct f_hidg {

/* get report */
struct usb_request *get_req;
- struct usb_hidg_report get_report;
+ void *get_req_buf;
bool get_report_returned;
int get_report_req_report_id;
int get_report_req_report_length;
@@ -568,6 +568,7 @@ static void get_report_workqueue_handler(struct work_struct *work)
struct usb_request *req;
struct report_entry *ptr;
unsigned long flags;
+ unsigned int copied;

int status = 0;

@@ -587,7 +588,10 @@ static void get_report_workqueue_handler(struct work_struct *work)
ptr = f_hidg_search_for_report(hidg, hidg->get_report_req_report_id);
if (ptr && !ptr->report_data.userspace_req) {
/* Report exists in list and it is to be used for immediate response */
- req->buf = ptr->report_data.data;
+ copied = min_t(unsigned int, req->length, ptr->report_data.length);
+ memcpy(req->buf, ptr->report_data.data, copied);
+ if (copied < MAX_REPORT_LENGTH)
+ memset(req->buf + copied, 0x0, MAX_REPORT_LENGTH - copied);
status = usb_ep_queue(cdev->gadget->ep0, req, GFP_ATOMIC);
hidg->get_report_returned = true;
spin_unlock_irqrestore(&hidg->get_report_spinlock, flags);
@@ -622,10 +626,12 @@ static void get_report_workqueue_handler(struct work_struct *work)
* Either get an updated response just serviced by userspace
* or send the latest response in the list
*/
- req->buf = ptr->report_data.data;
+ copied = min_t(unsigned int, req->length, ptr->report_data.length);
+ memcpy(req->buf, ptr->report_data.data, copied);
+ if (copied < MAX_REPORT_LENGTH)
+ memset(req->buf + copied, 0x0, MAX_REPORT_LENGTH - copied);
} else {
/* If there are no prevoiusly sent reports send empty report */
- req->buf = hidg->get_report.data;
memset(req->buf, 0x0, req->length);
}

@@ -1160,6 +1166,23 @@ static int hidg_bind(struct usb_configuration *c, struct usb_function *f)
if (!hidg->get_req)
return -ENOMEM;

+ /*
+ * The GET_REPORT response is served from a dedicated buffer, not
+ * from the report_list entries: userspace may update an entry
+ * (f_hidg_get_report()) while the controller is still reading the
+ * previous response, which would corrupt the data on the wire.
+ *
+ * The buffer lives from bind() to unbind(); hidg_disable() must
+ * not free it, because hidg_set_alt() does not reallocate it and
+ * the next GET_REPORT after a USB reset would use freed memory.
+ */
+ hidg->get_req_buf = kmalloc(MAX_REPORT_LENGTH, GFP_KERNEL);
+ if (!hidg->get_req_buf) {
+ status = -ENOMEM;
+ goto fail_free_request;
+ }
+ hidg->get_req->buf = hidg->get_req_buf;
+
hidg->get_req->zero = 0;
hidg->get_req->complete = hidg_get_report_complete;
hidg->get_req->context = hidg;
@@ -1303,6 +1326,9 @@ static int hidg_bind(struct usb_configuration *c, struct usb_function *f)
if (hidg->req != NULL)
free_ep_req(hidg->in_ep, hidg->req);

+ kfree(hidg->get_req_buf);
+ hidg->get_req_buf = NULL;
+fail_free_request:
usb_ep_free_request(c->cdev->gadget->ep0, hidg->get_req);
hidg->get_req = NULL;

@@ -1593,6 +1619,8 @@ static void hidg_unbind(struct usb_configuration *c, struct usb_function *f)

cdev_device_del(hidg->cdev, &hidg->dev);
destroy_workqueue(hidg->workqueue);
+ kfree(hidg->get_req_buf);
+ hidg->get_req_buf = NULL;
usb_free_all_descriptors(f);
}

--
2.53.0