Allocate files with posix_fallocate.

File::set_len() does not immediately allocate space for the file
resulting in potential failures when accessing those files at a
later point (e.g., if the disk is full).

This functionality can be tested by creating an arbitrarily small
tmpfs mount and creating state/data files within it:
```sh
sudo mount -t tmpfs -o size=4 tmpfs /tmp/limit
```

As a side effect, this creates more useful error messages:
```rust
FailedStateRead(Os { code: 28, kind: StorageFull, message: "No space
left on device" })
````

Author: austinhartzheim

src/data.rs

@@ -8,6 +8,7 @@ use std::os::unix::fs::OpenOptionsExt;
 use crate::instance::InstanceVersion;
 use crate::synchronizer::SynchronizerError;
 use crate::synchronizer::SynchronizerError::*;
+use crate::utils;
 
 /// Data container stores memory mapped data files allowing
 /// to switch between them when data instance version is changed
@@ -60,7 +61,7 @@ impl DataContainer {
             // grow data file when its current length exceeded
             let data_len = data.len() as u64;
             if data_len > data_file.metadata().map_err(FailedDataWrite)?.len() {
-                data_file.set_len(data_len).map_err(FailedDataWrite)?;
+                utils::set_len(&data_file, data_len as i64).map_err(FailedDataWrite)?;
             }
 
             *mmap = Some(unsafe { MmapMut::map_mut(&data_file).map_err(FailedDataWrite)? });

src/lib.rs

@@ -16,3 +16,4 @@ pub mod instance;
 pub mod locks;
 mod state;
 pub mod synchronizer;
+mod utils;

src/state.rs

@@ -13,6 +13,7 @@ use crate::instance::InstanceVersion;
 use crate::locks::WriteLockStrategy;
 use crate::synchronizer::SynchronizerError;
 use crate::synchronizer::SynchronizerError::*;
+use crate::utils;
 
 const STATE_SIZE: usize = mem::size_of::<State>();
 
@@ -162,9 +163,7 @@ impl<'a, WL: WriteLockStrategy<'a>> StateContainer<WL> {
         let mut need_init = false;
         // Reset state file size to match exactly `STATE_SIZE`
         if state_file.metadata().map_err(FailedStateRead)?.len() != STATE_SIZE as u64 {
-            state_file
-                .set_len(STATE_SIZE as u64)
-                .map_err(FailedStateRead)?;
+            utils::set_len(&state_file, STATE_SIZE as i64).map_err(FailedStateRead)?;
             need_init = true;
         }
 

src/utils.rs

@@ -0,0 +1,18 @@
+use std::fs::File;
+use std::io;
+#[cfg(unix)]
+use std::os::fd::AsRawFd;
+
+/// Set the length of the file to the specified length.
+pub(crate) fn set_len(file: &File, len: i64) -> Result<(), io::Error> {
+    // On Unix platforms, `.set_len()` may not return an error of the disk is full, so we allocate
+    // the entire file to ensure space is available.
+    #[cfg(unix)]
+    match unsafe { libc::posix_fallocate(file.as_raw_fd(), 0, len) } {
+        0 => Ok(()),
+        err => Err(io::Error::from_raw_os_error(err)),
+    }
+    // Support for non-Linux platforms is best-effort.
+    #[cfg(not(unix))]
+    data_file.set_len(STATE_SIZE).map_err(FailedStateRead)
+}