b592fcfe7f
The problem. When implementing a network namespace I need to be able to have multiple network devices with the same name. Currently this is a problem for /sys/class/net/*. What I want is a separate /sys/class/net directory in sysfs for each network namespace, and I want to name each of them /sys/class/net. I looked and the VFS actually allows that. All that is needed is for /sys/class/net to implement a follow link method to redirect lookups to the real directory you want. Implementing a follow link method that is sensitive to the current network namespace turns out to be 3 lines of code so it looks like a clean approach. Modifying sysfs so it doesn't get in my was is a bit trickier. I am calling the concept of multiple directories all at the same path in the filesystem shadow directories. With the directory entry really at that location the shadow master. The following patch modifies sysfs so it can handle a directory structure slightly different from the kobject tree so I can implement the shadow directories for handling /sys/class/net/. Signed-off-by: Eric W. Biederman <ebiederm@xmission.com> Cc: Maneesh Soni <maneesh@in.ibm.com> Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
296 lines
8.4 KiB
C
296 lines
8.4 KiB
C
/*
|
|
* kobject.h - generic kernel object infrastructure.
|
|
*
|
|
* Copyright (c) 2002-2003 Patrick Mochel
|
|
* Copyright (c) 2002-2003 Open Source Development Labs
|
|
*
|
|
* This file is released under the GPLv2.
|
|
*
|
|
*
|
|
* Please read Documentation/kobject.txt before using the kobject
|
|
* interface, ESPECIALLY the parts about reference counts and object
|
|
* destructors.
|
|
*/
|
|
|
|
#ifndef _KOBJECT_H_
|
|
#define _KOBJECT_H_
|
|
|
|
#ifdef __KERNEL__
|
|
|
|
#include <linux/types.h>
|
|
#include <linux/list.h>
|
|
#include <linux/sysfs.h>
|
|
#include <linux/compiler.h>
|
|
#include <linux/spinlock.h>
|
|
#include <linux/rwsem.h>
|
|
#include <linux/kref.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/wait.h>
|
|
#include <asm/atomic.h>
|
|
|
|
#define KOBJ_NAME_LEN 20
|
|
#define UEVENT_HELPER_PATH_LEN 256
|
|
|
|
/* path to the userspace helper executed on an event */
|
|
extern char uevent_helper[];
|
|
|
|
/* counter to tag the uevent, read only except for the kobject core */
|
|
extern u64 uevent_seqnum;
|
|
|
|
/* the actions here must match the proper string in lib/kobject_uevent.c */
|
|
typedef int __bitwise kobject_action_t;
|
|
enum kobject_action {
|
|
KOBJ_ADD = (__force kobject_action_t) 0x01, /* exclusive to core */
|
|
KOBJ_REMOVE = (__force kobject_action_t) 0x02, /* exclusive to core */
|
|
KOBJ_CHANGE = (__force kobject_action_t) 0x03, /* device state change */
|
|
KOBJ_MOUNT = (__force kobject_action_t) 0x04, /* mount event for block devices (broken) */
|
|
KOBJ_UMOUNT = (__force kobject_action_t) 0x05, /* umount event for block devices (broken) */
|
|
KOBJ_OFFLINE = (__force kobject_action_t) 0x06, /* device offline */
|
|
KOBJ_ONLINE = (__force kobject_action_t) 0x07, /* device online */
|
|
KOBJ_MOVE = (__force kobject_action_t) 0x08, /* device move */
|
|
};
|
|
|
|
struct kobject {
|
|
const char * k_name;
|
|
char name[KOBJ_NAME_LEN];
|
|
struct kref kref;
|
|
struct list_head entry;
|
|
struct kobject * parent;
|
|
struct kset * kset;
|
|
struct kobj_type * ktype;
|
|
struct dentry * dentry;
|
|
wait_queue_head_t poll;
|
|
};
|
|
|
|
extern int kobject_set_name(struct kobject *, const char *, ...)
|
|
__attribute__((format(printf,2,3)));
|
|
|
|
static inline const char * kobject_name(const struct kobject * kobj)
|
|
{
|
|
return kobj->k_name;
|
|
}
|
|
|
|
extern void kobject_init(struct kobject *);
|
|
extern void kobject_cleanup(struct kobject *);
|
|
|
|
extern int __must_check kobject_add(struct kobject *);
|
|
extern int __must_check kobject_shadow_add(struct kobject *, struct dentry *);
|
|
extern void kobject_del(struct kobject *);
|
|
|
|
extern int __must_check kobject_rename(struct kobject *, const char *new_name);
|
|
extern int __must_check kobject_shadow_rename(struct kobject *kobj,
|
|
struct dentry *new_parent,
|
|
const char *new_name);
|
|
extern int __must_check kobject_move(struct kobject *, struct kobject *);
|
|
|
|
extern int __must_check kobject_register(struct kobject *);
|
|
extern void kobject_unregister(struct kobject *);
|
|
|
|
extern struct kobject * kobject_get(struct kobject *);
|
|
extern void kobject_put(struct kobject *);
|
|
|
|
extern struct kobject *kobject_add_dir(struct kobject *, const char *);
|
|
|
|
extern char * kobject_get_path(struct kobject *, gfp_t);
|
|
|
|
struct kobj_type {
|
|
void (*release)(struct kobject *);
|
|
struct sysfs_ops * sysfs_ops;
|
|
struct attribute ** default_attrs;
|
|
};
|
|
|
|
|
|
/**
|
|
* kset - a set of kobjects of a specific type, belonging
|
|
* to a specific subsystem.
|
|
*
|
|
* All kobjects of a kset should be embedded in an identical
|
|
* type. This type may have a descriptor, which the kset points
|
|
* to. This allows there to exist sets of objects of the same
|
|
* type in different subsystems.
|
|
*
|
|
* A subsystem does not have to be a list of only one type
|
|
* of object; multiple ksets can belong to one subsystem. All
|
|
* ksets of a subsystem share the subsystem's lock.
|
|
*
|
|
* Each kset can support specific event variables; it can
|
|
* supress the event generation or add subsystem specific
|
|
* variables carried with the event.
|
|
*/
|
|
struct kset_uevent_ops {
|
|
int (*filter)(struct kset *kset, struct kobject *kobj);
|
|
const char *(*name)(struct kset *kset, struct kobject *kobj);
|
|
int (*uevent)(struct kset *kset, struct kobject *kobj, char **envp,
|
|
int num_envp, char *buffer, int buffer_size);
|
|
};
|
|
|
|
struct kset {
|
|
struct subsystem * subsys;
|
|
struct kobj_type * ktype;
|
|
struct list_head list;
|
|
spinlock_t list_lock;
|
|
struct kobject kobj;
|
|
struct kset_uevent_ops * uevent_ops;
|
|
};
|
|
|
|
|
|
extern void kset_init(struct kset * k);
|
|
extern int __must_check kset_add(struct kset * k);
|
|
extern int __must_check kset_register(struct kset * k);
|
|
extern void kset_unregister(struct kset * k);
|
|
|
|
static inline struct kset * to_kset(struct kobject * kobj)
|
|
{
|
|
return kobj ? container_of(kobj,struct kset,kobj) : NULL;
|
|
}
|
|
|
|
static inline struct kset * kset_get(struct kset * k)
|
|
{
|
|
return k ? to_kset(kobject_get(&k->kobj)) : NULL;
|
|
}
|
|
|
|
static inline void kset_put(struct kset * k)
|
|
{
|
|
kobject_put(&k->kobj);
|
|
}
|
|
|
|
static inline struct kobj_type * get_ktype(struct kobject * k)
|
|
{
|
|
if (k->kset && k->kset->ktype)
|
|
return k->kset->ktype;
|
|
else
|
|
return k->ktype;
|
|
}
|
|
|
|
extern struct kobject * kset_find_obj(struct kset *, const char *);
|
|
|
|
|
|
/**
|
|
* Use this when initializing an embedded kset with no other
|
|
* fields to initialize.
|
|
*/
|
|
#define set_kset_name(str) .kset = { .kobj = { .name = str } }
|
|
|
|
|
|
|
|
struct subsystem {
|
|
struct kset kset;
|
|
struct rw_semaphore rwsem;
|
|
};
|
|
|
|
#define decl_subsys(_name,_type,_uevent_ops) \
|
|
struct subsystem _name##_subsys = { \
|
|
.kset = { \
|
|
.kobj = { .name = __stringify(_name) }, \
|
|
.ktype = _type, \
|
|
.uevent_ops =_uevent_ops, \
|
|
} \
|
|
}
|
|
#define decl_subsys_name(_varname,_name,_type,_uevent_ops) \
|
|
struct subsystem _varname##_subsys = { \
|
|
.kset = { \
|
|
.kobj = { .name = __stringify(_name) }, \
|
|
.ktype = _type, \
|
|
.uevent_ops =_uevent_ops, \
|
|
} \
|
|
}
|
|
|
|
/* The global /sys/kernel/ subsystem for people to chain off of */
|
|
extern struct subsystem kernel_subsys;
|
|
/* The global /sys/hypervisor/ subsystem */
|
|
extern struct subsystem hypervisor_subsys;
|
|
|
|
/**
|
|
* Helpers for setting the kset of registered objects.
|
|
* Often, a registered object belongs to a kset embedded in a
|
|
* subsystem. These do no magic, just make the resulting code
|
|
* easier to follow.
|
|
*/
|
|
|
|
/**
|
|
* kobj_set_kset_s(obj,subsys) - set kset for embedded kobject.
|
|
* @obj: ptr to some object type.
|
|
* @subsys: a subsystem object (not a ptr).
|
|
*
|
|
* Can be used for any object type with an embedded ->kobj.
|
|
*/
|
|
|
|
#define kobj_set_kset_s(obj,subsys) \
|
|
(obj)->kobj.kset = &(subsys).kset
|
|
|
|
/**
|
|
* kset_set_kset_s(obj,subsys) - set kset for embedded kset.
|
|
* @obj: ptr to some object type.
|
|
* @subsys: a subsystem object (not a ptr).
|
|
*
|
|
* Can be used for any object type with an embedded ->kset.
|
|
* Sets the kset of @obj's embedded kobject (via its embedded
|
|
* kset) to @subsys.kset. This makes @obj a member of that
|
|
* kset.
|
|
*/
|
|
|
|
#define kset_set_kset_s(obj,subsys) \
|
|
(obj)->kset.kobj.kset = &(subsys).kset
|
|
|
|
/**
|
|
* subsys_set_kset(obj,subsys) - set kset for subsystem
|
|
* @obj: ptr to some object type.
|
|
* @subsys: a subsystem object (not a ptr).
|
|
*
|
|
* Can be used for any object type with an embedded ->subsys.
|
|
* Sets the kset of @obj's kobject to @subsys.kset. This makes
|
|
* the object a member of that kset.
|
|
*/
|
|
|
|
#define subsys_set_kset(obj,_subsys) \
|
|
(obj)->subsys.kset.kobj.kset = &(_subsys).kset
|
|
|
|
extern void subsystem_init(struct subsystem *);
|
|
extern int __must_check subsystem_register(struct subsystem *);
|
|
extern void subsystem_unregister(struct subsystem *);
|
|
|
|
static inline struct subsystem * subsys_get(struct subsystem * s)
|
|
{
|
|
return s ? container_of(kset_get(&s->kset),struct subsystem,kset) : NULL;
|
|
}
|
|
|
|
static inline void subsys_put(struct subsystem * s)
|
|
{
|
|
kset_put(&s->kset);
|
|
}
|
|
|
|
struct subsys_attribute {
|
|
struct attribute attr;
|
|
ssize_t (*show)(struct subsystem *, char *);
|
|
ssize_t (*store)(struct subsystem *, const char *, size_t);
|
|
};
|
|
|
|
extern int __must_check subsys_create_file(struct subsystem * ,
|
|
struct subsys_attribute *);
|
|
|
|
#if defined(CONFIG_HOTPLUG)
|
|
int kobject_uevent(struct kobject *kobj, enum kobject_action action);
|
|
int kobject_uevent_env(struct kobject *kobj, enum kobject_action action,
|
|
char *envp[]);
|
|
|
|
int add_uevent_var(char **envp, int num_envp, int *cur_index,
|
|
char *buffer, int buffer_size, int *cur_len,
|
|
const char *format, ...)
|
|
__attribute__((format (printf, 7, 8)));
|
|
#else
|
|
static inline int kobject_uevent(struct kobject *kobj, enum kobject_action action)
|
|
{ return 0; }
|
|
static inline int kobject_uevent_env(struct kobject *kobj,
|
|
enum kobject_action action,
|
|
char *envp[])
|
|
{ return 0; }
|
|
|
|
static inline int add_uevent_var(char **envp, int num_envp, int *cur_index,
|
|
char *buffer, int buffer_size, int *cur_len,
|
|
const char *format, ...)
|
|
{ return 0; }
|
|
#endif
|
|
|
|
#endif /* __KERNEL__ */
|
|
#endif /* _KOBJECT_H_ */
|