rubycc 1.0.0

data/include/libc/sys/inotify.h

@@ -0,0 +1,111 @@
+/* rubycc bundled <sys/inotify.h>: the Linux inotify(7) filesystem-change
+   notification interface. Provenance: clean room against the Linux kernel
+   UAPI (linux/inotify.h) and the glibc call surface, not derived from musl or
+   glibc source. The event-mask bits, the two init flags and struct
+   inotify_event's layout are that ABI reproduced as measured integer
+   constants and measured field offsets (an ABI fact, not copied text -- see
+   docs/HEADER-LICENSING.md sec. 4), the same treatment as poll.h and
+   sys/epoll.h.
+
+   Common layer, and that was measured rather than assumed. struct
+   inotify_event ends in a flexible array member, which is exactly the shape
+   where a wrong tail assumption would be invisible in a member-by-member
+   read, so its size and every offset were printed from the glibc oracle on
+   both targets and came back identical:
+
+     sizeof 16, _Alignof 4, wd @ 0, mask @ 4, cookie @ 8, len @ 12,
+     name @ 16 (the flexible member contributes nothing to sizeof, so the
+     16-byte size is the header alone -- which is what makes libev's
+     `ofs += sizeof (struct inotify_event) + ev->len` walk correct)
+
+   The member widths and signedness were measured too: wd is a signed 4-byte
+   int (it is a watch descriptor, and -1 is the error return of
+   inotify_add_watch), while mask, cookie and len are unsigned 4-byte. Since
+   nothing here differs between the targets, the header is arch neutral,
+   unlike sys/epoll.h whose struct packing does differ.
+
+   IN_CLOEXEC and IN_NONBLOCK share bits with the open(2) flags, and some O_*
+   names do differ between the targets (that is why fcntl.h is an arch-layer
+   header), so those two were measured on both as well: 0x80000 and 0x800 on
+   each.
+
+   inotify_init/inotify_init1/inotify_add_watch/inotify_rm_watch are
+   Linux/glibc declarations whose bodies resolve from the host libc at link
+   time.
+
+   Not included: the IN_ALL_EVENTS convenience mask is provided, but glibc's
+   internal aliases beyond it are not, and NAME_MAX (which callers sizing a
+   read buffer want next to this header) is left to <limits.h>, which already
+   provides it. nio4r, the gem that put this header on the list, reaches
+   inotify_init1 / inotify_add_watch / inotify_rm_watch and the mask bits
+   through libev's ev_stat backend. */
+
+#ifndef _RUBYCC_SYS_INOTIFY_H
+#define _RUBYCC_SYS_INOTIFY_H
+
+#include <stdint.h>
+
+/* Flags for inotify_init1; they share O_CLOEXEC's and O_NONBLOCK's bits
+   (measured, both arches). */
+#define IN_CLOEXEC  0x80000
+#define IN_NONBLOCK 0x800
+
+/* The events a watch can ask for (measured, both arches). */
+#define IN_ACCESS        0x00000001 /* file was read */
+#define IN_MODIFY        0x00000002 /* file was written */
+#define IN_ATTRIB        0x00000004 /* metadata changed */
+#define IN_CLOSE_WRITE   0x00000008 /* writable descriptor closed */
+#define IN_CLOSE_NOWRITE 0x00000010 /* read-only descriptor closed */
+#define IN_OPEN          0x00000020 /* file was opened */
+#define IN_MOVED_FROM    0x00000040 /* renamed out of the watched directory */
+#define IN_MOVED_TO      0x00000080 /* renamed into the watched directory */
+#define IN_CREATE        0x00000100 /* entry created in the directory */
+#define IN_DELETE        0x00000200 /* entry deleted from the directory */
+#define IN_DELETE_SELF   0x00000400 /* the watched file itself was deleted */
+#define IN_MOVE_SELF     0x00000800 /* the watched file itself was renamed */
+
+/* The two pairs above that callers usually want together. */
+#define IN_CLOSE (IN_CLOSE_WRITE | IN_CLOSE_NOWRITE)
+#define IN_MOVE  (IN_MOVED_FROM | IN_MOVED_TO)
+
+/* Everything a watch may be asked for, i.e. the twelve bits above
+   (measured: 0xfff on both arches). */
+#define IN_ALL_EVENTS 0x00000fff
+
+/* Events the kernel reports without being asked (measured, both arches). */
+#define IN_UNMOUNT     0x00002000 /* the backing filesystem was unmounted */
+#define IN_Q_OVERFLOW  0x00004000 /* the event queue overflowed */
+#define IN_IGNORED     0x00008000 /* the watch was removed */
+
+/* Bits that modify how inotify_add_watch installs the watch (measured, both
+   arches). IN_ISDIR is not one of these: it is set by the kernel on a
+   reported event whose subject is a directory. */
+#define IN_ONLYDIR     0x01000000 /* fail unless the path is a directory */
+#define IN_DONT_FOLLOW 0x02000000 /* do not dereference a symbolic link */
+#define IN_EXCL_UNLINK 0x04000000 /* stop reporting unlinked children */
+#define IN_MASK_CREATE 0x10000000 /* fail if a watch already exists */
+#define IN_MASK_ADD    0x20000000 /* add to, not replace, the existing mask */
+#define IN_ISDIR       0x40000000 /* reported: the subject is a directory */
+#define IN_ONESHOT     0x80000000 /* remove the watch after one event */
+
+/* One queued event, as read(2) hands it over. Measured: 16 bytes, 4-byte
+   aligned, with the four fixed members packed end to end and the name
+   starting immediately after them. `name` is a flexible array member: when
+   `len` is non-zero the kernel writes `len` bytes there (a NUL-terminated
+   name plus enough NUL padding to keep the next event 4-byte aligned), so
+   consecutive events in a read buffer are `sizeof(struct inotify_event) +
+   len` bytes apart. */
+struct inotify_event {
+  int      wd;     /* offset  0: the watch this event belongs to */
+  uint32_t mask;   /* offset  4: the IN_ bits that fired */
+  uint32_t cookie; /* offset  8: pairs a MOVED_FROM with its MOVED_TO */
+  uint32_t len;    /* offset 12: bytes of `name`, including padding */
+  char     name[]; /* offset 16: present only when len is non-zero */
+};
+
+int inotify_init(void);
+int inotify_init1(int __flags);
+int inotify_add_watch(int __fd, const char *__pathname, uint32_t __mask);
+int inotify_rm_watch(int __fd, int __wd);
+
+#endif /* _RUBYCC_SYS_INOTIFY_H */

