file.c 18.9 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1
/*
Tejun Heo's avatar
Tejun Heo committed
2
3
4
5
6
7
8
9
10
 * fs/sysfs/file.c - sysfs regular (text) file 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.
Linus Torvalds's avatar
Linus Torvalds committed
11
12
13
14
 */

#include <linux/module.h>
#include <linux/kobject.h>
15
#include <linux/kallsyms.h>
16
#include <linux/slab.h>
17
#include <linux/fsnotify.h>
18
#include <linux/namei.h>
19
#include <linux/poll.h>
20
#include <linux/list.h>
21
#include <linux/mutex.h>
Andrew Morton's avatar
Andrew Morton committed
22
#include <linux/limits.h>
Linus Torvalds's avatar
Linus Torvalds committed
23
24
25
26
#include <asm/uaccess.h>

#include "sysfs.h"

Tejun Heo's avatar
Tejun Heo committed
27
28
29
30
31
32
33
34
35
/*
 * There's one sysfs_buffer for each open file and one
 * sysfs_open_dirent for each sysfs_dirent with one or more open
 * files.
 *
 * filp->private_data points to sysfs_buffer and
 * sysfs_dirent->s_attr.open points to sysfs_open_dirent.  s_attr.open
 * is protected by sysfs_open_dirent_lock.
 */
Jiri Slaby's avatar
Jiri Slaby committed
36
static DEFINE_SPINLOCK(sysfs_open_dirent_lock);
Tejun Heo's avatar
Tejun Heo committed
37
38
39

struct sysfs_open_dirent {
	atomic_t		refcnt;
40
41
	atomic_t		event;
	wait_queue_head_t	poll;
Tejun Heo's avatar
Tejun Heo committed
42
43
44
	struct list_head	buffers; /* goes through sysfs_buffer.list */
};

45
46
47
48
struct sysfs_buffer {
	size_t			count;
	loff_t			pos;
	char			* page;
49
	const struct sysfs_ops	* ops;
50
	struct mutex		mutex;
51
52
	int			needs_read_fill;
	int			event;
Tejun Heo's avatar
Tejun Heo committed
53
	struct list_head	list;
54
};
Linus Torvalds's avatar
Linus Torvalds committed
55
56
57
58
59
60
61
62
63

/**
 *	fill_read_buffer - allocate and fill buffer from object.
 *	@dentry:	dentry pointer.
 *	@buffer:	data buffer for file.
 *
 *	Allocate @buffer->page, if it hasn't been already, then call the
 *	kobject's show() method to fill the buffer with this attribute's 
 *	data. 
64
65
 *	This is called only once, on the file's first read unless an error
 *	is returned.
Linus Torvalds's avatar
Linus Torvalds committed
66
67
68
 */
static int fill_read_buffer(struct dentry * dentry, struct sysfs_buffer * buffer)
{
69
	struct sysfs_dirent *attr_sd = dentry->d_fsdata;
70
	struct kobject *kobj = attr_sd->s_parent->s_dir.kobj;
71
	const struct sysfs_ops * ops = buffer->ops;
Linus Torvalds's avatar
Linus Torvalds committed
72
73
74
75
76
77
78
79
	int ret = 0;
	ssize_t count;

	if (!buffer->page)
		buffer->page = (char *) get_zeroed_page(GFP_KERNEL);
	if (!buffer->page)
		return -ENOMEM;

80
	/* need attr_sd for attr and ops, its parent for kobj */
81
	if (!sysfs_get_active(attr_sd))
82
83
		return -ENODEV;

84
	buffer->event = atomic_read(&attr_sd->s_attr.open->event);
85
	count = ops->show(kobj, attr_sd->s_attr.attr, buffer->page);
86

87
	sysfs_put_active(attr_sd);
88

89
90
91
92
	/*
	 * The code works fine with PAGE_SIZE return but it's likely to
	 * indicate truncated result or overflow in normal use cases.
	 */
93
94
95
96
97
98
	if (count >= (ssize_t)PAGE_SIZE) {
		print_symbol("fill_read_buffer: %s returned bad count\n",
			(unsigned long)ops->show);
		/* Try to struggle along */
		count = PAGE_SIZE - 1;
	}
99
100
	if (count >= 0) {
		buffer->needs_read_fill = 0;
Linus Torvalds's avatar
Linus Torvalds committed
101
		buffer->count = count;
102
	} else {
Linus Torvalds's avatar
Linus Torvalds committed
103
		ret = count;
104
	}
Linus Torvalds's avatar
Linus Torvalds committed
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
	return ret;
}

