Alternative options

Author: bigbruno

include/swap-default.conf

@@ -7,40 +7,51 @@
 # Swap Mode - How swap is configured
 #
 # auto            - Auto-detect: btrfs → zswap+swapfc, non-btrfs → zram only
-# zswap+swapfc    - Force zswap with swap files (requires btrfs)
-# zram            - Force zram only
+# zswap+swapfc    - Zswap cache + swap files (default for btrfs)
+# zram+swapfc     - Zram (fast) + swap files for overflow
+# zram            - Zram only (no disk swap)
 # manual          - Use explicit settings below (legacy mode)
 ################################################################################
 
 swap_mode=auto
 
 ################################################################################
 # Zswap - Compressed RAM cache for swap pages
+# Used in zswap+swapfc mode or manual with zswap_enabled=1
 #
 # zswap compresses pages before writing to swap, reducing I/O.
-# Automatically enabled in zswap+swapfc mode. Use zswap_enabled=0 to disable.
 # Requires a backing swap device (swap file or partition).
 ################################################################################
 
-zswap_compressor=zstd       # lzo lz4 zstd lzo-rle lz4hc
-zswap_max_pool_percent=45   # Max % of RAM for compressed pool
-zswap_zpool=zsmalloc        # Memory allocator
+zswap_compressor=zstd            # lzo lz4 zstd lzo-rle lz4hc
+zswap_max_pool_percent=45        # Max % of RAM for compressed pool
+zswap_zpool=zsmalloc             # Memory allocator (zsmalloc better than zbud)
+zswap_shrinker_enabled=1         # Proactively move cold pages to swap
+zswap_accept_threshold=80        # Accept pages again after pool was full (%)
 
 ################################################################################
 # Zram - Compressed RAM disk
-# Only used when swap_mode=zram or manual with zram_enabled=1
+# Used in zram+swapfc, zram-only modes, or manual with zram_enabled=1
 #
 # zram creates a compressed block device in RAM for swap
-# More efficient than zswap for systems without backing swap
+# Faster than zswap - ideal for desktop systems
 ################################################################################
 
-zram_size=$RAM_SIZE         # Size (default: equal to RAM)
+# zram_size supports: 1G, 512M, 50%, 100% (full RAM)
+zram_size=50%                # Size of zram device
 zram_alg=zstd               # Compression: lzo lz4 zstd lzo-rle lz4hc
-zram_prio=32767             # Swap priority
+zram_prio=32767             # Swap priority (highest = used first)
+
+# Zram writeback: move idle/incompressible pages to disk
+# Requires CONFIG_ZRAM_WRITEBACK in kernel
+# When enabled with empty dev, auto-creates sparse file + loop device
+zram_writeback=0            # 0=disabled, 1=enabled
+zram_writeback_dev=         # Backing device (partition or empty for auto loop)
+zram_writeback_size=1G      # Size of auto-created backing file
 
 ################################################################################
 # SwapFC - Dynamic swap file management (btrfs only)
-# Only used when swap_mode=zswap+swapfc or manual with swapfc_enabled=1
+# Used in zram+swapfc, zswap+swapfc modes, or manual with swapfc_enabled=1
 #
 # Creates swap files on-demand as memory pressure increases
 ################################################################################
@@ -55,6 +66,11 @@ swapfc_priority=50               # Swap priority (decreases per file)
 swapfc_path=/swapfc/swapfile     # Path for swap files (must be btrfs)
 swapfc_frequency=1               # Check interval in seconds
 
+# Btrfs compression mode: uses loop device over sparse file on compressed btrfs
+# This enables swap data to be compressed on disk by btrfs (zstd)
+# RAM: zswap compresses → Disk: btrfs compresses again (double compression!)
+swapfc_use_btrfs_compression=0
+
 ################################################################################
 # Enable/disable settings
 # zswap_enabled: Set to 0 to disable zswap (default: 1, enabled when not using zram)

include/systemd-swap.service

@@ -12,13 +12,7 @@ RemainAfterExit=yes
 TimeoutStopSec=5
 OOMScoreAdjust=-500
 CapabilityBoundingSet=CAP_SYS_ADMIN
