file.c 17.5 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6
/*
 * file.c - operations for regular (text) files.
 */

#include <linux/module.h>
#include <linux/kobject.h>
7
#include <linux/namei.h>
8
#include <linux/poll.h>
9
#include <linux/list.h>
10
#include <linux/mutex.h>
L
Linus Torvalds 已提交
11 12 13 14
#include <asm/uaccess.h>

#include "sysfs.h"

15
#define to_sattr(a) container_of(a,struct subsys_attribute, attr)
L
Linus Torvalds 已提交
16

M
Martin Waitz 已提交
17
/*
L
Linus Torvalds 已提交
18 19 20 21 22 23 24
 * Subsystem file operations.
 * These operations allow subsystems to have files that can be 
 * read/written. 
 */
static ssize_t 
subsys_attr_show(struct kobject * kobj, struct attribute * attr, char * page)
{
25
	struct kset *kset = to_kset(kobj);
L
Linus Torvalds 已提交
26
	struct subsys_attribute * sattr = to_sattr(attr);
27
	ssize_t ret = -EIO;
L
Linus Torvalds 已提交
28 29

	if (sattr->show)
30
		ret = sattr->show(kset, page);
L
Linus Torvalds 已提交
31 32 33 34 35 36 37
	return ret;
}

static ssize_t 
subsys_attr_store(struct kobject * kobj, struct attribute * attr, 
		  const char * page, size_t count)
{
38
	struct kset *kset = to_kset(kobj);
L
Linus Torvalds 已提交
39
	struct subsys_attribute * sattr = to_sattr(attr);
40
	ssize_t ret = -EIO;
L
Linus Torvalds 已提交
41 42

	if (sattr->store)
43
		ret = sattr->store(kset, page, count);
L
Linus Torvalds 已提交
44 45 46 47 48 49 50 51
	return ret;
}

static struct sysfs_ops subsys_sysfs_ops = {
	.show	= subsys_attr_show,
	.store	= subsys_attr_store,
};

T
Tejun Heo 已提交
52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67
/*
 * 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.
 */
static spinlock_t sysfs_open_dirent_lock = SPIN_LOCK_UNLOCKED;

struct sysfs_open_dirent {
	atomic_t		refcnt;
	struct list_head	buffers; /* goes through sysfs_buffer.list */
};

T
Tejun Heo 已提交
68 69 70 71 72
struct sysfs_buffer {
	size_t			count;
	loff_t			pos;
	char			* page;
	struct sysfs_ops	* ops;
73
	struct mutex		mutex;
T
Tejun Heo 已提交
74 75
	int			needs_read_fill;
	int			event;
T
Tejun Heo 已提交
76
	struct list_head	list;
T
Tejun Heo 已提交
77
};
L
Linus Torvalds 已提交
78 79 80 81 82 83 84 85 86

/**
 *	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. 
87 88
 *	This is called only once, on the file's first read unless an error
 *	is returned.
L
Linus Torvalds 已提交
89 90 91
 */
static int fill_read_buffer(struct dentry * dentry, struct sysfs_buffer * buffer)
{
92
	struct sysfs_dirent *attr_sd = dentry->d_fsdata;
T
Tejun Heo 已提交
93
	struct kobject *kobj = attr_sd->s_parent->s_dir.kobj;
L
Linus Torvalds 已提交
94 95 96 97 98 99 100 101 102
	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;

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

	buffer->event = atomic_read(&attr_sd->s_event);
T
Tejun Heo 已提交
108
	count = ops->show(kobj, attr_sd->s_attr.attr, buffer->page);
109 110 111

	sysfs_put_active_two(attr_sd);

L
Linus Torvalds 已提交
112
	BUG_ON(count > (ssize_t)PAGE_SIZE);
113 114
	if (count >= 0) {
		buffer->needs_read_fill = 0;
L
Linus Torvalds 已提交
115
		buffer->count = count;
116
	} else {
L
Linus Torvalds 已提交
117
		ret = count;
118
	}
L
Linus Torvalds 已提交
119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146
	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;

147
	mutex_lock(&buffer->mutex);
L
Linus Torvalds 已提交
148
	if (buffer->needs_read_fill) {
T
Tejun Heo 已提交
149
		retval = fill_read_buffer(file->f_path.dentry,buffer);
150
		if (retval)
L
Linus Torvalds 已提交
151 152
			goto out;
	}
153 154
	pr_debug("%s: count = %zd, ppos = %lld, buf = %s\n",
		 __FUNCTION__, count, *ppos, buffer->page);
155 156
	retval = simple_read_from_buffer(buf, count, ppos, buffer->page,
					 buffer->count);
L
Linus Torvalds 已提交
157
out:
158
	mutex_unlock(&buffer->mutex);
L
Linus Torvalds 已提交
159 160 161 162 163 164
	return retval;
}

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


