Subversion Repositories Kolibri OS

Rev

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

Rev Author Line No. Line
164 serge 1
 
378 serge 2
DRV_CURRENT  equ  4  ;current drivers model version
3
214 serge 4
 
227 serge 5
6
 
164 serge 7
proc attach_int_handler stdcall, irq:dword, handler:dword
8
9
 
10
	 test ebx, ebx
11
	 jz .err
12
	 mov eax, [handler]
13
	 test eax, eax
14
	 jz .err
15
	 mov [irq_tab+ebx*4], eax
16
         stdcall enable_irq, [irq]
17
	 ret
18
.err:
19
	 xor eax, eax
20
	 ret
21
endp
22
23
 
24
proc  detach_int_handler
25
26
 
27
endp
28
29
 
30
proc enable_irq stdcall, irq_line:dword
31
           mov ebx, [irq_line]
32
           mov edx, 0x21
33
           cmp ebx, 8
34
           jb @F
35
           mov edx, 0xA1
36
           sub ebx,8
37
@@:
38
           in al,dx
39
           btr eax, ebx
40
           out dx, al
41
           ret
42
endp
43
44
 
45
;; proc irq_serv
46
47
 
48
49
 
50
	   push eax
51
	   mov eax, 1
52
	   jmp .main
53
align 4
54
.irq_2:
55
	   push eax
56
	   mov eax, 2
57
	   jmp .main
58
align 4
59
.irq_3:
60
	   push eax
61
	   mov eax, 3
62
	   jmp .main
63
align 4
64
.irq_4:
65
	   push eax
66
	   mov eax, 4
67
	   jmp .main
68
align 4
69
.irq_5:
70
	   push eax
71
	   mov eax, 5
72
	   jmp .main
73
align 4
74
.irq_6:
75
	   push eax
76
	   mov eax, 6
77
	   jmp .main
78
align 4
79
.irq_7:
80
	   push eax
81
	   mov eax, 7
82
	   jmp .main
83
align 4
84
.irq_8:
85
	   push eax
86
	   mov eax, 8
87
	   jmp .main
88
align 4
89
.irq_9:
90
	   push eax
91
	   mov eax, 9
92
	   jmp .main
93
align 4
94
.irq_10:
95
	   push eax
96
	   mov eax, 10
97
	   jmp .main
98
align 4
99
.irq_11:
100
	   push eax
101
	   mov eax, 11
102
	   jmp .main
103
align 4
104
.irq_12:
105
	   push eax
106
	   mov eax, 12
107
	   jmp .main
108
align 4
109
.irq_13:
110
	   push eax
111
	   mov eax, 13
112
	   jmp .main
113
align 4
114
.irq_14:
115
	   push eax
116
	   mov eax, 14
117
	   jmp .main
118
align 4
119
.irq_15:
120
	   push eax
121
	   mov eax, 15
122
	   jmp .main
123
124
 
125
.main:
126
	   save_ring3_context
127
           mov   bx, app_data  ;os_data
420 serge 128
	   mov	 ds, bx
164 serge 129
	   mov	 es, bx
130
131
 
132
	   test ebx, ebx
133
	   jz .exit
134
135
 
136
137
 
138
	   restore_ring3_context
139
140
 
141
	   mov al, 0x20
142
           jb @f
143
	   out 0xa0, al
144
@@:
145
           out 0x20, al
146
147
 
148
	   iret
149
150
 
151
proc get_notify stdcall, p_ev:dword
152
153
 
154
           mov ebx,[current_slot]
427 serge 155
           test dword [ebx+APPDATA.event_mask],EVENT_NOTIFY
156
	   jz @f
164 serge 157
           and dword [ebx+APPDATA.event_mask], not EVENT_NOTIFY
427 serge 158
	   mov edi, [p_ev]
164 serge 159
	   mov dword [edi], EV_INTR
160
           mov eax, [ebx+APPDATA.event]
427 serge 161
	   mov dword [edi+4], eax
164 serge 162
	   ret
163
@@:
164
	   call change_task
165
	   jmp .wait
166
endp
167
168
 
169
proc pci_read32 stdcall, bus:dword, devfn:dword, reg:dword
170
	   xor eax, eax
171
	   xor ebx, ebx
172
	   mov ah, byte [bus]
173
           mov al, 6
174
	   mov bh, byte [devfn]
175
	   mov bl, byte [reg]
176
	   call pci_read_reg
