Context Navigation

kLdrModLX.c@ 117

Last change on this file since 117 was 117, checked in by bird, 5 years ago
kLdrModNative: Added KLDRMOD_OPEN_FLAGS_NATIVE_ALLOW_INIT_TERM to allow kWorker to re-init mspdb100.dll when _MSPDBSRV_ENDPOINT_ changes.
Property svn:eol-style set to `native` Property svn:keywords set to `Id Revision`
File size: 88.2 KB

Rev	Line
[2]	1	/* $Id: kLdrModLX.c 117 2020-03-15 15:23:36Z bird $ */
	2	/** @file
	3	* kLdr - The Module Interpreter for the Linear eXecutable (LX) Format.
	4	*/
	5
	6	/*
[29]	7	* Copyright (c) 2006-2007 Knut St. Osmundsen <bird-kStuff-spamix@anduin.net>
[2]	8	*
[29]	9	* Permission is hereby granted, free of charge, to any person
	10	* obtaining a copy of this software and associated documentation
	11	* files (the "Software"), to deal in the Software without
	12	* restriction, including without limitation the rights to use,
	13	* copy, modify, merge, publish, distribute, sublicense, and/or sell
	14	* copies of the Software, and to permit persons to whom the
	15	* Software is furnished to do so, subject to the following
	16	* conditions:
[2]	17	*
[29]	18	* The above copyright notice and this permission notice shall be
	19	* included in all copies or substantial portions of the Software.
[2]	20	*
[29]	21	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
	22	* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
	23	* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
	24	* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
	25	* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
	26	* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
	27	* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
	28	* OTHER DEALINGS IN THE SOFTWARE.
[2]	29	*/
	30
	31	/*******************************************************************************
	32	* Header Files *
	33	*******************************************************************************/
	34	#include <k/kLdr.h>
	35	#include "kLdrInternal.h"
	36	#include <k/kLdrFmts/lx.h>
	37
	38
	39	/*******************************************************************************
	40	* Defined Constants And Macros *
	41	*******************************************************************************/
	42	/** @def KLDRMODLX_STRICT
	43	* Define KLDRMODLX_STRICT to enabled strict checks in KLDRMODLX. */
	44	#define KLDRMODLX_STRICT 1
	45
	46	/** @def KLDRMODLX_ASSERT
	47	* Assert that an expression is true when KLDR_STRICT is defined.
	48	*/
	49	#ifdef KLDRMODLX_STRICT
	50	# define KLDRMODLX_ASSERT(expr) kHlpAssert(expr)
	51	#else
	52	# define KLDRMODLX_ASSERT(expr) do {} while (0)
	53	#endif
	54
	55
	56	/*******************************************************************************
	57	* Structures and Typedefs *
	58	*******************************************************************************/
	59	/**
	60	* Instance data for the LX module interpreter.
	61	*/
	62	typedef struct KLDRMODLX
	63	{
	64	/** Pointer to the module. (Follows the section table.) */
	65	PKLDRMOD pMod;
	66	/** Pointer to the user mapping. */
	67	const void *pvMapping;
	68	/** The size of the mapped LX image. */
	69	KSIZE cbMapped;
	70	/** Reserved flags. */
	71	KU32 f32Reserved;
	72
	73	/** The offset of the LX header. */
	74	KLDRFOFF offHdr;
	75	/** Copy of the LX header. */
	76	struct e32_exe Hdr;
	77
	78	/** Pointer to the loader section.
	79	* Allocated together with this strcture. */
	80	const KU8 *pbLoaderSection;
	81	/** Pointer to the last byte in the loader section. */
	82	const KU8 *pbLoaderSectionLast;
	83	/** Pointer to the object table in the loader section. */
	84	const struct o32_obj *paObjs;
	85	/** Pointer to the object page map table in the loader section. */
	86	const struct o32_map *paPageMappings;
	87	/** Pointer to the resource table in the loader section. */
	88	const struct rsrc32 *paRsrcs;
	89	/** Pointer to the resident name table in the loader section. */
	90	const KU8 *pbResNameTab;
	91	/** Pointer to the entry table in the loader section. */
	92	const KU8 *pbEntryTab;
	93
	94	/** Pointer to the non-resident name table. */
	95	KU8 *pbNonResNameTab;
	96	/** Pointer to the last byte in the non-resident name table. */
	97	const KU8 *pbNonResNameTabLast;
	98
	99	/** Pointer to the fixup section. */
	100	KU8 *pbFixupSection;
	101	/** Pointer to the last byte in the fixup section. */
	102	const KU8 *pbFixupSectionLast;
	103	/** Pointer to the fixup page table within pvFixupSection. */
	104	const KU32 *paoffPageFixups;
	105	/** Pointer to the fixup record table within pvFixupSection. */
	106	const KU8 *pbFixupRecs;
	107	/** Pointer to the import module name table within pvFixupSection. */
	108	const KU8 *pbImportMods;
	109	/** Pointer to the import module name table within pvFixupSection. */
	110	const KU8 *pbImportProcs;
	111	} KLDRMODLX, *PKLDRMODLX;
	112
	113
	114	/*******************************************************************************
	115	* Internal Functions *
	116	*******************************************************************************/
	117	static int kldrModLXHasDbgInfo(PKLDRMOD pMod, const void *pvBits);
	118	static int kldrModLXRelocateBits(PKLDRMOD pMod, void *pvBits, KLDRADDR NewBaseAddress, KLDRADDR OldBaseAddress,
	119	PFNKLDRMODGETIMPORT pfnGetImport, void *pvUser);
	120	static int kldrModLXDoCreate(PKRDR pRdr, KLDRFOFF offNewHdr, PKLDRMODLX *ppModLX);
[87]	121	static const KU8 kldrModLXDoNameTableLookupByOrdinal(const KU8 pbNameTable, KSSIZE cbNameTable, KU32 iOrdinal);
	122	static int kldrModLXDoNameLookup(PKLDRMODLX pModLX, const char pchSymbol, KSIZE cchSymbol, KU32 piSymbol);
	123	static const KU8 kldrModLXDoNameTableLookupByName(const KU8 pbNameTable, KSSIZE cbNameTable,
[2]	124	const char *pchSymbol, KSIZE cchSymbol);
	125	static int kldrModLXDoLoadBits(PKLDRMODLX pModLX, void *pvBits);
	126	static int kldrModLXDoIterDataUnpacking(KU8 pbDst, const KU8 pbSrc, int cbSrc);
	127	static int kldrModLXDoIterData2Unpacking(KU8 pbDst, const KU8 pbSrc, int cbSrc);
	128	static void kLdrModLXMemCopyW(KU8 pbDst, const KU8 pbSrc, int cb);
	129	static int kldrModLXDoProtect(PKLDRMODLX pModLX, void *pvBits, unsigned fUnprotectOrProtect);
[81]	130	static int kldrModLXDoCallDLL(PKLDRMODLX pModLX, void *pvMapping, unsigned uOp, KUPTR uHandle);
[2]	131	static int kldrModLXDoForwarderQuery(PKLDRMODLX pModLX, const struct e32_entry *pEntry,
	132	PFNKLDRMODGETIMPORT pfnGetForwarder, void pvUser, PKLDRADDR puValue, KU32 pfKind);
	133	static int kldrModLXDoLoadFixupSection(PKLDRMODLX pModLX);
	134	static int kldrModLXDoReloc(KU8 pbPage, int off, KLDRADDR PageAddress, const struct r32_rlc prlc,
	135	int iSelector, KLDRADDR uValue, KU32 fKind);
	136
	137
	138	/**
	139	* Create a loader module instance interpreting the executable image found
	140	* in the specified file provider instance.
	141	*
	142	* @returns 0 on success and *ppMod pointing to a module instance.
	143	* On failure, a non-zero OS specific error code is returned.
	144	* @param pOps Pointer to the registered method table.
	145	* @param pRdr The file provider instance to use.
[25]	146	* @param fFlags Flags, MBZ.
	147	* @param enmCpuArch The desired CPU architecture. KCPUARCH_UNKNOWN means
	148	* anything goes, but with a preference for the current
	149	* host architecture.
[2]	150	* @param offNewHdr The offset of the new header in MZ files. -1 if not found.
	151	* @param ppMod Where to store the module instance pointer.
	152	*/
