WebSVN – Kolibri OS – Diff – /kernel/branches/Kolibri-acpi/fs/fs.inc


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                              ;;
;; Copyright (C) KolibriOS team 2004-2011. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License    ;;
;;                                                              ;;
;;                                                              ;;
;; System service for filesystem call                           ;;
;; (C) 2004 Ville Turjanmaa, License: GPL                       ;;
;; 29.04.2006 Elimination of hangup after the                   ;;
;;            expiration hd_wait_timeout (for LBA) -  Mario79   ;;
;; 15.01.2005 get file size/attr/date,                          ;;
;;            file_append (only for hd) - ATV                   ;;
;; 23.11.2004 test if hd/partition is set - ATV                 ;;
;; 18.11.2004 get_disk_info and more error codes - ATV          ;;
;; 08.11.2004 expand_pathz and rename (only for hd) - ATV       ;;
;; 20.10.2004 Makedir/Removedir (only for hd) - ATV             ;;
;;                                                              ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
$Revision: 3555 $
 
 
iglobal
 
if lang eq sp
include 'fs/fs-sp.inc'
else
dir0:
             db  'HARDDISK   '
             db  'RAMDISK    '
             db  'FLOPPYDISK '
             db  0
 
dir1:
             db  'FIRST      '
             db  'SECOND     '
             db  'THIRD      '
             db  'FOURTH     '
             db  0
end if
 
not_select_IDE db 0
 
hd_address_table:
                   dd  0x1f0,0x00,0x1f0,0x10
                   dd  0x170,0x00,0x170,0x10
endg
 
file_system:
 
; IN:
;
; eax = 0  ; read file          /RamDisk/First  6
; eax = 8  ; lba read
; eax = 15 ; get_disk_info
;
; OUT:
;
; eax = 0  : read ok
; eax = 1  : no hd base and/or partition defined
; eax = 2  : function is unsupported for this FS
; eax = 3  : unknown FS
; eax = 4  : partition not defined at hd
; eax = 5  : file not found
; eax = 6  : end of file
; eax = 7  : memory pointer not in application area
; eax = 8  : disk full
; eax = 9  : fat table corrupted
; eax = 10 : access denied
; eax = 11 : disk error
;
; ebx = size
 
; \begin{diamond}[18.03.2006]
; for subfunction 16 (start application) error codes must be negative
;    because positive values are valid PIDs
; so possible return values are:
; eax > 0 : process created, eax=PID
 
; -0x10 <= eax < 0 : -eax is filesystem error code:
; eax = -1  = 0xFFFFFFFF : no hd base and/or partition defined
; eax = -3  = 0xFFFFFFFD : unknown FS
; eax = -5  = 0xFFFFFFFB : file not found
; eax = -6  = 0xFFFFFFFA : unexpected end of file (probably not executable file)
; eax = -9  = 0xFFFFFFF7 : fat table corrupted
; eax = -10 = 0xFFFFFFF6 : access denied
 
; -0x20 <= eax < -0x10: eax is process creation error code:
; eax = -0x20 = 0xFFFFFFE0 : too many processes
; eax = -0x1F = 0xFFFFFFE1 : not Menuet/Kolibri executable
; eax = -0x1E = 0xFFFFFFE2 : no memory
 
; ebx is not changed
 
; \end{diamond}[18.03.2006]
 
    ; Extract parameters
 ;   add    eax, std_application_base_address    ; abs start of info block
 
        cmp     dword [eax+0], 15; GET_DISK_INFO
        je      fs_info
 
        cmp     dword [CURRENT_TASK], 1; no memory checks for kernel requests
        jz      no_checks_for_kernel
        mov     edx, eax
        cmp     dword [eax+0], 1
        jnz     .usual_check
        mov     ebx, [eax+12]
 ;   add   ebx,std_application_base_address
        mov     ecx, [eax+8]
        call    check_region
        test    eax, eax
        jnz     area_in_app_mem
 
.error_output:
        mov     esi, buffer_failed
        call    sys_msg_board_str
;    mov   eax,7
        mov     dword [esp+36], 7
        ret
iglobal
  buffer_failed db 'K : Buffer check failed',13,10,0
endg
.usual_check:
        cmp     dword [eax+0], 0
        mov     ecx, 512
        jnz     .small_size
        mov     ecx, [eax+8]
        shl     ecx, 9
.small_size:
        mov     ebx, [eax+12]
 ;   add   ebx,std_application_base_address
        call    check_region
        test    eax, eax
        jz      .error_output
  area_in_app_mem:
        mov     eax, edx
  no_checks_for_kernel:
 
  fs_read:
 
        mov     ebx, [eax+20]   ; program wants root directory ?
        test    bl, bl
        je      fs_getroot
        test    bh, bh
        jne     fs_noroot
  fs_getroot:
; \begin{diamond}[18.03.2006]
; root - only read is allowed
; other operations return "access denied", eax=10
; (execute operation returns eax=-10)
        cmp     dword [eax], 0
        jz      .read_root
        mov     dword [esp+36], 10
        ret
.read_root:
; \end{diamond}[18.03.2006]
        mov     esi, dir0
        mov     edi, [eax+12]
 ;   add   edi,std_application_base_address
        mov     ecx, 11
        push    ecx