/**
 *	flush_write_buffer - push buffer to kobject.
M
Martin Waitz 已提交
195
 *	@dentry:	dentry to the attribute
L
Linus Torvalds 已提交
196
 *	@buffer:	data buffer for file.
M
Martin Waitz 已提交
197
 *	@count:		number of bytes
L
Linus Torvalds 已提交
198 199 200 201 202 203
 *
 *	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().
 */

204
static int
L
Linus Torvalds 已提交
205 206
flush_write_buffer(struct dentry * dentry, struct sysfs_buffer * buffer, size_t count)
{
207
	struct sysfs_dirent *attr_sd = dentry->d_fsdata;
T
Tejun Heo 已提交
208
	struct kobject *kobj = attr_sd->s_parent->s_dir.kobj;
L
Linus Torvalds 已提交
209
	struct sysfs_ops * ops = buffer->ops;
210 211 212 213 214 215
	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 已提交
216
	rc = ops->store(kobj, attr_sd->s_attr.attr, buffer->page, count);
217 218

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

220
	return rc;
L
Linus Torvalds 已提交
221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246
}


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

247
	mutex_lock(&buffer->mutex);
L
Linus Torvalds 已提交
248 249
	len = fill_write_buffer(buffer, buf, count);
	if (len > 0)
250
		len = flush_write_buffer(file->f_path.dentry, buffer, len);
L
Linus Torvalds 已提交
251 252
	if (len > 0)
		*ppos += len;
253
	mutex_unlock(&buffer->mutex);
L
Linus Torvalds 已提交
254 255 256
	return len;
}

T
Tejun Heo 已提交
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 287 288 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 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336
/**
 *	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);
	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);
}

337
static int sysfs_open_file(struct inode *inode, struct file *file)
L
Linus Torvalds 已提交
338
{
339
	struct sysfs_dirent *attr_sd = file->f_path.dentry->d_fsdata;
T
Tejun Heo 已提交
340
	struct kobject *kobj = attr_sd->s_parent->s_dir.kobj;
L
Linus Torvalds 已提交
341 342
	struct sysfs_buffer * buffer;
	struct sysfs_ops * ops = NULL;
343
	int error;
L
Linus Torvalds 已提交
344

345 346 347
	/* need attr_sd for attr and ops, its parent for kobj */
	if (!sysfs_get_active_two(attr_sd))
		return -ENODEV;
L
Linus Torvalds 已提交
348 349 350 351 352 353 354 355 356 357 358

	/* if the kobject has no ktype, then we assume that it is a subsystem
	 * itself, and use ops for it.
	 */
	if (kobj->kset && kobj->kset->ktype)
		ops = kobj->kset->ktype->sysfs_ops;
	else if (kobj->ktype)
		ops = kobj->ktype->sysfs_ops;
	else
		ops = &subsys_sysfs_ops;

T
Tejun Heo 已提交
359 360
	error = -EACCES;

L
Linus Torvalds 已提交
361 362 363 364
	/* No sysfs operations, either from having no subsystem,
	 * or the subsystem have no operations.
	 */
	if (!ops)
365
		goto err_out;
