file.c 19.1 KB
Newer Older
L
Linus Torvalds 已提交
1
/*
T
Tejun Heo 已提交
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.
L
Linus Torvalds 已提交
11 12 13 14
 */

#include <linux/module.h>
#include <linux/kobject.h>
15
#include <linux/kallsyms.h>
16
#include <linux/slab.h>
M
Miklos Szeredi 已提交
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>
A
Andrew Morton 已提交
22
#include <linux/limits.h>
L
Linus Torvalds 已提交
23 24 25 26
#include <asm/uaccess.h>

#include "sysfs.h"

A
Andrew Morton 已提交
27 28 29 30 31 32 33
/* used in crash dumps to help with debugging */
static char last_sysfs_file[PATH_MAX];
void sysfs_printk_last_file(void)
{
	printk(KERN_EMERG "last sysfs file: %s\n", last_sysfs_file);
}

T
Tejun Heo 已提交
34 35 36 37 38 39 40 41 42
/*
 * 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.
 */
J
Jiri Slaby 已提交
43
static DEFINE_SPINLOCK(sysfs_open_dirent_lock);
T
Tejun Heo 已提交
44 45 46

struct sysfs_open_dirent {
	atomic_t		refcnt;
47 48
	atomic_t		event;
	wait_queue_head_t	poll;
T
Tejun Heo 已提交
49 50 51
	struct list_head	buffers; /* goes through sysfs_buffer.list */
};

T
Tejun Heo 已提交
52 53 54 55
struct sysfs_buffer {
	size_t			count;
	loff_t			pos;
	char			* page;
56
	const struct sysfs_ops	* ops;
57
	struct mutex		mutex;
T
Tejun Heo 已提交
58 59
	int			needs_read_fill;
	int			event;
T
Tejun Heo 已提交
60
	struct list_head	list;
T
Tejun Heo 已提交
61
};
L
Linus Torvalds 已提交
62 63 64 65 66 67 68 69 70

/**
 *	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. 
71 72
 *	This is called only once, on the file's first read unless an error
 *	is returned.
L
Linus Torvalds 已提交
73 74 75
 */
static int fill_read_buffer(struct dentry * dentry, struct sysfs_buffer * buffer)
{
76
	struct sysfs_dirent *attr_sd = dentry->d_fsdata;
T
Tejun Heo 已提交
77
	struct kobject *kobj = attr_sd->s_parent->s_dir.kobj;
78
	const struct sysfs_ops * ops = buffer->ops;
L
Linus Torvalds 已提交
79 80 81 82 83 84 85 86
	int ret = 0;
	ssize_t count;

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

87
	/* need attr_sd for attr and ops, its parent for kobj */
88
	if (!sysfs_get_active(attr_sd))
89 90
		return -ENODEV;

91
	buffer->event = atomic_read(&attr_sd->s_attr.open->event);
T
Tejun Heo 已提交
92
	count = ops->show(kobj, attr_sd->s_attr.attr, buffer->page);
93

94
	sysfs_put_active(attr_sd);
95

96 97 98 99
	/*
	 * The code works fine with PAGE_SIZE return but it's likely to
	 * indicate truncated result or overflow in normal use cases.
	 */
100 101 102 103 104 105
	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;
	}
106 107
	if (count >= 0) {
		buffer->needs_read_fill = 0;
L
Linus Torvalds 已提交
108
		buffer->count = count;
109
	} else {
L
Linus Torvalds 已提交
110
		ret = count;
111
	}
L
Linus Torvalds 已提交
112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139
	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;

140
	mutex_lock(&buffer->mutex);
141
	if (buffer->needs_read_fill || *ppos == 0) {
T
Tejun Heo 已提交
142
		retval = fill_read_buffer(file->f_path.dentry,buffer);
143
		if (retval)
L
Linus Torvalds 已提交
144 145
			goto out;
	}
146
	pr_debug("%s: count = %zd, ppos = %lld, buf = %s\n",
147
		 __func__, count, *ppos, buffer->page);
148 149
	retval = simple_read_from_buffer(buf, count, ppos, buffer->page,
					 buffer->count);
L
Linus Torvalds 已提交
150
out:
151
	mutex_unlock(&buffer->mutex);
L
Linus Torvalds 已提交
152 153 154 155 156 157
	return retval;
}

