Branch data Line data Source code
1 : : /*
2 : : * fs/kernfs/file.c - kernfs file implementation
3 : : *
4 : : * Copyright (c) 2001-3 Patrick Mochel
5 : : * Copyright (c) 2007 SUSE Linux Products GmbH
6 : : * Copyright (c) 2007, 2013 Tejun Heo <tj@kernel.org>
7 : : *
8 : : * This file is released under the GPLv2.
9 : : */
10 : :
11 : : #include <linux/fs.h>
12 : : #include <linux/seq_file.h>
13 : : #include <linux/slab.h>
14 : : #include <linux/poll.h>
15 : : #include <linux/pagemap.h>
16 : : #include <linux/sched.h>
17 : :
18 : : #include "kernfs-internal.h"
19 : :
20 : : /*
21 : : * There's one kernfs_open_file for each open file and one kernfs_open_node
22 : : * for each kernfs_node with one or more open files.
23 : : *
24 : : * kernfs_node->attr.open points to kernfs_open_node. attr.open is
25 : : * protected by kernfs_open_node_lock.
26 : : *
27 : : * filp->private_data points to seq_file whose ->private points to
28 : : * kernfs_open_file. kernfs_open_files are chained at
29 : : * kernfs_open_node->files, which is protected by kernfs_open_file_mutex.
30 : : */
31 : : static DEFINE_SPINLOCK(kernfs_open_node_lock);
32 : : static DEFINE_MUTEX(kernfs_open_file_mutex);
33 : :
34 : : struct kernfs_open_node {
35 : : atomic_t refcnt;
36 : : atomic_t event;
37 : : wait_queue_head_t poll;
38 : : struct list_head files; /* goes through kernfs_open_file.list */
39 : : };
40 : :
41 : : static struct kernfs_open_file *kernfs_of(struct file *file)
42 : : {
43 : 4188 : return ((struct seq_file *)file->private_data)->private;
44 : : }
45 : :
46 : : /*
47 : : * Determine the kernfs_ops for the given kernfs_node. This function must
48 : : * be called while holding an active reference.
49 : : */
50 : : static const struct kernfs_ops *kernfs_ops(struct kernfs_node *kn)
51 : : {
52 : : if (kn->flags & KERNFS_LOCKDEP)
53 : : lockdep_assert_held(kn);
54 : : return kn->attr.ops;
55 : : }
56 : :
57 : : /*
58 : : * As kernfs_seq_stop() is also called after kernfs_seq_start() or
59 : : * kernfs_seq_next() failure, it needs to distinguish whether it's stopping
60 : : * a seq_file iteration which is fully initialized with an active reference
61 : : * or an aborted kernfs_seq_start() due to get_active failure. The
62 : : * position pointer is the only context for each seq_file iteration and
63 : : * thus the stop condition should be encoded in it. As the return value is
64 : : * directly visible to userland, ERR_PTR(-ENODEV) is the only acceptable
65 : : * choice to indicate get_active failure.
66 : : *
67 : : * Unfortunately, this is complicated due to the optional custom seq_file
68 : : * operations which may return ERR_PTR(-ENODEV) too. kernfs_seq_stop()
69 : : * can't distinguish whether ERR_PTR(-ENODEV) is from get_active failure or
70 : : * custom seq_file operations and thus can't decide whether put_active
71 : : * should be performed or not only on ERR_PTR(-ENODEV).
72 : : *
73 : : * This is worked around by factoring out the custom seq_stop() and
74 : : * put_active part into kernfs_seq_stop_active(), skipping it from
75 : : * kernfs_seq_stop() if ERR_PTR(-ENODEV) while invoking it directly after
76 : : * custom seq_file operations fail with ERR_PTR(-ENODEV) - this ensures
77 : : * that kernfs_seq_stop_active() is skipped only after get_active failure.
78 : : */
79 : 0 : static void kernfs_seq_stop_active(struct seq_file *sf, void *v)
80 : : {
81 : 2382 : struct kernfs_open_file *of = sf->private;
82 : 2382 : const struct kernfs_ops *ops = kernfs_ops(of->kn);
83 : :
84 [ - + ]: 2382 : if (ops->seq_stop)
85 : 0 : ops->seq_stop(sf, v);
86 : 2382 : kernfs_put_active(of->kn);
87 : 2380 : }
88 : :
89 : 0 : static void *kernfs_seq_start(struct seq_file *sf, loff_t *ppos)
90 : : {
91 : 2381 : struct kernfs_open_file *of = sf->private;
92 : : const struct kernfs_ops *ops;
93 : :
94 : : /*
95 : : * @of->mutex nests outside active ref and is just to ensure that
96 : : * the ops aren't called concurrently for the same open file.
97 : : */
98 : 2381 : mutex_lock(&of->mutex);
99 [ + ]: 2383 : if (!kernfs_get_active(of->kn))
100 : : return ERR_PTR(-ENODEV);
101 : :
102 : 2383 : ops = kernfs_ops(of->kn);
103 [ - + ]: 4764 : if (ops->seq_start) {
104 : 0 : void *next = ops->seq_start(sf, ppos);
105 : : /* see the comment above kernfs_seq_stop_active() */
106 [ # # ]: 0 : if (next == ERR_PTR(-ENODEV))
107 : 0 : kernfs_seq_stop_active(sf, next);
108 : 0 : return next;
109 : : } else {
110 : : /*
111 : : * The same behavior and code as single_open(). Returns
112 : : * !NULL if pos is at the beginning; otherwise, NULL.
113 : : */
114 [ + + ]: 2383 : return NULL + !*ppos;
115 : : }
116 : : }
117 : :
118 : 0 : static void *kernfs_seq_next(struct seq_file *sf, void *v, loff_t *ppos)
119 : : {
120 : 1448 : struct kernfs_open_file *of = sf->private;
121 : 1448 : const struct kernfs_ops *ops = kernfs_ops(of->kn);
122 : :
123 [ - + ]: 1448 : if (ops->seq_next) {
124 : 0 : void *next = ops->seq_next(sf, v, ppos);
125 : : /* see the comment above kernfs_seq_stop_active() */
126 [ # # ]: 0 : if (next == ERR_PTR(-ENODEV))
127 : 0 : kernfs_seq_stop_active(sf, next);
128 : 0 : return next;
129 : : } else {
130 : : /*
131 : : * The same behavior and code as single_open(), always
132 : : * terminate after the initial read.
133 : : */
134 : 1448 : ++*ppos;
135 : 1448 : return NULL;
136 : : }
137 : : }
138 : :
139 : 0 : static void kernfs_seq_stop(struct seq_file *sf, void *v)
140 : : {
141 : 2381 : struct kernfs_open_file *of = sf->private;
142 : :
143 [ + ]: 2381 : if (v != ERR_PTR(-ENODEV))
144 : 2383 : kernfs_seq_stop_active(sf, v);
145 : 2378 : mutex_unlock(&of->mutex);
146 : 2380 : }
147 : :
148 : 0 : static int kernfs_seq_show(struct seq_file *sf, void *v)
149 : : {
150 : 1449 : struct kernfs_open_file *of = sf->private;
151 : :
152 : 1449 : of->event = atomic_read(&of->kn->attr.open->event);
153 : :
154 : 1449 : return of->kn->attr.ops->seq_show(sf, v);
155 : : }
156 : :
157 : : static const struct seq_operations kernfs_seq_ops = {
158 : : .start = kernfs_seq_start,
159 : : .next = kernfs_seq_next,
160 : : .stop = kernfs_seq_stop,
161 : : .show = kernfs_seq_show,
162 : : };
163 : :
164 : : /*
165 : : * As reading a bin file can have side-effects, the exact offset and bytes
166 : : * specified in read(2) call should be passed to the read callback making
167 : : * it difficult to use seq_file. Implement simplistic custom buffering for
168 : : * bin files.
169 : : */
170 : 0 : static ssize_t kernfs_file_direct_read(struct kernfs_open_file *of,
171 : : char __user *user_buf, size_t count,
172 : : loff_t *ppos)
173 : : {
174 : 8 : ssize_t len = min_t(size_t, count, PAGE_SIZE);
175 : : const struct kernfs_ops *ops;
176 : : char *buf;
177 : :
178 : : buf = kmalloc(len, GFP_KERNEL);
179 [ + - ]: 8 : if (!buf)
180 : : return -ENOMEM;
181 : :
182 : : /*
183 : : * @of->mutex nests outside active ref and is just to ensure that
184 : : * the ops aren't called concurrently for the same open file.
185 : : */
186 : 8 : mutex_lock(&of->mutex);
187 [ - + ]: 8 : if (!kernfs_get_active(of->kn)) {
188 : : len = -ENODEV;
189 : 0 : mutex_unlock(&of->mutex);
190 : 0 : goto out_free;
191 : : }
192 : :
193 : 8 : ops = kernfs_ops(of->kn);
194 [ + - ]: 8 : if (ops->read)
195 : 8 : len = ops->read(of, buf, len, *ppos);
196 : : else
197 : : len = -EINVAL;
198 : :
199 : 8 : kernfs_put_active(of->kn);
200 : 8 : mutex_unlock(&of->mutex);
201 : :
202 [ + - ]: 8 : if (len < 0)
203 : : goto out_free;
204 : :
205 [ + - ]: 16 : if (copy_to_user(user_buf, buf, len)) {
206 : : len = -EFAULT;
207 : : goto out_free;
208 : : }
209 : :
210 : 8 : *ppos += len;
211 : :
212 : : out_free:
213 : 8 : kfree(buf);
214 : 8 : return len;
215 : : }
216 : :
217 : : /**
218 : : * kernfs_fop_read - kernfs vfs read callback
219 : : * @file: file pointer
220 : : * @user_buf: data to write
221 : : * @count: number of bytes
222 : : * @ppos: starting offset
223 : : */
224 : 0 : static ssize_t kernfs_fop_read(struct file *file, char __user *user_buf,
225 : : size_t count, loff_t *ppos)
226 : : {
227 : : struct kernfs_open_file *of = kernfs_of(file);
228 : :
229 [ + + ]: 2386 : if (of->kn->flags & KERNFS_HAS_SEQ_SHOW)
230 : 2378 : return seq_read(file, user_buf, count, ppos);
231 : : else
232 : 8 : return kernfs_file_direct_read(of, user_buf, count, ppos);
233 : : }
234 : :
235 : : /**
236 : : * kernfs_fop_write - kernfs vfs write callback
237 : : * @file: file pointer
238 : : * @user_buf: data to write
239 : : * @count: number of bytes
240 : : * @ppos: starting offset
241 : : *
242 : : * Copy data in from userland and pass it to the matching kernfs write
243 : : * operation.
244 : : *
245 : : * There is no easy way for us to know if userspace is only doing a partial
246 : : * write, so we don't support them. We expect the entire buffer to come on
247 : : * the first write. Hint: if you're writing a value, first read the file,
248 : : * modify only the the value you're changing, then write entire buffer
249 : : * back.
250 : : */
251 : 0 : static ssize_t kernfs_fop_write(struct file *file, const char __user *user_buf,
252 : : size_t count, loff_t *ppos)
253 : : {
254 : : struct kernfs_open_file *of = kernfs_of(file);
255 : 176 : ssize_t len = min_t(size_t, count, PAGE_SIZE);
256 : : const struct kernfs_ops *ops;
257 : : char *buf;
258 : :
259 : 176 : buf = kmalloc(len + 1, GFP_KERNEL);
260 [ + - ]: 176 : if (!buf)
261 : : return -ENOMEM;
262 : :
263 [ + - ]: 176 : if (copy_from_user(buf, user_buf, len)) {
264 : : len = -EFAULT;
265 : : goto out_free;
266 : : }
267 : 176 : buf[len] = '\0'; /* guarantee string termination */
268 : :
269 : : /*
270 : : * @of->mutex nests outside active ref and is just to ensure that
271 : : * the ops aren't called concurrently for the same open file.
272 : : */
273 : 176 : mutex_lock(&of->mutex);
274 [ - + ]: 176 : if (!kernfs_get_active(of->kn)) {
275 : 0 : mutex_unlock(&of->mutex);
276 : : len = -ENODEV;
277 : 0 : goto out_free;
278 : : }
279 : :
280 : 176 : ops = kernfs_ops(of->kn);
281 [ + - ]: 176 : if (ops->write)
282 : 176 : len = ops->write(of, buf, len, *ppos);
283 : : else
284 : : len = -EINVAL;
285 : :
286 : 176 : kernfs_put_active(of->kn);
287 : 176 : mutex_unlock(&of->mutex);
288 : :
289 [ + - ]: 176 : if (len > 0)
290 : 176 : *ppos += len;
291 : : out_free:
292 : 176 : kfree(buf);
293 : 176 : return len;
294 : : }
295 : :
296 : 0 : static void kernfs_vma_open(struct vm_area_struct *vma)
297 : : {
298 : 0 : struct file *file = vma->vm_file;
299 : : struct kernfs_open_file *of = kernfs_of(file);
300 : :
301 [ # # ]: 0 : if (!of->vm_ops)
302 : : return;
303 : :
304 [ # # ]: 0 : if (!kernfs_get_active(of->kn))
305 : : return;
306 : :
307 [ # # ]: 0 : if (of->vm_ops->open)
308 : 0 : of->vm_ops->open(vma);
309 : :
310 : 0 : kernfs_put_active(of->kn);
311 : : }
312 : :
313 : 0 : static int kernfs_vma_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
314 : : {
315 : 0 : struct file *file = vma->vm_file;
316 : : struct kernfs_open_file *of = kernfs_of(file);
317 : : int ret;
318 : :
319 [ # # ]: 0 : if (!of->vm_ops)
320 : : return VM_FAULT_SIGBUS;
321 : :
322 [ # # ]: 0 : if (!kernfs_get_active(of->kn))
323 : : return VM_FAULT_SIGBUS;
324 : :
325 : : ret = VM_FAULT_SIGBUS;
326 [ # # ]: 0 : if (of->vm_ops->fault)
327 : 0 : ret = of->vm_ops->fault(vma, vmf);
328 : :
329 : 0 : kernfs_put_active(of->kn);
330 : 0 : return ret;
331 : : }
332 : :
333 : 0 : static int kernfs_vma_page_mkwrite(struct vm_area_struct *vma,
334 : : struct vm_fault *vmf)
335 : : {
336 : 0 : struct file *file = vma->vm_file;
337 : : struct kernfs_open_file *of = kernfs_of(file);
338 : : int ret;
339 : :
340 [ # # ]: 0 : if (!of->vm_ops)
341 : : return VM_FAULT_SIGBUS;
342 : :
343 [ # # ]: 0 : if (!kernfs_get_active(of->kn))
344 : : return VM_FAULT_SIGBUS;
345 : :
346 : : ret = 0;
347 [ # # ]: 0 : if (of->vm_ops->page_mkwrite)
348 : 0 : ret = of->vm_ops->page_mkwrite(vma, vmf);
349 : : else
350 : 0 : file_update_time(file);
351 : :
352 : 0 : kernfs_put_active(of->kn);
353 : 0 : return ret;
354 : : }
355 : :
356 : 0 : static int kernfs_vma_access(struct vm_area_struct *vma, unsigned long addr,
357 : : void *buf, int len, int write)
358 : : {
359 : 0 : struct file *file = vma->vm_file;
360 : : struct kernfs_open_file *of = kernfs_of(file);
361 : : int ret;
362 : :
363 [ # # ]: 0 : if (!of->vm_ops)
364 : : return -EINVAL;
365 : :
366 [ # # ]: 0 : if (!kernfs_get_active(of->kn))
367 : : return -EINVAL;
368 : :
369 : : ret = -EINVAL;
370 [ # # ]: 0 : if (of->vm_ops->access)
371 : 0 : ret = of->vm_ops->access(vma, addr, buf, len, write);
372 : :
373 : 0 : kernfs_put_active(of->kn);
374 : 0 : return ret;
375 : : }
376 : :
377 : : #ifdef CONFIG_NUMA
378 : : static int kernfs_vma_set_policy(struct vm_area_struct *vma,
379 : : struct mempolicy *new)
380 : : {
381 : : struct file *file = vma->vm_file;
382 : : struct kernfs_open_file *of = kernfs_of(file);
383 : : int ret;
384 : :
385 : : if (!of->vm_ops)
386 : : return 0;
387 : :
388 : : if (!kernfs_get_active(of->kn))
389 : : return -EINVAL;
390 : :
391 : : ret = 0;
392 : : if (of->vm_ops->set_policy)
393 : : ret = of->vm_ops->set_policy(vma, new);
394 : :
395 : : kernfs_put_active(of->kn);
396 : : return ret;
397 : : }
398 : :
399 : : static struct mempolicy *kernfs_vma_get_policy(struct vm_area_struct *vma,
400 : : unsigned long addr)
401 : : {
402 : : struct file *file = vma->vm_file;
403 : : struct kernfs_open_file *of = kernfs_of(file);
404 : : struct mempolicy *pol;
405 : :
406 : : if (!of->vm_ops)
407 : : return vma->vm_policy;
408 : :
409 : : if (!kernfs_get_active(of->kn))
410 : : return vma->vm_policy;
411 : :
412 : : pol = vma->vm_policy;
413 : : if (of->vm_ops->get_policy)
414 : : pol = of->vm_ops->get_policy(vma, addr);
415 : :
416 : : kernfs_put_active(of->kn);
417 : : return pol;
418 : : }
419 : :
420 : : static int kernfs_vma_migrate(struct vm_area_struct *vma,
421 : : const nodemask_t *from, const nodemask_t *to,
422 : : unsigned long flags)
423 : : {
424 : : struct file *file = vma->vm_file;
425 : : struct kernfs_open_file *of = kernfs_of(file);
426 : : int ret;
427 : :
428 : : if (!of->vm_ops)
429 : : return 0;
430 : :
431 : : if (!kernfs_get_active(of->kn))
432 : : return 0;
433 : :
434 : : ret = 0;
435 : : if (of->vm_ops->migrate)
436 : : ret = of->vm_ops->migrate(vma, from, to, flags);
437 : :
438 : : kernfs_put_active(of->kn);
439 : : return ret;
440 : : }
441 : : #endif
442 : :
443 : : static const struct vm_operations_struct kernfs_vm_ops = {
444 : : .open = kernfs_vma_open,
445 : : .fault = kernfs_vma_fault,
446 : : .page_mkwrite = kernfs_vma_page_mkwrite,
447 : : .access = kernfs_vma_access,
448 : : #ifdef CONFIG_NUMA
449 : : .set_policy = kernfs_vma_set_policy,
450 : : .get_policy = kernfs_vma_get_policy,
451 : : .migrate = kernfs_vma_migrate,
452 : : #endif
453 : : };
454 : :
455 : 0 : static int kernfs_fop_mmap(struct file *file, struct vm_area_struct *vma)
456 : : {
457 : : struct kernfs_open_file *of = kernfs_of(file);
458 : : const struct kernfs_ops *ops;
459 : : int rc;
460 : :
461 : : /*
462 : : * mmap path and of->mutex are prone to triggering spurious lockdep
463 : : * warnings and we don't want to add spurious locking dependency
464 : : * between the two. Check whether mmap is actually implemented
465 : : * without grabbing @of->mutex by testing HAS_MMAP flag. See the
466 : : * comment in kernfs_file_open() for more details.
467 : : */
468 [ # # ]: 0 : if (!(of->kn->flags & KERNFS_HAS_MMAP))
469 : : return -ENODEV;
470 : :
471 : 0 : mutex_lock(&of->mutex);
472 : :
473 : : rc = -ENODEV;
474 [ # # ]: 0 : if (!kernfs_get_active(of->kn))
475 : : goto out_unlock;
476 : :
477 : 0 : ops = kernfs_ops(of->kn);
478 : 0 : rc = ops->mmap(of, vma);
479 : :
480 : : /*
481 : : * PowerPC's pci_mmap of legacy_mem uses shmem_zero_setup()
482 : : * to satisfy versions of X which crash if the mmap fails: that
483 : : * substitutes a new vm_file, and we don't then want bin_vm_ops.
484 : : */
485 [ # # ]: 0 : if (vma->vm_file != file)
486 : : goto out_put;
487 : :
488 : : rc = -EINVAL;
489 [ # # ][ # # ]: 0 : if (of->mmapped && of->vm_ops != vma->vm_ops)
490 : : goto out_put;
491 : :
492 : : /*
493 : : * It is not possible to successfully wrap close.
494 : : * So error if someone is trying to use close.
495 : : */
496 : : rc = -EINVAL;
497 [ # # ][ # # ]: 0 : if (vma->vm_ops && vma->vm_ops->close)
498 : : goto out_put;
499 : :
500 : : rc = 0;
501 : 0 : of->mmapped = 1;
502 : 0 : of->vm_ops = vma->vm_ops;
503 : 0 : vma->vm_ops = &kernfs_vm_ops;
504 : : out_put:
505 : 0 : kernfs_put_active(of->kn);
506 : : out_unlock:
507 : 0 : mutex_unlock(&of->mutex);
508 : :
509 : 0 : return rc;
510 : : }
511 : :
512 : : /**
513 : : * kernfs_get_open_node - get or create kernfs_open_node
514 : : * @kn: target kernfs_node
515 : : * @of: kernfs_open_file for this instance of open
516 : : *
517 : : * If @kn->attr.open exists, increment its reference count; otherwise,
518 : : * create one. @of is chained to the files list.
519 : : *
520 : : * LOCKING:
521 : : * Kernel thread context (may sleep).
522 : : *
523 : : * RETURNS:
524 : : * 0 on success, -errno on failure.
525 : : */
526 : 1633 : static int kernfs_get_open_node(struct kernfs_node *kn,
527 : : struct kernfs_open_file *of)
528 : : {
529 : : struct kernfs_open_node *on, *new_on = NULL;
530 : :
531 : : retry:
532 : 3172 : mutex_lock(&kernfs_open_file_mutex);
533 : : spin_lock_irq(&kernfs_open_node_lock);
534 : :
535 [ + + ][ + + ]: 3172 : if (!kn->attr.open && new_on) {
536 : 1538 : kn->attr.open = new_on;
537 : : new_on = NULL;
538 : : }
539 : :
540 : 3172 : on = kn->attr.open;
541 [ + + ]: 3172 : if (on) {
542 : 1633 : atomic_inc(&on->refcnt);
543 : 1633 : list_add_tail(&of->list, &on->files);
544 : : }
545 : :
546 : : spin_unlock_irq(&kernfs_open_node_lock);
547 : 3172 : mutex_unlock(&kernfs_open_file_mutex);
548 : :
549 [ + + ]: 3172 : if (on) {
550 : 1633 : kfree(new_on);
551 : : return 0;
552 : : }
553 : :
554 : : /* not there, initialize a new one and retry */
555 : : new_on = kmalloc(sizeof(*new_on), GFP_KERNEL);
556 [ + - ]: 1539 : if (!new_on)
557 : : return -ENOMEM;
558 : :
559 : 1539 : atomic_set(&new_on->refcnt, 0);
560 : 1539 : atomic_set(&new_on->event, 1);
561 : 1539 : init_waitqueue_head(&new_on->poll);
562 : 1539 : INIT_LIST_HEAD(&new_on->files);
563 : : goto retry;
564 : : }
565 : :
566 : : /**
567 : : * kernfs_put_open_node - put kernfs_open_node
568 : : * @kn: target kernfs_nodet
569 : : * @of: associated kernfs_open_file
570 : : *
571 : : * Put @kn->attr.open and unlink @of from the files list. If
572 : : * reference count reaches zero, disassociate and free it.
573 : : *
574 : : * LOCKING:
575 : : * None.
576 : : */
577 : 1627 : static void kernfs_put_open_node(struct kernfs_node *kn,
578 : : struct kernfs_open_file *of)
579 : : {
580 : 1627 : struct kernfs_open_node *on = kn->attr.open;
581 : : unsigned long flags;
582 : :
583 : 1627 : mutex_lock(&kernfs_open_file_mutex);
584 : 1633 : spin_lock_irqsave(&kernfs_open_node_lock, flags);
585 : :
586 [ + - ]: 1633 : if (of)
587 : : list_del(&of->list);
588 : :
589 [ + + ]: 1633 : if (atomic_dec_and_test(&on->refcnt))
590 : 1538 : kn->attr.open = NULL;
591 : : else
592 : : on = NULL;
593 : :
594 : : spin_unlock_irqrestore(&kernfs_open_node_lock, flags);
595 : 1633 : mutex_unlock(&kernfs_open_file_mutex);
596 : :
597 : 1633 : kfree(on);
598 : 1633 : }
599 : :
600 : 0 : static int kernfs_fop_open(struct inode *inode, struct file *file)
601 : : {
602 : 3266 : struct kernfs_node *kn = file->f_path.dentry->d_fsdata;
603 : : const struct kernfs_ops *ops;
604 : : struct kernfs_open_file *of;
605 : : bool has_read, has_write, has_mmap;
606 : : int error = -EACCES;
607 : :
608 [ + - ]: 1633 : if (!kernfs_get_active(kn))
609 : : return -ENODEV;
610 : :
611 : : ops = kernfs_ops(kn);
612 : :
613 [ + + ][ - + ]: 1633 : has_read = ops->seq_show || ops->read || ops->mmap;
[ # # ]
614 [ + + ][ + - ]: 1633 : has_write = ops->write || ops->mmap;
615 : 1633 : has_mmap = ops->mmap;
616 : :
617 : : /* check perms and supported operations */
618 [ + + ][ + - ]: 1633 : if ((file->f_mode & FMODE_WRITE) &&
619 [ + - ]: 176 : (!(inode->i_mode & S_IWUGO) || !has_write))
620 : : goto err_out;
621 : :
622 [ + + ][ + - ]: 1633 : if ((file->f_mode & FMODE_READ) &&
623 [ + - ]: 1457 : (!(inode->i_mode & S_IRUGO) || !has_read))
624 : : goto err_out;
625 : :
626 : : /* allocate a kernfs_open_file for the file */
627 : : error = -ENOMEM;
628 : : of = kzalloc(sizeof(struct kernfs_open_file), GFP_KERNEL);
629 [ + - ]: 1633 : if (!of)
630 : : goto err_out;
631 : :
632 : : /*
633 : : * The following is done to give a different lockdep key to
634 : : * @of->mutex for files which implement mmap. This is a rather
635 : : * crude way to avoid false positive lockdep warning around
636 : : * mm->mmap_sem - mmap nests @of->mutex under mm->mmap_sem and
637 : : * reading /sys/block/sda/trace/act_mask grabs sr_mutex, under
638 : : * which mm->mmap_sem nests, while holding @of->mutex. As each
639 : : * open file has a separate mutex, it's okay as long as those don't
640 : : * happen on the same file. At this point, we can't easily give
641 : : * each file a separate locking class. Let's differentiate on
642 : : * whether the file has mmap or not for now.
643 : : *
644 : : * Both paths of the branch look the same. They're supposed to
645 : : * look that way and give @of->mutex different static lockdep keys.
646 : : */
647 [ - + ]: 1633 : if (has_mmap)
648 : 0 : mutex_init(&of->mutex);
649 : : else
650 : 1633 : mutex_init(&of->mutex);
651 : :
652 : 1633 : of->kn = kn;
653 : 1633 : of->file = file;
654 : :
655 : : /*
656 : : * Always instantiate seq_file even if read access doesn't use
657 : : * seq_file or is not requested. This unifies private data access
658 : : * and readable regular files are the vast majority anyway.
659 : : */
660 [ + + ]: 1633 : if (ops->seq_show)
661 : 1625 : error = seq_open(file, &kernfs_seq_ops);
662 : : else
663 : 8 : error = seq_open(file, NULL);
664 [ + - ]: 1633 : if (error)
665 : : goto err_free;
666 : :
667 : 1633 : ((struct seq_file *)file->private_data)->private = of;
668 : :
669 : : /* seq_file clears PWRITE unconditionally, restore it if WRITE */
670 [ + + ]: 1633 : if (file->f_mode & FMODE_WRITE)
671 : 176 : file->f_mode |= FMODE_PWRITE;
672 : :
673 : : /* make sure we have open node struct */
674 : 1633 : error = kernfs_get_open_node(kn, of);
675 [ + - ]: 1633 : if (error)
676 : : goto err_close;
677 : :
678 : : /* open succeeded, put active references */
679 : 1633 : kernfs_put_active(kn);
680 : 1633 : return 0;
681 : :
682 : : err_close:
683 : 0 : seq_release(inode, file);
684 : : err_free:
685 : 0 : kfree(of);
686 : : err_out:
687 : 0 : kernfs_put_active(kn);
688 : 0 : return error;
689 : : }
690 : :
691 : 0 : static int kernfs_fop_release(struct inode *inode, struct file *filp)
692 : : {
693 : 1626 : struct kernfs_node *kn = filp->f_path.dentry->d_fsdata;
694 : : struct kernfs_open_file *of = kernfs_of(filp);
695 : :
696 : 1626 : kernfs_put_open_node(kn, of);
697 : 1633 : seq_release(inode, filp);
698 : 1633 : kfree(of);
699 : :
700 : 1633 : return 0;
701 : : }
702 : :
703 : 0 : void kernfs_unmap_bin_file(struct kernfs_node *kn)
704 : : {
705 : : struct kernfs_open_node *on;
706 : : struct kernfs_open_file *of;
707 : :
708 [ - + ]: 987 : if (!(kn->flags & KERNFS_HAS_MMAP))
709 : : return;
710 : :
711 : : spin_lock_irq(&kernfs_open_node_lock);
712 : 0 : on = kn->attr.open;
713 [ # # ]: 0 : if (on)
714 : 0 : atomic_inc(&on->refcnt);
715 : : spin_unlock_irq(&kernfs_open_node_lock);
716 [ # # ]: 0 : if (!on)
717 : : return;
718 : :
719 : 0 : mutex_lock(&kernfs_open_file_mutex);
720 [ # # ]: 987 : list_for_each_entry(of, &on->files, list) {
721 : 0 : struct inode *inode = file_inode(of->file);
722 : 0 : unmap_mapping_range(inode->i_mapping, 0, 0, 1);
723 : : }
724 : 0 : mutex_unlock(&kernfs_open_file_mutex);
725 : :
726 : 0 : kernfs_put_open_node(kn, NULL);
727 : : }
728 : :
729 : : /*
730 : : * Kernfs attribute files are pollable. The idea is that you read
731 : : * the content and then you use 'poll' or 'select' to wait for
732 : : * the content to change. When the content changes (assuming the
733 : : * manager for the kobject supports notification), poll will
734 : : * return POLLERR|POLLPRI, and select will return the fd whether
735 : : * it is waiting for read, write, or exceptions.
736 : : * Once poll/select indicates that the value has changed, you
737 : : * need to close and re-open the file, or seek to 0 and read again.
738 : : * Reminder: this only works for attributes which actively support
739 : : * it, and it is not possible to test an attribute from userspace
740 : : * to see if it supports poll (Neither 'poll' nor 'select' return
741 : : * an appropriate error code). When in doubt, set a suitable timeout value.
742 : : */
743 : 0 : static unsigned int kernfs_fop_poll(struct file *filp, poll_table *wait)
744 : : {
745 : : struct kernfs_open_file *of = kernfs_of(filp);
746 : 0 : struct kernfs_node *kn = filp->f_path.dentry->d_fsdata;
747 : 0 : struct kernfs_open_node *on = kn->attr.open;
748 : :
749 : : /* need parent for the kobj, grab both */
750 [ # # ]: 0 : if (!kernfs_get_active(kn))
751 : : goto trigger;
752 : :
753 : 0 : poll_wait(filp, &on->poll, wait);
754 : :
755 : 0 : kernfs_put_active(kn);
756 : :
757 [ # # ]: 0 : if (of->event != atomic_read(&on->event))
758 : : goto trigger;
759 : :
760 : : return DEFAULT_POLLMASK;
761 : :
762 : : trigger:
763 : : return DEFAULT_POLLMASK|POLLERR|POLLPRI;
764 : : }
765 : :
766 : : /**
767 : : * kernfs_notify - notify a kernfs file
768 : : * @kn: file to notify
769 : : *
770 : : * Notify @kn such that poll(2) on @kn wakes up.
771 : : */
772 : 0 : void kernfs_notify(struct kernfs_node *kn)
773 : : {
774 : : struct kernfs_open_node *on;
775 : : unsigned long flags;
776 : :
777 : 0 : spin_lock_irqsave(&kernfs_open_node_lock, flags);
778 : :
779 [ # # ][ # # ]: 0 : if (!WARN_ON(kernfs_type(kn) != KERNFS_FILE)) {
780 : 0 : on = kn->attr.open;
781 [ # # ]: 0 : if (on) {
782 : 0 : atomic_inc(&on->event);
783 : 0 : wake_up_interruptible(&on->poll);
784 : : }
785 : : }
786 : :
787 : : spin_unlock_irqrestore(&kernfs_open_node_lock, flags);
788 : 0 : }
789 : : EXPORT_SYMBOL_GPL(kernfs_notify);
790 : :
791 : : const struct file_operations kernfs_file_fops = {
792 : : .read = kernfs_fop_read,
793 : : .write = kernfs_fop_write,
794 : : .llseek = generic_file_llseek,
795 : : .mmap = kernfs_fop_mmap,
796 : : .open = kernfs_fop_open,
797 : : .release = kernfs_fop_release,
798 : : .poll = kernfs_fop_poll,
799 : : };
800 : :
801 : : /**
802 : : * __kernfs_create_file - kernfs internal function to create a file
803 : : * @parent: directory to create the file in
804 : : * @name: name of the file
805 : : * @mode: mode of the file
806 : : * @size: size of the file
807 : : * @ops: kernfs operations for the file
808 : : * @priv: private data for the file
809 : : * @ns: optional namespace tag of the file
810 : : * @static_name: don't copy file name
811 : : * @key: lockdep key for the file's active_ref, %NULL to disable lockdep
812 : : *
813 : : * Returns the created node on success, ERR_PTR() value on error.
814 : : */
815 : 0 : struct kernfs_node *__kernfs_create_file(struct kernfs_node *parent,
816 : : const char *name,
817 : : umode_t mode, loff_t size,
818 : : const struct kernfs_ops *ops,
819 : : void *priv, const void *ns,
820 : : bool name_is_static,
821 : : struct lock_class_key *key)
822 : : {
823 : : struct kernfs_addrm_cxt acxt;
824 : : struct kernfs_node *kn;
825 : : unsigned flags;
826 : : int rc;
827 : :
828 : : flags = KERNFS_FILE;
829 [ + - ]: 966 : if (name_is_static)
830 : : flags |= KERNFS_STATIC_NAME;
831 : :
832 : 966 : kn = kernfs_new_node(parent, name, (mode & S_IALLUGO) | S_IFREG, flags);
833 [ + - ]: 966 : if (!kn)
834 : : return ERR_PTR(-ENOMEM);
835 : :
836 : 966 : kn->attr.ops = ops;
837 : 966 : kn->attr.size = size;
838 : 966 : kn->ns = ns;
839 : 966 : kn->priv = priv;
840 : :
841 : : #ifdef CONFIG_DEBUG_LOCK_ALLOC
842 : : if (key) {
843 : : lockdep_init_map(&kn->dep_map, "s_active", key, 0);
844 : : kn->flags |= KERNFS_LOCKDEP;
845 : : }
846 : : #endif
847 : :
848 : : /*
849 : : * kn->attr.ops is accesible only while holding active ref. We
850 : : * need to know whether some ops are implemented outside active
851 : : * ref. Cache their existence in flags.
852 : : */
853 [ + + ]: 966 : if (ops->seq_show)
854 : 962 : kn->flags |= KERNFS_HAS_SEQ_SHOW;
855 [ - + ]: 966 : if (ops->mmap)
856 : 0 : kn->flags |= KERNFS_HAS_MMAP;
857 : :
858 : 966 : kernfs_addrm_start(&acxt);
859 : 966 : rc = kernfs_add_one(&acxt, kn);
860 : 966 : kernfs_addrm_finish(&acxt);
861 : :
862 [ - + ]: 966 : if (rc) {
863 : 0 : kernfs_put(kn);
864 : 0 : return ERR_PTR(rc);
865 : : }
866 : : return kn;
867 : : }
|
