Commit 0e95fa455c1012fc5d2247600b89e2d60f146ef3 | zig

author	LemonBoy <thatlemon@gmail.com> 2020-11-04 15:55:36+01:00
committer	LemonBoy <thatlemon@gmail.com> 2020-11-05 09:38:50+01:00
log	0e95fa455c1012fc5d2247600b89e2d60f146ef3
tree	3df314e8d7983da275ea6d33bf5d58f986106dd2
parent	346a686b9d6a086d0e5f3b25bd686681eea7052b

std: Split kernel&libc definitions of stat struct

There's no guarantee for the kernel definition to be ABI compatible with
the libc one (and vice versa).
There's also no guarantee of ABI compatibility between musl/glibc.

Fun, isn't it?

20 files changed, 153 insertions(+), 159 deletions(-)

lib
- std
  - c.zig
  - c
    darwin.zig
  - os.zig
  - os
    bits
    darwin.zig
    dragonfly.zig
    freebsd.zig
    linux
    arm-eabi.zig
    arm64.zig
    i386.zig
    mips.zig
    powerpc64.zig
    riscv64.zig
    sparc64.zig
    x86_64.zig
    netbsd.zig
    openbsd.zig
    wasi.zig
    linux.zig
    linux
    sparc64.zig
    test.zig

lib/std/c.zig+6-6

...	...	@@ -128,7 +128,7 @@ pub usingnamespace switch (builtin.os.tag) {
128	128	},
129	129	else => struct {
130	130	pub extern "c" fn realpath(noalias file_name: [:0]const u8, noalias resolved_name: []u8) ?[*:0]u8;
131		pub extern "c" fn fstatat(dirfd: fd_t, path: [:0]const u8, stat_buf: Stat, flags: u32) c_int;
	131	pub extern "c" fn fstatat(dirfd: fd_t, path: [:0]const u8, stat_buf: libc_stat, flags: u32) c_int;
132	132	},
133	133	};
134	134
...	...	@@ -202,26 +202,26 @@ pub usingnamespace switch (builtin.os.tag) {
202	202	pub extern "c" fn sigaction(sig: c_int, noalias act: const Sigaction, noalias oact: ?Sigaction) c_int;
203	203	pub extern "c" fn sigprocmask(how: c_int, noalias set: ?const sigset_t, noalias oset: ?sigset_t) c_int;
204	204	pub extern "c" fn socket(domain: c_uint, sock_type: c_uint, protocol: c_uint) c_int;
205		pub extern "c" fn stat(noalias path: [:0]const u8, noalias buf: Stat) c_int;
	205	pub extern "c" fn stat(noalias path: [:0]const u8, noalias buf: libc_stat) c_int;
206	206	},
207	207	.windows => struct {
208	208	// TODO: copied the else case and removed the socket function (because its in ws2_32)
209	209	// need to verify which of these is actually supported on windows
210	210	pub extern "c" fn clock_getres(clk_id: c_int, tp: *timespec) c_int;
211	211	pub extern "c" fn clock_gettime(clk_id: c_int, tp: *timespec) c_int;
212		pub extern "c" fn fstat(fd: fd_t, buf: *Stat) c_int;
	212	pub extern "c" fn fstat(fd: fd_t, buf: *libc_stat) c_int;
213	213	pub extern "c" fn getrusage(who: c_int, usage: *rusage) c_int;
214	214	pub extern "c" fn gettimeofday(noalias tv: ?timeval, noalias tz: ?timezone) c_int;
215	215	pub extern "c" fn nanosleep(rqtp: const timespec, rmtp: ?timespec) c_int;
216	216	pub extern "c" fn sched_yield() c_int;
217	217	pub extern "c" fn sigaction(sig: c_int, noalias act: const Sigaction, noalias oact: ?Sigaction) c_int;
218	218	pub extern "c" fn sigprocmask(how: c_int, noalias set: ?const sigset_t, noalias oset: ?sigset_t) c_int;
219		pub extern "c" fn stat(noalias path: [:0]const u8, noalias buf: Stat) c_int;
	219	pub extern "c" fn stat(noalias path: [:0]const u8, noalias buf: libc_stat) c_int;
220	220	},
221	221	else => struct {
222	222	pub extern "c" fn clock_getres(clk_id: c_int, tp: *timespec) c_int;
223	223	pub extern "c" fn clock_gettime(clk_id: c_int, tp: *timespec) c_int;
224		pub extern "c" fn fstat(fd: fd_t, buf: *Stat) c_int;
	224	pub extern "c" fn fstat(fd: fd_t, buf: *libc_stat) c_int;
225	225	pub extern "c" fn getrusage(who: c_int, usage: *rusage) c_int;
226	226	pub extern "c" fn gettimeofday(noalias tv: ?timeval, noalias tz: ?timezone) c_int;
227	227	pub extern "c" fn nanosleep(rqtp: const timespec, rmtp: ?timespec) c_int;
...	...	@@ -229,7 +229,7 @@ pub usingnamespace switch (builtin.os.tag) {
229	229	pub extern "c" fn sigaction(sig: c_int, noalias act: const Sigaction, noalias oact: ?Sigaction) c_int;
230	230	pub extern "c" fn sigprocmask(how: c_int, noalias set: ?const sigset_t, noalias oset: ?sigset_t) c_int;
231	231	pub extern "c" fn socket(domain: c_uint, sock_type: c_uint, protocol: c_uint) c_int;
232		pub extern "c" fn stat(noalias path: [:0]const u8, noalias buf: Stat) c_int;
	232	pub extern "c" fn stat(noalias path: [:0]const u8, noalias buf: libc_stat) c_int;
233	233	},
234	234	};
235	235

lib/std/c/darwin.zig+4-4

...	...	@@ -30,16 +30,16 @@ pub extern "c" fn @"realpath$DARWIN_EXTSN"(noalias file_name: [*:0]const u8, noa
30	30
31	31	pub extern "c" fn __getdirentries64(fd: c_int, buf_ptr: []u8, buf_len: usize, basep: i64) isize;
32	32
33		extern "c" fn fstat(fd: fd_t, buf: *Stat) c_int;
	33	extern "c" fn fstat(fd: fd_t, buf: *libc_stat) c_int;
34	34	/// On x86_64 Darwin, fstat has to be manully linked with $INODE64 suffix to force 64bit version.
35	35	/// Note that this is fixed on aarch64 and no longer necessary.
36		extern "c" fn @"fstat$INODE64"(fd: fd_t, buf: *Stat) c_int;
	36	extern "c" fn @"fstat$INODE64"(fd: fd_t, buf: *libc_stat) c_int;
37	37	pub const _fstat = if (builtin.arch == .aarch64) fstat else @"fstat$INODE64";
38	38
39		extern "c" fn fstatat(dirfd: fd_t, path: [:0]const u8, stat_buf: Stat, flags: u32) c_int;
	39	extern "c" fn fstatat(dirfd: fd_t, path: [:0]const u8, stat_buf: libc_stat, flags: u32) c_int;
40	40	/// On x86_64 Darwin, fstatat has to be manully linked with $INODE64 suffix to force 64bit version.
41	41	/// Note that this is fixed on aarch64 and no longer necessary.
42		extern "c" fn @"fstatat$INODE64"(dirfd: fd_t, path_name: [:0]const u8, buf: Stat, flags: u32) c_int;
	42	extern "c" fn @"fstatat$INODE64"(dirfd: fd_t, path_name: [:0]const u8, buf: libc_stat, flags: u32) c_int;
43	43	pub const _fstatat = if (builtin.arch == .aarch64) fstatat else @"fstatat$INODE64";
44	44
45	45	pub extern "c" fn mach_absolute_time() u64;

lib/std/os.zig+5

...	...	@@ -3267,6 +3267,11 @@ pub fn waitpid(pid: pid_t, flags: u32) WaitPidResult {
3267	3267	}
3268	3268	}
3269	3269
	3270	pub const Stat = if (builtin.link_libc)
	3271	system.libc_stat
	3272	else
	3273	system.kernel_stat;
	3274