[25]	153	static int kldrModLXCreate(PCKLDRMODOPS pOps, PKRDR pRdr, KU32 fFlags, KCPUARCH enmCpuArch, KLDRFOFF offNewHdr, PPKLDRMOD ppMod)
[2]	154	{
	155	PKLDRMODLX pModLX;
	156	int rc;
[79]	157	K_NOREF(fFlags);
[2]	158
	159	/*
	160	* Create the instance data and do a minimal header validation.
	161	*/
	162	rc = kldrModLXDoCreate(pRdr, offNewHdr, &pModLX);
	163	if (!rc)
	164	{
[25]	165	/*
	166	* Match up against the requested CPU architecture.
	167	*/
	168	if ( enmCpuArch == KCPUARCH_UNKNOWN
	169	\|\| pModLX->pMod->enmArch == enmCpuArch)
	170	{
	171	pModLX->pMod->pOps = pOps;
	172	pModLX->pMod->u32Magic = KLDRMOD_MAGIC;
	173	*ppMod = pModLX->pMod;
	174	return 0;
	175	}
	176	rc = KLDR_ERR_CPU_ARCH_MISMATCH;
[2]	177	}
	178	kHlpFree(pModLX);
	179	return rc;
	180	}
	181
	182
	183	/**
	184	* Separate function for reading creating the LX module instance to
	185	* simplify cleanup on failure.
	186	*/
	187	static int kldrModLXDoCreate(PKRDR pRdr, KLDRFOFF offNewHdr, PKLDRMODLX *ppModLX)
	188	{
	189	struct e32_exe Hdr;
	190	PKLDRMODLX pModLX;
	191	PKLDRMOD pMod;
	192	KSIZE cb;
	193	KSIZE cchFilename;
[114]	194	KSIZE offLdrStuff;
[2]	195	KU32 off, offEnd;
	196	KU32 i;
	197	int rc;
	198	int fCanOptimizeMapping;
	199	KU32 NextRVA;
	200	*ppModLX = NULL;
	201
	202	/*
	203	* Read the signature and file header.
	204	*/
	205	rc = kRdrRead(pRdr, &Hdr, sizeof(Hdr), offNewHdr > 0 ? offNewHdr : 0);
	206	if (rc)
	207	return rc;
	208	if ( Hdr.e32_magic[0] != E32MAGIC1
	209	\|\| Hdr.e32_magic[1] != E32MAGIC2)
	210	return KLDR_ERR_UNKNOWN_FORMAT;
	211
	212	/* We're not interested in anything but x86 images. */
	213	if ( Hdr.e32_level != E32LEVEL
	214	\|\| Hdr.e32_border != E32LEBO
	215	\|\| Hdr.e32_worder != E32LEWO
	216	\|\| Hdr.e32_cpu < E32CPU286
	217	\|\| Hdr.e32_cpu > E32CPU486
	218	\|\| Hdr.e32_pagesize != OBJPAGELEN
	219	)
	220	return KLDR_ERR_LX_BAD_HEADER;
	221
	222	/* Some rough sanity checks. */
	223	offEnd = kRdrSize(pRdr) >= (KLDRFOFF)~(KU32)16 ? ~(KU32)16 : (KU32)kRdrSize(pRdr);
	224	if ( Hdr.e32_itermap > offEnd
	225	\|\| Hdr.e32_datapage > offEnd
	226	\|\| Hdr.e32_nrestab > offEnd
	227	\|\| Hdr.e32_nrestab + Hdr.e32_cbnrestab > offEnd
	228	\|\| Hdr.e32_ldrsize > offEnd - offNewHdr - sizeof(Hdr)
	229	\|\| Hdr.e32_fixupsize > offEnd - offNewHdr - sizeof(Hdr)
	230	\|\| Hdr.e32_fixupsize + Hdr.e32_ldrsize > offEnd - offNewHdr - sizeof(Hdr))
	231	return KLDR_ERR_LX_BAD_HEADER;
	232
	233	/* Verify the loader section. */
	234	offEnd = Hdr.e32_objtab + Hdr.e32_ldrsize;
	235	if (Hdr.e32_objtab < sizeof(Hdr))
	236	return KLDR_ERR_LX_BAD_LOADER_SECTION;
	237	off = Hdr.e32_objtab + sizeof(struct o32_obj) * Hdr.e32_objcnt;
	238	if (off > offEnd)
	239	return KLDR_ERR_LX_BAD_LOADER_SECTION;
	240	if ( Hdr.e32_objmap
	241	&& (Hdr.e32_objmap < off \|\| Hdr.e32_objmap > offEnd))
	242	return KLDR_ERR_LX_BAD_LOADER_SECTION;
	243	if ( Hdr.e32_rsrccnt
	244	&& ( Hdr.e32_rsrctab < off
	245	\|\| Hdr.e32_rsrctab > offEnd
	246	\|\| Hdr.e32_rsrctab + sizeof(struct rsrc32) * Hdr.e32_rsrccnt > offEnd))
	247	return KLDR_ERR_LX_BAD_LOADER_SECTION;
	248	if ( Hdr.e32_restab
	249	&& (Hdr.e32_restab < off \|\| Hdr.e32_restab > offEnd - 2))
	250	return KLDR_ERR_LX_BAD_LOADER_SECTION;
	251	if ( Hdr.e32_enttab
	252	&& (Hdr.e32_enttab < off \|\| Hdr.e32_enttab >= offEnd))
	253	return KLDR_ERR_LX_BAD_LOADER_SECTION;
	254	if ( Hdr.e32_dircnt
	255	&& (Hdr.e32_dirtab < off \|\| Hdr.e32_dirtab > offEnd - 2))
	256	return KLDR_ERR_LX_BAD_LOADER_SECTION;
	257
	258	/* Verify the fixup section. */
	259	off = offEnd;
	260	offEnd = off + Hdr.e32_fixupsize;
	261	if ( Hdr.e32_fpagetab
	262	&& (Hdr.e32_fpagetab < off \|\| Hdr.e32_fpagetab > offEnd))
	263	{
	264	/*
	265	* wlink mixes the fixup section and the loader section.
	266	*/
	267	off = Hdr.e32_fpagetab;
	268	offEnd = off + Hdr.e32_fixupsize;
	269	Hdr.e32_ldrsize = off - Hdr.e32_objtab;
	270	}
	271	if ( Hdr.e32_frectab
	272	&& (Hdr.e32_frectab < off \|\| Hdr.e32_frectab > offEnd))
	273	return KLDR_ERR_LX_BAD_FIXUP_SECTION;
	274	if ( Hdr.e32_impmod
	275	&& (Hdr.e32_impmod < off \|\| Hdr.e32_impmod > offEnd \|\| Hdr.e32_impmod + Hdr.e32_impmodcnt > offEnd))
	276	return KLDR_ERR_LX_BAD_FIXUP_SECTION;
	277	if ( Hdr.e32_impproc
	278	&& (Hdr.e32_impproc < off \|\| Hdr.e32_impproc > offEnd))
	279	return KLDR_ERR_LX_BAD_FIXUP_SECTION;
	280
	281	/*
	282	* Calc the instance size, allocate and initialize it.
	283	*/
	284	cchFilename = kHlpStrLen(kRdrName(pRdr));
	285	cb = K_ALIGN_Z(sizeof(KLDRMODLX), 8)
	286	+ K_ALIGN_Z(K_OFFSETOF(KLDRMOD, aSegments[Hdr.e32_objcnt + 1]), 8)
[114]	287	+ K_ALIGN_Z(cchFilename + 1, 8);
	288	offLdrStuff = cb;
	289	cb += Hdr.e32_ldrsize + 2; /* +2 for two extra zeros. */
[2]	290	pModLX = (PKLDRMODLX)kHlpAlloc(cb);
	291	if (!pModLX)
	292	return KERR_NO_MEMORY;
	293	*ppModLX = pModLX;
	294
	295	/* KLDRMOD */
	296	pMod = (PKLDRMOD)((KU8 *)pModLX + K_ALIGN_Z(sizeof(KLDRMODLX), 8));
	297	pMod->pvData = pModLX;
	298	pMod->pRdr = pRdr;
	299	pMod->pOps = NULL; /* set upon success. */
	300	pMod->cSegments = Hdr.e32_objcnt;
[87]	301	pMod->cchFilename = (KU32)cchFilename;
[2]	302	pMod->pszFilename = (char *)K_ALIGN_P(&pMod->aSegments[pMod->cSegments], 8);
	303	kHlpMemCopy((char *)pMod->pszFilename, kRdrName(pRdr), cchFilename + 1);
	304	pMod->pszName = NULL; /* finalized further down */
	305	pMod->cchName = 0;
[58]	306	pMod->fFlags = 0;
[2]	307	switch (Hdr.e32_cpu)
	308	{
	309	case E32CPU286:
	310	pMod->enmCpu = KCPU_I80286;
	311	pMod->enmArch = KCPUARCH_X86_16;
	312	break;
	313	case E32CPU386:
	314	pMod->enmCpu = KCPU_I386;
	315	pMod->enmArch = KCPUARCH_X86_32;
	316	break;
	317	case E32CPU486:
	318	pMod->enmCpu = KCPU_I486;
	319	pMod->enmArch = KCPUARCH_X86_32;
	320	break;
	321	}
	322	pMod->enmEndian = KLDRENDIAN_LITTLE;
	323	pMod->enmFmt = KLDRFMT_LX;
	324	switch (Hdr.e32_mflags & E32MODMASK)
	325	{
	326	case E32MODEXE:
	327	pMod->enmType = !(Hdr.e32_mflags & E32NOINTFIX)
	328	? KLDRTYPE_EXECUTABLE_RELOCATABLE
	329	: KLDRTYPE_EXECUTABLE_FIXED;
	330	break;
	331
	332	case E32MODDLL:
	333	case E32PROTDLL:
	334	case E32MODPROTDLL:
	335	pMod->enmType = !(Hdr.e32_mflags & E32SYSDLL)
	336	? KLDRTYPE_SHARED_LIBRARY_RELOCATABLE
	337	: KLDRTYPE_SHARED_LIBRARY_FIXED;
	338	break;
	339
	340	case E32MODPDEV:
	341	case E32MODVDEV:
	342	pMod->enmType = KLDRTYPE_SHARED_LIBRARY_RELOCATABLE;
	343	break;
	344	}
	345	pMod->u32Magic = 0; /* set upon success. */
	346
	347	/* KLDRMODLX */
	348	pModLX->pMod = pMod;
	349	pModLX->pvMapping = 0;
	350	pModLX->cbMapped = 0;
	351	pModLX->f32Reserved = 0;
	352
	353	pModLX->offHdr = offNewHdr >= 0 ? offNewHdr : 0;
[24]	354	kHlpMemCopy(&pModLX->Hdr, &Hdr, sizeof(Hdr));
[2]	355
[114]	356	pModLX->pbLoaderSection = (KU8 *)pModLX + offLdrStuff;
[2]	357	pModLX->pbLoaderSectionLast = pModLX->pbLoaderSection + pModLX->Hdr.e32_ldrsize - 1;
	358	pModLX->paObjs = NULL;
	359	pModLX->paPageMappings = NULL;
	360	pModLX->paRsrcs = NULL;
	361	pModLX->pbResNameTab = NULL;
	362	pModLX->pbEntryTab = NULL;
	363
	364	pModLX->pbNonResNameTab = NULL;
	365	pModLX->pbNonResNameTabLast = NULL;
	366
	367	pModLX->pbFixupSection = NULL;
	368	pModLX->pbFixupSectionLast = NULL;
	369	pModLX->paoffPageFixups = NULL;
	370	pModLX->pbFixupRecs = NULL;
	371	pModLX->pbImportMods = NULL;
	372	pModLX->pbImportProcs = NULL;
	373
	374	/*
	375	* Read the loader data.
	376	*/
	377	rc = kRdrRead(pRdr, (void *)pModLX->pbLoaderSection, pModLX->Hdr.e32_ldrsize, pModLX->Hdr.e32_objtab + pModLX->offHdr);
	378	if (rc)
	379	return rc;
	380	((KU8 *)pModLX->pbLoaderSectionLast)[1] = 0;
	381	((KU8 *)pModLX->pbLoaderSectionLast)[2] = 0;
	382	if (pModLX->Hdr.e32_objcnt)
	383	pModLX->paObjs = (const struct o32_obj *)pModLX->pbLoaderSection;
	384	if (pModLX->Hdr.e32_objmap)
	385	pModLX->paPageMappings = (const struct o32_map *)(pModLX->pbLoaderSection + pModLX->Hdr.e32_objmap - pModLX->Hdr.e32_objtab);
	386	if (pModLX->Hdr.e32_rsrccnt)
	387	pModLX->paRsrcs = (const struct rsrc32 *)(pModLX->pbLoaderSection + pModLX->Hdr.e32_rsrctab - pModLX->Hdr.e32_objtab);
	388	if (pModLX->Hdr.e32_restab)
	389	pModLX->pbResNameTab = pModLX->pbLoaderSection + pModLX->Hdr.e32_restab - pModLX->Hdr.e32_objtab;
	390	if (pModLX->Hdr.e32_enttab)
	391	pModLX->pbEntryTab = pModLX->pbLoaderSection + pModLX->Hdr.e32_enttab - pModLX->Hdr.e32_objtab;
	392
	393	/*
	394	* Get the soname from the resident name table.
	395	* Very convenient that it's the 0 ordinal, because then we get a
	396	* free string terminator.
	397	* (The table entry consists of a pascal string followed by a 16-bit ordinal.)
	398	*/
	399	if (pModLX->pbResNameTab)
	400	pMod->pszName = (const char *)kldrModLXDoNameTableLookupByOrdinal(pModLX->pbResNameTab,
	401	pModLX->pbLoaderSectionLast - pModLX->pbResNameTab + 1,
	402	0);
	403	if (!pMod->pszName)
	404	return KLDR_ERR_LX_NO_SONAME;
	405	pMod->cchName = (const KU8 )pMod->pszName++;
	406	if (pMod->cchName != kHlpStrLen(pMod->pszName))
	407	return KLDR_ERR_LX_BAD_SONAME;
	408
	409	/*
	410	* Quick validation of the object table.
	411	*/
	412	cb = 0;
	413	for (i = 0; i < pMod->cSegments; i++)
	414	{
	415	if (pModLX->paObjs[i].o32_base & (OBJPAGELEN - 1))
	416	return KLDR_ERR_LX_BAD_OBJECT_TABLE;
	417	if (pModLX->paObjs[i].o32_base + pModLX->paObjs[i].o32_size <= pModLX->paObjs[i].o32_base)
	418	return KLDR_ERR_LX_BAD_OBJECT_TABLE;
	419	if (pModLX->paObjs[i].o32_mapsize > (pModLX->paObjs[i].o32_size + (OBJPAGELEN - 1)))
	420	return KLDR_ERR_LX_BAD_OBJECT_TABLE;
	421	if ( pModLX->paObjs[i].o32_mapsize
	422	&& ( (KU8 *)&pModLX->paPageMappings[pModLX->paObjs[i].o32_pagemap] > pModLX->pbLoaderSectionLast
	423	\|\| (KU8 *)&pModLX->paPageMappings[pModLX->paObjs[i].o32_pagemap + pModLX->paObjs[i].o32_mapsize]
	424	> pModLX->pbLoaderSectionLast))
	425	return KLDR_ERR_LX_BAD_OBJECT_TABLE;
	426	if (i > 0 && !(pModLX->paObjs[i].o32_flags & OBJRSRC))
	427	{
	428	if (pModLX->paObjs[i].o32_base <= pModLX->paObjs[i - 1].o32_base)
	429	return KLDR_ERR_LX_BAD_OBJECT_TABLE;
	430	if (pModLX->paObjs[i].o32_base < pModLX->paObjs[i - 1].o32_base + pModLX->paObjs[i - 1].o32_mapsize)
	431	return KLDR_ERR_LX_BAD_OBJECT_TABLE;
	432	}
	433	}
	434
	435	/*
	436	* Check if we can optimize the mapping by using a different
	437	* object alignment. The linker typically uses 64KB alignment,
	438	* we can easily get away with page alignment in most cases.
	439	*/
	440	fCanOptimizeMapping = !(Hdr.e32_mflags & (E32NOINTFIX \| E32SYSDLL));
	441	NextRVA = 0;
	442
	443	/*
	444	* Setup the KLDRMOD segment array.
	445	*/
	446	for (i = 0; i < pMod->cSegments; i++)
	447	{
	448	/* unused */
	449	pMod->aSegments[i].pvUser = NULL;
	450	pMod->aSegments[i].MapAddress = 0;
	451	pMod->aSegments[i].pchName = NULL;
	452	pMod->aSegments[i].cchName = 0;
	453	pMod->aSegments[i].offFile = -1;
	454	pMod->aSegments[i].cbFile = -1;
	455	pMod->aSegments[i].SelFlat = 0;
	456	pMod->aSegments[i].Sel16bit = 0;
	457
	458	/* flags */
	459	pMod->aSegments[i].fFlags = 0;
	460	if (pModLX->paObjs[i].o32_flags & OBJBIGDEF)
	461	pMod->aSegments[i].fFlags = KLDRSEG_FLAG_16BIT;
	462	if (pModLX->paObjs[i].o32_flags & OBJALIAS16)
	463	pMod->aSegments[i].fFlags = KLDRSEG_FLAG_OS2_ALIAS16;
	464	if (pModLX->paObjs[i].o32_flags & OBJCONFORM)
	465	pMod->aSegments[i].fFlags = KLDRSEG_FLAG_OS2_CONFORM;
	466	if (pModLX->paObjs[i].o32_flags & OBJIOPL)
	467	pMod->aSegments[i].fFlags = KLDRSEG_FLAG_OS2_IOPL;
	468
	469	/* size and addresses */
	470	pMod->aSegments[i].Alignment = OBJPAGELEN;
	471	pMod->aSegments[i].cb = pModLX->paObjs[i].o32_size;
	472	pMod->aSegments[i].LinkAddress = pModLX->paObjs[i].o32_base;
	473	pMod->aSegments[i].RVA = NextRVA;
	474	if ( fCanOptimizeMapping
	475	\|\| i + 1 >= pMod->cSegments
	476	\|\| (pModLX->paObjs[i].o32_flags & OBJRSRC)
	477	\|\| (pModLX->paObjs[i + 1].o32_flags & OBJRSRC))
	478	pMod->aSegments[i].cbMapped = K_ALIGN_Z(pModLX->paObjs[i].o32_size, OBJPAGELEN);
	479	else
	480	pMod->aSegments[i].cbMapped = pModLX->paObjs[i + 1].o32_base - pModLX->paObjs[i].o32_base;
[87]	481	NextRVA += (KU32)pMod->aSegments[i].cbMapped;
[2]	482
	483	/* protection */
	484	switch ( pModLX->paObjs[i].o32_flags
	485	& (OBJSHARED \| OBJREAD \| OBJWRITE \| OBJEXEC))
	486	{
	487	case 0:
	488	case OBJSHARED:
	489	pMod->aSegments[i].enmProt = KPROT_NOACCESS;
	490	break;
	491	case OBJREAD:
	492	case OBJREAD \| OBJSHARED:
	493	pMod->aSegments[i].enmProt = KPROT_READONLY;
	494	break;
	495	case OBJWRITE:
	496	case OBJWRITE \| OBJREAD:
	497	pMod->aSegments[i].enmProt = KPROT_WRITECOPY;
	498	break;
	499	case OBJWRITE \| OBJSHARED:
	500	case OBJWRITE \| OBJSHARED \| OBJREAD:
	501	pMod->aSegments[i].enmProt = KPROT_READWRITE;
	502	break;
	503	case OBJEXEC:
	504	case OBJEXEC \| OBJSHARED:
	505	pMod->aSegments[i].enmProt = KPROT_EXECUTE;
	506	break;
	507	case OBJEXEC \| OBJREAD:
	508	case OBJEXEC \| OBJREAD \| OBJSHARED:
	509	pMod->aSegments[i].enmProt = KPROT_EXECUTE_READ;
	510	break;
	511	case OBJEXEC \| OBJWRITE:
	512	case OBJEXEC \| OBJWRITE \| OBJREAD:
	513	pMod->aSegments[i].enmProt = KPROT_EXECUTE_WRITECOPY;
	514	break;
	515	case OBJEXEC \| OBJWRITE \| OBJSHARED:
	516	case OBJEXEC \| OBJWRITE \| OBJSHARED \| OBJREAD:
	517	pMod->aSegments[i].enmProt = KPROT_EXECUTE_READWRITE;
	518	break;
	519	}
	520	if ((pModLX->paObjs[i].o32_flags & (OBJREAD \| OBJWRITE \| OBJEXEC \| OBJRSRC)) == OBJRSRC)
	521	pMod->aSegments[i].enmProt = KPROT_READONLY;
	522	/*pMod->aSegments[i].f16bit = !(pModLX->paObjs[i].o32_flags & OBJBIGDEF)
	523	pMod->aSegments[i].fIOPL = !(pModLX->paObjs[i].o32_flags & OBJIOPL)
	524	pMod->aSegments[i].fConforming = !(pModLX->paObjs[i].o32_flags & OBJCONFORM) */
	525	}
	526
	527	/* set the mapping size */
	528	pModLX->cbMapped = NextRVA;
	529
	530	/*
	531	* We're done.
	532	*/
	533	*ppModLX = pModLX;
	534	return 0;
	535	}
	536
	537
	538	/** @copydoc KLDRMODOPS::pfnDestroy */
	539	static int kldrModLXDestroy(PKLDRMOD pMod)
	540	{
	541	PKLDRMODLX pModLX = (PKLDRMODLX)pMod->pvData;
	542	int rc = 0;
	543	KLDRMODLX_ASSERT(!pModLX->pvMapping);
	544
	545	if (pMod->pRdr)
	546	{
	547	rc = kRdrClose(pMod->pRdr);
	548	pMod->pRdr = NULL;
	549	}
	550	if (pModLX->pbNonResNameTab)
	551	{
	552	kHlpFree(pModLX->pbNonResNameTab);
	553	pModLX->pbNonResNameTab = NULL;
	554	}
	555	if (pModLX->pbFixupSection)
	556	{
	557	kHlpFree(pModLX->pbFixupSection);
	558	pModLX->pbFixupSection = NULL;
	559	}
	560	pMod->u32Magic = 0;
	561	pMod->pOps = NULL;
	562	kHlpFree(pModLX);
	563	return rc;
	564	}
	565
	566
	567	/**
	568	* Resolved base address aliases.
	569	*
	570	* @param pModLX The interpreter module instance
	571	* @param pBaseAddress The base address, IN & OUT.
	572	*/
	573	static void kldrModLXResolveBaseAddress(PKLDRMODLX pModLX, PKLDRADDR pBaseAddress)
	574	{
	575	if (*pBaseAddress == KLDRMOD_BASEADDRESS_MAP)
	576	*pBaseAddress = pModLX->pMod->aSegments[0].MapAddress;
	577	else if (*pBaseAddress == KLDRMOD_BASEADDRESS_LINK)
	578	*pBaseAddress = pModLX->pMod->aSegments[0].LinkAddress;
	579	}
	580
	581
	582	/** @copydoc kLdrModQuerySymbol */
	583	static int kldrModLXQuerySymbol(PKLDRMOD pMod, const void *pvBits, KLDRADDR BaseAddress, KU32 iSymbol,
	584	const char pchSymbol, KSIZE cchSymbol, const char pszVersion,
	585	PFNKLDRMODGETIMPORT pfnGetForwarder, void pvUser, PKLDRADDR puValue, KU32 pfKind)
	586	{
	587	PKLDRMODLX pModLX = (PKLDRMODLX)pMod->pvData;
	588	KU32 iOrdinal;
	589	int rc;
	590	const struct b32_bundle *pBundle;
[79]	591	K_NOREF(pvBits);
	592	K_NOREF(pszVersion);
[2]	593
	594	/*
	595	* Give up at once if there is no entry table.
	596	*/
	597	if (!pModLX->Hdr.e32_enttab)
	598	return KLDR_ERR_SYMBOL_NOT_FOUND;
	599
	600	/*
	601	* Translate the symbol name into an ordinal.
	602	*/
	603	if (pchSymbol)
	604	{
	605	rc = kldrModLXDoNameLookup(pModLX, pchSymbol, cchSymbol, &iSymbol);
	606	if (rc)
	607	return rc;
	608	}
	609
	610	/*
	611	* Iterate the entry table.
	612	* (The entry table is made up of bundles of similar exports.)
	613	*/
	614	iOrdinal = 1;
	615	pBundle = (const struct b32_bundle *)pModLX->pbEntryTab;
	616	while (pBundle->b32_cnt && iOrdinal <= iSymbol)
	617	{
	618	static const KSIZE s_cbEntry[] = { 0, 3, 5, 5, 7 };
	619
	620	/*
	621	* Check for a hit first.
	622	*/
	623	iOrdinal += pBundle->b32_cnt;
	624	if (iSymbol < iOrdinal)
	625	{
	626	KU32 offObject;
	627	const struct e32_entry pEntry = (const struct e32_entry )((KUPTR)(pBundle + 1)
	628	+ (iSymbol - (iOrdinal - pBundle->b32_cnt))
	629	* s_cbEntry[pBundle->b32_type]);
	630
	631	/*
	632	* Calculate the return address.
	633	*/
	634	kldrModLXResolveBaseAddress(pModLX, &BaseAddress);
	635	switch (pBundle->b32_type)
	636	{
	637	/* empty bundles are place holders unused ordinal ranges. */
	638	case EMPTY:
	639	return KLDR_ERR_SYMBOL_NOT_FOUND;
	640
	641	/* e32_flags + a 16-bit offset. */
	642	case ENTRY16:
	643	offObject = pEntry->e32_variant.e32_offset.offset16;
	644	if (pfKind)
	645	*pfKind = KLDRSYMKIND_16BIT \| KLDRSYMKIND_NO_TYPE;
	646	break;
	647
	648	/* e32_flags + a 16-bit offset + a 16-bit callgate selector. */
	649	case GATE16:
	650	offObject = pEntry->e32_variant.e32_callgate.offset;
	651	if (pfKind)
	652	*pfKind = KLDRSYMKIND_16BIT \| KLDRSYMKIND_CODE;
	653	break;
	654
	655	/* e32_flags + a 32-bit offset. */
	656	case ENTRY32:
	657	offObject = pEntry->e32_variant.e32_offset.offset32;
	658	if (pfKind)
	659	*pfKind = KLDRSYMKIND_32BIT;
	660	break;
	661
	662	/* e32_flags + 16-bit import module ordinal + a 32-bit procname or ordinal. */
	663	case ENTRYFWD:
	664	return kldrModLXDoForwarderQuery(pModLX, pEntry, pfnGetForwarder, pvUser, puValue, pfKind);
	665
	666	default:
	667	/* anyone actually using TYPEINFO will end up here. */
	668	KLDRMODLX_ASSERT(!"Bad bundle type");
	669	return KLDR_ERR_LX_BAD_BUNDLE;
	670	}
	671
	672	/*
	673	* Validate the object number and calc the return address.
	674	*/
	675	if ( pBundle->b32_obj <= 0
	676	\|\| pBundle->b32_obj > pMod->cSegments)
	677	return KLDR_ERR_LX_BAD_BUNDLE;
	678	if (puValue)
	679	*puValue = BaseAddress
	680	+ offObject
	681	+ pMod->aSegments[pBundle->b32_obj - 1].RVA;
	682	return 0;
	683	}
	684
	685	/*
	686	* Skip the bundle.
	687	*/
	688	if (pBundle->b32_type > ENTRYFWD)
	689	{
	690	KLDRMODLX_ASSERT(!"Bad type"); /** @todo figure out TYPEINFO. */
	691	return KLDR_ERR_LX_BAD_BUNDLE;
	692	}
	693	if (pBundle->b32_type == 0)
	694	pBundle = (const struct b32_bundle )((const KU8 )pBundle + 2);
	695	else
	696	pBundle = (const struct b32_bundle )((const KU8 )(pBundle + 1) + s_cbEntry[pBundle->b32_type] * pBundle->b32_cnt);
	697	}
	698
	699	return KLDR_ERR_SYMBOL_NOT_FOUND;
	700	}
	701
	702
	703	/**
	704	* Do name lookup.
	705	*
	706	* @returns See kLdrModQuerySymbol.
	707	* @param pModLX The module to lookup the symbol in.
	708	* @param pchSymbol The symbol to lookup.
	709	* @param cchSymbol The symbol name length.
	710	* @param piSymbol Where to store the symbol ordinal.
	711	*/
