Subversion Repositories Kolibri OS

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;;                                                              ;;

;; Copyright (C) KolibriOS team 2004-2021. All rights reserved. ;;

;;  Distributed under terms of the GNU General Public License.  ;;

;;                                                              ;;

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

$Revision: 9048 $

GREEDY_KERNEL  = 0

struct  APP_HEADER_00_

        banner          dq ?

        version         dd ?    ;+8

        start           dd ?    ;+12

        i_end           dd ?    ;+16

        mem_size        dd ?    ;+20

        i_param         dd ?    ;+24

ends

struct  APP_HEADER_01_

        banner          dq ?

        version         dd ?    ;+8

        start           dd ?    ;+12

        i_end           dd ?    ;+16

        mem_size        dd ?    ;+20

        stack_top       dd ?    ;+24

        i_param         dd ?    ;+28

        i_icon          dd ?    ;+32

ends

struct  APP_HDR

        cmdline         rd 1    ;0x00

        path            rd 1    ;0x04

        eip             rd 1    ;0x08

        esp             rd 1    ;0x0C

        _edata          rd 1    ;0x10

        _emem           rd 1    ;0x14

        img_base        rd 1    ;0x18

        img_size        rd 1

        filename_size   rd 1

        cmdline_size    rd 1

        path_string     rd 1

        pedescr         rd 1

ends

; Pointer to this structure is passed as the third argument

; to usermode PE loader by the kernel.

struct kernel_init_data

version         dw      ?

flags           dw      ?

syscall_method  dd      ?

; either one of SYSCALL_METHOD_xxx or pointer to procedure

exe_base        dd      ?

stack_base      dd      ?

stack_size      dd      ?

exe_path        dd      ?

command_line    dd      ?

environment     dd      ?

ends

SYSCALL_METHOD_I40 = 1

SYSCALL_METHOD_SYSENTER = 2

SYSCALL_METHOD_SYSCALL = 3

macro _clear_ op

{

        mov     ecx, op/4

        xor     eax, eax

        cld

        rep stosd

}

align 4

_strnlen:

        mov     edx, ecx

        xor     eax, eax

        repne scasb

        jne     @F

        inc     ecx

@@:

        mov     eax, edx

        sub     eax, ecx

        retn

fs_execute_from_sysdir:

        xor     ebx, ebx

fs_execute_from_sysdir_param:

        stdcall kernel_alloc, maxPathLength

        push    eax ebx

        mov     esi, ebp

        mov     edi, eax

        xor     eax, eax

        call    getFullPath

        pop     ecx ebx

        xor     edx, edx

; @brief Executes a program

; @param edx Flags

; @param ecx Commandline

; @param ebx Absolute file path

; @param eax String length

; @returns Negated error code or new process number

proc fs_execute

    locals

        cmdline         rd  1

        flags           rd  1

        slot            rd  1  ; index of new thread slot

        slot_base       rd  1  ; base address of it

; app header data

        hdr_cmdline     rd  1

        hdr_path        rd  1

        hdr_eip         rd  1

        hdr_esp         rd  1

        hdr_edata       rd  1

        hdr_emem        rd  1

        file_base       rd  1

        file_size       rd  1

        filename_size   rd  1

        cmdline_size    rd  1

        path_string     rd  1

        pedescr         rd  1

    endl

        mov     [flags], edx

        mov     [cmdline], ecx

        mov     [path_string], ebx

        mov     [filename_size], eax

        mov     edi, -ERROR_FILE_NOT_FOUND

        test    eax, eax

        jz      .err_file

        stdcall load_file, ebx

        test    eax, eax

        jz      .err_file

        stdcall load_file_maybe_pe, [path_string]

        mov     [pedescr], esi

        mov     [file_base], eax

        mov     [file_size], ebx

        test    esi, esi

        jnz     .file_ok

        mov     edi, eax

        cmp     eax, -0x1000

        ja      .err_file

        lea     ebx, [hdr_cmdline]

        call    test_app_header  ; fill our app header data locals with values from header of given program (if its correct)

        mov     edi, -TASKMAN_ERROR_NOT_A_EXECUTABLE

        test    eax, eax

        jz      .err_hdr

