SAFE public projects git trees. - safe/jmp/linux-2.6/blob - fs/sysfs/dir.c

   1 /*
   2  * dir.c - Operations for sysfs directories.
   3  */
   4
   5 #undef DEBUG
   6
   7 #include <linux/fs.h>
   8 #include <linux/mount.h>
   9 #include <linux/module.h>
  10 #include <linux/kobject.h>
  11 #include <linux/namei.h>
  12 #include <linux/idr.h>
  13 #include <linux/completion.h>
  14 #include <asm/semaphore.h>
  15 #include "sysfs.h"
  16
  17 DECLARE_RWSEM(sysfs_rename_sem);
  18 spinlock_t sysfs_lock = SPIN_LOCK_UNLOCKED;
  19 spinlock_t kobj_sysfs_assoc_lock = SPIN_LOCK_UNLOCKED;
  20
  21 static spinlock_t sysfs_ino_lock = SPIN_LOCK_UNLOCKED;
  22 static DEFINE_IDA(sysfs_ino_ida);
  23
  24 /**
  25  *      sysfs_link_sibling - link sysfs_dirent into sibling list
  26  *      @sd: sysfs_dirent of interest
  27  *
  28  *      Link @sd into its sibling list which starts from
  29  *      sd->s_parent->s_children.
  30  *
  31  *      Locking:
  32  *      mutex_lock(sd->s_parent->dentry->d_inode->i_mutex)
  33  */
  34 static void sysfs_link_sibling(struct sysfs_dirent *sd)
  35 {
  36         struct sysfs_dirent *parent_sd = sd->s_parent;
  37
  38         BUG_ON(sd->s_sibling);
  39         sd->s_sibling = parent_sd->s_children;
  40         parent_sd->s_children = sd;
  41 }
  42
  43 /**
  44  *      sysfs_unlink_sibling - unlink sysfs_dirent from sibling list
  45  *      @sd: sysfs_dirent of interest
  46  *
  47  *      Unlink @sd from its sibling list which starts from
  48  *      sd->s_parent->s_children.
  49  *
  50  *      Locking:
  51  *      mutex_lock(sd->s_parent->dentry->d_inode->i_mutex)
  52  */
  53 static void sysfs_unlink_sibling(struct sysfs_dirent *sd)
  54 {
  55         struct sysfs_dirent **pos;
  56
  57         for (pos = &sd->s_parent->s_children; *pos; pos = &(*pos)->s_sibling) {
  58                 if (*pos == sd) {
  59                         *pos = sd->s_sibling;
  60                         sd->s_sibling = NULL;
  61                         break;
  62                 }
  63         }
  64 }
  65
  66 /**
  67  *      sysfs_get_active - get an active reference to sysfs_dirent
  68  *      @sd: sysfs_dirent to get an active reference to
  69  *
  70  *      Get an active reference of @sd.  This function is noop if @sd
  71  *      is NULL.
  72  *
  73  *      RETURNS:
  74  *      Pointer to @sd on success, NULL on failure.
  75  */
  76 struct sysfs_dirent *sysfs_get_active(struct sysfs_dirent *sd)
  77 {
  78         if (unlikely(!sd))
  79                 return NULL;
  80
  81         while (1) {
  82                 int v, t;
  83
  84                 v = atomic_read(&sd->s_active);
  85                 if (unlikely(v < 0))
  86                         return NULL;
  87
  88                 t = atomic_cmpxchg(&sd->s_active, v, v + 1);
  89                 if (likely(t == v))
  90                         return sd;
  91                 if (t < 0)
  92                         return NULL;
  93
  94                 cpu_relax();
  95         }
  96 }
  97
  98 /**
  99  *      sysfs_put_active - put an active reference to sysfs_dirent
 100  *      @sd: sysfs_dirent to put an active reference to
 101  *
 102  *      Put an active reference to @sd.  This function is noop if @sd
 103  *      is NULL.
 104  */
 105 void sysfs_put_active(struct sysfs_dirent *sd)
 106 {
 107         struct completion *cmpl;
 108         int v;
 109
 110         if (unlikely(!sd))
 111                 return;
 112
 113         v = atomic_dec_return(&sd->s_active);
 114         if (likely(v != SD_DEACTIVATED_BIAS))
 115                 return;
 116
 117         /* atomic_dec_return() is a mb(), we'll always see the updated
 118          * sd->s_sibling.
 119          */
 120         cmpl = (void *)sd->s_sibling;
 121         complete(cmpl);
 122 }
 123
 124 /**
 125  *      sysfs_get_active_two - get active references to sysfs_dirent and parent
 126  *      @sd: sysfs_dirent of interest
 127  *
 128  *      Get active reference to @sd and its parent.  Parent's active
 129  *      reference is grabbed first.  This function is noop if @sd is
 130  *      NULL.
 131  *
 132  *      RETURNS:
 133  *      Pointer to @sd on success, NULL on failure.
 134  */
 135 struct sysfs_dirent *sysfs_get_active_two(struct sysfs_dirent *sd)
 136 {
 137         if (sd) {
 138                 if (sd->s_parent && unlikely(!sysfs_get_active(sd->s_parent)))
 139                         return NULL;
 140                 if (unlikely(!sysfs_get_active(sd))) {
 141                         sysfs_put_active(sd->s_parent);
 142                         return NULL;
 143                 }
 144         }
 145         return sd;
 146 }
 147
 148 /**
 149  *      sysfs_put_active_two - put active references to sysfs_dirent and parent
 150  *      @sd: sysfs_dirent of interest
 151  *
 152  *      Put active references to @sd and its parent.  This function is
 153  *      noop if @sd is NULL.
 154  */
 155 void sysfs_put_active_two(struct sysfs_dirent *sd)
 156 {
 157         if (sd) {
 158                 sysfs_put_active(sd);
 159                 sysfs_put_active(sd->s_parent);
 160         }
 161 }
 162
 163 /**
 164  *      sysfs_deactivate - deactivate sysfs_dirent
 165  *      @sd: sysfs_dirent to deactivate
 166  *
 167  *      Deny new active references and drain existing ones.
 168  */
 169 void sysfs_deactivate(struct sysfs_dirent *sd)
 170 {
 171         DECLARE_COMPLETION_ONSTACK(wait);
 172         int v;
 173
 174         BUG_ON(sd->s_sibling || !(sd->s_flags & SYSFS_FLAG_REMOVED));
 175         sd->s_sibling = (void *)&wait;
 176
 177         /* atomic_add_return() is a mb(), put_active() will always see
 178          * the updated sd->s_sibling.
 179          */
 180         v = atomic_add_return(SD_DEACTIVATED_BIAS, &sd->s_active);
 181
 182         if (v != SD_DEACTIVATED_BIAS)
 183                 wait_for_completion(&wait);
 184
 185         sd->s_sibling = NULL;
 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         parent_sd = sd->s_parent;
 220
 221         if (sysfs_type(sd) == SYSFS_KOBJ_LINK)
 222                 sysfs_put(sd->s_elem.symlink.target_sd);
 223         if (sysfs_type(sd) & SYSFS_COPY_NAME)
 224                 kfree(sd->s_name);
 225         kfree(sd->s_iattr);
 226         sysfs_free_ino(sd->s_ino);
 227         kmem_cache_free(sysfs_dir_cachep, sd);
 228
 229         sd = parent_sd;
 230         if (sd && atomic_dec_and_test(&sd->s_count))
 231                 goto repeat;
 232 }
 233
 234 static void sysfs_d_iput(struct dentry * dentry, struct inode * inode)
 235 {
 236         struct sysfs_dirent * sd = dentry->d_fsdata;
 237
 238         if (sd) {
 239                 /* sd->s_dentry is protected with sysfs_lock.  This
 240                  * allows sysfs_drop_dentry() to dereference it.
 241                  */
 242                 spin_lock(&sysfs_lock);
 243
 244                 /* The dentry might have been deleted or another
 245                  * lookup could have happened updating sd->s_dentry to
 246                  * point the new dentry.  Ignore if it isn't pointing
 247                  * to this dentry.
 248                  */
 249                 if (sd->s_dentry == dentry)
 250                         sd->s_dentry = NULL;
 251                 spin_unlock(&sysfs_lock);
 252                 sysfs_put(sd);
 253         }
 254         iput(inode);
 255 }
 256
 257 static struct dentry_operations sysfs_dentry_ops = {
 258         .d_iput         = sysfs_d_iput,
 259 };
 260
 261 struct sysfs_dirent *sysfs_new_dirent(const char *name, umode_t mode, int type)
 262 {
 263         char *dup_name = NULL;
 264         struct sysfs_dirent *sd = NULL;
 265
 266         if (type & SYSFS_COPY_NAME) {
 267                 name = dup_name = kstrdup(name, GFP_KERNEL);
 268                 if (!name)
 269                         goto err_out;
 270         }
 271
 272         sd = kmem_cache_zalloc(sysfs_dir_cachep, GFP_KERNEL);
 273         if (!sd)
 274                 goto err_out;
 275
 276         if (sysfs_alloc_ino(&sd->s_ino))
 277                 goto err_out;
 278
 279         atomic_set(&sd->s_count, 1);
 280         atomic_set(&sd->s_active, 0);
 281         atomic_set(&sd->s_event, 1);
 282
 283         sd->s_name = name;
 284         sd->s_mode = mode;
 285         sd->s_flags = type;
 286
 287         return sd;
 288
 289  err_out:
 290         kfree(dup_name);
 291         kmem_cache_free(sysfs_dir_cachep, sd);
 292         return NULL;
 293 }
 294
 295 static void sysfs_attach_dentry(struct sysfs_dirent *sd, struct dentry *dentry)
 296 {
 297         dentry->d_op = &sysfs_dentry_ops;
 298         dentry->d_fsdata = sysfs_get(sd);
 299
 300         /* protect sd->s_dentry against sysfs_d_iput */
 301         spin_lock(&sysfs_lock);
 302         sd->s_dentry = dentry;
 303         spin_unlock(&sysfs_lock);
 304
 305         d_rehash(dentry);
 306 }
 307
 308 void sysfs_attach_dirent(struct sysfs_dirent *sd,
 309                          struct sysfs_dirent *parent_sd, struct dentry *dentry)
 310 {
 311         if (dentry)
 312                 sysfs_attach_dentry(sd, dentry);
 313
 314         if (parent_sd) {
 315                 sd->s_parent = sysfs_get(parent_sd);
 316                 sysfs_link_sibling(sd);
 317         }
 318 }
 319
 320 /**
 321  *      sysfs_find_dirent - find sysfs_dirent with the given name
 322  *      @parent_sd: sysfs_dirent to search under
 323  *      @name: name to look for
 324  *
 325  *      Look for sysfs_dirent with name @name under @parent_sd.
 326  *
 327  *      LOCKING:
 328  *      mutex_lock(parent->i_mutex)
 329  *
 330  *      RETURNS:
 331  *      Pointer to sysfs_dirent if found, NULL if not.
 332  */
 333 struct sysfs_dirent *sysfs_find_dirent(struct sysfs_dirent *parent_sd,
 334                                        const unsigned char *name)
 335 {
 336         struct sysfs_dirent *sd;
 337
 338         for (sd = parent_sd->s_children; sd; sd = sd->s_sibling)
 339                 if (sysfs_type(sd) && !strcmp(sd->s_name, name))
 340                         return sd;
 341         return NULL;
 342 }
 343
 344 /**
 345  *      sysfs_get_dirent - find and get sysfs_dirent with the given name
 346  *      @parent_sd: sysfs_dirent to search under
 347  *      @name: name to look for
 348  *
 349  *      Look for sysfs_dirent with name @name under @parent_sd and get
 350  *      it if found.
 351  *
 352  *      LOCKING:
 353  *      Kernel thread context (may sleep)
 354  *
 355  *      RETURNS:
 356  *      Pointer to sysfs_dirent if found, NULL if not.
 357  */
 358 struct sysfs_dirent *sysfs_get_dirent(struct sysfs_dirent *parent_sd,
 359                                       const unsigned char *name)
 360 {
 361         struct sysfs_dirent *sd;
 362
 363         mutex_lock(&parent_sd->s_dentry->d_inode->i_mutex);
 364         sd = sysfs_find_dirent(parent_sd, name);
 365         sysfs_get(sd);
 366         mutex_unlock(&parent_sd->s_dentry->d_inode->i_mutex);
 367
 368         return sd;
 369 }
 370
 371 static int create_dir(struct kobject *kobj, struct sysfs_dirent *parent_sd,
 372                       const char *name, struct sysfs_dirent **p_sd)
 373 {
 374         struct dentry *parent = parent_sd->s_dentry;
 375         int error;
 376         umode_t mode = S_IFDIR| S_IRWXU | S_IRUGO | S_IXUGO;
 377         struct dentry *dentry;
 378         struct inode *inode;
 379         struct sysfs_dirent *sd;
 380
 381         mutex_lock(&parent->d_inode->i_mutex);
 382
 383         /* allocate */
 384         dentry = lookup_one_len(name, parent, strlen(name));
 385         if (IS_ERR(dentry)) {
 386                 error = PTR_ERR(dentry);
 387                 goto out_unlock;
 388         }
 389
 390         error = -EEXIST;
 391         if (dentry->d_inode)
 392                 goto out_dput;
 393
 394         error = -ENOMEM;
 395         sd = sysfs_new_dirent(name, mode, SYSFS_DIR);
 396         if (!sd)
 397                 goto out_drop;
 398         sd->s_elem.dir.kobj = kobj;
 399
 400         inode = sysfs_get_inode(sd);
 401         if (!inode)
 402                 goto out_sput;
 403
 404         if (inode->i_state & I_NEW) {
 405                 inode->i_op = &sysfs_dir_inode_operations;
 406                 inode->i_fop = &sysfs_dir_operations;
 407                 /* directory inodes start off with i_nlink == 2 (for ".") */
 408                 inc_nlink(inode);
 409         }
 410
 411         /* link in */
 412         error = -EEXIST;
 413         if (sysfs_find_dirent(parent_sd, name))
 414                 goto out_iput;
 415
 416         sysfs_instantiate(dentry, inode);
 417         inc_nlink(parent->d_inode);
 418         sysfs_attach_dirent(sd, parent_sd, dentry);
 419
 420         *p_sd = sd;
 421         error = 0;
 422         goto out_unlock;        /* pin directory dentry in core */
 423
 424  out_iput:
 425         iput(inode);
 426  out_sput:
 427         sysfs_put(sd);
 428  out_drop:
 429         d_drop(dentry);
 430  out_dput:
 431         dput(dentry);
 432  out_unlock:
 433         mutex_unlock(&parent->d_inode->i_mutex);
 434         return error;
 435 }
 436
 437 int sysfs_create_subdir(struct kobject *kobj, const char *name,
 438                         struct sysfs_dirent **p_sd)
 439 {
 440         return create_dir(kobj, kobj->sd, name, p_sd);
 441 }
 442
 443 /**
 444  *      sysfs_create_dir - create a directory for an object.
 445  *      @kobj:          object we're creating directory for.
 446  *      @shadow_parent: parent object.
 447  */
 448 int sysfs_create_dir(struct kobject *kobj,
 449                      struct sysfs_dirent *shadow_parent_sd)
 450 {
 451         struct sysfs_dirent *parent_sd, *sd;
 452         int error = 0;
 453
 454         BUG_ON(!kobj);
 455
 456         if (shadow_parent_sd)
 457                 parent_sd = shadow_parent_sd;
 458         else if (kobj->parent)
 459                 parent_sd = kobj->parent->sd;
 460         else if (sysfs_mount && sysfs_mount->mnt_sb)
 461                 parent_sd = sysfs_mount->mnt_sb->s_root->d_fsdata;
 462         else
 463                 return -EFAULT;
 464
 465         error = create_dir(kobj, parent_sd, kobject_name(kobj), &sd);
 466         if (!error)
 467                 kobj->sd = sd;
 468         return error;
 469 }
 470
 471 static struct dentry * sysfs_lookup(struct inode *dir, struct dentry *dentry,
 472                                 struct nameidata *nd)
 473 {
 474         struct sysfs_dirent * parent_sd = dentry->d_parent->d_fsdata;
 475         struct sysfs_dirent * sd;
 476         struct bin_attribute *bin_attr;
 477         struct inode *inode;
 478         int found = 0;
 479
 480         for (sd = parent_sd->s_children; sd; sd = sd->s_sibling) {
 481                 if ((sysfs_type(sd) & SYSFS_NOT_PINNED) &&
 482                     !strcmp(sd->s_name, dentry->d_name.name)) {
 483                         found = 1;
 484                         break;
 485                 }
 486         }
 487
 488         /* no such entry */
 489         if (!found)
 490                 return NULL;
 491
 492         /* attach dentry and inode */
 493         inode = sysfs_get_inode(sd);
 494         if (!inode)
 495                 return ERR_PTR(-ENOMEM);
 496
 497         if (inode->i_state & I_NEW) {
 498                 /* initialize inode according to type */
 499                 switch (sysfs_type(sd)) {
 500                 case SYSFS_KOBJ_ATTR:
 501                         inode->i_size = PAGE_SIZE;
 502                         inode->i_fop = &sysfs_file_operations;
 503                         break;
 504                 case SYSFS_KOBJ_BIN_ATTR:
 505                         bin_attr = sd->s_elem.bin_attr.bin_attr;
 506                         inode->i_size = bin_attr->size;
 507                         inode->i_fop = &bin_fops;
 508                         break;
 509                 case SYSFS_KOBJ_LINK:
 510                         inode->i_op = &sysfs_symlink_inode_operations;
 511                         break;
 512                 default:
 513                         BUG();
 514                 }
 515         }
 516
 517         sysfs_instantiate(dentry, inode);
 518         sysfs_attach_dentry(sd, dentry);
 519
 520         return NULL;
 521 }
 522
 523 const struct inode_operations sysfs_dir_inode_operations = {
 524         .lookup         = sysfs_lookup,
 525         .setattr        = sysfs_setattr,
 526 };
 527
 528 static void remove_dir(struct sysfs_dirent *sd)
 529 {
 530         struct dentry *parent = sd->s_parent->s_dentry;
 531
 532         mutex_lock(&parent->d_inode->i_mutex);
 533
 534         sysfs_unlink_sibling(sd);
 535         sd->s_flags |= SYSFS_FLAG_REMOVED;
 536
 537         pr_debug(" o %s removing done\n", sd->s_name);
 538
 539         mutex_unlock(&parent->d_inode->i_mutex);
 540
 541         sysfs_drop_dentry(sd);
 542         sysfs_deactivate(sd);
 543         sysfs_put(sd);
 544 }
 545
 546 void sysfs_remove_subdir(struct sysfs_dirent *sd)
 547 {
 548         remove_dir(sd);
 549 }
 550
 551
 552 static void __sysfs_remove_dir(struct sysfs_dirent *dir_sd)
 553 {
 554         struct sysfs_dirent *removed = NULL;
 555         struct sysfs_dirent **pos;
 556         struct dentry *dir;
 557
 558         if (!dir_sd)
 559                 return;
 560
 561         dir = dir_sd->s_dentry;
 562
 563         pr_debug("sysfs %s: removing dir\n", dir_sd->s_name);
 564         mutex_lock(&dir->d_inode->i_mutex);
 565         pos = &dir_sd->s_children;
 566         while (*pos) {
 567                 struct sysfs_dirent *sd = *pos;
 568
 569                 if (sysfs_type(sd) && (sysfs_type(sd) & SYSFS_NOT_PINNED)) {
 570                         sd->s_flags |= SYSFS_FLAG_REMOVED;
 571                         *pos = sd->s_sibling;
 572                         sd->s_sibling = removed;
 573                         removed = sd;
 574                 } else
 575                         pos = &(*pos)->s_sibling;
 576         }
 577         mutex_unlock(&dir->d_inode->i_mutex);
 578
 579         while (removed) {
 580                 struct sysfs_dirent *sd = removed;
 581
 582                 removed = sd->s_sibling;
 583                 sd->s_sibling = NULL;
 584
 585                 sysfs_drop_dentry(sd);
 586                 sysfs_deactivate(sd);
 587                 sysfs_put(sd);
 588         }
 589
 590         remove_dir(dir_sd);
 591 }
 592
 593 /**
 594  *      sysfs_remove_dir - remove an object's directory.
 595  *      @kobj:  object.
 596  *
 597  *      The only thing special about this is that we remove any files in
 598  *      the directory before we remove the directory, and we've inlined
 599  *      what used to be sysfs_rmdir() below, instead of calling separately.
 600  */
 601
 602 void sysfs_remove_dir(struct kobject * kobj)
 603 {
 604         struct sysfs_dirent *sd = kobj->sd;
 605
 606         spin_lock(&kobj_sysfs_assoc_lock);
 607         kobj->sd = NULL;
 608         spin_unlock(&kobj_sysfs_assoc_lock);
 609
 610         __sysfs_remove_dir(sd);
 611 }
 612
 613 int sysfs_rename_dir(struct kobject *kobj, struct sysfs_dirent *new_parent_sd,
 614                      const char *new_name)
 615 {
 616         struct sysfs_dirent *sd = kobj->sd;
 617         struct dentry *new_parent = new_parent_sd->s_dentry;
 618         struct dentry *new_dentry;
 619         char *dup_name;
 620         int error;
 621
 622         if (!new_parent_sd)
 623                 return -EFAULT;
 624
 625         down_write(&sysfs_rename_sem);
 626         mutex_lock(&new_parent->d_inode->i_mutex);
 627
 628         new_dentry = lookup_one_len(new_name, new_parent, strlen(new_name));
 629         if (IS_ERR(new_dentry)) {
 630                 error = PTR_ERR(new_dentry);
 631                 goto out_unlock;
 632         }
 633
 634         /* By allowing two different directories with the same
 635          * d_parent we allow this routine to move between different
 636          * shadows of the same directory
 637          */
 638         error = -EINVAL;
 639         if (sd->s_parent->s_dentry->d_inode != new_parent->d_inode ||
 640             new_dentry->d_parent->d_inode != new_parent->d_inode ||
 641             new_dentry == sd->s_dentry)
 642                 goto out_dput;
 643
 644         error = -EEXIST;
 645         if (new_dentry->d_inode)
 646                 goto out_dput;
 647
 648         /* rename kobject and sysfs_dirent */
 649         error = -ENOMEM;
 650         new_name = dup_name = kstrdup(new_name, GFP_KERNEL);
 651         if (!new_name)
 652                 goto out_drop;
 653
 654         error = kobject_set_name(kobj, "%s", new_name);
 655         if (error)
 656                 goto out_free;
 657
 658         kfree(sd->s_name);
 659         sd->s_name = new_name;
 660
 661         /* move under the new parent */
 662         d_add(new_dentry, NULL);
 663         d_move(sd->s_dentry, new_dentry);
 664
 665         sysfs_unlink_sibling(sd);
 666         sysfs_get(new_parent_sd);
 667         sysfs_put(sd->s_parent);
 668         sd->s_parent = new_parent_sd;
 669         sysfs_link_sibling(sd);
 670
 671         error = 0;
 672         goto out_unlock;
 673
 674  out_free:
 675         kfree(dup_name);
 676  out_drop:
 677         d_drop(new_dentry);
 678  out_dput:
 679         dput(new_dentry);
 680  out_unlock:
 681         mutex_unlock(&new_parent->d_inode->i_mutex);
 682         up_write(&sysfs_rename_sem);
 683         return error;
 684 }
 685
 686 int sysfs_move_dir(struct kobject *kobj, struct kobject *new_parent)
 687 {
 688         struct dentry *old_parent_dentry, *new_parent_dentry, *new_dentry;
 689         struct sysfs_dirent *new_parent_sd, *sd;
 690         int error;
 691
 692         old_parent_dentry = kobj->parent ?
 693                 kobj->parent->sd->s_dentry : sysfs_mount->mnt_sb->s_root;
 694         new_parent_dentry = new_parent ?
 695                 new_parent->sd->s_dentry : sysfs_mount->mnt_sb->s_root;
 696
 697         if (old_parent_dentry->d_inode == new_parent_dentry->d_inode)
 698                 return 0;       /* nothing to move */
 699 again:
 700         mutex_lock(&old_parent_dentry->d_inode->i_mutex);
 701         if (!mutex_trylock(&new_parent_dentry->d_inode->i_mutex)) {
 702                 mutex_unlock(&old_parent_dentry->d_inode->i_mutex);
 703                 goto again;
 704         }
 705
 706         new_parent_sd = new_parent_dentry->d_fsdata;
 707         sd = kobj->sd;
 708
 709         new_dentry = lookup_one_len(kobj->name, new_parent_dentry,
 710                                     strlen(kobj->name));
 711         if (IS_ERR(new_dentry)) {
 712                 error = PTR_ERR(new_dentry);
 713                 goto out;
 714         } else
 715                 error = 0;
 716         d_add(new_dentry, NULL);
 717         d_move(sd->s_dentry, new_dentry);
 718         dput(new_dentry);
 719
 720         /* Remove from old parent's list and insert into new parent's list. */
 721         sysfs_unlink_sibling(sd);
 722         sysfs_get(new_parent_sd);
 723         sysfs_put(sd->s_parent);
 724         sd->s_parent = new_parent_sd;
 725         sysfs_link_sibling(sd);
 726
 727 out:
 728         mutex_unlock(&new_parent_dentry->d_inode->i_mutex);
 729         mutex_unlock(&old_parent_dentry->d_inode->i_mutex);
 730
 731         return error;
 732 }
 733
 734 static int sysfs_dir_open(struct inode *inode, struct file *file)
 735 {
 736         struct dentry * dentry = file->f_path.dentry;
 737         struct sysfs_dirent * parent_sd = dentry->d_fsdata;
 738         struct sysfs_dirent * sd;
 739
 740         mutex_lock(&dentry->d_inode->i_mutex);
 741         sd = sysfs_new_dirent("_DIR_", 0, 0);
 742         if (sd)
 743                 sysfs_attach_dirent(sd, parent_sd, NULL);
 744         mutex_unlock(&dentry->d_inode->i_mutex);
 745
 746         file->private_data = sd;
 747         return sd ? 0 : -ENOMEM;
 748 }
 749
 750 static int sysfs_dir_close(struct inode *inode, struct file *file)
 751 {
 752         struct dentry * dentry = file->f_path.dentry;
 753         struct sysfs_dirent * cursor = file->private_data;
 754
 755         mutex_lock(&dentry->d_inode->i_mutex);
 756         sysfs_unlink_sibling(cursor);
 757         mutex_unlock(&dentry->d_inode->i_mutex);
 758
 759         release_sysfs_dirent(cursor);
 760
 761         return 0;
 762 }
 763
 764 /* Relationship between s_mode and the DT_xxx types */
 765 static inline unsigned char dt_type(struct sysfs_dirent *sd)
 766 {
 767         return (sd->s_mode >> 12) & 15;
 768 }
 769
 770 static int sysfs_readdir(struct file * filp, void * dirent, filldir_t filldir)
 771 {
 772         struct dentry *dentry = filp->f_path.dentry;
 773         struct sysfs_dirent * parent_sd = dentry->d_fsdata;
 774         struct sysfs_dirent *cursor = filp->private_data;
 775         struct sysfs_dirent **pos;
 776         ino_t ino;
 777         int i = filp->f_pos;
 778
 779         switch (i) {
 780                 case 0:
 781                         ino = parent_sd->s_ino;
 782                         if (filldir(dirent, ".", 1, i, ino, DT_DIR) < 0)
 783                                 break;
 784                         filp->f_pos++;
 785                         i++;
 786                         /* fallthrough */
 787                 case 1:
 788                         if (parent_sd->s_parent)
 789                                 ino = parent_sd->s_parent->s_ino;
 790                         else
 791                                 ino = parent_sd->s_ino;
 792                         if (filldir(dirent, "..", 2, i, ino, DT_DIR) < 0)
 793                                 break;
 794                         filp->f_pos++;
 795                         i++;
 796                         /* fallthrough */
 797                 default:
 798                         pos = &parent_sd->s_children;
 799                         while (*pos != cursor)
 800                                 pos = &(*pos)->s_sibling;
 801
 802                         /* unlink cursor */
 803                         *pos = cursor->s_sibling;
 804
 805                         if (filp->f_pos == 2)
 806                                 pos = &parent_sd->s_children;
 807
 808                         for ( ; *pos; pos = &(*pos)->s_sibling) {
 809                                 struct sysfs_dirent *next = *pos;
 810                                 const char * name;
 811                                 int len;
 812
 813                                 if (!sysfs_type(next))
 814                                         continue;
 815
 816                                 name = next->s_name;
 817                                 len = strlen(name);
 818                                 ino = next->s_ino;
 819
 820                                 if (filldir(dirent, name, len, filp->f_pos, ino,
 821                                                  dt_type(next)) < 0)
 822                                         break;
 823
 824                                 filp->f_pos++;
 825                         }
 826
 827                         /* put cursor back in */
 828                         cursor->s_sibling = *pos;
 829                         *pos = cursor;
 830         }
 831         return 0;
 832 }
 833
 834 static loff_t sysfs_dir_lseek(struct file * file, loff_t offset, int origin)
 835 {
 836         struct dentry * dentry = file->f_path.dentry;
 837
 838         mutex_lock(&dentry->d_inode->i_mutex);
 839         switch (origin) {
 840                 case 1:
 841                         offset += file->f_pos;
 842                 case 0:
 843                         if (offset >= 0)
 844                                 break;
 845                 default:
 846                         mutex_unlock(&file->f_path.dentry->d_inode->i_mutex);
 847                         return -EINVAL;
 848         }
 849         if (offset != file->f_pos) {
 850                 file->f_pos = offset;
 851                 if (file->f_pos >= 2) {
 852                         struct sysfs_dirent *sd = dentry->d_fsdata;
 853                         struct sysfs_dirent *cursor = file->private_data;
 854                         struct sysfs_dirent **pos;
 855                         loff_t n = file->f_pos - 2;
 856
 857                         sysfs_unlink_sibling(cursor);
 858
 859                         pos = &sd->s_children;
 860                         while (n && *pos) {
 861                                 struct sysfs_dirent *next = *pos;
 862                                 if (sysfs_type(next))
 863                                         n--;
 864                                 pos = &(*pos)->s_sibling;
 865                         }
 866
 867                         cursor->s_sibling = *pos;
 868                         *pos = cursor;
 869                 }
 870         }
 871         mutex_unlock(&dentry->d_inode->i_mutex);
 872         return offset;
 873 }
 874
 875
 876 /**
 877  *      sysfs_make_shadowed_dir - Setup so a directory can be shadowed
 878  *      @kobj:  object we're creating shadow of.
 879  */
 880
 881 int sysfs_make_shadowed_dir(struct kobject *kobj,
 882         void * (*follow_link)(struct dentry *, struct nameidata *))
 883 {
 884         struct inode *inode;
 885         struct inode_operations *i_op;
 886
 887         inode = kobj->sd->s_dentry->d_inode;
 888         if (inode->i_op != &sysfs_dir_inode_operations)
 889                 return -EINVAL;
 890
 891         i_op = kmalloc(sizeof(*i_op), GFP_KERNEL);
 892         if (!i_op)
 893                 return -ENOMEM;
 894
 895         memcpy(i_op, &sysfs_dir_inode_operations, sizeof(*i_op));
 896         i_op->follow_link = follow_link;
 897
 898         /* Locking of inode->i_op?
 899          * Since setting i_op is a single word write and they
 900          * are atomic we should be ok here.
 901          */
 902         inode->i_op = i_op;
 903         return 0;
 904 }
 905
 906 /**
 907  *      sysfs_create_shadow_dir - create a shadow directory for an object.
 908  *      @kobj:  object we're creating directory for.
 909  *
 910  *      sysfs_make_shadowed_dir must already have been called on this
 911  *      directory.
 912  */
 913
 914 struct sysfs_dirent *sysfs_create_shadow_dir(struct kobject *kobj)
 915 {
 916         struct dentry *dir = kobj->sd->s_dentry;
 917         struct inode *inode = dir->d_inode;
 918         struct dentry *parent = dir->d_parent;
 919         struct sysfs_dirent *parent_sd = parent->d_fsdata;
 920         struct dentry *shadow;
 921         struct sysfs_dirent *sd;
 922
 923         sd = ERR_PTR(-EINVAL);
 924         if (!sysfs_is_shadowed_inode(inode))
 925                 goto out;
 926
 927         shadow = d_alloc(parent, &dir->d_name);
 928         if (!shadow)
 929                 goto nomem;
 930
 931         sd = sysfs_new_dirent("_SHADOW_", inode->i_mode, SYSFS_DIR);
 932         if (!sd)
 933                 goto nomem;
 934         sd->s_elem.dir.kobj = kobj;
 935         /* point to parent_sd but don't attach to it */
 936         sd->s_parent = sysfs_get(parent_sd);
 937         sysfs_attach_dirent(sd, NULL, shadow);
 938
 939         d_instantiate(shadow, igrab(inode));
 940         inc_nlink(inode);
 941         inc_nlink(parent->d_inode);
 942
 943         dget(shadow);           /* Extra count - pin the dentry in core */
 944
 945 out:
 946         return sd;
 947 nomem:
 948         dput(shadow);
 949         sd = ERR_PTR(-ENOMEM);
 950         goto out;
 951 }
 952
 953 /**
 954  *      sysfs_remove_shadow_dir - remove an object's directory.
 955  *      @shadow_sd: sysfs_dirent of shadow directory
 956  *
 957  *      The only thing special about this is that we remove any files in
 958  *      the directory before we remove the directory, and we've inlined
 959  *      what used to be sysfs_rmdir() below, instead of calling separately.
 960  */
 961
 962 void sysfs_remove_shadow_dir(struct sysfs_dirent *shadow_sd)
 963 {
 964         __sysfs_remove_dir(shadow_sd);
 965 }
 966
 967 const struct file_operations sysfs_dir_operations = {
 968         .open           = sysfs_dir_open,
 969         .release        = sysfs_dir_close,
 970         .llseek         = sysfs_dir_lseek,
 971         .read           = generic_read_dir,
 972         .readdir        = sysfs_readdir,
 973 };