Branch data Line data Source code
1 : : /*
2 : : * fs/sysfs/file.c - sysfs regular (text) file implementation
3 : : *
4 : : * Copyright (c) 2001-3 Patrick Mochel
5 : : * Copyright (c) 2007 SUSE Linux Products GmbH
6 : : * Copyright (c) 2007 Tejun Heo <teheo@suse.de>
7 : : *
8 : : * This file is released under the GPLv2.
9 : : *
10 : : * Please see Documentation/filesystems/sysfs.txt for more information.
11 : : */
12 : :
13 : : #include <linux/module.h>
14 : : #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>
22 : : #include <linux/limits.h>
23 : : #include <linux/uaccess.h>
24 : : #include <linux/seq_file.h>
25 : : #include <linux/mm.h>
26 : :
27 : : #include "sysfs.h"
28 : :
29 : : /*
30 : : * There's one sysfs_open_file for each open file and one sysfs_open_dirent
31 : : * for each sysfs_dirent with one or more open files.
32 : : *
33 : : * sysfs_dirent->s_attr.open points to sysfs_open_dirent. s_attr.open is
34 : : * protected by sysfs_open_dirent_lock.
35 : : *
36 : : * filp->private_data points to seq_file whose ->private points to
37 : : * sysfs_open_file. sysfs_open_files are chained at
38 : : * sysfs_open_dirent->files, which is protected by sysfs_open_file_mutex.
39 : : */
40 : : static DEFINE_SPINLOCK(sysfs_open_dirent_lock);
41 : : static DEFINE_MUTEX(sysfs_open_file_mutex);
42 : :
43 : : struct sysfs_open_dirent {
44 : : atomic_t refcnt;
45 : : atomic_t event;
46 : : wait_queue_head_t poll;
47 : : struct list_head files; /* goes through sysfs_open_file.list */
48 : : };
49 : :
50 : : struct sysfs_open_file {
51 : : struct sysfs_dirent *sd;
52 : : struct file *file;
53 : : struct mutex mutex;
54 : : int event;
55 : : struct list_head list;
56 : :
57 : : bool mmapped;
58 : : const struct vm_operations_struct *vm_ops;
59 : : };
60 : :
61 : 1821 : static bool sysfs_is_bin(struct sysfs_dirent *sd)
62 : : {
63 : : return sysfs_type(sd) == SYSFS_KOBJ_BIN_ATTR;
64 : : }
65 : :
66 : : static struct sysfs_open_file *sysfs_of(struct file *file)
67 : : {
68 : 607 : return ((struct seq_file *)file->private_data)->private;
69 : : }
70 : :
71 : : /*
72 : : * Determine ktype->sysfs_ops for the given sysfs_dirent. This function
73 : : * must be called while holding an active reference.
74 : : */
75 : : static const struct sysfs_ops *sysfs_file_ops(struct sysfs_dirent *sd)
76 : : {
77 : 1214 : struct kobject *kobj = sd->s_parent->s_dir.kobj;
78 : :
79 : : if (!sysfs_ignore_lockdep(sd))
80 : : lockdep_assert_held(sd);
81 [ + - ][ # # ]: 1214 : return kobj->ktype ? kobj->ktype->sysfs_ops : NULL;
[ + - ]
82 : : }
83 : :
84 : : /*
85 : : * Reads on sysfs are handled through seq_file, which takes care of hairy
86 : : * details like buffering and seeking. The following function pipes
87 : : * sysfs_ops->show() result through seq_file.
88 : : */
89 : 0 : static int sysfs_seq_show(struct seq_file *sf, void *v)
90 : : {
91 : 607 : struct sysfs_open_file *of = sf->private;
92 : 1214 : struct kobject *kobj = of->sd->s_parent->s_dir.kobj;
93 : : const struct sysfs_ops *ops;
94 : : char *buf;
95 : : ssize_t count;
96 : :
97 : : /* acquire buffer and ensure that it's >= PAGE_SIZE */
98 : : count = seq_get_buf(sf, &buf);
99 [ - + ]: 607 : if (count < PAGE_SIZE) {
100 : : seq_commit(sf, -1);
101 : 0 : return 0;
102 : : }
103 : :
104 : : /*
105 : : * Need @of->sd for attr and ops, its parent for kobj. @of->mutex
106 : : * nests outside active ref and is just to ensure that the ops
107 : : * aren't called concurrently for the same open file.
108 : : */
109 : 607 : mutex_lock(&of->mutex);
110 [ - + ]: 607 : if (!sysfs_get_active(of->sd)) {
111 : 0 : mutex_unlock(&of->mutex);
112 : 0 : return -ENODEV;
113 : : }
114 : :
115 : 607 : of->event = atomic_read(&of->sd->s_attr.open->event);
116 : :
117 : : /*
118 : : * Lookup @ops and invoke show(). Control may reach here via seq
119 : : * file lseek even if @ops->show() isn't implemented.
120 : : */
121 : : ops = sysfs_file_ops(of->sd);
122 [ + - ]: 607 : if (ops->show)
123 : 607 : count = ops->show(kobj, of->sd->s_attr.attr, buf);
124 : : else
125 : : count = 0;
126 : :
127 : 607 : sysfs_put_active(of->sd);
128 : 607 : mutex_unlock(&of->mutex);
129 : :
130 [ + - ]: 607 : if (count < 0)
131 : : return count;
132 : :
133 : : /*
134 : : * The code works fine with PAGE_SIZE return but it's likely to
135 : : * indicate truncated result or overflow in normal use cases.
136 : : */
137 [ - + ]: 607 : if (count >= (ssize_t)PAGE_SIZE) {
138 : : print_symbol("fill_read_buffer: %s returned bad count\n",
139 : 0 : (unsigned long)ops->show);
140 : : /* Try to struggle along */
141 : : count = PAGE_SIZE - 1;
142 : : }
143 : : seq_commit(sf, count);
144 : : return 0;
145 : : }
146 : :
147 : : /*
148 : : * Read method for bin files. As reading a bin file can have side-effects,
149 : : * the exact offset and bytes specified in read(2) call should be passed to
150 : : * the read callback making it difficult to use seq_file. Implement
151 : : * simplistic custom buffering for bin files.
152 : : */
153 : 0 : static ssize_t sysfs_bin_read(struct file *file, char __user *userbuf,
154 : : size_t bytes, loff_t *off)
155 : : {
156 : : struct sysfs_open_file *of = sysfs_of(file);
157 : 0 : struct bin_attribute *battr = of->sd->s_attr.bin_attr;
158 : 0 : struct kobject *kobj = of->sd->s_parent->s_dir.kobj;
159 : 0 : loff_t size = file_inode(file)->i_size;
160 : 0 : int count = min_t(size_t, bytes, PAGE_SIZE);
161 : 0 : loff_t offs = *off;
162 : : char *buf;
163 : :
164 [ # # ]: 0 : if (!bytes)
165 : : return 0;
166 : :
167 [ # # ]: 0 : if (size) {
168 [ # # ]: 0 : if (offs > size)
169 : : return 0;
170 [ # # ]: 0 : if (offs + count > size)
171 : 0 : count = size - offs;
172 : : }
173 : :
174 : 0 : buf = kmalloc(count, GFP_KERNEL);
175 [ # # ]: 0 : if (!buf)
176 : : return -ENOMEM;
177 : :
178 : : /* need of->sd for battr, its parent for kobj */
179 : 0 : mutex_lock(&of->mutex);
180 [ # # ]: 0 : if (!sysfs_get_active(of->sd)) {
181 : : count = -ENODEV;
182 : 0 : mutex_unlock(&of->mutex);
183 : 0 : goto out_free;
184 : : }
185 : :
186 [ # # ]: 0 : if (battr->read)
187 : 0 : count = battr->read(file, kobj, battr, buf, offs, count);
188 : : else
189 : : count = -EIO;
190 : :
191 : 0 : sysfs_put_active(of->sd);
192 : 0 : mutex_unlock(&of->mutex);
193 : :
194 [ # # ]: 0 : if (count < 0)
195 : : goto out_free;
196 : :
197 [ # # ]: 0 : if (copy_to_user(userbuf, buf, count)) {
198 : : count = -EFAULT;
199 : : goto out_free;
200 : : }
201 : :
202 : : pr_debug("offs = %lld, *off = %lld, count = %d\n", offs, *off, count);
203 : :
204 : 0 : *off = offs + count;
205 : :
206 : : out_free:
207 : 0 : kfree(buf);
208 : 0 : return count;
209 : : }
210 : :
211 : : /**
212 : : * flush_write_buffer - push buffer to kobject
213 : : * @of: open file
214 : : * @buf: data buffer for file
215 : : * @off: file offset to write to
216 : : * @count: number of bytes
217 : : *
218 : : * Get the correct pointers for the kobject and the attribute we're dealing
219 : : * with, then call the store() method for it with @buf.
220 : : */
221 : 0 : static int flush_write_buffer(struct sysfs_open_file *of, char *buf, loff_t off,
222 : : size_t count)
223 : : {
224 : 0 : struct kobject *kobj = of->sd->s_parent->s_dir.kobj;
225 : : int rc = 0;
226 : :
227 : : /*
228 : : * Need @of->sd for attr and ops, its parent for kobj. @of->mutex
229 : : * nests outside active ref and is just to ensure that the ops
230 : : * aren't called concurrently for the same open file.
231 : : */
232 : 0 : mutex_lock(&of->mutex);
233 [ # # ]: 0 : if (!sysfs_get_active(of->sd)) {
234 : 0 : mutex_unlock(&of->mutex);
235 : 0 : return -ENODEV;
236 : : }
237 : :
238 [ # # ]: 0 : if (sysfs_is_bin(of->sd)) {
239 : 0 : struct bin_attribute *battr = of->sd->s_attr.bin_attr;
240 : :
241 : : rc = -EIO;
242 [ # # ]: 0 : if (battr->write)
243 : 0 : rc = battr->write(of->file, kobj, battr, buf, off,
244 : : count);
245 : : } else {
246 : : const struct sysfs_ops *ops = sysfs_file_ops(of->sd);
247 : :
248 : 0 : rc = ops->store(kobj, of->sd->s_attr.attr, buf, count);
249 : : }
250 : :
251 : 0 : sysfs_put_active(of->sd);
252 : 0 : mutex_unlock(&of->mutex);
253 : :
254 : 0 : return rc;
255 : : }
256 : :
257 : : /**
258 : : * sysfs_write_file - write an attribute
259 : : * @file: file pointer
260 : : * @user_buf: data to write
261 : : * @count: number of bytes
262 : : * @ppos: starting offset
263 : : *
264 : : * Copy data in from userland and pass it to the matching
265 : : * sysfs_ops->store() by invoking flush_write_buffer().
266 : : *
267 : : * There is no easy way for us to know if userspace is only doing a partial
268 : : * write, so we don't support them. We expect the entire buffer to come on
269 : : * the first write. Hint: if you're writing a value, first read the file,
270 : : * modify only the the value you're changing, then write entire buffer
271 : : * back.
272 : : */
273 : 0 : static ssize_t sysfs_write_file(struct file *file, const char __user *user_buf,
274 : : size_t count, loff_t *ppos)
275 : : {
276 : : struct sysfs_open_file *of = sysfs_of(file);
277 : 0 : ssize_t len = min_t(size_t, count, PAGE_SIZE);
278 : 0 : loff_t size = file_inode(file)->i_size;
279 : : char *buf;
280 : :
281 [ # # ][ # # ]: 0 : if (sysfs_is_bin(of->sd) && size) {
282 [ # # ]: 0 : if (size <= *ppos)
283 : : return 0;
284 : 0 : len = min_t(ssize_t, len, size - *ppos);
285 : : }
286 : :
287 [ # # ]: 0 : if (!len)
288 : : return 0;
289 : :
290 : 0 : buf = kmalloc(len + 1, GFP_KERNEL);
291 [ # # ]: 0 : if (!buf)
292 : : return -ENOMEM;
293 : :
294 [ # # ]: 0 : if (copy_from_user(buf, user_buf, len)) {
295 : : len = -EFAULT;
296 : : goto out_free;
297 : : }
298 : 0 : buf[len] = '\0'; /* guarantee string termination */
299 : :
300 : 0 : len = flush_write_buffer(of, buf, *ppos, len);
301 [ # # ]: 0 : if (len > 0)
302 : 0 : *ppos += len;
303 : : out_free:
304 : 0 : kfree(buf);
305 : 0 : return len;
306 : : }
307 : :
308 : 0 : static void sysfs_bin_vma_open(struct vm_area_struct *vma)
309 : : {
310 : 0 : struct file *file = vma->vm_file;
311 : : struct sysfs_open_file *of = sysfs_of(file);
312 : :
313 [ # # ]: 0 : if (!of->vm_ops)
314 : : return;
315 : :
316 [ # # ]: 0 : if (!sysfs_get_active(of->sd))
317 : : return;
318 : :
319 [ # # ]: 0 : if (of->vm_ops->open)
320 : 0 : of->vm_ops->open(vma);
321 : :
322 : 0 : sysfs_put_active(of->sd);
323 : : }
324 : :
325 : 0 : static int sysfs_bin_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
326 : : {
327 : 0 : struct file *file = vma->vm_file;
328 : : struct sysfs_open_file *of = sysfs_of(file);
329 : : int ret;
330 : :
331 [ # # ]: 0 : if (!of->vm_ops)
332 : : return VM_FAULT_SIGBUS;
333 : :
334 [ # # ]: 0 : if (!sysfs_get_active(of->sd))
335 : : return VM_FAULT_SIGBUS;
336 : :
337 : : ret = VM_FAULT_SIGBUS;
338 [ # # ]: 0 : if (of->vm_ops->fault)
339 : 0 : ret = of->vm_ops->fault(vma, vmf);
340 : :
341 : 0 : sysfs_put_active(of->sd);
342 : 0 : return ret;
343 : : }
344 : :
345 : 0 : static int sysfs_bin_page_mkwrite(struct vm_area_struct *vma,
346 : : struct vm_fault *vmf)
347 : : {
348 : 0 : struct file *file = vma->vm_file;
349 : : struct sysfs_open_file *of = sysfs_of(file);
350 : : int ret;
351 : :
352 [ # # ]: 0 : if (!of->vm_ops)
353 : : return VM_FAULT_SIGBUS;
354 : :
355 [ # # ]: 0 : if (!sysfs_get_active(of->sd))
356 : : return VM_FAULT_SIGBUS;
357 : :
358 : : ret = 0;
359 [ # # ]: 0 : if (of->vm_ops->page_mkwrite)
360 : 0 : ret = of->vm_ops->page_mkwrite(vma, vmf);
361 : : else
362 : 0 : file_update_time(file);
363 : :
364 : 0 : sysfs_put_active(of->sd);
365 : 0 : return ret;
366 : : }
367 : :
368 : 0 : static int sysfs_bin_access(struct vm_area_struct *vma, unsigned long addr,
369 : : void *buf, int len, int write)
370 : : {
371 : 0 : struct file *file = vma->vm_file;
372 : : struct sysfs_open_file *of = sysfs_of(file);
373 : : int ret;
374 : :
375 [ # # ]: 0 : if (!of->vm_ops)
376 : : return -EINVAL;
377 : :
378 [ # # ]: 0 : if (!sysfs_get_active(of->sd))
379 : : return -EINVAL;
380 : :
381 : : ret = -EINVAL;
382 [ # # ]: 0 : if (of->vm_ops->access)
383 : 0 : ret = of->vm_ops->access(vma, addr, buf, len, write);
384 : :
385 : 0 : sysfs_put_active(of->sd);
386 : 0 : return ret;
387 : : }
388 : :
389 : : #ifdef CONFIG_NUMA
390 : : static int sysfs_bin_set_policy(struct vm_area_struct *vma,
391 : : struct mempolicy *new)
392 : : {
393 : : struct file *file = vma->vm_file;
394 : : struct sysfs_open_file *of = sysfs_of(file);
395 : : int ret;
396 : :
397 : : if (!of->vm_ops)
398 : : return 0;
399 : :
400 : : if (!sysfs_get_active(of->sd))
401 : : return -EINVAL;
402 : :
403 : : ret = 0;
404 : : if (of->vm_ops->set_policy)
405 : : ret = of->vm_ops->set_policy(vma, new);
406 : :
407 : : sysfs_put_active(of->sd);
408 : : return ret;
409 : : }
410 : :
411 : : static struct mempolicy *sysfs_bin_get_policy(struct vm_area_struct *vma,
412 : : unsigned long addr)
413 : : {
414 : : struct file *file = vma->vm_file;
415 : : struct sysfs_open_file *of = sysfs_of(file);
416 : : struct mempolicy *pol;
417 : :
418 : : if (!of->vm_ops)
419 : : return vma->vm_policy;
420 : :
421 : : if (!sysfs_get_active(of->sd))
422 : : return vma->vm_policy;
423 : :
424 : : pol = vma->vm_policy;
425 : : if (of->vm_ops->get_policy)
426 : : pol = of->vm_ops->get_policy(vma, addr);
427 : :
428 : : sysfs_put_active(of->sd);
429 : : return pol;
430 : : }
431 : :
432 : : static int sysfs_bin_migrate(struct vm_area_struct *vma, const nodemask_t *from,
433 : : const nodemask_t *to, unsigned long flags)
434 : : {
435 : : struct file *file = vma->vm_file;
436 : : struct sysfs_open_file *of = sysfs_of(file);
437 : : int ret;
438 : :
439 : : if (!of->vm_ops)
440 : : return 0;
441 : :
442 : : if (!sysfs_get_active(of->sd))
443 : : return 0;
444 : :
445 : : ret = 0;
446 : : if (of->vm_ops->migrate)
447 : : ret = of->vm_ops->migrate(vma, from, to, flags);
448 : :
449 : : sysfs_put_active(of->sd);
450 : : return ret;
451 : : }
452 : : #endif
453 : :
454 : : static const struct vm_operations_struct sysfs_bin_vm_ops = {
455 : : .open = sysfs_bin_vma_open,
456 : : .fault = sysfs_bin_fault,
457 : : .page_mkwrite = sysfs_bin_page_mkwrite,
458 : : .access = sysfs_bin_access,
459 : : #ifdef CONFIG_NUMA
460 : : .set_policy = sysfs_bin_set_policy,
461 : : .get_policy = sysfs_bin_get_policy,
462 : : .migrate = sysfs_bin_migrate,
463 : : #endif
464 : : };
465 : :
466 : 0 : static int sysfs_bin_mmap(struct file *file, struct vm_area_struct *vma)
467 : : {
468 : : struct sysfs_open_file *of = sysfs_of(file);
469 : 0 : struct bin_attribute *battr = of->sd->s_attr.bin_attr;
470 : 0 : struct kobject *kobj = of->sd->s_parent->s_dir.kobj;
471 : : int rc;
472 : :
473 : 0 : mutex_lock(&of->mutex);
474 : :
475 : : /* need of->sd for battr, its parent for kobj */
476 : : rc = -ENODEV;
477 [ # # ]: 0 : if (!sysfs_get_active(of->sd))
478 : : goto out_unlock;
479 : :
480 [ # # ]: 0 : if (!battr->mmap)
481 : : goto out_put;
482 : :
483 : 0 : rc = battr->mmap(file, kobj, battr, vma);
484 [ # # ]: 0 : if (rc)
485 : : goto out_put;
486 : :
487 : : /*
488 : : * PowerPC's pci_mmap of legacy_mem uses shmem_zero_setup()
489 : : * to satisfy versions of X which crash if the mmap fails: that
490 : : * substitutes a new vm_file, and we don't then want bin_vm_ops.
491 : : */
492 [ # # ]: 0 : if (vma->vm_file != file)
493 : : goto out_put;
494 : :
495 : : rc = -EINVAL;
496 [ # # ][ # # ]: 0 : if (of->mmapped && of->vm_ops != vma->vm_ops)
497 : : goto out_put;
498 : :
499 : : /*
500 : : * It is not possible to successfully wrap close.
501 : : * So error if someone is trying to use close.
502 : : */
503 : : rc = -EINVAL;
504 [ # # ][ # # ]: 0 : if (vma->vm_ops && vma->vm_ops->close)
505 : : goto out_put;
506 : :
507 : : rc = 0;
508 : 0 : of->mmapped = 1;
509 : 0 : of->vm_ops = vma->vm_ops;
510 : 0 : vma->vm_ops = &sysfs_bin_vm_ops;
511 : : out_put:
512 : 0 : sysfs_put_active(of->sd);
513 : : out_unlock:
514 : 0 : mutex_unlock(&of->mutex);
515 : :
516 : 0 : return rc;
517 : : }
518 : :
519 : : /**
520 : : * sysfs_get_open_dirent - get or create sysfs_open_dirent
521 : : * @sd: target sysfs_dirent
522 : : * @of: sysfs_open_file for this instance of open
523 : : *
524 : : * If @sd->s_attr.open exists, increment its reference count;
525 : : * otherwise, create one. @of is chained to the files list.
526 : : *
527 : : * LOCKING:
528 : : * Kernel thread context (may sleep).
529 : : *
530 : : * RETURNS:
531 : : * 0 on success, -errno on failure.
532 : : */
533 : 607 : static int sysfs_get_open_dirent(struct sysfs_dirent *sd,
534 : : struct sysfs_open_file *of)
535 : : {
536 : : struct sysfs_open_dirent *od, *new_od = NULL;
537 : :
538 : : retry:
539 : 1151 : mutex_lock(&sysfs_open_file_mutex);
540 : : spin_lock_irq(&sysfs_open_dirent_lock);
541 : :
542 [ + + ][ + + ]: 1151 : if (!sd->s_attr.open && new_od) {
543 : 544 : sd->s_attr.open = new_od;
544 : : new_od = NULL;
545 : : }
546 : :
547 : 1151 : od = sd->s_attr.open;
548 [ + + ]: 1151 : if (od) {
549 : 607 : atomic_inc(&od->refcnt);
550 : 607 : list_add_tail(&of->list, &od->files);
551 : : }
552 : :
553 : : spin_unlock_irq(&sysfs_open_dirent_lock);
554 : 1151 : mutex_unlock(&sysfs_open_file_mutex);
555 : :
556 [ + + ]: 1151 : if (od) {
557 : 607 : kfree(new_od);
558 : : return 0;
559 : : }
560 : :
561 : : /* not there, initialize a new one and retry */
562 : : new_od = kmalloc(sizeof(*new_od), GFP_KERNEL);
563 [ + - ]: 544 : if (!new_od)
564 : : return -ENOMEM;
565 : :
566 : 544 : atomic_set(&new_od->refcnt, 0);
567 : 544 : atomic_set(&new_od->event, 1);
568 : 544 : init_waitqueue_head(&new_od->poll);
569 : 544 : INIT_LIST_HEAD(&new_od->files);
570 : : goto retry;
571 : : }
572 : :
573 : : /**
574 : : * sysfs_put_open_dirent - put sysfs_open_dirent
575 : : * @sd: target sysfs_dirent
576 : : * @of: associated sysfs_open_file
577 : : *
578 : : * Put @sd->s_attr.open and unlink @of from the files list. If
579 : : * reference count reaches zero, disassociate and free it.
580 : : *
581 : : * LOCKING:
582 : : * None.
583 : : */
584 : 607 : static void sysfs_put_open_dirent(struct sysfs_dirent *sd,
585 : : struct sysfs_open_file *of)
586 : : {
587 : 607 : struct sysfs_open_dirent *od = sd->s_attr.open;
588 : : unsigned long flags;
589 : :
590 : 607 : mutex_lock(&sysfs_open_file_mutex);
591 : 607 : spin_lock_irqsave(&sysfs_open_dirent_lock, flags);
592 : :
593 [ + - ]: 607 : if (of)
594 : : list_del(&of->list);
595 : :
596 [ + + ]: 607 : if (atomic_dec_and_test(&od->refcnt))
597 : 544 : sd->s_attr.open = NULL;
598 : : else
599 : : od = NULL;
600 : :
601 : : spin_unlock_irqrestore(&sysfs_open_dirent_lock, flags);
602 : 607 : mutex_unlock(&sysfs_open_file_mutex);
603 : :
604 : 607 : kfree(od);
605 : 607 : }
606 : :
607 : 0 : static int sysfs_open_file(struct inode *inode, struct file *file)
608 : : {
609 : 1214 : struct sysfs_dirent *attr_sd = file->f_path.dentry->d_fsdata;
610 : 607 : struct kobject *kobj = attr_sd->s_parent->s_dir.kobj;
611 : : struct sysfs_open_file *of;
612 : : bool has_read, has_write;
613 : : int error = -EACCES;
614 : :
615 : : /* need attr_sd for attr and ops, its parent for kobj */
616 [ + ]: 607 : if (!sysfs_get_active(attr_sd))
617 : : return -ENODEV;
618 : :
619 [ - + ]: 1214 : if (sysfs_is_bin(attr_sd)) {
620 : 0 : struct bin_attribute *battr = attr_sd->s_attr.bin_attr;
621 : :
622 [ # # ][ # # ]: 0 : has_read = battr->read || battr->mmap;
623 [ # # ][ # # ]: 0 : has_write = battr->write || battr->mmap;
624 : : } else {
625 : : const struct sysfs_ops *ops = sysfs_file_ops(attr_sd);
626 : :
627 : : /* every kobject with an attribute needs a ktype assigned */
628 [ - + ][ + - ]: 607 : if (WARN(!ops, KERN_ERR
629 : : "missing sysfs attribute operations for kobject: %s\n",
630 : : kobject_name(kobj)))
631 : : goto err_out;
632 : :
633 : 607 : has_read = ops->show;
634 : 607 : has_write = ops->store;
635 : : }
636 : :
637 : : /* check perms and supported operations */
638 [ - + ][ # # ]: 607 : if ((file->f_mode & FMODE_WRITE) &&
639 [ # # ]: 0 : (!(inode->i_mode & S_IWUGO) || !has_write))
640 : : goto err_out;
641 : :
642 [ + - ][ + - ]: 607 : if ((file->f_mode & FMODE_READ) &&
643 [ + - ]: 607 : (!(inode->i_mode & S_IRUGO) || !has_read))
644 : : goto err_out;
645 : :
646 : : /* allocate a sysfs_open_file for the file */
647 : : error = -ENOMEM;
648 : : of = kzalloc(sizeof(struct sysfs_open_file), GFP_KERNEL);
649 [ + - ]: 607 : if (!of)
650 : : goto err_out;
651 : :
652 : : /*
653 : : * The following is done to give a different lockdep key to
654 : : * @of->mutex for files which implement mmap. This is a rather
655 : : * crude way to avoid false positive lockdep warning around
656 : : * mm->mmap_sem - mmap nests @of->mutex under mm->mmap_sem and
657 : : * reading /sys/block/sda/trace/act_mask grabs sr_mutex, under
658 : : * which mm->mmap_sem nests, while holding @of->mutex. As each
659 : : * open file has a separate mutex, it's okay as long as those don't
660 : : * happen on the same file. At this point, we can't easily give
661 : : * each file a separate locking class. Let's differentiate on
662 : : * whether the file is bin or not for now.
663 : : */
664 [ - + ]: 607 : if (sysfs_is_bin(attr_sd))
665 : 0 : mutex_init(&of->mutex);
666 : : else
667 : 607 : mutex_init(&of->mutex);
668 : :
669 : 607 : of->sd = attr_sd;
670 : 607 : of->file = file;
671 : :
672 : : /*
673 : : * Always instantiate seq_file even if read access doesn't use
674 : : * seq_file or is not requested. This unifies private data access
675 : : * and readable regular files are the vast majority anyway.
676 : : */
677 [ - + ]: 607 : if (sysfs_is_bin(attr_sd))
678 : 0 : error = single_open(file, NULL, of);
679 : : else
680 : 607 : error = single_open(file, sysfs_seq_show, of);
681 [ + - ]: 607 : if (error)
682 : : goto err_free;
683 : :
684 : : /* seq_file clears PWRITE unconditionally, restore it if WRITE */
685 [ - + ]: 607 : if (file->f_mode & FMODE_WRITE)
686 : 0 : file->f_mode |= FMODE_PWRITE;
687 : :
688 : : /* make sure we have open dirent struct */
689 : 607 : error = sysfs_get_open_dirent(attr_sd, of);
690 [ + - ]: 607 : if (error)
691 : : goto err_close;
692 : :
693 : : /* open succeeded, put active references */
694 : 607 : sysfs_put_active(attr_sd);
695 : 607 : return 0;
696 : :
697 : : err_close:
698 : 0 : single_release(inode, file);
699 : : err_free:
700 : 0 : kfree(of);
701 : : err_out:
702 : 0 : sysfs_put_active(attr_sd);
703 : 0 : return error;
704 : : }
705 : :
706 : 0 : static int sysfs_release(struct inode *inode, struct file *filp)
707 : : {
708 : 607 : struct sysfs_dirent *sd = filp->f_path.dentry->d_fsdata;
709 : : struct sysfs_open_file *of = sysfs_of(filp);
710 : :
711 : 607 : sysfs_put_open_dirent(sd, of);
712 : 607 : single_release(inode, filp);
713 : 607 : kfree(of);
714 : :
715 : 607 : return 0;
716 : : }
717 : :
718 : 0 : void sysfs_unmap_bin_file(struct sysfs_dirent *sd)
719 : : {
720 : : struct sysfs_open_dirent *od;
721 : : struct sysfs_open_file *of;
722 : :
723 [ # # ]: 0 : if (!sysfs_is_bin(sd))
724 : : return;
725 : :
726 : : spin_lock_irq(&sysfs_open_dirent_lock);
727 : 0 : od = sd->s_attr.open;
728 [ # # ]: 0 : if (od)
729 : 0 : atomic_inc(&od->refcnt);
730 : : spin_unlock_irq(&sysfs_open_dirent_lock);
731 [ # # ]: 0 : if (!od)
732 : : return;
733 : :
734 : 0 : mutex_lock(&sysfs_open_file_mutex);
735 [ # # ]: 0 : list_for_each_entry(of, &od->files, list) {
736 : 0 : struct inode *inode = file_inode(of->file);
737 : 0 : unmap_mapping_range(inode->i_mapping, 0, 0, 1);
738 : : }
739 : 0 : mutex_unlock(&sysfs_open_file_mutex);
740 : :
741 : 0 : sysfs_put_open_dirent(sd, NULL);
742 : : }
743 : :
744 : : /* Sysfs attribute files are pollable. The idea is that you read
745 : : * the content and then you use 'poll' or 'select' to wait for
746 : : * the content to change. When the content changes (assuming the
747 : : * manager for the kobject supports notification), poll will
748 : : * return POLLERR|POLLPRI, and select will return the fd whether
749 : : * it is waiting for read, write, or exceptions.
750 : : * Once poll/select indicates that the value has changed, you
751 : : * need to close and re-open the file, or seek to 0 and read again.
752 : : * Reminder: this only works for attributes which actively support
753 : : * it, and it is not possible to test an attribute from userspace
754 : : * to see if it supports poll (Neither 'poll' nor 'select' return
755 : : * an appropriate error code). When in doubt, set a suitable timeout value.
756 : : */
757 : 0 : static unsigned int sysfs_poll(struct file *filp, poll_table *wait)
758 : : {
759 : : struct sysfs_open_file *of = sysfs_of(filp);
760 : 0 : struct sysfs_dirent *attr_sd = filp->f_path.dentry->d_fsdata;
761 : 0 : struct sysfs_open_dirent *od = attr_sd->s_attr.open;
762 : :
763 : : /* need parent for the kobj, grab both */
764 [ # # ]: 0 : if (!sysfs_get_active(attr_sd))
765 : : goto trigger;
766 : :
767 : 0 : poll_wait(filp, &od->poll, wait);
768 : :
769 : 0 : sysfs_put_active(attr_sd);
770 : :
771 [ # # ]: 0 : if (of->event != atomic_read(&od->event))
772 : : goto trigger;
773 : :
774 : : return DEFAULT_POLLMASK;
775 : :
776 : : trigger:
777 : : return DEFAULT_POLLMASK|POLLERR|POLLPRI;
778 : : }
779 : :
780 : 0 : void sysfs_notify_dirent(struct sysfs_dirent *sd)
781 : : {
782 : : struct sysfs_open_dirent *od;
783 : : unsigned long flags;
784 : :
785 : 0 : spin_lock_irqsave(&sysfs_open_dirent_lock, flags);
786 : :
787 [ # # ][ # # ]: 0 : if (!WARN_ON(sysfs_type(sd) != SYSFS_KOBJ_ATTR)) {
788 : 0 : od = sd->s_attr.open;
789 [ # # ]: 0 : if (od) {
790 : 0 : atomic_inc(&od->event);
791 : 0 : wake_up_interruptible(&od->poll);
792 : : }
793 : : }
794 : :
795 : : spin_unlock_irqrestore(&sysfs_open_dirent_lock, flags);
796 : 0 : }
797 : : EXPORT_SYMBOL_GPL(sysfs_notify_dirent);
798 : :
799 : 0 : void sysfs_notify(struct kobject *k, const char *dir, const char *attr)
800 : : {
801 : 0 : struct sysfs_dirent *sd = k->sd;
802 : :
803 : 0 : mutex_lock(&sysfs_mutex);
804 : :
805 [ # # ]: 0 : if (sd && dir)
806 : 0 : sd = sysfs_find_dirent(sd, dir, NULL);
807 [ # # ]: 0 : if (sd && attr)
808 : 0 : sd = sysfs_find_dirent(sd, attr, NULL);
809 [ # # ]: 0 : if (sd)
810 : 0 : sysfs_notify_dirent(sd);
811 : :
812 : 0 : mutex_unlock(&sysfs_mutex);
813 : 0 : }
814 : : EXPORT_SYMBOL_GPL(sysfs_notify);
815 : :
816 : : const struct file_operations sysfs_file_operations = {
817 : : .read = seq_read,
818 : : .write = sysfs_write_file,
819 : : .llseek = generic_file_llseek,
820 : : .open = sysfs_open_file,
821 : : .release = sysfs_release,
822 : : .poll = sysfs_poll,
823 : : };
824 : :
825 : : const struct file_operations sysfs_bin_operations = {
826 : : .read = sysfs_bin_read,
827 : : .write = sysfs_write_file,
828 : : .llseek = generic_file_llseek,
829 : : .mmap = sysfs_bin_mmap,
830 : : .open = sysfs_open_file,
831 : : .release = sysfs_release,
832 : : .poll = sysfs_poll,
833 : : };
834 : :
835 : 0 : int sysfs_add_file_mode_ns(struct sysfs_dirent *dir_sd,
836 : : const struct attribute *attr, int type,
837 : : umode_t amode, const void *ns)
838 : : {
839 : 224 : umode_t mode = (amode & S_IALLUGO) | S_IFREG;
840 : : struct sysfs_addrm_cxt acxt;
841 : : struct sysfs_dirent *sd;
842 : : int rc;
843 : :
844 : 224 : sd = sysfs_new_dirent(attr->name, mode, type);
845 [ + - ]: 224 : if (!sd)
846 : : return -ENOMEM;
847 : :
848 : 224 : sd->s_ns = ns;
849 : 224 : sd->s_attr.attr = (void *)attr;
850 : : sysfs_dirent_init_lockdep(sd);
851 : :
852 : 224 : sysfs_addrm_start(&acxt);
853 : 224 : rc = sysfs_add_one(&acxt, sd, dir_sd);
854 : 224 : sysfs_addrm_finish(&acxt);
855 : :
856 [ - + ]: 224 : if (rc)
857 : : sysfs_put(sd);
858 : :
859 : 224 : return rc;
860 : : }
861 : :
862 : :
863 : 0 : int sysfs_add_file(struct sysfs_dirent *dir_sd, const struct attribute *attr,
864 : : int type)
865 : : {
866 : 0 : return sysfs_add_file_mode_ns(dir_sd, attr, type, attr->mode, NULL);
867 : : }
868 : :
869 : : /**
870 : : * sysfs_create_file_ns - create an attribute file for an object with custom ns
871 : : * @kobj: object we're creating for
872 : : * @attr: attribute descriptor
873 : : * @ns: namespace the new file should belong to
874 : : */
875 : 0 : int sysfs_create_file_ns(struct kobject *kobj, const struct attribute *attr,
876 : : const void *ns)
877 : : {
878 [ + - ][ + - ]: 224 : BUG_ON(!kobj || !kobj->sd || !attr);
[ + - ][ - + ]
879 : :
880 : 224 : return sysfs_add_file_mode_ns(kobj->sd, attr, SYSFS_KOBJ_ATTR,
881 : : attr->mode, ns);
882 : :
883 : : }
884 : : EXPORT_SYMBOL_GPL(sysfs_create_file_ns);
885 : :
886 : 0 : int sysfs_create_files(struct kobject *kobj, const struct attribute **ptr)
887 : : {
888 : : int err = 0;
889 : : int i;
890 : :
891 [ # # ][ # # ]: 0 : for (i = 0; ptr[i] && !err; i++)
892 : : err = sysfs_create_file(kobj, ptr[i]);
893 [ # # ]: 0 : if (err)
894 [ # # ]: 0 : while (--i >= 0)
895 : 0 : sysfs_remove_file(kobj, ptr[i]);
896 : 0 : return err;
897 : : }
898 : : EXPORT_SYMBOL_GPL(sysfs_create_files);
899 : :
900 : : /**
901 : : * sysfs_add_file_to_group - add an attribute file to a pre-existing group.
902 : : * @kobj: object we're acting for.
903 : : * @attr: attribute descriptor.
904 : : * @group: group name.
905 : : */
906 : 0 : int sysfs_add_file_to_group(struct kobject *kobj,
907 : : const struct attribute *attr, const char *group)
908 : : {
909 : : struct sysfs_dirent *dir_sd;
910 : : int error;
911 : :
912 [ # # ]: 0 : if (group)
913 : 0 : dir_sd = sysfs_get_dirent(kobj->sd, group);
914 : : else
915 : 0 : dir_sd = sysfs_get(kobj->sd);
916 : :
917 [ # # ]: 0 : if (!dir_sd)
918 : : return -ENOENT;
919 : :
920 : : error = sysfs_add_file(dir_sd, attr, SYSFS_KOBJ_ATTR);
921 : : sysfs_put(dir_sd);
922 : :
923 : 0 : return error;
924 : : }
925 : : EXPORT_SYMBOL_GPL(sysfs_add_file_to_group);
926 : :
927 : : /**
928 : : * sysfs_chmod_file - update the modified mode value on an object attribute.
929 : : * @kobj: object we're acting for.
930 : : * @attr: attribute descriptor.
931 : : * @mode: file permissions.
932 : : *
933 : : */
934 : 0 : int sysfs_chmod_file(struct kobject *kobj, const struct attribute *attr,
935 : : umode_t mode)
936 : : {
937 : : struct sysfs_dirent *sd;
938 : : struct iattr newattrs;
939 : : int rc;
940 : :
941 : 0 : mutex_lock(&sysfs_mutex);
942 : :
943 : : rc = -ENOENT;
944 : 0 : sd = sysfs_find_dirent(kobj->sd, attr->name, NULL);
945 [ # # ]: 0 : if (!sd)
946 : : goto out;
947 : :
948 : 0 : newattrs.ia_mode = (mode & S_IALLUGO) | (sd->s_mode & ~S_IALLUGO);
949 : 0 : newattrs.ia_valid = ATTR_MODE;
950 : 0 : rc = sysfs_sd_setattr(sd, &newattrs);
951 : :
952 : : out:
953 : 0 : mutex_unlock(&sysfs_mutex);
954 : 0 : return rc;
955 : : }
956 : : EXPORT_SYMBOL_GPL(sysfs_chmod_file);
957 : :
958 : : /**
959 : : * sysfs_remove_file_ns - remove an object attribute with a custom ns tag
960 : : * @kobj: object we're acting for
961 : : * @attr: attribute descriptor
962 : : * @ns: namespace tag of the file to remove
963 : : *
964 : : * Hash the attribute name and namespace tag and kill the victim.
965 : : */
966 : 0 : void sysfs_remove_file_ns(struct kobject *kobj, const struct attribute *attr,
967 : : const void *ns)
968 : : {
969 : 0 : struct sysfs_dirent *dir_sd = kobj->sd;
970 : :
971 : 0 : sysfs_hash_and_remove(dir_sd, attr->name, ns);
972 : 0 : }
973 : : EXPORT_SYMBOL_GPL(sysfs_remove_file_ns);
974 : :
975 : 0 : void sysfs_remove_files(struct kobject *kobj, const struct attribute **ptr)
976 : : {
977 : : int i;
978 [ # # ]: 0 : for (i = 0; ptr[i]; i++)
979 : : sysfs_remove_file(kobj, ptr[i]);
980 : 0 : }
981 : : EXPORT_SYMBOL_GPL(sysfs_remove_files);
982 : :
983 : : /**
984 : : * sysfs_remove_file_from_group - remove an attribute file from a group.
985 : : * @kobj: object we're acting for.
986 : : * @attr: attribute descriptor.
987 : : * @group: group name.
988 : : */
989 : 0 : void sysfs_remove_file_from_group(struct kobject *kobj,
990 : : const struct attribute *attr, const char *group)
991 : : {
992 : : struct sysfs_dirent *dir_sd;
993 : :
994 [ # # ]: 0 : if (group)
995 : 0 : dir_sd = sysfs_get_dirent(kobj->sd, group);
996 : : else
997 : 0 : dir_sd = sysfs_get(kobj->sd);
998 [ # # ]: 0 : if (dir_sd) {
999 : 0 : sysfs_hash_and_remove(dir_sd, attr->name, NULL);
1000 : : sysfs_put(dir_sd);
1001 : : }
1002 : 0 : }
1003 : : EXPORT_SYMBOL_GPL(sysfs_remove_file_from_group);
1004 : :
1005 : : /**
1006 : : * sysfs_create_bin_file - create binary file for object.
1007 : : * @kobj: object.
1008 : : * @attr: attribute descriptor.
1009 : : */
1010 : 0 : int sysfs_create_bin_file(struct kobject *kobj,
1011 : : const struct bin_attribute *attr)
1012 : : {
1013 [ # # ][ # # ]: 0 : BUG_ON(!kobj || !kobj->sd || !attr);
[ # # ][ # # ]
1014 : :
1015 : 0 : return sysfs_add_file(kobj->sd, &attr->attr, SYSFS_KOBJ_BIN_ATTR);
1016 : : }
1017 : : EXPORT_SYMBOL_GPL(sysfs_create_bin_file);
1018 : :
1019 : : /**
1020 : : * sysfs_remove_bin_file - remove binary file for object.
1021 : : * @kobj: object.
1022 : : * @attr: attribute descriptor.
1023 : : */
1024 : 0 : void sysfs_remove_bin_file(struct kobject *kobj,
1025 : : const struct bin_attribute *attr)
1026 : : {
1027 : 0 : sysfs_hash_and_remove(kobj->sd, attr->attr.name, NULL);
1028 : 0 : }
1029 : : EXPORT_SYMBOL_GPL(sysfs_remove_bin_file);
1030 : :
1031 : : struct sysfs_schedule_callback_struct {
1032 : : struct list_head workq_list;
1033 : : struct kobject *kobj;
1034 : : void (*func)(void *);
1035 : : void *data;
1036 : : struct module *owner;
1037 : : struct work_struct work;
1038 : : };
1039 : :
1040 : : static struct workqueue_struct *sysfs_workqueue;
1041 : : static DEFINE_MUTEX(sysfs_workq_mutex);
1042 : : static LIST_HEAD(sysfs_workq);
1043 : 0 : static void sysfs_schedule_callback_work(struct work_struct *work)
1044 : : {
1045 : 0 : struct sysfs_schedule_callback_struct *ss = container_of(work,
1046 : : struct sysfs_schedule_callback_struct, work);
1047 : :
1048 : 0 : (ss->func)(ss->data);
1049 : 0 : kobject_put(ss->kobj);
1050 : 0 : module_put(ss->owner);
1051 : 0 : mutex_lock(&sysfs_workq_mutex);
1052 : : list_del(&ss->workq_list);
1053 : 0 : mutex_unlock(&sysfs_workq_mutex);
1054 : 0 : kfree(ss);
1055 : 0 : }
1056 : :
1057 : : /**
1058 : : * sysfs_schedule_callback - helper to schedule a callback for a kobject
1059 : : * @kobj: object we're acting for.
1060 : : * @func: callback function to invoke later.
1061 : : * @data: argument to pass to @func.
1062 : : * @owner: module owning the callback code
1063 : : *
1064 : : * sysfs attribute methods must not unregister themselves or their parent
1065 : : * kobject (which would amount to the same thing). Attempts to do so will
1066 : : * deadlock, since unregistration is mutually exclusive with driver
1067 : : * callbacks.
1068 : : *
1069 : : * Instead methods can call this routine, which will attempt to allocate
1070 : : * and schedule a workqueue request to call back @func with @data as its
1071 : : * argument in the workqueue's process context. @kobj will be pinned
1072 : : * until @func returns.
1073 : : *
1074 : : * Returns 0 if the request was submitted, -ENOMEM if storage could not
1075 : : * be allocated, -ENODEV if a reference to @owner isn't available,
1076 : : * -EAGAIN if a callback has already been scheduled for @kobj.
1077 : : */
1078 : 0 : int sysfs_schedule_callback(struct kobject *kobj, void (*func)(void *),
1079 : : void *data, struct module *owner)
1080 : : {
1081 : : struct sysfs_schedule_callback_struct *ss, *tmp;
1082 : :
1083 [ # # ]: 0 : if (!try_module_get(owner))
1084 : : return -ENODEV;
1085 : :
1086 : 0 : mutex_lock(&sysfs_workq_mutex);
1087 [ # # ]: 0 : list_for_each_entry_safe(ss, tmp, &sysfs_workq, workq_list)
1088 [ # # ]: 0 : if (ss->kobj == kobj) {
1089 : 0 : module_put(owner);
1090 : 0 : mutex_unlock(&sysfs_workq_mutex);
1091 : 0 : return -EAGAIN;
1092 : : }
1093 : 0 : mutex_unlock(&sysfs_workq_mutex);
1094 : :
1095 [ # # ]: 0 : if (sysfs_workqueue == NULL) {
1096 : 0 : sysfs_workqueue = create_singlethread_workqueue("sysfsd");
1097 [ # # ]: 0 : if (sysfs_workqueue == NULL) {
1098 : 0 : module_put(owner);
1099 : 0 : return -ENOMEM;
1100 : : }
1101 : : }
1102 : :
1103 : : ss = kmalloc(sizeof(*ss), GFP_KERNEL);
1104 [ # # ]: 0 : if (!ss) {
1105 : 0 : module_put(owner);
1106 : 0 : return -ENOMEM;
1107 : : }
1108 : 0 : kobject_get(kobj);
1109 : 0 : ss->kobj = kobj;
1110 : 0 : ss->func = func;
1111 : 0 : ss->data = data;
1112 : 0 : ss->owner = owner;
1113 : 0 : INIT_WORK(&ss->work, sysfs_schedule_callback_work);
1114 : 0 : INIT_LIST_HEAD(&ss->workq_list);
1115 : 0 : mutex_lock(&sysfs_workq_mutex);
1116 : : list_add_tail(&ss->workq_list, &sysfs_workq);
1117 : 0 : mutex_unlock(&sysfs_workq_mutex);
1118 : 0 : queue_work(sysfs_workqueue, &ss->work);
1119 : 0 : return 0;
1120 : : }
1121 : : EXPORT_SYMBOL_GPL(sysfs_schedule_callback);
|
