wifi: cfg80211: reinit wiphy work entries on runaway drain
PATCH 1/1 wifi: cfg80211: reinit wiphy work entries on runaway drain
cfg80211_process_wiphy_works() has a runaway guard for the process-all case. When the guard fires, it drops the remaining queued work by reinitializing rdev->wiphy_work_list.
That only resets the list head. The queued struct wiphy_work entries are embedded in their owners, and their entry fields still point at the old list neighbors. Later queue or cancel checks can then see a work item as listed even though the rdev list has been cleared.
Drain the remaining list with list_del_init() under wiphy_work_lock instead of reinitializing only the head. This keeps the existing WARN and drop behavior while leaving each work item in the same state as normal wiphy work removal.
--- net/wireless/core.c | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-)
net/wireless/core.c +8 -2
@@ -1278,8 +1278,14 @@ void cfg80211_process_wiphy_works(struct cfg80211_registered_device *rdev,if (wk == end)break ; -if (WARN_ON (--runaway_limit ==0 )) -INIT_LIST_HEAD (&rdev->wiphy_work_list); +if (WARN_ON (--runaway_limit ==0 )) { +while (!list_empty (&rdev->wiphy_work_list)) { + wk =list_first_entry (&rdev->wiphy_work_list, + struct wiphy_work, + entry); +list_del_init (&wk->entry); + } + } }spin_unlock_irqrestore (&rdev->wiphy_work_lock, flags); }
Signature · 1 line
2.43.0
Quoted 3 lines · Cen Zhang
cfg80211_process_wiphy_works()has a runaway guard for the process-all case. When the guard fires, it drops the remaining queued work by reinitializingrdev->wiphy_work_list.
Even this likely leaves the system in a bad state since requested work items would be skipped. Probably should also increase runaway_limit quite a bit as well (that has worked OK for me), maybe remove it entirely.
Thanks,
Ben
Quoted 39 lines
That only resets the list head. The queued struct
wiphy_workentries are embedded in their owners, and their entry fields still point at the old list neighbors. Later queue or cancel checks can then see a work item as listed even though the rdev list has been cleared.Drain the remaining list with
list_del_init()underwiphy_work_lockinstead of reinitializing only the head. This keeps the existing WARN and drop behavior while leaving each work item in the same state as normal wiphy work removal.Fixes a3ee4dc84c4e ("wifi: cfg80211: add a work abstraction with special semantics")Assisted-by Codex:gpt-5.5Signed-off-by Cen Zhang <[email protected]>--- net/wireless/core.c | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-)net/wireless/core.c +8
-2@@ -1278,8 +1278,14 @@ void cfg80211_process_wiphy_works(struct cfg80211_registered_device *rdev,if (wk == end)break ; -if (WARN_ON (--runaway_limit ==0 )) -INIT_LIST_HEAD (&rdev->wiphy_work_list); +if (WARN_ON (--runaway_limit ==0 )) { +while (!list_empty (&rdev->wiphy_work_list)) { + wk =list_first_entry (&rdev->wiphy_work_list, + struct wiphy_work, + entry); +list_del_init (&wk->entry); + } + } }spin_unlock_irqrestore (&rdev->wiphy_work_lock, flags); }
Signature · 2 lines
Ben Greear <[email protected]> Candela Technologies Inc http://www.candelatech.com
Hi Ben,
Thanks for your review and comments.
Quoted 3 lines
Even this likely leaves the system in a bad state since requested work items would be skipped. Probably should also increase
runaway_limitquite a bit as well (that has worked OK for me), maybe remove it entirely.
Fair. Hitting the guard still means pending work gets skipped; this patch only avoids leaving those work entries with stale list links after the existing drop path.
I was hesitant to remove the guard in the same change, because the flush-all paths run under the wiphy mutex, and a work item that keeps requeueing itself could otherwise keep flush, suspend, or unregister stuck there. Raising the limit sounds less risky, but I would want a concrete reason for the new value rather than picking one arbitrarily..
Best Regards,
Cen Zhang
Quoted 12 lines · Cen Zhang
Hi Ben,
Thanks for your review and comments.
Quoted 3 lines
Even this likely leaves the system in a bad state since requested work items would be skipped. Probably should also increase
runaway_limitquite a bit as well (that has worked OK for me), maybe remove it entirely.Fair. Hitting the guard still means pending work gets skipped; this patch only avoids leaving those work entries with stale list links after the existing drop path.
Quoted 5 lines
I was hesitant to remove the guard in the same change, because the flush-all paths run under the wiphy mutex, and a work item that keeps requeueing itself could otherwise keep flush, suspend, or unregister stuck there. Raising the limit sounds less risky, but I would want a concrete reason for the new value rather than picking one arbitrarily..
Yeah, you have a good point. I'm not sure of a proper solution. I set my limit to 200 and was no longer able to reproduce warning splats.
Your patch may certainly be an improvement.
Thanks,
Ben
Signature · 2 lines
Ben Greear <[email protected]> Candela Technologies Inc http://www.candelatech.com
Johannes Berg
maintainerQuoted 8 lines · Cen Zhang
cfg80211_process_wiphy_works()has a runaway guard for the process-all case. When the guard fires, it drops the remaining queued work by reinitializingrdev->wiphy_work_list.That only resets the list head. The queued struct
wiphy_workentries are embedded in their owners, and their entry fields still point at the old list neighbors. Later queue or cancel checks can then see a work item as listed even though the rdev list has been cleared.
Yeah ... that's not ideal, but also maybe part of the point. IIRC we've seen cases where works are accidentally re-initialised and we get into infinite loops iterating the list, or so.
So if everything else goes according to plan, your fix is certainly correct. If we get some kind of list corruption in the first place, then it's potentially going to make it worse.
Maybe at this point it's just worth bumping it to a few tens of thousand iterations and doing BUG()? I don't think loop detection is simple here.
johannes
Hi Johannes,
Thanks for your review and explanation.
Quoted 7 lines
Yeah ... that's not ideal, but also maybe part of the point. IIRC we've seen cases where works are accidentally re-initialised and we get into infinite loops iterating the list, or so.
So if everything else goes according to plan, your fix is certainly correct. If we get some kind of list corruption in the first place, then it's potentially going to make it worse.
Fair enough, thanks.
Quoted 2 lines
Maybe at this point it's just worth bumping it to a few tens of thousand iterations and doing
BUG()? I don't think loop detection is simple here.
I'll respin v2 with a much higher limit and BUG() if it is still hit.
Best regards,
Cen Zhang