file.c 19 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>
23
#include <linux/uaccess.h>
24
#include <linux/seq_file.h>
Linus Torvalds's avatar
Linus Torvalds committed
25
26
27

#include "sysfs.h"

Tejun Heo's avatar
Tejun Heo committed
28
/*
29
 * There's one sysfs_open_file for each open file and one sysfs_open_dirent
Tejun Heo's avatar
Tejun Heo committed
30
 * for each sysfs_dirent with one or more open files.
Tejun Heo's avatar
Tejun Heo committed
31
 *
Tejun Heo's avatar
Tejun Heo committed
32
33
34
 * sysfs_dirent->s_attr.open points to sysfs_open_dirent.  s_attr.open is
 * protected by sysfs_open_dirent_lock.
 *
35
36
 * filp->private_data points to seq_file whose ->private points to
 * sysfs_open_file.  sysfs_open_files are chained at
37
 * sysfs_open_dirent->files, which is protected by sysfs_open_file_mutex.
Tejun Heo's avatar
Tejun Heo committed
38
 */
Jiri Slaby's avatar
Jiri Slaby committed
39
static DEFINE_SPINLOCK(sysfs_open_dirent_lock);
Tejun Heo's avatar
Tejun Heo committed
40
static DEFINE_MUTEX(sysfs_open_file_mutex);
Tejun Heo's avatar
Tejun Heo committed
41
42
43

struct sysfs_open_dirent {
	atomic_t		refcnt;
44
45
	atomic_t		event;
	wait_queue_head_t	poll;
46
	struct list_head	files; /* goes through sysfs_open_file.list */
Tejun Heo's avatar
Tejun Heo committed
47
48
};

49
struct sysfs_open_file {
50
51
	struct sysfs_dirent	*sd;
	struct file		*file;
52
	struct mutex		mutex;
53
	int			event;
Tejun Heo's avatar
Tejun Heo committed
54
	struct list_head	list;
55
};
Linus Torvalds's avatar
Linus Torvalds committed
56

57
58
59
60
61
static bool sysfs_is_bin(struct sysfs_dirent *sd)
{
	return sysfs_type(sd) == SYSFS_KOBJ_BIN_ATTR;
}

62
63
64
65
66
static struct sysfs_open_file *sysfs_of(struct file *file)
{
	return ((struct seq_file *)file->private_data)->private;
}

Tejun Heo's avatar
Tejun Heo committed
67
68
69
70
71
72
73
74
75
76
77
78
/*
 * Determine ktype->sysfs_ops for the given sysfs_dirent.  This function
 * must be called while holding an active reference.
 */
static const struct sysfs_ops *sysfs_file_ops(struct sysfs_dirent *sd)
{
	struct kobject *kobj = sd->s_parent->s_dir.kobj;

	lockdep_assert_held(sd);
	return kobj->ktype ? kobj->ktype->sysfs_ops : NULL;
}

79
80
81
82
/*
 * Reads on sysfs are handled through seq_file, which takes care of hairy
 * details like buffering and seeking.  The following function pipes
 * sysfs_ops->show() result through seq_file.
Linus Torvalds's avatar
Linus Torvalds committed
83
 */
84
static int sysfs_seq_show(struct seq_file *sf, void *v)
Linus Torvalds's avatar
Linus Torvalds committed
85
{
86
87
	struct sysfs_open_file *of = sf->private;
	struct kobject *kobj = of->sd->s_parent->s_dir.kobj;
Tejun Heo's avatar
Tejun Heo committed
88
	const struct sysfs_ops *ops;
89
	char *buf;
Linus Torvalds's avatar
Linus Torvalds committed
90
91
	ssize_t count;

92
93
94
95
96
97
	/* acquire buffer and ensure that it's >= PAGE_SIZE */
	count = seq_get_buf(sf, &buf);
	if (count < PAGE_SIZE) {
		seq_commit(sf, -1);
		return 0;
	}
Linus Torvalds's avatar
Linus Torvalds committed
98

99
100
101
102
103
104
105
106
	/*
	 * Need @of->sd for attr and ops, its parent for kobj.  @of->mutex
	 * nests outside active ref and is just to ensure that the ops
	 * aren't called concurrently for the same open file.
	 */
	mutex_lock(&of->mutex);
	if (!sysfs_get_active(of->sd)) {
		mutex_unlock(&of->mutex);
107
		return -ENODEV;
108
	}
109

110
	of->event = atomic_read(&of->sd->s_attr.open->event);
Tejun Heo's avatar
Tejun Heo committed
111

112
113
114
115
116
117
118
119
120
	/*
	 * Lookup @ops and invoke show().  Control may reach here via seq
	 * file lseek even if @ops->show() isn't implemented.
	 */
	ops = sysfs_file_ops(of->sd);
	if (ops->show)
		count = ops->show(kobj, of->sd->s_attr.attr, buf);
	else
		count = 0;
121

122
123
124
125
126
	sysfs_put_active(of->sd);
	mutex_unlock(&of->mutex);

	if (count < 0)
		return count;
127

128
129
130
131
	/*
	 * The code works fine with PAGE_SIZE return but it's likely to
	 * indicate truncated result or overflow in normal use cases.
	 */
132
133
134
135
136
137
	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;
	}
