[qemu.git] / hw / 9pfs / virtio-9p-debug.c

/*
 * 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 "hw/virtio.h"
#include "hw/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");
    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_stat_dotl(V9fsPDU *pdu, int rx, size_t *offsetp,
                                                  const char *name)
{
    fprintf(llogfile, "%s={", name);
    pprint_qid(pdu, rx, offsetp, "qid");
    pprint_int32(pdu, rx, offsetp, ", st_mode");
    pprint_int64(pdu, rx, offsetp, ", st_nlink");
    pprint_int32(pdu, rx, offsetp, ", st_uid");
    pprint_int32(pdu, rx, offsetp, ", st_gid");
    pprint_int64(pdu, rx, offsetp, ", st_rdev");
    pprint_int64(pdu, rx, offsetp, ", st_size");
    pprint_int64(pdu, rx, offsetp, ", st_blksize");
    pprint_int64(pdu, rx, offsetp, ", st_blocks");
    pprint_int64(pdu, rx, offsetp, ", atime");
    pprint_int64(pdu, rx, offsetp, ", atime_nsec");
    pprint_int64(pdu, rx, offsetp, ", mtime");
    pprint_int64(pdu, rx, offsetp, ", mtime_nsec");
    pprint_int64(pdu, rx, offsetp, ", ctime");
    pprint_int64(pdu, rx, offsetp, ", ctime_nsec");
    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");
    }

    BUG_ON(!llogfile);

    switch (pdu->id) {
    case P9_TREADDIR:
        fprintf(llogfile, "TREADDIR: (");
        pprint_int32(pdu, 0, &offset, "fid");
        pprint_int64(pdu, 0, &offset, ", initial offset");
        pprint_int32(pdu, 0, &offset, ", max count");
        break;
    case P9_RREADDIR:
        fprintf(llogfile, "RREADDIR: (");
        pprint_int32(pdu, 1, &offset, "count");
#ifdef DEBUG_DATA
        pprint_data(pdu, 1, &offset, ", data");
#endif
        break;
    case P9_TMKDIR:
        fprintf(llogfile, "TMKDIR: (");
        pprint_int32(pdu, 0, &offset, "fid");
        pprint_str(pdu, 0, &offset, "name");
        pprint_int32(pdu, 0, &offset, "mode");
        pprint_int32(pdu, 0, &offset, "gid");
        break;
    case P9_RMKDIR:
        fprintf(llogfile, "RMKDIR: (");
        pprint_qid(pdu, 0, &offset, "qid");
        break;
    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_TGETATTR:
        fprintf(llogfile, "TGETATTR: (");
        pprint_int32(pdu, 0, &offset, "fid");
        break;
    case P9_RGETATTR:
        fprintf(llogfile, "RGETATTR: (");
        pprint_stat_dotl(pdu, 1, &offset, "getattr");
        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");
        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");
        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");
        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");
        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_TSYMLINK:
        fprintf(llogfile, "TSYMLINK: (");
        pprint_int32(pdu, 0, &offset, "fid");
        pprint_str(pdu, 0, &offset, ", name");
        pprint_str(pdu, 0, &offset, ", symname");
        pprint_int32(pdu, 0, &offset, ", gid");
        break;
    case P9_RSYMLINK:
        fprintf(llogfile, "RSYMLINK: (");
        pprint_qid(pdu, 1, &offset, "qid");
        break;
    case P9_TLCREATE:
        fprintf(llogfile, "TLCREATE: (");
        pprint_int32(pdu, 0, &offset, "dfid");
        pprint_str(pdu, 0, &offset, ", name");
        pprint_int32(pdu, 0, &offset, ", flags");
        pprint_int32(pdu, 0, &offset, ", mode");
        pprint_int32(pdu, 0, &offset, ", gid");
        break;
    case P9_RLCREATE:
        fprintf(llogfile, "RLCREATE: (");
        pprint_qid(pdu, 1, &offset, "qid");
        pprint_int32(pdu, 1, &offset, ", iounit");
        break;
    case P9_TMKNOD:
	fprintf(llogfile, "TMKNOD: (");
        pprint_int32(pdu, 0, &offset, "fid");
        pprint_str(pdu, 0, &offset, "name");
        pprint_int32(pdu, 0, &offset, "mode");
        pprint_int32(pdu, 0, &offset, "major");
        pprint_int32(pdu, 0, &offset, "minor");
        pprint_int32(pdu, 0, &offset, "gid");
        break;
    case P9_RMKNOD:
        fprintf(llogfile, "RMKNOD: )");
        pprint_qid(pdu, 0, &offset, "qid");
        break;
    case P9_TREADLINK:
	fprintf(llogfile, "TREADLINK: (");
        pprint_int32(pdu, 0, &offset, "fid");
        break;
    case P9_RREADLINK:
	fprintf(llogfile, "RREADLINK: (");
        pprint_str(pdu, 0, &offset, "target");
        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_TFSYNC:
        fprintf(llogfile, "TFSYNC: (");
        pprint_int32(pdu, 0, &offset, "fid");
        break;
    case P9_RFSYNC:
        fprintf(llogfile, "RFSYNC: (");
        break;
    case P9_TLINK:
        fprintf(llogfile, "TLINK: (");
        pprint_int32(pdu, 0, &offset, "dfid");
        pprint_int32(pdu, 0, &offset, ", fid");
        pprint_str(pdu, 0, &offset, ", newpath");
        break;
    case P9_RLINK:
        fprintf(llogfile, "RLINK: (");
        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;
    case P9_TXATTRWALK:
        fprintf(llogfile, "TXATTRWALK: (");
        pprint_int32(pdu, 0, &offset, "fid");
        pprint_int32(pdu, 0, &offset, ", newfid");
        pprint_str(pdu, 0, &offset, ", xattr name");
        break;
    case P9_RXATTRWALK:
        fprintf(llogfile, "RXATTRWALK: (");
        pprint_int64(pdu, 1, &offset, "xattrsize");
    case P9_TXATTRCREATE:
        fprintf(llogfile, "TXATTRCREATE: (");
        pprint_int32(pdu, 0, &offset, "fid");
        pprint_str(pdu, 0, &offset, ", name");
        pprint_int64(pdu, 0, &offset, ", xattrsize");
        pprint_int32(pdu, 0, &offset, ", flags");
        break;
    case P9_RXATTRCREATE:
        fprintf(llogfile, "RXATTRCREATE: (");
        break;
    case P9_TLOCK:
        fprintf(llogfile, "TLOCK: (");
        pprint_int32(pdu, 0, &offset, "fid");
        pprint_int8(pdu, 0, &offset, ", type");
        pprint_int32(pdu, 0, &offset, ", flags");
        pprint_int64(pdu, 0, &offset, ", start");
        pprint_int64(pdu, 0, &offset, ", length");
        pprint_int32(pdu, 0, &offset, ", proc_id");
        pprint_str(pdu, 0, &offset, ", client_id");
        break;
    case P9_RLOCK:
        fprintf(llogfile, "RLOCK: (");
        pprint_int8(pdu, 0, &offset, "status");
        break;
    case P9_TGETLOCK:
        fprintf(llogfile, "TGETLOCK: (");
        pprint_int32(pdu, 0, &offset, "fid");
        pprint_int8(pdu, 0, &offset, ", type");
        pprint_int64(pdu, 0, &offset, ", start");
        pprint_int64(pdu, 0, &offset, ", length");
        pprint_int32(pdu, 0, &offset, ", proc_id");
        pprint_str(pdu, 0, &offset, ", client_id");
        break;
    case P9_RGETLOCK:
        fprintf(llogfile, "RGETLOCK: (");
        pprint_int8(pdu, 0, &offset, "type");
        pprint_int64(pdu, 0, &offset, ", start");
        pprint_int64(pdu, 0, &offset, ", length");
        pprint_int32(pdu, 0, &offset, ", proc_id");
        pprint_str(pdu, 0, &offset, ", client_id");
        break;
    default:
        fprintf(llogfile, "unknown(%d): (", pdu->id);
        break;
    }

    fprintf(llogfile, ")\n");
    /* Flush the log message out */
    fflush(llogfile);
}
Commit	Line	Data
9f107513 AL	1	/*
	2	* Virtio 9p PDU debug
	3	*
	4	* Copyright IBM, Corp. 2010
	5	*
	6	* Authors:
	7	* Anthony Liguori <aliguori@us.ibm.com>
	8	*
	9	* This work is licensed under the terms of the GNU GPL, version 2. See
	10	* the COPYING file in the top-level directory.
	11	*
	12	*/
