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