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: 4465 $
+$Revision: 5089 $
 ; Read/write functions try to do large operations,
 ; it is significantly faster than several small operations.
         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.
         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.
+; 6d. Copy data for the caller, advance [.buffer].
+        mov     esi, edi
-; Note that buffer in edi is advanced automatically.
+        mov     edi, [.buffer]
-        mov     esi, ecx
+        mov     eax, 1
-        shl     esi, 9
+        shl     eax, cl
-        add     esi, [ebx+DISKCACHE.data]
+        mov     ecx, eax
-        mov     ecx, 512/4
+        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.
 ; 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 - 9
+        shl     ebx, 12
+        shr     ebx, cl
+        jz      .nomemory
         cmp     ebx, [.num_sectors]
         jbe     @f
         mov     ebx, [.num_sectors]
 @@:
         mov     eax, ebx
-        shl     eax, 9
+        shl     eax, cl
         stdcall kernel_alloc, eax
 ; If failed, return the appropriate error code.
         test    eax, eax
         jz      .nomemory
         mov     esi, eax
 ; If failed, save error code.
         test    eax, eax
         jz      @f
         mov     [.error_code+.local_vars2_size], eax
 @@:
-; 11. Copy data for the caller.
+; 11. Copy data for the caller, advance .buffer.
-; Note that buffer in edi is advanced automatically.
         cmp     [.current_num_sectors], 0
         jz      .copy_done
+        mov     ebx, [.cache+.local_vars2_size]
-        mov     ecx, [.current_num_sectors]
+        mov     eax, [.current_num_sectors]
+        mov     ecx, [ebx+DISKCACHE.sector_size_log]
-        shl     ecx, 9-2
+        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     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
+; 12b. Prepare for the loop: create a local variable that
 ; stores number of sectors to be copied.
-        push    edi
-        push    [.current_num_sectors+4]
+        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+8]
+        mov     eax, [.sector_lo+.local_vars2_size+4]
-        mov     edx, [.sector_hi+.local_vars2_size+8]
+        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, ecx
+        mov     esi, edi
+        mov     edi, [.buffer+.local_vars2_size+4]
-        shl     esi, 9
+        mov     eax, [esp]
-        add     esi, [ebx+DISKCACHE.data]
+        shl     eax, cl
-        mov     edi, [esp+4]
+        sub     edi, eax
-        mov     ecx, [esp]
+        mov     eax, 1
-        shl     ecx, 9-2
+        shl     eax, cl
-        sub     edi, ecx
+        mov     ecx, eax
-        mov     ecx, 512/4
+        shr     ecx, 2
         rep movsd
-        add     [.current_buffer+8], 512
+        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     esi, [.current_buffer+8]
+        mov     eax, 1
-        mov     edi, ecx
+        shl     eax, cl
-        shl     edi, 9
+        mov     esi, [.current_buffer+4]
-        add     edi, [ebx+DISKCACHE.data]
+        mov     ecx, eax
-        mov     ecx, 512/4
+        shr     ecx, 2
         rep movsd
-        mov     [.current_buffer+8], esi
+        mov     [.current_buffer+4], esi
 .sector_done:
-        add     [.sector_lo+.local_vars2_size+8], 1
+        add     [.sector_lo+.local_vars2_size+4], 1
-        adc     [.sector_hi+.local_vars2_size+8], 0
+        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 and restore edi.
+; 12g. Restore after the loop: pop the local variable.
         pop     ecx
-        pop     edi
 ; 12h. Release the lock.
         mov     ecx, [ebp+PARTITION.Disk]
         add     ecx, DISK.CacheLock
         call    mutex_unlock
 .copy_done:
 ; 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
+        push    [.buffer+12]    ; buffer
         mov     esi, [ebp+PARTITION.Disk]
         mov     al, DISKFUNC.read
         call    disk_call_driver
         test    eax, eax
         jnz     @f
         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     edi, ecx
+        mov     ecx, eax
-        shl     edi, 9
+        shr     ecx, 2
-        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.
         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     esi, ecx
+        mov     eax, 1
-        shl     esi, 9
+        shl     eax, cl
-        add     esi, [ebx+DISKCACHE.data]
+        mov     ecx, eax
-        mov     ecx, 512/4
+        shr     ecx, 2
         rep movsd
 ; 4d. Release the lock and return success.
         mov     ecx, [ebp+PARTITION.Disk]
         add     ecx, DISK.CacheLock
         call    mutex_unlock
 ; 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
+        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
         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, 512/4
+        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
         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], 512
+        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     edi, ecx
+        mov     ecx, eax
-        shl     edi, 9
+        shr     ecx, 2
-        add     edi, [ebx+DISKCACHE.data]
-        mov     ecx, 512/4
         rep movsd
         mov     [.current_buffer], esi
 .sector_done:
         add     [.sector_lo+.local_vars2_size], 1
         adc     [.sector_hi+.local_vars2_size], 0
 ; 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    ecx
+        push    esi
 ; 14. Call the driver to read one sector.
         push    1
         push    esp
         push    edx
-        push    [.sector_lo+16]
-        shl     ecx, 9
-        add     ecx, [ebx+DISKCACHE.data]
+        push    [.sector_lo+16]
-        push    ecx
+        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     ecx
-        lea     esi, [ecx*sizeof.CACHE_ITEM/4]
-        shl     esi, 2
-        add     esi, [ebx+DISKCACHE.pointer]
+        pop     esi
         mov     [esi+CACHE_ITEM.Status], CACHE_ITEM_COPY
         jmp     .found_in_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 = index 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     ecx, 1
