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