Burer/kolibrios
1
0
Fork 0
forked from KolibriOS/kolibrios
Code Pull Requests Activity

PE loader. Link kernel.mnt

Browse Source 
git-svn-id: svn://kolibrios.org@890 a494cfbc-eb01-0410-851d-a64ba20cac60
This commit is contained in:
Sergey Semyonov (Serge) 2008-10-30 19:23:42 +00:00
parent cb4549795b
commit da448a7a84
17 changed files with 862 additions and 55 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
kernel/branches/kolibri_pe/bus/pci/pci32.inc
View File

@ -32,7 +32,7 @@ $Revision$
;*************************************************************************** ;***************************************************************************
align 4 align 4
_PciApi:
pci_api: pci_api:
cmp [pci_access_enabled],1 cmp [pci_access_enabled],1

1
kernel/branches/kolibri_pe/const.inc
View File

@ -202,6 +202,7 @@ master_tab equ (page_tabs+ (page_tabs shr 10)) ;0xFDFF70000
_16BIT_BASE equ 0x00010000 _16BIT_BASE equ 0x00010000
LOAD_BASE equ 0x00100000 LOAD_BASE equ 0x00100000
OS_BASE equ 0xE0000000 OS_BASE equ 0xE0000000
IMAGE_BASE equ (OS_BASE+LOAD_BASE)
window_data equ OS_BASE window_data equ OS_BASE

688
kernel/branches/kolibri_pe/core/dll.c Normal file
View File

