authorgravatar for kubkon@jakubkonka.comJakub Konka <kubkon@jakubkonka.com> 2022-03-13 14:59:15+01:00
committergravatar for kubkon@jakubkonka.comJakub Konka <kubkon@jakubkonka.com> 2022-03-13 14:59:15+01:00
log1af0c75d71257ede964abf81209e167cb40f71f8
treeb2c1ee755d09ce8026f345d3912203afe5e1b84f
parent68c224d6ec9e710e70b4500c5b73fb40780621c0

std: fix imports for darwin specific flags and funcs

4 files changed, 51 insertions(+), 47 deletions(-)

lib/std/c.zig+3-1
......@@ -39,10 +39,12 @@ pub fn versionCheck(glibc_version: std.builtin.Version) type {
3939 };
4040}
4141
42pub const darwin = @import("c/darwin.zig");
43
4244pub usingnamespace switch (builtin.os.tag) {
4345 .linux => @import("c/linux.zig"),
4446 .windows => @import("c/windows.zig"),
45 .macos, .ios, .tvos, .watchos => @import("c/darwin.zig"),
47 .macos, .ios, .tvos, .watchos => darwin,
4648 .freebsd, .kfreebsd => @import("c/freebsd.zig"),
4749 .netbsd => @import("c/netbsd.zig"),
4850 .dragonfly => @import("c/dragonfly.zig"),
lib/std/macho.zig+9-9
......@@ -2,15 +2,15 @@ const std = @import("std");
22const builtin = @import("builtin");
33const assert = std.debug.assert;
44const io = std.io;
5const os = std.os.darwin;
5const c = std.c.darwin;
66const mem = std.mem;
77const meta = std.meta;
88const testing = std.testing;
99
1010const Allocator = mem.Allocator;
1111
12pub const cpu_type_t = os.integer_t;
13pub const cpu_subtype_t = os.integer_t;
12pub const cpu_type_t = c.integer_t;
13pub const cpu_subtype_t = c.integer_t;
1414
1515pub const mach_header = extern struct {
1616 magic: u32,
......@@ -605,10 +605,10 @@ pub const segment_command = extern struct {
605605 filesize: u32,
606606
607607 /// maximum VM protection
608 maxprot: os.vm_prot_t,
608 maxprot: c.vm_prot_t,
609609
610610 /// initial VM protection
611 initprot: os.vm_prot_t,
611 initprot: c.vm_prot_t,
612612
613613 /// number of sections in segment
614614 nsects: u32,
......@@ -642,10 +642,10 @@ pub const segment_command_64 = extern struct {
642642 filesize: u64 = 0,
643643
644644 /// maximum VM protection
645 maxprot: os.vm_prot_t = os.PROT.NONE,
645 maxprot: c.vm_prot_t = c.PROT.NONE,
646646
647647 /// initial VM protection
648 initprot: os.vm_prot_t = os.PROT.NONE,
648 initprot: c.vm_prot_t = c.PROT.NONE,
649649
650650 /// number of sections in segment
651651 nsects: u32 = 0,
......@@ -2148,8 +2148,8 @@ test "read-write segment command" {
21482148 .vmaddr = 4294967296,
21492149 .vmsize = 294912,
21502150 .filesize = 294912,
2151 .maxprot = os.PROT.READ | os.PROT.WRITE | os.PROT.EXEC,
2152 .initprot = os.PROT.EXEC | os.PROT.READ,
2151 .maxprot = c.PROT.READ | c.PROT.WRITE | c.PROT.EXEC,
2152 .initprot = c.PROT.EXEC | c.PROT.READ,
21532153 .nsects = 1,
21542154 },
21552155 };
lib/std/os.zig+5-1
......@@ -29,7 +29,11 @@ const Allocator = std.mem.Allocator;
2929const Preopen = std.fs.wasi.Preopen;
3030const PreopenList = std.fs.wasi.PreopenList;
3131
32pub const darwin = @import("os/darwin.zig");
32pub const darwin = struct {
33 pub usingnamespace std.c;
34 pub usingnamespace @import("os/darwin.zig");
35};
36
3337pub const dragonfly = std.c;
3438pub const freebsd = std.c;
3539pub const haiku = std.c;
lib/std/os/darwin.zig+34-36
......@@ -1,9 +1,7 @@
11const std = @import("std");
2const c = std.c.darwin;
23const log = std.log;
34const mem = std.mem;
4const os = @This();
5
6pub usingnamespace @import("../c.zig");
75
86pub const MachError = error{
97 /// Not enough permissions held to perform the requested kernel
......@@ -16,24 +14,24 @@ pub const MachError = error{
1614};
1715
1816pub const MachTask = struct {
19 port: os.mach_port_name_t,
17 port: c.mach_port_name_t,
2018
2119 pub fn isValid(self: MachTask) bool {
2220 return self.port != 0;
2321 }
2422
25 pub fn getCurrProtection(task: MachTask, address: u64, len: usize) MachError!os.vm_prot_t {
23 pub fn getCurrProtection(task: MachTask, address: u64, len: usize) MachError!c.vm_prot_t {
2624 var base_addr = address;
27 var base_len: os.mach_vm_size_t = if (len == 1) 2 else len;
28 var objname: os.mach_port_t = undefined;
29 var info: os.vm_region_submap_info_64 = undefined;
30 var count: os.mach_msg_type_number_t = os.VM_REGION_SUBMAP_SHORT_INFO_COUNT_64;
31 switch (os.getKernError(os.mach_vm_region(
25 var base_len: c.mach_vm_size_t = if (len == 1) 2 else len;
26 var objname: c.mach_port_t = undefined;
27 var info: c.vm_region_submap_info_64 = undefined;
28 var count: c.mach_msg_type_number_t = c.VM_REGION_SUBMAP_SHORT_INFO_COUNT_64;
29 switch (c.getKernError(c.mach_vm_region(
3230 task.port,
3331 &base_addr,
3432 &base_len,
35 os.VM_REGION_BASIC_INFO_64,
36 @ptrCast(os.vm_region_info_t, &info),
33 c.VM_REGION_BASIC_INFO_64,
34 @ptrCast(c.vm_region_info_t, &info),
3735 &count,
3836 &objname,
3937 ))) {
......@@ -46,16 +44,16 @@ pub const MachTask = struct {
4644 }
4745 }
4846
49 pub fn setMaxProtection(task: MachTask, address: u64, len: usize, prot: os.vm_prot_t) MachError!void {
47 pub fn setMaxProtection(task: MachTask, address: u64, len: usize, prot: c.vm_prot_t) MachError!void {
5048 return task.setProtectionImpl(address, len, true, prot);
5149 }
5250
53 pub fn setCurrProtection(task: MachTask, address: u64, len: usize, prot: os.vm_prot_t) MachError!void {
51 pub fn setCurrProtection(task: MachTask, address: u64, len: usize, prot: c.vm_prot_t) MachError!void {
5452 return task.setProtectionImpl(address, len, false, prot);
5553 }
5654
57 fn setProtectionImpl(task: MachTask, address: u64, len: usize, set_max: bool, prot: os.vm_prot_t) MachError!void {
58 switch (os.getKernError(os.mach_vm_protect(task.port, address, len, @boolToInt(set_max), prot))) {
55 fn setProtectionImpl(task: MachTask, address: u64, len: usize, set_max: bool, prot: c.vm_prot_t) MachError!void {
56 switch (c.getKernError(c.mach_vm_protect(task.port, address, len, @boolToInt(set_max), prot))) {
5957 .SUCCESS => return,
6058 .FAILURE => return error.PermissionDenied,
6159 else => |err| {
......@@ -73,7 +71,7 @@ pub const MachTask = struct {
7371 try task.setCurrProtection(
7472 address,
7573 buf.len,
76 os.PROT.READ | os.PROT.WRITE | os.PROT.COPY,
74 c.PROT.READ | c.PROT.WRITE | c.PROT.COPY,
7775 );
7876 defer {
7977 task.setCurrProtection(address, buf.len, curr_prot) catch {};
......@@ -90,11 +88,11 @@ pub const MachTask = struct {
9088
9189 while (total_written < count) {
9290 const curr_size = maxBytesLeftInPage(page_size, curr_addr, count - total_written);
93 switch (os.getKernError(os.mach_vm_write(
91 switch (c.getKernError(c.mach_vm_write(
9492 task.port,
9593 curr_addr,
9694 @ptrToInt(out_buf.ptr),
97 @intCast(os.mach_msg_type_number_t, curr_size),
95 @intCast(c.mach_msg_type_number_t, curr_size),
9896 ))) {
9997 .SUCCESS => {},
10098 .FAILURE => return error.PermissionDenied,
......@@ -106,12 +104,12 @@ pub const MachTask = struct {
106104
107105 switch (arch) {
108106 .aarch64 => {
109 var mattr_value: os.vm_machine_attribute_val_t = os.MATTR_VAL_CACHE_FLUSH;
110 switch (os.getKernError(os.vm_machine_attribute(
107 var mattr_value: c.vm_machine_attribute_val_t = c.MATTR_VAL_CACHE_FLUSH;
108 switch (c.getKernError(c.vm_machine_attribute(
111109 task.port,
112110 curr_addr,
113111 curr_size,
114 os.MATTR_CACHE,
112 c.MATTR_CACHE,
115113 &mattr_value,
116114 ))) {
117115 .SUCCESS => {},
......@@ -143,9 +141,9 @@ pub const MachTask = struct {
143141
144142 while (total_read < count) {
145143 const curr_size = maxBytesLeftInPage(page_size, curr_addr, count - total_read);
146 var curr_bytes_read: os.mach_msg_type_number_t = 0;
147 var vm_memory: os.vm_offset_t = undefined;
148 switch (os.getKernError(os.mach_vm_read(task.port, curr_addr, curr_size, &vm_memory, &curr_bytes_read))) {
144 var curr_bytes_read: c.mach_msg_type_number_t = 0;
145 var vm_memory: c.vm_offset_t = undefined;
146 switch (c.getKernError(c.mach_vm_read(task.port, curr_addr, curr_size, &vm_memory, &curr_bytes_read))) {
149147 .SUCCESS => {},
150148 .FAILURE => return error.PermissionDenied,
151149 else => |err| {
......@@ -155,7 +153,7 @@ pub const MachTask = struct {
155153 }
156154
157155 @memcpy(out_buf[0..].ptr, @intToPtr([*]const u8, vm_memory), curr_bytes_read);
158 _ = os.vm_deallocate(os.mach_task_self(), vm_memory, curr_bytes_read);
156 _ = c.vm_deallocate(c.mach_task_self(), vm_memory, curr_bytes_read);
159157
160158 out_buf = out_buf[curr_bytes_read..];
161159 curr_addr += curr_bytes_read;
......@@ -179,20 +177,20 @@ pub const MachTask = struct {
179177
180178 fn getPageSize(task: MachTask) MachError!usize {
181179 if (task.isValid()) {
182 var info_count = os.TASK_VM_INFO_COUNT;
183 var vm_info: os.task_vm_info_data_t = undefined;
184 switch (os.getKernError(os.task_info(
180 var info_count = c.TASK_VM_INFO_COUNT;
181 var vm_info: c.task_vm_info_data_t = undefined;
182 switch (c.getKernError(c.task_info(
185183 task.port,
186 os.TASK_VM_INFO,
187 @ptrCast(os.task_info_t, &vm_info),
184 c.TASK_VM_INFO,
185 @ptrCast(c.task_info_t, &vm_info),
188186 &info_count,
189187 ))) {
190188 .SUCCESS => return @intCast(usize, vm_info.page_size),
191189 else => {},
192190 }
193191 }
194 var page_size: os.vm_size_t = undefined;
195 switch (os.getKernError(os._host_page_size(os.mach_host_self(), &page_size))) {
192 var page_size: c.vm_size_t = undefined;
193 switch (c.getKernError(c._host_page_size(c.mach_host_self(), &page_size))) {
196194 .SUCCESS => return page_size,
197195 else => |err| {
198196 log.err("_host_page_size kernel call failed with error code: {s}", .{@tagName(err)});
......@@ -202,9 +200,9 @@ pub const MachTask = struct {
202200 }
203201};
204202
205pub fn machTaskForPid(pid: os.pid_t) MachError!MachTask {
206 var port: os.mach_port_name_t = undefined;
207 switch (os.getKernError(os.task_for_pid(os.mach_task_self(), pid, &port))) {
203pub fn machTaskForPid(pid: c.pid_t) MachError!MachTask {
204 var port: c.mach_port_name_t = undefined;
205 switch (c.getKernError(c.task_for_pid(c.mach_task_self(), pid, &port))) {
208206 .SUCCESS => {},
209207 .FAILURE => return error.PermissionDenied,
210208 else => |err| {