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

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

Subversion Repositories Kolibri OS

(root)/kernel/branches/kolibri_pe/core/dll.inc – Rev 2971