mirrors/cosmopolitan
1
0
Fork 0
mirror of https://github.com/jart/cosmopolitan.git synced 2025-02-07 06:53:33 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Make improvements

Browse source 
- This change fixes a bug that allowed unbuffered printf() output (to
  streams like stderr) to be truncated. This regression was introduced
  some time between now and the last release.

- POSIX specifies all functions as thread safe by default. This change
  works towards cleaning up our use of the @threadsafe / @threadunsafe
  documentation annotations to reflect that. The goal is (1) to use
  @threadunsafe to document functions which POSIX say needn't be thread
  safe, and (2) use @threadsafe to document functions that we chose to
  implement as thread safe even though POSIX didn't mandate it.

- Tidy up the clock_gettime() implementation. We're now trying out a
  cleaner approach to system call support that aims to maintain the
  Linux errno convention as long as possible. This also fixes bugs that
  existed previously, where the vDSO errno wasn't being translated
  properly. The gettimeofday() system call is now a wrapper for
  clock_gettime(), which reduces bloat in apps that use both.

- The recently-introduced improvements to the execute bit on Windows has
  had bugs fixed. access(X_OK) on a directory on Windows now succeeds.
  fstat() will now perform the MZ/#! ReadFile() operation correctly.

- Windows.h is no longer included in libc/isystem/, because it confused
  PCRE's build system into thinking Cosmopolitan is a WIN32 platform.
  Cosmo's Windows.h polyfill was never even really that good, since it
  only defines a subset of the subset of WIN32 APIs that Cosmo defines.

- The setlongerjmp() / longerjmp() APIs are removed. While they're nice
  APIs that are superior to the standardized setjmp / longjmp functions,
  they weren't superior enough to not be dead code in the monorepo. If
  you use these APIs, please file an issue and they'll be restored.

- The .com appending magic has now been removed from APE Loader.
This commit is contained in:
Justine Tunney 2023-10-02 19:25:19 -07:00
parent b99512ac58
commit ff77f2a6af
No known key found for this signature in database
GPG key ID: BE714B4575D6E328
226 changed files with 708 additions and 2657 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

57
ape/ape-m1.c
View file