873c3213 SW	13
	14	#include "hw/virtio.h"
	15	#include "hw/pc.h"
9f107513 AL	16	#include "virtio-9p.h"
	17	#include "virtio-9p-debug.h"
	18
	19	#define BUG_ON(cond) assert(!(cond))
	20
	21	static FILE *llogfile;
	22
	23	static struct iovec get_sg(V9fsPDU pdu, int rx)
	24	{
	25	if (rx) {
	26	return pdu->elem.in_sg;
	27	}
	28	return pdu->elem.out_sg;
	29	}
	30
	31	static int get_sg_count(V9fsPDU *pdu, int rx)
	32	{
	33	if (rx) {
	34	return pdu->elem.in_num;
	35	}
	36	return pdu->elem.out_num;
	37
	38	}
	39
	40	static void pprint_int8(V9fsPDU pdu, int rx, size_t offsetp,
	41	const char *name)
	42	{
	43	size_t copied;
	44	int count = get_sg_count(pdu, rx);
	45	size_t offset = *offsetp;
	46	struct iovec *sg = get_sg(pdu, rx);
	47	int8_t value;
	48
	49	copied = do_pdu_unpack(&value, sg, count, offset, sizeof(value));
	50
	51	BUG_ON(copied != sizeof(value));
	52	offset += sizeof(value);
	53	fprintf(llogfile, "%s=0x%x", name, value);
	54	*offsetp = offset;
	55	}
	56
	57	static void pprint_int16(V9fsPDU pdu, int rx, size_t offsetp,
	58	const char *name)
	59	{
	60	size_t copied;
	61	int count = get_sg_count(pdu, rx);
	62	struct iovec *sg = get_sg(pdu, rx);
	63	size_t offset = *offsetp;
	64	int16_t value;
	65
	66
	67	copied = do_pdu_unpack(&value, sg, count, offset, sizeof(value));
	68
	69	BUG_ON(copied != sizeof(value));
	70	offset += sizeof(value);
	71	fprintf(llogfile, "%s=0x%x", name, value);
	72	*offsetp = offset;
	73	}
	74
	75	static void pprint_int32(V9fsPDU pdu, int rx, size_t offsetp,
	76	const char *name)
	77	{
	78	size_t copied;
	79	int count = get_sg_count(pdu, rx);
80	struct iovec *sg = get_sg(pdu, rx);
81	size_t offset = *offsetp;
82	int32_t value;
83
84
85	copied = do_pdu_unpack(&value, sg, count, offset, sizeof(value));
86
87	BUG_ON(copied != sizeof(value));
88	offset += sizeof(value);
89	fprintf(llogfile, "%s=0x%x", name, value);
90	*offsetp = offset;
91	}
92
93	static void pprint_int64(V9fsPDU pdu, int rx, size_t offsetp,
94	const char *name)
95	{
96	size_t copied;
97	int count = get_sg_count(pdu, rx);
98	struct iovec *sg = get_sg(pdu, rx);
99	size_t offset = *offsetp;
100	int64_t value;
101
102
103	copied = do_pdu_unpack(&value, sg, count, offset, sizeof(value));
104
105	BUG_ON(copied != sizeof(value));
106	offset += sizeof(value);
107	fprintf(llogfile, "%s=0x%" PRIx64, name, value);
108	*offsetp = offset;
109	}
110
111	static void pprint_str(V9fsPDU pdu, int rx, size_t offsetp, const char *name)
112	{
113	int sg_count = get_sg_count(pdu, rx);
114	struct iovec *sg = get_sg(pdu, rx);
115	size_t offset = *offsetp;
116	uint16_t tmp_size, size;
117	size_t result;
118	size_t copied = 0;
119	int i = 0;
120
121	/* get the size */
122	copied = do_pdu_unpack(&tmp_size, sg, sg_count, offset, sizeof(tmp_size));
123	BUG_ON(copied != sizeof(tmp_size));
124	size = le16_to_cpupu(&tmp_size);
125	offset += copied;
126
127	fprintf(llogfile, "%s=", name);
128	for (i = 0; size && i < sg_count; i++) {
129	size_t len;
130	if (offset >= sg[i].iov_len) {
131	/* skip this sg */
132	offset -= sg[i].iov_len;
133	continue;
134	} else {
135	len = MIN(sg[i].iov_len - offset, size);
136	result = fwrite(sg[i].iov_base + offset, 1, len, llogfile);
137	BUG_ON(result != len);
138	size -= len;
139	copied += len;
140	if (size) {
141	offset = 0;
142	continue;
143	}
144	}
145	}
146	*offsetp += copied;
147	}
148
149	static void pprint_qid(V9fsPDU pdu, int rx, size_t offsetp, const char *name)
150	{
151	fprintf(llogfile, "%s={", name);
152	pprint_int8(pdu, rx, offsetp, "type");
153	pprint_int32(pdu, rx, offsetp, ", version");
154	pprint_int64(pdu, rx, offsetp, ", path");
155	fprintf(llogfile, "}");
156	}
157
158	static void pprint_stat(V9fsPDU pdu, int rx, size_t offsetp, const char *name)
159	{
160	fprintf(llogfile, "%s={", name);
161	pprint_int16(pdu, rx, offsetp, "size");
162	pprint_int16(pdu, rx, offsetp, ", type");
163	pprint_int32(pdu, rx, offsetp, ", dev");
164	pprint_qid(pdu, rx, offsetp, ", qid");
165	pprint_int32(pdu, rx, offsetp, ", mode");
166	pprint_int32(pdu, rx, offsetp, ", atime");
167	pprint_int32(pdu, rx, offsetp, ", mtime");
168	pprint_int64(pdu, rx, offsetp, ", length");
169	pprint_str(pdu, rx, offsetp, ", name");
170	pprint_str(pdu, rx, offsetp, ", uid");
171	pprint_str(pdu, rx, offsetp, ", gid");
172	pprint_str(pdu, rx, offsetp, ", muid");
cf03eb2c AB	173	pprint_str(pdu, rx, offsetp, ", extension");
	174	pprint_int32(pdu, rx, offsetp, ", uid");
	175	pprint_int32(pdu, rx, offsetp, ", gid");
	176	pprint_int32(pdu, rx, offsetp, ", muid");
9f107513 AL	177	fprintf(llogfile, "}");
	178	}
	179
