fix: FAT32 >1024 byte read/write truncation, VFS write notifications & dir watch

- FAT32 writeFile: replace hardcoded spc=4 with bootRecord^.spc for
  cluster allocation and per-sector write loop
- FAT32 writeFile: update directory entry byteSize on disk after write
- FAT32 readFile: use dir^.byteSize instead of cluster-based estimate,
  fix off-by-one in read loop, remove spurious +sectorSize allocation
- VFS: fire VFS_OnMutation on sync/async writes (cache invalidate + watch)
- VFS: invalidate all cache entries for volume on mutation (relPath mismatch)
- VFS: add vfsParentDir helper, store VFSDir in file descriptors
- FDTable: add VFSDir field, free on close
- File browser: enable directory watch & poll timer, two-step new file
  creation (open + write), remove io.syslog import
- Linker: add --no-warn-execstack to suppress ld exit code 1 on warning
- Add core.strings.helpers unit (getFileExtension, fmtFileSize, sort)

src/app/app.filebrowser.pas

@@ -30,7 +30,6 @@ uses
     core.strings,
     core.strings.helpers,
     core.gfx.fileicons,
-    io.syslog,
     debug.tracer,
     core.util,
     arch.x86.util;
@@ -228,7 +227,8 @@ procedure fb_rename_cb(e: Plv_event); cdecl; forward;
 procedure fb_rename_ok_cb(e: Plv_event); cdecl; forward;
 procedure fb_newfile_cb(e: Plv_event); cdecl; forward;
 procedure fb_newfile_ok_cb(e: Plv_event); cdecl; forward;
-procedure fb_newfile_done(error: TError; userdata: pointer); forward;
+procedure fb_newfile_opened(error: TError; userdata: pointer); forward;
+procedure fb_newfile_written(error: TError; userdata: pointer); forward;
 procedure fb_newfile_done_timer(tmr: Plv_timer); cdecl; forward;
 { Phase 7 — context menu }
 procedure fb_row_long_press_cb(e: Plv_event); cdecl; forward;
@@ -557,10 +557,10 @@ end;
 procedure navigate_to(state: PFileBrowserState; newDir: pchar);
 begin
     { Unwatch old directory }
-    {if state^.watch_id <> 0 then begin
+    if state^.watch_id <> 0 then begin
         driver.storage.vfs.UnwatchDirectory(state^.watch_id);
         state^.watch_id := 0;
-    end;}
+    end;
     push_history(state, newDir);
     if state^.cur_path <> nil then kfree(void(state^.cur_path));
     state^.cur_path := stringCopy(newDir);
@@ -568,8 +568,8 @@ begin
     build_breadcrumbs(state);
     if state^.tab_bar <> nil then rebuild_tab_bar(state);
     { Watch new directory }
-    {state^.watch_dirty := false;
+    state^.watch_dirty := false;
-    state^.watch_id := driver.storage.vfs.WatchDirectory(newDir, @fb_watch_cb, state);}
+    state^.watch_id := driver.storage.vfs.WatchDirectory(newDir, @fb_watch_cb, state);
     schedule_refresh(state);
 end;
 
@@ -1843,20 +1843,38 @@ begin
     nfctx^.err    := eNone;
     nfctx^.handle := 0;
     driver.storage.vfs.OpenFileAsync(fp, omCreate, nfctx^.handle,
-                                     @nfctx^.err, @fb_newfile_done, nfctx);
+                                     @nfctx^.err, @fb_newfile_opened, nfctx);
     kfree(void(fp));
 end;
 
-{ Async completion for file creation }
+{ Async step 1: file descriptor opened — now write 0 bytes to create dir entry }
-procedure fb_newfile_done(error: TError; userdata: pointer);
+procedure fb_newfile_opened(error: TError; userdata: pointer);
 var
     nfctx : PNewFileCtx;
 begin
     nfctx := PNewFileCtx(userdata);
     if nfctx = nil then exit;
     nfctx^.err := error;