/**
 *	fill_write_buffer - copy buffer from userspace.
 *	@buffer:	data buffer for file.
158
 *	@buf:		data from user.
L
Linus Torvalds 已提交
159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175
 *	@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)
176
		count = PAGE_SIZE - 1;
L
Linus Torvalds 已提交
177 178
	error = copy_from_user(buffer->page,buf,count);
	buffer->needs_read_fill = 1;
179 180 181
	/* 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;
L
Linus Torvalds 已提交
182 183 184 185 186 187
	return error ? -EFAULT : count;
}


/**
 *	flush_write_buffer - push buffer to kobject.
M
Martin Waitz 已提交
188
 *	@dentry:	dentry to the attribute
L
Linus Torvalds 已提交
189
 *	@buffer:	data buffer for file.
M
Martin Waitz 已提交
190
 *	@count:		number of bytes
L
Linus Torvalds 已提交
191 192 193 194 195 196
 *
 *	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().
 */

197
static int
L
Linus Torvalds 已提交
198 199
flush_write_buffer(struct dentry * dentry, struct sysfs_buffer * buffer, size_t count)
{
200
	struct sysfs_dirent *attr_sd = dentry->d_fsdata;
T
Tejun Heo 已提交
201
	struct kobject *kobj = attr_sd->s_parent->s_dir.kobj;
202
	const struct sysfs_ops * ops = buffer->ops;
203 204 205
	int rc;

	/* need attr_sd for attr and ops, its parent for kobj */
206
	if (!sysfs_get_active(attr_sd))
207 208
		return -ENODEV;

T
Tejun Heo 已提交
209
	rc = ops->store(kobj, attr_sd->s_attr.attr, buffer->page, count);
210

211
	sysfs_put_active(attr_sd);
L
Linus Torvalds 已提交
212

213
	return rc;
L
Linus Torvalds 已提交
214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239
}


/**
 *	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;

240
	mutex_lock(&buffer->mutex);
L
Linus Torvalds 已提交
241 242
	len = fill_write_buffer(buffer, buf, count);
	if (len > 0)
243
		len = flush_write_buffer(file->f_path.dentry, buffer, len);
L
Linus Torvalds 已提交
244 245
	if (len > 0)
		*ppos += len;
246
	mutex_unlock(&buffer->mutex);
L
Linus Torvalds 已提交
247 248 249
	return len;
}

T
Tejun Heo 已提交
250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270
/**
 *	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:
271
	spin_lock_irq(&sysfs_open_dirent_lock);
T
Tejun Heo 已提交
272 273 274 275 276 277 278 279 280 281 282 283

	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);
	}

284
	spin_unlock_irq(&sysfs_open_dirent_lock);
T
Tejun Heo 已提交
285 286 287 288 289 290 291 292 293 294 295 296

	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);
297 298
	atomic_set(&new_od->event, 1);
	init_waitqueue_head(&new_od->poll);
T
Tejun Heo 已提交
299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317
	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;
318
	unsigned long flags;
T
Tejun Heo 已提交
319

320
	spin_lock_irqsave(&sysfs_open_dirent_lock, flags);
T
Tejun Heo 已提交
321 322 323 324 325 326 327

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

328
	spin_unlock_irqrestore(&sysfs_open_dirent_lock, flags);
T
Tejun Heo 已提交
329 330 331 332

	kfree(od);
}

333
static int sysfs_open_file(struct inode *inode, struct file *file)
L
Linus Torvalds 已提交
334
{
335
	struct sysfs_dirent *attr_sd = file->f_path.dentry->d_fsdata;
T
Tejun Heo 已提交
336
	struct kobject *kobj = attr_sd->s_parent->s_dir.kobj;
337
	struct sysfs_buffer *buffer;
338
	const struct sysfs_ops *ops;
339
	int error = -EACCES;
A
Andrew Morton 已提交
340 341 342 343 344
	char *p;

	p = d_path(&file->f_path, last_sysfs_file, sizeof(last_sysfs_file));
	if (p)
		memmove(last_sysfs_file, p, strlen(p) + 1);
L
Linus Torvalds 已提交
345

346
	/* need attr_sd for attr and ops, its parent for kobj */
347
	if (!sysfs_get_active(attr_sd))