-DeviceAllow=block-blkext r
-DeviceAllow=block-device-mapper r
-DeviceAllow=block-loop
-DeviceAllow=block-sd r
-DeviceAllow=block-virtblk r
-DeviceAllow=block-zram
-IOSchedulingPriority=2
+DevicePolicy=auto
 NoNewPrivileges=yes
 PrivateNetwork=yes
 PrivateTmp=yes

src/main.rs

@@ -40,7 +40,8 @@ enum Commands {
 #[derive(Debug, Clone, Copy, PartialEq)]
 enum SwapMode {
     Auto,
-    ZswapSwapfc,  // zswap + swap files (for btrfs)
+    ZramSwapfc,   // zram + writeback to swap files (best for desktop!)
+    ZswapSwapfc,  // zswap + swap files (alternative)
     ZramOnly,     // zram only (for non-btrfs)
     Manual,       // Use explicit config values
 }
@@ -105,6 +106,7 @@ fn is_path_btrfs(path: &str) -> bool {
 /// Parse swap_mode from config
 fn get_swap_mode(config: &Config) -> SwapMode {
     match config.get("swap_mode").unwrap_or("auto").to_lowercase().as_str() {
+        "zram+swapfc" | "zram_swapfc" => SwapMode::ZramSwapfc,
         "zswap+swapfc" | "zswap" => SwapMode::ZswapSwapfc,
         "zram" | "zram_only" => SwapMode::ZramOnly,
         "manual" => SwapMode::Manual,
@@ -132,6 +134,7 @@ fn start() -> Result<(), Box<dyn std::error::Error>> {
         SwapMode::Auto => {
             let swapfc_path = config.get("swapfc_path").unwrap_or("/swapfc/swapfile");
             if is_path_btrfs(swapfc_path) || is_root_btrfs() {
+                // Desktop optimization: zswap + swapfc - tested to be faster
                 info!("Auto-detected btrfs: using zswap + swapfc");
                 SwapMode::ZswapSwapfc
             } else {
@@ -146,6 +149,36 @@ fn start() -> Result<(), Box<dyn std::error::Error>> {
     let mut zswap_backup: Option<ZswapBackup> = None;
 
     match effective_mode {
+        SwapMode::ZramSwapfc => {
+            // Desktop-optimized mode: zram for speed + swapfc for overflow
+            // zram is faster than zswap because it's a dedicated block device
+            
+            // Set up signal handler
+            signal_hook::flag::register(
+                signal_hook::consts::SIGTERM,
+                std::sync::Arc::new(std::sync::atomic::AtomicBool::new(false)),
+            )?;
+            ctrlc::set_handler(move || {
+                request_shutdown();
+            })?;
+
+            // Start zram first (primary high-priority swap)
+            info!("Setting up zram as primary swap...");
+            if let Err(e) = systemd_swap::zram::start(&config) {
+                error!("Zram: {}", e);
+            }
+
+            // Create swapfc for overflow/writeback (lower priority)
+            info!("Setting up swapfc as secondary swap for overflow...");
+            let mut swapfc = SwapFc::new(&config)?;
+            
+            // Create initial swap file
+            swapfc.create_initial_swap()?;
+
+            // Run swapfc monitoring loop
+            swapfc.run()?;
+        }
+
         SwapMode::ZswapSwapfc => {
             // For zswap: create swap file FIRST, then enable zswap
             // zswap needs a backing swap device to work

src/swapfc.rs

@@ -48,6 +48,7 @@ pub struct SwapFcConfig {
     pub priority: i32,
     pub force_use_loop: bool,
     pub directio: bool,
+    pub use_btrfs_compression: bool,
 }
 
 impl SwapFcConfig {
@@ -78,6 +79,7 @@ impl SwapFcConfig {
             priority: config.get_as("swapfc_priority").unwrap_or(50),
             force_use_loop: config.get_bool("swapfc_force_use_loop"),
             directio: config.get_bool("swapfc_directio"),
+            use_btrfs_compression: config.get_bool("swapfc_use_btrfs_compression"),
         })
     }
 }
@@ -265,26 +267,42 @@ impl SwapFc {
                 .open(&swapfile_path)?;
         }
 
-        // Disable COW for btrfs
-        let _ = Command::new("chattr").args(["+C"]).arg(&swapfile_path).status();
+        // Determine if we're using btrfs compression mode
+        let use_compression = self.config.use_btrfs_compression;
+        let use_loop = self.config.force_use_loop || use_compression;
+
+        if use_compression {
+            // For btrfs compression: use sparse file with truncate
+            // This allows btrfs to compress the data and only allocate used blocks
+            info!("swapFC: creating sparse file for btrfs compression");
+            Command::new("truncate")
+                .args(["--size", &self.config.chunk_size.to_string()])
+                .arg(&swapfile_path)
+                .status()?;
+            // Do NOT use chattr +C - we want compression!
+        } else {
+            // Disable COW for btrfs (normal mode)
+            let _ = Command::new("chattr").args(["+C"]).arg(&swapfile_path).status();
 
-        // Allocate space
-        Command::new("fallocate")
-            .args(["-l", &self.config.chunk_size.to_string()])
-            .arg(&swapfile_path)
-            .status()?;
+            // Allocate space with fallocate
+            Command::new("fallocate")
+                .args(["-l", &self.config.chunk_size.to_string()])
+                .arg(&swapfile_path)
+                .status()?;
+        }
 
-        let swapfile = if self.config.force_use_loop {
-            let directio = if self.config.directio { "on" } else { "off" };
+        let (swapfile, loop_device) = if use_loop {
+            // Create loop device
+            let directio = if self.config.directio && !use_compression { "on" } else { "off" };
             let loop_dev = run_cmd_output(&[
                 "losetup", "-f", "--show",
                 &format!("--direct-io={}", directio),
                 &swapfile_path.to_string_lossy(),
             ])?;
-            fs::remove_file(&swapfile_path)?;
-            loop_dev
+            let loop_dev = loop_dev.trim().to_string();
+            (loop_dev.clone(), Some(loop_dev))
         } else {
-            swapfile_path.to_string_lossy().to_string()
+            (swapfile_path.to_string_lossy().to_string(), None)
         };
 
         // mkswap
@@ -295,13 +313,21 @@ impl SwapFc {
             .status()?;
 
         // Generate and start swap unit
+        // Use discard=pages for compressed mode to release space when pages are freed
+        let discard_option = if use_compression { "pages" } else { "discard" };
         let unit_name = gen_swap_unit(
             Path::new(&swapfile),
             Some(self.priority),
-            Some("discard"),
+            Some(discard_option),
             &format!("swapfc_{}", self.allocated),
         )?;
 
+        // Store loop device info for cleanup
+        if let Some(ref loop_dev) = loop_device {
+            let loop_info_path = format!("{}/swapfc/loop_{}", WORK_DIR, self.allocated);
+            let _ = fs::write(&loop_info_path, format!("{}\n{}", loop_dev, swapfile_path.display()));
+        }
+
         self.priority -= 1;
 
         systemctl("daemon-reload", "")?;
@@ -316,6 +342,10 @@ impl SwapFc {
 
         let tag = format!("swapfc_{}", self.allocated);
 
+        // Check if we have loop device info for this swap
+        let loop_info_path = format!("{}/swapfc/loop_{}", WORK_DIR, self.allocated);
+        let loop_info = fs::read_to_string(&loop_info_path).ok();
+
         for unit_path in crate::helpers::find_swap_units() {
             if let Ok(content) = crate::helpers::read_file(&unit_path) {
                 if content.contains(&tag) {
@@ -331,7 +361,24 @@ impl SwapFc {
 
                         force_remove(&unit_path, true);
 
-                        if Path::new(&dev).is_file() {
+                        // Clean up loop device and backing file if applicable
+                        if let Some(ref info) = loop_info {
+                            let lines: Vec<&str> = info.lines().collect();
+                            if lines.len() >= 2 {
+                                let loop_dev = lines[0];
+                                let backing_file = lines[1];
+                                
+                                // Detach loop device
+                                let _ = Command::new("losetup")
+                                    .args(["-d", loop_dev])
+                                    .status();
+                                
+                                // Remove backing file
+                                force_remove(backing_file, false);
+                            }
+                            // Remove loop info file
+                            force_remove(&loop_info_path, false);
+                        } else if Path::new(&dev).is_file() {
                             force_remove(&dev, false);
                         }
                     }