@ -0,0 +1,688 @@
#include <types.h>
#include <core.h>
#include <spinlock.h>
#include <link.h>
#include <mm.h>
#include <slab.h>
typedef unsigned short WORD;
typedef unsigned int DWORD;
typedef unsigned int LONG;
typedef unsigned char BYTE;
#define IMAGE_DOS_SIGNATURE 0x5A4D
#define IMAGE_NT_SIGNATURE 0x00004550
#define IMAGE_NT_OPTIONAL_HDR32_MAGIC 0x10b
#pragma pack(push,2)
typedef struct _IMAGE_DOS_HEADER
{
WORD e_magic;
WORD e_cblp;
WORD e_cp;
WORD e_crlc;
WORD e_cparhdr;
WORD e_minalloc;
WORD e_maxalloc;
WORD e_ss;
WORD e_sp;
WORD e_csum;
WORD e_ip;
WORD e_cs;
WORD e_lfarlc;
WORD e_ovno;
WORD e_res[4];
WORD e_oemid;
WORD e_oeminfo;
WORD e_res2[10];
LONG e_lfanew;
} IMAGE_DOS_HEADER,*PIMAGE_DOS_HEADER;
#pragma pack(pop)
#pragma pack(push,4)
typedef struct _IMAGE_FILE_HEADER
{
WORD Machine;
WORD NumberOfSections;
DWORD TimeDateStamp;
DWORD PointerToSymbolTable;
DWORD NumberOfSymbols;
WORD SizeOfOptionalHeader;
WORD Characteristics;
} IMAGE_FILE_HEADER, *PIMAGE_FILE_HEADER;
typedef struct _IMAGE_DATA_DIRECTORY {
DWORD VirtualAddress;
DWORD Size;
} IMAGE_DATA_DIRECTORY,*PIMAGE_DATA_DIRECTORY;
#define IMAGE_NUMBEROF_DIRECTORY_ENTRIES 16
typedef struct _IMAGE_OPTIONAL_HEADER {
WORD Magic;
BYTE MajorLinkerVersion;
BYTE MinorLinkerVersion;
DWORD SizeOfCode;
DWORD SizeOfInitializedData;
DWORD SizeOfUninitializedData;
DWORD AddressOfEntryPoint;
DWORD BaseOfCode;
DWORD BaseOfData;
DWORD ImageBase;
DWORD SectionAlignment;
DWORD FileAlignment;
WORD MajorOperatingSystemVersion;
WORD MinorOperatingSystemVersion;
WORD MajorImageVersion;
WORD MinorImageVersion;
WORD MajorSubsystemVersion;
WORD MinorSubsystemVersion;
DWORD Win32VersionValue;
DWORD SizeOfImage;
DWORD SizeOfHeaders;
DWORD CheckSum;
WORD Subsystem;
WORD DllCharacteristics;
DWORD SizeOfStackReserve;
DWORD SizeOfStackCommit;
DWORD SizeOfHeapReserve;
DWORD SizeOfHeapCommit;
DWORD LoaderFlags;
DWORD NumberOfRvaAndSizes;
IMAGE_DATA_DIRECTORY DataDirectory[IMAGE_NUMBEROF_DIRECTORY_ENTRIES];
} IMAGE_OPTIONAL_HEADER,*PIMAGE_OPTIONAL_HEADER;
#pragma pack(pop)
#pragma pack(push,4)
typedef struct _IMAGE_NT_HEADERS
{
DWORD Signature;
IMAGE_FILE_HEADER FileHeader;
IMAGE_OPTIONAL_HEADER OptionalHeader;
} IMAGE_NT_HEADERS32,*PIMAGE_NT_HEADERS32;
#define IMAGE_SIZEOF_SHORT_NAME 8
typedef struct _IMAGE_SECTION_HEADER
{
BYTE Name[IMAGE_SIZEOF_SHORT_NAME];
union
{
DWORD PhysicalAddress;
DWORD VirtualSize;
} Misc;
DWORD VirtualAddress;
DWORD SizeOfRawData;
DWORD PointerToRawData;
DWORD PointerToRelocations;
DWORD PointerToLinenumbers;
WORD NumberOfRelocations;
WORD NumberOfLinenumbers;
DWORD Characteristics;
} IMAGE_SECTION_HEADER,*PIMAGE_SECTION_HEADER;
#pragma pack(pop)
#pragma pack(push,4)
typedef struct _IMAGE_BASE_RELOCATION {
DWORD VirtualAddress;
DWORD SizeOfBlock;
} IMAGE_BASE_RELOCATION,*PIMAGE_BASE_RELOCATION;
#pragma pack(pop)
typedef struct _IMAGE_IMPORT_DESCRIPTOR
{
union
{
DWORD Characteristics;
DWORD OriginalFirstThunk;
};
DWORD TimeDateStamp;
DWORD ForwarderChain;
DWORD Name;
DWORD FirstThunk;
} IMAGE_IMPORT_DESCRIPTOR,*PIMAGE_IMPORT_DESCRIPTOR;
typedef struct _IMAGE_THUNK_DATA32
{
union
{
DWORD ForwarderString;
DWORD Function;
DWORD Ordinal;
DWORD AddressOfData;
} u1;
} IMAGE_THUNK_DATA32,*PIMAGE_THUNK_DATA32;
typedef struct _IMAGE_IMPORT_BY_NAME
{
WORD Hint;
BYTE Name[1];
} IMAGE_IMPORT_BY_NAME,*PIMAGE_IMPORT_BY_NAME;
#define IMAGE_ORDINAL_FLAG 0x80000000
typedef struct _IMAGE_EXPORT_DIRECTORY {
DWORD Characteristics;
DWORD TimeDateStamp;
WORD MajorVersion;
WORD MinorVersion;
DWORD Name;
DWORD Base;
DWORD NumberOfFunctions;
DWORD NumberOfNames;
DWORD AddressOfFunctions;
DWORD AddressOfNames;
DWORD AddressOfNameOrdinals;
} IMAGE_EXPORT_DIRECTORY,*PIMAGE_EXPORT_DIRECTORY;
//extern IMAGE_EXPORT_DIRECTORY kernel_exports;
#define MakePtr( cast, ptr, addValue ) (cast)( (addr_t)(ptr) + (addValue) )
typedef struct
{
addr_t base;
addr_t frame;
md_t *md;
IMAGE_OPTIONAL_HEADER *opthdr;
}dll_t;
static inline bool IsPowerOf2(u32_t val)
{
if(val == 0)
return false;
return (val & (val - 1)) == 0;
}
static inline void sec_copy(void *dst, const void *src, size_t len)
{
u32_t tmp;
__asm__ __volatile__ (
"shrl $2, %%ecx \n\t"
"rep movsl"
:"=c"(tmp),"=S"(tmp),"=D"(tmp)
:"c"(len),"S"(src),"D"(dst)
:"cc");
};
static inline void sec_clear(void *dst, size_t len)
{
u32_t tmp;
__asm__ __volatile__ (
"xorl %%eax, %%eax \n\t"
"rep stosb"
:"=c"(tmp),"=D"(tmp)
:"c"(len),"D"(dst)
:"eax","cc");
};
int __stdcall strncmp(const char *s1, const char *s2, size_t n);
void __export create_image(void *img_base, void *image) asm ("CreateImage");
md_t* __fastcall load_image(const char *path);
void* __fastcall load_pe(const char *path)
{
md_t *md;
md = load_image(path);
if( md )
return (void*)md->base;
return NULL;
};
typedef struct
{
char srv_name[16]; // ASCIIZ string
u32_t magic; // +0x10 'SRV '
size_t size; // +0x14 size of structure SRV
void *fd; // +0x18 next SRV descriptor
void *bk; // +0x1C prev SRV descriptor
addr_t base; // +0x20 service base address
addr_t entry; // +0x24 service START function
void *srv_proc; // +0x28 main service handler
}srv_t;
typedef srv_t* __stdcall drv_entry_t(int);
srv_t* __fastcall load_pe_driver(const char *path)
{
PIMAGE_DOS_HEADER dos;
PIMAGE_NT_HEADERS32 nt;
drv_entry_t *drv_entry;
md_t *md;
srv_t *srv;
md = load_image(path);
if( ! md )
return 0;
dos = (PIMAGE_DOS_HEADER)md->base;
nt = MakePtr( PIMAGE_NT_HEADERS32, dos, dos->e_lfanew);
drv_entry = MakePtr(drv_entry_t*, md->base,
nt->OptionalHeader.AddressOfEntryPoint);
srv = drv_entry(1);
if(srv != NULL)
srv->entry = nt->OptionalHeader.AddressOfEntryPoint + md->base;
return srv;
}
md_t* __fastcall load_image(const char *path)
{
PIMAGE_DOS_HEADER dos;
PIMAGE_NT_HEADERS32 nt;
md_t *img_md;
size_t img_size;
void *img_base;
count_t img_pages;
size_t raw_size = 0;
void *raw;
// void *image;
DBG("load file %s\n", path);
raw = load_file(path, &raw_size);
DBG("raw = %x\n\n", raw);
dos = (PIMAGE_DOS_HEADER)raw;
if( !raw || raw_size < sizeof(IMAGE_DOS_HEADER) )
return NULL;
if( dos->e_magic != IMAGE_DOS_SIGNATURE || dos->e_lfanew <= 0)
return NULL;
nt = MakePtr( PIMAGE_NT_HEADERS32, dos, dos->e_lfanew);
if( (addr_t)nt < (addr_t)raw)
return NULL;
if(nt->Signature != IMAGE_NT_SIGNATURE)
return NULL;
if(nt->OptionalHeader.Magic != IMAGE_NT_OPTIONAL_HDR32_MAGIC)
return NULL;
if(nt->OptionalHeader.SectionAlignment < PAGE_SIZE)
{
if(nt->OptionalHeader.FileAlignment != nt->OptionalHeader.SectionAlignment)
return NULL;
}
else if(nt->OptionalHeader.SectionAlignment < nt->OptionalHeader.FileAlignment)
return NULL;
if(!IsPowerOf2(nt->OptionalHeader.SectionAlignment) ||
!IsPowerOf2(nt->OptionalHeader.FileAlignment))
return NULL;
if(nt->FileHeader.NumberOfSections > 96)
return NULL;
img_size = nt->OptionalHeader.SizeOfImage;
// img_pages = img_size / PAGE_SIZE;
img_md = md_alloc(img_size, PG_SW);
if( !img_md)
{
mem_free(raw);
return NULL;
};
img_base = (void*)img_md->base;
create_image(img_base, raw);
mem_free(raw);
// dos = (PIMAGE_DOS_HEADER)img_base;
// nt = MakePtr( PIMAGE_NT_HEADERS32, dos, dos->e_lfanew);
return img_md;
};
/*
addr_t get_proc_addr(addr_t module, char *name)
{
PIMAGE_DOS_HEADER expdos;
PIMAGE_NT_HEADERS32 expnt;
PIMAGE_EXPORT_DIRECTORY exp;
u32_t *functions;
char **funcname;
int ind;
expdos = (PIMAGE_DOS_HEADER)module;
expnt = MakePtr( PIMAGE_NT_HEADERS32, expdos, expdos->e_lfanew);
exp = MakePtr(PIMAGE_EXPORT_DIRECTORY,module,
expnt->OptionalHeader.DataDirectory[0].VirtualAddress);
functions = MakePtr(DWORD*,exp->AddressOfFunctions,module);
funcname = MakePtr(char**,exp->AddressOfNames,module);
for(ind=0; *funcname;funcname++,ind++)
{
if(!strcmp(name,MakePtr(char*,*funcname,module)))
return functions[ind] + module;
};
return -1;
};
*/
void create_image(void *img_base, void *image)
{
PIMAGE_DOS_HEADER dos;
PIMAGE_NT_HEADERS32 nt;
PIMAGE_SECTION_HEADER img_sec;
u32_t sec_align;
int i;
/* assumed that image is valid */
dos = (PIMAGE_DOS_HEADER)image;
nt = MakePtr( PIMAGE_NT_HEADERS32, dos, dos->e_lfanew);
sec_copy(img_base,image,nt->OptionalHeader.SizeOfHeaders);
img_sec = MakePtr(PIMAGE_SECTION_HEADER,nt,sizeof(IMAGE_NT_HEADERS32));
sec_align = nt->OptionalHeader.SectionAlignment;
for(i=0; i< nt->FileHeader.NumberOfSections; i++)
{
char *src_ptr;
char *dest_ptr;
size_t sec_size;
src_ptr = MakePtr(char*, image, img_sec->PointerToRawData);
dest_ptr = MakePtr(char*,img_base, img_sec->VirtualAddress);
if(img_sec->SizeOfRawData)
sec_copy(dest_ptr, src_ptr, img_sec->SizeOfRawData);
sec_size = (img_sec->Misc.VirtualSize + sec_align -1) & -sec_align;
if(sec_size > img_sec->SizeOfRawData)
sec_clear(dest_ptr + img_sec->SizeOfRawData,
sec_size - img_sec->SizeOfRawData);
img_sec++;
}
if(nt->OptionalHeader.DataDirectory[5].Size)
{
PIMAGE_BASE_RELOCATION reloc;
/* FIXME addr_t */
u32_t delta = (u32_t)img_base - nt->OptionalHeader.ImageBase;
reloc = MakePtr(PIMAGE_BASE_RELOCATION, img_base,
nt->OptionalHeader.DataDirectory[5].VirtualAddress);
while ( reloc->SizeOfBlock != 0 )
{
u32_t cnt;
u16_t *entry;
u16_t reltype;
u32_t offs;
cnt = (reloc->SizeOfBlock - sizeof(*reloc))/sizeof(u16_t);
entry = MakePtr( u16_t*, reloc, sizeof(*reloc) );
for ( i=0; i < cnt; i++ )
{
u16_t *p16;
u32_t *p32;
reltype = (*entry & 0xF000) >> 12;
offs = (*entry & 0x0FFF) + reloc->VirtualAddress;
switch(reltype)
{
case 1:
p16 = MakePtr(u16_t*, img_base, offs);
*p16+= (u16_t)(delta>>16);
break;
case 2:
p16 = MakePtr(u16_t*, img_base, offs);
*p16+= (u16_t)delta;
break;
case 3:
p32 = MakePtr(u32_t*, img_base, offs);
*p32+= delta;
}
entry++;
}
reloc = MakePtr(PIMAGE_BASE_RELOCATION, reloc,reloc->SizeOfBlock);
}
};
if(nt->OptionalHeader.DataDirectory[1].Size)
{
PIMAGE_IMPORT_DESCRIPTOR imp;
int warn = 0;
imp = MakePtr(PIMAGE_IMPORT_DESCRIPTOR, img_base,
nt->OptionalHeader.DataDirectory[1].VirtualAddress);
while ( 1 )
{
PIMAGE_THUNK_DATA32 thunk;
PIMAGE_DOS_HEADER expdos;
PIMAGE_NT_HEADERS32 expnt;
PIMAGE_EXPORT_DIRECTORY exp;
u32_t *iat;
char *libname;
addr_t *functions;
u16_t *ordinals;
char **funcname;
if ( (imp->TimeDateStamp==0 ) && (imp->Name==0) )
break;
libname=MakePtr(char*,imp->Name, img_base);
DBG("import from %s\n",libname);
expdos = (PIMAGE_DOS_HEADER)IMAGE_BASE;
expnt = MakePtr( PIMAGE_NT_HEADERS32, expdos, expdos->e_lfanew);
exp = MakePtr(PIMAGE_EXPORT_DIRECTORY,LOAD_BASE,
expnt->OptionalHeader.DataDirectory[0].VirtualAddress);
functions = MakePtr(DWORD*,exp->AddressOfFunctions,LOAD_BASE);
ordinals = MakePtr(WORD*, exp->AddressOfNameOrdinals,LOAD_BASE);
funcname = MakePtr(char**, exp->AddressOfNames,LOAD_BASE);
thunk = MakePtr(PIMAGE_THUNK_DATA32,
imp->Characteristics, img_base);
iat= MakePtr(DWORD*,imp->FirstThunk, img_base);
while ( 1 ) // Loop forever (or until we break out)
{
PIMAGE_IMPORT_BY_NAME ord;
addr_t addr;
if ( thunk->u1.AddressOfData == 0 )
break;
if ( thunk->u1.Ordinal & IMAGE_ORDINAL_FLAG )
{
// printf(" %4u\n", thunk->u1.Ordinal & 0xFFFF);
break;
}
else
{
ord = MakePtr(PIMAGE_IMPORT_BY_NAME,
thunk->u1.AddressOfData, img_base);
*iat=0;
DBG("import %s", ord->Name);
if(strncmp(ord->Name,
MakePtr(char*,funcname[ord->Hint],LOAD_BASE),32))
{
int ind;
char **names=funcname;
for(names = funcname,ind = 0;
ind < exp->NumberOfNames; names++,ind++)
{
if(!strncmp(ord->Name,MakePtr(char*,*names,LOAD_BASE),32))
{
DBG(" \tat %x\n", functions[ind] + LOAD_BASE);
*iat = functions[ind] + LOAD_BASE;
break;
};
};
if(ind == exp->NumberOfNames)
{
DBG(" unresolved import %s\n",ord->Name);
warn=1;
};
}
else
{
DBG(" \tat %x\n", functions[ord->Hint] + LOAD_BASE);
*iat = functions[ord->Hint] + LOAD_BASE;
};
};
thunk++; // Advance to next thunk
iat++;
}
imp++; // advance to next IMAGE_IMPORT_DESCRIPTOR
};
};
DBG("\ncreate pe base %x, size %x, %d sections\n\n",img_base,
nt->OptionalHeader.SizeOfImage, nt->FileHeader.NumberOfSections);
};
/*
u32 map_PE(u32 base, void *image)
{
PIMAGE_DOS_HEADER dos;
PIMAGE_NT_HEADERS32 nt;
PIMAGE_SECTION_HEADER sec;
int i;
int pages;
dos = (PIMAGE_DOS_HEADER)image;
nt = MakePtr( PIMAGE_NT_HEADERS32, dos, dos->e_lfanew);
img_size = nt->OptionalHeader.SizeOfImage;
img_pages = img_size / PAGE_SIZE;
img_md = md_alloc(img_size, PG_SW);
if( !img_md)
return NULL;
scopy(base,(u32)image,nt->OptionalHeader.SizeOfHeaders);
sec = MakePtr(PIMAGE_SECTION_HEADER,nt,sizeof(IMAGE_NT_HEADERS32));
if(nt->OptionalHeader.DataDirectory[1].Size)
{
PIMAGE_IMPORT_DESCRIPTOR imp;
imp = MakePtr(PIMAGE_IMPORT_DESCRIPTOR,base,
nt->OptionalHeader.DataDirectory[1].VirtualAddress);
while ( 1 )
{
PIMAGE_THUNK_DATA32 thunk;
u32 *iat;
char *libname;
if ( (imp->TimeDateStamp==0 ) && (imp->Name==0) )
break;
thunk = MakePtr(PIMAGE_THUNK_DATA32,
imp->Characteristics, base);
iat= MakePtr(DWORD*,imp->FirstThunk, base);
while ( 1 ) // Loop forever (or until we break out)
{
PIMAGE_IMPORT_BY_NAME ord;
u32 addr;
if ( thunk->u1.AddressOfData == 0 )
break;
if ( thunk->u1.Ordinal & IMAGE_ORDINAL_FLAG )
{
// printf(" %4u\n", thunk->u1.Ordinal & 0xFFFF);
break;
}
else
{
PKERNEL_EXPORT exp;
exp = kernel_export;
ord = MakePtr(PIMAGE_IMPORT_BY_NAME,
thunk->u1.AddressOfData,base);
*iat=-1;
do
{
if(!strncmp(ord->Name,exp->name,16))
{
*iat = exp->address;
break;
}
exp++;
} while(exp->name != 0);
};
thunk++; // Advance to next thunk
iat++;
}
imp++; // advance to next IMAGE_IMPORT_DESCRIPTOR
}
};
*/