data/include/libc/sys/ioctl.h

@@ -0,0 +1,36 @@
+/* rubycc bundled <sys/ioctl.h>: the ioctl(2) declaration and terminal window
+   size query (POSIX does not standardize ioctl at all; this is a Linux/glibc
+   ABI surface). Provenance: clean room against the glibc/Linux ABI (glibc's
+   bits/ioctl-types.h plus the kernel UAPI's asm-generic/ioctls.h request
+   numbers), not derived from musl. Narrowed to the surface io-console's
+   corpus sample actually reaches (Step 124, M5 H2): on the HAVE_TERMIOS_H
+   path (see termios.h's provenance note) the only ioctl requests it issues
+   are TIOCGWINSZ/TIOCSWINSZ against a `struct winsize`; the TCGETA/TCSETAF/
+   TIOCGETP/TIOCSETP requests belong to the termio.h/sgtty.h fallback paths
+   that HAVE_TERMIOS_H skips on Linux, so they are not reproduced here (the
+   same "corpus-reached surface only" scoping sched.h and poll.h used).
+   struct winsize is a struct callers read/write members of directly, so it
+   cannot be an opaque byte blob; its size (8) and every member's offset, and
+   the TIOCGWINSZ/TIOCSWINSZ request numbers, were measured against the glibc
+   oracle on both x86-64 and aarch64 (see test/test_header_abi.rb's IOCTL
+   case) and the two agreed exactly, so this header lives in the common
+   layer. */
+
+#ifndef _RUBYCC_SYS_IOCTL_H
+#define _RUBYCC_SYS_IOCTL_H
+
+/* struct winsize: 8 bytes, 2-byte aligned (measured, both arches). */
+struct winsize {
+  unsigned short ws_row;    /* offset 0: rows, in characters */
+  unsigned short ws_col;    /* offset 2: columns, in characters */
+  unsigned short ws_xpixel; /* offset 4: horizontal size, pixels */
+  unsigned short ws_ypixel; /* offset 6: vertical size, pixels */
+};
+
+/* Terminal window size ioctl requests (measured, both arches agree). */
+#define TIOCGWINSZ 0x5413
+#define TIOCSWINSZ 0x5414
+
+int ioctl(int __fd, unsigned long __request, ...);
+
+#endif /* _RUBYCC_SYS_IOCTL_H */

data/include/libc/sys/mman.h

