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