Burer/kolibrios
1
0
Fork 0
forked from KolibriOS/kolibrios
Code Pull Requests Activity

support for PnP disks, part 4: move NTFS,EXT2,/hd*,/bd* to the new interface

Browse Source 
git-svn-id: svn://kolibrios.org@3742 a494cfbc-eb01-0410-851d-a64ba20cac60
This commit is contained in:
CleverMouse 2013-07-01 16:29:16 +00:00
parent 05b437f60f
commit d59bc76c6d
18 changed files with 1655 additions and 3160 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
kernel/trunk/blkdev/cd_drv.inc
View File

@ -768,6 +768,8 @@ check_ATAPI_device_event:
cmp [cd_status], 0 cmp [cd_status], 0
jne .end jne .end
mov [IDE_Channel_2], 1 mov [IDE_Channel_2], 1
mov ecx, ide_channel2_mutex
call mutex_lock
call reserve_ok2 call reserve_ok2
mov [ChannelNumber], 2 mov [ChannelNumber], 2
mov [DiskNumber], 1 mov [DiskNumber], 1
@ -791,6 +793,8 @@ check_ATAPI_device_event:
cmp [cd_status], 0 cmp [cd_status], 0
jne .end jne .end
mov [IDE_Channel_2], 1 mov [IDE_Channel_2], 1
mov ecx, ide_channel2_mutex
call mutex_lock
call reserve_ok2 call reserve_ok2
mov [ChannelNumber], 2 mov [ChannelNumber], 2
mov [DiskNumber], 0 mov [DiskNumber], 0
@ -814,6 +818,8 @@ check_ATAPI_device_event:
cmp [cd_status], 0 cmp [cd_status], 0
jne .end jne .end
mov [IDE_Channel_1], 1 mov [IDE_Channel_1], 1
mov ecx, ide_channel1_mutex
call mutex_lock
call reserve_ok2 call reserve_ok2
mov [ChannelNumber], 1 mov [ChannelNumber], 1
mov [DiskNumber], 1 mov [DiskNumber], 1
@ -837,6 +843,8 @@ check_ATAPI_device_event:
cmp [cd_status], 0 cmp [cd_status], 0
jne .end jne .end
mov [IDE_Channel_1], 1 mov [IDE_Channel_1], 1
mov ecx, ide_channel1_mutex
call mutex_lock
call reserve_ok2 call reserve_ok2
mov [ChannelNumber], 1 mov [ChannelNumber], 1
mov [DiskNumber], 0 mov [DiskNumber], 0

77
kernel/trunk/blkdev/disk.inc
View File

@ -186,9 +186,9 @@ struct PARTITION
; Pointer to parent DISK structure. ; Pointer to parent DISK structure.
FSUserFunctions dd ? FSUserFunctions dd ?
; Handlers for the sysfunction 70h. This field is a pointer to the following ; Handlers for the sysfunction 70h. This field is a pointer to the following
; array. The first dword is a number of supported subfunctions, other dwords ; array. The first dword is pointer to disconnect handler.
; The first dword is a number of supported subfunctions, other dwords
; point to handlers of corresponding subfunctions. ; point to handlers of corresponding subfunctions.
; This field is 0 if file system is not recognized.
; ...fs-specific data may follow... ; ...fs-specific data may follow...
ends ends
@ -501,7 +501,8 @@ disk_media_dereference:
jz .nofree jz .nofree
.freeloop: .freeloop:
lodsd lodsd
call free mov ecx, [eax+PARTITION.FSUserFunctions]
call dword [ecx]
dec edi dec edi
jnz .freeloop jnz .freeloop
.nofree: .nofree:
@ -727,7 +728,7 @@ disk_scan_partitions:
; 10. This is not an MBR. The media is not partitioned. Create one partition ; 10. This is not an MBR. The media is not partitioned. Create one partition
; which covers all the media and abort the loop. ; which covers all the media and abort the loop.
stdcall disk_add_partition, 0, 0, \ stdcall disk_add_partition, 0, 0, \
dword [esi+DISK.MediaInfo.Capacity], dword [esi+DISK.MediaInfo.Capacity+4] dword [esi+DISK.MediaInfo.Capacity], dword [esi+DISK.MediaInfo.Capacity+4], esi
jmp .done jmp .done
.mbr: .mbr:
; 11. Process all entries of the new MBR/EBR ; 11. Process all entries of the new MBR/EBR
@ -855,7 +856,7 @@ irp type,\
adc edx, 0 adc edx, 0
push ecx push ecx
stdcall disk_add_partition, eax, edx, \ stdcall disk_add_partition, eax, edx, \
[ecx+PARTITION_TABLE_ENTRY.Length], 0 [ecx+PARTITION_TABLE_ENTRY.Length], 0, esi
pop ecx pop ecx
.nothing: .nothing:
; 5. Return. ; 5. Return.
@ -869,7 +870,10 @@ irp type,\
; This is an internal function called from disk_scan_partitions and ; This is an internal function called from disk_scan_partitions and
; process_partition_table_entry. It adds one partition to the list of ; process_partition_table_entry. It adds one partition to the list of
; partitions for the media. ; partitions for the media.
proc disk_add_partition stdcall uses ebx edi, start:qword, length:qword ; Important note: start, length, disk MUST be present and
; MUST be in the same order as in PARTITION structure.
; esi duplicates [disk].
proc disk_add_partition stdcall uses ebx edi, start:qword, length:qword, disk:dword
; 1. Check that this partition will not exceed the limit on total number. ; 1. Check that this partition will not exceed the limit on total number.
cmp [esi+DISK.NumPartitions], MAX_NUM_PARTITIONS cmp [esi+DISK.NumPartitions], MAX_NUM_PARTITIONS
jae .nothing jae .nothing
@ -974,49 +978,64 @@ disk_detect_partition:
virtual at ebp+8 virtual at ebp+8
.start dq ? .start dq ?
.length dq ? .length dq ?
end virtual .disk dd ?
; When disk_add_partition is called, ebx contains a pointer to
; a two-sectors-sized buffer. This function saves ebx in the stack
; immediately before ebp.
virtual at ebp-4
.buffer dd ?
end virtual end virtual
; 1. Read the bootsector to the buffer. ; 1. Read the bootsector to the buffer.
mov al, DISKFUNC.read ; When disk_add_partition is called, ebx contains a pointer to
mov ebx, [.buffer] ; a three-sectors-sized buffer. This function saves ebx in the stack
add ebx, 512 ; immediately before ebp.
push 1 mov ebx, [ebp-4] ; get buffer
stdcall disk_call_driver, ebx, dword [.start], dword [.start+4], esp add ebx, 512 ; advance over MBR data to bootsector data
add ebp, 8 ; ebp points to part of PARTITION structure
xor eax, eax ; first sector of the partition
call fs_read32_sys
push eax
; 2. Run tests for all supported filesystems. If at least one test succeeded, ; 2. Run tests for all supported filesystems. If at least one test succeeded,
; go to 4. ; go to 4.
; For tests: qword [ebp+8] = partition start, qword [ebp+10h] = partition ; For tests:
; length, [esp] = 0 if reading bootsector failed or 1 if succeeded, ; ebp -> first three fields of PARTITION structure, .start, .length, .disk;
; ebx points to the buffer for bootsector. ; [esp] = error code after bootsector read: 0 = ok, otherwise = failed,
; ebx points to the buffer for bootsector,
; ebx+512 points to 512-bytes buffer that can be used for anything.
call fat_create_partition call fat_create_partition
test eax, eax test eax, eax
jnz .success jnz .success
call ntfs_create_partition
test eax, eax
jnz .success
call ext2_create_partition
test eax, eax
jnz .success
; 3. No file system has recognized the volume, so just allocate the PARTITION ; 3. No file system has recognized the volume, so just allocate the PARTITION
; structure without extra fields. ; structure without extra fields.
movi eax, sizeof.PARTITION movi eax, sizeof.PARTITION
call malloc call malloc
test eax, eax test eax, eax
jz .nothing jz .nothing
mov edx, dword [.start] mov edx, dword [ebp+PARTITION.FirstSector]
mov dword [eax+PARTITION.FirstSector], edx mov dword [eax+PARTITION.FirstSector], edx
mov edx, dword [.start+4] mov edx, dword [ebp+PARTITION.FirstSector+4]
mov dword [eax+PARTITION.FirstSector+4], edx mov dword [eax+PARTITION.FirstSector+4], edx
mov edx, dword [.length] mov edx, dword [ebp+PARTITION.Length]
mov dword [eax+PARTITION.Length], edx mov dword [eax+PARTITION.Length], edx
mov edx, dword [.length+4] mov edx, dword [ebp+PARTITION.Length+4]
mov dword [eax+PARTITION.Length+4], edx mov dword [eax+PARTITION.Length+4], edx
mov [eax+PARTITION.Disk], esi mov [eax+PARTITION.Disk], esi
and [eax+PARTITION.FSUserFunctions], 0 mov [eax+PARTITION.FSUserFunctions], default_fs_functions
.success: .success:
.nothing: .nothing:
sub ebp, 8 ; restore ebp
; 4. Return with eax = pointer to PARTITION or NULL. ; 4. Return with eax = pointer to PARTITION or NULL.
pop ecx pop ecx
ret ret
iglobal
align 4
default_fs_functions:
dd free
dd 0 ; no user functions
endg
; This function is called from file_system_lfn. ; This function is called from file_system_lfn.
; This handler gets the control each time when fn 70 is called ; This handler gets the control each time when fn 70 is called
; with unknown item of root subdirectory. ; with unknown item of root subdirectory.
@ -1200,15 +1219,13 @@ fs_dyndisk:
mov eax, [edx+DISK.Partitions] mov eax, [edx+DISK.Partitions]
mov eax, [eax+ecx*4] mov eax, [eax+ecx*4]
mov edi, [eax+PARTITION.FSUserFunctions] mov edi, [eax+PARTITION.FSUserFunctions]
test edi, edi
jz .nofs
mov ecx, [ebx] mov ecx, [ebx]
cmp [edi], ecx cmp [edi+4], ecx
jbe .unsupported jbe .unsupported
push edx push edx
push ebp push ebp
mov ebp, eax mov ebp, eax
call dword [edi+4+ecx*4] call dword [edi+8+ecx*4]
pop ebp pop ebp
pop edx pop edx
mov dword [esp+32], eax mov dword [esp+32], eax
@ -1225,6 +1242,8 @@ fs_dyndisk:
mov dword [esp+32], ERROR_FILE_NOT_FOUND mov dword [esp+32], ERROR_FILE_NOT_FOUND
jmp .cleanup jmp .cleanup
.unsupported: .unsupported:
cmp edi, default_fs_functions
jz .nofs
mov dword [esp+32], ERROR_UNSUPPORTED_FS mov dword [esp+32], ERROR_UNSUPPORTED_FS
jmp .cleanup jmp .cleanup
.nomedia: .nomedia:

65
kernel/trunk/blkdev/disk_cache.inc
View File

@ -14,19 +14,7 @@ $Revision$
; eax is relative to partition start ; eax is relative to partition start
; out: eax = error code; 0 = ok ; out: eax = error code; 0 = ok
fs_read32_sys: fs_read32_sys:
; Compatibility hack: if PARTITION.Disk is 'old', there is no DISK structure, ; Save ecx, set ecx to SysCache and let the common part do its work.
; this request should be processed by hd_read.
cmp [ebp+PARTITION.Disk], 'old'
jnz @f
add eax, dword [ebp+PARTITION.FirstSector]
mov [hdd_appl_data], 0
call hd_read
mov [hdd_appl_data], 1 ; restore to default state
mov eax, [hd_error]
ret
@@:
; In the normal case, save ecx, set ecx to SysCache and let the common part
; do its work.
push ecx push ecx
mov ecx, [ebp+PARTITION.Disk] mov ecx, [ebp+PARTITION.Disk]
add ecx, DISK.SysCache add ecx, DISK.SysCache
@ -39,18 +27,7 @@ fs_read32_sys:
; eax is relative to partition start ; eax is relative to partition start
; out: eax = error code; 0 = ok ; out: eax = error code; 0 = ok
fs_read32_app: fs_read32_app:
; Compatibility hack: if PARTITION.Disk is 'old', there is no DISK structure, ; Save ecx, set ecx to AppCache and let the common part do its work.
; this request should be processed by hd_read.
cmp [ebp+PARTITION.Disk], 'old'
jnz @f
add eax, dword [ebp+PARTITION.FirstSector]
mov [hdd_appl_data], 1
call hd_read
mov eax, [hd_error]
ret
@@:
; In the normal case, save ecx, set ecx to AppCache and let the common part
; do its work.
push ecx push ecx
mov ecx, [ebp+PARTITION.Disk] mov ecx, [ebp+PARTITION.Disk]
add ecx, DISK.AppCache add ecx, DISK.AppCache
@ -185,19 +162,7 @@ end virtual
; eax is relative to partition start ; eax is relative to partition start
; out: eax = error code; 0 = ok ; out: eax = error code; 0 = ok
fs_write32_sys: fs_write32_sys:
; Compatibility hack: if PARTITION.Disk is 'old', there is no DISK structure, ; Save ecx, set ecx to SysCache and let the common part do its work.
; this request should be processed by hd_write.
cmp [ebp+PARTITION.Disk], 'old'
jnz @f
add eax, dword [ebp+PARTITION.FirstSector]
mov [hdd_appl_data], 0
call hd_write
mov [hdd_appl_data], 1 ; restore to default state
mov eax, [hd_error]
ret
@@:
; In the normal case, save ecx, set ecx to SysCache and let the common part
; do its work.
push ecx push ecx
mov ecx, [ebp+PARTITION.Disk] mov ecx, [ebp+PARTITION.Disk]
add ecx, DISK.SysCache add ecx, DISK.SysCache
@ -210,18 +175,7 @@ fs_write32_sys:
; eax is relative to partition start ; eax is relative to partition start
; out: eax = error code; 0 = ok ; out: eax = error code; 0 = ok
fs_write32_app: fs_write32_app:
; Compatibility hack: if PARTITION.Disk is 'old', there is no DISK structure, ; Save ecx, set ecx to AppCache and let the common part do its work.
; this request should be processed by hd_write.
cmp [ebp+PARTITION.Disk], 'old'
jnz @f
add eax, dword [ebp+PARTITION.FirstSector]
mov [hdd_appl_data], 1
call hd_write
mov eax, [hd_error]
ret
@@:
; In the normal case, save ecx, set ecx to AppCache and let the common part
; do its work.
push ecx push ecx
mov ecx, [ebp+PARTITION.Disk] mov ecx, [ebp+PARTITION.Disk]
add ecx, DISK.AppCache add ecx, DISK.AppCache
@ -622,17 +576,6 @@ disk_free_cache:
; This function flushes all modified data from both caches for the given DISK. ; This function flushes all modified data from both caches for the given DISK.
; esi = pointer to DISK ; esi = pointer to DISK
disk_sync: disk_sync:
; Compatibility hack: if PARTITION.Disk is 'old', there is no DISK structure,
; this request should be processed by write_cache.
cmp esi, 'old'
jnz @f
mov [hdd_appl_data], 0
call write_cache
mov [hdd_appl_data], 1
call write_cache
mov eax, [hd_error]
ret
@@:
; The algorithm is straightforward. ; The algorithm is straightforward.
push esi push esi
push esi ; for second write_cache64 push esi ; for second write_cache64