-    { Close the handle if it was opened successfully }
+    if (error = eNone) and (nfctx^.handle <> 0) then begin
-    if (error = eNone) and (nfctx^.handle <> 0) then
+        { WriteFileAsync needs a non-nil buffer; Length=0 so it is never read }
+        driver.storage.vfs.WriteFileAsync(nfctx^.handle, 0,
+            puint8(@nfctx^.err), 0, @fb_newfile_written, nfctx);
+    end else begin
+        if nfctx^.handle <> 0 then
+            driver.storage.vfs.CloseFile(nfctx^.handle);
+        lv_timer_create(@fb_newfile_done_timer, 1, nfctx);
+    end;
+end;
+
+{ Async step 2: write complete — close handle and schedule UI refresh }
+procedure fb_newfile_written(error: TError; userdata: pointer);
+var
+    nfctx : PNewFileCtx;
+begin
+    nfctx := PNewFileCtx(userdata);
+    if nfctx = nil then exit;
+    if error <> eNone then nfctx^.err := error;
+    if nfctx^.handle <> 0 then
         driver.storage.vfs.CloseFile(nfctx^.handle);
     lv_timer_create(@fb_newfile_done_timer, 1, nfctx);
 end;
@@ -3205,7 +3223,7 @@ begin
     rebuild_tab_bar(state);
 
     { Create 500ms poll timer for directory watch notifications }
-    {state^.watch_timer := lv_timer_create(@fb_watch_poll_timer, 500, state);}
+    state^.watch_timer := lv_timer_create(@fb_watch_poll_timer, 500, state);
 
     { Default bookmarks }
     add_bookmark_entry(state, '/');

src/driver/storage/driver.storage.fdtable.pas

@@ -40,6 +40,7 @@ type
         Volume      : PStorage_Volume;
         Directory   : pchar;       { directory path within the volume }
         FileName    : pchar;       { filename within that directory }
+        VFSDir      : pchar;       { full VFS parent directory path, e.g. '/sys' }
         OpenMode    : uint8;       { TOpenMode ordinal — avoids VFS type dependency }
         DataBuffer  : puint32;     { pre-loaded data for small files, nil otherwise }
         DataSize    : uint32;      { size of pre-loaded data in bytes }
@@ -109,6 +110,10 @@ begin
         kfree(void(entry^.FileName));
         entry^.FileName := nil;
     end;
+    if entry^.VFSDir <> nil then begin
+        kfree(void(entry^.VFSDir));
+        entry^.VFSDir := nil;
+    end;
 
     entry^.InUse := false;
     entry^.Loaded := false;

src/driver/storage/driver.storage.vfs.pas

@@ -448,14 +448,42 @@ end;
   calling FireWatchEvent directly. }
 procedure VFS_OnMutation(event : TVFSWatchEvent; dirPath : pchar; itemPath : pchar; vol : PStorage_Volume; relPath : pchar);
 begin
-    { Invalidate cache for the volume + relative path }
+    { Invalidate ALL cache entries for the volume.  relPath is a file-level
-    DirCache_Invalidate(vol, relPath);
+      path (e.g. 'test.txt') whose format differs from the directory-level
+      keys stored in the cache (e.g. '/'), so targeted matching fails.
+      Passing nil evicts every entry for the volume — safe and correct. }
+    DirCache_Invalidate(vol, nil);
     { Fire watch callbacks }
     FireWatchEvent(event, dirPath, itemPath);
 end;
 
 { =========================================================================== }
 
+{ Return a heap-allocated copy of the parent directory portion of an
+  absolute VFS path.  '/sys/hello.txt' -> '/sys', '/hello.txt' -> '/'. }
+function vfsParentDir(path : pchar) : pchar;
+var
+    abs  : pchar;
+    len  : uint32;
+    last : uint32;
+    i    : uint32;
+begin
+    abs := MakeAbsolutePath(path);
+    len := stringSize(abs);
+    last := 0;
+    if len > 0 then
+        for i := 0 to len - 1 do
+            if abs[i] = '/' then last := i;
+    if last = 0 then begin
+        vfsParentDir := stringNew(1);
+        vfsParentDir[0] := '/';
+    end else begin
+        vfsParentDir := stringNew(last);
+        core.util.memcpy(uint32(abs), uint32(vfsParentDir), last);
+    end;
+    kfree(void(abs));
+end;
+
 function makeRelative(Path : pchar; From : pchar) : pchar;
 var
     Result : pchar;
