sys/dev/raid/aac/aac_debug.c

   1 /*-
   2  * Copyright (c) 2000 Michael Smith
   3  * Copyright (c) 2001 Scott Long
   4  * Copyright (c) 2000 BSDi
   5  * Copyright (c) 2001 Adaptec, Inc.
   6  * All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  27  * SUCH DAMAGE.
  28  *
  29  *      $FreeBSD: src/sys/dev/aac/aac_debug.c,v 1.2.2.5 2003/01/11 18:39:39 scottl Exp $
  30  */
  31
  32 /*
  33  * Debugging support.
  34  */
  35 #include "opt_aac.h"
  36
  37 #include <sys/param.h>
  38 #include <sys/systm.h>
  39 #include <sys/kernel.h>
  40
  41 #include <dev/aac/aac_compat.h>
  42 #include <sys/bus.h>
  43 #include <sys/devicestat.h>
  44 #include <sys/disk.h>
  45
  46 #include <machine/resource.h>
  47 #include <machine/bus.h>
  48
  49 #include <dev/aac/aacreg.h>
  50 #include <dev/aac/aac_ioctl.h>
  51 #include <dev/aac/aacvar.h>
  52
  53 #ifdef AAC_DEBUG
  54 void    aac_printstate0(void);
  55 void    aac_intr0(void);
  56
  57 /*
  58  * Dump the command queue indices
  59  */
  60 void
  61 aac_print_queues(struct aac_softc *sc)
  62 {
  63         device_printf(sc->aac_dev, "FIB queue header at %p  queues at %p\n",
  64             &sc->aac_queues->qt_qindex[AAC_HOST_NORM_CMD_QUEUE][0],
  65             &sc->aac_queues->qt_HostNormCmdQueue[0]);
  66         device_printf(sc->aac_dev, "HOST_NORM_CMD  %d/%d (%d)\n",
  67             sc->aac_queues->qt_qindex[AAC_HOST_NORM_CMD_QUEUE][
  68                                       AAC_PRODUCER_INDEX],
  69             sc->aac_queues->qt_qindex[AAC_HOST_NORM_CMD_QUEUE][
  70                                       AAC_CONSUMER_INDEX],
  71             AAC_HOST_NORM_CMD_ENTRIES);
  72         device_printf(sc->aac_dev, "HOST_HIGH_CMD  %d/%d (%d)\n",
  73             sc->aac_queues->qt_qindex[AAC_HOST_HIGH_CMD_QUEUE][
  74                                       AAC_PRODUCER_INDEX],
  75             sc->aac_queues->qt_qindex[AAC_HOST_HIGH_CMD_QUEUE][
  76                                       AAC_CONSUMER_INDEX],
  77             AAC_HOST_HIGH_CMD_ENTRIES);
  78         device_printf(sc->aac_dev, "ADAP_NORM_CMD  %d/%d (%d)\n",
  79             sc->aac_queues->qt_qindex[AAC_ADAP_NORM_CMD_QUEUE][
  80                                       AAC_PRODUCER_INDEX],
  81             sc->aac_queues->qt_qindex[AAC_ADAP_NORM_CMD_QUEUE][
  82                                       AAC_CONSUMER_INDEX],
  83             AAC_ADAP_NORM_CMD_ENTRIES);
  84         device_printf(sc->aac_dev, "ADAP_HIGH_CMD  %d/%d (%d)\n",
  85             sc->aac_queues->qt_qindex[AAC_ADAP_HIGH_CMD_QUEUE][
  86                                       AAC_PRODUCER_INDEX],
  87             sc->aac_queues->qt_qindex[AAC_ADAP_HIGH_CMD_QUEUE][
  88                                       AAC_CONSUMER_INDEX],
  89             AAC_ADAP_HIGH_CMD_ENTRIES);
  90         device_printf(sc->aac_dev, "HOST_NORM_RESP %d/%d (%d)\n",
  91             sc->aac_queues->qt_qindex[AAC_HOST_NORM_RESP_QUEUE][
  92                                       AAC_PRODUCER_INDEX],
  93             sc->aac_queues->qt_qindex[AAC_HOST_NORM_RESP_QUEUE][
  94                                       AAC_CONSUMER_INDEX],
  95             AAC_HOST_NORM_RESP_ENTRIES);
  96         device_printf(sc->aac_dev, "HOST_HIGH_RESP %d/%d (%d)\n",
  97             sc->aac_queues->qt_qindex[AAC_HOST_HIGH_RESP_QUEUE][
  98                                       AAC_PRODUCER_INDEX],
  99             sc->aac_queues->qt_qindex[AAC_HOST_HIGH_RESP_QUEUE][
 100                                       AAC_CONSUMER_INDEX],
 101             AAC_HOST_HIGH_RESP_ENTRIES);
 102         device_printf(sc->aac_dev, "ADAP_NORM_RESP %d/%d (%d)\n",
 103             sc->aac_queues->qt_qindex[AAC_ADAP_NORM_RESP_QUEUE][
 104                                       AAC_PRODUCER_INDEX],
 105             sc->aac_queues->qt_qindex[AAC_ADAP_NORM_RESP_QUEUE][
 106                                       AAC_CONSUMER_INDEX],
 107             AAC_ADAP_NORM_RESP_ENTRIES);
 108         device_printf(sc->aac_dev, "ADAP_HIGH_RESP %d/%d (%d)\n",
 109             sc->aac_queues->qt_qindex[AAC_ADAP_HIGH_RESP_QUEUE][
 110                                       AAC_PRODUCER_INDEX],
 111             sc->aac_queues->qt_qindex[AAC_ADAP_HIGH_RESP_QUEUE][
 112                                       AAC_CONSUMER_INDEX],
 113             AAC_ADAP_HIGH_RESP_ENTRIES);
 114         device_printf(sc->aac_dev, "AACQ_FREE      %d/%d\n",
 115             sc->aac_qstat[AACQ_FREE].q_length, sc->aac_qstat[AACQ_FREE].q_max);
 116         device_printf(sc->aac_dev, "AACQ_BIO       %d/%d\n",
 117             sc->aac_qstat[AACQ_BIO].q_length, sc->aac_qstat[AACQ_BIO].q_max);
 118         device_printf(sc->aac_dev, "AACQ_READY     %d/%d\n",
 119             sc->aac_qstat[AACQ_READY].q_length,
 120             sc->aac_qstat[AACQ_READY].q_max);
 121         device_printf(sc->aac_dev, "AACQ_BUSY      %d/%d\n",
 122             sc->aac_qstat[AACQ_BUSY].q_length, sc->aac_qstat[AACQ_BUSY].q_max);
 123         device_printf(sc->aac_dev, "AACQ_COMPLETE  %d/%d\n",
 124             sc->aac_qstat[AACQ_COMPLETE].q_length,
 125             sc->aac_qstat[AACQ_COMPLETE].q_max);
 126 }
 127
 128 /*
 129  * Print the command queue states for controller 0 (callable from DDB)
 130  */
 131 void
 132 aac_printstate0(void)
 133 {
 134         struct aac_softc *sc;
 135
 136         sc = devclass_get_softc(aac_devclass, 0);
 137
 138         aac_print_queues(sc);
 139         switch (sc->aac_hwif) {
 140         case AAC_HWIF_I960RX:
 141                 device_printf(sc->aac_dev, "IDBR 0x%08x  IIMR 0x%08x  "
 142                     "IISR 0x%08x\n", AAC_GETREG4(sc, AAC_RX_IDBR),
 143                     AAC_GETREG4(sc, AAC_RX_IIMR), AAC_GETREG4(sc, AAC_RX_IISR));
 144                 device_printf(sc->aac_dev, "ODBR 0x%08x  OIMR 0x%08x  "
 145                     "OISR 0x%08x\n", AAC_GETREG4(sc, AAC_RX_ODBR),
 146                     AAC_GETREG4(sc, AAC_RX_OIMR), AAC_GETREG4(sc, AAC_RX_OISR));
 147                 AAC_SETREG4(sc, AAC_RX_OIMR, 0/*~(AAC_DB_COMMAND_READY |
 148                             AAC_DB_RESPONSE_READY | AAC_DB_PRINTF)*/);
 149                 device_printf(sc->aac_dev, "ODBR 0x%08x  OIMR 0x%08x  "
 150                     "OISR 0x%08x\n", AAC_GETREG4(sc, AAC_RX_ODBR),
 151                     AAC_GETREG4(sc, AAC_RX_OIMR), AAC_GETREG4(sc, AAC_RX_OISR));
 152                 break;
 153         case AAC_HWIF_STRONGARM:
 154                 /* XXX implement */
 155         }
 156 }
 157
 158 /*
 159  * simulate an interrupt for controller 0
 160  */
 161 void
 162 aac_intr0(void)
 163 {
 164         struct aac_softc *sc;
 165
 166         sc = devclass_get_softc(aac_devclass, 0);
 167
 168         aac_intr(sc);
 169 }
 170
 171 /*
 172  * Panic in a slightly informative fashion
 173  */
 174 void
 175 aac_panic(struct aac_softc *sc, char *reason)
 176 {
 177         aac_print_queues(sc);
 178         panic(reason);
 179 }
 180
 181 /*
 182  * Print a FIB
 183  */
 184 void
 185 aac_print_fib(struct aac_softc *sc, struct aac_fib *fib, char *caller)
 186 {
 187         if (fib == NULL) {
 188                 device_printf(sc->aac_dev,
 189                               "aac_print_fib called with NULL fib\n");
 190                 return;
 191         }
 192         device_printf(sc->aac_dev, "%s: FIB @ %p\n", caller, fib);
 193         device_printf(sc->aac_dev, "  XferState %b\n", fib->Header.XferState,
 194                       "\20"
 195                       "\1HOSTOWNED"
 196                       "\2ADAPTEROWNED"
 197                       "\3INITIALISED"
 198                       "\4EMPTY"
 199                       "\5FROMPOOL"
 200                       "\6FROMHOST"
 201                       "\7FROMADAP"
 202                       "\10REXPECTED"
 203                       "\11RNOTEXPECTED"
 204                       "\12DONEADAP"
 205                       "\13DONEHOST"
 206                       "\14HIGH"
 207                       "\15NORM"
 208                       "\16ASYNC"
 209                       "\17PAGEFILEIO"
 210                       "\20SHUTDOWN"
 211                       "\21LAZYWRITE"
 212                       "\22ADAPMICROFIB"
 213                       "\23BIOSFIB"
 214                       "\24FAST_RESPONSE"
 215                       "\25APIFIB\n");
 216         device_printf(sc->aac_dev, "  Command       %d\n", fib->Header.Command);
 217         device_printf(sc->aac_dev, "  StructType    %d\n",
 218                       fib->Header.StructType);
 219         device_printf(sc->aac_dev, "  Flags         0x%x\n", fib->Header.Flags);
 220         device_printf(sc->aac_dev, "  Size          %d\n", fib->Header.Size);
 221         device_printf(sc->aac_dev, "  SenderSize    %d\n",
 222                       fib->Header.SenderSize);
 223         device_printf(sc->aac_dev, "  SenderAddress 0x%x\n",
 224                       fib->Header.SenderFibAddress);
 225         device_printf(sc->aac_dev, "  RcvrAddress   0x%x\n",
 226                       fib->Header.ReceiverFibAddress);
 227         device_printf(sc->aac_dev, "  SenderData    0x%x\n",
 228                       fib->Header.SenderData);
 229         switch(fib->Header.Command) {
 230         case ContainerCommand:
 231         {
 232                 struct aac_blockread *br;
 233                 struct aac_blockwrite *bw;
 234                 struct aac_sg_table *sg;
 235                 int i;
 236
 237                 br = (struct aac_blockread*)fib->data;
 238                 bw = (struct aac_blockwrite*)fib->data;
 239                 sg = NULL;
 240
 241                 if (br->Command == VM_CtBlockRead) {
 242                         device_printf(sc->aac_dev,
 243                                       "  BlockRead: container %d  0x%x/%d\n",
 244                                       br->ContainerId, br->BlockNumber,
 245                                       br->ByteCount);
 246                         sg = &br->SgMap;
 247                 }
 248                 if (bw->Command == VM_CtBlockWrite) {
 249                         device_printf(sc->aac_dev,
 250                                       "  BlockWrite: container %d  0x%x/%d "
 251                                       "(%s)\n", bw->ContainerId,
 252                                       bw->BlockNumber, bw->ByteCount,
 253                                       bw->Stable == CSTABLE ? "stable" :
 254                                       "unstable");
 255                         sg = &bw->SgMap;
 256                 }
 257                 if (sg != NULL) {
 258                         device_printf(sc->aac_dev,
 259                                       "  %d s/g entries\n", sg->SgCount);
 260                         for (i = 0; i < sg->SgCount; i++)
 261                                 device_printf(sc->aac_dev, "  0x%08x/%d\n",
 262                                               sg->SgEntry[i].SgAddress,
 263                                               sg->SgEntry[i].SgByteCount);
 264                 }
 265                 break;
 266         }
 267         default:
 268                 device_printf(sc->aac_dev, "   %16D\n", fib->data, " ");
 269                 device_printf(sc->aac_dev, "   %16D\n", fib->data + 16, " ");
 270                 break;
 271         }
 272 }
 273
 274 /*
 275  * Describe an AIF we have received.
 276  */
 277 void
 278 aac_print_aif(struct aac_softc *sc, struct aac_aif_command *aif)
 279 {
 280         switch(aif->command) {
 281         case AifCmdEventNotify:
 282                 device_printf(sc->aac_dev, "EventNotify(%d)\n", aif->seqNumber);
 283                 switch(aif->data.EN.type) {
 284                 case AifEnGeneric:              /* Generic notification */
 285                         device_printf(sc->aac_dev, "(Generic) %.*s\n",
 286                                   (int)sizeof(aif->data.EN.data.EG),
 287                                   aif->data.EN.data.EG.text);
 288                         break;
 289                 case AifEnTaskComplete:         /* Task has completed */
 290                         device_printf(sc->aac_dev, "(TaskComplete)\n");
 291                         break;
 292                 case AifEnConfigChange:         /* Adapter configuration change
 293                                                  * occurred */
 294                         device_printf(sc->aac_dev, "(ConfigChange)\n");
 295                         break;
 296                 case AifEnContainerChange:      /* Adapter specific container
 297                                                  * configuration change */
 298                         device_printf(sc->aac_dev, "(ContainerChange) "
 299                                       "container %d,%d\n",
 300                                       aif->data.EN.data.ECC.container[0],
 301                                       aif->data.EN.data.ECC.container[1]);
 302                         break;
 303                 case AifEnDeviceFailure:        /* SCSI device failed */
 304                         device_printf(sc->aac_dev, "(DeviceFailure) "
 305                                       "handle %d\n",
 306                                       aif->data.EN.data.EDF.deviceHandle);
 307                         break;
 308                 case AifEnMirrorFailover:       /* Mirror failover started */
 309                         device_printf(sc->aac_dev, "(MirrorFailover) "
 310                                       "container %d failed, "
 311                                       "migrating from slice %d to %d\n",
 312                                       aif->data.EN.data.EMF.container,
 313                                       aif->data.EN.data.EMF.failedSlice,
 314                                       aif->data.EN.data.EMF.creatingSlice);
 315                         break;
 316                 case AifEnContainerEvent:       /* Significant container
 317                                                  * event */
 318                         device_printf(sc->aac_dev, "(ContainerEvent) "
 319                                       "container %d event "
 320                                       "%d\n", aif->data.EN.data.ECE.container,
 321                                       aif->data.EN.data.ECE.eventType);
 322                         break;
 323                 case AifEnFileSystemChange:     /* File system changed */
 324                         device_printf(sc->aac_dev, "(FileSystemChange)\n");
 325                         break;
 326                 case AifEnConfigPause:          /* Container pause event */
 327                         device_printf(sc->aac_dev, "(ConfigPause)\n");
 328                         break;
 329                 case AifEnConfigResume:         /* Container resume event */
 330                         device_printf(sc->aac_dev, "(ConfigResume)\n");
 331                         break;
 332                 case AifEnFailoverChange:       /* Failover space assignment
 333                                                  * changed */
 334                         device_printf(sc->aac_dev, "(FailoverChange)\n");
 335                         break;
 336                 case AifEnRAID5RebuildDone:     /* RAID5 rebuild finished */
 337                         device_printf(sc->aac_dev, "(RAID5RebuildDone)\n");
 338                         break;
 339                 case AifEnEnclosureManagement:  /* Enclosure management event */
 340                         device_printf(sc->aac_dev, "(EnclosureManagement) "
 341                                       "EMPID %d unit %d "
 342                                       "event %d\n", aif->data.EN.data.EEE.empID,
 343                                       aif->data.EN.data.EEE.unitID,
 344                                       aif->data.EN.data.EEE.eventType);
 345                         break;
 346                 case AifEnBatteryEvent:         /* Significant NV battery
 347                                                  * event */
 348                         device_printf(sc->aac_dev, "(BatteryEvent) %d "
 349                                       "(state was %d, is %d\n",
 350                                       aif->data.EN.data.EBE.transition_type,
 351                                       aif->data.EN.data.EBE.current_state,
 352                                       aif->data.EN.data.EBE.prior_state);
 353                         break;
 354                 case AifEnAddContainer:         /* A new container was
 355                                                  * created. */
 356                         device_printf(sc->aac_dev, "(AddContainer)\n");
 357                         break;
 358                 case AifEnDeleteContainer:      /* A container was deleted. */
 359                         device_printf(sc->aac_dev, "(DeleteContainer)\n");
 360                         break;
 361                 case AifEnBatteryNeedsRecond:   /* The battery needs
 362                                                  * reconditioning */
 363                         device_printf(sc->aac_dev, "(BatteryNeedsRecond)\n");
 364                         break;
 365                 case AifEnClusterEvent:         /* Some cluster event */
 366                         device_printf(sc->aac_dev, "(ClusterEvent) event %d\n",
 367                                       aif->data.EN.data.ECLE.eventType);
 368                         break;
 369                 case AifEnDiskSetEvent:         /* A disk set event occured. */
 370                         device_printf(sc->aac_dev, "(DiskSetEvent) event %d "
 371                                       "diskset %lld creator %lld\n",
 372                                       aif->data.EN.data.EDS.eventType,
 373                                       aif->data.EN.data.EDS.DsNum,
 374                                       aif->data.EN.data.EDS.CreatorId);
 375                         break;
 376                 case AifDenMorphComplete:       /* A morph operation
 377                                                  * completed */
 378                         device_printf(sc->aac_dev, "(MorphComplete)\n");
 379                         break;
 380                 case AifDenVolumeExtendComplete: /* A volume expand operation
 381                                                   * completed */
 382                         device_printf(sc->aac_dev, "(VolumeExtendComplete)\n");
 383                         break;
 384                 default:
 385                         device_printf(sc->aac_dev, "(%d)\n", aif->data.EN.type);
 386                         break;
 387                 }
 388                 break;
 389         case AifCmdJobProgress:
 390         {
 391                 char    *status;
 392                 switch(aif->data.PR[0].status) {
 393                 case AifJobStsSuccess:
 394                         status = "success"; break;
 395                 case AifJobStsFinished:
 396                         status = "finished"; break;
 397                 case AifJobStsAborted:
 398                         status = "aborted"; break;
 399                 case AifJobStsFailed:
 400                         status = "failed"; break;
 401                 case AifJobStsSuspended:
 402                         status = "suspended"; break;
 403                 case AifJobStsRunning:
 404                         status = "running"; break;
 405                 default:
 406                         status = "unknown status"; break;
 407                 }
 408
 409                 device_printf(sc->aac_dev, "JobProgress (%d) - %s (%d, %d)\n",
 410                               aif->seqNumber, status,
 411                               aif->data.PR[0].currentTick,
 412                               aif->data.PR[0].finalTick);
 413                 switch(aif->data.PR[0].jd.type) {
 414                 case AifJobScsiZero:            /* SCSI dev clear operation */
 415                         device_printf(sc->aac_dev, "(ScsiZero) handle %d\n",
 416                                       aif->data.PR[0].jd.client.scsi_dh);
 417                         break;
 418                 case AifJobScsiVerify:          /* SCSI device Verify operation
 419                                                  * NO REPAIR */
 420                         device_printf(sc->aac_dev, "(ScsiVerify) handle %d\n",
 421                                       aif->data.PR[0].jd.client.scsi_dh);
 422                         break;
 423                 case AifJobScsiExercise:        /* SCSI device Exercise
 424                                                  * operation */
 425                         device_printf(sc->aac_dev, "(ScsiExercise) handle %d\n",
 426                                       aif->data.PR[0].jd.client.scsi_dh);
 427                         break;
 428                 case AifJobScsiVerifyRepair:    /* SCSI device Verify operation
 429                                                  * WITH repair */
 430                         device_printf(sc->aac_dev,
 431                                       "(ScsiVerifyRepair) handle %d\n",
 432                                       aif->data.PR[0].jd.client.scsi_dh);
 433                         break;
 434                 case AifJobCtrZero:             /* Container clear operation */
 435                         device_printf(sc->aac_dev,
 436                                       "(ConatainerZero) container %d\n",
 437                                       aif->data.PR[0].jd.client.container.src);
 438                         break;
 439                 case AifJobCtrCopy:             /* Container copy operation */
 440                         device_printf(sc->aac_dev,
 441                                       "(ConatainerCopy) container %d to %d\n",
 442                                       aif->data.PR[0].jd.client.container.src,
 443                                       aif->data.PR[0].jd.client.container.dst);
 444                         break;
 445                 case AifJobCtrCreateMirror:     /* Container Create Mirror
 446                                                  * operation */
 447                         device_printf(sc->aac_dev,
 448                                       "(ConatainerCreateMirror) container %d\n",
 449                                       aif->data.PR[0].jd.client.container.src);
 450                                       /* XXX two containers? */
 451                         break;
 452                 case AifJobCtrMergeMirror:      /* Container Merge Mirror
 453                                                  * operation */
 454                         device_printf(sc->aac_dev,
 455                                       "(ConatainerMergeMirror) container %d\n",
 456                                       aif->data.PR[0].jd.client.container.src);
 457                                       /* XXX two containers? */
 458                         break;
 459                 case AifJobCtrScrubMirror:      /* Container Scrub Mirror
 460                                                  * operation */
 461                         device_printf(sc->aac_dev,
 462                                       "(ConatainerScrubMirror) container %d\n",
 463                                       aif->data.PR[0].jd.client.container.src);
 464                         break;
 465                 case AifJobCtrRebuildRaid5:     /* Container Rebuild Raid5
 466                                                  * operation */
 467                         device_printf(sc->aac_dev,
 468                                       "(ConatainerRebuildRaid5) container %d\n",
 469                                       aif->data.PR[0].jd.client.container.src);
 470                         break;
 471                 case AifJobCtrScrubRaid5:       /* Container Scrub Raid5
 472                                                  * operation */
 473                         device_printf(sc->aac_dev,
 474                                       "(ConatainerScrubRaid5) container %d\n",
 475                                       aif->data.PR[0].jd.client.container.src);
 476                         break;
 477                 case AifJobCtrMorph:            /* Container morph operation */
 478                         device_printf(sc->aac_dev,
 479                                       "(ConatainerMorph) container %d\n",
 480                                       aif->data.PR[0].jd.client.container.src);
 481                                       /* XXX two containers? */
 482                         break;
 483                 case AifJobCtrPartCopy:         /* Container Partition copy
 484                                                  * operation */
 485                         device_printf(sc->aac_dev,
 486                                       "(ConatainerPartCopy) container %d to "
 487                                       "%d\n",
 488                                       aif->data.PR[0].jd.client.container.src,
 489                                       aif->data.PR[0].jd.client.container.dst);
 490                         break;
 491                 case AifJobCtrRebuildMirror:    /* Container Rebuild Mirror
 492                                                  * operation */
 493                         device_printf(sc->aac_dev,
 494                                       "(ConatainerRebuildMirror) container "
 495                                       "%d\n",
 496                                       aif->data.PR[0].jd.client.container.src);
 497                         break;
 498                 case AifJobCtrCrazyCache:       /* crazy cache */
 499                         device_printf(sc->aac_dev,
 500                                       "(ConatainerCrazyCache) container %d\n",
 501                                       aif->data.PR[0].jd.client.container.src);
 502                                       /* XXX two containers? */
 503                         break;
 504                 case AifJobFsCreate:            /* File System Create
 505                                                  * operation */
 506                         device_printf(sc->aac_dev, "(FsCreate)\n");
 507                         break;
 508                 case AifJobFsVerify:            /* File System Verify
 509                                                  * operation */
 510                         device_printf(sc->aac_dev, "(FsVerivy)\n");
 511                         break;
 512                 case AifJobFsExtend:            /* File System Extend
 513                                                  * operation */
 514                         device_printf(sc->aac_dev, "(FsExtend)\n");
 515                         break;
 516                 case AifJobApiFormatNTFS:       /* Format a drive to NTFS */
 517                         device_printf(sc->aac_dev, "(FormatNTFS)\n");
 518                         break;
 519                 case AifJobApiFormatFAT:        /* Format a drive to FAT */
 520                         device_printf(sc->aac_dev, "(FormatFAT)\n");
 521                         break;
 522                 case AifJobApiUpdateSnapshot:   /* update the read/write half
 523                                                  * of a snapshot */
 524                         device_printf(sc->aac_dev, "(UpdateSnapshot)\n");
 525                         break;
 526                 case AifJobApiFormatFAT32:      /* Format a drive to FAT32 */
 527                         device_printf(sc->aac_dev, "(FormatFAT32)\n");
 528                         break;
 529                 case AifJobCtlContinuousCtrVerify: /* Adapter operation */
 530                         device_printf(sc->aac_dev, "(ContinuousCtrVerify)\n");
 531                         break;
 532                 default:
 533                         device_printf(sc->aac_dev, "(%d)\n",
 534                                       aif->data.PR[0].jd.type);
 535                         break;
 536                 }
 537                 break;
 538         }
 539         case AifCmdAPIReport:
 540                 device_printf(sc->aac_dev, "APIReport (%d)\n", aif->seqNumber);
 541                 break;
 542         case AifCmdDriverNotify:
 543                 device_printf(sc->aac_dev, "DriverNotify (%d)\n",
 544                               aif->seqNumber);
 545                 break;
 546         default:
 547                 device_printf(sc->aac_dev, "AIF %d (%d)\n", aif->command,
 548                               aif->seqNumber);
 549                 break;
 550         }
 551 }
 552 #endif /* AAC_DEBUG */