607
kernel/trunk/blkdev/hd_drv.inc
View File

@ -1,6 +1,6 @@
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; ;; ;; ;;
;; Copyright (C) KolibriOS team 2004-2012. All rights reserved. ;; ;; Copyright (C) KolibriOS team 2004-2013. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License ;; ;; Distributed under terms of the GNU General Public License ;;
;; ;; ;; ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@ -13,39 +13,93 @@ $Revision$
; Access through BIOS by diamond ; Access through BIOS by diamond
; LBA48 support by Mario79 ; LBA48 support by Mario79
;----------------------------------------------------------------------------- ;-----------------------------------------------------------------------------
struct HD_DATA
hdbase dd ?
hdid dd ?
hdpos dd ?
ends
iglobal
align 4 align 4
hd_read: ide_callbacks:
;----------------------------------------------------------- dd ide_callbacks.end - ide_callbacks ; strucsize
; input : eax = block to read dd 0 ; no close function
; ebx = destination dd 0 ; no closemedia function
;----------------------------------------------------------- dd ide_querymedia
dd ide_read
dd ide_write
dd 0 ; no flush function
dd 0 ; use default cache size
.end:
bd_callbacks:
dd bd_callbacks.end - bd_callbacks ; strucsize
dd 0 ; no close function
dd 0 ; no closemedia function
dd bd_querymedia
dd bd_read_interface
dd bd_write_interface
dd 0 ; no flush function
dd 0 ; use default cache size
.end:
hd0_data HD_DATA ?, 0, 1
hd1_data HD_DATA ?, 0x10, 2
hd2_data HD_DATA ?, 0, 3
hd3_data HD_DATA ?, 0x10, 4
endg
uglobal
ide_mutex MUTEX
ide_channel1_mutex MUTEX
ide_channel2_mutex MUTEX
endg
proc ide_read stdcall uses edi, \
hd_data, buffer, startsector:qword, numsectors
; hd_data = pointer to hd*_data
; buffer = pointer to buffer for data
; startsector = 64-bit start sector
; numsectors = pointer to number of sectors on input,
; must be filled with number of sectors really read
locals
sectors_todo dd ?
channel_lock dd ?
endl
; 1. Initialize number of sectors: get number of requested sectors
; and say that no sectors were read yet.
mov ecx, [numsectors]
mov eax, [ecx]
mov dword [ecx], 0
mov [sectors_todo], eax
; 2. Acquire the global lock.
mov ecx, ide_mutex
call mutex_lock
mov ecx, ide_channel2_mutex
mov eax, [hd_data]
cmp [eax+HD_DATA.hdbase], 0x1F0
jne .IDE_Channel_2
mov ecx, ide_channel1_mutex
.IDE_Channel_2:
mov [channel_lock], ecx
call mutex_lock
; 3. Convert parameters to the form suitable for worker procedures.
; Underlying procedures do not know about 64-bit sectors.
; Worker procedures use global variables and edi for [buffer].
cmp dword [startsector+4], 0
jnz .fail
and [hd_error], 0 and [hd_error], 0
push ecx esi edi ; scan cache mov ecx, [hd_data]
mov eax, [ecx+HD_DATA.hdbase]
call calculate_cache mov [hdbase], eax
add esi, 8 mov eax, [ecx+HD_DATA.hdid]
mov [hdid], eax
mov edi, 1 mov eax, [ecx+HD_DATA.hdpos]
mov [hdpos], eax
hdreadcache: mov eax, dword [startsector]
cmp dword [esi+4], 0 ; empty mov edi, [buffer]
je nohdcache ; 4. Worker procedures take one sectors per time, so loop over all sectors to read.
.sectors_loop:
cmp [esi], eax ; correct sector
je yeshdcache
nohdcache:
add esi, 8
inc edi
dec ecx
jnz hdreadcache
call find_empty_slot ; ret in edi
cmp [hd_error], 0
jne return_01
; Read through BIOS?
cmp [hdpos], 0x80
jae .bios
; DMA read is permitted if [allow_dma_access]=1 or 2 ; DMA read is permitted if [allow_dma_access]=1 or 2
cmp [allow_dma_access], 2 cmp [allow_dma_access], 2
ja .nodma ja .nodma
@ -55,38 +109,273 @@ nohdcache:
jmp @f jmp @f
.nodma: .nodma:
call hd_read_pio call hd_read_pio
jmp @f
.bios:
call bd_read
@@: @@:
cmp [hd_error], 0 cmp [hd_error], 0
jne return_01 jnz .fail
mov ecx, [numsectors]
call calculate_cache_1 inc dword [ecx] ; one more sector is read
lea esi, [edi*8+esi] dec [sectors_todo]
jz .done
mov [esi], eax ; sector number inc eax
mov dword [esi+4], 1 ; hd read - mark as same as in hd jnz .sectors_loop
; 5. Loop is done, either due to error or because everything is done.
yeshdcache: ; Release the global lock and return the corresponding status.
mov esi, edi .fail:
shl esi, 9 mov ecx, [channel_lock]
call mutex_unlock
push eax mov ecx, ide_mutex
call calculate_cache_2 call mutex_unlock
add esi, eax or eax, -1
pop eax
mov edi, ebx
mov ecx, 512/4
cld
rep movsd ; move data
return_01:
pop edi esi ecx
ret ret
.done:
mov ecx, [channel_lock]
call mutex_unlock
mov ecx, ide_mutex
call mutex_unlock
xor eax, eax
ret
endp
proc ide_write stdcall uses esi edi, \
hd_data, buffer, startsector:qword, numsectors
; hd_data = pointer to hd*_data
; buffer = pointer to buffer with data
; startsector = 64-bit start sector
; numsectors = pointer to number of sectors on input,
; must be filled with number of sectors really written
locals
sectors_todo dd ?
channel_lock dd ?
endl
; 1. Initialize number of sectors: get number of requested sectors
; and say that no sectors were read yet.
mov ecx, [numsectors]
mov eax, [ecx]
mov dword [ecx], 0
mov [sectors_todo], eax
; 2. Acquire the global lock.
mov ecx, ide_mutex
call mutex_lock
mov ecx, ide_channel2_mutex
mov eax, [hd_data]
cmp [eax+HD_DATA.hdbase], 0x1F0
jne .IDE_Channel_2
mov ecx, ide_channel1_mutex
.IDE_Channel_2:
mov [channel_lock], ecx
call mutex_lock
; 3. Convert parameters to the form suitable for worker procedures.
; Underlying procedures do not know about 64-bit sectors.
; Worker procedures use global variables and esi for [buffer].
cmp dword [startsector+4], 0
jnz .fail
and [hd_error], 0
mov ecx, [hd_data]
mov eax, [ecx+HD_DATA.hdbase]
mov [hdbase], eax
mov eax, [ecx+HD_DATA.hdid]
mov [hdid], eax
mov eax, [ecx+HD_DATA.hdpos]
mov [hdpos], eax
mov esi, [buffer]
lea edi, [startsector]
mov [cache_chain_ptr], edi
; 4. Worker procedures take max 16 sectors per time,
; loop until all sectors will be processed.
.sectors_loop:
mov ecx, 16
cmp ecx, [sectors_todo]
jbe @f
mov ecx, [sectors_todo]
@@:
mov [cache_chain_size], cl
; DMA write is permitted only if [allow_dma_access]=1
cmp [allow_dma_access], 2
jae .nodma
cmp [dma_hdd], 1
jnz .nodma
call cache_write_dma
jmp .common
.nodma:
mov [cache_chain_size], 1
call cache_write_pio
.common:
cmp [hd_error], 0
jnz .fail
movzx ecx, [cache_chain_size]
mov eax, [numsectors]
add [eax], ecx
sub [sectors_todo], ecx
jz .done
add [edi], ecx
jc .fail
shl ecx, 9
add esi, ecx
jmp .sectors_loop
; 5. Loop is done, either due to error or because everything is done.
; Release the global lock and return the corresponding status.
.fail:
mov ecx, [channel_lock]
call mutex_unlock
mov ecx, ide_mutex
call mutex_unlock
or eax, -1
ret
.done:
mov ecx, [channel_lock]
call mutex_unlock
mov ecx, ide_mutex
call mutex_unlock
xor eax, eax
ret
endp
; This is a stub.
proc ide_querymedia stdcall, hd_data, mediainfo
mov eax, [mediainfo]
mov [eax+DISKMEDIAINFO.Flags], 0
mov [eax+DISKMEDIAINFO.SectorSize], 512
or dword [eax+DISKMEDIAINFO.Capacity], 0xFFFFFFFF
or dword [eax+DISKMEDIAINFO.Capacity+4], 0xFFFFFFFF
xor eax, eax
ret
endp
proc bd_read_interface stdcall uses edi, \
userdata, buffer, startsector:qword, numsectors
; userdata = old [hdpos] = 80h + index in NumBiosDisks
; buffer = pointer to buffer for data
; startsector = 64-bit start sector
; numsectors = pointer to number of sectors on input,
; must be filled with number of sectors really read
locals
sectors_todo dd ?
endl
; 1. Initialize number of sectors: get number of requested sectors
; and say that no sectors were read yet.
mov ecx, [numsectors]
mov eax, [ecx]
mov dword [ecx], 0
mov [sectors_todo], eax
; 2. Acquire the global lock.
mov ecx, ide_mutex
call mutex_lock
; 3. Convert parameters to the form suitable for worker procedures.
; Underlying procedures do not know about 64-bit sectors.
; Worker procedures use global variables and edi for [buffer].
cmp dword [startsector+4], 0
jnz .fail
and [hd_error], 0
mov eax, [userdata]
mov [hdpos], eax
mov eax, dword [startsector]
mov edi, [buffer]
; 4. Worker procedures take one sectors per time, so loop over all sectors to read.
.sectors_loop:
call bd_read
cmp [hd_error], 0
jnz .fail
mov ecx, [numsectors]
inc dword [ecx] ; one more sector is read
dec [sectors_todo]
jz .done
inc eax
jnz .sectors_loop
; 5. Loop is done, either due to error or because everything is done.
; Release the global lock and return the corresponding status.
.fail:
mov ecx, ide_mutex
call mutex_unlock
or eax, -1
ret
.done:
mov ecx, ide_mutex
call mutex_unlock
xor eax, eax
ret
endp
proc bd_write_interface stdcall uses esi edi, \
userdata, buffer, startsector:qword, numsectors
; userdata = old [hdpos] = 80h + index in NumBiosDisks
; buffer = pointer to buffer with data
; startsector = 64-bit start sector
; numsectors = pointer to number of sectors on input,
; must be filled with number of sectors really written
locals
sectors_todo dd ?
endl
; 1. Initialize number of sectors: get number of requested sectors
; and say that no sectors were read yet.
mov ecx, [numsectors]
mov eax, [ecx]
mov dword [ecx], 0
mov [sectors_todo], eax
; 2. Acquire the global lock.
mov ecx, ide_mutex
call mutex_lock
; 3. Convert parameters to the form suitable for worker procedures.
; Underlying procedures do not know about 64-bit sectors.
; Worker procedures use global variables and esi for [buffer].
cmp dword [startsector+4], 0
jnz .fail
and [hd_error], 0
mov eax, [userdata]
mov [hdpos], eax
mov esi, [buffer]
lea edi, [startsector]
mov [cache_chain_ptr], edi
; 4. Worker procedures take max 16 sectors per time,
; loop until all sectors will be processed.
.sectors_loop:
mov ecx, 16
cmp ecx, [sectors_todo]
jbe @f
mov ecx, [sectors_todo]
@@:
mov [cache_chain_size], cl
call bd_write_cache_chain
cmp [hd_error], 0
jnz .fail
movzx ecx, [cache_chain_size]
mov eax, [numsectors]
add [eax], ecx
sub [sectors_todo], ecx
jz .done
add [edi], ecx
jc .fail
shl ecx, 9
add esi, ecx
jmp .sectors_loop
; 5. Loop is done, either due to error or because everything is done.
; Release the global lock and return the corresponding status.
.fail:
mov ecx, ide_mutex
call mutex_unlock
or eax, -1
ret
.done:
mov ecx, ide_mutex
call mutex_unlock
xor eax, eax
ret
endp
; This is a stub.
proc bd_querymedia stdcall, hd_data, mediainfo
mov eax, [mediainfo]
mov [eax+DISKMEDIAINFO.Flags], 0
mov [eax+DISKMEDIAINFO.SectorSize], 512
or dword [eax+DISKMEDIAINFO.Capacity], 0xFFFFFFFF
or dword [eax+DISKMEDIAINFO.Capacity+4], 0xFFFFFFFF
xor eax, eax
ret
endp
;----------------------------------------------------------------------------- ;-----------------------------------------------------------------------------
align 4 align 4
; input: eax = sector, edi -> buffer
; output: edi = edi + 512
hd_read_pio: hd_read_pio:
push eax edx push eax edx
@ -184,80 +473,18 @@ hd_read_pio:
pushfd pushfd
cli cli
push edi
shl edi, 9
push eax
call calculate_cache_2
add edi, eax
pop eax
mov ecx, 256 mov ecx, 256
mov edx, [hdbase] mov edx, [hdbase]
cld cld
rep insw rep insw
pop edi
popfd popfd
pop edx eax pop edx eax
ret ret
;----------------------------------------------------------------------------- ;-----------------------------------------------------------------------------
align 4 align 4
hd_write: ; edi -> sector, esi -> data
;-----------------------------------------------------------
; input : eax = block
; ebx = pointer to memory
;-----------------------------------------------------------
push ecx esi edi
; check if the cache already has the sector and overwrite it
call calculate_cache
add esi, 8
mov edi, 1
hdwritecache:
cmp dword [esi+4], 0 ; if cache slot is empty
je not_in_cache_write
cmp [esi], eax ; if the slot has the sector
je yes_in_cache_write
not_in_cache_write:
add esi, 8
inc edi
dec ecx
jnz hdwritecache
; sector not found in cache
; write the block to a new location
call find_empty_slot ; ret in edi
cmp [hd_error], 0
jne hd_write_access_denied
call calculate_cache_1
lea esi, [edi*8+esi]
mov [esi], eax ; sector number
yes_in_cache_write:
mov dword [esi+4], 2 ; write - differs from hd
shl edi, 9
push eax
call calculate_cache_2
add edi, eax
pop eax
mov esi, ebx
mov ecx, 512/4
cld
rep movsd ; move data
hd_write_access_denied:
pop edi esi ecx
ret
;-----------------------------------------------------------------------------
align 4
cache_write_pio: cache_write_pio:
; Select the desired drive ; Select the desired drive
mov edx, [hdbase] mov edx, [hdbase]
@ -271,7 +498,7 @@ cache_write_pio:
jne hd_write_error jne hd_write_error
; ATA with 28 or 48 bit for sector number? ; ATA with 28 or 48 bit for sector number?
mov eax, [esi] mov eax, [edi]
cmp eax, 0x10000000 cmp eax, 0x10000000
jae .lba48 jae .lba48
;-------------------------------------- ;--------------------------------------
@ -286,7 +513,7 @@ cache_write_pio:
inc eax inc eax
out dx, al ; ATA Sector Counter счётчик секторов out dx, al ; ATA Sector Counter счётчик секторов
inc edx inc edx
mov eax, [esi] ; eax = sector to write mov eax, [edi] ; eax = sector to write
out dx, al ; LBA Low LBA (7:0) out dx, al ; LBA Low LBA (7:0)
shr eax, 8 shr eax, 8
inc edx inc edx
@ -319,7 +546,7 @@ cache_write_pio:
inc eax inc eax
out dx, al ; Sector Count Current Sector count (7:0) out dx, al ; Sector Count Current Sector count (7:0)
inc edx inc edx
mov eax, [esi] mov eax, [edi]
rol eax, 8 rol eax, 8
out dx, al ; LBA Low Previous LBA (31:24) out dx, al ; LBA Low Previous LBA (31:24)
xor eax, eax ; because only 32 bit cache xor eax, eax ; because only 32 bit cache
@ -328,7 +555,7 @@ cache_write_pio:
inc edx inc edx
out dx, al ; LBA High Previous LBA (47:40) out dx, al ; LBA High Previous LBA (47:40)
sub edx, 2 sub edx, 2
mov eax, [esi] mov eax, [edi]
out dx, al ; LBA Low Current LBA (7:0) out dx, al ; LBA Low Current LBA (7:0)
shr eax, 8 shr eax, 8
inc edx inc edx
@ -355,14 +582,6 @@ cache_write_pio:
pushfd pushfd
cli cli
mov esi, edi
shl esi, 9
push eax
call calculate_cache_2
add esi, eax
pop eax
mov ecx, 256 mov ecx, 256
mov edx, [hdbase] mov edx, [hdbase]
cld cld
@ -605,19 +824,13 @@ hd_read_dma:
sub eax, [dma_cur_sector] sub eax, [dma_cur_sector]
shl eax, 9 shl eax, 9
add eax, (OS_BASE+IDE_DMA) add eax, (OS_BASE+IDE_DMA)
push ecx esi edi push ecx esi
mov esi, eax mov esi, eax
shl edi, 9
push eax
call calculate_cache_2
add edi, eax
pop eax
mov ecx, 512/4 mov ecx, 512/4
cld cld
rep movsd rep movsd
pop edi esi ecx pop esi ecx
pop edx pop edx
pop eax pop eax
ret ret
@ -766,24 +979,12 @@ hd_read_dma:
mov [dma_cur_sector], eax mov [dma_cur_sector], eax
jmp hd_read_dma jmp hd_read_dma
;----------------------------------------------------------------------------- ;-----------------------------------------------------------------------------
align 4 cache_write_dma:
write_cache_sector:
mov [cache_chain_size], 1
mov [cache_chain_pos], edi
;--------------------------------------
align 4
write_cache_chain:
cmp [hdpos], 0x80
jae bd_write_cache_chain
mov eax, [cache_chain_ptr] mov eax, [cache_chain_ptr]
push esi push esi
mov eax, IDE_descriptor_table mov eax, IDE_descriptor_table
mov edx, eax mov edx, eax
pusha pusha
mov esi, [cache_chain_pos]
shl esi, 9
call calculate_cache_2
add esi, eax
mov edi, (OS_BASE+IDE_DMA) mov edi, (OS_BASE+IDE_DMA)
mov dword [edx], IDE_DMA mov dword [edx], IDE_DMA
movzx ecx, [cache_chain_size] movzx ecx, [cache_chain_size]
@ -965,19 +1166,12 @@ bd_read:
sub eax, [bios_cur_sector] sub eax, [bios_cur_sector]
shl eax, 9 shl eax, 9
add eax, (OS_BASE+0x9A000) add eax, (OS_BASE+0x9A000)
push ecx esi edi push ecx esi
mov esi, eax mov esi, eax
shl edi, 9
push eax
call calculate_cache_2
add edi, eax
pop eax
mov ecx, 512/4 mov ecx, 512/4
cld cld
rep movsd rep movsd
pop edi esi ecx pop esi ecx
pop edx pop edx
pop eax pop eax
ret ret
@ -1006,10 +1200,6 @@ bd_read:
align 4 align 4
bd_write_cache_chain: bd_write_cache_chain:
pusha pusha
mov esi, [cache_chain_pos]
shl esi, 9
call calculate_cache_2
add esi, eax
mov edi, OS_BASE + 0x9A000 mov edi, OS_BASE + 0x9A000
movzx ecx, [cache_chain_size] movzx ecx, [cache_chain_size]
push ecx push ecx
@ -1041,7 +1231,7 @@ align 4
int13_call: int13_call:
; Because this code uses fixed addresses, ; Because this code uses fixed addresses,
; it can not be run simultaniously by many threads. ; it can not be run simultaniously by many threads.
; In current implementation it is protected by common mutex 'hd1_status' ; In current implementation it is protected by common mutex 'ide_status'
mov word [OS_BASE + 510h], 10h ; packet length mov word [OS_BASE + 510h], 10h ; packet length
mov word [OS_BASE + 512h], cx ; number of sectors mov word [OS_BASE + 512h], cx ; number of sectors
mov dword [OS_BASE + 514h], 9A000000h ; buffer 9A00:0000 mov dword [OS_BASE + 514h], 9A000000h ; buffer 9A00:0000
@ -1088,82 +1278,3 @@ int13_call:
@@: @@:
ret ret
; \end{diamond} ; \end{diamond}
;-----------------------------------------------------------------------------
align 4
reserve_hd1:
cli
cmp [hd1_status], 0
je reserve_ok1
sti
call change_task
jmp reserve_hd1
reserve_ok1:
push eax
mov eax, [CURRENT_TASK]
shl eax, 5
mov eax, [eax+CURRENT_TASK+TASKDATA.pid]
mov [hd1_status], eax
pop eax
sti
ret
;-----------------------------------------------------------------------------
uglobal
hd_in_cache db ?
endg
;-----------------------------------------------------------------------------
align 4
reserve_hd_channel:
; BIOS disk accesses are protected with common mutex hd1_status
; This must be modified when hd1_status will not be valid!
cmp [hdpos], 0x80
jae .ret
cmp [hdbase], 0x1F0
jne .IDE_Channel_2
.IDE_Channel_1:
cli
cmp [IDE_Channel_1], 0
je .reserve_ok_1
sti
call change_task
jmp .IDE_Channel_1
.IDE_Channel_2:
cli
cmp [IDE_Channel_2], 0
je .reserve_ok_2
sti
call change_task
jmp .IDE_Channel_2
.reserve_ok_1:
mov [IDE_Channel_1], 1
push eax
mov al, 1
jmp @f
.reserve_ok_2:
mov [IDE_Channel_2], 1
push eax
mov al, 3
@@:
cmp [hdid], 1
sbb al, -1
mov [hd_in_cache], al
pop eax
sti
.ret:
ret
;-----------------------------------------------------------------------------
free_hd_channel:
; see comment at reserve_hd_channel
cmp [hdpos], 0x80
jae .ret
cmp [hdbase], 0x1F0
jne .IDE_Channel_2
.IDE_Channel_1:
mov [IDE_Channel_1], 0
.ret:
ret
.IDE_Channel_2:
mov [IDE_Channel_2], 0
ret
;-----------------------------------------------------------------------------