;    cld    ; already is
        rep movsb
        mov     al, 0x10
        stosb
        add     edi, 32-11-1
        pop     ecx
        rep movsb
        stosb
        and     dword [esp+36], 0; ok read
        mov     dword [esp+24], 32*2; size of root
        ret
 
  fs_info:                      ;start of code - Mihasik
        push    eax
        cmp     [eax+21], byte 'r'
        je      fs_info_r
        cmp     [eax+21], byte 'R'
        je      fs_info_r
        mov     eax, 3          ;if unknown disk
        xor     ebx, ebx
        xor     ecx, ecx
        xor     edx, edx
        jmp     fs_info1
  fs_info_r:
        call    ramdisk_free_space;if ramdisk
        mov     ecx, edi        ;free space in ecx
        shr     ecx, 9          ;free clusters
        mov     ebx, 2847       ;total clusters
        mov     edx, 512        ;cluster size
        xor     eax, eax        ;always 0
  fs_info1:
        pop     edi
        mov     [esp+36], eax
        mov     [esp+24], ebx    ; total clusters on disk
        mov     [esp+32], ecx    ; free clusters on disk
        mov     [edi], edx       ; cluster size in bytes
        ret                      ;end of code - Mihasik
 
  fs_noroot:
 
        push    dword [eax+0]   ; read/write/delete/.../makedir/rename/lba/run
        push    dword [eax+4]   ; 512 block number to read
        push    dword [eax+8]   ; bytes to write/append or 512 blocks to read
        mov     ebx, [eax+12]
 ;   add   ebx,std_application_base_address
        push    ebx             ; abs start of return/save area
 
        lea     esi, [eax+20]   ; abs start of dir + filename
        mov     edi, [eax+16]
 ;   add   edi,std_application_base_address    ; abs start of work area
 
        call    expand_pathz
 
        push    edi             ; dir start
        push    ebx             ; name of file start
 
        mov     eax, [edi+1]
        cmp     eax, 'RD  '
        je      fs_yesramdisk
        cmp     eax, 'RAMD'
        jne     fs_noramdisk
 
  fs_yesramdisk:
 
        cmp     byte [edi+1+11], 0
        je      fs_give_dir1
 
        mov     eax, [edi+1+12]
        cmp     eax, '1   '
        je      fs_yesramdisk_first
        cmp     eax, 'FIRS'
        jne     fs_noramdisk
 
  fs_yesramdisk_first:
 
        cmp     dword [esp+20], 8; LBA read ramdisk
        jne     fs_no_LBA_read_ramdisk
 
        mov     eax, [esp+16]   ; LBA block to read
        mov     ecx, [esp+8]    ; abs pointer to return area
 
        call    LBA_read_ramdisk
        jmp     file_system_return
 
 
  fs_no_LBA_read_ramdisk:
 
        cmp     dword [esp+20], 0; READ
        jne     fs_noramdisk_read
 
        mov     eax, [esp+4]    ; fname
        add     eax, 2*12+1
        mov     ebx, [esp+16]   ; block start
        inc     ebx
        mov     ecx, [esp+12]   ; block count
        mov     edx, [esp+8]    ; return
        mov     esi, [esp+0]
        sub     esi, eax
        add     esi, 12+1       ; file name length
        call    fileread
 
        jmp     file_system_return
 
 
  fs_noramdisk_read:
  fs_noramdisk:
 
  ;********************************************************************
        mov     eax, [edi+1]
        cmp     eax, 'FD  '
        je      fs_yesflpdisk
        cmp     eax, 'FLOP'
        jne     fs_noflpdisk
 
  fs_yesflpdisk:
        call    reserve_flp
 
        cmp     byte [edi+1+11], 0
        je      fs_give_dir1
 
        mov     eax, [edi+1+12]
        cmp     eax, '1   '
        je      fs_yesflpdisk_first
        cmp     eax, 'FIRS'
        je      fs_yesflpdisk_first
        cmp     eax, '2   '
        je      fs_yesflpdisk_second
        cmp     eax, 'SECO'
        jne     fs_noflpdisk
        jmp     fs_yesflpdisk_second
 
  fs_yesflpdisk_first:
        mov     [flp_number], 1
        jmp     fs_yesflpdisk_start
  fs_yesflpdisk_second:
        mov     [flp_number], 2
  fs_yesflpdisk_start:
        cmp     dword [esp+20], 0; READ
        jne     fs_noflpdisk_read
 
        mov     eax, [esp+4]    ; fname
        add     eax, 2*12+1
        mov     ebx, [esp+16]   ; block start
        inc     ebx
        mov     ecx, [esp+12]   ; block count
        mov     edx, [esp+8]    ; return
        mov     esi, [esp+0]
        sub     esi, eax
        add     esi, 12+1       ; file name length
        call    floppy_fileread
 
        jmp     file_system_return
 
 
  fs_noflpdisk_read:
  fs_noflpdisk:
  ;*****************************************************************
 
        mov     eax, [edi+1]
        cmp     eax, 'HD0 '
        je      fs_yesharddisk_IDE0
        cmp     eax, 'HD1 '
        je      fs_yesharddisk_IDE1
        cmp     eax, 'HD2 '
        je      fs_yesharddisk_IDE2
        cmp     eax, 'HD3 '
        je      fs_yesharddisk_IDE3
        jmp     old_path_harddisk
fs_yesharddisk_IDE0:
        call    reserve_hd1
        mov     [hdbase], 0x1f0
        mov     [hdid], 0x0
        mov     [hdpos], 1
        jmp     fs_yesharddisk_partition
fs_yesharddisk_IDE1:
        call    reserve_hd1
        mov     [hdbase], 0x1f0
        mov     [hdid], 0x10
        mov     [hdpos], 2
        jmp     fs_yesharddisk_partition
fs_yesharddisk_IDE2:
        call    reserve_hd1
        mov     [hdbase], 0x170
        mov     [hdid], 0x0
        mov     [hdpos], 3
        jmp     fs_yesharddisk_partition
fs_yesharddisk_IDE3:
        call    reserve_hd1
        mov     [hdbase], 0x170
        mov     [hdid], 0x10
        mov     [hdpos], 4
fs_yesharddisk_partition:
        call    reserve_hd_channel
;    call  choice_necessity_partition
;    jmp   fs_yesharddisk_all
        jmp     fs_for_new_semantic
 
choice_necessity_partition:
        mov     eax, [edi+1+12]
        call    StringToNumber
        mov     [fat32part], eax
choice_necessity_partition_1:
        mov     ecx, [hdpos]
        xor     eax, eax
        mov     [hd_entries], eax; entries in hd cache
        mov     edx, DRIVE_DATA+2
        cmp     ecx, 0x80
        jb      search_partition_array
        mov     ecx, 4
 search_partition_array:
        mov     bl, [edx]
        movzx   ebx, bl
        add     eax, ebx
        inc     edx
        loop    search_partition_array
        mov     ecx, [hdpos]
        mov     edx, BiosDiskPartitions
        sub     ecx, 0x80
        jb      .s
        je      .f
 @@:
        mov     ebx, [edx]
        add     edx, 4
        add     eax, ebx
        loop    @b
        jmp     .f
 .s:
        sub     eax, ebx
 .f:
        add     eax, [known_part];   add   eax,[fat32part]
        dec     eax
        xor     edx, edx
        imul    eax, 100
        add     eax, DRIVE_DATA+0xa
        mov     [transfer_adress], eax
        call    partition_data_transfer_1
        ret
 
 old_path_harddisk:
        mov     eax, [edi+1]
        cmp     eax, 'HD  '
        je      fs_yesharddisk
        cmp     eax, 'HARD'
        jne     fs_noharddisk
 
  fs_yesharddisk:
        cmp     dword [esp+20], 8; LBA read
        jne     fs_no_LBA_read
        mov     eax, [esp+16]   ; LBA block to read
        lea     ebx, [edi+1+12] ; pointer to FIRST/SECOND/THIRD/FOURTH
        mov     ecx, [esp+8]    ; abs pointer to return area
        call    LBA_read
        jmp     file_system_return
 
  fs_no_LBA_read:
 
        cmp     byte [edi+1+11], 0; directory read
        je      fs_give_dir1
        call    reserve_hd1
 fs_for_new_semantic:
        call    choice_necessity_partition
 
  fs_yesharddisk_all:
        mov     eax, 1
        mov     ebx, [esp+24+24]
        cmp     [hdpos], 0      ; is hd base set?
        jz      hd_err_return
        cmp     [fat32part], 0  ; is partition set?
        jnz     @f