177
	   ret
178
endp
179
180
 
181
proc pci_read8 stdcall, bus:dword, devfn:dword, reg:dword
182
	   xor eax, eax
183
	   xor ebx, ebx
184
	   mov ah, byte [bus]
185
           mov al, 4
186
	   mov bh, byte [devfn]
187
	   mov bl, byte [reg]
188
	   call pci_read_reg
189
	   ret
190
endp
191
192
 
193
proc pci_write8 stdcall, bus:dword, devfn:dword, reg:dword, val:dword
194
	   xor eax, eax
195
	   xor ebx, ebx
196
	   mov ah, byte [bus]
197
           mov al, 8
198
	   mov bh, byte [devfn]
199
	   mov bl, byte [reg]
200
           mov ecx, [val]
201
           call pci_write_reg
202
	   ret
203
endp
204
205
 
206
io_code    equ  IOCTL.io_code
207
input      equ  IOCTL.input
208
inp_size   equ  IOCTL.inp_size
209
output     equ  IOCTL.output
210
out_size   equ  IOCTL.out_size
211
212
 
213
 
214
proc srv_handler stdcall, ioctl:dword
215
           mov esi, [ioctl]
216
           test esi, esi
217
           jz .err
218
219
 
220
           cmp [edi+SRV.magic], ' SRV'
221
	   jne .fail
222
223
 
224
	   jne .fail
225
226
 
227
           ret
228
.fail:
229
           xor eax, eax
230
           not eax
231
           mov [esi+output], eax
232
           mov [esi+out_size], 4
233
           ret
234
.err:
235
           xor eax, eax
236
           not eax
237
           ret
238
endp
239
240
 
377 serge 241
;  ebx= io_control
242
;
243
; retval
244
;  eax= error code
245
246
 
164 serge 247
srv_handlerEx:
377 serge 248
           cmp ebx, OS_BASE
432 serge 249
           jae .fail
250
164 serge 251
 
377 serge 252
           cmp [eax+SRV.magic], ' SRV'
253
	   jne .fail
164 serge 254
255
 
377 serge 256
	   jne .fail
164 serge 257
258
 
377 serge 259
           ret
164 serge 260
.fail:
261
           or eax, -1
377 serge 262
           ret
164 serge 263
264
 
265
restore  io_code
266
restore  input
267
restore  inp_size
268
restore  output
269
restore  out_size
270
271
 
272
proc get_service stdcall, sz_name:dword
273
           mov eax, [sz_name]
188 serge 274
           test eax, eax
275
           jnz @F
276
           ret
277
@@:
164 serge 278
           mov edx, [srv.fd]
278 serge 279
@@:
188 serge 280
           cmp edx, srv.fd-SRV_FD_OFFSET
278 serge 281
           je .not_load
282
283
 
284
           test eax, eax
188 serge 285
           je .ok
286
164 serge 287
 
278 serge 288
           jmp @B
289
.not_load:
164 serge 290
           pop ebp
346 diamond 291
           jmp load_driver
292
.ok:
164 serge 293
           mov eax, edx
278 serge 294
           ret
188 serge 295
endp
164 serge 296
297
 
298
reg_service:
278 serge 299
.sz_name equ esp+4
300
.handler equ esp+8
301
           mov eax, [.sz_name]
302
	   test eax, eax
164 serge 303
	   jz .fail
304
305
 
278 serge 306
	   test ebx, ebx
164 serge 307
	   jz .fail
308
309
 
278 serge 310
           call malloc           ;call alloc_service
311
	   test eax, eax
164 serge 312
	   jz .fail
313
314
 
315
           mov esi, [.sz_name]
278 serge 316
           mov ecx, 16/4
317
           rep movsd
318
164 serge 319
 
278 serge 320
           mov [eax+SRV.size], SRV_SIZE
321
322
 
323
           mov edx, [ebx+SRV.fd]
324
           mov [eax+SRV.fd], edx
325
           mov [eax+SRV.bk], ebx
326
           mov [ebx+SRV.fd], eax
327
           mov [edx+SRV.bk], eax
328
329
 
330
           mov [eax+SRV.srv_proc], ecx
331
           ret 8
281 serge 332
.fail:
164 serge 333
	   xor eax, eax
334
           ret 8
281 serge 335
164 serge 336
 
337
proc get_proc stdcall, exp:dword, sz_name:dword
338
339
 
340
.next:
341
           mov eax, [edx]