539
kernel/trunk/blkdev/ide_cache.inc
View File

@ -23,545 +23,6 @@
$Revision$ $Revision$
align 4
write_cache:
;-----------------------------------------------------------
; write all changed sectors to disk
;-----------------------------------------------------------
push eax ecx edx esi edi
; write difference ( 2 ) from cache to hd
call calculate_cache
add esi, 8
mov edi, 1
write_cache_more:
cmp dword [esi+4], 2; if cache slot is not different
jne .write_chain
mov dword [esi+4], 1; same as in hd
mov eax, [esi] ; eax = sector to write
cmp eax, [PARTITION_START]
jb danger
cmp eax, [PARTITION_END]
ja danger
cmp [hdpos], 0x80
jae @f
; DMA write is permitted only if [allow_dma_access]=1
cmp [allow_dma_access], 2
jae .nodma
cmp [dma_hdd], 1
jnz .nodma
@@:
; Объединяем запись цепочки последовательных секторов в одно обращение к диску
cmp ecx, 1
jz .nonext
cmp dword [esi+8+4], 2
jnz .nonext
push eax
inc eax
cmp eax, [esi+8]
pop eax
jnz .nonext
cmp [cache_chain_started], 1
jz @f
mov [cache_chain_started], 1
mov [cache_chain_size], 0
mov [cache_chain_pos], edi
mov [cache_chain_ptr], esi
@@:
inc [cache_chain_size]
cmp [cache_chain_size], 16
jnz .continue
jmp .write_chain
.nonext:
call flush_cache_chain
mov [cache_chain_size], 1
mov [cache_chain_ptr], esi
call write_cache_sector
jmp .continue
.nodma:
call cache_write_pio
.write_chain:
call flush_cache_chain
.continue:
danger:
add esi, 8
inc edi
dec ecx
jnz write_cache_more
call flush_cache_chain
return_02:
pop edi esi edx ecx eax
ret
flush_cache_chain:
cmp [cache_chain_started], 0
jz @f
call write_cache_chain
mov [cache_chain_started], 0
@@:
ret
;--------------------------------------------------------------------
align 4
find_empty_slot:
;-----------------------------------------------------------
; find empty or read slot, flush cache if next 10% is used by write
; output : edi = cache slot
;-----------------------------------------------------------
; push ecx esi
search_again:
call calculate_cache_3
shr ecx, 3
search_for_empty:
inc edi
call calculate_cache_4
jbe inside_cache
mov edi, 1
inside_cache:
push esi
call calculate_cache_1
cmp dword [edi*8+esi+4], 2
pop esi
jb found_slot ; it's empty or read
dec ecx
jnz search_for_empty
call write_cache ; no empty slots found, write all
cmp [hd_error], 0
jne found_slot_access_denied
jmp search_again ; and start again
found_slot:
call calculate_cache_5
found_slot_access_denied:
ret
;--------------------------------------------------------------------
align 4
calculate_cache:
; 1 - IDE0 ... 4 - IDE3
.ide0:
cmp [hdpos], 1
jne .ide1
cmp [hdd_appl_data], 0
jne .ide0_appl_data
mov ecx, [cache_ide0_system_sad_size]
mov esi, [cache_ide0_pointer]
ret
.ide0_appl_data:
mov ecx, [cache_ide0_appl_sad_size]
mov esi, [cache_ide0_data_pointer]
ret
.ide1:
cmp [hdpos], 2
jne .ide2
cmp [hdd_appl_data], 0
jne .ide1_appl_data
mov ecx, [cache_ide1_system_sad_size]
mov esi, [cache_ide1_pointer]
ret
.ide1_appl_data:
mov ecx, [cache_ide1_appl_sad_size]
mov esi, [cache_ide1_data_pointer]
ret
.ide2:
cmp [hdpos], 3
jne .ide3
cmp [hdd_appl_data], 0
jne .ide2_appl_data
mov ecx, [cache_ide2_system_sad_size]
mov esi, [cache_ide2_pointer]
ret
.ide2_appl_data:
mov ecx, [cache_ide2_appl_sad_size]
mov esi, [cache_ide2_data_pointer]
ret
.ide3:
cmp [hdpos], 4
jne .noide
cmp [hdd_appl_data], 0
jne .ide3_appl_data
mov ecx, [cache_ide3_system_sad_size]
mov esi, [cache_ide3_pointer]
ret
.ide3_appl_data:
mov ecx, [cache_ide3_appl_sad_size]
mov esi, [cache_ide3_data_pointer]
ret
.noide:
push eax
mov eax, [hdpos]
sub eax, 80h
cmp byte [BiosDisksData+eax*4+2], -1
jz @f
movzx eax, byte [BiosDisksData+eax*4+2]
imul eax, cache_ide1-cache_ide0
add eax, cache_ide0
jmp .get
@@:
imul eax, cache_ide1-cache_ide0
add eax, BiosDiskCaches
.get:
cmp [hdd_appl_data], 0
jne .bd_appl_data
mov ecx, [cache_ide0_system_sad_size-cache_ide0+eax]
mov esi, [cache_ide0_pointer-cache_ide0+eax]
pop eax
ret
.bd_appl_data:
mov ecx, [cache_ide0_appl_sad_size-cache_ide0+eax]
mov esi, [cache_ide0_data_pointer-cache_ide0+eax]
pop eax
ret
;--------------------------------------------------------------------
align 4
calculate_cache_1:
; 1 - IDE0 ... 4 - IDE3
.ide0:
cmp [hdpos], 1
jne .ide1
cmp [hdd_appl_data], 0
jne .ide0_appl_data
mov esi, [cache_ide0_pointer]
ret
.ide0_appl_data:
mov esi, [cache_ide0_data_pointer]
ret
.ide1:
cmp [hdpos], 2
jne .ide2
cmp [hdd_appl_data], 0
jne .ide1_appl_data
mov esi, [cache_ide1_pointer]
ret
.ide1_appl_data:
mov esi, [cache_ide1_data_pointer]
ret
.ide2:
cmp [hdpos], 3
jne .ide3
cmp [hdd_appl_data], 0
jne .ide2_appl_data
mov esi, [cache_ide2_pointer]
ret
.ide2_appl_data:
mov esi, [cache_ide2_data_pointer]
ret
.ide3:
cmp [hdpos], 4
jne .noide
cmp [hdd_appl_data], 0
jne .ide3_appl_data
mov esi, [cache_ide3_pointer]
ret
.ide3_appl_data:
mov esi, [cache_ide3_data_pointer]
ret
.noide:
push eax
mov eax, [hdpos]
sub eax, 80h
cmp byte [BiosDisksData+eax*4+2], -1
jz @f
movzx eax, byte [BiosDisksData+eax*4+2]
imul eax, cache_ide1-cache_ide0
add eax, cache_ide0
jmp .get
@@:
imul eax, cache_ide1-cache_ide0
add eax, BiosDiskCaches
.get:
cmp [hdd_appl_data], 0
jne .bd_appl_data
mov esi, [cache_ide0_pointer-cache_ide0+eax]
pop eax
ret
.bd_appl_data:
mov esi, [cache_ide0_data_pointer-cache_ide0+eax]
pop eax
ret
;--------------------------------------------------------------------
align 4
calculate_cache_2:
; 1 - IDE0 ... 4 - IDE3
.ide0:
cmp [hdpos], 1
jne .ide1
cmp [hdd_appl_data], 0
jne .ide0_appl_data
mov eax, [cache_ide0_system_data]
ret
.ide0_appl_data:
mov eax, [cache_ide0_appl_data]
ret
.ide1:
cmp [hdpos], 2
jne .ide2
cmp [hdd_appl_data], 0
jne .ide1_appl_data
mov eax, [cache_ide1_system_data]
ret
.ide1_appl_data:
mov eax, [cache_ide1_appl_data]
ret
.ide2:
cmp [hdpos], 3
jne .ide3
cmp [hdd_appl_data], 0
jne .ide2_appl_data
mov eax, [cache_ide2_system_data]
ret
.ide2_appl_data:
mov eax, [cache_ide2_appl_data]
ret
.ide3:
cmp [hdpos], 4
jne .noide
cmp [hdd_appl_data], 0
jne .ide3_appl_data
mov eax, [cache_ide3_system_data]
ret
.ide3_appl_data:
mov eax, [cache_ide3_appl_data]
ret
.noide:
mov eax, [hdpos]
sub eax, 80h
cmp byte [BiosDisksData+eax*4+2], -1
jz @f
movzx eax, byte [BiosDisksData+eax*4+2]
imul eax, cache_ide1-cache_ide0
add eax, cache_ide0
jmp .get
@@:
imul eax, cache_ide1-cache_ide0
add eax, BiosDiskCaches
.get:
cmp [hdd_appl_data], 0
jne .bd_appl_data
mov eax, [cache_ide0_system_data-cache_ide0+eax]
ret
.bd_appl_data:
mov eax, [cache_ide0_appl_data-cache_ide0+eax]
ret
;--------------------------------------------------------------------
align 4
calculate_cache_3:
; mov ecx,cache_max*10/100
; mov edi,[cache_search_start]
; 1 - IDE0 ... 4 - IDE3
.ide0:
cmp [hdpos], 1
jne .ide1
cmp [hdd_appl_data], 0
jne .ide0_appl_data
mov ecx, [cache_ide0_system_sad_size]
mov edi, [cache_ide0_search_start]
ret
.ide0_appl_data:
mov ecx, [cache_ide0_appl_sad_size]
mov edi, [cache_ide0_appl_search_start]
ret
.ide1:
cmp [hdpos], 2
jne .ide2
cmp [hdd_appl_data], 0
jne .ide1_appl_data
mov ecx, [cache_ide1_system_sad_size]
mov edi, [cache_ide1_search_start]
ret
.ide1_appl_data:
mov ecx, [cache_ide1_appl_sad_size]
mov edi, [cache_ide1_appl_search_start]
ret
.ide2:
cmp [hdpos], 3
jne .ide3
cmp [hdd_appl_data], 0
jne .ide2_appl_data
mov ecx, [cache_ide2_system_sad_size]
mov edi, [cache_ide2_search_start]
ret
.ide2_appl_data:
mov ecx, [cache_ide2_appl_sad_size]
mov edi, [cache_ide2_appl_search_start]
ret
.ide3:
cmp [hdpos], 4
jne .noide
cmp [hdd_appl_data], 0
jne .ide3_appl_data
mov ecx, [cache_ide3_system_sad_size]
mov edi, [cache_ide3_search_start]
ret
.ide3_appl_data:
mov ecx, [cache_ide3_appl_sad_size]
mov edi, [cache_ide3_appl_search_start]
ret
.noide:
push eax
mov eax, [hdpos]
sub eax, 80h
cmp byte [BiosDisksData+eax*4+2], -1
jz @f
movzx eax, byte [BiosDisksData+eax*4+2]
imul eax, cache_ide1-cache_ide0
add eax, cache_ide0
jmp .get
@@:
imul eax, cache_ide1-cache_ide0
add eax, BiosDiskCaches
.get:
cmp [hdd_appl_data], 0
jne .bd_appl_data
mov ecx, [cache_ide0_system_sad_size-cache_ide0+eax]
mov edi, [cache_ide0_search_start-cache_ide0+eax]
pop eax
ret
.bd_appl_data:
mov ecx, [cache_ide0_appl_sad_size-cache_ide0+eax]
mov edi, [cache_ide0_appl_search_start-cache_ide0+eax]
pop eax
ret
;--------------------------------------------------------------------
align 4
calculate_cache_4:
; cmp edi,cache_max
; 1 - IDE0 ... 4 - IDE3
.ide0:
cmp [hdpos], 1
jne .ide1
cmp [hdd_appl_data], 0
jne .ide0_appl_data
cmp edi, [cache_ide0_system_sad_size]
ret
.ide0_appl_data:
cmp edi, [cache_ide0_appl_sad_size]
ret
.ide1:
cmp [hdpos], 2
jne .ide2
cmp [hdd_appl_data], 0
jne .ide1_appl_data
cmp edi, [cache_ide1_system_sad_size]
ret
.ide1_appl_data:
cmp edi, [cache_ide1_appl_sad_size]
ret
.ide2:
cmp [hdpos], 3
jne .ide3
cmp [hdd_appl_data], 0
jne .ide2_appl_data
cmp edi, [cache_ide2_system_sad_size]
ret
.ide2_appl_data:
cmp edi, [cache_ide2_appl_sad_size]
ret
.ide3:
cmp [hdpos], 4
jne .noide
cmp [hdd_appl_data], 0
jne .ide3_appl_data
cmp edi, [cache_ide3_system_sad_size]
ret
.ide3_appl_data:
cmp edi, [cache_ide3_appl_sad_size]
ret
.noide:
push eax
mov eax, [hdpos]
sub eax, 80h
cmp byte [BiosDisksData+eax*4+2], -1
jz @f
movzx eax, byte [BiosDisksData+eax*4+2]
imul eax, cache_ide1-cache_ide0
add eax, cache_ide0
jmp .get
@@:
imul eax, cache_ide1-cache_ide0
add eax, BiosDiskCaches
.get:
cmp [hdd_appl_data], 0
jne .bd_appl_data
cmp edi, [cache_ide0_system_sad_size-cache_ide0+eax]
pop eax
ret
.bd_appl_data:
cmp edi, [cache_ide0_appl_sad_size-cache_ide0+eax]
pop eax
ret
;--------------------------------------------------------------------
align 4
calculate_cache_5:
; mov [cache_search_start],edi
; 1 - IDE0 ... 4 - IDE3
.ide0:
cmp [hdpos], 1
jne .ide1
cmp [hdd_appl_data], 0
jne .ide0_appl_data
mov [cache_ide0_search_start], edi
ret
.ide0_appl_data:
mov [cache_ide0_appl_search_start], edi
ret
.ide1:
cmp [hdpos], 2
jne .ide2
cmp [hdd_appl_data], 0
jne .ide1_appl_data
mov [cache_ide1_search_start], edi
ret
.ide1_appl_data:
mov [cache_ide1_appl_search_start], edi
ret
.ide2:
cmp [hdpos], 3
jne .ide3
cmp [hdd_appl_data], 0
jne .ide2_appl_data
mov [cache_ide2_search_start], edi
ret
.ide2_appl_data:
mov [cache_ide2_appl_search_start], edi
ret
.ide3:
cmp [hdpos], 4
jne .noide
cmp [hdd_appl_data], 0
jne .ide3_appl_data
mov [cache_ide3_search_start], edi
ret
.ide3_appl_data:
mov [cache_ide3_appl_search_start], edi
ret
.noide:
push eax
mov eax, [hdpos]
sub eax, 80h
cmp byte [BiosDisksData+eax*4+2], -1
jz @f
movzx eax, byte [BiosDisksData+eax*4+2]
imul eax, cache_ide1-cache_ide0
add eax, cache_ide0
jmp .get
@@:
imul eax, cache_ide1-cache_ide0
add eax, BiosDiskCaches
.get:
cmp [hdd_appl_data], 0
jne .bd_appl_data
mov [cache_ide0_search_start-cache_ide0+eax], edi
pop eax
ret
.bd_appl_data:
mov [cache_ide0_appl_search_start-cache_ide0+eax], edi
pop eax
ret
;--------------------------------------------------------------------
align 4 align 4
find_empty_slot_CD_cache: find_empty_slot_CD_cache:
;----------------------------------------------------------- ;-----------------------------------------------------------

147
kernel/trunk/boot/rdload.inc
View File

@ -1,6 +1,6 @@
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; ;; ;; ;;
;; Copyright (C) KolibriOS team 2004-2011. All rights reserved. ;; ;; Copyright (C) KolibriOS team 2004-2013. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License ;; ;; Distributed under terms of the GNU General Public License ;;
;; ;; ;; ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@ -8,87 +8,70 @@
$Revision$ $Revision$
read_ramdisk:
; READ RAMDISK IMAGE FROM HD ; READ RAMDISK IMAGE FROM HD
cmp [boot_dev+OS_BASE+0x10000], 1 cmp [boot_dev+OS_BASE+0x10000], 1
jne no_sys_on_hd jne no_sys_on_hd
test [DRIVE_DATA+1], byte 0x40 xor ebp, ebp
jz position_2 .hd_loop:
mov [hdbase], 0x1f0 lea eax, [ebp+'0']
mov [hdid], 0x0 mov [read_image_fsinfo.name_digit], al
mov [hdpos], 1 movzx eax, byte [DRIVE_DATA+2+ebp]
mov [fat32part], 0 test eax, eax
position_1_1: jz .next_hd
inc [fat32part] push eax
call search_and_read_image mov esi, 1
cmp [image_retrieved], 1 .partition_loop:
je yes_sys_on_hd mov eax, esi
movzx eax, byte [DRIVE_DATA+2] push -'0'
cmp [fat32part], eax @@:
jle position_1_1 xor edx, edx
position_2: div [_10]
test [DRIVE_DATA+1], byte 0x10 push edx
jz position_3 test eax, eax
mov [hdbase], 0x1f0 jnz @b
mov [hdid], 0x10 mov edi, read_image_fsinfo.partition
mov [hdpos], 2 @@:
mov [fat32part], 0 pop eax
position_2_1: add al, '0'
inc [fat32part] stosb
call search_and_read_image jnz @b
cmp [image_retrieved], 1 mov byte [edi-1], '/'
je yes_sys_on_hd push esi edi
movzx eax, byte [DRIVE_DATA+3] mov esi, bootpath1
cmp eax, [fat32part] mov ecx, bootpath1.len
jle position_2_1 rep movsb
position_3: call read_image
test [DRIVE_DATA+1], byte 0x4 test eax, eax
jz position_4 jz .yes
mov [hdbase], 0x170 cmp eax, 6
mov [hdid], 0x0 jz .yes
mov [hdpos], 3 pop edi
mov [fat32part], 0 push edi
position_3_1: mov esi, bootpath2
inc [fat32part] mov ecx, bootpath2.len
call search_and_read_image rep movsb
cmp [image_retrieved], 1 call read_image
je yes_sys_on_hd test eax, eax
movzx eax, byte [DRIVE_DATA+4] jz .yes
cmp eax, [fat32part] cmp eax, 6
jle position_3_1 jz .yes
position_4: pop edi esi
test [DRIVE_DATA+1], byte 0x1 inc esi
jz no_sys_on_hd cmp esi, [esp]
mov [hdbase], 0x170 jbe .partition_loop
mov [hdid], 0x10 pop eax
mov [hdpos], 4 .next_hd:
mov [fat32part], 0 inc ebp
position_4_1: cmp ebp, 4
inc [fat32part] jb .hd_loop
call search_and_read_image jmp no_sys_on_hd
cmp [image_retrieved], 1 .yes:
je yes_sys_on_hd pop edi esi eax
movzx eax, byte [DRIVE_DATA+5]
cmp eax, [fat32part]
jle position_4_1
jmp yes_sys_on_hd jmp yes_sys_on_hd
search_and_read_image:
call set_FAT32_variables
mov edx, bootpath
call read_image
test eax, eax
jz image_present
mov edx, bootpath2
call read_image
test eax, eax
jz image_present
ret
image_present:
mov [image_retrieved], 1
ret
iglobal iglobal
align 4 align 4
read_image_fsinfo: read_image_fsinfo:
@ -96,8 +79,16 @@ read_image_fsinfo:
dq 0 ; offset: zero dq 0 ; offset: zero
dd 1474560/512 ; size dd 1474560/512 ; size
dd RAMDISK ; buffer dd RAMDISK ; buffer
db 0 db '/hd'
dd hdsysimage+OS_BASE+0x10000 .name_digit db '0'
db '/'
.partition:
rb 64 ; should be enough for '255/KOLIBRI/KOLIBRI.IMG'
bootpath1 db 'KOLIBRI.IMG',0
.len = $ - bootpath1
bootpath2 db 'KOLIBRI/KOLIBRI.IMG',0
.len = $ - bootpath2
endg endg
read_image: read_image:
@ -107,8 +98,6 @@ read_image:
popad popad
ret ret
image_retrieved db 0
counter_of_partitions db 0
no_sys_on_hd: no_sys_on_hd:
; test_to_format_ram_disk (need if not using ram disk) ; test_to_format_ram_disk (need if not using ram disk)
cmp [boot_dev+OS_BASE+0x10000], 3 cmp [boot_dev+OS_BASE+0x10000], 3

5
kernel/trunk/core/sys32.inc
View File

@ -578,11 +578,6 @@ terminate: ; terminate application
push esi ; remove hd1 & cd & flp reservation push esi ; remove hd1 & cd & flp reservation
shl esi, 5 shl esi, 5
mov esi, [esi+CURRENT_TASK+TASKDATA.pid] mov esi, [esi+CURRENT_TASK+TASKDATA.pid]
cmp [hd1_status], esi
jnz @f
call free_hd_channel
and [hd1_status], 0
@@:
cmp [cd_status], esi cmp [cd_status], esi
jnz @f jnz @f
call free_cd_channel call free_cd_channel

2
kernel/trunk/data32.inc
View File

@ -164,8 +164,6 @@ else if ~ lang eq sp
ud_user_message db 'Error: unsupported processor instruction',0 ud_user_message db 'Error: unsupported processor instruction',0
end if end if
bootpath db '/KOLIBRI '
bootpath2 db 0
vmode db '/sys/drivers/VMODE.MDR',0 vmode db '/sys/drivers/VMODE.MDR',0
;vrr_m db 'VRR_M',0 ;vrr_m db 'VRR_M',0
kernel_file db 'KERNEL MNT' kernel_file db 'KERNEL MNT'

91
kernel/trunk/detect/getcache.inc
View File

@ -36,65 +36,27 @@ $Revision$
xor eax, eax xor eax, eax
mov [hdd_appl_data], 1;al mov [hdd_appl_data], 1;al
mov [cd_appl_data], 1 mov [cd_appl_data], 1
mov ch, [DRIVE_DATA+1] test byte [DRIVE_DATA+1], 2
mov cl, ch je .ide2
and cl, 11b
je .ide2
mov esi, cache_ide3 mov esi, cache_ide3
call get_cache_ide call get_cache_ide
.ide2: .ide2:
mov cl, ch test byte [DRIVE_DATA+1], 8
shr cl, 2
and cl, 11b
je .ide1 je .ide1
mov esi, cache_ide2 mov esi, cache_ide2
call get_cache_ide call get_cache_ide
.ide1: .ide1:
mov cl, ch test byte [DRIVE_DATA+1], 0x20
shr cl, 4
and cl, 11b
je .ide0 je .ide0
mov esi, cache_ide1 mov esi, cache_ide1
call get_cache_ide call get_cache_ide
.ide0: .ide0:
mov cl, ch test byte [DRIVE_DATA+1], 0x80
shr cl, 6
and cl, 11b
je @f je @f
mov esi, cache_ide0 mov esi, cache_ide0
call get_cache_ide call get_cache_ide
@@: @@:
xor ecx, ecx
cmp [NumBiosDisks], ecx
jz .endbd
mov esi, BiosDiskCaches
.loopbd:
push ecx
movsx ecx, byte [BiosDisksData+ecx*4+2]
inc ecx
jz .getbd
add ecx, ecx
movzx eax, byte [DRIVE_DATA+1]
shl eax, cl
and ah, 3
cmp ah, 1
jz .contbd
pop ecx
mov byte [BiosDisksData+ecx*4+2], -1
push ecx
.getbd:
mov eax, [cache_ide0_size]
mov [esi+cache_ide0_size-cache_ide0], eax
mov cl, 1
call get_cache_ide
.contbd:
pop ecx
add esi, cache_ide1-cache_ide0
inc ecx
cmp ecx, [NumBiosDisks]
jb .loopbd
.endbd:
jmp end_get_cache jmp end_get_cache
get_cache_ide: get_cache_ide:
@ -114,33 +76,6 @@ get_cache_ide:
add ebx, edx add ebx, edx
mov [esi+cache_ide0_data_pointer-cache_ide0], ebx mov [esi+cache_ide0_data_pointer-cache_ide0], ebx
cmp cl, 10b
je .cd
push ecx
mov eax, [esi+cache_ide0_system_data_size-cache_ide0]
call calculate_for_hd
add eax, [esi+cache_ide0_pointer-cache_ide0]
mov [esi+cache_ide0_system_data-cache_ide0], eax
mov [esi+cache_ide0_system_sad_size-cache_ide0], ecx
push edi
mov edi, [esi+cache_ide0_pointer-cache_ide0]
call clear_ide_cache
pop edi
mov eax, [esi+cache_ide0_appl_data_size-cache_ide0]
call calculate_for_hd
add eax, [esi+cache_ide0_data_pointer-cache_ide0]
mov [esi+cache_ide0_appl_data-cache_ide0], eax
mov [esi+cache_ide0_appl_sad_size-cache_ide0], ecx
push edi
mov edi, [esi+cache_ide0_data_pointer-cache_ide0]
call clear_ide_cache
pop edi
pop ecx
ret
.cd: .cd:
push ecx push ecx
mov eax, [esi+cache_ide0_system_data_size-cache_ide0] mov eax, [esi+cache_ide0_system_data_size-cache_ide0]
@ -168,20 +103,6 @@ get_cache_ide:
pop ecx pop ecx
ret ret
calculate_for_hd:
push eax
mov ebx, eax
shr eax, 9
shl eax, 3
sub ebx, eax
shr ebx, 9
mov ecx, ebx
shl ebx, 9
pop eax
sub eax, ebx
dec ecx
ret
calculate_for_cd: calculate_for_cd:
push eax push eax
mov ebx, eax mov ebx, eax

270
kernel/trunk/detect/sear_par.inc
View File

@ -1,165 +1,139 @@
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; ;; ;; ;;
;; Copyright (C) KolibriOS team 2004-2011. All rights reserved. ;; ;; Copyright (C) KolibriOS team 2004-2013. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License ;; ;; Distributed under terms of the GNU General Public License ;;
;; ;; ;; ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
$Revision$ $Revision$
search_partitions:
;**************************************************** ; 1. Fill missing parameters in HD_DATA structures.
; поиск логических дисков на обнаруженных HDD mov eax, [hd_address_table]
; и занесение данных в область таблицы mov [hd0_data.hdbase], eax ;0x1f0
; автор Mario79 mov [hd1_data.hdbase], eax
;**************************************************** mov eax, [hd_address_table+16]
mov [transfer_adress], DRIVE_DATA+0xa mov [hd2_data.hdbase], eax
search_partitions_ide0: mov [hd3_data.hdbase], eax
; 2. Notify the system about /hd* disks.
; For every existing disk, call ide_disk_add with correct parameters.
; Generate name "hdN" on the stack; this is 4 bytes including terminating zero.
; 2a. /hd0: exists if mask 0x40 in [DRIVE_DATA+1] is set,
; data: hd0_data,
; number of partitions: [DRIVE_DATA+2]
test [DRIVE_DATA+1], byte 0x40 test [DRIVE_DATA+1], byte 0x40
jz search_partitions_ide1 jz @f
mov eax, [hd_address_table] push 'hd0'
mov [hdbase], eax ;0x1f0 mov eax, esp ; name
mov [hdid], 0x0 mov edx, hd0_data
mov [hdpos], 1 call ide_disk_add
mov [known_part], 1 mov [DRIVE_DATA+2], al
search_partitions_ide0_1: pop ecx ; restore the stack
call set_PARTITION_variables @@:
test [problem_partition], 2 ; 2b. /hd1: exists if mask 0x10 in [DRIVE_DATA+1] is set,
jnz search_partitions_ide1 ; not found part ; data: hd1_data,
test [problem_partition], 1 ; number of partitions: [DRIVE_DATA+3]
jnz @F ; not found known_part
;cmp [problem_partition],0
;jne search_partitions_ide1
inc byte [DRIVE_DATA+2]
call partition_data_transfer
add [transfer_adress], 100
@@:
inc [known_part]
jmp search_partitions_ide0_1
search_partitions_ide1:
test [DRIVE_DATA+1], byte 0x10 test [DRIVE_DATA+1], byte 0x10
jz search_partitions_ide2 jz @f
mov eax, [hd_address_table] push 'hd1'
mov [hdbase], eax ;0x1f0 mov eax, esp
mov [hdid], 0x10 mov edx, hd1_data
mov [hdpos], 2 call ide_disk_add
mov [known_part], 1 mov [DRIVE_DATA+3], al
search_partitions_ide1_1:
call set_PARTITION_variables
test [problem_partition], 2
jnz search_partitions_ide2
test [problem_partition], 1
jnz @F
;cmp [problem_partition],0
;jne search_partitions_ide2
inc byte [DRIVE_DATA+3]
call partition_data_transfer
add [transfer_adress], 100
@@:
inc [known_part]
jmp search_partitions_ide1_1
search_partitions_ide2:
test [DRIVE_DATA+1], byte 0x4
jz search_partitions_ide3
mov eax, [hd_address_table+16]
mov [hdbase], eax ;0x170
mov [hdid], 0x0
mov [hdpos], 3
mov [known_part], 1
search_partitions_ide2_1:
call set_PARTITION_variables
test [problem_partition], 2
jnz search_partitions_ide3
test [problem_partition], 1
jnz @F
;cmp [problem_partition],0
;jne search_partitions_ide3
inc byte [DRIVE_DATA+4]
call partition_data_transfer
add [transfer_adress], 100
@@:
inc [known_part]
jmp search_partitions_ide2_1
search_partitions_ide3:
test [DRIVE_DATA+1], byte 0x1
jz end_search_partitions_ide
mov eax, [hd_address_table+16]
mov [hdbase], eax ;0x170
mov [hdid], 0x10
mov [hdpos], 4
mov [known_part], 1
search_partitions_ide3_1:
call set_PARTITION_variables
test [problem_partition], 2
jnz end_search_partitions_ide
test [problem_partition], 1
jnz @F
;cmp [problem_partition],0
;jne end_search_partitions_ide
inc byte [DRIVE_DATA+5]
call partition_data_transfer
add [transfer_adress], 100
@@:
inc [known_part]
jmp search_partitions_ide3_1
end_search_partitions_ide:
mov [hdpos], 80h
mov ecx, [NumBiosDisks]
test ecx, ecx
jz end_search_partitions
start_search_partitions_bd:
push ecx
mov eax, [hdpos]
and [BiosDiskPartitions+(eax-80h)*4], 0
mov [known_part], 1
search_partitions_bd:
call set_PARTITION_variables
test [problem_partition], 2
jnz end_search_partitions_bd
test [problem_partition], 1
jnz @F
;cmp [problem_partition], 0
;jne end_search_partitions_bd
mov eax, [hdpos]
inc [BiosDiskPartitions+(eax-80h)*4]
call partition_data_transfer
add [transfer_adress], 100
@@:
inc [known_part]
jmp search_partitions_bd
end_search_partitions_bd:
pop ecx pop ecx
inc [hdpos] @@:
loop start_search_partitions_bd ; 2c. /hd2: exists if mask 4 in [DRIVE_DATA+1] is set,
; data: hd2_data,
; number of partitions: [DRIVE_DATA+4]
test [DRIVE_DATA+1], byte 4
jz @f
push 'hd2'
mov eax, esp
mov edx, hd2_data
call ide_disk_add
mov [DRIVE_DATA+4], al
pop ecx
@@:
; 2d. /hd3: exists if mask 1 in [DRIVE_DATA+1] is set,
; data: hd3_data,
; number of partitions: [DRIVE_DATA+5]
test [DRIVE_DATA+1], byte 1
jz @f
push 'hd3'
mov eax, esp
mov edx, hd3_data
call ide_disk_add
mov [DRIVE_DATA+5], al
pop ecx
@@:
; 3. Notify the system about /bd* disks.
; 3a. Check whether there are BIOS disks. If no, skip step 3.
xor esi, esi
cmp esi, [NumBiosDisks]
jz .nobd
; Loop over all disks.
push 0
push 'bd'
.bdloop:
; 3b. Get the drive number for using in /bd* name.
movzx eax, byte [BiosDisksData+esi*4]
sub al, 80h
; 3c. Convert eax to decimal and store starting with [esp+3].
; First 2 bytes in [esp] are "bd".
lea edi, [esp+2]
; store digits in the stack, ending with -'0'
push -'0'
@@:
xor edx, edx
iglobal
align 4
_10 dd 10
endg
div [_10]
push edx
test eax, eax
jnz @b
; restore digits from the stack, this reverses the order;
; add '0', stop, when zero is reached
@@:
pop eax
add al, '0'
stosb
jnz @b
; 3e. Call the API with userdata = 80h + ecx.
mov eax, esp
lea edx, [esi+80h]
stdcall disk_add, bd_callbacks, eax, edx, 0
test eax, eax
jz @f
stdcall disk_media_changed, eax, 1
@@:
; 3f. Continue the loop.
inc esi
cmp esi, [NumBiosDisks]
jnz .bdloop
pop ecx ecx ; restore stack after name
.nobd:
jmp end_search_partitions jmp end_search_partitions
problem_partition db 0 ; used for partitions search ; Helper procedure for search_partitions, adds one IDE disk.
; For compatibility, number of partitions for IDE disks is kept in a separate variable,
include '../fs/part_set.inc' ; so the procedure returns number of partitions.
; eax -> name, edx -> disk data
partition_data_transfer: proc ide_disk_add
mov edi, [transfer_adress] stdcall disk_add, ide_callbacks, eax, edx, 0
mov esi, PARTITION_START ;start of file_system_data test eax, eax
mov ecx, (file_system_data_size+3)/4 jz @f
rep movsd push eax
ret stdcall disk_media_changed, eax, 1
uglobal pop eax
transfer_adress dd 0 mov eax, [eax+DISK.NumPartitions]
endg cmp eax, 255
partition_data_transfer_1: jbe @f
; cli mov eax, 255
push edi @@:
mov edi, PARTITION_START
mov esi, [transfer_adress]
mov ecx, (file_system_data_size+3)/4
rep movsd
pop edi
; sti
ret ret
endp
end_search_partitions: end_search_partitions:

554
kernel/trunk/fs/ext2.inc
View File

File diff suppressed because it is too large Load Diff

310
kernel/trunk/fs/fat32.inc
View File

