[linux.git] / lib / kobject_uevent.c

/*
 * kernel userspace event delivery
 *
 * Copyright (C) 2004 Red Hat, Inc.  All rights reserved.
 * Copyright (C) 2004 Novell, Inc.  All rights reserved.
 * Copyright (C) 2004 IBM, Inc. All rights reserved.
 *
 * Licensed under the GNU GPL v2.
 *
 * Authors:
 *	Robert Love		<[email protected]>
 *	Kay Sievers		<[email protected]>
 *	Arjan van de Ven	<[email protected]>
 *	Greg Kroah-Hartman	<[email protected]>
 */

#include <linux/spinlock.h>
#include <linux/socket.h>
#include <linux/skbuff.h>
#include <linux/netlink.h>
#include <linux/string.h>
#include <linux/kobject_uevent.h>
#include <linux/kobject.h>
#include <net/sock.h>

#define BUFFER_SIZE	1024	/* buffer for the hotplug env */
#define NUM_ENVP	32	/* number of env pointers */

#if defined(CONFIG_KOBJECT_UEVENT) || defined(CONFIG_HOTPLUG)
static char *action_to_string(enum kobject_action action)
{
	switch (action) {
	case KOBJ_ADD:
		return "add";
	case KOBJ_REMOVE:
		return "remove";
	case KOBJ_CHANGE:
		return "change";
	case KOBJ_MOUNT:
		return "mount";
	case KOBJ_UMOUNT:
		return "umount";
	case KOBJ_OFFLINE:
		return "offline";
	case KOBJ_ONLINE:
		return "online";
	default:
		return NULL;
	}
}
#endif

#ifdef CONFIG_KOBJECT_UEVENT
static struct sock *uevent_sock;

/**
 * send_uevent - notify userspace by sending event trough netlink socket
 *
 * @signal: signal name
 * @obj: object path (kobject)
 * @envp: possible hotplug environment to pass with the message
 * @gfp_mask:
 */
static int send_uevent(const char *signal, const char *obj,
		       char **envp, int gfp_mask)
{
	struct sk_buff *skb;
	char *pos;
	int len;

	if (!uevent_sock)
		return -EIO;

	len = strlen(signal) + 1;
	len += strlen(obj) + 1;

	/* allocate buffer with the maximum possible message size */
	skb = alloc_skb(len + BUFFER_SIZE, gfp_mask);
	if (!skb)
		return -ENOMEM;

	pos = skb_put(skb, len);
	sprintf(pos, "%s@%s", signal, obj);

	/* copy the environment key by key to our continuous buffer */
	if (envp) {
		int i;

		for (i = 2; envp[i]; i++) {
			len = strlen(envp[i]) + 1;
			pos = skb_put(skb, len);
			strcpy(pos, envp[i]);
		}
	}

	return netlink_broadcast(uevent_sock, skb, 0, 1, gfp_mask);
}

static int do_kobject_uevent(struct kobject *kobj, enum kobject_action action, 
			     struct attribute *attr, int gfp_mask)
{
	char *path;
	char *attrpath;
	char *signal;
	int len;
	int rc = -ENOMEM;

	path = kobject_get_path(kobj, gfp_mask);
	if (!path)
		return -ENOMEM;

	signal = action_to_string(action);
	if (!signal)
		return -EINVAL;

	if (attr) {
		len = strlen(path);
		len += strlen(attr->name) + 2;
		attrpath = kmalloc(len, gfp_mask);
		if (!attrpath)
			goto exit;
		sprintf(attrpath, "%s/%s", path, attr->name);
		rc = send_uevent(signal, attrpath, NULL, gfp_mask);
		kfree(attrpath);
	} else
		rc = send_uevent(signal, path, NULL, gfp_mask);

exit:
	kfree(path);
	return rc;
}

/**
 * kobject_uevent - notify userspace by sending event through netlink socket
 * 
 * @signal: signal name
 * @kobj: struct kobject that the event is happening to
 * @attr: optional struct attribute the event belongs to
 */
