ViewVC Help

View File | Revision Log | Show Annotations | Revision Graph | Root Listing

root/cebix/BasiliskII/src/Unix/Darwin/lowmem.c

Comparing BasiliskII/src/Unix/Darwin/lowmem.c (file contents):
Revision 1.2 by cebix, 2004-01-12T15:54:42Z vs.
Revision 1.8 by asvitkine, 2011-12-27T20:50:27Z

#	Line 3 | Line 3
3		*
4		*  Copyright (c) 2003 Michael Z. Sliczniak
5		*
6	<	*  Basilisk II (C) 1997-2004 Christian Bauer
6	>	*  Basilisk II (C) 1997-2005 Christian Bauer
7		*
8		*  This program is free software; you can redistribute it and/or modify
9		*  it under the terms of the GNU General Public License as published by
#	Line 25 | Line 25
25		#include <fcntl.h>
26		#include <errno.h>
27		#include <stdio.h>
28	+	#include <stdlib.h>
29		#include <string.h>
30		#include <mach/vm_prot.h>
31		#include <mach-o/loader.h>
32	+	#include <mach-o/fat.h>
33
34		static const char progname[] = "lowmem";
35	+	static const char *filename;
36	+
37	+	static int do_swap = 0;
38	+
39	+	static uint32_t target_uint32(uint32_t value)
40	+	{
41	+	if (do_swap)
42	+	value = OSSwapInt32(value);
43	+	return value;
44	+	}
45	+
46	+	void pagezero_32(struct mach_header *machhead)
47	+	{
48	+	struct segment_command *sc_cmd;
49	+
50	+	if (target_uint32(machhead->filetype) != MH_EXECUTE) {
51	+	(void)fprintf(stderr, "%s: %s does not appear to be an executable file\n",
52	+	progname, filename);
53	+	exit(1);
54	+	}
55	+	if (machhead->ncmds == 0) {
56	+	(void)fprintf(stderr, "%s: %s does not contain any load commands\n",
57	+	progname, filename);
58	+	exit(1);
59	+	}
60	+	sc_cmd = (void *)&machhead[1];
61	+	if (target_uint32(sc_cmd->cmd) != LC_SEGMENT){
62	+	(void)fprintf(stderr, "%s: load segment not first command in %s\n",
63	+	progname, filename);
64	+	exit(1);
65	+	}
66	+	if (strncmp(sc_cmd->segname, "__PAGEZERO", sizeof (*sc_cmd->segname))) {
67	+	(void)fprintf(stderr, "%s: zero page not first segment in %s\n",
68	+	progname, filename);
69	+	exit(1);
70	+	}
71	+	/* change the permissions */
72	+	sc_cmd->maxprot = target_uint32(VM_PROT_ALL);
73	+	sc_cmd->initprot = target_uint32(VM_PROT_ALL);
74	+	}
75	+
76	+	#if defined(MH_MAGIC_64)
77	+	void pagezero_64(struct mach_header_64 *machhead)
78	+	{
79	+	struct segment_command_64 *sc_cmd;
80	+
81	+	if (target_uint32(machhead->filetype) != MH_EXECUTE) {
82	+	(void)fprintf(stderr, "%s: %s does not appear to be an executable file\n",
83	+	progname, filename);
84	+	exit(1);
85	+	}
86	+	if (machhead->ncmds == 0) {
87	+	(void)fprintf(stderr, "%s: %s does not contain any load commands\n",
88	+	progname, filename);
89	+	exit(1);
90	+	}
91	+	sc_cmd = (void *)&machhead[1];
92	+	if (target_uint32(sc_cmd->cmd) != LC_SEGMENT_64) {
93	+	(void)fprintf(stderr, "%s: load segment not first command in %s\n",
94	+	progname, filename);
95	+	exit(1);
96	+	}
97	+	if (strncmp(sc_cmd->segname, "__PAGEZERO", sizeof(*sc_cmd->segname))) {
98	+	(void)fprintf(stderr, "%s: zero page not first segment in %s\n",
99	+	progname, filename);
100	+	exit(1);
101	+	}
102	+	/* change the permissions */
103	+	sc_cmd->maxprot = target_uint32(VM_PROT_ALL);
104	+	sc_cmd->initprot = target_uint32(VM_PROT_ALL);
105	+	}
106	+	#endif
107
108		/*
109		* Under Mach there is very little assumed about the memory map of object
#	Line 54 | Line 128 | main(int argc, const char *argv[])
128		{
129		int fd;
130		char *addr;
131	+	off_t file_size;
132		struct mach_header *machhead;
133	<	struct segment_command *sc_cmd;
133	>	#if defined(MH_MAGIC_64)
134	>	struct mach_header_64 *machhead64;
135	>	#endif
136	>	struct fat_header *fathead;
137
138		if (argc != 2) {
139		(void)fprintf(stderr, "Usage: %s executable\n", progname);
140		exit(1);
141		}
142
143	<	fd = open(argv[1], O_RDWR, 0);
143	>	filename = argv[1];
144	>
145	>	fd = open(filename, O_RDWR, 0);
146		if (fd == -1) {
147		(void)fprintf(stderr, "%s: could not open %s: %s\n",
148	<	progname, argv[1], strerror(errno));
148	>	progname, filename, strerror(errno));
149	>	exit(1);
150	>	}
151	>
152	>	file_size = lseek(fd, 0, SEEK_END);
153	>	if (file_size == -1) {
154	>	// for some mysterious reason, this sometimes fails...
155	>	file_size = 0x1000;
156	>	#if 0
157	>	(void)fprintf(stderr, "%s: could not get size of %s: %s\n",
158	>	progname, filename, strerror(errno));
159		exit(1);
160	+	#endif
161		}
162
163		/*
164		* Size does not really matter, it will be rounded-up to a multiple
165		* of the page size automatically.
166		*/
167	<	addr = mmap(NULL, 0x1000, PROT_READ | PROT_WRITE,
167	>	addr = mmap(NULL, file_size, PROT_READ | PROT_WRITE,
168		MAP_FILE | MAP_SHARED, fd, 0);
169	<	if (addr == NULL) {
169	>	if (addr == NULL || addr == MAP_FAILED) {
170		(void)fprintf(stderr, "%s: could not mmap %s: %s\n",
171	<	progname, argv[1], strerror(errno));
171	>	progname, filename, strerror(errno));
172		exit(1);
173		}
174
175		/*
176		* Check to see if the Mach-O magic bytes are in the header.
86	–	* If we cared about cross compiling we would also check against
87	–	* MH_CIGAM and then change the endianness with every access, but
88	–	* we do not care about that.
177		*/
178		machhead = (void *)addr;
179	<	if (machhead->magic != MH_MAGIC) {
179	>	#if defined(MH_MAGIC_64)
180	>	machhead64 = (void *)addr;
181	>	#endif
182	>	fathead = (void *)addr;
183	>
184	>	#if defined(MH_MAGIC_64)
185	>	do_swap = machhead->magic == MH_CIGAM || fathead->magic == FAT_CIGAM || machhead64->magic == MH_CIGAM_64;
186	>	#else
187	>	do_swap = machhead->magic == MH_CIGAM || fathead->magic == FAT_CIGAM;
188	>	#endif
189	>
190	>	if (target_uint32(machhead->magic) == MH_MAGIC) {
191	>	pagezero_32(machhead);
192	>	#if defined(MH_MAGIC_64)
193	>	} else if (target_uint32(machhead64->magic) == MH_MAGIC_64) {
194	>	pagezero_64(machhead64);
195	>	#endif
196	>	} else if (target_uint32(fathead->magic) == FAT_MAGIC) {
197	>	struct fat_arch *arch = (void *)&fathead[1];
198	>	int saved_swap = do_swap;
199	>	int i;
200	>	for (i = 0; i < target_uint32(fathead->nfat_arch); ++i, ++arch) {
201	>	machhead   = (void *)(addr + target_uint32(arch->offset));
202	>	#if defined(MH_MAGIC_64)
203	>	machhead64 = (void *)(addr + target_uint32(arch->offset));
204	>	#endif
205	>	#if defined(MH_MAGIC_64)
206	>	do_swap = machhead->magic == MH_CIGAM || machhead64->magic == MH_CIGAM_64;
207	>	#else
208	>	do_swap = machhead->magic == MH_CIGAM;
209	>	#endif
210	>	if (target_uint32(machhead->magic) == MH_MAGIC) {
211	>	pagezero_32(machhead);
212	>	#if defined(MH_MAGIC_64)
213	>	} else if (target_uint32(machhead64->magic) == MH_MAGIC_64) {
214	>	pagezero_64(machhead64);
215	>	#endif
216	>	} else {
217	>	(void)fprintf(stderr, "%s: %s does not appear to be a Mach-O object file\n",
218	>	progname, filename);
219	>	exit(1);
220	>	}
221	>	do_swap = saved_swap;
222	>	}
223	>	} else {
224		(void)fprintf(stderr, "%s: %s does not appear to be a Mach-O object file\n",
225	<	progname, argv[1]);
94	<	exit(1);
95	<	}
96	<
97	<	if (machhead->filetype != MH_EXECUTE) {
98	<	(void)fprintf(stderr, "%s: %s does not appear to be an executable file\n",
99	<	progname, argv[1]);
225	>	progname, filename);
226		exit(1);
227		}
228
103	–	if (machhead->ncmds == 0) {
104	–	(void)fprintf(stderr, "%s: %s does not contain any load commands\n",
105	–	progname, argv[1]);
106	–	exit(1);
107	–	}
108	–
109	–	sc_cmd = (void *)&machhead[1];
110	–	if (sc_cmd->cmd != LC_SEGMENT){
111	–	(void)fprintf(stderr, "%s: load segment not first command in %s\n",
112	–	progname, argv[1]);
113	–	exit(1);
114	–	}
115	–
116	–	if (strncmp(sc_cmd->segname, "__PAGEZERO",
117	–	sizeof (*sc_cmd->segname))) {
118	–	(void)fprintf(stderr, "%s: zero page not first segment in %s\n",
119	–	progname, argv[1]);
120	–	exit(1);
121	–	}
122	–
123	–	/* change the permissions */
124	–	sc_cmd->maxprot = VM_PROT_ALL;
125	–	sc_cmd->initprot = VM_PROT_ALL;
126	–
229		/*
230		* We do not make __PAGEZERO 8K in this program because then
231		* all of the offsets would be wrong in the object file after
232		* this segment. Instead we use the -pagezero_size option
233		* to link the executable.
234		*/
235	<	if (msync(addr, 0x1000, MS_SYNC) == -1) {
235	>	if (msync(addr, file_size, MS_SYNC) == -1) {
236		(void)fprintf(stderr, "%s: could not sync %s: %s\n",
237	<	progname, argv[1], strerror(errno));
237	>	progname, filename, strerror(errno));
238		exit(1);
239		}
240
241	<	if (munmap(addr, 0x1000) == -1) {
241	>	if (munmap(addr, file_size) == -1) {
242		(void)fprintf(stderr, "%s: could not unmap %s: %s\n",
243	<	progname, argv[1], strerror(errno));
243	>	progname, filename, strerror(errno));
244		exit(1);
245		}
246

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines