Subversion Repositories Kolibri OS

Rev

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

Rev Author Line No. Line
2288 clevermous 1
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2
;;                                                              ;;
2455 mario79 3
;; Copyright (C) KolibriOS team 2004-2011. All rights reserved. ;;
2288 clevermous 4
;; Distributed under terms of the GNU General Public License    ;;
5
;;                                                              ;;
6
;;                                                              ;;
7
;;  MenuetOS process management, protected ring3                ;;
8
;;                                                              ;;
9
;;  Distributed under GPL. See file COPYING for details.        ;;
10
;;  Copyright 2003 Ville Turjanmaa                              ;;
11
;;                                                              ;;
12
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
13
 
14
$Revision: 3909 $
15
 
16
align 4 ;3A08
17
build_interrupt_table:
18
        mov     edi, idts
19
        mov     esi, sys_int
20
        mov     ecx, 0x40
21
        mov     eax, (10001110b shl 24) + os_code
22
  @@:
23
        movsw   ;low word of code-entry
24
        stosd   ;interrupt gate type : os_code selector
25
        movsw   ;high word of code-entry
26
        loop    @b
27
        movsd   ;copy low  dword of trap gate for int 0x40
28
        movsd   ;copy high dword of trap gate for int 0x40
29
        lidt    [esi]
30
        ret
31
 
32
iglobal
33
  align 4
34
  sys_int:
35
    ;exception handlers addresses (for interrupt gate construction)
36
        dd      e0,e1,e2,e3,e4,e5,e6,except_7 ; SEE: core/fpu.inc
37
        dd      e8,e9,e10,e11,e12,e13,page_fault_exc,e15
38
        dd      e16, e17,e18, e19
39
        times   12 dd unknown_interrupt ;int_20..int_31
40
 
41
    ;interrupt handlers addresses (for interrupt gate construction)
42
        ; 0x20 .. 0x2F - IRQ handlers
43
        dd      irq0, irq_serv.irq_1, irq_serv.irq_2
44
        dd      irq_serv.irq_3, irq_serv.irq_4
45
        dd      irq_serv.irq_5,  irq_serv.irq_6,  irq_serv.irq_7
46
        dd      irq_serv.irq_8,  irq_serv.irq_9,  irq_serv.irq_10
47
        dd      irq_serv.irq_11, irq_serv.irq_12, irqD, irq_serv.irq_14, irq_serv.irq_15
48
        dd irq_serv.irq_16
49
        dd irq_serv.irq_17
50
        dd irq_serv.irq_18
51
        dd irq_serv.irq_19
52
        dd irq_serv.irq_20
53
        dd irq_serv.irq_21
54
        dd irq_serv.irq_22
55
        dd irq_serv.irq_23
56
 
57
    times 32 - IRQ_RESERVED dd unknown_interrupt
58
    ;int_0x40 gate trap (for directly copied)
59
        dw      i40 and 0xFFFF, os_code, 11101111b shl 8, i40 shr 16
60
 
61
  idtreg: ; data for LIDT instruction (!!! must be immediately below sys_int data)
62
        dw      2*($-sys_int-4)-1
63
        dd      idts ;0x8000B100
3539 clevermous 64
        dw      0    ;просто выравнивание
2288 clevermous 65
 
66
  msg_fault_sel dd  msg_exc_8,msg_exc_u,msg_exc_a,msg_exc_b
67
                dd  msg_exc_c,msg_exc_d,msg_exc_e
68
 
69
  msg_exc_8     db "Double fault", 0
70
  msg_exc_u     db "Undefined Exception", 0
71
  msg_exc_a     db "Invalid TSS", 0
72
  msg_exc_b     db "Segment not present", 0
73
  msg_exc_c     db "Stack fault", 0
74
  msg_exc_d     db "General protection fault", 0
75
  msg_exc_e     db "Page fault", 0
76
 
3342 yogev_ezra 77
  if lang eq sp
3344 yogev_ezra 78
    include 'core/sys32-sp.inc'
3342 yogev_ezra 79
  else
80
    msg_sel_ker   db "kernel", 0
81
    msg_sel_app   db "application", 0
3309 esevece 82
  end if
2288 clevermous 83
 
84
endg
85
 
86
macro save_ring3_context {
87
        pushad
88
}
89
macro restore_ring3_context {
90
        popad
91
}
92
macro exc_wo_code [num] {
93
  e#num :
94
        save_ring3_context
95
        mov     bl, num
96
        jmp     exc_c
97
} exc_wo_code   0,1,2,3,4,5,6,15,16,19
98
 
