Changeset 2827

Timestamp:

Oct 22, 2006, 8:05:28 PM (19 years ago)

Author:

bird

Message:

image format headers.

Location:

trunk/kLdr

Files:

• Makefile.kmk (modified) (1 diff)
• kLdr.h (modified) (1 diff)
• kLdrHlp.h (modified) (1 diff)
• kLdrInternal.h (modified) (1 diff)
• kLdrMod.c (modified) (2 diffs)
• kLdrModELF32.h (added)
• kLdrModELF64.h (added)
• kLdrModELFAmd64.h (added)
• kLdrModELFCommon.h (added)
• kLdrModELFi386.h (added)
• kLdrModLX.c (moved) (moved from trunk/kLdr/kLdrLX.c ) (1 diff)
• kLdrModMZ.h (added)
• kLdrModPE.h (added)

trunk/kLdr/Makefile.kmk

@@ -94 +94 @@
         kLdrRdr.c \
         kLdrRdrFile.c \
-        kLdrLX.c
+        kLdrMod.c \
+        kLdrModLX.c
 kLdr_SOURCES.os2 = \
         kLdr-os2.def \

trunk/kLdr/kLdr.h

@@ -282 +282 @@
 /** @} */
 
+
+/** @defgroup grp_kLdrErr   kLdr Status Codes
+ * kLdr uses a mix of native status codes and it's own status codes.
+ * A status code of 0 means success, all other status codes means failure.
+ * @{
+ */
+#ifdef __OS2__
+# define KLDR_ERR_BASE          0x7face000
+#elif defined(__WIN__)
+# define KLDR_ERR_BASE          0x7face000
+#else
+# error "port me"
+#endif
+/** The image format is unknown. */
+#define KLDR_ERR_UNKNOWN_FORMAT         (KLDR_ERR_BASE + 0)
+/** The MZ image format isn't supported by this kLdr build. */
+#define KLDR_ERR_MZ_NOT_SUPPORTED       (KLDR_ERR_BASE + 1)
+/** The NE image format isn't supported by this kLdr build. */
+#define KLDR_ERR_NE_NOT_SUPPORTED       (KLDR_ERR_BASE + 2)
+/** The LX image format isn't supported by this kLdr build. */
+#define KLDR_ERR_LX_NOT_SUPPORTED       (KLDR_ERR_BASE + 3)
+/** The LE image format isn't supported by this kLdr build. */
+#define KLDR_ERR_LE_NOT_SUPPORTED       (KLDR_ERR_BASE + 4)
+/** The PE image format isn't supported by this kLdr build. */
+#define KLDR_ERR_PE_NOT_SUPPORTED       (KLDR_ERR_BASE + 5)
+/** The ELF image format isn't supported by this kLdr build. */
+#define KLDR_ERR_ELF_NOT_SUPPORTED      (KLDR_ERR_BASE + 6)
+/** The mach-o image format isn't supported by this kLdr build. */
+#define KLDR_ERR_MACHO_NOT_SUPPORTED    (KLDR_ERR_BASE + 7)
+/** The mach-o image format isn't supported by this kLdr build. */
+#define KLDR_ERR_AOUT_NOT_SUPPORTED     (KLDR_ERR_BASE + 8)
+/** The mach-o image format isn't supported by this kLdr build. */
+#define KLDR_ERR_BAD_FIXUP              (KLDR_ERR_BASE + 32)
+
+/** @} */
+
+
 #ifdef __cplusplus
 }

trunk/kLdr/kLdrHlp.h

@@ -32 +32 @@
  * @internal
  * @{ */
+
 /** Get the minimum of two values. */
 #define KLDR_MIN(a, b) ((a) <= (b) ? (a) : (b))
-
+/** Calculate the offset of a structure member. */
+#define KLDR_OFFSETOF(strct, memb)  ( (size_t)( ((strct *)0)->memb ) )
 /** Align a size_t value. */
 #define KLDR_ALIGN_Z(val, align)    ( ((val) + ((align) - 1)) & ~(size_t)((align) - 1) )
 /** Align a void * value. */
 #define KLDR_ALIGN_P(pv, align)     ( (void *)( ((uintptr_t)(pv) + ((align) - 1)) & ~(uintptr_t)((align) - 1) ) )
+/** @def KLDRHLP_LE2H_U16
+ * Unsigned 16-bit little-endian to host translation. */
+/** @def KLDRHLP_LE2H_U32
+ * Unsigned 32-bit little-endian to host translation. */
+#if 1
+# define KLDRHLP_LE2H_U16(u16)  ((uint16_t)(u16))
+# define KLDRHLP_LE2H_U32(u32)  ((uint32_t)(u32))
+#else
+# define KLDRHLP_LE2H_U16(u16)  ( (uint16_t) (((u16) >> 8) | ((u16) << 8)) )
+# define KLDRHLP_LE2H_U32(u32)  (   ( ((u32) & UINT32_C(0xff000000)) >> 24 ) \
+                                  | ( ((u32) & UINT32_C(0x00ff0000)) >>  8 ) \
+                                  | ( ((u32) & UINT32_C(0x0000ff00)) <<  8 ) \
+                                  | ( ((u32) & UINT32_C(0x000000ff)) << 24 ) \
+                                )
+#endif
 
 /*

trunk/kLdr/kLdrInternal.h

@@ -32 +32 @@
 extern "C" {
 #endif
+
+/* ignore definitions in winnt.h */
+#undef IMAGE_DOS_SIGNATURE
+#undef IMAGE_NT_SIGNATURE
+
+/** @name Signatures we know
+ * @{ */
+/** ELF signature ("\x7fELF"). */
+#define IMAGE_ELF_SIGNATURE KLDRHLP_LE2H_U32(0x7f | ('E' << 8) | ((uint32_t)'L' << 16) | ((uint32_t)'F' << 24))
+/** PE signature ("PE\0\0"). */
+#define IMAGE_NT_SIGNATURE  KLDRHLP_LE2H_U32('P' | ('E' << 8))
+/** LX signature ("LX") */
+#define IMAGE_LX_SIGNATURE  KLDRHLP_LE2H_U16('L' | ('X' << 8))
+/** LE signature ("LE") */
+#define IMAGE_LE_SIGNATURE  KLDRHLP_LE2H_U16('L' | ('E' << 8))
+/** NE signature ("NE") */
+#define IMAGE_NE_SIGNATURE  KLDRHLP_LE2H_U16('N' | ('E' << 8))
+/** MZ signature ("MZ"). */
+#define IMAGE_DOS_SIGNATURE KLDRHLP_LE2H_U16('M' | ('Z' << 8))
+/** @} */
+
 
 /** Native file provider operations. */

