authorgravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2020-05-29 18:41:40-04:00
committergravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2020-05-29 18:41:40-04:00
logf107d654e073a7cc0c2e920ee6fac9b2b34dba0c
tree364c995c839ac3521522c2f9ca83368a162d8c66
parent4c8b937fb016a54b09d7447ca634b7cf1af78fce
parent89a97a7a278e69a440fd35665d4f1af864d023d9

Merge branch 'gereeter-reduced-path-max'

closes #4837

5 files changed, 98 insertions(+), 37 deletions(-)

lib/std/debug.zig+30-19
......@@ -670,10 +670,12 @@ pub fn openSelfDebugInfo(allocator: *mem.Allocator) anyerror!DebugInfo {
670670 }
671671}
672672
673/// This takes ownership of coff_file: users of this function should not close
674/// it themselves, even on error.
673675/// TODO resources https://github.com/ziglang/zig/issues/4353
674fn openCoffDebugInfo(allocator: *mem.Allocator, coff_file_path: [:0]const u16) !ModuleDebugInfo {
676/// TODO it's weird to take ownership even on error, rework this code.
677fn readCoffDebugInfo(allocator: *mem.Allocator, coff_file: File) !ModuleDebugInfo {
675678 nosuspend {
676 const coff_file = try std.fs.openFileAbsoluteW(coff_file_path, .{ .intended_io_mode = .blocking });
677679 errdefer coff_file.close();
678680
679681 const coff_obj = try allocator.create(coff.Coff);
......@@ -851,10 +853,13 @@ fn chopSlice(ptr: []const u8, offset: u64, size: u64) ![]const u8 {
851853 return ptr[start..end];
852854}
853855
856/// This takes ownership of elf_file: users of this function should not close
857/// it themselves, even on error.
854858/// TODO resources https://github.com/ziglang/zig/issues/4353
855pub fn openElfDebugInfo(allocator: *mem.Allocator, elf_file_path: []const u8) !ModuleDebugInfo {
859/// TODO it's weird to take ownership even on error, rework this code.
860pub fn readElfDebugInfo(allocator: *mem.Allocator, elf_file: File) !ModuleDebugInfo {
856861 nosuspend {
857 const mapped_mem = try mapWholeFile(elf_file_path);
862 const mapped_mem = try mapWholeFile(elf_file);
858863 const hdr = @ptrCast(*const elf.Ehdr, &mapped_mem[0]);
859864 if (!mem.eql(u8, hdr.e_ident[0..4], "\x7fELF")) return error.InvalidElfMagic;
860865 if (hdr.e_ident[elf.EI_VERSION] != 1) return error.InvalidElfVersion;
......@@ -921,8 +926,11 @@ pub fn openElfDebugInfo(allocator: *mem.Allocator, elf_file_path: []const u8) !M
921926}
922927
923928/// TODO resources https://github.com/ziglang/zig/issues/4353
924fn openMachODebugInfo(allocator: *mem.Allocator, macho_file_path: []const u8) !ModuleDebugInfo {
925 const mapped_mem = try mapWholeFile(macho_file_path);
929/// This takes ownership of coff_file: users of this function should not close
930/// it themselves, even on error.
931/// TODO it's weird to take ownership even on error, rework this code.
932fn readMachODebugInfo(allocator: *mem.Allocator, macho_file: File) !ModuleDebugInfo {
933 const mapped_mem = try mapWholeFile(macho_file);
926934
927935 const hdr = @ptrCast(
928936 *const macho.mach_header_64,
......@@ -1055,9 +1063,11 @@ const MachoSymbol = struct {
10551063 }
10561064};
10571065
1058fn mapWholeFile(path: []const u8) ![]align(mem.page_size) const u8 {
1066/// `file` is expected to have been opened with .intended_io_mode == .blocking.
1067/// Takes ownership of file, even on error.
1068/// TODO it's weird to take ownership even on error, rework this code.
1069fn mapWholeFile(file: File) ![]align(mem.page_size) const u8 {
10591070 nosuspend {
1060 const file = try fs.cwd().openFile(path, .{ .intended_io_mode = .blocking });
10611071 defer file.close();
10621072
10631073 const file_len = try math.cast(usize, try file.getEndPos());
......@@ -1140,10 +1150,11 @@ pub const DebugInfo = struct {
11401150 errdefer self.allocator.destroy(obj_di);
11411151
11421152 const macho_path = mem.spanZ(std.c._dyld_get_image_name(i));
1143 obj_di.* = openMachODebugInfo(self.allocator, macho_path) catch |err| switch (err) {
1153 const macho_file = fs.cwd().openFile(macho_path, .{ .intended_io_mode = .blocking }) catch |err| switch (err) {
11441154 error.FileNotFound => return error.MissingDebugInfo,
11451155 else => return err,
11461156 };
1157 obj_di.* = try readMachODebugInfo(self.allocator, macho_file);
11471158 obj_di.base_address = base_address;
11481159
11491160 try self.address_map.putNoClobber(base_address, obj_di);
......@@ -1221,10 +1232,11 @@ pub const DebugInfo = struct {
12211232 const obj_di = try self.allocator.create(ModuleDebugInfo);
12221233 errdefer self.allocator.destroy(obj_di);
12231234
1224 obj_di.* = openCoffDebugInfo(self.allocator, name_buffer[0 .. len + 4 :0]) catch |err| switch (err) {
1235 const coff_file = fs.openFileAbsoluteW(name_buffer[0 .. len + 4 :0], .{}) catch |err| switch (err) {
12251236 error.FileNotFound => return error.MissingDebugInfo,
12261237 else => return err,
12271238 };
1239 obj_di.* = try readCoffDebugInfo(self.allocator, coff_file);
12281240 obj_di.base_address = seg_start;
12291241
12301242 try self.address_map.putNoClobber(seg_start, obj_di);
......@@ -1280,20 +1292,18 @@ pub const DebugInfo = struct {
12801292 return obj_di;
12811293 }
12821294
1283 const elf_path = if (ctx.name.len > 0)
1284 ctx.name
1285 else blk: {
1286 var buf: [fs.MAX_PATH_BYTES]u8 = undefined;
1287 break :blk try fs.selfExePath(&buf);
1288 };
1289
12901295 const obj_di = try self.allocator.create(ModuleDebugInfo);
12911296 errdefer self.allocator.destroy(obj_di);
12921297
1293 obj_di.* = openElfDebugInfo(self.allocator, elf_path) catch |err| switch (err) {
1298 const elf_file = (if (ctx.name.len > 0)
1299 fs.cwd().openFile(ctx.name, .{ .intended_io_mode = .blocking })
1300 else
1301 fs.openSelfExe(.{ .intended_io_mode = .blocking })) catch |err| switch (err) {
12941302 error.FileNotFound => return error.MissingDebugInfo,
12951303 else => return err,
12961304 };
1305
1306 obj_di.* = try readElfDebugInfo(self.allocator, elf_file);
12971307 obj_di.base_address = ctx.base_address;
12981308
12991309 try self.address_map.putNoClobber(ctx.base_address, obj_di);
......@@ -1329,7 +1339,8 @@ pub const ModuleDebugInfo = switch (builtin.os.tag) {
13291339 }
13301340
13311341 fn loadOFile(self: *@This(), o_file_path: []const u8) !DW.DwarfInfo {
1332 const mapped_mem = try mapWholeFile(o_file_path);
1342 const o_file = try fs.cwd().openFile(o_file_path, .{ .intended_io_mode = .blocking });
1343 const mapped_mem = try mapWholeFile(o_file);
13331344
13341345 const hdr = @ptrCast(
13351346 *const macho.mach_header_64,
lib/std/fs.zig+42-14
......@@ -33,8 +33,11 @@ pub const GetAppDataDirError = @import("fs/get_app_data_dir.zig").GetAppDataDirE
3333
3434pub const Watch = @import("fs/watch.zig").Watch;
3535
36/// This represents the maximum size of a UTF-8 encoded file path.
37/// All file system operations which return a path are guaranteed to
36/// This represents the maximum size of a UTF-8 encoded file path that the
37/// operating system will accept. Paths, including those returned from file
38/// system operations, may be longer than this length, but such paths cannot
39/// be successfully passed back in other file system operations. However,
40/// all path components returned by file system operations are assumed to
3841/// fit into a UTF-8 encoded array of this length.
3942/// The byte count includes room for a null sentinel byte.
4043pub const MAX_PATH_BYTES = switch (builtin.os.tag) {
......@@ -1194,7 +1197,7 @@ pub const Dir = struct {
11941197 /// Read value of a symbolic link.
11951198 /// The return value is a slice of `buffer`, from index `0`.
11961199 /// Asserts that the path parameter has no null bytes.
1197 pub fn readLink(self: Dir, sub_path: []const u8, buffer: *[MAX_PATH_BYTES]u8) ![]u8 {
1200 pub fn readLink(self: Dir, sub_path: []const u8, buffer: []u8) ![]u8 {
11981201 const sub_path_c = try os.toPosixPath(sub_path);
11991202 return self.readLinkZ(&sub_path_c, buffer);
12001203 }
......@@ -1202,7 +1205,7 @@ pub const Dir = struct {
12021205 pub const readLinkC = @compileError("deprecated: renamed to readLinkZ");
12031206
12041207 /// Same as `readLink`, except the `pathname` parameter is null-terminated.
1205 pub fn readLinkZ(self: Dir, sub_path_c: [*:0]const u8, buffer: *[MAX_PATH_BYTES]u8) ![]u8 {
1208 pub fn readLinkZ(self: Dir, sub_path_c: [*:0]const u8, buffer: []u8) ![]u8 {
12061209 return os.readlinkatZ(self.fd, sub_path_c, buffer);
12071210 }
12081211
......@@ -1320,6 +1323,9 @@ pub const Dir = struct {
13201323 var cleanup_dir = true;
13211324 defer if (cleanup_dir) dir.close();
13221325
1326 // Valid use of MAX_PATH_BYTES because dir_name_buf will only
1327 // ever store a single path component that was returned from the
1328 // filesystem.
13231329 var dir_name_buf: [MAX_PATH_BYTES]u8 = undefined;
13241330 var dir_name: []const u8 = sub_path;
13251331
......@@ -1772,19 +1778,21 @@ pub fn walkPath(allocator: *Allocator, dir_path: []const u8) !Walker {
17721778
17731779pub const OpenSelfExeError = os.OpenError || os.windows.CreateFileError || SelfExePathError || os.FlockError;
17741780
1775pub fn openSelfExe() OpenSelfExeError!File {
1781pub fn openSelfExe(flags: File.OpenFlags) OpenSelfExeError!File {
17761782 if (builtin.os.tag == .linux) {
1777 return openFileAbsoluteZ("/proc/self/exe", .{});
1783 return openFileAbsoluteZ("/proc/self/exe", flags);
17781784 }
17791785 if (builtin.os.tag == .windows) {
17801786 const wide_slice = selfExePathW();
17811787 const prefixed_path_w = try os.windows.wToPrefixedFileW(wide_slice);
1782 return cwd().openFileW(prefixed_path_w.span(), .{});
1788 return cwd().openFileW(prefixed_path_w.span(), flags);
17831789 }
1790 // Use of MAX_PATH_BYTES here is valid as the resulting path is immediately
1791 // opened with no modification.
17841792 var buf: [MAX_PATH_BYTES]u8 = undefined;
17851793 const self_exe_path = try selfExePath(&buf);
17861794 buf[self_exe_path.len] = 0;
1787 return openFileAbsoluteZ(buf[0..self_exe_path.len :0].ptr, .{});
1795 return openFileAbsoluteZ(buf[0..self_exe_path.len :0].ptr, flags);
17881796}
17891797
17901798pub const SelfExePathError = os.ReadLinkError || os.SysCtlError;
......@@ -1792,6 +1800,13 @@ pub const SelfExePathError = os.ReadLinkError || os.SysCtlError;
17921800/// `selfExePath` except allocates the result on the heap.
17931801/// Caller owns returned memory.
17941802pub fn selfExePathAlloc(allocator: *Allocator) ![]u8 {
1803 // Use of MAX_PATH_BYTES here is justified as, at least on one tested Linux
1804 // system, readlink will completely fail to return a result larger than
1805 // PATH_MAX even if given a sufficiently large buffer. This makes it
1806 // fundamentally impossible to get the selfExePath of a program running in
1807 // a very deeply nested directory chain in this way.
1808 // TODO(#4812): Investigate other systems and whether it is possible to get
1809 // this path by trying larger and larger buffers until one succeeds.
17951810 var buf: [MAX_PATH_BYTES]u8 = undefined;
17961811 return mem.dupe(allocator, u8, try selfExePath(&buf));
17971812}
......@@ -1806,10 +1821,10 @@ pub fn selfExePathAlloc(allocator: *Allocator) ![]u8 {
18061821/// On Linux, depends on procfs being mounted. If the currently executing binary has
18071822/// been deleted, the file path looks something like `/a/b/c/exe (deleted)`.
18081823/// TODO make the return type of this a null terminated pointer
1809pub fn selfExePath(out_buffer: *[MAX_PATH_BYTES]u8) SelfExePathError![]u8 {
1824pub fn selfExePath(out_buffer: []u8) SelfExePathError![]u8 {
18101825 if (is_darwin) {
1811 var u32_len: u32 = out_buffer.len;
1812 const rc = std.c._NSGetExecutablePath(out_buffer, &u32_len);
1826 var u32_len: u32 = @intCast(u32, math.min(out_buffer.len, math.maxInt(u32)));
1827 const rc = std.c._NSGetExecutablePath(out_buffer.ptr, &u32_len);
18131828 if (rc != 0) return error.NameTooLong;
18141829 return mem.spanZ(@ptrCast([*:0]u8, out_buffer));
18151830 }
......@@ -1818,14 +1833,14 @@ pub fn selfExePath(out_buffer: *[MAX_PATH_BYTES]u8) SelfExePathError![]u8 {
18181833 .freebsd, .dragonfly => {
18191834 var mib = [4]c_int{ os.CTL_KERN, os.KERN_PROC, os.KERN_PROC_PATHNAME, -1 };
18201835 var out_len: usize = out_buffer.len;
1821 try os.sysctl(&mib, out_buffer, &out_len, null, 0);
1836 try os.sysctl(&mib, out_buffer.ptr, &out_len, null, 0);
18221837 // TODO could this slice from 0 to out_len instead?
18231838 return mem.spanZ(@ptrCast([*:0]u8, out_buffer));
18241839 },
18251840 .netbsd => {
18261841 var mib = [4]c_int{ os.CTL_KERN, os.KERN_PROC_ARGS, -1, os.KERN_PROC_PATHNAME };
18271842 var out_len: usize = out_buffer.len;
1828 try os.sysctl(&mib, out_buffer, &out_len, null, 0);
1843 try os.sysctl(&mib, out_buffer.ptr, &out_len, null, 0);
18291844 // TODO could this slice from 0 to out_len instead?
18301845 return mem.spanZ(@ptrCast([*:0]u8, out_buffer));
18311846 },
......@@ -1848,13 +1863,20 @@ pub fn selfExePathW() [:0]const u16 {
18481863/// `selfExeDirPath` except allocates the result on the heap.
18491864/// Caller owns returned memory.
18501865pub fn selfExeDirPathAlloc(allocator: *Allocator) ![]u8 {
1866 // Use of MAX_PATH_BYTES here is justified as, at least on one tested Linux
1867 // system, readlink will completely fail to return a result larger than
1868 // PATH_MAX even if given a sufficiently large buffer. This makes it
1869 // fundamentally impossible to get the selfExeDirPath of a program running
1870 // in a very deeply nested directory chain in this way.
1871 // TODO(#4812): Investigate other systems and whether it is possible to get
1872 // this path by trying larger and larger buffers until one succeeds.
18511873 var buf: [MAX_PATH_BYTES]u8 = undefined;
18521874 return mem.dupe(allocator, u8, try selfExeDirPath(&buf));
18531875}
18541876
18551877/// Get the directory path that contains the current executable.
18561878/// Returned value is a slice of out_buffer.
1857pub fn selfExeDirPath(out_buffer: *[MAX_PATH_BYTES]u8) SelfExePathError![]const u8 {
1879pub fn selfExeDirPath(out_buffer: []u8) SelfExePathError![]const u8 {
18581880 const self_exe_path = try selfExePath(out_buffer);
18591881 // Assume that the OS APIs return absolute paths, and therefore dirname
18601882 // will not return null.
......@@ -1864,6 +1886,12 @@ pub fn selfExeDirPath(out_buffer: *[MAX_PATH_BYTES]u8) SelfExePathError![]const
18641886/// `realpath`, except caller must free the returned memory.
18651887/// TODO integrate with `Dir`
18661888pub fn realpathAlloc(allocator: *Allocator, pathname: []const u8) ![]u8 {
1889 // Use of MAX_PATH_BYTES here is valid as the realpath function does not
1890 // have a variant that takes an arbitrary-size buffer.
1891 // TODO(#4812): Consider reimplementing realpath or using the POSIX.1-2008
1892 // NULL out parameter (GNU's canonicalize_file_name) to handle overelong
1893 // paths. musl supports passing NULL but restricts the output to PATH_MAX
1894 // anyway.
18671895 var buf: [MAX_PATH_BYTES]u8 = undefined;
18681896 return mem.dupe(allocator, u8, try os.realpath(pathname, &buf));
18691897}
lib/std/fs/test.zig+1-1
......@@ -6,7 +6,7 @@ const File = std.fs.File;
66test "openSelfExe" {
77 if (builtin.os.tag == .wasi) return error.SkipZigTest;
88
9 const self_exe_file = try std.fs.openSelfExe();
9 const self_exe_file = try std.fs.openSelfExe(.{});
1010 self_exe_file.close();
1111}
1212
lib/std/os.zig+2
......@@ -1236,6 +1236,8 @@ pub fn execvpeZ_expandArg0(
12361236 if (mem.indexOfScalar(u8, file_slice, '/') != null) return execveZ(file, child_argv, envp);
12371237
12381238 const PATH = getenvZ("PATH") orelse "/usr/local/bin:/bin/:/usr/bin";
1239 // Use of MAX_PATH_BYTES here is valid as the path_buf will be passed
1240 // directly to the operating system in execveZ.
12391241 var path_buf: [MAX_PATH_BYTES]u8 = undefined;
12401242 var it = mem.tokenize(PATH, ":");
12411243 var seen_eacces = false;
lib/std/process.zig+23-3
......@@ -15,14 +15,34 @@ pub const changeCurDir = os.chdir;
1515pub const changeCurDirC = os.chdirC;
1616
1717/// The result is a slice of `out_buffer`, from index `0`.
18pub fn getCwd(out_buffer: *[fs.MAX_PATH_BYTES]u8) ![]u8 {
18pub fn getCwd(out_buffer: []u8) ![]u8 {
1919 return os.getcwd(out_buffer);
2020}
2121
2222/// Caller must free the returned memory.
2323pub fn getCwdAlloc(allocator: *Allocator) ![]u8 {
24 var buf: [fs.MAX_PATH_BYTES]u8 = undefined;
25 return mem.dupe(allocator, u8, try os.getcwd(&buf));
24 // The use of MAX_PATH_BYTES here is just a heuristic: most paths will fit
25 // in stack_buf, avoiding an extra allocation in the common case.
26 var stack_buf: [fs.MAX_PATH_BYTES]u8 = undefined;
27 var heap_buf: ?[]u8 = null;
28 defer if (heap_buf) |buf| allocator.free(buf);
29
30 var current_buf: []u8 = &stack_buf;
31 while (true) {
32 if (os.getcwd(current_buf)) |slice| {
33 return mem.dupe(allocator, u8, slice);
34 } else |err| switch (err) {
35 error.NameTooLong => {
36 // The path is too long to fit in stack_buf. Allocate geometrically
37 // increasing buffers until we find one that works
38 const new_capacity = current_buf.len * 2;
39 if (heap_buf) |buf| allocator.free(buf);
40 current_buf = try allocator.alloc(u8, new_capacity);
41 heap_buf = current_buf;
42 },
43 else => |e| return e,
44 }
45 }
2646}
2747
2848test "getCwdAlloc" {