2013-11-24 21:54:58 +07:00
|
|
|
/*
|
|
|
|
* kernfs.h - pseudo filesystem decoupled from vfs locking
|
|
|
|
*
|
|
|
|
* This file is released under the GPLv2.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#ifndef __LINUX_KERNFS_H
|
|
|
|
#define __LINUX_KERNFS_H
|
|
|
|
|
2013-11-24 05:21:49 +07:00
|
|
|
#include <linux/kernel.h>
|
2013-11-24 05:21:50 +07:00
|
|
|
#include <linux/err.h>
|
2013-11-29 02:54:20 +07:00
|
|
|
#include <linux/list.h>
|
|
|
|
#include <linux/mutex.h>
|
2013-11-29 02:54:41 +07:00
|
|
|
#include <linux/idr.h>
|
2013-11-29 02:54:29 +07:00
|
|
|
#include <linux/lockdep.h>
|
2013-11-30 05:18:32 +07:00
|
|
|
#include <linux/rbtree.h>
|
|
|
|
#include <linux/atomic.h>
|
2014-02-04 02:02:55 +07:00
|
|
|
#include <linux/wait.h>
|
2013-11-24 05:21:49 +07:00
|
|
|
|
2013-11-24 05:21:52 +07:00
|
|
|
struct file;
|
2014-01-17 21:57:49 +07:00
|
|
|
struct dentry;
|
2013-11-24 05:21:52 +07:00
|
|
|
struct iattr;
|
2013-11-29 02:54:20 +07:00
|
|
|
struct seq_file;
|
|
|
|
struct vm_area_struct;
|
2013-11-29 02:54:43 +07:00
|
|
|
struct super_block;
|
|
|
|
struct file_system_type;
|
2013-11-24 05:21:52 +07:00
|
|
|
|
2013-12-12 02:11:55 +07:00
|
|
|
struct kernfs_open_node;
|
|
|
|
struct kernfs_iattrs;
|
2013-11-30 05:18:32 +07:00
|
|
|
|
|
|
|
enum kernfs_node_type {
|
2013-12-12 02:11:56 +07:00
|
|
|
KERNFS_DIR = 0x0001,
|
|
|
|
KERNFS_FILE = 0x0002,
|
|
|
|
KERNFS_LINK = 0x0004,
|
2013-11-30 05:18:32 +07:00
|
|
|
};
|
|
|
|
|
2013-12-12 02:11:56 +07:00
|
|
|
#define KERNFS_TYPE_MASK 0x000f
|
|
|
|
#define KERNFS_FLAG_MASK ~KERNFS_TYPE_MASK
|
2013-11-30 05:18:32 +07:00
|
|
|
|
|
|
|
enum kernfs_node_flag {
|
2014-02-04 02:09:12 +07:00
|
|
|
KERNFS_ACTIVATED = 0x0010,
|
2013-12-12 02:11:56 +07:00
|
|
|
KERNFS_NS = 0x0020,
|
|
|
|
KERNFS_HAS_SEQ_SHOW = 0x0040,
|
|
|
|
KERNFS_HAS_MMAP = 0x0080,
|
|
|
|
KERNFS_LOCKDEP = 0x0100,
|
2013-12-12 04:02:57 +07:00
|
|
|
KERNFS_STATIC_NAME = 0x0200,
|
kernfs, sysfs, driver-core: implement kernfs_remove_self() and its wrappers
Sometimes it's necessary to implement a node which wants to delete
nodes including itself. This isn't straightforward because of kernfs
active reference. While a file operation is in progress, an active
reference is held and kernfs_remove() waits for all such references to
drain before completing. For a self-deleting node, this is a deadlock
as kernfs_remove() ends up waiting for an active reference that itself
is sitting on top of.
This currently is worked around in the sysfs layer using
sysfs_schedule_callback() which makes such removals asynchronous.
While it works, it's rather cumbersome and inherently breaks
synchronicity of the operation - the file operation which triggered
the operation may complete before the removal is finished (or even
started) and the removal may fail asynchronously. If a removal
operation is immmediately followed by another operation which expects
the specific name to be available (e.g. removal followed by rename
onto the same name), there's no way to make the latter operation
reliable.
The thing is there's no inherent reason for this to be asynchrnous.
All that's necessary to do this synchronous is a dedicated operation
which drops its own active ref and deactivates self. This patch
implements kernfs_remove_self() and its wrappers in sysfs and driver
core. kernfs_remove_self() is to be called from one of the file
operations, drops the active ref the task is holding, removes the self
node, and restores active ref to the dead node so that the ref is
balanced afterwards. __kernfs_remove() is updated so that it takes an
early exit if the target node is already fully removed so that the
active ref restored by kernfs_remove_self() after removal doesn't
confuse the deactivation path.
This makes implementing self-deleting nodes very easy. The normal
removal path doesn't even need to be changed to use
kernfs_remove_self() for the self-deleting node. The method can
invoke kernfs_remove_self() on itself before proceeding the normal
removal path. kernfs_remove() invoked on the node by the normal
deletion path will simply be ignored.
This will replace sysfs_schedule_callback(). A subtle feature of
sysfs_schedule_callback() is that it collapses multiple invocations -
even if multiple removals are triggered, the removal callback is run
only once. An equivalent effect can be achieved by testing the return
value of kernfs_remove_self() - only the one which gets %true return
value should proceed with actual deletion. All other instances of
kernfs_remove_self() will wait till the enclosing kernfs operation
which invoked the winning instance of kernfs_remove_self() finishes
and then return %false. This trivially makes all users of
kernfs_remove_self() automatically show correct synchronous behavior
even when there are multiple concurrent operations - all "echo 1 >
delete" instances will finish only after the whole operation is
completed by one of the instances.
Note that manipulation of active ref is implemented in separate public
functions - kernfs_[un]break_active_protection().
kernfs_remove_self() is the only user at the moment but this will be
used to cater to more complex cases.
v2: For !CONFIG_SYSFS, dummy version kernfs_remove_self() was missing
and sysfs_remove_file_self() had incorrect return type. Fix it.
Reported by kbuild test bot.
v3: kernfs_[un]break_active_protection() separated out from
kernfs_remove_self() and exposed as public API.
Signed-off-by: Tejun Heo <tj@kernel.org>
Cc: Alan Stern <stern@rowland.harvard.edu>
Cc: kbuild test robot <fengguang.wu@intel.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2014-02-04 02:03:01 +07:00
|
|
|
KERNFS_SUICIDAL = 0x0400,
|
|
|
|
KERNFS_SUICIDED = 0x0800,
|
2013-11-30 05:18:32 +07:00
|
|
|
};
|
|
|
|
|
2014-02-04 02:09:12 +07:00
|
|
|
/* @flags for kernfs_create_root() */
|
|
|
|
enum kernfs_root_flag {
|
|
|
|
KERNFS_ROOT_CREATE_DEACTIVATED = 0x0001,
|
|
|
|
};
|
|
|
|
|
2013-12-12 02:11:53 +07:00
|
|
|
/* type-specific structures for kernfs_node union members */
|
|
|
|
struct kernfs_elem_dir {
|
2013-11-30 05:18:32 +07:00
|
|
|
unsigned long subdirs;
|
2013-12-12 02:11:54 +07:00
|
|
|
/* children rbtree starts here and goes through kn->rb */
|
2013-11-30 05:18:32 +07:00
|
|
|
struct rb_root children;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The kernfs hierarchy this directory belongs to. This fits
|
2013-12-12 02:11:53 +07:00
|
|
|
* better directly in kernfs_node but is here to save space.
|
2013-11-30 05:18:32 +07:00
|
|
|
*/
|
|
|
|
struct kernfs_root *root;
|
|
|
|
};
|
|
|
|
|
2013-12-12 02:11:53 +07:00
|
|
|
struct kernfs_elem_symlink {
|
|
|
|
struct kernfs_node *target_kn;
|
2013-11-30 05:18:32 +07:00
|
|
|
};
|
|
|
|
|
2013-12-12 02:11:53 +07:00
|
|
|
struct kernfs_elem_attr {
|
2013-11-30 05:18:32 +07:00
|
|
|
const struct kernfs_ops *ops;
|
2013-12-12 02:11:55 +07:00
|
|
|
struct kernfs_open_node *open;
|
2013-11-30 05:18:32 +07:00
|
|
|
loff_t size;
|
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
2013-12-12 02:11:53 +07:00
|
|
|
* kernfs_node - the building block of kernfs hierarchy. Each and every
|
|
|
|
* kernfs node is represented by single kernfs_node. Most fields are
|
2013-11-30 05:18:32 +07:00
|
|
|
* private to kernfs and shouldn't be accessed directly by kernfs users.
|
|
|
|
*
|
2013-12-12 02:11:53 +07:00
|
|
|
* As long as s_count reference is held, the kernfs_node itself is
|
|
|
|
* accessible. Dereferencing elem or any other outer entity requires
|
|
|
|
* active reference.
|
2013-11-30 05:18:32 +07:00
|
|
|
*/
|
2013-12-12 02:11:53 +07:00
|
|
|
struct kernfs_node {
|
2013-12-12 02:11:54 +07:00
|
|
|
atomic_t count;
|
|
|
|
atomic_t active;
|
2013-11-30 05:18:32 +07:00
|
|
|
#ifdef CONFIG_DEBUG_LOCK_ALLOC
|
|
|
|
struct lockdep_map dep_map;
|
|
|
|
#endif
|
2014-02-08 01:32:07 +07:00
|
|
|
/*
|
|
|
|
* Use kernfs_get_parent() and kernfs_name/path() instead of
|
|
|
|
* accessing the following two fields directly. If the node is
|
|
|
|
* never moved to a different parent, it is safe to access the
|
|
|
|
* parent directly.
|
|
|
|
*/
|
2013-12-12 02:11:54 +07:00
|
|
|
struct kernfs_node *parent;
|
|
|
|
const char *name;
|
2013-11-30 05:18:32 +07:00
|
|
|
|
2013-12-12 02:11:54 +07:00
|
|
|
struct rb_node rb;
|
2013-11-30 05:18:32 +07:00
|
|
|
|
2013-12-12 02:11:54 +07:00
|
|
|
const void *ns; /* namespace tag */
|
2014-01-14 05:09:38 +07:00
|
|
|
unsigned int hash; /* ns + name hash */
|
2013-11-30 05:18:32 +07:00
|
|
|
union {
|
2013-12-12 02:11:54 +07:00
|
|
|
struct kernfs_elem_dir dir;
|
|
|
|
struct kernfs_elem_symlink symlink;
|
|
|
|
struct kernfs_elem_attr attr;
|
2013-11-30 05:18:32 +07:00
|
|
|
};
|
|
|
|
|
|
|
|
void *priv;
|
|
|
|
|
2013-12-12 02:11:54 +07:00
|
|
|
unsigned short flags;
|
|
|
|
umode_t mode;
|
|
|
|
unsigned int ino;
|
2013-12-12 02:11:55 +07:00
|
|
|
struct kernfs_iattrs *iattr;
|
2013-11-30 05:18:32 +07:00
|
|
|
};
|
2013-11-24 21:54:58 +07:00
|
|
|
|
2013-12-12 04:03:00 +07:00
|
|
|
/*
|
2014-02-04 02:09:09 +07:00
|
|
|
* kernfs_syscall_ops may be specified on kernfs_create_root() to support
|
|
|
|
* syscalls. These optional callbacks are invoked on the matching syscalls
|
|
|
|
* and can perform any kernfs operations which don't necessarily have to be
|
|
|
|
* the exact operation requested. An active reference is held for each
|
|
|
|
* kernfs_node parameter.
|
2013-12-12 04:03:00 +07:00
|
|
|
*/
|
2014-02-04 02:09:09 +07:00
|
|
|
struct kernfs_syscall_ops {
|
2014-02-04 02:09:10 +07:00
|
|
|
int (*remount_fs)(struct kernfs_root *root, int *flags, char *data);
|
|
|
|
int (*show_options)(struct seq_file *sf, struct kernfs_root *root);
|
|
|
|
|
2013-12-12 04:03:00 +07:00
|
|
|
int (*mkdir)(struct kernfs_node *parent, const char *name,
|
|
|
|
umode_t mode);
|
|
|
|
int (*rmdir)(struct kernfs_node *kn);
|
|
|
|
int (*rename)(struct kernfs_node *kn, struct kernfs_node *new_parent,
|
|
|
|
const char *new_name);
|
|
|
|
};
|
|
|
|
|
2013-11-29 02:54:40 +07:00
|
|
|
struct kernfs_root {
|
|
|
|
/* published fields */
|
2013-12-12 02:11:53 +07:00
|
|
|
struct kernfs_node *kn;
|
2014-02-04 02:09:12 +07:00
|
|
|
unsigned int flags; /* KERNFS_ROOT_* flags */
|
2013-11-29 02:54:41 +07:00
|
|
|
|
|
|
|
/* private fields, do not use outside kernfs proper */
|
|
|
|
struct ida ino_ida;
|
2014-02-04 02:09:09 +07:00
|
|
|
struct kernfs_syscall_ops *syscall_ops;
|
2014-02-04 02:02:55 +07:00
|
|
|
wait_queue_head_t deactivate_waitq;
|
2013-11-29 02:54:40 +07:00
|
|
|
};
|
|
|
|
|
2013-12-12 02:11:55 +07:00
|
|
|
struct kernfs_open_file {
|
2013-11-29 02:54:20 +07:00
|
|
|
/* published fields */
|
2013-12-12 02:11:53 +07:00
|
|
|
struct kernfs_node *kn;
|
2013-11-29 02:54:20 +07:00
|
|
|
struct file *file;
|
2014-02-04 02:09:14 +07:00
|
|
|
void *priv;
|
2013-11-29 02:54:20 +07:00
|
|
|
|
|
|
|
/* private fields, do not use outside kernfs proper */
|
|
|
|
struct mutex mutex;
|
|
|
|
int event;
|
|
|
|
struct list_head list;
|
|
|
|
|
2014-03-05 03:38:46 +07:00
|
|
|
size_t atomic_write_len;
|
2013-11-29 02:54:20 +07:00
|
|
|
bool mmapped;
|
|
|
|
const struct vm_operations_struct *vm_ops;
|
|
|
|
};
|
|
|
|
|
2013-11-29 02:54:21 +07:00
|
|
|
struct kernfs_ops {
|
|
|
|
/*
|
|
|
|
* Read is handled by either seq_file or raw_read().
|
|
|
|
*
|
2013-11-29 02:54:26 +07:00
|
|
|
* If seq_show() is present, seq_file path is active. Other seq
|
|
|
|
* operations are optional and if not implemented, the behavior is
|
|
|
|
* equivalent to single_open(). @sf->private points to the
|
2013-12-12 02:11:55 +07:00
|
|
|
* associated kernfs_open_file.
|
2013-11-29 02:54:21 +07:00
|
|
|
*
|
|
|
|
* read() is bounced through kernel buffer and a read larger than
|
|
|
|
* PAGE_SIZE results in partial operation of PAGE_SIZE.
|
|
|
|
*/
|
|
|
|
int (*seq_show)(struct seq_file *sf, void *v);
|
2013-11-29 02:54:26 +07:00
|
|
|
|
|
|
|
void *(*seq_start)(struct seq_file *sf, loff_t *ppos);
|
|
|
|
void *(*seq_next)(struct seq_file *sf, void *v, loff_t *ppos);
|
|
|
|
void (*seq_stop)(struct seq_file *sf, void *v);
|
2013-11-29 02:54:21 +07:00
|
|
|
|
2013-12-12 02:11:55 +07:00
|
|
|
ssize_t (*read)(struct kernfs_open_file *of, char *buf, size_t bytes,
|
2013-11-29 02:54:21 +07:00
|
|
|
loff_t off);
|
|
|
|
|
|
|
|
/*
|
2014-02-04 02:09:13 +07:00
|
|
|
* write() is bounced through kernel buffer. If atomic_write_len
|
|
|
|
* is not set, a write larger than PAGE_SIZE results in partial
|
|
|
|
* operations of PAGE_SIZE chunks. If atomic_write_len is set,
|
|
|
|
* writes upto the specified size are executed atomically but
|
|
|
|
* larger ones are rejected with -E2BIG.
|
2013-11-29 02:54:21 +07:00
|
|
|
*/
|
2014-02-04 02:09:13 +07:00
|
|
|
size_t atomic_write_len;
|
2013-12-12 02:11:55 +07:00
|
|
|
ssize_t (*write)(struct kernfs_open_file *of, char *buf, size_t bytes,
|
2013-11-29 02:54:21 +07:00
|
|
|
loff_t off);
|
|
|
|
|
2013-12-12 02:11:55 +07:00
|
|
|
int (*mmap)(struct kernfs_open_file *of, struct vm_area_struct *vma);
|
2013-11-29 02:54:29 +07:00
|
|
|
|
|
|
|
#ifdef CONFIG_DEBUG_LOCK_ALLOC
|
|
|
|
struct lock_class_key lockdep_key;
|
|
|
|
#endif
|
2013-11-29 02:54:21 +07:00
|
|
|
};
|
|
|
|
|
2014-02-04 02:09:17 +07:00
|
|
|
#ifdef CONFIG_KERNFS
|
2013-11-24 05:21:49 +07:00
|
|
|
|
2013-12-12 02:11:56 +07:00
|
|
|
static inline enum kernfs_node_type kernfs_type(struct kernfs_node *kn)
|
2013-11-30 05:18:32 +07:00
|
|
|
{
|
2013-12-12 02:11:56 +07:00
|
|
|
return kn->flags & KERNFS_TYPE_MASK;
|
2013-11-30 05:18:32 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* kernfs_enable_ns - enable namespace under a directory
|
2013-12-12 02:11:53 +07:00
|
|
|
* @kn: directory of interest, should be empty
|
2013-11-30 05:18:32 +07:00
|
|
|
*
|
2013-12-12 02:11:53 +07:00
|
|
|
* This is to be called right after @kn is created to enable namespace
|
|
|
|
* under it. All children of @kn must have non-NULL namespace tags and
|
2013-11-30 05:18:32 +07:00
|
|
|
* only the ones which match the super_block's tag will be visible.
|
|
|
|
*/
|
2013-12-12 02:11:53 +07:00
|
|
|
static inline void kernfs_enable_ns(struct kernfs_node *kn)
|
2013-11-30 05:18:32 +07:00
|
|
|
{
|
2013-12-12 02:11:56 +07:00
|
|
|
WARN_ON_ONCE(kernfs_type(kn) != KERNFS_DIR);
|
2013-12-12 02:11:54 +07:00
|
|
|
WARN_ON_ONCE(!RB_EMPTY_ROOT(&kn->dir.children));
|
2013-12-12 02:11:56 +07:00
|
|
|
kn->flags |= KERNFS_NS;
|
2013-11-30 05:18:32 +07:00
|
|
|
}
|
|
|
|
|
2013-11-30 05:19:09 +07:00
|
|
|
/**
|
|
|
|
* kernfs_ns_enabled - test whether namespace is enabled
|
2013-12-12 02:11:53 +07:00
|
|
|
* @kn: the node to test
|
2013-11-30 05:19:09 +07:00
|
|
|
*
|
|
|
|
* Test whether namespace filtering is enabled for the children of @ns.
|
|
|
|
*/
|
2013-12-12 02:11:53 +07:00
|
|
|
static inline bool kernfs_ns_enabled(struct kernfs_node *kn)
|
2013-11-30 05:19:09 +07:00
|
|
|
{
|
2013-12-12 02:11:56 +07:00
|
|
|
return kn->flags & KERNFS_NS;
|
2013-11-30 05:19:09 +07:00
|
|
|
}
|
|
|
|
|
2014-02-08 01:32:07 +07:00
|
|
|
int kernfs_name(struct kernfs_node *kn, char *buf, size_t buflen);
|
|
|
|
char * __must_check kernfs_path(struct kernfs_node *kn, char *buf,
|
|
|
|
size_t buflen);
|
|
|
|
void pr_cont_kernfs_name(struct kernfs_node *kn);
|
|
|
|
void pr_cont_kernfs_path(struct kernfs_node *kn);
|
|
|
|
struct kernfs_node *kernfs_get_parent(struct kernfs_node *kn);
|
2013-12-12 02:11:53 +07:00
|
|
|
struct kernfs_node *kernfs_find_and_get_ns(struct kernfs_node *parent,
|
|
|
|
const char *name, const void *ns);
|
|
|
|
void kernfs_get(struct kernfs_node *kn);
|
|
|
|
void kernfs_put(struct kernfs_node *kn);
|
2013-11-29 02:54:30 +07:00
|
|
|
|
2014-02-04 02:09:15 +07:00
|
|
|
struct kernfs_node *kernfs_node_from_dentry(struct dentry *dentry);
|
|
|
|
struct kernfs_root *kernfs_root_from_sb(struct super_block *sb);
|
|
|
|
|
2014-02-04 02:09:09 +07:00
|
|
|
struct kernfs_root *kernfs_create_root(struct kernfs_syscall_ops *scops,
|
2014-02-04 02:09:12 +07:00
|
|
|
unsigned int flags, void *priv);
|
2013-11-29 02:54:40 +07:00
|
|
|
void kernfs_destroy_root(struct kernfs_root *root);
|
|
|
|
|
2013-12-12 02:11:53 +07:00
|
|
|
struct kernfs_node *kernfs_create_dir_ns(struct kernfs_node *parent,
|
2013-12-12 04:02:55 +07:00
|
|
|
const char *name, umode_t mode,
|
|
|
|
void *priv, const void *ns);
|
2013-12-12 04:02:57 +07:00
|
|
|
struct kernfs_node *__kernfs_create_file(struct kernfs_node *parent,
|
|
|
|
const char *name,
|
|
|
|
umode_t mode, loff_t size,
|
|
|
|
const struct kernfs_ops *ops,
|
|
|
|
void *priv, const void *ns,
|
|
|
|
bool name_is_static,
|
|
|
|
struct lock_class_key *key);
|
2013-12-12 02:11:53 +07:00
|
|
|
struct kernfs_node *kernfs_create_link(struct kernfs_node *parent,
|
|
|
|
const char *name,
|
|
|
|
struct kernfs_node *target);
|
2014-02-04 02:09:12 +07:00
|
|
|
void kernfs_activate(struct kernfs_node *kn);
|
2013-12-12 02:11:53 +07:00
|
|
|
void kernfs_remove(struct kernfs_node *kn);
|
kernfs, sysfs, driver-core: implement kernfs_remove_self() and its wrappers
Sometimes it's necessary to implement a node which wants to delete
nodes including itself. This isn't straightforward because of kernfs
active reference. While a file operation is in progress, an active
reference is held and kernfs_remove() waits for all such references to
drain before completing. For a self-deleting node, this is a deadlock
as kernfs_remove() ends up waiting for an active reference that itself
is sitting on top of.
This currently is worked around in the sysfs layer using
sysfs_schedule_callback() which makes such removals asynchronous.
While it works, it's rather cumbersome and inherently breaks
synchronicity of the operation - the file operation which triggered
the operation may complete before the removal is finished (or even
started) and the removal may fail asynchronously. If a removal
operation is immmediately followed by another operation which expects
the specific name to be available (e.g. removal followed by rename
onto the same name), there's no way to make the latter operation
reliable.
The thing is there's no inherent reason for this to be asynchrnous.
All that's necessary to do this synchronous is a dedicated operation
which drops its own active ref and deactivates self. This patch
implements kernfs_remove_self() and its wrappers in sysfs and driver
core. kernfs_remove_self() is to be called from one of the file
operations, drops the active ref the task is holding, removes the self
node, and restores active ref to the dead node so that the ref is
balanced afterwards. __kernfs_remove() is updated so that it takes an
early exit if the target node is already fully removed so that the
active ref restored by kernfs_remove_self() after removal doesn't
confuse the deactivation path.
This makes implementing self-deleting nodes very easy. The normal
removal path doesn't even need to be changed to use
kernfs_remove_self() for the self-deleting node. The method can
invoke kernfs_remove_self() on itself before proceeding the normal
removal path. kernfs_remove() invoked on the node by the normal
deletion path will simply be ignored.
This will replace sysfs_schedule_callback(). A subtle feature of
sysfs_schedule_callback() is that it collapses multiple invocations -
even if multiple removals are triggered, the removal callback is run
only once. An equivalent effect can be achieved by testing the return
value of kernfs_remove_self() - only the one which gets %true return
value should proceed with actual deletion. All other instances of
kernfs_remove_self() will wait till the enclosing kernfs operation
which invoked the winning instance of kernfs_remove_self() finishes
and then return %false. This trivially makes all users of
kernfs_remove_self() automatically show correct synchronous behavior
even when there are multiple concurrent operations - all "echo 1 >
delete" instances will finish only after the whole operation is
completed by one of the instances.
Note that manipulation of active ref is implemented in separate public
functions - kernfs_[un]break_active_protection().
kernfs_remove_self() is the only user at the moment but this will be
used to cater to more complex cases.
v2: For !CONFIG_SYSFS, dummy version kernfs_remove_self() was missing
and sysfs_remove_file_self() had incorrect return type. Fix it.
Reported by kbuild test bot.
v3: kernfs_[un]break_active_protection() separated out from
kernfs_remove_self() and exposed as public API.
Signed-off-by: Tejun Heo <tj@kernel.org>
Cc: Alan Stern <stern@rowland.harvard.edu>
Cc: kbuild test robot <fengguang.wu@intel.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2014-02-04 02:03:01 +07:00
|
|
|
void kernfs_break_active_protection(struct kernfs_node *kn);
|
|
|
|
void kernfs_unbreak_active_protection(struct kernfs_node *kn);
|
|
|
|
bool kernfs_remove_self(struct kernfs_node *kn);
|
2013-12-12 02:11:53 +07:00
|
|
|
int kernfs_remove_by_name_ns(struct kernfs_node *parent, const char *name,
|
2013-11-24 05:21:49 +07:00
|
|
|
const void *ns);
|
2013-12-12 02:11:53 +07:00
|
|
|
int kernfs_rename_ns(struct kernfs_node *kn, struct kernfs_node *new_parent,
|
2013-11-24 05:21:51 +07:00
|
|
|
const char *new_name, const void *new_ns);
|
2013-12-12 02:11:53 +07:00
|
|
|
int kernfs_setattr(struct kernfs_node *kn, const struct iattr *iattr);
|
|
|
|
void kernfs_notify(struct kernfs_node *kn);
|
2013-11-24 05:21:49 +07:00
|
|
|
|
2013-11-29 02:54:43 +07:00
|
|
|
const void *kernfs_super_ns(struct super_block *sb);
|
|
|
|
struct dentry *kernfs_mount_ns(struct file_system_type *fs_type, int flags,
|
2014-02-25 18:28:44 +07:00
|
|
|
struct kernfs_root *root, bool *new_sb_created,
|
|
|
|
const void *ns);
|
2013-11-29 02:54:43 +07:00
|
|
|
void kernfs_kill_sb(struct super_block *sb);
|
|
|
|
|
|
|
|
void kernfs_init(void);
|
|
|
|
|
2014-02-04 02:09:17 +07:00
|
|
|
#else /* CONFIG_KERNFS */
|
2013-11-24 05:21:49 +07:00
|
|
|
|
2013-12-12 02:11:56 +07:00
|
|
|
static inline enum kernfs_node_type kernfs_type(struct kernfs_node *kn)
|
2013-11-30 05:18:32 +07:00
|
|
|
{ return 0; } /* whatever */
|
|
|
|
|
2013-12-12 02:11:53 +07:00
|
|
|
static inline void kernfs_enable_ns(struct kernfs_node *kn) { }
|
2013-11-30 05:18:32 +07:00
|
|
|
|
2013-12-12 02:11:53 +07:00
|
|
|
static inline bool kernfs_ns_enabled(struct kernfs_node *kn)
|
2013-11-30 05:19:09 +07:00
|
|
|
{ return false; }
|
|
|
|
|
2014-02-08 01:32:07 +07:00
|
|
|
static inline int kernfs_name(struct kernfs_node *kn, char *buf, size_t buflen)
|
|
|
|
{ return -ENOSYS; }
|
|
|
|
|
|
|
|
static inline char * __must_check kernfs_path(struct kernfs_node *kn, char *buf,
|
|
|
|
size_t buflen)
|
|
|
|
{ return NULL; }
|
|
|
|
|
|
|
|
static inline void pr_cont_kernfs_name(struct kernfs_node *kn) { }
|
|
|
|
static inline void pr_cont_kernfs_path(struct kernfs_node *kn) { }
|
|
|
|
|
|
|
|
static inline struct kernfs_node *kernfs_get_parent(struct kernfs_node *kn)
|
|
|
|
{ return NULL; }
|
|
|
|
|
2013-12-12 02:11:53 +07:00
|
|
|
static inline struct kernfs_node *
|
|
|
|
kernfs_find_and_get_ns(struct kernfs_node *parent, const char *name,
|
2013-11-29 02:54:30 +07:00
|
|
|
const void *ns)
|
|
|
|
{ return NULL; }
|
|
|
|
|
2013-12-12 02:11:53 +07:00
|
|
|
static inline void kernfs_get(struct kernfs_node *kn) { }
|
|
|
|
static inline void kernfs_put(struct kernfs_node *kn) { }
|
2013-11-29 02:54:30 +07:00
|
|
|
|
2014-02-04 02:09:15 +07:00
|
|
|
static inline struct kernfs_node *kernfs_node_from_dentry(struct dentry *dentry)
|
|
|
|
{ return NULL; }
|
|
|
|
|
|
|
|
static inline struct kernfs_root *kernfs_root_from_sb(struct super_block *sb)
|
|
|
|
{ return NULL; }
|
|
|
|
|
2013-12-12 04:03:00 +07:00
|
|
|
static inline struct kernfs_root *
|
2014-02-04 02:09:12 +07:00
|
|
|
kernfs_create_root(struct kernfs_syscall_ops *scops, unsigned int flags,
|
|
|
|
void *priv)
|
2013-11-29 02:54:40 +07:00
|
|
|
{ return ERR_PTR(-ENOSYS); }
|
|
|
|
|
|
|
|
static inline void kernfs_destroy_root(struct kernfs_root *root) { }
|
|
|
|
|
2013-12-12 02:11:53 +07:00
|
|
|
static inline struct kernfs_node *
|
2013-12-12 04:02:55 +07:00
|
|
|
kernfs_create_dir_ns(struct kernfs_node *parent, const char *name,
|
|
|
|
umode_t mode, void *priv, const void *ns)
|
2013-11-29 02:54:15 +07:00
|
|
|
{ return ERR_PTR(-ENOSYS); }
|
|
|
|
|
2013-12-12 02:11:53 +07:00
|
|
|
static inline struct kernfs_node *
|
2013-12-12 04:02:57 +07:00
|
|
|
__kernfs_create_file(struct kernfs_node *parent, const char *name,
|
|
|
|
umode_t mode, loff_t size, const struct kernfs_ops *ops,
|
|
|
|
void *priv, const void *ns, bool name_is_static,
|
|
|
|
struct lock_class_key *key)
|
2013-11-29 02:54:24 +07:00
|
|
|
{ return ERR_PTR(-ENOSYS); }
|
|
|
|
|
2013-12-12 02:11:53 +07:00
|
|
|
static inline struct kernfs_node *
|
|
|
|
kernfs_create_link(struct kernfs_node *parent, const char *name,
|
|
|
|
struct kernfs_node *target)
|
2013-11-24 05:21:50 +07:00
|
|
|
{ return ERR_PTR(-ENOSYS); }
|
|
|
|
|
2014-02-04 02:09:12 +07:00
|
|
|
static inline void kernfs_activate(struct kernfs_node *kn) { }
|
|
|
|
|
2013-12-12 02:11:53 +07:00
|
|
|
static inline void kernfs_remove(struct kernfs_node *kn) { }
|
2013-11-24 05:21:49 +07:00
|
|
|
|
kernfs, sysfs, driver-core: implement kernfs_remove_self() and its wrappers
Sometimes it's necessary to implement a node which wants to delete
nodes including itself. This isn't straightforward because of kernfs
active reference. While a file operation is in progress, an active
reference is held and kernfs_remove() waits for all such references to
drain before completing. For a self-deleting node, this is a deadlock
as kernfs_remove() ends up waiting for an active reference that itself
is sitting on top of.
This currently is worked around in the sysfs layer using
sysfs_schedule_callback() which makes such removals asynchronous.
While it works, it's rather cumbersome and inherently breaks
synchronicity of the operation - the file operation which triggered
the operation may complete before the removal is finished (or even
started) and the removal may fail asynchronously. If a removal
operation is immmediately followed by another operation which expects
the specific name to be available (e.g. removal followed by rename
onto the same name), there's no way to make the latter operation
reliable.
The thing is there's no inherent reason for this to be asynchrnous.
All that's necessary to do this synchronous is a dedicated operation
which drops its own active ref and deactivates self. This patch
implements kernfs_remove_self() and its wrappers in sysfs and driver
core. kernfs_remove_self() is to be called from one of the file
operations, drops the active ref the task is holding, removes the self
node, and restores active ref to the dead node so that the ref is
balanced afterwards. __kernfs_remove() is updated so that it takes an
early exit if the target node is already fully removed so that the
active ref restored by kernfs_remove_self() after removal doesn't
confuse the deactivation path.
This makes implementing self-deleting nodes very easy. The normal
removal path doesn't even need to be changed to use
kernfs_remove_self() for the self-deleting node. The method can
invoke kernfs_remove_self() on itself before proceeding the normal
removal path. kernfs_remove() invoked on the node by the normal
deletion path will simply be ignored.
This will replace sysfs_schedule_callback(). A subtle feature of
sysfs_schedule_callback() is that it collapses multiple invocations -
even if multiple removals are triggered, the removal callback is run
only once. An equivalent effect can be achieved by testing the return
value of kernfs_remove_self() - only the one which gets %true return
value should proceed with actual deletion. All other instances of
kernfs_remove_self() will wait till the enclosing kernfs operation
which invoked the winning instance of kernfs_remove_self() finishes
and then return %false. This trivially makes all users of
kernfs_remove_self() automatically show correct synchronous behavior
even when there are multiple concurrent operations - all "echo 1 >
delete" instances will finish only after the whole operation is
completed by one of the instances.
Note that manipulation of active ref is implemented in separate public
functions - kernfs_[un]break_active_protection().
kernfs_remove_self() is the only user at the moment but this will be
used to cater to more complex cases.
v2: For !CONFIG_SYSFS, dummy version kernfs_remove_self() was missing
and sysfs_remove_file_self() had incorrect return type. Fix it.
Reported by kbuild test bot.
v3: kernfs_[un]break_active_protection() separated out from
kernfs_remove_self() and exposed as public API.
Signed-off-by: Tejun Heo <tj@kernel.org>
Cc: Alan Stern <stern@rowland.harvard.edu>
Cc: kbuild test robot <fengguang.wu@intel.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2014-02-04 02:03:01 +07:00
|
|
|
static inline bool kernfs_remove_self(struct kernfs_node *kn)
|
|
|
|
{ return false; }
|
|
|
|
|
2013-12-12 02:11:53 +07:00
|
|
|
static inline int kernfs_remove_by_name_ns(struct kernfs_node *kn,
|
2013-11-24 05:21:49 +07:00
|
|
|
const char *name, const void *ns)
|
|
|
|
{ return -ENOSYS; }
|
|
|
|
|
2013-12-12 02:11:53 +07:00
|
|
|
static inline int kernfs_rename_ns(struct kernfs_node *kn,
|
|
|
|
struct kernfs_node *new_parent,
|
2013-11-24 05:21:51 +07:00
|
|
|
const char *new_name, const void *new_ns)
|
|
|
|
{ return -ENOSYS; }
|
|
|
|
|
2013-12-12 02:11:53 +07:00
|
|
|
static inline int kernfs_setattr(struct kernfs_node *kn,
|
2013-11-24 05:21:52 +07:00
|
|
|
const struct iattr *iattr)
|
|
|
|
{ return -ENOSYS; }
|
|
|
|
|
2013-12-12 02:11:53 +07:00
|
|
|
static inline void kernfs_notify(struct kernfs_node *kn) { }
|
2013-11-29 02:54:27 +07:00
|
|
|
|
2013-11-29 02:54:43 +07:00
|
|
|
static inline const void *kernfs_super_ns(struct super_block *sb)
|
|
|
|
{ return NULL; }
|
|
|
|
|
|
|
|
static inline struct dentry *
|
|
|
|
kernfs_mount_ns(struct file_system_type *fs_type, int flags,
|
2014-02-25 18:28:44 +07:00
|
|
|
struct kernfs_root *root, bool *new_sb_created, const void *ns)
|
2013-11-29 02:54:43 +07:00
|
|
|
{ return ERR_PTR(-ENOSYS); }
|
|
|
|
|
|
|
|
static inline void kernfs_kill_sb(struct super_block *sb) { }
|
|
|
|
|
|
|
|
static inline void kernfs_init(void) { }
|
|
|
|
|
2014-02-04 02:09:17 +07:00
|
|
|
#endif /* CONFIG_KERNFS */
|
2013-11-24 05:21:49 +07:00
|
|
|
|
2013-12-12 02:11:53 +07:00
|
|
|
static inline struct kernfs_node *
|
|
|
|
kernfs_find_and_get(struct kernfs_node *kn, const char *name)
|
2013-11-29 02:54:30 +07:00
|
|
|
{
|
2013-12-12 02:11:53 +07:00
|
|
|
return kernfs_find_and_get_ns(kn, name, NULL);
|
2013-11-29 02:54:30 +07:00
|
|
|
}
|
|
|
|
|
2013-12-12 02:11:53 +07:00
|
|
|
static inline struct kernfs_node *
|
2013-12-12 04:02:55 +07:00
|
|
|
kernfs_create_dir(struct kernfs_node *parent, const char *name, umode_t mode,
|
|
|
|
void *priv)
|
2013-11-29 02:54:15 +07:00
|
|
|
{
|
2013-12-12 04:02:55 +07:00
|
|
|
return kernfs_create_dir_ns(parent, name, mode, priv, NULL);
|
2013-11-29 02:54:15 +07:00
|
|
|
}
|
|
|
|
|
2013-12-12 02:11:53 +07:00
|
|
|
static inline struct kernfs_node *
|
|
|
|
kernfs_create_file_ns(struct kernfs_node *parent, const char *name,
|
2013-11-29 02:54:29 +07:00
|
|
|
umode_t mode, loff_t size, const struct kernfs_ops *ops,
|
|
|
|
void *priv, const void *ns)
|
|
|
|
{
|
|
|
|
struct lock_class_key *key = NULL;
|
|
|
|
|
|
|
|
#ifdef CONFIG_DEBUG_LOCK_ALLOC
|
|
|
|
key = (struct lock_class_key *)&ops->lockdep_key;
|
|
|
|
#endif
|
2013-12-12 04:02:57 +07:00
|
|
|
return __kernfs_create_file(parent, name, mode, size, ops, priv, ns,
|
|
|
|
false, key);
|
2013-11-29 02:54:29 +07:00
|
|
|
}
|
|
|
|
|
2013-12-12 02:11:53 +07:00
|
|
|
static inline struct kernfs_node *
|
|
|
|
kernfs_create_file(struct kernfs_node *parent, const char *name, umode_t mode,
|
2013-11-29 02:54:24 +07:00
|
|
|
loff_t size, const struct kernfs_ops *ops, void *priv)
|
|
|
|
{
|
|
|
|
return kernfs_create_file_ns(parent, name, mode, size, ops, priv, NULL);
|
|
|
|
}
|
|
|
|
|
2013-12-12 02:11:53 +07:00
|
|
|
static inline int kernfs_remove_by_name(struct kernfs_node *parent,
|
2013-11-24 05:21:49 +07:00
|
|
|
const char *name)
|
|
|
|
{
|
|
|
|
return kernfs_remove_by_name_ns(parent, name, NULL);
|
|
|
|
}
|
|
|
|
|
2014-02-04 02:09:15 +07:00
|
|
|
static inline int kernfs_rename(struct kernfs_node *kn,
|
|
|
|
struct kernfs_node *new_parent,
|
|
|
|
const char *new_name)
|
|
|
|
{
|
|
|
|
return kernfs_rename_ns(kn, new_parent, new_name, NULL);
|
|
|
|
}
|
|
|
|
|
2013-11-29 02:54:43 +07:00
|
|
|
static inline struct dentry *
|
|
|
|
kernfs_mount(struct file_system_type *fs_type, int flags,
|
2014-02-25 18:28:44 +07:00
|
|
|
struct kernfs_root *root, bool *new_sb_created)
|
2013-11-29 02:54:43 +07:00
|
|
|
{
|
2014-02-25 18:28:44 +07:00
|
|
|
return kernfs_mount_ns(fs_type, flags, root, new_sb_created, NULL);
|
2013-11-29 02:54:43 +07:00
|
|
|
}
|
|
|
|
|
2013-11-24 21:54:58 +07:00
|
|
|
#endif /* __LINUX_KERNFS_H */
|