WebSVN – Kolibri OS – Blame – /kernel/trunk/core/dll.inc

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

Subversion Repositories Kolibri OS

(root)/kernel/trunk/core/dll.inc @ 819 – Rev 557