WebSVN – Kolibri OS – Diff – /kernel/trunk/core/taskman.inc

 ;; Copyright (C) KolibriOS team 2004-2015. All rights reserved. ;;
 ;; Distributed under terms of the GNU General Public License    ;;
 ;;                                                              ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-$Revision: 6263 $
+$Revision: 6333 $
         stack_top       dd ?    ;+24
         i_param         dd ?    ;+28
         i_icon          dd ?    ;+32
 ends
-struct  APP_PARAMS
+struct  APP_HDR
-        app_cmdline     dd ?    ;0x00
+        cmdline         rd 1    ;0x00
-        app_path        dd ?    ;0x04
+        path            rd 1    ;0x04
-        app_eip         dd ?    ;0x08
+        eip             rd 1    ;0x08
+        esp             rd 1    ;0x0C
-        app_esp         dd ?    ;0x0C
+        _edata          rd 1    ;0x10
+        _emem           rd 1    ;0x14
+        img_base        rd 1    ;0x18
+        img_size        rd 1
+        filename_size   rd 1
-        app_mem         dd ?    ;0x10
+        cmdline_size    rd 1
 ends
 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
-        rep stosd
+        sub     eax, ecx
         retn
 fs_execute_from_sysdir:
-        xor     ebx, ebx
-fs_execute_from_sysdir_param:
+        xor     ebx, ebx
-        xor     edx, edx
+fs_execute_from_sysdir_param:
-        mov     esi, sysdir_path
-align 4
-proc fs_execute
+        xor     edx, edx
-;fn_read:dword, file_size:dword, cluster:dword
+align 4
-; ebx - cmdline
+proc fs_execute
-; edx - flags
-; ebp - full filename
-; [esp+4] = procedure DoRead, [esp+8] = filesize & [esp+12]... - arguments for it
-       locals
+; ebx - cmdline
-         cmdline_size  dd ? ; +0 ; cmdline -12
+; edx - flags
-         cmdline_adr   dd ? ; +4 ; cmdline -8
-         cmdline_flag  dd ? ; +8 ; cmdline -4
-         cmdline       rd 64    ;256/4
+; ebp - full filename
-         filename      rd 256   ;1024/4
-         flags         dd ?
-         save_proc     dd ?
-         slot          dd ?
-         slot_base     dd ?
-         file_base     dd ?
-         file_size     dd ?
-;         handle        dd ? ;temp. for default cursor handle for curr. thread
-                      ;app header data
-         hdr_cmdline   dd ? ;0x00
-         hdr_path      dd ? ;0x04
-         hdr_eip       dd ? ;0x08
-         hdr_esp       dd ? ;0x0C
-         hdr_mem       dd ? ;0x10
-         hdr_i_end     dd ? ;0x14
-       endl
-        pushad
-;        cmp     [SCR_MODE], word 0x13
-;        jbe     @f
-;        pushad
-;        stdcall set_cursor, [def_cursor_clock]
-;        mov     [handle], eax
-;        mov     [redrawmouse_unconditional], 1
+       locals
-;        call    wakeup_osloop
-;        popad
-;@@:
-        mov     [flags], edx
-; [ebp]  pointer to filename
-        lea     edi, [filename]
-        lea     ecx, [edi+1024]
-        mov     al, '/'
+         filename      rd 1
-        stosb
-@@:
-        cmp     edi, ecx
-        jae     .bigfilename
-        lodsb
-        stosb
-        test    al, al
-        jnz     @b
-        mov     esi, [ebp]
-        test    esi, esi
-        jz      .namecopied
-        mov     byte [edi-1], '/'
-@@:
-        cmp     edi, ecx
-        jae     .bigfilename
-        lodsb
+         cmdline       rd 1
+         flags         rd 1
-        stosb
+         slot          rd 1
+         slot_base     rd 1
+;app header data
+         hdr_cmdline   rd 1 ;0x00
+         hdr_path      rd 1 ;0x04
-        test    al, al
+         hdr_eip       rd 1 ;0x08
-        jnz     @b
-        jmp     .namecopied
-.bigfilename:
-        popad
+         hdr_esp       rd 1 ;0x0C
+         hdr_edata     rd 1 ;0x10
-        mov     eax, -ERROR_FILE_NOT_FOUND
+         hdr_emem      rd 1 ;0x14
-        jmp     .final
-.namecopied:
-        xor     eax, eax
-        mov     [cmdline_flag], eax
-        mov     [cmdline_adr], eax
-        mov     [cmdline_size], eax
-        mov     [cmdline], ebx
-        test    ebx, ebx
-        jz      .no_copy
-;--------------------------------------
-        pushad
-        pushfd
-        mov     esi, ebx
-        mov     ecx, 65536 ; 64 Kb max for ext.cmdline
-        cld
-@@:
-        dec     ecx
-        jz      .end_string
-        lodsb
-        test    al, al
-        jnz     @b
-.end_string:
-        mov     eax, 65536 ; 64 Kb max for ext.cmdline
-        sub     eax, ecx
-        mov     [cmdline_size], eax
-        cmp     eax, 255
-        ja      @f
-        popfd
-        popad
-        jmp     .old_copy
-@@:
-        xor     eax, eax
+         file_base     rd 1 ;0x18
-        dec     eax
-        mov     [cmdline_flag], eax
-        popfd
-        popad
-; get memory for the extended command line
-        stdcall kernel_alloc, [cmdline_size] ;eax
-        test    eax, eax
-        jz      .old_copy ; get memory failed
-        mov     [cmdline_adr], eax
-        pushad
-        pushfd
-        mov     esi, ebx
-        mov     edi, eax
-        mov     ecx, [cmdline_size]
-        cld
-        rep movsb
-        popfd
-        popad
-        jmp     .no_copy
+         file_size     rd 1 ;0x1c
-.old_copy:
+         filename_size rd 1 ;0x20
-; clear flag because old method with 256 bytes
-        xor     eax, eax
+         cmdline_size  rd 1 ;0x24
         mov     [cmdline_flag], eax
-;--------------------------------------
+       endl
         lea     eax, [cmdline]
         jz      .err_hdr
         call    lock_application_table
         call    alloc_thread_slot
+        call    alloc_thread_slot
-        test    eax, eax
+        mov     esi, -0x20 ; too many processes
-        mov     esi, -0x20 ; too many processes
+        test    eax, eax
-        jz      .err
+        jz      .err_0
         mov     [slot], eax
+        shl     eax, 8
+        lea     edi, [SLOT_BASE+eax]
-        shl     eax, 8
+        mov     [slot_base], edi
-        add     eax, SLOT_BASE
+;clean extended information about process
+        mov     ecx, 256/4
-        mov     [slot_base], eax
+        xor     eax, eax
-        mov     edi, eax
-       _clear_ 256     ;clean extended information about process
+        cld
         rep stosd
 ; write application name
-        lea     eax, [filename]
+; write application name
-        stdcall strrchr, eax, '/'  ; now eax points to name without path
+        stdcall strrchr, [filename], '/'  ; now eax points to name without path
         lea     esi, [eax+1]
         test    eax, eax
         jnz     @F
-        lea     esi, [filename]
+        mov     esi, [filename]
         jz      .copy_process_name_done
         test    al, al
         jz      .copy_process_name_done
         stosb
         loop    .copy_process_name_loop
 .copy_process_name_done:
+        mov     edi, [cmdline]
+        xor     eax, eax
+        test    edi, edi
+        jz      @F
+        mov     ecx, 65535
+        call    _strnlen
+        cmp     eax, 256
+        jb      @F
+        lea     ebx, [eax+1]
+        add     [hdr_emem], ebx
-        mov     ebx, [current_process]
+@@:
+        mov     [cmdline_size], eax
-        mov     [save_proc], ebx
         stdcall create_process, [hdr_emem]
         stdcall create_process, [hdr_mem], [file_base], [file_size]
         mov     esi, -30; no memory
         test    eax, eax
-        jz      .failed
+        jz      .err_hdr
         mov     ebx, [sys_proc+LHEAD.prev]
         __list_add eax, ebx, sys_proc
-        mov     ebx, [hdr_mem]
+        mov     ebx, [hdr_emem]
         mov     [eax+PROC.mem_used], ebx
         mov     ebx, [slot_base]
         mov     [ebx+APPDATA.process], eax
-        lea     edx, [ebx+APPDATA.list]
-        lea     ecx, [eax+PROC.thr_list]
-        list_add_tail edx, ecx
-        xor     edx, edx
-        cmp     word [6], '02'
-        jne     @f
+        lea     edx, [ebx+APPDATA.list]
+        lea     ecx, [eax+PROC.thr_list]
-        not     edx
+        list_add_tail edx, ecx
-@@:
+        mov     esi, sizeof.APP_HDR
+        add     esi, [cmdline_size]
-        mov     [ebx+APPDATA.tls_base], edx
+        mov     edi, [filename]
+        mov     ecx, 1023
-        mov     ecx, [hdr_mem]
+        call    _strnlen
-        mov     edi, [file_size]
+        add     esi, eax
-        add     edi, 4095
+        mov     [filename_size], eax
+        stdcall kernel_alloc, esi
+        mov     [ebx+APPDATA.exec_params], eax
+        mov     edi, eax
-        and     edi, not 4095
-        sub     ecx, edi
+        lea     esi, [hdr_cmdline]
-        jna     @F
-        xor     eax, eax
+        mov     ecx, sizeof.APP_HDR/4
-        cld
-        rep stosb
-@@:
         rep movsd
 ; release only virtual space, not phisical memory
+        mov     esi, [filename]
+        mov     ecx, [filename_size]
+        rep movsb
-        stdcall free_kernel_space, [file_base]
-        lea     eax, [hdr_cmdline]
-        lea     ebx, [cmdline]
-        lea     ecx, [filename]
-        stdcall set_app_params , [slot], eax, ebx, ecx, [flags]
+        mov     ecx, [cmdline_size]
         mov     esi, [cmdline]
-        mov     eax, [save_proc]
+        rep movsb
-        call    set_cr3
-        mov     eax, [process_number];set result
-        call    unlock_application_table
-        jmp     .final
-.failed:
-        mov     eax, [save_proc]
-        call    set_cr3
-.err:
-.err_hdr:
+        lea     eax, [hdr_cmdline]
-        stdcall kernel_free, [file_base]
+        stdcall set_app_params , [slot], eax, [flags]
 .err_file:
-        call    unlock_application_table
+        mov     eax, [process_number]       ;set result
         cmp     [eax+6], word '00'
         jne     .check_01_header
         mov     ecx, [APP_HEADER_00.start]
-        mov     [ebx+0x08], ecx             ;app_eip
+        mov     [ebx+APP_HDR.eip], ecx
         mov     edx, [APP_HEADER_00.mem_size]
-        mov     [ebx+0x10], edx             ;app_mem
+        mov     [ebx+APP_HDR._emem], edx
         shr     edx, 1
         sub     edx, 0x10
-        mov     [ebx+0x0C], edx             ;app_esp
+        mov     [ebx+APP_HDR.esp], edx
         mov     ecx, [APP_HEADER_00.i_param]
-        mov     [ebx], ecx                  ;app_cmdline
+        mov     [ebx+APP_HDR.cmdline], ecx
-        mov     [ebx+4], dword 0            ;app_path
+        mov     [ebx+APP_HDR.path], 0
         mov     edx, [APP_HEADER_00.i_end]
-        mov     [ebx+0x14], edx
+        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             ;app_eip
+        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+0x10], edx             ;app_mem
+        mov     [ebx+APP_HDR._emem], edx
         mov     ecx, [APP_HEADER_01.stack_top]
-        mov     [ebx+0x0C], ecx             ;app_esp
+        mov     [ebx+APP_HDR.esp], ecx
         mov     edx, [APP_HEADER_01.i_param]
-        mov     [ebx], edx                  ;app_cmdline
+        mov     [ebx+APP_HDR.cmdline], edx
         mov     ecx, [APP_HEADER_01.i_icon]
-        mov     [ebx+4], ecx                ;app_path
+        mov     [ebx+APP_HDR.path], ecx
         sub     edx, thr_slot_map
         lea     eax, [eax+edx*8]
         popfd
         ret
 align 4
-proc create_process stdcall, app_size:dword,img_base:dword,img_size:dword
+proc create_process stdcall, app_size:dword
-       locals
-         app_pages   dd ?
-         img_pages   dd ?
+       locals
          process     dd ?
          app_tabs    dd ?
        endl
         push    ebx
-        push    esi
-        push    edi
-        mov     ecx, pg_data.mutex
+        push    esi
-        call    mutex_lock
+        push    edi
-        xor     eax, eax
-        mov     [process], eax
-        mov     eax, [app_size]
-        add     eax, 4095
-        and     eax, NOT(4095)
-        mov     [app_size], eax
-        mov     ebx, eax
+        xor     eax, eax
-        shr     eax, 12
-        mov     [app_pages], eax
+        mov     [process], eax
-        add     ebx, 0x3FFFFF
-        and     ebx, NOT(0x3FFFFF)
-        shr     ebx, 22
-        mov     [app_tabs], ebx
-        mov     ecx, [img_size]
-        add     ecx, 4095
-        and     ecx, NOT(4095)
-        mov     [img_size], ecx
-        shr     ecx, 12
-        mov     [img_pages], ecx
-        lea     eax, [eax+ebx+2];all requested memory
+        mov     eax, [app_size]
         add     eax, 0x3FFFFF
-        cmp     eax, [pg_data.pages_free]
+        shr     eax, 22
-        ja      .fail
+        mov     [app_tabs], eax
         mov     eax, [edi-8192+PROC.pdt_0_phys]
         or      eax, PG_SWR
         mov     [edi-4096+(page_tabs shr 20)], eax
-        lea     eax, [edi-8192]
-        call    set_cr3
+        lea     edx, [edi-4096]
-        mov     edx, [app_tabs]
+        mov     esi, [app_tabs]
         xor     edi, edi
-@@:
+.alloc_page_dir:
+        call    alloc_page
+        test    eax, eax
-        call    alloc_page
-        test    eax, eax
-        jz      .fail
-        stdcall map_page_table, edi, eax
-        add     edi, 0x00400000
+        jz      .fail
-        dec     edx
-        jnz     @B
+        or      eax, PG_UWR
+        mov     [edx], eax
         mov     edi, page_tabs
         mov     edi, [tmp_task_ptab]
-        mov     ecx, [app_tabs]
-        shl     ecx, 10
-        xor     eax, eax
-        rep stosd
-        mov     ecx, [img_pages]
-        mov     ebx, PG_UWR
-        xor     edx, edx
-        mov     esi, [img_base]
-        shr     esi, 10
-        add     esi, page_tabs
-        mov     edi, page_tabs
-.remap:
+        stdcall map_page, edi, eax, PG_SWR
-        lodsd
-        and     eax, 0xFFFFF000
+        mov     ecx, 1024
-        or      eax, ebx; force user level r/w access
-        stosd
-        add     edx, 0x1000
-        dec     [app_pages]
-        dec     ecx
-        jnz     .remap
-        mov     ecx, [app_pages]
+        xor     eax, eax
-        test    ecx, ecx
-        jz      .done
-.alloc:
-        call    alloc_page
-        test    eax, eax
-        jz      .fail
-        stdcall map_page, edx, eax, dword PG_UWR
+        rep stosd
-        add     edx, 0x1000
         dec     [app_pages]
-        jnz     .alloc
+        add     edx, 4
         dec     esi
-.done:
+        jnz     .alloc_page_dir
         mov     ecx, pg_data.mutex
