Subversion Repositories Kolibri OS

Rev

Rev 8851 | Rev 8866 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

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