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