WebSVN – Kolibri OS – Diff – /kernel/trunk/blkdev/disk_cache.inc


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                              ;;
;; Copyright (C) KolibriOS team 2011-2014. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License    ;;
;;                                                              ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
$Revision: 5095 $
 
; Read/write functions try to do large operations,
; it is significantly faster than several small operations.
; This requires large buffers.
; We can't use input/output buffers directly - they can be controlled
; by user-mode application, so they can be modified between the operation
; and copying to/from cache, giving invalid data in cache.
; It is unclear how to use cache directly, currently cache items are
; allocated/freed sector-wise, so items for sequential sectors can be
; scattered over all the cache.
; So read/write functions allocate a temporary buffer which is
; 1) not greater than half of free memory and
; 2) not greater than the following constant.
CACHE_MAX_ALLOC_SIZE = 4 shl 20
 
; Legacy interface for filesystems fs_{read,write}32_{sys,app}
; gives only one sector for FS. However, per-sector reading is inefficient,
; so internally fs_read32_{sys,app} reads to the cache several sequential
; sectors, hoping that they will be useful.
; Total number of sectors is given by the following constant.
CACHE_LEGACY_READ_SIZE = 16
 
; This structure describes one item in the cache.
struct CACHE_ITEM
SectorLo        dd      ?       ; low 32 bits of sector
SectorHi        dd      ?       ; high 32 bits of sector
Status          dd      ?       ; one of CACHE_ITEM_*
ends
 
; Possible values for CACHE_ITEM_*
CACHE_ITEM_EMPTY = 0
CACHE_ITEM_COPY = 1
CACHE_ITEM_MODIFIED = 2
 
; Read several sequential sectors using cache #1.
; in: edx:eax = start sector, relative to start of partition
; in: ecx = number of sectors to read
; in: ebx -> buffer
; in: ebp -> PARTITION
; out: eax = error code, 0 = ok
; out: ecx = number of sectors that were read
fs_read64_sys:
; Save ebx, set ebx to SysCache and let the common part do its work.
        push    ebx ebx
        mov     ebx, [ebp+PARTITION.Disk]
        add     ebx, DISK.SysCache
        jmp     fs_read64_common
 
; Read several sequential sectors using cache #2.
; in: edx:eax = start sector, relative to start of partition
; in: ecx = number of sectors to read
; in: edi -> buffer
; in: ebp -> PARTITION
; out: eax = error code, 0 = ok
; out: ecx = number of sectors that were read
fs_read64_app:
; Save ebx, set ebx to AppCache and let the common part do its work.
        push    ebx ebx
        mov     ebx, [ebp+PARTITION.Disk]
        add     ebx, DISK.AppCache
 
; Common part of fs_read64_{app,sys}:
; read several sequential sectors using the given cache.
fs_read64_common:
; 1. Setup stack frame.
        push    esi edi         ; save used registers to be stdcall
        push    0               ; initialize .error_code
        push    ebx edx eax ecx ecx     ; initialize stack variables
virtual at esp
.local_vars:
.num_sectors_orig dd    ?
; Number of sectors that should be read. Used to generate output value of ecx.
.num_sectors    dd      ?
; Number of sectors that remain to be read. Decreases from .num_sectors_orig to 0.
.sector_lo      dd      ?       ; low 32 bits of the current sector
.sector_hi      dd      ?       ; high 32 bits of the current sector
.cache          dd      ?       ; pointer to DISKCACHE
.error_code     dd      ?       ; current status
.local_vars_size = $ - .local_vars
.saved_regs     rd      2
.buffer         dd      ?       ; filled by fs_read64_{sys,app}
end virtual
; 2. Validate parameters against partition length:
; immediately return error if edx:eax are beyond partition end,
; decrease .num_sectors and .num_sectors_orig, if needed,
; so that the entire operation fits in the partition limits.
        mov     eax, dword [ebp+PARTITION.Length]
        mov     edx, dword [ebp+PARTITION.Length+4]
        sub     eax, [.sector_lo]
        sbb     edx, [.sector_hi]
        jb      .end_of_media
        jnz     .no_end_of_media
        cmp     ecx, eax
        jbe     .no_end_of_media
; If .num_sectors got decreased, set status to DISK_STATUS_END_OF_MEDIA;
; if all subsequent operations would be successful, this would become the final
; status, otherwise this would be rewritten by failed operation.
        mov     [.num_sectors], eax
        mov     [.num_sectors_orig], eax
        mov     [.error_code], DISK_STATUS_END_OF_MEDIA
.no_end_of_media:
; 3. If number of sectors to read is zero, either because zero-sectors operation
; was requested or because it got decreased to zero due to partition limits,
; just return the current status.
        cmp     [.num_sectors], 0
        jz      .return
; 4. Shift sector from partition-relative to absolute.
        mov     eax, dword [ebp+PARTITION.FirstSector]
        mov     edx, dword [ebp+PARTITION.FirstSector+4]
        add     [.sector_lo], eax
        adc     [.sector_hi], edx
; 5. If the cache is disabled, pass the request directly to the driver.
        cmp     [ebx+DISKCACHE.pointer], 0
        jz      .nocache
; 6. Look for sectors in the cache, sequentially from the beginning.
; Stop at the first sector that is not in the cache
; or when all sectors were read from the cache.
; 6a. Acquire the lock.
        mov     ecx, [ebp+PARTITION.Disk]
        add     ecx, DISK.CacheLock
        call    mutex_lock
.lookup_in_cache_loop:
; 6b. For each sector, call the lookup function without adding to the cache.
        mov     eax, [.sector_lo]
        mov     edx, [.sector_hi]
        call    cache_lookup_read
; 6c. If it has failed, the sector is not in cache;
; release the lock and go to 7.
        jc      .not_found_in_cache
; The sector is found in cache.
; 6d. Copy data for the caller, advance [.buffer].
        mov     esi, edi
        mov     edi, [.buffer]
        mov     eax, 1
        shl     eax, cl
        mov     ecx, eax
        shr     ecx, 2
        rep movsd
        mov     [.buffer], edi
; 6e. Advance the sector.
        add     [.sector_lo], 1
        adc     [.sector_hi], 0
; 6f. Decrement number of sectors left.
; If all sectors were read, release the lock and return.
        dec     [.num_sectors]
        jnz     .lookup_in_cache_loop
; Release the lock acquired at 6a.
        mov     ecx, [ebp+PARTITION.Disk]
        add     ecx, DISK.CacheLock
        call    mutex_unlock
.return:
        mov     eax, [.error_code]
        mov     ecx, [.num_sectors_orig]
        sub     ecx, [.num_sectors]
.nothing:
        add     esp, .local_vars_size
        pop     edi esi ebx ebx    ; restore used registers to be stdcall
        ret
.not_found_in_cache:
; Release the lock acquired at 6a.
        mov     ecx, [ebp+PARTITION.Disk]
        add     ecx, DISK.CacheLock
        call    mutex_unlock
; The current sector is not present in the cache.
; Ask the driver to read all requested not-yet-read sectors,
; put results in the cache.
; Also, see the comment before the definition of CACHE_MAX_ALLOC_SIZE.
; 7. Allocate buffer for operations.
; Normally, create buffer that is sufficient for all remaining data.
; However, for extra-large requests make an upper limit:
; do not use more than half of the free memory
; or more than CACHE_MAX_ALLOC_SIZE bytes.
        mov     ecx, [ebx+DISKCACHE.sector_size_log]
        mov     ebx, [pg_data.pages_free]
        shr     ebx, 1
        jz      .nomemory
        cmp     ebx, CACHE_MAX_ALLOC_SIZE shr 12
        jbe     @f
        mov     ebx, CACHE_MAX_ALLOC_SIZE shr 12
@@:
        shl     ebx, 12
        shr     ebx, cl
        jz      .nomemory
        cmp     ebx, [.num_sectors]
        jbe     @f
        mov     ebx, [.num_sectors]
@@:
        mov     eax, ebx
        shl     eax, cl
        stdcall kernel_alloc, eax
; If failed, return the appropriate error code.
        test    eax, eax
        jz      .nomemory
        mov     esi, eax
; Split the request to chunks that fit in the allocated buffer.
.read_loop:
; 8. Get iteration size: either size of allocated buffer in sectors
; or number of sectors left, select what is smaller.
        cmp     ebx, [.num_sectors]
        jbe     @f
        mov     ebx, [.num_sectors]
@@:
; 9. Create second portion of local variables.
; Note that variables here and above are esp-relative;
; it means that all addresses should be corrected when esp is changing.
        push    ebx esi esi
        push    ebx
; In particular, num_sectors is now [.num_sectors+.local_vars2_size].
virtual at esp
.local_vars2:
.current_num_sectors    dd      ?       ; number of sectors that were read
.current_buffer         dd      ?
; pointer inside .allocated_buffer that points
; to the beginning of not-processed data
.allocated_buffer       dd      ?       ; saved in safe place
.iteration_size         dd      ?       ; saved in safe place
.local_vars2_size = $ - .local_vars2
end virtual
; 10. Call the driver, reading the next chunk.
        push    esp     ; numsectors
        push    [.sector_hi+.local_vars2_size+4] ; startsector
        push    [.sector_lo+.local_vars2_size+8] ; startsector
        push    esi     ; buffer
        mov     esi, [ebp+PARTITION.Disk]
        mov     al, DISKFUNC.read
        call    disk_call_driver
; If failed, save error code.
        test    eax, eax
        jz      @f
        mov     [.error_code+.local_vars2_size], eax
@@:
; 11. Copy data for the caller, advance .buffer.
        cmp     [.current_num_sectors], 0
        jz      .copy_done
        mov     ebx, [.cache+.local_vars2_size]
        mov     eax, [.current_num_sectors]
        mov     ecx, [ebx+DISKCACHE.sector_size_log]
        shl     eax, cl
        mov     esi, [.allocated_buffer]
        mov     edi, [.buffer+.local_vars2_size]
        mov     ecx, eax
        shr     ecx, 2
        rep movsd
        mov     [.buffer+.local_vars2_size], edi
; 12. Copy data to the cache.
; 12a. Acquire the lock.
        mov     ecx, [ebp+PARTITION.Disk]
        add     ecx, DISK.CacheLock
        call    mutex_lock
; 12b. Prepare for the loop: create a local variable that
; stores number of sectors to be copied.
        push    [.current_num_sectors]
.store_to_cache:
; 12c. For each sector, call the lookup function with adding to the cache, if not yet.
        mov     eax, [.sector_lo+.local_vars2_size+4]
        mov     edx, [.sector_hi+.local_vars2_size+4]
        call    cache_lookup_write
        test    eax, eax
        jnz     .cache_error
; 12d. If the sector was already present in the cache as modified,
; data that were read at step 10 for this sector are obsolete,
; so rewrite data for the caller from the cache.
        cmp     [esi+CACHE_ITEM.Status], CACHE_ITEM_MODIFIED
        jnz     .not_modified
        mov     esi, edi
        mov     edi, [.buffer+.local_vars2_size+4]
        mov     eax, [esp]
        shl     eax, cl
        sub     edi, eax
        mov     eax, 1
        shl     eax, cl
        mov     ecx, eax
        shr     ecx, 2
        rep movsd
        add     [.current_buffer+4], eax
        jmp     .sector_done
.not_modified:
; 12e. For each not-modified sector,
; copy data, mark the item as not-modified copy of the disk,
; advance .current_buffer and .sector_hi:.sector_lo to the next sector.
        mov     [esi+CACHE_ITEM.Status], CACHE_ITEM_COPY
        mov     eax, 1
        shl     eax, cl
        mov     esi, [.current_buffer+4]
        mov     ecx, eax
        shr     ecx, 2
        rep movsd
        mov     [.current_buffer+4], esi
.sector_done:
        add     [.sector_lo+.local_vars2_size+4], 1
        adc     [.sector_hi+.local_vars2_size+4], 0
