lib/libdmsg/debug.c

   1 /*
   2  * Copyright (c) 2012 The DragonFly Project.  All rights reserved.
   3  *
   4  * This code is derived from software contributed to The DragonFly Project
   5  * by Matthew Dillon <dillon@dragonflybsd.org>
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  *
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in
  15  *    the documentation and/or other materials provided with the
  16  *    distribution.
  17  * 3. Neither the name of The DragonFly Project nor the names of its
  18  *    contributors may be used to endorse or promote products derived
  19  *    from this software without specific, prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  22  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  23  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  24  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
  25  * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  26  * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
  27  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  28  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
  29  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  30  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  31  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  32  * SUCH DAMAGE.
  33  */
  34
  35 #include "dmsg_local.h"
  36
  37 const char *
  38 dmsg_basecmd_str(uint32_t cmd)
  39 {
  40         static char buf[64];
  41         char protobuf[32];
  42         char cmdbuf[32];
  43         const char *protostr;
  44         const char *cmdstr;
  45
  46         switch(cmd & DMSGF_PROTOS) {
  47         case DMSG_PROTO_LNK:
  48                 protostr = "LNK_";
  49                 break;
  50         case DMSG_PROTO_DBG:
  51                 protostr = "DBG_";
  52                 break;
  53         case DMSG_PROTO_DOM:
  54                 protostr = "DOM_";
  55                 break;
  56         case DMSG_PROTO_CAC:
  57                 protostr = "CAC_";
  58                 break;
  59         case DMSG_PROTO_QRM:
  60                 protostr = "QRM_";
  61                 break;
  62         case DMSG_PROTO_BLK:
  63                 protostr = "BLK_";
  64                 break;
  65         case DMSG_PROTO_VOP:
  66                 protostr = "VOP_";
  67                 break;
  68         default:
  69                 snprintf(protobuf, sizeof(protobuf), "%x_",
  70                         (cmd & DMSGF_PROTOS) >> 20);
  71                 protostr = protobuf;
  72                 break;
  73         }
  74
  75         switch(cmd & (DMSGF_PROTOS |
  76                       DMSGF_CMDS |
  77                       DMSGF_SIZE)) {
  78         case DMSG_LNK_PAD:
  79                 cmdstr = "PAD";
  80                 break;
  81         case DMSG_LNK_PING:
  82                 cmdstr = "PING";
  83                 break;
  84         case DMSG_LNK_AUTH:
  85                 cmdstr = "AUTH";
  86                 break;
  87         case DMSG_LNK_CONN:
  88                 cmdstr = "CONN";
  89                 break;
  90         case DMSG_LNK_SPAN:
  91                 cmdstr = "SPAN";
  92                 break;
  93         case DMSG_LNK_VOLCONF:
  94                 cmdstr = "VOLCONF";
  95                 break;
  96         case DMSG_LNK_ERROR:
  97                 if (cmd & DMSGF_DELETE)
  98                         cmdstr = "RETURN";
  99                 else
 100                         cmdstr = "RESULT";
 101                 break;
 102         case DMSG_DBG_SHELL:
 103                 cmdstr = "SHELL";
 104                 break;
 105         default:
 106                 snprintf(cmdbuf, sizeof(cmdbuf),
 107                          "%06x", (cmd & (DMSGF_PROTOS |
 108                                          DMSGF_CMDS |
 109                                          DMSGF_SIZE)));
 110                 cmdstr = cmdbuf;
 111                 break;
 112         }
 113         snprintf(buf, sizeof(buf), "%s%s", protostr, cmdstr);
 114         return (buf);
 115 }
 116
 117 const char *
 118 dmsg_msg_str(dmsg_msg_t *msg)
 119 {
 120         dmsg_state_t *state;
 121         static char buf[256];
 122         char errbuf[16];
 123         char statebuf[64];
 124         char flagbuf[64];
 125         const char *statestr;
 126         const char *errstr;
 127         uint32_t basecmd;
 128         int i;
 129
 130         /*
 131          * Parse the state
 132          */
 133         if ((state = msg->state) != NULL) {
 134                 basecmd = (state->rxcmd & DMSGF_REPLY) ?
 135                           state->txcmd : state->rxcmd;
 136                 snprintf(statebuf, sizeof(statebuf),
 137                          " %s=%s,L=%s%s,R=%s%s",
 138                          ((state->txcmd & DMSGF_REPLY) ?
 139                                 "rcvcmd" : "sndcmd"),
 140                          dmsg_basecmd_str(basecmd),
 141                          ((state->txcmd & DMSGF_CREATE) ? "C" : ""),
 142                          ((state->txcmd & DMSGF_DELETE) ? "D" : ""),
 143                          ((state->rxcmd & DMSGF_CREATE) ? "C" : ""),
 144                          ((state->rxcmd & DMSGF_DELETE) ? "D" : "")
 145                 );
 146                 statestr = statebuf;
 147         } else {
 148                 statestr = "";
 149         }
 150
 151         /*
 152          * Parse the error
 153          */
 154         switch(msg->any.head.error) {
 155         case 0:
 156                 errstr = "";
 157                 break;
 158         case DMSG_IOQ_ERROR_SYNC:
 159                 errstr = "err=IOQ:NOSYNC";
 160                 break;
 161         case DMSG_IOQ_ERROR_EOF:
 162                 errstr = "err=IOQ:STREAMEOF";
 163                 break;
 164         case DMSG_IOQ_ERROR_SOCK:
 165                 errstr = "err=IOQ:SOCKERR";
 166                 break;
 167         case DMSG_IOQ_ERROR_FIELD:
 168                 errstr = "err=IOQ:BADFIELD";
 169                 break;
 170         case DMSG_IOQ_ERROR_HCRC:
 171                 errstr = "err=IOQ:BADHCRC";
 172                 break;
 173         case DMSG_IOQ_ERROR_XCRC:
 174                 errstr = "err=IOQ:BADXCRC";
 175                 break;
 176         case DMSG_IOQ_ERROR_ACRC:
 177                 errstr = "err=IOQ:BADACRC";
 178                 break;
 179         case DMSG_IOQ_ERROR_STATE:
 180                 errstr = "err=IOQ:BADSTATE";
 181                 break;
 182         case DMSG_IOQ_ERROR_NOPEER:
 183                 errstr = "err=IOQ:PEERCONFIG";
 184                 break;
 185         case DMSG_IOQ_ERROR_NORKEY:
 186                 errstr = "err=IOQ:BADRKEY";
 187                 break;
 188         case DMSG_IOQ_ERROR_NOLKEY:
 189                 errstr = "err=IOQ:BADLKEY";
 190                 break;
 191         case DMSG_IOQ_ERROR_KEYXCHGFAIL:
 192                 errstr = "err=IOQ:BADKEYXCHG";
 193                 break;
 194         case DMSG_IOQ_ERROR_KEYFMT:
 195                 errstr = "err=IOQ:BADFMT";
 196                 break;
 197         case DMSG_IOQ_ERROR_BADURANDOM:
 198                 errstr = "err=IOQ:BADRANDOM";
 199                 break;
 200         case DMSG_IOQ_ERROR_MSGSEQ:
 201                 errstr = "err=IOQ:BADSEQ";
 202                 break;
 203         case DMSG_IOQ_ERROR_EALREADY:
 204                 errstr = "err=IOQ:DUPMSG";
 205                 break;
 206         case DMSG_IOQ_ERROR_TRANS:
 207                 errstr = "err=IOQ:BADTRANS";
 208                 break;
 209         case DMSG_IOQ_ERROR_IVWRAP:
 210                 errstr = "err=IOQ:IVWRAP";
 211                 break;
 212         case DMSG_IOQ_ERROR_MACFAIL:
 213                 errstr = "err=IOQ:MACFAIL";
 214                 break;
 215         case DMSG_IOQ_ERROR_ALGO:
 216                 errstr = "err=IOQ:ALGOFAIL";
 217                 break;
 218         case DMSG_ERR_NOSUPP:
 219                 errstr = "err=NOSUPPORT";
 220                 break;
 221         default:
 222                 snprintf(errbuf, sizeof(errbuf),
 223                          " err=%d", msg->any.head.error);
 224                 errstr = errbuf;
 225                 break;
 226         }
 227
 228         /*
 229          * Message flags
 230          */
 231         i = 0;
 232         if (msg->any.head.cmd & (DMSGF_CREATE | DMSGF_DELETE |
 233                                  DMSGF_ABORT | DMSGF_REPLY)) {
 234                 flagbuf[i++] = '|';
 235                 if (msg->any.head.cmd & DMSGF_CREATE)
 236                         flagbuf[i++] = 'C';
 237                 if (msg->any.head.cmd & DMSGF_DELETE)
 238                         flagbuf[i++] = 'D';
 239                 if (msg->any.head.cmd & DMSGF_REPLY)
 240                         flagbuf[i++] = 'R';
 241                 if (msg->any.head.cmd & DMSGF_ABORT)
 242                         flagbuf[i++] = 'A';
 243         }
 244         flagbuf[i] = 0;
 245
 246         /*
 247          * Generate the buf
 248          */
 249         snprintf(buf, sizeof(buf),
 250                 "msg=%s%s %s msgid=%08x %s",
 251                  dmsg_basecmd_str(msg->any.head.cmd),
 252                  flagbuf,
 253                  errstr,
 254                  (uint32_t)(intmax_t)msg->any.head.msgid,   /* for brevity */
 255                  statestr);
 256
 257         return(buf);
 258 }