source: trunk/kLdr/kLdrHlp.c@ 2831

Last change on this file since 2831 was 2831, checked in by bird, 19 years ago

Comment.
  • Property svn:keywords set to Id
File size: 15.0 KB
RevLine 
[2826]1/* $Id: kLdrHlp.c 2831 2006-10-23 20:59:28Z bird $ */
[2825]2/** @file
3 *
4 * kLdr - The Dynamic Loader, Helper Functions.
5 *
6 * Copyright (c) 2006 knut st. osmundsen <bird-kbuild-src@anduin.net>
7 *
8 *
9 * This file is part of kLdr.
10 *
11 * kLdr is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; either version 2 of the License, or
14 * (at your option) any later version.
15 *
16 * kLdr is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU General Public License for more details.
20 *
21 * You should have received a copy of the GNU General Public License
22 * along with kLdr; if not, write to the Free Software
23 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
24 *
25 */
26
27
28/*******************************************************************************
29* Header Files *
30*******************************************************************************/
31#ifdef __OS2__
32# define INCL_BASE
33# define INCL_ERRORS
34# include <os2.h>
35#elif defined(__WIN__)
36# include <Windows.h>
37#else
38# error "port me"
39#endif
40
41#include <kLdr.h>
42#include "kLdrHlp.h"
43
44
[2830]45/*******************************************************************************
46* Global Variables *
47*******************************************************************************/
48#ifdef __OS2__
49/** The loader sempahore. */
50static HMTX g_hmtx;
51/** The base of the stub object.
52 * The OS/2 exe stub consists of a single data object. When allocating memory
53 * for an executable, we'll have to reuse this. */
54static void *g_pvStub = NULL;
55/** The size of the stub object - 0 if no stub. */
56static size_t g_cbStub = 0;
57
58#elif defined(__WIN__)
59/** The loader sempahore. */
60static CRITICAL_SECTION g_CritSect;
61/** The system info. */
62static SYSTEM_INFO g_SystemInfo;
63#else
64# error "port me"
65#endif
66
67
[2825]68/**
[2830]69 * Initializes the loader semaphore.
70 *
71 * @returns 0 on success, non-zero OS status code on failure.
72 */
73int kldrHlpSemInit(void)
74{
75#ifdef __OS2__
76 APIRET rc;
77 g_hmtx = NULLHANDLE;
78 rc = DosCreateMutexSem(NULL, &g_hmtx, 0, FALSE);
79 if (rc)
80 return rc;
81
82#elif defined(__WIN__)
83 InitializeCriticalSection(&g_CritSect);
84
85#else
86# error "port me"
87#endif
88 return 0;
89}
90
91
92/**
93 * Terminates the loader semaphore.
94 */
95void kldrHlpSemTerm(void)
96{
97#ifdef __OS2__
98 APIRET rc;
99 HMTX hmtx = g_hmtx;
100 g_hmtx = NULLHANDLE;
101 rc = DosCloseMutexSem(hmtx);
102 if (rc)
103 return rc;
104
105#elif defined(__WIN__)
106 DeleteCriticalSection(&g_CritSect);
107
108#else
109# error "port me"
110#endif
111}
112
113
114/**
115 * Requests the loader sempahore ownership.
116 * This can be done recursivly.
117 *
118 * @returns 0 on success, non-zero OS status code on failure.
119 */
120int kldrHlpSemRequest(void)
121{
122#ifdef __OS2__
123 APIRET rc = DosRequestMutexSem(g_hmtx, 5000);
124 if (rc == ERROR_TIMEOUT || rc == ERROR_SEM_TIMEOUT || rc == ERROR_INTERRUPT)
125 {
126 unsigned i = 0;
127 do
128 {
129 /** @todo check for deadlocks etc. */
130 rc = DosRequestMutexSem(g_hmtx, 1000);
131 } while ( ( rc == ERROR_TIMEOUT
132 || rc == ERROR_SEM_TIMEOUT
133 || rc == ERROR_INTERRUPT)
134 && i++ < 120);
135 }
136 return rc;
137
138#elif defined(__WIN__)
139 EnterCriticalSection(&g_CritSect);
140 return 0;
141
142#else
143# error "port me"
144#endif
145}
146
147
148/**
149 * Releases the loader semaphore ownership.
150 * The caller is responsible for making sure it's the semaphore owner!
151 */
152void kldrHlpSemRelease(void)
153{
154#ifdef __OS2__
155 APIRET rc = DosReleaseMutexSem(g_hmtx);
156 kldrHlpAssert(!rc); (void)rc;
157
158#elif defined(__WIN__)
159 LeaveCriticalSection(&g_CritSect);
160
161#else
162# error "port me"
163#endif
164
165}
166
167#ifdef __OS2__
168static ULONG kldrHlpPageProtToNative(KLDRPROT enmProt)
169{
170 switch (enmProt)
171 {
172 case KLDRPROT_NOACCESS: return PAG_EXECUTE | PAG_READ | PAG_WRITE;
173 case KLDRPROT_READONLY: return PAG_COMMIT | PAG_READ;
174 case KLDRPROT_READWRITE: return PAG_COMMIT | PAG_READ | PAG_WRITE;
175 case KLDRPROT_EXECUTE: return PAG_COMMIT | PAG_EXECUTE;
176 case KLDRPROT_EXECUTE_READ: return PAG_COMMIT | PAG_EXECUTE | PAG_READ;
177 case KLDRPROT_EXECUTE_READWRITE: return PAG_COMMIT | PAG_EXECUTE | PAG_READ | PAG_WRITE;
178 default:
179 kldrHlpAssert(0);
180 return ~0U;
181 }
182}
183#elif defined(__WIN__)
184static DWORD kldrHlpPageProtToNative(KLDRPROT enmProt)
185{
186 switch (enmProt)
187 {
188 case KLDRPROT_NOACCESS: return PAGE_NOACCESS;
189 case KLDRPROT_READONLY: return PAGE_READONLY;
190 case KLDRPROT_READWRITE: return PAGE_READWRITE;
191 case KLDRPROT_EXECUTE: return PAGE_EXECUTE;
192 case KLDRPROT_EXECUTE_READ: return PAGE_EXECUTE_READ;
193 case KLDRPROT_EXECUTE_READWRITE: return PAGE_EXECUTE_READWRITE;
194 default:
195 kldrHlpAssert(0);
196 return ~0U;
197 }
198}
199#endif
200
201
202/**
203 * Allocate a chunk of memory with page granularity.
204 *
205 * @returns 0 on success, non-zero OS status code on failure.
206 * @param ppv Where to store the address of the allocated memory.
207 * If fFixed is set, *ppv will on entry contain the desired address (page aligned).
208 * @param cb Number of bytes. Page aligned.
209 * @param enmProt The new protection. Copy-on-write is invalid.
210 */
211int kldrHlpPageAlloc(void **ppv, size_t cb, KLDRPROT enmProt, unsigned fFixed)
212{
213#ifdef __OS2__
214 APIRET rc;
215 ULONG fFlags = kldrHlpPageProtToNative(enmProt);;
216
217 if (!fFixed)
218 {
219 /* simple */
220 rc = DosAllocMem(ppv, cb, fFlags | OBJ_ANY);
221 if (rc == ERROR_INVALID_PARAMETER)
222 rc = DosAllocMem(ppv, cb, fFlags);
223 }
224 else
225 {
226 /* not so simple. */
227 /** @todo I've got code for this in libc somewhere. */
228 }
229 if (!rc)
230 return 0;
231 kldrHlpAssert(0);
232 return rc;
233
234#elif defined(__WIN__)
[2831]235 /* (We don't have to care about the stub here, because the stub will be unmapped before we get here.) */
[2830]236 int rc;
237 DWORD fProt = kldrHlpPageProtToNative(enmProt);
238
239 if (!g_SystemInfo.dwPageSize)
240 GetSystemInfo(&g_SystemInfo);
241
242 *ppv = VirtualAlloc(fFixed ? *ppv : NULL, cb, MEM_COMMIT, fProt);
243 if (*ppv == NULL)
244 {
245 rc = GetLastError();
246 kldrHlpAssert(0);
247 }
248 return rc;
249
250#else
251# error "port me"
252#endif
253}
254
255
256/**
257 * Change the protection of one or more pages in an allocation.
258 *
259 * (This will of course only work correctly on memory allocated by kldrHlpPageAlloc().)
260 *
261 * @returns 0 on success, non-zero OS status code on failure.
262 * @param pv First page. Page aligned.
263 * @param cb Number of bytes. Page aligned.
264 * @param enmProt The new protection. Copy-on-write is invalid.
265 */
266int kldrHlpPageProtect(void *pv, size_t cb, KLDRPROT enmProt)
267{
268#ifdef __OS2__
269 APIRET rc;
270 uintptr_t offStub;
271 ULONG fFlags = kldrHlpPageProtToNative(enmProt);;
272
273 /*
274 * The non-stub pages.
275 */
276 rc = DosSetMem(pv, cb, fFlags);
277 if (rc && fFlags != PAG_DECOMMIT)
278 rc = DosSetMem(pv, cb, fFlags | PAG_COMMIT);
279 if (rc)
280 {
281 /* Try page by page. */
282 while (cb > 0)
283 {
284 rc = DosSetMem(pv, 0x1000, fFlags);
285 if (rc && fFlags != PAG_DECOMMIT)
286 rc = DosSetMem(pv, 0x1000, fFlags | PAG_COMMIT);
287 if (rc)
288 return rc;
289 pv = (void *)((uintptr_t)pv + 0x1000);
290 cb -= 0x1000;
291 }
292 }
293 kldrHlpAssert(!rc);
294 return rc;
295
296#elif defined(__WIN__)
297 DWORD fOldProt = 0;
298 DWORD fProt = kldrHlpPageProtToNative(enmProt);
299 int rc = 0;
300
301 if (!VirtualProtect(pv, cb, fProt, &fOldProt))
302 {
303 rc = GetLastError();
304 kldrHlpAssert(0);
305 }
306 return rc;
307#else
308# error "port me"
309#endif
310}
311
312
313/**
314 * Free memory allocated by kldrHlpPageAlloc().
315 *
316 * @returns 0 on success, non-zero OS status code on failure.
317 * @param pv The address returned by kldrHlpPageAlloc().
318 * @param cb The byte count requested from kldrHlpPageAlloc().
319 */
320int kldrHlpPageFree(void *pv, size_t cb)
321{
322#ifdef __OS2__
323 APIRET rc;
324
325 /*
326 * Deal with any portion overlapping with the stub.
327 */
328 uintptr_t offStub = (uintptr_t)pv - (uintptr_t)g_pvStub;
329 if (offStub < g_cbStub)
330 {
331 /* decommit the pages in the stub. */
332 size_t cbSub = KLDR_MIN(g_cbStub - offStub, cb);
333 rc = DosSetMem(pv, cbStub, PAG_DECOMMIT);
334 if (rc)
335 {
336 /* Page by page, ignoring errors after the first success. */
337 while (cbSub > 0)
338 {
339 if (!DosSetMem(pv, 0x1000, PAG_DECOMMIT))
340 rc = 0;
341 pv = (void *)((uintptr_t)pv + 0x1000);
342 cbSub -= 0x1000;
343 cb -= 0x1000;
344 }
345 if (rc)
346 {
347 kldrHlpAssert(!rc);
348 return rc;
349 }
350 }
351 else
352 {
353 cb -= cbSub;
354 if (!cb)
355 return 0;
356 pv = (void *)((uintptr_t)pv + cbSub);
357 }
358 }
359
360 /*
361 * Free the object.
362 */
363 rc = DosFreeMem(pv);
364 kldrHlpAssert(!rc);
365 return rc;
366
367#elif defined(__WIN__)
368 /*
369 * Free the object.
370 */
371 int rc = 0;
372 if (!VirtualFree(pv, 0 /*cb*/, MEM_RELEASE))
373 {
374 rc = GetLastError();
375 kldrHlpAssert(0);
376 }
377 return rc;
378
379#else
380# error "port me"
381#endif
382}
383
384
385/**
[2825]386 * Get an environment variable.
387 *
388 * @returns 0 on success, on failure an OS specific status code is returned.
389 * @param pszVar The variable name.
390 * @param pszVal Where to store the value. NULL is allowed if *pcchVal is 0.
391 * @param pcchVal On input the size of the buffer pointed to by pszVal.
392 * On output this contains the string length on success, while on
393 * failure (including buffer overflow) the require buffer size.
394 * If the variable wasn't found, it's set to 0.
395 */
396int kldrHlpGetEnv(const char *pszVar, char *pszVal, size_t *pcchVal)
397{
398#ifdef __OS2__
399 PSZ pszValue = NULL;
400 int rc = DosScanEnv((PCSZ)pszVar, &pszValue);
401 if (!rc)
402 {
[2828]403 size_t cch = kLdrHlpStrLen(pszValue);
[2825]404 if (pszVal)
405 {
406 if (*pcchVal > cch)
407 {
[2828]408 kLdrHlpMemCopy(pszVal, pszValue, cch + 1);
[2825]409 *pcchVal = cch;
410 }
411 else if (*pcchVal)
412 {
[2828]413 kLdrHlpMemCopy(pszVal, pszValue, *pcchVal);
[2825]414 pszVal[*pcchVal - 1] = '\0';
415 rc = ERROR_BUFFER_OVERFLOW;
416 *pcchVal = cch + 1;
417 }
418 }
419 else
420 {
421 rc = ERROR_BUFFER_OVERFLOW;
422 *pcchVal = cch + 1;
423 }
424 }
425 else
426 {
427 if (pszVal)
428 *pszVal = '\0';
429 *pcchVal = 0;
430 }
431
432 return rc;
433
434#elif defined(__WIN__)
435 DWORD cch;
436 SetLastError(0);
437 cch = GetEnvironmentVariable(pszVar, pszVal, *pcchVal);
438 if (cch)
439 {
440 *pcchVal = cch;
441 return 0;
442 }
443 if (!GetLastError() == ERROR_ENVVAR_NOT_FOUND)
444 {
445 *pcchVal = 0;
446 return ERROR_ENVVAR_NOT_FOUND;
447 }
448 *pcchVal = cch;
449 return ERROR_BUFFER_OVERFLOW;
450
451#else
452# error "Port me"
453#endif
454}
455
456
457/**
458 * Terminate the process.
459 *
460 * @param rc The exit status.
461 */
462void kldrHlpExit(int rc)
463{
464 for (;;)
465 {
466#ifdef __OS2__
467 DosExit(EXIT_PROCESS, rc);
468
469#elif defined(__WIN__)
470 TerminateProcess(GetCurrentProcess(), rc);
471
472#else
473# error "Port me"
474#endif
475 kldrHlpAssert(!"Impossible");
476 }
477}
478
[2830]479
480/**
481 * Sleep for a number of milliseconds.
482 * @param cMillies Number of milliseconds to sleep.
483 */
484void kldrHlpSleep(unsigned cMillies)
485{
486#ifdef __OS2__
487 DosSleep(cMillies);
488#elif defined(__WIN__)
489 Sleep(cMillies);
490#else
491 usleep(cMillies * 1000);
492#endif
493}
494
495
[2825]496/** Internal worker for kldrHlpAssertMsg. */
497static void int2dec(char *pszLine, unsigned iLine)
498{
499 do
500 {
501 *pszLine = (iLine % 10) + '0';
502 iLine /= 10;
503 } while (iLine);
504 *pszLine++ = '\0';
505}
506
507
508/**
509 * Internal worker for the kLdrHlpAssert() macro.
510 *
511 * @param pszExpr The assert expression.
512 * @param pszFile The filename.
513 * @param iLine The line number.
514 * @param pszFunction The function name.
515 */
516void kldrHlpAssertMsg(const char *pszExpr, const char *pszFile, unsigned iLine, const char *pszFunction)
517{
518#ifdef __OS2__
519 static const char s_szMsg1[] = "\r\n!!!kLdr Assertion Failed!!!\n\rExpression: ";
520 static const char s_szMsg2[] = "\r\nAt: ";
521 static const char s_szMsg3[] = "\r\n";
522 ULONG cbWritten;
523 char szLine[16];
524
525 DosWrite((HFILE)2, s_szMsg1, sizeof(s_szMsg1) - 1, &cbWritten);
[2828]526 DosWrite((HFILE)2, pszExpr, kLdrHlpStrLen(pszExpr), &cbWritten);
[2825]527 DosWrite((HFILE)2, s_szMsg2, sizeof(s_szMsg2) - 1, &cbWritten);
[2828]528 DosWrite((HFILE)2, pszFile, kLdrHlpStrLen(pszFile), &cbWritten);
[2825]529 DosWrite((HFILE)2, "(", sizeof("(") - 1, &cbWritten);
530 int2dec(szLine, iLine);
[2828]531 DosWrite((HFILE)2, szLine, kLdrHlpStrLen(szLine), &cbWritten);
[2825]532 DosWrite((HFILE)2, ") ", sizeof(") ") - 1, &cbWritten);
[2828]533 DosWrite((HFILE)2, pszFunction, kLdrHlpStrLen(pszFunction), &cbWritten);
[2825]534 DosWrite((HFILE)2, s_szMsg3, sizeof(s_szMsg3) - 1, &cbWritten);
535
536#elif defined(__WIN__)
537 static const char s_szMsg1[] = "\r\n!!!kLdr Assertion Failed!!!\n\rExpression: ";
538 static const char s_szMsg2[] = "\r\nAt: ";
539 static const char s_szMsg3[] = "\r\n";
540 DWORD cbWritten;
541 char szLine[16];
542 const HANDLE hStdErr = (HANDLE)STD_ERROR_HANDLE;
543
544 WriteFile(hStdErr, s_szMsg1, sizeof(s_szMsg1) - 1, &cbWritten, NULL);
[2828]545 WriteFile(hStdErr, pszExpr, kLdrHlpStrLen(pszExpr), &cbWritten, NULL);
[2825]546 WriteFile(hStdErr, s_szMsg2, sizeof(s_szMsg2) - 1, &cbWritten, NULL);
[2828]547 WriteFile(hStdErr, pszFile, kLdrHlpStrLen(pszFile), &cbWritten, NULL);
[2825]548 WriteFile(hStdErr, "(", sizeof("(") - 1, &cbWritten, NULL);
549 int2dec(szLine, iLine);
[2828]550 WriteFile(hStdErr, szLine, kLdrHlpStrLen(szLine), &cbWritten, NULL);
[2825]551 WriteFile(hStdErr, ") ", sizeof(") ") - 1, &cbWritten, NULL);
[2828]552 WriteFile(hStdErr, pszFunction, kLdrHlpStrLen(pszFunction), &cbWritten, NULL);
[2825]553 WriteFile(hStdErr, s_szMsg3, sizeof(s_szMsg3) - 1, &cbWritten, NULL);
554
555#else
556# error "Port me"
557#endif
558}
559
Note: See TracBrowser for help on using the repository browser.