Lesson 5: Free Space

Free Space for a drive and check on file’s allocation policy in place in OS

Rust

 use std::fs::{self, File, remove_file}; use std::io::{self, Write, Seek, SeekFrom}; use std::path::Path; fn main() -> io::Result<()> { loop { println!("Enter file length in bytes (0 to quit):"); let mut input = String::new(); io::stdin().read_line(&mut input)?; let file_len: u64 = input.trim().parse().unwrap_or(0); if file_len == 0 { break; } let file_path = Path::new("temp_test_file"); let midpoint = file_len / 2; report_space("Before file creation")?; // Create file let mut file = File::create(file_path)?; report_space("After file creation")?; // Set file length file.set_len(file_len)?; report_space("After setting file length")?; // Write to midpoint file.seek(SeekFrom::Start(midpoint))?; file.write_all(&[0u8; 256])?; report_space("After writing to middle")?; // Cleanup drop(file); remove_file(file_path)?; println!("----------------------------------------\n"); } println!("\nEnd of FreeSpace demonstration"); Ok(()) } #[cfg(windows)] fn report_space(stage: &str) -> io::Result<()> { use std::ffi::OsStr; use std::os::windows::ffi::OsStrExt; use std::mem::MaybeUninit; #[repr(C)] #[derive(Debug)] struct ULARGE_INTEGER { quad_part: u64, } extern "system" { fn GetDiskFreeSpaceExW( lpDirectoryName: *const u16, lpFreeBytesAvailableToCaller: *mut ULARGE_INTEGER, lpTotalNumberOfBytes: *mut ULARGE_INTEGER, lpTotalNumberOfFreeBytes: *mut ULARGE_INTEGER, ) -> i32; } let path = Path::new("."); let mut path_utf16: Vec<u16> = OsStr::new(path).encode_wide().chain(Some(0)).collect(); let mut free_bytes = MaybeUninit::<ULARGE_INTEGER>::uninit(); let mut total_bytes = MaybeUninit::<ULARGE_INTEGER>::uninit(); let mut total_free = MaybeUninit::<ULARGE_INTEGER>::uninit(); let success = unsafe { GetDiskFreeSpaceExW( path_utf16.as_ptr(), free_bytes.as_mut_ptr(), total_bytes.as_mut_ptr(), total_free.as_mut_ptr(), ) }; if success == 0 { return Err(io::Error::last_os_error()); } let free_bytes = unsafe { free_bytes.assume_init().quad_part }; let total_bytes = unsafe { total_bytes.assume_init().quad_part }; let used_space = total_bytes - free_bytes; print_space(stage, total_bytes, used_space, free_bytes); Ok(()) } #[cfg(unix)] fn report_space(stage: &str) -> io::Result<()> { use std::os::unix::ffi::OsStrExt; use libc::{statvfs, c_char}; use std::ffi::CString; let path = Path::new("."); let c_path = CString::new(path.as_os_str().as_bytes()).unwrap(); let mut stat: libc::statvfs = unsafe { std::mem::zeroed() }; let result = unsafe { statvfs(c_path.as_ptr() as *const c_char, &mut stat) }; if result != 0 { return Err(io::Error::last_os_error()); } let block_size = stat.f_frsize as u64; let total_bytes = stat.f_blocks * block_size; let free_bytes = stat.f_bavail * block_size; let used_space = total_bytes - free_bytes; print_space(stage, total_bytes, used_space, free_bytes); Ok(()) } fn print_space(stage: &str, total: u64, used: u64, free: u64) { // Function (1): `print_space` // Purpose: Prints formatted information about disk space usage. // Input Parameters: // `stage`: A string slice describing the current stage or context. // `total`: Total disk space in bytes. // `used`: Used disk space in bytes. // `free`: Free disk space in bytes. // Output: Prints formatted output to the console. // Return Value: None. // Core Concept: Formats and displays disk space statistics, // demonstrating basic string formatting and numeric output in Rust. // Functionality Breakdown: // 1. Prints the stage with centered alignment. // 2. Prints total, used, and free space in bytes, comma-formatted. // 3. Prints total and free space in gigabytes, formatted to two // decimal places. // Nested Layers: // Layer 1: Function Definition and Parameter Handling // - Defines the function signature and input parameter types. // - Handles string slice and unsigned 64-bit integer inputs. // - Implies a context where disk space information is relevant // and needs to be displayed. // Layer 2: String Formatting and Output // - Uses `println!` macro for formatted output. // - Leverages format specifiers for alignment and numeric // formatting. // - Calls `format_num` (2) for comma-separated number formatting. // - Calls `bytes_to_gb` (3) for unit conversion (not provided, // assumed to exist). // Layer 3: Data Presentation and Unit Conversion // - Presents data in both bytes and gigabytes for readability. // - Assumes `bytes_to_gb` (3) performs a floating-point division // by 1024^3. // - Implies an audience familiar with both byte and gigabyte units. // Implications: // - The function assumes the existence of a `bytes_to_gb` (3) // function. // - The output is intended for human consumption, prioritizing // readability. // - The function does not perform any error handling or input // validation. println!("\n{:^20} status:", stage); // Variable (4): `stage`. // Purpose: Represents the current stage or context of the operation. // Data Type: `&str` (string slice). // Value Domain: Any valid UTF-8 string. // Theoretical Minimum Value: "" (empty string). // Theoretical Maximum Value: Theoretically unbounded, practically // limited by available memory. // Memory Footprint: String slices do not own the underlying data, // they only hold a pointer to the data and its length. // Architecture: The size of a `&str` is the size of a pointer plus // the size of a `usize` (for the length). Typically 16 bytes on 64-bit // architectures and 8 bytes on 32-bit architectures. // Edge Cases: // - Very long strings might affect formatting. // - Non-ASCII characters might affect alignment. // - Empty string is a valid input. // - Input containing only whitespace characters. // - Input with control characters or escape sequences. // - Input exceeding the display width of the terminal. // Nested Layers: // Layer 1: String Slice Representation // - `&str` is a borrowed reference to a string, providing a view // into a portion of a string. // - It does not own the underlying data, ensuring memory safety. // - The lifetime of the `&str` must not exceed the lifetime of // the string it refers to. // Layer 2: UTF-8 Encoding // - `&str` represents a sequence of UTF-8 encoded characters. // - Each character can be 1 to 4 bytes in length. // - UTF-8 is a variable-width character encoding, capable of // encoding all valid Unicode code points. // Layer 3: Memory Safety and Borrowing // - Rust's borrow checker ensures that the `&str` does not outlive // the string it borrows from. // - Prevents dangling pointers and ensures memory safety. // - Implies that the string data is owned elsewhere and cannot // be modified through this `&str`. println!("{:<15} {:>20} bytes", "Total space:", format_num(total)); // Variable (5): `total`. // Purpose: Represents the total disk space in bytes. // Data Type: `u64` (unsigned 64-bit integer). // Value Domain: [0, 2^64 - 1]. // Theoretical Minimum Value: 0. // Theoretical Maximum Value: 18,446,744,073,709,551,615. // Memory Footprint: 8 bytes on all architectures. // Edge Cases: // - Extremely large values might be difficult to format or display. // - Zero value indicates no disk space. // - Maximum value (2^64 - 1) is unlikely in practice but technically // possible. // - Input values representing impossible physical disk sizes. // - Values near the maximum representable limit, approaching // overflow if manipulated further. // - Values that are not multiples of typical disk sector sizes. // Nested Layers: // Layer 1: Unsigned Integer Representation // - `u64` represents a non-negative integer using 64 bits. // - Uses binary representation for storage. // - Cannot represent negative values. // Layer 2: Bitwise Operations // - `u64` supports bitwise operations like AND, OR, XOR, NOT, // left shift, and right shift. // - These operations can be used for low-level manipulation of // the value. // - Potential for bit manipulation errors if not handled // carefully. // Layer 3: Overflow Behavior // - In Rust, arithmetic operations on `u64` wrap around on // overflow in release mode. // - In debug mode, overflow will cause a panic. // - Overflow can lead to unexpected results if not accounted for. // Mitigation Strategies for Edge Cases: // - Implement input validation to ensure the value is within // realistic bounds for the given system. // - Use error handling mechanisms to gracefully handle overflow // situations. // - Consider using larger data types or specialized libraries for // handling very large numbers if necessary. println!("{:<15} {:>20} bytes", "Used space:", format_num(used)); // Variable (6): `used`. // Purpose: Represents the used disk space in bytes. // Data Type: `u64` (unsigned 64-bit integer). // Value Domain: [0, 2^64 - 1]. // Theoretical Minimum Value: 0. // Theoretical Maximum Value: 18,446,744,073,709,551,615. // Memory Footprint: 8 bytes. // Edge Cases: // - `used` greater than `total` is logically impossible but should // be handled. // - Zero value indicates no disk space used. // - A value equal to `total` indicates no free space. // - Values significantly larger than the expected usage, // potentially indicating an error in calculation. // - Values very close to the total capacity, leaving little free // space. // - Rapidly changing values in a multithreaded environment without // proper synchronization. // Nested Layers: // Layer 1: Relationship with `total` and `free` // - `used` is typically derived from `total` and `free`, or vice // versa. // - The relationship should be: `total` = `used` + `free`. // - Inconsistency in this relationship indicates an error. // Layer 2: Implications for System Operations // - High `used` space can lead to performance degradation. // - Low free space can prevent new files from being created. // - Monitoring `used` space is crucial for system stability. // Layer 3: Potential for Integer Overflow // - If `used` is calculated from other values, there's a // potential for integer overflow. // - Overflow can lead to incorrect calculations and unexpected // behavior. // - Mitigation: Use checked arithmetic operations or saturating // arithmetic to handle overflow gracefully. println!("{:<15} {:>20} bytes", "Free space:", format_num(free)); // Variable (7): `free`. // Purpose: Represents the free disk space in bytes. // Data Type: `u64` (unsigned 64-bit integer). // Value Domain: [0, 2^64 - 1]. // Theoretical Minimum Value: 0. // Theoretical Maximum Value: 18,446,744,073,709,551,615. // Memory Footprint: 8 bytes. // Edge Cases: // - Zero value indicates no free space, potentially halting system // operations. // - `free` greater than `total` is logically impossible. // - Very small values indicate limited capacity for new data. // - Values significantly larger than expected, indicating potential // errors in disk space reporting. // - Negative values if calculated incorrectly due to overflow. // - Inconsistent values reported by different tools or APIs due to // timing issues or caching mechanisms. // Nested Layers: // Layer 1: Relationship with `total` and `used` // - `free` is typically derived from `total` and `used`. // - Should satisfy: `total` = `used` + `free`. // - Discrepancies indicate errors in calculation or reporting. // Layer 2: Impact on System Performance // - Low `free` space can severely impact performance. // - Can lead to fragmentation and slow down file operations. // - Operating systems often reserve a portion of disk space, // affecting the actual usable `free` space. // Layer 3: Implications for File System Operations // - `free` space is crucial for creating and extending files. // - File systems may have limitations on how they allocate // `free` space. // - Different file systems may report `free` space differently. println!("{:<15} {:>20.2} GB", "Total:", bytes_to_gb(total)); // Function Call (3): `bytes_to_gb` (Assumed) // Purpose: Converts bytes to gigabytes. // Input: `u64` (bytes). // Output: `f64` or similar (gigabytes). // Core Concept: Unit conversion, likely involves division by 1024^3. // Potential Implementation: `fn bytes_to_gb(bytes: u64) -> f64 { // bytes as f64 / (1024.0 * 1024.0 * 1024.0) }` // Edge Cases for `bytes_to_gb`: // - Input of 0 should return 0. // - Very large inputs might lose precision due to floating-point // representation. // - Potential for rounding errors in the conversion. // - Different interpretations of "gigabyte" (1000^3 vs 1024^3). // - Input values that result in fractional gigabytes, requiring // rounding for display. // - Input values exceeding the maximum representable value for // `f64`, leading to infinity or NaN. println!("{:<15} {:>20.2} GB", "Free:", bytes_to_gb(free)); // Redundant call to `bytes_to_gb` with `free`. } fn format_num(n: u64) -> String { // Function (2): `format_num` // Purpose: Formats an unsigned 64-bit integer with comma separators. // Input: `n` - The number to format. // Output: A formatted string representation of the number. // Core Concept: String manipulation and numeric formatting. Adds commas // as thousands separators for improved readability. // Functionality Breakdown: // 1. Converts the `u64` to a `String`. // 2. Iterates through the characters of the string in reverse. // 3. Inserts a comma every three digits. // 4. Reverses the result to obtain the correct order. // Nested Layers: // Layer 1: Number to String Conversion // - `n.to_string()` converts the `u64` to its decimal string // representation. // - This involves converting the internal binary representation // to a base-10 string. // - The resulting string is allocated on the heap. // Layer 2: Reverse Iteration and Comma Insertion // - Iterating in reverse simplifies the logic for inserting // commas. // - `count` variable tracks the position from the end of the // string. // - Conditional logic ensures commas are only inserted at // appropriate positions. // Layer 3: String Reversal and Collection // - `result.chars().rev().collect()` reverses the string back to // the original order. // - `collect()` gathers the characters into a new `String`. // - Involves creating a new string and copying characters. // Implications: // - The function allocates memory on the heap for the intermediate // and final strings. // - The performance might be suboptimal for very large numbers due // to multiple string manipulations. // - The function assumes the standard US-style number formatting // with commas as thousands separators. let num_str = n.to_string(); // Variable (8): `num_str`. // Purpose: Stores the string representation of the input number `n`. // Data Type: `String` (owned string). // Value Domain: Any valid string representation of a `u64` in base 10. // Theoretical Minimum Value: "0". // Theoretical Maximum Value: "18446744073709551615". // Memory Footprint: Variable, depends on the length of the string. // Each character is a UTF-8 encoded, taking 1-4 bytes per character. // Additionally, `String` has an overhead for managing the heap-allocated // data (pointer, length, capacity). // Edge Cases: // - Input of 0 results in "0". // - Maximum `u64` value results in "18446744073709551615". // - Large numbers will result in longer strings, consuming more // memory. // - The string representation of very large numbers might be // difficult to read without separators. // - The conversion process itself might have limitations based on // the implementation of `to_string()`. // - Potential memory allocation failures if the system is out of // memory and the number is extremely large. let mut result = String::new(); // Variable (9): `result`. // Purpose: Stores the formatted number string being built. // Data Type: `String` (owned string). // Value Domain: Any valid UTF-8 string, but intended to be a // comma-separated representation of a number. // Theoretical Minimum Value: "" (empty string). // Theoretical Maximum Value: Theoretically unbounded, practically // limited by available memory and the maximum length of the formatted // number. // Memory Footprint: Initially, it's an empty string with a small // overhead. As characters and commas are added, it will grow dynamically // on the heap. // Edge Cases: // - The number of commas inserted depends on the magnitude of the // input number. // - For very large numbers, the resulting string can become quite // long. // - Potential for memory allocation failures during string growth // if the system is low on memory. // - If the input number is zero, the result will be "0" without any // commas. // - The growth pattern of the string might not be linear due to // reallocations when the capacity is exceeded. // - The specific growth strategy depends on the implementation of // `String` and its allocator. let mut count = 0; // Variable (10): `count`. // Purpose: Tracks the number of digits processed from the right. // Data Type: `u64`. // Value Domain: [0, 2^64 - 1]. Practically, it will be much smaller, // limited by the number of digits in the input number. // Theoretical Minimum Value: 0. // Theoretical Maximum Value: Theoretically 18,446,744,073,709,551,615, // but practically limited by the number of digits in `n`. // Memory Footprint: 8 bytes. // Edge Cases: // - If the input number has a number of digits that is a multiple // of 3, the last group will not have a comma prepended. // - For single-digit numbers, `count` will only reach 1. // - For very large numbers, `count` will correspond to the total // number of digits in the number. // - Potential for integer overflow if the input number has more // than 2^64 - 1 digits (highly unlikely). // - The maximum value of `count` is limited by the maximum length // of the string representation of the input number. // - If the input number were somehow modified externally during // the iteration, `count` might not accurately reflect the position. for c in num_str.chars().rev() { // Control Flow (11): `for` loop // Purpose: Iterates over the characters of `num_str` in reverse // order. // Iteration: The loop processes each character from the end of the // string to the beginning. // Termination: The loop terminates when all characters have been // processed. // Edge Cases: // - Empty string: The loop will not execute. // - String with only one character: The loop will execute once. // - Very long strings: The loop will iterate many times, // potentially impacting performance. // - If the string is modified concurrently during iteration, // the behavior is undefined. // - The performance of the loop depends on the efficiency of // the `chars()` and `rev()` iterators. // - The loop's behavior is undefined if the string contains // invalid UTF-8 sequences. // Nested Layers: // Layer 1: `chars()` Iterator // - `chars()` creates an iterator over the Unicode scalar // values of the string. // - Each iteration yields a `char`. // - The iterator handles UTF-8 decoding. // Layer 2: `rev()` Iterator Adapter // - `rev()` reverses the direction of the iterator. // - It adapts the underlying `chars()` iterator to yield // elements in reverse order. // - `rev()` itself does not allocate new memory. It just // changes the iteration direction. // Layer 3: Loop Body Execution // - For each character, the loop body is executed. // - The loop body manipulates `result` and `count`. // - The order of execution is crucial for the correct // formatting. if count % 3 == 0 && count != 0 { // Control Flow (12): `if` statement // Purpose: Determines whether to insert a comma. // Condition: A comma is inserted if `count` is a multiple of 3 // and not zero. // Edge Cases: // - `count` is 0: No comma is inserted. // - `count` is a multiple of 3: A comma is inserted. // - `count` is not a multiple of 3: No comma is inserted. // - The first group of digits (from the right) will never // have a comma prepended, even if it has three digits. // - The condition ensures that commas are only inserted // between groups of digits, not at the beginning. // - The behavior is consistent for all valid input values // of `count`. result.push(','); // String Manipulation (13): `result.push(',')` // Purpose: Appends a comma to the `result` string. // Operation: Modifies `result` in-place by adding a comma // character. // Edge Cases: // - `result` is empty: The comma becomes the first character. // - `result` already has content: The comma is appended to // the end. // - Repeated calls to `push` will keep appending commas. // - Potential for memory reallocation if `result`'s // capacity is exceeded. // - The performance of `push` depends on the implementation // of `String` and its dynamic resizing strategy. // - If the system is out of memory, `push` might fail to // allocate more memory for the string. } result.push(c); // String Manipulation (14): `result.push(c)` // Purpose: Appends the current character `c` to the `result` string. // Operation: Modifies `result` in-place. // Edge Cases: // - `result` is empty: `c` becomes the first character. // - `result` already has content: `c` is appended to the end. // - Repeated calls will append multiple characters. // - Memory reallocation might occur if `result`'s capacity is // exceeded. // - The performance depends on `String`'s implementation. // - If `c` is a multi-byte UTF-8 character, it will be appended // correctly as a single unit. count += 1; // Variable Update (15): `count += 1` // Purpose: Increments the digit counter. // Operation: Adds 1 to `count`. // Edge Cases: // - `count` is at its maximum value: Overflow will occur (in // release mode, it will wrap around; in debug mode, it will // panic). // - Overflow is unlikely in this specific scenario but // theoretically possible. // - The increment ensures that `count` tracks the number of // digits processed from the right. // - The correctness of the comma placement logic depends on // this increment. // - If the increment is accidentally skipped or duplicated, // the formatting will be incorrect. } result.chars().rev().collect() // String Manipulation (16): `result.chars().rev().collect()` // Purpose: Reverses the `result` string to obtain the correct order. // Operation: // 1. `result.chars()`: Creates an iterator over the characters of // `result`. // 2. `.rev()`: Reverses the iterator. // 3. `.collect()`: Collects the characters into a new `String`. // Edge Cases: // - `result` is empty: Returns an empty string. // - `result` has one character: Returns a string with the same // character. // - `result` has multiple characters: Returns a new string with // the characters in reversed order. // - Memory allocation occurs during `collect()` to create the new // reversed string. // - The performance depends on the length of `result` and the // efficiency of the iterators and `collect()`. // - If `result` contains multi-byte UTF-8 characters, they will // be reversed correctly as single units. } fn bytes_to_gb(bytes: u64) -> f64 { bytes as f64 / (1024.0 * 1024.0 * 1024.0) } 

C++ Implementation

// C++ implementation will be added here #include <windows.h> #include <tchar.h> #include <stdio.h> #include <stdlib.h>  void ReportError(LPCTSTR msg, DWORD exitCode, BOOL exitProgram); void ReportSpace(LPCTSTR Message); int _tmain(int argc, LPTSTR argv[]) { HANDLE hFile; LARGE_INTEGER FileLen, FileLenH; BYTE Buffer[256]; OVERLAPPED ov = {0}; DWORD nWrite; while (1) { FileLen.QuadPart = 0; _tprintf(_T("Enter file length in bytes (0 to quit): ")); _tscanf_s(_T("%I64d"), &FileLen.QuadPart); if (FileLen.QuadPart == 0) break; _tprintf(_T("\nRequested file size: %,20I64d bytes\n"), FileLen.QuadPart); FileLenH.QuadPart = FileLen.QuadPart / 2; ReportSpace(_T("Before file creation")); hFile = CreateFile(_T("TempTestFile"), GENERIC_READ | GENERIC_WRITE, 0, NULL, CREATE_NEW, FILE_ATTRIBUTE_NORMAL, NULL); if (hFile == INVALID_HANDLE_VALUE) ReportError(_T("Cannot create TempTestFile"), 2, TRUE); ReportSpace(_T("After file creation")); if (!SetFilePointerEx(hFile, FileLen, NULL, FILE_BEGIN)) ReportError(_T("Cannot set file pointer"), 3, TRUE); if (!SetEndOfFile(hFile)) ReportError(_T("Cannot set end of file"), 4, TRUE); ReportSpace(_T("After setting file length")); ov.Offset = FileLenH.LowPart; ov.OffsetHigh = FileLenH.HighPart; if (!WriteFile(hFile, Buffer, sizeof(Buffer), &nWrite, &ov)) ReportError(_T("Cannot write to middle of file"), 5, TRUE); ReportSpace(_T("After writing to middle")); CloseHandle(hFile); DeleteFile(_T("TempTestFile")); _tprintf(_T("\n----------------------------------------\n")); } _tprintf(_T("\nEnd of FreeSpace demonstration\n")); return 0; } void ReportError(LPCTSTR msg, DWORD exitCode, BOOL exitProgram) { LPVOID lpMsgBuf; DWORD dw = GetLastError(); FormatMessage( FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, dw, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&lpMsgBuf, 0, NULL); _tprintf(_T("\nERROR [%d]: %s\n"), dw, (LPCTSTR)lpMsgBuf); LocalFree(lpMsgBuf); if (exitProgram) { ExitProcess(exitCode); } } void ReportSpace(LPCTSTR Message) { ULARGE_INTEGER FreeBytes, TotalBytes, NumFreeBytes; const double GB = 1024.0 * 1024.0 * 1024.0; if (!GetDiskFreeSpaceEx(NULL, &FreeBytes, &TotalBytes, &NumFreeBytes)) ReportError(_T("Cannot get free space"), 1, TRUE); _tprintf(_T("\n%25s status:\n"), Message); _tprintf(_T(" Total disk space: %12.2f GB\n"), (double)TotalBytes.QuadPart / GB); _tprintf(_T(" Actual free space: %12.2f GB\n"), (double)NumFreeBytes.QuadPart / GB); _tprintf(_T(" Available to user: %12.2f GB\n"), (double)FreeBytes.QuadPart / GB); } 

Exercise

Let us implement this for small disks and observe, in C++23 or C++20.