sys/dev/aac/aac_debug.c

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