Archipelago » qemu

/*

 * Virtio 9p backend

 *

 * Copyright IBM, Corp. 2010

 *

 * Authors:

 *  Anthony Liguori   <aliguori@us.ibm.com>

 *

 * This work is licensed under the terms of the GNU GPL, version 2.  See

 * the COPYING file in the top-level directory.

 *

 */

#include "hw/virtio/virtio.h"

#include "hw/i386/pc.h"

#include "qemu/sockets.h"

#include "virtio-9p.h"

#include "fsdev/qemu-fsdev.h"

#include "virtio-9p-xattr.h"

#include "virtio-9p-coth.h"

#include "trace.h"

#include "migration/migration.h"

int open_fd_hw;

int total_open_fd;

static int open_fd_rc;

enum {

    Oread   = 0x00,

    Owrite  = 0x01,

    Ordwr   = 0x02,

    Oexec   = 0x03,

    Oexcl   = 0x04,

    Otrunc  = 0x10,

    Orexec  = 0x20,

    Orclose = 0x40,

    Oappend = 0x80,

};

static int omode_to_uflags(int8_t mode)

{

    int ret = 0;

    switch (mode & 3) {

    case Oread:

        ret = O_RDONLY;

        break;

    case Ordwr:

        ret = O_RDWR;

        break;

    case Owrite:

        ret = O_WRONLY;

        break;

    case Oexec:

        ret = O_RDONLY;

        break;

    }

    if (mode & Otrunc) {

        ret |= O_TRUNC;

    }

    if (mode & Oappend) {

        ret |= O_APPEND;

    }

    if (mode & Oexcl) {

        ret |= O_EXCL;

    }

    return ret;

}

struct dotl_openflag_map {

    int dotl_flag;

    int open_flag;

};

static int dotl_to_open_flags(int flags)

{

    int i;

    /*

     * We have same bits for P9_DOTL_READONLY, P9_DOTL_WRONLY

     * and P9_DOTL_NOACCESS

     */

    int oflags = flags & O_ACCMODE;

    struct dotl_openflag_map dotl_oflag_map[] = {

        { P9_DOTL_CREATE, O_CREAT },

        { P9_DOTL_EXCL, O_EXCL },

        { P9_DOTL_NOCTTY , O_NOCTTY },

        { P9_DOTL_TRUNC, O_TRUNC },

        { P9_DOTL_APPEND, O_APPEND },

        { P9_DOTL_NONBLOCK, O_NONBLOCK } ,

        { P9_DOTL_DSYNC, O_DSYNC },

        { P9_DOTL_FASYNC, FASYNC },

        { P9_DOTL_DIRECT, O_DIRECT },

        { P9_DOTL_LARGEFILE, O_LARGEFILE },

        { P9_DOTL_DIRECTORY, O_DIRECTORY },

        { P9_DOTL_NOFOLLOW, O_NOFOLLOW },

        { P9_DOTL_NOATIME, O_NOATIME },

        { P9_DOTL_SYNC, O_SYNC },

    };

    for (i = 0; i < ARRAY_SIZE(dotl_oflag_map); i++) {

        if (flags & dotl_oflag_map[i].dotl_flag) {

            oflags |= dotl_oflag_map[i].open_flag;

        }

    }

    return oflags;

}

void cred_init(FsCred *credp)

{

    credp->fc_uid = -1;

    credp->fc_gid = -1;

    credp->fc_mode = -1;

    credp->fc_rdev = -1;

}

static int get_dotl_openflags(V9fsState *s, int oflags)

{

    int flags;

    /*

     * Filter the client open flags

     */

    flags = dotl_to_open_flags(oflags);

    flags &= ~(O_NOCTTY | O_ASYNC | O_CREAT);

    /*

     * Ignore direct disk access hint until the server supports it.

     */

    flags &= ~O_DIRECT;

    return flags;

}

void v9fs_path_init(V9fsPath *path)

{

    path->data = NULL;

    path->size = 0;

}

void v9fs_path_free(V9fsPath *path)

{

    g_free(path->data);

    path->data = NULL;

    path->size = 0;

}

