1
2
3
4
5
6
7
8
9
10#include <linux/fs.h>
11#include <linux/seq_file.h>
12#include <linux/slab.h>
13#include <linux/poll.h>
14#include <linux/pagemap.h>
15#include <linux/sched/mm.h>
16#include <linux/fsnotify.h>
17#include <linux/uio.h>
18
19#include "kernfs-internal.h"
20
21
22
23
24
25
26
27
28
29
30
31
32static DEFINE_SPINLOCK(kernfs_open_node_lock);
33static DEFINE_MUTEX(kernfs_open_file_mutex);
34
35struct kernfs_open_node {
36 atomic_t event;
37 wait_queue_head_t poll;
38 struct list_head files;
39};
40
41
42
43
44
45
46
47
48
49#define KERNFS_NOTIFY_EOL ((void *)&kernfs_notify_list)
50
51static DEFINE_SPINLOCK(kernfs_notify_lock);
52static struct kernfs_node *kernfs_notify_list = KERNFS_NOTIFY_EOL;
53
54static struct kernfs_open_file *kernfs_of(struct file *file)
55{
56 return ((struct seq_file *)file->private_data)->private;
57}
58
59
60
61
62
63static const struct kernfs_ops *kernfs_ops(struct kernfs_node *kn)
64{
65 if (kn->flags & KERNFS_LOCKDEP)
66 lockdep_assert_held(kn);
67 return kn->attr.ops;
68}
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92static void kernfs_seq_stop_active(struct seq_file *sf, void *v)
93{
94 struct kernfs_open_file *of = sf->private;
95 const struct kernfs_ops *ops = kernfs_ops(of->kn);
96
97 if (ops->seq_stop)
98 ops->seq_stop(sf, v);
99 kernfs_put_active(of->kn);
100}
101
102static void *kernfs_seq_start(struct seq_file *sf, loff_t *ppos)
103{
104 struct kernfs_open_file *of = sf->private;
105 const struct kernfs_ops *ops;
106
107
108
109
110
111 mutex_lock(&of->mutex);
112 if (!kernfs_get_active(of->kn))
113 return ERR_PTR(-ENODEV);
114
115 ops = kernfs_ops(of->kn);
116 if (ops->seq_start) {
117 void *next = ops->seq_start(sf, ppos);
118
119 if (next == ERR_PTR(-ENODEV))
120 kernfs_seq_stop_active(sf, next);
121 return next;
122 }
123 return single_start(sf, ppos);
124}
125
126static void *kernfs_seq_next(struct seq_file *sf, void *v, loff_t *ppos)
127{
128 struct kernfs_open_file *of = sf->private;
129 const struct kernfs_ops *ops = kernfs_ops(of->kn);
130
131 if (ops->seq_next) {
132 void *next = ops->seq_next(sf, v, ppos);
133
134 if (next == ERR_PTR(-ENODEV))
135 kernfs_seq_stop_active(sf, next);
136 return next;
137 } else {
138
139
140
141
142 ++*ppos;
143 return NULL;
144 }
145}
146
147static void kernfs_seq_stop(struct seq_file *sf, void *v)
148{
149 struct kernfs_open_file *of = sf->private;
150
151 if (v != ERR_PTR(-ENODEV))
152 kernfs_seq_stop_active(sf, v);
153 mutex_unlock(&of->mutex);
154}
155
156static int kernfs_seq_show(struct seq_file *sf, void *v)
157{
158 struct kernfs_open_file *of = sf->private;
159
160 of->event = atomic_read(&of->kn->attr.open->event);
161
162 return of->kn->attr.ops->seq_show(sf, v);
163}
164
165static const struct seq_operations kernfs_seq_ops = {
166 .start = kernfs_seq_start,
167 .next = kernfs_seq_next,
168 .stop = kernfs_seq_stop,
169 .show = kernfs_seq_show,
170};
171
172
173
174
175
176
177
178static ssize_t kernfs_file_read_iter(struct kiocb *iocb, struct iov_iter *iter)
179{
180 struct kernfs_open_file *of = kernfs_of(iocb->ki_filp);
181 ssize_t len = min_t(size_t, iov_iter_count(iter), PAGE_SIZE);
182 const struct kernfs_ops *ops;
183 char *buf;
184
185 buf = of->prealloc_buf;
186 if (buf)
187 mutex_lock(&of->prealloc_mutex);
188 else
189 buf = kmalloc(len, GFP_KERNEL);
190 if (!buf)
191 return -ENOMEM;
192
193
194
195
196
197 mutex_lock(&of->mutex);
198 if (!kernfs_get_active(of->kn)) {
199 len = -ENODEV;
200 mutex_unlock(&of->mutex);
201 goto out_free;
202 }
203
204 of->event = atomic_read(&of->kn->attr.open->event);
205 ops = kernfs_ops(of->kn);
206 if (ops->read)
207 len = ops->read(of, buf, len, iocb->ki_pos);
208 else
209 len = -EINVAL;
210
211 kernfs_put_active(of->kn);
212 mutex_unlock(&of->mutex);
213
214 if (len < 0)
215 goto out_free;
216
217 if (copy_to_iter(buf, len, iter) != len) {
218 len = -EFAULT;
219 goto out_free;
220 }
221
222 iocb->ki_pos += len;
223
224 out_free:
225 if (buf == of->prealloc_buf)
226 mutex_unlock(&of->prealloc_mutex);
227 else
228 kfree(buf);
229 return len;
230}
231
232static ssize_t kernfs_fop_read_iter(struct kiocb *iocb, struct iov_iter *iter)
233{
234 if (kernfs_of(iocb->ki_filp)->kn->flags & KERNFS_HAS_SEQ_SHOW)
235 return seq_read_iter(iocb, iter);
236 return kernfs_file_read_iter(iocb, iter);
237}
238
239
240
241
242
243
244
245
246
247
248
249static ssize_t kernfs_fop_write_iter(struct kiocb *iocb, struct iov_iter *iter)
250{
251 struct kernfs_open_file *of = kernfs_of(iocb->ki_filp);
252 ssize_t len = iov_iter_count(iter);
253 const struct kernfs_ops *ops;
254 char *buf;
255
256 if (of->atomic_write_len) {
257 if (len > of->atomic_write_len)
258 return -E2BIG;
259 } else {
260 len = min_t(size_t, len, PAGE_SIZE);
261 }
262
263 buf = of->prealloc_buf;
264 if (buf)
265 mutex_lock(&of->prealloc_mutex);
266 else
267 buf = kmalloc(len + 1, GFP_KERNEL);
268 if (!buf)
269 return -ENOMEM;
270
271 if (copy_from_iter(buf, len, iter) != len) {
272 len = -EFAULT;
273 goto out_free;
274 }
275 buf[len] = '\0';
276
277
278
279
280
281 mutex_lock(&of->mutex);
282 if (!kernfs_get_active(of->kn)) {
283 mutex_unlock(&of->mutex);
284 len = -ENODEV;
285 goto out_free;
286 }
287
288 ops = kernfs_ops(of->kn);
289 if (ops->write)
290 len = ops->write(of, buf, len, iocb->ki_pos);
291 else
292 len = -EINVAL;
293
294 kernfs_put_active(of->kn);
295 mutex_unlock(&of->mutex);
296
297 if (len > 0)
298 iocb->ki_pos += len;
299
300out_free:
301 if (buf == of->prealloc_buf)
302 mutex_unlock(&of->prealloc_mutex);
303 else
304 kfree(buf);
305 return len;
306}
307
308static void kernfs_vma_open(struct vm_area_struct *vma)
309{
310 struct file *file = vma->vm_file;
311 struct kernfs_open_file *of = kernfs_of(file);
312
313 if (!of->vm_ops)
314 return;
315
316 if (!kernfs_get_active(of->kn))
317 return;
318
319 if (of->vm_ops->open)
320 of->vm_ops->open(vma);
321
322 kernfs_put_active(of->kn);
323}
324
325static vm_fault_t kernfs_vma_fault(struct vm_fault *vmf)
326{
327 struct file *file = vmf->vma->vm_file;
328 struct kernfs_open_file *of = kernfs_of(file);
329 vm_fault_t ret;
330
331 if (!of->vm_ops)
332 return VM_FAULT_SIGBUS;
333
334 if (!kernfs_get_active(of->kn))
335 return VM_FAULT_SIGBUS;
336
337 ret = VM_FAULT_SIGBUS;
338 if (of->vm_ops->fault)
339 ret = of->vm_ops->fault(vmf);
340
341 kernfs_put_active(of->kn);
342 return ret;
343}
344
345static vm_fault_t kernfs_vma_page_mkwrite(struct vm_fault *vmf)
346{
347 struct file *file = vmf->vma->vm_file;
348 struct kernfs_open_file *of = kernfs_of(file);
349 vm_fault_t ret;
350
351 if (!of->vm_ops)
352 return VM_FAULT_SIGBUS;
353
354 if (!kernfs_get_active(of->kn))
355 return VM_FAULT_SIGBUS;
356
357 ret = 0;
358 if (of->vm_ops->page_mkwrite)
359 ret = of->vm_ops->page_mkwrite(vmf);
360 else
361 file_update_time(file);
362
363 kernfs_put_active(of->kn);
364 return ret;
365}
366
367static int kernfs_vma_access(struct vm_area_struct *vma, unsigned long addr,
368 void *buf, int len, int write)
369{
370 struct file *file = vma->vm_file;
371 struct kernfs_open_file *of = kernfs_of(file);
372 int ret;
373
374 if (!of->vm_ops)
375 return -EINVAL;
376
377 if (!kernfs_get_active(of->kn))
378 return -EINVAL;
379
380 ret = -EINVAL;
381 if (of->vm_ops->access)
382 ret = of->vm_ops->access(vma, addr, buf, len, write);
383
384 kernfs_put_active(of->kn);
385 return ret;
386}
387
388#ifdef CONFIG_NUMA
389static int kernfs_vma_set_policy(struct vm_area_struct *vma,
390 struct mempolicy *new)
391{
392 struct file *file = vma->vm_file;
393 struct kernfs_open_file *of = kernfs_of(file);
394 int ret;
395
396 if (!of->vm_ops)
397 return 0;
398
399 if (!kernfs_get_active(of->kn))
400 return -EINVAL;
401
402 ret = 0;
403 if (of->vm_ops->set_policy)
404 ret = of->vm_ops->set_policy(vma, new);
405
406 kernfs_put_active(of->kn);
407 return ret;
408}
409
410static struct mempolicy *kernfs_vma_get_policy(struct vm_area_struct *vma,
411 unsigned long addr)
412{
413 struct file *file = vma->vm_file;
414 struct kernfs_open_file *of = kernfs_of(file);
415 struct mempolicy *pol;
416
417 if (!of->vm_ops)
418 return vma->vm_policy;
419
420 if (!kernfs_get_active(of->kn))
421 return vma->vm_policy;
422
423 pol = vma->vm_policy;
424 if (of->vm_ops->get_policy)
425 pol = of->vm_ops->get_policy(vma, addr);
426
427 kernfs_put_active(of->kn);
428 return pol;
429}
430
431#endif
432
433static const struct vm_operations_struct kernfs_vm_ops = {
434 .open = kernfs_vma_open,
435 .fault = kernfs_vma_fault,
436 .page_mkwrite = kernfs_vma_page_mkwrite,
437 .access = kernfs_vma_access,
438#ifdef CONFIG_NUMA
439 .set_policy = kernfs_vma_set_policy,
440 .get_policy = kernfs_vma_get_policy,
441#endif
442};
443
444static int kernfs_fop_mmap(struct file *file, struct vm_area_struct *vma)
445{
446 struct kernfs_open_file *of = kernfs_of(file);
447 const struct kernfs_ops *ops;
448 int rc;
449
450
451
452
453
454
455
456
457 if (!(of->kn->flags & KERNFS_HAS_MMAP))
458 return -ENODEV;
459
460 mutex_lock(&of->mutex);
461
462 rc = -ENODEV;
463 if (!kernfs_get_active(of->kn))
464 goto out_unlock;
465
466 ops = kernfs_ops(of->kn);
467 rc = ops->mmap(of, vma);
468 if (rc)
469 goto out_put;
470
471
472
473
474
475
476 if (vma->vm_file != file)
477 goto out_put;
478
479 rc = -EINVAL;
480 if (of->mmapped && of->vm_ops != vma->vm_ops)
481 goto out_put;
482
483
484
485
486
487 rc = -EINVAL;
488 if (vma->vm_ops && vma->vm_ops->close)
489 goto out_put;
490
491 rc = 0;
492 of->mmapped = true;
493 of->vm_ops = vma->vm_ops;
494 vma->vm_ops = &kernfs_vm_ops;
495out_put:
496 kernfs_put_active(of->kn);
497out_unlock:
498 mutex_unlock(&of->mutex);
499
500 return rc;
501}
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517static int kernfs_get_open_node(struct kernfs_node *kn,
518 struct kernfs_open_file *of)
519{
520 struct kernfs_open_node *on, *new_on = NULL;
521
522 retry:
523 mutex_lock(&kernfs_open_file_mutex);
524 spin_lock_irq(&kernfs_open_node_lock);
525
526 if (!kn->attr.open && new_on) {
527 kn->attr.open = new_on;
528 new_on = NULL;
529 }
530
531 on = kn->attr.open;
532 if (on)
533 list_add_tail(&of->list, &on->files);
534
535 spin_unlock_irq(&kernfs_open_node_lock);
536 mutex_unlock(&kernfs_open_file_mutex);
537
538 if (on) {
539 kfree(new_on);
540 return 0;
541 }
542
543
544 new_on = kmalloc(sizeof(*new_on), GFP_KERNEL);
545 if (!new_on)
546 return -ENOMEM;
547
548 atomic_set(&new_on->event, 1);
549 init_waitqueue_head(&new_on->poll);
550 INIT_LIST_HEAD(&new_on->files);
551 goto retry;
552}
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567static void kernfs_unlink_open_file(struct kernfs_node *kn,
568 struct kernfs_open_file *of)
569{
570 struct kernfs_open_node *on = kn->attr.open;
571 unsigned long flags;
572
573 mutex_lock(&kernfs_open_file_mutex);
574 spin_lock_irqsave(&kernfs_open_node_lock, flags);
575
576 if (of)
577 list_del(&of->list);
578
579 if (list_empty(&on->files))
580 kn->attr.open = NULL;
581 else
582 on = NULL;
583
584 spin_unlock_irqrestore(&kernfs_open_node_lock, flags);
585 mutex_unlock(&kernfs_open_file_mutex);
586
587 kfree(on);
588}
589
590static int kernfs_fop_open(struct inode *inode, struct file *file)
591{
592 struct kernfs_node *kn = inode->i_private;
593 struct kernfs_root *root = kernfs_root(kn);
594 const struct kernfs_ops *ops;
595 struct kernfs_open_file *of;
596 bool has_read, has_write, has_mmap;
597 int error = -EACCES;
598
599 if (!kernfs_get_active(kn))
600 return -ENODEV;
601
602 ops = kernfs_ops(kn);
603
604 has_read = ops->seq_show || ops->read || ops->mmap;
605 has_write = ops->write || ops->mmap;
606 has_mmap = ops->mmap;
607
608
609 if (root->flags & KERNFS_ROOT_EXTRA_OPEN_PERM_CHECK) {
610 if ((file->f_mode & FMODE_WRITE) &&
611 (!(inode->i_mode & S_IWUGO) || !has_write))
612 goto err_out;
613
614 if ((file->f_mode & FMODE_READ) &&
615 (!(inode->i_mode & S_IRUGO) || !has_read))
616 goto err_out;
617 }
618
619
620 error = -ENOMEM;
621 of = kzalloc(sizeof(struct kernfs_open_file), GFP_KERNEL);
622 if (!of)
623 goto err_out;
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640 if (has_mmap)
641 mutex_init(&of->mutex);
642 else
643 mutex_init(&of->mutex);
644
645 of->kn = kn;
646 of->file = file;
647
648
649
650
651
652 of->atomic_write_len = ops->atomic_write_len;
653
654 error = -EINVAL;
655
656
657
658
659
660 if (ops->prealloc && ops->seq_show)
661 goto err_free;
662 if (ops->prealloc) {
663 int len = of->atomic_write_len ?: PAGE_SIZE;
664 of->prealloc_buf = kmalloc(len + 1, GFP_KERNEL);
665 error = -ENOMEM;
666 if (!of->prealloc_buf)
667 goto err_free;
668 mutex_init(&of->prealloc_mutex);
669 }
670
671
672
673
674
675
676 if (ops->seq_show)
677 error = seq_open(file, &kernfs_seq_ops);
678 else
679 error = seq_open(file, NULL);
680 if (error)
681 goto err_free;
682
683 of->seq_file = file->private_data;
684 of->seq_file->private = of;
685
686
687 if (file->f_mode & FMODE_WRITE)
688 file->f_mode |= FMODE_PWRITE;
689
690
691 error = kernfs_get_open_node(kn, of);
692 if (error)
693 goto err_seq_release;
694
695 if (ops->open) {
696
697 error = ops->open(of);
698 if (error)
699 goto err_put_node;
700 }
701
702
703 kernfs_put_active(kn);
704 return 0;
705
706err_put_node:
707 kernfs_unlink_open_file(kn, of);
708err_seq_release:
709 seq_release(inode, file);
710err_free:
711 kfree(of->prealloc_buf);
712 kfree(of);
713err_out:
714 kernfs_put_active(kn);
715 return error;
716}
717
718
719static void kernfs_release_file(struct kernfs_node *kn,
720 struct kernfs_open_file *of)
721{
722
723
724
725
726
727
728
729 lockdep_assert_held(&kernfs_open_file_mutex);
730
731 if (!of->released) {
732
733
734
735
736
737 kn->attr.ops->release(of);
738 of->released = true;
739 }
740}
741
742static int kernfs_fop_release(struct inode *inode, struct file *filp)
743{
744 struct kernfs_node *kn = inode->i_private;
745 struct kernfs_open_file *of = kernfs_of(filp);
746
747 if (kn->flags & KERNFS_HAS_RELEASE) {
748 mutex_lock(&kernfs_open_file_mutex);
749 kernfs_release_file(kn, of);
750 mutex_unlock(&kernfs_open_file_mutex);
751 }
752
753 kernfs_unlink_open_file(kn, of);
754 seq_release(inode, filp);
755 kfree(of->prealloc_buf);
756 kfree(of);
757
758 return 0;
759}
760
761void kernfs_drain_open_files(struct kernfs_node *kn)
762{
763 struct kernfs_open_node *on;
764 struct kernfs_open_file *of;
765
766 if (!(kn->flags & (KERNFS_HAS_MMAP | KERNFS_HAS_RELEASE)))
767 return;
768
769
770
771
772
773
774
775
776
777 if (!kn->attr.open)
778 return;
779
780 mutex_lock(&kernfs_open_file_mutex);
781 if (!kn->attr.open) {
782 mutex_unlock(&kernfs_open_file_mutex);
783 return;
784 }
785
786 on = kn->attr.open;
787
788 list_for_each_entry(of, &on->files, list) {
789 struct inode *inode = file_inode(of->file);
790
791 if (kn->flags & KERNFS_HAS_MMAP)
792 unmap_mapping_range(inode->i_mapping, 0, 0, 1);
793
794 if (kn->flags & KERNFS_HAS_RELEASE)
795 kernfs_release_file(kn, of);
796 }
797
798 mutex_unlock(&kernfs_open_file_mutex);
799}
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815__poll_t kernfs_generic_poll(struct kernfs_open_file *of, poll_table *wait)
816{
817 struct kernfs_node *kn = kernfs_dentry_node(of->file->f_path.dentry);
818 struct kernfs_open_node *on = kn->attr.open;
819
820 poll_wait(of->file, &on->poll, wait);
821
822 if (of->event != atomic_read(&on->event))
823 return DEFAULT_POLLMASK|EPOLLERR|EPOLLPRI;
824
825 return DEFAULT_POLLMASK;
826}
827
828static __poll_t kernfs_fop_poll(struct file *filp, poll_table *wait)
829{
830 struct kernfs_open_file *of = kernfs_of(filp);
831 struct kernfs_node *kn = kernfs_dentry_node(filp->f_path.dentry);
832 __poll_t ret;
833
834 if (!kernfs_get_active(kn))
835 return DEFAULT_POLLMASK|EPOLLERR|EPOLLPRI;
836
837 if (kn->attr.ops->poll)
838 ret = kn->attr.ops->poll(of, wait);
839 else
840 ret = kernfs_generic_poll(of, wait);
841
842 kernfs_put_active(kn);
843 return ret;
844}
845
846static void kernfs_notify_workfn(struct work_struct *work)
847{
848 struct kernfs_node *kn;
849 struct kernfs_super_info *info;
850 struct kernfs_root *root;
851repeat:
852
853 spin_lock_irq(&kernfs_notify_lock);
854 kn = kernfs_notify_list;
855 if (kn == KERNFS_NOTIFY_EOL) {
856 spin_unlock_irq(&kernfs_notify_lock);
857 return;
858 }
859 kernfs_notify_list = kn->attr.notify_next;
860 kn->attr.notify_next = NULL;
861 spin_unlock_irq(&kernfs_notify_lock);
862
863 root = kernfs_root(kn);
864
865 down_write(&root->kernfs_rwsem);
866
867 list_for_each_entry(info, &kernfs_root(kn)->supers, node) {
868 struct kernfs_node *parent;
869 struct inode *p_inode = NULL;
870 struct inode *inode;
871 struct qstr name;
872
873
874
875
876
877
878
879 inode = ilookup(info->sb, kernfs_ino(kn));
880 if (!inode)
881 continue;
882
883 name = (struct qstr)QSTR_INIT(kn->name, strlen(kn->name));
884 parent = kernfs_get_parent(kn);
885 if (parent) {
886 p_inode = ilookup(info->sb, kernfs_ino(parent));
887 if (p_inode) {
888 fsnotify(FS_MODIFY | FS_EVENT_ON_CHILD,
889 inode, FSNOTIFY_EVENT_INODE,
890 p_inode, &name, inode, 0);
891 iput(p_inode);
892 }
893
894 kernfs_put(parent);
895 }
896
897 if (!p_inode)
898 fsnotify_inode(inode, FS_MODIFY);
899
900 iput(inode);
901 }
902
903 up_write(&root->kernfs_rwsem);
904 kernfs_put(kn);
905 goto repeat;
906}
907
908
909
910
911
912
913
914
915void kernfs_notify(struct kernfs_node *kn)
916{
917 static DECLARE_WORK(kernfs_notify_work, kernfs_notify_workfn);
918 unsigned long flags;
919 struct kernfs_open_node *on;
920
921 if (WARN_ON(kernfs_type(kn) != KERNFS_FILE))
922 return;
923
924
925 spin_lock_irqsave(&kernfs_open_node_lock, flags);
926 on = kn->attr.open;
927 if (on) {
928 atomic_inc(&on->event);
929 wake_up_interruptible(&on->poll);
930 }
931 spin_unlock_irqrestore(&kernfs_open_node_lock, flags);
932
933
934 spin_lock_irqsave(&kernfs_notify_lock, flags);
935 if (!kn->attr.notify_next) {
936 kernfs_get(kn);
937 kn->attr.notify_next = kernfs_notify_list;
938 kernfs_notify_list = kn;
939 schedule_work(&kernfs_notify_work);
940 }
941 spin_unlock_irqrestore(&kernfs_notify_lock, flags);
942}
943EXPORT_SYMBOL_GPL(kernfs_notify);
944
945const struct file_operations kernfs_file_fops = {
946 .read_iter = kernfs_fop_read_iter,
947 .write_iter = kernfs_fop_write_iter,
948 .llseek = generic_file_llseek,
949 .mmap = kernfs_fop_mmap,
950 .open = kernfs_fop_open,
951 .release = kernfs_fop_release,
952 .poll = kernfs_fop_poll,
953 .fsync = noop_fsync,
954 .splice_read = generic_file_splice_read,
955 .splice_write = iter_file_splice_write,
956};
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973struct kernfs_node *__kernfs_create_file(struct kernfs_node *parent,
974 const char *name,
975 umode_t mode, kuid_t uid, kgid_t gid,
976 loff_t size,
977 const struct kernfs_ops *ops,
978 void *priv, const void *ns,
979 struct lock_class_key *key)
980{
981 struct kernfs_node *kn;
982 unsigned flags;
983 int rc;
984
985 flags = KERNFS_FILE;
986
987 kn = kernfs_new_node(parent, name, (mode & S_IALLUGO) | S_IFREG,
988 uid, gid, flags);
989 if (!kn)
990 return ERR_PTR(-ENOMEM);
991
992 kn->attr.ops = ops;
993 kn->attr.size = size;
994 kn->ns = ns;
995 kn->priv = priv;
996
997#ifdef CONFIG_DEBUG_LOCK_ALLOC
998 if (key) {
999 lockdep_init_map(&kn->dep_map, "kn->active", key, 0);
1000 kn->flags |= KERNFS_LOCKDEP;
1001 }
1002#endif
1003
1004
1005
1006
1007
1008
1009 if (ops->seq_show)
1010 kn->flags |= KERNFS_HAS_SEQ_SHOW;
1011 if (ops->mmap)
1012 kn->flags |= KERNFS_HAS_MMAP;
1013 if (ops->release)
1014 kn->flags |= KERNFS_HAS_RELEASE;
1015
1016 rc = kernfs_add_one(kn);
1017 if (rc) {
1018 kernfs_put(kn);
1019 return ERR_PTR(rc);
1020 }
1021 return kn;
1022}
1023