138
139
	seq_commit(sf, count);
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
140
141
142
}

/**
Tejun Heo's avatar
Tejun Heo committed
143
144
145
 * flush_write_buffer - push buffer to kobject
 * @of: open file
 * @buf: data buffer for file
146
 * @off: file offset to write to
Tejun Heo's avatar
Tejun Heo committed
147
 * @count: number of bytes
Linus Torvalds's avatar
Linus Torvalds committed
148
 *
Tejun Heo's avatar
Tejun Heo committed
149
150
 * Get the correct pointers for the kobject and the attribute we're dealing
 * with, then call the store() method for it with @buf.
Linus Torvalds's avatar
Linus Torvalds committed
151
 */
152
static int flush_write_buffer(struct sysfs_open_file *of, char *buf, loff_t off,
Tejun Heo's avatar
Tejun Heo committed
153
			      size_t count)
Linus Torvalds's avatar
Linus Torvalds committed
154
{
155
	struct kobject *kobj = of->sd->s_parent->s_dir.kobj;
Tejun Heo's avatar
Tejun Heo committed
156
	int rc = 0;
157

Tejun Heo's avatar
Tejun Heo committed
158
159
160
161
162
163
164
165
	/*
	 * Need @of->sd for attr and ops, its parent for kobj.  @of->mutex
	 * nests outside active ref and is just to ensure that the ops
	 * aren't called concurrently for the same open file.
	 */
	mutex_lock(&of->mutex);
	if (!sysfs_get_active(of->sd)) {
		mutex_unlock(&of->mutex);
166
		return -ENODEV;
Tejun Heo's avatar
Tejun Heo committed
167
	}
168

169
170
171
172
173
174
175
176
177
178
179
180
	if (sysfs_is_bin(of->sd)) {
		struct bin_attribute *battr = of->sd->s_bin_attr.bin_attr;

		rc = -EIO;
		if (battr->write)
			rc = battr->write(of->file, kobj, battr, buf, off,
					  count);
	} else {
		const struct sysfs_ops *ops = sysfs_file_ops(of->sd);

		rc = ops->store(kobj, of->sd->s_attr.attr, buf, count);
	}
181

182
	sysfs_put_active(of->sd);
Tejun Heo's avatar
Tejun Heo committed
183
	mutex_unlock(&of->mutex);
Linus Torvalds's avatar
Linus Torvalds committed
184

185
	return rc;
Linus Torvalds's avatar
Linus Torvalds committed
186
187
188
}

/**
Tejun Heo's avatar
Tejun Heo committed
189
190
191
192
193
194
195
196
 * sysfs_write_file - write an attribute
 * @file: file pointer
 * @user_buf: data to write
 * @count: number of bytes
 * @ppos: starting offset
 *
 * Copy data in from userland and pass it to the matching
 * sysfs_ops->store() by invoking flush_write_buffer().
Linus Torvalds's avatar
Linus Torvalds committed
197
 *
Tejun Heo's avatar
Tejun Heo committed
198
199
200
201
202
 * 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.
Linus Torvalds's avatar
Linus Torvalds committed
203
 */
Tejun Heo's avatar
Tejun Heo committed
204
static ssize_t sysfs_write_file(struct file *file, const char __user *user_buf,
205
				size_t count, loff_t *ppos)
