WebSVN – Kolibri OS – Diff – /kernel/branches/kolibri-process/blkdev/disk_cache.inc

 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;                                                              ;;
-;; Copyright (C) KolibriOS team 2011-2012. All rights reserved. ;;
+;; Copyright (C) KolibriOS team 2011-2014. All rights reserved. ;;
 ;; Distributed under terms of the GNU General Public License    ;;
 ;;                                                              ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+$Revision: 4133 $
+; 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
+        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
+        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.
+        mov     edi, [.buffer]
+        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.
+; Note that buffer in edi is advanced automatically.
+        mov     esi, ecx
+        shl     esi, 9
+        add     esi, [ebx+DISKCACHE.data]
+        mov     ecx, 512/4
+        rep movsd
+; 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     ; 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     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 - 9
+        cmp     ebx, [.num_sectors]
+        jbe     @f
+        mov     ebx, [.num_sectors]
+@@:
+        mov     eax, ebx
+        shl     eax, 9
+        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.
+; Note that buffer in edi is advanced automatically.
+        cmp     [.current_num_sectors], 0
+        jz      .copy_done
+        mov     ecx, [.current_num_sectors]
+        shl     ecx, 9-2
+        mov     esi, [.allocated_buffer]
+        rep movsd
+; 12. Copy data to the cache.
+; 12a. Acquire the lock.
+        mov     ebx, [.cache+.local_vars2_size]
+        mov     ecx, [ebp+PARTITION.Disk]
+        add     ecx, DISK.CacheLock
+        call    mutex_lock
+; 12b. Prepare for the loop: save edi and create a local variable that
+; stores number of sectors to be copied.
+        push    edi
+        push    [.current_num_sectors+4]
+.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+8]
+        mov     edx, [.sector_hi+.local_vars2_size+8]
+        call    cache_lookup_write
+        test    eax, eax
+        jnz     .cache_error
+; 12d. 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+8]
+        mov     edi, ecx
+        shl     edi, 9
+        add     edi, [ebx+DISKCACHE.data]
+        mov     ecx, 512/4
+        rep movsd
+        mov     [.current_buffer+8], esi
+        add     [.sector_lo+.local_vars2_size+8], 1
+        adc     [.sector_hi+.local_vars2_size+8], 0
+; 12e. Continue the loop 12c-12d until all sectors are read.
+        dec     dword [esp]
+        jnz     .store_to_cache
+.cache_error:
+; 12f. Restore after the loop: pop the local variable and restore edi.
+        pop     ecx
+        pop     edi
+; 12g. 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    edi     ; 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     esi, [.cur_buffer]
+        mov     edi, ecx
+        shl     edi, 9
+        add     edi, [ebx+DISKCACHE.data]
+        mov     ecx, 512/4
+        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
 $Revision: 4133 $
 ; 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 ecx, set ecx to SysCache and let the common part do its work.
+; Save ebx, set ebx to SysCache and let the common part do its work.
-        push    ecx
+        push    ebx
-        mov     ecx, [ebp+PARTITION.Disk]
+        mov     ebx, [ebp+PARTITION.Disk]
+        add     ebx, DISK.SysCache
-        add     ecx, DISK.SysCache
+        jmp     fs_read32_common
         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 ecx, set ecx to AppCache and let the common part do its work.
+; Save ebx, set ebx to AppCache and let the common part do its work.
-        push    ecx
+        push    ebx
-        mov     ecx, [ebp+PARTITION.Disk]
+        mov     ebx, [ebp+PARTITION.Disk]
-        add     ecx, DISK.AppCache
+        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     ecx
+        pop     ebx
         ret
 @@:
 ; 2. Get the absolute sector on the disk.
-        push    edx esi
+        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     [ecx+DISKCACHE.pointer], 0
+        cmp     [ebx+DISKCACHE.pointer], 0
         jnz     .scancache
         push    1
         push    esp     ; numsectors
         push    edx     ; startsector
         push    eax     ; startsector
-        push    ebx     ; buffer
+        pushd   [esp+32]; buffer
         mov     esi, [ebp+PARTITION.Disk]
         mov     al, DISKFUNC.read
         call    disk_call_driver
         pop     ecx
