| Message ID | 268a0668144d5ff36ec7d87fdfa90faf583b7ccc.1615171203.git.skhan@linuxfoundation.org (mailing list archive) |
|---|---|
| State | Accepted |
| Commit | 9380afd6df70e24eacbdbde33afc6a3950965d22 |
| Headers | show |
| Series | usbip fixes to crashes found by syzbot | expand |
On 2021/03/08 12:53, Shuah Khan wrote: > Fix the above problems: > - Stop using kthread_get_run() macro to create/start threads. > - Create threads and get task struct reference. > - Add kthread_create() failure handling and bail out. > - Hold usbip_device lock to update local and shared states after > creating rx and tx threads. > - Update usbip_device status to SDEV_ST_USED. > - Update usbip_device tcp_socket, sockfd, tcp_rx, and tcp_tx > - Start threads after usbip_device (tcp_socket, sockfd, tcp_rx, tcp_tx, > and status) is complete. No, the whole usbip_sockfd_store() etc. should be serialized using a mutex, for two different threads can open same file and write the same content at the same moment. This results in seeing SDEV_ST_AVAILABLE and creating two threads and overwiting global variables and setting SDEV_ST_USED and starting two threads by each of two thread, which will later fail to call kthread_stop() on one of two thread because global variables are overwritten. kthread_crate() (which involves GFP_KERNEL allocation) can take long time enough to hit usbip_sockfd_store() must perform if (sdev->ud.status != SDEV_ST_AVAILABLE) { /* misc assignments for attach operation */ sdev->ud.status = SDEV_ST_USED; } under a lock, or multiple ud->tcp_{tx,rx} are created (which will later cause a crash like [1]) and refcount on ud->tcp_socket is leaked when usbip_sockfd_store() is concurrently called. problem. That's why my patch introduced usbip_event_mutex lock.
On 2021/03/08 16:35, Tetsuo Handa wrote: > On 2021/03/08 12:53, Shuah Khan wrote: >> Fix the above problems: >> - Stop using kthread_get_run() macro to create/start threads. >> - Create threads and get task struct reference. >> - Add kthread_create() failure handling and bail out. >> - Hold usbip_device lock to update local and shared states after >> creating rx and tx threads. >> - Update usbip_device status to SDEV_ST_USED. >> - Update usbip_device tcp_socket, sockfd, tcp_rx, and tcp_tx >> - Start threads after usbip_device (tcp_socket, sockfd, tcp_rx, tcp_tx, >> and status) is complete. > > No, the whole usbip_sockfd_store() etc. should be serialized using a mutex, > for two different threads can open same file and write the same content at > the same moment. This results in seeing SDEV_ST_AVAILABLE and creating two > threads and overwiting global variables and setting SDEV_ST_USED and starting > two threads by each of two thread, which will later fail to call kthread_stop() > on one of two thread because global variables are overwritten. > > kthread_crate() (which involves GFP_KERNEL allocation) can take long time > enough to hit > > usbip_sockfd_store() must perform > > if (sdev->ud.status != SDEV_ST_AVAILABLE) { Oops. This is if (sdev->ud.status == SDEV_ST_AVAILABLE) { of course. > /* misc assignments for attach operation */ > sdev->ud.status = SDEV_ST_USED; > } > > under a lock, or multiple ud->tcp_{tx,rx} are created (which will later > cause a crash like [1]) and refcount on ud->tcp_socket is leaked when > usbip_sockfd_store() is concurrently called. > > problem. That's why my patch introduced usbip_event_mutex lock. > And I think that same serialization is required between "rh_port_connect() from attach_store()" and "rh_port_disconnect() from vhci_shutdown_connection() via usbip_event_add(&vdev->ud, VDEV_EVENT_DOWN) from vhci_port_disconnect() from detach_store()", for both vhci_rx_pdu() from vhci_rx_loop() and vhci_port_disconnect() from detach_store() can queue VDEV_EVENT_DOWN event which can be processed without waiting for attach_store() to complete.
On 3/8/21 3:10 AM, Tetsuo Handa wrote: > On 2021/03/08 16:35, Tetsuo Handa wrote: >> On 2021/03/08 12:53, Shuah Khan wrote: >>> Fix the above problems: >>> - Stop using kthread_get_run() macro to create/start threads. >>> - Create threads and get task struct reference. >>> - Add kthread_create() failure handling and bail out. >>> - Hold usbip_device lock to update local and shared states after >>> creating rx and tx threads. >>> - Update usbip_device status to SDEV_ST_USED. >>> - Update usbip_device tcp_socket, sockfd, tcp_rx, and tcp_tx >>> - Start threads after usbip_device (tcp_socket, sockfd, tcp_rx, tcp_tx, >>> and status) is complete. >> >> No, the whole usbip_sockfd_store() etc. should be serialized using a mutex, >> for two different threads can open same file and write the same content at >> the same moment. This results in seeing SDEV_ST_AVAILABLE and creating two >> threads and overwiting global variables and setting SDEV_ST_USED and starting >> two threads by each of two thread, which will later fail to call kthread_stop() >> on one of two thread because global variables are overwritten. >> >> kthread_crate() (which involves GFP_KERNEL allocation) can take long time >> enough to hit >> >> usbip_sockfd_store() must perform >> >> if (sdev->ud.status != SDEV_ST_AVAILABLE) { > > Oops. This is > > if (sdev->ud.status == SDEV_ST_AVAILABLE) { > > of course. > >> /* misc assignments for attach operation */ >> sdev->ud.status = SDEV_ST_USED; >> } >> >> under a lock, or multiple ud->tcp_{tx,rx} are created (which will later >> cause a crash like [1]) and refcount on ud->tcp_socket is leaked when >> usbip_sockfd_store() is concurrently called. >> >> problem. That's why my patch introduced usbip_event_mutex lock. >> > > And I think that same serialization is required between "rh_port_connect() from attach_store()" and > "rh_port_disconnect() from vhci_shutdown_connection() via usbip_event_add(&vdev->ud, VDEV_EVENT_DOWN) > from vhci_port_disconnect() from detach_store()", for both vhci_rx_pdu() from vhci_rx_loop() and > vhci_port_disconnect() from detach_store() can queue VDEV_EVENT_DOWN event which can be processed > without waiting for attach_store() to complete. > Yes. We might need synchronization between events, threads, and shutdown in usbip_host side and in connection polling and threads in vhci. I am also looking at the shutdown sequences closely as well since the local state is referenced without usbip_device lock in these paths. I am approaching these problems as peeling the onion an expression so we can limit the changes and take a spot fix approach. We have the goal to address these crashes and not introduce regressions. I don't seem to be able to reproduce these problems consistently in my env. with the reproducer. I couldn't reproduce them in normal case at all. Hence, the this cautious approach that reduces the chance of regressions and if we see regressions, they can fixed easily. https://syzkaller.appspot.com/text?tag=ReproC&x=14801034d00000 If this patch series fixes the problems you are seeing, I would like get these fixes in and address the other two potential race conditions in another round of patches. I also want to soak these in the next for a few weeks. Please let me know if these patches fix the problems you are seeing in your env. thanks, -- Shuah
On 2021/03/09 1:27, Shuah Khan wrote: > Yes. We might need synchronization between events, threads, and shutdown > in usbip_host side and in connection polling and threads in vhci. > > I am also looking at the shutdown sequences closely as well since the > local state is referenced without usbip_device lock in these paths. > > I am approaching these problems as peeling the onion an expression so > we can limit the changes and take a spot fix approach. We have the > goal to address these crashes and not introduce regressions. I think my [PATCH v4 01/12]-[PATCH v4 06/12] simplify your further changes without introducing regressions. While ud->lock is held when checking ud->status, current attach/detach code is racy about read/update of ud->status . I think we can close race in attach/detach code via a simple usbip_event_mutex serialization.
On 2021/03/09 20:04, Tetsuo Handa wrote: > On 2021/03/09 1:27, Shuah Khan wrote: >> Yes. We might need synchronization between events, threads, and shutdown >> in usbip_host side and in connection polling and threads in vhci. >> >> I am also looking at the shutdown sequences closely as well since the >> local state is referenced without usbip_device lock in these paths. >> >> I am approaching these problems as peeling the onion an expression so >> we can limit the changes and take a spot fix approach. We have the >> goal to address these crashes and not introduce regressions. > > I think my [PATCH v4 01/12]-[PATCH v4 06/12] simplify your further changes > without introducing regressions. While ud->lock is held when checking ud->status, > current attach/detach code is racy about read/update of ud->status . I think we > can close race in attach/detach code via a simple usbip_event_mutex serialization. > Commit 04679b3489e048cd ("Staging: USB/IP: add client driver") says /* * The important thing is that only one context begins cleanup. * This is why error handling and cleanup become simple. * We do not want to consider race condition as possible. */ static void vhci_shutdown_connection(struct usbip_device *ud) but why are we allowing multiple contexts to begin startup? That's where a subtle race window syzbot is reporting happened. This driver has never thought the possibility that multiple userspace processes can concurrently begin startup. Then, it is quite natural that we make startup simple and safe, by enforcing that only one context begins startup. Without serialization between startup/cleanup/event_handler(), "Fix the above problems:" in your changelog cannot become true. First step should be closing time-of-check to time-of-use bug via entire serialization as if "nonpreemptible UP kernel".
On 3/8/21 9:27 AM, Shuah Khan wrote: > On 3/8/21 3:10 AM, Tetsuo Handa wrote: >> On 2021/03/08 16:35, Tetsuo Handa wrote: >>> On 2021/03/08 12:53, Shuah Khan wrote: >>>> Fix the above problems: >>>> - Stop using kthread_get_run() macro to create/start threads. >>>> - Create threads and get task struct reference. >>>> - Add kthread_create() failure handling and bail out. >>>> - Hold usbip_device lock to update local and shared states after >>>> creating rx and tx threads. >>>> - Update usbip_device status to SDEV_ST_USED. >>>> - Update usbip_device tcp_socket, sockfd, tcp_rx, and tcp_tx >>>> - Start threads after usbip_device (tcp_socket, sockfd, tcp_rx, tcp_tx, >>>> and status) is complete. >>> >>> No, the whole usbip_sockfd_store() etc. should be serialized using a >>> mutex, >>> for two different threads can open same file and write the same >>> content at >>> the same moment. This results in seeing SDEV_ST_AVAILABLE and >>> creating two >>> threads and overwiting global variables and setting SDEV_ST_USED and >>> starting >>> two threads by each of two thread, which will later fail to call >>> kthread_stop() >>> on one of two thread because global variables are overwritten. >>> >>> kthread_crate() (which involves GFP_KERNEL allocation) can take long >>> time >>> enough to hit >>> >>> usbip_sockfd_store() must perform >>> >>> if (sdev->ud.status != SDEV_ST_AVAILABLE) { >> >> Oops. This is >> >> if (sdev->ud.status == SDEV_ST_AVAILABLE) { >> >> of course. >> >>> /* misc assignments for attach operation */ >>> sdev->ud.status = SDEV_ST_USED; >>> } >>> >>> under a lock, or multiple ud->tcp_{tx,rx} are created (which will >>> later >>> cause a crash like [1]) and refcount on ud->tcp_socket is leaked when >>> usbip_sockfd_store() is concurrently called. >>> >>> problem. That's why my patch introduced usbip_event_mutex lock. >>> >> >> And I think that same serialization is required between >> "rh_port_connect() from attach_store()" and >> "rh_port_disconnect() from vhci_shutdown_connection() via >> usbip_event_add(&vdev->ud, VDEV_EVENT_DOWN) >> from vhci_port_disconnect() from detach_store()", for both >> vhci_rx_pdu() from vhci_rx_loop() and >> vhci_port_disconnect() from detach_store() can queue VDEV_EVENT_DOWN >> event which can be processed >> without waiting for attach_store() to complete. >> > > Yes. We might need synchronization between events, threads, and shutdown > in usbip_host side and in connection polling and threads in vhci. > > I am also looking at the shutdown sequences closely as well since the > local state is referenced without usbip_device lock in these paths. > > I am approaching these problems as peeling the onion an expression so > we can limit the changes and take a spot fix approach. We have the > goal to address these crashes and not introduce regressions. > > I don't seem to be able to reproduce these problems consistently in my > env. with the reproducer. I couldn't reproduce them in normal case at > all. Hence, the this cautious approach that reduces the chance of > regressions and if we see regressions, they can fixed easily. > > https://syzkaller.appspot.com/text?tag=ReproC&x=14801034d00000 > > If this patch series fixes the problems you are seeing, I would like > get these fixes in and address the other two potential race conditions > in another round of patches. I also want to soak these in the next > for a few weeks. > > Please let me know if these patches fix the problems you are seeing in > your env. > Can you verify these patches in your environment and see if you are seeing any problems? I want to first see where we are with these fixes. thanks, -- Shuah
On 3/9/21 4:04 AM, Tetsuo Handa wrote: > On 2021/03/09 1:27, Shuah Khan wrote: >> Yes. We might need synchronization between events, threads, and shutdown >> in usbip_host side and in connection polling and threads in vhci. >> >> I am also looking at the shutdown sequences closely as well since the >> local state is referenced without usbip_device lock in these paths. >> >> I am approaching these problems as peeling the onion an expression so >> we can limit the changes and take a spot fix approach. We have the >> goal to address these crashes and not introduce regressions. > > I think my [PATCH v4 01/12]-[PATCH v4 06/12] simplify your further changes > without introducing regressions. While ud->lock is held when checking ud->status, > current attach/detach code is racy about read/update of ud->status . I think we > can close race in attach/detach code via a simple usbip_event_mutex serialization. > Do you mean patches 1,2,3,3,4,5,6? thanks, -- Shuah
On 2021/03/10 4:50, Shuah Khan wrote: > On 3/9/21 4:04 AM, Tetsuo Handa wrote: >> On 2021/03/09 1:27, Shuah Khan wrote: >>> Yes. We might need synchronization between events, threads, and shutdown >>> in usbip_host side and in connection polling and threads in vhci. >>> >>> I am also looking at the shutdown sequences closely as well since the >>> local state is referenced without usbip_device lock in these paths. >>> >>> I am approaching these problems as peeling the onion an expression so >>> we can limit the changes and take a spot fix approach. We have the >>> goal to address these crashes and not introduce regressions. >> >> I think my [PATCH v4 01/12]-[PATCH v4 06/12] simplify your further changes >> without introducing regressions. While ud->lock is held when checking ud->status, >> current attach/detach code is racy about read/update of ud->status . I think we >> can close race in attach/detach code via a simple usbip_event_mutex serialization. >> > > Do you mean patches 1,2,3,3,4,5,6? Yes, my 1,2,3,4,5,6. Since you think that usbip_prepare_threads() does not worth introducing, I'm fine with replacing my 7,8,9,10,11,12 with your "[PATCH 0/6] usbip fixes to crashes found by syzbot".
On 3/9/21 4:40 PM, Tetsuo Handa wrote: > On 2021/03/10 4:50, Shuah Khan wrote: >> On 3/9/21 4:04 AM, Tetsuo Handa wrote: >>> On 2021/03/09 1:27, Shuah Khan wrote: >>>> Yes. We might need synchronization between events, threads, and shutdown >>>> in usbip_host side and in connection polling and threads in vhci. >>>> >>>> I am also looking at the shutdown sequences closely as well since the >>>> local state is referenced without usbip_device lock in these paths. >>>> >>>> I am approaching these problems as peeling the onion an expression so >>>> we can limit the changes and take a spot fix approach. We have the >>>> goal to address these crashes and not introduce regressions. >>> >>> I think my [PATCH v4 01/12]-[PATCH v4 06/12] simplify your further changes >>> without introducing regressions. While ud->lock is held when checking ud->status, >>> current attach/detach code is racy about read/update of ud->status . I think we >>> can close race in attach/detach code via a simple usbip_event_mutex serialization. >>> >> >> Do you mean patches 1,2,3,3,4,5,6? > > Yes, my 1,2,3,4,5,6. > > Since you think that usbip_prepare_threads() does not worth introducing, I'm fine with > replacing my 7,8,9,10,11,12 with your "[PATCH 0/6] usbip fixes to crashes found by syzbot". > Using event lock isn't the right approach to solve the race. It is a large grain lock. I am not looking to replace patches. I still haven't seen any response from you about if you were able to verify the fixes I sent in fix the problem you are seeing. thanks, -- Shuah
On 2021/03/10 8:52, Shuah Khan wrote: > On 3/9/21 4:40 PM, Tetsuo Handa wrote: >> On 2021/03/10 4:50, Shuah Khan wrote: >>> On 3/9/21 4:04 AM, Tetsuo Handa wrote: >>>> On 2021/03/09 1:27, Shuah Khan wrote: >>>>> Yes. We might need synchronization between events, threads, and shutdown >>>>> in usbip_host side and in connection polling and threads in vhci. >>>>> >>>>> I am also looking at the shutdown sequences closely as well since the >>>>> local state is referenced without usbip_device lock in these paths. >>>>> >>>>> I am approaching these problems as peeling the onion an expression so >>>>> we can limit the changes and take a spot fix approach. We have the >>>>> goal to address these crashes and not introduce regressions. >>>> >>>> I think my [PATCH v4 01/12]-[PATCH v4 06/12] simplify your further changes >>>> without introducing regressions. While ud->lock is held when checking ud->status, >>>> current attach/detach code is racy about read/update of ud->status . I think we >>>> can close race in attach/detach code via a simple usbip_event_mutex serialization. >>>> >>> >>> Do you mean patches 1,2,3,3,4,5,6? >> >> Yes, my 1,2,3,4,5,6. >> >> Since you think that usbip_prepare_threads() does not worth introducing, I'm fine with >> replacing my 7,8,9,10,11,12 with your "[PATCH 0/6] usbip fixes to crashes found by syzbot". >> > > Using event lock isn't the right approach to solve the race. It is a > large grain lock. I am not looking to replace patches. It is not a large grain lock. Since event_handler() is exclusively executed, this lock does _NOT_ block event_handler() unless attach/detach operations run concurrently. > > I still haven't seen any response from you about if you were able to > verify the fixes I sent in fix the problem you are seeing. I won't be able to verify your fixes, for it is syzbot who is seeing the problem. But I can see that your patch description is wrong because you are ignoring what I'm commenting. Global serialization had better come first. Your patch description depends on global serialization.
On 3/9/21 5:03 PM, Tetsuo Handa wrote: > On 2021/03/10 8:52, Shuah Khan wrote: >> On 3/9/21 4:40 PM, Tetsuo Handa wrote: >>> On 2021/03/10 4:50, Shuah Khan wrote: >>>> On 3/9/21 4:04 AM, Tetsuo Handa wrote: >>>>> On 2021/03/09 1:27, Shuah Khan wrote: >>>>>> Yes. We might need synchronization between events, threads, and shutdown >>>>>> in usbip_host side and in connection polling and threads in vhci. >>>>>> >>>>>> I am also looking at the shutdown sequences closely as well since the >>>>>> local state is referenced without usbip_device lock in these paths. >>>>>> >>>>>> I am approaching these problems as peeling the onion an expression so >>>>>> we can limit the changes and take a spot fix approach. We have the >>>>>> goal to address these crashes and not introduce regressions. >>>>> >>>>> I think my [PATCH v4 01/12]-[PATCH v4 06/12] simplify your further changes >>>>> without introducing regressions. While ud->lock is held when checking ud->status, >>>>> current attach/detach code is racy about read/update of ud->status . I think we >>>>> can close race in attach/detach code via a simple usbip_event_mutex serialization. >>>>> >>>> >>>> Do you mean patches 1,2,3,3,4,5,6? >>> >>> Yes, my 1,2,3,4,5,6. >>> >>> Since you think that usbip_prepare_threads() does not worth introducing, I'm fine with >>> replacing my 7,8,9,10,11,12 with your "[PATCH 0/6] usbip fixes to crashes found by syzbot". >>> >> >> Using event lock isn't the right approach to solve the race. It is a >> large grain lock. I am not looking to replace patches. > > It is not a large grain lock. Since event_handler() is exclusively executed, this lock > does _NOT_ block event_handler() unless attach/detach operations run concurrently. > >> event handler queues the events. It shouldn't be blocked by attach and detach. The events could originate for various reasons during the host and vhci operations. I don't like using this lock for attach and detach. >> I still haven't seen any response from you about if you were able to >> verify the fixes I sent in fix the problem you are seeing. > > I won't be able to verify your fixes, for it is syzbot who is seeing the problem. Thank you for letting me know. thanks, -- Shuah
On 2021/03/10 9:29, Shuah Khan wrote: >> It is not a large grain lock. Since event_handler() is exclusively executed, this lock >> does _NOT_ block event_handler() unless attach/detach operations run concurrently. >> >>> > > event handler queues the events. It shouldn't be blocked by attach > and detach. The events could originate for various reasons during > the host and vhci operations. I don't like using this lock for > attach and detach. How can attach/detach deadlock event_handler()? event_handler() calls e.g. vhci_shutdown_connection() via ud->eh_ops.shutdown(ud). vhci_shutdown_connection() e.g. waits for termination of tx/rx threads via kthread_stop_put(). event_handler() is already blocked by detach operation. How it can make situation worse to wait for creation of tx/rx threads in attach operation?
On 3/9/21 6:02 PM, Tetsuo Handa wrote: > On 2021/03/10 9:29, Shuah Khan wrote: >>> It is not a large grain lock. Since event_handler() is exclusively executed, this lock >>> does _NOT_ block event_handler() unless attach/detach operations run concurrently. >>> >>>> >> >> event handler queues the events. It shouldn't be blocked by attach >> and detach. The events could originate for various reasons during >> the host and vhci operations. I don't like using this lock for >> attach and detach. > > How can attach/detach deadlock event_handler()? > event_handler() calls e.g. vhci_shutdown_connection() via ud->eh_ops.shutdown(ud). > vhci_shutdown_connection() e.g. waits for termination of tx/rx threads via kthread_stop_put(). > event_handler() is already blocked by detach operation. > How it can make situation worse to wait for creation of tx/rx threads in attach operation? > event_lock shouldn't be held during event ops. usbip_event_add() uses it to add events. Protecting shutdown path needs a different approach. In any case, do you have comments on this patch which doesn't even touch vhci driver? I understand you are identifying additional race condition that the vhci patches in this series might not fix. That doesn't mean that these patches aren't valid. Do you have any comments specific to the patches in this series? thanks, -- Shuah
On 2021/03/10 11:07, Shuah Khan wrote: > On 3/9/21 6:02 PM, Tetsuo Handa wrote: >> On 2021/03/10 9:29, Shuah Khan wrote: >>>> It is not a large grain lock. Since event_handler() is exclusively executed, this lock >>>> does _NOT_ block event_handler() unless attach/detach operations run concurrently. >>>> >>> >>> event handler queues the events. It shouldn't be blocked by attach >>> and detach. The events could originate for various reasons during >>> the host and vhci operations. I don't like using this lock for >>> attach and detach. >> >> How can attach/detach deadlock event_handler()? >> event_handler() calls e.g. vhci_shutdown_connection() via ud->eh_ops.shutdown(ud). >> vhci_shutdown_connection() e.g. waits for termination of tx/rx threads via kthread_stop_put(). >> event_handler() is already blocked by detach operation. >> How it can make situation worse to wait for creation of tx/rx threads in attach operation? >> > > event_lock shouldn't be held during event ops. usbip_event_add() > uses it to add events. Protecting shutdown path needs a different > approach. I can't understand what you are talking about. event_lock is defined as static DEFINE_SPINLOCK(event_lock); in drivers/usb/usbip/usbip_event.c and usbip_event_add() uses it like spin_lock_irqsave(&event_lock, flags); spin_unlock_irqrestore(&event_lock, flags); , but so what? I know event_lock spinlock cannot be taken when calling ud->eh_ops.shutdown(ud); ud->eh_ops.reset(ud); ud->eh_ops.unusable(ud); in event_handler() because e.g. vhci_shutdown_connection() can sleep. What my [PATCH v4 01/12] is suggesting is usbip_event_mutex which is defined as static DEFINE_MUTEX(usbip_event_mutex); in drivers/usb/usbip/usbip_event.c and held when calling ud->eh_ops.shutdown(ud); ud->eh_ops.reset(ud); ud->eh_ops.unusable(ud); in event_handler(). Since event_handler() is executed exclusively via singlethreaded workqueue, "event_handler() holds usbip_event_mutex" itself does not introduce a new lock dependency. My question is, how holding usbip_event_mutex can cause deadlock if usbip_sockfd_store()/attach_store()/detach_store() also hold usbip_event_mutex . kthread_create() is essentially several kmalloc(GFP_KERNEL) where event_handler() cannot interfere unless event_handler() serves as a memory reclaiming function. My question again. What functions might sleep and hold locks other than kthread_create() for tx/rx threads? Your answer to my question (if you identified such dependency) will go into patch shown bottom which replaces my [PATCH v4 01/12]-[PATCH v4 04/12] patches. > > In any case, do you have comments on this patch which doesn't even > touch vhci driver? I'm just replying to your [PATCH 4/6] because all your [PATCH 4/6]-[PATCH 6/6] patches have the same oversight. > > I understand you are identifying additional race condition that > the vhci patches in this series might not fix. That doesn't mean > that these patches aren't valid. > > Do you have any comments specific to the patches in this series? Your [PATCH 5/6] is still racy regarding rh_port_connect() versus rh_port_disconnect(). As soon as you call wake_up_process(), rh_port_disconnect() can be called before rh_port_connect() is called. Since you don't like serializing event_handler() and usbip_sockfd_store()/attach_store()/detach_store() using usbip_event_mutex, my patch shown below which uses attach_detach_lock mutex cannot close such race window. Ideally, wake_up_process() should be deferred to after releasing attach_detach_lock, but please answer to my question first. From: Tetsuo Handa <penguin-kernel@I-love.SAKURA.ne.jp> Date: Wed, 10 Mar 2021 18:31:54 +0900 syzbot is reporting a NULL pointer dereference at sock_sendmsg() [1], for lack of serialization between attach_store() and event_handler() causes vhci_shutdown_connection() to observe vdev->ud.tcp_tx == NULL while vdev->ud.tcp_socket != NULL. Please read the reference link for details of this race window. While usbip module exclusively runs event_handler(), usbip module has never thought the possibility that multiple userspace processes can concurrently call usbip_sockfd_store()/attach_store()/detach_store(). As a result, there is a TOCTTOU bug in these functions regarding ud->status value which can result in similar crashes like [1]. Simplest way would be to run all of event_handler()/usbip_sockfd_store()/attach_store()/detach_store() functions exclusively using a global mutex. But Shuah Khan does not want to share a global mutex between these functions, for ...[please fill in this part]... . Therefore, this patch introduces a per-submodule local mutex which closes race window within usbip_sockfd_store() and attach_store()/detach_store(). This local mutex cannot close race window between event_handler() and usbip_sockfd_store()/attach_store()/detach_store(), for calling wake_up_process() allows kernel thread to call usbip_event_add(VDEV_EVENT_DOWN) and event_handler() will start detach operation before this local mutex is released. The race window via usbip_event_add(VDEV_EVENT_DOWN) from kernel thread will be addressed by subsequent patches in this series, by splitting kthread_get_run() into kthread_create() and wake_up_process(), and deferring wake_up_process() to immediately before releasing this local mutex. [1] https://syzkaller.appspot.com/bug?extid=95ce4b142579611ef0a9 References: https://lkml.kernel.org/r/676d4518-0faa-9fab-15db-0db8d216d7fb@i-love.sakura.ne.jp --- drivers/usb/usbip/stub_dev.c | 16 ++++++++++++++-- drivers/usb/usbip/vhci_sysfs.c | 31 +++++++++++++++++++++++++++---- drivers/usb/usbip/vudc_sysfs.c | 16 ++++++++++++++-- 3 files changed, 55 insertions(+), 8 deletions(-) diff --git a/drivers/usb/usbip/stub_dev.c b/drivers/usb/usbip/stub_dev.c index 2305d425e6c9..66c8f2385f3a 100644 --- a/drivers/usb/usbip/stub_dev.c +++ b/drivers/usb/usbip/stub_dev.c @@ -39,8 +39,8 @@ static DEVICE_ATTR_RO(usbip_status); * is used to transfer usbip requests by kernel threads. -1 is a magic number * by which usbip connection is finished. */ -static ssize_t usbip_sockfd_store(struct device *dev, struct device_attribute *attr, - const char *buf, size_t count) +static ssize_t __usbip_sockfd_store(struct device *dev, struct device_attribute *attr, + const char *buf, size_t count) { struct stub_device *sdev = dev_get_drvdata(dev); int sockfd = 0; @@ -104,6 +104,18 @@ static ssize_t usbip_sockfd_store(struct device *dev, struct device_attribute *a spin_unlock_irq(&sdev->ud.lock); return -EINVAL; } +static ssize_t usbip_sockfd_store(struct device *dev, struct device_attribute *attr, + const char *buf, size_t count) +{ + static DEFINE_MUTEX(attach_detach_lock); + ssize_t ret = mutex_lock_killable(&attach_detach_lock); + + if (ret) + return ret; + ret = __usbip_sockfd_store(dev, attr, buf, count); + mutex_unlock(&attach_detach_lock); + return ret; +} static DEVICE_ATTR_WO(usbip_sockfd); static struct attribute *usbip_attrs[] = { diff --git a/drivers/usb/usbip/vhci_sysfs.c b/drivers/usb/usbip/vhci_sysfs.c index 96e5371dc335..777aba9b9115 100644 --- a/drivers/usb/usbip/vhci_sysfs.c +++ b/drivers/usb/usbip/vhci_sysfs.c @@ -17,6 +17,7 @@ #include "vhci.h" /* TODO: refine locking ?*/ +static DEFINE_MUTEX(attach_detach_lock); /* * output example: @@ -225,8 +226,8 @@ static int valid_port(__u32 *pdev_nr, __u32 *rhport) return 1; } -static ssize_t detach_store(struct device *dev, struct device_attribute *attr, - const char *buf, size_t count) +static ssize_t __detach_store(struct device *dev, struct device_attribute *attr, + const char *buf, size_t count) { __u32 port = 0, pdev_nr = 0, rhport = 0; struct usb_hcd *hcd; @@ -263,6 +264,17 @@ static ssize_t detach_store(struct device *dev, struct device_attribute *attr, return count; } +static ssize_t detach_store(struct device *dev, struct device_attribute *attr, + const char *buf, size_t count) +{ + ssize_t ret = mutex_lock_killable(&attach_detach_lock); + + if (ret) + return ret; + ret = __detach_store(dev, attr, buf, count); + mutex_unlock(&attach_detach_lock); + return ret; +} static DEVICE_ATTR_WO(detach); static int valid_args(__u32 *pdev_nr, __u32 *rhport, @@ -300,8 +312,8 @@ static int valid_args(__u32 *pdev_nr, __u32 *rhport, * * write() returns 0 on success, else negative errno. */ -static ssize_t attach_store(struct device *dev, struct device_attribute *attr, - const char *buf, size_t count) +static ssize_t __attach_store(struct device *dev, struct device_attribute *attr, + const char *buf, size_t count) { struct socket *socket; int sockfd = 0; @@ -396,6 +408,17 @@ static ssize_t attach_store(struct device *dev, struct device_attribute *attr, return count; } +static ssize_t attach_store(struct device *dev, struct device_attribute *attr, + const char *buf, size_t count) +{ + ssize_t ret = mutex_lock_killable(&attach_detach_lock); + + if (ret) + return ret; + ret = __attach_store(dev, attr, buf, count); + mutex_unlock(&attach_detach_lock); + return ret; +} static DEVICE_ATTR_WO(attach); #define MAX_STATUS_NAME 16 diff --git a/drivers/usb/usbip/vudc_sysfs.c b/drivers/usb/usbip/vudc_sysfs.c index 100f680c572a..b14876dd2c0c 100644 --- a/drivers/usb/usbip/vudc_sysfs.c +++ b/drivers/usb/usbip/vudc_sysfs.c @@ -90,8 +90,8 @@ static ssize_t dev_desc_read(struct file *file, struct kobject *kobj, } static BIN_ATTR_RO(dev_desc, sizeof(struct usb_device_descriptor)); -static ssize_t usbip_sockfd_store(struct device *dev, struct device_attribute *attr, - const char *in, size_t count) +static ssize_t __usbip_sockfd_store(struct device *dev, struct device_attribute *attr, + const char *in, size_t count) { struct vudc *udc = (struct vudc *) dev_get_drvdata(dev); int rv; @@ -184,6 +184,18 @@ static ssize_t usbip_sockfd_store(struct device *dev, struct device_attribute *a return ret; } +static ssize_t usbip_sockfd_store(struct device *dev, struct device_attribute *attr, + const char *in, size_t count) +{ + static DEFINE_MUTEX(attach_detach_lock); + ssize_t ret = mutex_lock_killable(&attach_detach_lock); + + if (ret) + return ret; + ret = __usbip_sockfd_store(dev, attr, in, count); + mutex_unlock(&attach_detach_lock); + return ret; +} static DEVICE_ATTR_WO(usbip_sockfd); static ssize_t usbip_status_show(struct device *dev,
diff --git a/drivers/usb/usbip/stub_dev.c b/drivers/usb/usbip/stub_dev.c index 90c105469a07..8f1de1fbbeed 100644 --- a/drivers/usb/usbip/stub_dev.c +++ b/drivers/usb/usbip/stub_dev.c @@ -46,6 +46,8 @@ static ssize_t usbip_sockfd_store(struct device *dev, struct device_attribute *a int sockfd = 0; struct socket *socket; int rv; + struct task_struct *tcp_rx = NULL; + struct task_struct *tcp_tx = NULL; if (!sdev) { dev_err(dev, "sdev is null\n"); @@ -80,20 +82,36 @@ static ssize_t usbip_sockfd_store(struct device *dev, struct device_attribute *a goto sock_err; } - sdev->ud.tcp_socket = socket; - sdev->ud.sockfd = sockfd; - + /* unlock and create threads and get tasks */ spin_unlock_irq(&sdev->ud.lock); + tcp_rx = kthread_create(stub_rx_loop, &sdev->ud, "stub_rx"); + if (IS_ERR(tcp_rx)) { + sockfd_put(socket); + return -EINVAL; + } + tcp_tx = kthread_create(stub_tx_loop, &sdev->ud, "stub_tx"); + if (IS_ERR(tcp_tx)) { + kthread_stop(tcp_rx); + sockfd_put(socket); + return -EINVAL; + } - sdev->ud.tcp_rx = kthread_get_run(stub_rx_loop, &sdev->ud, - "stub_rx"); - sdev->ud.tcp_tx = kthread_get_run(stub_tx_loop, &sdev->ud, - "stub_tx"); + /* get task structs now */ + get_task_struct(tcp_rx); + get_task_struct(tcp_tx); + /* lock and update sdev->ud state */ spin_lock_irq(&sdev->ud.lock); + sdev->ud.tcp_socket = socket; + sdev->ud.sockfd = sockfd; + sdev->ud.tcp_rx = tcp_rx; + sdev->ud.tcp_tx = tcp_tx; sdev->ud.status = SDEV_ST_USED; spin_unlock_irq(&sdev->ud.lock); + wake_up_process(sdev->ud.tcp_rx); + wake_up_process(sdev->ud.tcp_tx); + } else { dev_info(dev, "stub down\n");
usbip_sockfd_store() is invoked when user requests attach (import) detach (unimport) usb device from usbip host. vhci_hcd sends import request and usbip_sockfd_store() exports the device if it is free for export. Export and unexport are governed by local state and shared state - Shared state (usbip device status, sockfd) - sockfd and Device status are used to determine if stub should be brought up or shut down. - Local state (tcp_socket, rx and tx thread task_struct ptrs) A valid tcp_socket controls rx and tx thread operations while the device is in exported state. - While the device is exported, device status is marked used and socket, sockfd, and thread pointers are valid. Export sequence (stub-up) includes validating the socket and creating receive (rx) and transmit (tx) threads to talk to the client to provide access to the exported device. rx and tx threads depends on local and shared state to be correct and in sync. Unexport (stub-down) sequence shuts the socket down and stops the rx and tx threads. Stub-down sequence relies on local and shared states to be in sync. There are races in updating the local and shared status in the current stub-up sequence resulting in crashes. These stem from starting rx and tx threads before local and global state is updated correctly to be in sync. 1. Doesn't handle kthread_create() error and saves invalid ptr in local state that drives rx and tx threads. 2. Updates tcp_socket and sockfd, starts stub_rx and stub_tx threads before updating usbip_device status to SDEV_ST_USED. This opens up a race condition between the threads and usbip_sockfd_store() stub up and down handling. Fix the above problems: - Stop using kthread_get_run() macro to create/start threads. - Create threads and get task struct reference. - Add kthread_create() failure handling and bail out. - Hold usbip_device lock to update local and shared states after creating rx and tx threads. - Update usbip_device status to SDEV_ST_USED. - Update usbip_device tcp_socket, sockfd, tcp_rx, and tcp_tx - Start threads after usbip_device (tcp_socket, sockfd, tcp_rx, tcp_tx, and status) is complete. Credit goes to syzbot and Tetsuo Handa for finding and root-causing the kthread_get_run() improper error handling problem and others. This is a hard problem to find and debug since the races aren't seen in a normal case. Fuzzing forces the race window to be small enough for the kthread_get_run() error path bug and starting threads before updating the local and shared state bug in the stub-up sequence. Tested with syzbot reproducer: - https://syzkaller.appspot.com/text?tag=ReproC&x=14801034d00000 Reported-by: syzbot <syzbot+a93fba6d384346a761e3@syzkaller.appspotmail.com> Reported-by: syzbot <syzbot+bf1a360e305ee719e364@syzkaller.appspotmail.com> Reported-by: syzbot <syzbot+95ce4b142579611ef0a9@syzkaller.appspotmail.com> Reported-by: Tetsuo Handa <penguin-kernel@I-love.SAKURA.ne.jp> Fixes: 9720b4bc76a83807 ("staging/usbip: convert to kthread") Cc: stable@vger.kernel.org Signed-off-by: Shuah Khan <skhan@linuxfoundation.org> --- drivers/usb/usbip/stub_dev.c | 32 +++++++++++++++++++++++++------- 1 file changed, 25 insertions(+), 7 deletions(-)