Fix: prevent panic when swap file creation fails (#7957)

* Fix: prevent panic when swap file creation fails

* weed mount: fix race condition in swap file initialization

Ensure thread-safe access to sf.file and other state in NewSwapFileChunk
and FreeResource by using sf.chunkTrackingLock consistently. Also
set sf.file to nil after closing to prevent reuse.

* weed mount: improve swap directory creation logic

- Check error for os.MkdirAll and log it if it fails.
- Use 0700 permissions for the swap directory for better security.
- Improve error logging context.

* weed mount: add unit tests for swap file creation

Add tests to verify:
- Concurrent initialization of the swap file.
- Correct directory permissions (0700).
- Automatic directory recreation if deleted.

* weed mount: fix thread-safety in swap file unit tests

Use atomic.Uint32 to track failures within goroutines in
TestSwapFile_NewSwapFileChunk_Concurrent to avoid unsafe calls to
t.Errorf from multiple goroutines.

* weed mount: simplify swap file creation logic

Refactor the directory check and retry logic for better readability and
to avoid re-using the main error variable for directory creation errors.
Remove redundant error logging.

* weed mount: improve error checking in swap file tests

Explicitly check if NewSwapFileChunk returns nil to provide more
informative failures.

* weed mount: update DirtyPages interface to return error

Propagate errors from SaveDataAt when swap file creation fails. This
prevents potential panics in the write path.

* weed mount: handle AddPage errors in write paths

Update ChunkedDirtyPages and PageWriter to propagate errors and update
WFS.Write and WFS.CopyFileRange to return fuse.EIO on failure.

* weed mount: update swap directory creation error message

Change "recreate" to "create/recreate" to better reflect that this path
is also taken during the initial creation of the swap directory.

---------

Co-authored-by: lixiang58 <lixiang58@lenovo.com>
Co-authored-by: Chris Lu <chris.lu@gmail.com>

weed/mount/page_writer/page_chunk_swapfile_test.go

@@ -0,0 +1,105 @@
+package page_writer
+
+import (
+	"os"
+	"path/filepath"
+	"sync"
+	"sync/atomic"
+	"testing"
+)
+
+func TestSwapFile_NewSwapFileChunk_Concurrent(t *testing.T) {
+	tempDir, err := os.MkdirTemp("", "seaweedfs_swap_test")
+	if err != nil {
+		t.Fatalf("failed to create temp dir: %v", err)
+	}
+	defer os.RemoveAll(tempDir)
+
+	sf := NewSwapFile(filepath.Join(tempDir, "swap"), 1024)
+	defer sf.FreeResource()
+
+	var wg sync.WaitGroup
+	var failures atomic.Uint32
+	numConcurrent := 10
+	for i := 0; i < numConcurrent; i++ {
+		wg.Add(1)
+		go func(idx int) {
+			defer wg.Done()
+			chunk := sf.NewSwapFileChunk(LogicChunkIndex(idx))
+			if chunk == nil {
+				failures.Add(1)
+			}
+		}(i)
+	}
+	wg.Wait()
+
+	if failures.Load() > 0 {
+		t.Errorf("failed to create %d chunks", failures.Load())
+	}
+
+	if sf.file == nil {
+		t.Error("sf.file should not be nil")
+	}
+}
+
+func TestSwapFile_MkdirAll_Permissions(t *testing.T) {
+	tempDir, err := os.MkdirTemp("", "seaweedfs_swap_perm_test")
+	if err != nil {
+		t.Fatalf("failed to create temp dir: %v", err)
+	}
+	defer os.RemoveAll(tempDir)
+
+	swapDir := filepath.Join(tempDir, "swap_subdir")
+	sf := NewSwapFile(swapDir, 1024)
+	defer sf.FreeResource()
+
+	// This should trigger os.MkdirAll
+	if sf.NewSwapFileChunk(0) == nil {
+		t.Fatal("NewSwapFileChunk failed to create a chunk")
+	}
+
+	info, err := os.Stat(swapDir)
+	if err != nil {
+		t.Fatalf("failed to stat swap dir: %v", err)
+	}
+
+	if !info.IsDir() {
+		t.Errorf("expected %s to be a directory", swapDir)
+	}
+
+	// Check permissions - should be 0700
+	if info.Mode().Perm() != 0700 {
+		t.Errorf("expected permissions 0700, got %o", info.Mode().Perm())
+	}
+}
+
+func TestSwapFile_RecreateDir(t *testing.T) {
+	tempDir, err := os.MkdirTemp("", "seaweedfs_swap_recreate_test")
+	if err != nil {
+		t.Fatalf("failed to create temp dir: %v", err)
+	}
+	defer os.RemoveAll(tempDir)
+
+	swapDir := filepath.Join(tempDir, "swap_recreate")
+	sf := NewSwapFile(swapDir, 1024)
+
+	// Create first chunk
+	if sf.NewSwapFileChunk(0) == nil {
+		t.Fatal("NewSwapFileChunk failed to create the first chunk")
+	}
+	sf.FreeResource()
+
+	// Delete the directory
+	os.RemoveAll(swapDir)
+
+	// Create second chunk - should recreate directory
+	chunk := sf.NewSwapFileChunk(1)
+	if chunk == nil {
+		t.Error("failed to create chunk after directory deletion")
+	}
+
+	if _, err := os.Stat(swapDir); os.IsNotExist(err) {
+		t.Error("swap directory was not recreated")
+	}
+	sf.FreeResource()
+}