Truncate and expand files when zero size is provided to int 21h/AH=40

diff --git a/build/chimaera.img b/build/chimaera.img
index 23b8a081527111d936fcaba4d1c49da9627ee450..c557ec32ece0d8483a2638fcac5af373429a7b09 100644 (file)
Binary files a/build/chimaera.img and b/build/chimaera.img differ

diff --git a/build/chimaera.vhd b/build/chimaera.vhd
index e6582f5ba99b244ea4d253666e25b7b2a31ed547..4f0093bfadd441215f898dbee5b4b661fd9829b3 100644 (file)
Binary files a/build/chimaera.vhd and b/build/chimaera.vhd differ

diff --git a/src/apps/hello/hello.asm b/src/apps/hello/hello.asm
index 4aac207ce1d62cb5654e288002d994c1efa5f043..1e8ab640908cda37d64e829badcd94151e989c7f 100644 (file)
--- a/src/apps/hello/hello.asm
+++ b/src/apps/hello/hello.asm
@@ -8,7 +8,7 @@
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; Include stdio.inc.
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-%include    <stdio.inc>
+;%include    <stdio.inc>
 
 ;******************************************************************************
 ; @function         _main
@@ -19,12 +19,66 @@ _main:
     mov     bx,     offset _msg_hello
     call    _writestr
     
+    mov     ah,     HEX (39)
+    mov     dx,     offset _new_dir
+    int     HEX (21)
+    jc      .exit
+    
+    mov     ah,     HEX (3A)
+    mov     dx,     offset _new_dir
+    int     HEX (21)
+    jc      .exit
+    
+    mov     bx,     offset _msg_status
+    call    _writestr
+    
     mov     ah,     HEX (3C)
     mov     cx,     HEX (20)
     mov     dx,     offset _new_file
     int     HEX (21)
     jc      .exit
     
+    call    _writehex
+    call    _crlf
+    
+    mov     bx,     ax
+    
+    mov     ax,     HEX (4202)
+    mov     cx,     1024
+    xor     dx,     dx
+    int     HEX (21)
+    jc      .exit
+    
+    call    _writehex
+    call    _crlf
+    
+    mov     ah,     HEX (40)
+    xor     cx,     cx
+    xor     dx,     dx
+    int     HEX (21)
+    jc      .exit
+    
+    mov     ax,     HEX (4200)
+    mov     cx,     16
+    xor     dx,     dx
+    int     HEX (21)
+    jc      .exit
+    
+    call    _writehex
+    call    _crlf
+    
+    mov     ah,     HEX (40)
+    xor     cx,     cx
+    xor     dx,     dx
+    int     HEX (21)
+    jc      .exit
+    
+;    mov     ah,     HEX (3C)
+;    mov     cx,     HEX (20)
+;    mov     dx,     offset _new_file
+;    int     HEX (21)
+;    jc      .exit
+;    
 ;    mov     ah,     HEX (3C)
 ;    mov     cx,     HEX (20)
 ;    mov     dx,     offset _existing_file
@@ -140,5 +194,7 @@ _main:
 ;; Data area.
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 _msg_hello:                     db      "Hello, world!",        HEX (0D),   HEX (0A),   HEX (00)
+_msg_status:                    db      "File tests",           HEX (0D),   HEX (0A),   HEX (00)
+_new_dir:                       db      "temp",                                         HEX (00)
 _new_file:                      db      "temp.txt",                                     HEX (00)
 ;_existing_file:                 db      "\\boot\\freeldr\\freeldr.cfg",                 HEX (00)

diff --git a/src/kernel/fat.asm b/src/kernel/fat.asm
index 4703318766883bd5b4ca79e40418423b0af90e16..61a2643375b7d9bd2385bf41e99a2b803a0932d3 100644 (file)
--- a/src/kernel/fat.asm
+++ b/src/kernel/fat.asm
@@ -167,7 +167,7 @@ _find_free12:
     push    bp
     
     mov     bp,     sp
-    sub     sp,     2
+    sub     sp,     6
     
     push    bx
     push    cx
@@ -175,6 +175,12 @@ _find_free12:
     push    di
     push    es
     
+    mov     ax,     cs:[_fat_sector]
+    mov     word ptr [bp - 6],      ax
+    
+    mov     ax,     cs:[_fat_sector + 2]
+    mov     word ptr [bp - 4],      ax
+    
     mov     ax,     cs:[_fat_seg]
     mov     es,     ax
     