/**
 *	sysfs_read_file - read an attribute. 
 *	@file:	file pointer.
 *	@buf:	buffer to fill.
 *	@count:	number of bytes to read.
 *	@ppos:	starting offset in file.
 *
 *	Userspace wants to read an attribute file. The attribute descriptor
 *	is in the file's ->d_fsdata. The target object is in the directory's
 *	->d_fsdata.
 *
 *	We call fill_read_buffer() to allocate and fill the buffer from the
 *	object's show() method exactly once (if the read is happening from
 *	the beginning of the file). That should fill the entire buffer with
 *	all the data the object has to offer for that attribute.
 *	We then call flush_read_buffer() to copy the buffer to userspace
 *	in the increments specified.
 */

static ssize_t
sysfs_read_file(struct file *file, char __user *buf, size_t count, loff_t *ppos)
{
	struct sysfs_buffer * buffer = file->private_data;
	ssize_t retval = 0;

133
	mutex_lock(&buffer->mutex);
134
	if (buffer->needs_read_fill || *ppos == 0) {
135
		retval = fill_read_buffer(file->f_path.dentry,buffer);
136
		if (retval)
Linus Torvalds's avatar
Linus Torvalds committed
137
138
			goto out;
	}
139
	pr_debug("%s: count = %zd, ppos = %lld, buf = %s\n",
140
		 __func__, count, *ppos, buffer->page);
141
142
	retval = simple_read_from_buffer(buf, count, ppos, buffer->page,
					 buffer->count);
Linus Torvalds's avatar
Linus Torvalds committed
143
out:
144
	mutex_unlock(&buffer->mutex);
Linus Torvalds's avatar
Linus Torvalds committed
145
146
147
148
149
150
	return retval;
}

/**
 *	fill_write_buffer - copy buffer from userspace.
 *	@buffer:	data buffer for file.
151
 *	@buf:		data from user.
Linus Torvalds's avatar
Linus Torvalds committed
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
 *	@count:		number of bytes in @userbuf.
 *
 *	Allocate @buffer->page if it hasn't been already, then
 *	copy the user-supplied buffer into it.
 */

static int 
fill_write_buffer(struct sysfs_buffer * buffer, const char __user * buf, size_t count)
{
	int error;

	if (!buffer->page)
		buffer->page = (char *)get_zeroed_page(GFP_KERNEL);
	if (!buffer->page)
		return -ENOMEM;

	if (count >= PAGE_SIZE)
169
		count = PAGE_SIZE - 1;
Linus Torvalds's avatar
Linus Torvalds committed
170
171
	error = copy_from_user(buffer->page,buf,count);
	buffer->needs_read_fill = 1;
172
173
174
	/* if buf is assumed to contain a string, terminate it by \0,
	   so e.g. sscanf() can scan the string easily */
	buffer->page[count] = 0;
Linus Torvalds's avatar
Linus Torvalds committed
175
176
177
178
179
180
	return error ? -EFAULT : count;
}


/**
 *	flush_write_buffer - push buffer to kobject.
181
 *	@dentry:	dentry to the attribute
Linus Torvalds's avatar
Linus Torvalds committed
182
 *	@buffer:	data buffer for file.
183
 *	@count:		number of bytes
Linus Torvalds's avatar
Linus Torvalds committed
184
185
186
187
188
189
 *
 *	Get the correct pointers for the kobject and the attribute we're
 *	dealing with, then call the store() method for the attribute, 
 *	passing the buffer that we acquired in fill_write_buffer().
 */

190
static int
Linus Torvalds's avatar
Linus Torvalds committed
191
192
flush_write_buffer(struct dentry * dentry, struct sysfs_buffer * buffer, size_t count)
{
193
	struct sysfs_dirent *attr_sd = dentry->d_fsdata;
194
	struct kobject *kobj = attr_sd->s_parent->s_dir.kobj;
195
	const struct sysfs_ops * ops = buffer->ops;
196
197
198
	int rc;

	/* need attr_sd for attr and ops, its parent for kobj */
199
	if (!sysfs_get_active(attr_sd))
200
201
		return -ENODEV;

202
	rc = ops->store(kobj, attr_sd->s_attr.attr, buffer->page, count);
203

204
	sysfs_put_active(attr_sd);
Linus Torvalds's avatar
Linus Torvalds committed
205

206
	return rc;
Linus Torvalds's avatar
Linus Torvalds committed
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
}


/**
 *	sysfs_write_file - write an attribute.
 *	@file:	file pointer
 *	@buf:	data to write
 *	@count:	number of bytes
 *	@ppos:	starting offset
 *
 *	Similar to sysfs_read_file(), though working in the opposite direction.
 *	We allocate and fill the data from the user in fill_write_buffer(),
 *	then push it to the kobject in flush_write_buffer().
 *	There is no easy way for us to know if userspace is only doing a partial
 *	write, so we don't support them. We expect the entire buffer to come
 *	on the first write. 
 *	Hint: if you're writing a value, first read the file, modify only the
 *	the value you're changing, then write entire buffer back. 
 */

static ssize_t
sysfs_write_file(struct file *file, const char __user *buf, size_t count, loff_t *ppos)
{
	struct sysfs_buffer * buffer = file->private_data;
	ssize_t len;

233
	mutex_lock(&buffer->mutex);
Linus Torvalds's avatar
Linus Torvalds committed
234
235
	len = fill_write_buffer(buffer, buf, count);
	if (len > 0)
236
		len = flush_write_buffer(file->f_path.dentry, buffer, len);
Linus Torvalds's avatar
Linus Torvalds committed
237
238
	if (len > 0)
		*ppos += len;
239
	mutex_unlock(&buffer->mutex);
Linus Torvalds's avatar
Linus Torvalds committed
240
241
242
	return len;
}

Tejun Heo's avatar
Tejun Heo committed
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
/**
 *	sysfs_get_open_dirent - get or create sysfs_open_dirent
 *	@sd: target sysfs_dirent
 *	@buffer: sysfs_buffer for this instance of open
 *
 *	If @sd->s_attr.open exists, increment its reference count;
 *	otherwise, create one.  @buffer is chained to the buffers
 *	list.
 *
 *	LOCKING:
 *	Kernel thread context (may sleep).
 *
 *	RETURNS:
 *	0 on success, -errno on failure.
 */
static int sysfs_get_open_dirent(struct sysfs_dirent *sd,
				 struct sysfs_buffer *buffer)
{
	struct sysfs_open_dirent *od, *new_od = NULL;

 retry:
264
	spin_lock_irq(&sysfs_open_dirent_lock);
Tejun Heo's avatar
Tejun Heo committed
265
266
267
268
269
270
271
272
273
274
275
276

	if (!sd->s_attr.open && new_od) {
		sd->s_attr.open = new_od;
		new_od = NULL;
	}

	od = sd->s_attr.open;
	if (od) {
		atomic_inc(&od->refcnt);
		list_add_tail(&buffer->list, &od->buffers);
	}

277
	spin_unlock_irq(&sysfs_open_dirent_lock);
Tejun Heo's avatar
Tejun Heo committed
278
279
280
281
282
283
284
285
286
287
288
289

