From: netdev-bot+sashiko@kernel.org
To: 847807867@qq.com
Cc: ms@dev.tdt.de, linux-x25@vger.kernel.org, netdev@vger.kernel.org,
davem@davemloft.net, kuba@kernel.org, edumazet@kernel.org,
pabeni@redhat.com, horms@kernel.org,
syzbot+300375dfd44665f063a6@syzkaller.appspotmail.com,
linux-kernel@vger.kernel.org
Subject: Re: [PATCH] x25: defer socket cleanup on link termination to process context
Date: Wed, 18 Nov 2026 18:35:21 +0000 [thread overview]
Message-ID: <179502692151.3136.18288735873132919768@kernel.org> (raw)
In-Reply-To: <tencent_F7C2DC0FA42B5866E5C39A9E70D3C52C2609@qq.com>
Thank you for your contribution! Sashiko AI review found 5 potential
issue(s) to consider.
Critical: 0 · High: 3 · Medium: 1 · Low: 1
If you believe none of the issues are legitimate, please reply to each
issue of Medium severity or higher and explain why the AI is wrong.
If any of them are legitimate and you plan to respin, please let patchwork
know by including "pw-bot: cr" as a separate line at the end of your reply
(one such reply per series is enough).
- [High] Each of the three new deferral sites calls x25_neigh_hold(nb)
and then schedule_work(&nb->kill_work) without checking what…
- [High] The patch adds nb->kill_work.
- [High] Device deletion now leaves a window in which X.25 sockets can
transmit on a freed net_device.
- [Medium] Moving x25_kill_by_neigh() into a worker changes the X.25
restart and out-of-order handling.
- [Low] The commit fixes a real bug reported by syzbot (sleeping in
atomic context and an inconsistent lockdep state in…
--
x25: defer socket cleanup on link termination to process context
This commit moves the x25_kill_by_neigh() calls in x25_link_control() and
x25_link_terminated() into a per-neighbour work item, so that lock_sock()
runs in process context. Each call site takes a reference on the
neighbour, and the work item drops it once it has run.
Closes: https://syzkaller.appspot.com/bug?extid=300375dfd44665f063a6
> Reported-by: syzbot+300375dfd44665f063a6@syzkaller.appspotmail.com
> Closes: https://syzkaller.appspot.com/bug?extid=300375dfd44665f063a6
> Signed-off-by: Shuai Liu <847807867@qq.com>
[Severity: Low]
This isn't a bug, but should this have a Fixes: tag and a Cc: stable?
The lock_sock()/release_sock() calls in x25_kill_by_neigh() were added by
commit 7781607938c8 ("net/x25: Fix null-ptr-deref caused by
x25_disconnect").
The later commit 5499e0602d2f ("net/x25: fix use-after-free in
x25_kill_by_neigh()") has Fixes: 7781607938c8 and Cc: stable, so the
stable trees contain the sleeping code too.
> diff --git a/net/x25/x25_link.c b/net/x25/x25_link.c
> index d1e8cd81c2143..150ccd78cba64 100644
> --- a/net/x25/x25_link.c
> +++ b/net/x25/x25_link.c
[ ... ]
> @@ -82,7 +90,8 @@ void x25_link_control(struct sk_buff *skb, struct x25_neigh *nb,
> break;
> case X25_LINK_STATE_3:
> /* clear existing virtual calls */
> - x25_kill_by_neigh(nb);
> + x25_neigh_hold(nb);
> + schedule_work(&nb->kill_work);
[Severity: High]
What happens to the reference from x25_neigh_hold() when kill_work is
already pending? In that case schedule_work() returns false and does not
queue the item again. x25_kill_by_neigh_work() still drops only one
reference per run:
static void x25_kill_by_neigh_work(struct work_struct *work)
{
...
x25_kill_by_neigh(nb);
x25_neigh_put(nb);
}
So each extra hold leaks a reference on nb. Once __x25_remove_neigh()
drops the list's reference, the refcount never reaches zero and nb is
never kfree()'d.
In X25_LINK_STATE_3, a RESTART_REQUEST leaves nb->state at STATE_3. A
remote peer that sends several restart requests before the worker runs
would therefore leak one reference per request.
Locally, the same happens when x25_link_terminated() runs twice before
the worker does. Examples are NETDEV_CHANGE with carrier off followed by
NETDEV_DOWN, or X25_IFACE_DISCONNECT followed by NETDEV_DOWN.
The commit message says "x25_kill_by_neigh() is idempotent, so repeated
scheduling is harmless". That holds for the cleanup itself, but does it
hold for the reference counting?
Would something like this work at all three call sites?
x25_neigh_hold(nb);
if (!schedule_work(&nb->kill_work))
x25_neigh_put(nb);
Every caller still holds its own reference from x25_get_neigh(), so that
put cannot free nb.
The RESTART_CONFIRMATION case and x25_link_terminated() below have the
same pattern.
>
> x25_transmit_restart_confirmation(nb);
> break;
[Severity: Medium]
Does deferring the clear change the restart semantics here? Before this
patch, the existing virtual calls were cleared before the restart
confirmation went out.
Now the confirmation goes out and nb->state stays at STATE_3. The stale
sockets are still in X25_STATE_3 with neighbour == nb.
x25_kill_by_neigh() matches only on the neighbour:
sk_for_each(s, &x25_list) {
if (x25_sk(s)->neighbour == nb) {
Calls set up after the restart, through x25_receive_data() ->
x25_rx_call_request() or a local x25_connect(), also have neighbour ==
nb. Would they get disconnected with ENETUNREACH when the worker finally
runs?
Until the worker runs, x25_find_socket(lci, nb) in x25_receive_data()
also keeps delivering post-restart frames to the stale sockets. That
includes a CALL_REQUEST that reuses a stale LCI, which would go to
x25_process_rx_frame() instead of x25_rx_call_request().
After x25_link_terminated() sets nb->state = X25_LINK_STATE_0, the stale
sockets can still transmit. This can happen through x25_sendmsg() ->
x25_kick(), or through the heartbeat and T2 timers via
x25_write_internal().
In STATE_0, x25_transmit_link() queues the skb on nb->queue and calls
x25_establish_link(). Could stale traffic bring a just-terminated link
back up? Those frames would then be flushed by the
nb->state == X25_LINK_STATE_3 loop at the end of x25_link_control().
The NETDEV_DOWN and NETDEV_CHANGE callers in x25_device_event() already
run in process context and didn't need deferral, but they lose their
synchronous cleanup too.
The "clear existing virtual calls" and "X.25 03/93 4.6.3" comments also
no longer match what the code does.
[ ... ]
> @@ -254,7 +264,8 @@ void x25_link_terminated(struct x25_neigh *nb)
> x25_stop_t20timer(nb);
>
> /* Out of order: clear existing virtual calls (X.25 03/93 4.6.3) */
> - x25_kill_by_neigh(nb);
> + x25_neigh_hold(nb);
> + schedule_work(&nb->kill_work);
> }
[Severity: High]
Can this lead to a use-after-free of the net_device when the device is
unregistered? unregister_netdevice() -> dev_close() sends NETDEV_DOWN,
and NETDEV_UNREGISTER follows under RTNL:
x25_device_event()
NETDEV_DOWN
x25_link_terminated(nb)
nb->state = X25_LINK_STATE_0
schedule_work(&nb->kill_work) <- sockets not cleared yet
NETDEV_UNREGISTER
x25_link_device_down(dev)
__x25_remove_neigh(nb)
dev_put(dev)
x25 sockets hold a reference on nb but not on nb->dev. Once the netdev
is freed, nb->dev dangles.
Before this patch, NETDEV_DOWN had already disconnected the sockets
(neighbour = NULL, state = X25_STATE_0). Now, until the worker runs, a
connected socket still has x25->state == X25_STATE_3 and
x25->neighbour == nb:
x25_sendmsg()
x25_kick()
x25_transmit_link(skb, nb) <- nb->state == STATE_0
x25_establish_link(nb)
switch (nb->dev->type)
...
skb->dev = nb->dev;
dev_queue_xmit(skb);
The heartbeat (x25_check_rbuf()) and the T2 timer
(x25_enquiry_response()) reach the same path through
x25_write_internal().
The worker also passes the stale nb->dev to x25_clear_forward_by_dev().
That function compares raw pointers, so it could match a new device
allocated at the same address.
Would it be better to keep the NETDEV_DOWN teardown synchronous, since it
runs in process context? Or at least flush or cancel kill_work and keep
the device pinned until the work has run?
>
> /*
> @@ -269,6 +280,7 @@ void x25_link_device_up(struct net_device *dev)
>
> skb_queue_head_init(&nb->queue);
> timer_setup(&nb->t20timer, x25_t20timer_expiry, 0);
> + INIT_WORK(&nb->kill_work, x25_kill_by_neigh_work);
[Severity: High]
Does anything cancel or flush kill_work on teardown? x25_exit(),
x25_link_free() and x25_link_device_down() never call cancel_work_sync()
or flush_work(). A pending work item does not pin the module.
With no X.25 sockets open, "ip link set <x25dev> down" (NETDEV_DOWN ->
x25_link_terminated() -> schedule_work()) followed right away by
"rmmod x25" is allowed.
x25_exit() -> x25_link_free() then drops the list references. nb stays
allocated because the work holds a reference. However, the module text
and data are freed before system_percpu_wq runs the item. That covers
x25_kill_by_neigh_work(), x25_list_lock, x25_list and x25_forward_list.
There is also an ordering question in x25_exit():
x25_proc_exit();
x25_link_free();
x25_route_free();
...
unregister_netdevice_notifier(&x25_dev_notifier);
dev_remove_pack(&x25_packet_type);
A receive or notifier call that is already in progress, holding an nb
from x25_get_neigh(), could still queue kill_work after x25_link_free().
Would a dedicated workqueue cover this, destroyed at the end of
x25_exit() after packet reception and the notifier have been shut down?
>
> dev_hold(dev);
> nb->dev = dev;
--
Sashiko AI review · https://netdev-ai.bots.linux.dev/sashiko/#/patchset/tencent_F7C2DC0FA42B5866E5C39A9E70D3C52C2609%40qq.com
prev parent reply other threads:[~2026-11-18 18:35 UTC|newest]
Thread overview: 5+ messages / expand[flat|nested] mbox.gz Atom feed top
2026-10-11 0:03 [syzbot] [x25?] inconsistent lock state in x25_kill_by_neigh (2) syzbot
2026-10-14 11:14 ` Forwarded: " syzbot
2026-10-14 11:15 ` syzbot
2026-11-16 0:34 ` [PATCH] x25: defer socket cleanup on link termination to process context Shuai Liu
2026-11-18 18:35 ` netdev-bot+sashiko [this message]
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=179502692151.3136.18288735873132919768@kernel.org \
--to=netdev-bot+sashiko@kernel.org \
--cc=847807867@qq.com \
--cc=davem@davemloft.net \
--cc=edumazet@kernel.org \
--cc=horms@kernel.org \
--cc=kuba@kernel.org \
--cc=linux-kernel@vger.kernel.org \
--cc=linux-x25@vger.kernel.org \
--cc=ms@dev.tdt.de \
--cc=netdev@vger.kernel.org \
--cc=pabeni@redhat.com \
--cc=syzbot+300375dfd44665f063a6@syzkaller.appspotmail.com \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox
all inboxes | Powered by JetHome®