[87]	712	static int kldrModLXDoNameLookup(PKLDRMODLX pModLX, const char pchSymbol, KSIZE cchSymbol, KU32 piSymbol)
[2]	713	{
	714
	715	/*
	716	* First do a hash table lookup.
	717	*/
	718	/** @todo hash name table for speed. */
	719
	720	/*
	721	* Search the name tables.
	722	*/
	723	const KU8 *pbName = kldrModLXDoNameTableLookupByName(pModLX->pbResNameTab,
	724	pModLX->pbLoaderSectionLast - pModLX->pbResNameTab + 1,
	725	pchSymbol, cchSymbol);
	726	if (!pbName)
	727	{
	728	if (!pModLX->pbNonResNameTab)
	729	{
	730	/* lazy load it */
	731	/** @todo non-resident name table. */
	732	}
	733	if (pModLX->pbNonResNameTab)
	734	pbName = kldrModLXDoNameTableLookupByName(pModLX->pbResNameTab,
	735	pModLX->pbNonResNameTabLast - pModLX->pbResNameTab + 1,
	736	pchSymbol, cchSymbol);
	737	}
	738	if (!pbName)
	739	return KLDR_ERR_SYMBOL_NOT_FOUND;
	740
	741	piSymbol = (const KU16 )(pbName + 1 + pbName);
	742	return 0;
	743	}
	744
	745
	746	#if 0
	747	/**
	748	* Hash a symbol using the algorithm from sdbm.
	749	*
	750	* The following was is the documenation of the orignal sdbm functions:
	751	*
	752	* This algorithm was created for sdbm (a public-domain reimplementation of
	753	* ndbm) database library. it was found to do well in scrambling bits,
	754	* causing better distribution of the keys and fewer splits. it also happens
	755	* to be a good general hashing function with good distribution. the actual
	756	* function is hash(i) = hash(i - 1) * 65599 + str[i]; what is included below
	757	* is the faster version used in gawk. [there is even a faster, duff-device
	758	* version] the magic constant 65599 was picked out of thin air while
	759	* experimenting with different constants, and turns out to be a prime.
	760	* this is one of the algorithms used in berkeley db (see sleepycat) and
	761	* elsewhere.
	762	*/
	763	static KU32 kldrModLXDoHash(const char *pchSymbol, KU8 cchSymbol)
	764	{
	765	KU32 hash = 0;
	766	int ch;
	767
	768	while ( cchSymbol-- > 0
	769	&& (ch = (unsigned const char )pchSymbol++))
	770	hash = ch + (hash << 6) + (hash << 16) - hash;
	771
	772	return hash;
	773	}
	774	#endif
	775
	776
	777	/**
	778	* Lookup a name table entry by name.
	779	*
	780	* @returns Pointer to the name table entry if found.
	781	* @returns NULL if not found.
	782	* @param pbNameTable Pointer to the name table that should be searched.
	783	* @param cbNameTable The size of the name table.
	784	* @param pchSymbol The name of the symbol we're looking for.
	785	* @param cchSymbol The length of the symbol name.
	786	*/
