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


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                              ;;
;; Copyright (C) KolibriOS team 2011-2015. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License    ;;
;;                                                              ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
$Revision: 6827 $
 
; =============================================================================
; ================================= Constants =================================
; =============================================================================
; Error codes for callback functions.
DISK_STATUS_OK              = 0 ; success
DISK_STATUS_GENERAL_ERROR   = -1; if no other code is suitable
DISK_STATUS_INVALID_CALL    = 1 ; invalid input parameters
DISK_STATUS_NO_MEDIA        = 2 ; no media present
DISK_STATUS_END_OF_MEDIA    = 3 ; end of media while reading/writing data
DISK_STATUS_NO_MEMORY       = 4 ; insufficient memory for driver operation
; Driver flags. Represent bits in DISK.DriverFlags.
DISK_NO_INSERT_NOTIFICATION = 1
; Media flags. Represent bits in DISKMEDIAINFO.Flags.
DISK_MEDIA_READONLY = 1
 
; If too many partitions are detected,there is probably an error on the disk.
; 256 partitions should be enough for any reasonable use.
; Also, the same number is limiting the number of MBRs to process; if
; too many MBRs are visible,there probably is a loop in the MBR structure.
MAX_NUM_PARTITIONS = 256
 
; =============================================================================
; ================================ Structures =================================
; =============================================================================
; This structure defines all callback functions for working with the physical
; device. They are implemented by a driver. Objects with this structure reside
; in a driver.
struct  DISKFUNC
        strucsize       dd ?
; Size of the structure. This field is intended for possible extensions of
; this structure. If a new function is added to this structure and a driver
; implements an old version, the caller can detect this by checking .strucsize,
; so the driver remains compatible.
        close           dd ?
; The pointer to the function which frees all driver-specific resources for
; the disk.
; Optional, may be NULL.
; void close(void* userdata);
        closemedia      dd ?
; The pointer to the function which informs the driver that the kernel has
; finished all processing with the current media. If media is removed, the
; driver should decline all requests to that media with DISK_STATUS_NO_MEDIA,
; even if new media is inserted, until this function is called. If media is
; removed, a new call to 'disk_media_changed' is not allowed until this
; function is called.
; Optional, may be NULL (if media is not removable).
; void closemedia(void* userdata);
        querymedia      dd ?
; The pointer to the function which determines capabilities of the media.
; int querymedia(void* userdata, DISKMEDIAINFO* info);
; Return value: one of DISK_STATUS_*
        read            dd ?
; The pointer to the function which reads data from the device.
; int read(void* userdata, void* buffer, __int64 startsector, int* numsectors);
; input: *numsectors = number of sectors to read
; output: *numsectors = number of sectors which were successfully read
; Return value: one of DISK_STATUS_*
        write           dd ?
; The pointer to the function which writes data to the device.
; Optional, may be NULL.
; int write(void* userdata, void* buffer, __int64 startsector, int* numsectors);
; input: *numsectors = number of sectors to write
; output: *numsectors = number of sectors which were successfully written
; Return value: one of DISK_STATUS_*
        flush           dd ?
; The pointer to the function which flushes the internal device cache.
; Optional, may be NULL.
; int flush(void* userdata);
; Return value: one of DISK_STATUS_*
; Note that read/write are called by the cache manager, so a driver should not
; create a software cache. This function is implemented for flushing a hardware
; cache, if it exists.
        adjust_cache_size       dd ?
; The pointer to the function which returns the cache size for this device.
; Optional, may be NULL.
; unsigned int adjust_cache_size(unsigned int suggested_size);
; Return value: 0 = disable cache, otherwise = used cache size in bytes.
ends
 
; This structure holds information on a medium.
; Objects with this structure are allocated by the kernel as a part of the DISK
; structure and are filled by a driver in the 'querymedia' callback.
struct  DISKMEDIAINFO
        Flags           dd ?
; Combination of DISK_MEDIA_* bits.
        SectorSize      dd ?
; Size of the sector.
        Capacity        dq ?
; Size of the media in sectors.
ends
 
; This structure represents the disk cache. To follow the old implementation,
; there are two distinct caches for a disk, one for "system" data,and the other
; for "application" data.
struct  DISKCACHE
; The following fields are inherited from data32.inc:cache_ideX.
        pointer         dd ?
        data_size       dd ?    ; unused
        data            dd ?
        sad_size        dd ?
        search_start    dd ?
        sector_size_log dd ?
ends
 
; This structure represents a disk device and its media for the kernel.
; This structure is allocated by the kernel in the 'disk_add' function,
; freed in the 'disk_dereference' function.
struct  DISK
; Fields of disk object
        Next            dd ?
        Prev            dd ?
; All disk devices are linked in one list with these two fields.
; Head of the list is the 'disk_list' variable.
        Functions       dd ?
; Pointer to the 'DISKFUNC' structure with driver functions.
        Name            dd ?
; Pointer to the string used for accesses through the global filesystem.
        UserData        dd ?
; This field is passed to all callback functions so a driver can decide which
; physical device is addressed.
        DriverFlags     dd ?
; Bitfield. Currently only DISK_NO_INSERT_NOTIFICATION bit is defined.
; If it is set, the driver will never issue 'disk_media_changed' notification
; with argument set to true, so the kernel must try to detect media during
; requests from the file system.
        RefCount        dd ?
; Count of active references to this structure. One reference is kept during
; the lifetime of the structure between 'disk_add' and 'disk_del'.
; Another reference is taken during any filesystem operation for this disk.
; One reference is added if media is inserted.
; The structure is destroyed when the reference count decrements to zero:
; this usually occurs in 'disk_del', but can be delayed to the end of last
; filesystem operation, if one is active.
        MediaLock       MUTEX
; Lock to protect the MEDIA structure. See the description after
; 'disk_list_mutex' for the locking strategy.
; Fields of media object
        MediaInserted   db ?
; 0 if media is not inserted, nonzero otherwise.
        MediaUsed       db ?
; 0 if media fields are not used, nonzero otherwise. If .MediaRefCount is
; nonzero, this field is nonzero too; however, when .MediaRefCount goes
; to zero, there is some time interval during which media object is still used.
                        dw ? ; padding
; The following fields are not valid unless either .MediaInserted is nonzero
; or they are accessed from a code which has obtained the reference when
; .MediaInserted was nonzero.
        MediaRefCount   dd ?
; Count of active references to the media object. One reference is kept during
; the lifetime of the media between two calls to 'disk_media_changed'.
; Another reference is taken during any filesystem operation for this media.
; The callback 'closemedia' is called when the reference count decrements to
; zero: this usually occurs in 'disk_media_changed', but can be delayed to the
; end of the last filesystem operation, if one is active.
        MediaInfo       DISKMEDIAINFO
; This field keeps information on the current media.
        NumPartitions   dd ?
; Number of partitions on this media.
        Partitions      dd ?
; Pointer to array of .NumPartitions pointers to PARTITION structures.
        cache_size      dd ?
; inherited from cache_ideX_size
        CacheLock       MUTEX
; Lock to protect both caches.
        SysCache        DISKCACHE
        AppCache        DISKCACHE
; Two caches for the disk.
ends
 
; This structure represents one partition for the kernel. This is a base
; template, the actual contents after common fields is determined by the
; file system code for this partition.
struct  PARTITION
        FirstSector     dq ?
; First sector of the partition.
        Length          dq ?
; Length of the partition in sectors.
        Disk            dd ?
; Pointer to parent DISK structure.
        FSUserFunctions dd ?
; Handlers for the sysfunction 70h. This field is a pointer to the following
; array. The first dword is pointer to disconnect handler.
; The first dword is a number of supported subfunctions, other dwords
; point to handlers of corresponding subfunctions.
; ...fs-specific data may follow...
ends
 
; This is an external structure, it represents an entry in the partition table.
struct  PARTITION_TABLE_ENTRY
        Bootable        db ?
; 80h = bootable partition, 0 = non-bootable partition, other values = invalid
        FirstHead       db ?
        FirstSector     db ?
        FirstTrack      db ?
; Coordinates of first sector in CHS.
        Type            db ?
; Partition type, one of predefined constants. 0 = empty, several types denote
; extended partition (see process_partition_table_entry), we are not interested
; in other values.
        LastHead        db ?
        LastSector      db ?
        LastTrack       db ?
; Coordinates of last sector in CHS.
        FirstAbsSector  dd ?
; Coordinate of first sector in LBA.
        Length          dd ?
; Length of the partition in sectors.
ends
 
; GUID Partition Table Header, UEFI 2.6, Table 18
struct GPTH
        Signature                rb 8
; 'EFI PART'
        Revision                 dd ?
; 0x00010000
        HeaderSize               dd ?
; Size of this header in bytes, must fit to one sector.
        HeaderCRC32              dd ?
; Set this field to zero, compute CRC32 via 0xEDB88320, compare.
        Reserved                 dd ?
; Myst be zero.
        MyLBA                    dq ?
; LBA of the sector containing this GPT header.
        AlternateLBA             dq ?
; LBA of the sector containing the other GPT header.
; AlternateLBA of Primary GPTH points to Backup one and vice versa.
        FirstUsableLBA           dq ?
; Only sectors between first and last UsableLBA may form partitions
        LastUsableLBA            dq ?
        DiskGUID                 rb 16
; Globally Unique IDentifier
        PartitionEntryLBA        dq ?
; First LBA of Partition Entry Array.
; Length in bytes is computed as a product of two following fields.
        NumberOfPartitionEntries dd ?
; Actual number of partitions depends on the contents of Partition Entry Array.
; A partition entry is unused if zeroed.
        SizeOfPartitionEntry     dd ?   ; in bytes
        PartitionEntryArrayCRC32 dd ?
; Same CRC as for GPT header.
ends
 
; GPT Partition Entry, UEFI 2.6, Table 19
struct GPE
        PartitionTypeGUID       rb 16
        UniquePartitionGUID     rb 16
        StartingLBA             dq ?
        EndingLBA               dq ?
; Length in sectors is EndingLBA - StartingLBA + 1.
        Attributes              dq ?
        PartitionName           rb 72
ends
 
; =============================================================================
; ================================ Global data ================================
; =============================================================================
iglobal
; The pseudo-item for the list of all DISK structures.
; Initialized to the empty list.
disk_list:
        dd      disk_list
        dd      disk_list
