1 /* 2 * Copyright (C) 2000 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com) 3 * Licensed under the GPL 4 * 5 * Ported the filesystem routines to 2.5. 6 * 2003-02-10 Petr Baudis <pasky@ucw.cz> 7 */ 8 9 #include <linux/fs.h> 10 #include <linux/module.h> 11 #include <linux/mm.h> 12 #include <linux/pagemap.h> 13 #include <linux/statfs.h> 14 #include <linux/slab.h> 15 #include <linux/seq_file.h> 16 #include <linux/mount.h> 17 #include <linux/namei.h> 18 #include "hostfs.h" 19 #include "init.h" 20 #include "kern.h" 21 22 struct hostfs_inode_info { 23 int fd; 24 fmode_t mode; 25 struct inode vfs_inode; 26 }; 27 28 static inline struct hostfs_inode_info *HOSTFS_I(struct inode *inode) 29 { 30 return list_entry(inode, struct hostfs_inode_info, vfs_inode); 31 } 32 33 #define FILE_HOSTFS_I(file) HOSTFS_I((file)->f_path.dentry->d_inode) 34 35 static int hostfs_d_delete(const struct dentry *dentry) 36 { 37 return 1; 38 } 39 40 static const struct dentry_operations hostfs_dentry_ops = { 41 .d_delete = hostfs_d_delete, 42 }; 43 44 /* Changed in hostfs_args before the kernel starts running */ 45 static char *root_ino = ""; 46 static int append = 0; 47 48 #define HOSTFS_SUPER_MAGIC 0x00c0ffee 49 50 static const struct inode_operations hostfs_iops; 51 static const struct inode_operations hostfs_dir_iops; 52 static const struct inode_operations hostfs_link_iops; 53 54 #ifndef MODULE 55 static int __init hostfs_args(char *options, int *add) 56 { 57 char *ptr; 58 59 ptr = strchr(options, ','); 60 if (ptr != NULL) 61 *ptr++ = '\0'; 62 if (*options != '\0') 63 root_ino = options; 64 65 options = ptr; 66 while (options) { 67 ptr = strchr(options, ','); 68 if (ptr != NULL) 69 *ptr++ = '\0'; 70 if (*options != '\0') { 71 if (!strcmp(options, "append")) 72 append = 1; 73 else printf("hostfs_args - unsupported option - %s\n", 74 options); 75 } 76 options = ptr; 77 } 78 return 0; 79 } 80 81 __uml_setup("hostfs=", hostfs_args, 82 "hostfs=<root dir>,<flags>,...\n" 83 " This is used to set hostfs parameters. The root directory argument\n" 84 " is used to confine all hostfs mounts to within the specified directory\n" 85 " tree on the host. If this isn't specified, then a user inside UML can\n" 86 " mount anything on the host that's accessible to the user that's running\n" 87 " it.\n" 88 " The only flag currently supported is 'append', which specifies that all\n" 89 " files opened by hostfs will be opened in append mode.\n\n" 90 ); 91 #endif 92 93 static char *__dentry_name(struct dentry *dentry, char *name) 94 { 95 char *p = dentry_path_raw(dentry, name, PATH_MAX); 96 char *root; 97 size_t len; 98 99 root = dentry->d_sb->s_fs_info; 100 len = strlen(root); 101 if (IS_ERR(p)) { 102 __putname(name); 103 return NULL; 104 } 105 strlcpy(name, root, PATH_MAX); 106 if (len > p - name) { 107 __putname(name); 108 return NULL; 109 } 110 if (p > name + len) { 111 char *s = name + len; 112 while ((*s++ = *p++) != '\0') 113 ; 114 } 115 return name; 116 } 117 118 static char *dentry_name(struct dentry *dentry) 119 { 120 char *name = __getname(); 121 if (!name) 122 return NULL; 123 124 return __dentry_name(dentry, name); /* will unlock */ 125 } 126 127 static char *inode_name(struct inode *ino) 128 { 129 struct dentry *dentry; 130 char *name; 131 132 dentry = d_find_alias(ino); 133 if (!dentry) 134 return NULL; 135 136 name = dentry_name(dentry); 137 138 dput(dentry); 139 140 return name; 141 } 142 143 static char *follow_link(char *link) 144 { 145 int len, n; 146 char *name, *resolved, *end; 147 148 len = 64; 149 while (1) { 150 n = -ENOMEM; 151 name = kmalloc(len, GFP_KERNEL); 152 if (name == NULL) 153 goto out; 154 155 n = hostfs_do_readlink(link, name, len); 156 if (n < len) 157 break; 158 len *= 2; 159 kfree(name); 160 } 161 if (n < 0) 162 goto out_free; 163 164 if (*name == '/') 165 return name; 166 167 end = strrchr(link, '/'); 168 if (end == NULL) 169 return name; 170 171 *(end + 1) = '\0'; 172 len = strlen(link) + strlen(name) + 1; 173 174 resolved = kmalloc(len, GFP_KERNEL); 175 if (resolved == NULL) { 176 n = -ENOMEM; 177 goto out_free; 178 } 179 180 sprintf(resolved, "%s%s", link, name); 181 kfree(name); 182 kfree(link); 183 return resolved; 184 185 out_free: 186 kfree(name); 187 out: 188 return ERR_PTR(n); 189 } 190 191 static struct inode *hostfs_iget(struct super_block *sb) 192 { 193 struct inode *inode = new_inode(sb); 194 if (!inode) 195 return ERR_PTR(-ENOMEM); 196 return inode; 197 } 198 199 int hostfs_statfs(struct dentry *dentry, struct kstatfs *sf) 200 { 201 /* 202 * do_statfs uses struct statfs64 internally, but the linux kernel 203 * struct statfs still has 32-bit versions for most of these fields, 204 * so we convert them here 205 */ 206 int err; 207 long long f_blocks; 208 long long f_bfree; 209 long long f_bavail; 210 long long f_files; 211 long long f_ffree; 212 213 err = do_statfs(dentry->d_sb->s_fs_info, 214 &sf->f_bsize, &f_blocks, &f_bfree, &f_bavail, &f_files, 215 &f_ffree, &sf->f_fsid, sizeof(sf->f_fsid), 216 &sf->f_namelen); 217 if (err) 218 return err; 219 sf->f_blocks = f_blocks; 220 sf->f_bfree = f_bfree; 221 sf->f_bavail = f_bavail; 222 sf->f_files = f_files; 223 sf->f_ffree = f_ffree; 224 sf->f_type = HOSTFS_SUPER_MAGIC; 225 return 0; 226 } 227 228 static struct inode *hostfs_alloc_inode(struct super_block *sb) 229 { 230 struct hostfs_inode_info *hi; 231 232 hi = kzalloc(sizeof(*hi), GFP_KERNEL); 233 if (hi == NULL) 234 return NULL; 235 hi->fd = -1; 236 inode_init_once(&hi->vfs_inode); 237 return &hi->vfs_inode; 238 } 239 240 static void hostfs_evict_inode(struct inode *inode) 241 { 242 truncate_inode_pages(&inode->i_data, 0); 243 end_writeback(inode); 244 if (HOSTFS_I(inode)->fd != -1) { 245 close_file(&HOSTFS_I(inode)->fd); 246 HOSTFS_I(inode)->fd = -1; 247 } 248 } 249 250 static void hostfs_i_callback(struct rcu_head *head) 251 { 252 struct inode *inode = container_of(head, struct inode, i_rcu); 253 INIT_LIST_HEAD(&inode->i_dentry); 254 kfree(HOSTFS_I(inode)); 255 } 256 257 static void hostfs_destroy_inode(struct inode *inode) 258 { 259 call_rcu(&inode->i_rcu, hostfs_i_callback); 260 } 261 262 static int hostfs_show_options(struct seq_file *seq, struct vfsmount *vfs) 263 { 264 const char *root_path = vfs->mnt_sb->s_fs_info; 265 size_t offset = strlen(root_ino) + 1; 266 267 if (strlen(root_path) > offset) 268 seq_printf(seq, ",%s", root_path + offset); 269 270 return 0; 271 } 272 273 static const struct super_operations hostfs_sbops = { 274 .alloc_inode = hostfs_alloc_inode, 275 .destroy_inode = hostfs_destroy_inode, 276 .evict_inode = hostfs_evict_inode, 277 .statfs = hostfs_statfs, 278 .show_options = hostfs_show_options, 279 }; 280 281 int hostfs_readdir(struct file *file, void *ent, filldir_t filldir) 282 { 283 void *dir; 284 char *name; 285 unsigned long long next, ino; 286 int error, len; 287 288 name = dentry_name(file->f_path.dentry); 289 if (name == NULL) 290 return -ENOMEM; 291 dir = open_dir(name, &error); 292 __putname(name); 293 if (dir == NULL) 294 return -error; 295 next = file->f_pos; 296 while ((name = read_dir(dir, &next, &ino, &len)) != NULL) { 297 error = (*filldir)(ent, name, len, file->f_pos, 298 ino, DT_UNKNOWN); 299 if (error) break; 300 file->f_pos = next; 301 } 302 close_dir(dir); 303 return 0; 304 } 305 306 int hostfs_file_open(struct inode *ino, struct file *file) 307 { 308 static DEFINE_MUTEX(open_mutex); 309 char *name; 310 fmode_t mode = 0; 311 int err; 312 int r = 0, w = 0, fd; 313 314 mode = file->f_mode & (FMODE_READ | FMODE_WRITE); 315 if ((mode & HOSTFS_I(ino)->mode) == mode) 316 return 0; 317 318 mode |= HOSTFS_I(ino)->mode; 319 320 retry: 321 if (mode & FMODE_READ) 322 r = 1; 323 if (mode & FMODE_WRITE) 324 w = 1; 325 if (w) 326 r = 1; 327 328 name = dentry_name(file->f_path.dentry); 329 if (name == NULL) 330 return -ENOMEM; 331 332 fd = open_file(name, r, w, append); 333 __putname(name); 334 if (fd < 0) 335 return fd; 336 337 mutex_lock(&open_mutex); 338 /* somebody else had handled it first? */ 339 if ((mode & HOSTFS_I(ino)->mode) == mode) { 340 mutex_unlock(&open_mutex); 341 return 0; 342 } 343 if ((mode | HOSTFS_I(ino)->mode) != mode) { 344 mode |= HOSTFS_I(ino)->mode; 345 mutex_unlock(&open_mutex); 346 close_file(&fd); 347 goto retry; 348 } 349 if (HOSTFS_I(ino)->fd == -1) { 350 HOSTFS_I(ino)->fd = fd; 351 } else { 352 err = replace_file(fd, HOSTFS_I(ino)->fd); 353 close_file(&fd); 354 if (err < 0) { 355 mutex_unlock(&open_mutex); 356 return err; 357 } 358 } 359 HOSTFS_I(ino)->mode = mode; 360 mutex_unlock(&open_mutex); 361 362 return 0; 363 } 364 365 int hostfs_fsync(struct file *file, int datasync) 366 { 367 return fsync_file(HOSTFS_I(file->f_mapping->host)->fd, datasync); 368 } 369 370 static const struct file_operations hostfs_file_fops = { 371 .llseek = generic_file_llseek, 372 .read = do_sync_read, 373 .splice_read = generic_file_splice_read, 374 .aio_read = generic_file_aio_read, 375 .aio_write = generic_file_aio_write, 376 .write = do_sync_write, 377 .mmap = generic_file_mmap, 378 .open = hostfs_file_open, 379 .release = NULL, 380 .fsync = hostfs_fsync, 381 }; 382 383 static const struct file_operations hostfs_dir_fops = { 384 .llseek = generic_file_llseek, 385 .readdir = hostfs_readdir, 386 .read = generic_read_dir, 387 }; 388 389 int hostfs_writepage(struct page *page, struct writeback_control *wbc) 390 { 391 struct address_space *mapping = page->mapping; 392 struct inode *inode = mapping->host; 393 char *buffer; 394 unsigned long long base; 395 int count = PAGE_CACHE_SIZE; 396 int end_index = inode->i_size >> PAGE_CACHE_SHIFT; 397 int err; 398 399 if (page->index >= end_index) 400 count = inode->i_size & (PAGE_CACHE_SIZE-1); 401 402 buffer = kmap(page); 403 base = ((unsigned long long) page->index) << PAGE_CACHE_SHIFT; 404 405 err = write_file(HOSTFS_I(inode)->fd, &base, buffer, count); 406 if (err != count) { 407 ClearPageUptodate(page); 408 goto out; 409 } 410 411 if (base > inode->i_size) 412 inode->i_size = base; 413 414 if (PageError(page)) 415 ClearPageError(page); 416 err = 0; 417 418 out: 419 kunmap(page); 420 421 unlock_page(page); 422 return err; 423 } 424 425 int hostfs_readpage(struct file *file, struct page *page) 426 { 427 char *buffer; 428 long long start; 429 int err = 0; 430 431 start = (long long) page->index << PAGE_CACHE_SHIFT; 432 buffer = kmap(page); 433 err = read_file(FILE_HOSTFS_I(file)->fd, &start, buffer, 434 PAGE_CACHE_SIZE); 435 if (err < 0) 436 goto out; 437 438 memset(&buffer[err], 0, PAGE_CACHE_SIZE - err); 439 440 flush_dcache_page(page); 441 SetPageUptodate(page); 442 if (PageError(page)) ClearPageError(page); 443 err = 0; 444 out: 445 kunmap(page); 446 unlock_page(page); 447 return err; 448 } 449 450 int hostfs_write_begin(struct file *file, struct address_space *mapping, 451 loff_t pos, unsigned len, unsigned flags, 452 struct page **pagep, void **fsdata) 453 { 454 pgoff_t index = pos >> PAGE_CACHE_SHIFT; 455 456 *pagep = grab_cache_page_write_begin(mapping, index, flags); 457 if (!*pagep) 458 return -ENOMEM; 459 return 0; 460 } 461 462 int hostfs_write_end(struct file *file, struct address_space *mapping, 463 loff_t pos, unsigned len, unsigned copied, 464 struct page *page, void *fsdata) 465 { 466 struct inode *inode = mapping->host; 467 void *buffer; 468 unsigned from = pos & (PAGE_CACHE_SIZE - 1); 469 int err; 470 471 buffer = kmap(page); 472 err = write_file(FILE_HOSTFS_I(file)->fd, &pos, buffer + from, copied); 473 kunmap(page); 474 475 if (!PageUptodate(page) && err == PAGE_CACHE_SIZE) 476 SetPageUptodate(page); 477 478 /* 479 * If err > 0, write_file has added err to pos, so we are comparing 480 * i_size against the last byte written. 481 */ 482 if (err > 0 && (pos > inode->i_size)) 483 inode->i_size = pos; 484 unlock_page(page); 485 page_cache_release(page); 486 487 return err; 488 } 489 490 static const struct address_space_operations hostfs_aops = { 491 .writepage = hostfs_writepage, 492 .readpage = hostfs_readpage, 493 .set_page_dirty = __set_page_dirty_nobuffers, 494 .write_begin = hostfs_write_begin, 495 .write_end = hostfs_write_end, 496 }; 497 498 static int read_name(struct inode *ino, char *name) 499 { 500 dev_t rdev; 501 struct hostfs_stat st; 502 int err = stat_file(name, &st, -1); 503 if (err) 504 return err; 505 506 /* Reencode maj and min with the kernel encoding.*/ 507 rdev = MKDEV(st.maj, st.min); 508 509 switch (st.mode & S_IFMT) { 510 case S_IFLNK: 511 ino->i_op = &hostfs_link_iops; 512 break; 513 case S_IFDIR: 514 ino->i_op = &hostfs_dir_iops; 515 ino->i_fop = &hostfs_dir_fops; 516 break; 517 case S_IFCHR: 518 case S_IFBLK: 519 case S_IFIFO: 520 case S_IFSOCK: 521 init_special_inode(ino, st.mode & S_IFMT, rdev); 522 ino->i_op = &hostfs_iops; 523 break; 524 525 default: 526 ino->i_op = &hostfs_iops; 527 ino->i_fop = &hostfs_file_fops; 528 ino->i_mapping->a_ops = &hostfs_aops; 529 } 530 531 ino->i_ino = st.ino; 532 ino->i_mode = st.mode; 533 ino->i_nlink = st.nlink; 534 ino->i_uid = st.uid; 535 ino->i_gid = st.gid; 536 ino->i_atime = st.atime; 537 ino->i_mtime = st.mtime; 538 ino->i_ctime = st.ctime; 539 ino->i_size = st.size; 540 ino->i_blocks = st.blocks; 541 return 0; 542 } 543 544 int hostfs_create(struct inode *dir, struct dentry *dentry, int mode, 545 struct nameidata *nd) 546 { 547 struct inode *inode; 548 char *name; 549 int error, fd; 550 551 inode = hostfs_iget(dir->i_sb); 552 if (IS_ERR(inode)) { 553 error = PTR_ERR(inode); 554 goto out; 555 } 556 557 error = -ENOMEM; 558 name = dentry_name(dentry); 559 if (name == NULL) 560 goto out_put; 561 562 fd = file_create(name, 563 mode & S_IRUSR, mode & S_IWUSR, mode & S_IXUSR, 564 mode & S_IRGRP, mode & S_IWGRP, mode & S_IXGRP, 565 mode & S_IROTH, mode & S_IWOTH, mode & S_IXOTH); 566 if (fd < 0) 567 error = fd; 568 else 569 error = read_name(inode, name); 570 571 __putname(name); 572 if (error) 573 goto out_put; 574 575 HOSTFS_I(inode)->fd = fd; 576 HOSTFS_I(inode)->mode = FMODE_READ | FMODE_WRITE; 577 d_instantiate(dentry, inode); 578 return 0; 579 580 out_put: 581 iput(inode); 582 out: 583 return error; 584 } 585 586 struct dentry *hostfs_lookup(struct inode *ino, struct dentry *dentry, 587 struct nameidata *nd) 588 { 589 struct inode *inode; 590 char *name; 591 int err; 592 593 inode = hostfs_iget(ino->i_sb); 594 if (IS_ERR(inode)) { 595 err = PTR_ERR(inode); 596 goto out; 597 } 598 599 err = -ENOMEM; 600 name = dentry_name(dentry); 601 if (name == NULL) 602 goto out_put; 603 604 err = read_name(inode, name); 605 606 __putname(name); 607 if (err == -ENOENT) { 608 iput(inode); 609 inode = NULL; 610 } 611 else if (err) 612 goto out_put; 613 614 d_add(dentry, inode); 615 return NULL; 616 617 out_put: 618 iput(inode); 619 out: 620 return ERR_PTR(err); 621 } 622 623 int hostfs_link(struct dentry *to, struct inode *ino, struct dentry *from) 624 { 625 char *from_name, *to_name; 626 int err; 627 628 if ((from_name = dentry_name(from)) == NULL) 629 return -ENOMEM; 630 to_name = dentry_name(to); 631 if (to_name == NULL) { 632 __putname(from_name); 633 return -ENOMEM; 634 } 635 err = link_file(to_name, from_name); 636 __putname(from_name); 637 __putname(to_name); 638 return err; 639 } 640 641 int hostfs_unlink(struct inode *ino, struct dentry *dentry) 642 { 643 char *file; 644 int err; 645 646 if (append) 647 return -EPERM; 648 649 if ((file = dentry_name(dentry)) == NULL) 650 return -ENOMEM; 651 652 err = unlink_file(file); 653 __putname(file); 654 return err; 655 } 656 657 int hostfs_symlink(struct inode *ino, struct dentry *dentry, const char *to) 658 { 659 char *file; 660 int err; 661 662 if ((file = dentry_name(dentry)) == NULL) 663 return -ENOMEM; 664 err = make_symlink(file, to); 665 __putname(file); 666 return err; 667 } 668 669 int hostfs_mkdir(struct inode *ino, struct dentry *dentry, int mode) 670 { 671 char *file; 672 int err; 673 674 if ((file = dentry_name(dentry)) == NULL) 675 return -ENOMEM; 676 err = do_mkdir(file, mode); 677 __putname(file); 678 return err; 679 } 680 681 int hostfs_rmdir(struct inode *ino, struct dentry *dentry) 682 { 683 char *file; 684 int err; 685 686 if ((file = dentry_name(dentry)) == NULL) 687 return -ENOMEM; 688 err = do_rmdir(file); 689 __putname(file); 690 return err; 691 } 692 693 int hostfs_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t dev) 694 { 695 struct inode *inode; 696 char *name; 697 int err; 698 699 inode = hostfs_iget(dir->i_sb); 700 if (IS_ERR(inode)) { 701 err = PTR_ERR(inode); 702 goto out; 703 } 704 705 err = -ENOMEM; 706 name = dentry_name(dentry); 707 if (name == NULL) 708 goto out_put; 709 710 init_special_inode(inode, mode, dev); 711 err = do_mknod(name, mode, MAJOR(dev), MINOR(dev)); 712 if (!err) 713 goto out_free; 714 715 err = read_name(inode, name); 716 __putname(name); 717 if (err) 718 goto out_put; 719 if (err) 720 goto out_put; 721 722 d_instantiate(dentry, inode); 723 return 0; 724 725 out_free: 726 __putname(name); 727 out_put: 728 iput(inode); 729 out: 730 return err; 731 } 732 733 int hostfs_rename(struct inode *from_ino, struct dentry *from, 734 struct inode *to_ino, struct dentry *to) 735 { 736 char *from_name, *to_name; 737 int err; 738 739 if ((from_name = dentry_name(from)) == NULL) 740 return -ENOMEM; 741 if ((to_name = dentry_name(to)) == NULL) { 742 __putname(from_name); 743 return -ENOMEM; 744 } 745 err = rename_file(from_name, to_name); 746 __putname(from_name); 747 __putname(to_name); 748 return err; 749 } 750 751 int hostfs_permission(struct inode *ino, int desired, unsigned int flags) 752 { 753 char *name; 754 int r = 0, w = 0, x = 0, err; 755 756 if (flags & IPERM_FLAG_RCU) 757 return -ECHILD; 758 759 if (desired & MAY_READ) r = 1; 760 if (desired & MAY_WRITE) w = 1; 761 if (desired & MAY_EXEC) x = 1; 762 name = inode_name(ino); 763 if (name == NULL) 764 return -ENOMEM; 765 766 if (S_ISCHR(ino->i_mode) || S_ISBLK(ino->i_mode) || 767 S_ISFIFO(ino->i_mode) || S_ISSOCK(ino->i_mode)) 768 err = 0; 769 else 770 err = access_file(name, r, w, x); 771 __putname(name); 772 if (!err) 773 err = generic_permission(ino, desired, flags, NULL); 774 return err; 775 } 776 777 int hostfs_setattr(struct dentry *dentry, struct iattr *attr) 778 { 779 struct inode *inode = dentry->d_inode; 780 struct hostfs_iattr attrs; 781 char *name; 782 int err; 783 784 int fd = HOSTFS_I(inode)->fd; 785 786 err = inode_change_ok(inode, attr); 787 if (err) 788 return err; 789 790 if (append) 791 attr->ia_valid &= ~ATTR_SIZE; 792 793 attrs.ia_valid = 0; 794 if (attr->ia_valid & ATTR_MODE) { 795 attrs.ia_valid |= HOSTFS_ATTR_MODE; 796 attrs.ia_mode = attr->ia_mode; 797 } 798 if (attr->ia_valid & ATTR_UID) { 799 attrs.ia_valid |= HOSTFS_ATTR_UID; 800 attrs.ia_uid = attr->ia_uid; 801 } 802 if (attr->ia_valid & ATTR_GID) { 803 attrs.ia_valid |= HOSTFS_ATTR_GID; 804 attrs.ia_gid = attr->ia_gid; 805 } 806 if (attr->ia_valid & ATTR_SIZE) { 807 attrs.ia_valid |= HOSTFS_ATTR_SIZE; 808 attrs.ia_size = attr->ia_size; 809 } 810 if (attr->ia_valid & ATTR_ATIME) { 811 attrs.ia_valid |= HOSTFS_ATTR_ATIME; 812 attrs.ia_atime = attr->ia_atime; 813 } 814 if (attr->ia_valid & ATTR_MTIME) { 815 attrs.ia_valid |= HOSTFS_ATTR_MTIME; 816 attrs.ia_mtime = attr->ia_mtime; 817 } 818 if (attr->ia_valid & ATTR_CTIME) { 819 attrs.ia_valid |= HOSTFS_ATTR_CTIME; 820 attrs.ia_ctime = attr->ia_ctime; 821 } 822 if (attr->ia_valid & ATTR_ATIME_SET) { 823 attrs.ia_valid |= HOSTFS_ATTR_ATIME_SET; 824 } 825 if (attr->ia_valid & ATTR_MTIME_SET) { 826 attrs.ia_valid |= HOSTFS_ATTR_MTIME_SET; 827 } 828 name = dentry_name(dentry); 829 if (name == NULL) 830 return -ENOMEM; 831 err = set_attr(name, &attrs, fd); 832 __putname(name); 833 if (err) 834 return err; 835 836 if ((attr->ia_valid & ATTR_SIZE) && 837 attr->ia_size != i_size_read(inode)) { 838 int error; 839 840 error = vmtruncate(inode, attr->ia_size); 841 if (err) 842 return err; 843 } 844 845 setattr_copy(inode, attr); 846 mark_inode_dirty(inode); 847 return 0; 848 } 849 850 static const struct inode_operations hostfs_iops = { 851 .create = hostfs_create, 852 .link = hostfs_link, 853 .unlink = hostfs_unlink, 854 .symlink = hostfs_symlink, 855 .mkdir = hostfs_mkdir, 856 .rmdir = hostfs_rmdir, 857 .mknod = hostfs_mknod, 858 .rename = hostfs_rename, 859 .permission = hostfs_permission, 860 .setattr = hostfs_setattr, 861 }; 862 863 static const struct inode_operations hostfs_dir_iops = { 864 .create = hostfs_create, 865 .lookup = hostfs_lookup, 866 .link = hostfs_link, 867 .unlink = hostfs_unlink, 868 .symlink = hostfs_symlink, 869 .mkdir = hostfs_mkdir, 870 .rmdir = hostfs_rmdir, 871 .mknod = hostfs_mknod, 872 .rename = hostfs_rename, 873 .permission = hostfs_permission, 874 .setattr = hostfs_setattr, 875 }; 876 877 static void *hostfs_follow_link(struct dentry *dentry, struct nameidata *nd) 878 { 879 char *link = __getname(); 880 if (link) { 881 char *path = dentry_name(dentry); 882 int err = -ENOMEM; 883 if (path) { 884 err = hostfs_do_readlink(path, link, PATH_MAX); 885 if (err == PATH_MAX) 886 err = -E2BIG; 887 __putname(path); 888 } 889 if (err < 0) { 890 __putname(link); 891 link = ERR_PTR(err); 892 } 893 } else { 894 link = ERR_PTR(-ENOMEM); 895 } 896 897 nd_set_link(nd, link); 898 return NULL; 899 } 900 901 static void hostfs_put_link(struct dentry *dentry, struct nameidata *nd, void *cookie) 902 { 903 char *s = nd_get_link(nd); 904 if (!IS_ERR(s)) 905 __putname(s); 906 } 907 908 static const struct inode_operations hostfs_link_iops = { 909 .readlink = generic_readlink, 910 .follow_link = hostfs_follow_link, 911 .put_link = hostfs_put_link, 912 }; 913 914 static int hostfs_fill_sb_common(struct super_block *sb, void *d, int silent) 915 { 916 struct inode *root_inode; 917 char *host_root_path, *req_root = d; 918 int err; 919 920 sb->s_blocksize = 1024; 921 sb->s_blocksize_bits = 10; 922 sb->s_magic = HOSTFS_SUPER_MAGIC; 923 sb->s_op = &hostfs_sbops; 924 sb->s_d_op = &hostfs_dentry_ops; 925 sb->s_maxbytes = MAX_LFS_FILESIZE; 926 927 /* NULL is printed as <NULL> by sprintf: avoid that. */ 928 if (req_root == NULL) 929 req_root = ""; 930 931 err = -ENOMEM; 932 sb->s_fs_info = host_root_path = 933 kmalloc(strlen(root_ino) + strlen(req_root) + 2, GFP_KERNEL); 934 if (host_root_path == NULL) 935 goto out; 936 937 sprintf(host_root_path, "%s/%s", root_ino, req_root); 938 939 root_inode = new_inode(sb); 940 if (!root_inode) 941 goto out; 942 943 err = read_name(root_inode, host_root_path); 944 if (err) 945 goto out_put; 946 947 if (S_ISLNK(root_inode->i_mode)) { 948 char *name = follow_link(host_root_path); 949 if (IS_ERR(name)) 950 err = PTR_ERR(name); 951 else 952 err = read_name(root_inode, name); 953 kfree(name); 954 if (err) 955 goto out_put; 956 } 957 958 err = -ENOMEM; 959 sb->s_root = d_alloc_root(root_inode); 960 if (sb->s_root == NULL) 961 goto out_put; 962 963 return 0; 964 965 out_put: 966 iput(root_inode); 967 out: 968 return err; 969 } 970 971 static struct dentry *hostfs_read_sb(struct file_system_type *type, 972 int flags, const char *dev_name, 973 void *data) 974 { 975 return mount_nodev(type, flags, data, hostfs_fill_sb_common); 976 } 977 978 static void hostfs_kill_sb(struct super_block *s) 979 { 980 kill_anon_super(s); 981 kfree(s->s_fs_info); 982 } 983 984 static struct file_system_type hostfs_type = { 985 .owner = THIS_MODULE, 986 .name = "hostfs", 987 .mount = hostfs_read_sb, 988 .kill_sb = hostfs_kill_sb, 989 .fs_flags = 0, 990 }; 991 992 static int __init init_hostfs(void) 993 { 994 return register_filesystem(&hostfs_type); 995 } 996 997 static void __exit exit_hostfs(void) 998 { 999 unregister_filesystem(&hostfs_type); 1000 } 1001 1002 module_init(init_hostfs) 1003 module_exit(exit_hostfs) 1004 MODULE_LICENSE("GPL"); 1005