diff --git a/lib/std/os/linux.zig b/lib/std/os/linux.zig
index 502b2defc2d8..f5c5f09fa433 100644
--- a/lib/std/os/linux.zig
+++ b/lib/std/os/linux.zig
@@ -32,21 +32,27 @@ test {
 }
 
 const arch_bits = switch (native_arch) {
-    .x86 => @import("linux/x86.zig"),
-    .x86_64 => @import("linux/x86_64.zig"),
     .aarch64, .aarch64_be => @import("linux/aarch64.zig"),
     .arm, .armeb, .thumb, .thumbeb => @import("linux/arm.zig"),
     .hexagon => @import("linux/hexagon.zig"),
-    .riscv32 => @import("linux/riscv32.zig"),
-    .riscv64 => @import("linux/riscv64.zig"),
-    .sparc64 => @import("linux/sparc64.zig"),
     .loongarch64 => @import("linux/loongarch64.zig"),
     .m68k => @import("linux/m68k.zig"),
     .mips, .mipsel => @import("linux/mips.zig"),
-    .mips64, .mips64el => @import("linux/mips64.zig"),
+    .mips64, .mips64el => switch (builtin.abi) {
+        .gnuabin32, .muslabin32 => @import("linux/mipsn32.zig"),
+        else => @import("linux/mips64.zig"),
+    },
     .powerpc, .powerpcle => @import("linux/powerpc.zig"),
     .powerpc64, .powerpc64le => @import("linux/powerpc64.zig"),
+    .riscv32 => @import("linux/riscv32.zig"),
+    .riscv64 => @import("linux/riscv64.zig"),
     .s390x => @import("linux/s390x.zig"),
+    .sparc64 => @import("linux/sparc64.zig"),
+    .x86 => @import("linux/x86.zig"),
+    .x86_64 => switch (builtin.abi) {
+        .gnux32, .muslx32 => @import("linux/x32.zig"),
+        else => @import("linux/x86_64.zig"),
+    },
     else => struct {},
 };
 
@@ -88,9 +94,6 @@ pub fn clone(
 }
 
 pub const ARCH = arch_bits.ARCH;
-pub const Elf_Symndx = arch_bits.Elf_Symndx;
-pub const F = arch_bits.F;
-pub const Flock = arch_bits.Flock;
 pub const HWCAP = arch_bits.HWCAP;
 pub const SC = arch_bits.SC;
 pub const Stat = arch_bits.Stat;
@@ -103,8 +106,6 @@ pub const mode_t = arch_bits.mode_t;
 pub const nlink_t = arch_bits.nlink_t;
 pub const off_t = arch_bits.off_t;
 pub const time_t = arch_bits.time_t;
-pub const timeval = arch_bits.timeval;
-pub const timezone = arch_bits.timezone;
 pub const user_desc = arch_bits.user_desc;
 
 pub const tls = @import("linux/tls.zig");
@@ -113,10 +114,10 @@ pub const IOCTL = @import("linux/ioctl.zig");
 pub const SECCOMP = @import("linux/seccomp.zig");
 
 pub const syscalls = @import("linux/syscalls.zig");