void v9fs_path_copy(V9fsPath *lhs, V9fsPath *rhs)

{

    v9fs_path_free(lhs);

    lhs->data = g_malloc(rhs->size);

    memcpy(lhs->data, rhs->data, rhs->size);

    lhs->size = rhs->size;

}

int v9fs_name_to_path(V9fsState *s, V9fsPath *dirpath,

                      const char *name, V9fsPath *path)

{

    int err;

    err = s->ops->name_to_path(&s->ctx, dirpath, name, path);

    if (err < 0) {

        err = -errno;

    }

    return err;

}

/*

 * Return TRUE if s1 is an ancestor of s2.

 *

 * E.g. "a/b" is an ancestor of "a/b/c" but not of "a/bc/d".

 * As a special case, We treat s1 as ancestor of s2 if they are same!

 */

static int v9fs_path_is_ancestor(V9fsPath *s1, V9fsPath *s2)

{

    if (!strncmp(s1->data, s2->data, s1->size - 1)) {

        if (s2->data[s1->size - 1] == '\0' || s2->data[s1->size - 1] == '/') {

            return 1;

        }

    }

    return 0;

}

static size_t v9fs_string_size(V9fsString *str)

{

    return str->size;

}

/*

 * returns 0 if fid got re-opened, 1 if not, < 0 on error */

static int v9fs_reopen_fid(V9fsPDU *pdu, V9fsFidState *f)

{

    int err = 1;

    if (f->fid_type == P9_FID_FILE) {

        if (f->fs.fd == -1) {

            do {

                err = v9fs_co_open(pdu, f, f->open_flags);

            } while (err == -EINTR && !pdu->cancelled);

        }

    } else if (f->fid_type == P9_FID_DIR) {

        if (f->fs.dir == NULL) {

            do {

                err = v9fs_co_opendir(pdu, f);

            } while (err == -EINTR && !pdu->cancelled);

        }

    }

    return err;

}

static V9fsFidState *get_fid(V9fsPDU *pdu, int32_t fid)

{

    int err;

    V9fsFidState *f;

    V9fsState *s = pdu->s;

    for (f = s->fid_list; f; f = f->next) {

        BUG_ON(f->clunked);

        if (f->fid == fid) {

            /*

             * Update the fid ref upfront so that

             * we don't get reclaimed when we yield

             * in open later.

             */

            f->ref++;

            /*

             * check whether we need to reopen the

             * file. We might have closed the fd

             * while trying to free up some file

             * descriptors.

             */

            err = v9fs_reopen_fid(pdu, f);

            if (err < 0) {

                f->ref--;

                return NULL;

            }

            /*

             * Mark the fid as referenced so that the LRU

             * reclaim won't close the file descriptor

             */

            f->flags |= FID_REFERENCED;

            return f;

        }

    }

    return NULL;

}

static V9fsFidState *alloc_fid(V9fsState *s, int32_t fid)

{

    V9fsFidState *f;

    for (f = s->fid_list; f; f = f->next) {

        /* If fid is already there return NULL */

        BUG_ON(f->clunked);

        if (f->fid == fid) {

            return NULL;

        }

    }

    f = g_malloc0(sizeof(V9fsFidState));

    f->fid = fid;

    f->fid_type = P9_FID_NONE;

    f->ref = 1;

    /*

     * Mark the fid as referenced so that the LRU

     * reclaim won't close the file descriptor

     */

    f->flags |= FID_REFERENCED;

    f->next = s->fid_list;

    s->fid_list = f;

    return f;

}

static int v9fs_xattr_fid_clunk(V9fsPDU *pdu, V9fsFidState *fidp)

