sysfs: Update the name hash when renaming sysfs entries
[linux-3.10.git] / fs / sysfs / dir.c
1 /*
2  * fs/sysfs/dir.c - sysfs core and dir operation implementation
3  *
4  * Copyright (c) 2001-3 Patrick Mochel
5  * Copyright (c) 2007 SUSE Linux Products GmbH
6  * Copyright (c) 2007 Tejun Heo <teheo@suse.de>
7  *
8  * This file is released under the GPLv2.
9  *
10  * Please see Documentation/filesystems/sysfs.txt for more information.
11  */
12
13 #undef DEBUG
14
15 #include <linux/fs.h>
16 #include <linux/mount.h>
17 #include <linux/module.h>
18 #include <linux/kobject.h>
19 #include <linux/namei.h>
20 #include <linux/idr.h>
21 #include <linux/completion.h>
22 #include <linux/mutex.h>
23 #include <linux/slab.h>
24 #include <linux/security.h>
25 #include <linux/hash.h>
26 #include "sysfs.h"
27
28 DEFINE_MUTEX(sysfs_mutex);
29 DEFINE_SPINLOCK(sysfs_assoc_lock);
30
31 #define to_sysfs_dirent(X) rb_entry((X), struct sysfs_dirent, s_rb);
32
33 static DEFINE_SPINLOCK(sysfs_ino_lock);
34 static DEFINE_IDA(sysfs_ino_ida);
35
36 /**
37  *      sysfs_name_hash
38  *      @ns:   Namespace tag to hash
39  *      @name: Null terminated string to hash
40  *
41  *      Returns 31 bit hash of ns + name (so it fits in an off_t )
42  */
43 static unsigned int sysfs_name_hash(const void *ns, const char *name)
44 {
45         unsigned long hash = init_name_hash();
46         unsigned int len = strlen(name);
47         while (len--)
48                 hash = partial_name_hash(*name++, hash);
49         hash = ( end_name_hash(hash) ^ hash_ptr( (void *)ns, 31 ) );
50         hash &= 0x7fffffffU;
51         /* Reserve hash numbers 0, 1 and INT_MAX for magic directory entries */
52         if (hash < 1)
53                 hash += 2;
54         if (hash >= INT_MAX)
55                 hash = INT_MAX - 1;
56         return hash;
57 }
58
59 static int sysfs_name_compare(unsigned int hash, const void *ns,
60         const char *name, const struct sysfs_dirent *sd)
61 {
62         if (hash != sd->s_hash)
63                 return hash - sd->s_hash;
64         if (ns != sd->s_ns)
65                 return ns - sd->s_ns;
66         return strcmp(name, sd->s_name);
67 }
68
69 static int sysfs_sd_compare(const struct sysfs_dirent *left,
70                             const struct sysfs_dirent *right)
71 {
72         return sysfs_name_compare(left->s_hash, left->s_ns, left->s_name,
73                                   right);
74 }
75
76 /**
77  *      sysfs_link_subling - link sysfs_dirent into sibling rbtree
78  *      @sd: sysfs_dirent of interest
79  *
80  *      Link @sd into its sibling rbtree which starts from
81  *      sd->s_parent->s_dir.children.
82  *
83  *      Locking:
84  *      mutex_lock(sysfs_mutex)
85  *
86  *      RETURNS:
87  *      0 on susccess -EEXIST on failure.
88  */
89 static int sysfs_link_sibling(struct sysfs_dirent *sd)
90 {
91         struct rb_node **node = &sd->s_parent->s_dir.children.rb_node;
92         struct rb_node *parent = NULL;
93
94         while (*node) {
95                 struct sysfs_dirent *pos;
96                 int result;
97
98                 pos = to_sysfs_dirent(*node);
99                 parent = *node;
100                 result = sysfs_sd_compare(sd, pos);
101                 if (result < 0)
102                         node = &pos->s_rb.rb_left;
103                 else if (result > 0)
104                         node = &pos->s_rb.rb_right;
105                 else
106                         return -EEXIST;
107         }
108         /* add new node and rebalance the tree */
109         rb_link_node(&sd->s_rb, parent, node);
110         rb_insert_color(&sd->s_rb, &sd->s_parent->s_dir.children);
111         return 0;
112 }
113
114 /**
115  *      sysfs_unlink_sibling - unlink sysfs_dirent from sibling rbtree
116  *      @sd: sysfs_dirent of interest
117  *
118  *      Unlink @sd from its sibling rbtree which starts from
119  *      sd->s_parent->s_dir.children.
120  *
121  *      Locking:
122  *      mutex_lock(sysfs_mutex)
123  */
124 static void sysfs_unlink_sibling(struct sysfs_dirent *sd)
125 {
126         rb_erase(&sd->s_rb, &sd->s_parent->s_dir.children);
127 }
128
129 /**
130  *      sysfs_get_active - get an active reference to sysfs_dirent
131  *      @sd: sysfs_dirent to get an active reference to
132  *
133  *      Get an active reference of @sd.  This function is noop if @sd
134  *      is NULL.
135  *
136  *      RETURNS:
137  *      Pointer to @sd on success, NULL on failure.
138  */
139 struct sysfs_dirent *sysfs_get_active(struct sysfs_dirent *sd)
140 {
141         if (unlikely(!sd))
142                 return NULL;
143
144         while (1) {
145                 int v, t;
146
147                 v = atomic_read(&sd->s_active);
148                 if (unlikely(v < 0))
149                         return NULL;
150
151                 t = atomic_cmpxchg(&sd->s_active, v, v + 1);
152                 if (likely(t == v)) {
153                         rwsem_acquire_read(&sd->dep_map, 0, 1, _RET_IP_);
154                         return sd;
155                 }
156                 if (t < 0)
157                         return NULL;
158
159                 cpu_relax();
160         }
161 }
162
163 /**
164  *      sysfs_put_active - put an active reference to sysfs_dirent
165  *      @sd: sysfs_dirent to put an active reference to
166  *
167  *      Put an active reference to @sd.  This function is noop if @sd
168  *      is NULL.
169  */
170 void sysfs_put_active(struct sysfs_dirent *sd)
171 {
172         int v;
173
174         if (unlikely(!sd))
175                 return;
176
177         rwsem_release(&sd->dep_map, 1, _RET_IP_);
178         v = atomic_dec_return(&sd->s_active);
179         if (likely(v != SD_DEACTIVATED_BIAS))
180                 return;
181
182         /* atomic_dec_return() is a mb(), we'll always see the updated
183          * sd->u.completion.
184          */
185         complete(sd->u.completion);
186 }
187
188 /**
189  *      sysfs_deactivate - deactivate sysfs_dirent
190  *      @sd: sysfs_dirent to deactivate
191  *
192  *      Deny new active references and drain existing ones.
193  */
194 static void sysfs_deactivate(struct sysfs_dirent *sd)
195 {
196         DECLARE_COMPLETION_ONSTACK(wait);
197         int v;
198
199         BUG_ON(!(sd->s_flags & SYSFS_FLAG_REMOVED));
200
201         if (!(sysfs_type(sd) & SYSFS_ACTIVE_REF))
202                 return;
203
204         sd->u.completion = (void *)&wait;
205
206         rwsem_acquire(&sd->dep_map, 0, 0, _RET_IP_);
207         /* atomic_add_return() is a mb(), put_active() will always see
208          * the updated sd->u.completion.
209          */
210         v = atomic_add_return(SD_DEACTIVATED_BIAS, &sd->s_active);
211
212         if (v != SD_DEACTIVATED_BIAS) {
213                 lock_contended(&sd->dep_map, _RET_IP_);
214                 wait_for_completion(&wait);
215         }
216
217         lock_acquired(&sd->dep_map, _RET_IP_);
218         rwsem_release(&sd->dep_map, 1, _RET_IP_);
219 }
220
221 static int sysfs_alloc_ino(unsigned int *pino)
222 {
223         int ino, rc;
224
225  retry:
226         spin_lock(&sysfs_ino_lock);
227         rc = ida_get_new_above(&sysfs_ino_ida, 2, &ino);
228         spin_unlock(&sysfs_ino_lock);
229
230         if (rc == -EAGAIN) {
231                 if (ida_pre_get(&sysfs_ino_ida, GFP_KERNEL))
232                         goto retry;
233                 rc = -ENOMEM;
234         }
235
236         *pino = ino;
237         return rc;
238 }
239
240 static void sysfs_free_ino(unsigned int ino)
241 {
242         spin_lock(&sysfs_ino_lock);
243         ida_remove(&sysfs_ino_ida, ino);
244         spin_unlock(&sysfs_ino_lock);
245 }
246
247 void release_sysfs_dirent(struct sysfs_dirent * sd)
248 {
249         struct sysfs_dirent *parent_sd;
250
251  repeat:
252         /* Moving/renaming is always done while holding reference.
253          * sd->s_parent won't change beneath us.
254          */
255         parent_sd = sd->s_parent;
256
257         if (sysfs_type(sd) == SYSFS_KOBJ_LINK)
258                 sysfs_put(sd->s_symlink.target_sd);
259         if (sysfs_type(sd) & SYSFS_COPY_NAME)
260                 kfree(sd->s_name);
261         if (sd->s_iattr && sd->s_iattr->ia_secdata)
262                 security_release_secctx(sd->s_iattr->ia_secdata,
263                                         sd->s_iattr->ia_secdata_len);
264         kfree(sd->s_iattr);
265         sysfs_free_ino(sd->s_ino);
266         kmem_cache_free(sysfs_dir_cachep, sd);
267
268         sd = parent_sd;
269         if (sd && atomic_dec_and_test(&sd->s_count))
270                 goto repeat;
271 }
272
273 static int sysfs_dentry_delete(const struct dentry *dentry)
274 {
275         struct sysfs_dirent *sd = dentry->d_fsdata;
276         return !!(sd->s_flags & SYSFS_FLAG_REMOVED);
277 }
278
279 static int sysfs_dentry_revalidate(struct dentry *dentry, struct nameidata *nd)
280 {
281         struct sysfs_dirent *sd;
282         int is_dir;
283
284         if (nd->flags & LOOKUP_RCU)
285                 return -ECHILD;
286
287         sd = dentry->d_fsdata;
288         mutex_lock(&sysfs_mutex);
289
290         /* The sysfs dirent has been deleted */
291         if (sd->s_flags & SYSFS_FLAG_REMOVED)
292                 goto out_bad;
293
294         /* The sysfs dirent has been moved? */
295         if (dentry->d_parent->d_fsdata != sd->s_parent)
296                 goto out_bad;
297
298         /* The sysfs dirent has been renamed */
299         if (strcmp(dentry->d_name.name, sd->s_name) != 0)
300                 goto out_bad;
301
302         mutex_unlock(&sysfs_mutex);
303 out_valid:
304         return 1;
305 out_bad:
306         /* Remove the dentry from the dcache hashes.
307          * If this is a deleted dentry we use d_drop instead of d_delete
308          * so sysfs doesn't need to cope with negative dentries.
309          *
310          * If this is a dentry that has simply been renamed we
311          * use d_drop to remove it from the dcache lookup on its
312          * old parent.  If this dentry persists later when a lookup
313          * is performed at its new name the dentry will be readded
314          * to the dcache hashes.
315          */
316         is_dir = (sysfs_type(sd) == SYSFS_DIR);
317         mutex_unlock(&sysfs_mutex);
318         if (is_dir) {
319                 /* If we have submounts we must allow the vfs caches
320                  * to lie about the state of the filesystem to prevent
321                  * leaks and other nasty things.
322                  */
323                 if (have_submounts(dentry))
324                         goto out_valid;
325                 shrink_dcache_parent(dentry);
326         }
327         d_drop(dentry);
328         return 0;
329 }
330
331 static void sysfs_dentry_iput(struct dentry *dentry, struct inode *inode)
332 {
333         struct sysfs_dirent * sd = dentry->d_fsdata;
334
335         sysfs_put(sd);
336         iput(inode);
337 }
338
339 static const struct dentry_operations sysfs_dentry_ops = {
340         .d_revalidate   = sysfs_dentry_revalidate,
341         .d_delete       = sysfs_dentry_delete,
342         .d_iput         = sysfs_dentry_iput,
343 };
344
345 struct sysfs_dirent *sysfs_new_dirent(const char *name, umode_t mode, int type)
346 {
347         char *dup_name = NULL;
348         struct sysfs_dirent *sd;
349
350         if (type & SYSFS_COPY_NAME) {
351                 name = dup_name = kstrdup(name, GFP_KERNEL);
352                 if (!name)
353                         return NULL;
354         }
355
356         sd = kmem_cache_zalloc(sysfs_dir_cachep, GFP_KERNEL);
357         if (!sd)
358                 goto err_out1;
359
360         if (sysfs_alloc_ino(&sd->s_ino))
361                 goto err_out2;
362
363         atomic_set(&sd->s_count, 1);
364         atomic_set(&sd->s_active, 0);
365
366         sd->s_name = name;
367         sd->s_mode = mode;
368         sd->s_flags = type;
369
370         return sd;
371
372  err_out2:
373         kmem_cache_free(sysfs_dir_cachep, sd);
374  err_out1:
375         kfree(dup_name);
376         return NULL;
377 }
378
379 /**
380  *      sysfs_addrm_start - prepare for sysfs_dirent add/remove
381  *      @acxt: pointer to sysfs_addrm_cxt to be used
382  *      @parent_sd: parent sysfs_dirent
383  *
384  *      This function is called when the caller is about to add or
385  *      remove sysfs_dirent under @parent_sd.  This function acquires
386  *      sysfs_mutex.  @acxt is used to keep and pass context to
387  *      other addrm functions.
388  *
389  *      LOCKING:
390  *      Kernel thread context (may sleep).  sysfs_mutex is locked on
391  *      return.
392  */
393 void sysfs_addrm_start(struct sysfs_addrm_cxt *acxt,
394                        struct sysfs_dirent *parent_sd)
395 {
396         memset(acxt, 0, sizeof(*acxt));
397         acxt->parent_sd = parent_sd;
398
399         mutex_lock(&sysfs_mutex);
400 }
401
402 /**
403  *      __sysfs_add_one - add sysfs_dirent to parent without warning
404  *      @acxt: addrm context to use
405  *      @sd: sysfs_dirent to be added
406  *
407  *      Get @acxt->parent_sd and set sd->s_parent to it and increment
408  *      nlink of parent inode if @sd is a directory and link into the
409  *      children list of the parent.
410  *
411  *      This function should be called between calls to
412  *      sysfs_addrm_start() and sysfs_addrm_finish() and should be
413  *      passed the same @acxt as passed to sysfs_addrm_start().
414  *
415  *      LOCKING:
416  *      Determined by sysfs_addrm_start().
417  *
418  *      RETURNS:
419  *      0 on success, -EEXIST if entry with the given name already
420  *      exists.
421  */
422 int __sysfs_add_one(struct sysfs_addrm_cxt *acxt, struct sysfs_dirent *sd)
423 {
424         struct sysfs_inode_attrs *ps_iattr;
425         int ret;
426
427         if (!!sysfs_ns_type(acxt->parent_sd) != !!sd->s_ns) {
428                 WARN(1, KERN_WARNING "sysfs: ns %s in '%s' for '%s'\n",
429                         sysfs_ns_type(acxt->parent_sd)? "required": "invalid",
430                         acxt->parent_sd->s_name, sd->s_name);
431                 return -EINVAL;
432         }
433
434         sd->s_hash = sysfs_name_hash(sd->s_ns, sd->s_name);
435         sd->s_parent = sysfs_get(acxt->parent_sd);
436
437         ret = sysfs_link_sibling(sd);
438         if (ret)
439                 return ret;
440
441         /* Update timestamps on the parent */
442         ps_iattr = acxt->parent_sd->s_iattr;
443         if (ps_iattr) {
444                 struct iattr *ps_iattrs = &ps_iattr->ia_iattr;
445                 ps_iattrs->ia_ctime = ps_iattrs->ia_mtime = CURRENT_TIME;
446         }
447
448         return 0;
449 }
450
451 /**
452  *      sysfs_pathname - return full path to sysfs dirent
453  *      @sd: sysfs_dirent whose path we want
454  *      @path: caller allocated buffer
455  *
456  *      Gives the name "/" to the sysfs_root entry; any path returned
457  *      is relative to wherever sysfs is mounted.
458  *
459  *      XXX: does no error checking on @path size
460  */
461 static char *sysfs_pathname(struct sysfs_dirent *sd, char *path)
462 {
463         if (sd->s_parent) {
464                 sysfs_pathname(sd->s_parent, path);
465                 strcat(path, "/");
466         }
467         strcat(path, sd->s_name);
468         return path;
469 }
470
471 /**
472  *      sysfs_add_one - add sysfs_dirent to parent
473  *      @acxt: addrm context to use
474  *      @sd: sysfs_dirent to be added
475  *
476  *      Get @acxt->parent_sd and set sd->s_parent to it and increment
477  *      nlink of parent inode if @sd is a directory and link into the
478  *      children list of the parent.
479  *
480  *      This function should be called between calls to
481  *      sysfs_addrm_start() and sysfs_addrm_finish() and should be
482  *      passed the same @acxt as passed to sysfs_addrm_start().
483  *
484  *      LOCKING:
485  *      Determined by sysfs_addrm_start().
486  *
487  *      RETURNS:
488  *      0 on success, -EEXIST if entry with the given name already
489  *      exists.
490  */
491 int sysfs_add_one(struct sysfs_addrm_cxt *acxt, struct sysfs_dirent *sd)
492 {
493         int ret;
494
495         ret = __sysfs_add_one(acxt, sd);
496         if (ret == -EEXIST) {
497                 char *path = kzalloc(PATH_MAX, GFP_KERNEL);
498                 WARN(1, KERN_WARNING
499                      "sysfs: cannot create duplicate filename '%s'\n",
500                      (path == NULL) ? sd->s_name :
501                      strcat(strcat(sysfs_pathname(acxt->parent_sd, path), "/"),
502                             sd->s_name));
503                 kfree(path);
504         }
505
506         return ret;
507 }
508
509 /**
510  *      sysfs_remove_one - remove sysfs_dirent from parent
511  *      @acxt: addrm context to use
512  *      @sd: sysfs_dirent to be removed
513  *
514  *      Mark @sd removed and drop nlink of parent inode if @sd is a
515  *      directory.  @sd is unlinked from the children list.
516  *
517  *      This function should be called between calls to
518  *      sysfs_addrm_start() and sysfs_addrm_finish() and should be
519  *      passed the same @acxt as passed to sysfs_addrm_start().
520  *
521  *      LOCKING:
522  *      Determined by sysfs_addrm_start().
523  */
524 void sysfs_remove_one(struct sysfs_addrm_cxt *acxt, struct sysfs_dirent *sd)
525 {
526         struct sysfs_inode_attrs *ps_iattr;
527
528         BUG_ON(sd->s_flags & SYSFS_FLAG_REMOVED);
529
530         sysfs_unlink_sibling(sd);
531
532         /* Update timestamps on the parent */
533         ps_iattr = acxt->parent_sd->s_iattr;
534         if (ps_iattr) {
535                 struct iattr *ps_iattrs = &ps_iattr->ia_iattr;
536                 ps_iattrs->ia_ctime = ps_iattrs->ia_mtime = CURRENT_TIME;
537         }
538
539         sd->s_flags |= SYSFS_FLAG_REMOVED;
540         sd->u.removed_list = acxt->removed;
541         acxt->removed = sd;
542 }
543
544 /**
545  *      sysfs_addrm_finish - finish up sysfs_dirent add/remove
546  *      @acxt: addrm context to finish up
547  *
548  *      Finish up sysfs_dirent add/remove.  Resources acquired by
549  *      sysfs_addrm_start() are released and removed sysfs_dirents are
550  *      cleaned up.
551  *
552  *      LOCKING:
553  *      sysfs_mutex is released.
554  */
555 void sysfs_addrm_finish(struct sysfs_addrm_cxt *acxt)
556 {
557         /* release resources acquired by sysfs_addrm_start() */
558         mutex_unlock(&sysfs_mutex);
559
560         /* kill removed sysfs_dirents */
561         while (acxt->removed) {
562                 struct sysfs_dirent *sd = acxt->removed;
563
564                 acxt->removed = sd->u.removed_list;
565
566                 sysfs_deactivate(sd);
567                 unmap_bin_file(sd);
568                 sysfs_put(sd);
569         }
570 }
571
572 /**
573  *      sysfs_find_dirent - find sysfs_dirent with the given name
574  *      @parent_sd: sysfs_dirent to search under
575  *      @name: name to look for
576  *
577  *      Look for sysfs_dirent with name @name under @parent_sd.
578  *
579  *      LOCKING:
580  *      mutex_lock(sysfs_mutex)
581  *
582  *      RETURNS:
583  *      Pointer to sysfs_dirent if found, NULL if not.
584  */
585 struct sysfs_dirent *sysfs_find_dirent(struct sysfs_dirent *parent_sd,
586                                        const void *ns,
587                                        const unsigned char *name)
588 {
589         struct rb_node *node = parent_sd->s_dir.children.rb_node;
590         unsigned int hash;
591
592         if (!!sysfs_ns_type(parent_sd) != !!ns) {
593                 WARN(1, KERN_WARNING "sysfs: ns %s in '%s' for '%s'\n",
594                         sysfs_ns_type(parent_sd)? "required": "invalid",
595                         parent_sd->s_name, name);
596                 return NULL;
597         }
598
599         hash = sysfs_name_hash(ns, name);
600         while (node) {
601                 struct sysfs_dirent *sd;
602                 int result;
603
604                 sd = to_sysfs_dirent(node);
605                 result = sysfs_name_compare(hash, ns, name, sd);
606                 if (result < 0)
607                         node = node->rb_left;
608                 else if (result > 0)
609                         node = node->rb_right;
610                 else
611                         return sd;
612         }
613         return NULL;
614 }
615
616 /**
617  *      sysfs_get_dirent - find and get sysfs_dirent with the given name
618  *      @parent_sd: sysfs_dirent to search under
619  *      @name: name to look for
620  *
621  *      Look for sysfs_dirent with name @name under @parent_sd and get
622  *      it if found.
623  *
624  *      LOCKING:
625  *      Kernel thread context (may sleep).  Grabs sysfs_mutex.
626  *
627  *      RETURNS:
628  *      Pointer to sysfs_dirent if found, NULL if not.
629  */
630 struct sysfs_dirent *sysfs_get_dirent(struct sysfs_dirent *parent_sd,
631                                       const void *ns,
632                                       const unsigned char *name)
633 {
634         struct sysfs_dirent *sd;
635
636         mutex_lock(&sysfs_mutex);
637         sd = sysfs_find_dirent(parent_sd, ns, name);
638         sysfs_get(sd);
639         mutex_unlock(&sysfs_mutex);
640
641         return sd;
642 }
643 EXPORT_SYMBOL_GPL(sysfs_get_dirent);
644
645 static int create_dir(struct kobject *kobj, struct sysfs_dirent *parent_sd,
646         enum kobj_ns_type type, const void *ns, const char *name,
647         struct sysfs_dirent **p_sd)
648 {
649         umode_t mode = S_IFDIR| S_IRWXU | S_IRUGO | S_IXUGO;
650         struct sysfs_addrm_cxt acxt;
651         struct sysfs_dirent *sd;
652         int rc;
653
654         /* allocate */
655         sd = sysfs_new_dirent(name, mode, SYSFS_DIR);
656         if (!sd)
657                 return -ENOMEM;
658
659         sd->s_flags |= (type << SYSFS_NS_TYPE_SHIFT);
660         sd->s_ns = ns;
661         sd->s_dir.kobj = kobj;
662
663         /* link in */
664         sysfs_addrm_start(&acxt, parent_sd);
665         rc = sysfs_add_one(&acxt, sd);
666         sysfs_addrm_finish(&acxt);
667
668         if (rc == 0)
669                 *p_sd = sd;
670         else
671                 sysfs_put(sd);
672
673         return rc;
674 }
675
676 int sysfs_create_subdir(struct kobject *kobj, const char *name,
677                         struct sysfs_dirent **p_sd)
678 {
679         return create_dir(kobj, kobj->sd,
680                           KOBJ_NS_TYPE_NONE, NULL, name, p_sd);
681 }
682
683 /**
684  *      sysfs_read_ns_type: return associated ns_type
685  *      @kobj: the kobject being queried
686  *
687  *      Each kobject can be tagged with exactly one namespace type
688  *      (i.e. network or user).  Return the ns_type associated with
689  *      this object if any
690  */
691 static enum kobj_ns_type sysfs_read_ns_type(struct kobject *kobj)
692 {
693         const struct kobj_ns_type_operations *ops;
694         enum kobj_ns_type type;
695
696         ops = kobj_child_ns_ops(kobj);
697         if (!ops)
698                 return KOBJ_NS_TYPE_NONE;
699
700         type = ops->type;
701         BUG_ON(type <= KOBJ_NS_TYPE_NONE);
702         BUG_ON(type >= KOBJ_NS_TYPES);
703         BUG_ON(!kobj_ns_type_registered(type));
704
705         return type;
706 }
707
708 /**
709  *      sysfs_create_dir - create a directory for an object.
710  *      @kobj:          object we're creating directory for. 
711  */
712 int sysfs_create_dir(struct kobject * kobj)
713 {
714         enum kobj_ns_type type;
715         struct sysfs_dirent *parent_sd, *sd;
716         const void *ns = NULL;
717         int error = 0;
718
719         BUG_ON(!kobj);
720
721         if (kobj->parent)
722                 parent_sd = kobj->parent->sd;
723         else
724                 parent_sd = &sysfs_root;
725
726         if (sysfs_ns_type(parent_sd))
727                 ns = kobj->ktype->namespace(kobj);
728         type = sysfs_read_ns_type(kobj);
729
730         error = create_dir(kobj, parent_sd, type, ns, kobject_name(kobj), &sd);
731         if (!error)
732                 kobj->sd = sd;
733         return error;
734 }
735
736 static struct dentry * sysfs_lookup(struct inode *dir, struct dentry *dentry,
737                                 struct nameidata *nd)
738 {
739         struct dentry *ret = NULL;
740         struct dentry *parent = dentry->d_parent;
741         struct sysfs_dirent *parent_sd = parent->d_fsdata;
742         struct sysfs_dirent *sd;
743         struct inode *inode;
744         enum kobj_ns_type type;
745         const void *ns;
746
747         mutex_lock(&sysfs_mutex);
748
749         type = sysfs_ns_type(parent_sd);
750         ns = sysfs_info(dir->i_sb)->ns[type];
751
752         sd = sysfs_find_dirent(parent_sd, ns, dentry->d_name.name);
753
754         /* no such entry */
755         if (!sd) {
756                 ret = ERR_PTR(-ENOENT);
757                 goto out_unlock;
758         }
759
760         /* attach dentry and inode */
761         inode = sysfs_get_inode(dir->i_sb, sd);
762         if (!inode) {
763                 ret = ERR_PTR(-ENOMEM);
764                 goto out_unlock;
765         }
766
767         /* instantiate and hash dentry */
768         ret = d_find_alias(inode);
769         if (!ret) {
770                 d_set_d_op(dentry, &sysfs_dentry_ops);
771                 dentry->d_fsdata = sysfs_get(sd);
772                 d_add(dentry, inode);
773         } else {
774                 d_move(ret, dentry);
775                 iput(inode);
776         }
777
778  out_unlock:
779         mutex_unlock(&sysfs_mutex);
780         return ret;
781 }
782
783 const struct inode_operations sysfs_dir_inode_operations = {
784         .lookup         = sysfs_lookup,
785         .permission     = sysfs_permission,
786         .setattr        = sysfs_setattr,
787         .getattr        = sysfs_getattr,
788         .setxattr       = sysfs_setxattr,
789 };
790
791 static void remove_dir(struct sysfs_dirent *sd)
792 {
793         struct sysfs_addrm_cxt acxt;
794
795         sysfs_addrm_start(&acxt, sd->s_parent);
796         sysfs_remove_one(&acxt, sd);
797         sysfs_addrm_finish(&acxt);
798 }
799
800 void sysfs_remove_subdir(struct sysfs_dirent *sd)
801 {
802         remove_dir(sd);
803 }
804
805
806 static void __sysfs_remove_dir(struct sysfs_dirent *dir_sd)
807 {
808         struct sysfs_addrm_cxt acxt;
809         struct rb_node *pos;
810
811         if (!dir_sd)
812                 return;
813
814         pr_debug("sysfs %s: removing dir\n", dir_sd->s_name);
815         sysfs_addrm_start(&acxt, dir_sd);
816         pos = rb_first(&dir_sd->s_dir.children);
817         while (pos) {
818                 struct sysfs_dirent *sd = to_sysfs_dirent(pos);
819                 pos = rb_next(pos);
820                 if (sysfs_type(sd) != SYSFS_DIR)
821                         sysfs_remove_one(&acxt, sd);
822         }
823         sysfs_addrm_finish(&acxt);
824
825         remove_dir(dir_sd);
826 }
827
828 /**
829  *      sysfs_remove_dir - remove an object's directory.
830  *      @kobj:  object.
831  *
832  *      The only thing special about this is that we remove any files in
833  *      the directory before we remove the directory, and we've inlined
834  *      what used to be sysfs_rmdir() below, instead of calling separately.
835  */
836
837 void sysfs_remove_dir(struct kobject * kobj)
838 {
839         struct sysfs_dirent *sd = kobj->sd;
840
841         spin_lock(&sysfs_assoc_lock);
842         kobj->sd = NULL;
843         spin_unlock(&sysfs_assoc_lock);
844
845         __sysfs_remove_dir(sd);
846 }
847
848 int sysfs_rename(struct sysfs_dirent *sd,
849         struct sysfs_dirent *new_parent_sd, const void *new_ns,
850         const char *new_name)
851 {
852         const char *dup_name = NULL;
853         int error;
854
855         mutex_lock(&sysfs_mutex);
856
857         error = 0;
858         if ((sd->s_parent == new_parent_sd) && (sd->s_ns == new_ns) &&
859             (strcmp(sd->s_name, new_name) == 0))
860                 goto out;       /* nothing to rename */
861
862         error = -EEXIST;
863         if (sysfs_find_dirent(new_parent_sd, new_ns, new_name))
864                 goto out;
865
866         /* rename sysfs_dirent */
867         if (strcmp(sd->s_name, new_name) != 0) {
868                 error = -ENOMEM;
869                 new_name = dup_name = kstrdup(new_name, GFP_KERNEL);
870                 if (!new_name)
871                         goto out;
872
873                 dup_name = sd->s_name;
874                 sd->s_name = new_name;
875                 sd->s_hash = sysfs_name_hash(sd->s_ns, sd->s_name);
876         }
877
878         /* Move to the appropriate place in the appropriate directories rbtree. */
879         sysfs_unlink_sibling(sd);
880         sysfs_get(new_parent_sd);
881         sysfs_put(sd->s_parent);
882         sd->s_ns = new_ns;
883         sd->s_parent = new_parent_sd;
884         sysfs_link_sibling(sd);
885
886         error = 0;
887  out:
888         mutex_unlock(&sysfs_mutex);
889         kfree(dup_name);
890         return error;
891 }
892
893 int sysfs_rename_dir(struct kobject *kobj, const char *new_name)
894 {
895         struct sysfs_dirent *parent_sd = kobj->sd->s_parent;
896         const void *new_ns = NULL;
897
898         if (sysfs_ns_type(parent_sd))
899                 new_ns = kobj->ktype->namespace(kobj);
900
901         return sysfs_rename(kobj->sd, parent_sd, new_ns, new_name);
902 }
903
904 int sysfs_move_dir(struct kobject *kobj, struct kobject *new_parent_kobj)
905 {
906         struct sysfs_dirent *sd = kobj->sd;
907         struct sysfs_dirent *new_parent_sd;
908         const void *new_ns = NULL;
909
910         BUG_ON(!sd->s_parent);
911         if (sysfs_ns_type(sd->s_parent))
912                 new_ns = kobj->ktype->namespace(kobj);
913         new_parent_sd = new_parent_kobj && new_parent_kobj->sd ?
914                 new_parent_kobj->sd : &sysfs_root;
915
916         return sysfs_rename(sd, new_parent_sd, new_ns, sd->s_name);
917 }
918
919 /* Relationship between s_mode and the DT_xxx types */
920 static inline unsigned char dt_type(struct sysfs_dirent *sd)
921 {
922         return (sd->s_mode >> 12) & 15;
923 }
924
925 static int sysfs_dir_release(struct inode *inode, struct file *filp)
926 {
927         sysfs_put(filp->private_data);
928         return 0;
929 }
930
931 static struct sysfs_dirent *sysfs_dir_pos(const void *ns,
932         struct sysfs_dirent *parent_sd, loff_t hash, struct sysfs_dirent *pos)
933 {
934         if (pos) {
935                 int valid = !(pos->s_flags & SYSFS_FLAG_REMOVED) &&
936                         pos->s_parent == parent_sd &&
937                         hash == pos->s_hash;
938                 sysfs_put(pos);
939                 if (!valid)
940                         pos = NULL;
941         }
942         if (!pos && (hash > 1) && (hash < INT_MAX)) {
943                 struct rb_node *node = parent_sd->s_dir.children.rb_node;
944                 while (node) {
945                         pos = to_sysfs_dirent(node);
946
947                         if (hash < pos->s_hash)
948                                 node = node->rb_left;
949                         else if (hash > pos->s_hash)
950                                 node = node->rb_right;
951                         else
952                                 break;
953                 }
954         }
955         /* Skip over entries in the wrong namespace */
956         while (pos && pos->s_ns != ns) {
957                 struct rb_node *node = rb_next(&pos->s_rb);
958                 if (!node)
959                         pos = NULL;
960                 else
961                         pos = to_sysfs_dirent(node);
962         }
963         return pos;
964 }
965
966 static struct sysfs_dirent *sysfs_dir_next_pos(const void *ns,
967         struct sysfs_dirent *parent_sd, ino_t ino, struct sysfs_dirent *pos)
968 {
969         pos = sysfs_dir_pos(ns, parent_sd, ino, pos);
970         if (pos) do {
971                 struct rb_node *node = rb_next(&pos->s_rb);
972                 if (!node)
973                         pos = NULL;
974                 else
975                         pos = to_sysfs_dirent(node);
976         } while (pos && pos->s_ns != ns);
977         return pos;
978 }
979
980 static int sysfs_readdir(struct file * filp, void * dirent, filldir_t filldir)
981 {
982         struct dentry *dentry = filp->f_path.dentry;
983         struct sysfs_dirent * parent_sd = dentry->d_fsdata;
984         struct sysfs_dirent *pos = filp->private_data;
985         enum kobj_ns_type type;
986         const void *ns;
987         ino_t ino;
988
989         type = sysfs_ns_type(parent_sd);
990         ns = sysfs_info(dentry->d_sb)->ns[type];
991
992         if (filp->f_pos == 0) {
993                 ino = parent_sd->s_ino;
994                 if (filldir(dirent, ".", 1, filp->f_pos, ino, DT_DIR) == 0)
995                         filp->f_pos++;
996         }
997         if (filp->f_pos == 1) {
998                 if (parent_sd->s_parent)
999                         ino = parent_sd->s_parent->s_ino;
1000                 else
1001                         ino = parent_sd->s_ino;
1002                 if (filldir(dirent, "..", 2, filp->f_pos, ino, DT_DIR) == 0)
1003                         filp->f_pos++;
1004         }
1005         mutex_lock(&sysfs_mutex);
1006         for (pos = sysfs_dir_pos(ns, parent_sd, filp->f_pos, pos);
1007              pos;
1008              pos = sysfs_dir_next_pos(ns, parent_sd, filp->f_pos, pos)) {
1009                 const char * name;
1010                 unsigned int type;
1011                 int len, ret;
1012
1013                 name = pos->s_name;
1014                 len = strlen(name);
1015                 ino = pos->s_ino;
1016                 type = dt_type(pos);
1017                 filp->f_pos = pos->s_hash;
1018                 filp->private_data = sysfs_get(pos);
1019
1020                 mutex_unlock(&sysfs_mutex);
1021                 ret = filldir(dirent, name, len, filp->f_pos, ino, type);
1022                 mutex_lock(&sysfs_mutex);
1023                 if (ret < 0)
1024                         break;
1025         }
1026         mutex_unlock(&sysfs_mutex);
1027         if ((filp->f_pos > 1) && !pos) { /* EOF */
1028                 filp->f_pos = INT_MAX;
1029                 filp->private_data = NULL;
1030         }
1031         return 0;
1032 }
1033
1034
1035 const struct file_operations sysfs_dir_operations = {
1036         .read           = generic_read_dir,
1037         .readdir        = sysfs_readdir,
1038         .release        = sysfs_dir_release,
1039         .llseek         = generic_file_llseek,
1040 };