@ -1,6 +1,6 @@
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; ;; ;; ;;
;; Copyright (C) KolibriOS team 2004-2011. All rights reserved. ;; ;; Copyright (C) KolibriOS team 2004-2013. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License ;; ;; Distributed under terms of the GNU General Public License ;;
;; ;; ;; ;;
;; FAT32.INC ;; ;; FAT32.INC ;;
@ -58,16 +58,15 @@ PUSHAD_ESI equ [esp+4]
PUSHAD_EDI equ [esp+0] PUSHAD_EDI equ [esp+0]
; Internal data for every FAT partition. ; Internal data for every FAT partition.
struct FAT struct FAT PARTITION
p PARTITION ; must be the first item
fs_type db ? fs_type db ?
fat16_root db 0 ; flag for fat16 rootdir fat16_root db 0 ; flag for fat16 rootdir
fat_change db 0 ; 1=fat has changed fat_change db 0 ; 1=fat has changed
db ? ; alignment db ? ; alignment
Lock MUTEX ? ; currently operations with one partition Lock MUTEX ? ; currently operations with one partition
; can not be executed in parallel since the ; can not be executed in parallel since the
; legacy code is not ready; this mutex guards ; legacy code is not ready; this mutex guards
; all operations ; all operations
SECTORS_PER_FAT dd 0x1f3a SECTORS_PER_FAT dd 0x1f3a
NUMBER_OF_FATS dd 0x2 NUMBER_OF_FATS dd 0x2
SECTORS_PER_CLUSTER dd 0x8 SECTORS_PER_CLUSTER dd 0x8
@ -121,6 +120,7 @@ endg
iglobal iglobal
align 4 align 4
fat_user_functions: fat_user_functions:
dd free
dd (fat_user_functions_end - fat_user_functions - 4) / 4 dd (fat_user_functions_end - fat_user_functions - 4) / 4
dd fat_Read dd fat_Read
dd fat_ReadFolder dd fat_ReadFolder
@ -138,17 +138,15 @@ endg
; these labels are located before the main function to make ; these labels are located before the main function to make
; most of jumps to these be short ; most of jumps to these be short
fat_create_partition.free_return0: fat_create_partition.free_return0:
push ebx
mov eax, ebp mov eax, ebp
call free call free
pop ebx
pop ebp pop ebp
fat_create_partition.return0: fat_create_partition.return0:
xor eax, eax xor eax, eax
ret ret
fat_create_partition: fat_create_partition:
; bootsector must have been successfully read ; bootsector must have been successfully read
cmp dword [esp+4], 1 cmp dword [esp+4], 0
jnz .return0 jnz .return0
; bootsector signature must be correct ; bootsector signature must be correct
cmp word [ebx+0x1fe], 0xaa55 cmp word [ebx+0x1fe], 0xaa55
@ -170,16 +168,17 @@ fat_create_partition:
call malloc call malloc
test eax, eax test eax, eax
jz .return0 jz .return0
mov ecx, [ebp+8] mov ecx, dword [ebp+PARTITION.FirstSector]
mov dword [eax+FAT.p.FirstSector], ecx mov dword [eax+FAT.FirstSector], ecx
mov ecx, [ebp+12] mov ecx, dword [ebp+PARTITION.FirstSector+4]
mov dword [eax+FAT.p.FirstSector+4], ecx mov dword [eax+FAT.FirstSector+4], ecx
mov ecx, [ebp+16] mov ecx, dword [ebp+PARTITION.Length]
mov dword [eax+FAT.p.Length], ecx mov dword [eax+FAT.Length], ecx
mov ecx, [ebp+20] mov ecx, dword [ebp+PARTITION.Length+4]
mov dword [eax+FAT.p.Length+4], ecx mov dword [eax+FAT.Length+4], ecx
mov [eax+FAT.p.Disk], esi mov ecx, [ebp+PARTITION.Disk]
mov [eax+FAT.p.FSUserFunctions], fat_user_functions mov [eax+FAT.Disk], ecx
mov [eax+FAT.FSUserFunctions], fat_user_functions
or [eax+FAT.fat_in_cache], -1 or [eax+FAT.fat_in_cache], -1
mov [eax+FAT.fat_change], 0 mov [eax+FAT.fat_change], 0
push ebp push ebp
@ -226,8 +225,8 @@ fat_create_partition:
jnz @f jnz @f
mov eax, [ebx+0x20] ; total sector count mov eax, [ebx+0x20] ; total sector count
@@: @@:
mov dword [ebp+FAT.p.Length], eax mov dword [ebp+FAT.Length], eax
and dword [ebp+FAT.p.Length+4], 0 and dword [ebp+FAT.Length+4], 0
sub eax, [ebp+FAT.DATA_START] ; eax = count of data sectors sub eax, [ebp+FAT.DATA_START] ; eax = count of data sectors
xor edx, edx xor edx, edx
div [ebp+FAT.SECTORS_PER_CLUSTER] div [ebp+FAT.SECTORS_PER_CLUSTER]
@ -262,7 +261,6 @@ fat_create_partition:
mov [ebp+FAT.fatEND], 0x0FFFFFF8 mov [ebp+FAT.fatEND], 0x0FFFFFF8
mov [ebp+FAT.fatMASK], 0x0FFFFFFF mov [ebp+FAT.fatMASK], 0x0FFFFFFF
mov al, 32 mov al, 32
mov [fs_type], al
mov [ebp+FAT.fs_type], al mov [ebp+FAT.fs_type], al
mov eax, ebp mov eax, ebp
pop ebp pop ebp
@ -274,7 +272,6 @@ fat_create_partition:
mov [ebp+FAT.fatEND], 0x0000FFF8 mov [ebp+FAT.fatEND], 0x0000FFF8
mov [ebp+FAT.fatMASK], 0x0000FFFF mov [ebp+FAT.fatMASK], 0x0000FFFF
mov al, 16 mov al, 16
mov [fs_type], al
mov [ebp+FAT.fs_type], al mov [ebp+FAT.fs_type], al
mov eax, ebp mov eax, ebp
pop ebp pop ebp
@ -768,42 +765,6 @@ hd_find_lfn:
pop esi pop esi
ret 4 ret 4
;----------------------------------------------------------------
;
; fs_HdRead - LFN variant for reading hard disk
;
; Obsolete, will be replaced with filesystem-specific functions.
;
; esi points to filename
; ebx pointer to 64-bit number = first wanted byte, 0+
; may be ebx=0 - start from first byte
; ecx number of bytes to read, 0+
; edx mem location to return data
;
; ret ebx = bytes read or 0xffffffff file not found
; eax = 0 ok read or other = errormsg
;
;--------------------------------------------------------------
fs_HdRead:
cmp [fs_type], 16
jz @f
cmp [fs_type], 32
jz @f
cmp [fs_type], 1
jz ntfs_HdRead
cmp [fs_type], 2
jz ext2_HdRead
or ebx, -1
mov eax, ERROR_UNKNOWN_FS
ret
@@:
sub ebx, 4
push ebp
mov ebp, [fs_dependent_data_start.partition]
call fat_Read
pop ebp
ret
;---------------------------------------------------------------- ;----------------------------------------------------------------
; fat_Read - FAT16/32 implementation of reading a file ; fat_Read - FAT16/32 implementation of reading a file
; in: ebp = pointer to FAT structure ; in: ebp = pointer to FAT structure
@ -943,43 +904,6 @@ fat_Read:
sub ebx, edx sub ebx, edx
jmp .reteof jmp .reteof
;----------------------------------------------------------------
;
; fs_HdReadFolder - LFN variant for reading hard disk folder
;
; Obsolete, will be replaced with filesystem-specific functions.
;
; esi points to filename
; ebx pointer to structure 32-bit number = first wanted block, 0+
; & flags (bitfields)
; flags: bit 0: 0=ANSI names, 1=UNICODE names
; ecx number of blocks to read, 0+
; edx mem location to return data
;
; ret ebx = blocks read or 0xffffffff folder not found
; eax = 0 ok read or other = errormsg
;
;--------------------------------------------------------------
fs_HdReadFolder:
cmp [fs_type], 16
jz @f
cmp [fs_type], 32
jz @f
cmp [fs_type], 1
jz ntfs_HdReadFolder
cmp [fs_type], 2
jz ext2_HdReadFolder
movi eax, ERROR_UNSUPPORTED_FS
or ebx, -1
ret
@@:
sub ebx, 4
push ebp
mov ebp, [fs_dependent_data_start.partition]
call fat_ReadFolder
pop ebp
ret
;---------------------------------------------------------------- ;----------------------------------------------------------------
; fat_ReadFolder - FAT16/32 implementation of reading a folder ; fat_ReadFolder - FAT16/32 implementation of reading a folder
; in: ebp = pointer to FAT structure ; in: ebp = pointer to FAT structure
@ -1377,52 +1301,6 @@ fat_get_sector:
pop ecx pop ecx
ret ret
;----------------------------------------------------------------
;
; fs_HdRewrite - LFN variant for writing hard disk
;
; Obsolete, will be replaced with filesystem-specific functions.
;
; esi points to filename
; ebx ignored (reserved)
; ecx number of bytes to write, 0+
; edx mem location to data
;
; ret ebx = number of written bytes
; eax = 0 ok read or other = errormsg
;
;--------------------------------------------------------------
fs_HdCreateFolder:
mov al, 1
jmp fs_HdRewrite.common
fs_HdRewrite:
xor eax, eax
.common:
cmp [fs_type], 16
jz @f
cmp [fs_type], 32
jz @f
cmp [fs_type], 1
jz ntfs_HdRewrite
cmp [fs_type], 2
jz ext2_HdRewrite
mov eax, ERROR_UNKNOWN_FS
xor ebx, ebx
ret
@@:
sub ebx, 4
push ebp
mov ebp, [fs_dependent_data_start.partition]
test eax, eax
mov eax, fat_CreateFolder
jnz @f
mov eax, fat_Rewrite
@@:
call eax
pop ebp
ret
fshrad: fshrad:
call fat_unlock call fat_unlock
mov eax, ERROR_ACCESS_DENIED mov eax, ERROR_ACCESS_DENIED
@ -1441,7 +1319,7 @@ fat_CreateFolder:
jmp fat_Rewrite.common jmp fat_Rewrite.common
;---------------------------------------------------------------- ;----------------------------------------------------------------
; fat_HdRewrite - FAT16/32 implementation of creating a new file ; fat_Rewrite - FAT16/32 implementation of creating a new file
; in: ebp = pointer to FAT structure ; in: ebp = pointer to FAT structure
; in: esi+[esp+4] = name ; in: esi+[esp+4] = name
; in: ebx = pointer to parameters from sysfunc 70 ; in: ebx = pointer to parameters from sysfunc 70
@ -1988,51 +1866,16 @@ fat_Rewrite:
mov [edi-32+20], cx mov [edi-32+20], cx
jmp .writedircont jmp .writedircont
;----------------------------------------------------------------
;
; fs_HdWrite - LFN variant for writing to hard disk
;
; Obsolete, will be replaced with filesystem-specific functions.
;
; esi points to filename
; ebx pointer to 64-bit number = first wanted byte, 0+
; may be ebx=0 - start from first byte
; ecx number of bytes to write, 0+
; edx mem location to data
;
; ret ebx = bytes written (maybe 0)
; eax = 0 ok write or other = errormsg
;
;--------------------------------------------------------------
fat_Write.access_denied: fat_Write.access_denied:
push ERROR_ACCESS_DENIED push ERROR_ACCESS_DENIED
fs_HdWrite.ret0: fat_Write.ret0:
pop eax pop eax
xor ebx, ebx xor ebx, ebx
ret ret
fs_HdWrite.ret11: fat_Write.ret11:
push ERROR_DEVICE push ERROR_DEVICE
jmp fs_HdWrite.ret0 jmp fat_Write.ret0
fs_HdWrite:
cmp [fs_type], 16
jz @f
cmp [fs_type], 32
jz @f
cmp [fs_type], 1
jz ntfs_HdWrite
cmp [fs_type], 2
jz ext2_HdWrite
push ERROR_UNKNOWN_FS
jmp .ret0
@@:
sub ebx, 4
push ebp
mov ebp, [fs_dependent_data_start.partition]
call fat_Write
pop ebp
ret
;---------------------------------------------------------------- ;----------------------------------------------------------------
; fat_Write - FAT16/32 implementation of writing to file ; fat_Write - FAT16/32 implementation of writing to file
@ -2051,7 +1894,7 @@ fat_Write:
pop edi pop edi
push eax push eax
call fat_unlock call fat_unlock
jmp fs_HdWrite.ret0 jmp .ret0
.found: .found:
; FAT does not support files larger than 4GB ; FAT does not support files larger than 4GB
cmp dword [ebx+8], 0 cmp dword [ebx+8], 0
@ -2060,7 +1903,7 @@ fat_Write:
pop edi pop edi
push ERROR_END_OF_FILE push ERROR_END_OF_FILE
call fat_unlock call fat_unlock
jmp fs_HdWrite.ret0 jmp .ret0
@@: @@:
mov ecx, [ebx+12] mov ecx, [ebx+12]
mov edx, [ebx+16] mov edx, [ebx+16]
@ -2361,39 +2204,6 @@ hd_extend_file:
stc stc
ret ret
;----------------------------------------------------------------
;
; fs_HdSetFileEnd - set end of file on hard disk
;
; Obsolete, will be replaced with filesystem-specific functions.
;
; esi points to filename
; ebx points to 64-bit number = new file size
; ecx ignored (reserved)
; edx ignored (reserved)
;
; ret eax = 0 ok or other = errormsg
;
;--------------------------------------------------------------
fs_HdSetFileEnd:
cmp [fs_type], 16
jz @f
cmp [fs_type], 32
jz @f
cmp [fs_type], 1
jz ntfs_HdSetFileEnd
cmp [fs_type], 2
jz ext2_HdSetFileEnd
movi eax, ERROR_UNKNOWN_FS
ret
@@:
sub ebx, 4
push ebp
mov ebp, [fs_dependent_data_start.partition]
call fat_SetFileEnd
pop ebp
ret
;---------------------------------------------------------------- ;----------------------------------------------------------------
; fat_SetFileEnd - FAT16/32 implementation of setting end-of-file ; fat_SetFileEnd - FAT16/32 implementation of setting end-of-file
; in: ebp = pointer to FAT structure ; in: ebp = pointer to FAT structure
@ -2634,25 +2444,6 @@ fat_SetFileEnd:
movi eax, ERROR_FAT_TABLE movi eax, ERROR_FAT_TABLE
ret ret
fs_HdGetFileInfo:
cmp [fs_type], 16
jz @f
cmp [fs_type], 32
jz @f
cmp [fs_type], 1
jz ntfs_HdGetFileInfo
cmp [fs_type], 2
jz ext2_HdGetFileInfo
mov eax, ERROR_UNKNOWN_FS
ret
@@:
sub ebx, 4
push ebp
mov ebp, [fs_dependent_data_start.partition]
call fat_GetFileInfo
pop ebp
ret
;---------------------------------------------------------------- ;----------------------------------------------------------------
; fat_GetFileInfo - FAT16/32 implementation of getting file info ; fat_GetFileInfo - FAT16/32 implementation of getting file info
; in: ebp = pointer to FAT structure ; in: ebp = pointer to FAT structure
@ -2687,25 +2478,6 @@ fat_GetFileInfo:
pop edi pop edi
ret ret
fs_HdSetFileInfo:
cmp [fs_type], 16
jz @f
cmp [fs_type], 32
jz @f
cmp [fs_type], 1
jz ntfs_HdSetFileInfo
cmp [fs_type], 2
jz ext2_HdSetFileInfo
mov eax, ERROR_UNKNOWN_FS
ret
@@:
sub ebx, 4
push ebp
mov ebp, [fs_dependent_data_start.partition]
call fat_SetFileInfo
pop ebp
ret
;---------------------------------------------------------------- ;----------------------------------------------------------------
; fat_SetFileInfo - FAT16/32 implementation of setting file info ; fat_SetFileInfo - FAT16/32 implementation of setting file info
; in: ebp = pointer to FAT structure ; in: ebp = pointer to FAT structure
@ -2741,36 +2513,6 @@ fat_SetFileInfo:
pop edi pop edi
ret ret
;----------------------------------------------------------------
;
; fs_HdDelete - delete file or empty folder from hard disk
;
; Obsolete, will be replaced with filesystem-specific functions.
;
; esi points to filename
;
; ret eax = 0 ok or other = errormsg
;
;--------------------------------------------------------------
fs_HdDelete:
cmp [fs_type], 16
jz @f
cmp [fs_type], 32
jz @f
cmp [fs_type], 1
jz ntfs_HdDelete
cmp [fs_type], 2
jz ext2_HdDelete
movi eax, ERROR_UNKNOWN_FS
ret
@@:
sub ebx, 4
push ebp
mov ebp, [fs_dependent_data_start.partition]
call fat_Delete
pop ebp
ret
;---------------------------------------------------------------- ;----------------------------------------------------------------
; fat_Delete - FAT16/32 implementation of deleting a file/folder ; fat_Delete - FAT16/32 implementation of deleting a file/folder
; in: ebp = pointer to FAT structure ; in: ebp = pointer to FAT structure

109
kernel/trunk/fs/fs.inc
View File

