src/useremul/useremul.c

/*
 *  Copyright (C) 2004-2007  Anders Gavare.  All rights reserved.
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions are met:
 *
 *  1. Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 *  2. Redistributions in binary form must reproduce the above copyright  
 *     notice, this list of conditions and the following disclaimer in the 
 *     documentation and/or other materials provided with the distribution.
 *  3. The name of the author may not be used to endorse or promote products
 *     derived from this software without specific prior written permission.
 *
 *  THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 *  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 *  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 *  ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE   
 *  FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 *  DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 *  OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 *  HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 *  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 *  OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 *  SUCH DAMAGE.
 *
 *
 *  $Id: useremul.c,v 1.6 2007/06/17 23:32:20 debug Exp $
 *
 *  COMMENT: Userland (syscall) emulation framework
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "cpu.h"
#include "machine.h"
#include "misc.h"
#include "useremul.h"


struct syscall_emul {
        char            *name;
        int             arch;
        char            *cpu_name;
        void            (*f)(struct cpu *, uint32_t);
        void            (*setup)(struct cpu *, int, char **);

        struct syscall_emul *next;
};

static struct syscall_emul *first_syscall_emul;

/*  Max length of strings passed using syscall parameters:  */
#define MAXLEN          8192


/*
 *  useremul_setup():
 *
 *  Set up an emulated environment suitable for running userland code. The
 *  program should already have been loaded into memory when this function
 *  is called.
 */
void useremul_setup(struct cpu *cpu, int argc, char **host_argv)
{
        struct syscall_emul *sep;

        sep = first_syscall_emul;

        while (sep != NULL) {
                if (strcasecmp(cpu->machine->userland_emul, sep->name) == 0) {
                        sep->setup(cpu, argc, host_argv);
                        return;
                }
                sep = sep->next;
        }

        fatal("useremul_setup(): internal error, unimplemented emulation?\n");
        exit(1);
}


/*
 *  useremul_syscall():
 *
 *  Handle userland syscalls.  This function is called whenever a userland
 *  process runs a 'syscall' instruction.  The code argument is the code
 *  embedded into the syscall instruction, if any.  (This 'code' value is not
 *  necessarily used by specific emulations.)
 */
void useremul_syscall(struct cpu *cpu, uint32_t code)
{
        if (cpu->useremul_syscall == NULL) {
                fatal("useremul_syscall(): cpu->useremul_syscall == NULL\n");
        } else
                cpu->useremul_syscall(cpu, code);
}


/*
 *  useremul_name_to_useremul():
 *
 *  Example:
 *     Input:  name = "netbsd/pmax"
 *     Output: sets *arch = ARCH_MIPS, *machine_name = "NetBSD/pmax",
 *             and *cpu_name = "R3000".
 */
void useremul_name_to_useremul(struct cpu *cpu, char *name, int *arch,
        char **machine_name, char **cpu_name)
{
        struct syscall_emul *sep;

        sep = first_syscall_emul;

        while (sep != NULL) {
                if (strcasecmp(name, sep->name) == 0) {
                        if (cpu_family_ptr_by_number(sep->arch) == NULL) {
                                printf("\nSupport for the CPU family needed"
                                    " for '%s' userland emulation was not"
                                    " enabled at configuration time.\n",
                                    sep->name);
                                exit(1);
                        }

                        if (cpu != NULL)
                                cpu->useremul_syscall = sep->f;

                        if (arch != NULL)
                                *arch = sep->arch;

                        if (machine_name != NULL)
                                CHECK_ALLOCATION((*machine_name) =
                                    strdup(sep->name));

                        if (cpu_name != NULL)
                                CHECK_ALLOCATION((*cpu_name) =
                                    strdup(sep->cpu_name));

                        return;
                }

                sep = sep->next;
        }

        fatal("Unknown userland emulation '%s'\n", name);
        exit(1);
}


/*
 *  add_useremul():
 *
 *  For internal use, from useremul_init() only. Adds an emulation mode.
 */