@@ -287,13 +293,19 @@ _find_free12.next:
 
 _find_free12.error:
 
+    mov     bx,     word ptr [bp - 6]
+    mov     cs:[_fat_sector],       bx
+    
+    mov     bx,     word ptr [bp - 4]
+    mov     cs:[_fat_sector + 2],   bx
+    
     pop     es
     pop     di
     pop     si
     pop     cx
     pop     bx
     
-    add     sp,     2
+    add     sp,     6
     pop     bp
     
     stc
@@ -301,13 +313,19 @@ _find_free12.error:
 
 _find_free12.done:
 
+    mov     bx,     word ptr [bp - 6]
+    mov     cs:[_fat_sector],       bx
+    
+    mov     bx,     word ptr [bp - 4]
+    mov     cs:[_fat_sector + 2],   bx
+    
     pop     es
     pop     di
     pop     si
     pop     cx
     pop     bx
     
-    add     sp,     2
+    add     sp,     6
     pop     bp
     
     clc
@@ -322,7 +340,7 @@ _find_free16:
     push    bp
     
     mov     bp,     sp
-    sub     sp,     2
+    sub     sp,     6
     
     push    bx
     push    cx
@@ -330,6 +348,12 @@ _find_free16:
     push    di
     push    es
     
+    mov     ax,     cs:[_fat_sector]
+    mov     word ptr [bp - 6],      ax
+    
+    mov     ax,     cs:[_fat_sector + 2]
+    mov     word ptr [bp - 4],      ax
+    
     mov     ax,     cs:[_fat_seg]
     mov     es,     ax
     
@@ -435,13 +459,19 @@ _find_free16.next:
 
 _find_free16.error:
 
+    mov     bx,     word ptr [bp - 6]
+    mov     cs:[_fat_sector],       bx
+    
+    mov     bx,     word ptr [bp - 4]
+    mov     cs:[_fat_sector + 2],   bx
+    
     pop     es
     pop     di
     pop     si
     pop     cx
     pop     bx
     
-    add     sp,     2
+    add     sp,     6
     pop     bp
     
     stc
@@ -449,13 +479,19 @@ _find_free16.error:
 
 _find_free16.done:
 
+    mov     bx,     word ptr [bp - 6]
+    mov     cs:[_fat_sector],       bx
+    
+    mov     bx,     word ptr [bp - 4]
+    mov     cs:[_fat_sector + 2],   bx
+    
     pop     es
     pop     di
     pop     si
     pop     cx
     pop     bx
     
-    add     sp,     2
+    add     sp,     6
     pop     bp
     
     clc
@@ -470,7 +506,7 @@ _find_free32:
     push    bp
     
     mov     bp,     sp
-    sub     sp,     2
+    sub     sp,     6
     
     push    bx
     push    cx
@@ -478,6 +514,12 @@ _find_free32:
     push    di
     push    es
     
+    mov     ax,     cs:[_fat_sector]
+    mov     word ptr [bp - 6],      ax
+    
+    mov     ax,     cs:[_fat_sector + 2]
+    mov     word ptr [bp - 4],      ax
+    
     mov     ax,     cs:[_fat_seg]
     mov     es,     ax
     
@@ -571,13 +613,19 @@ _find_free32.next:
 
 _find_free32.error:
 
+    mov     bx,     word ptr [bp - 6]
+    mov     cs:[_fat_sector],       bx
+    
+    mov     bx,     word ptr [bp - 4]
+    mov     cs:[_fat_sector + 2],   bx
+    
     pop     es
     pop     di
     pop     si
     pop     cx
     pop     bx
     
-    add     sp,     2
+    add     sp,     6
     pop     bp
     
     stc
@@ -585,13 +633,19 @@ _find_free32.error:
 
 _find_free32.done:
 
+    mov     bx,     word ptr [bp - 6]
+    mov     cs:[_fat_sector],       bx
+    
+    mov     bx,     word ptr [bp - 4]
+    mov     cs:[_fat_sector + 2],   bx
+    
     pop     es
     pop     di
     pop     si
     pop     cx
     pop     bx
     
-    add     sp,     2
+    add     sp,     6
     pop     bp
     
     clc
@@ -797,13 +851,13 @@ _nextcluster_fat12.even_cluster:
 
 _nextcluster_fat12.compare:
 
+    xor     dx,     dx
+    
     cmp     ax,     HEX (0FF8)
     cmc
 
 _nextcluster_fat12.done:
 