int kobject_uevent(struct kobject *kobj, enum kobject_action action,
		   struct attribute *attr)
{
	return do_kobject_uevent(kobj, action, attr, GFP_KERNEL);
}
EXPORT_SYMBOL_GPL(kobject_uevent);

int kobject_uevent_atomic(struct kobject *kobj, enum kobject_action action,
			  struct attribute *attr)
{
	return do_kobject_uevent(kobj, action, attr, GFP_ATOMIC);
}
EXPORT_SYMBOL_GPL(kobject_uevent_atomic);

static int __init kobject_uevent_init(void)
{
	uevent_sock = netlink_kernel_create(NETLINK_KOBJECT_UEVENT, NULL);

	if (!uevent_sock) {
		printk(KERN_ERR
		       "kobject_uevent: unable to create netlink socket!\n");
		return -ENODEV;
	}

	return 0;
}

postcore_initcall(kobject_uevent_init);

#else
static inline int send_uevent(const char *signal, const char *obj,
			      char **envp, int gfp_mask)
{
	return 0;
}

#endif /* CONFIG_KOBJECT_UEVENT */


#ifdef CONFIG_HOTPLUG
char hotplug_path[HOTPLUG_PATH_LEN] = "/sbin/hotplug";
u64 hotplug_seqnum;
static DEFINE_SPINLOCK(sequence_lock);

/**
 * kobject_hotplug - notify userspace by executing /sbin/hotplug
 *
 * @action: action that is happening (usually "ADD" or "REMOVE")
 * @kobj: struct kobject that the action is happening to
 */
void kobject_hotplug(struct kobject *kobj, enum kobject_action action)
{
	char *argv [3];
	char **envp = NULL;
	char *buffer = NULL;
	char *seq_buff;
	char *scratch;
	int i = 0;
	int retval;
	char *kobj_path = NULL;
	char *name = NULL;
	char *action_string;
	u64 seq;
	struct kobject *top_kobj = kobj;
	struct kset *kset;
	static struct kset_hotplug_ops null_hotplug_ops;
	struct kset_hotplug_ops *hotplug_ops = &null_hotplug_ops;

	/* If this kobj does not belong to a kset,
	   try to find a parent that does. */
	if (!top_kobj->kset && top_kobj->parent) {
		do {
			top_kobj = top_kobj->parent;
		} while (!top_kobj->kset && top_kobj->parent);
	}

	if (top_kobj->kset)
		kset = top_kobj->kset;
	else
		return;

	if (kset->hotplug_ops)
		hotplug_ops = kset->hotplug_ops;

	/* If the kset has a filter operation, call it.
	   Skip the event, if the filter returns zero. */
	if (hotplug_ops->filter) {
		if (!hotplug_ops->filter(kset, kobj))
			return;
	}

	pr_debug ("%s\n", __FUNCTION__);

	action_string = action_to_string(action);
	if (!action_string)
		return;

	envp = kmalloc(NUM_ENVP * sizeof (char *), GFP_KERNEL);
	if (!envp)
		return;
	memset (envp, 0x00, NUM_ENVP * sizeof (char *));

	buffer = kmalloc(BUFFER_SIZE, GFP_KERNEL);
	if (!buffer)
		goto exit;

	if (hotplug_ops->name)
		name = hotplug_ops->name(kset, kobj);
	if (name == NULL)
		name = kset->kobj.name;

	argv [0] = hotplug_path;
	argv [1] = name;
	argv [2] = NULL;

	/* minimal command environment */
	envp [i++] = "HOME=/";
	envp [i++] = "PATH=/sbin:/bin:/usr/sbin:/usr/bin";

	scratch = buffer;

	envp [i++] = scratch;
	scratch += sprintf(scratch, "ACTION=%s", action_string) + 1;

	kobj_path = kobject_get_path(kobj, GFP_KERNEL);
	if (!kobj_path)
		goto exit;

	envp [i++] = scratch;
	scratch += sprintf (scratch, "DEVPATH=%s", kobj_path) + 1;

	envp [i++] = scratch;
	scratch += sprintf(scratch, "SUBSYSTEM=%s", name) + 1;

	/* reserve space for the sequence,
	 * put the real one in after the hotplug call */
	envp[i++] = seq_buff = scratch;
	scratch += strlen("SEQNUM=18446744073709551616") + 1;

	if (hotplug_ops->hotplug) {
		/* have the kset specific function add its stuff */
		retval = hotplug_ops->hotplug (kset, kobj,
				  &envp[i], NUM_ENVP - i, scratch,
				  BUFFER_SIZE - (scratch - buffer));
		if (retval) {
			pr_debug ("%s - hotplug() returned %d\n",
				  __FUNCTION__, retval);
			goto exit;
		}
	}

	spin_lock(&sequence_lock);
	seq = ++hotplug_seqnum;
	spin_unlock(&sequence_lock);
	sprintf(seq_buff, "SEQNUM=%llu", (unsigned long long)seq);

	pr_debug ("%s: %s %s seq=%llu %s %s %s %s %s\n",
		  __FUNCTION__, argv[0], argv[1], (unsigned long long)seq,
		  envp[0], envp[1], envp[2], envp[3], envp[4]);

	send_uevent(action_string, kobj_path, envp, GFP_KERNEL);

	if (!hotplug_path[0])
		goto exit;

	retval = call_usermodehelper (argv[0], argv, envp, 0);
	if (retval)
		pr_debug ("%s - call_usermodehelper returned %d\n",
			  __FUNCTION__, retval);

exit:
	kfree(kobj_path);
	kfree(buffer);
	kfree(envp);
	return;
}
EXPORT_SYMBOL(kobject_hotplug);