{

    int retval = 0;

    if (fidp->fs.xattr.copied_len == -1) {

        /* getxattr/listxattr fid */

        goto free_value;

    }

    /*

     * if this is fid for setxattr. clunk should

     * result in setxattr localcall

     */

    if (fidp->fs.xattr.len != fidp->fs.xattr.copied_len) {

        /* clunk after partial write */

        retval = -EINVAL;

        goto free_out;

    }

    if (fidp->fs.xattr.len) {

        retval = v9fs_co_lsetxattr(pdu, &fidp->path, &fidp->fs.xattr.name,

                                   fidp->fs.xattr.value,

                                   fidp->fs.xattr.len,

                                   fidp->fs.xattr.flags);

    } else {

        retval = v9fs_co_lremovexattr(pdu, &fidp->path, &fidp->fs.xattr.name);

    }

free_out:

    v9fs_string_free(&fidp->fs.xattr.name);

free_value:

    if (fidp->fs.xattr.value) {

        g_free(fidp->fs.xattr.value);

    }

    return retval;

}

static int free_fid(V9fsPDU *pdu, V9fsFidState *fidp)

{

    int retval = 0;

    if (fidp->fid_type == P9_FID_FILE) {

        /* If we reclaimed the fd no need to close */

        if (fidp->fs.fd != -1) {

            retval = v9fs_co_close(pdu, &fidp->fs);

        }

    } else if (fidp->fid_type == P9_FID_DIR) {

        if (fidp->fs.dir != NULL) {

            retval = v9fs_co_closedir(pdu, &fidp->fs);

        }

    } else if (fidp->fid_type == P9_FID_XATTR) {

        retval = v9fs_xattr_fid_clunk(pdu, fidp);

    }

    v9fs_path_free(&fidp->path);

    g_free(fidp);

    return retval;

}

static int put_fid(V9fsPDU *pdu, V9fsFidState *fidp)

{

    BUG_ON(!fidp->ref);

    fidp->ref--;

    /*

     * Don't free the fid if it is in reclaim list

     */

    if (!fidp->ref && fidp->clunked) {

        if (fidp->fid == pdu->s->root_fid) {

            /*

             * if the clunked fid is root fid then we

             * have unmounted the fs on the client side.

             * delete the migration blocker. Ideally, this

             * should be hooked to transport close notification

             */

            if (pdu->s->migration_blocker) {

                migrate_del_blocker(pdu->s->migration_blocker);

                error_free(pdu->s->migration_blocker);

                pdu->s->migration_blocker = NULL;

            }

        }

        return free_fid(pdu, fidp);

    }

    return 0;

}

static V9fsFidState *clunk_fid(V9fsState *s, int32_t fid)

{

    V9fsFidState **fidpp, *fidp;

    for (fidpp = &s->fid_list; *fidpp; fidpp = &(*fidpp)->next) {

        if ((*fidpp)->fid == fid) {

            break;

        }

    }

    if (*fidpp == NULL) {

        return NULL;

    }

    fidp = *fidpp;

    *fidpp = fidp->next;

    fidp->clunked = 1;

    return fidp;

}

void v9fs_reclaim_fd(V9fsPDU *pdu)

{

    int reclaim_count = 0;

    V9fsState *s = pdu->s;

    V9fsFidState *f, *reclaim_list = NULL;

    for (f = s->fid_list; f; f = f->next) {

        /*

         * Unlink fids cannot be reclaimed. Check

         * for them and skip them. Also skip fids

         * currently being operated on.

         */

        if (f->ref || f->flags & FID_NON_RECLAIMABLE) {

            continue;

        }

        /*

         * if it is a recently referenced fid

         * we leave the fid untouched and clear the

         * reference bit. We come back to it later

         * in the next iteration. (a simple LRU without

         * moving list elements around)

         */

        if (f->flags & FID_REFERENCED) {

            f->flags &= ~FID_REFERENCED;

            continue;

        }

        /*

         * Add fids to reclaim list.

         */

        if (f->fid_type == P9_FID_FILE) {

            if (f->fs.fd != -1) {

                /*

                 * Up the reference count so that

                 * a clunk request won't free this fid

                 */

                f->ref++;

                f->rclm_lst = reclaim_list;

                reclaim_list = f;

                f->fs_reclaim.fd = f->fs.fd;

                f->fs.fd = -1;

                reclaim_count++;

            }

        } else if (f->fid_type == P9_FID_DIR) {

            if (f->fs.dir != NULL) {

                /*

                 * Up the reference count so that

                 * a clunk request won't free this fid

                 */

                f->ref++;

                f->rclm_lst = reclaim_list;

                reclaim_list = f;

                f->fs_reclaim.dir = f->fs.dir;

                f->fs.dir = NULL;

                reclaim_count++;

            }

        }

        if (reclaim_count >= open_fd_rc) {

            break;

        }

    }

    /*

     * Now close the fid in reclaim list. Free them if they

     * are already clunked.

     */

    while (reclaim_list) {

        f = reclaim_list;

        reclaim_list = f->rclm_lst;

        if (f->fid_type == P9_FID_FILE) {

            v9fs_co_close(pdu, &f->fs_reclaim);

        } else if (f->fid_type == P9_FID_DIR) {

            v9fs_co_closedir(pdu, &f->fs_reclaim);

        }

        f->rclm_lst = NULL;

        /*

         * Now drop the fid reference, free it

         * if clunked.

         */

        put_fid(pdu, f);

    }

}