348
		return -ENODEV;
L
Linus Torvalds 已提交
349

350 351
	/* every kobject with an attribute needs a ktype assigned */
	if (kobj->ktype && kobj->ktype->sysfs_ops)
L
Linus Torvalds 已提交
352
		ops = kobj->ktype->sysfs_ops;
353
	else {
A
Arjan van de Ven 已提交
354
		WARN(1, KERN_ERR "missing sysfs attribute operations for "
355
		       "kobject: %s\n", kobject_name(kobj));
356
		goto err_out;
357
	}
L
Linus Torvalds 已提交
358 359 360 361 362 363 364

	/* 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)
365
			goto err_out;
L
Linus Torvalds 已提交
366 367 368 369 370 371 372 373
	}

	/* 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)
374
			goto err_out;
L
Linus Torvalds 已提交
375 376 377 378 379
	}

	/* No error? Great, allocate a buffer for the file, and store it
	 * it in file->private_data for easy access.
	 */
380
	error = -ENOMEM;
381
	buffer = kzalloc(sizeof(struct sysfs_buffer), GFP_KERNEL);
382
	if (!buffer)
383
		goto err_out;
L
Linus Torvalds 已提交
384

385
	mutex_init(&buffer->mutex);
386 387 388 389
	buffer->needs_read_fill = 1;
	buffer->ops = ops;
	file->private_data = buffer;

T
Tejun Heo 已提交
390 391 392 393 394
	/* make sure we have open dirent struct */
	error = sysfs_get_open_dirent(attr_sd, buffer);
	if (error)
		goto err_free;

395
	/* open succeeded, put active references */
396
	sysfs_put_active(attr_sd);
397 398
	return 0;

T
Tejun Heo 已提交
399 400
 err_free:
	kfree(buffer);
401
 err_out:
402
	sysfs_put_active(attr_sd);
L
Linus Torvalds 已提交
403 404 405
	return error;
}

T
Tejun Heo 已提交
406
static int sysfs_release(struct inode *inode, struct file *filp)
L
Linus Torvalds 已提交
407
{
T
Tejun Heo 已提交
408
	struct sysfs_dirent *sd = filp->f_path.dentry->d_fsdata;
T
Tejun Heo 已提交
409
	struct sysfs_buffer *buffer = filp->private_data;
L
Linus Torvalds 已提交
410

T
Tejun Heo 已提交
411 412
	sysfs_put_open_dirent(sd, buffer);

413 414 415 416
	if (buffer->page)
		free_page((unsigned long)buffer->page);
	kfree(buffer);

L
Linus Torvalds 已提交
417 418 419
	return 0;
}

420 421 422 423 424 425 426
/* 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
427
 * need to close and re-open the file, or seek to 0 and read again.
428 429
 * Reminder: this only works for attributes which actively support
 * it, and it is not possible to test an attribute from userspace
430
 * to see if it supports poll (Neither 'poll' nor 'select' return
431 432 433 434 435
 * 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;
436
	struct sysfs_dirent *attr_sd = filp->f_path.dentry->d_fsdata;
437
	struct sysfs_open_dirent *od = attr_sd->s_attr.open;
438 439

	/* need parent for the kobj, grab both */
440
	if (!sysfs_get_active(attr_sd))
441
		goto trigger;
442

443
	poll_wait(filp, &od->poll, wait);
444

445
	sysfs_put_active(attr_sd);
446

447
	if (buffer->event != atomic_read(&od->event))
448
		goto trigger;
449

450
	return DEFAULT_POLLMASK;
451 452 453

 trigger:
	buffer->needs_read_fill = 1;
454
	return DEFAULT_POLLMASK|POLLERR|POLLPRI;
455 456
}

457 458 459
void sysfs_notify_dirent(struct sysfs_dirent *sd)
{
	struct sysfs_open_dirent *od;
460
	unsigned long flags;
461

462
	spin_lock_irqsave(&sysfs_open_dirent_lock, flags);
463 464 465 466 467 468 469

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

470
	spin_unlock_irqrestore(&sysfs_open_dirent_lock, flags);
471 472 473
}
EXPORT_SYMBOL_GPL(sysfs_notify_dirent);