@@ -0,0 +1,65 @@
+/* rubycc bundled <sys/mman.h>: the memory-mapping calls and the PROT_/MAP_/MS_/
+   MADV_ flag macros (POSIX plus Linux extensions). Provenance: clean room
+   against the Linux kernel UAPI (asm-generic/mman-common.h and mman.h), not
+   derived from musl. The flag values and MAP_FAILED are that ABI reproduced as
+   measured integer constants (an ABI fact, not copied text -- see
+   docs/HEADER-LICENSING.md), the same treatment as errno.h and fcntl.h. mmap,
+   munmap and kin are POSIX declarations. Common layer: every flag value is
+   identical on x86-64 and aarch64 (both use the asm-generic assignments). */
+
+#ifndef _RUBYCC_SYS_MMAN_H
+#define _RUBYCC_SYS_MMAN_H
+
+#ifndef _RUBYCC_SIZE_T
+#define _RUBYCC_SIZE_T
+typedef unsigned long size_t;
+#endif
+#ifndef _RUBYCC_OFF_T
+#define _RUBYCC_OFF_T
+typedef long off_t;
+#endif
+
+/* Memory protection bits (for mmap/mprotect). */
+#define PROT_NONE  0x0
+#define PROT_READ  0x1
+#define PROT_WRITE 0x2
+#define PROT_EXEC  0x4
+
+/* mmap flags. MAP_SHARED/MAP_PRIVATE are the required sharing mode; the rest
+   are Linux extensions. */
+#define MAP_SHARED    0x00001
+#define MAP_PRIVATE   0x00002
+#define MAP_FIXED     0x00010
+#define MAP_ANONYMOUS 0x00020
+#define MAP_ANON      MAP_ANONYMOUS
+#define MAP_GROWSDOWN 0x00100
+#define MAP_LOCKED    0x02000
+#define MAP_NORESERVE 0x04000
+#define MAP_POPULATE  0x08000
+#define MAP_STACK     0x20000
+
+/* mmap failure sentinel: the return value on error. */
+#define MAP_FAILED ((void *) -1)
+
+/* msync flags. */
+#define MS_ASYNC      0x1
+#define MS_INVALIDATE 0x2
+#define MS_SYNC       0x4
+
+/* madvise advice values. */
+#define MADV_NORMAL     0
+#define MADV_RANDOM     1
+#define MADV_SEQUENTIAL 2
+#define MADV_WILLNEED   3
+#define MADV_DONTNEED   4
+#define MADV_FREE       8
+
+void *mmap(void *__addr, size_t __len, int __prot, int __flags, int __fd, off_t __offset);
+int   munmap(void *__addr, size_t __len);
+int   mprotect(void *__addr, size_t __len, int __prot);
+int   msync(void *__addr, size_t __len, int __flags);
+int   madvise(void *__addr, size_t __len, int __advice);
+int   mlock(const void *__addr, size_t __len);
+int   munlock(const void *__addr, size_t __len);
+
+#endif /* _RUBYCC_SYS_MMAN_H */

data/include/libc/sys/param.h

@@ -0,0 +1,41 @@
+/* rubycc bundled <sys/param.h>: BSD-heritage traditional Unix parameter
+   macros. Provenance: clean room. glibc's own <sys/param.h> is itself only a
+   compatibility shim (its own comment header calls it "Compatibility header
+   for old-style Unix parameters and limits") that pulls in sys/types.h,
+   limits.h, endian.h and signal.h to synthesize BSD-named aliases
+   (MAXPATHLEN, NOFILE, ...) and a handful of bit-twiddling macros
+   (setbit/isset/howmany/roundup/MIN/MAX); it was inspected on the host
+   (x86-64 and aarch64 glibc, both agree) to confirm what it actually emits,
+   but no macro *body* is copied from it -- MIN/MAX/howmany/roundup below are
+   rubycc's own phrasing of the same well-known formulas (an ABI/behavioral
+   fact -- the value MIN(a,b)/roundup(x,y) etc. must produce -- not a
+   creative expression; see docs/HEADER-LICENSING.md Sec 4). Narrowed to the
+   surface digest's corpus sample actually reaches (Step 124, M5 H2): sha1.c's
+   `#include <sys/param.h>` is itself gated behind `defined(_KERNEL) ||
+   defined(_STANDALONE)`, neither of which a userspace Ruby extension build
+   ever defines, so the include is unreachable dead code for this gem in
+   practice -- and no digest source references MIN/MAX/howmany/roundup or any
+   other sys/param.h name either. This header ships only the traditional
+   four macros a "sys/param.h" compatibility shim is expected to carry
+   (matching the header's own docs above); the BSD name aliases (MAXPATHLEN,
+   NOFILE, ...), the setbit/isset bitmap macros and the endian.h/signal.h
+   pull-ins are not reproduced (no corpus sample needs them, and re-adding
+   them would just re-derive limits.h/endian.h under new names). */
+
+#ifndef _RUBYCC_SYS_PARAM_H
+#define _RUBYCC_SYS_PARAM_H
+
+#ifndef MIN
+#define MIN(a, b) ((a) < (b) ? (a) : (b))
+#endif
+#ifndef MAX
+#define MAX(a, b) ((a) > (b) ? (a) : (b))
+#endif
+#ifndef howmany
+#define howmany(x, y) (((x) + ((y) - 1)) / (y))
+#endif
+#ifndef roundup
+#define roundup(x, y) ((((x) + ((y) - 1)) / (y)) * (y))
+#endif
+
+#endif /* _RUBYCC_SYS_PARAM_H */

