file.c 18 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1
/*
Tejun Heo's avatar
Tejun Heo committed
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.
Linus Torvalds's avatar
Linus Torvalds committed
11
12
13
14
 */

#include <linux/module.h>
#include <linux/kobject.h>
15
#include <linux/kallsyms.h>
16
#include <linux/slab.h>
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>
Andrew Morton's avatar
Andrew Morton committed
22
#include <linux/limits.h>
Linus Torvalds's avatar
Linus Torvalds committed
23
24
25
26
#include <asm/uaccess.h>

#include "sysfs.h"

Andrew Morton's avatar
Andrew Morton committed
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);
}

Tejun Heo's avatar
Tejun Heo committed
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.
 */
Jiri Slaby's avatar
Jiri Slaby committed
43
static DEFINE_SPINLOCK(sysfs_open_dirent_lock);
Tejun Heo's avatar
Tejun Heo committed
44
45
46

struct sysfs_open_dirent {
	atomic_t		refcnt;
47
48
	atomic_t		event;
	wait_queue_head_t	poll;
Tejun Heo's avatar
Tejun Heo committed
49
50
51
	struct list_head	buffers; /* goes through sysfs_buffer.list */
};

52
53
54
55
56
struct sysfs_buffer {
	size_t			count;
	loff_t			pos;
	char			* page;
	struct sysfs_ops	* ops;
57
	struct mutex		mutex;
58
59
	int			needs_read_fill;
	int			event;
Tejun Heo's avatar
Tejun Heo committed
60
	struct list_head	list;
61
};
Linus Torvalds's avatar
Linus Torvalds committed
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.
Linus Torvalds's avatar
Linus Torvalds committed
73
74
75
 */
static int fill_read_buffer(struct dentry * dentry, struct sysfs_buffer * buffer)
{
76
	struct sysfs_dirent *attr_sd = dentry->d_fsdata;
77
	struct kobject *kobj = attr_sd->s_parent->s_dir.kobj;
Linus Torvalds's avatar
Linus Torvalds committed
78
79
80
81
82
83
84
85
86
	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;

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

91
	buffer->event = atomic_read(&attr_sd->s_attr.open->event);
92
	count = ops->show(kobj, attr_sd->s_attr.attr, buffer->page);
93
94
95

	sysfs_put_active_two(attr_sd);

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;
Linus Torvalds's avatar
Linus Torvalds committed
108
		buffer->count = count;
109
	} else {
Linus Torvalds's avatar
Linus Torvalds committed
110
		ret = count;
111
	}
Linus Torvalds's avatar
Linus Torvalds committed
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) {
142
		retval = fill_read_buffer(file->f_path.dentry,buffer);
143
		if (retval)
Linus Torvalds's avatar
Linus Torvalds committed
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);
Linus Torvalds's avatar
Linus Torvalds committed
150
out:
151
	mutex_unlock(&buffer->mutex);
Linus Torvalds's avatar
Linus Torvalds committed
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.
Linus Torvalds's avatar
Linus Torvalds committed
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;
Linus Torvalds's avatar
Linus Torvalds committed
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;
Linus Torvalds's avatar
Linus Torvalds committed
182
183
184
185
186
187
	return error ? -EFAULT : count;
}


/**
 *	flush_write_buffer - push buffer to kobject.
188
 *	@dentry:	dentry to the attribute
Linus Torvalds's avatar
Linus Torvalds committed
189
 *	@buffer:	data buffer for file.
190
 *	@count:		number of bytes
Linus Torvalds's avatar
Linus Torvalds committed
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
Linus Torvalds's avatar
Linus Torvalds committed
198
199
flush_write_buffer(struct dentry * dentry, struct sysfs_buffer * buffer, size_t count)
{
200
	struct sysfs_dirent *attr_sd = dentry->d_fsdata;
201
	struct kobject *kobj = attr_sd->s_parent->s_dir.kobj;
Linus Torvalds's avatar
Linus Torvalds committed
202
	struct sysfs_ops * ops = buffer->ops;
203
204
205
206
207
208
	int rc;

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

209
	rc = ops->store(kobj, attr_sd->s_attr.attr, buffer->page, count);
210
211

	sysfs_put_active_two(attr_sd);
Linus Torvalds's avatar
Linus Torvalds committed
212

213
	return rc;
Linus Torvalds's avatar
Linus Torvalds committed
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);
Linus Torvalds's avatar
Linus Torvalds committed
241
242
	len = fill_write_buffer(buffer, buf, count);
	if (len > 0)
243
		len = flush_write_buffer(file->f_path.dentry, buffer, len);
Linus Torvalds's avatar
Linus Torvalds committed
244
245
	if (len > 0)
		*ppos += len;
246
	mutex_unlock(&buffer->mutex);
Linus Torvalds's avatar
Linus Torvalds committed
247
248
249
	return len;
}

Tejun Heo's avatar
Tejun Heo committed
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
287
288
289
290
291
292
293
294
295
296
/**
 *	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);
297
298
	atomic_set(&new_od->event, 1);
	init_waitqueue_head(&new_od->poll);
Tejun Heo's avatar
Tejun Heo committed
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
	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);
}

332
static int sysfs_open_file(struct inode *inode, struct file *file)
Linus Torvalds's avatar
Linus Torvalds committed
333
{
334
	struct sysfs_dirent *attr_sd = file->f_path.dentry->d_fsdata;
335
	struct kobject *kobj = attr_sd->s_parent->s_dir.kobj;
336
337
338
	struct sysfs_buffer *buffer;
	struct sysfs_ops *ops;
	int error = -EACCES;
Andrew Morton's avatar
Andrew Morton committed
339
340
341
342
343
	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);
Linus Torvalds's avatar
Linus Torvalds committed
344

345
346
347
	/* need attr_sd for attr and ops, its parent for kobj */
	if (!sysfs_get_active_two(attr_sd))
		return -ENODEV;
