Changeset 483 for Whitix/branches/hybrid

Timestamp:

05/12/08 12:20:25 (4 months ago)

Author:

mwhitworth

Message:

Finish module code, add support for module symbolic crashes, fix functions.

Location:

Whitix/branches/hybrid/kernel

Files:

• load.c (modified) (2 diffs)
• module.c (modified) (11 diffs)
• symbols.c (modified) (4 diffs)

Whitix/branches/hybrid/kernel/load.c

@@ -53 +53 @@
  * FUNCTION: ExecOpen
  *
- * DESCRIPTION: Opens an executable file, and does basic checks for it's
+ * DESCRIPTION: Opens an executable file, and does basic checks for its
  *                              suitability.
  *
@@ -59 +59 @@
  *                         file - file structure.
  *
- ***********************************************************************/
-
-static int ExecOpen(char* pathName,struct File* file)
+ * RETURNS:             0 if successfully opened, the return value from DoOpenFile
+ *                              if it failed to open, or -EISDIR if the path name is a
+ *                              directory.
+ ***********************************************************************/
+
+static int ExecOpen(char* pathName, struct File* file)
 {
         int err;

Whitix/branches/hybrid/kernel/module.c

@@ -17 +17 @@
  */
 
+#include <config.h>
 #include <console.h>
 #include <elf.h>
@@ -27 +28 @@
 #include <slab.h>
 #include <sys.h>
+#include <task.h>
 
 LIST_HEAD(moduleList);
@@ -52 +54 @@
 
                 /* Handle data? */
-                return (module->textAddr+symbol->symValue);
+                return symbol->symValue;
         }
 
         return NULL;
 }
+
+#ifdef CONFIG_ALL_SYMBOLS
+
+void ModuleSymbolPrint(DWORD address)
+{
+        struct Module* curr, *module=NULL;
+
+        ListForEachEntry(curr, &moduleList, next)
+        {
+                if (address >= curr->textAddr && address < curr->textAddr+curr->textLength)
+                {
+                        module=curr;
+                        break;
+                }
+        }
+
+        if (module)
+        {
+                DWORD size, offset;
+                const char* SymbolLookup(char*, struct ElfSymbol*, int, DWORD, DWORD*, DWORD*);
+
+                const char* name=SymbolLookup(module->strTable, module->symTable, module->symTableSize, address, &size, &offset);
+
+                if (name)
+                        printf("%s+%#X/%#X\n", name, offset, size);
+                else
+                        printf("%#X\n", address);
+        }else
+                printf("%#X\n", address);
+}
+
+void ModuleSymbolAdd(struct Module* module)
+{
+        int length=module->symTableSize+module->strTableSize;
+        char* dest=(void*)VirtMapPhysRange(MODULE_START, MODULE_END, PAGE_ALIGN_UP(length) >> PAGE_SHIFT, 3);
+
+        memcpy(dest, module->symTable, module->symTableSize);
+        module->symTable=(struct ElfSymbol*)dest;
+
+        dest+=module->symTableSize;
+        memcpy(dest, module->strTable, module->strTableSize);
+        module->strTable=dest;  
+}
+
+#else
+void ModuleSymbolPrint(DWORD address)
+{
+        printf("%#X\n", address);
+}
+
+void ModuleSymbolAdd(struct Module* module)
+{
+}
+#endif
 
 DWORD ModuleResolveKernel(char* name)
@@ -97 +153 @@
 }
 