[87]	787	static const KU8 kldrModLXDoNameTableLookupByName(const KU8 pbNameTable, KSSIZE cbNameTable,
[2]	788	const char *pchSymbol, KSIZE cchSymbol)
	789	{
	790	/*
	791	* Determin the namelength up front so we can skip anything which doesn't matches the length.
	792	*/
	793	KU8 cbSymbol8Bit = (KU8)cchSymbol;
	794	if (cbSymbol8Bit != cchSymbol)
	795	return NULL; /* too long. */
	796
	797	/*
	798	* Walk the name table.
	799	*/
	800	while (*pbNameTable != 0 && cbNameTable > 0)
	801	{
	802	const KU8 cbName = *pbNameTable;
	803
	804	cbNameTable -= cbName + 1 + 2;
	805	if (cbNameTable < 0)
	806	break;
	807
	808	if ( cbName == cbSymbol8Bit
	809	&& !kHlpMemComp(pbNameTable + 1, pchSymbol, cbName))
	810	return pbNameTable;
	811
	812	/* next entry */
	813	pbNameTable += cbName + 1 + 2;
	814	}
	815
	816	return NULL;
	817	}
	818
	819
	820	/**
	821	* Deal with a forwarder entry.
	822	*
	823	* @returns See kLdrModQuerySymbol.
	824	* @param pModLX The PE module interpreter instance.
	825	* @param pEntry The forwarder entry.
	826	* @param pfnGetForwarder The callback for resolving forwarder symbols. (optional)
	827	* @param pvUser The user argument for the callback.
	828	* @param puValue Where to put the value. (optional)
	829	* @param pfKind Where to put the symbol kind. (optional)
	830	*/
	831	static int kldrModLXDoForwarderQuery(PKLDRMODLX pModLX, const struct e32_entry *pEntry,
	832	PFNKLDRMODGETIMPORT pfnGetForwarder, void pvUser, PKLDRADDR puValue, KU32 pfKind)
	833	{
	834	int rc;
	835	KU32 iSymbol;
	836	const char *pchSymbol;
	837	KU8 cchSymbol;
	838
	839	if (!pfnGetForwarder)
	840	return KLDR_ERR_FORWARDER_SYMBOL;
	841
	842	/*
	843	* Validate the entry import module ordinal.
	844	*/
	845	if ( !pEntry->e32_variant.e32_fwd.modord
	846	\|\| pEntry->e32_variant.e32_fwd.modord > pModLX->Hdr.e32_impmodcnt)
	847	return KLDR_ERR_LX_BAD_FORWARDER;
	848
	849	/*
	850	* Figure out the parameters.
	851	*/
	852	if (pEntry->e32_flags & FWD_ORDINAL)
	853	{
	854	iSymbol = pEntry->e32_variant.e32_fwd.value;
	855	pchSymbol = NULL; /* no symbol name. */
	856	cchSymbol = 0;
	857	}
	858	else
	859	{
	860	const KU8 *pbName;
	861
	862	/* load the fixup section if necessary. */
	863	if (!pModLX->pbImportProcs)
	864	{
	865	rc = kldrModLXDoLoadFixupSection(pModLX);
	866	if (rc)
	867	return rc;
	868	}
	869
	870	/* Make name pointer. */
	871	pbName = pModLX->pbImportProcs + pEntry->e32_variant.e32_fwd.value;
	872	if ( pbName >= pModLX->pbFixupSectionLast
	873	\|\| pbName < pModLX->pbFixupSection
	874	\|\| !*pbName)
	875	return KLDR_ERR_LX_BAD_FORWARDER;
	876
	877
	878	/* check for '#' name. */
	879	if (pbName[1] == '#')
	880	{
	881	KU8 cbLeft = *pbName;
	882	const KU8 *pb = pbName + 1;
	883	unsigned uBase;
	884
	885	/* base detection */
	886	uBase = 10;
	887	if ( cbLeft > 1
	888	&& pb[1] == '0'
	889	&& (pb[2] == 'x' \|\| pb[2] == 'X'))
	890	{
	891	uBase = 16;
	892	pb += 2;
	893	cbLeft -= 2;
	894	}
	895
	896	/* ascii to integer */
	897	iSymbol = 0;
	898	while (cbLeft-- > 0)
	899	{
	900	/* convert char to digit. */
	901	unsigned uDigit = *pb++;
	902	if (uDigit >= '0' && uDigit <= '9')
	903	uDigit -= '0';
	904	else if (uDigit >= 'a' && uDigit <= 'z')
	905	uDigit -= 'a' + 10;
	906	else if (uDigit >= 'A' && uDigit <= 'Z')
	907	uDigit -= 'A' + 10;
	908	else if (!uDigit)
	909	break;
	910	else
	911	return KLDR_ERR_LX_BAD_FORWARDER;
	912	if (uDigit >= uBase)
	913	return KLDR_ERR_LX_BAD_FORWARDER;
	914
	915	/* insert the digit */
	916	iSymbol *= uBase;
	917	iSymbol += uDigit;
	918	}
	919	if (!iSymbol)
	920	return KLDR_ERR_LX_BAD_FORWARDER;
	921
	922	pchSymbol = NULL; /* no symbol name. */
	923	cchSymbol = 0;
	924	}
	925	else
	926	{
	927	pchSymbol = (char *)pbName + 1;
	928	cchSymbol = *pbName;
	929	iSymbol = NIL_KLDRMOD_SYM_ORDINAL;
	930	}
	931	}
	932
	933	/*
	934	* Resolve the forwarder.
	935	*/
	936	rc = pfnGetForwarder(pModLX->pMod, pEntry->e32_variant.e32_fwd.modord - 1, iSymbol, pchSymbol, cchSymbol, NULL, puValue, pfKind, pvUser);
	937	if (!rc && pfKind)
	938	*pfKind \|= KLDRSYMKIND_FORWARDER;
	939	return rc;
	940	}
	941
	942
	943	/**
	944	* Loads the fixup section from the executable image.
	945	*
	946	* The fixup section isn't loaded until it's accessed. It's also freed by kLdrModDone().
	947	*
	948	* @returns 0 on success, non-zero kLdr or native status code on failure.
	949	* @param pModLX The PE module interpreter instance.
	950	*/
	951	static int kldrModLXDoLoadFixupSection(PKLDRMODLX pModLX)
	952	{
	953	int rc;
	954	KU32 off;
	955	void *pv;
	956
	957	pv = kHlpAlloc(pModLX->Hdr.e32_fixupsize);
	958	if (!pv)
	959	return KERR_NO_MEMORY;
	960
	961	off = pModLX->Hdr.e32_objtab + pModLX->Hdr.e32_ldrsize;
	962	rc = kRdrRead(pModLX->pMod->pRdr, pv, pModLX->Hdr.e32_fixupsize,
	963	off + pModLX->offHdr);
	964	if (!rc)
	965	{
	966	pModLX->pbFixupSection = pv;
	967	pModLX->pbFixupSectionLast = pModLX->pbFixupSection + pModLX->Hdr.e32_fixupsize;
	968	KLDRMODLX_ASSERT(!pModLX->paoffPageFixups);
	969	if (pModLX->Hdr.e32_fpagetab)
	970	pModLX->paoffPageFixups = (const KU32 *)(pModLX->pbFixupSection + pModLX->Hdr.e32_fpagetab - off);
	971	KLDRMODLX_ASSERT(!pModLX->pbFixupRecs);
	972	if (pModLX->Hdr.e32_frectab)
	973	pModLX->pbFixupRecs = pModLX->pbFixupSection + pModLX->Hdr.e32_frectab - off;
	974	KLDRMODLX_ASSERT(!pModLX->pbImportMods);
	975	if (pModLX->Hdr.e32_impmod)
	976	pModLX->pbImportMods = pModLX->pbFixupSection + pModLX->Hdr.e32_impmod - off;
	977	KLDRMODLX_ASSERT(!pModLX->pbImportProcs);
	978	if (pModLX->Hdr.e32_impproc)
	979	pModLX->pbImportProcs = pModLX->pbFixupSection + pModLX->Hdr.e32_impproc - off;
	980	}
	981	else
	982	kHlpFree(pv);
	983	return rc;
	984	}
	985
	986
	987	/** @copydoc kLdrModEnumSymbols */
	988	static int kldrModLXEnumSymbols(PKLDRMOD pMod, const void *pvBits, KLDRADDR BaseAddress,
	989	KU32 fFlags, PFNKLDRMODENUMSYMS pfnCallback, void *pvUser)
	990	{
	991	PKLDRMODLX pModLX = (PKLDRMODLX)pMod->pvData;
	992	const struct b32_bundle *pBundle;
	993	KU32 iOrdinal;
	994	int rc = 0;
[79]	995	K_NOREF(pvBits);
	996	K_NOREF(fFlags);
[2]	997
	998	kldrModLXResolveBaseAddress(pModLX, &BaseAddress);
	999
	1000	/*
	1001	* Enumerate the entry table.
	1002	* (The entry table is made up of bundles of similar exports.)
	1003	*/
	1004	iOrdinal = 1;
	1005	pBundle = (const struct b32_bundle *)pModLX->pbEntryTab;
	1006	while (pBundle->b32_cnt && iOrdinal)
	1007	{
	1008	static const KSIZE s_cbEntry[] = { 0, 3, 5, 5, 7 };
	1009
	1010	/*
	1011	* Enum the entries in the bundle.
	1012	*/
	1013	if (pBundle->b32_type != EMPTY)
	1014	{
	1015	const struct e32_entry *pEntry;
	1016	KSIZE cbEntry;
	1017	KLDRADDR BundleRVA;
	1018	unsigned cLeft;
	1019
	1020
	1021	/* Validate the bundle. */
	1022	switch (pBundle->b32_type)
	1023	{
	1024	case ENTRY16:
	1025	case GATE16:
	1026	case ENTRY32:
	1027	if ( pBundle->b32_obj <= 0
	1028	\|\| pBundle->b32_obj > pMod->cSegments)
	1029	return KLDR_ERR_LX_BAD_BUNDLE;
	1030	BundleRVA = pMod->aSegments[pBundle->b32_obj - 1].RVA;
	1031	break;
	1032
	1033	case ENTRYFWD:
	1034	BundleRVA = 0;
	1035	break;
	1036
	1037	default:
	1038	/* anyone actually using TYPEINFO will end up here. */
	1039	KLDRMODLX_ASSERT(!"Bad bundle type");
	1040	return KLDR_ERR_LX_BAD_BUNDLE;
	1041	}
	1042
	1043	/* iterate the bundle entries. */
	1044	cbEntry = s_cbEntry[pBundle->b32_type];
	1045	pEntry = (const struct e32_entry *)(pBundle + 1);
	1046	cLeft = pBundle->b32_cnt;
	1047	while (cLeft-- > 0)
	1048	{
	1049	KLDRADDR uValue;
	1050	KU32 fKind;
	1051	int fFoundName;
	1052	const KU8 *pbName;
	1053
	1054	/*
	1055	* Calc the symbol value and kind.
	1056	*/
	1057	switch (pBundle->b32_type)
	1058	{
	1059	/* e32_flags + a 16-bit offset. */
	1060	case ENTRY16:
	1061	uValue = BaseAddress + BundleRVA + pEntry->e32_variant.e32_offset.offset16;
	1062	fKind = KLDRSYMKIND_16BIT \| KLDRSYMKIND_NO_TYPE;
	1063	break;
	1064
	1065	/* e32_flags + a 16-bit offset + a 16-bit callgate selector. */
	1066	case GATE16:
	1067	uValue = BaseAddress + BundleRVA + pEntry->e32_variant.e32_callgate.offset;
	1068	fKind = KLDRSYMKIND_16BIT \| KLDRSYMKIND_CODE;
	1069	break;
	1070
	1071	/* e32_flags + a 32-bit offset. */
	1072	case ENTRY32:
	1073	uValue = BaseAddress + BundleRVA + pEntry->e32_variant.e32_offset.offset32;
	1074	fKind = KLDRSYMKIND_32BIT;
	1075	break;
	1076
	1077	/* e32_flags + 16-bit import module ordinal + a 32-bit procname or ordinal. */
	1078	case ENTRYFWD:
	1079	uValue = 0; /** @todo implement enumeration of forwarders properly. */
	1080	fKind = KLDRSYMKIND_FORWARDER;
	1081	break;
[28]	1082
	1083	default: /* shut up gcc. */
	1084	uValue = 0;
	1085	fKind = KLDRSYMKIND_NO_BIT \| KLDRSYMKIND_NO_TYPE;
	1086	break;
[2]	1087	}
	1088
	1089	/*
	1090	* Any symbol names?
	1091	*/
	1092	fFoundName = 0;
	1093
	1094	/* resident name table. */
	1095	pbName = pModLX->pbResNameTab;
	1096	if (pbName)
	1097	{
	1098	do
	1099	{
	1100	pbName = kldrModLXDoNameTableLookupByOrdinal(pbName, pModLX->pbLoaderSectionLast - pbName + 1, iOrdinal);
	1101	if (!pbName)
	1102	break;
	1103	fFoundName = 1;
	1104	rc = pfnCallback(pMod, iOrdinal, (const char )pbName + 1, pbName, NULL, uValue, fKind, pvUser);
	1105	if (rc)
	1106	return rc;
	1107
	1108	/* skip to the next entry */
	1109	pbName += 1 + *pbName + 2;
	1110	} while (pbName < pModLX->pbLoaderSectionLast);
	1111	}
	1112
	1113	/* resident name table. */
	1114	pbName = pModLX->pbNonResNameTab;
	1115	/** @todo lazy load the non-resident name table. */
	1116	if (pbName)
	1117	{
	1118	do
	1119	{
	1120	pbName = kldrModLXDoNameTableLookupByOrdinal(pbName, pModLX->pbNonResNameTabLast - pbName + 1, iOrdinal);
	1121	if (!pbName)
	1122	break;
	1123	fFoundName = 1;
	1124	rc = pfnCallback(pMod, iOrdinal, (const char )pbName + 1, pbName, NULL, uValue, fKind, pvUser);
	1125	if (rc)
	1126	return rc;
	1127
	1128	/* skip to the next entry */
	1129	pbName += 1 + *pbName + 2;
	1130	} while (pbName < pModLX->pbLoaderSectionLast);
	1131	}
	1132
	1133	/*
	1134	* If no names, call once with the ordinal only.
	1135	*/
	1136	if (!fFoundName)
	1137	{
	1138	rc = pfnCallback(pMod, iOrdinal, NULL, 0, NULL, uValue, fKind, pvUser);
	1139	if (rc)
	1140	return rc;
	1141	}
	1142
	1143	/* next */
	1144	iOrdinal++;
	1145	pEntry = (const struct e32_entry *)((KUPTR)pEntry + cbEntry);
	1146	}
	1147	}
	1148
	1149	/*
	1150	* The next bundle.
	1151	*/
	1152	if (pBundle->b32_type > ENTRYFWD)
	1153	{
	1154	KLDRMODLX_ASSERT(!"Bad type"); /** @todo figure out TYPEINFO. */
	1155	return KLDR_ERR_LX_BAD_BUNDLE;
	1156	}
	1157	if (pBundle->b32_type == 0)
	1158	pBundle = (const struct b32_bundle )((const KU8 )pBundle + 2);
	1159	else
	1160	pBundle = (const struct b32_bundle )((const KU8 )(pBundle + 1) + s_cbEntry[pBundle->b32_type] * pBundle->b32_cnt);
	1161	}
	1162
	1163	return 0;
	1164	}
	1165
	1166
	1167	/**
	1168	* Lookup a name table entry by ordinal.
	1169	*
	1170	* @returns Pointer to the name table entry if found.
	1171	* @returns NULL if not found.
	1172	* @param pbNameTable Pointer to the name table that should be searched.
	1173	* @param cbNameTable The size of the name table.
	1174	* @param iOrdinal The ordinal to search for.
	1175	*/
