[PATCH v3 3/4] usb: gadget: f_hid: fix race between userspace report update and GET_REPORT response
From: Shunbo Shi
Date: Wed Nov 11 2026 - 20:12:34 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 once in
hidg_alloc() and freed in hidg_release(): the handler copies the
entry data into get_req_buf and zeroes the rest before queueing,
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. Placing the buffer at the
function-instance level (rather than bind/unbind) means it is only
freed after all USB activity has ceased and all userspace file
references are gone, so no disable/set_alt/unbind ordering
constraints apply.
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..8c2adf392389 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;
@@ -128,6 +128,7 @@ static void hidg_release(struct device *dev)
kfree(entry);
}
+ kfree(hidg->get_req_buf);
kfree(hidg->report_desc);
kfree(hidg->set_report_buf);
kfree(hidg);
@@ -568,6 +569,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 +589,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 +627,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 +1167,15 @@ 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
+ * (allocated in hidg_alloc()), not from the report_list
+ * entries: userspace may update an entry while the controller
+ * is still reading the previous response, which would corrupt
+ * the data on the wire.
+ */
+ 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;
@@ -1646,6 +1662,18 @@ static struct usb_function *hidg_alloc(struct usb_function_instance *fi)
}
hidg->use_out_ep = !opts->no_out_endpoint;
+ /*
+ * Dedicated buffer for GET_REPORT responses, allocated once for
+ * the whole lifetime of this function instance: hidg_release()
+ * is the only safe free point, as it runs after all USB
+ * activity has ceased and all file references are gone.
+ */
+ hidg->get_req_buf = kmalloc(MAX_REPORT_LENGTH, GFP_KERNEL);
+ if (!hidg->get_req_buf) {
+ ret = -ENOMEM;
+ goto err_put_device;
+ }
+
++opts->refcnt;
mutex_unlock(&opts->lock);
--
2.53.0