1 /* xscreensaver, Copyright (c) 1998-2006 Jamie Zawinski <jwz@jwz.org>
3 * Permission to use, copy, modify, distribute, and sell this software and its
4 * documentation for any purpose is hereby granted without fee, provided that
5 * the above copyright notice appear in all copies and that both that
6 * copyright notice and this permission notice appear in supporting
7 * documentation. No representations are made about the suitability of this
8 * software for any purpose. It is provided "as is" without express or
11 * Blue Screen of Death: the finest in personal computer emulation.
12 * Concept cribbed from Stephen Martin <smartin@mks.com>;
13 * this version written by jwz, 4-Jun-98.
14 * Mostly rewritten by jwz, 20-Feb-2006.
20 - Define a function `new_os(dpy,win)' that returns a `bsod_state' struct.
21 - Draw on the window to set up its frame-zero state. This must be fast:
22 no sleeping or long loops!
23 - Populate the bsod_state structure with additional actions to take by
24 using the various BSOD_ macros. Note that you can control the delays
25 when printing text on a per-character or per-line basis.
26 - Insert your function in the `all_modes' table.
27 - Add a `doXXX' entry to `bsod_defaults'.
28 - Add fonts or colors to `bsod_defaults' if necessary.
30 Look at windows_31() for a simple example.
32 Look at linux_fsck() for a more complicated example with random behavior.
34 Or, you can bypass all that: look at nvidia() for a really hairy example.
38 #include "screenhack.h"
39 #include "xpm-pixmap.h"
44 #ifdef HAVE_XSHM_EXTENSION
49 # include <sys/utsname.h>
50 #endif /* HAVE_UNAME */
52 #if defined(HAVE_GDK_PIXBUF) || defined(HAVE_XPM) || defined(HAVE_COCOA)
57 # include "images/amiga.xpm"
58 # include "images/hmac.xpm"
59 # include "images/osx_10_2.xpm"
60 # include "images/osx_10_3.xpm"
62 #include "images/atari.xbm"
63 #include "images/mac.xbm"
64 #include "images/macbomb.xbm"
65 #include "images/atm.xbm"
68 #define countof(x) (sizeof((x))/sizeof((*x)))
73 LEFT_FULL, CENTER_FULL, RIGHT_FULL,
74 COLOR, INVERT, MOVETO, MARGINS,
75 CURSOR_BLOCK, CURSOR_LINE, RECT, COPY, PIXMAP, IMG,
76 PAUSE, CHAR_DELAY, LINE_DELAY,
82 void *arg1, *arg2, *arg3, *arg4, *arg5, *arg6;
88 XWindowAttributes xgwa;
92 int left_margin, right_margin; /* for text wrapping */
93 int top_margin, bottom_margin; /* for text scrolling */
97 Pixmap pixmap; /* Source image used by BSOD_PIXMAP */
99 int x, y; /* current text-drawing position */
100 int current_left; /* don't use this */
102 int pos; /* position in queue */
104 struct bsod_event *queue;
106 unsigned long char_delay; /* delay between printing characters */
107 unsigned long line_delay; /* delay between printing lines */
109 Bool macx_eol_kludge;
112 int (*draw_cb) (struct bsod_state *);
113 void (*free_cb) (struct bsod_state *);
115 async_load_state *img_loader;
119 # if !defined(__GNUC__) && !defined(__extension__)
120 /* don't warn about "string length is greater than the length ISO C89
121 compilers are required to support" in these string constants... */
122 # define __extension__ /**/
126 /* Draw text at the current position; align is LEFT, CENTER, RIGHT, or *_FULL
127 (meaning to clear the whole line margin to margin).
129 #define BSOD_TEXT(bst,align,string) do { \
130 ensure_queue (bst); \
131 (bst)->queue[(bst)->pos].type = (align); \
132 (bst)->queue[(bst)->pos].arg1 = (void *) strdup (__extension__ (string)); \
133 (bst)->queue[(bst)->pos].arg2 = (bst)->queue[(bst)->pos].arg1; \
134 (bst)->queue[(bst)->pos].arg3 = (void *) 0; \
138 /* Flip the foreground and background colors
140 #define BSOD_INVERT(bst) do { \
141 ensure_queue (bst); \
142 (bst)->queue[(bst)->pos].type = INVERT; \
146 /* Set the foreground and background colors to the given pixels
148 #define BSOD_COLOR(bst,fg,bg) do { \
149 ensure_queue (bst); \
150 (bst)->queue[(bst)->pos].type = COLOR; \
151 (bst)->queue[(bst)->pos].arg1 = (void *) fg; \
152 (bst)->queue[(bst)->pos].arg2 = (void *) bg; \
156 /* Set the position of the next text.
157 Note that this is the baseline: lower left corner of next char printed.
159 #define BSOD_MOVETO(bst,x,y) do { \
160 ensure_queue (bst); \
161 (bst)->queue[(bst)->pos].type = MOVETO; \
162 (bst)->queue[(bst)->pos].arg1 = (void *) ((long) (x)); \
163 (bst)->queue[(bst)->pos].arg2 = (void *) ((long) (y)); \
167 /* Delay for at least the given number of microseconds.
169 #define BSOD_PAUSE(bst,usec) do { \
170 ensure_queue (bst); \
171 (bst)->queue[(bst)->pos].type = PAUSE; \
172 (bst)->queue[(bst)->pos].arg1 = (void *) ((long) (usec)); \
176 /* Set the delay after each character is printed.
178 #define BSOD_CHAR_DELAY(bst,usec) do { \
179 ensure_queue (bst); \
180 (bst)->queue[(bst)->pos].type = CHAR_DELAY; \
181 (bst)->queue[(bst)->pos].arg1 = (void *) ((long) (usec)); \
185 /* Set the delay after each newline.
187 #define BSOD_LINE_DELAY(bst,usec) do { \
188 ensure_queue (bst); \
189 (bst)->queue[(bst)->pos].type = LINE_DELAY; \
190 (bst)->queue[(bst)->pos].arg1 = (void *) (usec); \
194 /* Set the prevailing left/right margins (used when strings have
195 embedded newlines, and when centering or right-justifying text.)
197 #define BSOD_MARGINS(bst,left,right) do { \
198 ensure_queue (bst); \
199 (bst)->queue[(bst)->pos].type = MARGINS; \
200 (bst)->queue[(bst)->pos].arg1 = (void *) ((long) (left)); \
201 (bst)->queue[(bst)->pos].arg2 = (void *) ((long) (right)); \
205 /* Draw a blinking cursor; type is CURSOR_BLOCK or CURSOR_LINE.
206 usec is how long 1/2 of a cycle is. count is how many times to blink.
207 (You can pass a gigantic number if this is the last thing in your mode.)
209 #define BSOD_CURSOR(bst,ctype,usec,count) do { \
210 ensure_queue (bst); \
211 (bst)->queue[(bst)->pos].type = (ctype); \
212 (bst)->queue[(bst)->pos].arg1 = (void *) (usec); \
213 (bst)->queue[(bst)->pos].arg2 = (void *) (count); \
217 /* Draw or fill a rectangle. You can set line-width in the GC.
219 #define BSOD_RECT(bst,fill,x,y,w,h) do { \
220 ensure_queue (bst); \
221 (bst)->queue[(bst)->pos].type = RECT; \
222 (bst)->queue[(bst)->pos].arg1 = (void *) ((long) (fill)); \
223 (bst)->queue[(bst)->pos].arg2 = (void *) ((long) (x)); \
224 (bst)->queue[(bst)->pos].arg3 = (void *) ((long) (y)); \
225 (bst)->queue[(bst)->pos].arg4 = (void *) ((long) (w)); \
226 (bst)->queue[(bst)->pos].arg5 = (void *) ((long) (h)); \
230 /* Copy a rect from the window, to the window.
232 #define BSOD_COPY(bst,srcx,srcy,w,h,tox,toy) do { \
233 ensure_queue (bst); \
234 (bst)->queue[(bst)->pos].type = COPY; \
235 (bst)->queue[(bst)->pos].arg1 = (void *) ((long) (srcx)); \
236 (bst)->queue[(bst)->pos].arg2 = (void *) ((long) (srcy)); \
237 (bst)->queue[(bst)->pos].arg3 = (void *) ((long) (w)); \
238 (bst)->queue[(bst)->pos].arg4 = (void *) ((long) (h)); \
239 (bst)->queue[(bst)->pos].arg5 = (void *) ((long) (tox)); \
240 (bst)->queue[(bst)->pos].arg6 = (void *) ((long) (toy)); \
244 /* Copy a rect from bst->pixmap to the window.
246 #define BSOD_PIXMAP(bst,srcx,srcy,w,h,tox,toy) do { \
247 BSOD_COPY(bst,srcx,srcy,w,h,tox,toy); \
248 (bst)->queue[(bst)->pos-1].type = PIXMAP; \
251 /* Load a random image (or the desktop) onto the window.
253 #define BSOD_IMG(bst) do { \
254 ensure_queue (bst); \
255 (bst)->queue[(bst)->pos].type = IMG; \
259 /* Jump around in the state table. You can use this as the last thing
260 in your state table to repeat the last N elements forever.
262 #define BSOD_LOOP(bst,off) do { \
263 ensure_queue (bst); \
264 (bst)->queue[(bst)->pos].type = LOOP; \
265 (bst)->queue[(bst)->pos].arg1 = (void *) (off); \
271 ensure_queue (struct bsod_state *bst)
274 if (bst->pos + 1 < bst->queue_size)
277 n = bst->queue_size + 10;
281 bst->queue = (struct bsod_event *)
282 realloc (bst->queue, n * sizeof(*bst->queue));
283 if (!bst->queue) abort();
284 memset (bst->queue + bst->queue_size, 0,
285 (n - bst->queue_size) * sizeof(*bst->queue));
291 position_for_text (struct bsod_state *bst, const char *line)
295 const char *start = line;
297 if (bst->queue[bst->pos].type != LEFT &&
298 bst->queue[bst->pos].type != LEFT_FULL)
301 int dir, ascent, descent;
303 const char *end = start;
304 while (*end && *end != '\r' && *end != '\n')
307 XTextExtents (bst->font, start, end-start,
308 &dir, &ascent, &descent, &ov);
309 if (ov.width > max_width)
310 max_width = ov.width;
315 switch (bst->queue[bst->pos].type) {
318 bst->current_left = bst->left_margin;
322 bst->x = max_width - bst->right_margin;
323 bst->current_left = bst->x;
328 int w = (bst->xgwa.width - bst->left_margin - bst->right_margin -
331 bst->x = bst->left_margin + (w / 2);
332 bst->current_left = bst->x;
342 bst_crlf (struct bsod_state *bst)
344 int lh = bst->font->ascent + bst->font->descent;
345 bst->x = bst->current_left;
346 if (!bst->scroll_p ||
347 bst->y + lh < bst->xgwa.height - bst->bottom_margin)
351 int w = bst->xgwa.width - bst->right_margin - bst->left_margin;
352 int h = bst->xgwa.height - bst->top_margin - bst->bottom_margin;
353 XCopyArea (bst->dpy, bst->window, bst->window, bst->gc,
355 bst->top_margin + lh,
359 XClearArea (bst->dpy, bst->window,
360 bst->left_margin, bst->top_margin + h - lh, w, lh, False);
366 draw_char (struct bsod_state *bst, char c)
372 bst->x = bst->current_left;
376 if (bst->macx_eol_kludge)
378 /* Special case for the weird way OSX crashes print newlines... */
379 XDrawImageString (bst->dpy, bst->window, bst->gc,
380 bst->x, bst->y, " ", 1);
381 XDrawImageString (bst->dpy, bst->window, bst->gc,
383 bst->y + bst->font->ascent + bst->font->descent,
388 else if (c == '\b') /* backspace */
390 int cw = (bst->font->per_char
391 ? bst->font->per_char['n'-bst->font->min_char_or_byte2].width
392 : bst->font->min_bounds.width);
394 if (bst->x < bst->left_margin)
395 bst->x = bst->left_margin;
399 int dir, ascent, descent;
401 XTextExtents (bst->font, &c, 1, &dir, &ascent, &descent, &ov);
404 bst->x + ov.width > bst->xgwa.width - bst->right_margin)
407 XDrawImageString (bst->dpy, bst->window, bst->gc,
408 bst->x, bst->y, &c, 1);
415 bsod_pop (struct bsod_state *bst)
417 bsod_event_type type = bst->queue[bst->pos].type;
420 return bst->draw_cb (bst);
422 if (bst->pos < 0) /* already done */
427 case LEFT: case LEFT_FULL:
428 case CENTER: case CENTER_FULL:
429 case RIGHT: case RIGHT_FULL:
431 const char *s = (const char *) bst->queue[bst->pos].arg2;
436 long delay = bst->line_delay;
438 bst->current_left = bst->left_margin;
442 if (! bst->queue[bst->pos].arg3) /* "done once" */
444 position_for_text (bst, s);
445 bst->queue[bst->pos].type = LEFT;
447 if (type == CENTER_FULL ||
451 XSetForeground (bst->dpy, bst->gc, bst->bg);
452 XFillRectangle (bst->dpy, bst->window, bst->gc,
454 bst->y - bst->font->ascent,
456 bst->font->ascent + bst->font->descent);
457 XSetForeground (bst->dpy, bst->gc, bst->fg);
463 bst->queue[bst->pos].arg2 = (void *) s;
464 bst->queue[bst->pos].arg3 = (void *) 1; /* "done once" */
466 return (c == '\r' || c == '\n'
472 unsigned long swap = bst->fg;
475 XSetForeground (bst->dpy, bst->gc, bst->fg);
476 XSetBackground (bst->dpy, bst->gc, bst->bg);
482 bst->fg = (unsigned long) bst->queue[bst->pos].arg1;
483 bst->bg = (unsigned long) bst->queue[bst->pos].arg2;
484 XSetForeground (bst->dpy, bst->gc, bst->fg);
485 XSetBackground (bst->dpy, bst->gc, bst->bg);
491 bst->x = (long) bst->queue[bst->pos].arg1;
492 bst->y = (long) bst->queue[bst->pos].arg2;
498 int f = (long) bst->queue[bst->pos].arg1;
499 int x = (long) bst->queue[bst->pos].arg2;
500 int y = (long) bst->queue[bst->pos].arg3;
501 int w = (long) bst->queue[bst->pos].arg4;
502 int h = (long) bst->queue[bst->pos].arg5;
504 XFillRectangle (bst->dpy, bst->window, bst->gc, x, y, w, h);
506 XDrawRectangle (bst->dpy, bst->window, bst->gc, x, y, w, h);
513 int srcx = (long) bst->queue[bst->pos].arg1;
514 int srcy = (long) bst->queue[bst->pos].arg2;
515 int w = (long) bst->queue[bst->pos].arg3;
516 int h = (long) bst->queue[bst->pos].arg4;
517 int tox = (long) bst->queue[bst->pos].arg5;
518 int toy = (long) bst->queue[bst->pos].arg6;
520 (type == PIXMAP ? bst->pixmap : bst->window),
521 bst->window, bst->gc,
522 srcx, srcy, w, h, tox, toy);
528 if (bst->img_loader) abort();
529 bst->img_loader = load_image_async_simple (0, bst->xgwa.screen,
530 bst->window, bst->window,
537 long delay = (long) bst->queue[bst->pos].arg1;
543 bst->char_delay = (long) bst->queue[bst->pos].arg1;
549 bst->line_delay = (long) bst->queue[bst->pos].arg1;
555 bst->left_margin = (long) bst->queue[bst->pos].arg1;
556 bst->right_margin = (long) bst->queue[bst->pos].arg2;
563 long delay = (long) bst->queue[bst->pos].arg1;
564 long count = (long) bst->queue[bst->pos].arg2;
567 if (type == CURSOR_BLOCK)
569 unsigned long swap = bst->fg;
572 XSetForeground (bst->dpy, bst->gc, bst->fg);
573 XSetBackground (bst->dpy, bst->gc, bst->bg);
574 draw_char (bst, ' ');
578 draw_char (bst, (count & 1 ? ' ' : '_'));
579 draw_char (bst, ' ');
585 bst->queue[bst->pos].arg2 = (void *) count;
593 long off = (long) bst->queue[bst->pos].arg1;
595 if (bst->pos < 0 || bst->pos >= bst->queue_size)
611 static struct bsod_state *
612 make_bsod_state (Display *dpy, Window window,
613 const char *name, const char *class)
616 struct bsod_state *bst;
617 char buf1[1024], buf2[1024];
618 char buf3[1024], buf4[1024];
619 const char *font1, *font2;
621 bst = (struct bsod_state *) calloc (1, sizeof (*bst));
622 bst->queue_size = 10;
623 bst->queue = (struct bsod_event *) calloc (bst->queue_size,
624 sizeof (*bst->queue));
626 bst->window = window;
627 XGetWindowAttributes (dpy, window, &bst->xgwa);
629 /* If the window is small:
630 use ".font" if it is loadable, else use ".font2".
632 If the window is big:
633 use ".bigFont" if it is loadable, else use ".bigFont2".
635 if (bst->xgwa.height < 640)
637 sprintf (buf1, "%.100s.font", name);
638 sprintf (buf2, "%.100s.font", class);
639 sprintf (buf3, "%.100s.font2", name);
640 sprintf (buf4, "%.100s.font2", class);
644 sprintf (buf1, "%.100s.bigFont", name);
645 sprintf (buf2, "%.100s.bigFont", class);
646 sprintf (buf3, "%.100s.bigFont2", name);
647 sprintf (buf4, "%.100s.bigFont2", class);
650 font1 = get_string_resource (dpy, buf1, buf2);
651 font2 = get_string_resource (dpy, buf3, buf4);
654 bst->font = XLoadQueryFont (dpy, font1);
655 if (! bst->font && font2)
656 bst->font = XLoadQueryFont (dpy, font2);
658 /* If neither of those worked, try some defaults. */
661 bst->font = XLoadQueryFont (dpy,"-*-courier-bold-r-*-*-*-120-*-*-m-*-*-*");
663 bst->font = XLoadQueryFont (dpy, "fixed");
667 gcv.font = bst->font->fid;
669 sprintf (buf1, "%.100s.foreground", name);
670 sprintf (buf2, "%.100s.Foreground", class);
671 bst->fg = gcv.foreground = get_pixel_resource (dpy, bst->xgwa.colormap,
673 sprintf (buf1, "%.100s.background", name);
674 sprintf (buf2, "%.100s.Background", class);
675 bst->bg = gcv.background = get_pixel_resource (dpy, bst->xgwa.colormap,
677 bst->gc = XCreateGC (dpy, window, GCFont|GCForeground|GCBackground, &gcv);
680 jwxyz_XSetAntiAliasing (dpy, bst->gc, False);
683 bst->left_margin = bst->right_margin = 10;
684 bst->x = bst->left_margin;
685 bst->y = bst->font->ascent + bst->left_margin;
687 XSetWindowBackground (dpy, window, gcv.background);
693 free_bsod_state (struct bsod_state *bst)
700 XFreePixmap(bst->dpy, bst->pixmap);
702 XFreeFont (bst->dpy, bst->font);
703 XFreeGC (bst->dpy, bst->gc);
705 for (i = 0; i < bst->queue_size; i++)
706 switch (bst->queue[i].type) {
707 case LEFT: case LEFT_FULL:
708 case RIGHT: case RIGHT_FULL:
709 case CENTER: case CENTER_FULL:
710 free ((char *) bst->queue[i].arg1);
722 double_pixmap (Display *dpy, GC gc, Visual *visual, int depth, Pixmap pixmap,
723 int pix_w, int pix_h)
726 Pixmap p2 = XCreatePixmap(dpy, pixmap, pix_w*2, pix_h*2, depth);
727 XImage *i1 = XGetImage(dpy, pixmap, 0, 0, pix_w, pix_h, ~0L, ZPixmap);
728 XImage *i2 = XCreateImage(dpy, visual, depth, ZPixmap, 0, 0,
729 pix_w*2, pix_h*2, 8, 0);
730 i2->data = (char *) calloc(i2->height, i2->bytes_per_line);
731 for (y = 0; y < pix_h; y++)
732 for (x = 0; x < pix_w; x++)
734 unsigned long p = XGetPixel(i1, x, y);
735 XPutPixel(i2, x*2, y*2, p);
736 XPutPixel(i2, x*2+1, y*2, p);
737 XPutPixel(i2, x*2, y*2+1, p);
738 XPutPixel(i2, x*2+1, y*2+1, p);
740 free(i1->data); i1->data = 0;
742 XPutImage(dpy, p2, gc, i2, 0, 0, 0, 0, i2->width, i2->height);
743 free(i2->data); i2->data = 0;
745 XFreePixmap(dpy, pixmap);
750 /*****************************************************************************
751 *****************************************************************************/
753 static struct bsod_state *
754 windows_31 (Display *dpy, Window window)
756 struct bsod_state *bst = make_bsod_state (dpy, window, "windows", "Windows");
758 BSOD_TEXT (bst, CENTER, "Windows\n");
760 BSOD_TEXT (bst, CENTER,
761 "A fatal exception 0E has occured at F0AD:42494C4C\n"
762 "the current application will be terminated.\n"
764 "* Press any key to terminate the current application.\n"
765 "* Press CTRL+ALT+DELETE again to restart your computer.\n"
766 " You will lose any unsaved information in all applications.\n"
769 BSOD_TEXT (bst, CENTER, "Press any key to continue");
771 bst->y = ((bst->xgwa.height -
772 ((bst->font->ascent + bst->font->descent) * 9))
775 XClearWindow (dpy, window);
780 static struct bsod_state *
781 windows_nt (Display *dpy, Window window)
783 struct bsod_state *bst = make_bsod_state (dpy, window, "windows", "Windows");
785 BSOD_TEXT (bst, LEFT,
786 "*** STOP: 0x0000001E (0x80000003,0x80106fc0,0x8025ea21,0xfd6829e8)\n"
787 "Unhandled Kernel exception c0000047 from fa8418b4 (8025ea21,fd6829e8)\n"
789 "Dll Base Date Stamp - Name Dll Base Date Stamp - Name\n"
790 "80100000 2be154c9 - ntoskrnl.exe 80400000 2bc153b0 - hal.dll\n"
791 "80258000 2bd49628 - ncrc710.sys 8025c000 2bd49688 - SCSIPORT.SYS \n"
792 "80267000 2bd49683 - scsidisk.sys 802a6000 2bd496b9 - Fastfat.sys\n"
793 "fa800000 2bd49666 - Floppy.SYS fa810000 2bd496db - Hpfs_Rec.SYS\n"
794 "fa820000 2bd49676 - Null.SYS fa830000 2bd4965a - Beep.SYS\n"
795 "fa840000 2bdaab00 - i8042prt.SYS fa850000 2bd5a020 - SERMOUSE.SYS\n"
796 "fa860000 2bd4966f - kbdclass.SYS fa870000 2bd49671 - MOUCLASS.SYS\n"
797 "fa880000 2bd9c0be - Videoprt.SYS fa890000 2bd49638 - NCC1701E.SYS\n"
798 "fa8a0000 2bd4a4ce - Vga.SYS fa8b0000 2bd496d0 - Msfs.SYS\n"
799 "fa8c0000 2bd496c3 - Npfs.SYS fa8e0000 2bd496c9 - Ntfs.SYS\n"
800 "fa940000 2bd496df - NDIS.SYS fa930000 2bd49707 - wdlan.sys\n"
801 "fa970000 2bd49712 - TDI.SYS fa950000 2bd5a7fb - nbf.sys\n"
802 "fa980000 2bd72406 - streams.sys fa9b0000 2bd4975f - ubnb.sys\n"
803 "fa9c0000 2bd5bfd7 - usbser.sys fa9d0000 2bd4971d - netbios.sys\n"
804 "fa9e0000 2bd49678 - Parallel.sys fa9f0000 2bd4969f - serial.SYS\n"
805 "faa00000 2bd49739 - mup.sys faa40000 2bd4971f - SMBTRSUP.SYS\n"
806 "faa10000 2bd6f2a2 - srv.sys faa50000 2bd4971a - afd.sys\n"
807 "faa60000 2bd6fd80 - rdr.sys faaa0000 2bd49735 - bowser.sys\n"
809 "Address dword dump Dll Base - Name\n"
810 "801afc20 80106fc0 80106fc0 00000000 00000000 80149905 : "
811 "fa840000 - i8042prt.SYS\n"
812 "801afc24 80149905 80149905 ff8e6b8c 80129c2c ff8e6b94 : "
813 "8025c000 - SCSIPORT.SYS\n"
814 "801afc2c 80129c2c 80129c2c ff8e6b94 00000000 ff8e6b94 : "
815 "80100000 - ntoskrnl.exe\n"
816 "801afc34 801240f2 80124f02 ff8e6df4 ff8e6f60 ff8e6c58 : "
817 "80100000 - ntoskrnl.exe\n"
818 "801afc54 80124f16 80124f16 ff8e6f60 ff8e6c3c 8015ac7e : "
819 "80100000 - ntoskrnl.exe\n"
820 "801afc64 8015ac7e 8015ac7e ff8e6df4 ff8e6f60 ff8e6c58 : "
821 "80100000 - ntoskrnl.exe\n"
822 "801afc70 80129bda 80129bda 00000000 80088000 80106fc0 : "
823 "80100000 - ntoskrnl.exe\n"
825 "Kernel Debugger Using: COM2 (Port 0x2f8, Baud Rate 19200)\n"
826 "Restart and set the recovery options in the system control panel\n"
827 "or the /CRASHDEBUG system start option. If this message reappears,\n"
828 "contact your system administrator or technical support group."
831 bst->line_delay = 750;
833 XClearWindow (dpy, window);
838 static struct bsod_state *
839 windows_2k (Display *dpy, Window window)
841 struct bsod_state *bst = make_bsod_state (dpy, window, "windows", "Windows");
843 BSOD_TEXT (bst, LEFT,
844 "*** STOP: 0x000000D1 (0xE1D38000,0x0000001C,0x00000000,0xF09D42DA)\n"
845 "DRIVER_IRQL_NOT_LESS_OR_EQUAL \n"
847 "*** Address F09D42DA base at F09D4000, DateStamp 39f459ff - CRASHDD.SYS\n"
849 "Beginning dump of physical memory\n");
850 BSOD_PAUSE (bst, 4000000);
851 BSOD_TEXT (bst, LEFT,
852 "Physical memory dump complete. Contact your system administrator or\n"
853 "technical support group.\n");
855 bst->left_margin = 40;
856 bst->y = (bst->font->ascent + bst->font->descent) * 10;
857 bst->line_delay = 750;
859 XClearWindow (dpy, window);
864 static struct bsod_state *
865 windows_me (Display *dpy, Window window)
867 struct bsod_state *bst = make_bsod_state (dpy, window, "windows", "Windows");
869 BSOD_TEXT (bst, LEFT,
870 "Windows protection error. You need to restart your computer.\n\n"
872 BSOD_CURSOR (bst, CURSOR_LINE, 120000, 999999);
874 bst->left_margin = 40;
875 bst->y = ((bst->xgwa.height -
876 ((bst->font->ascent + bst->font->descent) * 3))
879 XClearWindow (dpy, window);
884 static struct bsod_state *
885 windows_xp (Display *dpy, Window window)
887 struct bsod_state *bst = make_bsod_state (dpy, window, "windows", "Windows");
889 BSOD_TEXT (bst, LEFT, /* From Wm. Rhodes <xscreensaver@27.org> */
890 "A problem has been detected and windows has been shut down to prevent "
892 "to your computer.\n"
894 "If this is the first time you've seen this Stop error screen,\n"
895 "restart your computer. If this screen appears again, follow\n"
898 "Check to be sure you have adequate disk space. If a driver is\n"
899 "identified in the Stop message, disable the driver or check\n"
900 "with the manufacturer for driver updates. Try changing video\n"
903 "Check with your hardware vendor for any BIOS updates. Disable\n"
904 "BIOS memory options such as caching or shadowing. If you need\n"
905 "to use Safe Mode to remove or disable components, restart your\n"
906 "computer, press F8 to select Advanced Startup Options, and then\n"
907 "select Safe Mode.\n"
909 "Technical information:\n"
911 "*** STOP: 0x0000007E (0xC0000005,0xF88FF190,0x0xF8975BA0,0xF89758A0)\n"
914 "*** EPUSBDSK.sys - Address F88FF190 base at FF88FE000, datestamp "
917 "Beginning dump of physical memory\n");
918 BSOD_PAUSE (bst, 4000000);
919 BSOD_TEXT (bst, LEFT,
920 "Physical memory dump complete.\n"
921 "Contact your system administrator or technical support group for "
925 XClearWindow (dpy, window);
930 static struct bsod_state *
931 windows_lh (Display *dpy, Window window)
933 struct bsod_state *bst =
934 make_bsod_state (dpy, window, "windowslh", "WindowsLH");
936 unsigned long fg = bst->fg;
937 unsigned long bg = bst->bg;
938 unsigned long bg2 = get_pixel_resource (dpy, bst->xgwa.colormap,
939 "windowslh.background2",
940 "WindowsLH.Background");
942 /* The "RSOD" that appeared with "Windows Longhorn 5048.050401-0536_x86fre"
943 As reported by http://joi.ito.com/RedScreen.jpg
945 BSOD_COLOR (bst, bg, bg2);
946 BSOD_TEXT (bst, CENTER_FULL, "Windows Boot Error\n");
947 BSOD_COLOR (bst, fg, bg);
948 BSOD_TEXT (bst, CENTER,
950 "Windows Boot Manager has experienced a problem.\n"
953 " Status: 0xc000000f\n"
957 " Info: An error occurred transferring exectuion." /* (sic) */
961 "You can try to recover the system with the Microsoft Windows "
963 "Tools. (You might need to restart the system manually.)\n"
965 "If the problem continues, please contact your system administrator "
969 BSOD_MOVETO (bst, bst->left_margin, bst->xgwa.height - bst->font->descent);
970 BSOD_COLOR (bst, bg, bg2);
971 BSOD_TEXT (bst, LEFT_FULL, " SPACE=Continue\n");
973 bst->y = bst->font->ascent;
975 XClearWindow (dpy, window);
980 static struct bsod_state *
981 windows_other (Display *dpy, Window window)
983 /* Lump all of the 2K-ish crashes together and select them randomly...
985 int which = (random() % 4);
987 case 0: return windows_2k (dpy, window); break;
988 case 1: return windows_me (dpy, window); break;
989 case 2: return windows_xp (dpy, window); break;
990 case 3: return windows_lh (dpy, window); break;
991 default: abort(); break;
996 /* SCO OpenServer 5 panic, by Tom Kelly <tom@ancilla.toronto.on.ca>
998 static struct bsod_state *
999 sco (Display *dpy, Window window)
1001 struct bsod_state *bst = make_bsod_state (dpy, window, "sco", "SCO");
1003 BSOD_TEXT (bst, LEFT,
1004 "Unexpected trap in kernel mode:\n"
1006 "cr0 0x80010013 cr2 0x00000014 cr3 0x00000000 tlb 0x00000000\n"
1007 "ss 0x00071054 uesp 0x00012055 efl 0x00080888 ipl 0x00000005\n"
1008 "cs 0x00092585 eip 0x00544a4b err 0x004d4a47 trap 0x0000000E\n"
1009 "eax 0x0045474b ecx 0x0042544b edx 0x57687920 ebx 0x61726520\n"
1010 "esp 0x796f7520 ebp 0x72656164 esi 0x696e6720 edi 0x74686973\n"
1011 "ds 0x3f000000 es 0x43494c48 fs 0x43525343 gs 0x4f4d4b53\n"
1013 "PANIC: k_trap - kernel mode trap type 0x0000000E\n"
1014 "Trying to dump 5023 pages to dumpdev hd (1/41), 63 pages per '.'\n"
1016 BSOD_CHAR_DELAY (bst, 100000);
1017 BSOD_TEXT (bst, LEFT,
1018 "................................................................."
1021 BSOD_CHAR_DELAY (bst, 0);
1022 BSOD_TEXT (bst, LEFT,
1023 "5023 pages dumped\n"
1027 BSOD_PAUSE (bst, 2000000);
1028 BSOD_TEXT (bst, LEFT,
1029 "** Safe to Power Off **\n"
1031 "** Press Any Key to Reboot **\n"
1034 bst->y = ((bst->xgwa.height -
1035 ((bst->font->ascent + bst->font->descent) * 18)));
1037 XClearWindow (dpy, window);
1042 /* Linux (sparc) panic, by Tom Kelly <tom@ancilla.toronto.on.ca>
1044 static struct bsod_state *
1045 sparc_linux (Display *dpy, Window window)
1047 struct bsod_state *bst = make_bsod_state (dpy, window, "sco", "SCO");
1048 bst->scroll_p = True;
1049 bst->y = bst->xgwa.height - bst->font->ascent - bst->font->descent;
1051 BSOD_TEXT (bst, LEFT,
1052 "\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n"
1053 "Unable to handle kernel paging request at virtual address f0d4a000\n"
1054 "tsk->mm->context = 00000014\n"
1055 "tsk->mm->pgd = f26b0000\n"
1057 " \"@'/ ,. \\`@\"\n"
1060 "gawk(22827): Oops\n"
1061 "PSR: 044010c1 PC: f001c2cc NPC: f001c2d0 Y: 00000000\n"
1062 "g0: 00001000 g1: fffffff7 g2: 04401086 g3: 0001eaa0\n"
1063 "g4: 000207dc g5: f0130400 g6: f0d4a018 g7: 00000001\n"
1064 "o0: 00000000 o1: f0d4a298 o2: 00000040 o3: f1380718\n"
1065 "o4: f1380718 o5: 00000200 sp: f1b13f08 ret_pc: f001c2a0\n"
1066 "l0: efffd880 l1: 00000001 l2: f0d4a230 l3: 00000014\n"
1067 "l4: 0000ffff l5: f0131550 l6: f012c000 l7: f0130400\n"
1068 "i0: f1b13fb0 i1: 00000001 i2: 00000002 i3: 0007c000\n"
1069 "i4: f01457c0 i5: 00000004 i6: f1b13f70 i7: f0015360\n"
1070 "Instruction DUMP:\n"
1073 XClearWindow (dpy, window);
1078 /* BSD Panic by greywolf@starwolf.com - modeled after the Linux panic above.
1079 By Grey Wolf <greywolf@siteROCK.com>
1081 static struct bsod_state *
1082 bsd (Display *dpy, Window window)
1084 struct bsod_state *bst = make_bsod_state (dpy, window, "bsd", "BSD");
1086 const char * const panicstr[] = {
1087 "panic: ifree: freeing free inode\n",
1088 "panic: blkfree: freeing free block\n",
1089 "panic: improbability coefficient below zero\n",
1090 "panic: cgsixmmap\n",
1091 "panic: crazy interrupts\n",
1093 "panic: attempted windows install\n",
1095 "panic: free inode isn't\n",
1096 "panic: cpu_fork: curproc\n",
1097 "panic: malloc: out of space in kmem_map\n",
1098 "panic: vogon starship detected\n",
1099 "panic: teleport chamber: out of order\n",
1100 "panic: Brain fried - core dumped\n"
1103 char syncing[80], bbuf[5];
1105 for (i = 0; i < sizeof(syncing); i++)
1108 i = (random() % (sizeof(panicstr) / sizeof(*panicstr)));
1109 BSOD_TEXT (bst, LEFT, panicstr[i]);
1110 BSOD_TEXT (bst, LEFT, "Syncing disks: ");
1112 b = (random() % 40);
1113 for (n = 0; (n < 20) && (b > 0); n++)
1117 i = (random() & 0x7);
1118 b -= (random() & 0xff) % 20;
1122 sprintf (bbuf, "%d ", b);
1123 BSOD_TEXT (bst, LEFT, bbuf);
1124 BSOD_PAUSE (bst, 1000000);
1127 BSOD_TEXT (bst, LEFT, "\n");
1128 BSOD_TEXT (bst, LEFT, (b ? "damn!" : "sunk!"));
1129 BSOD_TEXT (bst, LEFT, "\nRebooting\n");
1131 bst->y = ((bst->xgwa.height -
1132 ((bst->font->ascent + bst->font->descent) * 4)));
1134 XClearWindow (dpy, window);
1139 static struct bsod_state *
1140 amiga (Display *dpy, Window window)
1142 struct bsod_state *bst = make_bsod_state (dpy, window, "amiga", "Amiga");
1145 int pix_w = 0, pix_h = 0;
1149 unsigned long bg2 = get_pixel_resource (dpy, bst->xgwa.colormap,
1150 "amiga.background2",
1151 "Amiga.Background");
1154 pixmap = xpm_data_to_pixmap (dpy, window, (char **) amiga_hand,
1156 # endif /* DO_XPM */
1158 if (pixmap && bst->xgwa.height > 600) /* scale up the bitmap */
1160 pixmap = double_pixmap (dpy, bst->gc, bst->xgwa.visual, bst->xgwa.depth,
1161 pixmap, pix_w, pix_h);
1166 XSetLineAttributes (dpy, bst->gc, lw, LineSolid, CapButt, JoinMiter);
1168 height = (bst->font->ascent + bst->font->descent) * 6;
1170 BSOD_PAUSE (bst, 2000000);
1171 BSOD_COPY (bst, 0, 0, bst->xgwa.width, bst->xgwa.height - height, 0, height);
1174 BSOD_RECT (bst, True, 0, 0, bst->xgwa.width, height);
1176 BSOD_TEXT (bst, CENTER,
1178 "Software failure. Press left mouse button to continue.\n"
1179 "Guru Meditation #00000003.00C01570"
1181 BSOD_RECT (bst, False, lw/2, lw/2, bst->xgwa.width - lw, height);
1182 BSOD_PAUSE (bst, 1000000);
1184 BSOD_LOOP (bst, -3);
1186 XSetWindowBackground (dpy, window, bg2);
1187 XClearWindow (dpy, window);
1188 XSetWindowBackground (dpy, window, bst->bg);
1192 int x = (bst->xgwa.width - pix_w) / 2;
1193 int y = ((bst->xgwa.height - pix_h) / 2);
1194 XCopyArea (dpy, pixmap, bst->window, bst->gc, 0, 0, pix_w, pix_h, x, y);
1204 /* Atari ST, by Marcus Herbert <rhoenie@nobiscum.de>
1205 Marcus had this to say:
1207 Though I still have my Atari somewhere, I hardly remember
1208 the meaning of the bombs. I think 9 bombs was "bus error" or
1209 something like that. And you often had a few bombs displayed
1210 quickly and then the next few ones coming up step by step.
1211 Perhaps somebody else can tell you more about it.. its just
1214 static struct bsod_state *
1215 atari (Display *dpy, Window window)
1217 struct bsod_state *bst = make_bsod_state (dpy, window, "atari", "Atari");
1220 int pix_w = atari_width;
1221 int pix_h = atari_height;
1225 pixmap = XCreatePixmapFromBitmapData (dpy, window, (char *) atari_bits,
1227 bst->fg, bst->bg, bst->xgwa.depth);
1228 pixmap = double_pixmap (dpy, bst->gc, bst->xgwa.visual, bst->xgwa.depth,
1229 pixmap, pix_w, pix_h);
1235 y = bst->xgwa.height/2;
1238 for (i = 1; i< 7; i++)
1239 BSOD_COPY (bst, x, y, pix_w, pix_h, (x + (i*offset)), y);
1243 BSOD_PAUSE (bst, 1000000);
1244 BSOD_COPY (bst, x, y, pix_w, pix_h, (x + (i*offset)), y);
1247 XClearWindow (dpy, window);
1248 XCopyArea (dpy, pixmap, window, bst->gc, 0, 0, pix_w, pix_h, x, y);
1249 XFreePixmap (dpy, pixmap);
1255 static struct bsod_state *
1256 mac (Display *dpy, Window window)
1258 struct bsod_state *bst = make_bsod_state (dpy, window, "mac", "Mac");
1261 int pix_w = mac_width;
1262 int pix_h = mac_height;
1263 int offset = mac_height * 4;
1266 const char *string = ("0 0 0 0 0 0 0 F\n"
1269 pixmap = XCreatePixmapFromBitmapData(dpy, window, (char *) mac_bits,
1270 mac_width, mac_height,
1271 bst->fg, bst->bg, bst->xgwa.depth);
1273 for (i = 0; i < 2; i++)
1275 pixmap = double_pixmap (dpy, bst->gc, bst->xgwa.visual, bst->xgwa.depth,
1276 pixmap, pix_w, pix_h);
1277 pix_w *= 2; pix_h *= 2;
1280 bst->x = (bst->xgwa.width - pix_w) / 2;
1281 bst->y = (((bst->xgwa.height + offset) / 2) -
1283 (bst->font->ascent + bst->font->descent) * 2);
1284 if (bst->y < 0) bst->y = 0;
1286 XClearWindow (dpy, window);
1287 XCopyArea (dpy, pixmap, window, bst->gc, 0, 0, pix_w, pix_h, bst->x, bst->y);
1288 XFreePixmap (dpy, pixmap);
1290 bst->y += offset + bst->font->ascent + bst->font->descent;
1291 BSOD_TEXT (bst, CENTER, string);
1297 static struct bsod_state *
1298 macsbug (Display *dpy, Window window)
1300 struct bsod_state *bst = make_bsod_state (dpy, window, "macsbug", "MacsBug");
1303 const char *left = (" SP \n"
1350 const char *bottom = (" _A09D\n"
1351 " +00884 40843714 #$0700,SR "
1353 " +00886 40843765 *+$0400 "
1355 " +00888 40843718 $0004(A7),([0,A7[)"
1356 " ; 04E8D0AE | 66B8");
1358 const char * body = ("PowerPC unmapped memory exception at 003AFDAC "
1359 "BowelsOfTheMemoryMgr+04F9C\n"
1360 " Calling chain using A6/R1 links\n"
1361 " Back chain ISA Caller\n"
1362 " 00000000 PPC 28C5353C __start+00054\n"
1363 " 24DB03C0 PPC 28B9258C main+0039C\n"
1364 " 24DB0350 PPC 28B9210C MainEvent+00494\n"
1365 " 24DB02B0 PPC 28B91B40 HandleEvent+00278\n"
1366 " 24DB0250 PPC 28B83DAC DoAppleEvent+00020\n"
1367 " 24DB0210 PPC FFD3E5D0 "
1368 "AEProcessAppleEvent+00020\n"
1369 " 24DB0132 68K 00589468\n"
1370 " 24DAFF8C 68K 00589582\n"
1371 " 24DAFF26 68K 00588F70\n"
1372 " 24DAFEB3 PPC 00307098 "
1373 "EmToNatEndMoveParams+00014\n"
1374 " 24DAFE40 PPC 28B9D0B0 DoScript+001C4\n"
1375 " 24DAFDD0 PPC 28B9C35C RunScript+00390\n"
1376 " 24DAFC60 PPC 28BA36D4 run_perl+000E0\n"
1377 " 24DAFC10 PPC 28BC2904 perl_run+002CC\n"
1378 " 24DAFA80 PPC 28C18490 Perl_runops+00068\n"
1379 " 24DAFA30 PPC 28BE6CC0 Perl_pp_backtick+000FC\n"
1380 " 24DAF9D0 PPC 28BA48B8 Perl_my_popen+00158\n"
1381 " 24DAF980 PPC 28C5395C sfclose+00378\n"
1382 " 24DAF930 PPC 28BA568C free+0000C\n"
1383 " 24DAF8F0 PPC 28BA6254 pool_free+001D0\n"
1384 " 24DAF8A0 PPC FFD48F14 DisposePtr+00028\n"
1385 " 24DAF7C9 PPC 00307098 "
1386 "EmToNatEndMoveParams+00014\n"
1387 " 24DAF780 PPC 003AA180 __DisposePtr+00010");
1392 int char_width, line_height;
1393 int col_right, row_top, row_bottom, page_right, page_bottom, body_top;
1396 unsigned long fg = bst->fg;
1397 unsigned long bg = bst->bg;
1398 unsigned long bc = get_pixel_resource (dpy, bst->xgwa.colormap,
1399 "macsbug.borderColor",
1400 "MacsBug.BorderColor");
1402 for (s = body; *s; s++) if (*s == '\n') body_lines++;
1404 char_width = (bst->font->per_char
1405 ? bst->font->per_char['n'-bst->font->min_char_or_byte2].width
1406 : bst->font->min_bounds.width);
1407 line_height = bst->font->ascent + bst->font->descent;
1409 col_right = char_width * 12; /* number of columns in `left' */
1410 page_bottom = line_height * 47; /* number of lines in `left' */
1412 if (page_bottom > bst->xgwa.height)
1413 page_bottom = bst->xgwa.height;
1415 row_bottom = page_bottom - line_height;
1416 row_top = row_bottom - (line_height * 4);
1417 page_right = col_right + (char_width * 88);
1418 body_top = row_top - (line_height * body_lines);
1427 xoff = (bst->xgwa.width - page_right) / 2;
1428 yoff = (bst->xgwa.height - page_bottom) / 2;
1430 if (xoff < 0) xoff = 0;
1431 if (yoff < 0) yoff = 0;
1433 BSOD_MARGINS (bst, xoff, yoff);
1435 BSOD_COLOR (bst, bc, bg);
1436 BSOD_RECT (bst, True, 0, 0, bst->xgwa.width, bst->xgwa.height);
1437 BSOD_COLOR (bst, bg, bg);
1438 BSOD_RECT (bst, True, xoff-2, yoff, page_right+4, page_bottom);
1439 BSOD_COLOR (bst, fg, bg);
1441 BSOD_MOVETO (bst, xoff, yoff + line_height);
1442 BSOD_TEXT (bst, LEFT, left);
1443 BSOD_MOVETO (bst, xoff+col_right, yoff + row_top + line_height);
1444 BSOD_TEXT (bst, LEFT, bottom);
1446 BSOD_RECT (bst, True, xoff + col_right, yoff, 2, page_bottom);
1447 BSOD_RECT (bst, True, xoff + col_right, yoff + row_top,
1448 page_right - col_right, 1);
1449 BSOD_RECT (bst, True, xoff + col_right, yoff + row_bottom,
1450 page_right - col_right, 1);
1451 BSOD_RECT (bst, False, xoff-2, yoff, page_right+4, page_bottom);
1453 BSOD_LINE_DELAY (bst, 500);
1455 xoff + col_right + char_width,
1456 yoff + body_top + line_height);
1457 BSOD_MARGINS (bst, xoff + col_right + char_width, yoff);
1458 BSOD_TEXT (bst, LEFT, body);
1460 BSOD_RECT (bst, False, xoff-2, yoff, page_right+4, page_bottom); /* again */
1462 BSOD_RECT (bst, False,
1463 xoff + col_right + (char_width/2)+2,
1464 yoff + row_bottom + 2,
1466 page_bottom - row_bottom - 4);
1468 BSOD_PAUSE (bst, 666666);
1470 BSOD_LOOP (bst, -3);
1472 XClearWindow (dpy, window);
1477 static struct bsod_state *
1478 mac1 (Display *dpy, Window window)
1480 struct bsod_state *bst = make_bsod_state (dpy, window, "mac1", "Mac1");
1483 int pix_w = macbomb_width;
1484 int pix_h = macbomb_height;
1487 pixmap = XCreatePixmapFromBitmapData (dpy, window, (char *) macbomb_bits,
1488 macbomb_width, macbomb_height,
1489 bst->fg, bst->bg, bst->xgwa.depth);
1491 x = (bst->xgwa.width - pix_w) / 2;
1492 y = (bst->xgwa.height - pix_h) / 2;
1495 XClearWindow (dpy, window);
1496 XCopyArea (dpy, pixmap, window, bst->gc, 0, 0, pix_w, pix_h, x, y);
1502 /* This is what kernel panics looked like on MacOS X 10.0 through 10.1.5.
1503 In later releases, it's a graphic of a power button with text in
1504 English, French, German, and Japanese overlayed transparently.
1506 static struct bsod_state *
1507 macx_10_0 (Display *dpy, Window window)
1509 struct bsod_state *bst = make_bsod_state (dpy, window, "macx", "MacX");
1511 XClearWindow (dpy, window);
1512 XSetForeground (dpy, bst->gc,
1513 get_pixel_resource (dpy, bst->xgwa.colormap,
1514 "macx.textForeground",
1515 "MacX.TextForeground"));
1516 XSetBackground (dpy, bst->gc,
1517 get_pixel_resource (dpy, bst->xgwa.colormap,
1518 "macx.textBackground",
1519 "MacX.TextBackground"));
1525 int x, y, pix_w, pix_h;
1526 pixmap = xpm_data_to_pixmap (dpy, window, (char **) happy_mac,
1527 &pix_w, &pix_h, &mask);
1529 x = (bst->xgwa.width - pix_w) / 2;
1530 y = (bst->xgwa.height - pix_h) / 2;
1532 XSetClipMask (dpy, bst->gc, mask);
1533 XSetClipOrigin (dpy, bst->gc, x, y);
1534 XCopyArea (dpy, pixmap, window, bst->gc, 0, 0, pix_w, pix_h, x, y);
1535 XSetClipMask (dpy, bst->gc, None);
1536 XFreePixmap (dpy, pixmap);
1540 bst->left_margin = 0;
1541 bst->right_margin = 0;
1542 bst->y = bst->font->ascent;
1543 bst->macx_eol_kludge = True;
1546 BSOD_PAUSE (bst, 3000000);
1547 BSOD_TEXT (bst, LEFT,
1548 "panic(cpu 0): Unable to find driver for this platform: "
1549 "\"PowerMac 3,5\".\n"
1551 "backtrace: 0x0008c2f4 0x0002a7a0 0x001f0204 0x001d4e4c 0x001d4c5c "
1552 "0x001a56cc 0x01d5dbc 0x001c621c 0x00037430 0x00037364\n"
1556 "No debugger configured - dumping debug information\n"
1558 "version string : Darwin Kernel Version 1.3:\n"
1559 "Thu Mar 1 06:56:40 PST 2001; root:xnu/xnu-123.5.obj~1/RELEASE_PPC\n"
1564 "DBAT0: 00000000 00000000\n"
1565 "DBAT1: 00000000 00000000\n"
1566 "DBAT2: 80001FFE 8000003A\n"
1567 "DBAT3: 90001FFE 9000003A\n"
1569 "backtrace: 0x0008c2f4 0x0002a7a0 0x001f0204 0x001d4e4c 0x001d4c5c "
1570 "0x001a56cc 0x01d5dbc 0x001c621c 0x00037430 0x00037364\n"
1572 "panic: We are hanging here...\n");
1579 static struct bsod_state *
1580 macx_10_2 (Display *dpy, Window window, Bool v10_3_p)
1582 struct bsod_state *bst = make_bsod_state (dpy, window, "macx", "MacX");
1585 int pix_w = 0, pix_h = 0;
1588 pixmap = xpm_data_to_pixmap (dpy, window,
1589 (char **) (v10_3_p ? osx_10_3 : osx_10_2),
1591 if (! pixmap) abort();
1594 if (bst->xgwa.height > 600) /* scale up the bitmap */
1596 pixmap = double_pixmap (dpy, bst->gc, bst->xgwa.visual, bst->xgwa.depth,
1597 pixmap, pix_w, pix_h);
1598 if (! pixmap) abort();
1605 BSOD_PAUSE (bst, 2000000);
1607 bst->pixmap = pixmap;
1609 x = (bst->xgwa.width - pix_w) / 2;
1610 y = ((bst->xgwa.height - pix_h) / 2);
1611 BSOD_PIXMAP (bst, 0, 0, pix_w, pix_h, x, y);
1615 # endif /* DO_XPM */
1618 static struct bsod_state *
1619 macx (Display *dpy, Window window)
1622 switch (random() % 3) {
1623 case 0: return macx_10_0 (dpy, window); break;
1624 case 1: return macx_10_2 (dpy, window, False); break;
1625 case 2: return macx_10_2 (dpy, window, True); break;
1628 # else /* !DO_XPM */
1629 return macx_10_0 (dpy, window);
1630 # endif /* !DO_XPM */
1634 #ifndef HAVE_COCOA /* #### I have no idea how to implement this without
1635 real plane-masks. I don't think it would look
1636 right if done with alpha-transparency... */
1639 * by Martin Pool <mbp@samba.org>, Feb 2000.
1641 * This is meant to look like the preferred failure mode of NCD
1642 * Xterms. The parameters for choosing what to copy where might not
1643 * be quite right, but it looks about ugly enough.
1645 static struct bsod_state *
1646 blitdamage (Display *dpy, Window window)
1648 struct bsod_state *bst =
1649 make_bsod_state (dpy, window, "blitdamage", "BlitDamage");
1652 int delta_x = 0, delta_y = 0;
1654 int chunk_h, chunk_w;
1660 w = bst->xgwa.width;
1661 h = bst->xgwa.height;
1663 gc_mask = GCForeground;
1665 XSetPlaneMask (dpy, bst->gc, random());
1668 chunk_w = w / (random() % 1 + 1);
1669 chunk_h = h / (random() % 1 + 1);
1670 if (random() & 0x1000)
1671 delta_y = random() % 600;
1672 if (!delta_y || (random() & 0x2000))
1673 delta_x = random() % 600;
1680 for (i = 0; i < steps; i++) {
1681 if (x + chunk_w > w)
1686 if (y + chunk_h > h)
1691 BSOD_COPY (bst, src_x, src_y, chunk_w, chunk_h, x, y);
1692 BSOD_PAUSE (bst, 1000);
1697 #endif /* !HAVE_COCOA */
1701 * OS/2 panics, by Knut St. Osmundsen <bird-xscreensaver@anduin.net>
1703 * All but one messages are real ones, some are from my test machines
1704 * and system dumps, others are reconstructed from google results.
1705 * Please, don't be to hard if the formatting of the earlier systems
1706 * aren't 100% correct.
1708 static struct bsod_state *
1709 os2 (Display *dpy, Window window)
1711 struct bsod_state *bst = make_bsod_state (dpy, window, "os2", "OS2");
1714 static const char * const os2_panics[] =
1715 { /* OS/2 2.0 trap - details are bogus (CR0++). */
1716 "TRAP 0002 ERRCD=0000 ERACC=**** ERLIM=********\n"
1717 "EAX=7d240a58 EBX=ff202fdc ECX=00064423 EDX=00003624\n"
1718 "ESI=fff3272c EDI=7d240004 EBP=00004a44 FLG=00003202\n"
1719 "CS:EIP=0160:fff702a6 CSACC=c09d CSLIM=ffffffff\n"
1720 "SS:ESP=0030:00004a38 SSACC=1097 SSLIM=00003fff\n"
1721 "DS=0158 DSACC=c0f3 DSLIM=ffffffff CR0=fffffffb\n"
1722 "ES=0158 ESACC=c0f3 ESLIM=ffffffff CR2=1a060014\n"
1723 "FS=0000 FSACC=**** FSLIM=********\n"
1724 "GS=0000 GSACC=**** GSLIM=********\n"
1726 "The system detected an internal processing error\n"
1727 "at location ##0160:fff6453f - 000d:a53f\n"
1731 "Internal revision 6.307, 92/03/01\n"
1734 /* warp 3 (early) */
1735 "TRAP 000e ERRCD=0000 ERACC=**** ERLIM=********\n"
1736 "EAX=ff050c20 EBX=000000bb ECX=ffff00c1 EDx=fff379b8\n"
1737 "ESI=ffe55a3c EDI=00000000 EBP=00004eb8 FLG=00013282\n"
1738 "CS:EIP=0160:fff8dbb8 CSACC=c09b CSLIM=ffffffff\n"
1739 "SS:EIP=0030:00004eb4 SSACC=1097 SSLIM=00003fff\n"
1740 "DS=0158 DSACC=c0f3 DSLIM=ffffffff CR0=8001001b\n"
1741 "ES=0158 DSACC=c0f3 DSLIM=ffffffff CR2=000000c7\n"
1742 "FS=0000 FSACC=**** FSLIM=********\n"
1743 "GS=0000 GSACC=**** GSLIM=********\n"
1745 "The system detected an internal processing error\n"
1746 "at location ##0160:fff66bf0 - 000d:9bf0.\n"
1750 "Internal revision 8.125, 94/02/16\n"
1752 "The system is stopped. Record the location number of the error\n"
1753 "and contact your service representative.\n",
1756 "TRAP 000e ERRCD=0002 ERACC=**** ERLIM=********\n"
1757 "EAX=00000000 EBX=fdef1e0c ECX=00003824 EDX=0000edf9\n"
1758 "ESI=fdf30e80 EDI=fc8b0000 EBP=00005658 FLG=00012246\n"
1759 "CS:EIP=0160:fff8ada3 CSACC=c09b CSLIM=ffffffff\n"
1760 "SS:ESP=0030:000055d4 SSACC=1097 SSLIM=0000480f\n"
1761 "DS=0158 DSACC=c093 DSLIM=ffffffff CR0=8001001b\n"
1762 "ES=0158 ESACC=c093 ESLIM=ffffffff CR2=fc8b0000\n"
1763 "FS=03b8 FSACC=0093 FSLIM=00000023\n"
1764 "GS=0000 GSACC=**** GSLIM=********\n"
1766 "The system detected an internal processing error\n"
1767 "at location ##0160:fff5c364 - 000d:a364.\n"
1771 "Internal revision 8200,94/11/07\n"
1773 "The system is stopped. Record all of the above information and\n"
1774 "contact your service representative.\n",
1777 "TRAP 000d ERRCD=2200 ERACC=1092 ERLIM=00010fff\n"
1778 "EAX=0000802e EBX=fff001c8 ECX=9bd80000 EDX=00000000\n"
1779 "ESI=fff09bd8 EDI=fdeb001b EBP=00000000 FLG=00012012\n"
1780 "CS:EIP=0168:fff480a2 CSACC=c09b CSLIM=ffffffff\n"
1781 "SS:ESP=00e8:00001f32 SSACC=0093 SSLIM=00001fff\n"
1782 "DS=0940 DSACC=0093 DSLIM=00000397 CR0=8001001b\n"
1783 "ES=00e8 ESACC=0093 ESLIM=00001fff CR2=15760008\n"
1784 "FS=0000 FSACC=**** FSLIM=****\n"
1785 "GS=0000 GSACC=**** GSLIM=****\n"
1787 "The system detected an internal processing error\n"
1788 "at location ##0168:fff4b06e - 000e:c06e\n"
1792 "Internal revision 8.259_uni,98/01/07\n"
1794 "The system is stopped. Record all of the above information and\n"
1795 "contact your service representative.\n",
1797 /* Warp 4.52+ - the official r0trap.exe from the debugging classes */
1798 "Exception in module: OS2KRNL\n"
1799 "TRAP 000e ERRCD=0002 ERACC=**** ERLIM=********\n"
1800 "EAX=00000001 EBX=80010002 ECX=ffed4638 EDX=0003f17b\n"
1801 "ESI=00000001 EDI=00000002 EBP=00005408 FLG=00012202\n"
1802 "CS:EIP=0168:fff3cd2e CSACC=c09b CSLIM=ffffffff\n"
1803 "SS:ESP=0030:000053ec SSACC=1097 SSLIM=000044ff\n"
1804 "DS=0160 DSACC=c093 DSLIM=ffffffff CR0=8001001b\n"
1805 "ES=0160 ESACC=c093 ESLIM=ffffffff CR2=00000001\n"
1806 "FS=0000 FSACC=**** FSLIM=********\n"
1807 "GS=0000 GSACC=**** GSLIM=********\n"
1809 "The system detected an internal processing error at\n"
1810 "location ##0168:fff1e3f3 - 000e:c3f3.\n"
1814 "Internal revision 14.097_UNI\n"
1816 "The system is stopped. Record all of the above information and\n"
1817 "contact your service representative.\n",
1819 /* Warp 4.52+, typical JFS problem. */
1820 "Exeption in module: JFS\n"
1821 "TRAP 0003 ERRCD=0000 ERACC=**** ERLIM=********\n"
1822 "EAX=00000000 EBX=ffffff05 ECX=00000001 EDX=f5cd8010\n"
1823 "ESI=000000e6 EDI=000000e7 EBP=f9c7378e FLG=00002296\n"
1824 "CS:EIP=0168:f8df3250 CSACC=c09b CSLIM=ffffffff\n"
1825 "SS:ESP=1550:fdc73778 SSACC=c093 SSLIM=ffffffff\n"
1826 "DS=0160 DSACC=c093 DSLIM=ffffffff CR0=80010016\n"
1827 "ES=0160 ESACC=c093 DSLIM=ffffffff CR2=05318000\n"
1828 "FS=03c0 FSACC=0093 DSLIM=00000023\n"
1829 "GS=0160 GSACC=c093 DSLIM=ffffffff\n"
1831 "The system detected an internal processing error\n"
1832 "at location ##0168:fff1e2ab - 000e:c2ab.\n"
1837 "Internal revision 14.100c_UNI\n"
1839 "The system is stopped. Record all of the above information and\n"
1840 "contact your service representative.\n"
1843 BSOD_TEXT (bst, LEFT, os2_panics[random() % countof(os2_panics)]);
1844 BSOD_CURSOR (bst, CURSOR_LINE, 240000, 999999);
1846 XClearWindow (dpy, window);
1851 /* SPARC Solaris panic. Should look pretty authentic on Solaris boxes.
1852 * Anton Solovyev <solovam@earthlink.net>
1854 static struct bsod_state *
1855 sparc_solaris (Display *dpy, Window window)
1857 struct bsod_state *bst = make_bsod_state (dpy, window, "solaris", "Solaris");
1860 bst->scroll_p = True;
1862 bst->left_margin = bst->right_margin = bst->xgwa.width * 0.07;
1863 bst->top_margin = bst->bottom_margin = bst->xgwa.height * 0.07;
1864 bst->y = bst->top_margin + bst->font->ascent;
1867 BSOD_PAUSE (bst, 3000000);
1870 BSOD_RECT (bst, True,
1871 bst->left_margin, bst->top_margin,
1872 bst->xgwa.width - bst->left_margin - bst->right_margin,
1873 bst->xgwa.height - bst->top_margin - bst->bottom_margin);
1876 BSOD_TEXT (bst, LEFT,
1877 "BAD TRAP: cpu=0 type=0x31 rp=0x2a10043b5e0 addr=0xf3880 mmu_fsr=0x0\n"
1878 "BAD TRAP occurred in module \"unix\" due to an illegal access to a"
1880 "adb: trap type = 0x31\n"
1882 "pid=307, pc=0x100306e4, sp=0x2a10043ae81, tstate=0x4480001602,"
1884 "g1-g7: 1045b000, 32f, 10079440, 180, 300000ebde8, 0, 30000953a20\n"
1885 "Begin traceback... sp = 2a10043ae81\n"
1886 "Called from 100bd060, fp=2a10043af31, args=f3700 300008cc988 f3880 0"
1888 "Called from 101fe1bc, fp=2a10043b011, args=3000045a240 104465a0"
1889 " 300008e47d0 300008e48fa 300008ae350 300008ae410\n"
1890 "Called from 1007c520, fp=2a10043b0c1, args=300008e4878 300003596e8 0"
1891 " 3000045a320 0 3000045a220\n"
1892 "Called from 1007c498, fp=2a10043b171, args=1045a000 300007847f0 20"
1893 " 3000045a240 1 0\n"
1894 "Called from 1007972c, fp=2a10043b221, args=1 300009517c0 30000951e58 1"
1896 "Called from 10031e10, fp=2a10043b2d1, args=3000095b0c8 0 300009396a8"
1897 " 30000953a20 0 1\n"
1898 "Called from 10000bdd8, fp=ffffffff7ffff1c1, args=0 57 100131480"
1899 " 100131480 10012a6e0 0\n"
1900 "End traceback...\n"
1901 "panic[cpu0]/thread=30000953a20: trap\n"
1902 "syncing file systems...");
1904 BSOD_PAUSE (bst, 3000000);
1906 BSOD_TEXT (bst, LEFT, " 1 done\n");
1907 BSOD_TEXT (bst, LEFT, "dumping to /dev/dsk/c0t0d0s3, offset 26935296\n");
1908 BSOD_PAUSE (bst, 2000000);
1911 for (i = 1; i <= 100; ++i)
1914 sprintf (buf, "\b\b\b\b\b\b\b\b\b\b\b%3d%% done", i);
1915 BSOD_TEXT (bst, LEFT, buf);
1916 BSOD_PAUSE (bst, 100000);
1919 BSOD_TEXT (bst, LEFT,
1920 ": 2803 pages dumped, compression ratio 2.88, dump succeeded\n");
1921 BSOD_PAUSE (bst, 2000000);
1923 BSOD_TEXT (bst, LEFT,
1931 /* Linux panic and fsck, by jwz
1933 static struct bsod_state *
1934 linux_fsck (Display *dpy, Window window)
1936 struct bsod_state *bst = make_bsod_state (dpy, window, "linux", "Linux");
1939 const char *sysname;
1942 const char *linux_panic[] = {
1943 " kernel: Unable to handle kernel paging request at virtual "
1944 "address 0000f0ad\n",
1945 " kernel: printing eip:\n",
1946 " kernel: c01becd7\n",
1947 " kernel: *pde = 00000000\n",
1948 " kernel: Oops: 0000\n",
1949 " kernel: CPU: 0\n",
1950 " kernel: EIP: 0010:[<c01becd7>] Tainted: P \n",
1951 " kernel: EFLAGS: 00010286\n",
1952 " kernel: eax: 0000ff00 ebx: ca6b7e00 ecx: ce1d7a60 edx: ce1d7a60\n",
1953 " kernel: esi: ca6b7ebc edi: 00030000 ebp: d3655ca0 esp: ca6b7e5c\n",
1954 " kernel: ds: 0018 es: 0018 ss: 0018\n",
1955 " kernel: Process crond (pid: 1189, stackpage=ca6b7000)\n",
1956 " kernel: Stack: d3655ca0 ca6b7ebc 00030054 ca6b7e7c c01c1e5b "
1957 "00000287 00000020 c01c1fbf \n",
1959 " kernel: 00005a36 000000dc 000001f4 00000000 00000000 "
1960 "ce046d40 00000001 00000000 \n",
1962 " kernel: ffffffff d3655ca0 d3655b80 00030054 c01bef93 "
1963 "d3655ca0 ca6b7ebc 00030054 \n",
1965 " kernel: Call Trace: [<c01c1e5b>] [<c01c1fbf>] [<c01bef93>] "
1966 "[<c01bf02b>] [<c0134c4f>]\n",
1968 " kernel: [<c0142562>] [<c0114f8c>] [<c0134de3>] [<c010891b>]\n",
1970 " kernel: Code: 2a 00 75 08 8b 44 24 2c 85 c0 74 0c 8b 44 24 58 83 48 18 "
1975 bst->scroll_p = True;
1977 bst->left_margin = bst->right_margin = 10;
1978 bst->top_margin = bst->bottom_margin = 10;
1985 if (uname (&uts) >= 0)
1986 sysname = uts.nodename;
1987 s = strchr (sysname, '.');
1990 # endif /* !HAVE_UNAME */
1993 BSOD_TEXT (bst, LEFT, "waiting for X server to shut down ");
1994 BSOD_PAUSE (bst, 100000);
1995 BSOD_TEXT (bst, LEFT,
1996 "XIO: fatal IO error 2 (broken pipe) on X server \":0.0\"\n"
1997 " after 339471 requests (339471 known processed) "
1998 "with 0 events remaining\n");
1999 BSOD_CHAR_DELAY (bst, 300000);
2000 BSOD_TEXT (bst, LEFT, ".........\n");
2001 BSOD_CHAR_DELAY (bst, 0);
2002 BSOD_TEXT (bst, LEFT,
2003 "xinit: X server slow to shut down, sending KILL signal.\n"
2004 "waiting for server to die ");
2005 BSOD_CHAR_DELAY (bst, 300000);
2006 BSOD_TEXT (bst, LEFT, "...\n");
2007 BSOD_CHAR_DELAY (bst, 0);
2008 BSOD_TEXT (bst, LEFT, "xinit: Can't kill server\n");
2009 BSOD_PAUSE (bst, 2000000);
2011 sprintf (buf, "\n%s Login: ", sysname);
2012 BSOD_TEXT (bst, LEFT, buf);
2013 BSOD_PAUSE (bst, 1000000);
2014 BSOD_TEXT (bst, LEFT,
2016 "Parallelizing fsck version 1.22 (22-Jun-2001)\n"
2017 "e2fsck 1.22, 22-Jun-2001 for EXT2 FS 0.5b, 95/08/09\n"
2018 "Warning! /dev/hda1 is mounted.\n"
2019 "/dev/hda1 contains a file system with errors, check forced.\n");
2020 BSOD_PAUSE (bst, 1000000);
2022 if (0 == random() % 2)
2023 BSOD_TEXT (bst, LEFT,
2024 "Couldn't find ext2 superblock, trying backup blocks...\n"
2025 "The filesystem size (according to the superblock) is 3644739 blocks\n"
2026 "The physical size of the device is 3636706 blocks\n"
2027 "Either the superblock or the partition table is likely to be corrupt!\n"
2029 BSOD_PAUSE (bst, 1000000);
2033 BSOD_TEXT (bst, LEFT, "Pass 1: Checking inodes, blocks, and sizes\n");
2034 BSOD_PAUSE (bst, 2000000);
2036 i = (random() % 60) - 20;
2039 int b = random() % 0xFFFF;
2040 sprintf (buf, "Deleted inode %d has zero dtime. Fix<y>? yes\n\n", b);
2041 BSOD_TEXT (bst, LEFT, buf);
2042 BSOD_PAUSE (bst, 1000);
2045 i = (random() % 40) - 10;
2048 int g = random() % 0xFFFF;
2049 int b = random() % 0xFFFFFFF;
2051 BSOD_PAUSE (bst, 1000000);
2053 sprintf (buf, "Warning: Group %d's copy of the group descriptors "
2054 "has a bad block (%d).\n", g, b);
2055 BSOD_TEXT (bst, LEFT, buf);
2057 b = random() % 0x3FFFFF;
2060 b += random() % 0xFFFF;
2062 "Error reading block %d (Attempt to read block "
2063 "from filesystem resulted in short read) while doing "
2064 "inode scan. Ignore error<y>?",
2066 BSOD_TEXT (bst, LEFT, buf);
2067 BSOD_PAUSE (bst, 10000);
2068 BSOD_TEXT (bst, LEFT, " yes\n\n");
2072 if (0 == (random() % 10))
2074 BSOD_PAUSE (bst, 1000000);
2076 i = 3 + (random() % 10);
2079 BSOD_TEXT (bst, LEFT,
2080 "Could not allocate 256 block(s) for inode table: "
2081 "No space left on device\n");
2082 BSOD_PAUSE (bst, 1000);
2084 BSOD_TEXT (bst, LEFT, "Restarting e2fsck from the beginning...\n");
2085 BSOD_PAUSE (bst, 2000000);
2090 i = (random() % 20) - 5;
2093 BSOD_PAUSE (bst, 1000000);
2097 int j = 5 + (random() % 10);
2098 int w = random() % 4;
2102 int b = random() % 0xFFFFF;
2103 int g = random() % 0xFFF;
2105 if (0 == (random() % 10))
2107 else if (0 == (random() % 10))
2112 "Inode table for group %d not in group. (block %d)\n"
2113 "WARNING: SEVERE DATA LOSS POSSIBLE.\n"
2118 "Block bitmap for group %d not in group. (block %d)\n"
2123 "Inode bitmap %d for group %d not in group.\n"
2126 else /* if (w == 3) */
2128 "Bad block %d in group %d's inode table.\n"
2129 "WARNING: SEVERE DATA LOSS POSSIBLE.\n"
2133 BSOD_TEXT (bst, LEFT, buf);
2134 BSOD_TEXT (bst, LEFT, " yes\n\n");
2135 BSOD_PAUSE (bst, 1000);
2140 if (0 == random() % 10) goto PANIC;
2141 BSOD_TEXT (bst, LEFT, "Pass 2: Checking directory structure\n");
2142 BSOD_PAUSE (bst, 2000000);
2144 i = (random() % 20) - 5;
2147 int n = random() % 0xFFFFF;
2148 int o = random() % 0xFFF;
2149 sprintf (buf, "Directory inode %d, block 0, offset %d: "
2150 "directory corrupted\n"
2153 BSOD_TEXT (bst, LEFT, buf);
2154 BSOD_PAUSE (bst, 1000);
2155 BSOD_TEXT (bst, LEFT, " yes\n\n");
2157 if (0 == (random() % 100))
2159 sprintf (buf, "Missing '.' in directory inode %d.\nFix<y>?", n);
2160 BSOD_TEXT (bst, LEFT, buf);
2161 BSOD_PAUSE (bst, 1000);
2162 BSOD_TEXT (bst, LEFT, " yes\n\n");
2166 if (0 == random() % 10)
2169 BSOD_TEXT (bst, LEFT,
2170 "Pass 3: Checking directory connectivity\n"
2171 "/lost+found not found. Create? yes\n");
2172 BSOD_PAUSE (bst, 2000000);
2174 /* Unconnected directory inode 4949 (/var/spool/squid/06/???)
2175 Connect to /lost+found<y>? yes
2177 '..' in /var/spool/squid/06/08 (20351) is <The NULL inode> (0), should be
2178 /var/spool/squid/06 (20350).
2181 Unconnected directory inode 128337 (/var/spool/squid/06/???)
2182 Connect to /lost+found<y>? yes
2186 if (0 == random() % 10) goto PANIC;
2187 BSOD_TEXT (bst, LEFT, "Pass 4: Checking reference counts\n");
2188 BSOD_PAUSE (bst, 2000000);
2190 /* Inode 2 ref count is 19, should be 20. Fix<y>? yes
2192 Inode 4949 ref count is 3, should be 2. Fix<y>? yes
2196 Inode 128336 ref count is 3, should be 2. Fix<y>? yes
2198 Inode 128337 ref count is 3, should be 2. Fix<y>? yes
2203 if (0 == random() % 10) goto PANIC;
2204 BSOD_TEXT (bst, LEFT, "Pass 5: Checking group summary information\n");
2205 BSOD_PAUSE (bst, 2000000);
2207 i = (random() % 200) - 50;
2210 BSOD_TEXT (bst, LEFT, "Block bitmap differences: ");
2213 sprintf (buf, " %d", -(random() % 0xFFF));
2214 BSOD_TEXT (bst, LEFT, buf);
2215 BSOD_PAUSE (bst, 1000);
2217 BSOD_TEXT (bst, LEFT, "\nFix? yes\n\n");
2221 i = (random() % 100) - 50;
2224 BSOD_TEXT (bst, LEFT, "Inode bitmap differences: ");
2227 sprintf (buf, " %d", -(random() % 0xFFF));
2228 BSOD_TEXT (bst, LEFT, buf);
2229 BSOD_PAUSE (bst, 1000);
2231 BSOD_TEXT (bst, LEFT, "\nFix? yes\n\n");
2234 i = (random() % 20) - 5;
2237 int g = random() % 0xFFFF;
2238 int c = random() % 0xFFFF;
2240 "Free blocks count wrong for group #0 (%d, counted=%d).\nFix? ",
2242 BSOD_TEXT (bst, LEFT, buf);
2243 BSOD_PAUSE (bst, 1000);
2244 BSOD_TEXT (bst, LEFT, " yes\n\n");
2250 BSOD_TEXT (bst, LEFT, "\n\n");
2251 while (linux_panic[i])
2253 time_t t = time ((time_t *) 0);
2254 struct tm *tm = localtime (&t);
2257 if (*linux_panic[i])
2259 strftime (prefix, sizeof(prefix)-1, "%b %d %H:%M:%S ", tm);
2260 BSOD_TEXT (bst, LEFT, prefix);
2261 BSOD_TEXT (bst, LEFT, sysname);
2262 BSOD_TEXT (bst, LEFT, linux_panic[i]);
2263 BSOD_PAUSE (bst, 1000);
2266 BSOD_PAUSE (bst, 300000);
2270 BSOD_PAUSE (bst, 4000000);
2272 XClearWindow(dpy, window);
2278 * Linux (hppa) panic, by Stuart Brady <sdbrady@ntlworld.com>
2279 * Output courtesy of M. Grabert
2281 static struct bsod_state *
2282 hppa_linux (Display *dpy, Window window)
2284 struct bsod_state *bst =
2285 make_bsod_state (dpy, window, "hppalinux", "HPPALinux");
2288 const char *release, *sysname, *gccversion, *version;
2289 long int linedelay = 0;
2292 struct { long int delay; const char *string; } linux_panic[] =
2293 {{ 0, "\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n"
2294 "\n\n\n\n\n\n\n\n\n\n\n\n\n" },
2295 { 0, "Linux version %s (root@%s) (gcc version %s) %s\n" },
2296 { 4000, "FP[0] enabled: Rev 1 Model 16\n" },
2297 { 10, "The 32-bit Kernel has started...\n" },
2298 { -1, "Determining PDC firmware type: System Map.\n" },
2299 { -1, "model 00005bb0 00000481 00000000 00000002 7778df9f 100000f0 "
2300 "00000008 000000b2 000000b2\n" },
2301 { -1, "vers 00000203\n" },
2302 { -1, "CPUID vers 17 rev 7 (0x00000227)\n" },
2303 { -1, "capabilities 0x3\n" },
2304 { -1, "model 9000/785/C3000\n" },
2305 { -1, "Total Memory: 1024 Mb\n" },
2306 { -1, "On node 0 totalpages: 262144\n" },
2307 { -1, " DMA zone: 262144 pages, LIFO batch:16\n" },
2308 { -1, " Normal zone: 0 pages, LIFO batch:1\n" },
2309 { -1, " HighMem zone: 0 pages, LIFO batch:1\n" },
2310 { -1, "LCD display at f05d0008,f05d0000 registered\n" },
2311 { -1, "Building zonelist for node : 0\n" },
2312 { -1, "Kernel command line: ide=nodma root=/dev/sda3 HOME=/ ip=off "
2313 "console=ttyS0 TERM=vt102 palo_kernel=2/vmlinux-2.6\n" },
2314 { -1, "ide_setup: ide=nodmaIDE: Prevented DMA\n" },
2315 { -1, "PID hash table entries: 16 (order 4: 128 bytes)\n" },
2316 {500, "Console: colour dummy device 160x64\n" },
2317 { 10, "Memory: 1034036k available\n" },
2318 { -1, "Calibrating delay loop... 796.67 BogoMIPS\n" },
2319 { -1, "Dentry cache hash table entries: 131072 (order: 7, 524288 "
2321 { -1, "Inode-cache hash table entries: 65536 (order: 6, 262144 "
2323 { -1, "Mount-cache hash table entries: 512 (order: 0, 4096 bytes)\n" },
2324 { -1, "POSIX conformance testing by UNIFIX\n" },
2325 { -1, "NET: Registered protocol family 16\n" },
2326 { 100, "Searching for devices...\n" },
2327 { 25, "Found devices:\n" },
2328 { 10, "1. Astro BC Runway Port at 0xfed00000 [10] "
2329 "{ 12, 0x0, 0x582, 0x0000b }\n" },
2330 { -1, "2. Elroy PCI Bridge at 0xfed30000 [10/0] "
2331 "{ 13, 0x0, 0x782, 0x0000a }\n" },
2332 { -1, "3. Elroy PCI Bridge at 0xfed32000 [10/1] "
2333 "{ 13, 0x0, 0x782, 0x0000a }\n" },
2334 { -1, "4. Elroy PCI Bridge at 0xfed38000 [10/4] "
2335 "{ 13, 0x0, 0x782, 0x0000a }\n" },
2336 { -1, "5. Elroy PCI Bridge at 0xfed3c000 [10/6] "
2337 "{ 13, 0x0, 0x782, 0x0000a }\n" },
2338 { -1, "6. AllegroHigh W at 0xfffa0000 [32] "
2339 "{ 0, 0x0, 0x5bb, 0x00004 }\n" },
2340 { -1, "7. Memory at 0xfed10200 [49] { 1, 0x0, 0x086, 0x00009 }\n" },
2341 { -1, "CPU(s): 1 x PA8500 (PCX-W) at 400.000000 MHz\n" },
2342 { -1, "SBA found Astro 2.1 at 0xfed00000\n" },
2343 { -1, "lba version TR2.1 (0x2) found at 0xfed30000\n" },
2344 { -1, "lba version TR2.1 (0x2) found at 0xfed32000\n" },
2345 { -1, "lba version TR2.1 (0x2) found at 0xfed38000\n" },
2346 { -1, "lba version TR2.1 (0x2) found at 0xfed3c000\n" },
2347 { 100, "SCSI subsystem initialized\n" },
2348 { 10, "drivers/usb/core/usb.c: registered new driver usbfs\n" },
2349 { -1, "drivers/usb/core/usb.c: registered new driver hub\n" },
2350 { -1, "ikconfig 0.7 with /proc/config*\n" },
2351 { -1, "Initializing Cryptographic API\n" },
2352 { 250, "SuperIO: probe of 0000:00:0e.0 failed with error -1\n" },
2353 { 20, "SuperIO: Found NS87560 Legacy I/O device at 0000:00:0e.1 "
2355 { -1, "SuperIO: Serial port 1 at 0x3f8\n" },
2356 { -1, "SuperIO: Serial port 2 at 0x2f8\n" },
2357 { -1, "SuperIO: Parallel port at 0x378\n" },
2358 { -1, "SuperIO: Floppy controller at 0x3f0\n" },
2359 { -1, "SuperIO: ACPI at 0x7e0\n" },
2360 { -1, "SuperIO: USB regulator enabled\n" },
2361 { -1, "SuperIO: probe of 0000:00:0e.2 failed with error -1\n" },
2362 { -1, "Soft power switch enabled, polling @ 0xf0400804.\n" },
2363 { -1, "pty: 256 Unix98 ptys configured\n" },
2364 { -1, "Generic RTC Driver v1.07\n" },
2365 { -1, "Serial: 8250/16550 driver $Revision: 1.90 $ 13 ports, "
2366 "IRQ sharing disabled\n" },
2367 { -1, "ttyS0 at I/O 0x3f8 (irq = 0) is a 16550A\n" },
2368 { -1, "ttyS1 at I/O 0x2f8 (irq = 0) is a 16550A\n" },
2369 { -1, "Linux Tulip driver version 1.1.13 (May 11, 2002)\n" },
2370 { 150, "tulip0: no phy info, aborting mtable build\n" },
2371 { 10, "tulip0: MII transceiver #1 config 1000 status 782d "
2372 "advertising 01e1.\n" },
2373 { -1, "eth0: Digital DS21143 Tulip rev 65 at 0xf4008000, "
2374 "00:10:83:F9:B4:34, IRQ 66.\n" },
2375 { -1, "Uniform Multi-Platform E-IDE driver Revision: 7.00alpha2\n" },
2376 { -1, "ide: Assuming 33MHz system bus speed for PIO modes; "
2377 "override with idebus=xx\n" },
2378 { 100, "SiI680: IDE controller at PCI slot 0000:01:06.0\n" },
2379 { 10, "SiI680: chipset revision 2\n" },
2380 { -1, "SiI680: BASE CLOCK == 133\n" },
2381 { -1, "SiI680: 100% native mode on irq 128\n" },
2382 { -1, " ide0: MMIO-DMA at 0xf4800000-0xf4800007 -- "
2383 "Error, MMIO ports already in use.\n" },
2384 { -1, " ide1: MMIO-DMA at 0xf4800008-0xf480000f -- "
2385 "Error, MMIO ports already in use.\n" },
2386 { 5, "hda: TS130220A2, ATA DISK drive\n" },
2387 { -1, " _______________________________\n" },
2388 { -1, " < Your System ate a SPARC! Gah! >\n" },
2389 { -1, " -------------------------------\n" },
2390 { -1, " \\ ^__^\n" },
2391 { -1, " \\ (xx)\\_______\n" },
2392 { -1, " (__)\\ )\\/\\\n" },
2393 { -1, " U ||----w |\n" },
2395 { -1, "swapper (pid 1): Breakpoint (code 0)\n" },
2397 { -1, " YZrvWESTHLNXBCVMcbcbcbcbOGFRQPDI\n" },
2398 { -1, "PSW: 00000000000001001111111100001111 Not tainted\n" },
2399 { -1, "r00-03 4d6f6f21 1032f010 10208f34 103fc2e0\n" },
2400 { -1, "r04-07 103fc230 00000001 00000001 0000000f\n" },
2401 { -1, "r08-11 103454f8 000f41fa 372d3980 103ee404\n" },
2402 { -1, "r12-15 3ccbf700 10344810 103ee010 f0400004\n" },
2403 { -1, "r16-19 f00008c4 f000017c f0000174 00000000\n" },
2404 { -1, "r20-23 fed32840 fed32800 00000000 0000000a\n" },
2405 { -1, "r24-27 0000ffa0 000000ff 103fc2e0 10326010\n" },
2406 { -1, "r28-31 00000000 00061a80 4ff98340 10208f34\n" },
2407 { -1, "sr0-3 00000000 00000000 00000000 00000000\n" },
2408 { -1, "sr4-7 00000000 00000000 00000000 00000000\n" },
2410 { -1, "IASQ: 00000000 00000000 IAOQ: 00000000 00000004\n" },
2411 { -1, " IIR: 00000000 ISR: 00000000 IOR: 00000000\n" },
2412 { -1, " CPU: 0 CR30: 4ff98000 CR31: 1037c000\n" },
2413 { -1, " ORIG_R28: 55555555\n" },
2414 { -1, " IAOQ[0]: 0x0\n" },
2415 { -1, " IAOQ[1]: 0x4\n" },
2416 { -1, " RP(r2): probe_hwif+0x218/0x44c\n" },
2417 { -1, "Kernel panic: Attempted to kill init!\n" },
2420 bst->scroll_p = True;
2422 bst->left_margin = bst->right_margin = 10;
2423 bst->top_margin = bst->bottom_margin = 10;
2425 release = "2.6.0-test11-pa2";
2427 version = "#2 Mon Dec 8 06:09:27 GMT 2003";
2432 if (uname (&uts) >= 0)
2434 sysname = uts.nodename;
2435 if (!strcmp (uts.sysname, "Linux"))
2437 release = uts.release;
2438 version = uts.version;
2441 s = strchr (sysname, '.');
2444 # endif /* !HAVE_UNAME */
2446 # if (defined (__GNUC__) && defined (__VERSION__))
2447 gccversion = __VERSION__;
2448 # else /* !(defined (__GNUC__) && defined (__VERSION__)) */
2449 gccversion = "3.3.2 (Debian)";
2450 # endif /* !(defined (__GNUC__) && defined (__VERSION__)) */
2452 /* Insert current host name into banner on line 2 */
2455 snprintf (ss, 1024, linux_panic[1].string,
2456 release, sysname, gccversion, version);
2457 linux_panic[1].string = ss;
2460 BSOD_PAUSE (bst, 100000);
2461 while (linux_panic[i].string)
2463 if (linux_panic[i].delay != -1)
2464 linedelay = linux_panic[i].delay * 1000;
2465 BSOD_PAUSE (bst, linedelay);
2466 BSOD_TEXT (bst, LEFT, linux_panic[i].string);
2470 bst->y = bst->xgwa.height - bst->font->ascent - bst->font->descent;
2472 XClearWindow(dpy, window);
2477 /* VMS by jwz (text sent by Roland Barmettler <roli@barmettler.net>)
2479 static struct bsod_state *
2480 vms (Display *dpy, Window window)
2482 struct bsod_state *bst = make_bsod_state (dpy, window, "vms", "VMS");
2484 const char *sysname;
2486 int dot_delay = 40000;
2487 int chunk_delay = 500000;
2494 const char *lines[] = {
2495 "%CNXMAN, Lost connection to system #\n"
2496 "%SHADOW-I-VOLPROC, DSA0: shadow master has changed. "
2497 "Dump file WILL be written if system crashes.\n"
2501 "%CNXMAN, Quorum lost, blocking activity\n"
2502 "%CNXMAN, Timed-out lost connection to system #\n"
2503 "%CNXMAN, Timed-out lost connection to system #\n"
2504 "%CNXMAN, Timed-out lost connection to system #\n"
2505 "%CNXMAN, Proposing reconfiguration of the VMScluster\n",
2508 "%CNXMAN, Removed from VMScluster system #\n"
2509 "%CNXMAN, Removed from VMScluster system #\n"
2510 "%CNXMAN, Removed from VMScluster system #\n"
2511 "%CNXMAN, Completing VMScluster state transition\n",
2514 "**** OpenVMS (TM) Alpha Operating system V7.3-1 - BUGCHECK ****\n"
2516 "** Bugcheck code = 000005DC: CLUEXIT, Node voluntarily exiting "
2518 "** Crash CPU: 00 Primary CPU: 00 Active CPUs: 00000001\n"
2519 "** Current Process = NULL\n"
2520 "** Current PSB ID = 00000001\n"
2523 "** Dumping error log buffers to HBVS unit 0\n"
2524 "**** Unable to dump error log buffers to remaining shadow set members\n"
2525 "** Error log buffers not dumped to HBVS unit 200\n"
2527 "** Dumping memory to HBVS unit 0\n"
2528 "**** Starting compressed selective memory dump at #...\n",
2533 "**** Memory dump complete - not all processes or global pages saved\n",
2541 "HALT instruction executed\n"
2542 "PC = ffffffff800c3884\n",
2548 "resetting all I/O buses\n"
2555 bst->scroll_p = True;
2557 bst->left_margin = bst->right_margin = 10;
2558 bst->top_margin = bst->bottom_margin = 10;
2564 if (uname (&uts) >= 0)
2565 sysname = uts.nodename;
2566 s = strchr (sysname, '.');
2569 # endif /* !HAVE_UNAME */
2571 args[0] = malloc (strlen(sysname) + 7);
2572 strcpy (args[0], sysname);
2575 /* Pick three numbers, 1-9, no overlaps. */
2576 ids[0] = 1 + (random() % 9);
2577 do { ids[1] = 1 + (random() % 9); } while (ids[1]==ids[0]);
2578 do { ids[2] = 1 + (random() % 9); } while (ids[2]==ids[0] || ids[2]==ids[1]);
2580 i = strlen(args[0])-1;
2582 args[0][i] = '0' + ids[0];
2585 for (s = args[0]; *s; s++)
2586 if (isalpha(*s)) *s = toupper (*s);
2588 args[1] = strdup (args[0]);
2589 args[2] = strdup (args[0]); args[2][i] = '0' + ids[1];
2590 args[3] = strdup (args[0]); args[3][i] = '0' + ids[2];
2592 args[4] = strdup (args[1]);
2593 args[5] = strdup (args[2]);
2594 args[6] = strdup (args[3]);
2597 time_t t = time ((time_t *) 0);
2598 struct tm *tm = localtime (&t);
2599 args[7] = malloc (30);
2600 strftime (args[7], 29, "%d-%b-%Y %H:%M", tm);
2601 for (s = args[7]; *s; s++)
2602 if (isalpha(*s)) *s = toupper (*s);
2606 for (i = 0; i < countof(lines); i++)
2608 const char *fmt = lines[i];
2609 if (! strcmp (fmt, "..."))
2611 int steps = 180 + (random() % 60);
2612 while (--steps >= 0)
2614 BSOD_TEXT (bst, LEFT, ".");
2615 BSOD_PAUSE (bst, dot_delay);
2620 char *fmt2 = malloc (strlen (fmt) * 2 + 1);
2621 for (s = (char *) fmt, s1 = fmt2; *s; s++)
2625 strcpy (s1, args[arg_count++]);
2632 BSOD_CHAR_DELAY (bst, char_delay);
2633 BSOD_TEXT (bst, LEFT, fmt2);
2635 BSOD_CHAR_DELAY (bst, 0);
2636 BSOD_PAUSE (bst, chunk_delay);
2640 for (i = 0; i < countof (args); i++)
2643 XClearWindow(dpy, window);
2648 /* HVX (formerly GCOS6) and TPS6 crash
2649 by Brian Garratt <brian-m.garratt@bull.co.uk>
2651 GCOS6 is a Unix-like operating system developed by Honeywell in the
2652 1970s in collaboration with MIT and AT&T (who called their version
2653 UNIX). Both are very much like MULTICS which Honeywell got from GE.
2655 HVX ("High-performance Virtual System on Unix") is an AIX application
2656 which emulates GCOS6 hardware on RS6000-like machines.
2658 static struct bsod_state *
2659 hvx (Display *dpy, Window window)
2661 struct bsod_state *bst = make_bsod_state (dpy, window, "hvx", "HVX");
2663 bst->scroll_p = True;
2665 bst->y = bst->xgwa.height - bst->bottom_margin - bst->font->ascent;
2667 BSOD_CHAR_DELAY (bst, 10000);
2668 BSOD_TEXT (bst, LEFT,
2669 "(TP) Trap no E Effective address 00000000 Instruction D7DE\n"
2670 "(TP) Registers :\n"
2671 "(TP) B1 -> B7 03801B02 00000000 03880D45 038BABDB 0388AFFD"
2672 " 0389B3F8 03972317\n"
2673 "(TP) R1 -> R7 0001 0007 F10F 090F 0020 0106 0272\n"
2674 "(TP) P I Z M1 0388A18B 3232 0000 FF00\n"
2675 "(TP) Program counter is at offset 0028 from string YTPAD\n"
2676 "(TP) User id of task which trapped is LT 626\n"
2679 BSOD_PAUSE (bst, 1000000);
2681 BSOD_CHAR_DELAY (bst, 100000);
2682 BSOD_TEXT (bst, LEFT, " TP CLOSE ALL");
2684 BSOD_CHAR_DELAY (bst, 10000);
2685 BSOD_TEXT (bst, LEFT, "\n(TP)?\n");
2686 BSOD_PAUSE (bst, 1000000);
2688 BSOD_CHAR_DELAY (bst, 100000);
2689 BSOD_TEXT (bst, LEFT, " TP ABORT -LT ALL");
2691 BSOD_CHAR_DELAY (bst, 10000);
2692 BSOD_TEXT (bst, LEFT, "\n(TP)?\n");
2693 BSOD_PAUSE (bst, 1000000);
2695 BSOD_CHAR_DELAY (bst, 100000);
2696 BSOD_TEXT (bst, LEFT, " TP STOP KILL");
2698 BSOD_CHAR_DELAY (bst, 10000);
2699 BSOD_TEXT (bst, LEFT,
2702 "Core dumps initiated for selected HVX processes ...\n"
2703 "Core dumps complete.\n"
2704 "Fri Jul 19 15:53:09 2002\n"
2705 "Live registers for cp 0:\n"
2706 " P = 7de3 IW=0000 I=32 CI=30000000 S=80006013"
2707 " IV=aa0 Level=13\n"
2708 " R1-7 = 1f 913 13 4 8 0 0\n"
2709 " B1-7 = 64e71b a93 50e 64e73c 6c2c 7000 b54\n"
2710 "Memory dump starting to file /var/hvx/dp01/diag/Level2 ...\n"
2711 "Memory dump complete.\n"
2714 XClearWindow(dpy, window);
2719 /* HPUX panic, by Tobias Klausmann <klausman@schwarzvogel.de>
2721 static struct bsod_state *
2722 hpux (Display *dpy, Window window)
2724 struct bsod_state *bst = make_bsod_state (dpy, window, "hvx", "HVX");
2725 const char *sysname;
2728 bst->scroll_p = True;
2729 bst->y = bst->xgwa.height - bst->bottom_margin - bst->font->ascent;
2736 if (uname (&uts) >= 0)
2737 sysname = uts.nodename;
2738 s = strchr (sysname, '.');
2741 # endif /* !HAVE_UNAME */
2743 BSOD_TEXT (bst, LEFT,
2747 sprintf (buf, "%.100s [HP Release B.11.00] (see /etc/issue)\n", sysname);
2748 BSOD_TEXT (bst, LEFT, buf);
2749 BSOD_PAUSE (bst, 1000000);
2750 BSOD_TEXT (bst, LEFT,
2753 " ******* Unexpected HPMC/TOC. Processor HPA FFFFFFFF'"
2754 "FFFA0000 *******\n"
2755 " GENERAL REGISTERS:\n"
2756 "r00/03 00000000'00000000 00000000'00000000 00000000'00000000 00000000'"
2758 "r04/07 00000000'00000001 00000000'0126E328 00000000'00000000 00000000'"
2760 "r08/11 00000000'00000000 00000000'0198CFC0 00000000'000476FE 00000000'"
2762 "r12/15 00000000'40013EE8 00000000'08000080 00000000'4002530C 00000000'"
2764 "r16/19 00000000'7F7F2A00 00000000'00000001 00000000'00000000 00000000'"
2766 "r20/23 00000000'006C8048 00000000'00000001 00000000'00000000 00000000'"
2768 "r24/27 00000000'00000000 00000000'00000000 00000000'00000000 00000000'"
2770 "r28/31 00000000'00000000 00000000'007DD628 00000000'0199F2B0 00000000'"
2772 " CONTROL REGISTERS:\n"
2773 "sr0/3 00000000'0F3B4000 00000000'0C2A2000 00000000'016FF800 00000000'"
2775 "sr4/7 00000000'00000000 00000000'016FF800 00000000'0DBF1400 00000000'"
2777 "pcq = 00000000'00000000.00000000'00104950 00000000'00000000.00000000'"
2779 "isr = 00000000'10240006 ior = 00000000'67D9E220 iir = 08000240 rctr = "
2782 "pid reg cr8/cr9 00007700'0000B3A9 00000000'0000C5D8\n"
2783 "pid reg cr12/cr13 00000000'00000000 00000000'00000000\n"
2784 "ipsw = 000000FF'080CFF1F iva = 00000000'0002C000 sar = 3A ccr = C0\n"
2785 "tr0/3 00000000'006C76C0 00000000'00000001 00000000'00000000 00000000'"
2787 "tr4/7 00000000'03790000 0000000C'4FB68340 00000000'C07EE13F 00000000'"
2789 "eiem = FFFFFFF0'FFFFFFFF eirr = 80000000'00000000 itmr = 0000000C'"
2791 "cr1/4 00000000'00000000 00000000'00000000 00000000'00000000 00000000'"
2793 "cr5/7 00000000'00000000 00000000'00000000 00000000'"
2795 " MACHINE CHECK PARAMETERS:\n"
2796 "Check Type = 00000000 CPU STATE = 9E000001 Cache Check = 00000000\n"
2797 "TLB Check = 00000000 Bus Check = 00000000 PIM State = ? SIU "
2798 "Status = ????????\n"
2799 "Assists = 00000000 Processor = 00000000\n"
2800 "Slave Addr = 00000000'00000000 Master Addr = 00000000'00000000\n"
2803 "TOC, pcsq.pcoq = 0'0.0'104950 , isr.ior = 0'10240006.0'67d9e220\n"
2804 "@(#)B2352B/9245XB HP-UX (B.11.00) #1: Wed Nov 5 22:38:19 PST 1997\n"
2805 "Transfer of control: (display==0xd904, flags==0x0)\n"
2809 "*** A system crash has occurred. (See the above messages for details.)\n"
2810 "*** The system is now preparing to dump physical memory to disk, for use\n"
2811 "*** in debugging the crash.\n"
2813 "*** The dump will be a SELECTIVE dump: 40 of 256 megabytes.\n"
2814 "*** To change this dump type, press any key within 10 seconds.\n"
2815 "*** Proceeding with selective dump.\n"
2817 "*** The dump may be aborted at any time by pressing ESC.\n");
2823 for (i = 0; i <= steps; i++)
2825 if (i > steps) i = steps;
2827 "*** Dumping: %3d%% complete (%d of 40 MB) (device 64:0x2)\r",
2830 BSOD_TEXT (bst, LEFT, buf);
2831 BSOD_PAUSE (bst, 1500000);
2835 BSOD_TEXT (bst, LEFT, "\n*** System rebooting.\n");
2837 XClearWindow(dpy, window);
2842 /* IBM OS/390 aka MVS aka z/OS.
2843 Text from Dan Espen <dane@mk.telcordia.com>.
2844 Apparently this isn't actually a crash, just a random session...
2847 static struct bsod_state *
2848 os390 (Display *dpy, Window window)
2850 struct bsod_state *bst = make_bsod_state (dpy, window, "os390", "OS390");
2852 bst->scroll_p = True;
2853 bst->y = bst->xgwa.height - bst->bottom_margin - bst->font->ascent;
2855 BSOD_LINE_DELAY (bst, 100000);
2856 BSOD_TEXT (bst, LEFT,
2857 "\n*** System rebooting.\n"
2858 "* ISPF Subtask abend *\n"
2859 "SPF ENDED DUE TO ERROR+\n"
2862 "IEA995I SYMPTOM DUMP OUTPUT\n"
2863 " USER COMPLETION CODE=0222\n"
2864 " TIME=23.00.51 SEQ=03210 CPU=0000 ASID=00AE\n"
2865 " PSW AT TIME OF ERROR 078D1000 859DAF18 ILC 2 INTC 0D\n"
2866 " NO ACTIVE MODULE FOUND\n"
2868 " DATA AT PSW 059DAF12 - 00181610 0A0D9180 70644710\n"
2869 " AR/GR 0: 00000000/80000000 1: 00000000/800000DE\n"
2870 " 2: 00000000/196504DC 3: 00000000/00037A78\n"
2871 " 4: 00000000/00037B78 5: 00000000/0003351C\n"
2872 " 6: 00000000/0000F0AD 7: 00000000/00012000\n"
2873 " 8: 00000000/059DAF10 9: 00000000/0002D098\n"
2874 " A: 00000000/059D9F10 B: 00000000/059D8F10\n"
2875 " C: 00000000/859D7F10 D: 00000000/00032D60\n"
2876 " E: 00000000/00033005 F: 01000002/00000041\n"
2877 " END OF SYMPTOM DUMP\n"
2878 "ISPS014 - ** Logical screen request failed - abend 0000DE **\n"
2879 "ISPS015 - ** Contact your system programmer or dialog developer.**\n"
2880 "*** ISPF Main task abend ***\n"
2881 "IEA995I SYMPTOM DUMP OUTPUT\n"
2882 " USER COMPLETION CODE=0222\n"
2883 " TIME=23.00.52 SEQ=03211 CPU=0000 ASID=00AE\n"
2884 " PSW AT TIME OF ERROR 078D1000 8585713C ILC 2 INTC 0D\n"
2885 " ACTIVE LOAD MODULE ADDRESS=05855000 OFFSET=0000213C\n"
2887 " DATA AT PSW 05857136 - 00181610 0A0D9180 D3304770\n"
2888 " GR 0: 80000000 1: 800000DE\n"
2889 " 2: 00015260 3: 00000038\n"
2890 " 4: 00012508 5: 00000000\n"
2891 " 6: 000173AC 7: FFFFFFF8\n"
2892 " 8: 05858000 9: 00012CA0\n"
2893 " A: 05857000 B: 05856000\n"
2894 " C: 85855000 D: 00017020\n"
2895 " E: 85857104 F: 00000000\n"
2896 " END OF SYMPTOM DUMP\n"
2899 BSOD_CURSOR (bst, CURSOR_LINE, 240000, 999999);
2901 XClearWindow(dpy, window);
2906 /* Compaq Tru64 Unix panic, by jwz as described by
2907 Tobias Klausmann <klausman@schwarzvogel.de>
2909 static struct bsod_state *
2910 tru64 (Display *dpy, Window window)
2912 struct bsod_state *bst = make_bsod_state (dpy, window, "tru64", "Tru64");
2913 const char *sysname;
2916 bst->scroll_p = True;
2917 bst->y = bst->xgwa.height - bst->bottom_margin - bst->font->ascent;
2919 sysname = "127.0.0.1";
2923 if (uname (&uts) >= 0)
2924 sysname = uts.nodename;
2926 # endif /* !HAVE_UNAME */
2929 "Compaq Tru64 UNIX V5.1B (Rev. 2650) (%.100s) console\n"
2933 BSOD_TEXT (bst, LEFT, buf);
2934 BSOD_PAUSE (bst, 6000000);
2936 BSOD_TEXT (bst, LEFT,
2937 "panic (cpu 0): trap: illegal instruction\n"
2938 "kernel inst fault=gentrap, ps=0x5, pc=0xfffffc0000593878, inst=0xaa\n"
2939 "kernel inst fault=gentrap, ps=0x5, pc=0xfffffc0000593878, inst=0xaa\n"
2941 "DUMP: blocks available: 1571600\n"
2942 "DUMP: blocks wanted: 100802 (partial compressed dump) [OKAY]\n"
2943 "DUMP: Device Disk Blocks Available\n"
2944 "DUMP: ------ ---------------------\n"
2945 "DUMP: 0x1300023 1182795 - 1571597 (of 1571598) [primary swap]\n"
2946 "DUMP.prom: Open: dev 0x5100041, block 2102016: SCSI 0 11 0 2 200 0 0\n"
2947 "DUMP: Writing header... [1024 bytes at dev 0x1300023, block 1571598]\n"
2948 "DUMP: Writing data");
2952 int steps = 4 + (random() % 8);
2953 BSOD_CHAR_DELAY (bst, 1000000);
2954 for (i = 0; i < steps; i++)
2955 BSOD_TEXT (bst, LEFT, ".");
2956 BSOD_CHAR_DELAY (bst, 0);
2957 sprintf (buf, "[%dMB]\n", steps);
2958 BSOD_TEXT (bst, LEFT, buf);
2961 BSOD_TEXT (bst, LEFT,
2962 "DUMP: Writing header... [1024 bytes at dev 0x1300023, block 1571598]\n"
2963 "DUMP: crash dump complete.\n"
2964 "kernel inst fault=gentrap, ps=0x5, pc=0xfffffc0000593878, inst=0xaa\n"
2966 "DUMP: second crash dump skipped: 'dump_savecnt' enforced.\n");
2967 BSOD_PAUSE (bst, 4000000);
2969 BSOD_TEXT (bst, LEFT,
2974 "HALT instruction executed\n"
2975 "PC = fffffc00005863b0\n");
2976 BSOD_PAUSE (bst, 3000000);
2978 BSOD_TEXT (bst, LEFT,
2985 XClearWindow(dpy, window);
2992 static struct bsod_state *
2993 msdos (Display *dpy, Window window)
2995 struct bsod_state *bst = make_bsod_state (dpy, window, "msdos", "MSDOS");
2997 BSOD_CHAR_DELAY (bst, 10000);
2998 BSOD_TEXT (bst, LEFT, "C:\\WINDOWS>");
2999 BSOD_CURSOR (bst, CURSOR_LINE, 200000, 8);
3001 BSOD_CHAR_DELAY (bst, 200000);
3002 BSOD_TEXT (bst, LEFT, "dir a:");
3003 BSOD_PAUSE (bst, 1000000);
3005 BSOD_CHAR_DELAY (bst, 10000);
3006 BSOD_TEXT (bst, LEFT, "\nNot ready reading drive A\nAbort, Retry, Fail?");
3008 BSOD_CURSOR (bst, CURSOR_LINE, 200000, 10);
3009 BSOD_CHAR_DELAY (bst, 200000);
3010 BSOD_TEXT (bst, LEFT, "f");
3011 BSOD_PAUSE (bst, 1000000);
3013 BSOD_CHAR_DELAY (bst, 10000);
3014 BSOD_TEXT (bst, LEFT,
3015 "\n\n\nNot ready reading drive A\nAbort, Retry, Fail?");
3017 BSOD_CURSOR (bst, CURSOR_LINE, 200000, 10);
3018 BSOD_CHAR_DELAY (bst, 200000);
3019 BSOD_TEXT (bst, LEFT, "f");
3020 BSOD_PAUSE (bst, 1000000);
3022 BSOD_CHAR_DELAY (bst, 10000);
3023 BSOD_TEXT (bst, LEFT, "\nVolume in drive A has no label\n\n"
3024 "Not ready reading drive A\nAbort, Retry, Fail?");
3026 BSOD_CURSOR (bst, CURSOR_LINE, 200000, 12);
3027 BSOD_CHAR_DELAY (bst, 200000);
3028 BSOD_TEXT (bst, LEFT, "a");
3029 BSOD_PAUSE (bst, 1000000);
3031 BSOD_CHAR_DELAY (bst, 10000);
3032 BSOD_TEXT (bst, LEFT, "\n\nC:\\WINDOWS>");
3034 BSOD_CURSOR (bst, CURSOR_LINE, 200000, 999999);
3036 XClearWindow(dpy, window);
3043 * This is what happens if an Nvidia card goes into some crazy text mode.
3044 * Most often seen on the second screen of a dual-head system when the
3045 * proper driver isn't loaded.
3047 typedef struct { int fg; int bg; int bit; Bool blink; } nvcell;
3050 nvspatter (nvcell *grid, int rows, int cols, int ncolors, int nbits,
3053 int max = rows * cols;
3054 int from = fill_p ? 0 : random() % (max - 1);
3055 int len = fill_p ? max : random() % (cols * 4);
3056 int to = from + len;
3058 Bool noisy = ((random() % 4) == 0);
3059 Bool diag = (noisy || fill_p) ? 0 : ((random() % 4) == 0);
3061 int fg = random() % ncolors;
3062 int bg = random() % ncolors;
3063 int blink = ((random() % 4) == 0);
3064 int bit = (random() % nbits);
3066 if (to > max) to = max;
3070 int src = random() % (rows * cols);
3071 int len2 = (cols / 2) - (random() % 5);
3073 for (i = from; i < to; i++, j++)
3075 if (j > src + len2 || j >= max)
3077 if (i >= max) abort();
3078 if (j >= max) abort();
3083 for (i = from; i < to; i++)
3085 nvcell *cell = &grid[i];
3089 cell->blink = blink;
3093 fg = random() % ncolors;
3094 bg = random() % ncolors;
3095 blink = ((random() % 8) == 0);
3101 struct bsod_state *bst;
3108 unsigned long colors[256];
3114 nvidia_free (struct bsod_state *bst)
3116 nvstate *nvs = (nvstate *) bst->closure;
3118 XFreeColors (bst->dpy, bst->xgwa.colormap, nvs->colors, nvs->ncolors, 0);
3119 for (i = 0; i < countof(nvs->bits); i++)
3120 XFreePixmap (bst->dpy, nvs->bits[i]);
3121 XFreeGC (bst->dpy, nvs->gc1);
3127 nvidia_draw (struct bsod_state *bst)
3129 nvstate *nvs = (nvstate *) bst->closure;
3132 for (y = 0; y < nvs->rows; y++)
3133 for (x = 0; x < nvs->cols; x++)
3135 nvcell *cell = &nvs->grid[y * nvs->cols + x];
3136 unsigned long fg = nvs->colors[cell->fg];
3137 unsigned long bg = nvs->colors[cell->bg];
3138 Bool flip = cell->blink && (nvs->tick & 1);
3139 XSetForeground (bst->dpy, bst->gc, flip ? fg : bg);
3140 XSetBackground (bst->dpy, bst->gc, flip ? bg : fg);
3141 XCopyPlane (bst->dpy, nvs->bits[cell->bit], bst->window, bst->gc,
3142 0, 0, nvs->cellw, nvs->cellh,
3143 x * nvs->cellw, y * nvs->cellh, 1L);
3147 if ((random() % 5) == 0) /* change the display */
3148 nvspatter (nvs->grid, nvs->rows, nvs->cols, nvs->ncolors,
3149 countof(nvs->bits), False);
3155 static struct bsod_state *
3156 nvidia (Display *dpy, Window window)
3158 struct bsod_state *bst = make_bsod_state (dpy, window, "nvidia", "nVidia");
3159 nvstate *nvs = (nvstate *) calloc (1, sizeof (*nvs));
3166 bst->draw_cb = nvidia_draw;
3167 bst->free_cb = nvidia_free;
3171 nvs->cellw = bst->xgwa.width / nvs->cols;
3172 nvs->cellh = bst->xgwa.height / nvs->rows;
3173 if (nvs->cellw < 8 || nvs->cellh < 18)
3174 nvs->cellw = 8, nvs->cellh = 18;
3175 nvs->cols = (bst->xgwa.width / nvs->cellw) + 1;
3176 nvs->rows = (bst->xgwa.height / nvs->cellh) + 1;
3178 nvs->grid = (nvcell *) calloc (sizeof(*nvs->grid), nvs->rows * nvs->cols);
3183 for (i = 0; i < nvs->ncolors; i++)
3186 c.red = random() & 0xFFFF;
3187 c.green = random() & 0xFFFF;
3188 c.blue = random() & 0xFFFF;
3189 c.flags = DoRed|DoGreen|DoBlue;
3190 XAllocColor (dpy, bst->xgwa.colormap, &c);
3191 nvs->colors[i] = c.pixel;
3194 /* Construct corrupted character bitmaps
3196 for (i = 0; i < countof(nvs->bits); i++)
3200 nvs->bits[i] = XCreatePixmap (dpy, window, nvs->cellw, nvs->cellh, 1);
3201 if (!nvs->gc1) nvs->gc1 = XCreateGC (dpy, nvs->bits[i], 0, &gcv);
3203 XSetForeground (dpy, nvs->gc1, 0);
3204 XFillRectangle (dpy, nvs->bits[i], nvs->gc1, 0, 0,
3205 nvs->cellw, nvs->cellh);
3206 XSetForeground (dpy, nvs->gc1, 1);
3208 if ((random() % 40) != 0)
3209 for (j = 0; j < ((nvs->cellw * nvs->cellh) / 16); j++)
3210 XFillRectangle (dpy, nvs->bits[i], nvs->gc1,
3211 (random() % (nvs->cellw-2)) & ~1,
3212 (random() % (nvs->cellh-2)) & ~1,
3216 /* Randomize the grid
3218 nvspatter (nvs->grid, nvs->rows, nvs->cols, nvs->ncolors,
3219 countof(nvs->bits), True);
3220 for (i = 0; i < 20; i++)
3221 nvspatter (nvs->grid, nvs->rows, nvs->cols, nvs->ncolors,
3222 countof(nvs->bits), False);
3229 * Simulate various Apple ][ crashes. The memory map encouraged many programs
3230 * to use the primary hi-res video page for various storage, and the secondary
3231 * hi-res page for active display. When it crashed into Applesoft or the
3232 * monitor, it would revert to the primary page and you'd see memory garbage on
3233 * the screen. Also, it was common for copy-protected games to use the primary
3234 * text page for important code, because that made it really hard to
3235 * reverse-engineer them. The result often looked like what this generates.
3237 * The Apple ][ logic and video hardware is in apple2.c. The TV is emulated by
3238 * analogtv.c for maximum realism
3240 * Trevor Blackwell <tlb@tlb.org>
3243 static const char * const apple2_basic_errors[]={
3247 "RETURN WITHOUT GOSUB",
3251 "BAD SUBSCRIPT ERROR",
3254 "FORMULA TOO COMPLEX",
3259 "DEFAULT ARGUMENTS ARE NOT ALLOWED IN DECLARATION OF FRIEND "
3260 "TEMPLATE SPECIALIZATION"
3264 static const char * const apple2_dos_errors[]={
3268 "NO BUFFERS AVAILABLE",
3269 "PROGRAM TOO LARGE",
3272 static void a2controller_crash(apple2_sim_t *sim, int *stepno,
3273 double *next_actiontime)
3275 apple2_state_t *st=sim->st;
3284 if (!sim->controller_data)
3285 sim->controller_data = calloc(sizeof(struct mydata),1);
3286 mine=(struct mydata *) sim->controller_data;
3291 a2_init_memory_active(sim);
3292 sim->dec->powerup = 1000.0;
3294 if (random()%3==0) {
3296 *next_actiontime+=0.4;
3299 else if (random()%4==0) {
3300 st->gr_mode=A2_GR_LORES;
3301 if (random()%3==0) st->gr_mode |= A2_GR_FULL;
3302 *next_actiontime+=0.4;
3305 else if (random()%2==0) {
3306 st->gr_mode=A2_GR_HIRES;
3310 st->gr_mode=A2_GR_HIRES;
3311 *next_actiontime+=0.4;
3317 /* An illegal instruction or a reset caused it to drop into the
3318 assembly language monitor, where you could disassemble code & view
3320 if (random()%3==0) {
3323 int addr=0xd000+random()%0x3000;
3325 "%02X",random()%0xff);
3328 sprintf(sim->printing_buf,
3331 " A=%02X X=%02X Y=%02X S=%02X F=%02X\n"
3334 random()%0xff, random()%0xff,
3335 random()%0xff, random()%0xff,
3337 sim->printing=sim->printing_buf;
3345 *next_actiontime += 2.0 + (random()%1000)*0.0002;
3348 /* Lots of programs had at least their main functionality in
3349 Applesoft Basic, which had a lot of limits (memory, string
3350 length, etc) and would sometimes crash unexpectedly. */
3351 sprintf(sim->printing_buf,
3357 apple2_basic_errors[random() %
3358 (sizeof(apple2_basic_errors)
3360 (1000*(random()%(random()%59+1)) +
3361 100*(random()%(random()%9+1)) +
3362 5*(random()%(random()%199+1)) +
3363 1*(random()%(random()%(random()%2+1)+1))));
3364 sim->printing=sim->printing_buf;
3368 *next_actiontime += 2.0 + (random()%1000)*0.0002;
3373 if (random()%3==0) {
3374 /* This was how you reset the Basic interpreter. The sort of
3375 incantation you'd have on a little piece of paper taped to the
3376 side of your machine */
3377 sim->typing="CALL -1370";
3380 else if (random()%2==0) {
3381 sim->typing="CATALOG\n";
3385 *next_actiontime+=1.0;
3392 *next_actiontime += 0.5;
3399 for (s="APPLE ]["; *s; s++) a2_printc(st,*s);
3402 *next_actiontime+=1.0;
3407 if (random()%50==0) {
3408 sprintf(sim->printing_buf,
3409 "\nDISK VOLUME 254\n\n"
3413 sim->printing=sim->printing_buf;
3416 sprintf(sim->printing_buf,"\n?%s\n]",
3417 apple2_dos_errors[random()%
3418 (sizeof(apple2_dos_errors) /
3420 sim->printing=sim->printing_buf;
3423 *next_actiontime+=1.0;
3427 if (random()%2==0) {
3428 /* This was how you went back to text mode in the monitor */
3429 sim->typing="FB4BG";
3432 *next_actiontime+=1.0;
3443 *next_actiontime+=2.0;
3447 /* This reset things into Basic */
3448 if (random()%2==0) {
3449 sim->typing="FAA6G";
3454 *next_actiontime+=sim->delay;
3459 for (i=0; i<1500; i++) {
3460 a2_poke(st, mine->fillptr, mine->fillbyte);
3462 mine->fillbyte = (mine->fillbyte+1)&0xff;
3464 *next_actiontime += 0.08;
3465 /* When you hit c000, it changed video settings */
3466 if (mine->fillptr>=0xc000) {
3470 /* And it seemed to reset around here, I dunno why */
3471 if (mine->fillptr>=0xcf00) *stepno=130;
3477 case A2CONTROLLER_FREE:
3484 a2_draw (struct bsod_state *bst)
3486 apple2_sim_t *sim = (apple2_sim_t *) bst->closure;
3488 sim = apple2_start (bst->dpy, bst->window, 9999999, a2controller_crash);
3492 if (! apple2_one_frame (sim)) {
3500 a2_free (struct bsod_state *bst)
3502 apple2_sim_t *sim = (apple2_sim_t *) bst->closure;
3504 sim->stepno = A2CONTROLLER_DONE;
3505 a2_draw (bst); /* finish up */
3506 if (bst->closure) abort(); /* should have been freed by now */
3511 static struct bsod_state *
3512 apple2crash (Display *dpy, Window window)
3514 struct bsod_state *bst = make_bsod_state (dpy, window, "apple2", "Apple2");
3515 bst->draw_cb = a2_draw;
3516 bst->free_cb = a2_free;
3521 static struct bsod_state *
3522 atm (Display *dpy, Window window)
3524 struct bsod_state *bst = make_bsod_state (dpy, window, "atm", "ATM");
3527 int pix_w = atm_width;
3528 int pix_h = atm_height;
3532 XClearWindow (dpy, window);
3534 pixmap = XCreatePixmapFromBitmapData (dpy, window, (char *) atm_bits,
3535 atm_width, atm_height,
3536 bst->fg, bst->bg, bst->xgwa.depth);
3538 while (pix_w <= bst->xgwa.width * scale &&
3539 pix_h <= bst->xgwa.height * scale)
3541 pixmap = double_pixmap (dpy, bst->gc, bst->xgwa.visual, bst->xgwa.depth,
3542 pixmap, pix_w, pix_h);
3548 x = (bst->xgwa.width - pix_w) / 2;
3549 y = (bst->xgwa.height - pix_h) / 2;
3555 XSetForeground (dpy, bst->gc,
3556 get_pixel_resource (dpy, bst->xgwa.colormap,
3559 for (j = -1; j < pix_w; j += i+1)
3560 XDrawLine (bst->dpy, pixmap, bst->gc, j, 0, j, pix_h);
3561 for (j = -1; j < pix_h; j += i+1)
3562 XDrawLine (bst->dpy, pixmap, bst->gc, 0, j, pix_w, j);
3565 XCopyArea (dpy, pixmap, window, bst->gc, 0, 0, pix_w, pix_h, x, y);
3567 XFreePixmap (dpy, pixmap);
3573 /*****************************************************************************
3574 *****************************************************************************/
3577 static const struct {
3579 struct bsod_state * (*fn) (Display *, Window);
3581 { "Windows", windows_31 },
3582 { "NT", windows_nt },
3583 { "Win2K", windows_other },
3586 { "MacsBug", macsbug },
3591 { "HPPALinux", hppa_linux },
3592 { "SparcLinux", sparc_linux },
3596 { "BlitDamage", blitdamage },
3598 { "Solaris", sparc_solaris },
3599 { "Linux", linux_fsck },
3606 { "Nvidia", nvidia },
3607 { "Apple2", apple2crash },
3612 struct driver_state {
3617 Bool debug_p, cycle_p;
3618 struct bsod_state *bst;
3623 hack_title (struct driver_state *dst)
3627 XFetchName (dst->bst->dpy, dst->bst->window, &oname);
3628 if (oname && !strncmp (oname, "BSOD: ", 6)) {
3629 char *tail = oname + 4;
3630 char *s = strchr (tail+1, ':');
3633 nname = malloc (strlen (tail) + strlen (dst->name) + 20);
3634 sprintf (nname, "BSOD: %s%s", dst->name, tail);
3635 XStoreName (dst->bst->dpy, dst->bst->window, nname);
3638 # endif /* !HAVE_COCOA */
3642 bsod_init (Display *dpy, Window window)
3644 struct driver_state *dst = (struct driver_state *) calloc (1, sizeof(*dst));
3647 dst->delay = get_integer_resource (dpy, "delay", "Integer");
3648 if (dst->delay < 3) dst->delay = 3;
3650 dst->debug_p = get_boolean_resource (dpy, "debug", "Boolean");
3653 s = get_string_resource(dpy, "doOnly", "DoOnly");
3654 if (s && !strcasecmp (s, "cycle"))
3657 dst->cycle_p = True;
3661 int count = countof(all_modes);
3662 for (dst->only = 0; dst->only < count; dst->only++)
3663 if (!strcasecmp (s, all_modes[dst->only].name))
3665 if (dst->only >= count)
3667 fprintf (stderr, "%s: unknown -only mode: \"%s\"\n", progname, s);
3679 static unsigned long
3680 bsod_draw (Display *dpy, Window window, void *closure)
3682 struct driver_state *dst = (struct driver_state *) closure;
3687 now = time ((time_t *) 0);
3688 time_left = dst->start + dst->delay - now;
3690 if (dst->bst && dst->bst->img_loader) /* still loading */
3692 dst->bst->img_loader =
3693 load_image_async_simple (dst->bst->img_loader, 0, 0, 0, 0, 0);
3697 if (! dst->bst && time_left > 0) /* run completed; wait out the delay */
3700 fprintf (stderr, "%s: %s: %d left\n", progname, dst->name, time_left);
3704 else if (dst->bst) /* sub-mode currently running */
3706 int this_delay = -1;
3709 this_delay = bsod_pop (dst->bst);
3711 /* XSync (dpy, False); slows down char drawing too much on HAVE_COCOA */
3713 if (this_delay == 0)
3714 goto AGAIN; /* no delay, not expired: stay here */
3715 else if (this_delay >= 0)
3716 return this_delay; /* return; time to sleep */
3718 { /* sub-mode run completed or expired */
3720 fprintf (stderr, "%s: %s: done\n", progname, dst->name);
3721 free_bsod_state (dst->bst);
3726 else /* launch a new sub-mode */
3729 dst->which = (dst->which + 1) % countof(all_modes);
3730 else if (dst->only >= 0)
3731 dst->which = dst->only;
3734 int count = countof(all_modes);
3737 for (i = 0; i < 200; i++)
3739 char name[100], class[100];
3740 int new_mode = (random() & 0xFF) % count;
3742 if (i < 100 && new_mode == dst->which)
3745 sprintf (name, "do%s", all_modes[new_mode].name);
3746 sprintf (class, "Do%s", all_modes[new_mode].name);
3748 if (get_boolean_resource (dpy, name, class))
3750 dst->which = new_mode;
3757 fprintf (stderr, "%s: no display modes enabled?\n", progname);
3759 dst->which = dst->only = 0;
3764 fprintf (stderr, "%s: %s: launch\n", progname,
3765 all_modes[dst->which].name);
3767 /* Run the mode setup routine...
3769 if (dst->bst) abort();
3770 dst->name = all_modes[dst->which].name;
3771 dst->bst = all_modes[dst->which].fn (dpy, window);
3772 dst->start = (dst->bst ? time ((time_t *) 0) : 0);
3774 /* Reset the structure run state to the beginning,
3775 and do some sanitization of the cursor position
3776 before the first run.
3781 fprintf (stderr, "%s: %s: queue size: %d (%d)\n", progname,
3782 dst->name, dst->bst->pos, dst->bst->queue_size);
3786 dst->bst->x = dst->bst->current_left = dst->bst->left_margin;
3788 if (dst->bst->y < dst->bst->top_margin + dst->bst->font->ascent)
3789 dst->bst->y = dst->bst->top_margin + dst->bst->font->ascent;
3798 bsod_reshape (Display *dpy, Window window, void *closure,
3799 unsigned int w, unsigned int h)
3801 struct driver_state *dst = (struct driver_state *) closure;
3804 w == dst->bst->xgwa.width &&
3805 h == dst->bst->xgwa.height)
3809 fprintf (stderr, "%s: %s: reshape reset\n", progname, dst->name);
3811 /* just pick a new mode and restart when the window is resized. */
3813 free_bsod_state (dst->bst);
3817 XClearWindow (dpy, window);
3822 bsod_event (Display *dpy, Window window, void *closure, XEvent *event)
3824 struct driver_state *dst = (struct driver_state *) closure;
3825 Bool reset_p = False;
3827 /* pick a new mode and restart when mouse clicked, or certain keys typed. */
3829 if (event->type == ButtonPress)
3831 else if (event->type == KeyPress)
3835 XLookupString (&event->xkey, &c, 1, &keysym, 0);
3836 if (c == ' ' || c == '\t' || c == '\r' || c == '\n')
3843 fprintf (stderr, "%s: %s: manual reset\n", progname, dst->name);
3845 free_bsod_state (dst->bst);
3849 XClearWindow (dpy, window);
3858 bsod_free (Display *dpy, Window window, void *closure)
3860 struct driver_state *dst = (struct driver_state *) closure;
3862 free_bsod_state (dst->bst);
3867 static const char *bsod_defaults [] = {
3881 "*doAtari: False", /* boring */
3882 "*doBSD: False", /* boring */
3884 "*doSparcLinux: False", /* boring */
3885 "*doHPPALinux: True",
3886 "*doBlitDamage: True",
3900 "*font2: -*-courier-bold-r-*-*-*-120-*-*-m-*-*-*",
3901 "*bigFont: -*-courier-bold-r-*-*-*-180-*-*-m-*-*-*",
3902 "*bigFont2: -*-courier-bold-r-*-*-*-180-*-*-m-*-*-*",
3904 ".foreground: White",
3905 ".background: Black",
3907 ".windows.foreground: White",
3908 ".windows.background: #0000AA", /* EGA color 0x01. */
3910 ".windowslh.foreground: White",
3911 ".windowslh.background: #AA0000", /* EGA color 0x04. */
3912 ".windowslh.background2: #AAAAAA", /* EGA color 0x07. */
3914 ".amiga.foreground: #FF0000",
3915 ".amiga.background: Black",
3916 ".amiga.background2: White",
3918 ".mac.foreground: #BBFFFF",
3919 ".mac.background: Black",
3921 ".atari.foreground: Black",
3922 ".atari.background: White",
3924 ".macsbug.font: -*-courier-medium-r-*-*-*-80-*-*-m-*-*-*",
3925 ".macsbug.bigFont: -*-courier-bold-r-*-*-*-140-*-*-m-*-*-*",
3926 ".macsbug.foreground: Black",
3927 ".macsbug.background: White",
3928 ".macsbug.borderColor: #AAAAAA",
3930 ".mac1.foreground: Black",
3931 ".mac1.background: White",
3933 ".macx.foreground: White",
3934 ".macx.textForeground: White",
3935 ".macx.textBackground: Black",
3936 ".macx.background: #888888",
3938 ".sco.font: -*-courier-bold-r-*-*-*-140-*-*-m-*-*-*",
3939 ".sco.foreground: White",
3940 ".sco.background: Black",
3942 ".hvx.font: -*-courier-bold-r-*-*-*-140-*-*-m-*-*-*",
3943 ".hvx.foreground: White",
3944 ".hvx.background: Black",
3946 ".linux.foreground: White",
3947 ".linux.background: Black",
3949 ".hppalinux.bigFont: -*-courier-bold-r-*-*-*-140-*-*-m-*-*-*",
3950 ".hppalinux.foreground: White",
3951 ".hppalinux.background: Black",
3953 ".sparclinux.bigFont: -*-courier-bold-r-*-*-*-140-*-*-m-*-*-*",
3954 ".sparclinux.foreground: White",
3955 ".sparclinux.background: Black",
3958 ".bsd.bigFont: -sun-console-medium-r-*-*-22-*-*-*-m-*-*-*",
3959 ".bsd.bigFont2: -*-courier-bold-r-*-*-*-140-*-*-m-*-*-*",
3960 ".bsd.foreground: #c0c0c0",
3961 ".bsd.background: Black",
3963 ".solaris.font: -sun-gallant-*-*-*-*-19-*-*-*-*-120-*-*",
3964 ".solaris.foreground: Black",
3965 ".solaris.background: White",
3967 ".hpux.bigFont: -*-courier-bold-r-*-*-*-140-*-*-m-*-*-*",
3968 ".hpux.foreground: White",
3969 ".hpux.background: Black",
3971 ".os390.bigFont: -*-courier-bold-r-*-*-*-140-*-*-m-*-*-*",
3972 ".os390.background: Black",
3973 ".os390.foreground: Red",
3975 ".tru64.bigFont: -*-courier-bold-r-*-*-*-140-*-*-m-*-*-*",
3976 ".tru64.foreground: White",
3977 ".tru64.background: #0000AA", /* EGA color 0x01. */
3979 ".vms.bigFont: -*-courier-bold-r-*-*-*-140-*-*-m-*-*-*",
3980 ".vms.foreground: White",
3981 ".vms.background: Black",
3983 ".msdos.bigFont: -*-courier-bold-r-*-*-*-140-*-*-m-*-*-*",
3984 ".msdos.foreground: White",
3985 ".msdos.background: Black",
3987 ".os2.foreground: White",
3988 ".os2.background: Black",
3990 ".atm.foreground: Black",
3991 ".atm.background: #FF6600",
3993 "*dontClearRoot: True",
3995 "*apple2TVColor: 50",
3997 "*apple2TVBrightness: 10",
3998 "*apple2TVContrast: 90",
3999 "*apple2SimulateUser: True",
4003 #ifdef HAVE_XSHM_EXTENSION
4009 static const XrmOptionDescRec bsod_options [] = {
4010 { "-delay", ".delay", XrmoptionSepArg, 0 },
4011 { "-only", ".doOnly", XrmoptionSepArg, 0 },
4012 { "-debug", ".debug", XrmoptionNoArg, "True" },
4013 { "-windows", ".doWindows", XrmoptionNoArg, "True" },
4014 { "-no-windows", ".doWindows", XrmoptionNoArg, "False" },
4015 { "-nt", ".doNT", XrmoptionNoArg, "True" },
4016 { "-no-nt", ".doNT", XrmoptionNoArg, "False" },
4017 { "-2k", ".doWin2K", XrmoptionNoArg, "True" },
4018 { "-no-2k", ".doWin2K", XrmoptionNoArg, "False" },
4019 { "-amiga", ".doAmiga", XrmoptionNoArg, "True" },
4020 { "-no-amiga", ".doAmiga", XrmoptionNoArg, "False" },
4021 { "-mac", ".doMac", XrmoptionNoArg, "True" },
4022 { "-no-mac", ".doMac", XrmoptionNoArg, "False" },
4023 { "-mac1", ".doMac1", XrmoptionNoArg, "True" },
4024 { "-no-mac1", ".doMac1", XrmoptionNoArg, "False" },
4025 { "-macx", ".doMacX", XrmoptionNoArg, "True" },
4026 { "-no-macx", ".doMacX", XrmoptionNoArg, "False" },
4027 { "-atari", ".doAtari", XrmoptionNoArg, "True" },
4028 { "-no-atari", ".doAtari", XrmoptionNoArg, "False" },
4029 { "-macsbug", ".doMacsBug", XrmoptionNoArg, "True" },
4030 { "-no-macsbug", ".doMacsBug", XrmoptionNoArg, "False" },
4031 { "-apple2", ".doApple2", XrmoptionNoArg, "True" },
4032 { "-no-apple2", ".doApple2", XrmoptionNoArg, "False" },
4033 { "-sco", ".doSCO", XrmoptionNoArg, "True" },
4034 { "-no-sco", ".doSCO", XrmoptionNoArg, "False" },
4035 { "-hvx", ".doHVX", XrmoptionNoArg, "True" },
4036 { "-no-hvx", ".doHVX", XrmoptionNoArg, "False" },
4037 { "-bsd", ".doBSD", XrmoptionNoArg, "True" },
4038 { "-no-bsd", ".doBSD", XrmoptionNoArg, "False" },
4039 { "-linux", ".doLinux", XrmoptionNoArg, "True" },
4040 { "-no-linux", ".doLinux", XrmoptionNoArg, "False" },
4041 { "-hppalinux", ".doHPPALinux", XrmoptionNoArg, "True" },
4042 { "-no-hppalinux", ".doHPPALinux", XrmoptionNoArg, "False" },
4043 { "-sparclinux", ".doSparcLinux", XrmoptionNoArg, "True" },
4044 { "-no-sparclinux", ".doSparcLinux", XrmoptionNoArg, "False" },
4045 { "-blitdamage", ".doBlitDamage", XrmoptionNoArg, "True" },
4046 { "-no-blitdamage", ".doBlitDamage", XrmoptionNoArg, "False" },
4047 { "-nvidia", ".doNvidia", XrmoptionNoArg, "True" },
4048 { "-no-nvidia", ".doNvidia", XrmoptionNoArg, "False" },
4049 { "-solaris", ".doSolaris", XrmoptionNoArg, "True" },
4050 { "-no-solaris", ".doSolaris", XrmoptionNoArg, "False" },
4051 { "-hpux", ".doHPUX", XrmoptionNoArg, "True" },
4052 { "-no-hpux", ".doHPUX", XrmoptionNoArg, "False" },
4053 { "-os390", ".doOS390", XrmoptionNoArg, "True" },
4054 { "-no-os390", ".doOS390", XrmoptionNoArg, "False" },
4055 { "-tru64", ".doHPUX", XrmoptionNoArg, "True" },
4056 { "-no-tru64", ".doTru64", XrmoptionNoArg, "False" },
4057 { "-vms", ".doVMS", XrmoptionNoArg, "True" },
4058 { "-no-vms", ".doVMS", XrmoptionNoArg, "False" },
4059 { "-msdos", ".doMSDOS", XrmoptionNoArg, "True" },
4060 { "-no-msdos", ".doMSDOS", XrmoptionNoArg, "False" },
4061 { "-os2", ".doOS2", XrmoptionNoArg, "True" },
4062 { "-no-os2", ".doOS2", XrmoptionNoArg, "False" },
4063 { "-atm", ".doATM", XrmoptionNoArg, "True" },
4064 { "-no-atm", ".doATM", XrmoptionNoArg, "False" },
4070 XSCREENSAVER_MODULE ("BSOD", bsod)