-    xor     dx,     dx
-    
     pop     si
     pop     cx
     ret
@@ -887,13 +941,13 @@ _nextcluster_fat16.first64:
 
 _nextcluster_fat16.compare:
 
+    xor     dx,     dx
+    
     cmp     ax,     HEX (FFF8)
     cmc
 
 _nextcluster_fat16.done:
 
-    xor     dx,     dx
-    
     pop     si
     pop     cx
     ret

diff --git a/src/kernel/file.asm b/src/kernel/file.asm
index 0c73b04856c77a99881e7f5966277ec328252608..2b67d1fee2ebdd12c9b1350678a7b46fd278b6c6 100644 (file)
--- a/src/kernel/file.asm
+++ b/src/kernel/file.asm
@@ -5,6 +5,11 @@
 % define        HEX(y)                  0x##y
 %endif
 
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Include our fat.inc.
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+%include    "fat.inc"
+
 ;******************************************************************************
 ; @function         _read_cluster
 ;******************************************************************************
@@ -1135,7 +1140,7 @@ _seek_file.ptr_ok:
 
 _seek_file.done:
 
-    mov     word ptr es:[si + 52],      1
+    mov     word ptr es:[si + 54],      1
     
     mov     ax,     es:[si + 62]
     mov     dx,     es:[si + 64]
@@ -1148,6 +1153,622 @@ _seek_file.done:
     
     ret
 
