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

#include <linux/module.h>
R
Robert Love 已提交
6
#include <linux/fsnotify.h>
L
Linus Torvalds 已提交
7
#include <linux/kobject.h>
8
#include <linux/namei.h>
9
#include <linux/poll.h>
10
#include <linux/list.h>
L
Linus Torvalds 已提交
11 12 13 14 15 16 17 18
#include <asm/uaccess.h>
#include <asm/semaphore.h>

#include "sysfs.h"

#define to_subsys(k) container_of(k,struct subsystem,kset.kobj)
#define to_sattr(a) container_of(a,struct subsys_attribute,attr)

M
Martin Waitz 已提交
19
/*
L
Linus Torvalds 已提交
20 21 22 23 24 25 26 27 28
 * 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)
{
	struct subsystem * s = to_subsys(kobj);
	struct subsys_attribute * sattr = to_sattr(attr);
29
	ssize_t ret = -EIO;
L
Linus Torvalds 已提交
30 31 32 33 34 35 36 37 38 39 40 41

	if (sattr->show)
		ret = sattr->show(s,page);
	return ret;
}

static ssize_t 
subsys_attr_store(struct kobject * kobj, struct attribute * attr, 
		  const char * page, size_t count)
{
	struct subsystem * s = to_subsys(kobj);
	struct subsys_attribute * sattr = to_sattr(attr);
42
	ssize_t ret = -EIO;
L
Linus Torvalds 已提交
43 44 45 46 47 48 49 50 51 52 53

	if (sattr->store)
		ret = sattr->store(s,page,count);
	return ret;
}

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

54 55 56 57 58
/**
 *	add_to_collection - add buffer to a collection
 *	@buffer:	buffer to be added
 *	@node		inode of set to add to
 */
L
Linus Torvalds 已提交
59

60 61 62 63
static inline void
add_to_collection(struct sysfs_buffer *buffer, struct inode *node)
{
	struct sysfs_buffer_collection *set = node->i_private;
L
Linus Torvalds 已提交
64

65 66 67 68 69 70 71 72 73 74 75 76
	mutex_lock(&node->i_mutex);
	list_add(&buffer->associates, &set->associates);
	mutex_unlock(&node->i_mutex);
}

static inline void
remove_from_collection(struct sysfs_buffer *buffer, struct inode *node)
{
	mutex_lock(&node->i_mutex);
	list_del(&buffer->associates);
	mutex_unlock(&node->i_mutex);
}
L
Linus Torvalds 已提交
77 78 79 80 81 82 83 84 85

/**
 *	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. 
86 87
 *	This is called only once, on the file's first read unless an error
 *	is returned.
L
Linus Torvalds 已提交
88 89 90
 */
static int fill_read_buffer(struct dentry * dentry, struct sysfs_buffer * buffer)
{
91
	struct sysfs_dirent * sd = dentry->d_fsdata;
L
Linus Torvalds 已提交
92 93 94 95 96 97 98 99 100 101 102
	struct attribute * attr = to_attr(dentry);
	struct kobject * kobj = to_kobj(dentry->d_parent);
	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
	buffer->event = atomic_read(&sd->s_event);
L
Linus Torvalds 已提交
104 105
	count = ops->show(kobj,attr,buffer->page);
	BUG_ON(count > (ssize_t)PAGE_SIZE);
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
	return ret;
}


/**
 *	flush_read_buffer - push buffer to userspace.
 *	@buffer:	data buffer for file.
119
 *	@buf:		user-passed buffer.
L
Linus Torvalds 已提交
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 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170
 *	@count:		number of bytes requested.
 *	@ppos:		file position.
 *
 *	Copy the buffer we filled in fill_read_buffer() to userspace.
 *	This is done at the reader's leisure, copying and advancing 
 *	the amount they specify each time.
 *	This may be called continuously until the buffer is empty.
 */