-        pop     esi edx
-        pop     ecx
-        ret
+        pop     edi esi edx ecx
-.scancache:
+        pop     ebx
+        ret
-; 4. Scan the cache.
+.scancache:
-        push    edi ecx ; scan cache
+        push    ebx edx eax
-        push    edx eax
+virtual at esp
+.local_vars:
+.sector_lo      dd      ?
+.sector_hi      dd      ?
-virtual at esp
+.cache          dd      ?
-.sector_lo      dd      ?
+.local_vars_size = $ - .local_vars
-.sector_hi      dd      ?
+.saved_regs     rd      4
+.buffer         dd      ?
-.cache          dd      ?
+end virtual
-end virtual
+; 4. Scan for the requested sector in the cache.
-; The following code is inherited from hd_read. The differences are:
+; If found, copy the data and return.
+; 4a. Acquire the lock.
-; all code is protected by the cache lock; instead of static calls
+        mov     ecx, [ebp+PARTITION.Disk]
-; to hd_read_dma/hd_read_pio/bd_read the dynamic call to DISKFUNC.read is used;
+        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
-; sector is 64-bit, not 32-bit.
+; If not found, go to 5.
+        jc      .not_found_in_cache
+.found_in_cache:
-        call    mutex_lock
+; 4c. Copy the data.
-        mov     eax, [.sector_lo]
+        mov     edi, [.buffer]
+        mov     esi, ecx
+        shl     esi, 9
+        add     esi, [ebx+DISKCACHE.data]
+        mov     ecx, 512/4
+        rep movsd
-        mov     edx, [.sector_hi]
+; 4d. Release the lock and return success.
-        mov     esi, [ecx+DISKCACHE.pointer]
+        mov     ecx, [ebp+PARTITION.Disk]
+        add     ecx, DISK.CacheLock
+        call    mutex_unlock
+.return:
+        xor     eax, eax
-        mov     ecx, [ecx+DISKCACHE.sad_size]
+.return_eax:
-        add     esi, 12
+        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)
-        mov     edi, 1
+        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.
+        stdcall kernel_alloc, CACHE_LEGACY_READ_SIZE shl 9
+; 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:
-.hdreadcache:
+.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, 512/4
+        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.
-        cmp     dword [esi+8], 0        ; empty
+        mov     eax, [.sector_lo+.local_vars2_size]
+        mov     edx, [.sector_hi+.local_vars2_size]
+        call    cache_lookup_write
+        test    eax, eax
-        je      .nohdcache
+        jnz     .cache_error
+; 11c. 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     edi, ecx
+        shl     edi, 9
+        add     edi, [ebx+DISKCACHE.data]
+        mov     ecx, 512/4
+        rep movsd
+        mov     [.current_buffer], esi
+        add     [.sector_lo+.local_vars2_size], 1
-        cmp     [esi], eax      ; correct sector
+        adc     [.sector_hi+.local_vars2_size], 0
+; 11d. Continue the loop at 11b-11c until all sectors are processed.
+        dec     [.num_sectors]
+        jnz     .store_to_cache
+.cache_error:
-        jne     .nohdcache
+; 11e. Release the lock.
-        cmp     [esi+4], edx    ; correct sector
+        mov     ecx, [ebp+PARTITION.Disk]
+        add     ecx, DISK.CacheLock
-        je      .yeshdcache
+        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:
-.nohdcache:
+; If no sectors were read, free the buffer allocated at step 7
+; and pass the error to the caller.
+        push    eax
-        add     esi, 12
+        stdcall kernel_free, [.allocated_buffer+4]
+        pop     eax
-        inc     edi
+        add     esp, .local_vars2_size
+        jmp     .return_eax
+.nomemory:
+        mov     eax, DISK_STATUS_NO_MEMORY
+        jmp     .return_eax
-        dec     ecx
+.floppy:
-        jnz     .hdreadcache
+; 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
-        mov     esi, [.cache]
+; 14. Mark the item as empty for the case of read error.
-        call    find_empty_slot64       ; ret in edi
+        mov     [esi+CACHE_ITEM.Status], CACHE_ITEM_EMPTY
-        test    eax, eax
+        push    ecx
-        jnz     .read_done
-        push    1
-        push    esp
+; 15. Call the driver to read one sector.
-        push    edx
+        push    1
-        push    [.sector_lo+12]
+        push    esp
-        mov     ecx, [.cache+16]
+        push    edx
-        mov     eax, edi
+        push    [.sector_lo+16]
-        shl     eax, 9
+        shl     ecx, 9
-        add     eax, [ecx+DISKCACHE.data]
+        add     ecx, [ebx+DISKCACHE.data]
-        push    eax
+        push    ecx
         mov     esi, [ebp+PARTITION.Disk]