static int v9fs_mark_fids_unreclaim(V9fsPDU *pdu, V9fsPath *path)

{

    int err;

    V9fsState *s = pdu->s;

    V9fsFidState *fidp, head_fid;

    head_fid.next = s->fid_list;

    for (fidp = s->fid_list; fidp; fidp = fidp->next) {

        if (fidp->path.size != path->size) {

            continue;

        }

        if (!memcmp(fidp->path.data, path->data, path->size)) {

            /* Mark the fid non reclaimable. */

            fidp->flags |= FID_NON_RECLAIMABLE;

            /* reopen the file/dir if already closed */

            err = v9fs_reopen_fid(pdu, fidp);

            if (err < 0) {

                return -1;

            }

            /*

             * Go back to head of fid list because

             * the list could have got updated when

             * switched to the worker thread

             */

            if (err == 0) {

                fidp = &head_fid;

            }

        }

    }

    return 0;

}

static void virtfs_reset(V9fsPDU *pdu)

{

    V9fsState *s = pdu->s;

    V9fsFidState *fidp = NULL;

    /* Free all fids */

    while (s->fid_list) {

        fidp = s->fid_list;

        s->fid_list = fidp->next;

        if (fidp->ref) {

            fidp->clunked = 1;

        } else {

            free_fid(pdu, fidp);

        }

    }

    if (fidp) {

        /* One or more unclunked fids found... */

        error_report("9pfs:%s: One or more uncluncked fids "

                     "found during reset", __func__);

    }

}

#define P9_QID_TYPE_DIR         0x80

#define P9_QID_TYPE_SYMLINK     0x02

#define P9_STAT_MODE_DIR        0x80000000

#define P9_STAT_MODE_APPEND     0x40000000

#define P9_STAT_MODE_EXCL       0x20000000

#define P9_STAT_MODE_MOUNT      0x10000000

#define P9_STAT_MODE_AUTH       0x08000000

#define P9_STAT_MODE_TMP        0x04000000

#define P9_STAT_MODE_SYMLINK    0x02000000

#define P9_STAT_MODE_LINK       0x01000000

#define P9_STAT_MODE_DEVICE     0x00800000

#define P9_STAT_MODE_NAMED_PIPE 0x00200000

#define P9_STAT_MODE_SOCKET     0x00100000

#define P9_STAT_MODE_SETUID     0x00080000

#define P9_STAT_MODE_SETGID     0x00040000

#define P9_STAT_MODE_SETVTX     0x00010000

#define P9_STAT_MODE_TYPE_BITS (P9_STAT_MODE_DIR |          \

                                P9_STAT_MODE_SYMLINK |      \

                                P9_STAT_MODE_LINK |         \

                                P9_STAT_MODE_DEVICE |       \

                                P9_STAT_MODE_NAMED_PIPE |   \

                                P9_STAT_MODE_SOCKET)

/* This is the algorithm from ufs in spfs */

static void stat_to_qid(const struct stat *stbuf, V9fsQID *qidp)