10
kernel/branches/kolibri_pe/core/dll.inc
View File

@ -208,6 +208,7 @@ proc get_notify stdcall, p_ev:dword
endp endp
align 4 align 4
_PciRead32:
proc pci_read32 stdcall, bus:dword, devfn:dword, reg:dword proc pci_read32 stdcall, bus:dword, devfn:dword, reg:dword
push ebx push ebx
xor eax, eax xor eax, eax
@ -222,6 +223,7 @@ proc pci_read32 stdcall, bus:dword, devfn:dword, reg:dword
endp endp
align 4 align 4
_PciRead16:
proc pci_read16 stdcall, bus:dword, devfn:dword, reg:dword proc pci_read16 stdcall, bus:dword, devfn:dword, reg:dword
push ebx push ebx
xor eax, eax xor eax, eax
@ -236,6 +238,7 @@ proc pci_read16 stdcall, bus:dword, devfn:dword, reg:dword
endp endp
align 4 align 4
_PciRead8:
proc pci_read8 stdcall, bus:dword, devfn:dword, reg:dword proc pci_read8 stdcall, bus:dword, devfn:dword, reg:dword
push ebx push ebx
xor eax, eax xor eax, eax
@ -250,6 +253,7 @@ proc pci_read8 stdcall, bus:dword, devfn:dword, reg:dword
endp endp
align 4 align 4
_PciWrite8:
proc pci_write8 stdcall, bus:dword, devfn:dword, reg:dword, val:dword proc pci_write8 stdcall, bus:dword, devfn:dword, reg:dword, val:dword
push ebx push ebx
xor eax, eax xor eax, eax
@ -265,6 +269,7 @@ proc pci_write8 stdcall, bus:dword, devfn:dword, reg:dword, val:dword
endp endp
align 4 align 4
_PciWrite16:
proc pci_write16 stdcall, bus:dword, devfn:dword, reg:dword, val:dword proc pci_write16 stdcall, bus:dword, devfn:dword, reg:dword, val:dword
push ebx push ebx
xor eax, eax xor eax, eax
@ -280,6 +285,7 @@ proc pci_write16 stdcall, bus:dword, devfn:dword, reg:dword, val:dword
endp endp
align 4 align 4
_PciWrite32:
proc pci_write32 stdcall, bus:dword, devfn:dword, reg:dword, val:dword proc pci_write32 stdcall, bus:dword, devfn:dword, reg:dword, val:dword
push ebx push ebx
xor eax, eax xor eax, eax
@ -387,6 +393,7 @@ proc get_service stdcall, sz_name:dword
endp endp
align 4 align 4
_RegService:
proc reg_service stdcall, name:dword, handler:dword proc reg_service stdcall, name:dword, handler:dword
push ebx push ebx
@ -562,6 +569,7 @@ endp
; loaded by the load_file() function ; loaded by the load_file() function
align 4 align 4
_LoadFile:
_load_file@4: _load_file@4:
proc load_file stdcall, file_name:dword proc load_file stdcall, file_name:dword
locals locals
@ -1110,6 +1118,7 @@ endp
; ebx= pid ; ebx= pid
align 4 align 4
_CreateObject:
create_kernel_object: create_kernel_object:
push ebx push ebx
@ -1138,6 +1147,7 @@ create_kernel_object:
; eax= object ; eax= object
align 4 align 4
_DestroyObject:
destroy_kernel_object: destroy_kernel_object:
pushfd pushfd

