file.c 19.8 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"

T
Tejun Heo 已提交
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.
 */
J
Jiri Slaby 已提交
36
static DEFINE_SPINLOCK(sysfs_open_dirent_lock);
T
Tejun Heo 已提交
37 38 39

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

T
Tejun Heo 已提交
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;
T
Tejun Heo 已提交
51 52
	int			needs_read_fill;
	int			event;
T
Tejun Heo 已提交
53
	struct list_head	list;
T
Tejun Heo 已提交
54
};
L
Linus Torvalds 已提交
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.
L
Linus Torvalds 已提交
66 67 68
 */
static int fill_read_buffer(struct dentry * dentry, struct sysfs_buffer * buffer)
{
69
	struct sysfs_dirent *attr_sd = dentry->d_fsdata;
T
Tejun Heo 已提交
70
	struct kobject *kobj = attr_sd->s_parent->s_dir.kobj;
71
	const struct sysfs_ops * ops = buffer->ops;
L
Linus Torvalds 已提交
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);
T
Tejun Heo 已提交
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;
L
Linus Torvalds 已提交
101
		buffer->count = count;
102
	} else {
L
Linus Torvalds 已提交
103
		ret = count;
104
	}
L
Linus Torvalds 已提交
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) {
T
Tejun Heo 已提交
135
		retval = fill_read_buffer(file->f_path.dentry,buffer);
136
		if (retval)
L
Linus Torvalds 已提交
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);
L
Linus Torvalds 已提交
143
out:
144
	mutex_unlock(&buffer->mutex);
L
Linus Torvalds 已提交
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.
L
Linus Torvalds 已提交
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;
L
Linus Torvalds 已提交
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;
L
Linus Torvalds 已提交
175 176 177 178 179 180
	return error ? -EFAULT : count;
}


/**
 *	flush_write_buffer - push buffer to kobject.
M
Martin Waitz 已提交
181
 *	@dentry:	dentry to the attribute
L
Linus Torvalds 已提交
182
 *	@buffer:	data buffer for file.
M
Martin Waitz 已提交
183
 *	@count:		number of bytes
L
Linus Torvalds 已提交
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
L
Linus Torvalds 已提交
191 192
flush_write_buffer(struct dentry * dentry, struct sysfs_buffer * buffer, size_t count)
{
193
	struct sysfs_dirent *attr_sd = dentry->d_fsdata;
T
Tejun Heo 已提交
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;

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

204
	sysfs_put_active(attr_sd);
L
Linus Torvalds 已提交
205

206
	return rc;
L
Linus Torvalds 已提交
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);
L
Linus Torvalds 已提交
234 235
	len = fill_write_buffer(buffer, buf, count);
	if (len > 0)
236
		len = flush_write_buffer(file->f_path.dentry, buffer, len);
L
Linus Torvalds 已提交
237 238
	if (len > 0)
		*ppos += len;
239
	mutex_unlock(&buffer->mutex);
L
Linus Torvalds 已提交
240 241 242
	return len;
}

T
Tejun Heo 已提交
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);
T
Tejun Heo 已提交
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);
T
Tejun Heo 已提交
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);
T
Tejun Heo 已提交
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;
T
Tejun Heo 已提交
312

313
	spin_lock_irqsave(&sysfs_open_dirent_lock, flags);
T
Tejun Heo 已提交
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);
T
Tejun Heo 已提交
322 323 324 325

	kfree(od);
}

326
static int sysfs_open_file(struct inode *inode, struct file *file)
L
Linus Torvalds 已提交
327
{
328
	struct sysfs_dirent *attr_sd = file->f_path.dentry->d_fsdata;
T
Tejun Heo 已提交
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;
L
Linus Torvalds 已提交
333

334
	/* need attr_sd for attr and ops, its parent for kobj */
335
	if (!sysfs_get_active(attr_sd))
336
		return -ENODEV;
L
Linus Torvalds 已提交
337

338 339
	/* every kobject with an attribute needs a ktype assigned */
	if (kobj->ktype && kobj->ktype->sysfs_ops)
L
Linus Torvalds 已提交
340
		ops = kobj->ktype->sysfs_ops;
341
	else {
A
Arjan van de Ven 已提交
342
		WARN(1, KERN_ERR "missing sysfs attribute operations for "
343
		       "kobject: %s\n", kobject_name(kobj));
344
		goto err_out;
345
	}
L
Linus Torvalds 已提交
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;
L
Linus Torvalds 已提交
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;
L
Linus Torvalds 已提交
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;
L
Linus Torvalds 已提交
372

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

T
Tejun Heo 已提交
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;