3270	3275	pub const FStatError = error{
3271	3276	SystemResources,
3272	3277

lib/std/os/bits/darwin.zig+4-10

...	...	@@ -72,13 +72,7 @@ pub const Flock = extern struct {
72	72	l_whence: i16,
73	73	};
74	74
75		/// Renamed to Stat to not conflict with the stat function.
76		/// atime, mtime, and ctime have functions to return `timespec`,
77		/// because although this is a POSIX API, the layout and names of
78		/// the structs are inconsistent across operating systems, and
79		/// in C, macros are used to hide the differences. Here we use
80		/// methods to accomplish this.
81		pub const Stat = extern struct {
	75	pub const libc_stat = extern struct {
82	76	dev: i32,
83	77	mode: u16,
84	78	nlink: u16,
...	...	@@ -102,21 +96,21 @@ pub const Stat = extern struct {
102	96	lspare: i32,
103	97	qspare: [2]i64,
104	98
105		pub fn atime(self: Stat) timespec {
	99	pub fn atime(self: @This()) timespec {
106	100	return timespec{
107	101	.tv_sec = self.atimesec,
108	102	.tv_nsec = self.atimensec,
109	103	};
110	104	}
111	105
112		pub fn mtime(self: Stat) timespec {
	106	pub fn mtime(self: @This()) timespec {
113	107	return timespec{
114	108	.tv_sec = self.mtimesec,
115	109	.tv_nsec = self.mtimensec,
116	110	};
117	111	}
118	112
119		pub fn ctime(self: Stat) timespec {
	113	pub fn ctime(self: @This()) timespec {
120	114	return timespec{
121	115	.tv_sec = self.ctimesec,
122	116	.tv_nsec = self.ctimensec,

lib/std/os/bits/dragonfly.zig+4-4

...	...	@@ -152,7 +152,7 @@ pub const PATH_MAX = 1024;
152	152
153	153	pub const ino_t = c_ulong;
154	154
155		pub const Stat = extern struct {
	155	pub const libc_stat = extern struct {
156	156	ino: ino_t,
157	157	nlink: c_uint,
158	158	dev: c_uint,
...	...	@@ -172,15 +172,15 @@ pub const Stat = extern struct {
172	172	lspare: i32,
173	173	qspare1: i64,
174	174	qspare2: i64,
175		pub fn atime(self: Stat) timespec {
	175	pub fn atime(self: @This()) timespec {
176	176	return self.atim;
177	177	}
178	178
179		pub fn mtime(self: Stat) timespec {
	179	pub fn mtime(self: @This()) timespec {
180	180	return self.mtim;
181	181	}
182	182
183		pub fn ctime(self: Stat) timespec {
	183	pub fn ctime(self: @This()) timespec {
184	184	return self.ctim;
185	185	}
186	186	};

lib/std/os/bits/freebsd.zig+4-10

...	...	@@ -119,13 +119,7 @@ pub const msghdr_const = extern struct {
119	119	pub const off_t = i64;
120	120	pub const ino_t = u64;
121	121
122		/// Renamed to Stat to not conflict with the stat function.
123		/// atime, mtime, and ctime have functions to return `timespec`,
124		/// because although this is a POSIX API, the layout and names of
125		/// the structs are inconsistent across operating systems, and
126		/// in C, macros are used to hide the differences. Here we use
127		/// methods to accomplish this.
128		pub const Stat = extern struct {
	122	pub const libc_stat = extern struct {
129	123	dev: u64,
130	124	ino: ino_t,
131	125	nlink: usize,
...	...	@@ -149,15 +143,15 @@ pub const Stat = extern struct {
149	143	gen: u64,
150	144	__spare: [10]u64,
151	145
152		pub fn atime(self: Stat) timespec {
	146	pub fn atime(self: @This()) timespec {
153	147	return self.atim;
154	148	}
155	149
156		pub fn mtime(self: Stat) timespec {
	150	pub fn mtime(self: @This()) timespec {
157	151	return self.mtim;
158	152	}
159	153
160		pub fn ctime(self: Stat) timespec {
	154	pub fn ctime(self: @This()) timespec {
161	155	return self.ctim;
162	156	}
163	157	};

lib/std/os/bits/linux/arm-eabi.zig+8-10

...	...	@@ -553,13 +553,8 @@ pub const ino_t = u64;
553	553	pub const dev_t = u64;
554	554	pub const blkcnt_t = i64;
555	555
556		/// Renamed to Stat to not conflict with the stat function.
557		/// atime, mtime, and ctime have functions to return `timespec`,
558		/// because although this is a POSIX API, the layout and names of
559		/// the structs are inconsistent across operating systems, and
560		/// in C, macros are used to hide the differences. Here we use
561		/// methods to accomplish this.
562		pub const Stat = extern struct {
	556	// The `stat` definition used by the Linux kernel.
	557	pub const kernel_stat = extern struct {
563	558	dev: dev_t,
564	559	__dev_padding: u32,
565	560	__ino_truncated: u32,
...	...	@@ -577,19 +572,22 @@ pub const Stat = extern struct {
577	572	ctim: timespec,
578	573	ino: ino_t,
579	574
580		pub fn atime(self: Stat) timespec {
	575	pub fn atime(self: @This()) timespec {
581	576	return self.atim;
582	577	}
583	578
584		pub fn mtime(self: Stat) timespec {
	579	pub fn mtime(self: @This()) timespec {
585	580	return self.mtim;
586	581	}
587	582
588		pub fn ctime(self: Stat) timespec {
	583	pub fn ctime(self: @This()) timespec {
589	584	return self.ctim;
590	585	}
591	586	};
592	587
	588	// The `stat64` definition used by the libc.
	589	pub const libc_stat = kernel_stat;
	590
593	591	pub const timespec = extern struct {
594	592	tv_sec: i32,
595	593	tv_nsec: i32,

lib/std/os/bits/linux/arm64.zig+8-10

...	...	@@ -424,13 +424,8 @@ pub const ino_t = usize;
424	424	pub const dev_t = usize;
425	425	pub const blkcnt_t = isize;
426	426
427		/// Renamed to Stat to not conflict with the stat function.
428		/// atime, mtime, and ctime have functions to return `timespec`,
429		/// because although this is a POSIX API, the layout and names of
430		/// the structs are inconsistent across operating systems, and
431		/// in C, macros are used to hide the differences. Here we use
432		/// methods to accomplish this.
433		pub const Stat = extern struct {
	427	// The `stat` definition used by the Linux kernel.
	428	pub const kernel_stat = extern struct {
434	429	dev: dev_t,
435	430	ino: ino_t,
436	431	mode: mode_t,
...	...	@@ -448,19 +443,22 @@ pub const Stat = extern struct {
448	443	ctim: timespec,
449	444	__unused: [2]u32,
450	445
451		pub fn atime(self: Stat) timespec {
	446	pub fn atime(self: @This()) timespec {
452	447	return self.atim;
453	448	}
454	449
455		pub fn mtime(self: Stat) timespec {
	450	pub fn mtime(self: @This()) timespec {
456	451	return self.mtim;
457	452	}
458	453
459		pub fn ctime(self: Stat) timespec {
	454	pub fn ctime(self: @This()) timespec {
460	455	return self.ctim;
461	456	}
462	457	};
463	458
	459	// The `stat64` definition used by the libc.
	460	pub const libc_stat = kernel_stat;
	461
464	462	pub const timespec = extern struct {
465	463	tv_sec: time_t,
466	464	tv_nsec: isize,

lib/std/os/bits/linux/i386.zig+8-10

...	...	@@ -546,13 +546,8 @@ pub const ino_t = u64;
546	546	pub const dev_t = u64;
547	547	pub const blkcnt_t = i64;
548	548
549		/// Renamed to Stat to not conflict with the stat function.
550		/// atime, mtime, and ctime have functions to return `timespec`,
551		/// because although this is a POSIX API, the layout and names of
552		/// the structs are inconsistent across operating systems, and
553		/// in C, macros are used to hide the differences. Here we use
554		/// methods to accomplish this.
555		pub const Stat = extern struct {
	549	// The `stat` definition used by the Linux kernel.
	550	pub const kernel_stat = extern struct {
556	551	dev: dev_t,
557	552	__dev_padding: u32,
558	553	__ino_truncated: u32,
...	...	@@ -570,19 +565,22 @@ pub const Stat = extern struct {
570	565	ctim: timespec,
571	566	ino: ino_t,
572	567
573		pub fn atime(self: Stat) timespec {
	568	pub fn atime(self: @This()) timespec {
574	569	return self.atim;
575	570	}
576	571
577		pub fn mtime(self: Stat) timespec {
	572	pub fn mtime(self: @This()) timespec {
578	573	return self.mtim;
579	574	}
580	575
581		pub fn ctime(self: Stat) timespec {
	576	pub fn ctime(self: @This()) timespec {
582	577	return self.ctim;
583	578	}
584	579	};
585	580
	581	// The `stat64` definition used by the libc.
	582	pub const libc_stat = kernel_stat;
	583
586	584	pub const timespec = extern struct {
587	585	tv_sec: i32,
588	586	tv_nsec: i32,

lib/std/os/bits/linux/mips.zig+42-9

...	...	@@ -536,41 +536,74 @@ pub const Flock = extern struct {
536	536
537	537	pub const blksize_t = i32;
538	538	pub const nlink_t = u32;
539		pub const time_t = isize;
	539	pub const time_t = i32;
540	540	pub const mode_t = u32;
541	541	pub const off_t = i64;
542	542	pub const ino_t = u64;
543		pub const dev_t = usize;
	543	pub const dev_t = u64;
544	544	pub const blkcnt_t = i64;
545	545
546		pub const Stat = extern struct {
	546	// The `stat` definition used by the Linux kernel.
	547	pub const kernel_stat = extern struct {
547	548	dev: u32,
548		__pad0: [3]u32,
	549	__pad0: [3]u32, // Reserved for st_dev expansion
549	550	ino: ino_t,
550	551	mode: mode_t,
551	552	nlink: nlink_t,
552	553	uid: uid_t,
553	554	gid: gid_t,
554		rdev: dev_t,
	555	rdev: u32,
555	556	__pad1: [3]u32,
556	557	size: off_t,
557	558	atim: timespec,
558	559	mtim: timespec,
559	560	ctim: timespec,
560	561	blksize: blksize_t,
561		__pad3: [1]u32,
	562	__pad3: u32,
562	563	blocks: blkcnt_t,
563	564	__pad4: [14]usize,
564	565
565		pub fn atime(self: Stat) timespec {
	566	pub fn atime(self: @This()) timespec {
	567	return self.atim;
	568	}
	569
	570	pub fn mtime(self: @This()) timespec {
	571	return self.mtim;
	572	}
	573
	574	pub fn ctime(self: @This()) timespec {
	575	return self.ctim;
	576	}
	577	};
	578
	579	pub const libc_stat = extern struct {
	580	dev: dev_t,
	581	__pad0: [2]u32,
	582	ino: ino_t,
	583	mode: mode_t,
	584	nlink: nlink_t,
	585	uid: uid_t,
	586	gid: gid_t,
	587	rdev: dev_t,
	588	__pad1: [2]u32,
	589	size: off_t,
	590	atim: timespec,
	591	mtim: timespec,
	592	ctim: timespec,
	593	blksize: blksize_t,
	594	__pad3: u32,
	595	blocks: blkcnt_t,
	596	__pad4: [14]u32,
	597
	598	pub fn atime(self: @This()) timespec {
566	599	return self.atim;
567	600	}
568	601
569		pub fn mtime(self: Stat) timespec {
	602	pub fn mtime(self: @This()) timespec {
570	603	return self.mtim;
571	604	}
572	605
573		pub fn ctime(self: Stat) timespec {
	606	pub fn ctime(self: @This()) timespec {
574	607	return self.ctim;
575	608	}
576	609	};

lib/std/os/bits/linux/powerpc64.zig+8-10

...	...	@@ -516,13 +516,8 @@ pub const ino_t = u64;
516	516	pub const dev_t = u64;
517	517	pub const blkcnt_t = i64;
518	518
519		/// Renamed to Stat to not conflict with the stat function.
520		/// atime, mtime, and ctime have functions to return `timespec`,
521		/// because although this is a POSIX API, the layout and names of
522		/// the structs are inconsistent across operating systems, and
523		/// in C, macros are used to hide the differences. Here we use
524		/// methods to accomplish this.
525		pub const Stat = extern struct {
	519	// The `stat` definition used by the Linux kernel.
	520	pub const kernel_stat = extern struct {
526	521	dev: dev_t,
527	522	ino: ino_t,
528	523	nlink: nlink_t,
...	...	@@ -538,19 +533,22 @@ pub const Stat = extern struct {
538	533	ctim: timespec,
539	534	__unused: [3]u64,
540	535
541		pub fn atime(self: Stat) timespec {
	536	pub fn atime(self: @This()) timespec {
542	537	return self.atim;
543	538	}
544	539
545		pub fn mtime(self: Stat) timespec {
	540	pub fn mtime(self: @This()) timespec {
546	541	return self.mtim;
547	542	}
548	543
549		pub fn ctime(self: Stat) timespec {
	544	pub fn ctime(self: @This()) timespec {
550	545	return self.ctim;
551	546	}
552	547	};
553	548
	549	// The `stat64` definition used by the libc.
	550	pub const libc_stat = kernel_stat;
	551
554	552	pub const timespec = extern struct {
555	553	tv_sec: time_t,
556	554	tv_nsec: isize,

lib/std/os/bits/linux/riscv64.zig+8-10

...	...	@@ -381,13 +381,8 @@ pub const Flock = extern struct {
381	381	__unused: [4]u8,
382	382	};
383	383
384		/// Renamed to Stat to not conflict with the stat function.
385		/// atime, mtime, and ctime have functions to return `timespec`,
386		/// because although this is a POSIX API, the layout and names of
387		/// the structs are inconsistent across operating systems, and
388		/// in C, macros are used to hide the differences. Here we use
389		/// methods to accomplish this.
390		pub const Stat = extern struct {
	384	// The `stat` definition used by the Linux kernel.
	385	pub const kernel_stat = extern struct {
391	386	dev: dev_t,
392	387	ino: ino_t,
393	388	mode: mode_t,
...	...	@@ -405,17 +400,20 @@ pub const Stat = extern struct {
405	400	ctim: timespec,
406	401	__unused: [2]u32,
407	402
408		pub fn atime(self: Stat) timespec {
	403	pub fn atime(self: @This()) timespec {
409	404	return self.atim;
410	405	}
411	406
412		pub fn mtime(self: Stat) timespec {
	407	pub fn mtime(self: @This()) timespec {
413	408	return self.mtim;
414	409	}
415	410
416		pub fn ctime(self: Stat) timespec {
	411	pub fn ctime(self: @This()) timespec {
417	412	return self.ctim;
418	413	}
419	414	};
420	415
	416	// The `stat64` definition used by the libc.
	417	pub const libc_stat = kernel_stat;
	418
421	419	pub const Elf_Symndx = u32;

lib/std/os/bits/linux/sparc64.zig+21-30

...	...	@@ -484,11 +484,7 @@ pub const off_t = i64;
484	484	pub const ino_t = u64;
485	485	pub const mode_t = u32;
486	486
487		/// atime, mtime, and ctime have functions to return `timespec`,
488		/// because although this is a POSIX API, the layout and names of
489		/// the structs are inconsistent across operating systems, and
490		/// in C, macros are used to hide the differences. Here we use
491		/// methods to accomplish this.
	487	// The `stat64` definition used by the libc.
492	488	pub const libc_stat = extern struct {
493	489	dev: u64,
494	490	ino: ino_t,
...	...	@@ -522,45 +518,40 @@ pub const libc_stat = extern struct {
522	518	}
523	519	};
524	520
	521	// The `stat64` definition used by the kernel.
525	522	pub const kernel_stat = extern struct {
526		dev: u32,
527		ino: ino_t,
528		mode: mode_t,
529		nlink: i16,
	523	dev: u64,
	524	ino: u64,
	525	nlink: u64,
530	526
	527	mode: u32,
531	528	uid: u32,
532	529	gid: u32,
533		rdev: u32,
534
535		size: off_t,
536		atim: isize,
537		mtim: isize,
538		ctim: isize,
	530	__pad0: u32,
539	531
540		blksize: off_t,
541		blocks: off_t,
	532	rdev: u64,
	533	size: i64,
	534	blksize: i64,
	535	blocks: i64,
542	536
543		__unused4: [2]isize,
	537	atim: timespec,
	538	mtim: timespec,
	539	ctim: timespec,
	540	__unused: [3]u64,
544	541
545		// Hack to make the stdlib not complain about atime
546		// and friends not being a method.
547		// TODO what should tv_nsec be filled with?
548		pub fn atime(self: kernel_stat) timespec {
549		return timespec{.tv_sec=self.atim, .tv_nsec=0};
	542	pub fn atime(self: @This()) timespec {
	543	return self.atim;
550	544	}
551	545
552		pub fn mtime(self: kernel_stat) timespec {
553		return timespec{.tv_sec=self.mtim, .tv_nsec=0};
	546	pub fn mtime(self: @This()) timespec {
	547	return self.mtim;
554	548	}
555	549
556		pub fn ctime(self: kernel_stat) timespec {
557		return timespec{.tv_sec=self.ctim, .tv_nsec=0};
	550	pub fn ctime(self: @This()) timespec {
	551	return self.ctim;
558	552	}
559	553	};
560	554
561		/// Renamed to Stat to not conflict with the stat function.
562		pub const Stat = if (std.builtin.link_libc) libc_stat else kernel_stat;
563
564	555	pub const timespec = extern struct {
565	556	tv_sec: isize,
566	557	tv_nsec: isize,

lib/std/os/bits/linux/x86_64.zig+8-10

...	...	@@ -512,13 +512,8 @@ pub const msghdr_const = extern struct {
512	512	pub const off_t = i64;
513	513	pub const ino_t = u64;
514	514
515		/// Renamed to Stat to not conflict with the stat function.
516		/// atime, mtime, and ctime have functions to return `timespec`,
517		/// because although this is a POSIX API, the layout and names of
518		/// the structs are inconsistent across operating systems, and
519		/// in C, macros are used to hide the differences. Here we use
520		/// methods to accomplish this.
521		pub const Stat = extern struct {
	515	// The `stat` definition used by the Linux kernel.
	516	pub const kernel_stat = extern struct {
522	517	dev: u64,
523	518	ino: ino_t,
524	519	nlink: usize,
...	...	@@ -537,19 +532,22 @@ pub const Stat = extern struct {
537	532	ctim: timespec,
538	533	__unused: [3]isize,
539	534
540		pub fn atime(self: Stat) timespec {
	535	pub fn atime(self: @This()) timespec {
541	536	return self.atim;
542	537	}
543	538
544		pub fn mtime(self: Stat) timespec {
	539	pub fn mtime(self: @This()) timespec {
545	540	return self.mtim;
546	541	}
547	542
548		pub fn ctime(self: Stat) timespec {
	543	pub fn ctime(self: @This()) timespec {
549	544	return self.ctim;
550	545	}
551	546	};
552	547
	548	// The `stat64` definition used by the libc.
	549	pub const libc_stat = kernel_stat;
	550
553	551	pub const timespec = extern struct {
554	552	tv_sec: isize,
555	553	tv_nsec: isize,

lib/std/os/bits/netbsd.zig+4-10

...	...	@@ -153,13 +153,7 @@ pub const msghdr_const = extern struct {
153	153	msg_flags: i32,
154	154	};
155	155
156		/// Renamed to Stat to not conflict with the stat function.
157		/// atime, mtime, and ctime have functions to return `timespec`,
158		/// because although this is a POSIX API, the layout and names of
159		/// the structs are inconsistent across operating systems, and
160		/// in C, macros are used to hide the differences. Here we use
161		/// methods to accomplish this.
162		pub const Stat = extern struct {
	156	pub const libc_stat = extern struct {
163	157	dev: dev_t,
164	158	mode: mode_t,
165	159	ino: ino_t,
...	...	@@ -178,15 +172,15 @@ pub const Stat = extern struct {
178	172	gen: u32,
179	173	__spare: [2]u32,
180	174
181		pub fn atime(self: Stat) timespec {
	175	pub fn atime(self: @This()) timespec {
182	176	return self.atim;
183	177	}
184	178
185		pub fn mtime(self: Stat) timespec {
	179	pub fn mtime(self: @This()) timespec {
186	180	return self.mtim;
187	181	}
188	182
189		pub fn ctime(self: Stat) timespec {
	183	pub fn ctime(self: @This()) timespec {
190	184	return self.ctim;
191	185	}
192	186	};

lib/std/os/bits/openbsd.zig+4-10

...	...	@@ -152,13 +152,7 @@ pub const msghdr_const = extern struct {
152	152	msg_flags: i32,
153	153	};
154	154
155		/// Renamed to Stat to not conflict with the stat function.
156		/// atime, mtime, and ctime have functions to return `timespec`,
157		/// because although this is a POSIX API, the layout and names of
158		/// the structs are inconsistent across operating systems, and
159		/// in C, macros are used to hide the differences. Here we use
160		/// methods to accomplish this.
161		pub const Stat = extern struct {
	155	pub const libc_stat = extern struct {
162	156	mode: mode_t,
163	157	dev: dev_t,
164	158	ino: ino_t,
...	...	@@ -176,15 +170,15 @@ pub const Stat = extern struct {
176	170	gen: u32,
177	171	birthtim: timespec,
178	172
179		pub fn atime(self: Stat) timespec {
	173	pub fn atime(self: @This()) timespec {
180	174	return self.atim;
181	175	}
182	176
183		pub fn mtime(self: Stat) timespec {
	177	pub fn mtime(self: @This()) timespec {
184	178	return self.mtim;
185	179	}
186	180
187		pub fn ctime(self: Stat) timespec {
	181	pub fn ctime(self: @This()) timespec {
188	182	return self.ctim;
189	183	}
190	184	};

lib/std/os/bits/wasi.zig+1-1

...	...	@@ -31,7 +31,7 @@ pub const timespec = struct {
31	31	}
32	32	};
33	33
34		pub const Stat = struct {
	34	pub const libc_stat = struct {
35	35	dev: device_t,
36	36	ino: inode_t,
37	37	mode: mode_t,

lib/std/os/linux.zig+4-4

...	...	@@ -1047,7 +1047,7 @@ pub fn accept4(fd: i32, noalias addr: ?sockaddr, noalias len: ?socklen_t, flag
1047	1047	return syscall4(.accept4, @bitCast(usize, @as(isize, fd)), @ptrToInt(addr), @ptrToInt(len), flags);
1048	1048	}
1049	1049
1050		pub fn fstat(fd: i32, stat_buf: *Stat) usize {
	1050	pub fn fstat(fd: i32, stat_buf: *kernel_stat) usize {
1051	1051	if (@hasField(SYS, "fstat64")) {
1052	1052	return syscall2(.fstat64, @bitCast(usize, @as(isize, fd)), @ptrToInt(stat_buf));
1053	1053	} else {
...	...	@@ -1055,7 +1055,7 @@ pub fn fstat(fd: i32, stat_buf: *Stat) usize {
1055	1055	}
1056	1056	}
1057	1057
1058		pub fn stat(pathname: [:0]const u8, statbuf: Stat) usize {
	1058	pub fn stat(pathname: [:0]const u8, statbuf: kernel_stat) usize {
1059	1059	if (@hasField(SYS, "stat64")) {
1060	1060	return syscall2(.stat64, @ptrToInt(pathname), @ptrToInt(statbuf));
1061	1061	} else {
...	...	@@ -1063,7 +1063,7 @@ pub fn stat(pathname: [:0]const u8, statbuf: Stat) usize {
1063	1063	}
1064	1064	}
1065	1065
1066		pub fn lstat(pathname: [:0]const u8, statbuf: Stat) usize {
	1066	pub fn lstat(pathname: [:0]const u8, statbuf: kernel_stat) usize {
1067	1067	if (@hasField(SYS, "lstat64")) {
1068	1068	return syscall2(.lstat64, @ptrToInt(pathname), @ptrToInt(statbuf));
1069	1069	} else {
...	...	@@ -1071,7 +1071,7 @@ pub fn lstat(pathname: [:0]const u8, statbuf: Stat) usize {
1071	1071	}
1072	1072	}
1073	1073
1074		pub fn fstatat(dirfd: i32, path: [:0]const u8, stat_buf: Stat, flags: u32) usize {
	1074	pub fn fstatat(dirfd: i32, path: [:0]const u8, stat_buf: kernel_stat, flags: u32) usize {
1075	1075	if (@hasField(SYS, "fstatat64")) {
1076	1076	return syscall4(.fstatat64, @bitCast(usize, @as(isize, dirfd)), @ptrToInt(path), @ptrToInt(stat_buf), flags);
1077	1077	} else {

lib/std/os/linux/sparc64.zig+1

...	...	@@ -12,6 +12,7 @@ pub fn syscall_pipe(fd: *[2]i32) usize {
12	12	\\1:
13	13	\\ st %%o0, [%%g3+0]
14	14	\\ st %%o1, [%%g3+4]
	15	\\ clr %%o0
15	16	\\2:
16	17	: [ret] "={o0}" (-> usize)
17	18	: [number] "{g1}" (@enumToInt(SYS.pipe)),

lib/std/os/linux/test.zig+1-1

...	...	@@ -67,7 +67,7 @@ test "statx" {
67	67	else => unreachable,
68	68	}
69	69
70		var stat_buf: linux.Stat = undefined;
	70	var stat_buf: linux.kernel_stat = undefined;
71	71	switch (linux.getErrno(linux.fstatat(file.handle, "", &stat_buf, linux.AT_EMPTY_PATH))) {
72	72	0 => {},
73	73	else => unreachable,