00ede4c2 SK	180	static void pprint_stat_dotl(V9fsPDU pdu, int rx, size_t offsetp,
	181	const char *name)
	182	{
	183	fprintf(llogfile, "%s={", name);
	184	pprint_qid(pdu, rx, offsetp, "qid");
	185	pprint_int32(pdu, rx, offsetp, ", st_mode");
	186	pprint_int64(pdu, rx, offsetp, ", st_nlink");
	187	pprint_int32(pdu, rx, offsetp, ", st_uid");
	188	pprint_int32(pdu, rx, offsetp, ", st_gid");
	189	pprint_int64(pdu, rx, offsetp, ", st_rdev");
	190	pprint_int64(pdu, rx, offsetp, ", st_size");
	191	pprint_int64(pdu, rx, offsetp, ", st_blksize");
	192	pprint_int64(pdu, rx, offsetp, ", st_blocks");
	193	pprint_int64(pdu, rx, offsetp, ", atime");
	194	pprint_int64(pdu, rx, offsetp, ", atime_nsec");
	195	pprint_int64(pdu, rx, offsetp, ", mtime");
	196	pprint_int64(pdu, rx, offsetp, ", mtime_nsec");
	197	pprint_int64(pdu, rx, offsetp, ", ctime");
	198	pprint_int64(pdu, rx, offsetp, ", ctime_nsec");
	199	fprintf(llogfile, "}");
	200	}
	201
	202
	203
