lib/libpuffs/opdump.c

   1 /*      $NetBSD: opdump.c,v 1.26 2009/04/06 14:45:11 pooka Exp $        */
   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
  34 /* yes, this is pretty much a mess */
  35
  36 #include <sys/cdefs.h>
  37 #if !defined(lint)
  38 __RCSID("$NetBSD: opdump.c,v 1.26 2009/04/06 14:45:11 pooka Exp $");
  39 #endif /* !lint */
  40
  41 #include <sys/types.h>
  42 #include <sys/time.h>
  43
  44 #include <puffs.h>
  45 #include <puffsdump.h>
  46 #include <stdio.h>
  47
  48 #include "puffs_priv.h"
  49
  50 /* XXX! */
  51 const char *vfsop_revmap[] = {
  52         "PUFFS_VFS_MOUNT",
  53         "PUFFS_VFS_START",
  54         "PUFFS_VFS_UNMOUNT",
  55         "PUFFS_VFS_ROOT",
  56         "PUFFS_VFS_STATVFS",
  57         "PUFFS_VFS_SYNC",
  58         "PUFFS_VFS_VGET",
  59         "PUFFS_VFS_FHTOVP",
  60         "PUFFS_VFS_VPTOFH",
  61         "PUFFS_VFS_INIT",
  62         "PUFFS_VFS_DONE",
  63         "PUFFS_VFS_SNAPSHOT",
  64         "PUFFS_VFS_EXTATTCTL",
  65         "PUFFS_VFS_SUSPEND"
  66 };
  67 /* XXX! */
  68 const char *vnop_revmap[] = {
  69         "PUFFS_VN_LOOKUP",
  70         "PUFFS_VN_CREATE",
  71         "PUFFS_VN_MKNOD",
  72         "PUFFS_VN_OPEN",
  73         "PUFFS_VN_CLOSE",
  74         "PUFFS_VN_ACCESS",
  75         "PUFFS_VN_GETATTR",
  76         "PUFFS_VN_SETATTR",
  77         "PUFFS_VN_READ",
  78         "PUFFS_VN_WRITE",
  79         "PUFFS_VN_IOCTL",
  80         "PUFFS_VN_FCNTL",
  81         "PUFFS_VN_POLL",
  82         "PUFFS_VN_KQFILTER",
  83         "PUFFS_VN_REVOKE",
  84         "PUFFS_VN_MMAP",
  85         "PUFFS_VN_FSYNC",
  86         "PUFFS_VN_SEEK",
  87         "PUFFS_VN_REMOVE",
  88         "PUFFS_VN_LINK",
  89         "PUFFS_VN_RENAME",
  90         "PUFFS_VN_MKDIR",
  91         "PUFFS_VN_RMDIR",
  92         "PUFFS_VN_SYMLINK",
  93         "PUFFS_VN_READDIR",
  94         "PUFFS_VN_READLINK",
  95         "PUFFS_VN_ABORTOP",
  96         "PUFFS_VN_INACTIVE",
  97         "PUFFS_VN_RECLAIM",
  98         "PUFFS_VN_LOCK",
  99         "PUFFS_VN_UNLOCK",
 100         "PUFFS_VN_BMAP",
 101         "PUFFS_VN_STRATEGY",
 102         "PUFFS_VN_PRINT",
 103         "PUFFS_VN_ISLOCKED",
 104         "PUFFS_VN_PATHCONF",
 105         "PUFFS_VN_ADVLOCK",
 106         "PUFFS_VN_LEASE",
 107         "PUFFS_VN_WHITEOUT",
 108         "PUFFS_VN_GETPAGES",
 109         "PUFFS_VN_PUTPAGES",
 110         "PUFFS_VN_BWRITE",
 111         "PUFFS_VN_GETEXTATTR",
 112         "PUFFS_VN_LISTEXTATTR",
 113         "PUFFS_VN_OPENEXTATTR",
 114         "PUFFS_VN_DELETEEXTATTR",
 115         "PUFFS_VN_SETEXTATTR",
 116 };
 117 /* XXX! */
 118 const char *cacheop_revmap[] = {
 119         "PUFFS_CACHE_WRITE"
 120 };
 121 /* XXX! */
 122 const char *errnot_revmap[] = {
 123         "PUFFS_ERR_MAKENODE",
 124         "PUFFS_ERR_LOOKUP",
 125         "PUFFS_ERR_READDIR",
 126         "PUFFS_ERR_READLINK",
 127         "PUFFS_ERR_READ",
 128         "PUFFS_ERR_WRITE",
 129         "PUFFS_ERR_VPTOFH"
 130 };
 131 /* XXX! */
 132 const char *flush_revmap[] = {
 133         "PUFFS_INVAL_NAMECACHE_NODE",
 134         "PUFFS_INVAL_NAMECACHE_DIR",
 135         "PUFFS_INVAL_NAMECACHE_ALL",
 136         "PUFFS_INVAL_PAGECACHE_NODE_RANGE",
 137         "PUFFS_FLUSH_PAGECACHE_NODE_RANGE",
 138 };
 139
 140 void
 141 puffsdump_req(struct puffs_req *preq)
 142 {
 143         static struct timeval tv_prev;
 144         struct timeval tv_now, tv;
 145         const char **map;
 146         int isvn = 0;
 147
 148         map = NULL; /* yes, we are all interested in your opinion, gcc */
 149         switch (PUFFSOP_OPCLASS(preq->preq_opclass)) {
 150         case PUFFSOP_VFS:
 151                 map = vfsop_revmap;
 152                 break;
 153         case PUFFSOP_VN:
 154                 map = vnop_revmap;
 155                 isvn = 1;
 156                 break;
 157         case PUFFSOP_CACHE:
 158                 map = cacheop_revmap;
 159                 break;
 160         case PUFFSOP_ERROR:
 161                 map = errnot_revmap;
 162                 break;
 163         case PUFFSOP_FLUSH:
 164                 map = flush_revmap;
 165                 break;
 166         }
 167
 168         printf("\treqid: %" PRIu64 ", opclass %d%s, optype: %s, "
 169             "cookie: %p,\n\t\taux: %p, auxlen: %zu, pid: %d, lwpid: %d\n",
 170             preq->preq_id, PUFFSOP_OPCLASS(preq->preq_opclass),
 171             PUFFSOP_WANTREPLY(preq->preq_opclass) ? "" : " (FAF)",
 172             map[preq->preq_optype], preq->preq_cookie,
 173             preq->preq_buf, preq->preq_buflen,
 174             preq->preq_pid, preq->preq_lid);
 175
 176         if (isvn) {
 177                 switch (preq->preq_optype) {
 178                 case PUFFS_VN_LOOKUP:
 179                         puffsdump_lookup(preq);
 180                         break;
 181                 case PUFFS_VN_READ:
 182                 case PUFFS_VN_WRITE:
 183                         puffsdump_readwrite(preq);
 184                         break;
 185                 case PUFFS_VN_OPEN:
 186                         puffsdump_open(preq);
 187                         break;
 188                 case PUFFS_VN_REMOVE:
 189                 case PUFFS_VN_RMDIR:
 190                 case PUFFS_VN_LINK:
 191                         puffsdump_targ(preq);
 192                         break;
 193                 case PUFFS_VN_READDIR:
 194                         puffsdump_readdir(preq);
 195                         break;
 196                 default:
 197                         break;
 198                 }
 199         }
 200
 201         PU_LOCK();
 202         gettimeofday(&tv_now, NULL);
 203         timersub(&tv_now, &tv_prev, &tv);
 204         printf("\t\tsince previous call: %lld.%06ld\n",
 205             (long long)tv.tv_sec, (long)tv.tv_usec);
 206         gettimeofday(&tv_prev, NULL);
 207         PU_UNLOCK();
 208 }
 209
 210 void
 211 puffsdump_rv(struct puffs_req *preq)
 212 {
 213
 214         if (PUFFSOP_OPCLASS(preq->preq_opclass) == PUFFSOP_VN) {
 215                 switch (preq->preq_optype) {
 216                 case PUFFS_VN_LOOKUP:
 217                         puffsdump_lookup_rv(preq);
 218                         break;
 219                 case PUFFS_VN_CREATE:
 220                 case PUFFS_VN_MKDIR:
 221                 case PUFFS_VN_MKNOD:
 222                 case PUFFS_VN_SYMLINK:
 223                         puffsdump_create_rv(preq);
 224                         break;
 225                 case PUFFS_VN_READ:
 226                 case PUFFS_VN_WRITE:
 227                         puffsdump_readwrite_rv(preq);
 228                         break;
 229                 case PUFFS_VN_READDIR:
 230                         puffsdump_readdir_rv(preq);
 231                         break;
 232                 default:
 233                         break;
 234                 }
 235         }
 236
 237         printf("\tRV reqid: %" PRIu64 ", result: %d %s\n",
 238             preq->preq_id, preq->preq_rv,
 239             preq->preq_rv ? strerror(preq->preq_rv) : "");
 240 }
 241
 242 void
 243 puffsdump_cookie(puffs_cookie_t c, const char *cookiename)
 244 {
 245
 246         printf("\t%scookie: at %p\n", cookiename, c);
 247 }
 248
 249 static const char *cn_opnames[] = {
 250         "LOOKUP",
 251         "CREATE",
 252         "DELETE",
 253         "RENAME"
 254 };
 255
 256 void
 257 puffsdump_cn(struct puffs_kcn *pkcn)
 258 {
 259
 260         printf("\t\tpuffs_cn: \"%s\", len %zu op %s (flags 0x%x)\n",
 261             pkcn->pkcn_name, pkcn->pkcn_namelen,
 262             cn_opnames[pkcn->pkcn_nameiop & NAMEI_OPMASK],
 263             pkcn->pkcn_flags);
 264 }
 265
 266 void
 267 puffsdump_lookup(struct puffs_req *preq)
 268 {
 269         struct puffs_vnmsg_lookup *lookup_msg = (void *)preq;
 270
 271         puffsdump_cn(&lookup_msg->pvnr_cn);
 272 }
 273
 274 void
 275 puffsdump_lookup_rv(struct puffs_req *preq)
 276 {
 277         struct puffs_vnmsg_lookup *lookup_msg = (void *)preq;
 278
 279         printf("\t\tnew node %p, type 0x%x,\n\t\tsize 0x%"PRIu64", dev 0x%llx\n",
 280             lookup_msg->pvnr_newnode, lookup_msg->pvnr_vtype,
 281             lookup_msg->pvnr_size, (unsigned long long)lookup_msg->pvnr_rdev);
 282 }
 283
 284 void
 285 puffsdump_create_rv(struct puffs_req *preq)
 286 {
 287         /* XXX: wrong type, but we know it fits the slot */
 288         struct puffs_vnmsg_create *create_msg = (void *)preq;
 289
 290         printf("\t\tnew node %p\n", create_msg->pvnr_newnode);
 291 }
 292
 293 void
 294 puffsdump_readwrite(struct puffs_req *preq)
 295 {
 296         struct puffs_vnmsg_rw *rw_msg = (void *)preq;
 297
 298         printf("\t\toffset: %" PRId64 ", resid %zu, ioflag 0x%x\n",
 299             rw_msg->pvnr_offset, rw_msg->pvnr_resid, rw_msg->pvnr_ioflag);
 300 }
 301
 302 void
 303 puffsdump_readwrite_rv(struct puffs_req *preq)
 304 {
 305         struct puffs_vnmsg_rw *rw_msg = (void *)preq;
 306
 307         printf("\t\tresid after op: %zu\n", rw_msg->pvnr_resid);
 308 }
 309
 310 void
 311 puffsdump_readdir_rv(struct puffs_req *preq)
 312 {
 313         struct puffs_vnmsg_readdir *readdir_msg = (void *)preq;
 314
 315         printf("\t\tresid after op: %zu, eofflag %d\n",
 316             readdir_msg->pvnr_resid, readdir_msg->pvnr_eofflag);
 317 }
 318
 319 void
 320 puffsdump_open(struct puffs_req *preq)
 321 {
 322         struct puffs_vnmsg_open *open_msg = (void *)preq;
 323
 324         printf("\t\tmode: 0x%x\n", open_msg->pvnr_mode);
 325 }
 326
 327 void
 328 puffsdump_targ(struct puffs_req *preq)
 329 {
 330         struct puffs_vnmsg_remove *remove_msg = (void *)preq; /* XXX! */
 331
 332         printf("\t\ttarget cookie: %p\n", remove_msg->pvnr_cookie_targ);
 333 }
 334
 335 void
 336 puffsdump_readdir(struct puffs_req *preq)
 337 {
 338         struct puffs_vnmsg_readdir *readdir_msg = (void *)preq;
 339
 340         printf("\t\tread offset: %" PRId64 "\n", readdir_msg->pvnr_offset);
 341 }
 342
 343 void
 344 /*ARGSUSED*/
 345 puffsdump_creds(struct puffs_cred *pcr)
 346 {
 347
 348 }
 349
 350 void
 351 puffsdump_int(int value, const char *name)
 352 {
 353
 354         printf("\tint (%s): %d\n", name, value);
 355 }