kLdrDyldMod.c@ 2

Last change on this file since 2 was 2, checked in by bird, 17 years ago
Imported http://svn.netlabs.org/repos/libc/trunk/kStuff, revision 3612.
Property svn:eol-style set to `native` Property svn:keywords set to `Id Revision`
File size: 36.6 KB

Line
1	/* $Id: kLdrDyldMod.c 2 2007-11-16 16:07:14Z bird $ */
2	/** @file
3	* kLdr - The Dynamic Loader, Dyld module methods.
4	*/
5
6	/*
7	* Copyright (c) 2006-2007 knut st. osmundsen <[email protected]>
8	*
9	* This file is part of kStuff.
10	*
11	* kStuff is free software; you can redistribute it and/or
12	* modify it under the terms of the GNU Lesser General Public
13	* License as published by the Free Software Foundation; either
14	* version 2.1 of the License, or (at your option) any later version.
15	*
16	* In addition to the permissions in the GNU Lesser General Public
17	* License, you are granted unlimited permission to link the compiled
18	* version of this file into combinations with other programs, and to
19	* distribute those combinations without any restriction coming from
20	* the use of this file.
21	*
22	* kStuff is distributed in the hope that it will be useful,
23	* but WITHOUT ANY WARRANTY; without even the implied warranty of
24	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
25	* Lesser General Public License for more details.
26	*
27	* You should have received a copy of the GNU Lesser General Public
28	* License along with kStuff; if not, write to the Free Software
29	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
30	* 02110-1301, USA
31	*/
32
33	/*******************************************************************************
34	* Header Files *
35	*******************************************************************************/
36	#include <k/kLdr.h>
37	#include "kLdrInternal.h"
38
39
40	/*******************************************************************************
41	* Defined Constants And Macros *
42	*******************************************************************************/
43	/** @def KLDRDYLDMOD_STRICT
44	* Define KLDRDYLDMOD_STRICT to enabled strict checks in kLdrDyld. */
45	#define KLDRDYLDMOD_STRICT 1
46
47	/** @def KLDRDYLDMOD_ASSERT
48	* Assert that an expression is true when KLDRDYLD_STRICT is defined.
49	*/
50	#ifdef KLDRDYLDMOD_STRICT
51	# define KLDRDYLDMOD_ASSERT(expr) kHlpAssert(expr)
52	#else
53	# define KLDRDYLDMOD_ASSERT(expr) do {} while (0)
54	#endif
55
56	/*******************************************************************************
57	* Internal Functions *
58	*******************************************************************************/
59	static void kldrDyldModUnlink(PKLDRDYLDMOD pMod);
60
61
62
63	/**
64	* Creates a module from the specified file provider instance.
65	*
66	* @returns 0 on success and *ppMod pointing to the new instance.
67	* On failure a non-zero kLdr status code is returned.
68	* @param pRdr The file provider instance.
69	* @param fFlags Load/search flags.
70	* @param ppMod Where to put the pointer to the new module on success.
71	*/
72	int kldrDyldModCreate(PKRDR pRdr, KU32 fFlags, PPKLDRDYLDMOD ppMod)
73	{
74	PKLDRDYLDMOD pMod;
75	PKLDRMOD pRawMod;
76	int rc;
77
78	*ppMod = NULL;
79
80	/** @todo deal with fFlags (exec/dll) */
81
82	/*
83	* Try open an module interpreter.
84	*/
85	rc = kLdrModOpenFromRdr(pRdr, &pRawMod);
86	if (rc)
87	return kldrDyldFailure(rc, "%s: %rc", kRdrName(pRdr), rc);
88
89	/*
90	* Match the module aginst the load flags.
91	*/
92	switch (pRawMod->enmType)
93	{
94	case KLDRTYPE_EXECUTABLE_FIXED:
95	case KLDRTYPE_EXECUTABLE_RELOCATABLE:
96	case KLDRTYPE_EXECUTABLE_PIC:
97	if (!(fFlags & KLDRDYLD_LOAD_FLAGS_EXECUTABLE))
98	{
99	kLdrModClose(pRawMod);
100	return KLDR_ERR_NOT_EXE;
101	}
102	break;
103
104	case KLDRTYPE_OBJECT: /* We can handle these as DLLs. */
105	case KLDRTYPE_SHARED_LIBRARY_FIXED:
106	case KLDRTYPE_SHARED_LIBRARY_RELOCATABLE:
107	case KLDRTYPE_SHARED_LIBRARY_PIC:
108	case KLDRTYPE_FORWARDER_DLL:
109	if (fFlags & KLDRDYLD_LOAD_FLAGS_EXECUTABLE)
110	{
111	kLdrModClose(pRawMod);
112	return KLDR_ERR_NOT_DLL;
113	}
114	break;
115
116	default:
117	KLDRDYLDMOD_ASSERT(!"Bad enmType!");
118	case KLDRTYPE_CORE:
119	return fFlags & KLDRDYLD_LOAD_FLAGS_EXECUTABLE ? KLDR_ERR_NOT_EXE : KLDR_ERR_NOT_DLL;
120	}
121
122	/*
123	* Allocate a new dyld module.
124	*/
125	pMod = (PKLDRDYLDMOD)kHlpAlloc(sizeof(*pMod));
126	if (pMod)
127	{
128	pMod->enmState = KLDRSTATE_OPEN;
129	pMod->pMod = pRawMod;
130	pMod->hMod = pMod;
131	pMod->cDepRefs = pMod->cDynRefs = pMod->cRefs = 0;
132	switch (pRawMod->enmType)
133	{
134	case KLDRTYPE_EXECUTABLE_FIXED:
135	case KLDRTYPE_EXECUTABLE_RELOCATABLE:
136	case KLDRTYPE_EXECUTABLE_PIC:
137	pMod->fExecutable = 1;
138	break;
139	default:
140	pMod->fExecutable = 0;
141	break;
142	}
143	pMod->fGlobalOrSpecific = 0;
144	pMod->fBindable = 0;
145	pMod->fInitList = 0;
146	pMod->fAlreadySeen = 0;
147	pMod->fMapped = 0;
148	pMod->fAllocatedTLS = 0;
149	pMod->f25Reserved = 0;
150	pMod->InitTerm.pNext = NULL;
151	pMod->InitTerm.pPrev = NULL;
152	pMod->Bind.pNext = NULL;
153	pMod->Bind.pPrev = NULL;
154	pMod->cPrereqs = 0;
155	pMod->papPrereqs = NULL;
156	pMod->u32MagicHead = KLDRDYMOD_MAGIC;
157	pMod->u32MagicTail = KLDRDYMOD_MAGIC;
158
159	/* it. */
160	pMod->Load.pNext = NULL;
161	pMod->Load.pPrev = kLdrDyldTail;
162	if (kLdrDyldTail)
163	kLdrDyldTail->Load.pNext = pMod;
164	else
165	kLdrDyldHead = pMod;
166	kLdrDyldTail = pMod;
167
168	/* deal with the remaining flags. */
169	if (fFlags & KLDRYDLD_LOAD_FLAGS_SPECIFIC_MODULE)
170	kldrDyldModMarkSpecific(pMod);
171	else
172	kldrDyldModMarkGlobal(pMod);
173
174	if (fFlags & KLDRYDLD_LOAD_FLAGS_GLOBAL_SYMBOLS)
175	kldrDyldModSetBindable(pMod, 0 /* not deep binable */);
176	else
177	kldrDyldModClearBindable(pMod);
178
179	/*
180	* We're good.
181	*/
182	*ppMod = pMod;
183	rc = 0;
184	}
185	else
186	{
187	kLdrModClose(pRawMod);
188	rc = KERR_NO_MEMORY;
189	}
190	return rc;
191	}
192
193
194	/**
195	* Creates a module for a native module.
196	*
197	* @returns 0 on success and *ppMod pointing to the new instance.
198	* On failure a non-zero kLdr status code is returned.
199	* @param hNativeModule The native handle.
200	* @param ppMod Where to put the pointer to the new module on success.
201	* @remark This function ain't finalized yet.
202	*/
203	int kldrDyldModCreateNative(KUPTR hNativeModule)
204	{
205	#if 0
206	/*
207	* Check if this module is already loaded by the native OS loader.
208	*/
209	rc = kld
210	{
211	#if K_OS == K_OS_OS2
212	HMODULE hmod = NULLHANDLE;
213	APIRET rc = DosQueryModuleHandle(kRdrName(pRdr), &hmod);
214	if (!rc)
215
216	#elif K_OS == K_OS_WINDOWS
217	HMODULE hmod = NULL;
218	if (GetModuleHandle(kRdrName(pRdr))
219
220	#else
221	# error "Port me"
222	#endif
223	}
224	#endif
225	return -1;
226	}
227
228
229	/**
230	* Destroys a module pending destruction.
231	*
232	* @param pMod The module in question.
233	*/
234	void kldrDyldModDestroy(PKLDRDYLDMOD pMod)
235	{
236	int rc;
237
238	/*
239	* Validate the state.
240	*/
241	switch (pMod->enmState)
242	{
243	case KLDRSTATE_PENDING_DESTROY:
244	case KLDRSTATE_GC:
245	break;
246	default:
247	KLDRDYLDMOD_ASSERT(!"Invalid state");
248	break;
249	}
250	KLDRDYLDMOD_ASSERT(!pMod->fInitList);
251	KLDRDYLDMOD_ASSERT(!pMod->cDynRefs);
252	KLDRDYLDMOD_ASSERT(!pMod->cDepRefs);
253
254	/*
255	* Ensure that the module is unmapped.
256	*/
257	if (pMod->fAllocatedTLS)
258	{
259	kLdrModFreeTLS(pMod->pMod);
260	pMod->fAllocatedTLS = 0;
261	}
262	if (pMod->fMapped)
263	{
264	rc = kLdrModUnmap(pMod->pMod); KLDRDYLDMOD_ASSERT(!rc);
265	pMod->fMapped = 0;
266	}
267
268	/*
269	* Ensure it's unlinked from all chains.
270	*/
271	if (pMod->enmState < KLDRSTATE_PENDING_DESTROY)
272	kldrDyldModUnlink(pMod);
273
274	/*
275	* Free everything associated with the module.
276	*/
277	/* the prerequisite array. */
278	if (pMod->papPrereqs)
279	{
280	KU32 i = pMod->cPrereqs;
281	while (i-- > 0)
282	{
283	KLDRDYLDMOD_ASSERT(pMod->papPrereqs[i] == NULL);
284	pMod->papPrereqs[i] = NULL;
285	}
286
287	kHlpFree(pMod->papPrereqs);
288	pMod->papPrereqs = NULL;
289	pMod->cPrereqs = 0;
290	}
291
292	/* the module interpreter. */
293	if (pMod->pMod)
294	{
295	rc = kLdrModClose(pMod->pMod); KLDRDYLDMOD_ASSERT(!rc);
296	pMod->pMod = NULL;
297	}
298
299
300	/*
301	* Finally, change the module state and free the module if
302	* there are not more references to it. If somebody is still
303	* referencing it, postpone the freeing to Deref.
304	*/
305	pMod->enmState = KLDRSTATE_DESTROYED;
306	if (!pMod->cRefs)
307	{
308	pMod->u32MagicHead = 1;
309	pMod->u32MagicTail = 2;
310	kHlpFree(pMod);
311	}
312	}
313
314
315	/**
316	* Unlinks the module from any list it might be in.
317	* It is assumed that the module is at least linked into the load list.
318	*
319	* @param pMod The moduel.
320	*/
321	static void kldrDyldModUnlink(PKLDRDYLDMOD pMod)
322	{
323	/* load list */
324	if (pMod->Load.pNext)
325	pMod->Load.pNext->Load.pPrev = pMod->Load.pPrev;
326	else
327	kLdrDyldTail = pMod->Load.pPrev;
328	if (pMod->Load.pPrev)
329	pMod->Load.pPrev->Load.pNext = pMod->Load.pNext;
330	else
331	kLdrDyldHead = pMod->Load.pNext;
332
333	/* bind list */
334	if (pMod->fBindable)
335	kldrDyldModClearBindable(pMod);
336
337	/* init term */
338	if (pMod->fInitList)
339	{
340	KLDRDYLDMOD_ASSERT(pMod->enmState < KLDRSTATE_INITIALIZATION_FAILED);
341	pMod->fInitList = 0;
342	if (pMod->InitTerm.pNext)
343	pMod->InitTerm.pNext->InitTerm.pPrev = pMod->InitTerm.pPrev;
344	else
345	g_pkLdrDyldInitTail = pMod->InitTerm.pPrev;
346	if (pMod->InitTerm.pPrev)
347	pMod->InitTerm.pPrev->InitTerm.pNext = pMod->InitTerm.pNext;
348	else
349	g_pkLdrDyldInitHead = pMod->InitTerm.pNext;
350	}
351	else if (pMod->enmState > KLDRSTATE_INITIALIZATION_FAILED)
352	{
353	KLDRDYLDMOD_ASSERT(pMod->enmState >= KLDRSTATE_GOOD);
354	if (pMod->InitTerm.pNext)
355	pMod->InitTerm.pNext->InitTerm.pPrev = pMod->InitTerm.pPrev;
356	else
357	g_pkLdrDyldTermTail = pMod->InitTerm.pPrev;
358	if (pMod->InitTerm.pPrev)
359	pMod->InitTerm.pPrev->InitTerm.pNext = pMod->InitTerm.pNext;
360	else
361	g_pkLdrDyldTermHead = pMod->InitTerm.pNext;
362	}
363	pMod->InitTerm.pNext = NULL;
364	pMod->InitTerm.pPrev = NULL;
365	}
366
367
368	/**
369	* Marks a module as bindable, i.e. it'll be considered when
370	* resolving names the unix way.
371	*
372	* @param pMod The module.
373	* @param fDeep When set the module will be inserted at the head of the
374	* module list used to resolve symbols. This means that the
375	* symbols in this module will be prefered of all the other
376	* modules.
377	*/
378	void kldrDyldModSetBindable(PKLDRDYLDMOD pMod, unsigned fDeep)
379	{
380	KLDRDYLDMOD_ASSERT(pMod->enmState >= KLDRSTATE_OPEN && pMod->enmState < KLDRSTATE_PENDING_GC);
381	if (!pMod->fBindable)
382	{
383	pMod->fBindable = 1;
384	if (!fDeep)
385	{
386	pMod->Bind.pNext = NULL;
387	pMod->Bind.pPrev = g_pkLdrDyldBindTail;
388	if (g_pkLdrDyldBindTail)
389	g_pkLdrDyldBindTail->Bind.pNext = pMod;
390	else
391	g_pkLdrDyldBindHead = pMod;
392	g_pkLdrDyldBindTail = pMod;
393	}
394	else
395	{
396	pMod->Bind.pPrev = NULL;
397	pMod->Bind.pNext = g_pkLdrDyldBindHead;
398	if (g_pkLdrDyldBindHead)
399	g_pkLdrDyldBindHead->Bind.pPrev = pMod;
400	else
401	g_pkLdrDyldBindTail = pMod;
402	g_pkLdrDyldBindHead = pMod;
403	}
404	}
405	}
406
407
408	/**
409	* Marks a module as not bindable, i.e. it will not be considered when
410	* resolving names the unix way.
411	*
412	* @param pMod The module.
413	*/
414	void kldrDyldModClearBindable(PKLDRDYLDMOD pMod)
415	{
416	KLDRDYLDMOD_ASSERT(pMod->enmState >= KLDRSTATE_OPEN && pMod->enmState < KLDRSTATE_PENDING_DESTROY);
417	if (pMod->fBindable)
418	{
419	pMod->fBindable = 0;
420	if (pMod->Bind.pPrev)
421	pMod->Bind.pPrev->Bind.pNext = pMod->Bind.pNext;
422	else
423	g_pkLdrDyldBindHead = pMod->Bind.pNext;
424	if (pMod->Bind.pNext)
425	pMod->Bind.pNext->Bind.pPrev = pMod->Bind.pPrev;
426	else
427	g_pkLdrDyldBindTail = pMod->Bind.pPrev;
428	pMod->Bind.pNext = NULL;
429	pMod->Bind.pPrev = NULL;
430	}
431	}
432
433
434	/**
435	* Marks the module as global instead of being specific.
436	*
437	* A global module can be a matching result when the request
438	* doesn't specify a path. A specific module will not match
439	* unless the path also matches.
440	*
441	* @param pMod The module.
442	*/
443	void kldrDyldModMarkGlobal(PKLDRDYLDMOD pMod)
444	{
445	pMod->fGlobalOrSpecific = 1;
446	}
447
448
449	/**
450	* Marks the module as specific instead of global.
451	*
452	* See kldrDyldModMarkGlobal for an explanation of the two terms.
453	*
454	* @param pMod The module.
455	*/
456	void kldrDyldModMarkSpecific(PKLDRDYLDMOD pMod)
457	{
458	pMod->fGlobalOrSpecific = 0;
459	}
460
461
462	/**
463	* Adds a reference to the module making sure it won't be freed just yet.
464	*
465	* @param pMod The module.
466	*/
467	void kldrDyldModAddRef(PKLDRDYLDMOD pMod)
468	{
469	pMod->cRefs++;
470	}
471
472
473	/**
474	* Dereference a module.
475	*
476	* @param pMod
477	*/
478	void kldrDyldModDeref(PKLDRDYLDMOD pMod)
479	{
480	/* validate input */
481	KLDRDYLDMOD_ASSERT(pMod->cRefs > 0);
482	KLDRDYLDMOD_ASSERT(pMod->cRefs >= pMod->cDepRefs + pMod->cDynRefs);
483	KLDRDYLDMOD_ASSERT(pMod->enmState > KLDRSTATE_INVALID && pMod->enmState <= KLDRSTATE_END);
484
485	/* decrement. */
486	if (pMod->cRefs > 0)
487	pMod->cRefs--;
488
489	/* execute delayed freeing. */
490	if ( pMod->enmState == KLDRSTATE_DESTROYED
491	&& !pMod->cRefs)
492	{
493	pMod->u32MagicHead = 1;
494	pMod->u32MagicTail = 2;
495	kHlpFree(pMod);
496	}
497	}
498
499
500	/**
501	* Increment the count of modules depending on this module.
502	*
503	* @param pMod The module.
504	* @param pDep The module which depends on us.
505	*/
506	void kldrDyldModAddDep(PKLDRDYLDMOD pMod, PKLDRDYLDMOD pDep)
507	{
508	(void)pDep;
509
510	/* validate state */
511	switch (pMod->enmState)
512	{
513	case KLDRSTATE_MAPPED:
514	case KLDRSTATE_RELOADED:
515	case KLDRSTATE_LOADED_PREREQUISITES:
516	case KLDRSTATE_RELOADED_LOADED_PREREQUISITES:
517	case KLDRSTATE_PENDING_INITIALIZATION:
518	case KLDRSTATE_INITIALIZING:
519	case KLDRSTATE_GOOD:
520	break;
521	default:
522	KLDRDYLDMOD_ASSERT(!"invalid state");
523	break;
524
525	}
526	KLDRDYLDMOD_ASSERT(pMod->enmState > KLDRSTATE_INVALID && pMod->enmState <= KLDRSTATE_END);
527	pMod->cRefs++;
528	pMod->cDepRefs++;
529	}
530
531
532	/**
533	* Drop a dependency.
534	*
535	* @param pMod The module.
536	* @param pDep The module which depends on us.
537	*/
538	void kldrDyldModRemoveDep(PKLDRDYLDMOD pMod, PKLDRDYLDMOD pDep)
539	{
540	KLDRDYLDMOD_ASSERT(pMod->cDepRefs > 0);
541	if (pMod->cDepRefs == 0)
542	return;
543	KLDRDYLDMOD_ASSERT(pMod->cDepRefs <= pMod->cRefs);
544	KLDRDYLDMOD_ASSERT(pMod->enmState >= KLDRSTATE_MAPPED && pMod->enmState <= KLDRSTATE_PENDING_DESTROY);
545
546	pMod->cRefs--;
547	pMod->cDepRefs--;
548	if ( pMod->cDepRefs > 0
549	\|\| pMod->cDynRefs > 0)
550	return;
551
552	/*
553	* The module should be unloaded.
554	*/
555	kldrDyldModUnloadPrerequisites(pMod);
556	}
557
558
559	/**
560	* Increment the dynamic load count.
561	*
562	* @returns 0
563	* @param pMod The module.
564	*/
565	int kldrDyldModDynamicLoad(PKLDRDYLDMOD pMod)
566	{
567	KLDRDYLDMOD_ASSERT( pMod->enmState == KLDRSTATE_GOOD
568	\|\| pMod->enmState == KLDRSTATE_PENDING_INITIALIZATION
569	\|\| pMod->enmState == KLDRSTATE_INITIALIZING);
570	pMod->cRefs++;
571	pMod->cDynRefs++;
572	return 0;
573	}
574
575
576	/**
577	* Decrement the dynamic load count of the module and unload the module
578	* if the total reference count reaches zero.
579	*
580	* This may cause a cascade of unloading to occure. See kldrDyldModUnloadPrerequisites().
581	*
582	* @returns status code.
583	* @retval 0 on success.
584	* @retval KLDR_ERR_NOT_LOADED_DYNAMICALLY if the module wasn't loaded dynamically.
585	* @param pMod The module to unload.
586	*/
587	int kldrDyldModDynamicUnload(PKLDRDYLDMOD pMod)
588	{
589	if (pMod->cDynRefs == 0)
590	return KLDR_ERR_NOT_LOADED_DYNAMICALLY;
591	KLDRDYLDMOD_ASSERT(pMod->cDynRefs <= pMod->cRefs);
592	KLDRDYLDMOD_ASSERT(pMod->enmState == KLDRSTATE_GOOD);
593
594	pMod->cRefs--;
595	pMod->cDynRefs--;
596	if ( pMod->cDynRefs > 0
597	\|\| pMod->cDepRefs > 0)
598	return 0;
599
600	/*
601	* The module should be unloaded.
602	*/
603	kldrDyldModUnloadPrerequisites(pMod);
604	return 0;
605	}
606
607
608	/**
609	* Worker for kldrDyldModUnloadPrerequisites.
610	*
611	* @returns The number of modules that now can be unloaded.
612	* @param pMod The module in question.
613	*/
614	static KU32 kldrDyldModUnloadPrerequisitesOne(PKLDRDYLDMOD pMod)
615	{
616	PKLDRDYLDMOD pMod2;
617	KU32 cToUnload = 0;
618	KU32 i;
619
620	KLDRDYLDMOD_ASSERT(pMod->papPrereqs \|\| !pMod->cPrereqs);
621
622	/*
623	* Release the one in this module.
624	*/
625	for (i = 0; i < pMod->cPrereqs; i++)
626	{
627	pMod2 = pMod->papPrereqs[i];
628	if (pMod2)
629	{
630	pMod->papPrereqs[i] = NULL;
631
632	/* do the derefering ourselves or we'll end up in a recursive loop here. */
633	KLDRDYLDMOD_ASSERT(pMod2->cDepRefs > 0);
634	KLDRDYLDMOD_ASSERT(pMod2->cRefs >= pMod2->cDepRefs);
635	pMod2->cDepRefs--;
636	pMod2->cRefs--;
637	cToUnload += !pMod2->cDepRefs && !pMod2->cDynRefs;
638	}
639	}
640
641	/*
642	* Change the state
643	*/
644	switch (pMod->enmState)
645	{
646	case KLDRSTATE_LOADED_PREREQUISITES:
647	case KLDRSTATE_FIXED_UP:
648	pMod->enmState = KLDRSTATE_PENDING_DESTROY;
649	kldrDyldModUnlink(pMod);
650	break;
651
652	case KLDRSTATE_PENDING_INITIALIZATION:
653	pMod->enmState = KLDRSTATE_PENDING_GC;
654	break;
655
656	case KLDRSTATE_RELOADED_FIXED_UP:
657	case KLDRSTATE_RELOADED_LOADED_PREREQUISITES:
658	case KLDRSTATE_GOOD:
659	pMod->enmState = KLDRSTATE_PENDING_TERMINATION;
660	break;
661
662	case KLDRSTATE_INITIALIZATION_FAILED:
663	break;
664
665	default:
666	KLDRDYLDMOD_ASSERT(!"invalid state");
667	break;
668	}
669
670	return cToUnload;
671	}
672
673
674	/**
675	* This is the heart of the unload code.
676	*
677	* It will recursivly (using the load list) initiate module unloading
678	* of all affected modules.
679	*
680	* This function will cause a state transition to PENDING_DESTROY, PENDING_GC
681	* or PENDING_TERMINATION depending on the module state. There is one exception
682	* to this, and that's INITIALIZATION_FAILED, where the state will not be changed.
683	*
684	* @param pMod The module which prerequisites should be unloaded.
685	*/
686	void kldrDyldModUnloadPrerequisites(PKLDRDYLDMOD pMod)
687	{
688	KU32 cToUnload;
689
690	/* sanity */
691	#ifdef KLDRDYLD_STRICT
692	{
693	PKLDRDYLDMOD pMod2;
694	for (pMod2 = kLdrDyldHead; pMod2; pMod2 = pMod2->Load.pNext)
695	KLDRDYLDMOD_ASSERT(pMod2->enmState != KLDRSTATE_GOOD \|\| pMod2->cRefs);
696	}
697	#endif
698	KLDRDYLDMOD_ASSERT(pMod->papPrereqs);
699
700	/*
701	* Unload prereqs of the module we're called on first.
702	*/
703	cToUnload = kldrDyldModUnloadPrerequisitesOne(pMod);
704
705	/*
706	* Iterate the load list in a cyclic manner until there are no more
707	* modules that can be pushed on into unloading.
708	*/
709	while (cToUnload)
710	{
711	cToUnload = 0;
712	for (pMod = kLdrDyldHead; pMod; pMod = pMod->Load.pNext)
713	{
714	if ( pMod->cDepRefs
715	\|\| pMod->cDynRefs
716	\|\| pMod->enmState >= KLDRSTATE_PENDING_TERMINATION
717	\|\| pMod->enmState < KLDRSTATE_LOADED_PREREQUISITES)
718	continue;
719	cToUnload += kldrDyldModUnloadPrerequisitesOne(pMod);
720	}
721	}
722	}
723
724
725	/**
726	* Loads the prerequisite modules this module depends on.
727	*
728	* To find each of the prerequisite modules this method calls
729	* kldrDyldGetPrerequisite() and it will make sure the modules
730	* are added to the load stack frame.
731	*
732	* @returns 0 on success, non-zero native OS or kLdr status code on failure.
733	* The state is changed to LOADED_PREREQUISITES or RELOADED_LOADED_PREREQUISITES.
734	* @param pMod The module.
735	* @param pszPrefix Prefix to use when searching.
736	* @param pszSuffix Suffix to use when searching.
737	* @param enmSearch Method to use when locating the module and any modules it may depend on.
738	* @param fFlags Flags, a combintation of the KLDRYDLD_LOAD_FLAGS_* \#defines.
739	*/
740	int kldrDyldModLoadPrerequisites(PKLDRDYLDMOD pMod, const char pszPrefix, const char pszSuffix,
741	KLDRDYLDSEARCH enmSearch, unsigned fFlags)
742	{
743	KI32 cPrereqs;
744	KU32 i;
745	int rc = 0;
746
747	/* sanity */
748	switch (pMod->enmState)
749	{
750	case KLDRSTATE_MAPPED:
751	case KLDRSTATE_RELOADED:
752	break;
753	default:
754	KLDRDYLDMOD_ASSERT(!"invalid state");
755	return -1;
756	}
757
758	/*
759	* Query number of prerequiste modules and allocate the array.
760	*/
761	cPrereqs = kLdrModNumberOfImports(pMod->pMod, NULL);
762	kHlpAssert(cPrereqs >= 0);
763	if (pMod->cPrereqs != cPrereqs)
764	{
765	KLDRDYLDMOD_ASSERT(!pMod->papPrereqs);
766	pMod->papPrereqs = (PPKLDRDYLDMOD)kHlpAllocZ(sizeof(pMod->papPrereqs[0]) * cPrereqs);
767	if (!pMod->papPrereqs)
768	return KERR_NO_MEMORY;
769	pMod->cPrereqs = cPrereqs;
770	}
771	else
772	KLDRDYLDMOD_ASSERT(pMod->papPrereqs \|\| !pMod->cPrereqs);
773
774	/*
775	* Iterate the prerequisites and load them.
776	*/
777	for (i = 0; i < pMod->cPrereqs; i++)
778	{
779	static char s_szPrereq[260];
780	PKLDRDYLDMOD pPrereqMod;
781
782	KLDRDYLDMOD_ASSERT(pMod->papPrereqs[i] == NULL);
783	rc = kLdrModGetImport(pMod->pMod, NULL, i, s_szPrereq, sizeof(s_szPrereq));
784	if (rc)
785	break;
786	rc = kldrDyldGetPrerequisite(s_szPrereq, pszPrefix, pszSuffix, enmSearch, fFlags, pMod, &pPrereqMod);
787	if (rc)
788	break;
789	pMod->papPrereqs[i] = pPrereqMod;
790	}
791
792	/* change the state regardless of what happend. */
793	if (pMod->enmState == KLDRSTATE_MAPPED)
794	pMod->enmState = KLDRSTATE_LOADED_PREREQUISITES;
795	else
796	pMod->enmState = KLDRSTATE_RELOADED_LOADED_PREREQUISITES;
797	return rc;
798	}
799
800
801	/**
802	* Maps an open module.
803	*
804	* On success the module will be in the MAPPED state.
805	*
806	* @returns 0 on success, non-zero native OS or kLdr status code on failure.
807	* @param pMod The module which needs to be unmapped and set pending for destruction.
808	*/
809	int kldrDyldModMap(PKLDRDYLDMOD pMod)
810	{
811	int rc;
812
813	/* sanity */
814	KLDRDYLDMOD_ASSERT(pMod->enmState == KLDRSTATE_OPEN);
815	KLDRDYLDMOD_ASSERT(!pMod->fMapped);
816	if (pMod->fMapped)
817	return 0;
818
819	/* do the job. */
820	rc = kLdrModMap(pMod->pMod);
821	if (!rc)
822	{
823	rc = kLdrModAllocTLS(pMod->pMod);
824	if (!rc)
825	{
826	/** @todo TLS */
827	pMod->fMapped = 1;
828	pMod->enmState = KLDRSTATE_MAPPED;
829	}
830	else
831	kLdrModUnmap(pMod->pMod);
832	}
833	return rc;
834	}
835
836
837	/**
838	* Unmaps the module, unlinks it from everywhere marks it PENDING_DESTROY.
839	*
840	* @returns 0 on success, non-zero native OS or kLdr status code on failure.
841	* @param pMod The module which needs to be unmapped and set pending for destruction.
842	*/
843	int kldrDyldModUnmap(PKLDRDYLDMOD pMod)
844	{
845	int rc;
846
847	/* sanity */
848	KLDRDYLDMOD_ASSERT(pMod->cRefs > 0);
849	KLDRDYLDMOD_ASSERT(pMod->fMapped);
850	switch (pMod->enmState)
851	{
852	case KLDRSTATE_MAPPED:
853	case KLDRSTATE_GC:
854	case KLDRSTATE_PENDING_DESTROY:
855	break;
856	default:
857	KLDRDYLDMOD_ASSERT(!"invalid state");
858	return -1;
859	}
860
861	/* do the job. */
862	if (pMod->fAllocatedTLS)
863	{
864	kLdrModFreeTLS(pMod->pMod);
865	pMod->fAllocatedTLS = 0;
866	}
867	rc = kLdrModUnmap(pMod->pMod);
868	if (!rc)
869	{
870	pMod->fMapped = 0;
871	if (pMod->enmState < KLDRSTATE_PENDING_DESTROY)
872	{
873	pMod->enmState = KLDRSTATE_PENDING_DESTROY;
874	kldrDyldModUnlink(pMod);
875	}
876	}
877
878	return rc;
879	}
880
881
882	/**
883	* Reloads the module.
884	*
885	* Reloading means that all modified pages are restored to their original
886	* state. Whether this includes the code segments depends on whether the fixups
887	* depend on the addend in the place they are fixing up - so it's format specific.
888	*
889	* @returns 0 on success, non-zero native OS or kLdr status code on failure.
890	* @param pMod The module which needs to be unmapped and set pending for destruction.
891	*/
892	int kldrDyldModReload(PKLDRDYLDMOD pMod)
893	{
894	int rc;
895
896	/* sanity */
897	KLDRDYLDMOD_ASSERT(pMod->cRefs > 0);
898	KLDRDYLDMOD_ASSERT(pMod->fMapped);
899
900	switch (pMod->enmState)
901	{
902	case KLDRSTATE_MAPPED:
903	case KLDRSTATE_GC:
904	case KLDRSTATE_PENDING_DESTROY:
905	break;
906	default:
907	KLDRDYLDMOD_ASSERT(!"invalid state");
908	return -1;
909	}
910
911	/* Free TLS before reloading. */
912	if (pMod->fAllocatedTLS)
913	{
914	kLdrModFreeTLS(pMod->pMod);
915	pMod->fAllocatedTLS = 0;
916	}
917
918	/* Let the module interpreter do the reloading of the mapping. */
919	rc = kLdrModReload(pMod->pMod);
920	if (!rc)
921	{
922	rc = kLdrModAllocTLS(pMod->pMod);
923	if (!rc)
924	{
925	pMod->fAllocatedTLS = 1;
926	pMod->enmState = KLDRSTATE_RELOADED;
927	}
928	}
929	return rc;
930	}
931
932
933	/**
934	* @copydoc FNKLDRMODGETIMPORT
935	* pvUser points to the KLDRDYLDMOD.
936	*/
937	static int kldrDyldModFixupGetImportCallback(PKLDRMOD pMod, KU32 iImport, KU32 iSymbol,
938	const char pchSymbol, KSIZE cchSymbol, const char pszVersion,
939	PKLDRADDR puValue, KU32 pfKind, void pvUser)
940	{
941	static int s_cRecursiveCalls = 0;
942	PKLDRDYLDMOD pDyldMod = (PKLDRDYLDMOD)pvUser;
943	int rc;
944
945	/* guard against too deep forwarder recursion. */
946	if (s_cRecursiveCalls >= 5)
947	return KLDR_ERR_TOO_LONG_FORWARDER_CHAIN;
948	s_cRecursiveCalls++;
949
950	if (iImport != NIL_KLDRMOD_IMPORT)
951	{
952	/* specific import module search. */
953	PKLDRDYLDMOD pPrereqMod;
954
955	KLDRDYLDMOD_ASSERT(iImport < pDyldMod->cPrereqs);
956	pPrereqMod = pDyldMod->papPrereqs[iImport];
957
958	KLDRDYLDMOD_ASSERT(pPrereqMod);
959	KLDRDYLDMOD_ASSERT(pPrereqMod->u32MagicHead == KLDRDYMOD_MAGIC);
960	KLDRDYLDMOD_ASSERT(pPrereqMod->u32MagicTail == KLDRDYMOD_MAGIC);
961	KLDRDYLDMOD_ASSERT(pPrereqMod->enmState < KLDRSTATE_TERMINATING);
962
963	rc = kLdrModQuerySymbol(pPrereqMod->pMod, NULL, KLDRMOD_BASEADDRESS_MAP,
964	iSymbol, pchSymbol, cchSymbol, pszVersion,
965	kldrDyldModFixupGetImportCallback, pPrereqMod, puValue, pfKind);
966	if (rc)
967	{
968	if (pchSymbol)
969	kldrDyldFailure(rc, "%s[%d]->%s.%.*s%s", pDyldMod->pMod->pszName, iImport,
970	pPrereqMod->pMod->pszName, cchSymbol, pchSymbol, pszVersion ? pszVersion : "");
971	else
972	kldrDyldFailure(rc, "%s[%d]->%s.%d%s", pDyldMod->pMod->pszName, iImport,
973	pPrereqMod->pMod->pszName, iSymbol, pszVersion ? pszVersion : "");
974	}
975	}
976	else
977	{
978	/* bind list search. */
979	unsigned fFound = 0;
980	PKLDRDYLDMOD pBindMod = g_pkLdrDyldBindHead;
981	rc = 0;
982	while (pBindMod)
983	{
984	KU32 fKind;
985	KLDRADDR uValue;
986	rc = kLdrModQuerySymbol(pBindMod->pMod, NULL, KLDRMOD_BASEADDRESS_MAP,
987	iSymbol, pchSymbol, cchSymbol, pszVersion,
988	kldrDyldModFixupGetImportCallback, pBindMod, &uValue, &fKind);
989	if ( !rc
990	&& ( !fFound
991	\|\| !(fKind & KLDRSYMKIND_WEAK)
992	)
993	)
994	{
995	*pfKind = fKind;
996	*puValue = uValue;
997	fFound = 1;
998	if (!(fKind & KLDRSYMKIND_WEAK))
999	break;
1000	}
1001
1002	/* next */
1003	pBindMod = pBindMod->Bind.pNext;
1004	}
1005	rc = fFound ? 0 : KLDR_ERR_SYMBOL_NOT_FOUND;
1006	if (!fFound)
1007	{
1008	if (pchSymbol)
1009	kldrDyldFailure(rc, "%s->%.*s%s", pDyldMod->pMod->pszName, cchSymbol, pchSymbol, pszVersion ? pszVersion : "");
1010	else
1011	kldrDyldFailure(rc, "%s->%d%s", pDyldMod->pMod->pszName, iSymbol, pszVersion ? pszVersion : "");
1012	}
1013	}
1014
1015	s_cRecursiveCalls--;
1016	return rc;
1017	}
1018
1019
1020	/**
1021	* Applies fixups to a module which prerequisistes has been
1022	* successfully loaded.
1023	*
1024	* @returns 0 on success, non-zero native OS or kLdr status code on failure.
1025	* @param pMod The module which needs to be unmapped and set pending for destruction.
1026	*/
1027	int kldrDyldModFixup(PKLDRDYLDMOD pMod)
1028	{
1029	int rc;
1030
1031	/* sanity */
1032	KLDRDYLDMOD_ASSERT(pMod->cRefs > 0);
1033	KLDRDYLDMOD_ASSERT( pMod->enmState == KLDRSTATE_LOADED_PREREQUISITES
1034	\|\| pMod->enmState == KLDRSTATE_RELOADED_LOADED_PREREQUISITES);
1035
1036	/* do the job */
1037	rc = kLdrModFixupMapping(pMod->pMod, kldrDyldModFixupGetImportCallback, pMod);/** @todo fixme. */
1038	if (!rc)
1039	pMod->enmState = KLDRSTATE_FIXED_UP;
1040	return rc;
1041	}
1042
1043
1044	/**
1045	* Calls the module initialization entry point if any.
1046	*
1047	* This is considered to be a module specific thing and leave if
1048	* to the module interpreter. They will have to deal with different
1049	* module init practices between platforms should there be any.
1050	*
1051	* @returns 0 and state changed to GOOD on success.
1052	* Non-zero OS or kLdr status code and status changed to INITIALIZATION_FAILED on failure.
1053	* @param pMod The module that should be initialized.
1054	*/
1055	int kldrDyldModCallInit(PKLDRDYLDMOD pMod)
1056	{
1057	int rc;
1058
1059	KLDRDYLDMOD_ASSERT(pMod->enmState == KLDRSTATE_PENDING_INITIALIZATION);
1060	KLDRDYLDMOD_ASSERT(!pMod->fInitList);
1061
1062	pMod->enmState = KLDRSTATE_INITIALIZING;
1063	rc = kLdrModCallInit(pMod->pMod, (KUPTR)pMod->hMod);
1064	if (!rc)
1065	{
1066	pMod->enmState = KLDRSTATE_GOOD;
1067	/* push it onto the termination list.*/
1068	pMod->InitTerm.pPrev = NULL;
1069	pMod->InitTerm.pNext = g_pkLdrDyldTermHead;
1070	if (g_pkLdrDyldTermHead)
1071	g_pkLdrDyldTermHead->InitTerm.pPrev = pMod;
1072	else
1073	g_pkLdrDyldTermTail = pMod;
1074	g_pkLdrDyldTermHead = pMod;
1075	}
1076	else
1077	pMod->enmState = KLDRSTATE_INITIALIZATION_FAILED;
1078
1079	return rc;
1080	}
1081
1082
1083	/**
1084	* Calls the module termination entry point if any.
1085	*
1086	* This'll change the module status to PENDING_GC.
1087	*
1088	* @param pMod The module that should be initialized.
1089	*/
1090	void kldrDyldModCallTerm(PKLDRDYLDMOD pMod)
1091	{
1092	KLDRDYLDMOD_ASSERT(pMod->enmState == KLDRSTATE_PENDING_TERMINATION);
1093
1094	pMod->enmState = KLDRSTATE_TERMINATING;
1095	kLdrModCallTerm(pMod->pMod, (KUPTR)pMod->hMod);
1096	pMod->enmState = KLDRSTATE_PENDING_GC;
1097	/* unlinking on destruction. */
1098	}
1099
1100
1101	/**
1102	* Calls the thread attach entry point if any.
1103	*
1104	* @returns 0 on success, non-zero on failure.
1105	* @param pMod The module.
1106	*/
1107	int kldrDyldModAttachThread(PKLDRDYLDMOD pMod)
1108	{
1109	KLDRDYLDMOD_ASSERT(pMod->enmState == KLDRSTATE_GOOD);
1110
1111	return kLdrModCallThread(pMod->pMod, (KUPTR)pMod->hMod, 1 /* attach */);
1112	}
1113
1114
1115	/**
1116	* Calls the thread detach entry point if any.
1117	*
1118	* @returns 0 on success, non-zero on failure.
1119	* @param pMod The module.
1120	*/
1121	void kldrDyldModDetachThread(PKLDRDYLDMOD pMod)
1122	{
1123	KLDRDYLDMOD_ASSERT(pMod->enmState == KLDRSTATE_GOOD);
1124
1125	kLdrModCallThread(pMod->pMod, (KUPTR)pMod->hMod, 0 /* detach */);
1126	}
1127
1128
1129	/**
1130	* Gets the main stack, allocate it if necessary.
1131	*
1132	* @returns 0 on success, non-zero native OS or kLdr status code on failure.
1133	* @param pMod The module.
1134	* @param ppvStack Where to store the address of the stack (lowest address).
1135	* @param pcbStack Where to store the size of the stack.
1136	*/
1137	int kldrDyldModGetMainStack(PKLDRDYLDMOD pMod, void *ppvStack, KSIZE pcbStack)
1138	{
1139	int rc = 0;
1140	KLDRSTACKINFO StackInfo;
1141	KLDRDYLDMOD_ASSERT(pMod->fExecutable);
1142
1143	/*
1144	* Since we might have to allocate the stack ourselves, and there will only
1145	* ever be one main stack, we'll be keeping the main stack info in globals.
1146	*/
1147	if (!g_fkLdrDyldDoneMainStack)
1148	{
1149	rc = kLdrModGetStackInfo(pMod->pMod, NULL, KLDRMOD_BASEADDRESS_MAP, &StackInfo);
1150	if (!rc)
1151	{
1152	/* check if there is a stack size override/default. */
1153	KSIZE cbDefOverride;
1154	if (kHlpGetEnvUZ("KLDR_MAIN_STACK_SIZE", &cbDefOverride))
1155	cbDefOverride = 0;
1156
1157
1158	/* needs allocating? */
1159	if ( StackInfo.LinkAddress == NIL_KLDRADDR
1160	\|\| StackInfo.cbStack < cbDefOverride)
1161	{
1162	KSIZE cbStack = (KSIZE)K_MAX(StackInfo.cbStack, cbDefOverride);
1163
1164	g_pvkLdrDyldMainStack = kldrDyldOSAllocStack(cbStack);
1165	if (g_pvkLdrDyldMainStack)
1166	{
1167	g_cbkLdrDyldMainStack = cbStack;
1168	g_fkLdrDyldMainStackAllocated = 1;
1169	}
1170	else
1171	rc = KLDR_ERR_MAIN_STACK_ALLOC_FAILED;
1172	}
1173	else
1174	{
1175	KLDRDYLDMOD_ASSERT(StackInfo.Address != NIL_KLDRADDR);
1176	KLDRDYLDMOD_ASSERT(StackInfo.cbStack > 0);
1177
1178	g_fkLdrDyldMainStackAllocated = 0;
1179	g_pvkLdrDyldMainStack = (void *)(KUPTR)StackInfo.Address;
1180	KLDRDYLDMOD_ASSERT((KUPTR)g_pvkLdrDyldMainStack == StackInfo.Address);
1181
1182	g_cbkLdrDyldMainStack = (KSIZE)StackInfo.cbStack;
1183	KLDRDYLDMOD_ASSERT(StackInfo.cbStack == g_cbkLdrDyldMainStack);
1184	}
1185	}
1186	if (!rc)
1187	g_fkLdrDyldDoneMainStack = 1;
1188	}
1189
1190	if (!rc)
1191	{
1192	if (ppvStack)
1193	*ppvStack = g_pvkLdrDyldMainStack;
1194	if (pcbStack)
1195	*pcbStack = g_cbkLdrDyldMainStack;
1196	}
1197
1198	return rc;
1199	}
1200
1201
1202	/**
1203	* This starts the executable module.
1204	*
1205	* @returns non-zero OS or kLdr status code on failure.
1206	* (won't return on success.)
1207	* @param pMod The executable module.
1208	*/
1209	int kldrDyldModStartExe(PKLDRDYLDMOD pMod)
1210	{
1211	int rc;
1212	KLDRADDR MainEPAddress;
1213	void *pvStack;
1214	KSIZE cbStack;
1215	KLDRDYLDMOD_ASSERT(pMod->fExecutable);
1216
1217	rc = kLdrModQueryMainEntrypoint(pMod->pMod, NULL, KLDRMOD_BASEADDRESS_MAP, &MainEPAddress);
1218	if (rc)
1219	return rc;
1220	rc = kldrDyldModGetMainStack(pMod, &pvStack, &cbStack);
1221	if (rc)
1222	return rc;
1223	return kldrDyldOSStartExe((KUPTR)MainEPAddress, pvStack, cbStack);
1224	}
1225
1226
1227	/**
1228	* Gets the module name.
1229	*
1230	* @returns 0 on success, KERR_BUFFER_OVERFLOW on failure.
1231	* @param pMod The module.
1232	* @param pszName Where to store the name.
1233	* @param cchName The size of the name buffer.
1234	*/
1235	int kldrDyldModGetName(PKLDRDYLDMOD pMod, char *pszName, KSIZE cchName)
1236	{
1237	KSIZE cch = K_MIN(cchName, pMod->pMod->cchName + 1);
1238	if (cch)
1239	{
1240	kHlpMemCopy(pszName, pMod->pMod->pszName, cch - 1);
1241	pszName[cch - 1] = '\0';
1242	}
1243	return cchName <= pMod->pMod->cchName ? KERR_BUFFER_OVERFLOW : 0;
1244	}
1245
1246
1247	/**
1248	* Gets the module filename.
1249	*
1250	* @returns 0 on success, KERR_BUFFER_OVERFLOW on failure.
1251	* @param pMod The module.
1252	* @param pszFilename Where to store the filename.
1253	* @param cchFilename The size of the filename buffer.
1254	*/
1255	int kldrDyldModGetFilename(PKLDRDYLDMOD pMod, char *pszFilename, KSIZE cchFilename)
1256	{
1257	KSIZE cch = K_MIN(cchFilename, pMod->pMod->cchFilename + 1);
1258	if (cch)
1259	{
1260	kHlpMemCopy(pszFilename, pMod->pMod->pszFilename, cch - 1);
1261	pszFilename[cch - 1] = '\0';
1262	}
1263	return cchFilename <= pMod->pMod->cchFilename ? KERR_BUFFER_OVERFLOW : 0;
1264	}
1265
1266
1267	/**
1268	* Gets the address/value of a symbol in the specified module.
1269	*
1270	* @returns 0 on success, KLDR_ERR_SYMBOL_NOT_FOUND on failure.
1271	* @param pMod The module.
1272	* @param uSymbolOrdinal The symbol ordinal 0. This is ignored if the name is non-zero.
1273	* @param pszSymbolName The symbol name. Can be NULL.
1274	* @param puValue Where to store the value. optional.
1275	* @param pfKind Where to store the symbol kind. optional.
1276	*/
1277	int kldrDyldModQuerySymbol(PKLDRDYLDMOD pMod, KU32 uSymbolOrdinal, const char *pszSymbolName,
1278	KUPTR puValue, KU32 pfKind)
1279	{
1280	int rc;
1281	KLDRADDR uValue = 0;
1282	KU32 fKind = 0;
1283
1284	rc = kLdrModQuerySymbol(pMod->pMod, NULL, KLDRMOD_BASEADDRESS_MAP,
1285	uSymbolOrdinal, pszSymbolName, kHlpStrLen(pszSymbolName), NULL,
1286	kldrDyldModFixupGetImportCallback, pMod,
1287	&uValue, &fKind);
1288	if (!rc)
1289	{
1290	if (puValue)
1291	{
1292	*puValue = (KUPTR)uValue;
1293	KLDRDYLDMOD_ASSERT(*puValue == uValue);
1294	}
1295	if (pfKind)
1296	*pfKind = fKind;
1297	}
1298
1299	return rc;
1300	}
1301

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

source: kStuff/trunk/kLdr/kLdrDyldMod.c@ 2

Download in other formats: