Fix append-ness of new fd affecting old fd

This commit fixes a case where opening a new file descriptor with the
append flag makes previously opened non-append fds append as well.

The fix is relatively simple, since the append-ness of an fd is already
tracked in the virtual fs implementation, there's no need to open the
actual file with the append flag.

This behavior is consistent across Linux and other Wasm runtimes.

fixes #5161

Signed-off-by: Yage Hu <[email protected]>

Author: yagehu

lib/wasix/src/syscalls/wasi/fd_write.rs

@@ -163,10 +163,12 @@ pub(crate) fn fd_write_internal<M: MemorySize>(
                                 if !is_stdio {
                                     if fd_entry.flags.contains(Fdflags::APPEND) {
                                         // `fdflags::append` means we need to seek to the end before writing.
-                                        offset = handle.size();
+                                        offset = fd_entry.inode.stat.read().unwrap().st_size;
                                         fd_entry.offset.store(offset, Ordering::Release);
                                     }
 
+                                    println!("whoa {offset}");
+
                                     handle
                                         .seek(std::io::SeekFrom::Start(offset))
                                         .await
@@ -206,6 +208,8 @@ pub(crate) fn fd_write_internal<M: MemorySize>(
                                     }
                                 }
 
+                                println!("written {written} {}", handle.size());
+
                                 if is_stdio {
                                     handle.flush().await.map_err(map_io_err)?;
                                 }

lib/wasix/src/syscalls/wasi/path_open.rs

@@ -237,7 +237,7 @@ pub(crate) fn path_open_internal(
                 let open_options = open_options
                     .write(minimum_rights.write)
                     .create(minimum_rights.create)
-                    .append(minimum_rights.append)
+                    .append(false)
                     .truncate(minimum_rights.truncate);
 
                 if minimum_rights.read {

tests/wasi-fyi/fs_open_append_offset.rs

@@ -0,0 +1,31 @@
+use std::{
+    fs,
+    io::{Seek, SeekFrom, Write},
+};
+
+fn main() {
+    let file = "fyi/fs_open_append_offset.dir/file";
+    let mut f0 = fs::OpenOptions::new()
+        .create(true)
+        .truncate(true)
+        .write(true)
+        .open(file)
+        .unwrap();
+
+    f0.write_all(b"abc").unwrap();
+    f0.seek(SeekFrom::Start(1)).unwrap();
+
+    assert_eq!(fs::read_to_string(file).unwrap(), "abc");
+
+    // This open with append should not affect the offset of f0.
+    let _f1 = fs::OpenOptions::new()
+        .create(true)
+        .write(true)
+        .append(true)
+        .open(file)
+        .unwrap();
+
+    f0.write_all(b"d").unwrap();
+
+    assert_eq!(fs::read_to_string(file).unwrap(), "adc");
+}

tests/wasi-fyi/test_fs/fyi/fs_open_append_offset.dir/.gitignore

@@ -0,0 +1 @@
+file