@@ -822,6 +850,7 @@ begin
             newObj^.Parent := Parent;
             newObj^.Reference := nil;
             newObj^.FileSize := entry^.fileSize;
+
             case entry^.entryType of
                 directoryEntry: newObj^.ObjectType := otDIRECTORY;
                 fileEntry:      newObj^.ObjectType := otFILE;
@@ -1124,6 +1153,7 @@ begin
         fd^.Volume := nil;
         fd^.Directory := nil;
         fd^.FileName := stringCopy(vfsObj^.ObjectName);
+        fd^.VFSDir := nil; { devices have no parent directory }
         fd^.OpenMode := uint8(ord(OpenMode));
         fd^.DataBuffer := nil;
         fd^.DataSize := 0;
@@ -1159,6 +1189,7 @@ begin
     fd^.Volume := vol;
     fd^.Directory := dir;
     fd^.FileName := fname;
+    fd^.VFSDir := vfsParentDir(Filename);
     fd^.OpenMode := uint8(ord(OpenMode));
     fd^.DataBuffer := nil;
     fd^.DataSize := 0;
@@ -1287,9 +1318,12 @@ begin
         status := puint32(kalloc(4));
         status^ := 0;
         vol^.filesystem^.writeCallback(vol, fd^.Directory, @dirEntry, Length, padBuf, status);
-        if status^ = 0 then
+        if status^ = 0 then begin
-            WriteFile := Length
+            WriteFile := Length;
-        else
+            { Invalidate cache + fire watch notification so open file
+              browsers see the updated size / new entry. }
+            VFS_OnMutation(weModified, fd^.VFSDir, fd^.VFSDir, vol, fd^.Directory);
+        end else
             WriteFile := 0;
         kfree(puint32(status));
         kfree(padBuf);
@@ -1458,6 +1492,12 @@ begin
         exit;
     end;
 
+    { Invalidate directory cache before dispatching the write.  The file
+      browser (and any other caller) only re-reads directory listings after
+      the completion callback fires, by which time the disk write has
+      finished and the fresh read will return the updated listing. }
+    VFS_OnMutation(weModified, fd^.VFSDir, fd^.VFSDir, vol, fd^.Directory);
+
     { Prefer async hook; fall back to sync if not available }
     if vol^.filesystem^.writeAsyncCallback <> nil then begin
         dirEntry.fileName  := fd^.FileName;
@@ -1556,6 +1596,7 @@ begin
     fd^.Volume    := vol;
     fd^.Directory := dir;
     fd^.FileName  := fname;
+    fd^.VFSDir    := vfsParentDir(Filename);
     fd^.OpenMode  := uint8(ord(OpenMode));
     fd^.DataBuffer:= nil;
     fd^.DataSize  := 0;

src/driver/storage/fs/driver.storage.fs.fat32.pas

@@ -1362,7 +1362,6 @@ var
     directories : PLinkedListBase;
     clusters : PLinkedListBase;
     startCluster: uint32;
-    device : PStorage_Device;
     dir : PDirectory;
     exists : boolean = false;
     sectorCount : uint32;
@@ -1371,12 +1370,19 @@ var
     dataStart : uint32;
     iterations : uint32;
     bufferPointer : puint32;
-    dataPosition : uint32;
 
     i : uint32;
     status : puint32;
     namePart : pchar;
     extPart  : pchar;
+
+    { Variables for updating directory entry byteSize }
+    entryIndex     : uint32;
+    parentCluster  : uint32;
+    dirSectorBuf   : puint32;
+    dirSectorLoc   : uint32;
+    entriesPerSec  : uint32;
+    entryOffset    : uint32;
 begin
     push_trace('driver.storage.fs.fat32.writeFile.enter');
     io.syslog.logln('FAT32', 'writeFile: enter');
@@ -1392,7 +1398,6 @@ begin
     end;
 
     bootRecord:= readBootRecord(volume);
