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

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