static int flush_read_buffer(struct sysfs_buffer * buffer, char __user * buf,
			     size_t count, loff_t * ppos)
{
	int error;

	if (*ppos > buffer->count)
		return 0;

	if (count > (buffer->count - *ppos))
		count = buffer->count - *ppos;

	error = copy_to_user(buf,buffer->page + *ppos,count);
	if (!error)
		*ppos += count;
	return error ? -EFAULT : count;
}

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

	down(&buffer->sem);
171 172 173 174
	if (buffer->orphaned) {
		retval = -ENODEV;
		goto out;
	}
L
Linus Torvalds 已提交
175
	if (buffer->needs_read_fill) {
176
		if ((retval = fill_read_buffer(file->f_path.dentry,buffer)))
L
Linus Torvalds 已提交
177 178
			goto out;
	}
179 180
	pr_debug("%s: count = %zd, ppos = %lld, buf = %s\n",
		 __FUNCTION__, count, *ppos, buffer->page);
L
Linus Torvalds 已提交
181 182 183 184 185 186 187 188 189
	retval = flush_read_buffer(buffer,buf,count,ppos);
out:
	up(&buffer->sem);
	return retval;
}

/**
 *	fill_write_buffer - copy buffer from userspace.
 *	@buffer:	data buffer for file.
190
 *	@buf:		data from user.
L
Linus Torvalds 已提交
191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207
 *	@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)
208
		count = PAGE_SIZE - 1;
L
Linus Torvalds 已提交
209 210
	error = copy_from_user(buffer->page,buf,count);
	buffer->needs_read_fill = 1;
211 212 213
	/* 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 已提交
214 215 216 217 218 219
	return error ? -EFAULT : count;
}


/**
 *	flush_write_buffer - push buffer to kobject.
M
Martin Waitz 已提交
220
 *	@dentry:	dentry to the attribute
L
Linus Torvalds 已提交
221
 *	@buffer:	data buffer for file.
M
Martin Waitz 已提交
222
 *	@count:		number of bytes
L
Linus Torvalds 已提交
223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263
 *
 *	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().
 */

static int 
flush_write_buffer(struct dentry * dentry, struct sysfs_buffer * buffer, size_t count)
{
	struct attribute * attr = to_attr(dentry);
	struct kobject * kobj = to_kobj(dentry->d_parent);
	struct sysfs_ops * ops = buffer->ops;

	return ops->store(kobj,attr,buffer->page,count);
}


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

	down(&buffer->sem);
264 265 266 267
	if (buffer->orphaned) {
		len = -ENODEV;
		goto out;
	}
L
Linus Torvalds 已提交
268 269
	len = fill_write_buffer(buffer, buf, count);
	if (len > 0)
270
		len = flush_write_buffer(file->f_path.dentry, buffer, len);
L
Linus Torvalds 已提交
271 272
	if (len > 0)
		*ppos += len;
273
out:
L
Linus Torvalds 已提交
274 275 276 277
	up(&buffer->sem);
	return len;
}

