2017-11-07 23:30:05 +07:00
|
|
|
// SPDX-License-Identifier: GPL-2.0
|
2005-04-17 05:20:36 +07:00
|
|
|
/*
|
|
|
|
* kobject.h - generic kernel object infrastructure.
|
|
|
|
*
|
2007-09-28 04:48:53 +07:00
|
|
|
* Copyright (c) 2002-2003 Patrick Mochel
|
|
|
|
* Copyright (c) 2002-2003 Open Source Development Labs
|
2008-01-25 12:27:06 +07:00
|
|
|
* Copyright (c) 2006-2008 Greg Kroah-Hartman <greg@kroah.com>
|
|
|
|
* Copyright (c) 2006-2008 Novell Inc.
|
2005-04-17 05:20:36 +07:00
|
|
|
*
|
2020-04-14 23:48:37 +07:00
|
|
|
* Please read Documentation/core-api/kobject.rst before using the kobject
|
2005-04-17 05:20:36 +07:00
|
|
|
* interface, ESPECIALLY the parts about reference counts and object
|
2008-01-25 12:27:06 +07:00
|
|
|
* destructors.
|
2005-04-17 05:20:36 +07:00
|
|
|
*/
|
|
|
|
|
|
|
|
#ifndef _KOBJECT_H_
|
|
|
|
#define _KOBJECT_H_
|
|
|
|
|
|
|
|
#include <linux/types.h>
|
|
|
|
#include <linux/list.h>
|
|
|
|
#include <linux/sysfs.h>
|
2006-08-15 12:43:17 +07:00
|
|
|
#include <linux/compiler.h>
|
2005-04-17 05:20:36 +07:00
|
|
|
#include <linux/spinlock.h>
|
|
|
|
#include <linux/kref.h>
|
2010-08-11 21:01:02 +07:00
|
|
|
#include <linux/kobject_ns.h>
|
2005-04-17 05:20:36 +07:00
|
|
|
#include <linux/kernel.h>
|
2006-03-20 13:53:53 +07:00
|
|
|
#include <linux/wait.h>
|
2011-07-27 06:09:06 +07:00
|
|
|
#include <linux/atomic.h>
|
2013-06-27 21:06:14 +07:00
|
|
|
#include <linux/workqueue.h>
|
2018-07-21 04:56:48 +07:00
|
|
|
#include <linux/uidgid.h>
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2005-11-16 15:00:00 +07:00
|
|
|
#define UEVENT_HELPER_PATH_LEN 256
|
2007-08-14 20:15:12 +07:00
|
|
|
#define UEVENT_NUM_ENVP 32 /* number of env pointers */
|
|
|
|
#define UEVENT_BUFFER_SIZE 2048 /* buffer for the variables */
|
2005-11-11 11:33:52 +07:00
|
|
|
|
2014-04-11 04:09:31 +07:00
|
|
|
#ifdef CONFIG_UEVENT_HELPER
|
2005-11-11 11:33:52 +07:00
|
|
|
/* path to the userspace helper executed on an event */
|
2005-11-16 15:00:00 +07:00
|
|
|
extern char uevent_helper[];
|
2014-04-11 04:09:31 +07:00
|
|
|
#endif
|
2005-11-11 11:33:52 +07:00
|
|
|
|
2005-11-16 15:00:00 +07:00
|
|
|
/* counter to tag the uevent, read only except for the kobject core */
|
|
|
|
extern u64 uevent_seqnum;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2007-07-09 03:29:26 +07:00
|
|
|
/*
|
|
|
|
* The actions here must match the index to the string array
|
|
|
|
* in lib/kobject_uevent.c
|
|
|
|
*
|
|
|
|
* Do not add new actions here without checking with the driver-core
|
|
|
|
* maintainers. Action strings are not meant to express subsystem
|
|
|
|
* or device specific properties. In most cases you want to send a
|
|
|
|
* kobject_uevent_env(kobj, KOBJ_CHANGE, env) with additional event
|
|
|
|
* specific variables added to the event environment.
|
|
|
|
*/
|
2005-11-11 11:33:52 +07:00
|
|
|
enum kobject_action {
|
2007-07-09 03:29:26 +07:00
|
|
|
KOBJ_ADD,
|
|
|
|
KOBJ_REMOVE,
|
|
|
|
KOBJ_CHANGE,
|
|
|
|
KOBJ_MOVE,
|
|
|
|
KOBJ_ONLINE,
|
|
|
|
KOBJ_OFFLINE,
|
2017-07-20 07:24:30 +07:00
|
|
|
KOBJ_BIND,
|
|
|
|
KOBJ_UNBIND,
|
2007-07-09 03:29:26 +07:00
|
|
|
KOBJ_MAX
|
2005-11-11 11:33:52 +07:00
|
|
|
};
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
struct kobject {
|
2007-12-20 08:09:39 +07:00
|
|
|
const char *name;
|
2005-04-17 05:20:36 +07:00
|
|
|
struct list_head entry;
|
2008-01-25 12:27:06 +07:00
|
|
|
struct kobject *parent;
|
|
|
|
struct kset *kset;
|
|
|
|
struct kobj_type *ktype;
|
2015-09-02 20:40:02 +07:00
|
|
|
struct kernfs_node *sd; /* sysfs directory entry */
|
2008-06-02 17:07:25 +07:00
|
|
|
struct kref kref;
|
2013-06-27 21:06:14 +07:00
|
|
|
#ifdef CONFIG_DEBUG_KOBJECT_RELEASE
|
|
|
|
struct delayed_work release;
|
|
|
|
#endif
|
2007-12-19 07:40:42 +07:00
|
|
|
unsigned int state_initialized:1;
|
|
|
|
unsigned int state_in_sysfs:1;
|
|
|
|
unsigned int state_add_uevent_sent:1;
|
|
|
|
unsigned int state_remove_uevent_sent:1;
|
2009-03-01 20:10:49 +07:00
|
|
|
unsigned int uevent_suppress:1;
|
2005-04-17 05:20:36 +07:00
|
|
|
};
|
|
|
|
|
2011-11-01 07:11:33 +07:00
|
|
|
extern __printf(2, 3)
|
|
|
|
int kobject_set_name(struct kobject *kobj, const char *name, ...);
|
2015-07-18 06:23:42 +07:00
|
|
|
extern __printf(2, 0)
|
|
|
|
int kobject_set_name_vargs(struct kobject *kobj, const char *fmt,
|
|
|
|
va_list vargs);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2008-01-25 12:27:06 +07:00
|
|
|
static inline const char *kobject_name(const struct kobject *kobj)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2007-12-20 08:09:39 +07:00
|
|
|
return kobj->name;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2007-12-18 13:05:35 +07:00
|
|
|
extern void kobject_init(struct kobject *kobj, struct kobj_type *ktype);
|
2011-11-01 07:11:33 +07:00
|
|
|
extern __printf(3, 4) __must_check
|
|
|
|
int kobject_add(struct kobject *kobj, struct kobject *parent,
|
|
|
|
const char *fmt, ...);
|
|
|
|
extern __printf(4, 5) __must_check
|
|
|
|
int kobject_init_and_add(struct kobject *kobj,
|
|
|
|
struct kobj_type *ktype, struct kobject *parent,
|
|
|
|
const char *fmt, ...);
|
2007-12-04 12:31:08 +07:00
|
|
|
|
2008-01-25 12:27:06 +07:00
|
|
|
extern void kobject_del(struct kobject *kobj);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2007-11-06 13:24:43 +07:00
|
|
|
extern struct kobject * __must_check kobject_create(void);
|
2007-11-06 04:16:15 +07:00
|
|
|
extern struct kobject * __must_check kobject_create_and_add(const char *name,
|
|
|
|
struct kobject *parent);
|
|
|
|
|
2006-08-15 12:43:17 +07:00
|
|
|
extern int __must_check kobject_rename(struct kobject *, const char *new_name);
|
2006-11-20 23:07:51 +07:00
|
|
|
extern int __must_check kobject_move(struct kobject *, struct kobject *);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2008-01-25 12:27:06 +07:00
|
|
|
extern struct kobject *kobject_get(struct kobject *kobj);
|
2017-03-23 07:37:01 +07:00
|
|
|
extern struct kobject * __must_check kobject_get_unless_zero(
|
|
|
|
struct kobject *kobj);
|
2008-01-25 12:27:06 +07:00
|
|
|
extern void kobject_put(struct kobject *kobj);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2013-09-12 09:29:05 +07:00
|
|
|
extern const void *kobject_namespace(struct kobject *kobj);
|
2018-07-21 04:56:48 +07:00
|
|
|
extern void kobject_get_ownership(struct kobject *kobj,
|
|
|
|
kuid_t *uid, kgid_t *gid);
|
2008-01-25 12:27:06 +07:00
|
|
|
extern char *kobject_get_path(struct kobject *kobj, gfp_t flag);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
drivers: core: Remove glue dirs from sysfs earlier
For devices with a class, we create a "glue" directory between
the parent device and the new device with the class name.
This directory is never "explicitely" removed when empty however,
this is left to the implicit sysfs removal done by kobject_release()
when the object loses its last reference via kobject_put().
This is problematic because as long as it's not been removed from
sysfs, it is still present in the class kset and in sysfs directory
structure.
The presence in the class kset exposes a use after free bug fixed
by the previous patch, but the presence in sysfs means that until
the kobject is released, which can take a while (especially with
kobject debugging), any attempt at re-creating such as binding a
new device for that class/parent pair, will result in a sysfs
duplicate file name error.
This fixes it by instead doing an explicit kobject_del() when
the glue dir is empty, by keeping track of the number of
child devices of the gluedir.
This is made easy by the fact that all glue dir operations are
done with a global mutex, and there's already a function
(cleanup_glue_dir) called in all the right places taking that
mutex that can be enhanced for this. It appears that this was
in fact the intent of the function, but the implementation was
wrong.
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
Acked-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2018-07-10 07:29:10 +07:00
|
|
|
/**
|
|
|
|
* kobject_has_children - Returns whether a kobject has children.
|
|
|
|
* @kobj: the object to test
|
|
|
|
*
|
|
|
|
* This will return whether a kobject has other kobjects as children.
|
|
|
|
*
|
|
|
|
* It does NOT account for the presence of attribute files, only sub
|
|
|
|
* directories. It also assumes there is no concurrent addition or
|
|
|
|
* removal of such children, and thus relies on external locking.
|
|
|
|
*/
|
|
|
|
static inline bool kobject_has_children(struct kobject *kobj)
|
|
|
|
{
|
|
|
|
WARN_ON_ONCE(kref_read(&kobj->kref) == 0);
|
|
|
|
|
|
|
|
return kobj->sd && kobj->sd->dir.subdirs;
|
|
|
|
}
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
struct kobj_type {
|
2008-01-25 12:27:06 +07:00
|
|
|
void (*release)(struct kobject *kobj);
|
2010-01-19 08:58:23 +07:00
|
|
|
const struct sysfs_ops *sysfs_ops;
|
2019-04-02 09:51:18 +07:00
|
|
|
struct attribute **default_attrs; /* use default_groups instead */
|
|
|
|
const struct attribute_group **default_groups;
|
2010-03-31 01:31:25 +07:00
|
|
|
const struct kobj_ns_type_operations *(*child_ns_type)(struct kobject *kobj);
|
|
|
|
const void *(*namespace)(struct kobject *kobj);
|
2018-07-21 04:56:48 +07:00
|
|
|
void (*get_ownership)(struct kobject *kobj, kuid_t *uid, kgid_t *gid);
|
2005-04-17 05:20:36 +07:00
|
|
|
};
|
|
|
|
|
2007-08-14 20:15:12 +07:00
|
|
|
struct kobj_uevent_env {
|
kobject: don't block for each kobject_uevent
Currently kobject_uevent has somewhat unpredictable semantics. The
point is, since it may call a usermode helper and wait for it to execute
(UMH_WAIT_EXEC), it is impossible to say for sure what lock dependencies
it will introduce for the caller - strictly speaking it depends on what
fs the binary is located on and the set of locks fork may take. There
are quite a few kobject_uevent's users that do not take this into
account and call it with various mutexes taken, e.g. rtnl_mutex,
net_mutex, which might potentially lead to a deadlock.
Since there is actually no reason to wait for the usermode helper to
execute there, let's make kobject_uevent start the helper asynchronously
with the aid of the UMH_NO_WAIT flag.
Personally, I'm interested in this, because I really want kobject_uevent
to be called under the slab_mutex in the slub implementation as it used
to be some time ago, because it greatly simplifies synchronization and
automatically fixes a kmemcg-related race. However, there was a
deadlock detected on an attempt to call kobject_uevent under the
slab_mutex (see https://lkml.org/lkml/2012/1/14/45), which was reported
to be fixed by releasing the slab_mutex for kobject_uevent.
Unfortunately, there was no information about who exactly blocked on the
slab_mutex causing the usermode helper to stall, neither have I managed
to find this out or reproduce the issue.
BTW, this is not the first attempt to make kobject_uevent use
UMH_NO_WAIT. Previous one was made by commit f520360d93cd ("kobject:
don't block for each kobject_uevent"), but it was wrong (it passed
arguments allocated on stack to async thread) so it was reverted in
05f54c13cd0c ("Revert "kobject: don't block for each kobject_uevent".").
It targeted on speeding up the boot process though.
Signed-off-by: Vladimir Davydov <vdavydov@parallels.com>
Cc: Greg KH <greg@kroah.com>
Cc: Christoph Lameter <cl@linux.com>
Cc: Pekka Enberg <penberg@kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2014-04-04 04:48:21 +07:00
|
|
|
char *argv[3];
|
2007-08-14 20:15:12 +07:00
|
|
|
char *envp[UEVENT_NUM_ENVP];
|
|
|
|
int envp_idx;
|
|
|
|
char buf[UEVENT_BUFFER_SIZE];
|
|
|
|
int buflen;
|
|
|
|
};
|
|
|
|
|
2007-07-27 23:36:26 +07:00
|
|
|
struct kset_uevent_ops {
|
2009-12-31 20:52:51 +07:00
|
|
|
int (* const filter)(struct kset *kset, struct kobject *kobj);
|
|
|
|
const char *(* const name)(struct kset *kset, struct kobject *kobj);
|
|
|
|
int (* const uevent)(struct kset *kset, struct kobject *kobj,
|
2007-08-14 20:15:12 +07:00
|
|
|
struct kobj_uevent_env *env);
|
2007-07-27 23:36:26 +07:00
|
|
|
};
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2007-11-02 19:47:53 +07:00
|
|
|
struct kobj_attribute {
|
|
|
|
struct attribute attr;
|
|
|
|
ssize_t (*show)(struct kobject *kobj, struct kobj_attribute *attr,
|
|
|
|
char *buf);
|
|
|
|
ssize_t (*store)(struct kobject *kobj, struct kobj_attribute *attr,
|
|
|
|
const char *buf, size_t count);
|
|
|
|
};
|
|
|
|
|
2010-01-19 08:58:23 +07:00
|
|
|
extern const struct sysfs_ops kobj_sysfs_ops;
|
2007-11-02 19:47:53 +07:00
|
|
|
|
2010-03-31 01:31:25 +07:00
|
|
|
struct sock;
|
2010-05-04 04:23:15 +07:00
|
|
|
|
2007-09-28 04:48:53 +07:00
|
|
|
/**
|
|
|
|
* struct kset - a set of kobjects of a specific type, belonging to a specific subsystem.
|
2005-04-17 05:20:36 +07:00
|
|
|
*
|
2007-09-28 04:48:53 +07:00
|
|
|
* A kset defines a group of kobjects. They can be individually
|
|
|
|
* different "types" but overall these kobjects all want to be grouped
|
|
|
|
* together and operated on in the same manner. ksets are used to
|
|
|
|
* define the attribute callbacks and other common events that happen to
|
|
|
|
* a kobject.
|
2005-04-17 05:20:36 +07:00
|
|
|
*
|
2007-09-28 04:48:53 +07:00
|
|
|
* @list: the list of all kobjects for this kset
|
|
|
|
* @list_lock: a lock for iterating over the kobjects
|
|
|
|
* @kobj: the embedded kobject for this kset (recursion, isn't it fun...)
|
|
|
|
* @uevent_ops: the set of uevent operations for this kset. These are
|
|
|
|
* called whenever a kobject has something happen to it so that the kset
|
|
|
|
* can add new environment variables, or filter out the uevents if so
|
|
|
|
* desired.
|
2005-04-17 05:20:36 +07:00
|
|
|
*/
|
|
|
|
struct kset {
|
2008-01-25 12:27:06 +07:00
|
|
|
struct list_head list;
|
|
|
|
spinlock_t list_lock;
|
|
|
|
struct kobject kobj;
|
2009-12-31 20:52:51 +07:00
|
|
|
const struct kset_uevent_ops *uevent_ops;
|
2016-10-28 15:22:25 +07:00
|
|
|
} __randomize_layout;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2008-01-25 12:27:06 +07:00
|
|
|
extern void kset_init(struct kset *kset);
|
|
|
|
extern int __must_check kset_register(struct kset *kset);
|
|
|
|
extern void kset_unregister(struct kset *kset);
|
2007-09-28 04:48:53 +07:00
|
|
|
extern struct kset * __must_check kset_create_and_add(const char *name,
|
2009-12-31 20:52:51 +07:00
|
|
|
const struct kset_uevent_ops *u,
|
2007-09-28 04:48:53 +07:00
|
|
|
struct kobject *parent_kobj);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2008-01-25 12:27:06 +07:00
|
|
|
static inline struct kset *to_kset(struct kobject *kobj)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2008-01-25 12:27:06 +07:00
|
|
|
return kobj ? container_of(kobj, struct kset, kobj) : NULL;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2008-01-25 12:27:06 +07:00
|
|
|
static inline struct kset *kset_get(struct kset *k)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
return k ? to_kset(kobject_get(&k->kobj)) : NULL;
|
|
|
|
}
|
|
|
|
|
2008-01-25 12:27:06 +07:00
|
|
|
static inline void kset_put(struct kset *k)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
kobject_put(&k->kobj);
|
|
|
|
}
|
|
|
|
|
2007-10-16 23:11:44 +07:00
|
|
|
static inline struct kobj_type *get_ktype(struct kobject *kobj)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2007-10-16 23:11:44 +07:00
|
|
|
return kobj->ktype;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2008-01-25 12:27:06 +07:00
|
|
|
extern struct kobject *kset_find_obj(struct kset *, const char *);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2007-11-07 01:36:58 +07:00
|
|
|
/* The global /sys/kernel/ kobject for people to chain off of */
|
|
|
|
extern struct kobject *kernel_kobj;
|
2008-07-24 11:27:39 +07:00
|
|
|
/* The global /sys/kernel/mm/ kobject for people to chain off of */
|
|
|
|
extern struct kobject *mm_kobj;
|
2007-11-01 22:29:06 +07:00
|
|
|
/* The global /sys/hypervisor/ kobject for people to chain off of */
|
|
|
|
extern struct kobject *hypervisor_kobj;
|
2007-11-28 02:28:26 +07:00
|
|
|
/* The global /sys/power/ kobject for people to chain off of */
|
|
|
|
extern struct kobject *power_kobj;
|
2007-11-06 04:16:15 +07:00
|
|
|
/* The global /sys/firmware/ kobject for people to chain off of */
|
|
|
|
extern struct kobject *firmware_kobj;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2006-12-20 04:01:27 +07:00
|
|
|
int kobject_uevent(struct kobject *kobj, enum kobject_action action);
|
|
|
|
int kobject_uevent_env(struct kobject *kobj, enum kobject_action action,
|
2006-11-20 23:07:51 +07:00
|
|
|
char *envp[]);
|
kobject: support passing in variables for synthetic uevents
This patch makes it possible to pass additional arguments in addition
to uevent action name when writing /sys/.../uevent attribute. These
additional arguments are then inserted into generated synthetic uevent
as additional environment variables.
Before, we were not able to pass any additional uevent environment
variables for synthetic uevents. This made it hard to identify such uevents
properly in userspace to make proper distinction between genuine uevents
originating from kernel and synthetic uevents triggered from userspace.
Also, it was not possible to pass any additional information which would
make it possible to optimize and change the way the synthetic uevents are
processed back in userspace based on the originating environment of the
triggering action in userspace. With the extra additional variables, we are
able to pass through this extra information needed and also it makes it
possible to synchronize with such synthetic uevents as they can be clearly
identified back in userspace.
The format for writing the uevent attribute is following:
ACTION [UUID [KEY=VALUE ...]
There's no change in how "ACTION" is recognized - it stays the same
("add", "change", "remove"). The "ACTION" is the only argument required
to generate synthetic uevent, the rest of arguments, that this patch
adds support for, are optional.
The "UUID" is considered as transaction identifier so it's possible to
use the same UUID value for one or more synthetic uevents in which case
we logically group these uevents together for any userspace listeners.
The "UUID" is expected to be in "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"
format where "x" is a hex digit. The value appears in uevent as
"SYNTH_UUID=xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" environment variable.
The "KEY=VALUE" pairs can contain alphanumeric characters only. It's
possible to define zero or more more pairs - each pair is then delimited
by a space character " ". Each pair appears in synthetic uevents as
"SYNTH_ARG_KEY=VALUE" environment variable. That means the KEY name gains
"SYNTH_ARG_" prefix to avoid possible collisions with existing variables.
To pass the "KEY=VALUE" pairs, it's also required to pass in the "UUID"
part for the synthetic uevent first.
If "UUID" is not passed in, the generated synthetic uevent gains
"SYNTH_UUID=0" environment variable automatically so it's possible to
identify this situation in userspace when reading generated uevent and so
we can still make a difference between genuine and synthetic uevents.
Signed-off-by: Peter Rajnoha <prajnoha@redhat.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2017-05-09 20:22:30 +07:00
|
|
|
int kobject_synth_uevent(struct kobject *kobj, const char *buf, size_t count);
|
2005-11-11 11:33:52 +07:00
|
|
|
|
2011-11-01 07:11:33 +07:00
|
|
|
__printf(2, 3)
|
|
|
|
int add_uevent_var(struct kobj_uevent_env *env, const char *format, ...);
|
2007-08-13 01:43:55 +07:00
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
#endif /* _KOBJECT_H_ */
|