@ -318,86 +318,6 @@ endg
fs_noflpdisk: fs_noflpdisk:
;***************************************************************** ;*****************************************************************
mov eax, [edi+1]
cmp eax, 'HD0 '
je fs_yesharddisk_IDE0
cmp eax, 'HD1 '
je fs_yesharddisk_IDE1
cmp eax, 'HD2 '
je fs_yesharddisk_IDE2
cmp eax, 'HD3 '
je fs_yesharddisk_IDE3
jmp old_path_harddisk
fs_yesharddisk_IDE0:
call reserve_hd1
mov [hdbase], 0x1f0
mov [hdid], 0x0
mov [hdpos], 1
jmp fs_yesharddisk_partition
fs_yesharddisk_IDE1:
call reserve_hd1
mov [hdbase], 0x1f0
mov [hdid], 0x10
mov [hdpos], 2
jmp fs_yesharddisk_partition
fs_yesharddisk_IDE2:
call reserve_hd1
mov [hdbase], 0x170
mov [hdid], 0x0
mov [hdpos], 3
jmp fs_yesharddisk_partition
fs_yesharddisk_IDE3:
call reserve_hd1
mov [hdbase], 0x170
mov [hdid], 0x10
mov [hdpos], 4
fs_yesharddisk_partition:
call reserve_hd_channel
; call choice_necessity_partition
; jmp fs_yesharddisk_all
jmp fs_for_new_semantic
choice_necessity_partition:
mov eax, [edi+1+12]
call StringToNumber
mov [fat32part], eax
choice_necessity_partition_1:
mov ecx, [hdpos]
xor eax, eax
mov [hd_entries], eax; entries in hd cache
mov edx, DRIVE_DATA+2
cmp ecx, 0x80
jb search_partition_array
mov ecx, 4
search_partition_array:
mov bl, [edx]
movzx ebx, bl
add eax, ebx
inc edx
loop search_partition_array
mov ecx, [hdpos]
mov edx, BiosDiskPartitions
sub ecx, 0x80
jb .s
je .f
@@:
mov ebx, [edx]
add edx, 4
add eax, ebx
loop @b
jmp .f
.s:
sub eax, ebx
.f:
add eax, [known_part]; add eax,[fat32part]
dec eax
xor edx, edx
imul eax, 100
add eax, DRIVE_DATA+0xa
mov [transfer_adress], eax
call partition_data_transfer_1
ret
old_path_harddisk: old_path_harddisk:
mov eax, [edi+1] mov eax, [edi+1]
cmp eax, 'HD ' cmp eax, 'HD '
@ -416,27 +336,7 @@ choice_necessity_partition_1:
fs_no_LBA_read: fs_no_LBA_read:
cmp byte [edi+1+11], 0; directory read
je fs_give_dir1
call reserve_hd1
fs_for_new_semantic:
call choice_necessity_partition
fs_yesharddisk_all:
mov eax, 1
mov ebx, [esp+24+24]
cmp [hdpos], 0 ; is hd base set?
jz hd_err_return
cmp [fat32part], 0 ; is partition set?
jnz @f
hd_err_return: hd_err_return:
call free_hd_channel
and [hd1_status], 0
jmp file_system_return
@@:
call free_hd_channel
and [hd1_status], 0
fs_noharddisk: fs_noharddisk:
; \begin{diamond}[18.03.2006] ; \begin{diamond}[18.03.2006]
@ -542,7 +442,10 @@ LBA_read:
lbarl1: lbarl1:
call reserve_hd1 pushad
mov ecx, ide_mutex
call mutex_lock
popad
push eax push eax
push ecx push ecx
@ -633,6 +536,10 @@ LBA_read:
mov [hd_error], 0 mov [hd_error], 0
mov [hd1_status], 0 mov [hd1_status], 0
add esp, 2*4 add esp, 2*4
pushad
mov ecx, ide_mutex
call mutex_unlock
popad
ret ret

277
kernel/trunk/fs/fs_lfn.inc
View File

@ -42,18 +42,6 @@ rootdirs:
db 10,'floppydisk' db 10,'floppydisk'
dd fs_OnFloppy dd fs_OnFloppy
dd fs_NextFloppy dd fs_NextFloppy
db 3,'hd0'
dd fs_OnHd0
dd fs_NextHd0
db 3,'hd1'
dd fs_OnHd1
dd fs_NextHd1
db 3,'hd2'
dd fs_OnHd2
dd fs_NextHd2
db 3,'hd3'
dd fs_OnHd3
dd fs_NextHd3
;********************************************** ;**********************************************
db 3,'cd0' db 3,'cd0'
dd fs_OnCd0 dd fs_OnCd0
@ -76,14 +64,6 @@ virtual_root_query:
db 'rd',0 db 'rd',0
dd fs_HasFloppy dd fs_HasFloppy
db 'fd',0 db 'fd',0
dd fs_HasHd0
db 'hd0',0
dd fs_HasHd1
db 'hd1',0
dd fs_HasHd2
db 'hd2',0
dd fs_HasHd3
db 'hd3',0
;********************************************** ;**********************************************
dd fs_HasCd0 dd fs_HasCd0
db 'cd0',0 db 'cd0',0
@ -97,7 +77,6 @@ virtual_root_query:
dd 0 dd 0
fs_additional_handlers: fs_additional_handlers:
dd biosdisk_handler, biosdisk_enum_root
dd dyndisk_handler, dyndisk_enum_root dd dyndisk_handler, dyndisk_enum_root
; add new handlers here ; add new handlers here
dd 0 dd 0
@ -523,84 +502,6 @@ fs_FloppyServices:
dd fs_FloppyCreateFolder dd fs_FloppyCreateFolder
fs_NumFloppyServices = ($ - fs_FloppyServices)/4 fs_NumFloppyServices = ($ - fs_FloppyServices)/4
fs_OnHd0:
call reserve_hd1
mov eax, [hd_address_table]
mov [hdbase], eax ;0x1F0
mov [hdid], 0
push 1
jmp fs_OnHd
fs_OnHd1:
call reserve_hd1
mov eax, [hd_address_table]
mov [hdbase], eax ;0x1F0
mov [hdid], 0x10
push 2
jmp fs_OnHd
fs_OnHd2:
call reserve_hd1
mov eax, [hd_address_table+16]
mov [hdbase], eax ;0x170
mov [hdid], 0
push 3
jmp fs_OnHd
fs_OnHd3:
call reserve_hd1
mov eax, [hd_address_table+16]
mov [hdbase], eax ;0x170
mov [hdid], 0x10
push 4
fs_OnHd:
call reserve_hd_channel
pop eax
mov [hdpos], eax
cmp ecx, 0x100
jae fs_OnHdAndBd.nf
cmp cl, [DRIVE_DATA+1+eax]
fs_OnHdAndBd:
jbe @f
.nf:
call free_hd_channel
and [hd1_status], 0
mov dword [image_of_eax], 5 ; not found
ret
@@:
mov [known_part], ecx ; mov [fat32part], ecx
push ebx esi
call choice_necessity_partition_1
pop esi ebx
mov ecx, [ebx+12]
mov edx, [ebx+16]
; add edx, std_application_base_address
mov eax, [ebx]
cmp eax, fs_NumHdServices
jae .not_impl
add ebx, 4
call dword [fs_HdServices + eax*4]
call free_hd_channel
and [hd1_status], 0
mov [image_of_eax], eax
mov [image_of_ebx], ebx
ret
.not_impl:
call free_hd_channel
and [hd1_status], 0
mov dword [image_of_eax], 2 ; not implemented
ret
fs_HdServices:
dd fs_HdRead
dd fs_HdReadFolder
dd fs_HdRewrite
dd fs_HdWrite
dd fs_HdSetFileEnd
dd fs_HdGetFileInfo
dd fs_HdSetFileInfo
dd 0
dd fs_HdDelete
dd fs_HdCreateFolder
fs_NumHdServices = ($ - fs_HdServices)/4
;******************************************************* ;*******************************************************
fs_OnCd0: fs_OnCd0:
call reserve_cd call reserve_cd
@ -691,22 +592,6 @@ fs_HasFloppy:
cmp byte [DRIVE_DATA], 0 cmp byte [DRIVE_DATA], 0
setnz al setnz al
ret ret
fs_HasHd0:
test byte [DRIVE_DATA+1], 01000000b
setnz al
ret
fs_HasHd1:
test byte [DRIVE_DATA+1], 00010000b
setnz al
ret
fs_HasHd2:
test byte [DRIVE_DATA+1], 00000100b
setnz al
ret
fs_HasHd3:
test byte [DRIVE_DATA+1], 00000001b
setnz al
ret
;******************************************************* ;*******************************************************
fs_HasCd0: fs_HasCd0:
@ -762,27 +647,6 @@ fs_NextFloppy:
stc stc
ret ret
; on hdx, we have partitions from 1 to [0x40002+x]
fs_NextHd0:
push 0
jmp fs_NextHd
fs_NextHd1:
push 1
jmp fs_NextHd
fs_NextHd2:
push 2
jmp fs_NextHd
fs_NextHd3:
push 3
fs_NextHd:
pop ecx
movzx ecx, byte [DRIVE_DATA+2+ecx]
cmp eax, ecx
jae fs_NextFloppy.no2
inc eax
clc
ret
;******************************************************* ;*******************************************************
fs_NextCd: fs_NextCd:
; we always have /cdX/1 ; we always have /cdX/1
@ -795,147 +659,6 @@ fs_NextCd:
ret ret
;******************************************************* ;*******************************************************
; Additional FS handlers.
; This handler gets the control each time when fn 70 is called
; with unknown item of root subdirectory.
; in: esi -> name
; ebp = 0 or rest of name relative to esi
; out: if the handler processes path, he must not return in file_system_lfn,
; but instead pop return address and return directly to the caller
; otherwise simply return
; here we test for /bd<N>/... - BIOS disks
biosdisk_handler:
cmp [NumBiosDisks], 0
jz .ret
mov al, [esi]
or al, 20h
cmp al, 'b'
jnz .ret
mov al, [esi+1]
or al, 20h
cmp al, 'd'
jnz .ret
push esi
inc esi
inc esi
cmp byte [esi], '0'
jb .ret2
cmp byte [esi], '9'
ja .ret2
xor edx, edx
@@:
lodsb
test al, al
jz .ok
cmp al, '/'
jz .ok
sub al, '0'
cmp al, 9
ja .ret2
lea edx, [edx*5]
lea edx, [edx*2+eax]
jmp @b
.ret2:
pop esi
.ret:
ret
.ok:
cmp al, '/'
jz @f
dec esi
@@:
add dl, 80h
xor ecx, ecx
@@:
cmp dl, [BiosDisksData+ecx*4]
jz .ok2
inc ecx
cmp ecx, [NumBiosDisks]
jb @b
jmp .ret2
.ok2:
add esp, 8
test al, al
jnz @f
mov esi, fs_BdNext
jmp file_system_lfn.maindir_noesi
@@:
push ecx
push ecx
push biosdisk_cleanup
push fs_OnBd
mov edi, esp
jmp file_system_lfn.found2
fs_BdNext:
cmp eax, [BiosDiskPartitions+ecx*4]
inc eax
cmc
biosdisk_cleanup:
ret
fs_OnBd:
pop edx edx edx edx
; edx = disk number, ecx = partition number
; esi+ebp = name
call reserve_hd1
add edx, 0x80
mov [hdpos], edx
cmp ecx, [BiosDiskPartitions+(edx-0x80)*4]
jmp fs_OnHdAndBd
; This handler is called when virtual root is enumerated
; and must return all items which can be handled by this.
; It is called several times, first time with eax=0
; in: eax = 0 for first call, previously returned value for subsequent calls
; out: eax = 0 => no more items
; eax != 0 => buffer pointed to by edi contains name of item
; here we enumerate existing BIOS disks /bd<N>
biosdisk_enum_root:
cmp eax, [NumBiosDisks]
jae .end
push eax
movzx eax, byte [BiosDisksData+eax*4]
sub al, 80h
push eax
mov al, 'b'
stosb
mov al, 'd'
stosb
pop eax
cmp al, 10
jae .big
add al, '0'
stosb
mov byte [edi], 0
pop eax
inc eax
ret
.end:
xor eax, eax
ret
.big:
push ecx edx
push -'0'
mov ecx, 10
@@:
xor edx, edx
div ecx
push edx
test eax, eax
jnz @b
xchg eax, edx
@@:
pop eax
add al, '0'
stosb
jnz @b
pop edx ecx
pop eax
inc eax
ret
;----------------------------------------------------------------------------- ;-----------------------------------------------------------------------------
process_replace_file_name: process_replace_file_name:
; in ; in

36
kernel/trunk/fs/iso9660.inc
View File

@ -42,26 +42,18 @@ reserve_cd_channel:
cmp [ChannelNumber], 1 cmp [ChannelNumber], 1
jne .IDE_Channel_2 jne .IDE_Channel_2
.IDE_Channel_1: .IDE_Channel_1:
cli pushad
cmp [IDE_Channel_1], 0 mov ecx, ide_channel1_mutex
je .reserve_ok_1 call mutex_lock
sti
call change_task
jmp .IDE_Channel_1
.IDE_Channel_2:
cli
cmp [IDE_Channel_2], 0
je .reserve_ok_2
sti
call change_task
jmp .IDE_Channel_2
.reserve_ok_1:
mov [IDE_Channel_1], 1 mov [IDE_Channel_1], 1
sti popad
ret ret
.reserve_ok_2: .IDE_Channel_2:
pushad
mov ecx, ide_channel2_mutex
call mutex_lock
mov [IDE_Channel_2], 1 mov [IDE_Channel_2], 1
sti popad
ret ret
free_cd_channel: free_cd_channel:
@ -69,11 +61,17 @@ free_cd_channel:
jne .IDE_Channel_2 jne .IDE_Channel_2
.IDE_Channel_1: .IDE_Channel_1:
mov [IDE_Channel_1], 0 mov [IDE_Channel_1], 0
sti pushad
mov ecx, ide_channel1_mutex
call mutex_unlock
popad
ret ret
.IDE_Channel_2: .IDE_Channel_2:
mov [IDE_Channel_2], 0 mov [IDE_Channel_2], 0
sti pushad
mov ecx, ide_channel2_mutex
call mutex_unlock
popad
ret ret
uglobal uglobal

1208
kernel/trunk/fs/ntfs.inc
View File

File diff suppressed because it is too large Load Diff

436
kernel/trunk/fs/part_set.inc
View File

