Subversion Repositories Kolibri OS

Rev

Rev 5984 | 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
;;  MenuetOS process management, protected ring3                ;;
8
;;                                                              ;;
9
;;  Distributed under GPL. See file COPYING for details.        ;;
10
;;  Copyright 2003 Ville Turjanmaa                              ;;
11
;;                                                              ;;
12
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1 ha 13
 
593 mikedld 14
$Revision: 6339 $
15
 
1056 Galkov 16
align 4 ;3A08
1 ha 17
build_interrupt_table:
1056 Galkov 18
        mov     edi, idts
19
        mov     esi, sys_int
20
        mov     ecx, 0x40
21
        mov     eax, (10001110b shl 24) + os_code
2434 Serge 22
  @@:
23
        movsw   ;low word of code-entry
1056 Galkov 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
1 ha 31
 
1056 Galkov 32
iglobal
33
  align 4
34
  sys_int:
35
    ;exception handlers addresses (for interrupt gate construction)
1076 Galkov 36
        dd      e0,e1,e2,e3,e4,e5,e6,except_7 ; SEE: core/fpu.inc
1056 Galkov 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
164 serge 40
 
1056 Galkov 41
    ;interrupt handlers addresses (for interrupt gate construction)
2434 Serge 42
        ; 0x20 .. 0x2F - IRQ handlers
1056 Galkov 43
        dd      irq0, irq_serv.irq_1, irq_serv.irq_2
44
        dd      irq_serv.irq_3, irq_serv.irq_4
2010 serge 45
        dd      irq_serv.irq_5,  irq_serv.irq_6,  irq_serv.irq_7
1056 Galkov 46
        dd      irq_serv.irq_8,  irq_serv.irq_9,  irq_serv.irq_10
2010 serge 47
        dd      irq_serv.irq_11, irq_serv.irq_12, irqD, irq_serv.irq_14, irq_serv.irq_15
2434 Serge 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
1 ha 56
 
2130 serge 57
    times 32 - IRQ_RESERVED dd unknown_interrupt
1056 Galkov 58
    ;int_0x40 gate trap (for directly copied)
59
        dw      i40 and 0xFFFF, os_code, 11101111b shl 8, i40 shr 16
656 mikedld 60
 
1076 Galkov 61
  idtreg: ; data for LIDT instruction (!!! must be immediately below sys_int data)
1056 Galkov 62
        dw      2*($-sys_int-4)-1
63
        dd      idts ;0x8000B100
3555 Serge 64
        dw      0    ;просто выравнивание
656 mikedld 65
 
1056 Galkov 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
164 serge 68
 
1056 Galkov 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
1 ha 76
 
3500 Serge 77
  if lang eq sp
78
    include 'core/sys32-sp.inc'
79
  else
3908 Serge 80
    msg_sel_ker   db "kernel", 0
81
    msg_sel_app   db "application", 0
3500 Serge 82
  end if
1 ha 83
 
84
endg
85
 
