Changeset 2830 for trunk/kLdr/kLdrHlp.c

Timestamp:

Oct 23, 2006, 10:53:11 PM (19 years ago)

Author:

bird

Message:

Page aligned object allocation.

File:

• trunk/kLdr/kLdrHlp.c (modified) (2 diffs)

trunk/kLdr/kLdrHlp.c

@@ -41 +41 @@
 #include <kLdr.h>
 #include "kLdrHlp.h"
+
+
+/*******************************************************************************
+*   Global Variables                                                           *
+*******************************************************************************/
+#ifdef __OS2__
+/** The loader sempahore. */
+static HMTX             g_hmtx;
+/** The base of the stub object.
+ * The OS/2 exe stub consists of a single data object. When allocating memory
+ * for an executable, we'll have to reuse this.  */
+static void            *g_pvStub = NULL;
+/** The size of the stub object - 0 if no stub. */
+static size_t           g_cbStub = 0;
+
+#elif defined(__WIN__)
+/** The loader sempahore. */
+static CRITICAL_SECTION g_CritSect;
+/** The system info. */
+static SYSTEM_INFO      g_SystemInfo;
+#else
+# error "port me"
+#endif
+
+
+/**
+ * Initializes the loader semaphore.
+ *
+ * @returns 0 on success, non-zero OS status code on failure.
+ */
+int     kldrHlpSemInit(void)
+{
+#ifdef __OS2__
+    APIRET rc;
+    g_hmtx = NULLHANDLE;
+    rc = DosCreateMutexSem(NULL, &g_hmtx, 0, FALSE);
+    if (rc)
+        return rc;
+
+#elif defined(__WIN__)
+    InitializeCriticalSection(&g_CritSect);
+
+#else
+# error "port me"
+#endif
+    return 0;
+}
+
+
+/**
+ * Terminates the loader semaphore.
+ */
+void    kldrHlpSemTerm(void)
+{
+#ifdef __OS2__
+    APIRET rc;
+    HMTX hmtx = g_hmtx;
+    g_hmtx = NULLHANDLE;
+    rc = DosCloseMutexSem(hmtx);
+    if (rc)
+        return rc;
+
+#elif defined(__WIN__)
+    DeleteCriticalSection(&g_CritSect);
+
+#else
+# error "port me"
+#endif
+}
+
+
+/**
+ * Requests the loader sempahore ownership.
+ * This can be done recursivly.
+ *
+ * @returns 0 on success, non-zero OS status code on failure.
+ */
+int     kldrHlpSemRequest(void)
+{
+#ifdef __OS2__
+    APIRET rc = DosRequestMutexSem(g_hmtx, 5000);
+    if (rc == ERROR_TIMEOUT || rc == ERROR_SEM_TIMEOUT || rc == ERROR_INTERRUPT)
+    {
+        unsigned i = 0;
+        do
+        {
+            /** @todo check for deadlocks etc. */
+            rc = DosRequestMutexSem(g_hmtx, 1000);
+        } while (   (   rc == ERROR_TIMEOUT
+                     || rc == ERROR_SEM_TIMEOUT
+                     || rc == ERROR_INTERRUPT)
+                 && i++ < 120);
+    }
+    return rc;
+
+#elif defined(__WIN__)
+    EnterCriticalSection(&g_CritSect);
+    return 0;
+
+#else
+# error "port me"
+#endif
+}
+
+
+/**
+ * Releases the loader semaphore ownership.
+ * The caller is responsible for making sure it's the semaphore owner!
+ */
+void    kldrHlpSemRelease(void)
+{
+#ifdef __OS2__
+    APIRET rc = DosReleaseMutexSem(g_hmtx);
+    kldrHlpAssert(!rc); (void)rc;
+
+#elif defined(__WIN__)
+    LeaveCriticalSection(&g_CritSect);
+
+#else
+# error "port me"
+#endif
+
+}
+
+#ifdef __OS2__
+static ULONG kldrHlpPageProtToNative(KLDRPROT enmProt)
+{
+    switch (enmProt)
+    {
+        case KLDRPROT_NOACCESS:             return PAG_EXECUTE | PAG_READ | PAG_WRITE;
+        case KLDRPROT_READONLY:             return PAG_COMMIT | PAG_READ;
+        case KLDRPROT_READWRITE:            return PAG_COMMIT | PAG_READ | PAG_WRITE;
+        case KLDRPROT_EXECUTE:              return PAG_COMMIT | PAG_EXECUTE;
+        case KLDRPROT_EXECUTE_READ:         return PAG_COMMIT | PAG_EXECUTE | PAG_READ;
+        case KLDRPROT_EXECUTE_READWRITE:    return PAG_COMMIT | PAG_EXECUTE | PAG_READ | PAG_WRITE;
+        default:
+            kldrHlpAssert(0);
+            return ~0U;
+    }
+}
+#elif defined(__WIN__)
+static DWORD kldrHlpPageProtToNative(KLDRPROT enmProt)
+{
+    switch (enmProt)
+    {
+        case KLDRPROT_NOACCESS:             return PAGE_NOACCESS;
+        case KLDRPROT_READONLY:             return PAGE_READONLY;
+        case KLDRPROT_READWRITE:            return PAGE_READWRITE;
+        case KLDRPROT_EXECUTE:              return PAGE_EXECUTE;
+        case KLDRPROT_EXECUTE_READ:         return PAGE_EXECUTE_READ;
+        case KLDRPROT_EXECUTE_READWRITE:    return PAGE_EXECUTE_READWRITE;
+        default:
+            kldrHlpAssert(0);
+            return ~0U;
+    }
+}
+#endif
+
+
+/**
+ * Allocate a chunk of memory with page granularity.
+ *
+ * @returns 0 on success, non-zero OS status code on failure.
+ * @param   ppv         Where to store the address of the allocated memory.
+ *                      If fFixed is set, *ppv will on entry contain the desired address (page aligned).
+ * @param   cb          Number of bytes. Page aligned.
+ * @param   enmProt     The new protection. Copy-on-write is invalid.
+ */
+int     kldrHlpPageAlloc(void **ppv, size_t cb, KLDRPROT enmProt, unsigned fFixed)
+{
+#ifdef __OS2__
+    APIRET  rc;
+    ULONG   fFlags = kldrHlpPageProtToNative(enmProt);;
+
+    if (!fFixed)
+    {
+        /* simple */
+        rc = DosAllocMem(ppv, cb, fFlags | OBJ_ANY);
+        if (rc == ERROR_INVALID_PARAMETER)
+            rc = DosAllocMem(ppv, cb, fFlags);
+    }
+    else
+    {
+        /* not so simple. */
+        /** @todo I've got code for this in libc somewhere. */
+    }
+    if (!rc)
+        return 0;
+    kldrHlpAssert(0);
+    return rc;
+
+#elif defined(__WIN__)
+    int     rc;
+    DWORD   fProt = kldrHlpPageProtToNative(enmProt);
+
+    if (!g_SystemInfo.dwPageSize)
+        GetSystemInfo(&g_SystemInfo);
+
+    *ppv = VirtualAlloc(fFixed ? *ppv : NULL, cb, MEM_COMMIT, fProt);
+    if (*ppv == NULL)
+    {
+        rc = GetLastError();
+        kldrHlpAssert(0);
+    }
+    return rc;
+
+#else
+# error "port me"
+#endif
+}
+
+
+/**
+ * Change the protection of one or more pages in an allocation.
+ *
+ * (This will of course only work correctly on memory allocated by kldrHlpPageAlloc().)
+ *
+ * @returns 0 on success, non-zero OS status code on failure.
+ * @param   pv          First page. Page aligned.
+ * @param   cb          Number of bytes. Page aligned.
+ * @param   enmProt     The new protection. Copy-on-write is invalid.
+ */
+int     kldrHlpPageProtect(void *pv, size_t cb, KLDRPROT enmProt)
+{
+#ifdef __OS2__
+    APIRET      rc;
+    uintptr_t   offStub;
+    ULONG       fFlags = kldrHlpPageProtToNative(enmProt);;
+
+    /*
+     * The non-stub pages.
+     */
+    rc = DosSetMem(pv, cb, fFlags);
+    if (rc && fFlags != PAG_DECOMMIT)
+        rc = DosSetMem(pv, cb, fFlags | PAG_COMMIT);
+    if (rc)
+    {
+        /* Try page by page. */
+        while (cb > 0)
+        {
+            rc = DosSetMem(pv, 0x1000, fFlags);
+            if (rc && fFlags != PAG_DECOMMIT)
+                rc = DosSetMem(pv, 0x1000, fFlags | PAG_COMMIT);
+            if (rc)
+                return rc;
+            pv = (void *)((uintptr_t)pv + 0x1000);
+            cb -= 0x1000;
+        }
+    }
+    kldrHlpAssert(!rc);
+    return rc;
+
+#elif defined(__WIN__)
+    DWORD fOldProt = 0;
+    DWORD fProt = kldrHlpPageProtToNative(enmProt);
+    int rc = 0;
+
+    if (!VirtualProtect(pv, cb, fProt, &fOldProt))
+    {
+        rc = GetLastError();
+        kldrHlpAssert(0);
+    }
+    return rc;
+#else
+# error "port me"
+#endif
+}
+
+
+/**
+ * Free memory allocated by kldrHlpPageAlloc().
+ *
+ * @returns 0 on success, non-zero OS status code on failure.
+ * @param   pv          The address returned by kldrHlpPageAlloc().
+ * @param   cb          The byte count requested from kldrHlpPageAlloc().
+ */
+int     kldrHlpPageFree(void *pv, size_t cb)
+{
+#ifdef __OS2__
+    APIRET rc;
+
+    /*
+     * Deal with any portion overlapping with the stub.
+     */
+    uintptr_t offStub = (uintptr_t)pv - (uintptr_t)g_pvStub;
+    if (offStub < g_cbStub)
+    {
+        /* decommit the pages in the stub. */
+        size_t cbSub = KLDR_MIN(g_cbStub - offStub, cb);
+        rc = DosSetMem(pv, cbStub, PAG_DECOMMIT);
+        if (rc)
+        {
+            /* Page by page, ignoring errors after the first success. */
+            while (cbSub > 0)
+            {
+                if (!DosSetMem(pv, 0x1000, PAG_DECOMMIT))
+                    rc = 0;
+                pv = (void *)((uintptr_t)pv + 0x1000);
+                cbSub -= 0x1000;
+                cb -= 0x1000;
+            }
+            if (rc)
+            {
+                kldrHlpAssert(!rc);
+                return rc;
+            }
+        }
+        else
+        {
+            cb -= cbSub;
+            if (!cb)
+                return 0;
+            pv = (void *)((uintptr_t)pv + cbSub);
+        }
+    }
+
+    /*
+     * Free the object.
+     */
+    rc = DosFreeMem(pv);
+    kldrHlpAssert(!rc);
+    return rc;
+
+#elif defined(__WIN__)
+    /*
+     * Free the object.
+     */
+    int rc = 0;
+    if (!VirtualFree(pv, 0 /*cb*/, MEM_RELEASE))
+    {
+        rc = GetLastError();
+        kldrHlpAssert(0);
+    }
+    return rc;
+
+#else
+# error "port me"
+#endif
+}
 
 
@@ -137 +476 @@
 }
 
+
+/**
+ * Sleep for a number of milliseconds.
+ * @param   cMillies    Number of milliseconds to sleep.
+ */
+void kldrHlpSleep(unsigned cMillies)
+{
+#ifdef __OS2__
+    DosSleep(cMillies);
+#elif defined(__WIN__)
+    Sleep(cMillies);
+#else
+    usleep(cMillies * 1000);
+#endif
+}
+
+
 /** Internal worker for kldrHlpAssertMsg. */
 static void int2dec(char *pszLine, unsigned iLine)