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