file.c 17.5 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/namei.h>
17
#include <linux/poll.h>
18
#include <linux/list.h>
19
#include <linux/mutex.h>
L
Linus Torvalds 已提交
20 21 22 23
#include <asm/uaccess.h>

#include "sysfs.h"

T
Tejun Heo 已提交
24 25 26 27 28 29 30 31 32
/*
 * 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 已提交
33
static DEFINE_SPINLOCK(sysfs_open_dirent_lock);
T
Tejun Heo 已提交
34 35 36

struct sysfs_open_dirent {
	atomic_t		refcnt;
37 38
	atomic_t		event;
	wait_queue_head_t	poll;
T
Tejun Heo 已提交
39 40 41
	struct list_head	buffers; /* goes through sysfs_buffer.list */
};

T
Tejun Heo 已提交
42 43 44 45 46
struct sysfs_buffer {
	size_t			count;
	loff_t			pos;
	char			* page;
	struct sysfs_ops	* ops;
47
	struct mutex		mutex;
T
Tejun Heo 已提交
48 49
	int			needs_read_fill;
	int			event;
T
Tejun Heo 已提交
50
	struct list_head	list;
T
Tejun Heo 已提交
51
};
L
Linus Torvalds 已提交
52 53 54 55 56 57 58 59 60

/**
 *	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. 
61 62
 *	This is called only once, on the file's first read unless an error
 *	is returned.
L
Linus Torvalds 已提交
63 64 65
 */
static int fill_read_buffer(struct dentry * dentry, struct sysfs_buffer * buffer)
{
66
	struct sysfs_dirent *attr_sd = dentry->d_fsdata;
T
Tejun Heo 已提交
67
	struct kobject *kobj = attr_sd->s_parent->s_dir.kobj;
L
Linus Torvalds 已提交
68 69 70 71 72 73 74 75 76
	struct sysfs_ops * ops = buffer->ops;
	int ret = 0;
	ssize_t count;

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

77 78 79 80
	/* need attr_sd for attr and ops, its parent for kobj */
	if (!sysfs_get_active_two(attr_sd))
		return -ENODEV;

81
	buffer->event = atomic_read(&attr_sd->s_attr.open->event);
T
Tejun Heo 已提交
82
	count = ops->show(kobj, attr_sd->s_attr.attr, buffer->page);
83 84 85

	sysfs_put_active_two(attr_sd);

86 87 88 89
	/*
	 * The code works fine with PAGE_SIZE return but it's likely to
	 * indicate truncated result or overflow in normal use cases.
	 */
90 91 92 93 94 95
	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;
	}
96 97
	if (count >= 0) {
		buffer->needs_read_fill = 0;
L
Linus Torvalds 已提交
98
		buffer->count = count;
99
	} else {
L
Linus Torvalds 已提交
100
		ret = count;
101
	}
L
Linus Torvalds 已提交
102 103 104 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
	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;

130
	mutex_lock(&buffer->mutex);
L
Linus Torvalds 已提交
131
	if (buffer->needs_read_fill) {
T
Tejun Heo 已提交
132
		retval = fill_read_buffer(file->f_path.dentry,buffer);
133
		if (retval)
L
Linus Torvalds 已提交
134 135
			goto out;
	}
136 137
	pr_debug("%s: count = %zd, ppos = %lld, buf = %s\n",
		 __FUNCTION__, count, *ppos, buffer->page);
138 139
	retval = simple_read_from_buffer(buf, count, ppos, buffer->page,
					 buffer->count);
L
Linus Torvalds 已提交
140
out:
141
	mutex_unlock(&buffer->mutex);
L
Linus Torvalds 已提交
142 143 144 145 146 147
	return retval;
}

/**
 *	fill_write_buffer - copy buffer from userspace.
 *	@buffer:	data buffer for file.
148
 *	@buf:		data from user.
L
Linus Torvalds 已提交
149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165
 *	@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)
166
		count = PAGE_SIZE - 1;
L
Linus Torvalds 已提交
167 168
	error = copy_from_user(buffer->page,buf,count);
	buffer->needs_read_fill = 1;
169 170 171
	/* 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 已提交
172 173 174 175 176 177
	return error ? -EFAULT : count;
}


/**
 *	flush_write_buffer - push buffer to kobject.
M
Martin Waitz 已提交
178
 *	@dentry:	dentry to the attribute
L
Linus Torvalds 已提交
179
 *	@buffer:	data buffer for file.
M
Martin Waitz 已提交
180
 *	@count:		number of bytes
L
Linus Torvalds 已提交
181 182 183 184 185 186
 *
 *	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().
 */