	if (od) {
		kfree(new_od);
		return 0;
	}

	/* not there, initialize a new one and retry */
	new_od = kmalloc(sizeof(*new_od), GFP_KERNEL);
	if (!new_od)
		return -ENOMEM;

	atomic_set(&new_od->refcnt, 0);
290
291
	atomic_set(&new_od->event, 1);
	init_waitqueue_head(&new_od->poll);
Tejun Heo's avatar
Tejun Heo committed
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
	INIT_LIST_HEAD(&new_od->buffers);
	goto retry;
}

/**
 *	sysfs_put_open_dirent - put sysfs_open_dirent
 *	@sd: target sysfs_dirent
 *	@buffer: associated sysfs_buffer
 *
 *	Put @sd->s_attr.open and unlink @buffer from the buffers list.
 *	If reference count reaches zero, disassociate and free it.
 *
 *	LOCKING:
 *	None.
 */
static void sysfs_put_open_dirent(struct sysfs_dirent *sd,
				  struct sysfs_buffer *buffer)
{
	struct sysfs_open_dirent *od = sd->s_attr.open;
311
	unsigned long flags;
Tejun Heo's avatar
Tejun Heo committed
312

313
	spin_lock_irqsave(&sysfs_open_dirent_lock, flags);
Tejun Heo's avatar
Tejun Heo committed
314
315
316
317
318
319
320

	list_del(&buffer->list);
	if (atomic_dec_and_test(&od->refcnt))
		sd->s_attr.open = NULL;
	else
		od = NULL;

321
	spin_unlock_irqrestore(&sysfs_open_dirent_lock, flags);
Tejun Heo's avatar
Tejun Heo committed
322
323
324
325

	kfree(od);
}

326
static int sysfs_open_file(struct inode *inode, struct file *file)
Linus Torvalds's avatar
Linus Torvalds committed
327
{
328
	struct sysfs_dirent *attr_sd = file->f_path.dentry->d_fsdata;
329
	struct kobject *kobj = attr_sd->s_parent->s_dir.kobj;
330
	struct sysfs_buffer *buffer;
331
	const struct sysfs_ops *ops;
332
	int error = -EACCES;
Linus Torvalds's avatar
Linus Torvalds committed
333

334
	/* need attr_sd for attr and ops, its parent for kobj */
335
	if (!sysfs_get_active(attr_sd))
336
		return -ENODEV;
Linus Torvalds's avatar
Linus Torvalds committed
337

338
339
	/* every kobject with an attribute needs a ktype assigned */
	if (kobj->ktype && kobj->ktype->sysfs_ops)
Linus Torvalds's avatar
Linus Torvalds committed
340
		ops = kobj->ktype->sysfs_ops;
341
	else {
Arjan van de Ven's avatar
Arjan van de Ven committed
342
		WARN(1, KERN_ERR "missing sysfs attribute operations for "
343
		       "kobject: %s\n", kobject_name(kobj));
344
		goto err_out;
345
	}
Linus Torvalds's avatar
Linus Torvalds committed
346
347
348
349
350
351
352

	/* File needs write support.
	 * The inode's perms must say it's ok, 
	 * and we must have a store method.
	 */
	if (file->f_mode & FMODE_WRITE) {
		if (!(inode->i_mode & S_IWUGO) || !ops->store)
353
			goto err_out;
Linus Torvalds's avatar
Linus Torvalds committed
354
355
356
357
358
359
360
361
	}

	/* File needs read support.
	 * The inode's perms must say it's ok, and we there
	 * must be a show method for it.
	 */
	if (file->f_mode & FMODE_READ) {
		if (!(inode->i_mode & S_IRUGO) || !ops->show)
362
			goto err_out;
Linus Torvalds's avatar
Linus Torvalds committed
363
364
365
366
367
	}

	/* No error? Great, allocate a buffer for the file, and store it
	 * it in file->private_data for easy access.
	 */
368
	error = -ENOMEM;
369
	buffer = kzalloc(sizeof(struct sysfs_buffer), GFP_KERNEL);
370
	if (!buffer)
371
		goto err_out;
Linus Torvalds's avatar
Linus Torvalds committed
372

373
	mutex_init(&buffer->mutex);
374
375
376
377
	buffer->needs_read_fill = 1;
	buffer->ops = ops;
	file->private_data = buffer;

Tejun Heo's avatar
Tejun Heo committed
378
379
380
381
382
	/* make sure we have open dirent struct */
	error = sysfs_get_open_dirent(attr_sd, buffer);
	if (error)
		goto err_free;

383
	/* open succeeded, put active references */
384
	sysfs_put_active(attr_sd);
385
386
	return 0;

Tejun Heo's avatar
Tejun Heo committed
387
388
 err_free:
	kfree(buffer);
389
 err_out:
390
	sysfs_put_active(attr_sd);
Linus Torvalds's avatar
Linus Torvalds committed
391
392
393
	return error;
}

