mirror of
https://github.com/AuxXxilium/linux_dsm_epyc7002.git
synced 2024-12-05 12:06:42 +07:00
36ce6dad6e
driver core: Suppress sysfs warnings for device_rename(). Renaming network devices to an already existing name is not something we want sysfs to print a scary warning for, since the callers can deal with this correctly. So let's introduce sysfs_create_link_nowarn() which gets rid of the common warning. Signed-off-by: Cornelia Huck <cornelia.huck@de.ibm.com> Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
217 lines
4.8 KiB
C
217 lines
4.8 KiB
C
/*
|
|
* fs/sysfs/symlink.c - sysfs symlink implementation
|
|
*
|
|
* Copyright (c) 2001-3 Patrick Mochel
|
|
* Copyright (c) 2007 SUSE Linux Products GmbH
|
|
* Copyright (c) 2007 Tejun Heo <teheo@suse.de>
|
|
*
|
|
* This file is released under the GPLv2.
|
|
*
|
|
* Please see Documentation/filesystems/sysfs.txt for more information.
|
|
*/
|
|
|
|
#include <linux/fs.h>
|
|
#include <linux/mount.h>
|
|
#include <linux/module.h>
|
|
#include <linux/kobject.h>
|
|
#include <linux/namei.h>
|
|
#include <linux/mutex.h>
|
|
|
|
#include "sysfs.h"
|
|
|
|
static int sysfs_do_create_link(struct kobject *kobj, struct kobject *target,
|
|
const char *name, int warn)
|
|
{
|
|
struct sysfs_dirent *parent_sd = NULL;
|
|
struct sysfs_dirent *target_sd = NULL;
|
|
struct sysfs_dirent *sd = NULL;
|
|
struct sysfs_addrm_cxt acxt;
|
|
int error;
|
|
|
|
BUG_ON(!name);
|
|
|
|
if (!kobj)
|
|
parent_sd = &sysfs_root;
|
|
else
|
|
parent_sd = kobj->sd;
|
|
|
|
error = -EFAULT;
|
|
if (!parent_sd)
|
|
goto out_put;
|
|
|
|
/* target->sd can go away beneath us but is protected with
|
|
* sysfs_assoc_lock. Fetch target_sd from it.
|
|
*/
|
|
spin_lock(&sysfs_assoc_lock);
|
|
if (target->sd)
|
|
target_sd = sysfs_get(target->sd);
|
|
spin_unlock(&sysfs_assoc_lock);
|
|
|
|
error = -ENOENT;
|
|
if (!target_sd)
|
|
goto out_put;
|
|
|
|
error = -ENOMEM;
|
|
sd = sysfs_new_dirent(name, S_IFLNK|S_IRWXUGO, SYSFS_KOBJ_LINK);
|
|
if (!sd)
|
|
goto out_put;
|
|
|
|
sd->s_symlink.target_sd = target_sd;
|
|
target_sd = NULL; /* reference is now owned by the symlink */
|
|
|
|
sysfs_addrm_start(&acxt, parent_sd);
|
|
if (warn)
|
|
error = sysfs_add_one(&acxt, sd);
|
|
else
|
|
error = __sysfs_add_one(&acxt, sd);
|
|
sysfs_addrm_finish(&acxt);
|
|
|
|
if (error)
|
|
goto out_put;
|
|
|
|
return 0;
|
|
|
|
out_put:
|
|
sysfs_put(target_sd);
|
|
sysfs_put(sd);
|
|
return error;
|
|
}
|
|
|
|
/**
|
|
* sysfs_create_link - create symlink between two objects.
|
|
* @kobj: object whose directory we're creating the link in.
|
|
* @target: object we're pointing to.
|
|
* @name: name of the symlink.
|
|
*/
|
|
int sysfs_create_link(struct kobject *kobj, struct kobject *target,
|
|
const char *name)
|
|
{
|
|
return sysfs_do_create_link(kobj, target, name, 1);
|
|
}
|
|
|
|
/**
|
|
* sysfs_create_link_nowarn - create symlink between two objects.
|
|
* @kobj: object whose directory we're creating the link in.
|
|
* @target: object we're pointing to.
|
|
* @name: name of the symlink.
|
|
*
|
|
* This function does the same as sysf_create_link(), but it
|
|
* doesn't warn if the link already exists.
|
|
*/
|
|
int sysfs_create_link_nowarn(struct kobject *kobj, struct kobject *target,
|
|
const char *name)
|
|
{
|
|
return sysfs_do_create_link(kobj, target, name, 0);
|
|
}
|
|
|
|
/**
|
|
* sysfs_remove_link - remove symlink in object's directory.
|
|
* @kobj: object we're acting for.
|
|
* @name: name of the symlink to remove.
|
|
*/
|
|
|
|
void sysfs_remove_link(struct kobject * kobj, const char * name)
|
|
{
|
|
struct sysfs_dirent *parent_sd = NULL;
|
|
|
|
if (!kobj)
|
|
parent_sd = &sysfs_root;
|
|
else
|
|
parent_sd = kobj->sd;
|
|
|
|
sysfs_hash_and_remove(parent_sd, name);
|
|
}
|
|
|
|
static int sysfs_get_target_path(struct sysfs_dirent *parent_sd,
|
|
struct sysfs_dirent *target_sd, char *path)
|
|
{
|
|
struct sysfs_dirent *base, *sd;
|
|
char *s = path;
|
|
int len = 0;
|
|
|
|
/* go up to the root, stop at the base */
|
|
base = parent_sd;
|
|
while (base->s_parent) {
|
|
sd = target_sd->s_parent;
|
|
while (sd->s_parent && base != sd)
|
|
sd = sd->s_parent;
|
|
|
|
if (base == sd)
|
|
break;
|
|
|
|
strcpy(s, "../");
|
|
s += 3;
|
|
base = base->s_parent;
|
|
}
|
|
|
|
/* 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;
|
|
}
|
|
|
|
/* check limits */
|
|
if (len < 2)
|
|
return -EINVAL;
|
|
len--;
|
|
if ((s - path) + len > PATH_MAX)
|
|
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);
|
|
|
|
len -= slen;
|
|
strncpy(s + len, sd->s_name, slen);
|
|
if (len)
|
|
s[--len] = '/';
|
|
|
|
sd = sd->s_parent;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
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;
|
|
int error;
|
|
|
|
mutex_lock(&sysfs_mutex);
|
|
error = sysfs_get_target_path(parent_sd, target_sd, path);
|
|
mutex_unlock(&sysfs_mutex);
|
|
|
|
return error;
|
|
}
|
|
|
|
static void *sysfs_follow_link(struct dentry *dentry, struct nameidata *nd)
|
|
{
|
|
int error = -ENOMEM;
|
|
unsigned long page = get_zeroed_page(GFP_KERNEL);
|
|
if (page)
|
|
error = sysfs_getlink(dentry, (char *) page);
|
|
nd_set_link(nd, error ? ERR_PTR(error) : (char *)page);
|
|
return NULL;
|
|
}
|
|
|
|
static void sysfs_put_link(struct dentry *dentry, struct nameidata *nd, void *cookie)
|
|
{
|
|
char *page = nd_get_link(nd);
|
|
if (!IS_ERR(page))
|
|
free_page((unsigned long)page);
|
|
}
|
|
|
|
const struct inode_operations sysfs_symlink_inode_operations = {
|
|
.readlink = generic_readlink,
|
|
.follow_link = sysfs_follow_link,
|
|
.put_link = sysfs_put_link,
|
|
};
|
|
|
|
|
|
EXPORT_SYMBOL_GPL(sysfs_create_link);
|
|
EXPORT_SYMBOL_GPL(sysfs_remove_link);
|