rom/exec/alertstrings.c

   1 /*
   2  * A library of alert strings and useful functions.
   3  * Used by platform-specific Alert() implementations
   4  */
   5
   6 #include <aros/debug.h>
   7 #include <exec/alerts.h>
   8 #include <exec/rawfmt.h>
   9 #include <exec/tasks.h>
  10 #include <proto/kernel.h>
  11
  12 #include "etask.h"
  13 #include "exec_intern.h"
  14 #include "exec_util.h"
  15
  16 struct Errors
  17 {
  18     ULONG   number;
  19     STRPTR  string;
  20 };
  21
  22 /* Get a string from an array of type Errors. */
  23 static STRPTR getString(ULONG alertnum, const struct Errors *errs)
  24 {
  25     /* Some of alert codes have AT_DeadEnd bit set, others have it reset.
  26        However in real life AT_DeadEnd bit may be set for any error, so
  27        we mask it out for comparison */
  28     alertnum &= ~AT_DeadEnd;
  29
  30     while((errs->number) && ((errs->number & ~AT_DeadEnd) != alertnum))
  31     {
  32         errs++;
  33     }
  34     return errs->string;
  35 }
  36
  37 static const struct Errors cpustrings[] =
  38 {
  39     { ACPU_BusErr,      "Hardware bus fault/address error" },
  40     { ACPU_AddressErr,  "Illegal address access (odd)" },
  41     { ACPU_InstErr,     "Illegal instruction" },
  42     { ACPU_DivZero,     "Division by zero" },
  43     { ACPU_CHK,         "CHK instruction error" },
  44     { ACPU_TRAPV,       "TRAPV instruction error" },
  45     { ACPU_PrivErr,     "Priviledge violation error" },
  46     { ACPU_Trace,       "Trace error" },
  47     { ACPU_LineA,       "Line 1010 (A) E mulator error" },
  48     { ACPU_LineF,       "Line 1111 (F) Emulator/Coprocessor error" },
  49     { ACPU_Format,      "Stack frame format error" },
  50     { ACPU_Spurious,    "Spurious interrupt error" },
  51     { 0, "Unknown CPU error" }
  52 };
  53
  54 static const struct Errors subsystems[] =
  55 {
  56     { 0x01,     "exec.library " },
  57     { 0x02,     "graphics.library " },
  58     { 0x03,     "layers.library " },
  59     { 0x04,     "intuition.library " },
  60     { 0x05,     "math.library " },
  61     { 0x07,     "dos.library " },
  62     { 0x08,     "ramlib " },
  63     { 0x09,     "icon.library " },
  64     { 0x0a,     "expansion.library " },
  65     { 0x0b,     "diskfont.library " },
  66     { 0x10,     "audio.device " },
  67     { 0x11,     "console.device " },
  68     { 0x12,     "gameport.device " },
  69     { 0x13,     "keyboard.device " },
  70     { 0x14,     "trackdisk.device " },
  71     { 0x15,     "timer.device " },
  72     { 0x20,     "cia.resource " },
  73     { 0x21,     "disk.resource " },
  74     { 0x22,     "misc.resource " },
  75     { 0x30,     "bootstrap " },
  76     { 0x31,     "workbench " },
  77     { 0x32,     "diskcopy " },
  78     { 0x33,     "gadtools " },
  79     { 0x34,     "utility " },
  80
  81     { 0x40,     "aros " },
  82     { 0x41,     "oop " },
  83     { 0x42,     "hidd " },
  84
  85     /* This takes in 0x35 as well... */
  86     { 0x00,     "unknown " }
  87 };
  88
  89 static const struct Errors types[] =
  90 {
  91     { 0x01,     "no memory for " },
  92     { 0x02,     "could not make library " },
  93     { 0x03,     "could not open library " },
  94     { 0x04,     "could not open device " },
  95     { 0x05,     "could not open resource " },
  96     { 0x06,     "IO error with " },
  97     { 0x07,     "no signal for/from " },
  98     { 0x08,     "bad parameter for/from " },
  99     { 0x09,     "close library error with " },
 100     { 0x0a,     "close device error with " },
 101     { 0x0b,     "process creating failure with " },
 102     { 0x00,     "unknown problem with "}
 103 };
 104
 105 static const struct Errors execstrings[] =
 106 {
 107     { AN_ExcptVect,     "MC68k Exception vector checksum" },
 108     { AN_BaseChkSum,    "ExecBase checksum" },
 109     { AN_LibChkSum,     "Library checksum failure" },
 110     { AN_MemCorrupt,    "Corrupt memory list detected" },
 111     { AN_IntrMem,       "No memory for interrupt servers" },
 112     { AN_InitAPtr,      "(obs) InitStruct of an APTR" },
 113     { AN_SemCorrupt,    "Semaphore in an illegal state" },
 114     { AN_FreeTwice,     "Memory freed twice" },
 115     { AN_BogusExcpt,    "Illegal mc68k exception taken" },
 116     { AN_IOUsedTwice,   "Attempt to reuse active IORequest" },
 117     { AN_MemoryInsane,  "Sanity check on memory list failed" },
 118     { AN_IOAfterClose,  "Attempt to use IORequest after close" },
 119     { AN_StackProbe,    "Stack extends out of range" },
 120     { AN_BadFreeAddr,   "Memory header not located" },
 121     { AN_BadSemaphore,  "Attempt to use the old message semaphore" },
 122     { 0, "unknown exec.library error" }
 123 };
 124
 125 static const struct Errors gfxstrings[] =
 126 {
 127     { AN_GfxNoMem,      "Graphics out of memory" },
 128     { AN_GfxNoMemMspc,  "No memory to allocate MonitorSpec" },
 129     { AN_LongFrame,     "No memory for long frame" },
 130     { AN_ShortFrame,    "No memory for short frame" },
 131     { AN_TextTmpRas,    "Mo memory for TmpRas" },
 132     { AN_BltBitMap,     "No memory for BltBitMap" },
 133     { AN_RegionMemory,  "No memory for Region" },
 134     { AN_MakeVPort,     "No memory for MakeVPort" },
 135     { AN_GfxNewError,   "Error in GfxNew()" },
 136     { AN_GfxFreeError,  "Error in GfxFree()" },
 137     { AN_GfxNoLCM,      "Emergency memory not available" },
 138     { AN_ObsoleteFont,  "Unsupported font description used" },
 139     { 0, "unknown graphics.library error" }
 140 };
 141
 142 static const struct Errors unknownstrings[] =
 143 {
 144     { 0, "unknown error" }
 145 };
 146
 147 static const struct Errors layersstrings[] =
 148 {
 149     { AN_LayersNoMem,   "layers: no memory" },
 150     { 0, "unknown layers.library error" }
 151 };
 152
 153 static const struct Errors intuistrings[] =
 154 {
 155     { AN_GadgetType,    "intuition: unknown gadget type" },
 156     { AN_CreatePort,    "intuition couldn't create port, no memory" },
 157     { AN_ItemAlloc,     "no memory for menu item" },
 158     { AN_SubAlloc,      "no memory for menu subitem" },
 159     { AN_PlaneAlloc,    "no memory for bitplane" },
 160     { AN_ItemBoxTop,    "top of item box < RelZero" },
 161     { AN_OpenScreen,    "no memory for OpenScreen()" },
 162     { AN_OpenScrnRast,  "no memory for OpenScreen() raster" },
 163     { AN_SysScrnType,   "unknown type of system screen" },
 164     { AN_AddSWGadget,   "add SW gadgets, no memory" },
 165     { AN_OpenWindow,    "no memory for OpenWindow()" },
 166     { AN_BadState,      "bad state return entering intuition" },
 167     { AN_BadMessage,    "bad message received by IDCMP" },
 168     { AN_WeirdEcho,     "weird echo causing incomprehension" },
 169     { AN_NoConsole,     "couldn't open the console.device" },
 170     { AN_NoISem,        "intuition skipped obtaining a semaphore" },
 171     { AN_ISemOrder,     "intuition got a semaphore in wrong order" },
 172     { 0, "unknown intuition.library error" }
 173 };
 174
 175 static const struct Errors mathstrings[] =
 176 {
 177     { 0, "unknown math library error" }
 178 };
 179
 180 static const struct Errors dosstrings[] =
 181 {
 182     { AN_StartMem,      "no memory at startup" },
 183     { AN_EndTask,       "EndTask did not end task" },
 184     { AN_QPktFail,      "QPkt failure" },
 185     { AN_AsyncPkt,      "unexpected DOS packet received" },
 186     { AN_FreeVec,       "freevec failed" },
 187     { AN_DiskBlkSeq,    "disk block sequence error" },
 188     { AN_BitMap,        "disk bitmap corrupt" },
 189     { AN_KeyFree,       "disk key already free" },
 190     { AN_BadChkSum,     "disk checksum bad" },
 191     { AN_DiskError,     "disk error" },
 192     { AN_KeyRange,      "disk key out of range" },
 193     { AN_BadOverlay,    "bad overlay" },
 194     { AN_BadInitFunc,   "invalid initialization packet for cli/shell" },
 195     { AN_FileReclosed,  "filehandle closed more than once" },
 196     { 0, "unknown dos.library error" }
 197 };
 198
 199 static const struct Errors ramlibstrings[] =
 200 {
 201     { AN_BadSegList,    "bad library seglist" },
 202     { 0, "unknown ramlib/lddemon error" }
 203 };
 204
 205 static const struct Errors iconstrings[] =
 206 {
 207     { 0, "unknown icon.library error" }
 208 };
 209
 210 static const struct Errors expanstrings[] =
 211 {
 212     { AN_BadExpansionFree,  "expansion freeing region already freed"},
 213     { 0, "unknown expansion.library error" }
 214 };
 215
 216 static const struct Errors utilitystrings[] =
 217 {
 218     {0, "unknown utility.library error" }
 219 };
 220
 221 static const struct Errors keymapstrings[] =
 222 {
 223     {0, "unknown keymap error" }
 224 };
 225
 226 static const struct Errors dfontstrings[] =
 227 {
 228     { 0, "unknown diskfont.library error" }
 229 };
 230
 231 static const struct Errors audiostrings[] =
 232 {
 233     { 0, "unknown audio.device error" }
 234 };
 235
 236 static const struct Errors consolestrings[] =
 237 {
 238     { AN_NoWindow, "can't open initial console window" },
 239     { 0, "unknown console.device error" }
 240 };
 241
 242 static const struct Errors gameportstrings[] =
 243 {
 244     { 0, "unknown gameport.device error" }
 245 };
 246
 247 static const struct Errors keyboardstrings[] =
 248 {
 249     { 0, "unknown keyboard.device error" }
 250 };
 251
 252 static const struct Errors trackdiskstrings[] =
 253 {
 254     { AN_TDCalibSeek,   "trackdisk calibrate seek error" },
 255     { 0, "unknown trackdisk.device error" }
 256 };
 257
 258 static const struct Errors timerstrings[] =
 259 {
 260     { AN_TMBadReq,      "bad timer request" },
 261     { AN_TMBadSupply,   "bad timer powersupply frequency" },
 262     { 0, "unknown timer.device error" }
 263 };
 264
 265 static const struct Errors ciastrings[] =
 266 {
 267     { 0, "unknown cia resource error" }
 268 };
 269
 270 static const struct Errors diskstrings[] =
 271 {
 272     { AN_DRHasDisk, "get disk unit, already has disk" },
 273     { AN_DRIntNoAct,"disk interrupt, no active unit" },
 274     { 0, "unknown disk.resource error" }
 275 };
 276
 277 static const struct Errors miscstrings[] =
 278 {
 279     { 0, "unknown misc.resource error" }
 280 };
 281
 282 static const struct Errors bootstrings[] =
 283 {
 284     { AN_BootError, "boot code returned an error" },
 285     { 0, "unknown bootstrap error" }
 286 };
 287
 288 static const struct Errors workbenchstrings[] =
 289 {
 290     { AN_NoFonts,           "no fonts for workbench" },
 291     { AN_WBBadStartupMsg1,  "bad startup message 1 for workbench" },
 292     { AN_WBBadStartupMsg2,  "bad startup message 2 for workbench" },
 293     { AN_WBBadIOMsg,        "bad IO message for workbench" },
 294     { AN_WBReLayoutToolMenu, "error with layout on tools menu" },
 295     { 0, "unknown workbench error" }
 296 };
 297
 298 static const struct Errors diskcopystrings[] =
 299 {
 300     {0, "unknown diskcopy error" }
 301 };
 302
 303 static const struct Errors gadtoolsstrings[] =
 304 {
 305     {0, "unknown gadtools.library error" }
 306 };
 307
 308 static const struct Errors arosstrings[] =
 309 {
 310     {0, "unknown aros.library error" }
 311 };
 312
 313 static const struct Errors oopstrings[] =
 314 {
 315     {0, "unknown oop.library error" }
 316 };
 317
 318 static const struct Errors hiddstrings[] =
 319 {
 320     {0, "unknown Hidd system error" }
 321 };
 322
 323 static const struct Errors *const stringlist[] =
 324 {
 325     /* 0x00 */
 326     unknownstrings,
 327     execstrings,
 328     gfxstrings,
 329     layersstrings,
 330     intuistrings,
 331     mathstrings,
 332     unknownstrings,
 333     dosstrings,
 334     ramlibstrings,
 335     iconstrings,
 336     expanstrings,
 337     dfontstrings,
 338     utilitystrings,
 339     keymapstrings,
 340     unknownstrings,
 341     unknownstrings,
 342
 343     /* 0x10 */
 344     audiostrings,
 345     consolestrings,
 346     gameportstrings,
 347     keyboardstrings,
 348     trackdiskstrings,
 349     timerstrings,
 350     unknownstrings,
 351     unknownstrings,
 352     unknownstrings,
 353     unknownstrings,
 354     unknownstrings,
 355     unknownstrings,
 356     unknownstrings,
 357     unknownstrings,
 358     unknownstrings,
 359     unknownstrings,
 360
 361     /* 0x20 */
 362     ciastrings,
 363     diskstrings,
 364     miscstrings,
 365     unknownstrings,
 366     unknownstrings,
 367     unknownstrings,
 368     unknownstrings,
 369     unknownstrings,
 370     unknownstrings,
 371     unknownstrings,
 372     unknownstrings,
 373     unknownstrings,
 374     unknownstrings,
 375     unknownstrings,
 376     unknownstrings,
 377     unknownstrings,
 378
 379     /* 0x30 */
 380     bootstrings,
 381     workbenchstrings,
 382     diskcopystrings,
 383     gadtoolsstrings,
 384     unknownstrings,
 385     unknownstrings,
 386     unknownstrings,
 387     unknownstrings,
 388     unknownstrings,
 389     unknownstrings,
 390     unknownstrings,
 391     unknownstrings,
 392     unknownstrings,
 393     unknownstrings,
 394     unknownstrings,
 395     unknownstrings,
 396
 397     /* 0x40 */
 398     arosstrings,
 399     oopstrings,
 400     hiddstrings
 401 };
 402
 403 /* Similar to strcpy() but returns a pointer to the next byte beyond the
 404    copied string. Useful for concatenation. */
 405 STRPTR Alert_AddString(STRPTR dest, STRPTR src)
 406 {
 407     while(*src)
 408     {
 409         *dest++ = *src++;
 410     }
 411     return dest;
 412 }
 413
 414 STRPTR Alert_GetTitle(ULONG alertNum)
 415 {
 416     if(alertNum & AG_NoMemory)
 417         return "Not Enough Memory!";
 418     else if(alertNum & AT_DeadEnd)
 419         return "Software Failure!";
 420     else
 421         return "Recoverable Alert!";
 422 }
 423
 424 STRPTR Alert_GetTaskName(struct Task *task)
 425 {
 426     STRPTR tname;
 427
 428     /* Find out the task name. The node type must be correct. */
 429     if (task && ((task->tc_Node.ln_Type == NT_TASK) || (task->tc_Node.ln_Type == NT_PROCESS))
 430        && (task->tc_Node.ln_Name != NULL))
 431         tname = task->tc_Node.ln_Name;
 432     else
 433         tname = "--task not found--";
 434     return tname;
 435 }
 436
 437 /* Decode the alert number, and try and work out what string to get */
 438 STRPTR Alert_GetString(ULONG alertnum, STRPTR buf)
 439 {
 440     /* Is this a CPU alert? */
 441     if((alertnum & 0x7f008000) == 0)
 442     {
 443         /* Yes */
 444         buf = Alert_AddString(buf, getString(alertnum, cpustrings));
 445     }
 446     /* Is this a General alert */
 447     else if((alertnum & 0x8000) == 0x8000)
 448     {
 449         UBYTE type = (alertnum & 0x00FF0000) >> 16;
 450         UWORD obj  = (alertnum & 0x7fff);
 451         UBYTE subsys = (alertnum & 0x7f000000) >> 24;
 452
 453         buf = Alert_AddString(buf, getString(obj, subsystems));
 454         buf = Alert_AddString(buf, getString(type, types));
 455         buf = Alert_AddString(buf, getString(subsys, subsystems));
 456     }
 457     /* This must be a specific alert */
 458     else
 459     {
 460         UBYTE subsys = (alertnum & 0x7f000000) >> 24;
 461
 462         if(subsys < 0x80)
 463             buf = Alert_AddString(buf, getString(alertnum, stringlist[subsys]));
 464         else
 465             buf = Alert_AddString(buf, "unknown error");
 466     }
 467
 468     *buf = 0;
 469     return buf;
 470 }
 471
 472 static char *hdrstring = "Task : 0x%P - %s\n"
 473                          "Error: 0x%08lx - ";
 474 static char *locstring = "PC   : 0x%P\n";
 475 static char *modstring = "Module %s Segment %lu %s (0x%P) Offset 0x%P\n";
 476 static char *funstring = "Function %s (0x%P) Offset 0x%P\n";
 477
 478 STRPTR FormatAlert(char *buffer, ULONG alertNum, struct Task *task, struct ExecBase *SysBase)
 479 {
 480     char *buf;
 481
 482     buf = NewRawDoFmt(hdrstring, RAWFMTFUNC_STRING, buffer, task, Alert_GetTaskName(task), alertNum);
 483     buf = Alert_GetString(alertNum, --buf);
 484     *buf++ = '\n';
 485     D(bug("[FormatAlert] Header:\n%s\n", buffer));
 486
 487     if (task)
 488     {
 489         struct IntETask *iet = GetIntETask(task);
 490
 491         if (iet->iet_AlertLocation)
 492         {
 493             char *modname, *segname, *symname;
 494             void *segaddr, *symaddr;
 495             unsigned int segnum;
 496
 497             buf = NewRawDoFmt(locstring, RAWFMTFUNC_STRING, buf, iet->iet_AlertLocation);
 498             D(bug("[FormatAlert] Location string:\n%s\n", buffer));
 499
 500 #ifdef KrnDecodeLocation
 501             if (KrnDecodeLocation(iet->iet_AlertLocation,
 502                                   KDL_ModuleName , &modname, KDL_SegmentNumber, &segnum ,
 503                                   KDL_SegmentName, &segname, KDL_SegmentStart , &segaddr,
 504                                   KDL_SymbolName , &symname, KDL_SymbolStart  , &symaddr,
 505                                   TAG_DONE))
 506             {
 507                 if (!segname)
 508                     segname = "- unknown -";
 509
 510                 buf = NewRawDoFmt(modstring, RAWFMTFUNC_STRING, --buf, modname, segnum, segname, segaddr, iet->iet_AlertLocation - segaddr);
 511
 512                 if (symaddr)
 513                 {
 514                     if (!symname)
 515                         symname = "- unknown -";
 516
 517                     buf = NewRawDoFmt(funstring, RAWFMTFUNC_STRING, --buf, symname, symaddr, iet->iet_AlertLocation - symaddr);
 518                 }
 519             }
 520 #endif
 521             /* After NewRawDoFmt() buf points to the character AFTER null terminator */
 522             buf--;
 523         }
 524     }
 525
 526     *buf = 0;
 527     return buf;
 528 }