static void add_useremul(char *name, int arch, char *cpu_name,
        void (*f)(struct cpu *, uint32_t),
        void (*setup)(struct cpu *, int, char **))
{
        struct syscall_emul *sep;

        CHECK_ALLOCATION(sep = malloc(sizeof(struct syscall_emul)));
        memset(sep, 0, sizeof(sep));

        sep->name     = name;
        sep->arch     = arch;
        sep->cpu_name = cpu_name;
        sep->f        = f;
        sep->setup    = setup;

        sep->next = first_syscall_emul;
        first_syscall_emul = sep;
}


/*
 *  useremul_list_emuls():
 *
 *  List all available userland emulation modes.  (Actually, only those which
 *  have CPU support enabled.)
 */
void useremul_list_emuls(void)
{
        struct syscall_emul *sep;
        int iadd = DEBUG_INDENTATION * 2;

        sep = first_syscall_emul;

        if (sep == NULL)
                return;

        debug("The following userland-only (syscall) emulation modes are"
            " available:\n\n");
        debug_indentation(iadd);

        while (sep != NULL) {
                if (cpu_family_ptr_by_number(sep->arch) != NULL) {
                        debug("%s (default CPU \"%s\")\n",
                            sep->name, sep->cpu_name);
                }

                sep = sep->next;
        }

        debug_indentation(-iadd);
        debug("\n(Most of these modes are bogus.)\n\n");
}


/*
 *  useremul_init():
 *
 *  This function should be called before any other useremul_*() function
 *  is used.
 */
void useremul_init(void)
{
        /*  Note: These are in reverse alphabetic order:  */

        add_useremul("NetBSD/pmax", ARCH_MIPS, "R3000",
            useremul_netbsd, useremul_netbsd_setup);

        add_useremul("FreeBSD/Alpha", ARCH_ALPHA, "21364",
            useremul_freebsd, useremul_freebsd_setup);
}