[87]	1176	static const KU8 kldrModLXDoNameTableLookupByOrdinal(const KU8 pbNameTable, KSSIZE cbNameTable, KU32 iOrdinal)
[2]	1177	{
	1178	while (*pbNameTable != 0 && cbNameTable > 0)
	1179	{
	1180	const KU8 cbName = *pbNameTable;
	1181	KU32 iName;
	1182
	1183	cbNameTable -= cbName + 1 + 2;
	1184	if (cbNameTable < 0)
	1185	break;
	1186
	1187	iName = *(pbNameTable + cbName + 1)
	1188	\| ((unsigned)*(pbNameTable + cbName + 2) << 8);
	1189	if (iName == iOrdinal)
	1190	return pbNameTable;
	1191
	1192	/* next entry */
	1193	pbNameTable += cbName + 1 + 2;
	1194	}
	1195
	1196	return NULL;
	1197	}
	1198
	1199
	1200	/** @copydoc kLdrModGetImport */
	1201	static int kldrModLXGetImport(PKLDRMOD pMod, const void pvBits, KU32 iImport, char pszName, KSIZE cchName)
	1202	{
	1203	PKLDRMODLX pModLX = (PKLDRMODLX)pMod->pvData;
	1204	const KU8 *pb;
	1205	int rc;
[79]	1206	K_NOREF(pvBits);
[2]	1207
	1208	/*
	1209	* Validate
	1210	*/
	1211	if (iImport >= pModLX->Hdr.e32_impmodcnt)
	1212	return KLDR_ERR_IMPORT_ORDINAL_OUT_OF_BOUNDS;
	1213
	1214	/*
	1215	* Lazy loading the fixup section.
	1216	*/
	1217	if (!pModLX->pbImportMods)
	1218	{
	1219	rc = kldrModLXDoLoadFixupSection(pModLX);
	1220	if (rc)
	1221	return rc;
	1222	}
	1223
	1224	/*
	1225	* Iterate the module import table until we reach the requested import ordinal.
	1226	*/
	1227	pb = pModLX->pbImportMods;
	1228	while (iImport-- > 0)
	1229	pb += *pb + 1;
	1230
	1231	/*
	1232	* Copy out the result.
	1233	*/
	1234	if (*pb < cchName)
	1235	{
	1236	kHlpMemCopy(pszName, pb + 1, *pb);
	1237	pszName[*pb] = '\0';
	1238	rc = 0;
	1239	}
	1240	else
	1241	{
	1242	kHlpMemCopy(pszName, pb + 1, cchName);
	1243	if (cchName)
	1244	pszName[cchName - 1] = '\0';
	1245	rc = KERR_BUFFER_OVERFLOW;
	1246	}
	1247
	1248	return rc;
	1249	}
	1250
	1251
	1252	/** @copydoc kLdrModNumberOfImports */
	1253	static KI32 kldrModLXNumberOfImports(PKLDRMOD pMod, const void *pvBits)
	1254	{
	1255	PKLDRMODLX pModLX = (PKLDRMODLX)pMod->pvData;
[79]	1256	K_NOREF(pvBits);
[2]	1257	return pModLX->Hdr.e32_impmodcnt;
	1258	}
	1259
	1260
	1261	/** @copydoc kLdrModGetStackInfo */
	1262	static int kldrModLXGetStackInfo(PKLDRMOD pMod, const void *pvBits, KLDRADDR BaseAddress, PKLDRSTACKINFO pStackInfo)
	1263	{
	1264	PKLDRMODLX pModLX = (PKLDRMODLX)pMod->pvData;
	1265	const KU32 i = pModLX->Hdr.e32_stackobj;
[79]	1266	K_NOREF(pvBits);
[2]	1267
	1268	if ( i
	1269	&& i <= pMod->cSegments
	1270	&& pModLX->Hdr.e32_esp <= pMod->aSegments[i - 1].LinkAddress + pMod->aSegments[i - 1].cb
	1271	&& pModLX->Hdr.e32_stacksize
	1272	&& pModLX->Hdr.e32_esp - pModLX->Hdr.e32_stacksize >= pMod->aSegments[i - 1].LinkAddress)
	1273	{
	1274
	1275	kldrModLXResolveBaseAddress(pModLX, &BaseAddress);
	1276	pStackInfo->LinkAddress = pModLX->Hdr.e32_esp - pModLX->Hdr.e32_stacksize;
	1277	pStackInfo->Address = BaseAddress
	1278	+ pMod->aSegments[i - 1].RVA
	1279	+ pModLX->Hdr.e32_esp - pModLX->Hdr.e32_stacksize - pMod->aSegments[i - 1].LinkAddress;
	1280	}
	1281	else
	1282	{
	1283	pStackInfo->Address = NIL_KLDRADDR;
	1284	pStackInfo->LinkAddress = NIL_KLDRADDR;
	1285	}
	1286	pStackInfo->cbStack = pModLX->Hdr.e32_stacksize;
	1287	pStackInfo->cbStackThread = 0;
	1288
	1289	return 0;
	1290	}
	1291
	1292
	1293	/** @copydoc kLdrModQueryMainEntrypoint */
	1294	static int kldrModLXQueryMainEntrypoint(PKLDRMOD pMod, const void *pvBits, KLDRADDR BaseAddress, PKLDRADDR pMainEPAddress)
	1295	{
	1296	PKLDRMODLX pModLX = (PKLDRMODLX)pMod->pvData;
[79]	1297	K_NOREF(pvBits);
[2]	1298
	1299	/*
	1300	* Convert the address from the header.
	1301	*/
	1302	kldrModLXResolveBaseAddress(pModLX, &BaseAddress);
	1303	*pMainEPAddress = pModLX->Hdr.e32_startobj
	1304	&& pModLX->Hdr.e32_startobj <= pMod->cSegments
	1305	&& pModLX->Hdr.e32_eip < pMod->aSegments[pModLX->Hdr.e32_startobj - 1].cb
	1306	? BaseAddress + pMod->aSegments[pModLX->Hdr.e32_startobj - 1].RVA + pModLX->Hdr.e32_eip
	1307	: NIL_KLDRADDR;
	1308	return 0;
	1309	}
	1310
	1311
	1312	/** @copydoc kLdrModEnumDbgInfo */
	1313	static int kldrModLXEnumDbgInfo(PKLDRMOD pMod, const void pvBits, PFNKLDRENUMDBG pfnCallback, void pvUser)
	1314	{
	1315	/PKLDRMODLX pModLX = (PKLDRMODLX)pMod->pvData;/
[79]	1316	K_NOREF(pfnCallback);
	1317	K_NOREF(pvUser);
[2]	1318
	1319	/*
	1320	* Quit immediately if no debug info.
	1321	*/
	1322	if (kldrModLXHasDbgInfo(pMod, pvBits))
	1323	return 0;
	1324	#if 0
	1325	/*
	1326	* Read the debug info and look for familiar magics and structures.
	1327	*/
	1328	/** @todo */
	1329	#endif
	1330
	1331	return 0;
	1332	}
	1333
	1334
	1335	/** @copydoc kLdrModHasDbgInfo */
	1336	static int kldrModLXHasDbgInfo(PKLDRMOD pMod, const void *pvBits)
	1337	{
	1338	PKLDRMODLX pModLX = (PKLDRMODLX)pMod->pvData;
[79]	1339	K_NOREF(pvBits);
[2]	1340
	1341	/*
	1342	* Don't curretnly bother with linkers which doesn't advertise it in the header.
	1343	*/
	1344	if ( !pModLX->Hdr.e32_debuginfo
	1345	\|\| !pModLX->Hdr.e32_debuglen)
	1346	return KLDR_ERR_NO_DEBUG_INFO;
	1347	return 0;
	1348	}
	1349
	1350
	1351	/** @copydoc kLdrModMap */
	1352	static int kldrModLXMap(PKLDRMOD pMod)
	1353	{
	1354	PKLDRMODLX pModLX = (PKLDRMODLX)pMod->pvData;
	1355	unsigned fFixed;
	1356	void *pvBase;
	1357	int rc;
	1358
	1359	/*
	1360	* Already mapped?
	1361	*/
	1362	if (pModLX->pvMapping)
	1363	return KLDR_ERR_ALREADY_MAPPED;
	1364
	1365	/*
	1366	* Allocate memory for it.
	1367	*/
	1368	/* fixed image? */
	1369	fFixed = pMod->enmType == KLDRTYPE_EXECUTABLE_FIXED
	1370	\|\| pMod->enmType == KLDRTYPE_SHARED_LIBRARY_FIXED;
	1371	if (!fFixed)
	1372	pvBase = NULL;
	1373	else
	1374	{
	1375	pvBase = (void *)(KUPTR)pMod->aSegments[0].LinkAddress;
	1376	if ((KUPTR)pvBase != pMod->aSegments[0].LinkAddress)
	1377	return KLDR_ERR_ADDRESS_OVERFLOW;
	1378	}
	1379	rc = kHlpPageAlloc(&pvBase, pModLX->cbMapped, KPROT_EXECUTE_READWRITE, fFixed);
	1380	if (rc)
	1381	return rc;
	1382
	1383	/*
	1384	* Load the bits, apply page protection, and update the segment table.
	1385	*/
	1386	rc = kldrModLXDoLoadBits(pModLX, pvBase);
	1387	if (!rc)
	1388	rc = kldrModLXDoProtect(pModLX, pvBase, 0 /* protect */);
	1389	if (!rc)
	1390	{
	1391	KU32 i;
	1392	for (i = 0; i < pMod->cSegments; i++)
	1393	{
	1394	if (pMod->aSegments[i].RVA != NIL_KLDRADDR)
	1395	pMod->aSegments[i].MapAddress = (KUPTR)pvBase + (KUPTR)pMod->aSegments[i].RVA;
	1396	}
	1397	pModLX->pvMapping = pvBase;
	1398	}
	1399	else
	1400	kHlpPageFree(pvBase, pModLX->cbMapped);
	1401	return rc;
	1402	}
	1403
	1404
	1405	/**
	1406	* Loads the LX pages into the specified memory mapping.
	1407	*
	1408	* @returns 0 on success.
	1409	* @returns non-zero kLdr or OS status code on failure.
	1410	*
	1411	* @param pModLX The LX module interpreter instance.
	1412	* @param pvBits Where to load the bits.
	1413	*/
	1414	static int kldrModLXDoLoadBits(PKLDRMODLX pModLX, void *pvBits)
	1415	{
	1416	const PKRDR pRdr = pModLX->pMod->pRdr;
	1417	KU8 *pbTmpPage = NULL;
	1418	int rc = 0;
	1419	KU32 i;
	1420
	1421	/*
	1422	* Iterate the segments.
	1423	*/
	1424	for (i = 0; i < pModLX->Hdr.e32_objcnt; i++)
	1425	{
	1426	const struct o32_obj * const pObj = &pModLX->paObjs[i];
[87]	1427	const KU32 cPages = (KU32)(pModLX->pMod->aSegments[i].cbMapped / OBJPAGELEN);
[2]	1428	KU32 iPage;
	1429	KU8 pbPage = (KU8 )pvBits + (KUPTR)pModLX->pMod->aSegments[i].RVA;
	1430
	1431	/*
	1432	* Iterate the page map pages.
	1433	*/
	1434	for (iPage = 0; !rc && iPage < pObj->o32_mapsize; iPage++, pbPage += OBJPAGELEN)
	1435	{
	1436	const struct o32_map *pMap = &pModLX->paPageMappings[iPage + pObj->o32_pagemap - 1];
	1437	switch (pMap->o32_pageflags)
	1438	{
	1439	case VALID:
	1440	if (pMap->o32_pagesize == OBJPAGELEN)
	1441	rc = kRdrRead(pRdr, pbPage, OBJPAGELEN,
	1442	pModLX->Hdr.e32_datapage + (pMap->o32_pagedataoffset << pModLX->Hdr.e32_pageshift));
	1443	else if (pMap->o32_pagesize < OBJPAGELEN)
	1444	{
	1445	rc = kRdrRead(pRdr, pbPage, pMap->o32_pagesize,
	1446	pModLX->Hdr.e32_datapage + (pMap->o32_pagedataoffset << pModLX->Hdr.e32_pageshift));
	1447	kHlpMemSet(pbPage + pMap->o32_pagesize, 0, OBJPAGELEN - pMap->o32_pagesize);
	1448	}
	1449	else
	1450	rc = KLDR_ERR_LX_BAD_PAGE_MAP;
	1451	break;
	1452
	1453	case ITERDATA:
	1454	case ITERDATA2:
	1455	/* make sure we've got a temp page .*/
	1456	if (!pbTmpPage)
	1457	{
	1458	pbTmpPage = kHlpAlloc(OBJPAGELEN + 256);
	1459	if (!pbTmpPage)
	1460	break;
	1461	}
	1462	/* validate the size. */
	1463	if (pMap->o32_pagesize > OBJPAGELEN + 252)
	1464	{
	1465	rc = KLDR_ERR_LX_BAD_PAGE_MAP;
	1466	break;
	1467	}
	1468
	1469	/* read it and ensure 4 extra zero bytes. */
	1470	rc = kRdrRead(pRdr, pbTmpPage, pMap->o32_pagesize,
	1471	pModLX->Hdr.e32_datapage + (pMap->o32_pagedataoffset << pModLX->Hdr.e32_pageshift));
	1472	if (rc)
	1473	break;
	1474	kHlpMemSet(pbTmpPage + pMap->o32_pagesize, 0, 4);
	1475
	1476	/* unpack it into the image page. */
	1477	if (pMap->o32_pageflags == ITERDATA2)
	1478	rc = kldrModLXDoIterData2Unpacking(pbPage, pbTmpPage, pMap->o32_pagesize);
	1479	else
	1480	rc = kldrModLXDoIterDataUnpacking(pbPage, pbTmpPage, pMap->o32_pagesize);
	1481	break;
	1482
	1483	case INVALID: /* we're probably not dealing correctly with INVALID pages... */
	1484	case ZEROED:
	1485	kHlpMemSet(pbPage, 0, OBJPAGELEN);
	1486	break;
	1487
	1488	case RANGE:
	1489	KLDRMODLX_ASSERT(!"RANGE");
[102]	1490	/* Falls through. */
[2]	1491	default:
	1492	rc = KLDR_ERR_LX_BAD_PAGE_MAP;
	1493	break;
	1494	}
	1495	}
	1496	if (rc)
	1497	break;
	1498
	1499	/*
	1500	* Zero the remaining pages.
	1501	*/
	1502	if (iPage < cPages)
	1503	kHlpMemSet(pbPage, 0, (cPages - iPage) * OBJPAGELEN);
	1504	}
	1505
	1506	if (pbTmpPage)
	1507	kHlpFree(pbTmpPage);
	1508	return rc;
	1509	}
	1510
	1511
	1512	/**
	1513	* Unpacks iterdata (aka EXEPACK).
	1514	*
	1515	* @returns 0 on success, non-zero kLdr status code on failure.
	1516	* @param pbDst Where to put the uncompressed data. (Assumes OBJPAGELEN size.)
	1517	* @param pbSrc The compressed source data.
	1518	* @param cbSrc The file size of the compressed data. The source buffer
	1519	* contains 4 additional zero bytes.
	1520	*/
	1521	static int kldrModLXDoIterDataUnpacking(KU8 pbDst, const KU8 pbSrc, int cbSrc)
	1522	{
	1523	const struct LX_Iter pIter = (const struct LX_Iter )pbSrc;
	1524	int cbDst = OBJPAGELEN;
	1525
	1526	/* Validate size of data. */
[96]	1527	if (cbSrc >= (int)OBJPAGELEN - 2)
[2]	1528	return KLDR_ERR_LX_BAD_ITERDATA;
	1529
	1530	/*
	1531	* Expand the page.
	1532	*/
	1533	while (cbSrc > 0 && pIter->LX_nIter)
	1534	{
	1535	if (pIter->LX_nBytes == 1)
	1536	{
	1537	/*
	1538	* Special case - one databyte.
	1539	*/
	1540	cbDst -= pIter->LX_nIter;
	1541	if (cbDst < 0)
	1542	return KLDR_ERR_LX_BAD_ITERDATA;
	1543
	1544	cbSrc -= 4 + 1;
	1545	if (cbSrc < -4)
	1546	return KLDR_ERR_LX_BAD_ITERDATA;
	1547
	1548	kHlpMemSet(pbDst, pIter->LX_Iterdata, pIter->LX_nIter);
	1549	pbDst += pIter->LX_nIter;
	1550	pIter++;
	1551	}
	1552	else
	1553	{
	1554	/*
	1555	* General.
	1556	*/
	1557	int i;
	1558
	1559	cbDst -= pIter->LX_nIter * pIter->LX_nBytes;
	1560	if (cbDst < 0)
	1561	return KLDR_ERR_LX_BAD_ITERDATA;
	1562
	1563	cbSrc -= 4 + pIter->LX_nBytes;
	1564	if (cbSrc < -4)
	1565	return KLDR_ERR_LX_BAD_ITERDATA;
	1566
	1567	for (i = pIter->LX_nIter; i > 0; i--, pbDst += pIter->LX_nBytes)
	1568	kHlpMemCopy(pbDst, &pIter->LX_Iterdata, pIter->LX_nBytes);
	1569	pIter = (struct LX_Iter )((char)pIter + 4 + pIter->LX_nBytes);
	1570	}
	1571	}
	1572
	1573	/*
	1574	* Zero remainder of the page.
	1575	*/
	1576	if (cbDst > 0)
	1577	kHlpMemSet(pbDst, 0, cbDst);
	1578
	1579	return 0;
	1580	}
	1581
	1582
	1583	/**
	1584	* Unpacks iterdata (aka EXEPACK).
	1585	*
	1586	* @returns 0 on success, non-zero kLdr status code on failure.
	1587	* @param pbDst Where to put the uncompressed data. (Assumes OBJPAGELEN size.)
	1588	* @param pbSrc The compressed source data.
	1589	* @param cbSrc The file size of the compressed data. The source buffer
	1590	* contains 4 additional zero bytes.
	1591	*/
	1592	static int kldrModLXDoIterData2Unpacking(KU8 pbDst, const KU8 pbSrc, int cbSrc)
	1593	{
	1594	int cbDst = OBJPAGELEN;
	1595
	1596	while (cbSrc > 0)
	1597	{
	1598	/*
	1599	* Bit 0 and 1 is the encoding type.
	1600	*/
	1601	switch (*pbSrc & 0x03)
	1602	{
	1603	/*
	1604	*
	1605	* 0 1 2 3 4 5 6 7
	1606	* type \| \|
	1607	* ----------------
	1608	* cb <cb bytes of data>
	1609	*
	1610	* Bits 2-7 is, if not zero, the length of an uncompressed run
	1611	* starting at the following byte.
	1612	*
	1613	* 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
	1614	* type \| \| \| \| \| \|
	1615	* ---------------- ---------------------- -----------------------
	1616	* zero cb char to multiply
	1617	*
	1618	* If the bits are zero, the following two bytes describes a 1 byte interation
	1619	* run. First byte is count, second is the byte to copy. A count of zero is
	1620	* means end of data, and we simply stops. In that case the rest of the data
	1621	* should be zero.
	1622	*/
	1623	case 0:
	1624	{
	1625	if (*pbSrc)
	1626	{
	1627	const int cb = *pbSrc >> 2;
	1628	cbDst -= cb;
	1629	if (cbDst < 0)
	1630	return KLDR_ERR_LX_BAD_ITERDATA2;
	1631	cbSrc -= cb + 1;
	1632	if (cbSrc < 0)
	1633	return KLDR_ERR_LX_BAD_ITERDATA2;
	1634	kHlpMemCopy(pbDst, ++pbSrc, cb);
	1635	pbDst += cb;
	1636	pbSrc += cb;
	1637	}
	1638	else if (cbSrc < 2)
	1639	return KLDR_ERR_LX_BAD_ITERDATA2;
	1640	else
	1641	{
	1642	const int cb = pbSrc[1];
	1643	if (!cb)
	1644	goto l_endloop;
	1645	cbDst -= cb;
	1646	if (cbDst < 0)
	1647	return KLDR_ERR_LX_BAD_ITERDATA2;
	1648	cbSrc -= 3;
	1649	if (cbSrc < 0)
	1650	return KLDR_ERR_LX_BAD_ITERDATA2;
	1651	kHlpMemSet(pbDst, pbSrc[2], cb);
	1652	pbDst += cb;
	1653	pbSrc += 3;
	1654	}
	1655	break;
	1656	}
	1657
	1658
	1659	/*
	1660	* 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
	1661	* type \| \| \| \| \| \|
	1662	* ---- ------- -------------------------
	1663	* cb1 cb2 - 3 offset <cb1 bytes of data>
	1664	*
	1665	* Two bytes layed out as described above, followed by cb1 bytes of data to be copied.
	1666	* The cb2(+3) and offset describes an amount of data to be copied from the expanded
	1667	* data relative to the current position. The data copied as you would expect it to be.
	1668	*/
	1669	case 1:
	1670	{
	1671	cbSrc -= 2;
	1672	if (cbSrc < 0)
	1673	return KLDR_ERR_LX_BAD_ITERDATA2;
	1674	else
	1675	{
	1676	const unsigned off = ((unsigned)pbSrc[1] << 1) \| (*pbSrc >> 7);
	1677	const int cb1 = (*pbSrc >> 2) & 3;
	1678	const int cb2 = ((*pbSrc >> 4) & 7) + 3;
	1679
	1680	pbSrc += 2;
	1681	cbSrc -= cb1;
	1682	if (cbSrc < 0)
	1683	return KLDR_ERR_LX_BAD_ITERDATA2;
	1684	cbDst -= cb1;
	1685	if (cbDst < 0)
	1686	return KLDR_ERR_LX_BAD_ITERDATA2;
	1687	kHlpMemCopy(pbDst, pbSrc, cb1);
	1688	pbDst += cb1;
	1689	pbSrc += cb1;
	1690
[28]	1691	if (off > OBJPAGELEN - (unsigned)cbDst)
[2]	1692	return KLDR_ERR_LX_BAD_ITERDATA2;
	1693	cbDst -= cb2;
	1694	if (cbDst < 0)
	1695	return KLDR_ERR_LX_BAD_ITERDATA2;
	1696	kHlpMemMove(pbDst, pbDst - off, cb2);
	1697	pbDst += cb2;
	1698	}
	1699	break;
	1700	}
	1701
	1702
	1703	/*
	1704	* 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
	1705	* type \| \| \| \|
	1706	* ---- ----------------------------------
	1707	* cb-3 offset
	1708	*
	1709	* Two bytes layed out as described above.
	1710	* The cb(+3) and offset describes an amount of data to be copied from the expanded
	1711	* data relative to the current position.
	1712	*
	1713	* If offset == 1 the data is not copied as expected, but in the memcpyw manner.
	1714	*/
	1715	case 2:
	1716	{
	1717	cbSrc -= 2;
	1718	if (cbSrc < 0)
	1719	return KLDR_ERR_LX_BAD_ITERDATA2;
	1720	else
	1721	{
	1722	const unsigned off = ((unsigned)pbSrc[1] << 4) \| (*pbSrc >> 4);
	1723	const int cb = ((*pbSrc >> 2) & 3) + 3;
	1724
	1725	pbSrc += 2;
[28]	1726	if (off > OBJPAGELEN - (unsigned)cbDst)
[2]	1727	return KLDR_ERR_LX_BAD_ITERDATA2;
	1728	cbDst -= cb;
	1729	if (cbDst < 0)
	1730	return KLDR_ERR_LX_BAD_ITERDATA2;
	1731	kLdrModLXMemCopyW(pbDst, pbDst - off, cb);
	1732	pbDst += cb;
	1733	}
	1734	break;
	1735	}
	1736
	1737
	1738	/*
	1739	* 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
	1740	* type \| \| \| \| \| \|
	1741	* ---------- ---------------- ----------------------------------
	1742	* cb1 cb2 offset <cb1 bytes of data>
	1743	*
	1744	* Three bytes layed out as described above, followed by cb1 bytes of data to be copied.
	1745	* The cb2 and offset describes an amount of data to be copied from the expanded
	1746	* data relative to the current position.
	1747	*
	1748	* If offset == 1 the data is not copied as expected, but in the memcpyw manner.
	1749	*/
	1750	case 3:
	1751	{
	1752	cbSrc -= 3;
	1753	if (cbSrc < 0)
	1754	return KLDR_ERR_LX_BAD_ITERDATA2;
	1755	else
	1756	{
	1757	const int cb1 = (*pbSrc >> 2) & 0xf;
	1758	const int cb2 = ((pbSrc[1] & 0xf) << 2) \| (*pbSrc >> 6);
	1759	const unsigned off = ((unsigned)pbSrc[2] << 4) \| (pbSrc[1] >> 4);
	1760
	1761	pbSrc += 3;
	1762	cbSrc -= cb1;
	1763	if (cbSrc < 0)
	1764	return KLDR_ERR_LX_BAD_ITERDATA2;
	1765	cbDst -= cb1;
	1766	if (cbDst < 0)
	1767	return KLDR_ERR_LX_BAD_ITERDATA2;
	1768	kHlpMemCopy(pbDst, pbSrc, cb1);
	1769	pbDst += cb1;
	1770	pbSrc += cb1;
	1771
[28]	1772	if (off > OBJPAGELEN - (unsigned)cbDst)
[2]	1773	return KLDR_ERR_LX_BAD_ITERDATA2;
	1774	cbDst -= cb2;
	1775	if (cbDst < 0)
	1776	return KLDR_ERR_LX_BAD_ITERDATA2;
	1777	kLdrModLXMemCopyW(pbDst, pbDst - off, cb2);
	1778	pbDst += cb2;
	1779	}
	1780	break;
	1781	}
	1782	} /* type switch. */
	1783	} /* unpack loop */
	1784
	1785	l_endloop:
	1786
	1787
	1788	/*
	1789	* Zero remainder of the page.
	1790	*/
	1791	if (cbDst > 0)
	1792	kHlpMemSet(pbDst, 0, cbDst);
	1793
	1794	return 0;
	1795	}
	1796
	1797
	1798	/**
	1799	* Special memcpy employed by the iterdata2 algorithm.
	1800	*
	1801	* Emulate a 16-bit memcpy (copying 16-bit at a time) and the effects this
	1802	* has if src is very close to the destination.
	1803	*
	1804	* @param pbDst Destination pointer.
	1805	* @param pbSrc Source pointer. Will always be <= pbDst.
	1806	* @param cb Amount of data to be copied.
	1807	* @remark This assumes that unaligned word and dword access is fine.
	1808	*/
	1809	static void kLdrModLXMemCopyW(KU8 pbDst, const KU8 pbSrc, int cb)
	1810	{
	1811	switch (pbDst - pbSrc)
	1812	{
	1813	case 0:
	1814	case 1:
	1815	case 2:
	1816	case 3:
	1817	/* 16-bit copy (unaligned) */
	1818	if (cb & 1)
	1819	pbDst++ = pbSrc++;
	1820	for (cb >>= 1; cb > 0; cb--, pbDst += 2, pbSrc += 2)
	1821	(KU16 )pbDst = (const KU16 )pbSrc;
	1822	break;
	1823
	1824	default:
	1825	/* 32-bit copy (unaligned) */
	1826	if (cb & 1)
	1827	pbDst++ = pbSrc++;
	1828	if (cb & 2)
	1829	{
	1830	(KU16 )pbDst = (const KU16 )pbSrc;
	1831	pbDst += 2;
	1832	pbSrc += 2;
	1833	}
	1834	for (cb >>= 2; cb > 0; cb--, pbDst += 4, pbSrc += 4)
	1835	(KU32 )pbDst = (const KU32 )pbSrc;
	1836	break;
	1837	}
	1838	}
	1839
	1840
	1841	/**
	1842	* Unprotects or protects the specified image mapping.
	1843	*
	1844	* @returns 0 on success.
	1845	* @returns non-zero kLdr or OS status code on failure.
	1846	*
	1847	* @param pModLX The LX module interpreter instance.
	1848	* @param pvBits The mapping to protect.
	1849	* @param UnprotectOrProtect If 1 unprotect (i.e. make all writable), otherwise
	1850	* protect according to the object table.
	1851	*/
	1852	static int kldrModLXDoProtect(PKLDRMODLX pModLX, void *pvBits, unsigned fUnprotectOrProtect)
	1853	{
	1854	KU32 i;
	1855	PKLDRMOD pMod = pModLX->pMod;
	1856
	1857	/*
	1858	* Change object protection.
	1859	*/
	1860	for (i = 0; i < pMod->cSegments; i++)
	1861	{
	1862	int rc;
	1863	void *pv;
	1864	KPROT enmProt;
	1865
	1866	/* calc new protection. */
	1867	enmProt = pMod->aSegments[i].enmProt;
	1868	if (fUnprotectOrProtect)
	1869	{
	1870	switch (enmProt)
	1871	{
	1872	case KPROT_NOACCESS:
	1873	case KPROT_READONLY:
	1874	case KPROT_READWRITE:
	1875	case KPROT_WRITECOPY:
	1876	enmProt = KPROT_READWRITE;
	1877	break;
	1878	case KPROT_EXECUTE:
	1879	case KPROT_EXECUTE_READ:
	1880	case KPROT_EXECUTE_READWRITE:
	1881	case KPROT_EXECUTE_WRITECOPY:
	1882	enmProt = KPROT_EXECUTE_READWRITE;
	1883	break;
	1884	default:
	1885	KLDRMODLX_ASSERT(!"bad enmProt");
	1886	return -1;
	1887	}
	1888	}
	1889	else
	1890	{
	1891	/* copy on write -> normal write. */
	1892	if (enmProt == KPROT_EXECUTE_WRITECOPY)
	1893	enmProt = KPROT_EXECUTE_READWRITE;
	1894	else if (enmProt == KPROT_WRITECOPY)
	1895	enmProt = KPROT_READWRITE;
	1896	}
	1897
	1898
	1899	/* calc the address and set page protection. */
	1900	pv = (KU8 *)pvBits + pMod->aSegments[i].RVA;
	1901
	1902	rc = kHlpPageProtect(pv, pMod->aSegments[i].cbMapped, enmProt);
	1903	if (rc)
	1904	break;
	1905
	1906	/** @todo the gap page should be marked NOACCESS! */
	1907	}
	1908
	1909	return 0;
	1910	}
	1911
	1912
	1913	/** @copydoc kLdrModUnmap */
	1914	static int kldrModLXUnmap(PKLDRMOD pMod)
	1915	{
	1916	PKLDRMODLX pModLX = (PKLDRMODLX)pMod->pvData;
	1917	KU32 i;
	1918	int rc;
	1919
	1920	/*
	1921	* Mapped?
	1922	*/
	1923	if (!pModLX->pvMapping)
	1924	return KLDR_ERR_NOT_MAPPED;
	1925
	1926	/*
	1927	* Free the mapping and update the segments.
	1928	*/
	1929	rc = kHlpPageFree((void *)pModLX->pvMapping, pModLX->cbMapped);
	1930	KLDRMODLX_ASSERT(!rc);
	1931	pModLX->pvMapping = NULL;
	1932
	1933	for (i = 0; i < pMod->cSegments; i++)
	1934	pMod->aSegments[i].MapAddress = 0;
	1935
	1936	return rc;
	1937	}
	1938
	1939
	1940	/** @copydoc kLdrModAllocTLS */