Linus Torvalds's avatar
Linus Torvalds committed
206
{
207
	struct sysfs_open_file *of = sysfs_of(file);
208
	ssize_t len = min_t(size_t, count, PAGE_SIZE);
Tejun Heo's avatar
Tejun Heo committed
209
	char *buf;
Linus Torvalds's avatar
Linus Torvalds committed
210

211
212
213
214
215
216
217
218
	if (sysfs_is_bin(of->sd)) {
		loff_t size = file_inode(file)->i_size;

		if (size <= *ppos)
			return 0;
		len = min_t(ssize_t, len, size - *ppos);
	}

Tejun Heo's avatar
Tejun Heo committed
219
220
221
222
223
224
225
226
227
228
229
230
231
	if (!len)
		return 0;

	buf = kmalloc(len + 1, GFP_KERNEL);
	if (!buf)
		return -ENOMEM;

	if (copy_from_user(buf, user_buf, len)) {
		len = -EFAULT;
		goto out_free;
	}
	buf[len] = '\0';	/* guarantee string termination */

232
	len = flush_write_buffer(of, buf, *ppos, len);
Linus Torvalds's avatar
Linus Torvalds committed
233
234
	if (len > 0)
		*ppos += len;
Tejun Heo's avatar
Tejun Heo committed
235
236
out_free:
	kfree(buf);
Linus Torvalds's avatar
Linus Torvalds committed
237
238
239
	return len;
}

Tejun Heo's avatar
Tejun Heo committed
240
241
242
/**
 *	sysfs_get_open_dirent - get or create sysfs_open_dirent
 *	@sd: target sysfs_dirent
243
 *	@of: sysfs_open_file for this instance of open
Tejun Heo's avatar
Tejun Heo committed
244
245
 *
 *	If @sd->s_attr.open exists, increment its reference count;
246
 *	otherwise, create one.  @of is chained to the files list.
Tejun Heo's avatar
Tejun Heo committed
247
248
249
250
251
252
253
254
 *
 *	LOCKING:
 *	Kernel thread context (may sleep).
 *
 *	RETURNS:
 *	0 on success, -errno on failure.
 */
static int sysfs_get_open_dirent(struct sysfs_dirent *sd,
255
				 struct sysfs_open_file *of)
Tejun Heo's avatar
Tejun Heo committed
256
257
258
259
{
	struct sysfs_open_dirent *od, *new_od = NULL;

 retry:
Tejun Heo's avatar
Tejun Heo committed
260
	mutex_lock(&sysfs_open_file_mutex);
261
	spin_lock_irq(&sysfs_open_dirent_lock);
Tejun Heo's avatar
Tejun Heo committed
262
263
264
265
266
267
268
269
270

	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);
271
		list_add_tail(&of->list, &od->files);
Tejun Heo's avatar
Tejun Heo committed
272
273
	}

274
	spin_unlock_irq(&sysfs_open_dirent_lock);
Tejun Heo's avatar
Tejun Heo committed
275
	mutex_unlock(&sysfs_open_file_mutex);
Tejun Heo's avatar
Tejun Heo committed
276
277
278
279
280
281
282
283
284
285
286
287

	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);
288
289
	atomic_set(&new_od->event, 1);
	init_waitqueue_head(&new_od->poll);
290
	INIT_LIST_HEAD(&new_od->files);
Tejun Heo's avatar
Tejun Heo committed
291
292
293
294
295
296
	goto retry;
}

/**
 *	sysfs_put_open_dirent - put sysfs_open_dirent
 *	@sd: target sysfs_dirent
297
 *	@of: associated sysfs_open_file
Tejun Heo's avatar
Tejun Heo committed
298
 *
299
300
 *	Put @sd->s_attr.open and unlink @of from the files list.  If
 *	reference count reaches zero, disassociate and free it.
Tejun Heo's avatar
Tejun Heo committed
301
302
303
304
305
 *
 *	LOCKING:
 *	None.
 */
static void sysfs_put_open_dirent(struct sysfs_dirent *sd,
306
				  struct sysfs_open_file *of)
