srctree

// Two threads could race against the same emutls_control.

 

// Use atomic for reading coherent value lockless.

 

if (index_lockless != 0) {

// index is already initialized, return it.

}

 

// Store a new index atomically (for having coherent index_lockless reading).

 

// Increment the next available index

emutls_control.next_index += 1;

 

assert(std.c.pthread_mutex_lock(&bucket.mutex) == .SUCCESS);

defer assert(std.c.pthread_mutex_unlock(&bucket.mutex) == .SUCCESS);

 

if (cancelled) {

return;

}

// The pending count increment in wait() must also now use seq_cst for the update + this pending load

// to be in the same modification order as our load isn't using release/acquire to guarantee it.

bucket.pending.fence(.seq_cst);

return;

}

 

// Keep a list of all the waiters notified and wake then up outside the mutex critical section.

var notified = WaitList{};

defer if (notified.len > 0) {

assert(pending >= notified.len);

 

while (notified.pop()) |waiter| {

defer assert(std.c.pthread_mutex_unlock(&bucket.mutex) == .SUCCESS);

 

// Another pending check again to avoid the WaitQueue lookup if not necessary.

notified = WaitQueue.remove(&bucket.treap, address, max_waiters);

}

}

 

 

try testing.expectEqual(num_writes, runner.writes);

 

}

 

// acquire ensures count decrement and code before

// previous unrefs()s happens-before we call dropFn

// below.

// fetchSub count decrement but it's extra barrier in

// possibly hot path.

rc.count.fence(.acquire);

 

pub extern "c" fn telldir(dp: *DIR) c_long;

pub extern "c" fn seekdir(dp: *DIR, loc: c_long) void;

 

pub extern "c" fn sigwait(set: ?*c.sigset_t, sig: ?*c_int) c_int;

 

pub extern "c" fn alarm(seconds: c_uint) c_uint;

 

 

pub const fstat = switch (native_os) {

.macos => switch (native_arch) {

else => private.fstatat,

};

 

pub const readdir = switch (native_os) {

.macos => switch (native_arch) {

.x86_64 => private.@"readdir$INODE64",

};

 

pub const realpath = switch (native_os) {

else => private.realpath,

};

 

pub const stat = switch (native_os) {

.macos => switch (native_arch) {

.x86_64 => private.@"stat$INODE64",

pub extern "c" fn recvmsg(sockfd: c.fd_t, msg: *c.msghdr, flags: u32) isize;

 

pub extern "c" fn kill(pid: c.pid_t, sig: c_int) c_int;

 

pub extern "c" fn setuid(uid: c.uid_t) c_int;

pub extern "c" fn setgid(gid: c.gid_t) c_int;

};

 

const private = struct {

extern "c" fn fstat(fd: c.fd_t, buf: *c.Stat) c_int;

extern "c" fn fstatat(dirfd: c.fd_t, path: [*:0]const u8, buf: *c.Stat, flag: u32) c_int;

extern "c" fn readdir(dir: *c.DIR) ?*c.dirent;

extern "c" fn realpath(noalias file_name: [*:0]const u8, noalias resolved_name: [*]u8) ?[*:0]u8;

extern "c" fn stat(noalias path: [*:0]const u8, noalias buf: *c.Stat) c_int;

 

/// macos modernized symbols.

 

/// macos modernized symbols.

extern "c" fn @"realpath$DARWIN_EXTSN"(noalias file_name: [*:0]const u8, noalias resolved_name: [*]u8) ?[*:0]u8;

 

/// netbsd modernized symbols.

extern "c" fn __fstat50(fd: c.fd_t, buf: *c.Stat) c_int;

};

 

pub extern "c" fn os_unfair_lock_assert_owner(o: os_unfair_lock_t) void;

pub extern "c" fn os_unfair_lock_assert_not_owner(o: os_unfair_lock_t) void;

 

// See: https://opensource.apple.com/source/xnu/xnu-6153.141.1/bsd/sys/_types.h.auto.html

// TODO: audit mode_t/pid_t, should likely be u16/i32

pub const blkcnt_t = i64;

 

addr: [16]u8,

scope_id: u32,

};

};

 

pub const Kevent = extern struct {

 

pub extern "c" fn pipe2(fds: *[2]fd_t, flags: std.c.O) c_int;

pub extern "c" fn arc4random_buf(buf: [*]u8, len: usize) void;

 

pub extern "c" fn __getdents30(fd: c_int, buf_ptr: [*]u8, nbytes: usize) c_int;

pub const getdents = __getdents30;

 

pub extern "c" fn __sigaltstack14(ss: ?*stack_t, old_ss: ?*stack_t) c_int;

pub const sigaltstack = __sigaltstack14;

 

pub extern "c" fn posix_memalign(memptr: *?*anyopaque, alignment: usize, size: usize) c_int;

 

pub const pthread_spin_t = switch (builtin.cpu.arch) {

.aarch64, .aarch64_be, .aarch64_32 => u8,

.mips, .mipsel, .mips64, .mips64el => u32,

 

posix.lseek_SET(self.dir.fd, 0) catch unreachable; // EBADF here likely means that the Dir was not opened with iteration permissions

self.first_iter = false;

}

self.dir.fd,

&self.buf,

self.buf.len,

posix.lseek_SET(self.dir.fd, 0) catch unreachable; // EBADF here likely means that the Dir was not opened with iteration permissions

self.first_iter = false;

}

switch (posix.errno(rc)) {

.SUCCESS => {},

.BADF => unreachable, // Dir is invalid or was opened without iteration ability

 

/// Result type is always `void`.

/// Uses the `bin_op` field. LHS is pointer, RHS is element.

atomic_store_unordered,

atomic_store_monotonic,

atomic_store_release,

atomic_store_seq_cst,

/// Atomically read-modify-write via a pointer.

/// Result type is the element type of the pointer.

 

.call_never_tail => try self.airCall(inst, .never_tail),

.call_never_inline => try self.airCall(inst, .never_inline),

 

 

.struct_field_ptr_index_0 => try self.airStructFieldPtrIndex(inst, 0),

.struct_field_ptr_index_1 => try self.airStructFieldPtrIndex(inst, 1),