.file_ok:

        call    lock_application_table

        call    alloc_thread_slot   ; create a slot for new thread

        mov     edi, -TASKMAN_ERROR_TOO_MANY_PROCESSES

        test    eax, eax

        jz      .err_0

        mov     [slot], eax

        shl     eax, 8

        lea     edi, [SLOT_BASE+eax]

        mov     [slot_base], edi

; clean extended information about process

        mov     ecx, sizeof.APPDATA/4

        xor     eax, eax

        cld

        rep stosd

; write application name ( APPDATA.appname )

        stdcall strrchr, [path_string], '/'

        lea     esi, [eax+1]    ; -> name without path

        mov     ecx, 11

        mov     edi, [slot_base]

@@:

        call    utf8to16

        call    uni2ansi_char

        cmp     al, '.'

        jz      @f

        test    al, al

        jz      @f

        stosb

        loop    @b

@@:

        mov     edi, [cmdline]

        xor     eax, eax

        test    edi, edi

        jz      @f

        mov     ecx, 65535

        call    _strnlen

        cmp     eax, 256

        jb      @f

; if cmdline length >= 256 then increase needed memory size by this length

        lea     ebx, [eax+1]

        add     [hdr_emem], ebx

@@:

        mov     [cmdline_size], eax

        xor     eax, eax

        cmp     [pedescr], eax

        jz      @f

        mov     [hdr_eip], eax

        mov     [hdr_esp], eax

        mov     [hdr_emem], eax

@@:

        stdcall create_process, [hdr_emem]  ; create a new process

        mov     edi, -TASKMAN_ERROR_OUT_OF_MEMORY

        test    eax, eax

        jz      .err_hdr

; add new process to the list

        mov     ebx, [sys_proc+LHEAD.prev]

        __list_add eax, ebx, sys_proc

; fill the structure fields:

        mov     ebx, [hdr_emem]

        mov     [eax+PROC.mem_used], ebx

; write that main thread of app belongs to new process

        mov     ebx, [slot_base]

        mov     [ebx+APPDATA.process], eax

; initialize the thread list of process: at this moment it consists only of one main thread

        lea     edx, [ebx+APPDATA.list]

        lea     ecx, [eax+PROC.thr_list]

        list_add_tail edx, ecx

; allocate space and copy app header data locals and cmdline string there, put pointer to exec_params of new thread

        mov     eax, [cmdline_size]

        add     eax, sizeof.APP_HDR

        stdcall kernel_alloc, eax

        mov     [ebx+APPDATA.exec_params], eax

        mov     edi, eax

        lea     esi, [hdr_cmdline]

        mov     ecx, sizeof.APP_HDR/4

        rep movsd

        mov     ecx, [cmdline_size]

        mov     esi, [cmdline]

        rep movsb

; set other parameters of application

        lea     eax, [hdr_cmdline]

        stdcall set_app_params , [slot], eax, [flags]

        mov     eax, [process_number]   ; return process number

        call    unlock_application_table

        ret

.err_0:

        mov     esi, [pedescr]

        test    esi, esi

        jz      @f

        call    dereference_pe

@@:

        call    unlock_application_table

.err_hdr:

        stdcall kernel_free, [file_base]

.err_file:

        stdcall kernel_free, [path_string]

        mov     eax, edi

        ret

endp

align 4