T
Tejun Heo 已提交
387 388
 err_free:
	kfree(buffer);
389
 err_out:
390
	sysfs_put_active(attr_sd);
L
Linus Torvalds 已提交
391 392 393
	return error;
}

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

T
Tejun Heo 已提交
399 400
	sysfs_put_open_dirent(sd, buffer);

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

L
Linus Torvalds 已提交
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 = {
L
Linus Torvalds 已提交
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,
L
Linus Torvalds 已提交
489 490
};

491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522
int sysfs_attr_ns(struct kobject *kobj, const struct attribute *attr,
		  const void **pns)
{
	struct sysfs_dirent *dir_sd = kobj->sd;
	const struct sysfs_ops *ops;
	const void *ns = NULL;
	int err;

	err = 0;
	if (!sysfs_ns_type(dir_sd))
		goto out;

	err = -EINVAL;
	if (!kobj->ktype)
		goto out;
	ops = kobj->ktype->sysfs_ops;
	if (!ops)
		goto out;
	if (!ops->namespace)
		goto out;

	err = 0;
	ns = ops->namespace(kobj, attr);
out:
	if (err) {
		WARN(1, KERN_ERR "missing sysfs namespace attribute operation for "
		     "kobject: %s\n", kobject_name(kobj));
	}
	*pns = ns;
	return err;
}

523 524
int sysfs_add_file_mode(struct sysfs_dirent *dir_sd,
			const struct attribute *attr, int type, mode_t amode)
L
Linus Torvalds 已提交
525
{
526
	umode_t mode = (amode & S_IALLUGO) | S_IFREG;
527
	struct sysfs_addrm_cxt acxt;
528
	struct sysfs_dirent *sd;
529
	const void *ns;
530
	int rc;
L
Linus Torvalds 已提交
531

532 533 534 535
	rc = sysfs_attr_ns(dir_sd->s_dir.kobj, attr, &ns);
	if (rc)
		return rc;

536 537 538
	sd = sysfs_new_dirent(attr->name, mode, type);
	if (!sd)
		return -ENOMEM;
539 540

	sd->s_ns = ns;
T
Tejun Heo 已提交
541
	sd->s_attr.attr = (void *)attr;
542
	sysfs_dirent_init_lockdep(sd);
L
Linus Torvalds 已提交
543

544
	sysfs_addrm_start(&acxt, dir_sd);
545 546
	rc = sysfs_add_one(&acxt, sd);
	sysfs_addrm_finish(&acxt);
547

548
	if (rc)
549
		sysfs_put(sd);
550

551
	return rc;
L
Linus Torvalds 已提交
552 553 554
}


555 556 557 558 559 560 561
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 已提交
562 563 564
/**
 *	sysfs_create_file - create an attribute file for an object.
 *	@kobj:	object we're creating for. 
565
 *	@attr:	attribute descriptor.
L
Linus Torvalds 已提交
566 567 568 569
 */

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

572
	return sysfs_add_file(kobj->sd, attr, SYSFS_KOBJ_ATTR);
L
Linus Torvalds 已提交
573 574 575

}

576 577 578 579 580 581 582 583 584 585 586 587
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 已提交
588

589 590 591 592 593 594 595 596 597
/**
 * 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)
{
598
	struct sysfs_dirent *dir_sd;
599 600
	int error;

601
	if (group)
602
		dir_sd = sysfs_get_dirent(kobj->sd, NULL, group);
603 604 605
	else
		dir_sd = sysfs_get(kobj->sd);

606 607 608 609 610 611
	if (!dir_sd)
		return -ENOENT;

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

612 613 614 615
	return error;
}
EXPORT_SYMBOL_GPL(sysfs_add_file_to_group);

616 617 618 619 620 621 622
/**
 * sysfs_chmod_file - update the modified mode value on an object attribute.
 * @kobj: object we're acting for.
 * @attr: attribute descriptor.
 * @mode: file permissions.
 *
 */
623 624
int sysfs_chmod_file(struct kobject *kobj, const struct attribute *attr,
		     mode_t mode)
625
{
626
	struct sysfs_dirent *sd;
627
	struct iattr newattrs;
628
	const void *ns;
629 630
	int rc;

631 632 633 634
	rc = sysfs_attr_ns(kobj, attr, &ns);
	if (rc)
		return rc;

635
	mutex_lock(&sysfs_mutex);
636

637
	rc = -ENOENT;
638
	sd = sysfs_find_dirent(kobj->sd, ns, attr->name);
639
	if (!sd)
640
		goto out;
641

642
	newattrs.ia_mode = (mode & S_IALLUGO) | (sd->s_mode & ~S_IALLUGO);
643
	newattrs.ia_valid = ATTR_MODE;
644
	rc = sysfs_sd_setattr(sd, &newattrs);
645

646
 out:
647
	mutex_unlock(&sysfs_mutex);
648
	return rc;
649 650 651 652
}
EXPORT_SYMBOL_GPL(sysfs_chmod_file);


