Subversion Repositories Kolibri OS

Rev

Rev 1310 | Rev 1314 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  2. ;;                                                              ;;
  3. ;; Copyright (C) KolibriOS team 2004-2007. All rights reserved. ;;
  4. ;; Distributed under terms of the GNU General Public License    ;;
  5. ;;                                                              ;;
  6. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  7.  
  8. $Revision: 1311 $
  9.  
  10.  
  11. GREEDY_KERNEL equ 0
  12.  
  13. struc APP_HEADER_00
  14. { .banner      dq ?
  15.   .version     dd ?    ;+8
  16.   .start       dd ?    ;+12
  17.   .i_end       dd ?    ;+16
  18.   .mem_size    dd ?    ;+20
  19.   .i_param     dd ?    ;+24
  20. }
  21.  
  22. struc APP_HEADER_01
  23. { .banner      dq ?
  24.   .version     dd ?    ;+8
  25.   .start       dd ?    ;+12
  26.   .i_end       dd ?    ;+16
  27.   .mem_size    dd ?    ;+20
  28.   .stack_top   dd ?    ;+24
  29.   .i_param     dd ?    ;+28
  30.   .i_icon      dd ?    ;+32
  31. }
  32.  
  33.  
  34. struc APP_PARAMS
  35. { .app_cmdline   ;0x00
  36.   .app_path  ;0x04
  37.   .app_eip   ;0x08
  38.   .app_esp   ;0x0C
  39.   .app_mem   ;0x10
  40. }
  41.  
  42. macro _clear_ op
  43. {  mov ecx, op/4
  44.    xor eax, eax
  45.    cld
  46.    rep stosd
  47. }
  48.  
  49. fs_execute_from_sysdir:
  50.     xor ebx, ebx
  51.     xor edx, edx
  52.     mov esi, sysdir_path
  53.  
  54. align 4
  55. proc fs_execute
  56.  
  57. ;fn_read:dword, file_size:dword, cluster:dword
  58.  
  59. ; ebx - cmdline
  60. ; edx - flags
  61. ; ebp - full filename
  62. ; [esp+4] = procedure DoRead, [esp+8] = filesize & [esp+12]... - arguments for it
  63.  
  64.        locals
  65.          cmdline       rd 64    ;256/4
  66.          filename      rd 256   ;1024/4
  67.          flags     dd ?
  68.  
  69.          save_cr3      dd ?
  70.          slot      dd ?
  71.          slot_base     dd ?
  72.          file_base     dd ?
  73.          file_size     dd ?
  74.                       ;app header data
  75.          hdr_cmdline   dd ? ;0x00
  76.          hdr_path      dd ? ;0x04
  77.          hdr_eip       dd ? ;0x08
  78.          hdr_esp       dd ? ;0x0C
  79.          hdr_mem       dd ? ;0x10
  80.          hdr_i_end     dd ? ;0x14
  81.        endl
  82.  
  83.        pushad
  84.  
  85.        mov [flags], edx
  86.  
  87. ; [ebp]  pointer to filename
  88.  
  89.        lea edi, [filename]
  90.        lea ecx, [edi+1024]
  91.        mov al, '/'
  92.        stosb
  93. @@:
  94.        cmp edi, ecx
  95.        jae .bigfilename
  96.        lodsb
  97.        stosb
  98.        test al, al
  99.        jnz @b
  100.        mov esi, [ebp]
  101.        test esi, esi
  102.        jz .namecopied
  103.        mov byte [edi-1], '/'
  104. @@:
  105.        cmp edi, ecx
  106.        jae .bigfilename
  107.        lodsb
  108.        stosb
  109.        test al, al
  110.        jnz @b
  111.        jmp .namecopied
  112. .bigfilename:
  113.        popad
  114.        mov eax, -ERROR_FILE_NOT_FOUND
  115.        ret
  116.  
  117. .namecopied:
  118.  
  119.        mov [cmdline], ebx
  120.        test ebx, ebx
  121.        jz @F
  122.  
  123.        lea eax, [cmdline]
  124.        mov dword [eax+252], 0
  125.        stdcall strncpy, eax, ebx, 255
  126. @@:
  127.        lea eax, [filename]
  128.        stdcall load_file, eax
  129.        mov  ecx, -ERROR_FILE_NOT_FOUND
  130.        test eax, eax
  131.        jz .err_file
  132.  
  133.        mov [file_base], eax
  134.        mov [file_size], ebx
  135.  
  136.        lea ebx, [hdr_cmdline]
  137.        call test_app_header
  138.        mov ecx, -0x1F
  139.        test eax, eax
  140.        jz .err_hdr
  141.  
  142.        ;mov esi, new_process_loading
  143.        ;call sys_msg_board_str       ; write message to message board
  144.  
  145. .wait_lock:
  146.        cmp [application_table_status],0
  147.        je .get_lock
  148.        call   change_task
  149.        jmp .wait_lock
  150.  
  151. .get_lock:
  152.        mov eax, 1
  153.        xchg eax, [application_table_status]
  154.        test eax, eax
  155.        jnz .wait_lock
  156.  
  157.        call set_application_table_status
  158.  
  159.        call get_new_process_place
  160.        test eax, eax
  161.        mov ecx, -0x20      ; too many processes
  162.        jz .err
  163.  
  164.        mov [slot], eax
  165.        shl eax, 8
  166.        add eax, SLOT_BASE
  167.        mov [slot_base], eax
  168.        mov edi, eax
  169.        _clear_ 256     ;clean extended information about process
  170.  
  171. ; write application name
  172.        lea eax, [filename]
  173.        stdcall strrchr,  eax, '/'  ; now eax points to name without path
  174.  
  175.        lea esi, [eax+1]
  176.        test eax, eax
  177.        jnz @F
  178.        lea esi, [filename]
  179. @@:
  180.        mov ecx, 8  ; 8 chars for name
  181.        mov edi, [slot_base]
  182. .copy_process_name_loop:
  183.        lodsb
  184.        cmp al, '.'
  185.        jz .copy_process_name_done
  186.        test al, al
  187.        jz .copy_process_name_done
  188.        stosb
  189.        loop .copy_process_name_loop
  190. .copy_process_name_done:
  191.  
  192.        mov ebx, cr3
  193.        mov [save_cr3], ebx
  194.  
  195.        stdcall create_app_space,[hdr_mem],[file_base],[file_size]
  196.        mov ecx, -30  ; no memory
  197.        test eax, eax
  198.        jz .failed
  199.  
  200.        mov   ebx,[slot_base]
  201.        mov   [ebx+APPDATA.dir_table],eax
  202.        mov   eax,[hdr_mem]
  203.        mov   [ebx+APPDATA.mem_size],eax
  204.  
  205.        xor edx, edx
  206.        cmp word [6], '02'
  207.        jne @f
  208.  
  209.        not edx
  210. @@:
  211.        mov   [ebx+APPDATA.tls_base],edx
  212.  
  213. if GREEDY_KERNEL
  214. else
  215.        mov ecx, [hdr_mem]
  216.        mov edi, [file_size]
  217.        add edi, 4095
  218.        and edi, not 4095
  219.        sub ecx, edi
  220.        jna @F
  221.  
  222.        xor eax, eax
  223.        cld
  224.        rep stosb
  225. @@:
  226. end if
  227.  
  228. ; release only virtual space, not phisical memory
  229.  
  230.        stdcall free_kernel_space, [file_base]
  231.        lea eax, [hdr_cmdline]
  232.        lea ebx, [cmdline]
  233.        lea ecx, [filename]
  234.        stdcall set_app_params ,[slot],eax,ebx,ecx,[flags]
  235.  
  236.        mov eax, [save_cr3]
  237.        call set_cr3
  238.  
  239.        xor ebx, ebx
  240.        mov [application_table_status],ebx ;unlock application_table_status mutex
  241.        mov eax,[process_number]  ;set result
  242.        ret
  243. .failed:
  244.        mov eax, [save_cr3]
  245.        call set_cr3
  246. .err:
  247. .err_hdr:
  248.        stdcall kernel_free,[file_base]
  249. .err_file:
  250.        xor eax, eax
  251.        mov [application_table_status],eax
  252.        mov eax, ecx
  253.        ret
  254. endp
  255.  
  256. align 4
  257. test_app_header:
  258.        virtual at eax
  259.          APP_HEADER_00 APP_HEADER_00
  260.        end virtual
  261.        virtual at eax
  262.          APP_HEADER_01 APP_HEADER_01
  263.        end virtual
  264.  
  265.        cmp dword [eax], 'MENU'
  266.        jne .fail
  267.        cmp word [eax+4],'ET'
  268.        jne .fail
  269.  
  270.        cmp [eax+6], word '00'
  271.        jne  .check_01_header
  272.  
  273.        mov  ecx,[APP_HEADER_00.start]
  274.        mov  [ebx+0x08], ecx                 ;app_eip
  275.        mov  edx,[APP_HEADER_00.mem_size]
  276.        mov  [ebx+0x10], edx                 ;app_mem
  277.        shr  edx,1
  278.        sub  edx,0x10
  279.        mov  [ebx+0x0C], edx                 ;app_esp
  280.        mov  ecx,[APP_HEADER_00.i_param]
  281.        mov  [ebx], ecx                      ;app_cmdline
  282.        mov  [ebx+4], dword 0                ;app_path
  283.        mov  edx, [APP_HEADER_00.i_end]
  284.        mov  [ebx+0x14], edx
  285.        ret
  286.  
  287.  .check_01_header:
  288.  
  289.        cmp [eax+6], word '01'
  290.        je @f
  291.        cmp [eax+6], word '02'
  292.        jne .fail
  293. @@:
  294.        mov  ecx,[APP_HEADER_01.start]
  295.        mov  [ebx+0x08], ecx                 ;app_eip
  296.        mov  edx,[APP_HEADER_01.mem_size]
  297.  
  298. ; \begin{diamond}[20.08.2006]
  299. ; sanity check (functions 19,58 load app_i_end bytes and that must
  300. ; fit in allocated memory to prevent kernel faults)
  301.        cmp  edx,[APP_HEADER_01.i_end]
  302.        jb   .fail
  303. ; \end{diamond}[20.08.2006]
  304.  
  305.        mov  [ebx+0x10], edx                 ;app_mem
  306.        mov  ecx,[APP_HEADER_01.stack_top]
  307.        mov  [ebx+0x0C], ecx                 ;app_esp
  308.        mov  edx,[APP_HEADER_01.i_param]
  309.        mov  [ebx], edx                      ;app_cmdline
  310.        mov  ecx,[APP_HEADER_01.i_icon]
  311.        mov  [ebx+4], ecx                    ;app_path
  312.        mov  edx, [APP_HEADER_01.i_end]
  313.        mov  [ebx+0x14], edx
  314.        ret
  315. .fail:
  316.        xor eax, eax
  317.        ret
  318.  
  319. align 4
  320. proc get_new_process_place
  321. ;input:
  322. ;  none
  323. ;result:
  324. ;  eax=[new_process_place]<>0 - ok
  325. ;      0 - failed.
  326. ;This function find least empty slot.
  327. ;It doesn't increase [TASK_COUNT]!
  328.        mov    eax,CURRENT_TASK
  329.        mov    ebx,[TASK_COUNT]
  330.        inc    ebx
  331.        shl    ebx,5
  332.        add    ebx,eax       ;ebx - address of process information for (last+1) slot
  333. .newprocessplace:
  334. ;eax = address of process information for current slot
  335.        cmp    eax,ebx
  336.        jz     .endnewprocessplace   ;empty slot after high boundary
  337.        add    eax,0x20
  338.        cmp    word [eax+0xa],9  ;check process state, 9 means that process slot is empty
  339.        jnz    .newprocessplace
  340. .endnewprocessplace:
  341.        mov    ebx,eax
  342.        sub    eax,CURRENT_TASK
  343.        shr    eax,5         ;calculate slot index
  344.        cmp    eax,256
  345.        jge    .failed       ;it should be <256
  346.        mov    word [ebx+0xa],9  ;set process state to 9 (for slot after hight boundary)
  347.        ret
  348. .failed:
  349.        xor    eax,eax
  350.        ret
  351. endp
  352.  
  353. align 4
  354. proc create_app_space stdcall, app_size:dword,img_base:dword,img_size:dword
  355.        locals
  356.          app_pages   dd ?
  357.          img_pages   dd ?
  358.          dir_addr    dd ?
  359.          app_tabs    dd ?
  360.        endl
  361.  
  362.        mov ebx, pg_data.pg_mutex
  363.        call wait_mutex   ;ebx
  364.  
  365.        xor eax, eax
  366.        mov [dir_addr], eax
  367.  
  368.        mov eax, [app_size]
  369.        add eax, 4095
  370.        and eax, NOT(4095)
  371.        mov [app_size], eax
  372.        mov ebx, eax
  373.        shr eax, 12
  374.        mov [app_pages], eax
  375.  
  376.        add ebx, 0x3FFFFF
  377.        and ebx, NOT(0x3FFFFF)
  378.        shr ebx, 22
  379.        mov [app_tabs], ebx
  380.  
  381.        mov ecx, [img_size]
  382.        add ecx, 4095
  383.        and ecx, NOT(4095)
  384.  
  385.        mov [img_size], ecx
  386.        shr ecx, 12
  387.        mov [img_pages], ecx
  388.  
  389.      if GREEDY_KERNEL
  390.        lea eax, [ecx+ebx+2]    ;only image size
  391.      else
  392.        lea eax, [eax+ebx+2]    ;all requested memory
  393.      end if
  394.        cmp eax, [pg_data.pages_free]
  395.        ja .fail
  396.  
  397.        call alloc_page
  398.        test eax, eax
  399.        jz .fail
  400.        mov [dir_addr], eax
  401.        stdcall map_page,[tmp_task_pdir],eax,dword PG_SW
  402.  
  403.        mov edi, [tmp_task_pdir]
  404.        mov ecx, (OS_BASE shr 20)/4
  405.        xor eax, eax
  406.        cld
  407.        rep stosd
  408.  
  409.        mov ecx, (OS_BASE shr 20)/4
  410.        mov esi, sys_pgdir+(OS_BASE shr 20)
  411.        rep movsd
  412.  
  413.        mov eax, [dir_addr]
  414.        or eax, PG_SW
  415.        mov [edi-4096+(page_tabs shr 20)], eax
  416.  
  417.        and eax, -4096
  418.        call set_cr3
  419.  
  420.        mov edx, [app_tabs]
  421.        mov edi, new_app_base
  422. @@:
  423.        call alloc_page
  424.        test eax, eax
  425.        jz .fail
  426.  
  427.        stdcall map_page_table, edi, eax
  428.        add edi, 0x00400000
  429.        dec edx
  430.        jnz @B
  431.  
  432.        mov edi, new_app_base
  433.        shr edi, 10
  434.        add edi, page_tabs
  435.  
  436.        mov ecx, [app_tabs]
  437.        shl ecx, 10
  438.        xor eax, eax
  439.        rep stosd
  440.  
  441.        mov ecx, [img_pages]
  442.        mov ebx, PG_UW
  443.        mov edx, new_app_base
  444.        mov esi, [img_base]
  445.        mov edi, new_app_base
  446.        shr esi, 10
  447.        shr edi, 10
  448.        add esi, page_tabs
  449.        add edi, page_tabs
  450. .remap:
  451.        lodsd
  452.        or eax, ebx      ; force user level r/w access
  453.        stosd
  454.        add edx, 0x1000
  455.        dec [app_pages]
  456.        dec ecx
  457.        jnz .remap
  458.  
  459.        mov ecx, [app_pages]
  460.        test ecx, ecx
  461.        jz .done
  462.  
  463. if GREEDY_KERNEL
  464.        mov eax, 0x02
  465.        rep stosd
  466. else
  467.  
  468. .alloc:
  469.        call alloc_page
  470.        test eax, eax
  471.        jz .fail
  472.  
  473.        stdcall map_page,edx,eax,dword PG_UW
  474.        add edx, 0x1000
  475.        dec [app_pages]
  476.        jnz .alloc
  477. end if
  478.  
  479. .done:
  480.        stdcall map_page,[tmp_task_pdir],dword 0,dword PG_UNMAP
  481.  
  482.        dec [pg_data.pg_mutex]
  483.        mov eax, [dir_addr]
  484.        ret
  485. .fail:
  486.        dec [pg_data.pg_mutex]
  487.        cmp [dir_addr], 0
  488.        je @f
  489.        stdcall destroy_app_space, [dir_addr], 0
  490. @@:
  491.        xor eax, eax
  492.        ret
  493. endp
  494.  
  495. align 4
  496. set_cr3:
  497.  
  498.        mov ebx, [current_slot]
  499.        mov [ebx+APPDATA.dir_table], eax
  500.        mov cr3, eax
  501.        ret
  502.  
  503. align 4
  504. proc destroy_page_table stdcall, pg_tab:dword
  505.  
  506.        push esi
  507.  
  508.        mov esi, [pg_tab]
  509.        mov ecx, 1024
  510. .free:
  511.        mov eax, [esi]
  512.        test eax, 1
  513.        jz .next
  514.            test eax, 1 shl 9
  515.            jnz .next                      ;skip shared pages
  516.        call free_page
  517. .next:
  518.        add esi, 4
  519.        dec ecx
  520.        jnz .free
  521.        pop esi
  522.        ret
  523. endp
  524.  
  525. align 4
  526. proc destroy_app_space stdcall, pg_dir:dword, dlls_list:dword
  527.  
  528.        xor   edx,edx
  529.        push  edx
  530.        mov   eax,0x2
  531.        mov ebx, [pg_dir]
  532. .loop:
  533. ;eax = current slot of process
  534.        mov   ecx,eax
  535.        shl   ecx,5
  536.        cmp   byte [CURRENT_TASK+ecx+0xa],9  ;if process running?
  537.        jz    @f              ;skip empty slots
  538.        shl   ecx,3
  539.        add   ecx,SLOT_BASE
  540.        cmp   [ecx+APPDATA.dir_table],ebx   ;compare page directory addresses
  541.        jnz   @f
  542.        mov   [ebp-4],ecx
  543.        inc   edx                ;thread found
  544. @@:
  545.        inc   eax
  546.        cmp   eax,[TASK_COUNT]       ;exit loop if we look through all processes
  547.        jle   .loop
  548.  
  549. ;edx = number of threads
  550. ;our process is zombi so it isn't counted
  551.        pop   ecx
  552.        cmp   edx,1
  553.        jg    .ret
  554. ;if there isn't threads then clear memory.
  555.        mov esi, [dlls_list]
  556.        call destroy_all_hdlls
  557.  
  558.        mov ebx, pg_data.pg_mutex
  559.        call wait_mutex   ;ebx
  560.  
  561.        mov eax, [pg_dir]
  562.        and eax, not 0xFFF
  563.        stdcall map_page,[tmp_task_pdir],eax,PG_SW
  564.        mov esi, [tmp_task_pdir]
  565.        mov edi, (OS_BASE shr 20)/4
  566. .destroy:
  567.        mov eax, [esi]
  568.        test eax, 1
  569.        jz .next
  570.        and eax, not 0xFFF
  571.        stdcall map_page,[tmp_task_ptab],eax,PG_SW
  572.        stdcall destroy_page_table, [tmp_task_ptab]
  573.        mov eax, [esi]
  574.        call free_page
  575. .next:
  576.        add esi, 4
  577.        dec edi
  578.        jnz .destroy
  579.  
  580.        mov eax, [pg_dir]
  581.        call free_page
  582. .exit:
  583.        stdcall map_page,[tmp_task_ptab],0,PG_UNMAP
  584.        stdcall map_page,[tmp_task_pdir],0,PG_UNMAP
  585.        dec [pg_data.pg_mutex]
  586. .ret:
  587.        ret
  588. endp
  589.  
  590. align 4
  591. get_pid:
  592.        mov eax, [TASK_BASE]
  593.        mov eax, [eax+TASKDATA.pid]
  594.        ret
  595.  
  596. pid_to_slot:
  597. ;Input:
  598. ;  eax - pid of process
  599. ;Output:
  600. ;  eax - slot of process or 0 if process don't exists
  601. ;Search process by PID.
  602.     push   ebx
  603.     push   ecx
  604.     mov    ebx,[TASK_COUNT]
  605.     shl    ebx,5
  606.     mov    ecx,2*32
  607.  
  608. .loop:
  609. ;ecx=offset of current process info entry
  610. ;ebx=maximum permitted offset
  611.     cmp    byte [CURRENT_TASK+ecx+0xa],9
  612.     jz     .endloop      ;skip empty slots
  613.     cmp    [CURRENT_TASK+ecx+0x4],eax ;check PID
  614.     jz     .pid_found
  615. .endloop:
  616.     add    ecx,32
  617.     cmp    ecx,ebx
  618.     jle    .loop
  619.  
  620.     pop    ecx
  621.     pop    ebx
  622.     xor    eax,eax
  623.     ret
  624.  
  625. .pid_found:
  626.     shr    ecx,5
  627.     mov    eax,ecx       ;convert offset to index of slot
  628.     pop    ecx
  629.     pop    ebx
  630.     ret
  631.  
  632. check_region:
  633. ;input:
  634. ;  ebx - start of buffer
  635. ;  ecx - size of buffer
  636. ;result:
  637. ;  eax = 1 region lays in app memory
  638. ;  eax = 0 region don't lays in app memory
  639.      mov  eax,[CURRENT_TASK]
  640.      jmp  check_process_region
  641. ;-----------------------------------------------------------------------------
  642. check_process_region:
  643. ;input:
  644. ;  eax - slot
  645. ;  ebx - start of buffer
  646. ;  ecx - size of buffer
  647. ;result:
  648. ;  eax = 1 region lays in app memory
  649. ;  eax = 0 region don't lays in app memory
  650.  
  651.      test ecx,ecx
  652.      jle  .ok
  653.      shl  eax,5
  654.      cmp  word [CURRENT_TASK+eax+0xa],0
  655.      jnz  .failed
  656.      shl  eax,3
  657.      mov  eax,[SLOT_BASE+eax+0xb8]
  658.      test eax,eax
  659.      jz   .failed
  660.  
  661.      mov  eax,1
  662.      ret
  663.  
  664.  
  665. ;    call MEM_Get_Linear_Address
  666. ;    push ebx
  667. ;    push ecx
  668. ;    push edx
  669. ;    mov  edx,ebx
  670. ;    and  edx,not (4096-1)
  671. ;    sub  ebx,edx
  672. ;    add  ecx,ebx
  673. ;    mov  ebx,edx
  674. ;    add  ecx,(4096-1)
  675. ;    and  ecx,not (4096-1)
  676. ;.loop:
  677. ;;eax - linear address of page directory
  678. ;;ebx - current page
  679. ;;ecx - current size
  680. ;    mov  edx,ebx
  681. ;    shr  edx,22
  682. ;    mov  edx,[eax+4*edx]
  683. ;    and  edx,not (4096-1)
  684. ;    test edx,edx
  685. ;    jz   .failed1
  686. ;    push eax
  687. ;    mov  eax,edx
  688. ;    call MEM_Get_Linear_Address
  689. ;    mov  edx,ebx
  690. ;    shr  edx,12
  691. ;    and  edx,(1024-1)
  692. ;    mov  eax,[eax+4*edx]
  693. ;    and  eax,not (4096-1)
  694. ;    test eax,eax
  695. ;    pop  eax
  696. ;    jz   .failed1
  697. ;    add  ebx,4096
  698. ;    sub  ecx,4096
  699. ;    jg   .loop
  700. ;    pop  edx
  701. ;    pop  ecx
  702. ;    pop  ebx
  703. .ok:
  704.     mov  eax,1
  705.     ret
  706. ;
  707. ;.failed1:
  708. ;    pop  edx
  709. ;    pop  ecx
  710. ;    pop  ebx
  711. .failed:
  712.     xor  eax,eax
  713.     ret
  714.  
  715. align 4
  716. proc read_process_memory
  717. ;Input:
  718. ;  eax - process slot
  719. ;  ebx - buffer address
  720. ;  ecx - buffer size
  721. ;  edx - start address in other process
  722. ;Output:
  723. ;  eax - number of bytes read.
  724.        locals
  725.          slot   dd ?
  726.          buff   dd ?
  727.          r_count    dd ?
  728.          offset dd ?
  729.          tmp_r_cnt  dd ?
  730.        endl
  731.  
  732.        mov [slot], eax
  733.        mov [buff], ebx
  734.        and [r_count], 0
  735.        mov [tmp_r_cnt], ecx
  736.        mov [offset], edx
  737.  
  738.        pushad
  739. .read_mem:
  740.        mov edx, [offset]
  741.        mov ebx, [tmp_r_cnt]
  742.  
  743.        mov ecx, 0x400000
  744.        and edx, 0x3FFFFF
  745.        sub ecx, edx
  746.        cmp ecx, ebx
  747.        jbe @f
  748.        mov ecx, ebx
  749. @@:
  750.        cmp ecx, 0x8000
  751.        jna @F
  752.        mov ecx, 0x8000
  753. @@:
  754.        mov eax, [slot]
  755.        shl  eax,8
  756.        mov ebx, [offset]
  757.  
  758.        push ecx
  759.        stdcall map_memEx, [proc_mem_map],\
  760.                   [SLOT_BASE+eax+0xB8],\
  761.                   ebx, ecx
  762.        pop ecx
  763.  
  764.        mov esi, [offset]
  765.        and esi, 0xfff
  766.        add esi, [proc_mem_map]
  767.        mov edi, [buff]
  768.        mov edx, ecx
  769.        rep movsb
  770.        add [r_count], edx
  771.  
  772.        add [offset], edx
  773.        sub [tmp_r_cnt], edx
  774.        jnz .read_mem
  775.  
  776.        popad
  777.        mov eax, [r_count]
  778.        ret
  779. endp
  780.  
  781. align 4
  782. proc write_process_memory
  783. ;Input:
  784. ;  eax - process slot
  785. ;  ebx - buffer address
  786. ;  ecx - buffer size
  787. ;  edx - start address in other process
  788. ;Output:
  789. ;  eax - number of bytes written
  790.  
  791.        locals
  792.          slot   dd ?
  793.          buff   dd ?
  794.          w_count    dd ?
  795.          offset dd ?
  796.          tmp_w_cnt  dd ?
  797.        endl
  798.  
  799.        mov [slot], eax
  800.        mov [buff], ebx
  801.        and [w_count], 0
  802.        mov [tmp_w_cnt], ecx
  803.        mov [offset], edx
  804.  
  805.        pushad
  806. .read_mem:
  807.        mov edx, [offset]
  808.        mov ebx, [tmp_w_cnt]
  809.  
  810.        mov ecx, 0x400000
  811.        and edx, 0x3FFFFF
  812.        sub ecx, edx
  813.        cmp ecx, ebx
  814.        jbe @f
  815.        mov ecx, ebx
  816. @@:
  817.        cmp ecx, 0x8000
  818.        jna @F
  819.        mov ecx, 0x8000
  820. @@:
  821.        mov eax, [slot]
  822.        shl  eax,8
  823.        mov ebx, [offset]
  824.       ;     add ebx, new_app_base
  825.        push ecx
  826.        stdcall map_memEx, [proc_mem_map],\
  827.                   [SLOT_BASE+eax+0xB8],\
  828.                   ebx, ecx
  829.        pop ecx
  830.  
  831.        mov edi, [offset]
  832.        and edi, 0xfff
  833.        add edi, [proc_mem_map]
  834.        mov esi, [buff]
  835.        mov edx, ecx
  836.        rep movsb
  837.  
  838.        add [w_count], edx
  839.        add [offset], edx
  840.        sub [tmp_w_cnt], edx
  841.        jnz .read_mem
  842.  
  843.        popad
  844.        mov eax, [w_count]
  845.        ret
  846. endp
  847.  
  848. align 4
  849. proc new_sys_threads
  850.        locals
  851.          slot      dd ?
  852.          app_cmdline   dd ? ;0x00
  853.          app_path      dd ? ;0x04
  854.          app_eip       dd ? ;0x08
  855.          app_esp       dd ? ;0x0C
  856.          app_mem       dd ? ;0x10
  857.        endl
  858.  
  859.        cmp eax,1
  860.        jne .failed          ;other subfunctions
  861.  
  862.        xor  eax,eax
  863.        mov [app_cmdline], eax
  864.        mov [app_path], eax
  865.        mov [app_eip], ebx
  866.        mov [app_esp], ecx
  867.  
  868.        ;mov    esi,new_process_loading
  869.        ;call   sys_msg_board_str
  870. .wait_lock:
  871.        cmp [application_table_status],0
  872.        je .get_lock
  873.        call   change_task
  874.        jmp .wait_lock
  875.  
  876. .get_lock:
  877.        mov eax, 1
  878.        xchg eax, [application_table_status]
  879.        cmp eax, 0
  880.        jne .wait_lock
  881.  
  882.        call   set_application_table_status
  883.  
  884.        call get_new_process_place
  885.        test eax, eax
  886.        jz .failed
  887.  
  888.        mov [slot], eax
  889.  
  890.        mov    esi,[current_slot]
  891.        mov    ebx,esi         ;ebx=esi - pointer to extended information about current thread
  892.  
  893.        mov    edi, eax
  894.        shl    edi,8
  895.        add    edi,SLOT_BASE
  896.        mov    edx,edi         ;edx=edi - pointer to extended infomation about new thread
  897.        mov    ecx,256/4
  898.        xor eax, eax
  899.        cld
  900.        rep    stosd           ;clean extended information about new thread
  901.        mov    esi,ebx
  902.        mov    edi,edx
  903.        mov    ecx,11
  904.        rep    movsb           ;copy process name
  905.  
  906.        mov eax,[ebx+APPDATA.heap_base]
  907.        mov [edx+APPDATA.heap_base], eax
  908.  
  909.        mov ecx,[ebx+APPDATA.heap_top]
  910.        mov [edx+APPDATA.heap_top], ecx
  911.  
  912.        mov eax,[ebx+APPDATA.mem_size]
  913.        mov [edx+APPDATA.mem_size], eax
  914.  
  915.        mov ecx,[ebx+APPDATA.dir_table]
  916.        mov [edx+APPDATA.dir_table],ecx      ;copy page directory
  917.  
  918.        mov eax,[ebx+APPDATA.dlls_list_ptr]
  919.        mov [edx+APPDATA.dlls_list_ptr],eax
  920.  
  921.        mov eax, [ebx+APPDATA.tls_base]
  922.        test eax, eax
  923.        jz @F
  924.  
  925.        push edx
  926.        stdcall user_alloc, 4096
  927.        pop edx
  928.        test eax, eax
  929.        jz .failed
  930. @@:
  931.        mov [edx+APPDATA.tls_base], eax
  932.  
  933.        lea eax, [app_cmdline]
  934.        stdcall set_app_params ,[slot],eax,dword 0,\
  935.                      dword 0,dword 0
  936.  
  937.        ;mov    esi,new_process_running
  938.        ;call   sys_msg_board_str            ;output information about succefull startup
  939.  
  940.        mov    [application_table_status],0  ;unlock application_table_status mutex
  941.        mov    eax,[process_number]          ;set result
  942.        ret
  943. .failed:
  944.        mov    [application_table_status],0
  945.        mov    eax,-1
  946.        ret
  947. endp
  948.  
  949. ; param
  950. ;  ebx=mutex
  951.  
  952. align 4
  953. wait_mutex:
  954. ;;Maxis use atomic bts for mutex 4.4.2009
  955.        push eax
  956.        push ebx
  957. .do_wait:
  958.            bts dword [ebx],0
  959.            jnc .locked
  960.        call change_task
  961.        jmp .do_wait
  962. .locked:
  963.        pop ebx
  964.        pop eax
  965.        ret
  966.  
  967. align 4
  968. tls_app_entry:
  969.  
  970.         call init_heap
  971.         stdcall user_alloc, 4096
  972.  
  973.         mov edx, [current_slot]
  974.         mov [edx+APPDATA.tls_base], eax
  975.         mov [tls_data_l+2],ax
  976.         shr eax,16
  977.         mov [tls_data_l+4],al
  978.         mov [tls_data_l+7],ah
  979.         mov dx, app_tls
  980.         mov fs, dx
  981.         popad
  982.         iretd
  983.  
  984.  
  985. EFL_IF     equ 0x0200
  986. EFL_IOPL1   equ 0x1000
  987. EFL_IOPL2   equ 0x2000
  988. EFL_IOPL3   equ 0x3000
  989.  
  990.  
  991. align 4
  992. proc set_app_params stdcall,slot:dword, params:dword,\
  993.             cmd_line:dword, app_path:dword, flags:dword
  994.  
  995.        locals
  996.          pl0_stack dd ?
  997.        endl
  998.  
  999.        stdcall kernel_alloc, RING0_STACK_SIZE+512
  1000.        mov [pl0_stack], eax
  1001.  
  1002.        lea edi, [eax+RING0_STACK_SIZE]
  1003.  
  1004.        mov eax, [slot]
  1005.        mov ebx, eax
  1006.  
  1007.        shl eax, 8
  1008.        mov [eax+SLOT_BASE+APPDATA.fpu_state], edi
  1009.        mov [eax+SLOT_BASE+APPDATA.exc_handler], 0
  1010.        mov [eax+SLOT_BASE+APPDATA.except_mask], 0
  1011.  
  1012. ;set default io permission map
  1013.        mov ecx, [SLOT_BASE+256+APPDATA.io_map]
  1014.        mov [eax+SLOT_BASE+APPDATA.io_map], ecx
  1015.        mov ecx, [SLOT_BASE+256+APPDATA.io_map+4]
  1016.        mov [eax+SLOT_BASE+APPDATA.io_map+4], ecx
  1017.  
  1018.        mov esi, fpu_data
  1019.        mov ecx, 512/4
  1020.        rep movsd
  1021.  
  1022.        cmp    ebx,[TASK_COUNT]
  1023.        jle    .noinc
  1024.        inc    dword [TASK_COUNT]       ;update number of processes
  1025. .noinc:
  1026.        shl ebx,8
  1027.        lea edx, [ebx+SLOT_BASE+APP_EV_OFFSET]
  1028.        mov [SLOT_BASE+APPDATA.fd_ev+ebx],edx
  1029.        mov [SLOT_BASE+APPDATA.bk_ev+ebx],edx
  1030.  
  1031.        add edx, APP_OBJ_OFFSET-APP_EV_OFFSET
  1032.        mov [SLOT_BASE+APPDATA.fd_obj+ebx],edx
  1033.        mov [SLOT_BASE+APPDATA.bk_obj+ebx],edx
  1034.  
  1035.        mov ecx, [def_cursor]
  1036.        mov [SLOT_BASE+APPDATA.cursor+ebx],ecx
  1037.        mov eax, [pl0_stack]
  1038.        mov [SLOT_BASE+APPDATA.pl0_stack+ebx],eax
  1039.        add eax, RING0_STACK_SIZE
  1040.        mov [SLOT_BASE+APPDATA.saved_esp0+ebx], eax
  1041.  
  1042.        push ebx
  1043.        stdcall kernel_alloc, 0x1000
  1044.        pop ebx
  1045.        mov esi,[current_slot]
  1046.        mov esi,[esi+APPDATA.cur_dir]
  1047.        mov ecx,0x1000/4
  1048.        mov edi,eax
  1049.        mov [ebx+SLOT_BASE+APPDATA.cur_dir],eax
  1050.        rep movsd
  1051.  
  1052.        shr ebx,3
  1053.        mov eax, new_app_base
  1054.        mov dword [CURRENT_TASK+ebx+0x10],eax
  1055.  
  1056. .add_command_line:
  1057.        mov edx,[params]
  1058.        mov edx,[edx]       ;app_cmdline
  1059.        test edx,edx
  1060.        jz @f           ;application doesn't need parameters
  1061.  
  1062.        mov     eax, edx
  1063.        add     eax, 256
  1064.        jc      @f
  1065.  
  1066.        cmp     eax, [SLOT_BASE+APPDATA.mem_size+ebx*8]
  1067.        ja      @f
  1068.  
  1069.        mov     byte [edx], 0   ;force empty string if no cmdline given
  1070.        mov     eax, [cmd_line]
  1071.        test    eax, eax
  1072.        jz      @f
  1073.        stdcall strncpy, edx, eax, 256
  1074. @@:
  1075.        mov edx,[params]
  1076.        mov edx, [edx+4]    ;app_path
  1077.        test edx,edx
  1078.        jz @F           ;application don't need path of file
  1079.        mov     eax, edx
  1080.        add     eax, 1024
  1081.        jc      @f
  1082.        cmp     eax, [SLOT_BASE+APPDATA.mem_size+ebx*8]
  1083.        ja      @f
  1084.        stdcall strncpy, edx, [app_path], 1024
  1085. @@:
  1086.        mov    ebx,[slot]
  1087.        mov    eax,ebx
  1088.        shl    ebx,5
  1089.        lea    ecx,[draw_data+ebx]  ;ecx - pointer to draw data
  1090.  
  1091.        mov edx, irq0.return
  1092.        cmp [ebx*8+SLOT_BASE+APPDATA.tls_base], -1
  1093.        jne @F
  1094.        mov edx, tls_app_entry
  1095. @@:
  1096. ; set window state to 'normal' (non-minimized/maximized/rolled-up) state
  1097.        mov     [ebx+window_data+WDATA.fl_wstate], WSTATE_NORMAL
  1098.        mov     [ebx+window_data+WDATA.fl_redraw], 1
  1099.        add    ebx,CURRENT_TASK        ;ebx - pointer to information about process
  1100.        mov    [ebx+TASKDATA.wnd_number],al;set window number on screen = process slot
  1101.  
  1102.        mov    [ebx+TASKDATA.event_mask],dword 1+2+4 ;set default event flags (see 40 function)
  1103.  
  1104.        inc    dword [process_number]
  1105.        mov    eax,[process_number]
  1106.        mov    [ebx+4],eax       ;set PID
  1107.  
  1108. ;set draw data to full screen
  1109.  
  1110.        mov    [ecx+0],dword 0
  1111.        mov    [ecx+4],dword 0
  1112.        mov    eax,[Screen_Max_X]
  1113.        mov    [ecx+8],eax
  1114.        mov    eax,[Screen_Max_Y]
  1115.        mov    [ecx+12],eax
  1116.  
  1117.        mov ebx, [pl0_stack]
  1118.        mov esi,[params]
  1119.        lea ecx, [ebx+REG_EIP]
  1120.        xor eax, eax
  1121.  
  1122.        mov [ebx+REG_RET], edx
  1123.        mov [ebx+REG_EDI], eax
  1124.        mov [ebx+REG_ESI], eax
  1125.        mov [ebx+REG_EBP], eax
  1126.        mov [ebx+REG_ESP], ecx   ;ebx+REG_EIP
  1127.        mov [ebx+REG_EBX], eax
  1128.        mov [ebx+REG_EDX], eax
  1129.        mov [ebx+REG_ECX], eax
  1130.        mov [ebx+REG_EAX], eax
  1131.  
  1132.        mov eax, [esi+0x08]       ;app_eip
  1133.        mov [ebx+REG_EIP],  eax   ;app_entry
  1134.        mov [ebx+REG_CS], dword app_code
  1135.        mov [ebx+REG_EFLAGS], dword EFL_IOPL1+EFL_IF
  1136.  
  1137.        mov eax, [esi+0x0C]       ;app_esp
  1138.        mov [ebx+REG_APP_ESP], eax    ;app_stack
  1139.        mov [ebx+REG_SS], dword app_data
  1140.  
  1141.        lea ecx, [ebx+REG_RET]
  1142.        mov ebx, [slot]
  1143.        shl ebx, 5
  1144.        mov [ebx*8+SLOT_BASE+APPDATA.saved_esp], ecx
  1145.  
  1146.        xor  ecx, ecx    ; process state - running
  1147. ; set if debuggee
  1148.        test byte [flags], 1
  1149.        jz   .no_debug
  1150.        inc  ecx     ; process state - suspended
  1151.        mov  eax,[CURRENT_TASK]
  1152.        mov  [SLOT_BASE+ebx*8+APPDATA.debugger_slot],eax
  1153. .no_debug:
  1154.        mov  [CURRENT_TASK+ebx+TASKDATA.state], cl
  1155.        ;mov    esi,new_process_running
  1156.        ;call   sys_msg_board_str     ;output information about succefull startup
  1157.        ret
  1158. endp
  1159.  
  1160. include "debug.inc"
  1161.