9f107513 AL	204	static void pprint_strs(V9fsPDU pdu, int rx, size_t offsetp, const char *name)
	205	{
	206	int sg_count = get_sg_count(pdu, rx);
	207	struct iovec *sg = get_sg(pdu, rx);
	208	size_t offset = *offsetp;
	209	uint16_t tmp_count, count, i;
	210	size_t copied = 0;
	211
	212	fprintf(llogfile, "%s={", name);
	213
	214	/* Get the count */
	215	copied = do_pdu_unpack(&tmp_count, sg, sg_count, offset, sizeof(tmp_count));
	216	BUG_ON(copied != sizeof(tmp_count));
	217	count = le16_to_cpupu(&tmp_count);
	218	offset += copied;
	219
	220	for (i = 0; i < count; i++) {
	221	char str[512];
	222	if (i) {
	223	fprintf(llogfile, ", ");
	224	}
	225	snprintf(str, sizeof(str), "[%d]", i);
	226	pprint_str(pdu, rx, &offset, str);
	227	}
	228
	229	fprintf(llogfile, "}");
	230
	231	*offsetp = offset;
	232	}
	233
	234	static void pprint_qids(V9fsPDU pdu, int rx, size_t offsetp, const char *name)
	235	{
	236	int sg_count = get_sg_count(pdu, rx);
	237	struct iovec *sg = get_sg(pdu, rx);
	238	size_t offset = *offsetp;
	239	uint16_t tmp_count, count, i;
	240	size_t copied = 0;
	241
	242	fprintf(llogfile, "%s={", name);
	243
	244	copied = do_pdu_unpack(&tmp_count, sg, sg_count, offset, sizeof(tmp_count));
	245	BUG_ON(copied != sizeof(tmp_count));
	246	count = le16_to_cpupu(&tmp_count);
	247	offset += copied;
	248
	249	for (i = 0; i < count; i++) {
	250	char str[512];
	251	if (i) {
	252	fprintf(llogfile, ", ");
	253	}
	254	snprintf(str, sizeof(str), "[%d]", i);
	255	pprint_qid(pdu, rx, &offset, str);
	256	}
	257
	258	fprintf(llogfile, "}");
	259
	260	*offsetp = offset;
	261	}
	262
	263	static void pprint_sg(V9fsPDU pdu, int rx, size_t offsetp, const char *name)
	264	{
	265	struct iovec *sg = get_sg(pdu, rx);
	266	unsigned int count;
	267	int i;
268
269	if (rx) {
270	count = pdu->elem.in_num;
271	} else {
272	count = pdu->elem.out_num;
273	}
274
275	fprintf(llogfile, "%s={", name);
276	for (i = 0; i < count; i++) {
277	if (i) {
278	fprintf(llogfile, ", ");
279	}
280	fprintf(llogfile, "(%p, 0x%zx)", sg[i].iov_base, sg[i].iov_len);
281	}
282	fprintf(llogfile, "}");
283	}
284
285	/* FIXME: read from a directory fid returns serialized stat_t's */
286	#ifdef DEBUG_DATA
287	static void pprint_data(V9fsPDU pdu, int rx, size_t offsetp, const char *name)
288	{
289	struct iovec *sg = get_sg(pdu, rx);
290	size_t offset = *offsetp;
291	unsigned int count;
292	int32_t size;
293	int total, i, j;
294	ssize_t len;
295
296	if (rx) {
297	count = pdu->elem.in_num;
069d89b8	298	} else {
9f107513 AL	299	count = pdu->elem.out_num;
	300	}
	301
	302	BUG_ON((offset + sizeof(size)) > sg[0].iov_len);
	303
	304	memcpy(&size, sg[0].iov_base + offset, sizeof(size));
	305	offset += sizeof(size);
	306
	307	fprintf(llogfile, "size: %x\n", size);
	308
	309	sg[0].iov_base += 11; /* skip header */
	310	sg[0].iov_len -= 11;
	311
	312	total = 0;
	313	for (i = 0; i < count; i++) {
	314	total += sg[i].iov_len;
	315	if (total >= size) {
	316	/* trim sg list so writev does the right thing */
	317	sg[i].iov_len -= (total - size);
	318	i++;
	319	break;
	320	}
	321	}
	322
	323	fprintf(llogfile, "%s={\"", name);
	324	fflush(llogfile);
	325	for (j = 0; j < i; j++) {
	326	if (j) {
	327	fprintf(llogfile, "\", \"");
	328	fflush(llogfile);
	329	}
	330
	331	do {
	332	len = writev(fileno(llogfile), &sg[j], 1);
	333	} while (len == -1 && errno == EINTR);
	334	fprintf(llogfile, "len == %ld: %m\n", len);
	335	BUG_ON(len != sg[j].iov_len);
	336	}
	337	fprintf(llogfile, "\"}");
	338
	339	sg[0].iov_base -= 11;
	340	sg[0].iov_len += 11;
	341
	342	}
	343	#endif
	344
	345	void pprint_pdu(V9fsPDU *pdu)
	346	{
	347	size_t offset = 7;
	348
	349	if (llogfile == NULL) {
	350	llogfile = fopen("/tmp/pdu.log", "w");
	351	}
	352
a03c54f1 SK	353	BUG_ON(!llogfile);
a03c54f1 SK	354
9f107513	355	switch (pdu->id) {
c18e2f94 SK	356	case P9_TREADDIR:
	357	fprintf(llogfile, "TREADDIR: (");
	358	pprint_int32(pdu, 0, &offset, "fid");
	359	pprint_int64(pdu, 0, &offset, ", initial offset");
	360	pprint_int32(pdu, 0, &offset, ", max count");
	361	break;
	362	case P9_RREADDIR:
	363	fprintf(llogfile, "RREADDIR: (");
	364	pprint_int32(pdu, 1, &offset, "count");
	365	#ifdef DEBUG_DATA
	366	pprint_data(pdu, 1, &offset, ", data");
	367	#endif
	368	break;
b67592ea MK	369	case P9_TMKDIR:
	370	fprintf(llogfile, "TMKDIR: (");
	371	pprint_int32(pdu, 0, &offset, "fid");
	372	pprint_str(pdu, 0, &offset, "name");
	373	pprint_int32(pdu, 0, &offset, "mode");
	374	pprint_int32(pdu, 0, &offset, "gid");
	375	break;
	376	case P9_RMKDIR:
	377	fprintf(llogfile, "RMKDIR: (");
	378	pprint_qid(pdu, 0, &offset, "qid");
	379	break;
9f107513 AL	380	case P9_TVERSION:
	381	fprintf(llogfile, "TVERSION: (");
	382	pprint_int32(pdu, 0, &offset, "msize");
	383	pprint_str(pdu, 0, &offset, ", version");
	384	break;
	385	case P9_RVERSION:
	386	fprintf(llogfile, "RVERSION: (");
	387	pprint_int32(pdu, 1, &offset, "msize");
	388	pprint_str(pdu, 1, &offset, ", version");
	389	break;
00ede4c2 SK	390	case P9_TGETATTR:
	391	fprintf(llogfile, "TGETATTR: (");
	392	pprint_int32(pdu, 0, &offset, "fid");
	393	break;
	394	case P9_RGETATTR:
	395	fprintf(llogfile, "RGETATTR: (");
	396	pprint_stat_dotl(pdu, 1, &offset, "getattr");
	397	break;
9f107513 AL	398	case P9_TAUTH:
	399	fprintf(llogfile, "TAUTH: (");
	400	pprint_int32(pdu, 0, &offset, "afid");
	401	pprint_str(pdu, 0, &offset, ", uname");
	402	pprint_str(pdu, 0, &offset, ", aname");
cf03eb2c	403	pprint_int32(pdu, 0, &offset, ", n_uname");
9f107513 AL	404	break;
	405	case P9_RAUTH:
	406	fprintf(llogfile, "RAUTH: (");
	407	pprint_qid(pdu, 1, &offset, "qid");
	408	break;
	409	case P9_TATTACH:
	410	fprintf(llogfile, "TATTACH: (");
	411	pprint_int32(pdu, 0, &offset, "fid");
	412	pprint_int32(pdu, 0, &offset, ", afid");
	413	pprint_str(pdu, 0, &offset, ", uname");
	414	pprint_str(pdu, 0, &offset, ", aname");
cf03eb2c	415	pprint_int32(pdu, 0, &offset, ", n_uname");
9f107513 AL	416	break;
	417	case P9_RATTACH:
	418	fprintf(llogfile, "RATTACH: (");
	419	pprint_qid(pdu, 1, &offset, "qid");
	420	break;
	421	case P9_TERROR:
	422	fprintf(llogfile, "TERROR: (");
	423	break;
	424	case P9_RERROR:
	425	fprintf(llogfile, "RERROR: (");
	426	pprint_str(pdu, 1, &offset, "ename");
cf03eb2c	427	pprint_int32(pdu, 1, &offset, ", ecode");
9f107513 AL	428	break;
	429	case P9_TFLUSH:
	430	fprintf(llogfile, "TFLUSH: (");
	431	pprint_int16(pdu, 0, &offset, "oldtag");
	432	break;
	433	case P9_RFLUSH:
	434	fprintf(llogfile, "RFLUSH: (");
	435	break;
	436	case P9_TWALK:
	437	fprintf(llogfile, "TWALK: (");
	438	pprint_int32(pdu, 0, &offset, "fid");
	439	pprint_int32(pdu, 0, &offset, ", newfid");
	440	pprint_strs(pdu, 0, &offset, ", wnames");
	441	break;
	442	case P9_RWALK:
	443	fprintf(llogfile, "RWALK: (");
	444	pprint_qids(pdu, 1, &offset, "wqids");
	445	break;
	446	case P9_TOPEN:
	447	fprintf(llogfile, "TOPEN: (");
	448	pprint_int32(pdu, 0, &offset, "fid");
	449	pprint_int8(pdu, 0, &offset, ", mode");
	450	break;
	451	case P9_ROPEN:
	452	fprintf(llogfile, "ROPEN: (");
	453	pprint_qid(pdu, 1, &offset, "qid");
	454	pprint_int32(pdu, 1, &offset, ", iounit");
	455	break;
	456	case P9_TCREATE:
	457	fprintf(llogfile, "TCREATE: (");
	458	pprint_int32(pdu, 0, &offset, "fid");
	459	pprint_str(pdu, 0, &offset, ", name");
	460	pprint_int32(pdu, 0, &offset, ", perm");
	461	pprint_int8(pdu, 0, &offset, ", mode");
cf03eb2c	462	pprint_str(pdu, 0, &offset, ", extension");
9f107513 AL	463	break;
	464	case P9_RCREATE:
	465	fprintf(llogfile, "RCREATE: (");
	466	pprint_qid(pdu, 1, &offset, "qid");
	467	pprint_int32(pdu, 1, &offset, ", iounit");
	468	break;
08c60fc9 VJJ	469	case P9_TSYMLINK:
	470	fprintf(llogfile, "TSYMLINK: (");
	471	pprint_int32(pdu, 0, &offset, "fid");
	472	pprint_str(pdu, 0, &offset, ", name");
	473	pprint_str(pdu, 0, &offset, ", symname");
	474	pprint_int32(pdu, 0, &offset, ", gid");
	475	break;
	476	case P9_RSYMLINK:
	477	fprintf(llogfile, "RSYMLINK: (");
	478	pprint_qid(pdu, 1, &offset, "qid");
	479	break;
c1568af5 VJJ	480	case P9_TLCREATE:
	481	fprintf(llogfile, "TLCREATE: (");
	482	pprint_int32(pdu, 0, &offset, "dfid");
	483	pprint_str(pdu, 0, &offset, ", name");
	484	pprint_int32(pdu, 0, &offset, ", flags");
	485	pprint_int32(pdu, 0, &offset, ", mode");
	486	pprint_int32(pdu, 0, &offset, ", gid");
	487	break;
	488	case P9_RLCREATE:
	489	fprintf(llogfile, "RLCREATE: (");
	490	pprint_qid(pdu, 1, &offset, "qid");
	491	pprint_int32(pdu, 1, &offset, ", iounit");
	492	break;
5268cecc MK	493	case P9_TMKNOD:
	494	fprintf(llogfile, "TMKNOD: (");
	495	pprint_int32(pdu, 0, &offset, "fid");
	496	pprint_str(pdu, 0, &offset, "name");
	497	pprint_int32(pdu, 0, &offset, "mode");
	498	pprint_int32(pdu, 0, &offset, "major");
	499	pprint_int32(pdu, 0, &offset, "minor");
	500	pprint_int32(pdu, 0, &offset, "gid");
	501	break;
	502	case P9_RMKNOD:
	503	fprintf(llogfile, "RMKNOD: )");
	504	pprint_qid(pdu, 0, &offset, "qid");
	505	break;
df0973a4 MK	506	case P9_TREADLINK:
	507	fprintf(llogfile, "TREADLINK: (");
	508	pprint_int32(pdu, 0, &offset, "fid");
	509	break;
	510	case P9_RREADLINK:
	511	fprintf(llogfile, "RREADLINK: (");
	512	pprint_str(pdu, 0, &offset, "target");
	513	break;
9f107513 AL	514	case P9_TREAD:
	515	fprintf(llogfile, "TREAD: (");
	516	pprint_int32(pdu, 0, &offset, "fid");
	517	pprint_int64(pdu, 0, &offset, ", offset");
	518	pprint_int32(pdu, 0, &offset, ", count");
	519	pprint_sg(pdu, 0, &offset, ", sg");
	520	break;
	521	case P9_RREAD:
	522	fprintf(llogfile, "RREAD: (");
	523	pprint_int32(pdu, 1, &offset, "count");
	524	pprint_sg(pdu, 1, &offset, ", sg");
	525	offset = 7;
	526	#ifdef DEBUG_DATA
	527	pprint_data(pdu, 1, &offset, ", data");
	528	#endif
	529	break;
	530	case P9_TWRITE:
	531	fprintf(llogfile, "TWRITE: (");
	532	pprint_int32(pdu, 0, &offset, "fid");
	533	pprint_int64(pdu, 0, &offset, ", offset");
	534	pprint_int32(pdu, 0, &offset, ", count");
	535	break;
	536	case P9_RWRITE:
	537	fprintf(llogfile, "RWRITE: (");
	538	pprint_int32(pdu, 1, &offset, "count");
	539	break;
	540	case P9_TCLUNK:
	541	fprintf(llogfile, "TCLUNK: (");
	542	pprint_int32(pdu, 0, &offset, "fid");
	543	break;
	544	case P9_RCLUNK:
	545	fprintf(llogfile, "RCLUNK: (");
	546	break;
b41e95d3 VJJ	547	case P9_TFSYNC:
	548	fprintf(llogfile, "TFSYNC: (");
	549	pprint_int32(pdu, 0, &offset, "fid");
	550	break;
	551	case P9_RFSYNC:
	552	fprintf(llogfile, "RFSYNC: (");
	553	break;
b2c224be VJJ	554	case P9_TLINK:
b2c224be VJJ	555	fprintf(llogfile, "TLINK: (");
d04e2826 HPB	556	pprint_int32(pdu, 0, &offset, "dfid");
d04e2826 HPB	557	pprint_int32(pdu, 0, &offset, ", fid");
b2c224be VJJ	558	pprint_str(pdu, 0, &offset, ", newpath");
	559	break;
	560	case P9_RLINK:
	561	fprintf(llogfile, "RLINK: (");
	562	break;
9f107513 AL	563	case P9_TREMOVE:
	564	fprintf(llogfile, "TREMOVE: (");
	565	pprint_int32(pdu, 0, &offset, "fid");
	566	break;
	567	case P9_RREMOVE:
	568	fprintf(llogfile, "RREMOVE: (");
	569	break;
	570	case P9_TSTAT:
	571	fprintf(llogfile, "TSTAT: (");
	572	pprint_int32(pdu, 0, &offset, "fid");
	573	break;
	574	case P9_RSTAT:
	575	fprintf(llogfile, "RSTAT: (");
	576	offset += 2; /* ignored */
	577	pprint_stat(pdu, 1, &offset, "stat");
	578	break;
	579	case P9_TWSTAT:
	580	fprintf(llogfile, "TWSTAT: (");
	581	pprint_int32(pdu, 0, &offset, "fid");
	582	offset += 2; /* ignored */
	583	pprint_stat(pdu, 0, &offset, ", stat");
	584	break;
	585	case P9_RWSTAT:
	586	fprintf(llogfile, "RWSTAT: (");
	587	break;
fa32ef88 AK	588	case P9_TXATTRWALK:
	589	fprintf(llogfile, "TXATTRWALK: (");
	590	pprint_int32(pdu, 0, &offset, "fid");
	591	pprint_int32(pdu, 0, &offset, ", newfid");
	592	pprint_str(pdu, 0, &offset, ", xattr name");
	593	break;
	594	case P9_RXATTRWALK:
	595	fprintf(llogfile, "RXATTRWALK: (");
	596	pprint_int64(pdu, 1, &offset, "xattrsize");
10b468bd AK	597	case P9_TXATTRCREATE:
	598	fprintf(llogfile, "TXATTRCREATE: (");
	599	pprint_int32(pdu, 0, &offset, "fid");
	600	pprint_str(pdu, 0, &offset, ", name");
	601	pprint_int64(pdu, 0, &offset, ", xattrsize");
	602	pprint_int32(pdu, 0, &offset, ", flags");
	603	break;
	604	case P9_RXATTRCREATE:
	605	fprintf(llogfile, "RXATTRCREATE: (");
fa32ef88	606	break;
82cc3ee8 MK	607	case P9_TLOCK:
	608	fprintf(llogfile, "TLOCK: (");
	609	pprint_int32(pdu, 0, &offset, "fid");
	610	pprint_int8(pdu, 0, &offset, ", type");
	611	pprint_int32(pdu, 0, &offset, ", flags");
	612	pprint_int64(pdu, 0, &offset, ", start");
	613	pprint_int64(pdu, 0, &offset, ", length");
	614	pprint_int32(pdu, 0, &offset, ", proc_id");
	615	pprint_str(pdu, 0, &offset, ", client_id");
	616	break;
	617	case P9_RLOCK:
	618	fprintf(llogfile, "RLOCK: (");
	619	pprint_int8(pdu, 0, &offset, "status");
	620	break;
8f354003 MK	621	case P9_TGETLOCK:
	622	fprintf(llogfile, "TGETLOCK: (");
	623	pprint_int32(pdu, 0, &offset, "fid");
	624	pprint_int8(pdu, 0, &offset, ", type");
	625	pprint_int64(pdu, 0, &offset, ", start");
	626	pprint_int64(pdu, 0, &offset, ", length");
	627	pprint_int32(pdu, 0, &offset, ", proc_id");
	628	pprint_str(pdu, 0, &offset, ", client_id");
	629	break;
	630	case P9_RGETLOCK:
	631	fprintf(llogfile, "RGETLOCK: (");
	632	pprint_int8(pdu, 0, &offset, "type");
	633	pprint_int64(pdu, 0, &offset, ", start");
	634	pprint_int64(pdu, 0, &offset, ", length");
	635	pprint_int32(pdu, 0, &offset, ", proc_id");
	636	pprint_str(pdu, 0, &offset, ", client_id");
	637	break;
9f107513 AL	638	default:
	639	fprintf(llogfile, "unknown(%d): (", pdu->id);
	640	break;
	641	}
	642
	643	fprintf(llogfile, ")\n");
0db09dd2 VJJ	644	/* Flush the log message out */
0db09dd2 VJJ	645	fflush(llogfile);
9f107513	646	}