Context Navigation

source: trunk/kLdr/kLdrModLX.c@ 2887

Visit:

Last change on this file since 2887 was 2887, checked in by bird, 19 years ago
Bugfixing.
Property svn:keywords set to `Id`
File size: 64.0 KB

Line
1	/* $Id: kLdrModLX.c 2887 2006-11-18 15:37:00Z bird $ */
2	/** @file
3	*
4	* kLdr - The Module Interpreter for the Linear eXecutable (LX) Format.
5	*
6	* Copyright (c) 2006 knut st. osmundsen <bird@anduin.net>
7	*
8	*
9	* This file is part of kLdr.
10	*
11	* kLdr is free software; you can redistribute it and/or modify
12	* it under the terms of the GNU General Public License as published by
13	* the Free Software Foundation; either version 2 of the License, or
14	* (at your option) any later version.
15	*
16	* kLdr is distributed in the hope that it will be useful,
17	* but WITHOUT ANY WARRANTY; without even the implied warranty of
18	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19	* GNU General Public License for more details.
20	*
21	* You should have received a copy of the GNU General Public License
22	* along with kLdr; if not, write to the Free Software
23	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
24	*
25	*/
26
27
28	/*******************************************************************************
29	* Header Files *
30	*******************************************************************************/
31	#include <kLdr.h>
32	#include "kLdrHlp.h"
33	#include "kLdrInternal.h"
34	#include "kLdrModLX.h"
35
36
37	/*******************************************************************************
38	* Defined Constants And Macros *
39	*******************************************************************************/
40	/** @def KLDRMODLX_STRICT
41	* Define KLDRMODLX_STRICT to enabled strict checks in KLDRMODLX. */
42	#define KLDRMODLX_STRICT 1
43
44	/** @def KLDRMODLX_ASSERT
45	* Assert that an expression is true when KLDR_STRICT is defined.
46	*/
47	#ifdef KLDRMODLX_STRICT
48	# define KLDRMODLX_ASSERT(expr) kldrHlpAssert(expr)
49	#else
50	# define KLDRMODLX_ASSERT(expr) do {} while (0)
51	#endif
52
53
54	/*******************************************************************************
55	* Structures and Typedefs *
56	*******************************************************************************/
57	/**
58	* Instance data for the LX module interpreter.
59	*/
60	typedef struct KLDRMODLX
61	{
62	/** Pointer to the module. (Follows the section table.) */
63	PKLDRMOD pMod;
64	/** Pointer to the user mapping. */
65	const void *pvMapping;
66	/** The size of the mapped LX image. */
67	size_t cbMapped;
68	/** Reserved flags. */
69	uint32_t f32Reserved;
70
71	/** The offset of the LX header. */
72	off_t offHdr;
73	/** Copy of the LX header. */
74	struct e32_exe Hdr;
75
76	/** Pointer to the loader section.
77	* Allocated together with this strcture. */
78	const uint8_t *pbLoaderSection;
79	/** Pointer to the last byte in the loader section. */
80	const uint8_t *pbLoaderSectionLast;
81	/** Pointer to the object table in the loader section. */
82	const struct o32_obj *paObjs;
83	/** Pointer to the object page map table in the loader section. */
84	const struct o32_map *paPageMappings;
85	/** Pointer to the resource table in the loader section. */
86	const struct rsrc32 *paRsrcs;
87	/** Pointer to the resident name table in the loader section. */
88	const uint8_t *pbResNameTab;
89	/** Pointer to the entry table in the loader section. */
90	const uint8_t *pbEntryTab;
91
92	/** Pointer to the non-resident name table. */
93	uint8_t *pbNonResNameTab;
94	/** Pointer to the last byte in the non-resident name table. */
95	const uint8_t *pbNonResNameTabLast;
96
97	/** Pointer to the fixup section. */
98	uint8_t *pbFixupSection;
99	/** Pointer to the last byte in the fixup section. */
100	const uint8_t *pbFixupSectionLast;
101	/** Pointer to the fixup page table within pvFixupSection. */
102	const uint32_t *paoffPageFixups;
103	/** Pointer to the fixup record table within pvFixupSection. */
104	const uint8_t *pbFixupRecs;
105	/** Pointer to the import module name table within pvFixupSection. */
106	const uint8_t *pbImportMods;
107	/** Pointer to the import module name table within pvFixupSection. */
108	const uint8_t *pbImportProcs;
109	} KLDRMODLX, *PKLDRMODLX;
110
111
112	/*******************************************************************************
113	* Internal Functions *
114	*******************************************************************************/
115	static int kldrModLXHasDbgInfo(PKLDRMOD pMod, const void *pvBits);
116	static int kldrModLXRelocateBits(PKLDRMOD pMod, void *pvBits, KLDRADDR NewBaseAddress, KLDRADDR OldBaseAddress,
117	PFNKLDRMODGETIMPORT pfnGetImport, void *pvUser);
118	static int kldrModLXDoCreate(PKLDRRDR pRdr, off_t offNewHdr, PKLDRMODLX *ppModLX);
119	static const uint8_t kldrModLXDoNameTableLookupByOrdinal(const uint8_t pbNameTable, int32_t cbNameTable, uint32_t iOrdinal);
120	static int kldrModLXDoNameLookup(PKLDRMODLX pModLX, const char pszSymbol, uint32_t piSymbol);
121	static const uint8_t kldrModLXDoNameTableLookupByName(const uint8_t pbNameTable, int32_t cbNameTable,
122	char *pchSymbol, size_t cchSymbol);
123	static int kldrModLXDoLoadBits(PKLDRMODLX pModLX, void *pvBits);
124	static int kldrModLXDoIterDataUnpacking(uint8_t pbDst, const uint8_t pbSrc, int cbSrc);
125	static int kldrModLXDoIterData2Unpacking(uint8_t pbDst, const uint8_t pbSrc, int cbSrc);
126	static void kLdrModLXMemCopyW(uint8_t pbDst, const uint8_t pbSrc, int cb);
127	static int kldrModLXDoProtect(PKLDRMODLX pModLX, void *pvBits, unsigned fUnprotectOrProtect);
128	static int kldrModLXDoCallDLL(PKLDRMODLX pModLX, unsigned uOp, uintptr_t uHandle);
129	static int kldrModLXDoForwarderQuery(PKLDRMODLX pModLX, const struct e32_entry *pEntry,
130	PFNKLDRMODGETIMPORT pfnGetForwarder, void pvUser, PKLDRADDR puValue, uint32_t pfKind);
131	static int kldrModLXDoLoadFixupSection(PKLDRMODLX pModLX);
132	static int32_t kldrModLXDoCall(uintptr_t uEntrypoint, uintptr_t uHandle, uint32_t uOp, void *pvReserved);
133
134
135	/**
136	* Create a loader module instance interpreting the executable image found
137	* in the specified file provider instance.
138	*
139	* @returns 0 on success and *ppMod pointing to a module instance.
140	* On failure, a non-zero OS specific error code is returned.
141	* @param pOps Pointer to the registered method table.
142	* @param pRdr The file provider instance to use.
143	* @param offNewHdr The offset of the new header in MZ files. -1 if not found.
144	* @param ppMod Where to store the module instance pointer.
145	*/
146	static int kldrModLXCreate(PCKLDRMODOPS pOps, PKLDRRDR pRdr, off_t offNewHdr, PPKLDRMOD ppMod)
147	{
148	PKLDRMODLX pModLX;
149	int rc;
150
151	/*
152	* Create the instance data and do a minimal header validation.
153	*/
154	rc = kldrModLXDoCreate(pRdr, offNewHdr, &pModLX);
155	if (!rc)
156	{
157	pModLX->pMod->pOps = pOps;
158	pModLX->pMod->u32Magic = KLDRMOD_MAGIC;
159	*ppMod = pModLX->pMod;
160	return 0;
161	}
162	kldrHlpFree(pModLX);
163	return rc;
164	}
165
166
167	/**
168	* Separate function for reading creating the LX module instance to
169	* simplify cleanup on failure.
170	*/
171	static int kldrModLXDoCreate(PKLDRRDR pRdr, off_t offNewHdr, PKLDRMODLX *ppModLX)
172	{
173	struct e32_exe Hdr;
174	PKLDRMODLX pModLX;
175	PKLDRMOD pMod;
176	size_t cb;
177	size_t cchFilename;
178	uint32_t off, offEnd;
179	uint32_t i;
180	int rc;
181	*ppModLX = NULL;
182
183	/*
184	* Read the signature and file header.
185	*/
186	rc = kLdrRdrRead(pRdr, &Hdr, sizeof(Hdr), offNewHdr > 0 ? offNewHdr : 0);
187	if (rc)
188	return rc;
189	if ( Hdr.e32_magic[0] != E32MAGIC1
190	\|\| Hdr.e32_magic[1] != E32MAGIC2)
191	return KLDR_ERR_UNKNOWN_FORMAT;
192
193	/* We're not interested in anything but x86 images. */
194	if ( Hdr.e32_level != E32LEVEL
195	\|\| Hdr.e32_border != E32LEBO
196	\|\| Hdr.e32_worder != E32LEWO
197	\|\| Hdr.e32_cpu < E32CPU286
198	\|\| Hdr.e32_cpu > E32CPU486
199	\|\| Hdr.e32_pagesize != OBJPAGELEN
200	)
201	return KLDR_ERR_LX_BAD_HEADER;
202
203	/* Some rough sanity checks. */
204	offEnd = kLdrRdrSize(pRdr) >= (off_t)~(uint32_t)16 ? ~(uint32_t)16 : (uint32_t)kLdrRdrSize(pRdr);
205	if ( Hdr.e32_itermap > offEnd
206	\|\| Hdr.e32_datapage > offEnd
207	\|\| Hdr.e32_nrestab > offEnd
208	\|\| Hdr.e32_nrestab + Hdr.e32_cbnrestab > offEnd
209	\|\| Hdr.e32_ldrsize > offEnd - offNewHdr - sizeof(Hdr)
210	\|\| Hdr.e32_fixupsize > offEnd - offNewHdr - sizeof(Hdr)
211	\|\| Hdr.e32_fixupsize + Hdr.e32_ldrsize > offEnd - offNewHdr - sizeof(Hdr))
212	return KLDR_ERR_LX_BAD_HEADER;
213
214	/* Verify the loader section. */
215	offEnd = Hdr.e32_objtab + Hdr.e32_ldrsize;
216	if (Hdr.e32_objtab < sizeof(Hdr))
217	return KLDR_ERR_LX_BAD_LOADER_SECTION;
218	off = Hdr.e32_objtab + sizeof(struct o32_obj) * Hdr.e32_objcnt;
219	if (off > offEnd)
220	return KLDR_ERR_LX_BAD_LOADER_SECTION;
221	if ( Hdr.e32_objmap
222	&& (Hdr.e32_objmap < off \|\| Hdr.e32_objmap > offEnd))
223	return KLDR_ERR_LX_BAD_LOADER_SECTION;
224	if ( Hdr.e32_rsrccnt
225	&& ( Hdr.e32_rsrctab < off
226	\|\| Hdr.e32_rsrctab > offEnd
227	\|\| Hdr.e32_rsrctab + sizeof(struct rsrc32) * Hdr.e32_rsrccnt > offEnd))
228	return KLDR_ERR_LX_BAD_LOADER_SECTION;
229	if ( Hdr.e32_restab
230	&& (Hdr.e32_restab < off \|\| Hdr.e32_restab > offEnd - 2))
231	return KLDR_ERR_LX_BAD_LOADER_SECTION;
232	if ( Hdr.e32_enttab
233	&& (Hdr.e32_enttab < off \|\| Hdr.e32_enttab > offEnd - 2))
234	return KLDR_ERR_LX_BAD_LOADER_SECTION;
235	if ( Hdr.e32_dircnt
236	&& (Hdr.e32_dirtab < off \|\| Hdr.e32_dirtab > offEnd))
237	return KLDR_ERR_LX_BAD_LOADER_SECTION;
238
239	/* Verify the fixup section. */
240	off = offEnd;
241	offEnd = off + Hdr.e32_fixupsize;
242	if ( Hdr.e32_fpagetab
243	&& (Hdr.e32_fpagetab < off \|\| Hdr.e32_fpagetab > offEnd))
244	return KLDR_ERR_LX_BAD_FIXUP_SECTION;
245	if ( Hdr.e32_frectab
246	&& (Hdr.e32_frectab < off \|\| Hdr.e32_frectab > offEnd))
247	return KLDR_ERR_LX_BAD_FIXUP_SECTION;
248	if ( Hdr.e32_impmod
249	&& (Hdr.e32_impmod < off \|\| Hdr.e32_impmod > offEnd \|\| Hdr.e32_impmod + Hdr.e32_impmodcnt > offEnd))
250	return KLDR_ERR_LX_BAD_FIXUP_SECTION;
251	if ( Hdr.e32_impproc
252	&& (Hdr.e32_impproc < off \|\| Hdr.e32_impproc > offEnd))
253	return KLDR_ERR_LX_BAD_FIXUP_SECTION;
254
255	/*
256	* Calc the instance size, allocate and initialize it.
257	*/
258	cchFilename = kLdrHlpStrLen(kLdrRdrName(pRdr));
259	cb = KLDR_ALIGN_Z(sizeof(KLDRMODLX), 8)
260	+ KLDR_ALIGN_Z(KLDR_OFFSETOF(KLDRMOD, aSegments[Hdr.e32_objcnt + 1]), 8)
261	+ KLDR_ALIGN_Z(cchFilename + 1, 8)
262	+ Hdr.e32_ldrsize;
263	pModLX = (PKLDRMODLX)kldrHlpAlloc(cb);
264	if (!pModLX)
265	return KLDR_ERR_NO_MEMORY;
266	*ppModLX = pModLX;
267
268	/* KLDRMOD */
269	pMod = (PKLDRMOD)((uint8_t *)pModLX + KLDR_ALIGN_Z(sizeof(KLDRMODLX), 8));
270	pMod->pvData = pModLX;
271	pMod->pRdr = pRdr;
272	pMod->pOps = NULL; /* set upon success. */
273	pMod->cSegments = Hdr.e32_objcnt;
274	pMod->cchFilename = cchFilename;
275	pMod->pszFilename = (char *)KLDR_ALIGN_P(&pMod->aSegments[pMod->cSegments], 8);
276	kLdrHlpMemCopy((char *)pMod->pszFilename, kLdrRdrName(pRdr), cchFilename + 1);
277	pMod->pszName = NULL; /* finalized further down */
278	pMod->cchName = 0;
279	switch (Hdr.e32_cpu)
280	{
281	case E32CPU286:
282	pMod->enmCpu = KLDRCPU_I80286;
283	pMod->enmArch = KLDRARCH_X86_16;
284	break;
285	case E32CPU386:
286	pMod->enmCpu = KLDRCPU_I386;
287	pMod->enmArch = KLDRARCH_X86_32;
288	break;
289	case E32CPU486:
290	pMod->enmCpu = KLDRCPU_I486;
291	pMod->enmArch = KLDRARCH_X86_32;
292	break;
293	}
294	pMod->enmEndian = KLDRENDIAN_LITTLE;
295	pMod->enmFmt = KLDRFMT_LX;
296	switch (Hdr.e32_mflags & E32MODMASK)
297	{
298	case E32MODEXE:
299	pMod->enmType = !(Hdr.e32_mflags & E32NOINTFIX)
300	? KLDRTYPE_EXECUTABLE_RELOCATABLE
301	: KLDRTYPE_EXECUTABLE_FIXED;
302	break;
303
304	case E32MODDLL:
305	case E32PROTDLL:
306	case E32MODPROTDLL:
307	pMod->enmType = !(Hdr.e32_mflags & E32SYSDLL)
308	? KLDRTYPE_SHARED_LIBRARY_RELOCATABLE
309	: KLDRTYPE_SHARED_LIBRARY_FIXED;
310	break;
311
312	case E32MODPDEV:
313	case E32MODVDEV:
314	pMod->enmType = KLDRTYPE_SHARED_LIBRARY_RELOCATABLE;
315	break;
316	}
317	pMod->u32Magic = 0; /* set upon success. */
318
319	/* KLDRMODLX */
320	pModLX->pMod = pMod;
321	pModLX->pvMapping = 0;
322	pModLX->cbMapped = Hdr.e32_mpages * Hdr.e32_pagesize;
323	pModLX->f32Reserved = 0;
324
325	pModLX->offHdr = offNewHdr >= 0 ? offNewHdr : 0;
326	pModLX->Hdr = Hdr;
327
328	pModLX->pbLoaderSection = KLDR_ALIGN_P(pMod->pszFilename + pMod->cchFilename + 1, 16);
329	pModLX->pbLoaderSectionLast = pModLX->pbLoaderSection + pModLX->Hdr.e32_ldrsize;
330	pModLX->paObjs = NULL;
331	pModLX->paPageMappings = NULL;
332	pModLX->paRsrcs = NULL;
333	pModLX->pbResNameTab = NULL;
334	pModLX->pbEntryTab = NULL;
335
336	pModLX->pbNonResNameTab = NULL;
337	pModLX->pbNonResNameTabLast = NULL;
338
339	pModLX->pbFixupSection = NULL;
340	pModLX->pbFixupSectionLast = NULL;
341	pModLX->paoffPageFixups = NULL;
342	pModLX->pbFixupRecs = NULL;
343	pModLX->pbImportMods = NULL;
344	pModLX->pbImportProcs = NULL;
345
346	/*
347	* Read the loader data.
348	*/
349	rc = kLdrRdrRead(pRdr, (void *)pModLX->pbLoaderSection, pModLX->Hdr.e32_ldrsize, pModLX->Hdr.e32_objtab + pModLX->offHdr);
350	if (rc)
351	return rc;
352	if (pModLX->Hdr.e32_objcnt)
353	pModLX->paObjs = (const struct o32_obj *)pModLX->pbLoaderSection;
354	if (pModLX->Hdr.e32_objmap)
355	pModLX->paPageMappings = (const struct o32_map *)(pModLX->pbLoaderSection + pModLX->Hdr.e32_objmap - pModLX->Hdr.e32_objtab);
356	if (pModLX->Hdr.e32_rsrccnt)
357	pModLX->paRsrcs = (const struct rsrc32 *)(pModLX->pbLoaderSection + pModLX->Hdr.e32_rsrctab - pModLX->Hdr.e32_objtab);
358	if (pModLX->Hdr.e32_restab)
359	pModLX->pbResNameTab = pModLX->pbLoaderSection + pModLX->Hdr.e32_restab - pModLX->Hdr.e32_objtab;
360	if (pModLX->Hdr.e32_enttab)
361	pModLX->pbEntryTab = pModLX->pbLoaderSection + pModLX->Hdr.e32_enttab - pModLX->Hdr.e32_objtab;
362
363	/*
364	* Get the soname from the resident name table.
365	* Very convenient that it's the 0 ordinal, because then we get a
366	* free string terminator.
367	* (The table entry consists of a pascal string followed by a 16-bit ordinal.)
368	*/
369	pMod->pszName = (const char *)kldrModLXDoNameTableLookupByOrdinal(pModLX->pbResNameTab,
370	pModLX->pbLoaderSectionLast - pModLX->pbResNameTab + 1,
371	0);
372	if (!pMod->pszName)
373	return KLDR_ERR_LX_NO_SONAME;
374	pMod->cchName = (const uint8_t )pMod->pszName++;
375	if (pMod->cchName != kLdrHlpStrLen(pMod->pszName))
376	return KLDR_ERR_LX_BAD_SONAME;
377
378	/*
379	* Quick validation of the object table.
380	*/
381	cb = 0;
382	for (i = 0; i < pMod->cSegments; i++)
383	{
384	if (pModLX->paObjs[i].o32_base & (OBJPAGELEN - 1))
385	return KLDR_ERR_LX_BAD_OBJECT_TABLE;
386	if (pModLX->paObjs[i].o32_base + pModLX->paObjs[i].o32_size <= pModLX->paObjs[i].o32_base)
387	return KLDR_ERR_LX_BAD_OBJECT_TABLE;
388	if (pModLX->paObjs[i].o32_mapsize > (pModLX->paObjs[i].o32_size + (OBJPAGELEN - 1)))
389	return KLDR_ERR_LX_BAD_OBJECT_TABLE;
390	if ( pModLX->paObjs[i].o32_mapsize
391	&& ( (uint8_t *)&pModLX->paPageMappings[pModLX->paObjs[i].o32_pagemap] > pModLX->pbLoaderSectionLast
392	\|\| (uint8_t *)&pModLX->paPageMappings[pModLX->paObjs[i].o32_pagemap + pModLX->paObjs[i].o32_mapsize]
393	> pModLX->pbLoaderSectionLast))
394	return KLDR_ERR_LX_BAD_OBJECT_TABLE;
395	if (i > 0)
396	{
397	if (pModLX->paObjs[i].o32_base <= pModLX->paObjs[i - 1].o32_base)
398	return KLDR_ERR_LX_BAD_OBJECT_TABLE;
399	if (pModLX->paObjs[i].o32_base < pModLX->paObjs[i - 1].o32_base + pModLX->paObjs[i - 1].o32_mapsize)
400	return KLDR_ERR_LX_BAD_OBJECT_TABLE;
401	}
402	}
403	pModLX->cbMapped = pMod->cSegments
404	? pModLX->paObjs[pMod->cSegments - 1].o32_base + pModLX->paObjs[pMod->cSegments - 1].o32_size
405	- pModLX->paObjs[pMod->cSegments - 1].o32_size
406	: 0;
407
408	/*
409	* Setup the KLDRMOD segment array.
410	*/
411	for (i = 0; i < pMod->cSegments; i++)
412	{
413	/* unused */
414	pMod->aSegments[i].pvUser = NULL;
415	pMod->aSegments[i].MapAddress = 0;
416	pMod->aSegments[i].pchName = NULL;
417	pMod->aSegments[i].cchName = 0;
418	pMod->aSegments[i].offFile = -1;
419	pMod->aSegments[i].cbFile = 0;
420
421	/* size and addresses */
422	pMod->aSegments[i].Alignment = OBJPAGELEN;
423	pMod->aSegments[i].cb = pModLX->paObjs[i].o32_size;
424	pMod->aSegments[i].LinkAddress = pModLX->paObjs[i].o32_base;
425	pMod->aSegments[i].RVA = pModLX->paObjs[i].o32_base - pModLX->paObjs[0].o32_base;
426	pMod->aSegments[i].cbMapped = KLDR_ALIGN_Z(pModLX->paObjs[i].o32_size, 16);
427	if (i + 1 < pMod->cSegments)
428	pMod->aSegments[i].cbMapped = pModLX->paObjs[i + 1].o32_base - pModLX->paObjs[i].o32_base;
429
430	/* protection */
431	switch ( pModLX->paObjs[i].o32_flags
432	& (OBJSHARED \| OBJREAD \| OBJWRITE \| OBJEXEC))
433	{
434	case 0:
435	case OBJSHARED:
436	pMod->aSegments[i].enmProt = KLDRPROT_NOACCESS;
437	break;
438	case OBJREAD:
439	case OBJREAD \| OBJSHARED:
440	pMod->aSegments[i].enmProt = KLDRPROT_READONLY;
441	break;
442	case OBJWRITE:
443	case OBJWRITE \| OBJREAD:
444	pMod->aSegments[i].enmProt = KLDRPROT_WRITECOPY;
445	break;
446	case OBJWRITE \| OBJSHARED:
447	case OBJWRITE \| OBJSHARED \| OBJREAD:
448	pMod->aSegments[i].enmProt = KLDRPROT_READWRITE;
449	break;
450	case OBJEXEC:
451	case OBJEXEC \| OBJSHARED:
452	pMod->aSegments[i].enmProt = KLDRPROT_EXECUTE;
453	break;
454	case OBJEXEC \| OBJREAD:
455	case OBJEXEC \| OBJREAD \| OBJSHARED:
456	pMod->aSegments[i].enmProt = KLDRPROT_EXECUTE_READ;
457	break;
458	case OBJEXEC \| OBJWRITE:
459	case OBJEXEC \| OBJWRITE \| OBJREAD:
460	pMod->aSegments[i].enmProt = KLDRPROT_EXECUTE_WRITECOPY;
461	break;
462	case OBJEXEC \| OBJWRITE \| OBJSHARED:
463	case OBJEXEC \| OBJWRITE \| OBJSHARED \| OBJREAD:
464	pMod->aSegments[i].enmProt = KLDRPROT_EXECUTE_READWRITE;
465	break;
466	}
467	if ((pModLX->paObjs[i].o32_flags & (OBJREAD \| OBJWRITE \| OBJEXEC \| OBJRSRC)) == OBJRSRC)
468	pMod->aSegments[i].enmProt = KLDRPROT_READONLY;
469	/*pMod->aSegments[i].f16bit = !(pModLX->paObjs[i].o32_flags & OBJBIGDEF)
470	pMod->aSegments[i].fIOPL = !(pModLX->paObjs[i].o32_flags & OBJIOPL)
471	pMod->aSegments[i].fConforming = !(pModLX->paObjs[i].o32_flags & OBJCONFORM) */
472	}
473
474	/*
475	* We're done.
476	*/
477	*ppModLX = pModLX;
478	return 0;
479	}
480
481
482	/** @copydoc KLDRMODOPS::pfnDestroy */
483	static int kldrModLXDestroy(PKLDRMOD pMod)
484	{
485	PKLDRMODLX pModLX = (PKLDRMODLX)pMod->pvData;
486	int rc = 0;
487	KLDRMODLX_ASSERT(pModLX->pvMapping);
488
489	if (pMod->pRdr)
490	{
491	rc = kLdrRdrClose(pMod->pRdr);
492	pMod->pRdr = NULL;
493	}
494	if (pModLX->pbNonResNameTab)
495	{
496	kldrHlpFree(pModLX->pbNonResNameTab);
497	pModLX->pbNonResNameTab = NULL;
498	}
499	if (pModLX->pbFixupSection)
500	{
501	kldrHlpFree(pModLX->pbFixupSection);
502	pModLX->pbFixupSection = NULL;
503	}
504	pMod->u32Magic = 0;
505	pMod->pOps = NULL;
506	kldrHlpFree(pModLX);
507	return rc;
508	}
509
510
511	/**
512	* Resolved base address aliases.
513	*
514	* @param pModLX The interpreter module instance
515	* @param pBaseAddress The base address, IN & OUT.
516	*/
517	static void kldrModLXResolveBaseAddress(PKLDRMODLX pModLX, PKLDRADDR pBaseAddress)
518	{
519	if (*pBaseAddress == KLDRMOD_BASEADDRESS_MAP)
520	*pBaseAddress = pModLX->pMod->aSegments[0].MapAddress;
521	else if (*pBaseAddress == KLDRMOD_BASEADDRESS_LINK)
522	*pBaseAddress = pModLX->pMod->aSegments[0].LinkAddress;
523	}
524
525
526	/** @copydoc kLdrModQuerySymbol */
527	static int kldrModLXQuerySymbol(PKLDRMOD pMod, const void *pvBits, KLDRADDR BaseAddress, uint32_t iSymbol,
528	const char pszSymbol, PFNKLDRMODGETIMPORT pfnGetForwarder, void pvUser,
529	PKLDRADDR puValue, uint32_t *pfKind)
530	{
531	PKLDRMODLX pModLX = (PKLDRMODLX)pMod->pvData;
532	uint32_t iOrdinal;
533	int rc;
534	const struct b32_bundle *pBundle;
535
536
537	/*
538	* Give up at once if there is no entry table.
539	*/
540	if (!pModLX->Hdr.e32_enttab)
541	return KLDR_ERR_SYMBOL_NOT_FOUND;
542
543	/*
544	* Translate the symbol name into an ordinal.
545	*/
546	if (pszSymbol)
547	{
548	rc = kldrModLXDoNameLookup(pModLX, pszSymbol, &iSymbol);
549	if (rc)
550	return rc;
551	}
552
553	/*
554	* Iterate the entry table.
555	* (The entry table is made up of bundles of similar exports.)
556	*/
557	iOrdinal = 0;
558	pBundle = (const struct b32_bundle *)pModLX->pbEntryTab;
559	while (!pBundle->b32_cnt && iOrdinal <= iSymbol)
560	{
561	static const size_t s_cbEntry[] = { 0, 3, 5, 5, 7 };
562
563	/*
564	* Check for a hit first.
565	*/
566	iOrdinal += pBundle->b32_cnt;
567	if (iSymbol < iOrdinal)
568	{
569	uint32_t offObject;
570	const struct e32_entry pEntry = (const struct e32_entry )((uintptr_t)(pBundle + 1)
571	+ iSymbol - (iOrdinal - pBundle->b32_cnt));
572
573	/*
574	* Calculate the return address.
575	*/
576	kldrModLXResolveBaseAddress(pModLX, &BaseAddress);
577	switch (pBundle->b32_type)
578	{
579	/* empty bundles are place holders unused ordinal ranges. */
580	case EMPTY:
581	return KLDR_ERR_SYMBOL_NOT_FOUND;
582
583	/* e32_flags + a 16-bit offset. */
584	case ENTRY16:
585	offObject = pEntry->e32_variant.e32_offset.offset16;
586	if (pfKind)
587	*pfKind = KLDRSYMKIND_16BIT \| KLDRSYMKIND_NO_TYPE;
588	break;
589
590	/* e32_flags + a 16-bit offset + a 16-bit callgate selector. */
591	case GATE16:
592	offObject = pEntry->e32_variant.e32_callgate.offset;
593	if (pfKind)
594	*pfKind = KLDRSYMKIND_16BIT \| KLDRSYMKIND_CODE;
595	break;
596
597	/* e32_flags + a 32-bit offset. */
598	case ENTRY32:
599	offObject = pEntry->e32_variant.e32_offset.offset32;
600	if (pfKind)
601	*pfKind = KLDRSYMKIND_32BIT;
602	break;
603
604	/* e32_flags + 16-bit import module ordinal + a 32-bit procname or ordinal. */
605	case ENTRYFWD:
606	return kldrModLXDoForwarderQuery(pModLX, pEntry, pfnGetForwarder, pvUser, puValue, pfKind);
607
608	default:
609	/* anyone actually using TYPEINFO will end up here. */
610	KLDRMODLX_ASSERT(!"Bad bundle type");
611	break;
612	}
613
614	/*
615	* Validate the object number and calc the return address.
616	*/
617	if ( pBundle->b32_obj <= 0
618	\|\| pBundle->b32_obj > pMod->cSegments)
619	return KLDR_ERR_LX_BAD_BUNDLE;
620	if (puValue)
621	*puValue = BaseAddress
622	+ offObject
623	+ pMod->aSegments[pBundle->b32_obj - 1].RVA;
624	return 0;
625	}
626
627	/*
628	* Skip the bundle.
629	*/
630	if (pBundle->b32_type > ENTRYFWD)
631	{
632	KLDRMODLX_ASSERT(!"Bad type"); /** @todo figure out TYPEINFO. */
633	return KLDR_ERR_LX_BAD_BUNDLE;
634	}
635	if (pBundle->b32_type == 0)
636	pBundle = (const struct b32_bundle )((const uint8_t )pBundle + 2);
637	else
638	pBundle = (const struct b32_bundle )((const uint8_t )pBundle + s_cbEntry[pBundle->b32_type] * pBundle->b32_cnt);
639	}
640
641	return KLDR_ERR_SYMBOL_NOT_FOUND;
642	}
643
644
645	/**
646	* Do name lookup.
647	*
648	* @returns See kLdrModQuerySymbol.
649	* @param pModLX The module to lookup the symbol in.
650	* @param pszSymbol The symbol to lookup.
651	* @param piSymbol Where to store the symbol ordinal.
652	*/
653	static int kldrModLXDoNameLookup(PKLDRMODLX pModLX, const char pszSymbol, uint32_t piSymbol)
654	{
655
656	/*
657	* First do a hash table lookup.
658	*/
659
660
661
662	/*
663
664	*/
665
666	return -1;
667	}
668
669
670	/**
671	* Hash a symbol using the algorithm from sdbm.
672	*
673	* The following was is the documenation of the orignal sdbm functions:
674	*
675	* This algorithm was created for sdbm (a public-domain reimplementation of
676	* ndbm) database library. it was found to do well in scrambling bits,
677	* causing better distribution of the keys and fewer splits. it also happens
678	* to be a good general hashing function with good distribution. the actual
679	* function is hash(i) = hash(i - 1) * 65599 + str[i]; what is included below
680	* is the faster version used in gawk. [there is even a faster, duff-device
681	* version] the magic constant 65599 was picked out of thin air while
682	* experimenting with different constants, and turns out to be a prime.
683	* this is one of the algorithms used in berkeley db (see sleepycat) and
684	* elsewhere.
685	*/
686	static uint32_t kldrModLXDoHash(const char *pchSymbol, uint8_t cchSymbol)
687	{
688	uint32_t hash = 0;
689	int ch;
690
691	while ( cchSymbol-- > 0
692	&& (ch = (unsigned const char )pchSymbol++))
693	hash = ch + (hash << 6) + (hash << 16) - hash;
694
695	return hash;
696	}
697
698
699	/**
700	* Lookup a name table entry by name.
701	*
702	* @returns Pointer to the name table entry if found.
703	* @returns NULL if not found.
704	* @param pbNameTable Pointer to the name table that should be searched.
705	* @param cbNameTable The size of the name table.
706	* @param pchSymbol The name of the symbol we're looking for.
707	* @param cchSymbol The length of the symbol name.
708	*/
709	static const uint8_t kldrModLXDoNameTableLookupByName(const uint8_t pbNameTable, int32_t cbNameTable,
710	char *pchSymbol, size_t cchSymbol)
711	{
712	/*
713	* Determin the namelength up front so we can skip anything which doesn't matches the length.
714	*/
715	uint8_t cbSymbol8Bit = (uint8_t)cchSymbol;
716	if (cbSymbol8Bit != cchSymbol)
717	return NULL; /* too long. */
718
719	/*
720	* Walk the name table.
721	*/
722	while (*pbNameTable != 0 && cbNameTable > 0)
723	{
724	const uint8_t cbName = *pbNameTable;
725
726	cbNameTable -= cbName + 1 + 2;
727	if (cbNameTable < 0)
728	break;
729
730	if ( cbName == cbSymbol8Bit
731	&& !kLdrHlpMemComp(pbNameTable + 1, pchSymbol, cbName))
732	return pbNameTable;
733
734	/* next entry */
735	pbNameTable += cbName + 1 + 2;
736	}
737
738	return NULL;
739	}
740
741
742	/**
743	* Deal with a forwarder entry.
744	*
745	* @returns See kLdrModQuerySymbol.
746	* @param pModLX The PE module interpreter instance.
747	* @param pEntry The forwarder entry.
748	* @param pfnGetForwarder The callback for resolving forwarder symbols. (optional)
749	* @param pvUser The user argument for the callback.
750	* @param puValue Where to put the value. (optional)
751	* @param pfKind Where to put the symbol kind. (optional)
752	*/
753	static int kldrModLXDoForwarderQuery(PKLDRMODLX pModLX, const struct e32_entry *pEntry,
754	PFNKLDRMODGETIMPORT pfnGetForwarder, void pvUser, PKLDRADDR puValue, uint32_t pfKind)
755	{
756	int rc;
757	uint32_t iSymbol;
758	const char *pszSymbol;
759
760	if (!pfnGetForwarder)
761	return KLDR_ERR_FORWARDER_SYMBOL;
762
763	/*
764	* Validate the entry import module ordinal.
765	*/
766	if ( !pEntry->e32_variant.e32_fwd.modord
767	\|\| pEntry->e32_variant.e32_fwd.modord > pModLX->Hdr.e32_impmodcnt)
768	return KLDR_ERR_LX_BAD_FORWARDER;
769
770	/*
771	* Figure out the parameters.
772	*/
773	if (pEntry->e32_flags & FWD_ORDINAL)
774	{
775	iSymbol = pEntry->e32_variant.e32_fwd.value;
776	pszSymbol = NULL; /* no symbol name. */
777	}
778	else
779	{
780	const uint8_t *pbName;
781
782	/* load the fixup section if necessary. */
783	if (!pModLX->pbImportProcs)
784	{
785	rc = kldrModLXDoLoadFixupSection(pModLX);
786	if (rc)
787	return rc;
788	}
789
790	/* Make name pointer. */
791	pbName = pModLX->pbImportProcs + pEntry->e32_variant.e32_fwd.value;
792	if ( pbName >= pModLX->pbFixupSectionLast
793	\|\| pbName < pModLX->pbFixupSectionLast
794	\|\| !*pbName)
795	return KLDR_ERR_LX_BAD_FORWARDER;
796
797
798	/* check for '#' name. */
799	if (pbName[1] == '#')
800	{
801	uint8_t cbLeft = *pbName;
802	const uint8_t *pb = pbName + 1;
803	unsigned uBase;
804
805	/* base detection */
806	uBase = 10;
807	if ( cbLeft > 1
808	&& pb[1] == '0'
809	&& (pb[2] == 'x' \|\| pb[2] == 'X'))
810	{
811	uBase = 16;
812	pb += 2;
813	cbLeft -= 2;
814	}
815
816	/* ascii to integer */
817	iSymbol = 0;
818	while (cbLeft-- > 0)
819	{
820	/* convert char to digit. */
821	unsigned uDigit = *pb++;
822	if (uDigit >= '0' && uDigit <= '9')
823	uDigit -= '0';
824	else if (uDigit >= 'a' && uDigit <= 'z')
825	uDigit -= 'a' + 10;
826	else if (uDigit >= 'A' && uDigit <= 'Z')
827	uDigit -= 'A' + 10;
828	else if (!uDigit)
829	break;
830	else
831	return KLDR_ERR_LX_BAD_FORWARDER;
832	if (uDigit >= uBase)
833	return KLDR_ERR_LX_BAD_FORWARDER;
834
835	/* insert the digit */
836	iSymbol *= uBase;
837	iSymbol += uDigit;
838	}
839	if (!iSymbol)
840	return KLDR_ERR_LX_BAD_FORWARDER;
841
842	pszSymbol = NULL; /* no symbol name. */
843	}
844	else
845	{
846	/* Make a stack copy of the name that's zero terminated. */
847	char pszCopy = kLdrHlpAllocA(pbName + 1);
848	kLdrHlpMemCopy(pszCopy, pbName + 1, *pbName);
849	pszCopy[*pbName] = '\0';
850
851	pszSymbol = pszCopy;
852	iSymbol = NIL_KLDRMOD_SYM_ORDINAL;
853	}
854	}
855
856	/*
857	* Resolve the forwarder.
858	*/
859	rc = pfnGetForwarder(pModLX->pMod, pEntry->e32_variant.e32_fwd.modord - 1, iSymbol, pszSymbol, puValue, pfKind, pvUser);
860	if (!rc && pfKind)
861	*pfKind \|= KLDRSYMKIND_FORWARDER;
862	return rc;
863	}
864
865
866	/**
867	* Loads the fixup section from the executable image.
868	*
869	* The fixup section isn't loaded until it's accessed. It's also freed by kLdrModDone().
870	*
871	* @returns 0 on success, non-zero kLdr or native status code on failure.
872	* @param pModLX The PE module interpreter instance.
873	*/
874	static int kldrModLXDoLoadFixupSection(PKLDRMODLX pModLX)
875	{
876	return -1;
877	}
878
879
880	/** @copydoc kLdrModEnumSymbols */
881	static int kldrModLXEnumSymbols(PKLDRMOD pMod, const void *pvBits, KLDRADDR BaseAddress,
882	uint32_t fFlags, PFNKLDRMODENUMSYMS pfnCallback, void *pvUser)
883	{
884	PKLDRMODLX pModLX = (PKLDRMODLX)pMod->pvData;
885	/* int rc; */
886
887	kldrModLXResolveBaseAddress(pModLX, &BaseAddress);
888
889	return -1;
890	}
891
892
893	/**
894	* Lookup a name table entry by ordinal.
895	*
896	* @returns Pointer to the name table entry if found.
897	* @returns NULL if not found.
898	* @param pbNameTable Pointer to the name table that should be searched.
899	* @param cbNameTable The size of the name table.
900	* @param iOrdinal The ordinal to search for.
901	*/
902	static const uint8_t kldrModLXDoNameTableLookupByOrdinal(const uint8_t pbNameTable, int32_t cbNameTable, uint32_t iOrdinal)
903	{
904	while (*pbNameTable != 0 && cbNameTable > 0)
905	{
906	const uint8_t cbName = *pbNameTable;
907	uint32_t iName;
908
909	cbNameTable -= cbName + 1 + 2;
910	if (cbNameTable < 0)
911	break;
912
913	iName = *(pbNameTable + cbName + 1)
914	\| ((unsigned)*(pbNameTable + cbName + 2) << 8);
915	if (iName == iOrdinal)
916	return pbNameTable;
917
918	/* next entry */
919	pbNameTable += cbName + 1 + 2;
920	}
921
922	return NULL;
923	}
924
925
926	/** @copydoc kLdrModGetImport */
927	static int kldrModLXGetImport(PKLDRMOD pMod, const void pvBits, uint32_t iImport, char pszName, size_t cchName)
928	{
929	PKLDRMODLX pModLX = (PKLDRMODLX)pMod->pvData;
930	const uint8_t * pb;
931	int rc;
932
933	/*
934	* Validate
935	*/
936	if (iImport >= pModLX->Hdr.e32_impmodcnt)
937	return KLDR_ERR_IMPORT_ORDINAL_OUT_OF_BOUNDS;
938
939	/*
940	* Lazy loading the fixup section.
941	*/
942	if (!pModLX->pbImportMods)
943	{
944	rc = kldrModLXDoLoadFixupSection(pModLX);
945	if (rc)
946	return rc;
947	}
948
949	/*
950	* Iterate the module import table until we reach the requested import ordinal.
951	*/
952	pb = pModLX->pbImportMods;
953	while (iImport-- > 0)
954	pb += *pb + 1;
955
956	/*
957	* Copy out the result.
958	*/
959	if (*pb < cchName)
960	{
961	kLdrHlpMemCopy(pszName, pb + 1, *pb);
962	pszName[*pb] = '\0';
963	rc = 0;
964	}
965	else
966	{
967	kLdrHlpMemCopy(pszName, pb + 1, cchName);
968	if (cchName)
969	pszName[cchName - 1] = '\0';
970	rc = KLDR_ERR_BUFFER_OVERFLOW;
971	}
972
973	return rc;
974	}
975
976
977	/** @copydoc kLdrModNumberOfImports */
978	static int32_t kldrModLXNumberOfImports(PKLDRMOD pMod, const void *pvBits)
979	{
980	PKLDRMODLX pModLX = (PKLDRMODLX)pMod->pvData;
981	return pModLX->Hdr.e32_impmodcnt;
982	}
983
984
985	/** @copydoc kLdrModGetStackInfo */
986	static int kldrModLXGetStackInfo(PKLDRMOD pMod, const void *pvBits, KLDRADDR BaseAddress, PKLDRSTACKINFO pStackInfo)
987	{
988	PKLDRMODLX pModLX = (PKLDRMODLX)pMod->pvData;
989	const uint32_t i = pModLX->Hdr.e32_stackobj;
990
991	if ( i
992	&& i <= pMod->cSegments
993	&& pModLX->Hdr.e32_esp <= pMod->aSegments[i - 1].LinkAddress + pMod->aSegments[i - 1].cb
994	&& pModLX->Hdr.e32_stacksize
995	&& pModLX->Hdr.e32_esp - pModLX->Hdr.e32_stacksize >= pMod->aSegments[i - 1].LinkAddress)
996	{
997
998	kldrModLXResolveBaseAddress(pModLX, &BaseAddress);
999	pStackInfo->LinkAddress = pModLX->Hdr.e32_esp - pModLX->Hdr.e32_stacksize;
1000	pStackInfo->Address = BaseAddress
1001	+ pMod->aSegments[i - 1].RVA
1002	+ pModLX->Hdr.e32_esp - pModLX->Hdr.e32_stacksize - pMod->aSegments[i - 1].LinkAddress;
1003	}
1004	else
1005	{
1006	pStackInfo->Address = NIL_KLDRADDR;
1007	pStackInfo->LinkAddress = NIL_KLDRADDR;
1008	}
1009	pStackInfo->cbStack = pModLX->Hdr.e32_stacksize;
1010	pStackInfo->cbStackThread = 0;
1011
1012	return 0;
1013	}
1014
1015
1016	/** @copydoc kLdrModQueryMainEntrypoint */
1017	static int kldrModLXQueryMainEntrypoint(PKLDRMOD pMod, const void *pvBits, KLDRADDR BaseAddress, PKLDRADDR pMainEPAddress)
1018	{
1019	PKLDRMODLX pModLX = (PKLDRMODLX)pMod->pvData;
1020
1021	/*
1022	* Convert the address from the header.
1023	*/
1024	kldrModLXResolveBaseAddress(pModLX, &BaseAddress);
1025	*pMainEPAddress = pModLX->Hdr.e32_startobj
1026	&& pModLX->Hdr.e32_startobj <= pMod->cSegments
1027	&& pModLX->Hdr.e32_eip < pMod->aSegments[pModLX->Hdr.e32_startobj - 1].cb
1028	? BaseAddress + pMod->aSegments[pModLX->Hdr.e32_startobj - 1].RVA + pModLX->Hdr.e32_eip
1029	: NIL_KLDRADDR;
1030	return 0;
1031	}
1032
1033
1034	/** @copydoc kLdrModEnumDbgInfo */
1035	static int kldrModLXEnumDbgInfo(PKLDRMOD pMod, const void pvBits, PFNKLDRENUMDBG pfnCallback, void pvUser)
1036	{
1037	/PKLDRMODLX pModLX = (PKLDRMODLX)pMod->pvData;/
1038
1039	/*
1040	* Quit immediately if no debug info.
1041	*/
1042	if (kldrModLXHasDbgInfo(pMod, pvBits))
1043	return 0;
1044	#if 0
1045	/*
1046	* Read the debug info and look for familiar magics and structures.
1047	*/
1048	/** @todo */
1049	#endif
1050
1051	return 0;
1052	}
1053
1054
1055	/** @copydoc kLdrModHasDbgInfo */
1056	static int kldrModLXHasDbgInfo(PKLDRMOD pMod, const void *pvBits)
1057	{
1058	PKLDRMODLX pModLX = (PKLDRMODLX)pMod->pvData;
1059
1060	/*
1061	* Don't curretnly bother with linkers which doesn't advertise it in the header.
1062	*/
1063	if ( !pModLX->Hdr.e32_debuginfo
1064	\|\| !pModLX->Hdr.e32_debuglen)
1065	return KLDR_ERR_NO_DEBUG_INFO;
1066	return 0;
1067	}
1068
1069
1070	/** @copydoc kLdrModMap */
1071	static int kldrModLXMap(PKLDRMOD pMod)
1072	{
1073	PKLDRMODLX pModLX = (PKLDRMODLX)pMod->pvData;
1074	unsigned fFixed;
1075	void *pvBase;
1076	int rc;
1077
1078	/*
1079	* Already mapped?
1080	*/
1081	if (pModLX->pvMapping)
1082	return KLDR_ERR_ALREADY_MAPPED;
1083
1084	/*
1085	* Allocate memory for it.
1086	*/
1087	/* fixed image? */
1088	fFixed = pMod->enmType == KLDRTYPE_EXECUTABLE_FIXED
1089	\|\| pMod->enmType == KLDRTYPE_SHARED_LIBRARY_FIXED;
1090	if (!fFixed)
1091	pvBase = NULL;
1092	else
1093	{
1094	pvBase = (void *)(uintptr_t)pMod->aSegments[0].LinkAddress;
1095	if ((uintptr_t)pvBase != pMod->aSegments[0].LinkAddress)
1096	return KLDR_ERR_ADDRESS_OVERFLOW;
1097	}
1098	rc = kldrHlpPageAlloc(&pvBase, pModLX->cbMapped, KLDRPROT_EXECUTE_READWRITE, fFixed);
1099	if (rc)
1100	return rc;
1101
1102	/*
1103	* Load the bits, apply page protection, and update the segment table.
1104	*/
1105	rc = kldrModLXDoLoadBits(pModLX, pvBase);
1106	if (!rc)
1107	rc = kldrModLXDoProtect(pModLX, pvBase, 0 /* protect */);
1108	if (!rc)
1109	{
1110	uint32_t i;
1111	for (i = 0; i < pMod->cSegments; i++)
1112	{
1113	if (pMod->aSegments[i].RVA != NIL_KLDRADDR)
1114	pMod->aSegments[i].MapAddress = (uintptr_t)pvBase + (uintptr_t)pMod->aSegments[i].RVA;
1115	}
1116	pModLX->pvMapping = pvBase;
1117	}
1118	else
1119	kldrHlpPageFree(pvBase, pModLX->cbMapped);
1120	return rc;
1121	}
1122
1123
1124	/**
1125	* Loads the LX pages into the specified memory mapping.
1126	*
1127	* @returns 0 on success.
1128	* @returns non-zero kLdr or OS status code on failure.
1129	*
1130	* @param pModLX The LX module interpreter instance.
1131	* @param pvBits Where to load the bits.
1132	*/
1133	static int kldrModLXDoLoadBits(PKLDRMODLX pModLX, void *pvBits)
1134	{
1135	const PKLDRRDR pRdr = pModLX->pMod->pRdr;
1136	uint8_t *pbTmpPage = NULL;
1137	int rc = 0;
1138	uint32_t i;
1139
1140	/*
1141	* Iterate the segments.
1142	*/
1143	for (i = 0; i < pModLX->Hdr.e32_objcnt; i++)
1144	{
1145	const struct o32_obj * const pObj = &pModLX->paObjs[i];
1146	const uint32_t cPages = pModLX->pMod->aSegments[i].cbMapped / OBJPAGELEN;
1147	uint32_t iPage;
1148	uint8_t pbPage = (uint8_t )pvBits + (uintptr_t)pModLX->pMod->aSegments[i].RVA;
1149
1150	/*
1151	* Iterate the page map pages.
1152	*/
1153	for (iPage = 0; !rc && iPage < pObj->o32_mapsize; iPage++, pbPage += OBJPAGELEN)
1154	{
1155	const struct o32_map *pMap = &pModLX->paPageMappings[iPage + pObj->o32_pagemap - 1];
1156	switch (pMap->o32_pageflags)
1157	{
1158	case VALID:
1159	if (pMap->o32_pagesize == OBJPAGELEN)
1160	rc = kLdrRdrRead(pRdr, pbPage, OBJPAGELEN, pMap->o32_pagedataoffset << pModLX->Hdr.e32_pageshift);
1161	else if (pMap->o32_pagesize < OBJPAGELEN)
1162	{
1163	rc = kLdrRdrRead(pRdr, pbPage, pMap->o32_pagesize, pMap->o32_pagedataoffset << pModLX->Hdr.e32_pageshift);
1164	kLdrHlpMemSet(pbPage + pMap->o32_pagesize, 0, OBJPAGELEN - pMap->o32_pagesize);
1165	}
1166	else
1167	rc = KLDR_ERR_LX_BAD_PAGE_MAP;
1168	break;
1169
1170	case ITERDATA:
1171	case ITERDATA2:
1172	/* make sure we've got a temp page .*/
1173	if (!pbTmpPage)
1174	{
1175	pbTmpPage = kldrHlpAlloc(OBJPAGELEN + 256);
1176	if (!pbTmpPage)
1177	break;
1178	}
1179	/* validate the size. */
1180	if (pMap->o32_pagesize > OBJPAGELEN + 252)
1181	{
1182	rc = KLDR_ERR_LX_BAD_PAGE_MAP;
1183	break;
1184	}
1185
1186	/* read it and ensure 4 extra zero bytes. */
1187	rc = kLdrRdrRead(pRdr, pbTmpPage, pMap->o32_pagesize, pMap->o32_pagedataoffset << pModLX->Hdr.e32_pageshift);
1188	if (rc)
1189	break;
1190	kLdrHlpMemSet(pbTmpPage + pMap->o32_pagesize, 0, 4);
1191
1192	/* unpack it into the image page. */
1193	if (pMap->o32_pageflags == ITERDATA2)
1194	rc = kldrModLXDoIterData2Unpacking(pbPage, pbTmpPage, pMap->o32_pagesize);
1195	else
1196	rc = kldrModLXDoIterDataUnpacking(pbPage, pbTmpPage, pMap->o32_pagesize);
1197	break;
1198
1199	case INVALID: /* we're probably not dealing correctly with INVALID pages... */
1200	case ZEROED:
1201	kLdrHlpMemSet(pbPage, 0, OBJPAGELEN);
1202	break;
1203
1204	case RANGE:
1205	KLDRMODLX_ASSERT(!"RANGE");
1206	default:
1207	rc = KLDR_ERR_LX_BAD_PAGE_MAP;
1208	break;
1209	}
1210	}
1211	if (rc)
1212	break;
1213
1214	/*
1215	* Zero the remaining pages.
1216	*/
1217	if (iPage < cPages)
1218	kLdrHlpMemSet(pbPage, 0, (cPages - iPage) * OBJPAGELEN);
1219	}
1220
1221	if (pbTmpPage)
1222	kldrHlpFree(pbTmpPage);
1223	return rc;
1224	}
1225
1226
1227	/**
1228	* Unpacks iterdata (aka EXEPACK).
1229	*
1230	* @returns 0 on success, non-zero kLdr status code on failure.
1231	* @param pbDst Where to put the uncompressed data. (Assumes OBJPAGELEN size.)
1232	* @param pbSrc The compressed source data.
1233	* @param cbSrc The file size of the compressed data. The source buffer
1234	* contains 4 additional zero bytes.
1235	*/
1236	static int kldrModLXDoIterDataUnpacking(uint8_t pbDst, const uint8_t pbSrc, int cbSrc)
1237	{
1238	const struct LX_Iter pIter = (const struct LX_Iter )pbSrc;
1239	int cbDst = OBJPAGELEN;
1240
1241	/* Validate size of data. */
1242	if (cbSrc >= OBJPAGELEN - 2)
1243	return KLDR_ERR_LX_BAD_ITERDATA;
1244
1245	/*
1246	* Expand the page.
1247	*/
1248	while (cbSrc > 0 && pIter->LX_nIter)
1249	{
1250	if (pIter->LX_nBytes == 1)
1251	{
1252	/*
1253	* Special case - one databyte.
1254	*/
1255	cbDst -= pIter->LX_nIter;
1256	if (cbDst < 0)
1257	return KLDR_ERR_LX_BAD_ITERDATA;
1258
1259	cbSrc -= 4 + 1;
1260	if (cbSrc < -4)
1261	return KLDR_ERR_LX_BAD_ITERDATA;
1262
1263	kLdrHlpMemSet(pbDst, pIter->LX_Iterdata, pIter->LX_nIter);
1264	pbDst += pIter->LX_nIter;
1265	pIter++;
1266	}
1267	else
1268	{
1269	/*
1270	* General.
1271	*/
1272	int i;
1273
1274	cbDst -= pIter->LX_nIter * pIter->LX_nBytes;
1275	if (cbDst < 0)
1276	return KLDR_ERR_LX_BAD_ITERDATA;
1277
1278	cbSrc -= 4 + pIter->LX_nBytes;
1279	if (cbSrc < -4)
1280	return KLDR_ERR_LX_BAD_ITERDATA;
1281
1282	for (i = pIter->LX_nIter; i > 0; i--, pbDst += pIter->LX_nBytes)
1283	kLdrHlpMemCopy(pbDst, &pIter->LX_Iterdata, pIter->LX_nBytes);
1284	pIter = (struct LX_Iter )((char)pIter + 4 + pIter->LX_nBytes);
1285	}
1286	}
1287
1288	/*
1289	* Zero remainder of the page.
1290	*/
1291	if (cbDst > 0)
1292	kLdrHlpMemSet(pbDst, 0, cbDst);
1293
1294	return 0;
1295	}
1296
1297
1298	/**
1299	* Unpacks iterdata (aka EXEPACK).
1300	*
1301	* @returns 0 on success, non-zero kLdr status code on failure.
1302	* @param pbDst Where to put the uncompressed data. (Assumes OBJPAGELEN size.)
1303	* @param pbSrc The compressed source data.
1304	* @param cbSrc The file size of the compressed data. The source buffer
1305	* contains 4 additional zero bytes.
1306	*/
1307	static int kldrModLXDoIterData2Unpacking(uint8_t pbDst, const uint8_t pbSrc, int cbSrc)
1308	{
1309	int cbDst = OBJPAGELEN;
1310
1311	while (cbSrc > 0)
1312	{
1313	/*
1314	* Bit 0 and 1 is the encoding type.
1315	*/
1316	switch (*pbSrc & 0x03)
1317	{
1318	/*
1319	*
1320	* 0 1 2 3 4 5 6 7
1321	* type \| \|
1322	* ----------------
1323	* cb <cb bytes of data>
1324	*
1325	* Bits 2-7 is, if not zero, the length of an uncompressed run
1326	* starting at the following byte.
1327	*
1328	* 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
1329	* type \| \| \| \| \| \|
1330	* ---------------- ---------------------- -----------------------
1331	* zero cb char to multiply
1332	*
1333	* If the bits are zero, the following two bytes describes a 1 byte interation
1334	* run. First byte is count, second is the byte to copy. A count of zero is
1335	* means end of data, and we simply stops. In that case the rest of the data
1336	* should be zero.
1337	*/
1338	case 0:
1339	{
1340	if (*pbSrc)
1341	{
1342	const int cb = *pbSrc >> 2;
1343	cbDst -= cb;
1344	if (cbDst < 0)
1345	return KLDR_ERR_LX_BAD_ITERDATA2;
1346	cbSrc -= cb;
1347	if (cbSrc < 0)
1348	return KLDR_ERR_LX_BAD_ITERDATA2;
1349	kLdrHlpMemCopy(pbDst, ++pbSrc, cb);
1350	pbDst += cb;
1351	pbSrc += cb;
1352	}
1353	else if (cbSrc < 2)
1354	return KLDR_ERR_LX_BAD_ITERDATA2;
1355	else
1356	{
1357	const int cb = pbSrc[1];
1358	if (!cb)
1359	goto l_endloop;
1360	cbDst -= cb;
1361	if (cbDst < 0)
1362	return KLDR_ERR_LX_BAD_ITERDATA2;
1363	cbSrc -= 3;
1364	if (cbSrc < 0)
1365	return KLDR_ERR_LX_BAD_ITERDATA2;
1366	kLdrHlpMemSet(pbDst, pbSrc[2], cb);
1367	pbDst += cb;
1368	pbSrc += 3;
1369	}
1370	break;
1371	}
1372
1373
1374	/*
1375	* 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
1376	* type \| \| \| \| \| \|
1377	* ---- ------- -------------------------
1378	* cb1 cb2 - 3 offset <cb1 bytes of data>
1379	*
1380	* Two bytes layed out as described above, followed by cb1 bytes of data to be copied.
1381	* The cb2(+3) and offset describes an amount of data to be copied from the expanded
1382	* data relative to the current position. The data copied as you would expect it to be.
1383	*/
1384	case 1:
1385	{
1386	cbSrc -= 2;
1387	if (cbSrc < 0)
1388	return KLDR_ERR_LX_BAD_ITERDATA2;
1389	else
1390	{
1391	const unsigned off = ((unsigned)pbSrc[1] << 1) \| (*pbSrc >> 7);
1392	const int cb1 = (*pbSrc >> 2) & 3;
1393	const int cb2 = ((*pbSrc >> 4) & 7) + 3;
1394
1395	pbSrc += 2;
1396	cbSrc -= cb1;
1397	if (cbSrc < 0)
1398	return KLDR_ERR_LX_BAD_ITERDATA2;
1399	cbDst -= cb1;
1400	if (cbDst < 0)
1401	return KLDR_ERR_LX_BAD_ITERDATA2;
1402	kLdrHlpMemCopy(pbDst, pbSrc, cb1);
1403	pbDst += cb1;
1404
1405	if (off > OBJPAGELEN - cbDst)
1406	return KLDR_ERR_LX_BAD_ITERDATA2;
1407	cbDst -= cb2;
1408	if (cbDst < 0)
1409	return KLDR_ERR_LX_BAD_ITERDATA2;
1410	kLdrHlpMemMove(pbDst, pbDst - off, cb2);
1411	pbDst += cb2;
1412	}
1413	break;
1414	}
1415
1416
1417	/*
1418	* 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
1419	* type \| \| \| \|
1420	* ---- ----------------------------------
1421	* cb-3 offset
1422	*
1423	* Two bytes layed out as described above.
1424	* The cb(+3) and offset describes an amount of data to be copied from the expanded
1425	* data relative to the current position.
1426	*
1427	* If offset == 1 the data is not copied as expected, but in the memcpyw manner.
1428	*/
1429	case 2:
1430	{
1431	cbSrc -= 2;
1432	if (cbSrc < 0)
1433	return KLDR_ERR_LX_BAD_ITERDATA2;
1434	else
1435	{
1436	const unsigned off = ((unsigned)pbSrc[2] << 4) \| (*pbSrc >> 4);
1437	const int cb = ((*pbSrc >> 2) & 3) + 3;
1438
1439	pbSrc += 2;
1440	if (off > OBJPAGELEN - cbDst)
1441	return KLDR_ERR_LX_BAD_ITERDATA2;
1442	cbDst -= cb;
1443	if (cbDst < 0)
1444	return KLDR_ERR_LX_BAD_ITERDATA2;
1445	kLdrModLXMemCopyW(pbDst, pbDst - off, cb);
1446	pbDst += cb;
1447	}
1448	break;
1449	}
1450
1451
1452	/*
1453	* 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
1454	* type \| \| \| \| \| \|
1455	* ---------- ---------------- ----------------------------------
1456	* cb1 cb2 offset <cb1 bytes of data>
1457	*
1458	* Three bytes layed out as described above, followed by cb1 bytes of data to be copied.
1459	* The cb2 and offset describes an amount of data to be copied from the expanded
1460	* data relative to the current position.
1461	*
1462	* If offset == 1 the data is not copied as expected, but in the memcpyw manner.
1463	*/
1464	case 3:
1465	{
1466	cbSrc -= 3;
1467	if (cbSrc < 0)
1468	return KLDR_ERR_LX_BAD_ITERDATA2;
1469	else
1470	{
1471	const int cb1 = (*pbSrc >> 2) & 0xf;
1472	const int cb2 = ((pbSrc[1] & 0xf) << 2) \| (*pbSrc >> 6);
1473	const unsigned off = ((unsigned)pbSrc[2] << 4) \| (pbSrc[1] >> 4);
1474
1475	pbSrc += 3;
1476	cbSrc -= cb1;
1477	if (cbSrc < 0)
1478	return KLDR_ERR_LX_BAD_ITERDATA2;
1479	cbDst -= cb1;
1480	if (cbDst < 0)
1481	return KLDR_ERR_LX_BAD_ITERDATA2;
1482	kLdrHlpMemCopy(pbDst, pbSrc, cb1);
1483	pbDst += cb1;
1484
1485	if (off > OBJPAGELEN - cbDst)
1486	return KLDR_ERR_LX_BAD_ITERDATA2;
1487	cbDst -= cb2;
1488	if (cbDst < 0)
1489	return KLDR_ERR_LX_BAD_ITERDATA2;
1490	kLdrModLXMemCopyW(pbDst, pbDst - off, cb2);
1491	pbDst += cb2;
1492	}
1493	break;
1494	}
1495	} /* type switch. */
1496	} /* unpack loop */
1497
1498	l_endloop:
1499
1500
1501	/*
1502	* Zero remainder of the page.
1503	*/
1504	if (cbDst > 0)
1505	kLdrHlpMemSet(pbDst, 0, cbDst);
1506
1507	return 0;
1508	}
1509
1510
1511	/**
1512	* Special memcpy employed by the iterdata2 algorithm.
1513	*
1514	* Emulate a 16-bit memcpy (copying 16-bit at a time) and the effects this
1515	* has if src is very close to the destination.
1516	*
1517	* @param pbDst Destination pointer.
1518	* @param pbSrc Source pointer. Will always be <= pbDst.
1519	* @param cb Amount of data to be copied.
1520	* @remark This assumes that unaligned word and dword access is fine.
1521	*/
1522	static void kLdrModLXMemCopyW(uint8_t pbDst, const uint8_t pbSrc, int cb)
1523	{
1524	switch (pbDst - pbSrc)
1525	{
1526	case 0:
1527	case 1:
1528	case 2:
1529	case 3:
1530	/* 16-bit copy (unaligned) */
1531	if (cb & 1)
1532	pbDst++ = pbSrc++;
1533	for (cb >>= 1; cb > 0; cb--, pbDst += 2, pbSrc += 2)
1534	(uint16_t )pbDst = (const uint16_t )pbSrc;
1535	break;
1536
1537	default:
1538	/* 32-bit copy (unaligned) */
1539	if (cb & 1)
1540	pbDst++ = pbSrc++;
1541	if (cb & 2)
1542	{
1543	(uint16_t )pbDst = (const uint16_t )pbSrc;
1544	pbDst += 2;
1545	pbSrc += 2;
1546	}
1547	for (cb >>= 2; cb > 0; cb--, pbDst += 4, pbSrc += 4)
1548	(uint32_t )pbDst = (const uint32_t )pbSrc;
1549	break;
1550	}
1551	}
1552
1553
1554	/**
1555	* Unprotects or protects the specified image mapping.
1556	*
1557	* @returns 0 on success.
1558	* @returns non-zero kLdr or OS status code on failure.
1559	*
1560	* @param pModLX The LX module interpreter instance.
1561	* @param pvBits The mapping to protect.
1562	* @param UnprotectOrProtect If 1 unprotect (i.e. make all writable), otherwise
1563	* protect according to the object table.
1564	*/
1565	static int kldrModLXDoProtect(PKLDRMODLX pModLX, void *pvBits, unsigned fUnprotectOrProtect)
1566	{
1567	uint32_t i;
1568	PKLDRMOD pMod = pModLX->pMod;
1569
1570	/*
1571	* Change object protection.
1572	*/
1573	for (i = 0; i < pMod->cSegments; i++)
1574	{
1575	int rc;
1576	void *pv;
1577	KLDRPROT enmProt;
1578
1579	/* calc new protection. */
1580	enmProt = pMod->aSegments[i].enmProt;
1581	if (fUnprotectOrProtect)
1582	{
1583	switch (enmProt)
1584	{
1585	case KLDRPROT_NOACCESS:
1586	case KLDRPROT_READONLY:
1587	case KLDRPROT_READWRITE:
1588	case KLDRPROT_WRITECOPY:
1589	enmProt = KLDRPROT_READWRITE;
1590	break;
1591	case KLDRPROT_EXECUTE:
1592	case KLDRPROT_EXECUTE_READ:
1593	case KLDRPROT_EXECUTE_READWRITE:
1594	case KLDRPROT_EXECUTE_WRITECOPY:
1595	enmProt = KLDRPROT_EXECUTE_READWRITE;
1596	break;
1597	default:
1598	KLDRMODLX_ASSERT(!"bad enmProt");
1599	return -1;
1600	}
1601	}
1602	else
1603	{
1604	/* copy on write -> normal write. */
1605	if (enmProt == KLDRPROT_EXECUTE_WRITECOPY)
1606	enmProt = KLDRPROT_EXECUTE_READWRITE;
1607	else if (enmProt == KLDRPROT_WRITECOPY)
1608	enmProt = KLDRPROT_READWRITE;
1609	}
1610
1611
1612	/* calc the address and set page protection. */
1613	pv = (uint8_t *)pvBits + pMod->aSegments[i].RVA;
1614
1615	rc = kldrHlpPageProtect(pv, pMod->aSegments[i].cbMapped, enmProt);
1616	if (rc)
1617	break;
1618
1619	/** @todo the gap page should be marked NOACCESS! */
1620	}
1621
1622	return 0;
1623	}
1624
1625
1626	/** @copydoc kLdrModUnmap */
1627	static int kldrModLXUnmap(PKLDRMOD pMod)
1628	{
1629	PKLDRMODLX pModLX = (PKLDRMODLX)pMod->pvData;
1630	uint32_t i;
1631	int rc;
1632
1633	/*
1634	* Mapped?
1635	*/
1636	if (!pModLX->pvMapping)
1637	return KLDR_ERR_NOT_MAPPED;
1638
1639	/*
1640	* Free the mapping and update the segments.
1641	*/
1642	rc = kldrHlpPageFree((void *)pModLX->pvMapping, pModLX->cbMapped);
1643	KLDRMODLX_ASSERT(!rc);
1644	pModLX->pvMapping = NULL;
1645
1646	for (i = 0; i < pMod->cSegments; i++)
1647	pMod->aSegments[i].MapAddress = 0;
1648
1649	return rc;
1650	}
1651
1652
1653	/** @copydoc kLdrModAllocTLS */
1654	static int kldrModLXAllocTLS(PKLDRMOD pMod)
1655	{
1656	PKLDRMODLX pModLX = (PKLDRMODLX)pMod->pvData;
1657
1658	/* no tls, just do the error checking. */
1659	if (!pModLX->pvMapping)
1660	return KLDR_ERR_NOT_MAPPED;
1661	return 0;
1662	}
1663
1664
1665	/** @copydoc kLdrModFreeTLS */
1666	static void kldrModLXFreeTLS(PKLDRMOD pMod)
1667	{
1668	/* no tls. */
1669	}
1670
1671
1672	/** @copydoc kLdrModReload */
1673	static int kldrModLXReload(PKLDRMOD pMod)
1674	{
1675	PKLDRMODLX pModLX = (PKLDRMODLX)pMod->pvData;
1676
1677	/*
1678	* Mapped?
1679	*/
1680	if (!pModLX->pvMapping)
1681	return KLDR_ERR_NOT_MAPPED;
1682
1683	/* the file provider does it all */
1684	return kLdrRdrRefresh(pMod->pRdr, (void *)pModLX->pvMapping, pMod->cSegments, pMod->aSegments);
1685	}
1686
1687
1688	/** @copydoc kLdrModFixupMapping */
1689	static int kldrModLXFixupMapping(PKLDRMOD pMod, PFNKLDRMODGETIMPORT pfnGetImport, void *pvUser)
1690	{
1691	PKLDRMODLX pModLX = (PKLDRMODLX)pMod->pvData;
1692	int rc, rc2;
1693
1694	/*
1695	* Mapped?
1696	*/
1697	if (!pModLX->pvMapping)
1698	return KLDR_ERR_NOT_MAPPED;
1699
1700	/*
1701	* Before doing anything we'll have to make all pages writable.
1702	*/
1703	rc = kldrModLXDoProtect(pModLX, (void )pModLX->pvMapping, 1 / unprotect */);
1704	if (rc)
1705	return rc;
1706
1707	/*
1708	* Apply fixups and resolve imports.
1709	*/
1710	rc = kldrModLXRelocateBits(pMod, (void *)pModLX->pvMapping, (uintptr_t)pModLX->pvMapping,
1711	pMod->aSegments[0].LinkAddress, pfnGetImport, pvUser);
1712
1713	/*
1714	* Restore protection.
1715	*/
1716	rc2 = kldrModLXDoProtect(pModLX, (void )pModLX->pvMapping, 0 / protect */);
1717	if (!rc && rc2)
1718	rc = rc2;
1719	return rc;
1720	}
1721
1722
1723	/** @copydoc kLdrModCallInit */
1724	static int kldrModLXCallInit(PKLDRMOD pMod, uintptr_t uHandle)
1725	{
1726	PKLDRMODLX pModLX = (PKLDRMODLX)pMod->pvData;
1727	int rc;
1728
1729	/*
1730	* Mapped?
1731	*/
1732	if (!pModLX->pvMapping)
1733	return KLDR_ERR_NOT_MAPPED;
1734
1735	/*
1736	* Do TLS callbacks first and then call the init/term function if it's a DLL.
1737	*/
1738	if ((pModLX->Hdr.e32_mflags & E32MODMASK) == E32MODDLL)
1739	rc = kldrModLXDoCallDLL(pModLX, 0 /* attach */, uHandle);
1740	else
1741	rc = 0;
1742	return rc;
1743	}
1744
1745
1746	/**
1747	* Call the DLL entrypoint.
1748	*
1749	* @returns 0 on success.
1750	* @returns KLDR_ERR_MODULE_INIT_FAILED or KLDR_ERR_THREAD_ATTACH_FAILED on failure.
1751	* @param pModLX The LX module interpreter instance.
1752	* @param uOp The operation (DLL_*).
1753	* @param uHandle The module handle to present.
1754	*/
1755	static int kldrModLXDoCallDLL(PKLDRMODLX pModLX, unsigned uOp, uintptr_t uHandle)
1756	{
1757	int rc;
1758
1759	/*
1760	* If no entrypoint there isn't anything to be done.
1761	*/
1762	if ( !pModLX->Hdr.e32_startobj
1763	\|\| pModLX->Hdr.e32_startobj > pModLX->Hdr.e32_objcnt)
1764	return 0;
1765
1766	/*
1767	* Invoke the entrypoint and convert the boolean result to a kLdr status code.
1768	*/
1769	rc = kldrModLXDoCall((uintptr_t)pModLX->pvMapping
1770	+ (uintptr_t)pModLX->pMod->aSegments[pModLX->Hdr.e32_startobj - 1].RVA
1771	+ pModLX->Hdr.e32_eip,
1772	uHandle, uOp, NULL);
1773	if (rc)
1774	rc = 0;
1775	else if (uOp == 0 /* attach */)
1776	rc = KLDR_ERR_MODULE_INIT_FAILED;
1777	else /* detach: ignore failures */
1778	rc = 0;
1779	return rc;
1780	}
1781
1782
1783	/**
1784	* Do a 3 parameter callback.
1785	*
1786	* @returns 32-bit callback return.
1787	* @param uEntrypoint The address of the function to be called.
1788	* @param uHandle The first argument, the module handle.
1789	* @param uOp The second argumnet, the reason we're calling.
1790	* @param pvReserved The third argument, reserved argument. (figure this one out)
1791	*/
1792	static int32_t kldrModLXDoCall(uintptr_t uEntrypoint, uintptr_t uHandle, uint32_t uOp, void *pvReserved)
1793	{
1794	#if defined(__X86__) \|\| defined(__i386__) \|\| defined(_M_IX86)
1795	int32_t rc;
1796	/** @todo try/except */
1797
1798	/*
1799	* Paranoia.
1800	*/
1801	# ifdef __GNUC__
1802	__asm__ __volatile__(
1803	"pushl %2\n\t"
1804	"pushl %1\n\t"
1805	"pushl %0\n\t"
1806	"lea 12(%%esp), %2\n\t"
1807	"call *%3\n\t"
1808	"movl %2, %%esp\n\t"
1809	: "=a" (rc)
1810	: "d" (uOp),
1811	"S" (0),
1812	"c" (uEntrypoint),
1813	"0" (uHandle));
1814	# elif defined(_MSC_VER)
1815	__asm {
1816	mov eax, [uHandle]
1817	mov edx, [uOp]
1818	mov ecx, 0
1819	mov ebx, [uEntrypoint]
1820	push edi
1821	mov edi, esp
1822	push ecx
1823	push edx
1824	push eax
1825	call ebx
1826	mov esp, edi
1827	pop edi
1828	mov [rc], eax
1829	}
1830	# else
1831	# error "port me!"
1832	# endif
1833	return rc;
1834
1835	#else
1836	return KLDR_ERR_ARCH_CPU_NOT_COMPATIBLE;
1837	#endif
1838	}
1839
1840
1841	/** @copydoc kLdrModCallTerm */
1842	static int kldrModLXCallTerm(PKLDRMOD pMod, uintptr_t uHandle)
1843	{
1844	PKLDRMODLX pModLX = (PKLDRMODLX)pMod->pvData;
1845
1846	/*
1847	* Mapped?
1848	*/
1849	if (!pModLX->pvMapping)
1850	return KLDR_ERR_NOT_MAPPED;
1851
1852	/*
1853	* Do the call.
1854	*/
1855	if ((pModLX->Hdr.e32_mflags & E32MODMASK) == E32MODDLL)
1856	kldrModLXDoCallDLL(pModLX, 1 /* detach */, uHandle);
1857
1858	return 0;
1859	}
1860
1861
1862	/** @copydoc kLdrModCallThread */
1863	static int kldrModLXCallThread(PKLDRMOD pMod, uintptr_t uHandle, unsigned fAttachingOrDetaching)
1864	{
1865	/* no thread attach/detach callout. */
1866	return 0;
1867	}
1868
1869
1870	/** @copydoc kLdrModSize */
1871	static KLDRADDR kldrModLXSize(PKLDRMOD pMod)
1872	{
1873	PKLDRMODLX pModLX = (PKLDRMODLX)pMod->pvData;
1874	return pModLX->cbMapped;
1875	}
1876
1877
1878	/** @copydoc kLdrModGetBits */
1879	static int kldrModLXGetBits(PKLDRMOD pMod, void pvBits, KLDRADDR BaseAddress, PFNKLDRMODGETIMPORT pfnGetImport, void pvUser)
1880	{
1881	PKLDRMODLX pModLX = (PKLDRMODLX)pMod->pvData;
1882	int rc;
1883
1884	/*
1885	* Load the image bits.
1886	*/
1887	rc = kldrModLXDoLoadBits(pModLX, pvBits);
1888	if (rc)
1889	return rc;
1890
1891	/*
1892	* Perform relocations.
1893	*/
1894	return kldrModLXRelocateBits(pMod, pvBits, BaseAddress, pMod->aSegments[0].LinkAddress, pfnGetImport, pvUser);
1895
1896	}
1897
1898
1899	/** @copydoc kLdrModRelocateBits */
1900	static int kldrModLXRelocateBits(PKLDRMOD pMod, void *pvBits, KLDRADDR NewBaseAddress, KLDRADDR OldBaseAddress,
1901	PFNKLDRMODGETIMPORT pfnGetImport, void *pvUser)
1902	{
1903	/*PKLDRMODLX pModLX = (PKLDRMODLX)pMod->pvData;
1904	int rc;*/
1905
1906	/** @todo Implement this. */
1907
1908	return -1;
1909	}
1910
1911
1912	/**
1913	* The LX module interpreter method table.
1914	*/
1915	KLDRMODOPS g_kLdrModLXOps =
1916	{
1917	"LX",
1918	NULL,
1919	kldrModLXCreate,
1920	kldrModLXDestroy,
1921	kldrModLXQuerySymbol,
1922	kldrModLXEnumSymbols,
1923	kldrModLXGetImport,
1924	kldrModLXNumberOfImports,
1925	NULL /* can execute one is optional */,
1926	kldrModLXGetStackInfo,
1927	kldrModLXQueryMainEntrypoint,
1928	kldrModLXEnumDbgInfo,
1929	kldrModLXHasDbgInfo,
1930	kldrModLXMap,
1931	kldrModLXUnmap,
1932	kldrModLXAllocTLS,
1933	kldrModLXFreeTLS,
1934	kldrModLXReload,
1935	kldrModLXFixupMapping,
1936	kldrModLXCallInit,
1937	kldrModLXCallTerm,
1938	kldrModLXCallThread,
1939	kldrModLXSize,
1940	kldrModLXGetBits,
1941	kldrModLXRelocateBits,
1942	42 /* the end */
1943	};
1944

Note: See TracBrowser for help on using the repository browser.

Download in other formats: