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