43
kernel/branches/kolibri_pe/core/export.asm Normal file
View File

@ -0,0 +1,43 @@
.file "export.asm"
.intel_syntax
.section .drectve
.ascii " -export:CreateImage"
.ascii " -export:LoadFile"
.ascii " -export:Kmalloc" #
.ascii " -export:Kfree" #
.ascii " -export:UserAlloc" # stdcall
.ascii " -export:UserFree" # stdcall
.ascii " -export:MapIoMem" # stdcall
.ascii " -export:GetPgAddr" # eax
.ascii " -export:CreateObject" #
.ascii " -export:DestroyObject" #
.ascii " -export:CreateRingBuffer" # stdcall
.ascii " -export:CommitPages" # eax, ebx, ecx
.ascii " -export:RegService" # stdcall
.ascii " -export:UnmapPages" # eax, ecx
.ascii " -export:SysMsgBoardStr" #
.ascii " -export:SetScreen" #
.ascii " -export:PciApi" #
.ascii " -export:PciRead8" # stdcall
.ascii " -export:PciRead16" # stdcall
.ascii " -export:PciRead32" # stdcall
.ascii " -export:PciWrite8" # stdcall
.ascii " -export:PciWrite16" # stdcall
.ascii " -export:PciWrite32" # stdcall
.ascii " -export:SelectHwCursor" # stdcall
.ascii " -export:SetHwCursor" # stdcall
.ascii " -export:HwCursorRestore" #
.ascii " -export:HwCursorCreate" #