342
           test eax, eax
343
           jz .end
344
345
 
346
           stdcall strncmp, eax, [sz_name], 16
347
           pop edx
348
           test eax, eax
349
           jz .ok
350
351
 
352
           jmp .next
353
.ok:
354
           mov eax, [edx+4]
355
.end:
356
           ret
357
endp
358
359
 
360
proc get_coff_sym stdcall, pSym:dword,count:dword, sz_sym:dword
361
362
 
363
	   stdcall strncmp, [pSym], [sz_sym], 8
364
	   test eax,eax
365
	   jz .ok
366
	   add [pSym], 18
367
	   dec [count]
368
	   jnz @b
369
	   xor eax, eax
370
	   ret
371
.ok:
372
	   mov ebx, [pSym]
373
	   mov eax, [ebx+8]
374
	   ret
375
endp
376
377
 
378
proc get_curr_task
188 serge 379
           mov eax,[CURRENT_TASK]
380
           shl eax, 8
381
           ret
382
endp
383
164 serge 384
 
188 serge 385
proc get_fileinfo stdcall, file_name:dword, info:dword
386
           locals
387
             cmd     dd ?
388
             offset  dd ?
389
                     dd ?
390
             count   dd ?
391
             buff    dd ?
392
                     db ?
393
             name    dd ?
394
           endl
395
164 serge 396
 
188 serge 397
           mov ebx, [file_name]
398
    ;       sub ebx, new_app_base
419 serge 399
           mov ecx, [info]
188 serge 400
    ;       sub ecx, new_app_base
419 serge 401
164 serge 402
 
188 serge 403
           mov [offset], eax
404
           mov [offset+4], eax
405
           mov [count], eax
406
           mov [buff], ecx
407
           mov byte [buff+4], al
408
           mov [name], ebx
409
164 serge 410
 
188 serge 411
           lea ebx, [cmd]
412
     ;      sub ebx, new_app_base
419 serge 413
           int 0x40
188 serge 414
           ret
415
endp
416
164 serge 417
 
188 serge 418
proc read_file stdcall,file_name:dword, buffer:dword, off:dword,\
419
                                     bytes:dword
420
           locals
421
             cmd     dd ?
422
             offset  dd ?
423
                     dd ?
424
             count   dd ?
425
             buff    dd ?
426
                     db ?
427
             name    dd ?
428
           endl
429
164 serge 430
 
188 serge 431
           mov ebx, [file_name]
432
           mov ecx, [off]
433
           mov edx, [bytes]
434
           mov esi, [buffer]
435
164 serge 436
 
188 serge 437
           mov [offset], ecx
438
           mov [offset+4], eax
439
           mov [count], edx
440
           mov [buff], esi
441
           mov byte [buff+4], al
442
           mov [name], ebx
443
444
 
432 serge 445
           push eax
446
           lea eax, [cmd]
447
           call file_system_lfn
448
           pop eax
449
           popad
450
           ret
188 serge 451
endp
452
453
 
363 serge 454
;  allocate kernel memory and loads the specified file
455
;
456
; param
457
;  file_name= full path to file
458
;
459
; retval
460
;  eax= file image in kernel memory
461
;  ebx= size of file
462
;
463
; warging
464
;  You mast call kernel_free() to delete each file
465
;  loaded by the load_file() function
466
467
 
188 serge 468
proc load_file stdcall, file_name:dword
469
           locals
470
             attr       dd ?
471
             flags      dd ?
472
             cr_time    dd ?
473
             cr_date    dd ?
474
             acc_time   dd ?
475
             acc_date   dd ?
476
             mod_time   dd ?
477
             mod_date   dd ?
478
             file_size  dd ?
479
480
 
481
             file2      dd ?
211 serge 482
           endl
188 serge 483
484
 
485
           stdcall get_fileinfo, [file_name], eax
486
           test eax, eax
164 serge 487
           jnz .fail
188 serge 488
164 serge 489
 
206 serge 490
           cmp eax, 1024*1024*16
237 serge 491
           ja .fail
492
206 serge 493
 
188 serge 494
           mov [file], eax
495
164 serge 496
 
188 serge 497
           cmp ebx, [file_size]
498
           jne .cleanup
499
211 serge 500
 
188 serge 501
           cmp dword [eax], 0x4B43504B
211 serge 502
           jne .exit
503
           mov ebx, [eax+4]