-pub const SYS = switch (@import("builtin").cpu.arch) {
+pub const SYS = switch (native_arch) {
     .arc => syscalls.Arc,
-    .arm, .armeb, .thumb, .thumbeb => syscalls.Arm,
     .aarch64, .aarch64_be => syscalls.Arm64,
+    .arm, .armeb, .thumb, .thumbeb => syscalls.Arm,
     .csky => syscalls.CSky,
     .hexagon => syscalls.Hexagon,
     .loongarch64 => syscalls.LoongArch64,
@@ -126,20 +127,20 @@ pub const SYS = switch (@import("builtin").cpu.arch) {
         .gnuabin32, .muslabin32 => syscalls.MipsN32,
         else => syscalls.MipsN64,
     },
+    .or1k => syscalls.OpenRisc,
+    .powerpc, .powerpcle => syscalls.PowerPC,
+    .powerpc64, .powerpc64le => syscalls.PowerPC64,
     .riscv32 => syscalls.RiscV32,
     .riscv64 => syscalls.RiscV64,
     .s390x => syscalls.S390x,
     .sparc => syscalls.Sparc,
     .sparc64 => syscalls.Sparc64,
-    .powerpc, .powerpcle => syscalls.PowerPC,
-    .powerpc64, .powerpc64le => syscalls.PowerPC64,
     .x86 => syscalls.X86,
     .x86_64 => switch (builtin.abi) {
         .gnux32, .muslx32 => syscalls.X32,
         else => syscalls.X64,
     },
     .xtensa => syscalls.Xtensa,
-    .or1k => syscalls.OpenRisc,
     else => @compileError("The Zig Standard Library is missing syscall definitions for the target CPU architecture"),
 };
 
@@ -1599,6 +1600,70 @@ pub fn waitid(id_type: P, id: i32, infop: *siginfo_t, flags: u32) usize {
     return syscall5(.waitid, @intFromEnum(id_type), @as(usize, @bitCast(@as(isize, id))), @intFromPtr(infop), flags, 0);
 }
 
+pub const F = struct {
+    pub const DUPFD = 0;
+    pub const GETFD = 1;
+    pub const SETFD = 2;
+    pub const GETFL = 3;
+    pub const SETFL = 4;
+
+    pub const GETLK = GET_SET_LK.GETLK;
+    pub const SETLK = GET_SET_LK.SETLK;
+    pub const SETLKW = GET_SET_LK.SETLKW;
+
+    const GET_SET_LK = if (@sizeOf(usize) == 64) extern struct {
+        pub const GETLK = if (is_mips) 14 else if (is_sparc) 7 else 5;
+        pub const SETLK = if (is_mips) 6 else if (is_sparc) 8 else 6;
+        pub const SETLKW = if (is_mips) 7 else if (is_sparc) 9 else 7;
+    } else extern struct {
+        // Ensure that 32-bit code uses the large-file variants (GETLK64, etc).
+
+        pub const GETLK = if (is_mips) 33 else 12;
+        pub const SETLK = if (is_mips) 34 else 13;
+        pub const SETLKW = if (is_mips) 35 else 14;
+    };
+
+    pub const SETOWN = if (is_mips) 24 else if (is_sparc) 6 else 8;
+    pub const GETOWN = if (is_mips) 23 else if (is_sparc) 5 else 9;
+
+    pub const SETSIG = 10;
+    pub const GETSIG = 11;
+
+    pub const SETOWN_EX = 15;
+    pub const GETOWN_EX = 16;
+
+    pub const GETOWNER_UIDS = 17;
+
+    pub const OFD_GETLK = 36;
+    pub const OFD_SETLK = 37;
+    pub const OFD_SETLKW = 38;
+
+    pub const RDLCK = if (is_sparc) 1 else 0;
+    pub const WRLCK = if (is_sparc) 2 else 1;
+    pub const UNLCK = if (is_sparc) 3 else 2;
+};
+
+pub const F_OWNER = enum(i32) {
+    TID = 0,
+    PID = 1,
+    PGRP = 2,
+    _,
+};
+
+pub const f_owner_ex = extern struct {
+    type: F_OWNER,
+    pid: pid_t,
+};
+
+pub const Flock = extern struct {
+    type: i16,
+    whence: i16,
+    start: off_t,
+    len: off_t,
+    pid: pid_t,
+    _unused: if (is_sparc) i16 else void,
+};
+
 pub fn fcntl(fd: fd_t, cmd: i32, arg: usize) usize {
     if (@hasField(SYS, "fcntl64")) {
         return syscall3(.fcntl64, @as(usize, @bitCast(@as(isize, fd))), @as(usize, @bitCast(@as(isize, cmd))), arg);
@@ -1611,6 +1676,8 @@ pub fn flock(fd: fd_t, operation: i32) usize {
     return syscall2(.flock, @as(usize, @bitCast(@as(isize, fd))), @as(usize, @bitCast(@as(isize, operation))));
 }
 
+pub const Elf_Symndx = if (native_arch == .s390x) u64 else u32;
+
 // We must follow the C calling convention when we call into the VDSO
 const VdsoClockGettime = *align(1) const fn (clockid_t, *timespec) callconv(.c) usize;
 var vdso_clock_gettime: ?VdsoClockGettime = &init_vdso_clock_gettime;
@@ -8360,6 +8427,16 @@ pub const POSIX_FADV = switch (native_arch) {
     },
 };
 
+pub const timeval = extern struct {
+    tv_sec: isize,
+    tv_usec: i64,
+};
+
+pub const timezone = extern struct {
+    minuteswest: i32,
+    dsttime: i32,
+};
+
 /// The timespec struct used by the kernel.
 pub const kernel_timespec = extern struct {
     sec: i64,
diff --git a/lib/std/os/linux/aarch64.zig b/lib/std/os/linux/aarch64.zig
index 4888a9eda3a2..4977593ef5a9 100644
--- a/lib/std/os/linux/aarch64.zig
+++ b/lib/std/os/linux/aarch64.zig
@@ -1,46 +1,34 @@
 const builtin = @import("builtin");
 const std = @import("../../std.zig");
-const maxInt = std.math.maxInt;
-const linux = std.os.linux;
-const SYS = linux.SYS;
-const socklen_t = linux.socklen_t;
-const sockaddr = linux.sockaddr;
-const iovec = std.posix.iovec;
-const iovec_const = std.posix.iovec_const;
-const uid_t = linux.uid_t;
-const gid_t = linux.gid_t;
-const pid_t = linux.pid_t;
-const stack_t = linux.stack_t;
-const sigset_t = linux.sigset_t;
-const timespec = std.os.linux.timespec;
-
-pub fn syscall0(number: SYS) usize {
+const SYS = std.os.linux.SYS;
+
+pub fn syscall0(number: SYS) u64 {
     return asm volatile ("svc #0"
-        : [ret] "={x0}" (-> usize),
+        : [ret] "={x0}" (-> u64),
         : [number] "{x8}" (@intFromEnum(number)),
         : .{ .memory = true });
 }
 
-pub fn syscall1(number: SYS, arg1: usize) usize {
+pub fn syscall1(number: SYS, arg1: u64) u64 {
     return asm volatile ("svc #0"
-        : [ret] "={x0}" (-> usize),
+        : [ret] "={x0}" (-> u64),
         : [number] "{x8}" (@intFromEnum(number)),
           [arg1] "{x0}" (arg1),
         : .{ .memory = true });
 }
 
-pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
+pub fn syscall2(number: SYS, arg1: u64, arg2: u64) u64 {
     return asm volatile ("svc #0"
-        : [ret] "={x0}" (-> usize),
+        : [ret] "={x0}" (-> u64),
         : [number] "{x8}" (@intFromEnum(number)),
           [arg1] "{x0}" (arg1),
           [arg2] "{x1}" (arg2),
         : .{ .memory = true });
 }
 
-pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
+pub fn syscall3(number: SYS, arg1: u64, arg2: u64, arg3: u64) u64 {
     return asm volatile ("svc #0"
-        : [ret] "={x0}" (-> usize),
+        : [ret] "={x0}" (-> u64),
         : [number] "{x8}" (@intFromEnum(number)),
           [arg1] "{x0}" (arg1),
           [arg2] "{x1}" (arg2),
@@ -48,9 +36,9 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
         : .{ .memory = true });
 }
 
-pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize {
+pub fn syscall4(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64) u64 {
     return asm volatile ("svc #0"
-        : [ret] "={x0}" (-> usize),
+        : [ret] "={x0}" (-> u64),
         : [number] "{x8}" (@intFromEnum(number)),
           [arg1] "{x0}" (arg1),
           [arg2] "{x1}" (arg2),
@@ -59,9 +47,9 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)
         : .{ .memory = true });
 }
 
-pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize {
+pub fn syscall5(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64, arg5: u64) u64 {
     return asm volatile ("svc #0"
-        : [ret] "={x0}" (-> usize),
+        : [ret] "={x0}" (-> u64),
         : [number] "{x8}" (@intFromEnum(number)),
           [arg1] "{x0}" (arg1),
           [arg2] "{x1}" (arg2),
@@ -73,15 +61,15 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
 
 pub fn syscall6(
     number: SYS,
-    arg1: usize,
-    arg2: usize,
-    arg3: usize,
-    arg4: usize,
-    arg5: usize,
-    arg6: usize,
-) usize {
+    arg1: u64,
+    arg2: u64,
+    arg3: u64,
+    arg4: u64,
+    arg5: u64,
+    arg6: u64,
+) u64 {
     return asm volatile ("svc #0"
-        : [ret] "={x0}" (-> usize),
+        : [ret] "={x0}" (-> u64),
         : [number] "{x8}" (@intFromEnum(number)),
           [arg1] "{x0}" (arg1),
           [arg2] "{x1}" (arg2),
@@ -92,7 +80,7 @@ pub fn syscall6(
         : .{ .memory = true });
 }
 
-pub fn clone() callconv(.naked) usize {
+pub fn clone() callconv(.naked) u64 {
     // __clone(func, stack, flags, arg, ptid, tls, ctid)
     //         x0,   x1,    w2,    x3,  x4,   x5,  x6
     //
@@ -135,7 +123,7 @@ pub fn clone() callconv(.naked) usize {
 pub const restore = restore_rt;
 
 pub fn restore_rt() callconv(.naked) noreturn {
-    switch (@import("builtin").zig_backend) {
+    switch (builtin.zig_backend) {
         .stage2_c => asm volatile (
             \\ mov x8, %[number]
             \\ svc #0
@@ -150,54 +138,19 @@ pub fn restore_rt() callconv(.naked) noreturn {
     }
 }
 
-pub const F = struct {
-    pub const DUPFD = 0;
-    pub const GETFD = 1;
-    pub const SETFD = 2;
-    pub const GETFL = 3;
-    pub const SETFL = 4;
-
-    pub const SETOWN = 8;
-    pub const GETOWN = 9;
-    pub const SETSIG = 10;
-    pub const GETSIG = 11;
-
-    pub const GETLK = 5;
-    pub const SETLK = 6;
-    pub const SETLKW = 7;
-
-    pub const RDLCK = 0;
-    pub const WRLCK = 1;
-    pub const UNLCK = 2;
-
-    pub const SETOWN_EX = 15;
-    pub const GETOWN_EX = 16;
-
-    pub const GETOWNER_UIDS = 17;
-};
-
 pub const VDSO = struct {
     pub const CGT_SYM = "__kernel_clock_gettime";
     pub const CGT_VER = "LINUX_2.6.39";
 };
 
-pub const Flock = extern struct {
-    type: i16,
-    whence: i16,
-    start: off_t,
-    len: off_t,
-    pid: pid_t,
-    __unused: [4]u8,
-};
-
 pub const blksize_t = i32;
 pub const nlink_t = u32;
-pub const time_t = isize;
+pub const time_t = i64;
 pub const mode_t = u32;
-pub const off_t = isize;
-pub const ino_t = usize;
-pub const dev_t = usize;
-pub const blkcnt_t = isize;
+pub const off_t = i64;
+pub const ino_t = u64;
+pub const dev_t = u64;
+pub const blkcnt_t = i64;
 
 // The `stat` definition used by the Linux kernel.
 pub const Stat = extern struct {
@@ -205,40 +158,28 @@ pub const Stat = extern struct {
     ino: ino_t,
     mode: mode_t,
     nlink: nlink_t,
-    uid: uid_t,
-    gid: gid_t,
+    uid: std.os.linux.uid_t,
+    gid: std.os.linux.gid_t,
     rdev: dev_t,
-    __pad: usize,
+    __pad: u64,
     size: off_t,
     blksize: blksize_t,
     __pad2: i32,
     blocks: blkcnt_t,
-    atim: timespec,
-    mtim: timespec,
-    ctim: timespec,
+    atim: std.os.linux.timespec,
+    mtim: std.os.linux.timespec,
+    ctim: std.os.linux.timespec,
     __unused: [2]u32,
 
-    pub fn atime(self: @This()) timespec {
+    pub fn atime(self: @This()) std.os.linux.timespec {
         return self.atim;
     }
 
-    pub fn mtime(self: @This()) timespec {
+    pub fn mtime(self: @This()) std.os.linux.timespec {
         return self.mtim;
     }
 
-    pub fn ctime(self: @This()) timespec {
+    pub fn ctime(self: @This()) std.os.linux.timespec {
         return self.ctim;
     }
 };
-
-pub const timeval = extern struct {
-    sec: isize,
-    usec: isize,
-};
-
-pub const timezone = extern struct {
-    minuteswest: i32,
-    dsttime: i32,
-};
-
-pub const Elf_Symndx = u32;
diff --git a/lib/std/os/linux/arm.zig b/lib/std/os/linux/arm.zig
index 799557065428..0a5b25f9f078 100644
--- a/lib/std/os/linux/arm.zig
+++ b/lib/std/os/linux/arm.zig
@@ -1,45 +1,34 @@
+const builtin = @import("builtin");
 const std = @import("../../std.zig");
-const maxInt = std.math.maxInt;
-const linux = std.os.linux;
-const SYS = linux.SYS;
-const iovec = std.posix.iovec;
-const iovec_const = std.posix.iovec_const;
-const socklen_t = linux.socklen_t;
-const stack_t = linux.stack_t;
-const sigset_t = linux.sigset_t;
-const uid_t = linux.uid_t;
-const gid_t = linux.gid_t;
-const pid_t = linux.pid_t;
-const sockaddr = linux.sockaddr;
-const timespec = linux.timespec;
+const SYS = std.os.linux.SYS;
 
-pub fn syscall0(number: SYS) usize {
+pub fn syscall0(number: SYS) u32 {
     return asm volatile ("svc #0"
-        : [ret] "={r0}" (-> usize),
+        : [ret] "={r0}" (-> u32),
         : [number] "{r7}" (@intFromEnum(number)),
         : .{ .memory = true });
 }
 
-pub fn syscall1(number: SYS, arg1: usize) usize {
+pub fn syscall1(number: SYS, arg1: u32) u32 {
     return asm volatile ("svc #0"
-        : [ret] "={r0}" (-> usize),
+        : [ret] "={r0}" (-> u32),
         : [number] "{r7}" (@intFromEnum(number)),
           [arg1] "{r0}" (arg1),
         : .{ .memory = true });
 }
 
-pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
+pub fn syscall2(number: SYS, arg1: u32, arg2: u32) u32 {
     return asm volatile ("svc #0"
-        : [ret] "={r0}" (-> usize),
+        : [ret] "={r0}" (-> u32),
         : [number] "{r7}" (@intFromEnum(number)),
           [arg1] "{r0}" (arg1),
           [arg2] "{r1}" (arg2),
         : .{ .memory = true });
 }
 
-pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
+pub fn syscall3(number: SYS, arg1: u32, arg2: u32, arg3: u32) u32 {
     return asm volatile ("svc #0"
-        : [ret] "={r0}" (-> usize),
+        : [ret] "={r0}" (-> u32),
         : [number] "{r7}" (@intFromEnum(number)),
           [arg1] "{r0}" (arg1),
           [arg2] "{r1}" (arg2),
@@ -47,9 +36,9 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
         : .{ .memory = true });
 }
 
-pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize {
+pub fn syscall4(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32) u32 {
     return asm volatile ("svc #0"
-        : [ret] "={r0}" (-> usize),
+        : [ret] "={r0}" (-> u32),
         : [number] "{r7}" (@intFromEnum(number)),
           [arg1] "{r0}" (arg1),
           [arg2] "{r1}" (arg2),
@@ -58,9 +47,9 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)
         : .{ .memory = true });
 }
 
-pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize {
+pub fn syscall5(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32, arg5: u32) u32 {
     return asm volatile ("svc #0"
-        : [ret] "={r0}" (-> usize),
+        : [ret] "={r0}" (-> u32),
         : [number] "{r7}" (@intFromEnum(number)),
           [arg1] "{r0}" (arg1),
           [arg2] "{r1}" (arg2),
@@ -72,15 +61,15 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
 
 pub fn syscall6(
     number: SYS,
-    arg1: usize,
-    arg2: usize,
-    arg3: usize,
-    arg4: usize,
-    arg5: usize,
-    arg6: usize,
-) usize {
+    arg1: u32,
+    arg2: u32,
+    arg3: u32,
+    arg4: u32,
+    arg5: u32,
+    arg6: u32,
+) u32 {
     return asm volatile ("svc #0"
-        : [ret] "={r0}" (-> usize),
+        : [ret] "={r0}" (-> u32),
         : [number] "{r7}" (@intFromEnum(number)),
           [arg1] "{r0}" (arg1),
           [arg2] "{r1}" (arg2),
@@ -91,7 +80,7 @@ pub fn syscall6(
         : .{ .memory = true });
 }
 
-pub fn clone() callconv(.naked) usize {
+pub fn clone() callconv(.naked) u32 {
     // __clone(func, stack, flags, arg, ptid, tls, ctid)
     //         r0,   r1,    r2,    r3,  +0,   +4,  +8
     //
@@ -128,23 +117,23 @@ pub fn clone() callconv(.naked) usize {
 }
 
 pub fn restore() callconv(.naked) noreturn {
-    switch (@import("builtin").zig_backend) {
+    switch (builtin.zig_backend) {
         .stage2_c => asm volatile (
             \\ mov r7, %[number]
             \\ svc #0
             :
             : [number] "I" (@intFromEnum(SYS.sigreturn)),
-            : .{ .memory = true }),
+        ),
         else => asm volatile (
             \\ svc #0
             :
             : [number] "{r7}" (@intFromEnum(SYS.sigreturn)),
-            : .{ .memory = true }),
+        ),
     }
 }
 
 pub fn restore_rt() callconv(.naked) noreturn {
-    switch (@import("builtin").zig_backend) {
+    switch (builtin.zig_backend) {
         .stage2_c => asm volatile (
             \\ mov r7, %[number]
             \\ svc #0
@@ -159,32 +148,6 @@ pub fn restore_rt() callconv(.naked) noreturn {
     }
 }
 
-pub const F = struct {
-    pub const DUPFD = 0;
-    pub const GETFD = 1;
-    pub const SETFD = 2;
-    pub const GETFL = 3;
-    pub const SETFL = 4;
-
-    pub const SETOWN = 8;
-    pub const GETOWN = 9;
-    pub const SETSIG = 10;
-    pub const GETSIG = 11;
-
-    pub const GETLK = 12;
-    pub const SETLK = 13;
-    pub const SETLKW = 14;
-
-    pub const RDLCK = 0;
-    pub const WRLCK = 1;
-    pub const UNLCK = 2;
-
-    pub const SETOWN_EX = 15;
-    pub const GETOWN_EX = 16;
-
-    pub const GETOWNER_UIDS = 17;
-};
-
 pub const VDSO = struct {
     pub const CGT_SYM = "__vdso_clock_gettime";
     pub const CGT_VER = "LINUX_2.6";
@@ -216,19 +179,9 @@ pub const HWCAP = struct {
     pub const EVTSTRM = 1 << 21;
 };
 
-pub const Flock = extern struct {
-    type: i16,
-    whence: i16,
-    __pad0: [4]u8,
-    start: off_t,
-    len: off_t,
-    pid: pid_t,
-    __unused: [4]u8,
-};
-
 pub const blksize_t = i32;
 pub const nlink_t = u32;
-pub const time_t = isize;
+pub const time_t = i32;
 pub const mode_t = u32;
 pub const off_t = i64;
 pub const ino_t = u64;
@@ -242,39 +195,27 @@ pub const Stat = extern struct {
     __ino_truncated: u32,
     mode: mode_t,
     nlink: nlink_t,
-    uid: uid_t,
-    gid: gid_t,
+    uid: std.os.linux.uid_t,
+    gid: std.os.linux.gid_t,
     rdev: dev_t,
     __rdev_padding: u32,
     size: off_t,
     blksize: blksize_t,
     blocks: blkcnt_t,
-    atim: timespec,
-    mtim: timespec,
-    ctim: timespec,
+    atim: std.os.linux.timespec,
+    mtim: std.os.linux.timespec,
+    ctim: std.os.linux.timespec,
     ino: ino_t,
 
-    pub fn atime(self: @This()) timespec {
+    pub fn atime(self: @This()) std.os.linux.timespec {
         return self.atim;
     }
 
-    pub fn mtime(self: @This()) timespec {
+    pub fn mtime(self: @This()) std.os.linux.timespec {
         return self.mtim;
     }
 
-    pub fn ctime(self: @This()) timespec {
+    pub fn ctime(self: @This()) std.os.linux.timespec {
         return self.ctim;
     }
 };
-
-pub const timeval = extern struct {
-    sec: i32,
-    usec: i32,
-};
-
-pub const timezone = extern struct {
-    minuteswest: i32,
-    dsttime: i32,
-};
-
-pub const Elf_Symndx = u32;
diff --git a/lib/std/os/linux/hexagon.zig b/lib/std/os/linux/hexagon.zig
index e3bf7a870953..41bcaa6d934c 100644
--- a/lib/std/os/linux/hexagon.zig
+++ b/lib/std/os/linux/hexagon.zig
@@ -1,45 +1,34 @@
 const builtin = @import("builtin");
 const std = @import("../../std.zig");
-const iovec = std.posix.iovec;
-const iovec_const = std.posix.iovec_const;
-const linux = std.os.linux;
-const SYS = linux.SYS;
-const uid_t = std.os.linux.uid_t;
-const gid_t = std.os.linux.gid_t;
-const pid_t = std.os.linux.pid_t;
-const sockaddr = linux.sockaddr;
-const socklen_t = linux.socklen_t;
-const stack_t = linux.stack_t;
-const sigset_t = linux.sigset_t;
-const timespec = std.os.linux.timespec;
+const SYS = std.os.linux.SYS;
 
-pub fn syscall0(number: SYS) usize {
+pub fn syscall0(number: SYS) u32 {
     return asm volatile ("trap0(#1)"
-        : [ret] "={r0}" (-> usize),
+        : [ret] "={r0}" (-> u32),
         : [number] "{r6}" (@intFromEnum(number)),
         : .{ .memory = true });
 }
 
-pub fn syscall1(number: SYS, arg1: usize) usize {
+pub fn syscall1(number: SYS, arg1: u32) u32 {
     return asm volatile ("trap0(#1)"
-        : [ret] "={r0}" (-> usize),
+        : [ret] "={r0}" (-> u32),
         : [number] "{r6}" (@intFromEnum(number)),
           [arg1] "{r0}" (arg1),
         : .{ .memory = true });
 }
 
-pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
+pub fn syscall2(number: SYS, arg1: u32, arg2: u32) u32 {
     return asm volatile ("trap0(#1)"
-        : [ret] "={r0}" (-> usize),
+        : [ret] "={r0}" (-> u32),
         : [number] "{r6}" (@intFromEnum(number)),
           [arg1] "{r0}" (arg1),
           [arg2] "{r1}" (arg2),
         : .{ .memory = true });
 }
 
-pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
+pub fn syscall3(number: SYS, arg1: u32, arg2: u32, arg3: u32) u32 {
     return asm volatile ("trap0(#1)"
-        : [ret] "={r0}" (-> usize),
+        : [ret] "={r0}" (-> u32),
         : [number] "{r6}" (@intFromEnum(number)),
           [arg1] "{r0}" (arg1),
           [arg2] "{r1}" (arg2),
@@ -47,9 +36,9 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
         : .{ .memory = true });
 }
 
-pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize {
+pub fn syscall4(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32) u32 {
     return asm volatile ("trap0(#1)"
-        : [ret] "={r0}" (-> usize),
+        : [ret] "={r0}" (-> u32),
         : [number] "{r6}" (@intFromEnum(number)),
           [arg1] "{r0}" (arg1),
           [arg2] "{r1}" (arg2),
@@ -58,9 +47,9 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)
         : .{ .memory = true });
 }
 
-pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize {
+pub fn syscall5(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32, arg5: u32) u32 {
     return asm volatile ("trap0(#1)"
-        : [ret] "={r0}" (-> usize),
+        : [ret] "={r0}" (-> u32),
         : [number] "{r6}" (@intFromEnum(number)),
           [arg1] "{r0}" (arg1),
           [arg2] "{r1}" (arg2),
@@ -72,15 +61,15 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
 
 pub fn syscall6(
     number: SYS,
-    arg1: usize,
-    arg2: usize,
-    arg3: usize,
-    arg4: usize,
-    arg5: usize,
-    arg6: usize,
-) usize {
+    arg1: u32,
+    arg2: u32,
+    arg3: u32,
+    arg4: u32,
+    arg5: u32,
+    arg6: u32,
+) u32 {
     return asm volatile ("trap0(#1)"
-        : [ret] "={r0}" (-> usize),
+        : [ret] "={r0}" (-> u32),
         : [number] "{r6}" (@intFromEnum(number)),
           [arg1] "{r0}" (arg1),
           [arg2] "{r1}" (arg2),
@@ -91,7 +80,7 @@ pub fn syscall6(
         : .{ .memory = true });
 }
 
-pub fn clone() callconv(.naked) usize {
+pub fn clone() callconv(.naked) u32 {
     // __clone(func, stack, flags, arg, ptid, tls, ctid)
     //         r0,   r1,    r2,    r3,  r4,   r5,  +0
     //
@@ -130,44 +119,6 @@ pub fn clone() callconv(.naked) usize {
     );
 }
 
-pub const F = struct {
-    pub const DUPFD = 0;
-    pub const GETFD = 1;
-    pub const SETFD = 2;
-    pub const GETFL = 3;
-    pub const SETFL = 4;
-    pub const GETLK = 5;
-    pub const SETLK = 6;
-    pub const SETLKW = 7;
-    pub const SETOWN = 8;
-    pub const GETOWN = 9;
-    pub const SETSIG = 10;
-    pub const GETSIG = 11;
-
-    pub const RDLCK = 0;
-    pub const WRLCK = 1;
-    pub const UNLCK = 2;
-
-    pub const SETOWN_EX = 15;
-    pub const GETOWN_EX = 16;
-
-    pub const GETOWNER_UIDS = 17;
-};
-
-pub const timeval = extern struct {
-    sec: time_t,
-    usec: i32,
-};
-
-pub const Flock = extern struct {
-    type: i16,
-    whence: i16,
-    start: off_t,
-    len: off_t,
-    pid: pid_t,
-    __unused: [4]u8,
-};
-
 pub const blksize_t = i32;
 pub const nlink_t = u32;
 pub const time_t = i32;
@@ -183,32 +134,30 @@ pub const Stat = extern struct {
     ino: ino_t,
     mode: mode_t,
     nlink: nlink_t,
-    uid: uid_t,
-    gid: gid_t,
+    uid: std.os.linux.uid_t,
+    gid: std.os.linux.gid_t,
     rdev: dev_t,
     __pad: u32,
     size: off_t,
     blksize: blksize_t,
     __pad2: i32,
     blocks: blkcnt_t,
-    atim: timespec,
-    mtim: timespec,
-    ctim: timespec,
+    atim: std.os.linux.timespec,
+    mtim: std.os.linux.timespec,
+    ctim: std.os.linux.timespec,
     __unused: [2]u32,
 
-    pub fn atime(self: @This()) timespec {
+    pub fn atime(self: @This()) std.os.linux.timespec {
         return self.atim;
     }
 
-    pub fn mtime(self: @This()) timespec {
+    pub fn mtime(self: @This()) std.os.linux.timespec {
         return self.mtim;
     }
 
-    pub fn ctime(self: @This()) timespec {
+    pub fn ctime(self: @This()) std.os.linux.timespec {
         return self.ctim;
     }
 };
 
-pub const Elf_Symndx = u32;
-
 pub const VDSO = void;
diff --git a/lib/std/os/linux/loongarch64.zig b/lib/std/os/linux/loongarch64.zig
index 4ed817167d1a..41450c997670 100644
--- a/lib/std/os/linux/loongarch64.zig
+++ b/lib/std/os/linux/loongarch64.zig
@@ -1,48 +1,38 @@
 const builtin = @import("builtin");
 const std = @import("../../std.zig");
-const linux = std.os.linux;
-const SYS = linux.SYS;
-const iovec = std.posix.iovec;
-const iovec_const = std.posix.iovec_const;
-const uid_t = linux.uid_t;
-const gid_t = linux.gid_t;
-const stack_t = linux.stack_t;
-const sigset_t = linux.sigset_t;
-const sockaddr = linux.sockaddr;
-const socklen_t = linux.socklen_t;
-const timespec = linux.timespec;
+const SYS = std.os.linux.SYS;
 
-pub fn syscall0(number: SYS) usize {
+pub fn syscall0(number: SYS) u64 {
     return asm volatile (
         \\ syscall 0
-        : [ret] "={$r4}" (-> usize),
+        : [ret] "={$r4}" (-> u64),
         : [number] "{$r11}" (@intFromEnum(number)),
         : .{ .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r16 = true, .r17 = true, .r18 = true, .r19 = true, .r20 = true, .memory = true });
 }
 
-pub fn syscall1(number: SYS, arg1: usize) usize {
+pub fn syscall1(number: SYS, arg1: u64) u64 {
     return asm volatile (
         \\ syscall 0
-        : [ret] "={$r4}" (-> usize),
+        : [ret] "={$r4}" (-> u64),
         : [number] "{$r11}" (@intFromEnum(number)),
           [arg1] "{$r4}" (arg1),
         : .{ .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r16 = true, .r17 = true, .r18 = true, .r19 = true, .r20 = true, .memory = true });
 }
 
-pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
+pub fn syscall2(number: SYS, arg1: u64, arg2: u64) u64 {
     return asm volatile (
         \\ syscall 0
-        : [ret] "={$r4}" (-> usize),
+        : [ret] "={$r4}" (-> u64),
         : [number] "{$r11}" (@intFromEnum(number)),
           [arg1] "{$r4}" (arg1),
           [arg2] "{$r5}" (arg2),
         : .{ .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r16 = true, .r17 = true, .r18 = true, .r19 = true, .r20 = true, .memory = true });
 }
 
-pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
+pub fn syscall3(number: SYS, arg1: u64, arg2: u64, arg3: u64) u64 {
     return asm volatile (
         \\ syscall 0
-        : [ret] "={$r4}" (-> usize),
+        : [ret] "={$r4}" (-> u64),
         : [number] "{$r11}" (@intFromEnum(number)),
           [arg1] "{$r4}" (arg1),
           [arg2] "{$r5}" (arg2),
@@ -50,10 +40,10 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
         : .{ .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r16 = true, .r17 = true, .r18 = true, .r19 = true, .r20 = true, .memory = true });
 }
 
-pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize {
+pub fn syscall4(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64) u64 {
     return asm volatile (
         \\ syscall 0
-        : [ret] "={$r4}" (-> usize),
+        : [ret] "={$r4}" (-> u64),
         : [number] "{$r11}" (@intFromEnum(number)),
           [arg1] "{$r4}" (arg1),
           [arg2] "{$r5}" (arg2),
@@ -62,10 +52,10 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)
         : .{ .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r16 = true, .r17 = true, .r18 = true, .r19 = true, .r20 = true, .memory = true });
 }
 
-pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize {
+pub fn syscall5(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64, arg5: u64) u64 {
     return asm volatile (
         \\ syscall 0
-        : [ret] "={$r4}" (-> usize),
+        : [ret] "={$r4}" (-> u64),
         : [number] "{$r11}" (@intFromEnum(number)),
           [arg1] "{$r4}" (arg1),
           [arg2] "{$r5}" (arg2),
@@ -77,16 +67,16 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
 
 pub fn syscall6(
     number: SYS,
-    arg1: usize,
-    arg2: usize,
-    arg3: usize,
-    arg4: usize,
-    arg5: usize,
-    arg6: usize,
-) usize {
+    arg1: u64,
+    arg2: u64,
+    arg3: u64,
+    arg4: u64,
+    arg5: u64,
+    arg6: u64,
+) u64 {
     return asm volatile (
         \\ syscall 0
-        : [ret] "={$r4}" (-> usize),
+        : [ret] "={$r4}" (-> u64),
         : [number] "{$r11}" (@intFromEnum(number)),
           [arg1] "{$r4}" (arg1),
           [arg2] "{$r5}" (arg2),
@@ -97,7 +87,7 @@ pub fn syscall6(
         : .{ .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r16 = true, .r17 = true, .r18 = true, .r19 = true, .r20 = true, .memory = true });
 }
 
-pub fn clone() callconv(.naked) usize {
+pub fn clone() callconv(.naked) u64 {
     // __clone(func, stack, flags, arg, ptid, tls, ctid)
     //           a0,    a1,    a2,  a3,   a4,  a5,   a6
     // sys_clone(flags, stack, ptid, ctid, tls)
@@ -150,64 +140,33 @@ pub const Stat = extern struct {
     ino: ino_t,
     mode: mode_t,
     nlink: nlink_t,
-    uid: uid_t,
-    gid: gid_t,
+    uid: std.os.linux.uid_t,
+    gid: std.os.linux.gid_t,
     rdev: dev_t,
     _pad1: u64,
     size: off_t,
     blksize: blksize_t,
     _pad2: i32,
     blocks: blkcnt_t,
-    atim: timespec,
-    mtim: timespec,
-    ctim: timespec,
+    atim: std.os.linux.timespec,
+    mtim: std.os.linux.timespec,
+    ctim: std.os.linux.timespec,
     _pad3: [2]u32,
 
-    pub fn atime(self: @This()) timespec {
+    pub fn atime(self: @This()) std.os.linux.timespec {
         return self.atim;
     }
 
-    pub fn mtime(self: @This()) timespec {
+    pub fn mtime(self: @This()) std.os.linux.timespec {
         return self.mtim;
     }
 
-    pub fn ctime(self: @This()) timespec {
+    pub fn ctime(self: @This()) std.os.linux.timespec {
         return self.ctim;
     }
 };
 
-pub const timeval = extern struct {
-    tv_sec: time_t,
-    tv_usec: i64,
-};
-
-pub const F = struct {
-    pub const DUPFD = 0;
-    pub const GETFD = 1;
-    pub const SETFD = 2;
-    pub const GETFL = 3;
-    pub const SETFL = 4;
-    pub const GETLK = 5;
-    pub const SETLK = 6;
-    pub const SETLKW = 7;
-    pub const SETOWN = 8;
-    pub const GETOWN = 9;
-    pub const SETSIG = 10;
-    pub const GETSIG = 11;
-
-    pub const RDLCK = 0;
-    pub const WRLCK = 1;
-    pub const UNLCK = 2;
-
-    pub const SETOWN_EX = 15;
-    pub const GETOWN_EX = 16;
-
-    pub const GETOWNER_UIDS = 17;
-};
-
 pub const VDSO = struct {
     pub const CGT_SYM = "__vdso_clock_gettime";
     pub const CGT_VER = "LINUX_5.10";
 };
-
-pub const Elf_Symndx = u32;
diff --git a/lib/std/os/linux/m68k.zig b/lib/std/os/linux/m68k.zig
index c3bd42b2ffb8..29d9adf1f7b0 100644
--- a/lib/std/os/linux/m68k.zig
+++ b/lib/std/os/linux/m68k.zig
@@ -1,43 +1,34 @@
 const builtin = @import("builtin");
 const std = @import("../../std.zig");
-const iovec = std.posix.iovec;
-const iovec_const = std.posix.iovec_const;
-const linux = std.os.linux;
-const SYS = linux.SYS;
-const uid_t = std.os.linux.uid_t;
-const gid_t = std.os.linux.uid_t;
-const pid_t = std.os.linux.pid_t;
-const sockaddr = linux.sockaddr;
-const socklen_t = linux.socklen_t;
-const timespec = std.os.linux.timespec;
-
-pub fn syscall0(number: SYS) usize {
+const SYS = std.os.linux.SYS;
+
+pub fn syscall0(number: SYS) u32 {
     return asm volatile ("trap #0"
-        : [ret] "={d0}" (-> usize),
+        : [ret] "={d0}" (-> u32),
         : [number] "{d0}" (@intFromEnum(number)),
         : .{ .memory = true });
 }
 
-pub fn syscall1(number: SYS, arg1: usize) usize {
+pub fn syscall1(number: SYS, arg1: u32) u32 {
     return asm volatile ("trap #0"
-        : [ret] "={d0}" (-> usize),
+        : [ret] "={d0}" (-> u32),
         : [number] "{d0}" (@intFromEnum(number)),
           [arg1] "{d1}" (arg1),
         : .{ .memory = true });
 }
 
-pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
+pub fn syscall2(number: SYS, arg1: u32, arg2: u32) u32 {
     return asm volatile ("trap #0"
-        : [ret] "={d0}" (-> usize),
+        : [ret] "={d0}" (-> u32),
         : [number] "{d0}" (@intFromEnum(number)),
           [arg1] "{d1}" (arg1),
           [arg2] "{d2}" (arg2),
         : .{ .memory = true });
 }
 
-pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
+pub fn syscall3(number: SYS, arg1: u32, arg2: u32, arg3: u32) u32 {
     return asm volatile ("trap #0"
-        : [ret] "={d0}" (-> usize),
+        : [ret] "={d0}" (-> u32),
         : [number] "{d0}" (@intFromEnum(number)),
           [arg1] "{d1}" (arg1),
           [arg2] "{d2}" (arg2),
@@ -45,9 +36,9 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
         : .{ .memory = true });
 }
 
-pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize {
+pub fn syscall4(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32) u32 {
     return asm volatile ("trap #0"
-        : [ret] "={d0}" (-> usize),
+        : [ret] "={d0}" (-> u32),
         : [number] "{d0}" (@intFromEnum(number)),
           [arg1] "{d1}" (arg1),
           [arg2] "{d2}" (arg2),
@@ -56,9 +47,9 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)
         : .{ .memory = true });
 }
 
-pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize {
+pub fn syscall5(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32, arg5: u32) u32 {
     return asm volatile ("trap #0"
-        : [ret] "={d0}" (-> usize),
+        : [ret] "={d0}" (-> u32),
         : [number] "{d0}" (@intFromEnum(number)),
           [arg1] "{d1}" (arg1),
           [arg2] "{d2}" (arg2),
@@ -70,15 +61,15 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
 
 pub fn syscall6(
     number: SYS,
-    arg1: usize,
-    arg2: usize,
-    arg3: usize,
-    arg4: usize,
-    arg5: usize,
-    arg6: usize,
-) usize {
+    arg1: u32,
+    arg2: u32,
+    arg3: u32,
+    arg4: u32,
+    arg5: u32,
+    arg6: u32,
+) u32 {
     return asm volatile ("trap #0"
-        : [ret] "={d0}" (-> usize),
+        : [ret] "={d0}" (-> u32),
         : [number] "{d0}" (@intFromEnum(number)),
           [arg1] "{d1}" (arg1),
           [arg2] "{d2}" (arg2),
@@ -89,7 +80,7 @@ pub fn syscall6(
         : .{ .memory = true });
 }
 
-pub fn clone() callconv(.naked) usize {
+pub fn clone() callconv(.naked) u32 {
     // __clone(func, stack, flags, arg, ptid, tls, ctid)
     //         +4,   +8,    +12,   +16, +20,  +24, +28
     //
@@ -151,32 +142,6 @@ pub fn restore_rt() callconv(.naked) noreturn {
     );
 }
 
-pub const F = struct {
-    pub const DUPFD = 0;
-    pub const GETFD = 1;
-    pub const SETFD = 2;
-    pub const GETFL = 3;
-    pub const SETFL = 4;
-
-    pub const SETOWN = 8;
-    pub const GETOWN = 9;
-    pub const SETSIG = 10;
-    pub const GETSIG = 11;
-
-    pub const GETLK = 12;
-    pub const SETLK = 13;
-    pub const SETLKW = 14;
-
-    pub const SETOWN_EX = 15;
-    pub const GETOWN_EX = 16;
-
-    pub const GETOWNER_UIDS = 17;
-
-    pub const RDLCK = 0;
-    pub const WRLCK = 1;
-    pub const UNLCK = 2;
-};
-
 pub const blksize_t = i32;
 pub const nlink_t = u32;
 pub const time_t = i32;
@@ -186,51 +151,36 @@ pub const ino_t = u64;
 pub const dev_t = u64;
 pub const blkcnt_t = i64;
 
-pub const timeval = extern struct {
-    sec: time_t,
-    usec: i32,
-};
-
-pub const Flock = extern struct {
-    type: i16,
-    whence: i16,
-    start: off_t,
-    len: off_t,
-    pid: pid_t,
-};
-
 pub const Stat = extern struct {
     dev: dev_t,
     __pad: i16,
     __ino_truncated: i32,
     mode: mode_t,
     nlink: nlink_t,
-    uid: uid_t,
-    gid: gid_t,
+    uid: std.os.linux.uid_t,
+    gid: std.os.linux.gid_t,
     rdev: dev_t,
     __pad2: i16,
     size: off_t,
     blksize: blksize_t,
     blocks: blkcnt_t,
-    atim: timespec,
-    mtim: timespec,
-    ctim: timespec,
+    atim: std.os.linux.timespec,
+    mtim: std.os.linux.timespec,
+    ctim: std.os.linux.timespec,
     ino: ino_t,
 
-    pub fn atime(self: @This()) timespec {
+    pub fn atime(self: @This()) std.os.linux.timespec {
         return self.atim;
     }
 
-    pub fn mtime(self: @This()) timespec {
+    pub fn mtime(self: @This()) std.os.linux.timespec {
         return self.mtim;
     }
 
-    pub fn ctime(self: @This()) timespec {
+    pub fn ctime(self: @This()) std.os.linux.timespec {
         return self.ctim;
     }
 };
 
-pub const Elf_Symndx = u32;
-
 // No VDSO used as of glibc 112a0ae18b831bf31f44d81b82666980312511d6.
 pub const VDSO = void;
diff --git a/lib/std/os/linux/mips.zig b/lib/std/os/linux/mips.zig
index 6412c847bdd6..7468396a09d5 100644
--- a/lib/std/os/linux/mips.zig
+++ b/lib/std/os/linux/mips.zig
@@ -1,32 +1,20 @@
 const builtin = @import("builtin");
 const std = @import("../../std.zig");
-const maxInt = std.math.maxInt;
-const linux = std.os.linux;
-const SYS = linux.SYS;
-const socklen_t = linux.socklen_t;
-const iovec = std.posix.iovec;
-const iovec_const = std.posix.iovec_const;
-const uid_t = linux.uid_t;
-const gid_t = linux.gid_t;
-const pid_t = linux.pid_t;
-const stack_t = linux.stack_t;
-const sigset_t = linux.sigset_t;
-const sockaddr = linux.sockaddr;
-const timespec = linux.timespec;
+const SYS = std.os.linux.SYS;
 
-pub fn syscall0(number: SYS) usize {
+pub fn syscall0(number: SYS) u32 {
     return asm volatile (
         \\ syscall
         \\ beq $7, $zero, 1f
         \\ blez $2, 1f
         \\ subu $2, $0, $2
         \\ 1:
-        : [ret] "={$2}" (-> usize),
+        : [ret] "={$2}" (-> u32),
         : [number] "{$2}" (@intFromEnum(number)),
         : .{ .r1 = true, .r3 = true, .r4 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r24 = true, .r25 = true, .hi = true, .lo = true, .memory = true });
 }
 
-pub fn syscall_pipe(fd: *[2]i32) usize {
+pub fn syscall_pipe(fd: *[2]i32) u32 {
     return asm volatile (
         \\ .set noat
         \\ .set noreorder
@@ -39,47 +27,47 @@ pub fn syscall_pipe(fd: *[2]i32) usize {
         \\ sw $2, 0($4)
         \\ sw $3, 4($4)
         \\ 2:
-        : [ret] "={$2}" (-> usize),
+        : [ret] "={$2}" (-> u32),
         : [number] "{$2}" (@intFromEnum(SYS.pipe)),
           [fd] "{$4}" (fd),
         : .{ .r1 = true, .r3 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r24 = true, .r25 = true, .hi = true, .lo = true, .memory = true });
 }
 
-pub fn syscall1(number: SYS, arg1: usize) usize {
+pub fn syscall1(number: SYS, arg1: u32) u32 {
     return asm volatile (
         \\ syscall
         \\ beq $7, $zero, 1f
         \\ blez $2, 1f
         \\ subu $2, $0, $2
         \\ 1:
-        : [ret] "={$2}" (-> usize),
+        : [ret] "={$2}" (-> u32),
         : [number] "{$2}" (@intFromEnum(number)),
           [arg1] "{$4}" (arg1),
         : .{ .r1 = true, .r3 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r24 = true, .r25 = true, .hi = true, .lo = true, .memory = true });
 }
 
-pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
+pub fn syscall2(number: SYS, arg1: u32, arg2: u32) u32 {
     return asm volatile (
         \\ syscall
         \\ beq $7, $zero, 1f
         \\ blez $2, 1f
         \\ subu $2, $0, $2
         \\ 1:
-        : [ret] "={$2}" (-> usize),
+        : [ret] "={$2}" (-> u32),
         : [number] "{$2}" (@intFromEnum(number)),
           [arg1] "{$4}" (arg1),
           [arg2] "{$5}" (arg2),
         : .{ .r1 = true, .r3 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r24 = true, .r25 = true, .hi = true, .lo = true, .memory = true });
 }
 
-pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
+pub fn syscall3(number: SYS, arg1: u32, arg2: u32, arg3: u32) u32 {
     return asm volatile (
         \\ syscall
         \\ beq $7, $zero, 1f
         \\ blez $2, 1f
         \\ subu $2, $0, $2
         \\ 1:
-        : [ret] "={$2}" (-> usize),
+        : [ret] "={$2}" (-> u32),
         : [number] "{$2}" (@intFromEnum(number)),
           [arg1] "{$4}" (arg1),
           [arg2] "{$5}" (arg2),
@@ -87,14 +75,14 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
         : .{ .r1 = true, .r3 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r24 = true, .r25 = true, .hi = true, .lo = true, .memory = true });
 }
 
-pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize {
+pub fn syscall4(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32) u32 {
     return asm volatile (
         \\ syscall
         \\ beq $7, $zero, 1f
         \\ blez $2, 1f
         \\ subu $2, $0, $2
         \\ 1:
-        : [ret] "={$2}" (-> usize),
+        : [ret] "={$2}" (-> u32),
         : [number] "{$2}" (@intFromEnum(number)),
           [arg1] "{$4}" (arg1),
           [arg2] "{$5}" (arg2),
@@ -103,7 +91,7 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)
         : .{ .r1 = true, .r3 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r24 = true, .r25 = true, .hi = true, .lo = true, .memory = true });
 }
 
-pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize {
+pub fn syscall5(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32, arg5: u32) u32 {
     return asm volatile (
         \\ .set noat
         \\ subu $sp, $sp, 24
@@ -114,7 +102,7 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
         \\ blez $2, 1f
         \\ subu $2, $0, $2
         \\ 1:
-        : [ret] "={$2}" (-> usize),
+        : [ret] "={$2}" (-> u32),
         : [number] "{$2}" (@intFromEnum(number)),
           [arg1] "{$4}" (arg1),
           [arg2] "{$5}" (arg2),
@@ -129,13 +117,13 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
 
 pub fn syscall6(
     number: SYS,
-    arg1: usize,
-    arg2: usize,
-    arg3: usize,
-    arg4: usize,
-    arg5: usize,
-    arg6: usize,
-) usize {
+    arg1: u32,
+    arg2: u32,
+    arg3: u32,
+    arg4: u32,
+    arg5: u32,
+    arg6: u32,
+) u32 {
     return asm volatile (
         \\ .set noat
         \\ subu $sp, $sp, 24
@@ -147,7 +135,7 @@ pub fn syscall6(
         \\ blez $2, 1f
         \\ subu $2, $0, $2
         \\ 1:
-        : [ret] "={$2}" (-> usize),
+        : [ret] "={$2}" (-> u32),
         : [number] "{$2}" (@intFromEnum(number)),
           [arg1] "{$4}" (arg1),
           [arg2] "{$5}" (arg2),
@@ -160,14 +148,14 @@ pub fn syscall6(
 
 pub fn syscall7(
     number: SYS,
-    arg1: usize,
-    arg2: usize,
-    arg3: usize,
-    arg4: usize,
-    arg5: usize,
-    arg6: usize,
-    arg7: usize,
-) usize {
+    arg1: u32,
+    arg2: u32,
+    arg3: u32,
+    arg4: u32,
+    arg5: u32,
+    arg6: u32,
+    arg7: u32,
+) u32 {
     return asm volatile (
         \\ .set noat
         \\ subu $sp, $sp, 32
@@ -180,7 +168,7 @@ pub fn syscall7(
         \\ blez $2, 1f
         \\ subu $2, $0, $2
         \\ 1:
-        : [ret] "={$2}" (-> usize),
+        : [ret] "={$2}" (-> u32),
         : [number] "{$2}" (@intFromEnum(number)),
           [arg1] "{$4}" (arg1),
           [arg2] "{$5}" (arg2),
@@ -192,7 +180,7 @@ pub fn syscall7(
         : .{ .r1 = true, .r3 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r24 = true, .r25 = true, .hi = true, .lo = true, .memory = true });
 }
 
-pub fn clone() callconv(.naked) usize {
+pub fn clone() callconv(.naked) u32 {
     // __clone(func, stack, flags, arg, ptid, tls, ctid)
     //         3,    4,     5,     6,   7,    8,   9
     //
@@ -243,47 +231,11 @@ pub fn clone() callconv(.naked) usize {
     );
 }
 
-pub const F = struct {
-    pub const DUPFD = 0;
-    pub const GETFD = 1;
-    pub const SETFD = 2;
-    pub const GETFL = 3;
-    pub const SETFL = 4;
-
-    pub const SETOWN = 24;
-    pub const GETOWN = 23;
-    pub const SETSIG = 10;
-    pub const GETSIG = 11;
-
-    pub const GETLK = 33;
-    pub const SETLK = 34;
-    pub const SETLKW = 35;
-
-    pub const RDLCK = 0;
-    pub const WRLCK = 1;
-    pub const UNLCK = 2;
-
-    pub const SETOWN_EX = 15;
-    pub const GETOWN_EX = 16;
-
-    pub const GETOWNER_UIDS = 17;
-};
-
 pub const VDSO = struct {
     pub const CGT_SYM = "__vdso_clock_gettime";
     pub const CGT_VER = "LINUX_2.6";
 };
 
-pub const Flock = extern struct {
-    type: i16,
-    whence: i16,
-    __pad0: [4]u8,
-    start: off_t,
-    len: off_t,
-    pid: pid_t,
-    __unused: [4]u8,
-};
-
 pub const blksize_t = u32;
 pub const nlink_t = u32;
 pub const time_t = i32;
@@ -300,51 +252,27 @@ pub const Stat = extern struct {
     ino: ino_t,
     mode: mode_t,
     nlink: nlink_t,
-    uid: uid_t,
-    gid: gid_t,
+    uid: std.os.linux.uid_t,
+    gid: std.os.linux.gid_t,
     rdev: dev_t,
     __pad1: [2]u32,
     size: off_t,
-    atim: i32,
-    atim_nsec: i32,
-    mtim: i32,
-    mtim_nsec: i32,
-    ctim: i32,
-    ctim_nsec: i32,
+    atim: std.os.linux.timespec,
+    mtim: std.os.linux.timespec,
+    ctim: std.os.linux.timespec,
     blksize: blksize_t,
     __pad3: u32,
     blocks: blkcnt_t,
 
-    pub fn atime(self: @This()) timespec {
-        return .{
-            .sec = self.atim,
-            .nsec = self.atim_nsec,
-        };
+    pub fn atime(self: @This()) std.os.linux.timespec {
+        return self.atim;
     }
 
-    pub fn mtime(self: @This()) timespec {
-        return .{
-            .sec = self.mtim,
-            .nsec = self.mtim_nsec,
-        };
+    pub fn mtime(self: @This()) std.os.linux.timespec {
+        return self.mtim;
     }
 
-    pub fn ctime(self: @This()) timespec {
-        return .{
-            .sec = self.ctim,
-            .nsec = self.ctim_nsec,
-        };
+    pub fn ctime(self: @This()) std.os.linux.timespec {
+        return self.ctim;
     }
 };
-
-pub const timeval = extern struct {
-    sec: isize,
-    usec: isize,
-};
-
-pub const timezone = extern struct {
-    minuteswest: i32,
-    dsttime: i32,
-};
-
-pub const Elf_Symndx = u32;
diff --git a/lib/std/os/linux/mips64.zig b/lib/std/os/linux/mips64.zig
index 44191901933e..187a093c437a 100644
--- a/lib/std/os/linux/mips64.zig
+++ b/lib/std/os/linux/mips64.zig
@@ -1,32 +1,20 @@
 const builtin = @import("builtin");
 const std = @import("../../std.zig");
-const maxInt = std.math.maxInt;
-const linux = std.os.linux;
-const SYS = linux.SYS;
-const socklen_t = linux.socklen_t;
-const iovec = std.posix.iovec;
-const iovec_const = std.posix.iovec_const;
-const uid_t = linux.uid_t;
-const gid_t = linux.gid_t;
-const pid_t = linux.pid_t;
-const stack_t = linux.stack_t;
-const sigset_t = linux.sigset_t;
-const sockaddr = linux.sockaddr;
-const timespec = linux.timespec;
+const SYS = std.os.linux.SYS;
 
-pub fn syscall0(number: SYS) usize {
+pub fn syscall0(number: SYS) u64 {
     return asm volatile (
         \\ syscall
         \\ beq $7, $zero, 1f
         \\ blez $2, 1f
         \\ dsubu $2, $0, $2
         \\ 1:
-        : [ret] "={$2}" (-> usize),
+        : [ret] "={$2}" (-> u64),
         : [number] "{$2}" (@intFromEnum(number)),
         : .{ .r1 = true, .r3 = true, .r4 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r24 = true, .r25 = true, .hi = true, .lo = true, .memory = true });
 }
 
-pub fn syscall_pipe(fd: *[2]i32) usize {
+pub fn syscall_pipe(fd: *[2]i32) u64 {
     return asm volatile (
         \\ .set noat
         \\ .set noreorder
@@ -39,13 +27,13 @@ pub fn syscall_pipe(fd: *[2]i32) usize {
         \\ sw $2, 0($4)
         \\ sw $3, 4($4)
         \\ 2:
-        : [ret] "={$2}" (-> usize),
+        : [ret] "={$2}" (-> u64),
         : [number] "{$2}" (@intFromEnum(SYS.pipe)),
           [fd] "{$4}" (fd),
         : .{ .r1 = true, .r3 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r24 = true, .r25 = true, .hi = true, .lo = true, .memory = true });
 }
 
-pub fn syscall1(number: SYS, arg1: usize) usize {
+pub fn syscall1(number: SYS, arg1: u64) u64 {
     return asm volatile (
         \\ syscall
         \\ beq $7, $zero, 1f
@@ -53,34 +41,34 @@ pub fn syscall1(number: SYS, arg1: usize) usize {
         \\ nop
         \\ dsubu $2, $0, $2
         \\ 1:
-        : [ret] "={$2}" (-> usize),
+        : [ret] "={$2}" (-> u64),
         : [number] "{$2}" (@intFromEnum(number)),
           [arg1] "{$4}" (arg1),
         : .{ .r1 = true, .r3 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r24 = true, .r25 = true, .hi = true, .lo = true, .memory = true });
 }
 
-pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
+pub fn syscall2(number: SYS, arg1: u64, arg2: u64) u64 {
     return asm volatile (
         \\ syscall
         \\ beq $7, $zero, 1f
         \\ blez $2, 1f
         \\ dsubu $2, $0, $2
         \\ 1:
-        : [ret] "={$2}" (-> usize),
+        : [ret] "={$2}" (-> u64),
         : [number] "{$2}" (@intFromEnum(number)),
           [arg1] "{$4}" (arg1),
           [arg2] "{$5}" (arg2),
         : .{ .r1 = true, .r3 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r24 = true, .r25 = true, .hi = true, .lo = true, .memory = true });
 }
 
-pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
+pub fn syscall3(number: SYS, arg1: u64, arg2: u64, arg3: u64) u64 {
     return asm volatile (
         \\ syscall
         \\ beq $7, $zero, 1f
         \\ blez $2, 1f
         \\ dsubu $2, $0, $2
         \\ 1:
-        : [ret] "={$2}" (-> usize),
+        : [ret] "={$2}" (-> u64),
         : [number] "{$2}" (@intFromEnum(number)),
           [arg1] "{$4}" (arg1),
           [arg2] "{$5}" (arg2),
@@ -88,14 +76,14 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
         : .{ .r1 = true, .r3 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r24 = true, .r25 = true, .hi = true, .lo = true, .memory = true });
 }
 
-pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize {
+pub fn syscall4(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64) u64 {
     return asm volatile (
         \\ syscall
         \\ beq $7, $zero, 1f
         \\ blez $2, 1f
         \\ dsubu $2, $0, $2
         \\ 1:
-        : [ret] "={$2}" (-> usize),
+        : [ret] "={$2}" (-> u64),
         : [number] "{$2}" (@intFromEnum(number)),
           [arg1] "{$4}" (arg1),
           [arg2] "{$5}" (arg2),
@@ -104,14 +92,14 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)
         : .{ .r1 = true, .r3 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r24 = true, .r25 = true, .hi = true, .lo = true, .memory = true });
 }
 
-pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize {
+pub fn syscall5(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64, arg5: u64) u64 {
     return asm volatile (
         \\ syscall
         \\ beq $7, $zero, 1f
         \\ blez $2, 1f
         \\ dsubu $2, $0, $2
         \\ 1:
-        : [ret] "={$2}" (-> usize),
+        : [ret] "={$2}" (-> u64),
         : [number] "{$2}" (@intFromEnum(number)),
           [arg1] "{$4}" (arg1),
           [arg2] "{$5}" (arg2),
@@ -123,20 +111,20 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
 
 pub fn syscall6(
     number: SYS,
-    arg1: usize,
-    arg2: usize,
-    arg3: usize,
-    arg4: usize,
-    arg5: usize,
-    arg6: usize,
-) usize {
+    arg1: u64,
+    arg2: u64,
+    arg3: u64,
+    arg4: u64,
+    arg5: u64,
+    arg6: u64,
+) u64 {
     return asm volatile (
         \\ syscall
         \\ beq $7, $zero, 1f
         \\ blez $2, 1f
         \\ dsubu $2, $0, $2
         \\ 1:
-        : [ret] "={$2}" (-> usize),
+        : [ret] "={$2}" (-> u64),
         : [number] "{$2}" (@intFromEnum(number)),
           [arg1] "{$4}" (arg1),
           [arg2] "{$5}" (arg2),
@@ -149,21 +137,21 @@ pub fn syscall6(
 
 pub fn syscall7(
     number: SYS,
-    arg1: usize,
-    arg2: usize,
-    arg3: usize,
-    arg4: usize,
-    arg5: usize,
-    arg6: usize,
-    arg7: usize,
-) usize {
+    arg1: u64,
+    arg2: u64,
+    arg3: u64,
+    arg4: u64,
+    arg5: u64,
+    arg6: u64,
+    arg7: u64,
+) u64 {
     return asm volatile (
         \\ syscall
         \\ beq $7, $zero, 1f
         \\ blez $2, 1f
         \\ dsubu $2, $0, $2
         \\ 1:
-        : [ret] "={$2}" (-> usize),
+        : [ret] "={$2}" (-> u64),
         : [number] "{$2}" (@intFromEnum(number)),
           [arg1] "{$4}" (arg1),
           [arg2] "{$5}" (arg2),
@@ -175,7 +163,7 @@ pub fn syscall7(
         : .{ .r1 = true, .r3 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r24 = true, .r25 = true, .hi = true, .lo = true, .memory = true });
 }
 
-pub fn clone() callconv(.naked) usize {
+pub fn clone() callconv(.naked) u64 {
     // __clone(func, stack, flags, arg, ptid, tls, ctid)
     //         3,    4,     5,     6,   7,    8,   9
     //
@@ -222,47 +210,11 @@ pub fn clone() callconv(.naked) usize {
     );
 }
 
-pub const F = struct {
-    pub const DUPFD = 0;
-    pub const GETFD = 1;
-    pub const SETFD = 2;
-    pub const GETFL = 3;
-    pub const SETFL = 4;
-
-    pub const SETOWN = 24;
-    pub const GETOWN = 23;
-    pub const SETSIG = 10;
-    pub const GETSIG = 11;
-
-    pub const GETLK = 33;
-    pub const SETLK = 34;
-    pub const SETLKW = 35;
-
-    pub const RDLCK = 0;
-    pub const WRLCK = 1;
-    pub const UNLCK = 2;
-
-    pub const SETOWN_EX = 15;
-    pub const GETOWN_EX = 16;
-
-    pub const GETOWNER_UIDS = 17;
-};
-
 pub const VDSO = struct {
     pub const CGT_SYM = "__vdso_clock_gettime";
     pub const CGT_VER = "LINUX_2.6";
 };
 
-pub const Flock = extern struct {
-    type: i16,
-    whence: i16,
-    __pad0: [4]u8,
-    start: off_t,
-    len: off_t,
-    pid: pid_t,
-    __unused: [4]u8,
-};
-
 pub const blksize_t = u32;
 pub const nlink_t = u32;
 pub const time_t = i32;
@@ -279,8 +231,8 @@ pub const Stat = extern struct {
     ino: ino_t,
     mode: mode_t,
     nlink: nlink_t,
-    uid: uid_t,
-    gid: gid_t,
+    uid: std.os.linux.uid_t,
+    gid: std.os.linux.gid_t,
     rdev: dev_t,
     __pad1: [2]u32, // -1 because our dev_t is u64 (kernel dev_t is really u32).
     size: off_t,
@@ -294,36 +246,24 @@ pub const Stat = extern struct {
     __pad3: u32,
     blocks: blkcnt_t,
 
-    pub fn atime(self: @This()) timespec {
+    pub fn atime(self: @This()) std.os.linux.timespec {
         return .{
             .sec = self.atim,
             .nsec = self.atim_nsec,
         };
     }
 
-    pub fn mtime(self: @This()) timespec {
+    pub fn mtime(self: @This()) std.os.linux.timespec {
         return .{
             .sec = self.mtim,
             .nsec = self.mtim_nsec,
         };
     }
 
-    pub fn ctime(self: @This()) timespec {
+    pub fn ctime(self: @This()) std.os.linux.timespec {
         return .{
             .sec = self.ctim,
             .nsec = self.ctim_nsec,
         };
     }
 };
-
-pub const timeval = extern struct {
-    sec: isize,
-    usec: isize,
-};
-
-pub const timezone = extern struct {
-    minuteswest: i32,
-    dsttime: i32,
-};
-
-pub const Elf_Symndx = u32;
diff --git a/lib/std/os/linux/mipsn32.zig b/lib/std/os/linux/mipsn32.zig
new file mode 100644
index 000000000000..59a4cf0549fa
--- /dev/null
+++ b/lib/std/os/linux/mipsn32.zig
@@ -0,0 +1,271 @@
+// TODO: A lot of this file is very likely wrong.
+
+const builtin = @import("builtin");
+const std = @import("../../std.zig");
+const SYS = std.os.linux.SYS;
+
+pub fn syscall0(number: SYS) u32 {
+    return asm volatile (
+        \\ syscall
+        \\ beq $7, $zero, 1f
+        \\ blez $2, 1f
+        \\ dsubu $2, $0, $2
+        \\ 1:
+        : [ret] "={$2}" (-> u32),
+        : [number] "{$2}" (@intFromEnum(number)),
+        : .{ .r1 = true, .r3 = true, .r4 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r24 = true, .r25 = true, .hi = true, .lo = true, .memory = true });
+}
+
+pub fn syscall_pipe(fd: *[2]i32) u32 {
+    return asm volatile (
+        \\ .set noat
+        \\ .set noreorder
+        \\ syscall
+        \\ beq $7, $zero, 1f
+        \\ nop
+        \\ b 2f
+        \\ subu $2, $0, $2
+        \\ 1:
+        \\ sw $2, 0($4)
+        \\ sw $3, 4($4)
+        \\ 2:
+        : [ret] "={$2}" (-> u32),
+        : [number] "{$2}" (@intFromEnum(SYS.pipe)),
+          [fd] "{$4}" (fd),
+        : .{ .r1 = true, .r3 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r24 = true, .r25 = true, .hi = true, .lo = true, .memory = true });
+}
+
+pub fn syscall1(number: SYS, arg1: u32) u32 {
+    return asm volatile (
+        \\ syscall
+        \\ beq $7, $zero, 1f
+        \\ blez $2, 1f
+        \\ nop
+        \\ dsubu $2, $0, $2
+        \\ 1:
+        : [ret] "={$2}" (-> u32),
+        : [number] "{$2}" (@intFromEnum(number)),
+          [arg1] "{$4}" (arg1),
+        : .{ .r1 = true, .r3 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r24 = true, .r25 = true, .hi = true, .lo = true, .memory = true });
+}
+
+pub fn syscall2(number: SYS, arg1: u32, arg2: u32) u32 {
+    return asm volatile (
+        \\ syscall
+        \\ beq $7, $zero, 1f
+        \\ blez $2, 1f
+        \\ dsubu $2, $0, $2
+        \\ 1:
+        : [ret] "={$2}" (-> u32),
+        : [number] "{$2}" (@intFromEnum(number)),
+          [arg1] "{$4}" (arg1),
+          [arg2] "{$5}" (arg2),
+        : .{ .r1 = true, .r3 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r24 = true, .r25 = true, .hi = true, .lo = true, .memory = true });
+}
+
+pub fn syscall3(number: SYS, arg1: u32, arg2: u32, arg3: u32) u32 {
+    return asm volatile (
+        \\ syscall
+        \\ beq $7, $zero, 1f
+        \\ blez $2, 1f
+        \\ dsubu $2, $0, $2
+        \\ 1:
+        : [ret] "={$2}" (-> u32),
+        : [number] "{$2}" (@intFromEnum(number)),
+          [arg1] "{$4}" (arg1),
+          [arg2] "{$5}" (arg2),
+          [arg3] "{$6}" (arg3),
+        : .{ .r1 = true, .r3 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r24 = true, .r25 = true, .hi = true, .lo = true, .memory = true });
+}
+
+pub fn syscall4(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32) u32 {
+    return asm volatile (
+        \\ syscall
+        \\ beq $7, $zero, 1f
+        \\ blez $2, 1f
+        \\ dsubu $2, $0, $2
+        \\ 1:
+        : [ret] "={$2}" (-> u32),
+        : [number] "{$2}" (@intFromEnum(number)),
+          [arg1] "{$4}" (arg1),
+          [arg2] "{$5}" (arg2),
+          [arg3] "{$6}" (arg3),
+          [arg4] "{$7}" (arg4),
+        : .{ .r1 = true, .r3 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r24 = true, .r25 = true, .hi = true, .lo = true, .memory = true });
+}
+
+pub fn syscall5(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32, arg5: u32) u32 {
+    return asm volatile (
+        \\ syscall
+        \\ beq $7, $zero, 1f
+        \\ blez $2, 1f
+        \\ dsubu $2, $0, $2
+        \\ 1:
+        : [ret] "={$2}" (-> u32),
+        : [number] "{$2}" (@intFromEnum(number)),
+          [arg1] "{$4}" (arg1),
+          [arg2] "{$5}" (arg2),
+          [arg3] "{$6}" (arg3),
+          [arg4] "{$7}" (arg4),
+          [arg5] "{$8}" (arg5),
+        : .{ .r1 = true, .r3 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r24 = true, .r25 = true, .hi = true, .lo = true, .memory = true });
+}
+
+pub fn syscall6(
+    number: SYS,
+    arg1: u32,
+    arg2: u32,
+    arg3: u32,
+    arg4: u32,
+    arg5: u32,
+    arg6: u32,
+) u32 {
+    return asm volatile (
+        \\ syscall
+        \\ beq $7, $zero, 1f
+        \\ blez $2, 1f
+        \\ dsubu $2, $0, $2
+        \\ 1:
+        : [ret] "={$2}" (-> u32),
+        : [number] "{$2}" (@intFromEnum(number)),
+          [arg1] "{$4}" (arg1),
+          [arg2] "{$5}" (arg2),
+          [arg3] "{$6}" (arg3),
+          [arg4] "{$7}" (arg4),
+          [arg5] "{$8}" (arg5),
+          [arg6] "{$9}" (arg6),
+        : .{ .r1 = true, .r3 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r24 = true, .r25 = true, .hi = true, .lo = true, .memory = true });
+}
+
+pub fn syscall7(
+    number: SYS,
+    arg1: u32,
+    arg2: u32,
+    arg3: u32,
+    arg4: u32,
+    arg5: u32,
+    arg6: u32,
+    arg7: u32,
+) u32 {
+    return asm volatile (
+        \\ syscall
+        \\ beq $7, $zero, 1f
+        \\ blez $2, 1f
+        \\ dsubu $2, $0, $2
+        \\ 1:
+        : [ret] "={$2}" (-> u32),
+        : [number] "{$2}" (@intFromEnum(number)),
+          [arg1] "{$4}" (arg1),
+          [arg2] "{$5}" (arg2),
+          [arg3] "{$6}" (arg3),
+          [arg4] "{$7}" (arg4),
+          [arg5] "{$8}" (arg5),
+          [arg6] "{$9}" (arg6),
+          [arg7] "{$10}" (arg7),
+        : .{ .r1 = true, .r3 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r24 = true, .r25 = true, .hi = true, .lo = true, .memory = true });
+}
+
+pub fn clone() callconv(.naked) u32 {
+    // __clone(func, stack, flags, arg, ptid, tls, ctid)
+    //         3,    4,     5,     6,   7,    8,   9
+    //
+    // syscall(SYS_clone, flags, stack, ptid, tls, ctid)
+    //         2          4,     5,     6,    7,   8
+    asm volatile (
+        \\ # Save function pointer and argument pointer on new thread stack
+        \\ and $5, $5, -16
+        \\ dsubu $5, $5, 16
+        \\ sd $4, 0($5)
+        \\ sd $7, 8($5)
+        \\ # Shuffle (fn,sp,fl,arg,ptid,tls,ctid) to (fl,sp,ptid,tls,ctid)
+        \\ move $4, $6
+        \\ move $6, $8
+        \\ move $7, $9
+        \\ move $8, $10
+        \\ li $2, 5055 # SYS_clone
+        \\ syscall
+        \\ beq $7, $0, 1f
+        \\ nop
+        \\ jr $ra
+        \\ dsubu $2, $0, $2
+        \\1:
+        \\ beq $2, $0, 1f
+        \\ nop
+        \\ jr $ra
+        \\ nop
+        \\1:
+    );
+    if (builtin.unwind_tables != .none or !builtin.strip_debug_info) asm volatile (
+        \\ .cfi_undefined $ra
+    );
+    asm volatile (
+        \\ move $fp, $zero
+        \\ move $ra, $zero
+        \\
+        \\ ld $25, 0($sp)
+        \\ ld $4, 8($sp)
+        \\ jalr $25
+        \\ nop
+        \\ move $4, $2
+        \\ li $2, 5058 # SYS_exit
+        \\ syscall
+    );
+}
+
+pub const VDSO = struct {
+    pub const CGT_SYM = "__vdso_clock_gettime";
+    pub const CGT_VER = "LINUX_2.6";
+};
+
+pub const blksize_t = u32;
+pub const nlink_t = u32;
+pub const time_t = i32;
+pub const mode_t = u32;
+pub const off_t = i64;
+pub const ino_t = u64;
+pub const dev_t = u64;
+pub const blkcnt_t = i64;
+
+// The `stat` definition used by the Linux kernel.
+pub const Stat = extern struct {
+    dev: dev_t,
+    __pad0: [2]u32, // -1 because our dev_t is u64 (kernel dev_t is really u32).
+    ino: ino_t,
+    mode: mode_t,
+    nlink: nlink_t,
+    uid: std.os.linux.uid_t,
+    gid: std.os.linux.gid_t,
+    rdev: dev_t,
+    __pad1: [2]u32, // -1 because our dev_t is u64 (kernel dev_t is really u32).
+    size: off_t,
+    atim: u32,
+    atim_nsec: u32,
+    mtim: u32,
+    mtim_nsec: u32,
+    ctim: u32,
+    ctim_nsec: u32,
+    blksize: blksize_t,
+    __pad3: u32,
+    blocks: blkcnt_t,
+
+    pub fn atime(self: @This()) std.os.linux.timespec {
+        return .{
+            .sec = self.atim,
+            .nsec = self.atim_nsec,
+        };
+    }
+
+    pub fn mtime(self: @This()) std.os.linux.timespec {
+        return .{
+            .sec = self.mtim,
+            .nsec = self.mtim_nsec,
+        };
+    }
+
+    pub fn ctime(self: @This()) std.os.linux.timespec {
+        return .{
+            .sec = self.ctim,
+            .nsec = self.ctim_nsec,
+        };
+    }
+};
diff --git a/lib/std/os/linux/powerpc.zig b/lib/std/os/linux/powerpc.zig
index c96a8a080459..46197d908523 100644
--- a/lib/std/os/linux/powerpc.zig
+++ b/lib/std/os/linux/powerpc.zig
@@ -1,61 +1,49 @@
 const builtin = @import("builtin");
 const std = @import("../../std.zig");
-const maxInt = std.math.maxInt;
-const linux = std.os.linux;
-const SYS = linux.SYS;
-const socklen_t = linux.socklen_t;
-const iovec = std.posix.iovec;
-const iovec_const = std.posix.iovec_const;
-const uid_t = linux.uid_t;
-const gid_t = linux.gid_t;
-const pid_t = linux.pid_t;
-const stack_t = linux.stack_t;
-const sigset_t = linux.sigset_t;
-const sockaddr = linux.sockaddr;
-const timespec = linux.timespec;
+const SYS = std.os.linux.SYS;
 
-pub fn syscall0(number: SYS) usize {
+pub fn syscall0(number: SYS) u32 {
     // r0 is both an input register and a clobber. musl and glibc achieve this with
     // a "+" constraint, which isn't supported in Zig, so instead we separately list
     // r0 as both an input and an output. (Listing it as an input and a clobber would
     // cause the C backend to emit invalid code; see #25209.)
-    var r0_out: usize = undefined;
+    var r0_out: u32 = undefined;
     return asm volatile (
         \\ sc
         \\ bns+ 1f
         \\ neg 3, 3
         \\ 1:
-        : [ret] "={r3}" (-> usize),
+        : [ret] "={r3}" (-> u32),
           [r0_out] "={r0}" (r0_out),
         : [number] "{r0}" (@intFromEnum(number)),
         : .{ .memory = true, .cr0 = true, .r4 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .ctr = true, .xer = true });
 }
 
-pub fn syscall1(number: SYS, arg1: usize) usize {
+pub fn syscall1(number: SYS, arg1: u32) u32 {
     // r0 is both an input and a clobber.
-    var r0_out: usize = undefined;
+    var r0_out: u32 = undefined;
     return asm volatile (
         \\ sc
         \\ bns+ 1f
         \\ neg 3, 3
         \\ 1:
-        : [ret] "={r3}" (-> usize),
+        : [ret] "={r3}" (-> u32),
           [r0_out] "={r0}" (r0_out),
         : [number] "{r0}" (@intFromEnum(number)),
           [arg1] "{r3}" (arg1),
         : .{ .memory = true, .cr0 = true, .r4 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .ctr = true, .xer = true });
 }
 
-pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
+pub fn syscall2(number: SYS, arg1: u32, arg2: u32) u32 {
     // These registers are both inputs and clobbers.
-    var r0_out: usize = undefined;
-    var r4_out: usize = undefined;
+    var r0_out: u32 = undefined;
+    var r4_out: u32 = undefined;
     return asm volatile (
         \\ sc
         \\ bns+ 1f
         \\ neg 3, 3
         \\ 1:
-        : [ret] "={r3}" (-> usize),
+        : [ret] "={r3}" (-> u32),
           [r0_out] "={r0}" (r0_out),
           [r4_out] "={r4}" (r4_out),
         : [number] "{r0}" (@intFromEnum(number)),
@@ -64,17 +52,17 @@ pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
         : .{ .memory = true, .cr0 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .ctr = true, .xer = true });
 }
 
-pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
+pub fn syscall3(number: SYS, arg1: u32, arg2: u32, arg3: u32) u32 {
     // These registers are both inputs and clobbers.
-    var r0_out: usize = undefined;
-    var r4_out: usize = undefined;
-    var r5_out: usize = undefined;
+    var r0_out: u32 = undefined;
+    var r4_out: u32 = undefined;
+    var r5_out: u32 = undefined;
     return asm volatile (
         \\ sc
         \\ bns+ 1f
         \\ neg 3, 3
         \\ 1:
-        : [ret] "={r3}" (-> usize),
+        : [ret] "={r3}" (-> u32),
           [r0_out] "={r0}" (r0_out),
           [r4_out] "={r4}" (r4_out),
           [r5_out] "={r5}" (r5_out),
@@ -85,18 +73,18 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
         : .{ .memory = true, .cr0 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .ctr = true, .xer = true });
 }
 
-pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize {
+pub fn syscall4(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32) u32 {
     // These registers are both inputs and clobbers.
-    var r0_out: usize = undefined;
-    var r4_out: usize = undefined;
-    var r5_out: usize = undefined;
-    var r6_out: usize = undefined;
+    var r0_out: u32 = undefined;
+    var r4_out: u32 = undefined;
+    var r5_out: u32 = undefined;
+    var r6_out: u32 = undefined;
     return asm volatile (
         \\ sc
         \\ bns+ 1f
         \\ neg 3, 3
         \\ 1:
-        : [ret] "={r3}" (-> usize),
+        : [ret] "={r3}" (-> u32),
           [r0_out] "={r0}" (r0_out),
           [r4_out] "={r4}" (r4_out),
           [r5_out] "={r5}" (r5_out),
@@ -109,19 +97,19 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)
         : .{ .memory = true, .cr0 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .ctr = true, .xer = true });
 }
 
-pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize {
+pub fn syscall5(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32, arg5: u32) u32 {
     // These registers are both inputs and clobbers.
-    var r0_out: usize = undefined;
-    var r4_out: usize = undefined;
-    var r5_out: usize = undefined;
-    var r6_out: usize = undefined;
-    var r7_out: usize = undefined;
+    var r0_out: u32 = undefined;
+    var r4_out: u32 = undefined;
+    var r5_out: u32 = undefined;
+    var r6_out: u32 = undefined;
+    var r7_out: u32 = undefined;
     return asm volatile (
         \\ sc
         \\ bns+ 1f
         \\ neg 3, 3
         \\ 1:
-        : [ret] "={r3}" (-> usize),
+        : [ret] "={r3}" (-> u32),
           [r0_out] "={r0}" (r0_out),
           [r4_out] "={r4}" (r4_out),
           [r5_out] "={r5}" (r5_out),
@@ -138,26 +126,26 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
 
 pub fn syscall6(
     number: SYS,
-    arg1: usize,
-    arg2: usize,
-    arg3: usize,
-    arg4: usize,
-    arg5: usize,
-    arg6: usize,
-) usize {
+    arg1: u32,
+    arg2: u32,
+    arg3: u32,
+    arg4: u32,
+    arg5: u32,
+    arg6: u32,
+) u32 {
     // These registers are both inputs and clobbers.
-    var r0_out: usize = undefined;
-    var r4_out: usize = undefined;
-    var r5_out: usize = undefined;
-    var r6_out: usize = undefined;
-    var r7_out: usize = undefined;
-    var r8_out: usize = undefined;
+    var r0_out: u32 = undefined;
+    var r4_out: u32 = undefined;
+    var r5_out: u32 = undefined;
+    var r6_out: u32 = undefined;
+    var r7_out: u32 = undefined;
+    var r8_out: u32 = undefined;
     return asm volatile (
         \\ sc
         \\ bns+ 1f
         \\ neg 3, 3
         \\ 1:
-        : [ret] "={r3}" (-> usize),
+        : [ret] "={r3}" (-> u32),
           [r0_out] "={r0}" (r0_out),
           [r4_out] "={r4}" (r4_out),
           [r5_out] "={r5}" (r5_out),
@@ -174,7 +162,7 @@ pub fn syscall6(
         : .{ .memory = true, .cr0 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .ctr = true, .xer = true });
 }
 
-pub fn clone() callconv(.naked) usize {
+pub fn clone() callconv(.naked) u32 {
     // __clone(func, stack, flags, arg, ptid, tls, ctid)
     //         3,    4,     5,     6,   7,    8,   9
     //
@@ -247,14 +235,14 @@ pub fn clone() callconv(.naked) usize {
 pub const restore = restore_rt;
 
 pub fn restore_rt() callconv(.naked) noreturn {
-    switch (@import("builtin").zig_backend) {
+    switch (builtin.zig_backend) {
         .stage2_c => asm volatile (
             \\ li 0, %[number]
             \\ sc
             :
             : [number] "i" (@intFromEnum(SYS.rt_sigreturn)),
         ),
-        else => _ = asm volatile (
+        else => asm volatile (
             \\ sc
             :
             : [number] "{r0}" (@intFromEnum(SYS.rt_sigreturn)),
@@ -262,48 +250,14 @@ pub fn restore_rt() callconv(.naked) noreturn {
     }
 }
 
-pub const F = struct {
-    pub const DUPFD = 0;
-    pub const GETFD = 1;
-    pub const SETFD = 2;
-    pub const GETFL = 3;
-    pub const SETFL = 4;
-
-    pub const SETOWN = 8;
-    pub const GETOWN = 9;
-    pub const SETSIG = 10;
-    pub const GETSIG = 11;
-
-    pub const GETLK = 12;
-    pub const SETLK = 13;
-    pub const SETLKW = 14;
-
-    pub const SETOWN_EX = 15;
-    pub const GETOWN_EX = 16;
-
-    pub const GETOWNER_UIDS = 17;
-
-    pub const RDLCK = 0;
-    pub const WRLCK = 1;
-    pub const UNLCK = 2;
-};
-
 pub const VDSO = struct {
     pub const CGT_SYM = "__kernel_clock_gettime";
     pub const CGT_VER = "LINUX_2.6.15";
 };
 
-pub const Flock = extern struct {
-    type: i16,
-    whence: i16,
-    start: off_t,
-    len: off_t,
-    pid: pid_t,
-};
-
 pub const blksize_t = i32;
 pub const nlink_t = u32;
-pub const time_t = isize;
+pub const time_t = i32;
 pub const mode_t = u32;
 pub const off_t = i64;
 pub const ino_t = u64;
@@ -316,39 +270,27 @@ pub const Stat = extern struct {
     ino: ino_t,
     mode: mode_t,
     nlink: nlink_t,
-    uid: uid_t,
-    gid: gid_t,
+    uid: std.os.linux.uid_t,
+    gid: std.os.linux.gid_t,
     rdev: dev_t,
     __rdev_padding: i16,
     size: off_t,
     blksize: blksize_t,
     blocks: blkcnt_t,
-    atim: timespec,
-    mtim: timespec,
-    ctim: timespec,
+    atim: std.os.linux.timespec,
+    mtim: std.os.linux.timespec,
+    ctim: std.os.linux.timespec,
     __unused: [2]u32,
 
-    pub fn atime(self: @This()) timespec {
+    pub fn atime(self: @This()) std.os.linux.timespec {
         return self.atim;
     }
 
-    pub fn mtime(self: @This()) timespec {
+    pub fn mtime(self: @This()) std.os.linux.timespec {
         return self.mtim;
     }
 
-    pub fn ctime(self: @This()) timespec {
+    pub fn ctime(self: @This()) std.os.linux.timespec {
         return self.ctim;
     }
 };
-
-pub const timeval = extern struct {
-    sec: time_t,
-    usec: isize,
-};
-
-pub const timezone = extern struct {
-    minuteswest: i32,
-    dsttime: i32,
-};
-
-pub const Elf_Symndx = u32;
diff --git a/lib/std/os/linux/powerpc64.zig b/lib/std/os/linux/powerpc64.zig
index 5b1af7cc2be4..6ff666910f61 100644
--- a/lib/std/os/linux/powerpc64.zig
+++ b/lib/std/os/linux/powerpc64.zig
@@ -1,61 +1,49 @@
 const builtin = @import("builtin");
 const std = @import("../../std.zig");
-const maxInt = std.math.maxInt;
-const linux = std.os.linux;
-const SYS = linux.SYS;
-const socklen_t = linux.socklen_t;
-const iovec = std.posix.iovec;
-const iovec_const = std.posix.iovec_const;
-const uid_t = linux.uid_t;
-const gid_t = linux.gid_t;
-const pid_t = linux.pid_t;
-const stack_t = linux.stack_t;
-const sigset_t = linux.sigset_t;
-const sockaddr = linux.sockaddr;
-const timespec = linux.timespec;
+const SYS = std.os.linux.SYS;
 
-pub fn syscall0(number: SYS) usize {
+pub fn syscall0(number: SYS) u64 {
     // r0 is both an input register and a clobber. musl and glibc achieve this with
     // a "+" constraint, which isn't supported in Zig, so instead we separately list
     // r0 as both an input and an output. (Listing it as an input and a clobber would
     // cause the C backend to emit invalid code; see #25209.)
-    var r0_out: usize = undefined;
+    var r0_out: u64 = undefined;
     return asm volatile (
         \\ sc
         \\ bns+ 1f
         \\ neg 3, 3
         \\ 1:
-        : [ret] "={r3}" (-> usize),
+        : [ret] "={r3}" (-> u64),
           [r0_out] "={r0}" (r0_out),
         : [number] "{r0}" (@intFromEnum(number)),
         : .{ .memory = true, .cr0 = true, .r4 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .ctr = true, .xer = true });
 }
 
-pub fn syscall1(number: SYS, arg1: usize) usize {
+pub fn syscall1(number: SYS, arg1: u64) u64 {
     // r0 is both an input and a clobber.
-    var r0_out: usize = undefined;
+    var r0_out: u64 = undefined;
     return asm volatile (
         \\ sc
         \\ bns+ 1f
         \\ neg 3, 3
         \\ 1:
-        : [ret] "={r3}" (-> usize),
+        : [ret] "={r3}" (-> u64),
           [r0_out] "={r0}" (r0_out),
         : [number] "{r0}" (@intFromEnum(number)),
           [arg1] "{r3}" (arg1),
         : .{ .memory = true, .cr0 = true, .r4 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .ctr = true, .xer = true });
 }
 
-pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
+pub fn syscall2(number: SYS, arg1: u64, arg2: u64) u64 {
     // These registers are both inputs and clobbers.
-    var r0_out: usize = undefined;
-    var r4_out: usize = undefined;
+    var r0_out: u64 = undefined;
+    var r4_out: u64 = undefined;
     return asm volatile (
         \\ sc
         \\ bns+ 1f
         \\ neg 3, 3
         \\ 1:
-        : [ret] "={r3}" (-> usize),
+        : [ret] "={r3}" (-> u64),
           [r0_out] "={r0}" (r0_out),
           [r4_out] "={r4}" (r4_out),
         : [number] "{r0}" (@intFromEnum(number)),
@@ -64,17 +52,17 @@ pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
         : .{ .memory = true, .cr0 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .ctr = true, .xer = true });
 }
 
-pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
+pub fn syscall3(number: SYS, arg1: u64, arg2: u64, arg3: u64) u64 {
     // These registers are both inputs and clobbers.
-    var r0_out: usize = undefined;
-    var r4_out: usize = undefined;
-    var r5_out: usize = undefined;
+    var r0_out: u64 = undefined;
+    var r4_out: u64 = undefined;
+    var r5_out: u64 = undefined;
     return asm volatile (
         \\ sc
         \\ bns+ 1f
         \\ neg 3, 3
         \\ 1:
-        : [ret] "={r3}" (-> usize),
+        : [ret] "={r3}" (-> u64),
           [r0_out] "={r0}" (r0_out),
           [r4_out] "={r4}" (r4_out),
           [r5_out] "={r5}" (r5_out),
@@ -85,18 +73,18 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
         : .{ .memory = true, .cr0 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .ctr = true, .xer = true });
 }
 
-pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize {
+pub fn syscall4(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64) u64 {
     // These registers are both inputs and clobbers.
-    var r0_out: usize = undefined;
-    var r4_out: usize = undefined;
-    var r5_out: usize = undefined;
-    var r6_out: usize = undefined;
+    var r0_out: u64 = undefined;
+    var r4_out: u64 = undefined;
+    var r5_out: u64 = undefined;
+    var r6_out: u64 = undefined;
     return asm volatile (
         \\ sc
         \\ bns+ 1f
         \\ neg 3, 3
         \\ 1:
-        : [ret] "={r3}" (-> usize),
+        : [ret] "={r3}" (-> u64),
           [r0_out] "={r0}" (r0_out),
           [r4_out] "={r4}" (r4_out),
           [r5_out] "={r5}" (r5_out),
@@ -109,19 +97,19 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)
         : .{ .memory = true, .cr0 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .ctr = true, .xer = true });
 }
 
-pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize {
+pub fn syscall5(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64, arg5: u64) u64 {
     // These registers are both inputs and clobbers.
-    var r0_out: usize = undefined;
-    var r4_out: usize = undefined;
-    var r5_out: usize = undefined;
-    var r6_out: usize = undefined;
-    var r7_out: usize = undefined;
+    var r0_out: u64 = undefined;
+    var r4_out: u64 = undefined;
+    var r5_out: u64 = undefined;
+    var r6_out: u64 = undefined;
+    var r7_out: u64 = undefined;
     return asm volatile (
         \\ sc
         \\ bns+ 1f
         \\ neg 3, 3
         \\ 1:
-        : [ret] "={r3}" (-> usize),
+        : [ret] "={r3}" (-> u64),
           [r0_out] "={r0}" (r0_out),
           [r4_out] "={r4}" (r4_out),
           [r5_out] "={r5}" (r5_out),
@@ -138,26 +126,26 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
 
 pub fn syscall6(
     number: SYS,
-    arg1: usize,
-    arg2: usize,
-    arg3: usize,
-    arg4: usize,
-    arg5: usize,
-    arg6: usize,
-) usize {
+    arg1: u64,
+    arg2: u64,
+    arg3: u64,
+    arg4: u64,
+    arg5: u64,
+    arg6: u64,
+) u64 {
     // These registers are both inputs and clobbers.
-    var r0_out: usize = undefined;
-    var r4_out: usize = undefined;
-    var r5_out: usize = undefined;
-    var r6_out: usize = undefined;
-    var r7_out: usize = undefined;
-    var r8_out: usize = undefined;
+    var r0_out: u64 = undefined;
+    var r4_out: u64 = undefined;
+    var r5_out: u64 = undefined;
+    var r6_out: u64 = undefined;
+    var r7_out: u64 = undefined;
+    var r8_out: u64 = undefined;
     return asm volatile (
         \\ sc
         \\ bns+ 1f
         \\ neg 3, 3
         \\ 1:
-        : [ret] "={r3}" (-> usize),
+        : [ret] "={r3}" (-> u64),
           [r0_out] "={r0}" (r0_out),
           [r4_out] "={r4}" (r4_out),
           [r5_out] "={r5}" (r5_out),
@@ -174,7 +162,7 @@ pub fn syscall6(
         : .{ .memory = true, .cr0 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .ctr = true, .xer = true });
 }
 
-pub fn clone() callconv(.naked) usize {
+pub fn clone() callconv(.naked) u64 {
     // __clone(func, stack, flags, arg, ptid, tls, ctid)
     //         3,    4,     5,     6,   7,    8,   9
     //
@@ -232,14 +220,14 @@ pub fn clone() callconv(.naked) usize {
 pub const restore = restore_rt;
 
 pub fn restore_rt() callconv(.naked) noreturn {
-    switch (@import("builtin").zig_backend) {
+    switch (builtin.zig_backend) {
         .stage2_c => asm volatile (
             \\ li 0, %[number]
             \\ sc
             :
             : [number] "i" (@intFromEnum(SYS.rt_sigreturn)),
         ),
-        else => _ = asm volatile (
+        else => asm volatile (
             \\ sc
             :
             : [number] "{r0}" (@intFromEnum(SYS.rt_sigreturn)),
@@ -247,46 +235,11 @@ pub fn restore_rt() callconv(.naked) noreturn {
     }
 }
 
-pub const F = struct {
-    pub const DUPFD = 0;
-    pub const GETFD = 1;
-    pub const SETFD = 2;
-    pub const GETFL = 3;
-    pub const SETFL = 4;
-
-    pub const SETOWN = 8;
-    pub const GETOWN = 9;
-    pub const SETSIG = 10;
-    pub const GETSIG = 11;
-
-    pub const GETLK = 5;
-    pub const SETLK = 6;
-    pub const SETLKW = 7;
-
-    pub const RDLCK = 0;
-    pub const WRLCK = 1;
-    pub const UNLCK = 2;
-
-    pub const SETOWN_EX = 15;
-    pub const GETOWN_EX = 16;
-
-    pub const GETOWNER_UIDS = 17;
-};
-
 pub const VDSO = struct {
     pub const CGT_SYM = "__kernel_clock_gettime";
     pub const CGT_VER = "LINUX_2.6.15";
 };
 
-pub const Flock = extern struct {
-    type: i16,
-    whence: i16,
-    start: off_t,
-    len: off_t,
-    pid: pid_t,
-    __unused: [4]u8,
-};
-
 pub const blksize_t = i64;
 pub const nlink_t = u64;
 pub const time_t = i64;
@@ -302,38 +255,26 @@ pub const Stat = extern struct {
     ino: ino_t,
     nlink: nlink_t,
     mode: mode_t,
-    uid: uid_t,
-    gid: gid_t,
+    uid: std.os.linux.uid_t,
+    gid: std.os.linux.gid_t,
     rdev: dev_t,
     size: off_t,
     blksize: blksize_t,
     blocks: blkcnt_t,
-    atim: timespec,
-    mtim: timespec,
-    ctim: timespec,
+    atim: std.os.linux.timespec,
+    mtim: std.os.linux.timespec,
+    ctim: std.os.linux.timespec,
     __unused: [3]u64,
 
-    pub fn atime(self: @This()) timespec {
+    pub fn atime(self: @This()) std.os.linux.timespec {
         return self.atim;
     }
 
-    pub fn mtime(self: @This()) timespec {
+    pub fn mtime(self: @This()) std.os.linux.timespec {
         return self.mtim;
     }
 
-    pub fn ctime(self: @This()) timespec {
+    pub fn ctime(self: @This()) std.os.linux.timespec {
         return self.ctim;
     }
 };
-
-pub const timeval = extern struct {
-    sec: isize,
-    usec: isize,
-};
-
-pub const timezone = extern struct {
-    minuteswest: i32,
-    dsttime: i32,
-};
-
-pub const Elf_Symndx = u32;
diff --git a/lib/std/os/linux/riscv32.zig b/lib/std/os/linux/riscv32.zig
index a0f73adeefd9..34f73506a1ab 100644
--- a/lib/std/os/linux/riscv32.zig
+++ b/lib/std/os/linux/riscv32.zig
@@ -1,45 +1,34 @@
 const builtin = @import("builtin");
 const std = @import("../../std.zig");
-const iovec = std.posix.iovec;
-const iovec_const = std.posix.iovec_const;
-const linux = std.os.linux;
-const SYS = linux.SYS;
-const uid_t = std.os.linux.uid_t;
-const gid_t = std.os.linux.gid_t;
-const pid_t = std.os.linux.pid_t;
-const stack_t = linux.stack_t;
-const sigset_t = linux.sigset_t;
-const sockaddr = linux.sockaddr;
-const socklen_t = linux.socklen_t;
-const timespec = std.os.linux.timespec;
+const SYS = std.os.linux.SYS;
 
-pub fn syscall0(number: SYS) usize {
+pub fn syscall0(number: SYS) u32 {
     return asm volatile ("ecall"
-        : [ret] "={x10}" (-> usize),
+        : [ret] "={x10}" (-> u32),
         : [number] "{x17}" (@intFromEnum(number)),
         : .{ .memory = true });
 }
 
-pub fn syscall1(number: SYS, arg1: usize) usize {
+pub fn syscall1(number: SYS, arg1: u32) u32 {
     return asm volatile ("ecall"
-        : [ret] "={x10}" (-> usize),
+        : [ret] "={x10}" (-> u32),
         : [number] "{x17}" (@intFromEnum(number)),
           [arg1] "{x10}" (arg1),
         : .{ .memory = true });
 }
 
-pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
+pub fn syscall2(number: SYS, arg1: u32, arg2: u32) u32 {
     return asm volatile ("ecall"
-        : [ret] "={x10}" (-> usize),
+        : [ret] "={x10}" (-> u32),
         : [number] "{x17}" (@intFromEnum(number)),
           [arg1] "{x10}" (arg1),
           [arg2] "{x11}" (arg2),
         : .{ .memory = true });
 }
 
-pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
+pub fn syscall3(number: SYS, arg1: u32, arg2: u32, arg3: u32) u32 {
     return asm volatile ("ecall"
-        : [ret] "={x10}" (-> usize),
+        : [ret] "={x10}" (-> u32),
         : [number] "{x17}" (@intFromEnum(number)),
           [arg1] "{x10}" (arg1),
           [arg2] "{x11}" (arg2),
@@ -47,9 +36,9 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
         : .{ .memory = true });
 }
 
-pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize {
+pub fn syscall4(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32) u32 {
     return asm volatile ("ecall"
-        : [ret] "={x10}" (-> usize),
+        : [ret] "={x10}" (-> u32),
         : [number] "{x17}" (@intFromEnum(number)),
           [arg1] "{x10}" (arg1),
           [arg2] "{x11}" (arg2),
@@ -58,9 +47,9 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)
         : .{ .memory = true });
 }
 
-pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize {
+pub fn syscall5(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32, arg5: u32) u32 {
     return asm volatile ("ecall"
-        : [ret] "={x10}" (-> usize),
+        : [ret] "={x10}" (-> u32),
         : [number] "{x17}" (@intFromEnum(number)),
           [arg1] "{x10}" (arg1),
           [arg2] "{x11}" (arg2),
@@ -72,15 +61,15 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
 
 pub fn syscall6(
     number: SYS,
-    arg1: usize,
-    arg2: usize,
-    arg3: usize,
-    arg4: usize,
-    arg5: usize,
-    arg6: usize,
-) usize {
+    arg1: u32,
+    arg2: u32,
+    arg3: u32,
+    arg4: u32,
+    arg5: u32,
+    arg6: u32,
+) u32 {
     return asm volatile ("ecall"
-        : [ret] "={x10}" (-> usize),
+        : [ret] "={x10}" (-> u32),
         : [number] "{x17}" (@intFromEnum(number)),
           [arg1] "{x10}" (arg1),
           [arg2] "{x11}" (arg2),
@@ -91,7 +80,7 @@ pub fn syscall6(
         : .{ .memory = true });
 }
 
-pub fn clone() callconv(.naked) usize {
+pub fn clone() callconv(.naked) u32 {
     // __clone(func, stack, flags, arg, ptid, tls, ctid)
     //         a0,   a1,    a2,    a3,  a4,   a5,  a6
     //
@@ -135,30 +124,6 @@ pub fn clone() callconv(.naked) usize {
     );
 }
 
-pub const F = struct {
-    pub const DUPFD = 0;
-    pub const GETFD = 1;
-    pub const SETFD = 2;
-    pub const GETFL = 3;
-    pub const SETFL = 4;
-    pub const GETLK = 5;
-    pub const SETLK = 6;
-    pub const SETLKW = 7;
-    pub const SETOWN = 8;
-    pub const GETOWN = 9;
-    pub const SETSIG = 10;
-    pub const GETSIG = 11;
-
-    pub const RDLCK = 0;
-    pub const WRLCK = 1;
-    pub const UNLCK = 2;
-
-    pub const SETOWN_EX = 15;
-    pub const GETOWN_EX = 16;
-
-    pub const GETOWNER_UIDS = 17;
-};
-
 pub const blksize_t = i32;
 pub const nlink_t = u32;
 pub const time_t = i64;
@@ -168,54 +133,38 @@ pub const ino_t = u64;
 pub const dev_t = u64;
 pub const blkcnt_t = i64;
 
-pub const timeval = extern struct {
-    sec: time_t,
-    usec: i64,
-};
-
-pub const Flock = extern struct {
-    type: i16,
-    whence: i16,
-    start: off_t,
-    len: off_t,
-    pid: pid_t,
-    __unused: [4]u8,
-};
-
 // The `stat` definition used by the Linux kernel.
 pub const Stat = extern struct {
     dev: dev_t,
     ino: ino_t,
     mode: mode_t,
     nlink: nlink_t,
-    uid: uid_t,
-    gid: gid_t,
+    uid: std.os.linux.uid_t,
+    gid: std.os.linux.gid_t,
     rdev: dev_t,
-    __pad: usize,
+    __pad: u32,
     size: off_t,
     blksize: blksize_t,
     __pad2: i32,
     blocks: blkcnt_t,
-    atim: timespec,
-    mtim: timespec,
-    ctim: timespec,
+    atim: std.os.linux.timespec,
+    mtim: std.os.linux.timespec,
+    ctim: std.os.linux.timespec,
     __unused: [2]u32,
 
-    pub fn atime(self: @This()) timespec {
+    pub fn atime(self: @This()) std.os.linux.timespec {
         return self.atim;
     }
 
-    pub fn mtime(self: @This()) timespec {
+    pub fn mtime(self: @This()) std.os.linux.timespec {
         return self.mtim;
     }
 
-    pub fn ctime(self: @This()) timespec {
+    pub fn ctime(self: @This()) std.os.linux.timespec {
         return self.ctim;
     }
 };
 
-pub const Elf_Symndx = u32;
-
 pub const VDSO = struct {
     pub const CGT_SYM = "__vdso_clock_gettime";
     pub const CGT_VER = "LINUX_4.15";
diff --git a/lib/std/os/linux/riscv64.zig b/lib/std/os/linux/riscv64.zig
index 53316204513a..e404693df08e 100644
--- a/lib/std/os/linux/riscv64.zig
+++ b/lib/std/os/linux/riscv64.zig
@@ -1,45 +1,34 @@
 const builtin = @import("builtin");
 const std = @import("../../std.zig");
-const iovec = std.posix.iovec;
-const iovec_const = std.posix.iovec_const;
-const linux = std.os.linux;
-const SYS = linux.SYS;
-const uid_t = std.os.linux.uid_t;
-const gid_t = std.os.linux.gid_t;
-const pid_t = std.os.linux.pid_t;
-const stack_t = linux.stack_t;
-const sigset_t = linux.sigset_t;
-const sockaddr = linux.sockaddr;
-const socklen_t = linux.socklen_t;
-const timespec = std.os.linux.timespec;
+const SYS = std.os.linux.SYS;
 
-pub fn syscall0(number: SYS) usize {
+pub fn syscall0(number: SYS) u64 {
     return asm volatile ("ecall"
-        : [ret] "={x10}" (-> usize),
+        : [ret] "={x10}" (-> u64),
         : [number] "{x17}" (@intFromEnum(number)),
         : .{ .memory = true });
 }
 
-pub fn syscall1(number: SYS, arg1: usize) usize {
+pub fn syscall1(number: SYS, arg1: u64) u64 {
     return asm volatile ("ecall"
-        : [ret] "={x10}" (-> usize),
+        : [ret] "={x10}" (-> u64),
         : [number] "{x17}" (@intFromEnum(number)),
           [arg1] "{x10}" (arg1),
         : .{ .memory = true });
 }
 
-pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
+pub fn syscall2(number: SYS, arg1: u64, arg2: u64) u64 {
     return asm volatile ("ecall"
-        : [ret] "={x10}" (-> usize),
+        : [ret] "={x10}" (-> u64),
         : [number] "{x17}" (@intFromEnum(number)),
           [arg1] "{x10}" (arg1),
           [arg2] "{x11}" (arg2),
         : .{ .memory = true });
 }
 
-pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
+pub fn syscall3(number: SYS, arg1: u64, arg2: u64, arg3: u64) u64 {
     return asm volatile ("ecall"
-        : [ret] "={x10}" (-> usize),
+        : [ret] "={x10}" (-> u64),
         : [number] "{x17}" (@intFromEnum(number)),
           [arg1] "{x10}" (arg1),
           [arg2] "{x11}" (arg2),
@@ -47,9 +36,9 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
         : .{ .memory = true });
 }
 
-pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize {
+pub fn syscall4(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64) u64 {
     return asm volatile ("ecall"
-        : [ret] "={x10}" (-> usize),
+        : [ret] "={x10}" (-> u64),
         : [number] "{x17}" (@intFromEnum(number)),
           [arg1] "{x10}" (arg1),
           [arg2] "{x11}" (arg2),
@@ -58,9 +47,9 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)
         : .{ .memory = true });
 }
 
-pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize {
+pub fn syscall5(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64, arg5: u64) u64 {
     return asm volatile ("ecall"
-        : [ret] "={x10}" (-> usize),
+        : [ret] "={x10}" (-> u64),
         : [number] "{x17}" (@intFromEnum(number)),
           [arg1] "{x10}" (arg1),
           [arg2] "{x11}" (arg2),
@@ -72,15 +61,15 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
 
 pub fn syscall6(
     number: SYS,
-    arg1: usize,
-    arg2: usize,
-    arg3: usize,
-    arg4: usize,
-    arg5: usize,
-    arg6: usize,
-) usize {
+    arg1: u64,
+    arg2: u64,
+    arg3: u64,
+    arg4: u64,
+    arg5: u64,
+    arg6: u64,
+) u64 {
     return asm volatile ("ecall"
-        : [ret] "={x10}" (-> usize),
+        : [ret] "={x10}" (-> u64),
         : [number] "{x17}" (@intFromEnum(number)),
           [arg1] "{x10}" (arg1),
           [arg2] "{x11}" (arg2),
@@ -91,7 +80,7 @@ pub fn syscall6(
         : .{ .memory = true });
 }
 
-pub fn clone() callconv(.naked) usize {
+pub fn clone() callconv(.naked) u64 {
     // __clone(func, stack, flags, arg, ptid, tls, ctid)
     //         a0,   a1,    a2,    a3,  a4,   a5,  a6
     //
@@ -135,30 +124,6 @@ pub fn clone() callconv(.naked) usize {
     );
 }
 
-pub const F = struct {
-    pub const DUPFD = 0;
-    pub const GETFD = 1;
-    pub const SETFD = 2;
-    pub const GETFL = 3;
-    pub const SETFL = 4;
-    pub const GETLK = 5;
-    pub const SETLK = 6;
-    pub const SETLKW = 7;
-    pub const SETOWN = 8;
-    pub const GETOWN = 9;
-    pub const SETSIG = 10;
-    pub const GETSIG = 11;
-
-    pub const RDLCK = 0;
-    pub const WRLCK = 1;
-    pub const UNLCK = 2;
-
-    pub const SETOWN_EX = 15;
-    pub const GETOWN_EX = 16;
-
-    pub const GETOWNER_UIDS = 17;
-};
-
 pub const blksize_t = i32;
 pub const nlink_t = u32;
 pub const time_t = i64;
@@ -168,54 +133,38 @@ pub const ino_t = u64;
 pub const dev_t = u64;
 pub const blkcnt_t = i64;
 
-pub const timeval = extern struct {
-    sec: time_t,
-    usec: i64,
-};
-
-pub const Flock = extern struct {
-    type: i16,
-    whence: i16,
-    start: off_t,
-    len: off_t,
-    pid: pid_t,
-    __unused: [4]u8,
-};
-
 // The `stat` definition used by the Linux kernel.
 pub const Stat = extern struct {
     dev: dev_t,
     ino: ino_t,
     mode: mode_t,
     nlink: nlink_t,
-    uid: uid_t,
-    gid: gid_t,
+    uid: std.os.linux.uid_t,
+    gid: std.os.linux.gid_t,
     rdev: dev_t,
-    __pad: usize,
+    __pad: u64,
     size: off_t,
     blksize: blksize_t,
     __pad2: i32,
     blocks: blkcnt_t,
-    atim: timespec,
-    mtim: timespec,
-    ctim: timespec,
+    atim: std.os.linux.timespec,
+    mtim: std.os.linux.timespec,
+    ctim: std.os.linux.timespec,
     __unused: [2]u32,
 
-    pub fn atime(self: @This()) timespec {
+    pub fn atime(self: @This()) std.os.linux.timespec {
         return self.atim;
     }
 
-    pub fn mtime(self: @This()) timespec {
+    pub fn mtime(self: @This()) std.os.linux.timespec {
         return self.mtim;
     }
 
-    pub fn ctime(self: @This()) timespec {
+    pub fn ctime(self: @This()) std.os.linux.timespec {
         return self.ctim;
     }
 };
 
-pub const Elf_Symndx = u32;
-
 pub const VDSO = struct {
     pub const CGT_SYM = "__vdso_clock_gettime";
     pub const CGT_VER = "LINUX_4.15";
diff --git a/lib/std/os/linux/s390x.zig b/lib/std/os/linux/s390x.zig
index 00bc09c51849..13b6bfd51203 100644
--- a/lib/std/os/linux/s390x.zig
+++ b/lib/std/os/linux/s390x.zig
@@ -1,45 +1,34 @@
 const builtin = @import("builtin");
 const std = @import("../../std.zig");
-const iovec = std.posix.iovec;
-const iovec_const = std.posix.iovec_const;
-const linux = std.os.linux;
-const SYS = linux.SYS;
-const uid_t = std.os.linux.uid_t;
-const gid_t = std.os.linux.gid_t;
-const pid_t = std.os.linux.pid_t;
-const sockaddr = linux.sockaddr;
-const socklen_t = linux.socklen_t;
-const timespec = std.os.linux.timespec;
-const stack_t = std.os.linux.stack_t;
-const sigset_t = std.os.linux.sigset_t;
-
-pub fn syscall0(number: SYS) usize {
+const SYS = std.os.linux.SYS;
+
+pub fn syscall0(number: SYS) u64 {
     return asm volatile ("svc 0"
-        : [ret] "={r2}" (-> usize),
+        : [ret] "={r2}" (-> u64),
         : [number] "{r1}" (@intFromEnum(number)),
         : .{ .memory = true });
 }
 
-pub fn syscall1(number: SYS, arg1: usize) usize {
+pub fn syscall1(number: SYS, arg1: u64) u64 {
     return asm volatile ("svc 0"
-        : [ret] "={r2}" (-> usize),
+        : [ret] "={r2}" (-> u64),
         : [number] "{r1}" (@intFromEnum(number)),
           [arg1] "{r2}" (arg1),
         : .{ .memory = true });
 }
 
-pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
+pub fn syscall2(number: SYS, arg1: u64, arg2: u64) u64 {
     return asm volatile ("svc 0"
-        : [ret] "={r2}" (-> usize),
+        : [ret] "={r2}" (-> u64),
         : [number] "{r1}" (@intFromEnum(number)),
           [arg1] "{r2}" (arg1),
           [arg2] "{r3}" (arg2),
         : .{ .memory = true });
 }
 
-pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
+pub fn syscall3(number: SYS, arg1: u64, arg2: u64, arg3: u64) u64 {
     return asm volatile ("svc 0"
-        : [ret] "={r2}" (-> usize),
+        : [ret] "={r2}" (-> u64),
         : [number] "{r1}" (@intFromEnum(number)),
           [arg1] "{r2}" (arg1),
           [arg2] "{r3}" (arg2),
@@ -47,9 +36,9 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
         : .{ .memory = true });
 }
 
-pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize {
+pub fn syscall4(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64) u64 {
     return asm volatile ("svc 0"
-        : [ret] "={r2}" (-> usize),
+        : [ret] "={r2}" (-> u64),
         : [number] "{r1}" (@intFromEnum(number)),
           [arg1] "{r2}" (arg1),
           [arg2] "{r3}" (arg2),
@@ -58,9 +47,9 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)
         : .{ .memory = true });
 }
 
-pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize {
+pub fn syscall5(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64, arg5: u64) u64 {
     return asm volatile ("svc 0"
-        : [ret] "={r2}" (-> usize),
+        : [ret] "={r2}" (-> u64),
         : [number] "{r1}" (@intFromEnum(number)),
           [arg1] "{r2}" (arg1),
           [arg2] "{r3}" (arg2),
@@ -70,9 +59,9 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
         : .{ .memory = true });
 }
 
-pub fn syscall6(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize, arg6: usize) usize {
+pub fn syscall6(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64, arg5: u64, arg6: u64) u64 {
     return asm volatile ("svc 0"
-        : [ret] "={r2}" (-> usize),
+        : [ret] "={r2}" (-> u64),
         : [number] "{r1}" (@intFromEnum(number)),
           [arg1] "{r2}" (arg1),
           [arg2] "{r3}" (arg2),
@@ -83,7 +72,7 @@ pub fn syscall6(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
         : .{ .memory = true });
 }
 
-pub fn clone() callconv(.naked) usize {
+pub fn clone() callconv(.naked) u64 {
     asm volatile (
         \\# int clone(
         \\#    fn,      a = r2
@@ -157,26 +146,6 @@ pub fn restore_rt() callconv(.naked) noreturn {
     );
 }
 
-pub const F = struct {
-    pub const DUPFD = 0;
-    pub const GETFD = 1;
-    pub const SETFD = 2;
-    pub const GETFL = 3;
-    pub const SETFL = 4;
-    pub const GETLK = 5;
-    pub const SETLK = 6;
-    pub const SETLKW = 7;
-    pub const SETOWN = 8;
-    pub const GETOWN = 9;
-    pub const SETSIG = 10;
-    pub const GETSIG = 11;
-
-    pub const SETOWN_EX = 15;
-    pub const GETOWN_EX = 16;
-
-    pub const GETOWNER_UIDS = 17;
-};
-
 pub const blksize_t = i64;
 pub const nlink_t = u64;
 pub const time_t = i64;
@@ -186,51 +155,36 @@ pub const ino_t = u64;
 pub const dev_t = u64;
 pub const blkcnt_t = i64;
 
-pub const timeval = extern struct {
-    sec: time_t,
-    usec: i64,
-};
-
-pub const Flock = extern struct {
-    type: i16,
-    whence: i16,
-    start: off_t,
-    len: off_t,
-    pid: pid_t,
-};
-
 // The `stat` definition used by the Linux kernel.
 pub const Stat = extern struct {
     dev: dev_t,
     ino: ino_t,
     nlink: nlink_t,
     mode: mode_t,
-    uid: uid_t,
-    gid: gid_t,
+    uid: std.os.linux.uid_t,
+    gid: std.os.linux.gid_t,
     rdev: dev_t,
     size: off_t,
-    atim: timespec,
-    mtim: timespec,
-    ctim: timespec,
+    atim: std.os.linux.timespec,
+    mtim: std.os.linux.timespec,
+    ctim: std.os.linux.timespec,
     blksize: blksize_t,
     blocks: blkcnt_t,
     __unused: [3]c_ulong,
 
-    pub fn atime(self: @This()) timespec {
+    pub fn atime(self: @This()) std.os.linux.timespec {
         return self.atim;
     }
 
-    pub fn mtime(self: @This()) timespec {
+    pub fn mtime(self: @This()) std.os.linux.timespec {
         return self.mtim;
     }
 
-    pub fn ctime(self: @This()) timespec {
+    pub fn ctime(self: @This()) std.os.linux.timespec {
         return self.ctim;
     }
 };
 
-pub const Elf_Symndx = u64;
-
 pub const VDSO = struct {
     pub const CGT_SYM = "__kernel_clock_gettime";
     pub const CGT_VER = "LINUX_2.6.29";
diff --git a/lib/std/os/linux/sparc64.zig b/lib/std/os/linux/sparc64.zig
index b542c3f98516..7bf1f2435913 100644
--- a/lib/std/os/linux/sparc64.zig
+++ b/lib/std/os/linux/sparc64.zig
@@ -1,21 +1,8 @@
 const builtin = @import("builtin");
 const std = @import("../../std.zig");
-const maxInt = std.math.maxInt;
-const pid_t = linux.pid_t;
-const uid_t = linux.uid_t;
-const clock_t = linux.clock_t;
-const stack_t = linux.stack_t;
-const sigset_t = linux.sigset_t;
+const SYS = std.os.linux.SYS;
 
-const linux = std.os.linux;
-const SYS = linux.SYS;
-const sockaddr = linux.sockaddr;
-const socklen_t = linux.socklen_t;
-const iovec = std.posix.iovec;
-const iovec_const = std.posix.iovec_const;
-const timespec = linux.timespec;
-
-pub fn syscall_pipe(fd: *[2]i32) usize {
+pub fn syscall_pipe(fd: *[2]i32) u64 {
     return asm volatile (
         \\ mov %[arg], %%g3
         \\ t 0x6d
@@ -29,13 +16,13 @@ pub fn syscall_pipe(fd: *[2]i32) usize {
         \\ st %%o1, [%%g3+4]
         \\ clr %%o0
         \\2:
-        : [ret] "={o0}" (-> usize),
+        : [ret] "={o0}" (-> u64),
         : [number] "{g1}" (@intFromEnum(SYS.pipe)),
           [arg] "r" (fd),
         : .{ .memory = true, .g3 = true });
 }
 
-pub fn syscall_fork() usize {
+pub fn syscall_fork() u64 {
     // Linux/sparc64 fork() returns two values in %o0 and %o1:
     // - On the parent's side, %o0 is the child's PID and %o1 is 0.
     // - On the child's side, %o0 is the parent's PID and %o1 is 1.
@@ -52,58 +39,58 @@ pub fn syscall_fork() usize {
         \\ dec %%o1
         \\ and %%o1, %%o0, %%o0
         \\ 2:
-        : [ret] "={o0}" (-> usize),
+        : [ret] "={o0}" (-> u64),
         : [number] "{g1}" (@intFromEnum(SYS.fork)),
         : .{ .memory = true, .icc = true, .o1 = true, .o2 = true, .o3 = true, .o4 = true, .o5 = true, .o7 = true });
 }
 
-pub fn syscall0(number: SYS) usize {
+pub fn syscall0(number: SYS) u64 {
     return asm volatile (
         \\ t 0x6d
         \\ bcc,pt %%xcc, 1f
         \\ nop
         \\ neg %%o0
         \\ 1:
-        : [ret] "={o0}" (-> usize),
+        : [ret] "={o0}" (-> u64),
         : [number] "{g1}" (@intFromEnum(number)),
         : .{ .memory = true, .icc = true, .o1 = true, .o2 = true, .o3 = true, .o4 = true, .o5 = true, .o7 = true });
 }
 
-pub fn syscall1(number: SYS, arg1: usize) usize {
+pub fn syscall1(number: SYS, arg1: u64) u64 {
     return asm volatile (
         \\ t 0x6d
         \\ bcc,pt %%xcc, 1f
         \\ nop
         \\ neg %%o0
         \\ 1:
-        : [ret] "={o0}" (-> usize),
+        : [ret] "={o0}" (-> u64),
         : [number] "{g1}" (@intFromEnum(number)),
           [arg1] "{o0}" (arg1),
         : .{ .memory = true, .icc = true, .o1 = true, .o2 = true, .o3 = true, .o4 = true, .o5 = true, .o7 = true });
 }
 
-pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
+pub fn syscall2(number: SYS, arg1: u64, arg2: u64) u64 {
     return asm volatile (
         \\ t 0x6d
         \\ bcc,pt %%xcc, 1f
         \\ nop
         \\ neg %%o0
         \\ 1:
-        : [ret] "={o0}" (-> usize),
+        : [ret] "={o0}" (-> u64),
         : [number] "{g1}" (@intFromEnum(number)),
           [arg1] "{o0}" (arg1),
           [arg2] "{o1}" (arg2),
         : .{ .memory = true, .icc = true, .o1 = true, .o2 = true, .o3 = true, .o4 = true, .o5 = true, .o7 = true });
 }
 
-pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
+pub fn syscall3(number: SYS, arg1: u64, arg2: u64, arg3: u64) u64 {
     return asm volatile (
         \\ t 0x6d
         \\ bcc,pt %%xcc, 1f
         \\ nop
         \\ neg %%o0
         \\ 1:
-        : [ret] "={o0}" (-> usize),
+        : [ret] "={o0}" (-> u64),
         : [number] "{g1}" (@intFromEnum(number)),
           [arg1] "{o0}" (arg1),
           [arg2] "{o1}" (arg2),
@@ -111,14 +98,14 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
         : .{ .memory = true, .icc = true, .o1 = true, .o2 = true, .o3 = true, .o4 = true, .o5 = true, .o7 = true });
 }
 
-pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize {
+pub fn syscall4(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64) u64 {
     return asm volatile (
         \\ t 0x6d
         \\ bcc,pt %%xcc, 1f
         \\ nop
         \\ neg %%o0
         \\ 1:
-        : [ret] "={o0}" (-> usize),
+        : [ret] "={o0}" (-> u64),
         : [number] "{g1}" (@intFromEnum(number)),
           [arg1] "{o0}" (arg1),
           [arg2] "{o1}" (arg2),
@@ -127,14 +114,14 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)
         : .{ .memory = true, .icc = true, .o1 = true, .o2 = true, .o3 = true, .o4 = true, .o5 = true, .o7 = true });
 }
 
-pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize {
+pub fn syscall5(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64, arg5: u64) u64 {
     return asm volatile (
         \\ t 0x6d
         \\ bcc,pt %%xcc, 1f
         \\ nop
         \\ neg %%o0
         \\ 1:
-        : [ret] "={o0}" (-> usize),
+        : [ret] "={o0}" (-> u64),
         : [number] "{g1}" (@intFromEnum(number)),
           [arg1] "{o0}" (arg1),
           [arg2] "{o1}" (arg2),
@@ -146,20 +133,20 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
 
 pub fn syscall6(
     number: SYS,
-    arg1: usize,
-    arg2: usize,
-    arg3: usize,
-    arg4: usize,
-    arg5: usize,
-    arg6: usize,
-) usize {
+    arg1: u64,
+    arg2: u64,
+    arg3: u64,
+    arg4: u64,
+    arg5: u64,
+    arg6: u64,
+) u64 {
     return asm volatile (
         \\ t 0x6d
         \\ bcc,pt %%xcc, 1f
         \\ nop
         \\ neg %%o0
         \\ 1:
-        : [ret] "={o0}" (-> usize),
+        : [ret] "={o0}" (-> u64),
         : [number] "{g1}" (@intFromEnum(number)),
           [arg1] "{o0}" (arg1),
           [arg2] "{o1}" (arg2),
@@ -170,7 +157,7 @@ pub fn syscall6(
         : .{ .memory = true, .icc = true, .o1 = true, .o2 = true, .o3 = true, .o4 = true, .o5 = true, .o7 = true });
 }
 
-pub fn clone() callconv(.naked) usize {
+pub fn clone() callconv(.naked) u64 {
     // __clone(func, stack, flags, arg, ptid, tls, ctid)
     //         i0,   i1,    i2,    i3,  i4,   i5,  sp
     //
@@ -236,93 +223,51 @@ pub fn restore_rt() callconv(.c) void {
         : .{ .memory = true, .icc = true, .o0 = true, .o1 = true, .o2 = true, .o3 = true, .o4 = true, .o5 = true, .o7 = true });
 }
 
-pub const F = struct {
-    pub const DUPFD = 0;
-    pub const GETFD = 1;
-    pub const SETFD = 2;
-    pub const GETFL = 3;
-    pub const SETFL = 4;
-
-    pub const SETOWN = 5;
-    pub const GETOWN = 6;
-    pub const GETLK = 7;
-    pub const SETLK = 8;
-    pub const SETLKW = 9;
-
-    pub const RDLCK = 1;
-    pub const WRLCK = 2;
-    pub const UNLCK = 3;
-
-    pub const SETOWN_EX = 15;
-    pub const GETOWN_EX = 16;
-
-    pub const GETOWNER_UIDS = 17;
-};
-
 pub const VDSO = struct {
     pub const CGT_SYM = "__vdso_clock_gettime";
     pub const CGT_VER = "LINUX_2.6";
 };
 
-pub const Flock = extern struct {
-    type: i16,
-    whence: i16,
-    start: off_t,
-    len: off_t,
-    pid: pid_t,
-};
-
 pub const off_t = i64;
 pub const ino_t = u64;
-pub const time_t = isize;
+pub const time_t = i64;
 pub const mode_t = u32;
-pub const dev_t = usize;
+pub const dev_t = u64;
 pub const nlink_t = u32;
-pub const blksize_t = isize;
-pub const blkcnt_t = isize;
+pub const blksize_t = i64;
+pub const blkcnt_t = i64;
 
 // The `stat64` definition used by the kernel.
 pub const Stat = extern struct {
-    dev: u64,
-    ino: u64,
-    nlink: u64,
+    dev: dev_t,
+    ino: ino_t,
+    nlink: nlink_t,
+    _pad: i32,
 
-    mode: u32,
-    uid: u32,
-    gid: u32,
+    mode: mode_t,
+    uid: std.os.linux.uid_t,
+    gid: std.os.linux.gid_t,
     __pad0: u32,
 
-    rdev: u64,
+    rdev: dev_t,
     size: i64,
-    blksize: i64,
-    blocks: i64,
+    blksize: blksize_t,
+    blocks: blkcnt_t,
 
-    atim: timespec,
-    mtim: timespec,
-    ctim: timespec,
+    atim: std.os.linux.timespec,
+    mtim: std.os.linux.timespec,
+    ctim: std.os.linux.timespec,
     __unused: [3]u64,
 
-    pub fn atime(self: @This()) timespec {
+    pub fn atime(self: @This()) std.os.linux.timespec {
         return self.atim;
     }
 
-    pub fn mtime(self: @This()) timespec {
+    pub fn mtime(self: @This()) std.os.linux.timespec {
         return self.mtim;
     }
 
-    pub fn ctime(self: @This()) timespec {
+    pub fn ctime(self: @This()) std.os.linux.timespec {
         return self.ctim;
     }
 };
-
-pub const timeval = extern struct {
-    sec: isize,
-    usec: i32,
-};
-
-pub const timezone = extern struct {
-    minuteswest: i32,
-    dsttime: i32,
-};
-
-pub const Elf_Symndx = u32;
diff --git a/lib/std/os/linux/thumb.zig b/lib/std/os/linux/thumb.zig
index 3e13bad1d84c..90200da744df 100644
--- a/lib/std/os/linux/thumb.zig
+++ b/lib/std/os/linux/thumb.zig
@@ -4,64 +4,55 @@
 //! Save and restore r7 around the syscall without touching the stack pointer not
 //! to break the frame chain.
 const std = @import("../../std.zig");
-const linux = std.os.linux;
-const SYS = linux.SYS;
+const SYS = std.os.linux.SYS;
 
-pub fn syscall0(number: SYS) usize {
-    @setRuntimeSafety(false);
-
-    var buf: [2]usize = .{ @intFromEnum(number), undefined };
+pub fn syscall0(number: SYS) u32 {
+    var buf: [2]u32 = .{ @intFromEnum(number), undefined };
     return asm volatile (
         \\ str r7, [%[tmp], #4]
         \\ ldr r7, [%[tmp]]
         \\ svc #0
         \\ ldr r7, [%[tmp], #4]
-        : [ret] "={r0}" (-> usize),
+        : [ret] "={r0}" (-> u32),
         : [tmp] "{r1}" (&buf),
         : .{ .memory = true });
 }
 
-pub fn syscall1(number: SYS, arg1: usize) usize {
-    @setRuntimeSafety(false);
-
-    var buf: [2]usize = .{ @intFromEnum(number), undefined };
+pub fn syscall1(number: SYS, arg1: u32) u32 {
+    var buf: [2]u32 = .{ @intFromEnum(number), undefined };
     return asm volatile (
         \\ str r7, [%[tmp], #4]
         \\ ldr r7, [%[tmp]]
         \\ svc #0
         \\ ldr r7, [%[tmp], #4]
-        : [ret] "={r0}" (-> usize),
+        : [ret] "={r0}" (-> u32),
         : [tmp] "{r1}" (&buf),
           [arg1] "{r0}" (arg1),
         : .{ .memory = true });
 }
 
-pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
-    @setRuntimeSafety(false);
-
-    var buf: [2]usize = .{ @intFromEnum(number), undefined };
+pub fn syscall2(number: SYS, arg1: u32, arg2: u32) u32 {
+    var buf: [2]u32 = .{ @intFromEnum(number), undefined };
     return asm volatile (
         \\ str r7, [%[tmp], #4]
         \\ ldr r7, [%[tmp]]
         \\ svc #0
         \\ ldr r7, [%[tmp], #4]
-        : [ret] "={r0}" (-> usize),
+        : [ret] "={r0}" (-> u32),
         : [tmp] "{r2}" (&buf),
           [arg1] "{r0}" (arg1),
           [arg2] "{r1}" (arg2),
         : .{ .memory = true });
 }
 
-pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
-    @setRuntimeSafety(false);
-
-    var buf: [2]usize = .{ @intFromEnum(number), undefined };
+pub fn syscall3(number: SYS, arg1: u32, arg2: u32, arg3: u32) u32 {
+    var buf: [2]u32 = .{ @intFromEnum(number), undefined };
     return asm volatile (
         \\ str r7, [%[tmp], #4]
         \\ ldr r7, [%[tmp]]
         \\ svc #0
         \\ ldr r7, [%[tmp], #4]
-        : [ret] "={r0}" (-> usize),
+        : [ret] "={r0}" (-> u32),
         : [tmp] "{r3}" (&buf),
           [arg1] "{r0}" (arg1),
           [arg2] "{r1}" (arg2),
@@ -69,16 +60,14 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
         : .{ .memory = true });
 }
 
-pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize {
-    @setRuntimeSafety(false);
-
-    var buf: [2]usize = .{ @intFromEnum(number), undefined };
+pub fn syscall4(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32) u32 {
+    var buf: [2]u32 = .{ @intFromEnum(number), undefined };
     return asm volatile (
         \\ str r7, [%[tmp], #4]
         \\ ldr r7, [%[tmp]]
         \\ svc #0
         \\ ldr r7, [%[tmp], #4]
-        : [ret] "={r0}" (-> usize),
+        : [ret] "={r0}" (-> u32),
         : [tmp] "{r4}" (&buf),
           [arg1] "{r0}" (arg1),
           [arg2] "{r1}" (arg2),
@@ -87,16 +76,14 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)
         : .{ .memory = true });
 }
 
-pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize {
-    @setRuntimeSafety(false);
-
-    var buf: [2]usize = .{ @intFromEnum(number), undefined };
+pub fn syscall5(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32, arg5: u32) u32 {
+    var buf: [2]u32 = .{ @intFromEnum(number), undefined };
     return asm volatile (
         \\ str r7, [%[tmp], #4]
         \\ ldr r7, [%[tmp]]
         \\ svc #0
         \\ ldr r7, [%[tmp], #4]
-        : [ret] "={r0}" (-> usize),
+        : [ret] "={r0}" (-> u32),
         : [tmp] "{r5}" (&buf),
           [arg1] "{r0}" (arg1),
           [arg2] "{r1}" (arg2),
@@ -108,22 +95,20 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
 
 pub fn syscall6(
     number: SYS,
-    arg1: usize,
-    arg2: usize,
-    arg3: usize,
-    arg4: usize,
-    arg5: usize,
-    arg6: usize,
-) usize {
-    @setRuntimeSafety(false);
-
-    var buf: [2]usize = .{ @intFromEnum(number), undefined };
+    arg1: u32,
+    arg2: u32,
+    arg3: u32,
+    arg4: u32,
+    arg5: u32,
+    arg6: u32,
+) u32 {
+    var buf: [2]u32 = .{ @intFromEnum(number), undefined };
     return asm volatile (
         \\ str r7, [%[tmp], #4]
         \\ ldr r7, [%[tmp]]
         \\ svc #0
         \\ ldr r7, [%[tmp], #4]
-        : [ret] "={r0}" (-> usize),
+        : [ret] "={r0}" (-> u32),
         : [tmp] "{r6}" (&buf),
           [arg1] "{r0}" (arg1),
           [arg2] "{r1}" (arg2),
diff --git a/lib/std/os/linux/tls.zig b/lib/std/os/linux/tls.zig
index 4433727d9ac7..0c063e6df2e1 100644
--- a/lib/std/os/linux/tls.zig
+++ b/lib/std/os/linux/tls.zig
@@ -16,7 +16,6 @@ const math = std.math;
 const assert = std.debug.assert;
 const native_arch = @import("builtin").cpu.arch;
 const linux = std.os.linux;
-const posix = std.posix;
 const page_size_min = std.heap.page_size_min;
 
 /// Represents an ELF TLS variant.
@@ -523,7 +522,7 @@ pub fn initStatic(phdrs: []elf.Phdr) void {
 }
 
 inline fn mmap_tls(length: usize) usize {
-    const prot = posix.PROT.READ | posix.PROT.WRITE;
+    const prot = linux.PROT.READ | linux.PROT.WRITE;
     const flags: linux.MAP = .{ .TYPE = .PRIVATE, .ANONYMOUS = true };
 
     if (@hasField(linux.SYS, "mmap2")) {
diff --git a/lib/std/os/linux/x32.zig b/lib/std/os/linux/x32.zig
new file mode 100644
index 000000000000..4335fac04b65
--- /dev/null
+++ b/lib/std/os/linux/x32.zig
@@ -0,0 +1,192 @@
+// TODO: A lot of this file is very likely wrong.
+
+const builtin = @import("builtin");
+const std = @import("../../std.zig");
+const SYS = std.os.linux.SYS;
+
+pub fn syscall0(number: SYS) u32 {
+    return asm volatile ("syscall"
+        : [ret] "={rax}" (-> u32),
+        : [number] "{rax}" (@intFromEnum(number)),
+        : .{ .rcx = true, .r11 = true, .memory = true });
+}
+
+pub fn syscall1(number: SYS, arg1: u32) u32 {
+    return asm volatile ("syscall"
+        : [ret] "={rax}" (-> u32),
+        : [number] "{rax}" (@intFromEnum(number)),
+          [arg1] "{rdi}" (arg1),
+        : .{ .rcx = true, .r11 = true, .memory = true });
+}
+
+pub fn syscall2(number: SYS, arg1: u32, arg2: u32) u32 {
+    return asm volatile ("syscall"
+        : [ret] "={rax}" (-> u32),
+        : [number] "{rax}" (@intFromEnum(number)),
+          [arg1] "{rdi}" (arg1),
+          [arg2] "{rsi}" (arg2),
+        : .{ .rcx = true, .r11 = true, .memory = true });
+}
+
+pub fn syscall3(number: SYS, arg1: u32, arg2: u32, arg3: u32) u32 {
+    return asm volatile ("syscall"
+        : [ret] "={rax}" (-> u32),
+        : [number] "{rax}" (@intFromEnum(number)),
+          [arg1] "{rdi}" (arg1),
+          [arg2] "{rsi}" (arg2),
+          [arg3] "{rdx}" (arg3),
+        : .{ .rcx = true, .r11 = true, .memory = true });
+}
+
+pub fn syscall4(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32) u32 {
+    return asm volatile ("syscall"
+        : [ret] "={rax}" (-> u32),
+        : [number] "{rax}" (@intFromEnum(number)),
+          [arg1] "{rdi}" (arg1),
+          [arg2] "{rsi}" (arg2),
+          [arg3] "{rdx}" (arg3),
+          [arg4] "{r10}" (arg4),
+        : .{ .rcx = true, .r11 = true, .memory = true });
+}
+
+pub fn syscall5(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32, arg5: u32) u32 {
+    return asm volatile ("syscall"
+        : [ret] "={rax}" (-> u32),
+        : [number] "{rax}" (@intFromEnum(number)),
+          [arg1] "{rdi}" (arg1),
+          [arg2] "{rsi}" (arg2),
+          [arg3] "{rdx}" (arg3),
+          [arg4] "{r10}" (arg4),
+          [arg5] "{r8}" (arg5),
+        : .{ .rcx = true, .r11 = true, .memory = true });
+}
+
+pub fn syscall6(
+    number: SYS,
+    arg1: u32,
+    arg2: u32,
+    arg3: u32,
+    arg4: u32,
+    arg5: u32,
+    arg6: u32,
+) u32 {
+    return asm volatile ("syscall"
+        : [ret] "={rax}" (-> u32),
+        : [number] "{rax}" (@intFromEnum(number)),
+          [arg1] "{rdi}" (arg1),
+          [arg2] "{rsi}" (arg2),
+          [arg3] "{rdx}" (arg3),
+          [arg4] "{r10}" (arg4),
+          [arg5] "{r8}" (arg5),
+          [arg6] "{r9}" (arg6),
+        : .{ .rcx = true, .r11 = true, .memory = true });
+}
+
+pub fn clone() callconv(.naked) u32 {
+    asm volatile (
+        \\      movl $56,%%eax // SYS_clone
+        \\      movq %%rdi,%%r11
+        \\      movq %%rdx,%%rdi
+        \\      movq %%r8,%%rdx
+        \\      movq %%r9,%%r8
+        \\      movq 8(%%rsp),%%r10
+        \\      movq %%r11,%%r9
+        \\      andq $-16,%%rsi
+        \\      subq $8,%%rsi
+        \\      movq %%rcx,(%%rsi)
+        \\      syscall
+        \\      testq %%rax,%%rax
+        \\      jz 1f
+        \\      retq
+        \\
+        \\1:
+    );
+    if (builtin.unwind_tables != .none or !builtin.strip_debug_info) asm volatile (
+        \\      .cfi_undefined %%rip
+    );
+    asm volatile (
+        \\      xorl %%ebp,%%ebp
+        \\
+        \\      popq %%rdi
+        \\      callq *%%r9
+        \\      movl %%eax,%%edi
+        \\      movl $60,%%eax // SYS_exit
+        \\      syscall
+        \\
+    );
+}
+
+pub const restore = restore_rt;
+
+pub fn restore_rt() callconv(.naked) noreturn {
+    switch (builtin.zig_backend) {
+        .stage2_c => asm volatile (
+            \\ movl %[number], %%eax
+            \\ syscall
+            :
+            : [number] "i" (@intFromEnum(SYS.rt_sigreturn)),
+        ),
+        else => asm volatile (
+            \\ syscall
+            :
+            : [number] "{rax}" (@intFromEnum(SYS.rt_sigreturn)),
+        ),
+    }
+}
+
+pub const mode_t = u32;
+pub const time_t = i32;
+pub const nlink_t = u32;
+pub const blksize_t = i32;
+pub const blkcnt_t = i32;
+pub const off_t = i64;
+pub const ino_t = u64;
+pub const dev_t = u64;
+
+pub const VDSO = struct {
+    pub const CGT_SYM = "__vdso_clock_gettime";
+    pub const CGT_VER = "LINUX_2.6";
+
+    pub const GETCPU_SYM = "__vdso_getcpu";
+    pub const GETCPU_VER = "LINUX_2.6";
+};
+
+pub const ARCH = struct {
+    pub const SET_GS = 0x1001;
+    pub const SET_FS = 0x1002;
+    pub const GET_FS = 0x1003;
+    pub const GET_GS = 0x1004;
+};
+
+// The `stat` definition used by the Linux kernel.
+pub const Stat = extern struct {
+    dev: dev_t,
+    ino: ino_t,
+    nlink: nlink_t,
+
+    mode: mode_t,
+    uid: std.os.linux.uid_t,
+    gid: std.os.linux.gid_t,
+    __pad0: u32,
+    rdev: dev_t,
+    size: off_t,
+    blksize: blksize_t,
+    blocks: i64,
+
+    atim: std.os.linux.timespec,
+    mtim: std.os.linux.timespec,
+    ctim: std.os.linux.timespec,
+    __unused: [3]i32,
+
+    pub fn atime(self: @This()) std.os.linux.timespec {
+        return self.atim;
+    }
+
+    pub fn mtime(self: @This()) std.os.linux.timespec {
+        return self.mtim;
+    }
+
+    pub fn ctime(self: @This()) std.os.linux.timespec {
+        return self.ctim;
+    }
+};
diff --git a/lib/std/os/linux/x86.zig b/lib/std/os/linux/x86.zig
index c24ffcae6aa3..3770607f554b 100644
--- a/lib/std/os/linux/x86.zig
+++ b/lib/std/os/linux/x86.zig
@@ -1,46 +1,34 @@
 const builtin = @import("builtin");
 const std = @import("../../std.zig");
-const maxInt = std.math.maxInt;
-const linux = std.os.linux;
-const SYS = linux.SYS;
-const socklen_t = linux.socklen_t;
-const iovec = std.posix.iovec;
-const iovec_const = std.posix.iovec_const;
-const uid_t = linux.uid_t;
-const gid_t = linux.gid_t;
-const pid_t = linux.pid_t;
-const stack_t = linux.stack_t;
-const sigset_t = linux.sigset_t;
-const sockaddr = linux.sockaddr;
-const timespec = linux.timespec;
+const SYS = std.os.linux.SYS;
 
-pub fn syscall0(number: SYS) usize {
+pub fn syscall0(number: SYS) u32 {
     return asm volatile ("int $0x80"
-        : [ret] "={eax}" (-> usize),
+        : [ret] "={eax}" (-> u32),
         : [number] "{eax}" (@intFromEnum(number)),
         : .{ .memory = true });
 }
 
-pub fn syscall1(number: SYS, arg1: usize) usize {
+pub fn syscall1(number: SYS, arg1: u32) u32 {
     return asm volatile ("int $0x80"
-        : [ret] "={eax}" (-> usize),
+        : [ret] "={eax}" (-> u32),
         : [number] "{eax}" (@intFromEnum(number)),
           [arg1] "{ebx}" (arg1),
         : .{ .memory = true });
 }
 
-pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
+pub fn syscall2(number: SYS, arg1: u32, arg2: u32) u32 {
     return asm volatile ("int $0x80"
-        : [ret] "={eax}" (-> usize),
+        : [ret] "={eax}" (-> u32),
         : [number] "{eax}" (@intFromEnum(number)),
           [arg1] "{ebx}" (arg1),
           [arg2] "{ecx}" (arg2),
         : .{ .memory = true });
 }
 
-pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
+pub fn syscall3(number: SYS, arg1: u32, arg2: u32, arg3: u32) u32 {
     return asm volatile ("int $0x80"
-        : [ret] "={eax}" (-> usize),
+        : [ret] "={eax}" (-> u32),
         : [number] "{eax}" (@intFromEnum(number)),
           [arg1] "{ebx}" (arg1),
           [arg2] "{ecx}" (arg2),
@@ -48,9 +36,9 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
         : .{ .memory = true });
 }
 
-pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize {
+pub fn syscall4(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32) u32 {
     return asm volatile ("int $0x80"
-        : [ret] "={eax}" (-> usize),
+        : [ret] "={eax}" (-> u32),
         : [number] "{eax}" (@intFromEnum(number)),
           [arg1] "{ebx}" (arg1),
           [arg2] "{ecx}" (arg2),
@@ -59,9 +47,9 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)
         : .{ .memory = true });
 }
 
-pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize {
+pub fn syscall5(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32, arg5: u32) u32 {
     return asm volatile ("int $0x80"
-        : [ret] "={eax}" (-> usize),
+        : [ret] "={eax}" (-> u32),
         : [number] "{eax}" (@intFromEnum(number)),
           [arg1] "{ebx}" (arg1),
           [arg2] "{ecx}" (arg2),
@@ -73,20 +61,20 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
 
 pub fn syscall6(
     number: SYS,
-    arg1: usize,
-    arg2: usize,
-    arg3: usize,
-    arg4: usize,
-    arg5: usize,
-    arg6: usize,
-) usize {
+    arg1: u32,
+    arg2: u32,
+    arg3: u32,
+    arg4: u32,
+    arg5: u32,
+    arg6: u32,
+) u32 {
     // arg6 can't be passed to asm in a register because ebp might be reserved as the frame pointer
     // and there are no more GPRs available; so we'll need a memory operand for it. Adding that
     // memory operand means that on PIC we might need a reference to the GOT, which in turn needs
     // *its* own GPR, so we need to pass another arg in memory too! This is surprisingly hard to get
     // right, because we can't touch esp or ebp until we're done with the memory input (as that
     // input could be relative to esp or ebp).
-    const args56: [2]usize = .{ arg5, arg6 };
+    const args56: [2]u32 = .{ arg5, arg6 };
     return asm volatile (
         \\ push %[args56]
         \\ push %%ebp
@@ -99,7 +87,7 @@ pub fn syscall6(
         \\ int  $0x80
         \\ pop  %%ebp
         \\ pop  %%edi
-        : [ret] "={eax}" (-> usize),
+        : [ret] "={eax}" (-> u32),
         : [number] "{eax}" (@intFromEnum(number)),
           [arg1] "{ebx}" (arg1),
           [arg2] "{ecx}" (arg2),
@@ -109,16 +97,16 @@ pub fn syscall6(
         : .{ .memory = true });
 }
 
-pub fn socketcall(call: usize, args: [*]const usize) usize {
+pub fn socketcall(call: u32, args: [*]const u32) u32 {
     return asm volatile ("int $0x80"
-        : [ret] "={eax}" (-> usize),
+        : [ret] "={eax}" (-> u32),
         : [number] "{eax}" (@intFromEnum(SYS.socketcall)),
           [arg1] "{ebx}" (call),
           [arg2] "{ecx}" (@intFromPtr(args)),
         : .{ .memory = true });
 }
 
-pub fn clone() callconv(.naked) usize {
+pub fn clone() callconv(.naked) u32 {
     // __clone(func, stack, flags, arg, ptid, tls, ctid)
     //         +8,   +12,   +16,   +20, +24,  +28, +32
     //
@@ -169,23 +157,23 @@ pub fn clone() callconv(.naked) usize {
 }
 
 pub fn restore() callconv(.naked) noreturn {
-    switch (@import("builtin").zig_backend) {
+    switch (builtin.zig_backend) {
         .stage2_c => asm volatile (
             \\ movl %[number], %%eax
             \\ int $0x80
             :
             : [number] "i" (@intFromEnum(SYS.sigreturn)),
-            : .{ .memory = true }),
+        ),
         else => asm volatile (
             \\ int $0x80
             :
             : [number] "{eax}" (@intFromEnum(SYS.sigreturn)),
-            : .{ .memory = true }),
+        ),
     }
 }
 
 pub fn restore_rt() callconv(.naked) noreturn {
-    switch (@import("builtin").zig_backend) {
+    switch (builtin.zig_backend) {
         .stage2_c => asm volatile (
             \\ movl %[number], %%eax
             \\ int $0x80
@@ -200,46 +188,14 @@ pub fn restore_rt() callconv(.naked) noreturn {
     }
 }
 
-pub const F = struct {
-    pub const DUPFD = 0;
-    pub const GETFD = 1;
-    pub const SETFD = 2;
-    pub const GETFL = 3;
-    pub const SETFL = 4;
-    pub const SETOWN = 8;
-    pub const GETOWN = 9;
-    pub const SETSIG = 10;
-    pub const GETSIG = 11;
-    pub const GETLK = 12;
-    pub const SETLK = 13;
-    pub const SETLKW = 14;
-    pub const SETOWN_EX = 15;
-    pub const GETOWN_EX = 16;
-    pub const GETOWNER_UIDS = 17;
-
-    pub const RDLCK = 0;
-    pub const WRLCK = 1;
-    pub const UNLCK = 2;
-};
-
 pub const VDSO = struct {
     pub const CGT_SYM = "__vdso_clock_gettime";
     pub const CGT_VER = "LINUX_2.6";
 };
 
-pub const ARCH = struct {};
-
-pub const Flock = extern struct {
-    type: i16,
-    whence: i16,
-    start: off_t,
-    len: off_t,
-    pid: pid_t,
-};
-
 pub const blksize_t = i32;
 pub const nlink_t = u32;
-pub const time_t = isize;
+pub const time_t = i32;
 pub const mode_t = u32;
 pub const off_t = i64;
 pub const ino_t = u64;
@@ -253,43 +209,31 @@ pub const Stat = extern struct {
     __ino_truncated: u32,
     mode: mode_t,
     nlink: nlink_t,
-    uid: uid_t,
-    gid: gid_t,
+    uid: std.os.linux.uid_t,
+    gid: std.os.linux.gid_t,
     rdev: dev_t,
     __rdev_padding: u32,
     size: off_t,
     blksize: blksize_t,
     blocks: blkcnt_t,
-    atim: timespec,
-    mtim: timespec,
-    ctim: timespec,
+    atim: std.os.linux.timespec,
+    mtim: std.os.linux.timespec,
+    ctim: std.os.linux.timespec,
     ino: ino_t,
 
-    pub fn atime(self: @This()) timespec {
+    pub fn atime(self: @This()) std.os.linux.timespec {
         return self.atim;
     }
 
-    pub fn mtime(self: @This()) timespec {
+    pub fn mtime(self: @This()) std.os.linux.timespec {
         return self.mtim;
     }
 
-    pub fn ctime(self: @This()) timespec {
+    pub fn ctime(self: @This()) std.os.linux.timespec {
         return self.ctim;
     }
 };
 
-pub const timeval = extern struct {
-    sec: i32,
-    usec: i32,
-};
-
-pub const timezone = extern struct {
-    minuteswest: i32,
-    dsttime: i32,
-};
-
-pub const Elf_Symndx = u32;
-
 pub const user_desc = extern struct {
     entry_number: u32,
     base_addr: u32,
diff --git a/lib/std/os/linux/x86_64.zig b/lib/std/os/linux/x86_64.zig
index e3db9e99c4ec..d9c2d17f09e3 100644
--- a/lib/std/os/linux/x86_64.zig
+++ b/lib/std/os/linux/x86_64.zig
@@ -1,48 +1,34 @@
 const builtin = @import("builtin");
 const std = @import("../../std.zig");
-const maxInt = std.math.maxInt;
-const linux = std.os.linux;
-const SYS = linux.SYS;
-const iovec = std.posix.iovec;
-const iovec_const = std.posix.iovec_const;
-
-const pid_t = linux.pid_t;
-const uid_t = linux.uid_t;
-const gid_t = linux.gid_t;
-const clock_t = linux.clock_t;
-const stack_t = linux.stack_t;
-const sigset_t = linux.sigset_t;
-const sockaddr = linux.sockaddr;
-const socklen_t = linux.socklen_t;
-const timespec = linux.timespec;
-
-pub fn syscall0(number: SYS) usize {
+const SYS = std.os.linux.SYS;
+
+pub fn syscall0(number: SYS) u64 {
     return asm volatile ("syscall"
-        : [ret] "={rax}" (-> usize),
+        : [ret] "={rax}" (-> u64),
         : [number] "{rax}" (@intFromEnum(number)),
         : .{ .rcx = true, .r11 = true, .memory = true });
 }
 
-pub fn syscall1(number: SYS, arg1: usize) usize {
+pub fn syscall1(number: SYS, arg1: u64) u64 {
     return asm volatile ("syscall"
-        : [ret] "={rax}" (-> usize),
+        : [ret] "={rax}" (-> u64),
         : [number] "{rax}" (@intFromEnum(number)),
           [arg1] "{rdi}" (arg1),
         : .{ .rcx = true, .r11 = true, .memory = true });
 }
 
-pub fn syscall2(number: SYS, arg1: usize, arg2: usize) usize {
+pub fn syscall2(number: SYS, arg1: u64, arg2: u64) u64 {
     return asm volatile ("syscall"
-        : [ret] "={rax}" (-> usize),
+        : [ret] "={rax}" (-> u64),
         : [number] "{rax}" (@intFromEnum(number)),
           [arg1] "{rdi}" (arg1),
           [arg2] "{rsi}" (arg2),
         : .{ .rcx = true, .r11 = true, .memory = true });
 }
 
-pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
+pub fn syscall3(number: SYS, arg1: u64, arg2: u64, arg3: u64) u64 {
     return asm volatile ("syscall"
-        : [ret] "={rax}" (-> usize),
+        : [ret] "={rax}" (-> u64),
         : [number] "{rax}" (@intFromEnum(number)),
           [arg1] "{rdi}" (arg1),
           [arg2] "{rsi}" (arg2),
@@ -50,9 +36,9 @@ pub fn syscall3(number: SYS, arg1: usize, arg2: usize, arg3: usize) usize {
         : .{ .rcx = true, .r11 = true, .memory = true });
 }
 
-pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize {
+pub fn syscall4(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64) u64 {
     return asm volatile ("syscall"
-        : [ret] "={rax}" (-> usize),
+        : [ret] "={rax}" (-> u64),
         : [number] "{rax}" (@intFromEnum(number)),
           [arg1] "{rdi}" (arg1),
           [arg2] "{rsi}" (arg2),
@@ -61,9 +47,9 @@ pub fn syscall4(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize)
         : .{ .rcx = true, .r11 = true, .memory = true });
 }
 
-pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize) usize {
+pub fn syscall5(number: SYS, arg1: u64, arg2: u64, arg3: u64, arg4: u64, arg5: u64) u64 {
     return asm volatile ("syscall"
-        : [ret] "={rax}" (-> usize),
+        : [ret] "={rax}" (-> u64),
         : [number] "{rax}" (@intFromEnum(number)),
           [arg1] "{rdi}" (arg1),
           [arg2] "{rsi}" (arg2),
@@ -75,15 +61,15 @@ pub fn syscall5(number: SYS, arg1: usize, arg2: usize, arg3: usize, arg4: usize,
 
 pub fn syscall6(
     number: SYS,
-    arg1: usize,
-    arg2: usize,
-    arg3: usize,
-    arg4: usize,
-    arg5: usize,
-    arg6: usize,
-) usize {
+    arg1: u64,
+    arg2: u64,
+    arg3: u64,
+    arg4: u64,
+    arg5: u64,
+    arg6: u64,
+) u64 {
     return asm volatile ("syscall"
-        : [ret] "={rax}" (-> usize),
+        : [ret] "={rax}" (-> u64),
         : [number] "{rax}" (@intFromEnum(number)),
           [arg1] "{rdi}" (arg1),
           [arg2] "{rsi}" (arg2),
@@ -94,7 +80,7 @@ pub fn syscall6(
         : .{ .rcx = true, .r11 = true, .memory = true });
 }
 
-pub fn clone() callconv(.naked) usize {
+pub fn clone() callconv(.naked) u64 {
     asm volatile (
         \\      movl $56,%%eax // SYS_clone
         \\      movq %%rdi,%%r11
@@ -131,7 +117,7 @@ pub fn clone() callconv(.naked) usize {
 pub const restore = restore_rt;
 
 pub fn restore_rt() callconv(.naked) noreturn {
-    switch (@import("builtin").zig_backend) {
+    switch (builtin.zig_backend) {
         .stage2_c => asm volatile (
             \\ movl %[number], %%eax
             \\ syscall
@@ -146,34 +132,14 @@ pub fn restore_rt() callconv(.naked) noreturn {
     }
 }
 
-pub const mode_t = usize;
-pub const time_t = isize;
-pub const nlink_t = usize;
-pub const blksize_t = isize;
-pub const blkcnt_t = isize;
-
-pub const F = struct {
-    pub const DUPFD = 0;
-    pub const GETFD = 1;
-    pub const SETFD = 2;
-    pub const GETFL = 3;
-    pub const SETFL = 4;
-    pub const GETLK = 5;
-    pub const SETLK = 6;
-    pub const SETLKW = 7;
-    pub const SETOWN = 8;
-    pub const GETOWN = 9;
-    pub const SETSIG = 10;
-    pub const GETSIG = 11;
-
-    pub const SETOWN_EX = 15;
-    pub const GETOWN_EX = 16;
-    pub const GETOWNER_UIDS = 17;
-
-    pub const RDLCK = 0;
-    pub const WRLCK = 1;
-    pub const UNLCK = 2;
-};
+pub const mode_t = u64;
+pub const time_t = i64;
+pub const nlink_t = u64;
+pub const blksize_t = i64;
+pub const blkcnt_t = i64;
+pub const off_t = i64;
+pub const ino_t = u64;
+pub const dev_t = u64;
 
 pub const VDSO = struct {
     pub const CGT_SYM = "__vdso_clock_gettime";
@@ -190,59 +156,35 @@ pub const ARCH = struct {
     pub const GET_GS = 0x1004;
 };
 
-pub const Flock = extern struct {
-    type: i16,
-    whence: i16,
-    start: off_t,
-    len: off_t,
-    pid: pid_t,
-};
-
-pub const off_t = i64;
-pub const ino_t = u64;
-pub const dev_t = u64;
-
 // The `stat` definition used by the Linux kernel.
 pub const Stat = extern struct {
     dev: dev_t,
     ino: ino_t,
-    nlink: usize,
+    nlink: u64,
 
     mode: u32,
-    uid: uid_t,
-    gid: gid_t,
+    uid: std.os.linux.uid_t,
+    gid: std.os.linux.gid_t,
     __pad0: u32,
     rdev: dev_t,
     size: off_t,
-    blksize: isize,
+    blksize: i64,
     blocks: i64,
 
-    atim: timespec,
-    mtim: timespec,
-    ctim: timespec,
-    __unused: [3]isize,
+    atim: std.os.linux.timespec,
+    mtim: std.os.linux.timespec,
+    ctim: std.os.linux.timespec,
+    __unused: [3]i64,
 
-    pub fn atime(self: @This()) timespec {
+    pub fn atime(self: @This()) std.os.linux.timespec {
         return self.atim;
     }
 
-    pub fn mtime(self: @This()) timespec {
+    pub fn mtime(self: @This()) std.os.linux.timespec {
         return self.mtim;
     }
 
-    pub fn ctime(self: @This()) timespec {
+    pub fn ctime(self: @This()) std.os.linux.timespec {
         return self.ctim;
     }
 };
-
-pub const timeval = extern struct {
-    sec: isize,
-    usec: isize,
-};
-
-pub const timezone = extern struct {
-    minuteswest: i32,
-    dsttime: i32,
-};
-
-pub const Elf_Symndx = u32;