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

 ;; Copyright (C) KolibriOS team 2004-2012. All rights reserved. ;;
 ;; Distributed under terms of the GNU General Public License    ;;
 ;;                                                              ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-$Revision: 4424 $
+$Revision: 5130 $
          cmdline_flag  dd ? ; +8 ; cmdline -4
          cmdline       rd 64    ;256/4
          filename      rd 256   ;1024/4
          flags         dd ?
-         save_cr3      dd ?
+         save_proc     dd ?
          slot          dd ?
          slot_base     dd ?
          file_base     dd ?
          file_size     dd ?
         test    eax, eax
         jz      .err_hdr
         call    lock_application_table
-        call    get_new_process_place
+        call    alloc_thread_slot
         test    eax, eax
         mov     esi, -0x20 ; too many processes
         jz      .copy_process_name_done
         stosb
         loop    .copy_process_name_loop
 .copy_process_name_done:
-        mov     ebx, cr3
+        mov     ebx, [current_process]
-        mov     [save_cr3], ebx
+        mov     [save_proc], ebx
-        stdcall create_app_space, [hdr_mem], [file_base], [file_size]
+        stdcall create_process, [hdr_mem], [file_base], [file_size]
         mov     esi, -30; no memory
+        test    eax, eax
+        jz      .failed
-        test    eax, eax
+        mov     ebx, [hdr_mem]
-        jz      .failed
+        mov     [eax+PROC.mem_used], ebx
+        mov     ebx, [slot_base]
-        mov     ebx, [slot_base]
+        mov     [ebx+APPDATA.process], eax
-        mov     [ebx+APPDATA.dir_table], eax
+        lea     edx, [ebx+APPDATA.list]
-        mov     eax, [hdr_mem]
+        lea     ecx, [eax+PROC.thr_list]
-        mov     [ebx+APPDATA.mem_size], eax
+        list_add_tail edx, ecx
         lea     eax, [hdr_cmdline]
         lea     ebx, [cmdline]
         lea     ecx, [filename]
         stdcall set_app_params , [slot], eax, ebx, ecx, [flags]
-        mov     eax, [save_cr3]
+        mov     eax, [save_proc]
         call    set_cr3
         mov     eax, [process_number];set result
         call    unlock_application_table
         jmp     .final
 .failed:
-        mov     eax, [save_cr3]
+        mov     eax, [save_proc]
         call    set_cr3
 .fail:
         xor     eax, eax
         ret
 align 4
-proc get_new_process_place
+alloc_thread_slot:
 ;input:
 ;  none
 ;result:
-;  eax=[new_process_place]<>0 - ok
+;  eax=[new_thread_slot]<>0 - ok
 ;      0 - failed.
 ;This function find least empty slot.
-;It doesn't increase [TASK_COUNT]!
+;It doesn't increase [TASK_COUNT]!
-        mov     eax, CURRENT_TASK
-        mov     ebx, [TASK_COUNT]
+        mov     edx, thr_slot_map
-        inc     ebx
+        pushfd
-        shl     ebx, 5
-        add     ebx, eax    ;ebx - address of process information for (last+1) slot
+        cli
-.newprocessplace:
-;eax = address of process information for current slot
+.l1:
-        cmp     eax, ebx
-        jz      .endnewprocessplace ;empty slot after high boundary
+        bsf     eax, [edx]
-        add     eax, 0x20
-        cmp     word [eax+0xa], 9;check process state, 9 means that process slot is empty
-        jnz     .newprocessplace
-.endnewprocessplace:
+        jnz     .found
-        mov     ebx, eax
+        add     edx, 4
-        sub     eax, CURRENT_TASK
-        shr     eax, 5      ;calculate slot index
+        cmp     edx, thr_slot_map+32
-        cmp     eax, 256
-        jge     .failed     ;it should be <256
+        jb      .l1
-        mov     word [ebx+0xa], 9;set process state to 9 (for slot after hight boundary)
-        ret
-.failed:
+        popfd
         xor     eax, eax
         ret