[81]	1941	static int kldrModLXAllocTLS(PKLDRMOD pMod, void *pvMapping)
[2]	1942	{
	1943	PKLDRMODLX pModLX = (PKLDRMODLX)pMod->pvData;
	1944
	1945	/* no tls, just do the error checking. */
[81]	1946	if ( pvMapping == KLDRMOD_INT_MAP
	1947	&& pModLX->pvMapping)
[2]	1948	return KLDR_ERR_NOT_MAPPED;
	1949	return 0;
	1950	}
	1951
	1952
	1953	/** @copydoc kLdrModFreeTLS */
[81]	1954	static void kldrModLXFreeTLS(PKLDRMOD pMod, void *pvMapping)
[2]	1955	{
	1956	/* no tls. */
[79]	1957	K_NOREF(pMod);
[81]	1958	K_NOREF(pvMapping);
[79]	1959
[2]	1960	}
	1961
	1962
	1963	/** @copydoc kLdrModReload */
	1964	static int kldrModLXReload(PKLDRMOD pMod)
	1965	{
	1966	PKLDRMODLX pModLX = (PKLDRMODLX)pMod->pvData;
	1967	int rc, rc2;
	1968
	1969	/*
	1970	* Mapped?
	1971	*/
	1972	if (!pModLX->pvMapping)
	1973	return KLDR_ERR_NOT_MAPPED;
	1974
	1975	/*
	1976	* Before doing anything we'll have to make all pages writable.
	1977	*/
	1978	rc = kldrModLXDoProtect(pModLX, (void )pModLX->pvMapping, 1 / unprotect */);
	1979	if (rc)
	1980	return rc;
	1981
	1982	/*
	1983	* Load the bits again.
	1984	*/
	1985	rc = kldrModLXDoLoadBits(pModLX, (void *)pModLX->pvMapping);
	1986
	1987	/*
	1988	* Restore protection.
	1989	*/
	1990	rc2 = kldrModLXDoProtect(pModLX, (void )pModLX->pvMapping, 0 / protect */);
	1991	if (!rc && rc2)
	1992	rc = rc2;
	1993	return rc;
	1994	}
	1995
	1996
	1997	/** @copydoc kLdrModFixupMapping */
	1998	static int kldrModLXFixupMapping(PKLDRMOD pMod, PFNKLDRMODGETIMPORT pfnGetImport, void *pvUser)
	1999	{
	2000	PKLDRMODLX pModLX = (PKLDRMODLX)pMod->pvData;
	2001	int rc, rc2;
	2002
	2003	/*
	2004	* Mapped?
	2005	*/
	2006	if (!pModLX->pvMapping)
	2007	return KLDR_ERR_NOT_MAPPED;
	2008
	2009	/*
	2010	* Before doing anything we'll have to make all pages writable.
	2011	*/
	2012	rc = kldrModLXDoProtect(pModLX, (void )pModLX->pvMapping, 1 / unprotect */);
	2013	if (rc)
	2014	return rc;
	2015
	2016	/*
	2017	* Apply fixups and resolve imports.
	2018	*/
	2019	rc = kldrModLXRelocateBits(pMod, (void *)pModLX->pvMapping, (KUPTR)pModLX->pvMapping,
	2020	pMod->aSegments[0].LinkAddress, pfnGetImport, pvUser);
	2021
	2022	/*
	2023	* Restore protection.
	2024	*/
	2025	rc2 = kldrModLXDoProtect(pModLX, (void )pModLX->pvMapping, 0 / protect */);
	2026	if (!rc && rc2)
	2027	rc = rc2;
	2028	return rc;
	2029	}
	2030
	2031
	2032	/** @copydoc kLdrModCallInit */
