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: 593 $
		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]
465	serge	434	; sub ebx, new_app_base
188	serge	435	mov ecx, [info]
465	serge	436	; sub ecx, new_app_base
164	serge	437
188	serge	438	mov [cmd], 5
		439	mov [offset], eax
		440	mov [offset+4], eax
		441	mov [count], eax
		442	mov [buff], ecx
		443	mov byte [buff+4], al
		444	mov [name], ebx
164	serge	445
188	serge	446	mov eax, 70
		447	lea ebx, [cmd]
465	serge	448	; sub ebx, new_app_base
188	serge	449	int 0x40
		450	ret
		451	endp
164	serge	452
188	serge	453	align 4
		454	proc read_file stdcall,file_name:dword, buffer:dword, off:dword,\
		455	bytes:dword
		456	locals
		457	cmd dd ?
		458	offset dd ?
		459	dd ?
		460	count dd ?
		461	buff dd ?
		462	db ?
		463	name dd ?
		464	endl
164	serge	465
188	serge	466	xor eax, eax
		467	mov ebx, [file_name]
		468	mov ecx, [off]
		469	mov edx, [bytes]
		470	mov esi, [buffer]
164	serge	471
188	serge	472	mov [cmd], eax
		473	mov [offset], ecx
		474	mov [offset+4], eax
		475	mov [count], edx
		476	mov [buff], esi
		477	mov byte [buff+4], al
		478	mov [name], ebx
		479
429	serge	480	pushad
		481	push eax
		482	lea eax, [cmd]
		483	call file_system_lfn
		484	pop eax
		485	popad
188	serge	486	ret
		487	endp
		488
363	serge	489	; description
		490	; allocate kernel memory and loads the specified file
		491	;
		492	; param
		493	; file_name= full path to file
		494	;
		495	; retval
		496	; eax= file image in kernel memory
		497	; ebx= size of file
		498	;
		499	; warging
		500	; You mast call kernel_free() to delete each file
		501	; loaded by the load_file() function
		502
188	serge	503	align 4
		504	proc load_file stdcall, file_name:dword
		505	locals
		506	attr dd ?
		507	flags dd ?
		508	cr_time dd ?
		509	cr_date dd ?
		510	acc_time dd ?
		511	acc_date dd ?
		512	mod_time dd ?
		513	mod_date dd ?
		514	file_size dd ?
		515
		516	file dd ?
211	serge	517	file2 dd ?
188	serge	518	endl
		519
		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
188	serge	564	ret
		565	.cleanup:
		566	stdcall kernel_free, [file]
		567	.fail:
		568	xor eax, eax
237	serge	569	xor ebx, ebx
188	serge	570	ret
		571	endp
164	serge	572
188	serge	573	align 4
		574	proc get_proc_ex stdcall, proc_name:dword, imports:dword
		575
		576	.look_up:
		577	mov edx, [imports]
198	serge	578	test edx, edx
		579	jz .end
188	serge	580	mov edx, [edx]
		581	test edx, edx
		582	jz .end
		583	.next:
		584	mov eax, [edx]
164	serge	585	test eax, eax
188	serge	586	jz .next_table
164	serge	587
188	serge	588	push edx
		589	stdcall strncmp, eax, [proc_name], 16
		590	pop edx
		591	test eax, eax
		592	jz .ok
164	serge	593
188	serge	594	add edx,8
		595	jmp .next
		596	.next_table:
		597	add [imports], 4
		598	jmp .look_up
		599	.ok:
		600	mov eax, [edx+4]
		601	ret
		602	.end:
		603	xor eax, eax
		604	ret
		605	endp
164	serge	606
188	serge	607	align 4
		608	proc fix_coff_symbols stdcall, sec:dword, symbols:dword,\
		609	sym_count:dword, strings:dword, imports:dword
		610	locals
		611	retval dd ?
		612	endl
164	serge	613
188	serge	614	mov edi, [symbols]
		615	mov [retval], 1
		616	.fix:
		617	movzx ebx, [edi+CSYM.SectionNumber]
		618	test ebx, ebx
		619	jnz .internal
		620	mov eax, dword [edi+CSYM.Name]
		621	test eax, eax
		622	jnz @F