-int ModuleSymbolResolve(struct Module* module, char* file, int sec)
+int ModuleSymbolPrepare(struct Module* module)
+{
+        int i;
+        DWORD symSize=module->symTableSize/sizeof(struct ElfSymbol);
+
+        for (i=1; i<symSize; i++)
+        {
+                struct ElfSymbol* symbol=&module->symTable[i];
+                char* symName=module->strTable+symbol->symName;
+
+                switch (symbol->symIndex)
+                {
+                        case STN_UNDEF:
+                                symbol->symValue=ModuleResolveKernel(symName);
+
+                                if (symbol->symValue)
+                                        break;
+
+                                printf("Could not resolve %s\n", symName);
+                                return -ENOENT;
+
+                        /* Absolute symbol. No relocation needed. */
+                        case STN_ABS:
+                                break;
+
+                        case STN_COMMON:
+                                printf("Please recompile the module with -fno-common.\n");
+                                return -ENOENT;
+
+                        default:
+                                symbol->symValue+=module->sectionHeaders[symbol->symIndex].shAddr;
+                }
+        }
+
+        return 0;
+}
+
+/* TODO: Create a prepare symbols function, then remove symValue manipulation code here. */
+
+void ModuleSymbolResolve(struct Module* module, char* file, int sec)
 {
         int i;
@@ -107 +202 @@
         {
                 reloc=&relTable[i];
-
                 unsigned long* relAddr=(unsigned long*)(module->sectionHeaders[ module->sectionHeaders[sec].shInfo ].shAddr+reloc->addr);
                 int symTabIdx=ELF_R_SYM(reloc->info);
                 struct ElfSymbol* symbol=&module->symTable[symTabIdx];
-                char* symName=module->strTable+symbol->symName;
-                DWORD symbolAddr=0;
-
-                if (symTabIdx && symName[0] != '.' && strlen(symName) && symbol->symIndex == STN_UNDEF)
-                {
-                        symbolAddr=ModuleResolveKernel(symName);
-
-                        /* Could not resolve symbol address. */
-                        if (!symbolAddr)
-                                return -EINVAL;
-                }
 
                 switch (ELF_R_TYPE(reloc->info))
@@ -129 +212 @@
 
                         case R_386_32:
-                        {
-                                if (symbol->symIndex == STN_UNDEF)
-                                        *relAddr+=symbolAddr;
-
-                                if (symbol->symIndex > 0 && symbol->symIndex < 0xF000)
-                                        *relAddr+=module->sectionHeaders[symbol->symIndex].shAddr;
-                        }
-                        break;
+                                *relAddr+=symbol->symValue;
+                                break;
 
                         case R_386_PC32:
-                                *relAddr+=symbolAddr-(DWORD)relAddr;
+                                *relAddr+=symbol->symValue-(DWORD)relAddr;
                                 break;
 
                         default:
-                                printf("ModuleSymbolResolve: type = %u\n", ELF_R_TYPE(reloc->info));
-                }
-        }
-
-        return 0;
+                                printf("ModuleSymbolResolve: type = %u, %u\n", ELF_R_TYPE(reloc->info), symbol->symIndex);
+                }
+        }
 }
 
@@ -186 +261 @@
         if (!ELF_HEAD_CHECK(elfHeader) || (elfHeader->fileType != ELF_REL) || (elfHeader->shEntrySize != sizeof(struct ElfSectionHeader)))
                 return -EINVAL;
-        
+
         /* Iterate through section headers. */
         sectionHeaders=(struct ElfSectionHeader*)((char*)file+elfHeader->shOffset);
@@ -207 +282 @@
 
                 if (sectionHeaders[i].shType == SEC_TYPE_STRTAB)
+                {
                         module->strTable=(char*)file+sectionHeaders[i].shOffset;
+                        module->strTableSize=sectionHeaders[i].shSize;
+                }
 
                 /* Align up sizes. */
@@ -213 +291 @@
         }
 
+        /* Copy over the module data into a new image. */
         char* dest;
-
         dest=module->loadAddr;
 
@@ -223 +301 @@
 
                 if (sectionHeaders[i].shFlags & SEC_FLAGS_EXEC)
+                {
                         module->textAddr=dest;
+                        module->textLength=sectionHeaders[i].shSize;
+                }
 
                 sectionHeaders[i].shAddr=dest;
@@ -234 +315 @@
         }
 
+        if (ModuleSymbolPrepare(module))
+                return -ENOENT;
+
         for (i=0; i<elfHeader->shEntries; i++)
         {
                 if (sectionHeaders[i].shType == SEC_TYPE_REL)
-                {
-                        /* Resolve entries in the module file. */
-                        if (ModuleSymbolResolve(module, file, i) < 0)
-                                return -EINVAL;
-                }
+                        /* Resolve entries in the module. */
+                        ModuleSymbolResolve(module, file, i);
         }
 

Whitix/branches/hybrid/kernel/symbols.c

@@ -35 +35 @@
 static int strTableSize DATA;
 
-const char* SymbolLookup(DWORD address, DWORD* size, DWORD* offset)
+const char* SymbolLookup(char* stringTable, struct ElfSymbol* symbolTable, int symSize, DWORD address, DWORD* size, DWORD* offset)
 {
         int i=0;
@@ -42 +42 @@
         DWORD currOffset=~0;
 
-        while (i < (symTableSize/sizeof(struct ElfSymbol)))
+        while (i < (symSize/sizeof(struct ElfSymbol)))
         {
-                symbol=&symTable[i++];
+                symbol=&symbolTable[i++];
 
                 if (ELF_ST_TYPE(symbol->symInfo) != STT_FUNC)
@@ -60 +60 @@
                 return NULL;
 
-        *offset=address-currSym->symValue;
+        *offset=currOffset;
         *size=currSym->symSize;
 
-        return strTable+currSym->symName;
+        if (*offset > *size)
+        {
+                printf("%#X-%#X = %#X %#X\n", address, symbol->symValue, *offset, *size);
+                while (1);
+        }
+
+        return stringTable+currSym->symName;
 }
 
@@ -70 +76 @@
         DWORD size, offset;
 
-        const char* name=SymbolLookup(address, &size, &offset);
+        const char* name=SymbolLookup(strTable, symTable, symTableSize, address, &size, &offset);
 
-        if (name)
+        if (name)
                 printf("%s+%#X/%#X\n", name, offset, size);
         else