/**
 * add_hotplug_env_var - helper for creating hotplug environment variables
 * @envp: Pointer to table of environment variables, as passed into
 * hotplug() method.
 * @num_envp: Number of environment variable slots available, as
 * passed into hotplug() method.
 * @cur_index: Pointer to current index into @envp.  It should be
 * initialized to 0 before the first call to add_hotplug_env_var(),
 * and will be incremented on success.
 * @buffer: Pointer to buffer for environment variables, as passed
 * into hotplug() method.
 * @buffer_size: Length of @buffer, as passed into hotplug() method.
 * @cur_len: Pointer to current length of space used in @buffer.
 * Should be initialized to 0 before the first call to
 * add_hotplug_env_var(), and will be incremented on success.
 * @format: Format for creating environment variable (of the form
 * "XXX=%x") for snprintf().
 *
 * Returns 0 if environment variable was added successfully or -ENOMEM
 * if no space was available.
 */
int add_hotplug_env_var(char **envp, int num_envp, int *cur_index,
			char *buffer, int buffer_size, int *cur_len,
			const char *format, ...)
{
	va_list args;

	/*
	 * We check against num_envp - 1 to make sure there is at
	 * least one slot left after we return, since the hotplug
	 * method needs to set the last slot to NULL.
	 */
	if (*cur_index >= num_envp - 1)
		return -ENOMEM;

	envp[*cur_index] = buffer + *cur_len;

	va_start(args, format);
	*cur_len += vsnprintf(envp[*cur_index],
			      max(buffer_size - *cur_len, 0),
			      format, args) + 1;
	va_end(args);

	if (*cur_len > buffer_size)
		return -ENOMEM;

	(*cur_index)++;
	return 0;
}
EXPORT_SYMBOL(add_hotplug_env_var);