-        mov     al, DISKFUNC.read
-        call    disk_call_driver
+        mov     al, DISKFUNC.read
-        pop     ecx
+        call    disk_call_driver
-        dec     ecx
+        pop     ecx
-        jnz     .read_done
+        dec     ecx
-        mov     ecx, [.cache]
+        jnz     .floppy_read_error
-        lea     eax, [edi*3]
+; 16. Get the slot and pointer to the cache item,
-        mov     esi, [ecx+DISKCACHE.pointer]
+; change the status to not-modified copy of the disk
-        lea     esi, [eax*4+esi]
+; and go to 4c.
+        pop     ecx
-        mov     eax, [.sector_lo]
-        mov     edx, [.sector_hi]
-        mov     [esi], eax      ; sector number
+        lea     esi, [ecx*sizeof.CACHE_ITEM/4]
-        mov     [esi+4], edx    ; sector number
+        shl     esi, 2
-        mov     dword [esi+8], 1; hd read - mark as same as in hd
+        add     esi, [ebx+DISKCACHE.pointer]
+        mov     [esi+CACHE_ITEM.Status], CACHE_ITEM_COPY
-.yeshdcache:
-        mov     esi, edi
+        jmp     .found_in_cache
-        mov     ecx, [.cache]
-        shl     esi, 9
-        add     esi, [ecx+DISKCACHE.data]
+; On error at steps 13-15, release the lock
-        mov     edi, ebx
+; and pass the error to the caller.
-        mov     ecx, 512/4
+.floppy_read_error:
-        rep movsd               ; move data
+        pop     ecx
-        xor     eax, eax        ; successful read
+.floppy_cache_error:
-.read_done:
-        mov     ecx, [.cache]
+        mov     ecx, [ebp+PARTITION.Disk]
-        push    eax
-        call    mutex_unlock
+        add     ecx, DISK.CacheLock
-        pop     eax
+        push    eax
-        add     esp, 12
+        call    mutex_unlock
-        pop     edi esi edx ecx
+        pop     eax
-        ret
+        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.
-fs_write32_sys:
+        push    ecx edx
-; Save ecx, set ecx to SysCache and let the common part do its work.
+        xor     edx, edx
-        push    ecx
+        mov     ecx, 1
-        mov     ecx, [ebp+PARTITION.Disk]
+        call    fs_write64_sys
-        add     ecx, DISK.SysCache
+        pop     edx ecx
-        jmp     fs_write32_common
+        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
+; This function is intended to replace the old 'hd_write' function when
-; eax is relative to partition start
-; out: eax = error code; 0 = ok
-fs_write32_app:
-; Save ecx, set ecx to AppCache and let the common part do its work.
-        push    ecx
-        mov     ecx, [ebp+PARTITION.Disk]
-        add     ecx, DISK.AppCache
-; This label is the common part of fs_read32_sys and fs_read32_app.
-fs_write32_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
+; [hdd_appl_data] = 1, so its input/output parameters are the same, except
-        cmp     dword [ebp+PARTITION.Length], eax
-        ja      @f
+; that it can't use the global variables 'hd_error' and 'hdd_appl_data'.
-        mov     eax, DISK_STATUS_END_OF_MEDIA
-        pop     ecx
-        ret
-@@:
-        push    edx esi
-; 2. Get the absolute sector on the disk.
-        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 request to the driver.
-        cmp     [ecx+DISKCACHE.pointer], 0
-        jnz     .scancache
-        push    1
-        push    esp     ; numsectors
+; in: eax = sector, ebx = buffer, ebp = pointer to PARTITION structure
-        push    edx     ; startsector
+; eax is relative to partition start
-        push    eax     ; startsector
+; out: eax = error code; 0 = ok
-        push    ebx     ; buffer
+fs_write32_app:
-        mov     esi, [ebp+PARTITION.Disk]
-        mov     al, DISKFUNC.write
-        call    disk_call_driver
-        pop     ecx
-        pop     esi edx
-        pop     ecx
-        ret
-.scancache:
-; 4. Scan the cache.
-        push    edi ecx ; scan cache
-        push    edx eax
-virtual at esp
-.sector_lo      dd      ?
-.sector_hi      dd      ?
-.cache          dd      ?
-end virtual
-; The following code is inherited from hd_write. The differences are:
-; all code is protected by the cache lock;
-; sector is 64-bit, not 32-bit.
-        call    mutex_lock
-        ; check if the cache already has the sector and overwrite it
-        mov     eax, [.sector_lo]
-        mov     edx, [.sector_hi]
-        mov     esi, [ecx+DISKCACHE.pointer]
-        mov     ecx, [ecx+DISKCACHE.sad_size]
-        add     esi, 12
+; Just call the advanced function.
+        push    ecx edx
-        mov     edi, 1
+        xor     edx, edx
-.hdwritecache:
-        cmp     dword [esi+8], 0        ; if cache slot is empty
-        je      .not_in_cache_write
-        cmp     [esi], eax      ; if the slot has the sector
-        jne     .not_in_cache_write
+        mov     ecx, 1
-        cmp     [esi+4], edx    ; if the slot has the sector
+        call    fs_write64_app
-        je      .yes_in_cache_write
+        pop     edx ecx
-.not_in_cache_write:
+        ret
-        add     esi, 12
-        inc     edi
+; Lookup for the given sector in the given cache.
-        dec     ecx
+; If the sector is not present, return error.
-        jnz     .hdwritecache
+; The caller must acquire the cache lock.
+; in: edx:eax = sector
-        ; sector not found in cache
-        ; write the block to a new location
-        mov     esi, [.cache]
-        call    find_empty_slot64       ; ret in edi
+; in: ebx -> DISKCACHE structure
-        test    eax, eax
-        jne     .hd_write_access_denied
+; out: CF set if sector is not in cache
+; out: ecx = index in cache
+; out: esi -> sector:status
+proc cache_lookup_read
-        mov     ecx, [.cache]
+        mov     esi, [ebx+DISKCACHE.pointer]
+        add     esi, sizeof.CACHE_ITEM
+        mov     ecx, 1
-        lea     eax, [edi*3]
-        mov     esi, [ecx+DISKCACHE.pointer]
-        lea     esi, [eax*4+esi]
+.hdreadcache:
-        mov     eax, [.sector_lo]
-        mov     edx, [.sector_hi]
-        mov     [esi], eax      ; sector number
+        cmp     [esi+CACHE_ITEM.Status], CACHE_ITEM_EMPTY
-        mov     [esi+4], edx    ; sector number
+        je      .nohdcache
-.yes_in_cache_write:
-        mov     dword [esi+8], 2        ; write - differs from hd
-        shl     edi, 9
-        mov     ecx, [.cache]
+        cmp     [esi+CACHE_ITEM.SectorLo], eax
+        jne     .nohdcache
-        add     edi, [ecx+DISKCACHE.data]
+        cmp     [esi+CACHE_ITEM.SectorHi], edx
+        jne     .nohdcache
+        clc
-        mov     esi, ebx
+        ret
+.nohdcache:
+        add     esi, sizeof.CACHE_ITEM
+        inc     ecx
+        cmp     ecx, [ebx+DISKCACHE.sad_size]
+        jbe     .hdreadcache
+        stc
+        ret
-        mov     ecx, 512/4
+endp
         rep movsd               ; move data
