Subversion Repositories Kolibri OS

Rev

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

  1. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  2. ;;                                                              ;;
  3. ;; Copyright (C) KolibriOS team 2004-2015. All rights reserved. ;;
  4. ;; Distributed under terms of the GNU General Public License    ;;
  5. ;;                                                              ;;
  6. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  7.  
  8. $Revision: 5595 $
  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_proc     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    alloc_thread_slot
  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, [current_process]
  252.         mov     [save_proc], ebx
  253.  
  254.         stdcall create_process, [hdr_mem], [file_base], [file_size]
  255.         mov     esi, -30; no memory
  256.         test    eax, eax
  257.         jz      .failed
  258.  
  259.         mov     ebx, [hdr_mem]
  260.         mov     [eax+PROC.mem_used], ebx
  261.  
  262.         mov     ebx, [slot_base]
  263.         mov     [ebx+APPDATA.process], eax
  264.  
  265.         lea     edx, [ebx+APPDATA.list]
  266.         lea     ecx, [eax+PROC.thr_list]
  267.         list_add_tail edx, ecx
  268.  
  269.         xor     edx, edx
  270.         cmp     word [6], '02'
  271.         jne     @f
  272.  
  273.         not     edx
  274. @@:
  275.         mov     [ebx+APPDATA.tls_base], edx
  276.  
  277. if GREEDY_KERNEL
  278. else
  279.         mov     ecx, [hdr_mem]
  280.         mov     edi, [file_size]
  281.         add     edi, 4095
  282.         and     edi, not 4095
  283.         sub     ecx, edi
  284.         jna     @F
  285.  
  286.         xor     eax, eax
  287.         cld
  288.         rep stosb
  289. @@:
  290. end if
  291.  
  292. ; release only virtual space, not phisical memory
  293.  
  294.         stdcall free_kernel_space, [file_base]
  295.         lea     eax, [hdr_cmdline]
  296.         lea     ebx, [cmdline]
  297.         lea     ecx, [filename]
  298.         stdcall set_app_params , [slot], eax, ebx, ecx, [flags]
  299.  
  300.         mov     eax, [save_proc]
  301.         call    set_cr3
  302.  
  303.         mov     eax, [process_number];set result
  304.         call    unlock_application_table
  305.  
  306.         jmp     .final
  307.  
  308. .failed:
  309.         mov     eax, [save_proc]
  310.         call    set_cr3
  311. .err:
  312. .err_hdr:
  313.         stdcall kernel_free, [file_base]
  314. .err_file:
  315.         call    unlock_application_table
  316.         mov     eax, esi
  317. .final:
  318.         cmp     [SCR_MODE], word 0x13
  319.         jbe     @f
  320.         pushad
  321.         stdcall set_cursor, [handle]
  322.         mov     [redrawmouse_unconditional], 1
  323.         call    wakeup_osloop
  324.         popad
  325. @@:
  326.         ret
  327. endp
  328.  
  329. align 4
  330. test_app_header:
  331.        virtual at eax
  332.          APP_HEADER_00 APP_HEADER_00_
  333.        end virtual
  334.        virtual at eax
  335.          APP_HEADER_01 APP_HEADER_01_
  336.        end virtual
  337.  
  338.         cmp     dword [eax], 'MENU'
  339.         jne     .fail
  340.         cmp     word [eax+4], 'ET'
  341.         jne     .fail
  342.  
  343.         cmp     [eax+6], word '00'
  344.         jne     .check_01_header
  345.  
  346.         mov     ecx, [APP_HEADER_00.start]
  347.         mov     [ebx+0x08], ecx             ;app_eip
  348.         mov     edx, [APP_HEADER_00.mem_size]
  349.         mov     [ebx+0x10], edx             ;app_mem
  350.         shr     edx, 1
  351.         sub     edx, 0x10
  352.         mov     [ebx+0x0C], edx             ;app_esp
  353.         mov     ecx, [APP_HEADER_00.i_param]
  354.         mov     [ebx], ecx                  ;app_cmdline
  355.         mov     [ebx+4], dword 0            ;app_path
  356.         mov     edx, [APP_HEADER_00.i_end]
  357.         mov     [ebx+0x14], edx
  358.         ret
  359.  
  360.  .check_01_header:
  361.  
  362.         cmp     [eax+6], word '01'
  363.         je      @f
  364.         cmp     [eax+6], word '02'
  365.         jne     .fail
  366. @@:
  367.         mov     ecx, [APP_HEADER_01.start]
  368.         mov     [ebx+0x08], ecx             ;app_eip
  369.         mov     edx, [APP_HEADER_01.mem_size]
  370.  
  371. ; \begin{diamond}[20.08.2006]
  372. ; sanity check (functions 19,58 load app_i_end bytes and that must
  373. ; fit in allocated memory to prevent kernel faults)
  374.         cmp     edx, [APP_HEADER_01.i_end]
  375.         jb      .fail
  376. ; \end{diamond}[20.08.2006]
  377.  
  378.         mov     [ebx+0x10], edx             ;app_mem
  379.         mov     ecx, [APP_HEADER_01.stack_top]
  380.         mov     [ebx+0x0C], ecx             ;app_esp
  381.         mov     edx, [APP_HEADER_01.i_param]
  382.         mov     [ebx], edx                  ;app_cmdline
  383.         mov     ecx, [APP_HEADER_01.i_icon]
  384.         mov     [ebx+4], ecx                ;app_path
  385.         mov     edx, [APP_HEADER_01.i_end]
  386.         mov     [ebx+0x14], edx
  387.         ret
  388. .fail:
  389.         xor     eax, eax
  390.         ret
  391.  
  392. align 4
  393. alloc_thread_slot:
  394. ;input:
  395. ;  none
  396. ;result:
  397. ;  eax=[new_thread_slot]<>0 - ok
  398. ;      0 - failed.
  399. ;This function find least empty slot.
  400. ;It doesn't increase [TASK_COUNT]!
  401.  
  402.  
  403.         mov     edx, thr_slot_map
  404.         pushfd
  405.         cli
  406. .l1:
  407.         bsf     eax, [edx]
  408.         jnz     .found
  409.         add     edx, 4
  410.         cmp     edx, thr_slot_map+32
  411.         jb      .l1
  412.  
  413.         popfd
  414.         xor     eax, eax
  415.         ret
  416. .found:
  417.         btr     [edx], eax
  418.         sub     edx, thr_slot_map
  419.         lea     eax, [eax+edx*8]
  420.         popfd
  421.         ret
  422.  
  423.  
  424. align 4
  425. proc create_process stdcall, app_size:dword,img_base:dword,img_size:dword
  426.        locals
  427.          app_pages   dd ?
  428.          img_pages   dd ?
  429.          process     dd ?
  430.          app_tabs    dd ?
  431.        endl
  432.  
  433.         push    ebx
  434.         push    esi
  435.         push    edi
  436.  
  437.         mov     ecx, pg_data.mutex
  438.         call    mutex_lock
  439.  
  440.         xor     eax, eax
  441.         mov     [process], eax
  442.  
  443.         mov     eax, [app_size]
  444.         add     eax, 4095
  445.         and     eax, NOT(4095)
  446.         mov     [app_size], eax
  447.         mov     ebx, eax
  448.         shr     eax, 12
  449.         mov     [app_pages], eax
  450.  
  451.         add     ebx, 0x3FFFFF
  452.         and     ebx, NOT(0x3FFFFF)
  453.         shr     ebx, 22
  454.         mov     [app_tabs], ebx
  455.  
  456.         mov     ecx, [img_size]
  457.         add     ecx, 4095
  458.         and     ecx, NOT(4095)
  459.  
  460.         mov     [img_size], ecx
  461.         shr     ecx, 12
  462.         mov     [img_pages], ecx
  463.  
  464.         lea     eax, [eax+ebx+2];all requested memory
  465.  
  466.         cmp     eax, [pg_data.pages_free]
  467.         ja      .fail
  468.  
  469.         stdcall kernel_alloc, 0x2000
  470.         test    eax, eax
  471.         jz      .fail
  472.         mov     [process], eax
  473.  
  474.         lea     edi, [eax+PROC.heap_lock]
  475.         mov     ecx, (PROC.ht_free-PROC.heap_lock)/4
  476.  
  477.         list_init eax
  478.         add     eax, PROC.thr_list
  479.         list_init eax
  480.  
  481.         xor     eax, eax
  482.         cld
  483.         rep stosd
  484.  
  485.         mov     [edi], dword (PROC.pdt_0 - PROC.htab)/4 - 3
  486.         mov     [edi+4], dword 3           ;reserve handles for stdin stdout and stderr
  487.         mov     ecx, (PROC.pdt_0 - PROC.htab)/4
  488.         add     edi, 8
  489.         inc     eax
  490. @@:
  491.         stosd
  492.         inc     eax
  493.         cmp     eax, ecx
  494.         jbe     @B
  495.  
  496.         mov     eax, edi
  497.         call    get_pg_addr
  498.         mov     [edi-4096+PROC.pdt_0_phys], eax
  499.  
  500.         mov     ecx, (OS_BASE shr 20)/4
  501.         xor     eax, eax
  502.         rep stosd
  503.  
  504.         mov     ecx, (OS_BASE shr 20)/4
  505.         mov     esi, sys_proc+PROC.pdt_0+(OS_BASE shr 20)
  506.         rep movsd
  507.  
  508.         mov     eax, [edi-8192+PROC.pdt_0_phys]
  509.         or      eax, PG_SWR
  510.         mov     [edi-4096+(page_tabs shr 20)], eax
  511.  
  512.         lea     eax, [edi-8192]
  513.         call    set_cr3
  514.  
  515.         mov     edx, [app_tabs]
  516.         xor     edi, edi
  517. @@:
  518.         call    alloc_page
  519.         test    eax, eax
  520.         jz      .fail
  521.  
  522.         stdcall map_page_table, edi, eax
  523.         add     edi, 0x00400000
  524.         dec     edx
  525.         jnz     @B
  526.  
  527.         mov     edi, page_tabs
  528.  
  529.         mov     ecx, [app_tabs]
  530.         shl     ecx, 10
  531.         xor     eax, eax
  532.         rep stosd
  533.  
  534.         mov     ecx, [img_pages]
  535.         mov     ebx, PG_UWR
  536.         xor     edx, edx
  537.         mov     esi, [img_base]
  538.         shr     esi, 10
  539.         add     esi, page_tabs
  540.         mov     edi, page_tabs
  541. .remap:
  542.         lodsd
  543.         and     eax, 0xFFFFF000
  544.         or      eax, ebx; force user level r/w access
  545.         stosd
  546.         add     edx, 0x1000
  547.         dec     [app_pages]
  548.         dec     ecx
  549.         jnz     .remap
  550.  
  551.         mov     ecx, [app_pages]
  552.         test    ecx, ecx
  553.         jz      .done
  554.  
  555. .alloc:
  556.         call    alloc_page
  557.         test    eax, eax
  558.         jz      .fail
  559.  
  560.         stdcall map_page, edx, eax, dword PG_UWR
  561.         add     edx, 0x1000
  562.         dec     [app_pages]
  563.         jnz     .alloc
  564.  
  565. .done:
  566.         mov     ecx, pg_data.mutex
  567.         call    mutex_unlock
  568.         mov     eax, [process]
  569.  
  570.         pop     edi
  571.         pop     esi
  572.         pop     ebx
  573.         ret
  574. .fail:
  575.         mov     ecx, pg_data.mutex
  576.         call    mutex_unlock
  577.         cmp     [process], 0
  578.         je      @f
  579. ;;        stdcall destroy_app_space, [dir_addr], 0
  580. @@:
  581.         xor     eax, eax
  582.         pop     edi
  583.         pop     esi
  584.         pop     ebx
  585.         ret
  586. endp
  587.  
  588. align 4
  589. set_cr3:
  590.         pushfd
  591.         cli
  592.         mov     ebx, [current_slot]
  593.         mov     [current_process], eax
  594.         mov     [ebx+APPDATA.process], eax
  595.         mov     eax, [eax+PROC.pdt_0_phys]
  596.         mov     cr3, eax
  597.         popfd
  598.         ret
  599.  
  600. align 4
  601. proc destroy_page_table stdcall, pg_tab:dword
  602.  
  603.         push    esi
  604.  
  605.         mov     esi, [pg_tab]
  606.         mov     ecx, 1024
  607. .free:
  608.         mov     eax, [esi]
  609.         test    eax, 1
  610.         jz      .next
  611.         test    eax, 2
  612.         jz      .next
  613.         test    eax, 1 shl 9
  614.         jnz     .next                     ;skip shared pages
  615.         call    free_page
  616. .next:
  617.         add     esi, 4
  618.         dec     ecx
  619.         jnz     .free
  620.         pop     esi
  621.         ret
  622. endp
  623.  
  624. align 4
  625. destroy_process: ;fastcall ecx= ptr to process
  626.  
  627.         lea     eax, [ecx+PROC.thr_list]
  628.         cmp     eax, [eax+LHEAD.next]
  629.         jne     .exit
  630.  
  631. align 4
  632. .internal:
  633.         push    ecx
  634.  
  635.         mov     esi, [ecx+PROC.dlls_list_ptr]
  636.         call    destroy_all_hdlls
  637.  
  638. ;        mov     ecx, pg_data.mutex
  639. ;        call    mutex_lock
  640.  
  641.         mov     esi, [esp]
  642.         add     esi, PROC.pdt_0
  643.         mov     edi, (0x80000000 shr 20)/4
  644. .destroy:
  645.         mov     eax, [esi]
  646.         test    eax, 1
  647.         jz      .next
  648.         and     eax, not 0xFFF
  649.         stdcall map_page, [tmp_task_ptab], eax, PG_SWR
  650.         stdcall destroy_page_table, [tmp_task_ptab]
  651.         mov     eax, [esi]
  652.         call    free_page
  653. .next:
  654.         add     esi, 4
  655.         dec     edi
  656.         jnz     .destroy
  657.  
  658.         call    kernel_free     ;ecx still in stack
  659.         stdcall map_page, [tmp_task_ptab], 0, PG_UNMAP
  660.  ;       mov     ecx, pg_data.mutex
  661.  ;       call    mutex_unlock
  662.  
  663. .exit:
  664.         ret
  665.  
  666. align 4
  667. get_pid:
  668.         mov     eax, [TASK_BASE]
  669.         mov     eax, [eax+TASKDATA.pid]
  670.         ret
  671.  
  672. pid_to_slot:
  673. ;Input:
  674. ;  eax - pid of process
  675. ;Output:
  676. ;  eax - slot of process or 0 if process don't exists
  677. ;Search process by PID.
  678.         push    ebx
  679.         push    ecx
  680.         mov     ebx, [TASK_COUNT]
  681.         shl     ebx, 5
  682.         mov     ecx, 2*32
  683.  
  684. .loop:
  685. ;ecx=offset of current process info entry
  686. ;ebx=maximum permitted offset
  687.         cmp     byte [CURRENT_TASK+ecx+0xa], 9
  688.         jz      .endloop ;skip empty slots
  689.         cmp     [CURRENT_TASK+ecx+0x4], eax;check PID
  690.         jz      .pid_found
  691. .endloop:
  692.         add     ecx, 32
  693.         cmp     ecx, ebx
  694.         jle     .loop
  695.  
  696.         pop     ecx
  697.         pop     ebx
  698.         xor     eax, eax
  699.         ret
  700.  
  701. .pid_found:
  702.         shr     ecx, 5
  703.         mov     eax, ecx ;convert offset to index of slot
  704.         pop     ecx
  705.         pop     ebx
  706.         ret
  707.  
  708. check_region:
  709. ;input:
  710. ;  esi - start of buffer
  711. ;  edx - size of buffer
  712. ;result:
  713. ;  eax = 1 region lays in app memory
  714. ;  eax = 0 region don't lays in app memory
  715.  
  716.         mov     eax, 1
  717.         ret
  718. if 0
  719.         mov     eax, [CURRENT_TASK]
  720. ;     jmp  check_process_region
  721. ;-----------------------------------------------------------------------------
  722. ;check_process_region:
  723. ;input:
  724. ;  eax - slot
  725. ;  esi - start of buffer
  726. ;  edx - size of buffer
  727. ;result:
  728. ;  eax = 1 region lays in app memory
  729. ;  eax = 0 region don't lays in app memory
  730.  
  731.         test    edx, edx
  732.         jle     .ok
  733.         shl     eax, 5
  734.         cmp     word [CURRENT_TASK+eax+0xa], 0
  735.         jnz     .failed
  736.         shl     eax, 3
  737.         mov     eax, [SLOT_BASE+eax+0xb8]
  738.         test    eax, eax
  739.         jz      .failed
  740.  
  741.         mov     eax, 1
  742.         ret
  743. .ok:
  744.         mov     eax, 1
  745.         ret
  746. .failed:
  747.         xor     eax, eax
  748.         ret
  749. end if
  750.  
  751. align 4
  752. proc read_process_memory
  753. ;Input:
  754. ;  eax - process slot
  755. ;  ecx - buffer address
  756. ;  edx - buffer size
  757. ;  esi - start address in other process
  758. ;Output:
  759. ;  eax - number of bytes read.
  760.        locals
  761.          slot   dd ?
  762.          buff   dd ?
  763.          r_count    dd ?
  764.          offset dd ?
  765.          tmp_r_cnt  dd ?
  766.        endl
  767.  
  768.         mov     [slot], eax
  769.         mov     [buff], ecx
  770.         and     [r_count], 0
  771.         mov     [tmp_r_cnt], edx
  772.         mov     [offset], esi
  773.  
  774.         pushad
  775. .read_mem:
  776.         mov     edx, [offset]
  777.         mov     ebx, [tmp_r_cnt]
  778.  
  779.         mov     ecx, 0x400000
  780.         and     edx, 0x3FFFFF
  781.         sub     ecx, edx
  782.         cmp     ecx, ebx
  783.         jbe     @f
  784.         mov     ecx, ebx
  785. @@:
  786.         cmp     ecx, 0x8000
  787.         jna     @F
  788.         mov     ecx, 0x8000
  789. @@:
  790.         mov     ebx, [offset]
  791.  
  792.         push    ecx
  793.         stdcall map_memEx, [proc_mem_map], \
  794.                 [slot], ebx, ecx, PG_READ
  795.         pop     ecx
  796.  
  797.         mov     esi, [offset]
  798.         and     esi, 0xfff
  799.         sub     eax, esi
  800.         jbe     .ret
  801.         cmp     ecx, eax
  802.         jbe     @f
  803.         mov     ecx, eax
  804.         mov     [tmp_r_cnt], eax
  805. @@:
  806.         add     esi, [proc_mem_map]
  807.         mov     edi, [buff]
  808.         mov     edx, ecx
  809.         rep movsb
  810.         add     [r_count], edx
  811.  
  812.         add     [offset], edx
  813.         sub     [tmp_r_cnt], edx
  814.         jnz     .read_mem
  815. .ret:
  816.         popad
  817.         mov     eax, [r_count]
  818.         ret
  819. endp
  820.  
  821. align 4
  822. proc write_process_memory
  823. ;Input:
  824. ;  eax - process slot
  825. ;  ecx - buffer address
  826. ;  edx - buffer size
  827. ;  esi - start address in other process
  828. ;Output:
  829. ;  eax - number of bytes written
  830.  
  831.        locals
  832.          slot   dd ?
  833.          buff   dd ?
  834.          w_count    dd ?
  835.          offset dd ?
  836.          tmp_w_cnt  dd ?
  837.        endl
  838.  
  839.         mov     [slot], eax
  840.         mov     [buff], ecx
  841.         and     [w_count], 0
  842.         mov     [tmp_w_cnt], edx
  843.         mov     [offset], esi
  844.  
  845.         pushad
  846. .read_mem:
  847.         mov     edx, [offset]
  848.         mov     ebx, [tmp_w_cnt]
  849.  
  850.         mov     ecx, 0x400000
  851.         and     edx, 0x3FFFFF
  852.         sub     ecx, edx
  853.         cmp     ecx, ebx
  854.         jbe     @f
  855.         mov     ecx, ebx
  856. @@:
  857.         cmp     ecx, 0x8000
  858.         jna     @F
  859.         mov     ecx, 0x8000
  860. @@:
  861.         mov     ebx, [offset]
  862.       ;     add ebx, new_app_base
  863.         push    ecx
  864.         stdcall map_memEx, [proc_mem_map], \
  865.                 [slot], ebx, ecx, PG_SWR
  866.         pop     ecx
  867.  
  868.         mov     edi, [offset]
  869.         and     edi, 0xfff
  870.         sub     eax, edi
  871.         jbe     .ret
  872.         cmp     ecx, eax
  873.         jbe     @f
  874.         mov     ecx, eax
  875.         mov     [tmp_w_cnt], eax
  876. @@:
  877.         add     edi, [proc_mem_map]
  878.         mov     esi, [buff]
  879.         mov     edx, ecx
  880.         rep movsb
  881.  
  882.         add     [w_count], edx
  883.         add     [offset], edx
  884.         sub     [tmp_w_cnt], edx
  885.         jnz     .read_mem
  886. .ret:
  887.         popad
  888.         mov     eax, [w_count]
  889.         ret
  890. endp
  891.  
  892. ;ebx = 1 - kernel thread
  893. ;ecx=thread entry point
  894. ;edx=thread stack pointer
  895. ;creation flags  0x01 - debugged
  896. ;                0x02 - kernel
  897.  
  898. align 4
  899. proc new_sys_threads
  900.        locals
  901.          slot          dd ?
  902.          flags         dd ?
  903.          app_cmdline   dd ? ;0x00
  904.          app_path      dd ? ;0x04
  905.          app_eip       dd ? ;0x08
  906.          app_esp       dd ? ;0x0C
  907.          app_mem       dd ? ;0x10
  908.        endl
  909.  
  910.         shl     ebx, 1
  911.         mov     [flags], ebx
  912.  
  913.         xor     eax, eax
  914.         mov     [app_eip], ecx
  915.         mov     [app_cmdline], eax
  916.         mov     [app_esp], edx
  917.         mov     [app_path], eax
  918.  
  919.         call    lock_application_table
  920.  
  921.         call    alloc_thread_slot
  922.         test    eax, eax
  923.         jz      .failed
  924.  
  925.         mov     [slot], eax
  926.  
  927.         mov     esi, [current_slot]
  928.         mov     ebx, esi      ;ebx=esi - pointer to extended information about current thread
  929.  
  930.         mov     edi, eax
  931.         shl     edi, 8
  932.         add     edi, SLOT_BASE
  933.         mov     edx, edi      ;edx=edi - pointer to extended infomation about new thread
  934.         mov     ecx, 256/4
  935.         xor     eax, eax
  936.         cld
  937.         rep stosd             ;clean extended information about new thread
  938.         mov     esi, ebx
  939.         mov     edi, edx
  940.         mov     ecx, 11
  941.         rep movsb             ;copy process name
  942.  
  943.         mov     eax, [ebx+APPDATA.process]
  944.         mov     [edx+APPDATA.process], eax
  945.  
  946.         lea     ebx, [edx+APPDATA.list]
  947.         lea     ecx, [eax+PROC.thr_list]
  948.         list_add_tail ebx, ecx               ;add thread to process child's list
  949.  
  950.         mov     eax, [ebx+APPDATA.tls_base]
  951.         test    eax, eax
  952.         jz      @F
  953.  
  954.         push    edx
  955.         stdcall user_alloc, 4096
  956.         pop     edx
  957.         test    eax, eax
  958.         jz      .failed1;eax=0
  959. @@:
  960.         mov     [edx+APPDATA.tls_base], eax
  961.  
  962.         lea     eax, [app_cmdline]
  963.         stdcall set_app_params , [slot], eax, dword 0, \
  964.                 dword 0, [flags]
  965.  
  966.         mov     eax, [process_number]           ;set result
  967.         call    unlock_application_table
  968.         ret
  969. .failed:
  970.         xor     eax, eax
  971. .failed1:
  972.         call    unlock_application_table
  973.         dec     eax     ;-1
  974.         ret
  975. endp
  976.  
  977. align 4
  978. tls_app_entry:
  979.  
  980.         call    init_heap
  981.         stdcall user_alloc, 4096
  982.  
  983.         mov     edx, [current_slot]
  984.         mov     [edx+APPDATA.tls_base], eax
  985.         mov     [tls_data_l+2], ax
  986.         shr     eax, 16
  987.         mov     [tls_data_l+4], al
  988.         mov     [tls_data_l+7], ah
  989.         mov     dx, app_tls
  990.         mov     fs, dx
  991.         popad
  992.         iretd
  993.  
  994.  
  995. EFL_IF     equ 0x0200
  996. EFL_IOPL1   equ 0x1000
  997. EFL_IOPL2   equ 0x2000
  998. EFL_IOPL3   equ 0x3000
  999.  
  1000.  
  1001. align 4
  1002. proc set_app_params stdcall,slot:dword, params:dword,\
  1003.             cmd_line:dword, app_path:dword, flags:dword
  1004.  
  1005.        locals
  1006.          pl0_stack dd ?
  1007.        endl
  1008.  
  1009.         stdcall kernel_alloc, RING0_STACK_SIZE+512
  1010.         mov     [pl0_stack], eax
  1011.  
  1012.         lea     edi, [eax+RING0_STACK_SIZE]
  1013.  
  1014.         mov     eax, [slot]
  1015.         mov     ebx, eax
  1016.  
  1017.         shl     eax, 8
  1018.         mov     [eax+SLOT_BASE+APPDATA.fpu_state], edi
  1019.         mov     [eax+SLOT_BASE+APPDATA.exc_handler], 0
  1020.         mov     [eax+SLOT_BASE+APPDATA.except_mask], 0
  1021.         mov     [eax+SLOT_BASE+APPDATA.terminate_protection], 80000001h
  1022.  
  1023. ;set default io permission map
  1024.         mov     ecx, [SLOT_BASE+256+APPDATA.io_map]
  1025.         mov     [eax+SLOT_BASE+APPDATA.io_map], ecx
  1026.         mov     ecx, [SLOT_BASE+256+APPDATA.io_map+4]
  1027.         mov     [eax+SLOT_BASE+APPDATA.io_map+4], ecx
  1028.  
  1029.         mov     esi, fpu_data
  1030.         mov     ecx, 512/4
  1031.         rep movsd
  1032.  
  1033.         cmp     ebx, [TASK_COUNT]
  1034.         jle     .noinc
  1035.         inc     dword [TASK_COUNT]     ;update number of processes
  1036. .noinc:
  1037.         shl     ebx, 8
  1038.         lea     edx, [ebx+SLOT_BASE+APP_EV_OFFSET]
  1039.         mov     [SLOT_BASE+APPDATA.fd_ev+ebx], edx
  1040.         mov     [SLOT_BASE+APPDATA.bk_ev+ebx], edx
  1041.  
  1042.         add     edx, APP_OBJ_OFFSET-APP_EV_OFFSET
  1043.         mov     [SLOT_BASE+APPDATA.fd_obj+ebx], edx
  1044.         mov     [SLOT_BASE+APPDATA.bk_obj+ebx], edx
  1045.  
  1046.         mov     ecx, [def_cursor]
  1047.         mov     [SLOT_BASE+APPDATA.cursor+ebx], ecx
  1048.         mov     eax, [pl0_stack]
  1049.         mov     [SLOT_BASE+APPDATA.pl0_stack+ebx], eax
  1050.         add     eax, RING0_STACK_SIZE
  1051.         mov     [SLOT_BASE+APPDATA.saved_esp0+ebx], eax
  1052.  
  1053.         push    ebx
  1054.         stdcall kernel_alloc, 0x1000
  1055.         pop     ebx
  1056.         mov     esi, [current_slot]
  1057.         mov     esi, [esi+APPDATA.cur_dir]
  1058.         mov     ecx, 0x1000/4
  1059.         mov     edi, eax
  1060.         mov     [ebx+SLOT_BASE+APPDATA.cur_dir], eax
  1061.         rep movsd
  1062.  
  1063.         shr     ebx, 3
  1064.         mov     eax, new_app_base
  1065.         mov     dword [CURRENT_TASK+ebx+0x10], eax
  1066.  
  1067. .add_command_line:
  1068.         mov     edx, [params]
  1069.         mov     edx, [edx] ;app_cmdline
  1070.         test    edx, edx
  1071.         jz      @f     ;application doesn't need parameters
  1072.  
  1073.         mov     eax, edx
  1074.         add     eax, 256
  1075.         jc      @f
  1076.  
  1077. ;        cmp     eax, [SLOT_BASE+APPDATA.mem_size+ebx*8]
  1078. ;        ja      @f
  1079.  
  1080.         mov     eax, [cmd_line]
  1081.  
  1082.         cmp     [edx], dword 0xffffffff ; extended destination tag
  1083.         jne     .no_ext_dest
  1084.  
  1085.         mov     edx, [edx+4] ; extended destination for cmdline
  1086.         jmp     .continue
  1087.  
  1088. .no_ext_dest:
  1089.         mov     [eax-12], dword 255
  1090. .continue:
  1091.         mov     byte [edx], 0  ;force empty string if no cmdline given
  1092.  
  1093.         test    eax, eax
  1094.         jz      @f
  1095. ;--------------------------------------
  1096.         cmp     [eax-4], dword 0xffffffff ; cmdline_flag
  1097.         jne     .old_copy
  1098.  
  1099.         push    eax
  1100.         stdcall strncpy, edx, [eax-8], [eax-12]
  1101.         pop     eax
  1102.  
  1103.         stdcall kernel_free, [eax-8]
  1104.         jmp     @f
  1105.  
  1106. .old_copy:
  1107. ;--------------------------------------
  1108.         stdcall strncpy, edx, eax, 256
  1109. @@:
  1110.         mov     edx, [params]
  1111.         mov     edx, [edx+4];app_path
  1112.         test    edx, edx
  1113.         jz      @F     ;application don't need path of file
  1114.         mov     eax, edx
  1115.         add     eax, 1024
  1116.         jc      @f
  1117. ;        cmp     eax, [SLOT_BASE+APPDATA.mem_size+ebx*8]
  1118. ;        ja      @f
  1119.         stdcall strncpy, edx, [app_path], 1024
  1120. @@:
  1121.         mov     ebx, [slot]
  1122.         mov     eax, ebx
  1123.         shl     ebx, 5
  1124.         lea     ecx, [draw_data+ebx];ecx - pointer to draw data
  1125.  
  1126.         mov     edx, irq0.return
  1127.         cmp     [ebx*8+SLOT_BASE+APPDATA.tls_base], -1
  1128.         jne     @F
  1129.         mov     edx, tls_app_entry
  1130. @@:
  1131. ; set window state to 'normal' (non-minimized/maximized/rolled-up) state
  1132.         mov     [ebx+window_data+WDATA.fl_wstate], WSTATE_NORMAL
  1133.         mov     [ebx+window_data+WDATA.fl_redraw], 1
  1134.         add     ebx, CURRENT_TASK     ;ebx - pointer to information about process
  1135.         mov     [ebx+TASKDATA.wnd_number], al;set window number on screen = process slot
  1136.  
  1137.         mov     [ebx+TASKDATA.event_mask], dword 1+2+4;set default event flags (see 40 function)
  1138.  
  1139.         inc     dword [process_number]
  1140.         mov     eax, [process_number]
  1141.         mov     [ebx+4], eax    ;set PID
  1142.  
  1143. ;set draw data to full screen
  1144.         xor     eax, eax
  1145.         mov     [ecx+0], dword eax
  1146.         mov     [ecx+4], dword eax
  1147.         mov     eax, [screen_workarea.right]
  1148.         mov     [ecx+8], eax
  1149.         mov     eax, [screen_workarea.bottom]
  1150.         mov     [ecx+12], eax
  1151.  
  1152.         mov     ebx, [pl0_stack]
  1153.         mov     esi, [params]
  1154.         lea     ecx, [ebx+REG_EIP]
  1155.         xor     eax, eax
  1156.  
  1157.         mov     [ebx+REG_RET], edx
  1158.         mov     [ebx+REG_EDI], eax
  1159.         mov     [ebx+REG_ESI], eax
  1160.         mov     [ebx+REG_EBP], eax
  1161.         mov     [ebx+REG_ESP], ecx;ebx+REG_EIP
  1162.         mov     [ebx+REG_EBX], eax
  1163.         mov     [ebx+REG_EDX], eax
  1164.         mov     [ebx+REG_ECX], eax
  1165.         mov     [ebx+REG_EAX], eax
  1166.  
  1167.         mov     eax, [esi+0x08]             ;app_eip
  1168.         mov     [ebx+REG_EIP], eax          ;app_entry
  1169.         mov     [ebx+REG_CS], dword app_code
  1170.         mov     ecx, USER_PRIORITY
  1171.  
  1172.         test    byte [flags], 2
  1173.         jz      @F
  1174.  
  1175.         mov     [ebx+REG_CS], dword os_code ; kernel thread
  1176.         mov     ecx, MAX_PRIORITY
  1177.  
  1178. @@:
  1179.         mov     [ebx+REG_EFLAGS], dword EFL_IOPL1+EFL_IF
  1180.  
  1181.         mov     eax, [esi+0x0C]  ;app_esp
  1182.         mov     [ebx+REG_APP_ESP], eax;app_stack
  1183.         mov     [ebx+REG_SS], dword app_data
  1184.  
  1185.         lea     edx, [ebx+REG_RET]
  1186.         mov     ebx, [slot]
  1187.         shl     ebx, 5
  1188.         mov     [ebx*8+SLOT_BASE+APPDATA.saved_esp], edx
  1189.  
  1190.         xor     edx, edx; process state - running
  1191. ; set if debuggee
  1192.         test    byte [flags], 1
  1193.         jz      .no_debug
  1194.         inc     edx ; process state - suspended
  1195.         mov     eax, [CURRENT_TASK]
  1196.         mov     [SLOT_BASE+ebx*8+APPDATA.debugger_slot], eax
  1197. .no_debug:
  1198.         mov     [CURRENT_TASK+ebx+TASKDATA.state], dl
  1199.         lea     edx, [SLOT_BASE+ebx*8]
  1200.         call    scheduler_add_thread
  1201.         ret
  1202. endp
  1203.  
  1204.  
  1205. align 4
  1206.  
  1207. get_stack_base:
  1208.         mov     eax, [current_slot]
  1209.         mov     eax, [eax+APPDATA.pl0_stack]
  1210.         ret
  1211.  
  1212.  
  1213. include "debug.inc"
  1214.