; 12f. Continue the loop 12c-12e until all sectors are read.
        dec     dword [esp]
        jnz     .store_to_cache
.cache_error:
; 12g. Restore after the loop: pop the local variable.
        pop     ecx
; 12h. Release the lock.
        mov     ecx, [ebp+PARTITION.Disk]
        add     ecx, DISK.CacheLock
        call    mutex_unlock
.copy_done:
; 13. Remove portion of local variables created at step 9.
        pop     ecx
        pop     esi esi ebx
; 14. Continue iterations while number of sectors read by the driver
; is equal to number of sectors requested and there are additional sectors.
        cmp     ecx, ebx
        jnz     @f
        sub     [.num_sectors], ebx
        jnz     .read_loop
@@:
; 15. Free the buffer allocated at step 7 and return.
        stdcall kernel_free, esi
        jmp     .return
 
; Special branches:
.nomemory:
; memory allocation failed at step 7: return the corresponding error
        mov     [.error_code], DISK_STATUS_NO_MEMORY
        jmp     .return
.nocache:
; step 5, after correcting number of sectors to fit in partition limits
; and advancing partition-relative sector to absolute,
; sees that cache is disabled: pass corrected request to the driver
        lea     eax, [.num_sectors]
        push    eax             ; numsectors
        push    [.sector_hi+4]  ; startsector
        push    [.sector_lo+8]  ; startsector
        push    [.buffer+12]    ; buffer
        mov     esi, [ebp+PARTITION.Disk]
        mov     al, DISKFUNC.read
        call    disk_call_driver
        test    eax, eax
        jnz     @f
        mov     eax, [.error_code]
@@:
        mov     ecx, [.num_sectors]
        jmp     .nothing
.end_of_media:
; requested sector is beyond the partition end: return the corresponding error
        mov     [.error_code], DISK_STATUS_END_OF_MEDIA
        jmp     .return
 
; Write several sequential sectors using cache #1.
; in: edx:eax = start sector
; in: ecx = number of sectors to write
; in: ebx -> buffer
; in: ebp -> PARTITION
; out: eax = error code, 0 = ok
; out: ecx = number of sectors that were written
fs_write64_sys:
; Save ebx, set ebx to SysCache and let the common part do its work.
        push    ebx
        mov     ebx, [ebp+PARTITION.Disk]
        add     ebx, DISK.SysCache
        jmp     fs_write64_common
 
; Write several sequential sectors using cache #2.
; in: edx:eax = start sector
; in: ecx = number of sectors to write
; in: ebx -> buffer
; in: ebp -> PARTITION
; out: eax = error code, 0 = ok
; out: ecx = number of sectors that were written
fs_write64_app:
; Save ebx, set ebx to AppCache and let the common part do its work.
        push    ebx
        mov     ebx, [ebp+PARTITION.Disk]
        add     ebx, DISK.AppCache
 
; Common part of fs_write64_{app,sys}:
; write several sequential sectors using the given cache.
fs_write64_common:
; 1. Setup stack frame.
        push    esi edi         ; save used registers to be stdcall
        push    0               ; initialize .error_code
        push    edx eax ecx ecx ; initialize stack variables
        push    [.buffer-4]     ; copy [.buffer] to [.cur_buffer]
                                ; -4 is due to esp-relative addressing
virtual at esp
.local_vars:
.cur_buffer     dd      ?       ; pointer to data that are currently copying
.num_sectors_orig dd    ?
; Number of sectors that should be written. Used to generate output value of ecx.
.num_sectors    dd      ?
; Number of sectors that remain to be written.
.sector_lo      dd      ?       ; low 32 bits of the current sector
.sector_hi      dd      ?       ; high 32 bits of the current sector
.error_code     dd      ?       ; current status
.local_vars_size = $ - .local_vars
.saved_regs     rd      2
.buffer         dd      ?       ; filled by fs_write64_{sys,app}
end virtual
; 2. Validate parameters against partition length:
; immediately return error if edx:eax are beyond partition end,
; decrease .num_sectors and .num_sectors_orig, if needed,
; so that the entire operation fits in the partition limits.
        mov     eax, dword [ebp+PARTITION.Length]
        mov     edx, dword [ebp+PARTITION.Length+4]
        sub     eax, [.sector_lo]
        sbb     edx, [.sector_hi]
        jb      .end_of_media
        jnz     .no_end_of_media
        cmp     ecx, eax
        jbe     .no_end_of_media
; If .num_sectors got decreased, set status to DISK_STATUS_END_OF_MEDIA;
; if all subsequent operations would be successful, this would become the final
; status, otherwise this would be rewritten by failed operation.
        mov     [.num_sectors], eax
        mov     [.num_sectors_orig], eax
        mov     [.error_code], DISK_STATUS_END_OF_MEDIA
.no_end_of_media:
; 3. If number of sectors to write is zero, either because zero-sectors operation
; was requested or because it got decreased to zero due to partition limits,
; just return the current status.
        cmp     [.num_sectors], 0
        jz      .return
; 4. Shift sector from partition-relative to absolute.
        mov     eax, dword [ebp+PARTITION.FirstSector]
        mov     edx, dword [ebp+PARTITION.FirstSector+4]
        add     [.sector_lo], eax
        adc     [.sector_hi], edx
; 5. If the cache is disabled, pass the request directly to the driver.
        cmp     [ebx+DISKCACHE.pointer], 0
        jz      .nocache
; 6. Store sectors in the cache, sequentially from the beginning.
; 6a. Acquire the lock.
        mov     ecx, [ebp+PARTITION.Disk]
        add     ecx, DISK.CacheLock
        call    mutex_lock
.lookup_in_cache_loop:
; 6b. For each sector, call the lookup function with adding to the cache, if not yet.
        mov     eax, [.sector_lo]
        mov     edx, [.sector_hi]
        call    cache_lookup_write
        test    eax, eax
        jnz     .cache_error
; 6c. For each sector, copy data, mark the item as modified and not saved,
; advance .current_buffer to the next sector.
        mov     [esi+CACHE_ITEM.Status], CACHE_ITEM_MODIFIED
        mov     eax, 1
        shl     eax, cl
        mov     esi, [.cur_buffer]
        mov     ecx, eax
        shr     ecx, 2
        rep movsd
        mov     [.cur_buffer], esi
; 6d. Remove the sector from the other cache.
; Normally it should not be there, but prefetching could put to the app cache
; data that normally should belong to the sys cache and vice versa.
; Note: this requires that both caches must be protected by the same lock.
        mov     eax, [.sector_lo]
        mov     edx, [.sector_hi]
        push    ebx
        sub     ebx, [ebp+PARTITION.Disk]
        xor     ebx, DISK.SysCache xor DISK.AppCache
        add     ebx, [ebp+PARTITION.Disk]
        call    cache_lookup_read
        jc      @f
        mov     [esi+CACHE_ITEM.Status], CACHE_ITEM_EMPTY
@@:
        pop     ebx
; 6e. Advance .sector_hi:.sector_lo to the next sector.
        add     [.sector_lo], 1
        adc     [.sector_hi], 0
; 6f. Continue the loop at 6b-6e until all sectors are processed.
        dec     [.num_sectors]
        jnz     .lookup_in_cache_loop
.unlock_return:
; 6g. Release the lock and return.
        mov     ecx, [ebp+PARTITION.Disk]
        add     ecx, DISK.CacheLock
        call    mutex_unlock
.return:
        mov     eax, [.error_code]
        mov     ecx, [.num_sectors_orig]
        sub     ecx, [.num_sectors]
.nothing:
        add     esp, .local_vars_size
        pop     edi esi ebx
        ret
 
; Special branches:
.cache_error:
; error at flushing the cache while adding sector to the cache:
; return the error from the lookup function
        mov     [.error_code], eax
        jmp     .unlock_return
.end_of_media:
; requested sector is beyond the partition end: return the corresponding error
        mov     eax, DISK_STATUS_END_OF_MEDIA
        xor     ecx, ecx
        jmp     .nothing
.nocache:
; step 5, after correcting number of sectors to fit in partition limits
; and advancing partition-relative sector to absolute,
; sees that cache is disabled: pass corrected request to the driver
        lea     eax, [.num_sectors]
        push    eax             ; numsectors
        push    [.sector_hi+4]  ; startsector
        push    [.sector_lo+8]  ; startsector
        push    [.buffer+12]    ; buffer
        mov     esi, [ebp+PARTITION.Disk]
        mov     al, DISKFUNC.write
        call    disk_call_driver
        mov     ecx, [.num_sectors]
        jmp     .nothing
 
; Legacy. Use fs_read64_sys instead.
; This function is intended to replace the old 'hd_read' function when
; [hdd_appl_data] = 0, so its input/output parameters are the same, except
; that it can't use the global variables 'hd_error' and 'hdd_appl_data'.
; in: eax = sector, ebx = buffer, ebp = pointer to PARTITION structure
; eax is relative to partition start
; out: eax = error code; 0 = ok
fs_read32_sys:
; Save ebx, set ebx to SysCache and let the common part do its work.
        push    ebx
        mov     ebx, [ebp+PARTITION.Disk]
        add     ebx, DISK.SysCache
        jmp     fs_read32_common
 
; Legacy. Use fs_read64_app instead.
; This function is intended to replace the old 'hd_read' function when
; [hdd_appl_data] = 1, so its input/output parameters are the same, except
; that it can't use the global variables 'hd_error' and 'hdd_appl_data'.
; in: eax = sector, ebx = buffer, ebp = pointer to PARTITION structure
; eax is relative to partition start
; out: eax = error code; 0 = ok
fs_read32_app:
; Save ebx, set ebx to AppCache and let the common part do its work.
        push    ebx
        mov     ebx, [ebp+PARTITION.Disk]
        add     ebx, DISK.AppCache
 
; This label is the common part of fs_read32_sys and fs_read32_app.
fs_read32_common:
; 1. Check that the required sector is inside the partition. If no, return
; DISK_STATUS_END_OF_MEDIA.
        cmp     dword [ebp+PARTITION.Length+4], 0
        jnz     @f
        cmp     dword [ebp+PARTITION.Length], eax
        ja      @f
        mov     eax, DISK_STATUS_END_OF_MEDIA
        pop     ebx
        ret
@@:
; 2. Get the absolute sector on the disk.
        push    ecx edx esi edi
        xor     edx, edx
        add     eax, dword [ebp+PARTITION.FirstSector]
        adc     edx, dword [ebp+PARTITION.FirstSector+4]
; 3. If there is no cache for this disk, just pass the request to the driver.
        cmp     [ebx+DISKCACHE.pointer], 0
        jnz     .scancache
        push    1
        push    esp     ; numsectors
        push    edx     ; startsector
        push    eax     ; startsector
        pushd   [esp+32]; buffer
        mov     esi, [ebp+PARTITION.Disk]
        mov     al, DISKFUNC.read
        call    disk_call_driver
        pop     ecx
        pop     edi esi edx ecx
        pop     ebx
        ret
.scancache:
        push    ebx edx eax
virtual at esp
.local_vars:
.sector_lo      dd      ?
.sector_hi      dd      ?
.cache          dd      ?
.local_vars_size = $ - .local_vars
.saved_regs     rd      4
.buffer         dd      ?
end virtual
; 4. Scan for the requested sector in the cache.
; If found, copy the data and return.
; 4a. Acquire the lock.
        mov     ecx, [ebp+PARTITION.Disk]
        add     ecx, DISK.CacheLock
        call    mutex_lock
; 4b. Call the lookup function without adding to the cache.
        mov     eax, [.sector_lo]
        mov     edx, [.sector_hi]
        call    cache_lookup_read
; If not found, go to 5.
        jc      .not_found_in_cache
.found_in_cache:
; 4c. Copy the data.
        mov     esi, edi
        mov     edi, [.buffer]
        mov     eax, 1
        shl     eax, cl
        mov     ecx, eax
        shr     ecx, 2
        rep movsd