test_app_header:

       virtual at eax

         APP_HEADER_00 APP_HEADER_00_

       end virtual

       virtual at eax

         APP_HEADER_01 APP_HEADER_01_

       end virtual

        cmp     dword [eax], 'MENU'

        jne     .fail

        cmp     word [eax+4], 'ET'

        jne     .fail

        cmp     [eax+6], word '00'

        jne     .check_01_header

        mov     ecx, [APP_HEADER_00.start]

        mov     [ebx+APP_HDR.eip], ecx

        mov     edx, [APP_HEADER_00.mem_size]

        mov     [ebx+APP_HDR._emem], edx

        shr     edx, 1

        sub     edx, 0x10

        mov     [ebx+APP_HDR.esp], edx

        mov     ecx, [APP_HEADER_00.i_param]

        mov     [ebx+APP_HDR.cmdline], ecx

        mov     [ebx+APP_HDR.path], 0

        mov     edx, [APP_HEADER_00.i_end]

        mov     [ebx+APP_HDR._edata], edx

        ret

 .check_01_header:

        cmp     [eax+6], word '01'

        je      @f

        cmp     [eax+6], word '02'

        jne     .fail

@@:

        mov     ecx, [APP_HEADER_01.start]

        mov     [ebx+0x08], ecx

        mov     edx, [APP_HEADER_01.mem_size]

; \begin{diamond}[20.08.2006]

; sanity check (functions 19,58 load app_i_end bytes and that must

; fit in allocated memory to prevent kernel faults)

        cmp     edx, [APP_HEADER_01.i_end]

        jb      .fail

; \end{diamond}[20.08.2006]

        mov     [ebx+APP_HDR._emem], edx

        mov     ecx, [APP_HEADER_01.stack_top]

        mov     [ebx+APP_HDR.esp], ecx

        mov     edx, [APP_HEADER_01.i_param]

        mov     [ebx+APP_HDR.cmdline], edx

        mov     ecx, [APP_HEADER_01.i_icon]

        mov     [ebx+APP_HDR.path], ecx

        mov     edx, [APP_HEADER_01.i_end]

        mov     [ebx+APP_HDR._edata], edx

        ret

.fail:

        xor     eax, eax

        ret

align 4

alloc_thread_slot:

;input:

;  none

;result:

;  eax=[new_thread_slot]<>0 - ok

;      0 - failed.

;This function find least empty slot.

;It doesn't increase [thread_count]!

        mov     edx, thr_slot_map

        pushfd

        cli

.l1:

        bsf     eax, [edx]

        jnz     .found

        add     edx, 4

        cmp     edx, thr_slot_map+32

        jb      .l1

        popfd

        xor     eax, eax

        ret

.found:

        btr     [edx], eax

        sub     edx, thr_slot_map

        lea     eax, [eax+edx*8]

        popfd

        ret

align 4

proc create_process stdcall, app_size:dword

       locals

         process     dd ?

         app_tabs    dd ?

       endl

        push    ebx

        push    esi

        push    edi

        xor     eax, eax

        mov     [process], eax

        mov     eax, [app_size]

        add     eax, 0x3FFFFF

        shr     eax, 22

        mov     [app_tabs], eax

        stdcall kernel_alloc, 0x2000

        test    eax, eax

        jz      .fail

        mov     [process], eax

        lea     edi, [eax+PROC.heap_base]

        list_init eax

        add     eax, PROC.thr_list

        list_init eax

        add     eax, PROC.smap_list - PROC.thr_list

        list_init eax

        lea     ecx, [eax+PROC.heap_lock-PROC.smap_list]

        call    mutex_init

        mov     ecx, (PROC.ht_free-PROC.heap_base)/4

        xor     eax, eax

        cld

        rep stosd

        mov     [edi], dword (PROC.pdt_0 - PROC.htab)/4 - 3

        mov     [edi+4], dword 3           ;reserve handles for stdin stdout and stderr

        mov     ecx, (PROC.pdt_0 - PROC.htab)/4

        add     edi, 8

        inc     eax

@@:

        stosd

        inc     eax

        cmp     eax, ecx

        jbe     @B

        mov     eax, edi

        call    get_pg_addr

        mov     [edi-4096+PROC.pdt_0_phys], eax

        mov     ecx, (OS_BASE shr 20)/4

        xor     eax, eax

        rep stosd

        mov     ecx, (OS_BASE shr 20)/4

        mov     esi, sys_proc+PROC.pdt_0+(OS_BASE shr 20)

        rep movsd

        mov     eax, [edi-8192+PROC.pdt_0_phys]

        or      eax, PG_SWR

        mov     [edi-4096+(page_tabs shr 20)], eax

        lea     edx, [edi-4096]

        mov     esi, [app_tabs]

        test    esi, esi

        jz      .no_page_dirs