187
static int
L
Linus Torvalds 已提交
188 189
flush_write_buffer(struct dentry * dentry, struct sysfs_buffer * buffer, size_t count)
{
190
	struct sysfs_dirent *attr_sd = dentry->d_fsdata;
T
Tejun Heo 已提交
191
	struct kobject *kobj = attr_sd->s_parent->s_dir.kobj;
L
Linus Torvalds 已提交
192
	struct sysfs_ops * ops = buffer->ops;
193 194 195 196 197 198
	int rc;

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

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

	sysfs_put_active_two(attr_sd);
L
Linus Torvalds 已提交
202

203
	return rc;
L
Linus Torvalds 已提交
204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229
}


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

230
	mutex_lock(&buffer->mutex);
L
Linus Torvalds 已提交
231 232
	len = fill_write_buffer(buffer, buf, count);
	if (len > 0)
233
		len = flush_write_buffer(file->f_path.dentry, buffer, len);
L
Linus Torvalds 已提交
234 235
	if (len > 0)
		*ppos += len;
236
	mutex_unlock(&buffer->mutex);
L
Linus Torvalds 已提交
237 238 239
	return len;
}

T
Tejun Heo 已提交
240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286
/**
 *	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:
	spin_lock(&sysfs_open_dirent_lock);

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

	spin_unlock(&sysfs_open_dirent_lock);

	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);
287 288
	atomic_set(&new_od->event, 1);
	init_waitqueue_head(&new_od->poll);
T
Tejun Heo 已提交
289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321
	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;

	spin_lock(&sysfs_open_dirent_lock);

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

	spin_unlock(&sysfs_open_dirent_lock);

	kfree(od);
}

322
static int sysfs_open_file(struct inode *inode, struct file *file)
L
Linus Torvalds 已提交
323
{
324
	struct sysfs_dirent *attr_sd = file->f_path.dentry->d_fsdata;
T
Tejun Heo 已提交
325
	struct kobject *kobj = attr_sd->s_parent->s_dir.kobj;
326 327 328
	struct sysfs_buffer *buffer;
	struct sysfs_ops *ops;
	int error = -EACCES;
L
Linus Torvalds 已提交
329

330 331 332
	/* need attr_sd for attr and ops, its parent for kobj */
	if (!sysfs_get_active_two(attr_sd))
		return -ENODEV;
L
Linus Torvalds 已提交
333

334 335
	/* every kobject with an attribute needs a ktype assigned */
	if (kobj->ktype && kobj->ktype->sysfs_ops)
L
Linus Torvalds 已提交
336
		ops = kobj->ktype->sysfs_ops;
337 338 339 340
	else {
		printk(KERN_ERR "missing sysfs attribute operations for "
		       "kobject: %s\n", kobject_name(kobj));
		WARN_ON(1);
341
		goto err_out;
342
	}
L
Linus Torvalds 已提交
343 344 345 346 347 348 349

	/* 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)
350
			goto err_out;
L
Linus Torvalds 已提交
351 352 353 354 355 356 357 358
	}

	/* 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)
359
			goto err_out;
L
Linus Torvalds 已提交
360 361 362 363 364
	}

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

370
	mutex_init(&buffer->mutex);
371 372 373 374
	buffer->needs_read_fill = 1;
	buffer->ops = ops;
	file->private_data = buffer;

T
Tejun Heo 已提交
375 376 377 378 379
	/* make sure we have open dirent struct */
	error = sysfs_get_open_dirent(attr_sd, buffer);
	if (error)
		goto err_free;

380
	/* open succeeded, put active references */
381 382 383
	sysfs_put_active_two(attr_sd);
	return 0;

T
Tejun Heo 已提交
384 385
 err_free:
	kfree(buffer);
386
 err_out:
387
	sysfs_put_active_two(attr_sd);
L
Linus Torvalds 已提交
388 389 390
	return error;
}