; 4d. Release the lock and return success.
        mov     ecx, [ebp+PARTITION.Disk]
        add     ecx, DISK.CacheLock
        call    mutex_unlock
.return:
        xor     eax, eax
.return_eax:
        add     esp, .local_vars_size
        pop     edi esi edx ecx
        pop     ebx
        ret
.not_found_in_cache:
; 5. Decide whether we need to prefetch further sectors.
; If so, advance to 6. If not, go to 13.
; Assume that devices < 3MB are floppies which are slow
; (ramdisk does not have a cache, so we don't even get here for ramdisk).
; This is a dirty hack, but the entire function is somewhat hacky. Use fs_read64*.
        mov     eax, [ebp+PARTITION.Disk]
        cmp     dword [eax+DISK.MediaInfo.Capacity+4], 0
        jnz     @f
        cmp     dword [eax+DISK.MediaInfo.Capacity], 3 shl (20-9)
        jb      .floppy
@@:
; We want to prefetch CACHE_LEGACY_READ_SIZE sectors.
; 6. Release the lock acquired at step 4a.
        mov     ecx, [ebp+PARTITION.Disk]
        add     ecx, DISK.CacheLock
        call    mutex_unlock
; 7. Allocate buffer for CACHE_LEGACY_READ_SIZE sectors.
        mov     eax, CACHE_LEGACY_READ_SIZE
        mov     ecx, [ebx+DISKCACHE.sector_size_log]
        shl     eax, cl
        stdcall kernel_alloc, eax
; If failed, return the corresponding error code.
        test    eax, eax
        jz      .nomemory
; 8. Create second portion of local variables.
        push    eax eax
        push    CACHE_LEGACY_READ_SIZE
virtual at esp
.local_vars2:
.num_sectors            dd      ?       ; number of sectors left
.current_buffer         dd      ?       ; pointer to data that are currently copying
.allocated_buffer       dd      ?       ; saved at safe place
.local_vars2_size = $ - .local_vars2
end virtual
; 9. Call the driver to read CACHE_LEGACY_READ_SIZE sectors.
        push    esp     ; numsectors
        push    [.sector_hi+.local_vars2_size+4]        ; startsector
        push    [.sector_lo+.local_vars2_size+8]        ; startsector
        push    eax     ; buffer
        mov     esi, [ebp+PARTITION.Disk]
        mov     al, DISKFUNC.read
        call    disk_call_driver
; Note: we're ok if at least one sector is read,
; read error somewhere after that just limits data to be put in cache.
        cmp     [.num_sectors], 0
        jz      .read_error
; 10. Copy data for the caller.
        mov     esi, [.allocated_buffer]
        mov     edi, [.buffer+.local_vars2_size]
        mov     ecx, [ebx+DISKCACHE.sector_size_log]
        mov     eax, 1
        shl     eax, cl
        mov     ecx, eax
        shr     ecx, 2
        rep movsd
; 11. Store all sectors that were successfully read to the cache.
; 11a. Acquire the lock.
        mov     ecx, [ebp+PARTITION.Disk]
        add     ecx, DISK.CacheLock
        call    mutex_lock
.store_to_cache:
; 11b. For each sector, call the lookup function with adding to the cache, if not yet.
        mov     eax, [.sector_lo+.local_vars2_size]
        mov     edx, [.sector_hi+.local_vars2_size]
        call    cache_lookup_write
        test    eax, eax
        jnz     .cache_error
; 11c. Ignore sectors marked as modified: for them the cache is more recent that disk data.
        mov     eax, 1
        shl     eax, cl
        cmp     [esi+CACHE_ITEM.Status], CACHE_ITEM_MODIFIED
        jnz     .not_modified
        add     [.current_buffer], eax
        jmp     .sector_done
.not_modified:
; 11d. For each sector, copy data, mark the item as not-modified copy of the disk,
; advance .current_buffer and .sector_hi:.sector_lo to the next sector.
        mov     [esi+CACHE_ITEM.Status], CACHE_ITEM_COPY
        mov     esi, [.current_buffer]
        mov     ecx, eax
        shr     ecx, 2
        rep movsd
        mov     [.current_buffer], esi
.sector_done:
        add     [.sector_lo+.local_vars2_size], 1
        adc     [.sector_hi+.local_vars2_size], 0
; 11e. Continue the loop at 11b-11d until all sectors are processed.
        dec     [.num_sectors]
        jnz     .store_to_cache
.cache_error:
; 11f. Release the lock.
        mov     ecx, [ebp+PARTITION.Disk]
        add     ecx, DISK.CacheLock
        call    mutex_unlock
.copy_done:
; 12. Remove portion of local variables created at step 8,
; free the buffer allocated at step 7 and return.
        pop     ecx ecx
        stdcall kernel_free
        jmp     .return
.read_error:
; If no sectors were read, free the buffer allocated at step 7
; and pass the error to the caller.
        push    eax
        stdcall kernel_free, [.allocated_buffer+4]
        pop     eax
        add     esp, .local_vars2_size
        jmp     .return_eax
.nomemory:
        mov     eax, DISK_STATUS_NO_MEMORY
        jmp     .return_eax
.floppy:
; We don't want to prefetch anything, just read one sector.
; We are still holding the lock acquired at step 4a.
; 13. Call the lookup function adding sector to the cache.
        call    cache_lookup_write
        test    eax, eax
        jnz     .floppy_cache_error
        push    esi
 
; 14. Call the driver to read one sector.
        push    1
        push    esp
        push    edx
        push    [.sector_lo+16]
        push    edi
        mov     esi, [ebp+PARTITION.Disk]
        mov     al, DISKFUNC.read
        call    disk_call_driver
        pop     ecx
        dec     ecx
        jnz     .floppy_read_error
; 15. Get the slot and pointer to the cache item,
; change the status to not-modified copy of the disk
; and go to 4c.
        pop     esi
        mov     [esi+CACHE_ITEM.Status], CACHE_ITEM_COPY
        jmp     .found_in_cache
 
; On error at steps 13-14, release the lock
; and pass the error to the caller.
.floppy_read_error:
        pop     ecx
.floppy_cache_error:
        mov     ecx, [ebp+PARTITION.Disk]
        add     ecx, DISK.CacheLock
        push    eax
        call    mutex_unlock
        pop     eax
        jmp     .return_eax
 
; This function is intended to replace the old 'hd_write' function when
; [hdd_appl_data] = 0, so its input/output parameters are the same, except
; that it can't use the global variables 'hd_error' and 'hdd_appl_data'.
; in: eax = sector, ebx = buffer, ebp = pointer to PARTITION structure
; eax is relative to partition start
; out: eax = error code; 0 = ok
fs_write32_sys:
; Just call the advanced function.
        push    ecx edx
        xor     edx, edx
        mov     ecx, 1
        call    fs_write64_sys
        pop     edx ecx
        ret
 
; This function is intended to replace the old 'hd_write' function when
; [hdd_appl_data] = 1, so its input/output parameters are the same, except
; that it can't use the global variables 'hd_error' and 'hdd_appl_data'.
; in: eax = sector, ebx = buffer, ebp = pointer to PARTITION structure
; eax is relative to partition start
; out: eax = error code; 0 = ok
fs_write32_app:
; Just call the advanced function.
        push    ecx edx
        xor     edx, edx
        mov     ecx, 1
        call    fs_write64_app
        pop     edx ecx
        ret
 
; Lookup for the given sector in the given cache.
; If the sector is not present, return error.
; The caller must acquire the cache lock.
; in: edx:eax = sector
; in: ebx -> DISKCACHE structure
; out: CF set if sector is not in cache
; out: ecx = sector_size_log
; out: esi -> sector:status
; out: edi -> sector data
proc cache_lookup_read
        mov     esi, [ebx+DISKCACHE.pointer]
        add     esi, sizeof.CACHE_ITEM
 
        mov     edi, 1
 
.hdreadcache:
 
        cmp     [esi+CACHE_ITEM.Status], CACHE_ITEM_EMPTY
        je      .nohdcache
 
        cmp     [esi+CACHE_ITEM.SectorLo], eax
        jne     .nohdcache
        cmp     [esi+CACHE_ITEM.SectorHi], edx
        jne     .nohdcache
        mov     ecx, [ebx+DISKCACHE.sector_size_log]
        shl     edi, cl
        add     edi, [ebx+DISKCACHE.data]
        clc
        ret
 
.nohdcache:
 
        add     esi, sizeof.CACHE_ITEM
        inc     edi
        cmp     edi, [ebx+DISKCACHE.sad_size]
        jbe     .hdreadcache
        stc
        ret
endp
 
; Lookup for the given sector in the given cache.
; If the sector is not present, allocate space for it,
; possibly flushing data.
; in: edx:eax = sector
; in: ebx -> DISKCACHE structure
; in: ebp -> PARTITION structure
; out: eax = error code
; out: esi -> sector:status
; out: edi -> sector data
proc cache_lookup_write
        call    cache_lookup_read
        jnc     .return0
        push    edx eax
;-----------------------------------------------------------
; find empty or read slot, flush cache if next 12.5% is used by write
; output : ecx = cache slot
;-----------------------------------------------------------
; Note: the code is essentially inherited, so probably
; no analysis of efficiency were done.
; However, it works.
.search_again:
        mov     eax, [ebx+DISKCACHE.sad_size]
        mov     ecx, [ebx+DISKCACHE.search_start]
        shr     eax, 3
        lea     esi, [ecx*sizeof.CACHE_ITEM/4]
        shl     esi, 2
        add     esi, [ebx+DISKCACHE.pointer]
.search_for_empty:
        inc     ecx
        add     esi, sizeof.CACHE_ITEM
        cmp     ecx, [ebx+DISKCACHE.sad_size]
        jbe     .inside_cache
        mov     ecx, 1
        mov     esi, [ebx+DISKCACHE.pointer]
        add     esi, sizeof.CACHE_ITEM
.inside_cache:
        cmp     [esi+CACHE_ITEM.Status], CACHE_ITEM_MODIFIED
        jb      .found_slot             ; it's empty or read
        dec     eax
        jnz     .search_for_empty
        stdcall write_cache64, [ebp+PARTITION.Disk] ; no empty slots found, write all
        test    eax, eax
        jne     .found_slot_access_denied
        jmp     .search_again           ; and start again
.found_slot:
        mov     [ebx+DISKCACHE.search_start], ecx
        popd    [esi+CACHE_ITEM.SectorLo]
        popd    [esi+CACHE_ITEM.SectorHi]
        mov     [esi+CACHE_ITEM.Status], CACHE_ITEM_EMPTY
        mov     edi, ecx
        mov     ecx, [ebx+DISKCACHE.sector_size_log]
        shl     edi, cl
        add     edi, [ebx+DISKCACHE.data]
.return0:
        xor     eax, eax        ; success
        ret
.found_slot_access_denied:
        add     esp, 8
        ret
endp
 
; Flush the given cache.
; The caller must acquire the cache lock.
; in: ebx -> DISKCACHE
; in: first argument in stdcall convention -> PARTITION
proc write_cache64
; 1. Setup stack frame.
        push    esi edi         ; save used registers to be stdcall
        sub     esp, .local_vars_size   ; reserve space for local vars
virtual at esp
.local_vars:
.cache_end      dd      ?       ; item past the end of the cache
.size_left      dd      ?       ; items left to scan
.current_ptr    dd      ?       ; pointer to the current item
;
; Write operations are coalesced in chains,
; one chain describes a sequential interval of sectors,
; they can be sequential or scattered in the cache.
.sequential     dd      ?
; boolean variable, 1 if the current chain is sequential in the cache,
; 0 if additional buffer is needed to perform the operation
.chain_start_pos dd     ?       ; data of chain start item
.chain_start_ptr dd     ?       ; pointer to chain start item
.chain_size     dd      ?       ; chain size (thanks, C.O.)
.iteration_size dd      ?
; If the chain size is too large, split the operation to several iterations.
; This is size in sectors for one iterations.
.iteration_buffer dd    ?       ; temporary buffer for non-sequential chains
.local_vars_size = $ - .local_vars
                rd      2       ; saved registers
                dd      ?       ; return address
.disk           dd      ?       ; first argument
end virtual
; 1. If there is no cache for this disk, nothing to do, just return zero.
        cmp     [ebx+DISKCACHE.pointer], 0
        jz      .return0
; 2. Prepare for the loop: initialize current pointer and .size_left,
; calculate .cache_end.
        mov     ecx, [ebx+DISKCACHE.sad_size]
        mov     [.size_left], ecx
        lea     ecx, [ecx*sizeof.CACHE_ITEM/4]
        shl     ecx, 2
        mov     esi, [ebx+DISKCACHE.pointer]
        add     esi, sizeof.CACHE_ITEM
        add     ecx, esi
        mov     [.cache_end], ecx
; 3. Main loop: go over all items, go to 5 for every modified item.
.look:
        cmp     [esi+CACHE_ITEM.Status], CACHE_ITEM_MODIFIED
        jz      .begin_write
.look_next:
        add     esi, sizeof.CACHE_ITEM
        dec     [.size_left]
        jnz     .look
; 4. Return success.
.return0:
        xor     eax, eax
.return:
        add     esp, .local_vars_size
        pop     edi esi         ; restore used registers to be stdcall
        ret     4               ; return popping one argument
.begin_write:
; We have found a modified item.
; 5. Prepare for chain finding: save the current item, initialize chain variables.
        mov     [.current_ptr], esi
; Initialize chain as sequential zero-length starting at the current item.
        mov     [.chain_start_ptr], esi
        mov     eax, [ebx+DISKCACHE.sad_size]
        sub     eax, [.size_left]
        inc     eax
        mov     ecx, [ebx+DISKCACHE.sector_size_log]
        shl     eax, cl
        add     eax, [ebx+DISKCACHE.data]
        mov     [.chain_start_pos], eax
        mov     [.chain_size], 0
        mov     [.sequential], 1
; 6. Expand the chain backward.
; Note: the main loop in step 2 looks for items sequentially,
; so the previous item is not modified. If the previous sector
; is present in the cache, it automatically makes the chain scattered.
; 6a. Calculate sector number: one before the sector for the current item.
        mov     eax, [esi+CACHE_ITEM.SectorLo]
        mov     edx, [esi+CACHE_ITEM.SectorHi]
        sub     eax, 1
        sbb     edx, 0
.find_chain_start:
; 6b. For each sector where the previous item does not expand the chain,
; call the lookup function without adding to the cache.
        call    cache_lookup_read
; 6c. If the sector is not found in cache or is not modified, stop expanding
; and advance to step 7.
        jc      .found_chain_start
        cmp     [esi+CACHE_ITEM.Status], CACHE_ITEM_MODIFIED
        jnz     .found_chain_start
; 6d. We have found a new block that expands the chain backwards.
; It makes the chain non-sequential.
; Normally, sectors come in sequential blocks, so try to look at previous items
; before returning to 6b; if there is a sequential block indeed, this saves some
; time instead of many full-fledged lookups.
        mov     [.sequential], 0
        mov     [.chain_start_pos], edi
.look_backward:
; 6e. For each sector, update chain start pos/ptr, decrement sector number,
; look at the previous item.
        mov     [.chain_start_ptr], esi
        inc     [.chain_size]
        sub     eax, 1
        sbb     edx, 0
        sub     esi, sizeof.CACHE_ITEM
; If the previous item exists...
        cmp     esi, [ebx+DISKCACHE.pointer]
        jbe     .find_chain_start
; ...describes the correct sector...
        cmp     [esi+CACHE_ITEM.SectorLo], eax
        jnz     .find_chain_start
        cmp     [esi+CACHE_ITEM.SectorHi], edx
        jnz     .find_chain_start
; ...and is modified...
        cmp     [esi+CACHE_ITEM.Status], CACHE_ITEM_MODIFIED
        jnz     .found_chain_start
; ...expand the chain one sector backwards and continue the loop at 6e.
; Otherwise, advance to step 7 if the previous item describes the correct sector
; but is not modified, and return to step 6b otherwise.
        mov     edi, 1
        shl     edi, cl
        sub     [.chain_start_pos], edi
        jmp     .look_backward
.found_chain_start:
; 7. Expand the chain forward.
; 7a. Prepare for the loop at 7b:
; set esi = pointer to current item, edx:eax = current sector.
        mov     esi, [.current_ptr]
        mov     eax, [esi+CACHE_ITEM.SectorLo]
        mov     edx, [esi+CACHE_ITEM.SectorHi]
.look_forward:
; 7b. First, look at the next item. If it describes the next sector:
; if it is modified, expand the chain with that sector and continue this step,
; if it is not modified, the chain is completed, so advance to step 8.
        inc     [.chain_size]
        add     eax, 1
        adc     edx, 0
        add     esi, sizeof.CACHE_ITEM
        cmp     esi, [.cache_end]
        jae     .find_chain_end
        cmp     [esi+CACHE_ITEM.SectorLo], eax
        jnz     .find_chain_end
        cmp     [esi+CACHE_ITEM.SectorHi], edx
        jnz     .find_chain_end
        cmp     [esi+CACHE_ITEM.Status], CACHE_ITEM_MODIFIED
        jnz     .found_chain_end
        jmp     .look_forward
.find_chain_end:
; 7c. Otherwise, call the lookup function.
        call    cache_lookup_read
; 7d. If the next sector is present in the cache and is modified,
; mark the chain as non-sequential and continue to step 7b.
        jc      .found_chain_end
        cmp     [esi+CACHE_ITEM.Status], CACHE_ITEM_MODIFIED
        jnz     .found_chain_end
        mov     [.sequential], 0
        jmp     .look_forward
.found_chain_end:
; 8. Decide whether the chain is sequential or scattered.
; Advance to step 9 for sequential chains, go to step 10 for scattered chains.
        cmp     [.sequential], 0
        jz      .write_non_sequential
.write_sequential:
; 9. Write a sequential chain to disk.
; 9a. Pass the entire chain to the driver.
        mov     eax, [.chain_start_ptr]
        lea     ecx, [.chain_size]
        push    ecx     ; numsectors
        pushd   [eax+CACHE_ITEM.SectorHi]       ; startsector
        pushd   [eax+CACHE_ITEM.SectorLo]       ; startsector
        push    [.chain_start_pos+12]           ; buffer
        mov     esi, [ebp+PARTITION.Disk]
        mov     al, DISKFUNC.write
        call    disk_call_driver
; 9b. If failed, pass the error code to the driver.
        test    eax, eax
        jnz     .return
; 9c. If succeeded, mark all sectors in the chain as not-modified,
; advance current item and number of items left to skip the chain.
        mov     esi, [.current_ptr]
        mov     eax, [.chain_size]
        sub     [.size_left], eax
@@:
        mov     [esi+CACHE_ITEM.Status], CACHE_ITEM_COPY
        add     esi, sizeof.CACHE_ITEM
        dec     eax
        jnz     @b
; 9d. Continue the main loop at step 2 if there are more sectors.
; Return success otherwise.
        cmp     [.size_left], 0
        jnz     .look
        jmp     .return0
.write_non_sequential:
; Write a non-sequential chain to the disk.
; 10. Allocate a temporary buffer.
; Use [.chain_size] sectors, but
; not greater than CACHE_MAX_ALLOC_SIZE bytes
; and not greater than half of free memory.
        mov     eax, [pg_data.pages_free]
        shr     eax, 1
        jz      .nomemory
        cmp     eax, CACHE_MAX_ALLOC_SIZE shr 12
        jbe     @f
        mov     eax, CACHE_MAX_ALLOC_SIZE shr 12
@@:
        shl     eax, 12
        shr     eax, cl
        jz      .nomemory
        cmp     eax, [.chain_size]
        jbe     @f
        mov     eax, [.chain_size]
@@:
        mov     [.iteration_size], eax
        shl     eax, cl
        stdcall kernel_alloc, eax
        test    eax, eax
        jz      .nomemory
        mov     [.iteration_buffer], eax
.write_non_sequential_iteration:
; 11. Split the chain so that each iteration fits in the allocated buffer.
; Iteration size is the minimum of chain size and allocated size.
        mov     eax, [.chain_size]
        cmp     eax, [.iteration_size]
        jae     @f
        mov     [.iteration_size], eax
@@:
; 12. Prepare arguments for the driver.
        mov     esi, [.chain_start_ptr]
        mov     edi, [.iteration_buffer]
        push    [.iteration_size]
        push    esp     ; numsectors
        push    [esi+CACHE_ITEM.SectorHi]       ; startsector
        push    [esi+CACHE_ITEM.SectorLo]       ; startsector
        push    edi     ; buffer
; 13. Copy data from the cache to the temporary buffer,
; advancing chain_start pos/ptr and marking sectors as not-modified.
; 13a. Prepare for the loop: push number of sectors to process.
        push    [.iteration_size+20]    ; temporary variable
.copy_loop:
; 13b. For each sector, copy the data.
; Note that edi is advanced automatically.
        mov     esi, [.chain_start_pos+24]
        mov     ecx, [ebx+DISKCACHE.sector_size_log]
        mov     eax, 1
        shl     eax, cl
        mov     ecx, eax
        shr     ecx, 2
        rep movsd
        mov     ecx, eax ; keep for 13e
; 13c. Mark the item as not-modified.
        mov     esi, [.chain_start_ptr+24]
        mov     [esi+CACHE_ITEM.Status], CACHE_ITEM_COPY
; 13d. Check whether the next sector continues the chain.
; If so, advance to 13e. Otherwise, go to 13f.
        mov     eax, [esi+CACHE_ITEM.SectorLo]
        mov     edx, [esi+CACHE_ITEM.SectorHi]
        add     esi, sizeof.CACHE_ITEM
        add     eax, 1
        adc     edx, 0
        cmp     esi, [.cache_end+24]
        jae     .no_forward
        cmp     [esi+CACHE_ITEM.SectorLo], eax
        jnz     .no_forward
        cmp     [esi+CACHE_ITEM.SectorHi], edx
        jnz     .no_forward
; 13e. Increment position/pointer to the chain and
; continue the loop.
        add     [.chain_start_pos+24], ecx
        mov     [.chain_start_ptr+24], esi
        dec     dword [esp]
        jnz     .copy_loop
        jmp     .copy_done
.no_forward:
; 13f. Call the lookup function without adding to the cache.
; Update position/pointer with returned value.
; Note: for the last sector in the chain, edi/esi may contain
; garbage; we are not going to use them in this case.
        push    edi
        call    cache_lookup_read
        mov     [.chain_start_pos+28], edi
        mov     [.chain_start_ptr+28], esi
        pop     edi
        dec     dword [esp]
        jnz     .copy_loop
.copy_done:
; 13g. Restore the stack after 13a.
        pop     ecx
; 14. Call the driver.
        mov     esi, [ebp+PARTITION.Disk]
        mov     al, DISKFUNC.write
        call    disk_call_driver
        pop     ecx     ; numsectors
; 15. If the driver has returned an error, free the buffer allocated at step 10
; and pass the error to the caller.
; Otherwise, remove the processed part from the chain and continue iterations
; starting in step 11 if there are more data to process.
        test    eax, eax
        jnz     .nonsequential_error
        sub     [.chain_size], ecx
        jnz     .write_non_sequential_iteration
; 16. The chain is written. Free the temporary buffer
; and continue the loop at step 2.
        stdcall kernel_free, [.iteration_buffer]
        mov     esi, [.current_ptr]
        jmp     .look_next
.nonsequential_error:
        push    eax
        stdcall kernel_free, [.iteration_buffer+4]
        pop     eax
        jmp     .return
.nomemory:
        mov     eax, DISK_STATUS_NO_MEMORY
        jmp     .return
endp
 
; This internal function is called from disk_add to initialize the caching for
; a new DISK.
; The algorithm is inherited from getcache.inc: take 1/32 part of the available
; physical memory, round down to 8 pages, limit by 128K from below and by 1M
; from above. Reserve 1/8 part of the cache for system data and 7/8 for app
; data.
; After the size is calculated, but before the cache is allocated, the device
; driver can adjust the size. In particular, setting size to zero disables
; caching: there is no sense in a cache for a ramdisk. In fact, such action
; is most useful example of a non-trivial adjustment.
; esi = pointer to DISK structure
disk_init_cache:
; 1. Verify sector size. The code requires it to be a power of 2 not less than 4.
; In the name of sanity check that sector size is not too small or too large.
        bsf     ecx, [esi+DISK.MediaInfo.SectorSize]
        jz      .invalid_sector_size
        mov     eax, 1
        shl     eax, cl
        cmp     eax, [esi+DISK.MediaInfo.SectorSize]
        jnz     .invalid_sector_size
        cmp     ecx, 6
        jb      .invalid_sector_size
        cmp     ecx, 14
        jbe     .normal_sector_size
.invalid_sector_size:
        DEBUGF 1,'K : sector size %x is invalid\n',[esi+DISK.MediaInfo.SectorSize]
        xor     eax, eax
        ret
.normal_sector_size:
        mov     [esi+DISK.SysCache.sector_size_log], ecx
        mov     [esi+DISK.AppCache.sector_size_log], ecx
; 2. Calculate the suggested cache size.
; 2a. Get the size of free physical memory in pages.
        mov     eax, [pg_data.pages_free]
; 2b. Use the value to calculate the size.
        shl     eax, 12 - 5     ; 1/32 of it in bytes
        and     eax, -8*4096    ; round down to the multiple of 8 pages
; 2c. Force lower and upper limits.
        cmp     eax, 1024*1024
        jb      @f
        mov     eax, 1024*1024
@@:
        cmp     eax, 128*1024
        ja      @f
        mov     eax, 128*1024
@@:
; 2d. Give a chance to the driver to adjust the size.
        push    eax
        mov     al, DISKFUNC.adjust_cache_size
        call    disk_call_driver
; Cache size calculated.
        mov     [esi+DISK.cache_size], eax
        test    eax, eax
        jz      .nocache
; 3. Allocate memory for the cache.
; 3a. Call the allocator.
        stdcall kernel_alloc, eax
        test    eax, eax
        jnz     @f
; 3b. If it failed, say a message and return with eax = 0.
        dbgstr 'no memory for disk cache'
        jmp     .nothing
@@:
; 4. Fill two DISKCACHE structures.
        mov     [esi+DISK.SysCache.pointer], eax
        lea     ecx, [esi+DISK.CacheLock]
        call    mutex_init
; The following code is inherited from getcache.inc.
        mov     edx, [esi+DISK.SysCache.pointer]
        and     [esi+DISK.SysCache.search_start], 0
        and     [esi+DISK.AppCache.search_start], 0
        mov     eax, [esi+DISK.cache_size]
        shr     eax, 3
        mov     [esi+DISK.SysCache.data_size], eax
        add     edx, eax
        imul    eax, 7
        mov     [esi+DISK.AppCache.data_size], eax
        mov     [esi+DISK.AppCache.pointer], edx
 
        mov     eax, [esi+DISK.SysCache.data_size]
        call    calculate_cache_slots
        add     eax, [esi+DISK.SysCache.pointer]
        mov     [esi+DISK.SysCache.data], eax
        mov     [esi+DISK.SysCache.sad_size], ecx
 
        push    edi
        mov     edi, [esi+DISK.SysCache.pointer]
        lea     ecx, [(ecx+1)*3]
        xor     eax, eax
        rep stosd
        pop     edi
 
        mov     eax, [esi+DISK.AppCache.data_size]
        call    calculate_cache_slots
        add     eax, [esi+DISK.AppCache.pointer]
        mov     [esi+DISK.AppCache.data], eax
        mov     [esi+DISK.AppCache.sad_size], ecx
 
        push    edi
        mov     edi, [esi+DISK.AppCache.pointer]
        lea     ecx, [(ecx+1)*3]
        xor     eax, eax
        rep stosd
        pop     edi
 
; 5. Return with nonzero al.
        mov     al, 1
; 6. Return.
.nothing:
        ret
; No caching is required for this driver. Zero cache pointers and return with
; nonzero al.
.nocache:
        mov     [esi+DISK.SysCache.pointer], eax
        mov     [esi+DISK.AppCache.pointer], eax
        mov     al, 1
        ret
 
calculate_cache_slots:
        push    eax
        mov     ecx, [esi+DISK.MediaInfo.SectorSize]
        add     ecx, sizeof.CACHE_ITEM
        xor     edx, edx
        div     ecx
        mov     ecx, eax
        imul    eax, [esi+DISK.MediaInfo.SectorSize]
        sub     [esp], eax
        pop     eax
        dec     ecx
        ret
 
 
; This internal function is called from disk_media_dereference to free the
; allocated cache, if there is one.
; esi = pointer to DISK structure
disk_free_cache:
; The algorithm is straightforward.
        mov     eax, [esi+DISK.SysCache.pointer]
        test    eax, eax
        jz      .nothing
        stdcall kernel_free, eax
.nothing:
        ret
 
; This function flushes all modified data from both caches for the given DISK.
; esi = pointer to DISK
disk_sync:
; The algorithm is straightforward.
        cmp     [esi+DISK.SysCache.pointer], 0
        jz      .nothing
        lea     ecx, [esi+DISK.CacheLock]
        call    mutex_lock
        push    ebx
        push    esi     ; for second write_cache64
        push    esi     ; for first write_cache64
        lea     ebx, [esi+DISK.SysCache]
        call    write_cache64
        add     ebx, DISK.AppCache - DISK.SysCache
        call    write_cache64
        pop     ebx
        lea     ecx, [esi+DISK.CacheLock]
        call    mutex_unlock
.nothing:
        mov     al, DISKFUNC.flush
        call    disk_call_driver
        ret

Rev 5089	Rev 5095
1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2	;; ;;	2	;; ;;
3	;; Copyright (C) KolibriOS team 2011-2014. All rights reserved. ;;	3	;; Copyright (C) KolibriOS team 2011-2014. All rights reserved. ;;
4	;; Distributed under terms of the GNU General Public License ;;	4	;; Distributed under terms of the GNU General Public License ;;
5	;; ;;	5	;; ;;
6	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	6	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
7		7
8	$Revision: 5089 $	8	$Revision: 5095 $
9		9
10	; Read/write functions try to do large operations,	10	; Read/write functions try to do large operations,
11	; it is significantly faster than several small operations.	11	; it is significantly faster than several small operations.
12	; This requires large buffers.	12	; This requires large buffers.
13	; We can't use input/output buffers directly - they can be controlled	13	; We can't use input/output buffers directly - they can be controlled
14	; by user-mode application, so they can be modified between the operation	14	; by user-mode application, so they can be modified between the operation
15	; and copying to/from cache, giving invalid data in cache.	15	; and copying to/from cache, giving invalid data in cache.
16	; It is unclear how to use cache directly, currently cache items are	16	; It is unclear how to use cache directly, currently cache items are
17	; allocated/freed sector-wise, so items for sequential sectors can be	17	; allocated/freed sector-wise, so items for sequential sectors can be
18	; scattered over all the cache.	18	; scattered over all the cache.
19	; So read/write functions allocate a temporary buffer which is	19	; So read/write functions allocate a temporary buffer which is
20	; 1) not greater than half of free memory and	20	; 1) not greater than half of free memory and
21	; 2) not greater than the following constant.	21	; 2) not greater than the following constant.
22	CACHE_MAX_ALLOC_SIZE = 4 shl 20	22	CACHE_MAX_ALLOC_SIZE = 4 shl 20
23		23
24	; Legacy interface for filesystems fs_{read,write}32_{sys,app}	24	; Legacy interface for filesystems fs_{read,write}32_{sys,app}
25	; gives only one sector for FS. However, per-sector reading is inefficient,	25	; gives only one sector for FS. However, per-sector reading is inefficient,
26	; so internally fs_read32_{sys,app} reads to the cache several sequential	26	; so internally fs_read32_{sys,app} reads to the cache several sequential
27	; sectors, hoping that they will be useful.	27	; sectors, hoping that they will be useful.
28	; Total number of sectors is given by the following constant.	28	; Total number of sectors is given by the following constant.
29	CACHE_LEGACY_READ_SIZE = 16	29	CACHE_LEGACY_READ_SIZE = 16
30		30
31	; This structure describes one item in the cache.	31	; This structure describes one item in the cache.
32	struct CACHE_ITEM	32	struct CACHE_ITEM
33	SectorLo dd ? ; low 32 bits of sector	33	SectorLo dd ? ; low 32 bits of sector
34	SectorHi dd ? ; high 32 bits of sector	34	SectorHi dd ? ; high 32 bits of sector
35	Status dd ? ; one of CACHE_ITEM_*	35	Status dd ? ; one of CACHE_ITEM_*
36	ends	36	ends
37		37
38	; Possible values for CACHE_ITEM_*	38	; Possible values for CACHE_ITEM_*
39	CACHE_ITEM_EMPTY = 0	39	CACHE_ITEM_EMPTY = 0
40	CACHE_ITEM_COPY = 1	40	CACHE_ITEM_COPY = 1
41	CACHE_ITEM_MODIFIED = 2	41	CACHE_ITEM_MODIFIED = 2
42		42
43	; Read several sequential sectors using cache #1.	43	; Read several sequential sectors using cache #1.
44	; in: edx:eax = start sector, relative to start of partition	44	; in: edx:eax = start sector, relative to start of partition
45	; in: ecx = number of sectors to read	45	; in: ecx = number of sectors to read
46	; in: ebx -> buffer	46	; in: ebx -> buffer
47	; in: ebp -> PARTITION	47	; in: ebp -> PARTITION
48	; out: eax = error code, 0 = ok	48	; out: eax = error code, 0 = ok
49	; out: ecx = number of sectors that were read	49	; out: ecx = number of sectors that were read
50	fs_read64_sys:	50	fs_read64_sys:
51	; Save ebx, set ebx to SysCache and let the common part do its work.	51	; Save ebx, set ebx to SysCache and let the common part do its work.
52	push ebx	52	push ebx ebx
53	mov ebx, [ebp+PARTITION.Disk]	53	mov ebx, [ebp+PARTITION.Disk]
54	add ebx, DISK.SysCache	54	add ebx, DISK.SysCache
55	jmp fs_read64_common	55	jmp fs_read64_common
56		56
57	; Read several sequential sectors using cache #2.	57	; Read several sequential sectors using cache #2.
58	; in: edx:eax = start sector, relative to start of partition	58	; in: edx:eax = start sector, relative to start of partition
59	; in: ecx = number of sectors to read	59	; in: ecx = number of sectors to read
60	; in: edi -> buffer	60	; in: edi -> buffer
61	; in: ebp -> PARTITION	61	; in: ebp -> PARTITION
62	; out: eax = error code, 0 = ok	62	; out: eax = error code, 0 = ok
63	; out: ecx = number of sectors that were read	63	; out: ecx = number of sectors that were read
64	fs_read64_app:	64	fs_read64_app:
65	; Save ebx, set ebx to AppCache and let the common part do its work.	65	; Save ebx, set ebx to AppCache and let the common part do its work.
66	push ebx	66	push ebx ebx
67	mov ebx, [ebp+PARTITION.Disk]	67	mov ebx, [ebp+PARTITION.Disk]
68	add ebx, DISK.AppCache	68	add ebx, DISK.AppCache
69		69
70	; Common part of fs_read64_{app,sys}:	70	; Common part of fs_read64_{app,sys}:
71	; read several sequential sectors using the given cache.	71	; read several sequential sectors using the given cache.
72	fs_read64_common:	72	fs_read64_common:
73	; 1. Setup stack frame.	73	; 1. Setup stack frame.
74	push esi edi ; save used registers to be stdcall	74	push esi edi ; save used registers to be stdcall
75	push 0 ; initialize .error_code	75	push 0 ; initialize .error_code
76	push ebx edx eax ecx ecx ; initialize stack variables	76	push ebx edx eax ecx ecx ; initialize stack variables
77	virtual at esp	77	virtual at esp
78	.local_vars:	78	.local_vars:
79	.num_sectors_orig dd ?	79	.num_sectors_orig dd ?
80	; Number of sectors that should be read. Used to generate output value of ecx.	80	; Number of sectors that should be read. Used to generate output value of ecx.
81	.num_sectors dd ?	81	.num_sectors dd ?
82	; Number of sectors that remain to be read. Decreases from .num_sectors_orig to 0.	82	; Number of sectors that remain to be read. Decreases from .num_sectors_orig to 0.
83	.sector_lo dd ? ; low 32 bits of the current sector	83	.sector_lo dd ? ; low 32 bits of the current sector
84	.sector_hi dd ? ; high 32 bits of the current sector	84	.sector_hi dd ? ; high 32 bits of the current sector
85	.cache dd ? ; pointer to DISKCACHE	85	.cache dd ? ; pointer to DISKCACHE
86	.error_code dd ? ; current status	86	.error_code dd ? ; current status
87	.local_vars_size = $ - .local_vars	87	.local_vars_size = $ - .local_vars
88	.saved_regs rd 2	88	.saved_regs rd 2
89	.buffer dd ? ; filled by fs_read64_{sys,app}	89	.buffer dd ? ; filled by fs_read64_{sys,app}
90	end virtual	90	end virtual
91	; 2. Validate parameters against partition length:	91	; 2. Validate parameters against partition length:
92	; immediately return error if edx:eax are beyond partition end,	92	; immediately return error if edx:eax are beyond partition end,
93	; decrease .num_sectors and .num_sectors_orig, if needed,	93	; decrease .num_sectors and .num_sectors_orig, if needed,
94	; so that the entire operation fits in the partition limits.	94	; so that the entire operation fits in the partition limits.
95	mov eax, dword [ebp+PARTITION.Length]	95	mov eax, dword [ebp+PARTITION.Length]
96	mov edx, dword [ebp+PARTITION.Length+4]	96	mov edx, dword [ebp+PARTITION.Length+4]
97	sub eax, [.sector_lo]	97	sub eax, [.sector_lo]
98	sbb edx, [.sector_hi]	98	sbb edx, [.sector_hi]
99	jb .end_of_media	99	jb .end_of_media
100	jnz .no_end_of_media	100	jnz .no_end_of_media
101	cmp ecx, eax	101	cmp ecx, eax
102	jbe .no_end_of_media	102	jbe .no_end_of_media
103	; If .num_sectors got decreased, set status to DISK_STATUS_END_OF_MEDIA;	103	; If .num_sectors got decreased, set status to DISK_STATUS_END_OF_MEDIA;
104	; if all subsequent operations would be successful, this would become the final	104	; if all subsequent operations would be successful, this would become the final
105	; status, otherwise this would be rewritten by failed operation.	105	; status, otherwise this would be rewritten by failed operation.
106	mov [.num_sectors], eax	106	mov [.num_sectors], eax
107	mov [.num_sectors_orig], eax	107	mov [.num_sectors_orig], eax
108	mov [.error_code], DISK_STATUS_END_OF_MEDIA	108	mov [.error_code], DISK_STATUS_END_OF_MEDIA
109	.no_end_of_media:	109	.no_end_of_media:
110	; 3. If number of sectors to read is zero, either because zero-sectors operation	110	; 3. If number of sectors to read is zero, either because zero-sectors operation
111	; was requested or because it got decreased to zero due to partition limits,	111	; was requested or because it got decreased to zero due to partition limits,
112	; just return the current status.	112	; just return the current status.
113	cmp [.num_sectors], 0	113	cmp [.num_sectors], 0
114	jz .return	114	jz .return
115	; 4. Shift sector from partition-relative to absolute.	115	; 4. Shift sector from partition-relative to absolute.
116	mov eax, dword [ebp+PARTITION.FirstSector]	116	mov eax, dword [ebp+PARTITION.FirstSector]
117	mov edx, dword [ebp+PARTITION.FirstSector+4]	117	mov edx, dword [ebp+PARTITION.FirstSector+4]
118	add [.sector_lo], eax	118	add [.sector_lo], eax
119	adc [.sector_hi], edx	119	adc [.sector_hi], edx
120	; 5. If the cache is disabled, pass the request directly to the driver.	120	; 5. If the cache is disabled, pass the request directly to the driver.
121	cmp [ebx+DISKCACHE.pointer], 0	121	cmp [ebx+DISKCACHE.pointer], 0
122	jz .nocache	122	jz .nocache
123	; 6. Look for sectors in the cache, sequentially from the beginning.	123	; 6. Look for sectors in the cache, sequentially from the beginning.
124	; Stop at the first sector that is not in the cache	124	; Stop at the first sector that is not in the cache
125	; or when all sectors were read from the cache.	125	; or when all sectors were read from the cache.
126	; 6a. Acquire the lock.	126	; 6a. Acquire the lock.
127	mov ecx, [ebp+PARTITION.Disk]	127	mov ecx, [ebp+PARTITION.Disk]
128	add ecx, DISK.CacheLock	128	add ecx, DISK.CacheLock
129	call mutex_lock	129	call mutex_lock
130	.lookup_in_cache_loop:	130	.lookup_in_cache_loop:
131	; 6b. For each sector, call the lookup function without adding to the cache.	131	; 6b. For each sector, call the lookup function without adding to the cache.
132	mov eax, [.sector_lo]	132	mov eax, [.sector_lo]
133	mov edx, [.sector_hi]	133	mov edx, [.sector_hi]
134	call cache_lookup_read	134	call cache_lookup_read
135	; 6c. If it has failed, the sector is not in cache;	135	; 6c. If it has failed, the sector is not in cache;
136	; release the lock and go to 7.	136	; release the lock and go to 7.
137	jc .not_found_in_cache	137	jc .not_found_in_cache
138	; The sector is found in cache.	138	; The sector is found in cache.
139	; 6d. Copy data for the caller, advance [.buffer].	139	; 6d. Copy data for the caller, advance [.buffer].
140	mov esi, edi	140	mov esi, edi
141	mov edi, [.buffer]	141	mov edi, [.buffer]
142	mov eax, 1	142	mov eax, 1
143	shl eax, cl	143	shl eax, cl
144	mov ecx, eax	144	mov ecx, eax
145	shr ecx, 2	145	shr ecx, 2
146	rep movsd	146	rep movsd
147	mov [.buffer], edi	147	mov [.buffer], edi
148	; 6e. Advance the sector.	148	; 6e. Advance the sector.
149	add [.sector_lo], 1	149	add [.sector_lo], 1
150	adc [.sector_hi], 0	150	adc [.sector_hi], 0
151	; 6f. Decrement number of sectors left.	151	; 6f. Decrement number of sectors left.
152	; If all sectors were read, release the lock and return.	152	; If all sectors were read, release the lock and return.
153	dec [.num_sectors]	153	dec [.num_sectors]
154	jnz .lookup_in_cache_loop	154	jnz .lookup_in_cache_loop
155	; Release the lock acquired at 6a.	155	; Release the lock acquired at 6a.
156	mov ecx, [ebp+PARTITION.Disk]	156	mov ecx, [ebp+PARTITION.Disk]
157	add ecx, DISK.CacheLock	157	add ecx, DISK.CacheLock
158	call mutex_unlock	158	call mutex_unlock
159	.return:	159	.return:
160	mov eax, [.error_code]	160	mov eax, [.error_code]
161	mov ecx, [.num_sectors_orig]	161	mov ecx, [.num_sectors_orig]
162	sub ecx, [.num_sectors]	162	sub ecx, [.num_sectors]
163	.nothing:	163	.nothing:
164	add esp, .local_vars_size	164	add esp, .local_vars_size
165	pop edi esi ebx ; restore used registers to be stdcall	165	pop edi esi ebx ebx ; restore used registers to be stdcall
166	ret	166	ret
167	.not_found_in_cache:	167	.not_found_in_cache:
168	; Release the lock acquired at 6a.	168	; Release the lock acquired at 6a.
169	mov ecx, [ebp+PARTITION.Disk]	169	mov ecx, [ebp+PARTITION.Disk]
170	add ecx, DISK.CacheLock	170	add ecx, DISK.CacheLock
171	call mutex_unlock	171	call mutex_unlock
172	; The current sector is not present in the cache.	172	; The current sector is not present in the cache.
173	; Ask the driver to read all requested not-yet-read sectors,	173	; Ask the driver to read all requested not-yet-read sectors,
174	; put results in the cache.	174	; put results in the cache.
175	; Also, see the comment before the definition of CACHE_MAX_ALLOC_SIZE.	175	; Also, see the comment before the definition of CACHE_MAX_ALLOC_SIZE.
176	; 7. Allocate buffer for operations.	176	; 7. Allocate buffer for operations.
177	; Normally, create buffer that is sufficient for all remaining data.	177	; Normally, create buffer that is sufficient for all remaining data.
178	; However, for extra-large requests make an upper limit:	178	; However, for extra-large requests make an upper limit:
179	; do not use more than half of the free memory	179	; do not use more than half of the free memory
180	; or more than CACHE_MAX_ALLOC_SIZE bytes.	180	; or more than CACHE_MAX_ALLOC_SIZE bytes.
181	mov ecx, [ebx+DISKCACHE.sector_size_log]	181	mov ecx, [ebx+DISKCACHE.sector_size_log]
182	mov ebx, [pg_data.pages_free]	182	mov ebx, [pg_data.pages_free]
183	shr ebx, 1	183	shr ebx, 1
184	jz .nomemory	184	jz .nomemory
185	cmp ebx, CACHE_MAX_ALLOC_SIZE shr 12	185	cmp ebx, CACHE_MAX_ALLOC_SIZE shr 12
186	jbe @f	186	jbe @f
187	mov ebx, CACHE_MAX_ALLOC_SIZE shr 12	187	mov ebx, CACHE_MAX_ALLOC_SIZE shr 12
188	@@:	188	@@:
189	shl ebx, 12	189	shl ebx, 12
190	shr ebx, cl	190	shr ebx, cl
191	jz .nomemory	191	jz .nomemory
192	cmp ebx, [.num_sectors]	192	cmp ebx, [.num_sectors]
193	jbe @f	193	jbe @f
194	mov ebx, [.num_sectors]	194	mov ebx, [.num_sectors]
195	@@:	195	@@:
196	mov eax, ebx	196	mov eax, ebx
197	shl eax, cl	197	shl eax, cl
198	stdcall kernel_alloc, eax	198	stdcall kernel_alloc, eax
199	; If failed, return the appropriate error code.	199	; If failed, return the appropriate error code.
200	test eax, eax	200	test eax, eax
201	jz .nomemory	201	jz .nomemory
202	mov esi, eax	202	mov esi, eax
203	; Split the request to chunks that fit in the allocated buffer.	203	; Split the request to chunks that fit in the allocated buffer.
204	.read_loop:	204	.read_loop:
205	; 8. Get iteration size: either size of allocated buffer in sectors	205	; 8. Get iteration size: either size of allocated buffer in sectors
206	; or number of sectors left, select what is smaller.	206	; or number of sectors left, select what is smaller.
207	cmp ebx, [.num_sectors]	207	cmp ebx, [.num_sectors]
208	jbe @f	208	jbe @f
209	mov ebx, [.num_sectors]	209	mov ebx, [.num_sectors]
210	@@:	210	@@:
211	; 9. Create second portion of local variables.	211	; 9. Create second portion of local variables.
212	; Note that variables here and above are esp-relative;	212	; Note that variables here and above are esp-relative;
213	; it means that all addresses should be corrected when esp is changing.	213	; it means that all addresses should be corrected when esp is changing.
214	push ebx esi esi	214	push ebx esi esi
215	push ebx	215	push ebx
216	; In particular, num_sectors is now [.num_sectors+.local_vars2_size].	216	; In particular, num_sectors is now [.num_sectors+.local_vars2_size].
217	virtual at esp	217	virtual at esp
218	.local_vars2:	218	.local_vars2:
219	.current_num_sectors dd ? ; number of sectors that were read	219	.current_num_sectors dd ? ; number of sectors that were read
220	.current_buffer dd ?	220	.current_buffer dd ?
221	; pointer inside .allocated_buffer that points	221	; pointer inside .allocated_buffer that points
222	; to the beginning of not-processed data	222	; to the beginning of not-processed data
223	.allocated_buffer dd ? ; saved in safe place	223	.allocated_buffer dd ? ; saved in safe place
224	.iteration_size dd ? ; saved in safe place	224	.iteration_size dd ? ; saved in safe place
225	.local_vars2_size = $ - .local_vars2	225	.local_vars2_size = $ - .local_vars2
226	end virtual	226	end virtual
227	; 10. Call the driver, reading the next chunk.	227	; 10. Call the driver, reading the next chunk.
228	push esp ; numsectors	228	push esp ; numsectors
229	push [.sector_hi+.local_vars2_size+4] ; startsector	229	push [.sector_hi+.local_vars2_size+4] ; startsector
230	push [.sector_lo+.local_vars2_size+8] ; startsector	230	push [.sector_lo+.local_vars2_size+8] ; startsector
231	push esi ; buffer	231	push esi ; buffer
232	mov esi, [ebp+PARTITION.Disk]	232	mov esi, [ebp+PARTITION.Disk]
233	mov al, DISKFUNC.read	233	mov al, DISKFUNC.read
234	call disk_call_driver	234	call disk_call_driver
235	; If failed, save error code.	235	; If failed, save error code.
236	test eax, eax	236	test eax, eax
237	jz @f	237	jz @f
238	mov [.error_code+.local_vars2_size], eax	238	mov [.error_code+.local_vars2_size], eax
239	@@:	239	@@:
240	; 11. Copy data for the caller, advance .buffer.	240	; 11. Copy data for the caller, advance .buffer.
241	cmp [.current_num_sectors], 0	241	cmp [.current_num_sectors], 0
242	jz .copy_done	242	jz .copy_done
243	mov ebx, [.cache+.local_vars2_size]	243	mov ebx, [.cache+.local_vars2_size]
244	mov eax, [.current_num_sectors]	244	mov eax, [.current_num_sectors]
245	mov ecx, [ebx+DISKCACHE.sector_size_log]	245	mov ecx, [ebx+DISKCACHE.sector_size_log]
246	shl eax, cl	246	shl eax, cl
247	mov esi, [.allocated_buffer]	247	mov esi, [.allocated_buffer]
248	mov edi, [.buffer+.local_vars2_size]	248	mov edi, [.buffer+.local_vars2_size]
249	mov ecx, eax	249	mov ecx, eax
250	shr ecx, 2	250	shr ecx, 2
251	rep movsd	251	rep movsd
252	mov [.buffer+.local_vars2_size], edi	252	mov [.buffer+.local_vars2_size], edi
253	; 12. Copy data to the cache.	253	; 12. Copy data to the cache.
254	; 12a. Acquire the lock.	254	; 12a. Acquire the lock.
255	mov ecx, [ebp+PARTITION.Disk]	255	mov ecx, [ebp+PARTITION.Disk]
256	add ecx, DISK.CacheLock	256	add ecx, DISK.CacheLock
257	call mutex_lock	257	call mutex_lock
258	; 12b. Prepare for the loop: create a local variable that	258	; 12b. Prepare for the loop: create a local variable that
259	; stores number of sectors to be copied.	259	; stores number of sectors to be copied.
260	push [.current_num_sectors]	260	push [.current_num_sectors]
261	.store_to_cache:	261	.store_to_cache:
262	; 12c. For each sector, call the lookup function with adding to the cache, if not yet.	262	; 12c. For each sector, call the lookup function with adding to the cache, if not yet.
263	mov eax, [.sector_lo+.local_vars2_size+4]	263	mov eax, [.sector_lo+.local_vars2_size+4]
264	mov edx, [.sector_hi+.local_vars2_size+4]	264	mov edx, [.sector_hi+.local_vars2_size+4]
265	call cache_lookup_write	265	call cache_lookup_write
266	test eax, eax	266	test eax, eax
267	jnz .cache_error	267	jnz .cache_error
268	; 12d. If the sector was already present in the cache as modified,	268	; 12d. If the sector was already present in the cache as modified,
269	; data that were read at step 10 for this sector are obsolete,	269	; data that were read at step 10 for this sector are obsolete,
270	; so rewrite data for the caller from the cache.	270	; so rewrite data for the caller from the cache.
271	cmp [esi+CACHE_ITEM.Status], CACHE_ITEM_MODIFIED	271	cmp [esi+CACHE_ITEM.Status], CACHE_ITEM_MODIFIED
272	jnz .not_modified	272	jnz .not_modified
273	mov esi, edi	273	mov esi, edi
274	mov edi, [.buffer+.local_vars2_size+4]	274	mov edi, [.buffer+.local_vars2_size+4]
275	mov eax, [esp]	275	mov eax, [esp]
276	shl eax, cl	276	shl eax, cl
277	sub edi, eax	277	sub edi, eax
278	mov eax, 1	278	mov eax, 1
279	shl eax, cl	279	shl eax, cl
280	mov ecx, eax	280	mov ecx, eax
281	shr ecx, 2	281	shr ecx, 2
282	rep movsd	282	rep movsd
283	add [.current_buffer+4], eax	283	add [.current_buffer+4], eax
284	jmp .sector_done	284	jmp .sector_done
285	.not_modified:	285	.not_modified:
286	; 12e. For each not-modified sector,	286	; 12e. For each not-modified sector,
287	; copy data, mark the item as not-modified copy of the disk,	287	; copy data, mark the item as not-modified copy of the disk,
288	; advance .current_buffer and .sector_hi:.sector_lo to the next sector.	288	; advance .current_buffer and .sector_hi:.sector_lo to the next sector.
289	mov [esi+CACHE_ITEM.Status], CACHE_ITEM_COPY	289	mov [esi+CACHE_ITEM.Status], CACHE_ITEM_COPY
290	mov eax, 1	290	mov eax, 1
291	shl eax, cl	291	shl eax, cl
292	mov esi, [.current_buffer+4]	292	mov esi, [.current_buffer+4]
293	mov ecx, eax	293	mov ecx, eax
294	shr ecx, 2	294	shr ecx, 2
295	rep movsd	295	rep movsd
296	mov [.current_buffer+4], esi	296	mov [.current_buffer+4], esi
297	.sector_done:	297	.sector_done:
298	add [.sector_lo+.local_vars2_size+4], 1	298	add [.sector_lo+.local_vars2_size+4], 1
299	adc [.sector_hi+.local_vars2_size+4], 0	299	adc [.sector_hi+.local_vars2_size+4], 0
300	; 12f. Continue the loop 12c-12e until all sectors are read.	300	; 12f. Continue the loop 12c-12e until all sectors are read.
301	dec dword [esp]	301	dec dword [esp]
302	jnz .store_to_cache	302	jnz .store_to_cache
303	.cache_error:	303	.cache_error:
304	; 12g. Restore after the loop: pop the local variable.	304	; 12g. Restore after the loop: pop the local variable.
305	pop ecx	305	pop ecx
306	; 12h. Release the lock.	306	; 12h. Release the lock.
307	mov ecx, [ebp+PARTITION.Disk]	307	mov ecx, [ebp+PARTITION.Disk]
308	add ecx, DISK.CacheLock	308	add ecx, DISK.CacheLock
309	call mutex_unlock	309	call mutex_unlock
310	.copy_done:	310	.copy_done:
311	; 13. Remove portion of local variables created at step 9.	311	; 13. Remove portion of local variables created at step 9.
312	pop ecx	312	pop ecx
313	pop esi esi ebx	313	pop esi esi ebx
314	; 14. Continue iterations while number of sectors read by the driver	314	; 14. Continue iterations while number of sectors read by the driver
315	; is equal to number of sectors requested and there are additional sectors.	315	; is equal to number of sectors requested and there are additional sectors.
316	cmp ecx, ebx	316	cmp ecx, ebx
317	jnz @f	317	jnz @f
318	sub [.num_sectors], ebx	318	sub [.num_sectors], ebx
319	jnz .read_loop	319	jnz .read_loop
320	@@:	320	@@:
321	; 15. Free the buffer allocated at step 7 and return.	321	; 15. Free the buffer allocated at step 7 and return.
322	stdcall kernel_free, esi	322	stdcall kernel_free, esi
323	jmp .return	323	jmp .return
324		324
325	; Special branches:	325	; Special branches:
326	.nomemory:	326	.nomemory:
327	; memory allocation failed at step 7: return the corresponding error	327	; memory allocation failed at step 7: return the corresponding error
328	mov [.error_code], DISK_STATUS_NO_MEMORY	328	mov [.error_code], DISK_STATUS_NO_MEMORY
329	jmp .return	329	jmp .return
330	.nocache:	330	.nocache:
331	; step 5, after correcting number of sectors to fit in partition limits	331	; step 5, after correcting number of sectors to fit in partition limits
332	; and advancing partition-relative sector to absolute,	332	; and advancing partition-relative sector to absolute,
333	; sees that cache is disabled: pass corrected request to the driver	333	; sees that cache is disabled: pass corrected request to the driver
334	lea eax, [.num_sectors]	334	lea eax, [.num_sectors]
335	push eax ; numsectors	335	push eax ; numsectors
336	push [.sector_hi+4] ; startsector	336	push [.sector_hi+4] ; startsector
337	push [.sector_lo+8] ; startsector	337	push [.sector_lo+8] ; startsector
338	push [.buffer+12] ; buffer	338	push [.buffer+12] ; buffer
339	mov esi, [ebp+PARTITION.Disk]	339	mov esi, [ebp+PARTITION.Disk]
340	mov al, DISKFUNC.read	340	mov al, DISKFUNC.read
341	call disk_call_driver	341	call disk_call_driver
342	test eax, eax	342	test eax, eax
343	jnz @f	343	jnz @f
344	mov eax, [.error_code]	344	mov eax, [.error_code]
345	@@:	345	@@:
346	mov ecx, [.num_sectors]	346	mov ecx, [.num_sectors]
347	jmp .nothing	347	jmp .nothing
348	.end_of_media:	348	.end_of_media:
349	; requested sector is beyond the partition end: return the corresponding error	349	; requested sector is beyond the partition end: return the corresponding error
350	mov [.error_code], DISK_STATUS_END_OF_MEDIA	350	mov [.error_code], DISK_STATUS_END_OF_MEDIA
351	jmp .return	351	jmp .return
352		352
353	; Write several sequential sectors using cache #1.	353	; Write several sequential sectors using cache #1.
354	; in: edx:eax = start sector	354	; in: edx:eax = start sector
355	; in: ecx = number of sectors to write	355	; in: ecx = number of sectors to write
356	; in: ebx -> buffer	356	; in: ebx -> buffer
357	; in: ebp -> PARTITION	357	; in: ebp -> PARTITION
358	; out: eax = error code, 0 = ok	358	; out: eax = error code, 0 = ok
359	; out: ecx = number of sectors that were written	359	; out: ecx = number of sectors that were written
360	fs_write64_sys:	360	fs_write64_sys:
361	; Save ebx, set ebx to SysCache and let the common part do its work.	361	; Save ebx, set ebx to SysCache and let the common part do its work.
362	push ebx	362	push ebx
363	mov ebx, [ebp+PARTITION.Disk]	363	mov ebx, [ebp+PARTITION.Disk]
364	add ebx, DISK.SysCache	364	add ebx, DISK.SysCache
365	jmp fs_write64_common	365	jmp fs_write64_common
366		366
367	; Write several sequential sectors using cache #2.	367	; Write several sequential sectors using cache #2.
368	; in: edx:eax = start sector	368	; in: edx:eax = start sector
369	; in: ecx = number of sectors to write	369	; in: ecx = number of sectors to write
370	; in: ebx -> buffer	370	; in: ebx -> buffer
371	; in: ebp -> PARTITION	371	; in: ebp -> PARTITION
372	; out: eax = error code, 0 = ok	372	; out: eax = error code, 0 = ok
373	; out: ecx = number of sectors that were written	373	; out: ecx = number of sectors that were written
374	fs_write64_app:	374	fs_write64_app:
375	; Save ebx, set ebx to AppCache and let the common part do its work.	375	; Save ebx, set ebx to AppCache and let the common part do its work.
376	push ebx	376	push ebx
377	mov ebx, [ebp+PARTITION.Disk]	377	mov ebx, [ebp+PARTITION.Disk]
378	add ebx, DISK.AppCache	378	add ebx, DISK.AppCache
379		379
380	; Common part of fs_write64_{app,sys}:	380	; Common part of fs_write64_{app,sys}:
381	; write several sequential sectors using the given cache.	381	; write several sequential sectors using the given cache.
382	fs_write64_common:	382	fs_write64_common:
383	; 1. Setup stack frame.	383	; 1. Setup stack frame.
384	push esi edi ; save used registers to be stdcall	384	push esi edi ; save used registers to be stdcall
385	push 0 ; initialize .error_code	385	push 0 ; initialize .error_code
386	push edx eax ecx ecx ; initialize stack variables	386	push edx eax ecx ecx ; initialize stack variables
387	push [.buffer-4] ; copy [.buffer] to [.cur_buffer]	387	push [.buffer-4] ; copy [.buffer] to [.cur_buffer]
388	; -4 is due to esp-relative addressing	388	; -4 is due to esp-relative addressing
389	virtual at esp	389	virtual at esp
390	.local_vars:	390	.local_vars:
391	.cur_buffer dd ? ; pointer to data that are currently copying	391	.cur_buffer dd ? ; pointer to data that are currently copying
392	.num_sectors_orig dd ?	392	.num_sectors_orig dd ?
393	; Number of sectors that should be written. Used to generate output value of ecx.	393	; Number of sectors that should be written. Used to generate output value of ecx.
394	.num_sectors dd ?	394	.num_sectors dd ?
395	; Number of sectors that remain to be written.	395	; Number of sectors that remain to be written.
396	.sector_lo dd ? ; low 32 bits of the current sector	396	.sector_lo dd ? ; low 32 bits of the current sector
397	.sector_hi dd ? ; high 32 bits of the current sector	397	.sector_hi dd ? ; high 32 bits of the current sector
398	.error_code dd ? ; current status	398	.error_code dd ? ; current status
399	.local_vars_size = $ - .local_vars	399	.local_vars_size = $ - .local_vars
400	.saved_regs rd 2	400	.saved_regs rd 2
401	.buffer dd ? ; filled by fs_write64_{sys,app}	401	.buffer dd ? ; filled by fs_write64_{sys,app}
402	end virtual	402	end virtual
403	; 2. Validate parameters against partition length:	403	; 2. Validate parameters against partition length:
404	; immediately return error if edx:eax are beyond partition end,	404	; immediately return error if edx:eax are beyond partition end,
405	; decrease .num_sectors and .num_sectors_orig, if needed,	405	; decrease .num_sectors and .num_sectors_orig, if needed,
406	; so that the entire operation fits in the partition limits.	406	; so that the entire operation fits in the partition limits.
407	mov eax, dword [ebp+PARTITION.Length]	407	mov eax, dword [ebp+PARTITION.Length]
408	mov edx, dword [ebp+PARTITION.Length+4]	408	mov edx, dword [ebp+PARTITION.Length+4]
409	sub eax, [.sector_lo]	409	sub eax, [.sector_lo]
410	sbb edx, [.sector_hi]	410	sbb edx, [.sector_hi]
411	jb .end_of_media	411	jb .end_of_media
412	jnz .no_end_of_media	412	jnz .no_end_of_media
413	cmp ecx, eax	413	cmp ecx, eax
414	jbe .no_end_of_media	414	jbe .no_end_of_media
415	; If .num_sectors got decreased, set status to DISK_STATUS_END_OF_MEDIA;	415	; If .num_sectors got decreased, set status to DISK_STATUS_END_OF_MEDIA;
416	; if all subsequent operations would be successful, this would become the final	416	; if all subsequent operations would be successful, this would become the final
417	; status, otherwise this would be rewritten by failed operation.	417	; status, otherwise this would be rewritten by failed operation.
418	mov [.num_sectors], eax	418	mov [.num_sectors], eax
419	mov [.num_sectors_orig], eax	419	mov [.num_sectors_orig], eax
420	mov [.error_code], DISK_STATUS_END_OF_MEDIA	420	mov [.error_code], DISK_STATUS_END_OF_MEDIA
421	.no_end_of_media:	421	.no_end_of_media:
422	; 3. If number of sectors to write is zero, either because zero-sectors operation	422	; 3. If number of sectors to write is zero, either because zero-sectors operation
423	; was requested or because it got decreased to zero due to partition limits,	423	; was requested or because it got decreased to zero due to partition limits,
424	; just return the current status.	424	; just return the current status.
425	cmp [.num_sectors], 0	425	cmp [.num_sectors], 0
426	jz .return	426	jz .return
427	; 4. Shift sector from partition-relative to absolute.	427	; 4. Shift sector from partition-relative to absolute.
428	mov eax, dword [ebp+PARTITION.FirstSector]	428	mov eax, dword [ebp+PARTITION.FirstSector]
429	mov edx, dword [ebp+PARTITION.FirstSector+4]	429	mov edx, dword [ebp+PARTITION.FirstSector+4]
430	add [.sector_lo], eax	430	add [.sector_lo], eax
431	adc [.sector_hi], edx	431	adc [.sector_hi], edx
432	; 5. If the cache is disabled, pass the request directly to the driver.	432	; 5. If the cache is disabled, pass the request directly to the driver.
433	cmp [ebx+DISKCACHE.pointer], 0	433	cmp [ebx+DISKCACHE.pointer], 0
434	jz .nocache	434	jz .nocache
435	; 6. Store sectors in the cache, sequentially from the beginning.	435	; 6. Store sectors in the cache, sequentially from the beginning.
436	; 6a. Acquire the lock.	436	; 6a. Acquire the lock.
437	mov ecx, [ebp+PARTITION.Disk]	437	mov ecx, [ebp+PARTITION.Disk]
438	add ecx, DISK.CacheLock	438	add ecx, DISK.CacheLock
439	call mutex_lock	439	call mutex_lock
440	.lookup_in_cache_loop:	440	.lookup_in_cache_loop:
441	; 6b. For each sector, call the lookup function with adding to the cache, if not yet.	441	; 6b. For each sector, call the lookup function with adding to the cache, if not yet.
442	mov eax, [.sector_lo]	442	mov eax, [.sector_lo]
443	mov edx, [.sector_hi]	443	mov edx, [.sector_hi]
444	call cache_lookup_write	444	call cache_lookup_write
445	test eax, eax	445	test eax, eax
446	jnz .cache_error	446	jnz .cache_error
447	; 6c. For each sector, copy data, mark the item as modified and not saved,	447	; 6c. For each sector, copy data, mark the item as modified and not saved,
448	; advance .current_buffer to the next sector.	448	; advance .current_buffer to the next sector.
449	mov [esi+CACHE_ITEM.Status], CACHE_ITEM_MODIFIED	449	mov [esi+CACHE_ITEM.Status], CACHE_ITEM_MODIFIED
450	mov eax, 1	450	mov eax, 1
451	shl eax, cl	451	shl eax, cl
452	mov esi, [.cur_buffer]	452	mov esi, [.cur_buffer]
453	mov ecx, eax	453	mov ecx, eax
454	shr ecx, 2	454	shr ecx, 2
455	rep movsd	455	rep movsd
456	mov [.cur_buffer], esi	456	mov [.cur_buffer], esi
457	; 6d. Remove the sector from the other cache.	457	; 6d. Remove the sector from the other cache.
458	; Normally it should not be there, but prefetching could put to the app cache	458	; Normally it should not be there, but prefetching could put to the app cache
459	; data that normally should belong to the sys cache and vice versa.	459	; data that normally should belong to the sys cache and vice versa.
460	; Note: this requires that both caches must be protected by the same lock.	460	; Note: this requires that both caches must be protected by the same lock.
461	mov eax, [.sector_lo]	461	mov eax, [.sector_lo]
462	mov edx, [.sector_hi]	462	mov edx, [.sector_hi]
463	push ebx	463	push ebx
464	sub ebx, [ebp+PARTITION.Disk]	464	sub ebx, [ebp+PARTITION.Disk]
465	xor ebx, DISK.SysCache xor DISK.AppCache	465	xor ebx, DISK.SysCache xor DISK.AppCache
466	add ebx, [ebp+PARTITION.Disk]	466	add ebx, [ebp+PARTITION.Disk]
467	call cache_lookup_read	467	call cache_lookup_read
468	jc @f	468	jc @f
469	mov [esi+CACHE_ITEM.Status], CACHE_ITEM_EMPTY	469	mov [esi+CACHE_ITEM.Status], CACHE_ITEM_EMPTY
470	@@:	470	@@:
471	pop ebx	471	pop ebx
472	; 6e. Advance .sector_hi:.sector_lo to the next sector.	472	; 6e. Advance .sector_hi:.sector_lo to the next sector.
473	add [.sector_lo], 1	473	add [.sector_lo], 1
474	adc [.sector_hi], 0	474	adc [.sector_hi], 0
475	; 6f. Continue the loop at 6b-6e until all sectors are processed.	475	; 6f. Continue the loop at 6b-6e until all sectors are processed.
476	dec [.num_sectors]	476	dec [.num_sectors]
477	jnz .lookup_in_cache_loop	477	jnz .lookup_in_cache_loop
478	.unlock_return:	478	.unlock_return:
479	; 6g. Release the lock and return.	479	; 6g. Release the lock and return.
480	mov ecx, [ebp+PARTITION.Disk]	480	mov ecx, [ebp+PARTITION.Disk]
481	add ecx, DISK.CacheLock	481	add ecx, DISK.CacheLock
482	call mutex_unlock	482	call mutex_unlock
483	.return:	483	.return:
484	mov eax, [.error_code]	484	mov eax, [.error_code]
485	mov ecx, [.num_sectors_orig]	485	mov ecx, [.num_sectors_orig]
486	sub ecx, [.num_sectors]	486	sub ecx, [.num_sectors]
487	.nothing:	487	.nothing:
488	add esp, .local_vars_size	488	add esp, .local_vars_size
489	pop edi esi ebx	489	pop edi esi ebx
490	ret	490	ret
491		491
492	; Special branches:	492	; Special branches:
493	.cache_error:	493	.cache_error:
494	; error at flushing the cache while adding sector to the cache:	494	; error at flushing the cache while adding sector to the cache:
495	; return the error from the lookup function	495	; return the error from the lookup function
496	mov [.error_code], eax	496	mov [.error_code], eax
497	jmp .unlock_return	497	jmp .unlock_return
498	.end_of_media:	498	.end_of_media:
499	; requested sector is beyond the partition end: return the corresponding error	499	; requested sector is beyond the partition end: return the corresponding error
500	mov eax, DISK_STATUS_END_OF_MEDIA	500	mov eax, DISK_STATUS_END_OF_MEDIA

Subversion Repositories Kolibri OS

(root)/kernel/trunk/blkdev/disk_cache.inc – Rev 5089 → 5095