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