Change to swapfc_chunk_size=20%

bigbruno · bigbruno · commit fbb41113df7f · 2026-01-03T11:09:49.000-03:00
diff --git a/README.md b/README.md
@@ -62,11 +62,11 @@ makepkg -si
 ## Usage
 
 ```bash
-# Check status (run as root for detailed zswap stats)
-sudo systemd-swap status
+# Check status (works without root, extra stats when root)
+systemd-swap status
 
-# View available compression algorithms
-systemd-swap compression
+# Show help
+systemd-swap --help
 
 # Restart after config changes
 sudo systemctl restart systemd-swap
@@ -135,7 +135,7 @@ zram_writeback_size=1G           # Auto backing file size
 ################################################################################
 # SwapFC - Dynamic swap files
 ################################################################################
-swapfc_chunk_size=512M           # Size of each swap file
+swapfc_chunk_size=512M           # Size: 512M, 1G, 10% (of RAM)
 swapfc_max_count=32              # Maximum swap files
 swapfc_free_ram_perc=35          # Create when free RAM < this %
 swapfc_free_swap_perc=25         # Create more when free swap < this %
diff --git a/include/swap-default.conf b/include/swap-default.conf
@@ -24,7 +24,7 @@ swap_mode=auto
 ################################################################################
 
 zswap_compressor=zstd            # lzo lz4 zstd lzo-rle lz4hc
-zswap_max_pool_percent=45        # Max % of RAM for compressed pool
+zswap_max_pool_percent=50        # Max % of RAM for compressed pool
 zswap_zpool=zsmalloc             # Memory allocator (zsmalloc better than zbud)
 zswap_shrinker_enabled=0         # Proactively move cold pages to swap
 zswap_accept_threshold=90        # Accept pages again after pool was full (%)
@@ -38,7 +38,7 @@ zswap_accept_threshold=90        # Accept pages again after pool was full (%)
 ################################################################################
 
 # zram_size supports: 1G, 512M, 50%, 100% (full RAM)
-zram_size=50%                # Size of zram device
+zram_size=80%               # Size of zram device
 zram_alg=zstd               # Compression: lzo lz4 zstd lzo-rle lz4hc
 zram_prio=32767             # Swap priority (highest = used first)
 
@@ -56,7 +56,8 @@ zram_writeback_size=1G      # Size of auto-created backing file
 # Creates swap files on-demand as memory pressure increases
 ################################################################################
 
-swapfc_chunk_size=512M           # Size of each swap file
+# swapfc_chunk_size supports: 1G, 512M, 10% (percentage of RAM)
+swapfc_chunk_size=20%            # Size of each swap file
 swapfc_max_count=32              # Maximum number of swap files
 swapfc_min_count=1               # Minimum (1 for zswap backing)
 swapfc_free_ram_perc=35          # Create swap when free RAM < this %
diff --git a/src/main.rs b/src/main.rs
@@ -32,8 +32,6 @@ enum Commands {
     Stop,
     /// Show swap status information
     Status,
-    /// List available compression algorithms
-    Compression,
 }
 
 /// Swap strategy based on filesystem detection
@@ -49,11 +47,17 @@ enum SwapMode {
 fn main() {
     let cli = Cli::parse();
 
-    let result = match cli.command.unwrap_or(Commands::Status) {
-        Commands::Start => start(),
-        Commands::Stop => stop(false),
-        Commands::Status => status(),
-        Commands::Compression => compression(),
+    let result = match cli.command {
+        Some(Commands::Start) => start(),
+        Some(Commands::Stop) => stop(false),
+        Some(Commands::Status) => status(),
+        None => {
+            // No subcommand provided, show help
+            use clap::CommandFactory;
+            Cli::command().print_help().ok();
+            println!();
+            return;
+        }
     };
 
     if let Err(e) = result {
@@ -368,7 +372,7 @@ fn status() -> Result<(), Box<dyn std::error::Error>> {
     }
 
     let swap_stats = get_mem_stats(&["MemTotal", "SwapTotal", "SwapFree"])?;
-    let mem_total = swap_stats["MemTotal"];
+    let _mem_total = swap_stats["MemTotal"];
     let swap_total = swap_stats["SwapTotal"];
     let swap_used = swap_total - swap_stats["SwapFree"];
 
@@ -380,59 +384,50 @@ fn status() -> Result<(), Box<dyn std::error::Error>> {
         println!("  zpool: {}", zswap.zpool);
         println!("  max_pool_percent: {}%", zswap.max_pool_percent);
 
-        if is_root && (zswap.pool_size > 0 || zswap.stored_pages > 0) {
-            let page_size = get_page_size();
-            let stored_bytes = zswap.stored_pages * page_size;
-            let ratio = zswap.compression_ratio(page_size);
-            let pool_util = zswap.pool_utilization_percent(mem_total);
-
-            println!();
-            println!("  === Pool Statistics (debugfs) ===");
-            println!("  pool_size: {} ({:.1} MiB)", zswap.pool_size, zswap.pool_size as f64 / 1024.0 / 1024.0);
-            println!("  stored_pages: {} ({:.1} MiB uncompressed)", zswap.stored_pages, stored_bytes as f64 / 1024.0 / 1024.0);
-            println!("  pool_utilization: {}%", pool_util);
-            println!("  compress_ratio: {:.0}%", ratio * 100.0);
-            println!("  same_filled_pages: {}", zswap.same_filled_pages);
-            println!();
-            println!("  === Writeback Statistics ===");
-            println!("  written_back_pages: {} ({:.1} MiB)", 
-                     zswap.written_back_pages, 
-                     (zswap.written_back_pages * page_size) as f64 / 1024.0 / 1024.0);
-            println!("  pool_limit_hit: {}", zswap.pool_limit_hit);
-            println!("  reject_reclaim_fail: {}", zswap.reject_reclaim_fail);
-
-            // Show effective swap usage
-            if swap_used > 0 {
-                let disk_used = swap_used.saturating_sub(stored_bytes);
-                println!();
-                println!("  === Effective Swap Usage ===");
-                println!("  kernel_reported_used: {:.1} MiB", swap_used as f64 / 1024.0 / 1024.0);
-                println!("  in_zswap_pool (RAM): {:.1} MiB", stored_bytes as f64 / 1024.0 / 1024.0);
-                println!("  actual_disk_used: {:.1} MiB", disk_used as f64 / 1024.0 / 1024.0);
-                let percent_in_ram = if swap_used > 0 {
-                    (stored_bytes as f64 / swap_used as f64) * 100.0
+        // Try to get basic stats from /proc/meminfo (works without root!)
+        if let Ok(usage) = systemd_swap::meminfo::get_effective_swap_usage() {
+            if usage.zswap_active {
+                let zswap_original = swap_used.saturating_sub(usage.swap_used_disk);
+                let zswap_compressed = usage.zswap_pool_bytes;
+                
+                let ratio = if zswap_original > 0 {
+                    (zswap_compressed as f64 / zswap_original as f64) * 100.0
                 } else {
                     0.0
                 };
-                println!("  swap_in_ram: {:.0}%", percent_in_ram);
-            }
-        } else if zswap.pool_size > 0 || zswap.stored_pages > 0 {
-            // Non-root, basic info only
-            let page_size = get_page_size();
-            let stored_bytes = zswap.stored_pages * page_size;
-            let ratio = if zswap.stored_pages > 0 {
-                (zswap.pool_size as f64 / stored_bytes as f64) * 100.0
-            } else {
-                0.0
-            };
 
-            println!("  pool_size: {} bytes", zswap.pool_size);
-            println!("  stored_pages: {}", zswap.stored_pages);
-            println!("  compress_ratio: {:.0}%", ratio);
+                println!();
+                println!("  === Pool Statistics ===");
+                println!("  pool_size: {:.1} MiB (compressed)", zswap_compressed as f64 / 1024.0 / 1024.0);
+                println!("  stored_data: {:.1} MiB (original)", zswap_original as f64 / 1024.0 / 1024.0);
+                println!("  pool_utilization: {}%", usage.zswap_pool_percent);
+                println!("  compress_ratio: {:.0}%", ratio);
+
+                // If running as root, show additional debugfs stats
+                if is_root && (zswap.stored_pages > 0 || zswap.written_back_pages > 0) {
+                    let page_size = get_page_size();
+                    
+                    println!();
+                    println!("  === Writeback Statistics (debugfs) ===");
+                    println!("  stored_pages: {}", zswap.stored_pages);
+                    println!("  same_filled_pages: {}", zswap.same_filled_pages);
+                    println!("  written_back_pages: {} ({:.1} MiB)", 
+                             zswap.written_back_pages, 
+                             (zswap.written_back_pages * page_size) as f64 / 1024.0 / 1024.0);
+                    println!("  pool_limit_hit: {}", zswap.pool_limit_hit);
+                    println!("  reject_reclaim_fail: {}", zswap.reject_reclaim_fail);
+                }
 
-            if swap_used > 0 {
-                let percent = (stored_bytes as f64 / swap_used as f64) * 100.0;
-                println!("  zswap_store/swap_store: {}/{} ({:.0}%)", stored_bytes, swap_used, percent);
+                // Show effective swap usage
+                if swap_used > 0 {
+                    println!();
+                    println!("  === Effective Swap Usage ===");
+                    println!("  kernel_reported_used: {:.1} MiB", swap_used as f64 / 1024.0 / 1024.0);
+                    println!("  in_zswap_pool (RAM): {:.1} MiB", zswap_original as f64 / 1024.0 / 1024.0);
+                    println!("  actual_disk_used: {:.1} MiB", usage.swap_used_disk as f64 / 1024.0 / 1024.0);
+                    let percent_in_ram = (zswap_original as f64 / swap_used as f64) * 100.0;
+                    println!("  swap_in_ram: {:.0}%", percent_in_ram);
+                }
             }
         }
     }
@@ -473,33 +468,3 @@ fn status() -> Result<(), Box<dyn std::error::Error>> {
     Ok(())
 }
 
-/// Show available compression algorithms
-fn compression() -> Result<(), Box<dyn std::error::Error>> {
-    let crypto = fs::read_to_string("/proc/crypto")?;
-
-    print!("Found loaded compression algorithms: ");
-
-    let mut first = true;
-    let mut current_name = String::new();
-
-    for line in crypto.lines() {
-        let line = line.trim();
-        if let Some(name) = line.strip_prefix("name") {
-            current_name = name.trim_start_matches(':').trim().to_string();
-        } else if let Some(typ) = line.strip_prefix("type") {
-            let current_type = typ.trim_start_matches(':').trim();
-
-            if current_type == "compression" && !current_name.is_empty() {
-                if first {
-                    first = false;
-                } else {
-                    print!(", ");
-                }
-                print!("{}", current_name);
-            }
-        }
-    }
-
-    println!();
-    Ok(())
-}
diff --git a/src/meminfo.rs b/src/meminfo.rs
@@ -175,7 +175,21 @@ pub struct EffectiveSwapUsage {
 /// When zswap is active, the kernel reports swap usage based on allocated slots,
 /// but most of those pages may still be in zswap's RAM pool and not written to disk.
 /// This function calculates the actual disk pressure.
+/// 
+/// Uses /proc/meminfo (Zswap, Zswapped) for basic stats - works without root!
+/// Optionally uses debugfs for additional statistics when running as root.
 pub fn get_effective_swap_usage() -> Result<EffectiveSwapUsage> {
+    // Try to get zswap stats from /proc/meminfo (available without root!)
+    // These fields were added in kernel 5.x
+    let zswap_fields = get_mem_stats_optional(&["Zswap", "Zswapped"]);
+    let (zswap_compressed, zswap_original) = match zswap_fields {
+        Ok(fields) => (
+            fields.get("Zswap").copied().unwrap_or(0),
+            fields.get("Zswapped").copied().unwrap_or(0),
+        ),
+        Err(_) => (0, 0),
+    };
+
     let stats = get_mem_stats(&["MemTotal", "SwapTotal", "SwapFree"])?;
     let swap_total = stats["SwapTotal"];
     let swap_free = stats["SwapFree"];
@@ -186,45 +200,72 @@ pub fn get_effective_swap_usage() -> Result<EffectiveSwapUsage> {
         swap_total,
         swap_free,
         swap_used_kernel,
-        zswap_pool_bytes: 0,
-        swap_used_disk: swap_used_kernel, // Default: assume all on disk
+        zswap_pool_bytes: zswap_compressed,
+        swap_used_disk: swap_used_kernel.saturating_sub(zswap_original),
         zswap_pool_percent: 0,
-        zswap_active: false,
+        zswap_active: zswap_original > 0 || zswap_compressed > 0,
     };
 
-    // Check zswap status
-    if let Some(zswap_stats) = get_zswap_stats() {
-        let page_size = get_page_size();
-        let stored_bytes = zswap_stats.stored_pages * page_size;
-
-        if stored_bytes > 0 {
-            result.zswap_active = true;
-            result.zswap_pool_bytes = zswap_stats.pool_total_size;
-
-            // Actual disk usage = kernel reported usage - pages in zswap pool
-            // Pages in zswap pool are still in RAM, not written to disk
-            result.swap_used_disk = swap_used_kernel.saturating_sub(stored_bytes);
-
-            // Calculate zswap pool utilization
-            // Read max_pool_percent from sysfs
-            let max_pool_percent: u64 = std::fs::read_to_string(
-                "/sys/module/zswap/parameters/max_pool_percent"
-            )
-                .ok()
-                .and_then(|s| s.trim().parse().ok())
-                .unwrap_or(20);
-
-            let max_pool_size = mem_total * max_pool_percent / 100;
-            if max_pool_size > 0 {
-                result.zswap_pool_percent = 
-                    ((zswap_stats.pool_total_size * 100) / max_pool_size).min(100) as u8;
-            }
+    // Calculate pool utilization if zswap is active
+    if result.zswap_active {
+        let max_pool_percent: u64 = std::fs::read_to_string(
+            "/sys/module/zswap/parameters/max_pool_percent"
+        )
+            .ok()
+            .and_then(|s| s.trim().parse().ok())
+            .unwrap_or(20);
+
+        let max_pool_size = mem_total * max_pool_percent / 100;
+        if max_pool_size > 0 {
+            result.zswap_pool_percent = 
+                ((zswap_compressed * 100) / max_pool_size).min(100) as u8;
         }
     }
 
     Ok(result)
 }
 
+/// Read memory stats from /proc/meminfo, ignoring missing fields
+fn get_mem_stats_optional(fields: &[&str]) -> Result<HashMap<String, u64>> {
+    let mut stats = HashMap::new();
+    let mut remaining: HashSet<&str> = fields.iter().copied().collect();
+
+    let file = File::open("/proc/meminfo")?;
+    let reader = BufReader::new(file);
+
+    for line in reader.lines() {
+        let line = line?;
+
+        if let Some(colon_pos) = line.find(':') {
+            let key = &line[..colon_pos];
+
+            if remaining.contains(key) {
+                let value_part = line[colon_pos + 1..].trim();
+                let parts: Vec<&str> = value_part.split_whitespace().collect();
+
+                let value = if parts.len() >= 2 && parts[1] == "kB" {
+                    parts[0].parse::<u64>().ok().map(|v| v * 1024)
+                } else if !parts.is_empty() {
+                    parts[0].parse::<u64>().ok()
+                } else {
+                    None
+                };
+
+                if let Some(v) = value {
+                    stats.insert(key.to_string(), v);
+                    remaining.remove(key);
+
+                    if remaining.is_empty() {
+                        break;
+                    }
+                }
+            }
+        }
+    }
+
+    Ok(stats)
+}
+
 /// Get effective free swap percentage accounting for zswap
 /// 
 /// This returns a more accurate picture of swap pressure:
diff --git a/src/swapfc.rs b/src/swapfc.rs
@@ -90,9 +90,22 @@ impl SwapFcConfig {
     }
 }
 
-/// Parse size string like "512M" or "1G" to bytes
+/// Parse size string like "512M", "1G", or "10%" (percentage of RAM) to bytes
 fn parse_size(s: &str) -> Result<u64> {
     let s = s.trim();
+    
+    // Check for percentage (e.g., "10%", "50%")
+    if let Some(percent_str) = s.strip_suffix('%') {
+        let percent: u64 = percent_str.parse().map_err(|_| SwapFcError::InvalidPath)?;
+        if percent > 100 {
+            return Err(SwapFcError::InvalidPath);
+        }
+        
+        // Get total RAM and calculate percentage
+        let ram_size = crate::meminfo::get_ram_size().map_err(|_| SwapFcError::InvalidPath)?;
+        return Ok(ram_size * percent / 100);
+    }
+    
     let (num, suffix) = s.split_at(s.len().saturating_sub(1));
     
     let multiplier = match suffix.to_uppercase().as_str() {
@@ -101,7 +114,7 @@ fn parse_size(s: &str) -> Result<u64> {
         "G" => 1024 * 1024 * 1024,
         "T" => 1024 * 1024 * 1024 * 1024,
         _ => {
-            // No suffix, try parsing whole string
+            // No suffix, try parsing whole string as bytes
             return s.parse().map_err(|_| SwapFcError::InvalidPath);
         }
     };