endg
uglobal
; This mutex guards all operations with the global list of DISK structures.
disk_list_mutex MUTEX
; * There are two dependent objects, a disk and a media. In the simplest case,
;   disk and media are both non-removable. However, in the general case both
;   can be removed at any time, simultaneously or only media,and this makes things
;   complicated.
; * For efficiency, both disk and media objects are located in the one
;   structure named DISK. However, logically they are different.
; * The following operations use data of disk object: adding (disk_add);
;   deleting (disk_del); filesystem (fs_lfn which eventually calls
;   dyndisk_handler or dyndisk_enum_root).
; * The following operations use data of media object: adding/removing
;   (disk_media_changed); filesystem (fs_lfn which eventually calls
;   dyndisk_handler; dyndisk_enum_root doesn't work with media).
; * Notifications disk_add, disk_media_changed, disk_del are synchronized
;   between themselves, this is a requirement for the driver. However, file
;   system operations are asynchronous, can be issued at any time by any
;   thread.
; * We must prevent a situation when a filesystem operation thinks that the
;   object is still valid but in fact the notification has destroyed the
;   object. So we keep a reference counter for both disk and media and destroy
;   the object when this counter goes to zero.
; * The driver must know when it is safe to free driver-allocated resources.
;   The object can be alive even after death notification has completed.
;   We use special callbacks to satisfy both assertions: 'close' for the disk
;   and 'closemedia' for the media. The destruction of the object includes
;   calling the corresponding callback.
; * Each filesystem operation keeps one reference for the disk and one
;   reference for the media. Notification disk_del forces notification on the
;   media death, so the reference counter for the disk is always not less than
;   the reference counter for the media.
; * Two operations "get the object" and "increment the reference counter" can
;   not be done simultaneously. We use a mutex to guard the consistency here.
;   It must be a part of the container for the object, so that this mutex can
;   be acquired as a part of getting the object from the container. The
;   container for disk object is the global list, and this list is guarded by
;   'disk_list_mutex'. The container for media object is the disk object, and
;   the corresponding mutex is DISK.MediaLock.
; * Notifications do not change the data of objects, they can only remove
;   objects. Thus we don't need another synchronization at this level. If two
;   filesystem operations are referencing the same filesystem data, this is
;   better resolved at the level of the filesystem.
endg
 
iglobal
; The function 'disk_scan_partitions' needs three sector-sized buffers for
; MBR, bootsector and fs-temporary sector data. It can not use the static
; buffers always, since it can be called for two or more disks in parallel.
; However, this case is not typical. We reserve three static 512-byte buffers
; and a flag that these buffers are currently used. If 'disk_scan_partitions'
; detects that the buffers are currently used, it allocates buffers from the
; heap. Also, the heap is used when sector size is other than 512.
; The flag is implemented as a global dword variable. When the static buffers
; are not used, the value is -1. When the static buffers are used, the value
; is normally 0 and temporarily can become greater. The function increments
; this value. If the resulting value is zero, it uses the buffers and
; decrements the value when the job is done. Otherwise, it immediately
; decrements the value and uses buffers from the heap, allocated in the
; beginning and freed in the end.
partition_buffer_users  dd      -1
endg
uglobal
; The static buffers for MBR, bootsector and fs-temporary sector data.
align 16
mbr_buffer      rb      512
bootsect_buffer rb      512
fs_tmp_buffer   rb      512
endg
 
iglobal
; This is the array of default implementations of driver callbacks.
; Same as DRIVERFUNC structure except for the first field; all functions must
; have the default implementations.
align 4
disk_default_callbacks:
        dd      disk_default_close
        dd      disk_default_closemedia
        dd      disk_default_querymedia
        dd      disk_default_read
        dd      disk_default_write
        dd      disk_default_flush
        dd      disk_default_adjust_cache_size
endg
 
; =============================================================================
; ================================= Functions =================================
; =============================================================================
 
; This function registers a disk device.
; This includes:
; - allocating an internal structure describing this device;
; - registering this structure in the global filesystem.
; The function initializes the disk as if there is no media. If a media is
; present, the function 'disk_media_changed' should be called after this
; function succeeds.
; Parameters:
; [esp+4] = pointer to DISKFUNC structure with the callbacks
; [esp+8] = pointer to name (ASCIIZ string)
; [esp+12] = userdata to be passed to the callbacks as is.
; [esp+16] = flags, bitfield. Currently only DISK_NO_INSERT_NOTIFICATION bit
;            is defined.
; Return value:
; NULL = operation has failed
; non-NULL = handle of the disk. This handle can be used
; in the operations with other Disk* functions.
; The handle is the pointer to the internal structure DISK.
disk_add:
        push    ebx esi         ; save used registers to be stdcall
; 1. Allocate the DISK structure.
; 1a. Call the heap manager.
        movi    eax, sizeof.DISK
        call    malloc
; 1b. Check the result. If allocation failed, return (go to 9) with eax = 0.
        test    eax, eax
        jz      .nothing
; 2. Copy the disk name to the DISK structure.
; 2a. Get length of the name, including the terminating zero.
        mov     ebx, [esp+8+8]  ; ebx = pointer to name
        push    eax             ; save allocated pointer to DISK
        xor     eax, eax        ; the argument of malloc() is in eax
@@:
        inc     eax
        cmp     byte [ebx+eax-1], 0
        jnz     @b
; 2b. Call the heap manager.
        call    malloc
; 2c. Check the result. If allocation failed, go to 7.
        pop     esi             ; restore allocated pointer to DISK
        test    eax, eax
        jz      .free
; 2d. Store the allocated pointer to the DISK structure.
        mov     [esi+DISK.Name], eax
; 2e. Copy the name.
@@:
        mov     dl, [ebx]
        mov     [eax], dl
        inc     ebx
        inc     eax
        test    dl, dl
        jnz     @b
; 3. Copy other arguments of the function to the DISK structure.
        mov     eax, [esp+4+8]
        mov     [esi+DISK.Functions], eax
        mov     eax, [esp+12+8]
        mov     [esi+DISK.UserData], eax
        mov     eax, [esp+16+8]
        mov     [esi+DISK.DriverFlags], eax
; 4. Initialize other fields of the DISK structure.
; Media is not inserted, reference counter is 1.
        lea     ecx, [esi+DISK.MediaLock]
        call    mutex_init
        xor     eax, eax
        mov     dword [esi+DISK.MediaInserted], eax
        mov     [esi+DISK.MediaRefCount], eax
        inc     eax
        mov     [esi+DISK.RefCount], eax
; The DISK structure is initialized.
; 5. Insert the new structure to the global list.
; 5a. Acquire the mutex.
        mov     ecx, disk_list_mutex
        call    mutex_lock
; 5b. Insert item to the tail of double-linked list.
        mov     edx, disk_list
        list_add_tail esi, edx     ;esi= new edx= list head
; 5c. Release the mutex.
        call    mutex_unlock
; 6. Return with eax = pointer to DISK.
        xchg    eax, esi
        jmp     .nothing
.free:
; Memory allocation for DISK structure succeeded, but for disk name failed.
; 7. Free the DISK structure.
        xchg    eax, esi
        call    free
; 8. Return with eax = 0.
        xor     eax, eax
.nothing:
; 9. Return.
        pop     esi ebx         ; restore used registers to be stdcall
        ret     16              ; purge 4 dword arguments to be stdcall
 
; This function deletes a disk device from the global filesystem.
; This includes:
; - removing a media including all partitions;
; - deleting this structure from the global filesystem;
; - dereferencing the DISK structure and possibly destroying it.
; Parameters:
; [esp+4] = handle of the disk, i.e. the pointer to the DISK structure.
; Return value: none.
disk_del:
        push    esi         ; save used registers to be stdcall
; 1. Force media to be removed. If the media is already removed, the
; call does nothing.
        mov     esi, [esp+4+4]  ; esi = handle of the disk
        stdcall disk_media_changed, esi, 0
; 2. Delete the structure from the global list.
; 2a. Acquire the mutex.
        mov     ecx, disk_list_mutex
        call    mutex_lock
; 2b. Delete item from double-linked list.
        mov     eax, [esi+DISK.Next]
        mov     edx, [esi+DISK.Prev]
        mov     [eax+DISK.Prev], edx
        mov     [edx+DISK.Next], eax
; 2c. Release the mutex.
        call    mutex_unlock
; 3. The structure still has one reference created in disk_add. Remove this
; reference. If there are no other references, disk_dereference will free the
; structure.
        call    disk_dereference
; 4. Return.
        pop     esi             ; restore used registers to be stdcall
        ret     4               ; purge 1 dword argument to be stdcall
 
; This is an internal function which removes a previously obtained reference
; to the disk. If this is the last reference, this function lets the driver
; finalize all associated data, and afterwards frees the DISK structure.
; esi = pointer to DISK structure
disk_dereference:
; 1. Decrement reference counter. Use atomic operation to correctly handle
; possible simultaneous calls.
        lock dec [esi+DISK.RefCount]
; 2. If the result is nonzero, there are other references, so nothing to do.
; In this case, return (go to 4).
        jnz     .nothing
; 3. If we are here, we just removed the last reference and must destroy the
; disk object.
; 3a. Call the driver.
        mov     al, DISKFUNC.close
        stdcall disk_call_driver
; 3b. Free the structure.
        xchg    eax, esi
        push    ebx
        call    free
        pop     ebx
; 4. Return.
.nothing:
        ret
 
; This is an internal function which removes a previously obtained reference
; to the media. If this is the last reference, this function calls 'closemedia'
; callback to signal the driver that the processing has finished and it is safe
; to inform about a new media.
; esi = pointer to DISK structure
disk_media_dereference:
; 1. Decrement reference counter. Use atomic operation to correctly handle
; possible simultaneous calls.
        lock dec [esi+DISK.MediaRefCount]
; 2. If the result is nonzero, there are other references, so nothing to do.
; In this case, return (go to 4).
        jnz     .nothing
; 3. If we are here, we just removed the last reference and must destroy the
; media object.
; Note that the same place inside the DISK structure is reused for all media
; objects, so we must guarantee that reusing does not happen while freeing.
; Reusing is only possible when someone processes a new media. There are two
; mutually exclusive variants:
; * driver issues media insert notifications (DISK_NO_INSERT_NOTIFICATION bit
;   in DISK.DriverFlags is not set). In this case, we require from the driver
;   that such notification (except for the first one) can occur only after a
;   call to 'closemedia' callback.
; * driver does not issue media insert notifications. In this case, the kernel
;   itself must sometimes check whether media is inserted. We have the flag
;   DISK.MediaUsed, visible to the kernel. This flag signals to the other parts
;   of kernel that the way is free.
; In the first case other parts of the kernel do not use DISK.MediaUsed, so it
; does not matter when this flag is cleared. In the second case this flag must
; be cleared after all other actions, including call to 'closemedia'.
; 3a. Free all partitions.
        push    esi edi
        mov     edi, [esi+DISK.NumPartitions]
        mov     esi, [esi+DISK.Partitions]
        test    edi, edi
        jz      .nofree
.freeloop:
        lodsd
        mov     ecx, [eax+PARTITION.FSUserFunctions]
        call    dword [ecx]
        dec     edi
        jnz     .freeloop
.nofree:
        pop     edi esi
; 3b. Free the cache.
        call    disk_free_cache
; 3c. Call the driver.
        mov     al, DISKFUNC.closemedia
        stdcall disk_call_driver
; 3d. Clear the flag.
        mov     [esi+DISK.MediaUsed], 0
.nothing:
        ret
 
; This function is called by the driver and informs the kernel that the media
; has changed. If the media is non-removable, it is called exactly once
; immediately after 'disk_add' and once from 'disk_del'.
; Parameters:
; [esp+4] = handle of the disk, i.e. the pointer to the DISK structure.
; [esp+8] = new status of the media: zero = no media, nonzero = media inserted.
disk_media_changed:
        push    ebx esi edi             ; save used registers to be stdcall
; 1. Remove the existing media, if it is present.
        mov     esi, [esp+4+12]         ; esi = pointer to DISK
; 1a. Check whether it is present. Since DISK.MediaInserted is changed only
; in this function and calls to this function are synchronized, no lock is
; required for checking.
        cmp     [esi+DISK.MediaInserted], 0
        jz      .noremove
; We really need to remove the media.
; 1b. Acquire mutex.
        lea     ecx, [esi+DISK.MediaLock]
        call    mutex_lock
; 1c. Clear the flag.
        mov     [esi+DISK.MediaInserted], 0
; 1d. Release mutex.
        call    mutex_unlock
; 1e. Remove the "lifetime" reference and possibly destroy the structure.
        call    disk_media_dereference
.noremove:
; 2. Test whether there is new media.
        cmp     dword [esp+8+12], 0
        jz      .noinsert
; Yep, there is.
; 3. Process the new media. We assume that all media fields are available to
; use, see comments in 'disk_media_dereference' (this covers using by previous
; media referencers) and note that calls to this function are synchronized
; (this covers using by new media referencers).
; 3a. Call the 'querymedia' callback.
; .Flags are set to zero for possible future extensions.
        lea     edx, [esi+DISK.MediaInfo]
        and     [edx+DISKMEDIAINFO.Flags], 0
        mov     al, DISKFUNC.querymedia
        stdcall disk_call_driver, edx
; 3b. Check the result of the callback. Abort if it failed.
        test    eax, eax
        jnz     .noinsert
; 3c. Allocate the cache unless disabled by the driver. Abort if failed.
        call    disk_init_cache
        test    al, al
        jz      .noinsert
; 3d. Acquire the lifetime reference for the media object.
        inc     [esi+DISK.MediaRefCount]
; 3e. Scan for partitions. Ignore result; the list of partitions is valid even
; on errors.
        call    disk_scan_partitions
; 3f. Media is inserted and available for use.
        inc     [esi+DISK.MediaInserted]
.noinsert:
; 4. Return.
        pop     edi esi ebx             ; restore used registers to be stdcall
        ret     8                       ; purge 2 dword arguments to be stdcall
 
; This function is a thunk for all functions of a disk driver.
; It checks whether the referenced function is implemented in the driver.
; If so, this function jumps to the function in the driver.
; Otherwise, it jumps to the default implementation.
; al = offset of function in the DISKFUNC structure;
; esi = pointer to the DISK structure;
; stack is the same as for the corresponding function except that the
; first parameter (void* userdata) is prepended automatically.
disk_call_driver:
        movzx   eax, al ; eax = offset of function in the DISKFUNC structure
; 1. Prepend the first argument to the stack.
        pop     ecx     ; ecx = return address
        push    [esi+DISK.UserData]     ; add argument
        push    ecx     ; save return address
; 2. Check that the required function is inside the table. If not, go to 5.
        mov     ecx, [esi+DISK.Functions]
        cmp     eax, [ecx+DISKFUNC.strucsize]
        jae     .default
; 3. Check that the required function is implemented. If not, go to 5.
        mov     ecx, [ecx+eax]
        test    ecx, ecx
        jz      .default
; 4. Jump to the required function.
        jmp     ecx
.default:
; 5. Driver does not implement the required function; use default implementation.
        jmp     dword [disk_default_callbacks+eax-4]
 
; The default implementation of DISKFUNC.querymedia.
disk_default_querymedia:
        movi    eax, DISK_STATUS_INVALID_CALL
        ret     8
 
; The default implementation of DISKFUNC.read and DISKFUNC.write.
disk_default_read:
disk_default_write:
        movi    eax, DISK_STATUS_INVALID_CALL
        ret     20
 
; The default implementation of DISKFUNC.close, DISKFUNC.closemedia and
; DISKFUNC.flush.
disk_default_close:
disk_default_closemedia:
disk_default_flush:
        xor     eax, eax
        ret     4
 
; The default implementation of DISKFUNC.adjust_cache_size.
disk_default_adjust_cache_size:
        mov     eax, [esp+8]
        ret     8
 
; This is an internal function called from 'disk_media_changed' when a new media
; is detected. It creates the list of partitions for the media.
; If media is not partitioned, then the list consists of one partition which
; covers all the media.
; esi = pointer to the DISK structure.
disk_scan_partitions:
; 1. Initialize .NumPartitions and .Partitions fields as zeros: empty list.
        and     [esi+DISK.NumPartitions], 0
        and     [esi+DISK.Partitions], 0
; 2. Acquire the buffer for MBR and bootsector tests. See the comment before
; the 'partition_buffer_users' variable.
        mov     eax, [esi+DISK.MediaInfo.SectorSize]
        cmp     eax, 512
        jnz     @f
        mov     ebx, mbr_buffer         ; assume the global buffer is free
        lock inc [partition_buffer_users]
        jz      .buffer_acquired        ; yes, it is free
        lock dec [partition_buffer_users]       ; no, we must allocate
@@:
        lea     eax, [eax*3]
        stdcall kernel_alloc, eax
        test    eax, eax
        jz      .nothing
        xchg    eax, ebx
.buffer_acquired:
; MBR/EBRs are organized in the chain. We use a loop over MBR/EBRs, but no
; more than MAX_NUM_PARTITION times.
; 3. Prepare things for the loop.
; ebp will hold the sector number for current MBR/EBR.
; [esp] will hold the sector number for current extended partition, if there
; is one.
; [esp+4] will hold the counter that prevents long loops.
        push    ebp             ; save ebp
        push    MAX_NUM_PARTITIONS      ; the counter of max MBRs to process
        xor     ebp, ebp        ; start from sector zero
        push    ebp             ; no extended partition yet
; 4. MBR is 512 bytes long. If sector size is less than 512 bytes,
; assume no MBR, no partitions and go to 11.
        cmp     [esi+DISK.MediaInfo.SectorSize], 512
        jb      .notmbr
.new_mbr:
; 5. Read the current sector.
; Note that 'read' callback operates with 64-bit sector numbers, so we must
; push additional zero as a high dword of sector number.
        mov     al, DISKFUNC.read
        push    1
        stdcall disk_call_driver, ebx, ebp, 0, esp
        pop     ecx
; 6. If the read has failed, abort the loop.
        dec     ecx
        jnz     .mbr_failed
; 7. Check the MBR/EBR signature. If it is wrong, abort the loop.
; Soon we will access the partition table which starts at ebx+0x1BE,
; so we can fill its address right now. If we do it now, then the addressing
; [ecx+0x40] is shorter than [ebx+0x1fe]: one-byte offset vs 4-bytes offset.
        lea     ecx, [ebx+0x1be]        ; ecx -> partition table
        cmp     word [ecx+0x40], 0xaa55
        jnz     .mbr_failed
; 8. The MBR is treated differently from EBRs. For MBR we additionally need to
; execute step 10 and possibly step 11.
        test    ebp, ebp
        jnz     .mbr
; 9. Handle GUID Partition Table
; 9a. Check if MBR is protective
        call    is_protective_mbr
        jnz     .no_gpt
; 9b. If so, try to scan GPT headers
        call    disk_scan_gpt
; 9c. If any GPT header is valid, ignore MBR
        jz      .done
; Otherwise process legacy/protective MBR
.no_gpt:
; The partition table can be present or not present. In the first case, we just
; read the MBR. In the second case, we just read the bootsector for a
; filesystem.
; The following algorithm is used to distinguish between these cases.
; A. If at least one entry of the partition table is invalid, this is
;    a bootsector. See the description of 'is_partition_table_entry' for
;    definition of validity.
; B. If all entries are empty (filesystem type field is zero) and the first
;    byte is jmp opcode (0EBh or 0E9h), this is a bootsector which happens to
;    have zeros in the place of partition table.
; C. Otherwise, this is an MBR.
; 10. Test for MBR vs bootsector.
; 10a. Check entries. If any is invalid, go to 11 (rule A).
        call    is_partition_table_entry
        jc      .notmbr
        add     ecx, 10h
        call    is_partition_table_entry
        jc      .notmbr
        add     ecx, 10h
        call    is_partition_table_entry
        jc      .notmbr
        add     ecx, 10h
        call    is_partition_table_entry
        jc      .notmbr
; 10b. Check types of the entries. If at least one is nonzero, go to 12 (rule C).
        mov     al, [ecx-30h+PARTITION_TABLE_ENTRY.Type]
        or      al, [ecx-20h+PARTITION_TABLE_ENTRY.Type]
        or      al, [ecx-10h+PARTITION_TABLE_ENTRY.Type]
        or      al, [ecx+PARTITION_TABLE_ENTRY.Type]
        jnz     .mbr
; 10c. Empty partition table or bootsector with many zeroes? (rule B)
        cmp     byte [ebx], 0EBh
        jz      .notmbr
        cmp     byte [ebx], 0E9h
        jnz     .mbr
.notmbr:
; 11. This is not an  MBR. The media is not partitioned. Create one partition
; which covers all the media and abort the loop.
        stdcall disk_add_partition, 0, 0, \
                dword [esi+DISK.MediaInfo.Capacity], dword [esi+DISK.MediaInfo.Capacity+4], esi
        jmp     .done
.mbr:
; 12. Process all entries of the new MBR/EBR
        lea     ecx, [ebx+0x1be]        ; ecx -> partition table
        push    0       ; assume no extended partition
        call    process_partition_table_entry
        add     ecx, 10h
        call    process_partition_table_entry
        add     ecx, 10h
        call    process_partition_table_entry
        add     ecx, 10h
        call    process_partition_table_entry
        pop     ebp
; 13. Test whether we found a new EBR and should continue the loop.
; 13a. If there was no next EBR, return.
        test    ebp, ebp
        jz      .done
; Ok, we have EBR.
; 13b. EBRs addresses are relative to the start of extended partition.
; For simplicity, just abort if an 32-bit overflow occurs; large disks
; are most likely partitioned with GPT, not MBR scheme, since the precise
; calculation here would increase limit just twice at the price of big
; compatibility problems.
        pop     eax     ; load extended partition
        add     ebp, eax
        jc      .mbr_failed
; 13c. If extended partition has not yet started, start it.
        test    eax, eax
        jnz     @f
        mov     eax, ebp
@@:
; 13d. If the limit is not exceeded, continue the loop.
        dec     dword [esp]
        push    eax     ; store extended partition
        jnz     .new_mbr
.mbr_failed:
.done:
; 14. Cleanup after the loop.
        pop     eax     ; not important anymore
        pop     eax     ; not important anymore
        pop     ebp     ; restore ebp
; 15. Release the buffer.
; 15a. Test whether it is the global buffer or we have allocated it.
        cmp     ebx, mbr_buffer
        jz      .release_partition_buffer
; 15b. If we have allocated it, free it.
        xchg    eax, ebx
        call    free
        jmp     .nothing
; 15c. Otherwise, release reference.
.release_partition_buffer:
        lock dec [partition_buffer_users]
.nothing:
; 16. Return.
        ret
 
 
; This function is called from disk_scan_partitions to validate and parse
; primary and backup GPTs.
proc disk_scan_gpt
; Scan primary GPT (second sector)
        stdcall scan_gpt, 1, 0
        test    eax, eax
; There is no code to restore backup GPT if it's corrupt.
; Therefore just exit if Primary GPT has been parsed successfully.
        jz      .exit
        DEBUGF  1, 'K : Primary GPT is corrupt, trying backup one\n'
        mov     eax, dword[esi+DISK.MediaInfo.Capacity+0]
        mov     edx, dword[esi+DISK.MediaInfo.Capacity+4]
        sub     eax, 1
        sbb     edx, 0
; Scan backup GPT (last sector)
        stdcall scan_gpt, eax, edx
        test    eax, eax
        jz      .exit
        DEBUGF  1, 'K : Backup GPT is also corrupt, fallback to legacy MBR\n'
.exit:
; Return value is ZF
        ret
endp
 
 
; This function is called from disk_scan_gpt to process a single GPT.
proc scan_gpt _mylba:qword
locals
        GPEA_len dd ?   ; Length of GPT Partition Entry Array in bytes
endl
        push    ebx edi
; Allocalte memory for GPT header
        mov     eax, [esi+DISK.MediaInfo.SectorSize]
        stdcall kernel_alloc, eax
        test    eax, eax
        jz      .fail
; Save pointer to stack, just in case
        push    eax
        mov     ebx, eax
; Read GPT header
        mov     al, DISKFUNC.read
        push    1
        stdcall disk_call_driver, ebx, dword[_mylba+0], dword[_mylba+4], esp
        pop     ecx
        test    eax, eax
        jnz     .fail_free_gpt
; Check signature
        cmp     dword[ebx+GPTH.Signature+0], 'EFI '
        jnz     .fail_free_gpt
        cmp     dword[ebx+GPTH.Signature+4], 'PART'
        jnz     .fail_free_gpt
; Check Revision
        cmp     [ebx+GPTH.Revision], 0x00010000
        jnz     .fail_free_gpt
; Compute and check CRC32
        xor     edx, edx
        xchg    edx, [ebx+GPTH.HeaderCRC32]
        mov     eax, -1
        stdcall crc_32, 0xEDB88320, ebx, [ebx+GPTH.HeaderSize]
        xor     eax, -1
        cmp     eax, edx
        jnz     .fail_free_gpt
; Reserved must be zero
        cmp     [ebx+GPTH.Reserved], 0
        jnz     .fail_free_gpt
; MyLBA of GPT header at LBA X must equal X
        mov     eax, dword[ebx+GPTH.MyLBA+0]
        mov     edx, dword[ebx+GPTH.MyLBA+4]
        cmp     eax, dword[_mylba+0]
        jnz     .fail_free_gpt
        cmp     edx, dword[_mylba+4]
        jnz     .fail_free_gpt
; Capacity - MyLBA = AlternateLBA
        mov     eax, dword[esi+DISK.MediaInfo.Capacity+0]
        mov     edx, dword[esi+DISK.MediaInfo.Capacity+4]
        sub     eax, dword[_mylba+0]
        sbb     edx, dword[_mylba+4]
        cmp     eax, dword[ebx+GPTH.AlternateLBA+0]
; DISK.MediaInfo.Capacity is -1 for ATA devices, disable this check for now.
;        jnz     .fail_free_gpt
        cmp     edx, dword[ebx+GPTH.AlternateLBA+4]
;        jnz     .fail_free_gpt
 
; Compute GPT Partition Entry Array (GPEA) length in bytes
        mov     eax, [ebx+GPTH.NumberOfPartitionEntries]
        mul     [ebx+GPTH.SizeOfPartitionEntry]
        test    edx, edx        ; far too big
        jnz     .fail_free_gpt
; Round up to sector boundary
        mov     ecx, [esi+DISK.MediaInfo.SectorSize]    ; power of two
        dec     ecx
        add     eax, ecx
        jc      .fail_free_gpt  ; too big
        not     ecx
        and     eax, ecx
; We will need this length to compute CRC32 of GPEA
        mov     [GPEA_len], eax
; Allocate memory for GPEA
        stdcall kernel_alloc, eax
        test    eax, eax
        jz      .fail_free_gpt
; Save to not juggle with registers
        push    eax
        mov     edi, eax
        mov     eax, [GPEA_len]
        xor     edx, edx
; Get the number of sectors GPEA fits into
        div     [esi+DISK.MediaInfo.SectorSize]
        push    eax     ; esp = pointer to the number of sectors
        mov     al, DISKFUNC.read
        stdcall disk_call_driver, edi, dword[ebx+GPTH.PartitionEntryLBA+0], \
                dword[ebx+GPTH.PartitionEntryLBA+4], esp
        pop     ecx
        test    eax, eax
        jnz     .fail_free_gpea_gpt
; Compute and check CRC32 of GPEA
        mov     edx, [ebx+GPTH.PartitionEntryArrayCRC32]
        mov     eax, -1
        stdcall crc_32, 0xEDB88320, edi, [GPEA_len]
        xor     eax, -1
        cmp     eax, edx
        jnz     .fail_free_gpea_gpt
 
; Process partitions, skip zeroed ones.
.next_gpe:
        xor     eax, eax
        mov     ecx, [ebx+GPTH.SizeOfPartitionEntry]
        repz scasb
        jz      .skip
        add     edi, ecx
        sub     edi, [ebx+GPTH.SizeOfPartitionEntry]
; Length of a partition in sectors is EndingLBA - StartingLBA + 1
        mov     eax, dword[edi+GPE.EndingLBA+0]
        mov     edx, dword[edi+GPE.EndingLBA+4]
        sub     eax, dword[edi+GPE.StartingLBA+0]
        sbb     edx, dword[edi+GPE.StartingLBA+4]
        add     eax, 1
        adc     edx, 0
        stdcall disk_add_partition, dword[edi+GPE.StartingLBA+0], \
                dword[edi+GPE.StartingLBA+4], eax, edx, esi
        add     edi, [ebx+GPTH.SizeOfPartitionEntry]
.skip:
        dec     [ebx+GPTH.NumberOfPartitionEntries]
        jnz     .next_gpe
 
; Pointers to GPT header and GPEA are on the stack
        stdcall kernel_free
        stdcall kernel_free
        pop     edi ebx
        xor     eax, eax
        ret
.fail_free_gpea_gpt:
        stdcall kernel_free
.fail_free_gpt:
        stdcall kernel_free
.fail:
        pop     edi ebx
        xor     eax, eax
        inc     eax
        ret
endp
 
; ecx = pointer to partition records array (MBR + 446)
is_protective_mbr:
        push    ecx edi
        xor     eax, eax
        cmp     [ecx-6], eax
        jnz     .exit
        cmp     [ecx-2], eax
        jnz     .exit
; Partition record 0 has specific fields
        cmp     dword[ecx+0], 0x00020000
        jnz     .exit
        cmp     byte[ecx+4], 0xEE
        jnz     .exit
        cmp     dword[ecx+8], 1
        jnz     .exit
; DISK.MediaInfo.Capacity is -1 for ATA devices, disable this check for now.
;        cmp     dword[esi+DISK.MediaInfo.Capacity+4], eax
;        mov     edi, 0xFFFFFFFF
;        jnz     @f
;        mov     edi, dword[esi+DISK.MediaInfo.Capacity+0]
;        dec     edi
;@@:
;        cmp     dword[ecx+12], edi
;        jnz     .exit
 
; Check that partition records 1-3 are filled with zero
        lea     edi, [ecx+16]
        mov     ecx, 16*3/2     ; 3 partitions
        repz scasw
.exit:
        pop     edi ecx
; Return value is ZF
        ret
 
; This is an internal function called from disk_scan_partitions. It checks
; whether the entry pointed to by ecx is a valid entry of partition table.
; The entry is valid if the first byte is 0 or 80h, the first sector plus the
; length is less than twice the size of media. Multiplication by two is
; required since the size mentioned in the partition table can be slightly
; greater than the real size.
is_partition_table_entry:
; 1. Check .Bootable field.
        mov     al, [ecx+PARTITION_TABLE_ENTRY.Bootable]
        and     al, 7Fh
        jnz     .invalid
; 3. Calculate first sector + length. Note that .FirstAbsSector is relative
; to the MBR/EBR, so the real sum is ebp + .FirstAbsSector + .Length.
        mov     eax, ebp
        xor     edx, edx
        add     eax, [ecx+PARTITION_TABLE_ENTRY.FirstAbsSector]
        adc     edx, 0
        add     eax, [ecx+PARTITION_TABLE_ENTRY.Length]
        adc     edx, 0
; 4. Divide by two.
        shr     edx, 1
        rcr     eax, 1
; 5. Compare with capacity. If the subtraction (edx:eax) - .Capacity does not
; overflow, this is bad.
        sub     eax, dword [esi+DISK.MediaInfo.Capacity]
        sbb     edx, dword [esi+DISK.MediaInfo.Capacity+4]
        jnc     .invalid
.valid:
; 5. Return success: CF is cleared.
        clc
        ret
.invalid:
; 6. Return fail: CF is set.
        stc
        ret
 
; This is an internal function called from disk_scan_partitions. It processes
; the entry pointed to by ecx.
; * If the entry is invalid, just ignore this entry.
; * If the type is zero, just ignore this entry.
; * If the type is one of types for extended partition, store the address
;   of this partition as the new MBR in [esp+4].
; * Otherwise, add the partition to the list of partitions for this disk.
;   We don't use the type from the entry to identify the file system;
;   fs-specific checks do this more reliably.
process_partition_table_entry:
; 1. Check for valid entry. If invalid, return (go to 5).
        call    is_partition_table_entry
        jc      .nothing
; 2. Check for empty entry. If invalid, return (go to 5).
        mov     al, [ecx+PARTITION_TABLE_ENTRY.Type]
        test    al, al
        jz      .nothing
; 3. Check for extended partition. If extended, go to 6.
irp type,\
    0x05,\                 ; DOS: extended partition
    0x0f,\                 ; WIN95: extended partition, LBA-mapped
    0xc5,\                 ; DRDOS/secured: extended partition
    0xd5                   ; Old Multiuser DOS secured: extended partition
{
        cmp     al, type
        jz      .extended
}
; 4. If we are here, that is a normal partition. Add it to the list.
; Note that the first sector is relative to MBR/EBR.
        mov     eax, ebp
        xor     edx, edx
        add     eax, [ecx+PARTITION_TABLE_ENTRY.FirstAbsSector]
        adc     edx, 0
        push    ecx
        stdcall disk_add_partition, eax, edx, \
                [ecx+PARTITION_TABLE_ENTRY.Length], 0, esi
        pop     ecx
.nothing:
; 5. Return.
        ret
.extended:
; 6. If we are here, that is an extended partition. Store the address.
        mov     eax, [ecx+PARTITION_TABLE_ENTRY.FirstAbsSector]
        mov     [esp+4], eax
        ret
 
; This is an internal function called from disk_scan_partitions and
; process_partition_table_entry. It adds one partition to the list of
; partitions for the media.
; Important note: start, length, disk MUST be present and
; MUST be in the same order as in PARTITION structure.
; esi duplicates [disk].
proc disk_add_partition stdcall uses ebx edi, start:qword, length:qword, disk:dword
; 1. Check that this partition will not exceed the limit on total number.
        cmp     [esi+DISK.NumPartitions], MAX_NUM_PARTITIONS
        jae     .nothing
; 2. Check that this partition does not overlap with any already registered
; partition. Since any file system assumes that the disk data will not change
; outside of its control, such overlap could be destructive.
; Since the number of partitions is usually very small and is guaranteed not
; to be large, the simple linear search is sufficient.
; 2a. Prepare the loop: edi will point to the current item of .Partitions
; array, ecx will be the current item, ebx will hold number of items left.
        mov     edi, [esi+DISK.Partitions]
        mov     ebx, [esi+DISK.NumPartitions]
        test    ebx, ebx
        jz      .partitionok
.scan_existing:
; 2b. Get the next partition.
        mov     ecx, [edi]
        add     edi, 4
; The range [.FirstSector, .FirstSector+.Length) must be either entirely to
; the left of [start, start+length) or entirely to the right.
; 2c. Subtract .FirstSector - start. The possible overflow distinguish between
; cases "to the left" (2e) and "to the right" (2d).
        mov     eax, dword [ecx+PARTITION.FirstSector]
        mov     edx, dword [ecx+PARTITION.FirstSector+4]
        sub     eax, dword [start]
        sbb     edx, dword [start+4]
        jb      .less
; 2d. .FirstSector is greater than or equal to start. Check that .FirstSector
; is greater than or equal to start+length; the subtraction
; (.FirstSector-start) - length must not cause overflow. Go to 2g if life is
; good or to 2f in the other case.
        sub     eax, dword [length]
        sbb     edx, dword [length+4]
        jb      .overlap
        jmp     .next_existing
.less:
; 2e. .FirstSector is less than start. Check that .FirstSector+.Length is less
; than or equal to start. If the addition (.FirstSector-start) + .Length does
; not cause overflow, then .FirstSector + .Length is strictly less than start;
; since the equality is also valid, use decrement preliminarily. Go to 2g or
; 2f depending on the overflow.
        sub     eax, 1
        sbb     edx, 0
        add     eax, dword [ecx+PARTITION.Length]
        adc     edx, dword [ecx+PARTITION.Length+4]
        jnc     .next_existing
.overlap:
; 2f. The partition overlaps with previously registered partition. Say warning
; and return with nothing done.
        dbgstr 'two partitions overlap, ignoring the last one'
        jmp     .nothing
.next_existing:
; 2g. The partition does not overlap with the current partition. Continue the
; loop.
        dec     ebx
        jnz     .scan_existing
.partitionok:
; 3. The partition has passed tests. Reallocate the partitions array for a new
; entry.
; 3a. Call the allocator.
        mov     eax, [esi+DISK.NumPartitions]
        inc     eax     ; one more entry
        shl     eax, 2  ; each entry is dword
        call    malloc
; 3b. Test the result. If failed, return with nothing done.
        test    eax, eax
        jz      .nothing
; 3c. Copy the old array to the new array.
        mov     edi, eax
        push    esi
        mov     ecx, [esi+DISK.NumPartitions]
        mov     esi, [esi+DISK.Partitions]
        rep movsd
        pop     esi
; 3d. Set the field in the DISK structure to the new array.
        xchg    [esi+DISK.Partitions], eax
; 3e. Free the old array.
        call    free
; 4. Recognize the file system.
; 4a. Call the filesystem recognizer. It will allocate the PARTITION structure
; with possible filesystem-specific fields.
        call    disk_detect_partition
; 4b. Check return value. If zero, return with list not changed; so far only
; the array was reallocated, this is ok for other code.
        test    eax, eax
        jz      .nothing
; 5. Insert the new partition to the list.
        stosd
        inc     [esi+DISK.NumPartitions]
; 6. Return.
.nothing:
        ret
endp
 
; This is an internal function called from disk_add_partition.
; It tries to recognize the file system on the partition and allocates the
; corresponding PARTITION structure with filesystem-specific fields.
disk_detect_partition:
; This function inherits the stack frame from disk_add_partition. In stdcall
; with ebp-based frame arguments start from ebp+8, since [ebp]=saved ebp
; and [ebp+4]=return address.
virtual at ebp+8
.start  dq      ?
.length dq      ?
.disk   dd      ?
end virtual
; 1. Read the bootsector to the buffer.
; When disk_add_partition is called, ebx contains a pointer to
; a three-sectors-sized buffer. This function saves ebx in the stack
; immediately before ebp.
        mov     ebx, [ebp-4] ; get buffer
        add     ebx, [esi+DISK.MediaInfo.SectorSize] ; advance over MBR data to bootsector data
        add     ebp, 8       ; ebp points to part of PARTITION structure
        xor     eax, eax     ; first sector of the partition
        call    fs_read32_sys
        push    eax
; 2. Run tests for all supported filesystems. If at least one test succeeded,
; go to 4.
; For tests:
; ebp -> first three fields of PARTITION structure, .start, .length, .disk;
; [esp] = error code after bootsector read: 0 = ok, otherwise = failed,
; ebx points to the buffer for bootsector,
; ebx+[esi+DISK.MediaInfo.SectorSize] points to sector-sized buffer that can be used for anything.
        call    fat_create_partition
        test    eax, eax
        jnz     .success
        call    ntfs_create_partition
        test    eax, eax
        jnz     .success
        call    ext2_create_partition
        test    eax, eax
        jnz     .success
        call    xfs_create_partition
        test    eax, eax
        jnz     .success
; 3. No file system has recognized the volume, so just allocate the PARTITION
; structure without extra fields.
        movi    eax, sizeof.PARTITION
        call    malloc
        test    eax, eax
        jz      .nothing
        mov     edx, dword [ebp+PARTITION.FirstSector]
        mov     dword [eax+PARTITION.FirstSector], edx
        mov     edx, dword [ebp+PARTITION.FirstSector+4]
        mov     dword [eax+PARTITION.FirstSector+4], edx
        mov     edx, dword [ebp+PARTITION.Length]
        mov     dword [eax+PARTITION.Length], edx
        mov     edx, dword [ebp+PARTITION.Length+4]
        mov     dword [eax+PARTITION.Length+4], edx
        mov     [eax+PARTITION.Disk], esi
        mov     [eax+PARTITION.FSUserFunctions], default_fs_functions
.success:
.nothing:
        sub     ebp, 8 ; restore ebp
; 4. Return with eax = pointer to PARTITION or NULL.
        pop     ecx
        ret
 
iglobal
align 4
default_fs_functions:
        dd      free
        dd      0       ; no user functions
endg
 
; This function is called from file_system_lfn.
; This handler gets the control each time when fn 70 is called
; with unknown item of root subdirectory.
; in: esi = ebp -> path string
; out: if the handler processes path, it must not return in file_system_lfn,
;      but instead pop return address and return directly to the caller
;      otherwise simply return
dyndisk_handler:
        push    ebx edi         ; save registers used in file_system_lfn
; 1. Acquire the mutex.
        mov     ecx, disk_list_mutex
        call    mutex_lock
; 2. Loop over the list of DISK structures.
; 2a. Initialize.
        mov     ebx, disk_list
.scan:
; 2b. Get the next item.
        mov     ebx, [ebx+DISK.Next]
; 2c. Check whether the list is done. If so, go to 3.
        cmp     ebx, disk_list
        jz      .notfound
; 2d. Compare names. If names match, go to 5.
        mov     edi, [ebx+DISK.Name]
        push    esi
@@:
; esi points to the name from fs operation; it is terminated by zero or slash.
        lodsb
        test    al, al
        jz      .eoin_dec
        cmp     al, '/'
        jz      .eoin
; edi points to the disk name.
        inc     edi
; edi points to lowercase name, this is a requirement for the driver.
; Characters at esi can have any register. Lowercase the current character.
; This lowercasing works for latin letters and digits; since the disk name
; should not contain other symbols, this is ok.
        or      al, 20h
        cmp     al, [edi-1]
        jz      @b
.wrongname:
; 2f. Names don't match. Continue the loop.
        pop     esi
        jmp     .scan
.notfound:
; The loop is done and no name matches.
; 3. Release the mutex.
        call    mutex_unlock
; 4. Return normally.
        pop     edi ebx         ; restore registers used in file_system_lfn
        ret
; part of 2d: the name matches partially, but we must check that this is full
; equality.
.eoin_dec:
        dec     esi
.eoin:
        cmp     byte [edi], 0
        jnz     .wrongname
; We found the addressed DISK structure.
; 5. Reference the disk.
        lock inc [ebx+DISK.RefCount]
; 6. Now we are sure that the DISK structure is not going to die at least
; while we are working with it, so release the global mutex.
        call    mutex_unlock
        pop     ecx             ; pop from the stack saved value of esi
; 7. Acquire the mutex for media object.
        pop     edi             ; restore edi
        lea     ecx, [ebx+DISK.MediaLock]
        call    mutex_lock
; 8. Get the media object. If it is not NULL, reference it.
        xor     edx, edx
        cmp     [ebx+DISK.MediaInserted], dl
        jz      @f
        mov     edx, ebx
        inc     [ebx+DISK.MediaRefCount]
@@:
; 9. Now we are sure that the media object, if it exists, is not going to die
; at least while we are working with it, so release the mutex for media object.
        call    mutex_unlock
        mov     ecx, ebx
        pop     ebx eax         ; restore ebx, pop return address
; 10. Check whether the fs operation wants to enumerate partitions (go to 11)
; or work with some concrete partition (go to 12).
        cmp     byte [esi], 0
        jnz     .haspartition
; 11. The fs operation wants to enumerate partitions.
; 11a. Only "list directory" operation is applicable to / path. Check
; the operation code. If wrong, go to 13.
        cmp     dword [ebx], 1
        jnz     .access_denied
; 11b. If the media is inserted, use 'fs_dyndisk_next' as an enumeration
; procedure. Otherwise, use 'fs_dyndisk_next_nomedia'.
        mov     esi, fs_dyndisk_next_nomedia
        test    edx, edx
        jz      @f
        mov     esi, fs_dyndisk_next
@@:
; 11c. Let the procedure from fs_lfn.inc do the job.
        jmp     file_system_lfn.maindir_noesi
 
.access_denied:
        mov     dword [esp+32], ERROR_ACCESS_DENIED
        mov     esi, ecx        ; disk*dereference assume that esi points to DISK
.cleanup_esi:
        test    edx, edx        ; if there are no media, we didn't reference it
        jz      @f
        call    disk_media_dereference
@@:
        call    disk_dereference
        stdcall kernel_free, ebp
        ret
 
.dyndisk_cleanup:
        pop     esi
        pop     edx
        mov     dword [esp+32], ERROR_FILE_NOT_FOUND
        jmp     .cleanup_esi
 
.haspartition:
; 12. The fs operation has specified some partition.
        push    edx
        push    ecx
        xor     eax, eax
        lodsb
        sub     eax, '0'
        jz      .dyndisk_cleanup
        cmp     eax, 10
        jnc     .dyndisk_cleanup
        mov     ecx, eax
        lodsb
        cmp     eax, '/'
        jz      @f
        test    eax, eax
        jnz     .dyndisk_cleanup
        dec     esi
@@:
        dec     ecx     ; convert to zero-based partition index
        pop     edx     ; edx = pointer to DISK, dword [esp] = NULL or edx
; If the driver does not support insert notifications and we are the only fs
; operation with this disk, ask the driver whether the media
; was inserted/removed/changed. Otherwise, assume that media status is valid.
        test    byte [edx+DISK.DriverFlags], DISK_NO_INSERT_NOTIFICATION
        jz      .media_accurate
        push    ecx esi
        mov     esi, edx
        cmp     dword [esp+8], 0
        jz      .test_no_media
        cmp     [esi+DISK.MediaRefCount], 2
        jnz     .media_accurate_pop
        lea     edx, [esi+DISK.MediaInfo]
        and     [edx+DISKMEDIAINFO.Flags], 0
        mov     al, DISKFUNC.querymedia
        stdcall disk_call_driver, edx
        test    eax, eax
        jz      .media_accurate_pop
        stdcall disk_media_dereference  ; drop our reference so that disk_media_changed could close the media
        stdcall disk_media_changed, esi, 0
        and     dword [esp+8], 0        ; no media
.test_no_media:
        stdcall disk_media_changed, esi, 1      ; issue fake notification
; if querymedia() inside disk_media_changed returns error, the notification is ignored
        cmp     [esi+DISK.MediaInserted], 0
        jz      .media_accurate_pop
        lock inc [esi+DISK.MediaRefCount]
        mov     dword [esp+8], esi
.media_accurate_pop:
        mov     edx, esi
        pop     esi ecx
.media_accurate:
        pop     eax
        test    eax, eax
        jz      .nomedia
        cmp     ecx, [edx+DISK.NumPartitions]
        jae     .notfound2
        mov     eax, [edx+DISK.Partitions]
        mov     eax, [eax+ecx*4]
        mov     edi, [eax+PARTITION.FSUserFunctions]
        mov     ecx, [ebx]
        cmp     [edi+4], ecx
        jbe     .unsupported
        push    edx
        push    ebp
        mov     ebp, eax
        call    dword [edi+8+ecx*4]
        pop     ebp
        pop     edx
        mov     dword [esp+32], eax
        mov     dword [esp+20], ebx
.cleanup:
        mov     esi, edx
        call    disk_media_dereference
@@:
        call    disk_dereference
        stdcall kernel_free, ebp
        ret
 
.unsupported:
        mov     dword [esp+32], ERROR_UNKNOWN_FS
        cmp     edi, default_fs_functions
        jz      .cleanup
        mov     dword [esp+32], ERROR_UNSUPPORTED_FS
        jmp     .cleanup
 
.notfound2:
        mov     dword [esp+32], ERROR_FILE_NOT_FOUND
        jmp     .cleanup
 
.nomedia:
        test    ecx, ecx
        jnz     .notfound2
        mov     dword [esp+32], ERROR_DEVICE
        mov     esi, edx
        jmp     @b
 
; This is a callback for enumerating partitions called from
; file_system_lfn.maindir in the case of inserted media.
; It just increments eax until DISK.NumPartitions reached and then
; cleans up.
fs_dyndisk_next:
        mov     ecx, [esp+8]
        cmp     eax, [ecx+DISK.NumPartitions]
        jae     .nomore
        inc     eax
        clc
        ret
.nomore:
        pusha
        mov     esi, ecx
        call    disk_media_dereference
        call    disk_dereference
        popa
        stc
        ret
 
; This is a callback for enumerating partitions called from
; file_system_lfn.maindir in the case of missing media.
; In this case we create one pseudo-partition.
fs_dyndisk_next_nomedia:
        cmp     eax, 1
        jae     .nomore
        inc     eax
        clc
        ret
.nomore:
        mov     ecx, [esp+8]
        pusha
        mov     esi, ecx
        call    disk_dereference
        popa
        stc
        ret
 
; This function is called from file_system_lfn.
; This handler is called when virtual root is enumerated
; and must return all items which can be handled by this.
; It is called several times, first time with eax=0
; in: eax = 0 for first call, previously returned value for subsequent calls
; out: eax = 0 => no more items
;      eax != 0 => buffer pointed to by edi contains name of item
dyndisk_enum_root:
        push    edx             ; save register used in file_system_lfn
        mov     ecx, disk_list_mutex    ; it will be useful
; 1. If this is the first call, acquire the mutex and initialize.
        test    eax, eax
        jnz     .notfirst
        call    mutex_lock
        mov     eax, disk_list
.notfirst:
; 2. Get next item.
        mov     eax, [eax+DISK.Next]
; 3. If there are no more items, go to 6.
        cmp     eax, disk_list
        jz      .last
; 4. Copy name from the DISK structure to edi.
        push    eax esi
        mov     esi, [eax+DISK.Name]
@@:
        lodsb
        stosb
        test    al, al
        jnz     @b
        pop     esi eax
; 5. Return with eax = item.
        pop     edx             ; restore register used in file_system_lfn
        ret
.last:
; 6. Release the mutex and return with eax = 0.
        call    mutex_unlock
        xor     eax, eax
        pop     edx             ; restore register used in file_system_lfn
        ret

Rev 6468	Rev 6827
1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2	;; ;;	2	;; ;;
3	;; Copyright (C) KolibriOS team 2011-2015. All rights reserved. ;;	3	;; Copyright (C) KolibriOS team 2011-2015. 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: 6468 $	8	$Revision: 6827 $
9		9
10	; =============================================================================	10	; =============================================================================
11	; ================================= Constants =================================	11	; ================================= Constants =================================
12	; =============================================================================	12	; =============================================================================
13	; Error codes for callback functions.	13	; Error codes for callback functions.
14	DISK_STATUS_OK = 0 ; success	14	DISK_STATUS_OK = 0 ; success
15	DISK_STATUS_GENERAL_ERROR = -1; if no other code is suitable	15	DISK_STATUS_GENERAL_ERROR = -1; if no other code is suitable
16	DISK_STATUS_INVALID_CALL = 1 ; invalid input parameters	16	DISK_STATUS_INVALID_CALL = 1 ; invalid input parameters
17	DISK_STATUS_NO_MEDIA = 2 ; no media present	17	DISK_STATUS_NO_MEDIA = 2 ; no media present
18	DISK_STATUS_END_OF_MEDIA = 3 ; end of media while reading/writing data	18	DISK_STATUS_END_OF_MEDIA = 3 ; end of media while reading/writing data
19	DISK_STATUS_NO_MEMORY = 4 ; insufficient memory for driver operation	19	DISK_STATUS_NO_MEMORY = 4 ; insufficient memory for driver operation
20	; Driver flags. Represent bits in DISK.DriverFlags.	20	; Driver flags. Represent bits in DISK.DriverFlags.
21	DISK_NO_INSERT_NOTIFICATION = 1	21	DISK_NO_INSERT_NOTIFICATION = 1
22	; Media flags. Represent bits in DISKMEDIAINFO.Flags.	22	; Media flags. Represent bits in DISKMEDIAINFO.Flags.
23	DISK_MEDIA_READONLY = 1	23	DISK_MEDIA_READONLY = 1
24		24
25	; If too many partitions are detected,there is probably an error on the disk.	25	; If too many partitions are detected,there is probably an error on the disk.
26	; 256 partitions should be enough for any reasonable use.	26	; 256 partitions should be enough for any reasonable use.
27	; Also, the same number is limiting the number of MBRs to process; if	27	; Also, the same number is limiting the number of MBRs to process; if
28	; too many MBRs are visible,there probably is a loop in the MBR structure.	28	; too many MBRs are visible,there probably is a loop in the MBR structure.
29	MAX_NUM_PARTITIONS = 256	29	MAX_NUM_PARTITIONS = 256
30		30
31	; =============================================================================	31	; =============================================================================
32	; ================================ Structures =================================	32	; ================================ Structures =================================
33	; =============================================================================	33	; =============================================================================
34	; This structure defines all callback functions for working with the physical	34	; This structure defines all callback functions for working with the physical
35	; device. They are implemented by a driver. Objects with this structure reside	35	; device. They are implemented by a driver. Objects with this structure reside
36	; in a driver.	36	; in a driver.
37	struct DISKFUNC	37	struct DISKFUNC
38	strucsize dd ?	38	strucsize dd ?
39	; Size of the structure. This field is intended for possible extensions of	39	; Size of the structure. This field is intended for possible extensions of
40	; this structure. If a new function is added to this structure and a driver	40	; this structure. If a new function is added to this structure and a driver
41	; implements an old version, the caller can detect this by checking .strucsize,	41	; implements an old version, the caller can detect this by checking .strucsize,
42	; so the driver remains compatible.	42	; so the driver remains compatible.
43	close dd ?	43	close dd ?
44	; The pointer to the function which frees all driver-specific resources for	44	; The pointer to the function which frees all driver-specific resources for
45	; the disk.	45	; the disk.
46	; Optional, may be NULL.	46	; Optional, may be NULL.
47	; void close(void* userdata);	47	; void close(void* userdata);
48	closemedia dd ?	48	closemedia dd ?
49	; The pointer to the function which informs the driver that the kernel has	49	; The pointer to the function which informs the driver that the kernel has
50	; finished all processing with the current media. If media is removed, the	50	; finished all processing with the current media. If media is removed, the
51	; driver should decline all requests to that media with DISK_STATUS_NO_MEDIA,	51	; driver should decline all requests to that media with DISK_STATUS_NO_MEDIA,
52	; even if new media is inserted, until this function is called. If media is	52	; even if new media is inserted, until this function is called. If media is
53	; removed, a new call to 'disk_media_changed' is not allowed until this	53	; removed, a new call to 'disk_media_changed' is not allowed until this
54	; function is called.	54	; function is called.
55	; Optional, may be NULL (if media is not removable).	55	; Optional, may be NULL (if media is not removable).
56	; void closemedia(void* userdata);	56	; void closemedia(void* userdata);
57	querymedia dd ?	57	querymedia dd ?
58	; The pointer to the function which determines capabilities of the media.	58	; The pointer to the function which determines capabilities of the media.
59	; int querymedia(void* userdata, DISKMEDIAINFO* info);	59	; int querymedia(void* userdata, DISKMEDIAINFO* info);
60	; Return value: one of DISK_STATUS_*	60	; Return value: one of DISK_STATUS_*
61	read dd ?	61	read dd ?
62	; The pointer to the function which reads data from the device.	62	; The pointer to the function which reads data from the device.
63	; int read(void* userdata, void* buffer, __int64 startsector, int* numsectors);	63	; int read(void* userdata, void* buffer, __int64 startsector, int* numsectors);
64	; input: *numsectors = number of sectors to read	64	; input: *numsectors = number of sectors to read
65	; output: *numsectors = number of sectors which were successfully read	65	; output: *numsectors = number of sectors which were successfully read
66	; Return value: one of DISK_STATUS_*	66	; Return value: one of DISK_STATUS_*
67	write dd ?	67	write dd ?
68	; The pointer to the function which writes data to the device.	68	; The pointer to the function which writes data to the device.
69	; Optional, may be NULL.	69	; Optional, may be NULL.
70	; int write(void* userdata, void* buffer, __int64 startsector, int* numsectors);	70	; int write(void* userdata, void* buffer, __int64 startsector, int* numsectors);
71	; input: *numsectors = number of sectors to write	71	; input: *numsectors = number of sectors to write
72	; output: *numsectors = number of sectors which were successfully written	72	; output: *numsectors = number of sectors which were successfully written
73	; Return value: one of DISK_STATUS_*	73	; Return value: one of DISK_STATUS_*
74	flush dd ?	74	flush dd ?
75	; The pointer to the function which flushes the internal device cache.	75	; The pointer to the function which flushes the internal device cache.
76	; Optional, may be NULL.	76	; Optional, may be NULL.
77	; int flush(void* userdata);	77	; int flush(void* userdata);
78	; Return value: one of DISK_STATUS_*	78	; Return value: one of DISK_STATUS_*
79	; Note that read/write are called by the cache manager, so a driver should not	79	; Note that read/write are called by the cache manager, so a driver should not
80	; create a software cache. This function is implemented for flushing a hardware	80	; create a software cache. This function is implemented for flushing a hardware
81	; cache, if it exists.	81	; cache, if it exists.
82	adjust_cache_size dd ?	82	adjust_cache_size dd ?
83	; The pointer to the function which returns the cache size for this device.	83	; The pointer to the function which returns the cache size for this device.
84	; Optional, may be NULL.	84	; Optional, may be NULL.
85	; unsigned int adjust_cache_size(unsigned int suggested_size);	85	; unsigned int adjust_cache_size(unsigned int suggested_size);
86	; Return value: 0 = disable cache, otherwise = used cache size in bytes.	86	; Return value: 0 = disable cache, otherwise = used cache size in bytes.
87	ends	87	ends
88		88
89	; This structure holds information on a medium.	89	; This structure holds information on a medium.
90	; Objects with this structure are allocated by the kernel as a part of the DISK	90	; Objects with this structure are allocated by the kernel as a part of the DISK
91	; structure and are filled by a driver in the 'querymedia' callback.	91	; structure and are filled by a driver in the 'querymedia' callback.
92	struct DISKMEDIAINFO	92	struct DISKMEDIAINFO
93	Flags dd ?	93	Flags dd ?
94	; Combination of DISK_MEDIA_* bits.	94	; Combination of DISK_MEDIA_* bits.
95	SectorSize dd ?	95	SectorSize dd ?
96	; Size of the sector.	96	; Size of the sector.
97	Capacity dq ?	97	Capacity dq ?
98	; Size of the media in sectors.	98	; Size of the media in sectors.
99	ends	99	ends
100		100
101	; This structure represents the disk cache. To follow the old implementation,	101	; This structure represents the disk cache. To follow the old implementation,
102	; there are two distinct caches for a disk, one for "system" data,and the other	102	; there are two distinct caches for a disk, one for "system" data,and the other
103	; for "application" data.	103	; for "application" data.
104	struct DISKCACHE	104	struct DISKCACHE
105	; The following fields are inherited from data32.inc:cache_ideX.	105	; The following fields are inherited from data32.inc:cache_ideX.
106	pointer dd ?	106	pointer dd ?
107	data_size dd ? ; unused	107	data_size dd ? ; unused
108	data dd ?	108	data dd ?
109	sad_size dd ?	109	sad_size dd ?
110	search_start dd ?	110	search_start dd ?
111	sector_size_log dd ?	111	sector_size_log dd ?
112	ends	112	ends
113		113
114	; This structure represents a disk device and its media for the kernel.	114	; This structure represents a disk device and its media for the kernel.
115	; This structure is allocated by the kernel in the 'disk_add' function,	115	; This structure is allocated by the kernel in the 'disk_add' function,
116	; freed in the 'disk_dereference' function.	116	; freed in the 'disk_dereference' function.
117	struct DISK	117	struct DISK
118	; Fields of disk object	118	; Fields of disk object
119	Next dd ?	119	Next dd ?
120	Prev dd ?	120	Prev dd ?
121	; All disk devices are linked in one list with these two fields.	121	; All disk devices are linked in one list with these two fields.
122	; Head of the list is the 'disk_list' variable.	122	; Head of the list is the 'disk_list' variable.
123	Functions dd ?	123	Functions dd ?
124	; Pointer to the 'DISKFUNC' structure with driver functions.	124	; Pointer to the 'DISKFUNC' structure with driver functions.
125	Name dd ?	125	Name dd ?
126	; Pointer to the string used for accesses through the global filesystem.	126	; Pointer to the string used for accesses through the global filesystem.
127	UserData dd ?	127	UserData dd ?
128	; This field is passed to all callback functions so a driver can decide which	128	; This field is passed to all callback functions so a driver can decide which
129	; physical device is addressed.	129	; physical device is addressed.
130	DriverFlags dd ?	130	DriverFlags dd ?
131	; Bitfield. Currently only DISK_NO_INSERT_NOTIFICATION bit is defined.	131	; Bitfield. Currently only DISK_NO_INSERT_NOTIFICATION bit is defined.
132	; If it is set, the driver will never issue 'disk_media_changed' notification	132	; If it is set, the driver will never issue 'disk_media_changed' notification
133	; with argument set to true, so the kernel must try to detect media during	133	; with argument set to true, so the kernel must try to detect media during
134	; requests from the file system.	134	; requests from the file system.
135	RefCount dd ?	135	RefCount dd ?
136	; Count of active references to this structure. One reference is kept during	136	; Count of active references to this structure. One reference is kept during
137	; the lifetime of the structure between 'disk_add' and 'disk_del'.	137	; the lifetime of the structure between 'disk_add' and 'disk_del'.
138	; Another reference is taken during any filesystem operation for this disk.	138	; Another reference is taken during any filesystem operation for this disk.
139	; One reference is added if media is inserted.	139	; One reference is added if media is inserted.
140	; The structure is destroyed when the reference count decrements to zero:	140	; The structure is destroyed when the reference count decrements to zero:
141	; this usually occurs in 'disk_del', but can be delayed to the end of last	141	; this usually occurs in 'disk_del', but can be delayed to the end of last
142	; filesystem operation, if one is active.	142	; filesystem operation, if one is active.
143	MediaLock MUTEX	143	MediaLock MUTEX
144	; Lock to protect the MEDIA structure. See the description after	144	; Lock to protect the MEDIA structure. See the description after
145	; 'disk_list_mutex' for the locking strategy.	145	; 'disk_list_mutex' for the locking strategy.
146	; Fields of media object	146	; Fields of media object
147	MediaInserted db ?	147	MediaInserted db ?
148	; 0 if media is not inserted, nonzero otherwise.	148	; 0 if media is not inserted, nonzero otherwise.
149	MediaUsed db ?	149	MediaUsed db ?
150	; 0 if media fields are not used, nonzero otherwise. If .MediaRefCount is	150	; 0 if media fields are not used, nonzero otherwise. If .MediaRefCount is
151	; nonzero, this field is nonzero too; however, when .MediaRefCount goes	151	; nonzero, this field is nonzero too; however, when .MediaRefCount goes
152	; to zero, there is some time interval during which media object is still used.	152	; to zero, there is some time interval during which media object is still used.
153	dw ? ; padding	153	dw ? ; padding
154	; The following fields are not valid unless either .MediaInserted is nonzero	154	; The following fields are not valid unless either .MediaInserted is nonzero
155	; or they are accessed from a code which has obtained the reference when	155	; or they are accessed from a code which has obtained the reference when
156	; .MediaInserted was nonzero.	156	; .MediaInserted was nonzero.
157	MediaRefCount dd ?	157	MediaRefCount dd ?
158	; Count of active references to the media object. One reference is kept during	158	; Count of active references to the media object. One reference is kept during
159	; the lifetime of the media between two calls to 'disk_media_changed'.	159	; the lifetime of the media between two calls to 'disk_media_changed'.
160	; Another reference is taken during any filesystem operation for this media.	160	; Another reference is taken during any filesystem operation for this media.
161	; The callback 'closemedia' is called when the reference count decrements to	161	; The callback 'closemedia' is called when the reference count decrements to
162	; zero: this usually occurs in 'disk_media_changed', but can be delayed to the	162	; zero: this usually occurs in 'disk_media_changed', but can be delayed to the
163	; end of the last filesystem operation, if one is active.	163	; end of the last filesystem operation, if one is active.
164	MediaInfo DISKMEDIAINFO	164	MediaInfo DISKMEDIAINFO
165	; This field keeps information on the current media.	165	; This field keeps information on the current media.
166	NumPartitions dd ?	166	NumPartitions dd ?
167	; Number of partitions on this media.	167	; Number of partitions on this media.
168	Partitions dd ?	168	Partitions dd ?
169	; Pointer to array of .NumPartitions pointers to PARTITION structures.	169	; Pointer to array of .NumPartitions pointers to PARTITION structures.
170	cache_size dd ?	170	cache_size dd ?
171	; inherited from cache_ideX_size	171	; inherited from cache_ideX_size
172	CacheLock MUTEX	172	CacheLock MUTEX
173	; Lock to protect both caches.	173	; Lock to protect both caches.
174	SysCache DISKCACHE	174	SysCache DISKCACHE
175	AppCache DISKCACHE	175	AppCache DISKCACHE
176	; Two caches for the disk.	176	; Two caches for the disk.
177	ends	177	ends
178		178
179	; This structure represents one partition for the kernel. This is a base	179	; This structure represents one partition for the kernel. This is a base
180	; template, the actual contents after common fields is determined by the	180	; template, the actual contents after common fields is determined by the
181	; file system code for this partition.	181	; file system code for this partition.
182	struct PARTITION	182	struct PARTITION
183	FirstSector dq ?	183	FirstSector dq ?
184	; First sector of the partition.	184	; First sector of the partition.
185	Length dq ?	185	Length dq ?
186	; Length of the partition in sectors.	186	; Length of the partition in sectors.
187	Disk dd ?	187	Disk dd ?
188	; Pointer to parent DISK structure.	188	; Pointer to parent DISK structure.
189	FSUserFunctions dd ?	189	FSUserFunctions dd ?
190	; Handlers for the sysfunction 70h. This field is a pointer to the following	190	; Handlers for the sysfunction 70h. This field is a pointer to the following
191	; array. The first dword is pointer to disconnect handler.	191	; array. The first dword is pointer to disconnect handler.
192	; The first dword is a number of supported subfunctions, other dwords	192	; The first dword is a number of supported subfunctions, other dwords
193	; point to handlers of corresponding subfunctions.	193	; point to handlers of corresponding subfunctions.
194	; ...fs-specific data may follow...	194	; ...fs-specific data may follow...
195	ends	195	ends
196		196
197	; This is an external structure, it represents an entry in the partition table.	197	; This is an external structure, it represents an entry in the partition table.
198	struct PARTITION_TABLE_ENTRY	198	struct PARTITION_TABLE_ENTRY
199	Bootable db ?	199	Bootable db ?
200	; 80h = bootable partition, 0 = non-bootable partition, other values = invalid	200	; 80h = bootable partition, 0 = non-bootable partition, other values = invalid
201	FirstHead db ?	201	FirstHead db ?
202	FirstSector db ?	202	FirstSector db ?
203	FirstTrack db ?	203	FirstTrack db ?
204	; Coordinates of first sector in CHS.	204	; Coordinates of first sector in CHS.
205	Type db ?	205	Type db ?
206	; Partition type, one of predefined constants. 0 = empty, several types denote	206	; Partition type, one of predefined constants. 0 = empty, several types denote
207	; extended partition (see process_partition_table_entry), we are not interested	207	; extended partition (see process_partition_table_entry), we are not interested
208	; in other values.	208	; in other values.
209	LastHead db ?	209	LastHead db ?
210	LastSector db ?	210	LastSector db ?
211	LastTrack db ?	211	LastTrack db ?
212	; Coordinates of last sector in CHS.	212	; Coordinates of last sector in CHS.
213	FirstAbsSector dd ?	213	FirstAbsSector dd ?
214	; Coordinate of first sector in LBA.	214	; Coordinate of first sector in LBA.
215	Length dd ?	215	Length dd ?
216	; Length of the partition in sectors.	216	; Length of the partition in sectors.
217	ends	217	ends
-		218
-		219	; GUID Partition Table Header, UEFI 2.6, Table 18
-		220	struct GPTH
-		221	Signature rb 8
-		222	; 'EFI PART'
-		223	Revision dd ?
-		224	; 0x00010000
-		225	HeaderSize dd ?
-		226	; Size of this header in bytes, must fit to one sector.
-		227	HeaderCRC32 dd ?
-		228	; Set this field to zero, compute CRC32 via 0xEDB88320, compare.
-		229	Reserved dd ?
-		230	; Myst be zero.
-		231	MyLBA dq ?
-		232	; LBA of the sector containing this GPT header.
-		233	AlternateLBA dq ?
-		234	; LBA of the sector containing the other GPT header.
-		235	; AlternateLBA of Primary GPTH points to Backup one and vice versa.
-		236	FirstUsableLBA dq ?
-		237	; Only sectors between first and last UsableLBA may form partitions
-		238	LastUsableLBA dq ?
-		239	DiskGUID rb 16
-		240	; Globally Unique IDentifier
-		241	PartitionEntryLBA dq ?
-		242	; First LBA of Partition Entry Array.
-		243	; Length in bytes is computed as a product of two following fields.
-		244	NumberOfPartitionEntries dd ?
-		245	; Actual number of partitions depends on the contents of Partition Entry Array.
-		246	; A partition entry is unused if zeroed.
-		247	SizeOfPartitionEntry dd ? ; in bytes
-		248	PartitionEntryArrayCRC32 dd ?
-		249	; Same CRC as for GPT header.
-		250	ends
-		251
-		252	; GPT Partition Entry, UEFI 2.6, Table 19
-		253	struct GPE
-		254	PartitionTypeGUID rb 16
-		255	UniquePartitionGUID rb 16
-		256	StartingLBA dq ?
-		257	EndingLBA dq ?
-		258	; Length in sectors is EndingLBA - StartingLBA + 1.
-		259	Attributes dq ?
-		260	PartitionName rb 72
-		261	ends
218		262
219	; =============================================================================	263	; =============================================================================
220	; ================================ Global data ================================	264	; ================================ Global data ================================
221	; =============================================================================	265	; =============================================================================
222	iglobal	266	iglobal
223	; The pseudo-item for the list of all DISK structures.	267	; The pseudo-item for the list of all DISK structures.
224	; Initialized to the empty list.	268	; Initialized to the empty list.
225	disk_list:	269	disk_list:
226	dd disk_list	270	dd disk_list
227	dd disk_list	271	dd disk_list
228	endg	272	endg
229	uglobal	273	uglobal
230	; This mutex guards all operations with the global list of DISK structures.	274	; This mutex guards all operations with the global list of DISK structures.
231	disk_list_mutex MUTEX	275	disk_list_mutex MUTEX
232	; * There are two dependent objects, a disk and a media. In the simplest case,	276	; * There are two dependent objects, a disk and a media. In the simplest case,
233	; disk and media are both non-removable. However, in the general case both	277	; disk and media are both non-removable. However, in the general case both
234	; can be removed at any time, simultaneously or only media,and this makes things	278	; can be removed at any time, simultaneously or only media,and this makes things
235	; complicated.	279	; complicated.
236	; * For efficiency, both disk and media objects are located in the one	280	; * For efficiency, both disk and media objects are located in the one
237	; structure named DISK. However, logically they are different.	281	; structure named DISK. However, logically they are different.
238	; * The following operations use data of disk object: adding (disk_add);	282	; * The following operations use data of disk object: adding (disk_add);
239	; deleting (disk_del); filesystem (fs_lfn which eventually calls	283	; deleting (disk_del); filesystem (fs_lfn which eventually calls
240	; dyndisk_handler or dyndisk_enum_root).	284	; dyndisk_handler or dyndisk_enum_root).
241	; * The following operations use data of media object: adding/removing	285	; * The following operations use data of media object: adding/removing
242	; (disk_media_changed); filesystem (fs_lfn which eventually calls	286	; (disk_media_changed); filesystem (fs_lfn which eventually calls
243	; dyndisk_handler; dyndisk_enum_root doesn't work with media).	287	; dyndisk_handler; dyndisk_enum_root doesn't work with media).
244	; * Notifications disk_add, disk_media_changed, disk_del are synchronized	288	; * Notifications disk_add, disk_media_changed, disk_del are synchronized
245	; between themselves, this is a requirement for the driver. However, file	289	; between themselves, this is a requirement for the driver. However, file
246	; system operations are asynchronous, can be issued at any time by any	290	; system operations are asynchronous, can be issued at any time by any
247	; thread.	291	; thread.
248	; * We must prevent a situation when a filesystem operation thinks that the	292	; * We must prevent a situation when a filesystem operation thinks that the
249	; object is still valid but in fact the notification has destroyed the	293	; object is still valid but in fact the notification has destroyed the
250	; object. So we keep a reference counter for both disk and media and destroy	294	; object. So we keep a reference counter for both disk and media and destroy
251	; the object when this counter goes to zero.	295	; the object when this counter goes to zero.
252	; * The driver must know when it is safe to free driver-allocated resources.	296	; * The driver must know when it is safe to free driver-allocated resources.
253	; The object can be alive even after death notification has completed.	297	; The object can be alive even after death notification has completed.
254	; We use special callbacks to satisfy both assertions: 'close' for the disk	298	; We use special callbacks to satisfy both assertions: 'close' for the disk
255	; and 'closemedia' for the media. The destruction of the object includes	299	; and 'closemedia' for the media. The destruction of the object includes
256	; calling the corresponding callback.	300	; calling the corresponding callback.
257	; * Each filesystem operation keeps one reference for the disk and one	301	; * Each filesystem operation keeps one reference for the disk and one
258	; reference for the media. Notification disk_del forces notification on the	302	; reference for the media. Notification disk_del forces notification on the
259	; media death, so the reference counter for the disk is always not less than	303	; media death, so the reference counter for the disk is always not less than
260	; the reference counter for the media.	304	; the reference counter for the media.
261	; * Two operations "get the object" and "increment the reference counter" can	305	; * Two operations "get the object" and "increment the reference counter" can
262	; not be done simultaneously. We use a mutex to guard the consistency here.	306	; not be done simultaneously. We use a mutex to guard the consistency here.
263	; It must be a part of the container for the object, so that this mutex can	307	; It must be a part of the container for the object, so that this mutex can
264	; be acquired as a part of getting the object from the container. The	308	; be acquired as a part of getting the object from the container. The
265	; container for disk object is the global list, and this list is guarded by	309	; container for disk object is the global list, and this list is guarded by
266	; 'disk_list_mutex'. The container for media object is the disk object, and	310	; 'disk_list_mutex'. The container for media object is the disk object, and
267	; the corresponding mutex is DISK.MediaLock.	311	; the corresponding mutex is DISK.MediaLock.
268	; * Notifications do not change the data of objects, they can only remove	312	; * Notifications do not change the data of objects, they can only remove
269	; objects. Thus we don't need another synchronization at this level. If two	313	; objects. Thus we don't need another synchronization at this level. If two
270	; filesystem operations are referencing the same filesystem data, this is	314	; filesystem operations are referencing the same filesystem data, this is
271	; better resolved at the level of the filesystem.	315	; better resolved at the level of the filesystem.
272	endg	316	endg
273		317
274	iglobal	318	iglobal
275	; The function 'disk_scan_partitions' needs three sector-sized buffers for	319	; The function 'disk_scan_partitions' needs three sector-sized buffers for
276	; MBR, bootsector and fs-temporary sector data. It can not use the static	320	; MBR, bootsector and fs-temporary sector data. It can not use the static
277	; buffers always, since it can be called for two or more disks in parallel.	321	; buffers always, since it can be called for two or more disks in parallel.
278	; However, this case is not typical. We reserve three static 512-byte buffers	322	; However, this case is not typical. We reserve three static 512-byte buffers
279	; and a flag that these buffers are currently used. If 'disk_scan_partitions'	323	; and a flag that these buffers are currently used. If 'disk_scan_partitions'
280	; detects that the buffers are currently used, it allocates buffers from the	324	; detects that the buffers are currently used, it allocates buffers from the
281	; heap. Also, the heap is used when sector size is other than 512.	325	; heap. Also, the heap is used when sector size is other than 512.
282	; The flag is implemented as a global dword variable. When the static buffers	326	; The flag is implemented as a global dword variable. When the static buffers
283	; are not used, the value is -1. When the static buffers are used, the value	327	; are not used, the value is -1. When the static buffers are used, the value
284	; is normally 0 and temporarily can become greater. The function increments	328	; is normally 0 and temporarily can become greater. The function increments
285	; this value. If the resulting value is zero, it uses the buffers and	329	; this value. If the resulting value is zero, it uses the buffers and
286	; decrements the value when the job is done. Otherwise, it immediately	330	; decrements the value when the job is done. Otherwise, it immediately
287	; decrements the value and uses buffers from the heap, allocated in the	331	; decrements the value and uses buffers from the heap, allocated in the
288	; beginning and freed in the end.	332	; beginning and freed in the end.
289	partition_buffer_users dd -1	333	partition_buffer_users dd -1
290	endg	334	endg
291	uglobal	335	uglobal
292	; The static buffers for MBR, bootsector and fs-temporary sector data.	336	; The static buffers for MBR, bootsector and fs-temporary sector data.
293	align 16	337	align 16
294	mbr_buffer rb 512	338	mbr_buffer rb 512
295	bootsect_buffer rb 512	339	bootsect_buffer rb 512
296	fs_tmp_buffer rb 512	340	fs_tmp_buffer rb 512
297	endg	341	endg
298		342
299	iglobal	343	iglobal
300	; This is the array of default implementations of driver callbacks.	344	; This is the array of default implementations of driver callbacks.
301	; Same as DRIVERFUNC structure except for the first field; all functions must	345	; Same as DRIVERFUNC structure except for the first field; all functions must
302	; have the default implementations.	346	; have the default implementations.
303	align 4	347	align 4
304	disk_default_callbacks:	348	disk_default_callbacks:
305	dd disk_default_close	349	dd disk_default_close
306	dd disk_default_closemedia	350	dd disk_default_closemedia
307	dd disk_default_querymedia	351	dd disk_default_querymedia
308	dd disk_default_read	352	dd disk_default_read
309	dd disk_default_write	353	dd disk_default_write
310	dd disk_default_flush	354	dd disk_default_flush
311	dd disk_default_adjust_cache_size	355	dd disk_default_adjust_cache_size
312	endg	356	endg
313		357
314	; =============================================================================	358	; =============================================================================
315	; ================================= Functions =================================	359	; ================================= Functions =================================
316	; =============================================================================	360	; =============================================================================
317		361
318	; This function registers a disk device.	362	; This function registers a disk device.
319	; This includes:	363	; This includes:
320	; - allocating an internal structure describing this device;	364	; - allocating an internal structure describing this device;
321	; - registering this structure in the global filesystem.	365	; - registering this structure in the global filesystem.
322	; The function initializes the disk as if there is no media. If a media is	366	; The function initializes the disk as if there is no media. If a media is
323	; present, the function 'disk_media_changed' should be called after this	367	; present, the function 'disk_media_changed' should be called after this
324	; function succeeds.	368	; function succeeds.
325	; Parameters:	369	; Parameters:
326	; [esp+4] = pointer to DISKFUNC structure with the callbacks	370	; [esp+4] = pointer to DISKFUNC structure with the callbacks
327	; [esp+8] = pointer to name (ASCIIZ string)	371	; [esp+8] = pointer to name (ASCIIZ string)
328	; [esp+12] = userdata to be passed to the callbacks as is.	372	; [esp+12] = userdata to be passed to the callbacks as is.
329	; [esp+16] = flags, bitfield. Currently only DISK_NO_INSERT_NOTIFICATION bit	373	; [esp+16] = flags, bitfield. Currently only DISK_NO_INSERT_NOTIFICATION bit
330	; is defined.	374	; is defined.
331	; Return value:	375	; Return value:
332	; NULL = operation has failed	376	; NULL = operation has failed
333	; non-NULL = handle of the disk. This handle can be used	377	; non-NULL = handle of the disk. This handle can be used
334	; in the operations with other Disk* functions.	378	; in the operations with other Disk* functions.
335	; The handle is the pointer to the internal structure DISK.	379	; The handle is the pointer to the internal structure DISK.
336	disk_add:	380	disk_add:
337	push ebx esi ; save used registers to be stdcall	381	push ebx esi ; save used registers to be stdcall
338	; 1. Allocate the DISK structure.	382	; 1. Allocate the DISK structure.
339	; 1a. Call the heap manager.	383	; 1a. Call the heap manager.
340	movi eax, sizeof.DISK	384	movi eax, sizeof.DISK
341	call malloc	385	call malloc
342	; 1b. Check the result. If allocation failed, return (go to 9) with eax = 0.	386	; 1b. Check the result. If allocation failed, return (go to 9) with eax = 0.
343	test eax, eax	387	test eax, eax
344	jz .nothing	388	jz .nothing
345	; 2. Copy the disk name to the DISK structure.	389	; 2. Copy the disk name to the DISK structure.
346	; 2a. Get length of the name, including the terminating zero.	390	; 2a. Get length of the name, including the terminating zero.
347	mov ebx, [esp+8+8] ; ebx = pointer to name	391	mov ebx, [esp+8+8] ; ebx = pointer to name
348	push eax ; save allocated pointer to DISK	392	push eax ; save allocated pointer to DISK
349	xor eax, eax ; the argument of malloc() is in eax	393	xor eax, eax ; the argument of malloc() is in eax
350	@@:	394	@@:
351	inc eax	395	inc eax
352	cmp byte [ebx+eax-1], 0	396	cmp byte [ebx+eax-1], 0
353	jnz @b	397	jnz @b
354	; 2b. Call the heap manager.	398	; 2b. Call the heap manager.
355	call malloc	399	call malloc
356	; 2c. Check the result. If allocation failed, go to 7.	400	; 2c. Check the result. If allocation failed, go to 7.
357	pop esi ; restore allocated pointer to DISK	401	pop esi ; restore allocated pointer to DISK
358	test eax, eax	402	test eax, eax
359	jz .free	403	jz .free
360	; 2d. Store the allocated pointer to the DISK structure.	404	; 2d. Store the allocated pointer to the DISK structure.
361	mov [esi+DISK.Name], eax	405	mov [esi+DISK.Name], eax
362	; 2e. Copy the name.	406	; 2e. Copy the name.
363	@@:	407	@@:
364	mov dl, [ebx]	408	mov dl, [ebx]
365	mov [eax], dl	409	mov [eax], dl
366	inc ebx	410	inc ebx
367	inc eax	411	inc eax
368	test dl, dl	412	test dl, dl
369	jnz @b	413	jnz @b
370	; 3. Copy other arguments of the function to the DISK structure.	414	; 3. Copy other arguments of the function to the DISK structure.
371	mov eax, [esp+4+8]	415	mov eax, [esp+4+8]
372	mov [esi+DISK.Functions], eax	416	mov [esi+DISK.Functions], eax
373	mov eax, [esp+12+8]	417	mov eax, [esp+12+8]
374	mov [esi+DISK.UserData], eax	418	mov [esi+DISK.UserData], eax
375	mov eax, [esp+16+8]	419	mov eax, [esp+16+8]
376	mov [esi+DISK.DriverFlags], eax	420	mov [esi+DISK.DriverFlags], eax
377	; 4. Initialize other fields of the DISK structure.	421	; 4. Initialize other fields of the DISK structure.
378	; Media is not inserted, reference counter is 1.	422	; Media is not inserted, reference counter is 1.
379	lea ecx, [esi+DISK.MediaLock]	423	lea ecx, [esi+DISK.MediaLock]
380	call mutex_init	424	call mutex_init
381	xor eax, eax	425	xor eax, eax
382	mov dword [esi+DISK.MediaInserted], eax	426	mov dword [esi+DISK.MediaInserted], eax
383	mov [esi+DISK.MediaRefCount], eax	427	mov [esi+DISK.MediaRefCount], eax
384	inc eax	428	inc eax
385	mov [esi+DISK.RefCount], eax	429	mov [esi+DISK.RefCount], eax
386	; The DISK structure is initialized.	430	; The DISK structure is initialized.
387	; 5. Insert the new structure to the global list.	431	; 5. Insert the new structure to the global list.
388	; 5a. Acquire the mutex.	432	; 5a. Acquire the mutex.
389	mov ecx, disk_list_mutex	433	mov ecx, disk_list_mutex
390	call mutex_lock	434	call mutex_lock
391	; 5b. Insert item to the tail of double-linked list.	435	; 5b. Insert item to the tail of double-linked list.
392	mov edx, disk_list	436	mov edx, disk_list
393	list_add_tail esi, edx ;esi= new edx= list head	437	list_add_tail esi, edx ;esi= new edx= list head
394	; 5c. Release the mutex.	438	; 5c. Release the mutex.
395	call mutex_unlock	439	call mutex_unlock
396	; 6. Return with eax = pointer to DISK.	440	; 6. Return with eax = pointer to DISK.
397	xchg eax, esi	441	xchg eax, esi
398	jmp .nothing	442	jmp .nothing
399	.free:	443	.free:
400	; Memory allocation for DISK structure succeeded, but for disk name failed.	444	; Memory allocation for DISK structure succeeded, but for disk name failed.
401	; 7. Free the DISK structure.	445	; 7. Free the DISK structure.
402	xchg eax, esi	446	xchg eax, esi
403	call free	447	call free
404	; 8. Return with eax = 0.	448	; 8. Return with eax = 0.
405	xor eax, eax	449	xor eax, eax
406	.nothing:	450	.nothing:
407	; 9. Return.	451	; 9. Return.
408	pop esi ebx ; restore used registers to be stdcall	452	pop esi ebx ; restore used registers to be stdcall
409	ret 16 ; purge 4 dword arguments to be stdcall	453	ret 16 ; purge 4 dword arguments to be stdcall
410		454
411	; This function deletes a disk device from the global filesystem.	455	; This function deletes a disk device from the global filesystem.
412	; This includes:	456	; This includes:
413	; - removing a media including all partitions;	457	; - removing a media including all partitions;
414	; - deleting this structure from the global filesystem;	458	; - deleting this structure from the global filesystem;
415	; - dereferencing the DISK structure and possibly destroying it.	459	; - dereferencing the DISK structure and possibly destroying it.
416	; Parameters:	460	; Parameters:
417	; [esp+4] = handle of the disk, i.e. the pointer to the DISK structure.	461	; [esp+4] = handle of the disk, i.e. the pointer to the DISK structure.
418	; Return value: none.	462	; Return value: none.
419	disk_del:	463	disk_del:
420	push esi ; save used registers to be stdcall	464	push esi ; save used registers to be stdcall
421	; 1. Force media to be removed. If the media is already removed, the	465	; 1. Force media to be removed. If the media is already removed, the
422	; call does nothing.	466	; call does nothing.
423	mov esi, [esp+4+4] ; esi = handle of the disk	467	mov esi, [esp+4+4] ; esi = handle of the disk
424	stdcall disk_media_changed, esi, 0	468	stdcall disk_media_changed, esi, 0
425	; 2. Delete the structure from the global list.	469	; 2. Delete the structure from the global list.
426	; 2a. Acquire the mutex.	470	; 2a. Acquire the mutex.
427	mov ecx, disk_list_mutex	471	mov ecx, disk_list_mutex
428	call mutex_lock	472	call mutex_lock
429	; 2b. Delete item from double-linked list.	473	; 2b. Delete item from double-linked list.
430	mov eax, [esi+DISK.Next]	474	mov eax, [esi+DISK.Next]
431	mov edx, [esi+DISK.Prev]	475	mov edx, [esi+DISK.Prev]
432	mov [eax+DISK.Prev], edx	476	mov [eax+DISK.Prev], edx
433	mov [edx+DISK.Next], eax	477	mov [edx+DISK.Next], eax
434	; 2c. Release the mutex.	478	; 2c. Release the mutex.
435	call mutex_unlock	479	call mutex_unlock
436	; 3. The structure still has one reference created in disk_add. Remove this	480	; 3. The structure still has one reference created in disk_add. Remove this
437	; reference. If there are no other references, disk_dereference will free the	481	; reference. If there are no other references, disk_dereference will free the
438	; structure.	482	; structure.
439	call disk_dereference	483	call disk_dereference
440	; 4. Return.	484	; 4. Return.
441	pop esi ; restore used registers to be stdcall	485	pop esi ; restore used registers to be stdcall
442	ret 4 ; purge 1 dword argument to be stdcall	486	ret 4 ; purge 1 dword argument to be stdcall
443		487
444	; This is an internal function which removes a previously obtained reference	488	; This is an internal function which removes a previously obtained reference
445	; to the disk. If this is the last reference, this function lets the driver	489	; to the disk. If this is the last reference, this function lets the driver
446	; finalize all associated data, and afterwards frees the DISK structure.	490	; finalize all associated data, and afterwards frees the DISK structure.
447	; esi = pointer to DISK structure	491	; esi = pointer to DISK structure
448	disk_dereference:	492	disk_dereference:
449	; 1. Decrement reference counter. Use atomic operation to correctly handle	493	; 1. Decrement reference counter. Use atomic operation to correctly handle
450	; possible simultaneous calls.	494	; possible simultaneous calls.
451	lock dec [esi+DISK.RefCount]	495	lock dec [esi+DISK.RefCount]
452	; 2. If the result is nonzero, there are other references, so nothing to do.	496	; 2. If the result is nonzero, there are other references, so nothing to do.
453	; In this case, return (go to 4).	497	; In this case, return (go to 4).
454	jnz .nothing	498	jnz .nothing
455	; 3. If we are here, we just removed the last reference and must destroy the	499	; 3. If we are here, we just removed the last reference and must destroy the
456	; disk object.	500	; disk object.

Subversion Repositories Kolibri OS

(root)/kernel/trunk/blkdev/disk.inc @ 6464 – Rev 6468 → 6827