Tejun Heo's avatar
Tejun Heo committed
307
308
{
	struct sysfs_open_dirent *od = sd->s_attr.open;
309
	unsigned long flags;
Tejun Heo's avatar
Tejun Heo committed
310

Tejun Heo's avatar
Tejun Heo committed
311
	mutex_lock(&sysfs_open_file_mutex);
312
	spin_lock_irqsave(&sysfs_open_dirent_lock, flags);
Tejun Heo's avatar
Tejun Heo committed
313

314
	list_del(&of->list);
Tejun Heo's avatar
Tejun Heo committed
315
316
317
318
319
	if (atomic_dec_and_test(&od->refcnt))
		sd->s_attr.open = NULL;
	else
		od = NULL;

320
	spin_unlock_irqrestore(&sysfs_open_dirent_lock, flags);
Tejun Heo's avatar
Tejun Heo committed
321
	mutex_unlock(&sysfs_open_file_mutex);
Tejun Heo's avatar
Tejun Heo committed
322
323
324
325

	kfree(od);
}

326
static int sysfs_open_file(struct inode *inode, struct file *file)
Linus Torvalds's avatar
Linus Torvalds committed
327
{
328
	struct sysfs_dirent *attr_sd = file->f_path.dentry->d_fsdata;
329
	struct kobject *kobj = attr_sd->s_parent->s_dir.kobj;
330
	struct sysfs_open_file *of;
331
	const struct sysfs_ops *ops;
332
	int error = -EACCES;
Linus Torvalds's avatar
Linus Torvalds committed
333

334
	/* need attr_sd for attr and ops, its parent for kobj */
335
	if (!sysfs_get_active(attr_sd))
336
		return -ENODEV;
Linus Torvalds's avatar
Linus Torvalds committed
337

338
	/* every kobject with an attribute needs a ktype assigned */
Tejun Heo's avatar
Tejun Heo committed
339
340
341
342
	ops = sysfs_file_ops(attr_sd);
	if (WARN(!ops, KERN_ERR
		 "missing sysfs attribute operations for kobject: %s\n",
		 kobject_name(kobj)))
343
		goto err_out;
Linus Torvalds's avatar
Linus Torvalds committed
344
345

	/* File needs write support.
346
	 * The inode's perms must say it's ok,
Linus Torvalds's avatar
Linus Torvalds committed
347
348
349
350
	 * and we must have a store method.
	 */
	if (file->f_mode & FMODE_WRITE) {
		if (!(inode->i_mode & S_IWUGO) || !ops->store)
351
			goto err_out;
Linus Torvalds's avatar
Linus Torvalds committed
352
353
354
355
356
357
358
359
	}

	/* 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)
360
			goto err_out;
Linus Torvalds's avatar
Linus Torvalds committed
361
362
	}

363
	/* allocate a sysfs_open_file for the file */
364
	error = -ENOMEM;
365
366
	of = kzalloc(sizeof(struct sysfs_open_file), GFP_KERNEL);
	if (!of)
367
		goto err_out;
Linus Torvalds's avatar
Linus Torvalds committed
368

369
	mutex_init(&of->mutex);
370
371
	of->sd = attr_sd;
	of->file = file;
372
373
374
375
376
377
378
379
380
381
382
383
384

	/*
	 * Always instantiate seq_file even if read access is not
	 * implemented or requested.  This unifies private data access and
	 * most files are readable anyway.
	 */
	error = single_open(file, sysfs_seq_show, of);
	if (error)
		goto err_free;

	/* seq_file clears PWRITE unconditionally, restore it if WRITE */
	if (file->f_mode & FMODE_WRITE)
		file->f_mode |= FMODE_PWRITE;
385

Tejun Heo's avatar
Tejun Heo committed
386
	/* make sure we have open dirent struct */
387
	error = sysfs_get_open_dirent(attr_sd, of);
Tejun Heo's avatar
Tejun Heo committed
388
	if (error)
389
		goto err_close;
Tejun Heo's avatar
Tejun Heo committed
390

391
	/* open succeeded, put active references */
392
	sysfs_put_active(attr_sd);
393
394
	return 0;

395
396
397
err_close:
	single_release(inode, file);
err_free:
398
	kfree(of);
399
err_out:
400
	sysfs_put_active(attr_sd);
Linus Torvalds's avatar
Linus Torvalds committed
401
402
403
	return error;
}

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

409
	sysfs_put_open_dirent(sd, of);
410
	single_release(inode, filp);
411
	kfree(of);
412

Linus Torvalds's avatar
Linus Torvalds committed
413
414
415
	return 0;
}