#endif /* CONFIG_HOTPLUG */
Commit	Line	Data
1da177e4 LT	1	/*
	2	* kernel userspace event delivery
	3	*
	4	* Copyright (C) 2004 Red Hat, Inc. All rights reserved.
	5	* Copyright (C) 2004 Novell, Inc. All rights reserved.
	6	* Copyright (C) 2004 IBM, Inc. All rights reserved.
	7	*
	8	* Licensed under the GNU GPL v2.
	9	*
	10	* Authors:
	11	* Robert Love <[email protected]>
	12	* Kay Sievers <[email protected]>
	13	* Arjan van de Ven <[email protected]>
	14	* Greg Kroah-Hartman <[email protected]>
	15	*/
	16
	17	#include <linux/spinlock.h>
	18	#include <linux/socket.h>
	19	#include <linux/skbuff.h>
	20	#include <linux/netlink.h>
	21	#include <linux/string.h>
	22	#include <linux/kobject_uevent.h>
	23	#include <linux/kobject.h>
	24	#include <net/sock.h>
	25
	26	#define BUFFER_SIZE 1024 /* buffer for the hotplug env */
	27	#define NUM_ENVP 32 /* number of env pointers */
	28
	29	#if defined(CONFIG_KOBJECT_UEVENT) \|\| defined(CONFIG_HOTPLUG)
	30	static char *action_to_string(enum kobject_action action)
	31	{
	32	switch (action) {
	33	case KOBJ_ADD:
	34	return "add";
	35	case KOBJ_REMOVE:
	36	return "remove";
	37	case KOBJ_CHANGE:
	38	return "change";
	39	case KOBJ_MOUNT:
	40	return "mount";
	41	case KOBJ_UMOUNT:
	42	return "umount";
	43	case KOBJ_OFFLINE:
	44	return "offline";
	45	case KOBJ_ONLINE:
	46	return "online";
	47	default:
	48	return NULL;
	49	}
	50	}
	51	#endif
	52
	53	#ifdef CONFIG_KOBJECT_UEVENT
	54	static struct sock *uevent_sock;
	55
	56	/**
	57	* send_uevent - notify userspace by sending event trough netlink socket
	58	*
	59	* @signal: signal name
	60	* @obj: object path (kobject)
	61	* @envp: possible hotplug environment to pass with the message
	62	* @gfp_mask:
	63	*/
	64	static int send_uevent(const char signal, const char obj,
65	char **envp, int gfp_mask)
66	{
67	struct sk_buff *skb;
68	char *pos;
69	int len;
70
71	if (!uevent_sock)
72	return -EIO;
73
74	len = strlen(signal) + 1;
75	len += strlen(obj) + 1;
76
77	/* allocate buffer with the maximum possible message size */
78	skb = alloc_skb(len + BUFFER_SIZE, gfp_mask);
79	if (!skb)
80	return -ENOMEM;
81
82	pos = skb_put(skb, len);
83	sprintf(pos, "%s@%s", signal, obj);
84
85	/* copy the environment key by key to our continuous buffer */
86	if (envp) {
87	int i;
88
89	for (i = 2; envp[i]; i++) {
90	len = strlen(envp[i]) + 1;
91	pos = skb_put(skb, len);
92	strcpy(pos, envp[i]);
93	}
94	}
95
96	return netlink_broadcast(uevent_sock, skb, 0, 1, gfp_mask);
97	}
98
99	static int do_kobject_uevent(struct kobject *kobj, enum kobject_action action,
100	struct attribute *attr, int gfp_mask)
101	{
102	char *path;
103	char *attrpath;
104	char *signal;
105	int len;
106	int rc = -ENOMEM;
107
108	path = kobject_get_path(kobj, gfp_mask);
109	if (!path)
110	return -ENOMEM;
111
112	signal = action_to_string(action);
113	if (!signal)
114	return -EINVAL;
115
116	if (attr) {
117	len = strlen(path);
118	len += strlen(attr->name) + 2;
119	attrpath = kmalloc(len, gfp_mask);
120	if (!attrpath)
121	goto exit;
122	sprintf(attrpath, "%s/%s", path, attr->name);
123	rc = send_uevent(signal, attrpath, NULL, gfp_mask);
124	kfree(attrpath);
125	} else
126	rc = send_uevent(signal, path, NULL, gfp_mask);
127
128	exit:
129	kfree(path);
130	return rc;
131	}
132
133	/**
134	* kobject_uevent - notify userspace by sending event through netlink socket
135	*
136	* @signal: signal name
137	* @kobj: struct kobject that the event is happening to
138	* @attr: optional struct attribute the event belongs to
139	*/
140	int kobject_uevent(struct kobject *kobj, enum kobject_action action,
141	struct attribute *attr)
142	{
143	return do_kobject_uevent(kobj, action, attr, GFP_KERNEL);
144	}
145	EXPORT_SYMBOL_GPL(kobject_uevent);
146
147	int kobject_uevent_atomic(struct kobject *kobj, enum kobject_action action,
148	struct attribute *attr)
149	{
150	return do_kobject_uevent(kobj, action, attr, GFP_ATOMIC);
151	}
152	EXPORT_SYMBOL_GPL(kobject_uevent_atomic);
153
154	static int __init kobject_uevent_init(void)
155	{
156	uevent_sock = netlink_kernel_create(NETLINK_KOBJECT_UEVENT, NULL);
157
158	if (!uevent_sock) {
159	printk(KERN_ERR
160	"kobject_uevent: unable to create netlink socket!\n");
161	return -ENODEV;
162	}
163
164	return 0;
165	}
166
167	postcore_initcall(kobject_uevent_init);
168
169	#else
170	static inline int send_uevent(const char signal, const char obj,
171	char **envp, int gfp_mask)
172	{
173	return 0;
174	}
175
176	#endif /* CONFIG_KOBJECT_UEVENT */
177
178
179	#ifdef CONFIG_HOTPLUG
180	char hotplug_path[HOTPLUG_PATH_LEN] = "/sbin/hotplug";
181	u64 hotplug_seqnum;
182	static DEFINE_SPINLOCK(sequence_lock);
183
184	/**
185	* kobject_hotplug - notify userspace by executing /sbin/hotplug
186	*
187	* @action: action that is happening (usually "ADD" or "REMOVE")
188	* @kobj: struct kobject that the action is happening to
189	*/
190	void kobject_hotplug(struct kobject *kobj, enum kobject_action action)
191	{
192	char *argv [3];
193	char **envp = NULL;
194	char *buffer = NULL;
195	char *seq_buff;
196	char *scratch;
197	int i = 0;
198	int retval;
199	char *kobj_path = NULL;
200	char *name = NULL;
201	char *action_string;
202	u64 seq;
203	struct kobject *top_kobj = kobj;
204	struct kset *kset;
205	static struct kset_hotplug_ops null_hotplug_ops;
206	struct kset_hotplug_ops *hotplug_ops = &null_hotplug_ops;
207
208	/* If this kobj does not belong to a kset,
209	try to find a parent that does. */
210	if (!top_kobj->kset && top_kobj->parent) {
211	do {
212	top_kobj = top_kobj->parent;
213	} while (!top_kobj->kset && top_kobj->parent);
214	}
215
216	if (top_kobj->kset)
217	kset = top_kobj->kset;
218	else
219	return;
220
221	if (kset->hotplug_ops)
222	hotplug_ops = kset->hotplug_ops;
223
224	/* If the kset has a filter operation, call it.
225	Skip the event, if the filter returns zero. */
226	if (hotplug_ops->filter) {
227	if (!hotplug_ops->filter(kset, kobj))
228	return;
229	}
230
231	pr_debug ("%s\n", __FUNCTION__);
232
233	action_string = action_to_string(action);
234	if (!action_string)
235	return;
236
237	envp = kmalloc(NUM_ENVP * sizeof (char *), GFP_KERNEL);
238	if (!envp)
239	return;
240	memset (envp, 0x00, NUM_ENVP * sizeof (char *));
241
242	buffer = kmalloc(BUFFER_SIZE, GFP_KERNEL);
243	if (!buffer)
244	goto exit;
245
246	if (hotplug_ops->name)
247	name = hotplug_ops->name(kset, kobj);
248	if (name == NULL)
249	name = kset->kobj.name;
250
251	argv [0] = hotplug_path;
252	argv [1] = name;
253	argv [2] = NULL;
254
255	/* minimal command environment */
256	envp [i++] = "HOME=/";
257	envp [i++] = "PATH=/sbin:/bin:/usr/sbin:/usr/bin";
258
259	scratch = buffer;
260
261	envp [i++] = scratch;
262	scratch += sprintf(scratch, "ACTION=%s", action_string) + 1;
263
264	kobj_path = kobject_get_path(kobj, GFP_KERNEL);
265	if (!kobj_path)
266	goto exit;
267
268	envp [i++] = scratch;
269	scratch += sprintf (scratch, "DEVPATH=%s", kobj_path) + 1;
270
271	envp [i++] = scratch;
272	scratch += sprintf(scratch, "SUBSYSTEM=%s", name) + 1;
273
274	/* reserve space for the sequence,
275	* put the real one in after the hotplug call */
276	envp[i++] = seq_buff = scratch;
277	scratch += strlen("SEQNUM=18446744073709551616") + 1;
278
279	if (hotplug_ops->hotplug) {
280	/* have the kset specific function add its stuff */
281	retval = hotplug_ops->hotplug (kset, kobj,
282	&envp[i], NUM_ENVP - i, scratch,
283	BUFFER_SIZE - (scratch - buffer));
284	if (retval) {
285	pr_debug ("%s - hotplug() returned %d\n",
286	__FUNCTION__, retval);
287	goto exit;
288	}
289	}
290
291	spin_lock(&sequence_lock);
292	seq = ++hotplug_seqnum;
293	spin_unlock(&sequence_lock);
294	sprintf(seq_buff, "SEQNUM=%llu", (unsigned long long)seq);
295
296	pr_debug ("%s: %s %s seq=%llu %s %s %s %s %s\n",
297	__FUNCTION__, argv[0], argv[1], (unsigned long long)seq,
298	envp[0], envp[1], envp[2], envp[3], envp[4]);
299
300	send_uevent(action_string, kobj_path, envp, GFP_KERNEL);
301
302	if (!hotplug_path[0])
303	goto exit;
304
305	retval = call_usermodehelper (argv[0], argv, envp, 0);
306	if (retval)
307	pr_debug ("%s - call_usermodehelper returned %d\n",
308	__FUNCTION__, retval);
309
310	exit:
311	kfree(kobj_path);
312	kfree(buffer);
313	kfree(envp);
314	return;
315	}
316	EXPORT_SYMBOL(kobject_hotplug);
317
318	/**
319	* add_hotplug_env_var - helper for creating hotplug environment variables
320	* @envp: Pointer to table of environment variables, as passed into
321	* hotplug() method.
322	* @num_envp: Number of environment variable slots available, as
323	* passed into hotplug() method.
324	* @cur_index: Pointer to current index into @envp. It should be
325	* initialized to 0 before the first call to add_hotplug_env_var(),
326	* and will be incremented on success.
327	* @buffer: Pointer to buffer for environment variables, as passed
328	* into hotplug() method.
329	* @buffer_size: Length of @buffer, as passed into hotplug() method.
330	* @cur_len: Pointer to current length of space used in @buffer.
331	* Should be initialized to 0 before the first call to
332	* add_hotplug_env_var(), and will be incremented on success.
333	* @format: Format for creating environment variable (of the form
334	* "XXX=%x") for snprintf().
335	*
336	* Returns 0 if environment variable was added successfully or -ENOMEM
337	* if no space was available.
338	*/
339	int add_hotplug_env_var(char *envp, int num_envp, int cur_index,
340	char buffer, int buffer_size, int cur_len,
341	const char *format, ...)
342	{
343	va_list args;
344
345	/*
346	* We check against num_envp - 1 to make sure there is at
347	* least one slot left after we return, since the hotplug
348	* method needs to set the last slot to NULL.
349	*/
350	if (*cur_index >= num_envp - 1)
351	return -ENOMEM;
352
353	envp[cur_index] = buffer + cur_len;
354
355	va_start(args, format);
356	cur_len += vsnprintf(envp[cur_index],
357	max(buffer_size - *cur_len, 0),
358	format, args) + 1;
359	va_end(args);
360
361	if (*cur_len > buffer_size)
362	return -ENOMEM;
363
364	(*cur_index)++;
365	return 0;
366	}
367	EXPORT_SYMBOL(add_hotplug_env_var);
368
369	#endif /* CONFIG_HOTPLUG */