+.found:
+        btr     [edx], eax
+        sub     edx, thr_slot_map
+        lea     eax, [eax+edx*8]
+        popfd
+        ret
 endp
 align 4
-proc create_app_space stdcall, app_size:dword,img_base:dword,img_size:dword
+proc create_process stdcall, app_size:dword,img_base:dword,img_size:dword
        locals
          app_pages   dd ?
          img_pages   dd ?
-         dir_addr    dd ?
+         process     dd ?
+         app_tabs    dd ?
+       endl
+        push    ebx
-         app_tabs    dd ?
+        push    esi
-       endl
+        push    edi
         mov     ecx, pg_data.mutex
         call    mutex_lock
         xor     eax, eax
-        mov     [dir_addr], eax
+        mov     [process], eax
         mov     [img_size], ecx
         shr     ecx, 12
-        mov     [img_pages], ecx
-if GREEDY_KERNEL
-        lea     eax, [ecx+ebx+2];only image size
+        mov     [img_pages], ecx
-else
         lea     eax, [eax+ebx+2];all requested memory
 end if
         cmp     eax, [pg_data.pages_free]
         ja      .fail
-        call    alloc_page
+        stdcall kernel_alloc, 0x2000
+        test    eax, eax
-        test    eax, eax
+        jz      .fail
+        mov     [process], eax
+        lea     edi, [eax+PROC.heap_lock]
+        mov     ecx, (4096-PROC.heap_lock)/4
-        jz      .fail
-        mov     [dir_addr], eax
-        stdcall map_page, [tmp_task_pdir], eax, dword PG_SW
+        list_init eax
         add     eax, PROC.thr_list
-        mov     edi, [tmp_task_pdir]
+        list_init eax
+        xor     eax, eax
+        cld
+        rep stosd
+        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
+        mov     ecx, (OS_BASE shr 20)/4
-        cld
+        xor     eax, eax
         rep stosd
         mov     ecx, (OS_BASE shr 20)/4
-        mov     esi, sys_pgdir+(OS_BASE shr 20)
+        mov     esi, sys_proc+PROC.pdt_0+(OS_BASE shr 20)
         rep movsd
-        mov     eax, [dir_addr]
+        mov     eax, [edi-8192+PROC.pdt_0_phys]
         or      eax, PG_SW
         mov     [edi-4096+(page_tabs shr 20)], eax
-        and     eax, -4096
+        lea     eax, [edi-8192]
         call    set_cr3
         mov     edx, [app_tabs]
-        mov     edi, new_app_base
+        xor     edi, edi
-@@:
-        call    alloc_page
-        test    eax, eax
+@@:
-        jz      .fail
+        call    alloc_page
         test    eax, eax
-        stdcall map_page_table, edi, eax
+        jz      .fail
         add     edi, 0x00400000
-        dec     edx
+        stdcall map_page_table, edi, eax
-        jnz     @B
+        add     edi, 0x00400000
+        dec     edx
-        mov     edi, new_app_base
+        jnz     @B
-        shr     edi, 10
         add     edi, page_tabs
-        mov     ecx, [app_tabs]
+        mov     edi, page_tabs
-        shl     ecx, 10
-        xor     eax, eax
+        mov     ecx, [app_tabs]
-        rep stosd
+        shl     ecx, 10
         xor     eax, eax
-        mov     ecx, [img_pages]
+        rep stosd
         mov     ebx, PG_UW
         mov     ecx, [app_pages]
         test    ecx, ecx
-        jz      .done
-if GREEDY_KERNEL
-        mov     eax, 0x02
-        rep stosd
-else
+        jz      .done
 .alloc:
         call    alloc_page
         test    eax, eax
         jz      .fail
         stdcall map_page, edx, eax, dword PG_UW
-        add     edx, 0x1000
-        dec     [app_pages]
+        add     edx, 0x1000
-        jnz     .alloc
-end if
         dec     [app_pages]