[81]	2033	static int kldrModLXCallInit(PKLDRMOD pMod, void *pvMapping, KUPTR uHandle)
[2]	2034	{
	2035	PKLDRMODLX pModLX = (PKLDRMODLX)pMod->pvData;
	2036	int rc;
	2037
	2038	/*
	2039	* Mapped?
	2040	*/
[81]	2041	if (pvMapping == KLDRMOD_INT_MAP)
	2042	{
[87]	2043	pvMapping = (void *)pModLX->pvMapping;
[81]	2044	if (!pvMapping)
	2045	return KLDR_ERR_NOT_MAPPED;
	2046	}
[2]	2047
	2048	/*
	2049	* Do TLS callbacks first and then call the init/term function if it's a DLL.
	2050	*/
	2051	if ((pModLX->Hdr.e32_mflags & E32MODMASK) == E32MODDLL)
[81]	2052	rc = kldrModLXDoCallDLL(pModLX, pvMapping, 0 /* attach */, uHandle);
[2]	2053	else
	2054	rc = 0;
	2055	return rc;
	2056	}
	2057
	2058
	2059	/**
	2060	* Call the DLL entrypoint.
	2061	*
	2062	* @returns 0 on success.
	2063	* @returns KLDR_ERR_MODULE_INIT_FAILED or KLDR_ERR_THREAD_ATTACH_FAILED on failure.
	2064	* @param pModLX The LX module interpreter instance.
[81]	2065	* @param pvMapping The module mapping to use (resolved).
[2]	2066	* @param uOp The operation (DLL_*).
	2067	* @param uHandle The module handle to present.
	2068	*/
[81]	2069	static int kldrModLXDoCallDLL(PKLDRMODLX pModLX, void *pvMapping, unsigned uOp, KUPTR uHandle)
[2]	2070	{
	2071	int rc;
	2072
	2073	/*
	2074	* If no entrypoint there isn't anything to be done.
	2075	*/
	2076	if ( !pModLX->Hdr.e32_startobj
	2077	\|\| pModLX->Hdr.e32_startobj > pModLX->Hdr.e32_objcnt)
	2078	return 0;
	2079
	2080	/*
	2081	* Invoke the entrypoint and convert the boolean result to a kLdr status code.
	2082	*/
[81]	2083	rc = kldrModLXDoCall((KUPTR)pvMapping
[2]	2084	+ (KUPTR)pModLX->pMod->aSegments[pModLX->Hdr.e32_startobj - 1].RVA
	2085	+ pModLX->Hdr.e32_eip,
	2086	uHandle, uOp, NULL);
	2087	if (rc)
	2088	rc = 0;
	2089	else if (uOp == 0 /* attach */)
	2090	rc = KLDR_ERR_MODULE_INIT_FAILED;
	2091	else /* detach: ignore failures */
	2092	rc = 0;
	2093	return rc;
	2094	}
	2095
	2096
	2097	/**
	2098	* Do a 3 parameter callback.
	2099	*
	2100	* @returns 32-bit callback return.
	2101	* @param uEntrypoint The address of the function to be called.
	2102	* @param uHandle The first argument, the module handle.
	2103	* @param uOp The second argumnet, the reason we're calling.
	2104	* @param pvReserved The third argument, reserved argument. (figure this one out)
	2105	*/
[117]	2106	KI32 kldrModLXDoCall(KUPTR uEntrypoint, KUPTR uHandle, KU32 uOp, void *pvReserved)
[2]	2107	{
	2108	#if defined(__X86__) \|\| defined(__i386__) \|\| defined(_M_IX86)
	2109	KI32 rc;
	2110	/** @todo try/except */
	2111
	2112	/*
	2113	* Paranoia.
	2114	*/
	2115	# ifdef __GNUC__
	2116	__asm__ __volatile__(
	2117	"pushl %2\n\t"
	2118	"pushl %1\n\t"
	2119	"pushl %0\n\t"
	2120	"lea 12(%%esp), %2\n\t"
	2121	"call *%3\n\t"
	2122	"movl %2, %%esp\n\t"
	2123	: "=a" (rc)
	2124	: "d" (uOp),
	2125	"S" (0),
	2126	"c" (uEntrypoint),
	2127	"0" (uHandle));
	2128	# elif defined(_MSC_VER)
	2129	__asm {
	2130	mov eax, [uHandle]
	2131	mov edx, [uOp]
	2132	mov ecx, 0
	2133	mov ebx, [uEntrypoint]
	2134	push edi
	2135	mov edi, esp
	2136	push ecx
	2137	push edx
	2138	push eax
	2139	call ebx
	2140	mov esp, edi
	2141	pop edi
	2142	mov [rc], eax
	2143	}
	2144	# else
	2145	# error "port me!"
	2146	# endif
[80]	2147	K_NOREF(pvReserved);
[2]	2148	return rc;
	2149
	2150	#else
[79]	2151	K_NOREF(uEntrypoint);
	2152	K_NOREF(uHandle);
	2153	K_NOREF(uOp);
	2154	K_NOREF(pvReserved);
[2]	2155	return KCPU_ERR_ARCH_CPU_NOT_COMPATIBLE;
	2156	#endif
	2157	}
	2158
	2159
	2160	/** @copydoc kLdrModCallTerm */
[81]	2161	static int kldrModLXCallTerm(PKLDRMOD pMod, void *pvMapping, KUPTR uHandle)
[2]	2162	{
	2163	PKLDRMODLX pModLX = (PKLDRMODLX)pMod->pvData;
	2164
	2165	/*
	2166	* Mapped?
	2167	*/
[81]	2168	if (pvMapping == KLDRMOD_INT_MAP)
	2169	{
[87]	2170	pvMapping = (void *)pModLX->pvMapping;
[81]	2171	if (!pvMapping)
	2172	return KLDR_ERR_NOT_MAPPED;
	2173	}
[2]	2174
	2175	/*
	2176	* Do the call.
	2177	*/
	2178	if ((pModLX->Hdr.e32_mflags & E32MODMASK) == E32MODDLL)
[81]	2179	kldrModLXDoCallDLL(pModLX, pvMapping, 1 /* detach */, uHandle);
[2]	2180
	2181	return 0;
	2182	}
	2183
	2184
	2185	/** @copydoc kLdrModCallThread */
