usr/src/lib/scsi/libses/common/ses_subr.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21
  22 /*
  23  * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
  24  * Use is subject to license terms.
  25  */
  26
  27 #pragma ident   "%Z%%M% %I%     %E% SMI"
  28
  29 #include <scsi/libses.h>
  30 #include "ses_impl.h"
  31
  32 __thread ses_errno_t _ses_errno;
  33 __thread char _ses_errmsg[1024];
  34 __thread char _ses_nverr_member[256];
  35
  36 static void ses_vpanic(const char *, va_list) __NORETURN;
  37
  38 static void
  39 ses_vpanic(const char *fmt, va_list ap)
  40 {
  41         int oserr = errno;
  42         char msg[BUFSIZ];
  43         size_t len;
  44
  45         (void) snprintf(msg, sizeof (msg), "ABORT: ");
  46         len = strlen(msg);
  47         (void) vsnprintf(msg + len, sizeof (msg) - len, fmt, ap);
  48
  49         if (strchr(fmt, '\n') == NULL) {
  50                 len = strlen(msg);
  51                 (void) snprintf(msg + len, sizeof (msg) - len, ": %s\n",
  52                     strerror(oserr));
  53         }
  54
  55         (void) write(STDERR_FILENO, msg, strlen(msg));
  56
  57 abort:
  58         abort();
  59         _exit(1);
  60 }
  61
  62 /*PRINTFLIKE1*/
  63 void
  64 ses_panic(const char *fmt, ...)
  65 {
  66         va_list ap;
  67
  68         va_start(ap, fmt);
  69         ses_vpanic(fmt, ap);
  70         va_end(ap);
  71 }
  72
  73 int
  74 ses_assert(const char *expr, const char *file, int line)
  75 {
  76         ses_panic("\"%s\", line %d: assertion failed: %s\n", file, line, expr);
  77
  78         /*NOTREACHED*/
  79         return (0);
  80 }
  81
  82 int
  83 nvlist_add_fixed_string(nvlist_t *nvl, const char *name,
  84     const char *buf, size_t len)
  85 {
  86         char *str = alloca(len + 1);
  87         bcopy(buf, str, len);
  88         str[len] = '\0';
  89
  90         return (nvlist_add_string(nvl, name, str));
  91 }
  92
  93 /*
  94  * Like fixed_string, but clears any leading or trailing spaces.
  95  */
  96 int
  97 nvlist_add_fixed_string_trunc(nvlist_t *nvl, const char *name,
  98     const char *buf, size_t len)
  99 {
 100         while (buf[0] == ' ' && len > 0) {
 101                 buf++;
 102                 len--;
 103         }
 104
 105         while (len > 0 && buf[len - 1] == ' ')
 106                 len--;
 107
 108         return (nvlist_add_fixed_string(nvl, name, buf, len));
 109 }
 110
 111 ses_errno_t
 112 ses_errno(void)
 113 {
 114         return (_ses_errno);
 115 }
 116
 117 const char *
 118 ses_errmsg(void)
 119 {
 120         if (_ses_errmsg[0] == '\0')
 121                 (void) snprintf(_ses_errmsg, sizeof (_ses_errmsg), "%s",
 122                     ses_strerror(_ses_errno));
 123
 124         return (_ses_errmsg);
 125 }
 126
 127 const char *
 128 ses_nv_error_member(void)
 129 {
 130         if (_ses_nverr_member[0] != '\0')
 131                 return (_ses_nverr_member);
 132         else
 133                 return (NULL);
 134 }
 135
 136 static int
 137 __ses_set_errno(ses_errno_t err, const char *nvm)
 138 {
 139         if (nvm == NULL) {
 140                 _ses_nverr_member[0] = '\0';
 141         } else {
 142                 (void) strlcpy(_ses_nverr_member, nvm,
 143                     sizeof (_ses_nverr_member));
 144         }
 145         _ses_errmsg[0] = '\0';
 146         _ses_errno = err;
 147
 148         return (-1);
 149 }
 150
 151 int
 152 ses_set_errno(ses_errno_t err)
 153 {
 154         return (__ses_set_errno(err, NULL));
 155 }
 156
 157 int
 158 ses_set_nverrno(int err, const char *member)
 159 {
 160         ses_errno_t se = (err == ENOMEM || err == EAGAIN) ?
 161             ESES_NOMEM : ESES_NVL;
 162
 163         /*
 164          * If the error is ESES_NVL, then we should always have a member
 165          * available.  The only time 'member' is NULL is when nvlist_alloc()
 166          * fails, which should only be possible if memory allocation fails.
 167          */
 168         assert(se == ESES_NOMEM || member != NULL);
 169
 170         return (__ses_set_errno(se, member));
 171 }
 172
 173 static int
 174 ses_verror(ses_errno_t err, const char *fmt, va_list ap)
 175 {
 176         int syserr = errno;
 177         size_t n;
 178         char *errmsg;
 179
 180         errmsg = alloca(sizeof (_ses_errmsg));
 181         (void) vsnprintf(errmsg, sizeof (_ses_errmsg), fmt, ap);
 182         (void) ses_set_errno(err);
 183
 184         n = strlen(errmsg);
 185
 186         while (n != 0 && errmsg[n - 1] == '\n')
 187                 errmsg[--n] = '\0';
 188
 189         bcopy(errmsg, _ses_errmsg, sizeof (_ses_errmsg));
 190         errno = syserr;
 191
 192         return (-1);
 193 }
 194
 195 static int
 196 ses_vnverror(int err, const char *member, const char *fmt,
 197     va_list ap)
 198 {
 199         int syserr = errno;
 200         size_t n;
 201         char *errmsg;
 202
 203         errmsg = alloca(sizeof (_ses_errmsg));
 204         (void) vsnprintf(errmsg, sizeof (_ses_errmsg), fmt, ap);
 205         (void) ses_set_nverrno(err, member);
 206
 207         n = strlen(errmsg);
 208
 209         while (n != 0 && errmsg[n - 1] == '\n')
 210                 errmsg[--n] = '\0';
 211
 212         (void) snprintf(errmsg + n, sizeof (_ses_errmsg) - n, ": %s",
 213             strerror(err));
 214
 215         bcopy(errmsg, _ses_errmsg, sizeof (_ses_errmsg));
 216         errno = syserr;
 217
 218         return (-1);
 219 }
 220
 221 int
 222 ses_error(ses_errno_t err, const char *fmt, ...)
 223 {
 224         va_list ap;
 225         int rv;
 226
 227         va_start(ap, fmt);
 228         rv = ses_verror(err, fmt, ap);
 229         va_end(ap);
 230
 231         return (rv);
 232 }
 233
 234 int
 235 ses_nverror(int err, const char *member, const char *fmt, ...)
 236 {
 237         va_list ap;
 238         int rv;
 239
 240         va_start(ap, fmt);
 241         rv = ses_vnverror(err, member, fmt, ap);
 242         va_end(ap);
 243
 244         return (rv);
 245 }
 246
 247 int
 248 ses_libscsi_error(libscsi_hdl_t *shp, const char *fmt, ...)
 249 {
 250         va_list ap;
 251         char errmsg[LIBSES_ERRMSGLEN];
 252         libscsi_errno_t se = libscsi_errno(shp);
 253         ses_errno_t e;
 254
 255         switch (se) {
 256         case ESCSI_NONE:
 257                 return (0);
 258         case ESCSI_NOMEM:
 259                 e = ESES_NOMEM;
 260                 break;
 261         case ESCSI_NOTSUP:
 262                 e = ESES_NOTSUP;
 263                 break;
 264         case ESCSI_ZERO_LENGTH:
 265         case ESCSI_VERSION:
 266         case ESCSI_BADFLAGS:
 267         case ESCSI_BOGUSFLAGS:
 268         case ESCSI_BADLENGTH:
 269         case ESCSI_NEEDBUF:
 270                 va_start(ap, fmt);
 271                 (void) vsnprintf(errmsg, sizeof (errmsg), fmt, ap);
 272                 va_end(ap);
 273                 ses_panic("%s: unexpected libscsi error %s: %s", errmsg,
 274                     libscsi_errname(se), libscsi_errmsg(shp));
 275                 break;
 276         case ESCSI_UNKNOWN:
 277                 e = ESES_UNKNOWN;
 278                 break;
 279         default:
 280                 e = ESES_LIBSCSI;
 281                 break;
 282         }
 283
 284         va_start(ap, fmt);
 285         (void) vsnprintf(errmsg, sizeof (errmsg), fmt, ap);
 286         va_end(ap);
 287
 288         return (ses_error(e, "%s: %s", errmsg, libscsi_errmsg(shp)));
 289 }
 290
 291 int
 292 ses_scsi_error(libscsi_action_t *ap, const char *fmt, ...)
 293 {
 294         va_list args;
 295         char errmsg[LIBSES_ERRMSGLEN];
 296         uint64_t asc = 0, ascq = 0, key = 0;
 297         const char *code, *keystr;
 298
 299         va_start(args, fmt);
 300         (void) vsnprintf(errmsg, sizeof (errmsg), fmt, args);
 301         va_end(args);
 302
 303         if (libscsi_action_parse_sense(ap, &key, &asc, &ascq, NULL) != 0)
 304                 return (ses_error(ESES_LIBSCSI,
 305                     "%s: SCSI status %d (no sense data available)", errmsg,
 306                     libscsi_action_get_status(ap)));
 307
 308         code = libscsi_sense_code_name(asc, ascq);
 309         keystr = libscsi_sense_key_name(key);
 310
 311         return (ses_error(ESES_LIBSCSI, "%s: SCSI status %d sense key %llu "
 312             "(%s) additional sense code 0x%llx/0x%llx (%s)", errmsg,
 313             libscsi_action_get_status(ap), key, keystr ? keystr : "<unknown>",
 314             asc, ascq, code ? code : "<unknown>"));
 315 }
 316
 317 void *
 318 ses_alloc(size_t sz)
 319 {
 320         void *p;
 321
 322         if (sz == 0)
 323                 ses_panic("attempted zero-length allocation");
 324
 325         if ((p = malloc(sz)) == NULL)
 326                 (void) ses_set_errno(ESES_NOMEM);
 327
 328         return (p);
 329 }
 330
 331 void *
 332 ses_zalloc(size_t sz)
 333 {
 334         void *p;
 335
 336         if ((p = ses_alloc(sz)) != NULL)
 337                 bzero(p, sz);
 338
 339         return (p);
 340 }
 341
 342 char *
 343 ses_strdup(const char *s)
 344 {
 345         char *p;
 346         size_t len;
 347
 348         if (s == NULL)
 349                 ses_panic("attempted zero-length allocation");
 350
 351         len = strlen(s) + 1;
 352
 353         if ((p = ses_alloc(len)) != NULL)
 354                 bcopy(s, p, len);
 355
 356         return (p);
 357 }
 358
 359 void *
 360 ses_realloc(void *p, size_t sz)
 361 {
 362         if (sz == 0)
 363                 ses_panic("attempted zero-length allocation");
 364
 365         if ((p = realloc(p, sz)) == NULL)
 366                 (void) ses_set_errno(ESES_NOMEM);
 367
 368         return (p);
 369 }
 370
 371 /*ARGSUSED*/
 372 void
 373 ses_free(void *p)
 374 {
 375         free(p);
 376 }