1	/*
2	* Copyright (C) 2004-2007 Anders Gavare. All rights reserved.
3	*
4	* Redistribution and use in source and binary forms, with or without
5	* modification, are permitted provided that the following conditions are met:
6	*
7	* 1. Redistributions of source code must retain the above copyright
8	* notice, this list of conditions and the following disclaimer.
9	* 2. Redistributions in binary form must reproduce the above copyright
10	* notice, this list of conditions and the following disclaimer in the
11	* documentation and/or other materials provided with the distribution.
12	* 3. The name of the author may not be used to endorse or promote products
13	* derived from this software without specific prior written permission.
14	*
15	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
16	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18	* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
19	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
21	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
25	* SUCH DAMAGE.
26	*
27	*
28	* $Id: useremul.c,v 1.6 2007/06/17 23:32:20 debug Exp $
29	*
30	* COMMENT: Userland (syscall) emulation framework
31	*/
32
33	#include <stdio.h>
34	#include <stdlib.h>
35	#include <string.h>
36
37	#include "cpu.h"
38	#include "machine.h"
39	#include "misc.h"
40	#include "useremul.h"
41
42
43	struct syscall_emul {
44	char *name;
45	int arch;
46	char *cpu_name;
47	void (f)(struct cpu , uint32_t);
48	void (setup)(struct cpu , int, char **);
49
50	struct syscall_emul *next;
51	};
52
53	static struct syscall_emul *first_syscall_emul;
54
55	/* Max length of strings passed using syscall parameters: */
56	#define MAXLEN 8192
57
58
59	/*
60	* useremul_setup():
61	*
62	* Set up an emulated environment suitable for running userland code. The
63	* program should already have been loaded into memory when this function
64	* is called.
65	*/
66	void useremul_setup(struct cpu cpu, int argc, char *host_argv)
67	{
68	struct syscall_emul *sep;
69
70	sep = first_syscall_emul;
71
72	while (sep != NULL) {
73	if (strcasecmp(cpu->machine->userland_emul, sep->name) == 0) {
74	sep->setup(cpu, argc, host_argv);
75	return;
76	}
77	sep = sep->next;
78	}
79
80	fatal("useremul_setup(): internal error, unimplemented emulation?\n");
81	exit(1);
82	}
83
84
85	/*
86	* useremul_syscall():
87	*
88	* Handle userland syscalls. This function is called whenever a userland
89	* process runs a 'syscall' instruction. The code argument is the code
90	* embedded into the syscall instruction, if any. (This 'code' value is not
91	* necessarily used by specific emulations.)
92	*/
93	void useremul_syscall(struct cpu *cpu, uint32_t code)
94	{
95	if (cpu->useremul_syscall == NULL) {
96	fatal("useremul_syscall(): cpu->useremul_syscall == NULL\n");
97	} else
98	cpu->useremul_syscall(cpu, code);
99	}
100
101
102	/*
103	* useremul_name_to_useremul():
104	*
105	* Example:
106	* Input: name = "netbsd/pmax"
107	* Output: sets arch = ARCH_MIPS, machine_name = "NetBSD/pmax",
108	* and *cpu_name = "R3000".
109	*/
110	void useremul_name_to_useremul(struct cpu cpu, char name, int *arch,
111	char machine_name, char cpu_name)
112	{
113	struct syscall_emul *sep;
114
115	sep = first_syscall_emul;
116
117	while (sep != NULL) {
118	if (strcasecmp(name, sep->name) == 0) {
119	if (cpu_family_ptr_by_number(sep->arch) == NULL) {
120	printf("\nSupport for the CPU family needed"
121	" for '%s' userland emulation was not"
122	" enabled at configuration time.\n",
123	sep->name);
124	exit(1);
125	}
126
127	if (cpu != NULL)
128	cpu->useremul_syscall = sep->f;
129
130	if (arch != NULL)
131	*arch = sep->arch;
132
133	if (machine_name != NULL)
134	CHECK_ALLOCATION((*machine_name) =
135	strdup(sep->name));
136
137	if (cpu_name != NULL)
138	CHECK_ALLOCATION((*cpu_name) =
139	strdup(sep->cpu_name));
140
141	return;
142	}
143
144	sep = sep->next;
145	}
146
147	fatal("Unknown userland emulation '%s'\n", name);
148	exit(1);
149	}
150
151
152	/*
153	* add_useremul():
154	*
155	* For internal use, from useremul_init() only. Adds an emulation mode.
156	*/
157	static void add_useremul(char name, int arch, char cpu_name,
158	void (f)(struct cpu , uint32_t),
159	void (setup)(struct cpu , int, char **))
160	{
161	struct syscall_emul *sep;
162
163	CHECK_ALLOCATION(sep = malloc(sizeof(struct syscall_emul)));
164	memset(sep, 0, sizeof(sep));
165
166	sep->name = name;
167	sep->arch = arch;
168	sep->cpu_name = cpu_name;
169	sep->f = f;
170	sep->setup = setup;
171
172	sep->next = first_syscall_emul;
173	first_syscall_emul = sep;
174	}
175
176
177	/*
178	* useremul_list_emuls():
179	*
180	* List all available userland emulation modes. (Actually, only those which
181	* have CPU support enabled.)
182	*/
183	void useremul_list_emuls(void)
184	{
185	struct syscall_emul *sep;
186	int iadd = DEBUG_INDENTATION * 2;
187
188	sep = first_syscall_emul;
189
190	if (sep == NULL)
191	return;
192
193	debug("The following userland-only (syscall) emulation modes are"
194	" available:\n\n");
195	debug_indentation(iadd);
196
197	while (sep != NULL) {
198	if (cpu_family_ptr_by_number(sep->arch) != NULL) {
199	debug("%s (default CPU \"%s\")\n",
200	sep->name, sep->cpu_name);
201	}
202
203	sep = sep->next;
204	}
205
206	debug_indentation(-iadd);
207	debug("\n(Most of these modes are bogus.)\n\n");
208	}
209
210
211	/*
212	* useremul_init():
213	*
214	* This function should be called before any other useremul_*() function
215	* is used.
216	*/
217	void useremul_init(void)
218	{
219	/* Note: These are in reverse alphabetic order: */
220
221	add_useremul("NetBSD/pmax", ARCH_MIPS, "R3000",
222	useremul_netbsd, useremul_netbsd_setup);
223
224	add_useremul("FreeBSD/Alpha", ARCH_ALPHA, "21364",
225	useremul_freebsd, useremul_freebsd_setup);
226	}
227