Tejun Heo's avatar
Tejun Heo committed
394
static int sysfs_release(struct inode *inode, struct file *filp)
Linus Torvalds's avatar
Linus Torvalds committed
395
{
Tejun Heo's avatar
Tejun Heo committed
396
	struct sysfs_dirent *sd = filp->f_path.dentry->d_fsdata;
397
	struct sysfs_buffer *buffer = filp->private_data;
Linus Torvalds's avatar
Linus Torvalds committed
398

Tejun Heo's avatar
Tejun Heo committed
399
400
	sysfs_put_open_dirent(sd, buffer);

401
402
403
404
	if (buffer->page)
		free_page((unsigned long)buffer->page);
	kfree(buffer);

Linus Torvalds's avatar
Linus Torvalds committed
405
406
407
	return 0;
}

408
409
410
411
412
413
414
/* Sysfs attribute files are pollable.  The idea is that you read
 * the content and then you use 'poll' or 'select' to wait for
 * the content to change.  When the content changes (assuming the
 * manager for the kobject supports notification), poll will
 * return POLLERR|POLLPRI, and select will return the fd whether
 * it is waiting for read, write, or exceptions.
 * Once poll/select indicates that the value has changed, you
415
 * need to close and re-open the file, or seek to 0 and read again.
416
417
 * Reminder: this only works for attributes which actively support
 * it, and it is not possible to test an attribute from userspace
418
 * to see if it supports poll (Neither 'poll' nor 'select' return
419
420
421
422
423
 * an appropriate error code).  When in doubt, set a suitable timeout value.
 */
static unsigned int sysfs_poll(struct file *filp, poll_table *wait)
{
	struct sysfs_buffer * buffer = filp->private_data;
424
	struct sysfs_dirent *attr_sd = filp->f_path.dentry->d_fsdata;
425
	struct sysfs_open_dirent *od = attr_sd->s_attr.open;
426
427

	/* need parent for the kobj, grab both */
428
	if (!sysfs_get_active(attr_sd))
429
		goto trigger;
430

431
	poll_wait(filp, &od->poll, wait);
432

433
	sysfs_put_active(attr_sd);
434

435
	if (buffer->event != atomic_read(&od->event))
436
		goto trigger;
437

438
	return DEFAULT_POLLMASK;
439
440
441

 trigger:
	buffer->needs_read_fill = 1;
442
	return DEFAULT_POLLMASK|POLLERR|POLLPRI;
443
444
}

445
446
447
void sysfs_notify_dirent(struct sysfs_dirent *sd)
{
	struct sysfs_open_dirent *od;
448
	unsigned long flags;
449

450
	spin_lock_irqsave(&sysfs_open_dirent_lock, flags);
451
452
453
454
455
456
457

	od = sd->s_attr.open;
	if (od) {
		atomic_inc(&od->event);
		wake_up_interruptible(&od->poll);
	}

458
	spin_unlock_irqrestore(&sysfs_open_dirent_lock, flags);
459
460
461
}
EXPORT_SYMBOL_GPL(sysfs_notify_dirent);

