Merge branches 'arm/rockchip', 'arm/exynos', 'arm/smmu', 'x86/vt-d', 'x86/amd', ...
[sfrench/cifs-2.6.git] / fs / kernfs / dir.c
1 /*
2  * fs/kernfs/dir.c - kernfs directory 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/sched.h>
12 #include <linux/fs.h>
13 #include <linux/namei.h>
14 #include <linux/idr.h>
15 #include <linux/slab.h>
16 #include <linux/security.h>
17 #include <linux/hash.h>
18
19 #include "kernfs-internal.h"
20
21 DEFINE_MUTEX(kernfs_mutex);
22 static DEFINE_SPINLOCK(kernfs_rename_lock);     /* kn->parent and ->name */
23 static char kernfs_pr_cont_buf[PATH_MAX];       /* protected by rename_lock */
24
25 #define rb_to_kn(X) rb_entry((X), struct kernfs_node, rb)
26
27 static bool kernfs_active(struct kernfs_node *kn)
28 {
29         lockdep_assert_held(&kernfs_mutex);
30         return atomic_read(&kn->active) >= 0;
31 }
32
33 static bool kernfs_lockdep(struct kernfs_node *kn)
34 {
35 #ifdef CONFIG_DEBUG_LOCK_ALLOC
36         return kn->flags & KERNFS_LOCKDEP;
37 #else
38         return false;
39 #endif
40 }
41
42 static int kernfs_name_locked(struct kernfs_node *kn, char *buf, size_t buflen)
43 {
44         return strlcpy(buf, kn->parent ? kn->name : "/", buflen);
45 }
46
47 static char * __must_check kernfs_path_locked(struct kernfs_node *kn, char *buf,
48                                               size_t buflen)
49 {
50         char *p = buf + buflen;
51         int len;
52
53         *--p = '\0';
54
55         do {
56                 len = strlen(kn->name);
57                 if (p - buf < len + 1) {
58                         buf[0] = '\0';
59                         p = NULL;
60                         break;
61                 }
62                 p -= len;
63                 memcpy(p, kn->name, len);
64                 *--p = '/';
65                 kn = kn->parent;
66         } while (kn && kn->parent);
67
68         return p;
69 }
70
71 /**
72  * kernfs_name - obtain the name of a given node
73  * @kn: kernfs_node of interest
74  * @buf: buffer to copy @kn's name into
75  * @buflen: size of @buf
76  *
77  * Copies the name of @kn into @buf of @buflen bytes.  The behavior is
78  * similar to strlcpy().  It returns the length of @kn's name and if @buf
79  * isn't long enough, it's filled upto @buflen-1 and nul terminated.
80  *
81  * This function can be called from any context.
82  */
83 int kernfs_name(struct kernfs_node *kn, char *buf, size_t buflen)
84 {
85         unsigned long flags;
86         int ret;
87
88         spin_lock_irqsave(&kernfs_rename_lock, flags);
89         ret = kernfs_name_locked(kn, buf, buflen);
90         spin_unlock_irqrestore(&kernfs_rename_lock, flags);
91         return ret;
92 }
93
94 /**
95  * kernfs_path - build full path of a given node
96  * @kn: kernfs_node of interest
97  * @buf: buffer to copy @kn's name into
98  * @buflen: size of @buf
99  *
100  * Builds and returns the full path of @kn in @buf of @buflen bytes.  The
101  * path is built from the end of @buf so the returned pointer usually
102  * doesn't match @buf.  If @buf isn't long enough, @buf is nul terminated
103  * and %NULL is returned.
104  */
105 char *kernfs_path(struct kernfs_node *kn, char *buf, size_t buflen)
106 {
107         unsigned long flags;
108         char *p;
109
110         spin_lock_irqsave(&kernfs_rename_lock, flags);
111         p = kernfs_path_locked(kn, buf, buflen);
112         spin_unlock_irqrestore(&kernfs_rename_lock, flags);
113         return p;
114 }
115 EXPORT_SYMBOL_GPL(kernfs_path);
116
117 /**
118  * pr_cont_kernfs_name - pr_cont name of a kernfs_node
119  * @kn: kernfs_node of interest
120  *
121  * This function can be called from any context.
122  */
123 void pr_cont_kernfs_name(struct kernfs_node *kn)
124 {
125         unsigned long flags;
126
127         spin_lock_irqsave(&kernfs_rename_lock, flags);
128
129         kernfs_name_locked(kn, kernfs_pr_cont_buf, sizeof(kernfs_pr_cont_buf));
130         pr_cont("%s", kernfs_pr_cont_buf);
131
132         spin_unlock_irqrestore(&kernfs_rename_lock, flags);
133 }
134
135 /**
136  * pr_cont_kernfs_path - pr_cont path of a kernfs_node
137  * @kn: kernfs_node of interest
138  *
139  * This function can be called from any context.
140  */
141 void pr_cont_kernfs_path(struct kernfs_node *kn)
142 {
143         unsigned long flags;
144         char *p;
145
146         spin_lock_irqsave(&kernfs_rename_lock, flags);
147
148         p = kernfs_path_locked(kn, kernfs_pr_cont_buf,
149                                sizeof(kernfs_pr_cont_buf));
150         if (p)
151                 pr_cont("%s", p);
152         else
153                 pr_cont("<name too long>");
154
155         spin_unlock_irqrestore(&kernfs_rename_lock, flags);
156 }
157
158 /**
159  * kernfs_get_parent - determine the parent node and pin it
160  * @kn: kernfs_node of interest
161  *
162  * Determines @kn's parent, pins and returns it.  This function can be
163  * called from any context.
164  */
165 struct kernfs_node *kernfs_get_parent(struct kernfs_node *kn)
166 {
167         struct kernfs_node *parent;
168         unsigned long flags;
169
170         spin_lock_irqsave(&kernfs_rename_lock, flags);
171         parent = kn->parent;
172         kernfs_get(parent);
173         spin_unlock_irqrestore(&kernfs_rename_lock, flags);
174
175         return parent;
176 }
177
178 /**
179  *      kernfs_name_hash
180  *      @name: Null terminated string to hash
181  *      @ns:   Namespace tag to hash
182  *
183  *      Returns 31 bit hash of ns + name (so it fits in an off_t )
184  */
185 static unsigned int kernfs_name_hash(const char *name, const void *ns)
186 {
187         unsigned long hash = init_name_hash();
188         unsigned int len = strlen(name);
189         while (len--)
190                 hash = partial_name_hash(*name++, hash);
191         hash = (end_name_hash(hash) ^ hash_ptr((void *)ns, 31));
192         hash &= 0x7fffffffU;
193         /* Reserve hash numbers 0, 1 and INT_MAX for magic directory entries */
194         if (hash < 2)
195                 hash += 2;
196         if (hash >= INT_MAX)
197                 hash = INT_MAX - 1;
198         return hash;
199 }
200
201 static int kernfs_name_compare(unsigned int hash, const char *name,
202                                const void *ns, const struct kernfs_node *kn)
203 {
204         if (hash < kn->hash)
205                 return -1;
206         if (hash > kn->hash)
207                 return 1;
208         if (ns < kn->ns)
209                 return -1;
210         if (ns > kn->ns)
211                 return 1;
212         return strcmp(name, kn->name);
213 }
214
215 static int kernfs_sd_compare(const struct kernfs_node *left,
216                              const struct kernfs_node *right)
217 {
218         return kernfs_name_compare(left->hash, left->name, left->ns, right);
219 }
220
221 /**
222  *      kernfs_link_sibling - link kernfs_node into sibling rbtree
223  *      @kn: kernfs_node of interest
224  *
225  *      Link @kn into its sibling rbtree which starts from
226  *      @kn->parent->dir.children.
227  *
228  *      Locking:
229  *      mutex_lock(kernfs_mutex)
230  *
231  *      RETURNS:
232  *      0 on susccess -EEXIST on failure.
233  */
234 static int kernfs_link_sibling(struct kernfs_node *kn)
235 {
236         struct rb_node **node = &kn->parent->dir.children.rb_node;
237         struct rb_node *parent = NULL;
238
239         while (*node) {
240                 struct kernfs_node *pos;
241                 int result;
242
243                 pos = rb_to_kn(*node);
244                 parent = *node;
245                 result = kernfs_sd_compare(kn, pos);
246                 if (result < 0)
247                         node = &pos->rb.rb_left;
248                 else if (result > 0)
249                         node = &pos->rb.rb_right;
250                 else
251                         return -EEXIST;
252         }
253
254         /* add new node and rebalance the tree */
255         rb_link_node(&kn->rb, parent, node);
256         rb_insert_color(&kn->rb, &kn->parent->dir.children);
257
258         /* successfully added, account subdir number */
259         if (kernfs_type(kn) == KERNFS_DIR)
260                 kn->parent->dir.subdirs++;
261
262         return 0;
263 }
264
265 /**
266  *      kernfs_unlink_sibling - unlink kernfs_node from sibling rbtree
267  *      @kn: kernfs_node of interest
268  *
269  *      Try to unlink @kn from its sibling rbtree which starts from
270  *      kn->parent->dir.children.  Returns %true if @kn was actually
271  *      removed, %false if @kn wasn't on the rbtree.
272  *
273  *      Locking:
274  *      mutex_lock(kernfs_mutex)
275  */
276 static bool kernfs_unlink_sibling(struct kernfs_node *kn)
277 {
278         if (RB_EMPTY_NODE(&kn->rb))
279                 return false;
280
281         if (kernfs_type(kn) == KERNFS_DIR)
282                 kn->parent->dir.subdirs--;
283
284         rb_erase(&kn->rb, &kn->parent->dir.children);
285         RB_CLEAR_NODE(&kn->rb);
286         return true;
287 }
288
289 /**
290  *      kernfs_get_active - get an active reference to kernfs_node
291  *      @kn: kernfs_node to get an active reference to
292  *
293  *      Get an active reference of @kn.  This function is noop if @kn
294  *      is NULL.
295  *
296  *      RETURNS:
297  *      Pointer to @kn on success, NULL on failure.
298  */
299 struct kernfs_node *kernfs_get_active(struct kernfs_node *kn)
300 {
301         if (unlikely(!kn))
302                 return NULL;
303
304         if (!atomic_inc_unless_negative(&kn->active))
305                 return NULL;
306
307         if (kernfs_lockdep(kn))
308                 rwsem_acquire_read(&kn->dep_map, 0, 1, _RET_IP_);
309         return kn;
310 }
311
312 /**
313  *      kernfs_put_active - put an active reference to kernfs_node
314  *      @kn: kernfs_node to put an active reference to
315  *
316  *      Put an active reference to @kn.  This function is noop if @kn
317  *      is NULL.
318  */
319 void kernfs_put_active(struct kernfs_node *kn)
320 {
321         struct kernfs_root *root = kernfs_root(kn);
322         int v;
323
324         if (unlikely(!kn))
325                 return;
326
327         if (kernfs_lockdep(kn))
328                 rwsem_release(&kn->dep_map, 1, _RET_IP_);
329         v = atomic_dec_return(&kn->active);
330         if (likely(v != KN_DEACTIVATED_BIAS))
331                 return;
332
333         wake_up_all(&root->deactivate_waitq);
334 }
335
336 /**
337  * kernfs_drain - drain kernfs_node
338  * @kn: kernfs_node to drain
339  *
340  * Drain existing usages and nuke all existing mmaps of @kn.  Mutiple
341  * removers may invoke this function concurrently on @kn and all will
342  * return after draining is complete.
343  */
344 static void kernfs_drain(struct kernfs_node *kn)
345         __releases(&kernfs_mutex) __acquires(&kernfs_mutex)
346 {
347         struct kernfs_root *root = kernfs_root(kn);
348
349         lockdep_assert_held(&kernfs_mutex);
350         WARN_ON_ONCE(kernfs_active(kn));
351
352         mutex_unlock(&kernfs_mutex);
353
354         if (kernfs_lockdep(kn)) {
355                 rwsem_acquire(&kn->dep_map, 0, 0, _RET_IP_);
356                 if (atomic_read(&kn->active) != KN_DEACTIVATED_BIAS)
357                         lock_contended(&kn->dep_map, _RET_IP_);
358         }
359
360         /* but everyone should wait for draining */
361         wait_event(root->deactivate_waitq,
362                    atomic_read(&kn->active) == KN_DEACTIVATED_BIAS);
363
364         if (kernfs_lockdep(kn)) {
365                 lock_acquired(&kn->dep_map, _RET_IP_);
366                 rwsem_release(&kn->dep_map, 1, _RET_IP_);
367         }
368
369         kernfs_unmap_bin_file(kn);
370
371         mutex_lock(&kernfs_mutex);
372 }
373
374 /**
375  * kernfs_get - get a reference count on a kernfs_node
376  * @kn: the target kernfs_node
377  */
378 void kernfs_get(struct kernfs_node *kn)
379 {
380         if (kn) {
381                 WARN_ON(!atomic_read(&kn->count));
382                 atomic_inc(&kn->count);
383         }
384 }
385 EXPORT_SYMBOL_GPL(kernfs_get);
386
387 /**
388  * kernfs_put - put a reference count on a kernfs_node
389  * @kn: the target kernfs_node
390  *
391  * Put a reference count of @kn and destroy it if it reached zero.
392  */
393 void kernfs_put(struct kernfs_node *kn)
394 {
395         struct kernfs_node *parent;
396         struct kernfs_root *root;
397
398         if (!kn || !atomic_dec_and_test(&kn->count))
399                 return;
400         root = kernfs_root(kn);
401  repeat:
402         /*
403          * Moving/renaming is always done while holding reference.
404          * kn->parent won't change beneath us.
405          */
406         parent = kn->parent;
407
408         WARN_ONCE(atomic_read(&kn->active) != KN_DEACTIVATED_BIAS,
409                   "kernfs_put: %s/%s: released with incorrect active_ref %d\n",
410                   parent ? parent->name : "", kn->name, atomic_read(&kn->active));
411
412         if (kernfs_type(kn) == KERNFS_LINK)
413                 kernfs_put(kn->symlink.target_kn);
414
415         kfree_const(kn->name);
416
417         if (kn->iattr) {
418                 if (kn->iattr->ia_secdata)
419                         security_release_secctx(kn->iattr->ia_secdata,
420                                                 kn->iattr->ia_secdata_len);
421                 simple_xattrs_free(&kn->iattr->xattrs);
422         }
423         kfree(kn->iattr);
424         ida_simple_remove(&root->ino_ida, kn->ino);
425         kmem_cache_free(kernfs_node_cache, kn);
426
427         kn = parent;
428         if (kn) {
429                 if (atomic_dec_and_test(&kn->count))
430                         goto repeat;
431         } else {
432                 /* just released the root kn, free @root too */
433                 ida_destroy(&root->ino_ida);
434                 kfree(root);
435         }
436 }
437 EXPORT_SYMBOL_GPL(kernfs_put);
438
439 static int kernfs_dop_revalidate(struct dentry *dentry, unsigned int flags)
440 {
441         struct kernfs_node *kn;
442
443         if (flags & LOOKUP_RCU)
444                 return -ECHILD;
445
446         /* Always perform fresh lookup for negatives */
447         if (d_really_is_negative(dentry))
448                 goto out_bad_unlocked;
449
450         kn = dentry->d_fsdata;
451         mutex_lock(&kernfs_mutex);
452
453         /* The kernfs node has been deactivated */
454         if (!kernfs_active(kn))
455                 goto out_bad;
456
457         /* The kernfs node has been moved? */
458         if (dentry->d_parent->d_fsdata != kn->parent)
459                 goto out_bad;
460
461         /* The kernfs node has been renamed */
462         if (strcmp(dentry->d_name.name, kn->name) != 0)
463                 goto out_bad;
464
465         /* The kernfs node has been moved to a different namespace */
466         if (kn->parent && kernfs_ns_enabled(kn->parent) &&
467             kernfs_info(dentry->d_sb)->ns != kn->ns)
468                 goto out_bad;
469
470         mutex_unlock(&kernfs_mutex);
471         return 1;
472 out_bad:
473         mutex_unlock(&kernfs_mutex);
474 out_bad_unlocked:
475         return 0;
476 }
477
478 static void kernfs_dop_release(struct dentry *dentry)
479 {
480         kernfs_put(dentry->d_fsdata);
481 }
482
483 const struct dentry_operations kernfs_dops = {
484         .d_revalidate   = kernfs_dop_revalidate,
485         .d_release      = kernfs_dop_release,
486 };
487
488 /**
489  * kernfs_node_from_dentry - determine kernfs_node associated with a dentry
490  * @dentry: the dentry in question
491  *
492  * Return the kernfs_node associated with @dentry.  If @dentry is not a
493  * kernfs one, %NULL is returned.
494  *
495  * While the returned kernfs_node will stay accessible as long as @dentry
496  * is accessible, the returned node can be in any state and the caller is
497  * fully responsible for determining what's accessible.
498  */
499 struct kernfs_node *kernfs_node_from_dentry(struct dentry *dentry)
500 {
501         if (dentry->d_sb->s_op == &kernfs_sops)
502                 return dentry->d_fsdata;
503         return NULL;
504 }
505
506 static struct kernfs_node *__kernfs_new_node(struct kernfs_root *root,
507                                              const char *name, umode_t mode,
508                                              unsigned flags)
509 {
510         struct kernfs_node *kn;
511         int ret;
512
513         name = kstrdup_const(name, GFP_KERNEL);
514         if (!name)
515                 return NULL;
516
517         kn = kmem_cache_zalloc(kernfs_node_cache, GFP_KERNEL);
518         if (!kn)
519                 goto err_out1;
520
521         /*
522          * If the ino of the sysfs entry created for a kmem cache gets
523          * allocated from an ida layer, which is accounted to the memcg that
524          * owns the cache, the memcg will get pinned forever. So do not account
525          * ino ida allocations.
526          */
527         ret = ida_simple_get(&root->ino_ida, 1, 0,
528                              GFP_KERNEL | __GFP_NOACCOUNT);
529         if (ret < 0)
530                 goto err_out2;
531         kn->ino = ret;
532
533         atomic_set(&kn->count, 1);
534         atomic_set(&kn->active, KN_DEACTIVATED_BIAS);
535         RB_CLEAR_NODE(&kn->rb);
536
537         kn->name = name;
538         kn->mode = mode;
539         kn->flags = flags;
540
541         return kn;
542
543  err_out2:
544         kmem_cache_free(kernfs_node_cache, kn);
545  err_out1:
546         kfree_const(name);
547         return NULL;
548 }
549
550 struct kernfs_node *kernfs_new_node(struct kernfs_node *parent,
551                                     const char *name, umode_t mode,
552                                     unsigned flags)
553 {
554         struct kernfs_node *kn;
555
556         kn = __kernfs_new_node(kernfs_root(parent), name, mode, flags);
557         if (kn) {
558                 kernfs_get(parent);
559                 kn->parent = parent;
560         }
561         return kn;
562 }
563
564 /**
565  *      kernfs_add_one - add kernfs_node to parent without warning
566  *      @kn: kernfs_node to be added
567  *
568  *      The caller must already have initialized @kn->parent.  This
569  *      function increments nlink of the parent's inode if @kn is a
570  *      directory and link into the children list of the parent.
571  *
572  *      RETURNS:
573  *      0 on success, -EEXIST if entry with the given name already
574  *      exists.
575  */
576 int kernfs_add_one(struct kernfs_node *kn)
577 {
578         struct kernfs_node *parent = kn->parent;
579         struct kernfs_iattrs *ps_iattr;
580         bool has_ns;
581         int ret;
582
583         mutex_lock(&kernfs_mutex);
584
585         ret = -EINVAL;
586         has_ns = kernfs_ns_enabled(parent);
587         if (WARN(has_ns != (bool)kn->ns, KERN_WARNING "kernfs: ns %s in '%s' for '%s'\n",
588                  has_ns ? "required" : "invalid", parent->name, kn->name))
589                 goto out_unlock;
590
591         if (kernfs_type(parent) != KERNFS_DIR)
592                 goto out_unlock;
593
594         ret = -ENOENT;
595         if ((parent->flags & KERNFS_ACTIVATED) && !kernfs_active(parent))
596                 goto out_unlock;
597
598         kn->hash = kernfs_name_hash(kn->name, kn->ns);
599
600         ret = kernfs_link_sibling(kn);
601         if (ret)
602                 goto out_unlock;
603
604         /* Update timestamps on the parent */
605         ps_iattr = parent->iattr;
606         if (ps_iattr) {
607                 struct iattr *ps_iattrs = &ps_iattr->ia_iattr;
608                 ps_iattrs->ia_ctime = ps_iattrs->ia_mtime = CURRENT_TIME;
609         }
610
611         mutex_unlock(&kernfs_mutex);
612
613         /*
614          * Activate the new node unless CREATE_DEACTIVATED is requested.
615          * If not activated here, the kernfs user is responsible for
616          * activating the node with kernfs_activate().  A node which hasn't
617          * been activated is not visible to userland and its removal won't
618          * trigger deactivation.
619          */
620         if (!(kernfs_root(kn)->flags & KERNFS_ROOT_CREATE_DEACTIVATED))
621                 kernfs_activate(kn);
622         return 0;
623
624 out_unlock:
625         mutex_unlock(&kernfs_mutex);
626         return ret;
627 }
628
629 /**
630  * kernfs_find_ns - find kernfs_node with the given name
631  * @parent: kernfs_node to search under
632  * @name: name to look for
633  * @ns: the namespace tag to use
634  *
635  * Look for kernfs_node with name @name under @parent.  Returns pointer to
636  * the found kernfs_node on success, %NULL on failure.
637  */
638 static struct kernfs_node *kernfs_find_ns(struct kernfs_node *parent,
639                                           const unsigned char *name,
640                                           const void *ns)
641 {
642         struct rb_node *node = parent->dir.children.rb_node;
643         bool has_ns = kernfs_ns_enabled(parent);
644         unsigned int hash;
645
646         lockdep_assert_held(&kernfs_mutex);
647
648         if (has_ns != (bool)ns) {
649                 WARN(1, KERN_WARNING "kernfs: ns %s in '%s' for '%s'\n",
650                      has_ns ? "required" : "invalid", parent->name, name);
651                 return NULL;
652         }
653
654         hash = kernfs_name_hash(name, ns);
655         while (node) {
656                 struct kernfs_node *kn;
657                 int result;
658
659                 kn = rb_to_kn(node);
660                 result = kernfs_name_compare(hash, name, ns, kn);
661                 if (result < 0)
662                         node = node->rb_left;
663                 else if (result > 0)
664                         node = node->rb_right;
665                 else
666                         return kn;
667         }
668         return NULL;
669 }
670
671 /**
672  * kernfs_find_and_get_ns - find and get kernfs_node with the given name
673  * @parent: kernfs_node to search under
674  * @name: name to look for
675  * @ns: the namespace tag to use
676  *
677  * Look for kernfs_node with name @name under @parent and get a reference
678  * if found.  This function may sleep and returns pointer to the found
679  * kernfs_node on success, %NULL on failure.
680  */
681 struct kernfs_node *kernfs_find_and_get_ns(struct kernfs_node *parent,
682                                            const char *name, const void *ns)
683 {
684         struct kernfs_node *kn;
685
686         mutex_lock(&kernfs_mutex);
687         kn = kernfs_find_ns(parent, name, ns);
688         kernfs_get(kn);
689         mutex_unlock(&kernfs_mutex);
690
691         return kn;
692 }
693 EXPORT_SYMBOL_GPL(kernfs_find_and_get_ns);
694
695 /**
696  * kernfs_create_root - create a new kernfs hierarchy
697  * @scops: optional syscall operations for the hierarchy
698  * @flags: KERNFS_ROOT_* flags
699  * @priv: opaque data associated with the new directory
700  *
701  * Returns the root of the new hierarchy on success, ERR_PTR() value on
702  * failure.
703  */
704 struct kernfs_root *kernfs_create_root(struct kernfs_syscall_ops *scops,
705                                        unsigned int flags, void *priv)
706 {
707         struct kernfs_root *root;
708         struct kernfs_node *kn;
709
710         root = kzalloc(sizeof(*root), GFP_KERNEL);
711         if (!root)
712                 return ERR_PTR(-ENOMEM);
713
714         ida_init(&root->ino_ida);
715         INIT_LIST_HEAD(&root->supers);
716
717         kn = __kernfs_new_node(root, "", S_IFDIR | S_IRUGO | S_IXUGO,
718                                KERNFS_DIR);
719         if (!kn) {
720                 ida_destroy(&root->ino_ida);
721                 kfree(root);
722                 return ERR_PTR(-ENOMEM);
723         }
724
725         kn->priv = priv;
726         kn->dir.root = root;
727
728         root->syscall_ops = scops;
729         root->flags = flags;
730         root->kn = kn;
731         init_waitqueue_head(&root->deactivate_waitq);
732
733         if (!(root->flags & KERNFS_ROOT_CREATE_DEACTIVATED))
734                 kernfs_activate(kn);
735
736         return root;
737 }
738
739 /**
740  * kernfs_destroy_root - destroy a kernfs hierarchy
741  * @root: root of the hierarchy to destroy
742  *
743  * Destroy the hierarchy anchored at @root by removing all existing
744  * directories and destroying @root.
745  */
746 void kernfs_destroy_root(struct kernfs_root *root)
747 {
748         kernfs_remove(root->kn);        /* will also free @root */
749 }
750
751 /**
752  * kernfs_create_dir_ns - create a directory
753  * @parent: parent in which to create a new directory
754  * @name: name of the new directory
755  * @mode: mode of the new directory
756  * @priv: opaque data associated with the new directory
757  * @ns: optional namespace tag of the directory
758  *
759  * Returns the created node on success, ERR_PTR() value on failure.
760  */
761 struct kernfs_node *kernfs_create_dir_ns(struct kernfs_node *parent,
762                                          const char *name, umode_t mode,
763                                          void *priv, const void *ns)
764 {
765         struct kernfs_node *kn;
766         int rc;
767
768         /* allocate */
769         kn = kernfs_new_node(parent, name, mode | S_IFDIR, KERNFS_DIR);
770         if (!kn)
771                 return ERR_PTR(-ENOMEM);
772
773         kn->dir.root = parent->dir.root;
774         kn->ns = ns;
775         kn->priv = priv;
776
777         /* link in */
778         rc = kernfs_add_one(kn);
779         if (!rc)
780                 return kn;
781
782         kernfs_put(kn);
783         return ERR_PTR(rc);
784 }
785
786 static struct dentry *kernfs_iop_lookup(struct inode *dir,
787                                         struct dentry *dentry,
788                                         unsigned int flags)
789 {
790         struct dentry *ret;
791         struct kernfs_node *parent = dentry->d_parent->d_fsdata;
792         struct kernfs_node *kn;
793         struct inode *inode;
794         const void *ns = NULL;
795
796         mutex_lock(&kernfs_mutex);
797
798         if (kernfs_ns_enabled(parent))
799                 ns = kernfs_info(dir->i_sb)->ns;
800
801         kn = kernfs_find_ns(parent, dentry->d_name.name, ns);
802
803         /* no such entry */
804         if (!kn || !kernfs_active(kn)) {
805                 ret = NULL;
806                 goto out_unlock;
807         }
808         kernfs_get(kn);
809         dentry->d_fsdata = kn;
810
811         /* attach dentry and inode */
812         inode = kernfs_get_inode(dir->i_sb, kn);
813         if (!inode) {
814                 ret = ERR_PTR(-ENOMEM);
815                 goto out_unlock;
816         }
817
818         /* instantiate and hash dentry */
819         ret = d_splice_alias(inode, dentry);
820  out_unlock:
821         mutex_unlock(&kernfs_mutex);
822         return ret;
823 }
824
825 static int kernfs_iop_mkdir(struct inode *dir, struct dentry *dentry,
826                             umode_t mode)
827 {
828         struct kernfs_node *parent = dir->i_private;
829         struct kernfs_syscall_ops *scops = kernfs_root(parent)->syscall_ops;
830         int ret;
831
832         if (!scops || !scops->mkdir)
833                 return -EPERM;
834
835         if (!kernfs_get_active(parent))
836                 return -ENODEV;
837
838         ret = scops->mkdir(parent, dentry->d_name.name, mode);
839
840         kernfs_put_active(parent);
841         return ret;
842 }
843
844 static int kernfs_iop_rmdir(struct inode *dir, struct dentry *dentry)
845 {
846         struct kernfs_node *kn  = dentry->d_fsdata;
847         struct kernfs_syscall_ops *scops = kernfs_root(kn)->syscall_ops;
848         int ret;
849
850         if (!scops || !scops->rmdir)
851                 return -EPERM;
852
853         if (!kernfs_get_active(kn))
854                 return -ENODEV;
855
856         ret = scops->rmdir(kn);
857
858         kernfs_put_active(kn);
859         return ret;
860 }
861
862 static int kernfs_iop_rename(struct inode *old_dir, struct dentry *old_dentry,
863                              struct inode *new_dir, struct dentry *new_dentry)
864 {
865         struct kernfs_node *kn  = old_dentry->d_fsdata;
866         struct kernfs_node *new_parent = new_dir->i_private;
867         struct kernfs_syscall_ops *scops = kernfs_root(kn)->syscall_ops;
868         int ret;
869
870         if (!scops || !scops->rename)
871                 return -EPERM;
872
873         if (!kernfs_get_active(kn))
874                 return -ENODEV;
875
876         if (!kernfs_get_active(new_parent)) {
877                 kernfs_put_active(kn);
878                 return -ENODEV;
879         }
880
881         ret = scops->rename(kn, new_parent, new_dentry->d_name.name);
882
883         kernfs_put_active(new_parent);
884         kernfs_put_active(kn);
885         return ret;
886 }
887
888 const struct inode_operations kernfs_dir_iops = {
889         .lookup         = kernfs_iop_lookup,
890         .permission     = kernfs_iop_permission,
891         .setattr        = kernfs_iop_setattr,
892         .getattr        = kernfs_iop_getattr,
893         .setxattr       = kernfs_iop_setxattr,
894         .removexattr    = kernfs_iop_removexattr,
895         .getxattr       = kernfs_iop_getxattr,
896         .listxattr      = kernfs_iop_listxattr,
897
898         .mkdir          = kernfs_iop_mkdir,
899         .rmdir          = kernfs_iop_rmdir,
900         .rename         = kernfs_iop_rename,
901 };
902
903 static struct kernfs_node *kernfs_leftmost_descendant(struct kernfs_node *pos)
904 {
905         struct kernfs_node *last;
906
907         while (true) {
908                 struct rb_node *rbn;
909
910                 last = pos;
911
912                 if (kernfs_type(pos) != KERNFS_DIR)
913                         break;
914
915                 rbn = rb_first(&pos->dir.children);
916                 if (!rbn)
917                         break;
918
919                 pos = rb_to_kn(rbn);
920         }
921
922         return last;
923 }
924
925 /**
926  * kernfs_next_descendant_post - find the next descendant for post-order walk
927  * @pos: the current position (%NULL to initiate traversal)
928  * @root: kernfs_node whose descendants to walk
929  *
930  * Find the next descendant to visit for post-order traversal of @root's
931  * descendants.  @root is included in the iteration and the last node to be
932  * visited.
933  */
934 static struct kernfs_node *kernfs_next_descendant_post(struct kernfs_node *pos,
935                                                        struct kernfs_node *root)
936 {
937         struct rb_node *rbn;
938
939         lockdep_assert_held(&kernfs_mutex);
940
941         /* if first iteration, visit leftmost descendant which may be root */
942         if (!pos)
943                 return kernfs_leftmost_descendant(root);
944
945         /* if we visited @root, we're done */
946         if (pos == root)
947                 return NULL;
948
949         /* if there's an unvisited sibling, visit its leftmost descendant */
950         rbn = rb_next(&pos->rb);
951         if (rbn)
952                 return kernfs_leftmost_descendant(rb_to_kn(rbn));
953
954         /* no sibling left, visit parent */
955         return pos->parent;
956 }
957
958 /**
959  * kernfs_activate - activate a node which started deactivated
960  * @kn: kernfs_node whose subtree is to be activated
961  *
962  * If the root has KERNFS_ROOT_CREATE_DEACTIVATED set, a newly created node
963  * needs to be explicitly activated.  A node which hasn't been activated
964  * isn't visible to userland and deactivation is skipped during its
965  * removal.  This is useful to construct atomic init sequences where
966  * creation of multiple nodes should either succeed or fail atomically.
967  *
968  * The caller is responsible for ensuring that this function is not called
969  * after kernfs_remove*() is invoked on @kn.
970  */
971 void kernfs_activate(struct kernfs_node *kn)
972 {
973         struct kernfs_node *pos;
974
975         mutex_lock(&kernfs_mutex);
976
977         pos = NULL;
978         while ((pos = kernfs_next_descendant_post(pos, kn))) {
979                 if (!pos || (pos->flags & KERNFS_ACTIVATED))
980                         continue;
981
982                 WARN_ON_ONCE(pos->parent && RB_EMPTY_NODE(&pos->rb));
983                 WARN_ON_ONCE(atomic_read(&pos->active) != KN_DEACTIVATED_BIAS);
984
985                 atomic_sub(KN_DEACTIVATED_BIAS, &pos->active);
986                 pos->flags |= KERNFS_ACTIVATED;
987         }
988
989         mutex_unlock(&kernfs_mutex);
990 }
991
992 static void __kernfs_remove(struct kernfs_node *kn)
993 {
994         struct kernfs_node *pos;
995
996         lockdep_assert_held(&kernfs_mutex);
997
998         /*
999          * Short-circuit if non-root @kn has already finished removal.
1000          * This is for kernfs_remove_self() which plays with active ref
1001          * after removal.
1002          */
1003         if (!kn || (kn->parent && RB_EMPTY_NODE(&kn->rb)))
1004                 return;
1005
1006         pr_debug("kernfs %s: removing\n", kn->name);
1007
1008         /* prevent any new usage under @kn by deactivating all nodes */
1009         pos = NULL;
1010         while ((pos = kernfs_next_descendant_post(pos, kn)))
1011                 if (kernfs_active(pos))
1012                         atomic_add(KN_DEACTIVATED_BIAS, &pos->active);
1013
1014         /* deactivate and unlink the subtree node-by-node */
1015         do {
1016                 pos = kernfs_leftmost_descendant(kn);
1017
1018                 /*
1019                  * kernfs_drain() drops kernfs_mutex temporarily and @pos's
1020                  * base ref could have been put by someone else by the time
1021                  * the function returns.  Make sure it doesn't go away
1022                  * underneath us.
1023                  */
1024                 kernfs_get(pos);
1025
1026                 /*
1027                  * Drain iff @kn was activated.  This avoids draining and
1028                  * its lockdep annotations for nodes which have never been
1029                  * activated and allows embedding kernfs_remove() in create
1030                  * error paths without worrying about draining.
1031                  */
1032                 if (kn->flags & KERNFS_ACTIVATED)
1033                         kernfs_drain(pos);
1034                 else
1035                         WARN_ON_ONCE(atomic_read(&kn->active) != KN_DEACTIVATED_BIAS);
1036
1037                 /*
1038                  * kernfs_unlink_sibling() succeeds once per node.  Use it
1039                  * to decide who's responsible for cleanups.
1040                  */
1041                 if (!pos->parent || kernfs_unlink_sibling(pos)) {
1042                         struct kernfs_iattrs *ps_iattr =
1043                                 pos->parent ? pos->parent->iattr : NULL;
1044
1045                         /* update timestamps on the parent */
1046                         if (ps_iattr) {
1047                                 ps_iattr->ia_iattr.ia_ctime = CURRENT_TIME;
1048                                 ps_iattr->ia_iattr.ia_mtime = CURRENT_TIME;
1049                         }
1050
1051                         kernfs_put(pos);
1052                 }
1053
1054                 kernfs_put(pos);
1055         } while (pos != kn);
1056 }
1057
1058 /**
1059  * kernfs_remove - remove a kernfs_node recursively
1060  * @kn: the kernfs_node to remove
1061  *
1062  * Remove @kn along with all its subdirectories and files.
1063  */
1064 void kernfs_remove(struct kernfs_node *kn)
1065 {
1066         mutex_lock(&kernfs_mutex);
1067         __kernfs_remove(kn);
1068         mutex_unlock(&kernfs_mutex);
1069 }
1070
1071 /**
1072  * kernfs_break_active_protection - break out of active protection
1073  * @kn: the self kernfs_node
1074  *
1075  * The caller must be running off of a kernfs operation which is invoked
1076  * with an active reference - e.g. one of kernfs_ops.  Each invocation of
1077  * this function must also be matched with an invocation of
1078  * kernfs_unbreak_active_protection().
1079  *
1080  * This function releases the active reference of @kn the caller is
1081  * holding.  Once this function is called, @kn may be removed at any point
1082  * and the caller is solely responsible for ensuring that the objects it
1083  * dereferences are accessible.
1084  */
1085 void kernfs_break_active_protection(struct kernfs_node *kn)
1086 {
1087         /*
1088          * Take out ourself out of the active ref dependency chain.  If
1089          * we're called without an active ref, lockdep will complain.
1090          */
1091         kernfs_put_active(kn);
1092 }
1093
1094 /**
1095  * kernfs_unbreak_active_protection - undo kernfs_break_active_protection()
1096  * @kn: the self kernfs_node
1097  *
1098  * If kernfs_break_active_protection() was called, this function must be
1099  * invoked before finishing the kernfs operation.  Note that while this
1100  * function restores the active reference, it doesn't and can't actually
1101  * restore the active protection - @kn may already or be in the process of
1102  * being removed.  Once kernfs_break_active_protection() is invoked, that
1103  * protection is irreversibly gone for the kernfs operation instance.
1104  *
1105  * While this function may be called at any point after
1106  * kernfs_break_active_protection() is invoked, its most useful location
1107  * would be right before the enclosing kernfs operation returns.
1108  */
1109 void kernfs_unbreak_active_protection(struct kernfs_node *kn)
1110 {
1111         /*
1112          * @kn->active could be in any state; however, the increment we do
1113          * here will be undone as soon as the enclosing kernfs operation
1114          * finishes and this temporary bump can't break anything.  If @kn
1115          * is alive, nothing changes.  If @kn is being deactivated, the
1116          * soon-to-follow put will either finish deactivation or restore
1117          * deactivated state.  If @kn is already removed, the temporary
1118          * bump is guaranteed to be gone before @kn is released.
1119          */
1120         atomic_inc(&kn->active);
1121         if (kernfs_lockdep(kn))
1122                 rwsem_acquire(&kn->dep_map, 0, 1, _RET_IP_);
1123 }
1124
1125 /**
1126  * kernfs_remove_self - remove a kernfs_node from its own method
1127  * @kn: the self kernfs_node to remove
1128  *
1129  * The caller must be running off of a kernfs operation which is invoked
1130  * with an active reference - e.g. one of kernfs_ops.  This can be used to
1131  * implement a file operation which deletes itself.
1132  *
1133  * For example, the "delete" file for a sysfs device directory can be
1134  * implemented by invoking kernfs_remove_self() on the "delete" file
1135  * itself.  This function breaks the circular dependency of trying to
1136  * deactivate self while holding an active ref itself.  It isn't necessary
1137  * to modify the usual removal path to use kernfs_remove_self().  The
1138  * "delete" implementation can simply invoke kernfs_remove_self() on self
1139  * before proceeding with the usual removal path.  kernfs will ignore later
1140  * kernfs_remove() on self.
1141  *
1142  * kernfs_remove_self() can be called multiple times concurrently on the
1143  * same kernfs_node.  Only the first one actually performs removal and
1144  * returns %true.  All others will wait until the kernfs operation which
1145  * won self-removal finishes and return %false.  Note that the losers wait
1146  * for the completion of not only the winning kernfs_remove_self() but also
1147  * the whole kernfs_ops which won the arbitration.  This can be used to
1148  * guarantee, for example, all concurrent writes to a "delete" file to
1149  * finish only after the whole operation is complete.
1150  */
1151 bool kernfs_remove_self(struct kernfs_node *kn)
1152 {
1153         bool ret;
1154
1155         mutex_lock(&kernfs_mutex);
1156         kernfs_break_active_protection(kn);
1157
1158         /*
1159          * SUICIDAL is used to arbitrate among competing invocations.  Only
1160          * the first one will actually perform removal.  When the removal
1161          * is complete, SUICIDED is set and the active ref is restored
1162          * while holding kernfs_mutex.  The ones which lost arbitration
1163          * waits for SUICDED && drained which can happen only after the
1164          * enclosing kernfs operation which executed the winning instance
1165          * of kernfs_remove_self() finished.
1166          */
1167         if (!(kn->flags & KERNFS_SUICIDAL)) {
1168                 kn->flags |= KERNFS_SUICIDAL;
1169                 __kernfs_remove(kn);
1170                 kn->flags |= KERNFS_SUICIDED;
1171                 ret = true;
1172         } else {
1173                 wait_queue_head_t *waitq = &kernfs_root(kn)->deactivate_waitq;
1174                 DEFINE_WAIT(wait);
1175
1176                 while (true) {
1177                         prepare_to_wait(waitq, &wait, TASK_UNINTERRUPTIBLE);
1178
1179                         if ((kn->flags & KERNFS_SUICIDED) &&
1180                             atomic_read(&kn->active) == KN_DEACTIVATED_BIAS)
1181                                 break;
1182
1183                         mutex_unlock(&kernfs_mutex);
1184                         schedule();
1185                         mutex_lock(&kernfs_mutex);
1186                 }
1187                 finish_wait(waitq, &wait);
1188                 WARN_ON_ONCE(!RB_EMPTY_NODE(&kn->rb));
1189                 ret = false;
1190         }
1191
1192         /*
1193          * This must be done while holding kernfs_mutex; otherwise, waiting
1194          * for SUICIDED && deactivated could finish prematurely.
1195          */
1196         kernfs_unbreak_active_protection(kn);
1197
1198         mutex_unlock(&kernfs_mutex);
1199         return ret;
1200 }
1201
1202 /**
1203  * kernfs_remove_by_name_ns - find a kernfs_node by name and remove it
1204  * @parent: parent of the target
1205  * @name: name of the kernfs_node to remove
1206  * @ns: namespace tag of the kernfs_node to remove
1207  *
1208  * Look for the kernfs_node with @name and @ns under @parent and remove it.
1209  * Returns 0 on success, -ENOENT if such entry doesn't exist.
1210  */
1211 int kernfs_remove_by_name_ns(struct kernfs_node *parent, const char *name,
1212                              const void *ns)
1213 {
1214         struct kernfs_node *kn;
1215
1216         if (!parent) {
1217                 WARN(1, KERN_WARNING "kernfs: can not remove '%s', no directory\n",
1218                         name);
1219                 return -ENOENT;
1220         }
1221
1222         mutex_lock(&kernfs_mutex);
1223
1224         kn = kernfs_find_ns(parent, name, ns);
1225         if (kn)
1226                 __kernfs_remove(kn);
1227
1228         mutex_unlock(&kernfs_mutex);
1229
1230         if (kn)
1231                 return 0;
1232         else
1233                 return -ENOENT;
1234 }
1235
1236 /**
1237  * kernfs_rename_ns - move and rename a kernfs_node
1238  * @kn: target node
1239  * @new_parent: new parent to put @sd under
1240  * @new_name: new name
1241  * @new_ns: new namespace tag
1242  */
1243 int kernfs_rename_ns(struct kernfs_node *kn, struct kernfs_node *new_parent,
1244                      const char *new_name, const void *new_ns)
1245 {
1246         struct kernfs_node *old_parent;
1247         const char *old_name = NULL;
1248         int error;
1249
1250         /* can't move or rename root */
1251         if (!kn->parent)
1252                 return -EINVAL;
1253
1254         mutex_lock(&kernfs_mutex);
1255
1256         error = -ENOENT;
1257         if (!kernfs_active(kn) || !kernfs_active(new_parent))
1258                 goto out;
1259
1260         error = 0;
1261         if ((kn->parent == new_parent) && (kn->ns == new_ns) &&
1262             (strcmp(kn->name, new_name) == 0))
1263                 goto out;       /* nothing to rename */
1264
1265         error = -EEXIST;
1266         if (kernfs_find_ns(new_parent, new_name, new_ns))
1267                 goto out;
1268
1269         /* rename kernfs_node */
1270         if (strcmp(kn->name, new_name) != 0) {
1271                 error = -ENOMEM;
1272                 new_name = kstrdup_const(new_name, GFP_KERNEL);
1273                 if (!new_name)
1274                         goto out;
1275         } else {
1276                 new_name = NULL;
1277         }
1278
1279         /*
1280          * Move to the appropriate place in the appropriate directories rbtree.
1281          */
1282         kernfs_unlink_sibling(kn);
1283         kernfs_get(new_parent);
1284
1285         /* rename_lock protects ->parent and ->name accessors */
1286         spin_lock_irq(&kernfs_rename_lock);
1287
1288         old_parent = kn->parent;
1289         kn->parent = new_parent;
1290
1291         kn->ns = new_ns;
1292         if (new_name) {
1293                 old_name = kn->name;
1294                 kn->name = new_name;
1295         }
1296
1297         spin_unlock_irq(&kernfs_rename_lock);
1298
1299         kn->hash = kernfs_name_hash(kn->name, kn->ns);
1300         kernfs_link_sibling(kn);
1301
1302         kernfs_put(old_parent);
1303         kfree_const(old_name);
1304
1305         error = 0;
1306  out:
1307         mutex_unlock(&kernfs_mutex);
1308         return error;
1309 }
1310
1311 /* Relationship between s_mode and the DT_xxx types */
1312 static inline unsigned char dt_type(struct kernfs_node *kn)
1313 {
1314         return (kn->mode >> 12) & 15;
1315 }
1316
1317 static int kernfs_dir_fop_release(struct inode *inode, struct file *filp)
1318 {
1319         kernfs_put(filp->private_data);
1320         return 0;
1321 }
1322
1323 static struct kernfs_node *kernfs_dir_pos(const void *ns,
1324         struct kernfs_node *parent, loff_t hash, struct kernfs_node *pos)
1325 {
1326         if (pos) {
1327                 int valid = kernfs_active(pos) &&
1328                         pos->parent == parent && hash == pos->hash;
1329                 kernfs_put(pos);
1330                 if (!valid)
1331                         pos = NULL;
1332         }
1333         if (!pos && (hash > 1) && (hash < INT_MAX)) {
1334                 struct rb_node *node = parent->dir.children.rb_node;
1335                 while (node) {
1336                         pos = rb_to_kn(node);
1337
1338                         if (hash < pos->hash)
1339                                 node = node->rb_left;
1340                         else if (hash > pos->hash)
1341                                 node = node->rb_right;
1342                         else
1343                                 break;
1344                 }
1345         }
1346         /* Skip over entries which are dying/dead or in the wrong namespace */
1347         while (pos && (!kernfs_active(pos) || pos->ns != ns)) {
1348                 struct rb_node *node = rb_next(&pos->rb);
1349                 if (!node)
1350                         pos = NULL;
1351                 else
1352                         pos = rb_to_kn(node);
1353         }
1354         return pos;
1355 }
1356
1357 static struct kernfs_node *kernfs_dir_next_pos(const void *ns,
1358         struct kernfs_node *parent, ino_t ino, struct kernfs_node *pos)
1359 {
1360         pos = kernfs_dir_pos(ns, parent, ino, pos);
1361         if (pos) {
1362                 do {
1363                         struct rb_node *node = rb_next(&pos->rb);
1364                         if (!node)
1365                                 pos = NULL;
1366                         else
1367                                 pos = rb_to_kn(node);
1368                 } while (pos && (!kernfs_active(pos) || pos->ns != ns));
1369         }
1370         return pos;
1371 }
1372
1373 static int kernfs_fop_readdir(struct file *file, struct dir_context *ctx)
1374 {
1375         struct dentry *dentry = file->f_path.dentry;
1376         struct kernfs_node *parent = dentry->d_fsdata;
1377         struct kernfs_node *pos = file->private_data;
1378         const void *ns = NULL;
1379
1380         if (!dir_emit_dots(file, ctx))
1381                 return 0;
1382         mutex_lock(&kernfs_mutex);
1383
1384         if (kernfs_ns_enabled(parent))
1385                 ns = kernfs_info(dentry->d_sb)->ns;
1386
1387         for (pos = kernfs_dir_pos(ns, parent, ctx->pos, pos);
1388              pos;
1389              pos = kernfs_dir_next_pos(ns, parent, ctx->pos, pos)) {
1390                 const char *name = pos->name;
1391                 unsigned int type = dt_type(pos);
1392                 int len = strlen(name);
1393                 ino_t ino = pos->ino;
1394
1395                 ctx->pos = pos->hash;
1396                 file->private_data = pos;
1397                 kernfs_get(pos);
1398
1399                 mutex_unlock(&kernfs_mutex);
1400                 if (!dir_emit(ctx, name, len, ino, type))
1401                         return 0;
1402                 mutex_lock(&kernfs_mutex);
1403         }
1404         mutex_unlock(&kernfs_mutex);
1405         file->private_data = NULL;
1406         ctx->pos = INT_MAX;
1407         return 0;
1408 }
1409
1410 static loff_t kernfs_dir_fop_llseek(struct file *file, loff_t offset,
1411                                     int whence)
1412 {
1413         struct inode *inode = file_inode(file);
1414         loff_t ret;
1415
1416         mutex_lock(&inode->i_mutex);
1417         ret = generic_file_llseek(file, offset, whence);
1418         mutex_unlock(&inode->i_mutex);
1419
1420         return ret;
1421 }
1422
1423 const struct file_operations kernfs_dir_fops = {
1424         .read           = generic_read_dir,
1425         .iterate        = kernfs_fop_readdir,
1426         .release        = kernfs_dir_fop_release,
1427         .llseek         = kernfs_dir_fop_llseek,
1428 };