-        call    mutex_unlock
+        stdcall map_page, [tmp_task_ptab], 0, PG_UNMAP
-        mov     eax, [process]
-        pop     edi
+        mov     eax, [process]
-        pop     esi
+        pop     edi
-        pop     ebx
+        pop     esi
-        ret
+        pop     ebx
-.fail:
+        ret
-        mov     ecx, pg_data.mutex
+.fail:
-        call    mutex_unlock
+        mov     ecx, [process]
-        cmp     [process], 0
+        jcxz    @F
         je      @f
-;;        stdcall destroy_app_space, [dir_addr], 0
+        call    destroy_process
 @@:
-        xor     eax, eax
-        pop     edi
-        pop     esi
-        pop     ebx
-        ret
-endp
-align 4
-set_cr3:
-        pushfd
-        cli
-        mov     ebx, [current_slot]
-        mov     [current_process], eax
+        xor     eax, eax
-        mov     [ebx+APPDATA.process], eax
+        pop     edi
-        mov     eax, [eax+PROC.pdt_0_phys]
+        pop     esi
         cmp     ecx, 0x8000
         jna     @F
         mov     ecx, 0x8000
 @@:
         mov     ebx, [offset]
-      ;     add ebx, new_app_base
         push    ecx
         stdcall map_memEx, [proc_mem_map], \
                 [slot], ebx, ecx, PG_SWR
         pop     ecx
         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, dword 0, \
-                dword 0, [flags]
+        stdcall set_app_params , [slot], eax, [flags]
         mov     eax, [process_number]           ;set result
         call    unlock_application_table
         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
+        stdcall map_process_image, [ebp+APP_HDR._emem],\
+                [ebp+APP_HDR.img_base], [ebp+APP_HDR.img_size]
+        xor     eax, eax
+        mov     edi, [ebp+APP_HDR.path]
+        lea     esi, [ebp+sizeof.APP_HDR]
+        mov     ecx, [ebp+APP_HDR.filename_size]
+        test    edi, edi
+        jnz     .copy_filename
+        add     esi, ecx
+        jmp     .check_cmdline
+.copy_filename:
+        rep movsb
+        stosb
+.check_cmdline:
+        mov     edi, [ebp+APP_HDR.cmdline]
+        mov     ecx, [ebp+APP_HDR.cmdline_size]
+        test    edi, edi
+        jz      .check_tls_header
+        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:
+        rep movsb
+        stosb
+.check_tls_header:
+        cmp     word [6], '02'
-tls_app_entry:
+        jne     .cleanup
         call    init_heap
         shr     eax, 16
         mov     [tls_data_l+4], al
         mov     [tls_data_l+7], ah
         mov     dx, app_tls
         mov     fs, dx
+.cleanup:
+        stdcall free_kernel_space, [ebp+APP_HDR.img_base]
+        stdcall kernel_free, ebp
+.exit:
         popad
         iretd
 EFL_IF      equ 0x0200
 EFL_IOPL1   equ 0x1000
 EFL_IOPL2   equ 0x2000
-EFL_IOPL3   equ 0x3000
 EFL_IOPL3   equ 0x3000
-align 4
-proc set_app_params stdcall,slot:dword, params:dword,\
+align 4
-            cmd_line:dword, app_path:dword, flags:dword
+proc set_app_params stdcall,slot:dword, params:dword, flags:dword
         mov     edi, eax
         mov     [ebx+SLOT_BASE+APPDATA.cur_dir], eax
         rep movsd
-        shr     ebx, 3
-        mov     eax, new_app_base
+        shr     ebx, 3
-        mov     dword [CURRENT_TASK+ebx+0x10], eax
-.add_command_line:
-        mov     edx, [params]
-        mov     edx, [edx] ;app_cmdline
-        test    edx, edx
-        jz      @f     ;application doesn't need parameters
-        mov     eax, edx
-        add     eax, 256
-        jc      @f
-;        cmp     eax, [SLOT_BASE+APPDATA.mem_size+ebx*8]
-;        ja      @f
-        mov     eax, [cmd_line]
-        cmp     [edx], dword 0xffffffff ; extended destination tag
-        jne     .no_ext_dest
-        mov     edx, [edx+4] ; extended destination for cmdline
-        jmp     .continue
-.no_ext_dest:
-        mov     [eax-12], dword 255
-.continue:
-        mov     byte [edx], 0  ;force empty string if no cmdline given
-        test    eax, eax
-        jz      @f
-;--------------------------------------
-        cmp     [eax-4], dword 0xffffffff ; cmdline_flag
-        jne     .old_copy
-        push    eax
-        stdcall strncpy, edx, [eax-8], [eax-12]
-        pop     eax
-        stdcall kernel_free, [eax-8]
-        jmp     @f
-.old_copy:
-;--------------------------------------
-        stdcall strncpy, edx, eax, 256
-@@:
-        mov     edx, [params]
-        mov     edx, [edx+4];app_path
-        test    edx, edx
-        jz      @F     ;application don't need path of file
-        mov     eax, edx
-        add     eax, 1024
-        jc      @f
-;        cmp     eax, [SLOT_BASE+APPDATA.mem_size+ebx*8]
-;        ja      @f
-        stdcall strncpy, edx, [app_path], 1024
+        mov     dword [CURRENT_TASK+ebx+0x10], 0
 @@:
         mov     ebx, [slot]
         mov     eax, ebx
-        shl     ebx, 5
-        lea     ecx, [draw_data+ebx];ecx - pointer to draw data
-        mov     edx, irq0.return
-        cmp     [ebx*8+SLOT_BASE+APPDATA.tls_base], -1
-        jne     @F
+        shl     ebx, 5
-        mov     edx, tls_app_entry
+        lea     ecx, [draw_data+ebx];ecx - pointer to draw data
 @@:
 ; set window state to 'normal' (non-minimized/maximized/rolled-up) state
         mov     [ebx+window_data+WDATA.fl_wstate], WSTATE_NORMAL
         mov     ebx, [pl0_stack]
         mov     esi, [params]
         lea     ecx, [ebx+REG_EIP]
         xor     eax, eax
-        mov     [ebx+REG_RET], edx
+        mov     [ebx+REG_RET], dword common_app_entry
         mov     [ebx+REG_EDI], eax
         mov     [ebx+REG_ESI], eax
         mov     [ebx+REG_EBP], eax
         mov     [ebx+REG_ESP], ecx;ebx+REG_EIP
         mov     [ebx+REG_EBX], eax
         mov     [ebx+REG_EDX], eax
         mov     [ebx+REG_ECX], eax
         mov     [ebx+REG_EAX], eax
-        mov     eax, [esi+0x08]             ;app_eip
+        mov     eax, [esi+APP_HDR.eip]
-        mov     [ebx+REG_EIP], eax          ;app_entry
+        mov     [ebx+REG_EIP], eax
         mov     [ebx+REG_CS], dword app_code
         mov     ecx, USER_PRIORITY
         test    byte [flags], 2
-        jz      @F
         jz      @F
         mov     [ebx+REG_CS], dword os_code ; kernel thread
-        mov     ecx, MAX_PRIORITY
+        mov     [ebx+REG_CS], dword os_code ; kernel thread
+        mov     ecx, MAX_PRIORITY
 @@:
         mov     [ebx+REG_EFLAGS], dword EFL_IOPL1+EFL_IF
-        mov     eax, [esi+0x0C]  ;app_esp
+        mov     eax, [esi+APP_HDR.esp]
         lea     edx, [SLOT_BASE+ebx*8]
         call    scheduler_add_thread
         ret
 endp
-align 4
 align 4
 get_stack_base:
         mov     eax, [current_slot]
         mov     eax, [eax+APPDATA.pl0_stack]

Subversion Repositories Kolibri OS

(root)/kernel/trunk/core/taskman.inc – Rev 6263 → 6333