237 serge 504
           mov [file_size], ebx
505
           stdcall kernel_alloc, ebx
506
211 serge 507
 
508
           jz .cleanup
509
510
 
511
           stdcall unpack, [file], eax
512
           stdcall kernel_free, [file]
513
           mov eax, [file2]
514
           mov ebx, [file_size]
237 serge 515
.exit:
211 serge 516
           push eax
269 serge 517
           lea edi, [eax+ebx]     ;cleanup remain space
518
           mov ecx, 4096          ;from file end
357 serge 519
           and ebx, 4095
520
           sub ecx, ebx
269 serge 521
           xor eax, eax
522
           cld
523
           rep stosb
524
           mov ebx, [file_size]
357 serge 525
           pop eax
269 serge 526
           ret
188 serge 527
.cleanup:
528
           stdcall kernel_free, [file]
529
.fail:
530
           xor eax, eax
531
           xor ebx, ebx
237 serge 532
           ret
188 serge 533
endp
534
164 serge 535
 
188 serge 536
proc get_proc_ex stdcall, proc_name:dword, imports:dword
537
538
 
539
           mov edx, [imports]
540
           test edx, edx
198 serge 541
           jz .end
542
           mov edx, [edx]
188 serge 543
           test edx, edx
544
           jz .end
545
.next:
546
           mov eax, [edx]
547
           test eax, eax
164 serge 548
           jz .next_table
188 serge 549
164 serge 550
 
188 serge 551
           stdcall strncmp, eax, [proc_name], 16
552
           pop edx
553
           test eax, eax
554
           jz .ok
555
164 serge 556
 
188 serge 557
           jmp .next
558
.next_table:
559
           add [imports], 4
560
           jmp .look_up
561
.ok:
562
           mov eax, [edx+4]
563
           ret
564
.end:
565
           xor eax, eax
566
           ret
567
endp
568
164 serge 569
 
188 serge 570
proc fix_coff_symbols stdcall, sec:dword, symbols:dword,\
571
                      sym_count:dword, strings:dword, imports:dword
572
           locals
573
             retval dd ?
574
           endl
575
164 serge 576
 
188 serge 577
           mov [retval], 1
578
.fix:
579
           movzx ebx, [edi+CSYM.SectionNumber]
580
           test ebx, ebx
581
           jnz .internal
582
           mov eax, dword [edi+CSYM.Name]
583
           test eax, eax
584
           jnz @F
585
164 serge 586
 
188 serge 587
           add edi, [strings]
588
@@:
589
           push edi
590
           stdcall get_proc_ex, edi,[imports]
591
           pop edi
592
164 serge 593
 
188 serge 594
           test eax, eax
595
           jnz @F
596
164 serge 597
 
188 serge 598
           call sys_msg_board_str
599
           mov esi, edi
600
           call sys_msg_board_str
601
           mov esi, msg_CR
602
           call sys_msg_board_str
603
164 serge 604
 
188 serge 605
@@:
606
           mov edi, [symbols]
607
           mov [edi+CSYM.Value], eax
608
           jmp .next
609
.internal:
610
           dec ebx
611
           shl ebx, 3
612
           lea ebx, [ebx+ebx*4]
613
           add ebx, [sec]
614
615
 
616
           add [edi+CSYM.Value], eax
617
.next:
618
           add edi, CSYM_SIZE
619
           mov [symbols], edi
620
           dec [sym_count]
621
           jnz .fix
622
           mov eax, [retval]
623
           ret
624
endp
164 serge 625
626
 
627
proc fix_coff_relocs stdcall, coff:dword, sec:dword, sym:dword
188 serge 628
	   locals
164 serge 629
             n_sec     dd ?
188 serge 630
	   endl
164 serge 631
632
 
188 serge 633
           movzx ebx, [eax+CFH.nSections]
634
           mov [n_sec], ebx
635
.fix_sec:
636
           mov esi, [sec]
637
	   mov edi, [esi+CFS.PtrReloc]
164 serge 638
           add edi, [coff]
188 serge 639
164 serge 640
 
188 serge 641
           test ecx, ecx
642
           jz .next
643
.next_reloc:
644
	   mov ebx, [edi+CRELOC.SymIndex]
164 serge 645
	   add ebx,ebx
646
	   lea ebx,[ebx+ebx*8]
647
           add ebx, [sym]
188 serge 648
164 serge 649
 
188 serge 650
164 serge 651
 
