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

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

Subversion Repositories Kolibri OS

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