.alloc_page_dir:

        call    alloc_page

        test    eax, eax

        jz      .fail

        or      eax, PG_UWR

        mov     [edx], eax

        mov     edi, [tmp_task_ptab]

        stdcall map_page, edi, eax, PG_SWR

        mov     ecx, 1024

        xor     eax, eax

        rep stosd

        add     edx, 4

        dec     esi

        jnz     .alloc_page_dir

.no_page_dirs:

        stdcall map_page, [tmp_task_ptab], 0, PG_UNMAP

        mov     eax, [process]

        pop     edi

        pop     esi

        pop     ebx

        ret

.fail:

        mov     ecx, [process]

        jecxz   @F

        call    destroy_process

@@:

        xor     eax, eax

        pop     edi

        pop     esi

        pop     ebx

        ret

endp

align 4

proc destroy_page_table stdcall, pg_tab:dword

        push    esi

        mov     esi, [pg_tab]

        mov     ecx, 1024

.free:

        mov     eax, [esi]

        test    eax, 1

        jz      .next

        test    eax, 1 shl 9

        jnz     .next                     ;skip shared pages

        call    free_page

.next:

        add     esi, 4

        dec     ecx

        jnz     .free

        pop     esi

        ret

endp

align 4

destroy_process: ;fastcall ecx= ptr to process

        lea     eax, [ecx+PROC.thr_list]

        cmp     eax, [eax+LHEAD.next]

        jne     .exit

align 4

.internal:

        push    ecx

        mov     esi, ecx

        list_del esi

        lea     ebx, [esi+PROC.smap_list]

        mov     edi, [esi+PROC.smap_list+SMAP.fd]

.smap_list_destroy:

        cmp     edi, ebx

        jz      .smap_list_done

        push    [edi+SMAP.fd]

        stdcall destroy_smap, [esp+4]

        pop     edi

        jmp     .smap_list_destroy

.smap_list_done:

        mov     esi, [esp]

        add     esi, PROC.pdt_0

        mov     edi, (0x80000000 shr 20)/4

.destroy:

        mov     eax, [esi]

        test    eax, 1

        jz      .next

        and     eax, not 0xFFF

        stdcall map_page, [tmp_task_ptab], eax, PG_SWR

        stdcall destroy_page_table, [tmp_task_ptab]

        mov     eax, [esi]

        call    free_page

.next:

        add     esi, 4

        dec     edi

        jnz     .destroy

        call    kernel_free     ;ecx still in stack

        stdcall map_page, [tmp_task_ptab], 0, PG_UNMAP

.exit:

        ret

align 4

get_pid:

        mov     eax, [TASK_BASE]

        mov     eax, [eax+TASKDATA.pid]

        ret

pid_to_slot:

;Input:

;  eax - pid of process

;Output:

;  eax - slot of process or 0 if process don't exists

;Search process by PID.

        push    ebx

        push    ecx

        mov     ebx, [thread_count]

        shl     ebx, BSF sizeof.TASKDATA ; multiply by size

        ; add 2*32 cause:

        ; [TASK_TABLE; TASK_TABLE + 32) isnt a task actually

        ; skip first process in the task table

        mov     ecx, 2*32

.loop:

;ecx = offset of current process info entry

;ebx = maximum permitted offset

        cmp     [TASK_TABLE+ecx+TASKDATA.state], TSTATE_FREE

        jz      .endloop ;skip empty slots

        cmp     [TASK_TABLE+ecx+TASKDATA.pid], eax;check PID

        jz      .pid_found