278
static int sysfs_open_file(struct inode *inode, struct file *file)
L
Linus Torvalds 已提交
279
{
280 281
	struct kobject *kobj = sysfs_get_kobject(file->f_path.dentry->d_parent);
	struct attribute * attr = to_attr(file->f_path.dentry);
282
	struct sysfs_buffer_collection *set;
L
Linus Torvalds 已提交
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
	struct sysfs_buffer * buffer;
	struct sysfs_ops * ops = NULL;
	int error = 0;

	if (!kobj || !attr)
		goto Einval;

	/* Grab the module reference for this attribute if we have one */
	if (!try_module_get(attr->owner)) {
		error = -ENODEV;
		goto Done;
	}

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

	/* No sysfs operations, either from having no subsystem,
	 * or the subsystem have no operations.
	 */
	if (!ops)
		goto Eaccess;

312 313 314 315 316 317 318 319 320 321 322 323
	/* make sure we have a collection to add our buffers to */
	mutex_lock(&inode->i_mutex);
	if (!(set = inode->i_private)) {
		if (!(set = inode->i_private = kmalloc(sizeof(struct sysfs_buffer_collection), GFP_KERNEL))) {
			error = -ENOMEM;
			goto Done;
		} else {
			INIT_LIST_HEAD(&set->associates);
		}
	}
	mutex_unlock(&inode->i_mutex);

L
Linus Torvalds 已提交
324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346
	/* 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)
			goto Eaccess;

	}

	/* 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)
			goto Eaccess;
	}

	/* No error? Great, allocate a buffer for the file, and store it
	 * it in file->private_data for easy access.
	 */
347
	buffer = kzalloc(sizeof(struct sysfs_buffer), GFP_KERNEL);
L
Linus Torvalds 已提交
348
	if (buffer) {
349
		INIT_LIST_HEAD(&buffer->associates);
L
Linus Torvalds 已提交
350 351 352
		init_MUTEX(&buffer->sem);
		buffer->needs_read_fill = 1;
		buffer->ops = ops;
353
		add_to_collection(buffer, inode);
L
Linus Torvalds 已提交
354 355 356 357 358 359 360 361 362 363 364 365
		file->private_data = buffer;
	} else
		error = -ENOMEM;
	goto Done;

 Einval:
	error = -EINVAL;
	goto Done;
 Eaccess:
	error = -EACCES;
	module_put(attr->owner);
 Done:
M
Mariusz Kozlowski 已提交
366
	if (error)
L
Linus Torvalds 已提交
367 368 369 370 371 372
		kobject_put(kobj);
	return error;
}

static int sysfs_release(struct inode * inode, struct file * filp)
{
373 374
	struct kobject * kobj = to_kobj(filp->f_path.dentry->d_parent);
	struct attribute * attr = to_attr(filp->f_path.dentry);
L
Linus Torvalds 已提交
375 376 377
	struct module * owner = attr->owner;
	struct sysfs_buffer * buffer = filp->private_data;

378 379
	if (buffer)
		remove_from_collection(buffer, inode);
M
Mariusz Kozlowski 已提交
380
	kobject_put(kobj);
L
Linus Torvalds 已提交
381 382 383 384 385 386 387 388 389 390 391
	/* After this point, attr should not be accessed. */
	module_put(owner);

	if (buffer) {
		if (buffer->page)
			free_page((unsigned long)buffer->page);
		kfree(buffer);
	}
	return 0;
}

392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408
/* 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
 * to see if it supports poll (Nether 'poll' or 'select' return
 * 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;
409 410
	struct kobject * kobj = to_kobj(filp->f_path.dentry->d_parent);
	struct sysfs_dirent * sd = filp->f_path.dentry->d_fsdata;
411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462
	int res = 0;

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

	if (buffer->event != atomic_read(&sd->s_event)) {
		res = POLLERR|POLLPRI;
		buffer->needs_read_fill = 1;
	}

	return res;
}


static struct dentry *step_down(struct dentry *dir, const char * name)
{
	struct dentry * de;

	if (dir == NULL || dir->d_inode == NULL)
		return NULL;

	mutex_lock(&dir->d_inode->i_mutex);
	de = lookup_one_len(name, dir, strlen(name));
	mutex_unlock(&dir->d_inode->i_mutex);
	dput(dir);
	if (IS_ERR(de))
		return NULL;
	if (de->d_inode == NULL) {
		dput(de);
		return NULL;
	}
	return de;
}

void sysfs_notify(struct kobject * k, char *dir, char *attr)
{
	struct dentry *de = k->dentry;
	if (de)
		dget(de);
	if (de && dir)
		de = step_down(de, dir);
	if (de && attr)
		de = step_down(de, attr);
	if (de) {
		struct sysfs_dirent * sd = de->d_fsdata;
		if (sd)
			atomic_inc(&sd->s_event);
		wake_up_interruptible(&k->poll);
		dput(de);
	}
}
EXPORT_SYMBOL_GPL(sysfs_notify);

463
const struct file_operations sysfs_file_operations = {
L
Linus Torvalds 已提交
464 465 466 467 468
	.read		= sysfs_read_file,
	.write		= sysfs_write_file,
	.llseek		= generic_file_llseek,
	.open		= sysfs_open_file,
	.release	= sysfs_release,
469
	.poll		= sysfs_poll,
L
Linus Torvalds 已提交
470 471 472 473 474 475 476
};


int sysfs_add_file(struct dentry * dir, const struct attribute * attr, int type)
{
	struct sysfs_dirent * parent_sd = dir->d_fsdata;
	umode_t mode = (attr->mode & S_IALLUGO) | S_IFREG;
477
	int error = -EEXIST;
L
Linus Torvalds 已提交
478

479
	mutex_lock(&dir->d_inode->i_mutex);
480 481 482
	if (!sysfs_dirent_exist(parent_sd, attr->name))
		error = sysfs_make_dirent(parent_sd, NULL, (void *)attr,
					  mode, type);
483
	mutex_unlock(&dir->d_inode->i_mutex);
L
Linus Torvalds 已提交
484 485 486 487 488 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

	return error;
}


/**
 *	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)
{
	BUG_ON(!kobj || !kobj->dentry || !attr);

	return sysfs_add_file(kobj->dentry, attr, SYSFS_KOBJ_ATTR);

}


/**
 * sysfs_update_file - update the modified timestamp on an object attribute.
 * @kobj: object we're acting for.
 * @attr: attribute descriptor.
 */