L
Linus Torvalds 已提交
653 654 655 656 657 658 659 660 661 662
/**
 *	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)
{
663 664 665 666 667 668
	const void *ns;

	if (sysfs_attr_ns(kobj, attr, &ns))
		return;

	sysfs_hash_and_remove(kobj->sd, ns, attr->name);
L
Linus Torvalds 已提交
669 670
}

671 672 673 674 675 676
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 已提交
677

678 679 680 681 682 683 684 685 686
/**
 * 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)
{
687
	struct sysfs_dirent *dir_sd;
688

689
	if (group)
690
		dir_sd = sysfs_get_dirent(kobj->sd, NULL, group);
691 692
	else
		dir_sd = sysfs_get(kobj->sd);
693
	if (dir_sd) {
694
		sysfs_hash_and_remove(dir_sd, NULL, attr->name);
695
		sysfs_put(dir_sd);
696 697 698 699
	}
}
EXPORT_SYMBOL_GPL(sysfs_remove_file_from_group);

700
struct sysfs_schedule_callback_struct {
701 702
	struct list_head	workq_list;
	struct kobject		*kobj;
703 704
	void			(*func)(void *);
	void			*data;
705
	struct module		*owner;
706 707 708
	struct work_struct	work;
};

709
static struct workqueue_struct *sysfs_workqueue;
710 711
static DEFINE_MUTEX(sysfs_workq_mutex);
static LIST_HEAD(sysfs_workq);
712 713 714 715 716 717 718
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);
719
	module_put(ss->owner);
720 721 722
	mutex_lock(&sysfs_workq_mutex);
	list_del(&ss->workq_list);
	mutex_unlock(&sysfs_workq_mutex);
723 724 725 726 727 728 729 730
	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.
731
 * @owner: module owning the callback code
732 733 734 735 736 737 738 739 740 741 742 743
 *
 * 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
744 745
 * be allocated, -ENODEV if a reference to @owner isn't available,
 * -EAGAIN if a callback has already been scheduled for @kobj.
746 747
 */
int sysfs_schedule_callback(struct kobject *kobj, void (*func)(void *),
748
		void *data, struct module *owner)
749
{
750
	struct sysfs_schedule_callback_struct *ss, *tmp;
751

752 753
	if (!try_module_get(owner))
		return -ENODEV;
754 755 756 757

	mutex_lock(&sysfs_workq_mutex);
	list_for_each_entry_safe(ss, tmp, &sysfs_workq, workq_list)
		if (ss->kobj == kobj) {
758
			module_put(owner);
759 760 761 762 763
			mutex_unlock(&sysfs_workq_mutex);
			return -EAGAIN;
		}
	mutex_unlock(&sysfs_workq_mutex);

764
	if (sysfs_workqueue == NULL) {
765
		sysfs_workqueue = create_singlethread_workqueue("sysfsd");
766 767 768 769 770 771
		if (sysfs_workqueue == NULL) {
			module_put(owner);
			return -ENOMEM;
		}
	}

772
	ss = kmalloc(sizeof(*ss), GFP_KERNEL);
773 774
	if (!ss) {
		module_put(owner);
775
		return -ENOMEM;
776
	}
777 778 779 780
	kobject_get(kobj);
	ss->kobj = kobj;
	ss->func = func;
	ss->data = data;
781
	ss->owner = owner;
782
	INIT_WORK(&ss->work, sysfs_schedule_callback_work);
783 784 785 786
	INIT_LIST_HEAD(&ss->workq_list);
	mutex_lock(&sysfs_workq_mutex);
	list_add_tail(&ss->workq_list, &sysfs_workq);
	mutex_unlock(&sysfs_workq_mutex);
787
	queue_work(sysfs_workqueue, &ss->work);
788 789 790 791
	return 0;
}
EXPORT_SYMBOL_GPL(sysfs_schedule_callback);

792

L
Linus Torvalds 已提交
793 794
EXPORT_SYMBOL_GPL(sysfs_create_file);
EXPORT_SYMBOL_GPL(sysfs_remove_file);
795 796
EXPORT_SYMBOL_GPL(sysfs_remove_files);
EXPORT_SYMBOL_GPL(sysfs_create_files);