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