416
417
418
419
420
421
422
/* 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
423
 * need to close and re-open the file, or seek to 0 and read again.
424
425
 * Reminder: this only works for attributes which actively support
 * it, and it is not possible to test an attribute from userspace
426
 * to see if it supports poll (Neither 'poll' nor 'select' return
427
428
429
430
 * an appropriate error code).  When in doubt, set a suitable timeout value.
 */
static unsigned int sysfs_poll(struct file *filp, poll_table *wait)
{
431
	struct sysfs_open_file *of = sysfs_of(filp);
432
	struct sysfs_dirent *attr_sd = filp->f_path.dentry->d_fsdata;
433
	struct sysfs_open_dirent *od = attr_sd->s_attr.open;
434
435

	/* need parent for the kobj, grab both */
436
	if (!sysfs_get_active(attr_sd))
437
		goto trigger;
438

439
	poll_wait(filp, &od->poll, wait);
440

441
	sysfs_put_active(attr_sd);
442

443
	if (of->event != atomic_read(&od->event))
444
		goto trigger;
445

446
	return DEFAULT_POLLMASK;
447
448

 trigger:
449
	return DEFAULT_POLLMASK|POLLERR|POLLPRI;
450
451
}

452
453
454
void sysfs_notify_dirent(struct sysfs_dirent *sd)
{
	struct sysfs_open_dirent *od;
455
	unsigned long flags;
456

457
	spin_lock_irqsave(&sysfs_open_dirent_lock, flags);
458

459
460
461
462
463
464
	if (!WARN_ON(sysfs_type(sd) != SYSFS_KOBJ_ATTR)) {
		od = sd->s_attr.open;
		if (od) {
			atomic_inc(&od->event);
			wake_up_interruptible(&od->poll);
		}
465
466
	}

467
	spin_unlock_irqrestore(&sysfs_open_dirent_lock, flags);
468
469
470
}
EXPORT_SYMBOL_GPL(sysfs_notify_dirent);

471
void sysfs_notify(struct kobject *k, const char *dir, const char *attr)
472
{
473
	struct sysfs_dirent *sd = k->sd;
474

475
476
477
	mutex_lock(&sysfs_mutex);

	if (sd && dir)
Tejun Heo's avatar
Tejun Heo committed
478
		sd = sysfs_find_dirent(sd, dir, NULL);
479
	if (sd && attr)
Tejun Heo's avatar
Tejun Heo committed
480
		sd = sysfs_find_dirent(sd, attr, NULL);
481
482
	if (sd)
		sysfs_notify_dirent(sd);
483
484

	mutex_unlock(&sysfs_mutex);
485
486
487
}
EXPORT_SYMBOL_GPL(sysfs_notify);

488
const struct file_operations sysfs_file_operations = {
489
	.read		= seq_read,
Linus Torvalds's avatar
Linus Torvalds committed
490
	.write		= sysfs_write_file,
491
	.llseek		= seq_lseek,
Linus Torvalds's avatar
Linus Torvalds committed
492
493
	.open		= sysfs_open_file,
	.release	= sysfs_release,
494
	.poll		= sysfs_poll,
Linus Torvalds's avatar
Linus Torvalds committed
495
496
};

497
498
499
500
501
const struct file_operations sysfs_bin_operations = {
	.write		= sysfs_write_file,
	.llseek		= generic_file_llseek,
};

502
503
504
int sysfs_add_file_mode_ns(struct sysfs_dirent *dir_sd,
			   const struct attribute *attr, int type,
			   umode_t amode, const void *ns)
Linus Torvalds's avatar
Linus Torvalds committed
505
{
506
	umode_t mode = (amode & S_IALLUGO) | S_IFREG;
507
	struct sysfs_addrm_cxt acxt;
508
	struct sysfs_dirent *sd;
509
	int rc;
Linus Torvalds's avatar
Linus Torvalds committed
510

511
512
513
	sd = sysfs_new_dirent(attr->name, mode, type);
	if (!sd)
		return -ENOMEM;
514
515

	sd->s_ns = ns;
516
	sd->s_attr.attr = (void *)attr;
517
	sysfs_dirent_init_lockdep(sd);
Linus Torvalds's avatar
Linus Torvalds committed
518

519
520
	sysfs_addrm_start(&acxt);
	rc = sysfs_add_one(&acxt, sd, dir_sd);
521
	sysfs_addrm_finish(&acxt);
522

523
	if (rc)
524
		sysfs_put(sd);
525

526
	return rc;
Linus Torvalds's avatar
Linus Torvalds committed
527
528
529
}


