1 /* xscreensaver, Copyright (c) 1998-2011 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); \
269 /* Restart the whole thing from the beginning.
271 #define BSOD_RESET(bst) do { \
272 ensure_queue (bst); \
273 (bst)->queue[(bst)->pos].type = RESET; \
279 ensure_queue (struct bsod_state *bst)
282 if (bst->pos + 1 < bst->queue_size)
285 n = bst->queue_size + 10;
289 bst->queue = (struct bsod_event *)
290 realloc (bst->queue, n * sizeof(*bst->queue));
291 if (!bst->queue) abort();
292 memset (bst->queue + bst->queue_size, 0,
293 (n - bst->queue_size) * sizeof(*bst->queue));
299 position_for_text (struct bsod_state *bst, const char *line)
303 const char *start = line;
305 if (bst->queue[bst->pos].type != LEFT &&
306 bst->queue[bst->pos].type != LEFT_FULL)
309 int dir, ascent, descent;
311 const char *end = start;
312 while (*end && *end != '\r' && *end != '\n')
315 XTextExtents (bst->font, start, end-start,
316 &dir, &ascent, &descent, &ov);
317 if (ov.width > max_width)
318 max_width = ov.width;
323 switch (bst->queue[bst->pos].type) {
326 bst->current_left = bst->left_margin;
330 bst->x = max_width - bst->right_margin;
331 bst->current_left = bst->x;
336 int w = (bst->xgwa.width - bst->left_margin - bst->right_margin -
339 bst->x = bst->left_margin + (w / 2);
340 bst->current_left = bst->x;
350 bst_crlf (struct bsod_state *bst)
352 int lh = bst->font->ascent + bst->font->descent;
353 bst->x = bst->current_left;
354 if (!bst->scroll_p ||
355 bst->y + lh < bst->xgwa.height - bst->bottom_margin)
359 int w = bst->xgwa.width - bst->right_margin - bst->left_margin;
360 int h = bst->xgwa.height - bst->top_margin - bst->bottom_margin;
361 XCopyArea (bst->dpy, bst->window, bst->window, bst->gc,
363 bst->top_margin + lh,
367 XClearArea (bst->dpy, bst->window,
368 bst->left_margin, bst->top_margin + h - lh, w, lh, False);
374 draw_char (struct bsod_state *bst, char c)
380 bst->x = bst->current_left;
384 if (bst->macx_eol_kludge)
386 /* Special case for the weird way OSX crashes print newlines... */
387 XDrawImageString (bst->dpy, bst->window, bst->gc,
388 bst->x, bst->y, " ", 1);
389 XDrawImageString (bst->dpy, bst->window, bst->gc,
391 bst->y + bst->font->ascent + bst->font->descent,
396 else if (c == '\b') /* backspace */
398 int cw = (bst->font->per_char
399 ? bst->font->per_char['n'-bst->font->min_char_or_byte2].width
400 : bst->font->min_bounds.width);
402 if (bst->x < bst->left_margin)
403 bst->x = bst->left_margin;
407 int dir, ascent, descent;
409 XTextExtents (bst->font, &c, 1, &dir, &ascent, &descent, &ov);
412 bst->x + ov.width > bst->xgwa.width - bst->right_margin)
415 XDrawImageString (bst->dpy, bst->window, bst->gc,
416 bst->x, bst->y, &c, 1);
423 bsod_pop (struct bsod_state *bst)
425 bsod_event_type type = bst->queue[bst->pos].type;
428 return bst->draw_cb (bst);
430 if (bst->pos < 0) /* already done */
435 case LEFT: case LEFT_FULL:
436 case CENTER: case CENTER_FULL:
437 case RIGHT: case RIGHT_FULL:
439 const char *s = (const char *) bst->queue[bst->pos].arg2;
444 long delay = bst->line_delay;
446 bst->current_left = bst->left_margin;
450 if (! bst->queue[bst->pos].arg3) /* "done once" */
452 position_for_text (bst, s);
453 bst->queue[bst->pos].arg4 = (void *) bst->queue[bst->pos].type;
454 bst->queue[bst->pos].type = LEFT;
456 if (type == CENTER_FULL ||
460 XSetForeground (bst->dpy, bst->gc, bst->bg);
461 XFillRectangle (bst->dpy, bst->window, bst->gc,
463 bst->y - bst->font->ascent,
465 bst->font->ascent + bst->font->descent);
466 XSetForeground (bst->dpy, bst->gc, bst->fg);
472 bst->queue[bst->pos].arg2 = (void *) s;
473 bst->queue[bst->pos].arg3 = (void *) 1; /* "done once" */
475 return (c == '\r' || c == '\n'
481 unsigned long swap = bst->fg;
484 XSetForeground (bst->dpy, bst->gc, bst->fg);
485 XSetBackground (bst->dpy, bst->gc, bst->bg);
491 bst->fg = (unsigned long) bst->queue[bst->pos].arg1;
492 bst->bg = (unsigned long) bst->queue[bst->pos].arg2;
493 XSetForeground (bst->dpy, bst->gc, bst->fg);
494 XSetBackground (bst->dpy, bst->gc, bst->bg);
500 bst->x = (long) bst->queue[bst->pos].arg1;
501 bst->y = (long) bst->queue[bst->pos].arg2;
507 int f = (long) bst->queue[bst->pos].arg1;
508 int x = (long) bst->queue[bst->pos].arg2;
509 int y = (long) bst->queue[bst->pos].arg3;
510 int w = (long) bst->queue[bst->pos].arg4;
511 int h = (long) bst->queue[bst->pos].arg5;
513 XFillRectangle (bst->dpy, bst->window, bst->gc, x, y, w, h);
515 XDrawRectangle (bst->dpy, bst->window, bst->gc, x, y, w, h);
522 int srcx = (long) bst->queue[bst->pos].arg1;
523 int srcy = (long) bst->queue[bst->pos].arg2;
524 int w = (long) bst->queue[bst->pos].arg3;
525 int h = (long) bst->queue[bst->pos].arg4;
526 int tox = (long) bst->queue[bst->pos].arg5;
527 int toy = (long) bst->queue[bst->pos].arg6;
529 (type == PIXMAP ? bst->pixmap : bst->window),
530 bst->window, bst->gc,
531 srcx, srcy, w, h, tox, toy);
537 if (bst->img_loader) abort();
538 bst->img_loader = load_image_async_simple (0, bst->xgwa.screen,
539 bst->window, bst->window,
546 long delay = (long) bst->queue[bst->pos].arg1;
552 bst->char_delay = (long) bst->queue[bst->pos].arg1;
558 bst->line_delay = (long) bst->queue[bst->pos].arg1;
564 bst->left_margin = (long) bst->queue[bst->pos].arg1;
565 bst->right_margin = (long) bst->queue[bst->pos].arg2;
572 long delay = (long) bst->queue[bst->pos].arg1;
573 long count = (long) bst->queue[bst->pos].arg2;
576 if (type == CURSOR_BLOCK)
578 unsigned long swap = bst->fg;
581 XSetForeground (bst->dpy, bst->gc, bst->fg);
582 XSetBackground (bst->dpy, bst->gc, bst->bg);
583 draw_char (bst, ' ');
587 draw_char (bst, (count & 1 ? ' ' : '_'));
588 draw_char (bst, ' ');
594 bst->queue[bst->pos].arg2 = (void *) count;
602 long off = (long) bst->queue[bst->pos].arg1;
604 if (bst->pos < 0 || bst->pos >= bst->queue_size)
611 for (i = 0; i < bst->queue_size; i++)
612 switch (bst->queue[i].type) {
613 case LEFT: case LEFT_FULL:
614 case CENTER: case CENTER_FULL:
615 case RIGHT: case RIGHT_FULL:
616 bst->queue[i].arg2 = bst->queue[i].arg1;
617 bst->queue[i].arg3 = 0;
618 bst->queue[i].type = (bsod_event_type) bst->queue[i].arg4;
637 static struct bsod_state *
638 make_bsod_state (Display *dpy, Window window,
639 const char *name, const char *class)
642 struct bsod_state *bst;
643 char buf1[1024], buf2[1024];
644 char buf3[1024], buf4[1024];
645 const char *font1, *font2;
647 bst = (struct bsod_state *) calloc (1, sizeof (*bst));
648 bst->queue_size = 10;
649 bst->queue = (struct bsod_event *) calloc (bst->queue_size,
650 sizeof (*bst->queue));
652 bst->window = window;
653 XGetWindowAttributes (dpy, window, &bst->xgwa);
655 /* If the window is small:
656 use ".font" if it is loadable, else use ".font2".
658 If the window is big:
659 use ".bigFont" if it is loadable, else use ".bigFont2".
665 bst->xgwa.height < 640
669 sprintf (buf1, "%.100s.font", name);
670 sprintf (buf2, "%.100s.font", class);
671 sprintf (buf3, "%.100s.font2", name);
672 sprintf (buf4, "%.100s.font2", class);
676 sprintf (buf1, "%.100s.bigFont", name);
677 sprintf (buf2, "%.100s.bigFont", class);
678 sprintf (buf3, "%.100s.bigFont2", name);
679 sprintf (buf4, "%.100s.bigFont2", class);
682 font1 = get_string_resource (dpy, buf1, buf2);
683 font2 = get_string_resource (dpy, buf3, buf4);
686 bst->font = XLoadQueryFont (dpy, font1);
687 if (! bst->font && font2)
688 bst->font = XLoadQueryFont (dpy, font2);
690 /* If neither of those worked, try some defaults. */
693 bst->font = XLoadQueryFont (dpy,"-*-courier-bold-r-*-*-*-120-*-*-m-*-*-*");
695 bst->font = XLoadQueryFont (dpy, "fixed");
699 gcv.font = bst->font->fid;
701 sprintf (buf1, "%.100s.foreground", name);
702 sprintf (buf2, "%.100s.Foreground", class);
703 bst->fg = gcv.foreground = get_pixel_resource (dpy, bst->xgwa.colormap,
705 sprintf (buf1, "%.100s.background", name);
706 sprintf (buf2, "%.100s.Background", class);
707 bst->bg = gcv.background = get_pixel_resource (dpy, bst->xgwa.colormap,
709 bst->gc = XCreateGC (dpy, window, GCFont|GCForeground|GCBackground, &gcv);
712 jwxyz_XSetAntiAliasing (dpy, bst->gc, False);
715 bst->left_margin = bst->right_margin = 10;
716 bst->x = bst->left_margin;
717 bst->y = bst->font->ascent + bst->left_margin;
719 XSetWindowBackground (dpy, window, gcv.background);
725 free_bsod_state (struct bsod_state *bst)
732 XFreePixmap(bst->dpy, bst->pixmap);
734 XFreeFont (bst->dpy, bst->font);
735 XFreeGC (bst->dpy, bst->gc);
737 for (i = 0; i < bst->queue_size; i++)
738 switch (bst->queue[i].type) {
739 case LEFT: case LEFT_FULL:
740 case RIGHT: case RIGHT_FULL:
741 case CENTER: case CENTER_FULL:
742 free ((char *) bst->queue[i].arg1);
754 double_pixmap (Display *dpy, GC gc, Visual *visual, int depth, Pixmap pixmap,
755 int pix_w, int pix_h)
758 Pixmap p2 = XCreatePixmap(dpy, pixmap, pix_w*2, pix_h*2, depth);
759 XImage *i1 = XGetImage(dpy, pixmap, 0, 0, pix_w, pix_h, ~0L, ZPixmap);
760 XImage *i2 = XCreateImage(dpy, visual, depth, ZPixmap, 0, 0,
761 pix_w*2, pix_h*2, 8, 0);
762 i2->data = (char *) calloc(i2->height, i2->bytes_per_line);
763 for (y = 0; y < pix_h; y++)
764 for (x = 0; x < pix_w; x++)
766 unsigned long p = XGetPixel(i1, x, y);
767 XPutPixel(i2, x*2, y*2, p);
768 XPutPixel(i2, x*2+1, y*2, p);
769 XPutPixel(i2, x*2, y*2+1, p);
770 XPutPixel(i2, x*2+1, y*2+1, p);
772 free(i1->data); i1->data = 0;
774 XPutImage(dpy, p2, gc, i2, 0, 0, 0, 0, i2->width, i2->height);
775 free(i2->data); i2->data = 0;
777 XFreePixmap(dpy, pixmap);
782 /*****************************************************************************
783 *****************************************************************************/
785 static struct bsod_state *
786 windows_31 (Display *dpy, Window window)
788 struct bsod_state *bst = make_bsod_state (dpy, window, "windows", "Windows");
790 BSOD_TEXT (bst, CENTER, "Windows\n");
792 BSOD_TEXT (bst, CENTER,
793 "A fatal exception 0E has occured at F0AD:42494C4C\n"
794 "the current application will be terminated.\n"
796 "* Press any key to terminate the current application.\n"
797 "* Press CTRL+ALT+DELETE again to restart your computer.\n"
798 " You will lose any unsaved information in all applications.\n"
801 BSOD_TEXT (bst, CENTER, "Press any key to continue");
803 bst->y = ((bst->xgwa.height -
804 ((bst->font->ascent + bst->font->descent) * 9))
807 XClearWindow (dpy, window);
812 static struct bsod_state *
813 windows_nt (Display *dpy, Window window)
815 struct bsod_state *bst = make_bsod_state (dpy, window, "windows", "Windows");
817 BSOD_TEXT (bst, LEFT,
818 "*** STOP: 0x0000001E (0x80000003,0x80106fc0,0x8025ea21,0xfd6829e8)\n"
819 "Unhandled Kernel exception c0000047 from fa8418b4 (8025ea21,fd6829e8)\n"
821 "Dll Base Date Stamp - Name Dll Base Date Stamp - Name\n"
822 "80100000 2be154c9 - ntoskrnl.exe 80400000 2bc153b0 - hal.dll\n"
823 "80258000 2bd49628 - ncrc710.sys 8025c000 2bd49688 - SCSIPORT.SYS \n"
824 "80267000 2bd49683 - scsidisk.sys 802a6000 2bd496b9 - Fastfat.sys\n"
825 "fa800000 2bd49666 - Floppy.SYS fa810000 2bd496db - Hpfs_Rec.SYS\n"
826 "fa820000 2bd49676 - Null.SYS fa830000 2bd4965a - Beep.SYS\n"
827 "fa840000 2bdaab00 - i8042prt.SYS fa850000 2bd5a020 - SERMOUSE.SYS\n"
828 "fa860000 2bd4966f - kbdclass.SYS fa870000 2bd49671 - MOUCLASS.SYS\n"
829 "fa880000 2bd9c0be - Videoprt.SYS fa890000 2bd49638 - NCC1701E.SYS\n"
830 "fa8a0000 2bd4a4ce - Vga.SYS fa8b0000 2bd496d0 - Msfs.SYS\n"
831 "fa8c0000 2bd496c3 - Npfs.SYS fa8e0000 2bd496c9 - Ntfs.SYS\n"
832 "fa940000 2bd496df - NDIS.SYS fa930000 2bd49707 - wdlan.sys\n"
833 "fa970000 2bd49712 - TDI.SYS fa950000 2bd5a7fb - nbf.sys\n"
834 "fa980000 2bd72406 - streams.sys fa9b0000 2bd4975f - ubnb.sys\n"
835 "fa9c0000 2bd5bfd7 - usbser.sys fa9d0000 2bd4971d - netbios.sys\n"
836 "fa9e0000 2bd49678 - Parallel.sys fa9f0000 2bd4969f - serial.SYS\n"
837 "faa00000 2bd49739 - mup.sys faa40000 2bd4971f - SMBTRSUP.SYS\n"
838 "faa10000 2bd6f2a2 - srv.sys faa50000 2bd4971a - afd.sys\n"
839 "faa60000 2bd6fd80 - rdr.sys faaa0000 2bd49735 - bowser.sys\n"
841 "Address dword dump Dll Base - Name\n"
842 "801afc20 80106fc0 80106fc0 00000000 00000000 80149905 : "
843 "fa840000 - i8042prt.SYS\n"
844 "801afc24 80149905 80149905 ff8e6b8c 80129c2c ff8e6b94 : "
845 "8025c000 - SCSIPORT.SYS\n"
846 "801afc2c 80129c2c 80129c2c ff8e6b94 00000000 ff8e6b94 : "
847 "80100000 - ntoskrnl.exe\n"
848 "801afc34 801240f2 80124f02 ff8e6df4 ff8e6f60 ff8e6c58 : "
849 "80100000 - ntoskrnl.exe\n"
850 "801afc54 80124f16 80124f16 ff8e6f60 ff8e6c3c 8015ac7e : "
851 "80100000 - ntoskrnl.exe\n"
852 "801afc64 8015ac7e 8015ac7e ff8e6df4 ff8e6f60 ff8e6c58 : "
853 "80100000 - ntoskrnl.exe\n"
854 "801afc70 80129bda 80129bda 00000000 80088000 80106fc0 : "
855 "80100000 - ntoskrnl.exe\n"
857 "Kernel Debugger Using: COM2 (Port 0x2f8, Baud Rate 19200)\n"
858 "Restart and set the recovery options in the system control panel\n"
859 "or the /CRASHDEBUG system start option. If this message reappears,\n"
860 "contact your system administrator or technical support group."
863 bst->line_delay = 750;
865 XClearWindow (dpy, window);
870 static struct bsod_state *
871 windows_2k (Display *dpy, Window window)
873 struct bsod_state *bst = make_bsod_state (dpy, window, "windows", "Windows");
875 BSOD_TEXT (bst, LEFT,
876 "*** STOP: 0x000000D1 (0xE1D38000,0x0000001C,0x00000000,0xF09D42DA)\n"
877 "DRIVER_IRQL_NOT_LESS_OR_EQUAL \n"
879 "*** Address F09D42DA base at F09D4000, DateStamp 39f459ff - CRASHDD.SYS\n"
881 "Beginning dump of physical memory\n");
882 BSOD_PAUSE (bst, 4000000);
883 BSOD_TEXT (bst, LEFT,
884 "Physical memory dump complete. Contact your system administrator or\n"
885 "technical support group.\n");
887 bst->left_margin = 40;
888 bst->y = (bst->font->ascent + bst->font->descent) * 10;
889 bst->line_delay = 750;
891 XClearWindow (dpy, window);
896 static struct bsod_state *
897 windows_me (Display *dpy, Window window)
899 struct bsod_state *bst = make_bsod_state (dpy, window, "windows", "Windows");
901 BSOD_TEXT (bst, LEFT,
902 "Windows protection error. You need to restart your computer.\n\n"
904 BSOD_CURSOR (bst, CURSOR_LINE, 120000, 999999);
906 bst->left_margin = 40;
907 bst->y = ((bst->xgwa.height -
908 ((bst->font->ascent + bst->font->descent) * 3))
911 XClearWindow (dpy, window);
916 static struct bsod_state *
917 windows_xp (Display *dpy, Window window)
919 struct bsod_state *bst = make_bsod_state (dpy, window, "windows", "Windows");
921 BSOD_TEXT (bst, LEFT, /* From Wm. Rhodes <xscreensaver@27.org> */
922 "A problem has been detected and windows has been shut down to prevent "
924 "to your computer.\n"
926 "If this is the first time you've seen this Stop error screen,\n"
927 "restart your computer. If this screen appears again, follow\n"
930 "Check to be sure you have adequate disk space. If a driver is\n"
931 "identified in the Stop message, disable the driver or check\n"
932 "with the manufacturer for driver updates. Try changing video\n"
935 "Check with your hardware vendor for any BIOS updates. Disable\n"
936 "BIOS memory options such as caching or shadowing. If you need\n"
937 "to use Safe Mode to remove or disable components, restart your\n"
938 "computer, press F8 to select Advanced Startup Options, and then\n"
939 "select Safe Mode.\n"
941 "Technical information:\n"
943 "*** STOP: 0x0000007E (0xC0000005,0xF88FF190,0x0xF8975BA0,0xF89758A0)\n"
946 "*** EPUSBDSK.sys - Address F88FF190 base at FF88FE000, datestamp "
949 "Beginning dump of physical memory\n");
950 BSOD_PAUSE (bst, 4000000);
951 BSOD_TEXT (bst, LEFT,
952 "Physical memory dump complete.\n"
953 "Contact your system administrator or technical support group for "
957 XClearWindow (dpy, window);
962 static struct bsod_state *
963 windows_lh (Display *dpy, Window window)
965 struct bsod_state *bst =
966 make_bsod_state (dpy, window, "windowslh", "WindowsLH");
968 unsigned long fg = bst->fg;
969 unsigned long bg = bst->bg;
970 unsigned long bg2 = get_pixel_resource (dpy, bst->xgwa.colormap,
971 "windowslh.background2",
972 "WindowsLH.Background");
974 /* The "RSOD" that appeared with "Windows Longhorn 5048.050401-0536_x86fre"
975 As reported by http://joi.ito.com/RedScreen.jpg
977 BSOD_COLOR (bst, bg, bg2);
978 BSOD_TEXT (bst, CENTER_FULL, "Windows Boot Error\n");
979 BSOD_COLOR (bst, fg, bg);
980 BSOD_TEXT (bst, CENTER,
982 "Windows Boot Manager has experienced a problem.\n"
985 " Status: 0xc000000f\n"
989 " Info: An error occurred transferring exectuion." /* (sic) */
993 "You can try to recover the system with the Microsoft Windows "
995 "Tools. (You might need to restart the system manually.)\n"
997 "If the problem continues, please contact your system administrator "
1001 BSOD_MOVETO (bst, bst->left_margin, bst->xgwa.height - bst->font->descent);
1002 BSOD_COLOR (bst, bg, bg2);
1003 BSOD_TEXT (bst, LEFT_FULL, " SPACE=Continue\n");
1005 bst->y = bst->font->ascent;
1007 XClearWindow (dpy, window);
1012 static struct bsod_state *
1013 windows_other (Display *dpy, Window window)
1015 /* Lump all of the 2K-ish crashes together and select them randomly...
1017 int which = (random() % 4);
1019 case 0: return windows_2k (dpy, window); break;
1020 case 1: return windows_me (dpy, window); break;
1021 case 2: return windows_xp (dpy, window); break;
1022 case 3: return windows_lh (dpy, window); break;
1023 default: abort(); break;
1028 /* As seen in Portal 2. By jwz.
1030 static struct bsod_state *
1031 glados (Display *dpy, Window window)
1033 struct bsod_state *bst = make_bsod_state (dpy, window, "glaDOS", "GlaDOS");
1034 const char * panicstr[] = {
1036 "MOLTEN CORE WARNING\n",
1038 "An operator error exception has occurred at FISSREAC0020093:09\n",
1039 "FISSREAC0020077:14 FISSREAC0020023:17 FISSREAC0020088:22\n",
1040 "neutron multiplication rate at spikevalue 99999999\n",
1042 "* Press any key to vent radiological emissions into atmosphere.\n",
1043 "* Consult reactor core manual for instructions on proper reactor core\n",
1044 "maintenance and repair.\n",
1046 "Press any key to continue\n",
1051 bst->y = ((bst->xgwa.height -
1052 ((bst->font->ascent + bst->font->descent) * countof(panicstr)))
1055 BSOD_MOVETO (bst, 0, bst->y);
1057 BSOD_TEXT (bst, CENTER, "OPERATOR ERROR\n");
1059 for (i = 0; i < countof(panicstr); i++)
1060 BSOD_TEXT (bst, CENTER, panicstr[i]);
1061 BSOD_PAUSE (bst, 1000000);
1063 BSOD_RECT (bst, True, 0, 0, bst->xgwa.width, bst->xgwa.height);
1065 BSOD_PAUSE (bst, 250000);
1068 XClearWindow (dpy, window);
1074 /* SCO OpenServer 5 panic, by Tom Kelly <tom@ancilla.toronto.on.ca>
1076 static struct bsod_state *
1077 sco (Display *dpy, Window window)
1079 struct bsod_state *bst = make_bsod_state (dpy, window, "sco", "SCO");
1081 BSOD_TEXT (bst, LEFT,
1082 "Unexpected trap in kernel mode:\n"
1084 "cr0 0x80010013 cr2 0x00000014 cr3 0x00000000 tlb 0x00000000\n"
1085 "ss 0x00071054 uesp 0x00012055 efl 0x00080888 ipl 0x00000005\n"
1086 "cs 0x00092585 eip 0x00544a4b err 0x004d4a47 trap 0x0000000E\n"
1087 "eax 0x0045474b ecx 0x0042544b edx 0x57687920 ebx 0x61726520\n"
1088 "esp 0x796f7520 ebp 0x72656164 esi 0x696e6720 edi 0x74686973\n"
1089 "ds 0x3f000000 es 0x43494c48 fs 0x43525343 gs 0x4f4d4b53\n"
1091 "PANIC: k_trap - kernel mode trap type 0x0000000E\n"
1092 "Trying to dump 5023 pages to dumpdev hd (1/41), 63 pages per '.'\n"
1094 BSOD_CHAR_DELAY (bst, 100000);
1095 BSOD_TEXT (bst, LEFT,
1096 "................................................................."
1099 BSOD_CHAR_DELAY (bst, 0);
1100 BSOD_TEXT (bst, LEFT,
1101 "5023 pages dumped\n"
1105 BSOD_PAUSE (bst, 2000000);
1106 BSOD_TEXT (bst, LEFT,
1107 "** Safe to Power Off **\n"
1109 "** Press Any Key to Reboot **\n"
1112 bst->y = ((bst->xgwa.height -
1113 ((bst->font->ascent + bst->font->descent) * 18)));
1115 XClearWindow (dpy, window);
1120 /* Linux (sparc) panic, by Tom Kelly <tom@ancilla.toronto.on.ca>
1122 static struct bsod_state *
1123 sparc_linux (Display *dpy, Window window)
1125 struct bsod_state *bst = make_bsod_state (dpy, window, "sco", "SCO");
1126 bst->scroll_p = True;
1127 bst->y = bst->xgwa.height - bst->font->ascent - bst->font->descent;
1129 BSOD_TEXT (bst, LEFT,
1130 "\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n"
1131 "Unable to handle kernel paging request at virtual address f0d4a000\n"
1132 "tsk->mm->context = 00000014\n"
1133 "tsk->mm->pgd = f26b0000\n"
1135 " \"@'/ ,. \\`@\"\n"
1138 "gawk(22827): Oops\n"
1139 "PSR: 044010c1 PC: f001c2cc NPC: f001c2d0 Y: 00000000\n"
1140 "g0: 00001000 g1: fffffff7 g2: 04401086 g3: 0001eaa0\n"
1141 "g4: 000207dc g5: f0130400 g6: f0d4a018 g7: 00000001\n"
1142 "o0: 00000000 o1: f0d4a298 o2: 00000040 o3: f1380718\n"
1143 "o4: f1380718 o5: 00000200 sp: f1b13f08 ret_pc: f001c2a0\n"
1144 "l0: efffd880 l1: 00000001 l2: f0d4a230 l3: 00000014\n"
1145 "l4: 0000ffff l5: f0131550 l6: f012c000 l7: f0130400\n"
1146 "i0: f1b13fb0 i1: 00000001 i2: 00000002 i3: 0007c000\n"
1147 "i4: f01457c0 i5: 00000004 i6: f1b13f70 i7: f0015360\n"
1148 "Instruction DUMP:\n"
1151 XClearWindow (dpy, window);
1156 /* BSD Panic by greywolf@starwolf.com - modeled after the Linux panic above.
1157 By Grey Wolf <greywolf@siteROCK.com>
1159 static struct bsod_state *
1160 bsd (Display *dpy, Window window)
1162 struct bsod_state *bst = make_bsod_state (dpy, window, "bsd", "BSD");
1164 const char * const panicstr[] = {
1165 "panic: ifree: freeing free inode\n",
1166 "panic: blkfree: freeing free block\n",
1167 "panic: improbability coefficient below zero\n",
1168 "panic: cgsixmmap\n",
1169 "panic: crazy interrupts\n",
1171 "panic: attempted windows install\n",
1173 "panic: free inode isn't\n",
1174 "panic: cpu_fork: curproc\n",
1175 "panic: malloc: out of space in kmem_map\n",
1176 "panic: vogon starship detected\n",
1177 "panic: teleport chamber: out of order\n",
1178 "panic: Brain fried - core dumped\n"
1181 char syncing[80], bbuf[5];
1183 for (i = 0; i < sizeof(syncing); i++)
1186 i = (random() % (sizeof(panicstr) / sizeof(*panicstr)));
1187 BSOD_TEXT (bst, LEFT, panicstr[i]);
1188 BSOD_TEXT (bst, LEFT, "Syncing disks: ");
1190 b = (random() % 40);
1191 for (n = 0; (n < 20) && (b > 0); n++)
1195 i = (random() & 0x7);
1196 b -= (random() & 0xff) % 20;
1200 sprintf (bbuf, "%d ", b);
1201 BSOD_TEXT (bst, LEFT, bbuf);
1202 BSOD_PAUSE (bst, 1000000);
1205 BSOD_TEXT (bst, LEFT, "\n");
1206 BSOD_TEXT (bst, LEFT, (b ? "damn!" : "sunk!"));
1207 BSOD_TEXT (bst, LEFT, "\nRebooting\n");
1209 bst->y = ((bst->xgwa.height -
1210 ((bst->font->ascent + bst->font->descent) * 4)));
1212 XClearWindow (dpy, window);
1217 static struct bsod_state *
1218 amiga (Display *dpy, Window window)
1220 struct bsod_state *bst = make_bsod_state (dpy, window, "amiga", "Amiga");
1223 int pix_w = 0, pix_h = 0;
1227 unsigned long bg2 = get_pixel_resource (dpy, bst->xgwa.colormap,
1228 "amiga.background2",
1229 "Amiga.Background");
1232 pixmap = xpm_data_to_pixmap (dpy, window, (char **) amiga_hand,
1234 # endif /* DO_XPM */
1236 if (pixmap && bst->xgwa.height > 600) /* scale up the bitmap */
1238 pixmap = double_pixmap (dpy, bst->gc, bst->xgwa.visual, bst->xgwa.depth,
1239 pixmap, pix_w, pix_h);
1244 XSetLineAttributes (dpy, bst->gc, lw, LineSolid, CapButt, JoinMiter);
1246 height = (bst->font->ascent + bst->font->descent) * 6;
1248 BSOD_PAUSE (bst, 2000000);
1249 BSOD_COPY (bst, 0, 0, bst->xgwa.width, bst->xgwa.height - height, 0, height);
1252 BSOD_RECT (bst, True, 0, 0, bst->xgwa.width, height);
1254 BSOD_TEXT (bst, CENTER,
1256 "Software failure. Press left mouse button to continue.\n"
1257 "Guru Meditation #00000003.00C01570"
1259 BSOD_RECT (bst, False, lw/2, lw/2, bst->xgwa.width - lw, height);
1260 BSOD_PAUSE (bst, 1000000);
1262 BSOD_LOOP (bst, -3);
1264 XSetWindowBackground (dpy, window, bg2);
1265 XClearWindow (dpy, window);
1266 XSetWindowBackground (dpy, window, bst->bg);
1270 int x = (bst->xgwa.width - pix_w) / 2;
1271 int y = ((bst->xgwa.height - pix_h) / 2);
1272 XCopyArea (dpy, pixmap, bst->window, bst->gc, 0, 0, pix_w, pix_h, x, y);
1282 /* Atari ST, by Marcus Herbert <rhoenie@nobiscum.de>
1283 Marcus had this to say:
1285 Though I still have my Atari somewhere, I hardly remember
1286 the meaning of the bombs. I think 9 bombs was "bus error" or
1287 something like that. And you often had a few bombs displayed
1288 quickly and then the next few ones coming up step by step.
1289 Perhaps somebody else can tell you more about it.. its just
1292 static struct bsod_state *
1293 atari (Display *dpy, Window window)
1295 struct bsod_state *bst = make_bsod_state (dpy, window, "atari", "Atari");
1298 int pix_w = atari_width;
1299 int pix_h = atari_height;
1303 pixmap = XCreatePixmapFromBitmapData (dpy, window, (char *) atari_bits,
1305 bst->fg, bst->bg, bst->xgwa.depth);
1306 pixmap = double_pixmap (dpy, bst->gc, bst->xgwa.visual, bst->xgwa.depth,
1307 pixmap, pix_w, pix_h);
1313 y = bst->xgwa.height/2;
1316 for (i = 1; i< 7; i++)
1317 BSOD_COPY (bst, x, y, pix_w, pix_h, (x + (i*offset)), y);
1321 BSOD_PAUSE (bst, 1000000);
1322 BSOD_COPY (bst, x, y, pix_w, pix_h, (x + (i*offset)), y);
1325 XClearWindow (dpy, window);
1326 XCopyArea (dpy, pixmap, window, bst->gc, 0, 0, pix_w, pix_h, x, y);
1327 XFreePixmap (dpy, pixmap);
1333 static struct bsod_state *
1334 mac (Display *dpy, Window window)
1336 struct bsod_state *bst = make_bsod_state (dpy, window, "mac", "Mac");
1339 int pix_w = mac_width;
1340 int pix_h = mac_height;
1341 int offset = mac_height * 4;
1344 const char *string = ("0 0 0 0 0 0 0 F\n"
1347 pixmap = XCreatePixmapFromBitmapData(dpy, window, (char *) mac_bits,
1348 mac_width, mac_height,
1349 bst->fg, bst->bg, bst->xgwa.depth);
1351 for (i = 0; i < 2; i++)
1353 pixmap = double_pixmap (dpy, bst->gc, bst->xgwa.visual, bst->xgwa.depth,
1354 pixmap, pix_w, pix_h);
1355 pix_w *= 2; pix_h *= 2;
1358 bst->x = (bst->xgwa.width - pix_w) / 2;
1359 bst->y = (((bst->xgwa.height + offset) / 2) -
1361 (bst->font->ascent + bst->font->descent) * 2);
1362 if (bst->y < 0) bst->y = 0;
1364 XClearWindow (dpy, window);
1365 XCopyArea (dpy, pixmap, window, bst->gc, 0, 0, pix_w, pix_h, bst->x, bst->y);
1366 XFreePixmap (dpy, pixmap);
1368 bst->y += offset + bst->font->ascent + bst->font->descent;
1369 BSOD_TEXT (bst, CENTER, string);
1375 static struct bsod_state *
1376 macsbug (Display *dpy, Window window)
1378 struct bsod_state *bst = make_bsod_state (dpy, window, "macsbug", "MacsBug");
1381 const char *left = (" SP \n"
1428 const char *bottom = (" _A09D\n"
1429 " +00884 40843714 #$0700,SR "
1431 " +00886 40843765 *+$0400 "
1433 " +00888 40843718 $0004(A7),([0,A7[)"
1434 " ; 04E8D0AE | 66B8");
1436 const char * body = ("PowerPC unmapped memory exception at 003AFDAC "
1437 "BowelsOfTheMemoryMgr+04F9C\n"
1438 " Calling chain using A6/R1 links\n"
1439 " Back chain ISA Caller\n"
1440 " 00000000 PPC 28C5353C __start+00054\n"
1441 " 24DB03C0 PPC 28B9258C main+0039C\n"
1442 " 24DB0350 PPC 28B9210C MainEvent+00494\n"
1443 " 24DB02B0 PPC 28B91B40 HandleEvent+00278\n"
1444 " 24DB0250 PPC 28B83DAC DoAppleEvent+00020\n"
1445 " 24DB0210 PPC FFD3E5D0 "
1446 "AEProcessAppleEvent+00020\n"
1447 " 24DB0132 68K 00589468\n"
1448 " 24DAFF8C 68K 00589582\n"
1449 " 24DAFF26 68K 00588F70\n"
1450 " 24DAFEB3 PPC 00307098 "
1451 "EmToNatEndMoveParams+00014\n"
1452 " 24DAFE40 PPC 28B9D0B0 DoScript+001C4\n"
1453 " 24DAFDD0 PPC 28B9C35C RunScript+00390\n"
1454 " 24DAFC60 PPC 28BA36D4 run_perl+000E0\n"
1455 " 24DAFC10 PPC 28BC2904 perl_run+002CC\n"
1456 " 24DAFA80 PPC 28C18490 Perl_runops+00068\n"
1457 " 24DAFA30 PPC 28BE6CC0 Perl_pp_backtick+000FC\n"
1458 " 24DAF9D0 PPC 28BA48B8 Perl_my_popen+00158\n"
1459 " 24DAF980 PPC 28C5395C sfclose+00378\n"
1460 " 24DAF930 PPC 28BA568C free+0000C\n"
1461 " 24DAF8F0 PPC 28BA6254 pool_free+001D0\n"
1462 " 24DAF8A0 PPC FFD48F14 DisposePtr+00028\n"
1463 " 24DAF7C9 PPC 00307098 "
1464 "EmToNatEndMoveParams+00014\n"
1465 " 24DAF780 PPC 003AA180 __DisposePtr+00010");
1470 int char_width, line_height;
1471 int col_right, row_top, row_bottom, page_right, page_bottom, body_top;
1474 unsigned long fg = bst->fg;
1475 unsigned long bg = bst->bg;
1476 unsigned long bc = get_pixel_resource (dpy, bst->xgwa.colormap,
1477 "macsbug.borderColor",
1478 "MacsBug.BorderColor");
1480 for (s = body; *s; s++) if (*s == '\n') body_lines++;
1482 char_width = (bst->font->per_char
1483 ? bst->font->per_char['n'-bst->font->min_char_or_byte2].width
1484 : bst->font->min_bounds.width);
1485 line_height = bst->font->ascent + bst->font->descent;
1487 col_right = char_width * 12; /* number of columns in `left' */
1488 page_bottom = line_height * 47; /* number of lines in `left' */
1490 if (page_bottom > bst->xgwa.height)
1491 page_bottom = bst->xgwa.height;
1493 row_bottom = page_bottom - line_height;
1494 row_top = row_bottom - (line_height * 4);
1495 page_right = col_right + (char_width * 88);
1496 body_top = row_top - (line_height * body_lines);
1505 xoff = (bst->xgwa.width - page_right) / 2;
1506 yoff = (bst->xgwa.height - page_bottom) / 2;
1508 if (xoff < 0) xoff = 0;
1509 if (yoff < 0) yoff = 0;
1511 BSOD_MARGINS (bst, xoff, yoff);
1513 BSOD_COLOR (bst, bc, bg);
1514 BSOD_RECT (bst, True, 0, 0, bst->xgwa.width, bst->xgwa.height);
1515 BSOD_COLOR (bst, bg, bg);
1516 BSOD_RECT (bst, True, xoff-2, yoff, page_right+4, page_bottom);
1517 BSOD_COLOR (bst, fg, bg);
1519 BSOD_MOVETO (bst, xoff, yoff + line_height);
1520 BSOD_TEXT (bst, LEFT, left);
1521 BSOD_MOVETO (bst, xoff+col_right, yoff + row_top + line_height);
1522 BSOD_TEXT (bst, LEFT, bottom);
1524 BSOD_RECT (bst, True, xoff + col_right, yoff, 2, page_bottom);
1525 BSOD_RECT (bst, True, xoff + col_right, yoff + row_top,
1526 page_right - col_right, 1);
1527 BSOD_RECT (bst, True, xoff + col_right, yoff + row_bottom,
1528 page_right - col_right, 1);
1529 BSOD_RECT (bst, False, xoff-2, yoff, page_right+4, page_bottom);
1531 BSOD_LINE_DELAY (bst, 500);
1533 xoff + col_right + char_width,
1534 yoff + body_top + line_height);
1535 BSOD_MARGINS (bst, xoff + col_right + char_width, yoff);
1536 BSOD_TEXT (bst, LEFT, body);
1538 BSOD_RECT (bst, False, xoff-2, yoff, page_right+4, page_bottom); /* again */
1540 BSOD_RECT (bst, False,
1541 xoff + col_right + (char_width/2)+2,
1542 yoff + row_bottom + 2,
1544 page_bottom - row_bottom - 4);
1546 BSOD_PAUSE (bst, 666666);
1548 BSOD_LOOP (bst, -3);
1550 XClearWindow (dpy, window);
1555 static struct bsod_state *
1556 mac1 (Display *dpy, Window window)
1558 struct bsod_state *bst = make_bsod_state (dpy, window, "mac1", "Mac1");
1561 int pix_w = macbomb_width;
1562 int pix_h = macbomb_height;
1565 pixmap = XCreatePixmapFromBitmapData (dpy, window, (char *) macbomb_bits,
1566 macbomb_width, macbomb_height,
1567 bst->fg, bst->bg, bst->xgwa.depth);
1569 x = (bst->xgwa.width - pix_w) / 2;
1570 y = (bst->xgwa.height - pix_h) / 2;
1573 XClearWindow (dpy, window);
1574 XCopyArea (dpy, pixmap, window, bst->gc, 0, 0, pix_w, pix_h, x, y);
1580 /* This is what kernel panics looked like on MacOS X 10.0 through 10.1.5.
1581 In later releases, it's a graphic of a power button with text in
1582 English, French, German, and Japanese overlayed transparently.
1584 static struct bsod_state *
1585 macx_10_0 (Display *dpy, Window window)
1587 struct bsod_state *bst = make_bsod_state (dpy, window, "macx", "MacX");
1589 XClearWindow (dpy, window);
1590 XSetForeground (dpy, bst->gc,
1591 get_pixel_resource (dpy, bst->xgwa.colormap,
1592 "macx.textForeground",
1593 "MacX.TextForeground"));
1594 XSetBackground (dpy, bst->gc,
1595 get_pixel_resource (dpy, bst->xgwa.colormap,
1596 "macx.textBackground",
1597 "MacX.TextBackground"));
1603 int x, y, pix_w, pix_h;
1604 pixmap = xpm_data_to_pixmap (dpy, window, (char **) happy_mac,
1605 &pix_w, &pix_h, &mask);
1610 pixmap = double_pixmap (dpy, bst->gc, bst->xgwa.visual,
1611 bst->xgwa.depth, pixmap, pix_w, pix_h);
1612 mask = double_pixmap (dpy, bst->gc, bst->xgwa.visual,
1613 1, mask, pix_w, pix_h);
1619 x = (bst->xgwa.width - pix_w) / 2;
1620 y = (bst->xgwa.height - pix_h) / 2;
1622 XSetClipMask (dpy, bst->gc, mask);
1623 XSetClipOrigin (dpy, bst->gc, x, y);
1624 XCopyArea (dpy, pixmap, window, bst->gc, 0, 0, pix_w, pix_h, x, y);
1625 XSetClipMask (dpy, bst->gc, None);
1626 XFreePixmap (dpy, pixmap);
1630 bst->left_margin = 0;
1631 bst->right_margin = 0;
1632 bst->y = bst->font->ascent;
1633 bst->macx_eol_kludge = True;
1636 BSOD_PAUSE (bst, 3000000);
1637 BSOD_TEXT (bst, LEFT,
1638 "panic(cpu 0): Unable to find driver for this platform: "
1639 "\"PowerMac 3,5\".\n"
1641 "backtrace: 0x0008c2f4 0x0002a7a0 0x001f0204 0x001d4e4c 0x001d4c5c "
1642 "0x001a56cc 0x01d5dbc 0x001c621c 0x00037430 0x00037364\n"
1646 "No debugger configured - dumping debug information\n"
1648 "version string : Darwin Kernel Version 1.3:\n"
1649 "Thu Mar 1 06:56:40 PST 2001; root:xnu/xnu-123.5.obj~1/RELEASE_PPC\n"
1654 "DBAT0: 00000000 00000000\n"
1655 "DBAT1: 00000000 00000000\n"
1656 "DBAT2: 80001FFE 8000003A\n"
1657 "DBAT3: 90001FFE 9000003A\n"
1659 "backtrace: 0x0008c2f4 0x0002a7a0 0x001f0204 0x001d4e4c 0x001d4c5c "
1660 "0x001a56cc 0x01d5dbc 0x001c621c 0x00037430 0x00037364\n"
1662 "panic: We are hanging here...\n");
1669 static struct bsod_state *
1670 macx_10_2 (Display *dpy, Window window, Bool v10_3_p)
1672 struct bsod_state *bst = make_bsod_state (dpy, window, "macx", "MacX");
1675 int pix_w = 0, pix_h = 0;
1678 pixmap = xpm_data_to_pixmap (dpy, window,
1679 (char **) (v10_3_p ? osx_10_3 : osx_10_2),
1681 if (! pixmap) abort();
1684 if (bst->xgwa.height > 600) /* scale up the bitmap */
1686 pixmap = double_pixmap (dpy, bst->gc, bst->xgwa.visual, bst->xgwa.depth,
1687 pixmap, pix_w, pix_h);
1688 if (! pixmap) abort();
1695 BSOD_PAUSE (bst, 2000000);
1697 bst->pixmap = pixmap;
1699 x = (bst->xgwa.width - pix_w) / 2;
1700 y = ((bst->xgwa.height - pix_h) / 2);
1701 BSOD_PIXMAP (bst, 0, 0, pix_w, pix_h, x, y);
1705 # endif /* DO_XPM */
1708 static struct bsod_state *
1709 macx (Display *dpy, Window window)
1712 switch (random() % 3) {
1713 case 0: return macx_10_0 (dpy, window); break;
1714 case 1: return macx_10_2 (dpy, window, False); break;
1715 case 2: return macx_10_2 (dpy, window, True); break;
1718 # else /* !DO_XPM */
1719 return macx_10_0 (dpy, window);
1720 # endif /* !DO_XPM */
1724 #ifndef HAVE_COCOA /* #### I have no idea how to implement this without
1725 real plane-masks. I don't think it would look
1726 right if done with alpha-transparency... */
1729 * by Martin Pool <mbp@samba.org>, Feb 2000.
1731 * This is meant to look like the preferred failure mode of NCD
1732 * Xterms. The parameters for choosing what to copy where might not
1733 * be quite right, but it looks about ugly enough.
1735 static struct bsod_state *
1736 blitdamage (Display *dpy, Window window)
1738 struct bsod_state *bst =
1739 make_bsod_state (dpy, window, "blitdamage", "BlitDamage");
1742 int delta_x = 0, delta_y = 0;
1744 int chunk_h, chunk_w;
1750 w = bst->xgwa.width;
1751 h = bst->xgwa.height;
1753 gc_mask = GCForeground;
1755 XSetPlaneMask (dpy, bst->gc, random());
1758 chunk_w = w / (random() % 1 + 1);
1759 chunk_h = h / (random() % 1 + 1);
1760 if (random() & 0x1000)
1761 delta_y = random() % 600;
1762 if (!delta_y || (random() & 0x2000))
1763 delta_x = random() % 600;
1770 for (i = 0; i < steps; i++) {
1771 if (x + chunk_w > w)
1776 if (y + chunk_h > h)
1781 BSOD_COPY (bst, src_x, src_y, chunk_w, chunk_h, x, y);
1782 BSOD_PAUSE (bst, 1000);
1787 #endif /* !HAVE_COCOA */
1791 * OS/2 panics, by Knut St. Osmundsen <bird-xscreensaver@anduin.net>
1793 * All but one messages are real ones, some are from my test machines
1794 * and system dumps, others are reconstructed from google results.
1795 * Please, don't be to hard if the formatting of the earlier systems
1796 * aren't 100% correct.
1798 static struct bsod_state *
1799 os2 (Display *dpy, Window window)
1801 struct bsod_state *bst = make_bsod_state (dpy, window, "os2", "OS2");
1804 static const char * const os2_panics[] =
1805 { /* OS/2 2.0 trap - details are bogus (CR0++). */
1806 "TRAP 0002 ERRCD=0000 ERACC=**** ERLIM=********\n"
1807 "EAX=7d240a58 EBX=ff202fdc ECX=00064423 EDX=00003624\n"
1808 "ESI=fff3272c EDI=7d240004 EBP=00004a44 FLG=00003202\n"
1809 "CS:EIP=0160:fff702a6 CSACC=c09d CSLIM=ffffffff\n"
1810 "SS:ESP=0030:00004a38 SSACC=1097 SSLIM=00003fff\n"
1811 "DS=0158 DSACC=c0f3 DSLIM=ffffffff CR0=fffffffb\n"
1812 "ES=0158 ESACC=c0f3 ESLIM=ffffffff CR2=1a060014\n"
1813 "FS=0000 FSACC=**** FSLIM=********\n"
1814 "GS=0000 GSACC=**** GSLIM=********\n"
1816 "The system detected an internal processing error\n"
1817 "at location ##0160:fff6453f - 000d:a53f\n"
1821 "Internal revision 6.307, 92/03/01\n"
1824 /* warp 3 (early) */
1825 "TRAP 000e ERRCD=0000 ERACC=**** ERLIM=********\n"
1826 "EAX=ff050c20 EBX=000000bb ECX=ffff00c1 EDx=fff379b8\n"
1827 "ESI=ffe55a3c EDI=00000000 EBP=00004eb8 FLG=00013282\n"
1828 "CS:EIP=0160:fff8dbb8 CSACC=c09b CSLIM=ffffffff\n"
1829 "SS:EIP=0030:00004eb4 SSACC=1097 SSLIM=00003fff\n"
1830 "DS=0158 DSACC=c0f3 DSLIM=ffffffff CR0=8001001b\n"
1831 "ES=0158 DSACC=c0f3 DSLIM=ffffffff CR2=000000c7\n"
1832 "FS=0000 FSACC=**** FSLIM=********\n"
1833 "GS=0000 GSACC=**** GSLIM=********\n"
1835 "The system detected an internal processing error\n"
1836 "at location ##0160:fff66bf0 - 000d:9bf0.\n"
1840 "Internal revision 8.125, 94/02/16\n"
1842 "The system is stopped. Record the location number of the error\n"
1843 "and contact your service representative.\n",
1846 "TRAP 000e ERRCD=0002 ERACC=**** ERLIM=********\n"
1847 "EAX=00000000 EBX=fdef1e0c ECX=00003824 EDX=0000edf9\n"
1848 "ESI=fdf30e80 EDI=fc8b0000 EBP=00005658 FLG=00012246\n"
1849 "CS:EIP=0160:fff8ada3 CSACC=c09b CSLIM=ffffffff\n"
1850 "SS:ESP=0030:000055d4 SSACC=1097 SSLIM=0000480f\n"
1851 "DS=0158 DSACC=c093 DSLIM=ffffffff CR0=8001001b\n"
1852 "ES=0158 ESACC=c093 ESLIM=ffffffff CR2=fc8b0000\n"
1853 "FS=03b8 FSACC=0093 FSLIM=00000023\n"
1854 "GS=0000 GSACC=**** GSLIM=********\n"
1856 "The system detected an internal processing error\n"
1857 "at location ##0160:fff5c364 - 000d:a364.\n"
1861 "Internal revision 8200,94/11/07\n"
1863 "The system is stopped. Record all of the above information and\n"
1864 "contact your service representative.\n",
1867 "TRAP 000d ERRCD=2200 ERACC=1092 ERLIM=00010fff\n"
1868 "EAX=0000802e EBX=fff001c8 ECX=9bd80000 EDX=00000000\n"
1869 "ESI=fff09bd8 EDI=fdeb001b EBP=00000000 FLG=00012012\n"
1870 "CS:EIP=0168:fff480a2 CSACC=c09b CSLIM=ffffffff\n"
1871 "SS:ESP=00e8:00001f32 SSACC=0093 SSLIM=00001fff\n"
1872 "DS=0940 DSACC=0093 DSLIM=00000397 CR0=8001001b\n"
1873 "ES=00e8 ESACC=0093 ESLIM=00001fff CR2=15760008\n"
1874 "FS=0000 FSACC=**** FSLIM=****\n"
1875 "GS=0000 GSACC=**** GSLIM=****\n"
1877 "The system detected an internal processing error\n"
1878 "at location ##0168:fff4b06e - 000e:c06e\n"
1882 "Internal revision 8.259_uni,98/01/07\n"
1884 "The system is stopped. Record all of the above information and\n"
1885 "contact your service representative.\n",
1887 /* Warp 4.52+ - the official r0trap.exe from the debugging classes */
1888 "Exception in module: OS2KRNL\n"
1889 "TRAP 000e ERRCD=0002 ERACC=**** ERLIM=********\n"
1890 "EAX=00000001 EBX=80010002 ECX=ffed4638 EDX=0003f17b\n"
1891 "ESI=00000001 EDI=00000002 EBP=00005408 FLG=00012202\n"
1892 "CS:EIP=0168:fff3cd2e CSACC=c09b CSLIM=ffffffff\n"
1893 "SS:ESP=0030:000053ec SSACC=1097 SSLIM=000044ff\n"
1894 "DS=0160 DSACC=c093 DSLIM=ffffffff CR0=8001001b\n"
1895 "ES=0160 ESACC=c093 ESLIM=ffffffff CR2=00000001\n"
1896 "FS=0000 FSACC=**** FSLIM=********\n"
1897 "GS=0000 GSACC=**** GSLIM=********\n"
1899 "The system detected an internal processing error at\n"
1900 "location ##0168:fff1e3f3 - 000e:c3f3.\n"
1904 "Internal revision 14.097_UNI\n"
1906 "The system is stopped. Record all of the above information and\n"
1907 "contact your service representative.\n",
1909 /* Warp 4.52+, typical JFS problem. */
1910 "Exeption in module: JFS\n"
1911 "TRAP 0003 ERRCD=0000 ERACC=**** ERLIM=********\n"
1912 "EAX=00000000 EBX=ffffff05 ECX=00000001 EDX=f5cd8010\n"
1913 "ESI=000000e6 EDI=000000e7 EBP=f9c7378e FLG=00002296\n"
1914 "CS:EIP=0168:f8df3250 CSACC=c09b CSLIM=ffffffff\n"
1915 "SS:ESP=1550:fdc73778 SSACC=c093 SSLIM=ffffffff\n"
1916 "DS=0160 DSACC=c093 DSLIM=ffffffff CR0=80010016\n"
1917 "ES=0160 ESACC=c093 DSLIM=ffffffff CR2=05318000\n"
1918 "FS=03c0 FSACC=0093 DSLIM=00000023\n"
1919 "GS=0160 GSACC=c093 DSLIM=ffffffff\n"
1921 "The system detected an internal processing error\n"
1922 "at location ##0168:fff1e2ab - 000e:c2ab.\n"
1927 "Internal revision 14.100c_UNI\n"
1929 "The system is stopped. Record all of the above information and\n"
1930 "contact your service representative.\n"
1933 BSOD_TEXT (bst, LEFT, os2_panics[random() % countof(os2_panics)]);
1934 BSOD_CURSOR (bst, CURSOR_LINE, 240000, 999999);
1936 XClearWindow (dpy, window);
1941 /* SPARC Solaris panic. Should look pretty authentic on Solaris boxes.
1942 * Anton Solovyev <solovam@earthlink.net>
1944 static struct bsod_state *
1945 sparc_solaris (Display *dpy, Window window)
1947 struct bsod_state *bst = make_bsod_state (dpy, window, "solaris", "Solaris");
1950 bst->scroll_p = True;
1952 bst->left_margin = bst->right_margin = bst->xgwa.width * 0.07;
1953 bst->top_margin = bst->bottom_margin = bst->xgwa.height * 0.07;
1954 bst->y = bst->top_margin + bst->font->ascent;
1957 BSOD_PAUSE (bst, 3000000);
1960 BSOD_RECT (bst, True,
1961 bst->left_margin, bst->top_margin,
1962 bst->xgwa.width - bst->left_margin - bst->right_margin,
1963 bst->xgwa.height - bst->top_margin - bst->bottom_margin);
1966 BSOD_TEXT (bst, LEFT,
1967 "BAD TRAP: cpu=0 type=0x31 rp=0x2a10043b5e0 addr=0xf3880 mmu_fsr=0x0\n"
1968 "BAD TRAP occurred in module \"unix\" due to an illegal access to a"
1970 "adb: trap type = 0x31\n"
1972 "pid=307, pc=0x100306e4, sp=0x2a10043ae81, tstate=0x4480001602,"
1974 "g1-g7: 1045b000, 32f, 10079440, 180, 300000ebde8, 0, 30000953a20\n"
1975 "Begin traceback... sp = 2a10043ae81\n"
1976 "Called from 100bd060, fp=2a10043af31, args=f3700 300008cc988 f3880 0"
1978 "Called from 101fe1bc, fp=2a10043b011, args=3000045a240 104465a0"
1979 " 300008e47d0 300008e48fa 300008ae350 300008ae410\n"
1980 "Called from 1007c520, fp=2a10043b0c1, args=300008e4878 300003596e8 0"
1981 " 3000045a320 0 3000045a220\n"
1982 "Called from 1007c498, fp=2a10043b171, args=1045a000 300007847f0 20"
1983 " 3000045a240 1 0\n"
1984 "Called from 1007972c, fp=2a10043b221, args=1 300009517c0 30000951e58 1"
1986 "Called from 10031e10, fp=2a10043b2d1, args=3000095b0c8 0 300009396a8"
1987 " 30000953a20 0 1\n"
1988 "Called from 10000bdd8, fp=ffffffff7ffff1c1, args=0 57 100131480"
1989 " 100131480 10012a6e0 0\n"
1990 "End traceback...\n"
1991 "panic[cpu0]/thread=30000953a20: trap\n"
1992 "syncing file systems...");
1994 BSOD_PAUSE (bst, 3000000);
1996 BSOD_TEXT (bst, LEFT, " 1 done\n");
1997 BSOD_TEXT (bst, LEFT, "dumping to /dev/dsk/c0t0d0s3, offset 26935296\n");
1998 BSOD_PAUSE (bst, 2000000);
2001 for (i = 1; i <= 100; ++i)
2004 sprintf (buf, "\b\b\b\b\b\b\b\b\b\b\b%3d%% done", i);
2005 BSOD_TEXT (bst, LEFT, buf);
2006 BSOD_PAUSE (bst, 100000);
2009 BSOD_TEXT (bst, LEFT,
2010 ": 2803 pages dumped, compression ratio 2.88, dump succeeded\n");
2011 BSOD_PAUSE (bst, 2000000);
2013 BSOD_TEXT (bst, LEFT,
2021 /* Linux panic and fsck, by jwz
2023 static struct bsod_state *
2024 linux_fsck (Display *dpy, Window window)
2026 struct bsod_state *bst = make_bsod_state (dpy, window, "linux", "Linux");
2029 const char *sysname;
2032 const char *linux_panic[] = {
2033 " kernel: Unable to handle kernel paging request at virtual "
2034 "address 0000f0ad\n",
2035 " kernel: printing eip:\n",
2036 " kernel: c01becd7\n",
2037 " kernel: *pde = 00000000\n",
2038 " kernel: Oops: 0000\n",
2039 " kernel: CPU: 0\n",
2040 " kernel: EIP: 0010:[<c01becd7>] Tainted: P \n",
2041 " kernel: EFLAGS: 00010286\n",
2042 " kernel: eax: 0000ff00 ebx: ca6b7e00 ecx: ce1d7a60 edx: ce1d7a60\n",
2043 " kernel: esi: ca6b7ebc edi: 00030000 ebp: d3655ca0 esp: ca6b7e5c\n",
2044 " kernel: ds: 0018 es: 0018 ss: 0018\n",
2045 " kernel: Process crond (pid: 1189, stackpage=ca6b7000)\n",
2046 " kernel: Stack: d3655ca0 ca6b7ebc 00030054 ca6b7e7c c01c1e5b "
2047 "00000287 00000020 c01c1fbf \n",
2049 " kernel: 00005a36 000000dc 000001f4 00000000 00000000 "
2050 "ce046d40 00000001 00000000 \n",
2052 " kernel: ffffffff d3655ca0 d3655b80 00030054 c01bef93 "
2053 "d3655ca0 ca6b7ebc 00030054 \n",
2055 " kernel: Call Trace: [<c01c1e5b>] [<c01c1fbf>] [<c01bef93>] "
2056 "[<c01bf02b>] [<c0134c4f>]\n",
2058 " kernel: [<c0142562>] [<c0114f8c>] [<c0134de3>] [<c010891b>]\n",
2060 " kernel: Code: 2a 00 75 08 8b 44 24 2c 85 c0 74 0c 8b 44 24 58 83 48 18 "
2065 bst->scroll_p = True;
2067 bst->left_margin = bst->right_margin = 10;
2068 bst->top_margin = bst->bottom_margin = 10;
2075 if (uname (&uts) >= 0)
2076 sysname = uts.nodename;
2077 s = strchr (sysname, '.');
2080 # endif /* !HAVE_UNAME */
2083 BSOD_TEXT (bst, LEFT, "waiting for X server to shut down ");
2084 BSOD_PAUSE (bst, 100000);
2085 BSOD_TEXT (bst, LEFT,
2086 "XIO: fatal IO error 2 (broken pipe) on X server \":0.0\"\n"
2087 " after 339471 requests (339471 known processed) "
2088 "with 0 events remaining\n");
2089 BSOD_CHAR_DELAY (bst, 300000);
2090 BSOD_TEXT (bst, LEFT, ".........\n");
2091 BSOD_CHAR_DELAY (bst, 0);
2092 BSOD_TEXT (bst, LEFT,
2093 "xinit: X server slow to shut down, sending KILL signal.\n"
2094 "waiting for server to die ");
2095 BSOD_CHAR_DELAY (bst, 300000);
2096 BSOD_TEXT (bst, LEFT, "...\n");
2097 BSOD_CHAR_DELAY (bst, 0);
2098 BSOD_TEXT (bst, LEFT, "xinit: Can't kill server\n");
2099 BSOD_PAUSE (bst, 2000000);
2101 sprintf (buf, "\n%s Login: ", sysname);
2102 BSOD_TEXT (bst, LEFT, buf);
2103 BSOD_PAUSE (bst, 1000000);
2104 BSOD_TEXT (bst, LEFT,
2106 "Parallelizing fsck version 1.22 (22-Jun-2001)\n"
2107 "e2fsck 1.22, 22-Jun-2001 for EXT2 FS 0.5b, 95/08/09\n"
2108 "Warning! /dev/hda1 is mounted.\n"
2109 "/dev/hda1 contains a file system with errors, check forced.\n");
2110 BSOD_PAUSE (bst, 1000000);
2112 if (0 == random() % 2)
2113 BSOD_TEXT (bst, LEFT,
2114 "Couldn't find ext2 superblock, trying backup blocks...\n"
2115 "The filesystem size (according to the superblock) is 3644739 blocks\n"
2116 "The physical size of the device is 3636706 blocks\n"
2117 "Either the superblock or the partition table is likely to be corrupt!\n"
2119 BSOD_PAUSE (bst, 1000000);
2123 BSOD_TEXT (bst, LEFT, "Pass 1: Checking inodes, blocks, and sizes\n");
2124 BSOD_PAUSE (bst, 2000000);
2126 i = (random() % 60) - 20;
2129 int b = random() % 0xFFFF;
2130 sprintf (buf, "Deleted inode %d has zero dtime. Fix<y>? yes\n\n", b);
2131 BSOD_TEXT (bst, LEFT, buf);
2132 BSOD_PAUSE (bst, 1000);
2135 i = (random() % 40) - 10;
2138 int g = random() % 0xFFFF;
2139 int b = random() % 0xFFFFFFF;
2141 BSOD_PAUSE (bst, 1000000);
2143 sprintf (buf, "Warning: Group %d's copy of the group descriptors "
2144 "has a bad block (%d).\n", g, b);
2145 BSOD_TEXT (bst, LEFT, buf);
2147 b = random() % 0x3FFFFF;
2150 b += random() % 0xFFFF;
2152 "Error reading block %d (Attempt to read block "
2153 "from filesystem resulted in short read) while doing "
2154 "inode scan. Ignore error<y>?",
2156 BSOD_TEXT (bst, LEFT, buf);
2157 BSOD_PAUSE (bst, 10000);
2158 BSOD_TEXT (bst, LEFT, " yes\n\n");
2162 if (0 == (random() % 10))
2164 BSOD_PAUSE (bst, 1000000);
2166 i = 3 + (random() % 10);
2169 BSOD_TEXT (bst, LEFT,
2170 "Could not allocate 256 block(s) for inode table: "
2171 "No space left on device\n");
2172 BSOD_PAUSE (bst, 1000);
2174 BSOD_TEXT (bst, LEFT, "Restarting e2fsck from the beginning...\n");
2175 BSOD_PAUSE (bst, 2000000);
2180 i = (random() % 20) - 5;
2183 BSOD_PAUSE (bst, 1000000);
2187 int j = 5 + (random() % 10);
2188 int w = random() % 4;
2192 int b = random() % 0xFFFFF;
2193 int g = random() % 0xFFF;
2195 if (0 == (random() % 10))
2197 else if (0 == (random() % 10))
2202 "Inode table for group %d not in group. (block %d)\n"
2203 "WARNING: SEVERE DATA LOSS POSSIBLE.\n"
2208 "Block bitmap for group %d not in group. (block %d)\n"
2213 "Inode bitmap %d for group %d not in group.\n"
2216 else /* if (w == 3) */
2218 "Bad block %d in group %d's inode table.\n"
2219 "WARNING: SEVERE DATA LOSS POSSIBLE.\n"
2223 BSOD_TEXT (bst, LEFT, buf);
2224 BSOD_TEXT (bst, LEFT, " yes\n\n");
2225 BSOD_PAUSE (bst, 1000);
2230 if (0 == random() % 10) goto PANIC;
2231 BSOD_TEXT (bst, LEFT, "Pass 2: Checking directory structure\n");
2232 BSOD_PAUSE (bst, 2000000);
2234 i = (random() % 20) - 5;
2237 int n = random() % 0xFFFFF;
2238 int o = random() % 0xFFF;
2239 sprintf (buf, "Directory inode %d, block 0, offset %d: "
2240 "directory corrupted\n"
2243 BSOD_TEXT (bst, LEFT, buf);
2244 BSOD_PAUSE (bst, 1000);
2245 BSOD_TEXT (bst, LEFT, " yes\n\n");
2247 if (0 == (random() % 100))
2249 sprintf (buf, "Missing '.' in directory inode %d.\nFix<y>?", n);
2250 BSOD_TEXT (bst, LEFT, buf);
2251 BSOD_PAUSE (bst, 1000);
2252 BSOD_TEXT (bst, LEFT, " yes\n\n");
2256 if (0 == random() % 10)
2259 BSOD_TEXT (bst, LEFT,
2260 "Pass 3: Checking directory connectivity\n"
2261 "/lost+found not found. Create? yes\n");
2262 BSOD_PAUSE (bst, 2000000);
2264 /* Unconnected directory inode 4949 (/var/spool/squid/06/???)
2265 Connect to /lost+found<y>? yes
2267 '..' in /var/spool/squid/06/08 (20351) is <The NULL inode> (0), should be
2268 /var/spool/squid/06 (20350).
2271 Unconnected directory inode 128337 (/var/spool/squid/06/???)
2272 Connect to /lost+found<y>? yes
2276 if (0 == random() % 10) goto PANIC;
2277 BSOD_TEXT (bst, LEFT, "Pass 4: Checking reference counts\n");
2278 BSOD_PAUSE (bst, 2000000);
2280 /* Inode 2 ref count is 19, should be 20. Fix<y>? yes
2282 Inode 4949 ref count is 3, should be 2. Fix<y>? yes
2286 Inode 128336 ref count is 3, should be 2. Fix<y>? yes
2288 Inode 128337 ref count is 3, should be 2. Fix<y>? yes
2293 if (0 == random() % 10) goto PANIC;
2294 BSOD_TEXT (bst, LEFT, "Pass 5: Checking group summary information\n");
2295 BSOD_PAUSE (bst, 2000000);
2297 i = (random() % 200) - 50;
2300 BSOD_TEXT (bst, LEFT, "Block bitmap differences: ");
2303 sprintf (buf, " %d", -(random() % 0xFFF));
2304 BSOD_TEXT (bst, LEFT, buf);
2305 BSOD_PAUSE (bst, 1000);
2307 BSOD_TEXT (bst, LEFT, "\nFix? yes\n\n");
2311 i = (random() % 100) - 50;
2314 BSOD_TEXT (bst, LEFT, "Inode bitmap differences: ");
2317 sprintf (buf, " %d", -(random() % 0xFFF));
2318 BSOD_TEXT (bst, LEFT, buf);
2319 BSOD_PAUSE (bst, 1000);
2321 BSOD_TEXT (bst, LEFT, "\nFix? yes\n\n");
2324 i = (random() % 20) - 5;
2327 int g = random() % 0xFFFF;
2328 int c = random() % 0xFFFF;
2330 "Free blocks count wrong for group #0 (%d, counted=%d).\nFix? ",
2332 BSOD_TEXT (bst, LEFT, buf);
2333 BSOD_PAUSE (bst, 1000);
2334 BSOD_TEXT (bst, LEFT, " yes\n\n");
2340 BSOD_TEXT (bst, LEFT, "\n\n");
2341 while (linux_panic[i])
2343 time_t t = time ((time_t *) 0);
2344 struct tm *tm = localtime (&t);
2347 if (*linux_panic[i])
2349 strftime (prefix, sizeof(prefix)-1, "%b %d %H:%M:%S ", tm);
2350 BSOD_TEXT (bst, LEFT, prefix);
2351 BSOD_TEXT (bst, LEFT, sysname);
2352 BSOD_TEXT (bst, LEFT, linux_panic[i]);
2353 BSOD_PAUSE (bst, 1000);
2356 BSOD_PAUSE (bst, 300000);
2360 BSOD_PAUSE (bst, 4000000);
2362 XClearWindow(dpy, window);
2368 * Linux (hppa) panic, by Stuart Brady <sdbrady@ntlworld.com>
2369 * Output courtesy of M. Grabert
2371 static struct bsod_state *
2372 hppa_linux (Display *dpy, Window window)
2374 struct bsod_state *bst =
2375 make_bsod_state (dpy, window, "hppalinux", "HPPALinux");
2378 const char *release, *sysname, *gccversion, *version;
2379 long int linedelay = 0;
2382 struct { long int delay; const char *string; } linux_panic[] =
2383 {{ 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"
2384 "\n\n\n\n\n\n\n\n\n\n\n\n\n" },
2385 { 0, "Linux version %s (root@%s) (gcc version %s) %s\n" },
2386 { 4000, "FP[0] enabled: Rev 1 Model 16\n" },
2387 { 10, "The 32-bit Kernel has started...\n" },
2388 { -1, "Determining PDC firmware type: System Map.\n" },
2389 { -1, "model 00005bb0 00000481 00000000 00000002 7778df9f 100000f0 "
2390 "00000008 000000b2 000000b2\n" },
2391 { -1, "vers 00000203\n" },
2392 { -1, "CPUID vers 17 rev 7 (0x00000227)\n" },
2393 { -1, "capabilities 0x3\n" },
2394 { -1, "model 9000/785/C3000\n" },
2395 { -1, "Total Memory: 1024 Mb\n" },
2396 { -1, "On node 0 totalpages: 262144\n" },
2397 { -1, " DMA zone: 262144 pages, LIFO batch:16\n" },
2398 { -1, " Normal zone: 0 pages, LIFO batch:1\n" },
2399 { -1, " HighMem zone: 0 pages, LIFO batch:1\n" },
2400 { -1, "LCD display at f05d0008,f05d0000 registered\n" },
2401 { -1, "Building zonelist for node : 0\n" },
2402 { -1, "Kernel command line: ide=nodma root=/dev/sda3 HOME=/ ip=off "
2403 "console=ttyS0 TERM=vt102 palo_kernel=2/vmlinux-2.6\n" },
2404 { -1, "ide_setup: ide=nodmaIDE: Prevented DMA\n" },
2405 { -1, "PID hash table entries: 16 (order 4: 128 bytes)\n" },
2406 {500, "Console: colour dummy device 160x64\n" },
2407 { 10, "Memory: 1034036k available\n" },
2408 { -1, "Calibrating delay loop... 796.67 BogoMIPS\n" },
2409 { -1, "Dentry cache hash table entries: 131072 (order: 7, 524288 "
2411 { -1, "Inode-cache hash table entries: 65536 (order: 6, 262144 "
2413 { -1, "Mount-cache hash table entries: 512 (order: 0, 4096 bytes)\n" },
2414 { -1, "POSIX conformance testing by UNIFIX\n" },
2415 { -1, "NET: Registered protocol family 16\n" },
2416 { 100, "Searching for devices...\n" },
2417 { 25, "Found devices:\n" },
2418 { 10, "1. Astro BC Runway Port at 0xfed00000 [10] "
2419 "{ 12, 0x0, 0x582, 0x0000b }\n" },
2420 { -1, "2. Elroy PCI Bridge at 0xfed30000 [10/0] "
2421 "{ 13, 0x0, 0x782, 0x0000a }\n" },
2422 { -1, "3. Elroy PCI Bridge at 0xfed32000 [10/1] "
2423 "{ 13, 0x0, 0x782, 0x0000a }\n" },
2424 { -1, "4. Elroy PCI Bridge at 0xfed38000 [10/4] "
2425 "{ 13, 0x0, 0x782, 0x0000a }\n" },
2426 { -1, "5. Elroy PCI Bridge at 0xfed3c000 [10/6] "
2427 "{ 13, 0x0, 0x782, 0x0000a }\n" },
2428 { -1, "6. AllegroHigh W at 0xfffa0000 [32] "
2429 "{ 0, 0x0, 0x5bb, 0x00004 }\n" },
2430 { -1, "7. Memory at 0xfed10200 [49] { 1, 0x0, 0x086, 0x00009 }\n" },
2431 { -1, "CPU(s): 1 x PA8500 (PCX-W) at 400.000000 MHz\n" },
2432 { -1, "SBA found Astro 2.1 at 0xfed00000\n" },
2433 { -1, "lba version TR2.1 (0x2) found at 0xfed30000\n" },
2434 { -1, "lba version TR2.1 (0x2) found at 0xfed32000\n" },
2435 { -1, "lba version TR2.1 (0x2) found at 0xfed38000\n" },
2436 { -1, "lba version TR2.1 (0x2) found at 0xfed3c000\n" },
2437 { 100, "SCSI subsystem initialized\n" },
2438 { 10, "drivers/usb/core/usb.c: registered new driver usbfs\n" },
2439 { -1, "drivers/usb/core/usb.c: registered new driver hub\n" },
2440 { -1, "ikconfig 0.7 with /proc/config*\n" },
2441 { -1, "Initializing Cryptographic API\n" },
2442 { 250, "SuperIO: probe of 0000:00:0e.0 failed with error -1\n" },
2443 { 20, "SuperIO: Found NS87560 Legacy I/O device at 0000:00:0e.1 "
2445 { -1, "SuperIO: Serial port 1 at 0x3f8\n" },
2446 { -1, "SuperIO: Serial port 2 at 0x2f8\n" },
2447 { -1, "SuperIO: Parallel port at 0x378\n" },
2448 { -1, "SuperIO: Floppy controller at 0x3f0\n" },
2449 { -1, "SuperIO: ACPI at 0x7e0\n" },
2450 { -1, "SuperIO: USB regulator enabled\n" },
2451 { -1, "SuperIO: probe of 0000:00:0e.2 failed with error -1\n" },
2452 { -1, "Soft power switch enabled, polling @ 0xf0400804.\n" },
2453 { -1, "pty: 256 Unix98 ptys configured\n" },
2454 { -1, "Generic RTC Driver v1.07\n" },
2455 { -1, "Serial: 8250/16550 driver $Revision: 1.96 $ 13 ports, "
2456 "IRQ sharing disabled\n" },
2457 { -1, "ttyS0 at I/O 0x3f8 (irq = 0) is a 16550A\n" },
2458 { -1, "ttyS1 at I/O 0x2f8 (irq = 0) is a 16550A\n" },
2459 { -1, "Linux Tulip driver version 1.1.13 (May 11, 2002)\n" },
2460 { 150, "tulip0: no phy info, aborting mtable build\n" },
2461 { 10, "tulip0: MII transceiver #1 config 1000 status 782d "
2462 "advertising 01e1.\n" },
2463 { -1, "eth0: Digital DS21143 Tulip rev 65 at 0xf4008000, "
2464 "00:10:83:F9:B4:34, IRQ 66.\n" },
2465 { -1, "Uniform Multi-Platform E-IDE driver Revision: 7.00alpha2\n" },
2466 { -1, "ide: Assuming 33MHz system bus speed for PIO modes; "
2467 "override with idebus=xx\n" },
2468 { 100, "SiI680: IDE controller at PCI slot 0000:01:06.0\n" },
2469 { 10, "SiI680: chipset revision 2\n" },
2470 { -1, "SiI680: BASE CLOCK == 133\n" },
2471 { -1, "SiI680: 100% native mode on irq 128\n" },
2472 { -1, " ide0: MMIO-DMA at 0xf4800000-0xf4800007 -- "
2473 "Error, MMIO ports already in use.\n" },
2474 { -1, " ide1: MMIO-DMA at 0xf4800008-0xf480000f -- "
2475 "Error, MMIO ports already in use.\n" },
2476 { 5, "hda: TS130220A2, ATA DISK drive\n" },
2477 { -1, " _______________________________\n" },
2478 { -1, " < Your System ate a SPARC! Gah! >\n" },
2479 { -1, " -------------------------------\n" },
2480 { -1, " \\ ^__^\n" },
2481 { -1, " \\ (xx)\\_______\n" },
2482 { -1, " (__)\\ )\\/\\\n" },
2483 { -1, " U ||----w |\n" },
2485 { -1, "swapper (pid 1): Breakpoint (code 0)\n" },
2487 { -1, " YZrvWESTHLNXBCVMcbcbcbcbOGFRQPDI\n" },
2488 { -1, "PSW: 00000000000001001111111100001111 Not tainted\n" },
2489 { -1, "r00-03 4d6f6f21 1032f010 10208f34 103fc2e0\n" },
2490 { -1, "r04-07 103fc230 00000001 00000001 0000000f\n" },
2491 { -1, "r08-11 103454f8 000f41fa 372d3980 103ee404\n" },
2492 { -1, "r12-15 3ccbf700 10344810 103ee010 f0400004\n" },
2493 { -1, "r16-19 f00008c4 f000017c f0000174 00000000\n" },
2494 { -1, "r20-23 fed32840 fed32800 00000000 0000000a\n" },
2495 { -1, "r24-27 0000ffa0 000000ff 103fc2e0 10326010\n" },
2496 { -1, "r28-31 00000000 00061a80 4ff98340 10208f34\n" },
2497 { -1, "sr0-3 00000000 00000000 00000000 00000000\n" },
2498 { -1, "sr4-7 00000000 00000000 00000000 00000000\n" },
2500 { -1, "IASQ: 00000000 00000000 IAOQ: 00000000 00000004\n" },
2501 { -1, " IIR: 00000000 ISR: 00000000 IOR: 00000000\n" },
2502 { -1, " CPU: 0 CR30: 4ff98000 CR31: 1037c000\n" },
2503 { -1, " ORIG_R28: 55555555\n" },
2504 { -1, " IAOQ[0]: 0x0\n" },
2505 { -1, " IAOQ[1]: 0x4\n" },
2506 { -1, " RP(r2): probe_hwif+0x218/0x44c\n" },
2507 { -1, "Kernel panic: Attempted to kill init!\n" },
2510 bst->scroll_p = True;
2512 bst->left_margin = bst->right_margin = 10;
2513 bst->top_margin = bst->bottom_margin = 10;
2515 release = "2.6.0-test11-pa2";
2517 version = "#2 Mon Dec 8 06:09:27 GMT 2003";
2522 if (uname (&uts) >= 0)
2524 sysname = uts.nodename;
2525 if (!strcmp (uts.sysname, "Linux"))
2527 release = uts.release;
2528 version = uts.version;
2531 s = strchr (sysname, '.');
2534 # endif /* !HAVE_UNAME */
2536 # if (defined (__GNUC__) && defined (__VERSION__))
2537 gccversion = __VERSION__;
2538 # else /* !(defined (__GNUC__) && defined (__VERSION__)) */
2539 gccversion = "3.3.2 (Debian)";
2540 # endif /* !(defined (__GNUC__) && defined (__VERSION__)) */
2542 /* Insert current host name into banner on line 2 */
2545 snprintf (ss, 1024, linux_panic[1].string,
2546 release, sysname, gccversion, version);
2547 linux_panic[1].string = ss;
2550 BSOD_PAUSE (bst, 100000);
2551 while (linux_panic[i].string)
2553 if (linux_panic[i].delay != -1)
2554 linedelay = linux_panic[i].delay * 1000;
2555 BSOD_PAUSE (bst, linedelay);
2556 BSOD_TEXT (bst, LEFT, linux_panic[i].string);
2560 bst->y = bst->xgwa.height - bst->font->ascent - bst->font->descent;
2562 XClearWindow(dpy, window);
2567 /* VMS by jwz (text sent by Roland Barmettler <roli@barmettler.net>)
2569 static struct bsod_state *
2570 vms (Display *dpy, Window window)
2572 struct bsod_state *bst = make_bsod_state (dpy, window, "vms", "VMS");
2574 const char *sysname;
2576 int dot_delay = 40000;
2577 int chunk_delay = 500000;
2584 const char *lines[] = {
2585 "%CNXMAN, Lost connection to system #\n"
2586 "%SHADOW-I-VOLPROC, DSA0: shadow master has changed. "
2587 "Dump file WILL be written if system crashes.\n"
2591 "%CNXMAN, Quorum lost, blocking activity\n"
2592 "%CNXMAN, Timed-out lost connection to system #\n"
2593 "%CNXMAN, Timed-out lost connection to system #\n"
2594 "%CNXMAN, Timed-out lost connection to system #\n"
2595 "%CNXMAN, Proposing reconfiguration of the VMScluster\n",
2598 "%CNXMAN, Removed from VMScluster system #\n"
2599 "%CNXMAN, Removed from VMScluster system #\n"
2600 "%CNXMAN, Removed from VMScluster system #\n"
2601 "%CNXMAN, Completing VMScluster state transition\n",
2604 "**** OpenVMS (TM) Alpha Operating system V7.3-1 - BUGCHECK ****\n"
2606 "** Bugcheck code = 000005DC: CLUEXIT, Node voluntarily exiting "
2608 "** Crash CPU: 00 Primary CPU: 00 Active CPUs: 00000001\n"
2609 "** Current Process = NULL\n"
2610 "** Current PSB ID = 00000001\n"
2613 "** Dumping error log buffers to HBVS unit 0\n"
2614 "**** Unable to dump error log buffers to remaining shadow set members\n"
2615 "** Error log buffers not dumped to HBVS unit 200\n"
2617 "** Dumping memory to HBVS unit 0\n"
2618 "**** Starting compressed selective memory dump at #...\n",
2623 "**** Memory dump complete - not all processes or global pages saved\n",
2631 "HALT instruction executed\n"
2632 "PC = ffffffff800c3884\n",
2638 "resetting all I/O buses\n"
2645 bst->scroll_p = True;
2647 bst->left_margin = bst->right_margin = 10;
2648 bst->top_margin = bst->bottom_margin = 10;
2654 if (uname (&uts) >= 0)
2655 sysname = uts.nodename;
2656 s = strchr (sysname, '.');
2659 # endif /* !HAVE_UNAME */
2661 args[0] = malloc (strlen(sysname) + 7);
2662 strcpy (args[0], sysname);
2665 /* Pick three numbers, 1-9, no overlaps. */
2666 ids[0] = 1 + (random() % 9);
2667 do { ids[1] = 1 + (random() % 9); } while (ids[1]==ids[0]);
2668 do { ids[2] = 1 + (random() % 9); } while (ids[2]==ids[0] || ids[2]==ids[1]);
2670 i = strlen(args[0])-1;
2672 args[0][i] = '0' + ids[0];
2675 for (s = args[0]; *s; s++)
2676 if (isalpha(*s)) *s = toupper (*s);
2678 args[1] = strdup (args[0]);
2679 args[2] = strdup (args[0]); args[2][i] = '0' + ids[1];
2680 args[3] = strdup (args[0]); args[3][i] = '0' + ids[2];
2682 args[4] = strdup (args[1]);
2683 args[5] = strdup (args[2]);
2684 args[6] = strdup (args[3]);
2687 time_t t = time ((time_t *) 0);
2688 struct tm *tm = localtime (&t);
2689 args[7] = malloc (30);
2690 strftime (args[7], 29, "%d-%b-%Y %H:%M", tm);
2691 for (s = args[7]; *s; s++)
2692 if (isalpha(*s)) *s = toupper (*s);
2696 for (i = 0; i < countof(lines); i++)
2698 const char *fmt = lines[i];
2699 if (! strcmp (fmt, "..."))
2701 int steps = 180 + (random() % 60);
2702 while (--steps >= 0)
2704 BSOD_TEXT (bst, LEFT, ".");
2705 BSOD_PAUSE (bst, dot_delay);
2710 char *fmt2 = malloc (strlen (fmt) * 2 + 1);
2711 for (s = (char *) fmt, s1 = fmt2; *s; s++)
2715 strcpy (s1, args[arg_count++]);
2722 BSOD_CHAR_DELAY (bst, char_delay);
2723 BSOD_TEXT (bst, LEFT, fmt2);
2725 BSOD_CHAR_DELAY (bst, 0);
2726 BSOD_PAUSE (bst, chunk_delay);
2730 for (i = 0; i < countof (args); i++)
2733 XClearWindow(dpy, window);
2738 /* HVX (formerly GCOS6) and TPS6 crash
2739 by Brian Garratt <brian-m.garratt@bull.co.uk>
2741 GCOS6 is a Unix-like operating system developed by Honeywell in the
2742 1970s in collaboration with MIT and AT&T (who called their version
2743 UNIX). Both are very much like MULTICS which Honeywell got from GE.
2745 HVX ("High-performance Virtual System on Unix") is an AIX application
2746 which emulates GCOS6 hardware on RS6000-like machines.
2748 static struct bsod_state *
2749 hvx (Display *dpy, Window window)
2751 struct bsod_state *bst = make_bsod_state (dpy, window, "hvx", "HVX");
2753 bst->scroll_p = True;
2755 bst->y = bst->xgwa.height - bst->bottom_margin - bst->font->ascent;
2757 BSOD_CHAR_DELAY (bst, 10000);
2758 BSOD_TEXT (bst, LEFT,
2759 "(TP) Trap no E Effective address 00000000 Instruction D7DE\n"
2760 "(TP) Registers :\n"
2761 "(TP) B1 -> B7 03801B02 00000000 03880D45 038BABDB 0388AFFD"
2762 " 0389B3F8 03972317\n"
2763 "(TP) R1 -> R7 0001 0007 F10F 090F 0020 0106 0272\n"
2764 "(TP) P I Z M1 0388A18B 3232 0000 FF00\n"
2765 "(TP) Program counter is at offset 0028 from string YTPAD\n"
2766 "(TP) User id of task which trapped is LT 626\n"
2769 BSOD_PAUSE (bst, 1000000);
2771 BSOD_CHAR_DELAY (bst, 100000);
2772 BSOD_TEXT (bst, LEFT, " TP CLOSE ALL");
2774 BSOD_CHAR_DELAY (bst, 10000);
2775 BSOD_TEXT (bst, LEFT, "\n(TP)?\n");
2776 BSOD_PAUSE (bst, 1000000);
2778 BSOD_CHAR_DELAY (bst, 100000);
2779 BSOD_TEXT (bst, LEFT, " TP ABORT -LT ALL");
2781 BSOD_CHAR_DELAY (bst, 10000);
2782 BSOD_TEXT (bst, LEFT, "\n(TP)?\n");
2783 BSOD_PAUSE (bst, 1000000);
2785 BSOD_CHAR_DELAY (bst, 100000);
2786 BSOD_TEXT (bst, LEFT, " TP STOP KILL");
2788 BSOD_CHAR_DELAY (bst, 10000);
2789 BSOD_TEXT (bst, LEFT,
2792 "Core dumps initiated for selected HVX processes ...\n"
2793 "Core dumps complete.\n"
2794 "Fri Jul 19 15:53:09 2002\n"
2795 "Live registers for cp 0:\n"
2796 " P = 7de3 IW=0000 I=32 CI=30000000 S=80006013"
2797 " IV=aa0 Level=13\n"
2798 " R1-7 = 1f 913 13 4 8 0 0\n"
2799 " B1-7 = 64e71b a93 50e 64e73c 6c2c 7000 b54\n"
2800 "Memory dump starting to file /var/hvx/dp01/diag/Level2 ...\n"
2801 "Memory dump complete.\n"
2804 XClearWindow(dpy, window);
2809 /* HPUX panic, by Tobias Klausmann <klausman@schwarzvogel.de>
2811 static struct bsod_state *
2812 hpux (Display *dpy, Window window)
2814 struct bsod_state *bst = make_bsod_state (dpy, window, "hvx", "HVX");
2815 const char *sysname;
2818 bst->scroll_p = True;
2819 bst->y = bst->xgwa.height - bst->bottom_margin - bst->font->ascent;
2826 if (uname (&uts) >= 0)
2827 sysname = uts.nodename;
2828 s = strchr (sysname, '.');
2831 # endif /* !HAVE_UNAME */
2833 BSOD_TEXT (bst, LEFT,
2837 sprintf (buf, "%.100s [HP Release B.11.00] (see /etc/issue)\n", sysname);
2838 BSOD_TEXT (bst, LEFT, buf);
2839 BSOD_PAUSE (bst, 1000000);
2840 BSOD_TEXT (bst, LEFT,
2843 " ******* Unexpected HPMC/TOC. Processor HPA FFFFFFFF'"
2844 "FFFA0000 *******\n"
2845 " GENERAL REGISTERS:\n"
2846 "r00/03 00000000'00000000 00000000'00000000 00000000'00000000 00000000'"
2848 "r04/07 00000000'00000001 00000000'0126E328 00000000'00000000 00000000'"
2850 "r08/11 00000000'00000000 00000000'0198CFC0 00000000'000476FE 00000000'"
2852 "r12/15 00000000'40013EE8 00000000'08000080 00000000'4002530C 00000000'"
2854 "r16/19 00000000'7F7F2A00 00000000'00000001 00000000'00000000 00000000'"
2856 "r20/23 00000000'006C8048 00000000'00000001 00000000'00000000 00000000'"
2858 "r24/27 00000000'00000000 00000000'00000000 00000000'00000000 00000000'"
2860 "r28/31 00000000'00000000 00000000'007DD628 00000000'0199F2B0 00000000'"
2862 " CONTROL REGISTERS:\n"
2863 "sr0/3 00000000'0F3B4000 00000000'0C2A2000 00000000'016FF800 00000000'"
2865 "sr4/7 00000000'00000000 00000000'016FF800 00000000'0DBF1400 00000000'"
2867 "pcq = 00000000'00000000.00000000'00104950 00000000'00000000.00000000'"
2869 "isr = 00000000'10240006 ior = 00000000'67D9E220 iir = 08000240 rctr = "
2872 "pid reg cr8/cr9 00007700'0000B3A9 00000000'0000C5D8\n"
2873 "pid reg cr12/cr13 00000000'00000000 00000000'00000000\n"
2874 "ipsw = 000000FF'080CFF1F iva = 00000000'0002C000 sar = 3A ccr = C0\n"
2875 "tr0/3 00000000'006C76C0 00000000'00000001 00000000'00000000 00000000'"
2877 "tr4/7 00000000'03790000 0000000C'4FB68340 00000000'C07EE13F 00000000'"
2879 "eiem = FFFFFFF0'FFFFFFFF eirr = 80000000'00000000 itmr = 0000000C'"
2881 "cr1/4 00000000'00000000 00000000'00000000 00000000'00000000 00000000'"
2883 "cr5/7 00000000'00000000 00000000'00000000 00000000'"
2885 " MACHINE CHECK PARAMETERS:\n"
2886 "Check Type = 00000000 CPU STATE = 9E000001 Cache Check = 00000000\n"
2887 "TLB Check = 00000000 Bus Check = 00000000 PIM State = ? SIU "
2888 "Status = ????????\n"
2889 "Assists = 00000000 Processor = 00000000\n"
2890 "Slave Addr = 00000000'00000000 Master Addr = 00000000'00000000\n"
2893 "TOC, pcsq.pcoq = 0'0.0'104950 , isr.ior = 0'10240006.0'67d9e220\n"
2894 "@(#)B2352B/9245XB HP-UX (B.11.00) #1: Wed Nov 5 22:38:19 PST 1997\n"
2895 "Transfer of control: (display==0xd904, flags==0x0)\n"
2899 "*** A system crash has occurred. (See the above messages for details.)\n"
2900 "*** The system is now preparing to dump physical memory to disk, for use\n"
2901 "*** in debugging the crash.\n"
2903 "*** The dump will be a SELECTIVE dump: 40 of 256 megabytes.\n"
2904 "*** To change this dump type, press any key within 10 seconds.\n"
2905 "*** Proceeding with selective dump.\n"
2907 "*** The dump may be aborted at any time by pressing ESC.\n");
2913 for (i = 0; i <= steps; i++)
2915 if (i > steps) i = steps;
2917 "*** Dumping: %3d%% complete (%d of 40 MB) (device 64:0x2)\r",
2920 BSOD_TEXT (bst, LEFT, buf);
2921 BSOD_PAUSE (bst, 1500000);
2925 BSOD_TEXT (bst, LEFT, "\n*** System rebooting.\n");
2927 XClearWindow(dpy, window);
2932 /* IBM OS/390 aka MVS aka z/OS.
2933 Text from Dan Espen <dane@mk.telcordia.com>.
2934 Apparently this isn't actually a crash, just a random session...
2937 static struct bsod_state *
2938 os390 (Display *dpy, Window window)
2940 struct bsod_state *bst = make_bsod_state (dpy, window, "os390", "OS390");
2942 bst->scroll_p = True;
2943 bst->y = bst->xgwa.height - bst->bottom_margin - bst->font->ascent;
2945 BSOD_LINE_DELAY (bst, 100000);
2946 BSOD_TEXT (bst, LEFT,
2947 "\n*** System rebooting.\n"
2948 "* ISPF Subtask abend *\n"
2949 "SPF ENDED DUE TO ERROR+\n"
2952 "IEA995I SYMPTOM DUMP OUTPUT\n"
2953 " USER COMPLETION CODE=0222\n"
2954 " TIME=23.00.51 SEQ=03210 CPU=0000 ASID=00AE\n"
2955 " PSW AT TIME OF ERROR 078D1000 859DAF18 ILC 2 INTC 0D\n"
2956 " NO ACTIVE MODULE FOUND\n"
2958 " DATA AT PSW 059DAF12 - 00181610 0A0D9180 70644710\n"
2959 " AR/GR 0: 00000000/80000000 1: 00000000/800000DE\n"
2960 " 2: 00000000/196504DC 3: 00000000/00037A78\n"
2961 " 4: 00000000/00037B78 5: 00000000/0003351C\n"
2962 " 6: 00000000/0000F0AD 7: 00000000/00012000\n"
2963 " 8: 00000000/059DAF10 9: 00000000/0002D098\n"
2964 " A: 00000000/059D9F10 B: 00000000/059D8F10\n"
2965 " C: 00000000/859D7F10 D: 00000000/00032D60\n"
2966 " E: 00000000/00033005 F: 01000002/00000041\n"
2967 " END OF SYMPTOM DUMP\n"
2968 "ISPS014 - ** Logical screen request failed - abend 0000DE **\n"
2969 "ISPS015 - ** Contact your system programmer or dialog developer.**\n"
2970 "*** ISPF Main task abend ***\n"
2971 "IEA995I SYMPTOM DUMP OUTPUT\n"
2972 " USER COMPLETION CODE=0222\n"
2973 " TIME=23.00.52 SEQ=03211 CPU=0000 ASID=00AE\n"
2974 " PSW AT TIME OF ERROR 078D1000 8585713C ILC 2 INTC 0D\n"
2975 " ACTIVE LOAD MODULE ADDRESS=05855000 OFFSET=0000213C\n"
2977 " DATA AT PSW 05857136 - 00181610 0A0D9180 D3304770\n"
2978 " GR 0: 80000000 1: 800000DE\n"
2979 " 2: 00015260 3: 00000038\n"
2980 " 4: 00012508 5: 00000000\n"
2981 " 6: 000173AC 7: FFFFFFF8\n"
2982 " 8: 05858000 9: 00012CA0\n"
2983 " A: 05857000 B: 05856000\n"
2984 " C: 85855000 D: 00017020\n"
2985 " E: 85857104 F: 00000000\n"
2986 " END OF SYMPTOM DUMP\n"
2989 BSOD_CURSOR (bst, CURSOR_LINE, 240000, 999999);
2991 XClearWindow(dpy, window);
2996 /* Compaq Tru64 Unix panic, by jwz as described by
2997 Tobias Klausmann <klausman@schwarzvogel.de>
2999 static struct bsod_state *
3000 tru64 (Display *dpy, Window window)
3002 struct bsod_state *bst = make_bsod_state (dpy, window, "tru64", "Tru64");
3003 const char *sysname;
3006 bst->scroll_p = True;
3007 bst->y = bst->xgwa.height - bst->bottom_margin - bst->font->ascent;
3009 sysname = "127.0.0.1";
3013 if (uname (&uts) >= 0)
3014 sysname = uts.nodename;
3016 # endif /* !HAVE_UNAME */
3019 "Compaq Tru64 UNIX V5.1B (Rev. 2650) (%.100s) console\n"
3023 BSOD_TEXT (bst, LEFT, buf);
3024 BSOD_PAUSE (bst, 6000000);
3026 BSOD_TEXT (bst, LEFT,
3027 "panic (cpu 0): trap: illegal instruction\n"
3028 "kernel inst fault=gentrap, ps=0x5, pc=0xfffffc0000593878, inst=0xaa\n"
3029 "kernel inst fault=gentrap, ps=0x5, pc=0xfffffc0000593878, inst=0xaa\n"
3031 "DUMP: blocks available: 1571600\n"
3032 "DUMP: blocks wanted: 100802 (partial compressed dump) [OKAY]\n"
3033 "DUMP: Device Disk Blocks Available\n"
3034 "DUMP: ------ ---------------------\n"
3035 "DUMP: 0x1300023 1182795 - 1571597 (of 1571598) [primary swap]\n"
3036 "DUMP.prom: Open: dev 0x5100041, block 2102016: SCSI 0 11 0 2 200 0 0\n"
3037 "DUMP: Writing header... [1024 bytes at dev 0x1300023, block 1571598]\n"
3038 "DUMP: Writing data");
3042 int steps = 4 + (random() % 8);
3043 BSOD_CHAR_DELAY (bst, 1000000);
3044 for (i = 0; i < steps; i++)
3045 BSOD_TEXT (bst, LEFT, ".");
3046 BSOD_CHAR_DELAY (bst, 0);
3047 sprintf (buf, "[%dMB]\n", steps);
3048 BSOD_TEXT (bst, LEFT, buf);
3051 BSOD_TEXT (bst, LEFT,
3052 "DUMP: Writing header... [1024 bytes at dev 0x1300023, block 1571598]\n"
3053 "DUMP: crash dump complete.\n"
3054 "kernel inst fault=gentrap, ps=0x5, pc=0xfffffc0000593878, inst=0xaa\n"
3056 "DUMP: second crash dump skipped: 'dump_savecnt' enforced.\n");
3057 BSOD_PAUSE (bst, 4000000);
3059 BSOD_TEXT (bst, LEFT,
3064 "HALT instruction executed\n"
3065 "PC = fffffc00005863b0\n");
3066 BSOD_PAUSE (bst, 3000000);
3068 BSOD_TEXT (bst, LEFT,
3075 XClearWindow(dpy, window);
3082 static struct bsod_state *
3083 msdos (Display *dpy, Window window)
3085 struct bsod_state *bst = make_bsod_state (dpy, window, "msdos", "MSDOS");
3087 BSOD_CHAR_DELAY (bst, 10000);
3088 BSOD_TEXT (bst, LEFT, "C:\\WINDOWS>");
3089 BSOD_CURSOR (bst, CURSOR_LINE, 200000, 8);
3091 BSOD_CHAR_DELAY (bst, 200000);
3092 BSOD_TEXT (bst, LEFT, "dir a:");
3093 BSOD_PAUSE (bst, 1000000);
3095 BSOD_CHAR_DELAY (bst, 10000);
3096 BSOD_TEXT (bst, LEFT, "\nNot ready reading drive A\nAbort, Retry, Fail?");
3098 BSOD_CURSOR (bst, CURSOR_LINE, 200000, 10);
3099 BSOD_CHAR_DELAY (bst, 200000);
3100 BSOD_TEXT (bst, LEFT, "f");
3101 BSOD_PAUSE (bst, 1000000);
3103 BSOD_CHAR_DELAY (bst, 10000);
3104 BSOD_TEXT (bst, LEFT,
3105 "\n\n\nNot ready reading drive A\nAbort, Retry, Fail?");
3107 BSOD_CURSOR (bst, CURSOR_LINE, 200000, 10);
3108 BSOD_CHAR_DELAY (bst, 200000);
3109 BSOD_TEXT (bst, LEFT, "f");
3110 BSOD_PAUSE (bst, 1000000);
3112 BSOD_CHAR_DELAY (bst, 10000);
3113 BSOD_TEXT (bst, LEFT, "\nVolume in drive A has no label\n\n"
3114 "Not ready reading drive A\nAbort, Retry, Fail?");
3116 BSOD_CURSOR (bst, CURSOR_LINE, 200000, 12);
3117 BSOD_CHAR_DELAY (bst, 200000);
3118 BSOD_TEXT (bst, LEFT, "a");
3119 BSOD_PAUSE (bst, 1000000);
3121 BSOD_CHAR_DELAY (bst, 10000);
3122 BSOD_TEXT (bst, LEFT, "\n\nC:\\WINDOWS>");
3124 BSOD_CURSOR (bst, CURSOR_LINE, 200000, 999999);
3126 XClearWindow(dpy, window);
3133 * This is what happens if an Nvidia card goes into some crazy text mode.
3134 * Most often seen on the second screen of a dual-head system when the
3135 * proper driver isn't loaded.
3137 typedef struct { int fg; int bg; int bit; Bool blink; } nvcell;
3140 nvspatter (nvcell *grid, int rows, int cols, int ncolors, int nbits,
3143 int max = rows * cols;
3144 int from = fill_p ? 0 : random() % (max - 1);
3145 int len = fill_p ? max : random() % (cols * 4);
3146 int to = from + len;
3148 Bool noisy = ((random() % 4) == 0);
3149 Bool diag = (noisy || fill_p) ? 0 : ((random() % 4) == 0);
3151 int fg = random() % ncolors;
3152 int bg = random() % ncolors;
3153 int blink = ((random() % 4) == 0);
3154 int bit = (random() % nbits);
3156 if (to > max) to = max;
3160 int src = random() % (rows * cols);
3161 int len2 = (cols / 2) - (random() % 5);
3163 for (i = from; i < to; i++, j++)
3165 if (j > src + len2 || j >= max)
3167 if (i >= max) abort();
3168 if (j >= max) abort();
3173 for (i = from; i < to; i++)
3175 nvcell *cell = &grid[i];
3179 cell->blink = blink;
3183 fg = random() % ncolors;
3184 bg = random() % ncolors;
3185 blink = ((random() % 8) == 0);
3191 struct bsod_state *bst;
3198 unsigned long colors[256];
3204 nvidia_free (struct bsod_state *bst)
3206 nvstate *nvs = (nvstate *) bst->closure;
3208 XFreeColors (bst->dpy, bst->xgwa.colormap, nvs->colors, nvs->ncolors, 0);
3209 for (i = 0; i < countof(nvs->bits); i++)
3210 XFreePixmap (bst->dpy, nvs->bits[i]);
3211 XFreeGC (bst->dpy, nvs->gc1);
3217 nvidia_draw (struct bsod_state *bst)
3219 nvstate *nvs = (nvstate *) bst->closure;
3222 for (y = 0; y < nvs->rows; y++)
3223 for (x = 0; x < nvs->cols; x++)
3225 nvcell *cell = &nvs->grid[y * nvs->cols + x];
3226 unsigned long fg = nvs->colors[cell->fg];
3227 unsigned long bg = nvs->colors[cell->bg];
3228 Bool flip = cell->blink && (nvs->tick & 1);
3229 XSetForeground (bst->dpy, bst->gc, flip ? fg : bg);
3230 XSetBackground (bst->dpy, bst->gc, flip ? bg : fg);
3231 XCopyPlane (bst->dpy, nvs->bits[cell->bit], bst->window, bst->gc,
3232 0, 0, nvs->cellw, nvs->cellh,
3233 x * nvs->cellw, y * nvs->cellh, 1L);
3237 if ((random() % 5) == 0) /* change the display */
3238 nvspatter (nvs->grid, nvs->rows, nvs->cols, nvs->ncolors,
3239 countof(nvs->bits), False);
3245 static struct bsod_state *
3246 nvidia (Display *dpy, Window window)
3248 struct bsod_state *bst = make_bsod_state (dpy, window, "nvidia", "nVidia");
3249 nvstate *nvs = (nvstate *) calloc (1, sizeof (*nvs));
3256 bst->draw_cb = nvidia_draw;
3257 bst->free_cb = nvidia_free;
3261 nvs->cellw = bst->xgwa.width / nvs->cols;
3262 nvs->cellh = bst->xgwa.height / nvs->rows;
3263 if (nvs->cellw < 8 || nvs->cellh < 18)
3264 nvs->cellw = 8, nvs->cellh = 18;
3265 nvs->cols = (bst->xgwa.width / nvs->cellw) + 1;
3266 nvs->rows = (bst->xgwa.height / nvs->cellh) + 1;
3268 nvs->grid = (nvcell *) calloc (sizeof(*nvs->grid), nvs->rows * nvs->cols);
3273 for (i = 0; i < nvs->ncolors; i++)
3276 c.red = random() & 0xFFFF;
3277 c.green = random() & 0xFFFF;
3278 c.blue = random() & 0xFFFF;
3279 c.flags = DoRed|DoGreen|DoBlue;
3280 XAllocColor (dpy, bst->xgwa.colormap, &c);
3281 nvs->colors[i] = c.pixel;
3284 /* Construct corrupted character bitmaps
3286 for (i = 0; i < countof(nvs->bits); i++)
3290 nvs->bits[i] = XCreatePixmap (dpy, window, nvs->cellw, nvs->cellh, 1);
3291 if (!nvs->gc1) nvs->gc1 = XCreateGC (dpy, nvs->bits[i], 0, &gcv);
3293 XSetForeground (dpy, nvs->gc1, 0);
3294 XFillRectangle (dpy, nvs->bits[i], nvs->gc1, 0, 0,
3295 nvs->cellw, nvs->cellh);
3296 XSetForeground (dpy, nvs->gc1, 1);
3298 if ((random() % 40) != 0)
3299 for (j = 0; j < ((nvs->cellw * nvs->cellh) / 16); j++)
3300 XFillRectangle (dpy, nvs->bits[i], nvs->gc1,
3301 (random() % (nvs->cellw-2)) & ~1,
3302 (random() % (nvs->cellh-2)) & ~1,
3306 /* Randomize the grid
3308 nvspatter (nvs->grid, nvs->rows, nvs->cols, nvs->ncolors,
3309 countof(nvs->bits), True);
3310 for (i = 0; i < 20; i++)
3311 nvspatter (nvs->grid, nvs->rows, nvs->cols, nvs->ncolors,
3312 countof(nvs->bits), False);
3319 * Simulate various Apple ][ crashes. The memory map encouraged many programs
3320 * to use the primary hi-res video page for various storage, and the secondary
3321 * hi-res page for active display. When it crashed into Applesoft or the
3322 * monitor, it would revert to the primary page and you'd see memory garbage on
3323 * the screen. Also, it was common for copy-protected games to use the primary
3324 * text page for important code, because that made it really hard to
3325 * reverse-engineer them. The result often looked like what this generates.
3327 * The Apple ][ logic and video hardware is in apple2.c. The TV is emulated by
3328 * analogtv.c for maximum realism
3330 * Trevor Blackwell <tlb@tlb.org>
3333 static const char * const apple2_basic_errors[]={
3337 "RETURN WITHOUT GOSUB",
3341 "BAD SUBSCRIPT ERROR",
3344 "FORMULA TOO COMPLEX",
3349 "DEFAULT ARGUMENTS ARE NOT ALLOWED IN DECLARATION OF FRIEND "
3350 "TEMPLATE SPECIALIZATION"
3354 static const char * const apple2_dos_errors[]={
3358 "NO BUFFERS AVAILABLE",
3359 "PROGRAM TOO LARGE",
3362 static void a2controller_crash(apple2_sim_t *sim, int *stepno,
3363 double *next_actiontime)
3365 apple2_state_t *st=sim->st;
3374 if (!sim->controller_data)
3375 sim->controller_data = calloc(sizeof(struct mydata),1);
3376 mine=(struct mydata *) sim->controller_data;
3381 a2_init_memory_active(sim);
3382 sim->dec->powerup = 1000.0;
3384 if (random()%3==0) {
3386 *next_actiontime+=0.4;
3389 else if (random()%4==0) {
3390 st->gr_mode=A2_GR_LORES;
3391 if (random()%3==0) st->gr_mode |= A2_GR_FULL;
3392 *next_actiontime+=0.4;
3395 else if (random()%2==0) {
3396 st->gr_mode=A2_GR_HIRES;
3400 st->gr_mode=A2_GR_HIRES;
3401 *next_actiontime+=0.4;
3407 /* An illegal instruction or a reset caused it to drop into the
3408 assembly language monitor, where you could disassemble code & view
3410 if (random()%3==0) {
3413 int addr=0xd000+random()%0x3000;
3415 "%02X",random()%0xff);
3418 sprintf(sim->printing_buf,
3421 " A=%02X X=%02X Y=%02X S=%02X F=%02X\n"
3424 random()%0xff, random()%0xff,
3425 random()%0xff, random()%0xff,
3427 sim->printing=sim->printing_buf;
3435 *next_actiontime += 2.0 + (random()%1000)*0.0002;
3438 /* Lots of programs had at least their main functionality in
3439 Applesoft Basic, which had a lot of limits (memory, string
3440 length, etc) and would sometimes crash unexpectedly. */
3441 sprintf(sim->printing_buf,
3447 apple2_basic_errors[random() %
3448 (sizeof(apple2_basic_errors)
3450 (1000*(random()%(random()%59+1)) +
3451 100*(random()%(random()%9+1)) +
3452 5*(random()%(random()%199+1)) +
3453 1*(random()%(random()%(random()%2+1)+1))));
3454 sim->printing=sim->printing_buf;
3458 *next_actiontime += 2.0 + (random()%1000)*0.0002;
3463 if (random()%3==0) {
3464 /* This was how you reset the Basic interpreter. The sort of
3465 incantation you'd have on a little piece of paper taped to the
3466 side of your machine */
3467 sim->typing="CALL -1370";
3470 else if (random()%2==0) {
3471 sim->typing="CATALOG\n";
3475 *next_actiontime+=1.0;
3482 *next_actiontime += 0.5;
3489 for (s="APPLE ]["; *s; s++) a2_printc(st,*s);
3492 *next_actiontime+=1.0;
3497 if (random()%50==0) {
3498 sprintf(sim->printing_buf,
3499 "\nDISK VOLUME 254\n\n"
3503 sim->printing=sim->printing_buf;
3506 sprintf(sim->printing_buf,"\n?%s\n]",
3507 apple2_dos_errors[random()%
3508 (sizeof(apple2_dos_errors) /
3510 sim->printing=sim->printing_buf;
3513 *next_actiontime+=1.0;
3517 if (random()%2==0) {
3518 /* This was how you went back to text mode in the monitor */
3519 sim->typing="FB4BG";
3522 *next_actiontime+=1.0;
3533 *next_actiontime+=2.0;
3537 /* This reset things into Basic */
3538 if (random()%2==0) {
3539 sim->typing="FAA6G";
3544 *next_actiontime+=sim->delay;
3549 for (i=0; i<1500; i++) {
3550 a2_poke(st, mine->fillptr, mine->fillbyte);
3552 mine->fillbyte = (mine->fillbyte+1)&0xff;
3554 *next_actiontime += 0.08;
3555 /* When you hit c000, it changed video settings */
3556 if (mine->fillptr>=0xc000) {
3560 /* And it seemed to reset around here, I dunno why */
3561 if (mine->fillptr>=0xcf00) *stepno=130;
3567 case A2CONTROLLER_FREE:
3575 a2_draw (struct bsod_state *bst)
3577 apple2_sim_t *sim = (apple2_sim_t *) bst->closure;
3579 sim = apple2_start (bst->dpy, bst->window, 9999999, a2controller_crash);
3583 if (! apple2_one_frame (sim)) {
3591 a2_free (struct bsod_state *bst)
3593 apple2_sim_t *sim = (apple2_sim_t *) bst->closure;
3595 sim->stepno = A2CONTROLLER_DONE;
3596 a2_draw (bst); /* finish up */
3597 if (bst->closure) abort(); /* should have been freed by now */
3602 static struct bsod_state *
3603 apple2crash (Display *dpy, Window window)
3605 struct bsod_state *bst = make_bsod_state (dpy, window, "apple2", "Apple2");
3606 bst->draw_cb = a2_draw;
3607 bst->free_cb = a2_free;
3612 /* A crash spotted on a cash machine circa 2006, by jwz. I didn't note
3613 what model it was; probably a Tranax Mini-Bank 1000 or similar vintage.
3615 static struct bsod_state *
3616 atm (Display *dpy, Window window)
3618 struct bsod_state *bst = make_bsod_state (dpy, window, "atm", "ATM");
3621 int pix_w = atm_width;
3622 int pix_h = atm_height;
3626 XClearWindow (dpy, window);
3628 pixmap = XCreatePixmapFromBitmapData (dpy, window, (char *) atm_bits,
3629 atm_width, atm_height,
3630 bst->fg, bst->bg, bst->xgwa.depth);
3632 while (pix_w <= bst->xgwa.width * scale &&
3633 pix_h <= bst->xgwa.height * scale)
3635 pixmap = double_pixmap (dpy, bst->gc, bst->xgwa.visual, bst->xgwa.depth,
3636 pixmap, pix_w, pix_h);
3642 x = (bst->xgwa.width - pix_w) / 2;
3643 y = (bst->xgwa.height - pix_h) / 2;
3649 XSetForeground (dpy, bst->gc,
3650 get_pixel_resource (dpy, bst->xgwa.colormap,
3653 for (j = -1; j < pix_w; j += i+1)
3654 XDrawLine (bst->dpy, pixmap, bst->gc, j, 0, j, pix_h);
3655 for (j = -1; j < pix_h; j += i+1)
3656 XDrawLine (bst->dpy, pixmap, bst->gc, 0, j, pix_w, j);
3659 XCopyArea (dpy, pixmap, window, bst->gc, 0, 0, pix_w, pix_h, x, y);
3661 XFreePixmap (dpy, pixmap);
3667 /*****************************************************************************
3668 *****************************************************************************/
3671 static const struct {
3673 struct bsod_state * (*fn) (Display *, Window);
3675 { "Windows", windows_31 },
3676 { "NT", windows_nt },
3677 { "Win2K", windows_other },
3680 { "MacsBug", macsbug },
3685 { "HPPALinux", hppa_linux },
3686 { "SparcLinux", sparc_linux },
3690 { "BlitDamage", blitdamage },
3692 { "Solaris", sparc_solaris },
3693 { "Linux", linux_fsck },
3700 { "Nvidia", nvidia },
3701 { "Apple2", apple2crash },
3703 { "GLaDOS", glados },
3707 struct driver_state {
3712 Bool debug_p, cycle_p;
3713 struct bsod_state *bst;
3718 hack_title (struct driver_state *dst)
3722 XFetchName (dst->bst->dpy, dst->bst->window, &oname);
3723 if (oname && !strncmp (oname, "BSOD: ", 6)) {
3724 char *tail = oname + 4;
3725 char *s = strchr (tail+1, ':');
3728 nname = malloc (strlen (tail) + strlen (dst->name) + 20);
3729 sprintf (nname, "BSOD: %s%s", dst->name, tail);
3730 XStoreName (dst->bst->dpy, dst->bst->window, nname);
3733 # endif /* !HAVE_COCOA */
3737 bsod_init (Display *dpy, Window window)
3739 struct driver_state *dst = (struct driver_state *) calloc (1, sizeof(*dst));
3742 dst->delay = get_integer_resource (dpy, "delay", "Integer");
3743 if (dst->delay < 3) dst->delay = 3;
3745 dst->debug_p = get_boolean_resource (dpy, "debug", "Boolean");
3748 s = get_string_resource(dpy, "doOnly", "DoOnly");
3749 if (s && !strcasecmp (s, "cycle"))
3752 dst->cycle_p = True;
3756 int count = countof(all_modes);
3757 for (dst->only = 0; dst->only < count; dst->only++)
3758 if (!strcasecmp (s, all_modes[dst->only].name))
3760 if (dst->only >= count)
3762 fprintf (stderr, "%s: unknown -only mode: \"%s\"\n", progname, s);
3774 static unsigned long
3775 bsod_draw (Display *dpy, Window window, void *closure)
3777 struct driver_state *dst = (struct driver_state *) closure;
3782 now = time ((time_t *) 0);
3783 time_left = dst->start + dst->delay - now;
3785 if (dst->bst && dst->bst->img_loader) /* still loading */
3787 dst->bst->img_loader =
3788 load_image_async_simple (dst->bst->img_loader, 0, 0, 0, 0, 0);
3792 if (! dst->bst && time_left > 0) /* run completed; wait out the delay */
3795 fprintf (stderr, "%s: %s: %d left\n", progname, dst->name, time_left);
3799 else if (dst->bst) /* sub-mode currently running */
3801 int this_delay = -1;
3804 this_delay = bsod_pop (dst->bst);
3806 /* XSync (dpy, False); slows down char drawing too much on HAVE_COCOA */
3808 if (this_delay == 0)
3809 goto AGAIN; /* no delay, not expired: stay here */
3810 else if (this_delay >= 0)
3811 return this_delay; /* return; time to sleep */
3813 { /* sub-mode run completed or expired */
3815 fprintf (stderr, "%s: %s: done\n", progname, dst->name);
3816 free_bsod_state (dst->bst);
3821 else /* launch a new sub-mode */
3824 dst->which = (dst->which + 1) % countof(all_modes);
3825 else if (dst->only >= 0)
3826 dst->which = dst->only;
3829 int count = countof(all_modes);
3832 for (i = 0; i < 200; i++)
3834 char name[100], class[100];
3835 int new_mode = (random() & 0xFF) % count;
3837 if (i < 100 && new_mode == dst->which)
3840 sprintf (name, "do%s", all_modes[new_mode].name);
3841 sprintf (class, "Do%s", all_modes[new_mode].name);
3843 if (get_boolean_resource (dpy, name, class))
3845 dst->which = new_mode;
3852 fprintf (stderr, "%s: no display modes enabled?\n", progname);
3854 dst->which = dst->only = 0;
3859 fprintf (stderr, "%s: %s: launch\n", progname,
3860 all_modes[dst->which].name);
3862 /* Run the mode setup routine...
3864 if (dst->bst) abort();
3865 dst->name = all_modes[dst->which].name;
3866 dst->bst = all_modes[dst->which].fn (dpy, window);
3867 dst->start = (dst->bst ? time ((time_t *) 0) : 0);
3869 /* Reset the structure run state to the beginning,
3870 and do some sanitization of the cursor position
3871 before the first run.
3876 fprintf (stderr, "%s: %s: queue size: %d (%d)\n", progname,
3877 dst->name, dst->bst->pos, dst->bst->queue_size);
3881 dst->bst->x = dst->bst->current_left = dst->bst->left_margin;
3883 if (dst->bst->y < dst->bst->top_margin + dst->bst->font->ascent)
3884 dst->bst->y = dst->bst->top_margin + dst->bst->font->ascent;
3893 bsod_reshape (Display *dpy, Window window, void *closure,
3894 unsigned int w, unsigned int h)
3896 struct driver_state *dst = (struct driver_state *) closure;
3899 w == dst->bst->xgwa.width &&
3900 h == dst->bst->xgwa.height)
3904 fprintf (stderr, "%s: %s: reshape reset\n", progname, dst->name);
3906 /* just pick a new mode and restart when the window is resized. */
3908 free_bsod_state (dst->bst);
3912 XClearWindow (dpy, window);
3917 bsod_event (Display *dpy, Window window, void *closure, XEvent *event)
3919 struct driver_state *dst = (struct driver_state *) closure;
3920 Bool reset_p = False;
3922 /* pick a new mode and restart when mouse clicked, or certain keys typed. */
3924 if (event->type == ButtonPress)
3926 else if (event->type == KeyPress)
3930 XLookupString (&event->xkey, &c, 1, &keysym, 0);
3931 if (c == ' ' || c == '\t' || c == '\r' || c == '\n')
3938 fprintf (stderr, "%s: %s: manual reset\n", progname, dst->name);
3940 free_bsod_state (dst->bst);
3944 XClearWindow (dpy, window);
3953 bsod_free (Display *dpy, Window window, void *closure)
3955 struct driver_state *dst = (struct driver_state *) closure;
3957 free_bsod_state (dst->bst);
3962 static const char *bsod_defaults [] = {
3976 "*doAtari: False", /* boring */
3977 "*doBSD: False", /* boring */
3979 "*doSparcLinux: False", /* boring */
3980 "*doHPPALinux: True",
3981 "*doBlitDamage: True",
3996 "*font2: -*-courier-bold-r-*-*-*-120-*-*-m-*-*-*",
3997 "*bigFont: -*-courier-bold-r-*-*-*-180-*-*-m-*-*-*",
3998 "*bigFont2: -*-courier-bold-r-*-*-*-180-*-*-m-*-*-*",
4000 ".foreground: White",
4001 ".background: Black",
4003 ".windows.foreground: White",
4004 ".windows.background: #0000AA", /* EGA color 0x01. */
4006 ".windowslh.foreground: White",
4007 ".windowslh.background: #AA0000", /* EGA color 0x04. */
4008 ".windowslh.background2: #AAAAAA", /* EGA color 0x07. */
4010 ".glaDOS.foreground: White",
4011 ".glaDOS.background: #0000AA", /* EGA color 0x01. */
4013 ".amiga.foreground: #FF0000",
4014 ".amiga.background: Black",
4015 ".amiga.background2: White",
4017 ".mac.foreground: #BBFFFF",
4018 ".mac.background: Black",
4020 ".atari.foreground: Black",
4021 ".atari.background: White",
4023 ".macsbug.font: -*-courier-medium-r-*-*-*-80-*-*-m-*-*-*",
4024 ".macsbug.bigFont: -*-courier-bold-r-*-*-*-140-*-*-m-*-*-*",
4025 ".macsbug.foreground: Black",
4026 ".macsbug.background: White",
4027 ".macsbug.borderColor: #AAAAAA",
4029 ".mac1.foreground: Black",
4030 ".mac1.background: White",
4032 ".macx.foreground: White",
4033 ".macx.textForeground: White",
4034 ".macx.textBackground: Black",
4035 ".macx.background: #888888",
4037 ".sco.font: -*-courier-bold-r-*-*-*-140-*-*-m-*-*-*",
4038 ".sco.foreground: White",
4039 ".sco.background: Black",
4041 ".hvx.font: -*-courier-bold-r-*-*-*-140-*-*-m-*-*-*",
4042 ".hvx.foreground: White",
4043 ".hvx.background: Black",
4045 ".linux.foreground: White",
4046 ".linux.background: Black",
4048 ".hppalinux.bigFont: -*-courier-bold-r-*-*-*-140-*-*-m-*-*-*",
4049 ".hppalinux.foreground: White",
4050 ".hppalinux.background: Black",
4052 ".sparclinux.bigFont: -*-courier-bold-r-*-*-*-140-*-*-m-*-*-*",
4053 ".sparclinux.foreground: White",
4054 ".sparclinux.background: Black",
4057 ".bsd.bigFont: -sun-console-medium-r-*-*-22-*-*-*-m-*-*-*",
4058 ".bsd.bigFont2: -*-courier-bold-r-*-*-*-140-*-*-m-*-*-*",
4059 ".bsd.foreground: #c0c0c0",
4060 ".bsd.background: Black",
4062 ".solaris.font: -sun-gallant-*-*-*-*-19-*-*-*-*-120-*-*",
4063 ".solaris.foreground: Black",
4064 ".solaris.background: White",
4066 ".hpux.bigFont: -*-courier-bold-r-*-*-*-140-*-*-m-*-*-*",
4067 ".hpux.foreground: White",
4068 ".hpux.background: Black",
4070 ".os390.bigFont: -*-courier-bold-r-*-*-*-140-*-*-m-*-*-*",
4071 ".os390.background: Black",
4072 ".os390.foreground: Red",
4074 ".tru64.bigFont: -*-courier-bold-r-*-*-*-140-*-*-m-*-*-*",
4075 ".tru64.foreground: White",
4076 ".tru64.background: #0000AA", /* EGA color 0x01. */
4078 ".vms.bigFont: -*-courier-bold-r-*-*-*-140-*-*-m-*-*-*",
4079 ".vms.foreground: White",
4080 ".vms.background: Black",
4082 ".msdos.bigFont: -*-courier-bold-r-*-*-*-140-*-*-m-*-*-*",
4083 ".msdos.foreground: White",
4084 ".msdos.background: Black",
4086 ".os2.foreground: White",
4087 ".os2.background: Black",
4089 ".atm.foreground: Black",
4090 ".atm.background: #FF6600",
4092 "*dontClearRoot: True",
4096 #ifdef HAVE_XSHM_EXTENSION
4101 "*font: Courier-Bold 9",
4102 ".amiga.font: Courier-Bold 12",
4103 ".macsbug.font: Courier-Bold 5",
4104 ".sco.font: Courier-Bold 9",
4105 ".hvx.font: Courier-Bold 9",
4106 ".bsd.font: Courier-Bold 9",
4107 ".solaris.font: Courier-Bold 6",
4113 static const XrmOptionDescRec bsod_options [] = {
4114 { "-delay", ".delay", XrmoptionSepArg, 0 },
4115 { "-only", ".doOnly", XrmoptionSepArg, 0 },
4116 { "-debug", ".debug", XrmoptionNoArg, "True" },
4117 { "-windows", ".doWindows", XrmoptionNoArg, "True" },
4118 { "-no-windows", ".doWindows", XrmoptionNoArg, "False" },
4119 { "-nt", ".doNT", XrmoptionNoArg, "True" },
4120 { "-no-nt", ".doNT", XrmoptionNoArg, "False" },
4121 { "-2k", ".doWin2K", XrmoptionNoArg, "True" },
4122 { "-no-2k", ".doWin2K", XrmoptionNoArg, "False" },
4123 { "-amiga", ".doAmiga", XrmoptionNoArg, "True" },
4124 { "-no-amiga", ".doAmiga", XrmoptionNoArg, "False" },
4125 { "-mac", ".doMac", XrmoptionNoArg, "True" },
4126 { "-no-mac", ".doMac", XrmoptionNoArg, "False" },
4127 { "-mac1", ".doMac1", XrmoptionNoArg, "True" },
4128 { "-no-mac1", ".doMac1", XrmoptionNoArg, "False" },
4129 { "-macx", ".doMacX", XrmoptionNoArg, "True" },
4130 { "-no-macx", ".doMacX", XrmoptionNoArg, "False" },
4131 { "-atari", ".doAtari", XrmoptionNoArg, "True" },
4132 { "-no-atari", ".doAtari", XrmoptionNoArg, "False" },
4133 { "-macsbug", ".doMacsBug", XrmoptionNoArg, "True" },
4134 { "-no-macsbug", ".doMacsBug", XrmoptionNoArg, "False" },
4135 { "-apple2", ".doApple2", XrmoptionNoArg, "True" },
4136 { "-no-apple2", ".doApple2", XrmoptionNoArg, "False" },
4137 { "-sco", ".doSCO", XrmoptionNoArg, "True" },
4138 { "-no-sco", ".doSCO", XrmoptionNoArg, "False" },
4139 { "-hvx", ".doHVX", XrmoptionNoArg, "True" },
4140 { "-no-hvx", ".doHVX", XrmoptionNoArg, "False" },
4141 { "-bsd", ".doBSD", XrmoptionNoArg, "True" },
4142 { "-no-bsd", ".doBSD", XrmoptionNoArg, "False" },
4143 { "-linux", ".doLinux", XrmoptionNoArg, "True" },
4144 { "-no-linux", ".doLinux", XrmoptionNoArg, "False" },
4145 { "-hppalinux", ".doHPPALinux", XrmoptionNoArg, "True" },
4146 { "-no-hppalinux", ".doHPPALinux", XrmoptionNoArg, "False" },
4147 { "-sparclinux", ".doSparcLinux", XrmoptionNoArg, "True" },
4148 { "-no-sparclinux", ".doSparcLinux", XrmoptionNoArg, "False" },
4149 { "-blitdamage", ".doBlitDamage", XrmoptionNoArg, "True" },
4150 { "-no-blitdamage", ".doBlitDamage", XrmoptionNoArg, "False" },
4151 { "-nvidia", ".doNvidia", XrmoptionNoArg, "True" },
4152 { "-no-nvidia", ".doNvidia", XrmoptionNoArg, "False" },
4153 { "-solaris", ".doSolaris", XrmoptionNoArg, "True" },
4154 { "-no-solaris", ".doSolaris", XrmoptionNoArg, "False" },
4155 { "-hpux", ".doHPUX", XrmoptionNoArg, "True" },
4156 { "-no-hpux", ".doHPUX", XrmoptionNoArg, "False" },
4157 { "-os390", ".doOS390", XrmoptionNoArg, "True" },
4158 { "-no-os390", ".doOS390", XrmoptionNoArg, "False" },
4159 { "-tru64", ".doHPUX", XrmoptionNoArg, "True" },
4160 { "-no-tru64", ".doTru64", XrmoptionNoArg, "False" },
4161 { "-vms", ".doVMS", XrmoptionNoArg, "True" },
4162 { "-no-vms", ".doVMS", XrmoptionNoArg, "False" },
4163 { "-msdos", ".doMSDOS", XrmoptionNoArg, "True" },
4164 { "-no-msdos", ".doMSDOS", XrmoptionNoArg, "False" },
4165 { "-os2", ".doOS2", XrmoptionNoArg, "True" },
4166 { "-no-os2", ".doOS2", XrmoptionNoArg, "False" },
4167 { "-atm", ".doATM", XrmoptionNoArg, "True" },
4168 { "-no-atm", ".doATM", XrmoptionNoArg, "False" },
4169 { "-glados", ".doGLaDOS", XrmoptionNoArg, "True" },
4170 { "-no-glados", ".doGLaDOS", XrmoptionNoArg, "False" },
4176 XSCREENSAVER_MODULE ("BSOD", bsod)