474
void sysfs_notify(struct kobject *k, const char *dir, const char *attr)
475
{
476
	struct sysfs_dirent *sd = k->sd;
477

478 479 480 481 482 483
	mutex_lock(&sysfs_mutex);

	if (sd && dir)
		sd = sysfs_find_dirent(sd, dir);
	if (sd && attr)
		sd = sysfs_find_dirent(sd, attr);
484 485
	if (sd)
		sysfs_notify_dirent(sd);
486 487

	mutex_unlock(&sysfs_mutex);
488 489 490
}
EXPORT_SYMBOL_GPL(sysfs_notify);

491
const struct file_operations sysfs_file_operations = {
L
Linus Torvalds 已提交
492 493 494 495 496
	.read		= sysfs_read_file,
	.write		= sysfs_write_file,
	.llseek		= generic_file_llseek,
	.open		= sysfs_open_file,
	.release	= sysfs_release,
497
	.poll		= sysfs_poll,
L
Linus Torvalds 已提交
498 499
};

500 501
int sysfs_add_file_mode(struct sysfs_dirent *dir_sd,
			const struct attribute *attr, int type, mode_t amode)
L
Linus Torvalds 已提交
502
{
503
	umode_t mode = (amode & S_IALLUGO) | S_IFREG;
504
	struct sysfs_addrm_cxt acxt;
505
	struct sysfs_dirent *sd;
506
	int rc;
L
Linus Torvalds 已提交
507

508 509 510
	sd = sysfs_new_dirent(attr->name, mode, type);
	if (!sd)
		return -ENOMEM;
T
Tejun Heo 已提交
511
	sd->s_attr.attr = (void *)attr;
512
	sysfs_dirent_init_lockdep(sd);
L
Linus Torvalds 已提交
513

514
	sysfs_addrm_start(&acxt, dir_sd);
515 516
	rc = sysfs_add_one(&acxt, sd);
	sysfs_addrm_finish(&acxt);
517

518
	if (rc)
519
		sysfs_put(sd);
520

521
	return rc;
L
Linus Torvalds 已提交
522 523 524
}


525 526 527 528 529 530 531
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);
}


L
Linus Torvalds 已提交
532 533 534
/**
 *	sysfs_create_file - create an attribute file for an object.
 *	@kobj:	object we're creating for. 
535
 *	@attr:	attribute descriptor.
L
Linus Torvalds 已提交
536 537 538 539
 */

int sysfs_create_file(struct kobject * kobj, const struct attribute * attr)
{
540
	BUG_ON(!kobj || !kobj->sd || !attr);
L
Linus Torvalds 已提交
541

542
	return sysfs_add_file(kobj->sd, attr, SYSFS_KOBJ_ATTR);
L
Linus Torvalds 已提交
543 544 545

}

546 547 548 549 550 551 552 553 554 555 556 557
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;
}
L
Linus Torvalds 已提交
558

559 560 561 562 563 564 565 566 567
/**
 * 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)
{
568
	struct sysfs_dirent *dir_sd;
569 570
	int error;

571 572 573 574 575
	if (group)
		dir_sd = sysfs_get_dirent(kobj->sd, group);
	else
		dir_sd = sysfs_get(kobj->sd);

576 577 578 579 580 581
	if (!dir_sd)
		return -ENOENT;

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

582 583 584 585
	return error;
}
EXPORT_SYMBOL_GPL(sysfs_add_file_to_group);

586 587 588 589 590 591 592 593 594
/**
 * sysfs_chmod_file - update the modified mode value on an object attribute.
 * @kobj: object we're acting for.
 * @attr: attribute descriptor.
 * @mode: file permissions.
 *
 */
int sysfs_chmod_file(struct kobject *kobj, struct attribute *attr, mode_t mode)
{
595
	struct sysfs_dirent *sd;
596
	struct iattr newattrs;
597 598
	int rc;

599
	mutex_lock(&sysfs_mutex);
600

601 602 603
	rc = -ENOENT;
	sd = sysfs_find_dirent(kobj->sd, attr->name);
	if (!sd)
604
		goto out;
605

606
	newattrs.ia_mode = (mode & S_IALLUGO) | (sd->s_mode & ~S_IALLUGO);
607
	newattrs.ia_valid = ATTR_MODE;
608
	rc = sysfs_sd_setattr(sd, &newattrs);
609

610
 out:
611
	mutex_unlock(&sysfs_mutex);
612
	return rc;
613 614 615 616
}
EXPORT_SYMBOL_GPL(sysfs_chmod_file);