{

    size_t size;

    memset(&qidp->path, 0, sizeof(qidp->path));

    size = MIN(sizeof(stbuf->st_ino), sizeof(qidp->path));

    memcpy(&qidp->path, &stbuf->st_ino, size);

    qidp->version = stbuf->st_mtime ^ (stbuf->st_size << 8);

    qidp->type = 0;

    if (S_ISDIR(stbuf->st_mode)) {

        qidp->type |= P9_QID_TYPE_DIR;

    }

    if (S_ISLNK(stbuf->st_mode)) {

        qidp->type |= P9_QID_TYPE_SYMLINK;

    }

}

static int fid_to_qid(V9fsPDU *pdu, V9fsFidState *fidp, V9fsQID *qidp)

{

    struct stat stbuf;

    int err;

    err = v9fs_co_lstat(pdu, &fidp->path, &stbuf);

    if (err < 0) {

        return err;

    }

    stat_to_qid(&stbuf, qidp);

    return 0;

}

static V9fsPDU *alloc_pdu(V9fsState *s)

{

    V9fsPDU *pdu = NULL;

    if (!QLIST_EMPTY(&s->free_list)) {

        pdu = QLIST_FIRST(&s->free_list);

        QLIST_REMOVE(pdu, next);

        QLIST_INSERT_HEAD(&s->active_list, pdu, next);

    }

    return pdu;

}

static void free_pdu(V9fsState *s, V9fsPDU *pdu)

{

    if (pdu) {

        /*

         * Cancelled pdu are added back to the freelist

         * by flush request .

         */

        if (!pdu->cancelled) {

            QLIST_REMOVE(pdu, next);

            QLIST_INSERT_HEAD(&s->free_list, pdu, next);

        }

    }

}

/*

 * We don't do error checking for pdu_marshal/unmarshal here

 * because we always expect to have enough space to encode

 * error details

 */

static void complete_pdu(V9fsState *s, V9fsPDU *pdu, ssize_t len)

{

    int8_t id = pdu->id + 1; /* Response */

    if (len < 0) {

        int err = -len;

        len = 7;

        if (s->proto_version != V9FS_PROTO_2000L) {

            V9fsString str;

            str.data = strerror(err);

            str.size = strlen(str.data);

            len += pdu_marshal(pdu, len, "s", &str);

            id = P9_RERROR;

        }

        len += pdu_marshal(pdu, len, "d", err);

        if (s->proto_version == V9FS_PROTO_2000L) {

            id = P9_RLERROR;

        }

        trace_v9fs_rerror(pdu->tag, pdu->id, err); /* Trace ERROR */

    }

    /* fill out the header */

    pdu_marshal(pdu, 0, "dbw", (int32_t)len, id, pdu->tag);

    /* keep these in sync */

    pdu->size = len;

    pdu->id = id;

    /* push onto queue and notify */

    virtqueue_push(s->vq, &pdu->elem, len);

    /* FIXME: we should batch these completions */

    virtio_notify(VIRTIO_DEVICE(s), s->vq);

    /* Now wakeup anybody waiting in flush for this request */

    qemu_co_queue_next(&pdu->complete);

    free_pdu(s, pdu);

}

static mode_t v9mode_to_mode(uint32_t mode, V9fsString *extension)

{

    mode_t ret;

    ret = mode & 0777;

    if (mode & P9_STAT_MODE_DIR) {

        ret |= S_IFDIR;

    }

    if (mode & P9_STAT_MODE_SYMLINK) {

        ret |= S_IFLNK;

    }

    if (mode & P9_STAT_MODE_SOCKET) {

        ret |= S_IFSOCK;

    }

    if (mode & P9_STAT_MODE_NAMED_PIPE) {

        ret |= S_IFIFO;

    }

    if (mode & P9_STAT_MODE_DEVICE) {

        if (extension->size && extension->data[0] == 'c') {

            ret |= S_IFCHR;

        } else {

            ret |= S_IFBLK;

        }

    }

    if (!(ret&~0777)) {

        ret |= S_IFREG;

    }

    if (mode & P9_STAT_MODE_SETUID) {

        ret |= S_ISUID;

    }

    if (mode & P9_STAT_MODE_SETGID) {

        ret |= S_ISGID;

    }

    if (mode & P9_STAT_MODE_SETVTX) {

        ret |= S_ISVTX;

    }

    return ret;

}