+;******************************************************************************
+; @function         _write_file
+;******************************************************************************
+global      _write_file
+_write_file:
+
+    push    bp
+    
+    mov     bp,     sp
+    sub     sp,     12
+    
+    push    bx
+    push    cx
+    push    dx
+    push    si
+    push    di
+    push    es
+    push    ds
+    
+    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+    ;; Make sure our total bytes read is zero.
+    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+    mov     word ptr [bp - 2],      0
+    
+    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+    ;; Make sure we're not write-only.
+    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+    cmp     word ptr es:[si + 56],  0
+    je      _write_file.error
+    
+    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+    ;; If theres zero byte to write then truncate/extend.
+    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+    and     cx,     cx
+    jz      _write_file.zero
+    
+    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+    ;; For now we'll jump to error
+    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+    jmp     _write_file.error
+
+_write_file.zero:
+
+    mov     ax,     es:[si + 66]
+    mov     dx,     es:[si + 68]
+    
+    cmp     dx,     es:[si + 64]
+    ja      _write_file.truncate
+    
+    cmp     dx,     es:[si + 64]
+    jne     _write_file.extend
+    
+    cmp     ax,     es:[si + 62]
+    jb      _write_file.extend
+
+_write_file.truncate:
+
+    mov     bx,     es:[si + 58]
+    or      bx,     es:[si + 60]
+    
+    and     bx,     bx
+    jz      _write_file.done
+    
+    mov     cx,     es:[si + 50]
+    div     cx
+    
+    mov     bx,     ax
+    
+    mov     ax,     es:[si + 62]
+    mov     dx,     es:[si + 64]
+    
+    mov     cx,     es:[si + 50]
+    div     cx
+    
+    mov     cx,     ax
+    xchg    bx,     cx
+    
+    mov     ax,     es:[si + 58]
+    mov     dx,     es:[si + 60]
+
+_write_file.truncate_walk:
+
+    mov     word ptr [bp - 6],      ax
+    mov     word ptr [bp - 4],      dx
+    
+    and     bx,     bx
+    jz      _write_file.truncate_ok
+    
+    call    cs:[_next_cluster]
+    jc      _write_file.truncate_ok
+    
+    dec     cx
+    
+    dec     bx
+    jnz     _write_file.truncate_walk
+
+_write_file.truncate_ok:
+
+    mov     ax,     word ptr [bp - 6]
+    mov     dx,     word ptr [bp - 4]
+    
+    mov     word ptr [bp - 12],     cx
+
+_write_file.truncate_loop:
+
+    and     cx,     cx
+    jz      _write_file.truncate_done
+    
+    call    cs:[_next_cluster]
+    jc      _write_file.truncate_done
+    
+    push    si
+    push    di
+    
+    mov     si,     ax
+    mov     di,     dx
+    
+    mov     ax,     word ptr [bp - 6]
+    mov     dx,     word ptr [bp - 4]
+    
+    mov     word ptr [bp - 6],      si
+    mov     word ptr [bp - 4],      di
+    
+    pop     di
+    pop     si
+    
+    push    bx
+    push    cx
+    
+    xor     bx,     bx
+    xor     cx,     cx
+    
+    call    cs:[_update_cluster]
+    
+    pop     cx
+    pop     bx
+    
+    mov     ax,     word ptr [bp - 6]
+    mov     dx,     word ptr [bp - 4]
+    
+    dec     cx
+    jnz     _write_file.truncate_loop
+
+_write_file.truncate_done:
+
+    mov     ax,     word ptr [bp - 6]
+    mov     dx,     word ptr [bp - 4]
+    
+    push    bx
+    push    cx
+    
+    xor     bx,     bx
+    xor     cx,     cx
+    
+    call    cs:[_update_cluster]
+    
+    pop     cx
+    pop     bx
+    
+    xor     ax,     ax
+    xor     dx,     dx
+    
+    mov     bx,     es:[si + 62]
+    or      bx,     es:[si + 64]
+    
+    and     bx,     bx
+    jz      _write_file.truncate_update
+    
+    mov     ax,     es:[si + 58]
+    mov     dx,     es:[si + 60]
+    
+    push    bx
+    push    cx
+    
+    mov     bx,     HEX (FFFF)
+    mov     cx,     HEX (FFF8)
+    
+    call    cs:[_update_cluster]
+    
+    pop     cx
+    pop     bx
+    
+    dec     word ptr [bp - 12]
+
+_write_file.truncate_update:
+
+    mov     es:[si + 58],       ax
+    mov     es:[si + 60],       dx
+    
+    mov     ax,     es:[si + 58]
+    mov     word ptr [bp - 6],      ax
+    
+    mov     ax,     es:[si + 60]
+    mov     word ptr [bp - 4],      ax
+    
+    mov     ax,     es:[si + 62]
+    mov     dx,     es:[si + 64]
+    
+    mov     es:[si + 66],       ax
+    mov     word ptr [bp - 10],     ax
+    
+    mov     es:[si + 68],       dx
+    mov     word ptr [bp - 8],      dx
+    
+    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+    ;; Update the entry on disk.
+    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+    mov     ax,     es:[si + 74]
+    mov     dx,     es:[si + 76]
+    
+    mov     cx,     es:[si + 78]
+    mov     di,     es:[si + 80]
+    
+    push    es
+    push    bx
+    push    ax
+    push    dx
+    push    cx
+    
+    mov     bx,     cs:[_disk_scratch]
+    mov     es,     bx
+    
+    xor     bx,     bx
+    call    _read_sectors
+    
+    mov     ax,     word ptr [bp - 6]
+    mov     es:[di + 26],       ax
+    
+    mov     ax,     word ptr [bp - 4]
+    mov     es:[di + 20],       ax
+    
+    mov     ax,     word ptr [bp - 10]
+    mov     es:[di + 28],       ax
+    
+    mov     ax,     word ptr [bp - 8]
+    mov     es:[di + 30],       ax
+    
+    pop     cx
+    pop     dx
+    pop     ax
+    
+    xor     bx,     bx
+    call    _write_sectors
+    
+    pop     bx
+    pop     es
+    
+    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+    ;; Check if we have an info sector.
+    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+    mov     ax,     cs:[_info_sector]
+    
+    and     ax,     ax
+    jz      _write_file.done
+    
+    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+    ;; Update the free clusters.
+    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+    xor     dx,     dx
+    
+    add     ax,     cs:[_hidden_sectors]
+    adc     dx,     cs:[_hidden_sectors + 2]
+    
+    mov     bx,     cs:[_disk_scratch]
+    mov     es,     bx
+    xor     bx,     bx
+    
+    mov     cx,     1
+    call    _read_sectors
+    
+    mov     di,     HEX (01E0)
+    
+    mov     ax,     es:[di + 8]
+    mov     dx,     es:[di + 10]
+    
+    add     ax,     word ptr [bp - 12]
+    adc     dx,     0
+    
+    mov     es:[di + 8],    ax
+    mov     es:[di + 10],   dx
+    
+    mov     ax,     cs:[_info_sector]
+    xor     dx,     dx
+    
+    add     ax,     cs:[_hidden_sectors]
+    adc     dx,     cs:[_hidden_sectors + 2]
+    
+    mov     cx,     1
+    call    _write_sectors
+    
+    jmp     _write_file.done
+
+_write_file.extend:
+
+    push    es
+    push    di
+    push    ax
+    
+    xor     cx,     es:[si + 50]
+    
+    mov     ax,     cs:[_disk_scratch]
+    mov     es,     ax
+    xor     di,     di
+    
+    xor     al,     al
+    rep     stosb
+    
+    pop     ax
+    pop     di
+    pop     es
+    
+    mov     cx,     es:[si + 50]
+    div     cx
+    
+    mov     bx,     ax
+    
+    mov     ax,     es:[si + 62]
+    mov     dx,     es:[si + 64]
+    
+    mov     cx,     es:[si + 50]
+    div     cx
+    
+    mov     cx,     ax
+    
+    mov     ax,     es:[si + 58]
+    mov     dx,     es:[si + 60]
+    
+    mov     di,     ax
+    or      di,     dx
+    
+    and     di,     di
+    jnz     _write_file.extend_walk
+    
+    call    cs:[_find_free]
+    jc      _write_file.done
+    
+    mov     word ptr [bp - 6],      ax
+    mov     word ptr [bp - 4],      dx
+    
+    mov     es:[si + 58],       ax
+    mov     es:[si + 60],       dx
+    
+    push    bx
+    push    cx
+    call    cs:[_convert_cluster]
+    
+    pop     cx
+    pop     bx
+    jc      _write_file.done
+    
+    push    es
+    push    bx
+    push    cx
+    
+    xor     ch,     ch
+    mov     cl,     cs:[_sectors_per_cluster]
+    
+    mov     bx,     cs:[_disk_scratch]
+    mov     es,     bx
+    
+    xor     bx,     bx
+    call    _write_sectors
+    
+    pop     cx
+    pop     bx
+    pop     es
+    
+    jmp     _write_file.extend_no_walk
+
+_write_file.extend_walk:
+
+    mov     word ptr [bp - 6],      ax
+    mov     word ptr [bp - 4],      dx
+    
+    and     bx,     bx
+    jz      _write_file.extend_no_walk
+    
+    call    cs:[_next_cluster]
+    jc      _write_file.extend_no_walk
+    
+    dec     cx
+    
+    dec     bx
+    jnz     _write_file.extend_walk
+
+_write_file.extend_no_walk:
+
+    mov     ax,     word ptr [bp - 6]
+    mov     dx,     word ptr [bp - 4]
+    
+    mov     word ptr [bp - 12],     cx
+
+_write_file.extend_loop:
+
+    and     cx,     cx
+    jz      _write_file.extend_update
+    
+    call    cs:[_find_free]
+    jc      _write_file.done
+    
+    push    bx
+    push    cx
+    
+    mov     bx,     dx
+    mov     cx,     ax
+    
+    mov     ax,     word ptr [bp - 6]
+    mov     dx,     word ptr [bp - 4]
+    
+    call    cs:[_update_cluster]
+    
+    push    bx
+    push    cx
+    call    cs:[_convert_cluster]
+    
+    pop     cx
+    pop     bx
+    jc      _write_file.extend_update
+    
+    push    es
+    push    bx
+    push    cx
+    
+    xor     ch,     ch
+    mov     cl,     cs:[_sectors_per_cluster]
+    
+    mov     bx,     cs:[_disk_scratch]
+    mov     es,     bx
+    
+    xor     bx,     bx
+    call    _write_sectors
+    
+    pop     cx
+    pop     bx
+    pop     es
+    
+    mov     word ptr [bp - 6],      cx
+    mov     word ptr [bp - 4],      bx
+    
+    pop     cx
+    pop     bx
+    
+    dec     cx
+    jnz     _write_file.extend_loop
+
+_write_file.extend_update:
+
+    push    es
+    push    bx
+    push    cx
+    
+    mov     bx,     HEX (FFFF)
+    mov     cx,     HEX (FFF8)
+    
+    mov     ax,     word ptr [bp - 6]
+    mov     dx,     word ptr [bp - 4]
+    
+    call    cs:[_update_cluster]
+    
+    call    cs:[_convert_cluster]
+    jc      _write_file.done
+    
+    xor     ch,     ch
+    mov     cl,     cs:[_sectors_per_cluster]
+    
+    mov     bx,     cs:[_disk_scratch]
+    mov     es,     bx
+    
+    xor     bx,     bx
+    call    _write_sectors
+    
+    pop     cx
+    pop     bx
+    pop     es
+    
+    mov     ax,     es:[si + 58]
+    mov     word ptr [bp - 6],      ax
+    
+    mov     ax,     es:[si + 60]
+    mov     word ptr [bp - 4],      ax
+    
+    mov     ax,     es:[si + 62]
+    mov     dx,     es:[si + 64]
+    
+    mov     es:[si + 66],       ax
+    mov     word ptr [bp - 10],     ax
+    
+    mov     es:[si + 68],       dx
+    mov     word ptr [bp - 8],      dx
+    
+    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+    ;; Update the entry on disk.
+    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+    mov     ax,     es:[si + 74]
+    mov     dx,     es:[si + 76]
+    
+    mov     cx,     es:[si + 78]
+    mov     di,     es:[si + 80]
+    
+    push    es
+    push    bx
+    push    ax
+    push    dx
+    push    cx
+    
+    mov     bx,     cs:[_disk_scratch]
+    mov     es,     bx
+    
+    xor     bx,     bx
+    call    _read_sectors
+    
+    mov     ax,     word ptr [bp - 6]
+    mov     es:[di + 26],       ax
+    
+    mov     ax,     word ptr [bp - 4]
+    mov     es:[di + 20],       ax
+    
+    mov     ax,     word ptr [bp - 10]
+    mov     es:[di + 28],       ax
+    
+    mov     ax,     word ptr [bp - 8]
+    mov     es:[di + 30],       ax
+    
+    pop     cx
+    pop     dx
+    pop     ax
+    
+    xor     bx,     bx
+    call    _write_sectors
+    
+    pop     bx
+    pop     es
+    
+    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+    ;; Check if we have an info sector.
+    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+    mov     ax,     cs:[_info_sector]
+    
+    and     ax,     ax
+    jz      _write_file.done
+    
+    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+    ;; Update the free clusters.
+    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+    xor     dx,     dx
+    
+    add     ax,     cs:[_hidden_sectors]
+    adc     dx,     cs:[_hidden_sectors + 2]
+    
+    mov     bx,     cs:[_disk_scratch]
+    mov     es,     bx
+    xor     bx,     bx
+    
+    mov     cx,     1
+    call    _read_sectors
+    
+    mov     di,     HEX (01E0)
+    
+    mov     ax,     es:[di + 8]
+    mov     dx,     es:[di + 10]
+    
+    sub     ax,     word ptr [bp - 12]
+    sbb     dx,     0
+    
+    mov     es:[di + 8],    ax
+    mov     es:[di + 10],   dx
+    
+    mov     ax,     cs:[_info_sector]
+    xor     dx,     dx
+    
+    add     ax,     cs:[_hidden_sectors]
+    adc     dx,     cs:[_hidden_sectors + 2]
+    
+    mov     cx,     1
+    call    _write_sectors
+
+_write_file.done:
+
+    mov     word ptr es:[si + 54],      1
+    
+    pop     ds
+    pop     es
+    pop     di
+    pop     si
+    pop     dx
+    pop     cx
+    pop     bx
+    
+    add     sp,     12
+    clc
+    
+    mov     ax,     word ptr [bp - 2]
+    pop     bp
+    
+    ret
+
+_write_file.error:
+
+    mov     word ptr es:[si + 54],      1
+    
+    pop     ds
+    pop     es
+    pop     di
+    pop     si
+    pop     dx
+    pop     cx
+    pop     bx
+    
+    add     sp,     12
+    stc
+    
+    mov     ax,     5
+    pop     bp
+    
+    ret
+
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; Data area.
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