-    device:= volume^.device;
     push_trace('driver.storage.fs.fat32.writeFile.readDir');
     directories:= readDirectory(volume, directory, status);
 
@@ -1416,7 +1421,8 @@ begin
     for i:=0 to LL_size(directories) - 1 do begin
         dir:= PDirectory(LL_get(directories, i));
         if compareByteArray8(dir^.fileName, cleanString(namePart, status)) and matchExtension(dir^.fileExtension, extPart) then begin
-            exists:= true; 
+            exists:= true;
+            entryIndex:= i;
             break;
         end;
     end;
@@ -1467,6 +1473,7 @@ begin
         push_trace('driver.storage.fs.fat32.writeFile.newFile');
         io.syslog.logln('FAT32', 'writeFile: creating new file');
 
+        entryIndex:= LL_size(directories); { New entry appended at end }
         startCluster:= writeDirectory(volume, directory, entry^.fileName, 0, status);
 
         { If writeDirectory failed (disk full, dir full, invalid name, etc.), propagate error }
@@ -1479,7 +1486,7 @@ begin
             exit;
         end;
 
-        clusterDifference:= (byteCount div bootRecord^.sectorsize) div 4;
+        clusterDifference:= (byteCount div bootRecord^.sectorsize) div bootRecord^.spc;
             push_trace('driver.storage.fs.fat32.writeFile.newFile.setupFat');
 
         for i:= startcluster to startCluster + clusterDifference - 1 do begin
@@ -1493,18 +1500,33 @@ begin
     push_trace('driver.storage.fs.fat32.writeFile.writeSectors');
     io.syslog.logln('FAT32', 'writeFile: writing sectors');
 
-    iterations:= (bytecount div bootRecord^.sectorSize) div bootRecord^.spc; //no of clusters
+    { Calculate total sectors needed and write each sector individually.
+      Assumes contiguous clusters starting at startCluster. }
+    iterations:= (bytecount + bootRecord^.sectorSize - 1) div bootRecord^.sectorSize;
+    if iterations > 0 then begin
+        for i:=0 to iterations - 1 do begin
+            bufferPointer:= puint32(uint32(buffer) + uint32(i * bootRecord^.sectorSize));
+            driver.storage.mgr.storage_write(volume^.device, dataStart + (startCluster * bootRecord^.spc) + i, 1, bufferPointer);
+        end;
+    end;
 
