FAILED: patch "[PATCH] usb: gadget: f_fs: initialize reset_work at allocation time" failed to apply to 6.18-stable tree
Subsystems (2)
[email protected]
maintainerThe patch below does not apply to the 6.18-stable tree.
If someone wants it applied there, or to any other stable or longterm tree, then please email the backport, including the original git commit id to <[email protected]>.
To reproduce the conflict and resubmit, you may use the following commands:
git fetch https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git/ linux-6.18.y
git checkout FETCH_HEAD
git cherry-pick -x 3137b243c93982fe3460335e12f9247739766e10
# <resolve conflicts, build, test, etc.>
git commit -s
git send-email --to '<[email protected]>' --in-reply-to '2026071455-cultural-frenzy-db69@gregkh' --subject-prefix 'PATCH 6.18.y' 'HEAD^..'
Possible dependencies:
thanks,
greg k-h
------------------ original commit in Linus's tree ------------------
From 3137b243c93982fe3460335e12f9247739766e10 Mon Sep 17 00:00:00 2001
From: Tyler Baker <[email protected]>
Date: Tue, 9 Jun 2026 15:36:34 -0400
Subject: [PATCH] usb: gadget: f_fs: initialize reset_work at allocation time
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
ffs_fs_kill_sb() unconditionally calls cancel_work_sync() on ffs->reset_work when a functionfs instance is unmounted:
ffs_data_reset(ffs); cancel_work_sync(&ffs->reset_work);
However ffs->reset_work is only ever initialized via INIT_WORK() in ffs_func_set_alt() and ffs_func_disable(), and only on the FFS_DEACTIVATED path. That state is reached solely by ffs_data_closed() when the instance is mounted with the "no_disconnect" option, so for the common case (no "no_disconnect", or mounted and unmounted without ever being deactivated) reset_work is never initialized.
ffs_data_new() allocates the ffs_data with kzalloc_obj() and does not initialize reset_work, and ffs_data_reset()/ffs_data_clear() do not touch it either, so reset_work.func is left NULL. cancel_work_sync() on such a work then trips the WARN_ON(!work->func) guard in __flush_work():
WARNING: kernel/workqueue.c:4301 at __flush_work+0x330/0x360, CPU#3: umount Call trace: __flush_work cancel_work_sync ffs_fs_kill_sb [usb_f_fs] deactivate_locked_super deactivate_super cleanup_mnt __cleanup_mnt task_work_run exit_to_user_mode_loop el0_svc
On older kernels cancel_work_sync() on a zero-initialized work struct was a silent no-op, which hid the missing initialization.
Initialize reset_work once in ffs_data_new() so it is always valid for the lifetime of the ffs_data, and drop the now-redundant INIT_WORK() calls from the two deactivation paths.
drivers/usb/gadget/function/f_fs.c +2 -2
@@ -288,6 +288,7 @@ static int ffs_acquire_dev(const char *dev_name, struct ffs_data *ffs_data);static void ffs_release_dev (struct ffs_dev *ffs_dev);static int ffs_ready (struct ffs_data *ffs);static void ffs_closed (struct ffs_data *ffs); +static void ffs_reset_work (struct work_struct *work);/* Misc helper functions ****************************************************/
@@ -2222,6 +2223,7 @@ static struct ffs_data *ffs_data_new(const char *dev_name)init_waitqueue_head (&ffs->ev.waitq);init_waitqueue_head (&ffs->wait);init_completion (&ffs->ep0req_completion); +INIT_WORK (&ffs->reset_work, ffs_reset_work);/* XXX REVISIT need to update it in some places, or do we? */ ffs->ev.can_stall =1 ;
@@ -3776,7 +3778,6 @@ static int ffs_func_set_alt(struct usb_function *f,if (ffs->state ==FFS_DEACTIVATED ) { ffs->state =FFS_CLOSING ;spin_unlock_irqrestore (&ffs->eps_lock, flags); -INIT_WORK (&ffs->reset_work, ffs_reset_work);schedule_work (&ffs->reset_work);return -ENODEV ; }
@@ -3807,7 +3808,6 @@ static void ffs_func_disable(struct usb_function *f)if (ffs->state ==FFS_DEACTIVATED ) { ffs->state =FFS_CLOSING ;spin_unlock_irqrestore (&ffs->eps_lock, flags); -INIT_WORK (&ffs->reset_work, ffs_reset_work);schedule_work (&ffs->reset_work);return ; }
Sasha Levin
maintainerPATCH 1/6 new helper: simple_remove_by_name()
From: Al Viro <[email protected]>
[ Upstream commit 4051a9115ad24bb9a691774730ca9c1dd56de665 ]
simple_recursive_removal(), but instead of victim dentry it takes parent + name.
Used to be open-coded in fs/fuse/control.c, but there's no need to expose the guts of that thing there and there are other potential users, so let's lift it into libfs...
Stable-dep-of: 3137b243c939 ("usb: gadget: f_fs: initialize reset_work at allocation time")
--- fs/fuse/control.c | 7 +------ fs/libfs.c | 13 +++++++++++++ include/linux/fs.h | 2 ++ 3 files changed, 16 insertions(+), 6 deletions(-)
fs/fuse/control.c +1 -6
@@ -290,18 +290,13 @@ static void remove_one(struct dentry *dentry)*/ void fuse_ctl_remove_conn (struct fuse_conn *fc) { -struct dentry *dentry;char name[32 ];if (!fuse_control_sb || fc->no_control)return ;sprintf (name,"%u" , fc->dev); - dentry =lookup_noperm_positive_unlocked (&QSTR (name), fuse_control_sb->s_root); -if (!IS_ERR (dentry)) { -simple_recursive_removal (dentry, remove_one); -dput (dentry);// paired with lookup_noperm_positive_unlocked() - } +simple_remove_by_name (fuse_control_sb->s_root, name, remove_one); }static int fuse_ctl_fill_super (struct super_block *sb,struct fs_context *fsc)
fs/libfs.c +13 -0
@@ -647,6 +647,19 @@ void simple_recursive_removal(struct dentry *dentry, }EXPORT_SYMBOL (simple_recursive_removal); +void simple_remove_by_name (struct dentry *parent,const char *name, +void (*callback)(struct dentry *)) +{ +struct dentry *dentry; + + dentry =lookup_noperm_positive_unlocked (&QSTR (name), parent); +if (!IS_ERR (dentry)) { +simple_recursive_removal (dentry, callback); +dput (dentry);// paired with lookup_noperm_positive_unlocked() + } +} +EXPORT_SYMBOL (simple_remove_by_name); +/* caller holds parent directory with I_MUTEX_PARENT */ void locked_recursive_removal (struct dentry *dentry,void (*callback)(struct dentry *))
include/linux/fs.h +2 -0
@@ -3654,6 +3654,8 @@ extern int simple_rename(struct mnt_idmap *, struct inode *, unsigned int);extern void simple_recursive_removal (struct dentry *,void (*callback)(struct dentry *)); +extern void simple_remove_by_name (struct dentry *,const char *, +void (*callback)(struct dentry *));extern void locked_recursive_removal (struct dentry *,void (*callback)(struct dentry *));extern int noop_fsync (struct file *,loff_t ,loff_t ,int );
Signature · 1 line
2.53.0
Sasha Levin
maintainerPATCH 2/6 functionfs: don't abuse ffs_data_closed() on fs shutdown
From: Al Viro <[email protected]>
[ Upstream commit fcb8985143540cbcb8e91c0ea8b7fb5d37c88177 ]
ffs_data_closed() has a seriously confusing logics in it: in addition to the normal "decrement a counter and do some work if it hits zero" there's "... and if it has somehow become negative, do that" bit.
It's not a race, despite smelling rather fishy. What really happens is that in addition to "call that on close of files there, to match the increments of counter on opens" there's one call in ->kill_sb(). Counter starts at 0 and never goes negative over the lifetime of filesystem (or we have much worse problems everywhere - ->release() call of some file somehow unpaired with successful ->open() of the same). At the filesystem shutdown it will be 0 or, again, we have much worse problems - filesystem instance destroyed with files on it still open. In other words, at that call and at that call alone the decrement would go from 0 to -1, hitting that chunk (and not hitting the "if it hits 0" part).
So that check is a weirdly spelled "called from ffs_kill_sb()". Just expand the call in the latter and kill the misplaced chunk in ffs_data_closed().
Stable-dep-of: 3137b243c939 ("usb: gadget: f_fs: initialize reset_work at allocation time")
--- drivers/usb/gadget/function/f_fs.c | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-)
drivers/usb/gadget/function/f_fs.c +8 -8
@@ -2086,12 +2086,18 @@ static int ffs_fs_init_fs_context(struct fs_context *fc)return 0 ; } +static void ffs_data_reset (struct ffs_data *ffs); +static void ffs_fs_kill_sb (struct super_block *sb) {kill_litter_super (sb); -if (sb->s_fs_info) -ffs_data_closed (sb->s_fs_info); +if (sb->s_fs_info) { +struct ffs_data *ffs = sb->s_fs_info; + ffs->state =FFS_CLOSING ; +ffs_data_reset (ffs); +ffs_data_put (ffs); + } }static struct file_system_type ffs_fs_type = {
@@ -2129,7 +2135,6 @@ static void functionfs_cleanup(void)/* ffs_data and ffs_function construction and destruction code **************/ static void ffs_data_clear (struct ffs_data *ffs); -static void ffs_data_reset (struct ffs_data *ffs);static void ffs_data_get (struct ffs_data *ffs) {
@@ -2186,11 +2191,6 @@ static void ffs_data_closed(struct ffs_data *ffs)ffs_data_reset (ffs); } } -if (atomic_read (&ffs->opened) <0 ) { - ffs->state =FFS_CLOSING ; -ffs_data_reset (ffs); - } -ffs_data_put (ffs); }
Signature · 1 line
2.53.0
Sasha Levin
maintainerPATCH 3/6 functionfs: don't bother with ffs->ref in ffs_data_{opened,closed}()
In reply to Sasha LevinFrom: Al Viro <[email protected]>
[ Upstream commit fe47466282a69499ae17a22f064e827badb77078 ]
A reference is held by the superblock (it's dropped in ffs_kill_sb()) and filesystem will not get to ->kill_sb() while there are any opened files, TYVM...
Stable-dep-of: 3137b243c939 ("usb: gadget: f_fs: initialize reset_work at allocation time")
--- drivers/usb/gadget/function/f_fs.c | 8 +++----- 1 file changed, 3 insertions(+), 5 deletions(-)
drivers/usb/gadget/function/f_fs.c +3 -5
@@ -2143,7 +2143,6 @@ static void ffs_data_get(struct ffs_data *ffs)static void ffs_data_opened (struct ffs_data *ffs) { -refcount_inc (&ffs->ref);if (atomic_add_return (1 , &ffs->opened) ==1 && ffs->state ==FFS_DEACTIVATED ) { ffs->state =FFS_CLOSING ;
@@ -2168,11 +2167,11 @@ static void ffs_data_put(struct ffs_data *ffs)static void ffs_data_closed (struct ffs_data *ffs) { -struct ffs_epfile *epfiles; -unsigned long flags; -if (atomic_dec_and_test (&ffs->opened)) {if (ffs->no_disconnect) { +struct ffs_epfile *epfiles; +unsigned long flags; + ffs->state =FFS_DEACTIVATED ;spin_lock_irqsave (&ffs->eps_lock, flags); epfiles = ffs->epfiles;
@@ -2191,7 +2190,6 @@ static void ffs_data_closed(struct ffs_data *ffs)ffs_data_reset (ffs); } } -ffs_data_put (ffs); }static struct ffs_data *ffs_data_new (const char *dev_name)
Signature · 1 line
2.53.0
Sasha Levin
maintainerPATCH 4/6 functionfs: switch to simple_remove_by_name()
In reply to Sasha LevinFrom: Al Viro <[email protected]>
[ Upstream commit c7747fafaba0dcdad3d7da240e961927b4865f98 ]
No need to return dentry from ffs_sb_create_file() or keep it around afterwards.
To avoid subtle issues with getting to ffs from epfiles in ffs_epfiles_destroy(), pass the superblock as explicit argument. Callers have it anyway.
Stable-dep-of: 3137b243c939 ("usb: gadget: f_fs: initialize reset_work at allocation time")
--- drivers/usb/gadget/function/f_fs.c | 51 +++++++++++++----------------- 1 file changed, 22 insertions(+), 29 deletions(-)
drivers/usb/gadget/function/f_fs.c +22 -29
@@ -162,8 +162,6 @@ struct ffs_epfile {struct ffs_data *ffs;struct ffs_ep *ep;/* P: ffs->eps_lock */ -struct dentry *dentry; -/* * Buffer for holding data from partial reads which may happen since * we’re rounding user read requests to a multiple of a max packet size.
@@ -273,11 +271,11 @@ struct ffs_desc_helper { };static int __must_check ffs_epfiles_create (struct ffs_data *ffs); -static void ffs_epfiles_destroy (struct ffs_epfile *epfiles,unsigned count); +static void ffs_epfiles_destroy (struct super_block *sb, +struct ffs_epfile *epfiles,unsigned count); -static struct dentry * -ffs_sb_create_file (struct super_block *sb,const char *name,void *data, -const struct file_operations *fops); +static int ffs_sb_create_file (struct super_block *sb,const char *name, +void *data,const struct file_operations *fops);/* Devices management *******************************************************/
@@ -1881,9 +1879,8 @@ ffs_sb_make_inode(struct super_block *sb, void *data, }/* Create "regular" file */ -static struct dentry *ffs_sb_create_file (struct super_block *sb, -const char *name,void *data, -const struct file_operations *fops) +static int ffs_sb_create_file (struct super_block *sb,const char *name, +void *data,const struct file_operations *fops) {struct ffs_data *ffs = sb->s_fs_info;struct dentry *dentry;
@@ -1891,16 +1888,16 @@ static struct dentry *ffs_sb_create_file(struct super_block *sb, dentry =d_alloc_name (sb->s_root, name);if (!dentry) -return NULL ; +return -ENOMEM ; inode =ffs_sb_make_inode (sb, data, fops,NULL , &ffs->file_perms);if (!inode) {dput (dentry); -return NULL ; +return -ENOMEM ; }d_add (dentry, inode); -return dentry; +return 0 ; }/* Super block */
@@ -1943,10 +1940,7 @@ static int ffs_sb_fill(struct super_block *sb, struct fs_context *fc)return -ENOMEM ;/* EP0 file */ -if (!ffs_sb_create_file (sb,"ep0" , ffs, &ffs_ep0_operations)) -return -ENOMEM ; - -return 0 ; +return ffs_sb_create_file (sb,"ep0" , ffs, &ffs_ep0_operations); }enum {
@@ -2180,7 +2174,7 @@ static void ffs_data_closed(struct ffs_data *ffs) flags);if (epfiles) -ffs_epfiles_destroy (epfiles, +ffs_epfiles_destroy (ffs->sb, epfiles, ffs->eps_count);if (ffs->setup_state ==FFS_SETUP_PENDING )
@@ -2239,7 +2233,7 @@ static void ffs_data_clear(struct ffs_data *ffs)* copy of epfile will save us from use-after-free. */ if (epfiles) { -ffs_epfiles_destroy (epfiles, ffs->eps_count); +ffs_epfiles_destroy (ffs->sb, epfiles, ffs->eps_count); ffs->epfiles =NULL ; }
@@ -2336,6 +2330,7 @@ static int ffs_epfiles_create(struct ffs_data *ffs) {struct ffs_epfile *epfile, *epfiles;unsigned i, count; +int err; count = ffs->eps_count; epfiles =kcalloc (count,sizeof (*epfiles),GFP_KERNEL );
@@ -2353,12 +2348,11 @@ static int ffs_epfiles_create(struct ffs_data *ffs)else sprintf (epfile->name,"ep%u" , i); epfile->in = (ffs->eps_addrmap[i] &USB_ENDPOINT_DIR_MASK ) ?1 :0 ; - epfile->dentry =ffs_sb_create_file (ffs->sb, epfile->name, - epfile, - &ffs_epfile_operations); -if (!epfile->dentry) { -ffs_epfiles_destroy (epfiles, i -1 ); -return -ENOMEM ; + err =ffs_sb_create_file (ffs->sb, epfile->name, + epfile, &ffs_epfile_operations); +if (err) { +ffs_epfiles_destroy (ffs->sb, epfiles, i -1 ); +return err; } }
@@ -2366,16 +2360,15 @@ static int ffs_epfiles_create(struct ffs_data *ffs)return 0 ; } -static void ffs_epfiles_destroy (struct ffs_epfile *epfiles,unsigned count) +static void ffs_epfiles_destroy (struct super_block *sb, +struct ffs_epfile *epfiles,unsigned count) {struct ffs_epfile *epfile = epfiles; +struct dentry *root = sb->s_root;for (; count; --count, ++epfile) {BUG_ON (mutex_is_locked (&epfile->mutex)); -if (epfile->dentry) { -simple_recursive_removal (epfile->dentry,NULL ); - epfile->dentry =NULL ; - } +simple_remove_by_name (root, epfile->name,NULL ); }kfree (epfiles);
Signature · 1 line
2.53.0
Sasha Levin
maintainerPATCH 5/6 functionfs: use spinlock for FFS_DEACTIVATED/FFS_CLOSING transitions
In reply to Sasha LevinFrom: Al Viro <[email protected]>
[ Upstream commit 2005aabe94eaab8608879d98afb901bc99bc3a31 ]
When all files are closed, functionfs needs ffs_data_reset() to be done before any further opens are allowed.
During that time we have ffs->state set to FFS_CLOSING; that makes ->open() fail with -EBUSY. Once ffs_data_reset() is done, it switches state (to FFS_READ_DESCRIPTORS) indicating that opening that thing is allowed again. There's a couple of additional twists:
* mounting with -o no_disconnect delays ffs_data_reset()
from doing that at the final ->release() to the first subsequent open(). That's indicated by ffs->state set to FFS_DEACTIVATED; if open() sees that, it immediately switches to FFS_CLOSING and proceeds with doing ffs_data_reset() before returning to userland.
* a couple of usb callbacks need to force the delayed
transition; unfortunately, they are done in locking environment that does not allow blocking and ffs_data_reset() can block. As the result, if these callbacks see FFS_DEACTIVATED, they change state to FFS_CLOSING and use schedule_work() to get ffs_data_reset() executed asynchronously.
Unfortunately, the locking is rather insufficient. A fix attempted in e5bf5ee26663 ("functionfs: fix the open/removal races") had closed a bunch of UAF, but it didn't do anything to the callbacks, lacked barriers in transition from FFS_CLOSING to FFS_READ_DESCRIPTORS _and_ it had been too heavy-handed in open()/open() serialization - I've used ffs->mutex for that, and it's being held over actual IO on ep0, complete with copy_from_user(), etc.
Even more unfortunately, the userland side is apparently racy enough to have the resulting timing changes (no failures, just a delayed return of open(2)) disrupt the things quite badly. Userland bugs or not, it's a clear regression that needs to be dealt with.
Solution is to use a spinlock for serializing these state checks and transitions - unlike ffs->mutex it can be taken in these callbacks and it doesn't disrupt the timings in open().
We could introduce a new spinlock, but it's easier to use the one that is already there (ffs->eps_lock) instead - the locking environment is safe for it in all affected places.
Since now it is held over all places that alter or check the open count (ffs->opened), there's no need to keep that atomic_t - int would serve just fine and it's simpler that way.
Stable-dep-of: 3137b243c939 ("usb: gadget: f_fs: initialize reset_work at allocation time")
--- drivers/usb/gadget/function/f_fs.c | 8 ++++++++ 1 file changed, 8 insertions(+)
drivers/usb/gadget/function/f_fs.c +8 -0
@@ -3736,6 +3736,7 @@ static int ffs_func_set_alt(struct usb_function *f, {struct ffs_function *func =ffs_func_from_usb (f);struct ffs_data *ffs = func->ffs; +unsigned long flags;int ret =0 , intf;if (alt >MAX_ALT_SETTINGS )
@@ -3748,12 +3749,15 @@ static int ffs_func_set_alt(struct usb_function *f,if (ffs->func)ffs_func_eps_disable (ffs->func); +spin_lock_irqsave (&ffs->eps_lock, flags);if (ffs->state ==FFS_DEACTIVATED ) { ffs->state =FFS_CLOSING ; +spin_unlock_irqrestore (&ffs->eps_lock, flags);INIT_WORK (&ffs->reset_work, ffs_reset_work);schedule_work (&ffs->reset_work);return -ENODEV ; } +spin_unlock_irqrestore (&ffs->eps_lock, flags);if (ffs->state !=FFS_ACTIVE )return -ENODEV ;
@@ -3771,16 +3775,20 @@ static void ffs_func_disable(struct usb_function *f) {struct ffs_function *func =ffs_func_from_usb (f);struct ffs_data *ffs = func->ffs; +unsigned long flags;if (ffs->func)ffs_func_eps_disable (ffs->func); +spin_lock_irqsave (&ffs->eps_lock, flags);if (ffs->state ==FFS_DEACTIVATED ) { ffs->state =FFS_CLOSING ; +spin_unlock_irqrestore (&ffs->eps_lock, flags);INIT_WORK (&ffs->reset_work, ffs_reset_work);schedule_work (&ffs->reset_work);return ; } +spin_unlock_irqrestore (&ffs->eps_lock, flags);if (ffs->state ==FFS_ACTIVE ) { ffs->func =NULL ;
Signature · 1 line
2.53.0
Sasha Levin
maintainerPATCH 6/6 usb: gadget: f_fs: initialize reset_work at allocation time
In reply to Sasha LevinFrom: Tyler Baker <[email protected]>
[ Upstream commit 3137b243c93982fe3460335e12f9247739766e10 ]
ffs_fs_kill_sb() unconditionally calls cancel_work_sync() on ffs->reset_work when a functionfs instance is unmounted:
ffs_data_reset(ffs); cancel_work_sync(&ffs->reset_work);
However ffs->reset_work is only ever initialized via INIT_WORK() in ffs_func_set_alt() and ffs_func_disable(), and only on the FFS_DEACTIVATED path. That state is reached solely by ffs_data_closed() when the instance is mounted with the "no_disconnect" option, so for the common case (no "no_disconnect", or mounted and unmounted without ever being deactivated) reset_work is never initialized.
ffs_data_new() allocates the ffs_data with kzalloc_obj() and does not initialize reset_work, and ffs_data_reset()/ffs_data_clear() do not touch it either, so reset_work.func is left NULL. cancel_work_sync() on such a work then trips the WARN_ON(!work->func) guard in __flush_work():
WARNING: kernel/workqueue.c:4301 at __flush_work+0x330/0x360, CPU#3: umount Call trace: __flush_work cancel_work_sync ffs_fs_kill_sb [usb_f_fs] deactivate_locked_super deactivate_super cleanup_mnt __cleanup_mnt task_work_run exit_to_user_mode_loop el0_svc
On older kernels cancel_work_sync() on a zero-initialized work struct was a silent no-op, which hid the missing initialization.
Initialize reset_work once in ffs_data_new() so it is always valid for the lifetime of the ffs_data, and drop the now-redundant INIT_WORK() calls from the two deactivation paths.
--- drivers/usb/gadget/function/f_fs.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
drivers/usb/gadget/function/f_fs.c +2 -2
@@ -289,6 +289,7 @@ static int ffs_acquire_dev(const char *dev_name, struct ffs_data *ffs_data);static void ffs_release_dev (struct ffs_dev *ffs_dev);static int ffs_ready (struct ffs_data *ffs);static void ffs_closed (struct ffs_data *ffs); +static void ffs_reset_work (struct work_struct *work);/* Misc helper functions ****************************************************/
@@ -2206,6 +2207,7 @@ static struct ffs_data *ffs_data_new(const char *dev_name)init_waitqueue_head (&ffs->ev.waitq);init_waitqueue_head (&ffs->wait);init_completion (&ffs->ep0req_completion); +INIT_WORK (&ffs->reset_work, ffs_reset_work);/* XXX REVISIT need to update it in some places, or do we? */ ffs->ev.can_stall =1 ;
@@ -3753,7 +3755,6 @@ static int ffs_func_set_alt(struct usb_function *f,if (ffs->state ==FFS_DEACTIVATED ) { ffs->state =FFS_CLOSING ;spin_unlock_irqrestore (&ffs->eps_lock, flags); -INIT_WORK (&ffs->reset_work, ffs_reset_work);schedule_work (&ffs->reset_work);return -ENODEV ; }
@@ -3784,7 +3785,6 @@ static void ffs_func_disable(struct usb_function *f)if (ffs->state ==FFS_DEACTIVATED ) { ffs->state =FFS_CLOSING ;spin_unlock_irqrestore (&ffs->eps_lock, flags); -INIT_WORK (&ffs->reset_work, ffs_reset_work);schedule_work (&ffs->reset_work);return ; }
Signature · 1 line
2.53.0