Subversion Repositories Kolibri OS

Rev

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

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