-    for i:=0 to iterations do begin
+    { Write succeeded — now update the directory entry's byteSize on disk }
-        dataPosition:= i * uint32(bootRecord^.sectorsize * 4); //needs to be bytes / 4
+    push_trace('driver.storage.fs.fat32.writeFile.updateByteSize');
-        bufferPointer:= @buffer[dataPosition div 4]; //todo change to puint8
+    if LL_size(directories) > 0 then begin
-        driver.storage.mgr.storage_write(volume^.device, dataStart + (startCluster * bootRecord^.spc) + (i * 4), 1, bufferPointer); //i * 4 needs to be changed, TODO fix fucking driver.storage.ctl.ide driver, it suks
+        parentCluster:= uint32(PDirectory(LL_get(directories, 0))^.clusterLow)
-        driver.storage.mgr.storage_write(volume^.device, dataStart + (startCluster * bootRecord^.spc) + (i * 4) + 1, 1, @bufferPointer[512 div 4]); 
+                     or uint32(PDirectory(LL_get(directories, 0))^.clusterHigh shl 16);
-        driver.storage.mgr.storage_write(volume^.device, dataStart + (startCluster * bootRecord^.spc) + (i * 4) + 2, 1, @bufferPointer[1024 div 4]); 
+        entriesPerSec:= bootRecord^.sectorSize div uint32(sizeof(TDirectory));
-        driver.storage.mgr.storage_write(volume^.device, dataStart + (startCluster * bootRecord^.spc) + (i * 4) + 3, 1, @bufferPointer[1536 div 4]); 
+        dirSectorLoc:= (entryIndex * uint32(sizeof(TDirectory))) div bootRecord^.sectorSize;
+        dirSectorLoc:= dirSectorLoc + (parentCluster * bootRecord^.spc);
+        entryOffset:= entryIndex mod entriesPerSec;
+
+        dirSectorBuf:= puint32(kalloc(bootRecord^.sectorSize));
+        driver.storage.mgr.storage_read(volume^.device, dataStart + dirSectorLoc, 1, dirSectorBuf);
+        PDirectory(dirSectorBuf)[entryOffset].byteSize:= byteCount;
+        driver.storage.mgr.storage_write(volume^.device, dataStart + dirSectorLoc, 1, dirSectorBuf);
+        kfree(dirSectorBuf);
     end;
 
-    { Write succeeded }
     io.syslog.logln('FAT32', 'writeFile: done');
     if statusOut <> nil then statusOut^:= ord(eNone);
 
@@ -1579,28 +1601,33 @@ begin
         clusters := getFatChain(volume, cluster, bootRecord);
         noClusters := LL_size(clusters);
 
-        data := puint32(kalloc(noClusters * bootRecord^.spc * bootRecord^.sectorSize + bootRecord^.sectorSize));
+        data := puint32(kalloc(noClusters * bootRecord^.spc * bootRecord^.sectorSize));
         if data = puint32(0) then begin
             push_trace('UNABLE TO ALLOCATE MEMORY');
             io.syslog.logln('FAT32', 'readFile: OOM allocating data buffer');
         end;
-        memset(uint32(data), 0, noClusters * bootRecord^.spc * bootRecord^.sectorSize + bootRecord^.sectorSize);
+        memset(uint32(data), 0, noClusters * bootRecord^.spc * bootRecord^.sectorSize);
 
-        readbuffer := puint32(kalloc(bootRecord^.sectorSize * 2));
+        readbuffer := puint32(kalloc(bootRecord^.sectorSize));
         if readbuffer = puint32(0) then begin
             push_trace('UNABLE TO ALLOCATE MEMORY');
             io.syslog.logln('FAT32', 'readFile: OOM allocating read buffer');
         end;
-        memset(uint32(readbuffer), 0, bootRecord^.sectorSize * 2);
 
-        for i:=0 to noClusters * bootRecord^.spc do begin
+        if noClusters * bootRecord^.spc > 0 then begin
-            driver.storage.mgr.storage_read(volume^.device, dataStart + ((cluster * bootRecord^.spc)+ i), 1, readbuffer);
+            for i:=0 to (noClusters * bootRecord^.spc) - 1 do begin
-            memcpy(uint32(readbuffer), uint32(@data[i*bootRecord^.sectorSize div 4]), bootRecord^.sectorSize);
+                driver.storage.mgr.storage_read(volume^.device, dataStart + ((cluster * bootRecord^.spc) + i), 1, readbuffer);
+                memcpy(uint32(readbuffer), uint32(@data[i * bootRecord^.sectorSize div 4]), bootRecord^.sectorSize);
+            end;
         end;
 
         kfree(readbuffer);
         buffer^ := uint32(data);
-        bytecount^ := noClusters * bootRecord^.spc * bootRecord^.sectorSize + bootRecord^.sectorSize;//maybe need to spc
+        { Report actual file size from directory entry, not cluster-based estimate }
+        if dir^.byteSize > 0 then
+            bytecount^ := dir^.byteSize
+        else
+            bytecount^ := noClusters * bootRecord^.spc * bootRecord^.sectorSize;
         readFile:= statusOut^;
         io.syslog.logln('FAT32', 'readFile: done');
         LL_Free(dirs);

toolchain/compile_link.sh

@@ -19,4 +19,4 @@ echo " "
 LIBGCC=$(gcc -m32 -print-libgcc-file-name)
 echo "libgcc: ${LIBGCC}"
 
-ld -m elf_i386 -s --gc-sections -Ttoolchain/linker.script -o bin/kernel.bin $objstring --start-group lib/liblvgl.a ${LIBGCC} --end-group
+ld -m elf_i386 -s --gc-sections --no-warn-execstack -Ttoolchain/linker.script -o bin/kernel.bin $objstring --start-group lib/liblvgl.a ${LIBGCC} --end-group