164	serge	623
188	serge	624	mov edi, [edi+4]
		625	add edi, [strings]
		626	@@:
		627	push edi
		628	stdcall get_proc_ex, edi,[imports]
		629	pop edi
164	serge	630
188	serge	631	xor ebx, ebx
		632	test eax, eax
		633	jnz @F
164	serge	634
188	serge	635	mov esi, msg_unresolved
		636	call sys_msg_board_str
		637	mov esi, edi
		638	call sys_msg_board_str
		639	mov esi, msg_CR
		640	call sys_msg_board_str
164	serge	641
188	serge	642	mov [retval],0
		643	@@:
		644	mov edi, [symbols]
		645	mov [edi+CSYM.Value], eax
		646	jmp .next
		647	.internal:
541	serge	648	cmp bx, -1
		649	je .next
		650	cmp bx, -2
		651	je .next
		652
188	serge	653	dec ebx
		654	shl ebx, 3
		655	lea ebx, [ebx+ebx*4]
		656	add ebx, [sec]
		657
		658	mov eax, [ebx+CFS.VirtualAddress]
		659	add [edi+CSYM.Value], eax
		660	.next:
		661	add edi, CSYM_SIZE
		662	mov [symbols], edi
		663	dec [sym_count]
		664	jnz .fix
		665	mov eax, [retval]
		666	ret
164	serge	667	endp
		668
		669	align 4
188	serge	670	proc fix_coff_relocs stdcall, coff:dword, sec:dword, sym:dword
164	serge	671	locals
188	serge	672	n_sec dd ?
164	serge	673	endl
		674
188	serge	675	mov eax, [coff]
		676	movzx ebx, [eax+CFH.nSections]
		677	mov [n_sec], ebx
		678	.fix_sec:
		679	mov esi, [sec]
164	serge	680	mov edi, [esi+CFS.PtrReloc]
188	serge	681	add edi, [coff]
164	serge	682
188	serge	683	movzx ecx, [esi+CFS.NumReloc]
		684	test ecx, ecx
		685	jz .next
		686	.next_reloc:
164	serge	687	mov ebx, [edi+CRELOC.SymIndex]
		688	add ebx,ebx
		689	lea ebx,[ebx+ebx*8]
188	serge	690	add ebx, [sym]
164	serge	691
188	serge	692	mov edx, [ebx+CSYM.Value]
164	serge	693
188	serge	694	cmp [edi+CRELOC.Type], 6
		695	je .dir_32
164	serge	696
188	serge	697	cmp [edi+CRELOC.Type], 20
		698	jne .next_reloc
		699	.rel_32:
164	serge	700	mov eax, [edi+CRELOC.VirtualAddress]
188	serge	701	add eax, [esi+CFS.VirtualAddress]
		702	sub edx, eax
		703	sub edx, 4
		704	jmp .fix
		705	.dir_32:
		706	mov eax, [edi+CRELOC.VirtualAddress]
		707	add eax, [esi+CFS.VirtualAddress]
		708	.fix:
		709	add [eax], edx
		710	add edi, 10
		711	dec ecx
		712	jnz .next_reloc
		713	.next:
206	serge	714	add [sec], COFF_SECTION_SIZE
188	serge	715	dec [n_sec]
		716	jnz .fix_sec
164	serge	717	.exit:
		718	ret
		719	endp
		720
188	serge	721	align 4
346	diamond	722	proc load_driver stdcall, driver_name:dword
188	serge	723	locals
		724	coff dd ?
		725	sym dd ?
		726	strings dd ?
		727	img_size dd ?
		728	img_base dd ?
		729	start dd ?
		730
		731	exports dd ? ;fake exports table
		732	dd ?
525	diamond	733	file_name rb 13+16+4+1 ; '/sys/drivers/.obj'
188	serge	734	endl
		735
465	serge	736	lea edx, [file_name]
525	diamond	737	mov dword [edx], '/sys'
		738	mov dword [edx+4], '/dri'
		739	mov dword [edx+8], 'vers'
		740	mov byte [edx+12], '/'
465	serge	741	mov esi, [driver_name]
525	diamond	742	lea edi, [edx+13]
465	serge	743	mov ecx, 16
346	diamond	744	@@:
465	serge	745	lodsb
		746	test al, al
		747	jz @f
		748	stosb
		749	loop @b