hd_err_return:
        call    free_hd_channel
        and     [hd1_status], 0
        jmp     file_system_return
@@:
 
        call    free_hd_channel
        and     [hd1_status], 0
 
  fs_noharddisk:
; \begin{diamond}[18.03.2006]
        mov     eax, 5   ; file not found
; а может быть, возвращать другой код ошибки?
        mov     ebx, [esp+24+24]; do not change ebx in application
; \end{diamond}[18.03.2006]
 
  file_system_return:
 
        add     esp, 24
 
        mov     [esp+36], eax
        mov     [esp+24], ebx
        ret
 
 
  fs_give_dir1:
 
; \begin{diamond}[18.03.2006]
; /RD,/FD,/HD - only read is allowed
; other operations return "access denied", eax=10
; (execute operation returns eax=-10)
        cmp     dword [esp+20], 0
        jz      .read
        add     esp, 20
        pop     ecx
        mov     dword [esp+36], 10
        ret
.read:
; \end{diamond}[18.03.2006]
        mov     al, 0x10
        mov     ebx, 1
        mov     edi, [esp+8]
        mov     esi, dir1
  fs_d1_new:
        mov     ecx, 11
;    cld
        rep movsb
        stosb
        add     edi, 32-11-1
        dec     ebx
        jne     fs_d1_new
 
        add     esp, 24
 
        and     dword [esp+36], 0; ok read
        mov     dword [esp+24], 32*1; dir/data size
        ret
 
 
 
LBA_read_ramdisk:
 
        cmp     [lba_read_enabled], 1
        je      lbarrl1
 
        xor     ebx, ebx
        mov     eax, 2
        ret
 
  lbarrl1:
 
        cmp     eax, 18*2*80
        jb      lbarrl2
        xor     ebx, ebx
        mov     eax, 3
        ret
 
  lbarrl2:
 
        pushad
 
        call    restorefatchain
 
        mov     edi, ecx
        mov     esi, eax
 
        shl     esi, 9
        add     esi, RAMDISK
        mov     ecx, 512/4
;    cld
        rep movsd
 
        popad
 
        xor     ebx, ebx
        xor     eax, eax
        ret
 
LBA_read:
 
; IN:
;
; eax = LBA block to read
; ebx = pointer to FIRST/SECOND/THIRD/FOURTH
; ecx = abs pointer to return area
 
        cmp     [lba_read_enabled], 1
        je      lbarl1
        mov     eax, 2
        ret
 
  lbarl1:
 
        call    reserve_hd1
 
        push    eax
        push    ecx
 
        mov     edi, hd_address_table
        mov     esi, dir1
        mov     eax, [ebx]
        mov     edx, '1   '
        mov     ecx, 4
  blar0:
        cmp     eax, [esi]
        je      blar2
        cmp     eax, edx
        je      blar2
        inc     edx
        add     edi, 8
        add     esi, 11
        dec     ecx
        jnz     blar0
 
        mov     eax, 1
        mov     ebx, 1
        jmp     LBA_read_ret
 
  blar2:
        mov     eax, [edi+0]
        mov     ebx, [edi+4]
 
        mov     [hdbase], eax
        mov     [hdid], ebx
 
        call    wait_for_hd_idle
        cmp     [hd_error], 0
        jne     hd_lba_error
 
    ; eax = hd port
    ; ebx = set for primary (0x00) or slave (0x10)
 
        cli
 
        mov     edx, eax
        inc     edx
        xor     eax, eax
        out     dx, al
        inc     edx
        inc     eax
        out     dx, al
        inc     edx
        mov     eax, [esp+4]
        out     dx, al
        shr     eax, 8
        inc     edx
        out     dx, al
        shr     eax, 8
        inc     edx
        out     dx, al
        shr     eax, 8
        inc     edx
        and     al, 1+2+4+8
        add     al, bl
        add     al, 128+64+32
        out     dx, al
 
        inc     edx
        mov     al, 20h
        out     dx, al
 
        sti
 
        call    wait_for_sector_buffer
        cmp     [hd_error], 0
        jne     hd_lba_error
 
        cli
 
        mov     edi, [esp+0]
        mov     ecx, 256
        sub     edx, 7
        cld
        rep insw
 
        sti
 
        xor     eax, eax
        xor     ebx, ebx
 
  LBA_read_ret:
        mov     [hd_error], 0
        mov     [hd1_status], 0
        add     esp, 2*4
 
        ret
 
 
expand_pathz:
; IN:
;   esi = asciiz path & file
;   edi = buffer for path & file name
; OUT:
;   edi = directory & file : / 11 + / 11 + / 11 - zero terminated
;   ebx = /file name - zero terminated
;   esi = pointer after source
 
        push    eax
        push    ecx
        push    edi;[esp+0]
 
  pathz_start:
        mov     byte [edi], '/'
        inc     edi
        mov     al, 32
        mov     ecx, 11
        cld
        rep stosb               ; clear filename area
        sub     edi, 11
        mov     ebx, edi        ; start of dir/file name
 
  pathz_new_char:
        mov     al, [esi]
        inc     esi
        cmp     al, 0
        je      pathz_end
 
        cmp     al, '/'
        jne     pathz_not_path
        cmp     edi, ebx        ; skip first '/'
        jz      pathz_new_char
        lea     edi, [ebx+11]   ; start of next directory
        jmp     pathz_start
 
  pathz_not_path:
        cmp     al, '.'
        jne     pathz_not_ext
        lea     edi, [ebx+8]    ; start of extension
        jmp     pathz_new_char
 
  pathz_not_ext:
        cmp     al, 'a'
        jb      pathz_not_low
        cmp     al, 'z'
        ja      pathz_not_low
        sub     al, 0x20        ; char to uppercase
 
  pathz_not_low:
        mov     [edi], al
        inc     edi
        mov     eax, [esp+0]    ; start_of_dest_path
        add     eax, 512        ; keep maximum path under 512 bytes
        cmp     edi, eax
        jb      pathz_new_char
 
  pathz_end:
        cmp     ebx, edi        ; if path end with '/'
        jnz     pathz_put_zero  ; go back 1 level
        sub     ebx, 12
 
  pathz_put_zero:
        mov     byte [ebx+11], 0
        dec     ebx             ; include '/' char into file name
        pop     edi
        pop     ecx
        pop     eax
        ret
 
