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

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

Subversion Repositories Kolibri OS

(root)/kernel/trunk/core/dll.inc – Rev 663