T
Tejun Heo 已提交
391
static int sysfs_release(struct inode *inode, struct file *filp)
L
Linus Torvalds 已提交
392
{
T
Tejun Heo 已提交
393
	struct sysfs_dirent *sd = filp->f_path.dentry->d_fsdata;
T
Tejun Heo 已提交
394
	struct sysfs_buffer *buffer = filp->private_data;
L
Linus Torvalds 已提交
395

T
Tejun Heo 已提交
396 397
	sysfs_put_open_dirent(sd, buffer);

398 399 400 401
	if (buffer->page)
		free_page((unsigned long)buffer->page);
	kfree(buffer);

L
Linus Torvalds 已提交
402 403 404
	return 0;
}

405 406 407 408 409 410 411 412 413 414 415
/* 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
 * need to close and re-open the file, as simply seeking and reading
 * again will not get new data, or reset the state of 'poll'.
 * Reminder: this only works for attributes which actively support
 * it, and it is not possible to test an attribute from userspace
416
 * to see if it supports poll (Neither 'poll' nor 'select' return
417 418 419 420 421
 * 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;
422
	struct sysfs_dirent *attr_sd = filp->f_path.dentry->d_fsdata;
423
	struct sysfs_open_dirent *od = attr_sd->s_attr.open;
424 425 426 427

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

429
	poll_wait(filp, &od->poll, wait);
430

431 432
	sysfs_put_active_two(attr_sd);

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

436 437 438 439 440
	return 0;

 trigger:
	buffer->needs_read_fill = 1;
	return POLLERR|POLLPRI;
441 442
}

443
void sysfs_notify(struct kobject *k, char *dir, char *attr)
444
{
445
	struct sysfs_dirent *sd = k->sd;
446

447 448 449 450 451 452 453
	mutex_lock(&sysfs_mutex);

	if (sd && dir)
		sd = sysfs_find_dirent(sd, dir);
	if (sd && attr)
		sd = sysfs_find_dirent(sd, attr);
	if (sd) {
454 455 456 457 458 459 460 461 462 463 464
		struct sysfs_open_dirent *od;

		spin_lock(&sysfs_open_dirent_lock);

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

		spin_unlock(&sysfs_open_dirent_lock);
465
	}
466 467

	mutex_unlock(&sysfs_mutex);
468 469 470
}
EXPORT_SYMBOL_GPL(sysfs_notify);

471
const struct file_operations sysfs_file_operations = {
L
Linus Torvalds 已提交
472 473 474 475 476
	.read		= sysfs_read_file,
	.write		= sysfs_write_file,
	.llseek		= generic_file_llseek,
	.open		= sysfs_open_file,
	.release	= sysfs_release,
477
	.poll		= sysfs_poll,
L
Linus Torvalds 已提交
478 479 480
};


481 482
int sysfs_add_file(struct sysfs_dirent *dir_sd, const struct attribute *attr,
		   int type)
L
Linus Torvalds 已提交
483 484
{
	umode_t mode = (attr->mode & S_IALLUGO) | S_IFREG;
485
	struct sysfs_addrm_cxt acxt;
486
	struct sysfs_dirent *sd;
487
	int rc;
L
Linus Torvalds 已提交
488

489 490 491
	sd = sysfs_new_dirent(attr->name, mode, type);
	if (!sd)
		return -ENOMEM;
T
Tejun Heo 已提交
492
	sd->s_attr.attr = (void *)attr;
L
Linus Torvalds 已提交
493

494
	sysfs_addrm_start(&acxt, dir_sd);
495 496
	rc = sysfs_add_one(&acxt, sd);
	sysfs_addrm_finish(&acxt);
497

498
	if (rc)
499
		sysfs_put(sd);
500

501
	return rc;
L
Linus Torvalds 已提交
502 503 504 505 506 507
}


/**
 *	sysfs_create_file - create an attribute file for an object.
 *	@kobj:	object we're creating for. 
508
 *	@attr:	attribute descriptor.
L
Linus Torvalds 已提交
509 510 511 512
 */

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

515
	return sysfs_add_file(kobj->sd, attr, SYSFS_KOBJ_ATTR);
L
Linus Torvalds 已提交
516 517 518 519

}


