FreeBSD/Linux Kernel Cross Reference
sys/kgmacros

     
     # Kernel gdb macros
     #
     #  These gdb macros should be useful during kernel development in
     #  determining what's going on in the kernel.
     #
     #  All the convenience variables used by these macros begin with $kgm_
     
     set print asm-demangle on
    set cp-abi gnu-v2
    
    # This option tells gdb to relax its stack tracing heuristics
    # Useful for debugging across stack switches
    # (to the interrupt stack, for instance). Requires gdb-675 or greater.
    set backtrace sanity-checks off
    
    echo Loading Kernel GDB Macros package.  Type "help kgm" for more info.\n
    
    define kgm
    printf ""
    echo  These are the gdb macros for kernel debugging.  Type "help kgm" for more info.\n
    end
    
    document kgm
    | These are the kernel gdb macros.  These gdb macros are intended to be
    | used when debugging a remote kernel via the kdp protocol.  Typically, you
    | would connect to your remote target like so:
    |                (gdb) target remote-kdp
    |                (gdb) attach <name-of-remote-host>
    |
    | The following macros are available in this package:
    |     showversion    Displays a string describing the remote kernel version
    |
    |     showalltasks   Display a summary listing of all tasks
    |     showallthreads Display info about all threads in the system
    |     showallstacks  Display the stack for each thread in the system
    |     showcurrentthreads   Display info about the thread running on each cpu
    |     showcurrentstacks    Display the stack for the thread running on each cpu
    |     showallvm      Display a summary listing of all the vm maps
    |     showallvme     Display a summary listing of all the vm map entries
    |     showallipc     Display a summary listing of all the ipc spaces
    |     showipcsummary     Display a summary listing of the ipc spaces of all tasks
    |     showallrights  Display a summary listing of all the ipc rights
    |     showallkexts   Display a summary listing of all loaded kexts (alias: showallkmods)
    |     showallknownkexts   Display a summary listing of all kexts, loaded or not
    |     showallbusyports    Display a listing of all ports with unread messages
    |     showallprocessors   Display a listing of all psets and processors
    |
    |     showallclasses    Display info about all OSObject subclasses in the system
    |     showobject        Show info about an OSObject - its vtable ptr and retain count, & more info for simple container classes.
    |     showregistry      Show info about all registry entries in the current plane
    |     showregistryprops Show info about all registry entries in the current plane, and their properties
    |     showregistryentry Show info about a registry entry; its properties and descendants in the current plane
    |     setregistryplane  Set the plane to be used for the iokit registry macros (pass zero for list)
    |
    |     setfindregistrystr  Set the encoded string for matching with
    |                         findregistryentry or findregistryprop (created from
    |                         strcmp_arg_pack64)
    |     findregistryentry   Find a registry entry that matches the encoded string
    |     findregistryentries Find all the registry entries that match the encoded string
    |     findregistryprop    Search the registry entry for a property that matches
    |                         the encoded string
    |
    |     showtask       Display info about the specified task
    |     showtaskthreads      Display info about the threads in the task
    |     showtaskstacks Display the stack for each thread in the task
    |     showtaskvm     Display info about the specified task's vm_map
    |     showtaskvme    Display info about the task's vm_map entries
    |     showtaskipc    Display info about the specified task's ipc space
    |     showtaskrights Display info about the task's ipc space entries
    |     showtaskrightsbt Display info about the task's ipc space entries with back traces
    |     showtaskbusyports    Display all of the task's ports with unread messages
    |
    |     showact        Display info about a thread specified by activation
    |     showactstack   Display the stack for a thread specified by activation
    |
    |     showmap        Display info about the specified vm_map
    |     showmapvme     Display a summary list of the specified vm_map's entries
    |
    |     showipc        Display info about the specified ipc space
    |     showrights     Display a summary list of all the rights in an ipc space
    |
    |     showpid        Display info about the process identified by pid
    |     showproc       Display info about the process identified by proc struct
    |     showprocinfo   Display detailed info about the process identified by proc struct
    |     showprocfiles  Given a proc_t pointer, display the list of open file descriptors
    |     showproclocks  Given a proc_t pointer, display the list of advisory file locks
    |     zombproc       Print out all procs in the zombie list
    |     showproctree   Show all the processes in a hierarchical tree form
    |     allproc        Print out all process in the system not in the zombie list
    |     zombstacks     Print out all stacks of tasks that are exiting
    |
    |     showinitchild  Print out all processes in the system which are children of init process
    |
    |     showkext       Display info about a kext (alias: showkmod)
    |     showkextaddr   Given an address, display the kext and offset (alias: showkmodaddr)
    |
    |     dumpcallqueue  Dump out all the entries given a queue head
    |
   |     showallmtx     Display info about mutexes usage
   |     showallrwlck   Display info about reader/writer locks usage
   |
   |     zprint         Display info about the memory zones
   |     showioalloc    Display info about iokit allocations
   |     paniclog       Display the panic log info
   |
   |     switchtoact    Switch to different context specified by activation
   |     switchtoctx    Switch to different context
   |     showuserstack  Display numeric backtrace of the user stack for an 
   |                    activation
   |     showtaskuserstacks         Display user stacks for a specified task
   |     showuserregisters          Display user registers for the specified thread
   |     showtaskuserregisters              Display user registers for the specified task
   |
   |     switchtouserthread Switch to the user context of the specified thread
   |     resetstacks    Return to the original kernel context
   |
   |     resetctx       Reset context
   |     resume_on      Resume when detaching from gdb
   |     resume_off     Don't resume when detaching from gdb 
   |
   |     sendcore       Configure kernel to send a coredump to the specified IP
   |     sendsyslog     Configure kernel to send a system log to the specified IP
   |     sendpaniclog   Configure kernel to send a panic log to the specified IP
   |     disablecore    Configure the kernel to disable coredump transmission
   |     getdumpinfo    Retrieve the current remote dump parameters
   |     setdumpinfo    Configure the remote dump parameters
   |
   |     switchtocorethread Corefile version of "switchtoact"
   |     resetcorectx   Corefile version of "resetctx"
   |
   |     readphys8      Reads the specified untranslated address (8-bit read)
   |     readphys16     Reads the specified untranslated address (16-bit read)
   |     readphys32     Reads the specified untranslated address (32-bit read)
   |     readphys64     Reads the specified untranslated address (64-bit read)
   |     writephys8     Writes to the specified untranslated address (8-bit write)
   |     writephys16    Writes to the specified untranslated address (16-bit write)
   |     writephys32    Writes to the specified untranslated address (32-bit write)
   |     writephys64    Writes to the specified untranslated address (64-bit write)
   |
   |     readioport8    Read 8-bits from the specified I/O Port
   |     readioport16   Read 16-bits from the specified I/O Port
   |     readioport32   Read 32-bits from the specified I/O Port
   |     writeioport8   Write 8-bits into the specified I/O Port
   |     writeioport16  Write 16-bits into the specified I/O Port
   |     writeioport32  Write 32-bits into the specified I/O Port
   |
   |     readmsr64      Read 64-bits from the specified MSR
   |     writemsr64     Write 64-bits into the specified MSR
   |
   |     rtentry_showdbg Print the debug information of a route entry
   |     rtentry_trash  Walk the list of trash route entries
   |
   |     inifa_showdbg  Print the debug information of an IPv4 interface address
   |     in6ifa_showdbg Print the debug information of an IPv6 interface address
   |     inm_showdbg    Print the debug information of an IPv4 multicast address
   |     ifma_showdbg   Print the debug information of a link multicast address
   |     ifpref_showdbg Print the debug information of an interface ref count
   |
   |     ndpr_showdbg   Print the debug information of a nd_prefix structure
   |     nddr_showdbg   Print the debug information of a nd_defrouter structure
   |
   |     imo_showdbg    Print the debug information of a ip_moptions structure
   |     im6o_showdbg   Print the debug information of a ip6_moptions structure
   |
   |     inifa_trash    Walk the list of trash in_ifaddr entries
   |     in6ifa_trash   Walk the list of trash in6_ifaddr entries
   |     inm_trash      Walk the list of trash in_multi entries
   |     in6m_trash     Walk the list of trash in6_multi entries
   |     ifma_trash     Walk the list of trash ifmultiaddr entries
   |
   |     mbuf_walkpkt   Walk the mbuf packet chain (m_nextpkt)
   |     mbuf_walk      Walk the mbuf chain (m_next)
   |     mbuf_buf2slab  Find the slab structure of the corresponding buffer
   |     mbuf_buf2mca   Find the mcache audit structure of the corresponding mbuf
   |     mbuf_showmca   Print the contents of an mbuf mcache audit structure
   |     mbuf_showactive   Print all active/in-use mbuf objects
   |     mbuf_showinactive Print all freed/in-cache mbuf objects 
   |     mbuf_showall   Print all mbuf objects
   |     mbuf_slabs     Print all slabs in the group
   |     mbuf_slabstbl  Print slabs table
   |     mbuf_stat      Print extended mbuf allocator statistics
   |     mbuf_countchain   Count the length of an mbuf chain
   |     mbuf_topleak   Print the top suspected mbuf leakers
   |     mbuf_traceleak Print the leak information for a given leak address
   |
   |     mcache_walkobj     Walk the mcache object chain (obj_next)
   |     mcache_stat        Print all mcaches in the system
   |     mcache_showcache   Display the number of objects in the cache
   |
   |     showbootargs       Display boot arguments passed to the target kernel
   |     showbootermemorymap Dump phys memory map from EFI
   |
   |     systemlog          Display the kernel's printf ring buffer
   |
   |     hexdump            Show the contents of memory as a hex/ASCII dump
   |
   |     showvnodepath      Print the path for a vnode
   |     showvnodelocks     Display list of advisory locks held/blocked on a vnode
   |     showvnodedev       Display information about a device vnode
   |     showtty            Display information about a struct tty
   |     showallvols        Display a summary of mounted volumes
   |     showvnode          Display info about one vnode
   |     showvolvnodes      Display info about all vnodes of a given volume
   |     showvolbusyvnodes  Display info about busy (iocount!=0) vnodes of a given volume
   |     showallbusyvnodes  Display info about all busy (iocount!=0) vnodes
   |     showallvnodes      Display info about all vnodes
   |     print_vnode        Print out the fields of a vnode struct
   |     showprocvnodes     Print out all the open fds which are vnodes in a process
   |     showallprocvnodes  Print out all the open fds which are vnodes in any process
   |     showmountvnodes    Print the vnode list
   |     showmountallvnodes Print the vnode inactive list
   |     showworkqvnodes    Print the vnode worker list
   |     shownewvnodes      Print the new vnode list
   |
   |     ifconfig           display ifconfig-like output
   |     showifnets         show the list of attached and detached interfaces
   |     showifaddrs        show the list of addresses for the given ifp
   |     showifmultiaddrs   show the list of multicast addresses for the given ifp
   |     showinmultiaddrs   show the list of IPv4 multicast addresses records 
   |     showin6multiaddrs  show the list of IPv6 multicast addresses records
   |
   |     showsocket         Display information about a socket
   |     showprocsockets    Given a proc_t pointer, display information about its sockets
   |     showallprocsockets Display information about the sockets of all the processes
   |
   |     show_tcp_pcbinfo   Display the list of the TCP protocol control blocks
   |     show_tcp_timewaitslots Display the list of the TCP protocol control blocks in TIMEWAIT
   |     show_udp_pcbinfo   Display the list of UDP protocol control blocks
   |
   |     show_rt_inet       Display the IPv4 routing table
   |     show_rt_inet6      Display the IPv6 routing table
   |
   |     showpmworkqueue       Display the IOPMWorkQueue object
   |     showregistrypmstate   Display power management state for all IOPower registry entries
   |     showioservicepm       Display the IOServicePM object
   |     showstacksaftertask   showallstacks starting after a given task
   |     showstacksafterthread showallstacks starting after a given thread
   |
   |     showMCAstate      Print machine-check register state after MC exception.
   |
   |     showallgdbstacks  Cause GDB to trace all thread stacks
   |     showallgdbcorestacks Corefile equivalent of "showallgdbstacks"
   |     kdp-reenter       Schedule reentry into the debugger and continue.
   |     kdp-reboot        Restart remote target
   |     kdp-version       Get KDP version number
   |
   |     zstack            Print zalloc caller stack (zone leak debugging)
   |     findoldest        Find oldest zone leak debugging record
   |     countpcs          Print how often a pc occurs in the zone leak log
   |
   |     showtopztrace     Print the ztrace with the most outstanding allocated memory
   |     showztrace                Print a backtrace record given its index
   |     showzalloc            Print an allocation record + stacktrace at index
   |     showztraceaddr    Print a backtrace record given its address
   |     showztracesabove  Print all the backtrace records with a size bigger than X
   |     showzstacktrace   Symbolicate and print a stored OSBacktrace
   |     
   |     showztraces       Finds all in-use traces in the ztraces table
   |     showzallocs       Finds all in-use allocations in the zallocs table
   |     showzstats        Shows the statistics gathered about the hash tables
   |
   |     showzallocsfortrace   Print all the allocations that refer to a trace
   |     showztracehistogram   Prints a histogram of the ztraces table
   |     showzallochistogram   Prints a histogram of the zallocs table     
   |
   |     pmap_walk     Perform a page-table walk
   |     pmap_vtop     Translate a virtual address to physical address
   |
   |     showuserdyldinfo       Show dyld information and error messages
   |                            in the target task
   |     showuserlibraries      Show binary images known by dyld in the
   |                            target task
   |     showallvmstats    Prints a summary of vm statistics in a table format
   |     memstats                  Displays memory statistics in a table format
   |
   |     showthreadfortid  Displays the address of the thread structure
   |                       for a given thread_id value. 
   |     
   |     strcmp_nomalloc   A version of strcmp that avoids the use of malloc
   |                       through the use of encoded strings created via
   |                       strcmp_arg_pack64.
   |     strcmp_arg_pack64 Pack a string into a 64-bit quantity for use by
   |                       strcmp_nomalloc
   |
   |     pci_cfg_read8     Read 8-bits from a PCI config space register
   |     pci_cfg_read16    Read 16-bits from a PCI config space register
   |     pci_cfg_read32    Read 32-bits from a PCI config space register
   |     pci_cfg_write8    Write 8-bits into a PCI config space register
   |     pci_cfg_write16   Write 16-bits into a PCI config space register
   |     pci_cfg_write32   Write 32-bits into a PCI config space register
   |     pci_cfg_dump      Dump entire config space for a PCI device
   |     pci_cfg_scan      Perform a scan for PCI devices
   |     pci_cfg_dump_all  Dump config spaces for all detected PCI devices
   |
   |     lapic_read32      Read APIC entry
   |     lapic_write32     Write APIC entry
   |     lapic_dump        Dump APIC entries
   |
   |     ioapic_read32     Read IOAPIC entry
   |     ioapic_write32    Write IOAPIC entry
   |     ioapic_dump       Dump IOAPIC entries
   |
   |     showallproviders  Display summary listing of all dtrace_providers
   |     showallmodctls    Display summary listing of all dtrace modctls
   |     showmodctl        Display info about a dtrace modctl
   |     showfbtprobe      Display info about an fbt probe given an id (traverses fbt_probetab)
   |     processortimers   Display all processor timers, noting any inconsistencies
   |
   | Type "help <macro>" for more specific help on a particular macro.
   | Type "show user <macro>" to see what the macro is really doing.
   end
   
   # This macro should appear before any symbol references, to facilitate
   # a gdb "source" without a loaded symbol file.
   define showversion
       kdp-kernelversion
   end
   
   document showversion
   Syntax: showversion
   | Read the kernel version string from a fixed address in low
   | memory. Useful if you don't know which kernel is on the other end,
   | and need to find the appropriate symbols. Beware that if you've
   | loaded a symbol file, but aren't connected to a remote target,
   | the version string from the symbol file will be displayed instead.
   | This macro expects to be connected to the remote kernel to function
   | correctly.
   end
   
   set $kgm_mtype_ppc      = 0x00000012
   set $kgm_mtype_arm      = 0x0000000C
   
   set $kgm_mtype_i386     = 0x00000007
   set $kgm_mtype_x86_64   = 0x01000007
   set $kgm_mtype_x86_any  = $kgm_mtype_i386
   set $kgm_mtype_x86_mask = 0xFEFFFFFF
   
   set $kgm_mtype = ((unsigned int *)&_mh_execute_header)[1]
   set $kgm_lp64 = $kgm_mtype & 0x01000000
   
   set $kgm_manual_pkt_ppc    = 0x549C
   set $kgm_manual_pkt_i386   = 0x249C
   set $kgm_manual_pkt_x86_64 = 0xFFFFFF8000002930
   set $kgm_manual_pkt_arm    = 0xFFFF04A0
   
   set $kgm_kdp_pkt_data_len   = 128
   
   # part of data packet
   set $kgm_kdp_pkt_hdr_req_off = 0
   set $kgm_kdp_pkt_hdr_seq_off = 1
   set $kgm_kdp_pkt_hdr_len_off = 2
   set $kgm_kdp_pkt_hdr_key_off = 4
   
   # after data packet
   set $kgm_kdp_pkt_len_off     = $kgm_kdp_pkt_data_len
   set $kgm_kdp_pkt_input_off   = $kgm_kdp_pkt_data_len + 4
   
   set $kgm_kdp_pkt_hostreboot = 0x13
   set $kgm_kdp_pkt_hdr_size   = 8
   
   
   set $kgm_readphys_force_kdp     = 0
   set $kgm_readphys_force_physmap = 0
   
   set $kgm_lcpu_self      = 0xFFFE
   
   set $kgm_reg_depth = 0
   set $kgm_reg_depth_max = 0xFFFF
   set $kgm_reg_plane = (IORegistryPlane *) gIOServicePlane
   set $kgm_namekey = (OSSymbol *) 0
   set $kgm_childkey = (OSSymbol *) 0
   
   set $kgm_show_object_addrs = 0
   set $kgm_show_object_retain = 0
   set $kgm_show_props = 0
   set $kgm_show_data_alwaysbytes = 0
   
   set $kgm_show_kmod_syms = 0
   
   # send a manual packet header that doesn't require knowing the location
   # of everything.
   define manualhdrint
          set $req = $arg0
   
          set $hdrp = (uint32_t *) $kgm_manual_pkt_i386
          if ($kgm_mtype == $kgm_mtype_ppc)
             set $hdrp = (uint32_t *) $kgm_manual_pkt_ppc
             set $req = $req << 1 # shift to deal with endiannness
          end
          if ($kgm_mtype == $kgm_mtype_x86_64)
             set $hdrp = (uint64_t *) $kgm_manual_pkt_x86_64
          end
          if ($kgm_mtype == $kgm_mtype_arm)
             set $hdrp = (uint32_t *) $kgm_manual_pkt_arm
          end
   
          set $pkt_hdr = *$hdrp
          set *((uint8_t *) ($pkt_hdr + $kgm_kdp_pkt_input_off))    = 0
          set *((uint32_t *) ($pkt_hdr + $kgm_kdp_pkt_len_off))     = $kgm_kdp_pkt_hdr_size
   
          set *((uint8_t *) ($pkt_hdr + $kgm_kdp_pkt_hdr_req_off))  = $req
          set *((uint8_t *) ($pkt_hdr + $kgm_kdp_pkt_hdr_seq_off))  = 0
          set *((uint16_t *) ($pkt_hdr + $kgm_kdp_pkt_hdr_len_off)) = $kgm_kdp_pkt_hdr_size
          set *((uint32_t *) ($pkt_hdr + $kgm_kdp_pkt_hdr_key_off)) = 0
          set *((uint8_t *) ($pkt_hdr + $kgm_kdp_pkt_input_off))    = 1
   
          # dummy to make sure manual packet is executed
          set $kgm_dummy = &_mh_execute_header
   end
   
   # Print a pointer
   define showptr
       if $kgm_lp64
           printf "0x%016llx", $arg0
       else
           printf "0x%08x", $arg0
       end
   end
   
   # for headers, leave 8 chars for LP64 pointers
   define showptrhdrpad
       if $kgm_lp64
           printf "        "
       end
   end
   
   # Print a userspace pointer, using $kgm_tasp
   define showuserptr
       set $kgm_userptr_task_64 = ( $kgm_taskp->taskFeatures[0] & 0x80000000)
       if $kgm_userptr_task_64
           printf "0x%016llx", $arg0
       else
           printf "0x%08x", $arg0
       end
   end
   
   define showkmodheader
       printf   "kmod_info "
       showptrhdrpad
       printf "  address   "
       showptrhdrpad
       printf "  size      "
       showptrhdrpad
       printf "  id    refs     version  name\n"
   end
   
   define showkmodint
       set $kgm_kmodp = (struct kmod_info *)$arg0
       showptr $kgm_kmodp
       printf "  "
       showptr $kgm_kmodp->address
       printf "  "
       showptr $kgm_kmodp->size
       printf "  "
       printf "%3d  ", $kgm_kmodp->id
       printf "%5d  ", $kgm_kmodp->reference_count
       printf "%10s  ", $kgm_kmodp->version
       printf "%s\n", $kgm_kmodp->name
   end
   
   # cached info of the last kext found, to speed up subsequent lookups
   set $kgm_pkmod = 0
   set $kgm_pkmodst = 0
   set $kgm_pkmoden = 0
   
   define showkmodaddrint
       showptr $arg0
       if ((unsigned long)$arg0 >= (unsigned long)$kgm_pkmodst) && ((unsigned long)$arg0 < (unsigned long)$kgm_pkmoden)
           set $kgm_off = ((unsigned long)$arg0 - (unsigned long)$kgm_pkmodst)
           printf " <%s + 0x%x>", $kgm_pkmod->name, $kgm_off
       else
           set $kgm_kmodp = (struct kmod_info *)kmod
           if ($kgm_mtype == $kgm_mtype_x86_64) && ($arg0 >= (unsigned long)&_mh_execute_header)
               # kexts are loaded below the kernel for x86_64
               set $kgm_kmodp = 0
           end
           while $kgm_kmodp
               set $kgm_off = ((unsigned long)$arg0 - (unsigned long)$kgm_kmodp->address)
               if ($kgm_kmodp->address <= $arg0) && ($kgm_off < $kgm_kmodp->size)
                   printf " <%s + 0x%x>", $kgm_kmodp->name, $kgm_off
                   set $kgm_pkmod = $kgm_kmodp
                   set $kgm_pkmodst = $kgm_kmodp->address
                   set $kgm_pkmoden = $kgm_pkmodst + $kgm_kmodp->size
                   set $kgm_kmodp = 0
               else
                   set $kgm_kmodp = $kgm_kmodp->next
               end
           end
       end
   end
   
   define showkmodaddr
       showkmodaddrint $arg0
   end
   document showkmodaddr
   Syntax: (gdb) showkmodaddr <addr>
   | Given an address, print the offset and name for the kmod containing it
   end
   
   define showkmod
       showkmodheader
       showkmodint $arg0
   end
   document showkmod
   Syntax: (gdb) showkmod <kmod>
   | Routine to print info about a kext
   end
   
   define showkext
       showkmod $arg0
   end
   document showkext
   Syntax: (gdb) showkext <kmod_info_address>
   | Routine to print info about a kext
   end
   
   define showallkmods
       showkmodheader
       set $kgm_kmodp = (struct kmod_info *)kmod
       while $kgm_kmodp
           showkmodint $kgm_kmodp
           set $kgm_kmodp = $kgm_kmodp->next
       end
   end
   document showallkmods
   Syntax: (gdb) showallkmods
   | Routine to print a summary listing of all loaded kexts
   end
   
   define showallkexts
       showallkmods
   end
   document showallkexts
   Syntax: (gdb) showallkexts
   | Routine to print a summary listing of all loaded kexts
   end
   
   # See OSKextVersion.c for the C code this is based on
   #
   set $KGM_OSKEXT_VERS_MAJ_MULT   = 100000000
   set $KGM_OSKEXT_VERS_MIN_MULT   = 1000000
   set $KGM_OSKEXT_VERS_REV_MULT   = 10000
   set $KGM_OSKEXT_VERS_STAGE_MULT = 1000
   
   define printoskextversion
       set $vers_scratch = $arg0
   
       if ($vers_scratch == -1)
           printf "(invalid)"
       else
        
           set $vers_major =  $vers_scratch / $KGM_OSKEXT_VERS_MAJ_MULT
   
           set $vers_scratch = $vers_scratch - ($vers_major * $KGM_OSKEXT_VERS_MAJ_MULT)
           set $vers_minor = $vers_scratch / $KGM_OSKEXT_VERS_MIN_MULT
   
           set $vers_scratch = $vers_scratch - ( $vers_minor * $KGM_OSKEXT_VERS_MIN_MULT)
           set $vers_revision =  $vers_scratch / $KGM_OSKEXT_VERS_REV_MULT
   
           set $vers_scratch = $vers_scratch - ( $vers_revision * $KGM_OSKEXT_VERS_REV_MULT)
           set $vers_stage =  $vers_scratch / $KGM_OSKEXT_VERS_STAGE_MULT
   
           set $vers_scratch = $vers_scratch - ( $vers_stage * $KGM_OSKEXT_VERS_STAGE_MULT)
           set $vers_stagelevel =  $vers_scratch
   
           printf "%d.%d", $vers_major, $vers_minor
           if ($vers_revision > 0)
               printf ".%d", $vers_revision
           end
           
           if ($vers_stage == 1)
               printf "d"
           end
           if ($vers_stage == 3)
               printf "a"
           end
           if ($vers_stage == 5)
               printf "b"
           end
           if ($vers_stage == 7)
               printf "fc"
           end
           if ($vers_stage == 1 || $vers_stage == 3 || $vers_stage == 5 || $vers_stage == 7)
               printf "%d", $vers_stagelevel
           end
       end
   end
   
   define showallknownkexts
      set $kext_count = sKextsByID->count
      set $kext_index = 0
      printf "%d kexts in sKextsByID:\n", $kext_count
   
      printf "OSKext *    "
      showptrhdrpad
      printf "load_addr   "
      showptrhdrpad
      
      printf " id  name (version)\n"
   
      while $kext_index < $kext_count
          set $kext_id = sKextsByID->dictionary[$kext_index].key->string
          set $oskext = (OSKext *)sKextsByID->dictionary[$kext_index].value
   
          showptr $oskext
          printf "  "
   
          if ($oskext->flags.loaded)
              showptr $oskext->kmod_info
              printf "  "
              printf "%3d", $oskext->loadTag
          else
              showptrhdrpad
              printf " -------- "
              printf "  "
              printf " --"
           end
           printf "  "
   
          printf "%.64s (", $kext_id
          printoskextversion (uint64_t)$oskext->version
          printf ")\n"
          set $kext_index = $kext_index + 1
      end
   end
   document showallknownkexts
   Syntax: (gdb) showallknownkexts
   | Routine to print a summary listing of all kexts, loaded or not
   end
   
   define showactheader
       printf "          "
       showptrhdrpad
       printf "  thread    "
       showptrhdrpad
       printf "    thread_id "
       showptrhdrpad
       printf "  processor "
       showptrhdrpad
       printf "   pri io_policy   state    wait_queue"
       showptrhdrpad
       printf "  wait_event\n"
   end
   
   
   define showactint
           printf "            "
           showptrhdrpad
           set $kgm_thread = *(struct thread *)$arg0
           showptr $arg0
           if ($kgm_thread.static_param)
              printf "[WQ]"
           else
              printf "    "
           end
           printf "  0x%llx   ", $kgm_thread.thread_id
           showptr $kgm_thread.last_processor
           printf "   %3d ", $kgm_thread.sched_pri
           if ($kgm_thread.uthread != 0)
              set $kgm_printed = 0
              set $kgm_uthread = (struct uthread *)$kgm_thread.uthread
              if ($kgm_uthread->uu_flag & 0x400)
                 printf "RAGE "
              else
                 printf "     "
              end
              set $diskpolicy = 0
              if ($kgm_thread->ext_actionstate.hw_disk != 0)
                   set $diskpolicy = $kgm_thread->ext_actionstate.hw_disk
              else 
                   if ($kgm_thread->actionstate.hw_disk != 0)
                           set $diskpolicy = $kgm_thread->actionstate.hw_disk
                   end
              end
              if ($kgm_thread->ext_actionstate.hw_bg != 0)
                   set $diskpolicy = 5
              end
              if ($kgm_thread->actionstate.hw_bg != 0)
                   set $diskpolicy = 4
              end
              if ($diskpolicy == 2)
                 printf "PASS    "
                 set $kgm_printed = 1
              end
              if ($diskpolicy == 3)
                 printf "THROT   "
                 set $kgm_printed = 1
              end
              if ($diskpolicy == 4)
                 printf "BG_THRT "
                 set $kgm_printed = 1
              end
              if ($diskpolicy == 5)
                 printf "EBG_THRT"
                 set $kgm_printed = 1
              end
              if ($kgm_printed == 0)
                 printf "        "
              end
           end
           set $kgm_state = $kgm_thread.state
           if $kgm_state & 0x80
               printf "I" 
           end
           if $kgm_state & 0x40
               printf "P" 
           end
           if $kgm_state & 0x20
               printf "A" 
           end
           if $kgm_state & 0x10
               printf "H" 
           end
           if $kgm_state & 0x08
               printf "U" 
           end
           if $kgm_state & 0x04
               printf "R" 
           end
           if $kgm_state & 0x02
               printf "S" 
           end
           if $kgm_state & 0x01
               printf "W"
               printf "\t    " 
               showptr $kgm_thread.wait_queue
               printf "  "
                   if (((unsigned long)$kgm_thread.wait_event > (unsigned long)&last_kernel_symbol) \
                       && ($arg1 != 2) && ($kgm_show_kmod_syms == 0))
                           showkmodaddr $kgm_thread.wait_event
                   else
                           output /a $kgm_thread.wait_event
                   end
                   if ($kgm_thread.uthread != 0)
                       set $kgm_uthread = (struct uthread *)$kgm_thread.uthread
                       if ($kgm_uthread->uu_wmesg != 0)
                           printf "\t \"%s\"", $kgm_uthread->uu_wmesg
                       end
                   end
           end
           if ($kgm_thread.uthread != 0)
              set $kgm_uthread = (struct uthread *)$kgm_thread.uthread
              if ($kgm_uthread->pth_name && $kgm_uthread->pth_name[0])
                      printf "\n\t\tThread Name: %s", $kgm_uthread->pth_name
              end
           end
           if $arg1 != 0
               if ($kgm_thread.kernel_stack != 0)
                   if ($kgm_thread.uthread != 0)
                           printf "\n          "
                           set $kgm_uthread = (struct uthread *)$kgm_thread.uthread
                           if ($kgm_uthread->uu_kwe.kwe_kwqqueue != 0)
                                   set $kwq = (ksyn_wait_queue_t)$kgm_uthread->uu_kwe.kwe_kwqqueue
                                   printf "              kwq_lockcount:0x%x; kwq_retval:0x%x", $kgm_uthread->uu_kwe.kwe_lockseq, $kgm_uthread->uu_kwe.kwe_psynchretval
                                   printf "\n                "
                                   show_kwq $kwq
                                   printf "          "
                           end
                   end
                   if ($kgm_thread.reserved_stack != 0)
                           printf "\n          "
                           showptrhdrpad
                           printf "      reserved_stack="
                           showptr $kgm_thread.reserved_stack
                   end
                   printf "\n          "
                   showptrhdrpad
                   printf "      kernel_stack="
                   showptr $kgm_thread.kernel_stack
                   if ($kgm_mtype == $kgm_mtype_ppc)
                           set $mysp = $kgm_thread.machine.pcb->save_r1
                   end
                   if (($kgm_mtype & $kgm_mtype_x86_mask) == $kgm_mtype_x86_any)
                           set $kgm_statep = (struct x86_kernel_state *) \
                                   ($kgm_thread->kernel_stack + kernel_stack_size \
                                    - sizeof(struct x86_kernel_state))
                           if ($kgm_mtype == $kgm_mtype_i386)
                                   set $mysp = $kgm_statep->k_ebp
                           else
                                   set $mysp = $kgm_statep->k_rbp
                           end
                   end
                   if ($kgm_mtype == $kgm_mtype_arm)
                           if (((unsigned long)$r7 < ((unsigned long) ($kgm_thread->kernel_stack+kernel_stack_size))) \
                         && ((unsigned long)$r7 > (unsigned long) ($kgm_thread->kernel_stack)))
                                   set $mysp = $r7
                           else
                                   set $kgm_statep = (struct arm_saved_state *)$kgm_thread.machine.kstackptr
                                   set $mysp = $kgm_statep->r[7]
                           end
                   end
                   set $prevsp = $mysp - 16
                   printf "\n          "
                   showptrhdrpad
                   printf "      stacktop="
                   showptr $mysp
                   if ($kgm_mtype == $kgm_mtype_ppc)
                           set $stkmask = 0xf
                   else
                           set $stkmask = 0x3
                   end
                   set $kgm_return = 0
                   set $kgm_actint_framecount = 0
                   while ($mysp != 0) && (($mysp & $stkmask) == 0) \
                         && ($mysp != $prevsp) \
                         && ((((unsigned long) $mysp ^ (unsigned long) $prevsp) < 0x2000) \
                         || (((unsigned long)$mysp < ((unsigned long) ($kgm_thread->kernel_stack+kernel_stack_size))) \
                         && ((unsigned long)$mysp > (unsigned long) ($kgm_thread->kernel_stack)))) \
                         && ($kgm_actint_framecount < 128)
                           printf "\n          "
                           set $kgm_actint_framecount = $kgm_actint_framecount + 1
                           showptrhdrpad
                           printf "      "
                           showptr $mysp
                           printf "  "
                           if ($kgm_mtype == $kgm_mtype_ppc)
                                   set $kgm_return = *($mysp + 8)
                           end
                           if ($kgm_mtype == $kgm_mtype_i386)
                                   set $kgm_return = *($mysp + 4)
                           end
                           if ($kgm_mtype == $kgm_mtype_x86_64)
                                   set $kgm_return = *(unsigned long *)($mysp + 8)
                           end
                           if ($kgm_mtype == $kgm_mtype_arm)
                                   set $kgm_return = *($mysp + 4)
                           end
                           if (((unsigned long) $kgm_return < (unsigned long) &_mh_execute_header || \
                                (unsigned long) $kgm_return >= (unsigned long) &last_kernel_symbol ) \
                               && ($kgm_show_kmod_syms == 0))
                                   showkmodaddr $kgm_return
                           else
                                   output /a $kgm_return
                           end
                           set $prevsp = $mysp
                           set $mysp = *(unsigned long *)$mysp
                   end
                   set $kgm_return = 0
                   printf "\n          "
                   showptrhdrpad
                   printf "      stackbottom="
                   showptr $prevsp
               else
                   printf "\n          "
                   showptrhdrpad
                   printf "      continuation="
                   output /a $kgm_thread.continuation
               end
               printf "\n"
           else
               printf "\n"
           end
   end         
   
   define showact
       showactheader
       showactint $arg0 0
   end
   document showact
   Syntax: (gdb) showact <activation> 
   | Routine to print out the state of a specific thread.
   end
   
   
   define showactstack
       showactheader
       showactint $arg0 1
   end
   document showactstack
   Syntax: (gdb) showactstack <activation> 
   | Routine to print out the stack of a specific thread.
   end
   
   
   define showallthreads
       set $kgm_head_taskp = &tasks
       set $kgm_taskp = (struct task *)($kgm_head_taskp->next)
       while $kgm_taskp != $kgm_head_taskp
           showtaskheader
           showtaskint $kgm_taskp
           showactheader
           set $kgm_head_actp = &($kgm_taskp->threads)
           set $kgm_actp = (struct thread *)($kgm_taskp->threads.next)
           while $kgm_actp != $kgm_head_actp
               showactint $kgm_actp 0
               set $kgm_actp = (struct thread *)($kgm_actp->task_threads.next)
           end
           printf "\n"
           set $kgm_taskp = (struct task *)($kgm_taskp->tasks.next)
       end
   end
   document showallthreads
   Syntax: (gdb) showallthreads
   | Routine to print out info about all threads in the system.
   end
   
   define showprocessorint
       set $kgm_processor_int = (struct processor *)$arg0
       printf "Processor "
       showptr $kgm_processor_int
       printf " State %d (cpu_id 0x%x)\n", ($kgm_processor_int)->state, ($kgm_processor_int)->cpu_id
   end
   
   define showcurrentthreads
       set $kgm_prp = (struct processor *)processor_list
       while $kgm_prp != 0
           showprocessorint $kgm_prp
           if ($kgm_prp)->active_thread != 0
               set $kgm_actp = ($kgm_prp)->active_thread
               showtaskheader
               showtaskint ($kgm_actp)->task
               showactheader
               showactint $kgm_actp 0
               printf "\n"
           end
           set $kgm_prp = ($kgm_prp)->processor_list
       end
   end
   document showcurrentthreads
   Syntax: (gdb) showcurrentthreads
   | Routine to print out info about the thread running on each cpu.
   end
   
   
   define _showrunqint
           set $kgm_runq = (struct run_queue *)$arg0
           
           printf "    Priority Run Queue Info: Count %d\n", $kgm_runq->count
           set $kgm_runq_queue_i = 0
           set $kgm_runq_queue_count = sizeof($kgm_runq->queues)/sizeof($kgm_runq->queues[0])
           while $kgm_runq->count && $kgm_runq_queue_i < $kgm_runq_queue_count
                   set $kgm_runq_queue_head = &$kgm_runq->queues[$kgm_runq_queue_i]
                   set $kgm_runq_queue_p = $kgm_runq_queue_head->next
                   if $kgm_runq_queue_p != $kgm_runq_queue_head
                           set $kgm_runq_queue_this_count = 0
                           while $kgm_runq_queue_p != $kgm_runq_queue_head
                                   set $kgm_runq_queue_this_count = $kgm_runq_queue_this_count + 1
                                   showtask ((thread_t)$kgm_runq_queue_p)->task
                                   showactstack $kgm_runq_queue_p
                                   set $kgm_runq_queue_p = $kgm_runq_queue_p->next
                           end
                           printf "      Queue Priority %3d [", $kgm_runq_queue_i
                           showptr $kgm_runq_queue_head
                           printf "] Count %d\n", $kgm_runq_queue_this_count
                   end
                   set $kgm_runq_queue_i = $kgm_runq_queue_i + 1
           end
   
   end
   
   define _showgrrrint
           set $kgm_grrr_runq = $arg0
           
           printf "    GRRR Info: Count %d Weight %d Current Group ", $kgm_grrr_runq->count, $kgm_grrr_runq->weight
           showptr $kgm_grrr_runq->current_group
           printf "\n"
           set $kgm_grrr_group_i = 0
           set $kgm_grrr_group_count = sizeof($kgm_grrr_runq->groups)/sizeof($kgm_grrr_runq->groups[0])
           while $kgm_grrr_runq->count && $kgm_grrr_group_i < $kgm_grrr_group_count
                   set $kgm_grrr_group = &$kgm_grrr_runq->groups[$kgm_grrr_group_i]
                   if $kgm_grrr_group->count > 0
                           printf "      Group %3d [", $kgm_grrr_group->index
                           showptr $kgm_grrr_group
                           printf "] Count %d Weight %d\n", $kgm_grrr_group->count, $kgm_grrr_group->weight
                           set $kgm_grrr_group_client_head = &$kgm_grrr_group->clients
                           set $kgm_grrr_group_client = $kgm_grrr_group_client_head->next
                           while $kgm_grrr_group_client != $kgm_grrr_group_client_head
                                   # showtask ((thread_t)$kgm_grrr_group_client)->task
                                   # showactstack $kgm_grrr_group_client
                                   set $kgm_grrr_group_client = $kgm_grrr_group_client->next
                           end
                   end
                   set $kgm_grrr_group_i = $kgm_grrr_group_i + 1
           end
   end
   
   define showallprocessors
           set $kgm_pset = &pset0
   
           set $kgm_show_grrr = 0
           set $kgm_show_priority_runq = 0
           set $kgm_show_priority_pset_runq = 0
           set $kgm_show_fairshare_grrr = 0
           set $kgm_show_fairshare_list = 0
   
           if _sched_enum == 1
                   set $kgm_show_priority_runq = 1
                   set $kgm_show_fairshare_list = 1
           end
           if _sched_enum == 2
                   set $kgm_show_priority_pset_runq = 1
                   set $kgm_show_fairshare_list = 1
           end
           if _sched_enum == 4
                   set $kgm_show_grrr = 1
                   set $kgm_show_fairshare_grrr = 1
           end
           if _sched_enum == 5
                  set $kgm_show_priority_runq = 1
                  set $kgm_show_fairshare_list = 1
          end
          if _sched_enum == 6
                  set $kgm_show_priority_pset_runq = 1
                  set $kgm_show_fairshare_list = 1
          end
  
          while $kgm_pset != 0
                  printf "Processor Set "
                  showptr $kgm_pset
                  printf " Count %d (cpu_id 0x%x-0x%x)\n", ($kgm_pset)->cpu_set_count, ($kgm_pset)->cpu_set_low, ($kgm_pset)->cpu_set_hi
                  printf "  Active Processors:\n"
                  set $kgm_active_queue_head = &($kgm_pset)->active_queue
                  set $kgm_active_elt = $kgm_active_queue_head->next
                  while $kgm_active_elt != $kgm_active_queue_head
                          set $kgm_processor = (processor_t)$kgm_active_elt
                          printf "    "
                          showprocessorint $kgm_processor
  
                          if $kgm_show_priority_runq
                                  set $kgm_runq = &$kgm_processor->runq
                                  _showrunqint $kgm_runq
                          end
                          if $kgm_show_grrr
                                  set $kgm_grrr_runq = &$kgm_processor->grrr_runq
                                  _showgrrrint $kgm_grrr_runq
                          end
                          
                          if $kgm_processor->processor_meta != 0 && $kgm_processor->processor_meta->primary == $kgm_processor
                                  set $kgm_processor_meta_idle_head = &$kgm_processor->processor_meta->idle_queue
                                  set $kgm_processor_meta_idle = $kgm_processor_meta_idle_head->next
                                  while $kgm_processor_meta_idle != $kgm_processor_meta_idle_head
                                          printf "      Idle Meta Processor: "
                                          showprocessorint $kgm_processor_meta_idle
                                          set $kgm_processor_meta_idle = $kgm_processor_meta_idle->next
                                  end
                          end
                          
                          set $kgm_active_elt = $kgm_active_elt->next
                  end
                  printf "  Idle Processors:\n"
                  set $kgm_idle_queue_head = &($kgm_pset)->idle_queue
                  set $kgm_idle_elt = $kgm_idle_queue_head->next
                  while $kgm_idle_elt != $kgm_idle_queue_head
                          set $kgm_processor = (processor_t)$kgm_idle_elt
                          printf "    "
                          showprocessorint $kgm_processor
                          
                          if $kgm_processor->processor_meta != 0 && $kgm_processor->processor_meta->primary == $kgm_processor
                                  set $kgm_processor_meta_idle_head = &$kgm_processor->processor_meta->idle_queue
                                  set $kgm_processor_meta_idle = $kgm_processor_meta_idle_head->next
                                  while $kgm_processor_meta_idle != $kgm_processor_meta_idle_head
                                          printf "      Idle Meta Processor: "
                                          showprocessorint $kgm_processor_meta_idle
                                          set $kgm_processor_meta_idle = $kgm_processor_meta_idle->next
                                  end
                          end
  
                          set $kgm_idle_elt = $kgm_idle_elt->next
                  end
  
                  if $kgm_show_priority_pset_runq
                          set $kgm_runq = &$kgm_pset->pset_runq
                          printf "\n"
                          _showrunqint $kgm_runq
                  end
                  set $kgm_pset = ($kgm_pset)->pset_list
          end
          
          printf "\n"
          printf "Realtime Queue Count %d\n", rt_runq.count
          set $kgm_rt_runq_head = &rt_runq.queue
          set $kgm_rt_runq = $kgm_rt_runq_head->next
          while $kgm_rt_runq != $kgm_rt_runq_head
                  showtask ((thread_t)$kgm_rt_runq)->task
                  showact $kgm_rt_runq
                  set $kgm_rt_runq = $kgm_rt_runq->next
          end
          
          printf "\n"
          if $kgm_show_fairshare_list
                  printf "Fair Share Queue Count %d\n", fs_runq.count
                  set $kgm_fs_runq_head = &fs_runq.queue
                  set $kgm_fs_runq = $kgm_fs_runq_head->next
                  while $kgm_fs_runq != $kgm_fs_runq_head
                          showtask ((thread_t)$kgm_fs_runq)->task
                          showact $kgm_fs_runq
                          set $kgm_fs_runq = $kgm_fs_runq->next
                  end
          end
          if $kgm_show_fairshare_grrr
                  printf "Fair Share Queue Count %d\n", fs_grrr_runq.count
                  set $kgm_fs_grrr = &fs_grrr_runq
                  _showgrrrint $kgm_fs_grrr
          end
  end
  document showallprocessors
  Syntax: (gdb) showallprocessors
  | Routine to print out info about all psets and processors
  end
  
  set $decode_wait_events = 0
  define showallstacks
      set $kgm_head_taskp = &tasks
      set $kgm_taskp = (struct task *)($kgm_head_taskp->next)
      while $kgm_taskp != $kgm_head_taskp
          showtaskheader
          showtaskint $kgm_taskp
          set $kgm_head_actp = &($kgm_taskp->threads)
          set $kgm_actp = (struct thread *)($kgm_taskp->threads.next)
          while $kgm_actp != $kgm_head_actp
              showactheader
              if ($decode_wait_events > 0)
                 showactint $kgm_actp 1
              else
                 showactint $kgm_actp 2
              end
              set $kgm_actp = (struct thread *)($kgm_actp->task_threads.next)
          end
          printf "\n"
          set $kgm_taskp = (struct task *)($kgm_taskp->tasks.next)
      end
  
      printf "\nZombie Processes:\n" 
      zombstacks
  end
  
  document showallstacks
  Syntax: (gdb) showallstacks
  | Routine to print out the stack for each thread in the system.
  | If the variable $decode_wait_events is non-zero, the routine attempts to
  | interpret thread wait_events as kernel module offsets, which can add to
  | processing time.
  end
  
  define showcurrentstacks
      set $kgm_prp = processor_list
      while $kgm_prp != 0
          showprocessorint $kgm_prp
          if ($kgm_prp)->active_thread != 0
              set $kgm_actp = ($kgm_prp)->active_thread
              showtaskheader
              showtaskint ($kgm_actp)->task
              showactheader
              showactint $kgm_actp 1
              printf "\n"
          end
          set $kgm_prp = ($kgm_prp)->processor_list
      end
  end
  
  document showcurrentstacks
  Syntax: (gdb) showcurrentstacks
  | Routine to print out the thread running on each cpu (incl. its stack)
  end
  
  define showwaiterheader
      printf "waiters     thread      "
      printf "processor   pri  state  wait_queue  wait_event\n"
  end
  
  define showwaitqwaiters
      set $kgm_w_waitqp = (WaitQueue*)$arg0
      set $kgm_w_linksp = &($kgm_w_waitqp->wq_queue)
      set $kgm_w_wqe = (WaitQueueElement *)$kgm_w_linksp->next
      set $kgm_w_found = 0
      while ( (queue_entry_t)$kgm_w_wqe != (queue_entry_t)$kgm_w_linksp)
          if ($kgm_w_wqe->wqe_type != &_wait_queue_link)
                  if !$kgm_w_found
                          set $kgm_w_found = 1
                          showwaiterheader
                  end
                  set $kgm_w_shuttle = (struct thread *)$kgm_w_wqe
                  showactint $kgm_w_shuttle 0
          end     
          set $kgm_w_wqe = (WaitQueueElement *)$kgm_w_wqe->wqe_links.next
      end
  end
  
  define showwaitqwaitercount
      set $kgm_wc_waitqp = (WaitQueue*)$arg0
      set $kgm_wc_linksp = &($kgm_wc_waitqp->wq_queue)
      set $kgm_wc_wqe = (WaitQueueElement *)$kgm_wc_linksp->next
      set $kgm_wc_count = 0
      while ( (queue_entry_t)$kgm_wc_wqe != (queue_entry_t)$kgm_wc_linksp)
          if ($kgm_wc_wqe->wqe_type != &_wait_queue_link)
                  set $kgm_wc_count = $kgm_wc_count + 1
          end
          set $kgm_wc_wqe = (WaitQueueElement *)$kgm_wc_wqe->wqe_links.next
      end
      printf "0x%08x  ", $kgm_wc_count
  end
  
  define showwaitqmembercount
      set $kgm_mc_waitqsetp = (WaitQueueSet*)$arg0
      set $kgm_mc_setlinksp = &($kgm_mc_waitqsetp->wqs_setlinks)
      set $kgm_mc_wql = (WaitQueueLink *)$kgm_mc_setlinksp->next
      set $kgm_mc_count = 0
      while ( (queue_entry_t)$kgm_mc_wql != (queue_entry_t)$kgm_mc_setlinksp)
          set $kgm_mc_count = $kgm_mc_count + 1
          set $kgm_mc_wql = (WaitQueueLink *)$kgm_mc_wql->wql_setlinks.next
      end
      printf "0x%08x  ", $kgm_mc_count
  end
  
      
  define showwaitqmemberheader
      printf "set-members wait_queue  interlock   "
      printf "pol  type   member_cnt  waiter_cnt\n"
  end
  
  define showwaitqmemberint
      set $kgm_m_waitqp = (WaitQueue*)$arg0
      printf "            0x%08x  ", $kgm_m_waitqp
      printf "0x%08x  ", $kgm_m_waitqp->wq_interlock.lock_data
      if ($kgm_m_waitqp->wq_fifo)
          printf "Fifo "
      else
          printf "Prio "
      end
      if ($kgm_m_waitqp->wq_type == 0xf1d1)
          printf "Set    "
          showwaitqmembercount $kgm_m_waitqp
      else
          printf "Que    0x00000000  "
      end
      showwaitqwaitercount $kgm_m_waitqp
      printf "\n"
  end
  
  
  define showwaitqmemberofheader
      printf "member-of   wait_queue  interlock   "
      printf "pol  type   member_cnt  waiter_cnt\n"
  end
  
  define showwaitqmemberof
      set $kgm_mo_waitqp = (WaitQueue*)$arg0
      set $kgm_mo_linksp = &($kgm_mo_waitqp->wq_queue)
      set $kgm_mo_wqe = (WaitQueueElement *)$kgm_mo_linksp->next
      set $kgm_mo_found = 0
      while ( (queue_entry_t)$kgm_mo_wqe != (queue_entry_t)$kgm_mo_linksp)
          if ($kgm_mo_wqe->wqe_type == &_wait_queue_link)
                  if !$kgm_mo_found
                          set $kgm_mo_found = 1
                          showwaitqmemberofheader
                  end
                  set $kgm_mo_wqlp = (WaitQueueLink *)$kgm_mo_wqe
                  set $kgm_mo_wqsetp = (WaitQueue*)($kgm_mo_wqlp->wql_setqueue)
                  showwaitqmemberint $kgm_mo_wqsetp
          end     
          set $kgm_mo_wqe = (WaitQueueElement *)$kgm_mo_wqe->wqe_links.next
      end
  end
  
  define showwaitqmembers
      set $kgm_ms_waitqsetp = (WaitQueueSet*)$arg0
      set $kgm_ms_setlinksp = &($kgm_ms_waitqsetp->wqs_setlinks)
      set $kgm_ms_wql = (WaitQueueLink *)$kgm_ms_setlinksp->next
      set $kgm_ms_found = 0
      while ( (queue_entry_t)$kgm_ms_wql != (queue_entry_t)$kgm_ms_setlinksp)
          set $kgm_ms_waitqp = $kgm_ms_wql->wql_element.wqe_queue
          if !$kgm_ms_found  
              showwaitqmemberheader
              set $kgm_ms_found = 1
          end
          showwaitqmemberint $kgm_ms_waitqp
          set $kgm_ms_wql = (WaitQueueLink *)$kgm_ms_wql->wql_setlinks.next
      end
  end
  
  define showwaitqheader
      printf "wait_queue  ref_count   interlock   "
      printf "pol  type   member_cnt  waiter_cnt\n"
  end
  
  define showwaitqint
      set $kgm_waitqp = (WaitQueue*)$arg0
      printf "0x%08x  ", $kgm_waitqp
      if ($kgm_waitqp->wq_type == 0xf1d1)
          printf "0x%08x  ", ((WaitQueueSet*)$kgm_waitqp)->wqs_refcount
      else
          printf "0x00000000  "
      end
      printf "0x%08x  ", $kgm_waitqp->wq_interlock.lock_data
      if ($kgm_waitqp->wq_fifo)
          printf "Fifo "
      else
          printf "Prio "
      end
      if ($kgm_waitqp->wq_type == 0xf1d1)
          printf "Set    "
          showwaitqmembercount $kgm_waitqp
      else
          printf "Que    0x00000000  "
      end
      showwaitqwaitercount $kgm_waitqp
      printf "\n"
  end
  
  define showwaitq
      set $kgm_waitq1p = (WaitQueue*)$arg0
      showwaitqheader
      showwaitqint $kgm_waitq1p   
      if ($kgm_waitq1p->wq_type == 0xf1d1)
          showwaitqmembers $kgm_waitq1p
      else
          showwaitqmemberof $kgm_waitq1p
      end
      showwaitqwaiters $kgm_waitq1p
  end
  
  define showmapheader
      printf "vm_map    "
      showptrhdrpad
      printf "  pmap      "
      showptrhdrpad
      printf "  vm_size   "
      showptrhdrpad
      printf " #ents rpage  hint      "
      showptrhdrpad
      printf "  first_free\n"
  end
  
  define showvmeheader
      printf "    entry     "
      showptrhdrpad
      printf "  start               prot  #page  object    "
      showptrhdrpad
      printf "  offset\n"
  end
  
  define showvmint
      set $kgm_mapp = (vm_map_t)$arg0
      set $kgm_map = *$kgm_mapp
      showptr $arg0
      printf "  "
      showptr $kgm_map.pmap
      printf "  "
      showptr $kgm_map.size
      printf "   %3d ", $kgm_map.hdr.nentries
      if $kgm_map.pmap
          printf "%5d  ", $kgm_map.pmap->stats.resident_count
      else
          printf "<n/a>  "
      end
      showptr $kgm_map.hint
      printf "  "
      showptr $kgm_map.first_free
      printf "\n"
      if $arg1 != 0
          showvmeheader   
          set $kgm_head_vmep = &($kgm_mapp->hdr.links)
          set $kgm_vmep = $kgm_map.hdr.links.next
          while (($kgm_vmep != 0) && ($kgm_vmep != $kgm_head_vmep))
              set $kgm_vme = *$kgm_vmep
              printf "    "
              showptr $kgm_vmep
              printf "  0x%016llx  ", $kgm_vme.links.start
              printf "%1x", $kgm_vme.protection
              printf "%1x", $kgm_vme.max_protection
              if $kgm_vme.inheritance == 0x0
                  printf "S"
              end
              if $kgm_vme.inheritance == 0x1
                  printf "C"
              end
              if $kgm_vme.inheritance == 0x2
                  printf "-"
              end
              if $kgm_vme.inheritance == 0x3
                  printf "D"
              end
              if $kgm_vme.is_sub_map
                  printf "s "
              else
                  if $kgm_vme.needs_copy
                      printf "n "
                  else
                      printf "  "
                  end
              end
              printf "%6d  ",($kgm_vme.links.end - $kgm_vme.links.start) >> 12
              showptr $kgm_vme.object.vm_object
              printf "  0x%016llx\n", $kgm_vme.offset
              set $kgm_vmep = $kgm_vme.links.next
          end
      end
      printf "\n"
  end
  
  
  define showmapwiredp
      set $kgm_mapp = (vm_map_t)$arg0
      set $kgm_map = *$kgm_mapp
      set $kgm_head_vmep = &($kgm_mapp->hdr.links)
      set $kgm_vmep = $kgm_map.hdr.links.next
      set $kgm_objp_prev = (struct vm_object *)0
      if $arg1 == 0
          set $kgm_saw_kernel_obj = 0
          set $kgm_wired_count = 0
          set $kgm_objp_print_space = 1
      else
          set $kgm_objp_print_space = 0
      end
      while (($kgm_vmep != 0) && ($kgm_vmep != $kgm_head_vmep))
          set $kgm_vme = *$kgm_vmep
          set $kgm_objp = $kgm_vme.object.vm_object
          if $kgm_vme.is_sub_map
              if $arg1 == 0
                  set $kgm_mapp_orig = $kgm_mapp
                  set $kgm_vmep_orig = $kgm_vmep
                  set $kgm_vme_orig = $kgm_vme
                  set $kgm_head_vmep_orig = $kgm_head_vmep
                  printf "\n****"
                  showptr $kgm_objp
                  showmapwiredp $kgm_objp 1
                  set $kgm_vme = $kgm_vme_orig
                  set $kgm_vmep = $kgm_vmep_orig
                  set $kgm_mapp = $kgm_mapp_orig
                  set $kgm_head_vmep = $kgm_head_vmep_orig
                  set $kgm_objp = (struct vm_object *)0
              else
                  printf "\n????"     
                  showptr $kgm_mapp
                  printf "    "
                  showptr $kgm_vmep
                  set $kgm_objp = (struct vm_object *)0
                  printf "\n"
              end
          end
          if ($kgm_objp == $kgm_objp_prev)
              set $kgm_objp = (struct vm_object *)0
          end
          if $kgm_objp == kernel_object
             if $kgm_saw_kernel_obj
                 set $kgm_objp = (struct vm_object *)0
             end
             set $kgm_saw_kernel_obj = 1
          end
          if $kgm_objp && $kgm_objp->wired_page_count
              if $kgm_objp_print_space == 1
                  printf "    "
                  showptr $kgm_mapp
              end
              set $kgm_objp_print_space = 1
              printf "    "
              showptr $kgm_vmep
              printf "  0x%016llx  ", $kgm_vme.links.start
              printf "%5d", $kgm_vme.alias
              printf "%6d  ",($kgm_vme.links.end - $kgm_vme.links.start) >> 12
              showptr $kgm_objp
              printf "[%3d]", $kgm_objp->ref_count
              printf "%7d\n", $kgm_objp->wired_page_count
              set $kgm_wired_count = $kgm_wired_count + $kgm_objp->wired_page_count
              set $kgm_objp_prev = $kgm_objp
          end
          set $kgm_vmep = $kgm_vme.links.next
      end
      if $arg1 == 0
          printf "total wired count = %d\n", $kgm_wired_count
      end
  end
  
  define showmapwired
      printf "    map       "
      showptrhdrpad
      printf "    entry     "
      showptrhdrpad
      printf "  start               alias  #page  object    "
      showptrhdrpad
      printf "       wired\n"
      showmapwiredp $arg0 0
  end
  document showmapwired
  Syntax: (gdb) showmapwired <vm_map>
  | Routine to print out a summary listing of all the entries with wired pages in a vm_map
  end
  
  define showmapvme
          showmapheader
          showvmint $arg0 1
  end
  document showmapvme
  Syntax: (gdb) showmapvme <vm_map>
  | Routine to print out a summary listing of all the entries in a vm_map
  end
  
  
  define showmap
          showmapheader
          showvmint $arg0 0
  end
  document showmap
  Syntax: (gdb) showmap <vm_map>
  | Routine to print out info about the specified vm_map
  end
  
  define showallvm
      set $kgm_head_taskp = &tasks
      set $kgm_taskp = (struct task *)($kgm_head_taskp->next)
      while $kgm_taskp != $kgm_head_taskp
          showtaskheader
          showmapheader
          showtaskint $kgm_taskp
          showvmint $kgm_taskp->map 0
          set $kgm_taskp = (struct task *)($kgm_taskp->tasks.next)
      end
  end
  document showallvm
  Syntax: (gdb) showallvm
  | Routine to print a summary listing of all the vm maps
  end
  
  
  define showallvme
      set $kgm_head_taskp = &tasks
      set $kgm_taskp = (struct task *)($kgm_head_taskp->next)
      while $kgm_taskp != $kgm_head_taskp
          showtaskheader
          showmapheader
          showtaskint $kgm_taskp
          showvmint $kgm_taskp->map 1
          set $kgm_taskp = (struct task *)($kgm_taskp->tasks.next)
      end
  end
  document showallvme
  Syntax: (gdb) showallvme
  | Routine to print a summary listing of all the vm map entries
  end
  
  
  define showipcheader
      printf "ipc_space "
      showptrhdrpad
      printf "  is_table  "
      showptrhdrpad
      printf "  table_next"
      showptrhdrpad
      printf " flags ports  splaysize   "
      showptrhdrpad
      printf "splaybase\n"
  end
  
  define showipceheader
      printf "            "
      showptrhdrpad
      printf "object      "
      showptrhdrpad
      showptrhdrpad
      printf "name        rite urefs  destname    "
      showptrhdrpad
      printf "destination\n"
  end
  
  define showipceint
      set $kgm_ie = *(ipc_entry_t)$arg0
      printf "            "
      showptrhdrpad
      showptr $kgm_ie.ie_object
      showptrhdrpad
      printf "  0x%08x  ", $arg1
      if $kgm_ie.ie_bits & 0x00100000
          printf "Dead "
          printf "%5d\n", $kgm_ie.ie_bits & 0xffff
      else
          if $kgm_ie.ie_bits & 0x00080000
              printf "SET  "
              printf "%5d\n", $kgm_ie.ie_bits & 0xffff
          else
              if $kgm_ie.ie_bits & 0x00010000
                  if $kgm_ie.ie_bits & 0x00020000
                      printf " SR"
                  else
                      printf "  S"
                  end
              else
                  if $kgm_ie.ie_bits & 0x00020000
                     printf "  R"
                  end
              end
              if $kgm_ie.ie_bits & 0x00040000
                  printf "  O"
              end
              if $kgm_ie.index.request
                  set $kgm_port = (ipc_port_t)$kgm_ie.ie_object
                  set $kgm_requests = $kgm_port->ip_requests
                  set $kgm_req_soright = $kgm_requests[$kgm_ie.index.request].notify.port
                  if $kgm_req_soright
  #                   Armed send-possible notification?
                      if (uintptr_t)$kgm_req_soright & 0x1
                          printf "s"
                      else
  #                       Delayed send-possible notification?
                          if (uintptr_t)$kgm_req_soright & 0x2
                              printf "d"
                          else
  #                           Dead-name notification
                              printf "n"
                          end
                      end     
                  else
                      printf " "
                  end
              else
                  printf " "
              end
  #           Collision (with tree)?
              if $kgm_ie.ie_bits & 0x00800000
                  printf "c"
              else
                  printf " "
              end
              printf "%5d  ", $kgm_ie.ie_bits & 0xffff
              showportdest $kgm_ie.ie_object
          end
      end
  end
  
  define showipcint
      set $kgm_isp = (ipc_space_t)$arg0
      set $kgm_is = *$kgm_isp
      showptr $arg0
      printf "  "
      showptr $kgm_is.is_table
      printf "  "
      showptr $kgm_is.is_table_next
      printf "  "
      if $kgm_is.is_growing != 0
          printf "G"
      else
          printf " "
      end
      if $kgm_is.is_fast != 0
          printf "F"
      else
          printf " "
      end
      if $kgm_is.is_active != 0
          printf "A  "
      else
          printf "   "
      end
      printf "%5d  ", $kgm_is.is_table_size + $kgm_is.is_tree_total
      showptr $kgm_is.is_tree_total
      printf "  "
      showptr &$kgm_isp->is_tree
      printf "\n"
      if $arg1 != 0
          showipceheader
          set $kgm_iindex = 0
          set $kgm_iep = $kgm_is.is_table
          set $kgm_destspacep = (ipc_space_t)0
          while ( $kgm_iindex < $kgm_is.is_table_size )
              set $kgm_ie = *$kgm_iep
              if $kgm_ie.ie_bits & 0x001f0000
                  set $kgm_name = (($kgm_iindex << 8)|($kgm_ie.ie_bits >> 24))
                  showipceint $kgm_iep $kgm_name
                  if $arg2 != 0
                     if $kgm_ie.ie_object != 0 && ($kgm_ie.ie_bits & 0x00070000) && ((ipc_port_t) $kgm_ie.ie_object)->ip_callstack[0] != 0
                          printf "              user bt: "
                          showportbt $kgm_ie.ie_object $kgm_is.is_task
                     end
                  end
              end
              set $kgm_iindex = $kgm_iindex + 1
              set $kgm_iep = &($kgm_is.is_table[$kgm_iindex])
          end
          if $kgm_is.is_tree_total
              printf "Still need to write tree traversal\n"
          end
      end
      printf "\n"
  end
  
  
  define showipc
      set $kgm_isp = (ipc_space_t)$arg0
      showipcheader
      showipcint $kgm_isp 0 0
  end
  document showipc
  Syntax: (gdb) showipc <ipc_space>
  | Routine to print the status of the specified ipc space
  end
  
  define showrights
          set $kgm_isp = (ipc_space_t)$arg0
      showipcheader
          showipcint $kgm_isp 1 0
  end
  document showrights
  Syntax: (gdb) showrights <ipc_space>
  | Routine to print a summary list of all the rights in a specified ipc space
  end
  
  
  define showtaskipc
          set $kgm_taskp = (task_t)$arg0
          showtaskheader
          showtaskint $kgm_taskp
          showipcheader
          showipcint $kgm_taskp->itk_space 0 0
  end
  document showtaskipc
  Syntax: (gdb) showtaskipc <task>
  | Routine to print info about the ipc space for a task
  end
  
  
  define showtaskrights
          set $kgm_taskp = (task_t)$arg0
          showtaskheader
          showtaskint $kgm_taskp
          showipcheader
          showipcint $kgm_taskp->itk_space 1 0
  end
  document showtaskrights
  Syntax: (gdb) showtaskrights <task>
  | Routine to print info about the ipc rights for a task
  end
  
  define showtaskrightsbt
          set $kgm_taskp = (task_t)$arg0
          showtaskheader
          showtaskint $kgm_taskp
          showipcheader
          showipcint $kgm_taskp->itk_space 1 1
  end
  document showtaskrightsbt
  Syntax: (gdb) showtaskrightsbt <task>
  | Routine to print info about the ipc rights for a task with backtraces
  end
  
  define showallipc
      set $kgm_head_taskp = &tasks
      set $kgm_cur_taskp = (struct task *)($kgm_head_taskp->next)
      while $kgm_cur_taskp != $kgm_head_taskp
          showtaskheader
          showtaskint $kgm_cur_taskp
          showipcheader
          showipcint $kgm_cur_taskp->itk_space 0 0
          set $kgm_cur_taskp = (struct task *)($kgm_cur_taskp->tasks.next)
      end
  end
  document showallipc
  Syntax: (gdb) showallipc
  | Routine to print a summary listing of all the ipc spaces
  end
  
  define showipcsumheader
      printf "task         "
      showptrhdrpad
      printf " pid         "
      printf " #acts         "
      printf " tsize "
      printf "command\n"
  end
  
  define showipcsummaryint
      set $kgm_taskp = (struct task *)$arg0
      showptr $arg0
      printf "%7d", ((struct proc *)$kgm_taskp->bsd_info)->p_pid
      printf "%15d", $kgm_taskp->thread_count
      printf "%15d", $kgm_cur_taskp->itk_space.is_table_size      
          printf " %s\n", ((struct proc *)$kgm_taskp->bsd_info)->p_comm
  end
  
  define showipcsummary
      showipcsumheader
      set $kgm_head_taskp = &tasks
      set $kgm_cur_taskp = (struct task *)($kgm_head_taskp->next)
      while $kgm_cur_taskp != $kgm_head_taskp
          showipcsummaryint $kgm_cur_taskp
          set $kgm_cur_taskp = (struct task *)($kgm_cur_taskp->tasks.next)
      end
  end
  
  document showipcsummary
  Syntax: (gdb) showipcsummary 
  | Summarizes the IPC state of all tasks. This is a convenient way to dump
  | some basic clues about IPC messaging. You can use the output to determine
  | tasks that are candidates for further investigation.
  end
  
  
  define showallrights
      set $kgm_head_taskp = &tasks
      set $kgm_cur_taskp = (struct task *)($kgm_head_taskp->next)
      while $kgm_cur_taskp != $kgm_head_taskp
          showtaskheader
          showtaskint $kgm_cur_taskp
          showipcheader
          showipcint $kgm_cur_taskp->itk_space 1 0
          set $kgm_cur_taskp = (struct task *)($kgm_cur_taskp->tasks.next)
      end
  end
  document showallrights
  Syntax: (gdb) showallrights
  | Routine to print a summary listing of all the ipc rights
  end
  
  
  define showtaskvm
          set $kgm_taskp = (task_t)$arg0
          showtaskheader
          showmapheader
          showtaskint $kgm_taskp
          showvmint $kgm_taskp->map 0
  end
  document showtaskvm
  Syntax: (gdb) showtaskvm <task>
  | Routine to print out info about a task's vm_map
  end
  
  define showtaskvme
          set $kgm_taskp = (task_t)$arg0
          showtaskheader
          showtaskint $kgm_taskp
          showmapheader
          showvmint $kgm_taskp->map 1
  end
  document showtaskvme
  Syntax: (gdb) showtaskvme <task>
  | Routine to print out info about a task's vm_map_entries
  end
  
  
  define showtaskheader
      printf "task      "
      showptrhdrpad
      printf "  vm_map    "
      showptrhdrpad
      printf "  ipc_space "
      showptrhdrpad
      printf " #acts "
      showprocheader
  end
  
  
  define showtaskint
      set $kgm_taskp = (struct task *)$arg0
      showptr $arg0
      printf "  "
      showptr $kgm_taskp->map
      printf "  "
      showptr $kgm_taskp->itk_space
      printf " %5d ", $kgm_taskp->thread_count
      showprocint $kgm_taskp->bsd_info
  end
  
  define showtask
      showtaskheader
      showtaskint $arg0
  end
  document showtask
  Syntax (gdb) showtask <task>
  | Routine to print out info about a task.
  end
  
  
  define showtaskthreads
      showtaskheader
      set $kgm_taskp = (struct task *)$arg0
      showtaskint $kgm_taskp
      showactheader
      set $kgm_head_actp = &($kgm_taskp->threads)
      set $kgm_actp = (struct thread *)($kgm_taskp->threads.next)
      while $kgm_actp != $kgm_head_actp
          showactint $kgm_actp 0
          set $kgm_actp = (struct thread *)($kgm_actp->task_threads.next)
      end
  end
  document showtaskthreads
  Syntax: (gdb) showtaskthreads <task>
  | Routine to print info about the threads in a task.
  end
  
  
  define showtaskstacks
      showtaskheader
      set $kgm_taskp = (struct task *)$arg0
      showtaskint $kgm_taskp
      set $kgm_head_actp = &($kgm_taskp->threads)
      set $kgm_actp = (struct thread *)($kgm_taskp->threads.next)
      while $kgm_actp != $kgm_head_actp
          showactheader
          showactint $kgm_actp 1
          set $kgm_actp = (struct thread *)($kgm_actp->task_threads.next)
      end
  end
  document showtaskstacks
  Syntax: (gdb) showtaskstacks <task>
  | Routine to print out the stack for each thread in a task.
  end
  
  define showqueue_elems
          set $queue_head = (struct queue_entry *)($arg0)
          set $queue = (struct queue_entry *)($queue_head->next)
      while $queue != $queue_head
                  showptr $queue
                  printf " "
                  set $thread = (struct thread *)$queue
                  set $task = (struct task *)$thread->task
                  set $bsd = (struct proc *)$task->bsd_info
                  set $guy = (char *)$bsd->p_comm
                  showptr $thread
                  printf " "
                  showptr $task
                  printf " "
                  showptr $bsd
                  printf " "
                  showptr $guy
                  #printf "  %s\n", $kgm_procp->p_comm
                  printf "\n"
          set $queue = (struct queue_entry *)($queue->next)
      end
  end
  
  define showalltasks
      showtaskheader
      set $kgm_head_taskp = &tasks
      set $kgm_taskp = (struct task *)($kgm_head_taskp->next)
      while $kgm_taskp != $kgm_head_taskp
          showtaskint $kgm_taskp
          set $kgm_taskp = (struct task *)($kgm_taskp->tasks.next)
      end
  end
  document showalltasks
  Syntax: (gdb) showalltasks
  | Routine to print a summary listing of all the tasks
  | wq_state -> reports "number of workq threads", "number of scheduled workq threads", "number of pending work items"
  |   if "number of pending work items" seems stuck at non-zero, it may indicate that the workqueue mechanism is hung
  | io_policy -> RAGE  - rapid aging of vnodes requested
  |              NORM  - normal I/O explicitly requested (this is the default)
  |              PASS  - passive I/O requested (i.e. I/Os do not affect throttling decisions)
  |              THROT - throttled I/O requested (i.e. thread/task may be throttled after each I/O completes)
  end
  
  define showprocheader
      printf "  pid  process     "
      showptrhdrpad
      printf "io_policy    wq_state   command\n"
  end
  
  define showprocint
      set $kgm_procp = (struct proc *)$arg0
      if $kgm_procp != 0
          set $kgm_printed = 0
          printf "%5d  ", $kgm_procp->p_pid
          showptr $kgm_procp
          if ($kgm_procp->p_lflag & 0x400000)
             printf "  RAGE "
          else
             printf "       "
          end
          set $ptask = (struct task *)$kgm_procp->task
          set $diskpolicy = 0
          if ($ptask->ext_actionstate.hw_disk != 0)
                  set $diskpolicy = $ptask->ext_actionstate.hw_disk
          else 
                  if ($ptask->actionstate.hw_disk != 0)
                          set $diskpolicy = $ptask->actionstate.hw_disk
                  end
          end
          if ($ptask->ext_actionstate.hw_bg != 0)
                  set $diskpolicy = 5
          end
          if ($ptask->actionstate.hw_bg != 0)
                  set $diskpolicy = 4
          end
          if ($diskpolicy == 2)
                  printf "PASS    "
                  set $kgm_printed = 1
          end
          if ($diskpolicy == 3)
                  printf "THROT   "
                  set $kgm_printed = 1
          end
          if ($diskpolicy == 4)
                  printf "BG_THRT "
                  set $kgm_printed = 1
          end
          if ($diskpolicy == 5)
                  printf "EBG_THRT"
                  set $kgm_printed = 1
          end
          if ($kgm_printed == 0)
             printf "      "
          end
          set $kgm_wqp = (struct workqueue *)$kgm_procp->p_wqptr
          if $kgm_wqp != 0
             printf "  %2d %2d %2d ", $kgm_wqp->wq_nthreads, $kgm_wqp->wq_thidlecount, $kgm_wqp->wq_itemcount
          else
             printf "           "
          end
          printf "  %s\n", $kgm_procp->p_comm
      else
          printf "  *0*  "
          showptr 0
          printf "  --\n"
      end
  end
  
  define showpid
      showtaskheader
      set $kgm_head_taskp = &tasks
      set $kgm_taskp = (struct task *)($kgm_head_taskp->next)
      while $kgm_taskp != $kgm_head_taskp
          set $kgm_procp = (struct proc *)$kgm_taskp->bsd_info
          if (($kgm_procp != 0) && ($kgm_procp->p_pid == $arg0))
              showtaskint $kgm_taskp
              set $kgm_taskp = $kgm_head_taskp
          else
              set $kgm_taskp = (struct task *)($kgm_taskp->tasks.next)
          end
      end
  end
  document showpid
  Syntax: (gdb) showpid <pid>
  | Routine to print a single process by pid
  end
  
  define showproc
      showtaskheader
      set $kgm_procp = (struct proc *)$arg0
      showtaskint $kgm_procp->task
  end
  
  
  define kdb
      set switch_debugger=1
      continue
  end
  document kdb
  | kdb - Switch to the inline kernel debugger
  |
  | usage: kdb
  |
  | The kdb macro allows you to invoke the inline kernel debugger.
  end
  
  define showpsetheader
      printf "portset     "
      showptrhdrpad
      printf "waitqueue   "
      showptrhdrpad
      showptrhdrpad
      printf "recvname    flags refs  recvname    "
      showptrhdrpad
      printf "process\n"
  end
  
  define showportheader
      printf "port        "
      showptrhdrpad
      printf "mqueue      "
      showptrhdrpad
      showptrhdrpad
      printf "recvname    flags refs  recvname    "
      showptrhdrpad
      printf "dest\n"
  end
  
  define showportmemberheader
      printf "members     "
      showptrhdrpad
      printf "port        "
      showptrhdrpad
      showptrhdrpad
      printf "recvname    "
      printf "flags refs  mqueue      "
      showptrhdrpad
      printf "msgcount\n"
  end
  
  define showkmsgheader
      printf "dest-port   "
      showptrhdrpad
      printf "kmsg        "
      showptrhdrpad
      showptrhdrpad
      printf "msgid       "
      printf "disp  size  "
      printf "reply-port  "
      showptrhdrpad
      printf "source\n"
  end
  
  define showkmsgsrcint
      set $kgm_kmsgsrchp = ((ipc_kmsg_t)$arg0)->ikm_header
  #    set $kgm_kmsgsrctp = (mach_msg_audit_trailer_t *)((uintptr_t)$kgm_kmsgsrchp + $kgm_kmsgsrchp->msgh_size)
  #    set $kgm_kmsgpid = $kgm_kmsgsrctp->msgh_audit.val[5]
      set $kgm_kmsgpid = (pid_t)((uint *)((uintptr_t)$kgm_kmsgsrchp + $kgm_kmsgsrchp->msgh_size))[10]
  # compare against a well-known or cached value as this may be slow
      if ($kgm_kmsgpid == 0)
         set $kgm_kmsgsrcpid = (pid_t)0
         set $kgm_kmsgsrcprocp = (struct proc *)kernel_task->bsd_info
      else 
         if ($kgm_kmsgpid != $kgm_kmsgsrcpid)
            set $kgm_kmsgsrchead_taskp = &tasks
            set $kgm_kmsgsrctaskp = (struct task *)($kgm_kmsgsrchead_taskp->next)
            while $kgm_kmsgsrctaskp != $kgm_kmsgsrchead_taskp
                set $kgm_kmsgsrcprocp = (struct proc *)$kgm_kmsgsrctaskp->bsd_info
                set $kgm_kmsgsrcpid = $kgm_kmsgsrcprocp->p_pid
                if (($kgm_kmsgsrcprocp != 0) && ($kgm_kmsgsrcprocp->p_pid == $kgm_kmsgpid))
                    set $kgm_kmsgsrctaskp = $kgm_kmsgsrchead_taskp
                else
                    set $kgm_kmsgsrctaskp = (struct task *)($kgm_kmsgsrctaskp->tasks.next)
                end
            end
         end
      end
      if ($kgm_kmsgsrcprocp->p_pid == $kgm_kmsgpid)
          printf "%s(%d)\n", $kgm_kmsgsrcprocp->p_comm, $kgm_kmsgpid
      else
          printf "unknown(%d)\n", $kgm_kmsgpid
      end
  end
  
  define showkmsgint
      set $kgm_kmsghp = ((ipc_kmsg_t)$arg0)->ikm_header
      set $kgm_kmsgh = *$kgm_kmsghp
      if ($arg1 != 0)
          printf "            "
          showptrhdrpad
      else
          showptr $kgm_kmsgh.msgh_remote_port
      end
      showptr $arg0
      showptrhdrpad
      printf "  0x%08x  ", $kgm_kmsgh.msgh_id
      if (($kgm_kmsgh.msgh_bits & 0xff) == 19)
          printf "rC"
      else
          printf "rM"
      end
      if (($kgm_kmsgh.msgh_bits & 0xff00) == (19 << 8))
          printf "lC"
      else
          printf "lM"
      end
      if ($kgm_kmsgh.msgh_bits & 0xf0000000)
          printf "c"
      else
          printf "s"
      end
      printf "%5d  ", $kgm_kmsgh.msgh_size
      showptr $kgm_kmsgh.msgh_local_port
      printf "  "
      set $kgm_kmsgsrcpid = (pid_t)0
      showkmsgsrcint $arg0
  end
  
  define showkmsg
      showkmsgint $arg0 0
  end
  
  define showkobject
      set $kgm_portp = (struct ipc_port *)$arg0
      showptr $kgm_portp->ip_kobject
      printf "  kobject("
      set $kgm_kotype = ($kgm_portp->ip_object.io_bits & 0x00000fff)
      if ($kgm_kotype == 1)
          printf "THREAD"
      end
      if ($kgm_kotype == 2)
          printf "TASK"
      end
      if ($kgm_kotype == 3)
          printf "HOST"
      end
      if ($kgm_kotype == 4)
          printf "HOST_PRIV"
      end
      if ($kgm_kotype == 5)
          printf "PROCESSOR"
      end
      if ($kgm_kotype == 6)
          printf "PSET"
      end
      if ($kgm_kotype == 7)
          printf "PSET_NAME"
      end
      if ($kgm_kotype == 8)
          printf "TIMER"
      end
      if ($kgm_kotype == 9)
          printf "PAGER_REQ"
      end
      if ($kgm_kotype == 10)
          printf "DEVICE"
      end
      if ($kgm_kotype == 11)
          printf "XMM_OBJECT"
      end
      if ($kgm_kotype == 12)
          printf "XMM_PAGER"
      end
      if ($kgm_kotype == 13)
          printf "XMM_KERNEL"
      end
      if ($kgm_kotype == 14)
          printf "XMM_REPLY"
      end
      if ($kgm_kotype == 15)
          printf "NOTDEF 15"
      end
      if ($kgm_kotype == 16)
          printf "NOTDEF 16"
      end
      if ($kgm_kotype == 17)
          printf "HOST_SEC"
      end
      if ($kgm_kotype == 18)
          printf "LEDGER"
      end
      if ($kgm_kotype == 19)
          printf "MASTER_DEV"
      end
      if ($kgm_kotype == 20)
          printf "ACTIVATION"
      end
      if ($kgm_kotype == 21)
          printf "SUBSYSTEM"
      end
      if ($kgm_kotype == 22)
          printf "IO_DONE_QUE"
      end
      if ($kgm_kotype == 23)
          printf "SEMAPHORE"
      end
      if ($kgm_kotype == 24)
          printf "LOCK_SET"
      end
      if ($kgm_kotype == 25)
          printf "CLOCK"
      end
      if ($kgm_kotype == 26)
          printf "CLOCK_CTRL"
      end
      if ($kgm_kotype == 27)
          printf "IOKIT_SPARE"
      end
      if ($kgm_kotype == 28)
          printf "NAMED_MEM"
      end
      if ($kgm_kotype == 29)
          printf "IOKIT_CON"
      end
      if ($kgm_kotype == 30)
          printf "IOKIT_OBJ"
      end
      if ($kgm_kotype == 31)
          printf "UPL"
      end
      if ($kgm_kotype == 34)
          printf "FD"
      end
      printf ")\n"
  end
  
  define showportdestproc
      set $kgm_portp = (struct ipc_port *)$arg0
      set $kgm_spacep = $kgm_portp->data.receiver
  #   check against the previous cached value - this is slow
      if ($kgm_spacep != $kgm_destspacep)
          set $kgm_destprocp = (struct proc *)0
          set $kgm_head_taskp = &tasks
          set $kgm_desttaskp = (struct task *)($kgm_head_taskp->next)
          while (($kgm_destprocp == 0) && ($kgm_desttaskp != $kgm_head_taskp))
              set $kgm_destspacep = $kgm_desttaskp->itk_space
              if ($kgm_destspacep == $kgm_spacep)
                 set $kgm_destprocp = (struct proc *)$kgm_desttaskp->bsd_info
              else
                 set $kgm_desttaskp = (struct task *)($kgm_desttaskp->tasks.next)
              end
          end
      end
      if $kgm_destprocp != 0
         printf "%s(%d)\n", $kgm_destprocp->p_comm, $kgm_destprocp->p_pid
      else
         printf "task "
         showptr $kgm_desttaskp
         printf "\n"
      end
  end
  
  define showportdest
      set $kgm_portp = (struct ipc_port *)$arg0
      set $kgm_spacep = $kgm_portp->data.receiver
      if ((uintptr_t)$kgm_spacep == (uintptr_t)ipc_space_kernel)
          showkobject $kgm_portp
      else
          if ($kgm_portp->ip_object.io_bits & 0x80000000)
              showptr $kgm_portp->ip_messages.data.port.receiver_name
          printf "  "
              showportdestproc $kgm_portp
          else
          showptr $kgm_portp
              printf "  inactive-port\n"
          end
      end
  end
  
  define showportmember
      printf "            "
      showptrhdrpad
      showptr $arg0
      showptrhdrpad
      set $kgm_portp = (struct ipc_port *)$arg0
      printf "  0x%08x  ", $kgm_portp->ip_messages.data.port.receiver_name
      if ($kgm_portp->ip_object.io_bits & 0x80000000)
          printf "A"
      else
          printf " "
      end
      printf "Port"
      printf "%5d  ", $kgm_portp->ip_object.io_references
      showptr &($kgm_portp->ip_messages)
      printf "  0x%08x\n", $kgm_portp->ip_messages.data.port.msgcount
  end
  
  define showportbt
      set $kgm_iebt = ((ipc_port_t) $arg0)->ip_callstack
      set $kgm_iepid = ((ipc_port_t) $arg0)->ip_spares[0]
      set $kgm_procpid = ((proc_t) (((task_t) $arg1)->bsd_info))->p_pid
      if $kgm_iebt[0] != 0
          showptr $kgm_iebt[0]
          set $kgm_iebt_loop_ctr = 1
          while ($kgm_iebt_loop_ctr < 16 && $kgm_iebt[$kgm_iebt_loop_ctr])
              printf " "
              showptr $kgm_iebt[$kgm_iebt_loop_ctr]
              set $kgm_iebt_loop_ctr = $kgm_iebt_loop_ctr + 1
          end
          if $kgm_iepid != $kgm_procpid
              printf " (%d)", $kgm_iepid
          end
          printf "\n"
      end
  end
  
  define showportint
      showptr $arg0
      printf "  "
      set $kgm_portp = (struct ipc_port *)$arg0
      showptr &($kgm_portp->ip_messages)
      showptrhdrpad
      printf "  0x%08x  ", $kgm_portp->ip_messages.data.port.receiver_name
      if ($kgm_portp->ip_object.io_bits & 0x80000000)
          printf "A"
      else
          printf "D"
      end
      printf "Port"
      printf "%5d  ", $kgm_portp->ip_object.io_references
      set $kgm_destspacep = (struct ipc_space *)0
      showportdest $kgm_portp
      set $kgm_kmsgp = (ipc_kmsg_t)$kgm_portp->ip_messages.data.port.messages.ikmq_base
      if $arg1 && $kgm_kmsgp
          showkmsgheader
          showkmsgint $kgm_kmsgp 1
          set $kgm_kmsgheadp = $kgm_kmsgp
          set $kgm_kmsgp = $kgm_kmsgp->ikm_next
          while $kgm_kmsgp != $kgm_kmsgheadp
              showkmsgint $kgm_kmsgp 1
              set $kgm_kmsgp = $kgm_kmsgp->ikm_next
          end
      end
  end
  
  define showpsetint
      showptr $arg0
      printf "  "
      set $kgm_psetp = (struct ipc_pset *)$arg0
      showptr &($kgm_psetp->ips_messages)
      showptrhdrpad
      printf "  0x%08x  ", $kgm_psetp->ips_messages.data.pset.local_name
      if ($kgm_psetp->ips_object.io_bits & 0x80000000)
          printf "A"
      else
          printf "D"
      end
      printf "Set "
      printf "%5d  ", $kgm_psetp->ips_object.io_references
      showptr $kgm_psetp->ips_messages.data.pset.local_name
      printf "  "
      set $kgm_setlinksp = &($kgm_psetp->ips_messages.data.pset.set_queue.wqs_setlinks)
      set $kgm_wql = (WaitQueueLink *)$kgm_setlinksp->next
      set $kgm_found = 0
      while ( (queue_entry_t)$kgm_wql != (queue_entry_t)$kgm_setlinksp)
          set $kgm_portp = (struct ipc_port *)((uintptr_t)($kgm_wql->wql_element->wqe_queue) - (uintptr_t)$kgm_portoff)
          if !$kgm_found  
              set $kgm_destspacep = (struct ipc_space *)0
              showportdestproc $kgm_portp
              showportmemberheader
              set $kgm_found = 1
          end
          showportmember $kgm_portp 0
          set $kgm_wql = (WaitQueueLink *)$kgm_wql->wql_setlinks.next
      end
      if !$kgm_found
          printf "--n/e--\n"
      end
  end
  
  define showpset
      set $kgm_portoff = &(((struct ipc_port *)0)->ip_messages)
      showpsetheader
      showpsetint $arg0 1
  end
  
  define showport
      showportheader
      showportint $arg0 1
  end
  
  define showipcobject
      set $kgm_objectp = (ipc_object_t)$arg0
      if ($kgm_objectp->io_bits & 0x7fff0000)
          set $kgm_portoff = &(((struct ipc_port *)0)->ip_messages)
          showpset $kgm_objectp
      else
          showport $kgm_objectp
      end
  end
  
  define showmqueue
      set $kgm_mqueue = *(struct ipc_mqueue *)$arg0
      if ($kgm_mqueue.data.pset.set_queue.wqs_wait_queue.wq_type == 0xf1d1)
          set $kgm_psetoff = &(((struct ipc_pset *)0)->ips_messages)
          set $kgm_pset = (((long)$arg0) - ((long)$kgm_psetoff))
          showpsetheader
          showpsetint $kgm_pset 1
      end
      if ($kgm_mqueue.data.pset.set_queue.wqs_wait_queue.wq_type == 0xf1d0)
          set $kgm_portoff = &(((struct ipc_port *)0)->ip_messages)
          set $kgm_port = (((long)$arg0) - ((long)$kgm_portoff))
          showportheader
          showportint $kgm_port 1
      end
  end
  
  define zprint_one
      set $kgm_zone = (struct zone *)$arg0
  
      showptr $kgm_zone
      printf "  %6d ",$kgm_zone->count
      printf "%8x ",$kgm_zone->cur_size
      printf "%8x ",$kgm_zone->max_size
      printf "%6d ",$kgm_zone->elem_size
      printf "%8x ",$kgm_zone->alloc_size
          printf " %8d ",$kgm_zone->num_allocs
          printf "%8d ",$kgm_zone->num_frees
      printf "%s ",$kgm_zone->zone_name
  
      if ($kgm_zone->exhaustible)
          printf "H"
      end
      if ($kgm_zone->collectable)
          printf "C"
      end
      if ($kgm_zone->expandable)
          printf "X"
      end
      if ($kgm_zone->noencrypt)
          printf "$"
      end
      printf "\n"
  end
  
  
  define zprint
      printf "ZONE      "
      showptrhdrpad
      printf "   COUNT   TOT_SZ   MAX_SZ ELT_SZ ALLOC_SZ TOT_ALLOC TOT_FREE NAME\n"
      set $kgm_zone_ptr = (struct zone *)first_zone
      while ($kgm_zone_ptr != 0)
          zprint_one $kgm_zone_ptr
          set $kgm_zone_ptr = $kgm_zone_ptr->next_zone
      end
      printf "\n"
  end
  document zprint
  Syntax: (gdb) zprint
  | Routine to print a summary listing of all the kernel zones
  end
  
  define showmtxgrp
      set $kgm_mtxgrp = (struct _lck_grp_ *)$arg0
  
      if ($kgm_mtxgrp->lck_grp_mtxcnt)
          showptr $kgm_mtxgrp
          printf " %8d ",$kgm_mtxgrp->lck_grp_mtxcnt
          printf "%12u ",$kgm_mtxgrp->lck_grp_stat.lck_grp_mtx_stat.lck_grp_mtx_util_cnt
          printf "%8u ",$kgm_mtxgrp->lck_grp_stat.lck_grp_mtx_stat.lck_grp_mtx_miss_cnt
          printf "%8u ",$kgm_mtxgrp->lck_grp_stat.lck_grp_mtx_stat.lck_grp_mtx_wait_cnt
          printf "%s ",&$kgm_mtxgrp->lck_grp_name
          printf "\n"
      end
  end
  
  
  define showallmtx
      printf "LCK GROUP "
      showptrhdrpad
      printf "      CNT         UTIL     MISS     WAIT NAME\n"
      set $kgm_mtxgrp_ptr = (struct _lck_grp_ *)&lck_grp_queue
      set $kgm_mtxgrp_ptr = (struct _lck_grp_ *)$kgm_mtxgrp_ptr->lck_grp_link.next
      while ($kgm_mtxgrp_ptr != (struct _lck_grp_ *)&lck_grp_queue)
          showmtxgrp $kgm_mtxgrp_ptr
          set $kgm_mtxgrp_ptr = (struct _lck_grp_ *)$kgm_mtxgrp_ptr->lck_grp_link.next
      end
      printf "\n"
  end
  document showallmtx
  Syntax: (gdb) showallmtx
  | Routine to print a summary listing of all mutexes
  end
  
  define showrwlckgrp
      set $kgm_rwlckgrp = (struct _lck_grp_ *)$arg0
  
      if ($kgm_rwlckgrp->lck_grp_rwcnt)
          showptr $kgm_rwlckgrp
          printf " %8d ",$kgm_rwlckgrp->lck_grp_rwcnt
          printf "%12u ",$kgm_rwlckgrp->lck_grp_stat.lck_grp_rw_stat.lck_grp_rw_util_cnt
          printf "%8u ",$kgm_rwlckgrp->lck_grp_stat.lck_grp_rw_stat.lck_grp_rw_miss_cnt
          printf "%8u ",$kgm_rwlckgrp->lck_grp_stat.lck_grp_rw_stat.lck_grp_rw_wait_cnt
          printf "%s ",&$kgm_rwlckgrp->lck_grp_name
          printf "\n"
      end
  end
  
  
  define showallrwlck
      printf "LCK GROUP "
      showptrhdrpad
      printf "      CNT         UTIL     MISS     WAIT NAME\n"
      set $kgm_rwlckgrp_ptr = (struct _lck_grp_ *)&lck_grp_queue
      set $kgm_rwlckgrp_ptr = (struct _lck_grp_ *)$kgm_rwlckgrp_ptr->lck_grp_link.next
      while ($kgm_rwlckgrp_ptr != (struct _lck_grp_ *)&lck_grp_queue)
          showrwlckgrp $kgm_rwlckgrp_ptr
          set $kgm_rwlckgrp_ptr = (struct _lck_grp_ *)$kgm_rwlckgrp_ptr->lck_grp_link.next
      end
      printf "\n"
  end
  document showallrwlck
  Syntax: (gdb) showallrwlck
  | Routine to print a summary listing of all read/writer locks
  end
  
  set $kdp_act_counter = 0
  set $kdp_arm_act_counter = 0
  
  set $r0_save    = 0
  set $r1_save    = 0
  set $r2_save    = 0
  set $r3_save    = 0
  set $r4_save    = 0
  set $r5_save    = 0
  set $r6_save    = 0
  set $r7_save    = 0
  set $r8_save    = 0
  set $r9_save    = 0
  set $r10_save   = 0
  set $r11_save   = 0
  set $r12_save   = 0
  set $sp_save    = 0
  set $lr_save    = 0
  set $pc_save    = 0
  
  define showcontext_int
          echo Context switched, current instruction pointer: 
          output/a $pc
          echo \n
  end
  
  define switchtoact
          set $newact = (struct thread *) $arg0
          select 0
          if ($newact->kernel_stack == 0)
                  echo This activation does not have a stack.\n
                  echo continuation:
                  output/a (unsigned) $newact.continuation
                  echo \n
          else
                  if ($kgm_mtype == $kgm_mtype_ppc)
                          if ($kdp_act_counter == 0)
                                  set $kdpstate = (struct savearea *) kdp.saved_state
                          end
                          set $kdp_act_counter = $kdp_act_counter + 1
                          set (struct savearea *) kdp.saved_state=$newact->machine->pcb
                          flushregs
                          flushstack
                          set $pc=$newact->machine->pcb.save_srr0
                          update
                  end
                  if ($kgm_mtype == $kgm_mtype_i386)
                          set $kdpstatep = (struct x86_saved_state32 *) kdp.saved_state
                          if ($kdp_act_counter == 0)
                             set $kdpstate = *($kdpstatep)
                          end     
                          set $kdp_act_counter = $kdp_act_counter + 1
          
                          set $kgm_statep = (struct x86_kernel_state *) \
                                                  ($newact->kernel_stack + kernel_stack_size \
                                                   - sizeof(struct x86_kernel_state))
                          set $kdpstatep->ebx = $kgm_statep->k_ebx 
                          set $kdpstatep->ebp = $kgm_statep->k_ebp 
                          set $kdpstatep->edi = $kgm_statep->k_edi 
                          set $kdpstatep->esi = $kgm_statep->k_esi 
                          set $kdpstatep->eip = $kgm_statep->k_eip 
                          flushregs
                          flushstack
                          set $pc = $kgm_statep->k_eip
                          update
                  end
                  if ($kgm_mtype == $kgm_mtype_x86_64)
                          set $kdpstatep = (struct x86_saved_state64 *) kdp.saved_state
                          if ($kdp_act_counter == 0)
                             set $kdpstate = *($kdpstatep)
                          end     
                          set $kdp_act_counter = $kdp_act_counter + 1
          
                          set $kgm_statep = (struct x86_kernel_state *) \
                                                  ($newact->kernel_stack + kernel_stack_size \
                                                   - sizeof(struct x86_kernel_state))
                          set $kdpstatep->rbx = $kgm_statep->k_rbx 
                          set $kdpstatep->rbp = $kgm_statep->k_rbp 
                          set $kdpstatep->r12 = $kgm_statep->k_r12 
                          set $kdpstatep->r13 = $kgm_statep->k_r13 
                          set $kdpstatep->r14 = $kgm_statep->k_r14 
                          set $kdpstatep->r15 = $kgm_statep->k_r15 
                          set $kdpstatep->isf.rsp = $kgm_statep->k_rsp 
                          flushregs
                          flushstack
                          set $pc = $kgm_statep->k_rip
                          update
                  end
                  if ($kgm_mtype == $kgm_mtype_arm)
                          set $kdp_arm_act_counter = $kdp_arm_act_counter + 1
                          if ($kdp_arm_act_counter == 1)
                                  set $r0_save   = $r0
                                  set $r1_save   = $r1
                                  set $r2_save   = $r2
                                  set $r3_save   = $r3
                                  set $r4_save   = $r4
                                  set $r5_save   = $r5
                                  set $r6_save   = $r6
                                  set $r7_save   = $r7
                                  set $r8_save   = $r8
                                  set $r9_save   = $r9
                                  set $r10_save  = $r10
                                  set $r11_save  = $r11
                                  set $r12_save  = $r12
                                  set $sp_save   = $sp
                                  set $lr_save   = $lr
                                  set $pc_save   = $pc
                          end
                          set $pc_ctx = load_reg+8
                          set $kgm_statep = (struct arm_saved_state *)((struct thread*)$arg0)->machine.kstackptr
                          set $r0 =  $kgm_statep->r[0]
                          set $r1 =  $kgm_statep->r[1]
                          set $r2 =  $kgm_statep->r[2]
                          set $r3 =  $kgm_statep->r[3]
                          set $r4 =  $kgm_statep->r[4]
                          set $r5 =  $kgm_statep->r[5]
                          set $r6 =  $kgm_statep->r[6]
                          set $r8 =  $kgm_statep->r[8]
                          set $r9 =  $kgm_statep->r[9]
                          set $r10 = $kgm_statep->r[10]
                          set $r11 = $kgm_statep->r[11]
                          set $r12 = $kgm_statep->r[12]
                          set $sp = $kgm_statep->sp
                          set $lr = $kgm_statep->lr
                          set $pc = $pc_ctx
                          set $r7 =  $kgm_statep->r[7]
                          flushregs
                          flushstack
                  end
          end
          showcontext_int
  end
  
  document switchtoact  
  Syntax: switchtoact <address of activation>
  | This command allows gdb to examine the execution context and call
  | stack for the specified activation. For example, to view the backtrace
  | for an activation issue "switchtoact <address>", followed by "bt".
  | Before resuming execution, issue a "resetctx" command, to
  | return to the original execution context.
  end     
  
  define switchtoctx
          select 0
          if ($kgm_mtype == $kgm_mtype_ppc)
                  if ($kdp_act_counter == 0)
                     set $kdpstate = (struct savearea *) kdp.saved_state
                  end
                  set $kdp_act_counter = $kdp_act_counter + 1
                  set (struct savearea *) kdp.saved_state=(struct savearea *) $arg0
                  flushregs
                  flushstack
                  set $pc=((struct savearea *) $arg0)->save_srr0
                  update
          else
          if ($kgm_mtype == $kgm_mtype_arm)
                  select 0
                  set $kdp_arm_act_counter = $kdp_arm_act_counter + 1
                  if ($kdp_arm_act_counter == 1)
                          set $r0_save   = $r0
                          set $r1_save   = $r1
                          set $r2_save   = $r2
                          set $r3_save   = $r3
                          set $r4_save   = $r4
                          set $r5_save   = $r5
                          set $r6_save   = $r6
                          set $r7_save   = $r7
                          set $r8_save   = $r8
                          set $r9_save   = $r9
                          set $r10_save  = $r10
                          set $r11_save  = $r11
                          set $r12_save  = $r12
                          set $sp_save   = $sp
                          set $lr_save   = $lr
                          set $pc_save   = $pc
                  end
                  set $kgm_statep = (struct arm_saved_state *)$arg0
                  set $r0 =  $kgm_statep->r[0]
                  set $r1 =  $kgm_statep->r[1]
                  set $r2 =  $kgm_statep->r[2]
                  set $r3 =  $kgm_statep->r[3]
                  set $r4 =  $kgm_statep->r[4]
                  set $r5 =  $kgm_statep->r[5]
                  set $r6 =  $kgm_statep->r[6]
                  set $r8 =  $kgm_statep->r[8]
                  set $r9 =  $kgm_statep->r[9]
                  set $r10 = $kgm_statep->r[10]
                  set $r11 = $kgm_statep->r[11]
                  set $r12 = $kgm_statep->r[12]
                  set $sp = $kgm_statep->sp
                  set $lr = $kgm_statep->lr
                  set $r7 =  $kgm_statep->r[7]
                  set $pc = $kgm_statep->pc
                  flushregs
                  flushstack
                  update
          else
                  echo switchtoctx not implemented for this architecture.\n
          end
  end
  
  document switchtoctx  
  Syntax: switchtoctx <address of pcb>
  | This command allows gdb to examine an execution context and dump the
  | backtrace for this execution context.
  | Before resuming execution, issue a "resetctx" command, to
  | return to the original execution context.
  end     
  
  define resetctx
          select 0
          if ($kdp_act_counter != 0)
                  if ($kgm_mtype == $kgm_mtype_ppc)
                          set (struct savearea *)kdp.saved_state=$kdpstate
                          flushregs
                          flushstack
                          set $pc=((struct savearea *) kdp.saved_state)->save_srr0
                          update
                          set $kdp_act_counter = 0
                  end
                  if ($kgm_mtype == $kgm_mtype_i386)
                          set $kdpstatep = (struct x86_saved_state32 *) kdp.saved_state
                          set *($kdpstatep)=$kdpstate
                          flushregs
                          flushstack
                          set $pc=$kdpstatep->eip
                          update
                          set $kdp_act_counter = 0
                  end
                  if ($kgm_mtype == $kgm_mtype_x86_64)
                          set $kdpstatep = (struct x86_saved_state64 *) kdp.saved_state
                          set *($kdpstatep)=$kdpstate
                          flushregs
                          flushstack
                          set $pc=$kdpstatep->isf.rip
                          update
                          set $kdp_act_counter = 0
                  end
                  showcontext_int
          end
          if ($kgm_mtype == $kgm_mtype_arm && $kdp_arm_act_counter != 0)
                  echo Restoring context\n
                  set $r0  = $r0_save
                  flushregs
                  set $r1  = $r1_save
                  flushregs
                  set $r2  = $r2_save
                  flushregs
                  set $r3  = $r3_save
                  flushregs
                  set $r4  = $r4_save
                  flushregs
                  set $r5  = $r5_save
                  flushregs
                  set $r6  = $r6_save
                  flushregs
                  set $r8  = $r8_save
                  flushregs
                  set $r9  = $r9_save
                  flushregs
                  set $r10 = $r10_save
                  flushregs
                  set $r11 = $r11_save
                  flushregs
                  set $r12 = $r12_save
                  flushregs
                  set $sp  = $sp_save
                  flushregs
                  set $lr  = $lr_save
                  flushregs
                  set $pc  = $pc_save
                  flushregs
                  set $r7  = $r7_save
                  flushregs
                  flushstack
                  update
                  set $kdp_arm_act_counter = 0
          end
  end     
          
  document resetctx
  | Syntax: resetctx
  | Returns to the original execution context. This command should be
  | issued if you wish to resume execution after using the "switchtoact"
  | or "switchtoctx" commands.
  end     
  
  # This is a pre-hook for the continue command, to prevent inadvertent attempts 
  # to resume from the context switched to for examination.
  define hook-continue
         resetctx
  end
  
  # This is a pre-hook for the detach command, to prevent inadvertent attempts 
  # to resume from the context switched to for examination.
  define hook-detach
         resetctx
  end
  
  define resume_on
          set $resume = KDP_DUMPINFO_SETINFO | KDP_DUMPINFO_RESUME
          dumpinfoint $resume
  end
  
  document resume_on
  | Syntax: resume_on
  | The target system will resume when detaching  or exiting from gdb. 
  | This is the default behavior.
  end
  
  define resume_off
          set $noresume = KDP_DUMPINFO_SETINFO | KDP_DUMPINFO_NORESUME
          dumpinfoint $noresume
  end
  
  document resume_off
  | Syntax: resume_off
  | The target system  won't resume after detaching from gdb and
  | can be attached with a new gdb session
  end
  
  define paniclog
          set $kgm_panic_bufptr = debug_buf
          set $kgm_panic_bufptr_max = debug_buf_ptr
          while $kgm_panic_bufptr < $kgm_panic_bufptr_max
                  if *(char *)$kgm_panic_bufptr == 10
                          printf "\n"
                  else
                          printf "%c", *(char *)$kgm_panic_bufptr
                  end
                  set $kgm_panic_bufptr= (char *)$kgm_panic_bufptr + 1
          end
  end
  
  document paniclog
  | Syntax: paniclog
  | Display the panic log information
  |
  end
  
  define dumpcallqueue
          set $kgm_callhead = $arg0
          set $kgm_callentry = $kgm_callhead->next
          set $kgm_i = 0
          while $kgm_callentry != $kgm_callhead
                  set $kgm_call = (struct call_entry *)$kgm_callentry
                  printf "0x%08x ", $kgm_call
                  printf "0x%08x 0x%08x ", $kgm_call->param0, $kgm_call->param1
                  output $kgm_call->deadline
                  printf "\t"
                  output $kgm_call->func
                  printf "\n"
                  set $kgm_i = $kgm_i + 1
                  set $kgm_callentry = $kgm_callentry->next
          end
          printf "%d entries\n", $kgm_i
  end
  
  document dumpcallqueue
  | Syntax: dumpcallqueue <queue head>
  | Displays the contents of the specified call_entry queue.
  end
  
  define showtaskacts
  showtaskthreads $arg0
  end
  document showtaskacts
  | See help showtaskthreads.
  end
  
  define showallacts
  showallthreads
  end
  document showallacts
  | See help showallthreads.
  end
  
  
  define resetstacks
         _kgm_flush_loop
         set kdp_pmap = 0
         _kgm_flush_loop
         resetctx
         _kgm_flush_loop
         _kgm_update_loop
         resetctx
         _kgm_update_loop
  end
  
  document resetstacks
  | Syntax: resetstacks
  | Internal kgmacro routine used by the "showuserstack" macro 
  | to reset the target pmap to the kernel pmap.
  end
  
  #Barely effective hacks to work around bugs in the "flush" and "update" 
  #gdb commands in Tiger (up to 219); these aren't necessary with Panther
  #gdb, but do no harm.
  define _kgm_flush_loop
         set $kgm_flush_loop_ctr = 0
         while ($kgm_flush_loop_ctr < 30)
               flushregs
               flushstack
               set $kgm_flush_loop_ctr = $kgm_flush_loop_ctr + 1
         end
  end
  
  define _kgm_update_loop
         set $kgm_update_loop_ctr = 0
         while ($kgm_update_loop_ctr < 30)
               update
               set $kgm_update_loop_ctr = $kgm_update_loop_ctr + 1
         end
  end
  # Internal routine used by "_loadfrom" to read from 64-bit addresses
  # on 32-bit kernels
  define _loadk32m64
         # set up the manual KDP packet
         set manual_pkt.input = 0
         set manual_pkt.len = sizeof(kdp_readmem64_req_t)
         set $kgm_pkt = (kdp_readmem64_req_t *)&manual_pkt.data
         set $kgm_pkt->hdr.request = KDP_READMEM64
         set $kgm_pkt->hdr.len = sizeof(kdp_readmem64_req_t)
         set $kgm_pkt->hdr.is_reply = 0
         set $kgm_pkt->hdr.seq = 0
         set $kgm_pkt->hdr.key = 0
         set $kgm_pkt->address = (uint64_t)$arg0
         set $kgm_pkt->nbytes = sizeof(uint64_t)
         set manual_pkt.input = 1
         # dummy to make sure manual packet is executed
         set $kgm_dummy = &_mh_execute_header
         set $kgm_pkt = (kdp_readmem64_reply_t *)&manual_pkt.data
         if ($kgm_pkt->error == 0)
                  set $kgm_k32read64 = *(uint64_t *)$kgm_pkt->data
         else
                  set $kgm_k32read64 = 0
         end
  end
  
  # Internal routine used by "showx86backtrace" to abstract possible loads from
  # user space
  define _loadfrom
          if (kdp_pmap == 0)
                  set $kgm_loadval = *(uintptr_t *)$arg0
          else
          if ($kgm_x86_abi == 0xe)
                set $kgm_loadval = *(uint32_t *)$arg0
          else
          if ($kgm_x86_abi == 0xf)
              if ($kgm_mtype == $kgm_mtype_i386)
                      _loadk32m64 $arg0
                      set $kgm_loadval = $kgm_k32read64
              else
                      set $kgm_loadval = *(uint64_t *)$arg0
              end
          end
          end
  end
  end
  
  
  #This is necessary since gdb often doesn't do backtraces on x86 correctly
  #in the absence of symbols.The code below in showuserstack and 
  #showx86backtrace also contains several workarouds for the gdb bug where 
  #gdb stops macro evaluation because of spurious "Cannot read memory"
  #errors on x86. These errors appear on ppc as well, but they don't
  #always stop macro evaluation.
  
  set $kgm_cur_frame = 0
  set $kgm_cur_pc = 0
  set $kgm_x86_abi = 0
  define showx86backtrace
          if ($kgm_mtype == $kgm_mtype_i386)
                  set $kgm_frame_reg = $ebp
                  set $kgm_pc = $eip
                  set $kgm_ret_off = 4
          end
          if ($kgm_mtype == $kgm_mtype_x86_64)
                  set $kgm_frame_reg = $rbp
                  set $kgm_pc = $rip
                  set $kgm_ret_off = 8
          end
  
          if ($kgm_x86_abi == 0xe)
                  set $kgm_ret_off = 4
          end
          if ($kgm_x86_abi == 0xf)
                  set $kgm_ret_off = 8
          end
  
          if ($kgm_cur_frame == 0)
                  set $kgm_cur_frame = $kgm_frame_reg
          end
          if ($kgm_cur_pc == 0)
                  set $kgm_cur_pc = $kgm_pc
          end
          printf "0: Frame: 0x%016llx PC: 0x%016llx\n", $kgm_cur_frame, $kgm_cur_pc
          if (!(($kgm_x86_abi == 0xf) && ($kgm_mtype == $kgm_mtype_i386)))
                  x/i $kgm_cur_pc
          end
          set $kgm_tmp_frame = $kgm_cur_frame
          set $kgm_cur_frame = 0
          set $kgm_cur_pc = 0
          _loadfrom ($kgm_tmp_frame)
          set $kgm_prev_frame = $kgm_loadval
          _loadfrom ($kgm_tmp_frame+$kgm_ret_off)
          set $kgm_prev_pc = $kgm_loadval
          set $kgm_frameno = 1
          while ($kgm_prev_frame != 0) && ($kgm_prev_frame != 0x0000000800000008)
                  printf "%d: Saved frame: 0x%016llx Saved PC: 0x%016llx\n", $kgm_frameno, $kgm_prev_frame, $kgm_prev_pc
                  if (!(($kgm_x86_abi == 0xf) && ($kgm_mtype == $kgm_mtype_i386)))
                     x/i $kgm_prev_pc
                  end
                  _loadfrom ($kgm_prev_frame+$kgm_ret_off)
                  set $kgm_prev_pc = $kgm_loadval
                  _loadfrom ($kgm_prev_frame)
                  set $kgm_prev_frame = $kgm_loadval
                  set $kgm_frameno = $kgm_frameno + 1
          end
          set kdp_pmap = 0
          set $kgm_x86_abi = 0
  end
  
  define showx86backtrace2
          set $kgm_cur_frame = $arg0
          set $kgm_cur_pc = $arg1
          showx86backtrace
  end
  
  define showuserstack
                  select 0
                  if ($kgm_mtype == $kgm_mtype_ppc)       
                     if ($kdp_act_counter == 0)
                        set $kdpstate = (struct savearea *) kdp.saved_state
                     end
                     set $kdp_act_counter = $kdp_act_counter + 1
                     set $newact = (struct thread *) $arg0
                     _kgm_flush_loop
                     set $checkpc = $newact->machine->upcb.save_srr0
                     if ($checkpc == 0)
                        echo This activation does not appear to have
                        echo \20 a valid user context.\n
                     else       
                       set (struct savearea *) kdp.saved_state=$newact->machine->upcb
                       set $pc = $checkpc
  #flush and update seem to be executed lazily by gdb on Tiger, hence the
  #repeated invocations - see 3743135
                      _kgm_flush_loop
  # This works because the new pmap is used only for reads
                       set kdp_pmap = $newact->task->map->pmap
                       _kgm_flush_loop
                       _kgm_update_loop
                       bt
                       resetstacks
                       _kgm_flush_loop
                       _kgm_update_loop
                       resetstacks
                       _kgm_flush_loop
                       _kgm_update_loop
                     end
                  else
                  if (($kgm_mtype & $kgm_mtype_x86_mask) == $kgm_mtype_x86_any)
                          set $newact = (struct thread *) $arg0
                          set $newiss = (x86_saved_state_t *) ($newact->machine->iss)
                          set $kgm_x86_abi = $newiss.flavor
                          if ($newiss.flavor == 0xf) 
                                  set $checkpc = $newiss.uss.ss_64.isf.rip
                                  set $checkframe = $newiss.uss.ss_64.rbp
  
                          else
                                  set $checkpc = $newiss.uss.ss_32.eip
                                  set $checkframe = $newiss.uss.ss_32.ebp
                          end
  
                          if ($checkpc == 0)
                              echo This activation does not appear to have
                              echo \20 a valid user context.\n
                          else
                          set $kgm_cur_frame = $checkframe
                          set $kgm_cur_pc = $checkpc
  # When have more than one argument is present, don't print usage
                          if ( $argc == 1 )
                                  printf "You may now issue the showx86backtrace command to see the user space backtrace for this thread ("
                                  showptr $arg0
                                  printf "); you can also examine memory locations in this address space (pmap "
                                  showptr $newact->task->map->pmap
                                  printf ") before issuing the backtrace. This two-step process is necessary to work around various bugs in x86 gdb, which cause it to stop memory evaluation on spurious memory read errors. Additionally, you may need to issue a set kdp_pmap = 0 command after the showx86backtrace completes, to resume reading from the kernel address space.\n"
                          end
                          set kdp_pmap = $newact->task->map->pmap
                          _kgm_flush_loop
                          _kgm_update_loop
                          end                     
                  else
                  if ($kgm_mtype == $kgm_mtype_arm)
                          if (kdp->is_conn > 0)
                                  set $kgm_threadp = (struct thread *)$arg0
                                  set $kgm_saved_pmap = kdp_pmap
                                  showactheader
                                  showactint $kgm_threadp 0
                                  set $kgm_thread_pmap = $kgm_threadp->task->map->pmap
                                  set $kgm_thread_sp = $kgm_threadp.machine->PcbData.r[7]
                                  set kdp_pmap = $kgm_thread_pmap
                                  while ($kgm_thread_sp != 0)
                                  set $link_register = *($kgm_thread_sp + 4)
                                  showptrhdrpad
                                          printf "                  "
                                          showptr $kgm_thread_sp
                                          printf "  "
                                  showptr $link_register
                                  printf "\n"
                                  set $kgm_thread_sp = *$kgm_thread_sp
                                  end
                                  set kdp_pmap = $kgm_saved_pmap
                          else
                                  echo You must be connected via nanokdp to use this macro\n
                          end
                  else
                          echo showuserstack not supported on this architecture\n
                  end
                  end
                  end
  end
  document showuserstack
  Syntax: showuserstack <address of thread activation>
  |This command displays a numeric backtrace for the user space stack of
  |the given thread activation. It may, of course, fail to display a
  |complete backtrace if portions of the user stack are not mapped in.
  |Symbolic backtraces can be obtained either by running gdb on the
  |user space binary, or a tool such as "symbolicate".
  |Note that while this command works on Panther's gdb, an issue
  |with Tiger gdb (3743135) appears to hamper the evaluation of this
  |macro in some cases.
  end
  
  define showtaskuserstacks
      set $kgm_taskp = (struct task *)$arg0
      set $kgm_head_actp = &($kgm_taskp->threads)
      set $kgm_actp = (struct thread *)($kgm_taskp->threads.next)
      while $kgm_actp != $kgm_head_actp
          printf "For thread "
          showptr $kgm_actp
          printf "\n"
          showuserstack $kgm_actp quiet
          if (($kgm_mtype & $kgm_mtype_x86_mask) == $kgm_mtype_x86_any)
                  showx86backtrace
          end
          set kdp_pmap=0
          set $kgm_actp = (struct thread *)($kgm_actp->task_threads.next)
          printf "\n"
      end
      showuserlibraries $kgm_taskp
  end
  document showtaskuserstacks
  Syntax: (gdb) showtaskuserstacks <task>
  | Print out the user stack for each thread in a task, followed by the user libraries.
  end
  
  
  define showuserregisters
          set $kgm_threadp = (struct thread *)$arg0
          set $kgm_taskp = $kgm_threadp->task
          if (($kgm_mtype & $kgm_mtype_x86_mask) == $kgm_mtype_x86_any)
                  set $newiss = (x86_saved_state_t *) ($kgm_threadp->machine.iss)
                  set $kgm_x86_abi = $newiss.flavor
                  if ($newiss.flavor == 0xf)
                          printf "X86 Thread State (64-bit):\n"
                          set $kgm_ss64 = $newiss.uss.ss_64
  
                          printf "  rax: "
                          showuserptr $kgm_ss64.rax
                          printf "  rbx: "
                          showuserptr $kgm_ss64.rbx
                          printf "  rcx: "
                          showuserptr $kgm_ss64.rcx
                          printf "  rdx: "
                          showuserptr $kgm_ss64.rdx
                          printf "\n"
  
                          printf "  rdi: "
                          showuserptr $kgm_ss64.rdi
                          printf "  rsi: "
                          showuserptr $kgm_ss64.rsi
                          printf "  rbp: "
                          showuserptr $kgm_ss64.rbp
                          printf "  rsp: "
                          showuserptr $kgm_ss64.isf.rsp
                          printf "\n"
  
                          printf "   r8: "
                          showuserptr $kgm_ss64.r8
                          printf "   r9: "
                          showuserptr $kgm_ss64.r9
                          printf "  r10: "
                          showuserptr $kgm_ss64.r10
                          printf "  r11: "
                          showuserptr $kgm_ss64.r11
                          printf "\n"
  
                          printf "  r12: "
                          showuserptr $kgm_ss64.r12
                          printf "  r13: "
                          showuserptr $kgm_ss64.r13
                          printf "  r14: "
                          showuserptr $kgm_ss64.r14
                          printf "  r15: "
                          showuserptr $kgm_ss64.r15
                          printf "\n"
  
                          printf "  rip: "
                          showuserptr $kgm_ss64.isf.rip
                          printf "  rfl: "
                          showuserptr $kgm_ss64.isf.rflags
                          printf "  cr2: "
                          showuserptr $kgm_ss64.cr2
                          printf "\n"
                  else
                          printf "X86 Thread State (32-bit):\n"
                          set $kgm_ss32 = $newiss.uss.ss_32
  
                          printf "  eax: "
                          showuserptr $kgm_ss32.eax
                          printf "  ebx: "
                          showuserptr $kgm_ss32.ebx
                          printf "  ecx: "
                          showuserptr $kgm_ss32.ecx
                          printf "  edx: "
                          showuserptr $kgm_ss32.edx
                          printf "\n"
  
                          printf "  edi: "
                          showuserptr $kgm_ss32.edi
                          printf "  esi: "
                          showuserptr $kgm_ss32.esi
                          printf "  ebp: "
                          showuserptr $kgm_ss32.ebp
                          printf "  esp: "
                          showuserptr $kgm_ss32.uesp
                          printf "\n"
  
                          printf "   ss: "
                          showuserptr $kgm_ss32.ss
                          printf "  efl: "
                          showuserptr $kgm_ss32.efl
                          printf "  eip: "
                          showuserptr $kgm_ss32.eip
                          printf "   cs: "
                          showuserptr $kgm_ss32.cs
                          printf "\n"
  
                          printf "   ds: "
                          showuserptr $kgm_ss32.ds
                          printf "   es: "
                          showuserptr $kgm_ss32.es
                          printf "   fs: "
                          showuserptr $kgm_ss32.fs
                          printf "   gs: "
                          showuserptr $kgm_ss32.gs
                          printf "\n"
  
                          printf "  cr2: "
                          showuserptr $kgm_ss32.cr2
                          printf "\n"
                  end
          else
          if ($kgm_mtype == $kgm_mtype_arm)
                  printf "ARM Thread State:\n"
                  set $kgm_pcb = (arm_saved_state_t *) ($kgm_threadp->machine.upcb)
  
                  printf "    r0: "
                  showuserptr $kgm_pcb.r[0]
                  printf "    r1: "
                  showuserptr $kgm_pcb.r[1]
                  printf "    r2: "
                  showuserptr $kgm_pcb.r[2]
                  printf "    r3: "
                  showuserptr $kgm_pcb.r[3]
                  printf "\n"
  
                  printf "    r4: "
                  showuserptr $kgm_pcb.r[4]
                  printf "    r5: "
                  showuserptr $kgm_pcb.r[5]
                  printf "    r6: "
                  showuserptr $kgm_pcb.r[6]
                  printf "    r7: "
                  showuserptr $kgm_pcb.r[7]
                  printf "\n"
  
                  printf "    r8: "
                  showuserptr $kgm_pcb.r[8]
                  printf "    r9: "
                  showuserptr $kgm_pcb.r[9]
                  printf "   r10: "
                  showuserptr $kgm_pcb.r[10]
                  printf "   r11: "
                  showuserptr $kgm_pcb.r[11]
                  printf "\n"
  
                  printf "    ip: "
                  showuserptr $kgm_pcb.r[12]
                  printf "    sp: "
                  showuserptr $kgm_pcb.sp
                  printf "    lr: "
                  showuserptr $kgm_pcb.lr
                  printf "    pc: "
                  showuserptr $kgm_pcb.pc
                  printf "\n"
  
                  printf "  cpsr: "
                  showuserptr $kgm_pcb.cpsr
                  printf "\n"
          else
                  echo showuserregisters not supported on this architecture\n
          end
          end
  end
  document showuserregisters
  Syntax: showuserstack <address of thread>
  |This command displays the last known user register state
  |for the thread. This map not be correct for cases where
  |the thread is currently executing in userspace. However
  |for threads that have entered the kernel (either explicitly
  |with a system call or implicitly with a fault), it should
  |be accurate
  end
  
  define showtaskuserregisters
      set $kgm_taskp = (struct task *)$arg0
      set $kgm_head_actp = &($kgm_taskp->threads)
      set $kgm_actp = (struct thread *)($kgm_taskp->threads.next)
      while $kgm_actp != $kgm_head_actp
          printf "For thread "
          showptr $kgm_actp
          printf "\n"
          showuserregisters $kgm_actp
          set $kgm_actp = (struct thread *)($kgm_actp->task_threads.next)
          printf "\n"
      end
  end
  document showtaskuserregisters
  Syntax: (gdb) showtaskuserregisters <task>
  | Print out the user registers for each thread in a task
  end
  
  define kdp-reboot
  # Alternatively, set *(*(unsigned **) 0x2498) = 1 
  # (or 0x5498 on PPC, 0xffffff8000002928 on x86_64, 0xffff049c on arm)
         manualhdrint $kgm_kdp_pkt_hostreboot
         continue
  end
  
  document kdp-reboot
  Syntax: kdp-reboot
  |Reboot the remote target machine; not guaranteed to succeed. 
  end
  
  define kdpversionint
         # set up the manual KDP packet
         set manual_pkt.input = 0
         set manual_pkt.len = sizeof(kdp_version_req_t)
         set $kgm_pkt = (kdp_version_req_t *)&manual_pkt.data
         set $kgm_pkt->hdr.request  = KDP_VERSION
         set $kgm_pkt->hdr.len      = sizeof(kdp_version_req_t)
         set $kgm_pkt->hdr.is_reply = 0
         set $kgm_pkt->hdr.seq      = 0
         set $kgm_pkt->hdr.key      = 0
         set manual_pkt.input       = 1
         # dummy to make sure manual packet is executed
         set $kgm_dummy = &_mh_execute_header
         set $kgm_pkt = (kdp_version_reply_t *)&manual_pkt.data
         set $kgm_kdp_version = $kgm_pkt->version
         set $kgm_kdp_feature = $kgm_pkt->feature
  end
  
  define kdp-version
         kdpversionint
         printf "KDP VERSION = %d, FEATURE = 0x%x\n", $kgm_kdp_version, $kgm_kdp_feature
  end
  
  document kdp-version
  Syntax: kdp-version
  |Get the KDP protocol version being used by the kernel.
  end
  
  define dumpinfoint
         # set up the manual KDP packet
         set manual_pkt.input        = 0
  
         set manual_pkt.len          = sizeof(kdp_dumpinfo_req_t)
         set $kgm_pkt                = (kdp_dumpinfo_req_t *)&manual_pkt.data
         set $kgm_pkt->hdr.request  = KDP_DUMPINFO
         set $kgm_pkt->hdr.len      = sizeof(kdp_dumpinfo_req_t)
         set $kgm_pkt->hdr.is_reply = 0
         set $kgm_pkt->hdr.seq      = 0
         set $kgm_pkt->hdr.key      = 0
         set $kgm_pkt->type         = $arg0 
         set $kgm_pkt->name         = ""
         set $kgm_pkt->destip       = ""
         set $kgm_pkt->routerip     = ""
         set $kgm_pkt->port         = 0
  
         if $argc > 1
            set $kgm_pkt->name      = "$arg1"
         end
         if $argc > 2
            set $kgm_pkt->destip    = "$arg2"
         end
         if $argc > 3
            set $kgm_pkt->routerip  = "$arg3"
         end
         if $argc > 4
            set $kgm_pkt->port      = $arg4
         end
  
         set manual_pkt.input       = 1
         # dummy to make sure manual packet is executed
         set $kgm_dummy = &_mh_execute_header
  end
  
  define sendcore
         if $argc > 1
            dumpinfoint KDP_DUMPINFO_CORE $arg1 $arg0
         else
            dumpinfoint KDP_DUMPINFO_CORE \0 $arg0
         end
  end
  
  document sendcore
  Syntax: sendcore <IP address> [filename]
  |Configure the kernel to transmit a kernel coredump to a server (kdumpd) 
  |at the specified IP address. This is useful when the remote target has
  |not been previously configured to transmit coredumps, and you wish to
  |preserve kernel state for later examination. NOTE: You must issue a "continue"
  |command after using this macro to trigger the kernel coredump. The kernel
  |will resume waiting in the debugger after completion of the coredump. You
  |may disable coredumps by executing the "disablecore" macro. You can 
  |optionally specify the filename to be used for the generated core file.
  end
  
  define sendsyslog
         if $argc > 1
            dumpinfoint KDP_DUMPINFO_SYSTEMLOG $arg1 $arg0
         else
            dumpinfoint KDP_DUMPINFO_SYSTEMLOG \0 $arg0
         end
  end
  
  document sendsyslog
  Syntax: sendsyslog <IP address> [filename]
  |Configure the kernel to transmit a kernel system log to a server (kdumpd) 
  |at the specified IP address. NOTE: You must issue a "continue"
  |command after using this macro to trigger the kernel system log. The kernel
  |will resume waiting in the debugger after completion. You can optionally
  |specify the name to be used for the generated system log.
  end
  
  define sendpaniclog
         if panicstr 
            if $argc > 1
               dumpinfoint KDP_DUMPINFO_PANICLOG $arg1 $arg0
            else
               dumpinfoint KDP_DUMPINFO_PANICLOG \0 $arg0
            end
         else
            printf "No panic log available.\n"
         end
  end
  
  document sendpaniclog
  Syntax: sendpaniclog <IP address> [filename]
  |Configure the kernel to transmit a kernel paniclog to a server (kdumpd) 
  |at the specified IP address. NOTE: You must issue a "continue"
  |command after using this macro to trigger the kernel panic log. The kernel
  |will resume waiting in the debugger after completion. You can optionally
  |specify the name to be used for the generated panic log.
  end
  
  define getdumpinfo
         dumpinfoint KDP_DUMPINFO_GETINFO
         set $kgm_dumpinfo = (kdp_dumpinfo_reply_t *) manual_pkt.data
         if $kgm_dumpinfo->type & KDP_DUMPINFO_REBOOT
            printf "Sysem will reboot after kernel info gets dumped.\n"
         else
            printf "Sysem will not reboot after kernel info gets dumped.\n"
         end
         if $kgm_dumpinfo->type & KDP_DUMPINFO_NORESUME
            printf "System will allow a re-attach after a KDP disconnect.\n"
         else
            printf "System will resume after a KDP disconnect.\n"
         end
         set $kgm_dumpinfo_type = $kgm_dumpinfo->type & KDP_DUMPINFO_MASK
         if $kgm_dumpinfo_type == KDP_DUMPINFO_DISABLE
            printf "Kernel not setup for remote dumps.\n"
         else
            printf "Remote dump type: "
            if $kgm_dumpinfo_type == KDP_DUMPINFO_CORE
               printf "Core file\n"
            end
            if $kgm_dumpinfo_type == KDP_DUMPINFO_PANICLOG
               printf "Panic log\n"
            end
            if $kgm_dumpinfo_type == KDP_DUMPINFO_SYSTEMLOG
               printf "System log\n"
            end
  
            printf "Name: "
            if $kgm_dumpinfo->name[0] == '\0'
               printf "(autogenerated)\n"
            else
               printf "%s\n", $kgm_dumpinfo->name
            end             
  
            printf "Network Info: %s[%d] ", $kgm_dumpinfo->destip, $kgm_dumpinfo->port
            if $kgm_dumpinfo->routerip[0] == '\0'
               printf "\n"
            else
               printf "Router: %s\n", $kgm_dumpinfo->routerip
            end
         end
  end
  
  document getdumpinfo
  Syntax: getdumpinfo
  |Retrieve the current remote dump settings. 
  end
  
  define setdumpinfo
         dumpinfoint KDP_DUMPINFO_SETINFO $arg0 $arg1 $arg2 $arg3
  end
  
  document setdumpinfo
  Syntax: setdumpinfo <filename> <ip> <router> <port>
  |Configure the current remote dump settings. Specify \0 if you
  |want to use the defaults (filename) or previously configured
  |settings (ip/router). Specify 0 for the port if you wish to 
  |use the previously configured/default setting for that.
  end
  
  define disablecore
         dumpinfoint KDP_DUMPINFO_DISABLE
  end
  
  document disablecore
  Syntax: disablecore
  |Reconfigures the kernel so that it no longer transmits kernel coredumps. This
  |complements the "sendcore" macro, but it may be used if the kernel has been
  |configured to transmit coredumps through boot-args as well.
  end
  
  define switchtocorethread
          set $newact = (struct thread *) $arg0
          select 0
          if ($newact->kernel_stack == 0)
             echo This thread does not have a stack.\n
             echo continuation:
             output/a (unsigned) $newact.continuation
             echo \n
          else
          if ($kgm_mtype == $kgm_mtype_ppc)
             loadcontext $newact->machine->pcb
             flushstack
             set $pc = $newact->machine->pcb.save_srr0
          else
          if (($kgm_mtype & $kgm_mtype_x86_mask) == $kgm_mtype_x86_any)
                  set $kgm_cstatep = (struct x86_kernel_state *) \
                                          ($newact->kernel_stack + kernel_stack_size \
                                           - sizeof(struct x86_kernel_state))
                  loadcontext $kgm_cstatep
                  flushstack
          else
                  echo switchtocorethread not supported on this architecture\n
          end
          end
          showcontext_int
          end
  end
  
  document switchtocorethread
  Syntax: switchtocorethread <address of activation>
  | The corefile equivalent of "switchtoact". When debugging a kernel coredump
  | file, this command can be used to examine the execution context and stack
  | trace for a given thread activation. For example, to view the backtrace
  | for a thread issue "switchtocorethread <address>", followed by "bt".
  | Before resuming execution, issue a "resetcorectx" command, to
  | return to the original execution context. Note that this command
  | requires gdb support, as documented in Radar 3401283.
  end
  
  define loadcontext
          select 0
          if ($kgm_mtype == $kgm_mtype_ppc)
          set $kgm_contextp = (struct savearea *) $arg0
          set $pc = $kgm_contextp.save_srr0
          set $r1 = $kgm_contextp.save_r1
          set $lr = $kgm_contextp.save_lr
  
          set $r2 = $kgm_contextp.save_r2
          set $r3 = $kgm_contextp.save_r3
          set $r4 = $kgm_contextp.save_r4
          set $r5 = $kgm_contextp.save_r5
          set $r6 = $kgm_contextp.save_r6
          set $r7 = $kgm_contextp.save_r7
          set $r8 = $kgm_contextp.save_r8
          set $r9 = $kgm_contextp.save_r9
          set $r10 = $kgm_contextp.save_r10
          set $r11 = $kgm_contextp.save_r11
          set $r12 = $kgm_contextp.save_r12
          set $r13 = $kgm_contextp.save_r13
          set $r14 = $kgm_contextp.save_r14
          set $r15 = $kgm_contextp.save_r15
          set $r16 = $kgm_contextp.save_r16
          set $r17 = $kgm_contextp.save_r17
          set $r18 = $kgm_contextp.save_r18
          set $r19 = $kgm_contextp.save_r19
          set $r20 = $kgm_contextp.save_r20
          set $r21 = $kgm_contextp.save_r21
          set $r22 = $kgm_contextp.save_r22
          set $r23 = $kgm_contextp.save_r23
          set $r24 = $kgm_contextp.save_r24
          set $r25 = $kgm_contextp.save_r25
          set $r26 = $kgm_contextp.save_r26
          set $r27 = $kgm_contextp.save_r27
          set $r28 = $kgm_contextp.save_r28
          set $r29 = $kgm_contextp.save_r29
          set $r30 = $kgm_contextp.save_r30
          set $r31 = $kgm_contextp.save_r31
  
          set $cr = $kgm_contextp.save_cr
          set $ctr = $kgm_contextp.save_ctr
         else
          if ($kgm_mtype == $kgm_mtype_i386)
                  set $kgm_contextp = (struct x86_kernel_state *) $arg0
                  set $ebx = $kgm_contextp->k_ebx 
                  set $ebp = $kgm_contextp->k_ebp 
                  set $edi = $kgm_contextp->k_edi 
                  set $esi = $kgm_contextp->k_esi 
                  set $eip = $kgm_contextp->k_eip 
                  set $pc =  $kgm_contextp->k_eip
          else
          if ($kgm_mtype == $kgm_mtype_x86_64)
                  set $kgm_contextp = (struct x86_kernel_state *) $arg0
                  set $rbx = $kgm_contextp->k_rbx 
                  set $rbp = $kgm_contextp->k_rbp 
                  set $r12 = $kgm_contextp->k_r12 
                  set $r13 = $kgm_contextp->k_r13 
                  set $r14 = $kgm_contextp->k_r14 
                  set $r15 = $kgm_contextp->k_r15 
                  set $rip = $kgm_contextp->k_rip
                  set $pc = $kgm_contextp->k_rip
          else
                  echo loadcontext not supported on this architecture\n
          end
          end
          end
  end
  
  define resetcorectx
          select 0
          if ($kgm_mtype == $kgm_mtype_ppc)
                  set $kgm_corecontext = (struct savearea *) kdp.saved_state
                  loadcontext $kgm_corecontext
          else
          if ($kgm_mtype == $kgm_mtype_i386)
                  set $kdpstatep = (struct x86_saved_state32 *) kdp.saved_state
                  set $ebx = $kdpstatep->ebx
                  set $ebp = $kdpstatep->ebp
                  set $edi = $kdpstatep->edi
                  set $esi = $kdpstatep->esi
                  set $eip = $kdpstatep->eip
                  set $eax = $kdpstatep->eax
                  set $ecx = $kdpstatep->ecx
                  set $edx = $kdpstatep->edx
                  flushregs
                  flushstack
                  set $pc = $kdpstatep->eip
                  update
          else
                  echo resetcorectx not supported on this architecture\n
          end
          end
          showcontext_int
  end
  
  document resetcorectx
  Syntax: resetcorectx
  | The corefile equivalent of "resetctx". Returns to the original
  | execution context (that of the active thread at the time of the NMI or
  | panic). This command should be issued if you wish to resume
  | execution after using the "switchtocorethread" command.
  end
  
  #Helper function for "showallgdbstacks"
  
  define showgdbthread
          printf "            0x%08x  ", $arg0
          set $kgm_thread = *(struct thread *)$arg0
          printf "0x%08x  ", $arg0
          printf "%3d  ", $kgm_thread.sched_pri
          set $kgm_state = $kgm_thread.state
          if $kgm_state & 0x80
              printf "I" 
          end
          if $kgm_state & 0x40
              printf "P" 
          end
          if $kgm_state & 0x20
              printf "A" 
          end
          if $kgm_state & 0x10
              printf "H" 
          end
          if $kgm_state & 0x08
              printf "U" 
          end
          if $kgm_state & 0x04
              printf "R" 
          end
          if $kgm_state & 0x02
              printf "S" 
          end
          if $kgm_state & 0x01
              printf "W\t" 
              printf "0x%08x  ", $kgm_thread.wait_queue
              output /a (unsigned) $kgm_thread.wait_event
                  if ($kgm_thread.uthread != 0)
                          set $kgm_uthread = (struct uthread *)$kgm_thread.uthread
                          if ($kgm_uthread->uu_wmesg != 0)
                                  printf " \"%s\"", $kgm_uthread->uu_wmesg
                          end
              end
          end
          if $arg1 != 0
              if ($kgm_thread.kernel_stack != 0)
                  if ($kgm_thread.reserved_stack != 0)
                          printf "\n\t\treserved_stack=0x%08x", $kgm_thread.reserved_stack
                  end
                  printf "\n\t\tkernel_stack=0x%08x", $kgm_thread.kernel_stack
                  if ($kgm_mtype == $kgm_mtype_ppc)
                          set $mysp = $kgm_thread.machine.pcb->save_r1
                  end
                  if ($kgm_mtype == $kgm_mtype_i386)
                          set $kgm_statep = (struct x86_kernel_state *) \
                                  ($kgm_thread->kernel_stack + kernel_stack_size \
                                   - sizeof(struct x86_kernel_state))
                          set $mysp = $kgm_statep->k_ebp
                  end
                  if ($kgm_mtype == $kgm_mtype_arm)
                          if (((unsigned long)$r7 < ((unsigned long) ($kgm_thread->kernel_stack+kernel_stack_size))) \
                        && ((unsigned long)$r7 > (unsigned long) ($kgm_thread->kernel_stack)))
                                  set $mysp = $r7
                          else
                                  set $kgm_statep = (struct arm_saved_state *)$kgm_thread.machine.kstackptr
                                  set $mysp = $kgm_statep->r[7]
                          end
                  end
                  set $prevsp = 0
                  printf "\n\t\tstacktop=0x%08x", $mysp
                  if ($arg2 == 0)
                          switchtoact $arg0
                  else
                          switchtocorethread $arg0
                  end
                  bt
              else
                  printf "\n\t\t\tcontinuation="
                  output /a (unsigned) $kgm_thread.continuation
              end
              printf "\n"
          else
              printf "\n"
          end
  end         
  
  #Use of this macro is currently (8/04) blocked by the fact that gdb
  #stops evaluating macros when encountering an error, such as a failure
  #to read memory from a certain location. Until this issue (described in
  #3758949) is addressed, evaluation of this macro may stop upon
  #encountering such an error.
  
  define showallgdbstacks
      set $kgm_head_taskp = &tasks
      set $kgm_taskp = (struct task *)($kgm_head_taskp->next)
      while $kgm_taskp != $kgm_head_taskp
          showtaskheader
          showtaskint $kgm_taskp
          set $kgm_head_actp = &($kgm_taskp->threads)
          set $kgm_actp = (struct thread *)($kgm_taskp->threads.next)
          while $kgm_actp != $kgm_head_actp
              showactheader
              showgdbthread $kgm_actp 1 0
              set $kgm_actp = (struct thread *)($kgm_actp->task_threads.next)
          end
          printf "\n"
          set $kgm_taskp = (struct task *)($kgm_taskp->tasks.next)
      end
      resetctx
  end
  
  document showallgdbstacks
  Syntax: showallgdbstacks
  | An alternative to "showallstacks". Iterates through the task list and
  | displays a gdb generated backtrace for each kernel thread. It is
  | advantageous in that it is much faster than "showallstacks", and
  | decodes function call arguments and displays source level traces, but
  | it has the drawback that it doesn't determine if frames belong to
  | functions from kernel extensions, as with "showallstacks".
  | This command may terminate prematurely because of a gdb bug
  | (Radar 3758949), which stops macro evaluation on memory read
  | errors.
  end
  
  define showallgdbcorestacks
          select 0
          set $kgm_head_taskp = &tasks
          set $kgm_taskp = (struct task *)($kgm_head_taskp->next)
          while $kgm_taskp != $kgm_head_taskp
                  showtaskheader
                  showtaskint $kgm_taskp
                  set $kgm_head_actp = &($kgm_taskp->threads)
                  set $kgm_actp = (struct thread *)($kgm_taskp->threads.next)
                  while $kgm_actp != $kgm_head_actp
                  showactheader
                  showgdbthread $kgm_actp 1 1
                  set $kgm_actp = (struct thread *)($kgm_actp->task_threads.next)
                  end
                  printf "\n"
                  set $kgm_taskp = (struct task *)($kgm_taskp->tasks.next)
          end
          resetcorectx
  end
  
  
  document showallgdbcorestacks
  Syntax: showallgdbcorestacks
  |Corefile version of "showallgdbstacks"
  end
  
  
  define switchtouserthread
                  select 0
                  if ($kgm_mtype == $kgm_mtype_ppc)       
                     if ($kdp_act_counter == 0)
                        set $kdpstate = (struct savearea *) kdp.saved_state
                     end
                     set $kdp_act_counter = $kdp_act_counter + 1
                     set $newact = (struct thread *) $arg0
                     _kgm_flush_loop
                     set $checkpc = $newact->machine->upcb.save_srr0
                     if ($checkpc == 0)
                        echo This activation does not appear to have
                        echo \20 a valid user context.\n
                     else       
                       set (struct savearea *) kdp.saved_state=$newact->machine->upcb
                       set $pc = $checkpc
  #flush and update seem to be executed lazily by gdb on Tiger, hence the
  #repeated invocations - see 3743135
                      _kgm_flush_loop
  # This works because the new pmap is used only for reads
                       set kdp_pmap = $newact->task->map->pmap
                       _kgm_flush_loop
                       _kgm_update_loop
                     end
                  else
                     echo switchtouserthread not implemented for this architecture.\n
          end
  end
  
  document switchtouserthread
  Syntax: switchtouserthread <address of thread>
  | Analogous to switchtoact, but switches to the user context of a
  | specified thread address. Similar to the "showuserstack"
  | command, but this command does not return gdb to the kernel context
  | immediately. This is to assist with the following (rather risky)
  | manoeuvre - upon switching to the user context and virtual address
  | space, the user may choose to call remove-symbol-file on the
  | mach_kernel symbol file, and then add-symbol-file on the user space
  | binary's symfile. gdb can then generate symbolic backtraces 
  | for the user space thread. To return to the
  | kernel context and virtual address space, the process must be
  | reversed, i.e. call remove-symbol-file on the user space symbols, and
  | then add-symbol-file on the appropriate mach_kernel, and issue the
  | "resetstacks" command. Note that gdb may not react kindly to all these
  | symbol file switches. The same restrictions that apply to "showuserstack"
  | apply here - pages that have been paged out cannot be read while in the
  | debugger context, so backtraces may terminate early.
  | If the virtual addresses in the stack trace do not conflict with those
  | of symbols in the kernel's address space, it may be sufficient to
  | just do an add-symbol-file on the user space binary's symbol file.
  | Note that while this command works on Panther's gdb, an issue
  | with Tiger gdb (3743135) appears to hamper the evaluation of this
  | macro in some cases.
  end
  
  define showmetaclass
      set $kgm_metaclassp = (OSMetaClass *)$arg0
      printf "%-5d", $kgm_metaclassp->instanceCount
      printf "x %5d bytes", $kgm_metaclassp->classSize
      printf " %s\n", $kgm_metaclassp->className->string
  end
  
  define showstring
      printf "\"%s\"", ((OSString *)$arg0)->string
  end
  
  define shownumber
      printf "%lld", ((OSNumber *)$arg0)->value
  end
  
  define showboolean
      if ($arg0 == gOSBooleanFalse)
          printf "No"
      else
          printf "Yes"
      end
  end
  
  define showdatabytes
      set $kgm_data = (OSData *)$arg0
  
      printf "<"
      set $kgm_datap = (const unsigned char *) $kgm_data->data
          set $kgm_idx = 0
          while ( $kgm_idx < $kgm_data->length )
                  printf "%02X", *$kgm_datap
                  set $kgm_datap = $kgm_datap + 1
                  set $kgm_idx = $kgm_idx + 1
          end
          printf ">\n"
  end
  
  define showdata
      set $kgm_data = (OSData *)$arg0
  
      printf "<"
      set $kgm_datap = (const unsigned char *) $kgm_data->data
  
      set $kgm_printstr = 0
      if (0 == (3 & (unsigned int)$kgm_datap) && ($kgm_data->length >= 3))
          set $kgm_bytes = *(unsigned int *) $kgm_datap
          if (0xffff0000 & $kgm_bytes)
              set $kgm_idx = 0
              set $kgm_printstr = 1
              while ($kgm_idx++ < 4)
                  set $kgm_bytes = $kgm_bytes >> 8
                  set $kgm_char = 0xff & $kgm_bytes
                  if ($kgm_char && (($kgm_char < 0x20) || ($kgm_char > 0x7e)))
                      set $kgm_printstr = 0
                  end
              end
          end
      end
      
      set $kgm_idx = 0
      if ($kgm_printstr)
          set $kgm_quoted = 0
          while ($kgm_idx < $kgm_data->length)
              set $kgm_char = $kgm_datap[$kgm_idx++]
              if ($kgm_char)
                  if (0 == $kgm_quoted)
                      set $kgm_quoted = 1
                      if ($kgm_idx > 1)
                          printf ",\""
                      else
                          printf "\""
                      end
                  end
                  printf "%c", $kgm_char
              else
                  if ($kgm_quoted)
                      set $kgm_quoted = 0
                      printf "\""
                  end
              end
          end
          if ($kgm_quoted)
              printf "\""
          end
      else
          if (0 == (3 & (unsigned int)$kgm_datap))
              while (($kgm_idx + 3) <= $kgm_data->length)
                  printf "%08x", *(unsigned int *) &$kgm_datap[$kgm_idx]
                  set $kgm_idx = $kgm_idx + 4
              end
          end
          while ($kgm_idx < $kgm_data->length)
              printf "%02x", $kgm_datap[$kgm_idx++]
          end
      end
      printf ">"
  end
  
  define showdictionaryint
      set $kgm$arg0_dict = (OSDictionary *)$arg1
  
      printf "{"
      set $kgm$arg0_idx = 0
      while ($kgm$arg0_idx < $kgm$arg0_dict->count)
          set $kgm_obj = $kgm$arg0_dict->dictionary[$kgm$arg0_idx].key
          showobjectint _$arg0 $kgm_obj
          printf "="
          set $kgm_obj = $kgm$arg0_dict->dictionary[$kgm$arg0_idx++].value
          showobjectint _$arg0 $kgm_obj
          if ($kgm$arg0_idx < $kgm$arg0_dict->count)
              printf ","
          end
      end
      printf "}"
  end
  
  define indent
      set $kgm_idx = 0
      while ($kgm_idx < $arg0)
          if ($arg1 & (1 << $kgm_idx++))
              printf "| "
          else
              printf "  "
          end
      end
  end
  
  define showregdictionary
      indent $kgm_reg_depth+2 $arg1
      printf "{\n"
  
      set $kgm_reg_idx = 0
      while ($kgm_reg_idx < $arg0->count)
          indent $kgm_reg_depth+2 $arg1
          printf "  "
          set $kgm_obj = $arg0->dictionary[$kgm_reg_idx].key
          showobjectint _ $kgm_obj
          printf " = "
  
          set $kgm_obj = $arg0->dictionary[$kgm_reg_idx++].value
          showobjectint _ $kgm_obj
          printf "\n"
      end
      indent $kgm_reg_depth+2 $arg1
      printf "}\n"
  end
  
  
  define showorderedsetarrayint
      set $kgm$arg0_array = (_Element *)$arg1
      set $kgm$arg0_count = $arg2
  
      set $kgm$arg0_idx = 0
      while ($kgm$arg0_idx < $kgm$arg0_count)
          set $kgm_obj = $kgm$arg0_array[$kgm$arg0_idx++]
          showobjectint _$arg0 $kgm_obj
          if ($kgm$arg0_idx < $kgm$arg0_count)
              printf ","
          end
      end
  end
  
  define showorderedsetint
      set $kgm_array = ((OSOrderedSet *)$arg1)->array
      set $count = ((OSOrderedSet *)$arg1)->count
      printf "["
      showorderedsetarrayint $arg0 $kgm_array $count
      printf "]"
  end
  
  define showarraysetint
      set $kgm$arg0_array = (OSArray *)$arg1
  
      set $kgm$arg0_idx = 0
      while ($kgm$arg0_idx < $kgm$arg0_array->count)
          set $kgm_obj = $kgm$arg0_array->array[$kgm$arg0_idx++]
          showobjectint _$arg0 $kgm_obj
          if ($kgm$arg0_idx < $kgm$arg0_array->count)
              printf ","
          end
      end
  end
  
  define showarrayint
      printf "("
      showarraysetint $arg0 $arg1
      printf ")"
  end
  
  define showsetint
      set $kgm_array = ((OSSet *)$arg1)->members
      printf "["
      showarraysetint $arg0 $kgm_array
      printf "]"
  end
  
  
  define showobjectint
      set $kgm_obj = (OSObject *) $arg1
      set $kgm_vt = *((void **) $arg1)
  
      if ($kgm_lp64 || $kgm_mtype == $kgm_mtype_arm)
          set $kgm_vt = $kgm_vt - 2 * sizeof(void *)
      end
  
      if ($kgm_show_object_addrs)
          printf "`object "
          showptr $arg1
          printf ", vt "
          output /a (unsigned long) $kgm_vt
          if ($kgm_show_object_retain)
              printf ", retain count %d, container retain %d", (0xffff & $kgm_obj->retainCount), $kgm_obj->retainCount >> 16
          end
          printf "` "
      end
  
      # No multiple-inheritance
      set $kgm_shown = 0
      if ($kgm_vt == &_ZTV8OSString)
          showstring $arg1
          set $kgm_shown = 1
      end
          if ($kgm_vt == &_ZTV8OSSymbol)
              showstring $arg1
          set $kgm_shown = 1
      end
      if ($kgm_vt == &_ZTV8OSNumber)
                  shownumber $arg1
          set $kgm_shown = 1
      end
      if ($kgm_vt == &_ZTV6OSData)
          if $kgm_show_data_alwaysbytes == 1
              showdatabytes $arg1
          else
              showdata $arg1
          end
          set $kgm_shown = 1
      end
      if ($kgm_vt == &_ZTV9OSBoolean)
          showboolean $arg1
          set $kgm_shown = 1
      end
      if ($kgm_vt == &_ZTV12OSDictionary)
          showdictionaryint _$arg0 $arg1
          set $kgm_shown = 1
      end
      if ($kgm_vt == &_ZTV7OSArray)
          showarrayint _$arg0 $arg1
          set $kgm_shown = 1
      end
      if ($kgm_vt == &_ZTV5OSSet)
          showsetint _$arg0 $arg1
          set $kgm_shown = 1
      end
      if ($kgm_vt == &_ZTV12OSOrderedSet)
          showorderedsetint _$arg0 $arg1
          set $kgm_shown = 1
      end
      
      if ($kgm_shown != 1)
          if ($kgm_show_object_addrs == 0)
              printf "`object "
              showptr $arg1
              printf ", vt "
              output /a (unsigned long) $kgm_vt
              printf "`"
          end
      end
  end
  
  define showobject
      set $kgm_save = $kgm_show_object_addrs
      set $kgm_show_object_addrs = 1
      set $kgm_show_object_retain = 1
      showobjectint _ $arg0
      set $kgm_show_object_addrs = $kgm_save
      set $kgm_show_object_retain = 0
      printf "\n"
  end
  document showobject
  Syntax: (gdb) showobject <object address>
  | Show info about an OSObject - its vtable ptr and retain count.
  | If the object is a simple container class, more info will be shown.
  end
  
  define dictget 
      set $kgm_dictp = (OSDictionary *)$arg0
      set $kgm_keyp = (const OSSymbol *)$arg1
      set $kgm_idx = 0
      set $kgm_result = 0
      while (($kgm_idx < $kgm_dictp->count) && ($kgm_result == 0))
          if ($kgm_keyp == $kgm_dictp->dictionary[$kgm_idx].key)
              set $kgm_result = $kgm_dictp->dictionary[$kgm_idx].value
          end
          set $kgm_idx = $kgm_idx + 1
      end
  end
  
  
  define _registryentryrecurseinit
      set $kgm_re         = (IOService *)$arg1
      set $kgm$arg0_stack = (unsigned long long) $arg2
  
      if ($arg3)
          set $kgm$arg0_stack = $kgm$arg0_stack | (1ULL << $kgm_reg_depth)
      else
          set $kgm$arg0_stack = $kgm$arg0_stack & ~(1ULL << $kgm_reg_depth)
      end
  
      dictget $kgm_re->fRegistryTable $kgm_childkey
      set $kgm$arg0_child_array = (OSArray *) $kgm_result
  
      if ($kgm$arg0_child_array)
          set $kgm$arg0_child_count = $kgm$arg0_child_array->count
      else
          set $kgm$arg0_child_count = 0
      end
  
      if ($kgm$arg0_child_count)
          set $kgm$arg0_stack = $kgm$arg0_stack | (2ULL << $kgm_reg_depth)
      else
          set $kgm$arg0_stack = $kgm$arg0_stack & ~(2ULL << $kgm_reg_depth)
      end
  end
  
  define findregistryentryrecurse
      set $kgm_registry_entry = 0
      _registryentryrecurseinit $arg0 $arg1 $arg2 $arg3
  
      dictget $kgm_re->fRegistryTable $kgm_namekey
      if ($kgm_result == 0)
          dictget $kgm_re->fRegistryTable gIONameKey
      end
      if ($kgm_result == 0)
          dictget $kgm_re->fPropertyTable gIOClassKey
      end
  
      if ($kgm_result != 0)
         set $str = ((OSString *) $kgm_result)->string
         strcmp_nomalloc $str $kgm_reg_find_str0 $kgm_reg_find_str1 $kgm_reg_find_str2 $kgm_reg_find_str3 $kgm_reg_find_str4 $kgm_reg_find_str5 $kgm_reg_find_str6 $kgm_reg_find_str7 $kgm_reg_find_str8 
         if $kgm_findregistry_verbose
            echo .
         end
  
         if $kgm_strcmp_result == 0
            if $kgm_findregistry_verbose
               printf "\n%s:\n | ", ((OSString *) $kgm_result)->string
               showobject $kgm_re
               printf " | "
               print $kgm_re
            end
  
            # don't populate $kgm_registry_entry if we want to show everything
            if !$kgm_findregistry_continue
               set $kgm_registry_entry = $kgm_re
            end
         end
      end
  
      # recurse
      if (!$kgm_registry_entry && ($kgm$arg0_child_count != 0))
          set $kgm_reg_depth = $kgm_reg_depth + 1
          set $kgm$arg0_child_idx = 0
  
          while ($kgm$arg0_child_idx < $kgm$arg0_child_count)
              set $kgm_re = $kgm$arg0_child_array->array[$kgm$arg0_child_idx++]
              set $kgm_more_sib = ($kgm$arg0_child_idx < $kgm$arg0_child_count)
              if $kgm_reg_depth >= $kgm_reg_depth_max + 1
                 loop_break
              end
              findregistryentryrecurse _$arg0 $kgm_re $kgm$arg0_stack $kgm_more_sib 
              if $kgm_registry_entry
                 loop_break
              end
          end
          set $kgm_reg_depth = $kgm_reg_depth - 1
      end
  end
  
  define findregdictvalue
      set $kgm_registry_value = 0
      set $kgm_reg_idx = 0
      while ($kgm_reg_idx < $arg0->count)
          set $kgm_obj = $arg0->dictionary + $kgm_reg_idx
          set $str = ((OSString *)$kgm_obj->key)->string
          strcmp_nomalloc $str $kgm_reg_find_str0 $kgm_reg_find_str1 $kgm_reg_find_str2 $kgm_reg_find_str3 $kgm_reg_find_str4 $kgm_reg_find_str5 $kgm_reg_find_str6 $kgm_reg_find_str7 $kgm_reg_find_str8 
  
          if $kgm_strcmp_result == 0
             set $kgm_registry_value = $kgm_obj->value
             if $kgm_findregistry_verbose
                showobject $kgm_registry_value
                print $kgm_registry_value
             end
             loop_break
          end
          set $kgm_reg_idx = $kgm_reg_idx + 1
      end
  end
  
  define setfindregistrystr
      set $kgm_reg_find_str0 = 0
      set $kgm_reg_find_str1 = 0
      set $kgm_reg_find_str2 = 0
      set $kgm_reg_find_str3 = 0
      set $kgm_reg_find_str4 = 0
      set $kgm_reg_find_str5 = 0
      set $kgm_reg_find_str6 = 0
      set $kgm_reg_find_str7 = 0
      set $kgm_reg_find_str8 = 0
  
      if $argc > 0
         set $kgm_reg_find_str0 = $arg0
      end
      if $argc > 1
         set $kgm_reg_find_str1 = $arg1
      end
      if $argc > 2
         set $kgm_reg_find_str2 = $arg2
      end
      if $argc > 3
         set $kgm_reg_find_str3 = $arg3
      end
      if $argc > 4
         set $kgm_reg_find_str4 = $arg4
      end
      if $argc > 5
         set $kgm_reg_find_str5 = $arg5
      end
      if $argc > 6
         set $kgm_reg_find_str6 = $arg6
      end
      if $argc > 7
         set $kgm_reg_find_str7 = $arg7
      end
      if $argc > 8
         set $kgm_reg_find_str8 = $arg8
      end
  end
  
  document setfindregistrystr
  Syntax: (gdb) setfindregistrystr [a] [b] [c] [d] [e] [f] [g] [h] [i]
  | Store an encoded string into up to 9 arguments for use by 
  | findregistryprop or findregistryentry. The arguments are created
  | through calls to strcmp_arg_pack64
  end
  
  define _findregistryprop
      set $reg       = (IOService *) $arg0
      set $kgm_props = $reg->fPropertyTable
      set $kgm_findregistry_verbose = 0
  
      findregdictvalue $kgm_props 
  end
  
  define findregistryprop
      set $reg       = (IOService *) $arg0
      set $kgm_props = $reg->fPropertyTable
  
      set $kgm_findregistry_verbose = 1
      findregdictvalue $kgm_props 
  end
  
  document findregistryprop
  Syntax: (gdb) findregistryprop <entry>
  | Given a registry entry, print out the contents for the property that matches
  | the encoded string specified via setfindregistrystr.
  |
  | For example, the following will print out the "intel-pic" property stored in
  | the AppleACPIPlatformExpert registry entry $pe_entry:
  |            strcmp_arg_pack64 'i' 'n' 't' 'e' 'l' '-' 'p' 'i' 
  |            set $intel_pi = $kgm_strcmp_arg
  |            strcmp_arg_pack64 'c' 0 0 0 0 0 0 0
  |            set $c = $kgm_strcmp_arg
  |            setfindregistrystr $intel_pi $c
  |            findregistryprop $pe_entry
  end
  
  define findregistryentryint
      if !$kgm_reg_plane
         set $kgm_reg_plane = (IORegistryPlane *) gIOServicePlane
      end
  
      if !$kgm_reg_plane
         printf "Please load kgmacros after KDP attaching to the target.\n"
      else
         set $kgm_namekey   = (OSSymbol *) $kgm_reg_plane->nameKey
         set $kgm_childkey  = (OSSymbol *) $kgm_reg_plane->keys[1]
         if $kgm_findregistry_verbose
            printf "Searching"
         end
         findregistryentryrecurse _ $arg0 0 0
      end
  end
  
  define _findregistryentry
      set $kgm_findregistry_verbose  = 0
      set $kgm_findregistry_continue = 0
      set $kgm_reg_depth             = 0
  
      findregistryentryint gRegistryRoot
  end
  
  define findregistryentry
      set $kgm_findregistry_verbose  = 1
      set $kgm_findregistry_continue = 0
      set $kgm_reg_depth             = 0
  
      findregistryentryint gRegistryRoot
  end
  
  define findregistryentries
      set $kgm_findregistry_verbose  = 1
      set $kgm_findregistry_continue = 1
      set $kgm_reg_depth             = 0
  
      findregistryentryint gRegistryRoot
  end
  
  document findregistryentry
  Syntax: (gdb) findregistryentry
  | Search for a registry entry that matches the encoded string specified through
  | setfindregistrystr. You can alter the search depth through use of 
  | $kgm_reg_depth_max.
  |
  | For example, the following will pull out the AppleACPIPlatformExpert registry
  | entry:
  |         strcmp_arg_pack64 'A' 'p' 'p' 'l' 'e' 'A' 'C' 'P'
  |         set $AppleACP = $kgm_strcmp_arg
  |         strcmp_arg_pack64 'I' 'P' 'l' 'a' 't' 'f' 'o' 'r'
  |         set $IPlatfor = $kgm_strcmp_arg
  |         strcmp_arg_pack64 'm' 'E' 'x' 'p' 'e' 'r' 't' 0
  |         set $mExpert = $kgm_strcmp_arg
  |         setfindregistrystr $AppleACP $IPlatfor $mExpert
  |         findregistryentry
  end
  
  document findregistryentries
  Syntax: (gdb) findregistryentries
  | Search for all registry entries that match the encoded string specified through
  | setfindregistrystr. You can alter the search depth through use of 
  | $kgm_reg_depth_max. See findregistryentry for an example of how to encode a string.
  end
  
  
  define showregistryentryrecurse
      _registryentryrecurseinit $arg0 $arg1 $arg2 $arg3
  
      indent $kgm_reg_depth $kgm$arg0_stack
      printf "+-o "
  
      dictget $kgm_re->fRegistryTable $kgm_namekey
      if ($kgm_result == 0)
          dictget $kgm_re->fRegistryTable gIONameKey
      end
      if ($kgm_result == 0)
          dictget $kgm_re->fPropertyTable gIOClassKey
      end
  
      if ($kgm_result != 0)
          printf "%s", ((OSString *)$kgm_result)->string
      else
          if (((IOService*)$kgm_re)->pwrMgt &&  ((IOService*)$kgm_re)->pwrMgt->Name)
              printf "%s", ((IOService*)$kgm_re)->pwrMgt->Name
          else
  #           printf ", guessclass "
  #           guessclass $kgm_re
              printf "??"
          end
      end
  
  
      printf "  <object "
      showptr $kgm_re
      printf ", id 0x%llx, ", $kgm_re->IORegistryEntry::reserved->fRegistryEntryID
      printf "vtable "
      set $kgm_vt = (unsigned long) *(void**) $kgm_re
      if ($kgm_lp64 || $kgm_mtype == $kgm_mtype_arm)
          set $kgm_vt = $kgm_vt - 2 * sizeof(void *)
      end
      output /a $kgm_vt
  
      if ($kgm_vt != &_ZTV15IORegistryEntry)
          printf ", "
          set $kgm_state =  $kgm_re->__state[0]
          # kIOServiceRegisteredState
          if (0 == ($kgm_state & 2))
              printf "!"
          end
          printf "registered, "
          # kIOServiceMatchedState
          if (0 == ($kgm_state & 4))
              printf "!"
          end
          printf "matched, "
          # kIOServiceInactiveState
          if ($kgm_state & 1)
              printf "in"
          end
          printf "active, busy %d, retain count %d", (0xff & $kgm_re->__state[1]), (0xffff & $kgm_re->retainCount)
      end
      printf ">\n"
  
      if ($kgm_show_props)
          set $kgm_props = $kgm_re->fPropertyTable
          showregdictionary $kgm_props $kgm$arg0_stack
      end
  
      # recurse
      if ($kgm$arg0_child_count != 0)
  
          set $kgm_reg_depth = $kgm_reg_depth + 1
          set $kgm$arg0_child_idx = 0
  
          while ($kgm$arg0_child_idx < $kgm$arg0_child_count)
              set $kgm_re = $kgm$arg0_child_array->array[$kgm$arg0_child_idx++]
              set $kgm_more_sib = ($kgm$arg0_child_idx < $kgm$arg0_child_count)
              if $kgm_reg_depth >= $kgm_reg_depth_max + 1
                 loop_break
              end
              showregistryentryrecurse _$arg0 $kgm_re $kgm$arg0_stack $kgm_more_sib
          end
  
          set $kgm_reg_depth = $kgm_reg_depth - 1
      end
  end
  
  define showregistryentryint
      if !$kgm_reg_plane
         set $kgm_reg_plane = (IORegistryPlane *) gIOServicePlane
      end
  
      if !$kgm_reg_plane
         printf "Please load kgmacros after KDP attaching to the target.\n"
      else        
         set $kgm_namekey   = (OSSymbol *) $kgm_reg_plane->nameKey
         set $kgm_childkey  = (OSSymbol *) $kgm_reg_plane->keys[1]
         showregistryentryrecurse _ $arg0 0 0
      end
  end
  
  define showregistry
      set $kgm_reg_depth  = 0
      set $kgm_show_props = 0
      showregistryentryint gRegistryRoot
  end
  document showregistry
  Syntax: (gdb) showregistry 
  | Show info about all registry entries in the current plane. You can specify the maximum
  | display depth with $kgm_reg_depth_max.
  end
  
  define showregistryprops
      set $kgm_reg_depth  = 0
      set $kgm_show_props = 1
      showregistryentryint gRegistryRoot
  end
  document showregistryprops
  Syntax: (gdb) showregistryprops 
  | Show info about all registry entries in the current plane, and their properties.
  | set $kgm_show_object_addrs = 1 and/or set $kgm_show_object_retain = 1 will display
  | more verbose information
  end
  
  define showregistryentry
      set $kgm_reg_depth  = 0
      set $kgm_show_props = 1
      showregistryentryint $arg0
  end
  document showregistryentry
  Syntax: (gdb) showregistryentry <object address>
  | Show info about a registry entry; its properties and descendants in the current plane.
  end
  
  define setregistryplane
      if ($arg0 != 0)
          set $kgm_reg_plane = (IORegistryPlane *) $arg0
      else
          showobjectint _ gIORegistryPlanes
          printf "\n"
      end
  end
  document setregistryplane
  Syntax: (gdb) setregistryplane <plane object address>
  | Set the plane to be used for the iokit registry macros. An argument of zero will 
  | display known planes.
  end
  
  define guessclass
      set $kgm_classidx = 0
      set $kgm_lookvt = *((void **) $arg0)
      set $kgm_bestvt = (void *) 0
      set $kgm_bestidx = 0
      
      while $kgm_classidx < sAllClassesDict->count
          set $kgm_meta = (OSMetaClass *) sAllClassesDict->dictionary[$kgm_classidx].value
  
          set $kgm_vt = *((void **) $kgm_meta)
  
          if (($kgm_vt > $kgm_bestvt) && ($kgm_vt < $kgm_lookvt))
              set $kgm_bestvt  = $kgm_vt
              set $kgm_bestidx = $kgm_classidx
          end
          set $kgm_classidx = $kgm_classidx + 1
      end
      printf "%s", sAllClassesDict->dictionary[$kgm_bestidx].key->string
  end
  
  define showallclasses
      set $kgm_classidx = 0
      while $kgm_classidx < sAllClassesDict->count
          set $kgm_meta = (OSMetaClass *) sAllClassesDict->dictionary[$kgm_classidx++].value
          showmetaclass $kgm_meta
      end
  end
  
  document showallclasses
  Syntax: (gdb) showallclasses
  | Show the instance counts and ivar size of all OSObject subclasses. See ioclasscount man page for details.
  end
  
  define showioalloc
      printf " Instance allocation = 0x%08lx = %4ld K\n", (int) debug_ivars_size, ((int) debug_ivars_size) / 1024
      printf "Container allocation = 0x%08lx = %4ld K\n", (int) debug_container_malloc_size, ((int) debug_container_malloc_size) / 1024
      printf " IOMalloc allocation = 0x%08lx = %4ld K\n", (int) debug_iomalloc_size, ((int) debug_iomalloc_size) / 1024
      printf " Pageable allocation = 0x%08lx = %4ld K\n", (vm_size_t) debug_iomallocpageable_size, ((vm_size_t) debug_iomallocpageable_size) / 1024
  end
  
  document showioalloc
  Syntax: (gdb) showioalloc
  | Show some accounting of memory allocated by IOKit allocators. See ioalloccount man page for details.
  end
  
  define showosobjecttracking
      set $kgm_next = (OSObjectTracking *) gOSObjectTrackList.next
      while $kgm_next != &gOSObjectTrackList
          set $obj = (OSObject *) ($kgm_next+1)
          showobject $obj
          set $kgm_idx = 0
          while $kgm_idx < (sizeof($kgm_next->bt) / sizeof($kgm_next->bt[0]))
              if ((unsigned long) $kgm_next->bt[$kgm_idx] > (unsigned long) &last_kernel_symbol)
                  showkmodaddr $kgm_next->bt[$kgm_idx]
                  printf "\n"
              else
                  if ((unsigned long) $kgm_next->bt[$kgm_idx] > 0)
                      output /a $kgm_next->bt[$kgm_idx]
                      printf "\n"
                  end
              end
              set $kgm_idx = $kgm_idx + 1
          end
          printf "\n"
          set $kgm_next = (OSObjectTracking *) $kgm_next->link.next
      end
  end
  
  document showosobjecttracking
  Syntax: (gdb) showosobjecttracking
  | Show the list of tracked OSObject allocations with backtraces.
  | Boot with the kOSTraceObjectAlloc (0x00400000) io debug flag set. 
  | Set gOSObjectTrackThread to 1 or a thread_t to capture new OSObjects allocated by a thread or all threads.
  end
  
  # $kgm_readphys_force_kdp and $kgm_readphys_force_physmap
  # can respectively cause physical memory access to use
  # a KDP manual packet or the physical memory mapping
  # even if the default behavior would be otherwise.
  define readphysint
      set $kgm_readphysint_result = 0xBAD10AD
  
      if ($kgm_readphys_force_kdp != 0)
          set $kgm_readphys_use_kdp = 1
      else
          if ($kgm_readphys_force_physmap)
              set $kgm_readphys_use_kdp = 0
          else
              set $kgm_readphys_use_kdp = ( kdp->is_conn > 0 )
          end
      end
  
      if ($kgm_readphys_use_kdp)
  
          # set up the manual KDP packet
          set manual_pkt.input = 0
          set manual_pkt.len = sizeof(kdp_readphysmem64_req_t)
          set $kgm_pkt = (kdp_readphysmem64_req_t *)&manual_pkt.data
          set $kgm_pkt->hdr.request  = KDP_READPHYSMEM64
          set $kgm_pkt->hdr.len      = sizeof(kdp_readphysmem64_req_t)
          set $kgm_pkt->hdr.is_reply = 0
          set $kgm_pkt->hdr.seq      = 0
          set $kgm_pkt->hdr.key      = 0
          set $kgm_pkt->address      = (uint64_t)$arg0
          set $kgm_pkt->nbytes       = $arg1 >> 3
          set $kgm_pkt->lcpu         = $arg2
          set manual_pkt.input       = 1
          # dummy to make sure manual packet is executed
          set $kgm_dummy = &_mh_execute_header
          set $kgm_pkt = (kdp_readphysmem64_reply_t *)&manual_pkt.data
          if ($kgm_pkt->error == 0)
              if $arg1 == 8
                  set $kgm_readphysint_result = *((uint8_t *)$kgm_pkt->data)
              end
              if $arg1 == 16
                  set $kgm_readphysint_result = *((uint16_t *)$kgm_pkt->data)
              end
              if $arg1 == 32
                  set $kgm_readphysint_result = *((uint32_t *)$kgm_pkt->data)
              end
              if $arg1 == 64
                  set $kgm_readphysint_result = *((uint64_t *)$kgm_pkt->data)
              end
          end
  
      else
          # No KDP. Attempt to use physical memory mapping
  
          if ($kgm_mtype == $kgm_mtype_x86_64)
              set $kgm_readphys_paddr_in_kva = (unsigned long long)$arg0 + (((unsigned long long)-1 << 47) | ((unsigned long long)509 << 39))
          else
              if ($kgm_mtype == $kgm_mtype_arm)
                  set $kgm_readphys_paddr_in_kva = (unsigned long long)$arg0 - gPhysBase + gVirtBase
              else
                  printf "readphys not available for current architecture.\n"
                  set $kgm_readphys_paddr_in_kva = 0
              end
          end
          if $kgm_readphys_paddr_in_kva
              if $arg1 == 8
                  set $kgm_readphysint_result = *((uint8_t *)$kgm_readphys_paddr_in_kva)
              end
              if $arg1 == 16
                  set $kgm_readphysint_result = *((uint16_t *)$kgm_readphys_paddr_in_kva)
              end
              if $arg1 == 32
                  set $kgm_readphysint_result = *((uint32_t *)$kgm_readphys_paddr_in_kva)
              end
              if $arg1 == 64
                  set $kgm_readphysint_result = *((uint64_t *)$kgm_readphys_paddr_in_kva)
              end
          end
      end
  end
  
  define readphys8
         readphysint $arg0 8 $kgm_lcpu_self
         output /a $arg0
         printf ":\t0x%02hhx\n", $kgm_readphysint_result
         set $kgm_readphys_result = (uint64_t)$kgm_readphysint_result
  end
  
  define readphys16
         readphysint $arg0 16 $kgm_lcpu_self
         output /a $arg0
         printf ":\t0x%04hx\n", $kgm_readphysint_result
         set $kgm_readphys_result = (uint64_t)$kgm_readphysint_result
  end
  
  define readphys32
         readphysint $arg0 32 $kgm_lcpu_self
         output /a $arg0
         printf ":\t0x%08x\n", $kgm_readphysint_result
         set $kgm_readphys_result = (uint64_t)$kgm_readphysint_result
  end
  
  define readphys64
         readphysint $arg0 64 $kgm_lcpu_self
         output /a $arg0
         printf ":\t0x%016llx\n", $kgm_readphysint_result
         set $kgm_readphys_result = (uint64_t)$kgm_readphysint_result
  end
  
  define readphys
         readphys32 $arg0
  end
  
  document readphys8
  | See readphys64
  end
  
  document readphys16
  | See readphys64
  end
  
  document readphys32
  | See readphys64
  end
  
  document readphys64
  | The argument is interpreted as a physical address, and the 64-bit word
  | addressed is displayed. Saves 64-bit result in $kgm_readphys_result.
  end
  
  define writephysint
         # set up the manual KDP packet
         set manual_pkt.input = 0
         set manual_pkt.len = sizeof(kdp_writephysmem64_req_t)
         set $kgm_pkt = (kdp_writephysmem64_req_t *)&manual_pkt.data
         set $kgm_pkt->hdr.request  = KDP_WRITEPHYSMEM64
         set $kgm_pkt->hdr.len      = sizeof(kdp_writephysmem64_req_t)
         set $kgm_pkt->hdr.is_reply = 0
         set $kgm_pkt->hdr.seq      = 0
         set $kgm_pkt->hdr.key      = 0
         set $kgm_pkt->address      = (uint64_t)$arg0
         set $kgm_pkt->nbytes       = $arg1 >> 3
         set $kgm_pkt->lcpu         = $arg3
         if $arg1 == 8
            set *(uint8_t *)$kgm_pkt->data = (uint8_t)$arg2
         end
         if $arg1 == 16
            set *(uint16_t *)$kgm_pkt->data = (uint16_t)$arg2
         end
         if $arg1 == 32
            set *(uint32_t *)$kgm_pkt->data = (uint32_t)$arg2
         end
         if $arg1 == 64
            set *(uint64_t *)$kgm_pkt->data = (uint64_t)$arg2
         end
         set manual_pkt.input = 1
         # dummy to make sure manual packet is executed
         set $kgm_dummy = &_mh_execute_header
         set $kgm_pkt = (kdp_writephysmem64_reply_t *)&manual_pkt.data
         set $kgm_writephysint_result = $kgm_pkt->error
  end
  
  define writephys8
         writephysint $arg0 8 $arg1 $kgm_lcpu_self
  end
  
  define writephys16
         writephysint $arg0 16 $arg1 $kgm_lcpu_self
  end
  
  define writephys32
         writephysint $arg0 32 $arg1 $kgm_lcpu_self
  end
  
  define writephys64
         writephysint $arg0 64 $arg1 $kgm_lcpu_self
  end
  
  document writephys8
  | See writephys64
  end
  
  document writephys16
  | See writephys64
  end
  
  document writephys32
  | See writephys64
  end
  
  document writephys64
  | The argument is interpreted as a physical address, and the second argument is
  | written to that address as a 64-bit word.
  end
  
  define addkextsyms
          shell echo cd `pwd` > /tmp/gdb-cd
          cd $arg0
          source kcbmacros
          source /tmp/gdb-cd
          set $kgm_show_kmod_syms = 1
  end
  
  document addkextsyms
  | Takes a directory of symbols for kexts generated with kextcache -y and loads them
  | into gdb.
  | (gdb) addkextsyms /path/to/symboldir
  end
  
  define showprocfiles
      if ($argc == 1)
          _showprocheader
          _showprocfiles $arg0
      else
          printf "| Usage:\n|\n"
          help showprocfiles
      end
  end
  document showprocfiles
  Syntax: (gdb) showprocfiles <proc_t>
  | Given a proc_t pointer, display the list of open file descriptors for the
  | referenced process.
  end
  
  define _showprocheader
      printf "fd     fileglob  "
      showptrhdrpad
      printf "  fg flags    fg type   fg data   "
      showptrhdrpad
      printf "  info\n"
      printf "-----  ----------"
      if $kgm_lp64
          printf "--------"
      end
      printf "  ----------  --------  ----------"
      if $kgm_lp64
          printf "--------"
      end
      printf "  -------------------\n"
  end
  
  define _showprocfiles
      set $kgm_spf_filedesc = ((proc_t)$arg0)->p_fd
      set $kgm_spf_last = $kgm_spf_filedesc->fd_lastfile
      set $kgm_spf_ofiles = $kgm_spf_filedesc->fd_ofiles
      set $kgm_spf_count = 0
      while ($kgm_spf_count <= $kgm_spf_last)
          if ($kgm_spf_ofiles[$kgm_spf_count] == 0)
              # DEBUG: For files that were open, but are now closed
              # printf "%-5d  FILEPROC_NULL\n", $kgm_spf_count
          else
              # display fd #, fileglob address, fileglob flags
              set $kgm_spf_flags = $kgm_spf_ofiles[$kgm_spf_count].f_flags
              set $kgm_spf_fg = $kgm_spf_ofiles[$kgm_spf_count].f_fglob
              printf "%-5d  ", $kgm_spf_count
              showptr $kgm_spf_fg
              printf "  0x%08x  ", $kgm_spf_flags
              # decode fileglob type
              set $kgm_spf_fgt = $kgm_spf_fg->fg_type
              if ($kgm_spf_fgt == 1)
                  printf "VNODE   "
              end
              if ($kgm_spf_fgt == 2)
                  printf "SOCKET  "
              end
              if ($kgm_spf_fgt == 3)
                  printf "PSXSHM  "
              end
              if ($kgm_spf_fgt == 4)
                  printf "PSXSEM  "
              end
              if ($kgm_spf_fgt == 5)
                  printf "KQUEUE  "
              end
              if ($kgm_spf_fgt == 6)
                  printf "PIPE    "
              end
              if ($kgm_spf_fgt == 7)
                  printf "FSEVENTS"
              end
              if ($kgm_spf_fgt < 1 || $kgm_spf_fgt > 7)
                  printf "?: %-5d", $kgm_spf_fgt
              end
  
              # display fileglob data address and decode interesting fact(s)
              # about data, if we know any
              set $kgm_spf_fgd = $kgm_spf_fg->fg_data
              printf "  "
              showptr $kgm_spf_fgd
              printf "  "
              if ($kgm_spf_fgt == 1)
                  set $kgm_spf_name = ((struct vnode *)$kgm_spf_fgd)->v_name
                  if ($kgm_spf_name == 0)
                      printf "(null)"
                  else
                      printf "%s", $kgm_spf_name
                  end
              end
              printf "\n"
          end
          set $kgm_spf_count = $kgm_spf_count + 1
      end
  end
  
  #
  # Show all the advisory file locks held by a process for each of the vnode
  # type files that it has open; do this by walking the per process open file
  # table and looking at any vnode type fileglob that has a non-NULL lock list
  # associated with it.
  #
  define showproclocks
      if ($argc == 1)
          _showproclocks $arg0
      else
          printf "| Usage:\n|\n"
          help showproclocks
      end
  end
  document showproclocks
  Syntax: (gdb) showproclocks <proc_t>
  | Given a proc_t pointer, display the list of advisory file locks held by the
  | referenced process.
  end
  
  define _showproclocks
      set $kgm_spl_filedesc = ((proc_t)$arg0)->p_fd
      set $kgm_spl_last = $kgm_spl_filedesc->fd_lastfile
      set $kgm_spl_ofiles = $kgm_spl_filedesc->fd_ofiles
      set $kgm_spl_count = 0
      set $kgm_spl_seen = 0
      while ($kgm_spl_count <= $kgm_spl_last)
          if ($kgm_spl_ofiles[$kgm_spl_count] == 0)
              # DEBUG: For files that were open, but are now closed
              # printf "%-5d  FILEPROC_NULL\n", $kgm_spl_count
          else
              set $kgm_spl_fg = $kgm_spl_ofiles[$kgm_spl_count].f_fglob
              # decode fileglob type
              set $kgm_spl_fgt = $kgm_spl_fg->fg_type
              if ($kgm_spl_fgt == 1)
                  set $kgm_spl_fgd = $kgm_spl_fg->fg_data
                  set $kgm_spl_name = ((struct vnode *)$kgm_spl_fgd)->v_name
                  set $kgm_spl_vnode = ((vnode_t)$kgm_spl_fgd)
                  set $kgm_spl_lockiter = $kgm_spl_vnode->v_lockf
                  if ($kgm_spl_lockiter != 0)
                      if ($kgm_spl_seen == 0)
                          _showvnodelockheader
                      end
                      set $kgm_spl_seen = $kgm_spl_seen + 1
                      printf "( fd %d, name ", $kgm_spl_count
                      if ($kgm_spl_name == 0)
                          printf "(null) )"
                      else
                          printf "%s )\n", $kgm_spl_name
                      end
                      _showvnodelocks $kgm_spl_fgd
                  end
              end
          end
          set $kgm_spl_count = $kgm_spf_count + 1
      end
      printf "%d total locks for ", $kgm_spl_seen
      showptr $arg0
      printf "\n"
  end
  
  define showprocinfo
      set $kgm_spi_proc = (proc_t)$arg0
      printf "Process "
      showptr $kgm_spi_proc
      printf "\n"
      printf "   name %s\n", $kgm_spi_proc->p_comm
      printf "   pid:%.8d", $kgm_spi_proc->p_pid
      printf "   task:"
      showptr $kgm_spi_proc->task
      printf "   p_stat:%.1d", $kgm_spi_proc->p_stat
      printf "   parent pid:%.8d", $kgm_spi_proc->p_ppid
      printf "\n"
      # decode part of credential
      set $kgm_spi_cred = $kgm_spi_proc->p_ucred
      if ($kgm_spi_cred != 0)
          printf "Cred: euid %d ruid %d svuid %d\n", $kgm_spi_cred->cr_posix.cr_uid, $kgm_spi_cred->cr_posix.cr_ruid, $kgm_spi_cred->cr_posix.cr_svuid
      else
          printf "Cred: (null)\n"
      end
      # decode flags
      set $kgm_spi_flag = $kgm_spi_proc->p_flag
      printf "Flags: 0x%08x\n", $kgm_spi_flag
      if ($kgm_spi_flag & 0x00000001)
          printf "    0x00000001 - may hold advisory locks\n"
      end
      if ($kgm_spi_flag & 0x00000002)
          printf "    0x00000002 - has a controlling tty\n"
      end
      if ($kgm_spi_flag & 0x00000004)
          printf "    0x00000004 - process is 64 bit\n"
      else
          printf "   !0x00000004 - process is 32 bit\n"
      end
      if ($kgm_spi_flag & 0x00000008)
          printf "    0x00000008 - no SIGCHLD on child stop\n"
      end
      if ($kgm_spi_flag & 0x00000010)
          printf "    0x00000010 - waiting for child exec/exit\n"
      end
      if ($kgm_spi_flag & 0x00000020)
          printf "    0x00000020 - has started profiling\n"
      end
      if ($kgm_spi_flag & 0x00000040)
          printf "    0x00000040 - in select; wakeup/waiting danger\n"
      end
      if ($kgm_spi_flag & 0x00000080)
          printf "    0x00000080 - was stopped and continued\n"
      end
      if ($kgm_spi_flag & 0x00000100)
          printf "    0x00000100 - has set privileges since exec\n"
      end
      if ($kgm_spi_flag & 0x00000200)
          printf "    0x00000200 - system process: no signals, stats, or swap\n"
      end
      if ($kgm_spi_flag & 0x00000400)
          printf "    0x00000400 - timing out during a sleep\n"
      end
      if ($kgm_spi_flag & 0x00000800)
          printf "    0x00000800 - debugged process being traced\n"
      end
      if ($kgm_spi_flag & 0x00001000)
          printf "    0x00001000 - debugging process has waited for child\n"
      end
      if ($kgm_spi_flag & 0x00002000)
          printf "    0x00002000 - exit in progress\n"
      end
      if ($kgm_spi_flag & 0x00004000)
          printf "    0x00004000 - process has called exec\n"
      end
      if ($kgm_spi_flag & 0x00008000)
          printf "    0x00008000 - owe process an addupc() XXX\n"
      end
      if ($kgm_spi_flag & 0x00010000)
          printf "    0x00010000 - affinity for Rosetta children\n"
      end
      if ($kgm_spi_flag & 0x00020000)
          printf "    0x00020000 - wants to run Rosetta\n"
      end
      if ($kgm_spi_flag & 0x00040000)
          printf "    0x00040000 - has wait() in progress\n"
      end
      if ($kgm_spi_flag & 0x00080000)
          printf "    0x00080000 - kdebug tracing on for this process\n"
      end
      if ($kgm_spi_flag & 0x00100000)
          printf "    0x00100000 - blocked due to SIGTTOU or SIGTTIN\n"
      end
      if ($kgm_spi_flag & 0x00200000)
          printf "    0x00200000 - has called reboot()\n"
      end
      if ($kgm_spi_flag & 0x00400000)
          printf "    0x00400000 - is TBE state\n"
      end
      if ($kgm_spi_flag & 0x00800000)
          printf "    0x00800000 - signal exceptions\n"
      end
      if ($kgm_spi_flag & 0x01000000)
          printf "    0x01000000 - has thread cwd\n"
      end
      if ($kgm_spi_flag & 0x02000000)
          printf "    0x02000000 - has vfork() children\n"
      end
      if ($kgm_spi_flag & 0x04000000)
          printf "    0x04000000 - not allowed to attach\n"
      end
      if ($kgm_spi_flag & 0x08000000)
          printf "    0x08000000 - vfork() in progress\n"
      end
      if ($kgm_spi_flag & 0x10000000)
          printf "    0x10000000 - no shared libraries\n"
      end
      if ($kgm_spi_flag & 0x20000000)
          printf "    0x20000000 - force quota for root\n"
      end
      if ($kgm_spi_flag & 0x40000000)
          printf "    0x40000000 - no zombies when children exit\n"
      end
      if ($kgm_spi_flag & 0x80000000)
          printf "    0x80000000 - don't hang on remote FS ops\n"
      end
      # decode state
      set $kgm_spi_state = $kgm_spi_proc->p_stat
      printf "State: "
      if ($kgm_spi_state == 1)
          printf "Idle\n"
      end
      if ($kgm_spi_state == 2)
          printf "Run\n"
      end
      if ($kgm_spi_state == 3)
          printf "Sleep\n"
      end
      if ($kgm_spi_state == 4)
          printf "Stop\n"
      end
      if ($kgm_spi_state == 5)
          printf "Zombie\n"
      end
      if ($kgm_spi_state == 6)
          printf "Reaping\n"
      end
      if ($kgm_spi_state < 1 || $kgm_spi_state > 6)
          printf "(Unknown)\n"
      end
  end
  
  document showprocinfo
  Syntax: (gdb) showprocinfo <proc_t>
  | Displays name, pid, parent and task for a proc_t. Decodes cred, flag and p_stat fields.
  end
  
  #
  # dump the zombprocs 
  #
  define zombproc
    set $basep = (struct proc  *)zombproc->lh_first
    set $pp = $basep
    while $pp
          showprocinfo $pp
        set $pp = $pp->p_list.le_next
    end
  end
  
  document zombproc
  Syntax: (gdb) zombproc 
  | Routine to print out all procs in the zombie list
  end
  
  #
  # dump the zombstacks 
  #
  define zombstacks
    set $basep = (struct proc  *)zombproc->lh_first
    set $pp = $basep
    while $pp
          if $pp->p_stat != 5
                  showtaskstacks $pp->task
          end
       set $pp = $pp->p_list.le_next
    end
  end
  
  document zombstacks
  Syntax: (gdb) zombstacks 
  | Routine to print out all stacks of tasks that are exiting
  end
  
  
  #
  # dump the allprocs
  #
  define allproc
    set $basep = (struct proc  *)allproc->lh_first
    set $pp = $basep
    while $pp
          showprocinfo $pp
        set $pp = $pp->p_list.le_next
    end
  end
  
  document allproc
  Syntax: (gdb) allproc 
  | Routine to print out all process in the system 
  | which are not in the zombie list
  end
  define showprocsiblingint
      set $kgm_sibling_ptr = (struct proc *)$arg0
      set $kgm_lx = $arg1 
      while $kgm_lx
          printf "|  " 
          set $kgm_lx = $kgm_lx-3 
      end   
      printf "|--%d    %s    [ 0x%llx ]\n", $kgm_sibling_ptr->p_pid, $kgm_sibling_ptr->p_comm, $kgm_sibling_ptr
  end
  define showproctreeint
  #Initialize all the set variables used in this macro
      set $kgm_basep1 = 0
      set $kgm_sibling_ptr = 0
      set $kgm_lx = 0
      set $kgm_tmp_base = 0
      set $kgm_head_ptr = 0
      set $kgm_search_pid = 0 
      set $kgm_rev = 0
      set $kgm_x = 0
  
      set $kgm_basep1 = (struct proc *)allproc->lh_first
      if ($arg0 == 0)
          set $kgm_head_ptr = (struct proc *)initproc
      end       
      if ($arg0 > 0)
          set $kgm_tmp_base = (struct proc *)allproc->lh_first
          set $kgm_search_pid = $arg0 
          while $kgm_tmp_base
              if ( $kgm_tmp_base->p_pid == $kgm_search_pid)
                 if ($kgm_tmp_base->p_childrencnt > 0)
                      set $kgm_head_ptr = $kgm_tmp_base->p_children.lh_first
                 else
                      set $kgm_head_ptr = 0
                      printf "No children present for PID=%d", $kgm_search_pid
                 end
                 loop_break
              end
              set $kgm_tmp_base = $kgm_tmp_base->p_list.le_next
          end
      end
      set $kgm_rev = 0
      set $kgm_x = 0
      if ($kgm_head_ptr)
          printf "PID   PROCESS       POINTER]\n"
          printf "===   =======       =======\n"
          printf "%d    %s      [ 0x%llx ]\n", $kgm_head_ptr->p_ppid, $kgm_head_ptr->p_pptr->p_comm, $kgm_head_ptr
          printf "|--%d    %s      [ 0x%llx ]\n", $kgm_head_ptr->p_pid, $kgm_head_ptr->p_comm, $kgm_head_ptr
      end
      while ($kgm_head_ptr)
         #Is childrencnt = 0?       YES  {=> no children}
          if ($kgm_head_ptr->p_childrencnt == 0)
              # Does it have sibling? 
              if($kgm_head_ptr->p_sibling.le_next == 0)
                  #No, it does not have sibling, so go back to its parent which will go to its sibling
                  if($kgm_head_ptr == $kgm_head_ptr->p_pptr)
                      loop_break
                  end
                  set $kgm_head_ptr = $kgm_head_ptr->p_pptr
                  if ($kgm_head_ptr == $kgm_tmp_base)
                      loop_break
                  end
                  if ($kgm_x > 3)
                      set $kgm_x = $kgm_x - 3
                  end
                  set $kgm_rev = 1
              end
              if($kgm_head_ptr->p_sibling.le_next != 0)
                  # Yes, it has sibling. So print sibling
                  set $kgm_rev = 0
                  showprocsiblingint $kgm_head_ptr->p_sibling.le_next $kgm_x
                  set $kgm_head_ptr = $kgm_head_ptr->p_sibling.le_next
              end
          # childrencnt != 0  {=> it has children}
          else
              if ($kgm_rev == 1)
                  if($kgm_head_ptr->p_sibling.le_next == 0)
                      #No, it does not have sibling, so go back to its parent which will go to its sibling
                      if($kgm_head_ptr == $kgm_head_ptr->p_pptr)
                          loop_break
                      end
                      set $kgm_head_ptr = $kgm_head_ptr->p_pptr
                      if ($kgm_head_ptr == $kgm_tmp_base)
                          loop_break
                      end
  
                      if ($kgm_x > 3)
                          set $kgm_x = $kgm_x - 3
                      end
                      set $kgm_rev = 1
                  end
                  if($kgm_head_ptr->p_sibling.le_next != 0)
                      set $kgm_rev = 0
                      # Yes, it has sibling. So print sibling
                      showprocsiblingint $kgm_head_ptr->p_sibling.le_next $kgm_x
                      set $kgm_head_ptr = $kgm_head_ptr->p_sibling.le_next
                  end
              else
                  set $kgm_head_ptr = $kgm_head_ptr->p_children.lh_first
                  set $kgm_x = $kgm_x + 3
                  set $kgm_lx = $kgm_x
                  while $kgm_lx
                      printf "|  "
                      set $kgm_lx = $kgm_lx-3
                  end
                  printf "|--%d    %s      [ 0x%llx ] \n", $kgm_head_ptr->p_pid, $kgm_head_ptr->p_comm, $kgm_head_ptr
              end
          end
      end
      printf "\n"
  #Unset all the set variables used in this macro
      set $kgm_basep1 = 0
      set $kgm_sibling_ptr = 0
      set $kgm_lx = 0
      set $kgm_tmp_base = 0
      set $kgm_head_ptr = 0
      set $kgm_search_pid = 0
      set $kgm_rev = 0
      set $kgm_x = 0
  end
  define showproctree
      if ($argc > 0)
          showproctreeint $arg0
      else
          showproctreeint 0
      end
  end
  document showproctree
  Syntax: (gdb) showproctree <pid>
  | Routine to print the processes in the system in a hierarchical tree form. This routine does not print zombie processes.
  | If no argument is given, showproctree will print all the processes in the system.  
  | If pid is specified, showproctree prints all the descendants of the indicated process
  end
  
  
  define print_vnode
     set $vp = (struct vnode *)$arg0
     printf "   "
     printf " vp "
     showptr $vp
     printf " use %d", $vp->v_usecount
     printf " io %d", $vp->v_iocount
     printf " kuse %d", $vp->v_kusecount
     printf " type %d", $vp->v_type
     printf " flg 0x%.8x", $vp->v_flag
     printf " lflg 0x%.8x", $vp->v_lflag
     printf " par "
     showptr $vp->v_parent
     set $_name = (char *)$vp->v_name
     if ($_name != 0)
        printf " %s", $_name
     end
    if ($vp->v_type == VREG) && ($vp->v_un.vu_ubcinfo != 0)
         printf " mapped %d", ($vp->v_un.vu_ubcinfo.ui_flags & 0x08) ? 1 : 0
     end
     printf "\n"
  end
  
  document print_vnode
  Syntax: (gdb) print_vnode <vnode>
  | Prints out the fields of a vnode struct
  end
  
  define showprocvnodes
          set $pp = (struct proc *)$arg0
          set $fdp = (struct filedesc *)$pp->p_fd
          set $cvp = $fdp->fd_cdir
          set $rvp = $fdp->fd_rdir
          if $cvp
                  printf "Current Working Directory \n"
                  print_vnode $cvp
                  printf "\n"
          end
          if $rvp
                  printf "Current Root Directory \n"
                  print_vnode $rvp
                  printf "\n"
          end
          set $count = 0
          set $fpp =  (struct fileproc **)($fdp->fd_ofiles)
          set $fpo =  (char)($fdp->fd_ofileflags[0])
          while $count < $fdp->fd_nfiles
                  #printf"fpp %x ", *$fpp
                  if *$fpp
                          set $fg =(struct fileglob *)((**$fpp)->f_fglob)
                          if  $fg && (($fg)->fg_type == 1) 
                                  if $fdp->fd_ofileflags[$count] & 4
                                          printf "U: "
                                  else
                                          printf " "
                                  end
                                  printf "fd = %d ", $count
                                  print_vnode $fg->fg_data
                          end
                  end
                  set $fpp = $fpp + 1
                  set $count = $count + 1         
          end
  end
  
  document showprocvnodes
  Syntax: (gdb) showprocvnodes <proc_address>
  | Routine to print out all the open fds
  | which are vnodes in a process
  end
  
  define showallprocvnodes
    set $basep = (struct proc  *)allproc->lh_first
    set $pp = $basep
    while $pp
          printf "============================================ \n"
          showprocinfo $pp
          showprocvnodes $pp
          set $pp = $pp->p_list.le_next
    end
  end
  
  document showallprocvnodes
  Syntax: (gdb) showallprocvnodes
  | Routine to print out all the open fds
  | which are vnodes 
  end
  
  
  #   
  # dump the childrent of a proc 
  #
  define showinitchild
    set $basep = (struct proc  *)initproc->p_children.lh_first
    set $pp = $basep
    while $pp
          showprocinfo $pp
        set $pp = $pp->p_sibling.le_next
    end
  end
  
  document showinitchild
  Syntax: (gdb) showinitchild 
  | Routine to print out all processes in the system 
  | which are children of init process
  end
  
  
  define showmountallvnodes
    set $mp = (struct mount *)$arg0
    set $basevp = (struct vnode *)$mp->mnt_vnodelist.tqh_first
    set $vp = $basevp
    printf "____________________ Vnode list Queue ---------------\n"
    while $vp
        print_vnode $vp
        set $vp = $vp->v_mntvnodes->tqe_next
    end
    set $basevp = (struct vnode *)$mp->mnt_workerqueue.tqh_first
    set $vp = $basevp
    printf "____________________ Worker Queue ---------------\n"
    while $vp
        print_vnode $vp
        set $vp = $vp->v_mntvnodes->tqe_next
    end
    set $basevp = (struct vnode *)$mp->mnt_newvnodes.tqh_first
    set $vp = $basevp
    printf "____________________ New vnodes  Queue ---------------\n"
    while $vp
        print_vnode $vp
        set $vp = $vp->v_mntvnodes->tqe_next
    end
  end
  document showmountallvnodes
  Syntax: showmountallvnodes <struct mount *>
  | Print the vnode inactive list
  end
  
  
  define showmountvnodes
    set $mp = (struct mount *)$arg0
    set $basevp = (struct vnode *)$mp->mnt_vnodelist.tqh_first
    set $vp = $basevp
    printf "____________________ Vnode list Queue ---------------\n"
    while $vp
        print_vnode $vp
        set $vp = $vp->v_mntvnodes->tqe_next
    end
  end
  document showmountvnodes
  Syntax: showmountvnodes <struct mount *>
  | Print the vnode list
  end
  
  
  
  define showworkqvnodes
    set $mp = (struct mount *)$arg0
    set $basevp = (struct vnode *)$mp->mnt_workerqueue.tqh_first
    set $vp = $basevp
    printf "____________________ Worker Queue ---------------\n"
    while $vp
        print_vnode $vp
        set $vp = $vp->v_mntvnodes->tqe_next
    end
  end
  document showworkqvnodes
  Syntax: showworkqvnodes <struct mount *>
  | Print the vnode worker list
  end
  
  
  define shownewvnodes
    set $mp = (struct mount *)$arg0
    set $basevp = (struct vnode *)$mp->mnt_newvnodes.tqh_first
    set $vp = $basevp
    printf "____________________ New vnodes  Queue ---------------\n"
    while $vp
        print_vnode $vp
        set $vp = $vp->v_mntvnodes->tqe_next
    end
  end
  
  document shownewvnodes
  Syntax: shownewvnodes <struct mount *>
  | Print the new vnode list
  end
  
  
  #
  # print mount point info
  define print_mount 
     set $mp = (struct mount *)$arg0
     printf "   "
     printf " mp "
     showptr $mp
     printf " flag %x", $mp->mnt_flag
     printf " kern_flag %x", $mp->mnt_kern_flag
     printf " lflag %x", $mp->mnt_lflag
     printf " type:  %s", $mp->mnt_vfsstat.f_fstypename
     printf " mnton:  %s", $mp->mnt_vfsstat.f_mntonname
     printf " mntfrom:  %s", $mp->mnt_vfsstat.f_mntfromname
     printf "\n"
  end
  
  define showallmounts
          set $mp=(struct mount *)mountlist.tqh_first
          while $mp
                  print_mount $mp
                  set $mp = $mp->mnt_list.tqe_next
          end
  end
          
  document showallmounts
  Syntax: showallmounts
  | Print all mount points
  end
  
  define pcprint
          if (((unsigned long) $arg0 < (unsigned long) &_mh_execute_header || \
               (unsigned long) $arg0 >= (unsigned long) &last_kernel_symbol ))
                  showkmodaddr $arg0
          else
                  output /a $arg0
          end
  end
  
  define mbuf_walkpkt
          set $mp = (struct mbuf *)$arg0
          set $cnt = 1
          set $tot = 0
          while $mp
                  printf "%4d: %p [len %4d, type %2d, ", $cnt, $mp, \
                      $mp->m_hdr.mh_len, $mp->m_hdr.mh_type
                  if mclaudit != 0
                          mbuf_buf2mca $mp
                          printf ", "
                  end
                  set $tot = $tot + $mp->m_hdr.mh_len
                  printf "total %d]\n", $tot
                  set $mp = $mp->m_hdr.mh_nextpkt
                  set $cnt = $cnt + 1
          end
  end
  
  document mbuf_walkpkt
  Syntax: (gdb) mbuf_walkpkt <addr>
  | Given an mbuf address, walk its m_nextpkt pointer
  end
  
  define mbuf_walk
          set $mp = (struct mbuf *)$arg0
          set $cnt = 1
          set $tot = 0
          while $mp
                  printf "%4d: %p [len %4d, type %2d, ", $cnt, $mp, \
                      $mp->m_hdr.mh_len, $mp->m_hdr.mh_type
                  if mclaudit != 0
                          mbuf_buf2mca $mp
                          printf ", "
                  end
                  set $tot = $tot + $mp->m_hdr.mh_len
                  printf "total %d]\n", $tot
                  set $mp = $mp->m_hdr.mh_next
                  set $cnt = $cnt + 1
          end
  end
  
  document mbuf_walk
  Syntax: (gdb) mbuf_walk <addr>
  | Given an mbuf address, walk its m_next pointer
  end
  
  define mbuf_buf2slab
          set $addr = $arg0
          set $gix = ((char *)$addr - (char *)mbutl) >> 20
          set $ix = ((char *)$addr - (char *)slabstbl[$gix].slg_slab[0].sl_base) >> 12
          set $slab = &slabstbl[$gix].slg_slab[$ix]
          if $kgm_lp64
                  printf "0x%-16llx", $slab
          else
                  printf "0x%-8x", $slab
          end
  end
  
  document mbuf_buf2slab
  | Given an mbuf object, find its corresponding slab address.
  end
  
  define mbuf_buf2mca
          set $addr = $arg0
          set $ix = ((char *)$addr - (char *)mbutl) >> 12
          set $clbase = ((union mbigcluster *)mbutl) + $ix
          set $mclidx = (((char *)$addr - (char *)$clbase) >> 8)
          set $mca = mclaudit[$ix].cl_audit[$mclidx]
          if $kgm_lp64
                  printf "mca: 0x%-16llx", $mca
          else
                  printf "mca: 0x%-8x", $mca
          end
  end
  
  document mbuf_buf2mca
  Syntax: (gdb) mbuf_buf2mca <addr>
  | Given an mbuf object, find its buffer audit structure address.
  | This requires mbuf buffer auditing to be turned on, by setting
  | the appropriate flags to the "mbuf_debug" boot-args parameter.
  end
  
  define mbuf_showmca
          set language c
          set $mca = (mcache_audit_t *)$arg0
          set $cp = (mcache_t *)$mca->mca_cache
          printf "object type:\t\t"
          mbuf_mca_ctype $mca 1
          printf "\ncontrolling mcache:\t%p (%s)\n", $mca->mca_cache, $cp->mc_name
          if $mca->mca_uflags & $MB_SCVALID
                  set $ix = ((char *)$mca->mca_addr - (char *)mbutl) >> 12
                  set $clbase = ((union mbigcluster *)mbutl) + $ix
                  set $mclidx = (((char *)$mca->mca_addr - (char *)$clbase) >> 8)
                  printf "mbuf obj:\t\t%p\n", $mca->mca_addr
                  printf "mbuf index:\t\t%d (out of 16) in cluster base %p\n", \
                      $mclidx + 1, $clbase
                  if $mca->mca_uptr != 0
                          set $peer_mca = (mcache_audit_t *)$mca->mca_uptr
                          printf "paired cluster obj:\t%p (mca %p)\n", \
                              $peer_mca->mca_addr, $peer_mca
                  end
                  printf "saved contents:\t\t%p (%d bytes)\n", \
                      $mca->mca_contents, $mca->mca_contents_size
          else
                  printf "cluster obj:\t\t%p\n", $mca->mca_addr
                  if $mca->mca_uptr != 0
                          set $peer_mca = (mcache_audit_t *)$mca->mca_uptr
                          printf "paired mbuf obj:\t%p (mca %p)\n", \
                              $peer_mca->mca_addr, $peer_mca
                  end
          end
          printf "recent transaction for this buffer (thread %p):\n", \
              $mca->mca_thread
          set $cnt = 0
          while $cnt < $mca->mca_depth
                  set $kgm_pc = $mca->mca_stack[$cnt]
                  printf "%4d: ", $cnt + 1
                  pcprint $kgm_pc
                  printf "\n"
                  set $cnt = $cnt + 1
          end
          if $mca->mca_pdepth > 0
                  printf "previous transaction for this buffer (thread %p):\n", \
                      $mca->mca_pthread
          end
          set $cnt = 0
          while $cnt < $mca->mca_pdepth
                  set $kgm_pc = $mca->mca_pstack[$cnt]
                  printf "%4d: ", $cnt + 1
                  pcprint $kgm_pc
                  printf "\n"
                  set $cnt = $cnt + 1
          end
          set language auto
  end
  
  document mbuf_showmca
  Syntax: (gdb) mbuf_showmca <addr>
  | Given an mbuf/cluster buffer audit structure address, print the audit
  | records including the stack trace of the last buffer transaction.
  end
  
  define mbuf_topleak
          set language c
          set $topcnt = 0
          if $arg0 < 5
                  set $maxcnt = $arg0
          else
                  set $maxcnt = 5
          end
          while $topcnt < $maxcnt
                  mbuf_traceleak mleak_top_trace[$topcnt]
                  set $topcnt = $topcnt + 1
          end
          set language auto
  end
  
  document mbuf_topleak
  Syntax: (gdb) mbuf_topleak <num>
  | Prints information about the top <num> suspected mbuf leakers
  | where <num> is a value <= 5
  end
  
  define mbuf_traceleak
          set language c
          set $trace = (struct mtrace *) $arg0
          if $trace->allocs != 0
                  printf "%p:%d outstanding allocs\n", $trace, $trace->allocs
                  printf "backtrace saved %d deep:\n", $trace->depth
                  if $trace->depth != 0
                          set $cnt = 0
                          while $cnt < $trace->depth
                                  printf "%4d: ", $cnt + 1
                                  pcprint $trace->addr[$cnt]
                                  printf "\n"
                                  set $cnt = $cnt + 1
                          end
                  end
          end
          set language auto
  end
  
  document mbuf_traceleak
  Syntax: (gdb) mbuf_traceleak <addr>
  | Given an mbuf leak trace (mtrace) structure address, print out the
  | stored information with that trace
  end
  
  set $MCF_NOCPUCACHE = 0x10
  
  define mcache_stat
          set $head = (mcache_t *)mcache_head
          set $mc = $head
  
      if $kgm_lp64
                  printf "cache                        cache              cache    buf   buf            backing             (# of retries)     bufs\n"
                  printf "name                         state               addr   size align               zone     wait   nowait   failed  incache\n"
                  printf "------------------------- -------- ------------------ ------ ----- ------------------ -------------------------- --------\n"
          else
                  printf "cache                        cache      cache    buf   buf    backing             (# of retries)     bufs\n"
                  printf "name                         state       addr   size align       zone     wait   nowait   failed  incache\n"
                  printf "------------------------- -------- ---------- ------ ----- ---------- -------------------------- --------\n"
          end
          while $mc != 0
                  set $bktsize = $mc->mc_cpu.cc_bktsize
                  printf "%-25s ", $mc->mc_name
                  if ($mc->mc_flags & $MCF_NOCPUCACHE)
                          printf "disabled"
                  else
                          if $mc->mc_purge_cnt > 0
                                  printf " purging"
                          else
                                  if $bktsize == 0
                                          printf " offline"
                                  else
                                          printf "  online"
                                  end
                          end
                  end
                  printf " %p %6d %5d ",$mc, \
                      $mc->mc_bufsize, $mc->mc_align
                  if $mc->mc_slab_zone != 0
                          printf "%p", $mc->mc_slab_zone
                  else
                      if $kgm_lp64
                                  printf "            custom"
                          else
                                  printf "    custom"
                          end
                  end
                  set $tot = 0
                  set $tot += $mc->mc_full.bl_total * $bktsize
                  set $ccp = (mcache_cpu_t *)$mc->mc_cpu
                  set $n = 0
                  while $n < ncpu
                          if $ccp->cc_objs > 0
                                  set $tot += $ccp->cc_objs
                          end
                          if $ccp->cc_pobjs > 0
                                  set $tot += $ccp->cc_pobjs
                          end
                          set $n += 1
                          set $ccp += 1
                  end
                  printf " %8d %8d %8d %8d", $mc->mc_wretry_cnt, \
                      $mc->mc_nwretry_cnt, $mc->mc_nwfail_cnt, $tot
                  printf "\n"
                  set $mc = (mcache_t *)$mc->mc_list.le_next
          end
  end
  
  document mcache_stat
  Syntax: (gdb) mcache_stat
  | Print all mcaches in the system.
  end
  
  define mcache_showzone
          set $mc = (mcache_t *)$arg0
          if $mc->mc_slab_zone != 0
                  printf "%p", $mc->mc_slab_zone
          else
                  printf "   custom"
  end
  
  document mcache_showzone
  Syntax: (gdb) mcache_showzone <mcache_addr>
  | Print the type of backend (custom or zone) of a mcache.
  end
  
  define mcache_walkobj
          set $p = (mcache_obj_t *)$arg0
          set $cnt = 1
          set $tot = 0
          while $p
                  printf "%4d: %p\n", $cnt, $p,
                  set $p = $p->obj_next
                  set $cnt = $cnt + 1
          end
  end
  
  document mcache_walkobj
  Syntax: (gdb) mcache_walkobj <addr>
  | Given a mcache object address, walk its obj_next pointer
  end
  
  define mcache_showcache
          set $cp = (mcache_t *)$arg0
          set $ccp = (mcache_cpu_t *)$cp->mc_cpu
          set $bktsize = $cp->mc_cpu.cc_bktsize
          set $cnt = 0
          set $tot = 0
          printf "Showing cache '%s':\n\n", $cp->mc_name
          printf " CPU  cc_objs cc_pobjs    total\n"
          printf "---- -------- -------- --------\n"
          while $cnt < ncpu
                  set $objs = $ccp->cc_objs
                  if $objs <= 0
                          set $objs = 0
                  end
                  set $pobjs = $ccp->cc_pobjs
                  if $pobjs <= 0
                          set $pobjs = 0
                  end
                  set $tot_cpu = $objs + $pobjs
                  set $tot += $tot_cpu
                  printf "%4d %8d %8d %8d\n", $cnt, $objs, $pobjs, $tot_cpu
                  set $ccp += 1
                  set $cnt += 1
          end
          printf "                       ========\n"
          printf "                       %8d\n", $tot
          printf "\n"
          set $tot += $cp->mc_full.bl_total * $bktsize
          printf "Total # of full buckets (%d objs/bkt):\t%-8d\n", \
              $bktsize, $cp->mc_full.bl_total
          printf "Total # of objects cached:\t\t%-8d\n", $tot
  end
  
  document mcache_showcache
  | Display the number of objects in the cache
  end
  
  set $NSLABSPMB = sizeof(mcl_slabg_t)/sizeof(mcl_slab_t)
  
  define mbuf_slabstbl
          set $x = 0
  
          if $kgm_lp64
                  printf "slot slabg              slabs range\n"
                  printf "---- ------------------ -------------------------------------------\n"
          else
                  printf "slot slabg      slabs range\n"
                  printf "---- ---------- ---------------------------\n"
          end
          while $x < maxslabgrp
                  set $slg = slabstbl[$x]
                  printf "%3d: ", $x
                  if $slg == 0
                          printf "-\n"
                  else
                          if $kgm_lp64
                                  printf "0x%-16llx [ 0x%-16llx - 0x%-16llx ]\n", $slg, &$slg->slg_slab[0], \
                                      &$slg->slg_slab[$NSLABSPMB-1]
                          else
                                  printf "0x%-8x [ 0x%-8x - 0x%-8x ]\n", $slg, &$slg->slg_slab[0], \
                                      &$slg->slg_slab[$NSLABSPMB-1]
                          end
                  end
                  set $x += 1
          end
  end
  
  document mbuf_slabstbl
  | Display the mbuf slabs table
  end
  
  set $SLF_MAPPED=0x0001
  set $SLF_PARTIAL=0x0002
  set $SLF_DETACHED=0x0004
  
  define mbuf_slabs
          set $slg = (mcl_slabg_t *)$arg0
          set $x = 0
  
          if $kgm_lp64
                  printf "slot slab               next               obj                mca                 C  R  N   size flags\n"
                  printf "---- ------------------ ------------------ ------------------ ------------------ -- -- -- ------ -----\n"
          else
                  printf "slot slab       next       obj        mca         C  R  N   size flags\n"
                  printf "---- ---------- ---------- ---------- ---------- -- -- -- ------ -----\n"
          end
          while $x < $NSLABSPMB
                  set $sl = &$slg->slg_slab[$x]
                  set $mca = 0
                  set $obj = $sl->sl_base
  
                  if mclaudit != 0
                          set $ix = ((char *)$obj - (char *)mbutl) >> 12
                          set $clbase = ((union mbigcluster *)mbutl) + $ix
                          set $mclidx = (((char *)$obj - (char *)$clbase) >> 8)
                          set $mca = mclaudit[$ix].cl_audit[$mclidx]
                  end
  
                  if $kgm_lp64
                          printf "%3d: 0x%-16llx 0x%-16llx 0x%-16llx 0x%-16llx %2d %2d %2d %6d 0x%04x ", \
                              $x + 1, $sl, $sl->sl_next, $obj, $mca, $sl->sl_class, \
                              $sl->sl_refcnt, $sl->sl_chunks, $sl->sl_len, \
                              $sl->sl_flags
                  else
                          printf "%3d: 0x%-8x 0x%-8x 0x%-8x 0x%-8x %2d %2d %2d %6d 0x%04x ", \
                              $x + 1, $sl, $sl->sl_next, $obj, $mca, $sl->sl_class, \
                              $sl->sl_refcnt, $sl->sl_chunks, $sl->sl_len, \
                              $sl->sl_flags
                  end
                  if $sl->sl_flags != 0
                          printf "<"
                          if $sl->sl_flags & $SLF_MAPPED
                                  printf "mapped"
                          end
                          if $sl->sl_flags & $SLF_PARTIAL
                                  printf ",partial"
                          end
                          if $sl->sl_flags & $SLF_DETACHED
                                  printf ",detached"
                          end
                          printf ">"
                  end
                  printf "\n"
  
                  if $sl->sl_chunks > 1
                          set $z = 1
                          set $c = $sl->sl_len / $sl->sl_chunks
  
                          while $z < $sl->sl_chunks
                                  set $obj = $sl->sl_base + ($c * $z)
                                  set $mca = 0
  
                                  if mclaudit != 0
                                          set $ix = ((char *)$obj - (char *)mbutl) >> 12
                                          set $clbase = ((union mbigcluster *)mbutl) + $ix
                                          set $mclidx = (((char *)$obj - (char *)$clbase) >> 8)
                                          set $mca = mclaudit[$ix].cl_audit[$mclidx]
                                  end
  
                                  if $kgm_lp64
                                          printf "                                           0x%-16llx 0x%-16llx\n", $obj, $mca
                                  else
                                          printf "                           0x%-8x 0x%-8x\n", $obj, $mca
                                  end
                                  set $z += 1
                          end
                  end
  
                  set $x += 1
          end
  end
  
  document mbuf_slabs
  | Display all mbuf slabs in the group
  end
  
  define mbuf_stat
          set $x = 0
  
          printf "class               total   cached     uncached           inuse           failed   waiter notified    purge\n"
          printf "name                 objs     objs     objs / slabs        objs      alloc count    count    count    count\n"
          printf "---------------- -------- -------- ------------------- -------- ---------------- -------- -------- --------\n"
          while $x < (sizeof(mbuf_table) / sizeof(mbuf_table[0]))
                  set $mbt = mbuf_table[$x]
                  set $mcs = (mb_class_stat_t *)mbuf_table[$x].mtbl_stats
                  set $tot = 0
                  set $mc = $mbt->mtbl_cache
                  set $bktsize = $mc->mc_cpu.cc_bktsize
                  set $tot += $mc->mc_full.bl_total * $bktsize
                  set $ccp = (mcache_cpu_t *)$mc->mc_cpu
                  set $n = 0
                  while $n < ncpu
                          if $ccp->cc_objs > 0
                                  set $tot += $ccp->cc_objs
                          end
                          if $ccp->cc_pobjs > 0
                                  set $tot += $ccp->cc_pobjs
                          end
                          set $n += 1
                          set $ccp += 1
                  end
  
                  printf "%-16s %8d %8d %8d / %-8d %8d %16llu %8d %8llu %8llu", \
                      $mcs->mbcl_cname, $mcs->mbcl_total, $tot, \
                      $mcs->mbcl_infree, $mcs->mbcl_slab_cnt, \
                      ($mcs->mbcl_total - $tot - $mcs->mbcl_infree), \
                      $mcs->mbcl_fail_cnt, $mc->mc_waiter_cnt, \
                      $mcs->mbcl_notified, $mcs->mbcl_purge_cnt
                  printf "\n"
                  set $x += 1
          end
  end
  
  document mbuf_stat
  | Print extended mbuf allocator statistics.
  end
  
  set $MB_INUSE = 0x1
  set $MB_COMP_INUSE = 0x2
  set $MB_SCVALID = 0x4
  
  set $MCLBYTES = 2048
  set $MSIZE = 256
  set $NBPG = 4096
  set $M16KCLBYTES = 16384
  
  define mbuf_mca_ctype
          set $mca = (mcache_audit_t *)$arg0
          set $vopt = $arg1
          set $cp = $mca->mca_cache
          set $class = (unsigned int)$cp->mc_private
          set $csize = mbuf_table[$class].mtbl_stats->mbcl_size
          set $done = 0
          if $csize == $MSIZE
                  if $vopt
                          printf "M (mbuf) "
                  else
                          printf "M     "
                  end
                  set $done = 1
          end
          if !$done && $csize == $MCLBYTES
                  if $vopt
                          printf "CL (2K cluster) "
                  else
                          printf "CL    "
                  end
                  set $done = 1
          end
          if !$done && $csize == $NBPG
                  if $vopt
                          printf "BCL (4K cluster) "
                  else
                          printf "BCL   "
                  end
                  set $done = 1
          end
          if !$done && $csize == $M16KCLBYTES
                  if $vopt
                          printf "JCL (16K cluster) "
                  else
                          printf "JCL   "
                  end
                  set $done = 1
          end
          if !$done && $csize == ($MSIZE+$MCLBYTES)
                  if $mca->mca_uflags & $MB_SCVALID
                          if $mca->mca_uptr
                                  printf "M+CL  "
                                  if $vopt
                                          printf "(paired mbuf, 2K cluster)"
                                  end
                          else
                                  printf "M-CL  "
                                  if $vopt
                                          printf "(unpaired mbuf, 2K cluster) "
                                  end
                          end
                  else
                          if $mca->mca_uptr
                                  printf "CL+M  "
                                  if $vopt
                                          printf "(paired 2K cluster, mbuf) "
                                  end
                          else
                                  printf "CL-M  "
                                  if $vopt
                                          printf "(paired 2K cluster, mbuf) "
                                  end
                          end
                  end
                  set $done = 1
          end
          if !$done && $csize == ($MSIZE+$NBPG)
                  if $mca->mca_uflags & $MB_SCVALID
                          if $mca->mca_uptr
                                  printf "M+BCL "
                                  if $vopt
                                          printf "(paired mbuf, 4K cluster) "
                                  end
                          else
                                  printf "M-BCL "
                                  if $vopt
                                          printf "(unpaired mbuf, 4K cluster) "
                                  end
                          end
                  else
                          if $mca->mca_uptr
                                  printf "BCL+M "
                                  if $vopt
                                          printf "(paired 4K cluster, mbuf) "
                                  end
                          else
                                  printf "BCL-M "
                                  if $vopt
                                          printf "(unpaired 4K cluster, mbuf) "
                                  end
                          end
                  end
                  set $done = 1
          end
          if !$done && $csize == ($MSIZE+$M16KCLBYTES)
                  if $mca->mca_uflags & $MB_SCVALID
                          if $mca->mca_uptr
                                  printf "M+JCL "
                                  if $vopt
                                          printf "(paired mbuf, 16K cluster) "
                                  end
                          else
                                  printf "M-JCL "
                                  if $vopt
                                          printf "(unpaired mbuf, 16K cluster) "
                                  end
                          end
                  else
                          if $mca->mca_uptr
                                  printf "JCL+M "
                                  if $vopt
                                          printf "(paired 16K cluster, mbuf) "
                                  end
                          else
                                  printf "JCL-M "
                                  if $vopt
                                          printf "(unpaired 16K cluster, mbuf) "
                                  end
                          end
                  end
                  set $done = 1
          end
          if !$done
                  printf "unknown: %s ", $cp->mc_name
          end
  end
  
  document mbuf_mca_ctype
  | This is a helper macro for mbuf_show{active,inactive,all} that prints
  | out the mbuf object type represented by a given mcache audit structure.
  end
  
  define mbuf_showactive
          if $argc == 0
                  mbuf_walkallslabs 1 0
          else
                  mbuf_walkallslabs 1 0 $arg0
          end
  end
  
  document mbuf_showactive
  Syntax: (gdb) mbuf_showactive
  | Walk the mbuf objects pool and print only the active ones; this
  | requires mbuf debugging to be turned on, by setting the appropriate flags
  | to the "mbuf_debug" boot-args parameter.  Active objects are those that
  | are outstanding (have not returned to the mbuf slab layer) and in use
  | by the client (have not been freed).
  end
  
  define mbuf_showinactive
          mbuf_walkallslabs 0 1
  end
  
  document mbuf_showinactive
  Syntax: (gdb) mbuf_showinactive
  | Walk the mbuf objects pool and print only the inactive ones; this
  | requires mbuf debugging to be turned on, by setting the appropriate flags
  | to the "mbuf_debug" boot-args parameter.  Inactive objects are those that
  | are outstanding (have not returned to the mbuf slab layer) but have been
  | freed by the client, i.e. they still reside in the mcache layer ready to
  | be used for subsequent allocation requests.
  end
  
  define mbuf_showall
          mbuf_walkallslabs 1 1
  end
  
  document mbuf_showall
  Syntax: (gdb) mbuf_showall
  | Walk the mbuf objects pool and print them all; this requires
  | mbuf debugging to be turned on, by setting the appropriate flags to the
  | "mbuf_debug" boot-args parameter.
  end
  
  define mbuf_mcaobjs
  end
  
  define mbuf_walkallslabs
          set $show_a = $arg0
          set $show_f = $arg1
          if $argc == 3
                  set $show_tr = $arg2
          else
                  set $show_tr = 0
          end
          set $x = 0
          set $total = 0
          set $total_a = 0
          set $total_f = 0
  
          printf "("
          if $show_a && !$show_f
                  printf "Searching only for active "
          end
          if !$show_a && $show_f
                  printf "Searching only for inactive "
          end
          if $show_a && $show_f
                  printf "Displaying all "
          end
          printf "objects; this may take a while ...)\n\n"
  
          if $kgm_lp64
                  printf "                        slab                mca                obj        allocation\n"
                  printf "slot idx             address            address            address type        state\n"
                  printf "---- ---- ------------------ ------------------ ------------------ ----- -----------\n"
          else
                  printf "                slab        mca        obj        allocation\n"
                  printf "slot idx     address    address    address type        state\n"
                  printf "---- ---- ---------- ---------- ---------- ----- -----------\n"
          end
          
          while $x < slabgrp
                  set $slg = slabstbl[$x]
                  set $y = 0
                  set $stop = 0
                  while $y < $NSLABSPMB && $stop == 0
                          set $sl = &$slg->slg_slab[$y]
                          set $base = (char *)$sl->sl_base
                          set $ix = ($base - (char *)mbutl) >> 12
                          set $clbase = ((union mbigcluster *)mbutl) + $ix
                          set $mclidx = ($base - (char *)$clbase) >> 8
                          set $mca = mclaudit[$ix].cl_audit[$mclidx]
                          set $first = 1
  
                          while $mca != 0 && $mca->mca_addr != 0
                                  set $printmca = 0
                                  if $mca->mca_uflags & ($MB_INUSE|$MB_COMP_INUSE)
                                          set $total_a = $total_a + 1
                                          set $printmca = $show_a
                                  else
                                          set $total_f = $total_f + 1
                                          set $printmca = $show_f
                                  end
  
                                  if $printmca != 0
                                          if $first == 1
                                                  if $kgm_lp64
                                                          printf "%4d %4d 0x%-16llx ", $x, $y, $sl
                                                  else
                                                          printf "%4d %4d 0x%-8x ", $x, $y, $sl
                                                  end
                                          else
                                              if $kgm_lp64
                                                          printf "                             "
                                              else
                                                          printf "                     "
                                              end
                                          end
  
                                          if $kgm_lp64
                                                  printf "0x%-16llx 0x%-16llx ", $mca, $mca->mca_addr
                                          else
                                                  printf "0x%-8x 0x%-8x ", $mca, $mca->mca_addr
                                          end
  
                                          mbuf_mca_ctype $mca 0
                                          if $mca->mca_uflags & ($MB_INUSE|$MB_COMP_INUSE)
                                                  printf "active      "
                                          else
                                                  printf "      freed "
                                          end
                                          if $first == 1
                                                  set $first = 0
                                          end
                                          printf "\n"
                                          set $total = $total + 1
                                          
                                          if $show_tr != 0
                                                  printf "recent transaction for this buffer (thread %p):\n", \
                                                          $mca->mca_thread
                                                  set $cnt = 0
                                                  while $cnt < $mca->mca_depth
                                                          set $kgm_pc = $mca->mca_stack[$cnt]
                                                          printf "%4d: ", $cnt + 1
                                                          pcprint $kgm_pc
                                                          printf "\n"
                                                          set $cnt = $cnt + 1
                                                  end
                                          end
                                  end
                                  
                                  set $mca = $mca->mca_next
                          end
                          set $y += 1
                          if $slg->slg_slab[$y].sl_base == 0
                                  set $stop = 1
                          end
                  end
                  set $x += 1
          end
          if $total && $show_a && $show_f
                  printf "\ntotal objects:\t%d\n", $total
                  printf "active/unfreed:\t%d\n", $total_a
                  printf "freed/in_cache:\t%d\n", $total_f
          end
  end
  
  document mbuf_walkallslabs
  | Walk the mbuf objects pool; this requires mbuf debugging to be
  | turned on, by setting the appropriate flags to the "mbuf_debug" boot-args
  | parameter.  This is a backend routine for mbuf_show{active,inactive,all}.
  end
  
  define mbuf_countchain
          set $mp = (struct mbuf *)$arg0
          
          set $pkt = 0
          set $nxt = 0
  
          while $mp != 0
                  set $pkt = $pkt + 1
          
                  set $mn = (struct mbuf *)$mp->m_hdr.mh_next
                  while $mn != 0
                          set $nxt = $nxt + 1
                          
                          set $mn = (struct mbuf *)$mn->m_hdr.mh_next
                  end
                  
                  set $mp = $mp->m_hdr.mh_nextpkt
  
                  if (($pkt + $nxt) % 50) == 0
                          printf "... %d\n", $pkt + $nxt
                  end
          end
  
          printf "\ntotal: %d (via m_next: %d)\n", $pkt + $nxt, $nxt
  end
  
  document mbuf_countchain
  Syntax: mbuf_countchain <addr>
  | Count the total number of mbufs chained from the given the address of an mbuf. 
  | The routine follows both the m_next pointers and m_nextpkt pointers.
  end
  
  set $RTF_UP          = 0x1
  set $RTF_GATEWAY     = 0x2
  set $RTF_HOST        = 0x4
  set $RTF_REJECT      = 0x8
  set $RTF_DYNAMIC     = 0x10
  set $RTF_MODIFIED    = 0x20
  set $RTF_DONE        = 0x40
  set $RTF_DELCLONE    = 0x80
  set $RTF_CLONING     = 0x100
  set $RTF_XRESOLVE    = 0x200
  set $RTF_LLINFO      = 0x400
  set $RTF_STATIC      = 0x800
  set $RTF_BLACKHOLE   = 0x1000
  set $RTF_PROTO2      = 0x4000
  set $RTF_PROTO1      = 0x8000
  set $RTF_PRCLONING   = 0x10000
  set $RTF_WASCLONED   = 0x20000
  set $RTF_PROTO3      = 0x40000
  set $RTF_PINNED      = 0x100000
  set $RTF_LOCAL       = 0x200000
  set $RTF_BROADCAST   = 0x400000
  set $RTF_MULTICAST   = 0x800000
  set $RTF_IFSCOPE     = 0x1000000
  set $RTF_CONDEMNED   = 0x2000000
  
  set $AF_INET = 2
  set $AF_INET6 = 30
  set $AF_LINK = 18
  
  define rtentry_prdetails
          set $rt = (struct rtentry *)$arg0
          set $is_v6 = 0
  
          set $dst = (struct sockaddr *)$rt->rt_nodes->rn_u.rn_leaf.rn_Key
          if $dst->sa_family == $AF_INET
                  showsockaddr_in $dst
                  printf " "
          else
                  if $dst->sa_family == $AF_INET6
                          showsockaddr_in6 $dst
                          printf " "
                          set $is_v6 = 1
                  else
                          if $dst->sa_family == $AF_LINK
                                  showsockaddr_dl $dst
                                  printf " "
                          else
                                  showsockaddr_unspec $dst
                          end
                  end
          end
  
          set $dst = (struct sockaddr *)$rt->rt_gateway
          if $dst->sa_family == $AF_INET
                  showsockaddr_in $dst
                  printf "   "
          else
                  if $dst->sa_family == $AF_INET6
                          set $is_v6 = 1
                          showsockaddr_in6 $dst
                          printf " "
                  else
                          if $dst->sa_family == $AF_LINK
                                  showsockaddr_dl $dst
                                  if $is_v6
                                          printf "                       "
                                  else
                                          printf " "
                                  end
                          else
                                  showsockaddr_unspec $dst
                          end
                  end
          end
  
          if $rt->rt_flags & $RTF_WASCLONED
                  if $kgm_lp64
                          printf "%18p ", $rt->rt_parent
                  else
                          printf "%10p ", $rt->rt_parent
                  end
          else
                  if $kgm_lp64
                          printf "                   "
                  else
                          printf "           "
                  end
          end
  
          printf "%6u %8u ", $rt->rt_refcnt, $rt->rt_rmx.rmx_pksent
  
          if $rt->rt_flags & $RTF_UP
                  printf "U"
          end
          if $rt->rt_flags & $RTF_GATEWAY
                  printf "G"
          end
          if $rt->rt_flags & $RTF_HOST
                  printf "H"
          end
          if $rt->rt_flags & $RTF_REJECT
                  printf "R"
          end
          if $rt->rt_flags & $RTF_DYNAMIC
                  printf "D"
          end
          if $rt->rt_flags & $RTF_MODIFIED
                  printf "M"
          end
          if $rt->rt_flags & $RTF_CLONING
                  printf "C"
          end
          if $rt->rt_flags & $RTF_PRCLONING
                  printf "c"
          end
          if $rt->rt_flags & $RTF_LLINFO
                  printf "L"
          end
          if $rt->rt_flags & $RTF_STATIC
                  printf "S"
          end
          if $rt->rt_flags & $RTF_PROTO1
                  printf "1"
          end
          if $rt->rt_flags & $RTF_PROTO2
                  printf "2"
          end
          if $rt->rt_flags & $RTF_PROTO3
                  printf "3"
          end
          if $rt->rt_flags & $RTF_WASCLONED
                  printf "W"
          end
          if $rt->rt_flags & $RTF_BROADCAST
                  printf "b"
          end
          if $rt->rt_flags & $RTF_MULTICAST
                  printf "m"
          end
          if $rt->rt_flags & $RTF_XRESOLVE
                  printf "X"
          end
          if $rt->rt_flags & $RTF_BLACKHOLE
                  printf "B"
          end
          if $rt->rt_flags & $RTF_IFSCOPE
                  printf "I"
          end
  
          printf "/%s%d", $rt->rt_ifp->if_name, $rt->rt_ifp->if_unit
  end
  
  set $RNF_ROOT   = 2
  
  define _rttable_dump
          set $rnh = $arg0
          set $rn = (struct radix_node *)$rnh->rnh_treetop
          set $rnh_cnt = $rnh->rnh_cnt
                  
          while $rn->rn_bit >= 0
                  set $rn = $rn->rn_u.rn_node.rn_L
          end
          
          while 1
                  set $base = (struct radix_node *)$rn
                  while ($rn->rn_parent->rn_u.rn_node.rn_R == $rn) && ($rn->rn_flags & $RNF_ROOT) == 0
                          set $rn = $rn->rn_parent
                  end
                  set $rn = $rn->rn_parent->rn_u.rn_node.rn_R
                  while $rn->rn_bit >= 0
                          set $rn = $rn->rn_u.rn_node.rn_L
                  end
                  set $next = $rn
                  while $base != 0
                          set $rn = $base
                          set $base = $rn->rn_u.rn_leaf.rn_Dupedkey
                          if ($rn->rn_flags & $RNF_ROOT) == 0
                                  
                                  set $rt = (struct rtentry *)$rn
                                  
                                  if $kgm_lp64
                                          printf "%18p ", $rt
                                  else
                                          printf "%10p ", $rt
                                  end
                                  rtentry_prdetails $rt
                                  printf "\n"
                                  
                          end
                  end
                  set $rn = $next
                  if ($rn->rn_flags & $RNF_ROOT) != 0
                          loop_break
                  end
          end
  end
  
  
  define show_rt_inet
          if $kgm_lp64
                  printf " rtentry           dst             gw                parent             Refs   Use      flags/if\n"
                  printf " ----------------- --------------- ----------------- ------------------ ------ -------- -----------\n"
          else
                  printf " rtentry   dst             gw                parent     Refs   Use      flags/if\n"
                  printf " --------- --------------- ----------------- ---------- ------ -------- -----------\n"
          end
          _rttable_dump rt_tables[2]
  end
  
  document show_rt_inet
  Syntax: (gdb) show_rt_inet
  | Show the entries of the IPv4 routing table.
  end
  
  define show_rt_inet6
          if $kgm_lp64
                  printf " rtentry           dst                                     gw                                      parent             Refs   Use      flags/if\n"
                  printf " ----------------- --------------------------------------- --------------------------------------- ------------------ ------ -------- -----------\n"
          else
                  printf " rtentry   dst                                     gw                                      parent     Refs   Use      flags/if\n"
                  printf " --------- --------------------------------------- --------------------------------------- ---------- ------ -------- -----------\n"
          end
          _rttable_dump rt_tables[30]
  end
  
  document show_rt_inet6
  Syntax: (gdb) show_rt_inet6
  | Show the entries of the IPv6 routing table.
  end
  
  define rtentry_trash
          set $rtd = (struct rtentry_dbg *)rttrash_head.tqh_first
          set $cnt = 0
          while $rtd != 0
                  if $cnt == 0
                      if $kgm_lp64
                                  printf "                rtentry ref   hold   rele             dst    gw             parent flags/if\n"
                                  printf "      ----------------- --- ------ ------ --------------- ----- ------------------ -----------\n"
                          else
                                  printf "        rtentry ref   hold   rele             dst    gw     parent flags/if\n"
                                  printf "      --------- --- ------ ------ --------------- ----- ---------- -----------\n"
                          end
                  end
                  printf "%4d: %p %3d %6d %6d ", $cnt + 1, $rtd, \
                      $rtd->rtd_refhold_cnt - $rtd->rtd_refrele_cnt, \
                      $rtd->rtd_refhold_cnt, $rtd->rtd_refrele_cnt
                  rtentry_prdetails $rtd
                  printf "\n"
                  set $rtd = $rtd->rtd_trash_link.tqe_next
                  set $cnt = $cnt + 1
          end
  end
  
  document rtentry_trash
  Syntax: (gdb) rtentry_trash
  | Walk the list of trash route entries; this requires route entry
  | debugging to be turned on, by setting the appropriate flags to the
  | "rte_debug" boot-args parameter.
  end
  
  set $CTRACE_STACK_SIZE = ctrace_stack_size
  set $CTRACE_HIST_SIZE = ctrace_hist_size
  
  define rtentry_showdbg
          set $rtd = (struct rtentry_dbg *)$arg0
          set $cnt = 0
  
          printf "Total holds:\t%d\n", $rtd->rtd_refhold_cnt
          printf "Total releases:\t%d\n", $rtd->rtd_refrele_cnt
  
          set $ix = 0
          while $ix < $CTRACE_STACK_SIZE
                  set $kgm_pc = $rtd->rtd_alloc.pc[$ix]
                  if $kgm_pc != 0
                          if $ix == 0
                                  printf "\nAlloc (thread %p):\n", \
                                      $rtd->rtd_alloc.th
                          end
                          printf "%4d: ", $ix + 1
                          pcprint $kgm_pc
                          printf "\n"
                  end
                  set $ix = $ix + 1
          end
          set $ix = 0
          while $ix < $CTRACE_STACK_SIZE
                  set $kgm_pc = $rtd->rtd_free.pc[$ix]
                  if $kgm_pc != 0
                          if $ix == 0
                                  printf "\nFree: (thread %p)\n", \
                                      $rtd->rtd_free.th
                          end
                          printf "%4d: ", $ix + 1
                          pcprint $kgm_pc
                          printf "\n"
                  end
                  set $ix = $ix + 1
          end
          while $cnt < $CTRACE_HIST_SIZE
                  set $ix = 0
                  while $ix < $CTRACE_STACK_SIZE
                          set $kgm_pc = $rtd->rtd_refhold[$cnt].pc[$ix]
                          if $kgm_pc != 0
                                  if $ix == 0
                                          printf "\nHold [%d] (thread %p):\n", \
                                              $cnt, $rtd->rtd_refhold[$cnt].th
                                  end
                                  printf "%4d: ", $ix + 1
                                  pcprint $kgm_pc
                                  printf "\n"
                          end
                          set $ix = $ix + 1
                  end
                  set $cnt = $cnt + 1
          end
          set $cnt = 0
          while $cnt < $CTRACE_HIST_SIZE
                  set $ix = 0
                  while $ix < $CTRACE_STACK_SIZE
                          set $kgm_pc = $rtd->rtd_refrele[$cnt].pc[$ix]
                          if $kgm_pc != 0
                                  if $ix == 0
                                          printf "\nRelease [%d] (thread %p):\n",\
                                              $cnt, $rtd->rtd_refrele[$cnt].th
                                  end
                                  printf "%4d: ", $ix + 1
                                  pcprint $kgm_pc
                                  printf "\n"
                          end
                          set $ix = $ix + 1
                  end
                  set $cnt = $cnt + 1
          end
  
          printf "\nTotal locks:\t%d\n", $rtd->rtd_lock_cnt
          printf "Total unlocks:\t%d\n", $rtd->rtd_unlock_cnt
  
          set $cnt = 0
          while $cnt < $CTRACE_HIST_SIZE
                  set $ix = 0
                  while $ix < $CTRACE_STACK_SIZE
                          set $kgm_pc = $rtd->rtd_lock[$cnt].pc[$ix]
                          if $kgm_pc != 0
                                  if $ix == 0
                                          printf "\nLock [%d] (thread %p):\n",\
                                              $cnt, $rtd->rtd_lock[$cnt].th
                                  end
                                  printf "%4d: ", $ix + 1
                                  pcprint $kgm_pc
                                  printf "\n"
                          end
                          set $ix = $ix + 1
                  end
                  set $cnt = $cnt + 1
          end
          set $cnt = 0
          while $cnt < $CTRACE_HIST_SIZE
                  set $ix = 0
                  while $ix < $CTRACE_STACK_SIZE
                          set $kgm_pc = $rtd->rtd_unlock[$cnt].pc[$ix]
                          if $kgm_pc != 0
                                  if $ix == 0
                                          printf "\nUnlock [%d] (thread %p):\n",\
                                              $cnt, $rtd->rtd_unlock[$cnt].th
                                  end
                                  printf "%4d: ", $ix + 1
                                  pcprint $kgm_pc
                                  printf "\n"
                          end
                          set $ix = $ix + 1
                  end
                  set $cnt = $cnt + 1
          end
  end
  
  document rtentry_showdbg
  Syntax: (gdb) rtentry_showdbg <addr>
  | Given a route entry structure address, print the debug information
  | related to it.  This requires route entry debugging to be turned
  | on, by setting the appropriate flags to the "rte_debug" boot-args
  | parameter.
  end
  
  set $INIFA_TRACE_HIST_SIZE = inifa_trace_hist_size
  
  define inifa_showdbg
          set $inifa = (struct in_ifaddr_dbg *)$arg0
          set $cnt = 0
  
          printf "Total holds:\t%d\n", $inifa->inifa_refhold_cnt
          printf "Total releases:\t%d\n", $inifa->inifa_refrele_cnt
  
          set $ix = 0
          while $ix < $CTRACE_STACK_SIZE
                  set $kgm_pc = $inifa->inifa_alloc.pc[$ix]
                  if $kgm_pc != 0
                          if $ix == 0
                                  printf "\nAlloc (thread %p):\n", \
                                      $inifa->inifa_alloc.th
                          end
                          printf "%4d: ", $ix + 1
                          pcprint $kgm_pc
                          printf "\n"
                  end
                  set $ix = $ix + 1
          end
          set $ix = 0
          while $ix < $CTRACE_STACK_SIZE
                  set $kgm_pc = $inifa->inifa_free.pc[$ix]
                  if $kgm_pc != 0
                          if $ix == 0
                                  printf "\nFree: (thread %p)\n", \
                                      $inifa->inifa_free.th
                          end
                          printf "%4d: ", $ix + 1
                          pcprint $kgm_pc
                          printf "\n"
                  end
                  set $ix = $ix + 1
          end
          while $cnt < $INIFA_TRACE_HIST_SIZE
                  set $ix = 0
                  while $ix < $CTRACE_STACK_SIZE
                          set $kgm_pc = $inifa->inifa_refhold[$cnt].pc[$ix]
                          if $kgm_pc != 0
                                  if $ix == 0
                                          printf "\nHold [%d] (thread %p):\n", \
                                              $cnt, $inifa->inifa_refhold[$cnt].th
                                  end
                                  printf "%4d: ", $ix + 1
                                  pcprint $kgm_pc
                                  printf "\n"
                          end
                          set $ix = $ix + 1
                  end
                  set $cnt = $cnt + 1
          end
          set $cnt = 0
          while $cnt < $INIFA_TRACE_HIST_SIZE
                  set $ix = 0
                  while $ix < $CTRACE_STACK_SIZE
                          set $kgm_pc = $inifa->inifa_refrele[$cnt].pc[$ix]
                          if $kgm_pc != 0
                                  if $ix == 0
                                          printf "\nRelease [%d] (thread %p):\n",\
                                              $cnt, $inifa->inifa_refrele[$cnt].th
                                  end
                                  printf "%4d: ", $ix + 1
                                  pcprint $kgm_pc
                                  printf "\n"
                          end
                          set $ix = $ix + 1
                  end
                  set $cnt = $cnt + 1
          end
  end
  
  document inifa_showdbg
  Syntax: (gdb) inifa_showdbg <addr>
  | Given an IPv4 interface structure address, print the debug information
  | related to it.  This requires interface address debugging to be turned
  | on, by setting the appropriate flags to the "ifa_debug" boot-args
  | parameter.
  end
  
  set $IN6IFA_TRACE_HIST_SIZE = in6ifa_trace_hist_size
  
  define in6ifa_showdbg
          set $in6ifa = (struct in6_ifaddr_dbg *)$arg0
          set $cnt = 0
  
          printf "Total holds:\t%d\n", $in6ifa->in6ifa_refhold_cnt
          printf "Total releases:\t%d\n", $in6ifa->in6ifa_refrele_cnt
  
          set $ix = 0
          while $ix < $CTRACE_STACK_SIZE
                  set $kgm_pc = $in6ifa->in6ifa_alloc.pc[$ix]
                  if $kgm_pc != 0
                          if $ix == 0
                                  printf "\nAlloc (thread %p):\n", \
                                      $in6ifa->in6ifa_alloc.th
                          end
                          printf "%4d: ", $ix + 1
                          pcprint $kgm_pc
                          printf "\n"
                  end
                  set $ix = $ix + 1
          end
          set $ix = 0
          while $ix < $CTRACE_STACK_SIZE
                  set $kgm_pc = $in6ifa->in6ifa_free.pc[$ix]
                  if $kgm_pc != 0
                          if $ix == 0
                                  printf "\nFree: (thread %p)\n", \
                                      $in6ifa->in6ifa_free.th
                          end
                          printf "%4d: ", $ix + 1
                          pcprint $kgm_pc
                          printf "\n"
                  end
                  set $ix = $ix + 1
          end
          while $cnt < $IN6IFA_TRACE_HIST_SIZE
                  set $ix = 0
                  while $ix < $CTRACE_STACK_SIZE
                          set $kgm_pc = $in6ifa->in6ifa_refhold[$cnt].pc[$ix]
                          if $kgm_pc != 0
                                  if $ix == 0
                                          printf "\nHold [%d] (thread %p):\n", \
                                            $cnt, $in6ifa->in6ifa_refhold[$cnt].th
                                  end
                                  printf "%4d: ", $ix + 1
                                  pcprint $kgm_pc
                                  printf "\n"
                          end
                          set $ix = $ix + 1
                  end
                  set $cnt = $cnt + 1
          end
          set $cnt = 0
          while $cnt < $IN6IFA_TRACE_HIST_SIZE
                  set $ix = 0
                  while $ix < $CTRACE_STACK_SIZE
                          set $kgm_pc = $in6ifa->in6ifa_refrele[$cnt].pc[$ix]
                          if $kgm_pc != 0
                                  if $ix == 0
                                          printf "\nRelease [%d] (thread %p):\n",\
                                            $cnt, $in6ifa->in6ifa_refrele[$cnt].th
                                  end
                                  printf "%4d: ", $ix + 1
                                  pcprint $kgm_pc
                                  printf "\n"
                          end
                          set $ix = $ix + 1
                  end
                  set $cnt = $cnt + 1
          end
  end
  
  document in6ifa_showdbg
  Syntax: (gdb) in6ifa_showdbg <addr>
  | Given an IPv6 interface structure address, print the debug information
  | related to it.  This requires interface address debugging to be turned
  | on, by setting the appropriate flags to the "ifa_debug" boot-args
  | parameter.
  end
  
  set $IFMA_TRACE_HIST_SIZE = ifma_trace_hist_size
  
  define ifma_showdbg
          set $ifma = (struct ifmultiaddr_dbg *)$arg0
          set $cnt = 0
  
          printf "Total holds:\t%d\n", $ifma->ifma_refhold_cnt
          printf "Total releases:\t%d\n", $ifma->ifma_refrele_cnt
  
          while $cnt < $IFMA_TRACE_HIST_SIZE
                  set $ix = 0
                  while $ix < $CTRACE_STACK_SIZE
                          set $kgm_pc = $ifma->ifma_refhold[$cnt].pc[$ix]
                          if $kgm_pc != 0
                                  if $ix == 0
                                          printf "\nHold [%d] (thread %p):\n", \
                                            $cnt, $ifma->ifma_refhold[$cnt].th
                                  end
                                  printf "%4d: ", $ix + 1
                                  pcprint $kgm_pc
                                  printf "\n"
                          end
                          set $ix = $ix + 1
                  end
                  set $cnt = $cnt + 1
          end
          set $cnt = 0
          while $cnt < $IFMA_TRACE_HIST_SIZE
                  set $ix = 0
                  while $ix < $CTRACE_STACK_SIZE
                          set $kgm_pc = $ifma->ifma_refrele[$cnt].pc[$ix]
                          if $kgm_pc != 0
                                  if $ix == 0
                                          printf "\nRelease [%d] (thread %p):\n",\
                                            $cnt, $ifma->ifma_refrele[$cnt].th
                                  end
                                  printf "%4d: ", $ix + 1
                                  pcprint $kgm_pc
                                  printf "\n"
                          end
                          set $ix = $ix + 1
                  end
                  set $cnt = $cnt + 1
          end
  end
  
  document ifma_showdbg
  Syntax: (gdb) ifma_showdbg <addr>
  | Given a link multicast structure address, print the debug information
  | related to it.  This requires interface address debugging to be turned
  | on, by setting the appropriate flags to the "ifa_debug" boot-args
  | parameter.
  end
  
  set $INM_TRACE_HIST_SIZE = inm_trace_hist_size
  
  define inm_showdbg
          set $inm = (struct in_multi_dbg *)$arg0
          set $cnt = 0
  
          printf "Total holds:\t%d\n", $inm->inm_refhold_cnt
          printf "Total releases:\t%d\n", $inm->inm_refrele_cnt
  
          while $cnt < $INM_TRACE_HIST_SIZE
                  set $ix = 0
                  while $ix < $CTRACE_STACK_SIZE
                          set $kgm_pc = $inm->inm_refhold[$cnt].pc[$ix]
                          if $kgm_pc != 0
                                  if $ix == 0
                                          printf "\nHold [%d] (thread %p):\n", \
                                            $cnt, $inm->inm_refhold[$cnt].th
                                  end
                                  printf "%4d: ", $ix + 1
                                  pcprint $kgm_pc
                                  printf "\n"
                          end
                          set $ix = $ix + 1
                  end
                  set $cnt = $cnt + 1
          end
          set $cnt = 0
          while $cnt < $INM_TRACE_HIST_SIZE
                  set $ix = 0
                  while $ix < $CTRACE_STACK_SIZE
                          set $kgm_pc = $inm->inm_refrele[$cnt].pc[$ix]
                          if $kgm_pc != 0
                                  if $ix == 0
                                          printf "\nRelease [%d] (thread %p):\n",\
                                            $cnt, $inm->inm_refrele[$cnt].th
                                  end
                                  printf "%4d: ", $ix + 1
                                  pcprint $kgm_pc
                                  printf "\n"
                          end
                          set $ix = $ix + 1
                  end
                  set $cnt = $cnt + 1
          end
  end
  
  document inm_showdbg
  Syntax: (gdb) inm_showdbg <addr>
  | Given an IPv4 multicast structure address, print the debug information
  | related to it.  This requires interface address debugging to be turned
  | on, by setting the appropriate flags to the "ifa_debug" boot-args
  | parameter.
  end
  
  set $IF_REF_TRACE_HIST_SIZE = if_ref_trace_hist_size
  
  define ifpref_showdbg
          set $dl_if = (struct dlil_ifnet_dbg *)$arg0
          set $cnt = 0
  
          printf "Total references:\t%d\n", $dl_if->dldbg_if_refhold_cnt
          printf "Total releases:\t\t%d\n", $dl_if->dldbg_if_refrele_cnt
  
          while $cnt < $IF_REF_TRACE_HIST_SIZE
                  set $ix = 0
                  while $ix < $CTRACE_STACK_SIZE
                          set $kgm_pc = $dl_if->dldbg_if_refhold[$cnt].pc[$ix]
                          if $kgm_pc != 0
                                  if $ix == 0
                                          printf "\nHold [%d] (thread %p):\n", \
                                              $cnt, \
                                              $dl_if->dldbg_if_refhold[$cnt].th
                                  end
                                  printf "%4d: ", $ix + 1
                                  pcprint $kgm_pc
                                  printf "\n"
                          end
                          set $ix = $ix + 1
                  end
                  set $cnt = $cnt + 1
          end
          set $cnt = 0
          while $cnt < $IF_REF_TRACE_HIST_SIZE
                  set $ix = 0
                  while $ix < $CTRACE_STACK_SIZE
                          set $kgm_pc = $dl_if->dldbg_if_refrele[$cnt].pc[$ix]
                          if $kgm_pc != 0
                                  if $ix == 0
                                          printf "\nRelease [%d] (thread %p):\n",\
                                              $cnt, \
                                              $dl_if->dldbg_if_refrele[$cnt].th
                                  end
                                  printf "%4d: ", $ix + 1
                                  pcprint $kgm_pc
                                  printf "\n"
                          end
                          set $ix = $ix + 1
                  end
                  set $cnt = $cnt + 1
          end
  end
  
  document ifpref_showdbg
  Syntax: (gdb) ifpref_showdbg <addr>
  | Given an ifnet structure address, print the debug information
  | related to its refcnt.  This requires ifnet debugging to be turned
  | on, by setting the appropriate flags to the "ifnet_debug" boot-args
  | parameter.
  end
  
  define in6ifa_trash
          set $ifa = (struct in6_ifaddr_dbg *)in6ifa_trash_head.tqh_first
          set $cnt = 0
          while $ifa != 0
                  if $cnt == 0
                      if $kgm_lp64
                                  printf "                in6_ifa ref   hold   rele\n"
                                  printf "      ----------------- --- ------ ------\n"
                          else
                                  printf "        in6_ifa ref   hold   rele\n"
                                  printf "      --------- --- ------ ------\n"
                          end
                  end
                  printf "%4d: %p %3d %6d %6d ", $cnt + 1, $ifa, \
                      $ifa->in6ifa_refhold_cnt - $ifa->in6ifa_refrele_cnt, \
                      $ifa->in6ifa_refhold_cnt, $ifa->in6ifa_refrele_cnt
                  showsockaddr_in6 $ifa->in6ifa.ia_ifa.ifa_addr
                  printf "\n"
                  set $ifa = $ifa->in6ifa_trash_link.tqe_next
                  set $cnt = $cnt + 1
          end
  end
  
  set $NDPR_TRACE_HIST_SIZE = ndpr_trace_hist_size
  
  define ndpr_showdbg
          set $ndpr = (struct nd_prefix_dbg *)$arg0
          set $cnt = 0
  
          printf "Total references:\t%d\n", $ndpr->ndpr_refhold_cnt
          printf "Total releases:\t\t%d\n", $ndpr->ndpr_refrele_cnt
  
          while $cnt < $NDPR_TRACE_HIST_SIZE
                  set $ix = 0
                  while $ix < $CTRACE_STACK_SIZE
                          set $kgm_pc = $ndpr->ndpr_refhold[$cnt].pc[$ix]
                          if $kgm_pc != 0
                                  if $ix == 0
                                          printf "\nHold [%d] (thread %p):\n", \
                                              $cnt, \
                                              $ndpr->ndpr_refhold[$cnt].th
                                  end
                                  printf "%4d: ", $ix + 1
                                  pcprint $kgm_pc
                                  printf "\n"
                          end
                          set $ix = $ix + 1
                  end
                  set $cnt = $cnt + 1
          end
          set $cnt = 0
          while $cnt < $NDPR_TRACE_HIST_SIZE
                  set $ix = 0
                  while $ix < $CTRACE_STACK_SIZE
                          set $kgm_pc = $ndpr->ndpr_refrele[$cnt].pc[$ix]
                          if $kgm_pc != 0
                                  if $ix == 0
                                          printf "\nRelease [%d] (thread %p):\n",\
                                              $cnt, \
                                              $ndpr->ndpr_refrele[$cnt].th
                                  end
                                  printf "%4d: ", $ix + 1
                                  pcprint $kgm_pc
                                  printf "\n"
                          end
                          set $ix = $ix + 1
                  end
                  set $cnt = $cnt + 1
          end
  end
  
  document ndpr_showdbg
  Syntax: (gdb) ndpr_showdbg <addr>
  | Given a nd_prefix structure address, print the debug information
  | related to its refcnt.  This requires the interface address debugging
  | to be turned on, by setting the appropriate flags to the "ifa_debug"
  | boot-args parameter.
  end
  
  set $NDDR_TRACE_HIST_SIZE = nddr_trace_hist_size
  
  define nddr_showdbg
          set $nddr = (struct nd_defrouter_dbg *)$arg0
          set $cnt = 0
  
          printf "Total references:\t%d\n", $nddr->nddr_refhold_cnt
          printf "Total releases:\t\t%d\n", $nddr->nddr_refrele_cnt
  
          while $cnt < $NDDR_TRACE_HIST_SIZE
                  set $ix = 0
                  while $ix < $CTRACE_STACK_SIZE
                          set $kgm_pc = $nddr->nddr_refhold[$cnt].pc[$ix]
                          if $kgm_pc != 0
                                  if $ix == 0
                                          printf "\nHold [%d] (thread %p):\n", \
                                              $cnt, \
                                              $nddr->nddr_refhold[$cnt].th
                                  end
                                  printf "%4d: ", $ix + 1
                                  pcprint $kgm_pc
                                  printf "\n"
                          end
                          set $ix = $ix + 1
                  end
                  set $cnt = $cnt + 1
          end
          set $cnt = 0
          while $cnt < $NDDR_TRACE_HIST_SIZE
                  set $ix = 0
                  while $ix < $CTRACE_STACK_SIZE
                          set $kgm_pc = $nddr->nddr_refrele[$cnt].pc[$ix]
                          if $kgm_pc != 0
                                  if $ix == 0
                                          printf "\nRelease [%d] (thread %p):\n",\
                                              $cnt, \
                                              $nddr->nddr_refrele[$cnt].th
                                  end
                                  printf "%4d: ", $ix + 1
                                  pcprint $kgm_pc
                                  printf "\n"
                          end
                          set $ix = $ix + 1
                  end
                  set $cnt = $cnt + 1
          end
  end
  
  document nddr_showdbg
  Syntax: (gdb) nddr_showdbg <addr>
  | Given a nd_defrouter structure address, print the debug information
  | related to its refcnt.  This requires the interface address debugging
  | to be turned on, by setting the appropriate flags to the "ifa_debug"
  | boot-args parameter.
  end
  set $IMO_TRACE_HIST_SIZE = imo_trace_hist_size
  
  define imo_showdbg
          set $imo = (struct ip_moptions_dbg *)$arg0
          set $cnt = 0
  
          printf "Total references:\t%d\n", $imo->imo_refhold_cnt
          printf "Total releases:\t\t%d\n", $imo->imo_refrele_cnt
  
          while $cnt < $IMO_TRACE_HIST_SIZE
                  set $ix = 0
                  while $ix < $CTRACE_STACK_SIZE
                          set $kgm_pc = $imo->imo_refhold[$cnt].pc[$ix]
                          if $kgm_pc != 0
                                  if $ix == 0
                                          printf "\nHold [%d] (thread %p):\n", \
                                              $cnt, \
                                              $imo->imo_refhold[$cnt].th
                                  end
                                  printf "%4d: ", $ix + 1
                                  pcprint $kgm_pc
                                  printf "\n"
                          end
                          set $ix = $ix + 1
                  end
                  set $cnt = $cnt + 1
          end
          set $cnt = 0
          while $cnt < $IMO_TRACE_HIST_SIZE
                  set $ix = 0
                  while $ix < $CTRACE_STACK_SIZE
                          set $kgm_pc = $imo->imo_refrele[$cnt].pc[$ix]
                          if $kgm_pc != 0
                                  if $ix == 0
                                          printf "\nRelease [%d] (thread %p):\n",\
                                              $cnt, \
                                              $imo->imo_refrele[$cnt].th
                                  end
                                  printf "%4d: ", $ix + 1
                                  pcprint $kgm_pc
                                  printf "\n"
                          end
                          set $ix = $ix + 1
                  end
                  set $cnt = $cnt + 1
          end
  end
  
  document imo_showdbg
  Syntax: (gdb) imo_showdbg <addr>
  | Given a ip_moptions structure address, print the debug information
  | related to its refcnt.  This requires the interface address debugging
  | to be turned on, by setting the appropriate flags to the "ifa_debug"
  | boot-args parameter.
  end
  
  set $IM6O_TRACE_HIST_SIZE = im6o_trace_hist_size
  
  define im6o_showdbg
          set $im6o = (struct ip6_moptions_dbg *)$arg0
          set $cnt = 0
  
          printf "Total references:\t%d\n", $im6o->im6o_refhold_cnt
          printf "Total releases:\t\t%d\n", $im6o->im6o_refrele_cnt
  
          while $cnt < $IM6O_TRACE_HIST_SIZE
                  set $ix = 0
                  while $ix < $CTRACE_STACK_SIZE
                          set $kgm_pc = $im6o->im6o_refhold[$cnt].pc[$ix]
                          if $kgm_pc != 0
                                  if $ix == 0
                                          printf "\nHold [%d] (thread %p):\n", \
                                              $cnt, \
                                              $im6o->im6o_refhold[$cnt].th
                                  end
                                  printf "%4d: ", $ix + 1
                                  pcprint $kgm_pc
                                  printf "\n"
                          end
                          set $ix = $ix + 1
                  end
                  set $cnt = $cnt + 1
          end
          set $cnt = 0
          while $cnt < $IM6O_TRACE_HIST_SIZE
                  set $ix = 0
                  while $ix < $CTRACE_STACK_SIZE
                          set $kgm_pc = $im6o->im6o_refrele[$cnt].pc[$ix]
                          if $kgm_pc != 0
                                  if $ix == 0
                                          printf "\nRelease [%d] (thread %p):\n",\
                                              $cnt, \
                                              $im6o->im6o_refrele[$cnt].th
                                  end
                                  printf "%4d: ", $ix + 1
                                  pcprint $kgm_pc
                                  printf "\n"
                          end
                          set $ix = $ix + 1
                  end
                  set $cnt = $cnt + 1
          end
  end
  
  document im6o_showdbg
  Syntax: (gdb) im6o_showdbg <addr>
  | Given a ip6_moptions structure address, print the debug information
  | related to its refcnt.  This requires the interface address debugging
  | to be turned on, by setting the appropriate flags to the "ifa_debug"
  | boot-args parameter.
  end
  
  document in6ifa_trash
  Syntax: (gdb) in6ifa_trash
  | Walk the list of trash in6_ifaddr entries; this requires interface
  | address debugging to be turned on, by setting the appropriate flags
  | to the "ifa_debug" boot-args parameter.
  end
  
  define inifa_trash
          set $ifa = (struct in_ifaddr_dbg *)inifa_trash_head.tqh_first
          set $cnt = 0
          while $ifa != 0
                  if $cnt == 0
                      if $kgm_lp64
                                  printf "                 in_ifa ref   hold   rele\n"
                                  printf "      ----------------- --- ------ ------\n"
                          else
                                  printf "         in_ifa ref   hold   rele\n"
                                  printf "      --------- --- ------ ------\n"
                          end
                  end
                  printf "%4d: %p %3d %6d %6d ", $cnt + 1, $ifa, \
                      $ifa->inifa_refhold_cnt - $ifa->inifa_refrele_cnt, \
                      $ifa->inifa_refhold_cnt, $ifa->inifa_refrele_cnt
                  showsockaddr_in $ifa->inifa.ia_ifa.ifa_addr
                  printf "\n"
                  set $ifa = $ifa->inifa_trash_link.tqe_next
                  set $cnt = $cnt + 1
          end
  end
  
  document inifa_trash
  Syntax: (gdb) inifa_trash
  | Walk the list of trash in_ifaddr entries; this requires interface
  | address debugging to be turned on, by setting the appropriate flags
  | to the "ifa_debug" boot-args parameter.
  end
  
  define ifma_trash
          set $ifma = (struct ifmultiaddr_dbg *)ifma_trash_head.tqh_first
          set $cnt = 0
          while $ifma != 0
                  if $cnt == 0
                      if $kgm_lp64
                                  printf "                   ifma ref   hold   rele\n"
                                  printf "      ----------------- --- ------ ------\n"
                          else
                                  printf "          ifma  ref   hold   rele\n"
                                  printf "      --------- --- ------ ------\n"
                          end
                  end
                  printf "%4d: %p %3d %6d %6d ", $cnt + 1, $ifma, \
                      $ifma->ifma_refhold_cnt - $ifma->ifma_refrele_cnt, \
                      $ifma->ifma_refhold_cnt, $ifma->ifma_refrele_cnt
                  showsockaddr $ifma->ifma.ifma_addr
                  printf " @ %s%d", $ifma->ifma.ifma_ifp->if_name, \
                      $ifma->ifma.ifma_ifp->if_unit
                  printf "\n"
                  set $ifma = $ifma->ifma_trash_link.tqe_next
                  set $cnt = $cnt + 1
          end
  end
  
  document ifma_trash
  Syntax: (gdb) ifma_trash
  | Walk the list of trash ifmultiaddr entries; this requires interface
  | address debugging to be turned on, by setting the appropriate flags
  | to the "ifa_debug" boot-args parameter.
  end
  
  define inm_trash
          set $inm = (struct in_multi_dbg *)inm_trash_head.tqh_first
          set $cnt = 0
          while $inm != 0
                  if $cnt == 0
                      if $kgm_lp64
                                  printf "                    inm ref   hold   rele\n"
                                  printf "      ----------------- --- ------ ------\n"
                          else
                                  printf "            inm ref   hold   rele\n"
                                  printf "      --------- --- ------ ------\n"
                          end
                  end
                  printf "%4d: %p %3d %6d %6d ", $cnt + 1, $inm, \
                      $inm->inm_refhold_cnt - $inm->inm_refrele_cnt, \
                      $inm->inm_refhold_cnt, $inm->inm_refrele_cnt
                  show_in_addr &($inm->inm.inm_addr)
                  printf "\n"
                  set $inm = $inm->inm_trash_link.tqe_next
                  set $cnt = $cnt + 1
          end
  end
  
  document inm_trash
  Syntax: (gdb) inm_trash
  | Walk the list of trash in_multi entries; this requires interface
  | address debugging to be turned on, by setting the appropriate flags
  | to the "ifa_debug" boot-args parameter.
  end
  
  define in6m_trash
          set $in6m = (struct in6_multi_dbg *)in6m_trash_head.tqh_first
          set $cnt = 0
          while $in6m != 0
                  if $cnt == 0
                      if $kgm_lp64
                                  printf "                   in6m ref   hold   rele\n"
                                  printf "      ----------------- --- ------ ------\n"
                          else
                                  printf "           in6m ref   hold   rele\n"
                                  printf "      --------- --- ------ ------\n"
                          end
                  end
                  printf "%4d: %p %3d %6d %6d ", $cnt + 1, $in6m, \
                      $in6m->in6m_refhold_cnt - $in6m->in6m_refrele_cnt, \
                      $in6m->in6m_refhold_cnt, $in6m->in6m_refrele_cnt
                  show_in_addr &($in6m->in6m.in6m_addr)
                  printf "\n"
                  set $in6m = $in6m->in6m_trash_link.tqe_next
                  set $cnt = $cnt + 1
          end
  end
  
  document in6m_trash
  Syntax: (gdb) in6m_trash
  | Walk the list of trash in6_multi entries; this requires interface
  | address debugging to be turned on, by setting the appropriate flags
  | to the "ifa_debug" boot-args parameter.
  end
  
  #
  # print all OSMalloc stats 
  
  define ostag_print
  set $kgm_tagp = (OSMallocTag)$arg0
  printf "0x%08x: ", $kgm_tagp
  printf "%8d ",$kgm_tagp->OSMT_refcnt
  printf "%8x ",$kgm_tagp->OSMT_state
  printf "%8x ",$kgm_tagp->OSMT_attr
  printf "%s ",$kgm_tagp->OSMT_name
  printf "\n"
  end
  
  
  define showosmalloc 
  printf "TAG          COUNT     STATE     ATTR     NAME\n"
  set $kgm_tagheadp = (struct _OSMallocTag_ *)&OSMalloc_tag_list
      set $kgm_tagptr = (struct _OSMallocTag_ * )($kgm_tagheadp->OSMT_link.next)
      while $kgm_tagptr != $kgm_tagheadp
          ostag_print $kgm_tagptr
          set $kgm_tagptr = (struct _OSMallocTag_ *)$kgm_tagptr->OSMT_link.next
      end
          printf "\n"
  end
  document showosmalloc
  Syntax: (gdb) showosmalloc
  | Print the outstanding allocation count by OSMallocTags.
  end
  
  
  define systemlog
      if msgbufp->msg_bufc[msgbufp->msg_bufx] == 0 \
         && msgbufp->msg_bufc[0] != 0
          # The buffer hasn't wrapped, so take the easy (and fast!) path
          printf "%s", msgbufp->msg_bufc
      else
          set $kgm_msgbuf = *msgbufp
          set $kgm_syslog_bufsize = $kgm_msgbuf.msg_size
          set $kgm_syslog_bufend = $kgm_msgbuf.msg_bufx
          if $kgm_syslog_bufend >= $kgm_syslog_bufsize
              set $kgm_syslog_bufend = 0
          end
      
          # print older messages from msg_bufx to end of buffer
          set $kgm_i = $kgm_syslog_bufend
          while $kgm_i < $kgm_syslog_bufsize
              set $kgm_syslog_char = $kgm_msgbuf.msg_bufc[$kgm_i]
              if $kgm_syslog_char == 0
                  # break out of loop
                  set $kgm_i = $kgm_syslog_bufsize
              else
                  printf "%c", $kgm_syslog_char
              end
              set $kgm_i = $kgm_i + 1
          end
          
          # print newer messages from start of buffer to msg_bufx
          set $kgm_i = 0
          while $kgm_i < $kgm_syslog_bufend
              set $kgm_syslog_char = $kgm_msgbuf.msg_bufc[$kgm_i]
              if $kgm_syslog_char != 0
                  printf "%c", $kgm_syslog_char
              end
              set $kgm_i = $kgm_i + 1
          end
      end
      printf "\n"
  end
  document systemlog
  | Syntax: systemlog
  | Display the kernel's printf ring buffer
  end
  
  
  define hexdump
          set $kgm_addr = (unsigned char *)$arg0
          set $kgm_len = $arg1
          while $kgm_len > 0
                  showptr $kgm_addr
                  printf ": "
                  set $kgm_i = 0
                  while $kgm_i < 16
                          printf "%02x ", *($kgm_addr+$kgm_i)
                          set $kgm_i += 1
                  end
                  printf " |"
                  set $kgm_i = 0
                  while $kgm_i < 16
                          set $kgm_temp = *($kgm_addr+$kgm_i)
                          if $kgm_temp < 32 || $kgm_temp >= 127
                                  printf "."
                          else
                                  printf "%c", $kgm_temp
                          end
                          set $kgm_i += 1
                  end
                  printf "|\n"
                  set $kgm_addr += 16
                  set $kgm_len -= 16
          end
  end
  document hexdump
  | Show the contents of memory as a hex/ASCII dump
  | The following is the syntax:
  | (gdb) hexdump <address> <length>
  end
  
  
  define printcolonhex
      if ($argc == 2) 
          set $addr = $arg0
          set $count = $arg1
          set $li = 0
          while ($li < $count)
              if ($li == 0)
                          printf "%02x", (u_char)$addr[$li]
              end
              if ($li != 0)
                          printf ":%02x", (u_char)$addr[$li]
              end
              set $li = $li + 1
          end
      end
  end
  
  define showsockaddr_dl
      set $sdl = (struct sockaddr_dl *)$arg0
      if ($sdl == 0)
                  printf "(null)           "
      else
              if $sdl->sdl_nlen == 0 && $sdl->sdl_alen == 0 && $sdl->sdl_slen == 0
                  printf "link#%3d         ", $sdl->sdl_index
              else
                          set $addr = $sdl->sdl_data + $sdl->sdl_nlen
                          set $count = $sdl->sdl_alen
                          printcolonhex $addr $count
                  end
      end
  end
  
  define showsockaddr_unspec
      set $sockaddr = (struct sockaddr *)$arg0
      set $addr = $sockaddr->sa_data
      set $count = $sockaddr->sa_len - 2
      printcolonhex $addr $count
  end
  
  define showsockaddr_at
      set $sockaddr = (struct sockaddr *)$arg0
      set $addr = $sockaddr->sa_data
      set $count = $sockaddr->sa_len - 2
      printcolonhex $addr $count
  end
  
  define show_in_addr
      set $ia = (unsigned char *)$arg0
      printf "%3u.%03u.%03u.%03u", $ia[0], $ia[1], $ia[2], $ia[3]
  end
  
  define showsockaddr_in
      set $sin = (struct sockaddr_in *)$arg0
      set $sa_bytes = (unsigned char *)&($sin->sin_addr)
      show_in_addr $sa_bytes
  end
  
  define show_in6_addr
      set $ia = (unsigned char *)$arg0
      printf "%2x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x", \
          $ia[0], $ia[1], $ia[2], $ia[3], $ia[4], $ia[5], $ia[6], $ia[7], $ia[8], $ia[9], $ia[10], $ia[11], $ia[12], $ia[13], $ia[14], $ia[15]
  end
  
  define showsockaddr_in6
      set $sin6 = (struct sockaddr_in6 *)$arg0
      set $sa_bytes = $sin6->sin6_addr.__u6_addr.__u6_addr8
      show_in6_addr $sa_bytes
  end
  
  define showsockaddr_un
          set $sun = (struct sockaddr_un *)$arg0
          if $sun == 0
                  printf "(null)"
          else
                  if $sun->sun_path[0] == 0
                          printf "\"\""
                  else
                          printf "%s", $sun->sun_path
                  end
          end
  end
  
  define showifmultiaddrs
     set $ifp = (struct ifnet *)$arg0
     set $if_multi = (struct ifmultiaddr *)$ifp->if_multiaddrs->lh_first
     set $mymulti = $if_multi
     set $myi = 0
     while ($mymulti != 0)
          printf "%2d. %p ", $myi, $mymulti
          set $sa_family = $mymulti->ifma_addr.sa_family
          if ($sa_family == 2)
              if ($mymulti->ifma_ll != 0)
                  showsockaddr_dl $mymulti->ifma_ll->ifma_addr
                  printf " "
              end
              showsockaddr_in $mymulti->ifma_addr
          end
          if ($sa_family == 30)
              if ($mymulti->ifma_ll != 0)
                  showsockaddr_dl $mymulti->ifma_ll->ifma_addr
                  printf " "
              end
              showsockaddr_in6 $mymulti->ifma_addr
          end
          if ($sa_family == 18)
              showsockaddr_dl $mymulti->ifma_addr
          end
          if ($sa_family == 0)
              showsockaddr_unspec $mymulti->ifma_addr 6
          end
          printf " [%d]", $mymulti->ifma_refcount
          printf "\n"
          set $mymulti = $mymulti->ifma_link.le_next
          set $myi = $myi + 1
     end
  end
  
  document showifmultiaddrs
  Syntax showifmultiaddrs <ifp>
  | show the (struct ifnet).if_multiaddrs list of multicast addresses for the given ifp
  end
  
  define showinmultiaddrs
     set $in_multi = (struct in_multi *)(in_multihead->lh_first)
     set $mymulti = $in_multi
     set $myi = 0
     while ($mymulti != 0)
          set $ifp = (struct ifnet *)$mymulti->inm_ifp
          printf "%2d. %p ", $myi, $mymulti
          show_in_addr &($mymulti->inm_addr)
          printf " (ifp %p [%s%d] ifma %p) ", $ifp, $ifp->if_name, \
              $ifp->if_unit, $mymulti->inm_ifma
          printf "\n"
          set $mymulti = $mymulti->inm_link.le_next
          set $myi = $myi + 1
     end
  end
  
  document showinmultiaddrs
  Syntax showinmultiaddrs
  | show the contents of IPv4 multicast address records
  end
  
  define showin6multiaddrs
     set $in6_multi = (struct in6_multi *)(in6_multihead->lh_first)
     set $mymulti = $in6_multi
     set $myi = 0
     while ($mymulti != 0)
          set $ifp = (struct ifnet *)$mymulti->in6m_ifp
          printf "%2d. %p ", $myi, $mymulti
          show_in6_addr &($mymulti->in6m_addr)
          printf " (ifp %p [%s%d] ifma %p) ", $ifp, $ifp->if_name, \
              $ifp->if_unit, $mymulti->in6m_ifma
          printf "\n"
          set $mymulti = $mymulti->in6m_entry.le_next
          set $myi = $myi + 1
     end
  end
  
  document showin6multiaddrs
  Syntax showin6multiaddrs
  | show the contents of IPv6 multicast address records
  end
  
  define showsockaddr
      set $mysock = (struct sockaddr *)$arg0
      set $showsockaddr_handled = 0
      if ($mysock == 0)
          printf "(null)"
      else
          if ($mysock->sa_family == 0)
                  printf "UNSPC"
              showsockaddr_unspec $mysock
              set $showsockaddr_handled = 1
          end
          if ($mysock->sa_family == 1)
                  printf "UNIX "
              showsockaddr_un $mysock
              set $showsockaddr_handled = 1
          end
          if ($mysock->sa_family == 2)
                  printf "INET "
              showsockaddr_in $mysock
              set $showsockaddr_handled = 1
          end
          if ($mysock->sa_family == 30)
                  printf "INET6 "
              showsockaddr_in6 $mysock
              set $showsockaddr_handled = 1
          end
          if ($mysock->sa_family == 18)
                  printf "LINK "
              showsockaddr_dl $mysock
              set $showsockaddr_handled = 1
          end
          if ($mysock->sa_family == 16)
                  printf "ATLK "
              showsockaddr_at $mysock
              set $showsockaddr_handled = 1
          end
          if ($showsockaddr_handled == 0)
              printf "FAM %d ", $mysock->sa_family
              set $addr = $mysock->sa_data
              set $count = $mysock->sa_len
              printcolonhex $addr $count
          end
      end
  end
  
  define showifflags
          set $flags = (u_short)$arg0
          set $first = 1
          printf "<"
          if ($flags & 0x1)
              printf "UP"
              set $first = 0
          end
          if ($flags & 0x2)
              if ($first == 1)
                  set $first = 0
              else
                  printf ","
              end
              printf "BROADCAST"
          end
          if ($flags & 0x4)
              printf "DEBUG"
          end
          if ($flags & 0x8)
              if ($first == 1)
                  set $first = 0
              else
                  printf ","
              end
              printf "LOOPBACK"
          end
          if ($flags & 0x10)
              if ($first == 1)
                  set $first = 0
              else
                  printf ","
              end
              printf "POINTTOPOINT"
          end
  ##      if ($flags & 0x20)
  ##          if ($first == 1)
  #               set $first = 0
  ##          else
  #               printf ","
  #           end
  #           printf "NOTRAILERS"
  #       end
          if ($flags & 0x40)
              if ($first == 1)
                  set $first = 0
              else
                  printf ","
              end
              printf "RUNNING"
          end
          if ($flags & 0x80)
              if ($first == 1)
                  set $first = 0
              else
                  printf ","
              end
              printf "NOARP"
          end
          if ($flags & 0x100)
              if ($first == 1)
                  set $first = 0
              else
                  printf ","
              end
              printf "PROMISC"
          end
          if ($flags & 0x200)
              if ($first == 1)
                  set $first = 0
              else
                  printf ","
              end
              printf "ALLMULTI"
          end
          if ($flags & 0x400)
              if ($first == 1)
                  set $first = 0
              else
                  printf ","
              end
              printf "OACTIVE"
          end
          if ($flags & 0x800)
              if ($first == 1)
                  set $first = 0
              else
                  printf ","
              end
              printf "SIMPLEX"
          end
          if ($flags & 0x1000)
              if ($first == 1)
                  set $first = 0
              else
                  printf ","
              end
              printf "LINK0"
          end
          if ($flags & 0x2000)
              if ($first == 1)
                  set $first = 0
              else
                  printf ","
              end
              printf "LINK1"
          end
          if ($flags & 0x4000)
              if ($first == 1)
                  set $first = 0
              else
                  printf ","
              end
              printf "LINK2-ALTPHYS"
          end
          if ($flags & 0x8000)
              if ($first == 1)
                  set $first = 0
              else
                  printf ","
              end
              printf "MULTICAST"
          end
          printf ">"
  end
  
  define showifaddrs
     set $ifp = (struct ifnet *)$arg0
     set $myifaddr = (struct ifaddr *)$ifp->if_addrhead->tqh_first
     set $myi = 0
     while ($myifaddr != 0)
          printf "\t%d. %p ", $myi, $myifaddr
          showsockaddr $myifaddr->ifa_addr
          printf " [%d]\n", $myifaddr->ifa_refcnt
          set $myifaddr = $myifaddr->ifa_link->tqe_next
          set $myi = $myi + 1
     end
  end
  
  document showifaddrs
  Syntax: showifaddrs <ifp>
  | show the (struct ifnet).if_addrhead list of addresses for the given ifp
  end
  
  define ifconfig
     set $ifconfig_all = 0
     if ($argc == 1)
          set $ifconfig_all = 1
     end
     set $ifp = (struct ifnet *)(ifnet_head->tqh_first)
     while ($ifp != 0)
          printf "%s%d: flags=%hx", $ifp->if_name, $ifp->if_unit, (u_short)$ifp->if_flags
          showifflags $ifp->if_flags
          printf " index %d", $ifp->if_index
          printf " mtu %d\n", $ifp->if_data.ifi_mtu
          printf "\t(struct ifnet *)"
      showptr $ifp
      printf "\n"
          if ($ifconfig_all == 1) 
             showifaddrs $ifp
      end
          set $ifp = $ifp->if_link->tqe_next
     end
  end
  document ifconfig
  Syntax: (gdb) ifconfig
  | display ifconfig-like output, and print the (struct ifnet *) pointers for further inspection
  end
  
  set $DLIF_INUSE = 0x1
  set $DLIF_REUSE = 0x2
  
  define showifnets
          set $all = 0
          if ($argc == 1)
                  set $all = 1
          end
          set $dlifp = (struct dlil_ifnet *)(dlil_ifnet_head->tqh_first)
          while ($dlifp != 0)
                  set $ifp = (struct ifnet *)$dlifp
                  if ($dlifp->dl_if_flags & $DLIF_REUSE)
                          printf "*"
                  end
                  if ($dlifp->dl_if_flags & $DLIF_INUSE)
                          printf "%s%d: ", $ifp->if_name, $ifp->if_unit
                  else
                          printf "[%s%d]: ", $ifp->if_name, $ifp->if_unit
                  end
                  printf "flags=%hx", (u_short)$ifp->if_flags
                  showifflags $ifp->if_flags
                  printf " index %d", $ifp->if_index
                  printf " mtu %d\n", $ifp->if_data.ifi_mtu
                  printf "\t(struct ifnet *)"
                  showptr $ifp
                  printf "\n"
                  if ($all == 1) 
                          showifaddrs $ifp
                  end
                  set $dlifp = $dlifp->dl_if_link->tqe_next
          end
  end
  
  document showifnets
  Syntax: (gdb) showifnets
  | Display ifconfig-like output for all attached and detached interfaces
  end
  
  define _show_unix_domain_socket
          set $so = (struct socket *)$arg0
          set $pcb = (struct unpcb *)$so->so_pcb
          if $pcb == 0
                  printf "unpcb: (null) "
          else
                  printf "unpcb: %p ", $pcb
                  printf "unp_vnode: %p ", $pcb->unp_vnode
                  printf "unp_conn: %p ", $pcb->unp_conn
                  printf "unp_addr: "
                  showsockaddr_un $pcb->unp_addr
          end
  end
  
  define _show_in_port
          set $str = (unsigned char *)$arg0
          set $port = *(unsigned short *)$arg0
          
          if (((($port & 0xff00) >> 8) == $str[0])) && ((($port & 0x00ff) == $str[1]))
                  #printf "big endian "
                  printf ":%d ", $port
          else
                  #printf "little endian "
                  printf ":%d ", (($port & 0xff00) >> 8) | (($port & 0x00ff) << 8)
          end
  end
  
  define _show_in_addr_4in6
          set $ia = (unsigned char *)$arg0
          if $ia
              printf "%3u.%03u.%03u.%03u", $ia[0], $ia[1], $ia[2], $ia[3]
          end
  end
  
  define _show_in6_addr
          set $ia = (unsigned char *)$arg0
          if $ia
                  printf "%2x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x", \
                          $ia[0], $ia[1], $ia[2], $ia[3], $ia[4], $ia[5], $ia[6], $ia[7], \
                          $ia[8], $ia[9], $ia[10], $ia[11], $ia[12], $ia[13], $ia[14], $ia[15]
          end
  end
  
  define _showtcpstate
          set $tp = (struct tcpcb *)$arg0
          if $tp
                  if $tp->t_state == 0
                          printf "CLOSED      "
                  end
                  if $tp->t_state == 1
                          printf "LISTEN      "
                  end
                  if $tp->t_state == 2
                          printf "SYN_SENT    "
                  end
                  if $tp->t_state == 3
                          printf "SYN_RCVD    "
                  end
                  if $tp->t_state == 4
                          printf "ESTABLISHED "
                  end
                  if $tp->t_state == 5
                          printf "CLOSE_WAIT   "
                  end
                  if $tp->t_state == 6
                          printf "FIN_WAIT_1   "
                  end
                  if $tp->t_state == 7
                          printf "CLOSING      "
                  end
                  if $tp->t_state == 8
                          printf "LAST_ACK     "
                  end
                  if $tp->t_state == 9
                          printf "FIN_WAIT_2   "
                  end
                  if $tp->t_state == 10
                          printf "TIME_WAIT    "
                  end
          end
  end
  
  define _showsockprotocol
          set $so = (struct socket *)$arg0
          set $inpcb = (struct inpcb *)$so->so_pcb
  
          if $so->so_proto->pr_protocol == 6
                  printf "TCP "
                  _showtcpstate $inpcb->inp_ppcb
          end
          if $so->so_proto->pr_protocol == 17
                  printf "UDP "
          end
          if $so->so_proto->pr_protocol == 1
                  printf "ICMP "
          end
          if $so->so_proto->pr_protocol == 254
                  printf "DIVERT "
          end
          if $so->so_proto->pr_protocol == 255
                  printf "RAW "
          end
  end
  
  define _show_ipv4_socket
          set $so = (struct socket *)$arg0
          set $inpcb = (struct inpcb *)$so->so_pcb
          if $inpcb == 0
                  printf "inpcb: (null) "
          else
                  printf "inpcb: %p ", $inpcb
                  
                  _showsockprotocol $so
  
                  _show_in_addr_4in6  &$inpcb->inp_dependladdr.inp46_local
                  _show_in_port  &$inpcb->inp_lport
                  printf "-> "
                  _show_in_addr_4in6  &$inpcb->inp_dependfaddr.inp46_foreign
                  _show_in_port &$inpcb->inp_fport
          end
  end
  
  define _show_ipv6_socket
          set $so = (struct socket *)$arg0
          set $pcb = (struct inpcb *)$so->so_pcb
          if $pcb == 0
                  printf "inpcb: (null) "
          else
                  printf "inpcb: %p ", $pcb
  
                  _showsockprotocol $so
  
                  _show_in6_addr  &$pcb->inp_dependladdr.inp6_local
                  _show_in_port  &$pcb->inp_lport
                  printf "-> "
                  _show_in6_addr  &$pcb->inp_dependfaddr.inp6_foreign
                  _show_in_port &$pcb->inp_fport
          end
  end
  
  
  define showsocket
          set $so = (struct socket *)$arg0
          if $so == 0
                  printf "so: (null) "
          else
                  printf "so: %p ", $so
                  if $so && $so->so_proto && $so->so_proto->pr_domain
                          set $domain = (struct  domain *) $so->so_proto->pr_domain
  
                          printf "%s ", $domain->dom_name
                          if  $domain->dom_family == 1
                                  _show_unix_domain_socket $so
                          end
                          if  $domain->dom_family == 2
                                  _show_ipv4_socket $so
                          end
                          if  $domain->dom_family == 30
                                  _show_ipv6_socket $so
                          end
                  end
          end
          printf "\n"
  end
  document showsocket
  Syntax: (gdb) showsocket <socket_address>
  | Routine to print out a socket
  end
  
  define showprocsockets
          set $pp = (struct proc *)$arg0
          set $fdp = (struct filedesc *)$pp->p_fd
  
          set $count = 0
          set $fpp =  (struct fileproc **)($fdp->fd_ofiles)
          set $fpo =  (char)($fdp->fd_ofileflags[0])
          while $count < $fdp->fd_nfiles
                  if *$fpp
                          set $fg =(struct fileglob *)((**$fpp)->f_fglob)
                          if  $fg && (($fg)->fg_type == 2) 
                                  if $fdp->fd_ofileflags[$count] & 4
                                          printf "U: "
                                  else
                                          printf " "
                                  end
                                  printf "fd = %d ", $count
                                  if  $fg->fg_data
                                          showsocket  $fg->fg_data
                                  else
                                          printf "\n"
                                  end
                          end
                  end
                  set $fpp = $fpp + 1
                  set $count = $count + 1         
          end
  end
  document showprocsockets
  Syntax: (gdb) showprocsockets <proc_address>
  | Routine to print out all the open fds
  | which are sockets in a process
  end
  
  define showallprocsockets
    set $basep = (struct proc  *)allproc->lh_first
    set $pp = $basep
    while $pp
          printf "============================================ \n"
          showproc $pp
          showprocsockets $pp
          set $pp = $pp->p_list.le_next
    end
  end
  document showallprocsockets
  Syntax: (gdb) showallprocsockets
  | Routine to print out all the open fds
  | which are sockets 
  end
  
  define _print_ntohs
          set $port = (unsigned short)$arg0
          set $port = (unsigned short)((($arg0 & 0xff00) >> 8) & 0xff)
          set $port |= (unsigned short)(($arg0 & 0xff) << 8)
          printf "%5d", $port
  end
  
  set $INPCB_STATE_INUSE=0x1
  set $INPCB_STATE_CACHED=0x2
  set $INPCB_STATE_DEAD=0x3
  
  set $INP_RECVOPTS=0x01
  set $INP_RECVRETOPTS=0x02
  set $INP_RECVDSTADDR=0x04
  set $INP_HDRINCL=0x08
  set $INP_HIGHPORT=0x10
  set $INP_LOWPORT=0x20
  set $INP_ANONPORT=0x40
  set $INP_RECVIF=0x80
  set $INP_MTUDISC=0x100
  set $INP_STRIPHDR=0x200
  set $INP_FAITH=0x400
  set $INP_INADDR_ANY=0x800
  set $INP_RECVTTL=0x1000
  set $INP_UDP_NOCKSUM=0x2000
  set $IN6P_IPV6_V6ONLY=0x008000
  set $IN6P_PKTINFO=0x010000
  set $IN6P_HOPLIMIT=0x020000
  set $IN6P_HOPOPTS=0x040000
  set $IN6P_DSTOPTS=0x080000
  set $IN6P_RTHDR=0x100000
  set $IN6P_RTHDRDSTOPTS=0x200000
  set $IN6P_AUTOFLOWLABEL=0x800000
  set $IN6P_BINDV6ONLY=0x10000000
  
  set $INP_IPV4=0x1
  set $INP_IPV6=0x2
  
  set $IPPROTO_TCP=6
  set $IPPROTO_UDP=17
  
  define _dump_inpcb
          set $pcb = (struct inpcb *)$arg0
          if $kgm_lp64
                  printf "%18p", $pcb
          else
                  printf "%10p ", $pcb
          end
          if $arg1 == $IPPROTO_TCP
                  printf "tcp"
          else
                  if $arg1 == $IPPROTO_UDP
                          printf "udp"
                  else
                          printf "%2d.", $arg1
                  end
          end
          if ($pcb->inp_vflag & $INP_IPV4)
                  printf "4 "
          end
          if ($pcb->inp_vflag & $INP_IPV6)
                  printf "6 "
          end
  
          if ($pcb->inp_vflag & $INP_IPV4)
                  printf "                        "
                  _show_in_addr &$pcb->inp_dependladdr.inp46_local.ia46_addr4
          else
                  _show_in6_addr &$pcb->inp_dependladdr.inp6_local
          end
          printf " "
          _print_ntohs $pcb->inp_lport
          printf " "
          if ($pcb->inp_vflag & $INP_IPV4)
                  printf "                        "
                  _show_in_addr &($pcb->inp_dependfaddr.inp46_foreign.ia46_addr4)
          else
                  _show_in6_addr &($pcb->inp_dependfaddr.inp6_foreign)
          end
          printf " "
          _print_ntohs $pcb->inp_fport
          printf " "
  
          if $arg1 == $IPPROTO_TCP
                  _showtcpstate $pcb->inp_ppcb
          end
  
  #       printf "phd "
  #       set $phd = $pcb->inp_phd
  #       while $phd != 0
  #               printf " "
  #               _print_ntohs $phd->phd_port
  #               set $phd = $phd->phd_hash.le_next
  #       end
  #       printf ", "
          if ($pcb->inp_flags & $INP_RECVOPTS)
                  printf "recvopts "
          end
          if ($pcb->inp_flags & $INP_RECVRETOPTS)
                  printf "recvretopts "
          end
          if ($pcb->inp_flags & $INP_RECVDSTADDR)
                  printf "recvdstaddr "
          end
          if ($pcb->inp_flags & $INP_HDRINCL)
                  printf "hdrincl "
          end
          if ($pcb->inp_flags & $INP_HIGHPORT)
                  printf "highport "
          end
          if ($pcb->inp_flags & $INP_LOWPORT)
                  printf "lowport "
          end
          if ($pcb->inp_flags & $INP_ANONPORT)
                  printf "anonport "
          end
          if ($pcb->inp_flags & $INP_RECVIF)
                  printf "recvif "
          end
          if ($pcb->inp_flags & $INP_MTUDISC)
                  printf "mtudisc "
          end
          if ($pcb->inp_flags & $INP_STRIPHDR)
                  printf "striphdr "
          end
          if ($pcb->inp_flags & $INP_FAITH)
                  printf "faith "
          end
          if ($pcb->inp_flags & $INP_INADDR_ANY)
                  printf "inaddr_any "
          end
          if ($pcb->inp_flags & $INP_RECVTTL)
                  printf "recvttl "
          end
          if ($pcb->inp_flags & $INP_UDP_NOCKSUM)
                  printf "nocksum "
          end
          if ($pcb->inp_flags & $IN6P_IPV6_V6ONLY)
                  printf "v6only "
          end
          if ($pcb->inp_flags & $IN6P_PKTINFO)
                  printf "pktinfo "
          end
          if ($pcb->inp_flags & $IN6P_HOPLIMIT)
                  printf "hoplimit "
          end
          if ($pcb->inp_flags & $IN6P_HOPOPTS)
                  printf "hopopts "
          end
          if ($pcb->inp_flags & $IN6P_DSTOPTS)
                  printf "dstopts "
          end
          if ($pcb->inp_flags & $IN6P_RTHDR)
                  printf "rthdr "
          end
          if ($pcb->inp_flags & $IN6P_RTHDRDSTOPTS)
                  printf "rthdrdstopts "
          end
          if ($pcb->inp_flags & $IN6P_AUTOFLOWLABEL)
                  printf "autoflowlabel "
          end
          if ($pcb->inp_flags & $IN6P_BINDV6ONLY)
                  printf "bindv6only "
          end
          set $so = (struct socket *)$pcb->inp_socket
          if $so != 0
                  printf "[so=%p s=%ld r=%ld usecnt=%ld] ", $so, $so->so_snd.sb_cc, \
                      $so->so_rcv.sb_cc, $so->so_usecount
          end
          if ($pcb->inp_state == 0 || $pcb->inp_state == $INPCB_STATE_INUSE)
                  printf "inuse, "
          else
                  if ($pcb->inp_state == $INPCB_STATE_CACHED)
                          printf "cached, "
                  else
                          if ($pcb->inp_state == $INPCB_STATE_DEAD)
                                  printf "dead, "
                          else
                                  printf "unknown (%d), ", $pcb->inp_state
                          end
                  end
          end
  end
  
  define _dump_inpcbport
          set $ppcb = (struct inpcbport *)$arg0
          printf "%p: lport ", $ppcb
          _print_ntohs $ppcb->phd_port
  end
  
  set $UDBHASHSIZE=16
  
  define _dump_pcbinfo
          set $snd_cc = 0
          set $snd_buf = (unsigned int)0
          set $rcv_cc = 0
          set $rcv_buf = (unsigned int)0
          set $pcbseen = 0
          set $pcbi = (struct inpcbinfo *)$arg0
          printf "lastport %d lastlow %d lasthi %d\n", \
              $pcbi->lastport, $pcbi->lastlow, $pcbi->lasthi
          printf "active pcb count is %d\n", $pcbi->ipi_count
          set $hashsize = $pcbi->hashmask + 1
          printf "hash size is %d\n", $hashsize
          printf "hash base %p has the following inpcb(s):\n", $pcbi->hashbase
          if $kgm_lp64
                  printf "pcb                prot source                          address port  destination                     address port\n"
                  printf "------------------ ---- --------------------------------------- ----- --------------------------------------- -----\n"
          else
                  printf "pcb        prot source                          address port  destination                     address port\n"
                  printf "---------- ---- --------------------------------------- ----- --------------------------------------- -----\n"
          end
          set $i = 0
          set $hashbase = $pcbi->hashbase
          set $head = *(uintptr_t *)$hashbase
          while $i < $hashsize
                  if $head != 0
                          set $pcb0 = (struct inpcb *)$head
                          while $pcb0  != 0
                                  set $pcbseen += 1
                                  _dump_inpcb $pcb0 $arg1
                                  set $so = (struct socket *)$pcb->inp_socket
                                  if $so != 0
                                          set $snd_cc += $so->so_snd.sb_cc
                                          set $mp = $so->so_snd.sb_mb
                                          while $mp
                                                  set $snd_buf += 256
                                                  if ($mp->m_hdr.mh_flags & 0x01)
                                                          set $snd_buf += $mp->M_dat.MH.MH_dat.MH_ext.ext_size
                                                  end
                                                  set $mp = $mp->m_hdr.mh_next
                                          end
                                          set $rcv_cc += $so->so_rcv.sb_cc
                                          set $mp = $so->so_rcv.sb_mb
                                          while $mp
                                                  set $rcv_buf += 256
                                                  if ($mp->m_hdr.mh_flags & 0x01)
                                                          set $rcv_buf += $mp->M_dat.MH.MH_dat.MH_ext.ext_size
                                                  end
                                                  set $mp = $mp->m_hdr.mh_next
                                          end
                                  end
                                  set $pcb0 = $pcb0->inp_hash.le_next
                                  printf "\n"
                          end
                  end
                  set $i += 1
                  set $hashbase += 1
                  set $head = *(uintptr_t *)$hashbase
          end
          printf "total seen %ld snd_cc %ld rcv_cc %ld\n", $pcbseen, $snd_cc, $rcv_cc
          printf "total snd_buf %u rcv_buf %u \n", (unsigned int)$snd_buf, (unsigned int)$rcv_buf
          printf "port hash base is %p\n", $pcbi->porthashbase
          set $i = 0
          set $hashbase = $pcbi->porthashbase
          set $head = *(uintptr_t *)$hashbase
          while $i < $hashsize
                  if $head != 0
                          set $pcb0 = (struct inpcbport *)$head
                          while $pcb0  != 0
                                  printf "\t"
                                  _dump_inpcbport $pcb0
                                  printf "\n"
                                  set $pcb0 = $pcb0->phd_hash.le_next
                          end
                  end
                  set $i += 1
                  set $hashbase += 1
                  set $head = *(uintptr_t *)$hashbase
          end
  end
  
  set $N_TIME_WAIT_SLOTS=128
  
  define show_tcp_timewaitslots
          set $slot = -1
          set $all = 0
          if $argc == 1
                  if (int)$arg0 == -1
                          set $all = 1
                  else
                          set $slot = (int)$arg0
                  end
          end
          printf "time wait slot size %d cur_tw_slot %ld\n", $N_TIME_WAIT_SLOTS, cur_tw_slot
          set $i = 0
          while $i < $N_TIME_WAIT_SLOTS
                  set $perslot = 0
                  set $head = (uintptr_t *)time_wait_slots[$i]
                  if $i == $slot || $slot == -1
                          if $head != 0
                                  set $pcb0 = (struct inpcb *)$head
                                  while $pcb0  != 0
                                          set $perslot += 1
                                          set $pcb0 = $pcb0->inp_list.le_next
                                  end
                          end
                          printf "  slot %ld count %ld\n", $i, $perslot
                  end
                  if $all ||  $i == $slot
                          if $head != 0
                                  set $pcb0 = (struct inpcb *)$head
                                  while $pcb0  != 0
                                          printf "\t"
                                          _dump_inpcb $pcb0 $IPPROTO_TCP
                                          printf "\n"
                                          set $pcb0 = $pcb0->inp_list.le_next
                                  end
                          end
                  end
                  set $i += 1
          end
  end
  document show_tcp_timewaitslots
  Syntax: (gdb) show_tcp_timewaitslots
  | Print the list of TCP protocol control block in the TIMEWAIT state
  | Pass -1 to see the list of PCB for each slot
  | Pass a slot number to see information for that slot with the list of PCB
  end
  
  define show_tcp_pcbinfo
          _dump_pcbinfo &tcbinfo $IPPROTO_TCP
  end
  document show_tcp_pcbinfo
  Syntax: (gdb) show_tcp_pcbinfo
  | Print the list of TCP protocol control block information
  end
  
  
  define show_udp_pcbinfo
          _dump_pcbinfo &udbinfo $IPPROTO_UDP
  end
  document show_udp_pcbinfo
  Syntax: (gdb) show_udp_pcbinfo
  | Print the list of UDP protocol control block information
  end
  
  define showbpfdtab
      set $myi = 0
      while ($myi < bpf_dtab_size)
          if (bpf_dtab[$myi] != 0)
                  printf "Address 0x%x, bd_next 0x%x\n", bpf_dtab[$myi], bpf_dtab[$myi]->bd_next
                  print *bpf_dtab[$myi]
          end
          set $myi = $myi + 1
      end
  end
  
  define printvnodepathint_recur
          if $arg0 != 0
                  if ($arg0->v_flag & 0x000001) && ($arg0->v_mount != 0)
                          if $arg0->v_mount->mnt_vnodecovered != 0
                                  printvnodepathint_recur  $arg0->v_mount->mnt_vnodecovered $arg0->v_mount->mnt_vnodecovered->v_name
                          end
                  else
                          printvnodepathint_recur $arg0->v_parent $arg0->v_parent->v_name
                          printf "/%s", $arg1
                  end
          end
  end
  
  define showvnodepath
          set $vp = (struct vnode *)$arg0
          if $vp != 0
                  if ($vp->v_flag & 0x000001) && ($vp->v_mount != 0) && ($vp->v_mount->mnt_flag & 0x00004000)
                          printf "/"
                  else
                          printvnodepathint_recur $vp $vp->v_name
                  end
          end
          printf "\n"
  end
  
  document showvnodepath
  Syntax: (gdb) showvnodepath <vnode>
  | Prints the path for a vnode
  end
  
  define showallvols
          printf "volume    "
      showptrhdrpad
      printf "  mnt_data  "
      showptrhdrpad
      printf "  mnt_devvp "
      showptrhdrpad
      printf "  typename    mountpoint\n"
          set $kgm_vol = (mount_t) mountlist.tqh_first
          while $kgm_vol
          showptr $kgm_vol
          printf "  "
          showptr $kgm_vol->mnt_data
          printf "  "
          showptr $kgm_vol->mnt_devvp
          printf "  "
                  if  ($kgm_vol->mnt_vtable->vfc_name[0] == 'h') && \
                      ($kgm_vol->mnt_vtable->vfc_name[1] == 'f') && \
                      ($kgm_vol->mnt_vtable->vfc_name[2] == 's') && \
                      ($kgm_vol->mnt_vtable->vfc_name[3] == '\0')
                          set $kgm_hfsmount = \
                              (struct hfsmount *) $kgm_vol->mnt_data
                          if $kgm_hfsmount->hfs_freezing_proc != 0
                                  printf "FROZEN hfs  "
                          else
                                  printf "hfs         "
                          end
                  else
                          printf "%-10s  ", $kgm_vol->mnt_vtable->vfc_name
                  end
                  printf "%s\n", $kgm_vol->mnt_vfsstat.f_mntonname
                  
                  set $kgm_vol = (mount_t) $kgm_vol->mnt_list.tqe_next
          end
  end
  
  document showallvols
  Syntax: (gdb) showallvols
  | Display a summary of mounted volumes
  end
  
  define showvnodeheader
          printf "vnode     "
      showptrhdrpad
      printf "  usecount  iocount  v_data    "
      showptrhdrpad
      printf "  vtype  parent    "
      showptrhdrpad    
      printf "  name\n"
  end
  
  define showvnodeint
          set $kgm_vnode = (vnode_t) $arg0
          showptr $kgm_vnode
          printf "  %8d  ", $kgm_vnode->v_usecount
          printf "%7d  ", $kgm_vnode->v_iocount
  # print information about clean/dirty blocks?
          showptr $kgm_vnode->v_data
      printf "  "
          # print the vtype, using the enum tag
          set $kgm_vtype = $kgm_vnode->v_type
          if $kgm_vtype == VNON
                  printf "VNON   "
          end
          if $kgm_vtype == VREG
                  printf "VREG   "
          end
          if $kgm_vtype == VDIR
                  printf "VDIR   "
          end
          if $kgm_vtype == VBLK
                  printf "VBLK   "
          end
          if $kgm_vtype == VCHR
                  printf "VCHR   "
          end
          if $kgm_vtype == VLNK
                  printf "VLNK   "
          end
          if $kgm_vtype == VSOCK
                  printf "VSOCK  "
          end
          if $kgm_vtype == VFIFO
                  printf "VFIFO  "
          end
          if $kgm_vtype == VBAD
                  printf "VBAD   "
          end
          if ($kgm_vtype < VNON) || ($kgm_vtype > VBAD)
                  printf "%5d  ", $kgm_vtype
          end
  
          showptr $kgm_vnode->v_parent
      printf "  "
          if ($kgm_vnode->v_name != 0)
                  printf "%s\n", $kgm_vnode->v_name
          else 
                  # If this is HFS vnode, get name from the cnode
                  if ($kgm_vnode->v_tag == 16) 
                          set $kgm_cnode = (struct cnode *)$kgm_vnode->v_data
                          printf "hfs: %s\n", (char *)$kgm_cnode->c_desc->cd_nameptr
                  else 
                          printf "\n"
                  end
          end
  end
  
  define showvnode
          showvnodeheader
          showvnodeint $arg0
  end
  
  document showvnode
  Syntax: (gdb) showvnode <vnode>
  | Display info about one vnode
  end
  
  define showvolvnodes
          showvnodeheader
          set $kgm_vol = (mount_t) $arg0
          set $kgm_vnode = (vnode_t) $kgm_vol.mnt_vnodelist.tqh_first
          while $kgm_vnode
                  showvnodeint $kgm_vnode
                  set $kgm_vnode = (vnode_t) $kgm_vnode->v_mntvnodes.tqe_next
          end
  end
  
  document showvolvnodes
  Syntax: (gdb) showvolvnodes <mouont_t>
  | Display info about all vnodes of a given mount_t
  end
  
  define showvolbusyvnodes
          showvnodeheader
          set $kgm_vol = (mount_t) $arg0
          set $kgm_vnode = (vnode_t) $kgm_vol.mnt_vnodelist.tqh_first
          while $kgm_vnode
                  if $kgm_vnode->v_iocount != 0
                          showvnodeint $kgm_vnode
                  end
                  set $kgm_vnode = (vnode_t) $kgm_vnode->v_mntvnodes.tqe_next
          end
  end
  
  document showvolbusyvnodes
  Syntax: (gdb) showvolbusyvnodes <mount_t>
  | Display info about busy (iocount!=0) vnodes of a given mount_t
  end
  
  define showallbusyvnodes
          showvnodeheader
          set $kgm_vol = (mount_t) mountlist.tqh_first
          while $kgm_vol
                  set $kgm_vnode = (vnode_t) $kgm_vol.mnt_vnodelist.tqh_first
                  while $kgm_vnode
                          if $kgm_vnode->v_iocount != 0
                                  showvnodeint $kgm_vnode
                          end
                          set $kgm_vnode = (vnode_t) $kgm_vnode->v_mntvnodes.tqe_next
                  end
                  set $kgm_vol = (mount_t) $kgm_vol->mnt_list.tqe_next
          end
  end
  
  document showallbusyvnodes
  Syntax: (gdb) showallbusyvnodes <vnode>
  | Display info about all busy (iocount!=0) vnodes
  end
  
  define showallvnodes
          showvnodeheader
          set $kgm_vol = (mount_t) mountlist.tqh_first
          while $kgm_vol
                  set $kgm_vnode = (vnode_t) $kgm_vol.mnt_vnodelist.tqh_first
                  while $kgm_vnode
                          showvnodeint $kgm_vnode
                          set $kgm_vnode = (vnode_t) $kgm_vnode->v_mntvnodes.tqe_next
                  end
                  set $kgm_vol = (mount_t) $kgm_vol->mnt_list.tqe_next
          end
  end
  
  document showallvnodes
  Syntax: (gdb) showallvnodes
  | Display info about all vnodes
  end
  
  define _showvnodelockheader
      printf "*  type   W  held by        lock type  start               end\n"
      printf "-  -----  -  -------------  ---------  ------------------  ------------------\n"
  end
  
  define _showvnodelock
      set $kgm_svl_lock = ((struct lockf *)$arg0)
  
      # decode flags
      set $kgm_svl_flags = $kgm_svl_lock->lf_flags
      set $kgm_svl_type = $kgm_svl_lock->lf_type
      if ($kgm_svl_flags & 0x20)
          printf "flock"
      end
      if ($kgm_svl_flags & 0x40)
          printf "posix"
      end
      if ($kgm_svl_flags & 0x80)
          printf "prov "
      end
      if ($kgm_svl_flags & 0x10)
          printf "  W  "
      else
          printf "  .  "
      end
  
      # POSIX file vs. advisory range locks
      if ($kgm_svl_flags & 0x40)
          set $kgm_svl_proc = (proc_t)$kgm_svl_lock->lf_id
          printf "PID %8d   ", $kgm_svl_proc->p_pid
      else
          printf "ID 0x%08x  ", $kgm_svl_lock->lf_id
      end
  
      # lock type
      if ($kgm_svl_type == 1)
                  printf "shared     "
      else
          if ($kgm_svl_type == 3)
                  printf "exclusive  "
          else
              if ($kgm_svl_type == 2)
                  printf "unlock     "
              else
                  printf "unknown    "
              end
          end
      end
  
      # start and stop
      printf "0x%016x..", $kgm_svl_lock->lf_start
      printf "0x%016x  ", $kgm_svl_lock->lf_end
      printf "\n"
  end
  # Body of showvnodelocks, not including header
  define _showvnodelocks
      set $kgm_svl_vnode = ((vnode_t)$arg0)
      set $kgm_svl_lockiter = $kgm_svl_vnode->v_lockf
      while ($kgm_svl_lockiter != 0)
          # locks that are held
          printf "H  "
          _showvnodelock $kgm_svl_lockiter
  
          # and any locks blocked by them
          set $kgm_svl_blocker = $kgm_svl_lockiter->lf_blkhd.tqh_first
          while ($kgm_svl_blocker != 0)
              printf ">  "
              _showvnodelock $kgm_svl_blocker
              set $kgm_svl_blocker = $kgm_svl_blocker->lf_block.tqe_next
          end
  
          # and on to the next one...
          set $kgm_svl_lockiter = $kgm_svl_lockiter->lf_next
      end
  end
  
  
  define showvnodelocks
      if ($argc == 1)
          _showvnodelockheader
          _showvnodelocks $arg0
      else
          printf "| Usage:\n|\n"
          help showvnodelocks
      end
  end
  
  document showvnodelocks
  Syntax: (gdb) showvnodelocks <vnode_t>
  | Given a vnodet pointer, display the list of advisory record locks for the
  | referenced pvnodes
  end
  
  define showbootargs
          printf "%s\n", (char*)((boot_args*)PE_state.bootArgs).CommandLine
  end
  
  document showbootargs
  Syntax: showbootargs
  | Display boot arguments passed to the target kernel
  end
  
  define showbootermemorymap
          if ($kgm_mtype == $kgm_mtype_i386)
              set $kgm_voffset = 0
          else
              if ($kgm_mtype == $kgm_mtype_x86_64)
                  set $kgm_voffset = 0xFFFFFF8000000000ULL
              else
                  echo showbootermemorymap not supported on this architecture
              end
          end
  
          set $kgm_boot_args = kernelBootArgs
          set $kgm_msize = kernelBootArgs->MemoryMapDescriptorSize
          set $kgm_mcount = kernelBootArgs->MemoryMapSize / $kgm_msize
          set $kgm_i = 0
         
          printf "Type       Physical Start   Number of Pages  Virtual Start    Attributes\n"
          while $kgm_i < $kgm_mcount
               set $kgm_mptr = (EfiMemoryRange *)((unsigned long)kernelBootArgs->MemoryMap + $kgm_voffset + $kgm_i * $kgm_msize)
  #            p/x *$kgm_mptr
               if $kgm_mptr->Type == 0
                 printf "Reserved  "
               end
               if $kgm_mptr->Type == 1
                 printf "LoaderCode"
               end
               if $kgm_mptr->Type == 2
                 printf "LoaderData"
               end
               if $kgm_mptr->Type == 3
                 printf "BS_code   "
               end
               if $kgm_mptr->Type == 4
                 printf "BS_data   "
               end
               if $kgm_mptr->Type == 5
                 printf "RT_code   "
               end
               if $kgm_mptr->Type == 6
                 printf "RT_data   "
               end
               if $kgm_mptr->Type == 7
                 printf "Convention"
               end
               if $kgm_mptr->Type == 8
                 printf "Unusable  "
               end
               if $kgm_mptr->Type == 9
                 printf "ACPI_recl "
               end
               if $kgm_mptr->Type == 10
                 printf "ACPI_NVS  "
               end
               if $kgm_mptr->Type == 11
                 printf "MemMapIO  "
               end
               if $kgm_mptr->Type == 12
                 printf "MemPortIO "
               end
               if $kgm_mptr->Type == 13
                 printf "PAL_code  "
               end
               if $kgm_mptr->Type > 13
                 printf "UNKNOWN   "
               end
  
               printf " %016llx %016llx", $kgm_mptr->PhysicalStart, $kgm_mptr->NumberOfPages
               if $kgm_mptr->VirtualStart != 0
                 printf " %016llx", $kgm_mptr->VirtualStart
               else
                 printf "                 "
               end
               printf " %016llx\n", $kgm_mptr->Attribute
               set $kgm_i = $kgm_i + 1
         end
  end
  
  document showbootermemorymap
  Syntax: (gdb) showbootermemorymap
  | Prints out the phys memory map from kernelBootArgs
  end
  
  
  define showstacksaftertask
      set $kgm_head_taskp = &tasks
      set $kgm_taskp = (struct task *)$arg0
      set $kgm_taskp = (struct task *)$kgm_taskp->tasks.next
      while $kgm_taskp != $kgm_head_taskp
          showtaskheader
          showtaskint $kgm_taskp
          set $kgm_head_actp = &($kgm_taskp->threads)
          set $kgm_actp = (struct thread *)($kgm_taskp->threads.next)
          while $kgm_actp != $kgm_head_actp
              showactheader
              if ($decode_wait_events > 0)
                 showactint $kgm_actp 1
              else
                 showactint $kgm_actp 2
              end
              set $kgm_actp = (struct thread *)($kgm_actp->task_threads.next)
          end
          printf "\n"
          set $kgm_taskp = (struct task *)($kgm_taskp->tasks.next)
      end
  end
  document showstacksaftertask
  Syntax: (gdb) showstacksaftertask <task>
  | Routine to print out all stacks (as in showallstacks) starting after a given task
  | Useful if that gdb refuses to print a certain task's stack.
  end
  
  define showpmworkqueueint
      set $kgm_pm_workqueue = (IOPMWorkQueue *)$arg0
      set $kgm_pm_wq = &($kgm_pm_workqueue->fWorkQueue)
      set $kgm_pm_wqe = (IOServicePM *)$kgm_pm_wq->next
      while ((queue_entry_t) $kgm_pm_wqe != (queue_entry_t) $kgm_pm_wq)
          printf "service   "
          showptrhdrpad
          printf "  ps  ms  wr  name\n"
          showptr $kgm_pm_wqe->Owner
          printf "  "
          printf "%02d  ", $kgm_pm_wqe->CurrentPowerState
          printf "%02d  ", $kgm_pm_wqe->MachineState
          printf "%02d  ", $kgm_pm_wqe->WaitReason
          printf "%s\n", $kgm_pm_wqe->Name
          printf "request   "
          showptrhdrpad
          printf "  type  next      "
          showptrhdrpad
          printf "  root      "
          showptrhdrpad
          printf "  work_wait   free_wait\n"
          set $kgm_pm_rq = &($kgm_pm_wqe->RequestHead)
          set $kgm_pm_rqe = (IOPMRequest *)$kgm_pm_rq->next
          while ((queue_entry_t) $kgm_pm_rqe != (queue_entry_t) $kgm_pm_rq)
              showptr $kgm_pm_rqe
              printf "  0x%02x  ", $kgm_pm_rqe->fType
              showptr $kgm_pm_rqe->fRequestNext
              printf "  "
              showptr $kgm_pm_rqe->fRequestRoot
              printf "  0x%08x  0x%08x\n", $kgm_pm_rqe->fWorkWaitCount, $kgm_pm_rqe->fFreeWaitCount
              showptrhdrpad
              printf "            args  "
              showptr $kgm_pm_rqe->fArg0
              printf "  "
              showptr $kgm_pm_rqe->fArg1
              printf "  "
              showptr $kgm_pm_rqe->fArg2
              printf "\n"
              set $kgm_pm_rqe = (IOPMRequest *)$kgm_pm_rqe->fCommandChain.next
          end
          printf "\n"
          set $kgm_pm_wqe = (IOServicePM *)$kgm_pm_wqe->WorkChain.next
      end
  end
  
  define showpmworkqueue
      printf "IOPMWorkQueue "
      showptr gIOPMWorkQueue
      printf " length "
      printf "%u", gIOPMWorkQueue->fQueueLength
      printf "\n"
      if (gIOPMWorkQueue->fQueueLength > 0)
          showpmworkqueueint gIOPMWorkQueue
      end
  end
  
  document showpmworkqueue
  Syntax: (gdb) showpmworkqueue
  | Display the IOPMWorkQueue object
  end
  
  define showioservicepm
      set $kgm_iopmpriv = (IOServicePM *)$arg0
      printf "{ "
      printf "MachineState = %d (", $kgm_iopmpriv->MachineState
      if ( $kgm_iopmpriv->MachineState == 0 )
          printf "kIOPM_Finished"
      else
      if ( $kgm_iopmpriv->MachineState == 1 )
          printf "kIOPM_OurChangeTellClientsPowerDown"
      else
      if ( $kgm_iopmpriv->MachineState == 2 )
          printf "kIOPM_OurChangeTellPriorityClientsPowerDown"
      else
      if ( $kgm_iopmpriv->MachineState == 3 )
          printf "kIOPM_OurChangeNotifyInterestedDriversWillChange"
      else
      if ( $kgm_iopmpriv->MachineState == 4 )
          printf "kIOPM_OurChangeSetPowerState"
      else
      if ( $kgm_iopmpriv->MachineState == 5 )
          printf "kIOPM_OurChangeWaitForPowerSettle"
      else
      if ( $kgm_iopmpriv->MachineState == 6 )
          printf "kIOPM_OurChangeNotifyInterestedDriversDidChange"
      else
      if ( $kgm_iopmpriv->MachineState == 7 )
          printf "kIOPM_OurChangeTellCapabilityDidChange"
      else
      if ( $kgm_iopmpriv->MachineState == 8 )
          printf "kIOPM_OurChangeFinish"
      else
      if ( $kgm_iopmpriv->MachineState == 9 )
          printf "Unused_MachineState_9"
      else
      if ( $kgm_iopmpriv->MachineState == 10 )
          printf "kIOPM_ParentChangeTellPriorityClientsPowerDown"
      else
      if ( $kgm_iopmpriv->MachineState == 11 )
          printf "kIOPM_ParentChangeNotifyInterestedDriversWillChange"
      else
      if ( $kgm_iopmpriv->MachineState == 12 )
          printf "kIOPM_ParentChangeSetPowerState"
      else
      if ( $kgm_iopmpriv->MachineState == 13 )
          printf "kIOPM_ParentChangeWaitForPowerSettle"
      else
      if ( $kgm_iopmpriv->MachineState == 14)
          printf "kIOPM_ParentChangeNotifyInterestedDriversDidChange"
      else
      if ( $kgm_iopmpriv->MachineState == 15)
          printf "kIOPM_ParentChangeTellCapabilityDidChange"
      else
      if ( $kgm_iopmpriv->MachineState == 16)
          printf "kIOPM_ParentChangeAcknowledgePowerChange"
      else
      if ( $kgm_iopmpriv->MachineState == 17)
          printf "kIOPM_NotifyChildrenStart"
      else
      if ( $kgm_iopmpriv->MachineState == 18)
          printf "kIOPM_NotifyChildrenOrdered"
      else
      if ( $kgm_iopmpriv->MachineState == 19)
          printf "kIOPM_NotifyChildrenDelayed"
      else
      if ( $kgm_iopmpriv->MachineState == 20)
          printf "kIOPM_SyncTellClientsPowerDown"
      else
      if ( $kgm_iopmpriv->MachineState == 21)
          printf "kIOPM_SyncTellPriorityClientsPowerDown"
      else
      if ( $kgm_iopmpriv->MachineState == 22)
          printf "kIOPM_SyncNotifyWillChange"
      else
      if ( $kgm_iopmpriv->MachineState == 23)
          printf "kIOPM_SyncNotifyDidChange"
      else
      if ( $kgm_iopmpriv->MachineState == 24)
          printf "kIOPM_SyncTellCapabilityDidChange"
      else
      if ( $kgm_iopmpriv->MachineState == 25)
          printf "kIOPM_SyncFinish"
      else
      if ( $kgm_iopmpriv->MachineState == 26)
          printf "kIOPM_TellCapabilityChangeDone"
      else
      if ( $kgm_iopmpriv->MachineState == 27)
          printf "kIOPM_DriverThreadCallDone"
      else
          printf "Unknown_MachineState"
      end
      end
      end
      end
      end
      end
      end
      end
      end
      end
      end
      end
      end
      end
      end
      end
      end
      end
      end
      end
      end
      end
      end
      end
      end
      end
      end
          end
          printf "), "
          
          if ( $kgm_iopmpriv->MachineState != 20 )
          printf "DriverTimer = %d, ",(unsigned int)$kgm_iopmpriv->DriverTimer
          printf "SettleTime  = %d, ",(unsigned int)$kgm_iopmpriv->SettleTimeUS
          printf "HeadNoteFlags = %08x, ",(unsigned int)$kgm_iopmpriv->HeadNoteChangeFlags
          printf "HeadNotePendingAcks = %x, ",(unsigned int)$kgm_iopmpriv->HeadNotePendingAcks
          end
  
      if ( $kgm_iopmpriv->DeviceOverrideEnabled != 0 )
          printf"DeviceOverrides, "
      end
          
      printf "DeviceDesire = %d, ",(unsigned int)$kgm_iopmpriv->DeviceDesire
      printf "DesiredPowerState = %d, ",(unsigned int)$kgm_iopmpriv->DesiredPowerState
      printf "PreviousRequest = %d }\n",(unsigned int)$kgm_iopmpriv->PreviousRequestPowerFlags
  end
  
  document showioservicepm
  Syntax: (gdb) showioservicepm <IOServicePM pointer>
  | Routine to dump the IOServicePM object
  end
  
  define showregistryentryrecursepmstate
      set $kgm_re         = (IOService *)$arg1
      set $kgm$arg0_stack = (unsigned long long) $arg2
  
      if ($arg3)
          set $kgm$arg0_stack = $kgm$arg0_stack | (1ULL << $kgm_reg_depth)
      else
          set $kgm$arg0_stack = $kgm$arg0_stack & ~(1ULL << $kgm_reg_depth)
      end
  
      dictget $kgm_re->fRegistryTable $kgm_childkey
      set $kgm$arg0_child_array = (OSArray *) $kgm_result
  
      if ($kgm$arg0_child_array)
          set $kgm$arg0_child_count = $kgm$arg0_child_array->count
      else
          set $kgm$arg0_child_count = 0
      end
  
      if ($kgm$arg0_child_count)
          set $kgm$arg0_stack = $kgm$arg0_stack | (2ULL << $kgm_reg_depth)
      else
          set $kgm$arg0_stack = $kgm$arg0_stack & ~(2ULL << $kgm_reg_depth)
      end
  
      indent $kgm_reg_depth $kgm$arg0_stack
      printf "+-o "
  
      dictget $kgm_re->fRegistryTable $kgm_namekey
      if ($kgm_result == 0)
          dictget $kgm_re->fRegistryTable gIONameKey
      end
      if ($kgm_result == 0)
          dictget $kgm_re->fPropertyTable gIOClassKey
      end
  
      if ($kgm_result != 0)
          printf "%s <%p>", ((OSString *)$kgm_result)->string, $kgm_re
      else
          if (((IOService*)$kgm_re)->pwrMgt &&  ((IOService*)$kgm_re)->pwrMgt->Name)
              printf "%s <", ((IOService*)$kgm_re)->pwrMgt->Name
              showptr $kgm_re
              printf ">"
          else
              printf "?? <"
              showptr $kgm_re
              printf ">"
          end
      end
  
      if (((IOService*)$kgm_re)->pwrMgt )
          printf " Current Power State: %ld ", ((IOService*)$kgm_re)->pwrMgt->CurrentPowerState
          #printf " Mach State %ld", ((IOService*)$kgm_re)->pwrMgt->MachineState
          showioservicepm ((IOService*)$kgm_re)->pwrMgt
      end
      printf "\n"
     
  
      # recurse
      if ($kgm$arg0_child_count != 0)
  
          set $kgm_reg_depth = $kgm_reg_depth + 1
          set $kgm$arg0_child_idx = 0
  
          while ($kgm$arg0_child_idx < $kgm$arg0_child_count)
              set $kgm_re = $kgm$arg0_child_array->array[$kgm$arg0_child_idx++]
              set $kgm_more_sib = ($kgm$arg0_child_idx < $kgm$arg0_child_count)
              if $kgm_reg_depth >= $kgm_reg_depth_max + 1
                 loop_break
              end
              showregistryentryrecursepmstate _$arg0 $kgm_re $kgm$arg0_stack $kgm_more_sib
          end
  
          set $kgm_reg_depth = $kgm_reg_depth - 1
      end
  end
  
  define showregistryentryintpmstate
      if !$kgm_reg_plane
         set $kgm_reg_plane = (IORegistryPlane *) gIOServicePlane
      end
  
      if !$kgm_reg_plane
         printf "Please load kgmacros after KDP attaching to the target.\n"
      else
         set $kgm_namekey   = (OSSymbol *) $kgm_reg_plane->nameKey
         set $kgm_childkey  = (OSSymbol *) $kgm_reg_plane->keys[1]
         showregistryentryrecursepmstate _ $arg0 0 0
      end
  end
  
  define showregistrypmstate
  #    setregistryplane gIOPowerPlane
      set $kgm_reg_depth  = 0
      set $kgm_show_props = 1
      showregistryentryintpmstate gRegistryRoot
  end
  
  document showregistrypmstate
  Syntax: (gdb) showregistrypmstate
  | Routine to dump the PM state of each IOPower registry entry
  end
  
  define showstacksafterthread
      set $kgm_head_taskp = &tasks
      set $kgm_actp = (struct thread *)$arg0
      set $kgm_actp = (struct thread *)($kgm_actp->task_threads.next)
      set $kgm_taskp = (struct task *)$kgm_actp->task
      while $kgm_taskp != $kgm_head_taskp
          showtaskheader
          showtaskint $kgm_taskp
          set $kgm_head_actp = &($kgm_taskp->threads)
          if $kgm_actp == 0
              set $kgm_actp = (struct thread *)($kgm_taskp->threads.next)
          end
          while $kgm_actp != $kgm_head_actp
              showactheader
              if ($decode_wait_events > 0)
                 showactint $kgm_actp 1
              else
                 showactint $kgm_actp 2
              end
              set $kgm_actp = (struct thread *)($kgm_actp->task_threads.next)
          end
          printf "\n"
          set $kgm_taskp = (struct task *)($kgm_taskp->tasks.next)
          set $kgm_actp = 0
      end
  end
  
  document showstacksafterthread
  Syntax: (gdb) showstacksafterthread <thread>
  | Routine to print out all stacks (as in showallstacks) starting after a given thread
  | Useful if that gdb refuses to print a certain task's stack.
  end
  
  define kdp-reenter
         set kdp_reentry_deadline = ((unsigned) $arg0)*1000
         continue
  end
  
  document kdp-reenter
  Syntax: (gdb) kdp-reenter <seconds>
  | Schedules reentry into the debugger after <seconds> seconds, and resumes
  | the target system.
  end
  
  define _if_present
      if (!$arg0)
          printf " not"
      end
      printf " present"
  end
  
  define showMCAstate
      if (($kgm_mtype & $kgm_mtype_x86_mask) != $kgm_mtype_x86_any)
          printf "Not available for current architecture.\n"
      else
          printf "MCA"
          _if_present mca_MCA_present
          printf ", control MSR"
          _if_present mca_control_MSR_present
          printf ", threshold status"
          _if_present mca_threshold_status_present
          printf "\n%d error banks, ", mca_error_bank_count
          printf "family code 0x%x, ", mca_family
          printf "machine-check dump state: %d\n", mca_dump_state
          set $kgm_cpu = 0
          while cpu_data_ptr[$kgm_cpu] != 0
              set $kgm_mcp = cpu_data_ptr[$kgm_cpu]->cpu_mca_state
              if $kgm_mcp
                  printf "CPU %d:", $kgm_cpu
                  printf " mca_mcg_ctl: 0x%016llx", $kgm_mcp->mca_mcg_ctl
                  printf " mca_mcg_status: 0x%016llx\n", $kgm_mcp->mca_mcg_status.u64
                  printf "bank   "
                  printf "mca_mci_ctl        "
                  printf "mca_mci_status     "
                  printf "mca_mci_addr       "
                  printf "mca_mci_misc\n"
                  set $kgm_bank = 0
                  while $kgm_bank < mca_error_bank_count
                      set $kgm_bp = &$kgm_mcp->mca_error_bank[$kgm_bank]
                      printf " %2d:", $kgm_bank
                      printf " 0x%016llx", $kgm_bp->mca_mci_ctl
                      printf " 0x%016llx", $kgm_bp->mca_mci_status.u64
                      printf " 0x%016llx", $kgm_bp->mca_mci_addr
                      printf " 0x%016llx\n", $kgm_bp->mca_mci_misc
                      set $kgm_bank = $kgm_bank + 1
                  end
              end
              set $kgm_cpu = $kgm_cpu + 1
          end
      end
  end
  
  document showMCAstate
  Syntax: showMCAstate
  | Print machine-check register state after MC exception.
  end
  
  define _pt_step
      #
      # Step to lower-level page table and print attributes
      #   $kgm_pt_paddr: current page table entry physical address
      #   $kgm_pt_index: current page table entry index (0..511)
      # returns
      #   $kgm_pt_paddr: next level page table entry physical address
      #                  or null if invalid
      #   $kgm_pt_valid: 1 if $kgm_pt_paddr is valid, 0 if the walk
      #                  should be aborted
      #   $kgm_pt_large: 1 if kgm_pt_paddr is a page frame address
      #                  of a large page and not another page table entry
      # For $kgm_pt_verbose = 0: print nothing
      #                       1: print basic information
      #                       2: print basic information and hex table dump
      #
      set $kgm_entryp = $kgm_pt_paddr + 8*$kgm_pt_index
      readphysint $kgm_entryp 64 $kgm_lcpu_self
      set $entry = $kgm_readphysint_result
      if $kgm_pt_verbose >= 3
          set $kgm_pte_loop = 0
          while $kgm_pte_loop < 512
              set $kgm_pt_paddr_tmp = $kgm_pt_paddr + $kgm_pte_loop*8
              readphys64 $kgm_pt_paddr_tmp
              set $kgm_pte_loop = $kgm_pte_loop + 1
          end
      end
      set $kgm_paddr_mask = ~((0xfffULL<<52) | 0xfffULL)
      set $kgm_paddr_largemask = ~((0xfffULL<<52) | 0x1fffffULL)
      if $kgm_pt_verbose < 2
          if $entry & (0x1 << 0)
              set $kgm_pt_valid = 1
              if $entry & (0x1 << 7)
                  set $kgm_pt_large = 1
                  set $kgm_pt_paddr = $entry & $kgm_paddr_largemask
              else
                  set $kgm_pt_large = 0
                  set $kgm_pt_paddr = $entry & $kgm_paddr_mask
              end     
          else
              set $kgm_pt_valid = 0
              set $kgm_pt_large = 0
              set $kgm_pt_paddr = 0
          end
      else
          printf "0x%016llx:\n\t0x%016llx\n\t", $kgm_entryp, $entry
          if $entry & (0x1 << 0)
              printf "valid"      
              set $kgm_pt_paddr = $entry & $kgm_paddr_mask
              set $kgm_pt_valid = 1
          else
              printf "invalid"
              set $kgm_pt_paddr = 0
              set $kgm_pt_valid = 0
              # stop decoding other bits
              set $entry = 0
          end
          if $entry & (0x1 << 1)
              printf " writeable" 
          else
              printf " read-only" 
          end
          if $entry & (0x1 << 2)
              printf " user" 
          else
              printf " supervisor" 
          end
          if $entry & (0x1 << 3)
              printf " PWT" 
          end
          if $entry & (0x1 << 4)
              printf " PCD" 
          end
          if $entry & (0x1 << 5)
              printf " accessed" 
          end
          if $entry & (0x1 << 6)
              printf " dirty" 
          end
          if $entry & (0x1 << 7)
              printf " large" 
              set $kgm_pt_large = 1
          else
              set $kgm_pt_large = 0
          end
          if $entry & (0x1 << 8)
              printf " global" 
          end
          if $entry & (0x3 << 9)
              printf " avail:0x%x", ($entry >> 9) & 0x3
          end
          if $entry & (0x1ULL << 63)
              printf " noexec" 
          end
          printf "\n"
      end
  end
  
  define _pml4_walk
      set $kgm_pt_paddr = $arg0
      set $kgm_vaddr = $arg1
      set $kgm_pt_valid = $kgm_pt_paddr != 0
      set $kgm_pt_large = 0
      set $kgm_pframe_offset = 0
      if $kgm_pt_valid && cpu_64bit
          # Look up bits 47:39 of the linear address in PML4T
          set $kgm_pt_index = ($kgm_vaddr >> 39) & 0x1ffULL
          set $kgm_pframe_offset = $kgm_vaddr & 0x7fffffffffULL
          if $kgm_pt_verbose >= 2
              printf "pml4 (index %d):\n", $kgm_pt_index
          end
          _pt_step
      end
      if $kgm_pt_valid
          # Look up bits 38:30 of the linear address in PDPT
          set $kgm_pt_index = ($kgm_vaddr >> 30) & 0x1ffULL
          set $kgm_pframe_offset = $kgm_vaddr & 0x3fffffffULL
          if $kgm_pt_verbose >= 2
              printf "pdpt (index %d):\n", $kgm_pt_index
          end
          _pt_step
      end
      if $kgm_pt_valid && !$kgm_pt_large
          # Look up bits 29:21 of the linear address in PDT
          set $kgm_pt_index = ($kgm_vaddr >> 21) & 0x1ffULL
          set $kgm_pframe_offset = $kgm_vaddr & 0x1fffffULL
          if $kgm_pt_verbose >= 2
              printf "pdt (index %d):\n", $kgm_pt_index
          end
          _pt_step
      end
      if $kgm_pt_valid && !$kgm_pt_large
          # Look up bits 20:21 of the linear address in PT
          set $kgm_pt_index = ($kgm_vaddr >> 12) & 0x1ffULL
          set $kgm_pframe_offset = $kgm_vaddr & 0xfffULL
          if $kgm_pt_verbose >= 2
              printf "pt (index %d):\n", $kgm_pt_index
          end
          _pt_step
      end
  
      if $kgm_pt_valid
          set $kgm_paddr = $kgm_pt_paddr + $kgm_pframe_offset
          set $kgm_paddr_isvalid = 1
      else
          set $kgm_paddr = 0
          set $kgm_paddr_isvalid = 0
      end
  
      if $kgm_pt_verbose >= 1
          if $kgm_paddr_isvalid
              readphysint $kgm_paddr 32 $kgm_lcpu_self
              set $kgm_value = $kgm_readphysint_result
              printf "phys 0x%016llx: 0x%08x\n", $kgm_paddr, $kgm_value
          else
              printf "(no translation)\n"
          end
      end
  end
  
  define _pmap_walk_x86
      set $kgm_pmap = (pmap_t) $arg0
      _pml4_walk $kgm_pmap->pm_cr3 $arg1
  end
  
  define _pmap_walk_arm
      set $kgm_paddr = 0
      set $kgm_paddr_isvalid = 0
  end
  
  define pmap_walk
      if $argc != 2
          printf "pmap_walk <pmap> <vaddr>\n"
      else
          if !$kgm_pt_verbose
              set $kgm_pt_verbose = 2
          else
              if $kgm_pt_verbose > 3
                  set $kgm_pt_verbose = 2
              end
          end
          if (($kgm_mtype & $kgm_mtype_x86_mask) == $kgm_mtype_x86_any)
              _pmap_walk_x86 $arg0 $arg1
          else
              if ($kgm_mtype == $kgm_mtype_arm)
                  _pmap_walk_arm $arg0 $arg1
              else
                  printf "Not available for current architecture.\n"
              end
          end
      end
  end
  
  document pmap_walk
  Syntax: (gdb) pmap_walk <pmap> <virtual_address>
  | Perform a page-table walk in <pmap> for <virtual_address>.
  | Set:
  |     $kgm_pt_verbose=0 for no output, $kgm_paddr will be set
  |                       if $kgm_paddr_isvalid is 1
  |     $kgm_pt_verbose=1 for final physical address
  |     $kgm_pt_verbose=2 for dump of page table entry.
  |     $kgm_pt_verbose=3 for full hex dump of page tables.
  end
  
  define pmap_vtop
      if $argc != 2
          printf "pmap_vtop <pamp> <vaddr>\n"
      else
          set $kgm_pt_verbose = 1
          if (($kgm_mtype & $kgm_mtype_x86_mask) == $kgm_mtype_x86_any)
              _pmap_walk_x86 $arg0 $arg1
          else
              if ($kgm_mtype == $kgm_mtype_arm)
                  _pmap_walk_arm $arg0 $arg1
              else
                  printf "Not available for current architecture.\n"
              end
          end
      end
  end
  
  document pmap_vtop
  Syntax: (gdb) pmap_vtop <pmap> <virtual_address>
  | For page-tables in <pmap> translate <virtual_address> to physical address.
  end
  
  define zstack
          set $index = $arg0
  
          if (log_records == 0)
                  set $count = 0
                  printf "Zone logging not enabled.  Add 'zlog=<zone name>' to boot-args.\n"
          else 
                  if ($argc == 2)
                          set $count = $arg1
                  else
                          set $count = 1
                  end
          end
  
          while ($count)
                  printf "\n--------------- "
  
                  if (zrecords[$index].z_opcode == 1)
                          printf "ALLOC "
                  else
                          printf "FREE "
                  end
  
                  printf " 0x%x : index %d  :  ztime %d -------------\n", zrecords[$index].z_element, $index, zrecords[$index].z_time
  
                  set $frame = 0
  
                  while ($frame < 15)
                          set $frame_pc = zrecords[$index].z_pc[$frame]
  
                          if ($frame_pc == 0)
                                  loop_break
                          end
  
                          x/i $frame_pc
                          set $frame = $frame + 1
                  end
  
                  set $index = $index + 1
                  set $count = $count - 1
          end
  end
  
  document zstack
  Syntax: (gdb) zstack <index> [<count>]
  | Zone leak debugging: print the stack trace of log element at <index>.
  | If a <count> is supplied, it prints <count> log elements starting at <index>.
  |
  | The suggested usage is to look at indexes below zcurrent and look for common stack traces.
  | The stack trace that occurs the most is probably the cause of the leak.  Find the pc of the
  | function calling into zalloc and use the countpcs kgmacro to find out how often that pc occurs in the log.
  | The pc occuring in a high percentage of records is most likely the source of the leak.
  |
  | The findoldest kgmacro is also useful for leak debugging since it identifies the oldest record
  | in the log, which may indicate the leaker.
  end
  
  define findoldest
          set $index = 0
          set $count = log_records
          set $cur_min = 2000000000
          set $cur_index = 0
  
          if (log_records == 0)
                  printf "Zone logging not enabled.  Add 'zlog=<zone name>' to boot-args.\n"
          else
  
                  while ($count)
                          if (zrecords[$index].z_element && zrecords[$index].z_time < $cur_min)
                                  set $cur_index = $index
                                  set $cur_min = zrecords[$index].z_time
                          end
          
                          set $count = $count - 1
                          set $index = $index + 1
                  end
          
                  printf "oldest record is at log index %d:\n", $cur_index
                  zstack $cur_index
          end
  end
  
  document findoldest
  Syntax: (gdb) findoldest
  | Zone leak debugging: find and print the oldest record in the log.  Note that this command
  | can take several minutes to run since it uses linear search.
  |
  | Once it prints a stack trace, find the pc of the caller above all the zalloc, kalloc and
  | IOKit layers.  Then use the countpcs kgmacro to see how often this caller has allocated
  | memory.  A caller with a high percentage of records in the log is probably the leaker.
  end
  
  define countpcs
          set $target_pc = $arg0
          set $index = 0
          set $count = log_records
          set $found = 0
  
          if (log_records == 0)
                  printf "Zone logging not enabled.  Add 'zlog=<zone name>' to boot-args.\n"
          else
  
                  while ($count)
                          set $frame = 0
          
                          if (zrecords[$index].z_element != 0)
                                  while ($frame < 15)
                                          if (zrecords[$index].z_pc[$frame] == $target_pc)
                                                  set $found = $found + 1
                                                  set $frame = 15
                                          end
                  
                                          set $frame = $frame + 1
                                  end
                          end
          
                          set $index = $index + 1
                          set $count = $count - 1
                  end
          
                  printf "occurred %d times in log (%d%c of records)\n", $found, ($found * 100) / zrecorded, '%'
          end
  end
  
  document countpcs
  Syntax: (gdb) countpcs <pc>
  | Zone leak debugging: search the log and print a count of all log entries that contain the given <pc>
  | in the stack trace.  This is useful for verifying a suspected <pc> as being the source of
  | the leak.  If a high percentage of the log entries contain the given <pc>, then it's most
  | likely the source of the leak.  Note that this command can take several minutes to run.
  end
  
  define findelem
          set $fe_index = zcurrent
          set $fe_count = log_records
          set $fe_elem = $arg0
          set $fe_prev_op = -1
  
          if (log_records == 0)
                  printf "Zone logging not enabled.  Add 'zlog=<zone name>' to boot-args.\n"
          end
  
          while ($fe_count)
                  if (zrecords[$fe_index].z_element == $fe_elem)
                          zstack $fe_index
  
                          if (zrecords[$fe_index].z_opcode == $fe_prev_op)
                                  printf "***************   DOUBLE OP!   *********************\n
                          end
  
                          set $fe_prev_op = zrecords[$fe_index].z_opcode
                  end
  
                  set $fe_count = $fe_count - 1
                  set $fe_index = $fe_index + 1
  
                  if ($fe_index >= log_records)
                          set $fe_index = 0
                  end
          end
  end
  
  document findelem
  Syntax: (gdb) findelem <elem addr>
  | Zone corruption debugging: search the log and print out the stack traces for all log entries that
  | refer to the given zone element.  When the kernel panics due to a corrupted zone element, get the
  | element address and use this macro.  This will show you the stack traces of all logged zalloc and
  | zfree operations which tells you who touched the element in the recent past.  This also makes
  | double-frees readily apparent.
  end
  
  
  # This implements a shadowing scheme in kgmacros. If the
  # current user data can be accessed by simply changing kdp_pmap,
  # that is used. Otherwise, we copy data into a temporary buffer
  # in the kernel's address space and use that instead. Don't rely on
  # kdp_pmap between invocations of map/unmap. Since the shadow
  # codepath uses a manual KDP packet, request no more than 128 bytes.
  # Uses $kgm_lp64 for kernel address space size, and
  # $kgm_readphys_use_kdp/$kgm_readphys_force_physmap to override
  # how the user pages are accessed ($kgm_readphys_force_physmap
  # implies walking the user task's pagetables to get a physical
  # address and then shadowing data from there using the
  # physical mapping of memory).
  define _map_user_data_from_task
      set $kgm_map_user_taskp = (task_t)$arg0
      set $kgm_map_user_map = $kgm_map_user_taskp->map
      set $kgm_map_user_pmap = $kgm_map_user_map->pmap
      set $kgm_map_user_task_64 = ( $kgm_map_user_taskp->taskFeatures[0] & 0x80000000)
      set $kgm_map_user_window = 0
      set $kgm_map_switch_map = 0
      
      if ($kgm_readphys_force_kdp != 0)
          set $kgm_readphys_use_kdp = 1
      else
          if ($kgm_readphys_force_physmap)
              set $kgm_readphys_use_kdp = 0
          else
              set $kgm_readphys_use_kdp = ( kdp->is_conn > 0 )
          end
      end
  
      if ($kgm_readphys_use_kdp)
  
          if $kgm_lp64
              set $kgm_map_switch_map = 1
          else
              if !$kgm_map_user_task_64
                  set $kgm_map_switch_map = 1
              end
          end
      
          if ($kgm_map_switch_map)
              # switch the map safely
              set $kgm_map_user_window = $arg1
              set kdp_pmap = $kgm_map_user_pmap
          else
              # requires shadowing/copying
  
              # set up the manual KDP packet
              set manual_pkt.input = 0
              set manual_pkt.len = sizeof(kdp_readmem64_req_t)
              set $kgm_pkt = (kdp_readmem64_req_t *)&manual_pkt.data
              set $kgm_pkt->hdr.request = KDP_READMEM64
              set $kgm_pkt->hdr.len = sizeof(kdp_readmem64_req_t)
              set $kgm_pkt->hdr.is_reply = 0
              set $kgm_pkt->hdr.seq = 0
              set $kgm_pkt->hdr.key = 0
              set $kgm_pkt->address = (uint64_t)$arg1
              set $kgm_pkt->nbytes = (uint32_t)$arg2
  
              set kdp_pmap = $kgm_map_user_pmap
              set manual_pkt.input = 1
              # dummy to make sure manual packet is executed
              set $kgm_dummy = &_mh_execute_header
              # Go back to kernel map so that we can access buffer directly
              set kdp_pmap = 0
  
              set $kgm_pkt = (kdp_readmem64_reply_t *)&manual_pkt.data
              if ($kgm_pkt->error == 0)
                  set $kgm_map_user_window = $kgm_pkt->data
              else
                  set $kgm_map_user_window = 0
              end
          end
  
      else
          # without the benefit of a KDP stub on the target, try to
          # find the user task's physical mapping and memcpy the data.
          # If it straddles a page boundary, copy in two passes
          set $kgm_vaddr_range1_start = (unsigned long long)$arg1
          set $kgm_vaddr_range1_count = (unsigned long long)$arg2
          if (($kgm_vaddr_range1_start + $kgm_vaddr_range1_count) & 0xFFF) < $kgm_vaddr_range1_count
              set $kgm_vaddr_range2_start = ($kgm_vaddr_range1_start + $kgm_vaddr_range1_count) & ~((unsigned long long)0xFFF)
              set $kgm_vaddr_range2_count = $kgm_vaddr_range1_start + $kgm_vaddr_range1_count - $kgm_vaddr_range2_start
              set $kgm_vaddr_range1_count = $kgm_vaddr_range2_start - $kgm_vaddr_range1_start
          else
              set $kgm_vaddr_range2_start = 0
              set $kgm_vaddr_range2_count = 0
          end
          set $kgm_paddr_range1_in_kva = 0
          set $kgm_paddr_range2_in_kva = 0
  
          if ($kgm_mtype == $kgm_mtype_x86_64)
              set $kgm_pt_verbose = 0
              _pmap_walk_x86 $kgm_map_user_pmap $kgm_vaddr_range1_start
              if $kgm_paddr_isvalid
                  set $kgm_paddr_range1_in_kva = $kgm_paddr + (((unsigned long long)-1 << 47) | ((unsigned long long)509 << 39))
              end
              if $kgm_vaddr_range2_start
                  _pmap_walk_x86 $kgm_map_user_pmap $kgm_vaddr_range2_start
                  if $kgm_paddr_isvalid
                      set $kgm_paddr_range2_in_kva = $kgm_paddr + (((unsigned long long)-1 << 47) | ((unsigned long long)509 << 39))
                  end
              end
          else
              if ($kgm_mtype == $kgm_mtype_arm)
                  set $kgm_pt_verbose = 0
                  _pmap_walk_arm $kgm_map_user_pmap $kgm_vaddr_range1_start
                  if $kgm_paddr_isvalid
                     set $kgm_paddr_range1_in_kva = $kgm_paddr - gPhysBase + gVirtBase
                  end
                  if $kgm_vaddr_range2_start
                      _pmap_walk_arm $kgm_map_user_pmap $kgm_vaddr_range2_start
                      if $kgm_paddr_isvalid
                          set $kgm_paddr_range2_in_kva = $kgm_paddr - gPhysBase + gVirtBase
                      end
                  end
              else
                  printf "Not available for current architecture.\n"
                  set $kgm_paddr_isvalid = 0
              end
          end
          if $kgm_paddr_range1_in_kva
              set $kgm_pkt = (kdp_readmem64_reply_t *)&manual_pkt.data
              memcpy $kgm_pkt->data $kgm_paddr_range1_in_kva $kgm_vaddr_range1_count
              if $kgm_paddr_range2_in_kva
                  memcpy &$kgm_pkt->data[$kgm_vaddr_range1_count] $kgm_paddr_range2_in_kva $kgm_vaddr_range2_count
              end
              set $kgm_map_user_window  = $kgm_pkt->data
          else
             set $kgm_map_user_window  = 0
         end
     end
 end
 
 define _unmap_user_data_from_task
     set kdp_pmap = 0
 end
 
 # uses $kgm_taskp. Maps 32 bytes at a time and prints it
 define _print_path_for_image
     set $kgm_print_path_address = (unsigned long long)$arg0
     set $kgm_path_str_notdone = 1
 
     if ($kgm_print_path_address == 0)
        set $kgm_path_str_notdone = 0
     end
     
     while $kgm_path_str_notdone
         _map_user_data_from_task $kgm_taskp $kgm_print_path_address 32
 
         set $kgm_print_path_ptr = (char *)$kgm_map_user_window
         set $kgm_path_i = 0
         while ($kgm_path_i < 32 && $kgm_print_path_ptr[$kgm_path_i] != '\0')
             set $kgm_path_i = $kgm_path_i + 1
         end
         printf "%.32s", $kgm_print_path_ptr
         
         _unmap_user_data_from_task $kgm_taskp