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