int np_printfcall(FILE *f, Npfcall *fc, int dotu) { int i, ret, type, fid, tag; if (!fc) return fprintf(f, "NULL"); type = fc->type; fid = fc->fid; tag = fc->tag; ret = 0; switch (type) { case Tversion: ret += fprintf(f, "Tversion tag %u msize %u version '%.*s'", tag, fc->msize, fc->version.len, fc->version.str); break; case Rversion: ret += fprintf(f, "Rversion tag %u msize %u version '%.*s'", tag, fc->msize, fc->version.len, fc->version.str); break; case Tauth: ret += fprintf(f, "Tauth tag %u afid %d uname %.*s aname %.*s", tag, fc->afid, fc->uname.len, fc->uname.str, fc->aname.len, fc->aname.str); break; case Rauth: ret += fprintf(f, "Rauth tag %u qid ", tag); np_printqid(f, &fc->qid); break; case Tattach: ret += fprintf(f, "Tattach tag %u fid %d afid %d uname %.*s aname %.*s", tag, fid, fc->afid, fc->uname.len, fc->uname.str, fc->aname.len, fc->aname.str); break; case Rattach: ret += fprintf(f, "Rattach tag %u qid ", tag); np_printqid(f, &fc->qid); break; case Rerror: ret += fprintf(f, "Rerror tag %u ename %.*s", tag, fc->ename.len, fc->ename.str); if (dotu) ret += fprintf(f, " ecode %d", fc->ecode); break; case Tflush: ret += fprintf(f, "Tflush tag %u oldtag %u", tag, fc->oldtag); break; case Rflush: ret += fprintf(f, "Rflush tag %u", tag); break; case Twalk: ret += fprintf(f, "Twalk tag %u fid %d newfid %d nwname %d", tag, fid, fc->newfid, fc->nwname); for(i = 0; i < fc->nwname; i++) ret += fprintf(f, " '%.*s'", fc->wnames[i].len, fc->wnames[i].str); break; case Rwalk: ret += fprintf(f, "Rwalk tag %u nwqid %d", tag, fc->nwqid); for(i = 0; i < fc->nwqid; i++) ret += np_printqid(f, &fc->wqids[i]); break; case Topen: ret += fprintf(f, "Topen tag %u fid %d mode %d", tag, fid, fc->mode); break; case Ropen: ret += fprintf(f, "Ropen tag %u", tag); ret += np_printqid(f, &fc->qid); ret += fprintf(f, " iounit %d", fc->iounit); break; case Tcreate: ret += fprintf(f, "Tcreate tag %u fid %d name %.*s perm ", tag, fid, fc->name.len, fc->name.str); ret += np_printperm(f, fc->perm); ret += fprintf(f, " mode %d", fc->mode); if (dotu) ret += fprintf(f, " ext %.*s", fc->extension.len, fc->extension.str); break; case Rcreate: ret += fprintf(f, "Rcreate tag %u", tag); ret += np_printqid(f, &fc->qid); ret += fprintf(f, " iounit %d", fc->iounit); break; case Tread: ret += fprintf(f, "Tread tag %u fid %d offset %lld count %u", tag, fid, fc->offset, fc->count); break; case Rread: ret += fprintf(f, "Rread tag %u count %u data ", tag, fc->count); ret += np_printdata(f, fc->data, fc->count); break; case Twrite: ret += fprintf(f, "Twrite tag %u fid %d offset %lld count %u data ", tag, fid, fc->offset, fc->count); ret += np_printdata(f, fc->data, fc->count); break; case Rwrite: ret += fprintf(f, "Rwrite tag %u count %u", tag, fc->count); break; case Tclunk: ret += fprintf(f, "Tclunk tag %u fid %d", tag, fid); break; case Rclunk: ret += fprintf(f, "Rclunk tag %u", tag); break; case Tremove: ret += fprintf(f, "Tremove tag %u fid %d", tag, fid); break; case Rremove: ret += fprintf(f, "Rremove tag %u", tag); break; case Tstat: ret += fprintf(f, "Tstat tag %u fid %d", tag, fid); break; case Rstat: ret += fprintf(f, "Rstat tag %u ", tag); ret += np_printstat(f, &fc->stat, dotu); break; case Twstat: ret += fprintf(f, "Twstat tag %u fid %d ", tag, fid); ret += np_printstat(f, &fc->stat, dotu); break; case Rwstat: ret += fprintf(f, "Rwstat tag %u", tag); break; default: ret += fprintf(f, "unknown type %d", type); break; } return ret; }
void np_snprintfcall(char *s, int len, Npfcall *fc) { int i; s[0] = '\0'; if (!fc) { spf (s, len, "NULL"); return; } switch (fc->type) { case P9_TLERROR: spf (s, len, "P9_TLERROR tag %u", fc->tag); break; case P9_RLERROR: spf (s, len, "P9_RLERROR tag %u", fc->tag); spf (s, len, " ecode %"PRIu32, fc->u.rlerror.ecode); break; case P9_TSTATFS: spf (s, len, "P9_TSTATFS tag %u", fc->tag); spf (s, len, " fid %"PRIu32, fc->u.tstatfs.fid); break; case P9_RSTATFS: spf (s, len, "P9_RSTATFS tag %u", fc->tag); spf (s, len, " type %"PRIu32, fc->u.rstatfs.type); spf (s, len, " bsize %"PRIu32, fc->u.rstatfs.bsize); spf (s, len, " blocks %"PRIu64, fc->u.rstatfs.blocks); spf (s, len, " bfree %"PRIu64, fc->u.rstatfs.bfree); spf (s, len, " bavail %"PRIu64, fc->u.rstatfs.bavail); spf (s, len, " files %"PRIu64, fc->u.rstatfs.files); spf (s, len, " ffree %"PRIu64, fc->u.rstatfs.ffree); spf (s, len, " fsid %"PRIu64, fc->u.rstatfs.fsid); spf (s, len, " namelen %"PRIu32, fc->u.rstatfs.namelen); break; case P9_TLOPEN: spf (s, len, "P9_TLOPEN tag %u", fc->tag); spf (s, len, " fid %"PRIu32, fc->u.tlopen.fid); spf (s, len, " flags 0%"PRIo32, fc->u.tlopen.flags); break; case P9_RLOPEN: spf (s, len, "P9_RLOPEN tag %u qid ", fc->tag); np_printqid(s, len, &fc->u.rlopen.qid); spf (s, len, " iounit %"PRIu32, fc->u.rlopen.iounit); break; case P9_TLCREATE: spf (s, len, "P9_TLCREATE tag %u", fc->tag); spf (s, len, " fid %"PRIu32, fc->u.tlcreate.fid); spf (s, len, " name '%.*s'", fc->u.tlcreate.name.len, fc->u.tlcreate.name.str); spf (s, len, " flags 0x%"PRIx32, fc->u.tlcreate.flags); spf (s, len, " mode 0%"PRIo32, fc->u.tlcreate.mode); spf (s, len, " gid %"PRIu32, fc->u.tlcreate.gid); break; case P9_RLCREATE: spf (s, len, "P9_RLCREATE tag %u qid ", fc->tag); np_printqid(s, len, &fc->u.rlcreate.qid); spf (s, len, " iounit %"PRIu32, fc->u.rlcreate.iounit); break; case P9_TSYMLINK: spf (s, len, "P9_TSYMLINK tag %u", fc->tag); spf (s, len, " fid %"PRIu32, fc->u.tsymlink.fid); spf (s, len, " name '%.*s'", fc->u.tsymlink.name.len, fc->u.tsymlink.name.str); spf (s, len, " symtgt '%.*s'", fc->u.tsymlink.symtgt.len, fc->u.tsymlink.symtgt.str); spf (s, len, " gid %"PRIu32, fc->u.tsymlink.gid); break; case P9_RSYMLINK: spf (s, len, "P9_RSYMLINK tag %d qid ", fc->tag); np_printqid(s, len, &fc->u.rsymlink.qid); break; case P9_TMKNOD: spf (s, len, "P9_TMKNOD tag %u", fc->tag); spf (s, len, " fid %"PRIu32, fc->u.tmknod.fid); spf (s, len, " name '%.*s'", fc->u.tmknod.name.len, fc->u.tmknod.name.str); spf (s, len, " mode 0%"PRIo32, fc->u.tmknod.mode); spf (s, len, " major %"PRIu32, fc->u.tmknod.major); spf (s, len, " minor %"PRIu32, fc->u.tmknod.minor); spf (s, len, " gid %"PRIu32, fc->u.tmknod.gid); break; case P9_RMKNOD: spf (s, len, "P9_RMKNOD tag %d qid ", fc->tag); np_printqid(s, len, &fc->u.rsymlink.qid); break; case P9_TRENAME: spf (s, len, "P9_TRENAME tag %u", fc->tag); spf (s, len, " fid %"PRIu32, fc->u.trename.fid); spf (s, len, " dfid %"PRIu32, fc->u.trename.dfid); spf (s, len, " name '%.*s'", fc->u.trename.name.len, fc->u.trename.name.str); break; case P9_RRENAME: spf (s, len, "P9_RRENAME tag %u", fc->tag); break; case P9_TREADLINK: spf (s, len, "P9_TREADLINK tag %u", fc->tag); spf (s, len, " fid %"PRIu32, fc->u.treadlink.fid); break; case P9_RREADLINK: spf (s, len, "P9_RREADLINK tag %u", fc->tag); spf (s, len, " target '%.*s'", fc->u.rreadlink.target.len, fc->u.rreadlink.target.str); break; case P9_TGETATTR: spf (s, len, "P9_TGETATTR tag %u", fc->tag); spf (s, len, " fid %"PRIu32, fc->u.tgetattr.fid); spf (s, len, " request_mask 0x%"PRIx64, fc->u.tgetattr.request_mask); break; case P9_RGETATTR: spf (s, len, "P9_RGETATTR tag %u", fc->tag); spf (s, len, " valid 0x%"PRIx64, fc->u.rgetattr.valid); spf (s, len, " qid "); if ((fc->u.rgetattr.valid & P9_STAT_INO)) np_printqid(s, len, &fc->u.rgetattr.qid); else spf (s, len, "X"); if ((fc->u.rgetattr.valid & P9_STAT_MODE)) spf (s, len, " mode 0%"PRIo32, fc->u.rgetattr.mode); else spf (s, len, " mode X"); if ((fc->u.rgetattr.valid & P9_STAT_UID)) spf (s, len, " uid %"PRIu32, fc->u.rgetattr.uid); else spf (s, len, " uid X"); if ((fc->u.rgetattr.valid & P9_STAT_GID)) spf (s, len, " gid %"PRIu32, fc->u.rgetattr.gid); else spf (s, len, " gid X"); if ((fc->u.rgetattr.valid & P9_STAT_NLINK)) spf (s, len, " nlink %"PRIu64, fc->u.rgetattr.nlink); else spf (s, len, " nlink X"); if ((fc->u.rgetattr.valid & P9_STAT_RDEV)) spf (s, len, " rdev %"PRIu64, fc->u.rgetattr.rdev); else spf (s, len, " rdev X"); if ((fc->u.rgetattr.valid & P9_STAT_SIZE)) spf (s, len, " size %"PRIu64, fc->u.rgetattr.size); else spf (s, len, " size X"); spf (s, len, " blksize %"PRIu64, fc->u.rgetattr.blksize); if ((fc->u.rgetattr.valid & P9_STAT_BLOCKS)) spf (s, len, " blocks %"PRIu64, fc->u.rgetattr.blocks); else spf (s, len, " blocks X"); if ((fc->u.rgetattr.valid & P9_STAT_ATIME)) spf (s, len, " atime %s", np_timestr(fc->u.rgetattr.atime_sec, fc->u.rgetattr.atime_nsec)); else spf (s, len, " atime X"); if ((fc->u.rgetattr.valid & P9_STAT_MTIME)) spf (s, len, " mtime %s", np_timestr(fc->u.rgetattr.mtime_sec, fc->u.rgetattr.mtime_nsec)); else spf (s, len, " mtime X"); if ((fc->u.rgetattr.valid & P9_STAT_CTIME)) spf (s, len, " ctime %s", np_timestr(fc->u.rgetattr.ctime_sec, fc->u.rgetattr.ctime_nsec)); else spf (s, len, " ctime X"); if ((fc->u.rgetattr.valid & P9_STAT_BTIME)) spf (s, len, " btime %s", np_timestr(fc->u.rgetattr.btime_sec, fc->u.rgetattr.btime_nsec)); else spf (s, len, " btime X"); if ((fc->u.rgetattr.valid & P9_STAT_GEN)) spf (s, len, " gen %"PRIu64, fc->u.rgetattr.gen); else spf (s, len, " gen X"); if ((fc->u.rgetattr.valid & P9_STAT_DATA_VERSION)) spf (s, len, " data_version %"PRIu64, fc->u.rgetattr.data_version); else spf (s, len, " data_version X"); break; case P9_TSETATTR: spf (s, len, "P9_TSETATTR tag %u", fc->tag); spf (s, len, " fid %"PRIu32, fc->u.tsetattr.fid); spf (s, len, " valid 0x%"PRIx32, fc->u.tsetattr.valid); if ((fc->u.tsetattr.valid & P9_ATTR_MODE)) spf (s, len, " mode 0%"PRIo32, fc->u.tsetattr.mode); else spf (s, len, " mode X"); if ((fc->u.tsetattr.valid & P9_ATTR_UID)) spf (s, len, " uid %"PRIu32, fc->u.tsetattr.uid); else spf (s, len, " uid X"); if ((fc->u.tsetattr.valid & P9_ATTR_GID)) spf (s, len, " gid %"PRIu32, fc->u.tsetattr.gid); else spf (s, len, " gid X"); if ((fc->u.tsetattr.valid & P9_ATTR_SIZE)) spf (s, len, " size %"PRIu64, fc->u.tsetattr.size); else spf (s, len, " size X"); if (!(fc->u.tsetattr.valid & P9_ATTR_ATIME)) spf (s, len, " atime X"); else if (!(fc->u.tsetattr.valid & P9_ATTR_ATIME_SET)) spf (s, len, " atime X"); else spf (s, len, " atime %s", np_timestr(fc->u.tsetattr.atime_sec, fc->u.tsetattr.atime_nsec)); if (!(fc->u.tsetattr.valid & P9_ATTR_MTIME)) spf (s, len, " mtime X"); else if (!(fc->u.tsetattr.valid & P9_ATTR_MTIME_SET)) spf (s, len, " mtime now"); else spf (s, len, " mtime %s", np_timestr(fc->u.tsetattr.mtime_sec, fc->u.tsetattr.mtime_nsec)); break; case P9_RSETATTR: spf (s, len, "P9_RSETATTR tag %u", fc->tag); break; case P9_TXATTRWALK: spf (s, len, "P9_TXATTRWALK tag %u", fc->tag); spf (s, len, " fid %"PRIu32, fc->u.txattrwalk.fid); spf (s, len, " attrfid %"PRIu32, fc->u.txattrwalk.attrfid); spf (s, len, " name '%.*s'", fc->u.txattrwalk.name.len, fc->u.txattrwalk.name.str); break; case P9_RXATTRWALK: spf (s, len, "P9_RXATTRWALK tag %u", fc->tag); spf (s, len, " size %"PRIu64, fc->u.rxattrwalk.size); break; case P9_TXATTRCREATE: spf (s, len, "P9_TXATTRCREATE tag %u", fc->tag); spf (s, len, " fid %"PRIu32, fc->u.txattrcreate.fid); spf (s, len, " name '%.*s'", fc->u.txattrcreate.name.len, fc->u.txattrcreate.name.str); spf (s, len, " size %"PRIu64, fc->u.txattrcreate.size); spf (s, len, " flag %"PRIu32, fc->u.txattrcreate.flag); break; case P9_RXATTRCREATE: spf (s, len, "P9_RXATTRCREATE tag %u", fc->tag); break; case P9_TREADDIR: spf (s, len, "P9_TREADDIR tag %u", fc->tag); spf (s, len, " fid %"PRIu32, fc->u.treaddir.fid); spf (s, len, " offset %"PRIu64, fc->u.treaddir.offset); spf (s, len, " count %"PRIu32, fc->u.treaddir.count); break; case P9_RREADDIR: spf (s, len, "P9_RREADDIR tag %u", fc->tag); spf (s, len, " count %"PRIu32, fc->u.rreaddir.count); np_printdents(s, len, fc->u.rreaddir.data, fc->u.rreaddir.count); break; case P9_TFSYNC: spf (s, len, "P9_TFSYNC tag %u", fc->tag); spf (s, len, " fid %"PRIu32, fc->u.tfsync.fid); break; case P9_RFSYNC: spf (s, len, "P9_RFSYNC tag %u", fc->tag); break; case P9_TLOCK: spf (s, len, "P9_TLOCK tag %u", fc->tag); spf (s, len, " fid %"PRIu32, fc->u.tlock.fid); spf (s, len, " type "); np_printlocktype(s, len, fc->u.tlock.type); spf (s, len, " flags %"PRIu32, fc->u.tlock.flags); spf (s, len, " start %"PRIu64, fc->u.tlock.start); spf (s, len, " length %"PRIu64, fc->u.tlock.length); spf (s, len, " proc_id %"PRIu32, fc->u.tlock.proc_id); spf (s, len, " client_id '%.*s'", fc->u.tlock.client_id.len, fc->u.tlock.client_id.str); break; case P9_RLOCK: spf (s, len, "P9_RLOCK tag %u", fc->tag); spf (s, len, " status "); np_printlockstatus(s, len, fc->u.rlock.status); break; case P9_TGETLOCK: spf (s, len, "P9_TGETLOCK tag %u", fc->tag); spf (s, len, " fid %"PRIu32, fc->u.tgetlock.fid); spf (s, len, " type "); np_printlocktype(s, len, fc->u.tgetlock.type); spf (s, len, " start %"PRIu64, fc->u.tgetlock.start); spf (s, len, " length %"PRIu64, fc->u.tgetlock.length); spf (s, len, " proc_id %"PRIu32, fc->u.tgetlock.proc_id); spf (s, len, " client_id '%.*s'", fc->u.tgetlock.client_id.len, fc->u.tgetlock.client_id.str); break; case P9_RGETLOCK: spf (s, len, "P9_RGETLOCK tag %u", fc->tag); spf (s, len, " type "); np_printlocktype(s, len, fc->u.rgetlock.type); spf (s, len, " start %"PRIu64, fc->u.rgetlock.start); spf (s, len, " length %"PRIu64, fc->u.rgetlock.length); spf (s, len, " proc_id %"PRIu32, fc->u.rgetlock.proc_id); spf (s, len, " client_id '%.*s'", fc->u.rgetlock.client_id.len, fc->u.rgetlock.client_id.str); break; case P9_TLINK: spf (s, len, "P9_TLINK tag %u", fc->tag); spf (s, len, " dfid %"PRIu32, fc->u.tlink.dfid); spf (s, len, " fid %"PRIu32, fc->u.tlink.fid); spf (s, len, " name '%.*s'", fc->u.tlink.name.len, fc->u.tlink.name.str); break; case P9_RLINK: spf (s, len, "P9_RLINK tag %u", fc->tag); break; case P9_TMKDIR: spf (s, len, "P9_TMKDIR tag %u", fc->tag); spf (s, len, " fid %"PRIu32, fc->u.tmkdir.fid); spf (s, len, " name '%.*s'", fc->u.tmkdir.name.len, fc->u.tmkdir.name.str); spf (s, len, " mode 0%"PRIo32, fc->u.tmkdir.mode); spf (s, len, " gid %"PRIu32, fc->u.tmkdir.gid); break; case P9_RMKDIR: spf (s, len, "P9_RMKDIR tag %u qid ", fc->tag); np_printqid(s, len, &fc->u.rmkdir.qid); break; case P9_TRENAMEAT: spf (s, len, "P9_TRENAMEAT tag %u", fc->tag); spf (s, len, " olddirfid %"PRIu32, fc->u.trenameat.olddirfid); spf (s, len, " oldname '%.*s'", fc->u.trenameat.oldname.len, fc->u.trenameat.oldname.str); spf (s, len, " newdirfid %"PRIu32, fc->u.trenameat.newdirfid); spf (s, len, " newname '%.*s'", fc->u.trenameat.newname.len, fc->u.trenameat.newname.str); break; case P9_RRENAMEAT: spf (s, len, "P9_RRENAMEAT tag %u", fc->tag); break; case P9_TUNLINKAT: spf (s, len, "P9_TUNLINKAT tag %u", fc->tag); spf (s, len, " dirfid %"PRIu32, fc->u.tunlinkat.dirfid); spf (s, len, " name '%.*s'", fc->u.tunlinkat.name.len, fc->u.tunlinkat.name.str); spf (s, len, " flags %"PRIu32, fc->u.tunlinkat.flags); break; case P9_RUNLINKAT: spf (s, len, "P9_RUNLINKAT tag %u", fc->tag); break; case P9_TVERSION: spf (s, len, "P9_TVERSION tag %u", fc->tag); spf (s, len, " msize %u", fc->u.tversion.msize); spf (s, len, " version '%.*s'", fc->u.tversion.version.len, fc->u.tversion.version.str); break; case P9_RVERSION: spf (s, len, "P9_RVERSION tag %u msize %u", fc->tag, fc->u.rversion.msize); spf (s, len, " version '%.*s'", fc->u.rversion.version.len, fc->u.rversion.version.str); break; case P9_TAUTH: spf (s, len, "P9_TAUTH tag %u afid %d", fc->tag, fc->u.tauth.afid); spf (s, len, " uname '%.*s'", fc->u.tauth.uname.len, fc->u.tauth.uname.str); spf (s, len, " aname '%.*s'", fc->u.tauth.aname.len, fc->u.tauth.aname.str); if (fc->u.tauth.n_uname != P9_NONUNAME) spf (s, len, " n_uname %u", fc->u.tauth.n_uname); else spf (s, len, " n_uname P9_NONUNAME"); break; case P9_RAUTH: spf (s, len, "P9_RAUTH tag %u qid ", fc->tag); np_printqid(s, len, &fc->u.rauth.qid); break; case P9_TATTACH: spf (s, len, "P9_TATTACH tag %u", fc->tag); spf (s, len, " fid %d afid %d", fc->u.tattach.fid, fc->u.tattach.afid); spf (s, len, " uname '%.*s'", fc->u.tattach.uname.len, fc->u.tattach.uname.str); spf (s, len, " aname '%.*s'", fc->u.tattach.aname.len, fc->u.tattach.aname.str); if (fc->u.tattach.n_uname != P9_NONUNAME) spf (s, len, " n_uname %u", fc->u.tattach.n_uname); else spf (s, len, " n_uname P9_NONUNAME"); break; case P9_RATTACH: spf (s, len, "P9_RATTACH tag %u qid ", fc->tag); np_printqid(s, len, &fc->u.rattach.qid); break; case P9_TFLUSH: spf (s, len, "P9_TFLUSH tag %u oldtag %u", fc->tag, fc->u.tflush.oldtag); break; case P9_RFLUSH: spf (s, len, "P9_RFLUSH tag %u", fc->tag); break; case P9_TWALK: spf (s, len, "P9_TWALK tag %u fid %d newfid %d nwname %d", fc->tag, fc->u.twalk.fid, fc->u.twalk.newfid, fc->u.twalk.nwname); for(i = 0; i < fc->u.twalk.nwname; i++) spf (s, len, " '%.*s'", fc->u.twalk.wnames[i].len, fc->u.twalk.wnames[i].str); break; case P9_RWALK: spf (s, len, "P9_RWALK tag %u nwqid %d ", fc->tag, fc->u.rwalk.nwqid); for(i = 0; i < fc->u.rwalk.nwqid; i++) np_printqid(s, len, &fc->u.rwalk.wqids[i]); break; case P9_TREAD: spf (s, len, "P9_TREAD tag %u fid %d offset %"PRIu64" count %u", fc->tag, fc->u.tread.fid, fc->u.tread.offset, fc->u.tread.count); break; case P9_RREAD: spf (s, len, "P9_RREAD tag %u count %u", fc->tag, fc->u.rread.count); np_printdata(s, len, fc->u.rread.data, fc->u.rread.count); break; case P9_TWRITE: spf (s, len, "P9_TWRITE tag %u", fc->tag); spf (s, len, " fid %d", fc->u.twrite.fid); spf (s, len, " offset %"PRIu64, fc->u.twrite.offset); spf (s, len, " count %u", fc->u.twrite.count); np_printdata(s, len, fc->u.twrite.data, fc->u.twrite.count); break; case P9_RWRITE: spf (s, len, "P9_RWRITE tag %u count %u", fc->tag, fc->u.rwrite.count); break; case P9_TCLUNK: spf (s, len, "P9_TCLUNK tag %u fid %d", fc->tag, fc->u.tclunk.fid); break; case P9_RCLUNK: spf (s, len, "P9_RCLUNK tag %u", fc->tag); break; case P9_TREMOVE: spf (s, len, "P9_TREMOVE tag %u fid %d", fc->tag, fc->u.tremove.fid); break; case P9_RREMOVE: spf (s, len, "P9_RREMOVE tag %u", fc->tag); break; /* unused ops that we consider a protocol error */ case P9_RERROR: spf (s, len, "P9_RERROR: deprecated protocol op"); break; case P9_TOPEN: spf (s, len, "P9_TOPEN: deprecated protocol op"); break; case P9_ROPEN: spf (s, len, "P9_ROPEN: deprecated protocol op"); break; case P9_TCREATE: spf (s, len, "P9_TCREATE: deprecated protocol op"); break; case P9_RCREATE: spf (s, len, "P9_RCREATE: deprecated protocol op"); break; case P9_TSTAT: spf (s, len, "P9_TSTAT: deprecated protocol op"); break; case P9_RSTAT: spf (s, len, "P9_RSTAT: deprecated protocol op"); break; default: spf (s, len, "unknown protocol op (%d)", fc->type); break; } }