L
Linus Torvalds 已提交
366 367 368 369 370 371 372

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

	/* 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)
382
			goto err_out;
L
Linus Torvalds 已提交
383 384 385 386 387
	}

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

393
	mutex_init(&buffer->mutex);
394 395 396 397
	buffer->needs_read_fill = 1;
	buffer->ops = ops;
	file->private_data = buffer;

T
Tejun Heo 已提交
398 399 400 401 402
	/* make sure we have open dirent struct */
	error = sysfs_get_open_dirent(attr_sd, buffer);
	if (error)
		goto err_free;

403
	/* open succeeded, put active references */
404 405 406
	sysfs_put_active_two(attr_sd);
	return 0;

T
Tejun Heo 已提交
407 408
 err_free:
	kfree(buffer);
409
 err_out:
410
	sysfs_put_active_two(attr_sd);
L
Linus Torvalds 已提交
411 412 413
	return error;
}

T
Tejun Heo 已提交
414
static int sysfs_release(struct inode *inode, struct file *filp)
L
Linus Torvalds 已提交
415
{
T
Tejun Heo 已提交
416
	struct sysfs_dirent *sd = filp->f_path.dentry->d_fsdata;
T
Tejun Heo 已提交
417
	struct sysfs_buffer *buffer = filp->private_data;
L
Linus Torvalds 已提交
418

T
Tejun Heo 已提交
419 420
	sysfs_put_open_dirent(sd, buffer);

421 422 423 424
	if (buffer->page)
		free_page((unsigned long)buffer->page);
	kfree(buffer);

L
Linus Torvalds 已提交
425 426 427
	return 0;
}

428 429 430 431 432 433 434 435 436 437 438
/* 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
439
 * to see if it supports poll (Neither 'poll' nor 'select' return
440 441 442 443 444
 * 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;
445
	struct sysfs_dirent *attr_sd = filp->f_path.dentry->d_fsdata;
T
Tejun Heo 已提交
446
	struct kobject *kobj = attr_sd->s_parent->s_dir.kobj;
447 448 449 450

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

	poll_wait(filp, &kobj->poll, wait);

454 455 456 457
	sysfs_put_active_two(attr_sd);

	if (buffer->event != atomic_read(&attr_sd->s_event))
		goto trigger;
458

459 460 461 462 463
	return 0;

 trigger:
	buffer->needs_read_fill = 1;
	return POLLERR|POLLPRI;
464 465
}

466
void sysfs_notify(struct kobject *k, char *dir, char *attr)
467
{
468
	struct sysfs_dirent *sd = k->sd;
469

470 471 472 473 474 475 476 477
	mutex_lock(&sysfs_mutex);

	if (sd && dir)
		sd = sysfs_find_dirent(sd, dir);
	if (sd && attr)
		sd = sysfs_find_dirent(sd, attr);
	if (sd) {
		atomic_inc(&sd->s_event);
478 479
		wake_up_interruptible(&k->poll);
	}
480 481

	mutex_unlock(&sysfs_mutex);
482 483 484
}
EXPORT_SYMBOL_GPL(sysfs_notify);

485
const struct file_operations sysfs_file_operations = {
L
Linus Torvalds 已提交
486 487 488 489 490
	.read		= sysfs_read_file,
	.write		= sysfs_write_file,
	.llseek		= generic_file_llseek,
	.open		= sysfs_open_file,
	.release	= sysfs_release,
491
	.poll		= sysfs_poll,
L
Linus Torvalds 已提交
492 493 494
};


495 496
int sysfs_add_file(struct sysfs_dirent *dir_sd, const struct attribute *attr,
		   int type)
L
Linus Torvalds 已提交
497 498
{
	umode_t mode = (attr->mode & S_IALLUGO) | S_IFREG;
499
	struct sysfs_addrm_cxt acxt;
500
	struct sysfs_dirent *sd;
501
	int rc;
L
Linus Torvalds 已提交
502

503 504 505
	sd = sysfs_new_dirent(attr->name, mode, type);
	if (!sd)
		return -ENOMEM;
T
Tejun Heo 已提交
506
	sd->s_attr.attr = (void *)attr;
L
Linus Torvalds 已提交
507

508
	sysfs_addrm_start(&acxt, dir_sd);
509 510
	rc = sysfs_add_one(&acxt, sd);
	sysfs_addrm_finish(&acxt);
511

512
	if (rc)
513
		sysfs_put(sd);
514

515
	return rc;
L
Linus Torvalds 已提交
516 517 518 519 520 521 522 523 524 525 526
}


/**
 *	sysfs_create_file - create an attribute file for an object.
 *	@kobj:	object we're creating for. 
 *	@attr:	atrribute descriptor.
 */

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

