Commit 324a56e1 authored by Tejun Heo's avatar Tejun Heo Committed by Greg Kroah-Hartman

kernfs: s/sysfs_dirent/kernfs_node/ and rename its friends accordingly

kernfs has just been separated out from sysfs and we're already in
full conflict mode.  Nothing can make the situation any worse.  Let's
take the chance to name things properly.

This patch performs the following renames.

* s/sysfs_elem_dir/kernfs_elem_dir/
* s/sysfs_elem_symlink/kernfs_elem_symlink/
* s/sysfs_elem_attr/kernfs_elem_file/
* s/sysfs_dirent/kernfs_node/
* s/sd/kn/ in kernfs proper
* s/parent_sd/parent/
* s/target_sd/target/
* s/dir_sd/parent/
* s/to_sysfs_dirent()/rb_to_kn()/
* misc renames of local vars when they conflict with the above

Because md, mic and gpio dig into sysfs details, this patch ends up
modifying them.  All are sysfs_dirent renames and trivial.  While we
can avoid these by introducing a dummy wrapping struct sysfs_dirent
around kernfs_node, given the limited usage outside kernfs and sysfs
proper, I don't think such workaround is called for.

This patch is strictly rename only and doesn't introduce any
functional difference.

- mic / gpio renames were missing.  Spotted by kbuild test robot.
Signed-off-by: default avatarTejun Heo <tj@kernel.org>
Cc: Neil Brown <neilb@suse.de>
Cc: Linus Walleij <linus.walleij@linaro.org>
Cc: Ashutosh Dixit <ashutosh.dixit@intel.com>
Cc: kbuild test robot <fengguang.wu@intel.com>
Signed-off-by: default avatarGreg Kroah-Hartman <gregkh@linuxfoundation.org>
parent a8b1c019
......@@ -393,7 +393,7 @@ static const DEVICE_ATTR(value, 0644,
static irqreturn_t gpio_sysfs_irq(int irq, void *priv)
{
struct sysfs_dirent *value_sd = priv;
struct kernfs_node *value_sd = priv;
sysfs_notify_dirent(value_sd);
return IRQ_HANDLED;
......@@ -402,7 +402,7 @@ static irqreturn_t gpio_sysfs_irq(int irq, void *priv)
static int gpio_setup_irq(struct gpio_desc *desc, struct device *dev,
unsigned long gpio_flags)
{
struct sysfs_dirent *value_sd;
struct kernfs_node *value_sd;
unsigned long irq_flags;
int ret, irq, id;
......
......@@ -1635,7 +1635,7 @@ int bitmap_create(struct mddev *mddev)
sector_t blocks = mddev->resync_max_sectors;
struct file *file = mddev->bitmap_info.file;
int err;
struct sysfs_dirent *bm = NULL;
struct kernfs_node *bm = NULL;
BUILD_BUG_ON(sizeof(bitmap_super_t) != 256);
......
......@@ -225,7 +225,7 @@ struct bitmap {
wait_queue_head_t overflow_wait;
wait_queue_head_t behind_wait;
struct sysfs_dirent *sysfs_can_clear;
struct kernfs_node *sysfs_can_clear;
};
/* the bitmap API */
......
......@@ -106,7 +106,7 @@ struct md_rdev {
*/
struct work_struct del_work; /* used for delayed sysfs removal */
struct sysfs_dirent *sysfs_state; /* handle for 'state'
struct kernfs_node *sysfs_state; /* handle for 'state'
* sysfs entry */
struct badblocks {
......@@ -376,10 +376,10 @@ struct mddev {
sector_t resync_max; /* resync should pause
* when it gets here */
struct sysfs_dirent *sysfs_state; /* handle for 'array_state'
struct kernfs_node *sysfs_state; /* handle for 'array_state'
* file in sysfs.
*/
struct sysfs_dirent *sysfs_action; /* handle for 'sync_action' */
struct kernfs_node *sysfs_action; /* handle for 'sync_action' */
struct work_struct del_work; /* used for delayed sysfs removal */
......@@ -498,13 +498,13 @@ struct md_sysfs_entry {
};
extern struct attribute_group md_bitmap_group;
static inline struct sysfs_dirent *sysfs_get_dirent_safe(struct sysfs_dirent *sd, char *name)
static inline struct kernfs_node *sysfs_get_dirent_safe(struct kernfs_node *sd, char *name)
{
if (sd)
return sysfs_get_dirent(sd, name);
return sd;
}
static inline void sysfs_notify_dirent_safe(struct sysfs_dirent *sd)
static inline void sysfs_notify_dirent_safe(struct kernfs_node *sd)
{
if (sd)
sysfs_notify_dirent(sd);
......
......@@ -112,7 +112,7 @@ struct mic_device {
struct work_struct shutdown_work;
u8 state;
u8 shutdown_status;
struct sysfs_dirent *state_sysfs;
struct kernfs_node *state_sysfs;
struct completion reset_wait;
void *log_buf_addr;
int *log_buf_len;
......
This diff is collapsed.
This diff is collapsed.
......@@ -46,36 +46,36 @@ void __init sysfs_inode_init(void)
panic("failed to init sysfs_backing_dev_info");
}
static struct sysfs_inode_attrs *sysfs_inode_attrs(struct sysfs_dirent *sd)
static struct sysfs_inode_attrs *sysfs_inode_attrs(struct kernfs_node *kn)
{
struct iattr *iattrs;
if (sd->s_iattr)
return sd->s_iattr;
if (kn->s_iattr)
return kn->s_iattr;
sd->s_iattr = kzalloc(sizeof(struct sysfs_inode_attrs), GFP_KERNEL);
if (!sd->s_iattr)
kn->s_iattr = kzalloc(sizeof(struct sysfs_inode_attrs), GFP_KERNEL);
if (!kn->s_iattr)
return NULL;
iattrs = &sd->s_iattr->ia_iattr;
iattrs = &kn->s_iattr->ia_iattr;
/* assign default attributes */
iattrs->ia_mode = sd->s_mode;
iattrs->ia_mode = kn->s_mode;
iattrs->ia_uid = GLOBAL_ROOT_UID;
iattrs->ia_gid = GLOBAL_ROOT_GID;
iattrs->ia_atime = iattrs->ia_mtime = iattrs->ia_ctime = CURRENT_TIME;
simple_xattrs_init(&sd->s_iattr->xattrs);
simple_xattrs_init(&kn->s_iattr->xattrs);
return sd->s_iattr;
return kn->s_iattr;
}
static int __kernfs_setattr(struct sysfs_dirent *sd, const struct iattr *iattr)
static int __kernfs_setattr(struct kernfs_node *kn, const struct iattr *iattr)
{
struct sysfs_inode_attrs *attrs;
struct iattr *iattrs;
unsigned int ia_valid = iattr->ia_valid;
attrs = sysfs_inode_attrs(sd);
attrs = sysfs_inode_attrs(kn);
if (!attrs)
return -ENOMEM;
......@@ -93,24 +93,24 @@ static int __kernfs_setattr(struct sysfs_dirent *sd, const struct iattr *iattr)
iattrs->ia_ctime = iattr->ia_ctime;
if (ia_valid & ATTR_MODE) {
umode_t mode = iattr->ia_mode;
iattrs->ia_mode = sd->s_mode = mode;
iattrs->ia_mode = kn->s_mode = mode;
}
return 0;
}
/**
* kernfs_setattr - set iattr on a node
* @sd: target node
* @kn: target node
* @iattr: iattr to set
*
* Returns 0 on success, -errno on failure.
*/
int kernfs_setattr(struct sysfs_dirent *sd, const struct iattr *iattr)
int kernfs_setattr(struct kernfs_node *kn, const struct iattr *iattr)
{
int ret;
mutex_lock(&sysfs_mutex);
ret = __kernfs_setattr(sd, iattr);
ret = __kernfs_setattr(kn, iattr);
mutex_unlock(&sysfs_mutex);
return ret;
}
......@@ -118,10 +118,10 @@ int kernfs_setattr(struct sysfs_dirent *sd, const struct iattr *iattr)
int sysfs_setattr(struct dentry *dentry, struct iattr *iattr)
{
struct inode *inode = dentry->d_inode;
struct sysfs_dirent *sd = dentry->d_fsdata;
struct kernfs_node *kn = dentry->d_fsdata;
int error;
if (!sd)
if (!kn)
return -EINVAL;
mutex_lock(&sysfs_mutex);
......@@ -129,7 +129,7 @@ int sysfs_setattr(struct dentry *dentry, struct iattr *iattr)
if (error)
goto out;
error = __kernfs_setattr(sd, iattr);
error = __kernfs_setattr(kn, iattr);
if (error)
goto out;
......@@ -141,14 +141,14 @@ int sysfs_setattr(struct dentry *dentry, struct iattr *iattr)
return error;
}
static int sysfs_sd_setsecdata(struct sysfs_dirent *sd, void **secdata,
static int sysfs_sd_setsecdata(struct kernfs_node *kn, void **secdata,
u32 *secdata_len)
{
struct sysfs_inode_attrs *attrs;
void *old_secdata;
size_t old_secdata_len;
attrs = sysfs_inode_attrs(sd);
attrs = sysfs_inode_attrs(kn);
if (!attrs)
return -ENOMEM;
......@@ -166,13 +166,13 @@ static int sysfs_sd_setsecdata(struct sysfs_dirent *sd, void **secdata,
int sysfs_setxattr(struct dentry *dentry, const char *name, const void *value,
size_t size, int flags)
{
struct sysfs_dirent *sd = dentry->d_fsdata;
struct kernfs_node *kn = dentry->d_fsdata;
struct sysfs_inode_attrs *attrs;
void *secdata;
int error;
u32 secdata_len = 0;
attrs = sysfs_inode_attrs(sd);
attrs = sysfs_inode_attrs(kn);
if (!attrs)
return -ENOMEM;
......@@ -188,7 +188,7 @@ int sysfs_setxattr(struct dentry *dentry, const char *name, const void *value,
return error;
mutex_lock(&sysfs_mutex);
error = sysfs_sd_setsecdata(sd, &secdata, &secdata_len);
error = sysfs_sd_setsecdata(kn, &secdata, &secdata_len);
mutex_unlock(&sysfs_mutex);
if (secdata)
......@@ -204,10 +204,10 @@ int sysfs_setxattr(struct dentry *dentry, const char *name, const void *value,
int sysfs_removexattr(struct dentry *dentry, const char *name)
{
struct sysfs_dirent *sd = dentry->d_fsdata;
struct kernfs_node *kn = dentry->d_fsdata;
struct sysfs_inode_attrs *attrs;
attrs = sysfs_inode_attrs(sd);
attrs = sysfs_inode_attrs(kn);
if (!attrs)
return -ENOMEM;
......@@ -217,10 +217,10 @@ int sysfs_removexattr(struct dentry *dentry, const char *name)
ssize_t sysfs_getxattr(struct dentry *dentry, const char *name, void *buf,
size_t size)
{
struct sysfs_dirent *sd = dentry->d_fsdata;
struct kernfs_node *kn = dentry->d_fsdata;
struct sysfs_inode_attrs *attrs;
attrs = sysfs_inode_attrs(sd);
attrs = sysfs_inode_attrs(kn);
if (!attrs)
return -ENOMEM;
......@@ -229,10 +229,10 @@ ssize_t sysfs_getxattr(struct dentry *dentry, const char *name, void *buf,
ssize_t sysfs_listxattr(struct dentry *dentry, char *buf, size_t size)
{
struct sysfs_dirent *sd = dentry->d_fsdata;
struct kernfs_node *kn = dentry->d_fsdata;
struct sysfs_inode_attrs *attrs;
attrs = sysfs_inode_attrs(sd);
attrs = sysfs_inode_attrs(kn);
if (!attrs)
return -ENOMEM;
......@@ -254,57 +254,58 @@ static inline void set_inode_attr(struct inode *inode, struct iattr *iattr)
inode->i_ctime = iattr->ia_ctime;
}
static void sysfs_refresh_inode(struct sysfs_dirent *sd, struct inode *inode)
static void sysfs_refresh_inode(struct kernfs_node *kn, struct inode *inode)
{
struct sysfs_inode_attrs *attrs = sd->s_iattr;
struct sysfs_inode_attrs *attrs = kn->s_iattr;
inode->i_mode = sd->s_mode;
inode->i_mode = kn->s_mode;
if (attrs) {
/* sysfs_dirent has non-default attributes
* get them from persistent copy in sysfs_dirent
/*
* kernfs_node has non-default attributes get them from
* persistent copy in kernfs_node.
*/
set_inode_attr(inode, &attrs->ia_iattr);
security_inode_notifysecctx(inode, attrs->ia_secdata,
attrs->ia_secdata_len);
}
if (sysfs_type(sd) == SYSFS_DIR)
set_nlink(inode, sd->s_dir.subdirs + 2);
if (sysfs_type(kn) == SYSFS_DIR)
set_nlink(inode, kn->s_dir.subdirs + 2);
}
int sysfs_getattr(struct vfsmount *mnt, struct dentry *dentry,
struct kstat *stat)
{
struct sysfs_dirent *sd = dentry->d_fsdata;
struct kernfs_node *kn = dentry->d_fsdata;
struct inode *inode = dentry->d_inode;
mutex_lock(&sysfs_mutex);
sysfs_refresh_inode(sd, inode);
sysfs_refresh_inode(kn, inode);
mutex_unlock(&sysfs_mutex);
generic_fillattr(inode, stat);
return 0;
}
static void sysfs_init_inode(struct sysfs_dirent *sd, struct inode *inode)
static void sysfs_init_inode(struct kernfs_node *kn, struct inode *inode)
{
kernfs_get(sd);
inode->i_private = sd;
kernfs_get(kn);
inode->i_private = kn;
inode->i_mapping->a_ops = &sysfs_aops;
inode->i_mapping->backing_dev_info = &sysfs_backing_dev_info;
inode->i_op = &sysfs_inode_operations;
set_default_inode_attr(inode, sd->s_mode);
sysfs_refresh_inode(sd, inode);
set_default_inode_attr(inode, kn->s_mode);
sysfs_refresh_inode(kn, inode);
/* initialize inode according to type */
switch (sysfs_type(sd)) {
switch (sysfs_type(kn)) {
case SYSFS_DIR:
inode->i_op = &sysfs_dir_inode_operations;
inode->i_fop = &sysfs_dir_operations;
break;
case SYSFS_KOBJ_ATTR:
inode->i_size = sd->s_attr.size;
inode->i_size = kn->s_attr.size;
inode->i_fop = &kernfs_file_operations;
break;
case SYSFS_KOBJ_LINK:
......@@ -318,13 +319,13 @@ static void sysfs_init_inode(struct sysfs_dirent *sd, struct inode *inode)
}
/**
* sysfs_get_inode - get inode for sysfs_dirent
* sysfs_get_inode - get inode for kernfs_node
* @sb: super block
* @sd: sysfs_dirent to allocate inode for
* @kn: kernfs_node to allocate inode for
*
* Get inode for @sd. If such inode doesn't exist, a new inode
* is allocated and basics are initialized. New inode is
* returned locked.
* Get inode for @kn. If such inode doesn't exist, a new inode is
* allocated and basics are initialized. New inode is returned
* locked.
*
* LOCKING:
* Kernel thread context (may sleep).
......@@ -332,44 +333,44 @@ static void sysfs_init_inode(struct sysfs_dirent *sd, struct inode *inode)
* RETURNS:
* Pointer to allocated inode on success, NULL on failure.
*/
struct inode *sysfs_get_inode(struct super_block *sb, struct sysfs_dirent *sd)
struct inode *sysfs_get_inode(struct super_block *sb, struct kernfs_node *kn)
{
struct inode *inode;
inode = iget_locked(sb, sd->s_ino);
inode = iget_locked(sb, kn->s_ino);
if (inode && (inode->i_state & I_NEW))
sysfs_init_inode(sd, inode);
sysfs_init_inode(kn, inode);
return inode;
}
/*
* The sysfs_dirent serves as both an inode and a directory entry for sysfs.
* To prevent the sysfs inode numbers from being freed prematurely we take a
* reference to sysfs_dirent from the sysfs inode. A
* The kernfs_node serves as both an inode and a directory entry for sysfs.
* To prevent the sysfs inode numbers from being freed prematurely we take
* a reference to kernfs_node from the sysfs inode. A
* super_operations.evict_inode() implementation is needed to drop that
* reference upon inode destruction.
*/
void sysfs_evict_inode(struct inode *inode)
{
struct sysfs_dirent *sd = inode->i_private;
struct kernfs_node *kn = inode->i_private;
truncate_inode_pages(&inode->i_data, 0);
clear_inode(inode);
kernfs_put(sd);
kernfs_put(kn);
}
int sysfs_permission(struct inode *inode, int mask)
{
struct sysfs_dirent *sd;
struct kernfs_node *kn;
if (mask & MAY_NOT_BLOCK)
return -ECHILD;
sd = inode->i_private;
kn = inode->i_private;
mutex_lock(&sysfs_mutex);
sysfs_refresh_inode(sd, inode);
sysfs_refresh_inode(kn, inode);
mutex_unlock(&sysfs_mutex);
return generic_permission(inode, mask);
......
......@@ -31,24 +31,24 @@ struct sysfs_inode_attrs {
/* SYSFS_TYPE_MASK and types are defined in include/linux/kernfs.h */
/**
* kernfs_root - find out the kernfs_root a sysfs_dirent belongs to
* @sd: sysfs_dirent of interest
* kernfs_root - find out the kernfs_root a kernfs_node belongs to
* @kn: kernfs_node of interest
*
* Return the kernfs_root @sd belongs to.
* Return the kernfs_root @kn belongs to.
*/
static inline struct kernfs_root *kernfs_root(struct sysfs_dirent *sd)
static inline struct kernfs_root *kernfs_root(struct kernfs_node *kn)
{
/* if parent exists, it's always a dir; otherwise, @sd is a dir */
if (sd->s_parent)
sd = sd->s_parent;
return sd->s_dir.root;
if (kn->s_parent)
kn = kn->s_parent;
return kn->s_dir.root;
}
/*
* Context structure to be used while adding/removing nodes.
*/
struct sysfs_addrm_cxt {
struct sysfs_dirent *removed;
struct kernfs_node *removed;
};
/*
......@@ -62,10 +62,10 @@ struct sysfs_super_info {
struct kernfs_root *root;
/*
* Each sb is associated with one namespace tag, currently the network
* namespace of the task which mounted this sysfs instance. If multiple
* tags become necessary, make the following an array and compare
* sysfs_dirent tag against every entry.
* Each sb is associated with one namespace tag, currently the
* network namespace of the task which mounted this sysfs instance.
* If multiple tags become necessary, make the following an array
* and compare kernfs_node tag against every entry.
*/
const void *ns;
};
......@@ -76,7 +76,7 @@ extern struct kmem_cache *sysfs_dir_cachep;
/*
* inode.c
*/
struct inode *sysfs_get_inode(struct super_block *sb, struct sysfs_dirent *sd);
struct inode *sysfs_get_inode(struct super_block *sb, struct kernfs_node *kn);
void sysfs_evict_inode(struct inode *inode);
int sysfs_permission(struct inode *inode, int mask);
int sysfs_setattr(struct dentry *dentry, struct iattr *iattr);
......@@ -98,21 +98,21 @@ extern const struct dentry_operations sysfs_dentry_ops;
extern const struct file_operations sysfs_dir_operations;
extern const struct inode_operations sysfs_dir_inode_operations;
struct sysfs_dirent *sysfs_get_active(struct sysfs_dirent *sd);
void sysfs_put_active(struct sysfs_dirent *sd);
struct kernfs_node *sysfs_get_active(struct kernfs_node *kn);
void sysfs_put_active(struct kernfs_node *kn);
void sysfs_addrm_start(struct sysfs_addrm_cxt *acxt);
int sysfs_add_one(struct sysfs_addrm_cxt *acxt, struct sysfs_dirent *sd,
struct sysfs_dirent *parent_sd);
int sysfs_add_one(struct sysfs_addrm_cxt *acxt, struct kernfs_node *kn,
struct kernfs_node *parent);
void sysfs_addrm_finish(struct sysfs_addrm_cxt *acxt);
struct sysfs_dirent *sysfs_new_dirent(struct kernfs_root *root,
const char *name, umode_t mode, int type);
struct kernfs_node *sysfs_new_dirent(struct kernfs_root *root,
const char *name, umode_t mode, int type);
/*
* file.c
*/
extern const struct file_operations kernfs_file_operations;
void sysfs_unmap_bin_file(struct sysfs_dirent *sd);
void sysfs_unmap_bin_file(struct kernfs_node *kn);
/*
* symlink.c
......
......@@ -39,7 +39,7 @@ static int sysfs_fill_super(struct super_block *sb)
/* get root inode, initialize and unlock it */
mutex_lock(&sysfs_mutex);
inode = sysfs_get_inode(sb, info->root->sd);
inode = sysfs_get_inode(sb, info->root->kn);
mutex_unlock(&sysfs_mutex);
if (!inode) {
pr_debug("sysfs: could not get root inode\n");
......@@ -52,8 +52,8 @@ static int sysfs_fill_super(struct super_block *sb)
pr_debug("%s: could not get root dentry!\n", __func__);
return -ENOMEM;
}
kernfs_get(info->root->sd);
root->d_fsdata = info->root->sd;
kernfs_get(info->root->kn);
root->d_fsdata = info->root->kn;
sb->s_root = root;
sb->s_d_op = &sysfs_dentry_ops;
return 0;
......@@ -145,7 +145,7 @@ struct dentry *kernfs_mount_ns(struct file_system_type *fs_type, int flags,
void kernfs_kill_sb(struct super_block *sb)
{
struct sysfs_super_info *info = sysfs_info(sb);
struct sysfs_dirent *root_sd = sb->s_root->d_fsdata;
struct kernfs_node *root_kn = sb->s_root->d_fsdata;
/*
* Remove the superblock from fs_supers/s_instances
......@@ -153,13 +153,13 @@ void kernfs_kill_sb(struct super_block *sb)
*/
kill_anon_super(sb);
kfree(info);
kernfs_put(root_sd);
kernfs_put(root_kn);
}
void __init kernfs_init(void)
{
sysfs_dir_cachep = kmem_cache_create("sysfs_dir_cache",
sizeof(struct sysfs_dirent),
sizeof(struct kernfs_node),
0, SLAB_PANIC, NULL);
sysfs_inode_init();
}
......@@ -22,50 +22,50 @@
*
* Returns the created node on success, ERR_PTR() value on error.
*/
struct sysfs_dirent *kernfs_create_link(struct sysfs_dirent *parent,
const char *name,
struct sysfs_dirent *target)
struct kernfs_node *kernfs_create_link(struct kernfs_node *parent,
const char *name,
struct kernfs_node *target)
{
struct sysfs_dirent *sd;
struct kernfs_node *kn;
struct sysfs_addrm_cxt acxt;
int error;
sd = sysfs_new_dirent(kernfs_root(parent), name, S_IFLNK|S_IRWXUGO,
kn = sysfs_new_dirent(kernfs_root(parent), name, S_IFLNK|S_IRWXUGO,
SYSFS_KOBJ_LINK);
if (!sd)
if (!kn)
return ERR_PTR(-ENOMEM);
if (kernfs_ns_enabled(parent))
sd->s_ns = target->s_ns;
sd->s_symlink.target_sd = target;
kn->s_ns = target->s_ns;
kn->s_symlink.target_kn = target;
kernfs_get(target); /* ref owned by symlink */
sysfs_addrm_start(&acxt);
error = sysfs_add_one(&acxt, sd, parent);
error = sysfs_add_one(&acxt, kn, parent);
sysfs_addrm_finish(&acxt);
if (!error)
return sd;
return kn;
kernfs_put(sd);
kernfs_put(kn);
return ERR_PTR(error);
}
static int sysfs_get_target_path(struct sysfs_dirent *parent_sd,
struct sysfs_dirent *target_sd, char *path)
static int sysfs_get_target_path(struct kernfs_node *parent,
struct kernfs_node *target, char *path)
{
struct sysfs_dirent *base, *sd;
struct kernfs_node *base, *kn;
char *s = path;
int len = 0;
/* go up to the root, stop at the base */
base = parent_sd;
base = parent;
while (base->s_parent) {
sd = target_sd->s_parent;
while (sd->s_parent && base != sd)
sd = sd->s_parent;
kn = target->s_parent;
while (kn->s_parent && base != kn)
kn = kn->s_parent;
if (base == sd)
if (base == kn)
break;
strcpy(s, "../");
......@@ -74,10 +74,10 @@ static int sysfs_get_target_path(struct sysfs_dirent *parent_sd,
}
/* determine end of target string for reverse fillup */
sd = target_sd;
while (sd->s_parent && sd != base) {
len += strlen(sd->s_name) + 1;
sd = sd->s_parent;
kn = target;
while (kn->s_parent && kn != base) {
len += strlen(kn->s_name) + 1;
kn = kn->s_parent;
}
/* check limits */
......@@ -88,16 +88,16 @@ static int sysfs_get_target_path(struct sysfs_dirent *parent_sd,
return -ENAMETOOLONG;
/* reverse fillup of target string from target to base */
sd = target_sd;
while (sd->s_parent && sd != base) {
int slen = strlen(sd->s_name);
kn = target;
while (kn->s_parent && kn != base) {
int slen = strlen(kn->s_name);
len -= slen;
strncpy(s + len, sd->s_name, slen);
strncpy(s + len, kn->s_name, slen);
if (len)
s[--len] = '/';
sd = sd->s_parent;
kn = kn->s_parent;
}
return 0;
......@@ -105,13 +105,13 @@ static int sysfs_get_target_path(struct sysfs_dirent *parent_sd,
static int sysfs_getlink(struct dentry *dentry, char *path)
{
struct sysfs_dirent *sd = dentry->d_fsdata;
struct sysfs_dirent *parent_sd = sd->s_parent;
struct sysfs_dirent *target_sd = sd->s_symlink.target_sd;
struct kernfs_node *kn = dentry->d_fsdata;
struct kernfs_node *parent = kn->s_parent;
struct kernfs_node *target = kn->s_symlink.target_kn;
int error;
mutex_lock(&sysfs_mutex);
error = sysfs_get_target_path(parent_sd, target_sd, path);
error = sysfs_get_target_path(parent, target, path);
mutex_unlock(&sysfs_mutex);
return error;
......
......@@ -21,23 +21,23 @@ DEFINE_SPINLOCK(sysfs_symlink_target_lock);
/**
* sysfs_pathname - return full path to sysfs dirent
* @sd: sysfs_dirent whose path we want
* @kn: kernfs_node whose path we want
* @path: caller allocated buffer of size PATH_MAX
*
* Gives the name "/" to the sysfs_root entry; any path returned
* is relative to wherever sysfs is mounted.
*/
static char *sysfs_pathname(struct sysfs_dirent *sd, char *path)
static char *sysfs_pathname(struct kernfs_node *kn, char *path)
{
if (sd->s_parent) {
sysfs_pathname(sd->s_parent, path);
if (kn->s_parent) {
sysfs_pathname(kn->s_parent, path);
strlcat(path, "/", PATH_MAX);
}
strlcat(path, sd->s_name, PATH_MAX);
strlcat(path, kn->s_name, PATH_MAX);
return path;
}
void sysfs_warn_dup(struct sysfs_dirent *parent, const char *name)
void sysfs_warn_dup(struct kernfs_node *parent, const char *name)
{
char *path;
......@@ -61,26 +61,26 @@ void sysfs_warn_dup(struct sysfs_dirent *parent, const char *name)
*/
int sysfs_create_dir_ns(struct kobject *kobj, const void *ns)
{
struct sysfs_dirent *parent_sd, *sd;
struct kernfs_node *parent, *kn;
BUG_ON(!kobj);
if (kobj->parent)
parent_sd = kobj->parent->sd;
parent = kobj->parent->sd;
else
parent_sd = sysfs_root_sd;
parent = sysfs_root_kn;
if (!parent_sd)
if (!parent)
return -ENOENT;
sd = kernfs_create_dir_ns(parent_sd, kobject_name(kobj), kobj, ns);
if (IS_ERR(sd)) {
if (PTR_ERR(sd) == -EEXIST)
sysfs_warn_dup(parent_sd, kobject_name(kobj));
return PTR_ERR(sd);
kn = kernfs_create_dir_ns(parent, kobject_name(kobj), kobj, ns);
if (IS_ERR(kn)) {
if (PTR_ERR(kn) == -EEXIST)
sysfs_warn_dup(parent, kobject_name(kobj));
return PTR_ERR(kn);
}