Subversion Repositories Kolibri OS

Rev

Rev 1311 | Rev 1322 | 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: 1314 $
  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 ebx, [offset]
  755.  
  756.        push ecx
  757.        stdcall map_memEx, [proc_mem_map],\
  758.                   [slot], ebx, ecx, PG_MAP
  759.        pop ecx
  760.  
  761.        mov esi, [offset]
  762.        and esi, 0xfff
  763.        sub eax, esi
  764.        jbe .ret
  765.        cmp ecx, eax
  766.        jbe @f
  767.        mov ecx, eax
  768.        mov [tmp_r_cnt], eax
  769. @@:
  770.        add esi, [proc_mem_map]
  771.        mov edi, [buff]
  772.        mov edx, ecx
  773.        rep movsb
  774.        add [r_count], edx
  775.  
  776.        add [offset], edx
  777.        sub [tmp_r_cnt], edx
  778.        jnz .read_mem
  779. .ret:
  780.        popad
  781.        mov eax, [r_count]
  782.        ret
  783. endp
  784.  
  785. align 4
  786. proc write_process_memory
  787. ;Input:
  788. ;  eax - process slot
  789. ;  ebx - buffer address
  790. ;  ecx - buffer size
  791. ;  edx - start address in other process
  792. ;Output:
  793. ;  eax - number of bytes written
  794.  
  795.        locals
  796.          slot   dd ?
  797.          buff   dd ?
  798.          w_count    dd ?
  799.          offset dd ?
  800.          tmp_w_cnt  dd ?
  801.        endl
  802.  
  803.        mov [slot], eax
  804.        mov [buff], ebx
  805.        and [w_count], 0
  806.        mov [tmp_w_cnt], ecx
  807.        mov [offset], edx
  808.  
  809.        pushad
  810. .read_mem:
  811.        mov edx, [offset]
  812.        mov ebx, [tmp_w_cnt]
  813.  
  814.        mov ecx, 0x400000
  815.        and edx, 0x3FFFFF
  816.        sub ecx, edx
  817.        cmp ecx, ebx
  818.        jbe @f
  819.        mov ecx, ebx
  820. @@:
  821.        cmp ecx, 0x8000
  822.        jna @F
  823.        mov ecx, 0x8000
  824. @@:
  825.        mov ebx, [offset]
  826.       ;     add ebx, new_app_base
  827.        push ecx
  828.        stdcall map_memEx, [proc_mem_map],\
  829.                   [slot], ebx, ecx, PG_SW
  830.        pop ecx
  831.  
  832.        mov edi, [offset]
  833.        and edi, 0xfff
  834.        sub eax, edi
  835.        jbe .ret
  836.        cmp ecx, eax
  837.        jbe @f
  838.        mov ecx, eax
  839.        mov [tmp_w_cnt], eax
  840. @@:
  841.        add edi, [proc_mem_map]
  842.        mov esi, [buff]
  843.        mov edx, ecx
  844.        rep movsb
  845.  
  846.        add [w_count], edx
  847.        add [offset], edx
  848.        sub [tmp_w_cnt], edx
  849.        jnz .read_mem
  850. .ret:
  851.        popad
  852.        mov eax, [w_count]
  853.        ret
  854. endp
  855.  
  856. align 4
  857. proc new_sys_threads
  858.        locals
  859.          slot      dd ?
  860.          app_cmdline   dd ? ;0x00
  861.          app_path      dd ? ;0x04
  862.          app_eip       dd ? ;0x08
  863.          app_esp       dd ? ;0x0C
  864.          app_mem       dd ? ;0x10
  865.        endl
  866.  
  867.        cmp eax,1
  868.        jne .failed          ;other subfunctions
  869.  
  870.        xor  eax,eax
  871.        mov [app_cmdline], eax
  872.        mov [app_path], eax
  873.        mov [app_eip], ebx
  874.        mov [app_esp], ecx
  875.  
  876.        ;mov    esi,new_process_loading
  877.        ;call   sys_msg_board_str
  878. .wait_lock:
  879.        cmp [application_table_status],0
  880.        je .get_lock
  881.        call   change_task
  882.        jmp .wait_lock
  883.  
  884. .get_lock:
  885.        mov eax, 1
  886.        xchg eax, [application_table_status]
  887.        cmp eax, 0
  888.        jne .wait_lock
  889.  
  890.        call   set_application_table_status
  891.  
  892.        call get_new_process_place
  893.        test eax, eax
  894.        jz .failed
  895.  
  896.        mov [slot], eax
  897.  
  898.        mov    esi,[current_slot]
  899.        mov    ebx,esi         ;ebx=esi - pointer to extended information about current thread
  900.  
  901.        mov    edi, eax
  902.        shl    edi,8
  903.        add    edi,SLOT_BASE
  904.        mov    edx,edi         ;edx=edi - pointer to extended infomation about new thread
  905.        mov    ecx,256/4
  906.        xor eax, eax
  907.        cld
  908.        rep    stosd           ;clean extended information about new thread
  909.        mov    esi,ebx
  910.        mov    edi,edx
  911.        mov    ecx,11
  912.        rep    movsb           ;copy process name
  913.  
  914.        mov eax,[ebx+APPDATA.heap_base]
  915.        mov [edx+APPDATA.heap_base], eax
  916.  
  917.        mov ecx,[ebx+APPDATA.heap_top]
  918.        mov [edx+APPDATA.heap_top], ecx
  919.  
  920.        mov eax,[ebx+APPDATA.mem_size]
  921.        mov [edx+APPDATA.mem_size], eax
  922.  
  923.        mov ecx,[ebx+APPDATA.dir_table]
  924.        mov [edx+APPDATA.dir_table],ecx      ;copy page directory
  925.  
  926.        mov eax,[ebx+APPDATA.dlls_list_ptr]
  927.        mov [edx+APPDATA.dlls_list_ptr],eax
  928.  
  929.        mov eax, [ebx+APPDATA.tls_base]
  930.        test eax, eax
  931.        jz @F
  932.  
  933.        push edx
  934.        stdcall user_alloc, 4096
  935.        pop edx
  936.        test eax, eax
  937.        jz .failed
  938. @@:
  939.        mov [edx+APPDATA.tls_base], eax
  940.  
  941.        lea eax, [app_cmdline]
  942.        stdcall set_app_params ,[slot],eax,dword 0,\
  943.                      dword 0,dword 0
  944.  
  945.        ;mov    esi,new_process_running
  946.        ;call   sys_msg_board_str            ;output information about succefull startup
  947.  
  948.        mov    [application_table_status],0  ;unlock application_table_status mutex
  949.        mov    eax,[process_number]          ;set result
  950.        ret
  951. .failed:
  952.        mov    [application_table_status],0
  953.        mov    eax,-1
  954.        ret
  955. endp
  956.  
  957. ; param
  958. ;  ebx=mutex
  959.  
  960. align 4
  961. wait_mutex:
  962. ;;Maxis use atomic bts for mutex 4.4.2009
  963.        push eax
  964.        push ebx
  965. .do_wait:
  966.            bts dword [ebx],0
  967.            jnc .locked
  968.        call change_task
  969.        jmp .do_wait
  970. .locked:
  971.        pop ebx
  972.        pop eax
  973.        ret
  974.  
  975. align 4
  976. tls_app_entry:
  977.  
  978.         call init_heap
  979.         stdcall user_alloc, 4096
  980.  
  981.         mov edx, [current_slot]
  982.         mov [edx+APPDATA.tls_base], eax
  983.         mov [tls_data_l+2],ax
  984.         shr eax,16
  985.         mov [tls_data_l+4],al
  986.         mov [tls_data_l+7],ah
  987.         mov dx, app_tls
  988.         mov fs, dx
  989.         popad
  990.         iretd
  991.  
  992.  
  993. EFL_IF     equ 0x0200
  994. EFL_IOPL1   equ 0x1000
  995. EFL_IOPL2   equ 0x2000
  996. EFL_IOPL3   equ 0x3000
  997.  
  998.  
  999. align 4
  1000. proc set_app_params stdcall,slot:dword, params:dword,\
  1001.             cmd_line:dword, app_path:dword, flags:dword
  1002.  
  1003.        locals
  1004.          pl0_stack dd ?
  1005.        endl
  1006.  
  1007.        stdcall kernel_alloc, RING0_STACK_SIZE+512
  1008.        mov [pl0_stack], eax
  1009.  
  1010.        lea edi, [eax+RING0_STACK_SIZE]
  1011.  
  1012.        mov eax, [slot]
  1013.        mov ebx, eax
  1014.  
  1015.        shl eax, 8
  1016.        mov [eax+SLOT_BASE+APPDATA.fpu_state], edi
  1017.        mov [eax+SLOT_BASE+APPDATA.exc_handler], 0
  1018.        mov [eax+SLOT_BASE+APPDATA.except_mask], 0
  1019.  
  1020. ;set default io permission map
  1021.        mov ecx, [SLOT_BASE+256+APPDATA.io_map]
  1022.        mov [eax+SLOT_BASE+APPDATA.io_map], ecx
  1023.        mov ecx, [SLOT_BASE+256+APPDATA.io_map+4]
  1024.        mov [eax+SLOT_BASE+APPDATA.io_map+4], ecx
  1025.  
  1026.        mov esi, fpu_data
  1027.        mov ecx, 512/4
  1028.        rep movsd
  1029.  
  1030.        cmp    ebx,[TASK_COUNT]
  1031.        jle    .noinc
  1032.        inc    dword [TASK_COUNT]       ;update number of processes
  1033. .noinc:
  1034.        shl ebx,8
  1035.        lea edx, [ebx+SLOT_BASE+APP_EV_OFFSET]
  1036.        mov [SLOT_BASE+APPDATA.fd_ev+ebx],edx
  1037.        mov [SLOT_BASE+APPDATA.bk_ev+ebx],edx
  1038.  
  1039.        add edx, APP_OBJ_OFFSET-APP_EV_OFFSET
  1040.        mov [SLOT_BASE+APPDATA.fd_obj+ebx],edx
  1041.        mov [SLOT_BASE+APPDATA.bk_obj+ebx],edx
  1042.  
  1043.        mov ecx, [def_cursor]
  1044.        mov [SLOT_BASE+APPDATA.cursor+ebx],ecx
  1045.        mov eax, [pl0_stack]
  1046.        mov [SLOT_BASE+APPDATA.pl0_stack+ebx],eax
  1047.        add eax, RING0_STACK_SIZE
  1048.        mov [SLOT_BASE+APPDATA.saved_esp0+ebx], eax
  1049.  
  1050.        push ebx
  1051.        stdcall kernel_alloc, 0x1000
  1052.        pop ebx
  1053.        mov esi,[current_slot]
  1054.        mov esi,[esi+APPDATA.cur_dir]
  1055.        mov ecx,0x1000/4
  1056.        mov edi,eax
  1057.        mov [ebx+SLOT_BASE+APPDATA.cur_dir],eax
  1058.        rep movsd
  1059.  
  1060.        shr ebx,3
  1061.        mov eax, new_app_base
  1062.        mov dword [CURRENT_TASK+ebx+0x10],eax
  1063.  
  1064. .add_command_line:
  1065.        mov edx,[params]
  1066.        mov edx,[edx]       ;app_cmdline
  1067.        test edx,edx
  1068.        jz @f           ;application doesn't need parameters
  1069.  
  1070.        mov     eax, edx
  1071.        add     eax, 256
  1072.        jc      @f
  1073.  
  1074.        cmp     eax, [SLOT_BASE+APPDATA.mem_size+ebx*8]
  1075.        ja      @f
  1076.  
  1077.        mov     byte [edx], 0   ;force empty string if no cmdline given
  1078.        mov     eax, [cmd_line]
  1079.        test    eax, eax
  1080.        jz      @f
  1081.        stdcall strncpy, edx, eax, 256
  1082. @@:
  1083.        mov edx,[params]
  1084.        mov edx, [edx+4]    ;app_path
  1085.        test edx,edx
  1086.        jz @F           ;application don't need path of file
  1087.        mov     eax, edx
  1088.        add     eax, 1024
  1089.        jc      @f
  1090.        cmp     eax, [SLOT_BASE+APPDATA.mem_size+ebx*8]
  1091.        ja      @f
  1092.        stdcall strncpy, edx, [app_path], 1024
  1093. @@:
  1094.        mov    ebx,[slot]
  1095.        mov    eax,ebx
  1096.        shl    ebx,5
  1097.        lea    ecx,[draw_data+ebx]  ;ecx - pointer to draw data
  1098.  
  1099.        mov edx, irq0.return
  1100.        cmp [ebx*8+SLOT_BASE+APPDATA.tls_base], -1
  1101.        jne @F
  1102.        mov edx, tls_app_entry
  1103. @@:
  1104. ; set window state to 'normal' (non-minimized/maximized/rolled-up) state
  1105.        mov     [ebx+window_data+WDATA.fl_wstate], WSTATE_NORMAL
  1106.        mov     [ebx+window_data+WDATA.fl_redraw], 1
  1107.        add    ebx,CURRENT_TASK        ;ebx - pointer to information about process
  1108.        mov    [ebx+TASKDATA.wnd_number],al;set window number on screen = process slot
  1109.  
  1110.        mov    [ebx+TASKDATA.event_mask],dword 1+2+4 ;set default event flags (see 40 function)
  1111.  
  1112.        inc    dword [process_number]
  1113.        mov    eax,[process_number]
  1114.        mov    [ebx+4],eax       ;set PID
  1115.  
  1116. ;set draw data to full screen
  1117.  
  1118.        mov    [ecx+0],dword 0
  1119.        mov    [ecx+4],dword 0
  1120.        mov    eax,[Screen_Max_X]
  1121.        mov    [ecx+8],eax
  1122.        mov    eax,[Screen_Max_Y]
  1123.        mov    [ecx+12],eax
  1124.  
  1125.        mov ebx, [pl0_stack]
  1126.        mov esi,[params]
  1127.        lea ecx, [ebx+REG_EIP]
  1128.        xor eax, eax
  1129.  
  1130.        mov [ebx+REG_RET], edx
  1131.        mov [ebx+REG_EDI], eax
  1132.        mov [ebx+REG_ESI], eax
  1133.        mov [ebx+REG_EBP], eax
  1134.        mov [ebx+REG_ESP], ecx   ;ebx+REG_EIP
  1135.        mov [ebx+REG_EBX], eax
  1136.        mov [ebx+REG_EDX], eax
  1137.        mov [ebx+REG_ECX], eax
  1138.        mov [ebx+REG_EAX], eax
  1139.  
  1140.        mov eax, [esi+0x08]       ;app_eip
  1141.        mov [ebx+REG_EIP],  eax   ;app_entry
  1142.        mov [ebx+REG_CS], dword app_code
  1143.        mov [ebx+REG_EFLAGS], dword EFL_IOPL1+EFL_IF
  1144.  
  1145.        mov eax, [esi+0x0C]       ;app_esp
  1146.        mov [ebx+REG_APP_ESP], eax    ;app_stack
  1147.        mov [ebx+REG_SS], dword app_data
  1148.  
  1149.        lea ecx, [ebx+REG_RET]
  1150.        mov ebx, [slot]
  1151.        shl ebx, 5
  1152.        mov [ebx*8+SLOT_BASE+APPDATA.saved_esp], ecx
  1153.  
  1154.        xor  ecx, ecx    ; process state - running
  1155. ; set if debuggee
  1156.        test byte [flags], 1
  1157.        jz   .no_debug
  1158.        inc  ecx     ; process state - suspended
  1159.        mov  eax,[CURRENT_TASK]
  1160.        mov  [SLOT_BASE+ebx*8+APPDATA.debugger_slot],eax
  1161. .no_debug:
  1162.        mov  [CURRENT_TASK+ebx+TASKDATA.state], cl
  1163.        ;mov    esi,new_process_running
  1164.        ;call   sys_msg_board_str     ;output information about succefull startup
  1165.        ret
  1166. endp
  1167.  
  1168. include "debug.inc"
  1169.