xref: /illumos-kvm-cmd/hw/virtio-9p-debug.c (revision 68396ea9)
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  */
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 
get_sg(V9fsPDU * pdu,int rx)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 
get_sg_count(V9fsPDU * pdu,int rx)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 
pprint_int8(V9fsPDU * pdu,int rx,size_t * offsetp,const char * name)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 
pprint_int16(V9fsPDU * pdu,int rx,size_t * offsetp,const char * name)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 
pprint_int32(V9fsPDU * pdu,int rx,size_t * offsetp,const char * name)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 
pprint_int64(V9fsPDU * pdu,int rx,size_t * offsetp,const char * name)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 
pprint_str(V9fsPDU * pdu,int rx,size_t * offsetp,const char * name)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 
pprint_qid(V9fsPDU * pdu,int rx,size_t * offsetp,const char * name)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 
pprint_stat(V9fsPDU * pdu,int rx,size_t * offsetp,const char * name)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     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");
176     fprintf(llogfile, "}");
177 }
178 
pprint_stat_dotl(V9fsPDU * pdu,int rx,size_t * offsetp,const char * name)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 
pprint_strs(V9fsPDU * pdu,int rx,size_t * offsetp,const char * name)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 
pprint_qids(V9fsPDU * pdu,int rx,size_t * offsetp,const char * name)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 
pprint_sg(V9fsPDU * pdu,int rx,size_t * offsetp,const char * name)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
pprint_data(V9fsPDU * pdu,int rx,size_t * offsetp,const char * name)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 
352     BUG_ON(!llogfile);
353 
354     switch (pdu->id) {
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;
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;
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;
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;
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");
402         pprint_int32(pdu, 0, &offset, ", n_uname");
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");
414         pprint_int32(pdu, 0, &offset, ", n_uname");
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");
426         pprint_int32(pdu, 1, &offset, ", ecode");
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");
461         pprint_str(pdu, 0, &offset, ", extension");
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;
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;
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;
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;
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;
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;
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;
553     case P9_TLINK:
554         fprintf(llogfile, "TLINK: (");
555         pprint_int32(pdu, 0, &offset, "dfid");
556         pprint_int32(pdu, 0, &offset, ", fid");
557         pprint_str(pdu, 0, &offset, ", newpath");
558         break;
559     case P9_RLINK:
560         fprintf(llogfile, "RLINK: (");
561         break;
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;
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");
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: (");
605         break;
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;
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;
637     default:
638         fprintf(llogfile, "unknown(%d): (", pdu->id);
639         break;
640     }
641 
642     fprintf(llogfile, ")\n");
643     /* Flush the log message out */
644     fflush(llogfile);
645 }
646