[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");
    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");
}
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");
172	if (dotu) {
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");
177	}
178	fprintf(llogfile, "}");
179	}
180
181	static void pprint_strs(V9fsPDU pdu, int rx, size_t offsetp, const char *name)
182	{
183	int sg_count = get_sg_count(pdu, rx);
184	struct iovec *sg = get_sg(pdu, rx);
185	size_t offset = *offsetp;
186	uint16_t tmp_count, count, i;
187	size_t copied = 0;
188
189	fprintf(llogfile, "%s={", name);
190
191	/* Get the count */
192	copied = do_pdu_unpack(&tmp_count, sg, sg_count, offset, sizeof(tmp_count));
193	BUG_ON(copied != sizeof(tmp_count));
194	count = le16_to_cpupu(&tmp_count);
195	offset += copied;
196
197	for (i = 0; i < count; i++) {
198	char str[512];
199	if (i) {
200	fprintf(llogfile, ", ");
201	}
202	snprintf(str, sizeof(str), "[%d]", i);
203	pprint_str(pdu, rx, &offset, str);
204	}
205
206	fprintf(llogfile, "}");
207
208	*offsetp = offset;
209	}
210
211	static void pprint_qids(V9fsPDU pdu, int rx, size_t offsetp, const char *name)
212	{
213	int sg_count = get_sg_count(pdu, rx);
214	struct iovec *sg = get_sg(pdu, rx);
215	size_t offset = *offsetp;
216	uint16_t tmp_count, count, i;
217	size_t copied = 0;
218
219	fprintf(llogfile, "%s={", name);
220
221	copied = do_pdu_unpack(&tmp_count, sg, sg_count, offset, sizeof(tmp_count));
222	BUG_ON(copied != sizeof(tmp_count));
223	count = le16_to_cpupu(&tmp_count);
224	offset += copied;
225
226	for (i = 0; i < count; i++) {
227	char str[512];
228	if (i) {
229	fprintf(llogfile, ", ");
230	}
231	snprintf(str, sizeof(str), "[%d]", i);
232	pprint_qid(pdu, rx, &offset, str);
233	}
234
235	fprintf(llogfile, "}");
236
237	*offsetp = offset;
238	}
239
240	static void pprint_sg(V9fsPDU pdu, int rx, size_t offsetp, const char *name)
241	{
242	struct iovec *sg = get_sg(pdu, rx);
243	unsigned int count;
244	int i;
245
246	if (rx) {
247	count = pdu->elem.in_num;
248	} else {
249	count = pdu->elem.out_num;
250	}
251
252	fprintf(llogfile, "%s={", name);
253	for (i = 0; i < count; i++) {
254	if (i) {
255	fprintf(llogfile, ", ");
256	}
257	fprintf(llogfile, "(%p, 0x%zx)", sg[i].iov_base, sg[i].iov_len);
258	}
259	fprintf(llogfile, "}");
260	}
261
262	/* FIXME: read from a directory fid returns serialized stat_t's */
263	#ifdef DEBUG_DATA
264	static void pprint_data(V9fsPDU pdu, int rx, size_t offsetp, const char *name)
265	{
266	struct iovec *sg = get_sg(pdu, rx);
267	size_t offset = *offsetp;
268	unsigned int count;
269	int32_t size;
270	int total, i, j;
271	ssize_t len;
272
273	if (rx) {
274	count = pdu->elem.in_num;
275	} else
276	count = pdu->elem.out_num;
277	}
278
279	BUG_ON((offset + sizeof(size)) > sg[0].iov_len);
280
281	memcpy(&size, sg[0].iov_base + offset, sizeof(size));
282	offset += sizeof(size);
283
284	fprintf(llogfile, "size: %x\n", size);
285
286	sg[0].iov_base += 11; /* skip header */
287	sg[0].iov_len -= 11;
288
289	total = 0;
290	for (i = 0; i < count; i++) {
291	total += sg[i].iov_len;
292	if (total >= size) {
293	/* trim sg list so writev does the right thing */
294	sg[i].iov_len -= (total - size);
295	i++;
296	break;
297	}
298	}
299
300	fprintf(llogfile, "%s={\"", name);
301	fflush(llogfile);
302	for (j = 0; j < i; j++) {
303	if (j) {
304	fprintf(llogfile, "\", \"");
305	fflush(llogfile);
306	}
307
308	do {
309	len = writev(fileno(llogfile), &sg[j], 1);
310	} while (len == -1 && errno == EINTR);
311	fprintf(llogfile, "len == %ld: %m\n", len);
312	BUG_ON(len != sg[j].iov_len);
313	}
314	fprintf(llogfile, "\"}");
315
316	sg[0].iov_base -= 11;
317	sg[0].iov_len += 11;
318
319	}
320	#endif
321
322	void pprint_pdu(V9fsPDU *pdu)
323	{
324	size_t offset = 7;
325
326	if (llogfile == NULL) {
327	llogfile = fopen("/tmp/pdu.log", "w");
328	}
329
330	switch (pdu->id) {
331	case P9_TVERSION:
332	fprintf(llogfile, "TVERSION: (");
333	pprint_int32(pdu, 0, &offset, "msize");
334	pprint_str(pdu, 0, &offset, ", version");
335	break;
336	case P9_RVERSION:
337	fprintf(llogfile, "RVERSION: (");
338	pprint_int32(pdu, 1, &offset, "msize");
339	pprint_str(pdu, 1, &offset, ", version");
340	break;
341	case P9_TAUTH:
342	fprintf(llogfile, "TAUTH: (");
343	pprint_int32(pdu, 0, &offset, "afid");
344	pprint_str(pdu, 0, &offset, ", uname");
345	pprint_str(pdu, 0, &offset, ", aname");
346	if (dotu) {
347	pprint_int32(pdu, 0, &offset, ", n_uname");
348	}
349	break;
350	case P9_RAUTH:
351	fprintf(llogfile, "RAUTH: (");
352	pprint_qid(pdu, 1, &offset, "qid");
353	break;
354	case P9_TATTACH:
355	fprintf(llogfile, "TATTACH: (");
356	pprint_int32(pdu, 0, &offset, "fid");
357	pprint_int32(pdu, 0, &offset, ", afid");
358	pprint_str(pdu, 0, &offset, ", uname");
359	pprint_str(pdu, 0, &offset, ", aname");
360	if (dotu) {
361	pprint_int32(pdu, 0, &offset, ", n_uname");
362	}
363	break;
364	case P9_RATTACH:
365	fprintf(llogfile, "RATTACH: (");
366	pprint_qid(pdu, 1, &offset, "qid");
367	break;
368	case P9_TERROR:
369	fprintf(llogfile, "TERROR: (");
370	break;
371	case P9_RERROR:
372	fprintf(llogfile, "RERROR: (");
373	pprint_str(pdu, 1, &offset, "ename");
374	if (dotu) {
375	pprint_int32(pdu, 1, &offset, ", ecode");
376	}
377	break;
378	case P9_TFLUSH:
379	fprintf(llogfile, "TFLUSH: (");
380	pprint_int16(pdu, 0, &offset, "oldtag");
381	break;
382	case P9_RFLUSH:
383	fprintf(llogfile, "RFLUSH: (");
384	break;
385	case P9_TWALK:
386	fprintf(llogfile, "TWALK: (");
387	pprint_int32(pdu, 0, &offset, "fid");
388	pprint_int32(pdu, 0, &offset, ", newfid");
389	pprint_strs(pdu, 0, &offset, ", wnames");
390	break;
391	case P9_RWALK:
392	fprintf(llogfile, "RWALK: (");
393	pprint_qids(pdu, 1, &offset, "wqids");
394	break;
395	case P9_TOPEN:
396	fprintf(llogfile, "TOPEN: (");
397	pprint_int32(pdu, 0, &offset, "fid");
398	pprint_int8(pdu, 0, &offset, ", mode");
399	break;
400	case P9_ROPEN:
401	fprintf(llogfile, "ROPEN: (");
402	pprint_qid(pdu, 1, &offset, "qid");
403	pprint_int32(pdu, 1, &offset, ", iounit");
404	break;
405	case P9_TCREATE:
406	fprintf(llogfile, "TCREATE: (");
407	pprint_int32(pdu, 0, &offset, "fid");
408	pprint_str(pdu, 0, &offset, ", name");
409	pprint_int32(pdu, 0, &offset, ", perm");
410	pprint_int8(pdu, 0, &offset, ", mode");
411	if (dotu) {
412	pprint_str(pdu, 0, &offset, ", extension");
413	}
414	break;
415	case P9_RCREATE:
416	fprintf(llogfile, "RCREATE: (");
417	pprint_qid(pdu, 1, &offset, "qid");
418	pprint_int32(pdu, 1, &offset, ", iounit");
419	break;
420	case P9_TREAD:
421	fprintf(llogfile, "TREAD: (");
422	pprint_int32(pdu, 0, &offset, "fid");
423	pprint_int64(pdu, 0, &offset, ", offset");
424	pprint_int32(pdu, 0, &offset, ", count");
425	pprint_sg(pdu, 0, &offset, ", sg");
426	break;
427	case P9_RREAD:
428	fprintf(llogfile, "RREAD: (");
429	pprint_int32(pdu, 1, &offset, "count");
430	pprint_sg(pdu, 1, &offset, ", sg");
431	offset = 7;
432	#ifdef DEBUG_DATA
433	pprint_data(pdu, 1, &offset, ", data");
434	#endif
435	break;
436	case P9_TWRITE:
437	fprintf(llogfile, "TWRITE: (");
438	pprint_int32(pdu, 0, &offset, "fid");
439	pprint_int64(pdu, 0, &offset, ", offset");
440	pprint_int32(pdu, 0, &offset, ", count");
441	break;
442	case P9_RWRITE:
443	fprintf(llogfile, "RWRITE: (");
444	pprint_int32(pdu, 1, &offset, "count");
445	break;
446	case P9_TCLUNK:
447	fprintf(llogfile, "TCLUNK: (");
448	pprint_int32(pdu, 0, &offset, "fid");
449	break;
450	case P9_RCLUNK:
451	fprintf(llogfile, "RCLUNK: (");
452	break;
453	case P9_TREMOVE:
454	fprintf(llogfile, "TREMOVE: (");
455	pprint_int32(pdu, 0, &offset, "fid");
456	break;
457	case P9_RREMOVE:
458	fprintf(llogfile, "RREMOVE: (");
459	break;
460	case P9_TSTAT:
461	fprintf(llogfile, "TSTAT: (");
462	pprint_int32(pdu, 0, &offset, "fid");
463	break;
464	case P9_RSTAT:
465	fprintf(llogfile, "RSTAT: (");
466	offset += 2; /* ignored */
467	pprint_stat(pdu, 1, &offset, "stat");
468	break;
469	case P9_TWSTAT:
470	fprintf(llogfile, "TWSTAT: (");
471	pprint_int32(pdu, 0, &offset, "fid");
472	offset += 2; /* ignored */
473	pprint_stat(pdu, 0, &offset, ", stat");
474	break;
475	case P9_RWSTAT:
476	fprintf(llogfile, "RWSTAT: (");
477	break;
478	default:
479	fprintf(llogfile, "unknown(%d): (", pdu->id);
480	break;
481	}
482
483	fprintf(llogfile, ")\n");
484	}