src/Unix/paranoia.cpp

/*
 *  paranoia.cpp - Check undocumented features of the underlying
 *                 kernel that SheepShaver relies upon
 *
 *  SheepShaver (C) 1997-2008 Christian Bauer and Marc Hellwig
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

/*
 * TODO
 * - Check for nested signal handlers vs. sigaltstack()
 */

#include <unistd.h>
#include <stdio.h>
#include <signal.h>
#include <errno.h>
#include <pthread.h>
#include <sys/types.h>
#include <sys/ucontext.h>

#include "sysdeps.h"
#include "sigregs.h"
#include "main.h"
#include "user_strings.h"

#define DEBUG 1
#include "debug.h"


// Constants
const uint32 SIG_STACK_SIZE = 0x10000;          // Size of signal stack

// Prototypes
extern "C" void *get_sp(void);
extern "C" void *get_r2(void);
extern "C" void set_r2(void *);
extern "C" void *get_r13(void);
extern "C" void set_r13(void *);
extern void paranoia_check(void);
static void sigusr2_handler(int sig, siginfo_t *sip, void *scp);
static void *tick_func(void *);
static void *emul_func(void *);

// Global variables
static void *sig_stack = NULL;

static int err = 0;
static void *sig_sp = NULL;
static void *sig_r5 = NULL;
static int sig_sc_signal = 0;
static void *sig_sc_regs = NULL;
static uint32 sig_r2 = 0;

static pthread_t tick_thread;
static pthread_t emul_thread;
static volatile uint32 tick_thread_ready = 0;
static volatile uint32 emul_thread_regs[32] = { 0, };
static volatile uint32 &emul_thread_ready = emul_thread_regs[0];


void paranoia_check(void)
{
        char str[256];

        printf("Paranoia checks...\n");

        // Create and install stack for signal handler
        sig_stack = malloc(SIG_STACK_SIZE);
        if (sig_stack == NULL) {
                ErrorAlert(GetString(STR_NOT_ENOUGH_MEMORY_ERR));
                exit(1);
        }

        struct sigaltstack old_stack;
        struct sigaltstack new_stack;
        new_stack.ss_sp = (char *)sig_stack;
        new_stack.ss_flags = 0;
        new_stack.ss_size = SIG_STACK_SIZE;
        if (sigaltstack(&new_stack, &old_stack) < 0) {
                sprintf(str, GetString(STR_SIGALTSTACK_ERR), strerror(errno));
                ErrorAlert(str);
                exit(1);
        }

        // Install SIGUSR2 signal handler
        static struct sigaction old_action;
        static struct sigaction sigusr2_action;
        sigemptyset(&sigusr2_action.sa_mask);
        sigusr2_action.sa_sigaction = sigusr2_handler;
        sigusr2_action.sa_flags = SA_SIGINFO | SA_ONSTACK | SA_RESTART;
        if (sigaction(SIGUSR2, &sigusr2_action, &old_action) < 0) {
                sprintf(str, GetString(STR_SIG_INSTALL_ERR), "SIGUSR2", strerror(errno));
                ErrorAlert(str);
                exit(1);
        }

        // Start tick thread that will trigger only one SIGUSR2
        pthread_create(&tick_thread, NULL, tick_func, NULL);

        // Get my thread ID and execute MacOS thread function
        emul_thread = pthread_self();
        emul_func(NULL);

        // Check error code
        switch (err) {
                case 1:
                        printf("FATAL: sigaltstack() doesn't seem to work (sp in signal handler was %p, expected %p..%p)\n", sig_sp, sig_stack, (uintptr)sig_stack + SIG_STACK_SIZE);
                        break;
                case 2:
                        printf("FATAL: r5 in signal handler (%p) doesn't point to stack\n", sig_r5);
                        break;
                case 3:
                        printf("FATAL: machine registers in signal handler (%p) doesn't point to stack\n", sig_sc_regs);
                        break;
                case 4:
                        printf("FATAL: register file in signal handler is corrupted\n");
                        break;
        }
        if (err) {
                printf("Maybe you need a different kernel?\n");
                exit(1);
        }

        // Clean up
        printf("...passed\n");
        sigaction(SIGUSR2, &old_action, NULL);
        sigaltstack(&old_stack, NULL);
        free(sig_stack);
}