-.done:
+        jnz     .alloc
-        stdcall map_page, [tmp_task_pdir], dword 0, dword PG_UNMAP
+.done:
+        mov     ecx, pg_data.mutex
+        call    mutex_unlock
+        mov     eax, [process]
-        mov     ecx, pg_data.mutex
+        pop     edi
-        call    mutex_unlock
+        pop     esi
-        mov     eax, [dir_addr]
+        pop     ebx
         ret
 .fail:
         mov     ecx, pg_data.mutex
         call    mutex_unlock
-        cmp     [dir_addr], 0
+        cmp     [process], 0
+        je      @f
+;;        stdcall destroy_app_space, [dir_addr], 0
+@@:
-        je      @f
+        xor     eax, eax
-        stdcall destroy_app_space, [dir_addr], 0
+        pop     edi
-@@:
+        pop     esi
-        xor     eax, eax
+        pop     ebx
+        ret
-        ret
+endp
 endp
+align 4
+set_cr3:
+        pushfd
-align 4
+        cli
+        mov     ebx, [current_slot]
-set_cr3:
+        mov     [current_process], eax
         mov     [ebx+APPDATA.process], eax
-        mov     ebx, [current_slot]
+        mov     eax, [eax+PROC.pdt_0_phys]
         mov     ecx, 1024
 .free:
         mov     eax, [esi]
         test    eax, 1
         jz      .next
+        test    eax, 2
+        jz      .next
         test    eax, 1 shl 9
         jnz     .next                     ;skip shared pages
         call    free_page
 .next:
         add     esi, 4
         pop     esi
         ret
 endp
 align 4
-proc destroy_app_space stdcall, pg_dir:dword, dlls_list:dword
-        xor     edx, edx
-        push    edx
+destroy_process: ;fastcall ecx= ptr to process
-        mov     eax, 0x1
-        mov     ebx, [pg_dir]
-.loop:
-;eax = current slot of process
-        mov     ecx, eax
-        shl     ecx, 5
-        cmp     byte [CURRENT_TASK+ecx+0xa], 9;if process running?
-        jz      @f           ;skip empty slots
-        shl     ecx, 3
-        add     ecx, SLOT_BASE
-        cmp     [ecx+APPDATA.dir_table], ebx;compare page directory addresses
-        jnz     @f
-        mov     [ebp-4], ecx
-        inc     edx             ;thread found
-@@:
-        inc     eax
+        lea     eax, [ecx+PROC.thr_list]
-        cmp     eax, [TASK_COUNT]   ;exit loop if we look through all processes
-        jle     .loop
+        cmp     eax, [eax+LHEAD.next]
-;edx = number of threads
+        jne     .exit
-;our process is zombi so it isn't counted
-        pop     ecx
-        cmp     edx, 1
-        jg      .ret
-;if there isn't threads then clear memory.
+align 4
-        mov     esi, [dlls_list]
+.internal:
-        call    destroy_all_hdlls;ecx=APPDATA
+        push    ecx
+        mov     esi, [ecx+PROC.dlls_list_ptr]
-        mov     ecx, pg_data.mutex
+        call    destroy_all_hdlls
-        call    mutex_lock
+;        mov     ecx, pg_data.mutex
-        mov     eax, [pg_dir]
+;        call    mutex_lock
         and     eax, not 0xFFF
-        stdcall map_page, [tmp_task_pdir], eax, PG_SW
+        mov     esi, [esp]
-        mov     esi, [tmp_task_pdir]
+        add     esi, PROC.pdt_0
-        mov     edi, (OS_BASE shr 20)/4
+        mov     edi, (0x80000000 shr 20)/4
 .next:
         add     esi, 4
         dec     edi
         jnz     .destroy
-        mov     eax, [pg_dir]
-        call    free_page
-.exit:
+        call    kernel_free     ;ecx still in stack
-        stdcall map_page, [tmp_task_ptab], 0, PG_UNMAP
-        stdcall map_page, [tmp_task_pdir], 0, PG_UNMAP
+        stdcall map_page, [tmp_task_ptab], 0, PG_UNMAP
-        mov     ecx, pg_data.mutex
+ ;       mov     ecx, pg_data.mutex
+ ;       call    mutex_unlock
-        call    mutex_unlock
-.ret:
+.exit:
-        ret
-endp
+        ret
 align 4
 get_pid:
 ;  esi - start of buffer
 ;  edx - size of buffer
 ;result:
 ;  eax = 1 region lays in app memory
 ;  eax = 0 region don't lays in app memory