462
void sysfs_notify(struct kobject *k, const char *dir, const char *attr)
463
{
464
	struct sysfs_dirent *sd = k->sd;
465

466
467
468
	mutex_lock(&sysfs_mutex);

	if (sd && dir)
469
470
471
472
		/* Only directories are tagged, so no need to pass
		 * a tag explicitly.
		 */
		sd = sysfs_find_dirent(sd, NULL, dir);
473
	if (sd && attr)
474
		sd = sysfs_find_dirent(sd, NULL, attr);
475
476
	if (sd)
		sysfs_notify_dirent(sd);
477
478

	mutex_unlock(&sysfs_mutex);
479
480
481
}
EXPORT_SYMBOL_GPL(sysfs_notify);

482
const struct file_operations sysfs_file_operations = {
Linus Torvalds's avatar
Linus Torvalds committed
483
484
485
486
487
	.read		= sysfs_read_file,
	.write		= sysfs_write_file,
	.llseek		= generic_file_llseek,
	.open		= sysfs_open_file,
	.release	= sysfs_release,
488
	.poll		= sysfs_poll,
Linus Torvalds's avatar
Linus Torvalds committed
489
490
};

491
492
int sysfs_add_file_mode(struct sysfs_dirent *dir_sd,
			const struct attribute *attr, int type, mode_t amode)
Linus Torvalds's avatar
Linus Torvalds committed
493
{
494
	umode_t mode = (amode & S_IALLUGO) | S_IFREG;
495
	struct sysfs_addrm_cxt acxt;
496
	struct sysfs_dirent *sd;
497
	int rc;
Linus Torvalds's avatar
Linus Torvalds committed
498

499
500
501
	sd = sysfs_new_dirent(attr->name, mode, type);
	if (!sd)
		return -ENOMEM;
502
	sd->s_attr.attr = (void *)attr;
503
	sysfs_dirent_init_lockdep(sd);
Linus Torvalds's avatar
Linus Torvalds committed
504

505
	sysfs_addrm_start(&acxt, dir_sd);
506
507
	rc = sysfs_add_one(&acxt, sd);
	sysfs_addrm_finish(&acxt);
508

509
	if (rc)
510
		sysfs_put(sd);
511

512
	return rc;
Linus Torvalds's avatar
Linus Torvalds committed
513
514
515
}


516
517
518
519
520
521
522
int sysfs_add_file(struct sysfs_dirent *dir_sd, const struct attribute *attr,
		   int type)
{
	return sysfs_add_file_mode(dir_sd, attr, type, attr->mode);
}


Linus Torvalds's avatar
Linus Torvalds committed
523
524
525
/**
 *	sysfs_create_file - create an attribute file for an object.
 *	@kobj:	object we're creating for. 
526
 *	@attr:	attribute descriptor.
Linus Torvalds's avatar
Linus Torvalds committed
527
528
529
530
 */

int sysfs_create_file(struct kobject * kobj, const struct attribute * attr)
{
531
	BUG_ON(!kobj || !kobj->sd || !attr);
Linus Torvalds's avatar
Linus Torvalds committed
532

533
	return sysfs_add_file(kobj->sd, attr, SYSFS_KOBJ_ATTR);
Linus Torvalds's avatar
Linus Torvalds committed
534
535
536

}

537
538
539
540
541
542
543
544
545
546
547
548
int sysfs_create_files(struct kobject *kobj, const struct attribute **ptr)
{
	int err = 0;
	int i;

	for (i = 0; ptr[i] && !err; i++)
		err = sysfs_create_file(kobj, ptr[i]);
	if (err)
		while (--i >= 0)
			sysfs_remove_file(kobj, ptr[i]);
	return err;
}
Linus Torvalds's avatar
Linus Torvalds committed
549