static void *tick_func(void *)
{
        tick_thread_ready = true;

        // Wait for emul thread to initialize
        D(bug("[tick_thread] waiting for emul thread to initialize\n"));
        while (!emul_thread_ready)
                usleep(0);

        // Trigger interrupt and terminate
        D(bug("[tick_thread] trigger interrupt\n"));
        pthread_kill(emul_thread, SIGUSR2);
        return NULL;
}

static void *emul_func(void *)
{
        // Wait for tick thread to initialize
        D(bug("[emul_thread] waiting for tick thread to initialize\n"));
        while (!tick_thread_ready)
                usleep(0);

        // Fill in register and wait for an interrupt from the tick thread
        D(bug("[emul_thread] filling in registers and waiting for interrupt\n"));
#if defined(__APPLE__) && defined(__MACH__)
#define REG(n) "r" #n
#else
#define REG(n) #n
#endif
        asm volatile ("stw  " REG(2) ",2*4(%0)\n"
                                  "mr   " REG(2) ",%0\n"
#define SAVE_REG(n) \
                                  "stw  " REG(n) "," #n "*4(" REG(2) ")\n" \
                                  "addi " REG(n) "," REG(2) ","#n"\n"
                                  SAVE_REG(1)
                                  SAVE_REG(3)
                                  SAVE_REG(4)
                                  SAVE_REG(5)
                                  SAVE_REG(6)
                                  SAVE_REG(7)
                                  SAVE_REG(8)
                                  SAVE_REG(9)
                                  SAVE_REG(10)
                                  SAVE_REG(11)
                                  SAVE_REG(12)
                                  SAVE_REG(13)
                                  SAVE_REG(14)
                                  SAVE_REG(15)
                                  SAVE_REG(16)
                                  SAVE_REG(17)
                                  SAVE_REG(18)
                                  SAVE_REG(19)
                                  SAVE_REG(20)
                                  SAVE_REG(21)
                                  SAVE_REG(22)
                                  SAVE_REG(23)
                                  SAVE_REG(24)
                                  SAVE_REG(25)
                                  SAVE_REG(26)
                                  SAVE_REG(27)
                                  SAVE_REG(28)
                                  SAVE_REG(29)
                                  SAVE_REG(30)
                                  SAVE_REG(31)
#undef SAVE_REG
                                  "   li   " REG(0) ",1\n"
                                  "   stw  " REG(0) ",0(" REG(2) ")\n" // regs[0] == emul_thread_ready
                                  "0: lwz  " REG(0) ",0(" REG(2) ")\n"
                                  "   cmpi 0," REG(0) ",0\n"
                                  "   bne+ 0b\n"
#define LOAD_REG(n) \
                                 "lwz  " REG(n) "," #n "*4(" REG(2) ")\n"
                                  LOAD_REG(1)
                                  LOAD_REG(3)
                                  LOAD_REG(4)
                                  LOAD_REG(5)
                                  LOAD_REG(6)
                                  LOAD_REG(7)
                                  LOAD_REG(8)
                                  LOAD_REG(9)
                                  LOAD_REG(10)
                                  LOAD_REG(11)
                                  LOAD_REG(12)
                                  LOAD_REG(13)
                                  LOAD_REG(14)
                                  LOAD_REG(15)
                                  LOAD_REG(16)
                                  LOAD_REG(17)
                                  LOAD_REG(18)
                                  LOAD_REG(19)
                                  LOAD_REG(20)
                                  LOAD_REG(21)
                                  LOAD_REG(22)
                                  LOAD_REG(23)
                                  LOAD_REG(24)
                                  LOAD_REG(25)
                                  LOAD_REG(26)
                                  LOAD_REG(27)
                                  LOAD_REG(28)
                                  LOAD_REG(29)
                                  LOAD_REG(30)
                                  LOAD_REG(31)
                                  LOAD_REG(2)
#undef LOAD_REG
                : :  "r" ((uintptr)&emul_thread_regs[0]) : "r0");
#undef REG
}


