Commit 9f107513 authored by Anthony Liguori's avatar Anthony Liguori
Browse files

virtio-9p: Add a virtio 9p device to qemu 



This patch doesn't implement the 9p protocol handling
code. It adds a simple device which dump the protocol data.

[jvrao@linux.vnet.ibm.com: Little-Endian to host format conversion]
[aneesh.kumar@linux.vnet.ibm.com: Multiple-mounts support]

Signed-off-by: default avatarAnthony Liguori <aliguori@us.ibm.com>
Signed-off-by: default avatarAneesh Kumar K.V <aneesh.kumar@linux.vnet.ibm.com>
Signed-off-by: default avatarAnthony Liguori <aliguori@us.ibm.com>
parent 74db920c

Makefile.target

+1 −0
Original line number Diff line number Diff line
@@ -168,6 +168,7 @@ obj-y += virtio-blk.o virtio-balloon.o virtio-net.o virtio-serial-bus.o 
obj-$(CONFIG_VIRTIO_PCI) += virtio-pci.o

obj-y += vhost_net.o

obj-$(CONFIG_VHOST_NET) += vhost.o

obj-$(CONFIG_LINUX) += virtio-9p.o virtio-9p-debug.o virtio-9p-local.o

obj-y += rwhandler.o

obj-$(CONFIG_KVM) += kvm.o kvm-all.o

obj-$(CONFIG_NO_KVM) += kvm-stub.o

fsdev/qemu-fsdev.c

+1 −1
Original line number Diff line number Diff line
@@ -21,7 +21,7 @@ static QTAILQ_HEAD(FsTypeEntry_head, FsTypeListEntry) fstype_entries = 
    QTAILQ_HEAD_INITIALIZER(fstype_entries);



static FsTypeTable FsTypes[] = {

    { .name = "local", .ops = NULL},

    { .name = "local", .ops = &local_ops},

};



int qemu_fsdev_add(QemuOpts *opts)

fsdev/qemu-fsdev.h

+1 −0
Original line number Diff line number Diff line
@@ -50,4 +50,5 @@ typedef struct FsTypeListEntry { 


extern int qemu_fsdev_add(QemuOpts *opts);

extern FsTypeEntry *get_fsdev_fsentry(char *id);

extern FileOperations local_ops;

#endif

hw/9p.h

0 → 100644
+26 −0
Original line number Diff line number Diff line 
/*

 * Virtio 9p

 *

 * Copyright IBM, Corp. 2010

 *

 * Authors:

 *  Aneesh Kumar K.V <aneesh.kumar@linux.vnet.ibm.com>

 *

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

 * the COPYING file in the top-level directory.

 *

 */



#ifndef QEMU_9P_H

#define QEMU_9P_H



#include <stdbool.h>



typedef struct V9fsConf

{

    /* tag name for the device */

    char *tag;

    char *fsdev_id;

} V9fsConf;



#endif

hw/virtio-9p-debug.c

0 → 100644
+484 −0
Original line number Diff line number Diff line 
/*

 * Virtio 9p PDU debug

 *

 * 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 "virtio.h"

#include "pc.h"

#include "virtio-9p.h"

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



#define BUG_ON(cond) assert(!(cond))



static FILE *llogfile;



static struct iovec *get_sg(V9fsPDU *pdu, int rx)

{

    if (rx) {

        return pdu->elem.in_sg;

    }

    return pdu->elem.out_sg;

}



static int get_sg_count(V9fsPDU *pdu, int rx)

{

    if (rx) {

        return pdu->elem.in_num;

    }

    return pdu->elem.out_num;



}



static void pprint_int8(V9fsPDU *pdu, int rx, size_t *offsetp,

                        const char *name)

{

    size_t copied;

    int count = get_sg_count(pdu, rx);

    size_t offset = *offsetp;

    struct iovec *sg = get_sg(pdu, rx);

    int8_t value;



    copied = do_pdu_unpack(&value, sg, count, offset, sizeof(value));



    BUG_ON(copied != sizeof(value));

    offset += sizeof(value);

    fprintf(llogfile, "%s=0x%x", name, value);

    *offsetp = offset;

}



static void pprint_int16(V9fsPDU *pdu, int rx, size_t *offsetp,

                        const char *name)

{

    size_t copied;

    int count = get_sg_count(pdu, rx);

    struct iovec *sg = get_sg(pdu, rx);

    size_t offset = *offsetp;

    int16_t value;





    copied = do_pdu_unpack(&value, sg, count, offset, sizeof(value));



    BUG_ON(copied != sizeof(value));

    offset += sizeof(value);

    fprintf(llogfile, "%s=0x%x", name, value);

    *offsetp = offset;

}



static void pprint_int32(V9fsPDU *pdu, int rx, size_t *offsetp,

                        const char *name)

{

    size_t copied;

    int count = get_sg_count(pdu, rx);

    struct iovec *sg = get_sg(pdu, rx);

    size_t offset = *offsetp;

    int32_t value;





    copied = do_pdu_unpack(&value, sg, count, offset, sizeof(value));



    BUG_ON(copied != sizeof(value));

    offset += sizeof(value);

    fprintf(llogfile, "%s=0x%x", name, value);

    *offsetp = offset;

}



static void pprint_int64(V9fsPDU *pdu, int rx, size_t *offsetp,

                        const char *name)

{

    size_t copied;

    int count = get_sg_count(pdu, rx);

    struct iovec *sg = get_sg(pdu, rx);

    size_t offset = *offsetp;

    int64_t value;





    copied = do_pdu_unpack(&value, sg, count, offset, sizeof(value));



    BUG_ON(copied != sizeof(value));

    offset += sizeof(value);

    fprintf(llogfile, "%s=0x%" PRIx64, name, value);

    *offsetp = offset;

}



static void pprint_str(V9fsPDU *pdu, int rx, size_t *offsetp, const char *name)

{

    int sg_count = get_sg_count(pdu, rx);

    struct iovec *sg = get_sg(pdu, rx);

    size_t offset = *offsetp;

    uint16_t tmp_size, size;

    size_t result;

    size_t copied = 0;

    int i = 0;



    /* get the size */

    copied = do_pdu_unpack(&tmp_size, sg, sg_count, offset, sizeof(tmp_size));

    BUG_ON(copied != sizeof(tmp_size));

    size = le16_to_cpupu(&tmp_size);

    offset += copied;



    fprintf(llogfile, "%s=", name);

    for (i = 0; size && i < sg_count; i++) {

        size_t len;

        if (offset >= sg[i].iov_len) {

            /* skip this sg */

            offset -= sg[i].iov_len;

            continue;

        } else {

            len = MIN(sg[i].iov_len - offset, size);

            result = fwrite(sg[i].iov_base + offset, 1, len, llogfile);

            BUG_ON(result != len);

            size -= len;

            copied += len;

            if (size) {

                offset = 0;

                continue;

            }

        }

    }

    *offsetp += copied;

}