550
551
552
553
554
555
556
557
558
/**
 * sysfs_add_file_to_group - add an attribute file to a pre-existing group.
 * @kobj: object we're acting for.
 * @attr: attribute descriptor.
 * @group: group name.
 */
int sysfs_add_file_to_group(struct kobject *kobj,
		const struct attribute *attr, const char *group)
{
559
	struct sysfs_dirent *dir_sd;
560
561
	int error;

562
	if (group)
563
		dir_sd = sysfs_get_dirent(kobj->sd, NULL, group);
564
565
566
	else
		dir_sd = sysfs_get(kobj->sd);

567
568
569
570
571
572
	if (!dir_sd)
		return -ENOENT;

	error = sysfs_add_file(dir_sd, attr, SYSFS_KOBJ_ATTR);
	sysfs_put(dir_sd);

573
574
575
576
	return error;
}
EXPORT_SYMBOL_GPL(sysfs_add_file_to_group);

577
578
579
580
581
582
583
/**
 * sysfs_chmod_file - update the modified mode value on an object attribute.
 * @kobj: object we're acting for.
 * @attr: attribute descriptor.
 * @mode: file permissions.
 *
 */
584
585
int sysfs_chmod_file(struct kobject *kobj, const struct attribute *attr,
		     mode_t mode)
586
{
587
	struct sysfs_dirent *sd;
588
	struct iattr newattrs;
589
590
	int rc;

591
	mutex_lock(&sysfs_mutex);
592

593
	rc = -ENOENT;
594
	sd = sysfs_find_dirent(kobj->sd, NULL, attr->name);
595
	if (!sd)
596
		goto out;
597

598
	newattrs.ia_mode = (mode & S_IALLUGO) | (sd->s_mode & ~S_IALLUGO);
599
	newattrs.ia_valid = ATTR_MODE;
600
	rc = sysfs_sd_setattr(sd, &newattrs);
601

602
 out:
603
	mutex_unlock(&sysfs_mutex);
604
	return rc;
605
606
607
608
}
EXPORT_SYMBOL_GPL(sysfs_chmod_file);


Linus Torvalds's avatar
Linus Torvalds committed
609
610
611
612
613
614
615
616
617
618
/**
 *	sysfs_remove_file - remove an object attribute.
 *	@kobj:	object we're acting for.
 *	@attr:	attribute descriptor.
 *
 *	Hash the attribute name and kill the victim.
 */

void sysfs_remove_file(struct kobject * kobj, const struct attribute * attr)
{
619
	sysfs_hash_and_remove(kobj->sd, NULL, attr->name);
Linus Torvalds's avatar
Linus Torvalds committed
620
621
}

622
623
624
625
626
627
void sysfs_remove_files(struct kobject * kobj, const struct attribute **ptr)
{
	int i;
	for (i = 0; ptr[i]; i++)
		sysfs_remove_file(kobj, ptr[i]);
}
Linus Torvalds's avatar
Linus Torvalds committed
628

629
630
631
632
633
634
635
636
637
/**
 * sysfs_remove_file_from_group - remove an attribute file from a group.
 * @kobj: object we're acting for.
 * @attr: attribute descriptor.
 * @group: group name.
 */
void sysfs_remove_file_from_group(struct kobject *kobj,
		const struct attribute *attr, const char *group)
{
638
	struct sysfs_dirent *dir_sd;
639

640
	if (group)
641
		dir_sd = sysfs_get_dirent(kobj->sd, NULL, group);
642
643
	else
		dir_sd = sysfs_get(kobj->sd);
644
	if (dir_sd) {
645
		sysfs_hash_and_remove(dir_sd, NULL, attr->name);
646
		sysfs_put(dir_sd);
647
648
649
650
	}
}
EXPORT_SYMBOL_GPL(sysfs_remove_file_from_group);

651
struct sysfs_schedule_callback_struct {
652
653
	struct list_head	workq_list;
	struct kobject		*kobj;
654
655
	void			(*func)(void *);
	void			*data;
656
	struct module		*owner;
657
658
659
	struct work_struct	work;
};

