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