WebSVN – Kolibri OS – Diff – /kernel/branches/kolibri_pe/fs/fs.inc


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

Subversion Repositories Kolibri OS

(root)/kernel/branches/kolibri_pe/fs/fs.inc – Rev 846 → 2971