L
Linus Torvalds 已提交
617 618 619 620 621 622 623 624 625 626
/**
 *	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)
{
627
	sysfs_hash_and_remove(kobj->sd, attr->name);
L
Linus Torvalds 已提交
628 629
}

630 631 632 633 634 635
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]);
}
L
Linus Torvalds 已提交
636

637 638 639 640 641 642 643 644 645
/**
 * 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)
{
646
	struct sysfs_dirent *dir_sd;
647

648 649 650 651
	if (group)
		dir_sd = sysfs_get_dirent(kobj->sd, group);
	else
		dir_sd = sysfs_get(kobj->sd);
652 653 654
	if (dir_sd) {
		sysfs_hash_and_remove(dir_sd, attr->name);
		sysfs_put(dir_sd);
655 656 657 658
	}
}
EXPORT_SYMBOL_GPL(sysfs_remove_file_from_group);

659
struct sysfs_schedule_callback_struct {
660 661
	struct list_head	workq_list;
	struct kobject		*kobj;
662 663
	void			(*func)(void *);
	void			*data;
664
	struct module		*owner;
665 666 667
	struct work_struct	work;
};

668
static struct workqueue_struct *sysfs_workqueue;
669 670
static DEFINE_MUTEX(sysfs_workq_mutex);
static LIST_HEAD(sysfs_workq);
671 672 673 674 675 676 677
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);
678
	module_put(ss->owner);
679 680 681
	mutex_lock(&sysfs_workq_mutex);
	list_del(&ss->workq_list);
	mutex_unlock(&sysfs_workq_mutex);
682 683 684 685 686 687 688 689
	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.
690
 * @owner: module owning the callback code
691 692 693 694 695 696 697 698 699 700 701 702
 *
 * 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
703 704
 * be allocated, -ENODEV if a reference to @owner isn't available,
 * -EAGAIN if a callback has already been scheduled for @kobj.
705 706
 */
int sysfs_schedule_callback(struct kobject *kobj, void (*func)(void *),
707
		void *data, struct module *owner)
708
{
709
	struct sysfs_schedule_callback_struct *ss, *tmp;
710

711 712
	if (!try_module_get(owner))
		return -ENODEV;
713 714 715 716

	mutex_lock(&sysfs_workq_mutex);
	list_for_each_entry_safe(ss, tmp, &sysfs_workq, workq_list)
		if (ss->kobj == kobj) {
717
			module_put(owner);
718 719 720 721 722
			mutex_unlock(&sysfs_workq_mutex);
			return -EAGAIN;
		}
	mutex_unlock(&sysfs_workq_mutex);

723
	if (sysfs_workqueue == NULL) {
724
		sysfs_workqueue = create_singlethread_workqueue("sysfsd");
725 726 727 728 729 730
		if (sysfs_workqueue == NULL) {
			module_put(owner);
			return -ENOMEM;
		}
	}

731
	ss = kmalloc(sizeof(*ss), GFP_KERNEL);
732 733
	if (!ss) {
		module_put(owner);
734
		return -ENOMEM;
735
	}
736 737 738 739
	kobject_get(kobj);
	ss->kobj = kobj;
	ss->func = func;
	ss->data = data;
740
	ss->owner = owner;
741
	INIT_WORK(&ss->work, sysfs_schedule_callback_work);
742 743 744 745
	INIT_LIST_HEAD(&ss->workq_list);
	mutex_lock(&sysfs_workq_mutex);
	list_add_tail(&ss->workq_list, &sysfs_workq);
	mutex_unlock(&sysfs_workq_mutex);
746
	queue_work(sysfs_workqueue, &ss->work);
747 748 749 750
	return 0;
}
EXPORT_SYMBOL_GPL(sysfs_schedule_callback);

751

L
Linus Torvalds 已提交
752 753
EXPORT_SYMBOL_GPL(sysfs_create_file);
EXPORT_SYMBOL_GPL(sysfs_remove_file);
754 755
EXPORT_SYMBOL_GPL(sysfs_remove_files);
EXPORT_SYMBOL_GPL(sysfs_create_files);