Linus Torvalds's avatar
Linus Torvalds committed
348

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

	/* 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)
364
			goto err_out;
Linus Torvalds's avatar
Linus Torvalds committed
365
366
367
368
369
370
371
372
	}

	/* 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)
373
			goto err_out;
Linus Torvalds's avatar
Linus Torvalds committed
374
375
376
377
378
	}

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

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

Tejun Heo's avatar
Tejun Heo committed
389
390
391
392
393
	/* make sure we have open dirent struct */
	error = sysfs_get_open_dirent(attr_sd, buffer);
	if (error)
		goto err_free;

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

Tejun Heo's avatar
Tejun Heo committed
398
399
 err_free:
	kfree(buffer);
400
 err_out:
401
	sysfs_put_active_two(attr_sd);
Linus Torvalds's avatar
Linus Torvalds committed
402
403
404
	return error;
}

Tejun Heo's avatar
Tejun Heo committed
405
static int sysfs_release(struct inode *inode, struct file *filp)
Linus Torvalds's avatar
Linus Torvalds committed
406
{
Tejun Heo's avatar
Tejun Heo committed
407
	struct sysfs_dirent *sd = filp->f_path.dentry->d_fsdata;
408
	struct sysfs_buffer *buffer = filp->private_data;
Linus Torvalds's avatar
Linus Torvalds committed
409

Tejun Heo's avatar
Tejun Heo committed
410
411
	sysfs_put_open_dirent(sd, buffer);

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

Linus Torvalds's avatar
Linus Torvalds committed
416
417
418
	return 0;
}

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

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

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

444
445
	sysfs_put_active_two(attr_sd);

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

449
450
451
452
453
	return 0;

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

456
void sysfs_notify(struct kobject *k, char *dir, char *attr)
457
{
458
	struct sysfs_dirent *sd = k->sd;
459

460
461
462
463
464
465
466
	mutex_lock(&sysfs_mutex);

	if (sd && dir)
		sd = sysfs_find_dirent(sd, dir);
	if (sd && attr)
		sd = sysfs_find_dirent(sd, attr);
	if (sd) {
467
468
469
470
471
472
473
474
475
476
477
		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);
478
	}
479
480

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

484
const struct file_operations sysfs_file_operations = {
Linus Torvalds's avatar
Linus Torvalds committed
485
486
487
488
489
	.read		= sysfs_read_file,
	.write		= sysfs_write_file,
	.llseek		= generic_file_llseek,
	.open		= sysfs_open_file,
	.release	= sysfs_release,
490
	.poll		= sysfs_poll,
Linus Torvalds's avatar
Linus Torvalds committed
491
492
};

493
494
int sysfs_add_file_mode(struct sysfs_dirent *dir_sd,
			const struct attribute *attr, int type, mode_t amode)
Linus Torvalds's avatar
Linus Torvalds committed
495
{
496
	umode_t mode = (amode & S_IALLUGO) | S_IFREG;
497
	struct sysfs_addrm_cxt acxt;
498
	struct sysfs_dirent *sd;
499
	int rc;
Linus Torvalds's avatar
Linus Torvalds committed
500

501
502
503
	sd = sysfs_new_dirent(attr->name, mode, type);
	if (!sd)
		return -ENOMEM;
504
	sd->s_attr.attr = (void *)attr;
Linus Torvalds's avatar
Linus Torvalds committed
505

506
	sysfs_addrm_start(&acxt, dir_sd);
507
508
	rc = sysfs_add_one(&acxt, sd);
	sysfs_addrm_finish(&acxt);
509

510
	if (rc)
511
		sysfs_put(sd);
512

513
	return rc;
Linus Torvalds's avatar
Linus Torvalds committed
514
515
516
}