346	diamond	750	@@:
465	serge	751	mov dword [edi], '.obj'
		752	mov byte [edi+4], 0
346	diamond	753	stdcall load_file, edx
214	serge	754
188	serge	755	test eax, eax
227	serge	756	jz .exit
188	serge	757
		758	mov [coff], eax
		759
		760	movzx ecx, [eax+CFH.nSections]
		761	xor ebx, ebx
		762
		763	lea edx, [eax+20]
		764	@@:
		765	add ebx, [edx+CFS.SizeOfRawData]
		766	add ebx, 15
		767	and ebx, not 15
206	serge	768	add edx, COFF_SECTION_SIZE
188	serge	769	dec ecx
		770	jnz @B
		771	mov [img_size], ebx
		772
		773	stdcall kernel_alloc, ebx
		774	test eax, eax
		775	jz .fail
		776	mov [img_base], eax
		777
		778	mov edi, eax
		779	xor eax, eax
		780	mov ecx, [img_size]
		781	add ecx, 4095
		782	and ecx, not 4095
		783	shr ecx, 2
		784	cld
		785	rep stosd
		786
		787	mov edx, [coff]
		788	movzx ebx, [edx+CFH.nSections]
		789	mov edi, [img_base]
		790	lea eax, [edx+20]
		791	@@:
		792	mov [eax+CFS.VirtualAddress], edi
		793	mov esi, [eax+CFS.PtrRawData]
		794	test esi, esi
		795	jnz .copy
		796	add edi, [eax+CFS.SizeOfRawData]
		797	jmp .next
		798	.copy:
		799	add esi, edx
		800	mov ecx, [eax+CFS.SizeOfRawData]
		801	cld
		802	rep movsb
		803	.next:
		804	add edi, 15
		805	and edi, not 15
206	serge	806	add eax, COFF_SECTION_SIZE
188	serge	807	dec ebx
		808	jnz @B
		809
		810	mov ebx, [edx+CFH.pSymTable]
		811	add ebx, edx
		812	mov [sym], ebx
		813	mov ecx, [edx+CFH.nSymbols]
		814	add ecx,ecx
		815	lea ecx,[ecx+ecx8] ;ecx=18 = nSymbols*CSYM_SIZE
		816	add ecx, [sym]
		817	mov [strings], ecx
		818
		819	lea ebx, [exports]
		820	mov dword [ebx], kernel_export
		821	mov dword [ebx+4], 0
		822	lea eax, [edx+20]
		823
		824	stdcall fix_coff_symbols, eax, [sym], [edx+CFH.nSymbols],\
		825	[strings], ebx
		826	test eax, eax
227	serge	827	jz .link_fail
188	serge	828
		829	mov ebx, [coff]
		830	add ebx, 20
		831	stdcall fix_coff_relocs, [coff], ebx, [sym]
		832
		833	mov ebx, [coff]
227	serge	834	stdcall get_coff_sym,[sym],[ebx+CFH.nSymbols],szVersion
		835	test eax, eax
		836	jz .link_fail
		837
		838	mov eax, [eax]
		839	shr eax, 16
		840	cmp eax, DRV_COMPAT
		841	jb .ver_fail
		842
		843	cmp eax, DRV_CURRENT
		844	ja .ver_fail
		845
		846	mov ebx, [coff]
188	serge	847	stdcall get_coff_sym,[sym],[ebx+CFH.nSymbols],szSTART
		848	mov [start], eax
		849
		850	stdcall kernel_free, [coff]
		851
		852	mov ebx, [start]
214	serge	853	stdcall ebx, DRV_ENTRY
188	serge	854	test eax, eax
		855	jnz .ok
		856
		857	stdcall kernel_free, [img_base]
		858	xor eax, eax
		859	ret
		860	.ok:
		861	mov ebx, [img_base]
		862	mov [eax+SRV.base], ebx
214	serge	863	mov ecx, [start]
		864	mov [eax+SRV.entry], ecx
188	serge	865	ret
227	serge	866
		867	.ver_fail:
		868	mov esi, msg_CR
		869	call sys_msg_board_str
346	diamond	870	mov esi, [driver_name]
227	serge	871	call sys_msg_board_str
		872	mov esi, msg_CR
		873	call sys_msg_board_str
		874	mov esi, msg_version
		875	call sys_msg_board_str
		876	mov esi, msg_www
		877	call sys_msg_board_str
		878	jmp .cleanup
		879
		880	.link_fail:
		881	mov esi, msg_module
		882	call sys_msg_board_str
