Attachment #4314 for bug #23209

View | Details | Raw Unified | Return to bug 23209
Collapse All | Expand All

Lines 136-142 Link Here

(-)libx86-1.1/lrmi.c (-1 / +1 lines)
136	if (context.ready)	136	if (context.ready)
137	return 1;	137	return 1;
138		138
139	if (!LRMI_common_init())	139	if (!LRMI_common_init(0))
140	return 0;	140	return 0;
141		141
142	/*	142	/*




	int i;
	X86EMU_intrFuncs intFuncs[256];

	mmap_addr = LRMI_common_init(1);

	if (!mmap_addr)
		return 0;

	mmap_addr = 0;
	
	X86EMU_pioFuncs pioFuncs = {
		(&x_inb),
		(&x_inw),

	X86_ESP = 0xFFF9;
	memset (stack, 0, 64*1024);

	*mmap_addr = 0x4f; /* Make sure that we end up jumping back to a
			      halt instruction */

	M.mem_base = (unsigned long)mmap_addr;
	M.mem_size = 1024*1024;

	return 1;




static struct {
	int ready;
	int count;
	void *offset;
	struct mem_block blocks[REAL_MEM_BLOCKS];
} mem_info = { 0 };

static int
real_mem_init(int high_page)
{
	void *m;
	int fd_zero, flags = MAP_SHARED;

	if (mem_info.ready)
		return 1;

		return 0;
	}

	if (!high_page)
		flags |= MAP_FIXED;

	m = mmap((void *)REAL_MEM_BASE, REAL_MEM_SIZE,
		 PROT_READ | PROT_WRITE | PROT_EXEC,
		 flags, fd_zero, 0);

	if (m == (void *)-1) {
		perror("mmap /dev/zero");

	close(fd_zero);

	mem_info.ready = 1;
	mem_info.offset = m;
	mem_info.count = 1;
	mem_info.blocks[0].size = REAL_MEM_SIZE;
	mem_info.blocks[0].free = 1;

real_mem_deinit(void)
{
	if (mem_info.ready) {
		munmap(mem_info.offset, REAL_MEM_SIZE);
		mem_info.ready = 0;
	}
}

LRMI_alloc_real(int size)
{
	int i;
	char *r = (char *)mem_info.offset;

	if (!mem_info.ready)
		return NULL;

LRMI_free_real(void *m)
{
	int i;
	char *r = (char *)mem_info.offset;

	if (!mem_info.ready)
		return;

	return *(unsigned short *)(i * 4);
}

void *LRMI_common_init(int high_page)
{
	void *m, *offset;
	int fd_mem;

	if (!real_mem_init(high_page))
		return NULL;

	offset = mem_info.offset - REAL_MEM_BASE;

	/*
	 Map the Interrupt Vectors (0x0 - 0x400) + BIOS data (0x400 - 0x502)

	if (fd_mem == -1) {
		real_mem_deinit();
		perror("open /dev/mem");
		return NULL;
	}

	m = mmap(offset, 0x502,
		 PROT_READ | PROT_WRITE | PROT_EXEC,
		 MAP_FIXED | MAP_SHARED, fd_mem, 0);

	if (m == (void *)-1) {
		close(fd_mem);
		real_mem_deinit();
		perror("mmap /dev/mem");
		return NULL;
	}

	m = mmap(offset+0xa0000, 0x100000 - 0xa0000,
	 PROT_READ | PROT_WRITE | PROT_EXEC,
	 MAP_FIXED | MAP_SHARED, fd_mem, 0xa0000);

	if (m == (void *)-1) {
		munmap(offset, 0x502);
		close(fd_mem);
		real_mem_deinit();
		perror("mmap /dev/mem");
		return NULL;
	}

	close(fd_mem);

	return offset;
}

Lines 40-43 Link Here

(-)libx86-1.1/x86-common.h (-1 / +1 lines)
40		40
41	void *LRMI_alloc_real(int size);	41	void *LRMI_alloc_real(int size);
42	void LRMI_free_real(void *m);	42	void LRMI_free_real(void *m);
43	int LRMI_common_init(void);	43	void *LRMI_common_init(int high_page);

Return to bug 23209

Lines 139-149 Link Here

(-)libx86-1.1/thunk.c (-6 / +6 lines)
139	int i;	139	int i;
140	X86EMU_intrFuncs intFuncs[256];	140	X86EMU_intrFuncs intFuncs[256];
141		141
142	if (!LRMI_common_init())	142	mmap_addr = LRMI_common_init(1);
		143
		144	if (!mmap_addr)
143	return 0;	145	return 0;
144		146
145	mmap_addr = 0;
146
147	X86EMU_pioFuncs pioFuncs = {	147	X86EMU_pioFuncs pioFuncs = {
148	(&x_inb),	148	(&x_inb),
149	(&x_inw),	149	(&x_inw),
Lines 169-178 Link Here
169	X86_ESP = 0xFFF9;	169	X86_ESP = 0xFFF9;
170	memset (stack, 0, 64*1024);	170	memset (stack, 0, 64*1024);
171		171
172	((char )0) = 0x4f; /* Make sure that we end up jumping back to a	172	mmap_addr = 0x4f; / Make sure that we end up jumping back to a
173	halt instruction */	173	halt instruction */
174		174
175	M.mem_base = 0;	175	M.mem_base = (unsigned long)mmap_addr;
176	M.mem_size = 1024*1024;	176	M.mem_size = 1024*1024;
177		177
178	return 1;	178	return 1;

Lines 45-58 Link Here

(-)libx86-1.1/x86-common.c (-20 / +27 lines)
45	static struct {	45	static struct {
46	int ready;	46	int ready;
47	int count;	47	int count;
		48	void *offset;
48	struct mem_block blocks[REAL_MEM_BLOCKS];	49	struct mem_block blocks[REAL_MEM_BLOCKS];
49	} mem_info = { 0 };	50	} mem_info = { 0 };
50		51
51	static int	52	static int
52	real_mem_init(void)	53	real_mem_init(int high_page)
53	{	54	{
54	void *m;	55	void *m;
55	int fd_zero;	56	int fd_zero, flags = MAP_SHARED;
56		57
57	if (mem_info.ready)	58	if (mem_info.ready)
58	return 1;	59	return 1;
Lines 63-71 Link Here
63	return 0;	64	return 0;
64	}	65	}
65		66
		67	if (!high_page)
		68	flags \|= MAP_FIXED;
		69
66	m = mmap((void *)REAL_MEM_BASE, REAL_MEM_SIZE,	70	m = mmap((void *)REAL_MEM_BASE, REAL_MEM_SIZE,
67	PROT_READ \| PROT_WRITE \| PROT_EXEC,	71	PROT_READ \| PROT_WRITE \| PROT_EXEC,
68	MAP_FIXED \| MAP_SHARED, fd_zero, 0);	72	flags, fd_zero, 0);
69		73
70	if (m == (void *)-1) {	74	if (m == (void *)-1) {
71	perror("mmap /dev/zero");	75	perror("mmap /dev/zero");
Lines 76-81 Link Here
76	close(fd_zero);	80	close(fd_zero);
77		81
78	mem_info.ready = 1;	82	mem_info.ready = 1;
		83	mem_info.offset = m;
79	mem_info.count = 1;	84	mem_info.count = 1;
80	mem_info.blocks[0].size = REAL_MEM_SIZE;	85	mem_info.blocks[0].size = REAL_MEM_SIZE;
81	mem_info.blocks[0].free = 1;	86	mem_info.blocks[0].free = 1;
Lines 87-93 Link Here
87	real_mem_deinit(void)	92	real_mem_deinit(void)
88	{	93	{
89	if (mem_info.ready) {	94	if (mem_info.ready) {
90	munmap((void *)REAL_MEM_BASE, REAL_MEM_SIZE);	95	munmap(mem_info.offset, REAL_MEM_SIZE);
91	mem_info.ready = 0;	96	mem_info.ready = 0;
92	}	97	}
93	}	98	}
Lines 119-125 Link Here
119	LRMI_alloc_real(int size)	124	LRMI_alloc_real(int size)
120	{	125	{
121	int i;	126	int i;
122	char r = (char )REAL_MEM_BASE;	127	char r = (char )mem_info.offset;
123		128
124	if (!mem_info.ready)	129	if (!mem_info.ready)
125	return NULL;	130	return NULL;
Lines 151-157 Link Here
151	LRMI_free_real(void *m)	156	LRMI_free_real(void *m)
152	{	157	{
153	int i;	158	int i;
154	char r = (char )REAL_MEM_BASE;	159	char r = (char )mem_info.offset;
155		160
156	if (!mem_info.ready)	161	if (!mem_info.ready)
157	return;	162	return;
Lines 200-212 Link Here
200	return (unsigned short )(i * 4);	205	return (unsigned short )(i * 4);
201	}	206	}
202		207
203	int LRMI_common_init(void)	208	void *LRMI_common_init(int high_page)
204	{	209	{
205	void *m;	210	void m, offset;
206	int fd_mem;	211	int fd_mem;
207		212
208	if (!real_mem_init())	213	if (!real_mem_init(high_page))
209	return 0;	214	return NULL;
		215
		216	offset = mem_info.offset - REAL_MEM_BASE;
210		217
211	/*	218	/*
212	Map the Interrupt Vectors (0x0 - 0x400) + BIOS data (0x400 - 0x502)	219	Map the Interrupt Vectors (0x0 - 0x400) + BIOS data (0x400 - 0x502)
Lines 217-249 Link Here
217	if (fd_mem == -1) {	224	if (fd_mem == -1) {
218	real_mem_deinit();	225	real_mem_deinit();
219	perror("open /dev/mem");	226	perror("open /dev/mem");
220	return 0;	227	return NULL;
221	}	228	}
222		229
223	m = mmap((void *)0, 0x502,	230	m = mmap(offset, 0x502,
224	PROT_READ \| PROT_WRITE \| PROT_EXEC,	231	PROT_READ \| PROT_WRITE \| PROT_EXEC,
225	MAP_FIXED \| MAP_SHARED, fd_mem, 0);	232	MAP_FIXED \| MAP_SHARED, fd_mem, 0);
226		233
227	if (m == (void *)-1) {	234	if (m == (void *)-1) {
228	close(fd_mem);	235	close(fd_mem);
229	real_mem_deinit();	236	real_mem_deinit();
230	perror("mmap /dev/mem");	237	perror("mmap /dev/mem");
231	return 0;	238	return NULL;
232	}	239	}
233		240
234	m = mmap((void *)0xa0000, 0x100000 - 0xa0000,	241	m = mmap(offset+0xa0000, 0x100000 - 0xa0000,
235	PROT_READ \| PROT_WRITE \| PROT_EXEC,	242	PROT_READ \| PROT_WRITE \| PROT_EXEC,
236	MAP_FIXED \| MAP_SHARED, fd_mem, 0xa0000);	243	MAP_FIXED \| MAP_SHARED, fd_mem, 0xa0000);
237		244
238	if (m == (void *)-1) {	245	if (m == (void *)-1) {
239	munmap((void *)0, 0x502);	246	munmap(offset, 0x502);
240	close(fd_mem);	247	close(fd_mem);
241	real_mem_deinit();	248	real_mem_deinit();
242	perror("mmap /dev/mem");	249	perror("mmap /dev/mem");
243	return 0;	250	return NULL;
244	}	251	}
245		252
246	close(fd_mem);	253	close(fd_mem);
247		254
248	return 1;	255	return offset;
249	}	256	}