517
518
519
520
521
522
523
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);
}


Linus Torvalds's avatar
Linus Torvalds committed
524
525
526
/**
 *	sysfs_create_file - create an attribute file for an object.
 *	@kobj:	object we're creating for. 
527
 *	@attr:	attribute descriptor.
Linus Torvalds's avatar
Linus Torvalds committed
528
529
530
531
 */

int sysfs_create_file(struct kobject * kobj, const struct attribute * attr)
{
532
	BUG_ON(!kobj || !kobj->sd || !attr);
Linus Torvalds's avatar
Linus Torvalds committed
533

534
	return sysfs_add_file(kobj->sd, attr, SYSFS_KOBJ_ATTR);
Linus Torvalds's avatar
Linus Torvalds committed
535
536
537
538

}


539
540
541
542
543
544
545
546
547
/**
 * 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)
{
548
	struct sysfs_dirent *dir_sd;
549
550
	int error;

551
552
553
554
555
	if (group)
		dir_sd = sysfs_get_dirent(kobj->sd, group);
	else
		dir_sd = sysfs_get(kobj->sd);

556
557
558
559
560
561
	if (!dir_sd)
		return -ENOENT;

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

562
563
564
565
	return error;
}
EXPORT_SYMBOL_GPL(sysfs_add_file_to_group);

566
567
568
569
570
571
572
573
574
/**
 * 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)
{
575
576
	struct sysfs_dirent *victim_sd = NULL;
	struct dentry *victim = NULL;
577
578
	struct inode * inode;
	struct iattr newattrs;
579
580
581
582
583
584
585
	int rc;

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

586
	mutex_lock(&sysfs_rename_mutex);
587
	victim = sysfs_get_dentry(victim_sd);
588
	mutex_unlock(&sysfs_rename_mutex);
589
590
591
592
	if (IS_ERR(victim)) {
		rc = PTR_ERR(victim);
		victim = NULL;
		goto out;
593
594
	}

595
	inode = victim->d_inode;
596

597
	mutex_lock(&inode->i_mutex);
598

599
600
	newattrs.ia_mode = (mode & S_IALLUGO) | (inode->i_mode & ~S_IALLUGO);
	newattrs.ia_valid = ATTR_MODE | ATTR_CTIME;
601
602
	newattrs.ia_ctime = current_fs_time(inode->i_sb);
	rc = sysfs_setattr(victim, &newattrs);
603
604

	if (rc == 0) {
605
		fsnotify_change(victim, newattrs.ia_valid);
606
607
608
609
610
		mutex_lock(&sysfs_mutex);
		victim_sd->s_mode = newattrs.ia_mode;
		mutex_unlock(&sysfs_mutex);
	}

611
612
613
614
615
	mutex_unlock(&inode->i_mutex);
 out:
	dput(victim);
	sysfs_put(victim_sd);
	return rc;
616
617
618
619
}
EXPORT_SYMBOL_GPL(sysfs_chmod_file);


Linus Torvalds's avatar
Linus Torvalds committed
620
621
622
623
624
625
626
627
628
629
/**
 *	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)
{
630
	sysfs_hash_and_remove(kobj->sd, attr->name);
Linus Torvalds's avatar
Linus Torvalds committed
631
632
633
}


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

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

656
657
658
659
struct sysfs_schedule_callback_struct {
	struct kobject 		*kobj;
	void			(*func)(void *);
	void			*data;
660
	struct module		*owner;
661
662
663
664
665
666
667
668
669
670
	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);
671
	module_put(ss->owner);
672
673
674
675
676
677
678
679
	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.
680
 * @owner: module owning the callback code
681
682
683
684
685
686
687
688
689
690
691
692
 *
 * 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
693
 * be allocated, -ENODEV if a reference to @owner isn't available.
694
695
 */
int sysfs_schedule_callback(struct kobject *kobj, void (*func)(void *),
696
		void *data, struct module *owner)
697
698
699
{
	struct sysfs_schedule_callback_struct *ss;

700
701
	if (!try_module_get(owner))
		return -ENODEV;
702
	ss = kmalloc(sizeof(*ss), GFP_KERNEL);
703
704
	if (!ss) {
		module_put(owner);
705
		return -ENOMEM;
706
	}
707
708
709
710
	kobject_get(kobj);
	ss->kobj = kobj;
	ss->func = func;
	ss->data = data;
711
	ss->owner = owner;
712
713
714
715
716
717
	INIT_WORK(&ss->work, sysfs_schedule_callback_work);
	schedule_work(&ss->work);
	return 0;
}
EXPORT_SYMBOL_GPL(sysfs_schedule_callback);

718

Linus Torvalds's avatar
Linus Torvalds committed
719
720
EXPORT_SYMBOL_GPL(sysfs_create_file);
EXPORT_SYMBOL_GPL(sysfs_remove_file);