mirrors/Zag
1
0
Fork 0
mirror of https://github.com/rdmsr/zag.git synced 2026-10-31 07:18:22 +00:00
Code Issues Packages Projects Releases Wiki Activity

all: standardize suffixes

Browse Source 
ki -> kep
mi -> mmp
This commit is contained in:
Loïc Grégoire
2026-09-02 22:20:25 -04:00
parent cf58ad369e
commit 497e08bd7b
37 changed files with 244 additions and 245 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/mm/amd64/impl.zig
+3 -3
View File
@@ -1,7 +1,7 @@
const amd64 = @import("arch");
const r = @import("root");
const mm = r.mm;
const mi = mm.private;
const mmp = mm.private;
pub const hhdm_minimum_max_address = r.gib(4);
@@ -17,7 +17,7 @@ pub const hhdm_base = 0xffff800000000000;
pub const kernel_heap_base = 0xffffc00000000000;
pub const pfndb_base = 0xffffd00000000000;
pub const levels = [_]mi.PMapLevel{
pub const levels = [_]mmp.PMapLevel{
.{ .shift = 12, .mask = 0x1ff, .leaf = true }, // 4K
.{ .shift = 21, .mask = 0x1ff, .leaf = true }, // 2M
.{ .shift = 30, .mask = 0x1ff, .leaf = true }, // 1G
@@ -117,5 +117,5 @@ pub fn is_leaf_level_enabled(level: usize) bool {
}
pub fn init_kernel() void {
mi.kernel_space.pmap.root_pa = amd64.read_cr(3);
mmp.kernel_space.pmap.root_pa = amd64.read_cr(3);
}
src/mm/balance.zig
+1 -1
View File
@@ -10,7 +10,7 @@ const std = @import("std");
const ps = r.ps;
const ke = r.ke;
const mm = r.mm;
const mi = mm.private;
const mmp = mm.private;
const balance_interval = ke.Tunable(u32, 1000, "mm.balance.interval_ms");
src/mm/heap.zig
+17 -17
View File
@@ -1,54 +1,54 @@
const r = @import("root");
const ke = r.ke;
const mm = r.mm;
const mi = mm.private;
const mmp = mm.private;
pub fn init() void {
mi.kernel_space.arena.init(
mmp.kernel_space.arena.init(
"kernel heap",
mi.impl.kernel_heap_base,
mmp.impl.kernel_heap_base,
r.tib(16),
mm.page_size,
) catch @panic("failed to initialize kernel heap arena");
}
pub fn alloc(size: usize, policy: mm.WaitPolicy) mm.Error!*anyopaque {
mi.kernel_space.lock.acquire();
mmp.kernel_space.lock.acquire();
const addr = mi.kernel_space.arena.alloc(size, .{}) catch {
mi.kernel_space.lock.release();
const addr = mmp.kernel_space.arena.alloc(size, .{}) catch {
mmp.kernel_space.lock.release();
return mm.Error.OutOfMemory;
};
const npages = size / mm.page_size;
for (0..npages) |i| {
const pte = mi.pmap.wire_pte(
&mi.kernel_space,
const pte = mmp.pmap.wire_pte(
&mmp.kernel_space,
addr + (i * mm.page_size),
policy,
) catch {
mi.kernel_space.lock.release();
mmp.kernel_space.lock.release();
return mm.Error.OutOfMemory;
};
mi.kernel_space.lock.release();
mmp.kernel_space.lock.release();
const page = mi.phys.alloc_opts(.{ .policy = policy }) orelse {
const page = mmp.phys.alloc_opts(.{ .policy = policy }) orelse {
return mm.Error.OutOfMemory;
};
mi.kernel_space.lock.acquire();
mmp.kernel_space.lock.acquire();
pte.* = mi.impl.make_leaf_pte(page, .{ .read = true, .write = true }, 0);
pte.* = mmp.impl.make_leaf_pte(page, .{ .read = true, .write = true }, 0);
}
mi.kernel_space.lock.release();
mmp.kernel_space.lock.release();
return @ptrFromInt(addr);
}
pub fn free(va: r.VAddr, size: usize) void {
mi.kernel_space.lock.acquire();
mi.tlb.reclaim_range(&mi.kernel_space, va, size);
mi.kernel_space.lock.release();
mmp.kernel_space.lock.acquire();
mmp.tlb.reclaim_range(&mmp.kernel_space, va, size);
mmp.kernel_space.lock.release();
}
src/mm/init.zig
+8 -8
View File
@@ -1,18 +1,18 @@
const r = @import("root");
const pl = r.pl;
const mm = r.mm;
const mi = mm.private;
const mmp = mm.private;
const config = @import("config");
pub fn init() linksection(r.init) void {
mi.phys.init();
mi.zone.early_init();
mi.vmem.init();
mi.heap.init();
mmp.phys.init();
mmp.zone.early_init();
mmp.vmem.init();
mmp.heap.init();
}
pub fn late_init() linksection(r.init) void {
mi.zone.late_init();
mi.tlb.init();
mi.balance.init();
mmp.zone.late_init();
mmp.tlb.init();
mmp.balance.init();
}
src/mm/phys.zig
+2 -2
View File
@@ -3,7 +3,7 @@ const std = @import("std");
const rtl = @import("rtl");
const pl = r.pl;
const mm = r.mm;
const mi = mm.private;
const mmp = mm.private;
const ke = r.ke;
const log = std.log.scoped(.@"mm/phys");
@@ -173,7 +173,7 @@ pub fn init() linksection(r.init) void {
// Get the kernel pagemap from the loader,
// we are already in it so no need to activate it.
mi.impl.init_kernel();
mmp.impl.init_kernel();
// Calculate the minimum amount of free memory we accept,
// this formula is from Linux and does not grow linearly;
src/mm/pmap.zig
+23 -23
View File
@@ -4,7 +4,7 @@ const r = @import("root");
const rtl = @import("rtl");
const std = @import("std");
const mm = r.mm;
const mi = mm.private;
const mmp = mm.private;
/// Describes a contiguous region of physical memory to be mapped
/// at a given virtual address.
@@ -33,7 +33,7 @@ const ContiguousSource = struct {
};
fn level_shift(level: usize) u6 {
return mi.impl.levels[level].shift;
return mmp.impl.levels[level].shift;
}
fn page_size(level: usize) usize {
@@ -41,24 +41,24 @@ fn page_size(level: usize) usize {
}
fn index_for_level(va: usize, level: usize) usize {
return (va >> level_shift(level)) & mi.impl.levels[level].mask;
return (va >> level_shift(level)) & mmp.impl.levels[level].mask;
}
pub const PMap = struct {
const Self = @This();
const num_levels = mi.impl.levels.len;
const num_levels = mmp.impl.levels.len;
const entries_per_table = 512;
const index_mask = entries_per_table - 1;
root_pa: r.PAddr,
fn is_leaf_level(level: usize) bool {
return mi.impl.levels[level].leaf;
return mmp.impl.levels[level].leaf;
}
fn leaf_level_enabled(level: usize) bool {
return is_leaf_level(level) and mi.impl.is_leaf_level_enabled(level);
return is_leaf_level(level) and mmp.impl.is_leaf_level_enabled(level);
}
fn cursor(self: *Self, va: r.VAddr) Cursor {
@@ -74,7 +74,7 @@ pub const PMap = struct {
}
pub fn activate(self: *Self) void {
mi.impl.activate(self.root_pa);
mmp.impl.activate(self.root_pa);
}
pub fn map_from(self: *Self, va: r.VAddr, size: usize, source: anytype) void {
@@ -129,7 +129,7 @@ pub const PMap = struct {
/// Unmap a contiguous range of virtual pages.
/// Only small pages are supported.
/// Return a pfn that points to the physical pages that were unmapped.
pub fn unmap(self: *Self, va: r.VAddr, size: usize) ?mi.PfnList {
pub fn unmap(self: *Self, va: r.VAddr, size: usize) ?mmp.PfnList {
std.debug.assert(std.mem.isAligned(va, mm.page_size));
var c = self.cursor(va);
@@ -153,7 +153,7 @@ pub const PMap = struct {
const page = mm.pfn_to_struct_page(pfn);
list.insert_tail(&page.free.link);
c.tables[level][idx] = std.mem.zeroes(mi.impl.Pte);
c.tables[level][idx] = std.mem.zeroes(mmp.impl.Pte);
break;
}
@@ -182,7 +182,7 @@ pub const PMap = struct {
va: r.VAddr,
/// Cached pointers to each level's page table, filled as the cursor
/// descends. Only indices in `[0, top_level]` are valid.
tables: [num_levels][*]mi.impl.Pte,
tables: [num_levels][*]mmp.impl.Pte,
/// Index of the highest level for which `tables` currently holds a
/// valid pointer. Descends toward 0 (the leaf) as `walk_down` runs.
/// Reset upward in `advance` when the VA crosses a level boundary.
@@ -197,24 +197,24 @@ pub const PMap = struct {
while (current_level > target_level) {
const idx = index_for_level(self.va, current_level);
var pte = mi.impl.Pte.load(&self.tables[current_level][idx]);
var pte = mmp.impl.Pte.load(&self.tables[current_level][idx]);
if (!pte.present) {
if (!allocate) {
return error.PageNotMapped;
}
const new_table_pa = mi.phys.alloc();
const new_table_pa = mmp.phys.alloc();
const table_ptr: [*]mi.impl.Pte = @ptrFromInt(
const table_ptr: [*]mmp.impl.Pte = @ptrFromInt(
mm.p2v(new_table_pa),
);
@memset(
table_ptr[0..entries_per_table],
std.mem.zeroes(mi.impl.Pte),
std.mem.zeroes(mmp.impl.Pte),
);
pte = mi.impl.make_table_pte(new_table_pa);
pte = mmp.impl.make_table_pte(new_table_pa);
self.tables[current_level][idx] = pte;
}
@@ -247,7 +247,7 @@ pub const PMap = struct {
const table = self.tables[target_level];
table[index_for_level(self.va, target_level)] =
mi.impl.make_leaf_pte(current_pa, flags, target_level);
mmp.impl.make_leaf_pte(current_pa, flags, target_level);
const step = page_size(target_level);
current_pa += step;
@@ -279,14 +279,14 @@ pub const PMap = struct {
};
pub fn wire_pte(
space: *mi.Space,
space: *mmp.Space,
va: r.VAddr,
policy: mm.WaitPolicy,
) mm.Error!*mi.impl.Pte {
) mm.Error!*mmp.impl.Pte {
std.debug.assert(space.lock.is_locked());
var table: [*]mi.impl.Pte = @ptrFromInt(mm.p2v(mi.kernel_space.pmap.root_pa));
var level = mi.impl.levels.len - 1;
var table: [*]mmp.impl.Pte = @ptrFromInt(mm.p2v(mmp.kernel_space.pmap.root_pa));
var level = mmp.impl.levels.len - 1;
while (true) {
const idx = index_for_level(va, level);
@@ -302,7 +302,7 @@ pub fn wire_pte(
// since that may block.
space.lock.release();
const new_table_pa = mi.phys.alloc_opts(.{ .policy = policy }) orelse {
const new_table_pa = mmp.phys.alloc_opts(.{ .policy = policy }) orelse {
space.lock.acquire();
return mm.Error.OutOfMemory;
};
@@ -316,12 +316,12 @@ pub fn wire_pte(
if (entry.present) {
// Another thread beat us to it,
// free the page we just allocated and continue.
mi.phys.free(new_table_pa);
mmp.phys.free(new_table_pa);
} else {
const new_table_ptr: [*]u64 = @ptrFromInt(mm.p2v(new_table_pa));
@memset(new_table_ptr[0..512], 0);
table[idx] = mi.impl.make_table_pte(new_table_pa);
table[idx] = mmp.impl.make_table_pte(new_table_pa);
entry = table[idx];
}
}
src/mm/tlb.zig
+2 -2
View File
@@ -6,7 +6,7 @@ const rtl = @import("rtl");
const ke = r.ke;
const mm = r.mm;
const mi = mm.private;
const mmp = mm.private;
const ps = r.ps;
const ex = r.ex;
@@ -23,7 +23,7 @@ fn reclaim_state(obj: *anyopaque, _: ?*anyopaque) void {
const state: *ke.ShootdownState = @fieldParentPtr("link", link);
const space: *mm.Space = @ptrFromInt(state.payload[0]);
const pfn_list: mi.PfnList = @bitCast(state.payload[1]);
const pfn_list: mmp.PfnList = @bitCast(state.payload[1]);
const base = state.base;
const npages = state.npages;
src/mm/vmem.zig
+2 -2
View File
@@ -58,7 +58,7 @@
const std = @import("std");
const rtl = @import("rtl");
const mm = @import("root").mm;
const mi = mm.private;
const mmp = mm.private;
pub const Policy = enum {
/// Use the smallest free segment that can satisfy the request.
@@ -127,7 +127,7 @@ const Segment = struct {
/// address space.
const freelist_count = @bitSizeOf(usize);
var seg_zone: mi.zone.TypedZone(Segment) = undefined;
var seg_zone: mmp.zone.TypedZone(Segment) = undefined;
pub const Arena = struct {
/// Name of the arena, for debugging purposes.
src/mm/zone.zig
+7 -7
View File
@@ -115,7 +115,7 @@ const config = @import("config");
const ke = r.ke;
const mm = r.mm;
const ex = r.ex;
const mi = mm.private;
const mmp = mm.private;
/// Interval at which we do housekeeping (working set update, reaping, etc.)
pub const update_interval_s = 15;
@@ -907,7 +907,7 @@ pub const Zone = struct {
@intFromPtr(obj),
mm.page_size,
);
const phys = mi.kernel_space.pmap.query(page_va).?;
const phys = mmp.kernel_space.pmap.query(page_va).?;
const page = mm.pfn_to_struct_page(mm.page_to_pfn(phys));
break :blk page.alloced.slab_data.slab;
} else blk: {
@@ -1227,7 +1227,7 @@ pub const Zone = struct {
}
fn alloc_page(policy: mm.WaitPolicy) !*anyopaque {
const alloc_ret = mi.phys.alloc_opts(.{ .policy = policy }) orelse
const alloc_ret = mmp.phys.alloc_opts(.{ .policy = policy }) orelse
return error.OutOfMemory;
return @ptrFromInt(mm.p2v(alloc_ret));
}
@@ -1235,7 +1235,7 @@ pub const Zone = struct {
fn free_page(p: *anyopaque) void {
const phys = mm.v2p(@intFromPtr(p));
mi.phys.free(phys);
mmp.phys.free(phys);
}
fn slab_create_small(self: *Self, policy: mm.WaitPolicy) mm.Error!*Slab {
@@ -1273,7 +1273,7 @@ pub const Zone = struct {
fn slab_create_large(self: *Self, policy: mm.WaitPolicy) mm.Error!*Slab {
const capacity = (self.slab_size) / self.chunk_size;
const buf = try mi.heap.alloc(self.slab_size, policy);
const buf = try mmp.heap.alloc(self.slab_size, policy);
var ret: *Slab = @ptrCast(
@alignCast(
@@ -1296,7 +1296,7 @@ pub const Zone = struct {
ret.alloc_rr = 0;
for (0..self.slab_size / mm.page_size) |i| {
const phys_page = mi.kernel_space.pmap.query(
const phys_page = mmp.kernel_space.pmap.query(
@intFromPtr(buf) + i * mm.page_size,
) orelse @panic("Could not query page");
const page = mm.pfn_to_struct_page(mm.page_to_pfn(phys_page));
@@ -1650,7 +1650,7 @@ fn gpa_alloc(
if (len > 2048) {
if (ptr_align.toByteUnits() > mm.page_size) return null;
const pages = std.mem.alignForward(usize, len, mm.page_size);
const ptr = mi.heap.alloc(pages, .WaitForMemory) catch return null;
const ptr = mmp.heap.alloc(pages, .WaitForMemory) catch return null;
return @ptrCast(ptr);
}