;*******************************************
;* string to number
;* input eax - 4 byte string
;* output eax - number
;*******************************************
StringToNumber:
;    ПЕРЕВОД СТРОКОВОГО ЧИСЛА В ЧИСЛОВОЙ ВИД
;    Вход:
;        EDI - адрес строки с числом. Конец числа отмечен кодом 0Dh
;    Выход:
;        CF - индикатор ошибок:
;            0 - ошибок нет;
;            1 - ошибка
;        Если CF=0, то AX - число.
 
        push    bx
        push    cx
        push    dx
        push    edi
        mov     [partition_string], eax
        mov     edi, partition_string
        xor     cx, cx
i1:
        mov     al, [edi]
        cmp     al, 32;13
        je      i_exit
;    cmp    al,'0'
;    jb    err
;    cmp    al,'9'
;    ja    err
        sub     al, 48
        shl     cx, 1
        jc      error
        mov     bx, cx
        shl     cx, 1
        jc      error
        shl     cx, 1
        jc      error
        add     cx, bx
        jc      error
        cbw
        add     cx, ax
        jc      error
i3:
        inc     edi
        jmp     i1
i_exit:
        mov     ax, cx
        clc
i4:
        movzx   eax, ax
        pop     edi
        pop     dx
        pop     cx
        pop     bx
        ret
 
error:
        stc
        jmp     i4
 
partition_string:
                  dd 0
                  db 32

