sys/cam/scsi/scsi_pt.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause
   3  *
   4  * Implementation of SCSI Processor Target Peripheral driver for CAM.
   5  *
   6  * Copyright (c) 1998 Justin T. Gibbs.
   7  * All rights reserved.
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted provided that the following conditions
  11  * are met:
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions, and the following disclaimer,
  14  *    without modification, immediately at the beginning of the file.
  15  * 2. The name of the author may not be used to endorse or promote products
  16  *    derived from this software without specific prior written permission.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  19  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  20  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  21  * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
  22  * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  23  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  24  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  25  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  26  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  27  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  28  * SUCH DAMAGE.
  29  */
  30
  31 #include <sys/cdefs.h>
  32 #include <sys/param.h>
  33 #include <sys/queue.h>
  34 #include <sys/systm.h>
  35 #include <sys/kernel.h>
  36 #include <sys/types.h>
  37 #include <sys/bio.h>
  38 #include <sys/devicestat.h>
  39 #include <sys/malloc.h>
  40 #include <sys/conf.h>
  41 #include <sys/ptio.h>
  42
  43 #include <cam/cam.h>
  44 #include <cam/cam_ccb.h>
  45 #include <cam/cam_periph.h>
  46 #include <cam/cam_xpt_periph.h>
  47 #include <cam/cam_debug.h>
  48
  49 #include <cam/scsi/scsi_all.h>
  50 #include <cam/scsi/scsi_message.h>
  51 #include <cam/scsi/scsi_pt.h>
  52
  53 #include "opt_pt.h"
  54
  55 typedef enum {
  56         PT_STATE_PROBE,
  57         PT_STATE_NORMAL
  58 } pt_state;
  59
  60 typedef enum {
  61         PT_FLAG_NONE            = 0x00,
  62         PT_FLAG_OPEN            = 0x01,
  63         PT_FLAG_DEVICE_INVALID  = 0x02,
  64         PT_FLAG_RETRY_UA        = 0x04
  65 } pt_flags;
  66
  67 typedef enum {
  68         PT_CCB_BUFFER_IO        = 0x01,
  69         PT_CCB_RETRY_UA         = 0x04,
  70         PT_CCB_BUFFER_IO_UA     = PT_CCB_BUFFER_IO|PT_CCB_RETRY_UA
  71 } pt_ccb_state;
  72
  73 /* Offsets into our private area for storing information */
  74 #define ccb_state       ppriv_field0
  75 #define ccb_bp          ppriv_ptr1
  76
  77 struct pt_softc {
  78         struct   bio_queue_head bio_queue;
  79         struct   devstat *device_stats;
  80         LIST_HEAD(, ccb_hdr) pending_ccbs;
  81         pt_state state;
  82         pt_flags flags;
  83         int      io_timeout;
  84         struct cdev *dev;
  85 };
  86
  87 static  d_open_t        ptopen;
  88 static  d_close_t       ptclose;
  89 static  d_strategy_t    ptstrategy;
  90 static  periph_init_t   ptinit;
  91 static  void            ptasync(void *callback_arg, uint32_t code,
  92                                 struct cam_path *path, void *arg);
  93 static  periph_ctor_t   ptctor;
  94 static  periph_oninv_t  ptoninvalidate;
  95 static  periph_dtor_t   ptdtor;
  96 static  periph_start_t  ptstart;
  97 static  void            ptdone(struct cam_periph *periph,
  98                                union ccb *done_ccb);
  99 static  d_ioctl_t       ptioctl;
 100 static  int             pterror(union ccb *ccb, uint32_t cam_flags,
 101                                 uint32_t sense_flags);
 102
 103 void    scsi_send_receive(struct ccb_scsiio *csio, uint32_t retries,
 104                           void (*cbfcnp)(struct cam_periph *, union ccb *),
 105                           u_int tag_action, int readop, u_int byte2,
 106                           uint32_t xfer_len, uint8_t *data_ptr,
 107                           uint8_t sense_len, uint32_t timeout);
 108
 109 static struct periph_driver ptdriver =
 110 {
 111         ptinit, "pt",
 112         TAILQ_HEAD_INITIALIZER(ptdriver.units), /* generation */ 0
 113 };
 114
 115 PERIPHDRIVER_DECLARE(pt, ptdriver);
 116
 117 static struct cdevsw pt_cdevsw = {
 118         .d_version =    D_VERSION,
 119         .d_flags =      0,
 120         .d_open =       ptopen,
 121         .d_close =      ptclose,
 122         .d_read =       physread,
 123         .d_write =      physwrite,
 124         .d_ioctl =      ptioctl,
 125         .d_strategy =   ptstrategy,
 126         .d_name =       "pt",
 127 };
 128
 129 #ifndef SCSI_PT_DEFAULT_TIMEOUT
 130 #define SCSI_PT_DEFAULT_TIMEOUT         60
 131 #endif
 132
 133 static int
 134 ptopen(struct cdev *dev, int flags, int fmt, struct thread *td)
 135 {
 136         struct cam_periph *periph;
 137         struct pt_softc *softc;
 138         int error = 0;
 139
 140         periph = (struct cam_periph *)dev->si_drv1;
 141         if (cam_periph_acquire(periph) != 0)
 142                 return (ENXIO);
 143
 144         softc = (struct pt_softc *)periph->softc;
 145
 146         cam_periph_lock(periph);
 147         if (softc->flags & PT_FLAG_DEVICE_INVALID) {
 148                 cam_periph_release_locked(periph);
 149                 cam_periph_unlock(periph);
 150                 return(ENXIO);
 151         }
 152
 153         if ((softc->flags & PT_FLAG_OPEN) == 0)
 154                 softc->flags |= PT_FLAG_OPEN;
 155         else {
 156                 error = EBUSY;
 157                 cam_periph_release(periph);
 158         }
 159
 160         CAM_DEBUG(periph->path, CAM_DEBUG_TRACE,
 161             ("ptopen: dev=%s\n", devtoname(dev)));
 162
 163         cam_periph_unlock(periph);
 164         return (error);
 165 }
 166
 167 static int
 168 ptclose(struct cdev *dev, int flag, int fmt, struct thread *td)
 169 {
 170         struct  cam_periph *periph;
 171         struct  pt_softc *softc;
 172
 173         periph = (struct cam_periph *)dev->si_drv1;
 174         softc = (struct pt_softc *)periph->softc;
 175
 176         cam_periph_lock(periph);
 177
 178         softc->flags &= ~PT_FLAG_OPEN;
 179         cam_periph_release_locked(periph);
 180         cam_periph_unlock(periph);
 181         return (0);
 182 }
 183
 184 /*
 185  * Actually translate the requested transfer into one the physical driver
 186  * can understand.  The transfer is described by a buf and will include
 187  * only one physical transfer.
 188  */
 189 static void
 190 ptstrategy(struct bio *bp)
 191 {
 192         struct cam_periph *periph;
 193         struct pt_softc *softc;
 194
 195         periph = (struct cam_periph *)bp->bio_dev->si_drv1;
 196         bp->bio_resid = bp->bio_bcount;
 197         if (periph == NULL) {
 198                 biofinish(bp, NULL, ENXIO);
 199                 return;
 200         }
 201         cam_periph_lock(periph);
 202         softc = (struct pt_softc *)periph->softc;
 203
 204         /*
 205          * If the device has been made invalid, error out
 206          */
 207         if ((softc->flags & PT_FLAG_DEVICE_INVALID)) {
 208                 cam_periph_unlock(periph);
 209                 biofinish(bp, NULL, ENXIO);
 210                 return;
 211         }
 212
 213         /*
 214          * Place it in the queue of disk activities for this disk
 215          */
 216         bioq_insert_tail(&softc->bio_queue, bp);
 217
 218         /*
 219          * Schedule ourselves for performing the work.
 220          */
 221         xpt_schedule(periph, CAM_PRIORITY_NORMAL);
 222         cam_periph_unlock(periph);
 223
 224         return;
 225 }
 226
 227 static void
 228 ptinit(void)
 229 {
 230         cam_status status;
 231
 232         /*
 233          * Install a global async callback.  This callback will
 234          * receive async callbacks like "new device found".
 235          */
 236         status = xpt_register_async(AC_FOUND_DEVICE, ptasync, NULL, NULL);
 237
 238         if (status != CAM_REQ_CMP) {
 239                 printf("pt: Failed to attach master async callback "
 240                        "due to status 0x%x!\n", status);
 241         }
 242 }
 243
 244 static cam_status
 245 ptctor(struct cam_periph *periph, void *arg)
 246 {
 247         struct pt_softc *softc;
 248         struct ccb_getdev *cgd;
 249         struct ccb_pathinq cpi;
 250         struct make_dev_args args;
 251         int error;
 252
 253         cgd = (struct ccb_getdev *)arg;
 254         if (cgd == NULL) {
 255                 printf("ptregister: no getdev CCB, can't register device\n");
 256                 return(CAM_REQ_CMP_ERR);
 257         }
 258
 259         softc = (struct pt_softc *)malloc(sizeof(*softc),M_DEVBUF,M_NOWAIT);
 260
 261         if (softc == NULL) {
 262                 printf("daregister: Unable to probe new device. "
 263                        "Unable to allocate softc\n");
 264                 return(CAM_REQ_CMP_ERR);
 265         }
 266
 267         bzero(softc, sizeof(*softc));
 268         LIST_INIT(&softc->pending_ccbs);
 269         softc->state = PT_STATE_NORMAL;
 270         bioq_init(&softc->bio_queue);
 271
 272         softc->io_timeout = SCSI_PT_DEFAULT_TIMEOUT * 1000;
 273
 274         periph->softc = softc;
 275
 276         xpt_path_inq(&cpi, periph->path);
 277
 278         cam_periph_unlock(periph);
 279
 280         make_dev_args_init(&args);
 281         args.mda_devsw = &pt_cdevsw;
 282         args.mda_unit = periph->unit_number;
 283         args.mda_uid = UID_ROOT;
 284         args.mda_gid = GID_OPERATOR;
 285         args.mda_mode = 0600;
 286         args.mda_si_drv1 = periph;
 287         error = make_dev_s(&args, &softc->dev, "%s%d", periph->periph_name,
 288             periph->unit_number);
 289         if (error != 0) {
 290                 cam_periph_lock(periph);
 291                 return (CAM_REQ_CMP_ERR);
 292         }
 293
 294         softc->device_stats = devstat_new_entry("pt",
 295                           periph->unit_number, 0,
 296                           DEVSTAT_NO_BLOCKSIZE,
 297                           SID_TYPE(&cgd->inq_data) |
 298                           XPORT_DEVSTAT_TYPE(cpi.transport),
 299                           DEVSTAT_PRIORITY_OTHER);
 300
 301         cam_periph_lock(periph);
 302
 303         /*
 304          * Add async callbacks for bus reset and
 305          * bus device reset calls.  I don't bother
 306          * checking if this fails as, in most cases,
 307          * the system will function just fine without
 308          * them and the only alternative would be to
 309          * not attach the device on failure.
 310          */
 311         xpt_register_async(AC_SENT_BDR | AC_BUS_RESET | AC_LOST_DEVICE,
 312                            ptasync, periph, periph->path);
 313
 314         /* Tell the user we've attached to the device */
 315         xpt_announce_periph(periph, NULL);
 316
 317         return(CAM_REQ_CMP);
 318 }
 319
 320 static void
 321 ptoninvalidate(struct cam_periph *periph)
 322 {
 323         struct pt_softc *softc;
 324
 325         softc = (struct pt_softc *)periph->softc;
 326
 327         /*
 328          * De-register any async callbacks.
 329          */
 330         xpt_register_async(0, ptasync, periph, periph->path);
 331
 332         softc->flags |= PT_FLAG_DEVICE_INVALID;
 333
 334         /*
 335          * Return all queued I/O with ENXIO.
 336          * XXX Handle any transactions queued to the card
 337          *     with XPT_ABORT_CCB.
 338          */
 339         bioq_flush(&softc->bio_queue, NULL, ENXIO);
 340 }
 341
 342 static void
 343 ptdtor(struct cam_periph *periph)
 344 {
 345         struct pt_softc *softc;
 346
 347         softc = (struct pt_softc *)periph->softc;
 348
 349         devstat_remove_entry(softc->device_stats);
 350         cam_periph_unlock(periph);
 351         destroy_dev(softc->dev);
 352         cam_periph_lock(periph);
 353         free(softc, M_DEVBUF);
 354 }
 355
 356 static void
 357 ptasync(void *callback_arg, uint32_t code, struct cam_path *path, void *arg)
 358 {
 359         struct cam_periph *periph;
 360
 361         periph = (struct cam_periph *)callback_arg;
 362         switch (code) {
 363         case AC_FOUND_DEVICE:
 364         {
 365                 struct ccb_getdev *cgd;
 366                 cam_status status;
 367
 368                 cgd = (struct ccb_getdev *)arg;
 369                 if (cgd == NULL)
 370                         break;
 371
 372                 if (cgd->protocol != PROTO_SCSI)
 373                         break;
 374                 if (SID_QUAL(&cgd->inq_data) != SID_QUAL_LU_CONNECTED)
 375                         break;
 376                 if (SID_TYPE(&cgd->inq_data) != T_PROCESSOR)
 377                         break;
 378
 379                 /*
 380                  * Allocate a peripheral instance for
 381                  * this device and start the probe
 382                  * process.
 383                  */
 384                 status = cam_periph_alloc(ptctor, ptoninvalidate, ptdtor,
 385                                           ptstart, "pt", CAM_PERIPH_BIO,
 386                                           path, ptasync,
 387                                           AC_FOUND_DEVICE, cgd);
 388
 389                 if (status != CAM_REQ_CMP
 390                  && status != CAM_REQ_INPROG)
 391                         printf("ptasync: Unable to attach to new device "
 392                                 "due to status 0x%x\n", status);
 393                 break;
 394         }
 395         case AC_SENT_BDR:
 396         case AC_BUS_RESET:
 397         {
 398                 struct pt_softc *softc;
 399                 struct ccb_hdr *ccbh;
 400
 401                 softc = (struct pt_softc *)periph->softc;
 402                 /*
 403                  * Don't fail on the expected unit attention
 404                  * that will occur.
 405                  */
 406                 softc->flags |= PT_FLAG_RETRY_UA;
 407                 LIST_FOREACH(ccbh, &softc->pending_ccbs, periph_links.le)
 408                         ccbh->ccb_state |= PT_CCB_RETRY_UA;
 409         }
 410         /* FALLTHROUGH */
 411         default:
 412                 cam_periph_async(periph, code, path, arg);
 413                 break;
 414         }
 415 }
 416
 417 static void
 418 ptstart(struct cam_periph *periph, union ccb *start_ccb)
 419 {
 420         struct pt_softc *softc;
 421         struct bio *bp;
 422
 423         softc = (struct pt_softc *)periph->softc;
 424
 425         CAM_DEBUG(periph->path, CAM_DEBUG_TRACE, ("ptstart\n"));
 426
 427         /*
 428          * See if there is a buf with work for us to do..
 429          */
 430         bp = bioq_first(&softc->bio_queue);
 431         if (bp == NULL) {
 432                 xpt_release_ccb(start_ccb);
 433         } else {
 434                 bioq_remove(&softc->bio_queue, bp);
 435
 436                 devstat_start_transaction_bio(softc->device_stats, bp);
 437
 438                 scsi_send_receive(&start_ccb->csio,
 439                                   /*retries*/4,
 440                                   ptdone,
 441                                   MSG_SIMPLE_Q_TAG,
 442                                   bp->bio_cmd == BIO_READ,
 443                                   /*byte2*/0,
 444                                   bp->bio_bcount,
 445                                   bp->bio_data,
 446                                   /*sense_len*/SSD_FULL_SIZE,
 447                                   /*timeout*/softc->io_timeout);
 448
 449                 start_ccb->ccb_h.ccb_state = PT_CCB_BUFFER_IO_UA;
 450
 451                 /*
 452                  * Block out any asynchronous callbacks
 453                  * while we touch the pending ccb list.
 454                  */
 455                 LIST_INSERT_HEAD(&softc->pending_ccbs, &start_ccb->ccb_h,
 456                                  periph_links.le);
 457
 458                 start_ccb->ccb_h.ccb_bp = bp;
 459                 bp = bioq_first(&softc->bio_queue);
 460
 461                 xpt_action(start_ccb);
 462
 463                 if (bp != NULL) {
 464                         /* Have more work to do, so ensure we stay scheduled */
 465                         xpt_schedule(periph, CAM_PRIORITY_NORMAL);
 466                 }
 467         }
 468 }
 469
 470 static void
 471 ptdone(struct cam_periph *periph, union ccb *done_ccb)
 472 {
 473         struct pt_softc *softc;
 474         struct ccb_scsiio *csio;
 475
 476         softc = (struct pt_softc *)periph->softc;
 477
 478         CAM_DEBUG(periph->path, CAM_DEBUG_TRACE, ("ptdone\n"));
 479
 480         csio = &done_ccb->csio;
 481         switch (csio->ccb_h.ccb_state) {
 482         case PT_CCB_BUFFER_IO:
 483         case PT_CCB_BUFFER_IO_UA:
 484         {
 485                 struct bio *bp;
 486
 487                 bp = (struct bio *)done_ccb->ccb_h.ccb_bp;
 488                 if ((done_ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
 489                         int error;
 490                         int sf;
 491
 492                         if ((csio->ccb_h.ccb_state & PT_CCB_RETRY_UA) != 0)
 493                                 sf = SF_RETRY_UA;
 494                         else
 495                                 sf = 0;
 496
 497                         error = pterror(done_ccb, CAM_RETRY_SELTO, sf);
 498                         if (error == ERESTART) {
 499                                 /*
 500                                  * A retry was scheuled, so
 501                                  * just return.
 502                                  */
 503                                 return;
 504                         }
 505                         if (error != 0) {
 506                                 if (error == ENXIO) {
 507                                         /*
 508                                          * Catastrophic error.  Mark our device
 509                                          * as invalid.
 510                                          */
 511                                         xpt_print(periph->path,
 512                                             "Invalidating device\n");
 513                                         softc->flags |= PT_FLAG_DEVICE_INVALID;
 514                                 }
 515
 516                                 /*
 517                                  * return all queued I/O with EIO, so that
 518                                  * the client can retry these I/Os in the
 519                                  * proper order should it attempt to recover.
 520                                  */
 521                                 bioq_flush(&softc->bio_queue, NULL, EIO);
 522                                 bp->bio_error = error;
 523                                 bp->bio_resid = bp->bio_bcount;
 524                                 bp->bio_flags |= BIO_ERROR;
 525                         } else {
 526                                 bp->bio_resid = csio->resid;
 527                                 bp->bio_error = 0;
 528                                 if (bp->bio_resid != 0) {
 529                                         /* Short transfer ??? */
 530                                         bp->bio_flags |= BIO_ERROR;
 531                                 }
 532                         }
 533                         if ((done_ccb->ccb_h.status & CAM_DEV_QFRZN) != 0)
 534                                 cam_release_devq(done_ccb->ccb_h.path,
 535                                                  /*relsim_flags*/0,
 536                                                  /*reduction*/0,
 537                                                  /*timeout*/0,
 538                                                  /*getcount_only*/0);
 539                 } else {
 540                         bp->bio_resid = csio->resid;
 541                         if (bp->bio_resid != 0)
 542                                 bp->bio_flags |= BIO_ERROR;
 543                 }
 544
 545                 /*
 546                  * Block out any asynchronous callbacks
 547                  * while we touch the pending ccb list.
 548                  */
 549                 LIST_REMOVE(&done_ccb->ccb_h, periph_links.le);
 550
 551                 biofinish(bp, softc->device_stats, 0);
 552                 break;
 553         }
 554         }
 555         xpt_release_ccb(done_ccb);
 556 }
 557
 558 static int
 559 pterror(union ccb *ccb, uint32_t cam_flags, uint32_t sense_flags)
 560 {
 561
 562         return(cam_periph_error(ccb, cam_flags, sense_flags));
 563 }
 564
 565 static int
 566 ptioctl(struct cdev *dev, u_long cmd, caddr_t addr, int flag, struct thread *td)
 567 {
 568         struct cam_periph *periph;
 569         struct pt_softc *softc;
 570         int error = 0;
 571
 572         periph = (struct cam_periph *)dev->si_drv1;
 573         softc = (struct pt_softc *)periph->softc;
 574
 575         cam_periph_lock(periph);
 576
 577         switch(cmd) {
 578         case PTIOCGETTIMEOUT:
 579                 if (softc->io_timeout >= 1000)
 580                         *(int *)addr = softc->io_timeout / 1000;
 581                 else
 582                         *(int *)addr = 0;
 583                 break;
 584         case PTIOCSETTIMEOUT:
 585                 if (*(int *)addr < 1) {
 586                         error = EINVAL;
 587                         break;
 588                 }
 589
 590                 softc->io_timeout = *(int *)addr * 1000;
 591
 592                 break;
 593         default:
 594                 error = cam_periph_ioctl(periph, cmd, addr, pterror);
 595                 break;
 596         }
 597
 598         cam_periph_unlock(periph);
 599
 600         return(error);
 601 }
 602
 603 void
 604 scsi_send_receive(struct ccb_scsiio *csio, uint32_t retries,
 605                   void (*cbfcnp)(struct cam_periph *, union ccb *),
 606                   u_int tag_action, int readop, u_int byte2,
 607                   uint32_t xfer_len, uint8_t *data_ptr, uint8_t sense_len,
 608                   uint32_t timeout)
 609 {
 610         struct scsi_send_receive *scsi_cmd;
 611
 612         scsi_cmd = (struct scsi_send_receive *)&csio->cdb_io.cdb_bytes;
 613         scsi_cmd->opcode = readop ? RECEIVE : SEND;
 614         scsi_cmd->byte2 = byte2;
 615         scsi_ulto3b(xfer_len, scsi_cmd->xfer_len);
 616         scsi_cmd->control = 0;
 617
 618         cam_fill_csio(csio,
 619                       retries,
 620                       cbfcnp,
 621                       /*flags*/readop ? CAM_DIR_IN : CAM_DIR_OUT,
 622                       tag_action,
 623                       data_ptr,
 624                       xfer_len,
 625                       sense_len,
 626                       sizeof(*scsi_cmd),
 627                       timeout);
 628 }