diff --git a/src/kernel/int21.asm b/src/kernel/int21.asm
index 8a0b2ae1be57987b5c490da064f09544d1ed568f..7e3899a0ae30b3ad66cfec06d1ff3b538b08faf7 100644 (file)
--- a/src/kernel/int21.asm
+++ b/src/kernel/int21.asm
@@ -331,10 +331,8 @@ _get_disk_info.fat32:
 
 _get_disk_info.done:
 
-    xor     ax,     ax
-    
-    mov     cs:[_fat_sector],   ax
-    mov     cs:[_fat_sector + 2],   ax
+    mov     word ptr cs:[_fat_sector],      0
+    mov     word ptr cs:[_fat_sector + 2],      0
     
     pop     ds
     pop     es
@@ -1907,7 +1905,7 @@ _int21_3A.clear:
     inc     cx
     
     mov     ax,     si
-    mov     dx,     si
+    mov     dx,     di
     
     jmp     _int21_3A.clear
 
@@ -1981,7 +1979,7 @@ _int21_3A.clear_final:
     mov     ax,     cs:[_info_sector]
     
     and     ax,     ax
-    jz      _int21_41.done
+    jz      _int21_3A.done
     
     ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
     ;; Update the free clusters.
@@ -2251,6 +2249,9 @@ _int21_3B.fat32:
 
 _int21_3B.get_path:
 
