sysfs: Remove first pass at shadow directory support
[linux-2.6.git] / fs / sysfs / dir.c
1 /*
2  * dir.c - Operations for sysfs directories.
3  */
4
5 #undef DEBUG
6
7 #include <linux/fs.h>
8 #include <linux/mount.h>
9 #include <linux/module.h>
10 #include <linux/kobject.h>
11 #include <linux/namei.h>
12 #include <linux/idr.h>
13 #include <linux/completion.h>
14 #include <linux/mutex.h>
15 #include "sysfs.h"
16
17 DEFINE_MUTEX(sysfs_mutex);
18 spinlock_t sysfs_assoc_lock = SPIN_LOCK_UNLOCKED;
19
20 static spinlock_t sysfs_ino_lock = SPIN_LOCK_UNLOCKED;
21 static DEFINE_IDA(sysfs_ino_ida);
22
23 /**
24  *      sysfs_link_sibling - link sysfs_dirent into sibling list
25  *      @sd: sysfs_dirent of interest
26  *
27  *      Link @sd into its sibling list which starts from
28  *      sd->s_parent->s_children.
29  *
30  *      Locking:
31  *      mutex_lock(sysfs_mutex)
32  */
33 void sysfs_link_sibling(struct sysfs_dirent *sd)
34 {
35         struct sysfs_dirent *parent_sd = sd->s_parent;
36
37         BUG_ON(sd->s_sibling);
38         sd->s_sibling = parent_sd->s_children;
39         parent_sd->s_children = sd;
40 }
41
42 /**
43  *      sysfs_unlink_sibling - unlink sysfs_dirent from sibling list
44  *      @sd: sysfs_dirent of interest
45  *
46  *      Unlink @sd from its sibling list which starts from
47  *      sd->s_parent->s_children.
48  *
49  *      Locking:
50  *      mutex_lock(sysfs_mutex)
51  */
52 void sysfs_unlink_sibling(struct sysfs_dirent *sd)
53 {
54         struct sysfs_dirent **pos;
55
56         for (pos = &sd->s_parent->s_children; *pos; pos = &(*pos)->s_sibling) {
57                 if (*pos == sd) {
58                         *pos = sd->s_sibling;
59                         sd->s_sibling = NULL;
60                         break;
61                 }
62         }
63 }
64
65 /**
66  *      sysfs_get_dentry - get dentry for the given sysfs_dirent
67  *      @sd: sysfs_dirent of interest
68  *
69  *      Get dentry for @sd.  Dentry is looked up if currently not
70  *      present.  This function climbs sysfs_dirent tree till it
71  *      reaches a sysfs_dirent with valid dentry attached and descends
72  *      down from there looking up dentry for each step.
73  *
74  *      LOCKING:
75  *      Kernel thread context (may sleep)
76  *
77  *      RETURNS:
78  *      Pointer to found dentry on success, ERR_PTR() value on error.
79  */
80 struct dentry *sysfs_get_dentry(struct sysfs_dirent *sd)
81 {
82         struct sysfs_dirent *cur;
83         struct dentry *parent_dentry, *dentry;
84         int i, depth;
85
86         /* Find the first parent which has valid s_dentry and get the
87          * dentry.
88          */
89         mutex_lock(&sysfs_mutex);
90  restart0:
91         spin_lock(&sysfs_assoc_lock);
92  restart1:
93         spin_lock(&dcache_lock);
94
95         dentry = NULL;
96         depth = 0;
97         cur = sd;
98         while (!cur->s_dentry || !cur->s_dentry->d_inode) {
99                 if (cur->s_flags & SYSFS_FLAG_REMOVED) {
100                         dentry = ERR_PTR(-ENOENT);
101                         depth = 0;
102                         break;
103                 }
104                 cur = cur->s_parent;
105                 depth++;
106         }
107         if (!IS_ERR(dentry))
108                 dentry = dget_locked(cur->s_dentry);
109
110         spin_unlock(&dcache_lock);
111         spin_unlock(&sysfs_assoc_lock);
112
113         /* from the found dentry, look up depth times */
114         while (depth--) {
115                 /* find and get depth'th ancestor */
116                 for (cur = sd, i = 0; cur && i < depth; i++)
117                         cur = cur->s_parent;
118
119                 /* This can happen if tree structure was modified due
120                  * to move/rename.  Restart.
121                  */
122                 if (i != depth) {
123                         dput(dentry);
124                         goto restart0;
125                 }
126
127                 sysfs_get(cur);
128
129                 mutex_unlock(&sysfs_mutex);
130
131                 /* look it up */
132                 parent_dentry = dentry;
133                 dentry = lookup_one_len_kern(cur->s_name, parent_dentry,
134                                              strlen(cur->s_name));
135                 dput(parent_dentry);
136
137                 if (IS_ERR(dentry)) {
138                         sysfs_put(cur);
139                         return dentry;
140                 }
141
142                 mutex_lock(&sysfs_mutex);
143                 spin_lock(&sysfs_assoc_lock);
144
145                 /* This, again, can happen if tree structure has
146                  * changed and we looked up the wrong thing.  Restart.
147                  */
148                 if (cur->s_dentry != dentry) {
149                         dput(dentry);
150                         sysfs_put(cur);
151                         goto restart1;
152                 }
153
154                 spin_unlock(&sysfs_assoc_lock);
155
156                 sysfs_put(cur);
157         }
158
159         mutex_unlock(&sysfs_mutex);
160         return dentry;
161 }
162
163 /**
164  *      sysfs_get_active - get an active reference to sysfs_dirent
165  *      @sd: sysfs_dirent to get an active reference to
166  *
167  *      Get an active reference of @sd.  This function is noop if @sd
168  *      is NULL.
169  *
170  *      RETURNS:
171  *      Pointer to @sd on success, NULL on failure.
172  */
173 struct sysfs_dirent *sysfs_get_active(struct sysfs_dirent *sd)
174 {
175         if (unlikely(!sd))
176                 return NULL;
177
178         while (1) {
179                 int v, t;
180
181                 v = atomic_read(&sd->s_active);
182                 if (unlikely(v < 0))
183                         return NULL;
184
185                 t = atomic_cmpxchg(&sd->s_active, v, v + 1);
186                 if (likely(t == v))
187                         return sd;
188                 if (t < 0)
189                         return NULL;
190
191                 cpu_relax();
192         }
193 }
194
195 /**
196  *      sysfs_put_active - put an active reference to sysfs_dirent
197  *      @sd: sysfs_dirent to put an active reference to
198  *
199  *      Put an active reference to @sd.  This function is noop if @sd
200  *      is NULL.
201  */
202 void sysfs_put_active(struct sysfs_dirent *sd)
203 {
204         struct completion *cmpl;
205         int v;
206
207         if (unlikely(!sd))
208                 return;
209
210         v = atomic_dec_return(&sd->s_active);
211         if (likely(v != SD_DEACTIVATED_BIAS))
212                 return;
213
214         /* atomic_dec_return() is a mb(), we'll always see the updated
215          * sd->s_sibling.
216          */
217         cmpl = (void *)sd->s_sibling;
218         complete(cmpl);
219 }
220
221 /**
222  *      sysfs_get_active_two - get active references to sysfs_dirent and parent
223  *      @sd: sysfs_dirent of interest
224  *
225  *      Get active reference to @sd and its parent.  Parent's active
226  *      reference is grabbed first.  This function is noop if @sd is
227  *      NULL.
228  *
229  *      RETURNS:
230  *      Pointer to @sd on success, NULL on failure.
231  */
232 struct sysfs_dirent *sysfs_get_active_two(struct sysfs_dirent *sd)
233 {
234         if (sd) {
235                 if (sd->s_parent && unlikely(!sysfs_get_active(sd->s_parent)))
236                         return NULL;
237                 if (unlikely(!sysfs_get_active(sd))) {
238                         sysfs_put_active(sd->s_parent);
239                         return NULL;
240                 }
241         }
242         return sd;
243 }
244
245 /**
246  *      sysfs_put_active_two - put active references to sysfs_dirent and parent
247  *      @sd: sysfs_dirent of interest
248  *
249  *      Put active references to @sd and its parent.  This function is
250  *      noop if @sd is NULL.
251  */
252 void sysfs_put_active_two(struct sysfs_dirent *sd)
253 {
254         if (sd) {
255                 sysfs_put_active(sd);
256                 sysfs_put_active(sd->s_parent);
257         }
258 }
259
260 /**
261  *      sysfs_deactivate - deactivate sysfs_dirent
262  *      @sd: sysfs_dirent to deactivate
263  *
264  *      Deny new active references and drain existing ones.
265  */
266 static void sysfs_deactivate(struct sysfs_dirent *sd)
267 {
268         DECLARE_COMPLETION_ONSTACK(wait);
269         int v;
270
271         BUG_ON(sd->s_sibling || !(sd->s_flags & SYSFS_FLAG_REMOVED));
272         sd->s_sibling = (void *)&wait;
273
274         /* atomic_add_return() is a mb(), put_active() will always see
275          * the updated sd->s_sibling.
276          */
277         v = atomic_add_return(SD_DEACTIVATED_BIAS, &sd->s_active);
278
279         if (v != SD_DEACTIVATED_BIAS)
280                 wait_for_completion(&wait);
281
282         sd->s_sibling = NULL;
283 }
284
285 static int sysfs_alloc_ino(ino_t *pino)
286 {
287         int ino, rc;
288
289  retry:
290         spin_lock(&sysfs_ino_lock);
291         rc = ida_get_new_above(&sysfs_ino_ida, 2, &ino);
292         spin_unlock(&sysfs_ino_lock);
293
294         if (rc == -EAGAIN) {
295                 if (ida_pre_get(&sysfs_ino_ida, GFP_KERNEL))
296                         goto retry;
297                 rc = -ENOMEM;
298         }
299
300         *pino = ino;
301         return rc;
302 }
303
304 static void sysfs_free_ino(ino_t ino)
305 {
306         spin_lock(&sysfs_ino_lock);
307         ida_remove(&sysfs_ino_ida, ino);
308         spin_unlock(&sysfs_ino_lock);
309 }
310
311 void release_sysfs_dirent(struct sysfs_dirent * sd)
312 {
313         struct sysfs_dirent *parent_sd;
314
315  repeat:
316         /* Moving/renaming is always done while holding reference.
317          * sd->s_parent won't change beneath us.
318          */
319         parent_sd = sd->s_parent;
320
321         if (sysfs_type(sd) == SYSFS_KOBJ_LINK)
322                 sysfs_put(sd->s_elem.symlink.target_sd);
323         if (sysfs_type(sd) & SYSFS_COPY_NAME)
324                 kfree(sd->s_name);
325         kfree(sd->s_iattr);
326         sysfs_free_ino(sd->s_ino);
327         kmem_cache_free(sysfs_dir_cachep, sd);
328
329         sd = parent_sd;
330         if (sd && atomic_dec_and_test(&sd->s_count))
331                 goto repeat;
332 }
333
334 static void sysfs_d_iput(struct dentry * dentry, struct inode * inode)
335 {
336         struct sysfs_dirent * sd = dentry->d_fsdata;
337
338         if (sd) {
339                 /* sd->s_dentry is protected with sysfs_assoc_lock.
340                  * This allows sysfs_drop_dentry() to dereference it.
341                  */
342                 spin_lock(&sysfs_assoc_lock);
343
344                 /* The dentry might have been deleted or another
345                  * lookup could have happened updating sd->s_dentry to
346                  * point the new dentry.  Ignore if it isn't pointing
347                  * to this dentry.
348                  */
349                 if (sd->s_dentry == dentry)
350                         sd->s_dentry = NULL;
351                 spin_unlock(&sysfs_assoc_lock);
352                 sysfs_put(sd);
353         }
354         iput(inode);
355 }
356
357 static struct dentry_operations sysfs_dentry_ops = {
358         .d_iput         = sysfs_d_iput,
359 };
360
361 struct sysfs_dirent *sysfs_new_dirent(const char *name, umode_t mode, int type)
362 {
363         char *dup_name = NULL;
364         struct sysfs_dirent *sd;
365
366         if (type & SYSFS_COPY_NAME) {
367                 name = dup_name = kstrdup(name, GFP_KERNEL);
368                 if (!name)
369                         return NULL;
370         }
371
372         sd = kmem_cache_zalloc(sysfs_dir_cachep, GFP_KERNEL);
373         if (!sd)
374                 goto err_out1;
375
376         if (sysfs_alloc_ino(&sd->s_ino))
377                 goto err_out2;
378
379         atomic_set(&sd->s_count, 1);
380         atomic_set(&sd->s_active, 0);
381         atomic_set(&sd->s_event, 1);
382
383         sd->s_name = name;
384         sd->s_mode = mode;
385         sd->s_flags = type;
386
387         return sd;
388
389  err_out2:
390         kmem_cache_free(sysfs_dir_cachep, sd);
391  err_out1:
392         kfree(dup_name);
393         return NULL;
394 }
395
396 /**
397  *      sysfs_attach_dentry - associate sysfs_dirent with dentry
398  *      @sd: target sysfs_dirent
399  *      @dentry: dentry to associate
400  *
401  *      Associate @sd with @dentry.  This is protected by
402  *      sysfs_assoc_lock to avoid race with sysfs_d_iput().
403  *
404  *      LOCKING:
405  *      mutex_lock(sysfs_mutex)
406  */
407 static void sysfs_attach_dentry(struct sysfs_dirent *sd, struct dentry *dentry)
408 {
409         dentry->d_op = &sysfs_dentry_ops;
410         dentry->d_fsdata = sysfs_get(sd);
411
412         /* protect sd->s_dentry against sysfs_d_iput */
413         spin_lock(&sysfs_assoc_lock);
414         sd->s_dentry = dentry;
415         spin_unlock(&sysfs_assoc_lock);
416
417         d_rehash(dentry);
418 }
419
420 static int sysfs_ilookup_test(struct inode *inode, void *arg)
421 {
422         struct sysfs_dirent *sd = arg;
423         return inode->i_ino == sd->s_ino;
424 }
425
426 /**
427  *      sysfs_addrm_start - prepare for sysfs_dirent add/remove
428  *      @acxt: pointer to sysfs_addrm_cxt to be used
429  *      @parent_sd: parent sysfs_dirent
430  *
431  *      This function is called when the caller is about to add or
432  *      remove sysfs_dirent under @parent_sd.  This function acquires
433  *      sysfs_mutex, grabs inode for @parent_sd if available and lock
434  *      i_mutex of it.  @acxt is used to keep and pass context to
435  *      other addrm functions.
436  *
437  *      LOCKING:
438  *      Kernel thread context (may sleep).  sysfs_mutex is locked on
439  *      return.  i_mutex of parent inode is locked on return if
440  *      available.
441  */
442 void sysfs_addrm_start(struct sysfs_addrm_cxt *acxt,
443                        struct sysfs_dirent *parent_sd)
444 {
445         struct inode *inode;
446
447         memset(acxt, 0, sizeof(*acxt));
448         acxt->parent_sd = parent_sd;
449
450         /* Lookup parent inode.  inode initialization and I_NEW
451          * clearing are protected by sysfs_mutex.  By grabbing it and
452          * looking up with _nowait variant, inode state can be
453          * determined reliably.
454          */
455         mutex_lock(&sysfs_mutex);
456
457         inode = ilookup5_nowait(sysfs_sb, parent_sd->s_ino, sysfs_ilookup_test,
458                                 parent_sd);
459
460         if (inode && !(inode->i_state & I_NEW)) {
461                 /* parent inode available */
462                 acxt->parent_inode = inode;
463
464                 /* sysfs_mutex is below i_mutex in lock hierarchy.
465                  * First, trylock i_mutex.  If fails, unlock
466                  * sysfs_mutex and lock them in order.
467                  */
468                 if (!mutex_trylock(&inode->i_mutex)) {
469                         mutex_unlock(&sysfs_mutex);
470                         mutex_lock(&inode->i_mutex);
471                         mutex_lock(&sysfs_mutex);
472                 }
473         } else
474                 iput(inode);
475 }
476
477 /**
478  *      sysfs_add_one - add sysfs_dirent to parent
479  *      @acxt: addrm context to use
480  *      @sd: sysfs_dirent to be added
481  *
482  *      Get @acxt->parent_sd and set sd->s_parent to it and increment
483  *      nlink of parent inode if @sd is a directory.  @sd is NOT
484  *      linked into the children list of the parent.  The caller
485  *      should invoke sysfs_link_sibling() after this function
486  *      completes if @sd needs to be on the children list.
487  *
488  *      This function should be called between calls to
489  *      sysfs_addrm_start() and sysfs_addrm_finish() and should be
490  *      passed the same @acxt as passed to sysfs_addrm_start().
491  *
492  *      LOCKING:
493  *      Determined by sysfs_addrm_start().
494  */
495 void sysfs_add_one(struct sysfs_addrm_cxt *acxt, struct sysfs_dirent *sd)
496 {
497         sd->s_parent = sysfs_get(acxt->parent_sd);
498
499         if (sysfs_type(sd) == SYSFS_DIR && acxt->parent_inode)
500                 inc_nlink(acxt->parent_inode);
501
502         acxt->cnt++;
503 }
504
505 /**
506  *      sysfs_remove_one - remove sysfs_dirent from parent
507  *      @acxt: addrm context to use
508  *      @sd: sysfs_dirent to be added
509  *
510  *      Mark @sd removed and drop nlink of parent inode if @sd is a
511  *      directory.  @sd is NOT unlinked from the children list of the
512  *      parent.  The caller is repsonsible for removing @sd from the
513  *      children list before calling this function.
514  *
515  *      This function should be called between calls to
516  *      sysfs_addrm_start() and sysfs_addrm_finish() and should be
517  *      passed the same @acxt as passed to sysfs_addrm_start().
518  *
519  *      LOCKING:
520  *      Determined by sysfs_addrm_start().
521  */
522 void sysfs_remove_one(struct sysfs_addrm_cxt *acxt, struct sysfs_dirent *sd)
523 {
524         BUG_ON(sd->s_sibling || (sd->s_flags & SYSFS_FLAG_REMOVED));
525
526         sd->s_flags |= SYSFS_FLAG_REMOVED;
527         sd->s_sibling = acxt->removed;
528         acxt->removed = sd;
529
530         if (sysfs_type(sd) == SYSFS_DIR && acxt->parent_inode)
531                 drop_nlink(acxt->parent_inode);
532
533         acxt->cnt++;
534 }
535
536 /**
537  *      sysfs_drop_dentry - drop dentry for the specified sysfs_dirent
538  *      @sd: target sysfs_dirent
539  *
540  *      Drop dentry for @sd.  @sd must have been unlinked from its
541  *      parent on entry to this function such that it can't be looked
542  *      up anymore.
543  *
544  *      @sd->s_dentry which is protected with sysfs_assoc_lock points
545  *      to the currently associated dentry but we're not holding a
546  *      reference to it and racing with dput().  Grab dcache_lock and
547  *      verify dentry before dropping it.  If @sd->s_dentry is NULL or
548  *      dput() beats us, no need to bother.
549  */
550 static void sysfs_drop_dentry(struct sysfs_dirent *sd)
551 {
552         struct dentry *dentry = NULL;
553         struct inode *inode;
554
555         /* We're not holding a reference to ->s_dentry dentry but the
556          * field will stay valid as long as sysfs_assoc_lock is held.
557          */
558         spin_lock(&sysfs_assoc_lock);
559         spin_lock(&dcache_lock);
560
561         /* drop dentry if it's there and dput() didn't kill it yet */
562         if (sd->s_dentry && sd->s_dentry->d_inode) {
563                 dentry = dget_locked(sd->s_dentry);
564                 spin_lock(&dentry->d_lock);
565                 __d_drop(dentry);
566                 spin_unlock(&dentry->d_lock);
567         }
568
569         spin_unlock(&dcache_lock);
570         spin_unlock(&sysfs_assoc_lock);
571
572         dput(dentry);
573
574         /* adjust nlink and update timestamp */
575         inode = ilookup(sysfs_sb, sd->s_ino);
576         if (inode) {
577                 mutex_lock(&inode->i_mutex);
578
579                 inode->i_ctime = CURRENT_TIME;
580                 drop_nlink(inode);
581                 if (sysfs_type(sd) == SYSFS_DIR)
582                         drop_nlink(inode);
583
584                 mutex_unlock(&inode->i_mutex);
585                 iput(inode);
586         }
587 }
588
589 /**
590  *      sysfs_addrm_finish - finish up sysfs_dirent add/remove
591  *      @acxt: addrm context to finish up
592  *
593  *      Finish up sysfs_dirent add/remove.  Resources acquired by
594  *      sysfs_addrm_start() are released and removed sysfs_dirents are
595  *      cleaned up.  Timestamps on the parent inode are updated.
596  *
597  *      LOCKING:
598  *      All mutexes acquired by sysfs_addrm_start() are released.
599  *
600  *      RETURNS:
601  *      Number of added/removed sysfs_dirents since sysfs_addrm_start().
602  */
603 int sysfs_addrm_finish(struct sysfs_addrm_cxt *acxt)
604 {
605         /* release resources acquired by sysfs_addrm_start() */
606         mutex_unlock(&sysfs_mutex);
607         if (acxt->parent_inode) {
608                 struct inode *inode = acxt->parent_inode;
609
610                 /* if added/removed, update timestamps on the parent */
611                 if (acxt->cnt)
612                         inode->i_ctime = inode->i_mtime = CURRENT_TIME;
613
614                 mutex_unlock(&inode->i_mutex);
615                 iput(inode);
616         }
617
618         /* kill removed sysfs_dirents */
619         while (acxt->removed) {
620                 struct sysfs_dirent *sd = acxt->removed;
621
622                 acxt->removed = sd->s_sibling;
623                 sd->s_sibling = NULL;
624
625                 sysfs_drop_dentry(sd);
626                 sysfs_deactivate(sd);
627                 sysfs_put(sd);
628         }
629
630         return acxt->cnt;
631 }
632
633 /**
634  *      sysfs_find_dirent - find sysfs_dirent with the given name
635  *      @parent_sd: sysfs_dirent to search under
636  *      @name: name to look for
637  *
638  *      Look for sysfs_dirent with name @name under @parent_sd.
639  *
640  *      LOCKING:
641  *      mutex_lock(sysfs_mutex)
642  *
643  *      RETURNS:
644  *      Pointer to sysfs_dirent if found, NULL if not.
645  */
646 struct sysfs_dirent *sysfs_find_dirent(struct sysfs_dirent *parent_sd,
647                                        const unsigned char *name)
648 {
649         struct sysfs_dirent *sd;
650
651         for (sd = parent_sd->s_children; sd; sd = sd->s_sibling)
652                 if (sysfs_type(sd) && !strcmp(sd->s_name, name))
653                         return sd;
654         return NULL;
655 }
656
657 /**
658  *      sysfs_get_dirent - find and get sysfs_dirent with the given name
659  *      @parent_sd: sysfs_dirent to search under
660  *      @name: name to look for
661  *
662  *      Look for sysfs_dirent with name @name under @parent_sd and get
663  *      it if found.
664  *
665  *      LOCKING:
666  *      Kernel thread context (may sleep).  Grabs sysfs_mutex.
667  *
668  *      RETURNS:
669  *      Pointer to sysfs_dirent if found, NULL if not.
670  */
671 struct sysfs_dirent *sysfs_get_dirent(struct sysfs_dirent *parent_sd,
672                                       const unsigned char *name)
673 {
674         struct sysfs_dirent *sd;
675
676         mutex_lock(&sysfs_mutex);
677         sd = sysfs_find_dirent(parent_sd, name);
678         sysfs_get(sd);
679         mutex_unlock(&sysfs_mutex);
680
681         return sd;
682 }
683
684 static int create_dir(struct kobject *kobj, struct sysfs_dirent *parent_sd,
685                       const char *name, struct sysfs_dirent **p_sd)
686 {
687         umode_t mode = S_IFDIR| S_IRWXU | S_IRUGO | S_IXUGO;
688         struct sysfs_addrm_cxt acxt;
689         struct sysfs_dirent *sd;
690
691         /* allocate */
692         sd = sysfs_new_dirent(name, mode, SYSFS_DIR);
693         if (!sd)
694                 return -ENOMEM;
695         sd->s_elem.dir.kobj = kobj;
696
697         /* link in */
698         sysfs_addrm_start(&acxt, parent_sd);
699
700         if (!sysfs_find_dirent(parent_sd, name)) {
701                 sysfs_add_one(&acxt, sd);
702                 sysfs_link_sibling(sd);
703         }
704
705         if (!sysfs_addrm_finish(&acxt)) {
706                 sysfs_put(sd);
707                 return -EEXIST;
708         }
709
710         *p_sd = sd;
711         return 0;
712 }
713
714 int sysfs_create_subdir(struct kobject *kobj, const char *name,
715                         struct sysfs_dirent **p_sd)
716 {
717         return create_dir(kobj, kobj->sd, name, p_sd);
718 }
719
720 /**
721  *      sysfs_create_dir - create a directory for an object.
722  *      @kobj:          object we're creating directory for. 
723  */
724 int sysfs_create_dir(struct kobject * kobj)
725 {
726         struct sysfs_dirent *parent_sd, *sd;
727         int error = 0;
728
729         BUG_ON(!kobj);
730
731         if (kobj->parent)
732                 parent_sd = kobj->parent->sd;
733         else if (sysfs_mount && sysfs_mount->mnt_sb)
734                 parent_sd = sysfs_mount->mnt_sb->s_root->d_fsdata;
735         else
736                 return -EFAULT;
737
738         error = create_dir(kobj, parent_sd, kobject_name(kobj), &sd);
739         if (!error)
740                 kobj->sd = sd;
741         return error;
742 }
743
744 static int sysfs_count_nlink(struct sysfs_dirent *sd)
745 {
746         struct sysfs_dirent *child;
747         int nr = 0;
748
749         for (child = sd->s_children; child; child = child->s_sibling)
750                 if (sysfs_type(child) == SYSFS_DIR)
751                         nr++;
752         return nr + 2;
753 }
754
755 static struct dentry * sysfs_lookup(struct inode *dir, struct dentry *dentry,
756                                 struct nameidata *nd)
757 {
758         struct dentry *ret = NULL;
759         struct sysfs_dirent * parent_sd = dentry->d_parent->d_fsdata;
760         struct sysfs_dirent * sd;
761         struct bin_attribute *bin_attr;
762         struct inode *inode;
763         int found = 0;
764
765         mutex_lock(&sysfs_mutex);
766
767         for (sd = parent_sd->s_children; sd; sd = sd->s_sibling) {
768                 if (sysfs_type(sd) &&
769                     !strcmp(sd->s_name, dentry->d_name.name)) {
770                         found = 1;
771                         break;
772                 }
773         }
774
775         /* no such entry */
776         if (!found)
777                 goto out_unlock;
778
779         /* attach dentry and inode */
780         inode = sysfs_get_inode(sd);
781         if (!inode) {
782                 ret = ERR_PTR(-ENOMEM);
783                 goto out_unlock;
784         }
785
786         if (inode->i_state & I_NEW) {
787                 /* initialize inode according to type */
788                 switch (sysfs_type(sd)) {
789                 case SYSFS_DIR:
790                         inode->i_op = &sysfs_dir_inode_operations;
791                         inode->i_fop = &sysfs_dir_operations;
792                         inode->i_nlink = sysfs_count_nlink(sd);
793                         break;
794                 case SYSFS_KOBJ_ATTR:
795                         inode->i_size = PAGE_SIZE;
796                         inode->i_fop = &sysfs_file_operations;
797                         break;
798                 case SYSFS_KOBJ_BIN_ATTR:
799                         bin_attr = sd->s_elem.bin_attr.bin_attr;
800                         inode->i_size = bin_attr->size;
801                         inode->i_fop = &bin_fops;
802                         break;
803                 case SYSFS_KOBJ_LINK:
804                         inode->i_op = &sysfs_symlink_inode_operations;
805                         break;
806                 default:
807                         BUG();
808                 }
809         }
810
811         sysfs_instantiate(dentry, inode);
812         sysfs_attach_dentry(sd, dentry);
813
814  out_unlock:
815         mutex_unlock(&sysfs_mutex);
816         return ret;
817 }
818
819 const struct inode_operations sysfs_dir_inode_operations = {
820         .lookup         = sysfs_lookup,
821         .setattr        = sysfs_setattr,
822 };
823
824 static void remove_dir(struct sysfs_dirent *sd)
825 {
826         struct sysfs_addrm_cxt acxt;
827
828         sysfs_addrm_start(&acxt, sd->s_parent);
829         sysfs_unlink_sibling(sd);
830         sysfs_remove_one(&acxt, sd);
831         sysfs_addrm_finish(&acxt);
832 }
833
834 void sysfs_remove_subdir(struct sysfs_dirent *sd)
835 {
836         remove_dir(sd);
837 }
838
839
840 static void __sysfs_remove_dir(struct sysfs_dirent *dir_sd)
841 {
842         struct sysfs_addrm_cxt acxt;
843         struct sysfs_dirent **pos;
844
845         if (!dir_sd)
846                 return;
847
848         pr_debug("sysfs %s: removing dir\n", dir_sd->s_name);
849         sysfs_addrm_start(&acxt, dir_sd);
850         pos = &dir_sd->s_children;
851         while (*pos) {
852                 struct sysfs_dirent *sd = *pos;
853
854                 if (sysfs_type(sd) && sysfs_type(sd) != SYSFS_DIR) {
855                         *pos = sd->s_sibling;
856                         sd->s_sibling = NULL;
857                         sysfs_remove_one(&acxt, sd);
858                 } else
859                         pos = &(*pos)->s_sibling;
860         }
861         sysfs_addrm_finish(&acxt);
862
863         remove_dir(dir_sd);
864 }
865
866 /**
867  *      sysfs_remove_dir - remove an object's directory.
868  *      @kobj:  object.
869  *
870  *      The only thing special about this is that we remove any files in
871  *      the directory before we remove the directory, and we've inlined
872  *      what used to be sysfs_rmdir() below, instead of calling separately.
873  */
874
875 void sysfs_remove_dir(struct kobject * kobj)
876 {
877         struct sysfs_dirent *sd = kobj->sd;
878
879         spin_lock(&sysfs_assoc_lock);
880         kobj->sd = NULL;
881         spin_unlock(&sysfs_assoc_lock);
882
883         __sysfs_remove_dir(sd);
884 }
885
886 int sysfs_rename_dir(struct kobject * kobj, const char *new_name)
887 {
888         struct sysfs_dirent *sd;
889         struct dentry *parent = NULL;
890         struct dentry *old_dentry = NULL, *new_dentry = NULL;
891         struct sysfs_dirent *parent_sd;
892         const char *dup_name = NULL;
893         int error;
894
895         if (!kobj->parent)
896                 return -EINVAL;
897
898         /* get dentries */
899         sd = kobj->sd;
900         old_dentry = sysfs_get_dentry(sd);
901         if (IS_ERR(old_dentry)) {
902                 error = PTR_ERR(old_dentry);
903                 goto out_dput;
904         }
905
906         parent_sd = kobj->parent->sd;
907         parent = sysfs_get_dentry(parent_sd);
908         if (IS_ERR(parent)) {
909                 error = PTR_ERR(parent);
910                 goto out_dput;
911         }
912
913         /* lock parent and get dentry for new name */
914         mutex_lock(&parent->d_inode->i_mutex);
915
916         new_dentry = lookup_one_len(new_name, parent, strlen(new_name));
917         if (IS_ERR(new_dentry)) {
918                 error = PTR_ERR(new_dentry);
919                 goto out_unlock;
920         }
921
922         error = -EINVAL;
923         if (old_dentry == new_dentry)
924                 goto out_unlock;
925
926         error = -EEXIST;
927         if (new_dentry->d_inode)
928                 goto out_unlock;
929
930         /* rename kobject and sysfs_dirent */
931         error = -ENOMEM;
932         new_name = dup_name = kstrdup(new_name, GFP_KERNEL);
933         if (!new_name)
934                 goto out_drop;
935
936         error = kobject_set_name(kobj, "%s", new_name);
937         if (error)
938                 goto out_drop;
939
940         mutex_lock(&sysfs_mutex);
941
942         dup_name = sd->s_name;
943         sd->s_name = new_name;
944
945         /* move under the new parent */
946         d_add(new_dentry, NULL);
947         d_move(sd->s_dentry, new_dentry);
948
949         sysfs_unlink_sibling(sd);
950         sysfs_get(parent_sd);
951         sysfs_put(sd->s_parent);
952         sd->s_parent = parent_sd;
953         sysfs_link_sibling(sd);
954
955         mutex_unlock(&sysfs_mutex);
956
957         error = 0;
958         goto out_unlock;
959
960  out_drop:
961         d_drop(new_dentry);
962  out_unlock:
963         mutex_unlock(&parent->d_inode->i_mutex);
964  out_dput:
965         kfree(dup_name);
966         dput(parent);
967         dput(old_dentry);
968         dput(new_dentry);
969         return error;
970 }
971
972 int sysfs_move_dir(struct kobject *kobj, struct kobject *new_parent_kobj)
973 {
974         struct sysfs_dirent *sd = kobj->sd;
975         struct sysfs_dirent *new_parent_sd;
976         struct dentry *old_parent, *new_parent = NULL;
977         struct dentry *old_dentry = NULL, *new_dentry = NULL;
978         int error;
979
980         BUG_ON(!sd->s_parent);
981         new_parent_sd = new_parent_kobj->sd ? new_parent_kobj->sd : &sysfs_root;
982
983         /* get dentries */
984         old_dentry = sysfs_get_dentry(sd);
985         if (IS_ERR(old_dentry)) {
986                 error = PTR_ERR(old_dentry);
987                 goto out_dput;
988         }
989         old_parent = sd->s_parent->s_dentry;
990
991         new_parent = sysfs_get_dentry(new_parent_sd);
992         if (IS_ERR(new_parent)) {
993                 error = PTR_ERR(new_parent);
994                 goto out_dput;
995         }
996
997         if (old_parent->d_inode == new_parent->d_inode) {
998                 error = 0;
999                 goto out_dput;  /* nothing to move */
1000         }
1001 again:
1002         mutex_lock(&old_parent->d_inode->i_mutex);
1003         if (!mutex_trylock(&new_parent->d_inode->i_mutex)) {
1004                 mutex_unlock(&old_parent->d_inode->i_mutex);
1005                 goto again;
1006         }
1007
1008         new_dentry = lookup_one_len(kobject_name(kobj), new_parent, strlen(kobject_name(kobj)));
1009         if (IS_ERR(new_dentry)) {
1010                 error = PTR_ERR(new_dentry);
1011                 goto out_unlock;
1012         } else
1013                 error = 0;
1014         d_add(new_dentry, NULL);
1015         d_move(sd->s_dentry, new_dentry);
1016         dput(new_dentry);
1017
1018         /* Remove from old parent's list and insert into new parent's list. */
1019         mutex_lock(&sysfs_mutex);
1020
1021         sysfs_unlink_sibling(sd);
1022         sysfs_get(new_parent_sd);
1023         sysfs_put(sd->s_parent);
1024         sd->s_parent = new_parent_sd;
1025         sysfs_link_sibling(sd);
1026
1027         mutex_unlock(&sysfs_mutex);
1028
1029  out_unlock:
1030         mutex_unlock(&new_parent->d_inode->i_mutex);
1031         mutex_unlock(&old_parent->d_inode->i_mutex);
1032  out_dput:
1033         dput(new_parent);
1034         dput(old_dentry);
1035         dput(new_dentry);
1036         return error;
1037 }
1038
1039 static int sysfs_dir_open(struct inode *inode, struct file *file)
1040 {
1041         struct dentry * dentry = file->f_path.dentry;
1042         struct sysfs_dirent * parent_sd = dentry->d_fsdata;
1043         struct sysfs_dirent * sd;
1044
1045         sd = sysfs_new_dirent("_DIR_", 0, 0);
1046         if (sd) {
1047                 mutex_lock(&sysfs_mutex);
1048                 sd->s_parent = sysfs_get(parent_sd);
1049                 sysfs_link_sibling(sd);
1050                 mutex_unlock(&sysfs_mutex);
1051         }
1052
1053         file->private_data = sd;
1054         return sd ? 0 : -ENOMEM;
1055 }
1056
1057 static int sysfs_dir_close(struct inode *inode, struct file *file)
1058 {
1059         struct sysfs_dirent * cursor = file->private_data;
1060
1061         mutex_lock(&sysfs_mutex);
1062         sysfs_unlink_sibling(cursor);
1063         mutex_unlock(&sysfs_mutex);
1064
1065         release_sysfs_dirent(cursor);
1066
1067         return 0;
1068 }
1069
1070 /* Relationship between s_mode and the DT_xxx types */
1071 static inline unsigned char dt_type(struct sysfs_dirent *sd)
1072 {
1073         return (sd->s_mode >> 12) & 15;
1074 }
1075
1076 static int sysfs_readdir(struct file * filp, void * dirent, filldir_t filldir)
1077 {
1078         struct dentry *dentry = filp->f_path.dentry;
1079         struct sysfs_dirent * parent_sd = dentry->d_fsdata;
1080         struct sysfs_dirent *cursor = filp->private_data;
1081         struct sysfs_dirent **pos;
1082         ino_t ino;
1083         int i = filp->f_pos;
1084
1085         switch (i) {
1086                 case 0:
1087                         ino = parent_sd->s_ino;
1088                         if (filldir(dirent, ".", 1, i, ino, DT_DIR) < 0)
1089                                 break;
1090                         filp->f_pos++;
1091                         i++;
1092                         /* fallthrough */
1093                 case 1:
1094                         if (parent_sd->s_parent)
1095                                 ino = parent_sd->s_parent->s_ino;
1096                         else
1097                                 ino = parent_sd->s_ino;
1098                         if (filldir(dirent, "..", 2, i, ino, DT_DIR) < 0)
1099                                 break;
1100                         filp->f_pos++;
1101                         i++;
1102                         /* fallthrough */
1103                 default:
1104                         mutex_lock(&sysfs_mutex);
1105
1106                         pos = &parent_sd->s_children;
1107                         while (*pos != cursor)
1108                                 pos = &(*pos)->s_sibling;
1109
1110                         /* unlink cursor */
1111                         *pos = cursor->s_sibling;
1112
1113                         if (filp->f_pos == 2)
1114                                 pos = &parent_sd->s_children;
1115
1116                         for ( ; *pos; pos = &(*pos)->s_sibling) {
1117                                 struct sysfs_dirent *next = *pos;
1118                                 const char * name;
1119                                 int len;
1120
1121                                 if (!sysfs_type(next))
1122                                         continue;
1123
1124                                 name = next->s_name;
1125                                 len = strlen(name);
1126                                 ino = next->s_ino;
1127
1128                                 if (filldir(dirent, name, len, filp->f_pos, ino,
1129                                                  dt_type(next)) < 0)
1130                                         break;
1131
1132                                 filp->f_pos++;
1133                         }
1134
1135                         /* put cursor back in */
1136                         cursor->s_sibling = *pos;
1137                         *pos = cursor;
1138
1139                         mutex_unlock(&sysfs_mutex);
1140         }
1141         return 0;
1142 }
1143
1144 static loff_t sysfs_dir_lseek(struct file * file, loff_t offset, int origin)
1145 {
1146         struct dentry * dentry = file->f_path.dentry;
1147
1148         switch (origin) {
1149                 case 1:
1150                         offset += file->f_pos;
1151                 case 0:
1152                         if (offset >= 0)
1153                                 break;
1154                 default:
1155                         return -EINVAL;
1156         }
1157         if (offset != file->f_pos) {
1158                 mutex_lock(&sysfs_mutex);
1159
1160                 file->f_pos = offset;
1161                 if (file->f_pos >= 2) {
1162                         struct sysfs_dirent *sd = dentry->d_fsdata;
1163                         struct sysfs_dirent *cursor = file->private_data;
1164                         struct sysfs_dirent **pos;
1165                         loff_t n = file->f_pos - 2;
1166
1167                         sysfs_unlink_sibling(cursor);
1168
1169                         pos = &sd->s_children;
1170                         while (n && *pos) {
1171                                 struct sysfs_dirent *next = *pos;
1172                                 if (sysfs_type(next))
1173                                         n--;
1174                                 pos = &(*pos)->s_sibling;
1175                         }
1176
1177                         cursor->s_sibling = *pos;
1178                         *pos = cursor;
1179                 }
1180
1181                 mutex_unlock(&sysfs_mutex);
1182         }
1183
1184         return offset;
1185 }
1186
1187 const struct file_operations sysfs_dir_operations = {
1188         .open           = sysfs_dir_open,
1189         .release        = sysfs_dir_close,
1190         .llseek         = sysfs_dir_lseek,
1191         .read           = generic_read_dir,
1192         .readdir        = sysfs_readdir,
1193 };