[81]	2186	static int kldrModLXCallThread(PKLDRMOD pMod, void *pvMapping, KUPTR uHandle, unsigned fAttachingOrDetaching)
[2]	2187	{
	2188	/* no thread attach/detach callout. */
[79]	2189	K_NOREF(pMod);
[81]	2190	K_NOREF(pvMapping);
[79]	2191	K_NOREF(uHandle);
	2192	K_NOREF(fAttachingOrDetaching);
[2]	2193	return 0;
	2194	}
	2195
	2196
	2197	/** @copydoc kLdrModSize */
	2198	static KLDRADDR kldrModLXSize(PKLDRMOD pMod)
	2199	{
	2200	PKLDRMODLX pModLX = (PKLDRMODLX)pMod->pvData;
	2201	return pModLX->cbMapped;
	2202	}
	2203
	2204
	2205	/** @copydoc kLdrModGetBits */
	2206	static int kldrModLXGetBits(PKLDRMOD pMod, void pvBits, KLDRADDR BaseAddress, PFNKLDRMODGETIMPORT pfnGetImport, void pvUser)
	2207	{
	2208	PKLDRMODLX pModLX = (PKLDRMODLX)pMod->pvData;
	2209	int rc;
	2210
	2211	/*
	2212	* Load the image bits.
	2213	*/
	2214	rc = kldrModLXDoLoadBits(pModLX, pvBits);
	2215	if (rc)
	2216	return rc;
	2217
	2218	/*
	2219	* Perform relocations.
	2220	*/
	2221	return kldrModLXRelocateBits(pMod, pvBits, BaseAddress, pMod->aSegments[0].LinkAddress, pfnGetImport, pvUser);
	2222
	2223	}
	2224
	2225
	2226	/** @copydoc kLdrModRelocateBits */
	2227	static int kldrModLXRelocateBits(PKLDRMOD pMod, void *pvBits, KLDRADDR NewBaseAddress, KLDRADDR OldBaseAddress,
	2228	PFNKLDRMODGETIMPORT pfnGetImport, void *pvUser)
	2229	{
	2230	PKLDRMODLX pModLX = (PKLDRMODLX)pMod->pvData;
	2231	KU32 iSeg;
	2232	int rc;
	2233
	2234	/*
	2235	* Do we need to to anything?
	2236	*/
	2237	if ( NewBaseAddress == OldBaseAddress
	2238	&& NewBaseAddress == pModLX->paObjs[0].o32_base
	2239	&& !pModLX->Hdr.e32_impmodcnt)
	2240	return 0;
	2241
	2242	/*
	2243	* Load the fixup section.
	2244	*/
	2245	if (!pModLX->pbFixupSection)
	2246	{
	2247	rc = kldrModLXDoLoadFixupSection(pModLX);
	2248	if (rc)
	2249	return rc;
	2250	}
	2251
	2252	/*
	2253	* Iterate the segments.
	2254	*/
	2255	for (iSeg = 0; iSeg < pModLX->Hdr.e32_objcnt; iSeg++)
	2256	{
	2257	const struct o32_obj * const pObj = &pModLX->paObjs[iSeg];
	2258	KLDRADDR PageAddress = NewBaseAddress + pModLX->pMod->aSegments[iSeg].RVA;
	2259	KU32 iPage;
	2260	KU8 pbPage = (KU8 )pvBits + (KUPTR)pModLX->pMod->aSegments[iSeg].RVA;
	2261
	2262	/*
	2263	* Iterate the page map pages.
	2264	*/
	2265	for (iPage = 0, rc = 0; !rc && iPage < pObj->o32_mapsize; iPage++, pbPage += OBJPAGELEN, PageAddress += OBJPAGELEN)
	2266	{
	2267	const KU8 * const pbFixupRecEnd = pModLX->pbFixupRecs + pModLX->paoffPageFixups[iPage + pObj->o32_pagemap];
	2268	const KU8 *pb = pModLX->pbFixupRecs + pModLX->paoffPageFixups[iPage + pObj->o32_pagemap - 1];
[79]	2269	KLDRADDR uValue = NIL_KLDRADDR;
	2270	KU32 fKind = 0;
[2]	2271	int iSelector;
	2272
	2273	/* sanity */
	2274	if (pbFixupRecEnd < pb)
	2275	return KLDR_ERR_BAD_FIXUP;
	2276	if (pbFixupRecEnd - 1 > pModLX->pbFixupSectionLast)
	2277	return KLDR_ERR_BAD_FIXUP;
	2278	if (pb < pModLX->pbFixupSection)
	2279	return KLDR_ERR_BAD_FIXUP;
	2280
	2281	/*
	2282	* Iterate the fixup record.
	2283	*/
	2284	while (pb < pbFixupRecEnd)
	2285	{
	2286	union _rel
	2287	{
	2288	const KU8 * pb;
	2289	const struct r32_rlc *prlc;
	2290	} u;
	2291
	2292	u.pb = pb;
	2293	pb += 3 + (u.prlc->nr_stype & NRCHAIN ? 0 : 1); /* place pch at the 4th member. */
	2294
	2295	/*
	2296	* Figure out the target.
	2297	*/
	2298	switch (u.prlc->nr_flags & NRRTYP)
	2299	{
	2300	/*
	2301	* Internal fixup.
	2302	*/
	2303	case NRRINT:
	2304	{
	2305	KU16 iTrgObject;
	2306	KU32 offTrgObject;
	2307
	2308	/* the object */
	2309	if (u.prlc->nr_flags & NR16OBJMOD)
	2310	{
	2311	iTrgObject = (const KU16 )pb;
	2312	pb += 2;
	2313	}
	2314	else
	2315	iTrgObject = *pb++;
	2316	iTrgObject--;
	2317	if (iTrgObject >= pModLX->Hdr.e32_objcnt)
	2318	return KLDR_ERR_BAD_FIXUP;
	2319
	2320	/* the target */
	2321	if ((u.prlc->nr_stype & NRSRCMASK) != NRSSEG)
	2322	{
	2323	if (u.prlc->nr_flags & NR32BITOFF)
	2324	{
	2325	offTrgObject = (const KU32 )pb;
	2326	pb += 4;
	2327	}
	2328	else
	2329	{
	2330	offTrgObject = (const KU16 )pb;
	2331	pb += 2;
	2332	}
	2333
	2334	/* calculate the symbol info. */
	2335	uValue = offTrgObject + NewBaseAddress + pMod->aSegments[iTrgObject].RVA;
	2336	}
	2337	else
	2338	uValue = NewBaseAddress + pMod->aSegments[iTrgObject].RVA;
	2339	if ( (u.prlc->nr_stype & NRALIAS)
	2340	\|\| (pMod->aSegments[iTrgObject].fFlags & KLDRSEG_FLAG_16BIT))
	2341	iSelector = pMod->aSegments[iTrgObject].Sel16bit;
	2342	else
	2343	iSelector = pMod->aSegments[iTrgObject].SelFlat;
	2344	fKind = 0;
	2345	break;
	2346	}
	2347
	2348	/*
	2349	* Import by symbol ordinal.
	2350	*/
	2351	case NRRORD:
	2352	{
	2353	KU16 iModule;
	2354	KU32 iSymbol;
	2355
	2356	/* the module ordinal */
	2357	if (u.prlc->nr_flags & NR16OBJMOD)
	2358	{
	2359	iModule = (const KU16 )pb;
	2360	pb += 2;
	2361	}
	2362	else
	2363	iModule = *pb++;
	2364	iModule--;
	2365	if (iModule >= pModLX->Hdr.e32_impmodcnt)
	2366	return KLDR_ERR_BAD_FIXUP;
	2367	#if 1
	2368	if (u.prlc->nr_flags & NRICHAIN)
	2369	return KLDR_ERR_BAD_FIXUP;
	2370	#endif
	2371
	2372	/* . */
	2373	if (u.prlc->nr_flags & NR32BITOFF)
	2374	{
	2375	iSymbol = (const KU32 )pb;
	2376	pb += 4;
	2377	}
	2378	else if (!(u.prlc->nr_flags & NR8BITORD))
	2379	{
	2380	iSymbol = (const KU16 )pb;
	2381	pb += 2;
	2382	}
	2383	else
	2384	iSymbol = *pb++;
	2385
	2386	/* resolve it. */
	2387	rc = pfnGetImport(pMod, iModule, iSymbol, NULL, 0, NULL, &uValue, &fKind, pvUser);
	2388	if (rc)
	2389	return rc;
	2390	iSelector = -1;
	2391	break;
	2392	}
	2393
	2394	/*
	2395	* Import by symbol name.
	2396	*/
	2397	case NRRNAM:
	2398	{
	2399	KU32 iModule;
	2400	KU16 offSymbol;
	2401	const KU8 *pbSymbol;
	2402
	2403	/* the module ordinal */
	2404	if (u.prlc->nr_flags & NR16OBJMOD)
	2405	{
	2406	iModule = (const KU16 )pb;
	2407	pb += 2;
	2408	}
	2409	else
	2410	iModule = *pb++;
	2411	iModule--;
	2412	if (iModule >= pModLX->Hdr.e32_impmodcnt)
	2413	return KLDR_ERR_BAD_FIXUP;
	2414	#if 1
	2415	if (u.prlc->nr_flags & NRICHAIN)
	2416	return KLDR_ERR_BAD_FIXUP;
	2417	#endif
	2418
	2419	/* . */
	2420	if (u.prlc->nr_flags & NR32BITOFF)
	2421	{
	2422	offSymbol = (const KU32 )pb;
	2423	pb += 4;
	2424	}
	2425	else if (!(u.prlc->nr_flags & NR8BITORD))
	2426	{
	2427	offSymbol = (const KU16 )pb;
	2428	pb += 2;
	2429	}
	2430	else
	2431	offSymbol = *pb++;
	2432	pbSymbol = pModLX->pbImportProcs + offSymbol;
	2433	if ( pbSymbol < pModLX->pbImportProcs
	2434	\|\| pbSymbol > pModLX->pbFixupSectionLast)
	2435	return KLDR_ERR_BAD_FIXUP;
	2436
	2437	/* resolve it. */
	2438	rc = pfnGetImport(pMod, iModule, NIL_KLDRMOD_SYM_ORDINAL, (const char )pbSymbol + 1, pbSymbol, NULL,
	2439	&uValue, &fKind, pvUser);
	2440	if (rc)
	2441	return rc;
	2442	iSelector = -1;
	2443	break;
	2444	}
	2445
	2446	case NRRENT:
	2447	KLDRMODLX_ASSERT(!"NRRENT");
[102]	2448	/* Falls through. */
[2]	2449	default:
[28]	2450	iSelector = -1;
[2]	2451	break;
	2452	}
	2453
	2454	/* addend */
	2455	if (u.prlc->nr_flags & NRADD)
	2456	{
	2457	if (u.prlc->nr_flags & NR32BITADD)
	2458	{
	2459	uValue += (const KU32 )pb;
	2460	pb += 4;
	2461	}
	2462	else
	2463	{
	2464	uValue += (const KU16 )pb;
	2465	pb += 2;
	2466	}
	2467	}
	2468
	2469
	2470	/*
	2471	* Deal with the 'source' (i.e. the place that should be modified - very logical).
	2472	*/
	2473	if (!(u.prlc->nr_stype & NRCHAIN))
	2474	{
	2475	int off = u.prlc->r32_soff;
	2476
	2477	/* common / simple */
	2478	if ( (u.prlc->nr_stype & NRSRCMASK) == NROFF32
	2479	&& off >= 0
[96]	2480	&& off <= (int)OBJPAGELEN - 4)
[87]	2481	(KU32 )&pbPage[off] = (KU32)uValue;
[2]	2482	else if ( (u.prlc->nr_stype & NRSRCMASK) == NRSOFF32
	2483	&& off >= 0
[96]	2484	&& off <= (int)OBJPAGELEN - 4)
[87]	2485	(KU32 )&pbPage[off] = (KU32)(uValue - (PageAddress + off + 4));
[2]	2486	else
	2487	{
	2488	/* generic */
	2489	rc = kldrModLXDoReloc(pbPage, off, PageAddress, u.prlc, iSelector, uValue, fKind);
	2490	if (rc)
	2491	return rc;
	2492	}
	2493	}
	2494	else if (!(u.prlc->nr_flags & NRICHAIN))
	2495	{
	2496	const KI16 poffSrc = (const KI16 )pb;
	2497	KU8 c = u.pb[2];
	2498
	2499	/* common / simple */
	2500	if ((u.prlc->nr_stype & NRSRCMASK) == NROFF32)
	2501	{
	2502	while (c-- > 0)
	2503	{
	2504	int off = *poffSrc++;
[96]	2505	if (off >= 0 && off <= (int)OBJPAGELEN - 4)
[87]	2506	(KU32 )&pbPage[off] = (KU32)uValue;
[2]	2507	else
	2508	{
	2509	rc = kldrModLXDoReloc(pbPage, off, PageAddress, u.prlc, iSelector, uValue, fKind);
	2510	if (rc)
	2511	return rc;
	2512	}
	2513	}
	2514	}
	2515	else if ((u.prlc->nr_stype & NRSRCMASK) == NRSOFF32)
	2516	{
	2517	while (c-- > 0)
	2518	{
	2519	int off = *poffSrc++;
[96]	2520	if (off >= 0 && off <= (int)OBJPAGELEN - 4)
[87]	2521	(KU32 )&pbPage[off] = (KU32)(uValue - (PageAddress + off + 4));
[2]	2522	else
	2523	{
	2524	rc = kldrModLXDoReloc(pbPage, off, PageAddress, u.prlc, iSelector, uValue, fKind);
	2525	if (rc)
	2526	return rc;
	2527	}
	2528	}
	2529	}
	2530	else
	2531	{
	2532	while (c-- > 0)
	2533	{
	2534	rc = kldrModLXDoReloc(pbPage, *poffSrc++, PageAddress, u.prlc, iSelector, uValue, fKind);
	2535	if (rc)
	2536	return rc;
	2537	}
	2538	}
	2539	pb = (const KU8 *)poffSrc;
	2540	}
	2541	else
	2542	{
	2543	/* This is a pain because it will require virgin pages on a relocation. */
	2544	KLDRMODLX_ASSERT(!"NRICHAIN");
	2545	return KLDR_ERR_LX_NRICHAIN_NOT_SUPPORTED;
	2546	}
	2547	}
	2548	}
	2549	}
	2550
	2551	return 0;
	2552	}
	2553
	2554
	2555	/**
	2556	* Applies the relocation to one 'source' in a page.
	2557	*
	2558	* This takes care of the more esotic case while the common cases
	2559	* are dealt with seperately.
	2560	*
	2561	* @returns 0 on success, non-zero kLdr status code on failure.
	2562	* @param pbPage The page in which to apply the fixup.
	2563	* @param off Page relative offset of where to apply the offset.
	2564	* @param uValue The target value.
	2565	* @param fKind The target kind.
	2566	*/
	2567	static int kldrModLXDoReloc(KU8 pbPage, int off, KLDRADDR PageAddress, const struct r32_rlc prlc,
	2568	int iSelector, KLDRADDR uValue, KU32 fKind)
	2569	{
	2570	#pragma pack(1) /* just to be sure */
	2571	union
	2572	{
	2573	KU8 ab[6];
	2574	KU32 off32;
	2575	KU16 off16;
	2576	KU8 off8;
	2577	struct
	2578	{
	2579	KU16 off;
	2580	KU16 Sel;
	2581	} Far16;
	2582	struct
	2583	{
	2584	KU32 off;
	2585	KU16 Sel;
	2586	} Far32;
	2587	} uData;
	2588	#pragma pack()
	2589	const KU8 *pbSrc;
	2590	KU8 *pbDst;
	2591	KU8 cb;
	2592
[79]	2593	K_NOREF(fKind);
	2594
[2]	2595	/*
	2596	* Compose the fixup data.
	2597	*/
	2598	switch (prlc->nr_stype & NRSRCMASK)
	2599	{
	2600	case NRSBYT:
	2601	uData.off8 = (KU8)uValue;
	2602	cb = 1;
	2603	break;
	2604	case NRSSEG:
	2605	if (iSelector == -1)
	2606	{
	2607	/* fixme */
	2608	}
	2609	uData.off16 = iSelector;
	2610	cb = 2;
	2611	break;
	2612	case NRSPTR:
	2613	if (iSelector == -1)
	2614	{
	2615	/* fixme */
	2616	}
	2617	uData.Far16.off = (KU16)uValue;
	2618	uData.Far16.Sel = iSelector;
	2619	cb = 4;
	2620	break;
	2621	case NRSOFF:
	2622	uData.off16 = (KU16)uValue;
	2623	cb = 2;
	2624	break;
	2625	case NRPTR48:
	2626	if (iSelector == -1)
	2627	{
	2628	/* fixme */
	2629	}
	2630	uData.Far32.off = (KU32)uValue;
	2631	uData.Far32.Sel = iSelector;
	2632	cb = 6;
	2633	break;
	2634	case NROFF32:
	2635	uData.off32 = (KU32)uValue;
	2636	cb = 4;
	2637	break;
	2638	case NRSOFF32:
[87]	2639	uData.off32 = (KU32)(uValue - (PageAddress + off + 4));
[2]	2640	cb = 4;
	2641	break;
	2642	default:
	2643	return KLDR_ERR_LX_BAD_FIXUP_SECTION; /** @todo fix error, add more checks! */
	2644	}
	2645
	2646	/*
	2647	* Apply it. This is sloooow...
	2648	*/
	2649	pbSrc = &uData.ab[0];
	2650	pbDst = pbPage + off;
	2651	while (cb-- > 0)
	2652	{
[96]	2653	if (off > (int)OBJPAGELEN)
[2]	2654	break;
	2655	if (off >= 0)
	2656	pbDst = pbSrc;
	2657	pbSrc++;
	2658	pbDst++;
	2659	}
	2660
	2661	return 0;
	2662	}
	2663
	2664
	2665	/**
	2666	* The LX module interpreter method table.
	2667	*/
	2668	KLDRMODOPS g_kLdrModLXOps =
	2669	{
	2670	"LX",
	2671	NULL,
	2672	kldrModLXCreate,
	2673	kldrModLXDestroy,
	2674	kldrModLXQuerySymbol,
	2675	kldrModLXEnumSymbols,
	2676	kldrModLXGetImport,
	2677	kldrModLXNumberOfImports,
	2678	NULL /* can execute one is optional */,
	2679	kldrModLXGetStackInfo,
	2680	kldrModLXQueryMainEntrypoint,
[54]	2681	NULL /* pfnQueryImageUuid */,
[2]	2682	NULL /* fixme */,
	2683	NULL /* fixme */,
	2684	kldrModLXEnumDbgInfo,
	2685	kldrModLXHasDbgInfo,
	2686	kldrModLXMap,
	2687	kldrModLXUnmap,
	2688	kldrModLXAllocTLS,
	2689	kldrModLXFreeTLS,
	2690	kldrModLXReload,
	2691	kldrModLXFixupMapping,
	2692	kldrModLXCallInit,
	2693	kldrModLXCallTerm,
	2694	kldrModLXCallThread,
	2695	kldrModLXSize,
	2696	kldrModLXGetBits,
	2697	kldrModLXRelocateBits,
	2698	NULL /* fixme: pfnMostlyDone */,
	2699	42 /* the end */
	2700	};
	2701

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

Context Navigation

source: trunk/kLdr/kLdrModLX.c@ 117

Download in other formats: