usr/src/cmd/cxgbetool/cxgbetool.c

   1 /*
   2  * This file and its contents are supplied under the terms of the
   3  * Common Development and Distribution License ("CDDL"), version 1.0.
   4  * You may only use this file in accordance with the terms of version
   5  * 1.0 of the CDDL.
   6  *
   7  * A full copy of the text of the CDDL should have accompanied this
   8  * source.  A copy of the CDDL is also available via the Internet at
   9  * http://www.illumos.org/license/CDDL.
  10  */
  11
  12 /*
  13  * Copyright (c) 2018 by Chelsio Communications, Inc.
  14  */
  15
  16 #include <stdio.h>
  17 #include <stdlib.h>
  18 #include <unistd.h>
  19 #include <stropts.h>
  20 #include <sys/types.h>
  21 #include <sys/stat.h>
  22 #include <fcntl.h>
  23 #include <sys/socket.h>
  24 #include <strings.h>
  25 #include <sys/varargs.h>
  26 #include <errno.h>
  27 #include <sys/byteorder.h>
  28 #include <inttypes.h>
  29 #include <sys/sysmacros.h>
  30
  31 #include "t4nex.h"
  32 #include "version.h"
  33 #include "osdep.h"
  34 #include "t4fw_interface.h"
  35
  36 /*
  37  * Firmware Device Log Dumping
  38  */
  39
  40 static const char * const devlog_level_strings[] = {
  41         [FW_DEVLOG_LEVEL_EMERG]         = "EMERG",
  42         [FW_DEVLOG_LEVEL_CRIT]          = "CRIT",
  43         [FW_DEVLOG_LEVEL_ERR]           = "ERR",
  44         [FW_DEVLOG_LEVEL_NOTICE]        = "NOTICE",
  45         [FW_DEVLOG_LEVEL_INFO]          = "INFO",
  46         [FW_DEVLOG_LEVEL_DEBUG]         = "DEBUG"
  47 };
  48
  49 static const char * const devlog_facility_strings[] = {
  50         [FW_DEVLOG_FACILITY_CORE]       = "CORE",
  51         [FW_DEVLOG_FACILITY_CF]         = "CF",
  52         [FW_DEVLOG_FACILITY_SCHED]      = "SCHED",
  53         [FW_DEVLOG_FACILITY_TIMER]      = "TIMER",
  54         [FW_DEVLOG_FACILITY_RES]        = "RES",
  55         [FW_DEVLOG_FACILITY_HW]         = "HW",
  56         [FW_DEVLOG_FACILITY_FLR]        = "FLR",
  57         [FW_DEVLOG_FACILITY_DMAQ]       = "DMAQ",
  58         [FW_DEVLOG_FACILITY_PHY]        = "PHY",
  59         [FW_DEVLOG_FACILITY_MAC]        = "MAC",
  60         [FW_DEVLOG_FACILITY_PORT]       = "PORT",
  61         [FW_DEVLOG_FACILITY_VI]         = "VI",
  62         [FW_DEVLOG_FACILITY_FILTER]     = "FILTER",
  63         [FW_DEVLOG_FACILITY_ACL]        = "ACL",
  64         [FW_DEVLOG_FACILITY_TM]         = "TM",
  65         [FW_DEVLOG_FACILITY_QFC]        = "QFC",
  66         [FW_DEVLOG_FACILITY_DCB]        = "DCB",
  67         [FW_DEVLOG_FACILITY_ETH]        = "ETH",
  68         [FW_DEVLOG_FACILITY_OFLD]       = "OFLD",
  69         [FW_DEVLOG_FACILITY_RI]         = "RI",
  70         [FW_DEVLOG_FACILITY_ISCSI]      = "ISCSI",
  71         [FW_DEVLOG_FACILITY_FCOE]       = "FCOE",
  72         [FW_DEVLOG_FACILITY_FOISCSI]    = "FOISCSI",
  73         [FW_DEVLOG_FACILITY_FOFCOE]     = "FOFCOE",
  74         [FW_DEVLOG_FACILITY_CHNET]      = "CHNET",
  75 };
  76
  77 static const char *progname;
  78
  79 static void usage(FILE *fp)
  80 {
  81         fprintf(fp, "Usage: %s <path to t4nex#> [operation]\n", progname);
  82         fprintf(fp,
  83             "\tdevlog                              show device log\n"
  84             "\tloadfw <FW image>                   Flash the FW image\n");
  85         exit(fp == stderr ? 1 : 0);
  86 }
  87
  88 static void
  89 err(int code, const char *fmt, ...)
  90 {
  91         va_list ap;
  92         int e = errno;
  93
  94         va_start(ap, fmt);
  95         fprintf(stderr, "error: ");
  96         vfprintf(stderr, fmt, ap);
  97         fprintf(stderr, ": %s\n", strerror(e));
  98         va_end(ap);
  99         exit(code);
 100 }
 101
 102 static int
 103 doit(const char *iff_name, unsigned long cmd, void *data)
 104 {
 105         int fd = 0;
 106         int rc = 0;
 107
 108         if ((fd = open(iff_name, O_RDWR)) < 0)
 109                 return (-1);
 110
 111         rc = (ioctl(fd, cmd, data) < 0) ? errno : rc;
 112         close(fd);
 113         return (rc);
 114 }
 115
 116 static void
 117 get_devlog(int argc, char *argv[], int start_arg, const char *iff_name)
 118 {
 119         struct t4_devlog *devlog;
 120         struct fw_devlog_e *entry, *buf;
 121         int rc = 0, first = 0, nentries, i, j, len;
 122         uint64_t ftstamp = UINT64_MAX;
 123
 124         devlog = malloc(T4_DEVLOG_SIZE + sizeof (struct t4_devlog));
 125         if (!devlog)
 126                 err(1, "%s: can't allocate devlog buffer", __func__);
 127
 128         devlog->len = T4_DEVLOG_SIZE;
 129         /* Get device log */
 130         rc = doit(iff_name, T4_IOCTL_DEVLOG, devlog);
 131         if (rc == ENOBUFS) {
 132                 /*
 133                  * Default buffer size is not sufficient to hold device log.
 134                  * Driver has updated the devlog.len to indicate the expected
 135                  * size. Free the currently allocated devlog.data, allocate
 136                  * again with right size and retry.
 137                  */
 138                 len = devlog->len;
 139                 free(devlog);
 140
 141                 if ((devlog = malloc(len + sizeof (struct t4_devlog))) == NULL)
 142                         err(1, "%s: can't reallocate devlog buffer", __func__);
 143
 144                 rc = doit(iff_name, T4_IOCTL_DEVLOG, devlog);
 145         }
 146         if (rc) {
 147                 free(devlog);
 148                 err(1, "%s: can't get device log", __func__);
 149         }
 150
 151         /* There are nentries number of entries in the buffer */
 152         nentries = (devlog->len / sizeof (struct fw_devlog_e));
 153
 154         buf = (struct fw_devlog_e *)devlog->data;
 155
 156         /* Find the first entry */
 157         for (i = 0; i < nentries; i++) {
 158                 entry = &buf[i];
 159
 160                 if (entry->timestamp == 0)
 161                         break;
 162
 163                 entry->timestamp = BE_64(entry->timestamp);
 164                 entry->seqno = BE_32(entry->seqno);
 165                 for (j = 0; j < 8; j++)
 166                         entry->params[j] = BE_32(entry->params[j]);
 167
 168                 if (entry->timestamp < ftstamp) {
 169                         ftstamp = entry->timestamp;
 170                         first = i;
 171                 }
 172         }
 173
 174         printf("%10s  %15s  %8s  %8s  %s\n", "Seq#", "Tstamp", "Level",
 175             "Facility", "Message");
 176
 177         i = first;
 178
 179         do {
 180                 entry = &buf[i];
 181
 182                 if (entry->timestamp == 0)
 183                         break;
 184
 185                 printf("%10d  %15llu  %8s  %8s  ", entry->seqno,
 186                     entry->timestamp,
 187                     (entry->level < ARRAY_SIZE(devlog_level_strings) ?
 188                     devlog_level_strings[entry->level] : "UNKNOWN"),
 189                     (entry->facility < ARRAY_SIZE(devlog_facility_strings) ?
 190                     devlog_facility_strings[entry->facility] : "UNKNOWN"));
 191
 192                 printf((const char *)entry->fmt, entry->params[0],
 193                     entry->params[1], entry->params[2], entry->params[3],
 194                     entry->params[4], entry->params[5], entry->params[6],
 195                     entry->params[7]);
 196
 197                 if (++i == nentries)
 198                         i = 0;
 199
 200         } while (i != first);
 201
 202         free(devlog);
 203 }
 204
 205 static void
 206 load_fw(int argc, char *argv[], int start_arg, const char *iff_name)
 207 {
 208         const char *fname = argv[start_arg];
 209         struct t4_ldfw *fw;
 210         struct stat sb;
 211         size_t len;
 212         int fd;
 213
 214         if (argc != 4)
 215                 err(1, "incorrect number of arguments.");
 216
 217         fd = open(fname, O_RDONLY);
 218         if (fd < 0)
 219                 err(1, "%s: opening %s failed", __func__, fname);
 220         if (fstat(fd, &sb) < 0) {
 221                 close(fd);
 222                 err(1, "%s: fstat %s failed", __func__, fname);
 223         }
 224         len = (size_t)sb.st_size;
 225
 226         fw = malloc(sizeof (struct t4_ldfw) + len);
 227         if (!fw) {
 228                 close(fd);
 229                 err(1, "%s: %s allocate %ld bytes failed",
 230                     __func__, fname, sizeof (struct t4_ldfw) + len);
 231         }
 232
 233         if (read(fd, fw->data, len) < len) {
 234                 close(fd);
 235                 free(fw);
 236                 err(1, "%s: %s read failed", __func__, fname);
 237         }
 238
 239         close(fd);
 240
 241         fw->len = len;
 242
 243         if (doit(iff_name, T4_IOCTL_LOAD_FW, fw)) {
 244                 free(fw);
 245                 err(1, "%s: IOCTL failed", __func__);
 246         } else {
 247                 printf("FW flash success, reload driver/reboot to take "
 248                     "effect\n");
 249         }
 250
 251         free(fw);
 252 }
 253
 254 static void
 255 run_cmd(int argc, char *argv[], const char *iff_name)
 256 {
 257         if (strcmp(argv[2], "devlog") == 0)
 258                 get_devlog(argc, argv, 3, iff_name);
 259         else if (strcmp(argv[2], "loadfw") == 0)
 260                 load_fw(argc, argv, 3, iff_name);
 261         else
 262                 usage(stderr);
 263 }
 264
 265 int
 266 main(int argc, char *argv[])
 267 {
 268         const char *iff_name;
 269
 270         progname = argv[0];
 271
 272         if (argc == 2) {
 273                 if (strcmp(argv[1], "-h") == 0 ||
 274                     strcmp(argv[1], "--help") == 0) {
 275                         usage(stdout);
 276                 }
 277
 278                 if (strcmp(argv[1], "-v") == 0 ||
 279                     strcmp(argv[1], "--version") == 0) {
 280                         printf("cxgbetool version %s\n", DRV_VERSION);
 281                         exit(0);
 282                 }
 283         }
 284
 285         if (argc < 3)
 286                 usage(stderr);
 287
 288         iff_name = argv[1];
 289
 290         run_cmd(argc, argv, iff_name);
 291
 292         return (0);
 293 }