+        mov     eax, 1
+        ret
+if 0
         mov     eax, [CURRENT_TASK]
 ;     jmp  check_process_region
 ;-----------------------------------------------------------------------------
 ;check_process_region:
 ;input:
         test    eax, eax
         jz      .failed
         mov     eax, 1
-        ret
-;    call MEM_Get_Linear_Address
-;    push ebx
-;    push ecx
-;    push edx
-;    mov  edx,ebx
-;    and  edx,not (4096-1)
-;    sub  ebx,edx
-;    add  ecx,ebx
-;    mov  ebx,edx
-;    add  ecx,(4096-1)
-;    and  ecx,not (4096-1)
-;.loop:
-;;eax - linear address of page directory
-;;ebx - current page
-;;ecx - current size
-;    mov  edx,ebx
-;    shr  edx,22
-;    mov  edx,[eax+4*edx]
-;    and  edx,not (4096-1)
-;    test edx,edx
-;    jz   .failed1
-;    push eax
-;    mov  eax,edx
-;    call MEM_Get_Linear_Address
-;    mov  edx,ebx
-;    shr  edx,12
-;    and  edx,(1024-1)
-;    mov  eax,[eax+4*edx]
-;    and  eax,not (4096-1)
-;    test eax,eax
-;    pop  eax
-;    jz   .failed1
-;    add  ebx,4096
-;    sub  ecx,4096
-;    jg   .loop
-;    pop  edx
-;    pop  ecx
-;    pop  ebx
+        ret
 .ok:
         mov     eax, 1
-        ret
-;
-;.failed1:
-;    pop  edx
-;    pop  ecx
-;    pop  ebx
+        ret
 .failed:
         xor     eax, eax
+        ret
-        ret
+end if
 align 4
 proc read_process_memory
         mov     [app_esp], edx
         mov     [app_path], eax
         call    lock_application_table
-        call    get_new_process_place
+        call    alloc_thread_slot
         test    eax, eax
         mov     esi, ebx
         mov     edi, edx
         mov     ecx, 11
         rep movsb             ;copy process name
-        mov     eax, [ebx+APPDATA.heap_base]
+        mov     eax, [ebx+APPDATA.process]
-        mov     [edx+APPDATA.heap_base], eax
-        mov     ecx, [ebx+APPDATA.heap_top]
-        mov     [edx+APPDATA.heap_top], ecx
+        mov     [edx+APPDATA.process], eax
-        mov     eax, [ebx+APPDATA.mem_size]
-        mov     [edx+APPDATA.mem_size], eax
+        lea     ebx, [edx+APPDATA.list]
-        mov     ecx, [ebx+APPDATA.dir_table]
-        mov     [edx+APPDATA.dir_table], ecx;copy page directory
-        mov     eax, [ebx+APPDATA.dlls_list_ptr]
+        lea     ecx, [eax+PROC.thr_list]
-        mov     [edx+APPDATA.dlls_list_ptr], eax
+        list_add_tail ebx, ecx               ;add thread to process child's list
         mov     eax, edx
         add     eax, 256
         jc      @f
-        cmp     eax, [SLOT_BASE+APPDATA.mem_size+ebx*8]
+;        cmp     eax, [SLOT_BASE+APPDATA.mem_size+ebx*8]
-        ja      @f
+;        ja      @f
         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]
+;        cmp     eax, [SLOT_BASE+APPDATA.mem_size+ebx*8]
-        ja      @f
+;        ja      @f
         stdcall strncpy, edx, [app_path], 1024
 @@:
         mov     ebx, [slot]
         mov     eax, ebx
         shl     ebx, 5

Subversion Repositories Kolibri OS

(root)/kernel/trunk/core/taskman.inc – Rev 4424 → 5130