.endloop:

        add     ecx, sizeof.TASKDATA

        cmp     ecx, ebx

        jle     .loop

        pop     ecx

        pop     ebx

        xor     eax, eax

        ret

.pid_found:

        shr     ecx, BSF sizeof.TASKDATA ; divide by size

        mov     eax, ecx ;convert offset to index of slot

        pop     ecx

        pop     ebx

        ret

align 4

proc read_process_memory

;Input:

;  eax - process slot

;  ecx - buffer address

;  edx - buffer size

;  esi - start address in other process

;Output:

;  eax - number of bytes read.

       locals

         slot   dd ?

         buff   dd ?

         r_count    dd ?

         offset dd ?

         tmp_r_cnt  dd ?

         mapped_size dd ?

       endl

        mov     [slot], eax

        mov     [buff], ecx

        and     [r_count], 0

        mov     [tmp_r_cnt], edx

        mov     [offset], esi

        pushad

        mov     ecx, proc_mem_mutex

        call    mutex_lock

.read_mem:

        mov     edx, [offset]

        mov     ebx, [tmp_r_cnt]

        mov     ecx, 0x400000

        and     edx, 0x3FFFFF

        sub     ecx, edx

        cmp     ecx, ebx

        jbe     @f

        mov     ecx, ebx

@@:

        cmp     ecx, 0x8000

        jna     @F

        mov     ecx, 0x8000

@@:

        mov     ebx, [offset]

        push    ecx

        stdcall map_memEx, [proc_mem_map], \

                [slot], ebx, ecx, PG_READ, [proc_mem_tab]

        mov     [mapped_size], eax

        pop     ecx

        mov     esi, [offset]

        and     esi, 0xfff

        sub     eax, esi

        jbe     .ret_unmap

        cmp     ecx, eax

        jbe     @f

        mov     ecx, eax

        mov     [tmp_r_cnt], eax

@@:

        add     esi, [proc_mem_map]

        mov     edi, [buff]

        push    ecx

        rep movsb

        stdcall unmap_memEx, [proc_mem_map], \

                [slot], ebx, [mapped_size], [proc_mem_tab]

        pop     ecx

        add     [r_count], ecx

        add     [offset], ecx

        sub     [tmp_r_cnt], ecx

        jnz     .read_mem

.ret:

        mov     ecx, proc_mem_mutex

        call    mutex_unlock

        popad

        mov     eax, [r_count]

        ret

.ret_unmap:

        stdcall unmap_memEx, [proc_mem_map], \

                [slot], ebx, [mapped_size], [proc_mem_tab]

        jmp     .ret

endp

align 4

proc write_process_memory

;Input:

;  eax - process slot

;  ecx - buffer address

;  edx - buffer size

;  esi - start address in other process

;Output:

;  eax - number of bytes written

       locals

         slot   dd ?

         buff   dd ?

         w_count    dd ?

         offset dd ?

         tmp_w_cnt  dd ?

         mapped_size dd ?

       endl

        mov     [slot], eax

        mov     [buff], ecx

        and     [w_count], 0

        mov     [tmp_w_cnt], edx

        mov     [offset], esi

        pushad

        mov     ecx, proc_mem_mutex

        call    mutex_lock

.write_mem:

        mov     edx, [offset]

        mov     ebx, [tmp_w_cnt]

        mov     ecx, 0x400000

        and     edx, 0x3FFFFF

        sub     ecx, edx

        cmp     ecx, ebx

        jbe     @f

        mov     ecx, ebx

@@:

        cmp     ecx, 0x8000

        jna     @F

        mov     ecx, 0x8000

@@:

        mov     ebx, [offset]

        push    ecx

        stdcall map_memEx, [proc_mem_map], \

                [slot], ebx, ecx, PG_SWR, [proc_mem_tab]

        mov     [mapped_size], eax

        pop     ecx

        mov     edi, [offset]

        and     edi, 0xfff

        sub     eax, edi

        jbe     .ret_unmap

        cmp     ecx, eax

        jbe     @f

        mov     ecx, eax

        mov     [tmp_w_cnt], eax