1
kernel/branches/kolibri_pe/core/exports.inc
View File

@ -110,7 +110,6 @@ kernel_export:
dd szCommitPages , commit_pages ;not implemented dd szCommitPages , commit_pages ;not implemented
dd szReleasePages , release_pages dd szReleasePages , release_pages
dd szFreeKernelSpace , free_kernel_space ;stdcall
dd szMemAlloc , @mem_alloc@8 ;fastcall dd szMemAlloc , @mem_alloc@8 ;fastcall
dd szMemFree , @mem_free@4 ;fastcall dd szMemFree , @mem_free@4 ;fastcall
dd szUserAlloc , user_alloc ;stdcall dd szUserAlloc , user_alloc ;stdcall

8
kernel/branches/kolibri_pe/core/heap.inc
View File

@ -15,12 +15,6 @@ USED_BLOCK equ 8
DONT_FREE_BLOCK equ 10h DONT_FREE_BLOCK equ 10h
align 4
proc free_kernel_space stdcall uses ebx ecx edx esi edi, base:dword
ret
endp
;;;;;;;;;;;;;; USER ;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;; USER ;;;;;;;;;;;;;;;;;
@ -55,6 +49,7 @@ proc init_heap
endp endp
align 4 align 4
_UserAlloc:
proc user_alloc stdcall, alloc_size:dword proc user_alloc stdcall, alloc_size:dword
push ebx push ebx
@ -131,6 +126,7 @@ m_exit:
endp endp
align 4 align 4
_UserFree:
proc user_free stdcall, base:dword proc user_free stdcall, base:dword
push esi push esi