data/include/libc/sys/resource.h

@@ -0,0 +1,109 @@
+/* rubycc bundled <sys/resource.h>: resource limits and usage (POSIX.1).
+   Provenance: clean room against the POSIX public interface and the Linux
+   kernel UAPI (asm-generic/resource.h); struct rlimit's and struct rusage's
+   member names, types and order are that ABI's own public contract, not
+   glibc implementation detail. Every member is used directly by callers, so
+   neither struct can be an opaque byte blob; both structs' sizes and every
+   member's offset were measured against the glibc oracle on both x86-64 and
+   aarch64 (see test/test_header_abi.rb's RESOURCE case) and the two agreed
+   exactly (rlim_t is `unsigned long` and struct timeval's members are both
+   `long` on either LP64 target, so neither struct has an arch-dependent
+   field width), so this header lives in the common layer. The C libraries do
+   differ, though: struct rusage is larger on musl, which is carried below
+   under __RUBYCC_LIBC_MUSL__ (see the preprocessor's LIBCS). struct timeval
+   reuses the __timeval_defined guard sys/time.h also defines it under, so the
+   two headers agree rather than redefine when both are included.
+   The RLIMIT_* enumerators and RUSAGE_* constants are the standard Linux/
+   glibc values (measured, both arches agree). getrlimit/setrlimit/getrusage
+   are POSIX declarations whose bodies resolve from the host libc at link time
+   (Step 123, M5 H2). */
+
+#ifndef _RUBYCC_SYS_RESOURCE_H
+#define _RUBYCC_SYS_RESOURCE_H
+
+#ifndef _RUBYCC_TIME_T
+#define _RUBYCC_TIME_T
+typedef long time_t;
+#endif
+#ifndef _RUBYCC_SUSECONDS_T
+#define _RUBYCC_SUSECONDS_T
+typedef long suseconds_t;
+#endif
+
+#ifndef __timeval_defined
+#define __timeval_defined 1
+struct timeval {
+  time_t      tv_sec;
+  suseconds_t tv_usec;
+};
+#endif
+
+typedef unsigned long rlim_t;
+
+/* struct rlimit: 16 bytes, 8-byte aligned (measured, both arches). */
+struct rlimit {
+  rlim_t rlim_cur; /* Soft limit. offset 0 */
+  rlim_t rlim_max; /* Hard limit. offset 8 */
+};
+
+/* struct rusage: 144 bytes, 8-byte aligned on glibc and 272 bytes, 8-byte
+   aligned on musl (both sizeof/_Alignof pairs measured with the ABI harness,
+   glibc's on this host and musl's on the CI musl run, docs/STEPS.md Step 193).
+   Every member offset below was probed on both and agreed, so the two libraries
+   differ only in what follows the last member: musl reserves a further 128
+   bytes there. Those bytes are reproduced as one opaque trailing array rather
+   than as named fields, because only their extent was measured -- the same
+   treatment sys/stat.h gives struct stat's reserved slots. The
+   ru_ixrss/ru_idrss/ru_isrss/ru_nswap fields are unused by Linux but kept for
+   the standard layout. */
+struct rusage {
+  struct timeval ru_utime;    /* offset 0:   user CPU time used */
+  struct timeval ru_stime;    /* offset 16:  system CPU time used */
+  long ru_maxrss;             /* offset 32:  maximum resident set size */
+  long ru_ixrss;              /* offset 40:  integral shared memory size */
+  long ru_idrss;              /* offset 48:  integral unshared data size */
+  long ru_isrss;              /* offset 56:  integral unshared stack size */
+  long ru_minflt;             /* offset 64:  page reclaims */
+  long ru_majflt;             /* offset 72:  page faults */
+  long ru_nswap;              /* offset 80:  swaps */
+  long ru_inblock;            /* offset 88:  block input operations */
+  long ru_oublock;            /* offset 96:  block output operations */
+  long ru_msgsnd;             /* offset 104: messages sent */
+  long ru_msgrcv;             /* offset 112: messages received */
+  long ru_nsignals;           /* offset 120: signals received */
+  long ru_nvcsw;              /* offset 128: voluntary context switches */
+  long ru_nivcsw;             /* offset 136: involuntary context switches */
+#if defined(__RUBYCC_LIBC_MUSL__)
+  long __reserved[16];        /* offset 144: musl's trailing 128 bytes (measured) */
+#endif
+};
+
+#define RLIMIT_CPU        0
+#define RLIMIT_FSIZE      1
+#define RLIMIT_DATA       2
+#define RLIMIT_STACK      3
+#define RLIMIT_CORE       4
+#define RLIMIT_RSS        5
+#define RLIMIT_NPROC      6
+#define RLIMIT_NOFILE     7
+#define RLIMIT_MEMLOCK    8
+#define RLIMIT_AS         9
+#define RLIMIT_LOCKS      10
+#define RLIMIT_SIGPENDING 11
+#define RLIMIT_MSGQUEUE   12
+#define RLIMIT_NICE       13
+#define RLIMIT_RTPRIO     14
+#define RLIMIT_RTTIME     15
+#define RLIMIT_NLIMITS    16
+
+#define RLIM_INFINITY ((rlim_t)-1)
+
+#define RUSAGE_SELF     0
+#define RUSAGE_CHILDREN (-1)
+#define RUSAGE_THREAD   1
+
+int getrlimit(int __resource, struct rlimit *__rlimits);
+int setrlimit(int __resource, const struct rlimit *__rlimits);
+int getrusage(int __who, struct rusage *__usage);
+
+#endif /* _RUBYCC_SYS_RESOURCE_H */