@@:

        add     edi, [proc_mem_map]

        mov     esi, [buff]

        push    ecx

        rep movsb

        stdcall unmap_memEx, [proc_mem_map], \

                [slot], ebx, [mapped_size], [proc_mem_tab]

        pop     ecx

        add     [w_count], ecx

        add     [offset], ecx

        sub     [tmp_w_cnt], ecx

        jnz     .write_mem

.ret:

        mov     ecx, proc_mem_mutex

        call    mutex_unlock

        popad

        mov     eax, [w_count]

        ret

.ret_unmap:

        stdcall unmap_memEx, [proc_mem_map], [slot], ebx, [mapped_size], [proc_mem_tab]

        jmp     .ret

endp

;ebx = 1 - kernel thread

;ecx=thread entry point

;edx=thread stack pointer

;creation flags  0x01 - debugged

;                0x02 - kernel

align 4

proc new_sys_threads

       locals

         slot          dd ?

         flags         dd ?

         app_cmdline   dd ? ;0x00

         app_path      dd ? ;0x04

         app_eip       dd ? ;0x08

         app_esp       dd ? ;0x0C

         app_mem       dd ? ;0x10

       endl

        shl     ebx, 1

        mov     [flags], ebx

        xor     eax, eax

        mov     [app_eip], ecx

        mov     [app_cmdline], eax

        mov     [app_esp], edx

        mov     [app_path], eax

        call    lock_application_table

        call    alloc_thread_slot

        test    eax, eax

        jz      .failed

        mov     [slot], eax

        mov     esi, [current_slot]

        mov     ebx, esi      ;ebx=esi - pointer to extended information about current thread

        mov     edi, eax

        shl     edi, 8

        add     edi, SLOT_BASE

        mov     edx, edi      ;edx=edi - pointer to extended infomation about new thread

        mov     ecx, sizeof.APPDATA/4

        xor     eax, eax

        cld

        rep stosd             ;clean extended information about new thread

        mov     esi, ebx

        mov     edi, edx

        mov     ecx, 11

        rep movsb             ;copy process name

        mov     eax, [ebx+APPDATA.tls_base]

        test    eax, eax

        jz      @F

        push    edx

        stdcall user_alloc, 4096

        pop     edx

        test    eax, eax

        jz      .failed1;eax=0

@@:

        mov     [edx+APPDATA.tls_base], eax

        mov     eax, [ebx+APPDATA.process]

        mov     [edx+APPDATA.process], eax

        lea     ebx, [edx+APPDATA.list]

        lea     ecx, [eax+PROC.thr_list]

        list_add_tail ebx, ecx               ;add thread to process child's list

        lea     eax, [app_cmdline]

        stdcall set_app_params , [slot], eax, [flags]

        mov     eax, [process_number]           ;set result

        call    unlock_application_table

        ret

.failed:

        xor     eax, eax

.failed1:

        call    unlock_application_table

        dec     eax     ;-1

        ret

endp

proc map_process_image stdcall, img_size:dword, file_base:dword, file_size:dword

        mov     edx, [img_size]

        mov     esi, [file_base]

        mov     ecx, [file_size]

        add     edx, 4095

        add     ecx, 4095

        shr     edx, 12        ; total pages

        shr     ecx, 12        ; image pages

        mov     edi, page_tabs

        shr     esi, 10

        add     esi, edi

.map_image:

        lodsd

        and     eax, -4096

        or      eax, PG_UWR

        stosd

        dec     edx

        loop    .map_image

        test    edx, edx

        jz      .done

.map_bss:

        call    alloc_page

        test    eax, eax

        jz      .fail

        or      eax, PG_UWR

        stosd

        dec     edx

        jnz     .map_bss

        mov     edi, [file_size]

        mov     ecx, [img_size]

        add     edi, 4095

        and     edi, -4096

        add     ecx, 4095

        and     ecx, -4096

        sub     ecx, edi

        shr     ecx, 2

        xor     eax, eax

        rep stosd