void sigusr2_handler(int sig, siginfo_t *sip, void *scp)
{
        machine_regs *r = MACHINE_REGISTERS(scp);

#ifdef SYSTEM_CLOBBERS_R2
        // Restore pointer to Thread Local Storage
        set_r2(TOC);
#endif

#ifdef SYSTEM_CLOBBERS_R13
        // Restore pointer to .sdata section
        set_r13(R13);
#endif

        ucontext_t *ucp = (ucontext_t *)scp;
        D(bug("SIGUSR2 caught\n"));

        // Check whether sigaltstack works
        sig_sp = get_sp();
        if (sig_sp < sig_stack || sig_sp >= ((uint8 *)sig_stack + SIG_STACK_SIZE)) {
                err = 1;
                goto ret;
        }

        // Check whether r5 points to info on the stack
        sig_r5 = ucp;
        if (sig_r5 < sig_stack || sig_r5 >= ((uint8 *)sig_stack + SIG_STACK_SIZE)) {
                err = 2;
                goto ret;
        }

        // Check whether context regs points to info on the stack
        sig_sc_regs = &r->gpr(0);
        if (sig_sc_regs < sig_stack || sig_sc_regs >= ((uint8 *)sig_stack + SIG_STACK_SIZE)) {
                err = 3;
                goto ret;
        }

        // Check whether registers still hold the values we set them to
        for (int n = 0; n < 32; n++) {
                uint32 expected = (uintptr)&emul_thread_regs[0];
                if (n == 0)
                        expected = 1;
                else if (n != 2)
                        expected += n;
                if (r->gpr(n) != expected) {
                        D(bug("Register corruption: r%d was %08x, expected %08x\n", n, r->gpr(n), expected));
                        err = 4;
                        goto ret;
                }
        }

  ret:
        // Tell emul_func() to exit
        emul_thread_ready = false;
}


#ifdef TEST
void *TOC;
void *R13;

extern "C" void EmulOp(void *r, uint32 pc, int selector);
void EmulOp(void *r, uint32 pc, int selector)
{
}

extern "C" void check_load_invoc(uint32 type, int16 id, uint32 h);
void check_load_invoc(uint32 type, int16 id, uint32 h)
{
}

void ErrorAlert(const char *text)
{
        printf(GetString(STR_SHELL_ERROR_PREFIX), text);
}

