rose: fix use-after-free and reference counting bugs
Subsystems (2)
cover rose: fix use-after-free and reference counting bugs
This series fixes several bugs in the ROSE protocol loopback path and state machines, all confirmed by KASAN on a live system.
A long-standing practical consequence of these bugs is that once the rose module has been used to establish at least one connection, it can no longer be unloaded cleanly: rmmod(8) hangs or causes a kernel crash because outstanding references and running timers prevent the module from completing its exit path. Patches 2 and 3 together fix this by ensuring the loopback timer stops cleanly and all neighbour references are released on module exit.
Patch 1 fixes a device reference leak in rose_loopback_timer(): dev_put() was only called on the failure path of rose_rx_call_request(), leaking a reference on every successful loopback CALL_REQUEST. It also removes a dead check that can never be true for the loopback neighbour.
Patch 2 adds hold/put protection around the loopback timer body so that rose_loopback_neigh cannot be freed while the callback is running.
Patch 3 fixes a race between the loopback timer and module removal by switching rose_loopback_clear() to timer_delete_sync() and adding an atomic loopback_stopping flag that prevents the timer from re-arming itself after module exit has started.
Patch 4 clears rose->neighbour to NULL after every rose_neigh_put() call in the ROSE state machines (rose_in.c), preventing use of a potentially freed pointer by later code paths.
Patch 5 guards the rose_neigh_put() call in rose_timer_expiry() STATE_2 against a NULL pointer that can appear when a concurrent teardown path (e.g. rose_kill_by_device()) has already cleared the neighbour pointer between a timer re-arm and the next firing.
Bernard Pidoux (5):
rose: fix dev_put() leak in rose_loopback_timer()
rose: hold loopback neighbour reference across timer callback
rose: fix race between loopback timer and module removal
rose: clear neighbour pointer after rose_neigh_put() in state machines
rose: guard rose_neigh_put() against NULL in timer expiry
net/rose/rose_in.c | 6 +++++ net/rose/rose_loopback.c | 53 +++++++++++++++++++++++++++------------- net/rose/rose_timer.c | 5 +++- 3 files changed, 46 insertions(+), 18 deletions(-)
Signature · 1 line
2.51.0
PATCH 1/5 rose: fix dev_put() leak in rose_loopback_timer()
rose_rx_call_request() always consumes or returns the skb but never releases the device reference obtained from rose_dev_get(). When rose_rx_call_request() succeeds (returns non-zero) dev_put() was never called, leaking one reference per loopback CALL_REQUEST.
Move dev_put() outside the conditional so it is called unconditionally after rose_rx_call_request() in all cases.
Also remove the dead check (!rose_loopback_neigh->dev && !rose_loopback_neigh->loopback) that immediately precedes it: the loopback neighbour always has loopback=1 so this condition can never be true.
--- net/rose/rose_loopback.c | 11 ++--------- 1 file changed, 2 insertions(+), 9 deletions(-)
net/rose/rose_loopback.c +2 -9
@@ -96,22 +96,15 @@ static void rose_loopback_timer(struct timer_list *unused) }if (frametype ==ROSE_CALL_REQUEST ) { -if (!rose_loopback_neigh->dev && - !rose_loopback_neigh->loopback) { -kfree_skb (skb); -continue ; - } - dev =rose_dev_get (dest);if (!dev) {kfree_skb (skb);continue ; } -if (rose_rx_call_request (skb, dev, rose_loopback_neigh, lci_o) ==0 ) { -dev_put (dev); +if (rose_rx_call_request (skb, dev, rose_loopback_neigh, lci_o) ==0 )kfree_skb (skb); - } +dev_put (dev); }else {kfree_skb (skb); }
Signature · 1 line
2.51.0
PATCH 2/5 rose: hold loopback neighbour reference across timer callback
In reply to Bernard Pidouxrose_loopback_timer() dereferences rose_loopback_neigh throughout its body but holds no reference on it. A concurrent rose_loopback_clear() followed by rose_add_loopback_neigh() could free and reallocate the neighbour while the timer body is running, causing a use-after-free.
Take a reference with rose_neigh_hold() at the start of the callback (bailing out if the pointer is already NULL) and release it with rose_neigh_put() at the single exit point. The neigh cannot be freed while the callback holds a reference.
--- net/rose/rose_loopback.c | 11 ++++++++++- 1 file changed, 10 insertions(+), 1 deletion(-)
net/rose/rose_loopback.c +10 -1
@@ -66,10 +66,15 @@ static void rose_loopback_timer(struct timer_list *unused)unsigned int lci_i, lci_o;int count; +if (rose_loopback_neigh) +rose_neigh_hold (rose_loopback_neigh); +else +return ; +for (count =0 ; count <ROSE_LOOPBACK_LIMIT ; count++) { skb =skb_dequeue (&loopback_queue);if (!skb) -return ; + goto out;if (skb->len <ROSE_MIN_LEN ) {kfree_skb (skb);continue ;
@@ -109,6 +114,10 @@ static void rose_loopback_timer(struct timer_list *unused)kfree_skb (skb); } } + +out: +rose_neigh_put (rose_loopback_neigh); +if (!skb_queue_empty (&loopback_queue))mod_timer (&loopback_timer, jiffies +1 ); }
Signature · 1 line
2.51.0
PATCH 3/5 rose: fix race between loopback timer and module removal
In reply to Bernard Pidouxrose_loopback_clear() called timer_delete() which returns immediately without waiting for any running callback to complete. If the timer fired concurrently with module removal, rose_loopback_timer() could re-arm the timer after timer_delete() returned and then access rose_loopback_neigh after it was freed.
Two complementary changes close the race:
1. Add a loopback_stopping atomic flag. rose_loopback_timer() checks it at entry (before acquiring a reference) and again inside the loop; when set it drains the queue and exits without re-arming the timer.
2. Switch rose_loopback_clear() to timer_delete_sync() so it blocks until any in-flight callback has returned before freeing resources.
The smp_mb() between setting the flag and calling timer_delete_sync() ensures the flag is visible to any callback that is about to run.
--- net/rose/rose_loopback.c | 31 ++++++++++++++++++++++++------- 1 file changed, 24 insertions(+), 7 deletions(-)
net/rose/rose_loopback.c +24 -7
@@ -12,13 +12,15 @@#include <net/rose.h> #include <linux/init.h> -static struct sk_buff_head loopback_queue;#define ROSE_LOOPBACK_LIMIT 1000 -static struct timer_list loopback_timer; +static struct timer_list loopback_timer; +static struct sk_buff_head loopback_queue;static void rose_set_loopback_timer (void );static void rose_loopback_timer (struct timer_list *unused); +static atomic_t loopback_stopping =ATOMIC_INIT (0 ); +void rose_loopback_init (void ) {skb_queue_head_init (&loopback_queue);
@@ -66,6 +68,9 @@ static void rose_loopback_timer(struct timer_list *unused)unsigned int lci_i, lci_o;int count; +if (atomic_read (&loopback_stopping)) +return ; +if (rose_loopback_neigh)rose_neigh_hold (rose_loopback_neigh);else
@@ -75,6 +80,13 @@ static void rose_loopback_timer(struct timer_list *unused) skb =skb_dequeue (&loopback_queue);if (!skb) goto out; + +if (atomic_read (&loopback_stopping)) { +kfree_skb (skb); +skb_queue_purge (&loopback_queue); + goto out; + } +if (skb->len <ROSE_MIN_LEN ) {kfree_skb (skb);continue ;
@@ -118,7 +130,7 @@ static void rose_loopback_timer(struct timer_list *unused) out:rose_neigh_put (rose_loopback_neigh); -if (!skb_queue_empty (&loopback_queue)) +if (!atomic_read (&loopback_stopping) && !skb_queue_empty (&loopback_queue))mod_timer (&loopback_timer, jiffies +1 ); }
@@ -126,10 +138,15 @@ void __exit rose_loopback_clear(void) {struct sk_buff *skb; -timer_delete (&loopback_timer); +atomic_set (&loopback_stopping,1 ); +/* Pairs with atomic_read() in rose_loopback_timer(): ensure the +* stopping flag is visible before we cancel, so a concurrent +* callback aborts its loop early rather than re-arming the timer. +*/ +smp_mb (); + +timer_delete_sync (&loopback_timer); -while ((skb =skb_dequeue (&loopback_queue)) !=NULL ) { - skb->sk =NULL ; +while ((skb =skb_dequeue (&loopback_queue)) !=NULL )kfree_skb (skb); - } }
Signature · 1 line
2.51.0
PATCH 4/5 rose: clear neighbour pointer after rose_neigh_put() in state machines
In reply to Bernard PidouxAfter calling rose_neigh_put() in rose_state1_machine() through rose_state5_machine(), rose->neighbour was left pointing at the potentially freed neighbour structure. A subsequent timer expiry or concurrent teardown path could dereference the stale pointer, causing a use-after-free.
Set rose->neighbour to NULL immediately after each rose_neigh_put() call in the state machine functions.
--- net/rose/rose_in.c | 6 ++++++ 1 file changed, 6 insertions(+)
net/rose/rose_in.c +6 -0
@@ -57,6 +57,7 @@ static int rose_state1_machine(struct sock *sk, struct sk_buff *skb, int frametyrose_write_internal (sk,ROSE_CLEAR_CONFIRMATION );rose_disconnect (sk,ECONNREFUSED , skb->data[3 ], skb->data[4 ]);rose_neigh_put (rose->neighbour); + rose->neighbour =NULL ;break ;default :
@@ -80,11 +81,13 @@ static int rose_state2_machine(struct sock *sk, struct sk_buff *skb, int frametyrose_write_internal (sk,ROSE_CLEAR_CONFIRMATION );rose_disconnect (sk,0 , skb->data[3 ], skb->data[4 ]);rose_neigh_put (rose->neighbour); + rose->neighbour =NULL ;break ;case ROSE_CLEAR_CONFIRMATION :rose_disconnect (sk,0 ,-1 ,-1 );rose_neigh_put (rose->neighbour); + rose->neighbour =NULL ;break ;default :
@@ -122,6 +125,7 @@ static int rose_state3_machine(struct sock *sk, struct sk_buff *skb, int frametyrose_write_internal (sk,ROSE_CLEAR_CONFIRMATION );rose_disconnect (sk,0 , skb->data[3 ], skb->data[4 ]);rose_neigh_put (rose->neighbour); + rose->neighbour =NULL ;break ;case ROSE_RR :
@@ -235,6 +239,7 @@ static int rose_state4_machine(struct sock *sk, struct sk_buff *skb, int frametyrose_write_internal (sk,ROSE_CLEAR_CONFIRMATION );rose_disconnect (sk,0 , skb->data[3 ], skb->data[4 ]);rose_neigh_put (rose->neighbour); + rose->neighbour =NULL ;break ;default :
@@ -255,6 +260,7 @@ static int rose_state5_machine(struct sock *sk, struct sk_buff *skb, int frametyrose_write_internal (sk,ROSE_CLEAR_CONFIRMATION );rose_disconnect (sk,0 , skb->data[3 ], skb->data[4 ]);rose_neigh_put (rose_sk (sk)->neighbour); +rose_sk (sk)->neighbour =NULL ; }return 0 ;
Signature · 1 line
2.51.0
PATCH 5/5 rose: guard rose_neigh_put() against NULL in timer expiry
In reply to Bernard PidouxIn rose_timer_expiry(), the ROSE_STATE_2 branch calls rose_neigh_put(rose->neighbour) without first checking whether the pointer is NULL. After commit 5de7665e0a07 ("net: rose: fix timer races against user threads") the timer is re-armed when the socket is owned by a user thread; between the re-arm and the next firing, a device-down event or concurrent teardown via rose_kill_by_device() can set rose->neighbour to NULL, leading to a NULL-pointer dereference inside rose_neigh_put().
Add a NULL check before the put and clear the pointer afterwards.
--- net/rose/rose_timer.c | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-)
net/rose/rose_timer.c +4 -1
@@ -180,7 +180,10 @@ static void rose_timer_expiry(struct timer_list *t)break ;case ROSE_STATE_2 :/* T3 */ -rose_neigh_put (rose->neighbour); +if (rose->neighbour) { +rose_neigh_put (rose->neighbour); + rose->neighbour =NULL ; + }rose_disconnect (sk,ETIMEDOUT ,-1 ,-1 );break ;
Signature · 1 line
2.51.0