[PATCH proxmox-backup 09/10] api2: backup: check space for fixed and dynamic index files

[Robert Obkircher <r.obkircher@proxmox.com>]

The dynamic index writer uses a 1 MiB buffer, so size checks only need
to include that.

The fixed index writer uses mmap+ftruncate, which makes it difficult
to tell whether file system space has already been reserved. Because
running out of space would risk getting killed with SIGBUS it is
better to always check for the total size. On non-CoW file systems the
risk could be reduced further by switching to fallocate.

Signed-off-by: Robert Obkircher <r.obkircher@proxmox.com>
---
 src/api2/backup/environment.rs | 23 +++++++++++++++++++++++
 src/api2/backup/mod.rs         | 19 ++++++++++++++++++-
 2 files changed, 41 insertions(+), 1 deletion(-)

diff --git a/src/api2/backup/environment.rs b/src/api2/backup/environment.rs
index ab623f1ff..c297d78c5 100644
--- a/src/api2/backup/environment.rs
+++ b/src/api2/backup/environment.rs
@@ -377,6 +377,24 @@ impl BackupEnvironment {
         Ok(uid)
     }
 
+    pub fn fixed_writer_check_space(&self, wid: usize, offset: u64) -> Result<(), Error> {
+        let mut state = self.state.lock().unwrap();
+
+        state.ensure_unfinished()?;
+
+        let data = match state.fixed_writers.get_mut(&wid) {
+            Some(data) => data,
+            None => bail!("fixed writer '{}' not registered", wid),
+        };
+
+        let content_size = data
+            .size
+            .unwrap_or_else(|| data.index.size().max(offset + data.chunk_size as u64));
+
+        self.datastore
+            .check_space(4096 + 32 * content_size.div_ceil(data.chunk_size as u64))
+    }
+
     /// Append chunk to dynamic writer
     pub fn dynamic_writer_append_chunk(
         &self,
@@ -533,6 +551,8 @@ impl BackupEnvironment {
             );
         }
 
+        self.datastore.check_space(1024 * 1024)?;
+
         let expected_csum = data.index.close()?;
         data.closed = true;
 
@@ -642,6 +662,9 @@ impl BackupEnvironment {
             }
         }
 
+        self.datastore
+            .check_space(4096 + data.index.index_length() as u64 * 32)?;
+
         let expected_csum = data.index.close()?;
         data.closed = true;
 
diff --git a/src/api2/backup/mod.rs b/src/api2/backup/mod.rs
index 86ec49487..0edaca601 100644
--- a/src/api2/backup/mod.rs
+++ b/src/api2/backup/mod.rs
@@ -437,6 +437,8 @@ fn create_dynamic_index(
         bail!("wrong archive extension: '{}'", archive_name);
     }
 
+    env.datastore.check_space(1024 * 1024)?;
+
     let mut path = env.backup_dir.relative_path();
     path.push(archive_name);
 
@@ -489,6 +491,8 @@ fn create_fixed_index(
         bail!("wrong archive extension: '{}'", archive_name);
     }
 
+    env.datastore.check_space(size.unwrap_or(4096 + 4096))?;
+
     let mut path = env.backup_dir.relative_path();
     path.push(&archive_name);
 
@@ -610,6 +614,10 @@ fn dynamic_append(
 
     env.debug(format!("dynamic_append {} chunks", digest_list.len()));
 
+    // BufWriter capacity + new data
+    env.datastore
+        .check_space(1024 * 1024 + digest_list.len() as u64 * 40)?;
+
     for (i, item) in digest_list.iter().enumerate() {
         let digest_str = item.as_str().unwrap();
         let digest = <[u8; 32]>::from_hex(digest_str)?;
@@ -683,10 +691,19 @@ fn fixed_append(
 
     env.debug(format!("fixed_append {} chunks", digest_list.len()));
 
+    let offset_list = offset_list
+        .iter()
+        .map(|o| o.as_u64().unwrap())
+        .collect::<Vec<_>>();
+
+    if let Some(max_offset) = offset_list.iter().max() {
+        env.fixed_writer_check_space(wid, *max_offset)?;
+    }
+
     for (i, item) in digest_list.iter().enumerate() {
         let digest_str = item.as_str().unwrap();
         let digest = <[u8; 32]>::from_hex(digest_str)?;
-        let offset = offset_list[i].as_u64().unwrap();
+        let offset = offset_list[i];
         let size = env
             .lookup_chunk(&digest)
             .ok_or_else(|| format_err!("no such chunk {}", digest_str))?;
-- 
2.47.3