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,68 +12,59 @@ const UefiPoolAllocator = struct {
12	return @intToPtr([]align(8) u8, @ptrToInt(ptr) - @sizeOf(usize));	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	fn alloc(	15	fn alloc(
35	_: *anyopaque,	16	_: *anyopaque,
36	len: usize,	17	len: usize,
37	ptr_align: u29,	18	log2_ptr_align: u8,
38	len_align: u29,
39	ret_addr: usize,	19	ret_addr: usize,
40	) Allocator.Error![]u8 {	20	) ?[*]u8 {
41	_ = ret_addr;	21	_ = ret_addr;
42		22
43	assert(len > 0);	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)	29	const full_len = metadata_len + len;
49	return ptr[0..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	fn resize(	43	fn resize(
55	_: *anyopaque,	44	_: *anyopaque,
56	buf: []u8,	45	buf: []u8,
57	buf_align: u29,	46	log2_old_ptr_align: u8,
58	new_len: usize,	47	new_len: usize,
59	len_align: u29,
60	ret_addr: usize,	48	ret_addr: usize,
61	) ?usize {	49	) bool {
62	_ = buf_align;
63	_ = ret_addr;	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	fn free(	59	fn free(
69	_: *anyopaque,	60	_: *anyopaque,
70	buf: []u8,	61	buf: []u8,
71	buf_align: u29,	62	log2_old_ptr_align: u8,
72	ret_addr: usize,	63	ret_addr: usize,
73	) void {	64	) void {
74	_ = buf_align;	65	_ = log2_old_ptr_align;
75	_ = ret_addr;	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,49 +96,44 @@ const raw_pool_allocator_table = Allocator.VTable{
105	fn uefi_alloc(	96	fn uefi_alloc(
106	_: *anyopaque,	97	_: *anyopaque,
107	len: usize,	98	len: usize,
108	ptr_align: u29,	99	log2_ptr_align: u8,
109	len_align: u29,
110	ret_addr: usize,	100	ret_addr: usize,
111	) Allocator.Error![]u8 {	101	) ?[*]u8 {
112	_ = len_align;
113	_ = ret_addr;	102	_ = ret_addr;
114		103
115	std.debug.assert(ptr_align <= 8);	104	std.debug.assert(log2_ptr_align <= 3);
116		105
117	var ptr: [*]align(8) u8 = undefined;	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) {	109	return ptr;
120	return error.OutOfMemory;
121	}
122
123	return ptr[0..len];
124	}	110	}
125		111
126	fn uefi_resize(	112	fn uefi_resize(
127	_: *anyopaque,	113	_: *anyopaque,
128	buf: []u8,	114	buf: []u8,
129	old_align: u29,	115	log2_old_ptr_align: u8,
130	new_len: usize,	116	new_len: usize,
131	len_align: u29,
132	ret_addr: usize,	117	ret_addr: usize,
133	) ?usize {	118	) bool {
134	_ = old_align;
135	_ = ret_addr;	119	_ = ret_addr;
136		120
137	if (new_len <= buf.len) {	121	std.debug.assert(log2_old_ptr_align <= 3);
138	return mem.alignAllocLen(buf.len, new_len, len_align);	122
139	}	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	fn uefi_free(	130	fn uefi_free(
145	_: *anyopaque,	131	_: *anyopaque,
146	buf: []u8,	132	buf: []u8,
147	buf_align: u29,	133	log2_old_ptr_align: u8,
148	ret_addr: usize,	134	ret_addr: usize,
149	) void {	135	) void {
150	_ = buf_align;	136	_ = log2_old_ptr_align;
151	_ = ret_addr;	137	_ = ret_addr;
152	_ = uefi.system_table.boot_services.?.freePool(@alignCast(8, buf.ptr));	138	_ = uefi.system_table.boot_services.?.freePool(@alignCast(8, buf.ptr));
153	}	139	}