WebSVN – Kolibri OS – Blame – /kernel/trunk/fs/ext.inc

Rev	Author	Line No.	Line
6462	pathoswith	1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
		2	;; ;;
		3	;; Copyright (C) KolibriOS team 2013-2016. All rights reserved. ;;
		4	;; Distributed under terms of the GNU General Public License. ;;
		5	;; ;;
		6	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
		7
		8	$Revision: 6462 $
		9
		10	; EXT external functions
		11	; in:
		12	; ebx -> parameter structure of sysfunc 70
		13	; ebp -> EXTFS structure
		14	; [esi]+[[esp+4]] = name
		15	; out:
		16	; eax, ebx = return values for sysfunc 70
		17	iglobal
		18	align 4
		19	ext_user_functions:
		20	dd ext_free
		21	dd (ext_user_functions_end - ext_user_functions - 4) / 4
		22	dd ext_ReadFile
		23	dd ext_ReadFolder
		24	dd ext_CreateFile
		25	dd ext_WriteFile
		26	dd ext_SetFileEnd
		27	dd ext_GetFileInfo
		28	dd ext_SetFileInfo
		29	dd 0
		30	dd ext_Delete
		31	dd ext_CreateFolder
		32	ext_user_functions_end:
		33	endg
		34
		35	struct DIRENTRY
		36	inodeNumber dd ?
		37	entryLength dw ?
		38	nameLength db ?
		39	fileType db ?
		40	name db ? ; rb [nameLength]
		41	ends
		42
		43	struct INODE
		44	accessMode dw ?
		45	UID dw ?
		46	fileSize dd ?
		47	accessedTime dd ?
		48	inodeModified dd ?
		49	dataModified dd ?
		50	deletedTime dd ?
		51	GID dw ?
		52	linksCount dw ?
		53	sectorsUsed dd ?
		54	featureFlags dd ?
		55	reserved dd ?
		56	blockNumbers rd 12
		57	addressBlock dd ?
		58	doubleAddress dd ?
		59	tripleAddress dd ?
		60	generation dd ?
		61	ACL dd ?
		62	fileSizeHigh dd ?
		63	ends
		64
		65	struct BGDESCR ; block group descriptor
		66	blockBitmap dd ?
		67	inodeBitmap dd ?
		68	inodeTable dd ?
		69	blocksFree dw ?
		70	inodesFree dw ?
		71	directoriesCount dw ?
		72	reserved rb 14
		73	ends
		74
		75	struct SUPERBLOCK
		76	inodesTotal dd ?
		77	blocksTotal dd ?
		78	blocksReserved dd ?
		79	blocksFree dd ?
		80	inodesFree dd ?
		81	firstGroupBlock dd ?
		82	sectorsPerBlockLog dd ? ; shift for 1024
		83	fragmentSizeLog dd ?
		84	blocksPerGroup dd ?
		85	fragmentsPerGroup dd ?
		86	inodesPerGroup dd ?
		87	lastMountTime dd ?
		88	lastWriteTime dd ?
		89	mountCount dw ?
		90	mountMax dw ?
		91	magic dw ?
		92	state dw ?
		93	errorHandling dw ?
		94	additionalVersion dw ?
		95	lastCheck dd ?
		96	checkInterval dd ?
		97	creatorOS dd ?
		98	dynamicVersionFlag dd ?
		99	reservedUID dw ?
		100	reservedGID dw ?
		101	firstInode dd ?
		102	inodeSize dw ?
		103	thisBlockGroup dw ?
		104	compatibleFlags dd ?
		105	incompatibleFlags dd ?
		106	RO_compatibleFlags dd ?
		107	ends
		108
		109	; ext4 extent tree
		110	struct NODEHEADER ; tree node header
		111	magic dw ? ; 0xF30A
		112	entriesFolow dw ?
		113	entriesMax dw ?
		114	currentDepth dw ?
		115	generation dd ?
		116	ends
		117
		118	struct INDEX ; root/branch
		119	fileBlock dd ?
		120	nodeBlock dd ?
		121	nodeBlockHigh dw ?
		122	reserved dw ?
		123	ends
		124
		125	struct EXTENT ; leaf
		126	fileBlock dd ?
		127	blocksCount dw ?
		128	fsBlockHigh dw ?
		129	fsBlock dd ?
		130	ends
		131
		132	ROOT_INODE = 2
		133	PERMISSIONS = 110110110b
		134	EXTENTS_USED = 80000h
		135	TYPE_MASK = 0F000h
		136	FLAG_FILE = 8000h
		137	DIRECTORY = 4000h
		138	DIR_FLAG_FILE = 1
		139	DIR_DIRECTORY = 2
		140	KOS_HIDDEN = 2
		141	KOS_DIRECTORY = 10h
		142	READ_ONLY = 1
		143
		144	; Implemented "incompatible" features:
		145	; 2 = have file type in directory entry
		146	; 40h = extents
		147	; 200h = flexible block groups
		148	INCOMPATIBLE_SUPPORT = 242h
		149	; Read only support for "incompatible" features:
		150	INCOMPATIBLE_READ_SUPPORT = 240h
		151
		152	; Implemented "read-only" features:
		153	; 1 = sparse superblock
		154	; 2 = 64-bit file size
		155	READ_ONLY_SUPPORT = 3
		156
		157	struct EXTFS PARTITION
		158	Lock MUTEX
		159	mountType dd ?
		160	sectorsPerBlockLog dd ? ; shift for 512
		161	bytesPerBlock dd ?
		162	sectorsPerBlock dd ?
		163	dwordsPerBlock dd ?
		164	dwordsPerBranch dd ? ; dwordsPerBlock ^ 2
		165	mainBlockBuffer dd ?
		166	tempBlockBuffer dd ?
		167	align 512
		168	superblock SUPERBLOCK
		169	align 1024
		170	rootInodeBuffer INODE
		171	align 1024
		172	mainInodeBuffer INODE
		173	align 1024
		174	tempInodeBuffer INODE
		175	ends
		176
		177	; mount if it's a valid EXT partition
		178	ext2_create_partition:
		179	; in:
		180	; ebp -> PARTITION structure
		181	; ebx -> boot sector
		182	; ebx+512 -> buffer
		183	; out:
		184	; eax -> EXTFS structure, 0 = not EXT
		185	push ebx
		186	cmp dword [esi+DISK.MediaInfo.SectorSize], 512
		187	jnz .fail
		188	mov eax, 2
		189	add ebx, 512
		190	call fs_read32_sys
		191	test eax, eax
		192	jnz .fail
		193	cmp [ebx+SUPERBLOCK.magic], 0xEF53
		194	jne .fail
		195	cmp [ebx+SUPERBLOCK.state], 1
		196	jne .fail
		197	test [ebx+SUPERBLOCK.incompatibleFlags], not INCOMPATIBLE_SUPPORT
		198	jnz .fail
		199	cmp [ebx+SUPERBLOCK.sectorsPerBlockLog], 6 ; 64KB
		200	ja .fail
		201	cmp [ebx+SUPERBLOCK.inodeSize], 1024
		202	ja .fail
		203	cmp [ebx+SUPERBLOCK.blocksPerGroup], 0
		204	je .fail
		205	cmp [ebx+SUPERBLOCK.inodesPerGroup], 0
		206	je .fail
		207	stdcall kernel_alloc, 1000h
		208	test eax, eax
		209	jz .fail
		210	mov ecx, dword [ebp+PARTITION.FirstSector]
		211	mov dword [eax+EXTFS.FirstSector], ecx
		212	mov ecx, dword [ebp+PARTITION.FirstSector+4]
		213	mov dword [eax+EXTFS.FirstSector+4], ecx
		214	mov ecx, dword [ebp+PARTITION.Length]
		215	mov dword [eax+EXTFS.Length], ecx
		216	mov ecx, dword [ebp+PARTITION.Length+4]
		217	mov dword [eax+EXTFS.Length+4], ecx
		218	mov ecx, [ebp+PARTITION.Disk]
		219	mov [eax+EXTFS.Disk], ecx
		220	mov [eax+EXTFS.FSUserFunctions], ext_user_functions
		221
		222	push ebp esi edi
		223	mov ebp, eax
		224	lea ecx, [eax+EXTFS.Lock]
		225	call mutex_init
		226	mov esi, ebx
		227	lea edi, [ebp+EXTFS.superblock]
		228	mov ecx, 512/4
		229	rep movsd ; copy superblock
		230	mov ecx, [ebx+SUPERBLOCK.sectorsPerBlockLog]
		231	inc ecx
		232	mov [ebp+EXTFS.sectorsPerBlockLog], ecx
		233	mov eax, 1
		234	shl eax, cl
		235	mov [ebp+EXTFS.sectorsPerBlock], eax
		236	shl eax, 9
		237	mov [ebp+EXTFS.bytesPerBlock], eax
		238	shl eax, 1
		239	push eax
		240	shr eax, 3
		241	mov [ebp+EXTFS.dwordsPerBlock], eax
		242	mul eax
		243	mov [ebp+EXTFS.dwordsPerBranch], eax
		244	call kernel_alloc
		245	test eax, eax
		246	jz .error
		247	mov [ebp+EXTFS.mainBlockBuffer], eax
		248	add eax, [ebp+EXTFS.bytesPerBlock]
		249	mov [ebp+EXTFS.tempBlockBuffer], eax
		250	mov [ebp+EXTFS.mountType], 0
		251	test [ebx+SUPERBLOCK.RO_compatibleFlags], not READ_ONLY_SUPPORT
		252	jnz .read_only
		253	test [ebx+SUPERBLOCK.incompatibleFlags], INCOMPATIBLE_READ_SUPPORT
		254	jz @f
		255	.read_only:
		256	or [ebp+EXTFS.mountType], READ_ONLY
		257	@@: ; read root inode
		258	lea ebx, [ebp+EXTFS.rootInodeBuffer]
		259	mov eax, ROOT_INODE
		260	call readInode
		261	test eax, eax
		262	jnz @f
		263	mov eax, ebp
		264	pop edi esi ebp ebx
		265	ret
		266
		267	@@:
		268	stdcall kernel_free, [ebp+EXTFS.mainBlockBuffer]
		269	.error:
		270	stdcall kernel_free, ebp
		271	pop edi esi ebp
		272	.fail:
		273	pop ebx
		274	xor eax, eax
		275	ret
		276
		277	; unmount EXT partition
		278	ext_free:
		279	; in: eax -> EXTFS structure
		280	push eax
		281	stdcall kernel_free, [eax+EXTFS.mainBlockBuffer]
		282	call kernel_free
		283	ret
		284
		285	extfsWriteBlock:
		286	push fs_write64_sys
		287	jmp @f
		288	; in:
		289	; eax = block number
		290	; ebx -> buffer
		291	extfsReadBlock:
		292	push fs_read64_sys
		293	@@:
		294	push ecx edx
		295	mov ecx, [ebp+EXTFS.sectorsPerBlock]
		296	mul ecx
		297	call dword[esp+8]
		298	pop edx ecx
		299	add esp, 4
		300	test eax, eax
		301	jz @f
		302	movi eax, ERROR_DEVICE
		303	stc
		304	@@:
		305	ret
		306
		307	extfsReadDescriptor:
		308	; in: eax = block group number
		309	; out:
		310	; [ebp+EXTFS.tempBlockBuffer] -> relevant block
		311	; eax -> block group descriptor, 0 = error
		312	push edx ebx
		313	shl eax, 5
		314	xor edx, edx
		315	div [ebp+EXTFS.bytesPerBlock]
		316	add eax, [ebp+EXTFS.superblock.firstGroupBlock]
		317	inc eax
		318	mov ebx, [ebp+EXTFS.tempBlockBuffer]
		319	call extfsReadBlock
		320	jc .fail
		321	mov eax, ebx
		322	add eax, edx
		323	@@:
		324	pop ebx edx
		325	ret
		326
		327	.fail:
		328	xor eax, eax
		329	stc
		330	jmp @b
		331
		332	extfsWriteDescriptor:
		333	; in:
		334	; eax = block group number
		335	; [ebp+EXTFS.tempBlockBuffer] -> relevant block
		336	push edx ebx
		337	shl eax, 5
		338	xor edx, edx
		339	div [ebp+EXTFS.bytesPerBlock]
		340	add eax, [ebp+EXTFS.superblock.firstGroupBlock]
		341	inc eax
		342	mov ebx, [ebp+EXTFS.tempBlockBuffer]
		343	call extfsWriteBlock
		344	pop ebx edx
		345	ret
		346
		347	extfsResourceFree:
		348	; in:
		349	; ecx=0 -> block, ecx=1 -> inode
		350	; eax = block/inode number
		351	push ebx edx
		352	sub eax, [ebp+EXTFS.superblock.firstGroupBlock]
		353	xor edx, edx
		354	div [ebp+EXTFS.superblock.blocksPerGroup]
		355	push eax edx
		356	call extfsReadDescriptor
		357	jc .fail
		358	inc [eax+BGDESCR.blocksFree+ecx*2]
		359	mov eax, [eax+BGDESCR.blockBitmap+ecx*4]
		360	mov ebx, [ebp+EXTFS.mainBlockBuffer]
		361	mov edx, eax
		362	call extfsReadBlock
		363	jc .fail
		364	pop eax
		365	push edx
		366	mov edx, eax
		367	and edx, 31
		368	shr eax, 5
		369	shl eax, 2
		370	add eax, [ebp+EXTFS.mainBlockBuffer]
		371	btr [eax], edx
		372	pop eax
		373	mov ebx, [ebp+EXTFS.mainBlockBuffer]
		374	call extfsWriteBlock
		375	jc @f
		376	inc [ebp+EXTFS.superblock.blocksFree+ecx*4]
		377	pop eax
		378	call extfsWriteDescriptor
		379	.ret:
		380	pop edx ebx
		381	ret
		382
		383	.fail:
		384	pop eax
		385	@@:
		386	pop eax
		387	movi eax, ERROR_DEVICE
		388	jmp .ret
		389
		390	freeDoublyIndirectBlock:
		391	; in: eax = doubly-indirect block number
		392	; out: eax=1 -> finished
		393	test eax, eax
		394	jz .complete
		395	push eax
		396	mov ebx, [ebp+EXTFS.tempBlockBuffer]
		397	call extfsReadBlock
		398	pop eax
		399	jc .ret
		400	xor ecx, ecx
		401	call extfsResourceFree
		402	mov edx, ebx
		403	add edx, [ebp+EXTFS.bytesPerBlock]
		404	@@:
		405	mov eax, [ebx]
		406	test eax, eax
		407	jz .complete
		408	call extfsResourceFree
		409	add ebx, 4
		410	cmp ebx, edx
		411	jb @b
		412	.ret:
		413	xor eax, eax
		414	ret
		415
		416	.complete:
		417	inc eax
		418	ret
		419
		420	inodeBlockAlloc:
		421	; in: esi -> inode
		422	; out: ebx = block number
		423	; TODO: fix to have correct preference.
		424	mov eax, ROOT_INODE
		425	call extfsBlockAlloc
		426	jc @f
		427	mov eax, [ebp+EXTFS.sectorsPerBlock]
		428	add [esi+INODE.sectorsUsed], eax
		429	xor eax, eax
		430	@@:
		431	ret
		432
		433	extfsBlockAlloc: ; also erases
		434	; in: eax = inode number
		435	; out: ebx = block number
		436	xor ebx, ebx
		437	call extfsResourceAlloc
		438	jc @f
		439	push ebx ecx edi
		440	mov ecx, [ebp+EXTFS.dwordsPerBlock]
		441	mov edi, [ebp+EXTFS.tempBlockBuffer]
		442	mov ebx, edi
		443	xor eax, eax
		444	rep stosd
		445	pop edi ecx
		446	mov eax, [esp]
		447	call extfsWriteBlock
		448	pop ebx
		449	@@:
		450	ret
		451
		452	extfsResourceAlloc:
		453	; in:
		454	; eax = inode number
		455	; ebx=0 -> block, ebx=1 -> inode
		456	; out:
		457	; ebx = block/inode number
		458	push ecx edx esi edi
		459	dec eax
		460	xor edx, edx
		461	div [ebp+EXTFS.superblock.inodesPerGroup]
		462	push eax eax
		463	mov esi, .forward ; search forward, then backward
		464	.test_block_group:
		465	call extfsReadDescriptor
		466	jc .fail
		467	dec [eax+BGDESCR.blocksFree+ebx*2]
		468	mov eax, [eax+BGDESCR.blockBitmap+ebx*4]
		469	push ebx
		470	mov ebx, [ebp+EXTFS.mainBlockBuffer]
		471	mov edx, eax
		472	mov edi, ebx
		473	call extfsReadBlock
		474	pop ebx
		475	jc .fail
		476	mov ecx, [ebp+EXTFS.superblock.blocksPerGroup+ebx*8]
		477	or eax, -1
		478	shr ecx, 5
		479	jz .next
		480	repz scasd
		481	jz .next
		482	sub edi, 4
		483	mov eax, [edi]
		484	not eax
		485	bsf eax, eax
		486	bts [edi], eax
		487	sub edi, [ebp+EXTFS.mainBlockBuffer]
		488	shl edi, 3
		489	add eax, edi
		490	mov ecx, eax
		491	mov eax, edx
		492	push ebx
		493	mov ebx, [ebp+EXTFS.mainBlockBuffer]
		494	call extfsWriteBlock
		495	pop ebx
		496	jc .fail
		497	mov eax, [esp]
		498	mul [ebp+EXTFS.superblock.blocksPerGroup+ebx*8]
		499	add eax, ecx
		500	dec [ebp+EXTFS.superblock.blocksFree+ebx*4]
		501	mov ebx, eax
		502	pop eax
		503	add esp, 4
		504	call extfsWriteDescriptor
		505	@@:
		506	pop edi esi edx ecx
		507	ret
		508
		509	.fail:
		510	pop eax eax
		511	movi eax, ERROR_DEVICE
		512	jmp @b
		513
		514	.next:
		515	jmp esi
		516
		517	.forward:
		518	inc dword[esp]
		519	mov eax, [esp]
		520	mul [ebp+EXTFS.superblock.blocksPerGroup+ebx*8]
		521	neg ebx
		522	cmp eax, [ebp+EXTFS.superblock.blocksTotal+ebx*4]
		523	ja @f
		524	neg ebx
		525	mov eax, [esp]
		526	jmp .test_block_group
		527
		528	@@:
		529	neg ebx
		530	mov eax, [esp+4]
		531	mov [esp], eax
		532	mov esi, .backward
		533	.backward:
		534	sub dword[esp], 1
		535	jc .fail
		536	mov eax, [esp]
		537	jmp .test_block_group
		538
		539	extfsGetFileBlock:
		540	; in:
		541	; ecx = file block number
		542	; esi -> inode
		543	; out:
		544	; ecx = block number
		545	test [esi+INODE.featureFlags], EXTENTS_USED
		546	jz .listTreeSearch
		547	pushad
		548	add esi, INODE.blockNumbers
		549	.extentTreeSearch:
		550	cmp word [esi+NODEHEADER.magic], 0xF30A
		551	jne .fail
		552	movzx ebx, [esi+NODEHEADER.entriesFolow]
		553	add esi, sizeof.NODEHEADER
		554	cmp word [esi-sizeof.NODEHEADER+NODEHEADER.currentDepth], 0
		555	je .leaf_block
		556	test ebx, ebx
		557	jz .fail ; empty
		558	@@:
		559	cmp ebx, 1
		560	je .end_search_index
		561	cmp ecx, [esi+INDEX.fileBlock]
		562	jb .fail
		563	cmp ecx, [esi+sizeof.INDEX+INDEX.fileBlock]
		564	jb .end_search_index
		565	add esi, sizeof.INDEX
		566	dec ebx
		567	jmp @b
		568
		569	.end_search_index:
		570	mov ebx, [ebp+EXTFS.tempBlockBuffer]
		571	mov eax, [esi+INDEX.nodeBlock]
		572	call extfsReadBlock
		573	jc .fail
		574	mov esi, ebx
		575	jmp .extentTreeSearch
		576
		577	.leaf_block:
		578	test ebx, ebx
		579	jz .fail
		580	mov edx, [esi+EXTENT.fileBlock]
		581	cmp ecx, edx
		582	jb .fail
		583	movzx edi, [esi+EXTENT.blocksCount]
		584	add edx, edi
		585	cmp ecx, edx
		586	jb .end_search_extent
		587	add esi, sizeof.EXTENT
		588	dec ebx
		589	jmp .leaf_block
		590
		591	.end_search_extent:
		592	sub ecx, [esi+EXTENT.fileBlock]
		593	add ecx, [esi+EXTENT.fsBlock]
		594	mov PUSHAD_ECX, ecx
		595	popad
		596	xor eax, eax
		597	ret
		598
		599	.fail:
		600	popad
		601	movi eax, ERROR_FS_FAIL
		602	stc
		603	ret
		604
		605	.get_indirect_block:
		606	push edx ebx
		607	mov eax, [esi+INODE.addressBlock]
		608	test eax, eax
		609	jz .fail3
		610	mov ebx, [ebp+EXTFS.tempBlockBuffer]
		611	call extfsReadBlock
		612	jc @f
		613	mov ecx, [ebx+ecx*4]
		614	@@:
		615	pop ebx edx
		616	ret
		617
		618	.get_direct_block:
		619	mov ecx, [esi+INODE.blockNumbers+ecx*4]
		620	xor eax, eax
		621	ret
		622
		623	.listTreeSearch:
		624	cmp ecx, 12
		625	jb .get_direct_block
		626	sub ecx, 12
		627	cmp ecx, [ebp+EXTFS.dwordsPerBlock]
		628	jb .get_indirect_block
		629	sub ecx, [ebp+EXTFS.dwordsPerBlock]
		630	cmp ecx, [ebp+EXTFS.dwordsPerBranch]
		631	jb .get_double_indirect_block
		632	; triply-indirect blocks
		633	sub ecx, [ebp+EXTFS.dwordsPerBranch]
		634	push edx ebx
		635	mov eax, [esi+INODE.tripleAddress]
		636	mov ebx, [ebp+EXTFS.tempBlockBuffer]
		637	call extfsReadBlock
		638	jc .fail2
		639	xor edx, edx
		640	mov eax, ecx
		641	div [ebp+EXTFS.dwordsPerBranch]
		642	; eax = number in triply-indirect block, edx = number in branch
		643	mov eax, [ebx+eax*4]
		644	test eax, eax
		645	jz .fail3
		646	call extfsReadBlock
		647	jc .fail2
		648	mov eax, edx
		649	jmp @f
		650
		651	.fail3:
		652	pop ebx edx
		653	movi eax, ERROR_FS_FAIL
		654	stc
		655	ret
		656
		657	.get_double_indirect_block:
		658	push edx ebx
		659	mov eax, [esi+INODE.doubleAddress]
		660	test eax, eax
		661	jz .fail3
		662	mov ebx, [ebp+EXTFS.tempBlockBuffer]
		663	call extfsReadBlock
		664	jc .fail2
		665	mov eax, ecx
		666	@@:
		667	xor edx, edx
		668	div [ebp+EXTFS.dwordsPerBlock]
		669	; eax = number in doubly-indirect block, edx = number in indirect block
		670	mov eax, [ebx+eax*4]
		671	test eax, eax
		672	jz .fail3
		673	call extfsReadBlock
		674	jc .fail2
		675	mov ecx, [ebx+edx*4]
		676	.fail2:
		677	pop ebx edx
		678	ret
		679
		680	extfsSetFileBlock:
		681	; in:
		682	; ecx = file block number
		683	; edi = block number
		684	; esi -> inode
		685	push ebx ecx edx
		686	cmp ecx, 12
		687	jb .direct_block
		688	sub ecx, 12
		689	cmp ecx, [ebp+EXTFS.dwordsPerBlock]
		690	jb .indirect_block
		691	sub ecx, [ebp+EXTFS.dwordsPerBlock]
		692	cmp ecx, [ebp+EXTFS.dwordsPerBranch]
		693	jb .double_indirect_block
		694	; triple indirect blocks
		695	sub ecx, [ebp+EXTFS.dwordsPerBranch]
		696	mov eax, [esi+INODE.tripleAddress]
		697	test eax, eax
		698	jnz @f
		699	call inodeBlockAlloc
		700	jc .ret
		701	mov [esi+INODE.tripleAddress], ebx
		702	mov eax, ebx
		703	@@:
		704	push eax
		705	mov ebx, [ebp+EXTFS.tempBlockBuffer]
		706	call extfsReadBlock
		707	jc .fail_alloc_4
		708	xor edx, edx
		709	mov eax, ecx
		710	div [ebp+EXTFS.dwordsPerBranch]
		711	; eax = number in triply-indirect block, edx = number in branch
		712	lea ecx, [ebx+eax*4]
		713	mov eax, [ebx+eax*4]
		714	test eax, eax
		715	jnz @f
		716	call inodeBlockAlloc
		717	jc .fail_alloc_4
		718	mov [ecx], ebx
		719	mov eax, [esp]
		720	mov ebx, [ebp+EXTFS.tempBlockBuffer]
		721	call extfsWriteBlock
		722	jc .fail_alloc_4
		723	mov eax, [ecx]
		724	@@:
		725	mov [esp], eax
		726	call extfsReadBlock
		727	jc .fail_alloc_4
		728	mov eax, edx
		729	jmp @f
		730
		731	.double_indirect_block:
		732	mov eax, [esi+INODE.doubleAddress]
		733	test eax, eax
		734	jnz .double_indirect_present
		735	call inodeBlockAlloc
		736	jc .ret
		737	mov [esi+INODE.doubleAddress], ebx
		738	mov eax, ebx
		739	.double_indirect_present:
		740	push eax
		741	mov ebx, [ebp+EXTFS.tempBlockBuffer]
		742	call extfsReadBlock
		743	jc .fail_alloc_4
		744	mov eax, ecx
		745	@@:
		746	xor edx, edx
		747	div [ebp+EXTFS.dwordsPerBlock]
		748	; eax = number in doubly-indirect block, edx = number in indirect block
		749	lea ecx, [ebx+edx*4]
		750	push ecx
		751	lea ecx, [ebx+eax*4]
		752	cmp dword[ecx], 0
		753	jne @f
		754	call inodeBlockAlloc
		755	jc .fail_alloc_8
		756	mov [ecx], ebx
		757	mov eax, [esp+4]
		758	mov ebx, [ebp+EXTFS.tempBlockBuffer]
		759	call extfsWriteBlock
		760	jc .fail_alloc_8
		761	@@:
		762	mov eax, [ecx]
		763	push eax
		764	call extfsReadBlock
		765	jc .fail_alloc_12
		766	pop eax ecx edx
		767	mov [ecx], edi
		768	call extfsWriteBlock
		769	jmp .ret
		770
		771	.indirect_block:
		772	mov eax, [esi+INODE.addressBlock]
		773	test eax, eax
		774	jnz @f
		775	call inodeBlockAlloc
		776	jc .ret
		777	mov [esi+INODE.addressBlock], ebx
		778	mov eax, ebx
		779	@@:
		780	push eax
		781	mov ebx, [ebp+EXTFS.tempBlockBuffer]
		782	call extfsReadBlock
		783	jc .fail_alloc_4
		784	mov [ebx+ecx*4], edi
		785	pop eax
		786	call extfsWriteBlock
		787	jmp .ret
		788
		789	.direct_block:
		790	mov [esi+INODE.blockNumbers+ecx*4], edi
		791	xor eax, eax
		792	.ret:
		793	pop edx ecx ebx
		794	ret
		795
		796	.fail_alloc_12:
		797	pop ebx
		798	.fail_alloc_8:
		799	pop ebx
		800	.fail_alloc_4:
		801	pop ebx
		802	jmp .ret
		803
		804	extfsEraseFileBlock: ; also allocates
		805	; in:
		806	; edx = inode number
		807	; eax = file block number
		808	; [ebp+EXTFS.tempInodeBuffer] = inode
		809	push ebx ecx edx edi esi
		810	mov edi, eax
		811	mov ecx, eax
		812	lea esi, [ebp+EXTFS.tempInodeBuffer]
		813	call extfsGetFileBlock
		814	jc @f
		815	test ecx, ecx
		816	jz .allocate
		817	mov edx, ecx
		818	mov ecx, [ebp+EXTFS.bytesPerBlock]
		819	mov edi, [ebp+EXTFS.tempBlockBuffer]
		820	xor eax, eax
		821	rep stosb
		822	mov eax, edx
		823	mov ebx, [ebp+EXTFS.tempBlockBuffer]
		824	call extfsWriteBlock
		825	jmp @f
		826
		827	.allocate:
		828	mov eax, edx
		829	call extfsBlockAlloc
		830	jc @f
		831	mov ecx, edi
		832	mov edi, ebx
		833	lea esi, [ebp+EXTFS.tempInodeBuffer]
		834	call extfsSetFileBlock
		835	jc @f
		836	mov eax, [ebp+EXTFS.sectorsPerBlock]
		837	add [esi+INODE.sectorsUsed], eax
		838	xor eax, eax
		839	@@:
		840	pop esi edi edx ecx ebx
		841	ret
		842
		843	extfsFreeFileBlock:
		844	; in:
		845	; eax = file block number
		846	; [ebp+EXTFS.tempInodeBuffer] = inode
		847	push ebx ecx edi esi
		848	mov edi, eax
		849	mov ecx, eax
		850	lea esi, [ebp+EXTFS.tempInodeBuffer]
		851	call extfsGetFileBlock
		852	jc @f
		853	test ecx, ecx
		854	jz @f
		855	mov eax, ecx
		856	xor ecx, ecx
		857	call extfsResourceFree
		858	mov ecx, edi
		859	xor edi, edi
		860	lea esi, [ebp+EXTFS.tempInodeBuffer]
		861	call extfsSetFileBlock
		862	mov eax, [ebp+EXTFS.sectorsPerBlock]
		863	sub [esi+INODE.sectorsUsed], eax
		864	xor eax, eax
		865	@@:
		866	pop esi edi ecx ebx
		867	ret
		868
		869	extfsReadFileBlock:
		870	; in:
		871	; eax = file block number
		872	; [ebp+EXTFS.tempInodeBuffer] = inode
		873	; out:
		874	; [ebp+EXTFS.mainBlockBuffer] -> block
		875	push ebx ecx edx esi
		876	mov ecx, eax
		877	lea esi, [ebp+EXTFS.tempInodeBuffer]
		878	call extfsGetFileBlock
		879	jc .ret
		880	test ecx, ecx
		881	jz @f
		882	mov eax, ecx
		883	mov ebx, [ebp+EXTFS.mainBlockBuffer]
		884	call extfsReadBlock
		885	.ret:
		886	pop esi edx ecx ebx
		887	ret
		888
		889	@@:
		890	movi eax, ERROR_FS_FAIL
		891	stc
		892	jmp .ret
		893
		894	extfsWriteFileBlock:
		895	; in:
		896	; eax = file block number
		897	; [ebp+EXTFS.tempInodeBuffer] = inode
		898	; [ebp+EXTFS.mainBlockBuffer] -> block to write
		899	push ebx ecx edx esi
		900	mov ecx, eax
		901	lea esi, [ebp+EXTFS.tempInodeBuffer]
		902	call extfsGetFileBlock
		903	jc @f
		904	test ecx, ecx
		905	jz @b
		906	mov eax, ecx
		907	mov ebx, [ebp+EXTFS.mainBlockBuffer]
		908	call extfsWriteBlock
		909	@@:
		910	pop esi edx ecx ebx
		911	ret
		912
		913	getInodeLocation:
		914	; in: eax = inode number
		915	; out:
		916	; ebx = inode sector
		917	; edx = offset in sector
		918	dec eax
		919	xor edx, edx
		920	div [ebp+EXTFS.superblock.inodesPerGroup]
		921	mov ecx, edx
		922	shl eax, 5
		923	xor edx, edx
		924	div [ebp+EXTFS.bytesPerBlock]
		925	add eax, [ebp+EXTFS.superblock.firstGroupBlock]
		926	inc eax
		927	mov ebx, [ebp+EXTFS.tempBlockBuffer]
		928	call extfsReadBlock
		929	jc @f
		930	add ebx, edx
		931	mov ebx, [ebx+BGDESCR.inodeTable]
		932	mov eax, ecx
		933	mov ecx, [ebp+EXTFS.sectorsPerBlockLog]
		934	shl ebx, cl
		935	mul [ebp+EXTFS.superblock.inodeSize]
		936	mov edx, eax
		937	shr eax, 9
		938	and edx, 511
		939	add ebx, eax
		940	xor eax, eax
		941	@@:
		942	ret
		943
		944	writeInode:
		945	; in:
		946	; eax = inode number
		947	; ebx -> inode data
		948	push edx edi esi ecx ebx eax
		949	mov edi, ebx
		950	call fsGetTime
		951	add eax, 978307200
		952	mov [edi+INODE.inodeModified], eax
		953	pop eax
		954	call getInodeLocation
		955	jc .ret
		956	mov eax, ebx
		957	mov ebx, [ebp+EXTFS.tempBlockBuffer]
		958	mov ecx, eax
		959	call fs_read32_sys
		960	test eax, eax
		961	jnz @f
		962	mov eax, ecx
		963	mov esi, edi
		964	movzx ecx, [ebp+EXTFS.superblock.inodeSize]
		965	mov edi, edx
		966	add edi, ebx
		967	rep movsb
		968	call fs_write32_sys
		969	.ret:
		970	pop ebx ecx esi edi edx
		971	ret
		972
		973	@@:
		974	movi eax, ERROR_DEVICE
		975	stc
		976	jmp .ret
		977
		978	readInode:
		979	; in:
		980	; eax = inode number
		981	; ebx -> inode buffer
		982	push edx edi esi ecx ebx
		983	mov edi, ebx
		984	call getInodeLocation
		985	jc @f
		986	mov eax, ebx
		987	mov ebx, [ebp+EXTFS.tempBlockBuffer]
		988	call fs_read32_sys
		989	test eax, eax
		990	jnz @b
		991	movzx ecx, [ebp+EXTFS.superblock.inodeSize]
		992	mov esi, edx
		993	add esi, ebx
		994	rep movsb
		995	xor eax, eax
		996	@@:
		997	pop ebx ecx esi edi edx
		998	ret
		999
		1000	extfsExtendFile:
		1001	; in:
		1002	; eax = inode number
		1003	; ecx = new size
		1004	push ebx ecx edx esi edi eax
		1005	lea ebx, [ebp+EXTFS.tempInodeBuffer]
		1006	call readInode
		1007	jc .ret
		1008	cmp [ebx+INODE.fileSize], ecx
		1009	jnc .ret
		1010	mov eax, [ebx+INODE.fileSize]
		1011	push eax
		1012	sub ecx, eax
		1013	xor edx, edx
		1014	div [ebp+EXTFS.bytesPerBlock]
		1015	test edx, edx
		1016	jz .start_aligned
		1017	mov esi, [ebp+EXTFS.bytesPerBlock]
		1018	sub esi, edx
		1019	cmp esi, ecx
		1020	jbe @f
		1021	mov esi, ecx
		1022	@@: ; clear esi trailing bytes in block number eax
		1023	push eax
		1024	call extfsReadFileBlock
		1025	pop edi
		1026	jc .error_inode_size
		1027	push edi ecx
		1028	xor eax, eax
		1029	mov ecx, esi
		1030	mov edi, ebx
		1031	add edi, edx
		1032	rep stosb
		1033	pop ecx eax
		1034	call extfsWriteFileBlock
		1035	jc .error_inode_size
		1036	add [esp], esi
		1037	sub ecx, esi
		1038	jz .write_inode
		1039	.start_aligned:
		1040	cmp ecx, [ebp+EXTFS.bytesPerBlock]
		1041	jb @f
		1042	mov eax, [esp]
		1043	xor edx, edx
		1044	div [ebp+EXTFS.bytesPerBlock]
		1045	mov edx, [esp+4]
		1046	call extfsEraseFileBlock
		1047	jc .error_inode_size
		1048	mov eax, [ebp+EXTFS.bytesPerBlock]
		1049	sub ecx, eax
		1050	add [esp], eax
		1051	jmp .start_aligned
		1052
		1053	@@: ; handle the remaining bytes
		1054	test ecx, ecx
		1055	jz .write_inode
		1056	mov eax, [esp]
		1057	xor edx, edx
		1058	div [ebp+EXTFS.bytesPerBlock]
		1059	mov edx, [esp+4]
		1060	call extfsEraseFileBlock
		1061	jc .error_inode_size
		1062	add [esp], ecx
		1063	.write_inode:
		1064	xor eax, eax
		1065	.error_inode_size:
		1066	lea ebx, [ebp+EXTFS.tempInodeBuffer]
		1067	pop [ebx+INODE.fileSize]
		1068	push eax
		1069	mov eax, [esp+4]
		1070	call writeInode
		1071	pop ebx
		1072	jc .ret
		1073	xchg eax, ebx
		1074	cmp ebx, eax ; set CF
		1075	.ret:
		1076	pop edi edi esi edx ecx ebx
		1077	ret
		1078
		1079	extfsTruncateFile:
		1080	; in:
		1081	; eax = inode number
		1082	; ecx = new size
		1083	push ebx ecx edx esi edi eax
		1084	lea ebx, [ebp+EXTFS.tempInodeBuffer]
		1085	call readInode
		1086	jc .ret
		1087	cmp ecx, [ebx+INODE.fileSize]
		1088	jnc .ret
		1089	mov eax, [ebx+INODE.fileSize]
		1090	push eax
		1091	sub ecx, eax
		1092	not ecx
		1093	inc ecx
		1094	xor edx, edx
		1095	div [ebp+EXTFS.bytesPerBlock]
		1096	test edx, edx
		1097	jz .start_aligned
		1098	mov esi, edx
		1099	cmp esi, ecx
		1100	jbe @f
		1101	; if the size to truncate is smaller than the unaligned bytes
		1102	; we're going to clear neccessary bytes from the EOF
		1103	push eax
		1104	call extfsReadFileBlock
		1105	pop edi
		1106	jc .error_inode_size
		1107	push edi ecx
		1108	mov edi, [ebp+EXTFS.mainBlockBuffer]
		1109	sub edx, ecx
		1110	add edi, edx
		1111	xor eax, eax
		1112	rep stosb
		1113	pop ecx eax
		1114	call extfsWriteFileBlock
		1115	jc .error_inode_size
		1116	sub [esp], ecx
		1117	jmp .write_inode
		1118
		1119	@@:
		1120	call extfsFreeFileBlock
		1121	sub [esp], esi
		1122	sub ecx, esi
		1123	jz .write_inode
		1124	.start_aligned:
		1125	cmp ecx, [ebp+EXTFS.bytesPerBlock]
		1126	jb @f
		1127	mov eax, [esp]
		1128	xor edx, edx
		1129	div [ebp+EXTFS.bytesPerBlock]
		1130	dec eax
		1131	call extfsFreeFileBlock
		1132	mov eax, [ebp+EXTFS.bytesPerBlock]
		1133	sub ecx, eax
		1134	sub [esp], eax
		1135	jmp .start_aligned
		1136
		1137	@@: ; handle the remaining bytes
		1138	test ecx, ecx
		1139	jz .write_inode
		1140	mov eax, [esp]
		1141	xor edx, edx
		1142	div [ebp+EXTFS.bytesPerBlock]
		1143	dec eax
		1144	push eax
		1145	call extfsReadFileBlock
		1146	pop edi
		1147	jc .error_inode_size
		1148	push edi ecx
		1149	mov edi, [ebp+EXTFS.mainBlockBuffer]
		1150	mov edx, [ebp+EXTFS.bytesPerBlock]
		1151	sub edx, ecx
		1152	add edi, edx
		1153	xor eax, eax
		1154	rep stosb
		1155	pop ecx eax
		1156	call extfsWriteFileBlock
		1157	jc .error_inode_size
		1158	sub [esp], ecx
		1159	.write_inode:
		1160	xor eax, eax
		1161	.error_inode_size:
		1162	lea ebx, [ebp+EXTFS.tempInodeBuffer]
		1163	pop [ebx+INODE.fileSize]
		1164	push eax
		1165	mov eax, [esp+4]
		1166	call writeInode
		1167	pop ebx
		1168	jc .ret
		1169	xchg eax, ebx
		1170	cmp ebx, eax ; set CF
		1171	.ret:
		1172	pop edi edi esi edx ecx ebx
		1173	ret
		1174
		1175	linkInode:
		1176	; in:
		1177	; eax = inode on which to link
		1178	; ebx = inode to link
		1179	; esi -> name
		1180	; dl = file type
		1181	push esi edi ebx ecx eax edx
		1182	call strlen
		1183	add ecx, 8 ; directory entry size
		1184	push esi ebx ecx
		1185	xor ecx, ecx
		1186	lea esi, [ebp+EXTFS.tempInodeBuffer]
		1187	mov ebx, esi
		1188	call readInode
		1189	jc .error_inode_read
		1190	mov ecx, [ebp+EXTFS.sectorsPerBlockLog]
		1191	mov eax, [esi+INODE.sectorsUsed]
		1192	shr eax, cl
		1193	xor ecx, ecx
		1194	push eax ; maximum file block number
		1195	push ecx ; current file block number
		1196	.searchBlock:
		1197	call extfsGetFileBlock
		1198	jc .error_get_inode_block
		1199	test ecx, ecx
		1200	jz .alloc_block
		1201	push ecx
		1202	mov eax, ecx
		1203	mov ebx, [ebp+EXTFS.tempBlockBuffer]
		1204	call extfsReadBlock
		1205	jc .error_block_read
		1206	mov ecx, [esp+8]
		1207	mov edi, [ebp+EXTFS.tempBlockBuffer]
		1208	mov edx, edi
		1209	add edx, [ebp+EXTFS.bytesPerBlock]
		1210	.searchSpace:
		1211	movzx eax, [edi+DIRENTRY.entryLength]
		1212	test eax, eax
		1213	jz .zeroLength
		1214	cmp [edi+DIRENTRY.inodeNumber], 0
		1215	je .unusedEntry
		1216	movzx ebx, [edi+DIRENTRY.nameLength]
		1217	add ebx, 8+3
		1218	and ebx, -4
		1219	sub eax, ebx
		1220	add edi, ebx
		1221	cmp eax, ecx
		1222	jb .nextEntry
		1223	sub edi, ebx
		1224	mov [edi+DIRENTRY.entryLength], bx
		1225	add edi, ebx
		1226	mov [edi+DIRENTRY.entryLength], ax
		1227	jmp .found
		1228
		1229	.unusedEntry:
		1230	cmp eax, ecx
		1231	jge .found
		1232	.nextEntry:
		1233	add edi, eax
		1234	cmp edi, edx
		1235	jb .searchSpace
		1236	jmp .nextBlock
		1237
		1238	.zeroLength:
		1239	mov [edi+DIRENTRY.entryLength], cx
		1240	mov eax, edx
		1241	sub eax, edi
		1242	cmp eax, ecx
		1243	jge .found
		1244	mov [edi+DIRENTRY.inodeNumber], 0
		1245	mov [edi+DIRENTRY.entryLength], ax
		1246	; this block wasn't linking to the next one, so write it, and use the next block
		1247	pop eax
		1248	mov ebx, [ebp+EXTFS.tempBlockBuffer]
		1249	call extfsWriteBlock
		1250	jc .error_get_inode_block
		1251	inc dword[esp]
		1252	mov ecx, [esp]
		1253	call extfsGetFileBlock
		1254	jc .error_get_inode_block
		1255	test ecx, ecx
		1256	jz .alloc_block
		1257	push ecx
		1258	jmp .prepare_block
		1259
		1260	.nextBlock:
		1261	add esp, 4
		1262	inc dword[esp]
		1263	mov ecx, [esp]
		1264	cmp ecx, [esp+4]
		1265	jbe .searchBlock
		1266	.alloc_block:
		1267	mov eax, [esp+12]
		1268	call extfsBlockAlloc
		1269	jc .error_get_inode_block
		1270	mov ecx, [esp]
		1271	mov edi, ebx
		1272	call extfsSetFileBlock
		1273	jc .error_get_inode_block
		1274	mov eax, [ebp+EXTFS.bytesPerBlock]
		1275	add [esi+INODE.fileSize], eax
		1276	mov eax, [ebp+EXTFS.sectorsPerBlock]
		1277	add [esi+INODE.sectorsUsed], eax
		1278	mov eax, [esp+24]
		1279	mov ebx, esi
		1280	call writeInode
		1281	jc .error_get_inode_block
		1282	push edi ; save the block we just allocated
		1283	.prepare_block:
		1284	mov eax, [esp]
		1285	mov ebx, [ebp+EXTFS.tempBlockBuffer]
		1286	call extfsReadBlock
		1287	jc .error_block_read
		1288	mov edi, ebx
		1289	mov eax, [ebp+EXTFS.bytesPerBlock]
		1290	mov [edi+DIRENTRY.entryLength], ax
		1291	.found:
		1292	pop edx ecx ecx ecx ebx esi
		1293	push ebx
		1294	mov [edi], ebx ; save inode
		1295	mov eax, [esp+4]
		1296	cmp [ebp+EXTFS.superblock.dynamicVersionFlag], 0
		1297	je .name
		1298	mov [edi+DIRENTRY.fileType], al
		1299	.name:
		1300	sub ecx, 8
		1301	mov [edi+DIRENTRY.nameLength], cl
		1302	add edi, 8
		1303	rep movsb
		1304	mov eax, edx
		1305	mov ebx, [ebp+EXTFS.tempBlockBuffer]
		1306	call extfsWriteBlock
		1307	jc .error_block_write
		1308	mov eax, [esp]
		1309	lea ebx, [ebp+EXTFS.tempInodeBuffer]
		1310	call readInode
		1311	jc .error_block_write
		1312	pop eax
		1313	inc [ebx+INODE.linksCount]
		1314	call writeInode
		1315	jc @f
		1316	xor eax, eax
		1317	@@:
		1318	pop edx ecx ecx ebx edi esi
		1319	ret
		1320
		1321	.error_block_read:
		1322	pop ebx
		1323	.error_get_inode_block:
		1324	pop ebx ebx
		1325	.error_inode_read:
		1326	pop ebx ebx
		1327	.error_block_write:
		1328	pop ebx
		1329	jmp @b
		1330
		1331	unlinkInode:
		1332	; in:
		1333	; eax = inode from which to unlink
		1334	; ebx = inode to unlink
		1335	; out:
		1336	; eax = current number of links to inode, -1 = error
		1337	push edx esi edi ebx
		1338	lea ebx, [ebp+EXTFS.tempInodeBuffer]
		1339	call readInode
		1340	jc .fail
		1341	push eax
		1342	lea esi, [ebp+EXTFS.tempInodeBuffer]
		1343	.loop:
		1344	mov ecx, [esp]
		1345	call extfsGetFileBlock
		1346	jc .fail_loop
		1347	test ecx, ecx
		1348	jz .fail_loop
		1349	mov eax, ecx
		1350	mov edi, ecx
		1351	mov ebx, [ebp+EXTFS.tempBlockBuffer]
		1352	call extfsReadBlock
		1353	jc .fail_loop
		1354	.first_dir_entry: ; edi -> block
		1355	mov eax, [esp+4]
		1356	cmp [ebx+DIRENTRY.inodeNumber], eax
		1357	jne @f
		1358	mov [ebx+DIRENTRY.inodeNumber], 0
		1359	mov word [ebx+DIRENTRY.nameLength], 0 ; fileType = 0
		1360	jmp .write_block
		1361
		1362	@@:
		1363	mov edx, ebx
		1364	add edx, [ebp+EXTFS.bytesPerBlock]
		1365	push edx
		1366	mov edx, ebx
		1367	movzx ecx, [ebx+DIRENTRY.entryLength]
		1368	add ebx, ecx
		1369	.dir_entry:
		1370	cmp [ebx+DIRENTRY.inodeNumber], eax
		1371	jne @f
		1372	mov cx, [ebx+DIRENTRY.entryLength]
		1373	add [edx+DIRENTRY.entryLength], cx
		1374	pop eax
		1375	jmp .write_block
		1376
		1377	@@:
		1378	mov edx, ebx
		1379	movzx ecx, [ebx+DIRENTRY.entryLength]
		1380	test ecx, ecx
		1381	jz .fail_inode
		1382	add ebx, ecx
		1383	cmp ebx, [esp]
		1384	jb .dir_entry
		1385	pop ecx
		1386	inc dword[esp]
		1387	jmp .loop
		1388
		1389	.fail_inode:
		1390	pop eax
		1391	.fail_loop:
		1392	pop eax
		1393	.fail:
		1394	or eax, -1
		1395	jmp @f
		1396
		1397	.write_block:
		1398	pop eax
		1399	mov eax, edi
		1400	mov ebx, [ebp+EXTFS.tempBlockBuffer]
		1401	call extfsWriteBlock
		1402	jc .fail
		1403	mov eax, [esp]
		1404	lea ebx, [ebp+EXTFS.tempInodeBuffer]
		1405	call readInode
		1406	jc .fail
		1407	dec word [ebx+INODE.linksCount]
		1408	mov eax, [esp]
		1409	call writeInode
		1410	jc .fail
		1411	movzx eax, word [ebx+INODE.linksCount]
		1412	@@:
		1413	pop ebx edi esi edx
		1414	ret
		1415
		1416	findInode_parent:
		1417	; in: esi -> path
		1418	; out:
		1419	; edi -> file name
		1420	; esi = inode
		1421	push esi
		1422	xor edi, edi
		1423	.loop:
		1424	cmp byte [esi], '/'
		1425	jne @f
		1426	mov edi, esi
		1427	inc esi
		1428	jmp .loop
		1429
		1430	@@:
		1431	inc esi
		1432	cmp byte [esi-1], 0
		1433	jne .loop
		1434	cmp edi, 0
		1435	jne @f
		1436	; parent is root
		1437	pop edi
		1438	dec esi
		1439	jmp .get_inode
		1440
		1441	@@: ; parent is folder
		1442	mov byte [edi], 0
		1443	inc edi
		1444	pop esi
		1445	.get_inode:
		1446	push ebx edx
		1447	stdcall findInode, 0
		1448	pop edx ebx
		1449	ret
		1450
		1451	findInode:
		1452	; in: [esi]+[[esp+4]] = name
		1453	; out:
		1454	; [ebp+EXTFS.mainInodeBuffer] = inode
		1455	; esi = inode number
		1456	; dl = first byte of file/folder name
		1457	lea edx, [ebp+EXTFS.rootInodeBuffer]
		1458	cmp [edx+INODE.sectorsUsed], 0
		1459	je .not_found
		1460	cmp byte [esi], 0
		1461	jne .next_path_part
		1462	; root
		1463	push edi ecx
		1464	lea esi, [ebp+EXTFS.rootInodeBuffer]
		1465	lea edi, [ebp+EXTFS.mainInodeBuffer]
		1466	movzx ecx, [ebp+EXTFS.superblock.inodeSize]
		1467	rep movsb
		1468	pop ecx edi
		1469	xor eax, eax
		1470	xor dl, dl
		1471	mov esi, ROOT_INODE
		1472	ret 4
		1473
		1474	.next_path_part:
		1475	push [edx+INODE.sectorsUsed]
		1476	xor ecx, ecx
		1477	.folder_block_cycle:
		1478	push ecx
		1479	xchg esi, edx
		1480	call extfsGetFileBlock
		1481	jc .error_get_block
		1482	xchg esi, edx
		1483	mov eax, ecx
		1484	mov ebx, [ebp+EXTFS.mainBlockBuffer]
		1485	call extfsReadBlock
		1486	jc .error_get_block
		1487	push esi edx
		1488	sub esp, 256
		1489	mov edx, ebx
		1490	add edx, [ebp+EXTFS.bytesPerBlock]
		1491	.start_rec:
		1492	cmp [ebx+DIRENTRY.inodeNumber], 0
		1493	jz .next_rec
		1494	mov edi, esp
		1495	push esi
		1496	movzx ecx, [ebx+DIRENTRY.nameLength]
		1497	lea esi, [ebx+DIRENTRY.name]
		1498	call utf8_to_cp866
		1499	mov ecx, edi
		1500	lea edi, [esp+4]
		1501	sub ecx, edi ; number of bytes in resulting string
		1502	mov esi, [esp]
		1503	@@: ; edi -> converted string in stack, ecx = size, esi -> original file path
		1504	jecxz .test_find
		1505	dec ecx
		1506	lodsb
		1507	call char_toupper
		1508	mov ah, [edi]
		1509	inc edi
		1510	xchg al, ah
		1511	call char_toupper
		1512	cmp al, ah
		1513	je @b
		1514	@@: ; doesn't match
		1515	pop esi
		1516	.next_rec:
		1517	movzx eax, [ebx+DIRENTRY.entryLength]
		1518	add ebx, eax
		1519	cmp ebx, edx
		1520	jb .start_rec
		1521	push eax
		1522	jmp @f
		1523
		1524	.test_find:
		1525	cmp byte [esi], 0
		1526	je @f
		1527	cmp byte [esi], '/'
		1528	jne @b
		1529	inc esi
		1530	@@:
		1531	add esp, 256+4
		1532	pop edx edi ecx
		1533	; ebx -> matched directory entry, esi -> name without parent, or not changed
		1534	cmp edi, esi
		1535	je .next_folder_block
		1536	cmp byte [esi], 0
		1537	jnz @f
		1538	cmp dword[esp+8], 0
		1539	je .get_inode_ret
		1540	mov esi, [esp+8]
		1541	mov dword[esp+8], 0
		1542	@@:
		1543	mov eax, [ebx+DIRENTRY.inodeNumber]
		1544	lea ebx, [ebp+EXTFS.mainInodeBuffer]
		1545	call readInode
		1546	jc .error_get_inode
		1547	movzx eax, [ebx+INODE.accessMode]
		1548	and eax, TYPE_MASK
		1549	cmp eax, DIRECTORY
		1550	jne .not_found ; path folder is a file
		1551	pop ecx
		1552	mov edx, ebx
		1553	jmp .next_path_part
		1554
		1555	.next_folder_block:
		1556	pop eax
		1557	sub eax, [ebp+EXTFS.sectorsPerBlock]
		1558	jle .not_found
		1559	push eax
		1560	inc ecx
		1561	jmp .folder_block_cycle
		1562
		1563	.get_inode_ret:
		1564	pop eax
		1565	mov dl, [ebx+DIRENTRY.name]
		1566	mov eax, [ebx+DIRENTRY.inodeNumber]
		1567	lea ebx, [ebp+EXTFS.mainInodeBuffer]
		1568	mov esi, eax
		1569	call readInode
		1570	ret 4
		1571
		1572	.not_found:
		1573	movi eax, ERROR_FILE_NOT_FOUND
		1574	stc
		1575	ret 4
		1576
		1577	.error_get_block:
		1578	pop ebx
		1579	.error_get_inode:
		1580	pop ebx
		1581	ret 4
		1582
		1583	writeSuperblock:
		1584	push ebx
		1585	mov eax, 2
		1586	lea ebx, [ebp+EXTFS.superblock]
		1587	call fs_write32_sys
		1588	pop ebx
		1589	ret
		1590
		1591	extfsWritingInit:
		1592	movi eax, ERROR_ACCESS_DENIED
		1593	cmp byte [esi], 0
		1594	jz @f
		1595	movi eax, ERROR_UNSUPPORTED_FS
		1596	test [ebp+EXTFS.mountType], READ_ONLY
		1597	jnz @f
		1598	ext_lock:
		1599	lea ecx, [ebp+EXTFS.Lock]
		1600	jmp mutex_lock
		1601
		1602	@@:
		1603	pop ebx
		1604	xor ebx, ebx
		1605	ret
		1606
		1607	ext_unlock:
		1608	lea ecx, [ebp+EXTFS.Lock]
		1609	jmp mutex_unlock
		1610
		1611	;----------------------------------------------------------------
		1612	ext_ReadFolder:
		1613	call ext_lock
		1614	cmp byte [esi], 0
		1615	jz .root_folder
		1616	push ebx
		1617	stdcall findInode, [esp+4+4]
		1618	pop ebx
		1619	jc .error_ret
		1620	lea esi, [ebp+EXTFS.mainInodeBuffer]
		1621	test [esi+INODE.accessMode], DIRECTORY
		1622	jz .error_not_found
		1623	jmp @f
		1624
		1625	.root_folder:
		1626	lea esi, [ebp+EXTFS.rootInodeBuffer]
		1627	lea edi, [ebp+EXTFS.mainInodeBuffer]
		1628	movzx ecx, [ebp+EXTFS.superblock.inodeSize]
		1629	shr ecx, 2
		1630	push edi
		1631	rep movsd
		1632	pop esi
		1633	@@:
		1634	cmp [esi+INODE.fileSize], 0
		1635	je .error_empty_dir
		1636	mov edx, [ebx+16]
		1637	push edx ; [edi+28] result buffer
		1638	push 0 ; [edi+24] end of the current block in folder
		1639	pushd [ebx+12] ; [edi+20] files to read
		1640	pushd [ebx+4] ; [edi+16] first wanted file
		1641	pushd [ebx+8] ; [edi+12] flags
		1642	push 0 ; [edi+8] read files
		1643	push 0 ; [edi+4] files in folder
		1644	push 0 ; [edi] current block index
		1645	mov edi, esp ; edi -> local variables
		1646	add edx, 32
		1647	xor ecx, ecx
		1648	call extfsGetFileBlock
		1649	jc .error_get_block
		1650	mov eax, ecx
		1651	mov ebx, [ebp+EXTFS.mainBlockBuffer]
		1652	call extfsReadBlock
		1653	jc .error_get_block
		1654	mov eax, ebx
		1655	add eax, [ebp+EXTFS.bytesPerBlock]
		1656	mov [edi+24], eax
		1657	mov ecx, [edi+16]
		1658	.find_wanted_start:
		1659	jecxz .find_wanted_end
		1660	.find_wanted_cycle:
		1661	cmp [ebx+DIRENTRY.inodeNumber], 0
		1662	jz @f
		1663	inc dword [edi+4]
		1664	dec ecx
		1665	@@:
		1666	movzx eax, [ebx+DIRENTRY.entryLength]
		1667	cmp eax, 12 ; minimum entry length
		1668	jb .error_bad_len
		1669	test eax, 3 ; length must be aligned
		1670	jnz .error_bad_len
		1671	sub [esi+INODE.fileSize], eax
		1672	add ebx, eax
		1673	cmp ebx, [edi+24]
		1674	jb .find_wanted_start
		1675	push .find_wanted_start
		1676	.end_block: ; read next block
		1677	cmp [esi+INODE.fileSize], 0
		1678	jle .end_dir
		1679	inc dword [edi]
		1680	push ecx
		1681	mov ecx, [edi]
		1682	call extfsGetFileBlock
		1683	jc .error_get_block
		1684	mov eax, ecx
		1685	mov ebx, [ebp+EXTFS.mainBlockBuffer]
		1686	call extfsReadBlock
		1687	jc .error_get_block
		1688	pop ecx
		1689	mov eax, ebx
		1690	add eax, [ebp+EXTFS.bytesPerBlock]
		1691	mov [edi+24], eax
		1692	ret
		1693
		1694	.wanted_end:
		1695	loop .find_wanted_cycle
		1696	.find_wanted_end:
		1697	mov ecx, [edi+20]
		1698	.wanted_start:
		1699	jecxz .wanted_end
		1700	cmp [ebx+DIRENTRY.inodeNumber], 0
		1701	jz .empty_rec
		1702	inc dword [edi+8]
		1703	inc dword [edi+4]
		1704	push ebx edi ecx esi edx
		1705	mov edi, edx
		1706	xor eax, eax
		1707	mov ecx, 40 / 4
		1708	rep stosd
		1709	mov eax, [ebx+DIRENTRY.inodeNumber]
		1710	lea ebx, [ebp+EXTFS.tempInodeBuffer]
		1711	call readInode
		1712	jc .error_read_subinode
		1713	mov esi, ebx
		1714	lea edi, [edx+8]
		1715	mov eax, [ebx+INODE.inodeModified]
		1716	sub eax, 978307200 ; 01.01.1970-01.01.2001 = (36531+8)246060
		1717	call fsTime2bdfe
		1718
		1719	mov eax, [esi+INODE.accessedTime]
		1720	sub eax, 978307200
		1721	call fsTime2bdfe
		1722
		1723	mov eax, [esi+INODE.dataModified]
		1724	sub eax, 978307200
		1725	call fsTime2bdfe
		1726	pop edx
		1727	or dword [edx], KOS_DIRECTORY
		1728	test [esi+INODE.accessMode], DIRECTORY
		1729	jnz @f
		1730	xor dword [edx], KOS_DIRECTORY ; mark as file
		1731	mov eax, [esi+INODE.fileSize]
		1732	stosd
		1733	mov eax, [esi+INODE.fileSizeHigh]
		1734	stosd
		1735	@@:
		1736	mov esi, [esp+12]
		1737	movzx ecx, [esi+DIRENTRY.nameLength]
		1738	lea edi, [edx+40]
		1739	lea esi, [esi+DIRENTRY.name]
		1740	call utf8_to_cp866
		1741	and byte [edi], 0
		1742	pop esi ecx edi ebx
		1743	cmp byte [edx+40], '.'
		1744	jne @f
		1745	or dword [edx], KOS_HIDDEN
		1746	@@:
		1747	add edx, 40+264 ; go to the next record
		1748	dec ecx
		1749	.empty_rec:
		1750	movzx eax, [ebx+DIRENTRY.entryLength]
		1751	cmp eax, 12
		1752	jb .error_bad_len
		1753	test eax, 3
		1754	jnz .error_bad_len
		1755	sub [esi+INODE.fileSize], eax
		1756	add ebx, eax
		1757	cmp ebx, [edi+24]
		1758	jb .wanted_start
		1759	push .wanted_start
		1760	jmp .end_block
		1761
		1762	.end_dir:
		1763	call ext_unlock
		1764	mov edx, [edi+28]
		1765	mov ebx, [edi+8]
		1766	mov ecx, [edi+4]
		1767	mov dword [edx], 1 ; version
		1768	mov [edx+4], ebx
		1769	mov [edx+8], ecx
		1770	lea esp, [edi+32]
		1771	mov ecx, 20/4
		1772	lea edi, [edx+12]
		1773	xor eax, eax
		1774	rep stosd
		1775	ret
		1776
		1777	.error_bad_len:
		1778	movi eax, ERROR_FS_FAIL
		1779	.error_read_subinode:
		1780	.error_get_block:
		1781	lea esp, [edi+32]
		1782	.error_ret:
		1783	or ebx, -1
		1784	push eax
		1785	call ext_unlock
		1786	pop eax
		1787	ret
		1788
		1789	.error_empty_dir:
		1790	movi eax, ERROR_FS_FAIL
		1791	jmp .error_ret
		1792
		1793	.error_not_found:
		1794	movi eax, ERROR_FILE_NOT_FOUND
		1795	jmp .error_ret
		1796
		1797	;----------------------------------------------------------------
		1798	ext_ReadFile:
		1799	call ext_lock
		1800	push ERROR_ACCESS_DENIED
		1801	cmp byte [esi], 0
		1802	jz .error ; root
		1803	mov [esp], ebx
		1804	stdcall findInode, [esp+4+4]
		1805	pop ebx
		1806	jc .error_eax
		1807	push ERROR_ACCESS_DENIED
		1808	lea esi, [ebp+EXTFS.mainInodeBuffer]
		1809	mov ax, [esi+INODE.accessMode]
		1810	and ax, TYPE_MASK
		1811	cmp ax, FLAG_FILE
		1812	jnz .error ; not a file
		1813	pop eax
		1814	mov edi, [ebx+16]
		1815	mov ecx, [ebx+12]
		1816	mov eax, [ebx+4]
		1817	mov edx, [ebx+8]
		1818	push ERROR_END_OF_FILE
		1819	cmp [esi+INODE.fileSizeHigh], edx
		1820	ja @f
		1821	jb .error
		1822	cmp [esi+INODE.fileSize], eax
		1823	jna .error
		1824	@@:
		1825	add esp, 4
		1826	add eax, ecx
		1827	adc edx, 0
		1828	cmp [esi+INODE.fileSizeHigh], edx
		1829	ja .read_till_requested
		1830	jb .read_whole_file
		1831	cmp [esi+INODE.fileSize], eax
		1832	jae .read_till_requested
		1833	.read_whole_file:
		1834	push 1 ; read till the end of file
		1835	mov ecx, [esi+INODE.fileSize]
		1836	sub ecx, [ebx+4]
		1837	jmp @f
		1838
		1839	.read_till_requested:
		1840	push 0 ; read as much as requested
		1841	@@: ; ecx = bytes to read, edi -> buffer
		1842	push ecx
		1843	; read part of the first block
		1844	mov edx, [ebx+8]
		1845	mov eax, [ebx+4]
		1846	div [ebp+EXTFS.bytesPerBlock]
		1847	push eax
		1848	push ecx
		1849	mov ecx, eax
		1850	call extfsGetFileBlock
		1851	jc .error_at_first_block
		1852	mov ebx, [ebp+EXTFS.mainBlockBuffer]
		1853	mov eax, ecx
		1854	call extfsReadBlock
		1855	jc .error_at_first_block
		1856	pop ecx
		1857	add ebx, edx
		1858	neg edx
		1859	add edx, [ebp+EXTFS.bytesPerBlock]
		1860	cmp ecx, edx
		1861	jbe .only_one_block
		1862	mov eax, ecx
		1863	sub eax, edx ; bytes to read
		1864	mov ecx, edx
		1865	push esi
		1866	mov esi, ebx
		1867	rep movsb
		1868	pop esi
		1869	mov ebx, edi
		1870	xor edx, edx
		1871	div [ebp+EXTFS.bytesPerBlock]
		1872	mov edi, eax
		1873	@@:
		1874	test edi, edi
		1875	jz .finish_block
		1876	inc dword [esp]
		1877	mov ecx, [esp]
		1878	call extfsGetFileBlock
		1879	jc .error_at_read_cycle
		1880	mov eax, ecx
		1881	call extfsReadBlock
		1882	jc .error_at_read_cycle
		1883	add ebx, [ebp+EXTFS.bytesPerBlock]
		1884	dec edi
		1885	jmp @b
		1886
		1887	.finish_block: ; edx = number of bytes in the last block
		1888	test edx, edx
		1889	jz .end_read
		1890	pop ecx ; block counter
		1891	inc ecx
		1892	call extfsGetFileBlock
		1893	jc .error_at_finish_block
		1894	mov edi, ebx
		1895	mov eax, ecx
		1896	mov ebx, [ebp+EXTFS.mainBlockBuffer]
		1897	call extfsReadBlock
		1898	jc .error_at_finish_block
		1899	push eax
		1900	mov ecx, edx
		1901	.only_one_block:
		1902	mov esi, ebx
		1903	rep movsb
		1904	.end_read:
		1905	call ext_unlock
		1906	pop eax ebx eax
		1907	test eax, eax
		1908	jz @f
		1909	movi eax, ERROR_END_OF_FILE
		1910	@@:
		1911	ret
		1912
		1913	.error_at_first_block:
		1914	pop ebx
		1915	.error_at_read_cycle:
		1916	pop ebx
		1917	.error_at_finish_block:
		1918	pop ebx ebx
		1919	.error_eax:
		1920	push eax
		1921	.error:
		1922	call ext_unlock
		1923	xor ebx, ebx
		1924	pop eax
		1925	ret
		1926
		1927	;----------------------------------------------------------------
		1928	ext_GetFileInfo:
		1929	call ext_lock
		1930	mov edx, [ebx+16]
		1931	cmp byte [esi], 0
		1932	jz .is_root
		1933	push edx
		1934	stdcall findInode, [esp+4+4]
		1935	mov ebx, edx
		1936	pop edx
		1937	lea esi, [ebp+EXTFS.mainInodeBuffer]
		1938	jnc @f
		1939	push eax
		1940	call ext_unlock
		1941	pop eax
		1942	ret
		1943
		1944	.is_root:
		1945	xor ebx, ebx
		1946	lea esi, [ebp+EXTFS.rootInodeBuffer]
		1947	@@:
		1948	xor eax, eax
		1949	mov edi, edx
		1950	mov ecx, 40/4
		1951	rep stosd
		1952	cmp bl, '.'
		1953	jne @f
		1954	or dword [edx], KOS_HIDDEN
		1955	@@:
		1956	or dword [edx], KOS_DIRECTORY
		1957	test [esi+INODE.accessMode], DIRECTORY
		1958	jnz @f
		1959	xor dword [edx], KOS_DIRECTORY ; mark as file
		1960	mov eax, [esi+INODE.fileSize]
		1961	mov ebx, [esi+INODE.fileSizeHigh]
		1962	mov dword [edx+32], eax
		1963	mov dword [edx+36], ebx
		1964	@@:
		1965	lea edi, [edx+8]
		1966	mov eax, [esi+INODE.inodeModified]
		1967	sub eax, 978307200 ; 01.01.1970-01.01.2001 = (36531+8)246060
		1968	call fsTime2bdfe
		1969
		1970	mov eax, [esi+INODE.accessedTime]
		1971	sub eax, 978307200
		1972	call fsTime2bdfe
		1973
		1974	mov eax, [esi+INODE.dataModified]
		1975	sub eax, 978307200
		1976	call fsTime2bdfe
		1977	call ext_unlock
		1978	xor eax, eax
		1979	ret
		1980
		1981	;----------------------------------------------------------------
		1982	ext_SetFileInfo:
		1983	call extfsWritingInit
		1984	pushd [ebx+16]
		1985	stdcall findInode, [esp+4+4]
		1986	pop edx
		1987	jc @f
		1988	push esi ; inode number
		1989	lea esi, [edx+16]
		1990	lea edi, [ebp+EXTFS.mainInodeBuffer]
		1991	call fsCalculateTime
		1992	add eax, 978307200 ; 01.01.1970-01.01.2001 = (36531+8)246060
		1993	mov [edi+INODE.accessedTime], eax
		1994
		1995	add esi, 8
		1996	call fsCalculateTime
		1997	add eax, 978307200
		1998	mov [edi+INODE.dataModified], eax
		1999	mov ebx, edi
		2000	pop eax
		2001	call writeInode
		2002	@@:
		2003	push eax
		2004	jc @f
		2005	call writeSuperblock
		2006	mov esi, [ebp+PARTITION.Disk]
		2007	call disk_sync
		2008	@@:
		2009	call ext_unlock
		2010	pop eax
		2011	ret
		2012
		2013	;----------------------------------------------------------------
		2014	ext_Delete:
		2015	call extfsWritingInit
		2016	push esi
		2017	stdcall findInode, [esp+4+4]
		2018	mov ebx, esi
		2019	pop esi
		2020	push eax
		2021	jc .ret
		2022	pop eax
		2023	lea edx, [ebp+EXTFS.mainInodeBuffer]
		2024	movzx edx, [edx+INODE.accessMode]
		2025	and edx, TYPE_MASK
		2026	cmp edx, DIRECTORY
		2027	jne .file
		2028	push esi ebx edx 0
		2029	lea esi, [ebp+EXTFS.mainInodeBuffer]
		2030	.checkDirectory:
		2031	mov ecx, [esp]
		2032	call extfsGetFileBlock
		2033	jc .not_empty_eax
		2034	test ecx, ecx
		2035	jz .empty
		2036	mov eax, ecx
		2037	mov ebx, [ebp+EXTFS.tempBlockBuffer]
		2038	call extfsReadBlock
		2039	jc .not_empty_eax
		2040	mov edx, ebx
		2041	add edx, [ebp+EXTFS.bytesPerBlock]
		2042	movzx ecx, [ebx+DIRENTRY.entryLength]
		2043	add ebx, ecx
		2044	.dir_entry:
		2045	cmp byte [ebx+DIRENTRY.nameLength], 1
		2046	jne @f
		2047	cmp byte [ebx+DIRENTRY.name], '.'
		2048	jne .not_empty
		2049	@@:
		2050	cmp byte [ebx+DIRENTRY.nameLength], 2
		2051	jne .not_empty
		2052	cmp word [ebx+DIRENTRY.name], '..'
		2053	jne .not_empty
		2054	movzx ecx, [ebx+DIRENTRY.entryLength]
		2055	add ebx, ecx
		2056	cmp ebx, edx
		2057	jb .dir_entry
		2058	inc dword[esp]
		2059	jmp .checkDirectory
		2060
		2061	.empty:
		2062	pop edx edx ebx esi
		2063	.file:
		2064	call findInode_parent
		2065	jc .error
		2066	mov eax, esi
		2067	; save file/folder's and parent's inode
		2068	push ebx eax
		2069	cmp edx, DIRECTORY
		2070	jne @f
		2071	; Unlink '.'
		2072	mov eax, [esp+4]
		2073	call unlinkInode
		2074	cmp eax, -1
		2075	je .error_stack8
		2076	; Unlink '..'
		2077	mov eax, [esp+4]
		2078	mov ebx, [esp]
		2079	call unlinkInode
		2080	cmp eax, -1
		2081	je .error_stack8
		2082	@@:
		2083	pop eax
		2084	mov ebx, [esp]
		2085	call unlinkInode
		2086	cmp eax, -1
		2087	je .error_stack4
		2088	test eax, eax
		2089	jz @f
		2090	; has hardlinks
		2091	xor eax, eax
		2092	mov [esp], eax
		2093	jmp .disk_sync
		2094
		2095	@@:
		2096	mov eax, [esp]
		2097	lea ebx, [ebp+EXTFS.mainInodeBuffer]
		2098	call readInode
		2099	jc .error_stack4_eax
		2100	; free file's data
		2101	lea esi, [ebp+EXTFS.mainInodeBuffer]
		2102	xor ecx, ecx
		2103	@@:
		2104	push ecx
		2105	call extfsGetFileBlock
		2106	jc .error_stack8_eax
		2107	mov eax, ecx
		2108	test eax, eax
		2109	jz @f
		2110	xor ecx, ecx
		2111	call extfsResourceFree
		2112	pop ecx
		2113	inc ecx
		2114	jmp @b
		2115
		2116	@@: ; free indirect blocks
		2117	pop ecx
		2118	push edx
		2119	lea edi, [ebp+EXTFS.mainInodeBuffer]
		2120	mov eax, [edi+INODE.addressBlock]
		2121	test eax, eax
		2122	jz .success
		2123	xor ecx, ecx
		2124	call extfsResourceFree
		2125	mov eax, [edi+INODE.doubleAddress]
		2126	call freeDoublyIndirectBlock
		2127	cmp eax, 1
		2128	je .success
		2129	mov eax, [edi+INODE.tripleAddress]
		2130	test eax, eax
		2131	jz .success
		2132	push eax
		2133	mov ebx, [ebp+EXTFS.tempBlockBuffer]
		2134	call extfsReadBlock
		2135	pop ecx
		2136	jc .error_stack8_eax
		2137	mov eax, ecx
		2138	xor ecx, ecx
		2139	call extfsResourceFree
		2140	mov edx, ebx
		2141	add edx, [ebp+EXTFS.bytesPerBlock]
		2142	@@:
		2143	mov eax, [ebx]
		2144	test eax, eax
		2145	jz .success
		2146	push ebx edx
		2147	call freeDoublyIndirectBlock
		2148	pop edx ebx
		2149	cmp eax, 1
		2150	je .success
		2151	add ebx, 4
		2152	cmp ebx, edx
		2153	jb @b
		2154	.success: ; clear the inode, and add deletion time
		2155	xor eax, eax
		2156	movzx ecx, [ebp+EXTFS.superblock.inodeSize]
		2157	rep stosb
		2158	lea edi, [ebp+EXTFS.mainInodeBuffer]
		2159	call fsGetTime
		2160	pop edx
		2161	add eax, 978307200
		2162	mov [edi+INODE.deletedTime], eax
		2163	mov eax, [esp]
		2164	mov ebx, edi
		2165	call writeInode
		2166	jc .error_stack4_eax
		2167	cmp edx, DIRECTORY
		2168	jne @f
		2169	mov eax, [esp]
		2170	dec eax
		2171	xor edx, edx
		2172	div [ebp+EXTFS.superblock.inodesPerGroup]
		2173	push eax
		2174	call extfsReadDescriptor
		2175	jc .error_stack8
		2176	dec [eax+BGDESCR.directoriesCount]
		2177	pop eax
		2178	call extfsWriteDescriptor
		2179	@@: ; free inode
		2180	pop eax
		2181	dec eax
		2182	xor ecx, ecx
		2183	inc ecx
		2184	call extfsResourceFree
		2185	push eax
		2186	.disk_sync:
		2187	call writeSuperblock
		2188	mov esi, [ebp+PARTITION.Disk]
		2189	call disk_sync
		2190	.ret:
		2191	call ext_unlock
		2192	xor ebx, ebx
		2193	pop eax
		2194	ret
		2195
		2196	.not_empty:
		2197	pop eax
		2198	.error_stack8:
		2199	pop eax
		2200	.error_stack4:
		2201	pop eax
		2202	push ERROR_ACCESS_DENIED
		2203	jmp .disk_sync
		2204
		2205	.not_empty_eax:
		2206	pop ebx
		2207	.error_stack8_eax:
		2208	pop ebx
		2209	.error_stack4_eax:
		2210	pop ebx
		2211	.error:
		2212	push eax
		2213	jmp .disk_sync
		2214
		2215	;----------------------------------------------------------------
		2216	ext_CreateFolder:
		2217	call extfsWritingInit
		2218	push esi
		2219	stdcall findInode, [esp+4+4]
		2220	pop esi
		2221	jnc .success ; exist
		2222	call findInode_parent
		2223	jc .error
		2224	mov eax, esi
		2225	xor ebx, ebx
		2226	inc ebx
		2227	call extfsResourceAlloc
		2228	jc .error
		2229	inc ebx
		2230	push ebx esi edi
		2231	xor al, al
		2232	lea edi, [ebp+EXTFS.tempInodeBuffer]
		2233	movzx ecx, [ebp+EXTFS.superblock.inodeSize]
		2234	rep stosb
		2235	lea edi, [ebp+EXTFS.tempInodeBuffer]
		2236	call fsGetTime
		2237	add eax, 978307200
		2238	mov [edi+INODE.accessedTime], eax
		2239	mov [edi+INODE.dataModified], eax
		2240	mov ebx, edi
		2241	pop edi esi edx
		2242	; edx = allocated inode number, edi -> filename, esi = parent inode number
		2243	mov [ebx+INODE.accessMode], DIRECTORY or PERMISSIONS
		2244	mov eax, edx
		2245	call writeInode
		2246	jc .error
		2247	; link to self
		2248	push edx esi
		2249	mov eax, edx
		2250	mov ebx, eax
		2251	mov dl, DIR_DIRECTORY
		2252	mov esi, self_link
		2253	call linkInode
		2254	pop esi edx
		2255	jc .error
		2256	; link to parent
		2257	push edx esi
		2258	mov eax, ebx
		2259	mov ebx, esi
		2260	mov dl, DIR_DIRECTORY
		2261	mov esi, parent_link
		2262	call linkInode
		2263	pop esi edx
		2264	jc .error
		2265	; link parent to child
		2266	mov eax, esi
		2267	mov ebx, edx
		2268	mov esi, edi
		2269	mov dl, DIR_DIRECTORY
		2270	call linkInode
		2271	jc .error
		2272	mov eax, ebx
		2273	dec eax
		2274	xor edx, edx
		2275	div [ebp+EXTFS.superblock.inodesPerGroup]
		2276	mov edx, eax
		2277	call extfsReadDescriptor
		2278	jc @f
		2279	inc [eax+BGDESCR.directoriesCount]
		2280	mov eax, edx
		2281	call extfsWriteDescriptor
		2282	.success:
		2283	.error:
		2284	push eax
		2285	call writeSuperblock
		2286	mov esi, [ebp+PARTITION.Disk]
		2287	call disk_sync
		2288	call ext_unlock
		2289	pop eax
		2290	ret
		2291
		2292	@@:
		2293	movi eax, ERROR_DEVICE
		2294	jmp .error
		2295
		2296	self_link db ".", 0
		2297	parent_link db "..", 0
		2298
		2299	;----------------------------------------------------------------
		2300	ext_CreateFile:
		2301	call extfsWritingInit
		2302	push ebx esi
		2303	stdcall findInode, [esp+8+4]
		2304	mov esi, [esp]
		2305	jc @f
		2306	call ext_unlock
		2307	stdcall ext_Delete, [esp+8+4]
		2308	mov [esp], eax
		2309	call ext_lock
		2310	pop eax
		2311	test eax, eax
		2312	jnz .error
		2313	mov esi, [esp]
		2314	@@:
		2315	call findInode_parent
		2316	jc .error
		2317	mov eax, esi
		2318	xor ebx, ebx
		2319	inc ebx
		2320	call extfsResourceAlloc
		2321	jc .error
		2322	inc ebx
		2323	push ebx esi edi
		2324	xor al, al
		2325	lea edi, [ebp+EXTFS.tempInodeBuffer]
		2326	movzx ecx, [ebp+EXTFS.superblock.inodeSize]
		2327	rep stosb
		2328	lea edi, [ebp+EXTFS.tempInodeBuffer]
		2329	call fsGetTime
		2330	add eax, 978307200
		2331	mov [edi+INODE.accessedTime], eax
		2332	mov [edi+INODE.dataModified], eax
		2333	mov ebx, edi
		2334	pop edi esi edx
		2335	; edx = allocated inode number, edi -> filename, esi = parent inode number
		2336	mov [ebx+INODE.accessMode], FLAG_FILE or PERMISSIONS
		2337	mov eax, edx
		2338	call writeInode
		2339	jc .error
		2340	; link parent to child
		2341	mov eax, esi
		2342	mov ebx, edx
		2343	mov esi, edi
		2344	mov dl, DIR_FLAG_FILE
		2345	call linkInode
		2346	jc .error
		2347	pop esi ebx
		2348	call ext_unlock
		2349	jmp ext_WriteFile
		2350
		2351	.error:
		2352	push eax
		2353	call ext_unlock
		2354	pop eax ebx ebx
		2355	xor ebx, ebx
		2356	ret
		2357
		2358	;----------------------------------------------------------------
		2359	ext_WriteFile:
		2360	call extfsWritingInit
		2361	push 0 ebx
		2362	stdcall findInode, [esp+8+4]
		2363	jc .error
		2364	lea edx, [ebp+EXTFS.mainInodeBuffer]
		2365	movi eax, ERROR_ACCESS_DENIED
		2366	test [edx+INODE.accessMode], FLAG_FILE
		2367	jz .error ; not a file
		2368	mov ebx, [esp]
		2369	push esi ; inode number
		2370	mov eax, esi
		2371	mov ecx, [ebx+4]
		2372	call extfsExtendFile
		2373	jc .error2
		2374	mov ecx, [ebx+12]
		2375	mov esi, [ebx+16]
		2376	mov eax, [edx+INODE.fileSize]
		2377	push eax
		2378	xor edx, edx
		2379	div [ebp+EXTFS.bytesPerBlock]
		2380	test edx, edx
		2381	jz .start_aligned
		2382	mov ebx, [ebp+EXTFS.bytesPerBlock]
		2383	sub ebx, edx
		2384	cmp ebx, ecx
		2385	jbe @f
		2386	mov ebx, ecx
		2387	@@:
		2388	push eax
		2389	call extfsReadFileBlock
		2390	pop edi
		2391	jc .error_inode_size
		2392	mov eax, edi
		2393	push ecx
		2394	mov ecx, ebx
		2395	mov edi, ebx
		2396	add edi, edx
		2397	rep movsb
		2398	pop ecx
		2399	call extfsWriteFileBlock
		2400	jc .error_inode_size
		2401	add [esp], ebx
		2402	sub ecx, ebx
		2403	jz .write_inode
		2404	.start_aligned:
		2405	cmp ecx, [ebp+EXTFS.bytesPerBlock]
		2406	jb @f
		2407	mov eax, [esp]
		2408	xor edx, edx
		2409	div [ebp+EXTFS.bytesPerBlock]
		2410	mov edx, [esp+4]
		2411	push eax
		2412	call extfsEraseFileBlock
		2413	pop edi
		2414	jc .error_inode_size
		2415	mov eax, edi
		2416	push ecx
		2417	mov ecx, [ebp+EXTFS.bytesPerBlock]
		2418	mov edi, [ebp+EXTFS.mainBlockBuffer]
		2419	rep movsb
		2420	pop ecx
		2421	call extfsWriteFileBlock
		2422	jc .error_inode_size
		2423	mov eax, [ebp+EXTFS.bytesPerBlock]
		2424	sub ecx, eax
		2425	add [esp], eax
		2426	jmp .start_aligned
		2427	@@: ; Handle the remaining bytes.
		2428	test ecx, ecx
		2429	jz .write_inode
		2430	mov eax, [esp]
		2431	xor edx, edx
		2432	div [ebp+EXTFS.bytesPerBlock]
		2433	push eax
		2434	call extfsReadFileBlock
		2435	pop eax
		2436	jnc @f
		2437	mov edx, [esp+4]
		2438	push eax
		2439	call extfsEraseFileBlock
		2440	pop edi
		2441	jc .error_inode_size
		2442	mov eax, edi
		2443	@@:
		2444	push ecx
		2445	mov edi, [ebp+EXTFS.mainBlockBuffer]
		2446	rep movsb
		2447	pop ecx
		2448	call extfsWriteFileBlock
		2449	jc .error_inode_size
		2450	add [esp], ecx
		2451	xor ecx, ecx
		2452	.error_inode_size:
		2453	mov [esp+12], eax
		2454	.write_inode:
		2455	lea ebx, [ebp+EXTFS.tempInodeBuffer]
		2456	pop [ebx+INODE.fileSize]
		2457	pop eax
		2458	call writeInode
		2459	pop ebx
		2460	mov ebx, [ebx+12]
		2461	sub ebx, ecx
		2462	test eax, eax
		2463	jz @f
		2464	mov [esp], eax
		2465	@@:
		2466	call writeSuperblock
		2467	mov esi, [ebp+PARTITION.Disk]
		2468	call disk_sync
		2469	@@:
		2470	call ext_unlock
		2471	pop eax
		2472	ret
		2473
		2474	.error2:
		2475	pop ebx
		2476	.error:
		2477	pop ebx ebx
		2478	push eax
		2479	jmp @b
		2480
		2481	;----------------------------------------------------------------
		2482	ext_SetFileEnd:
		2483	call extfsWritingInit
		2484	pushd [ebx+4]
		2485	stdcall findInode, [esp+4+4]
		2486	pop ecx
		2487	jc @f
		2488	lea edx, [ebp+EXTFS.mainInodeBuffer]
		2489	movi eax, ERROR_ACCESS_DENIED
		2490	cmp [edx+INODE.accessMode], FLAG_FILE
		2491	jnz @f ; not a file
		2492	mov eax, esi
		2493	call extfsExtendFile
		2494	jc @f
		2495	mov eax, esi
		2496	call extfsTruncateFile
		2497	jc @f
		2498	mov eax, esi
		2499	lea ebx, [ebp+EXTFS.tempInodeBuffer]
		2500	call writeInode
		2501	@@:
		2502	push eax
		2503	call writeSuperblock
		2504	mov esi, [ebp+PARTITION.Disk]
		2505	call disk_sync
		2506	call ext_unlock
		2507	pop eax
		2508	ret

Subversion Repositories Kolibri OS

(root)/kernel/trunk/fs/ext.inc @ 6933 – Rev 6462