@ -1,436 +0,0 @@
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; ;;
;; Copyright (C) KolibriOS team 2004-2011. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License ;;
;; ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
$Revision$
;*************************************************************
;* 13.02.2010 Find all partition and check supported FS
;* 12.07.2007 Check all 4 entry of MBR and EMBR
;* 29.04.2006 Elimination of hangup after the
;* expiration hd_wait_timeout - Mario79
;* 28.01.2006 find all Fat16/32 partition in all input point
;* to MBR - Mario79
;*************************************************************
uglobal
align 4
;******************************************************
; Please do not change this place - variables in text
; Mario79
; START place
;******************************************************
PARTITION_START dd 0x3f
PARTITION_END dd 0
fs_type db 0 ; 1=NTFS, 2=EXT2/3, 16=FAT16, 32=FAT32
align 4
fs_dependent_data_start:
; FATxx data
.partition dd ?
rb 80
fs_dependent_data_end:
file_system_data_size = $ - PARTITION_START
if file_system_data_size > 96
ERROR:
sizeof(file system data) too big!
end if
virtual at fs_dependent_data_start
; NTFS data
ntfs_data:
.sectors_per_cluster dd ?
.mft_cluster dd ?
.mftmirr_cluster dd ?
.frs_size dd ? ; FRS size in bytes
.iab_size dd ? ; IndexAllocationBuffer size in bytes
.frs_buffer dd ?
.iab_buffer dd ?
.mft_retrieval dd ?
.mft_retrieval_size dd ?
.mft_retrieval_alloc dd ?
.mft_retrieval_end dd ?
.cur_index_size dd ?
.cur_index_buf dd ?
if $ > fs_dependent_data_end
ERROR:
increase sizeof(fs_dependent_data)!
end if
end virtual
virtual at fs_dependent_data_start
; EXT2 data
ext2_data:
.log_block_size dd ?
.block_size dd ?
.count_block_in_block dd ?
.blocks_per_group dd ?
.global_desc_table dd ?
.root_inode dd ? ; pointer to root inode in memory
.inode_size dd ?
.count_pointer_in_block dd ? ; block_size / 4
.count_pointer_in_block_square dd ? ; (block_size / 4)**2
.ext2_save_block dd ? ;RUS: блок на глобальную 1 процедуру ;ENG: block for 1 global procedure
.ext2_temp_block dd ? ;RUS: блок для мелких процедур ;ENG: block for small procedures
.ext2_save_inode dd ? ;RUS: inode на глобальную процедуру ;ENG: inode for global procedure
.ext2_temp_inode dd ? ;RUS: inode для мелких процедур ;ENG: inode for small procedures
.sb dd ? ; superblock
.groups_count dd ?
if $ > fs_dependent_data_end
ERROR:
increase sizeof(fs_dependent_data)!
end if
end virtual
;***************************************************************************
; End place
; Mario79
;***************************************************************************
endg
iglobal
partition_types: ; list of fat16/32 partitions
db 0x04 ; DOS: fat16 <32M
db 0x06 ; DOS: fat16 >32M
db 0x0b ; WIN95: fat32
db 0x0c ; WIN95: fat32, LBA-mapped
db 0x0e ; WIN95: fat16, LBA-mapped
db 0x14 ; Hidden DOS: fat16 <32M
db 0x16 ; Hidden DOS: fat16 >32M
db 0x1b ; Hidden WIN95: fat32
db 0x1c ; Hidden WIN95: fat32, LBA-mapped
db 0x1e ; Hidden WIN95: fat16, LBA-mapped
db 0xc4 ; DRDOS/secured: fat16 <32M
db 0xc6 ; DRDOS/secured: fat16 >32M
db 0xcb ; DRDOS/secured: fat32
db 0xcc ; DRDOS/secured: fat32, LBA-mapped
db 0xce ; DRDOS/secured: fat16, LBA-mapped
db 0xd4 ; Old Multiuser DOS secured: fat16 <32M
db 0xd6 ; Old Multiuser DOS secured: fat16 >32M
db 0x07 ; NTFS
db 0x27 ; NTFS, hidden
db 0x83 ; Linux native file system (ext2fs)
partition_types_end:
extended_types: ; list of extended partitions
db 0x05 ; DOS: extended partition
db 0x0f ; WIN95: extended partition, LBA-mapped
db 0xc5 ; DRDOS/secured: extended partition
db 0xd5 ; Old Multiuser DOS secured: extended partition
extended_types_end:
endg
; Partition chain used:
; MBR <---------------------
; | |
; |-> PARTITION1 |
; |-> EXTENDED PARTITION - ;not need be second partition
; |-> PARTITION3
; |-> PARTITION4
set_PARTITION_variables:
set_FAT32_variables: ;deprecated
and [problem_partition], 0
call reserve_hd1
call reserve_hd_channel
pushad
cmp dword [hdpos], 0
je problem_hd
xor ecx, ecx ; partition count
;or edx,-1 ; flag for partition
xor eax, eax ; address MBR
xor ebp, ebp ; extended partition start
new_mbr:
test ebp, ebp ; is there extended partition? (MBR or EMBR)
jnz extended_already_set; yes
xchg ebp, eax ; no. set it now
extended_already_set:
add eax, ebp ; mbr=mbr+0, ext_part=ext_start+relat_start
mov ebx, buffer
call hd_read
cmp [hd_error], 0
jne problem_hd
cmp word [ebx+0x1fe], 0xaa55; is it valid boot sector?
jnz end_partition_chain
push eax ; push only one time
cmp dword [ebx+0x1be+0xc], 0; skip over empty partition
jnz test_primary_partition_0
cmp dword [ebx+0x1be+0xc+16], 0
jnz test_primary_partition_1
cmp dword [ebx+0x1be+0xc+16+16], 0
jnz test_primary_partition_2
cmp dword [ebx+0x1be+0xc+16+16+16], 0
jnz test_primary_partition_3
pop eax
jmp end_partition_chain
test_primary_partition_0:
mov al, [ebx+0x1be+4]; get primary partition type
call scan_partition_types
jnz test_primary_partition_1; no. skip over
inc ecx
cmp ecx, [known_part]; is it wanted partition?
jnz test_primary_partition_1; no
pop eax
;mov edx, eax ; start sector
add eax, [ebx+0x1be+8] ; add relative start
;mov [PARTITON_START],edx
;push edx
mov edx, [ebx+0x1be+12] ; length
;add edx, eax ; add length
;dec edx ; PARTITION_END is inclusive
;mov [PARTITION_END], edx ; note that this can be changed
; when file system data will be available
mov cl, [ebx+0x1be+4] ; fs_type
;mov [fs_type], dl ; save for FS recognizer (separate FAT vs NTFS)
;pop edx
jmp hd_and_partition_ok
test_primary_partition_1:
mov al, [ebx+0x1be+4+16]; get primary partition type
call scan_partition_types
jnz test_primary_partition_2 ; no. skip over
inc ecx
cmp ecx, [known_part]; is it wanted partition?
jnz test_primary_partition_2 ; no
pop eax
add eax, [ebx+0x1be+8+16]
mov edx, [ebx+0x1be+12+16]
mov cl, [ebx+0x1be+4+16]
jmp hd_and_partition_ok
;mov edx, eax
;add edx, [ebx+0x1be+8+16]
;push edx
;add edx, [ebx+0x1be+12+16]
;dec edx
;mov [PARTITION_END], edx
;mov al, [ebx+0x1be+4+16]
;mov [fs_type], dl
;pop edx
test_primary_partition_2:
mov al, [ebx+0x1be+4+16+16]; get primary partition type
call scan_partition_types
jnz test_primary_partition_3 ; no. skip over
inc ecx
cmp ecx, [known_part]; is it wanted partition?
jnz test_primary_partition_3 ; no
pop eax
add eax, [ebx+0x1be+8+16+16]
mov edx, [ebx+0x1be+12+16+16]
mov cl, [ebx+0x1be+4+16+16]
jmp hd_and_partition_ok
;mov edx, eax
;add edx, [ebx+0x1be+8+16+16]
;push edx
;add edx, [ebx+0x1be+12+16+16]
;dec edx
;mov [PARTITION_END], edx
;mov al, [ebx+0x1be+4+16+16]
;mov [fs_type], dl
;pop edx
test_primary_partition_3:
mov al, [ebx+0x1be+4+16+16+16]; get primary partition type
call scan_partition_types
jnz test_ext_partition_0 ; no. skip over
inc ecx
cmp ecx, [known_part]; is it wanted partition?
jnz test_ext_partition_0; no
pop eax
add eax, [ebx+0x1be+8+16+16+16]
mov edx, [ebx+0x1be+12+16+16+16]
mov cl, [ebx+0x1be+4+16+16+16]
jmp hd_and_partition_ok
;mov edx, eax
;add edx, [ebx+0x1be+8+16+16+16]
;push edx
;add edx, [ebx+0x1be+12+16+16+16]
;dec edx
;mov [PARTITION_END], edx
;mov al, [ebx+0x1be+4+16+16+16]
;mov [fs_type], dl
;pop edx
test_ext_partition_0:
pop eax ; просто выкидываем из стека
mov al, [ebx+0x1be+4]; get extended partition type
call scan_extended_types
jnz test_ext_partition_1
mov eax, [ebx+0x1be+8]; add relative start
test eax, eax ; is there extended partition?
jnz new_mbr ; yes. read it
test_ext_partition_1:
mov al, [ebx+0x1be+4+16]; get extended partition type
call scan_extended_types
jnz test_ext_partition_2
mov eax, [ebx+0x1be+8+16]; add relative start
test eax, eax ; is there extended partition?
jnz new_mbr ; yes. read it
test_ext_partition_2:
mov al, [ebx+0x1be+4+16+16]; get extended partition type
call scan_extended_types
jnz test_ext_partition_3
mov eax, [ebx+0x1be+8+16+16]; add relative start
test eax, eax ; is there extended partition?
jnz new_mbr ; yes. read it
test_ext_partition_3:
mov al, [ebx+0x1be+4+16+16+16]; get extended partition type
call scan_extended_types
jnz end_partition_chain; no. end chain
mov eax, [ebx+0x1be+8+16+16+16]; get start of extended partition
test eax, eax ; is there extended partition?
jnz new_mbr ; yes. read it
end_partition_chain:
;mov [partition_count],ecx
;cmp edx,-1 ; found wanted partition?
;jnz hd_and_partition_ok ; yes. install it
;jmp problem_partition_or_fat
problem_hd:
or [problem_partition], 2
jmp return_from_part_set
scan_partition_types:
push ecx
mov edi, partition_types
mov ecx, partition_types_end-partition_types
cld
repne scasb ; is partition type ok?
pop ecx
ret
scan_extended_types:
push ecx
mov edi, extended_types
mov ecx, extended_types_end-extended_types
cld
repne scasb ; is it extended partition?
pop ecx
ret
problem_fat_dec_count: ; bootsector is missing or another problem
; dec [partition_count] ; remove it from partition_count
problem_partition_or_fat:
or [problem_partition], 1
return_from_part_set:
popad
;mov [fs_type],0
call free_hd_channel
mov [hd1_status], 0 ; free
ret
hd_and_partition_ok:
;eax = PARTITION_START edx=PARTITION_LENGTH cl=fs_type
mov [fs_type], cl
;mov eax,edx
mov [PARTITION_START], eax
add edx, eax
dec edx
mov [PARTITION_END], edx
; mov edx, [PARTITION_END]
; sub edx, eax
; inc edx ; edx = length of partition зачем оно нам??
; mov [hd_setup],1
mov ebx, buffer
call hd_read ; read boot sector of partition
cmp [hd_error], 0
jz boot_read_ok
cmp [fs_type], 7
jnz problem_fat_dec_count
; NTFS duplicates bootsector:
; NT4/2k/XP+ saves bootsector copy in the end of disk
; NT 3.51 saves bootsector copy in the middle of disk
and [hd_error], 0
mov eax, [PARTITION_END]
call hd_read
cmp [hd_error], 0
jnz @f
call ntfs_test_bootsec
jnc boot_read_ok
@@:
and [hd_error], 0
mov eax, edx
shr eax, 1
add eax, [PARTITION_START]
call hd_read
cmp [hd_error], 0
jnz problem_fat_dec_count ; no chance...
boot_read_ok:
; if we are running on NTFS, check bootsector
call ntfs_test_bootsec ; test ntfs
jnc ntfs_setup
call ext2_test_superblock ; test ext2fs
jnc ext2_setup
mov eax, [PARTITION_START] ;ext2 test changes [buffer]
call hd_read
cmp [hd_error], 0
jnz problem_fat_dec_count
push 0
mov eax, [PARTITION_END]
sub eax, [PARTITION_START]
inc eax
push eax
push 0
push [PARTITION_START]
push ebp
push ebp
mov ebp, esp
mov esi, 'old' ; special value: there is no DISK structure
push 1 ; bootsector read successfully
call fat_create_partition
add esp, 4*7
test eax, eax
jz problem_fat_dec_count
mov [fs_dependent_data_start.partition], eax
mov al, [eax+FAT.fs_type]
mov [fs_type], al
popad
call free_hd_channel
mov [hd1_status], 0 ; free
ret

74
kernel/trunk/kernel.asm
View File

@ -1,6 +1,6 @@
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; ;;
;; Copyright (C) KolibriOS team 2004-2012. All rights reserved. ;; Copyright (C) KolibriOS team 2004-2013. All rights reserved.
;; PROGRAMMING: ;; PROGRAMMING:
;; Ivan Poddubny ;; Ivan Poddubny
;; Marat Zakiyanov (Mario79) ;; Marat Zakiyanov (Mario79)
@ -356,6 +356,13 @@ high_code:
mov ecx, application_table_mutex mov ecx, application_table_mutex
call mutex_init call mutex_init
mov ecx, ide_mutex
call mutex_init
mov ecx, ide_channel1_mutex
call mutex_init
mov ecx, ide_channel2_mutex
call mutex_init
; SAVE REAL MODE VARIABLES ; SAVE REAL MODE VARIABLES
xor eax, eax xor eax, eax
mov ax, [BOOT_VARS + BOOT_IDE_PI_16] mov ax, [BOOT_VARS + BOOT_IDE_PI_16]
@ -1656,76 +1663,17 @@ endg
ret ret
nsyse5: nsyse5:
sub ebx, 2 ; HD BASE sub ebx, 2 ; HD BASE - obsolete
jnz nsyse7 jnz nsyse7
test ecx, ecx
jz nosethd
cmp ecx, 4
ja nosethd
mov [hd_base], cl
cmp ecx, 1
jnz noprmahd
mov eax, [hd_address_table]
mov [hdbase], eax ;0x1f0
and dword [hdid], 0x0
mov dword [hdpos], ecx
; call set_FAT32_variables
noprmahd:
cmp ecx, 2
jnz noprslhd
mov eax, [hd_address_table]
mov [hdbase], eax ;0x1f0
mov [hdid], 0x10
mov dword [hdpos], ecx
; call set_FAT32_variables
noprslhd:
cmp ecx, 3
jnz nosemahd
mov eax, [hd_address_table+16]
mov [hdbase], eax ;0x170
and dword [hdid], 0x0
mov dword [hdpos], ecx
; call set_FAT32_variables
nosemahd:
cmp ecx, 4
jnz noseslhd
mov eax, [hd_address_table+16]
mov [hdbase], eax ;0x170
mov [hdid], 0x10
mov dword [hdpos], ecx
; call set_FAT32_variables
noseslhd:
call reserve_hd1
call reserve_hd_channel
call free_hd_channel
and dword [hd1_status], 0 ; free
nosethd: nosethd:
ret ret
iglobal
hd_base db 0
endg
nsyse7: nsyse7:
; cmp eax,8 ; HD PARTITION ; cmp eax,8 ; HD PARTITION - obsolete
dec ebx dec ebx
jnz nsyse8 jnz nsyse8
mov [fat32part], ecx
; call set_FAT32_variables
call reserve_hd1
call reserve_hd_channel
call free_hd_channel
; pusha
call choice_necessity_partition_1
; popa
and dword [hd1_status], 0 ; free
ret ret
nsyse8: nsyse8:
@ -1826,7 +1774,7 @@ ngsyse5:
; cmp eax,7 ; cmp eax,7
sub ebx, 2 sub ebx, 2
jnz ngsyse7 jnz ngsyse7
movzx eax, [hd_base] xor eax, eax
mov [esp+32], eax mov [esp+32], eax
ret ret
ngsyse7: ngsyse7: