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