rom/alerthook/alerthook.c

   1 /*
   2     Copyright © 1995-2001, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: Alert.Hook for AROS
   6     Lang: english
   7 */
   8
   9 #define DEBUG 0
  10 #include <aros/debug.h>
  11 #include <aros/config.h>
  12 #include <exec/types.h>
  13 #include <exec/resident.h>
  14 #include <exec/alerts.h>
  15 #include <exec/tasks.h>
  16 #include <exec/execbase.h>
  17 #include <intuition/intuitionbase.h>
  18 #include <proto/exec.h>
  19 #include <proto/intuition.h>
  20 #include <aros/system.h>
  21 #include <aros/libcall.h>
  22 #include <aros/asmcall.h>
  23
  24 struct Errors
  25 {
  26     ULONG   number;
  27     STRPTR  string;
  28 };
  29
  30 static const UBYTE Alerthook_name[];
  31 static const UBYTE Alerthook_version[];
  32 static AROS_UFP3(ULONG, Alerthook_init,
  33     AROS_UFPA(void *,               dummy1,  D0),
  34     AROS_UFPA(BPTR,                 dummy2,  A0),
  35     AROS_UFPA(struct ExecBase *,    SysBase, A6)
  36 );
  37
  38 STRPTR getGuruString(ULONG, STRPTR);
  39
  40 extern void Alerthook_end(void);
  41
  42 const struct Resident Alerthook_resident =
  43 {
  44     RTC_MATCHWORD,
  45     (struct Resident *)&Alerthook_resident,
  46     (APTR)&Alerthook_end,
  47     RTF_COLDSTART,
  48     41,
  49     NT_UNKNOWN,
  50     -45,
  51     (UBYTE *)Alerthook_name,
  52     (UBYTE *)&Alerthook_version[6],
  53     (APTR)&Alerthook_init,
  54 };
  55
  56 static const UBYTE Alerthook_name[] = "alert.hook\r\n";
  57 static const UBYTE Alerthook_version[] = "$VER: alert.hook 41.8 " ADATE;
  58 static UBYTE *const nomem = "\x38\x0f" "Not Enough Memory! ";
  59 static UBYTE *const sfail = "\x38\x0f" "Software Failure! ";
  60 static UBYTE *const recov = "\x38\x0f" "Recoverable Alert! ";
  61 static UBYTE *const mouse = "\x01\x50\x0f" "Press mouse button to continue.";
  62 static UBYTE *const fmtstring = "\xa8\x2a" "Task:   %08lx - ";
  63 static UBYTE *const errstring = "\x1e" "Error  %04x %04x - ";
  64 static UBYTE *const tasknotfound = "--task not found--";
  65
  66 /* This is the callback for RawDoFmt() */
  67 AROS_UFH2(void, putChProc,
  68     AROS_UFHA(UBYTE, chr, D0),
  69     AROS_UFHA(STRPTR *, buf, A3))
  70 {
  71     AROS_LIBFUNC_INIT
  72
  73     **buf = chr;
  74     *buf += 1;
  75
  76     AROS_LIBFUNC_EXIT
  77 }
  78
  79 /* This function copies a string, but also returns a pointer to the
  80    '\0' at the end of the string. This way I can concat the strings
  81    which have '\0' in them for other reasons.
  82
  83    Note len == -1 is equivalent to strcpy(dest,src).
  84 */
  85 static STRPTR
  86 mystrcpy(STRPTR dest, STRPTR src, LONG len)
  87 {
  88     while(len && *src)
  89     {
  90         *dest++ = *src++;
  91         len--;
  92     }
  93     *dest++ = 0;
  94     return dest;
  95 }
  96
  97 static AROS_UFH3(ULONG, Alerthook_init,
  98     AROS_UFHA(void *,               dummy1,  D0),
  99     AROS_UFHA(BPTR,                 dummy2,  A0),
 100     AROS_UFHA(struct ExecBase *,    SysBase, A6)
 101 )
 102 {
 103     AROS_LIBFUNC_INIT
 104
 105 #if (AROS_FLAVOUR & AROS_FLAVOUR_NATIVE)
 106     /*
 107         Clear memory location zero (a cookie for the delayed guru after reset).
 108         Some machines will keep putting a guru up during every reset if I don't
 109         do this here.
 110     */
 111     ULONG *location_zero = (void *)0;
 112
 113     *location_zero = 0;
 114 #endif
 115
 116     D(bug("AlertHook: *******************\n"));
 117     if(SysBase->LastAlert[0] != -1)
 118     {
 119         struct IntuitionBase *IntuitionBase;
 120         struct Task *task;
 121         UBYTE buffer[256], *buf, *tname;
 122
 123         D(bug("alert.hook: LastAlert[0] = 0x%lx\n", SysBase->LastAlert[0]));
 124
 125         buffer[0] = 0;
 126         buf = &buffer[1];
 127
 128         if(SysBase->LastAlert[0] & AG_NoMemory)
 129             buf = mystrcpy(buf, nomem, -1);
 130         else if(SysBase->LastAlert[0] & AT_DeadEnd)
 131             buf = mystrcpy(buf, sfail, -1);
 132         else
 133             buf = mystrcpy(buf, recov, -1);
 134
 135         *buf++ = 1;
 136
 137         buf = mystrcpy(buf, mouse, -1);
 138         *buf++ = 1; *buf++ = 0;
 139
 140         /* Find out the task name. The node type must be correct. */
 141         task = (struct Task *)SysBase->LastAlert[1];
 142         if( (
 143                   (task->tc_Node.ln_Type == NT_TASK)
 144                || (task->tc_Node.ln_Type == NT_PROCESS)
 145             )
 146             && (task->tc_Node.ln_Name != NULL)
 147           )
 148             tname = task->tc_Node.ln_Name;
 149         else
 150             tname = tasknotfound;
 151
 152         RawDoFmt(fmtstring, &SysBase->LastAlert[1], (void *)putChProc, &buf);
 153         buf = mystrcpy(buf - 1, tname, 30);
 154         *buf++ = 1; *buf++ = 0;
 155
 156         /* Use this variable to hold the current address */
 157         tname = buf++;
 158         RawDoFmt(errstring, &SysBase->LastAlert[0], (void *)putChProc, &buf);
 159
 160         buf = getGuruString(SysBase->LastAlert[0], &buf[-1]);
 161         *buf++ = 0;
 162
 163         /* This rather strange contraption will centre the string. */
 164         *((UBYTE *)tname) = (82 - (buf - tname)) << 2;
 165
 166         IntuitionBase = (struct IntuitionBase *)OpenLibrary("intuition.library",0);
 167
 168         if(IntuitionBase)
 169         {
 170             if(IntuitionBase->LibNode.lib_Version >= 39)
 171                 TimedDisplayAlert(SysBase->LastAlert[0] & AT_DeadEnd, buffer, 0x38, 500);
 172             else
 173                 DisplayAlert(SysBase->LastAlert[0] & AT_DeadEnd, buffer, 0x38);
 174
 175             CloseLibrary((struct Library *)IntuitionBase);
 176         } else {
 177             D(bug("alert.hook: No intuition, dumping message\n"));
 178             D(bug("alert.hook: %s\n", buffer));
 179         }
 180
 181         SysBase->LastAlert[0] = -1;
 182     }
 183 #if 0
 184     SysBase->LastAlert[0] = old;
 185     SysBase->LastAlert[1] = NULL;
 186 #endif
 187     return FALSE;
 188
 189     AROS_LIBFUNC_EXIT
 190 }
 191
 192 /* Get a string from an array of type Errors. */
 193 STRPTR getString(STRPTR buffer, ULONG alertnum, const struct Errors *errs)
 194 {
 195     while((errs->number) && (errs->number != alertnum))
 196     {
 197         errs++;
 198     }
 199     return mystrcpy(buffer, errs->string, -1);
 200 }
 201
 202 static const struct Errors cpustrings[] =
 203 {
 204     { ACPU_BusErr,      "Hardware bus fault/address error" },
 205     { ACPU_AddressErr,  "Illegal address access (odd)" },
 206     { ACPU_InstErr,     "Illegal instruction" },
 207     { ACPU_DivZero,     "Division by zero" },
 208     { ACPU_CHK,         "CHK instruction error" },
 209     { ACPU_TRAPV,       "TRAPV instruction error" },
 210     { ACPU_PrivErr,     "Priviledge violation error" },
 211     { ACPU_Trace,       "Trace error" },
 212     { ACPU_LineA,       "Line 1010 (A) E mulator error" },
 213     { ACPU_LineF,       "Line 1111 (F) Emulator/Coprocessor error" },
 214     { ACPU_Format,      "Stack frame format error" },
 215     { ACPU_Spurious,    "Spurious interrupt error" },
 216     { 0, "Unknown CPU error" }
 217 };
 218
 219 static const struct Errors subsystems[] =
 220 {
 221     { 0x01,     "exec.library " },
 222     { 0x02,     "graphics.library " },
 223     { 0x03,     "layers.library " },
 224     { 0x04,     "intuition.library " },
 225     { 0x05,     "math.library " },
 226     { 0x07,     "dos.library " },
 227     { 0x08,     "ramlib " },
 228     { 0x09,     "icon.library " },
 229     { 0x0a,     "expansion.library " },
 230     { 0x0b,     "diskfont.library " },
 231     { 0x10,     "audio.device " },
 232     { 0x11,     "console.device " },
 233     { 0x12,     "gameport.device " },
 234     { 0x13,     "keyboard.device " },
 235     { 0x14,     "trackdisk.device " },
 236     { 0x15,     "timer.device " },
 237     { 0x20,     "cia.resource " },
 238     { 0x21,     "disk.resource " },
 239     { 0x22,     "misc.resource " },
 240     { 0x30,     "bootstrap " },
 241     { 0x31,     "workbench " },
 242     { 0x32,     "diskcopy " },
 243     { 0x33,     "gadtools " },
 244     { 0x34,     "utility " },
 245
 246     { 0x40,     "aros " },
 247     { 0x41,     "oop " },
 248     { 0x42,     "hidd " },
 249
 250     /* This takes in 0x35 as well... */
 251     { 0x00,     "unknown " }
 252 };
 253
 254 static const struct Errors types[] =
 255 {
 256     { 0x01,     "no memory for " },
 257     { 0x02,     "could not make library " },
 258     { 0x03,     "could not open library " },
 259     { 0x04,     "could not open device " },
 260     { 0x05,     "could not open resource " },
 261     { 0x06,     "IO error with " },
 262     { 0x07,     "no signal for/from " },
 263     { 0x08,     "bad parameter for/from " },
 264     { 0x09,     "close library error with " },
 265     { 0x0a,     "close device error with " },
 266     { 0x0b,     "process creating failure with " },
 267     { 0x00,     "unknown problem with "}
 268 };
 269
 270 static const struct Errors execstrings[] =
 271 {
 272     { AN_ExcptVect,     "MC68k Exception vector checksum" },
 273     { AN_BaseChkSum,    "ExecBase checksum" },
 274     { AN_LibChkSum,     "Library checksum failure" },
 275     { AN_MemCorrupt,    "Corrupt memory list detected" },
 276     { AN_IntrMem,       "No memory for interrupt servers" },
 277     { AN_InitAPtr,      "(obs) InitStruct of an APTR" },
 278     { AN_SemCorrupt,    "Semaphore in an illegal state" },
 279     { AN_FreeTwice,     "Memory freed twice" },
 280     { AN_BogusExcpt,    "Illegal mc68k exception taken" },
 281     { AN_IOUsedTwice,   "Attempt to reuse active IORequest" },
 282     { AN_MemoryInsane,  "Sanity check on memory list failed" },
 283     { AN_IOAfterClose,  "Attempt to use IORequest after close" },
 284     { AN_StackProbe,    "Stack extends out of range" },
 285     { AN_BadFreeAddr,   "Memory header not located" },
 286     { AN_BadSemaphore,  "Attempt to use the old message semaphore" },
 287     { 0, "unknown exec.library error" }
 288 };
 289
 290 static const struct Errors gfxstrings[] =
 291 {
 292     { AN_GfxNoMem,      "Graphics out of memory" },
 293     { AN_GfxNoMemMspc,  "No memory to allocate MonitorSpec" },
 294     { AN_LongFrame,     "No memory for long frame" },
 295     { AN_ShortFrame,    "No memory for short frame" },
 296     { AN_TextTmpRas,    "Mo memory for TmpRas" },
 297     { AN_BltBitMap,     "No memory for BltBitMap" },
 298     { AN_RegionMemory,  "No memory for Region" },
 299     { AN_MakeVPort,     "No memory for MakeVPort" },
 300     { AN_GfxNewError,   "Error in GfxNew()" },
 301     { AN_GfxFreeError,  "Error in GfxFree()" },
 302     { AN_GfxNoLCM,      "Emergency memory not available" },
 303     { AN_ObsoleteFont,  "Unsupported font description used" },
 304     { 0, "unknown graphics.library error" }
 305 };
 306
 307 static const struct Errors unknownstrings[] =
 308 {
 309     { 0, "unknown error" }
 310 };
 311
 312 static const struct Errors layersstrings[] =
 313 {
 314     { AN_LayersNoMem,   "layers: no memory" },
 315     { 0, "unknown layers.library error" }
 316 };
 317
 318 static const struct Errors intuistrings[] =
 319 {
 320     { AN_GadgetType,    "intuition: unknown gadget type" },
 321     { AN_CreatePort,    "intuition couldn't create port, no memory" },
 322     { AN_ItemAlloc,     "no memory for menu item" },
 323     { AN_SubAlloc,      "no memory for menu subitem" },
 324     { AN_PlaneAlloc,    "no memory for bitplane" },
 325     { AN_ItemBoxTop,    "top of item box < RelZero" },
 326     { AN_OpenScreen,    "no memory for OpenScreen()" },
 327     { AN_OpenScrnRast,  "no memory for OpenScreen() raster" },
 328     { AN_SysScrnType,   "unknown type of system screen" },
 329     { AN_AddSWGadget,   "add SW gadgets, no memory" },
 330     { AN_OpenWindow,    "no memory for OpenWindow()" },
 331     { AN_BadState,      "bad state return entering intuition" },
 332     { AN_BadMessage,    "bad message received by IDCMP" },
 333     { AN_WeirdEcho,     "weird echo causing incomprehension" },
 334     { AN_NoConsole,     "couldn't open the console.device" },
 335     { AN_NoISem,        "intuition skipped obtaining a semaphore" },
 336     { AN_ISemOrder,     "intuition got a semaphore in wrong order" },
 337     { 0, "unknown intuition.library error" }
 338 };
 339
 340 static const struct Errors mathstrings[] =
 341 {
 342     { 0, "unknown math library error" }
 343 };
 344
 345 static const struct Errors dosstrings[] =
 346 {
 347     { AN_StartMem,      "no memory at startup" },
 348     { AN_EndTask,       "EndTask did not end task" },
 349     { AN_QPktFail,      "QPkt failure" },
 350     { AN_AsyncPkt,      "unexpected DOS packet received" },
 351     { AN_FreeVec,       "freevec failed" },
 352     { AN_DiskBlkSeq,    "disk block sequence error" },
 353     { AN_BitMap,        "disk bitmap corrupt" },
 354     { AN_KeyFree,       "disk key already free" },
 355     { AN_BadChkSum,     "disk checksum bad" },
 356     { AN_DiskError,     "disk error" },
 357     { AN_KeyRange,      "disk key out of range" },
 358     { AN_BadOverlay,    "bad overlay" },
 359     { AN_BadInitFunc,   "invalid initialization packet for cli/shell" },
 360     { AN_FileReclosed,  "filehandle closed more than once" },
 361     { 0, "unknown dos.library error" }
 362 };
 363
 364 static const struct Errors ramlibstrings[] =
 365 {
 366     { AN_BadSegList,    "bad library seglist" },
 367     { 0, "unknown ramlib/lddemon error" }
 368 };
 369
 370 static const struct Errors iconstrings[] =
 371 {
 372     { 0, "unknown icon.library error" }
 373 };
 374
 375 static const struct Errors expanstrings[] =
 376 {
 377     { AN_BadExpansionFree,  "expansion freeing region already freed"},
 378     { 0, "unknown expansion.library error" }
 379 };
 380
 381 static const struct Errors utilitystrings[] =
 382 {
 383     {0, "unknown utility.library error" }
 384 };
 385
 386 static const struct Errors keymapstrings[] =
 387 {
 388     {0, "unknown keymap error" }
 389 };
 390
 391 static const struct Errors dfontstrings[] =
 392 {
 393     { 0, "unknown diskfont.library error" }
 394 };
 395
 396 static const struct Errors audiostrings[] =
 397 {
 398     { 0, "unknown audio.device error" }
 399 };
 400
 401 static const struct Errors consolestrings[] =
 402 {
 403     { AN_NoWindow, "can't open initial console window" },
 404     { 0, "unknown console.device error" }
 405 };
 406
 407 static const struct Errors gameportstrings[] =
 408 {
 409     { 0, "unknown gameport.device error" }
 410 };
 411
 412 static const struct Errors keyboardstrings[] =
 413 {
 414     { 0, "unknown keyboard.device error" }
 415 };
 416
 417 static const struct Errors trackdiskstrings[] =
 418 {
 419     { AN_TDCalibSeek,   "trackdisk calibrate seek error" },
 420     { 0, "unknown trackdisk.device error" }
 421 };
 422
 423 static const struct Errors timerstrings[] =
 424 {
 425     { AN_TMBadReq,      "bad timer request" },
 426     { AN_TMBadSupply,   "bad timer powersupply frequency" },
 427     { 0, "unknown timer.device error" }
 428 };
 429
 430 static const struct Errors ciastrings[] =
 431 {
 432     { 0, "unknown cia resource error" }
 433 };
 434
 435 static const struct Errors diskstrings[] =
 436 {
 437     { AN_DRHasDisk, "get disk unit, already has disk" },
 438     { AN_DRIntNoAct,"disk interrupt, no active unit" },
 439     { 0, "unknown disk.resource error" }
 440 };
 441
 442 static const struct Errors miscstrings[] =
 443 {
 444     { 0, "unknown misc.resource error" }
 445 };
 446
 447 static const struct Errors bootstrings[] =
 448 {
 449     { AN_BootError, "boot code returned an error" },
 450     { 0, "unknown bootstrap error" }
 451 };
 452
 453 static const struct Errors workbenchstrings[] =
 454 {
 455     { AN_NoFonts,           "no fonts for workbench" },
 456     { AN_WBBadStartupMsg1,  "bad startup message 1 for workbench" },
 457     { AN_WBBadStartupMsg2,  "bad startup message 2 for workbench" },
 458     { AN_WBBadIOMsg,        "bad IO message for workbench" },
 459     { AN_WBReLayoutToolMenu, "error with layout on tools menu" },
 460     { 0, "unknown workbench error" }
 461 };
 462
 463 static const struct Errors diskcopystrings[] =
 464 {
 465     {0, "unknown diskcopy error" }
 466 };
 467
 468 static const struct Errors gadtoolsstrings[] =
 469 {
 470     {0, "unknown gadtools.library error" }
 471 };
 472
 473 static const struct Errors arosstrings[] =
 474 {
 475     {0, "unknown aros.library error" }
 476 };
 477
 478 static const struct Errors oopstrings[] =
 479 {
 480     {0, "unknown oop.library error" }
 481 };
 482
 483 static const struct Errors hiddstrings[] =
 484 {
 485     {0, "unknown Hidd system error" }
 486 };
 487
 488 static const struct Errors *const stringlist[] =
 489 {
 490     /* 0x00 */
 491     unknownstrings,
 492     execstrings,
 493     gfxstrings,
 494     layersstrings,
 495     intuistrings,
 496     mathstrings,
 497     unknownstrings,
 498     dosstrings,
 499     ramlibstrings,
 500     iconstrings,
 501     expanstrings,
 502     dfontstrings,
 503     utilitystrings,
 504     keymapstrings,
 505     unknownstrings,
 506     unknownstrings,
 507
 508     /* 0x10 */
 509     audiostrings,
 510     consolestrings,
 511     gameportstrings,
 512     keyboardstrings,
 513     trackdiskstrings,
 514     timerstrings,
 515     unknownstrings,
 516     unknownstrings,
 517     unknownstrings,
 518     unknownstrings,
 519     unknownstrings,
 520     unknownstrings,
 521     unknownstrings,
 522     unknownstrings,
 523     unknownstrings,
 524     unknownstrings,
 525
 526     /* 0x20 */
 527     ciastrings,
 528     diskstrings,
 529     miscstrings,
 530     unknownstrings,
 531     unknownstrings,
 532     unknownstrings,
 533     unknownstrings,
 534     unknownstrings,
 535     unknownstrings,
 536     unknownstrings,
 537     unknownstrings,
 538     unknownstrings,
 539     unknownstrings,
 540     unknownstrings,
 541     unknownstrings,
 542     unknownstrings,
 543
 544     /* 0x30 */
 545     bootstrings,
 546     workbenchstrings,
 547     diskcopystrings,
 548     gadtoolsstrings,
 549     unknownstrings,
 550     unknownstrings,
 551     unknownstrings,
 552     unknownstrings,
 553     unknownstrings,
 554     unknownstrings,
 555     unknownstrings,
 556     unknownstrings,
 557     unknownstrings,
 558     unknownstrings,
 559     unknownstrings,
 560     unknownstrings,
 561
 562     /* 0x40 */
 563     arosstrings,
 564     oopstrings,
 565     hiddstrings
 566 };
 567
 568 /* Decode the alert number, and try and work out what string to get */
 569 STRPTR getGuruString(ULONG alertnum, STRPTR buf)
 570 {
 571     /* Is this a CPU alert? */
 572     if((alertnum & 0x7f008000) == 0)
 573     {
 574         /* Yes */
 575         buf = getString(buf, alertnum, cpustrings);
 576     }
 577     /* Is this a General alert */
 578     else if((alertnum & 0x8000) == 0x8000)
 579     {
 580         UBYTE type = (alertnum & 0x00FF0000) >> 16;
 581         UWORD obj  = (alertnum & 0x7fff);
 582         UBYTE subsys = (alertnum & 0x7f000000) >> 24;
 583
 584         buf = getString(buf, obj, subsystems);
 585         buf = getString(&buf[-1], type, types);
 586         buf = getString(&buf[-1], subsys, subsystems);
 587     }
 588     /* This must be a specific alert */
 589     else
 590     {
 591         UBYTE subsys = (alertnum & 0x7f000000) >> 24;
 592
 593         if(subsys < 0x80)
 594             buf = getString(buf, alertnum, stringlist[subsys]);
 595         else
 596             buf = mystrcpy(buf, "unknown error", -1);
 597     }
 598
 599     return buf;
 600 }