blob: 00f9ceff8dd74946e6f70ca79a0b67d5e701050b (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
|
//! Zone Allocation
const types = @import("../types/types.zig");
const Zone = types.Zone;
const ZonePageMeta = types.ZonePageMeta;
const FreeElement = types.FreeElement;
const page_size = types.page_size;
const bootstrap = @import("../bootstrap/bootstrap.zig");
const convert = @import("../../convert/convert.zig");
const pmm = @import("../../../pmm/pmm.zig");
pub const AllocError = error{
OutOfMemory,
};
pub fn zalloc(zone: *Zone) AllocError!*anyopaque {
if (zone.partial_pages == null) {
try expand(zone);
}
const page = zone.partial_pages orelse return AllocError.OutOfMemory;
const elem = page.free_list orelse return AllocError.OutOfMemory;
page.free_list = elem.next;
page.in_use += 1;
zone.alloc_count += 1;
if (page.free_list == null) {
zone.partial_pages = page.next;
page.next = zone.full_pages;
zone.full_pages = page;
}
return @ptrCast(elem);
}
pub fn zalloc_zeroed(zone: *Zone) AllocError!*anyopaque {
const ptr = try zalloc(zone);
const bytes: [*]u8 = @ptrCast(ptr);
@memset(bytes[0..zone.elem_size], 0);
return ptr;
}
pub fn zfree(zone: *Zone, ptr: *anyopaque) void {
const page_virt = @intFromPtr(ptr) & ~@as(usize, page_size - 1);
const page = find_page(zone, page_virt) orelse return;
const was_full = (page.free_list == null);
const elem: *FreeElement = @ptrCast(@alignCast(ptr));
elem.next = page.free_list;
page.free_list = elem;
page.in_use -|= 1;
zone.free_count += 1;
if (was_full) {
remove_from_full(zone, page);
page.next = zone.partial_pages;
zone.partial_pages = page;
}
}
fn expand(zone: *Zone) AllocError!void {
const phys = pmm.allocate_page() catch return AllocError.OutOfMemory;
const virt = convert.phys_to_virt(phys);
const page_meta_zone = bootstrap.get_page_meta_zone();
const meta_ptr = zalloc(page_meta_zone) catch {
pmm.free_page(phys);
return AllocError.OutOfMemory;
};
const meta: *ZonePageMeta = @ptrCast(@alignCast(meta_ptr));
meta.zone = zone;
meta.page_phys = phys;
meta.page_virt = virt;
meta.free_list = null;
meta.in_use = 0;
meta.next = zone.partial_pages;
zone.partial_pages = meta;
zone.page_count += 1;
const base: [*]u8 = @ptrFromInt(virt);
var offset: usize = 0;
while (offset + zone.elem_size <= page_size) : (offset += zone.elem_size) {
const elem: *FreeElement = @ptrCast(@alignCast(base + offset));
elem.next = meta.free_list;
meta.free_list = elem;
}
}
fn find_page(zone: *Zone, page_virt: usize) ?*ZonePageMeta {
var current = zone.partial_pages;
while (current) |page_meta| {
if (page_meta.page_virt == page_virt) return page_meta;
current = page_meta.next;
}
current = zone.full_pages;
while (current) |page_meta| {
if (page_meta.page_virt == page_virt) return page_meta;
current = page_meta.next;
}
return null;
}
fn remove_from_full(zone: *Zone, target: *ZonePageMeta) void {
if (zone.full_pages == target) {
zone.full_pages = target.next;
return;
}
var current = zone.full_pages;
while (current) |page_meta| {
if (page_meta.next == target) {
page_meta.next = target.next;
return;
}
current = page_meta.next;
}
}
|