static void pprint_qid(V9fsPDU *pdu, int rx, size_t *offsetp, const char *name)

{

    fprintf(llogfile, "%s={", name);

    pprint_int8(pdu, rx, offsetp, "type");

    pprint_int32(pdu, rx, offsetp, ", version");

    pprint_int64(pdu, rx, offsetp, ", path");

    fprintf(llogfile, "}");

}



static void pprint_stat(V9fsPDU *pdu, int rx, size_t *offsetp, const char *name)

{

    fprintf(llogfile, "%s={", name);

    pprint_int16(pdu, rx, offsetp, "size");

    pprint_int16(pdu, rx, offsetp, ", type");

    pprint_int32(pdu, rx, offsetp, ", dev");

    pprint_qid(pdu, rx, offsetp, ", qid");

    pprint_int32(pdu, rx, offsetp, ", mode");

    pprint_int32(pdu, rx, offsetp, ", atime");

    pprint_int32(pdu, rx, offsetp, ", mtime");

    pprint_int64(pdu, rx, offsetp, ", length");

    pprint_str(pdu, rx, offsetp, ", name");

    pprint_str(pdu, rx, offsetp, ", uid");

    pprint_str(pdu, rx, offsetp, ", gid");

    pprint_str(pdu, rx, offsetp, ", muid");

    if (dotu) {

        pprint_str(pdu, rx, offsetp, ", extension");

        pprint_int32(pdu, rx, offsetp, ", uid");

        pprint_int32(pdu, rx, offsetp, ", gid");

        pprint_int32(pdu, rx, offsetp, ", muid");

    }

    fprintf(llogfile, "}");

}



static void pprint_strs(V9fsPDU *pdu, int rx, size_t *offsetp, const char *name)

{

    int sg_count = get_sg_count(pdu, rx);

    struct iovec *sg = get_sg(pdu, rx);

    size_t offset = *offsetp;

    uint16_t tmp_count, count, i;

    size_t copied = 0;



    fprintf(llogfile, "%s={", name);



    /* Get the count */

    copied = do_pdu_unpack(&tmp_count, sg, sg_count, offset, sizeof(tmp_count));

    BUG_ON(copied != sizeof(tmp_count));

    count = le16_to_cpupu(&tmp_count);

    offset += copied;



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

        char str[512];

        if (i) {

            fprintf(llogfile, ", ");

        }

        snprintf(str, sizeof(str), "[%d]", i);

        pprint_str(pdu, rx, &offset, str);

    }



    fprintf(llogfile, "}");



    *offsetp = offset;

}