529
	return sysfs_add_file(kobj->sd, attr, SYSFS_KOBJ_ATTR);
L
Linus Torvalds 已提交
530 531 532 533

}


534 535 536 537 538 539 540 541 542
/**
 * 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)
{
543
	struct sysfs_dirent *dir_sd;
544 545
	int error;

546 547 548 549 550 551 552
	dir_sd = sysfs_get_dirent(kobj->sd, group);
	if (!dir_sd)
		return -ENOENT;

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

553 554 555 556
	return error;
}
EXPORT_SYMBOL_GPL(sysfs_add_file_to_group);

557 558 559 560 561 562 563 564 565
/**
 * 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)
{
566 567
	struct sysfs_dirent *victim_sd = NULL;
	struct dentry *victim = NULL;
568 569
	struct inode * inode;
	struct iattr newattrs;
570 571 572 573 574 575 576
	int rc;

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

577
	mutex_lock(&sysfs_rename_mutex);
578
	victim = sysfs_get_dentry(victim_sd);
579
	mutex_unlock(&sysfs_rename_mutex);
580 581 582 583
	if (IS_ERR(victim)) {
		rc = PTR_ERR(victim);
		victim = NULL;
		goto out;
584 585
	}

586
	inode = victim->d_inode;
587

588
	mutex_lock(&inode->i_mutex);
589

590 591 592
	newattrs.ia_mode = (mode & S_IALLUGO) | (inode->i_mode & ~S_IALLUGO);
	newattrs.ia_valid = ATTR_MODE | ATTR_CTIME;
	rc = notify_change(victim, &newattrs);
593 594 595 596 597 598 599

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

600 601 602 603 604
	mutex_unlock(&inode->i_mutex);
 out:
	dput(victim);
	sysfs_put(victim_sd);
	return rc;
605 606 607 608
}
EXPORT_SYMBOL_GPL(sysfs_chmod_file);


L
Linus Torvalds 已提交
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, attr->name);
L
Linus Torvalds 已提交
620 621 622
}


623 624 625 626 627 628 629 630 631
/**
 * 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)
{
632
	struct sysfs_dirent *dir_sd;
633

634 635 636 637
	dir_sd = sysfs_get_dirent(kobj->sd, group);
	if (dir_sd) {
		sysfs_hash_and_remove(dir_sd, attr->name);
		sysfs_put(dir_sd);
638 639 640 641
	}
}
EXPORT_SYMBOL_GPL(sysfs_remove_file_from_group);

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

686 687
	if (!try_module_get(owner))
		return -ENODEV;
688
	ss = kmalloc(sizeof(*ss), GFP_KERNEL);
689 690
	if (!ss) {
		module_put(owner);
691
		return -ENOMEM;
692
	}
693 694 695 696
	kobject_get(kobj);
	ss->kobj = kobj;
	ss->func = func;
	ss->data = data;
697
	ss->owner = owner;
698 699 700 701 702 703
	INIT_WORK(&ss->work, sysfs_schedule_callback_work);
	schedule_work(&ss->work);
	return 0;
}
EXPORT_SYMBOL_GPL(sysfs_schedule_callback);

704

L
Linus Torvalds 已提交
705 706
EXPORT_SYMBOL_GPL(sysfs_create_file);
EXPORT_SYMBOL_GPL(sysfs_remove_file);