188 serge 652
           je .dir_32
653
164 serge 654
 
188 serge 655
           jne .next_reloc
656
.rel_32:
657
	   mov eax, [edi+CRELOC.VirtualAddress]
164 serge 658
           add eax, [esi+CFS.VirtualAddress]
188 serge 659
           sub edx, eax
660
           sub edx, 4
661
           jmp .fix
662
.dir_32:
663
	   mov eax, [edi+CRELOC.VirtualAddress]
664
           add eax, [esi+CFS.VirtualAddress]
665
.fix:
666
           add [eax], edx
667
           add edi, 10
668
           dec ecx
669
           jnz .next_reloc
670
.next:
671
           add [sec], COFF_SECTION_SIZE
206 serge 672
           dec [n_sec]
188 serge 673
           jnz .fix_sec
674
.exit:
164 serge 675
	   ret
676
endp
677
678
 
188 serge 679
proc load_driver stdcall, driver_name:dword
346 diamond 680
           locals
188 serge 681
             coff      dd ?
682
             sym       dd ?
683
             strings   dd ?
684
             img_size  dd ?
685
             img_base  dd ?
686
             start     dd ?
687
688
 
689
                       dd ?
690
             file_name rb 14+16+4+1      ; '/rd/1/drivers/.obj'
346 diamond 691
           endl
188 serge 692
693
 
417 serge 694
           mov     dword [edx], '/rd/'
695
           mov     dword [edx+4], '1/dr'
696
           mov     dword [edx+8], 'iver'
697
           mov     word [edx+12], 's/'
698
           mov     esi, [driver_name]
699
           lea     edi, [edx+14]
700
           mov     ecx, 16
701
@@:
346 diamond 702
           lodsb
417 serge 703
           test    al, al
704
           jz      @f
705
           stosb
706
           loop    @b
707
@@:
346 diamond 708
           mov     dword [edi], '.obj'
417 serge 709
           mov     byte [edi+4], 0
710
           stdcall load_file, edx
346 diamond 711
214 serge 712
 
188 serge 713
           jz .exit
227 serge 714
188 serge 715
 
716
717
 
718
           xor ebx, ebx
719
720
 
721
@@:
722
           add ebx, [edx+CFS.SizeOfRawData]
723
           add ebx, 15
724
           and ebx, not 15
725
           add edx, COFF_SECTION_SIZE
206 serge 726
           dec ecx
188 serge 727
           jnz @B
728
           mov [img_size], ebx
729
730
 
731
           test eax, eax
732
           jz .fail
733
           mov [img_base], eax
734
735
 
736
           xor eax, eax
737
           mov ecx, [img_size]
738
           add ecx, 4095
739
           and ecx, not 4095
740
           shr ecx, 2
741
           cld
742
           rep stosd
743
744
 
745
           movzx ebx, [edx+CFH.nSections]
746
           mov edi, [img_base]
747
           lea eax, [edx+20]
748
@@:
749
           mov [eax+CFS.VirtualAddress], edi
750
           mov esi, [eax+CFS.PtrRawData]
751
           test esi, esi
752
           jnz .copy
753
           add edi, [eax+CFS.SizeOfRawData]
754
           jmp .next
755
.copy:
756
           add esi, edx
757
           mov ecx, [eax+CFS.SizeOfRawData]
758
           cld
759
           rep movsb
760
.next:
761
           add edi, 15
762
           and edi, not 15
763
           add eax, COFF_SECTION_SIZE
206 serge 764
           dec ebx
188 serge 765
           jnz @B
766
767
 
768
           add ebx, edx
769
           mov [sym], ebx
770
           mov ecx, [edx+CFH.nSymbols]
771
           add ecx,ecx
772
           lea ecx,[ecx+ecx*8] ;ecx*=18 = nSymbols*CSYM_SIZE
773
           add ecx, [sym]
774
           mov [strings], ecx
775
776
 
777
           mov dword [ebx], kernel_export
778
           mov dword [ebx+4], 0
779
           lea eax, [edx+20]
780
781
 
782
                                     [strings], ebx
783
           test eax, eax
784
           jz .link_fail
227 serge 785
188 serge 786
 
787
           add ebx, 20
788
           stdcall fix_coff_relocs, [coff], ebx, [sym]
789
790
 
791
           stdcall get_coff_sym,[sym],[ebx+CFH.nSymbols],szVersion
227 serge 792
           test eax, eax
