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 (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved. 24 */ 25 26 #include <sys/types.h> 27 #include <sys/scsi/generic/commands.h> 28 #include <sys/scsi/impl/spc3_types.h> 29 30 #include <stddef.h> 31 #include <stdlib.h> 32 #include <string.h> 33 #include <strings.h> 34 #include <alloca.h> 35 #include <stdio.h> 36 #include <unistd.h> 37 #include <dlfcn.h> 38 39 #include <scsi/libscsi.h> 40 #include "libscsi_impl.h" 41 42 int 43 libscsi_assert(const char *expr, const char *file, int line) 44 { 45 char *msg; 46 size_t len; 47 48 len = snprintf(NULL, 0, 49 "ABORT: \"%s\", line %d: assertion failed: %s\n", file, line, expr); 50 51 msg = alloca(len + 1); 52 53 (void) snprintf(msg, len + 1, 54 "ABORT: \"%s\", line %d: assertion failed: %s\n", file, line, expr); 55 56 (void) write(STDERR_FILENO, msg, strlen(msg)); 57 58 abort(); 59 _exit(1); 60 61 /*NOTREACHED*/ 62 return (0); 63 } 64 65 int 66 libscsi_set_errno(libscsi_hdl_t *hp, libscsi_errno_t err) 67 { 68 hp->lsh_errno = err; 69 hp->lsh_errmsg[0] = '\0'; 70 71 return (-1); 72 } 73 74 /* 75 * Internal routine for setting both _ue_errno and _ue_errmsg. We save 76 * and restore the UNIX errno across this routing so the caller can use either 77 * libscsi_set_errno(), libscsi_error(), or libscsi_verror() without this value 78 * changing. 79 */ 80 int 81 libscsi_verror(libscsi_hdl_t *hp, libscsi_errno_t err, const char *fmt, 82 va_list ap) 83 { 84 size_t n; 85 char *errmsg; 86 87 /* 88 * To allow the existing error message to itself be used in an error 89 * message, we put the new error message into a buffer on the stack, 90 * and then copy it into lsh_errmsg. We also need to set the errno, 91 * but because the call to libscsi_set_errno() is destructive to 92 * lsh_errmsg, we do this after we print into our temporary buffer 93 * (in case _libscsi_errmsg is part of the error message) and before we 94 * copy the temporary buffer on to _libscsi_errmsg (to prevent our new 95 * message from being nuked by the call to libscsi_set_errno()). 96 */ 97 errmsg = alloca(sizeof (hp->lsh_errmsg)); 98 (void) vsnprintf(errmsg, sizeof (hp->lsh_errmsg), fmt, ap); 99 (void) libscsi_set_errno(hp, err); 100 101 n = strlen(errmsg); 102 103 if (n != 0 && errmsg[n - 1] == '\n') 104 errmsg[n - 1] = '\0'; 105 106 bcopy(errmsg, hp->lsh_errmsg, n + 1); 107 108 return (-1); 109 } 110 111 /*PRINTFLIKE3*/ 112 int 113 libscsi_error(libscsi_hdl_t *hp, libscsi_errno_t err, const char *fmt, ...) 114 { 115 va_list ap; 116 117 if (fmt == NULL) 118 return (libscsi_set_errno(hp, err)); 119 120 va_start(ap, fmt); 121 err = libscsi_verror(hp, err, fmt, ap); 122 va_end(ap); 123 124 return (err); 125 } 126 127 libscsi_errno_t 128 libscsi_errno(libscsi_hdl_t *hp) 129 { 130 return (hp->lsh_errno); 131 } 132 133 const char * 134 libscsi_errmsg(libscsi_hdl_t *hp) 135 { 136 if (hp->lsh_errmsg[0] == '\0') 137 (void) strlcpy(hp->lsh_errmsg, libscsi_strerror(hp->lsh_errno), 138 sizeof (hp->lsh_errmsg)); 139 140 return (hp->lsh_errmsg); 141 } 142 143 void * 144 libscsi_alloc(libscsi_hdl_t *hp, size_t size) 145 { 146 void *mem; 147 148 if (size == 0) { 149 (void) libscsi_set_errno(hp, ESCSI_ZERO_LENGTH); 150 return (NULL); 151 } 152 153 if ((mem = malloc(size)) == NULL) 154 (void) libscsi_set_errno(hp, ESCSI_NOMEM); 155 156 return (mem); 157 } 158 159 void * 160 libscsi_zalloc(libscsi_hdl_t *hp, size_t size) 161 { 162 void *mem; 163 164 if ((mem = libscsi_alloc(hp, size)) == NULL) 165 return (NULL); 166 167 bzero(mem, size); 168 169 return (mem); 170 } 171 172 char * 173 libscsi_strdup(libscsi_hdl_t *hp, const char *str) 174 { 175 size_t len = strlen(str); 176 char *dup = libscsi_alloc(hp, len + 1); 177 178 if (dup == NULL) 179 return (NULL); 180 181 return (strcpy(dup, str)); 182 } 183 184 /*ARGSUSED*/ 185 void 186 libscsi_free(libscsi_hdl_t *hp, void *ptr) 187 { 188 free(ptr); 189 } 190 191 libscsi_hdl_t * 192 libscsi_init(uint_t version, libscsi_errno_t *errp) 193 { 194 libscsi_hdl_t *hp; 195 196 if ((hp = malloc(sizeof (libscsi_hdl_t))) == NULL) { 197 if (errp != NULL) 198 *errp = ESCSI_NOMEM; 199 return (NULL); 200 } 201 202 bzero(hp, sizeof (libscsi_hdl_t)); 203 hp->lsh_version = version; 204 205 return (hp); 206 } 207 208 void 209 libscsi_fini(libscsi_hdl_t *hp) 210 { 211 libscsi_engine_impl_t *eip, *neip; 212 213 if (hp == NULL) 214 return; 215 216 ASSERT(hp->lsh_targets == 0); 217 218 for (eip = hp->lsh_engines; eip != NULL; eip = neip) { 219 neip = eip->lsei_next; 220 (void) dlclose(eip->lsei_dl_hdl); 221 libscsi_free(hp, eip); 222 } 223 224 free(hp); 225 } 226 227 size_t 228 libscsi_cmd_cdblen(libscsi_hdl_t *hp, uint8_t cmd) 229 { 230 size_t sz; 231 232 switch (CDB_GROUPID(cmd)) { 233 case CDB_GROUPID_0: 234 sz = CDB_GROUP0; 235 break; 236 case CDB_GROUPID_1: 237 sz = CDB_GROUP1; 238 break; 239 case CDB_GROUPID_2: 240 sz = CDB_GROUP2; 241 break; 242 case CDB_GROUPID_3: 243 sz = CDB_GROUP3; 244 break; 245 case CDB_GROUPID_4: 246 sz = CDB_GROUP4; 247 break; 248 case CDB_GROUPID_5: 249 sz = CDB_GROUP5; 250 break; 251 case CDB_GROUPID_6: 252 sz = CDB_GROUP6; 253 break; 254 case CDB_GROUPID_7: 255 sz = CDB_GROUP7; 256 break; 257 default: 258 sz = 0; 259 } 260 261 if (sz == 0) 262 (void) libscsi_error(hp, ESCSI_BADCMD, 263 "unknown or unsupported command %u", cmd); 264 265 return (sz); 266 } 267 268 static char * 269 libscsi_process_inquiry_string(libscsi_hdl_t *hp, const char *raw, size_t len) 270 { 271 char *buf; 272 273 buf = alloca(len + 1); 274 bcopy(raw, buf, len); 275 276 for (; len > 0; len--) { 277 if (buf[len - 1] != ' ') 278 break; 279 } 280 281 buf[len] = '\0'; 282 283 return (libscsi_strdup(hp, buf)); 284 } 285 286 /* 287 * As part of basic initialization, we always retrieve the INQUIRY information 288 * to have the vendor/product/revision information available for all consumers. 289 */ 290 int 291 libscsi_get_inquiry(libscsi_hdl_t *hp, libscsi_target_t *tp) 292 { 293 libscsi_action_t *ap; 294 spc3_inquiry_cdb_t *cp; 295 spc3_inquiry_data_t data; 296 size_t len; 297 298 if ((ap = libscsi_action_alloc(hp, SPC3_CMD_INQUIRY, 299 LIBSCSI_AF_READ | LIBSCSI_AF_SILENT | LIBSCSI_AF_DIAGNOSE, &data, 300 offsetof(spc3_inquiry_data_t, id_vs_36[0]))) == NULL) 301 return (-1); 302 303 cp = (spc3_inquiry_cdb_t *)libscsi_action_get_cdb(ap); 304 305 SCSI_WRITE16(&cp->ic_allocation_length, 306 offsetof(spc3_inquiry_data_t, id_vs_36[0])); 307 308 if (libscsi_exec(ap, tp) != 0 || 309 libscsi_action_get_status(ap) != 0) { 310 libscsi_action_free(ap); 311 return (libscsi_set_errno(hp, ESCSI_INQUIRY_FAILED)); 312 } 313 314 (void) libscsi_action_get_buffer(ap, NULL, NULL, &len); 315 libscsi_action_free(ap); 316 317 if (len < offsetof(spc3_inquiry_data_t, id_vs_36)) 318 return (libscsi_set_errno(hp, ESCSI_INQUIRY_FAILED)); 319 320 if ((tp->lst_vendor = libscsi_process_inquiry_string(hp, 321 data.id_vendor_id, sizeof (data.id_vendor_id))) == NULL || 322 (tp->lst_product = libscsi_process_inquiry_string(hp, 323 data.id_product_id, sizeof (data.id_product_id))) == NULL || 324 (tp->lst_revision = libscsi_process_inquiry_string(hp, 325 data.id_product_revision, 326 sizeof (data.id_product_revision))) == NULL) { 327 return (-1); 328 } 329 330 return (0); 331 } 332 333 const char * 334 libscsi_vendor(libscsi_target_t *tp) 335 { 336 return (tp->lst_vendor); 337 } 338 339 const char * 340 libscsi_product(libscsi_target_t *tp) 341 { 342 return (tp->lst_product); 343 } 344 345 const char * 346 libscsi_revision(libscsi_target_t *tp) 347 { 348 return (tp->lst_revision); 349 } 350