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

 ; 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              dd      ?
+.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.
         dd      disk_list
         dd      disk_list
 endg
 uglobal
 ; This mutex guards all operations with the global list of DISK structures.
-disk_list_mutex dd      0
+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, this makes things
 ;   complicated.
 ; * For efficiency, both disk and media objects are located in the one
         mov     eax, [esp+16+8]
         mov     [ebx+DISK.DriverFlags], eax
 ; 4. Initialize other fields of the DISK structure.
 ; Media is not inserted, initialized state of mutex is zero,
 ; reference counter is 1.
+        lea     ecx, [ebx+DISK.MediaLock]
+        call    mutex_init
         xor     eax, eax
         mov     dword [ebx+DISK.MediaInserted], eax
-        mov     [ebx+DISK.MediaLock], eax
         inc     eax
         mov     [ebx+DISK.RefCount], eax
 ; The DISK structure is initialized.
 ; 5. Insert the new structure to the global list.
-        xchg    eax, ebx        ; now eax = pointer to DISK
 ; 5a. Acquire the mutex.
-        mov     ebx, disk_list_mutex
+        mov     ecx, disk_list_mutex
-        call    wait_mutex
+        call    mutex_lock
 ; 5b. Insert item to the tail of double-linked list.
         mov     edx, disk_list
-        mov     ecx, [edx+DISK.Prev]
+        list_add_tail ebx, edx     ;ebx= new edx= list head
-        mov     [eax+DISK.Prev], ecx
-        mov     [eax+DISK.Next], edx
-        mov     [edx+DISK.Prev], eax
-        mov     [ecx+DISK.Next], eax
 ; 5c. Release the mutex.
-        mov     dword [ebx], 0
+        call mutex_unlock
 ; 6. Return with eax = pointer to DISK.
+        xchg    eax, ebx
         jmp     .nothing
 .free:
 ; Memory allocation for DISK structure succeeded, but for disk name failed.
 ; 7. Free the DISK structure.
         xchg    eax, ebx
 ; - 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    ebx esi         ; save used registers to be stdcall
+        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+8]  ; esi = handle of the disk
         stdcall disk_media_changed, esi, 0
 ; 2. Delete the structure from the global list.
 ; 2a. Acquire the mutex.
-        mov     ebx, disk_list_mutex
+        mov     ecx, disk_list_mutex
-        call    wait_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.
-        mov     dword [ebx], 0
+        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 ebx         ; restore used registers to be stdcall
+        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
 ; required for checking.
         cmp     [esi+DISK.MediaInserted], 0
         jz      .noremove
 ; We really need to remove the media.
 ; 1b. Acquire mutex.
-        lea     ebx, [esi+DISK.MediaLock]
+        lea     ecx, [esi+DISK.MediaLock]
-        call    wait_mutex
+        call    mutex_lock
 ; 1c. Clear the flag.
         mov     [esi+DISK.MediaInserted], 0
 ; 1d. Release mutex.
-        mov     dword [ebx], 0
+        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
 ;      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     ebx, disk_list_mutex
+        mov     ecx, disk_list_mutex
-        call    wait_mutex
+        call    mutex_lock
 ; 2. Loop over the list of DISK structures.
 ; 2a. Initialize.
-        mov     ecx, disk_list
+        mov     ebx, disk_list
 .scan:
 ; 2b. Get the next item.
-        mov     ecx, [ecx+DISK.Next]
+        mov     ebx, [ebx+DISK.Next]
 ; 2c. Check whether the list is done. If so, go to 3.
-        cmp     ecx, disk_list
+        cmp     ebx, disk_list
         jz      .notfound
 ; 2d. Compare names. If names match, go to 5.
-        mov     edi, [ecx+DISK.Name]
+        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
         pop     esi
         jmp     .scan
 .notfound:
 ; The loop is done and no name matches.
 ; 3. Release the mutex.
-        mov     dword [ebx], 0
+        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:
         cmp     byte [edi], 0
         jnz     .wrongname
 ; We found the addressed DISK structure.
 ; 5. Reference the disk.
-lock    inc     [ecx+DISK.RefCount]
+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.
-        mov     dword [ebx], 0
+        call    mutex_unlock
 ; 7. Acquire the mutex for media object.
         pop     edi             ; restore edi
-        lea     ebx, [ecx+DISK.MediaLock]
+        lea     ecx, [ebx+DISK.MediaLock]
-        call    wait_mutex
+        call    mutex_lock
 ; 8. Get the media object. If it is not NULL, reference it.
         xor     edx, edx
-        cmp     [ecx+DISK.MediaInserted], dl
+        cmp     [ebx+DISK.MediaInserted], dl
         jz      @f
-        mov     edx, ecx
+        mov     edx, ebx
-        inc     [ecx+DISK.MediaRefCount]
+        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     dword [ebx], 0
+        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
         test    byte [edx+DISK.DriverFlags], DISK_NO_INSERT_NOTIFICATION
         jz      .deverror
 ; if the driver does not support insert notifications and we are the only fs
 ; operation with this disk, issue the fake insert notification; if media is
 ; still not inserted, 'disk_media_changed' will detect this and do nothing
-        push    ebx
+;;;        push    ebx
-        lea     ebx, [edx+DISK.MediaLock]
+        lea     ecx, [edx+DISK.MediaLock]
-        call    wait_mutex
+        call    mutex_lock
         cmp     [edx+DISK.MediaRefCount], 1
         jnz     .noluck
-        mov     dword [ebx], 0
+        call    mutex_unlock
         push    edx
         stdcall disk_media_changed, edx, 1
         pop     edx
+        lea     ecx, [edx+DISK.MediaLock]
-        call    wait_mutex
+        call    mutex_lock
         cmp     [edx+DISK.MediaInserted], 0
         jz      .noluck
 lock    inc     [edx+DISK.MediaRefCount]
-        mov     dword [ebx], 0
+        call    mutex_unlock
         xor     ecx, ecx
         jmp     .main
 .noluck:
-        mov     dword [ebx], 0
+        call    mutex_unlock
 .deverror:
         mov     dword [esp+32], ERROR_DEVICE
         mov     esi, edx
         call    disk_dereference
         ret
 ; 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    ebx             ; save register used in file_system_lfn
-        mov     ebx, disk_list_mutex    ; it will be useful
+        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    wait_mutex
+        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.
 ; 5. Return with eax = item.
         pop     ebx             ; restore register used in file_system_lfn
         ret
 .last:
 ; 6. Release the mutex and return with eax = 0.
+        call    mutex_unlock
         xor     eax, eax
-        mov     dword [ebx], eax
         pop     ebx             ; restore register used in file_system_lfn
         ret

Subversion Repositories Kolibri OS

(root)/kernel/trunk/fs/disk.inc – Rev 2120 → 2129