static void pprint_qids(V9fsPDU *pdu, int rx, size_t *offsetp, const char *name)

{

    int sg_count = get_sg_count(pdu, rx);

    struct iovec *sg = get_sg(pdu, rx);

    size_t offset = *offsetp;

    uint16_t tmp_count, count, i;

    size_t copied = 0;



    fprintf(llogfile, "%s={", name);



    copied = do_pdu_unpack(&tmp_count, sg, sg_count, offset, sizeof(tmp_count));

    BUG_ON(copied != sizeof(tmp_count));

    count = le16_to_cpupu(&tmp_count);

    offset += copied;



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

        char str[512];

        if (i) {

            fprintf(llogfile, ", ");

        }

        snprintf(str, sizeof(str), "[%d]", i);

        pprint_qid(pdu, rx, &offset, str);

    }



    fprintf(llogfile, "}");



    *offsetp = offset;

}



static void pprint_sg(V9fsPDU *pdu, int rx, size_t *offsetp, const char *name)

{

    struct iovec *sg = get_sg(pdu, rx);

    unsigned int count;

    int i;



    if (rx) {

        count = pdu->elem.in_num;

    } else {

        count = pdu->elem.out_num;

    }



    fprintf(llogfile, "%s={", name);

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

        if (i) {

            fprintf(llogfile, ", ");

        }

        fprintf(llogfile, "(%p, 0x%zx)", sg[i].iov_base, sg[i].iov_len);

    }

    fprintf(llogfile, "}");

}



/* FIXME: read from a directory fid returns serialized stat_t's */

#ifdef DEBUG_DATA

static void pprint_data(V9fsPDU *pdu, int rx, size_t *offsetp, const char *name)

{

    struct iovec *sg = get_sg(pdu, rx);

    size_t offset = *offsetp;

    unsigned int count;

    int32_t size;

    int total, i, j;

    ssize_t len;



    if (rx) {

        count = pdu->elem.in_num;

    } else

        count = pdu->elem.out_num;

    }



    BUG_ON((offset + sizeof(size)) > sg[0].iov_len);



    memcpy(&size, sg[0].iov_base + offset, sizeof(size));

    offset += sizeof(size);



    fprintf(llogfile, "size: %x\n", size);



    sg[0].iov_base += 11; /* skip header */

    sg[0].iov_len -= 11;



    total = 0;

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

        total += sg[i].iov_len;

        if (total >= size) {

            /* trim sg list so writev does the right thing */

            sg[i].iov_len -= (total - size);

            i++;

            break;

        }

    }



    fprintf(llogfile, "%s={\"", name);

    fflush(llogfile);

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

        if (j) {

            fprintf(llogfile, "\", \"");

            fflush(llogfile);

        }



        do {

            len = writev(fileno(llogfile), &sg[j], 1);

        } while (len == -1 && errno == EINTR);

        fprintf(llogfile, "len == %ld: %m\n", len);

        BUG_ON(len != sg[j].iov_len);

    }

    fprintf(llogfile, "\"}");



    sg[0].iov_base -= 11;

    sg[0].iov_len += 11;



}

#endif



void pprint_pdu(V9fsPDU *pdu)