520 521 522 523 524 525 526 527 528
/**
 * 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)
{
529
	struct sysfs_dirent *dir_sd;
530 531
	int error;

532 533 534 535 536
	if (group)
		dir_sd = sysfs_get_dirent(kobj->sd, group);
	else
		dir_sd = sysfs_get(kobj->sd);

537 538 539 540 541 542
	if (!dir_sd)
		return -ENOENT;

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

543 544 545 546
	return error;
}
EXPORT_SYMBOL_GPL(sysfs_add_file_to_group);

547 548 549 550 551 552 553 554 555
/**
 * 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)
{
556 557
	struct sysfs_dirent *victim_sd = NULL;
	struct dentry *victim = NULL;
558 559
	struct inode * inode;
	struct iattr newattrs;
560 561 562 563 564 565 566
	int rc;

	rc = -ENOENT;
	victim_sd = sysfs_get_dirent(kobj->sd, attr->name);
	if (!victim_sd)
		goto out;

567
	mutex_lock(&sysfs_rename_mutex);
568
	victim = sysfs_get_dentry(victim_sd);
569
	mutex_unlock(&sysfs_rename_mutex);
570 571 572 573
	if (IS_ERR(victim)) {
		rc = PTR_ERR(victim);
		victim = NULL;
		goto out;
574 575
	}

576
	inode = victim->d_inode;
577

578
	mutex_lock(&inode->i_mutex);
579

580 581 582
	newattrs.ia_mode = (mode & S_IALLUGO) | (inode->i_mode & ~S_IALLUGO);
	newattrs.ia_valid = ATTR_MODE | ATTR_CTIME;
	rc = notify_change(victim, &newattrs);
583 584 585 586 587 588 589

	if (rc == 0) {
		mutex_lock(&sysfs_mutex);
		victim_sd->s_mode = newattrs.ia_mode;
		mutex_unlock(&sysfs_mutex);
	}

590 591 592 593 594
	mutex_unlock(&inode->i_mutex);
 out:
	dput(victim);
	sysfs_put(victim_sd);
	return rc;
595 596 597 598
}
EXPORT_SYMBOL_GPL(sysfs_chmod_file);


L
Linus Torvalds 已提交
599 600 601 602 603 604 605 606 607 608
/**
 *	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)
{
609
	sysfs_hash_and_remove(kobj->sd, attr->name);
L
Linus Torvalds 已提交
610 611 612
}


613 614 615 616 617 618 619 620 621
/**
 * 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)
{
622
	struct sysfs_dirent *dir_sd;
623

624 625 626 627
	if (group)
		dir_sd = sysfs_get_dirent(kobj->sd, group);
	else
		dir_sd = sysfs_get(kobj->sd);
628 629 630
	if (dir_sd) {
		sysfs_hash_and_remove(dir_sd, attr->name);
		sysfs_put(dir_sd);
631 632 633 634
	}
}
EXPORT_SYMBOL_GPL(sysfs_remove_file_from_group);

635 636 637 638
struct sysfs_schedule_callback_struct {
	struct kobject 		*kobj;
	void			(*func)(void *);
	void			*data;
639
	struct module		*owner;
640 641 642 643 644 645 646 647 648 649
	struct work_struct	work;
};

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);
650
	module_put(ss->owner);
651 652 653 654 655 656 657 658
	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.
659
 * @owner: module owning the callback code
660 661 662 663 664 665 666 667 668 669 670 671
 *
 * 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
672
 * be allocated, -ENODEV if a reference to @owner isn't available.
673 674
 */
int sysfs_schedule_callback(struct kobject *kobj, void (*func)(void *),
675
		void *data, struct module *owner)
676 677 678
{
	struct sysfs_schedule_callback_struct *ss;

679 680
	if (!try_module_get(owner))
		return -ENODEV;
681
	ss = kmalloc(sizeof(*ss), GFP_KERNEL);
682 683
	if (!ss) {
		module_put(owner);
684
		return -ENOMEM;
685
	}
686 687 688 689
	kobject_get(kobj);
	ss->kobj = kobj;
	ss->func = func;
	ss->data = data;
690
	ss->owner = owner;
691 692 693 694 695 696
	INIT_WORK(&ss->work, sysfs_schedule_callback_work);
	schedule_work(&ss->work);
	return 0;
}
EXPORT_SYMBOL_GPL(sysfs_schedule_callback);

697

L
Linus Torvalds 已提交
698 699
EXPORT_SYMBOL_GPL(sysfs_create_file);
EXPORT_SYMBOL_GPL(sysfs_remove_file);