346	diamond	883	mov esi, [driver_name]
227	serge	884	call sys_msg_board_str
		885	mov esi, msg_CR
		886	call sys_msg_board_str
		887	.cleanup:
		888	stdcall kernel_free,[img_base]
188	serge	889	.fail:
227	serge	890	stdcall kernel_free, [coff]
		891	.exit:
188	serge	892	xor eax, eax
		893	ret
164	serge	894	endp
		895
198	serge	896	align 4
		897	proc load_library stdcall, file_name:dword
		898	locals
		899	coff dd ?
		900	sym dd ?
		901	strings dd ?
		902	img_size dd ?
		903	img_base dd ?
		904	exports dd ?
		905	endl
		906
		907	cli
		908
		909	stdcall load_file, [file_name]
		910	test eax, eax
		911	jz .fail
		912
		913	mov [coff], eax
		914	movzx ecx, [eax+CFH.nSections]
		915	xor ebx, ebx
		916
		917	lea edx, [eax+20]
		918	@@:
		919	add ebx, [edx+CFS.SizeOfRawData]
		920	add ebx, 15
		921	and ebx, not 15
206	serge	922	add edx, COFF_SECTION_SIZE
198	serge	923	dec ecx
		924	jnz @B
		925	mov [img_size], ebx
		926
		927	call init_heap
		928	stdcall user_alloc, [img_size]
		929
		930	test eax, eax
		931	jz .fail
		932	mov [img_base], eax
		933
		934	mov edx, [coff]
		935	movzx ebx, [edx+CFH.nSections]
		936	mov edi, [img_base]
		937	lea eax, [edx+20]
		938	@@:
		939	mov [eax+CFS.VirtualAddress], edi
		940	mov esi, [eax+CFS.PtrRawData]
		941	test esi, esi
		942	jnz .copy
		943	add edi, [eax+CFS.SizeOfRawData]
		944	jmp .next
		945	.copy:
		946	add esi, edx
465	serge	947	; add edi, new_app_base
198	serge	948	mov ecx, [eax+CFS.SizeOfRawData]
		949	cld
		950	rep movsb
		951	.next:
465	serge	952	add edi, 15 ;-new_app_base
		953	and edi, -16
206	serge	954	add eax, COFF_SECTION_SIZE
198	serge	955	dec ebx
		956	jnz @B
		957
		958	mov ebx, [edx+CFH.pSymTable]
		959	add ebx, edx
		960	mov [sym], ebx
		961	mov ecx, [edx+CFH.nSymbols]
		962	add ecx,ecx
		963	lea ecx,[ecx+ecx8] ;ecx=18 = nSymbols*CSYM_SIZE
		964	add ecx, [sym]
		965	mov [strings], ecx
		966
		967	lea eax, [edx+20]
		968
		969	stdcall fix_coff_symbols, eax, [sym], [edx+CFH.nSymbols],\
		970	[strings], dword 0
		971	test eax, eax
		972	jnz @F
		973
		974	@@:
		975	mov edx, [coff]
		976	movzx ebx, [edx+CFH.nSections]
		977	mov edi, new_app_base
		978	lea eax, [edx+20]
		979	@@:
		980	add [eax+CFS.VirtualAddress], edi ;patch user space offset
206	serge	981	add eax, COFF_SECTION_SIZE
198	serge	982	dec ebx
		983	jnz @B
		984
		985	add edx, 20
		986	stdcall fix_coff_relocs, [coff], edx, [sym]
		987
		988	mov ebx, [coff]
		989	stdcall get_coff_sym,[sym],[ebx+CFH.nSymbols],szEXPORTS
		990	mov [exports], eax
		991
		992	stdcall kernel_free, [coff]
		993	mov eax, [exports]
		994	ret
		995	.fail:
		996	xor eax, eax
		997	ret
		998	endp
		999
214	serge	1000	align 4
		1001	proc stop_all_services
278	serge	1002
		1003	mov edx, [srv.fd]
214	serge	1004	.next:
278	serge	1005	cmp edx, srv.fd-SRV_FD_OFFSET
		1006	je .done
		1007	cmp [edx+SRV.magic], ' SRV'