{

    size_t offset = 7;



    if (llogfile == NULL) {

        llogfile = fopen("/tmp/pdu.log", "w");

    }



    switch (pdu->id) {

    case P9_TVERSION:

        fprintf(llogfile, "TVERSION: (");

        pprint_int32(pdu, 0, &offset, "msize");

        pprint_str(pdu, 0, &offset, ", version");

        break;

    case P9_RVERSION:

        fprintf(llogfile, "RVERSION: (");

        pprint_int32(pdu, 1, &offset, "msize");

        pprint_str(pdu, 1, &offset, ", version");

        break;

    case P9_TAUTH:

        fprintf(llogfile, "TAUTH: (");

        pprint_int32(pdu, 0, &offset, "afid");

        pprint_str(pdu, 0, &offset, ", uname");

        pprint_str(pdu, 0, &offset, ", aname");

        if (dotu) {

            pprint_int32(pdu, 0, &offset, ", n_uname");

        }

        break;

    case P9_RAUTH:

        fprintf(llogfile, "RAUTH: (");

        pprint_qid(pdu, 1, &offset, "qid");

        break;

    case P9_TATTACH:

        fprintf(llogfile, "TATTACH: (");

        pprint_int32(pdu, 0, &offset, "fid");

        pprint_int32(pdu, 0, &offset, ", afid");

        pprint_str(pdu, 0, &offset, ", uname");

        pprint_str(pdu, 0, &offset, ", aname");

        if (dotu) {

            pprint_int32(pdu, 0, &offset, ", n_uname");

        }

        break;

    case P9_RATTACH:

        fprintf(llogfile, "RATTACH: (");

        pprint_qid(pdu, 1, &offset, "qid");

        break;

    case P9_TERROR:

        fprintf(llogfile, "TERROR: (");

        break;

    case P9_RERROR:

        fprintf(llogfile, "RERROR: (");

        pprint_str(pdu, 1, &offset, "ename");

        if (dotu) {

            pprint_int32(pdu, 1, &offset, ", ecode");

        }

        break;

    case P9_TFLUSH:

        fprintf(llogfile, "TFLUSH: (");

        pprint_int16(pdu, 0, &offset, "oldtag");

        break;

    case P9_RFLUSH:

        fprintf(llogfile, "RFLUSH: (");

        break;

    case P9_TWALK:

        fprintf(llogfile, "TWALK: (");

        pprint_int32(pdu, 0, &offset, "fid");

        pprint_int32(pdu, 0, &offset, ", newfid");

        pprint_strs(pdu, 0, &offset, ", wnames");

        break;

    case P9_RWALK:

        fprintf(llogfile, "RWALK: (");

        pprint_qids(pdu, 1, &offset, "wqids");

        break;

    case P9_TOPEN:

        fprintf(llogfile, "TOPEN: (");

        pprint_int32(pdu, 0, &offset, "fid");

        pprint_int8(pdu, 0, &offset, ", mode");

        break;

    case P9_ROPEN:

        fprintf(llogfile, "ROPEN: (");

        pprint_qid(pdu, 1, &offset, "qid");

        pprint_int32(pdu, 1, &offset, ", iounit");

        break;

    case P9_TCREATE:

        fprintf(llogfile, "TCREATE: (");

        pprint_int32(pdu, 0, &offset, "fid");

        pprint_str(pdu, 0, &offset, ", name");

        pprint_int32(pdu, 0, &offset, ", perm");

        pprint_int8(pdu, 0, &offset, ", mode");

        if (dotu) {

            pprint_str(pdu, 0, &offset, ", extension");

        }

        break;

    case P9_RCREATE:

        fprintf(llogfile, "RCREATE: (");

        pprint_qid(pdu, 1, &offset, "qid");

        pprint_int32(pdu, 1, &offset, ", iounit");

        break;

    case P9_TREAD:

        fprintf(llogfile, "TREAD: (");

        pprint_int32(pdu, 0, &offset, "fid");

        pprint_int64(pdu, 0, &offset, ", offset");

        pprint_int32(pdu, 0, &offset, ", count");

        pprint_sg(pdu, 0, &offset, ", sg");

        break;

    case P9_RREAD:

        fprintf(llogfile, "RREAD: (");

        pprint_int32(pdu, 1, &offset, "count");

        pprint_sg(pdu, 1, &offset, ", sg");

        offset = 7;

#ifdef DEBUG_DATA

        pprint_data(pdu, 1, &offset, ", data");

#endif

        break;

    case P9_TWRITE:

        fprintf(llogfile, "TWRITE: (");

        pprint_int32(pdu, 0, &offset, "fid");

        pprint_int64(pdu, 0, &offset, ", offset");

        pprint_int32(pdu, 0, &offset, ", count");

        break;

    case P9_RWRITE:

        fprintf(llogfile, "RWRITE: (");

        pprint_int32(pdu, 1, &offset, "count");

        break;

    case P9_TCLUNK:

        fprintf(llogfile, "TCLUNK: (");

        pprint_int32(pdu, 0, &offset, "fid");

        break;

    case P9_RCLUNK:

        fprintf(llogfile, "RCLUNK: (");

        break;

    case P9_TREMOVE:

        fprintf(llogfile, "TREMOVE: (");

        pprint_int32(pdu, 0, &offset, "fid");

        break;

    case P9_RREMOVE:

        fprintf(llogfile, "RREMOVE: (");

        break;

    case P9_TSTAT:

        fprintf(llogfile, "TSTAT: (");

        pprint_int32(pdu, 0, &offset, "fid");

        break;

    case P9_RSTAT:

        fprintf(llogfile, "RSTAT: (");

        offset += 2; /* ignored */

        pprint_stat(pdu, 1, &offset, "stat");

        break;

    case P9_TWSTAT:

        fprintf(llogfile, "TWSTAT: (");

        pprint_int32(pdu, 0, &offset, "fid");

        offset += 2; /* ignored */

        pprint_stat(pdu, 0, &offset, ", stat");

        break;

    case P9_RWSTAT:

        fprintf(llogfile, "RWSTAT: (");

        break;

    default:

        fprintf(llogfile, "unknown(%d): (", pdu->id);

        break;

    }



    fprintf(llogfile, ")\n");

}