.done:

.fail:

        ret

endp

align 4

common_app_entry:

        mov     ebp, [current_slot]

        mov     ebp, [ebp+APPDATA.exec_params]

        test    ebp, ebp

        jz      .exit

; APPDATA.exec_params have first thread only,

; so second and next threads don't get here (they jump to .exit)

        cmp     [ebp+APP_HDR.pedescr], 0

        jz      .init_legacy_app

; init PE application

        mov     eax, [current_process]

        mov     [eax+PROC.mem_used], 0xF000 ; leave first 64K as unallocatable

        call    init_heap

        mov     eax, [current_process]

        mov     [eax+PROC.mem_used], 0

        stdcall map_pe_usermode, [ebp+APP_HDR.pedescr],\

                [ebp+APP_HDR.img_base], [ebp+APP_HDR.img_size]

        cmp     eax, -0x1000

        ja      .failed

        push    eax

        stdcall load_file_maybe_pe, pe_loader_usermode

        test    esi, esi

        jz      .pe_loader_notfound

        mov     edx, [esi+PEDESCR.entry]

        mov     [esp+4+20h], edx

        stdcall map_pe_usermode, esi, eax, ebx

        cmp     eax, -0x1000

        ja      .pe_loader_failed

        add     [esp+4+20h], eax

        push    eax

        mov     eax, [ebp+APP_HDR.filename_size]

        add     eax, [ebp+APP_HDR.cmdline_size]

        add     eax, sizeof.kernel_init_data + 2

        stdcall user_alloc, eax

        test    eax, eax

        jz      .failed

        mov     ebx, eax

        mov     dword [eax+kernel_init_data.version], 1 + (0 shl 16) ; version, flags

        mov     [eax+kernel_init_data.syscall_method], SYSCALL_METHOD_I40

        lea     edi, [eax+sizeof.kernel_init_data]

        mov     [eax+kernel_init_data.exe_path], edi

        mov     esi, [ebp+APP_HDR.path_string]

        mov     ecx, [ebp+APP_HDR.filename_size]

        rep movsb

        mov     byte [edi], 0

        inc     edi

        mov     [eax+kernel_init_data.command_line], edi

        lea     esi, [ebp+sizeof.APP_HDR]

        mov     ecx, [ebp+APP_HDR.cmdline_size]

        rep movsb

        mov     byte [edi], 0

        mov     ecx, [ebp+APP_HDR.pedescr]

        mov     ecx, [ecx+PEDESCR.stacksize]

        mov     [eax+kernel_init_data.stack_size], ecx

        stdcall user_alloc, ecx

        test    eax, eax

        jz      .failed

        mov     [ebx+kernel_init_data.stack_base], eax

        add     eax, [ebx+kernel_init_data.stack_size]

        sub     eax, 16

        pop     dword [eax+4]

        pop     [ebx+kernel_init_data.exe_base]

        mov     dword [eax+8], 1 ; DLL_PROCESS_ATTACH

        mov     dword [eax+12], ebx

        mov     [esp+2Ch], eax

        jmp     .common_tls

.pe_loader_notfound:

        cmp     eax, -0x1000

        ja      .pe_loader_failed

        stdcall kernel_free, eax

.pe_loader_failed:

        dbgstr 'Failed to load kolibri.dll'

.failed:

        stdcall kernel_free, [ebp+APP_HDR.path_string]

        jmp     sys_end

.init_legacy_app:

; init MENUETxx application

        stdcall map_process_image, [ebp+APP_HDR._emem],\

                [ebp+APP_HDR.img_base], [ebp+APP_HDR.img_size]

        mov     esi, [ebp+APP_HDR.path_string]

        mov     edi, [ebp+APP_HDR.path]

        mov     ecx, [ebp+APP_HDR.filename_size]

        cmp     ecx, 1023

        jc      @f

        mov     ecx, 1022

