Skip to main content

strat9_kernel/shell/commands/mem/
mod.rs

1//! Memory management commands
2use crate::{
3    shell::{output::format_bytes, ShellError},
4    shell_println,
5};
6use alloc::string::String;
7
8/// Display memory status
9pub fn cmd_mem(args: &[String]) -> Result<(), ShellError> {
10    if args.len() > 0 && args[0] == "zones" {
11        return cmd_mem_zones();
12    }
13
14    let (total_pages, allocated_pages) = {
15        let allocator_guard = crate::memory::buddy::get_allocator().lock();
16        if let Some(ref allocator) = *allocator_guard {
17            allocator.page_totals()
18        } else {
19            shell_println!("  Memory allocator not initialized");
20            return Ok(());
21        }
22    };
23
24    let total_bytes = total_pages * 4096;
25    let used_bytes = allocated_pages * 4096;
26    let free_bytes = total_bytes - used_bytes;
27
28    let (total_val, total_unit) = format_bytes(total_bytes);
29    let (used_val, used_unit) = format_bytes(used_bytes);
30    let (free_val, free_unit) = format_bytes(free_bytes);
31
32    shell_println!("Memory status:");
33    shell_println!(
34        "  Total:     {} {} ({} pages)",
35        total_val,
36        total_unit,
37        total_pages
38    );
39    shell_println!(
40        "  Used:      {} {} ({} pages)",
41        used_val,
42        used_unit,
43        allocated_pages
44    );
45    shell_println!(
46        "  Free:      {} {} ({} pages)",
47        free_val,
48        free_unit,
49        total_pages - allocated_pages
50    );
51    shell_println!("");
52
53    Ok(())
54}
55
56/// Display detailed memory zone information
57fn cmd_mem_zones() -> Result<(), ShellError> {
58    const MAX_ZONES: usize = 4;
59    let mut zones_info = [(0u8, 0u64, 0usize, 0usize); MAX_ZONES];
60    let zone_count;
61
62    {
63        let allocator_guard = crate::memory::buddy::get_allocator().lock();
64        if let Some(ref allocator) = *allocator_guard {
65            zone_count = allocator.zone_snapshot(&mut zones_info);
66        } else {
67            shell_println!("  Memory allocator not initialized");
68            return Ok(());
69        }
70    }
71
72    shell_println!("Memory zones:");
73    for i in 0..zone_count {
74        let (zone_type, base, page_count, allocated) = zones_info[i];
75        let total_bytes = page_count * 4096;
76        let free_bytes = (page_count - allocated) * 4096;
77
78        let (total_val, total_unit) = format_bytes(total_bytes);
79        let (free_val, free_unit) = format_bytes(free_bytes);
80
81        shell_println!("  Zone {:?}:", zone_type_from_u8(zone_type));
82        shell_println!("    Base:      0x{:016x}", base);
83        shell_println!(
84            "    Total:     {} {} ({} pages)",
85            total_val,
86            total_unit,
87            page_count
88        );
89        shell_println!(
90            "    Free:      {} {} ({} pages)",
91            free_val,
92            free_unit,
93            page_count - allocated
94        );
95        shell_println!("    Used:      {} pages", allocated);
96        shell_println!("");
97    }
98
99    Ok(())
100}
101
102/// Performs the zone type from u8 operation.
103fn zone_type_from_u8(val: u8) -> crate::memory::zone::ZoneType {
104    match val {
105        0 => crate::memory::zone::ZoneType::DMA,
106        1 => crate::memory::zone::ZoneType::Normal,
107        2 => crate::memory::zone::ZoneType::HighMem,
108        _ => crate::memory::zone::ZoneType::DMA,
109    }
110}