Commit 4971df857213f32b39e79f39b6e391cf76d06c3a | zig

author	antlilja <liljaanton2001@gmail.com> 2023-01-11 22:51:47+01:00
committer	Andrew Kelley <andrew@ziglang.org> 2023-01-12 03:46:15-05:00
log	4971df857213f32b39e79f39b6e391cf76d06c3a
tree	4e77e50e39e28618c1d9cf8062d48b8177d73615
parent	2a92b04b9dc21356f383b12af9040ca79f268267

UEFI pool allocator changes

* Changed the interface to align with the new allocator interface.
* Fixed bug where not enough memory was allocated for the header or to
  align the pointer.

1 files changed, 41 insertions(+), 55 deletions(-)

lib
- std
  - os
    uefi
    pool_allocator.zig

lib/std/os/uefi/pool_allocator.zig+41-55

...	...	@@ -12,68 +12,59 @@ const UefiPoolAllocator = struct {
12	12	return @intToPtr([]align(8) u8, @ptrToInt(ptr) - @sizeOf(usize));
13	13	}
14	14
15		fn alignedAlloc(len: usize, alignment: usize) ?[*]u8 {
16		var unaligned_ptr: [*]align(8) u8 = undefined;
17
18		if (uefi.system_table.boot_services.?.allocatePool(uefi.efi_pool_memory_type, len, &unaligned_ptr) != .Success)
19		return null;
20
21		const unaligned_addr = @ptrToInt(unaligned_ptr);
22		const aligned_addr = mem.alignForward(unaligned_addr + @sizeOf(usize), alignment);
23
24		var aligned_ptr = unaligned_ptr + (aligned_addr - unaligned_addr);
25		getHeader(aligned_ptr).* = unaligned_ptr;
26
27		return aligned_ptr;
28		}
29
30		fn alignedFree(ptr: [*]u8) void {
31		_ = uefi.system_table.boot_services.?.freePool(getHeader(ptr).*);
32		}
33
34	15	fn alloc(
35	16	_: *anyopaque,
36	17	len: usize,
37		ptr_align: u29,
38		len_align: u29,
	18	log2_ptr_align: u8,
39	19	ret_addr: usize,
40		) Allocator.Error![]u8 {
	20	) ?[*]u8 {
41	21	_ = ret_addr;
42	22
43	23	assert(len > 0);
44		assert(std.math.isPowerOfTwo(ptr_align));
45	24
46		var ptr = alignedAlloc(len, ptr_align) orelse return error.OutOfMemory;
	25	const ptr_align = 1 << log2_ptr_align;
	26
	27	const metadata_len = mem.alignForward(@sizeOf(usize), ptr_align);
47	28
48		if (len_align == 0)
49		return ptr[0..len];
	29	const full_len = metadata_len + len;
50	30
51		return ptr[0..mem.alignBackwardAnyAlign(len, len_align)];
	31	var unaligned_ptr: [*]align(8) u8 = undefined;
	32	if (uefi.system_table.boot_services.?.allocatePool(uefi.efi_pool_memory_type, full_len, &unaligned_ptr) != .Success) return null;
	33
	34	const unaligned_addr = @ptrToInt(unaligned_ptr);
	35	const aligned_addr = mem.alignForward(unaligned_addr + @sizeOf(usize), ptr_align);
	36
	37	var aligned_ptr = unaligned_ptr + (aligned_addr - unaligned_addr);
	38	getHeader(aligned_ptr).* = unaligned_ptr;
	39
	40	return aligned_ptr;
52	41	}
53	42
54	43	fn resize(
55	44	_: *anyopaque,
56	45	buf: []u8,
57		buf_align: u29,
	46	log2_old_ptr_align: u8,
58	47	new_len: usize,
59		len_align: u29,
60	48	ret_addr: usize,
61		) ?usize {
62		_ = buf_align;
	49	) bool {
63	50	_ = ret_addr;
64	51
65		return if (new_len <= buf.len) mem.alignAllocLen(buf.len, new_len, len_align) else null;
	52	if (new_len > buf.len) return false;
	53
	54	_ = mem.alignAllocLen(buf.len, new_len, log2_old_ptr_align);
	55
	56	return true;
66	57	}
67	58
68	59	fn free(
69	60	_: *anyopaque,
70	61	buf: []u8,
71		buf_align: u29,
	62	log2_old_ptr_align: u8,
72	63	ret_addr: usize,
73	64	) void {
74		_ = buf_align;
	65	_ = log2_old_ptr_align;
75	66	_ = ret_addr;
76		alignedFree(buf.ptr);
	67	_ = uefi.system_table.boot_services.?.freePool(getHeader(buf.ptr).*);
77	68	}
78	69	};
79	70
...	...	@@ -105,49 +96,44 @@ const raw_pool_allocator_table = Allocator.VTable{
105	96	fn uefi_alloc(
106	97	_: *anyopaque,
107	98	len: usize,
108		ptr_align: u29,
109		len_align: u29,
	99	log2_ptr_align: u8,
110	100	ret_addr: usize,
111		) Allocator.Error![]u8 {
112		_ = len_align;
	101	) ?[*]u8 {
113	102	_ = ret_addr;
114	103
115		std.debug.assert(ptr_align <= 8);
	104	std.debug.assert(log2_ptr_align <= 3);
116	105
117	106	var ptr: [*]align(8) u8 = undefined;
	107	if (uefi.system_table.boot_services.?.allocatePool(uefi.efi_pool_memory_type, len, &ptr) != .Success) return null;
118	108
119		if (uefi.system_table.boot_services.?.allocatePool(uefi.efi_pool_memory_type, len, &ptr) != .Success) {
120		return error.OutOfMemory;
121		}
122
123		return ptr[0..len];
	109	return ptr;
124	110	}
125	111
126	112	fn uefi_resize(
127	113	_: *anyopaque,
128	114	buf: []u8,
129		old_align: u29,
	115	log2_old_ptr_align: u8,
130	116	new_len: usize,
131		len_align: u29,
132	117	ret_addr: usize,
133		) ?usize {
134		_ = old_align;
	118	) bool {
135	119	_ = ret_addr;
136	120
137		if (new_len <= buf.len) {
138		return mem.alignAllocLen(buf.len, new_len, len_align);
139		}
	121	std.debug.assert(log2_old_ptr_align <= 3);
	122
	123	if (new_len > buf.len) return false;
	124
	125	_ = mem.alignAllocLen(buf.len, new_len, 8);
140	126
141		return null;
	127	return true;
142	128	}
143	129
144	130	fn uefi_free(
145	131	_: *anyopaque,
146	132	buf: []u8,
147		buf_align: u29,
	133	log2_old_ptr_align: u8,
148	134	ret_addr: usize,
149	135	) void {
150		_ = buf_align;
	136	_ = log2_old_ptr_align;
151	137	_ = ret_addr;
152	138	_ = uefi.system_table.boot_services.?.freePool(@alignCast(8, buf.ptr));
153	139	}