data/include/libc/sys/socket.h

@@ -0,0 +1,167 @@
+/* rubycc bundled <sys/socket.h>: the socket address family / type / option
+   macros, the socket address structs (sockaddr, sockaddr_storage, msghdr,
+   iovec, cmsghdr, linger) and the POSIX socket calls. Provenance: clean room
+   against the Linux kernel UAPI (linux/socket.h, asm-generic/socket.h,
+   linux/uio.h) and the glibc socket ABI, not derived from musl. The AF_/PF_/
+   SOCK_/SOL_/SO_/MSG_/SHUT_ values and the struct layouts are that ABI
+   reproduced as measured integer constants and measured field offsets (an ABI
+   fact, not copied text -- see docs/HEADER-LICENSING.md), the same treatment
+   as errno.h and fcntl.h. socket, bind, connect and kin are POSIX declarations
+   whose bodies resolve from the host libc at link time. Common layer: every
+   macro value and every struct layout below (struct sockaddr, sockaddr_storage,
+   msghdr, iovec, cmsghdr and linger all included) is identical on x86-64 and
+   aarch64. */
+
+#ifndef _RUBYCC_SYS_SOCKET_H
+#define _RUBYCC_SYS_SOCKET_H
+
+#ifndef _RUBYCC_SIZE_T
+#define _RUBYCC_SIZE_T
+typedef unsigned long size_t;
+#endif
+#ifndef _RUBYCC_SSIZE_T
+#define _RUBYCC_SSIZE_T
+typedef long ssize_t;
+#endif
+#ifndef _RUBYCC_SOCKLEN_T
+#define _RUBYCC_SOCKLEN_T
+typedef unsigned int socklen_t;
+#endif
+#ifndef _RUBYCC_SA_FAMILY_T
+#define _RUBYCC_SA_FAMILY_T
+typedef unsigned short sa_family_t;
+#endif
+
+/* struct iovec: 16 bytes, 8-byte aligned (measured, both arches). */
+#ifndef _RUBYCC_STRUCT_IOVEC
+#define _RUBYCC_STRUCT_IOVEC
+struct iovec {
+  void  *iov_base; /* offset 0 */
+  size_t iov_len;  /* offset 8 */
+};
+#endif
+
+/* struct sockaddr: 16 bytes, the generic socket address (POSIX/glibc). */
+struct sockaddr {
+  sa_family_t sa_family;   /* offset 0 */
+  char        sa_data[14]; /* offset 2 */
+};
+
+/* struct sockaddr_storage: 128 bytes, 8-byte aligned (measured, both arches),
+   large and aligned enough to hold any of the protocol-specific sockaddr_*
+   structs. __ss_align forces the 8-byte alignment and pads the struct out to
+   the full 128 bytes. */
+struct sockaddr_storage {
+  sa_family_t   ss_family;       /* offset 0   */
+  char          __ss_padding[118]; /* offset 2 */
+  unsigned long __ss_align;      /* offset 120 */
+};
+
+/* struct msghdr: 56 bytes (measured, both arches), the sendmsg/recvmsg
+   scatter-gather message descriptor. */
+struct msghdr {
+  void         *msg_name;       /* offset 0  */
+  socklen_t     msg_namelen;    /* offset 8  */
+  struct iovec *msg_iov;        /* offset 16 */
+  size_t        msg_iovlen;     /* offset 24 */
+  void         *msg_control;    /* offset 32 */
+  size_t        msg_controllen; /* offset 40 */
+  int           msg_flags;      /* offset 48 */
+};
+
+/* struct cmsghdr: 16 bytes, one ancillary-data record header. */
+struct cmsghdr {
+  size_t cmsg_len;   /* offset 0  */
+  int    cmsg_level; /* offset 8  */
+  int    cmsg_type;  /* offset 12 */
+};
+
+/* struct linger: 8 bytes, the SO_LINGER option payload. */
+struct linger {
+  int l_onoff;
+  int l_linger;
+};
+
+/* Address / protocol families (Linux kernel UAPI). */
+#define AF_UNSPEC 0
+#define AF_UNIX   1
+#define AF_LOCAL  AF_UNIX
+#define AF_INET   2
+#define AF_INET6  10
+/* AF_NETLINK is the kernel-configuration socket family. It is here because a
+   corpus gem asked for it by name (raindrops' linux_inet_diag.c opens one to
+   read TCP listen queues) and for no other reason: the families are a numbered
+   space with dozens of members, and adding the ones nobody has reached for
+   would be values nobody has measured. */
+#define AF_NETLINK 16
+
+#define PF_UNSPEC AF_UNSPEC
+#define PF_UNIX   AF_UNIX
+#define PF_LOCAL  AF_UNIX
+#define PF_INET   AF_INET
+#define PF_INET6  AF_INET6
+#define PF_NETLINK AF_NETLINK
+
+/* Socket types. SOCK_CLOEXEC/SOCK_NONBLOCK are Linux extensions that may be
+   OR'd into the type argument of socket()/socketpair(). */
+#define SOCK_STREAM    1
+#define SOCK_DGRAM     2
+#define SOCK_RAW       3
+#define SOCK_SEQPACKET 5
+#define SOCK_NONBLOCK  0x800
+#define SOCK_CLOEXEC   0x80000
+
+/* getsockopt/setsockopt level and SO_* option names (asm-generic/socket.h). */
+#define SOL_SOCKET 1
+
+#define SO_REUSEADDR 2
+#define SO_TYPE      3
+#define SO_ERROR     4
+#define SO_BROADCAST 6
+#define SO_SNDBUF    7
+#define SO_RCVBUF    8
+#define SO_KEEPALIVE 9
+#define SO_LINGER    13
+#define SO_REUSEPORT 15
+
+/* send/recv message flags. */
+#define MSG_OOB      1
+#define MSG_PEEK     2
+#define MSG_TRUNC    0x20
+#define MSG_DONTWAIT 0x40
+#define MSG_WAITALL  0x100
+#define MSG_NOSIGNAL 0x4000
+
+/* shutdown() how. */
+#define SHUT_RD   0
+#define SHUT_WR   1
+#define SHUT_RDWR 2
+
+int     socket(int __domain, int __type, int __protocol);
+int     socketpair(int __domain, int __type, int __protocol, int __fds[2]);
+int     bind(int __fd, const struct sockaddr *__addr, socklen_t __len);
+int     getsockname(int __fd, struct sockaddr *__addr, socklen_t *__len);
+int     connect(int __fd, const struct sockaddr *__addr, socklen_t __len);
+int     getpeername(int __fd, struct sockaddr *__addr, socklen_t *__len);
+ssize_t send(int __fd, const void *__buf, size_t __n, int __flags);
+ssize_t recv(int __fd, void *__buf, size_t __n, int __flags);
+ssize_t sendto(int __fd, const void *__buf, size_t __n, int __flags,
+               const struct sockaddr *__addr, socklen_t __addr_len);
+ssize_t recvfrom(int __fd, void *__buf, size_t __n, int __flags,
+                  struct sockaddr *__addr, socklen_t *__addr_len);
+ssize_t sendmsg(int __fd, const struct msghdr *__message, int __flags);
+ssize_t recvmsg(int __fd, struct msghdr *__message, int __flags);
+int     getsockopt(int __fd, int __level, int __optname, void *__optval, socklen_t *__optlen);
+int     setsockopt(int __fd, int __level, int __optname, const void *__optval, socklen_t __optlen);
+int     listen(int __fd, int __n);
+int     accept(int __fd, struct sockaddr *__addr, socklen_t *__addr_len);
+/* accept4 is the Linux extension that folds SOCK_CLOEXEC / SOCK_NONBLOCK into
+   the accept itself, closing the race a separate fcntl leaves open. glibc gates
+   it behind _GNU_SOURCE; this header exposes SOCK_CLOEXEC unconditionally
+   already (see the socket types above), so the declaration follows the same
+   rule rather than growing a feature-test macro of its own. kgio's accept.c
+   calls it whenever its extconf found it. */
+int     accept4(int __fd, struct sockaddr *__addr, socklen_t *__addr_len, int __flags);
+int     shutdown(int __fd, int __how);
+
+#endif /* _RUBYCC_SYS_SOCKET_H */