+    mov     word ptr cs:[_fat_sector],      0
+    mov     word ptr cs:[_fat_sector + 2],      0
+    
     mov     di,     si
     
     push    es
@@ -2599,6 +2600,8 @@ _int21_3C:
 
 _int21_3C.open:
 
+    mov     ax,     HEX (3D02)
+    
     call    _open_file
     jnc     _int21_3C.zero
 
@@ -2651,6 +2654,8 @@ _int21_3C.create:
     ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
     ;; Try and open the file again.
     ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+    mov     ax,     HEX (3D02)
+    
     call    _open_file
     jc      _int21_3C.error
     
@@ -3151,6 +3156,9 @@ _int21_3F.fat32:
 
 _int21_3F.read:
 
+    mov     word ptr cs:[_fat_sector],      0
+    mov     word ptr cs:[_fat_sector + 2],      0
+    
     pop     cx
     pop     ax
     pop     ds
@@ -3211,7 +3219,7 @@ _int21_40:
     ;; If stdin was passed then we can't write to it.
     ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
     and     bx,     bx
-    jz      _int21_40.error
+    jz      _int21_40.invalid
     
     ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
     ;; Otherwise, lets write the bytes.
@@ -3235,13 +3243,13 @@ _int21_40.check:
     ;; Check if we have any open files.
     ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
     cmp     word ptr cs:[_vec_files + 2],       0