int sysfs_update_file(struct kobject * kobj, const struct attribute * attr)
{
	struct dentry * dir = kobj->dentry;
	struct dentry * victim;
	int res = -ENOENT;

515
	mutex_lock(&dir->d_inode->i_mutex);
516
	victim = lookup_one_len(attr->name, dir, strlen(attr->name));
L
Linus Torvalds 已提交
517 518 519 520 521
	if (!IS_ERR(victim)) {
		/* make sure dentry is really there */
		if (victim->d_inode && 
		    (victim->d_parent->d_inode == dir->d_inode)) {
			victim->d_inode->i_mtime = CURRENT_TIME;
R
Robert Love 已提交
522
			fsnotify_modify(victim);
L
Linus Torvalds 已提交
523 524 525 526 527
			res = 0;
		} else
			d_drop(victim);
		
		/**
528
		 * Drop the reference acquired from lookup_one_len() above.
L
Linus Torvalds 已提交
529 530 531
		 */
		dput(victim);
	}
532
	mutex_unlock(&dir->d_inode->i_mutex);
L
Linus Torvalds 已提交
533 534 535 536 537

	return res;
}


538 539 540 541 542 543 544 545 546 547 548
/**
 * 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)
{
	struct dentry *dir = kobj->dentry;
	struct dentry *victim;
549 550
	struct inode * inode;
	struct iattr newattrs;
551 552
	int res = -ENOENT;

553
	mutex_lock(&dir->d_inode->i_mutex);
554
	victim = lookup_one_len(attr->name, dir, strlen(attr->name));
555 556 557
	if (!IS_ERR(victim)) {
		if (victim->d_inode &&
		    (victim->d_parent->d_inode == dir->d_inode)) {
558
			inode = victim->d_inode;
559
			mutex_lock(&inode->i_mutex);
560 561 562 563
			newattrs.ia_mode = (mode & S_IALLUGO) |
						(inode->i_mode & ~S_IALLUGO);
			newattrs.ia_valid = ATTR_MODE | ATTR_CTIME;
			res = notify_change(victim, &newattrs);
564
			mutex_unlock(&inode->i_mutex);
565
		}
566
		dput(victim);
567
	}
568
	mutex_unlock(&dir->d_inode->i_mutex);
569 570 571 572 573 574

	return res;
}
EXPORT_SYMBOL_GPL(sysfs_chmod_file);


L
Linus Torvalds 已提交
575 576 577 578 579 580 581 582 583 584
/**
 *	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)
{
585
	sysfs_hash_and_remove(kobj->dentry, attr->name);
L
Linus Torvalds 已提交
586 587 588 589 590 591
}


EXPORT_SYMBOL_GPL(sysfs_create_file);
EXPORT_SYMBOL_GPL(sysfs_remove_file);
EXPORT_SYMBOL_GPL(sysfs_update_file);