Subversion Repositories Kolibri OS

Rev

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

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