99
macro exc_w_code [num] {
100
  e#num :
101
        add     esp, 4
102
        save_ring3_context
103
        mov     bl, num
104
        jmp     exc_c
105
} exc_w_code    8,9,10,11,12,13,17,18
106
 
107
 
108
uglobal
109
  pf_err_code   dd ?
110
endg
111
 
3539 clevermous 112
page_fault_exc:                 ; дуракоусточивость: селекторы испорчены...
113
        pop     [ss:pf_err_code]; действительно до следующего #PF
2288 clevermous 114
        save_ring3_context
115
        mov     bl, 14
116
 
3539 clevermous 117
exc_c:                          ; исключения (все, кроме 7-го - #NM)
118
; Фрэйм стека при исключении/прерывании из 3-го кольца + pushad (т.е., именно здесь)
2288 clevermous 119
  reg_ss        equ esp+0x30
120
  reg_esp3      equ esp+0x2C
121
  reg_eflags    equ esp+0x28
122
  reg_cs3       equ esp+0x24
123
  reg_eip       equ esp+0x20
3539 clevermous 124
 ; это фрэйм от pushad
2288 clevermous 125
  reg_eax       equ esp+0x1C
126
  reg_ecx       equ esp+0x18
127
  reg_edx       equ esp+0x14
128
  reg_ebx       equ esp+0x10
129
  reg_esp0      equ esp+0x0C
130
  reg_ebp       equ esp+0x08
131
  reg_esi       equ esp+0x04
132
  reg_edi       equ esp+0x00
133
 
3539 clevermous 134
        mov     ax, app_data        ;исключение
135
        mov     ds, ax                  ;загрузим правильные значения
136
        mov     es, ax                  ;в регистры
137
        cld                     ; и приводим DF к стандарту
2288 clevermous 138
        movzx   ebx, bl
139
; redirect to V86 manager? (EFLAGS & 0x20000) != 0?
140
        test    byte[reg_eflags+2], 2
141
        jnz     v86_exc_c
142
        cmp     bl, 14          ; #PF
143
        jne     @f
144
        call    page_fault_handler ; SEE: core/memory.inc
145
  @@:
146
        mov     esi, [current_slot]
147
        btr     [esi+APPDATA.except_mask], ebx
148
        jnc     @f
149
        mov     eax, [esi+APPDATA.exc_handler]
150
        test    eax, eax
151
        jnz     IRetToUserHook
152
  @@:
153
        cli
154
        mov     eax, [esi+APPDATA.debugger_slot]
155
        test    eax, eax
156
        jnz     .debug
157
        sti
158
; not debuggee => say error and terminate
159
        call    show_error_parameters ;; only ONE using, inline ???
160
       ;mov     edx, [TASK_BASE]
161
        mov     [edx + TASKDATA.state], byte 4 ; terminate
3534 clevermous 162
        call    wakeup_osloop
3615 clevermous 163
        call    change_task
164
; If we're here, then the main OS thread has crashed before initializing IDLE thread.
165
; Or they both have crashed. Anyway, things are hopelessly broken.
166
        hlt
167
        jmp     $-1
2288 clevermous 168
.debug:
169
; we are debugged process, notify debugger and suspend ourself
170
; eax=debugger PID
171
        mov     ecx, 1          ; debug_message code=other_exception
172
        cmp     bl, 1           ; #DB
173
        jne     .notify         ; notify debugger and suspend ourself
174
        mov     ebx, dr6        ; debug_message data=DR6_image
175
        xor     edx, edx
176
        mov     dr6, edx
177
        mov     edx, dr7
178
        mov     cl, not 8
179
  .l1:
180
        shl     dl, 2
181
        jc      @f
182
        and     bl, cl
183
  @@:
184
        sar     cl, 1
185
        jc      .l1
186
        mov     cl, 3           ; debug_message code=debug_exception
187
.notify:
188
        push    ebx             ; debug_message data
189
        mov     ebx, [TASK_BASE]
190
        push    [ebx+TASKDATA.pid] ; PID
191
        push    ecx             ; debug_message code ((here: ecx==1/3))
192
        mov     cl, 12          ; debug_message size
193
        call    debugger_notify ;; only ONE using, inline ??? SEE: core/debug.inc
194
        add     esp, 12
195
        mov     edx, [TASK_BASE]
196
        mov     byte [edx+TASKDATA.state], 1 ; suspended
197
        call    change_task     ; SEE: core/shed.inc
198
        restore_ring3_context
199
        iretd
200
 
201
IRetToUserHook:
202
        xchg    eax, [reg_eip]
203
        sub     dword[reg_esp3], 8
204
        mov     edi, [reg_esp3]
205
        stosd
206
        mov     [edi], ebx
207
        restore_ring3_context
208
; simply return control to interrupted process
209
unknown_interrupt:
210
        iretd
211
 
212
;-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
213
; bl - error vector
214
show_error_parameters:
215
        cmp     bl, 0x06
216
        jnz     .no_ud
217
        push    ebx
218
        mov     ebx, ud_user_message
219
        mov     ebp, notifyapp
220
        call    fs_execute_from_sysdir_param
221
        pop     ebx
222
.no_ud:
223
        mov     edx, [TASK_BASE];not scratched below
3309 esevece 224
        if lang eq sp
225
        DEBUGF  1, "K : Proceso - terminado forzado PID: %x [%s]\n", [edx+TASKDATA.pid], [current_slot]
226
        else
3294 clevermous 227
        DEBUGF  1, "K : Process - forced terminate PID: %x [%s]\n", [edx+TASKDATA.pid], [current_slot]
3309 esevece 228
        end if
2288 clevermous 229
        cmp     bl, 0x08
230
        jb      .l0
231
        cmp     bl, 0x0e
232
        jbe     .l1
233
  .l0:
234
        mov     bl, 0x09
235
  .l1:
236
        mov     eax, [msg_fault_sel+ebx*4 - 0x08*4]
237
        DEBUGF  1, "K : %s\n", eax
238
        mov     eax, [reg_cs3+4]
239
        mov     edi, msg_sel_app
240
        mov     ebx, [reg_esp3+4]
241
        cmp     eax, app_code
242
        je      @f
243
        mov     edi, msg_sel_ker
244
        mov     ebx, [reg_esp0+4]
245
    @@:
246
        DEBUGF  1, "K : EAX : %x EBX : %x ECX : %x\n", [reg_eax+4], [reg_ebx+4], [reg_ecx+4]
247
        DEBUGF  1, "K : EDX : %x ESI : %x EDI : %x\n", [reg_edx+4], [reg_esi+4], [reg_edi+4]
248
        DEBUGF  1, "K : EBP : %x EIP : %x ESP : %x\n", [reg_ebp+4], [reg_eip+4], ebx
249
        DEBUGF  1, "K : Flags : %x CS : %x (%s)\n", [reg_eflags+4], eax, edi
3909 mario79 250
        DEBUGF  1, "K : Stack dump:\n"
251
        DEBUGF  1, "K : [ESP+00]: %x [ESP+04]: %x [ESP+08]: %x\n", [ebx], [ebx+4], [ebx+8]
252
        DEBUGF  1, "K : [ESP+12]: %x [ESP+16]: %x [ESP+20]: %x\n", [ebx+12], [ebx+16], [ebx+20]
253
        DEBUGF  1, "K : [ESP+24]: %x [ESP+28]: %x [ESP+32]: %x\n", [ebx+24], [ebx+28], [ebx+32]
2288 clevermous 254
        ret
255
;-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
256
 
257
  restore  reg_ss
258
  restore  reg_esp3
259
  restore  reg_eflags
260
  restore  reg_cs
261
  restore  reg_eip
262
  restore  reg_eax
263
  restore  reg_ecx
264
  restore  reg_edx
265
  restore  reg_ebx
266
  restore  reg_esp0
267
  restore  reg_ebp
268
  restore  reg_esi
269
  restore  reg_edi
270
 
271
 
272
align 4
3534 clevermous 273
lock_application_table:
274
        push    eax ecx edx
275
        mov     ecx, application_table_mutex
276
        call    mutex_lock
2288 clevermous 277
 
278
        mov     eax, [CURRENT_TASK]
279
        shl     eax, 5
280
        add     eax, CURRENT_TASK+TASKDATA.pid
281
        mov     eax, [eax]
282
 
3534 clevermous 283
        mov     [application_table_owner], eax
2288 clevermous 284
 
3534 clevermous 285
        pop     edx ecx eax
2288 clevermous 286
 
287
        ret
288
 
289
align 4
3534 clevermous 290
unlock_application_table:
291
        push    eax ecx edx
2288 clevermous 292
 
3534 clevermous 293
        mov     [application_table_owner], 0
294
        mov     ecx, application_table_mutex
295
        call    mutex_unlock
2288 clevermous 296
 
3534 clevermous 297
        pop     edx ecx eax
2288 clevermous 298
 
299
        ret
300
 
3539 clevermous 301
;  * eax = 64 - номер функции
302
;  * ebx = 1 - единственная подфункция
303
;  * ecx = новый размер памяти
304
;Возвращаемое значение:
305
;  * eax = 0 - успешно
306
;  * eax = 1 - недостаточно памяти
2288 clevermous 307
 
308
align 4
309
sys_resize_app_memory:
310
        ; ebx = 1 - resize
311
        ; ecx = new amount of memory
312
 
313
;        cmp    eax,1
314
        dec     ebx
315
        jnz     .no_application_mem_resize
316
        stdcall new_mem_resize, ecx
317
        mov     [esp+32], eax
318
.no_application_mem_resize:
319
        ret
320
 
321
iglobal
322
;  process_terminating  db 'K : Process - terminating',13,10,0
323
;  process_terminated   db 'K : Process - done',13,10,0
324
  msg_obj_destroy       db 'K : destroy app object',13,10,0
325
endg
326
 
327
; param
328
;  esi= slot
329
 
330
align 4
331
terminate: ; terminate application
332
 
333
           .slot equ esp   ;locals
334
 
335
        push    esi        ;save .slot
336
 
337
        shl     esi, 8
338
        cmp     [SLOT_BASE+esi+APPDATA.dir_table], 0
339
        jne     @F
340
        pop     esi
341
        shl     esi, 5
342
        mov     [CURRENT_TASK+esi+TASKDATA.state], 9
343
        ret
344
@@:
3534 clevermous 345
        lea     edx, [SLOT_BASE+esi]
346
        call    scheduler_remove_thread
2288 clevermous 347
           ;mov    esi,process_terminating
348
           ;call   sys_msg_board_str
3534 clevermous 349
        call    lock_application_table
2288 clevermous 350
 
351
; if the process is in V86 mode...
352
        mov     eax, [.slot]
353
        shl     eax, 8
354
        mov     esi, [eax+SLOT_BASE+APPDATA.pl0_stack]
355
        add     esi, RING0_STACK_SIZE
356
        cmp     [eax+SLOT_BASE+APPDATA.saved_esp0], esi
357
        jz      .nov86
358
; ...it has page directory for V86 mode
359
        mov     esi, [eax+SLOT_BASE+APPDATA.saved_esp0]
360
        mov     ecx, [esi+4]
361
        mov     [eax+SLOT_BASE+APPDATA.dir_table], ecx
362
; ...and I/O permission map for V86 mode
363
        mov     ecx, [esi+12]
364
        mov     [eax+SLOT_BASE+APPDATA.io_map], ecx
365
        mov     ecx, [esi+8]
366
        mov     [eax+SLOT_BASE+APPDATA.io_map+4], ecx
367
.nov86:
368
 
369
        mov     esi, [.slot]
370
        shl     esi, 8
371
        add     esi, SLOT_BASE+APP_OBJ_OFFSET
372
@@:
373
        mov     eax, [esi+APPOBJ.fd]
374
        test    eax, eax
375
        jz      @F
376
 
377
        cmp     eax, esi
378
        je      @F
379
 
380
        push    esi
381
        call    [eax+APPOBJ.destroy]
382
           DEBUGF 1,"%s",msg_obj_destroy
383
        pop     esi
384
        jmp     @B
385
@@:
386
 
387
        mov     eax, [.slot]
388
        shl     eax, 8
389
        stdcall destroy_app_space, [SLOT_BASE+eax+APPDATA.dir_table], [SLOT_BASE+eax+APPDATA.dlls_list_ptr]
390
 
391
        mov     esi, [.slot]
3534 clevermous 392
        cmp     [fpu_owner], esi ; if user fpu last -> fpu user = 2
2288 clevermous 393
        jne     @F
394
 
3534 clevermous 395
        mov     [fpu_owner], 2
396
        mov     eax, [256*2+SLOT_BASE+APPDATA.fpu_state]
2288 clevermous 397
        clts
398
        bt      [cpu_caps], CAPS_SSE
399
        jnc     .no_SSE
400
        fxrstor [eax]
401
        jmp     @F
402
.no_SSE:
403
        fnclex
404
        frstor  [eax]
405
@@:
406
 
407
        mov     [KEY_COUNT], byte 0    ; empty keyboard buffer
408
        mov     [BTN_COUNT], byte 0    ; empty button buffer
409
 
410
 
411
; remove defined hotkeys
412
        mov     eax, hotkey_list
413
.loop:
414
        cmp     [eax+8], esi
415
        jnz     .cont
416
        mov     ecx, [eax]
417
        jecxz   @f
418
        push    dword [eax+12]
419
        pop     dword [ecx+12]
420
@@:
421
        mov     ecx, [eax+12]
422
        push    dword [eax]
423
        pop     dword [ecx]
424
        xor     ecx, ecx
425
        mov     [eax], ecx
426
        mov     [eax+4], ecx
427
        mov     [eax+8], ecx
428
        mov     [eax+12], ecx
429
.cont:
430
        add     eax, 16
431
        cmp     eax, hotkey_list+256*16
432
        jb      .loop
2709 mario79 433
; get process PID
434
        mov     eax, esi
435
        shl     eax, 5
436
        mov     eax, [eax+CURRENT_TASK+TASKDATA.pid]
437
; compare current lock input with process PID
438
        cmp     eax, [PID_lock_input]
439
        jne     @f
440
 
441
        xor     eax, eax
442
        mov     [PID_lock_input], eax
443
@@:
2288 clevermous 444
; remove hotkeys in buffer
445
        mov     eax, hotkey_buffer
446
.loop2:
447
        cmp     [eax], esi
448
        jnz     .cont2
449
        and     dword [eax+4], 0
450
        and     dword [eax], 0
451
.cont2:
452
        add     eax, 8
453
        cmp     eax, hotkey_buffer+120*8
454
        jb      .loop2
455
 
456
        mov     ecx, esi          ; remove buttons
457
  bnewba2:
458
        mov     edi, [BTN_ADDR]
459
        mov     eax, edi
460
        cld
461
        movzx   ebx, word [edi]
462
        inc     bx
463
  bnewba:
464
        dec     bx
465
        jz      bnmba
466
        add     eax, 0x10
467
        cmp     cx, [eax]
468
        jnz     bnewba
469
        pusha
470
        mov     ecx, ebx
471
        inc     ecx
472
        shl     ecx, 4
473
        mov     ebx, eax
474
        add     eax, 0x10
475
        call    memmove
476
        dec     dword [edi]
477
        popa
478
        jmp     bnewba2
479
  bnmba:
480
 
481
        pusha   ; save window coordinates for window restoring
482
        cld
483
        shl     esi, 5
484
        add     esi, window_data
485
        mov     eax, [esi+WDATA.box.left]
486
        mov     [draw_limits.left], eax
487
        add     eax, [esi+WDATA.box.width]
488
        mov     [draw_limits.right], eax
489
        mov     eax, [esi+WDATA.box.top]
490
        mov     [draw_limits.top], eax
491
        add     eax, [esi+WDATA.box.height]
492
        mov     [draw_limits.bottom], eax
493
 
494
        xor     eax, eax
495
        mov     [esi+WDATA.box.left], eax
496
        mov     [esi+WDATA.box.width], eax
497
        mov     [esi+WDATA.box.top], eax
498
        mov     [esi+WDATA.box.height], eax
499
        mov     [esi+WDATA.cl_workarea], eax
500
        mov     [esi+WDATA.cl_titlebar], eax
501
        mov     [esi+WDATA.cl_frames], eax
502
        mov     dword [esi+WDATA.reserved], eax; clear all flags: wstate, redraw, wdrawn
503
        lea     edi, [esi-window_data+draw_data]
504
        mov     ecx, 32/4
505
        rep stosd
506
        popa
507
 
508
; debuggee test
509
        pushad
510
        mov     edi, esi
511
        shl     edi, 5
512
        mov     eax, [SLOT_BASE+edi*8+APPDATA.debugger_slot]
513
        test    eax, eax
514
        jz      .nodebug
3598 clevermous 515
        movi    ecx, 8
2288 clevermous 516
        push    dword [CURRENT_TASK+edi+TASKDATA.pid]; PID
517
        push    2
518
        call    debugger_notify
519
        pop     ecx
520
        pop     ecx
521
.nodebug:
522
        popad
523
 
524
        mov     ebx, [.slot]
525
        shl     ebx, 8
526
        push    ebx
527
        mov     ebx, [SLOT_BASE+ebx+APPDATA.pl0_stack]
528
 
529
        stdcall kernel_free, ebx
530
 
531
        pop     ebx
532
        mov     ebx, [SLOT_BASE+ebx+APPDATA.cur_dir]
533
        stdcall kernel_free, ebx
534
 
535
        mov     edi, [.slot]
536
        shl     edi, 8
537
        add     edi, SLOT_BASE
538
 
539
        mov     eax, [edi+APPDATA.io_map]
540
        cmp     eax, [SLOT_BASE+256+APPDATA.io_map]
541
        je      @F
542
        call    free_page
543
@@:
544
        mov     eax, [edi+APPDATA.io_map+4]
545
        cmp     eax, [SLOT_BASE+256+APPDATA.io_map+4]
546
        je      @F
547
        call    free_page
548
@@:
549
        mov     eax, 0x20202020
550
        stosd
551
        stosd
552
        stosd
553
        mov     ecx, 244/4
554
        xor     eax, eax
555
        rep stosd
556
 
557
  ; activate window
558
        movzx   eax, word [WIN_STACK + esi*2]
559
        cmp     eax, [TASK_COUNT]
560
        jne     .dont_activate
561
        pushad
562
 .check_next_window:
563
        dec     eax
564
        cmp     eax, 1
565
        jbe     .nothing_to_activate
566
        lea     esi, [WIN_POS+eax*2]
567
        movzx   edi, word [esi]              ; edi = process
568
        shl     edi, 5
569
        cmp     [CURRENT_TASK + edi + TASKDATA.state], byte 9 ; skip dead slots
570
        je      .check_next_window
571
        add     edi, window_data
572
; \begin{diamond}[19.09.2006]
573
; skip minimized windows
574
        test    [edi + WDATA.fl_wstate], WSTATE_MINIMIZED
575
        jnz     .check_next_window
576
; \end{diamond}
577
        call    waredraw
578
 .nothing_to_activate:
579
        popad
580
 .dont_activate:
581
 
582
        push    esi     ; remove hd1 & cd & flp reservation
583
        shl     esi, 5
584
        mov     esi, [esi+CURRENT_TASK+TASKDATA.pid]
585
        cmp     [cd_status], esi
586
        jnz     @f
587
        call    free_cd_channel
588
        and     [cd_status], 0
589
@@:
590
        cmp     [flp_status], esi
591
        jnz     @f
592
        and     [flp_status], 0
593
@@:
594
        pop     esi
595
        cmp     [bgrlockpid], esi
596
        jnz     @f
597
        and     [bgrlockpid], 0
598
        and     [bgrlock], 0
599
@@:
600
 
601
        pusha                 ; remove all port reservations
602
        mov     edx, esi
603
        shl     edx, 5
604
        add     edx, CURRENT_TASK
605
        mov     edx, [edx+TASKDATA.pid]
606
 
607
  rmpr0:
608
 
609
        mov     esi, [RESERVED_PORTS]
610
 
611
        test    esi, esi
612
        jz      rmpr9
613
 
614
  rmpr3:
615
 
616
        mov     edi, esi
617
        shl     edi, 4
618
        add     edi, RESERVED_PORTS
619
 
620
        cmp     edx, [edi]
621
        je      rmpr4
622
 
623
        dec     esi
624
        jnz     rmpr3
625
 
626
        jmp     rmpr9
627
 
628
  rmpr4:
629
 
630
        mov     ecx, 256
631
        sub     ecx, esi
632
        shl     ecx, 4
633
 
634
        mov     esi, edi
635
        add     esi, 16
636
        cld
637
        rep movsb
638
 
639
        dec     dword [RESERVED_PORTS]
640
 
641
        jmp     rmpr0
642
 
643
  rmpr9:
644
 
645
        popa
646
        mov     edi, esi ; do not run this process slot
647
        shl     edi, 5
648
        mov     [edi+CURRENT_TASK + TASKDATA.state], byte 9
649
; debugger test - terminate all debuggees
650
        mov     eax, 2
651
        mov     ecx, SLOT_BASE+2*0x100+APPDATA.debugger_slot
652
.xd0:
653
        cmp     eax, [TASK_COUNT]
654
        ja      .xd1
655
        cmp     dword [ecx], esi
656
        jnz     @f
657
        and     dword [ecx], 0
658
        pushad
659
        xchg    eax, ecx
660
        mov     ebx, 2
661
        call    sys_system
662
        popad
663
@@:
664
        inc     eax
665
        add     ecx, 0x100
666
        jmp     .xd0
667
.xd1:
668
;    call  systest
669
        sti     ; .. and life goes on
670
 
671
        mov     eax, [draw_limits.left]
672
        mov     ebx, [draw_limits.top]
673
        mov     ecx, [draw_limits.right]
674
        mov     edx, [draw_limits.bottom]
675
        call    calculatescreen
676
        xor     eax, eax
677
        xor     esi, esi
678
        call    redrawscreen
679
 
3534 clevermous 680
        call    unlock_application_table
2288 clevermous 681
    ;mov   esi,process_terminated
682
    ;call  sys_msg_board_str
683
        add     esp, 4
684
        ret
685
restore .slot
686
 
2642 mario79 687
;build_scheduler:
688
;        mov     esi, boot_sched_1
689
;        call    boot_log
690
;        call   build_process_gdt_tss_pointer
2288 clevermous 691
 
2642 mario79 692
;        mov    esi,boot_sched_2
693
;        call   boot_log
694
;        ret
3296 clevermous 695
 
696
; Three following procedures are used to guarantee that
697
; some part of kernel code will not be terminated from outside
698
; while it is running.
699
; Note: they do not protect a thread from terminating due to errors inside
700
; the thread; accessing a nonexisting memory would still terminate it.
701
 
702
; First two procedures must be used in pair by thread-to-be-protected
703
; to signal the beginning and the end of an important part.
704
; It is OK to have nested areas.
705
 
706
; The last procedure must be used by outside wanna-be-terminators;
707
; if it is safe to terminate the given thread immediately, it returns eax=1;
708
; otherwise, it returns eax=0 and notifies the target thread that it should
709
; terminate itself when leaving a critical area (the last critical area if
710
; they are nested).
711
 
712
; Implementation. Those procedures use one dword in APPDATA for the thread,
713
; APPDATA.terminate_protection.
714
; * The upper bit is 1 during normal operations and 0 when terminate is requested.
715
; * Other bits form a number = depth of critical regions,
716
;   plus 1 if the upper bit is 1.
717
; * When this dword goes to zero, the thread should be destructed,
718
;   and the procedure in which it happened becomes responsible for destruction.
719
 
720
; Enter critical area. Called by thread which wants to be protected.
721
proc protect_from_terminate
722
        mov     edx, [current_slot]
723
; Atomically increment depth of critical areas and get the old value.
724
        mov     eax, 1
725
        lock xadd [edx+APPDATA.terminate_protection], eax
726
; If the old value was zero, somebody has started to terminate us,
727
; so we are destructing and cannot do anything protected.
728
; Otherwise, return to the caller.
729
        test    eax, eax
730
        jz      @f
731
        ret
732
@@:
733
; Wait for somebody to finish us.
734
        call    change_task
735
        jmp     @b
736
endp
737
 
738
; Leave critical area. Called by thread which wants to be protected.
739
proc unprotect_from_terminate
740
        mov     edx, [current_slot]
741
; Atomically decrement depth of critical areas.
742
        lock dec [edx+APPDATA.terminate_protection]
743
; If the result of decrement is zero, somebody has requested termination,
744
; but at that moment we were inside a critical area; terminate now.
745
        jz      sys_end
746
; Otherwise, return to the caller.
747
        ret
748
endp
749
 
750
; Request termination of thread identified by edx = SLOT_BASE + slot*256.
751
; Called by anyone.
752
proc request_terminate
753
        xor     eax, eax        ; set return value
754
; Atomically clear the upper bit. If it was already zero, then
755
; somebody has requested termination before us, so just exit.
756
        lock btr [edx+APPDATA.terminate_protection], 31
757
        jnc     .unsafe
758
; Atomically decrement depth of critical areas.
759
        lock dec [edx+APPDATA.terminate_protection]
760
; If the result of decrement is nonzero, the target thread is inside a
761
; critical area; leave termination to leaving that area.
762
        jnz     .unsafe
763
; Otherwise, it is safe to kill the target now and the caller is responsible
764
; for this. Return eax=1.
765
        inc     eax
766
.unsafe:
767
        ret
768
endp
769