793
           jz .link_fail
794
795
 
796
           shr eax, 16
797
           cmp eax, DRV_COMPAT
798
           jb .ver_fail
799
800
 
801
           ja .ver_fail
802
803
 
804
           stdcall get_coff_sym,[sym],[ebx+CFH.nSymbols],szSTART
188 serge 805
           mov [start], eax
806
807
 
808
809
 
810
           stdcall ebx, DRV_ENTRY
214 serge 811
           test eax, eax
188 serge 812
           jnz .ok
813
814
 
815
           xor eax, eax
816
           ret
817
.ok:
818
           mov ebx, [img_base]
819
           mov [eax+SRV.base], ebx
820
           mov ecx, [start]
214 serge 821
           mov [eax+SRV.entry], ecx
822
           ret
188 serge 823
227 serge 824
 
825
           mov esi, msg_CR
826
           call sys_msg_board_str
827
           mov esi, [driver_name]
346 diamond 828
           call sys_msg_board_str
227 serge 829
           mov esi, msg_CR
830
           call sys_msg_board_str
831
           mov esi, msg_version
832
           call sys_msg_board_str
833
           mov esi, msg_www
834
           call sys_msg_board_str
835
           jmp .cleanup
836
837
 
838
           mov esi, msg_module
839
           call sys_msg_board_str
840
           mov esi, [driver_name]
346 diamond 841
           call sys_msg_board_str
227 serge 842
           mov esi, msg_CR
843
           call sys_msg_board_str
844
.cleanup:
845
           stdcall kernel_free,[img_base]
846
.fail:
188 serge 847
           stdcall kernel_free, [coff]
227 serge 848
.exit:
849
           xor eax, eax
188 serge 850
           ret
851
endp
164 serge 852
853
 
198 serge 854
proc load_library stdcall, file_name:dword
855
           locals
856
             coff      dd ?
857
             sym       dd ?
858
             strings   dd ?
859
             img_size  dd ?
860
             img_base  dd ?
861
             exports   dd ?
862
           endl
863
864
 
865
866
 
867
           test eax, eax
868
           jz .fail
869
870
 
871
           movzx ecx, [eax+CFH.nSections]
872
           xor ebx, ebx
873
874
 
875
@@:
876
           add ebx, [edx+CFS.SizeOfRawData]
877
           add ebx, 15
878
           and ebx, not 15
879
           add edx, COFF_SECTION_SIZE
206 serge 880
           dec ecx
198 serge 881
           jnz @B
882
           mov [img_size], ebx
883
884
 
885
           stdcall user_alloc, [img_size]
886
887
 
888
           jz .fail
889
           mov [img_base], eax
890
891
 
892
           movzx ebx, [edx+CFH.nSections]
893
           mov edi, [img_base]
894
           lea eax, [edx+20]
895
@@:
896
           mov [eax+CFS.VirtualAddress], edi
897
           mov esi, [eax+CFS.PtrRawData]
898
           test esi, esi
899
           jnz .copy
900
           add edi, [eax+CFS.SizeOfRawData]
901
           jmp .next
902
.copy:
903
           add esi, edx
904
    ;       add edi, new_app_base
419 serge 905
           mov ecx, [eax+CFS.SizeOfRawData]
198 serge 906
           cld
907
           rep movsb
908
.next:
909
           add edi, 15 ;-new_app_base
419 serge 910
           and edi, -16
911
           add eax, COFF_SECTION_SIZE
206 serge 912
           dec ebx
198 serge 913
           jnz @B
914
915
 
916
           add ebx, edx
917
           mov [sym], ebx
918
           mov ecx, [edx+CFH.nSymbols]
919
           add ecx,ecx
920
           lea ecx,[ecx+ecx*8] ;ecx*=18 = nSymbols*CSYM_SIZE
921
           add ecx, [sym]
922
           mov [strings], ecx
923
924
 
925
926
 
927
                                     [strings], dword 0
928
           test eax, eax
929
           jnz @F
930
931
 
932
           mov edx, [coff]
933
           movzx ebx, [edx+CFH.nSections]
934
           mov edi, new_app_base
935
           lea eax, [edx+20]
936
@@:
937
           add [eax+CFS.VirtualAddress], edi  ;patch user space offset
938
           add eax, COFF_SECTION_SIZE
206 serge 939
           dec ebx
198 serge 940
           jnz @B
941
942
 
