Return to virtio-9p-debug.c CVS log

Up to [Qemu by Fabrice Bellard] / qemu / hw / 9pfs

Annotation of qemu/hw/9pfs/virtio-9p-debug.c, revision 1.1

1.1     ! root        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: 
        !            14: #include "hw/virtio.h"
        !            15: #include "hw/pc.h"
        !            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");
        !           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:     fprintf(llogfile, "}");
        !           178: }
        !           179: 
        !           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: 
        !           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;
        !           298:     } else
        !           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: 
        !           353:     BUG_ON(!llogfile);
        !           354: 
        !           355:     switch (pdu->id) {
        !           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;
        !           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;
        !           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;
        !           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;
        !           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");
        !           403:         pprint_int32(pdu, 0, &offset, ", n_uname");
        !           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");
        !           415:         pprint_int32(pdu, 0, &offset, ", n_uname");
        !           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");
        !           427:         pprint_int32(pdu, 1, &offset, ", ecode");
        !           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");
        !           462:         pprint_str(pdu, 0, &offset, ", extension");
        !           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;
        !           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;
        !           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;
        !           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;
        !           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;
        !           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;
        !           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;
        !           554:     case P9_TLINK:
        !           555:         fprintf(llogfile, "TLINK: (");
        !           556:         pprint_int32(pdu, 0, &offset, "dfid");
        !           557:         pprint_int32(pdu, 0, &offset, ", fid");
        !           558:         pprint_str(pdu, 0, &offset, ", newpath");
        !           559:         break;
        !           560:     case P9_RLINK:
        !           561:         fprintf(llogfile, "RLINK: (");
        !           562:         break;
        !           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;
        !           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");
        !           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: (");
        !           606:         break;
        !           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;
        !           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;
        !           638:     default:
        !           639:         fprintf(llogfile, "unknown(%d): (", pdu->id);
        !           640:         break;
        !           641:     }
        !           642: 
        !           643:     fprintf(llogfile, ")\n");
        !           644:     /* Flush the log message out */
        !           645:     fflush(llogfile);
        !           646: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.