trunk/kLdr/kLdrMod.c

@@ -32 +32 @@
 #include "kLdrHlp.h"
 #include "kLdrInternal.h"
+#include "kLdrModMZ.h"
+#if 1 /* testing headers */
+# include "kLdrModPE.h"
+//# include "kLdrModLX.h"
+# include "kLdrModELF32.h"
+# include "kLdrModELF64.h"
+#endif
 
 
+/**
+ * Open a executable image from a file provider instance.
+ *
+ * @returns 0 on success and *ppMod pointing to a module instance.
+ *          On failure, a non-zero OS specific error code is returned.
+ * @param   pRdr            The file provider instance to use.
+ *                          On success, the ownership of the instance is taken by the
+ *                          module and the caller must not ever touch it again.
+ *                          (The instance is not closed on failure, the call has to do that.)
+ * @param   ppMod           Where to store the module handle.
+ */
+int kLdrModOpenFromRdr(PKLDRRDR pRdr, PPKLDRMOD ppMod)
+{
+    union
+    {
+        uint32_t    u32;
+        uint16_t    u16;
+        uint16_t    au16[2];
+        uint8_t     au8[4];
+    }       u;
+    off_t   offHdr = 0;
+    int     rc;
+
+    /*
+     * Try figure out what kind of image this is.
+     * Always read the 'new header' if we encounter MZ.
+     */
+    rc = kLdrRdrRead(pRdr, &u, sizeof(u), 0);
+    if (rc)
+        return rc;
+    if (    u.u16 == IMAGE_DOS_SIGNATURE
+        &&  kLdrRdrSize(pRdr) > sizeof(IMAGE_DOS_HEADER))
+    {
+        rc = kLdrRdrRead(pRdr, &u, sizeof(u.u32), KLDR_OFFSETOF(IMAGE_DOS_HEADER, e_lfanew));
+        if (rc)
+            return rc;
+        if ((off_t)u.u32 < kLdrRdrSize(pRdr))
+        {
+            offHdr = u.u32;
+            rc = kLdrRdrRead(pRdr, &u, sizeof(u.u32), offHdr);
+            if (rc)
+                return rc;
+        }
+        else
+            u.u16 = IMAGE_DOS_SIGNATURE;
+    }
+
+    /*
+     * Use the magic to select the appropriate image interpreter.
+     */
+    if (u.u16 == IMAGE_DOS_SIGNATURE)
+        return KLDR_ERR_MZ_NOT_SUPPORTED;
+    else if (u.u16 == IMAGE_NE_SIGNATURE)
+        return KLDR_ERR_NE_NOT_SUPPORTED;
+    else if (u.u16 == IMAGE_LX_SIGNATURE)
+        return KLDR_ERR_LX_NOT_SUPPORTED;
+    else if (u.u16 == IMAGE_LE_SIGNATURE)
+        return KLDR_ERR_LE_NOT_SUPPORTED;
+    else if (u.u32 == IMAGE_NT_SIGNATURE)
+        return KLDR_ERR_PE_NOT_SUPPORTED;
+    else if (u.u32 == IMAGE_ELF_SIGNATURE)
+        return KLDR_ERR_ELF_NOT_SUPPORTED;
+    return KLDR_ERR_UNKNOWN_FORMAT;
+}
+
+
+/**
+ * Open a executable image by file name.
+ *
+ * @returns 0 on success and *ppMod pointing to a module instance.
+ *          On failure, a non-zero OS specific error code is returned.
+ * @param   pszFilename     The filename to open.
+ * @param   ppMod           Where to store the module handle.
+ */
 int kLdrModOpen(const char *pszFilename, PPKLDRMOD ppMod)
 {
@@ -39 +120 @@
      * Open the file using a bit provider.
      */
-
-
+    PKLDRRDR pRdr;
+    int rc = kLdrRdrOpen(&pRdr, pszFilename);
+    if (!rc)
+    {
+        rc = kLdrModOpenFromRdr(pRdr, ppMod);
+        if (!rc)
+            return 0;
+       kLdrRdrClose(pRdr);
+    }
+    return rc;
 }
 

trunk/kLdr/kLdrModLX.c

@@ -26 +26 @@
 
 #include "kLdr.h"
+