660
static struct workqueue_struct *sysfs_workqueue;
661
662
static DEFINE_MUTEX(sysfs_workq_mutex);
static LIST_HEAD(sysfs_workq);
663
664
665
666
667
668
669
static void sysfs_schedule_callback_work(struct work_struct *work)
{
	struct sysfs_schedule_callback_struct *ss = container_of(work,
			struct sysfs_schedule_callback_struct, work);

	(ss->func)(ss->data);
	kobject_put(ss->kobj);
670
	module_put(ss->owner);
671
672
673
	mutex_lock(&sysfs_workq_mutex);
	list_del(&ss->workq_list);
	mutex_unlock(&sysfs_workq_mutex);
674
675
676
677
678
679
680
681
	kfree(ss);
}

/**
 * sysfs_schedule_callback - helper to schedule a callback for a kobject
 * @kobj: object we're acting for.
 * @func: callback function to invoke later.
 * @data: argument to pass to @func.
682
 * @owner: module owning the callback code
683
684
685
686
687
688
689
690
691
692
693
694
 *
 * sysfs attribute methods must not unregister themselves or their parent
 * kobject (which would amount to the same thing).  Attempts to do so will
 * deadlock, since unregistration is mutually exclusive with driver
 * callbacks.
 *
 * Instead methods can call this routine, which will attempt to allocate
 * and schedule a workqueue request to call back @func with @data as its
 * argument in the workqueue's process context.  @kobj will be pinned
 * until @func returns.
 *
 * Returns 0 if the request was submitted, -ENOMEM if storage could not
695
696
 * be allocated, -ENODEV if a reference to @owner isn't available,
 * -EAGAIN if a callback has already been scheduled for @kobj.
697
698
 */
int sysfs_schedule_callback(struct kobject *kobj, void (*func)(void *),
699
		void *data, struct module *owner)
700
{
701
	struct sysfs_schedule_callback_struct *ss, *tmp;
702

703
704
	if (!try_module_get(owner))
		return -ENODEV;
705
706
707
708

	mutex_lock(&sysfs_workq_mutex);
	list_for_each_entry_safe(ss, tmp, &sysfs_workq, workq_list)
		if (ss->kobj == kobj) {
709
			module_put(owner);
710
711
712
713
714
			mutex_unlock(&sysfs_workq_mutex);
			return -EAGAIN;
		}
	mutex_unlock(&sysfs_workq_mutex);

715
	if (sysfs_workqueue == NULL) {
716
		sysfs_workqueue = create_singlethread_workqueue("sysfsd");
717
718
719
720
721
722
		if (sysfs_workqueue == NULL) {
			module_put(owner);
			return -ENOMEM;
		}
	}

723
	ss = kmalloc(sizeof(*ss), GFP_KERNEL);
724
725
	if (!ss) {
		module_put(owner);
726
		return -ENOMEM;
727
	}
728
729
730
731
	kobject_get(kobj);
	ss->kobj = kobj;
	ss->func = func;
	ss->data = data;
732
	ss->owner = owner;
733
	INIT_WORK(&ss->work, sysfs_schedule_callback_work);
734
735
736
737
	INIT_LIST_HEAD(&ss->workq_list);
	mutex_lock(&sysfs_workq_mutex);
	list_add_tail(&ss->workq_list, &sysfs_workq);
	mutex_unlock(&sysfs_workq_mutex);
738
	queue_work(sysfs_workqueue, &ss->work);
739
740
741
742
	return 0;
}
EXPORT_SYMBOL_GPL(sysfs_schedule_callback);

743

Linus Torvalds's avatar
Linus Torvalds committed
744
745
EXPORT_SYMBOL_GPL(sysfs_create_file);
EXPORT_SYMBOL_GPL(sysfs_remove_file);
746
747
EXPORT_SYMBOL_GPL(sysfs_remove_files);
EXPORT_SYMBOL_GPL(sysfs_create_files);