4
kernel/branches/kolibri_pe/core/malloc.inc
View File

@ -20,6 +20,9 @@ $Revision$
; esi= nb ; esi= nb
; ebx= idx ; ebx= idx
; ;
align 4
_Kmalloc:
malloc: malloc:
push esi push esi
@ -197,6 +200,7 @@ malloc:
; eax= mem ; eax= mem
align 4 align 4
_Kfree:
free: free:
push edi push edi
mov edi, eax mov edi, eax

16
kernel/branches/kolibri_pe/core/memory.inc
View File

@ -29,6 +29,8 @@ map_space: ;not implemented
ret ret
align 4
_MapIoMem:
proc map_io_mem stdcall, base:dword, size:dword, flags:dword proc map_io_mem stdcall, base:dword, size:dword, flags:dword
push edi push edi
@ -71,6 +73,7 @@ endp
; ecx= count ; ecx= count
align 4 align 4
_CommitPages:
commit_pages: commit_pages:
push edi push edi
test ecx, ecx test ecx, ecx
@ -136,6 +139,7 @@ release_pages:
; ecx= count ; ecx= count
align 4 align 4
_UnmapPages:
unmap_pages: unmap_pages:
push edi push edi
@ -362,6 +366,7 @@ update_mem_size:
; eax= phisical page address ; eax= phisical page address
align 4 align 4
_GetPgAddr:
get_pg_addr: get_pg_addr:
shr eax, 12 shr eax, 12
mov eax, [page_tabs+eax*4] mov eax, [page_tabs+eax*4]
@ -860,10 +865,11 @@ proc sys_ipc_send stdcall, PID:dword, msg_addr:dword, msg_size:dword
.buffer_overflow: .buffer_overflow:
push 3 push 3
.ret: .ret:
mov eax, [used_buf] mov ecx, [used_buf]
cmp eax, [ipc_tmp] cmp ecx, [ipc_tmp]
jz @f jz @f
stdcall free_kernel_space,eax
call @mem_free@4
@@: @@:
pop eax pop eax
popf popf
@ -1105,6 +1111,7 @@ proc stall stdcall, delay:dword
endp endp
align 4 align 4
_CreateRingBuffer:
proc create_ring_buffer stdcall, size:dword, flags:dword proc create_ring_buffer stdcall, size:dword, flags:dword
locals locals
buf_ptr dd ? buf_ptr dd ?
@ -1151,7 +1158,8 @@ proc create_ring_buffer stdcall, size:dword, flags:dword
pop ebx pop ebx
ret ret
.mm_fail: .mm_fail:
;stdcall free_kernel_space, [buf_ptr] mov ecx, [buf_ptr]
call @mem_free@4
pop ebx pop ebx
xor eax, eax xor eax, eax
.fail: .fail:

7
kernel/branches/kolibri_pe/data32.inc
View File

@ -359,9 +359,16 @@ srv.bk rd 1
scr_width rd 1 scr_width rd 1
scr_height rd 1 scr_height rd 1
_HwCursorCreate:
create_cursor rd 1 create_cursor rd 1
_SelectHwCursor:
select_hw_cursor rd 1 select_hw_cursor rd 1
_SetHwCursor:
set_hw_cursor rd 1 set_hw_cursor rd 1
_HwCursorRestore:
hw_restore rd 1 hw_restore rd 1
def_cursor rd 1 def_cursor rd 1

3
kernel/branches/kolibri_pe/include/core.h
View File

@ -1,6 +1,7 @@
#define OS_BASE 0xE0000000 #define OS_BASE 0xE0000000
#define IMAGE_BASE 0xE0100000
#define LOAD_BASE 0x00100000
void printf (const char *format, ...); void printf (const char *format, ...);

10
kernel/branches/kolibri_pe/include/mm.h
View File

@ -83,7 +83,11 @@ void __fastcall core_free(addr_t frame);
pfn_t alloc_page() __attribute__ ((deprecated)); pfn_t alloc_page() __attribute__ ((deprecated));
md_t* __fastcall md_alloc(size_t size, u32_t flags); #define __export __attribute__ ((dllexport))
void* __fastcall mem_alloc(size_t size, u32_t flags);
void __fastcall mem_free(void *mem);
md_t* __fastcall md_alloc(size_t size, u32_t flags) ;
void* __fastcall __export mem_alloc(size_t size, u32_t flags) asm ("MemAlloc");
void __fastcall __export mem_free(void *mem) asm ("MemFree");

49
kernel/branches/kolibri_pe/kernel.asm
View File