data/include/libc/sys/statfs.h

@@ -0,0 +1,82 @@
+/* rubycc bundled <sys/statfs.h>: the Linux statfs(2) filesystem-statistics
+   interface. Provenance: clean room against the Linux kernel UAPI
+   (the statfs(2) argument layout) and the glibc call surface, not derived
+   from musl or glibc source. struct statfs's size, member widths, signedness
+   and offsets are that ABI reproduced from measurement (an ABI fact, not
+   copied text -- see docs/HEADER-LICENSING.md sec. 4), the same treatment as
+   sys/stat.h and dirent.h.
+
+   Common layer, and this one is worth spelling out because the naive guess
+   is the other way. The kernel has two statfs layouts -- a legacy one whose
+   counters are 32-bit and a 64-bit one -- and glibc's member types are
+   written in terms of word-sized typedefs, so it would be reasonable to
+   expect the two targets to disagree the way sys/stat.h's struct stat does.
+   Measured with the glibc oracle, they do not: both x86-64 and aarch64
+   report
+
+     sizeof 120, _Alignof 8, and every member 8 bytes wide at
+     f_type 0, f_bsize 8, f_blocks 16, f_bfree 24, f_bavail 32,
+     f_files 40, f_ffree 48, f_fsid 56, f_namelen 64, f_frsize 72,
+     f_flags 80, f_spare 88 (4 x 8 = 32 bytes, running to 120)
+
+   i.e. both LP64 targets land on the all-64-bit layout with no padding
+   anywhere, so one arch-neutral definition serves. The signedness was
+   measured member by member as well, and is not uniform: f_type, f_bsize,
+   f_namelen, f_frsize, f_flags and f_spare are signed, while the six
+   counters f_blocks / f_bfree / f_bavail / f_files / f_ffree are unsigned.
+   That asymmetry is why signedness was probed rather than assumed -- libev
+   compares f_type against magic numbers as large as 0x9123683e, which only
+   behaves as intended because the field is a signed 64-bit word rather than
+   a 32-bit one.
+
+   f_fsid's type: glibc gets __fsid_t from its bits/types.h layer and spells
+   the fsid_t alias in <sys/types.h> under __USE_MISC; measured, <sys/statfs.h>
+   alone gives only the __fsid_t spelling. rubycc has no split types layer to
+   reach for and its bundled <sys/types.h> does not carry the type, so both
+   names are defined here under one guard. The type itself measured 8 bytes
+   with 4-byte alignment -- two 4-byte ints, not one 8-byte word, which is
+   why f_fsid cannot simply be written as a long.
+
+   Not included: struct statfs64 / statfs64 / fstatfs64 (measured, statfs64
+   is byte-for-byte the same 120-byte layout on both LP64 targets, so the
+   plain names already are the 64-bit interface here), and the ST_* mount
+   flag names, which measurement confirms <sys/statfs.h> does not define at
+   all -- they belong to <sys/statvfs.h>, which rubycc does not bundle. nio4r,
+   the gem that put this header on the list, reaches statfs and f_type only,
+   from libev's ev_stat backend deciding whether a filesystem is local enough
+   for inotify to be trusted. */
+
+#ifndef _RUBYCC_SYS_STATFS_H
+#define _RUBYCC_SYS_STATFS_H
+
+/* The filesystem identifier statfs reports. Measured: 8 bytes, 4-byte
+   aligned, i.e. a pair of 4-byte ints rather than one 8-byte word. */
+#ifndef _RUBYCC_FSID_T
+#define _RUBYCC_FSID_T
+typedef struct {
+  int __val[2];
+} __fsid_t;
+typedef __fsid_t fsid_t;
+#endif
+
+/* Measured: 120 bytes, 8-byte aligned, every member one 8-byte word and no
+   padding. Signedness is per member -- see the header note. */
+struct statfs {
+  long          f_type;    /* offset  0: filesystem magic number */
+  long          f_bsize;   /* offset  8: optimal transfer block size */
+  unsigned long f_blocks;  /* offset 16: total blocks, in f_frsize units */
+  unsigned long f_bfree;   /* offset 24: free blocks */
+  unsigned long f_bavail;  /* offset 32: free blocks available to non-root */
+  unsigned long f_files;   /* offset 40: total file nodes */
+  unsigned long f_ffree;   /* offset 48: free file nodes */
+  __fsid_t      f_fsid;    /* offset 56: filesystem id */
+  long          f_namelen; /* offset 64: maximum filename length */
+  long          f_frsize;  /* offset 72: fragment size */
+  long          f_flags;   /* offset 80: mount flags */
+  long          f_spare[4];/* offset 88: reserved, runs to 120 */
+};
+
+int statfs(const char *__path, struct statfs *__buf);
+int fstatfs(int __fd, struct statfs *__buf);
+
+#endif /* _RUBYCC_SYS_STATFS_H */