1056 Galkov 86
macro save_ring3_context {
87
        pushad
40 halyavin 88
}
1056 Galkov 89
macro restore_ring3_context {
90
        popad
40 halyavin 91
}
1056 Galkov 92
macro exc_wo_code [num] {
8 poddubny 93
  e#num :
1056 Galkov 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
1 ha 98
 
1056 Galkov 99
macro exc_w_code [num] {
22 poddubny 100
  e#num :
1056 Galkov 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
22 poddubny 106
 
107
 
1056 Galkov 108
uglobal
109
  pf_err_code   dd ?
110
endg
1 ha 111
 
3555 Serge 112
page_fault_exc:                 ; дуракоусточивость: селекторы испорчены...
113
        pop     [ss:pf_err_code]; действительно до следующего #PF
1056 Galkov 114
        save_ring3_context
2434 Serge 115
        mov     bl, 14
1086 Galkov 116
 
3555 Serge 117
exc_c:                          ; исключения (все, кроме 7-го - #NM)
118
; Фрэйм стека при исключении/прерывании из 3-го кольца + pushad (т.е., именно здесь)
1056 Galkov 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
3555 Serge 124
 ; это фрэйм от pushad
1056 Galkov 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
 
3555 Serge 134
        mov     ax, app_data        ;исключение
135
        mov     ds, ax                  ;загрузим правильные значения
136
        mov     es, ax                  ;в регистры
137
        cld                     ; и приводим DF к стандарту
2434 Serge 138
        movzx   ebx, bl
709 diamond 139
; redirect to V86 manager? (EFLAGS & 0x20000) != 0?
2434 Serge 140
        test    byte[reg_eflags+2], 2
1056 Galkov 141
        jnz     v86_exc_c
2434 Serge 142
        cmp     bl, 14          ; #PF
1074 Galkov 143
        jne     @f
1076 Galkov 144
        call    page_fault_handler ; SEE: core/memory.inc
2434 Serge 145
  @@:
146
        mov     esi, [current_slot]
1074 Galkov 147
        btr     [esi+APPDATA.except_mask], ebx
148
        jnc     @f
2434 Serge 149
        mov     eax, [esi+APPDATA.exc_handler]
1074 Galkov 150
        test    eax, eax
1056 Galkov 151
        jnz     IRetToUserHook
2434 Serge 152
  @@:
153
        cli
1056 Galkov 154
        mov     eax, [esi+APPDATA.debugger_slot]
155
        test    eax, eax
156
        jnz     .debug
157
        sti
40 halyavin 158
; not debuggee => say error and terminate
1056 Galkov 159
        call    show_error_parameters ;; only ONE using, inline ???
160
       ;mov     edx, [TASK_BASE]
161
        mov     [edx + TASKDATA.state], byte 4 ; terminate
3555 Serge 162
        call    wakeup_osloop
3626 Serge 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
40 halyavin 168
.debug:
169
; we are debugged process, notify debugger and suspend ourself
170
; eax=debugger PID
2434 Serge 171
        mov     ecx, 1          ; debug_message code=other_exception
172
        cmp     bl, 1           ; #DB
1076 Galkov 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
2434 Serge 179
  .l1:
180
        shl     dl, 2
1076 Galkov 181
        jc      @f
182
        and     bl, cl
2434 Serge 183
  @@:
184
        sar     cl, 1
1076 Galkov 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
2434 Serge 194
        add     esp, 12
1076 Galkov 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
1 ha 200
 
1056 Galkov 201
IRetToUserHook:
202
        xchg    eax, [reg_eip]
1074 Galkov 203
        sub     dword[reg_esp3], 8
1056 Galkov 204
        mov     edi, [reg_esp3]
205
        stosd
1074 Galkov 206
        mov     [edi], ebx
1056 Galkov 207
        restore_ring3_context
1638 serge 208
; simply return control to interrupted process
1056 Galkov 209
unknown_interrupt:
210
        iretd
1 ha 211
 
658 Ghost 212
;-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
1638 serge 213
; bl - error vector
1 ha 214
show_error_parameters:
2010 serge 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:
2434 Serge 223
        mov     edx, [TASK_BASE];not scratched below
3500 Serge 224
        if lang eq sp
225
        DEBUGF  1, "K : Proceso - terminado forzado PID: %x [%s]\n", [edx+TASKDATA.pid], [current_slot]
226
        else
227
        DEBUGF  1, "K : Process - forced terminate PID: %x [%s]\n", [edx+TASKDATA.pid], [current_slot]
228
        end if
1056 Galkov 229
        cmp     bl, 0x08
230
        jb      .l0
231
        cmp     bl, 0x0e
232
        jbe     .l1
2434 Serge 233
  .l0:
234
        mov     bl, 0x09
235
  .l1:
236
        mov     eax, [msg_fault_sel+ebx*4 - 0x08*4]
1056 Galkov 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]
2434 Serge 245
    @@:
246
        DEBUGF  1, "K : EAX : %x EBX : %x ECX : %x\n", [reg_eax+4], [reg_ebx+4], [reg_ecx+4]
1056 Galkov 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
4265 Serge 250
 
251
        DEBUGF  1, "K : Stack dump:\n"
252
        push    eax ebx ecx edx
253
        call    .check_ESP
254
        test    eax, eax
255
        jnz     .error_ESP
256
        DEBUGF  1, "K : [ESP+00]: %x",[ebx]
257
        add     ebx, 4
258
        call    .check_ESP
259
        test    eax, eax
260
        jnz     .error_ESP
261
        DEBUGF  1, " [ESP+04]: %x",[ebx]
262
        add     ebx, 4
263
        call    .check_ESP
264
        test    eax, eax
265
        jnz     .error_ESP
5984 serge 266
        DEBUGF  1, " [ESP+08]: %x\n",[ebx]
4265 Serge 267
        add     ebx, 4
268
        call    .check_ESP
269
        test    eax, eax
270
        jnz     .error_ESP
271
        DEBUGF  1, "K : [ESP+12]: %x",[ebx]
272
        add     ebx, 4
273
        call    .check_ESP
274
        test    eax, eax
275
        jnz     .error_ESP
276
        DEBUGF  1, " [ESP+16]: %x",[ebx]
277
        add     ebx, 4
278
        call    .check_ESP
279
        test    eax, eax
280
        jnz     .error_ESP
281
        DEBUGF  1, " [ESP+20]: %x\n",[ebx]
282
        add     ebx, 4
283
        call    .check_ESP
284
        test    eax, eax
285
        jnz     .error_ESP
286
        DEBUGF  1, "K : [ESP+24]: %x",[ebx]
287
        add     ebx, 4
288
        call    .check_ESP
289
        test    eax, eax
290
        jnz     .error_ESP
291
        DEBUGF  1, " [ESP+28]: %x",[ebx]
292
        add     ebx, 4
293
        call    .check_ESP
294
        test    eax, eax
295
        jnz     .error_ESP
5984 serge 296
        DEBUGF  1, " [ESP+32]: %x\n",[ebx]
4265 Serge 297
        pop     edx ecx ebx eax
1056 Galkov 298
        ret
4265 Serge 299
.error_ESP:
300
        pop     edx ecx ebx eax
301
        DEBUGF  1, "\n"
302
        DEBUGF  1, "K : Unexpected end of the stack\n"
303
        ret
304
;--------------------------------------
305
.check_ESP:
306
        push    ebx
307
        shr     ebx, 12
308
        mov     ecx, ebx
6339 serge 309
        shr     ecx, 9
310
        mov     edx, [master_tab+ecx*8]
5565 serge 311
        test    edx, PG_READ
4265 Serge 312
        jz      .fail             ;page table is not created
313
                                  ;incorrect address in the program
314
 
6339 serge 315
        mov     eax, [page_tabs+ebx*8]
4265 Serge 316
        test    eax, 2
317
        jz      .fail             ;address not reserved for use. error
5984 serge 318
 
319
        pop     ebx
4265 Serge 320
        xor     eax, eax
5984 serge 321
        ret
322
 
4265 Serge 323
.fail:
324
        pop     ebx
325
        xor     eax, eax
326
        dec     eax
327
        ret
658 Ghost 328
;-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
164 serge 329
 
1056 Galkov 330
  restore  reg_ss
331
  restore  reg_esp3
332
  restore  reg_eflags
333
  restore  reg_cs
334
  restore  reg_eip
335
  restore  reg_eax
336
  restore  reg_ecx
337
  restore  reg_edx
338
  restore  reg_ebx
339
  restore  reg_esp0
340
  restore  reg_ebp
341
  restore  reg_esi
342
  restore  reg_edi
16 poddubny 343
 
1638 serge 344
 
2106 serge 345
align 4
3555 Serge 346
lock_application_table:
347
        push    eax ecx edx
348
        mov     ecx, application_table_mutex
349
        call    mutex_lock
1 ha 350
 
2434 Serge 351
        mov     eax, [CURRENT_TASK]
352
        shl     eax, 5
353
        add     eax, CURRENT_TASK+TASKDATA.pid
354
        mov     eax, [eax]
1 ha 355
 
3555 Serge 356
        mov     [application_table_owner], eax
1 ha 357
 
3555 Serge 358
        pop     edx ecx eax
1 ha 359
 
1056 Galkov 360
        ret
1 ha 361
 
2106 serge 362
align 4
3555 Serge 363
unlock_application_table:
364
        push    eax ecx edx
1 ha 365
 
3555 Serge 366
        mov     [application_table_owner], 0
367
        mov     ecx, application_table_mutex
368
        call    mutex_unlock
1 ha 369
 
3555 Serge 370
        pop     edx ecx eax
1 ha 371
 
1056 Galkov 372
        ret
1 ha 373
 
3555 Serge 374
;  * eax = 64 - номер функции
375
;  * ebx = 1 - единственная подфункция
376
;  * ecx = новый размер памяти
377
;Возвращаемое значение:
378
;  * eax = 0 - успешно
379
;  * eax = 1 - недостаточно памяти
1306 Lrz 380
 
2106 serge 381
align 4
1 ha 382
sys_resize_app_memory:
1306 Lrz 383
        ; ebx = 1 - resize
384
        ; ecx = new amount of memory
1 ha 385
 
1306 Lrz 386
;        cmp    eax,1
2434 Serge 387
        dec     ebx
388
        jnz     .no_application_mem_resize
4423 Serge 389
 
390
        mov     eax, [pg_data.pages_free]
391
        shl     eax, 12
392
        cmp     eax, ecx
393
        jae     @f
394
 
395
        xor     eax, eax
396
        inc     eax
397
        jmp     .store_result
398
@@:
1307 Lrz 399
        stdcall new_mem_resize, ecx
4423 Serge 400
.store_result:
2434 Serge 401
        mov     [esp+32], eax
164 serge 402
.no_application_mem_resize:
1056 Galkov 403
        ret
1 ha 404
 
405
iglobal
1056 Galkov 406
;  process_terminating  db 'K : Process - terminating',13,10,0
407
;  process_terminated   db 'K : Process - done',13,10,0
408
  msg_obj_destroy       db 'K : destroy app object',13,10,0
1 ha 409
endg
410
 
329 serge 411
; param
412
;  esi= slot
1 ha 413
 
2106 serge 414
align 4
1 ha 415
terminate: ; terminate application
5201 serge 416
destroy_thread:
1 ha 417
 
5201 serge 418
        .slot     equ esp+4             ;locals
419
        .process  equ esp               ;ptr to parent process
329 serge 420
 
5201 serge 421
 
2434 Serge 422
        push    esi        ;save .slot
334 serge 423
 
2434 Serge 424
        shl     esi, 8
5201 serge 425
        mov     edx, [SLOT_BASE+esi+APPDATA.process]
426
        test    edx, edx
427
        jnz     @F
2434 Serge 428
        pop     esi
429
        shl     esi, 5
430
        mov     [CURRENT_TASK+esi+TASKDATA.state], 9
431
        ret
334 serge 432
@@:
5201 serge 433
        push    edx                     ;save .process
3555 Serge 434
        lea     edx, [SLOT_BASE+esi]
435
        call    scheduler_remove_thread
436
        call    lock_application_table
1 ha 437
 
709 diamond 438
; if the process is in V86 mode...
1056 Galkov 439
        mov     eax, [.slot]
440
        shl     eax, 8
441
        mov     esi, [eax+SLOT_BASE+APPDATA.pl0_stack]
442
        add     esi, RING0_STACK_SIZE
443
        cmp     [eax+SLOT_BASE+APPDATA.saved_esp0], esi
444
        jz      .nov86
709 diamond 445
; ...it has page directory for V86 mode
1056 Galkov 446
        mov     esi, [eax+SLOT_BASE+APPDATA.saved_esp0]
447
        mov     ecx, [esi+4]
5201 serge 448
        mov     [eax+SLOT_BASE+APPDATA.process], ecx
709 diamond 449
; ...and I/O permission map for V86 mode
1056 Galkov 450
        mov     ecx, [esi+12]
451
        mov     [eax+SLOT_BASE+APPDATA.io_map], ecx
452
        mov     ecx, [esi+8]
453
        mov     [eax+SLOT_BASE+APPDATA.io_map+4], ecx
709 diamond 454
.nov86:
5201 serge 455
;destroy per-thread kernel objects
2434 Serge 456
        mov     esi, [.slot]
457
        shl     esi, 8
458
        add     esi, SLOT_BASE+APP_OBJ_OFFSET
329 serge 459
@@:
2434 Serge 460
        mov     eax, [esi+APPOBJ.fd]
461
        test    eax, eax
462
        jz      @F
334 serge 463
 
2434 Serge 464
        cmp     eax, esi
465
        je      @F
164 serge 466
 
2434 Serge 467
        push    esi
468
        call    [eax+APPOBJ.destroy]
1056 Galkov 469
           DEBUGF 1,"%s",msg_obj_destroy
2434 Serge 470
        pop     esi
471
        jmp     @B
329 serge 472
@@:
2434 Serge 473
        mov     esi, [.slot]
3555 Serge 474
        cmp     [fpu_owner], esi ; if user fpu last -> fpu user = 2
2434 Serge 475
        jne     @F
164 serge 476
 
3555 Serge 477
        mov     [fpu_owner], 2
478
        mov     eax, [256*2+SLOT_BASE+APPDATA.fpu_state]
2434 Serge 479
        clts
480
        bt      [cpu_caps], CAPS_SSE
481
        jnc     .no_SSE
482
        fxrstor [eax]
483
        jmp     @F
203 serge 484
.no_SSE:
2434 Serge 485
        fnclex
486
        frstor  [eax]
357 serge 487
@@:
203 serge 488
 
2434 Serge 489
        mov     [KEY_COUNT], byte 0    ; empty keyboard buffer
490
        mov     [BTN_COUNT], byte 0    ; empty button buffer
1 ha 491
 
492
 
92 diamond 493
; remove defined hotkeys
1056 Galkov 494
        mov     eax, hotkey_list
92 diamond 495
.loop:
1056 Galkov 496
        cmp     [eax+8], esi
497
        jnz     .cont
498
        mov     ecx, [eax]
499
        jecxz   @f
500
        push    dword [eax+12]
501
        pop     dword [ecx+12]
92 diamond 502
@@:
1056 Galkov 503
        mov     ecx, [eax+12]
504
        push    dword [eax]
505
        pop     dword [ecx]
506
        xor     ecx, ecx
507
        mov     [eax], ecx
508
        mov     [eax+4], ecx
509
        mov     [eax+8], ecx
510
        mov     [eax+12], ecx
92 diamond 511
.cont:
1056 Galkov 512
        add     eax, 16
513
        cmp     eax, hotkey_list+256*16
514
        jb      .loop
2987 Serge 515
; get process PID
516
        mov     eax, esi
517
        shl     eax, 5
518
        mov     eax, [eax+CURRENT_TASK+TASKDATA.pid]
519
; compare current lock input with process PID
520
        cmp     eax, [PID_lock_input]
521
        jne     @f
522
 
523
        xor     eax, eax
524
        mov     [PID_lock_input], eax
525
@@:
92 diamond 526
; remove hotkeys in buffer
1056 Galkov 527
        mov     eax, hotkey_buffer
92 diamond 528
.loop2:
1056 Galkov 529
        cmp     [eax], esi
530
        jnz     .cont2
531
        and     dword [eax+4], 0
532
        and     dword [eax], 0
92 diamond 533
.cont2:
1056 Galkov 534
        add     eax, 8
535
        cmp     eax, hotkey_buffer+120*8
536
        jb      .loop2
92 diamond 537
 
2434 Serge 538
        mov     ecx, esi          ; remove buttons
1 ha 539
  bnewba2:
2434 Serge 540
        mov     edi, [BTN_ADDR]
541
        mov     eax, edi
542
        cld
543
        movzx   ebx, word [edi]
544
        inc     bx
1 ha 545
  bnewba:
2434 Serge 546
        dec     bx
547
        jz      bnmba
548
        add     eax, 0x10
549
        cmp     cx, [eax]
550
        jnz     bnewba
551
        pusha
552
        mov     ecx, ebx
553
        inc     ecx
554
        shl     ecx, 4
555
        mov     ebx, eax
556
        add     eax, 0x10
557
        call    memmove
558
        dec     dword [edi]
559
        popa
560
        jmp     bnewba2
1 ha 561
  bnmba:
562
 
2434 Serge 563
        pusha   ; save window coordinates for window restoring
564
        cld
565
        shl     esi, 5
566
        add     esi, window_data
567
        mov     eax, [esi+WDATA.box.left]
568
        mov     [draw_limits.left], eax
569
        add     eax, [esi+WDATA.box.width]
570
        mov     [draw_limits.right], eax
571
        mov     eax, [esi+WDATA.box.top]
572
        mov     [draw_limits.top], eax
573
        add     eax, [esi+WDATA.box.height]
574
        mov     [draw_limits.bottom], eax
1 ha 575
 
2434 Serge 576
        xor     eax, eax
577
        mov     [esi+WDATA.box.left], eax
578
        mov     [esi+WDATA.box.width], eax
579
        mov     [esi+WDATA.box.top], eax
580
        mov     [esi+WDATA.box.height], eax
581
        mov     [esi+WDATA.cl_workarea], eax
582
        mov     [esi+WDATA.cl_titlebar], eax
583
        mov     [esi+WDATA.cl_frames], eax
5984 serge 584
        mov     dword [esi+WDATA.z_modif], eax; clear all flags: z_modif, wstate, redraw, wdrawn
2434 Serge 585
        lea     edi, [esi-window_data+draw_data]
586
        mov     ecx, 32/4
587
        rep stosd
588
        popa
1 ha 589
 
40 halyavin 590
; debuggee test
2434 Serge 591
        pushad
592
        mov     edi, esi
593
        shl     edi, 5
594
        mov     eax, [SLOT_BASE+edi*8+APPDATA.debugger_slot]
595
        test    eax, eax
596
        jz      .nodebug
3626 Serge 597
        movi    ecx, 8
2434 Serge 598
        push    dword [CURRENT_TASK+edi+TASKDATA.pid]; PID
599
        push    2
600
        call    debugger_notify
601
        pop     ecx
602
        pop     ecx
40 halyavin 603
.nodebug:
2434 Serge 604
        popad
40 halyavin 605
 
2434 Serge 606
        mov     ebx, [.slot]
607
        shl     ebx, 8
608
        push    ebx
609
        mov     ebx, [SLOT_BASE+ebx+APPDATA.pl0_stack]
1 ha 610
 
2434 Serge 611
        stdcall kernel_free, ebx
1 ha 612
 
2434 Serge 613
        pop     ebx
614
        mov     ebx, [SLOT_BASE+ebx+APPDATA.cur_dir]
615
        stdcall kernel_free, ebx
521 diamond 616
 
2434 Serge 617
        mov     edi, [.slot]
618
        shl     edi, 8
619
        add     edi, SLOT_BASE
465 serge 620
 
2434 Serge 621
        mov     eax, [edi+APPDATA.io_map]
622
        cmp     eax, [SLOT_BASE+256+APPDATA.io_map]
623
        je      @F
624
        call    free_page
465 serge 625
@@:
2434 Serge 626
        mov     eax, [edi+APPDATA.io_map+4]
627
        cmp     eax, [SLOT_BASE+256+APPDATA.io_map+4]
628
        je      @F
629
        call    free_page
465 serge 630
@@:
5201 serge 631
        lea     ebx, [edi+APPDATA.list]
632
        list_del ebx                    ;destroys edx, ecx
633
 
2434 Serge 634
        mov     eax, 0x20202020
635
        stosd
636
        stosd
637
        stosd
638
        mov     ecx, 244/4
639
        xor     eax, eax
640
        rep stosd
1 ha 641
 
102 poddubny 642
  ; activate window
2434 Serge 643
        movzx   eax, word [WIN_STACK + esi*2]
644
        cmp     eax, [TASK_COUNT]
645
        jne     .dont_activate
1056 Galkov 646
        pushad
102 poddubny 647
 .check_next_window:
2434 Serge 648
        dec     eax
649
        cmp     eax, 1
650
        jbe     .nothing_to_activate
651
        lea     esi, [WIN_POS+eax*2]
652
        movzx   edi, word [esi]              ; edi = process
653
        shl     edi, 5
654
        cmp     [CURRENT_TASK + edi + TASKDATA.state], byte 9 ; skip dead slots
655
        je      .check_next_window
656
        add     edi, window_data
154 diamond 657
; \begin{diamond}[19.09.2006]
658
; skip minimized windows
2434 Serge 659
        test    [edi + WDATA.fl_wstate], WSTATE_MINIMIZED
660
        jnz     .check_next_window
154 diamond 661
; \end{diamond}
2434 Serge 662
        call    waredraw
102 poddubny 663
 .nothing_to_activate:
1056 Galkov 664
        popad
102 poddubny 665
 .dont_activate:
666
 
1056 Galkov 667
        push    esi     ; remove hd1 & cd & flp reservation
668
        shl     esi, 5
669
        mov     esi, [esi+CURRENT_TASK+TASKDATA.pid]
670
        cmp     [cd_status], esi
671
        jnz     @f
672
        call    free_cd_channel
1306 Lrz 673
        and     [cd_status], 0
92 diamond 674
@@:
1056 Galkov 675
        pop     esi
676
        cmp     [bgrlockpid], esi
677
        jnz     @f
678
        and     [bgrlockpid], 0
1306 Lrz 679
        and     [bgrlock], 0
546 diamond 680
@@:
1 ha 681
 
2434 Serge 682
        pusha                 ; remove all port reservations
683
        mov     edx, esi
684
        shl     edx, 5
685
        add     edx, CURRENT_TASK
686
        mov     edx, [edx+TASKDATA.pid]
1 ha 687
 
688
  rmpr0:
689
 
2434 Serge 690
        mov     esi, [RESERVED_PORTS]
1 ha 691
 
2434 Serge 692
        test    esi, esi
693
        jz      rmpr9
1 ha 694
 
695
  rmpr3:
696
 
2434 Serge 697
        mov     edi, esi
698
        shl     edi, 4
699
        add     edi, RESERVED_PORTS
1 ha 700
 
2434 Serge 701
        cmp     edx, [edi]
702
        je      rmpr4
1 ha 703
 
2434 Serge 704
        dec     esi
705
        jnz     rmpr3
1 ha 706
 
2434 Serge 707
        jmp     rmpr9
1 ha 708
 
709
  rmpr4:
710
 
2434 Serge 711
        mov     ecx, 256
712
        sub     ecx, esi
713
        shl     ecx, 4
1 ha 714
 
2434 Serge 715
        mov     esi, edi
716
        add     esi, 16
717
        cld
718
        rep movsb
1 ha 719
 
2434 Serge 720
        dec     dword [RESERVED_PORTS]
1 ha 721
 
2434 Serge 722
        jmp     rmpr0
1 ha 723
 
724
  rmpr9:
725
 
2434 Serge 726
        popa
727
        mov     edi, esi ; do not run this process slot
728
        shl     edi, 5
729
        mov     [edi+CURRENT_TASK + TASKDATA.state], byte 9
40 halyavin 730
; debugger test - terminate all debuggees
2434 Serge 731
        mov     eax, 2
732
        mov     ecx, SLOT_BASE+2*0x100+APPDATA.debugger_slot
40 halyavin 733
.xd0:
2434 Serge 734
        cmp     eax, [TASK_COUNT]
735
        ja      .xd1
736
        cmp     dword [ecx], esi
737
        jnz     @f
738
        and     dword [ecx], 0
739
        pushad
740
        xchg    eax, ecx
741
        mov     ebx, 2
742
        call    sys_system
743
        popad
40 halyavin 744
@@:
2434 Serge 745
        inc     eax
746
        add     ecx, 0x100
747
        jmp     .xd0
40 halyavin 748
.xd1:
5201 serge 749
;release slot
750
 
751
        bts     [thr_slot_map], esi
752
 
753
        mov     ecx, [.process]
754
        lea     eax, [ecx+PROC.thr_list]
755
        cmp     eax, [eax+LHEAD.next]
756
        jne     @F
757
 
758
        call    destroy_process.internal
759
@@:
2434 Serge 760
        sti     ; .. and life goes on
1 ha 761
 
2434 Serge 762
        mov     eax, [draw_limits.left]
763
        mov     ebx, [draw_limits.top]
764
        mov     ecx, [draw_limits.right]
765
        mov     edx, [draw_limits.bottom]
766
        call    calculatescreen
767
        xor     eax, eax
768
        xor     esi, esi
769
        call    redrawscreen
1 ha 770
 
3555 Serge 771
        call    unlock_application_table
506 mikedld 772
    ;mov   esi,process_terminated
773
    ;call  sys_msg_board_str
5201 serge 774
        add     esp, 8
2434 Serge 775
        ret
345 serge 776
restore .slot
5201 serge 777
restore .process
1 ha 778
 
3500 Serge 779
; Three following procedures are used to guarantee that
780
; some part of kernel code will not be terminated from outside
781
; while it is running.
782
; Note: they do not protect a thread from terminating due to errors inside
783
; the thread; accessing a nonexisting memory would still terminate it.
784
 
785
; First two procedures must be used in pair by thread-to-be-protected
786
; to signal the beginning and the end of an important part.
787
; It is OK to have nested areas.
788
 
789
; The last procedure must be used by outside wanna-be-terminators;
790
; if it is safe to terminate the given thread immediately, it returns eax=1;
791
; otherwise, it returns eax=0 and notifies the target thread that it should
792
; terminate itself when leaving a critical area (the last critical area if
793
; they are nested).
794
 
795
; Implementation. Those procedures use one dword in APPDATA for the thread,
796
; APPDATA.terminate_protection.
797
; * The upper bit is 1 during normal operations and 0 when terminate is requested.
798
; * Other bits form a number = depth of critical regions,
799
;   plus 1 if the upper bit is 1.
800
; * When this dword goes to zero, the thread should be destructed,
801
;   and the procedure in which it happened becomes responsible for destruction.
802
 
803
; Enter critical area. Called by thread which wants to be protected.
804
proc protect_from_terminate
805
        mov     edx, [current_slot]
806
; Atomically increment depth of critical areas and get the old value.
807
        mov     eax, 1
808
        lock xadd [edx+APPDATA.terminate_protection], eax
809
; If the old value was zero, somebody has started to terminate us,
810
; so we are destructing and cannot do anything protected.
811
; Otherwise, return to the caller.
812
        test    eax, eax
813
        jz      @f
814
        ret
815
@@:
816
; Wait for somebody to finish us.
817
        call    change_task
818
        jmp     @b
819
endp
820
 
821
; Leave critical area. Called by thread which wants to be protected.
822
proc unprotect_from_terminate
823
        mov     edx, [current_slot]
824
; Atomically decrement depth of critical areas.
825
        lock dec [edx+APPDATA.terminate_protection]
826
; If the result of decrement is zero, somebody has requested termination,
827
; but at that moment we were inside a critical area; terminate now.
828
        jz      sys_end
829
; Otherwise, return to the caller.
830
        ret
831
endp
832
 
833
; Request termination of thread identified by edx = SLOT_BASE + slot*256.
834
; Called by anyone.
835
proc request_terminate
836
        xor     eax, eax        ; set return value
837
; Atomically clear the upper bit. If it was already zero, then
838
; somebody has requested termination before us, so just exit.
839
        lock btr [edx+APPDATA.terminate_protection], 31
840
        jnc     .unsafe
841
; Atomically decrement depth of critical areas.
842
        lock dec [edx+APPDATA.terminate_protection]
843
; If the result of decrement is nonzero, the target thread is inside a
844
; critical area; leave termination to leaving that area.
845
        jnz     .unsafe
846
; Otherwise, it is safe to kill the target now and the caller is responsible
847
; for this. Return eax=1.
848
        inc     eax
849
.unsafe:
850
        ret
851
endp
852