Annotation of src/lib/libpuffs/opdump.c, Revision 1.30
1.30 ! pooka 1: /* $NetBSD: opdump.c,v 1.29 2010/01/07 20:47:47 pooka Exp $ */
1.1 pooka 2:
3: /*
4: * Copyright (c) 2005, 2006 Antti Kantee. All Rights Reserved.
5: *
6: * Development of this software was supported by the
7: * Google Summer of Code program and the Ulla Tuominen Foundation.
8: * The Google SoC project was mentored by Bill Studenmund.
9: *
10: * Redistribution and use in source and binary forms, with or without
11: * modification, are permitted provided that the following conditions
12: * are met:
13: * 1. Redistributions of source code must retain the above copyright
14: * notice, this list of conditions and the following disclaimer.
15: * 2. Redistributions in binary form must reproduce the above copyright
16: * notice, this list of conditions and the following disclaimer in the
17: * documentation and/or other materials provided with the distribution.
18: *
19: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
20: * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
21: * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
22: * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
23: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
25: * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29: * SUCH DAMAGE.
30: */
31:
32: /* Pretty-printing helper routines for VFS/VOP request contents */
33:
1.11 pooka 34: /* yes, this is pretty much a mess */
35:
1.1 pooka 36: #include <sys/cdefs.h>
37: #if !defined(lint)
1.30 ! pooka 38: __RCSID("$NetBSD: opdump.c,v 1.29 2010/01/07 20:47:47 pooka Exp $");
1.1 pooka 39: #endif /* !lint */
40:
1.11 pooka 41: #include <sys/types.h>
42: #include <sys/time.h>
43:
1.1 pooka 44: #include <puffs.h>
45: #include <puffsdump.h>
46: #include <stdio.h>
47:
1.17 pooka 48: #include "puffs_priv.h"
49:
1.28 pooka 50: #define DINT " "
51:
1.1 pooka 52: /* XXX! */
1.4 pooka 53: const char *vfsop_revmap[] = {
54: "PUFFS_VFS_MOUNT",
55: "PUFFS_VFS_START",
56: "PUFFS_VFS_UNMOUNT",
57: "PUFFS_VFS_ROOT",
58: "PUFFS_VFS_STATVFS",
59: "PUFFS_VFS_SYNC",
60: "PUFFS_VFS_VGET",
61: "PUFFS_VFS_FHTOVP",
62: "PUFFS_VFS_VPTOFH",
63: "PUFFS_VFS_INIT",
64: "PUFFS_VFS_DONE",
65: "PUFFS_VFS_SNAPSHOT",
1.7 pooka 66: "PUFFS_VFS_EXTATTCTL",
67: "PUFFS_VFS_SUSPEND"
1.4 pooka 68: };
69: /* XXX! */
1.1 pooka 70: const char *vnop_revmap[] = {
1.4 pooka 71: "PUFFS_VN_LOOKUP",
72: "PUFFS_VN_CREATE",
73: "PUFFS_VN_MKNOD",
74: "PUFFS_VN_OPEN",
75: "PUFFS_VN_CLOSE",
76: "PUFFS_VN_ACCESS",
77: "PUFFS_VN_GETATTR",
78: "PUFFS_VN_SETATTR",
79: "PUFFS_VN_READ",
80: "PUFFS_VN_WRITE",
81: "PUFFS_VN_IOCTL",
82: "PUFFS_VN_FCNTL",
83: "PUFFS_VN_POLL",
84: "PUFFS_VN_KQFILTER",
85: "PUFFS_VN_REVOKE",
86: "PUFFS_VN_MMAP",
87: "PUFFS_VN_FSYNC",
88: "PUFFS_VN_SEEK",
89: "PUFFS_VN_REMOVE",
90: "PUFFS_VN_LINK",
91: "PUFFS_VN_RENAME",
92: "PUFFS_VN_MKDIR",
93: "PUFFS_VN_RMDIR",
94: "PUFFS_VN_SYMLINK",
95: "PUFFS_VN_READDIR",
96: "PUFFS_VN_READLINK",
97: "PUFFS_VN_ABORTOP",
98: "PUFFS_VN_INACTIVE",
99: "PUFFS_VN_RECLAIM",
100: "PUFFS_VN_LOCK",
101: "PUFFS_VN_UNLOCK",
102: "PUFFS_VN_BMAP",
103: "PUFFS_VN_STRATEGY",
104: "PUFFS_VN_PRINT",
105: "PUFFS_VN_ISLOCKED",
106: "PUFFS_VN_PATHCONF",
107: "PUFFS_VN_ADVLOCK",
108: "PUFFS_VN_LEASE",
109: "PUFFS_VN_WHITEOUT",
110: "PUFFS_VN_GETPAGES",
111: "PUFFS_VN_PUTPAGES",
112: "PUFFS_VN_BWRITE",
113: "PUFFS_VN_GETEXTATTR",
114: "PUFFS_VN_LISTEXTATTR",
115: "PUFFS_VN_OPENEXTATTR",
116: "PUFFS_VN_DELETEEXTATTR",
117: "PUFFS_VN_SETEXTATTR",
1.1 pooka 118: };
1.14 pooka 119: /* XXX! */
1.9 pooka 120: const char *cacheop_revmap[] = {
121: "PUFFS_CACHE_WRITE"
122: };
1.14 pooka 123: /* XXX! */
124: const char *errnot_revmap[] = {
125: "PUFFS_ERR_MAKENODE",
126: "PUFFS_ERR_LOOKUP",
127: "PUFFS_ERR_READDIR",
128: "PUFFS_ERR_READLINK",
129: "PUFFS_ERR_READ",
130: "PUFFS_ERR_WRITE",
131: "PUFFS_ERR_VPTOFH"
132: };
1.20 pooka 133: /* XXX! */
134: const char *flush_revmap[] = {
135: "PUFFS_INVAL_NAMECACHE_NODE",
136: "PUFFS_INVAL_NAMECACHE_DIR",
137: "PUFFS_INVAL_NAMECACHE_ALL",
138: "PUFFS_INVAL_PAGECACHE_NODE_RANGE",
139: "PUFFS_FLUSH_PAGECACHE_NODE_RANGE",
140: };
1.1 pooka 141:
142: void
143: puffsdump_req(struct puffs_req *preq)
144: {
1.11 pooka 145: static struct timeval tv_prev;
146: struct timeval tv_now, tv;
1.4 pooka 147: const char **map;
1.12 pooka 148: int isvn = 0;
1.1 pooka 149:
1.30 ! pooka 150: printf("reqid: %" PRIu64 ", ", preq->preq_id);
1.9 pooka 151: switch (PUFFSOP_OPCLASS(preq->preq_opclass)) {
152: case PUFFSOP_VFS:
153: map = vfsop_revmap;
154: break;
155: case PUFFSOP_VN:
156: map = vnop_revmap;
1.12 pooka 157: isvn = 1;
1.9 pooka 158: break;
159: case PUFFSOP_CACHE:
160: map = cacheop_revmap;
161: break;
1.14 pooka 162: case PUFFSOP_ERROR:
163: map = errnot_revmap;
164: break;
1.20 pooka 165: case PUFFSOP_FLUSH:
166: map = flush_revmap;
167: break;
1.30 ! pooka 168: default:
! 169: printf("unhandled opclass\n");
! 170: return;
1.9 pooka 171: }
1.11 pooka 172:
1.30 ! pooka 173: printf("opclass %d%s, optype: %s, "
1.28 pooka 174: "cookie: %p,\n" DINT "aux: %p, auxlen: %zu, pid: %d, lwpid: %d\n",
1.30 ! pooka 175: PUFFSOP_OPCLASS(preq->preq_opclass),
1.5 pooka 176: PUFFSOP_WANTREPLY(preq->preq_opclass) ? "" : " (FAF)",
177: map[preq->preq_optype], preq->preq_cookie,
1.16 pooka 178: preq->preq_buf, preq->preq_buflen,
179: preq->preq_pid, preq->preq_lid);
1.12 pooka 180:
181: if (isvn) {
182: switch (preq->preq_optype) {
1.13 pooka 183: case PUFFS_VN_LOOKUP:
184: puffsdump_lookup(preq);
185: break;
1.12 pooka 186: case PUFFS_VN_READ:
187: case PUFFS_VN_WRITE:
188: puffsdump_readwrite(preq);
189: break;
1.19 pooka 190: case PUFFS_VN_OPEN:
191: puffsdump_open(preq);
192: break;
1.23 pooka 193: case PUFFS_VN_REMOVE:
194: case PUFFS_VN_RMDIR:
195: case PUFFS_VN_LINK:
196: puffsdump_targ(preq);
197: break;
1.27 pooka 198: case PUFFS_VN_READDIR:
199: puffsdump_readdir(preq);
200: break;
1.29 pooka 201: case PUFFS_VN_CREATE:
202: case PUFFS_VN_MKDIR:
203: case PUFFS_VN_MKNOD:
204: case PUFFS_VN_SYMLINK:
205: puffsdump_create(preq);
206: break;
207: case PUFFS_VN_SETATTR:
208: puffsdump_attr(preq);
209: break;
1.12 pooka 210: default:
211: break;
212: }
213: }
1.29 pooka 214:
1.17 pooka 215: PU_LOCK();
1.11 pooka 216: gettimeofday(&tv_now, NULL);
217: timersub(&tv_now, &tv_prev, &tv);
1.28 pooka 218: printf(DINT "since previous call: %lld.%06ld\n",
1.25 christos 219: (long long)tv.tv_sec, (long)tv.tv_usec);
1.11 pooka 220: gettimeofday(&tv_prev, NULL);
1.17 pooka 221: PU_UNLOCK();
1.1 pooka 222: }
223:
224: void
1.8 pooka 225: puffsdump_rv(struct puffs_req *preq)
226: {
227:
1.13 pooka 228: if (PUFFSOP_OPCLASS(preq->preq_opclass) == PUFFSOP_VN) {
229: switch (preq->preq_optype) {
230: case PUFFS_VN_LOOKUP:
231: puffsdump_lookup_rv(preq);
232: break;
1.21 pooka 233: case PUFFS_VN_CREATE:
234: case PUFFS_VN_MKDIR:
235: case PUFFS_VN_MKNOD:
236: case PUFFS_VN_SYMLINK:
237: puffsdump_create_rv(preq);
238: break;
1.22 pooka 239: case PUFFS_VN_READ:
240: case PUFFS_VN_WRITE:
241: puffsdump_readwrite_rv(preq);
242: break;
1.26 pooka 243: case PUFFS_VN_READDIR:
244: puffsdump_readdir_rv(preq);
245: break;
1.29 pooka 246: case PUFFS_VN_GETATTR:
247: puffsdump_attr(preq);
248: break;
1.13 pooka 249: default:
250: break;
251: }
252: }
1.26 pooka 253:
1.28 pooka 254: printf("RV reqid: %" PRIu64 ", result: %d %s\n",
1.26 pooka 255: preq->preq_id, preq->preq_rv,
256: preq->preq_rv ? strerror(preq->preq_rv) : "");
1.8 pooka 257: }
258:
1.29 pooka 259: /*
260: * Slightly tedious print-routine so that we get a nice NOVAL instead
261: * of some tedious output representations for -1, especially (uint64_t)-1
262: *
263: * We use typecasting to make this work beyond time_t/dev_t size changes.
264: */
265: static void
266: dumpattr(struct vattr *vap)
267: {
268: const char * const vtypes[] = { VNODE_TYPES };
269: char buf[128];
270:
271: /* XXX: better readability. and this is debug, so no cycle-sweat */
272: #define DEFAULTBUF() snprintf(buf, sizeof(buf), "NOVAL")
273:
274: printf(DINT "vattr:\n");
275: printf(DINT DINT "type: %s, ", vtypes[vap->va_type]);
276:
277: DEFAULTBUF();
278: if (vap->va_mode != (mode_t)PUFFS_VNOVAL)
279: snprintf(buf, sizeof(buf), "0%o", vap->va_mode);
280: printf("mode: %s, ", buf);
281:
282: DEFAULTBUF();
283: if (vap->va_nlink != (nlink_t)PUFFS_VNOVAL)
284: snprintf(buf, sizeof(buf), "%d", vap->va_nlink);
285: printf("nlink: %s, ", buf);
286:
287: DEFAULTBUF();
288: if (vap->va_uid != (uid_t)PUFFS_VNOVAL)
289: snprintf(buf, sizeof(buf), "%d", vap->va_uid);
290: printf("uid: %s, ", buf);
291:
292: DEFAULTBUF();
293: if (vap->va_gid != (gid_t)PUFFS_VNOVAL)
294: snprintf(buf, sizeof(buf), "%d", vap->va_gid);
295: printf("gid: %s\n", buf);
296:
297: DEFAULTBUF();
298: if (vap->va_fsid != (dev_t)PUFFS_VNOVAL)
299: snprintf(buf, sizeof(buf), "0x%llx",
300: (unsigned long long)vap->va_fsid);
301: printf(DINT DINT "fsid: %s, ", buf);
302:
303: DEFAULTBUF();
304: if (vap->va_fileid != (ino_t)PUFFS_VNOVAL)
305: snprintf(buf, sizeof(buf), "%" PRIu64, vap->va_fileid);
306: printf("ino: %s, ", buf);
307:
308: DEFAULTBUF();
309: if (vap->va_size != (u_quad_t)PUFFS_VNOVAL)
310: snprintf(buf, sizeof(buf), "%" PRIu64, vap->va_size);
311: printf("size: %s, ", buf);
312:
313: DEFAULTBUF();
314: if (vap->va_blocksize != (long)PUFFS_VNOVAL)
315: snprintf(buf, sizeof(buf), "%ld", vap->va_blocksize);
316: printf("bsize: %s\n", buf);
317:
318: DEFAULTBUF();
319: if (vap->va_atime.tv_sec != (time_t)PUFFS_VNOVAL)
320: snprintf(buf, sizeof(buf), "%lld",
321: (long long)vap->va_atime.tv_sec);
322: printf(DINT DINT "a.s: %s, ", buf);
323:
324: DEFAULTBUF();
325: if (vap->va_atime.tv_nsec != (long)PUFFS_VNOVAL)
326: snprintf(buf, sizeof(buf), "%ld", vap->va_atime.tv_nsec);
327: printf("a.ns: %s, ", buf);
328:
329: DEFAULTBUF();
330: if (vap->va_mtime.tv_sec != (time_t)PUFFS_VNOVAL)
331: snprintf(buf, sizeof(buf), "%lld",
332: (long long)vap->va_mtime.tv_sec);
333: printf("m.s: %s, ", buf);
334:
335: DEFAULTBUF();
336: if (vap->va_mtime.tv_nsec != (long)PUFFS_VNOVAL)
337: snprintf(buf, sizeof(buf), "%ld", vap->va_mtime.tv_nsec);
338: printf("m.ns: %s\n", buf);
339:
340: DEFAULTBUF();
341: if (vap->va_ctime.tv_sec != (time_t)PUFFS_VNOVAL)
342: snprintf(buf, sizeof(buf), "%lld",
343: (long long)vap->va_ctime.tv_sec);
344: printf(DINT DINT "c.s: %s, ", buf);
345:
346: DEFAULTBUF();
347: if (vap->va_ctime.tv_nsec != (long)PUFFS_VNOVAL)
348: snprintf(buf, sizeof(buf), "%ld", vap->va_ctime.tv_nsec);
349: printf("c.ns: %s, ", buf);
350:
351: DEFAULTBUF();
352: if (vap->va_birthtime.tv_sec != (time_t)PUFFS_VNOVAL)
353: snprintf(buf, sizeof(buf), "%lld",
354: (long long)vap->va_birthtime.tv_sec);
355: printf("b.s: %s, ", buf);
356:
357: DEFAULTBUF();
358: if (vap->va_birthtime.tv_nsec != (long)PUFFS_VNOVAL)
359: snprintf(buf, sizeof(buf), "%ld", vap->va_birthtime.tv_nsec);
360: printf("b.ns: %s\n", buf);
361:
362: DEFAULTBUF();
363: if (vap->va_gen != (u_long)PUFFS_VNOVAL)
364: snprintf(buf, sizeof(buf), "%lu", vap->va_gen);
365: printf(DINT DINT "gen: %s, ", buf);
366:
367: DEFAULTBUF();
368: if (vap->va_flags != (u_long)PUFFS_VNOVAL)
369: snprintf(buf, sizeof(buf), "0x%lx", vap->va_flags);
370: printf("flags: %s, ", buf);
371:
372: DEFAULTBUF();
373: if (vap->va_rdev != (dev_t)PUFFS_VNOVAL)
374: snprintf(buf, sizeof(buf), "0x%llx",
375: (unsigned long long)vap->va_rdev);
376: printf("rdev: %s\n", buf);
377:
378: DEFAULTBUF();
379: if (vap->va_bytes != (u_quad_t)PUFFS_VNOVAL)
380: snprintf(buf, sizeof(buf), "%" PRIu64, vap->va_bytes);
381: printf(DINT DINT "bytes: %s, ", buf);
382:
383: snprintf(buf, sizeof(buf), "%" PRIu64, vap->va_filerev);
384: printf("filerev: %s, ", buf);
385:
386: snprintf(buf, sizeof(buf), "0x%x", vap->va_vaflags);
387: printf("vaflags: %s\n", buf);
388: }
389:
1.8 pooka 390: void
1.24 pooka 391: puffsdump_cookie(puffs_cookie_t c, const char *cookiename)
1.1 pooka 392: {
393:
1.28 pooka 394: printf("%scookie: at %p\n", cookiename, c);
1.1 pooka 395: }
396:
397: static const char *cn_opnames[] = {
398: "LOOKUP",
399: "CREATE",
400: "DELETE",
401: "RENAME"
402: };
1.13 pooka 403:
1.1 pooka 404: void
1.13 pooka 405: puffsdump_cn(struct puffs_kcn *pkcn)
1.1 pooka 406: {
407:
1.28 pooka 408: printf(DINT "puffs_cn: \"%s\", len %zu op %s (flags 0x%x)\n",
1.13 pooka 409: pkcn->pkcn_name, pkcn->pkcn_namelen,
410: cn_opnames[pkcn->pkcn_nameiop & NAMEI_OPMASK],
411: pkcn->pkcn_flags);
412: }
413:
414: void
415: puffsdump_lookup(struct puffs_req *preq)
416: {
1.15 pooka 417: struct puffs_vnmsg_lookup *lookup_msg = (void *)preq;
1.13 pooka 418:
1.15 pooka 419: puffsdump_cn(&lookup_msg->pvnr_cn);
1.13 pooka 420: }
421:
422: void
423: puffsdump_lookup_rv(struct puffs_req *preq)
424: {
1.15 pooka 425: struct puffs_vnmsg_lookup *lookup_msg = (void *)preq;
1.13 pooka 426:
1.28 pooka 427: printf(DINT "new %p, type 0x%x, size 0x%"PRIu64", dev 0x%llx\n",
1.15 pooka 428: lookup_msg->pvnr_newnode, lookup_msg->pvnr_vtype,
1.25 christos 429: lookup_msg->pvnr_size, (unsigned long long)lookup_msg->pvnr_rdev);
1.1 pooka 430: }
431:
432: void
1.29 pooka 433: puffsdump_create(struct puffs_req *preq)
434: {
435: /* XXX: wrong type, but we know it fits the slot */
436: struct puffs_vnmsg_create *create_msg = (void *)preq;
437:
438: dumpattr(&create_msg->pvnr_va);
439: }
440:
441: void
1.21 pooka 442: puffsdump_create_rv(struct puffs_req *preq)
443: {
444: /* XXX: wrong type, but we know it fits the slot */
445: struct puffs_vnmsg_create *create_msg = (void *)preq;
446:
1.28 pooka 447: printf(DINT "new %p\n", create_msg->pvnr_newnode);
1.21 pooka 448: }
449:
450: void
1.12 pooka 451: puffsdump_readwrite(struct puffs_req *preq)
452: {
1.15 pooka 453: struct puffs_vnmsg_rw *rw_msg = (void *)preq;
1.12 pooka 454:
1.28 pooka 455: printf(DINT "offset: %" PRId64 ", resid %zu, ioflag 0x%x\n",
1.15 pooka 456: rw_msg->pvnr_offset, rw_msg->pvnr_resid, rw_msg->pvnr_ioflag);
1.12 pooka 457: }
458:
459: void
1.22 pooka 460: puffsdump_readwrite_rv(struct puffs_req *preq)
461: {
462: struct puffs_vnmsg_rw *rw_msg = (void *)preq;
463:
1.28 pooka 464: printf(DINT "resid after op: %zu\n", rw_msg->pvnr_resid);
1.22 pooka 465: }
466:
467: void
1.26 pooka 468: puffsdump_readdir_rv(struct puffs_req *preq)
469: {
470: struct puffs_vnmsg_readdir *readdir_msg = (void *)preq;
471:
1.28 pooka 472: printf(DINT "resid after op: %zu, eofflag %d\n",
1.26 pooka 473: readdir_msg->pvnr_resid, readdir_msg->pvnr_eofflag);
474: }
475:
476: void
1.19 pooka 477: puffsdump_open(struct puffs_req *preq)
478: {
479: struct puffs_vnmsg_open *open_msg = (void *)preq;
480:
1.28 pooka 481: printf(DINT "mode: 0x%x\n", open_msg->pvnr_mode);
1.19 pooka 482: }
483:
484: void
1.23 pooka 485: puffsdump_targ(struct puffs_req *preq)
486: {
487: struct puffs_vnmsg_remove *remove_msg = (void *)preq; /* XXX! */
488:
1.28 pooka 489: printf(DINT "target cookie: %p\n", remove_msg->pvnr_cookie_targ);
1.23 pooka 490: }
491:
492: void
1.27 pooka 493: puffsdump_readdir(struct puffs_req *preq)
494: {
495: struct puffs_vnmsg_readdir *readdir_msg = (void *)preq;
496:
1.28 pooka 497: printf(DINT "read offset: %" PRId64 "\n", readdir_msg->pvnr_offset);
1.1 pooka 498: }
1.29 pooka 499:
500: void
501: puffsdump_attr(struct puffs_req *preq)
502: {
503: struct puffs_vnmsg_setgetattr *attr_msg = (void *)preq;
504:
505: dumpattr(&attr_msg->pvnr_va);
506: }
CVSweb <webmaster@jp.NetBSD.org>
![[BACK]](/icons/back.gif){kind=icon}
Return to opdump.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [cvs.NetBSD.org] / src / lib / libpuffs