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 <asm/semaphore.h>
  14 #include "sysfs.h"
  15
  16 DECLARE_RWSEM(sysfs_rename_sem);
  17 spinlock_t sysfs_lock = SPIN_LOCK_UNLOCKED;
  18
  19 static spinlock_t sysfs_ino_lock = SPIN_LOCK_UNLOCKED;
  20 static DEFINE_IDA(sysfs_ino_ida);
  21
  22 int sysfs_alloc_ino(ino_t *pino)
  23 {
  24         int ino, rc;
  25
  26  retry:
  27         spin_lock(&sysfs_ino_lock);
  28         rc = ida_get_new_above(&sysfs_ino_ida, 2, &ino);
  29         spin_unlock(&sysfs_ino_lock);
  30
  31         if (rc == -EAGAIN) {
  32                 if (ida_pre_get(&sysfs_ino_ida, GFP_KERNEL))
  33                         goto retry;
  34                 rc = -ENOMEM;
  35         }
  36
  37         *pino = ino;
  38         return rc;
  39 }
  40
  41 static void sysfs_free_ino(ino_t ino)
  42 {
  43         spin_lock(&sysfs_ino_lock);
  44         ida_remove(&sysfs_ino_ida, ino);
  45         spin_unlock(&sysfs_ino_lock);
  46 }
  47
  48 void release_sysfs_dirent(struct sysfs_dirent * sd)
  49 {
  50         if (sd->s_type & SYSFS_KOBJ_LINK) {
  51                 struct sysfs_symlink * sl = sd->s_element;
  52                 kfree(sl->link_name);
  53                 kobject_put(sl->target_kobj);
  54                 kfree(sl);
  55         }
  56         kfree(sd->s_iattr);
  57         sysfs_free_ino(sd->s_ino);
  58         kmem_cache_free(sysfs_dir_cachep, sd);
  59 }
  60
  61 static void sysfs_d_iput(struct dentry * dentry, struct inode * inode)
  62 {
  63         struct sysfs_dirent * sd = dentry->d_fsdata;
  64
  65         if (sd) {
  66                 /* sd->s_dentry is protected with sysfs_lock.  This
  67                  * allows sysfs_drop_dentry() to dereference it.
  68                  */
  69                 spin_lock(&sysfs_lock);
  70
  71                 /* The dentry might have been deleted or another
  72                  * lookup could have happened updating sd->s_dentry to
  73                  * point the new dentry.  Ignore if it isn't pointing
  74                  * to this dentry.
  75                  */
  76                 if (sd->s_dentry == dentry)
  77                         sd->s_dentry = NULL;
  78                 spin_unlock(&sysfs_lock);
  79                 sysfs_put(sd);
  80         }
  81         iput(inode);
  82 }
  83
  84 static struct dentry_operations sysfs_dentry_ops = {
  85         .d_iput         = sysfs_d_iput,
  86 };
  87
  88 /*
  89  * Allocates a new sysfs_dirent and links it to the parent sysfs_dirent
  90  */
  91 static struct sysfs_dirent * __sysfs_new_dirent(void * element)
  92 {
  93         struct sysfs_dirent * sd;
  94
  95         sd = kmem_cache_zalloc(sysfs_dir_cachep, GFP_KERNEL);
  96         if (!sd)
  97                 return NULL;
  98
  99         if (sysfs_alloc_ino(&sd->s_ino)) {
 100                 kmem_cache_free(sysfs_dir_cachep, sd);
 101                 return NULL;
 102         }
 103
 104         atomic_set(&sd->s_count, 1);
 105         atomic_set(&sd->s_event, 1);
 106         INIT_LIST_HEAD(&sd->s_children);
 107         INIT_LIST_HEAD(&sd->s_sibling);
 108         sd->s_element = element;
 109
 110         return sd;
 111 }
 112
 113 static void __sysfs_list_dirent(struct sysfs_dirent *parent_sd,
 114                               struct sysfs_dirent *sd)
 115 {
 116         if (sd)
 117                 list_add(&sd->s_sibling, &parent_sd->s_children);
 118 }
 119
 120 static struct sysfs_dirent * sysfs_new_dirent(struct sysfs_dirent *parent_sd,
 121                                                 void * element)
 122 {
 123         struct sysfs_dirent *sd;
 124         sd = __sysfs_new_dirent(element);
 125         __sysfs_list_dirent(parent_sd, sd);
 126         return sd;
 127 }
 128
 129 /*
 130  *
 131  * Return -EEXIST if there is already a sysfs element with the same name for
 132  * the same parent.
 133  *
 134  * called with parent inode's i_mutex held
 135  */
 136 int sysfs_dirent_exist(struct sysfs_dirent *parent_sd,
 137                           const unsigned char *new)
 138 {
 139         struct sysfs_dirent * sd;
 140
 141         list_for_each_entry(sd, &parent_sd->s_children, s_sibling) {
 142                 if (sd->s_element) {
 143                         const unsigned char *existing = sysfs_get_name(sd);
 144                         if (strcmp(existing, new))
 145                                 continue;
 146                         else
 147                                 return -EEXIST;
 148                 }
 149         }
 150
 151         return 0;
 152 }
 153
 154
 155 static struct sysfs_dirent *
 156 __sysfs_make_dirent(struct dentry *dentry, void *element, mode_t mode, int type)
 157 {
 158         struct sysfs_dirent * sd;
 159
 160         sd = __sysfs_new_dirent(element);
 161         if (!sd)
 162                 goto out;
 163
 164         sd->s_mode = mode;
 165         sd->s_type = type;
 166         sd->s_dentry = dentry;
 167         if (dentry) {
 168                 dentry->d_fsdata = sysfs_get(sd);
 169                 dentry->d_op = &sysfs_dentry_ops;
 170         }
 171
 172 out:
 173         return sd;
 174 }
 175
 176 int sysfs_make_dirent(struct sysfs_dirent * parent_sd, struct dentry * dentry,
 177                         void * element, umode_t mode, int type)
 178 {
 179         struct sysfs_dirent *sd;
 180
 181         sd = __sysfs_make_dirent(dentry, element, mode, type);
 182         __sysfs_list_dirent(parent_sd, sd);
 183
 184         return sd ? 0 : -ENOMEM;
 185 }
 186
 187 static int init_dir(struct inode * inode)
 188 {
 189         inode->i_op = &sysfs_dir_inode_operations;
 190         inode->i_fop = &sysfs_dir_operations;
 191
 192         /* directory inodes start off with i_nlink == 2 (for "." entry) */
 193         inc_nlink(inode);
 194         return 0;
 195 }
 196
 197 static int init_file(struct inode * inode)
 198 {
 199         inode->i_size = PAGE_SIZE;
 200         inode->i_fop = &sysfs_file_operations;
 201         return 0;
 202 }
 203
 204 static int init_symlink(struct inode * inode)
 205 {
 206         inode->i_op = &sysfs_symlink_inode_operations;
 207         return 0;
 208 }
 209
 210 static int create_dir(struct kobject * k, struct dentry * p,
 211                       const char * n, struct dentry ** d)
 212 {
 213         int error;
 214         umode_t mode = S_IFDIR| S_IRWXU | S_IRUGO | S_IXUGO;
 215
 216         mutex_lock(&p->d_inode->i_mutex);
 217         *d = lookup_one_len(n, p, strlen(n));
 218         if (!IS_ERR(*d)) {
 219                 if (sysfs_dirent_exist(p->d_fsdata, n))
 220                         error = -EEXIST;
 221                 else
 222                         error = sysfs_make_dirent(p->d_fsdata, *d, k, mode,
 223                                                                 SYSFS_DIR);
 224                 if (!error) {
 225                         error = sysfs_create(*d, mode, init_dir);
 226                         if (!error) {
 227                                 inc_nlink(p->d_inode);
 228                                 (*d)->d_op = &sysfs_dentry_ops;
 229                                 d_rehash(*d);
 230                         }
 231                 }
 232                 if (error && (error != -EEXIST)) {
 233                         struct sysfs_dirent *sd = (*d)->d_fsdata;
 234                         if (sd) {
 235                                 list_del_init(&sd->s_sibling);
 236                                 sysfs_put(sd);
 237                         }
 238                         d_drop(*d);
 239                 }
 240                 dput(*d);
 241         } else
 242                 error = PTR_ERR(*d);
 243         mutex_unlock(&p->d_inode->i_mutex);
 244         return error;
 245 }
 246
 247
 248 int sysfs_create_subdir(struct kobject * k, const char * n, struct dentry ** d)
 249 {
 250         return create_dir(k,k->dentry,n,d);
 251 }
 252
 253 /**
 254  *      sysfs_create_dir - create a directory for an object.
 255  *      @kobj:          object we're creating directory for.
 256  *      @shadow_parent: parent parent object.
 257  */
 258
 259 int sysfs_create_dir(struct kobject * kobj, struct dentry *shadow_parent)
 260 {
 261         struct dentry * dentry = NULL;
 262         struct dentry * parent;
 263         int error = 0;
 264
 265         BUG_ON(!kobj);
 266
 267         if (shadow_parent)
 268                 parent = shadow_parent;
 269         else if (kobj->parent)
 270                 parent = kobj->parent->dentry;
 271         else if (sysfs_mount && sysfs_mount->mnt_sb)
 272                 parent = sysfs_mount->mnt_sb->s_root;
 273         else
 274                 return -EFAULT;
 275
 276         error = create_dir(kobj,parent,kobject_name(kobj),&dentry);
 277         if (!error)
 278                 kobj->dentry = dentry;
 279         return error;
 280 }
 281
 282 /* attaches attribute's sysfs_dirent to the dentry corresponding to the
 283  * attribute file
 284  */
 285 static int sysfs_attach_attr(struct sysfs_dirent * sd, struct dentry * dentry)
 286 {
 287         struct attribute * attr = NULL;
 288         struct bin_attribute * bin_attr = NULL;
 289         int (* init) (struct inode *) = NULL;
 290         int error = 0;
 291
 292         if (sd->s_type & SYSFS_KOBJ_BIN_ATTR) {
 293                 bin_attr = sd->s_element;
 294                 attr = &bin_attr->attr;
 295         } else {
 296                 attr = sd->s_element;
 297                 init = init_file;
 298         }
 299
 300         dentry->d_fsdata = sysfs_get(sd);
 301         /* protect sd->s_dentry against sysfs_d_iput */
 302         spin_lock(&sysfs_lock);
 303         sd->s_dentry = dentry;
 304         spin_unlock(&sysfs_lock);
 305         error = sysfs_create(dentry, (attr->mode & S_IALLUGO) | S_IFREG, init);
 306         if (error) {
 307                 sysfs_put(sd);
 308                 return error;
 309         }
 310
 311         if (bin_attr) {
 312                 dentry->d_inode->i_size = bin_attr->size;
 313                 dentry->d_inode->i_fop = &bin_fops;
 314         }
 315         dentry->d_op = &sysfs_dentry_ops;
 316         d_rehash(dentry);
 317
 318         return 0;
 319 }
 320
 321 static int sysfs_attach_link(struct sysfs_dirent * sd, struct dentry * dentry)
 322 {
 323         int err = 0;
 324
 325         dentry->d_fsdata = sysfs_get(sd);
 326         /* protect sd->s_dentry against sysfs_d_iput */
 327         spin_lock(&sysfs_lock);
 328         sd->s_dentry = dentry;
 329         spin_unlock(&sysfs_lock);
 330         err = sysfs_create(dentry, S_IFLNK|S_IRWXUGO, init_symlink);
 331         if (!err) {
 332                 dentry->d_op = &sysfs_dentry_ops;
 333                 d_rehash(dentry);
 334         } else
 335                 sysfs_put(sd);
 336
 337         return err;
 338 }
 339
 340 static struct dentry * sysfs_lookup(struct inode *dir, struct dentry *dentry,
 341                                 struct nameidata *nd)
 342 {
 343         struct sysfs_dirent * parent_sd = dentry->d_parent->d_fsdata;
 344         struct sysfs_dirent * sd;
 345         int err = 0;
 346
 347         list_for_each_entry(sd, &parent_sd->s_children, s_sibling) {
 348                 if (sd->s_type & SYSFS_NOT_PINNED) {
 349                         const unsigned char * name = sysfs_get_name(sd);
 350
 351                         if (strcmp(name, dentry->d_name.name))
 352                                 continue;
 353
 354                         if (sd->s_type & SYSFS_KOBJ_LINK)
 355                                 err = sysfs_attach_link(sd, dentry);
 356                         else
 357                                 err = sysfs_attach_attr(sd, dentry);
 358                         break;
 359                 }
 360         }
 361
 362         return ERR_PTR(err);
 363 }
 364
 365 const struct inode_operations sysfs_dir_inode_operations = {
 366         .lookup         = sysfs_lookup,
 367         .setattr        = sysfs_setattr,
 368 };
 369
 370 static void remove_dir(struct dentry * d)
 371 {
 372         struct dentry * parent = dget(d->d_parent);
 373         struct sysfs_dirent * sd;
 374
 375         mutex_lock(&parent->d_inode->i_mutex);
 376         d_delete(d);
 377         sd = d->d_fsdata;
 378         list_del_init(&sd->s_sibling);
 379         sysfs_put(sd);
 380         if (d->d_inode)
 381                 simple_rmdir(parent->d_inode,d);
 382
 383         pr_debug(" o %s removing done (%d)\n",d->d_name.name,
 384                  atomic_read(&d->d_count));
 385
 386         mutex_unlock(&parent->d_inode->i_mutex);
 387         dput(parent);
 388 }
 389
 390 void sysfs_remove_subdir(struct dentry * d)
 391 {
 392         remove_dir(d);
 393 }
 394
 395
 396 static void __sysfs_remove_dir(struct dentry *dentry)
 397 {
 398         struct sysfs_dirent * parent_sd;
 399         struct sysfs_dirent * sd, * tmp;
 400
 401         dget(dentry);
 402         if (!dentry)
 403                 return;
 404
 405         pr_debug("sysfs %s: removing dir\n",dentry->d_name.name);
 406         mutex_lock(&dentry->d_inode->i_mutex);
 407         parent_sd = dentry->d_fsdata;
 408         list_for_each_entry_safe(sd, tmp, &parent_sd->s_children, s_sibling) {
 409                 if (!sd->s_element || !(sd->s_type & SYSFS_NOT_PINNED))
 410                         continue;
 411                 list_del_init(&sd->s_sibling);
 412                 sysfs_drop_dentry(sd, dentry);
 413                 sysfs_put(sd);
 414         }
 415         mutex_unlock(&dentry->d_inode->i_mutex);
 416
 417         remove_dir(dentry);
 418         /**
 419          * Drop reference from dget() on entrance.
 420          */
 421         dput(dentry);
 422 }
 423
 424 /**
 425  *      sysfs_remove_dir - remove an object's directory.
 426  *      @kobj:  object.
 427  *
 428  *      The only thing special about this is that we remove any files in
 429  *      the directory before we remove the directory, and we've inlined
 430  *      what used to be sysfs_rmdir() below, instead of calling separately.
 431  */
 432
 433 void sysfs_remove_dir(struct kobject * kobj)
 434 {
 435         __sysfs_remove_dir(kobj->dentry);
 436         kobj->dentry = NULL;
 437 }
 438
 439 int sysfs_rename_dir(struct kobject * kobj, struct dentry *new_parent,
 440                      const char *new_name)
 441 {
 442         int error = 0;
 443         struct dentry * new_dentry;
 444
 445         if (!new_parent)
 446                 return -EFAULT;
 447
 448         down_write(&sysfs_rename_sem);
 449         mutex_lock(&new_parent->d_inode->i_mutex);
 450
 451         new_dentry = lookup_one_len(new_name, new_parent, strlen(new_name));
 452         if (!IS_ERR(new_dentry)) {
 453                 /* By allowing two different directories with the
 454                  * same d_parent we allow this routine to move
 455                  * between different shadows of the same directory
 456                  */
 457                 if (kobj->dentry->d_parent->d_inode != new_parent->d_inode)
 458                         return -EINVAL;
 459                 else if (new_dentry->d_parent->d_inode != new_parent->d_inode)
 460                         error = -EINVAL;
 461                 else if (new_dentry == kobj->dentry)
 462                         error = -EINVAL;
 463                 else if (!new_dentry->d_inode) {
 464                         error = kobject_set_name(kobj, "%s", new_name);
 465                         if (!error) {
 466                                 struct sysfs_dirent *sd, *parent_sd;
 467
 468                                 d_add(new_dentry, NULL);
 469                                 d_move(kobj->dentry, new_dentry);
 470
 471                                 sd = kobj->dentry->d_fsdata;
 472                                 parent_sd = new_parent->d_fsdata;
 473
 474                                 list_del_init(&sd->s_sibling);
 475                                 list_add(&sd->s_sibling, &parent_sd->s_children);
 476                         }
 477                         else
 478                                 d_drop(new_dentry);
 479                 } else
 480                         error = -EEXIST;
 481                 dput(new_dentry);
 482         }
 483         mutex_unlock(&new_parent->d_inode->i_mutex);
 484         up_write(&sysfs_rename_sem);
 485
 486         return error;
 487 }
 488
 489 int sysfs_move_dir(struct kobject *kobj, struct kobject *new_parent)
 490 {
 491         struct dentry *old_parent_dentry, *new_parent_dentry, *new_dentry;
 492         struct sysfs_dirent *new_parent_sd, *sd;
 493         int error;
 494
 495         old_parent_dentry = kobj->parent ?
 496                 kobj->parent->dentry : sysfs_mount->mnt_sb->s_root;
 497         new_parent_dentry = new_parent ?
 498                 new_parent->dentry : sysfs_mount->mnt_sb->s_root;
 499
 500         if (old_parent_dentry->d_inode == new_parent_dentry->d_inode)
 501                 return 0;       /* nothing to move */
 502 again:
 503         mutex_lock(&old_parent_dentry->d_inode->i_mutex);
 504         if (!mutex_trylock(&new_parent_dentry->d_inode->i_mutex)) {
 505                 mutex_unlock(&old_parent_dentry->d_inode->i_mutex);
 506                 goto again;
 507         }
 508
 509         new_parent_sd = new_parent_dentry->d_fsdata;
 510         sd = kobj->dentry->d_fsdata;
 511
 512         new_dentry = lookup_one_len(kobj->name, new_parent_dentry,
 513                                     strlen(kobj->name));
 514         if (IS_ERR(new_dentry)) {
 515                 error = PTR_ERR(new_dentry);
 516                 goto out;
 517         } else
 518                 error = 0;
 519         d_add(new_dentry, NULL);
 520         d_move(kobj->dentry, new_dentry);
 521         dput(new_dentry);
 522
 523         /* Remove from old parent's list and insert into new parent's list. */
 524         list_del_init(&sd->s_sibling);
 525         list_add(&sd->s_sibling, &new_parent_sd->s_children);
 526
 527 out:
 528         mutex_unlock(&new_parent_dentry->d_inode->i_mutex);
 529         mutex_unlock(&old_parent_dentry->d_inode->i_mutex);
 530
 531         return error;
 532 }
 533
 534 static int sysfs_dir_open(struct inode *inode, struct file *file)
 535 {
 536         struct dentry * dentry = file->f_path.dentry;
 537         struct sysfs_dirent * parent_sd = dentry->d_fsdata;
 538
 539         mutex_lock(&dentry->d_inode->i_mutex);
 540         file->private_data = sysfs_new_dirent(parent_sd, NULL);
 541         mutex_unlock(&dentry->d_inode->i_mutex);
 542
 543         return file->private_data ? 0 : -ENOMEM;
 544
 545 }
 546
 547 static int sysfs_dir_close(struct inode *inode, struct file *file)
 548 {
 549         struct dentry * dentry = file->f_path.dentry;
 550         struct sysfs_dirent * cursor = file->private_data;
 551
 552         mutex_lock(&dentry->d_inode->i_mutex);
 553         list_del_init(&cursor->s_sibling);
 554         mutex_unlock(&dentry->d_inode->i_mutex);
 555
 556         release_sysfs_dirent(cursor);
 557
 558         return 0;
 559 }
 560
 561 /* Relationship between s_mode and the DT_xxx types */
 562 static inline unsigned char dt_type(struct sysfs_dirent *sd)
 563 {
 564         return (sd->s_mode >> 12) & 15;
 565 }
 566
 567 static int sysfs_readdir(struct file * filp, void * dirent, filldir_t filldir)
 568 {
 569         struct dentry *dentry = filp->f_path.dentry;
 570         struct sysfs_dirent * parent_sd = dentry->d_fsdata;
 571         struct sysfs_dirent *cursor = filp->private_data;
 572         struct list_head *p, *q = &cursor->s_sibling;
 573         ino_t ino;
 574         int i = filp->f_pos;
 575
 576         switch (i) {
 577                 case 0:
 578                         ino = parent_sd->s_ino;
 579                         if (filldir(dirent, ".", 1, i, ino, DT_DIR) < 0)
 580                                 break;
 581                         filp->f_pos++;
 582                         i++;
 583                         /* fallthrough */
 584                 case 1:
 585                         ino = parent_ino(dentry);
 586                         if (filldir(dirent, "..", 2, i, ino, DT_DIR) < 0)
 587                                 break;
 588                         filp->f_pos++;
 589                         i++;
 590                         /* fallthrough */
 591                 default:
 592                         if (filp->f_pos == 2)
 593                                 list_move(q, &parent_sd->s_children);
 594
 595                         for (p=q->next; p!= &parent_sd->s_children; p=p->next) {
 596                                 struct sysfs_dirent *next;
 597                                 const char * name;
 598                                 int len;
 599
 600                                 next = list_entry(p, struct sysfs_dirent,
 601                                                    s_sibling);
 602                                 if (!next->s_element)
 603                                         continue;
 604
 605                                 name = sysfs_get_name(next);
 606                                 len = strlen(name);
 607                                 ino = next->s_ino;
 608
 609                                 if (filldir(dirent, name, len, filp->f_pos, ino,
 610                                                  dt_type(next)) < 0)
 611                                         return 0;
 612
 613                                 list_move(q, p);
 614                                 p = q;
 615                                 filp->f_pos++;
 616                         }
 617         }
 618         return 0;
 619 }
 620
 621 static loff_t sysfs_dir_lseek(struct file * file, loff_t offset, int origin)
 622 {
 623         struct dentry * dentry = file->f_path.dentry;
 624
 625         mutex_lock(&dentry->d_inode->i_mutex);
 626         switch (origin) {
 627                 case 1:
 628                         offset += file->f_pos;
 629                 case 0:
 630                         if (offset >= 0)
 631                                 break;
 632                 default:
 633                         mutex_unlock(&file->f_path.dentry->d_inode->i_mutex);
 634                         return -EINVAL;
 635         }
 636         if (offset != file->f_pos) {
 637                 file->f_pos = offset;
 638                 if (file->f_pos >= 2) {
 639                         struct sysfs_dirent *sd = dentry->d_fsdata;
 640                         struct sysfs_dirent *cursor = file->private_data;
 641                         struct list_head *p;
 642                         loff_t n = file->f_pos - 2;
 643
 644                         list_del(&cursor->s_sibling);
 645                         p = sd->s_children.next;
 646                         while (n && p != &sd->s_children) {
 647                                 struct sysfs_dirent *next;
 648                                 next = list_entry(p, struct sysfs_dirent,
 649                                                    s_sibling);
 650                                 if (next->s_element)
 651                                         n--;
 652                                 p = p->next;
 653                         }
 654                         list_add_tail(&cursor->s_sibling, p);
 655                 }
 656         }
 657         mutex_unlock(&dentry->d_inode->i_mutex);
 658         return offset;
 659 }
 660
 661
 662 /**
 663  *      sysfs_make_shadowed_dir - Setup so a directory can be shadowed
 664  *      @kobj:  object we're creating shadow of.
 665  */
 666
 667 int sysfs_make_shadowed_dir(struct kobject *kobj,
 668         void * (*follow_link)(struct dentry *, struct nameidata *))
 669 {
 670         struct inode *inode;
 671         struct inode_operations *i_op;
 672
 673         inode = kobj->dentry->d_inode;
 674         if (inode->i_op != &sysfs_dir_inode_operations)
 675                 return -EINVAL;
 676
 677         i_op = kmalloc(sizeof(*i_op), GFP_KERNEL);
 678         if (!i_op)
 679                 return -ENOMEM;
 680
 681         memcpy(i_op, &sysfs_dir_inode_operations, sizeof(*i_op));
 682         i_op->follow_link = follow_link;
 683
 684         /* Locking of inode->i_op?
 685          * Since setting i_op is a single word write and they
 686          * are atomic we should be ok here.
 687          */
 688         inode->i_op = i_op;
 689         return 0;
 690 }
 691
 692 /**
 693  *      sysfs_create_shadow_dir - create a shadow directory for an object.
 694  *      @kobj:  object we're creating directory for.
 695  *
 696  *      sysfs_make_shadowed_dir must already have been called on this
 697  *      directory.
 698  */
 699
 700 struct dentry *sysfs_create_shadow_dir(struct kobject *kobj)
 701 {
 702         struct sysfs_dirent *sd;
 703         struct dentry *parent, *dir, *shadow;
 704         struct inode *inode;
 705
 706         dir = kobj->dentry;
 707         inode = dir->d_inode;
 708         parent = dir->d_parent;
 709         shadow = ERR_PTR(-EINVAL);
 710         if (!sysfs_is_shadowed_inode(inode))
 711                 goto out;
 712
 713         shadow = d_alloc(parent, &dir->d_name);
 714         if (!shadow)
 715                 goto nomem;
 716
 717         sd = __sysfs_make_dirent(shadow, kobj, inode->i_mode, SYSFS_DIR);
 718         if (!sd)
 719                 goto nomem;
 720
 721         d_instantiate(shadow, igrab(inode));
 722         inc_nlink(inode);
 723         inc_nlink(parent->d_inode);
 724         shadow->d_op = &sysfs_dentry_ops;
 725
 726         dget(shadow);           /* Extra count - pin the dentry in core */
 727
 728 out:
 729         return shadow;
 730 nomem:
 731         dput(shadow);
 732         shadow = ERR_PTR(-ENOMEM);
 733         goto out;
 734 }
 735
 736 /**
 737  *      sysfs_remove_shadow_dir - remove an object's directory.
 738  *      @shadow: dentry of shadow directory
 739  *
 740  *      The only thing special about this is that we remove any files in
 741  *      the directory before we remove the directory, and we've inlined
 742  *      what used to be sysfs_rmdir() below, instead of calling separately.
 743  */
 744
 745 void sysfs_remove_shadow_dir(struct dentry *shadow)
 746 {
 747         __sysfs_remove_dir(shadow);
 748 }
 749
 750 const struct file_operations sysfs_dir_operations = {
 751         .open           = sysfs_dir_open,
 752         .release        = sysfs_dir_close,
 753         .llseek         = sysfs_dir_lseek,
 754         .read           = generic_read_dir,
 755         .readdir        = sysfs_readdir,
 756 };