WebSVN – Kolibri OS – Blame – /kernel/branches/flat_kernel/core/dll.inc

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

Subversion Repositories Kolibri OS

(root)/kernel/branches/flat_kernel/core/dll.inc – Rev 444