-        xor     eax, eax        ; success
+; Lookup for the given sector in the given cache.
-.hd_write_access_denied:
+; If the sector is not present, allocate space for it,
+; possibly flushing data.
+; in: edx:eax = sector
+; in: ebx -> DISKCACHE structure
-        mov     ecx, [.cache]
+; in: ebp -> PARTITION structure
-        push    eax
+; out: eax = error code
-        call    mutex_unlock
+; out: ecx = index in cache
-        pop     eax
+; out: esi -> sector:status
+proc cache_lookup_write
+        call    cache_lookup_read
+        jnc     .return0
-        add     esp, 12
+        push    edx eax
-        pop     edi esi edx ecx
+;-----------------------------------------------------------
+; find empty or read slot, flush cache if next 12.5% is used by write
-        ret
+; output : ecx = cache slot
 ;-----------------------------------------------------------
-; This internal function is called from fs_read32_* and fs_write32_*. It is the
+; Note: the code is essentially inherited, so probably
+; no analysis of efficiency were done.
+; However, it works.
-; analogue of find_empty_slot for 64-bit sectors.
+.search_again:
-find_empty_slot64:
-;-----------------------------------------------------------
-; find empty or read slot, flush cache if next 12.5% is used by write
+        mov     eax, [ebx+DISKCACHE.sad_size]
-; output : edi = cache slot
-;-----------------------------------------------------------
+        mov     ecx, [ebx+DISKCACHE.search_start]
-.search_again:
+        shr     eax, 3
-        mov     ecx, [esi+DISKCACHE.sad_size]
+        lea     esi, [ecx*sizeof.CACHE_ITEM/4]
-        mov     edi, [esi+DISKCACHE.search_start]
+        shl     esi, 2
-        shr     ecx, 3
+        add     esi, [ebx+DISKCACHE.pointer]
 .search_for_empty:
-        inc     edi
+        inc     ecx
-        cmp     edi, [esi+DISKCACHE.sad_size]
+        add     esi, sizeof.CACHE_ITEM
-        jbe     .inside_cache
+        cmp     ecx, [ebx+DISKCACHE.sad_size]
+        jbe     .inside_cache
+        mov     ecx, 1
+        mov     esi, [ebx+DISKCACHE.pointer]
-        mov     edi, 1
+        add     esi, sizeof.CACHE_ITEM
+.inside_cache:
-.inside_cache:
+        cmp     [esi+CACHE_ITEM.Status], CACHE_ITEM_MODIFIED
+        jb      .found_slot             ; it's empty or read
-        lea     eax, [edi*3]
+        dec     eax
+        jnz     .search_for_empty
+        stdcall write_cache64, [ebp+PARTITION.Disk] ; no empty slots found, write all
-        shl     eax, 2
+        test    eax, eax
+        jne     .found_slot_access_denied
-        add     eax, [esi+DISKCACHE.pointer]
+        jmp     .search_again           ; and start again
+.found_slot:
+        mov     [ebx+DISKCACHE.search_start], ecx
+        popd    [esi+CACHE_ITEM.SectorLo]
+        popd    [esi+CACHE_ITEM.SectorHi]
+.return0:
-        cmp     dword [eax+8], 2
+        xor     eax, eax        ; success
+        ret
+.found_slot_access_denied:
+        add     esp, 8
+        ret
+endp
+; Flush the given cache.
-        jb      .found_slot             ; it's empty or read
+; 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
-        dec     ecx
+        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
-        jnz     .search_for_empty
+.size_left      dd      ?       ; items left to scan
+.current_ptr    dd      ?       ; pointer to the current item
+;
-        stdcall write_cache64, [ebp+PARTITION.Disk] ; no empty slots found, write all
+; Write operations are coalesced in chains,
-        test    eax, eax
+; one chain describes a sequential interval of sectors,
-        jne     .found_slot_access_denied
-        jmp     .search_again           ; and start again
+; they can be sequential or scattered in the cache.
-.found_slot:
+.sequential     dd      ?
-        mov     [esi+DISKCACHE.search_start], edi
+; boolean variable, 1 if the current chain is sequential in the cache,
-        xor     eax, eax        ; success
+; 0 if additional buffer is needed to perform the operation
+.chain_start_pos dd     ?       ; slot 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.
-.found_slot_access_denied:
+.iteration_buffer dd    ?       ; temporary buffer for non-sequential chains
+.local_vars_size = $ - .local_vars
+                rd      2       ; saved registers
-        ret
+                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
-; This function is intended to replace the old 'write_cache' function.
+        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:
-proc write_cache64 uses ecx edx esi edi, disk:dword
+        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.
-locals
+; 5. Prepare for chain finding: save the current item, initialize chain variables.
-cache_chain_started     dd      0
+        mov     [.current_ptr], esi
-cache_chain_size        dd      ?
+; Initialize chain as sequential zero-length starting at the current item.
-cache_chain_pos         dd      ?
+        mov     [.chain_start_ptr], esi
+        mov     eax, [ebx+DISKCACHE.sad_size]
+        sub     eax, [.size_left]
+        inc     eax
-cache_chain_ptr         dd      ?
+        mov     [.chain_start_pos], eax
+        mov     [.chain_size], 0
-endl
+        mov     [.sequential], 1
-saved_esi_pos = 16+12 ; size of local variables + size of registers before esi
+; 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]
-; If there is no cache for this disk, nothing to do.
+        sub     eax, 1
-        cmp     [esi+DISKCACHE.pointer], 0
+        sbb     edx, 0
+.find_chain_start:
-        jz      .flush
+; 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.
-; write all changed sectors to disk
+        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], ecx
+.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
-        ; write difference ( 2 ) from cache to DISK
+; ...expand the chain one sector backwards and continue the loop at 6e.
-        mov     ecx, [esi+DISKCACHE.sad_size]
+; Otherwise, advance to step 7 if the previous item describes the correct sector
-        mov     esi, [esi+DISKCACHE.pointer]
+; but is not modified, and return to step 6b otherwise.
+        dec     [.chain_start_pos]
-        add     esi, 12
+        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:
-        mov     edi, 1
+; 9. Write a sequential chain to disk.
+; 9a. Pass the entire chain to the driver.
+        mov     eax, [.chain_start_ptr]
+        mov     edx, [.chain_start_pos]
-.write_cache_more:
+        shl     edx, 9
+        add     edx, [ebx+DISKCACHE.data]
-        cmp     dword [esi+8], 2        ; if cache slot is not different
+        lea     ecx, [.chain_size]
-        jne     .write_chain
+        push    ecx     ; numsectors
-        mov     dword [esi+8], 1        ; same as in hd
+        pushd   [eax+CACHE_ITEM.SectorHi]       ; startsector
-        mov     eax, [esi]
+        pushd   [eax+CACHE_ITEM.SectorLo]       ; startsector
-        mov     edx, [esi+4]            ; edx:eax = sector to write
+        push    edx     ; buffer
-; Объединяем запись цепочки последовательных секторов в одно обращение к диску
-        cmp     ecx, 1
-        jz      .nonext
-        cmp     dword [esi+12+8], 2
+        mov     esi, [ebp+PARTITION.Disk]
-        jnz     .nonext
-        push    eax edx
+        mov     al, DISKFUNC.write
-        add     eax, 1
+        call    disk_call_driver
-        adc     edx, 0
+; 9b. If failed, pass the error code to the driver.
-        cmp     eax, [esi+12]
+        test    eax, eax
-        jnz     @f
+        jnz     .return
-        cmp     edx, [esi+12+4]
+; 9c. If succeeded, mark all sectors in the chain as not-modified,
-@@:
+; advance current item and number of items left to skip the chain.
-        pop     edx eax
+        mov     esi, [.current_ptr]
-        jnz     .nonext
+        mov     eax, [.chain_size]
-        cmp     [cache_chain_started], 1
+        sub     [.size_left], eax
-        jz      @f
+@@:
-        mov     [cache_chain_started], 1
+        mov     [esi+CACHE_ITEM.Status], CACHE_ITEM_COPY
-        mov     [cache_chain_size], 0
+        add     esi, sizeof.CACHE_ITEM
-        mov     [cache_chain_pos], edi
+        dec     eax
-        mov     [cache_chain_ptr], esi
+        jnz     @b
-@@:
+; 9d. Continue the main loop at step 2 if there are more sectors.
+; Return success otherwise.
-        inc     [cache_chain_size]
+        cmp     [.size_left], 0
-        cmp     [cache_chain_size], 16
+        jnz     .look
-        jnz     .continue
-        jmp     .write_chain
+        jmp     .return0
-.nonext:
+.write_non_sequential:
+; Write a non-sequential chain to the disk.
-        call    .flush_cache_chain
+; 10. Allocate a temporary buffer.
-        test    eax, eax
+; Use [.chain_size] sectors, but
-        jnz     .nothing
+; not greater than CACHE_MAX_ALLOC_SIZE bytes
-        mov     [cache_chain_size], 1
+; and not greater than half of free memory.
-        mov     [cache_chain_ptr], esi
+        mov     eax, [pg_data.pages_free]
-        call    .write_cache_sector
-        test    eax, eax
+        shr     eax, 1
-        jnz     .nothing
+        jz      .nomemory
-        jmp     .continue
+        cmp     eax, CACHE_MAX_ALLOC_SIZE shr 12
-.write_chain:
-        call    .flush_cache_chain
-        test    eax, eax
-        jnz     .nothing
+        jbe     @f
-.continue:
+        mov     eax, CACHE_MAX_ALLOC_SIZE shr 12
-        add     esi, 12
+@@:
-        inc     edi
+        shl     eax, 12 - 9
-        dec     ecx
-        jnz     .write_cache_more
+        cmp     eax, [.chain_size]
-        call    .flush_cache_chain
+        jbe     @f
-        test    eax, eax
-        jnz     .nothing
-.flush:
-        mov     esi, [disk]
-        mov     al, DISKFUNC.flush
+        mov     eax, [.chain_size]
-        call    disk_call_driver
-.nothing:
-        ret
+@@:
+        mov     [.iteration_size], eax
-.flush_cache_chain:
-        xor     eax, eax
-        cmp     [cache_chain_started], eax
+        shl     eax, 9
-        jz      @f
-        call    .write_cache_chain
+        stdcall kernel_alloc, eax
-        mov     [cache_chain_started], 0
+        test    eax, eax
-@@:
-        retn
+        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]
-.write_cache_sector:
+        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]
+        shl     esi, 9
+        add     esi, [ebx+DISKCACHE.data]
+        mov     ecx, 512/4
+        rep movsd
+; 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.
+        inc     [.chain_start_pos+24]
+        mov     [.chain_start_ptr+24], esi
+        dec     dword [esp]
-        mov     [cache_chain_size], 1
+        jnz     .copy_loop
-        mov     [cache_chain_pos], edi
+        jmp     .copy_done
-.write_cache_chain:
+.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, ecx/esi may contain
+; garbage; we are not going to use them in this case.
+        call    cache_lookup_read
-        pusha
+        mov     [.chain_start_pos+24], ecx
+        mov     [.chain_start_ptr+24], esi
-        mov     edi, [cache_chain_pos]
+        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
-        mov     ecx, [ebp-saved_esi_pos]
+; 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.
-        shl     edi, 9
+        test    eax, eax
-        add     edi, [ecx+DISKCACHE.data]
+        jnz     .nonsequential_error
-        mov     ecx, [cache_chain_size]
+        sub     [.chain_size], ecx
-        push    ecx
+        jnz     .write_non_sequential_iteration
-        push    esp     ; numsectors
+; 16. The chain is written. Free the temporary buffer
         dbgstr 'no memory for disk cache'
         jmp     .nothing
 @@:
 ; 3. Fill two DISKCACHE structures.
         mov     [esi+DISK.SysCache.pointer], eax
-        lea     ecx, [esi+DISK.SysCache.mutex]
-        call    mutex_init
-        lea     ecx, [esi+DISK.AppCache.mutex]
+        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
 ; 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]
-; The algorithm is straightforward.
+        call    mutex_lock
-        push    esi
+        push    ebx
         push    esi     ; for second write_cache64
         push    esi     ; for first write_cache64
-        add     esi, DISK.SysCache
+        lea     ebx, [esi+DISK.SysCache]
         call    write_cache64
-        add     esi, DISK.AppCache - DISK.SysCache
+        add     ebx, DISK.AppCache - DISK.SysCache
         call    write_cache64
+        pop     ebx
+        lea     ecx, [esi+DISK.CacheLock]
+        call    mutex_unlock
+.nothing:
+        mov     al, DISKFUNC.flush
-        pop     esi
+        call    disk_call_driver

Subversion Repositories Kolibri OS

(root)/kernel/branches/kolibri-process/blkdev/disk_cache.inc – Rev 4429 → 4457