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