Rev 3500	Rev 3555
1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2	;; ;;	2	;; ;;
3	;; Copyright (C) KolibriOS team 2004-2011. All rights reserved. ;;	3	;; Copyright (C) KolibriOS team 2004-2011. 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	;; System service for filesystem call ;;	7	;; System service for filesystem call ;;
8	;; (C) 2004 Ville Turjanmaa, License: GPL ;;	8	;; (C) 2004 Ville Turjanmaa, License: GPL ;;
9	;; 29.04.2006 Elimination of hangup after the ;;	9	;; 29.04.2006 Elimination of hangup after the ;;
10	;; expiration hd_wait_timeout (for LBA) - Mario79 ;;	10	;; expiration hd_wait_timeout (for LBA) - Mario79 ;;
11	;; 15.01.2005 get file size/attr/date, ;;	11	;; 15.01.2005 get file size/attr/date, ;;
12	;; file_append (only for hd) - ATV ;;	12	;; file_append (only for hd) - ATV ;;
13	;; 23.11.2004 test if hd/partition is set - ATV ;;	13	;; 23.11.2004 test if hd/partition is set - ATV ;;
14	;; 18.11.2004 get_disk_info and more error codes - ATV ;;	14	;; 18.11.2004 get_disk_info and more error codes - ATV ;;
15	;; 08.11.2004 expand_pathz and rename (only for hd) - ATV ;;	15	;; 08.11.2004 expand_pathz and rename (only for hd) - ATV ;;
16	;; 20.10.2004 Makedir/Removedir (only for hd) - ATV ;;	16	;; 20.10.2004 Makedir/Removedir (only for hd) - ATV ;;
17	;; ;;	17	;; ;;
18	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	18	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
19		19
20	$Revision: 3500 $	20	$Revision: 3555 $
21		21
22		22
23	iglobal	23	iglobal
24		24
25	if lang eq sp	25	if lang eq sp
26	include 'fs/fs-sp.inc'	26	include 'fs/fs-sp.inc'
27	else	27	else
28	dir0:	28	dir0:
29	db 'HARDDISK '	29	db 'HARDDISK '
30	db 'RAMDISK '	30	db 'RAMDISK '
31	db 'FLOPPYDISK '	31	db 'FLOPPYDISK '
32	db 0	32	db 0
33		33
34	dir1:	34	dir1:
35	db 'FIRST '	35	db 'FIRST '
36	db 'SECOND '	36	db 'SECOND '
37	db 'THIRD '	37	db 'THIRD '
38	db 'FOURTH '	38	db 'FOURTH '
39	db 0	39	db 0
40	end if	40	end if
41		41
42	not_select_IDE db 0	42	not_select_IDE db 0
43		43
44	hd_address_table:	44	hd_address_table:
45	dd 0x1f0,0x00,0x1f0,0x10	45	dd 0x1f0,0x00,0x1f0,0x10
46	dd 0x170,0x00,0x170,0x10	46	dd 0x170,0x00,0x170,0x10
47	endg	47	endg
48		48
49	file_system:	49	file_system:
50		50
51	; IN:	51	; IN:
52	;	52	;
53	; eax = 0 ; read file /RamDisk/First 6	53	; eax = 0 ; read file /RamDisk/First 6
54	; eax = 8 ; lba read	54	; eax = 8 ; lba read
55	; eax = 15 ; get_disk_info	55	; eax = 15 ; get_disk_info
56	;	56	;
57	; OUT:	57	; OUT:
58	;	58	;
59	; eax = 0 : read ok	59	; eax = 0 : read ok
60	; eax = 1 : no hd base and/or partition defined	60	; eax = 1 : no hd base and/or partition defined
61	; eax = 2 : function is unsupported for this FS	61	; eax = 2 : function is unsupported for this FS
62	; eax = 3 : unknown FS	62	; eax = 3 : unknown FS
63	; eax = 4 : partition not defined at hd	63	; eax = 4 : partition not defined at hd
64	; eax = 5 : file not found	64	; eax = 5 : file not found
65	; eax = 6 : end of file	65	; eax = 6 : end of file
66	; eax = 7 : memory pointer not in application area	66	; eax = 7 : memory pointer not in application area
67	; eax = 8 : disk full	67	; eax = 8 : disk full
68	; eax = 9 : fat table corrupted	68	; eax = 9 : fat table corrupted
69	; eax = 10 : access denied	69	; eax = 10 : access denied
70	; eax = 11 : disk error	70	; eax = 11 : disk error
71	;	71	;
72	; ebx = size	72	; ebx = size
73		73
74	; \begin{diamond}[18.03.2006]	74	; \begin{diamond}[18.03.2006]
75	; for subfunction 16 (start application) error codes must be negative	75	; for subfunction 16 (start application) error codes must be negative
76	; because positive values are valid PIDs	76	; because positive values are valid PIDs
77	; so possible return values are:	77	; so possible return values are:
78	; eax > 0 : process created, eax=PID	78	; eax > 0 : process created, eax=PID
79		79
80	; -0x10 <= eax < 0 : -eax is filesystem error code:	80	; -0x10 <= eax < 0 : -eax is filesystem error code:
81	; eax = -1 = 0xFFFFFFFF : no hd base and/or partition defined	81	; eax = -1 = 0xFFFFFFFF : no hd base and/or partition defined
82	; eax = -3 = 0xFFFFFFFD : unknown FS	82	; eax = -3 = 0xFFFFFFFD : unknown FS
83	; eax = -5 = 0xFFFFFFFB : file not found	83	; eax = -5 = 0xFFFFFFFB : file not found
84	; eax = -6 = 0xFFFFFFFA : unexpected end of file (probably not executable file)	84	; eax = -6 = 0xFFFFFFFA : unexpected end of file (probably not executable file)
85	; eax = -9 = 0xFFFFFFF7 : fat table corrupted	85	; eax = -9 = 0xFFFFFFF7 : fat table corrupted
86	; eax = -10 = 0xFFFFFFF6 : access denied	86	; eax = -10 = 0xFFFFFFF6 : access denied
87		87
88	; -0x20 <= eax < -0x10: eax is process creation error code:	88	; -0x20 <= eax < -0x10: eax is process creation error code:
89	; eax = -0x20 = 0xFFFFFFE0 : too many processes	89	; eax = -0x20 = 0xFFFFFFE0 : too many processes
90	; eax = -0x1F = 0xFFFFFFE1 : not Menuet/Kolibri executable	90	; eax = -0x1F = 0xFFFFFFE1 : not Menuet/Kolibri executable
91	; eax = -0x1E = 0xFFFFFFE2 : no memory	91	; eax = -0x1E = 0xFFFFFFE2 : no memory
92		92
93	; ebx is not changed	93	; ebx is not changed
94		94
95	; \end{diamond}[18.03.2006]	95	; \end{diamond}[18.03.2006]
96		96
97	; Extract parameters	97	; Extract parameters
98	; add eax, std_application_base_address ; abs start of info block	98	; add eax, std_application_base_address ; abs start of info block
99		99
100	cmp dword [eax+0], 15; GET_DISK_INFO	100	cmp dword [eax+0], 15; GET_DISK_INFO
101	je fs_info	101	je fs_info
102		102
103	cmp dword [CURRENT_TASK], 1; no memory checks for kernel requests	103	cmp dword [CURRENT_TASK], 1; no memory checks for kernel requests
104	jz no_checks_for_kernel	104	jz no_checks_for_kernel
105	mov edx, eax	105	mov edx, eax
106	cmp dword [eax+0], 1	106	cmp dword [eax+0], 1
107	jnz .usual_check	107	jnz .usual_check
108	mov ebx, [eax+12]	108	mov ebx, [eax+12]
109	; add ebx,std_application_base_address	109	; add ebx,std_application_base_address
110	mov ecx, [eax+8]	110	mov ecx, [eax+8]
111	call check_region	111	call check_region
112	test eax, eax	112	test eax, eax
113	jnz area_in_app_mem	113	jnz area_in_app_mem
114		114
115	.error_output:	115	.error_output:
116	mov esi, buffer_failed	116	mov esi, buffer_failed
117	call sys_msg_board_str	117	call sys_msg_board_str
118	; mov eax,7	118	; mov eax,7
119	mov dword [esp+36], 7	119	mov dword [esp+36], 7
120	ret	120	ret
121	iglobal	121	iglobal
122	buffer_failed db 'K : Buffer check failed',13,10,0	122	buffer_failed db 'K : Buffer check failed',13,10,0
123	endg	123	endg
124	.usual_check:	124	.usual_check:
125	cmp dword [eax+0], 0	125	cmp dword [eax+0], 0
126	mov ecx, 512	126	mov ecx, 512
127	jnz .small_size	127	jnz .small_size
128	mov ecx, [eax+8]	128	mov ecx, [eax+8]
129	shl ecx, 9	129	shl ecx, 9
130	.small_size:	130	.small_size:
131	mov ebx, [eax+12]	131	mov ebx, [eax+12]
132	; add ebx,std_application_base_address	132	; add ebx,std_application_base_address
133	call check_region	133	call check_region
134	test eax, eax	134	test eax, eax
135	jz .error_output	135	jz .error_output
136	area_in_app_mem:	136	area_in_app_mem:
137	mov eax, edx	137	mov eax, edx
138	no_checks_for_kernel:	138	no_checks_for_kernel:
139		139
140	fs_read:	140	fs_read:
141		141
142	mov ebx, [eax+20] ; program wants root directory ?	142	mov ebx, [eax+20] ; program wants root directory ?
143	test bl, bl	143	test bl, bl
144	je fs_getroot	144	je fs_getroot
145	test bh, bh	145	test bh, bh
146	jne fs_noroot	146	jne fs_noroot
147	fs_getroot:	147	fs_getroot:
148	; \begin{diamond}[18.03.2006]	148	; \begin{diamond}[18.03.2006]
149	; root - only read is allowed	149	; root - only read is allowed
150	; other operations return "access denied", eax=10	150	; other operations return "access denied", eax=10
151	; (execute operation returns eax=-10)	151	; (execute operation returns eax=-10)
152	cmp dword [eax], 0	152	cmp dword [eax], 0
153	jz .read_root	153	jz .read_root
154	mov dword [esp+36], 10	154	mov dword [esp+36], 10
155	ret	155	ret
156	.read_root:	156	.read_root:
157	; \end{diamond}[18.03.2006]	157	; \end{diamond}[18.03.2006]
158	mov esi, dir0	158	mov esi, dir0
159	mov edi, [eax+12]	159	mov edi, [eax+12]
160	; add edi,std_application_base_address	160	; add edi,std_application_base_address
161	mov ecx, 11	161	mov ecx, 11
162	push ecx	162	push ecx
163	; cld ; already is	163	; cld ; already is
164	rep movsb	164	rep movsb
165	mov al, 0x10	165	mov al, 0x10
166	stosb	166	stosb
167	add edi, 32-11-1	167	add edi, 32-11-1
168	pop ecx	168	pop ecx
169	rep movsb	169	rep movsb
170	stosb	170	stosb
171	and dword [esp+36], 0; ok read	171	and dword [esp+36], 0; ok read
172	mov dword [esp+24], 32*2; size of root	172	mov dword [esp+24], 32*2; size of root
173	ret	173	ret
174		174
175	fs_info: ;start of code - Mihasik	175	fs_info: ;start of code - Mihasik
176	push eax	176	push eax
177	cmp [eax+21], byte 'r'	177	cmp [eax+21], byte 'r'
178	je fs_info_r	178	je fs_info_r
179	cmp [eax+21], byte 'R'	179	cmp [eax+21], byte 'R'
180	je fs_info_r	180	je fs_info_r
181	mov eax, 3 ;if unknown disk	181	mov eax, 3 ;if unknown disk
182	xor ebx, ebx	182	xor ebx, ebx
183	xor ecx, ecx	183	xor ecx, ecx
184	xor edx, edx	184	xor edx, edx
185	jmp fs_info1	185	jmp fs_info1
186	fs_info_r:	186	fs_info_r:
187	call ramdisk_free_space;if ramdisk	187	call ramdisk_free_space;if ramdisk
188	mov ecx, edi ;free space in ecx	188	mov ecx, edi ;free space in ecx
189	shr ecx, 9 ;free clusters	189	shr ecx, 9 ;free clusters
190	mov ebx, 2847 ;total clusters	190	mov ebx, 2847 ;total clusters
191	mov edx, 512 ;cluster size	191	mov edx, 512 ;cluster size
192	xor eax, eax ;always 0	192	xor eax, eax ;always 0
193	fs_info1:	193	fs_info1:
194	pop edi	194	pop edi
195	mov [esp+36], eax	195	mov [esp+36], eax
196	mov [esp+24], ebx ; total clusters on disk	196	mov [esp+24], ebx ; total clusters on disk
197	mov [esp+32], ecx ; free clusters on disk	197	mov [esp+32], ecx ; free clusters on disk
198	mov [edi], edx ; cluster size in bytes	198	mov [edi], edx ; cluster size in bytes
199	ret ;end of code - Mihasik	199	ret ;end of code - Mihasik
200		200
201	fs_noroot:	201	fs_noroot:
202		202
203	push dword [eax+0] ; read/write/delete/.../makedir/rename/lba/run	203	push dword [eax+0] ; read/write/delete/.../makedir/rename/lba/run
204	push dword [eax+4] ; 512 block number to read	204	push dword [eax+4] ; 512 block number to read
205	push dword [eax+8] ; bytes to write/append or 512 blocks to read	205	push dword [eax+8] ; bytes to write/append or 512 blocks to read
206	mov ebx, [eax+12]	206	mov ebx, [eax+12]
207	; add ebx,std_application_base_address	207	; add ebx,std_application_base_address
208	push ebx ; abs start of return/save area	208	push ebx ; abs start of return/save area
209		209
210	lea esi, [eax+20] ; abs start of dir + filename	210	lea esi, [eax+20] ; abs start of dir + filename
211	mov edi, [eax+16]	211	mov edi, [eax+16]
212	; add edi,std_application_base_address ; abs start of work area	212	; add edi,std_application_base_address ; abs start of work area
213		213
214	call expand_pathz	214	call expand_pathz
215		215
216	push edi ; dir start	216	push edi ; dir start
217	push ebx ; name of file start	217	push ebx ; name of file start
218		218
219	mov eax, [edi+1]	219	mov eax, [edi+1]
220	cmp eax, 'RD '	220	cmp eax, 'RD '
221	je fs_yesramdisk	221	je fs_yesramdisk
222	cmp eax, 'RAMD'	222	cmp eax, 'RAMD'
223	jne fs_noramdisk	223	jne fs_noramdisk
224		224
225	fs_yesramdisk:	225	fs_yesramdisk:
226		226
227	cmp byte [edi+1+11], 0	227	cmp byte [edi+1+11], 0
228	je fs_give_dir1	228	je fs_give_dir1
229		229
230	mov eax, [edi+1+12]	230	mov eax, [edi+1+12]
231	cmp eax, '1 '	231	cmp eax, '1 '
232	je fs_yesramdisk_first	232	je fs_yesramdisk_first
233	cmp eax, 'FIRS'	233	cmp eax, 'FIRS'
234	jne fs_noramdisk	234	jne fs_noramdisk
235		235
236	fs_yesramdisk_first:	236	fs_yesramdisk_first:
237		237
238	cmp dword [esp+20], 8; LBA read ramdisk	238	cmp dword [esp+20], 8; LBA read ramdisk
239	jne fs_no_LBA_read_ramdisk	239	jne fs_no_LBA_read_ramdisk
240		240
241	mov eax, [esp+16] ; LBA block to read	241	mov eax, [esp+16] ; LBA block to read
242	mov ecx, [esp+8] ; abs pointer to return area	242	mov ecx, [esp+8] ; abs pointer to return area
243		243
244	call LBA_read_ramdisk	244	call LBA_read_ramdisk
245	jmp file_system_return	245	jmp file_system_return
246		246
247		247
248	fs_no_LBA_read_ramdisk:	248	fs_no_LBA_read_ramdisk:
249		249
250	cmp dword [esp+20], 0; READ	250	cmp dword [esp+20], 0; READ
251	jne fs_noramdisk_read	251	jne fs_noramdisk_read
252		252
253	mov eax, [esp+4] ; fname	253	mov eax, [esp+4] ; fname
254	add eax, 2*12+1	254	add eax, 2*12+1
255	mov ebx, [esp+16] ; block start	255	mov ebx, [esp+16] ; block start
256	inc ebx	256	inc ebx
257	mov ecx, [esp+12] ; block count	257	mov ecx, [esp+12] ; block count
258	mov edx, [esp+8] ; return	258	mov edx, [esp+8] ; return
259	mov esi, [esp+0]	259	mov esi, [esp+0]
260	sub esi, eax	260	sub esi, eax
261	add esi, 12+1 ; file name length	261	add esi, 12+1 ; file name length
262	call fileread	262	call fileread
263		263
264	jmp file_system_return	264	jmp file_system_return
265		265
266		266
267	fs_noramdisk_read:	267	fs_noramdisk_read:
268	fs_noramdisk:	268	fs_noramdisk:
269		269
270	;********************************************************************	270	;********************************************************************
271	mov eax, [edi+1]	271	mov eax, [edi+1]
272	cmp eax, 'FD '	272	cmp eax, 'FD '
273	je fs_yesflpdisk	273	je fs_yesflpdisk
274	cmp eax, 'FLOP'	274	cmp eax, 'FLOP'
275	jne fs_noflpdisk	275	jne fs_noflpdisk
276		276
277	fs_yesflpdisk:	277	fs_yesflpdisk:
278	call reserve_flp	278	call reserve_flp
279		279
280	cmp byte [edi+1+11], 0	280	cmp byte [edi+1+11], 0
281	je fs_give_dir1	281	je fs_give_dir1
282		282
283	mov eax, [edi+1+12]	283	mov eax, [edi+1+12]
284	cmp eax, '1 '	284	cmp eax, '1 '
285	je fs_yesflpdisk_first	285	je fs_yesflpdisk_first
286	cmp eax, 'FIRS'	286	cmp eax, 'FIRS'
287	je fs_yesflpdisk_first	287	je fs_yesflpdisk_first
288	cmp eax, '2 '	288	cmp eax, '2 '
289	je fs_yesflpdisk_second	289	je fs_yesflpdisk_second
290	cmp eax, 'SECO'	290	cmp eax, 'SECO'
291	jne fs_noflpdisk	291	jne fs_noflpdisk
292	jmp fs_yesflpdisk_second	292	jmp fs_yesflpdisk_second
293		293
294	fs_yesflpdisk_first:	294	fs_yesflpdisk_first:
295	mov [flp_number], 1	295	mov [flp_number], 1
296	jmp fs_yesflpdisk_start	296	jmp fs_yesflpdisk_start
297	fs_yesflpdisk_second:	297	fs_yesflpdisk_second:
298	mov [flp_number], 2	298	mov [flp_number], 2
299	fs_yesflpdisk_start:	299	fs_yesflpdisk_start:
300	cmp dword [esp+20], 0; READ	300	cmp dword [esp+20], 0; READ
301	jne fs_noflpdisk_read	301	jne fs_noflpdisk_read
302		302
303	mov eax, [esp+4] ; fname	303	mov eax, [esp+4] ; fname
304	add eax, 2*12+1	304	add eax, 2*12+1
305	mov ebx, [esp+16] ; block start	305	mov ebx, [esp+16] ; block start
306	inc ebx	306	inc ebx
307	mov ecx, [esp+12] ; block count	307	mov ecx, [esp+12] ; block count
308	mov edx, [esp+8] ; return	308	mov edx, [esp+8] ; return
309	mov esi, [esp+0]	309	mov esi, [esp+0]
310	sub esi, eax	310	sub esi, eax
311	add esi, 12+1 ; file name length	311	add esi, 12+1 ; file name length
312	call floppy_fileread	312	call floppy_fileread
313		313
314	jmp file_system_return	314	jmp file_system_return
315		315
316		316
317	fs_noflpdisk_read:	317	fs_noflpdisk_read:
318	fs_noflpdisk:	318	fs_noflpdisk:
319	;*****************************************************************	319	;*****************************************************************
320		320
321	mov eax, [edi+1]	321	mov eax, [edi+1]
322	cmp eax, 'HD0 '	322	cmp eax, 'HD0 '
323	je fs_yesharddisk_IDE0	323	je fs_yesharddisk_IDE0
324	cmp eax, 'HD1 '	324	cmp eax, 'HD1 '
325	je fs_yesharddisk_IDE1	325	je fs_yesharddisk_IDE1
326	cmp eax, 'HD2 '	326	cmp eax, 'HD2 '
327	je fs_yesharddisk_IDE2	327	je fs_yesharddisk_IDE2
328	cmp eax, 'HD3 '	328	cmp eax, 'HD3 '
329	je fs_yesharddisk_IDE3	329	je fs_yesharddisk_IDE3
330	jmp old_path_harddisk	330	jmp old_path_harddisk
331	fs_yesharddisk_IDE0:	331	fs_yesharddisk_IDE0:
332	call reserve_hd1	332	call reserve_hd1
333	mov [hdbase], 0x1f0	333	mov [hdbase], 0x1f0
334	mov [hdid], 0x0	334	mov [hdid], 0x0
335	mov [hdpos], 1	335	mov [hdpos], 1
336	jmp fs_yesharddisk_partition	336	jmp fs_yesharddisk_partition
337	fs_yesharddisk_IDE1:	337	fs_yesharddisk_IDE1:
338	call reserve_hd1	338	call reserve_hd1
339	mov [hdbase], 0x1f0	339	mov [hdbase], 0x1f0
340	mov [hdid], 0x10	340	mov [hdid], 0x10
341	mov [hdpos], 2	341	mov [hdpos], 2
342	jmp fs_yesharddisk_partition	342	jmp fs_yesharddisk_partition
343	fs_yesharddisk_IDE2:	343	fs_yesharddisk_IDE2:
344	call reserve_hd1	344	call reserve_hd1
345	mov [hdbase], 0x170	345	mov [hdbase], 0x170
346	mov [hdid], 0x0	346	mov [hdid], 0x0
347	mov [hdpos], 3	347	mov [hdpos], 3
348	jmp fs_yesharddisk_partition	348	jmp fs_yesharddisk_partition
349	fs_yesharddisk_IDE3:	349	fs_yesharddisk_IDE3:
350	call reserve_hd1	350	call reserve_hd1
351	mov [hdbase], 0x170	351	mov [hdbase], 0x170
352	mov [hdid], 0x10	352	mov [hdid], 0x10
353	mov [hdpos], 4	353	mov [hdpos], 4
354	fs_yesharddisk_partition:	354	fs_yesharddisk_partition:
355	call reserve_hd_channel	355	call reserve_hd_channel
356	; call choice_necessity_partition	356	; call choice_necessity_partition
357	; jmp fs_yesharddisk_all	357	; jmp fs_yesharddisk_all
358	jmp fs_for_new_semantic	358	jmp fs_for_new_semantic
359		359
360	choice_necessity_partition:	360	choice_necessity_partition:
361	mov eax, [edi+1+12]	361	mov eax, [edi+1+12]
362	call StringToNumber	362	call StringToNumber
363	mov [fat32part], eax	363	mov [fat32part], eax
364	choice_necessity_partition_1:	364	choice_necessity_partition_1:
365	mov ecx, [hdpos]	365	mov ecx, [hdpos]
366	xor eax, eax	366	xor eax, eax
367	mov [hd_entries], eax; entries in hd cache	367	mov [hd_entries], eax; entries in hd cache
368	mov edx, DRIVE_DATA+2	368	mov edx, DRIVE_DATA+2
369	cmp ecx, 0x80	369	cmp ecx, 0x80
370	jb search_partition_array	370	jb search_partition_array
371	mov ecx, 4	371	mov ecx, 4
372	search_partition_array:	372	search_partition_array:
373	mov bl, [edx]	373	mov bl, [edx]
374	movzx ebx, bl	374	movzx ebx, bl
375	add eax, ebx	375	add eax, ebx
376	inc edx	376	inc edx
377	loop search_partition_array	377	loop search_partition_array
378	mov ecx, [hdpos]	378	mov ecx, [hdpos]
379	mov edx, BiosDiskPartitions	379	mov edx, BiosDiskPartitions
380	sub ecx, 0x80	380	sub ecx, 0x80
381	jb .s	381	jb .s
382	je .f	382	je .f
383	@@:	383	@@:
384	mov ebx, [edx]	384	mov ebx, [edx]
385	add edx, 4	385	add edx, 4
386	add eax, ebx	386	add eax, ebx
387	loop @b	387	loop @b
388	jmp .f	388	jmp .f
389	.s:	389	.s:
390	sub eax, ebx	390	sub eax, ebx
391	.f:	391	.f:
392	add eax, [known_part]; add eax,[fat32part]	392	add eax, [known_part]; add eax,[fat32part]
393	dec eax	393	dec eax
394	xor edx, edx	394	xor edx, edx
395	imul eax, 100	395	imul eax, 100
396	add eax, DRIVE_DATA+0xa	396	add eax, DRIVE_DATA+0xa
397	mov [transfer_adress], eax	397	mov [transfer_adress], eax
398	call partition_data_transfer_1	398	call partition_data_transfer_1
399	ret	399	ret
400		400
401	old_path_harddisk:	401	old_path_harddisk:
402	mov eax, [edi+1]	402	mov eax, [edi+1]
403	cmp eax, 'HD '	403	cmp eax, 'HD '
404	je fs_yesharddisk	404	je fs_yesharddisk
405	cmp eax, 'HARD'	405	cmp eax, 'HARD'
406	jne fs_noharddisk	406	jne fs_noharddisk
407		407
408	fs_yesharddisk:	408	fs_yesharddisk:
409	cmp dword [esp+20], 8; LBA read	409	cmp dword [esp+20], 8; LBA read
410	jne fs_no_LBA_read	410	jne fs_no_LBA_read
411	mov eax, [esp+16] ; LBA block to read	411	mov eax, [esp+16] ; LBA block to read
412	lea ebx, [edi+1+12] ; pointer to FIRST/SECOND/THIRD/FOURTH	412	lea ebx, [edi+1+12] ; pointer to FIRST/SECOND/THIRD/FOURTH
413	mov ecx, [esp+8] ; abs pointer to return area	413	mov ecx, [esp+8] ; abs pointer to return area
414	call LBA_read	414	call LBA_read
415	jmp file_system_return	415	jmp file_system_return
416		416
417	fs_no_LBA_read:	417	fs_no_LBA_read:
418		418
419	cmp byte [edi+1+11], 0; directory read	419	cmp byte [edi+1+11], 0; directory read
420	je fs_give_dir1	420	je fs_give_dir1
421	call reserve_hd1	421	call reserve_hd1
422	fs_for_new_semantic:	422	fs_for_new_semantic:
423	call choice_necessity_partition	423	call choice_necessity_partition
424		424
425	fs_yesharddisk_all:	425	fs_yesharddisk_all:
426	mov eax, 1	426	mov eax, 1
427	mov ebx, [esp+24+24]	427	mov ebx, [esp+24+24]
428	cmp [hdpos], 0 ; is hd base set?	428	cmp [hdpos], 0 ; is hd base set?
429	jz hd_err_return	429	jz hd_err_return
430	cmp [fat32part], 0 ; is partition set?	430	cmp [fat32part], 0 ; is partition set?
431	jnz @f	431	jnz @f
432	hd_err_return:	432	hd_err_return:
433	call free_hd_channel	433	call free_hd_channel
434	and [hd1_status], 0	434	and [hd1_status], 0
435	jmp file_system_return	435	jmp file_system_return
436	@@:	436	@@:
437		437
438	call free_hd_channel	438	call free_hd_channel
439	and [hd1_status], 0	439	and [hd1_status], 0
440		440
441	fs_noharddisk:	441	fs_noharddisk:
442	; \begin{diamond}[18.03.2006]	442	; \begin{diamond}[18.03.2006]
443	mov eax, 5 ; file not found	443	mov eax, 5 ; file not found
444	; à ìîæåò áûòü, âîçâðàùàòü äðóãîé êîä îøèáêè?	444	; а может быть, возвращать другой код ошибки?
445	mov ebx, [esp+24+24]; do not change ebx in application	445	mov ebx, [esp+24+24]; do not change ebx in application
446	; \end{diamond}[18.03.2006]	446	; \end{diamond}[18.03.2006]
447		447
448	file_system_return:	448	file_system_return:
449		449
450	add esp, 24	450	add esp, 24
451		451
452	mov [esp+36], eax	452	mov [esp+36], eax
453	mov [esp+24], ebx	453	mov [esp+24], ebx
454	ret	454	ret
455		455
456		456
457	fs_give_dir1:	457	fs_give_dir1:
458		458
459	; \begin{diamond}[18.03.2006]	459	; \begin{diamond}[18.03.2006]
460	; /RD,/FD,/HD - only read is allowed	460	; /RD,/FD,/HD - only read is allowed
461	; other operations return "access denied", eax=10	461	; other operations return "access denied", eax=10
462	; (execute operation returns eax=-10)	462	; (execute operation returns eax=-10)
463	cmp dword [esp+20], 0	463	cmp dword [esp+20], 0
464	jz .read	464	jz .read
465	add esp, 20	465	add esp, 20
466	pop ecx	466	pop ecx
467	mov dword [esp+36], 10	467	mov dword [esp+36], 10
468	ret	468	ret
469	.read:	469	.read:
470	; \end{diamond}[18.03.2006]	470	; \end{diamond}[18.03.2006]
471	mov al, 0x10	471	mov al, 0x10
472	mov ebx, 1	472	mov ebx, 1
473	mov edi, [esp+8]	473	mov edi, [esp+8]
474	mov esi, dir1	474	mov esi, dir1
475	fs_d1_new:	475	fs_d1_new:
476	mov ecx, 11	476	mov ecx, 11
477	; cld	477	; cld
478	rep movsb	478	rep movsb
479	stosb	479	stosb
480	add edi, 32-11-1	480	add edi, 32-11-1
481	dec ebx	481	dec ebx
482	jne fs_d1_new	482	jne fs_d1_new
483		483
484	add esp, 24	484	add esp, 24
485		485
486	and dword [esp+36], 0; ok read	486	and dword [esp+36], 0; ok read
487	mov dword [esp+24], 32*1; dir/data size	487	mov dword [esp+24], 32*1; dir/data size
488	ret	488	ret
489		489
490		490
491		491
492	LBA_read_ramdisk:	492	LBA_read_ramdisk:
493		493
494	cmp [lba_read_enabled], 1	494	cmp [lba_read_enabled], 1
495	je lbarrl1	495	je lbarrl1
496		496
497	xor ebx, ebx	497	xor ebx, ebx
498	mov eax, 2	498	mov eax, 2
499	ret	499	ret
500		500

Subversion Repositories Kolibri OS

(root)/kernel/branches/Kolibri-acpi/fs/fs.inc – Rev 3500 → 3555