@ -131,10 +131,44 @@ public _rd_root_end
public _load_file@4 public _load_file@4
public _kernel_exports
public _strncmp@12 public _strncmp@12
public _LoadFile ; stdcall export
public _CreateObject ; export
public _DestroyObject ; export
public _CreateRingBuffer ; stdcall export
public _CommitPages ; export
public _GetPgAddr ; export
public _MapIoMem ; stdcall export
public _UnmapPages ; export
public _Kmalloc ; export
public _Kfree ; export
public _UserAlloc ; stdcall export
public _UserFree ; stdcall export
public _RegService ; stdcall export
public _SysMsgBoardStr ; export
public _SetScreen ; export FIXME make fastcall
public _PciApi ; export
public _PciRead8 ; stdcall export
public _PciRead16 ; stdcall export
public _PciRead32 ; stdcall export
public _PciWrite8 ; stdcall export
public _PciWrite16 ; stdcall export
public _PciWrite32 ; stdcall export
public _SelectHwCursor ; stdcall export
public _SetHwCursor ; stdcall export
public _HwCursorRestore ; export
public _HwCursorCreate ; export
extrn __edata extrn __edata
extrn _16bit_start extrn _16bit_start
@ -152,8 +186,11 @@ extrn @core_free@4
extrn @init_heap@8 extrn @init_heap@8
extrn @find_large_md@4 extrn @find_large_md@4
extrn @mem_alloc@8 extrn _MemAlloc
extrn @mem_free@4 extrn _MemFree
@mem_alloc@8 equ _MemAlloc
@mem_free@4 equ _MemFree
extrn @load_pe@4 extrn @load_pe@4
extrn @load_pe_driver@4 extrn @load_pe_driver@4
@ -4545,6 +4582,8 @@ pic_delay:
pdl1: ret pdl1: ret
align 4
_SysMsgBoardStr:
sys_msg_board_str: sys_msg_board_str:
pushad pushad
@ -5060,7 +5099,9 @@ read_from_hd: ; Read from hd - fn not in use
paleholder: paleholder:
ret ret
align 4 align 4
_SetScreen:
set_screen: set_screen:
cmp eax, [Screen_Max_X] cmp eax, [Screen_Max_X]
jne .set jne .set

1
kernel/branches/kolibri_pe/kernel32.inc
View File

@ -182,7 +182,6 @@ include "core/heap.inc" ; kernel and app heap
include "core/malloc.inc" ; small kernel heap include "core/malloc.inc" ; small kernel heap
include "core/taskman.inc" include "core/taskman.inc"
include "core/dll.inc" include "core/dll.inc"
include "core/peload.inc" ;
include "core/exports.inc" include "core/exports.inc"
include "core/string.inc" include "core/string.inc"
include "core/v86.inc" ; virtual-8086 manager include "core/v86.inc" ; virtual-8086 manager

11
kernel/branches/kolibri_pe/ld.x
View File

@ -20,6 +20,14 @@ SECTIONS
{ {
*(.flat) *(.text) *(.rdata) *(.data) *(.flat) *(.text) *(.rdata) *(.data)
} }
.edata ALIGN(32):
{
*(.edata)
_code_end = .;
. = ALIGN(4096);
}
__edata = . - 0xE0000000; __edata = . - 0xE0000000;
.bss ALIGN(4096) : .bss ALIGN(4096) :
@ -28,6 +36,8 @@ SECTIONS
} }
__kernel_end = . - 0xE0000000; __kernel_end = . - 0xE0000000;
/DISCARD/ : /DISCARD/ :
{ {
*(.debug$S) *(.debug$S)
@ -35,7 +45,6 @@ SECTIONS
*(.debug$F) *(.debug$F)
*(.drectve) *(.drectve)
*(.reloc) *(.reloc)
*(.edata)
} }
} }

13
kernel/branches/kolibri_pe/makefile
View File

@ -35,12 +35,6 @@ PE_SRC:= \
boot/boot.asm \ boot/boot.asm \
boot/start.asm boot/start.asm
#include <types.h>
#include <core.h>
#include <spinlock.h>
#include <link.h>
#include <mm.h>
#include <slab.h>
H_SRC:= \ H_SRC:= \
include/types.h \ include/types.h \
@ -60,8 +54,8 @@ all: kernel.gz
kernel.gz :kernel.mnt kernel.gz :kernel.mnt
7z a -tgzip kernel.gz kernel.mnt 7z a -tgzip kernel.gz kernel.mnt
kernel.mnt: kernel.obj $(PE_OBJS) Makefile ld.x kernel.mnt: kernel.obj bin/export.obj $(PE_OBJS) Makefile ld.x
ld $(LDFLAGS) -T ld.x -o $@ kernel.obj $(PE_OBJS) ld $(LDFLAGS) -T ld.x -o $@ kernel.obj bin/export.obj $(PE_OBJS)
bin/%.obj : core/%.c $(H_SRC) Makefile bin/%.obj : core/%.c $(H_SRC) Makefile
$(CC) $(CFLAGS) -o $@ $< $(CC) $(CFLAGS) -o $@ $<
@ -69,6 +63,9 @@ bin/%.obj : core/%.c $(H_SRC) Makefile
bin/%.obj: %.asm bin/%.obj: %.asm
$(FASM) $< $@ $(FASM) $< $@
bin/export.obj: core/export.asm
as -o $@ $<
kernel.obj: $(KERNEL_SRC) kernel.obj: $(KERNEL_SRC)
$(FASM) kernel.asm $(FASM) kernel.asm