@@:

        push    esi

        test    edi, edi

        jz      @f

        stdcall is_region_userspace, edi, [ebp+APP_HDR.filename_size]

        jnz     @f

        mov     al, '/'

        stosb

        rep movsb

        mov     byte [edi], 0

@@:

        call    kernel_free

        mov     edi, [ebp+APP_HDR.cmdline]

        test    edi, edi

        jz      .check_tls_header

        lea     esi, [ebp+sizeof.APP_HDR]

        mov     ecx, [ebp+APP_HDR.cmdline_size]

        cmp     ecx, 256

        jb      .copy_cmdline

        mov     edi, [ebp+APP_HDR._emem]

        add     edi, 4095

        and     edi, -4096

        sub     edi, ecx

        dec     edi

        cmp     word [6], '00'

        jne     @f

        mov     [APP_HEADER_00_.i_param], edi

        jmp     .copy_cmdline

@@:

        mov     [APP_HEADER_01_.i_param], edi

.copy_cmdline:

        inc     ecx  ; keep in mind about 0 in the end

        stdcall is_region_userspace, edi, ecx

        jnz     .check_tls_header

        dec     ecx

        rep movsb

        mov     byte [edi], 0

.check_tls_header:

        cmp     word [6], '02'

        jne     .try_load_dll ;.common

        call    init_heap

.common_tls:

        stdcall user_alloc, 4096

        mov     edx, [current_slot]

        mov     [edx+APPDATA.tls_base], eax

        mov     [tls_data_l+2], ax

        shr     eax, 16

        mov     [tls_data_l+4], al

        mov     [tls_data_l+7], ah

        mov     dx, app_tls

        mov     fs, dx

; { Patch by Coldy, For DLL autoload

.try_load_dll:

; Test app header version

        mov     ecx, dword[ebp+APP_HDR.img_base]

        cmp     dword[ecx+8], 2

        jne     .common

;if APP_HEADER.version = 2 => load lib/dll.obj & change eip to APP_STARTUP_THUNK

        DEBUGF 1, 'K : App header version 2\n'

        stdcall load_library, dll_lib_path, 0

        cmp     eax, 0

        jne     @f

; Something went wrong (TODO: Next 2 line is code copy after .cleanup)

        stdcall free_kernel_space, [ebp+APP_HDR.img_base]

        stdcall kernel_free, ebp

        DEBUGF 1, 'K : DLL.OBJ not found! Terminate application!\n'

        mov     ebx, dll_error_msg

        mov     ebp, notifyapp

        call    fs_execute_from_sysdir_param

; Terminate process (TODO: Need jump to .cleanup after sys_end ?)

        call    sys_end

@@:

; Find APP_STARTUP_THUNK in DLL.OBJ

        sub     eax, 4

        mov     eax, [eax]

;.change_eip:

        mov     ecx, [current_slot]

        mov     ecx, [ecx+APPDATA.pl0_stack]

        mov     [ecx+REG_EIP], eax

; } End patch by Coldy, For DLL autoload

        mov     fs, dx

.common:

        stdcall free_kernel_space, [ebp+APP_HDR.img_base]

        stdcall kernel_free, ebp

        mov     ebx, [current_slot]

        cmp     [ebx+APPDATA.debugger_slot], 0

        je      .exit

        mov     eax, [TASK_BASE]

        mov     [eax+TASKDATA.state], TSTATE_RUN_SUSPENDED

        call    change_task

.exit:

        popad

        iretd

EFL_IF      = 0x0200

EFL_IOPL1   = 0x1000

EFL_IOPL2   = 0x2000

EFL_IOPL3   = 0x3000

align 4

proc set_app_params stdcall,slot:dword, params:dword, flags:dword

       locals

         pl0_stack dd ?

       endl

        mov     eax, [xsave_area_size]

        add     eax, RING0_STACK_SIZE

        stdcall kernel_alloc, eax

        mov     [pl0_stack], eax

        lea     edi, [eax+RING0_STACK_SIZE]

        mov     eax, [slot]

        mov     ebx, eax