943
           stdcall fix_coff_relocs, [coff], edx, [sym]
944
945
 
946
           stdcall get_coff_sym,[sym],[ebx+CFH.nSymbols],szEXPORTS
947
           mov [exports], eax
948
949
 
950
           mov eax, [exports]
951
           ret
952
.fail:
953
           xor eax, eax
954
           ret
955
endp
956
957
 
214 serge 958
proc stop_all_services
959
278 serge 960
 
961
.next:
214 serge 962
           cmp edx,  srv.fd-SRV_FD_OFFSET
278 serge 963
           je .done
964
           cmp [edx+SRV.magic], ' SRV'
965
           jne .next
227 serge 966
           cmp [edx+SRV.size], SRV_SIZE
278 serge 967
           jne .next
227 serge 968
           mov ebx, [edx+SRV.entry]
278 serge 969
           mov edx, [edx+SRV.fd]
970
           push edx
971
           stdcall ebx, dword -1
214 serge 972
           pop edx
278 serge 973
           jmp .next
214 serge 974
.done:
278 serge 975
           ret
976
endp
214 serge 977
198 serge 978
 
281 serge 979
;  eax= size
291 serge 980
;  ebx= pid
981
214 serge 982
 
281 serge 983
create_kernel_object:
984
985
 
986
           call malloc
987
           pop ebx
988
           test eax, eax
989
           jz .fail
990
991
 
427 serge 992
           add ecx, APP_OBJ_OFFSET
993
281 serge 994
 
345 serge 995
           cli
996
           mov edx, [ecx+APPOBJ.fd]
281 serge 997
           mov [eax+APPOBJ.fd], edx
998
           mov [eax+APPOBJ.bk], ecx
999
           mov [eax+APPOBJ.pid], ebx
1000
1001
 
1002
           mov [edx+APPOBJ.bk], eax
1003
           popfd
345 serge 1004
.fail:
281 serge 1005
           ret
1006
1007
 
1008
;  eax= object
1009
1010
 
1011
destroy_kernel_object:
1012
1013
 
345 serge 1014
           cli
1015
           mov ebx, [eax+APPOBJ.fd]
281 serge 1016
           mov ecx, [eax+APPOBJ.bk]
1017
           mov [ebx+APPOBJ.bk], ecx
1018
           mov [ecx+APPOBJ.fd], ebx
1019
           popfd
345 serge 1020
281 serge 1021
 
1022
           mov [eax], edx
1023
           mov [eax+4], edx
1024
           mov [eax+8], edx
1025
           mov [eax+12], edx
1026
           mov [eax+16], edx
1027
1028
 
1029
           ret
1030
1031
 
1032
 
427 serge 1033
 
1034
1035
 
1036
1037
 
1038
           pusfd
1039
           pushad
1040
           push IRQ_0
1041
           jmp .master
1042
.irq_1:
1043
           pusfd
1044
           pushad
1045
           push IRQ_1
1046
           jmp .master
1047
1048
 
1049
           mov ax, app_data
1050
           mov ds, eax
1051
           mov es, eax
1052
           mov ebx, [esp+4]  ;IRQ_xx
1053
           mov eax, [irq_handlers+ebx+4]
1054
           call intr_handler
1055
           mov ecx, [esp+4]
1056
           cmp [irq_actids+ecx*4], 0
1057
           je @F
1058
           in al, 0x21
1059
           bts eax, ecx
1060
           out 0x21, al
1061
           mov al, 0x20
1062
           out 0x20, al
1063
           jmp .restart
1064
1065
 
1066
           mov ax, app_data
1067
           mov ds, eax
1068
           mov es, eax
1069
           mov ebx, [esp+4]  ;IRQ_xx
1070
           mov eax, [irq_handlers+ebx+4]
1071
           call intr_handler
1072
           mov ecx, [esp+4]
1073
           sub ecx, 8
1074
           cmp [irq_actids+ecx*4], 0
1075
           je @F
1076
           in al, 0xA1
1077
           bts eax, ecx
1078
           out 0xA1, al
1079
           mov al, 0x20
1080
           out 0xA0, al
1081
           out 0x20, al
1082
.restart:
1083
           mov ebx, [next_slot]
1084
           test ebx, ebx
1085
           jz @F
1086
           mov [next_task],0
1087
           mov esi, [prev_slot]
1088
           call do_change_task
1089
           add esp, 4
1090
           iretd
1091
1092
 
1093