rom/intuition/dumpintuistate.c

   1 /*
   2     Copyright © 1995-2013, The AROS Development Team. All rights reserved.
   3     Copyright © 2001-2003, The MorphOS Development Team. All Rights Reserved.
   4     $Id$
   5 */
   6
   7 #include "intuition_intern.h"
   8
   9 static void ShowSemaphore(const char *, struct SignalSemaphore *);
  10 static void ShowLayer(struct Layer *);
  11
  12 /*****************************************************************************
  13
  14     NAME */
  15 #include <proto/intuition.h>
  16
  17         AROS_LH0(void, DumpIntuiState,
  18
  19 /*  SYNOPSIS */
  20
  21 /*  LOCATION */
  22         struct IntuitionBase *, IntuitionBase, 152, Intuition)
  23
  24 /*  FUNCTION
  25         Private: dump the internal state of intuition.
  26
  27     INPUTS
  28
  29     RESULT
  30         None.
  31
  32     NOTES
  33
  34     EXAMPLE
  35
  36     BUGS
  37
  38     SEE ALSO
  39
  40     INTERNALS
  41
  42 *****************************************************************************/
  43 {
  44     AROS_LIBFUNC_INIT
  45
  46 #if 1
  47
  48     struct IntIntuitionBase *IBase = GetPrivIBase(IntuitionBase);
  49     struct Screen *scr;
  50     struct Window *win;
  51
  52     Forbid();
  53
  54     dprintf("----------------------------------------------------------------\n");
  55     dprintf("IntuitionBase 0x%lx\n", (ULONG) IntuitionBase);
  56     ShowSemaphore("IBaseLock", IBase->IBaseLock);
  57     ShowSemaphore("PubScrListLock", &IBase->PubScrListLock);
  58     ShowSemaphore("GadgetLock", &IBase->GadgetLock);
  59     ShowSemaphore("MenuLock", &IBase->MenuLock);
  60     ShowSemaphore("IntuiActionLock", &IBase->IntuiActionLock);
  61     ShowSemaphore("InputHandlerLock", &IBase->InputHandlerLock);
  62     ShowSemaphore("ClassListLock", &IBase->ClassListLock);
  63
  64     dprintf("\nScreens:\n");
  65
  66     for (scr = IntuitionBase->FirstScreen; scr; scr = scr->NextScreen)
  67     {
  68         dprintf("\nScreen 0x%lx <%s>\n", (ULONG) scr, scr->Title ? scr->Title : (UBYTE *)"NULL");
  69
  70         dprintf("LayerInfo 0x%lx LockLayersCount %ld\n",
  71             (ULONG) &scr->LayerInfo, (LONG) scr->LayerInfo.LockLayersCount);
  72         ShowSemaphore("LayerInfo", &scr->LayerInfo.Lock);
  73         ShowLayer(GetPrivScreen(scr)->rootLayer);
  74         ShowLayer(scr->BarLayer);
  75
  76         for (win = scr->FirstWindow; win; win = win->NextWindow)
  77         {
  78             dprintf("\nWindow 0x%lx <%s>\n", (ULONG) win, win->Title ? win->Title : (UBYTE *)"NULL");
  79
  80             ShowLayer(WLAYER(win));
  81
  82             if (IS_GZZWINDOW(win))
  83             {
  84                 ShowLayer(BLAYER(win));
  85             }
  86         }
  87     }
  88
  89     dprintf("----------------------------------------------------------------\n");
  90
  91     Permit();
  92
  93 #endif
  94
  95     AROS_LIBFUNC_EXIT
  96 }
  97
  98 #if 1
  99
 100 void *CheckValidPtr(void *Ptr)
 101 {
 102     if (((ULONG) Ptr >= 0x20000000UL) &&
 103         ((ULONG) Ptr < 0x30000000UL))
 104     {
 105         return(Ptr);
 106     }
 107     if (((ULONG) Ptr >= 0x7000000UL) &&
 108         ((ULONG) Ptr < 0xb510000UL))
 109     {
 110         return(Ptr);
 111     }
 112     else if (((ULONG) Ptr >= ((ULONG) 0x11000000)) &&
 113          ((ULONG) Ptr < ((ULONG) 0x14000000)))
 114     {
 115         return(Ptr);
 116     }
 117     else if (((ULONG) Ptr >= ((ULONG) 0x10100000)) &&
 118          ((ULONG) Ptr < ((ULONG) 0x10400000)))
 119     {
 120         return(Ptr);
 121     }
 122     else if (((ULONG) Ptr >= ((ULONG) 0x10800000)) &&
 123          ((ULONG) Ptr < ((ULONG) 0x10900000)))
 124     {
 125         return(Ptr);
 126     }
 127     else if (((ULONG) Ptr >= 0x1000) &&
 128          ((ULONG) Ptr < 0x00200000))
 129     {
 130         return(Ptr);
 131     }
 132     else if (((ULONG) Ptr >= 0x00f80000) &&
 133          ((ULONG) Ptr <  0x01000000))
 134     {
 135         return(Ptr);
 136     }
 137     else if ((ULONG) Ptr == (ULONG) 0x100000f0)
 138     {
 139         return(Ptr);
 140     }
 141     return(NULL);
 142 }
 143
 144 #pragma pack(2)
 145 struct  SegTrackerSemaphore
 146 {
 147     struct  SignalSemaphore Semaphore;
 148     void                    (*Search)(void);
 149     struct  MinList         List;
 150 };
 151
 152 struct  SegArray
 153 {
 154     ULONG   Address;
 155     ULONG   Size;
 156 };
 157
 158 struct  SegTrackerNode
 159 {
 160     struct  MinNode         Node;
 161     char                    *Name;
 162     struct  SegArray        Array[1];
 163 };
 164 #pragma pack()
 165
 166 static struct SegTrackerSemaphore       *MySegInfo;
 167
 168 #define DEBUG_SEGTRACKER(x)     ;
 169
 170 #undef SysBase
 171
 172 char    *FindAddress(ULONG      Address,
 173                      ULONG      *Hunk,
 174                      ULONG      *Offset)
 175 {
 176     struct SegTrackerNode   *MyNode;
 177     char                    *Name=NULL;
 178     ULONG                   Count;
 179
 180     DEBUG_SEGTRACKER(dprintf("FindAddress(Address 0x%lx Hunk 0x%lx Offset 0x%lx)\n",
 181                  Address,
 182                  Hunk,
 183                  Offset));
 184
 185     /* MySegInfo isn`t valid after a coldreboot
 186      * therefore scan for it everytime
 187      */
 188     if (TRUE)//(MySegInfo==NULL)
 189     {
 190         struct ExecBase *SysBase = *(struct ExecBase **)4;
 191         MySegInfo =(struct SegTrackerSemaphore*) FindSemaphore("SegTracker");
 192         DEBUG_SEGTRACKER(dprintf("FindAddress: SegInfo 0x%lx\n",
 193                      MySegInfo));
 194     }
 195     if (MySegInfo)
 196     {
 197         if (CheckValidPtr(MySegInfo))
 198         {
 199             MyNode    =(struct SegTrackerNode*) MySegInfo->List.mlh_Head;
 200             DEBUG_SEGTRACKER(dprintf("FindAddress: 1st Node 0x%lx\n",
 201                          MyNode));
 202             while ((CheckValidPtr(MyNode)) &&
 203                 (MyNode->Node.mln_Succ) &&
 204                 (!Name))
 205             {
 206                 Count   =       0;
 207                 DEBUG_SEGTRACKER(dprintf("FindAddress: Current Segment %s\n",
 208                              MyNode->Name));
 209
 210                 while (MyNode->Array[Count].Address)
 211                 {
 212                     DEBUG_SEGTRACKER(dprintf("FindAddress: Current Address 0x%lx Size 0x%lx\n",
 213                                  MyNode->Array[Count].Address,
 214                                  MyNode->Array[Count].Size));
 215
 216                     if ((Address > MyNode->Array[Count].Address) &&
 217                         (Address < (MyNode->Array[Count].Address + MyNode->Array[Count].Size)))
 218                     {
 219                         *Hunk               =       Count;
 220                         *Offset             =       Address - MyNode->Array[Count].Address - 4;
 221                         Name                =       MyNode->Name;
 222
 223                         if (Hunk==Offset)
 224                         {
 225                             *Hunk     =       MyNode->Array[0].Address;
 226                         }
 227                         DEBUG_SEGTRACKER(dprintf("FindAddress: Found %s\n",
 228                                      Name));
 229                     }
 230                     Count++;
 231                 }
 232                 MyNode  =(struct SegTrackerNode*) MyNode->Node.mln_Succ;
 233             }
 234         }
 235     }
 236     return(Name);
 237 }
 238
 239 void    ShowStack(ULONG Address,
 240                   ULONG Size)
 241 {
 242     ULONG   Ptr;
 243     char    *MyName;
 244     ULONG   Hunk;
 245     ULONG   Offset;
 246
 247     if (CheckValidPtr((ULONG*) Address))
 248     {
 249         Ptr =       Address;
 250         while (Ptr < (Address+Size))
 251         {
 252             if ((MyName=FindAddress(*((ULONG*) Ptr),
 253                             &Hunk,
 254                             &Offset)))
 255             {
 256                 dprintf("\t\t0x%lx -> %s Hunk %ld Offset 0x%08lx\n",
 257                     *((ULONG*) Ptr),
 258                     MyName,
 259                     Hunk,
 260                     Offset);
 261                 Ptr     +=      4;
 262             }
 263             else
 264             {
 265                 Ptr     +=      2;
 266             }
 267         }
 268     }
 269 }
 270
 271 #define MAXLEVEL        10
 272 #define DEBUG_SHOWHISTORY(x)    ;
 273
 274 void    ShowPPCStackHistory(ULONG       *Stack,
 275                             ULONG       *StackEnd)
 276 {
 277     char    *MyName;
 278     ULONG   Hunk;
 279     ULONG   Offset;
 280     ULONG   *CurrentStack;
 281     ULONG   *StackPtr;
 282     int     i;
 283
 284
 285     i             =       0;
 286     CurrentStack  =       Stack;
 287
 288     DEBUG_SHOWHISTORY(dprintf("ShowPPCStackHistory: Stack 0x%lx StackEnd 0x%lx\n",
 289                   Stack,
 290                   StackEnd));
 291
 292     while (CurrentStack < StackEnd)
 293     {
 294         StackPtr    =(ULONG*) CurrentStack[0];      /* Get previous stackframe */
 295         DEBUG_SHOWHISTORY(dprintf("ShowPPCStackHistory: StackPtr 0x%lx\n",
 296                       StackPtr));
 297         if ((StackPtr >= Stack) &&
 298             (StackPtr < StackEnd))
 299         {
 300             if (CheckValidPtr((ULONG*) StackPtr[1]))
 301             {
 302                 /* Legal LR */
 303
 304                 if ((MyName=FindAddress(StackPtr[1],
 305                                 &Hunk,
 306                                 &Offset)))
 307                 {
 308                     dprintf("\t\tStackFrame[%ld].LR-> Address 0x%08lx -> %s Hunk %ld Offset 0x%08lx\n",
 309                         (LONG) i,
 310                         StackPtr[1],
 311                         MyName,
 312                         Hunk,
 313                         Offset);
 314                 }
 315                 else
 316                 {
 317                     dprintf("\t\tStackFrame[%ld].LR-> Address 0x%08lx\n",
 318                         (LONG) i,
 319                         StackPtr[1]);
 320                 }
 321 #if 0
 322                 PPCDissasemble((APTR) StackPtr[1],
 323                            4,
 324                            PPCLibBase);
 325 #endif
 326             }
 327             else
 328             {
 329                 dprintf("\t\tStackFrame[%ld].LR-> Address 0x%08lx **Not Valid**\n\n",
 330                     (LONG) i,
 331                     StackPtr[1]);
 332             }
 333             i--;
 334             CurrentStack      =       StackPtr;
 335             if (i < -MAXLEVEL)
 336             {
 337                 DEBUG_SHOWHISTORY(dprintf("ShowPPCStackHistory: MaxLevel end\n"));
 338                 break;
 339             }
 340         }
 341         else
 342         {
 343             DEBUG_SHOWHISTORY(dprintf("ShowPPCStackHistory: address outside\n"));
 344             break;
 345         }
 346     }
 347 }
 348
 349
 350 /* hack-o-rama */
 351 #if 0
 352 typedef unsigned int        u_int32_t;
 353 typedef double          float64_t;
 354 struct __QVector
 355 {
 356     u_int32_t   A;
 357     u_int32_t   B;
 358     u_int32_t   C;
 359     u_int32_t   D;
 360 };
 361
 362 typedef struct __QVector        vector128_t;
 363 #endif
 364
 365 #if 1
 366 /*
 367  * Yeah yeah, this is ugly.. who cares..
 368  */
 369 typedef unsigned int        u_int32_t;
 370 typedef double          float64_t;
 371 struct __QVector
 372 {
 373     u_int32_t   A;
 374     u_int32_t   B;
 375     u_int32_t   C;
 376     u_int32_t   D;
 377 };
 378 typedef struct __QVector        vector128_t;
 379
 380
 381 struct PPCRegFrame
 382 {
 383     u_int32_t       StackGap[4];        /* StackFrame Gap..so a function working
 384                                  * with the PPCRegFrame as the GPR1 doesn`t
 385                                  * overwrite any contents with a LR store at 4(1)
 386                                  */
 387
 388     u_int32_t       Version;        /* Version of the structure */
 389     u_int32_t       Type;           /* Type of the regframe */
 390     u_int32_t       Flags;          /* The filled up registers */
 391     u_int32_t       State;          /* State of the Thread(only used for Get) */
 392
 393     u_int32_t       SRR0;
 394     u_int32_t       SRR1;
 395     u_int32_t       LR;
 396     u_int32_t       CTR;
 397
 398     u_int32_t       CR;
 399     u_int32_t       XER;
 400
 401     u_int32_t       GPR[32];
 402
 403     float64_t       FPR[32];
 404     float64_t       FPSCR;
 405
 406     u_int32_t       VSAVE;
 407     u_int32_t       AlignPad0;
 408     u_int32_t       AlignPad1;
 409     u_int32_t       AlignPad2;
 410     vector128_t     VSCR;
 411     vector128_t     VMX[32];
 412     /* no size
 413         */
 414 };
 415 #endif
 416
 417 void ShowTaskState(struct Task *task)
 418 {
 419     struct PPCRegFrame *frame = task->tc_ETask->PPCRegFrame;
 420     struct EmulHandle *emul = (APTR)frame->GPR[2];
 421     char *MyName;
 422     ULONG Offset, Hunk;
 423
 424     dprintf("\t\tSRR0 0x%lx LR 0x%lx CTR 0x%lx PC 0x%lx\n",
 425         (ULONG) frame->SRR0, (ULONG) frame->LR, (ULONG) frame->CTR,
 426         emul->Flags & EMULFLAGSF_PPC ? (ULONG) emul->PC : (ULONG) frame->GPR[13]);
 427
 428     if (emul->Flags & EMULFLAGSF_PPC)
 429     {
 430         if ((MyName=FindAddress((ULONG) frame->SRR0,
 431                         &Hunk,
 432                         &Offset)))
 433         {
 434             dprintf("\t\tSRR0 -> %s Hunk %ld Offset 0x%08lx\n",
 435                 MyName,
 436                 Hunk,
 437                 Offset);
 438         }
 439
 440         if ((MyName=FindAddress((ULONG) frame->LR,
 441                         &Hunk,
 442                         &Offset)))
 443         {
 444             dprintf("\t\t  LR -> %s Hunk %ld Offset 0x%08lx\n",
 445                 MyName,
 446                 Hunk,
 447                 Offset);
 448         }
 449
 450         if ((MyName=FindAddress((ULONG) frame->CTR,
 451                         &Hunk,
 452                         &Offset)))
 453         {
 454             dprintf("\t\t CTR -> %s Hunk %ld Offset 0x%08lx\n",
 455                 MyName,
 456                 Hunk,
 457                 Offset);
 458         }
 459
 460
 461         ShowPPCStackHistory((ULONG*) frame->GPR[1],
 462                     (ULONG*) (frame->GPR[1] + 1000));
 463
 464         if ((MyName=FindAddress((ULONG) emul->PC,
 465                         &Hunk,
 466                         &Offset)))
 467         {
 468             dprintf("\t\tPC -> %s Hunk %ld Offset 0x%08lx\n",
 469                 MyName,
 470                 Hunk,
 471                 Offset);
 472         }
 473         ShowStack(emul->An[7],
 474               0x80);
 475     }
 476     else
 477     {
 478         if ((MyName=FindAddress((ULONG) frame->GPR[13],
 479                         &Hunk,
 480                         &Offset)))
 481         {
 482             dprintf("\t\tPC -> %s Hunk %ld Offset 0x%08lx\n",
 483                 MyName,
 484                 Hunk,
 485                 Offset);
 486         }
 487         ShowStack(frame->GPR[31],
 488               0x80);
 489     }
 490 }
 491
 492 void ShowSemaphore(const char *name, struct SignalSemaphore *sem)
 493 {
 494     struct SemaphoreRequest *req;
 495
 496     if (name)
 497         dprintf("Semaphore %s:\n", name);
 498
 499     dprintf("Semaphore 0x%lx NestCount %d QueueCount %d Owner 0x%lx <%s>\n",
 500         (ULONG) sem, sem->ss_NestCount, sem->ss_QueueCount,
 501         (ULONG) sem->ss_Owner, sem->ss_Owner && sem->ss_Owner->tc_Node.ln_Name ?
 502         sem->ss_Owner->tc_Node.ln_Name : "NULL");
 503     if (sem->ss_Owner)
 504         ShowTaskState(sem->ss_Owner);
 505
 506     ForeachNode(&sem->ss_WaitQueue, req)
 507     {
 508         dprintf("\tTask 0x%lx <%s>\n", (ULONG) req->sr_Waiter,
 509             req->sr_Waiter->tc_Node.ln_Name ? req->sr_Waiter->tc_Node.ln_Name : "NULL");
 510         ShowTaskState(req->sr_Waiter);
 511     }
 512 }
 513
 514 void ShowLayer(struct Layer *layer)
 515 {
 516     if (layer)
 517     {
 518         dprintf("Layer 0x%lx\n", (ULONG) layer);
 519         ShowSemaphore(NULL, &layer->Lock);
 520     }
 521 }
 522
 523 #endif