+        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
-        cmp     [esi+CACHE_ITEM.SectorLo], eax
+        jne     .nohdcache
-        jne     .nohdcache
+        mov     ecx, [ebx+DISKCACHE.sector_size_log]
-        cmp     [esi+CACHE_ITEM.SectorHi], edx
+        shl     edi, cl
-        jne     .nohdcache
+        add     edi, [ebx+DISKCACHE.data]
         clc
         ret
 .nohdcache:
         add     esi, sizeof.CACHE_ITEM
 ; possibly flushing data.
 ; in: edx:eax = sector
 ; in: ebx -> DISKCACHE structure
 ; in: ebp -> PARTITION structure
 ; out: eax = error code
-; out: ecx = index in cache
 ; out: esi -> sector:status
+; out: edi -> sector data
 proc cache_lookup_write
         call    cache_lookup_read
         jnc     .return0
         push    edx eax
 ;-----------------------------------------------------------
 .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
 ; 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     ?       ; slot of chain start item
+.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.
 ; 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,
 ; 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
+        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]
         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
-        dec     [.chain_start_pos]
+        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.
         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]
-        mov     edx, [.chain_start_pos]
-        shl     edx, 9
-        add     edx, [ebx+DISKCACHE.data]
         lea     ecx, [.chain_size]
         push    ecx     ; numsectors
         pushd   [eax+CACHE_ITEM.SectorHi]       ; startsector
         pushd   [eax+CACHE_ITEM.SectorLo]       ; startsector
-        push    edx     ; buffer
+        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
         jz      .nomemory
         cmp     eax, CACHE_MAX_ALLOC_SIZE shr 12
         jbe     @f
         mov     eax, CACHE_MAX_ALLOC_SIZE shr 12
 @@:
-        shl     eax, 12 - 9
+        shl     eax, 12
+        shr     eax, cl
+        jz      .nomemory
         cmp     eax, [.chain_size]
         jbe     @f
         mov     eax, [.chain_size]
 @@:
         mov     [.iteration_size], eax
-        shl     eax, 9
+        shl     eax, cl
         stdcall kernel_alloc, eax
         test    eax, eax
         jz      .nomemory
         mov     [.iteration_buffer], eax
 .write_non_sequential_iteration:
         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     esi, 9
+        shl     eax, cl
-        add     esi, [ebx+DISKCACHE.data]
+        mov     ecx, eax
-        mov     ecx, 512/4
+        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.
         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]
+        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, ecx/esi may contain
+; 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+24], ecx
+        mov     [.chain_start_pos+28], edi
-        mov     [.chain_start_ptr+24], esi
+        mov     [.chain_start_ptr+28], esi
+        pop     edi
         dec     dword [esp]
         jnz     .copy_loop
 .copy_done:
 ; 13g. Restore the stack after 13a.
         pop     ecx
 ; 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
-; 1. Calculate the suggested cache size.
+; 2. Calculate the suggested cache size.
-; 1a. Get the size of free physical memory in pages.
+; 2a. Get the size of free physical memory in pages.
         mov     eax, [pg_data.pages_free]
-; 1b. Use the value to calculate the size.
+; 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
-; 1c. Force lower and upper limits.
+; 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
 @@:
-; 1d. Give a chance to the driver to adjust the size.
+; 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
-; 2. Allocate memory for the cache.
+; 3. Allocate memory for the cache.
-; 2a. Call the allocator.
+; 3a. Call the allocator.
         stdcall kernel_alloc, eax
         test    eax, eax
         jnz     @f
-; 2b. If it failed, say a message and return with eax = 0.
+; 3b. If it failed, say a message and return with eax = 0.
         dbgstr 'no memory for disk cache'
         jmp     .nothing
 @@:
-; 3. Fill two DISKCACHE structures.
+; 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]
         imul    eax, 7
         mov     [esi+DISK.AppCache.data_size], eax
         mov     [esi+DISK.AppCache.pointer], edx
-        mov     eax, [esi+DISK.SysCache.data_size]
-        push    ebx
+        mov     eax, [esi+DISK.SysCache.data_size]
-        call    calculate_for_hd64
-        pop     ebx
+        call    calculate_cache_slots
         add     eax, [esi+DISK.SysCache.pointer]
         mov     [esi+DISK.SysCache.data], eax
         mov     [esi+DISK.SysCache.sad_size], ecx
         xor     eax, eax
         rep stosd
         pop     edi
-        mov     eax, [esi+DISK.AppCache.data_size]
-        push    ebx
+        mov     eax, [esi+DISK.AppCache.data_size]
-        call    calculate_for_hd64
-        pop     ebx
+        call    calculate_cache_slots
         add     eax, [esi+DISK.AppCache.pointer]
         mov     [esi+DISK.AppCache.data], eax
         mov     [esi+DISK.AppCache.sad_size], ecx
         lea     ecx, [(ecx+1)*3]
         xor     eax, eax
         rep stosd
         pop     edi
-; 4. Return with nonzero al.
+; 5. Return with nonzero al.
         mov     al, 1
-; 5. Return.
+; 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_for_hd64:
+calculate_cache_slots:
         push    eax
-        mov     ebx, eax
+        mov     ecx, [esi+DISK.MediaInfo.SectorSize]
-        shr     eax, 9
+        add     ecx, sizeof.CACHE_ITEM
-        lea     eax, [eax*3]
+        xor     edx, edx
-        shl     eax, 2
+        div     ecx
-        sub     ebx, eax
+        mov     ecx, eax
-        shr     ebx, 9
-        mov     ecx, ebx
+        imul    eax, [esi+DISK.MediaInfo.SectorSize]
-        shl     ebx, 9
-        pop     eax
+        sub     [esp], eax
-        sub     eax, ebx
+        pop     eax
         dec     ecx

Subversion Repositories Kolibri OS

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