530
531
532
int sysfs_add_file(struct sysfs_dirent *dir_sd, const struct attribute *attr,
		   int type)
{
533
	return sysfs_add_file_mode_ns(dir_sd, attr, type, attr->mode, NULL);
534
535
}

Linus Torvalds's avatar
Linus Torvalds committed
536
/**
537
538
539
540
 * sysfs_create_file_ns - create an attribute file for an object with custom ns
 * @kobj: object we're creating for
 * @attr: attribute descriptor
 * @ns: namespace the new file should belong to
Linus Torvalds's avatar
Linus Torvalds committed
541
 */
542
543
int sysfs_create_file_ns(struct kobject *kobj, const struct attribute *attr,
			 const void *ns)
Linus Torvalds's avatar
Linus Torvalds committed
544
{
545
	BUG_ON(!kobj || !kobj->sd || !attr);
Linus Torvalds's avatar
Linus Torvalds committed
546

547
548
	return sysfs_add_file_mode_ns(kobj->sd, attr, SYSFS_KOBJ_ATTR,
				      attr->mode, ns);
Linus Torvalds's avatar
Linus Torvalds committed
549
550

}
551
EXPORT_SYMBOL_GPL(sysfs_create_file_ns);
Linus Torvalds's avatar
Linus Torvalds committed
552

553
554
555
556
557
558
559
560
561
562
563
564
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;
}
565
EXPORT_SYMBOL_GPL(sysfs_create_files);
Linus Torvalds's avatar
Linus Torvalds committed
566

567
568
569
570
571
572
573
574
575
/**
 * 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)
{
576
	struct sysfs_dirent *dir_sd;
577
578
	int error;

579
	if (group)
Tejun Heo's avatar
Tejun Heo committed
580
		dir_sd = sysfs_get_dirent(kobj->sd, group);
581
582
583
	else
		dir_sd = sysfs_get(kobj->sd);

584
585
586
587
588
589
	if (!dir_sd)
		return -ENOENT;

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

590
591
592
593
	return error;
}
EXPORT_SYMBOL_GPL(sysfs_add_file_to_group);

594
595
596
597
598
599
600
/**
 * sysfs_chmod_file - update the modified mode value on an object attribute.
 * @kobj: object we're acting for.
 * @attr: attribute descriptor.
 * @mode: file permissions.
 *
 */
601
int sysfs_chmod_file(struct kobject *kobj, const struct attribute *attr,
Al Viro's avatar
Al Viro committed
602
		     umode_t mode)
603
{
604
	struct sysfs_dirent *sd;
605
	struct iattr newattrs;
606
607
	int rc;

608
	mutex_lock(&sysfs_mutex);
609

610
	rc = -ENOENT;
Tejun Heo's avatar
Tejun Heo committed
611
	sd = sysfs_find_dirent(kobj->sd, attr->name, NULL);
612
	if (!sd)
613
		goto out;
614

615
	newattrs.ia_mode = (mode & S_IALLUGO) | (sd->s_mode & ~S_IALLUGO);
616
	newattrs.ia_valid = ATTR_MODE;
617
	rc = sysfs_sd_setattr(sd, &newattrs);
618

619
 out:
620
	mutex_unlock(&sysfs_mutex);
621
	return rc;
622
623
624
}
EXPORT_SYMBOL_GPL(sysfs_chmod_file);

Linus Torvalds's avatar
Linus Torvalds committed
625
/**
626
627
628
629
 * sysfs_remove_file_ns - remove an object attribute with a custom ns tag
 * @kobj: object we're acting for
 * @attr: attribute descriptor
 * @ns: namespace tag of the file to remove
Linus Torvalds's avatar
Linus Torvalds committed
630
 *
631
 * Hash the attribute name and namespace tag and kill the victim.
Linus Torvalds's avatar
Linus Torvalds committed
632
 */
633
634
void sysfs_remove_file_ns(struct kobject *kobj, const struct attribute *attr,
			  const void *ns)