static int donttouch_stat(V9fsStat *stat)

{

    if (stat->type == -1 &&

        stat->dev == -1 &&

        stat->qid.type == -1 &&

        stat->qid.version == -1 &&

        stat->qid.path == -1 &&

        stat->mode == -1 &&

        stat->atime == -1 &&

        stat->mtime == -1 &&

        stat->length == -1 &&

        !stat->name.size &&

        !stat->uid.size &&

        !stat->gid.size &&

        !stat->muid.size &&

        stat->n_uid == -1 &&

        stat->n_gid == -1 &&

        stat->n_muid == -1) {

        return 1;

    }

    return 0;

}

static void v9fs_stat_init(V9fsStat *stat)

{

    v9fs_string_init(&stat->name);

    v9fs_string_init(&stat->uid);

    v9fs_string_init(&stat->gid);

    v9fs_string_init(&stat->muid);

    v9fs_string_init(&stat->extension);

}

static void v9fs_stat_free(V9fsStat *stat)

{

    v9fs_string_free(&stat->name);

    v9fs_string_free(&stat->uid);

    v9fs_string_free(&stat->gid);

    v9fs_string_free(&stat->muid);

    v9fs_string_free(&stat->extension);

}

static uint32_t stat_to_v9mode(const struct stat *stbuf)

{

    uint32_t mode;

    mode = stbuf->st_mode & 0777;

    if (S_ISDIR(stbuf->st_mode)) {

        mode |= P9_STAT_MODE_DIR;

    }

    if (S_ISLNK(stbuf->st_mode)) {

        mode |= P9_STAT_MODE_SYMLINK;

    }

    if (S_ISSOCK(stbuf->st_mode)) {

        mode |= P9_STAT_MODE_SOCKET;

    }

    if (S_ISFIFO(stbuf->st_mode)) {

        mode |= P9_STAT_MODE_NAMED_PIPE;

    }

    if (S_ISBLK(stbuf->st_mode) || S_ISCHR(stbuf->st_mode)) {

        mode |= P9_STAT_MODE_DEVICE;

    }

    if (stbuf->st_mode & S_ISUID) {

        mode |= P9_STAT_MODE_SETUID;

    }

    if (stbuf->st_mode & S_ISGID) {

        mode |= P9_STAT_MODE_SETGID;

    }

    if (stbuf->st_mode & S_ISVTX) {

        mode |= P9_STAT_MODE_SETVTX;

    }

    return mode;

}

static int stat_to_v9stat(V9fsPDU *pdu, V9fsPath *name,

                            const struct stat *stbuf,

                            V9fsStat *v9stat)

{

    int err;

    const char *str;

    memset(v9stat, 0, sizeof(*v9stat));

    stat_to_qid(stbuf, &v9stat->qid);

    v9stat->mode = stat_to_v9mode(stbuf);

    v9stat->atime = stbuf->st_atime;

    v9stat->mtime = stbuf->st_mtime;

    v9stat->length = stbuf->st_size;

    v9fs_string_null(&v9stat->uid);

    v9fs_string_null(&v9stat->gid);

    v9fs_string_null(&v9stat->muid);

    v9stat->n_uid = stbuf->st_uid;

    v9stat->n_gid = stbuf->st_gid;

    v9stat->n_muid = 0;

    v9fs_string_null(&v9stat->extension);

    if (v9stat->mode & P9_STAT_MODE_SYMLINK) {

        err = v9fs_co_readlink(pdu, name, &v9stat->extension);

        if (err < 0) {

            return err;

        }

    } else if (v9stat->mode & P9_STAT_MODE_DEVICE) {

        v9fs_string_sprintf(&v9stat->extension, "%c %u %u",

                S_ISCHR(stbuf->st_mode) ? 'c' : 'b',

                major(stbuf->st_rdev), minor(stbuf->st_rdev));

    } else if (S_ISDIR(stbuf->st_mode) || S_ISREG(stbuf->st_mode)) {

        v9fs_string_sprintf(&v9stat->extension, "%s %lu",

                "HARDLINKCOUNT", (unsigned long)stbuf->st_nlink);

    }

    str = strrchr(name->data, '/');

    if (str) {

        str += 1;

    } else {

        str = name->data;

    }

    v9fs_string_sprintf(&v9stat->name, "%s", str);

    v9stat->size = 61 +

        v9fs_string_size(&v9stat->name) +

        v9fs_string_size(&v9stat->uid) +

        v9fs_string_size(&v9stat->gid) +

        v9fs_string_size(&v9stat->muid) +

        v9fs_string_size(&v9stat->extension);

    return 0;

}