-    je      _int21_40.error
+    je      _int21_40.invalid
     
     ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
     ;; Make sure we have a valid file handle.
     ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
     cmp     bx,     3
-    jb      _int21_40.error
+    jb      _int21_40.invalid
     
     ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
     ;; Get the correct file offset by subtracting 3.
@@ -3275,7 +3283,7 @@ _int21_40.check:
     ;; If the vector entry is zero then the file handle is invalid.
     ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
     cmp     word ptr es:[bx],       0
-    je      _int21_40.error
+    je      _int21_40.invalid
     
     ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
     ;; Re-initialize the extra segment but this time with the address
@@ -3290,8 +3298,8 @@ _int21_40.copy:
     push    ax
     push    cx
     
-    mov     ds,     ax
     xor     si,     si
+    mov     ds,     ax
     
     lodsw
     mov     cs:[_curr_cluster],     ax
@@ -3372,12 +3380,26 @@ _int21_40.fat32:
 
 _int21_40.write:
 
+    mov     word ptr cs:[_fat_sector],      0
+    mov     word ptr cs:[_fat_sector + 2],      0
+    
     pop     cx
     pop     ax
     pop     ds
     pop     si
     
     mov     es,     ax
+    xor     si,     si
+    
+    call    _write_file
+    jc      _int21_40.error
+    
+    jmp     _int21_40.done
+
+_int21_40.invalid:
+
+    mov     ax,     6
+    stc
 
 _int21_40.error:
 
@@ -3390,9 +3412,6 @@ _int21_40.error:
     pop     bx
     pop     bp
     
-    mov     ax,     6
-    stc
-    
     jmp     iretc
 
 _int21_40.done:
@@ -4580,6 +4599,9 @@ _int21_4F.fat32:
 
 _int21_4F.find:
 
+    mov     word ptr cs:[_fat_sector],      0
+    mov     word ptr cs:[_fat_sector + 2],      0
+    
     pop     bx
     pop     cx
     

diff --git a/src/kernel/kernel.asm b/src/kernel/kernel.asm
index dc23c0f2e799489bdd51e79fbc8e800d767ba637..331a05405319a71901ad52a0874b32c8553ecc96 100644 (file)
--- a/src/kernel/kernel.asm
+++ b/src/kernel/kernel.asm
@@ -619,6 +619,12 @@ _check_disks:
     mul     cx
     stosw
     
+    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+    ;; No info sector.
+    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+    xor     ax,     ax
+    stosw
+    
     ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
     ;; We don't want to set the selected drive so jump to getting the
     ;; hard disk paritions.