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