#define P9_STATS_MODE          0x00000001ULL

#define P9_STATS_NLINK         0x00000002ULL

#define P9_STATS_UID           0x00000004ULL

#define P9_STATS_GID           0x00000008ULL

#define P9_STATS_RDEV          0x00000010ULL

#define P9_STATS_ATIME         0x00000020ULL

#define P9_STATS_MTIME         0x00000040ULL

#define P9_STATS_CTIME         0x00000080ULL

#define P9_STATS_INO           0x00000100ULL

#define P9_STATS_SIZE          0x00000200ULL

#define P9_STATS_BLOCKS        0x00000400ULL

#define P9_STATS_BTIME         0x00000800ULL

#define P9_STATS_GEN           0x00001000ULL

#define P9_STATS_DATA_VERSION  0x00002000ULL

#define P9_STATS_BASIC         0x000007ffULL /* Mask for fields up to BLOCKS */

#define P9_STATS_ALL           0x00003fffULL /* Mask for All fields above */

static void stat_to_v9stat_dotl(V9fsState *s, const struct stat *stbuf,

                                V9fsStatDotl *v9lstat)

{

    memset(v9lstat, 0, sizeof(*v9lstat));

    v9lstat->st_mode = stbuf->st_mode;

    v9lstat->st_nlink = stbuf->st_nlink;

    v9lstat->st_uid = stbuf->st_uid;

    v9lstat->st_gid = stbuf->st_gid;

    v9lstat->st_rdev = stbuf->st_rdev;

    v9lstat->st_size = stbuf->st_size;

    v9lstat->st_blksize = stbuf->st_blksize;

    v9lstat->st_blocks = stbuf->st_blocks;

    v9lstat->st_atime_sec = stbuf->st_atime;

    v9lstat->st_atime_nsec = stbuf->st_atim.tv_nsec;

    v9lstat->st_mtime_sec = stbuf->st_mtime;

    v9lstat->st_mtime_nsec = stbuf->st_mtim.tv_nsec;

    v9lstat->st_ctime_sec = stbuf->st_ctime;

    v9lstat->st_ctime_nsec = stbuf->st_ctim.tv_nsec;

    /* Currently we only support BASIC fields in stat */

    v9lstat->st_result_mask = P9_STATS_BASIC;

    stat_to_qid(stbuf, &v9lstat->qid);

}

static void print_sg(struct iovec *sg, int cnt)

{

    int i;

    printf("sg[%d]: {", cnt);

    for (i = 0; i < cnt; i++) {

        if (i) {

            printf(", ");

        }

        printf("(%p, %zd)", sg[i].iov_base, sg[i].iov_len);

    }

    printf("}\n");

}

/* Will call this only for path name based fid */

static void v9fs_fix_path(V9fsPath *dst, V9fsPath *src, int len)

{

    V9fsPath str;

    v9fs_path_init(&str);

    v9fs_path_copy(&str, dst);

    v9fs_string_sprintf((V9fsString *)dst, "%s%s", src->data, str.data+len);

    v9fs_path_free(&str);

    /* +1 to include terminating NULL */

    dst->size++;

}

static inline bool is_ro_export(FsContext *ctx)

{

    return ctx->export_flags & V9FS_RDONLY;

}

static void v9fs_version(void *opaque)

{

    ssize_t err;

    V9fsPDU *pdu = opaque;

    V9fsState *s = pdu->s;

    V9fsString version;

    size_t offset = 7;

    v9fs_string_init(&version);

    err = pdu_unmarshal(pdu, offset, "ds", &s->msize, &version);

    if (err < 0) {

        offset = err;