sys/cam/ctl/ctl_error.c

   1 /*-
   2  * Copyright (c) 2003-2009 Silicon Graphics International Corp.
   3  * Copyright (c) 2011 Spectra Logic Corporation
   4  * Copyright (c) 2014-2015 Alexander Motin <mav@FreeBSD.org>
   5  * All rights reserved.
   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  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions, and the following disclaimer,
  12  *    without modification.
  13  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
  14  *    substantially similar to the "NO WARRANTY" disclaimer below
  15  *    ("Disclaimer") and any redistribution must be conditioned upon
  16  *    including a substantially similar Disclaimer requirement for further
  17  *    binary redistribution.
  18  *
  19  * NO WARRANTY
  20  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  21  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  22  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
  23  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  24  * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  25  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  26  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  27  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  28  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
  29  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  30  * POSSIBILITY OF SUCH DAMAGES.
  31  *
  32  * $Id: //depot/users/kenm/FreeBSD-test2/sys/cam/ctl/ctl_error.c#2 $
  33  */
  34 /*
  35  * CAM Target Layer error reporting routines.
  36  *
  37  * Author: Ken Merry <ken@FreeBSD.org>
  38  */
  39
  40 #include <sys/cdefs.h>
  41 __FBSDID("$FreeBSD$");
  42
  43 #include <sys/param.h>
  44 #include <sys/systm.h>
  45 #include <sys/kernel.h>
  46 #include <sys/types.h>
  47 #include <sys/malloc.h>
  48 #include <sys/lock.h>
  49 #include <sys/mutex.h>
  50 #include <sys/condvar.h>
  51 #include <sys/stddef.h>
  52 #include <sys/ctype.h>
  53 #include <sys/sysctl.h>
  54 #include <machine/stdarg.h>
  55
  56 #include <cam/scsi/scsi_all.h>
  57 #include <cam/scsi/scsi_da.h>
  58 #include <cam/ctl/ctl_io.h>
  59 #include <cam/ctl/ctl.h>
  60 #include <cam/ctl/ctl_frontend.h>
  61 #include <cam/ctl/ctl_backend.h>
  62 #include <cam/ctl/ctl_ioctl.h>
  63 #include <cam/ctl/ctl_error.h>
  64 #include <cam/ctl/ctl_ha.h>
  65 #include <cam/ctl/ctl_private.h>
  66
  67 void
  68 ctl_set_sense_data_va(struct scsi_sense_data *sense_data, u_int *sense_len,
  69     void *lunptr, scsi_sense_data_type sense_format, int current_error,
  70     int sense_key, int asc, int ascq, va_list ap)
  71 {
  72         struct ctl_lun *lun;
  73
  74         lun = (struct ctl_lun *)lunptr;
  75
  76         /*
  77          * Determine whether to return fixed or descriptor format sense
  78          * data.
  79          */
  80         if (sense_format == SSD_TYPE_NONE) {
  81                 /*
  82                  * If the format isn't specified, we only return descriptor
  83                  * sense if the LUN exists and descriptor sense is turned
  84                  * on for that LUN.
  85                  */
  86                 if ((lun != NULL) && (lun->MODE_CTRL.rlec & SCP_DSENSE))
  87                         sense_format = SSD_TYPE_DESC;
  88                 else
  89                         sense_format = SSD_TYPE_FIXED;
  90         }
  91
  92         /*
  93          * Determine maximum sense data length to return.
  94          */
  95         if (*sense_len == 0) {
  96                 if ((lun != NULL) && (lun->MODE_CTRLE.max_sense != 0))
  97                         *sense_len = lun->MODE_CTRLE.max_sense;
  98                 else
  99                         *sense_len = SSD_FULL_SIZE;
 100         }
 101
 102         scsi_set_sense_data_va(sense_data, sense_len, sense_format,
 103             current_error, sense_key, asc, ascq, ap);
 104 }
 105
 106 void
 107 ctl_set_sense_data(struct scsi_sense_data *sense_data, u_int *sense_len,
 108     void *lunptr, scsi_sense_data_type sense_format, int current_error,
 109     int sense_key, int asc, int ascq, ...)
 110 {
 111         va_list ap;
 112
 113         va_start(ap, ascq);
 114         ctl_set_sense_data_va(sense_data, sense_len, lunptr, sense_format,
 115             current_error, sense_key, asc, ascq, ap);
 116         va_end(ap);
 117 }
 118
 119 void
 120 ctl_set_sense(struct ctl_scsiio *ctsio, int current_error, int sense_key,
 121               int asc, int ascq, ...)
 122 {
 123         va_list ap;
 124         struct ctl_lun *lun;
 125         u_int sense_len;
 126
 127         /*
 128          * The LUN can't go away until all of the commands have been
 129          * completed.  Therefore we can safely access the LUN structure and
 130          * flags without the lock.
 131          */
 132         lun = CTL_LUN(ctsio);
 133
 134         va_start(ap, ascq);
 135         sense_len = 0;
 136         ctl_set_sense_data_va(&ctsio->sense_data, &sense_len,
 137                               lun,
 138                               SSD_TYPE_NONE,
 139                               current_error,
 140                               sense_key,
 141                               asc,
 142                               ascq,
 143                               ap);
 144         va_end(ap);
 145
 146         ctsio->scsi_status = SCSI_STATUS_CHECK_COND;
 147         ctsio->sense_len = sense_len;
 148         ctsio->io_hdr.status = CTL_SCSI_ERROR | CTL_AUTOSENSE;
 149 }
 150
 151 /*
 152  * Transform fixed sense data into descriptor sense data.
 153  *
 154  * For simplicity's sake, we assume that both sense structures are
 155  * SSD_FULL_SIZE.  Otherwise, the logic gets more complicated.
 156  */
 157 void
 158 ctl_sense_to_desc(struct scsi_sense_data_fixed *sense_src,
 159                   struct scsi_sense_data_desc *sense_dest)
 160 {
 161         struct scsi_sense_stream stream_sense;
 162         int current_error;
 163         u_int sense_len;
 164         uint8_t stream_bits;
 165
 166         bzero(sense_dest, sizeof(*sense_dest));
 167
 168         if ((sense_src->error_code & SSD_ERRCODE) == SSD_DEFERRED_ERROR)
 169                 current_error = 0;
 170         else
 171                 current_error = 1;
 172
 173         bzero(&stream_sense, sizeof(stream_sense));
 174
 175         /*
 176          * Check to see whether any of the tape-specific bits are set.  If
 177          * so, we'll need a stream sense descriptor.
 178          */
 179         if (sense_src->flags & (SSD_ILI|SSD_EOM|SSD_FILEMARK))
 180                 stream_bits = sense_src->flags & ~SSD_KEY;
 181         else
 182                 stream_bits = 0;
 183
 184         /*
 185          * Utilize our sense setting routine to do the transform.  If a
 186          * value is set in the fixed sense data, set it in the descriptor
 187          * data.  Otherwise, skip it.
 188          */
 189         sense_len = SSD_FULL_SIZE;
 190         ctl_set_sense_data((struct scsi_sense_data *)sense_dest, &sense_len,
 191                            /*lun*/ NULL,
 192                            /*sense_format*/ SSD_TYPE_DESC,
 193                            current_error,
 194                            /*sense_key*/ sense_src->flags & SSD_KEY,
 195                            /*asc*/ sense_src->add_sense_code,
 196                            /*ascq*/ sense_src->add_sense_code_qual,
 197
 198                            /* Information Bytes */
 199                            (sense_src->error_code & SSD_ERRCODE_VALID) ?
 200                            SSD_ELEM_INFO : SSD_ELEM_SKIP,
 201                            sizeof(sense_src->info),
 202                            sense_src->info,
 203
 204                            /* Command specific bytes */
 205                            (scsi_4btoul(sense_src->cmd_spec_info) != 0) ?
 206                            SSD_ELEM_COMMAND : SSD_ELEM_SKIP,
 207                            sizeof(sense_src->cmd_spec_info),
 208                            sense_src->cmd_spec_info,
 209
 210                            /* FRU */
 211                            (sense_src->fru != 0) ?
 212                            SSD_ELEM_FRU : SSD_ELEM_SKIP,
 213                            sizeof(sense_src->fru),
 214                            &sense_src->fru,
 215
 216                            /* Sense Key Specific */
 217                            (sense_src->sense_key_spec[0] & SSD_SCS_VALID) ?
 218                            SSD_ELEM_SKS : SSD_ELEM_SKIP,
 219                            sizeof(sense_src->sense_key_spec),
 220                            sense_src->sense_key_spec,
 221
 222                            /* Tape bits */
 223                            (stream_bits != 0) ?
 224                            SSD_ELEM_STREAM : SSD_ELEM_SKIP,
 225                            sizeof(stream_bits),
 226                            &stream_bits,
 227
 228                            SSD_ELEM_NONE);
 229 }
 230
 231 /*
 232  * Transform descriptor format sense data into fixed sense data.
 233  *
 234  * Some data may be lost in translation, because there are descriptors
 235  * thant can't be represented as fixed sense data.
 236  *
 237  * For simplicity's sake, we assume that both sense structures are
 238  * SSD_FULL_SIZE.  Otherwise, the logic gets more complicated.
 239  */
 240 void
 241 ctl_sense_to_fixed(struct scsi_sense_data_desc *sense_src,
 242                    struct scsi_sense_data_fixed *sense_dest)
 243 {
 244         int current_error;
 245         uint8_t *info_ptr = NULL, *cmd_ptr = NULL, *fru_ptr = NULL;
 246         uint8_t *sks_ptr = NULL, *stream_ptr = NULL;
 247         int info_size = 0, cmd_size = 0, fru_size = 0;
 248         int sks_size = 0, stream_size = 0;
 249         int pos;
 250         u_int sense_len;
 251
 252         if ((sense_src->error_code & SSD_ERRCODE) == SSD_DESC_CURRENT_ERROR)
 253                 current_error = 1;
 254         else
 255                 current_error = 0;
 256
 257         for (pos = 0; pos < (int)(sense_src->extra_len - 1);) {
 258                 struct scsi_sense_desc_header *header;
 259
 260                 header = (struct scsi_sense_desc_header *)
 261                     &sense_src->sense_desc[pos];
 262
 263                 /*
 264                  * See if this record goes past the end of the sense data.
 265                  * It shouldn't, but check just in case.
 266                  */
 267                 if ((pos + header->length + sizeof(*header)) >
 268                      sense_src->extra_len)
 269                         break;
 270
 271                 switch (sense_src->sense_desc[pos]) {
 272                 case SSD_DESC_INFO: {
 273                         struct scsi_sense_info *info;
 274
 275                         info = (struct scsi_sense_info *)header;
 276
 277                         info_ptr = info->info;
 278                         info_size = sizeof(info->info);
 279
 280                         pos += info->length +
 281                             sizeof(struct scsi_sense_desc_header);
 282                         break;
 283                 }
 284                 case SSD_DESC_COMMAND: {
 285                         struct scsi_sense_command *cmd;
 286
 287                         cmd = (struct scsi_sense_command *)header;
 288                         cmd_ptr = cmd->command_info;
 289                         cmd_size = sizeof(cmd->command_info);
 290
 291                         pos += cmd->length +
 292                             sizeof(struct scsi_sense_desc_header);
 293                         break;
 294                 }
 295                 case SSD_DESC_FRU: {
 296                         struct scsi_sense_fru *fru;
 297
 298                         fru = (struct scsi_sense_fru *)header;
 299                         fru_ptr = &fru->fru;
 300                         fru_size = sizeof(fru->fru);
 301                         pos += fru->length +
 302                             sizeof(struct scsi_sense_desc_header);
 303                         break;
 304                 }
 305                 case SSD_DESC_SKS: {
 306                         struct scsi_sense_sks *sks;
 307
 308                         sks = (struct scsi_sense_sks *)header;
 309                         sks_ptr = sks->sense_key_spec;
 310                         sks_size = sizeof(sks->sense_key_spec);
 311
 312                         pos = sks->length +
 313                             sizeof(struct scsi_sense_desc_header);
 314                         break;
 315                 }
 316                 case SSD_DESC_STREAM: {
 317                         struct scsi_sense_stream *stream_sense;
 318
 319                         stream_sense = (struct scsi_sense_stream *)header;
 320                         stream_ptr = &stream_sense->byte3;
 321                         stream_size = sizeof(stream_sense->byte3);
 322                         pos = stream_sense->length +
 323                             sizeof(struct scsi_sense_desc_header);
 324                         break;
 325                 }
 326                 default:
 327                         /*
 328                          * We don't recognize this particular sense
 329                          * descriptor type, so just skip it.
 330                          */
 331                         pos += sizeof(*header) + header->length;
 332                         break;
 333                 }
 334         }
 335
 336         sense_len = SSD_FULL_SIZE;
 337         ctl_set_sense_data((struct scsi_sense_data *)sense_dest, &sense_len,
 338                            /*lun*/ NULL,
 339                            /*sense_format*/ SSD_TYPE_FIXED,
 340                            current_error,
 341                            /*sense_key*/ sense_src->sense_key & SSD_KEY,
 342                            /*asc*/ sense_src->add_sense_code,
 343                            /*ascq*/ sense_src->add_sense_code_qual,
 344
 345                            /* Information Bytes */
 346                            (info_ptr != NULL) ? SSD_ELEM_INFO : SSD_ELEM_SKIP,
 347                            info_size,
 348                            info_ptr,
 349
 350                            /* Command specific bytes */
 351                            (cmd_ptr != NULL) ? SSD_ELEM_COMMAND : SSD_ELEM_SKIP,
 352                            cmd_size,
 353                            cmd_ptr,
 354
 355                            /* FRU */
 356                            (fru_ptr != NULL) ? SSD_ELEM_FRU : SSD_ELEM_SKIP,
 357                            fru_size,
 358                            fru_ptr,
 359
 360                            /* Sense Key Specific */
 361                            (sks_ptr != NULL) ? SSD_ELEM_SKS : SSD_ELEM_SKIP,
 362                            sks_size,
 363                            sks_ptr,
 364
 365                            /* Tape bits */
 366                            (stream_ptr != NULL) ? SSD_ELEM_STREAM : SSD_ELEM_SKIP,
 367                            stream_size,
 368                            stream_ptr,
 369
 370                            SSD_ELEM_NONE);
 371 }
 372
 373 void
 374 ctl_set_ua(struct ctl_scsiio *ctsio, int asc, int ascq)
 375 {
 376         ctl_set_sense(ctsio,
 377                       /*current_error*/ 1,
 378                       /*sense_key*/ SSD_KEY_UNIT_ATTENTION,
 379                       asc,
 380                       ascq,
 381                       SSD_ELEM_NONE);
 382 }
 383
 384 static void
 385 ctl_ua_to_ascq(struct ctl_lun *lun, ctl_ua_type ua_to_build, int *asc,
 386     int *ascq, ctl_ua_type *ua_to_clear, uint8_t **info)
 387 {
 388
 389         switch (ua_to_build) {
 390         case CTL_UA_POWERON:
 391                 /* 29h/01h  POWER ON OCCURRED */
 392                 *asc = 0x29;
 393                 *ascq = 0x01;
 394                 *ua_to_clear = ~0;
 395                 break;
 396         case CTL_UA_BUS_RESET:
 397                 /* 29h/02h  SCSI BUS RESET OCCURRED */
 398                 *asc = 0x29;
 399                 *ascq = 0x02;
 400                 *ua_to_clear = ~0;
 401                 break;
 402         case CTL_UA_TARG_RESET:
 403                 /* 29h/03h  BUS DEVICE RESET FUNCTION OCCURRED*/
 404                 *asc = 0x29;
 405                 *ascq = 0x03;
 406                 *ua_to_clear = ~0;
 407                 break;
 408         case CTL_UA_I_T_NEXUS_LOSS:
 409                 /* 29h/07h  I_T NEXUS LOSS OCCURRED */
 410                 *asc = 0x29;
 411                 *ascq = 0x07;
 412                 *ua_to_clear = ~0;
 413                 break;
 414         case CTL_UA_LUN_RESET:
 415                 /* 29h/00h  POWER ON, RESET, OR BUS DEVICE RESET OCCURRED */
 416                 /*
 417                  * Since we don't have a specific ASC/ASCQ pair for a LUN
 418                  * reset, just return the generic reset code.
 419                  */
 420                 *asc = 0x29;
 421                 *ascq = 0x00;
 422                 break;
 423         case CTL_UA_LUN_CHANGE:
 424                 /* 3Fh/0Eh  REPORTED LUNS DATA HAS CHANGED */
 425                 *asc = 0x3F;
 426                 *ascq = 0x0E;
 427                 break;
 428         case CTL_UA_MODE_CHANGE:
 429                 /* 2Ah/01h  MODE PARAMETERS CHANGED */
 430                 *asc = 0x2A;
 431                 *ascq = 0x01;
 432                 break;
 433         case CTL_UA_LOG_CHANGE:
 434                 /* 2Ah/02h  LOG PARAMETERS CHANGED */
 435                 *asc = 0x2A;
 436                 *ascq = 0x02;
 437                 break;
 438         case CTL_UA_INQ_CHANGE:
 439                 /* 3Fh/03h  INQUIRY DATA HAS CHANGED */
 440                 *asc = 0x3F;
 441                 *ascq = 0x03;
 442                 break;
 443         case CTL_UA_RES_PREEMPT:
 444                 /* 2Ah/03h  RESERVATIONS PREEMPTED */
 445                 *asc = 0x2A;
 446                 *ascq = 0x03;
 447                 break;
 448         case CTL_UA_RES_RELEASE:
 449                 /* 2Ah/04h  RESERVATIONS RELEASED */
 450                 *asc = 0x2A;
 451                 *ascq = 0x04;
 452                 break;
 453         case CTL_UA_REG_PREEMPT:
 454                 /* 2Ah/05h  REGISTRATIONS PREEMPTED */
 455                 *asc = 0x2A;
 456                 *ascq = 0x05;
 457                 break;
 458         case CTL_UA_ASYM_ACC_CHANGE:
 459                 /* 2Ah/06h  ASYMMETRIC ACCESS STATE CHANGED */
 460                 *asc = 0x2A;
 461                 *ascq = 0x06;
 462                 break;
 463         case CTL_UA_CAPACITY_CHANGE:
 464                 /* 2Ah/09h  CAPACITY DATA HAS CHANGED */
 465                 *asc = 0x2A;
 466                 *ascq = 0x09;
 467                 break;
 468         case CTL_UA_THIN_PROV_THRES:
 469                 /* 38h/07h  THIN PROVISIONING SOFT THRESHOLD REACHED */
 470                 *asc = 0x38;
 471                 *ascq = 0x07;
 472                 *info = lun->ua_tpt_info;
 473                 break;
 474         case CTL_UA_MEDIUM_CHANGE:
 475                 /* 28h/00h  NOT READY TO READY CHANGE, MEDIUM MAY HAVE CHANGED */
 476                 *asc = 0x28;
 477                 *ascq = 0x00;
 478                 break;
 479         case CTL_UA_IE:
 480                 /* Informational exception */
 481                 *asc = lun->ie_asc;
 482                 *ascq = lun->ie_ascq;
 483                 break;
 484         default:
 485                 panic("%s: Unknown UA %x", __func__, ua_to_build);
 486         }
 487 }
 488
 489 ctl_ua_type
 490 ctl_build_qae(struct ctl_lun *lun, uint32_t initidx, uint8_t *resp)
 491 {
 492         ctl_ua_type ua;
 493         ctl_ua_type ua_to_build, ua_to_clear;
 494         uint8_t *info;
 495         int asc, ascq;
 496         uint32_t p, i;
 497
 498         mtx_assert(&lun->lun_lock, MA_OWNED);
 499         p = initidx / CTL_MAX_INIT_PER_PORT;
 500         i = initidx % CTL_MAX_INIT_PER_PORT;
 501         if (lun->pending_ua[p] == NULL)
 502                 ua = CTL_UA_POWERON;
 503         else
 504                 ua = lun->pending_ua[p][i];
 505         if (ua == CTL_UA_NONE)
 506                 return (CTL_UA_NONE);
 507
 508         ua_to_build = (1 << (ffs(ua) - 1));
 509         ua_to_clear = ua_to_build;
 510         info = NULL;
 511         ctl_ua_to_ascq(lun, ua_to_build, &asc, &ascq, &ua_to_clear, &info);
 512
 513         resp[0] = SSD_KEY_UNIT_ATTENTION;
 514         if (ua_to_build == ua)
 515                 resp[0] |= 0x10;
 516         else
 517                 resp[0] |= 0x20;
 518         resp[1] = asc;
 519         resp[2] = ascq;
 520         return (ua_to_build);
 521 }
 522
 523 ctl_ua_type
 524 ctl_build_ua(struct ctl_lun *lun, uint32_t initidx,
 525     struct scsi_sense_data *sense, u_int *sense_len,
 526     scsi_sense_data_type sense_format)
 527 {
 528         ctl_ua_type *ua;
 529         ctl_ua_type ua_to_build, ua_to_clear;
 530         uint8_t *info;
 531         int asc, ascq;
 532         uint32_t p, i;
 533
 534         mtx_assert(&lun->lun_lock, MA_OWNED);
 535         mtx_assert(&lun->ctl_softc->ctl_lock, MA_NOTOWNED);
 536         p = initidx / CTL_MAX_INIT_PER_PORT;
 537         if ((ua = lun->pending_ua[p]) == NULL) {
 538                 mtx_unlock(&lun->lun_lock);
 539                 ua = malloc(sizeof(ctl_ua_type) * CTL_MAX_INIT_PER_PORT,
 540                     M_CTL, M_WAITOK);
 541                 mtx_lock(&lun->lun_lock);
 542                 if (lun->pending_ua[p] == NULL) {
 543                         lun->pending_ua[p] = ua;
 544                         for (i = 0; i < CTL_MAX_INIT_PER_PORT; i++)
 545                                 ua[i] = CTL_UA_POWERON;
 546                 } else {
 547                         free(ua, M_CTL);
 548                         ua = lun->pending_ua[p];
 549                 }
 550         }
 551         i = initidx % CTL_MAX_INIT_PER_PORT;
 552         if (ua[i] == CTL_UA_NONE)
 553                 return (CTL_UA_NONE);
 554
 555         ua_to_build = (1 << (ffs(ua[i]) - 1));
 556         ua_to_clear = ua_to_build;
 557         info = NULL;
 558         ctl_ua_to_ascq(lun, ua_to_build, &asc, &ascq, &ua_to_clear, &info);
 559
 560         ctl_set_sense_data(sense, sense_len, lun, sense_format, 1,
 561             /*sense_key*/ SSD_KEY_UNIT_ATTENTION, asc, ascq,
 562             ((info != NULL) ? SSD_ELEM_INFO : SSD_ELEM_SKIP), 8, info,
 563             SSD_ELEM_NONE);
 564
 565         /* We're reporting this UA, so clear it */
 566         ua[i] &= ~ua_to_clear;
 567
 568         if (ua_to_build == CTL_UA_LUN_CHANGE) {
 569                 mtx_unlock(&lun->lun_lock);
 570                 mtx_lock(&lun->ctl_softc->ctl_lock);
 571                 ctl_clr_ua_allluns(lun->ctl_softc, initidx, ua_to_build);
 572                 mtx_unlock(&lun->ctl_softc->ctl_lock);
 573                 mtx_lock(&lun->lun_lock);
 574         } else if (ua_to_build == CTL_UA_THIN_PROV_THRES &&
 575             (lun->MODE_LBP.main.flags & SLBPP_SITUA) != 0) {
 576                 ctl_clr_ua_all(lun, -1, ua_to_build);
 577         }
 578
 579         return (ua_to_build);
 580 }
 581
 582 void
 583 ctl_set_overlapped_cmd(struct ctl_scsiio *ctsio)
 584 {
 585         /* OVERLAPPED COMMANDS ATTEMPTED */
 586         ctl_set_sense(ctsio,
 587                       /*current_error*/ 1,
 588                       /*sense_key*/ SSD_KEY_ILLEGAL_REQUEST,
 589                       /*asc*/ 0x4E,
 590                       /*ascq*/ 0x00,
 591                       SSD_ELEM_NONE);
 592 }
 593
 594 void
 595 ctl_set_overlapped_tag(struct ctl_scsiio *ctsio, uint8_t tag)
 596 {
 597         /* TAGGED OVERLAPPED COMMANDS (NN = QUEUE TAG) */
 598         ctl_set_sense(ctsio,
 599                       /*current_error*/ 1,
 600                       /*sense_key*/ SSD_KEY_ILLEGAL_REQUEST,
 601                       /*asc*/ 0x4D,
 602                       /*ascq*/ tag,
 603                       SSD_ELEM_NONE);
 604 }
 605
 606 /*
 607  * Tell the user that there was a problem with the command or data he sent.
 608  */
 609 void
 610 ctl_set_invalid_field(struct ctl_scsiio *ctsio, int sks_valid, int command,
 611                       int field, int bit_valid, int bit)
 612 {
 613         uint8_t sks[3];
 614         int asc;
 615
 616         if (command != 0) {
 617                 /* "Invalid field in CDB" */
 618                 asc = 0x24;
 619         } else {
 620                 /* "Invalid field in parameter list" */
 621                 asc = 0x26;
 622         }
 623
 624         if (sks_valid) {
 625                 sks[0] = SSD_SCS_VALID;
 626                 if (command)
 627                         sks[0] |= SSD_FIELDPTR_CMD;
 628                 scsi_ulto2b(field, &sks[1]);
 629
 630                 if (bit_valid)
 631                         sks[0] |= SSD_BITPTR_VALID | bit;
 632         }
 633
 634         ctl_set_sense(ctsio,
 635                       /*current_error*/ 1,
 636                       /*sense_key*/ SSD_KEY_ILLEGAL_REQUEST,
 637                       asc,
 638                       /*ascq*/ 0x00,
 639                       /*type*/ (sks_valid != 0) ? SSD_ELEM_SKS : SSD_ELEM_SKIP,
 640                       /*size*/ sizeof(sks),
 641                       /*data*/ sks,
 642                       SSD_ELEM_NONE);
 643 }
 644 void
 645 ctl_set_invalid_field_ciu(struct ctl_scsiio *ctsio)
 646 {
 647
 648         /* "Invalid field in command information unit" */
 649         ctl_set_sense(ctsio,
 650                       /*current_error*/ 1,
 651                       /*sense_key*/ SSD_KEY_ABORTED_COMMAND,
 652                       /*ascq*/ 0x0E,
 653                       /*ascq*/ 0x03,
 654                       SSD_ELEM_NONE);
 655 }
 656
 657 void
 658 ctl_set_invalid_opcode(struct ctl_scsiio *ctsio)
 659 {
 660         uint8_t sks[3];
 661
 662         sks[0] = SSD_SCS_VALID | SSD_FIELDPTR_CMD;
 663         scsi_ulto2b(0, &sks[1]);
 664
 665         /* "Invalid command operation code" */
 666         ctl_set_sense(ctsio,
 667                       /*current_error*/ 1,
 668                       /*sense_key*/ SSD_KEY_ILLEGAL_REQUEST,
 669                       /*asc*/ 0x20,
 670                       /*ascq*/ 0x00,
 671                       /*type*/ SSD_ELEM_SKS,
 672                       /*size*/ sizeof(sks),
 673                       /*data*/ sks,
 674                       SSD_ELEM_NONE);
 675 }
 676
 677 void
 678 ctl_set_param_len_error(struct ctl_scsiio *ctsio)
 679 {
 680         /* "Parameter list length error" */
 681         ctl_set_sense(ctsio,
 682                       /*current_error*/ 1,
 683                       /*sense_key*/ SSD_KEY_ILLEGAL_REQUEST,
 684                       /*asc*/ 0x1a,
 685                       /*ascq*/ 0x00,
 686                       SSD_ELEM_NONE);
 687 }
 688
 689 void
 690 ctl_set_already_locked(struct ctl_scsiio *ctsio)
 691 {
 692         /* Vendor unique "Somebody already is locked" */
 693         ctl_set_sense(ctsio,
 694                       /*current_error*/ 1,
 695                       /*sense_key*/ SSD_KEY_ILLEGAL_REQUEST,
 696                       /*asc*/ 0x81,
 697                       /*ascq*/ 0x00,
 698                       SSD_ELEM_NONE);
 699 }
 700
 701 void
 702 ctl_set_unsupported_lun(struct ctl_scsiio *ctsio)
 703 {
 704         /* "Logical unit not supported" */
 705         ctl_set_sense(ctsio,
 706                       /*current_error*/ 1,
 707                       /*sense_key*/ SSD_KEY_ILLEGAL_REQUEST,
 708                       /*asc*/ 0x25,
 709                       /*ascq*/ 0x00,
 710                       SSD_ELEM_NONE);
 711 }
 712
 713 void
 714 ctl_set_internal_failure(struct ctl_scsiio *ctsio, int sks_valid,
 715                          uint16_t retry_count)
 716 {
 717         uint8_t sks[3];
 718
 719         if (sks_valid) {
 720                 sks[0] = SSD_SCS_VALID;
 721                 sks[1] = (retry_count >> 8) & 0xff;
 722                 sks[2] = retry_count & 0xff;
 723         }
 724
 725         /* "Internal target failure" */
 726         ctl_set_sense(ctsio,
 727                       /*current_error*/ 1,
 728                       /*sense_key*/ SSD_KEY_HARDWARE_ERROR,
 729                       /*asc*/ 0x44,
 730                       /*ascq*/ 0x00,
 731                       /*type*/ (sks_valid != 0) ? SSD_ELEM_SKS : SSD_ELEM_SKIP,
 732                       /*size*/ sizeof(sks),
 733                       /*data*/ sks,
 734                       SSD_ELEM_NONE);
 735 }
 736
 737 void
 738 ctl_set_medium_error(struct ctl_scsiio *ctsio, int read)
 739 {
 740         if (read) {
 741                 /* "Unrecovered read error" */
 742                 ctl_set_sense(ctsio,
 743                               /*current_error*/ 1,
 744                               /*sense_key*/ SSD_KEY_MEDIUM_ERROR,
 745                               /*asc*/ 0x11,
 746                               /*ascq*/ 0x00,
 747                               SSD_ELEM_NONE);
 748         } else {
 749                 /* "Write error - auto reallocation failed" */
 750                 ctl_set_sense(ctsio,
 751                               /*current_error*/ 1,
 752                               /*sense_key*/ SSD_KEY_MEDIUM_ERROR,
 753                               /*asc*/ 0x0C,
 754                               /*ascq*/ 0x02,
 755                               SSD_ELEM_NONE);
 756         }
 757 }
 758
 759 void
 760 ctl_set_aborted(struct ctl_scsiio *ctsio)
 761 {
 762         ctl_set_sense(ctsio,
 763                       /*current_error*/ 1,
 764                       /*sense_key*/ SSD_KEY_ABORTED_COMMAND,
 765                       /*asc*/ 0x45,
 766                       /*ascq*/ 0x00,
 767                       SSD_ELEM_NONE);
 768 }
 769
 770 void
 771 ctl_set_lba_out_of_range(struct ctl_scsiio *ctsio, uint64_t lba)
 772 {
 773         uint8_t info[8];
 774
 775         scsi_u64to8b(lba, info);
 776
 777         /* "Logical block address out of range" */
 778         ctl_set_sense(ctsio,
 779                       /*current_error*/ 1,
 780                       /*sense_key*/ SSD_KEY_ILLEGAL_REQUEST,
 781                       /*asc*/ 0x21,
 782                       /*ascq*/ 0x00,
 783                       /*type*/ (lba != 0) ? SSD_ELEM_INFO : SSD_ELEM_SKIP,
 784                       /*size*/ sizeof(info), /*data*/ &info,
 785                       SSD_ELEM_NONE);
 786 }
 787
 788 void
 789 ctl_set_lun_stopped(struct ctl_scsiio *ctsio)
 790 {
 791         /* "Logical unit not ready, initializing cmd. required" */
 792         ctl_set_sense(ctsio,
 793                       /*current_error*/ 1,
 794                       /*sense_key*/ SSD_KEY_NOT_READY,
 795                       /*asc*/ 0x04,
 796                       /*ascq*/ 0x02,
 797                       SSD_ELEM_NONE);
 798 }
 799
 800 void
 801 ctl_set_lun_int_reqd(struct ctl_scsiio *ctsio)
 802 {
 803         /* "Logical unit not ready, manual intervention required" */
 804         ctl_set_sense(ctsio,
 805                       /*current_error*/ 1,
 806                       /*sense_key*/ SSD_KEY_NOT_READY,
 807                       /*asc*/ 0x04,
 808                       /*ascq*/ 0x03,
 809                       SSD_ELEM_NONE);
 810 }
 811
 812 void
 813 ctl_set_lun_ejected(struct ctl_scsiio *ctsio)
 814 {
 815         /* "Medium not present - tray open" */
 816         ctl_set_sense(ctsio,
 817                       /*current_error*/ 1,
 818                       /*sense_key*/ SSD_KEY_NOT_READY,
 819                       /*asc*/ 0x3A,
 820                       /*ascq*/ 0x02,
 821                       SSD_ELEM_NONE);
 822 }
 823
 824 void
 825 ctl_set_lun_no_media(struct ctl_scsiio *ctsio)
 826 {
 827         /* "Medium not present - tray closed" */
 828         ctl_set_sense(ctsio,
 829                       /*current_error*/ 1,
 830                       /*sense_key*/ SSD_KEY_NOT_READY,
 831                       /*asc*/ 0x3A,
 832                       /*ascq*/ 0x01,
 833                       SSD_ELEM_NONE);
 834 }
 835
 836 void
 837 ctl_set_illegal_pr_release(struct ctl_scsiio *ctsio)
 838 {
 839         /* "Invalid release of persistent reservation" */
 840         ctl_set_sense(ctsio,
 841                       /*current_error*/ 1,
 842                       /*sense_key*/ SSD_KEY_ILLEGAL_REQUEST,
 843                       /*asc*/ 0x26,
 844                       /*ascq*/ 0x04,
 845                       SSD_ELEM_NONE);
 846 }
 847
 848 void
 849 ctl_set_lun_transit(struct ctl_scsiio *ctsio)
 850 {
 851         /* "Logical unit not ready, asymmetric access state transition" */
 852         ctl_set_sense(ctsio,
 853                       /*current_error*/ 1,
 854                       /*sense_key*/ SSD_KEY_NOT_READY,
 855                       /*asc*/ 0x04,
 856                       /*ascq*/ 0x0a,
 857                       SSD_ELEM_NONE);
 858 }
 859
 860 void
 861 ctl_set_lun_standby(struct ctl_scsiio *ctsio)
 862 {
 863         /* "Logical unit not ready, target port in standby state" */
 864         ctl_set_sense(ctsio,
 865                       /*current_error*/ 1,
 866                       /*sense_key*/ SSD_KEY_NOT_READY,
 867                       /*asc*/ 0x04,
 868                       /*ascq*/ 0x0b,
 869                       SSD_ELEM_NONE);
 870 }
 871
 872 void
 873 ctl_set_lun_unavail(struct ctl_scsiio *ctsio)
 874 {
 875         /* "Logical unit not ready, target port in unavailable state" */
 876         ctl_set_sense(ctsio,
 877                       /*current_error*/ 1,
 878                       /*sense_key*/ SSD_KEY_NOT_READY,
 879                       /*asc*/ 0x04,
 880                       /*ascq*/ 0x0c,
 881                       SSD_ELEM_NONE);
 882 }
 883
 884 void
 885 ctl_set_medium_format_corrupted(struct ctl_scsiio *ctsio)
 886 {
 887         /* "Medium format corrupted" */
 888         ctl_set_sense(ctsio,
 889                       /*current_error*/ 1,
 890                       /*sense_key*/ SSD_KEY_MEDIUM_ERROR,
 891                       /*asc*/ 0x31,
 892                       /*ascq*/ 0x00,
 893                       SSD_ELEM_NONE);
 894 }
 895
 896 void
 897 ctl_set_medium_magazine_inaccessible(struct ctl_scsiio *ctsio)
 898 {
 899         /* "Medium magazine not accessible" */
 900         ctl_set_sense(ctsio,
 901                       /*current_error*/ 1,
 902                       /*sense_key*/ SSD_KEY_NOT_READY,
 903                       /*asc*/ 0x3b,
 904                       /*ascq*/ 0x11,
 905                       SSD_ELEM_NONE);
 906 }
 907
 908 void
 909 ctl_set_data_phase_error(struct ctl_scsiio *ctsio)
 910 {
 911         /* "Data phase error" */
 912         ctl_set_sense(ctsio,
 913                       /*current_error*/ 1,
 914                       /*sense_key*/ SSD_KEY_NOT_READY,
 915                       /*asc*/ 0x4b,
 916                       /*ascq*/ 0x00,
 917                       SSD_ELEM_NONE);
 918 }
 919
 920 void
 921 ctl_set_reservation_conflict(struct ctl_scsiio *ctsio)
 922 {
 923
 924         ctsio->scsi_status = SCSI_STATUS_RESERV_CONFLICT;
 925         ctsio->sense_len = 0;
 926         ctsio->io_hdr.status = CTL_SCSI_ERROR;
 927 }
 928
 929 void
 930 ctl_set_queue_full(struct ctl_scsiio *ctsio)
 931 {
 932
 933         ctsio->scsi_status = SCSI_STATUS_QUEUE_FULL;
 934         ctsio->sense_len = 0;
 935         ctsio->io_hdr.status = CTL_SCSI_ERROR;
 936 }
 937
 938 void
 939 ctl_set_busy(struct ctl_scsiio *ctsio)
 940 {
 941
 942         ctsio->scsi_status = SCSI_STATUS_BUSY;
 943         ctsio->sense_len = 0;
 944         ctsio->io_hdr.status = CTL_SCSI_ERROR;
 945 }
 946
 947 void
 948 ctl_set_task_aborted(struct ctl_scsiio *ctsio)
 949 {
 950
 951         ctsio->scsi_status = SCSI_STATUS_TASK_ABORTED;
 952         ctsio->sense_len = 0;
 953         ctsio->io_hdr.status = CTL_CMD_ABORTED;
 954 }
 955
 956 void
 957 ctl_set_hw_write_protected(struct ctl_scsiio *ctsio)
 958 {
 959         /* "Hardware write protected" */
 960         ctl_set_sense(ctsio,
 961                       /*current_error*/ 1,
 962                       /*sense_key*/ SSD_KEY_DATA_PROTECT,
 963                       /*asc*/ 0x27,
 964                       /*ascq*/ 0x01,
 965                       SSD_ELEM_NONE);
 966 }
 967
 968 void
 969 ctl_set_space_alloc_fail(struct ctl_scsiio *ctsio)
 970 {
 971         /* "Space allocation failed write protect" */
 972         ctl_set_sense(ctsio,
 973                       /*current_error*/ 1,
 974                       /*sense_key*/ SSD_KEY_DATA_PROTECT,
 975                       /*asc*/ 0x27,
 976                       /*ascq*/ 0x07,
 977                       SSD_ELEM_NONE);
 978 }
 979
 980 void
 981 ctl_set_success(struct ctl_scsiio *ctsio)
 982 {
 983
 984         ctsio->scsi_status = SCSI_STATUS_OK;
 985         ctsio->sense_len = 0;
 986         ctsio->io_hdr.status = CTL_SUCCESS;
 987 }