Linus Torvalds's avatar
Linus Torvalds committed
635
{
636
	struct sysfs_dirent *dir_sd = kobj->sd;
637

Tejun Heo's avatar
Tejun Heo committed
638
	sysfs_hash_and_remove(dir_sd, attr->name, ns);
Linus Torvalds's avatar
Linus Torvalds committed
639
}
640
EXPORT_SYMBOL_GPL(sysfs_remove_file_ns);
Linus Torvalds's avatar
Linus Torvalds committed
641

642
void sysfs_remove_files(struct kobject *kobj, const struct attribute **ptr)
643
644
645
646
647
{
	int i;
	for (i = 0; ptr[i]; i++)
		sysfs_remove_file(kobj, ptr[i]);
}
648
EXPORT_SYMBOL_GPL(sysfs_remove_files);
Linus Torvalds's avatar
Linus Torvalds committed
649

650
651
652
653
654
655
656
657
658
/**
 * 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)
{
659
	struct sysfs_dirent *dir_sd;
660

661
	if (group)
Tejun Heo's avatar
Tejun Heo committed
662
		dir_sd = sysfs_get_dirent(kobj->sd, group);
663
664
	else
		dir_sd = sysfs_get(kobj->sd);
665
	if (dir_sd) {
Tejun Heo's avatar
Tejun Heo committed
666
		sysfs_hash_and_remove(dir_sd, attr->name, NULL);
667
		sysfs_put(dir_sd);
668
669
670
671
	}
}
EXPORT_SYMBOL_GPL(sysfs_remove_file_from_group);

672
struct sysfs_schedule_callback_struct {
673
674
	struct list_head	workq_list;
	struct kobject		*kobj;
675
676
	void			(*func)(void *);
	void			*data;
677
	struct module		*owner;
678
679
680
	struct work_struct	work;
};

681
static struct workqueue_struct *sysfs_workqueue;
682
683
static DEFINE_MUTEX(sysfs_workq_mutex);
static LIST_HEAD(sysfs_workq);
684
685
686
687
688
689
690
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);
691
	module_put(ss->owner);
692
693
694
	mutex_lock(&sysfs_workq_mutex);
	list_del(&ss->workq_list);
	mutex_unlock(&sysfs_workq_mutex);
695
696
697
698
699
700
701
702
	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.
703
 * @owner: module owning the callback code
704
705
706
707
708
709
710
711
712
713
714
715
 *
 * 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
716
717
 * be allocated, -ENODEV if a reference to @owner isn't available,
 * -EAGAIN if a callback has already been scheduled for @kobj.
718
719
 */
int sysfs_schedule_callback(struct kobject *kobj, void (*func)(void *),
720
		void *data, struct module *owner)
721
{
722
	struct sysfs_schedule_callback_struct *ss, *tmp;
723

724
725
	if (!try_module_get(owner))
		return -ENODEV;
726
727
728
729

	mutex_lock(&sysfs_workq_mutex);
	list_for_each_entry_safe(ss, tmp, &sysfs_workq, workq_list)
		if (ss->kobj == kobj) {
730
			module_put(owner);
731
732
733
734
735
			mutex_unlock(&sysfs_workq_mutex);
			return -EAGAIN;
		}
	mutex_unlock(&sysfs_workq_mutex);

736
	if (sysfs_workqueue == NULL) {
737
		sysfs_workqueue = create_singlethread_workqueue("sysfsd");
738
739
740
741
742
743
		if (sysfs_workqueue == NULL) {
			module_put(owner);
			return -ENOMEM;
		}
	}

744
	ss = kmalloc(sizeof(*ss), GFP_KERNEL);
745
746
	if (!ss) {
		module_put(owner);
747
		return -ENOMEM;
748
	}
749
750
751
752
	kobject_get(kobj);
	ss->kobj = kobj;
	ss->func = func;
	ss->data = data;
753
	ss->owner = owner;
754
	INIT_WORK(&ss->work, sysfs_schedule_callback_work);
755
756
757
758
	INIT_LIST_HEAD(&ss->workq_list);
	mutex_lock(&sysfs_workq_mutex);
	list_add_tail(&ss->workq_list, &sysfs_workq);
	mutex_unlock(&sysfs_workq_mutex);
759
	queue_work(sysfs_workqueue, &ss->work);
760
761
762
	return 0;
}
EXPORT_SYMBOL_GPL(sysfs_schedule_callback);