data/include/libc/sys/timerfd.h

@@ -0,0 +1,55 @@
+/* rubycc bundled <sys/timerfd.h>: the Linux timerfd(2) family, which delivers
+   POSIX timer expirations as readable events on a file descriptor.
+   Provenance: clean room against the Linux kernel UAPI
+   (linux/timerfd.h) and the glibc call surface, not derived from musl or
+   glibc source. The four TFD_* values are that ABI reproduced as measured
+   integer constants (an ABI fact, not copied text -- see
+   docs/HEADER-LICENSING.md sec. 4), printed from the glibc oracle on x86-64
+   and on aarch64 (cross gcc + qemu).
+
+   Common layer. Both TFD_CLOEXEC and TFD_NONBLOCK share bits with the
+   open(2) flags, which do differ between the two targets for some O_* names
+   (that is why fcntl.h is an arch-layer header), so this was measured rather
+   than assumed. It measured identical on both:
+
+     TFD_CLOEXEC 0x80000, TFD_NONBLOCK 0x800,
+     TFD_TIMER_ABSTIME 1, TFD_TIMER_CANCEL_ON_SET 2
+
+   and so did everything the interface's types rest on -- struct itimerspec
+   is 32 bytes with it_interval at 0 and it_value at 16, struct timespec is
+   16 bytes, clockid_t is 4 -- so no arch split is needed here.
+
+   struct itimerspec is NOT duplicated below: the bundled <time.h> already
+   defines it (next to struct timespec, which it is built from), so this
+   header includes <time.h> and lets the one definition serve, the same
+   judgement <sys/wait.h> makes about siginfo_t. That include also supplies
+   the CLOCK_* ids timerfd_create's first argument takes.
+
+   Not included: timerfd_settime64/timerfd_gettime64 (the 32-bit-time_t
+   compatibility entry points; on LP64 targets glibc resolves the plain names
+   to the 64-bit implementation already). nio4r, the gem that put this header
+   on the list, reaches timerfd_create and timerfd_settime through libev's
+   periodic-timer backend. */
+
+#ifndef _RUBYCC_SYS_TIMERFD_H
+#define _RUBYCC_SYS_TIMERFD_H
+
+#include <time.h>
+
+/* timerfd_create flags (measured, both arches). */
+#define TFD_CLOEXEC  0x80000
+#define TFD_NONBLOCK 0x800
+
+/* timerfd_settime flags (measured, both arches). ABSTIME reads the value as
+   an absolute time on the chosen clock; CANCEL_ON_SET additionally makes a
+   discontinuous change of CLOCK_REALTIME cancel the timer, which is how a
+   reader learns the wall clock was stepped. */
+#define TFD_TIMER_ABSTIME       1
+#define TFD_TIMER_CANCEL_ON_SET 2
+
+int timerfd_create(int __clock_id, int __flags);
+int timerfd_settime(int __fd, int __flags, const struct itimerspec *__new_value,
+                    struct itimerspec *__old_value);
+int timerfd_gettime(int __fd, struct itimerspec *__curr_value);
+
+#endif /* _RUBYCC_SYS_TIMERFD_H */