int main(void)
{
#ifdef SYSTEM_CLOBBERS_R2
        // Get TOC pointer
        TOC = get_r2();
#endif

#ifdef SYSTEM_CLOBBERS_R13
        // Get r13 register
        R13 = get_r13();
#endif

        // Check some things
        paranoia_check();
}
#endif
Revision:	1.4
Committed:	2008-01-01T09:47:38Z (16 years, 10 months ago) by gbeauche
Branch:	MAIN
Changes since 1.3:	+1 -1 lines
Log Message:	Happy New Year!
#	User	Rev	Content
1	gbeauche	1.1	/*
2			* paranoia.cpp - Check undocumented features of the underlying
3			* kernel that SheepShaver relies upon
4			*
5	gbeauche	1.4	* SheepShaver (C) 1997-2008 Christian Bauer and Marc Hellwig
6	gbeauche	1.1	*
7			* This program is free software; you can redistribute it and/or modify
8			* it under the terms of the GNU General Public License as published by
9			* the Free Software Foundation; either version 2 of the License, or
10			* (at your option) any later version.
11			*
12			* This program is distributed in the hope that it will be useful,
13			* but WITHOUT ANY WARRANTY; without even the implied warranty of
14			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15			* GNU General Public License for more details.
16			*
17			* You should have received a copy of the GNU General Public License
18			* along with this program; if not, write to the Free Software
19			* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20			*/
21
22			/*
23			* TODO
24			* - Check for nested signal handlers vs. sigaltstack()
25			*/
26
27			#include <unistd.h>
28			#include <stdio.h>
29			#include <signal.h>
30			#include <errno.h>
31			#include <pthread.h>
32			#include <sys/types.h>
33			#include <sys/ucontext.h>
34
35			#include "sysdeps.h"
36			#include "sigregs.h"
37			#include "main.h"
38			#include "user_strings.h"
39
40			#define DEBUG 1
41			#include "debug.h"
42
43
44			// Constants
45			const uint32 SIG_STACK_SIZE = 0x10000; // Size of signal stack
46
47			// Prototypes
48			extern "C" void *get_sp(void);
49			extern "C" void *get_r2(void);
50			extern "C" void set_r2(void *);
51			extern "C" void *get_r13(void);
52			extern "C" void set_r13(void *);
53			extern void paranoia_check(void);
54	gbeauche	1.2	static void sigusr2_handler(int sig, siginfo_t sip, void scp);
55	gbeauche	1.1	static void tick_func(void );
56			static void emul_func(void );
57
58			// Global variables
59			static void *sig_stack = NULL;
60
61			static int err = 0;
62			static void *sig_sp = NULL;
63			static void *sig_r5 = NULL;
64			static int sig_sc_signal = 0;
65			static void *sig_sc_regs = NULL;
66			static uint32 sig_r2 = 0;
67
68			static pthread_t tick_thread;
69			static pthread_t emul_thread;
70			static volatile uint32 tick_thread_ready = 0;
71			static volatile uint32 emul_thread_regs[32] = { 0, };
72			static volatile uint32 &emul_thread_ready = emul_thread_regs[0];
73
74
75			void paranoia_check(void)
76			{
77			char str[256];
78
79			printf("Paranoia checks...\n");
80
81			// Create and install stack for signal handler
82			sig_stack = malloc(SIG_STACK_SIZE);
83			if (sig_stack == NULL) {
84			ErrorAlert(GetString(STR_NOT_ENOUGH_MEMORY_ERR));
85			exit(1);
86			}
87
88			struct sigaltstack old_stack;
89			struct sigaltstack new_stack;
90			new_stack.ss_sp = (char *)sig_stack;
91			new_stack.ss_flags = 0;
92			new_stack.ss_size = SIG_STACK_SIZE;
93			if (sigaltstack(&new_stack, &old_stack) < 0) {
94			sprintf(str, GetString(STR_SIGALTSTACK_ERR), strerror(errno));
95			ErrorAlert(str);
96			exit(1);
97			}
98
99			// Install SIGUSR2 signal handler
100			static struct sigaction old_action;
101			static struct sigaction sigusr2_action;
102			sigemptyset(&sigusr2_action.sa_mask);
103			sigusr2_action.sa_sigaction = sigusr2_handler;
104			sigusr2_action.sa_flags = SA_SIGINFO \| SA_ONSTACK \| SA_RESTART;
105			if (sigaction(SIGUSR2, &sigusr2_action, &old_action) < 0) {
106	gbeauche	1.3	sprintf(str, GetString(STR_SIG_INSTALL_ERR), "SIGUSR2", strerror(errno));
107	gbeauche	1.1	ErrorAlert(str);
108			exit(1);
109			}
110
111			// Start tick thread that will trigger only one SIGUSR2
112			pthread_create(&tick_thread, NULL, tick_func, NULL);
113
114			// Get my thread ID and execute MacOS thread function
115			emul_thread = pthread_self();
116			emul_func(NULL);
117
118			// Check error code
119			switch (err) {
120			case 1:
121			printf("FATAL: sigaltstack() doesn't seem to work (sp in signal handler was %p, expected %p..%p)\n", sig_sp, sig_stack, (uintptr)sig_stack + SIG_STACK_SIZE);
122			break;
123			case 2:
124			printf("FATAL: r5 in signal handler (%p) doesn't point to stack\n", sig_r5);
125			break;
126			case 3:
127			printf("FATAL: machine registers in signal handler (%p) doesn't point to stack\n", sig_sc_regs);
128			break;
129			case 4:
130			printf("FATAL: register file in signal handler is corrupted\n");
131			break;
132			}
133			if (err) {
134			printf("Maybe you need a different kernel?\n");
135			exit(1);
136			}
137
138			// Clean up
139			printf("...passed\n");
140			sigaction(SIGUSR2, &old_action, NULL);
141			sigaltstack(&old_stack, NULL);
142			free(sig_stack);
143			}
144
145			static void tick_func(void )
146			{
147			tick_thread_ready = true;
148
149			// Wait for emul thread to initialize
150			D(bug("[tick_thread] waiting for emul thread to initialize\n"));
151			while (!emul_thread_ready)
152			usleep(0);
153
154			// Trigger interrupt and terminate
155			D(bug("[tick_thread] trigger interrupt\n"));
156			pthread_kill(emul_thread, SIGUSR2);
157			return NULL;
158			}
159
160			static void emul_func(void )
161			{
162			// Wait for tick thread to initialize
163			D(bug("[emul_thread] waiting for tick thread to initialize\n"));
164			while (!tick_thread_ready)
165			usleep(0);
166
167			// Fill in register and wait for an interrupt from the tick thread
168			D(bug("[emul_thread] filling in registers and waiting for interrupt\n"));
169			#if defined(__APPLE__) && defined(__MACH__)
170			#define REG(n) "r" #n
171			#else
172			#define REG(n) #n
173			#endif
174			asm volatile ("stw " REG(2) ",2*4(%0)\n"
175			"mr " REG(2) ",%0\n"
176			#define SAVE_REG(n) \
177			"stw " REG(n) "," #n "*4(" REG(2) ")\n" \
178			"addi " REG(n) "," REG(2) ","#n"\n"
179			SAVE_REG(1)
180			SAVE_REG(3)
181			SAVE_REG(4)
182			SAVE_REG(5)
183			SAVE_REG(6)
184			SAVE_REG(7)
185			SAVE_REG(8)
186			SAVE_REG(9)
187			SAVE_REG(10)
188			SAVE_REG(11)
189			SAVE_REG(12)
190			SAVE_REG(13)
191			SAVE_REG(14)
192			SAVE_REG(15)
193			SAVE_REG(16)
194			SAVE_REG(17)
195			SAVE_REG(18)
196			SAVE_REG(19)
197			SAVE_REG(20)
198			SAVE_REG(21)
199			SAVE_REG(22)
200			SAVE_REG(23)
201			SAVE_REG(24)
202			SAVE_REG(25)
203			SAVE_REG(26)
204			SAVE_REG(27)
205			SAVE_REG(28)
206			SAVE_REG(29)
207			SAVE_REG(30)
208			SAVE_REG(31)
209			#undef SAVE_REG
210			" li " REG(0) ",1\n"
211			" stw " REG(0) ",0(" REG(2) ")\n" // regs[0] == emul_thread_ready
212			"0: lwz " REG(0) ",0(" REG(2) ")\n"
213			" cmpi 0," REG(0) ",0\n"
214			" bne+ 0b\n"
215			#define LOAD_REG(n) \
216			"lwz " REG(n) "," #n "*4(" REG(2) ")\n"
217			LOAD_REG(1)
218			LOAD_REG(3)
219			LOAD_REG(4)
220			LOAD_REG(5)
221			LOAD_REG(6)
222			LOAD_REG(7)
223			LOAD_REG(8)
224			LOAD_REG(9)
225			LOAD_REG(10)
226			LOAD_REG(11)
227			LOAD_REG(12)
228			LOAD_REG(13)
229			LOAD_REG(14)
230			LOAD_REG(15)
231			LOAD_REG(16)
232			LOAD_REG(17)
233			LOAD_REG(18)
234			LOAD_REG(19)
235			LOAD_REG(20)
236			LOAD_REG(21)
237			LOAD_REG(22)
238			LOAD_REG(23)
239			LOAD_REG(24)
240			LOAD_REG(25)
241			LOAD_REG(26)
242			LOAD_REG(27)
243			LOAD_REG(28)
244			LOAD_REG(29)
245			LOAD_REG(30)
246			LOAD_REG(31)
247			LOAD_REG(2)
248			#undef LOAD_REG
249			: : "r" ((uintptr)&emul_thread_regs[0]) : "r0");
250			#undef REG
251			}
252
253
254			void sigusr2_handler(int sig, siginfo_t sip, void scp)
255			{
256			machine_regs *r = MACHINE_REGISTERS(scp);
257
258			#ifdef SYSTEM_CLOBBERS_R2
259			// Restore pointer to Thread Local Storage
260			set_r2(TOC);
261			#endif
262
263			#ifdef SYSTEM_CLOBBERS_R13
264			// Restore pointer to .sdata section
265			set_r13(R13);
266			#endif
267
268			ucontext_t ucp = (ucontext_t )scp;
269			D(bug("SIGUSR2 caught\n"));
270
271			// Check whether sigaltstack works
272			sig_sp = get_sp();
273			if (sig_sp < sig_stack \|\| sig_sp >= ((uint8 *)sig_stack + SIG_STACK_SIZE)) {
274			err = 1;
275			goto ret;
276			}
277
278			// Check whether r5 points to info on the stack
279			sig_r5 = ucp;
280			if (sig_r5 < sig_stack \|\| sig_r5 >= ((uint8 *)sig_stack + SIG_STACK_SIZE)) {
281			err = 2;
282			goto ret;
283			}
284
285			// Check whether context regs points to info on the stack
286			sig_sc_regs = &r->gpr(0);
287			if (sig_sc_regs < sig_stack \|\| sig_sc_regs >= ((uint8 *)sig_stack + SIG_STACK_SIZE)) {
288			err = 3;
289			goto ret;
290			}
291
292			// Check whether registers still hold the values we set them to
293			for (int n = 0; n < 32; n++) {
294			uint32 expected = (uintptr)&emul_thread_regs[0];
295			if (n == 0)
296			expected = 1;
297			else if (n != 2)
298			expected += n;
299			if (r->gpr(n) != expected) {
300			D(bug("Register corruption: r%d was %08x, expected %08x\n", n, r->gpr(n), expected));
301			err = 4;
302			goto ret;
303			}
304			}
305
306			ret:
307			// Tell emul_func() to exit
308			emul_thread_ready = false;
309			}
310
311
312			#ifdef TEST
313			void *TOC;
314			void *R13;
315
316			extern "C" void EmulOp(void *r, uint32 pc, int selector);
317			void EmulOp(void *r, uint32 pc, int selector)
318			{
319			}
320
321			extern "C" void check_load_invoc(uint32 type, int16 id, uint32 h);
322			void check_load_invoc(uint32 type, int16 id, uint32 h)
323			{
324			}
325
326			void ErrorAlert(const char *text)
327			{
328			printf(GetString(STR_SHELL_ERROR_PREFIX), text);
329			}
330
331			int main(void)
332			{
333			#ifdef SYSTEM_CLOBBERS_R2
334			// Get TOC pointer
335			TOC = get_r2();
336			#endif
337
338			#ifdef SYSTEM_CLOBBERS_R13
339			// Get r13 register
340			R13 = get_r13();
341			#endif
342
343			// Check some things
344			paranoia_check();
345			}
346			#endif