227	serge	1008	jne .next
278	serge	1009	cmp [edx+SRV.size], SRV_SIZE
227	serge	1010	jne .next
278	serge	1011	mov ebx, [edx+SRV.entry]
		1012	mov edx, [edx+SRV.fd]
		1013	push edx
214	serge	1014	stdcall ebx, dword -1
278	serge	1015	pop edx
214	serge	1016	jmp .next
278	serge	1017	.done:
		1018	ret
214	serge	1019	endp
198	serge	1020
281	serge	1021	; param
291	serge	1022	; eax= size
		1023	; ebx= pid
214	serge	1024
281	serge	1025	align 4
		1026	create_kernel_object:
		1027
		1028	push ebx
		1029	call malloc
		1030	pop ebx
		1031	test eax, eax
		1032	jz .fail
		1033
465	serge	1034	mov ecx,[current_slot]
		1035	add ecx, APP_OBJ_OFFSET
281	serge	1036
345	serge	1037	pushfd
		1038	cli
281	serge	1039	mov edx, [ecx+APPOBJ.fd]
		1040	mov [eax+APPOBJ.fd], edx
		1041	mov [eax+APPOBJ.bk], ecx
		1042	mov [eax+APPOBJ.pid], ebx
		1043
		1044	mov [ecx+APPOBJ.fd], eax
		1045	mov [edx+APPOBJ.bk], eax
345	serge	1046	popfd
281	serge	1047	.fail:
		1048	ret
		1049
		1050	; param
		1051	; eax= object
		1052
		1053	align 4
		1054	destroy_kernel_object:
		1055
345	serge	1056	pushfd
		1057	cli
281	serge	1058	mov ebx, [eax+APPOBJ.fd]
		1059	mov ecx, [eax+APPOBJ.bk]
		1060	mov [ebx+APPOBJ.bk], ecx
		1061	mov [ecx+APPOBJ.fd], ebx
345	serge	1062	popfd
281	serge	1063
		1064	xor edx, edx ;clear common header
		1065	mov [eax], edx
		1066	mov [eax+4], edx
		1067	mov [eax+8], edx
		1068	mov [eax+12], edx
		1069	mov [eax+16], edx
		1070
		1071	call free ;release object memory
		1072	ret
		1073
		1074
164	serge	1075
465	serge	1076	if 0
164	serge	1077
465	serge	1078	irq:
188	serge	1079
465	serge	1080	.irq0:
		1081	pusfd
		1082	pushad
		1083	push IRQ_0
		1084	jmp .master
		1085	.irq_1:
		1086	pusfd
		1087	pushad
		1088	push IRQ_1
		1089	jmp .master
		1090
		1091	.master:
		1092	mov ax, app_data
		1093	mov ds, eax
		1094	mov es, eax
		1095	mov ebx, [esp+4] ;IRQ_xx
		1096	mov eax, [irq_handlers+ebx+4]
		1097	call intr_handler
		1098	mov ecx, [esp+4]
		1099	cmp [irq_actids+ecx*4], 0
		1100	je @F
		1101	in al, 0x21
		1102	bts eax, ecx
		1103	out 0x21, al
		1104	mov al, 0x20
		1105	out 0x20, al
		1106	jmp .restart
		1107
		1108	.slave:
		1109	mov ax, app_data
		1110	mov ds, eax
		1111	mov es, eax
		1112	mov ebx, [esp+4] ;IRQ_xx
		1113	mov eax, [irq_handlers+ebx+4]
		1114	call intr_handler
		1115	mov ecx, [esp+4]
		1116	sub ecx, 8
		1117	cmp [irq_actids+ecx*4], 0
		1118	je @F
		1119	in al, 0xA1
		1120	bts eax, ecx
		1121	out 0xA1, al
		1122	mov al, 0x20
		1123	out 0xA0, al
		1124	out 0x20, al
		1125	.restart:
		1126	mov ebx, [next_slot]
		1127	test ebx, ebx
		1128	jz @F
		1129	mov [next_task],0
		1130	mov esi, [prev_slot]
		1131	call do_change_task
		1132	add esp, 4
		1133	iretd
		1134
		1135	end if
		1136

Subversion Repositories Kolibri OS

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