@ -76,7 +76,8 @@ struct Syslib {
long (*write)(int, const void *, size_t);
long (*read)(int, void *, size_t);
long (*sigaction)(int, const struct sigaction *, struct sigaction *);
long (*pselect)(int, fd_set *, fd_set *, fd_set *, const struct timespec *, const sigset_t *);
long (*pselect)(int, fd_set *, fd_set *, fd_set *, const struct timespec *,
const sigset_t *);
long (*mprotect)(void *, size_t, int);
};
@ -187,10 +188,6 @@ struct ApeLoader {
char rando[16];
};
static int ToLower(int c) {
return 'A' <= c && c <= 'Z' ? c + ('a' - 'A') : c;
}
static unsigned long StrLen(const char *s) {
unsigned long n = 0;
while (*s++) ++n;
@ -349,38 +346,14 @@ __attribute__((__noreturn__)) static void Pexit(const char *c, int failed,
_exit(127);
}
static char EndsWithIgnoreCase(const char *p, unsigned long n, const char *s) {
unsigned long i, m;
if (n >= (m = StrLen(s))) {
for (i = n - m; i < n; ++i) {
if (ToLower(p[i]) != *s++) {
return 0;
}
}
return 1;
} else {
return 0;
}
}
static char IsComPath(struct PathSearcher *ps) {
return EndsWithIgnoreCase(ps->name, ps->namelen, ".com") ||
EndsWithIgnoreCase(ps->name, ps->namelen, ".exe") ||
EndsWithIgnoreCase(ps->name, ps->namelen, ".com.dbg");
}
static char AccessCommand(struct PathSearcher *ps, const char *suffix,
unsigned long pathlen) {
unsigned long suffixlen;
suffixlen = StrLen(suffix);
if (pathlen + 1 + ps->namelen + suffixlen + 1 > sizeof(ps->path)) return 0;
static char AccessCommand(struct PathSearcher *ps, unsigned long pathlen) {
if (pathlen + 1 + ps->namelen + 1 > sizeof(ps->path)) return 0;
if (pathlen && ps->path[pathlen - 1] != '/') ps->path[pathlen++] = '/';
MemMove(ps->path + pathlen, ps->name, ps->namelen);
MemMove(ps->path + pathlen + ps->namelen, suffix, suffixlen + 1);
return !access(ps->path, X_OK);
}
static char SearchPath(struct PathSearcher *ps, const char *suffix) {
static char SearchPath(struct PathSearcher *ps) {
const char *p;
unsigned long i;
for (p = ps->syspath;;) {
@ -389,7 +362,7 @@ static char SearchPath(struct PathSearcher *ps, const char *suffix) {
ps->path[i] = p[i];
}
}
if (AccessCommand(ps, suffix, i)) {
if (AccessCommand(ps, i)) {
return 1;
} else if (p[i] == ':') {
p += i + 1;
@ -399,13 +372,13 @@ static char SearchPath(struct PathSearcher *ps, const char *suffix) {
}
}
static char FindCommand(struct PathSearcher *ps, const char *suffix) {
static char FindCommand(struct PathSearcher *ps) {
ps->path[0] = 0;
/* paths are always 100% taken literally when a slash exists
$ ape foo/bar.com arg1 arg2 */
if (MemChr(ps->name, '/', ps->namelen)) {
return AccessCommand(ps, suffix, 0);
return AccessCommand(ps, 0);
}
/* we don't run files in the current directory
@ -416,12 +389,12 @@ static char FindCommand(struct PathSearcher *ps, const char *suffix) {
however we will execute this
$ ape - foo.com foo.com arg1 arg2
because cosmo's execve needs it */
if (ps->literally && AccessCommand(ps, suffix, 0)) {
if (ps->literally && AccessCommand(ps, 0)) {
return 1;
}
/* otherwise search for name on $PATH */
return SearchPath(ps, suffix);
return SearchPath(ps);
}
static char *Commandv(struct PathSearcher *ps, const char *name,
@ -429,7 +402,7 @@ static char *Commandv(struct PathSearcher *ps, const char *name,
ps->syspath = syspath ? syspath : "/bin:/usr/local/bin:/usr/bin";
if (!(ps->namelen = StrLen((ps->name = name)))) return 0;
if (ps->namelen + 1 > sizeof(ps->path)) return 0;
if (FindCommand(ps, "") || (!IsComPath(ps) && FindCommand(ps, ".com"))) {
if (FindCommand(ps)) {
return ps->path;
} else {
return 0;
@ -843,12 +816,14 @@ static long sys_mmap(void *addr, size_t size, int prot, int flags, int fd,
return sysret((long)mmap(addr, size, prot, flags, fd, off));
}
static long sys_sigaction(int sig, const struct sigaction *act, struct sigaction *oact) {
static long sys_sigaction(int sig, const struct sigaction *act,
struct sigaction *oact) {
return sysret(sigaction(sig, act, oact));
}
static long sys_pselect(int nfds, fd_set *readfds, fd_set *writefds, fd_set *errorfds,
const struct timespec *timeout, const sigset_t *sigmask) {
static long sys_pselect(int nfds, fd_set *readfds, fd_set *writefds,
fd_set *errorfds, const struct timespec *timeout,
const sigset_t *sigmask) {
return sysret(pselect(nfds, readfds, writefds, errorfds, timeout, sigmask));
}

46
ape/loader.c
View file

@ -227,10 +227,6 @@ EXTERN_C void Launch(void *, long, void *, int) __attribute__((__noreturn__));
extern char __executable_start[];
extern char _end[];
static int ToLower(int c) {
return 'A' <= c && c <= 'Z' ? c + ('a' - 'A') : c;
}
static unsigned long StrLen(const char *s) {
unsigned long n = 0;
while (*s++) ++n;
@ -538,38 +534,14 @@ __attribute__((__noreturn__)) static void Pexit(int os, const char *c, int rc,
Exit(127, os);
}
static char EndsWithIgnoreCase(const char *p, unsigned long n, const char *s) {
unsigned long i, m;
if (n >= (m = StrLen(s))) {
for (i = n - m; i < n; ++i) {
if (ToLower(p[i]) != *s++) {
return 0;
}
}
return 1;
} else {
return 0;
}
}
static char IsComPath(struct PathSearcher *ps) {
return EndsWithIgnoreCase(ps->name, ps->namelen, ".com") ||
EndsWithIgnoreCase(ps->name, ps->namelen, ".exe") ||
EndsWithIgnoreCase(ps->name, ps->namelen, ".com.dbg");
}
static char AccessCommand(struct PathSearcher *ps, const char *suffix,
unsigned long pathlen) {
unsigned long suffixlen;
suffixlen = StrLen(suffix);
if (pathlen + 1 + ps->namelen + suffixlen + 1 > sizeof(ps->path)) return 0;
static char AccessCommand(struct PathSearcher *ps, unsigned long pathlen) {
if (pathlen + 1 + ps->namelen + 1 > sizeof(ps->path)) return 0;
if (pathlen && ps->path[pathlen - 1] != '/') ps->path[pathlen++] = '/';
MemMove(ps->path + pathlen, ps->name, ps->namelen);
MemMove(ps->path + pathlen + ps->namelen, suffix, suffixlen + 1);
return !Access(ps->path, X_OK, ps->os);
}
static char SearchPath(struct PathSearcher *ps, const char *suffix) {
static char SearchPath(struct PathSearcher *ps) {
const char *p;
unsigned long i;
for (p = ps->syspath;;) {
@ -578,7 +550,7 @@ static char SearchPath(struct PathSearcher *ps, const char *suffix) {
ps->path[i] = p[i];
}
}
if (AccessCommand(ps, suffix, i)) {
if (AccessCommand(ps, i)) {
return 1;
} else if (p[i] == ':') {
p += i + 1;
@ -588,13 +560,13 @@ static char SearchPath(struct PathSearcher *ps, const char *suffix) {
}
}
static char FindCommand(struct PathSearcher *ps, const char *suffix) {
static char FindCommand(struct PathSearcher *ps) {
ps->path[0] = 0;
/* paths are always 100% taken literally when a slash exists
$ ape foo/bar.com arg1 arg2 */
if (MemChr(ps->name, '/', ps->namelen)) {
return AccessCommand(ps, suffix, 0);
return AccessCommand(ps, 0);
}
/* we don't run files in the current directory
@ -605,12 +577,12 @@ static char FindCommand(struct PathSearcher *ps, const char *suffix) {
however we will execute this
$ ape - foo.com foo.com arg1 arg2
because cosmo's execve needs it */
if (ps->literally && AccessCommand(ps, suffix, 0)) {
if (ps->literally && AccessCommand(ps, 0)) {
return 1;
}
/* otherwise search for name on $PATH */
return SearchPath(ps, suffix);
return SearchPath(ps);
}
static char *Commandv(struct PathSearcher *ps, int os, const char *name,
@ -619,7 +591,7 @@ static char *Commandv(struct PathSearcher *ps, int os, const char *name,
ps->syspath = syspath ? syspath : "/bin:/usr/local/bin:/usr/bin";
if (!(ps->namelen = StrLen((ps->name = name)))) return 0;
if (ps->namelen + 1 > sizeof(ps->path)) return 0;
if (FindCommand(ps, "") || (!IsComPath(ps) && FindCommand(ps, ".com"))) {
if (FindCommand(ps)) {
return ps->path;
} else {
return 0;

1
dsp/mpeg/mpeg1.c
View file

@ -32,6 +32,7 @@
#include "dsp/mpeg/idct.h"
#include "dsp/mpeg/mpeg.h"
#include "dsp/mpeg/video.h"
#include "libc/calls/struct/timespec.h"
#include "libc/fmt/conv.h"
#include "libc/log/log.h"
#include "libc/macros.internal.h"

2
libc/calls/calls.mk
View file

@ -107,6 +107,8 @@ o//libc/calls/statfs2cosmo.o: private \
# we always want -O2 because:
# division is expensive if not optimized
o/$(MODE)/libc/calls/clock.o \
o/$(MODE)/libc/calls/gettimeofday.o \
o/$(MODE)/libc/calls/clock_gettime-mono.o \
o/$(MODE)/libc/calls/timespec_tomillis.o \
o/$(MODE)/libc/calls/timespec_tomicros.o \
o/$(MODE)/libc/calls/timespec_totimeval.o \

2
libc/calls/clock.c
View file

@ -52,7 +52,7 @@ int64_t clock(void) {
struct rusage ru;
struct timespec ts;
e = errno;
if (clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &ts) == -1) {
if (clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &ts)) {
errno = e;
if (getrusage(RUSAGE_SELF, &ru) != -1) {
ts = timeval_totimespec(timeval_add(ru.ru_utime, ru.ru_stime));

1
libc/calls/clock_getres.c
View file

@ -54,7 +54,6 @@ static int sys_clock_getres_xnu(int clock, struct timespec *ts) {
* @error EPERM if pledge() is in play without stdio promise
* @error EINVAL if `clock` isn't supported on this system
* @error EFAULT if `ts` points to bad memory
* @threadsafe
*/
int clock_getres(int clock, struct timespec *ts) {
int rc;

23
libc/calls/clock_gettime-mono.c
View file

@ -16,15 +16,19 @@
│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR │
│ PERFORMANCE OF THIS SOFTWARE. │
╚─────────────────────────────────────────────────────────────────────────────*/
#include "libc/atomic.h"
#include "libc/calls/struct/timespec.h"
#include "libc/cosmo.h"
#include "libc/errno.h"
#include "libc/nexgen32e/rdtsc.h"
#include "libc/nexgen32e/x86feature.h"
#include "libc/sysv/consts/clock.h"
#include "libc/sysv/errfuns.h"
/**
* @fileoverview Fast Monotonic Clock Polyfill for XNU/NT.
*/
static struct {
_Atomic(uint32_t) once;
atomic_uint once;
struct timespec base_wall;
uint64_t base_tick;
} g_mono;
@ -37,13 +41,18 @@ static void sys_clock_gettime_mono_init(void) {
int sys_clock_gettime_mono(struct timespec *time) {
uint64_t nanos;
uint64_t cycles;
if (X86_HAVE(INVTSC)) {
#ifdef __x86_64__
// intel architecture guarantees that a mapping exists between rdtsc &
// nanoseconds only if the cpu advertises invariant timestamps support
if (!X86_HAVE(INVTSC)) return -EINVAL;
#endif
cosmo_once(&g_mono.once, sys_clock_gettime_mono_init);
cycles = rdtsc() - g_mono.base_tick;
// this is a crude approximation, that's worked reasonably well so far
// only the kernel knows the actual mapping between rdtsc and nanosecs
// which we could attempt to measure ourselves using clock_gettime but
// we'd need to impose 100 ms of startup latency for a guess this good
nanos = cycles / 3;
*time = timespec_add(g_mono.base_wall, timespec_fromnanos(nanos));
return 0;
} else {
return einval();
}
}

8
libc/calls/clock_gettime-nt.c
View file

@ -16,12 +16,12 @@
│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR │
│ PERFORMANCE OF THIS SOFTWARE. │
╚─────────────────────────────────────────────────────────────────────────────*/
#include "libc/calls/clock_gettime.internal.h"
#include "libc/fmt/conv.h"
#include "libc/calls/struct/timespec.internal.h"
#include "libc/errno.h"
#include "libc/fmt/wintime.internal.h"
#include "libc/nt/struct/filetime.h"
#include "libc/nt/synchronization.h"
#include "libc/sysv/consts/clock.h"
#include "libc/sysv/errfuns.h"
textwindows int sys_clock_gettime_nt(int clock, struct timespec *ts) {
struct NtFileTime ft;
@ -32,6 +32,6 @@ textwindows int sys_clock_gettime_nt(int clock, struct timespec *ts) {
} else if (clock == CLOCK_MONOTONIC) {
return sys_clock_gettime_mono(ts);
} else {
return einval();
return -EINVAL;
}
}

11
libc/calls/clock_gettime-m1.c → libc/calls/clock_gettime-sysv.c
View file

@ -1,7 +1,7 @@
/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :vi│
╞══════════════════════════════════════════════════════════════════════════════╡
│ Copyright 2022 Justine Alexandra Roberts Tunney │
│ Copyright 2023 Justine Alexandra Roberts Tunney │
│ │
│ Permission to use, copy, modify, and/or distribute this software for │
│ any purpose with or without fee is hereby granted, provided that the │
@ -16,11 +16,10 @@
│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR │
│ PERFORMANCE OF THIS SOFTWARE. │
╚─────────────────────────────────────────────────────────────────────────────*/
#include "libc/calls/struct/timespec.h"
#include "libc/calls/struct/timespec.internal.h"
#include "libc/calls/syscall-sysv.internal.h"
#include "libc/runtime/syslib.internal.h"
#include "libc/calls/syscall_support-sysv.internal.h"
#include "libc/sysv/consts/nr.h"
int sys_clock_gettime_m1(int clock, struct timespec *ts) {
return _sysret(__syslib->__clock_gettime(clock, ts));
int sys_clock_gettime(int clock, struct timespec *ts) {
return __syscall2i(clock, (long)ts, __NR_clock_gettime);
}

42
libc/calls/clock_gettime-xnu.c
View file

@ -16,28 +16,46 @@
│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR │
│ PERFORMANCE OF THIS SOFTWARE. │
╚─────────────────────────────────────────────────────────────────────────────*/
#include "libc/calls/clock_gettime.internal.h"
#include "libc/calls/struct/timespec.internal.h"
#include "libc/calls/struct/timeval.internal.h"
#include "libc/errno.h"
#include "libc/sysv/consts/clock.h"
#include "libc/sysv/errfuns.h"
#ifdef __x86_64__
int sys_clock_gettime_xnu(int clock, struct timespec *ts) {
axdx_t ad;
long ax, dx;
if (clock == CLOCK_REALTIME) {
ad = sys_gettimeofday((struct timeval *)ts, 0, 0);
if (ad.ax != -1) {
if (ad.ax) {
ts->tv_sec = ad.ax;
ts->tv_nsec = ad.dx;
// invoke the system call
//
// int gettimeofday(struct timeval *tp,
// struct timezone *tzp,
// uint64_t *mach_absolute_time);
//
// as follows
//
// ax, dx = gettimeofday(&ts, 0, 0);
//
// to support multiple calling conventions
//
// 1. new xnu returns *ts in memory via rdi
// 2. old xnu returns *ts in rax:rdx regs
//
// we assume this system call always succeeds
asm volatile("syscall"
: "=a"(ax), "=d"(dx)
: "0"(0x2000000 | 116), "D"(ts), "S"(0), "1"(0)
: "rcx", "r8", "r9", "r10", "r11", "memory");
if (ax) {
ts->tv_sec = ax;
ts->tv_nsec = dx;
}
ts->tv_nsec *= 1000;
return 0;
} else {
return -1;
}
} else if (clock == CLOCK_MONOTONIC) {
return sys_clock_gettime_mono(ts);
} else {
return einval();
return -EINVAL;
}
}
#endif /* __x86_64__ */

167
libc/calls/clock_gettime.c
View file

@ -16,82 +16,14 @@
│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR │
│ PERFORMANCE OF THIS SOFTWARE. │
╚─────────────────────────────────────────────────────────────────────────────*/
#include "libc/assert.h"
#include "libc/calls/asan.internal.h"
#include "libc/calls/clock_gettime.internal.h"
#include "libc/calls/state.internal.h"
#include "libc/calls/struct/timespec.h"
#include "libc/calls/struct/timespec.internal.h"
#include "libc/calls/struct/timeval.h"
#include "libc/calls/syscall_support-sysv.internal.h"
#include "libc/dce.h"
#include "libc/fmt/conv.h"
#include "libc/intrin/asan.internal.h"
#include "libc/intrin/asmflag.h"
#include "libc/intrin/bits.h"
#include "libc/errno.h"
#include "libc/intrin/describeflags.internal.h"
#include "libc/intrin/strace.internal.h"
#include "libc/mem/alloca.h"
#include "libc/nt/synchronization.h"
#include "libc/sysv/errfuns.h"
#include "libc/thread/tls.h"
/**
* Returns nanosecond time.
*
* This is a high-precision timer that supports multiple definitions of
* time. Among the more popular is CLOCK_MONOTONIC. This function has a
* zero syscall implementation of that on modern x86.
*
* rdtsc l: 13𝑐 4𝑛𝑠
* gettimeofday l: 44𝑐 14𝑛𝑠
* clock_gettime l: 40𝑐 13𝑛𝑠
* __clock_gettime l: 35𝑐 11𝑛𝑠
* sys_clock_gettime l: 220𝑐 71𝑛𝑠
*
* @param clock can be one of:
* - `CLOCK_REALTIME`: universally supported
* - `CLOCK_REALTIME_FAST`: ditto but faster on freebsd
* - `CLOCK_REALTIME_PRECISE`: ditto but better on freebsd
* - `CLOCK_REALTIME_COARSE`: : like `CLOCK_REALTIME_FAST` w/ Linux 2.6.32+
* - `CLOCK_MONOTONIC`: universally supported
* - `CLOCK_MONOTONIC_FAST`: ditto but faster on freebsd
* - `CLOCK_MONOTONIC_PRECISE`: ditto but better on freebsd
* - `CLOCK_MONOTONIC_COARSE`: : like `CLOCK_MONOTONIC_FAST` w/ Linux 2.6.32+
* - `CLOCK_MONOTONIC_RAW`: is actually monotonic but needs Linux 2.6.28+
* - `CLOCK_PROCESS_CPUTIME_ID`: linux and bsd
* - `CLOCK_THREAD_CPUTIME_ID`: linux and bsd
* - `CLOCK_MONOTONIC_COARSE`: linux, freebsd
* - `CLOCK_PROF`: linux and netbsd
* - `CLOCK_BOOTTIME`: linux and openbsd
* - `CLOCK_REALTIME_ALARM`: linux-only
* - `CLOCK_BOOTTIME_ALARM`: linux-only
* - `CLOCK_TAI`: linux-only
* @param ts is where the result is stored
* @return 0 on success, or -1 w/ errno
* @error EPERM if pledge() is in play without stdio promise
* @error EINVAL if `clock` isn't supported on this system
* @error EFAULT if `ts` points to bad memory
* @see strftime(), gettimeofday()
* @asyncsignalsafe
* @threadsafe
* @vforksafe
*/
int clock_gettime(int clock, struct timespec *ts) {
// threads on win32 stacks call this so we can't asan check *ts
int rc;
if (clock == 127) {
rc = einval(); // 127 is used by consts.sh to mean unsupported
} else {
rc = __clock_gettime(clock, ts);
}
#if SYSDEBUG
if (__tls_enabled && !(__get_tls()->tib_flags & TIB_FLAG_TIME_CRITICAL)) {
POLLTRACE("clock_gettime(%s, [%s]) → %d% m", DescribeClockName(clock),
DescribeTimespec(rc, ts), rc);
}
#endif
return rc;
}
#include "libc/runtime/syslib.internal.h"
#ifdef __aarch64__
#define CGT_VDSO __vdsosym("LINUX_2.6.39", "__kernel_clock_gettime")
@ -99,39 +31,72 @@ int clock_gettime(int clock, struct timespec *ts) {
#define CGT_VDSO __vdsosym("LINUX_2.6", "__vdso_clock_gettime")
#endif
/**
* Returns pointer to fastest clock_gettime().
*/
clock_gettime_f *__clock_gettime_get(bool *opt_out_isfast) {
bool isfast;
clock_gettime_f *res;
if (IsLinux() && (res = CGT_VDSO)) {
isfast = true;
} else if (IsXnu()) {
#ifdef __x86_64__
res = sys_clock_gettime_xnu;
isfast = false;
#elif defined(__aarch64__)
res = sys_clock_gettime_m1;
isfast = true;
#else
#error "unsupported architecture"
#endif
typedef int clock_gettime_f(int, struct timespec *);
static clock_gettime_f *__clock_gettime_get(void) {
clock_gettime_f *cgt;
if (IsLinux() && (cgt = CGT_VDSO)) {
return cgt;
} else if (__syslib) {
return (void *)__syslib->__clock_gettime;
} else if (IsWindows()) {
isfast = true;
res = sys_clock_gettime_nt;
return sys_clock_gettime_nt;
#ifdef __x86_64__
} else if (IsXnu()) {
return sys_clock_gettime_xnu;
#endif
} else {
isfast = false;
res = sys_clock_gettime;
return sys_clock_gettime;
}
if (opt_out_isfast) {
*opt_out_isfast = isfast;
}
return res;
}
int __clock_gettime_init(int clockid, struct timespec *ts) {
clock_gettime_f *gettime;
__clock_gettime = gettime = __clock_gettime_get(0);
return gettime(clockid, ts);
static int __clock_gettime_init(int, struct timespec *);
static clock_gettime_f *__clock_gettime = __clock_gettime_init;
static int __clock_gettime_init(int clockid, struct timespec *ts) {
clock_gettime_f *cgt;
__clock_gettime = cgt = __clock_gettime_get();
return cgt(clockid, ts);
}
/**
* Returns nanosecond time.
*
* @param clock can be one of:
* - `CLOCK_REALTIME`: universally supported
* - `CLOCK_REALTIME_FAST`: ditto but faster on freebsd
* - `CLOCK_REALTIME_PRECISE`: ditto but better on freebsd
* - `CLOCK_REALTIME_COARSE`: : like `CLOCK_REALTIME_FAST` w/ Linux 2.6.32+
* - `CLOCK_MONOTONIC`: universally supported (except on XNU/NT w/o INVTSC)
* - `CLOCK_MONOTONIC_FAST`: ditto but faster on freebsd
* - `CLOCK_MONOTONIC_PRECISE`: ditto but better on freebsd
* - `CLOCK_MONOTONIC_COARSE`: : like `CLOCK_MONOTONIC_FAST` w/ Linux 2.6.32+
* - `CLOCK_MONOTONIC_RAW`: is actually monotonic but needs Linux 2.6.28+
* - `CLOCK_PROCESS_CPUTIME_ID`: linux and bsd (NetBSD permits OR'd PID)
* - `CLOCK_THREAD_CPUTIME_ID`: linux and bsd (NetBSD permits OR'd TID)
* - `CLOCK_MONOTONIC_COARSE`: linux, freebsd
* - `CLOCK_PROF`: linux and netbsd
* - `CLOCK_BOOTTIME`: linux and openbsd
* - `CLOCK_REALTIME_ALARM`: linux-only
* - `CLOCK_BOOTTIME_ALARM`: linux-only
* - `CLOCK_TAI`: linux-only
* @param ts is where the result is stored (or null to do clock check)
* @return 0 on success, or -1 w/ errno
* @raise EFAULT if `ts` points to invalid memory
* @error EINVAL if `clock` isn't supported on this system
* @error EPERM if pledge() is in play without stdio promise
* @error ESRCH on NetBSD if PID/TID OR'd into `clock` wasn't found
* @see strftime(), gettimeofday()
* @asyncsignalsafe
* @vforksafe
*/
int clock_gettime(int clock, struct timespec *ts) {
// threads on win32 stacks call this so we can't asan check *ts
int rc = __clock_gettime(clock, ts);
if (rc) {
errno = -rc;
rc = -1;
}
TIMETRACE("clock_gettime(%s, [%s]) → %d% m", DescribeClockName(clock),
DescribeTimespec(rc, ts), rc);
return rc;
}

16
libc/calls/clock_gettime.internal.h
View file

@ -1,16 +0,0 @@
#ifndef COSMOPOLITAN_LIBC_CALLS_CLOCK_GETTIME_H_
#define COSMOPOLITAN_LIBC_CALLS_CLOCK_GETTIME_H_
#include "libc/calls/struct/timespec.h"
#if !(__ASSEMBLER__ + __LINKER__ + 0)
COSMOPOLITAN_C_START_
typedef int clock_gettime_f(int, struct timespec *);
extern clock_gettime_f *__clock_gettime;
clock_gettime_f *__clock_gettime_get(bool *);
int __clock_gettime_init(int, struct timespec *);
int sys_clock_gettime_mono(struct timespec *);
COSMOPOLITAN_C_END_
#endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */
#endif /* COSMOPOLITAN_LIBC_CALLS_CLOCK_GETTIME_H_ */

28
libc/calls/clock_nanosleep-xnu.c
View file

@ -19,40 +19,40 @@
#include "libc/calls/struct/timespec.h"
#include "libc/calls/struct/timespec.internal.h"
#include "libc/calls/struct/timeval.h"
#include "libc/calls/struct/timeval.internal.h"
#include "libc/calls/syscall-sysv.internal.h"
#include "libc/errno.h"
#include "libc/fmt/conv.h"
#include "libc/intrin/strace.internal.h"
#include "libc/intrin/weaken.h"
#include "libc/runtime/syslib.internal.h"
#include "libc/sock/internal.h"
#include "libc/sysv/consts/clock.h"
#include "libc/sysv/consts/timer.h"
#include "libc/sysv/errfuns.h"
#include "libc/thread/posixthread.internal.h"
#include "libc/thread/thread.h"
#include "libc/thread/tls.h"
int sys_clock_nanosleep_xnu(int clock, int flags, const struct timespec *req,
struct timespec *rem) {
#ifdef __x86_64__
struct timeval abs, now, rel;
if (clock == CLOCK_REALTIME) {
if (flags & TIMER_ABSTIME) {
abs = timespec_totimeval(*req);
sys_gettimeofday_xnu(&now, 0, 0);
if (timeval_cmp(abs, now) > 0) {
rel = timeval_sub(abs, now);
struct timespec now;
sys_clock_gettime_xnu(clock, &now);
if (timespec_cmp(*req, now) > 0) {
struct timeval rel = timespec_totimeval(timespec_sub(*req, now));
return sys_select(0, 0, 0, 0, &rel);
} else {
return 0;
}
} else {
return sys_nanosleep_xnu(req, rem);
int rc;
struct timespec beg;
if (rem) sys_clock_gettime_xnu(CLOCK_REALTIME, &beg);
struct timeval rel = timespec_totimeval(*req); // rounds up
rc = sys_select(0, 0, 0, 0, &rel);
if (rc == -1 && rem && errno == EINTR) {
struct timespec end;
sys_clock_gettime_xnu(CLOCK_REALTIME, &end);
*rem = timespec_subz(*req, timespec_sub(end, beg));
}
} else {
return enotsup();
return rc;
}
#else
long res;

24
libc/calls/clock_nanosleep.c
View file

@ -21,7 +21,6 @@
#include "libc/calls/blockcancel.internal.h"
#include "libc/calls/blocksigs.internal.h"
#include "libc/calls/calls.h"
#include "libc/calls/clock_gettime.internal.h"
#include "libc/calls/cp.internal.h"
#include "libc/calls/state.internal.h"
#include "libc/calls/struct/timespec.h"
@ -76,16 +75,15 @@ static errno_t sys_clock_nanosleep(int clock, int flags,
static struct timespec GetNanosleepLatency(void) {
errno_t rc;
int64_t nanos;
clock_gettime_f *cgt;
struct timespec x, y, w = {0, 1};
if (!(nanos = g_nanosleep_latency)) {
BLOCK_SIGNALS;
for (cgt = __clock_gettime_get(0);;) {
npassert(!cgt(CLOCK_REALTIME_PRECISE, &x));
for (;;) {
unassert(!clock_gettime(CLOCK_REALTIME_PRECISE, &x));
rc = sys_clock_nanosleep(CLOCK_REALTIME, 0, &w, 0);
npassert(!rc || rc == EINTR);
unassert(!rc || rc == EINTR);
if (!rc) {
npassert(!cgt(CLOCK_REALTIME_PRECISE, &y));
unassert(!clock_gettime(CLOCK_REALTIME_PRECISE, &y));
nanos = timespec_tonanos(timespec_sub(y, x));
g_nanosleep_latency = nanos;
break;
@ -107,7 +105,6 @@ static errno_t CheckCancel(void) {
static errno_t SpinNanosleep(int clock, int flags, const struct timespec *req,
struct timespec *rem) {
errno_t rc;
clock_gettime_f *cgt;
struct timespec now, start, elapsed;
if ((rc = CheckCancel())) {
if (rc == EINTR && !flags && rem) {
@ -115,11 +112,10 @@ static errno_t SpinNanosleep(int clock, int flags, const struct timespec *req,
}
return rc;
}
cgt = __clock_gettime_get(0);
npassert(!cgt(CLOCK_REALTIME, &start));
unassert(!clock_gettime(CLOCK_REALTIME, &start));
for (;;) {
pthread_yield();
npassert(!cgt(CLOCK_REALTIME, &now));
unassert(!clock_gettime(CLOCK_REALTIME, &now));
if (flags & TIMER_ABSTIME) {
if (timespec_cmp(now, *req) >= 0) {
return 0;
@ -177,7 +173,7 @@ static bool ShouldUseSpinNanosleep(int clock, int flags,
return false;
}
e = errno;
if (__clock_gettime_get(0)(clock, &now)) {
if (clock_gettime(clock, &now)) {
// punt to the nanosleep system call
errno = e;
return false;
@ -258,12 +254,8 @@ errno_t clock_nanosleep(int clock, int flags, const struct timespec *req,
} else {
rc = sys_clock_nanosleep(clock, flags, req, rem);
}
#if SYSDEBUG
if (__tls_enabled && !(__get_tls()->tib_flags & TIB_FLAG_TIME_CRITICAL)) {
STRACE("clock_nanosleep(%s, %s, %s, [%s]) → %s", DescribeClockName(clock),
TIMETRACE("clock_nanosleep(%s, %s, %s, [%s]) → %s", DescribeClockName(clock),
DescribeSleepFlags(flags), DescribeTimespec(0, req),
DescribeTimespec(rc, rem), DescribeErrno(rc));
}
#endif
return rc;
}

1
libc/calls/creat.c
View file

@ -34,7 +34,6 @@
* @cancellationpoint
* @asyncsignalsafe
* @restartable
* @threadsafe
* @vforksafe
*/
int creat(const char *file, uint32_t mode) {

2
libc/calls/fstat-nt.c
View file

@ -21,7 +21,7 @@
#include "libc/calls/internal.h"
#include "libc/calls/struct/stat.h"
#include "libc/calls/syscall_support-nt.internal.h"
#include "libc/fmt/conv.h"
#include "libc/fmt/wintime.internal.h"
#include "libc/intrin/atomic.h"
#include "libc/intrin/bsr.h"
#include "libc/intrin/strace.internal.h"

2
libc/calls/fstatvfs.c
View file

@ -35,3 +35,5 @@ int fstatvfs(int fd, struct statvfs *sv) {
return -1;
}
}
__weak_reference(fstatvfs, fstatvfs64);

1
libc/calls/ftruncate.c
View file

@ -60,7 +60,6 @@
* @raise ENOSYS on bare metal
* @cancellationpoint
* @asyncsignalsafe
* @threadsafe
*/
int ftruncate(int fd, int64_t length) {
int rc;

1
libc/calls/futimens.c
View file

@ -40,7 +40,6 @@
* @raise EFAULT if `ts` memory was invalid
* @raise ENOSYS on RHEL5 or bare metal
* @asyncsignalsafe
* @threadsafe
*/
int futimens(int fd, const struct timespec ts[2]) {
int rc;

1
libc/calls/futimes.c
View file

@ -37,7 +37,6 @@
* @raise ENOSYS on RHEL5 or bare metal
* @see futimens() for modern version
* @asyncsignalsafe
* @threadsafe
*/
int futimes(int fd, const struct timeval tv[2]) {
int rc;

1
libc/calls/getcontext.S
View file

@ -30,7 +30,6 @@
// @see makecontext()
// @see swapcontext()
// @see setcontext()
// @threadsafe
.ftrace1
getcontext:
.ftrace2

1
libc/calls/getppid.c
View file

@ -28,7 +28,6 @@
* @return parent process id (always successful)
* @note slow on Windows; needs to iterate process tree
* @asyncsignalsafe
* @threadsafe
* @vforksafe
*/
int getppid(void) {

2
libc/calls/getrusage-nt.c
View file

@ -19,7 +19,7 @@
#include "libc/calls/sig.internal.h"
#include "libc/calls/struct/rusage.internal.h"
#include "libc/calls/syscall_support-nt.internal.h"
#include "libc/fmt/conv.h"
#include "libc/fmt/wintime.internal.h"
#include "libc/nt/accounting.h"
#include "libc/nt/process.h"
#include "libc/nt/runtime.h"

35
libc/calls/gettimeofday-m1.c
View file

@ -1,35 +0,0 @@
/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :vi│
╞══════════════════════════════════════════════════════════════════════════════╡
│ Copyright 2020 Justine Alexandra Roberts Tunney │
│ │
│ Permission to use, copy, modify, and/or distribute this software for │
│ any purpose with or without fee is hereby granted, provided that the │
│ above copyright notice and this permission notice appear in all copies. │
│ │
│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL │
│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED │
│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE │
│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL │
│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR │
│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER │
│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR │
│ PERFORMANCE OF THIS SOFTWARE. │
╚─────────────────────────────────────────────────────────────────────────────*/
#include "libc/calls/struct/timespec.h"
#include "libc/calls/struct/timeval.h"
#include "libc/calls/struct/timeval.internal.h"
#include "libc/calls/syscall-sysv.internal.h"
#include "libc/runtime/syslib.internal.h"
#include "libc/sysv/consts/clock.h"
axdx_t sys_gettimeofday_m1(struct timeval *tv, struct timezone *tz, void *wut) {
axdx_t ad;
struct timespec ts;
ad.ax = _sysret(__syslib->__clock_gettime(CLOCK_REALTIME, &ts));
ad.dx = 0;
if (!ad.ax && tv) {
*tv = timespec_totimeval(ts);
}
return ad;
}

25
libc/calls/gettimeofday-metal.c
View file

@ -1,25 +0,0 @@
/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :vi│
╞══════════════════════════════════════════════════════════════════════════════╡
│ Copyright 2020 Justine Alexandra Roberts Tunney │
│ │
│ Permission to use, copy, modify, and/or distribute this software for │
│ any purpose with or without fee is hereby granted, provided that the │
│ above copyright notice and this permission notice appear in all copies. │
│ │
│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL │
│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED │
│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE │
│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL │
│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR │
│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER │
│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR │
│ PERFORMANCE OF THIS SOFTWARE. │
╚─────────────────────────────────────────────────────────────────────────────*/
#include "libc/calls/struct/timeval.internal.h"
#include "libc/time/struct/timezone.h"
axdx_t sys_gettimeofday_metal(struct timeval *tv, struct timezone *tz,
void *wut) {
return (axdx_t){-1, 0};
}

31
libc/calls/gettimeofday-nt.c
View file

@ -1,31 +0,0 @@
/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :vi│
╞══════════════════════════════════════════════════════════════════════════════╡
│ Copyright 2020 Justine Alexandra Roberts Tunney │
│ │
│ Permission to use, copy, modify, and/or distribute this software for │
│ any purpose with or without fee is hereby granted, provided that the │
│ above copyright notice and this permission notice appear in all copies. │
│ │
│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL │
│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED │
│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE │
│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL │
│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR │
│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER │
│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR │
│ PERFORMANCE OF THIS SOFTWARE. │
╚─────────────────────────────────────────────────────────────────────────────*/
#include "libc/fmt/conv.h"
#include "libc/nt/struct/filetime.h"
#include "libc/nt/synchronization.h"
#include "libc/str/str.h"
textwindows axdx_t sys_gettimeofday_nt(struct timeval *tv, struct timezone *tz,
void *wut) {
struct NtFileTime ft;
GetSystemTimeAsFileTime(&ft);
if (tv) *tv = FileTimeToTimeVal(ft);
if (tz) bzero(tz, sizeof(*tz));
return (axdx_t){0, 0};
}

31
libc/calls/gettimeofday-xnu.c
View file

@ -1,31 +0,0 @@
/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :vi│
╞══════════════════════════════════════════════════════════════════════════════╡
│ Copyright 2020 Justine Alexandra Roberts Tunney │
│ │
│ Permission to use, copy, modify, and/or distribute this software for │
│ any purpose with or without fee is hereby granted, provided that the │
│ above copyright notice and this permission notice appear in all copies. │
│ │
│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL │
│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED │
│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE │
│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL │
│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR │
│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER │
│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR │
│ PERFORMANCE OF THIS SOFTWARE. │
╚─────────────────────────────────────────────────────────────────────────────*/
#include "libc/calls/struct/timeval.internal.h"
axdx_t sys_gettimeofday_xnu(struct timeval *tv, struct timezone *tz,
void *wut) {
axdx_t ad;
ad = sys_gettimeofday(tv, tz, wut);
if (ad.ax > 0 && tv) {
tv->tv_sec = ad.ax;
tv->tv_usec = ad.dx;
ad.ax = 0;
}
return ad;
}

81
libc/calls/gettimeofday.c
View file

@ -16,24 +16,11 @@
│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR │
│ PERFORMANCE OF THIS SOFTWARE. │
╚─────────────────────────────────────────────────────────────────────────────*/
#include "libc/assert.h"
#include "libc/calls/state.internal.h"
#include "libc/calls/struct/itimerval.internal.h"
#include "libc/calls/struct/timespec.h"
#include "libc/calls/struct/timeval.h"
#include "libc/calls/struct/timeval.internal.h"
#include "libc/calls/syscall_support-sysv.internal.h"
#include "libc/dce.h"
#include "libc/intrin/asan.internal.h"
#include "libc/intrin/describeflags.internal.h"
#include "libc/intrin/strace.internal.h"
#include "libc/sysv/errfuns.h"
#include "libc/thread/tls.h"
#include "libc/sysv/consts/clock.h"
#include "libc/time/struct/timezone.h"
typedef axdx_t gettimeofday_f(struct timeval *, struct timezone *, void *);
static gettimeofday_f __gettimeofday_init;
static gettimeofday_f *__gettimeofday = __gettimeofday_init;
/**
* Returns system wall time in microseconds, e.g.
*
@ -47,60 +34,26 @@ static gettimeofday_f *__gettimeofday = __gettimeofday_init;
* iso8601(p, &tm);
* printf("%s\n", p);
*
* @param tv points to timeval that receives result if non-NULL
* @param tz receives UTC timezone if non-NULL
* @param tv points to timeval that receives result if non-null
* @param tz is completely ignored
* @return 0 on success, or -1 w/ errno
* @raise EFAULT if `tv` points to invalid memory
* @see clock_gettime() for nanosecond precision
* @see strftime() for string formatting
* @asyncsignalsafe
* @vforksafe
*/
int gettimeofday(struct timeval *tv, struct timezone *tz) {
int rc = __gettimeofday(tv, tz, 0).ax;
#if SYSDEBUG
if (__tls_enabled && !(__get_tls()->tib_flags & TIB_FLAG_TIME_CRITICAL)) {
POLLTRACE("gettimeofday([%s], %p) → %d% m", DescribeTimeval(rc, tv), tz,
rc);
}
#endif
return rc;
}
/**
* Returns pointer to fastest gettimeofday().
*/
gettimeofday_f *__gettimeofday_get(bool *opt_out_isfast) {
bool isfast;
gettimeofday_f *res;
if (IsLinux() && (res = __vdsosym("LINUX_2.6", "__vdso_gettimeofday"))) {
isfast = true;
} else if (IsWindows()) {
isfast = true;
res = sys_gettimeofday_nt;
} else if (IsXnu()) {
#ifdef __x86_64__
res = sys_gettimeofday_xnu;
isfast = false;
#elif defined(__aarch64__)
res = sys_gettimeofday_m1;
isfast = true;
#else
#error "unsupported architecture"
#endif
} else if (IsMetal()) {
isfast = false;
res = sys_gettimeofday_metal;
if (tv) {
struct timespec ts;
if (clock_gettime(CLOCK_REALTIME, &ts) != -1) {
tv->tv_sec = ts.tv_sec;
tv->tv_usec = (ts.tv_nsec + 999) / 1000;
return 0;
} else {
isfast = false;
res = sys_gettimeofday;
return -1;
}
if (opt_out_isfast) {
*opt_out_isfast = isfast;
} else {
return 0;
}
return res;
}
static axdx_t __gettimeofday_init(struct timeval *tv, //
struct timezone *tz, //
void *arg) {
gettimeofday_f *gettime;
__gettimeofday = gettime = __gettimeofday_get(0);
return gettime(tv, tz, 0);
}

2
libc/calls/getuid.c
View file

@ -37,7 +37,6 @@
*
* @return user id (always successful)
* @asyncsignalsafe
* @threadsafe
* @vforksafe
*/
uint32_t getuid(void) {
@ -62,7 +61,6 @@ uint32_t getuid(void) {
*
* @return group id (always successful)
* @asyncsignalsafe
* @threadsafe
* @vforksafe
*/
uint32_t getgid(void) {

1
libc/calls/lseek.c
View file

@ -72,7 +72,6 @@
* @raise EINVAL if resulting offset would be negative
* @raise EINVAL if `whence` isn't valid
* @asyncsignalsafe
* @threadsafe
* @vforksafe
*/
int64_t lseek(int fd, int64_t offset, int whence) {

1
libc/calls/makedirs.c
View file

@ -44,7 +44,6 @@
* @raise ENOENT if `path` is an empty string
* @raise ELOOP if loop was detected resolving components of `path`
* @asyncsignalsafe
* @threadsafe
*/
int makedirs(const char *path, unsigned mode) {
int c, e, i, n;

1
libc/calls/mkdir.c
View file

@ -45,7 +45,6 @@
* @see makedirs() which is higher-level
* @see mkdirat() for modern call
* @asyncsignalsafe
* @threadsafe
*/
int mkdir(const char *path, unsigned mode) {
return mkdirat(AT_FDCWD, path, mode);

1
libc/calls/munmap-sysv.c
View file

@ -29,7 +29,6 @@
* but it works on everything else including bare metal.
*
* @asyncsignalsafe
* @threadsafe
*/
int sys_munmap(void *p, size_t n) {
int rc;

51
libc/calls/nanosleep-xnu.c
View file

@ -1,51 +0,0 @@
/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :vi│
╞══════════════════════════════════════════════════════════════════════════════╡
│ Copyright 2020 Justine Alexandra Roberts Tunney │
│ │
│ Permission to use, copy, modify, and/or distribute this software for │
│ any purpose with or without fee is hereby granted, provided that the │
│ above copyright notice and this permission notice appear in all copies. │
│ │
│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL │
│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED │
│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE │
│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL │
│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR │
│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER │
│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR │
│ PERFORMANCE OF THIS SOFTWARE. │
╚─────────────────────────────────────────────────────────────────────────────*/
#include "libc/calls/struct/timespec.h"
#include "libc/calls/struct/timespec.internal.h"
#include "libc/calls/struct/timeval.h"
#include "libc/calls/struct/timeval.internal.h"
#include "libc/calls/syscall-sysv.internal.h"
#include "libc/errno.h"
#include "libc/runtime/syslib.internal.h"
#include "libc/sock/internal.h"
// nanosleep() on xnu: a bloodbath of a polyfill
// consider using clock_nanosleep(TIMER_ABSTIME)
int sys_nanosleep_xnu(const struct timespec *req, struct timespec *rem) {
#ifdef __x86_64__
int rc;
struct timeval wt, t1, t2, td;
if (rem) sys_gettimeofday_xnu(&t1, 0, 0);
wt = timespec_totimeval(*req); // rounds up
rc = sys_select(0, 0, 0, 0, &wt);
if (rem && rc == -1 && errno == EINTR) {
sys_gettimeofday_xnu(&t2, 0, 0);
td = timeval_sub(t2, t1);
if (timeval_cmp(td, wt) >= 0) {
rem->tv_sec = 0;
rem->tv_nsec = 0;
} else {
*rem = timeval_totimespec(timeval_sub(wt, td));
}
}
return rc;
#else
return _sysret(__syslib->__nanosleep(req, rem));
#endif
}

6
libc/calls/nanosleep.c
View file

@ -37,11 +37,11 @@
* @norestart
*/
int nanosleep(const struct timespec *req, struct timespec *rem) {
int rc;
if (!(rc = clock_nanosleep(CLOCK_REALTIME, 0, req, rem))) {
errno_t err;
if (!(err = clock_nanosleep(CLOCK_REALTIME, 0, req, rem))) {
return 0;
} else {
errno = rc;
errno = err;
return -1;
}
}

7
libc/calls/ntaccesscheck.c
View file

@ -16,6 +16,7 @@
│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR │
│ PERFORMANCE OF THIS SOFTWARE. │
╚─────────────────────────────────────────────────────────────────────────────*/
#include "libc/assert.h"
#include "libc/calls/calls.h"
#include "libc/calls/internal.h"
#include "libc/calls/syscall_support-nt.internal.h"
@ -35,6 +36,7 @@
#include "libc/nt/errors.h"
#include "libc/nt/files.h"
#include "libc/nt/runtime.h"
#include "libc/nt/struct/byhandlefileinformation.h"
#include "libc/nt/struct/genericmapping.h"
#include "libc/nt/struct/privilegeset.h"
#include "libc/nt/struct/securitydescriptor.h"
@ -62,6 +64,7 @@ textwindows int ntaccesscheck(const char16_t *pathname, uint32_t flags) {
struct NtGenericMapping mapping;
struct NtPrivilegeSet privileges;
uint32_t secsize, granted, privsize;
struct NtByHandleFileInformation wst;
int64_t hToken, hImpersonatedToken, hFile;
intptr_t buffer[1024 / sizeof(intptr_t)];
if (flags & X_OK) flags |= R_OK;
@ -100,7 +103,9 @@ textwindows int ntaccesscheck(const char16_t *pathname, uint32_t flags) {
0, kNtOpenExisting,
kNtFileAttributeNormal | kNtFileFlagBackupSemantics,
0)) != -1) {
if (IsWindowsExecutable(hFile)) {
unassert(GetFileInformationByHandle(hFile, &wst));
if ((wst.dwFileAttributes & kNtFileAttributeDirectory) ||
IsWindowsExecutable(hFile)) {
rc = 0;
} else {
rc = eacces();

1
libc/calls/open.c
View file

@ -32,7 +32,6 @@
* @cancellationpoint
* @asyncsignalsafe
* @restartable
* @threadsafe
* @vforksafe
*/
int open(const char *file, int flags, ...) {

1
libc/calls/openat.c
View file

@ -168,7 +168,6 @@
* @cancellationpoint
* @asyncsignalsafe
* @restartable
* @threadsafe
* @vforksafe
*/
int openat(int dirfd, const char *path, int flags, ...) {

1
libc/calls/pledge-linux.c
View file

@ -2297,7 +2297,6 @@ static privileged void AppendPledge(struct Filter *f, //
* @param ipromises is inverted integer bitmask of pledge() promises
* @return 0 on success, or negative error number on error
* @asyncsignalsafe
* @threadsafe
* @vforksafe
*/
privileged int sys_pledge_linux(unsigned long ipromises, int mode) {

1
libc/calls/pledge.c
View file

@ -234,7 +234,6 @@
* @raise ENOSYS if `pledge(0, 0)` was used and security is not possible
* @raise EINVAL if `execpromises` on Linux isn't a subset of `promises`
* @raise EINVAL if `promises` allows exec and `execpromises` is null
* @threadsafe
* @vforksafe
*/
int pledge(const char *promises, const char *execpromises) {

1
libc/calls/poll.c
View file

@ -62,7 +62,6 @@
* @raise EINTR if signal was delivered
* @cancellationpoint
* @asyncsignalsafe
* @threadsafe
* @norestart
*/
int poll(struct pollfd *fds, size_t nfds, int timeout_ms) {

1
libc/calls/posix_fadvise.c
View file

@ -46,7 +46,6 @@ int sys_fadvise_netbsd(int, int, int64_t, int64_t, int) asm("sys_fadvise");
* @raise ENOTSUP if `fd` is a /zip file
* @raise ENOSYS on XNU and OpenBSD
* @returnserrno
* @threadsafe
*/
errno_t posix_fadvise(int fd, int64_t offset, int64_t len, int advice) {
int rc, e = errno;

1
libc/calls/posix_madvise.c
View file

@ -24,7 +24,6 @@
*
* @return 0 on success, or errno on error
* @returnserrno
* @threadsafe
*/
errno_t posix_madvise(void *addr, uint64_t len, int advice) {
int rc, e = errno;

1
libc/calls/ppoll.c
View file

@ -57,7 +57,6 @@
* @raise EINTR if signal was delivered
* @cancellationpoint
* @asyncsignalsafe
* @threadsafe
* @norestart
*/
int ppoll(struct pollfd *fds, size_t nfds, const struct timespec *timeout,

1
libc/calls/pread.c
View file

@ -52,7 +52,6 @@
* @see pwrite(), write()
* @cancellationpoint
* @asyncsignalsafe
* @threadsafe
* @vforksafe
*/
ssize_t pread(int fd, void *buf, size_t size, int64_t offset) {

1
libc/calls/pwrite.c
View file

@ -46,7 +46,6 @@
* @see pread(), write()
* @cancellationpoint
* @asyncsignalsafe
* @threadsafe
* @vforksafe
*/
ssize_t pwrite(int fd, const void *buf, size_t size, int64_t offset) {

4
libc/calls/read-nt.c
View file

@ -53,8 +53,6 @@
#include "libc/thread/tls.h"
#ifdef __x86_64__
__msabi extern typeof(CloseHandle) *const __imp_CloseHandle;
static const struct {
int vk;
int normal_str;
@ -578,7 +576,7 @@ textwindows ssize_t sys_read_nt_impl(int fd, void *data, size_t size,
goto BlockingOperation;
}
}
__imp_CloseHandle(overlap.hEvent); // __imp_ to avoid log noise
CloseHandle(overlap.hEvent);
if (!pwriting && seekable) {
if (ok) f->pointer = offset + got;

2
libc/calls/reservefd.c
View file

@ -51,7 +51,6 @@ int __ensurefds_unlocked(int fd) {
/**
* Grows file descriptor array memory if needed.
* @asyncsignalsafe
* @threadsafe
*/
int __ensurefds(int fd) {
__fds_lock();
@ -89,7 +88,6 @@ int __reservefd_unlocked(int start) {
/**
* Finds open file descriptor slot.
* @asyncsignalsafe
* @threadsafe
*/
int __reservefd(int start) {
int fd;

8
libc/calls/siginfo2cosmo.c
View file

@ -85,6 +85,14 @@ privileged void __siginfo2cosmo(struct siginfo *si,
notpossible;
}
// Turn BUS_OBJERR into BUS_ADRERR for consistency with Linux.
// See test/libc/calls/sigbus_test.c
if (IsFreebsd() || IsOpenbsd()) {
if (si_signo == 10 && si_code == 3) {
si_code = 2;
}
}
*si = (struct siginfo){0};
si->si_signo = si_signo;
si->si_errno = si_errno;

1
libc/calls/state.internal.h
View file

@ -6,7 +6,6 @@
COSMOPOLITAN_C_START_
extern int __vforked;
extern bool __time_critical;
extern pthread_mutex_t __fds_lock_obj;
extern unsigned __sighandrvas[NSIG + 1];
extern unsigned __sighandflags[NSIG + 1];

2
libc/calls/statvfs.c
View file

@ -35,3 +35,5 @@ int statvfs(const char *path, struct statvfs *sv) {
return -1;
}
}
__strong_reference(statvfs, statvfs64);

10
libc/calls/__clock_gettime.c → libc/calls/stime.c
View file

@ -16,6 +16,12 @@
│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR │
│ PERFORMANCE OF THIS SOFTWARE. │
╚─────────────────────────────────────────────────────────────────────────────*/
#include "libc/calls/clock_gettime.internal.h"
#include "libc/calls/struct/timeval.h"
#include "libc/time/time.h"
clock_gettime_f *__clock_gettime = __clock_gettime_init;
/**
* Changes time, the old fashioned way.
*/
int stime(const int64_t *t) {
return settimeofday(&(struct timeval){*t}, 0);
}

6
libc/calls/struct/timespec.internal.h
View file

@ -10,18 +10,18 @@ int __sys_clock_nanosleep(int, int, const struct timespec *, struct timespec *);
int __sys_utimensat(int, const char *, const struct timespec[2], int);
int __utimens(int, const char *, const struct timespec[2], int);
int sys_clock_getres(int, struct timespec *);
int sys_clock_settime(int, const struct timespec *);
int sys_clock_gettime(int, struct timespec *);
int sys_clock_gettime_nt(int, struct timespec *);
int sys_clock_gettime_m1(int, struct timespec *);
int sys_clock_gettime_mono(struct timespec *);
int sys_clock_gettime_nt(int, struct timespec *);
int sys_clock_gettime_xnu(int, struct timespec *);
int sys_clock_nanosleep_nt(int, int, const struct timespec *, struct timespec *);
int sys_clock_nanosleep_openbsd(int, int, const struct timespec *, struct timespec *);
int sys_clock_nanosleep_xnu(int, int, const struct timespec *, struct timespec *);
int sys_clock_settime(int, const struct timespec *);
int sys_futimens(int, const struct timespec[2]);
int sys_nanosleep(const struct timespec *, struct timespec *);
int sys_nanosleep_nt(const struct timespec *, struct timespec *);
int sys_nanosleep_xnu(const struct timespec *, struct timespec *);
int sys_sem_timedwait(int64_t, const struct timespec *);
int sys_utimensat(int, const char *, const struct timespec[2], int);
int sys_utimensat_nt(int, const char *, const struct timespec[2], int);

5
libc/calls/struct/timeval.internal.h
View file

@ -6,16 +6,11 @@
#if !(__ASSEMBLER__ + __LINKER__ + 0)
COSMOPOLITAN_C_START_
axdx_t sys_gettimeofday(struct timeval *, struct timezone *, void *);
int sys_settimeofday(const struct timeval *, const struct timezone *);
int sys_futimes(int, const struct timeval *);
int sys_lutimes(const char *, const struct timeval *);
int sys_utimes(const char *, const struct timeval *);
axdx_t sys_gettimeofday_m1(struct timeval *, struct timezone *, void *);
axdx_t sys_gettimeofday_xnu(struct timeval *, struct timezone *, void *);
axdx_t sys_gettimeofday_nt(struct timeval *, struct timezone *, void *);
int sys_utimes_nt(const char *, const struct timeval[2]);
axdx_t sys_gettimeofday_metal(struct timeval *, struct timezone *, void *);
const char *DescribeTimeval(char[45], int, const struct timeval *);
#define DescribeTimeval(rc, ts) DescribeTimeval(alloca(45), rc, ts)

1
libc/calls/swapcontext.S
View file

@ -35,7 +35,6 @@
//
// @return 0 on success, or -1 w/ errno
// @returnstwice
// @threadsafe
.ftrace1
swapcontext:
.ftrace2

5
libc/calls/syscall_support-sysv.internal.h
View file

@ -6,6 +6,11 @@ COSMOPOLITAN_C_START_
│ cosmopolitan § syscalls » system five » structless support ─╬─│┼
╚────────────────────────────────────────────────────────────────────────────│*/
long __syscall2(long, long, int);
int __syscall2i(long, long, int) asm("__syscall2");
long __syscall3(long, long, long, int);
int __syscall3i(long, long, long, int) asm("__syscall3");
bool __is_linux_2_6_23(void);
bool32 sys_isatty_metal(int);
int __fixupnewfd(int, int);

2
libc/calls/timespec_real.c
View file

@ -31,6 +31,6 @@
*/
struct timespec timespec_real(void) {
struct timespec ts;
npassert(!clock_gettime(CLOCK_REALTIME, &ts));
unassert(!clock_gettime(CLOCK_REALTIME, &ts));
return ts;
}

1
libc/calls/tmpfd.c
View file

@ -71,7 +71,6 @@ int _mkstemp(char *, int);
* @see tmpfile() for stdio version
* @cancellationpoint
* @asyncsignalsafe
* @threadsafe
* @vforksafe
*/
int tmpfd(void) {

1
libc/calls/truncate.c
View file

@ -61,7 +61,6 @@
* @raise ENOSYS on bare metal
* @cancellationpoint
* @see ftruncate()
* @threadsafe
*/
int truncate(const char *path, int64_t length) {
int rc;

2
libc/calls/ttyname.c
View file

@ -17,7 +17,7 @@
│ PERFORMANCE OF THIS SOFTWARE. │
╚─────────────────────────────────────────────────────────────────────────────*/
#include "libc/calls/calls.h"
#include "libc/calls/sysparam.h"
#include "libc/stdio/sysparam.h"
#include "libc/errno.h"
#include "libc/log/log.h"
#include "libc/paths.h"

1
libc/calls/ttyname_r.c
View file

@ -85,7 +85,6 @@ static errno_t ttyname_linux(int fd, char *buf, size_t size) {
* @return 0 on success, or error number on error
* @raise ERANGE if `size` was too small
* @returnserrno
* @threadsafe
*/
errno_t ttyname_r(int fd, char *buf, size_t size) {
errno_t e, res;

1
libc/calls/ucontext.c
View file

@ -43,7 +43,6 @@ static int __contextmask(const sigset_t *opt_set, sigset_t *opt_out_oldset) {
* @see swapcontext()
* @see makecontext()
* @see getcontext()
* @threadsafe
*/
int setcontext(const ucontext_t *uc) {
if (__contextmask(&uc->uc_sigmask, 0)) return -1;

1
libc/calls/unveil.c
View file

@ -460,7 +460,6 @@ int sys_unveil_linux(const char *path, const char *permissions) {
* @note on Linux this function requires Linux Kernel 5.13+ and version 6.2+
* to properly support truncation operations
* @see [1] https://docs.kernel.org/userspace-api/landlock.html
* @threadsafe
*/
int unveil(const char *path, const char *permissions) {
int e, rc;

1
libc/calls/utime.c
View file

@ -26,7 +26,6 @@
* @return 0 on success, or -1 w/ errno
* @see utimensat() for modern version
* @asyncsignalsafe
* @threadsafe
*/
int utime(const char *path, const struct utimbuf *times) {
struct timeval tv[2];

3
libc/calls/utimensat-nt.c
View file

@ -17,8 +17,9 @@
│ PERFORMANCE OF THIS SOFTWARE. │
╚─────────────────────────────────────────────────────────────────────────────*/
#include "libc/calls/internal.h"
#include "libc/calls/struct/timespec.h"
#include "libc/calls/syscall_support-nt.internal.h"
#include "libc/fmt/conv.h"
#include "libc/fmt/wintime.internal.h"
#include "libc/nt/createfile.h"
#include "libc/nt/enum/accessmask.h"
#include "libc/nt/enum/creationdisposition.h"

1
libc/calls/utimensat.c
View file

@ -51,7 +51,6 @@
* @raise ENOTSUP on XNU or RHEL5 when `dirfd` isn't `AT_FDCWD`
* @raise ENOSYS on bare metal
* @asyncsignalsafe
* @threadsafe
*/
int utimensat(int dirfd, const char *path, const struct timespec ts[2],
int flags) {

1
libc/calls/utimes.c
View file

@ -32,7 +32,6 @@
* @note truncates to second precision on rhel5
* @see utimensat() for modern version
* @asyncsignalsafe
* @threadsafe
*/
int utimes(const char *path, const struct timeval tv[2]) {
int rc;

17
libc/calls/vdsofunc.greg.c
View file

@ -27,6 +27,7 @@
#include "libc/elf/struct/verdaux.h"
#include "libc/elf/struct/verdef.h"
#include "libc/intrin/bits.h"
#include "libc/intrin/getauxval.internal.h"
#include "libc/intrin/strace.internal.h"
#include "libc/runtime/runtime.h"
#include "libc/str/str.h"
@ -55,7 +56,7 @@ static inline int CheckDsoSymbolVersion(Elf64_Verdef *vd, int sym,
}
/**
* Returns address of vDSO function.
* Returns address of "Virtual Dynamic Shared Object" function on Linux.
*/
void *__vdsosym(const char *version, const char *name) {
void *p;
@ -64,23 +65,19 @@ void *__vdsosym(const char *version, const char *name) {
Elf64_Phdr *phdr;
char *strtab = 0;
size_t *dyn, base;
unsigned long *ap;
Elf64_Sym *symtab = 0;
uint16_t *versym = 0;
Elf_Symndx *hashtab = 0;
Elf64_Verdef *verdef = 0;
struct AuxiliaryValue av;
for (ehdr = 0, ap = __auxv; ap[0]; ap += 2) {
if (ap[0] == AT_SYSINFO_EHDR) {
ehdr = (void *)ap[1];
break;
}
}
if (!ehdr || READ32LE(ehdr->e_ident) != READ32LE("\177ELF")) {
KERNTRACE("__vdsosym() → AT_SYSINFO_EHDR ELF not found");
av = __getauxval(AT_SYSINFO_EHDR);
if (!av.isfound) {
KERNTRACE("__vdsosym() → missing AT_SYSINFO_EHDR");
return 0;
}
ehdr = (void *)av.value;
phdr = (void *)((char *)ehdr + ehdr->e_phoff);
for (base = -1, dyn = 0, i = 0; i < ehdr->e_phnum;
i++, phdr = (void *)((char *)phdr + ehdr->e_phentsize)) {

2
libc/calls/weirdtypes.h
View file

@ -64,6 +64,7 @@ typedef uint32_t nlink_t; /* uint16_t on xnu */
#define fstat64 fstat
#define fstatat64 fstatat
#define fstatfs64 fstatfs
#define fstatvfs64 fstatvfs
#define getrlimit64 getrlimit
#define ino64_t ino_t
#define lockf64 lockf
@ -83,6 +84,7 @@ typedef uint32_t nlink_t; /* uint16_t on xnu */
#define setrlimit64 setrlimit
#define stat64 stat
#define statfs64 statfs
#define statvfs64 statvfs
#define versionsort64 versionsort
#endif

17
libc/calls/winexec.c
View file

@ -17,12 +17,27 @@
│ PERFORMANCE OF THIS SOFTWARE. │
╚─────────────────────────────────────────────────────────────────────────────*/
#include "libc/calls/internal.h"
#include "libc/nt/errors.h"
#include "libc/nt/events.h"
#include "libc/nt/files.h"
#include "libc/nt/runtime.h"
#include "libc/nt/struct/overlapped.h"
// checks if file should be considered an executable on windows
textwindows int IsWindowsExecutable(int64_t handle) {
// read first two bytes of file
// access() and stat() aren't cancelation points
char buf[2];
uint32_t got;
return ReadFile(handle, buf, 2, &got, 0) && got == 2 &&
struct NtOverlapped overlap = {.hEvent = CreateEvent(0, 0, 0, 0)};
bool ok = (ReadFile(handle, buf, 2, 0, &overlap) ||
GetLastError() == kNtErrorIoPending) &&
GetOverlappedResult(handle, &overlap, &got, true);
CloseHandle(overlap.hEvent);
// it's an executable if it starts with `MZ` or `#!`
return ok && got == 2 && //
((buf[0] == 'M' && buf[1] == 'Z') || //
(buf[0] == '#' && buf[1] == '!'));
}

4
libc/calls/write-nt.c
View file

@ -47,8 +47,6 @@
#include "libc/thread/thread.h"
#include "libc/thread/tls.h"
__msabi extern typeof(CloseHandle) *const __imp_CloseHandle;
static bool IsMouseModeCommand(int x) {
return x == 1000 || // SET_VT200_MOUSE
x == 1002 || // SET_BTN_EVENT_MOUSE
@ -202,7 +200,7 @@ static textwindows ssize_t sys_write_nt_impl(int fd, void *data, size_t size,
goto BlockingOperation;
}
}
__imp_CloseHandle(overlap.hEvent); // __imp_ to avoid log noise
CloseHandle(overlap.hEvent);
if (seekable && !pwriting) {
if (ok) f->pointer = offset + sent;

1
libc/dns/freeaddrinfo.c
View file

@ -21,7 +21,6 @@
/**
* Frees addresses returned by getaddrinfo().
* @threadsafe
*/
void freeaddrinfo(struct addrinfo *ai) {
struct addrinfo *next;

1
libc/dns/getaddrinfo.c
View file

@ -41,7 +41,6 @@
* @param res receives a pointer that must be freed with freeaddrinfo(),
* and won't be modified if non-zero is returned
* @return 0 on success or EAI_xxx value
* @threadsafe
*/
int getaddrinfo(const char *name, const char *service,
const struct addrinfo *hints, struct addrinfo **res) {

1
libc/dns/gethoststxt.c
View file

@ -51,7 +51,6 @@ static const char *GetHostsTxtPath(char *path, size_t size) {
* Returns hosts.txt map.
*
* @note yoinking realloc() ensures there's no size limits
* @threadsafe
*/
const struct HostsTxt *GetHostsTxt(void) {
FILE *f;

1
libc/dns/getresolvconf.c
View file

@ -37,7 +37,6 @@ static struct ResolvConfInitialStaticMemory {
/**
* Returns singleton with DNS server address.
* @threadsafe
*/
const struct ResolvConf *GetResolvConf(void) {
int rc;

1
libc/dns/lookupservicesbyname.c
View file

@ -50,7 +50,6 @@
* @return -1 on error, or positive port number
* @note aliases are read from file for comparison, but not returned.
* @see LookupServicesByPort
* @threadsafe
*/
int LookupServicesByName(const char *servname, char *servproto,
size_t servprotolen, char *buf, size_t bufsize,

59
libc/fmt/conv.h
View file

@ -1,16 +1,5 @@
#ifndef COSMOPOLITAN_LIBC_FMT_CONV_H_
#define COSMOPOLITAN_LIBC_FMT_CONV_H_
#include "libc/calls/struct/timespec.h"
#include "libc/calls/struct/timeval.h"
#include "libc/nt/struct/filetime.h"
/*───────────────────────────────────────────────────────────────────────────│─╗
│ cosmopolitan § conversion ─╬─│┼
╚────────────────────────────────────────────────────────────────────────────│*/
#define MODERNITYSECONDS 11644473600ull
#define HECTONANOSECONDS 10000000ull
#if !(__ASSEMBLER__ + __LINKER__ + 0)
COSMOPOLITAN_C_START_
@ -48,52 +37,10 @@ float wcstof(const wchar_t *, wchar_t **);
double wcstod(const wchar_t *, wchar_t **);
long double wcstold(const wchar_t *, wchar_t **);
/*───────────────────────────────────────────────────────────────────────────│─╗
│ cosmopolitan § conversion » time ─╬─│┼
╚────────────────────────────────────────────────────────────────────────────│*/
int64_t DosDateTimeToUnix(unsigned, unsigned) libcesque nosideeffect;
struct timeval WindowsTimeToTimeVal(int64_t)
libcesque nosideeffect;
struct timespec WindowsTimeToTimeSpec(int64_t)
libcesque nosideeffect;
int64_t TimeSpecToWindowsTime(struct timespec) libcesque nosideeffect;
int64_t TimeValToWindowsTime(struct timeval) libcesque nosideeffect;
struct timeval WindowsDurationToTimeVal(int64_t)
libcesque nosideeffect;
struct timespec WindowsDurationToTimeSpec(int64_t)
libcesque nosideeffect;
#define MakeFileTime(x) \
({ \
int64_t __x = x; \
(struct NtFileTime){(uint32_t)__x, (uint32_t)(__x >> 32)}; \
})
#define ReadFileTime(t) \
({ \
struct NtFileTime __t = t; \
uint64_t x = __t.dwHighDateTime; \
(int64_t)(x << 32 | __t.dwLowDateTime); \
})
#define FileTimeToTimeSpec(x) WindowsTimeToTimeSpec(ReadFileTime(x))
#define FileTimeToTimeVal(x) WindowsTimeToTimeVal(ReadFileTime(x))
#define TimeSpecToFileTime(x) MakeFileTime(TimeSpecToWindowsTime(x))
#define TimeValToFileTime(x) MakeFileTime(TimeValToWindowsTime(x))
/*───────────────────────────────────────────────────────────────────────────│─╗
│ cosmopolitan § conversion » manipulation ─╬─│┼
╚────────────────────────────────────────────────────────────────────────────│*/
#ifdef _COSMO_SOURCE
char *stripext(char *);
char *stripexts(char *);
#endif
/*───────────────────────────────────────────────────────────────────────────│─╗
│ cosmopolitan § conversion » computation ─╬─│┼
╚────────────────────────────────────────────────────────────────────────────│*/
#endif /* _COSMO_SOURCE */
typedef struct {
int quot;
@ -120,10 +67,6 @@ ldiv_t ldiv(long, long) pureconst;
lldiv_t lldiv(long long, long long) pureconst;
imaxdiv_t imaxdiv(intmax_t, intmax_t) pureconst;
/*───────────────────────────────────────────────────────────────────────────│─╗
│ cosmopolitan § conversion » optimizations ─╬─│┼
╚────────────────────────────────────────────────────────────────────────────│*/
#if __STDC_VERSION__ + 0 >= 199901L
#define div(num, den) ((div_t){(num) / (den), (num) % (den)})
#define ldiv(num, den) ((ldiv_t){(num) / (den), (num) % (den)})

41
libc/fmt/wintime.internal.h Normal file
View file

@ -0,0 +1,41 @@
#ifndef COSMOPOLITAN_LIBC_FMT_WINTIME_H_
#define COSMOPOLITAN_LIBC_FMT_WINTIME_H_
#include "libc/calls/struct/timespec.h"
#include "libc/calls/struct/timeval.h"
#include "libc/nt/struct/filetime.h"
#define MODERNITYSECONDS 11644473600ull
#define HECTONANOSECONDS 10000000ull
#if !(__ASSEMBLER__ + __LINKER__ + 0)
COSMOPOLITAN_C_START_
int64_t DosDateTimeToUnix(uint32_t, uint32_t) pureconst;
int64_t TimeSpecToWindowsTime(struct timespec) pureconst;
int64_t TimeValToWindowsTime(struct timeval) pureconst;
struct timespec WindowsDurationToTimeSpec(int64_t) pureconst;
struct timespec WindowsTimeToTimeSpec(int64_t) pureconst;
struct timeval WindowsDurationToTimeVal(int64_t) pureconst;
struct timeval WindowsTimeToTimeVal(int64_t) pureconst;
#define MakeFileTime(x) \
({ \
int64_t __x = x; \
(struct NtFileTime){(uint32_t)__x, (uint32_t)(__x >> 32)}; \
})
#define ReadFileTime(t) \
({ \
struct NtFileTime __t = t; \
uint64_t x = __t.dwHighDateTime; \
(int64_t)(x << 32 | __t.dwLowDateTime); \
})
#define FileTimeToTimeSpec(x) WindowsTimeToTimeSpec(ReadFileTime(x))
#define FileTimeToTimeVal(x) WindowsTimeToTimeVal(ReadFileTime(x))
#define TimeSpecToFileTime(x) MakeFileTime(TimeSpecToWindowsTime(x))
#define TimeValToFileTime(x) MakeFileTime(TimeValToWindowsTime(x))
COSMOPOLITAN_C_END_
#endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */
#endif /* COSMOPOLITAN_LIBC_FMT_WINTIME_H_ */

68
libc/intrin/bt.c
View file

@ -1,68 +0,0 @@
/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :vi│
╞══════════════════════════════════════════════════════════════════════════════╡
│ Copyright 2022 Justine Alexandra Roberts Tunney │
│ │
│ Permission to use, copy, modify, and/or distribute this software for │
│ any purpose with or without fee is hereby granted, provided that the │
│ above copyright notice and this permission notice appear in all copies. │
│ │
│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL │
│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED │
│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE │
│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL │
│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR │
│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER │
│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR │
│ PERFORMANCE OF THIS SOFTWARE. │
╚─────────────────────────────────────────────────────────────────────────────*/
#include "libc/errno.h"
#include "libc/intrin/kprintf.h"
#include "libc/intrin/weaken.h"
#include "libc/log/backtrace.internal.h"
#include "libc/runtime/symbols.internal.h"
static _Thread_local bool noreentry;
/**
* Shows backtrace if crash reporting facilities are linked.
*/
void _bt(const char *fmt, ...) {
int e;
va_list va;
if (!noreentry) {
noreentry = true;
} else {
return;
}
if (fmt) {
va_start(va, fmt);
kvprintf(fmt, va);
va_end(va);
}
if (_weaken(ShowBacktrace) && _weaken(GetSymbolTable)) {
e = errno;
_weaken(ShowBacktrace)(2, __builtin_frame_address(0));
errno = e;
} else {
kprintf("_bt() can't show backtrace because you need:\n"
"\t__static_yoink(\"ShowBacktrace\");\n"
"to be linked.\n");
if (_weaken(PrintBacktraceUsingSymbols) && _weaken(GetSymbolTable)) {
e = errno;
_weaken(PrintBacktraceUsingSymbols)(2, __builtin_frame_address(0),
_weaken(GetSymbolTable)());
errno = e;
} else {
kprintf("_bt() can't show backtrace because you need:\n"
"\t__static_yoink(\"PrintBacktraceUsingSymbols\");\n"
"\t__static_yoink(\"GetSymbolTable\");\n"
"to be linked.\n");
}
}
noreentry = false;
}

37
libc/intrin/closehandle.c
View file

@ -1,37 +0,0 @@
/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :vi│
╞══════════════════════════════════════════════════════════════════════════════╡
│ Copyright 2022 Justine Alexandra Roberts Tunney │
│ │
│ Permission to use, copy, modify, and/or distribute this software for │
│ any purpose with or without fee is hereby granted, provided that the │
│ above copyright notice and this permission notice appear in all copies. │
│ │
│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL │
│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED │
│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE │
│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL │
│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR │
│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER │
│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR │
│ PERFORMANCE OF THIS SOFTWARE. │
╚─────────────────────────────────────────────────────────────────────────────*/
#include "libc/calls/syscall_support-nt.internal.h"
#include "libc/intrin/strace.internal.h"
#include "libc/log/log.h"
#include "libc/nt/runtime.h"
#include "libc/nt/thunk/msabi.h"
__msabi extern typeof(CloseHandle) *const __imp_CloseHandle;
/**
* Closes an open object handle.
* @note this wrapper takes care of ABI, STRACE(), and __winerr()
*/
textwindows bool32 CloseHandle(int64_t hObject) {
bool32 ok;
ok = __imp_CloseHandle(hObject);
if (!ok) __winerr();
NTTRACE("CloseHandle(%ld) → %hhhd% m", hObject, ok);
return ok;
}

4
libc/intrin/cp.c
View file

@ -51,9 +51,7 @@ void end_cancellation_point(int state) {
}
void report_cancellation_point(void) {
BLOCK_CANCELLATIONS;
_bt("error: need BEGIN/END_CANCELLATION_POINT\n");
ALLOW_CANCELLATIONS;
__builtin_trap();
}
#endif /* MODE_DBG */

1
libc/intrin/directmap.c
View file

@ -33,7 +33,6 @@
* for passing the magic memory handle on Windows NT to CloseHandle().
*
* @asyncsignalsafe
* @threadsafe
*/
struct DirectMap sys_mmap(void *addr, size_t size, int prot, int flags, int fd,
int64_t off) {

1
libc/intrin/exit.c
View file

@ -40,7 +40,6 @@
* by hosing the interrupt descriptors and triple faulting the system.
*
* @asyncsignalsafe
* @threadsafe
* @vforksafe
* @noreturn
*/

1
libc/intrin/exit1.greg.c
View file

@ -40,7 +40,6 @@ __msabi extern typeof(ExitThread) *const __imp_ExitThread;
*
* @param rc only works on Linux and Windows
* @see cthread_exit()
* @threadsafe
* @noreturn
*/
privileged wontreturn void _Exit1(int rc) {

7
libc/intrin/getmainstack.c
View file

@ -28,6 +28,8 @@
#include "libc/sysv/consts/rlim.h"
#include "libc/sysv/consts/rlimit.h"
// Hack for guessing boundaries of _start()'s stack
//
// Every UNIX system in our support vector creates arg blocks like:
//
// <HIGHEST-STACK-ADDRESS>
@ -53,6 +55,11 @@
// up to the microprocessor page size (this computes the top addr)
// and the bottom is computed by subtracting RLIMIT_STACK rlim_cur
// It's simple but gets tricky if we consider environ can be empty
//
// This code always guesses correctly on Windows because WinMain()
// is written to allocate a stack ourself. Local testing on Linux,
// XNU, FreeBSD, OpenBSD, and NetBSD says that accuracy is ±1 page
// and that error rate applies to both beginning and end addresses
static char *__get_last(char **list) {
char *res = 0;

1
libc/intrin/getpid.c
View file

@ -38,7 +38,6 @@
*
* @return process id (always successful)
* @asyncsignalsafe
* @threadsafe
* @vforksafe
*/
int getpid(void) {

1
libc/intrin/gettid.c
View file

@ -34,7 +34,6 @@
*
* @return thread id greater than zero or -1 w/ errno
* @asyncsignalsafe
* @threadsafe
* @vforksafe
*/
int gettid(void) {

1
libc/intrin/rand64.c
View file

@ -43,7 +43,6 @@ static struct {
* @note this function is not intended for cryptography
* @note this function passes bigcrush and practrand
* @asyncsignalsafe
* @threadsafe
* @vforksafe
*/
uint64_t _rand64(void) {

13
libc/intrin/strace.internal.h
View file

@ -3,12 +3,13 @@
#include "libc/intrin/likely.h"
#include "libc/runtime/runtime.h"
#define _KERNTRACE 0 /* not configurable w/ flag yet */
#define _NTTRACE 1 /* not configurable w/ flag yet */
#define _POLLTRACE 0 /* not configurable w/ flag yet */
#define _DATATRACE 1 /* not configurable w/ flag yet */
#define _STDIOTRACE 0 /* not configurable w/ flag yet */
#define _LOCKTRACE 0 /* not configurable w/ flag yet */
#define _NTTRACE 0 /* not configurable w/ flag yet */
#define _STDIOTRACE 0 /* not configurable w/ flag yet */
#define _KERNTRACE 0 /* not configurable w/ flag yet */
#define _TIMETRACE 0 /* not configurable w/ flag yet */
#define STRACE_PROLOGUE "%rSYS %6P %'18T "
@ -63,6 +64,12 @@ COSMOPOLITAN_C_START_
#define LOCKTRACE(FMT, ...) (void)0
#endif
#if defined(SYSDEBUG) && _TIMETRACE
#define TIMETRACE(FMT, ...) STRACE(FMT, ##__VA_ARGS__)
#else
#define TIMETRACE(FMT, ...) (void)0
#endif
void __stracef(const char *, ...);
COSMOPOLITAN_C_END_

3
libc/intrin/strsignal.c
View file

@ -33,8 +33,9 @@ static char g_strsignal[21];
*
* @param sig is signal number which should be in range 1 through 128
* @return string which is valid code describing signal
* @see strsignal_r() for better thread safety
* @see strsignal_r()
* @see sigaction()
* @threadunsafe
*/
char *strsignal(int sig) {
return strsignal_r(sig, g_strsignal);

1
libc/intrin/strsignal_r.c
View file

@ -34,7 +34,6 @@
* @return pointer to .rodata string, or to `buf` after mutating
* @see sigaction()
* @asyncsignalsafe
* @threadsafe
*/
privileged char *strsignal_r(int sig, char buf[21]) {
const char *s;

8
libc/intrin/unsetenv.c
View file

@ -19,6 +19,7 @@
#include "libc/dce.h"
#include "libc/intrin/getenv.internal.h"
#include "libc/runtime/runtime.h"
#include "libc/str/str.h"
#include "libc/sysv/errfuns.h"
/**
@ -27,15 +28,12 @@
* @param s is non-empty environment key which can't contain `'='`
* @return 0 on success, or -1 w/ errno and environment is unchanged
* @raise EINVAL if `s` is an empty string or has a `'='` character
* @threadunsafe
*/
int unsetenv(const char *s) {
char **p;
struct Env e;
const char *t;
if (!s || !*s) return einval();
for (t = s; *t; ++t) {
if (*t == '=') return einval();
}
if (!s || !*s || strchr(s, '=')) return einval();
if ((p = environ)) {
e = __getenv(p, s);
while (p[e.i]) {

2
libc/isystem/sys/param.h
View file

@ -4,7 +4,7 @@
#include "libc/calls/calls.h"
#include "libc/calls/struct/rlimit.h"
#include "libc/calls/struct/rusage.h"
#include "libc/calls/sysparam.h"
#include "libc/stdio/sysparam.h"
#include "libc/calls/weirdtypes.h"
#include "libc/limits.h"
#include "libc/sysv/consts/endian.h"

1507
libc/isystem/windows.h
View file

File diff suppressed because it is too large Load diff

1
libc/log/die.c
View file

@ -38,7 +38,6 @@
*
* @see __minicrash() for signal handlers, e.g. handling abort()
* @asyncsignalsafe
* @threadsafe
* @vforksafe
*/
relegated wontreturn void __die(void) {

1
libc/log/minicrash.c
View file

@ -49,7 +49,6 @@
*
* @see __die() for crashing from normal code without aborting
* @asyncsignalsafe
* @threadsafe
* @vforksafe
*/
relegated dontinstrument void __minicrash(int sig, siginfo_t *si, void *arg) {

1
libc/log/vflogf.c
View file

@ -81,7 +81,6 @@ static void vflogf_onfail(FILE *f) {
* time that it took to connect. This is great in forking applications.
*
* @asyncsignalsafe
* @threadsafe
*/
void(vflogf)(unsigned level, const char *file, int line, FILE *f,
const char *fmt, va_list va) {

8
libc/macros.internal.h
View file

@ -10,6 +10,14 @@
* @fileoverview Common C preprocessor, assembler, and linker macros.
*/
#ifdef MAX
#undef MAX
#endif
#ifdef MIN
#undef MIN
#endif
#define TRUE 1
#define FALSE 0

1
libc/mem/aligned_alloc.c
View file

@ -27,7 +27,6 @@
* @return memory address, or NULL w/ errno
* @throw EINVAL if !IS2POW(a)
* @see pvalloc()
* @threadsafe
*/
void *aligned_alloc(size_t a, size_t n) {
if (IS2POW(a)) {

1
libc/mem/calloc.c
View file

@ -30,7 +30,6 @@ void *(*hook_calloc)(size_t, size_t) = dlcalloc;
* @return rax is memory address, or NULL w/ errno
* @note overreliance on memalign is a sure way to fragment space
* @see dlcalloc()
* @threadsafe
*/
void *calloc(size_t n, size_t itemsize) {
return hook_calloc(n, itemsize);

Some files were not shown because too many files have changed in this diff Show more