Subversion Repositories Kolibri OS

Rev

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