?????????? ????????? - ??????????????? - /home/agenciai/public_html/cd38d8/bits.tar
???????
ioctl-types.ph 0000644 00000003344 15125155350 0007357 0 ustar 00 require '_h2ph_pre.ph'; no warnings qw(redefine misc); unless(defined(&_SYS_IOCTL_H)) { die("Never use <bits/ioctl-types.h> directly; include <sys/ioctl.h> instead."); } require 'asm/ioctls.ph'; eval 'sub NCC () {8;}' unless defined(&NCC); eval 'sub TIOCM_LE () {0x1;}' unless defined(&TIOCM_LE); eval 'sub TIOCM_DTR () {0x2;}' unless defined(&TIOCM_DTR); eval 'sub TIOCM_RTS () {0x4;}' unless defined(&TIOCM_RTS); eval 'sub TIOCM_ST () {0x8;}' unless defined(&TIOCM_ST); eval 'sub TIOCM_SR () {0x10;}' unless defined(&TIOCM_SR); eval 'sub TIOCM_CTS () {0x20;}' unless defined(&TIOCM_CTS); eval 'sub TIOCM_CAR () {0x40;}' unless defined(&TIOCM_CAR); eval 'sub TIOCM_RNG () {0x80;}' unless defined(&TIOCM_RNG); eval 'sub TIOCM_DSR () {0x100;}' unless defined(&TIOCM_DSR); eval 'sub TIOCM_CD () { &TIOCM_CAR;}' unless defined(&TIOCM_CD); eval 'sub TIOCM_RI () { &TIOCM_RNG;}' unless defined(&TIOCM_RI); eval 'sub N_TTY () {0;}' unless defined(&N_TTY); eval 'sub N_SLIP () {1;}' unless defined(&N_SLIP); eval 'sub N_MOUSE () {2;}' unless defined(&N_MOUSE); eval 'sub N_PPP () {3;}' unless defined(&N_PPP); eval 'sub N_STRIP () {4;}' unless defined(&N_STRIP); eval 'sub N_AX25 () {5;}' unless defined(&N_AX25); eval 'sub N_X25 () {6;}' unless defined(&N_X25); eval 'sub N_6PACK () {7;}' unless defined(&N_6PACK); eval 'sub N_MASC () {8;}' unless defined(&N_MASC); eval 'sub N_R3964 () {9;}' unless defined(&N_R3964); eval 'sub N_PROFIBUS_FDL () {10;}' unless defined(&N_PROFIBUS_FDL); eval 'sub N_IRDA () {11;}' unless defined(&N_IRDA); eval 'sub N_SMSBLOCK () {12;}' unless defined(&N_SMSBLOCK); eval 'sub N_HDLC () {13;}' unless defined(&N_HDLC); eval 'sub N_SYNC_PPP () {14;}' unless defined(&N_SYNC_PPP); eval 'sub N_HCI () {15;}' unless defined(&N_HCI); 1; ioctls.ph 0000644 00000007363 15125155350 0006405 0 ustar 00 require '_h2ph_pre.ph'; no warnings qw(redefine misc); unless(defined(&_SYS_IOCTL_H)) { die("Never use <bits/ioctls.h> directly; include <sys/ioctl.h> instead."); } require 'asm/ioctls.ph'; eval 'sub SIOCADDRT () {0x890b;}' unless defined(&SIOCADDRT); eval 'sub SIOCDELRT () {0x890c;}' unless defined(&SIOCDELRT); eval 'sub SIOCRTMSG () {0x890d;}' unless defined(&SIOCRTMSG); eval 'sub SIOCGIFNAME () {0x8910;}' unless defined(&SIOCGIFNAME); eval 'sub SIOCSIFLINK () {0x8911;}' unless defined(&SIOCSIFLINK); eval 'sub SIOCGIFCONF () {0x8912;}' unless defined(&SIOCGIFCONF); eval 'sub SIOCGIFFLAGS () {0x8913;}' unless defined(&SIOCGIFFLAGS); eval 'sub SIOCSIFFLAGS () {0x8914;}' unless defined(&SIOCSIFFLAGS); eval 'sub SIOCGIFADDR () {0x8915;}' unless defined(&SIOCGIFADDR); eval 'sub SIOCSIFADDR () {0x8916;}' unless defined(&SIOCSIFADDR); eval 'sub SIOCGIFDSTADDR () {0x8917;}' unless defined(&SIOCGIFDSTADDR); eval 'sub SIOCSIFDSTADDR () {0x8918;}' unless defined(&SIOCSIFDSTADDR); eval 'sub SIOCGIFBRDADDR () {0x8919;}' unless defined(&SIOCGIFBRDADDR); eval 'sub SIOCSIFBRDADDR () {0x891a;}' unless defined(&SIOCSIFBRDADDR); eval 'sub SIOCGIFNETMASK () {0x891b;}' unless defined(&SIOCGIFNETMASK); eval 'sub SIOCSIFNETMASK () {0x891c;}' unless defined(&SIOCSIFNETMASK); eval 'sub SIOCGIFMETRIC () {0x891d;}' unless defined(&SIOCGIFMETRIC); eval 'sub SIOCSIFMETRIC () {0x891e;}' unless defined(&SIOCSIFMETRIC); eval 'sub SIOCGIFMEM () {0x891f;}' unless defined(&SIOCGIFMEM); eval 'sub SIOCSIFMEM () {0x8920;}' unless defined(&SIOCSIFMEM); eval 'sub SIOCGIFMTU () {0x8921;}' unless defined(&SIOCGIFMTU); eval 'sub SIOCSIFMTU () {0x8922;}' unless defined(&SIOCSIFMTU); eval 'sub SIOCSIFNAME () {0x8923;}' unless defined(&SIOCSIFNAME); eval 'sub SIOCSIFHWADDR () {0x8924;}' unless defined(&SIOCSIFHWADDR); eval 'sub SIOCGIFENCAP () {0x8925;}' unless defined(&SIOCGIFENCAP); eval 'sub SIOCSIFENCAP () {0x8926;}' unless defined(&SIOCSIFENCAP); eval 'sub SIOCGIFHWADDR () {0x8927;}' unless defined(&SIOCGIFHWADDR); eval 'sub SIOCGIFSLAVE () {0x8929;}' unless defined(&SIOCGIFSLAVE); eval 'sub SIOCSIFSLAVE () {0x8930;}' unless defined(&SIOCSIFSLAVE); eval 'sub SIOCADDMULTI () {0x8931;}' unless defined(&SIOCADDMULTI); eval 'sub SIOCDELMULTI () {0x8932;}' unless defined(&SIOCDELMULTI); eval 'sub SIOCGIFINDEX () {0x8933;}' unless defined(&SIOCGIFINDEX); eval 'sub SIOGIFINDEX () { &SIOCGIFINDEX;}' unless defined(&SIOGIFINDEX); eval 'sub SIOCSIFPFLAGS () {0x8934;}' unless defined(&SIOCSIFPFLAGS); eval 'sub SIOCGIFPFLAGS () {0x8935;}' unless defined(&SIOCGIFPFLAGS); eval 'sub SIOCDIFADDR () {0x8936;}' unless defined(&SIOCDIFADDR); eval 'sub SIOCSIFHWBROADCAST () {0x8937;}' unless defined(&SIOCSIFHWBROADCAST); eval 'sub SIOCGIFCOUNT () {0x8938;}' unless defined(&SIOCGIFCOUNT); eval 'sub SIOCGIFBR () {0x8940;}' unless defined(&SIOCGIFBR); eval 'sub SIOCSIFBR () {0x8941;}' unless defined(&SIOCSIFBR); eval 'sub SIOCGIFTXQLEN () {0x8942;}' unless defined(&SIOCGIFTXQLEN); eval 'sub SIOCSIFTXQLEN () {0x8943;}' unless defined(&SIOCSIFTXQLEN); eval 'sub SIOCDARP () {0x8953;}' unless defined(&SIOCDARP); eval 'sub SIOCGARP () {0x8954;}' unless defined(&SIOCGARP); eval 'sub SIOCSARP () {0x8955;}' unless defined(&SIOCSARP); eval 'sub SIOCDRARP () {0x8960;}' unless defined(&SIOCDRARP); eval 'sub SIOCGRARP () {0x8961;}' unless defined(&SIOCGRARP); eval 'sub SIOCSRARP () {0x8962;}' unless defined(&SIOCSRARP); eval 'sub SIOCGIFMAP () {0x8970;}' unless defined(&SIOCGIFMAP); eval 'sub SIOCSIFMAP () {0x8971;}' unless defined(&SIOCSIFMAP); eval 'sub SIOCADDDLCI () {0x8980;}' unless defined(&SIOCADDDLCI); eval 'sub SIOCDELDLCI () {0x8981;}' unless defined(&SIOCDELDLCI); eval 'sub SIOCDEVPRIVATE () {0x89f0;}' unless defined(&SIOCDEVPRIVATE); eval 'sub SIOCPROTOPRIVATE () {0x89e0;}' unless defined(&SIOCPROTOPRIVATE); 1; timesize.ph 0000644 00000000406 15125155350 0006730 0 ustar 00 require '_h2ph_pre.ph'; no warnings qw(redefine misc); if(defined (&__x86_64__) && defined (&__ILP32__)) { eval 'sub __TIMESIZE () {64;}' unless defined(&__TIMESIZE); } else { eval 'sub __TIMESIZE () { &__WORDSIZE;}' unless defined(&__TIMESIZE); } 1; syscall.ph 0000644 00000232253 15125155350 0006560 0 ustar 00 require '_h2ph_pre.ph'; no warnings qw(redefine misc); unless(defined(&_SYSCALL_H)) { die("Never use <bits/syscall.h> directly; include <sys/syscall.h> instead."); } eval 'sub __GLIBC_LINUX_VERSION_CODE () {395520;}' unless defined(&__GLIBC_LINUX_VERSION_CODE); if(defined(&__NR_FAST_atomic_update)) { eval 'sub SYS_FAST_atomic_update () { &__NR_FAST_atomic_update;}' unless defined(&SYS_FAST_atomic_update); } if(defined(&__NR_FAST_cmpxchg)) { eval 'sub SYS_FAST_cmpxchg () { &__NR_FAST_cmpxchg;}' unless defined(&SYS_FAST_cmpxchg); } if(defined(&__NR_FAST_cmpxchg64)) { eval 'sub SYS_FAST_cmpxchg64 () { &__NR_FAST_cmpxchg64;}' unless defined(&SYS_FAST_cmpxchg64); } if(defined(&__NR__llseek)) { eval 'sub SYS__llseek () { &__NR__llseek;}' unless defined(&SYS__llseek); } if(defined(&__NR__newselect)) { eval 'sub SYS__newselect () { &__NR__newselect;}' unless defined(&SYS__newselect); } if(defined(&__NR__sysctl)) { eval 'sub SYS__sysctl () { &__NR__sysctl;}' unless defined(&SYS__sysctl); } if(defined(&__NR_accept)) { eval 'sub SYS_accept () { &__NR_accept;}' unless defined(&SYS_accept); } if(defined(&__NR_accept4)) { eval 'sub SYS_accept4 () { &__NR_accept4;}' unless defined(&SYS_accept4); } if(defined(&__NR_access)) { eval 'sub SYS_access () { &__NR_access;}' unless defined(&SYS_access); } if(defined(&__NR_acct)) { eval 'sub SYS_acct () { &__NR_acct;}' unless defined(&SYS_acct); } if(defined(&__NR_acl_get)) { eval 'sub SYS_acl_get () { &__NR_acl_get;}' unless defined(&SYS_acl_get); } if(defined(&__NR_acl_set)) { eval 'sub SYS_acl_set () { &__NR_acl_set;}' unless defined(&SYS_acl_set); } if(defined(&__NR_add_key)) { eval 'sub SYS_add_key () { &__NR_add_key;}' unless defined(&SYS_add_key); } if(defined(&__NR_adjtimex)) { eval 'sub SYS_adjtimex () { &__NR_adjtimex;}' unless defined(&SYS_adjtimex); } if(defined(&__NR_afs_syscall)) { eval 'sub SYS_afs_syscall () { &__NR_afs_syscall;}' unless defined(&SYS_afs_syscall); } if(defined(&__NR_alarm)) { eval 'sub SYS_alarm () { &__NR_alarm;}' unless defined(&SYS_alarm); } if(defined(&__NR_alloc_hugepages)) { eval 'sub SYS_alloc_hugepages () { &__NR_alloc_hugepages;}' unless defined(&SYS_alloc_hugepages); } if(defined(&__NR_arc_gettls)) { eval 'sub SYS_arc_gettls () { &__NR_arc_gettls;}' unless defined(&SYS_arc_gettls); } if(defined(&__NR_arc_settls)) { eval 'sub SYS_arc_settls () { &__NR_arc_settls;}' unless defined(&SYS_arc_settls); } if(defined(&__NR_arc_usr_cmpxchg)) { eval 'sub SYS_arc_usr_cmpxchg () { &__NR_arc_usr_cmpxchg;}' unless defined(&SYS_arc_usr_cmpxchg); } if(defined(&__NR_arch_prctl)) { eval 'sub SYS_arch_prctl () { &__NR_arch_prctl;}' unless defined(&SYS_arch_prctl); } if(defined(&__NR_arm_fadvise64_64)) { eval 'sub SYS_arm_fadvise64_64 () { &__NR_arm_fadvise64_64;}' unless defined(&SYS_arm_fadvise64_64); } if(defined(&__NR_arm_sync_file_range)) { eval 'sub SYS_arm_sync_file_range () { &__NR_arm_sync_file_range;}' unless defined(&SYS_arm_sync_file_range); } if(defined(&__NR_atomic_barrier)) { eval 'sub SYS_atomic_barrier () { &__NR_atomic_barrier;}' unless defined(&SYS_atomic_barrier); } if(defined(&__NR_atomic_cmpxchg_32)) { eval 'sub SYS_atomic_cmpxchg_32 () { &__NR_atomic_cmpxchg_32;}' unless defined(&SYS_atomic_cmpxchg_32); } if(defined(&__NR_attrctl)) { eval 'sub SYS_attrctl () { &__NR_attrctl;}' unless defined(&SYS_attrctl); } if(defined(&__NR_bdflush)) { eval 'sub SYS_bdflush () { &__NR_bdflush;}' unless defined(&SYS_bdflush); } if(defined(&__NR_bind)) { eval 'sub SYS_bind () { &__NR_bind;}' unless defined(&SYS_bind); } if(defined(&__NR_bpf)) { eval 'sub SYS_bpf () { &__NR_bpf;}' unless defined(&SYS_bpf); } if(defined(&__NR_break)) { eval 'sub SYS_break () { &__NR_break;}' unless defined(&SYS_break); } if(defined(&__NR_breakpoint)) { eval 'sub SYS_breakpoint () { &__NR_breakpoint;}' unless defined(&SYS_breakpoint); } if(defined(&__NR_brk)) { eval 'sub SYS_brk () { &__NR_brk;}' unless defined(&SYS_brk); } if(defined(&__NR_cachectl)) { eval 'sub SYS_cachectl () { &__NR_cachectl;}' unless defined(&SYS_cachectl); } if(defined(&__NR_cacheflush)) { eval 'sub SYS_cacheflush () { &__NR_cacheflush;}' unless defined(&SYS_cacheflush); } if(defined(&__NR_cachestat)) { eval 'sub SYS_cachestat () { &__NR_cachestat;}' unless defined(&SYS_cachestat); } if(defined(&__NR_capget)) { eval 'sub SYS_capget () { &__NR_capget;}' unless defined(&SYS_capget); } if(defined(&__NR_capset)) { eval 'sub SYS_capset () { &__NR_capset;}' unless defined(&SYS_capset); } if(defined(&__NR_chdir)) { eval 'sub SYS_chdir () { &__NR_chdir;}' unless defined(&SYS_chdir); } if(defined(&__NR_chmod)) { eval 'sub SYS_chmod () { &__NR_chmod;}' unless defined(&SYS_chmod); } if(defined(&__NR_chown)) { eval 'sub SYS_chown () { &__NR_chown;}' unless defined(&SYS_chown); } if(defined(&__NR_chown32)) { eval 'sub SYS_chown32 () { &__NR_chown32;}' unless defined(&SYS_chown32); } if(defined(&__NR_chroot)) { eval 'sub SYS_chroot () { &__NR_chroot;}' unless defined(&SYS_chroot); } if(defined(&__NR_clock_adjtime)) { eval 'sub SYS_clock_adjtime () { &__NR_clock_adjtime;}' unless defined(&SYS_clock_adjtime); } if(defined(&__NR_clock_adjtime64)) { eval 'sub SYS_clock_adjtime64 () { &__NR_clock_adjtime64;}' unless defined(&SYS_clock_adjtime64); } if(defined(&__NR_clock_getres)) { eval 'sub SYS_clock_getres () { &__NR_clock_getres;}' unless defined(&SYS_clock_getres); } if(defined(&__NR_clock_getres_time64)) { eval 'sub SYS_clock_getres_time64 () { &__NR_clock_getres_time64;}' unless defined(&SYS_clock_getres_time64); } if(defined(&__NR_clock_gettime)) { eval 'sub SYS_clock_gettime () { &__NR_clock_gettime;}' unless defined(&SYS_clock_gettime); } if(defined(&__NR_clock_gettime64)) { eval 'sub SYS_clock_gettime64 () { &__NR_clock_gettime64;}' unless defined(&SYS_clock_gettime64); } if(defined(&__NR_clock_nanosleep)) { eval 'sub SYS_clock_nanosleep () { &__NR_clock_nanosleep;}' unless defined(&SYS_clock_nanosleep); } if(defined(&__NR_clock_nanosleep_time64)) { eval 'sub SYS_clock_nanosleep_time64 () { &__NR_clock_nanosleep_time64;}' unless defined(&SYS_clock_nanosleep_time64); } if(defined(&__NR_clock_settime)) { eval 'sub SYS_clock_settime () { &__NR_clock_settime;}' unless defined(&SYS_clock_settime); } if(defined(&__NR_clock_settime64)) { eval 'sub SYS_clock_settime64 () { &__NR_clock_settime64;}' unless defined(&SYS_clock_settime64); } if(defined(&__NR_clone)) { eval 'sub SYS_clone () { &__NR_clone;}' unless defined(&SYS_clone); } if(defined(&__NR_clone2)) { eval 'sub SYS_clone2 () { &__NR_clone2;}' unless defined(&SYS_clone2); } if(defined(&__NR_clone3)) { eval 'sub SYS_clone3 () { &__NR_clone3;}' unless defined(&SYS_clone3); } if(defined(&__NR_close)) { eval 'sub SYS_close () { &__NR_close;}' unless defined(&SYS_close); } if(defined(&__NR_close_range)) { eval 'sub SYS_close_range () { &__NR_close_range;}' unless defined(&SYS_close_range); } if(defined(&__NR_cmpxchg_badaddr)) { eval 'sub SYS_cmpxchg_badaddr () { &__NR_cmpxchg_badaddr;}' unless defined(&SYS_cmpxchg_badaddr); } if(defined(&__NR_connect)) { eval 'sub SYS_connect () { &__NR_connect;}' unless defined(&SYS_connect); } if(defined(&__NR_copy_file_range)) { eval 'sub SYS_copy_file_range () { &__NR_copy_file_range;}' unless defined(&SYS_copy_file_range); } if(defined(&__NR_creat)) { eval 'sub SYS_creat () { &__NR_creat;}' unless defined(&SYS_creat); } if(defined(&__NR_create_module)) { eval 'sub SYS_create_module () { &__NR_create_module;}' unless defined(&SYS_create_module); } if(defined(&__NR_delete_module)) { eval 'sub SYS_delete_module () { &__NR_delete_module;}' unless defined(&SYS_delete_module); } if(defined(&__NR_dipc)) { eval 'sub SYS_dipc () { &__NR_dipc;}' unless defined(&SYS_dipc); } if(defined(&__NR_dup)) { eval 'sub SYS_dup () { &__NR_dup;}' unless defined(&SYS_dup); } if(defined(&__NR_dup2)) { eval 'sub SYS_dup2 () { &__NR_dup2;}' unless defined(&SYS_dup2); } if(defined(&__NR_dup3)) { eval 'sub SYS_dup3 () { &__NR_dup3;}' unless defined(&SYS_dup3); } if(defined(&__NR_epoll_create)) { eval 'sub SYS_epoll_create () { &__NR_epoll_create;}' unless defined(&SYS_epoll_create); } if(defined(&__NR_epoll_create1)) { eval 'sub SYS_epoll_create1 () { &__NR_epoll_create1;}' unless defined(&SYS_epoll_create1); } if(defined(&__NR_epoll_ctl)) { eval 'sub SYS_epoll_ctl () { &__NR_epoll_ctl;}' unless defined(&SYS_epoll_ctl); } if(defined(&__NR_epoll_ctl_old)) { eval 'sub SYS_epoll_ctl_old () { &__NR_epoll_ctl_old;}' unless defined(&SYS_epoll_ctl_old); } if(defined(&__NR_epoll_pwait)) { eval 'sub SYS_epoll_pwait () { &__NR_epoll_pwait;}' unless defined(&SYS_epoll_pwait); } if(defined(&__NR_epoll_pwait2)) { eval 'sub SYS_epoll_pwait2 () { &__NR_epoll_pwait2;}' unless defined(&SYS_epoll_pwait2); } if(defined(&__NR_epoll_wait)) { eval 'sub SYS_epoll_wait () { &__NR_epoll_wait;}' unless defined(&SYS_epoll_wait); } if(defined(&__NR_epoll_wait_old)) { eval 'sub SYS_epoll_wait_old () { &__NR_epoll_wait_old;}' unless defined(&SYS_epoll_wait_old); } if(defined(&__NR_eventfd)) { eval 'sub SYS_eventfd () { &__NR_eventfd;}' unless defined(&SYS_eventfd); } if(defined(&__NR_eventfd2)) { eval 'sub SYS_eventfd2 () { &__NR_eventfd2;}' unless defined(&SYS_eventfd2); } if(defined(&__NR_exec_with_loader)) { eval 'sub SYS_exec_with_loader () { &__NR_exec_with_loader;}' unless defined(&SYS_exec_with_loader); } if(defined(&__NR_execv)) { eval 'sub SYS_execv () { &__NR_execv;}' unless defined(&SYS_execv); } if(defined(&__NR_execve)) { eval 'sub SYS_execve () { &__NR_execve;}' unless defined(&SYS_execve); } if(defined(&__NR_execveat)) { eval 'sub SYS_execveat () { &__NR_execveat;}' unless defined(&SYS_execveat); } if(defined(&__NR_exit)) { eval 'sub SYS_exit () { &__NR_exit;}' unless defined(&SYS_exit); } if(defined(&__NR_exit_group)) { eval 'sub SYS_exit_group () { &__NR_exit_group;}' unless defined(&SYS_exit_group); } if(defined(&__NR_faccessat)) { eval 'sub SYS_faccessat () { &__NR_faccessat;}' unless defined(&SYS_faccessat); } if(defined(&__NR_faccessat2)) { eval 'sub SYS_faccessat2 () { &__NR_faccessat2;}' unless defined(&SYS_faccessat2); } if(defined(&__NR_fadvise64)) { eval 'sub SYS_fadvise64 () { &__NR_fadvise64;}' unless defined(&SYS_fadvise64); } if(defined(&__NR_fadvise64_64)) { eval 'sub SYS_fadvise64_64 () { &__NR_fadvise64_64;}' unless defined(&SYS_fadvise64_64); } if(defined(&__NR_fallocate)) { eval 'sub SYS_fallocate () { &__NR_fallocate;}' unless defined(&SYS_fallocate); } if(defined(&__NR_fanotify_init)) { eval 'sub SYS_fanotify_init () { &__NR_fanotify_init;}' unless defined(&SYS_fanotify_init); } if(defined(&__NR_fanotify_mark)) { eval 'sub SYS_fanotify_mark () { &__NR_fanotify_mark;}' unless defined(&SYS_fanotify_mark); } if(defined(&__NR_fchdir)) { eval 'sub SYS_fchdir () { &__NR_fchdir;}' unless defined(&SYS_fchdir); } if(defined(&__NR_fchmod)) { eval 'sub SYS_fchmod () { &__NR_fchmod;}' unless defined(&SYS_fchmod); } if(defined(&__NR_fchmodat)) { eval 'sub SYS_fchmodat () { &__NR_fchmodat;}' unless defined(&SYS_fchmodat); } if(defined(&__NR_fchmodat2)) { eval 'sub SYS_fchmodat2 () { &__NR_fchmodat2;}' unless defined(&SYS_fchmodat2); } if(defined(&__NR_fchown)) { eval 'sub SYS_fchown () { &__NR_fchown;}' unless defined(&SYS_fchown); } if(defined(&__NR_fchown32)) { eval 'sub SYS_fchown32 () { &__NR_fchown32;}' unless defined(&SYS_fchown32); } if(defined(&__NR_fchownat)) { eval 'sub SYS_fchownat () { &__NR_fchownat;}' unless defined(&SYS_fchownat); } if(defined(&__NR_fcntl)) { eval 'sub SYS_fcntl () { &__NR_fcntl;}' unless defined(&SYS_fcntl); } if(defined(&__NR_fcntl64)) { eval 'sub SYS_fcntl64 () { &__NR_fcntl64;}' unless defined(&SYS_fcntl64); } if(defined(&__NR_fdatasync)) { eval 'sub SYS_fdatasync () { &__NR_fdatasync;}' unless defined(&SYS_fdatasync); } if(defined(&__NR_fgetxattr)) { eval 'sub SYS_fgetxattr () { &__NR_fgetxattr;}' unless defined(&SYS_fgetxattr); } if(defined(&__NR_finit_module)) { eval 'sub SYS_finit_module () { &__NR_finit_module;}' unless defined(&SYS_finit_module); } if(defined(&__NR_flistxattr)) { eval 'sub SYS_flistxattr () { &__NR_flistxattr;}' unless defined(&SYS_flistxattr); } if(defined(&__NR_flock)) { eval 'sub SYS_flock () { &__NR_flock;}' unless defined(&SYS_flock); } if(defined(&__NR_fork)) { eval 'sub SYS_fork () { &__NR_fork;}' unless defined(&SYS_fork); } if(defined(&__NR_fp_udfiex_crtl)) { eval 'sub SYS_fp_udfiex_crtl () { &__NR_fp_udfiex_crtl;}' unless defined(&SYS_fp_udfiex_crtl); } if(defined(&__NR_free_hugepages)) { eval 'sub SYS_free_hugepages () { &__NR_free_hugepages;}' unless defined(&SYS_free_hugepages); } if(defined(&__NR_fremovexattr)) { eval 'sub SYS_fremovexattr () { &__NR_fremovexattr;}' unless defined(&SYS_fremovexattr); } if(defined(&__NR_fsconfig)) { eval 'sub SYS_fsconfig () { &__NR_fsconfig;}' unless defined(&SYS_fsconfig); } if(defined(&__NR_fsetxattr)) { eval 'sub SYS_fsetxattr () { &__NR_fsetxattr;}' unless defined(&SYS_fsetxattr); } if(defined(&__NR_fsmount)) { eval 'sub SYS_fsmount () { &__NR_fsmount;}' unless defined(&SYS_fsmount); } if(defined(&__NR_fsopen)) { eval 'sub SYS_fsopen () { &__NR_fsopen;}' unless defined(&SYS_fsopen); } if(defined(&__NR_fspick)) { eval 'sub SYS_fspick () { &__NR_fspick;}' unless defined(&SYS_fspick); } if(defined(&__NR_fstat)) { eval 'sub SYS_fstat () { &__NR_fstat;}' unless defined(&SYS_fstat); } if(defined(&__NR_fstat64)) { eval 'sub SYS_fstat64 () { &__NR_fstat64;}' unless defined(&SYS_fstat64); } if(defined(&__NR_fstatat64)) { eval 'sub SYS_fstatat64 () { &__NR_fstatat64;}' unless defined(&SYS_fstatat64); } if(defined(&__NR_fstatfs)) { eval 'sub SYS_fstatfs () { &__NR_fstatfs;}' unless defined(&SYS_fstatfs); } if(defined(&__NR_fstatfs64)) { eval 'sub SYS_fstatfs64 () { &__NR_fstatfs64;}' unless defined(&SYS_fstatfs64); } if(defined(&__NR_fsync)) { eval 'sub SYS_fsync () { &__NR_fsync;}' unless defined(&SYS_fsync); } if(defined(&__NR_ftime)) { eval 'sub SYS_ftime () { &__NR_ftime;}' unless defined(&SYS_ftime); } if(defined(&__NR_ftruncate)) { eval 'sub SYS_ftruncate () { &__NR_ftruncate;}' unless defined(&SYS_ftruncate); } if(defined(&__NR_ftruncate64)) { eval 'sub SYS_ftruncate64 () { &__NR_ftruncate64;}' unless defined(&SYS_ftruncate64); } if(defined(&__NR_futex)) { eval 'sub SYS_futex () { &__NR_futex;}' unless defined(&SYS_futex); } if(defined(&__NR_futex_requeue)) { eval 'sub SYS_futex_requeue () { &__NR_futex_requeue;}' unless defined(&SYS_futex_requeue); } if(defined(&__NR_futex_time64)) { eval 'sub SYS_futex_time64 () { &__NR_futex_time64;}' unless defined(&SYS_futex_time64); } if(defined(&__NR_futex_wait)) { eval 'sub SYS_futex_wait () { &__NR_futex_wait;}' unless defined(&SYS_futex_wait); } if(defined(&__NR_futex_waitv)) { eval 'sub SYS_futex_waitv () { &__NR_futex_waitv;}' unless defined(&SYS_futex_waitv); } if(defined(&__NR_futex_wake)) { eval 'sub SYS_futex_wake () { &__NR_futex_wake;}' unless defined(&SYS_futex_wake); } if(defined(&__NR_futimesat)) { eval 'sub SYS_futimesat () { &__NR_futimesat;}' unless defined(&SYS_futimesat); } if(defined(&__NR_get_kernel_syms)) { eval 'sub SYS_get_kernel_syms () { &__NR_get_kernel_syms;}' unless defined(&SYS_get_kernel_syms); } if(defined(&__NR_get_mempolicy)) { eval 'sub SYS_get_mempolicy () { &__NR_get_mempolicy;}' unless defined(&SYS_get_mempolicy); } if(defined(&__NR_get_robust_list)) { eval 'sub SYS_get_robust_list () { &__NR_get_robust_list;}' unless defined(&SYS_get_robust_list); } if(defined(&__NR_get_thread_area)) { eval 'sub SYS_get_thread_area () { &__NR_get_thread_area;}' unless defined(&SYS_get_thread_area); } if(defined(&__NR_get_tls)) { eval 'sub SYS_get_tls () { &__NR_get_tls;}' unless defined(&SYS_get_tls); } if(defined(&__NR_getcpu)) { eval 'sub SYS_getcpu () { &__NR_getcpu;}' unless defined(&SYS_getcpu); } if(defined(&__NR_getcwd)) { eval 'sub SYS_getcwd () { &__NR_getcwd;}' unless defined(&SYS_getcwd); } if(defined(&__NR_getdents)) { eval 'sub SYS_getdents () { &__NR_getdents;}' unless defined(&SYS_getdents); } if(defined(&__NR_getdents64)) { eval 'sub SYS_getdents64 () { &__NR_getdents64;}' unless defined(&SYS_getdents64); } if(defined(&__NR_getdomainname)) { eval 'sub SYS_getdomainname () { &__NR_getdomainname;}' unless defined(&SYS_getdomainname); } if(defined(&__NR_getdtablesize)) { eval 'sub SYS_getdtablesize () { &__NR_getdtablesize;}' unless defined(&SYS_getdtablesize); } if(defined(&__NR_getegid)) { eval 'sub SYS_getegid () { &__NR_getegid;}' unless defined(&SYS_getegid); } if(defined(&__NR_getegid32)) { eval 'sub SYS_getegid32 () { &__NR_getegid32;}' unless defined(&SYS_getegid32); } if(defined(&__NR_geteuid)) { eval 'sub SYS_geteuid () { &__NR_geteuid;}' unless defined(&SYS_geteuid); } if(defined(&__NR_geteuid32)) { eval 'sub SYS_geteuid32 () { &__NR_geteuid32;}' unless defined(&SYS_geteuid32); } if(defined(&__NR_getgid)) { eval 'sub SYS_getgid () { &__NR_getgid;}' unless defined(&SYS_getgid); } if(defined(&__NR_getgid32)) { eval 'sub SYS_getgid32 () { &__NR_getgid32;}' unless defined(&SYS_getgid32); } if(defined(&__NR_getgroups)) { eval 'sub SYS_getgroups () { &__NR_getgroups;}' unless defined(&SYS_getgroups); } if(defined(&__NR_getgroups32)) { eval 'sub SYS_getgroups32 () { &__NR_getgroups32;}' unless defined(&SYS_getgroups32); } if(defined(&__NR_gethostname)) { eval 'sub SYS_gethostname () { &__NR_gethostname;}' unless defined(&SYS_gethostname); } if(defined(&__NR_getitimer)) { eval 'sub SYS_getitimer () { &__NR_getitimer;}' unless defined(&SYS_getitimer); } if(defined(&__NR_getpagesize)) { eval 'sub SYS_getpagesize () { &__NR_getpagesize;}' unless defined(&SYS_getpagesize); } if(defined(&__NR_getpeername)) { eval 'sub SYS_getpeername () { &__NR_getpeername;}' unless defined(&SYS_getpeername); } if(defined(&__NR_getpgid)) { eval 'sub SYS_getpgid () { &__NR_getpgid;}' unless defined(&SYS_getpgid); } if(defined(&__NR_getpgrp)) { eval 'sub SYS_getpgrp () { &__NR_getpgrp;}' unless defined(&SYS_getpgrp); } if(defined(&__NR_getpid)) { eval 'sub SYS_getpid () { &__NR_getpid;}' unless defined(&SYS_getpid); } if(defined(&__NR_getpmsg)) { eval 'sub SYS_getpmsg () { &__NR_getpmsg;}' unless defined(&SYS_getpmsg); } if(defined(&__NR_getppid)) { eval 'sub SYS_getppid () { &__NR_getppid;}' unless defined(&SYS_getppid); } if(defined(&__NR_getpriority)) { eval 'sub SYS_getpriority () { &__NR_getpriority;}' unless defined(&SYS_getpriority); } if(defined(&__NR_getrandom)) { eval 'sub SYS_getrandom () { &__NR_getrandom;}' unless defined(&SYS_getrandom); } if(defined(&__NR_getresgid)) { eval 'sub SYS_getresgid () { &__NR_getresgid;}' unless defined(&SYS_getresgid); } if(defined(&__NR_getresgid32)) { eval 'sub SYS_getresgid32 () { &__NR_getresgid32;}' unless defined(&SYS_getresgid32); } if(defined(&__NR_getresuid)) { eval 'sub SYS_getresuid () { &__NR_getresuid;}' unless defined(&SYS_getresuid); } if(defined(&__NR_getresuid32)) { eval 'sub SYS_getresuid32 () { &__NR_getresuid32;}' unless defined(&SYS_getresuid32); } if(defined(&__NR_getrlimit)) { eval 'sub SYS_getrlimit () { &__NR_getrlimit;}' unless defined(&SYS_getrlimit); } if(defined(&__NR_getrusage)) { eval 'sub SYS_getrusage () { &__NR_getrusage;}' unless defined(&SYS_getrusage); } if(defined(&__NR_getsid)) { eval 'sub SYS_getsid () { &__NR_getsid;}' unless defined(&SYS_getsid); } if(defined(&__NR_getsockname)) { eval 'sub SYS_getsockname () { &__NR_getsockname;}' unless defined(&SYS_getsockname); } if(defined(&__NR_getsockopt)) { eval 'sub SYS_getsockopt () { &__NR_getsockopt;}' unless defined(&SYS_getsockopt); } if(defined(&__NR_gettid)) { eval 'sub SYS_gettid () { &__NR_gettid;}' unless defined(&SYS_gettid); } if(defined(&__NR_gettimeofday)) { eval 'sub SYS_gettimeofday () { &__NR_gettimeofday;}' unless defined(&SYS_gettimeofday); } if(defined(&__NR_getuid)) { eval 'sub SYS_getuid () { &__NR_getuid;}' unless defined(&SYS_getuid); } if(defined(&__NR_getuid32)) { eval 'sub SYS_getuid32 () { &__NR_getuid32;}' unless defined(&SYS_getuid32); } if(defined(&__NR_getunwind)) { eval 'sub SYS_getunwind () { &__NR_getunwind;}' unless defined(&SYS_getunwind); } if(defined(&__NR_getxattr)) { eval 'sub SYS_getxattr () { &__NR_getxattr;}' unless defined(&SYS_getxattr); } if(defined(&__NR_getxgid)) { eval 'sub SYS_getxgid () { &__NR_getxgid;}' unless defined(&SYS_getxgid); } if(defined(&__NR_getxpid)) { eval 'sub SYS_getxpid () { &__NR_getxpid;}' unless defined(&SYS_getxpid); } if(defined(&__NR_getxuid)) { eval 'sub SYS_getxuid () { &__NR_getxuid;}' unless defined(&SYS_getxuid); } if(defined(&__NR_gtty)) { eval 'sub SYS_gtty () { &__NR_gtty;}' unless defined(&SYS_gtty); } if(defined(&__NR_idle)) { eval 'sub SYS_idle () { &__NR_idle;}' unless defined(&SYS_idle); } if(defined(&__NR_init_module)) { eval 'sub SYS_init_module () { &__NR_init_module;}' unless defined(&SYS_init_module); } if(defined(&__NR_inotify_add_watch)) { eval 'sub SYS_inotify_add_watch () { &__NR_inotify_add_watch;}' unless defined(&SYS_inotify_add_watch); } if(defined(&__NR_inotify_init)) { eval 'sub SYS_inotify_init () { &__NR_inotify_init;}' unless defined(&SYS_inotify_init); } if(defined(&__NR_inotify_init1)) { eval 'sub SYS_inotify_init1 () { &__NR_inotify_init1;}' unless defined(&SYS_inotify_init1); } if(defined(&__NR_inotify_rm_watch)) { eval 'sub SYS_inotify_rm_watch () { &__NR_inotify_rm_watch;}' unless defined(&SYS_inotify_rm_watch); } if(defined(&__NR_io_cancel)) { eval 'sub SYS_io_cancel () { &__NR_io_cancel;}' unless defined(&SYS_io_cancel); } if(defined(&__NR_io_destroy)) { eval 'sub SYS_io_destroy () { &__NR_io_destroy;}' unless defined(&SYS_io_destroy); } if(defined(&__NR_io_getevents)) { eval 'sub SYS_io_getevents () { &__NR_io_getevents;}' unless defined(&SYS_io_getevents); } if(defined(&__NR_io_pgetevents)) { eval 'sub SYS_io_pgetevents () { &__NR_io_pgetevents;}' unless defined(&SYS_io_pgetevents); } if(defined(&__NR_io_pgetevents_time64)) { eval 'sub SYS_io_pgetevents_time64 () { &__NR_io_pgetevents_time64;}' unless defined(&SYS_io_pgetevents_time64); } if(defined(&__NR_io_setup)) { eval 'sub SYS_io_setup () { &__NR_io_setup;}' unless defined(&SYS_io_setup); } if(defined(&__NR_io_submit)) { eval 'sub SYS_io_submit () { &__NR_io_submit;}' unless defined(&SYS_io_submit); } if(defined(&__NR_io_uring_enter)) { eval 'sub SYS_io_uring_enter () { &__NR_io_uring_enter;}' unless defined(&SYS_io_uring_enter); } if(defined(&__NR_io_uring_register)) { eval 'sub SYS_io_uring_register () { &__NR_io_uring_register;}' unless defined(&SYS_io_uring_register); } if(defined(&__NR_io_uring_setup)) { eval 'sub SYS_io_uring_setup () { &__NR_io_uring_setup;}' unless defined(&SYS_io_uring_setup); } if(defined(&__NR_ioctl)) { eval 'sub SYS_ioctl () { &__NR_ioctl;}' unless defined(&SYS_ioctl); } if(defined(&__NR_ioperm)) { eval 'sub SYS_ioperm () { &__NR_ioperm;}' unless defined(&SYS_ioperm); } if(defined(&__NR_iopl)) { eval 'sub SYS_iopl () { &__NR_iopl;}' unless defined(&SYS_iopl); } if(defined(&__NR_ioprio_get)) { eval 'sub SYS_ioprio_get () { &__NR_ioprio_get;}' unless defined(&SYS_ioprio_get); } if(defined(&__NR_ioprio_set)) { eval 'sub SYS_ioprio_set () { &__NR_ioprio_set;}' unless defined(&SYS_ioprio_set); } if(defined(&__NR_ipc)) { eval 'sub SYS_ipc () { &__NR_ipc;}' unless defined(&SYS_ipc); } if(defined(&__NR_kcmp)) { eval 'sub SYS_kcmp () { &__NR_kcmp;}' unless defined(&SYS_kcmp); } if(defined(&__NR_kern_features)) { eval 'sub SYS_kern_features () { &__NR_kern_features;}' unless defined(&SYS_kern_features); } if(defined(&__NR_kexec_file_load)) { eval 'sub SYS_kexec_file_load () { &__NR_kexec_file_load;}' unless defined(&SYS_kexec_file_load); } if(defined(&__NR_kexec_load)) { eval 'sub SYS_kexec_load () { &__NR_kexec_load;}' unless defined(&SYS_kexec_load); } if(defined(&__NR_keyctl)) { eval 'sub SYS_keyctl () { &__NR_keyctl;}' unless defined(&SYS_keyctl); } if(defined(&__NR_kill)) { eval 'sub SYS_kill () { &__NR_kill;}' unless defined(&SYS_kill); } if(defined(&__NR_landlock_add_rule)) { eval 'sub SYS_landlock_add_rule () { &__NR_landlock_add_rule;}' unless defined(&SYS_landlock_add_rule); } if(defined(&__NR_landlock_create_ruleset)) { eval 'sub SYS_landlock_create_ruleset () { &__NR_landlock_create_ruleset;}' unless defined(&SYS_landlock_create_ruleset); } if(defined(&__NR_landlock_restrict_self)) { eval 'sub SYS_landlock_restrict_self () { &__NR_landlock_restrict_self;}' unless defined(&SYS_landlock_restrict_self); } if(defined(&__NR_lchown)) { eval 'sub SYS_lchown () { &__NR_lchown;}' unless defined(&SYS_lchown); } if(defined(&__NR_lchown32)) { eval 'sub SYS_lchown32 () { &__NR_lchown32;}' unless defined(&SYS_lchown32); } if(defined(&__NR_lgetxattr)) { eval 'sub SYS_lgetxattr () { &__NR_lgetxattr;}' unless defined(&SYS_lgetxattr); } if(defined(&__NR_link)) { eval 'sub SYS_link () { &__NR_link;}' unless defined(&SYS_link); } if(defined(&__NR_linkat)) { eval 'sub SYS_linkat () { &__NR_linkat;}' unless defined(&SYS_linkat); } if(defined(&__NR_listen)) { eval 'sub SYS_listen () { &__NR_listen;}' unless defined(&SYS_listen); } if(defined(&__NR_listmount)) { eval 'sub SYS_listmount () { &__NR_listmount;}' unless defined(&SYS_listmount); } if(defined(&__NR_listxattr)) { eval 'sub SYS_listxattr () { &__NR_listxattr;}' unless defined(&SYS_listxattr); } if(defined(&__NR_llistxattr)) { eval 'sub SYS_llistxattr () { &__NR_llistxattr;}' unless defined(&SYS_llistxattr); } if(defined(&__NR_llseek)) { eval 'sub SYS_llseek () { &__NR_llseek;}' unless defined(&SYS_llseek); } if(defined(&__NR_lock)) { eval 'sub SYS_lock () { &__NR_lock;}' unless defined(&SYS_lock); } if(defined(&__NR_lookup_dcookie)) { eval 'sub SYS_lookup_dcookie () { &__NR_lookup_dcookie;}' unless defined(&SYS_lookup_dcookie); } if(defined(&__NR_lremovexattr)) { eval 'sub SYS_lremovexattr () { &__NR_lremovexattr;}' unless defined(&SYS_lremovexattr); } if(defined(&__NR_lseek)) { eval 'sub SYS_lseek () { &__NR_lseek;}' unless defined(&SYS_lseek); } if(defined(&__NR_lsetxattr)) { eval 'sub SYS_lsetxattr () { &__NR_lsetxattr;}' unless defined(&SYS_lsetxattr); } if(defined(&__NR_lsm_get_self_attr)) { eval 'sub SYS_lsm_get_self_attr () { &__NR_lsm_get_self_attr;}' unless defined(&SYS_lsm_get_self_attr); } if(defined(&__NR_lsm_list_modules)) { eval 'sub SYS_lsm_list_modules () { &__NR_lsm_list_modules;}' unless defined(&SYS_lsm_list_modules); } if(defined(&__NR_lsm_set_self_attr)) { eval 'sub SYS_lsm_set_self_attr () { &__NR_lsm_set_self_attr;}' unless defined(&SYS_lsm_set_self_attr); } if(defined(&__NR_lstat)) { eval 'sub SYS_lstat () { &__NR_lstat;}' unless defined(&SYS_lstat); } if(defined(&__NR_lstat64)) { eval 'sub SYS_lstat64 () { &__NR_lstat64;}' unless defined(&SYS_lstat64); } if(defined(&__NR_madvise)) { eval 'sub SYS_madvise () { &__NR_madvise;}' unless defined(&SYS_madvise); } if(defined(&__NR_map_shadow_stack)) { eval 'sub SYS_map_shadow_stack () { &__NR_map_shadow_stack;}' unless defined(&SYS_map_shadow_stack); } if(defined(&__NR_mbind)) { eval 'sub SYS_mbind () { &__NR_mbind;}' unless defined(&SYS_mbind); } if(defined(&__NR_membarrier)) { eval 'sub SYS_membarrier () { &__NR_membarrier;}' unless defined(&SYS_membarrier); } if(defined(&__NR_memfd_create)) { eval 'sub SYS_memfd_create () { &__NR_memfd_create;}' unless defined(&SYS_memfd_create); } if(defined(&__NR_memfd_secret)) { eval 'sub SYS_memfd_secret () { &__NR_memfd_secret;}' unless defined(&SYS_memfd_secret); } if(defined(&__NR_memory_ordering)) { eval 'sub SYS_memory_ordering () { &__NR_memory_ordering;}' unless defined(&SYS_memory_ordering); } if(defined(&__NR_migrate_pages)) { eval 'sub SYS_migrate_pages () { &__NR_migrate_pages;}' unless defined(&SYS_migrate_pages); } if(defined(&__NR_mincore)) { eval 'sub SYS_mincore () { &__NR_mincore;}' unless defined(&SYS_mincore); } if(defined(&__NR_mkdir)) { eval 'sub SYS_mkdir () { &__NR_mkdir;}' unless defined(&SYS_mkdir); } if(defined(&__NR_mkdirat)) { eval 'sub SYS_mkdirat () { &__NR_mkdirat;}' unless defined(&SYS_mkdirat); } if(defined(&__NR_mknod)) { eval 'sub SYS_mknod () { &__NR_mknod;}' unless defined(&SYS_mknod); } if(defined(&__NR_mknodat)) { eval 'sub SYS_mknodat () { &__NR_mknodat;}' unless defined(&SYS_mknodat); } if(defined(&__NR_mlock)) { eval 'sub SYS_mlock () { &__NR_mlock;}' unless defined(&SYS_mlock); } if(defined(&__NR_mlock2)) { eval 'sub SYS_mlock2 () { &__NR_mlock2;}' unless defined(&SYS_mlock2); } if(defined(&__NR_mlockall)) { eval 'sub SYS_mlockall () { &__NR_mlockall;}' unless defined(&SYS_mlockall); } if(defined(&__NR_mmap)) { eval 'sub SYS_mmap () { &__NR_mmap;}' unless defined(&SYS_mmap); } if(defined(&__NR_mmap2)) { eval 'sub SYS_mmap2 () { &__NR_mmap2;}' unless defined(&SYS_mmap2); } if(defined(&__NR_modify_ldt)) { eval 'sub SYS_modify_ldt () { &__NR_modify_ldt;}' unless defined(&SYS_modify_ldt); } if(defined(&__NR_mount)) { eval 'sub SYS_mount () { &__NR_mount;}' unless defined(&SYS_mount); } if(defined(&__NR_mount_setattr)) { eval 'sub SYS_mount_setattr () { &__NR_mount_setattr;}' unless defined(&SYS_mount_setattr); } if(defined(&__NR_move_mount)) { eval 'sub SYS_move_mount () { &__NR_move_mount;}' unless defined(&SYS_move_mount); } if(defined(&__NR_move_pages)) { eval 'sub SYS_move_pages () { &__NR_move_pages;}' unless defined(&SYS_move_pages); } if(defined(&__NR_mprotect)) { eval 'sub SYS_mprotect () { &__NR_mprotect;}' unless defined(&SYS_mprotect); } if(defined(&__NR_mpx)) { eval 'sub SYS_mpx () { &__NR_mpx;}' unless defined(&SYS_mpx); } if(defined(&__NR_mq_getsetattr)) { eval 'sub SYS_mq_getsetattr () { &__NR_mq_getsetattr;}' unless defined(&SYS_mq_getsetattr); } if(defined(&__NR_mq_notify)) { eval 'sub SYS_mq_notify () { &__NR_mq_notify;}' unless defined(&SYS_mq_notify); } if(defined(&__NR_mq_open)) { eval 'sub SYS_mq_open () { &__NR_mq_open;}' unless defined(&SYS_mq_open); } if(defined(&__NR_mq_timedreceive)) { eval 'sub SYS_mq_timedreceive () { &__NR_mq_timedreceive;}' unless defined(&SYS_mq_timedreceive); } if(defined(&__NR_mq_timedreceive_time64)) { eval 'sub SYS_mq_timedreceive_time64 () { &__NR_mq_timedreceive_time64;}' unless defined(&SYS_mq_timedreceive_time64); } if(defined(&__NR_mq_timedsend)) { eval 'sub SYS_mq_timedsend () { &__NR_mq_timedsend;}' unless defined(&SYS_mq_timedsend); } if(defined(&__NR_mq_timedsend_time64)) { eval 'sub SYS_mq_timedsend_time64 () { &__NR_mq_timedsend_time64;}' unless defined(&SYS_mq_timedsend_time64); } if(defined(&__NR_mq_unlink)) { eval 'sub SYS_mq_unlink () { &__NR_mq_unlink;}' unless defined(&SYS_mq_unlink); } if(defined(&__NR_mremap)) { eval 'sub SYS_mremap () { &__NR_mremap;}' unless defined(&SYS_mremap); } if(defined(&__NR_msgctl)) { eval 'sub SYS_msgctl () { &__NR_msgctl;}' unless defined(&SYS_msgctl); } if(defined(&__NR_msgget)) { eval 'sub SYS_msgget () { &__NR_msgget;}' unless defined(&SYS_msgget); } if(defined(&__NR_msgrcv)) { eval 'sub SYS_msgrcv () { &__NR_msgrcv;}' unless defined(&SYS_msgrcv); } if(defined(&__NR_msgsnd)) { eval 'sub SYS_msgsnd () { &__NR_msgsnd;}' unless defined(&SYS_msgsnd); } if(defined(&__NR_msync)) { eval 'sub SYS_msync () { &__NR_msync;}' unless defined(&SYS_msync); } if(defined(&__NR_multiplexer)) { eval 'sub SYS_multiplexer () { &__NR_multiplexer;}' unless defined(&SYS_multiplexer); } if(defined(&__NR_munlock)) { eval 'sub SYS_munlock () { &__NR_munlock;}' unless defined(&SYS_munlock); } if(defined(&__NR_munlockall)) { eval 'sub SYS_munlockall () { &__NR_munlockall;}' unless defined(&SYS_munlockall); } if(defined(&__NR_munmap)) { eval 'sub SYS_munmap () { &__NR_munmap;}' unless defined(&SYS_munmap); } if(defined(&__NR_name_to_handle_at)) { eval 'sub SYS_name_to_handle_at () { &__NR_name_to_handle_at;}' unless defined(&SYS_name_to_handle_at); } if(defined(&__NR_nanosleep)) { eval 'sub SYS_nanosleep () { &__NR_nanosleep;}' unless defined(&SYS_nanosleep); } if(defined(&__NR_newfstatat)) { eval 'sub SYS_newfstatat () { &__NR_newfstatat;}' unless defined(&SYS_newfstatat); } if(defined(&__NR_nfsservctl)) { eval 'sub SYS_nfsservctl () { &__NR_nfsservctl;}' unless defined(&SYS_nfsservctl); } if(defined(&__NR_ni_syscall)) { eval 'sub SYS_ni_syscall () { &__NR_ni_syscall;}' unless defined(&SYS_ni_syscall); } if(defined(&__NR_nice)) { eval 'sub SYS_nice () { &__NR_nice;}' unless defined(&SYS_nice); } if(defined(&__NR_old_adjtimex)) { eval 'sub SYS_old_adjtimex () { &__NR_old_adjtimex;}' unless defined(&SYS_old_adjtimex); } if(defined(&__NR_old_getpagesize)) { eval 'sub SYS_old_getpagesize () { &__NR_old_getpagesize;}' unless defined(&SYS_old_getpagesize); } if(defined(&__NR_oldfstat)) { eval 'sub SYS_oldfstat () { &__NR_oldfstat;}' unless defined(&SYS_oldfstat); } if(defined(&__NR_oldlstat)) { eval 'sub SYS_oldlstat () { &__NR_oldlstat;}' unless defined(&SYS_oldlstat); } if(defined(&__NR_oldolduname)) { eval 'sub SYS_oldolduname () { &__NR_oldolduname;}' unless defined(&SYS_oldolduname); } if(defined(&__NR_oldstat)) { eval 'sub SYS_oldstat () { &__NR_oldstat;}' unless defined(&SYS_oldstat); } if(defined(&__NR_oldumount)) { eval 'sub SYS_oldumount () { &__NR_oldumount;}' unless defined(&SYS_oldumount); } if(defined(&__NR_olduname)) { eval 'sub SYS_olduname () { &__NR_olduname;}' unless defined(&SYS_olduname); } if(defined(&__NR_open)) { eval 'sub SYS_open () { &__NR_open;}' unless defined(&SYS_open); } if(defined(&__NR_open_by_handle_at)) { eval 'sub SYS_open_by_handle_at () { &__NR_open_by_handle_at;}' unless defined(&SYS_open_by_handle_at); } if(defined(&__NR_open_tree)) { eval 'sub SYS_open_tree () { &__NR_open_tree;}' unless defined(&SYS_open_tree); } if(defined(&__NR_openat)) { eval 'sub SYS_openat () { &__NR_openat;}' unless defined(&SYS_openat); } if(defined(&__NR_openat2)) { eval 'sub SYS_openat2 () { &__NR_openat2;}' unless defined(&SYS_openat2); } if(defined(&__NR_osf_adjtime)) { eval 'sub SYS_osf_adjtime () { &__NR_osf_adjtime;}' unless defined(&SYS_osf_adjtime); } if(defined(&__NR_osf_afs_syscall)) { eval 'sub SYS_osf_afs_syscall () { &__NR_osf_afs_syscall;}' unless defined(&SYS_osf_afs_syscall); } if(defined(&__NR_osf_alt_plock)) { eval 'sub SYS_osf_alt_plock () { &__NR_osf_alt_plock;}' unless defined(&SYS_osf_alt_plock); } if(defined(&__NR_osf_alt_setsid)) { eval 'sub SYS_osf_alt_setsid () { &__NR_osf_alt_setsid;}' unless defined(&SYS_osf_alt_setsid); } if(defined(&__NR_osf_alt_sigpending)) { eval 'sub SYS_osf_alt_sigpending () { &__NR_osf_alt_sigpending;}' unless defined(&SYS_osf_alt_sigpending); } if(defined(&__NR_osf_asynch_daemon)) { eval 'sub SYS_osf_asynch_daemon () { &__NR_osf_asynch_daemon;}' unless defined(&SYS_osf_asynch_daemon); } if(defined(&__NR_osf_audcntl)) { eval 'sub SYS_osf_audcntl () { &__NR_osf_audcntl;}' unless defined(&SYS_osf_audcntl); } if(defined(&__NR_osf_audgen)) { eval 'sub SYS_osf_audgen () { &__NR_osf_audgen;}' unless defined(&SYS_osf_audgen); } if(defined(&__NR_osf_chflags)) { eval 'sub SYS_osf_chflags () { &__NR_osf_chflags;}' unless defined(&SYS_osf_chflags); } if(defined(&__NR_osf_execve)) { eval 'sub SYS_osf_execve () { &__NR_osf_execve;}' unless defined(&SYS_osf_execve); } if(defined(&__NR_osf_exportfs)) { eval 'sub SYS_osf_exportfs () { &__NR_osf_exportfs;}' unless defined(&SYS_osf_exportfs); } if(defined(&__NR_osf_fchflags)) { eval 'sub SYS_osf_fchflags () { &__NR_osf_fchflags;}' unless defined(&SYS_osf_fchflags); } if(defined(&__NR_osf_fdatasync)) { eval 'sub SYS_osf_fdatasync () { &__NR_osf_fdatasync;}' unless defined(&SYS_osf_fdatasync); } if(defined(&__NR_osf_fpathconf)) { eval 'sub SYS_osf_fpathconf () { &__NR_osf_fpathconf;}' unless defined(&SYS_osf_fpathconf); } if(defined(&__NR_osf_fstat)) { eval 'sub SYS_osf_fstat () { &__NR_osf_fstat;}' unless defined(&SYS_osf_fstat); } if(defined(&__NR_osf_fstatfs)) { eval 'sub SYS_osf_fstatfs () { &__NR_osf_fstatfs;}' unless defined(&SYS_osf_fstatfs); } if(defined(&__NR_osf_fstatfs64)) { eval 'sub SYS_osf_fstatfs64 () { &__NR_osf_fstatfs64;}' unless defined(&SYS_osf_fstatfs64); } if(defined(&__NR_osf_fuser)) { eval 'sub SYS_osf_fuser () { &__NR_osf_fuser;}' unless defined(&SYS_osf_fuser); } if(defined(&__NR_osf_getaddressconf)) { eval 'sub SYS_osf_getaddressconf () { &__NR_osf_getaddressconf;}' unless defined(&SYS_osf_getaddressconf); } if(defined(&__NR_osf_getdirentries)) { eval 'sub SYS_osf_getdirentries () { &__NR_osf_getdirentries;}' unless defined(&SYS_osf_getdirentries); } if(defined(&__NR_osf_getdomainname)) { eval 'sub SYS_osf_getdomainname () { &__NR_osf_getdomainname;}' unless defined(&SYS_osf_getdomainname); } if(defined(&__NR_osf_getfh)) { eval 'sub SYS_osf_getfh () { &__NR_osf_getfh;}' unless defined(&SYS_osf_getfh); } if(defined(&__NR_osf_getfsstat)) { eval 'sub SYS_osf_getfsstat () { &__NR_osf_getfsstat;}' unless defined(&SYS_osf_getfsstat); } if(defined(&__NR_osf_gethostid)) { eval 'sub SYS_osf_gethostid () { &__NR_osf_gethostid;}' unless defined(&SYS_osf_gethostid); } if(defined(&__NR_osf_getitimer)) { eval 'sub SYS_osf_getitimer () { &__NR_osf_getitimer;}' unless defined(&SYS_osf_getitimer); } if(defined(&__NR_osf_getlogin)) { eval 'sub SYS_osf_getlogin () { &__NR_osf_getlogin;}' unless defined(&SYS_osf_getlogin); } if(defined(&__NR_osf_getmnt)) { eval 'sub SYS_osf_getmnt () { &__NR_osf_getmnt;}' unless defined(&SYS_osf_getmnt); } if(defined(&__NR_osf_getrusage)) { eval 'sub SYS_osf_getrusage () { &__NR_osf_getrusage;}' unless defined(&SYS_osf_getrusage); } if(defined(&__NR_osf_getsysinfo)) { eval 'sub SYS_osf_getsysinfo () { &__NR_osf_getsysinfo;}' unless defined(&SYS_osf_getsysinfo); } if(defined(&__NR_osf_gettimeofday)) { eval 'sub SYS_osf_gettimeofday () { &__NR_osf_gettimeofday;}' unless defined(&SYS_osf_gettimeofday); } if(defined(&__NR_osf_kloadcall)) { eval 'sub SYS_osf_kloadcall () { &__NR_osf_kloadcall;}' unless defined(&SYS_osf_kloadcall); } if(defined(&__NR_osf_kmodcall)) { eval 'sub SYS_osf_kmodcall () { &__NR_osf_kmodcall;}' unless defined(&SYS_osf_kmodcall); } if(defined(&__NR_osf_lstat)) { eval 'sub SYS_osf_lstat () { &__NR_osf_lstat;}' unless defined(&SYS_osf_lstat); } if(defined(&__NR_osf_memcntl)) { eval 'sub SYS_osf_memcntl () { &__NR_osf_memcntl;}' unless defined(&SYS_osf_memcntl); } if(defined(&__NR_osf_mincore)) { eval 'sub SYS_osf_mincore () { &__NR_osf_mincore;}' unless defined(&SYS_osf_mincore); } if(defined(&__NR_osf_mount)) { eval 'sub SYS_osf_mount () { &__NR_osf_mount;}' unless defined(&SYS_osf_mount); } if(defined(&__NR_osf_mremap)) { eval 'sub SYS_osf_mremap () { &__NR_osf_mremap;}' unless defined(&SYS_osf_mremap); } if(defined(&__NR_osf_msfs_syscall)) { eval 'sub SYS_osf_msfs_syscall () { &__NR_osf_msfs_syscall;}' unless defined(&SYS_osf_msfs_syscall); } if(defined(&__NR_osf_msleep)) { eval 'sub SYS_osf_msleep () { &__NR_osf_msleep;}' unless defined(&SYS_osf_msleep); } if(defined(&__NR_osf_mvalid)) { eval 'sub SYS_osf_mvalid () { &__NR_osf_mvalid;}' unless defined(&SYS_osf_mvalid); } if(defined(&__NR_osf_mwakeup)) { eval 'sub SYS_osf_mwakeup () { &__NR_osf_mwakeup;}' unless defined(&SYS_osf_mwakeup); } if(defined(&__NR_osf_naccept)) { eval 'sub SYS_osf_naccept () { &__NR_osf_naccept;}' unless defined(&SYS_osf_naccept); } if(defined(&__NR_osf_nfssvc)) { eval 'sub SYS_osf_nfssvc () { &__NR_osf_nfssvc;}' unless defined(&SYS_osf_nfssvc); } if(defined(&__NR_osf_ngetpeername)) { eval 'sub SYS_osf_ngetpeername () { &__NR_osf_ngetpeername;}' unless defined(&SYS_osf_ngetpeername); } if(defined(&__NR_osf_ngetsockname)) { eval 'sub SYS_osf_ngetsockname () { &__NR_osf_ngetsockname;}' unless defined(&SYS_osf_ngetsockname); } if(defined(&__NR_osf_nrecvfrom)) { eval 'sub SYS_osf_nrecvfrom () { &__NR_osf_nrecvfrom;}' unless defined(&SYS_osf_nrecvfrom); } if(defined(&__NR_osf_nrecvmsg)) { eval 'sub SYS_osf_nrecvmsg () { &__NR_osf_nrecvmsg;}' unless defined(&SYS_osf_nrecvmsg); } if(defined(&__NR_osf_nsendmsg)) { eval 'sub SYS_osf_nsendmsg () { &__NR_osf_nsendmsg;}' unless defined(&SYS_osf_nsendmsg); } if(defined(&__NR_osf_ntp_adjtime)) { eval 'sub SYS_osf_ntp_adjtime () { &__NR_osf_ntp_adjtime;}' unless defined(&SYS_osf_ntp_adjtime); } if(defined(&__NR_osf_ntp_gettime)) { eval 'sub SYS_osf_ntp_gettime () { &__NR_osf_ntp_gettime;}' unless defined(&SYS_osf_ntp_gettime); } if(defined(&__NR_osf_old_creat)) { eval 'sub SYS_osf_old_creat () { &__NR_osf_old_creat;}' unless defined(&SYS_osf_old_creat); } if(defined(&__NR_osf_old_fstat)) { eval 'sub SYS_osf_old_fstat () { &__NR_osf_old_fstat;}' unless defined(&SYS_osf_old_fstat); } if(defined(&__NR_osf_old_getpgrp)) { eval 'sub SYS_osf_old_getpgrp () { &__NR_osf_old_getpgrp;}' unless defined(&SYS_osf_old_getpgrp); } if(defined(&__NR_osf_old_killpg)) { eval 'sub SYS_osf_old_killpg () { &__NR_osf_old_killpg;}' unless defined(&SYS_osf_old_killpg); } if(defined(&__NR_osf_old_lstat)) { eval 'sub SYS_osf_old_lstat () { &__NR_osf_old_lstat;}' unless defined(&SYS_osf_old_lstat); } if(defined(&__NR_osf_old_open)) { eval 'sub SYS_osf_old_open () { &__NR_osf_old_open;}' unless defined(&SYS_osf_old_open); } if(defined(&__NR_osf_old_sigaction)) { eval 'sub SYS_osf_old_sigaction () { &__NR_osf_old_sigaction;}' unless defined(&SYS_osf_old_sigaction); } if(defined(&__NR_osf_old_sigblock)) { eval 'sub SYS_osf_old_sigblock () { &__NR_osf_old_sigblock;}' unless defined(&SYS_osf_old_sigblock); } if(defined(&__NR_osf_old_sigreturn)) { eval 'sub SYS_osf_old_sigreturn () { &__NR_osf_old_sigreturn;}' unless defined(&SYS_osf_old_sigreturn); } if(defined(&__NR_osf_old_sigsetmask)) { eval 'sub SYS_osf_old_sigsetmask () { &__NR_osf_old_sigsetmask;}' unless defined(&SYS_osf_old_sigsetmask); } if(defined(&__NR_osf_old_sigvec)) { eval 'sub SYS_osf_old_sigvec () { &__NR_osf_old_sigvec;}' unless defined(&SYS_osf_old_sigvec); } if(defined(&__NR_osf_old_stat)) { eval 'sub SYS_osf_old_stat () { &__NR_osf_old_stat;}' unless defined(&SYS_osf_old_stat); } if(defined(&__NR_osf_old_vadvise)) { eval 'sub SYS_osf_old_vadvise () { &__NR_osf_old_vadvise;}' unless defined(&SYS_osf_old_vadvise); } if(defined(&__NR_osf_old_vtrace)) { eval 'sub SYS_osf_old_vtrace () { &__NR_osf_old_vtrace;}' unless defined(&SYS_osf_old_vtrace); } if(defined(&__NR_osf_old_wait)) { eval 'sub SYS_osf_old_wait () { &__NR_osf_old_wait;}' unless defined(&SYS_osf_old_wait); } if(defined(&__NR_osf_oldquota)) { eval 'sub SYS_osf_oldquota () { &__NR_osf_oldquota;}' unless defined(&SYS_osf_oldquota); } if(defined(&__NR_osf_pathconf)) { eval 'sub SYS_osf_pathconf () { &__NR_osf_pathconf;}' unless defined(&SYS_osf_pathconf); } if(defined(&__NR_osf_pid_block)) { eval 'sub SYS_osf_pid_block () { &__NR_osf_pid_block;}' unless defined(&SYS_osf_pid_block); } if(defined(&__NR_osf_pid_unblock)) { eval 'sub SYS_osf_pid_unblock () { &__NR_osf_pid_unblock;}' unless defined(&SYS_osf_pid_unblock); } if(defined(&__NR_osf_plock)) { eval 'sub SYS_osf_plock () { &__NR_osf_plock;}' unless defined(&SYS_osf_plock); } if(defined(&__NR_osf_priocntlset)) { eval 'sub SYS_osf_priocntlset () { &__NR_osf_priocntlset;}' unless defined(&SYS_osf_priocntlset); } if(defined(&__NR_osf_profil)) { eval 'sub SYS_osf_profil () { &__NR_osf_profil;}' unless defined(&SYS_osf_profil); } if(defined(&__NR_osf_proplist_syscall)) { eval 'sub SYS_osf_proplist_syscall () { &__NR_osf_proplist_syscall;}' unless defined(&SYS_osf_proplist_syscall); } if(defined(&__NR_osf_reboot)) { eval 'sub SYS_osf_reboot () { &__NR_osf_reboot;}' unless defined(&SYS_osf_reboot); } if(defined(&__NR_osf_revoke)) { eval 'sub SYS_osf_revoke () { &__NR_osf_revoke;}' unless defined(&SYS_osf_revoke); } if(defined(&__NR_osf_sbrk)) { eval 'sub SYS_osf_sbrk () { &__NR_osf_sbrk;}' unless defined(&SYS_osf_sbrk); } if(defined(&__NR_osf_security)) { eval 'sub SYS_osf_security () { &__NR_osf_security;}' unless defined(&SYS_osf_security); } if(defined(&__NR_osf_select)) { eval 'sub SYS_osf_select () { &__NR_osf_select;}' unless defined(&SYS_osf_select); } if(defined(&__NR_osf_set_program_attributes)) { eval 'sub SYS_osf_set_program_attributes () { &__NR_osf_set_program_attributes;}' unless defined(&SYS_osf_set_program_attributes); } if(defined(&__NR_osf_set_speculative)) { eval 'sub SYS_osf_set_speculative () { &__NR_osf_set_speculative;}' unless defined(&SYS_osf_set_speculative); } if(defined(&__NR_osf_sethostid)) { eval 'sub SYS_osf_sethostid () { &__NR_osf_sethostid;}' unless defined(&SYS_osf_sethostid); } if(defined(&__NR_osf_setitimer)) { eval 'sub SYS_osf_setitimer () { &__NR_osf_setitimer;}' unless defined(&SYS_osf_setitimer); } if(defined(&__NR_osf_setlogin)) { eval 'sub SYS_osf_setlogin () { &__NR_osf_setlogin;}' unless defined(&SYS_osf_setlogin); } if(defined(&__NR_osf_setsysinfo)) { eval 'sub SYS_osf_setsysinfo () { &__NR_osf_setsysinfo;}' unless defined(&SYS_osf_setsysinfo); } if(defined(&__NR_osf_settimeofday)) { eval 'sub SYS_osf_settimeofday () { &__NR_osf_settimeofday;}' unless defined(&SYS_osf_settimeofday); } if(defined(&__NR_osf_shmat)) { eval 'sub SYS_osf_shmat () { &__NR_osf_shmat;}' unless defined(&SYS_osf_shmat); } if(defined(&__NR_osf_signal)) { eval 'sub SYS_osf_signal () { &__NR_osf_signal;}' unless defined(&SYS_osf_signal); } if(defined(&__NR_osf_sigprocmask)) { eval 'sub SYS_osf_sigprocmask () { &__NR_osf_sigprocmask;}' unless defined(&SYS_osf_sigprocmask); } if(defined(&__NR_osf_sigsendset)) { eval 'sub SYS_osf_sigsendset () { &__NR_osf_sigsendset;}' unless defined(&SYS_osf_sigsendset); } if(defined(&__NR_osf_sigstack)) { eval 'sub SYS_osf_sigstack () { &__NR_osf_sigstack;}' unless defined(&SYS_osf_sigstack); } if(defined(&__NR_osf_sigwaitprim)) { eval 'sub SYS_osf_sigwaitprim () { &__NR_osf_sigwaitprim;}' unless defined(&SYS_osf_sigwaitprim); } if(defined(&__NR_osf_sstk)) { eval 'sub SYS_osf_sstk () { &__NR_osf_sstk;}' unless defined(&SYS_osf_sstk); } if(defined(&__NR_osf_stat)) { eval 'sub SYS_osf_stat () { &__NR_osf_stat;}' unless defined(&SYS_osf_stat); } if(defined(&__NR_osf_statfs)) { eval 'sub SYS_osf_statfs () { &__NR_osf_statfs;}' unless defined(&SYS_osf_statfs); } if(defined(&__NR_osf_statfs64)) { eval 'sub SYS_osf_statfs64 () { &__NR_osf_statfs64;}' unless defined(&SYS_osf_statfs64); } if(defined(&__NR_osf_subsys_info)) { eval 'sub SYS_osf_subsys_info () { &__NR_osf_subsys_info;}' unless defined(&SYS_osf_subsys_info); } if(defined(&__NR_osf_swapctl)) { eval 'sub SYS_osf_swapctl () { &__NR_osf_swapctl;}' unless defined(&SYS_osf_swapctl); } if(defined(&__NR_osf_swapon)) { eval 'sub SYS_osf_swapon () { &__NR_osf_swapon;}' unless defined(&SYS_osf_swapon); } if(defined(&__NR_osf_syscall)) { eval 'sub SYS_osf_syscall () { &__NR_osf_syscall;}' unless defined(&SYS_osf_syscall); } if(defined(&__NR_osf_sysinfo)) { eval 'sub SYS_osf_sysinfo () { &__NR_osf_sysinfo;}' unless defined(&SYS_osf_sysinfo); } if(defined(&__NR_osf_table)) { eval 'sub SYS_osf_table () { &__NR_osf_table;}' unless defined(&SYS_osf_table); } if(defined(&__NR_osf_uadmin)) { eval 'sub SYS_osf_uadmin () { &__NR_osf_uadmin;}' unless defined(&SYS_osf_uadmin); } if(defined(&__NR_osf_usleep_thread)) { eval 'sub SYS_osf_usleep_thread () { &__NR_osf_usleep_thread;}' unless defined(&SYS_osf_usleep_thread); } if(defined(&__NR_osf_uswitch)) { eval 'sub SYS_osf_uswitch () { &__NR_osf_uswitch;}' unless defined(&SYS_osf_uswitch); } if(defined(&__NR_osf_utc_adjtime)) { eval 'sub SYS_osf_utc_adjtime () { &__NR_osf_utc_adjtime;}' unless defined(&SYS_osf_utc_adjtime); } if(defined(&__NR_osf_utc_gettime)) { eval 'sub SYS_osf_utc_gettime () { &__NR_osf_utc_gettime;}' unless defined(&SYS_osf_utc_gettime); } if(defined(&__NR_osf_utimes)) { eval 'sub SYS_osf_utimes () { &__NR_osf_utimes;}' unless defined(&SYS_osf_utimes); } if(defined(&__NR_osf_utsname)) { eval 'sub SYS_osf_utsname () { &__NR_osf_utsname;}' unless defined(&SYS_osf_utsname); } if(defined(&__NR_osf_wait4)) { eval 'sub SYS_osf_wait4 () { &__NR_osf_wait4;}' unless defined(&SYS_osf_wait4); } if(defined(&__NR_osf_waitid)) { eval 'sub SYS_osf_waitid () { &__NR_osf_waitid;}' unless defined(&SYS_osf_waitid); } if(defined(&__NR_pause)) { eval 'sub SYS_pause () { &__NR_pause;}' unless defined(&SYS_pause); } if(defined(&__NR_pciconfig_iobase)) { eval 'sub SYS_pciconfig_iobase () { &__NR_pciconfig_iobase;}' unless defined(&SYS_pciconfig_iobase); } if(defined(&__NR_pciconfig_read)) { eval 'sub SYS_pciconfig_read () { &__NR_pciconfig_read;}' unless defined(&SYS_pciconfig_read); } if(defined(&__NR_pciconfig_write)) { eval 'sub SYS_pciconfig_write () { &__NR_pciconfig_write;}' unless defined(&SYS_pciconfig_write); } if(defined(&__NR_perf_event_open)) { eval 'sub SYS_perf_event_open () { &__NR_perf_event_open;}' unless defined(&SYS_perf_event_open); } if(defined(&__NR_perfctr)) { eval 'sub SYS_perfctr () { &__NR_perfctr;}' unless defined(&SYS_perfctr); } if(defined(&__NR_perfmonctl)) { eval 'sub SYS_perfmonctl () { &__NR_perfmonctl;}' unless defined(&SYS_perfmonctl); } if(defined(&__NR_personality)) { eval 'sub SYS_personality () { &__NR_personality;}' unless defined(&SYS_personality); } if(defined(&__NR_pidfd_getfd)) { eval 'sub SYS_pidfd_getfd () { &__NR_pidfd_getfd;}' unless defined(&SYS_pidfd_getfd); } if(defined(&__NR_pidfd_open)) { eval 'sub SYS_pidfd_open () { &__NR_pidfd_open;}' unless defined(&SYS_pidfd_open); } if(defined(&__NR_pidfd_send_signal)) { eval 'sub SYS_pidfd_send_signal () { &__NR_pidfd_send_signal;}' unless defined(&SYS_pidfd_send_signal); } if(defined(&__NR_pipe)) { eval 'sub SYS_pipe () { &__NR_pipe;}' unless defined(&SYS_pipe); } if(defined(&__NR_pipe2)) { eval 'sub SYS_pipe2 () { &__NR_pipe2;}' unless defined(&SYS_pipe2); } if(defined(&__NR_pivot_root)) { eval 'sub SYS_pivot_root () { &__NR_pivot_root;}' unless defined(&SYS_pivot_root); } if(defined(&__NR_pkey_alloc)) { eval 'sub SYS_pkey_alloc () { &__NR_pkey_alloc;}' unless defined(&SYS_pkey_alloc); } if(defined(&__NR_pkey_free)) { eval 'sub SYS_pkey_free () { &__NR_pkey_free;}' unless defined(&SYS_pkey_free); } if(defined(&__NR_pkey_mprotect)) { eval 'sub SYS_pkey_mprotect () { &__NR_pkey_mprotect;}' unless defined(&SYS_pkey_mprotect); } if(defined(&__NR_poll)) { eval 'sub SYS_poll () { &__NR_poll;}' unless defined(&SYS_poll); } if(defined(&__NR_ppoll)) { eval 'sub SYS_ppoll () { &__NR_ppoll;}' unless defined(&SYS_ppoll); } if(defined(&__NR_ppoll_time64)) { eval 'sub SYS_ppoll_time64 () { &__NR_ppoll_time64;}' unless defined(&SYS_ppoll_time64); } if(defined(&__NR_prctl)) { eval 'sub SYS_prctl () { &__NR_prctl;}' unless defined(&SYS_prctl); } if(defined(&__NR_pread64)) { eval 'sub SYS_pread64 () { &__NR_pread64;}' unless defined(&SYS_pread64); } if(defined(&__NR_preadv)) { eval 'sub SYS_preadv () { &__NR_preadv;}' unless defined(&SYS_preadv); } if(defined(&__NR_preadv2)) { eval 'sub SYS_preadv2 () { &__NR_preadv2;}' unless defined(&SYS_preadv2); } if(defined(&__NR_prlimit64)) { eval 'sub SYS_prlimit64 () { &__NR_prlimit64;}' unless defined(&SYS_prlimit64); } if(defined(&__NR_process_madvise)) { eval 'sub SYS_process_madvise () { &__NR_process_madvise;}' unless defined(&SYS_process_madvise); } if(defined(&__NR_process_mrelease)) { eval 'sub SYS_process_mrelease () { &__NR_process_mrelease;}' unless defined(&SYS_process_mrelease); } if(defined(&__NR_process_vm_readv)) { eval 'sub SYS_process_vm_readv () { &__NR_process_vm_readv;}' unless defined(&SYS_process_vm_readv); } if(defined(&__NR_process_vm_writev)) { eval 'sub SYS_process_vm_writev () { &__NR_process_vm_writev;}' unless defined(&SYS_process_vm_writev); } if(defined(&__NR_prof)) { eval 'sub SYS_prof () { &__NR_prof;}' unless defined(&SYS_prof); } if(defined(&__NR_profil)) { eval 'sub SYS_profil () { &__NR_profil;}' unless defined(&SYS_profil); } if(defined(&__NR_pselect6)) { eval 'sub SYS_pselect6 () { &__NR_pselect6;}' unless defined(&SYS_pselect6); } if(defined(&__NR_pselect6_time64)) { eval 'sub SYS_pselect6_time64 () { &__NR_pselect6_time64;}' unless defined(&SYS_pselect6_time64); } if(defined(&__NR_ptrace)) { eval 'sub SYS_ptrace () { &__NR_ptrace;}' unless defined(&SYS_ptrace); } if(defined(&__NR_putpmsg)) { eval 'sub SYS_putpmsg () { &__NR_putpmsg;}' unless defined(&SYS_putpmsg); } if(defined(&__NR_pwrite64)) { eval 'sub SYS_pwrite64 () { &__NR_pwrite64;}' unless defined(&SYS_pwrite64); } if(defined(&__NR_pwritev)) { eval 'sub SYS_pwritev () { &__NR_pwritev;}' unless defined(&SYS_pwritev); } if(defined(&__NR_pwritev2)) { eval 'sub SYS_pwritev2 () { &__NR_pwritev2;}' unless defined(&SYS_pwritev2); } if(defined(&__NR_query_module)) { eval 'sub SYS_query_module () { &__NR_query_module;}' unless defined(&SYS_query_module); } if(defined(&__NR_quotactl)) { eval 'sub SYS_quotactl () { &__NR_quotactl;}' unless defined(&SYS_quotactl); } if(defined(&__NR_quotactl_fd)) { eval 'sub SYS_quotactl_fd () { &__NR_quotactl_fd;}' unless defined(&SYS_quotactl_fd); } if(defined(&__NR_read)) { eval 'sub SYS_read () { &__NR_read;}' unless defined(&SYS_read); } if(defined(&__NR_readahead)) { eval 'sub SYS_readahead () { &__NR_readahead;}' unless defined(&SYS_readahead); } if(defined(&__NR_readdir)) { eval 'sub SYS_readdir () { &__NR_readdir;}' unless defined(&SYS_readdir); } if(defined(&__NR_readlink)) { eval 'sub SYS_readlink () { &__NR_readlink;}' unless defined(&SYS_readlink); } if(defined(&__NR_readlinkat)) { eval 'sub SYS_readlinkat () { &__NR_readlinkat;}' unless defined(&SYS_readlinkat); } if(defined(&__NR_readv)) { eval 'sub SYS_readv () { &__NR_readv;}' unless defined(&SYS_readv); } if(defined(&__NR_reboot)) { eval 'sub SYS_reboot () { &__NR_reboot;}' unless defined(&SYS_reboot); } if(defined(&__NR_recv)) { eval 'sub SYS_recv () { &__NR_recv;}' unless defined(&SYS_recv); } if(defined(&__NR_recvfrom)) { eval 'sub SYS_recvfrom () { &__NR_recvfrom;}' unless defined(&SYS_recvfrom); } if(defined(&__NR_recvmmsg)) { eval 'sub SYS_recvmmsg () { &__NR_recvmmsg;}' unless defined(&SYS_recvmmsg); } if(defined(&__NR_recvmmsg_time64)) { eval 'sub SYS_recvmmsg_time64 () { &__NR_recvmmsg_time64;}' unless defined(&SYS_recvmmsg_time64); } if(defined(&__NR_recvmsg)) { eval 'sub SYS_recvmsg () { &__NR_recvmsg;}' unless defined(&SYS_recvmsg); } if(defined(&__NR_remap_file_pages)) { eval 'sub SYS_remap_file_pages () { &__NR_remap_file_pages;}' unless defined(&SYS_remap_file_pages); } if(defined(&__NR_removexattr)) { eval 'sub SYS_removexattr () { &__NR_removexattr;}' unless defined(&SYS_removexattr); } if(defined(&__NR_rename)) { eval 'sub SYS_rename () { &__NR_rename;}' unless defined(&SYS_rename); } if(defined(&__NR_renameat)) { eval 'sub SYS_renameat () { &__NR_renameat;}' unless defined(&SYS_renameat); } if(defined(&__NR_renameat2)) { eval 'sub SYS_renameat2 () { &__NR_renameat2;}' unless defined(&SYS_renameat2); } if(defined(&__NR_request_key)) { eval 'sub SYS_request_key () { &__NR_request_key;}' unless defined(&SYS_request_key); } if(defined(&__NR_restart_syscall)) { eval 'sub SYS_restart_syscall () { &__NR_restart_syscall;}' unless defined(&SYS_restart_syscall); } if(defined(&__NR_riscv_flush_icache)) { eval 'sub SYS_riscv_flush_icache () { &__NR_riscv_flush_icache;}' unless defined(&SYS_riscv_flush_icache); } if(defined(&__NR_riscv_hwprobe)) { eval 'sub SYS_riscv_hwprobe () { &__NR_riscv_hwprobe;}' unless defined(&SYS_riscv_hwprobe); } if(defined(&__NR_rmdir)) { eval 'sub SYS_rmdir () { &__NR_rmdir;}' unless defined(&SYS_rmdir); } if(defined(&__NR_rseq)) { eval 'sub SYS_rseq () { &__NR_rseq;}' unless defined(&SYS_rseq); } if(defined(&__NR_rt_sigaction)) { eval 'sub SYS_rt_sigaction () { &__NR_rt_sigaction;}' unless defined(&SYS_rt_sigaction); } if(defined(&__NR_rt_sigpending)) { eval 'sub SYS_rt_sigpending () { &__NR_rt_sigpending;}' unless defined(&SYS_rt_sigpending); } if(defined(&__NR_rt_sigprocmask)) { eval 'sub SYS_rt_sigprocmask () { &__NR_rt_sigprocmask;}' unless defined(&SYS_rt_sigprocmask); } if(defined(&__NR_rt_sigqueueinfo)) { eval 'sub SYS_rt_sigqueueinfo () { &__NR_rt_sigqueueinfo;}' unless defined(&SYS_rt_sigqueueinfo); } if(defined(&__NR_rt_sigreturn)) { eval 'sub SYS_rt_sigreturn () { &__NR_rt_sigreturn;}' unless defined(&SYS_rt_sigreturn); } if(defined(&__NR_rt_sigsuspend)) { eval 'sub SYS_rt_sigsuspend () { &__NR_rt_sigsuspend;}' unless defined(&SYS_rt_sigsuspend); } if(defined(&__NR_rt_sigtimedwait)) { eval 'sub SYS_rt_sigtimedwait () { &__NR_rt_sigtimedwait;}' unless defined(&SYS_rt_sigtimedwait); } if(defined(&__NR_rt_sigtimedwait_time64)) { eval 'sub SYS_rt_sigtimedwait_time64 () { &__NR_rt_sigtimedwait_time64;}' unless defined(&SYS_rt_sigtimedwait_time64); } if(defined(&__NR_rt_tgsigqueueinfo)) { eval 'sub SYS_rt_tgsigqueueinfo () { &__NR_rt_tgsigqueueinfo;}' unless defined(&SYS_rt_tgsigqueueinfo); } if(defined(&__NR_rtas)) { eval 'sub SYS_rtas () { &__NR_rtas;}' unless defined(&SYS_rtas); } if(defined(&__NR_s390_guarded_storage)) { eval 'sub SYS_s390_guarded_storage () { &__NR_s390_guarded_storage;}' unless defined(&SYS_s390_guarded_storage); } if(defined(&__NR_s390_pci_mmio_read)) { eval 'sub SYS_s390_pci_mmio_read () { &__NR_s390_pci_mmio_read;}' unless defined(&SYS_s390_pci_mmio_read); } if(defined(&__NR_s390_pci_mmio_write)) { eval 'sub SYS_s390_pci_mmio_write () { &__NR_s390_pci_mmio_write;}' unless defined(&SYS_s390_pci_mmio_write); } if(defined(&__NR_s390_runtime_instr)) { eval 'sub SYS_s390_runtime_instr () { &__NR_s390_runtime_instr;}' unless defined(&SYS_s390_runtime_instr); } if(defined(&__NR_s390_sthyi)) { eval 'sub SYS_s390_sthyi () { &__NR_s390_sthyi;}' unless defined(&SYS_s390_sthyi); } if(defined(&__NR_sched_get_affinity)) { eval 'sub SYS_sched_get_affinity () { &__NR_sched_get_affinity;}' unless defined(&SYS_sched_get_affinity); } if(defined(&__NR_sched_get_priority_max)) { eval 'sub SYS_sched_get_priority_max () { &__NR_sched_get_priority_max;}' unless defined(&SYS_sched_get_priority_max); } if(defined(&__NR_sched_get_priority_min)) { eval 'sub SYS_sched_get_priority_min () { &__NR_sched_get_priority_min;}' unless defined(&SYS_sched_get_priority_min); } if(defined(&__NR_sched_getaffinity)) { eval 'sub SYS_sched_getaffinity () { &__NR_sched_getaffinity;}' unless defined(&SYS_sched_getaffinity); } if(defined(&__NR_sched_getattr)) { eval 'sub SYS_sched_getattr () { &__NR_sched_getattr;}' unless defined(&SYS_sched_getattr); } if(defined(&__NR_sched_getparam)) { eval 'sub SYS_sched_getparam () { &__NR_sched_getparam;}' unless defined(&SYS_sched_getparam); } if(defined(&__NR_sched_getscheduler)) { eval 'sub SYS_sched_getscheduler () { &__NR_sched_getscheduler;}' unless defined(&SYS_sched_getscheduler); } if(defined(&__NR_sched_rr_get_interval)) { eval 'sub SYS_sched_rr_get_interval () { &__NR_sched_rr_get_interval;}' unless defined(&SYS_sched_rr_get_interval); } if(defined(&__NR_sched_rr_get_interval_time64)) { eval 'sub SYS_sched_rr_get_interval_time64 () { &__NR_sched_rr_get_interval_time64;}' unless defined(&SYS_sched_rr_get_interval_time64); } if(defined(&__NR_sched_set_affinity)) { eval 'sub SYS_sched_set_affinity () { &__NR_sched_set_affinity;}' unless defined(&SYS_sched_set_affinity); } if(defined(&__NR_sched_setaffinity)) { eval 'sub SYS_sched_setaffinity () { &__NR_sched_setaffinity;}' unless defined(&SYS_sched_setaffinity); } if(defined(&__NR_sched_setattr)) { eval 'sub SYS_sched_setattr () { &__NR_sched_setattr;}' unless defined(&SYS_sched_setattr); } if(defined(&__NR_sched_setparam)) { eval 'sub SYS_sched_setparam () { &__NR_sched_setparam;}' unless defined(&SYS_sched_setparam); } if(defined(&__NR_sched_setscheduler)) { eval 'sub SYS_sched_setscheduler () { &__NR_sched_setscheduler;}' unless defined(&SYS_sched_setscheduler); } if(defined(&__NR_sched_yield)) { eval 'sub SYS_sched_yield () { &__NR_sched_yield;}' unless defined(&SYS_sched_yield); } if(defined(&__NR_seccomp)) { eval 'sub SYS_seccomp () { &__NR_seccomp;}' unless defined(&SYS_seccomp); } if(defined(&__NR_security)) { eval 'sub SYS_security () { &__NR_security;}' unless defined(&SYS_security); } if(defined(&__NR_select)) { eval 'sub SYS_select () { &__NR_select;}' unless defined(&SYS_select); } if(defined(&__NR_semctl)) { eval 'sub SYS_semctl () { &__NR_semctl;}' unless defined(&SYS_semctl); } if(defined(&__NR_semget)) { eval 'sub SYS_semget () { &__NR_semget;}' unless defined(&SYS_semget); } if(defined(&__NR_semop)) { eval 'sub SYS_semop () { &__NR_semop;}' unless defined(&SYS_semop); } if(defined(&__NR_semtimedop)) { eval 'sub SYS_semtimedop () { &__NR_semtimedop;}' unless defined(&SYS_semtimedop); } if(defined(&__NR_semtimedop_time64)) { eval 'sub SYS_semtimedop_time64 () { &__NR_semtimedop_time64;}' unless defined(&SYS_semtimedop_time64); } if(defined(&__NR_send)) { eval 'sub SYS_send () { &__NR_send;}' unless defined(&SYS_send); } if(defined(&__NR_sendfile)) { eval 'sub SYS_sendfile () { &__NR_sendfile;}' unless defined(&SYS_sendfile); } if(defined(&__NR_sendfile64)) { eval 'sub SYS_sendfile64 () { &__NR_sendfile64;}' unless defined(&SYS_sendfile64); } if(defined(&__NR_sendmmsg)) { eval 'sub SYS_sendmmsg () { &__NR_sendmmsg;}' unless defined(&SYS_sendmmsg); } if(defined(&__NR_sendmsg)) { eval 'sub SYS_sendmsg () { &__NR_sendmsg;}' unless defined(&SYS_sendmsg); } if(defined(&__NR_sendto)) { eval 'sub SYS_sendto () { &__NR_sendto;}' unless defined(&SYS_sendto); } if(defined(&__NR_set_mempolicy)) { eval 'sub SYS_set_mempolicy () { &__NR_set_mempolicy;}' unless defined(&SYS_set_mempolicy); } if(defined(&__NR_set_mempolicy_home_node)) { eval 'sub SYS_set_mempolicy_home_node () { &__NR_set_mempolicy_home_node;}' unless defined(&SYS_set_mempolicy_home_node); } if(defined(&__NR_set_robust_list)) { eval 'sub SYS_set_robust_list () { &__NR_set_robust_list;}' unless defined(&SYS_set_robust_list); } if(defined(&__NR_set_thread_area)) { eval 'sub SYS_set_thread_area () { &__NR_set_thread_area;}' unless defined(&SYS_set_thread_area); } if(defined(&__NR_set_tid_address)) { eval 'sub SYS_set_tid_address () { &__NR_set_tid_address;}' unless defined(&SYS_set_tid_address); } if(defined(&__NR_set_tls)) { eval 'sub SYS_set_tls () { &__NR_set_tls;}' unless defined(&SYS_set_tls); } if(defined(&__NR_setdomainname)) { eval 'sub SYS_setdomainname () { &__NR_setdomainname;}' unless defined(&SYS_setdomainname); } if(defined(&__NR_setfsgid)) { eval 'sub SYS_setfsgid () { &__NR_setfsgid;}' unless defined(&SYS_setfsgid); } if(defined(&__NR_setfsgid32)) { eval 'sub SYS_setfsgid32 () { &__NR_setfsgid32;}' unless defined(&SYS_setfsgid32); } if(defined(&__NR_setfsuid)) { eval 'sub SYS_setfsuid () { &__NR_setfsuid;}' unless defined(&SYS_setfsuid); } if(defined(&__NR_setfsuid32)) { eval 'sub SYS_setfsuid32 () { &__NR_setfsuid32;}' unless defined(&SYS_setfsuid32); } if(defined(&__NR_setgid)) { eval 'sub SYS_setgid () { &__NR_setgid;}' unless defined(&SYS_setgid); } if(defined(&__NR_setgid32)) { eval 'sub SYS_setgid32 () { &__NR_setgid32;}' unless defined(&SYS_setgid32); } if(defined(&__NR_setgroups)) { eval 'sub SYS_setgroups () { &__NR_setgroups;}' unless defined(&SYS_setgroups); } if(defined(&__NR_setgroups32)) { eval 'sub SYS_setgroups32 () { &__NR_setgroups32;}' unless defined(&SYS_setgroups32); } if(defined(&__NR_sethae)) { eval 'sub SYS_sethae () { &__NR_sethae;}' unless defined(&SYS_sethae); } if(defined(&__NR_sethostname)) { eval 'sub SYS_sethostname () { &__NR_sethostname;}' unless defined(&SYS_sethostname); } if(defined(&__NR_setitimer)) { eval 'sub SYS_setitimer () { &__NR_setitimer;}' unless defined(&SYS_setitimer); } if(defined(&__NR_setns)) { eval 'sub SYS_setns () { &__NR_setns;}' unless defined(&SYS_setns); } if(defined(&__NR_setpgid)) { eval 'sub SYS_setpgid () { &__NR_setpgid;}' unless defined(&SYS_setpgid); } if(defined(&__NR_setpgrp)) { eval 'sub SYS_setpgrp () { &__NR_setpgrp;}' unless defined(&SYS_setpgrp); } if(defined(&__NR_setpriority)) { eval 'sub SYS_setpriority () { &__NR_setpriority;}' unless defined(&SYS_setpriority); } if(defined(&__NR_setregid)) { eval 'sub SYS_setregid () { &__NR_setregid;}' unless defined(&SYS_setregid); } if(defined(&__NR_setregid32)) { eval 'sub SYS_setregid32 () { &__NR_setregid32;}' unless defined(&SYS_setregid32); } if(defined(&__NR_setresgid)) { eval 'sub SYS_setresgid () { &__NR_setresgid;}' unless defined(&SYS_setresgid); } if(defined(&__NR_setresgid32)) { eval 'sub SYS_setresgid32 () { &__NR_setresgid32;}' unless defined(&SYS_setresgid32); } if(defined(&__NR_setresuid)) { eval 'sub SYS_setresuid () { &__NR_setresuid;}' unless defined(&SYS_setresuid); } if(defined(&__NR_setresuid32)) { eval 'sub SYS_setresuid32 () { &__NR_setresuid32;}' unless defined(&SYS_setresuid32); } if(defined(&__NR_setreuid)) { eval 'sub SYS_setreuid () { &__NR_setreuid;}' unless defined(&SYS_setreuid); } if(defined(&__NR_setreuid32)) { eval 'sub SYS_setreuid32 () { &__NR_setreuid32;}' unless defined(&SYS_setreuid32); } if(defined(&__NR_setrlimit)) { eval 'sub SYS_setrlimit () { &__NR_setrlimit;}' unless defined(&SYS_setrlimit); } if(defined(&__NR_setsid)) { eval 'sub SYS_setsid () { &__NR_setsid;}' unless defined(&SYS_setsid); } if(defined(&__NR_setsockopt)) { eval 'sub SYS_setsockopt () { &__NR_setsockopt;}' unless defined(&SYS_setsockopt); } if(defined(&__NR_settimeofday)) { eval 'sub SYS_settimeofday () { &__NR_settimeofday;}' unless defined(&SYS_settimeofday); } if(defined(&__NR_setuid)) { eval 'sub SYS_setuid () { &__NR_setuid;}' unless defined(&SYS_setuid); } if(defined(&__NR_setuid32)) { eval 'sub SYS_setuid32 () { &__NR_setuid32;}' unless defined(&SYS_setuid32); } if(defined(&__NR_setxattr)) { eval 'sub SYS_setxattr () { &__NR_setxattr;}' unless defined(&SYS_setxattr); } if(defined(&__NR_sgetmask)) { eval 'sub SYS_sgetmask () { &__NR_sgetmask;}' unless defined(&SYS_sgetmask); } if(defined(&__NR_shmat)) { eval 'sub SYS_shmat () { &__NR_shmat;}' unless defined(&SYS_shmat); } if(defined(&__NR_shmctl)) { eval 'sub SYS_shmctl () { &__NR_shmctl;}' unless defined(&SYS_shmctl); } if(defined(&__NR_shmdt)) { eval 'sub SYS_shmdt () { &__NR_shmdt;}' unless defined(&SYS_shmdt); } if(defined(&__NR_shmget)) { eval 'sub SYS_shmget () { &__NR_shmget;}' unless defined(&SYS_shmget); } if(defined(&__NR_shutdown)) { eval 'sub SYS_shutdown () { &__NR_shutdown;}' unless defined(&SYS_shutdown); } if(defined(&__NR_sigaction)) { eval 'sub SYS_sigaction () { &__NR_sigaction;}' unless defined(&SYS_sigaction); } if(defined(&__NR_sigaltstack)) { eval 'sub SYS_sigaltstack () { &__NR_sigaltstack;}' unless defined(&SYS_sigaltstack); } if(defined(&__NR_signal)) { eval 'sub SYS_signal () { &__NR_signal;}' unless defined(&SYS_signal); } if(defined(&__NR_signalfd)) { eval 'sub SYS_signalfd () { &__NR_signalfd;}' unless defined(&SYS_signalfd); } if(defined(&__NR_signalfd4)) { eval 'sub SYS_signalfd4 () { &__NR_signalfd4;}' unless defined(&SYS_signalfd4); } if(defined(&__NR_sigpending)) { eval 'sub SYS_sigpending () { &__NR_sigpending;}' unless defined(&SYS_sigpending); } if(defined(&__NR_sigprocmask)) { eval 'sub SYS_sigprocmask () { &__NR_sigprocmask;}' unless defined(&SYS_sigprocmask); } if(defined(&__NR_sigreturn)) { eval 'sub SYS_sigreturn () { &__NR_sigreturn;}' unless defined(&SYS_sigreturn); } if(defined(&__NR_sigsuspend)) { eval 'sub SYS_sigsuspend () { &__NR_sigsuspend;}' unless defined(&SYS_sigsuspend); } if(defined(&__NR_socket)) { eval 'sub SYS_socket () { &__NR_socket;}' unless defined(&SYS_socket); } if(defined(&__NR_socketcall)) { eval 'sub SYS_socketcall () { &__NR_socketcall;}' unless defined(&SYS_socketcall); } if(defined(&__NR_socketpair)) { eval 'sub SYS_socketpair () { &__NR_socketpair;}' unless defined(&SYS_socketpair); } if(defined(&__NR_splice)) { eval 'sub SYS_splice () { &__NR_splice;}' unless defined(&SYS_splice); } if(defined(&__NR_spu_create)) { eval 'sub SYS_spu_create () { &__NR_spu_create;}' unless defined(&SYS_spu_create); } if(defined(&__NR_spu_run)) { eval 'sub SYS_spu_run () { &__NR_spu_run;}' unless defined(&SYS_spu_run); } if(defined(&__NR_ssetmask)) { eval 'sub SYS_ssetmask () { &__NR_ssetmask;}' unless defined(&SYS_ssetmask); } if(defined(&__NR_stat)) { eval 'sub SYS_stat () { &__NR_stat;}' unless defined(&SYS_stat); } if(defined(&__NR_stat64)) { eval 'sub SYS_stat64 () { &__NR_stat64;}' unless defined(&SYS_stat64); } if(defined(&__NR_statfs)) { eval 'sub SYS_statfs () { &__NR_statfs;}' unless defined(&SYS_statfs); } if(defined(&__NR_statfs64)) { eval 'sub SYS_statfs64 () { &__NR_statfs64;}' unless defined(&SYS_statfs64); } if(defined(&__NR_statmount)) { eval 'sub SYS_statmount () { &__NR_statmount;}' unless defined(&SYS_statmount); } if(defined(&__NR_statx)) { eval 'sub SYS_statx () { &__NR_statx;}' unless defined(&SYS_statx); } if(defined(&__NR_stime)) { eval 'sub SYS_stime () { &__NR_stime;}' unless defined(&SYS_stime); } if(defined(&__NR_stty)) { eval 'sub SYS_stty () { &__NR_stty;}' unless defined(&SYS_stty); } if(defined(&__NR_subpage_prot)) { eval 'sub SYS_subpage_prot () { &__NR_subpage_prot;}' unless defined(&SYS_subpage_prot); } if(defined(&__NR_swapcontext)) { eval 'sub SYS_swapcontext () { &__NR_swapcontext;}' unless defined(&SYS_swapcontext); } if(defined(&__NR_swapoff)) { eval 'sub SYS_swapoff () { &__NR_swapoff;}' unless defined(&SYS_swapoff); } if(defined(&__NR_swapon)) { eval 'sub SYS_swapon () { &__NR_swapon;}' unless defined(&SYS_swapon); } if(defined(&__NR_switch_endian)) { eval 'sub SYS_switch_endian () { &__NR_switch_endian;}' unless defined(&SYS_switch_endian); } if(defined(&__NR_symlink)) { eval 'sub SYS_symlink () { &__NR_symlink;}' unless defined(&SYS_symlink); } if(defined(&__NR_symlinkat)) { eval 'sub SYS_symlinkat () { &__NR_symlinkat;}' unless defined(&SYS_symlinkat); } if(defined(&__NR_sync)) { eval 'sub SYS_sync () { &__NR_sync;}' unless defined(&SYS_sync); } if(defined(&__NR_sync_file_range)) { eval 'sub SYS_sync_file_range () { &__NR_sync_file_range;}' unless defined(&SYS_sync_file_range); } if(defined(&__NR_sync_file_range2)) { eval 'sub SYS_sync_file_range2 () { &__NR_sync_file_range2;}' unless defined(&SYS_sync_file_range2); } if(defined(&__NR_syncfs)) { eval 'sub SYS_syncfs () { &__NR_syncfs;}' unless defined(&SYS_syncfs); } if(defined(&__NR_sys_debug_setcontext)) { eval 'sub SYS_sys_debug_setcontext () { &__NR_sys_debug_setcontext;}' unless defined(&SYS_sys_debug_setcontext); } if(defined(&__NR_sys_epoll_create)) { eval 'sub SYS_sys_epoll_create () { &__NR_sys_epoll_create;}' unless defined(&SYS_sys_epoll_create); } if(defined(&__NR_sys_epoll_ctl)) { eval 'sub SYS_sys_epoll_ctl () { &__NR_sys_epoll_ctl;}' unless defined(&SYS_sys_epoll_ctl); } if(defined(&__NR_sys_epoll_wait)) { eval 'sub SYS_sys_epoll_wait () { &__NR_sys_epoll_wait;}' unless defined(&SYS_sys_epoll_wait); } if(defined(&__NR_syscall)) { eval 'sub SYS_syscall () { &__NR_syscall;}' unless defined(&SYS_syscall); } if(defined(&__NR_sysfs)) { eval 'sub SYS_sysfs () { &__NR_sysfs;}' unless defined(&SYS_sysfs); } if(defined(&__NR_sysinfo)) { eval 'sub SYS_sysinfo () { &__NR_sysinfo;}' unless defined(&SYS_sysinfo); } if(defined(&__NR_syslog)) { eval 'sub SYS_syslog () { &__NR_syslog;}' unless defined(&SYS_syslog); } if(defined(&__NR_sysmips)) { eval 'sub SYS_sysmips () { &__NR_sysmips;}' unless defined(&SYS_sysmips); } if(defined(&__NR_tee)) { eval 'sub SYS_tee () { &__NR_tee;}' unless defined(&SYS_tee); } if(defined(&__NR_tgkill)) { eval 'sub SYS_tgkill () { &__NR_tgkill;}' unless defined(&SYS_tgkill); } if(defined(&__NR_time)) { eval 'sub SYS_time () { &__NR_time;}' unless defined(&SYS_time); } if(defined(&__NR_timer_create)) { eval 'sub SYS_timer_create () { &__NR_timer_create;}' unless defined(&SYS_timer_create); } if(defined(&__NR_timer_delete)) { eval 'sub SYS_timer_delete () { &__NR_timer_delete;}' unless defined(&SYS_timer_delete); } if(defined(&__NR_timer_getoverrun)) { eval 'sub SYS_timer_getoverrun () { &__NR_timer_getoverrun;}' unless defined(&SYS_timer_getoverrun); } if(defined(&__NR_timer_gettime)) { eval 'sub SYS_timer_gettime () { &__NR_timer_gettime;}' unless defined(&SYS_timer_gettime); } if(defined(&__NR_timer_gettime64)) { eval 'sub SYS_timer_gettime64 () { &__NR_timer_gettime64;}' unless defined(&SYS_timer_gettime64); } if(defined(&__NR_timer_settime)) { eval 'sub SYS_timer_settime () { &__NR_timer_settime;}' unless defined(&SYS_timer_settime); } if(defined(&__NR_timer_settime64)) { eval 'sub SYS_timer_settime64 () { &__NR_timer_settime64;}' unless defined(&SYS_timer_settime64); } if(defined(&__NR_timerfd)) { eval 'sub SYS_timerfd () { &__NR_timerfd;}' unless defined(&SYS_timerfd); } if(defined(&__NR_timerfd_create)) { eval 'sub SYS_timerfd_create () { &__NR_timerfd_create;}' unless defined(&SYS_timerfd_create); } if(defined(&__NR_timerfd_gettime)) { eval 'sub SYS_timerfd_gettime () { &__NR_timerfd_gettime;}' unless defined(&SYS_timerfd_gettime); } if(defined(&__NR_timerfd_gettime64)) { eval 'sub SYS_timerfd_gettime64 () { &__NR_timerfd_gettime64;}' unless defined(&SYS_timerfd_gettime64); } if(defined(&__NR_timerfd_settime)) { eval 'sub SYS_timerfd_settime () { &__NR_timerfd_settime;}' unless defined(&SYS_timerfd_settime); } if(defined(&__NR_timerfd_settime64)) { eval 'sub SYS_timerfd_settime64 () { &__NR_timerfd_settime64;}' unless defined(&SYS_timerfd_settime64); } if(defined(&__NR_times)) { eval 'sub SYS_times () { &__NR_times;}' unless defined(&SYS_times); } if(defined(&__NR_tkill)) { eval 'sub SYS_tkill () { &__NR_tkill;}' unless defined(&SYS_tkill); } if(defined(&__NR_truncate)) { eval 'sub SYS_truncate () { &__NR_truncate;}' unless defined(&SYS_truncate); } if(defined(&__NR_truncate64)) { eval 'sub SYS_truncate64 () { &__NR_truncate64;}' unless defined(&SYS_truncate64); } if(defined(&__NR_tuxcall)) { eval 'sub SYS_tuxcall () { &__NR_tuxcall;}' unless defined(&SYS_tuxcall); } if(defined(&__NR_udftrap)) { eval 'sub SYS_udftrap () { &__NR_udftrap;}' unless defined(&SYS_udftrap); } if(defined(&__NR_ugetrlimit)) { eval 'sub SYS_ugetrlimit () { &__NR_ugetrlimit;}' unless defined(&SYS_ugetrlimit); } if(defined(&__NR_ulimit)) { eval 'sub SYS_ulimit () { &__NR_ulimit;}' unless defined(&SYS_ulimit); } if(defined(&__NR_umask)) { eval 'sub SYS_umask () { &__NR_umask;}' unless defined(&SYS_umask); } if(defined(&__NR_umount)) { eval 'sub SYS_umount () { &__NR_umount;}' unless defined(&SYS_umount); } if(defined(&__NR_umount2)) { eval 'sub SYS_umount2 () { &__NR_umount2;}' unless defined(&SYS_umount2); } if(defined(&__NR_uname)) { eval 'sub SYS_uname () { &__NR_uname;}' unless defined(&SYS_uname); } if(defined(&__NR_unlink)) { eval 'sub SYS_unlink () { &__NR_unlink;}' unless defined(&SYS_unlink); } if(defined(&__NR_unlinkat)) { eval 'sub SYS_unlinkat () { &__NR_unlinkat;}' unless defined(&SYS_unlinkat); } if(defined(&__NR_unshare)) { eval 'sub SYS_unshare () { &__NR_unshare;}' unless defined(&SYS_unshare); } if(defined(&__NR_uselib)) { eval 'sub SYS_uselib () { &__NR_uselib;}' unless defined(&SYS_uselib); } if(defined(&__NR_userfaultfd)) { eval 'sub SYS_userfaultfd () { &__NR_userfaultfd;}' unless defined(&SYS_userfaultfd); } if(defined(&__NR_usr26)) { eval 'sub SYS_usr26 () { &__NR_usr26;}' unless defined(&SYS_usr26); } if(defined(&__NR_usr32)) { eval 'sub SYS_usr32 () { &__NR_usr32;}' unless defined(&SYS_usr32); } if(defined(&__NR_ustat)) { eval 'sub SYS_ustat () { &__NR_ustat;}' unless defined(&SYS_ustat); } if(defined(&__NR_utime)) { eval 'sub SYS_utime () { &__NR_utime;}' unless defined(&SYS_utime); } if(defined(&__NR_utimensat)) { eval 'sub SYS_utimensat () { &__NR_utimensat;}' unless defined(&SYS_utimensat); } if(defined(&__NR_utimensat_time64)) { eval 'sub SYS_utimensat_time64 () { &__NR_utimensat_time64;}' unless defined(&SYS_utimensat_time64); } if(defined(&__NR_utimes)) { eval 'sub SYS_utimes () { &__NR_utimes;}' unless defined(&SYS_utimes); } if(defined(&__NR_utrap_install)) { eval 'sub SYS_utrap_install () { &__NR_utrap_install;}' unless defined(&SYS_utrap_install); } if(defined(&__NR_vfork)) { eval 'sub SYS_vfork () { &__NR_vfork;}' unless defined(&SYS_vfork); } if(defined(&__NR_vhangup)) { eval 'sub SYS_vhangup () { &__NR_vhangup;}' unless defined(&SYS_vhangup); } if(defined(&__NR_vm86)) { eval 'sub SYS_vm86 () { &__NR_vm86;}' unless defined(&SYS_vm86); } if(defined(&__NR_vm86old)) { eval 'sub SYS_vm86old () { &__NR_vm86old;}' unless defined(&SYS_vm86old); } if(defined(&__NR_vmsplice)) { eval 'sub SYS_vmsplice () { &__NR_vmsplice;}' unless defined(&SYS_vmsplice); } if(defined(&__NR_vserver)) { eval 'sub SYS_vserver () { &__NR_vserver;}' unless defined(&SYS_vserver); } if(defined(&__NR_wait4)) { eval 'sub SYS_wait4 () { &__NR_wait4;}' unless defined(&SYS_wait4); } if(defined(&__NR_waitid)) { eval 'sub SYS_waitid () { &__NR_waitid;}' unless defined(&SYS_waitid); } if(defined(&__NR_waitpid)) { eval 'sub SYS_waitpid () { &__NR_waitpid;}' unless defined(&SYS_waitpid); } if(defined(&__NR_write)) { eval 'sub SYS_write () { &__NR_write;}' unless defined(&SYS_write); } if(defined(&__NR_writev)) { eval 'sub SYS_writev () { &__NR_writev;}' unless defined(&SYS_writev); } 1; wordsize.ph 0000644 00000001347 15125155350 0006752 0 ustar 00 require '_h2ph_pre.ph'; no warnings qw(redefine misc); if(defined (&__x86_64__) && !defined (&__ILP32__)) { eval 'sub __WORDSIZE () {64;}' unless defined(&__WORDSIZE); } else { eval 'sub __WORDSIZE () {32;}' unless defined(&__WORDSIZE); eval 'sub __WORDSIZE32_SIZE_ULONG () {0;}' unless defined(&__WORDSIZE32_SIZE_ULONG); eval 'sub __WORDSIZE32_PTRDIFF_LONG () {0;}' unless defined(&__WORDSIZE32_PTRDIFF_LONG); } if(defined(&__x86_64__)) { eval 'sub __WORDSIZE_TIME64_COMPAT32 () {1;}' unless defined(&__WORDSIZE_TIME64_COMPAT32); eval 'sub __SYSCALL_WORDSIZE () {64;}' unless defined(&__SYSCALL_WORDSIZE); } else { eval 'sub __WORDSIZE_TIME64_COMPAT32 () {0;}' unless defined(&__WORDSIZE_TIME64_COMPAT32); } 1; long-double.ph 0000644 00000000251 15125155350 0007304 0 ustar 00 require '_h2ph_pre.ph'; no warnings qw(redefine misc); eval 'sub __LDOUBLE_REDIRECTS_TO_FLOAT128_ABI () {0;}' unless defined(&__LDOUBLE_REDIRECTS_TO_FLOAT128_ABI); 1; sem.h 0000644 00000004323 15125171642 0005507 0 ustar 00 /* Copyright (C) 1995-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _SYS_SEM_H # error "Never include <bits/sem.h> directly; use <sys/sem.h> instead." #endif #include <sys/types.h> #include <bits/timesize.h> #include <bits/types/struct_semid_ds.h> #include <bits/types/struct_semid64_ds.h> /* Flags for `semop'. */ #define SEM_UNDO 0x1000 /* undo the operation on exit */ /* Commands for `semctl'. */ #define GETPID 11 /* get sempid */ #define GETVAL 12 /* get semval */ #define GETALL 13 /* get all semval's */ #define GETNCNT 14 /* get semncnt */ #define GETZCNT 15 /* get semzcnt */ #define SETVAL 16 /* set semval */ #define SETALL 17 /* set all semval's */ /* The user should define a union like the following to use it for arguments for `semctl'. union semun { int val; <= value for SETVAL struct semid_ds *buf; <= buffer for IPC_STAT & IPC_SET unsigned short int *array; <= array for GETALL & SETALL struct seminfo *__buf; <= buffer for IPC_INFO }; Previous versions of this file used to define this union but this is incorrect. One can test the macro _SEM_SEMUN_UNDEFINED to see whether one must define the union or not. */ #define _SEM_SEMUN_UNDEFINED 1 #ifdef __USE_MISC /* ipcs ctl cmds */ # define SEM_STAT 18 # define SEM_INFO 19 # define SEM_STAT_ANY 20 struct seminfo { int semmap; int semmni; int semmns; int semmnu; int semmsl; int semopm; int semume; int semusz; int semvmx; int semaem; }; #endif /* __USE_MISC */ atomic_wide_counter.h 0000644 00000002403 15125171642 0010743 0 ustar 00 /* Monotonically increasing wide counters (at least 62 bits). Copyright (C) 2016-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _BITS_ATOMIC_WIDE_COUNTER_H #define _BITS_ATOMIC_WIDE_COUNTER_H /* Counter that is monotonically increasing (by less than 2**31 per increment), with a single writer, and an arbitrary number of readers. */ typedef union { __extension__ unsigned long long int __value64; struct { unsigned int __low; unsigned int __high; } __value32; } __atomic_wide_counter; #endif /* _BITS_ATOMIC_WIDE_COUNTER_H */ syslog-path.h 0000644 00000002045 15125171642 0007174 0 ustar 00 /* <bits/syslog-path.h> -- _PATH_LOG definition Copyright (C) 2006-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _SYS_SYSLOG_H # error "Never include this file directly. Use <sys/syslog.h> instead" #endif #ifndef _BITS_SYSLOG_PATH_H #define _BITS_SYSLOG_PATH_H 1 #define _PATH_LOG "/dev/log" #endif /* bits/syslog-path.h */ sigevent-consts.h 0000644 00000002677 15125171642 0010070 0 ustar 00 /* sigevent constants. Linux version. Copyright (C) 1997-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _BITS_SIGEVENT_CONSTS_H #define _BITS_SIGEVENT_CONSTS_H 1 #if !defined _SIGNAL_H && !defined _AIO_H #error "Don't include <bits/sigevent-consts.h> directly; use <signal.h> instead." #endif /* `sigev_notify' values. */ enum { SIGEV_SIGNAL = 0, /* Notify via signal. */ # define SIGEV_SIGNAL SIGEV_SIGNAL SIGEV_NONE, /* Other notification: meaningless. */ # define SIGEV_NONE SIGEV_NONE SIGEV_THREAD, /* Deliver via thread creation. */ # define SIGEV_THREAD SIGEV_THREAD SIGEV_THREAD_ID = 4 /* Send signal to specific thread. This is a Linux extension. */ #define SIGEV_THREAD_ID SIGEV_THREAD_ID }; #endif floatn-common.h 0000644 00000024125 15125171642 0007476 0 ustar 00 /* Macros to control TS 18661-3 glibc features where the same definitions are appropriate for all platforms. Copyright (C) 2017-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _BITS_FLOATN_COMMON_H #define _BITS_FLOATN_COMMON_H #include <features.h> #include <bits/long-double.h> /* This header should be included at the bottom of each bits/floatn.h. It defines the following macros for each _FloatN and _FloatNx type, where the same definitions, or definitions based only on the macros in bits/floatn.h, are appropriate for all glibc configurations. */ /* Defined to 1 if the current compiler invocation provides a floating-point type with the right format for this type, and this glibc includes corresponding *fN or *fNx interfaces for it. */ #define __HAVE_FLOAT16 0 #define __HAVE_FLOAT32 1 #define __HAVE_FLOAT64 1 #define __HAVE_FLOAT32X 1 #define __HAVE_FLOAT128X 0 /* Defined to 1 if the corresponding __HAVE_<type> macro is 1 and the type is the first with its format in the sequence of (the default choices for) float, double, long double, _Float16, _Float32, _Float64, _Float128, _Float32x, _Float64x, _Float128x for this glibc; that is, if functions present once per floating-point format rather than once per type are present for this type. All configurations supported by glibc have _Float32 the same format as float, _Float64 and _Float32x the same format as double, the _Float64x the same format as either long double or _Float128. No configurations support _Float128x or, as of GCC 7, have compiler support for a type meeting the requirements for _Float128x. */ #define __HAVE_DISTINCT_FLOAT16 __HAVE_FLOAT16 #define __HAVE_DISTINCT_FLOAT32 0 #define __HAVE_DISTINCT_FLOAT64 0 #define __HAVE_DISTINCT_FLOAT32X 0 #define __HAVE_DISTINCT_FLOAT64X 0 #define __HAVE_DISTINCT_FLOAT128X __HAVE_FLOAT128X /* Defined to 1 if the corresponding _FloatN type is not binary compatible with the corresponding ISO C type in the current compilation unit as opposed to __HAVE_DISTINCT_FLOATN, which indicates the default types built in glibc. */ #define __HAVE_FLOAT128_UNLIKE_LDBL (__HAVE_DISTINCT_FLOAT128 \ && __LDBL_MANT_DIG__ != 113) /* Defined to 1 if any _FloatN or _FloatNx types that are not ABI-distinct are however distinct types at the C language level (so for the purposes of __builtin_types_compatible_p and _Generic). */ #if __GNUC_PREREQ (7, 0) && !defined __cplusplus # define __HAVE_FLOATN_NOT_TYPEDEF 1 #else # define __HAVE_FLOATN_NOT_TYPEDEF 0 #endif #ifndef __ASSEMBLER__ /* Defined to concatenate the literal suffix to be used with _FloatN or _FloatNx types, if __HAVE_<type> is 1. The corresponding literal suffixes exist since GCC 7, for C only. */ # if __HAVE_FLOAT16 # if !__GNUC_PREREQ (7, 0) || (defined __cplusplus && !__GNUC_PREREQ (13, 0)) /* No corresponding suffix available for this type. */ # define __f16(x) ((_Float16) x##f) # else # define __f16(x) x##f16 # endif # endif # if __HAVE_FLOAT32 # if !__GNUC_PREREQ (7, 0) || (defined __cplusplus && !__GNUC_PREREQ (13, 0)) # define __f32(x) x##f # else # define __f32(x) x##f32 # endif # endif # if __HAVE_FLOAT64 # if !__GNUC_PREREQ (7, 0) || (defined __cplusplus && !__GNUC_PREREQ (13, 0)) # ifdef __NO_LONG_DOUBLE_MATH # define __f64(x) x##l # else # define __f64(x) x # endif # else # define __f64(x) x##f64 # endif # endif # if __HAVE_FLOAT32X # if !__GNUC_PREREQ (7, 0) || (defined __cplusplus && !__GNUC_PREREQ (13, 0)) # define __f32x(x) x # else # define __f32x(x) x##f32x # endif # endif # if __HAVE_FLOAT64X # if !__GNUC_PREREQ (7, 0) || (defined __cplusplus && !__GNUC_PREREQ (13, 0)) # if __HAVE_FLOAT64X_LONG_DOUBLE # define __f64x(x) x##l # else # define __f64x(x) __f128 (x) # endif # else # define __f64x(x) x##f64x # endif # endif # if __HAVE_FLOAT128X # if !__GNUC_PREREQ (7, 0) || (defined __cplusplus && !__GNUC_PREREQ (13, 0)) # error "_Float128X supported but no constant suffix" # else # define __f128x(x) x##f128x # endif # endif /* Defined to a complex type if __HAVE_<type> is 1. */ # if __HAVE_FLOAT16 # if !__GNUC_PREREQ (7, 0) || (defined __cplusplus && !__GNUC_PREREQ (13, 0)) typedef _Complex float __cfloat16 __attribute__ ((__mode__ (__HC__))); # define __CFLOAT16 __cfloat16 # else # define __CFLOAT16 _Complex _Float16 # endif # endif # if __HAVE_FLOAT32 # if !__GNUC_PREREQ (7, 0) || (defined __cplusplus && !__GNUC_PREREQ (13, 0)) # define __CFLOAT32 _Complex float # else # define __CFLOAT32 _Complex _Float32 # endif # endif # if __HAVE_FLOAT64 # if !__GNUC_PREREQ (7, 0) || (defined __cplusplus && !__GNUC_PREREQ (13, 0)) # ifdef __NO_LONG_DOUBLE_MATH # define __CFLOAT64 _Complex long double # else # define __CFLOAT64 _Complex double # endif # else # define __CFLOAT64 _Complex _Float64 # endif # endif # if __HAVE_FLOAT32X # if !__GNUC_PREREQ (7, 0) || (defined __cplusplus && !__GNUC_PREREQ (13, 0)) # define __CFLOAT32X _Complex double # else # define __CFLOAT32X _Complex _Float32x # endif # endif # if __HAVE_FLOAT64X # if !__GNUC_PREREQ (7, 0) || (defined __cplusplus && !__GNUC_PREREQ (13, 0)) # if __HAVE_FLOAT64X_LONG_DOUBLE # define __CFLOAT64X _Complex long double # else # define __CFLOAT64X __CFLOAT128 # endif # else # define __CFLOAT64X _Complex _Float64x # endif # endif # if __HAVE_FLOAT128X # if !__GNUC_PREREQ (7, 0) || (defined __cplusplus && !__GNUC_PREREQ (13, 0)) # error "_Float128X supported but no complex type" # else # define __CFLOAT128X _Complex _Float128x # endif # endif /* The remaining of this file provides support for older compilers. */ # if __HAVE_FLOAT16 # if !__GNUC_PREREQ (7, 0) || (defined __cplusplus && !__GNUC_PREREQ (13, 0)) typedef float _Float16 __attribute__ ((__mode__ (__HF__))); # endif # if !__GNUC_PREREQ (7, 0) # define __builtin_huge_valf16() ((_Float16) __builtin_huge_val ()) # define __builtin_inff16() ((_Float16) __builtin_inf ()) # define __builtin_nanf16(x) ((_Float16) __builtin_nan (x)) # define __builtin_nansf16(x) ((_Float16) __builtin_nans (x)) # endif # endif # if __HAVE_FLOAT32 # if !__GNUC_PREREQ (7, 0) || (defined __cplusplus && !__GNUC_PREREQ (13, 0)) typedef float _Float32; # endif # if !__GNUC_PREREQ (7, 0) # define __builtin_huge_valf32() (__builtin_huge_valf ()) # define __builtin_inff32() (__builtin_inff ()) # define __builtin_nanf32(x) (__builtin_nanf (x)) # define __builtin_nansf32(x) (__builtin_nansf (x)) # endif # endif # if __HAVE_FLOAT64 /* If double, long double and _Float64 all have the same set of values, TS 18661-3 requires the usual arithmetic conversions on long double and _Float64 to produce _Float64. For this to be the case when building with a compiler without a distinct _Float64 type, _Float64 must be a typedef for long double, not for double. */ # ifdef __NO_LONG_DOUBLE_MATH # if !__GNUC_PREREQ (7, 0) || (defined __cplusplus && !__GNUC_PREREQ (13, 0)) typedef long double _Float64; # endif # if !__GNUC_PREREQ (7, 0) # define __builtin_huge_valf64() (__builtin_huge_vall ()) # define __builtin_inff64() (__builtin_infl ()) # define __builtin_nanf64(x) (__builtin_nanl (x)) # define __builtin_nansf64(x) (__builtin_nansl (x)) # endif # else # if !__GNUC_PREREQ (7, 0) || (defined __cplusplus && !__GNUC_PREREQ (13, 0)) typedef double _Float64; # endif # if !__GNUC_PREREQ (7, 0) # define __builtin_huge_valf64() (__builtin_huge_val ()) # define __builtin_inff64() (__builtin_inf ()) # define __builtin_nanf64(x) (__builtin_nan (x)) # define __builtin_nansf64(x) (__builtin_nans (x)) # endif # endif # endif # if __HAVE_FLOAT32X # if !__GNUC_PREREQ (7, 0) || (defined __cplusplus && !__GNUC_PREREQ (13, 0)) typedef double _Float32x; # endif # if !__GNUC_PREREQ (7, 0) # define __builtin_huge_valf32x() (__builtin_huge_val ()) # define __builtin_inff32x() (__builtin_inf ()) # define __builtin_nanf32x(x) (__builtin_nan (x)) # define __builtin_nansf32x(x) (__builtin_nans (x)) # endif # endif # if __HAVE_FLOAT64X # if __HAVE_FLOAT64X_LONG_DOUBLE # if !__GNUC_PREREQ (7, 0) || (defined __cplusplus && !__GNUC_PREREQ (13, 0)) typedef long double _Float64x; # endif # if !__GNUC_PREREQ (7, 0) # define __builtin_huge_valf64x() (__builtin_huge_vall ()) # define __builtin_inff64x() (__builtin_infl ()) # define __builtin_nanf64x(x) (__builtin_nanl (x)) # define __builtin_nansf64x(x) (__builtin_nansl (x)) # endif # else # if !__GNUC_PREREQ (7, 0) || (defined __cplusplus && !__GNUC_PREREQ (13, 0)) typedef _Float128 _Float64x; # endif # if !__GNUC_PREREQ (7, 0) # define __builtin_huge_valf64x() (__builtin_huge_valf128 ()) # define __builtin_inff64x() (__builtin_inff128 ()) # define __builtin_nanf64x(x) (__builtin_nanf128 (x)) # define __builtin_nansf64x(x) (__builtin_nansf128 (x)) # endif # endif # endif # if __HAVE_FLOAT128X # if !__GNUC_PREREQ (7, 0) || (defined __cplusplus && !__GNUC_PREREQ (13, 0)) # error "_Float128x supported but no type" # endif # if !__GNUC_PREREQ (7, 0) # define __builtin_huge_valf128x() ((_Float128x) __builtin_huge_val ()) # define __builtin_inff128x() ((_Float128x) __builtin_inf ()) # define __builtin_nanf128x(x) ((_Float128x) __builtin_nan (x)) # define __builtin_nansf128x(x) ((_Float128x) __builtin_nans (x)) # endif # endif #endif /* !__ASSEMBLER__. */ #endif /* _BITS_FLOATN_COMMON_H */ a.out.h 0000644 00000000414 15125171642 0005746 0 ustar 00 #ifndef __A_OUT_GNU_H__ # error "Never use <bits/a.out.h> directly; include <a.out.h> instead." #endif #ifdef __x86_64__ /* Signal to users of this header that this architecture really doesn't support a.out binary format. */ #define __NO_A_OUT_SUPPORT 1 #endif stab.def 0000644 00000021520 15125171642 0006161 0 ustar 00 /* Table of DBX symbol codes for the GNU system. Copyright (C) 1988, 1997-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ /* This contains contribution from Cygnus Support. */ /* Global variable. Only the name is significant. To find the address, look in the corresponding external symbol. */ __define_stab (N_GSYM, 0x20, "GSYM") /* Function name for BSD Fortran. Only the name is significant. To find the address, look in the corresponding external symbol. */ __define_stab (N_FNAME, 0x22, "FNAME") /* Function name or text-segment variable for C. Value is its address. Desc is supposedly starting line number, but GCC doesn't set it and DBX seems not to miss it. */ __define_stab (N_FUN, 0x24, "FUN") /* Data-segment variable with internal linkage. Value is its address. "Static Sym". */ __define_stab (N_STSYM, 0x26, "STSYM") /* BSS-segment variable with internal linkage. Value is its address. */ __define_stab (N_LCSYM, 0x28, "LCSYM") /* Name of main routine. Only the name is significant. This is not used in C. */ __define_stab (N_MAIN, 0x2a, "MAIN") /* Global symbol in Pascal. Supposedly the value is its line number; I'm skeptical. */ __define_stab (N_PC, 0x30, "PC") /* Number of symbols: 0, files,,funcs,lines according to Ultrix V4.0. */ __define_stab (N_NSYMS, 0x32, "NSYMS") /* "No DST map for sym: name, ,0,type,ignored" according to Ultrix V4.0. */ __define_stab (N_NOMAP, 0x34, "NOMAP") /* New stab from Solaris. I don't know what it means, but it don't seem to contain useful information. */ __define_stab (N_OBJ, 0x38, "OBJ") /* New stab from Solaris. I don't know what it means, but it don't seem to contain useful information. Possibly related to the optimization flags used in this module. */ __define_stab (N_OPT, 0x3c, "OPT") /* Register variable. Value is number of register. */ __define_stab (N_RSYM, 0x40, "RSYM") /* Modula-2 compilation unit. Can someone say what info it contains? */ __define_stab (N_M2C, 0x42, "M2C") /* Line number in text segment. Desc is the line number; value is corresponding address. */ __define_stab (N_SLINE, 0x44, "SLINE") /* Similar, for data segment. */ __define_stab (N_DSLINE, 0x46, "DSLINE") /* Similar, for bss segment. */ __define_stab (N_BSLINE, 0x48, "BSLINE") /* Sun's source-code browser stabs. ?? Don't know what the fields are. Supposedly the field is "path to associated .cb file". THIS VALUE OVERLAPS WITH N_BSLINE! */ __define_stab (N_BROWS, 0x48, "BROWS") /* GNU Modula-2 definition module dependency. Value is the modification time of the definition file. Other is non-zero if it is imported with the GNU M2 keyword %INITIALIZE. Perhaps N_M2C can be used if there are enough empty fields? */ __define_stab(N_DEFD, 0x4a, "DEFD") /* THE FOLLOWING TWO STAB VALUES CONFLICT. Happily, one is for Modula-2 and one is for C++. Still,... */ /* GNU C++ exception variable. Name is variable name. */ __define_stab (N_EHDECL, 0x50, "EHDECL") /* Modula2 info "for imc": name,,0,0,0 according to Ultrix V4.0. */ __define_stab (N_MOD2, 0x50, "MOD2") /* GNU C++ `catch' clause. Value is its address. Desc is nonzero if this entry is immediately followed by a CAUGHT stab saying what exception was caught. Multiple CAUGHT stabs means that multiple exceptions can be caught here. If Desc is 0, it means all exceptions are caught here. */ __define_stab (N_CATCH, 0x54, "CATCH") /* Structure or union element. Value is offset in the structure. */ __define_stab (N_SSYM, 0x60, "SSYM") /* Name of main source file. Value is starting text address of the compilation. */ __define_stab (N_SO, 0x64, "SO") /* Automatic variable in the stack. Value is offset from frame pointer. Also used for type descriptions. */ __define_stab (N_LSYM, 0x80, "LSYM") /* Beginning of an include file. Only Sun uses this. In an object file, only the name is significant. The Sun linker puts data into some of the other fields. */ __define_stab (N_BINCL, 0x82, "BINCL") /* Name of sub-source file (#include file). Value is starting text address of the compilation. */ __define_stab (N_SOL, 0x84, "SOL") /* Parameter variable. Value is offset from argument pointer. (On most machines the argument pointer is the same as the frame pointer. */ __define_stab (N_PSYM, 0xa0, "PSYM") /* End of an include file. No name. This and N_BINCL act as brackets around the file's output. In an object file, there is no significant data in this entry. The Sun linker puts data into some of the fields. */ __define_stab (N_EINCL, 0xa2, "EINCL") /* Alternate entry point. Value is its address. */ __define_stab (N_ENTRY, 0xa4, "ENTRY") /* Beginning of lexical block. The desc is the nesting level in lexical blocks. The value is the address of the start of the text for the block. The variables declared inside the block *precede* the N_LBRAC symbol. */ __define_stab (N_LBRAC, 0xc0, "LBRAC") /* Place holder for deleted include file. Replaces a N_BINCL and everything up to the corresponding N_EINCL. The Sun linker generates these when it finds multiple identical copies of the symbols from an include file. This appears only in output from the Sun linker. */ __define_stab (N_EXCL, 0xc2, "EXCL") /* Modula-2 scope information. Can someone say what info it contains? */ __define_stab (N_SCOPE, 0xc4, "SCOPE") /* End of a lexical block. Desc matches the N_LBRAC's desc. The value is the address of the end of the text for the block. */ __define_stab (N_RBRAC, 0xe0, "RBRAC") /* Begin named common block. Only the name is significant. */ __define_stab (N_BCOMM, 0xe2, "BCOMM") /* End named common block. Only the name is significant (and it should match the N_BCOMM). */ __define_stab (N_ECOMM, 0xe4, "ECOMM") /* End common (local name): value is address. I'm not sure how this is used. */ __define_stab (N_ECOML, 0xe8, "ECOML") /* These STAB's are used on Gould systems for Non-Base register symbols or something like that. FIXME. I have assigned the values at random since I don't have a Gould here. Fixups from Gould folk welcome... */ __define_stab (N_NBTEXT, 0xF0, "NBTEXT") __define_stab (N_NBDATA, 0xF2, "NBDATA") __define_stab (N_NBBSS, 0xF4, "NBBSS") __define_stab (N_NBSTS, 0xF6, "NBSTS") __define_stab (N_NBLCS, 0xF8, "NBLCS") /* Second symbol entry containing a length-value for the preceding entry. The value is the length. */ __define_stab (N_LENG, 0xfe, "LENG") /* The above information, in matrix format. STAB MATRIX _________________________________________________ | 00 - 1F are not dbx stab symbols | | In most cases, the low bit is the EXTernal bit| | 00 UNDEF | 02 ABS | 04 TEXT | 06 DATA | | 01 |EXT | 03 |EXT | 05 |EXT | 07 |EXT | | 08 BSS | 0A INDR | 0C FN_SEQ | 0E | | 09 |EXT | 0B | 0D | 0F | | 10 | 12 COMM | 14 SETA | 16 SETT | | 11 | 13 | 15 | 17 | | 18 SETD | 1A SETB | 1C SETV | 1E WARNING| | 19 | 1B | 1D | 1F FN | |_______________________________________________| | Debug entries with bit 01 set are unused. | | 20 GSYM | 22 FNAME | 24 FUN | 26 STSYM | | 28 LCSYM | 2A MAIN | 2C | 2E | | 30 PC | 32 NSYMS | 34 NOMAP | 36 | | 38 OBJ | 3A | 3C OPT | 3E | | 40 RSYM | 42 M2C | 44 SLINE | 46 DSLINE | | 48 BSLINE*| 4A DEFD | 4C | 4E | | 50 EHDECL*| 52 | 54 CATCH | 56 | | 58 | 5A | 5C | 5E | | 60 SSYM | 62 | 64 SO | 66 | | 68 | 6A | 6C | 6E | | 70 | 72 | 74 | 76 | | 78 | 7A | 7C | 7E | | 80 LSYM | 82 BINCL | 84 SOL | 86 | | 88 | 8A | 8C | 8E | | 90 | 92 | 94 | 96 | | 98 | 9A | 9C | 9E | | A0 PSYM | A2 EINCL | A4 ENTRY | A6 | | A8 | AA | AC | AE | | B0 | B2 | B4 | B6 | | B8 | BA | BC | BE | | C0 LBRAC | C2 EXCL | C4 SCOPE | C6 | | C8 | CA | CC | CE | | D0 | D2 | D4 | D6 | | D8 | DA | DC | DE | | E0 RBRAC | E2 BCOMM | E4 ECOMM | E6 | | E8 ECOML | EA | EC | EE | | F0 | F2 | F4 | F6 | | F8 | FA | FC | FE LENG | +-----------------------------------------------+ * 50 EHDECL is also MOD2. * 48 BSLINE is also BROWS. */ dirent.h 0000644 00000003353 15125171642 0006212 0 ustar 00 /* Copyright (C) 1996-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _DIRENT_H # error "Never use <bits/dirent.h> directly; include <dirent.h> instead." #endif struct dirent { #ifndef __USE_FILE_OFFSET64 __ino_t d_ino; __off_t d_off; #else __ino64_t d_ino; __off64_t d_off; #endif unsigned short int d_reclen; unsigned char d_type; char d_name[256]; /* We must not include limits.h! */ }; #ifdef __USE_LARGEFILE64 struct dirent64 { __ino64_t d_ino; __off64_t d_off; unsigned short int d_reclen; unsigned char d_type; char d_name[256]; /* We must not include limits.h! */ }; #endif #define d_fileno d_ino /* Backwards compatibility. */ #undef _DIRENT_HAVE_D_NAMLEN #define _DIRENT_HAVE_D_RECLEN #define _DIRENT_HAVE_D_OFF #define _DIRENT_HAVE_D_TYPE #if defined __OFF_T_MATCHES_OFF64_T && defined __INO_T_MATCHES_INO64_T /* Inform libc code that these two types are effectively identical. */ # define _DIRENT_MATCHES_DIRENT64 1 #else # define _DIRENT_MATCHES_DIRENT64 0 #endif error-ldbl.h 0000644 00000001764 15125171642 0006775 0 ustar 00 /* Redirections for error.h functions for -mlong-double-64. Copyright (C) 2019-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _ERROR_H # error "Never include <bits/error-ldbl.h> directly; use <error.h> instead." #endif __LDBL_REDIR_DECL (error) __LDBL_REDIR_DECL (error_at_line) initspin.h 0000644 00000000031 15125171642 0006550 0 ustar 00 /* No thread support. */ mqueue2.h 0000644 00000004147 15125171642 0006312 0 ustar 00 /* Checking macros for mq functions. Copyright (C) 2007-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _FCNTL_H # error "Never include <bits/mqueue2.h> directly; use <mqueue.h> instead." #endif /* Check that calls to mq_open with O_CREAT set have an appropriate third and fourth parameter. */ extern mqd_t mq_open (const char *__name, int __oflag, ...) __THROW __nonnull ((1)); extern mqd_t __mq_open_2 (const char *__name, int __oflag) __THROW __nonnull ((1)); extern mqd_t __REDIRECT_NTH (__mq_open_alias, (const char *__name, int __oflag, ...), mq_open) __nonnull ((1)); __errordecl (__mq_open_wrong_number_of_args, "mq_open can be called either with 2 or 4 arguments"); __errordecl (__mq_open_missing_mode_and_attr, "mq_open with O_CREAT in second argument needs 4 arguments"); __fortify_function mqd_t __NTH (mq_open (const char *__name, int __oflag, ...)) { if (__va_arg_pack_len () != 0 && __va_arg_pack_len () != 2) __mq_open_wrong_number_of_args (); if (__builtin_constant_p (__oflag)) { if ((__oflag & O_CREAT) != 0 && __va_arg_pack_len () == 0) { __mq_open_missing_mode_and_attr (); return __mq_open_2 (__name, __oflag); } return __mq_open_alias (__name, __oflag, __va_arg_pack ()); } if (__va_arg_pack_len () == 0) return __mq_open_2 (__name, __oflag); return __mq_open_alias (__name, __oflag, __va_arg_pack ()); } getopt_ext.h 0000644 00000005736 15125171642 0007116 0 ustar 00 /* Declarations for getopt (GNU extensions). Copyright (C) 1989-2021 Free Software Foundation, Inc. This file is part of the GNU C Library and is also part of gnulib. Patches to this file should be submitted to both projects. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _GETOPT_EXT_H #define _GETOPT_EXT_H 1 /* This header should not be used directly; include getopt.h instead. Unlike most bits headers, it does not have a protective #error, because the guard macro for getopt.h in gnulib is not fixed. */ __BEGIN_DECLS /* Describe the long-named options requested by the application. The LONG_OPTIONS argument to getopt_long or getopt_long_only is a vector of 'struct option' terminated by an element containing a name which is zero. The field 'has_arg' is: no_argument (or 0) if the option does not take an argument, required_argument (or 1) if the option requires an argument, optional_argument (or 2) if the option takes an optional argument. If the field 'flag' is not NULL, it points to a variable that is set to the value given in the field 'val' when the option is found, but left unchanged if the option is not found. To have a long-named option do something other than set an 'int' to a compiled-in constant, such as set a value from 'optarg', set the option's 'flag' field to zero and its 'val' field to a nonzero value (the equivalent single-letter option character, if there is one). For long options that have a zero 'flag' field, 'getopt' returns the contents of the 'val' field. */ struct option { const char *name; /* has_arg can't be an enum because some compilers complain about type mismatches in all the code that assumes it is an int. */ int has_arg; int *flag; int val; }; /* Names for the values of the 'has_arg' field of 'struct option'. */ #define no_argument 0 #define required_argument 1 #define optional_argument 2 extern int getopt_long (int ___argc, char *__getopt_argv_const *___argv, const char *__shortopts, const struct option *__longopts, int *__longind) __THROW __nonnull ((2, 3)); extern int getopt_long_only (int ___argc, char *__getopt_argv_const *___argv, const char *__shortopts, const struct option *__longopts, int *__longind) __THROW __nonnull ((2, 3)); __END_DECLS #endif /* getopt_ext.h */ mman-shared.h 0000644 00000005431 15125171642 0007120 0 ustar 00 /* Memory-mapping-related declarations/definitions, not architecture-specific. Copyright (C) 2017-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _SYS_MMAN_H # error "Never use <bits/mman-shared.h> directly; include <sys/mman.h> instead." #endif #ifdef __USE_GNU /* Flags for mremap. */ # define MREMAP_MAYMOVE 1 # define MREMAP_FIXED 2 # define MREMAP_DONTUNMAP 4 /* Flags for memfd_create. */ # ifndef MFD_CLOEXEC # define MFD_CLOEXEC 1U # define MFD_ALLOW_SEALING 2U # define MFD_HUGETLB 4U # endif /* Flags for mlock2. */ # ifndef MLOCK_ONFAULT # define MLOCK_ONFAULT 1U # endif /* Access rights for pkey_alloc. */ # ifndef PKEY_DISABLE_ACCESS # define PKEY_DISABLE_ACCESS 0x1 # define PKEY_DISABLE_WRITE 0x2 # endif __BEGIN_DECLS /* Create a new memory file descriptor. NAME is a name for debugging. FLAGS is a combination of the MFD_* constants. */ int memfd_create (const char *__name, unsigned int __flags) __THROW; /* Lock pages from ADDR (inclusive) to ADDR + LENGTH (exclusive) into memory. FLAGS is a combination of the MLOCK_* flags above. */ int mlock2 (const void *__addr, size_t __length, unsigned int __flags) __THROW; /* Allocate a new protection key, with the PKEY_DISABLE_* bits specified in ACCESS_RIGHTS. The protection key mask for the current thread is updated to match the access privilege for the new key. */ int pkey_alloc (unsigned int __flags, unsigned int __access_rights) __THROW; /* Update the access rights for the current thread for KEY, which must have been allocated using pkey_alloc. */ int pkey_set (int __key, unsigned int __access_rights) __THROW; /* Return the access rights for the current thread for KEY, which must have been allocated using pkey_alloc. */ int pkey_get (int __key) __THROW; /* Free an allocated protection key, which must have been allocated using pkey_alloc. */ int pkey_free (int __key) __THROW; /* Apply memory protection flags for KEY to the specified address range. */ int pkey_mprotect (void *__addr, size_t __len, int __prot, int __pkey) __THROW; __END_DECLS #endif /* __USE_GNU */ link_lavcurrent.h 0000644 00000002113 15125171642 0010120 0 ustar 00 /* Data structure for communication from the run-time dynamic linker for loaded ELF shared objects. LAV_CURRENT definition. Copyright (C) 2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _LINK_H # error "Never include <bits/link_lavcurrent.h> directly; use <link.h> instead." #endif /* Version numbers for la_version handshake interface. */ #define LAV_CURRENT 2 string_fortified.h 0000644 00000010371 15125171642 0010264 0 ustar 00 /* Copyright (C) 2004-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _BITS_STRING_FORTIFIED_H #define _BITS_STRING_FORTIFIED_H 1 #ifndef _STRING_H # error "Never use <bits/string_fortified.h> directly; include <string.h> instead." #endif __fortify_function void * __NTH (memcpy (void *__restrict __dest, const void *__restrict __src, size_t __len)) { return __builtin___memcpy_chk (__dest, __src, __len, __glibc_objsize0 (__dest)); } __fortify_function void * __NTH (memmove (void *__dest, const void *__src, size_t __len)) { return __builtin___memmove_chk (__dest, __src, __len, __glibc_objsize0 (__dest)); } #ifdef __USE_GNU __fortify_function void * __NTH (mempcpy (void *__restrict __dest, const void *__restrict __src, size_t __len)) { return __builtin___mempcpy_chk (__dest, __src, __len, __glibc_objsize0 (__dest)); } #endif /* The first two tests here help to catch a somewhat common problem where the second and third parameter are transposed. This is especially problematic if the intended fill value is zero. In this case no work is done at all. We detect these problems by referring non-existing functions. */ __fortify_function void * __NTH (memset (void *__dest, int __ch, size_t __len)) { return __builtin___memset_chk (__dest, __ch, __len, __glibc_objsize0 (__dest)); } #ifdef __USE_MISC # include <bits/strings_fortified.h> void __explicit_bzero_chk (void *__dest, size_t __len, size_t __destlen) __THROW __nonnull ((1)) __fortified_attr_access (__write_only__, 1, 2); __fortify_function void __NTH (explicit_bzero (void *__dest, size_t __len)) { __explicit_bzero_chk (__dest, __len, __glibc_objsize0 (__dest)); } #endif __fortify_function char * __NTH (strcpy (char *__restrict __dest, const char *__restrict __src)) { return __builtin___strcpy_chk (__dest, __src, __glibc_objsize (__dest)); } #ifdef __USE_XOPEN2K8 __fortify_function char * __NTH (stpcpy (char *__restrict __dest, const char *__restrict __src)) { return __builtin___stpcpy_chk (__dest, __src, __glibc_objsize (__dest)); } #endif __fortify_function char * __NTH (strncpy (char *__restrict __dest, const char *__restrict __src, size_t __len)) { return __builtin___strncpy_chk (__dest, __src, __len, __glibc_objsize (__dest)); } #ifdef __USE_XOPEN2K8 # if __GNUC_PREREQ (4, 7) || __glibc_clang_prereq (2, 6) __fortify_function char * __NTH (stpncpy (char *__dest, const char *__src, size_t __n)) { return __builtin___stpncpy_chk (__dest, __src, __n, __glibc_objsize (__dest)); } # else extern char *__stpncpy_chk (char *__dest, const char *__src, size_t __n, size_t __destlen) __THROW __fortified_attr_access (__write_only__, 1, 3) __attr_access ((__read_only__, 2)); extern char *__REDIRECT_NTH (__stpncpy_alias, (char *__dest, const char *__src, size_t __n), stpncpy); __fortify_function char * __NTH (stpncpy (char *__dest, const char *__src, size_t __n)) { if (__bos (__dest) != (size_t) -1 && (!__builtin_constant_p (__n) || __n > __bos (__dest))) return __stpncpy_chk (__dest, __src, __n, __bos (__dest)); return __stpncpy_alias (__dest, __src, __n); } # endif #endif __fortify_function char * __NTH (strcat (char *__restrict __dest, const char *__restrict __src)) { return __builtin___strcat_chk (__dest, __src, __glibc_objsize (__dest)); } __fortify_function char * __NTH (strncat (char *__restrict __dest, const char *__restrict __src, size_t __len)) { return __builtin___strncat_chk (__dest, __src, __len, __glibc_objsize (__dest)); } #endif /* bits/string_fortified.h */ pthreadtypes.h 0000644 00000006000 15125171642 0007431 0 ustar 00 /* Declaration of common pthread types for all architectures. Copyright (C) 2017-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _BITS_PTHREADTYPES_COMMON_H # define _BITS_PTHREADTYPES_COMMON_H 1 /* For internal mutex and condition variable definitions. */ #include <bits/thread-shared-types.h> /* Thread identifiers. The structure of the attribute type is not exposed on purpose. */ typedef unsigned long int pthread_t; /* Data structures for mutex handling. The structure of the attribute type is not exposed on purpose. */ typedef union { char __size[__SIZEOF_PTHREAD_MUTEXATTR_T]; int __align; } pthread_mutexattr_t; /* Data structure for condition variable handling. The structure of the attribute type is not exposed on purpose. */ typedef union { char __size[__SIZEOF_PTHREAD_CONDATTR_T]; int __align; } pthread_condattr_t; /* Keys for thread-specific data */ typedef unsigned int pthread_key_t; /* Once-only execution */ typedef int __ONCE_ALIGNMENT pthread_once_t; union pthread_attr_t { char __size[__SIZEOF_PTHREAD_ATTR_T]; long int __align; }; #ifndef __have_pthread_attr_t typedef union pthread_attr_t pthread_attr_t; # define __have_pthread_attr_t 1 #endif typedef union { struct __pthread_mutex_s __data; char __size[__SIZEOF_PTHREAD_MUTEX_T]; long int __align; } pthread_mutex_t; typedef union { struct __pthread_cond_s __data; char __size[__SIZEOF_PTHREAD_COND_T]; __extension__ long long int __align; } pthread_cond_t; #if defined __USE_UNIX98 || defined __USE_XOPEN2K /* Data structure for reader-writer lock variable handling. The structure of the attribute type is deliberately not exposed. */ typedef union { struct __pthread_rwlock_arch_t __data; char __size[__SIZEOF_PTHREAD_RWLOCK_T]; long int __align; } pthread_rwlock_t; typedef union { char __size[__SIZEOF_PTHREAD_RWLOCKATTR_T]; long int __align; } pthread_rwlockattr_t; #endif #ifdef __USE_XOPEN2K /* POSIX spinlock data type. */ typedef volatile int pthread_spinlock_t; /* POSIX barriers data type. The structure of the type is deliberately not exposed. */ typedef union { char __size[__SIZEOF_PTHREAD_BARRIER_T]; long int __align; } pthread_barrier_t; typedef union { char __size[__SIZEOF_PTHREAD_BARRIERATTR_T]; int __align; } pthread_barrierattr_t; #endif #endif sigstack.h 0000644 00000002220 15125171642 0006525 0 ustar 00 /* sigstack, sigaltstack definitions. Copyright (C) 1998-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _BITS_SIGSTACK_H #define _BITS_SIGSTACK_H 1 #if !defined _SIGNAL_H && !defined _SYS_UCONTEXT_H # error "Never include this file directly. Use <signal.h> instead" #endif /* Minimum stack size for a signal handler. */ #define MINSIGSTKSZ 2048 /* System default stack size. */ #define SIGSTKSZ 8192 #endif /* bits/sigstack.h */ ipc-perm.h 0000644 00000003321 15125171642 0006434 0 ustar 00 /* struct ipc_perm definition. Copyright (C) 2019-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <http://www.gnu.org/licenses/>. */ #ifndef _SYS_IPC_H # error "Never use <bits/ipc-perm.h> directly; include <sys/ipc.h> instead." #endif /* Data structure used to pass permission information to IPC operations. It follows the kernel ipc64_perm size so the syscall can be made directly without temporary buffer copy. However, since glibc defines the MODE field as mode_t per POSIX definition (BZ#18231), it omits the __PAD1 field (since glibc does not export mode_t as 16-bit for any architecture). */ struct ipc_perm { __key_t __key; /* Key. */ __uid_t uid; /* Owner's user ID. */ __gid_t gid; /* Owner's group ID. */ __uid_t cuid; /* Creator's user ID. */ __gid_t cgid; /* Creator's group ID. */ __mode_t mode; /* Read/write permission. */ unsigned short int __seq; /* Sequence number. */ unsigned short int __pad2; __syscall_ulong_t __glibc_reserved1; __syscall_ulong_t __glibc_reserved2; }; msq.h 0000644 00000003401 15125171642 0005517 0 ustar 00 /* Copyright (C) 1995-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _SYS_MSG_H # error "Never use <bits/msq.h> directly; include <sys/msg.h> instead." #endif #include <bits/types.h> /* Types used in the MSQID_DS structure definition. */ typedef __syscall_ulong_t msgqnum_t; typedef __syscall_ulong_t msglen_t; #include <bits/types/struct_msqid_ds.h> #include <bits/types/struct_msqid64_ds.h> /* Define options for message queue functions. */ #define MSG_NOERROR 010000 /* no error if message is too big */ #ifdef __USE_GNU # define MSG_EXCEPT 020000 /* recv any msg except of specified type */ # define MSG_COPY 040000 /* copy (not remove) all queue messages */ #endif #ifdef __USE_MISC # define msg_cbytes __msg_cbytes /* ipcs ctl commands */ # define MSG_STAT 11 # define MSG_INFO 12 # define MSG_STAT_ANY 13 /* buffer for msgctl calls IPC_INFO, MSG_INFO */ struct msginfo { int msgpool; int msgmap; int msgmax; int msgmnb; int msgmni; int msgssz; int msgtql; unsigned short int msgseg; }; #endif /* __USE_MISC */ locale.h 0000644 00000002530 15125171642 0006160 0 ustar 00 /* Definition of locale category symbol values. Copyright (C) 2001-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #if !defined _LOCALE_H && !defined _LANGINFO_H # error "Never use <bits/locale.h> directly; include <locale.h> instead." #endif #ifndef _BITS_LOCALE_H #define _BITS_LOCALE_H 1 #define __LC_CTYPE 0 #define __LC_NUMERIC 1 #define __LC_TIME 2 #define __LC_COLLATE 3 #define __LC_MONETARY 4 #define __LC_MESSAGES 5 #define __LC_ALL 6 #define __LC_PAPER 7 #define __LC_NAME 8 #define __LC_ADDRESS 9 #define __LC_TELEPHONE 10 #define __LC_MEASUREMENT 11 #define __LC_IDENTIFICATION 12 #endif /* bits/locale.h */ libm-simd-decl-stubs.h 0000644 00000005674 15125171642 0010655 0 ustar 00 /* Empty definitions required for __MATHCALL_VEC unfolding in mathcalls.h. Copyright (C) 2014-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _MATH_H # error "Never include <bits/libm-simd-decl-stubs.h> directly;\ include <math.h> instead." #endif /* Needed definitions could be generated with: for func in $(grep __MATHCALL_VEC math/bits/mathcalls.h |\ sed -r "s|__MATHCALL_VEC.?\(||; s|,.*||"); do echo "#define __DECL_SIMD_${func}"; echo "#define __DECL_SIMD_${func}f"; echo "#define __DECL_SIMD_${func}l"; done */ #ifndef _BITS_LIBM_SIMD_DECL_STUBS_H #define _BITS_LIBM_SIMD_DECL_STUBS_H 1 #define __DECL_SIMD_cos #define __DECL_SIMD_cosf #define __DECL_SIMD_cosl #define __DECL_SIMD_cosf16 #define __DECL_SIMD_cosf32 #define __DECL_SIMD_cosf64 #define __DECL_SIMD_cosf128 #define __DECL_SIMD_cosf32x #define __DECL_SIMD_cosf64x #define __DECL_SIMD_cosf128x #define __DECL_SIMD_sin #define __DECL_SIMD_sinf #define __DECL_SIMD_sinl #define __DECL_SIMD_sinf16 #define __DECL_SIMD_sinf32 #define __DECL_SIMD_sinf64 #define __DECL_SIMD_sinf128 #define __DECL_SIMD_sinf32x #define __DECL_SIMD_sinf64x #define __DECL_SIMD_sinf128x #define __DECL_SIMD_sincos #define __DECL_SIMD_sincosf #define __DECL_SIMD_sincosl #define __DECL_SIMD_sincosf16 #define __DECL_SIMD_sincosf32 #define __DECL_SIMD_sincosf64 #define __DECL_SIMD_sincosf128 #define __DECL_SIMD_sincosf32x #define __DECL_SIMD_sincosf64x #define __DECL_SIMD_sincosf128x #define __DECL_SIMD_log #define __DECL_SIMD_logf #define __DECL_SIMD_logl #define __DECL_SIMD_logf16 #define __DECL_SIMD_logf32 #define __DECL_SIMD_logf64 #define __DECL_SIMD_logf128 #define __DECL_SIMD_logf32x #define __DECL_SIMD_logf64x #define __DECL_SIMD_logf128x #define __DECL_SIMD_exp #define __DECL_SIMD_expf #define __DECL_SIMD_expl #define __DECL_SIMD_expf16 #define __DECL_SIMD_expf32 #define __DECL_SIMD_expf64 #define __DECL_SIMD_expf128 #define __DECL_SIMD_expf32x #define __DECL_SIMD_expf64x #define __DECL_SIMD_expf128x #define __DECL_SIMD_pow #define __DECL_SIMD_powf #define __DECL_SIMD_powl #define __DECL_SIMD_powf16 #define __DECL_SIMD_powf32 #define __DECL_SIMD_powf64 #define __DECL_SIMD_powf128 #define __DECL_SIMD_powf32x #define __DECL_SIMD_powf64x #define __DECL_SIMD_powf128x #endif thread-shared-types.h 0000644 00000007527 15125171642 0010611 0 ustar 00 /* Common threading primitives definitions for both POSIX and C11. Copyright (C) 2017-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _THREAD_SHARED_TYPES_H #define _THREAD_SHARED_TYPES_H 1 /* Arch-specific definitions. Each architecture must define the following macros to define the expected sizes of pthread data types: __SIZEOF_PTHREAD_ATTR_T - size of pthread_attr_t. __SIZEOF_PTHREAD_MUTEX_T - size of pthread_mutex_t. __SIZEOF_PTHREAD_MUTEXATTR_T - size of pthread_mutexattr_t. __SIZEOF_PTHREAD_COND_T - size of pthread_cond_t. __SIZEOF_PTHREAD_CONDATTR_T - size of pthread_condattr_t. __SIZEOF_PTHREAD_RWLOCK_T - size of pthread_rwlock_t. __SIZEOF_PTHREAD_RWLOCKATTR_T - size of pthread_rwlockattr_t. __SIZEOF_PTHREAD_BARRIER_T - size of pthread_barrier_t. __SIZEOF_PTHREAD_BARRIERATTR_T - size of pthread_barrierattr_t. The additional macro defines any constraint for the lock alignment inside the thread structures: __LOCK_ALIGNMENT - for internal lock/futex usage. Same idea but for the once locking primitive: __ONCE_ALIGNMENT - for pthread_once_t/once_flag definition. */ #include <bits/pthreadtypes-arch.h> #include <bits/atomic_wide_counter.h> /* Common definition of pthread_mutex_t. */ typedef struct __pthread_internal_list { struct __pthread_internal_list *__prev; struct __pthread_internal_list *__next; } __pthread_list_t; typedef struct __pthread_internal_slist { struct __pthread_internal_slist *__next; } __pthread_slist_t; /* Arch-specific mutex definitions. A generic implementation is provided by sysdeps/nptl/bits/struct_mutex.h. If required, an architecture can override it by defining: 1. struct __pthread_mutex_s (used on both pthread_mutex_t and mtx_t definition). It should contains at least the internal members defined in the generic version. 2. __LOCK_ALIGNMENT for any extra attribute for internal lock used with atomic operations. 3. The macro __PTHREAD_MUTEX_INITIALIZER used for static initialization. It should initialize the mutex internal flag. */ #include <bits/struct_mutex.h> /* Arch-sepecific read-write lock definitions. A generic implementation is provided by struct_rwlock.h. If required, an architecture can override it by defining: 1. struct __pthread_rwlock_arch_t (used on pthread_rwlock_t definition). It should contain at least the internal members defined in the generic version. 2. The macro __PTHREAD_RWLOCK_INITIALIZER used for static initialization. It should initialize the rwlock internal type. */ #include <bits/struct_rwlock.h> /* Common definition of pthread_cond_t. */ struct __pthread_cond_s { __atomic_wide_counter __wseq; __atomic_wide_counter __g1_start; unsigned int __glibc_unused___g_refs[2] __LOCK_ALIGNMENT; unsigned int __g_size[2]; unsigned int __g1_orig_size; unsigned int __wrefs; unsigned int __g_signals[2]; }; typedef unsigned int __tss_t; typedef unsigned long int __thrd_t; typedef struct { int __data __ONCE_ALIGNMENT; } __once_flag; #define __ONCE_FLAG_INIT { 0 } #endif /* _THREAD_SHARED_TYPES_H */ hwcap.h 0000644 00000001714 15125171642 0006026 0 ustar 00 /* Defines for bits in AT_HWCAP. Copyright (C) 2012-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _SYS_AUXV_H # error "Never include <bits/hwcap.h> directly; use <sys/auxv.h> instead." #endif /* No bits defined for this architecture. */ types/struct_sigstack.h 0000644 00000002061 15125171642 0011300 0 ustar 00 /* Define struct sigstack. Copyright (C) 1998-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef __sigstack_defined #define __sigstack_defined 1 /* Structure describing a signal stack (obsolete). */ struct sigstack { void *ss_sp; /* Signal stack pointer. */ int ss_onstack; /* Nonzero if executing on this stack. */ }; #endif types/clockid_t.h 0000644 00000000256 15125171642 0010023 0 ustar 00 #ifndef __clockid_t_defined #define __clockid_t_defined 1 #include <bits/types.h> /* Clock ID used in clock and timer functions. */ typedef __clockid_t clockid_t; #endif types/FILE.h 0000644 00000000264 15125171642 0006606 0 ustar 00 #ifndef __FILE_defined #define __FILE_defined 1 struct _IO_FILE; /* The opaque type of streams. This is the definition used elsewhere. */ typedef struct _IO_FILE FILE; #endif types/struct_FILE.h 0000644 00000010754 15125171642 0010217 0 ustar 00 /* Copyright (C) 1991-2021 Free Software Foundation, Inc. Copyright The GNU Toolchain Authors. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef __struct_FILE_defined #define __struct_FILE_defined 1 /* Caution: The contents of this file are not part of the official stdio.h API. However, much of it is part of the official *binary* interface, and therefore cannot be changed. */ #if defined _IO_USE_OLD_IO_FILE && !defined _LIBC # error "_IO_USE_OLD_IO_FILE should only be defined when building libc itself" #endif #if defined _IO_lock_t_defined && !defined _LIBC # error "_IO_lock_t_defined should only be defined when building libc itself" #endif #include <bits/types.h> #include <bits/wordsize.h> struct _IO_FILE; struct _IO_marker; struct _IO_codecvt; struct _IO_wide_data; /* During the build of glibc itself, _IO_lock_t will already have been defined by internal headers. */ #ifndef _IO_lock_t_defined typedef void _IO_lock_t; #endif /* The tag name of this struct is _IO_FILE to preserve historic C++ mangled names for functions taking FILE* arguments. That name should not be used in new code. */ struct _IO_FILE { int _flags; /* High-order word is _IO_MAGIC; rest is flags. */ /* The following pointers correspond to the C++ streambuf protocol. */ char *_IO_read_ptr; /* Current read pointer */ char *_IO_read_end; /* End of get area. */ char *_IO_read_base; /* Start of putback+get area. */ char *_IO_write_base; /* Start of put area. */ char *_IO_write_ptr; /* Current put pointer. */ char *_IO_write_end; /* End of put area. */ char *_IO_buf_base; /* Start of reserve area. */ char *_IO_buf_end; /* End of reserve area. */ /* The following fields are used to support backing up and undo. */ char *_IO_save_base; /* Pointer to start of non-current get area. */ char *_IO_backup_base; /* Pointer to first valid character of backup area */ char *_IO_save_end; /* Pointer to end of non-current get area. */ struct _IO_marker *_markers; struct _IO_FILE *_chain; int _fileno; #ifdef _LIBC int _flags2:24; /* Fallback buffer to use when malloc fails to allocate one. */ char _short_backupbuf[1]; #else /* Legacy ABI for ABI checking outside of glibc. */ int _flags2; #endif __off_t _old_offset; /* This used to be _offset but it's too small. */ /* 1+column number of pbase(); 0 is unknown. */ unsigned short _cur_column; signed char _vtable_offset; char _shortbuf[1]; _IO_lock_t *_lock; #ifdef _IO_USE_OLD_IO_FILE }; struct _IO_FILE_complete { struct _IO_FILE _file; #endif __off64_t _offset; /* Wide character stream stuff. */ struct _IO_codecvt *_codecvt; struct _IO_wide_data *_wide_data; struct _IO_FILE *_freeres_list; void *_freeres_buf; size_t __pad5; int _mode; #ifdef _LIBC # if __WORDSIZE == 64 int _unused3; # endif __uint64_t _total_written; # if __WORDSIZE == 32 int _unused3; # endif /* Make sure we don't get into trouble again. */ char _unused2[12 * sizeof (int) - 4 * sizeof (void *) - sizeof (size_t)]; #else char _unused2[15 * sizeof (int) - 4 * sizeof (void *) - sizeof (size_t)]; #endif }; /* These macros are used by bits/stdio.h and internal headers. */ #define __getc_unlocked_body(_fp) \ (__glibc_unlikely ((_fp)->_IO_read_ptr >= (_fp)->_IO_read_end) \ ? __uflow (_fp) : *(unsigned char *) (_fp)->_IO_read_ptr++) #define __putc_unlocked_body(_ch, _fp) \ (__glibc_unlikely ((_fp)->_IO_write_ptr >= (_fp)->_IO_write_end) \ ? __overflow (_fp, (unsigned char) (_ch)) \ : (unsigned char) (*(_fp)->_IO_write_ptr++ = (_ch))) #define _IO_EOF_SEEN 0x0010 #define __feof_unlocked_body(_fp) (((_fp)->_flags & _IO_EOF_SEEN) != 0) #define _IO_ERR_SEEN 0x0020 #define __ferror_unlocked_body(_fp) (((_fp)->_flags & _IO_ERR_SEEN) != 0) #define _IO_USER_LOCK 0x8000 /* Many more flag bits are defined internally. */ #endif types/__FILE.h 0000644 00000000156 15125171642 0007104 0 ustar 00 #ifndef ____FILE_defined #define ____FILE_defined 1 struct _IO_FILE; typedef struct _IO_FILE __FILE; #endif types/stack_t.h 0000644 00000002046 15125171642 0007517 0 ustar 00 /* Define stack_t. Linux version. Copyright (C) 1998-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef __stack_t_defined #define __stack_t_defined 1 #define __need_size_t #include <stddef.h> /* Structure describing a signal stack. */ typedef struct { void *ss_sp; int ss_flags; size_t ss_size; } stack_t; #endif types/time_t.h 0000644 00000000313 15125171642 0007343 0 ustar 00 #ifndef __time_t_defined #define __time_t_defined 1 #include <bits/types.h> /* Returned by `time'. */ #ifdef __USE_TIME_BITS64 typedef __time64_t time_t; #else typedef __time_t time_t; #endif #endif types/__mbstate_t.h 0000644 00000001064 15125171642 0010346 0 ustar 00 #ifndef ____mbstate_t_defined #define ____mbstate_t_defined 1 /* Integral type unchanged by default argument promotions that can hold any value corresponding to members of the extended character set, as well as at least one value that does not correspond to any member of the extended character set. */ #ifndef __WINT_TYPE__ # define __WINT_TYPE__ unsigned int #endif /* Conversion state information. */ typedef struct { int __count; union { __WINT_TYPE__ __wch; char __wchb[4]; } __value; /* Value so far. */ } __mbstate_t; #endif types/siginfo_t.h 0000644 00000007464 15125171642 0010061 0 ustar 00 #ifndef __siginfo_t_defined #define __siginfo_t_defined 1 #include <bits/wordsize.h> #include <bits/types.h> #include <bits/types/__sigval_t.h> #define __SI_MAX_SIZE 128 #if __WORDSIZE == 64 # define __SI_PAD_SIZE ((__SI_MAX_SIZE / sizeof (int)) - 4) #else # define __SI_PAD_SIZE ((__SI_MAX_SIZE / sizeof (int)) - 3) #endif /* Some fields of siginfo_t have architecture-specific variations. */ #include <bits/siginfo-arch.h> #ifndef __SI_ALIGNMENT # define __SI_ALIGNMENT /* nothing */ #endif #ifndef __SI_BAND_TYPE # define __SI_BAND_TYPE long int #endif #ifndef __SI_CLOCK_T # define __SI_CLOCK_T __clock_t #endif #ifndef __SI_ERRNO_THEN_CODE # define __SI_ERRNO_THEN_CODE 1 #endif #ifndef __SI_HAVE_SIGSYS # define __SI_HAVE_SIGSYS 1 #endif #ifndef __SI_SIGFAULT_ADDL # define __SI_SIGFAULT_ADDL /* nothing */ #endif typedef struct { int si_signo; /* Signal number. */ #if __SI_ERRNO_THEN_CODE int si_errno; /* If non-zero, an errno value associated with this signal, as defined in <errno.h>. */ int si_code; /* Signal code. */ #else int si_code; int si_errno; #endif #if __WORDSIZE == 64 int __pad0; /* Explicit padding. */ #endif union { int _pad[__SI_PAD_SIZE]; /* kill(). */ struct { __pid_t si_pid; /* Sending process ID. */ __uid_t si_uid; /* Real user ID of sending process. */ } _kill; /* POSIX.1b timers. */ struct { int si_tid; /* Timer ID. */ int si_overrun; /* Overrun count. */ __sigval_t si_sigval; /* Signal value. */ } _timer; /* POSIX.1b signals. */ struct { __pid_t si_pid; /* Sending process ID. */ __uid_t si_uid; /* Real user ID of sending process. */ __sigval_t si_sigval; /* Signal value. */ } _rt; /* SIGCHLD. */ struct { __pid_t si_pid; /* Which child. */ __uid_t si_uid; /* Real user ID of sending process. */ int si_status; /* Exit value or signal. */ __SI_CLOCK_T si_utime; __SI_CLOCK_T si_stime; } _sigchld; /* SIGILL, SIGFPE, SIGSEGV, SIGBUS. */ struct { void *si_addr; /* Faulting insn/memory ref. */ __SI_SIGFAULT_ADDL short int si_addr_lsb; /* Valid LSB of the reported address. */ union { /* used when si_code=SEGV_BNDERR */ struct { void *_lower; void *_upper; } _addr_bnd; /* used when si_code=SEGV_PKUERR */ __uint32_t _pkey; } _bounds; } _sigfault; /* SIGPOLL. */ struct { __SI_BAND_TYPE si_band; /* Band event for SIGPOLL. */ int si_fd; } _sigpoll; /* SIGSYS. */ #if __SI_HAVE_SIGSYS struct { void *_call_addr; /* Calling user insn. */ int _syscall; /* Triggering system call number. */ unsigned int _arch; /* AUDIT_ARCH_* of syscall. */ } _sigsys; #endif } _sifields; } siginfo_t __SI_ALIGNMENT; /* X/Open requires some more fields with fixed names. */ #define si_pid _sifields._kill.si_pid #define si_uid _sifields._kill.si_uid #define si_timerid _sifields._timer.si_tid #define si_overrun _sifields._timer.si_overrun #define si_status _sifields._sigchld.si_status #define si_utime _sifields._sigchld.si_utime #define si_stime _sifields._sigchld.si_stime #define si_value _sifields._rt.si_sigval #define si_int _sifields._rt.si_sigval.sival_int #define si_ptr _sifields._rt.si_sigval.sival_ptr #define si_addr _sifields._sigfault.si_addr #define si_addr_lsb _sifields._sigfault.si_addr_lsb #define si_lower _sifields._sigfault._bounds._addr_bnd._lower #define si_upper _sifields._sigfault._bounds._addr_bnd._upper #define si_pkey _sifields._sigfault._bounds._pkey #define si_band _sifields._sigpoll.si_band #define si_fd _sifields._sigpoll.si_fd #if __SI_HAVE_SIGSYS # define si_call_addr _sifields._sigsys._call_addr # define si_syscall _sifields._sigsys._syscall # define si_arch _sifields._sigsys._arch #endif #endif types/error_t.h 0000644 00000001576 15125171642 0007552 0 ustar 00 /* Define error_t. Copyright (C) 1991-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef __error_t_defined # define __error_t_defined 1 typedef int error_t; #endif types/wint_t.h 0000644 00000001434 15125171642 0007373 0 ustar 00 #ifndef __wint_t_defined #define __wint_t_defined 1 /* Some versions of stddef.h provide wint_t, even though neither the C nor C++ standards, nor POSIX, specifies this. We assume that stddef.h will define the macro _WINT_T if and only if it provides wint_t, and conversely, that it will avoid providing wint_t if _WINT_T is already defined. */ #ifndef _WINT_T #define _WINT_T 1 /* Integral type unchanged by default argument promotions that can hold any value corresponding to members of the extended character set, as well as at least one value that does not correspond to any member of the extended character set. */ #ifndef __WINT_TYPE__ # define __WINT_TYPE__ unsigned int #endif typedef __WINT_TYPE__ wint_t; #endif /* _WINT_T */ #endif /* bits/types/wint_t.h */ types/sig_atomic_t.h 0000644 00000000420 15125171642 0010522 0 ustar 00 #ifndef __sig_atomic_t_defined #define __sig_atomic_t_defined 1 #include <bits/types.h> /* An integral type that can be modified atomically, without the possibility of a signal arriving in the middle of the operation. */ typedef __sig_atomic_t sig_atomic_t; #endif types/__sigval_t.h 0000644 00000002174 15125171642 0010177 0 ustar 00 /* Define __sigval_t. Copyright (C) 1997-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef ____sigval_t_defined #define ____sigval_t_defined /* Type for data associated with a signal. */ #ifdef __USE_POSIX199309 union sigval { int sival_int; void *sival_ptr; }; typedef union sigval __sigval_t; #else union __sigval { int __sival_int; void *__sival_ptr; }; typedef union __sigval __sigval_t; #endif #endif types/sigval_t.h 0000644 00000001127 15125171642 0007676 0 ustar 00 #ifndef __sigval_t_defined #define __sigval_t_defined #include <bits/types/__sigval_t.h> /* To avoid sigval_t (not a standard type name) having C++ name mangling depending on whether the selected standard includes union sigval, it should not be defined at all when using a standard for which the sigval name is not reserved; in that case, headers should not include <bits/types/sigval_t.h> and should use only the internal __sigval_t name. */ #ifndef __USE_POSIX199309 # error "sigval_t defined for standard not including union sigval" #endif typedef __sigval_t sigval_t; #endif types/mbstate_t.h 0000644 00000000207 15125171642 0010046 0 ustar 00 #ifndef __mbstate_t_defined #define __mbstate_t_defined 1 #include <bits/types/__mbstate_t.h> typedef __mbstate_t mbstate_t; #endif types/sigevent_t.h 0000644 00000002264 15125171642 0010240 0 ustar 00 #ifndef __sigevent_t_defined #define __sigevent_t_defined 1 #include <bits/wordsize.h> #include <bits/types.h> #include <bits/types/__sigval_t.h> #define __SIGEV_MAX_SIZE 64 #if __WORDSIZE == 64 # define __SIGEV_PAD_SIZE ((__SIGEV_MAX_SIZE / sizeof (int)) - 4) #else # define __SIGEV_PAD_SIZE ((__SIGEV_MAX_SIZE / sizeof (int)) - 3) #endif /* Forward declaration. */ #ifndef __have_pthread_attr_t typedef union pthread_attr_t pthread_attr_t; # define __have_pthread_attr_t 1 #endif /* Structure to transport application-defined values with signals. */ typedef struct sigevent { __sigval_t sigev_value; int sigev_signo; int sigev_notify; union { int _pad[__SIGEV_PAD_SIZE]; /* When SIGEV_SIGNAL and SIGEV_THREAD_ID set, LWP ID of the thread to receive the signal. */ __pid_t _tid; struct { void (*_function) (__sigval_t); /* Function to start. */ pthread_attr_t *_attribute; /* Thread attributes. */ } _sigev_thread; } _sigev_un; } sigevent_t; /* POSIX names to access some of the members. */ #define sigev_notify_function _sigev_un._sigev_thread._function #define sigev_notify_attributes _sigev_un._sigev_thread._attribute #endif types/struct_semid64_ds.h 0000644 00000002125 15125171642 0011432 0 ustar 00 /* Generic implementation of the semaphore struct semid64_ds. Copyright (C) 2020-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _SYS_SEM_H # error "Never include <bits/types/struct_semid_ds.h> directly; use <sys/sem.h> instead." #endif #if __TIMESIZE == 64 # define __semid64_ds semid_ds #else struct __semid64_ds { # include <bits/types/struct_semid64_ds_helper.h> }; #endif types/clock_t.h 0000644 00000000217 15125171642 0007503 0 ustar 00 #ifndef __clock_t_defined #define __clock_t_defined 1 #include <bits/types.h> /* Returned by `clock'. */ typedef __clock_t clock_t; #endif types/struct_semid64_ds_helper.h 0000644 00000002274 15125171642 0012776 0 ustar 00 /* Common definitions for struct semid_ds with 64-bit time. Copyright (C) 2020-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ /* Content of internal __semid64_ds. */ struct ipc_perm sem_perm; /* operation permission struct */ __time64_t sem_otime; /* last semop() time */ __time64_t sem_ctime; /* last time changed by semctl() */ __syscall_ulong_t sem_nsems; /* number of semaphores in set */ unsigned long int __glibc_reserved3; unsigned long int __glibc_reserved4; types/timer_t.h 0000644 00000000237 15125171642 0007532 0 ustar 00 #ifndef __timer_t_defined #define __timer_t_defined 1 #include <bits/types.h> /* Timer ID returned by `timer_create'. */ typedef __timer_t timer_t; #endif types/locale_t.h 0000644 00000001727 15125171642 0007656 0 ustar 00 /* Definition of locale_t. Copyright (C) 2017-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _BITS_TYPES_LOCALE_T_H #define _BITS_TYPES_LOCALE_T_H 1 #include <bits/types/__locale_t.h> typedef __locale_t locale_t; #endif /* bits/types/locale_t.h */ types/res_state.h 0000644 00000003731 15125171642 0010062 0 ustar 00 #ifndef __res_state_defined #define __res_state_defined 1 #include <sys/types.h> #include <netinet/in.h> /* res_state: the global state used by the resolver stub. */ #define MAXNS 3 /* max # name servers we'll track */ #define MAXDFLSRCH 3 /* # default domain levels to try */ #define MAXDNSRCH 6 /* max # domains in search path */ #define MAXRESOLVSORT 10 /* number of net to sort on */ struct __res_state { int retrans; /* retransmition time interval */ int retry; /* number of times to retransmit */ unsigned long options; /* option flags - see below. */ int nscount; /* number of name servers */ struct sockaddr_in nsaddr_list[MAXNS]; /* address of name server */ unsigned short id; /* current message id */ /* 2 byte hole here. */ char *dnsrch[MAXDNSRCH+1]; /* components of domain to search */ char defdname[256]; /* default domain (deprecated) */ unsigned long pfcode; /* RES_PRF_ flags - see below. */ unsigned ndots:4; /* threshold for initial abs. query */ unsigned nsort:4; /* number of elements in sort_list[] */ unsigned ipv6_unavail:1; /* connecting to IPv6 server failed */ unsigned unused:23; struct { struct in_addr addr; uint32_t mask; } sort_list[MAXRESOLVSORT]; /* 4 byte hole here on 64-bit architectures. */ void * __glibc_unused_qhook; void * __glibc_unused_rhook; int res_h_errno; /* last one set for this context */ int _vcsock; /* PRIVATE: for res_send VC i/o */ unsigned int _flags; /* PRIVATE: see below */ /* 4 byte hole here on 64-bit architectures. */ union { char pad[52]; /* On an i386 this means 512b total. */ struct { uint16_t nscount; uint16_t nsmap[MAXNS]; int nssocks[MAXNS]; uint16_t nscount6; uint16_t nsinit; struct sockaddr_in6 *nsaddrs[MAXNS]; #ifdef _LIBC unsigned long long int __glibc_extension_index __attribute__((packed)); #else unsigned int __glibc_reserved[2]; #endif } _ext; } _u; }; typedef struct __res_state *res_state; #endif /* __res_state_defined */ types/struct_rusage.h 0000644 00000010031 15125171642 0010752 0 ustar 00 /* Define struct rusage. Copyright (C) 1994-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef __rusage_defined #define __rusage_defined 1 #include <bits/types.h> #include <bits/types/struct_timeval.h> /* Structure which says how much of each resource has been used. If the system does not keep track of a particular value, the struct field is always zero. */ /* The purpose of all the unions is to have the kernel-compatible layout while keeping the API type as 'long int', and among machines where __syscall_slong_t is not 'long int', this only does the right thing for little-endian ones, like x32. */ struct rusage { /* Total amount of user time used. */ struct timeval ru_utime; /* Total amount of system time used. */ struct timeval ru_stime; /* Maximum resident set size (in kilobytes). */ __extension__ union { long int ru_maxrss; __syscall_slong_t __ru_maxrss_word; }; /* Amount of sharing of text segment memory with other processes (kilobyte-seconds). */ __extension__ union { long int ru_ixrss; __syscall_slong_t __ru_ixrss_word; }; /* Amount of data segment memory used (kilobyte-seconds). */ __extension__ union { long int ru_idrss; __syscall_slong_t __ru_idrss_word; }; /* Amount of stack memory used (kilobyte-seconds). */ __extension__ union { long int ru_isrss; __syscall_slong_t __ru_isrss_word; }; /* Number of soft page faults (i.e. those serviced by reclaiming a page from the list of pages awaiting reallocation. */ __extension__ union { long int ru_minflt; __syscall_slong_t __ru_minflt_word; }; /* Number of hard page faults (i.e. those that required I/O). */ __extension__ union { long int ru_majflt; __syscall_slong_t __ru_majflt_word; }; /* Number of times a process was swapped out of physical memory. */ __extension__ union { long int ru_nswap; __syscall_slong_t __ru_nswap_word; }; /* Number of input operations via the file system. Note: This and `ru_oublock' do not include operations with the cache. */ __extension__ union { long int ru_inblock; __syscall_slong_t __ru_inblock_word; }; /* Number of output operations via the file system. */ __extension__ union { long int ru_oublock; __syscall_slong_t __ru_oublock_word; }; /* Number of IPC messages sent. */ __extension__ union { long int ru_msgsnd; __syscall_slong_t __ru_msgsnd_word; }; /* Number of IPC messages received. */ __extension__ union { long int ru_msgrcv; __syscall_slong_t __ru_msgrcv_word; }; /* Number of signals delivered. */ __extension__ union { long int ru_nsignals; __syscall_slong_t __ru_nsignals_word; }; /* Number of voluntary context switches, i.e. because the process gave up the process before it had to (usually to wait for some resource to be available). */ __extension__ union { long int ru_nvcsw; __syscall_slong_t __ru_nvcsw_word; }; /* Number of involuntary context switches, i.e. a higher priority process became runnable or the current process used up its time slice. */ __extension__ union { long int ru_nivcsw; __syscall_slong_t __ru_nivcsw_word; }; }; #endif types/struct_osockaddr.h 0000644 00000000422 15125171642 0011440 0 ustar 00 #ifndef __osockaddr_defined #define __osockaddr_defined 1 /* This is the 4.3 BSD `struct sockaddr' format, which is used as wire format in the grotty old 4.3 `talk' protocol. */ struct osockaddr { unsigned short int sa_family; unsigned char sa_data[14]; }; #endif types/struct_shmid64_ds.h 0000644 00000002127 15125171642 0011437 0 ustar 00 /* Generic implementation of the shared memory struct shmid_ds. Copyright (C) 2020-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _SYS_SHM_H # error "Never include <bits/types/struct_shmid_ds.h> directly; use <sys/shm.h> instead." #endif #if __TIMESIZE == 64 # define __shmid64_ds shmid_ds #else struct __shmid64_ds { # include <bits/types/struct_shmid64_ds_helper.h> }; #endif types/__sigset_t.h 0000644 00000000316 15125171642 0010204 0 ustar 00 #ifndef ____sigset_t_defined #define ____sigset_t_defined #define _SIGSET_NWORDS (1024 / (8 * sizeof (unsigned long int))) typedef struct { unsigned long int __val[_SIGSET_NWORDS]; } __sigset_t; #endif types/struct_tm.h 0000644 00000001370 15125171642 0010112 0 ustar 00 #ifndef __struct_tm_defined #define __struct_tm_defined 1 #include <bits/types.h> /* ISO C `broken-down time' structure. */ struct tm { int tm_sec; /* Seconds. [0-60] (1 leap second) */ int tm_min; /* Minutes. [0-59] */ int tm_hour; /* Hours. [0-23] */ int tm_mday; /* Day. [1-31] */ int tm_mon; /* Month. [0-11] */ int tm_year; /* Year - 1900. */ int tm_wday; /* Day of week. [0-6] */ int tm_yday; /* Days in year.[0-365] */ int tm_isdst; /* DST. [-1/0/1]*/ # ifdef __USE_MISC long int tm_gmtoff; /* Seconds east of UTC. */ const char *tm_zone; /* Timezone abbreviation. */ # else long int __tm_gmtoff; /* Seconds east of UTC. */ const char *__tm_zone; /* Timezone abbreviation. */ # endif }; #endif types/struct_timespec.h 0000644 00000001543 15125171642 0011305 0 ustar 00 /* NB: Include guard matches what <linux/time.h> uses. */ #ifndef _STRUCT_TIMESPEC #define _STRUCT_TIMESPEC 1 #include <bits/types.h> #include <bits/endian.h> #include <bits/types/time_t.h> /* POSIX.1b structure for a time value. This is like a `struct timeval' but has nanoseconds instead of microseconds. */ struct timespec { #ifdef __USE_TIME_BITS64 __time64_t tv_sec; /* Seconds. */ #else __time_t tv_sec; /* Seconds. */ #endif #if __WORDSIZE == 64 \ || (defined __SYSCALL_WORDSIZE && __SYSCALL_WORDSIZE == 64) \ || (__TIMESIZE == 32 && !defined __USE_TIME_BITS64) __syscall_slong_t tv_nsec; /* Nanoseconds. */ #else # if __BYTE_ORDER == __BIG_ENDIAN int: 32; /* Padding. */ long int tv_nsec; /* Nanoseconds. */ # else long int tv_nsec; /* Nanoseconds. */ int: 32; /* Padding. */ # endif #endif }; #endif types/struct_statx_timestamp.h 0000644 00000002262 15125171642 0012721 0 ustar 00 /* Definition of the generic version of struct statx_timestamp. Copyright (C) 2018-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _SYS_STAT_H # error Never include <bits/types/struct_statx_timestamp.h> directly, include <sys/stat.h> instead. #endif #ifndef __statx_timestamp_defined #define __statx_timestamp_defined 1 struct statx_timestamp { __int64_t tv_sec; __uint32_t tv_nsec; __int32_t __statx_timestamp_pad1[1]; }; #endif /* __statx_timestamp_defined */ types/struct_statx.h 0000644 00000003551 15125171642 0010640 0 ustar 00 /* Definition of the generic version of struct statx. Copyright (C) 2018-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _SYS_STAT_H # error Never include <bits/types/struct_statx.h> directly, include <sys/stat.h> instead. #endif #ifndef __statx_defined #define __statx_defined 1 /* Warning: The kernel may add additional fields to this struct in the future. Only use this struct for calling the statx function, not for storing data. (Expansion will be controlled by the mask argument of the statx function.) */ struct statx { __uint32_t stx_mask; __uint32_t stx_blksize; __uint64_t stx_attributes; __uint32_t stx_nlink; __uint32_t stx_uid; __uint32_t stx_gid; __uint16_t stx_mode; __uint16_t __statx_pad1[1]; __uint64_t stx_ino; __uint64_t stx_size; __uint64_t stx_blocks; __uint64_t stx_attributes_mask; struct statx_timestamp stx_atime; struct statx_timestamp stx_btime; struct statx_timestamp stx_ctime; struct statx_timestamp stx_mtime; __uint32_t stx_rdev_major; __uint32_t stx_rdev_minor; __uint32_t stx_dev_major; __uint32_t stx_dev_minor; __uint64_t __statx_pad2[14]; }; #endif /* __statx_defined */ types/struct_itimerspec.h 0000644 00000000440 15125171642 0011633 0 ustar 00 #ifndef __itimerspec_defined #define __itimerspec_defined 1 #include <bits/types.h> #include <bits/types/struct_timespec.h> /* POSIX.1b structure for timer start values and intervals. */ struct itimerspec { struct timespec it_interval; struct timespec it_value; }; #endif types/__locale_t.h 0000644 00000003272 15125171642 0010151 0 ustar 00 /* Definition of struct __locale_struct and __locale_t. Copyright (C) 1997-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _BITS_TYPES___LOCALE_T_H #define _BITS_TYPES___LOCALE_T_H 1 /* POSIX.1-2008: the locale_t type, representing a locale context (implementation-namespace version). This type should be treated as opaque by applications; some details are exposed for the sake of efficiency in e.g. ctype functions. */ struct __locale_struct { /* Note: LC_ALL is not a valid index into this array. */ struct __locale_data *__locales[13]; /* 13 = __LC_LAST. */ /* To increase the speed of this solution we add some special members. */ const unsigned short int *__ctype_b; const int *__ctype_tolower; const int *__ctype_toupper; /* Note: LC_ALL is not a valid index into this array. */ const char *__names[13]; }; typedef struct __locale_struct *__locale_t; #endif /* bits/types/__locale_t.h */ types/struct_msqid_ds.h 0000644 00000004117 15125171642 0011277 0 ustar 00 /* Generic implementation of the SysV message struct msqid_ds. Copyright (C) 2020-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _SYS_MSG_H # error "Never use <bits/msq.h> directly; include <sys/msg.h> instead." #endif #include <bits/types/time_t.h> /* Structure of record for one message inside the kernel. The type `struct msg' is opaque. */ struct msqid_ds { #ifdef __USE_TIME_BITS64 # include <bits/types/struct_msqid64_ds_helper.h> #else struct ipc_perm msg_perm; /* structure describing operation permission */ # if __TIMESIZE == 32 __time_t msg_stime; /* time of last msgsnd command */ unsigned long int __msg_stime_high; __time_t msg_rtime; /* time of last msgsnd command */ unsigned long int __msg_rtime_high; __time_t msg_ctime; /* time of last change */ unsigned long int __msg_ctime_high; # else __time_t msg_stime; /* time of last msgsnd command */ __time_t msg_rtime; /* time of last msgsnd command */ __time_t msg_ctime; /* time of last change */ # endif __syscall_ulong_t __msg_cbytes; /* current number of bytes on queue */ msgqnum_t msg_qnum; /* number of messages currently on queue */ msglen_t msg_qbytes; /* max number of bytes allowed on queue */ __pid_t msg_lspid; /* pid of last msgsnd() */ __pid_t msg_lrpid; /* pid of last msgrcv() */ __syscall_ulong_t __glibc_reserved4; __syscall_ulong_t __glibc_reserved5; #endif }; types/__fpos64_t.h 0000644 00000000632 15125171642 0010030 0 ustar 00 #ifndef _____fpos64_t_defined #define _____fpos64_t_defined 1 #include <bits/types.h> #include <bits/types/__mbstate_t.h> /* The tag name of this struct is _G_fpos64_t to preserve historic C++ mangled names for functions taking fpos_t and/or fpos64_t arguments. That name should not be used in new code. */ typedef struct _G_fpos64_t { __off64_t __pos; __mbstate_t __state; } __fpos64_t; #endif types/struct_timeval.h 0000644 00000000633 15125171642 0011134 0 ustar 00 #ifndef __timeval_defined #define __timeval_defined 1 #include <bits/types.h> /* A time value that is accurate to the nearest microsecond but also has a range of years. */ struct timeval { #ifdef __USE_TIME_BITS64 __time64_t tv_sec; /* Seconds. */ __suseconds64_t tv_usec; /* Microseconds. */ #else __time_t tv_sec; /* Seconds. */ __suseconds_t tv_usec; /* Microseconds. */ #endif }; #endif types/cookie_io_functions_t.h 0000644 00000005245 15125171642 0012446 0 ustar 00 /* Copyright (C) 1991-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef __cookie_io_functions_t_defined #define __cookie_io_functions_t_defined 1 #include <bits/types.h> /* Functions to do I/O and file management for a stream. */ /* Read NBYTES bytes from COOKIE into a buffer pointed to by BUF. Return number of bytes read. */ typedef __ssize_t cookie_read_function_t (void *__cookie, char *__buf, size_t __nbytes); /* Write NBYTES bytes pointed to by BUF to COOKIE. Write all NBYTES bytes unless there is an error. Return number of bytes written. If there is an error, return 0 and do not write anything. If the file has been opened for append (__mode.__append set), then set the file pointer to the end of the file and then do the write; if not, just write at the current file pointer. */ typedef __ssize_t cookie_write_function_t (void *__cookie, const char *__buf, size_t __nbytes); /* Move COOKIE's file position to *POS bytes from the beginning of the file (if W is SEEK_SET), the current position (if W is SEEK_CUR), or the end of the file (if W is SEEK_END). Set *POS to the new file position. Returns zero if successful, nonzero if not. */ typedef int cookie_seek_function_t (void *__cookie, __off64_t *__pos, int __w); /* Close COOKIE. */ typedef int cookie_close_function_t (void *__cookie); /* The structure with the cookie function pointers. The tag name of this struct is _IO_cookie_io_functions_t to preserve historic C++ mangled names for functions taking cookie_io_functions_t arguments. That name should not be used in new code. */ typedef struct _IO_cookie_io_functions_t { cookie_read_function_t *read; /* Read bytes. */ cookie_write_function_t *write; /* Write bytes. */ cookie_seek_function_t *seek; /* Seek/tell file position. */ cookie_close_function_t *close; /* Close file. */ } cookie_io_functions_t; #endif types/sigset_t.h 0000644 00000000303 15125171642 0007702 0 ustar 00 #ifndef __sigset_t_defined #define __sigset_t_defined 1 #include <bits/types/__sigset_t.h> /* A set of signals to be blocked, unblocked, or waited for. */ typedef __sigset_t sigset_t; #endif types/struct_sched_param.h 0000644 00000002061 15125171642 0011736 0 ustar 00 /* Sched parameter structure. Generic version. Copyright (C) 1996-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _BITS_TYPES_STRUCT_SCHED_PARAM #define _BITS_TYPES_STRUCT_SCHED_PARAM 1 /* Data structure to describe a process' schedulability. */ struct sched_param { int sched_priority; }; #endif /* bits/types/struct_sched_param.h */ types/struct_msqid64_ds.h 0000644 00000002106 15125171642 0011445 0 ustar 00 /* Generic implementation of the SysV message struct msqid64_ds. Copyright (C) 2020-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _SYS_MSG_H # error "Never use <bits/msq.h> directly; include <sys/msg.h> instead." #endif #if __TIMESIZE == 64 # define __msqid64_ds msqid_ds #else struct __msqid64_ds { # include <bits/types/struct_msqid64_ds_helper.h> }; #endif types/struct_shmid64_ds_helper.h 0000644 00000002511 15125171642 0012773 0 ustar 00 /* Common definitions for struct semid_ds with 64-bit time. Copyright (C) 2020-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ struct ipc_perm shm_perm; /* operation permission struct */ size_t shm_segsz; /* size of segment in bytes */ __time64_t shm_atime; /* time of last shmat() */ __time64_t shm_dtime; /* time of last shmdt() */ __time64_t shm_ctime; /* time of last change by shmctl() */ __pid_t shm_cpid; /* pid of creator */ __pid_t shm_lpid; /* pid of last shmop */ shmatt_t shm_nattch; /* number of current attaches */ unsigned long int __glibc_reserved5; unsigned long int __glibc_reserved6; types/struct_timeb.h 0000644 00000000635 15125171642 0010575 0 ustar 00 #ifndef __timeb_defined #define __timeb_defined 1 #include <bits/types/time_t.h> /* Structure returned by the 'ftime' function. */ struct timeb { time_t time; /* Seconds since epoch, as from 'time'. */ unsigned short int millitm; /* Additional milliseconds. */ short int timezone; /* Minutes west of GMT. */ short int dstflag; /* Nonzero if Daylight Savings Time used. */ }; #endif types/struct_msqid64_ds_helper.h 0000644 00000002755 15125171642 0013016 0 ustar 00 /* Common definitions for struct msqid_ds with 64-bit time. Copyright (C) 2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library. If not, see <https://www.gnu.org/licenses/>. */ /* Content of internal __msqid64_ds. */ struct ipc_perm msg_perm; /* structure describing operation permission */ __time64_t msg_stime; /* time of last msgsnd command */ __time64_t msg_rtime; /* time of last msgsnd command */ __time64_t msg_ctime; /* time of last change */ __syscall_ulong_t __msg_cbytes; /* current number of bytes on queue */ msgqnum_t msg_qnum; /* number of messages currently on queue */ msglen_t msg_qbytes; /* max number of bytes allowed on queue */ __pid_t msg_lspid; /* pid of last msgsnd() */ __pid_t msg_lrpid; /* pid of last msgrcv() */ unsigned long int __glibc_reserved4; unsigned long int __glibc_reserved5; types/struct_iovec.h 0000644 00000002052 15125171642 0010575 0 ustar 00 /* Define struct iovec. Copyright (C) 1996-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef __iovec_defined #define __iovec_defined 1 #define __need_size_t #include <stddef.h> /* Structure for scatter/gather I/O. */ struct iovec { void *iov_base; /* Pointer to data. */ size_t iov_len; /* Length of data. */ }; #endif types/struct_shmid_ds.h 0000644 00000003711 15125171642 0011265 0 ustar 00 /* Generic implementation of the shared memory struct shmid_ds. Copyright (C) 2020-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _SYS_SHM_H # error "Never include <bits/types/struct_shmid_ds.h> directly; use <sys/shm.h> instead." #endif /* Data structure describing a shared memory segment. */ struct shmid_ds { #ifdef __USE_TIME_BITS64 # include <bits/types/struct_shmid64_ds_helper.h> #else struct ipc_perm shm_perm; /* operation permission struct */ size_t shm_segsz; /* size of segment in bytes */ # if __TIMESIZE == 32 __time_t shm_atime; /* time of last shmat() */ unsigned long int __shm_atime_high; __time_t shm_dtime; /* time of last shmdt() */ unsigned long int __shm_dtime_high; __time_t shm_ctime; /* time of last change by shmctl() */ unsigned long int __shm_ctime_high; # else __time_t shm_atime; /* time of last shmat() */ __time_t shm_dtime; /* time of last shmdt() */ __time_t shm_ctime; /* time of last change by shmctl() */ # endif __pid_t shm_cpid; /* pid of creator */ __pid_t shm_lpid; /* pid of last shmop */ shmatt_t shm_nattch; /* number of current attaches */ __syscall_ulong_t __glibc_reserved5; __syscall_ulong_t __glibc_reserved6; #endif }; types/__fpos_t.h 0000644 00000000575 15125171642 0007664 0 ustar 00 #ifndef _____fpos_t_defined #define _____fpos_t_defined 1 #include <bits/types.h> #include <bits/types/__mbstate_t.h> /* The tag name of this struct is _G_fpos_t to preserve historic C++ mangled names for functions taking fpos_t arguments. That name should not be used in new code. */ typedef struct _G_fpos_t { __off_t __pos; __mbstate_t __state; } __fpos_t; #endif types/struct_semid_ds.h 0000644 00000002756 15125171642 0011272 0 ustar 00 /* x86 implementation of the semaphore struct semid_ds. Copyright (C) 1995-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _SYS_SEM_H # error "Never include <bits/types/struct_semid_ds.h> directly; use <sys/sem.h> instead." #endif /* Data structure describing a set of semaphores. */ struct semid_ds { #ifdef __USE_TIME_BITS64 # include <bits/types/struct_semid64_ds_helper.h> #else struct ipc_perm sem_perm; /* operation permission struct */ __time_t sem_otime; /* last semop() time */ __syscall_ulong_t __sem_otime_high; __time_t sem_ctime; /* last time changed by semctl() */ __syscall_ulong_t __sem_ctime_high; __syscall_ulong_t sem_nsems; /* number of semaphores in set */ __syscall_ulong_t __glibc_reserved3; __syscall_ulong_t __glibc_reserved4; #endif }; types/struct___jmp_buf_tag.h 0000644 00000002673 15125171642 0012254 0 ustar 00 /* Define struct __jmp_buf_tag. Copyright (C) 1991-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef __jmp_buf_tag_defined #define __jmp_buf_tag_defined 1 #include <bits/setjmp.h> /* Get `__jmp_buf'. */ #include <bits/types/__sigset_t.h> /* Calling environment, plus possibly a saved signal mask. */ struct __jmp_buf_tag { /* NOTE: The machine-dependent definitions of `__sigsetjmp' assume that a `jmp_buf' begins with a `__jmp_buf' and that `__mask_was_saved' follows it. Do not move these members or add others before it. */ __jmp_buf __jmpbuf; /* Calling environment. */ int __mask_was_saved; /* Saved the signal mask? */ __sigset_t __saved_mask; /* Saved signal mask. */ }; #endif siginfo-arch.h 0000644 00000001331 15125171642 0007270 0 ustar 00 /* Architecture-specific adjustments to siginfo_t. x86 version. */ #ifndef _BITS_SIGINFO_ARCH_H #define _BITS_SIGINFO_ARCH_H 1 #if defined __x86_64__ && __WORDSIZE == 32 /* si_utime and si_stime must be 4 byte aligned for x32 to match the kernel. We align siginfo_t to 8 bytes so that si_utime and si_stime are actually aligned to 8 bytes since their offsets are multiple of 8 bytes. Note: with some compilers, the alignment attribute would be ignored if it were put in __SI_CLOCK_T instead of encapsulated in a typedef. */ typedef __clock_t __attribute__ ((__aligned__ (4))) __sigchld_clock_t; # define __SI_ALIGNMENT __attribute__ ((__aligned__ (8))) # define __SI_CLOCK_T __sigchld_clock_t #endif #endif wordsize.h 0000644 00000000672 15125171642 0006574 0 ustar 00 /* Determine the wordsize from the preprocessor defines. */ #if defined __x86_64__ && !defined __ILP32__ # define __WORDSIZE 64 #else # define __WORDSIZE 32 #define __WORDSIZE32_SIZE_ULONG 0 #define __WORDSIZE32_PTRDIFF_LONG 0 #endif #ifdef __x86_64__ # define __WORDSIZE_TIME64_COMPAT32 1 /* Both x86-64 and x32 use the 64-bit system call interface. */ # define __SYSCALL_WORDSIZE 64 #else # define __WORDSIZE_TIME64_COMPAT32 0 #endif libc-header-start.h 0000644 00000010276 15125171642 0010221 0 ustar 00 /* Handle feature test macros at the start of a header. Copyright (C) 2016-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ /* This header is internal to glibc and should not be included outside of glibc headers. Headers including it must define __GLIBC_INTERNAL_STARTING_HEADER_IMPLEMENTATION first. This header cannot have multiple include guards because ISO C feature test macros depend on the definition of the macro when an affected header is included, not when the first system header is included. */ #ifndef __GLIBC_INTERNAL_STARTING_HEADER_IMPLEMENTATION # error "Never include <bits/libc-header-start.h> directly." #endif #undef __GLIBC_INTERNAL_STARTING_HEADER_IMPLEMENTATION #include <features.h> /* ISO/IEC TR 24731-2:2010 defines the __STDC_WANT_LIB_EXT2__ macro. */ #undef __GLIBC_USE_LIB_EXT2 #if (defined __USE_GNU \ || (defined __STDC_WANT_LIB_EXT2__ && __STDC_WANT_LIB_EXT2__ > 0)) # define __GLIBC_USE_LIB_EXT2 1 #else # define __GLIBC_USE_LIB_EXT2 0 #endif /* ISO/IEC TS 18661-1:2014 defines the __STDC_WANT_IEC_60559_BFP_EXT__ macro. Most but not all symbols enabled by that macro in TS 18661-1 are enabled unconditionally in C2X. In C2X, the symbols in Annex F still require a new feature test macro __STDC_WANT_IEC_60559_EXT__ instead (C2X does not define __STDC_WANT_IEC_60559_BFP_EXT__), while a few features from TS 18661-1 are not included in C2X (and thus should depend on __STDC_WANT_IEC_60559_BFP_EXT__ even when C2X features are enabled). __GLIBC_USE (IEC_60559_BFP_EXT) controls those features from TS 18661-1 not included in C2X. __GLIBC_USE (IEC_60559_BFP_EXT_C2X) controls those features from TS 18661-1 that are also included in C2X (with no feature test macro required in C2X). __GLIBC_USE (IEC_60559_EXT) controls those features from TS 18661-1 that are included in C2X but conditional on __STDC_WANT_IEC_60559_EXT__. (There are currently no features conditional on __STDC_WANT_IEC_60559_EXT__ that are not in TS 18661-1.) */ #undef __GLIBC_USE_IEC_60559_BFP_EXT #if defined __USE_GNU || defined __STDC_WANT_IEC_60559_BFP_EXT__ # define __GLIBC_USE_IEC_60559_BFP_EXT 1 #else # define __GLIBC_USE_IEC_60559_BFP_EXT 0 #endif #undef __GLIBC_USE_IEC_60559_BFP_EXT_C2X #if __GLIBC_USE (IEC_60559_BFP_EXT) || __GLIBC_USE (ISOC2X) # define __GLIBC_USE_IEC_60559_BFP_EXT_C2X 1 #else # define __GLIBC_USE_IEC_60559_BFP_EXT_C2X 0 #endif #undef __GLIBC_USE_IEC_60559_EXT #if __GLIBC_USE (IEC_60559_BFP_EXT) || defined __STDC_WANT_IEC_60559_EXT__ # define __GLIBC_USE_IEC_60559_EXT 1 #else # define __GLIBC_USE_IEC_60559_EXT 0 #endif /* ISO/IEC TS 18661-4:2015 defines the __STDC_WANT_IEC_60559_FUNCS_EXT__ macro. Other than the reduction functions, the symbols from this TS are enabled unconditionally in C2X. */ #undef __GLIBC_USE_IEC_60559_FUNCS_EXT #if defined __USE_GNU || defined __STDC_WANT_IEC_60559_FUNCS_EXT__ # define __GLIBC_USE_IEC_60559_FUNCS_EXT 1 #else # define __GLIBC_USE_IEC_60559_FUNCS_EXT 0 #endif #undef __GLIBC_USE_IEC_60559_FUNCS_EXT_C2X #if __GLIBC_USE (IEC_60559_FUNCS_EXT) || __GLIBC_USE (ISOC2X) # define __GLIBC_USE_IEC_60559_FUNCS_EXT_C2X 1 #else # define __GLIBC_USE_IEC_60559_FUNCS_EXT_C2X 0 #endif /* ISO/IEC TS 18661-3:2015 defines the __STDC_WANT_IEC_60559_TYPES_EXT__ macro. */ #undef __GLIBC_USE_IEC_60559_TYPES_EXT #if defined __USE_GNU || defined __STDC_WANT_IEC_60559_TYPES_EXT__ # define __GLIBC_USE_IEC_60559_TYPES_EXT 1 #else # define __GLIBC_USE_IEC_60559_TYPES_EXT 0 #endif sigcontext.h 0000644 00000010252 15125171642 0007110 0 ustar 00 /* Copyright (C) 2002-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _BITS_SIGCONTEXT_H #define _BITS_SIGCONTEXT_H 1 #if !defined _SIGNAL_H && !defined _SYS_UCONTEXT_H # error "Never use <bits/sigcontext.h> directly; include <signal.h> instead." #endif #include <bits/types.h> #define FP_XSTATE_MAGIC1 0x46505853U #define FP_XSTATE_MAGIC2 0x46505845U #define FP_XSTATE_MAGIC2_SIZE sizeof (FP_XSTATE_MAGIC2) struct _fpx_sw_bytes { __uint32_t magic1; __uint32_t extended_size; __uint64_t xstate_bv; __uint32_t xstate_size; __uint32_t __glibc_reserved1[7]; }; struct _fpreg { unsigned short significand[4]; unsigned short exponent; }; struct _fpxreg { unsigned short significand[4]; unsigned short exponent; unsigned short __glibc_reserved1[3]; }; struct _xmmreg { __uint32_t element[4]; }; #ifndef __x86_64__ struct _fpstate { /* Regular FPU environment. */ __uint32_t cw; __uint32_t sw; __uint32_t tag; __uint32_t ipoff; __uint32_t cssel; __uint32_t dataoff; __uint32_t datasel; struct _fpreg _st[8]; unsigned short status; unsigned short magic; /* FXSR FPU environment. */ __uint32_t _fxsr_env[6]; __uint32_t mxcsr; __uint32_t __glibc_reserved1; struct _fpxreg _fxsr_st[8]; struct _xmmreg _xmm[8]; __uint32_t __glibc_reserved2[56]; }; #ifndef sigcontext_struct /* Kernel headers before 2.1.1 define a struct sigcontext_struct, but we need sigcontext. Some packages have come to rely on sigcontext_struct being defined on 32-bit x86, so define this for their benefit. */ # define sigcontext_struct sigcontext #endif #define X86_FXSR_MAGIC 0x0000 struct sigcontext { unsigned short gs, __gsh; unsigned short fs, __fsh; unsigned short es, __esh; unsigned short ds, __dsh; unsigned long edi; unsigned long esi; unsigned long ebp; unsigned long esp; unsigned long ebx; unsigned long edx; unsigned long ecx; unsigned long eax; unsigned long trapno; unsigned long err; unsigned long eip; unsigned short cs, __csh; unsigned long eflags; unsigned long esp_at_signal; unsigned short ss, __ssh; struct _fpstate * fpstate; unsigned long oldmask; unsigned long cr2; }; #else /* __x86_64__ */ struct _fpstate { /* FPU environment matching the 64-bit FXSAVE layout. */ __uint16_t cwd; __uint16_t swd; __uint16_t ftw; __uint16_t fop; __uint64_t rip; __uint64_t rdp; __uint32_t mxcsr; __uint32_t mxcr_mask; struct _fpxreg _st[8]; struct _xmmreg _xmm[16]; __uint32_t __glibc_reserved1[24]; }; struct sigcontext { __uint64_t r8; __uint64_t r9; __uint64_t r10; __uint64_t r11; __uint64_t r12; __uint64_t r13; __uint64_t r14; __uint64_t r15; __uint64_t rdi; __uint64_t rsi; __uint64_t rbp; __uint64_t rbx; __uint64_t rdx; __uint64_t rax; __uint64_t rcx; __uint64_t rsp; __uint64_t rip; __uint64_t eflags; unsigned short cs; unsigned short gs; unsigned short fs; unsigned short __pad0; __uint64_t err; __uint64_t trapno; __uint64_t oldmask; __uint64_t cr2; __extension__ union { struct _fpstate * fpstate; __uint64_t __fpstate_word; }; __uint64_t __reserved1 [8]; }; #endif /* __x86_64__ */ struct _xsave_hdr { __uint64_t xstate_bv; __uint64_t __glibc_reserved1[2]; __uint64_t __glibc_reserved2[5]; }; struct _ymmh_state { __uint32_t ymmh_space[64]; }; struct _xstate { struct _fpstate fpstate; struct _xsave_hdr xstate_hdr; struct _ymmh_state ymmh; }; #endif /* _BITS_SIGCONTEXT_H */ procfs.h 0000644 00000003751 15125171642 0006223 0 ustar 00 /* Types for registers for sys/procfs.h. x86 version. Copyright (C) 2001-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _SYS_PROCFS_H # error "Never include <bits/procfs.h> directly; use <sys/procfs.h> instead." #endif /* Type for a general-purpose register. */ #ifdef __x86_64__ __extension__ typedef unsigned long long elf_greg_t; #else typedef unsigned long elf_greg_t; #endif /* And the whole bunch of them. We could have used `struct user_regs_struct' directly in the typedef, but tradition says that the register set is an array, which does have some peculiar semantics, so leave it that way. */ #define ELF_NGREG (sizeof (struct user_regs_struct) / sizeof (elf_greg_t)) typedef elf_greg_t elf_gregset_t[ELF_NGREG]; #ifndef __x86_64__ /* Register set for the floating-point registers. */ typedef struct user_fpregs_struct elf_fpregset_t; /* Register set for the extended floating-point registers. Includes the Pentium III SSE registers in addition to the classic floating-point stuff. */ typedef struct user_fpxregs_struct elf_fpxregset_t; #else /* Register set for the extended floating-point registers. Includes the Pentium III SSE registers in addition to the classic floating-point stuff. */ typedef struct user_fpregs_struct elf_fpregset_t; #endif termios-baud.h 0000644 00000003440 15125171642 0007315 0 ustar 00 /* termios baud rate selection definitions. Linux/generic version. Copyright (C) 2019-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library. If not, see <https://www.gnu.org/licenses/>. */ #ifndef _TERMIOS_H # error "Never include <bits/termios-baud.h> directly; use <termios.h> instead." #endif #ifdef __USE_MISC # define CBAUD 000000010017 /* Baud speed mask (not in POSIX). */ # define CBAUDEX 000000010000 /* Extra baud speed mask, included in CBAUD. (not in POSIX). */ # define CIBAUD 002003600000 /* Input baud rate (not used). */ # define CMSPAR 010000000000 /* Mark or space (stick) parity. */ # define CRTSCTS 020000000000 /* Flow control. */ #endif /* Extra output baud rates (not in POSIX). */ #define B57600 0010001 #define B115200 0010002 #define B230400 0010003 #define B460800 0010004 #define B500000 0010005 #define B576000 0010006 #define B921600 0010007 #define B1000000 0010010 #define B1152000 0010011 #define B1500000 0010012 #define B2000000 0010013 #define B2500000 0010014 #define B3000000 0010015 #define B3500000 0010016 #define B4000000 0010017 #define __MAX_BAUD B4000000 termios.h 0000644 00000004170 15125171642 0006405 0 ustar 00 /* termios type and macro definitions. Linux version. Copyright (C) 1993-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _TERMIOS_H # error "Never include <bits/termios.h> directly; use <termios.h> instead." #endif typedef unsigned char cc_t; typedef unsigned int speed_t; typedef unsigned int tcflag_t; #include <bits/termios-struct.h> #include <bits/termios-c_cc.h> #include <bits/termios-c_iflag.h> #include <bits/termios-c_oflag.h> /* c_cflag bit meaning */ #define B0 0000000 /* hang up */ #define B50 0000001 #define B75 0000002 #define B110 0000003 #define B134 0000004 #define B150 0000005 #define B200 0000006 #define B300 0000007 #define B600 0000010 #define B1200 0000011 #define B1800 0000012 #define B2400 0000013 #define B4800 0000014 #define B9600 0000015 #define B19200 0000016 #define B38400 0000017 #ifdef __USE_MISC # define EXTA B19200 # define EXTB B38400 #endif #include <bits/termios-baud.h> #include <bits/termios-c_cflag.h> #include <bits/termios-c_lflag.h> #ifdef __USE_MISC /* ioctl (fd, TIOCSERGETLSR, &result) where result may be as below */ # define TIOCSER_TEMT 0x01 /* Transmitter physically empty */ #endif /* tcflow() and TCXONC use these */ #define TCOOFF 0 #define TCOON 1 #define TCIOFF 2 #define TCION 3 /* tcflush() and TCFLSH use these */ #define TCIFLUSH 0 #define TCOFLUSH 1 #define TCIOFLUSH 2 #include <bits/termios-tcflow.h> #include <bits/termios-misc.h> setjmp.h 0000644 00000002407 15125171642 0006226 0 ustar 00 /* Copyright (C) 2001-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ /* Define the machine-dependent type `jmp_buf'. x86-64 version. */ #ifndef _BITS_SETJMP_H #define _BITS_SETJMP_H 1 #if !defined _SETJMP_H && !defined _PTHREAD_H # error "Never include <bits/setjmp.h> directly; use <setjmp.h> instead." #endif #include <bits/wordsize.h> #ifndef _ASM # if __WORDSIZE == 64 typedef long int __jmp_buf[8]; # elif defined __x86_64__ __extension__ typedef long long int __jmp_buf[8]; # else typedef int __jmp_buf[6]; # endif #endif #endif /* bits/setjmp.h */ termios-c_cflag.h 0000644 00000002316 15125171642 0007761 0 ustar 00 /* termios control mode definitions. Linux/generic version. Copyright (C) 2019-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library. If not, see <https://www.gnu.org/licenses/>. */ #ifndef _TERMIOS_H # error "Never include <bits/termios-c_cflag.h> directly; use <termios.h> instead." #endif /* c_cflag bits. */ #define CSIZE 0000060 #define CS5 0000000 #define CS6 0000020 #define CS7 0000040 #define CS8 0000060 #define CSTOPB 0000100 #define CREAD 0000200 #define PARENB 0000400 #define PARODD 0001000 #define HUPCL 0002000 #define CLOCAL 0004000 wchar2.h 0000644 00000034755 15125171642 0006125 0 ustar 00 /* Checking macros for wchar functions. Copyright (C) 2005-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _WCHAR_H # error "Never include <bits/wchar2.h> directly; use <wchar.h> instead." #endif extern wchar_t *__REDIRECT_NTH (__wmemcpy_alias, (wchar_t *__restrict __s1, const wchar_t *__restrict __s2, size_t __n), wmemcpy); extern wchar_t *__REDIRECT_NTH (__wmemcpy_chk_warn, (wchar_t *__restrict __s1, const wchar_t *__restrict __s2, size_t __n, size_t __ns1), __wmemcpy_chk) __warnattr ("wmemcpy called with length bigger than size of destination " "buffer"); __fortify_function wchar_t * __NTH (wmemcpy (wchar_t *__restrict __s1, const wchar_t *__restrict __s2, size_t __n)) { return __glibc_fortify_n (wmemcpy, __n, sizeof (wchar_t), __glibc_objsize0 (__s1), __s1, __s2, __n); } extern wchar_t *__REDIRECT_NTH (__wmemmove_alias, (wchar_t *__s1, const wchar_t *__s2, size_t __n), wmemmove); extern wchar_t *__REDIRECT_NTH (__wmemmove_chk_warn, (wchar_t *__s1, const wchar_t *__s2, size_t __n, size_t __ns1), __wmemmove_chk) __warnattr ("wmemmove called with length bigger than size of destination " "buffer"); __fortify_function wchar_t * __NTH (wmemmove (wchar_t *__s1, const wchar_t *__s2, size_t __n)) { return __glibc_fortify_n (wmemmove, __n, sizeof (wchar_t), __glibc_objsize0 (__s1), __s1, __s2, __n); } #ifdef __USE_GNU extern wchar_t *__REDIRECT_NTH (__wmempcpy_alias, (wchar_t *__restrict __s1, const wchar_t *__restrict __s2, size_t __n), wmempcpy); extern wchar_t *__REDIRECT_NTH (__wmempcpy_chk_warn, (wchar_t *__restrict __s1, const wchar_t *__restrict __s2, size_t __n, size_t __ns1), __wmempcpy_chk) __warnattr ("wmempcpy called with length bigger than size of destination " "buffer"); __fortify_function wchar_t * __NTH (wmempcpy (wchar_t *__restrict __s1, const wchar_t *__restrict __s2, size_t __n)) { return __glibc_fortify_n (wmempcpy, __n, sizeof (wchar_t), __glibc_objsize0 (__s1), __s1, __s2, __n); } #endif extern wchar_t *__REDIRECT_NTH (__wmemset_alias, (wchar_t *__s, wchar_t __c, size_t __n), wmemset); extern wchar_t *__REDIRECT_NTH (__wmemset_chk_warn, (wchar_t *__s, wchar_t __c, size_t __n, size_t __ns), __wmemset_chk) __warnattr ("wmemset called with length bigger than size of destination " "buffer"); __fortify_function wchar_t * __NTH (wmemset (wchar_t *__s, wchar_t __c, size_t __n)) { return __glibc_fortify_n (wmemset, __n, sizeof (wchar_t), __glibc_objsize0 (__s), __s, __c, __n); } extern wchar_t *__REDIRECT_NTH (__wcscpy_alias, (wchar_t *__restrict __dest, const wchar_t *__restrict __src), wcscpy); __fortify_function wchar_t * __NTH (wcscpy (wchar_t *__restrict __dest, const wchar_t *__restrict __src)) { size_t sz = __glibc_objsize (__dest); if (sz != (size_t) -1) return __wcscpy_chk (__dest, __src, sz / sizeof (wchar_t)); return __wcscpy_alias (__dest, __src); } extern wchar_t *__REDIRECT_NTH (__wcpcpy_alias, (wchar_t *__restrict __dest, const wchar_t *__restrict __src), wcpcpy); __fortify_function wchar_t * __NTH (wcpcpy (wchar_t *__restrict __dest, const wchar_t *__restrict __src)) { size_t sz = __glibc_objsize (__dest); if (sz != (size_t) -1) return __wcpcpy_chk (__dest, __src, sz / sizeof (wchar_t)); return __wcpcpy_alias (__dest, __src); } extern wchar_t *__REDIRECT_NTH (__wcsncpy_alias, (wchar_t *__restrict __dest, const wchar_t *__restrict __src, size_t __n), wcsncpy); extern wchar_t *__REDIRECT_NTH (__wcsncpy_chk_warn, (wchar_t *__restrict __dest, const wchar_t *__restrict __src, size_t __n, size_t __destlen), __wcsncpy_chk) __warnattr ("wcsncpy called with length bigger than size of destination " "buffer"); __fortify_function wchar_t * __NTH (wcsncpy (wchar_t *__restrict __dest, const wchar_t *__restrict __src, size_t __n)) { return __glibc_fortify_n (wcsncpy, __n, sizeof (wchar_t), __glibc_objsize (__dest), __dest, __src, __n); } extern wchar_t *__REDIRECT_NTH (__wcpncpy_alias, (wchar_t *__restrict __dest, const wchar_t *__restrict __src, size_t __n), wcpncpy); extern wchar_t *__REDIRECT_NTH (__wcpncpy_chk_warn, (wchar_t *__restrict __dest, const wchar_t *__restrict __src, size_t __n, size_t __destlen), __wcpncpy_chk) __warnattr ("wcpncpy called with length bigger than size of destination " "buffer"); __fortify_function wchar_t * __NTH (wcpncpy (wchar_t *__restrict __dest, const wchar_t *__restrict __src, size_t __n)) { return __glibc_fortify_n (wcpncpy, __n, sizeof (wchar_t), __glibc_objsize (__dest), __dest, __src, __n); } extern wchar_t *__REDIRECT_NTH (__wcscat_alias, (wchar_t *__restrict __dest, const wchar_t *__restrict __src), wcscat); __fortify_function wchar_t * __NTH (wcscat (wchar_t *__restrict __dest, const wchar_t *__restrict __src)) { size_t sz = __glibc_objsize (__dest); if (sz != (size_t) -1) return __wcscat_chk (__dest, __src, sz / sizeof (wchar_t)); return __wcscat_alias (__dest, __src); } extern wchar_t *__REDIRECT_NTH (__wcsncat_alias, (wchar_t *__restrict __dest, const wchar_t *__restrict __src, size_t __n), wcsncat); __fortify_function wchar_t * __NTH (wcsncat (wchar_t *__restrict __dest, const wchar_t *__restrict __src, size_t __n)) { size_t sz = __glibc_objsize (__dest); if (sz != (size_t) -1) return __wcsncat_chk (__dest, __src, __n, sz / sizeof (wchar_t)); return __wcsncat_alias (__dest, __src, __n); } extern int __REDIRECT_NTH_LDBL (__swprintf_alias, (wchar_t *__restrict __s, size_t __n, const wchar_t *__restrict __fmt, ...), swprintf); #ifdef __va_arg_pack __fortify_function int __NTH (swprintf (wchar_t *__restrict __s, size_t __n, const wchar_t *__restrict __fmt, ...)) { size_t sz = __glibc_objsize (__s); if (sz != (size_t) -1 || __USE_FORTIFY_LEVEL > 1) return __swprintf_chk (__s, __n, __USE_FORTIFY_LEVEL - 1, sz / sizeof (wchar_t), __fmt, __va_arg_pack ()); return __swprintf_alias (__s, __n, __fmt, __va_arg_pack ()); } #elif !defined __cplusplus /* XXX We might want to have support in gcc for swprintf. */ # define swprintf(s, n, ...) \ (__glibc_objsize (s) != (size_t) -1 || __USE_FORTIFY_LEVEL > 1 \ ? __swprintf_chk (s, n, __USE_FORTIFY_LEVEL - 1, \ __glibc_objsize (s) / sizeof (wchar_t), __VA_ARGS__) \ : swprintf (s, n, __VA_ARGS__)) #endif extern int __REDIRECT_NTH_LDBL (__vswprintf_alias, (wchar_t *__restrict __s, size_t __n, const wchar_t *__restrict __fmt, __gnuc_va_list __ap), vswprintf); __fortify_function int __NTH (vswprintf (wchar_t *__restrict __s, size_t __n, const wchar_t *__restrict __fmt, __gnuc_va_list __ap)) { size_t sz = __glibc_objsize (__s); if (sz != (size_t) -1 || __USE_FORTIFY_LEVEL > 1) return __vswprintf_chk (__s, __n, __USE_FORTIFY_LEVEL - 1, sz / sizeof (wchar_t), __fmt, __ap); return __vswprintf_alias (__s, __n, __fmt, __ap); } #if __USE_FORTIFY_LEVEL > 1 # ifdef __va_arg_pack __fortify_function int wprintf (const wchar_t *__restrict __fmt, ...) { return __wprintf_chk (__USE_FORTIFY_LEVEL - 1, __fmt, __va_arg_pack ()); } __fortify_function int fwprintf (__FILE *__restrict __stream, const wchar_t *__restrict __fmt, ...) { return __fwprintf_chk (__stream, __USE_FORTIFY_LEVEL - 1, __fmt, __va_arg_pack ()); } # elif !defined __cplusplus # define wprintf(...) \ __wprintf_chk (__USE_FORTIFY_LEVEL - 1, __VA_ARGS__) # define fwprintf(stream, ...) \ __fwprintf_chk (stream, __USE_FORTIFY_LEVEL - 1, __VA_ARGS__) # endif __fortify_function int vwprintf (const wchar_t *__restrict __fmt, __gnuc_va_list __ap) { return __vwprintf_chk (__USE_FORTIFY_LEVEL - 1, __fmt, __ap); } __fortify_function int vfwprintf (__FILE *__restrict __stream, const wchar_t *__restrict __fmt, __gnuc_va_list __ap) { return __vfwprintf_chk (__stream, __USE_FORTIFY_LEVEL - 1, __fmt, __ap); } #endif extern wchar_t *__REDIRECT (__fgetws_alias, (wchar_t *__restrict __s, int __n, __FILE *__restrict __stream), fgetws) __wur; extern wchar_t *__REDIRECT (__fgetws_chk_warn, (wchar_t *__restrict __s, size_t __size, int __n, __FILE *__restrict __stream), __fgetws_chk) __wur __warnattr ("fgetws called with bigger size than length " "of destination buffer"); __fortify_function __wur wchar_t * fgetws (wchar_t *__restrict __s, int __n, __FILE *__restrict __stream) { size_t sz = __glibc_objsize (__s); if (__glibc_safe_or_unknown_len (__n, sizeof (wchar_t), sz)) return __fgetws_alias (__s, __n, __stream); if (__glibc_unsafe_len (__n, sizeof (wchar_t), sz)) return __fgetws_chk_warn (__s, sz / sizeof (wchar_t), __n, __stream); return __fgetws_chk (__s, sz / sizeof (wchar_t), __n, __stream); } #ifdef __USE_GNU extern wchar_t *__REDIRECT (__fgetws_unlocked_alias, (wchar_t *__restrict __s, int __n, __FILE *__restrict __stream), fgetws_unlocked) __wur; extern wchar_t *__REDIRECT (__fgetws_unlocked_chk_warn, (wchar_t *__restrict __s, size_t __size, int __n, __FILE *__restrict __stream), __fgetws_unlocked_chk) __wur __warnattr ("fgetws_unlocked called with bigger size than length " "of destination buffer"); __fortify_function __wur wchar_t * fgetws_unlocked (wchar_t *__restrict __s, int __n, __FILE *__restrict __stream) { size_t sz = __glibc_objsize (__s); if (__glibc_safe_or_unknown_len (__n, sizeof (wchar_t), sz)) return __fgetws_unlocked_alias (__s, __n, __stream); if (__glibc_unsafe_len (__n, sizeof (wchar_t), sz)) return __fgetws_unlocked_chk_warn (__s, sz / sizeof (wchar_t), __n, __stream); return __fgetws_unlocked_chk (__s, sz / sizeof (wchar_t), __n, __stream); } #endif extern size_t __REDIRECT_NTH (__wcrtomb_alias, (char *__restrict __s, wchar_t __wchar, mbstate_t *__restrict __ps), wcrtomb) __wur; __fortify_function __wur size_t __NTH (wcrtomb (char *__restrict __s, wchar_t __wchar, mbstate_t *__restrict __ps)) { /* We would have to include <limits.h> to get a definition of MB_LEN_MAX. But this would only disturb the namespace. So we define our own version here. */ #define __WCHAR_MB_LEN_MAX 16 #if defined MB_LEN_MAX && MB_LEN_MAX != __WCHAR_MB_LEN_MAX # error "Assumed value of MB_LEN_MAX wrong" #endif if (__glibc_objsize (__s) != (size_t) -1 && __WCHAR_MB_LEN_MAX > __glibc_objsize (__s)) return __wcrtomb_chk (__s, __wchar, __ps, __glibc_objsize (__s)); return __wcrtomb_alias (__s, __wchar, __ps); } extern size_t __REDIRECT_NTH (__mbsrtowcs_alias, (wchar_t *__restrict __dst, const char **__restrict __src, size_t __len, mbstate_t *__restrict __ps), mbsrtowcs); extern size_t __REDIRECT_NTH (__mbsrtowcs_chk_warn, (wchar_t *__restrict __dst, const char **__restrict __src, size_t __len, mbstate_t *__restrict __ps, size_t __dstlen), __mbsrtowcs_chk) __warnattr ("mbsrtowcs called with dst buffer smaller than len " "* sizeof (wchar_t)"); __fortify_function size_t __NTH (mbsrtowcs (wchar_t *__restrict __dst, const char **__restrict __src, size_t __len, mbstate_t *__restrict __ps)) { return __glibc_fortify_n (mbsrtowcs, __len, sizeof (wchar_t), __glibc_objsize (__dst), __dst, __src, __len, __ps); } extern size_t __REDIRECT_NTH (__wcsrtombs_alias, (char *__restrict __dst, const wchar_t **__restrict __src, size_t __len, mbstate_t *__restrict __ps), wcsrtombs); extern size_t __REDIRECT_NTH (__wcsrtombs_chk_warn, (char *__restrict __dst, const wchar_t **__restrict __src, size_t __len, mbstate_t *__restrict __ps, size_t __dstlen), __wcsrtombs_chk) __warnattr ("wcsrtombs called with dst buffer smaller than len"); __fortify_function size_t __NTH (wcsrtombs (char *__restrict __dst, const wchar_t **__restrict __src, size_t __len, mbstate_t *__restrict __ps)) { return __glibc_fortify (wcsrtombs, __len, sizeof (char), __glibc_objsize (__dst), __dst, __src, __len, __ps); } #ifdef __USE_XOPEN2K8 extern size_t __REDIRECT_NTH (__mbsnrtowcs_alias, (wchar_t *__restrict __dst, const char **__restrict __src, size_t __nmc, size_t __len, mbstate_t *__restrict __ps), mbsnrtowcs); extern size_t __REDIRECT_NTH (__mbsnrtowcs_chk_warn, (wchar_t *__restrict __dst, const char **__restrict __src, size_t __nmc, size_t __len, mbstate_t *__restrict __ps, size_t __dstlen), __mbsnrtowcs_chk) __warnattr ("mbsnrtowcs called with dst buffer smaller than len " "* sizeof (wchar_t)"); __fortify_function size_t __NTH (mbsnrtowcs (wchar_t *__restrict __dst, const char **__restrict __src, size_t __nmc, size_t __len, mbstate_t *__restrict __ps)) { return __glibc_fortify_n (mbsnrtowcs, __len, sizeof (wchar_t), __glibc_objsize (__dst), __dst, __src, __nmc, __len, __ps); } extern size_t __REDIRECT_NTH (__wcsnrtombs_alias, (char *__restrict __dst, const wchar_t **__restrict __src, size_t __nwc, size_t __len, mbstate_t *__restrict __ps), wcsnrtombs); extern size_t __REDIRECT_NTH (__wcsnrtombs_chk_warn, (char *__restrict __dst, const wchar_t **__restrict __src, size_t __nwc, size_t __len, mbstate_t *__restrict __ps, size_t __dstlen), __wcsnrtombs_chk) __warnattr ("wcsnrtombs called with dst buffer smaller than len"); __fortify_function size_t __NTH (wcsnrtombs (char *__restrict __dst, const wchar_t **__restrict __src, size_t __nwc, size_t __len, mbstate_t *__restrict __ps)) { return __glibc_fortify (wcsnrtombs, __len, sizeof (char), __glibc_objsize (__dst), __dst, __src, __nwc, __len, __ps); } #endif struct_stat_time64_helper.h 0000644 00000005051 15125171642 0012030 0 ustar 00 /* Definition for helper to define struct stat with 64-bit time. Copyright (C) 2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library. If not, see <https://www.gnu.org/licenses/>. */ /* Content of internal __stat64_t64 struct. */ __dev_t st_dev; /* Device. */ __ino64_t st_ino; /* file serial number. */ __mode_t st_mode; /* File mode. */ __nlink_t st_nlink; /* Link count. */ __uid_t st_uid; /* User ID of the file's owner. */ __gid_t st_gid; /* Group ID of the file's group. */ __dev_t st_rdev; /* Device number, if device. */ __off64_t st_size; /* Size of file, in bytes. */ __blksize_t st_blksize; /* Optimal block size for I/O. */ __blkcnt64_t st_blocks; /* Number 512-byte blocks allocated. */ #ifdef __USE_XOPEN2K8 # ifndef __struct_timespec # define __struct_timespec struct timespec # endif /* Nanosecond resolution timestamps are stored in a format equivalent to 'struct timespec'. This is the type used whenever possible but the Unix namespace rules do not allow the identifier 'timespec' to appear in the <sys/stat.h> header. Therefore we have to handle the use of this header in strictly standard-compliant sources special. */ __struct_timespec st_atim; __struct_timespec st_mtim; __struct_timespec st_ctim; # define st_atime st_atim.tv_sec # define st_mtime st_mtim.tv_sec # define st_ctime st_ctim.tv_sec # undef __struct_timespec #else /* The definition should be equal to the 'struct __timespec64' internal layout. */ # if __BYTE_ORDER == __BIG_ENDIAN # define __fieldts64(name) \ __time64_t name; __int32_t :32; __int32_t name ## nsec # else # define __fieldts64(name) \ __time64_t name; __int32_t name ## nsec; __int32_t :32 # endif __fieldts64 (st_atime); __fieldts64 (st_mtime); __fieldts64 (st_ctime); unsigned long int __glibc_reserved4; unsigned long int __glibc_reserved5; # undef __fieldts64 #endif siginfo-consts.h 0000644 00000015574 15125171642 0007702 0 ustar 00 /* siginfo constants. Linux version. Copyright (C) 1997-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _BITS_SIGINFO_CONSTS_H #define _BITS_SIGINFO_CONSTS_H 1 #ifndef _SIGNAL_H #error "Don't include <bits/siginfo-consts.h> directly; use <signal.h> instead." #endif /* Most of these constants are uniform across all architectures, but there is one exception. */ #include <bits/siginfo-arch.h> #ifndef __SI_ASYNCIO_AFTER_SIGIO # define __SI_ASYNCIO_AFTER_SIGIO 1 #endif /* Values for `si_code'. Positive values are reserved for kernel-generated signals. */ enum { SI_ASYNCNL = -60, /* Sent by asynch name lookup completion. */ SI_DETHREAD = -7, /* Sent by execve killing subsidiary threads. */ SI_TKILL, /* Sent by tkill. */ SI_SIGIO, /* Sent by queued SIGIO. */ #if __SI_ASYNCIO_AFTER_SIGIO SI_ASYNCIO, /* Sent by AIO completion. */ SI_MESGQ, /* Sent by real time mesq state change. */ SI_TIMER, /* Sent by timer expiration. */ #else SI_MESGQ, SI_TIMER, SI_ASYNCIO, #endif SI_QUEUE, /* Sent by sigqueue. */ SI_USER, /* Sent by kill, sigsend. */ SI_KERNEL = 0x80 /* Send by kernel. */ #define SI_ASYNCNL SI_ASYNCNL #define SI_DETHREAD SI_DETHREAD #define SI_TKILL SI_TKILL #define SI_SIGIO SI_SIGIO #define SI_ASYNCIO SI_ASYNCIO #define SI_MESGQ SI_MESGQ #define SI_TIMER SI_TIMER #define SI_ASYNCIO SI_ASYNCIO #define SI_QUEUE SI_QUEUE #define SI_USER SI_USER #define SI_KERNEL SI_KERNEL }; # if defined __USE_XOPEN_EXTENDED || defined __USE_XOPEN2K8 /* `si_code' values for SIGILL signal. */ enum { ILL_ILLOPC = 1, /* Illegal opcode. */ # define ILL_ILLOPC ILL_ILLOPC ILL_ILLOPN, /* Illegal operand. */ # define ILL_ILLOPN ILL_ILLOPN ILL_ILLADR, /* Illegal addressing mode. */ # define ILL_ILLADR ILL_ILLADR ILL_ILLTRP, /* Illegal trap. */ # define ILL_ILLTRP ILL_ILLTRP ILL_PRVOPC, /* Privileged opcode. */ # define ILL_PRVOPC ILL_PRVOPC ILL_PRVREG, /* Privileged register. */ # define ILL_PRVREG ILL_PRVREG ILL_COPROC, /* Coprocessor error. */ # define ILL_COPROC ILL_COPROC ILL_BADSTK, /* Internal stack error. */ # define ILL_BADSTK ILL_BADSTK ILL_BADIADDR /* Unimplemented instruction address. */ # define ILL_BADIADDR ILL_BADIADDR }; /* `si_code' values for SIGFPE signal. */ enum { FPE_INTDIV = 1, /* Integer divide by zero. */ # define FPE_INTDIV FPE_INTDIV FPE_INTOVF, /* Integer overflow. */ # define FPE_INTOVF FPE_INTOVF FPE_FLTDIV, /* Floating point divide by zero. */ # define FPE_FLTDIV FPE_FLTDIV FPE_FLTOVF, /* Floating point overflow. */ # define FPE_FLTOVF FPE_FLTOVF FPE_FLTUND, /* Floating point underflow. */ # define FPE_FLTUND FPE_FLTUND FPE_FLTRES, /* Floating point inexact result. */ # define FPE_FLTRES FPE_FLTRES FPE_FLTINV, /* Floating point invalid operation. */ # define FPE_FLTINV FPE_FLTINV FPE_FLTSUB, /* Subscript out of range. */ # define FPE_FLTSUB FPE_FLTSUB FPE_FLTUNK = 14, /* Undiagnosed floating-point exception. */ # define FPE_FLTUNK FPE_FLTUNK FPE_CONDTRAP /* Trap on condition. */ # define FPE_CONDTRAP FPE_CONDTRAP }; /* `si_code' values for SIGSEGV signal. */ enum { SEGV_MAPERR = 1, /* Address not mapped to object. */ # define SEGV_MAPERR SEGV_MAPERR SEGV_ACCERR, /* Invalid permissions for mapped object. */ # define SEGV_ACCERR SEGV_ACCERR SEGV_BNDERR, /* Bounds checking failure. */ # define SEGV_BNDERR SEGV_BNDERR SEGV_PKUERR, /* Protection key checking failure. */ # define SEGV_PKUERR SEGV_PKUERR SEGV_ACCADI, /* ADI not enabled for mapped object. */ # define SEGV_ACCADI SEGV_ACCADI SEGV_ADIDERR, /* Disrupting MCD error. */ # define SEGV_ADIDERR SEGV_ADIDERR SEGV_ADIPERR, /* Precise MCD exception. */ # define SEGV_ADIPERR SEGV_ADIPERR SEGV_MTEAERR, /* Asynchronous ARM MTE error. */ # define SEGV_MTEAERR SEGV_MTEAERR SEGV_MTESERR /* Synchronous ARM MTE exception. */ # define SEGV_MTESERR SEGV_MTESERR }; /* `si_code' values for SIGBUS signal. */ enum { BUS_ADRALN = 1, /* Invalid address alignment. */ # define BUS_ADRALN BUS_ADRALN BUS_ADRERR, /* Non-existant physical address. */ # define BUS_ADRERR BUS_ADRERR BUS_OBJERR, /* Object specific hardware error. */ # define BUS_OBJERR BUS_OBJERR BUS_MCEERR_AR, /* Hardware memory error: action required. */ # define BUS_MCEERR_AR BUS_MCEERR_AR BUS_MCEERR_AO /* Hardware memory error: action optional. */ # define BUS_MCEERR_AO BUS_MCEERR_AO }; # endif # ifdef __USE_XOPEN_EXTENDED /* `si_code' values for SIGTRAP signal. */ enum { TRAP_BRKPT = 1, /* Process breakpoint. */ # define TRAP_BRKPT TRAP_BRKPT TRAP_TRACE, /* Process trace trap. */ # define TRAP_TRACE TRAP_TRACE TRAP_BRANCH, /* Process taken branch trap. */ # define TRAP_BRANCH TRAP_BRANCH TRAP_HWBKPT, /* Hardware breakpoint/watchpoint. */ # define TRAP_HWBKPT TRAP_HWBKPT TRAP_UNK /* Undiagnosed trap. */ # define TRAP_UNK TRAP_UNK }; # endif # if defined __USE_XOPEN_EXTENDED || defined __USE_XOPEN2K8 /* `si_code' values for SIGCHLD signal. */ enum { CLD_EXITED = 1, /* Child has exited. */ # define CLD_EXITED CLD_EXITED CLD_KILLED, /* Child was killed. */ # define CLD_KILLED CLD_KILLED CLD_DUMPED, /* Child terminated abnormally. */ # define CLD_DUMPED CLD_DUMPED CLD_TRAPPED, /* Traced child has trapped. */ # define CLD_TRAPPED CLD_TRAPPED CLD_STOPPED, /* Child has stopped. */ # define CLD_STOPPED CLD_STOPPED CLD_CONTINUED /* Stopped child has continued. */ # define CLD_CONTINUED CLD_CONTINUED }; /* `si_code' values for SIGPOLL signal. */ enum { POLL_IN = 1, /* Data input available. */ # define POLL_IN POLL_IN POLL_OUT, /* Output buffers available. */ # define POLL_OUT POLL_OUT POLL_MSG, /* Input message available. */ # define POLL_MSG POLL_MSG POLL_ERR, /* I/O error. */ # define POLL_ERR POLL_ERR POLL_PRI, /* High priority input available. */ # define POLL_PRI POLL_PRI POLL_HUP /* Device disconnected. */ # define POLL_HUP POLL_HUP }; # endif /* Architectures might also add architecture-specific constants. These are all considered GNU extensions. */ #ifdef __USE_GNU # include <bits/siginfo-consts-arch.h> #endif #endif termios-misc.h 0000644 00000001711 15125171642 0007334 0 ustar 00 /* termios baud platform specific definitions. Linux/generic version. Copyright (C) 2019-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library. If not, see <https://www.gnu.org/licenses/>. */ #ifndef _TERMIOS_H # error "Never include <bits/termios-misc.h> directly; use <termios.h> instead." #endif dirent_ext.h 0000644 00000002373 15125171642 0007073 0 ustar 00 /* System-specific extensions of <dirent.h>. Linux version. Copyright (C) 2019-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _DIRENT_H # error "Never include <bits/dirent_ext.h> directly; use <dirent.h> instead." #endif __BEGIN_DECLS #ifdef __USE_GNU /* Read from the directory descriptor FD into LENGTH bytes at BUFFER. Return the number of bytes read on success (0 for end of directory), and -1 for failure. */ extern __ssize_t getdents64 (int __fd, void *__buffer, size_t __length) __THROW __nonnull ((2)); #endif __END_DECLS inet-fortified-decl.h 0000644 00000003462 15125171642 0010543 0 ustar 00 /* Declarations of checking macros for inet functions. Copyright (C) 2025 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _BITS_INET_FORTIFIED_DEC_H #define _BITS_INET_FORTIFIED_DEC_H 1 #ifndef _ARPA_INET_H # error "Never include <bits/inet-fortified-decl.h> directly; use <arpa/inet.h> instead." #endif extern const char *__inet_ntop_chk (int, const void *, char *, socklen_t, size_t); extern const char *__REDIRECT_NTH (__inet_ntop_alias, (int, const void *, char *, socklen_t), inet_ntop); extern const char *__REDIRECT_NTH (__inet_ntop_chk_warn, (int, const void *, char *, socklen_t, size_t), __inet_ntop_chk) __warnattr ("inet_ntop called with bigger length than " "size of destination buffer"); extern int __inet_pton_chk (int, const char *, void *, size_t); extern int __REDIRECT_NTH (__inet_pton_alias, (int, const char *, void *), inet_pton); extern int __REDIRECT_NTH (__inet_pton_chk_warn, (int, const char *, void *, size_t), __inet_pton_chk) __warnattr ("inet_pton called with a destination buffer size too small"); #endif /* bits/inet-fortified-decl.h. */ mman.h 0000644 00000002523 15125171642 0005653 0 ustar 00 /* Definitions for POSIX memory map interface. Linux/x86_64 version. Copyright (C) 2001-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _SYS_MMAN_H # error "Never use <bits/mman.h> directly; include <sys/mman.h> instead." #endif /* The following definitions basically come from the kernel headers. But the kernel header is not namespace clean. */ /* Other flags. */ #ifdef __USE_MISC # define MAP_32BIT 0x40 /* Only give out 32-bit addresses. */ # define MAP_ABOVE4G 0x80 /* Only map above 4GB. */ #endif #include <bits/mman-map-flags-generic.h> /* Include generic Linux declarations. */ #include <bits/mman-linux.h> wchar2-decl.h 0000644 00000010740 15125171642 0007016 0 ustar 00 /* Checking macros for wchar functions. Declarations only. Copyright (C) 2004-2022 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _BITS_WCHAR2_DECL_H #define _BITS_WCHAR2_DECL_H 1 #ifndef _WCHAR_H # error "Never include <bits/wchar2-decl.h> directly; use <wchar.h> instead." #endif extern wchar_t *__wmemcpy_chk (wchar_t *__restrict __s1, const wchar_t *__restrict __s2, size_t __n, size_t __ns1) __THROW; extern wchar_t *__wmemmove_chk (wchar_t *__s1, const wchar_t *__s2, size_t __n, size_t __ns1) __THROW; #ifdef __USE_GNU extern wchar_t *__wmempcpy_chk (wchar_t *__restrict __s1, const wchar_t *__restrict __s2, size_t __n, size_t __ns1) __THROW; #endif extern wchar_t *__wmemset_chk (wchar_t *__s, wchar_t __c, size_t __n, size_t __ns) __THROW; extern wchar_t *__wcscpy_chk (wchar_t *__restrict __dest, const wchar_t *__restrict __src, size_t __n) __THROW; extern wchar_t *__wcpcpy_chk (wchar_t *__restrict __dest, const wchar_t *__restrict __src, size_t __destlen) __THROW; extern wchar_t *__wcsncpy_chk (wchar_t *__restrict __dest, const wchar_t *__restrict __src, size_t __n, size_t __destlen) __THROW; extern wchar_t *__wcpncpy_chk (wchar_t *__restrict __dest, const wchar_t *__restrict __src, size_t __n, size_t __destlen) __THROW; extern wchar_t *__wcscat_chk (wchar_t *__restrict __dest, const wchar_t *__restrict __src, size_t __destlen) __THROW; extern wchar_t *__wcsncat_chk (wchar_t *__restrict __dest, const wchar_t *__restrict __src, size_t __n, size_t __destlen) __THROW; extern int __swprintf_chk (wchar_t *__restrict __s, size_t __n, int __flag, size_t __s_len, const wchar_t *__restrict __format, ...) __THROW /* __attribute__ ((__format__ (__wprintf__, 5, 6))) */; extern int __vswprintf_chk (wchar_t *__restrict __s, size_t __n, int __flag, size_t __s_len, const wchar_t *__restrict __format, __gnuc_va_list __arg) __THROW /* __attribute__ ((__format__ (__wprintf__, 5, 0))) */; #if __USE_FORTIFY_LEVEL > 1 extern int __fwprintf_chk (__FILE *__restrict __stream, int __flag, const wchar_t *__restrict __format, ...); extern int __wprintf_chk (int __flag, const wchar_t *__restrict __format, ...); extern int __vfwprintf_chk (__FILE *__restrict __stream, int __flag, const wchar_t *__restrict __format, __gnuc_va_list __ap); extern int __vwprintf_chk (int __flag, const wchar_t *__restrict __format, __gnuc_va_list __ap); #endif extern wchar_t *__fgetws_chk (wchar_t *__restrict __s, size_t __size, int __n, __FILE *__restrict __stream) __wur; #ifdef __USE_GNU extern wchar_t *__fgetws_unlocked_chk (wchar_t *__restrict __s, size_t __size, int __n, __FILE *__restrict __stream) __wur; #endif extern size_t __wcrtomb_chk (char *__restrict __s, wchar_t __wchar, mbstate_t *__restrict __p, size_t __buflen) __THROW __wur; extern size_t __mbsrtowcs_chk (wchar_t *__restrict __dst, const char **__restrict __src, size_t __len, mbstate_t *__restrict __ps, size_t __dstlen) __THROW; extern size_t __wcsrtombs_chk (char *__restrict __dst, const wchar_t **__restrict __src, size_t __len, mbstate_t *__restrict __ps, size_t __dstlen) __THROW; #ifdef __USE_XOPEN2K8 extern size_t __mbsnrtowcs_chk (wchar_t *__restrict __dst, const char **__restrict __src, size_t __nmc, size_t __len, mbstate_t *__restrict __ps, size_t __dstlen) __THROW; extern size_t __wcsnrtombs_chk (char *__restrict __dst, const wchar_t **__restrict __src, size_t __nwc, size_t __len, mbstate_t *__restrict __ps, size_t __dstlen) __THROW; #endif #endif /* bits/wchar2-decl.h. */ math-vector.h 0000644 00000004404 15125171642 0007154 0 ustar 00 /* Platform-specific SIMD declarations of math functions. Copyright (C) 2014-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _MATH_H # error "Never include <bits/math-vector.h> directly;\ include <math.h> instead." #endif /* Get default empty definitions for simd declarations. */ #include <bits/libm-simd-decl-stubs.h> #if defined __x86_64__ && defined __FAST_MATH__ # if defined _OPENMP && _OPENMP >= 201307 /* OpenMP case. */ # define __DECL_SIMD_x86_64 _Pragma ("omp declare simd notinbranch") # elif __GNUC_PREREQ (6,0) /* W/o OpenMP use GCC 6.* __attribute__ ((__simd__)). */ # define __DECL_SIMD_x86_64 __attribute__ ((__simd__ ("notinbranch"))) # endif # ifdef __DECL_SIMD_x86_64 # undef __DECL_SIMD_cos # define __DECL_SIMD_cos __DECL_SIMD_x86_64 # undef __DECL_SIMD_cosf # define __DECL_SIMD_cosf __DECL_SIMD_x86_64 # undef __DECL_SIMD_sin # define __DECL_SIMD_sin __DECL_SIMD_x86_64 # undef __DECL_SIMD_sinf # define __DECL_SIMD_sinf __DECL_SIMD_x86_64 # undef __DECL_SIMD_sincos # define __DECL_SIMD_sincos __DECL_SIMD_x86_64 # undef __DECL_SIMD_sincosf # define __DECL_SIMD_sincosf __DECL_SIMD_x86_64 # undef __DECL_SIMD_log # define __DECL_SIMD_log __DECL_SIMD_x86_64 # undef __DECL_SIMD_logf # define __DECL_SIMD_logf __DECL_SIMD_x86_64 # undef __DECL_SIMD_exp # define __DECL_SIMD_exp __DECL_SIMD_x86_64 # undef __DECL_SIMD_expf # define __DECL_SIMD_expf __DECL_SIMD_x86_64 # undef __DECL_SIMD_pow # define __DECL_SIMD_pow __DECL_SIMD_x86_64 # undef __DECL_SIMD_powf # define __DECL_SIMD_powf __DECL_SIMD_x86_64 # endif #endif utmpx.h 0000644 00000006772 15125171642 0006112 0 ustar 00 /* Structures and definitions for the user accounting database. GNU version. Copyright (C) 1997-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _UTMPX_H # error "Never include <bits/utmpx.h> directly; use <utmpx.h> instead." #endif #include <bits/types.h> #include <sys/time.h> #include <bits/wordsize.h> #ifdef __USE_GNU # include <paths.h> # define _PATH_UTMPX _PATH_UTMP # define _PATH_WTMPX _PATH_WTMP #endif #define __UT_LINESIZE 32 #define __UT_NAMESIZE 32 #define __UT_HOSTSIZE 256 /* The structure describing the status of a terminated process. This type is used in `struct utmpx' below. */ struct __exit_status { #ifdef __USE_GNU short int e_termination; /* Process termination status. */ short int e_exit; /* Process exit status. */ #else short int __e_termination; /* Process termination status. */ short int __e_exit; /* Process exit status. */ #endif }; /* The structure describing an entry in the user accounting database. */ struct utmpx { short int ut_type; /* Type of login. */ __pid_t ut_pid; /* Process ID of login process. */ char ut_line[__UT_LINESIZE] __attribute_nonstring__; /* Devicename. */ char ut_id[4] __attribute_nonstring__; /* Inittab ID. */ char ut_user[__UT_NAMESIZE] __attribute_nonstring__; /* Username. */ char ut_host[__UT_HOSTSIZE] __attribute_nonstring__; /* Hostname for remote login. */ struct __exit_status ut_exit; /* Exit status of a process marked as DEAD_PROCESS. */ /* The fields ut_session and ut_tv must be the same size when compiled 32- and 64-bit. This allows files and shared memory to be shared between 32- and 64-bit applications. */ #if __WORDSIZE_TIME64_COMPAT32 __int32_t ut_session; /* Session ID, used for windowing. */ struct { __int32_t tv_sec; /* Seconds. */ __int32_t tv_usec; /* Microseconds. */ } ut_tv; /* Time entry was made. */ #else long int ut_session; /* Session ID, used for windowing. */ struct timeval ut_tv; /* Time entry was made. */ #endif __int32_t ut_addr_v6[4]; /* Internet address of remote host. */ char __glibc_reserved[20]; /* Reserved for future use. */ }; /* Values for the `ut_type' field of a `struct utmpx'. */ #define EMPTY 0 /* No valid user accounting information. */ #ifdef __USE_GNU # define RUN_LVL 1 /* The system's runlevel. */ #endif #define BOOT_TIME 2 /* Time of system boot. */ #define NEW_TIME 3 /* Time after system clock changed. */ #define OLD_TIME 4 /* Time when system clock changed. */ #define INIT_PROCESS 5 /* Process spawned by the init process. */ #define LOGIN_PROCESS 6 /* Session leader of a logged in user. */ #define USER_PROCESS 7 /* Normal process. */ #define DEAD_PROCESS 8 /* Terminated process. */ #ifdef __USE_GNU # define ACCOUNTING 9 /* System accounting. */ #endif sigaction.h 0000644 00000005567 15125171642 0006716 0 ustar 00 /* The proper definitions for Linux's sigaction. Copyright (C) 1993-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _BITS_SIGACTION_H #define _BITS_SIGACTION_H 1 #ifndef _SIGNAL_H # error "Never include <bits/sigaction.h> directly; use <signal.h> instead." #endif /* Structure describing the action to be taken when a signal arrives. */ struct sigaction { /* Signal handler. */ #if defined __USE_POSIX199309 || defined __USE_XOPEN_EXTENDED union { /* Used if SA_SIGINFO is not set. */ __sighandler_t sa_handler; /* Used if SA_SIGINFO is set. */ void (*sa_sigaction) (int, siginfo_t *, void *); } __sigaction_handler; # define sa_handler __sigaction_handler.sa_handler # define sa_sigaction __sigaction_handler.sa_sigaction #else __sighandler_t sa_handler; #endif /* Additional set of signals to be blocked. */ __sigset_t sa_mask; /* Special flags. */ int sa_flags; /* Restore handler. */ void (*sa_restorer) (void); }; /* Bits in `sa_flags'. */ #define SA_NOCLDSTOP 1 /* Don't send SIGCHLD when children stop. */ #define SA_NOCLDWAIT 2 /* Don't create zombie on child death. */ #define SA_SIGINFO 4 /* Invoke signal-catching function with three arguments instead of one. */ #if defined __USE_XOPEN_EXTENDED || defined __USE_MISC # define SA_ONSTACK 0x08000000 /* Use signal stack by using `sa_restorer'. */ #endif #if defined __USE_XOPEN_EXTENDED || defined __USE_XOPEN2K8 # define SA_RESTART 0x10000000 /* Restart syscall on signal return. */ # define SA_NODEFER 0x40000000 /* Don't automatically block the signal when its handler is being executed. */ # define SA_RESETHAND 0x80000000 /* Reset to SIG_DFL on entry to handler. */ #endif #ifdef __USE_MISC # define SA_INTERRUPT 0x20000000 /* Historical no-op. */ /* Some aliases for the SA_ constants. */ # define SA_NOMASK SA_NODEFER # define SA_ONESHOT SA_RESETHAND # define SA_STACK SA_ONSTACK #endif /* Values for the HOW argument to `sigprocmask'. */ #define SIG_BLOCK 0 /* Block signals. */ #define SIG_UNBLOCK 1 /* Unblock signals. */ #define SIG_SETMASK 2 /* Set the set of blocked signals. */ #endif pthread_stack_min-dynamic.h 0000644 00000002271 15125171642 0012024 0 ustar 00 /* Definition of PTHREAD_STACK_MIN, possibly dynamic. Copyright (C) 2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef PTHREAD_STACK_MIN # if defined __USE_DYNAMIC_STACK_SIZE && __USE_DYNAMIC_STACK_SIZE # ifndef __ASSEMBLER__ # define __SC_THREAD_STACK_MIN_VALUE 75 __BEGIN_DECLS extern long int __sysconf (int __name) __THROW; __END_DECLS # define PTHREAD_STACK_MIN __sysconf (__SC_THREAD_STACK_MIN_VALUE) # endif # else # include <bits/pthread_stack_min.h> # endif #endif sysmacros.h 0000644 00000005611 15125171642 0006747 0 ustar 00 /* Definitions of macros to access `dev_t' values. Copyright (C) 1996-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _BITS_SYSMACROS_H #define _BITS_SYSMACROS_H 1 #ifndef _SYS_SYSMACROS_H # error "Never include <bits/sysmacros.h> directly; use <sys/sysmacros.h> instead." #endif /* dev_t in glibc is a 64-bit quantity, with 32-bit major and minor numbers. Our default encoding is MMMM Mmmm mmmM MMmm, where M is a hex digit of the major number and m is a hex digit of the minor number. This is downward compatible with legacy systems where dev_t is 16 bits wide, encoded as MMmm. It is also downward compatible with the Linux kernel, which (as of 2016) uses 32-bit dev_t, encoded as mmmM MMmm. Systems that use an incompatible encoding for dev_t should override this file in the appropriate sysdeps subdirectory. */ #define __SYSMACROS_DECLARE_MAJOR(DECL_TEMPL) \ DECL_TEMPL(unsigned int, major, (__dev_t __dev)) #define __SYSMACROS_DEFINE_MAJOR(DECL_TEMPL) \ __SYSMACROS_DECLARE_MAJOR (DECL_TEMPL) \ { \ unsigned int __major; \ __major = ((__dev & (__dev_t) 0x00000000000fff00u) >> 8); \ __major |= ((__dev & (__dev_t) 0xfffff00000000000u) >> 32); \ return __major; \ } #define __SYSMACROS_DECLARE_MINOR(DECL_TEMPL) \ DECL_TEMPL(unsigned int, minor, (__dev_t __dev)) #define __SYSMACROS_DEFINE_MINOR(DECL_TEMPL) \ __SYSMACROS_DECLARE_MINOR (DECL_TEMPL) \ { \ unsigned int __minor; \ __minor = ((__dev & (__dev_t) 0x00000000000000ffu) >> 0); \ __minor |= ((__dev & (__dev_t) 0x00000ffffff00000u) >> 12); \ return __minor; \ } #define __SYSMACROS_DECLARE_MAKEDEV(DECL_TEMPL) \ DECL_TEMPL(__dev_t, makedev, (unsigned int __major, unsigned int __minor)) #define __SYSMACROS_DEFINE_MAKEDEV(DECL_TEMPL) \ __SYSMACROS_DECLARE_MAKEDEV (DECL_TEMPL) \ { \ __dev_t __dev; \ __dev = (((__dev_t) (__major & 0x00000fffu)) << 8); \ __dev |= (((__dev_t) (__major & 0xfffff000u)) << 32); \ __dev |= (((__dev_t) (__minor & 0x000000ffu)) << 0); \ __dev |= (((__dev_t) (__minor & 0xffffff00u)) << 12); \ return __dev; \ } #endif /* bits/sysmacros.h */ printf-ldbl.h 0000644 00000001740 15125171642 0007140 0 ustar 00 /* -mlong-double-64 compatibility mode for <printf.h> functions. Copyright (C) 2006-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _PRINTF_H # error "Never include <bits/printf-ldbl.h> directly; use <printf.h> instead." #endif __LDBL_REDIR_DECL (printf_size) utsname.h 0000644 00000002275 15125171642 0006403 0 ustar 00 /* Copyright (C) 1995-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _SYS_UTSNAME_H # error "Never include <bits/utsname.h> directly; use <sys/utsname.h> instead." #endif /* Length of the entries in `struct utsname' is 65. */ #define _UTSNAME_LENGTH 65 /* Linux provides as additional information in the `struct utsname' the name of the current domain. Define _UTSNAME_DOMAIN_LENGTH to a value != 0 to activate this entry. */ #define _UTSNAME_DOMAIN_LENGTH _UTSNAME_LENGTH select.h 0000644 00000002741 15125171642 0006204 0 ustar 00 /* Copyright (C) 1997-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _SYS_SELECT_H # error "Never use <bits/select.h> directly; include <sys/select.h> instead." #endif /* We don't use `memset' because this would require a prototype and the array isn't too big. */ #define __FD_ZERO(s) \ do { \ unsigned int __i; \ fd_set *__arr = (s); \ for (__i = 0; __i < sizeof (fd_set) / sizeof (__fd_mask); ++__i) \ __FDS_BITS (__arr)[__i] = 0; \ } while (0) #define __FD_SET(d, s) \ ((void) (__FDS_BITS (s)[__FD_ELT(d)] |= __FD_MASK(d))) #define __FD_CLR(d, s) \ ((void) (__FDS_BITS (s)[__FD_ELT(d)] &= ~__FD_MASK(d))) #define __FD_ISSET(d, s) \ ((__FDS_BITS (s)[__FD_ELT (d)] & __FD_MASK (d)) != 0) signum-generic.h 0000644 00000006361 15125171642 0007643 0 ustar 00 /* Signal number constants. Generic template. Copyright (C) 1991-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _BITS_SIGNUM_GENERIC_H #define _BITS_SIGNUM_GENERIC_H 1 #ifndef _SIGNAL_H #error "Never include <bits/signum-generic.h> directly; use <signal.h> instead." #endif /* Fake signal functions. */ #define SIG_ERR ((__sighandler_t) -1) /* Error return. */ #define SIG_DFL ((__sighandler_t) 0) /* Default action. */ #define SIG_IGN ((__sighandler_t) 1) /* Ignore signal. */ #ifdef __USE_XOPEN # define SIG_HOLD ((__sighandler_t) 2) /* Add signal to hold mask. */ #endif /* We define here all the signal names listed in POSIX (1003.1-2008); as of 1003.1-2013, no additional signals have been added by POSIX. We also define here signal names that historically exist in every real-world POSIX variant (e.g. SIGWINCH). Signals in the 1-15 range are defined with their historical numbers. For other signals, we use the BSD numbers. There are two unallocated signal numbers in the 1-31 range: 7 and 29. Signal number 0 is reserved for use as kill(pid, 0), to test whether a process exists without sending it a signal. */ /* ISO C99 signals. */ #define SIGINT 2 /* Interactive attention signal. */ #define SIGILL 4 /* Illegal instruction. */ #define SIGABRT 6 /* Abnormal termination. */ #define SIGFPE 8 /* Erroneous arithmetic operation. */ #define SIGSEGV 11 /* Invalid access to storage. */ #define SIGTERM 15 /* Termination request. */ /* Historical signals specified by POSIX. */ #define SIGHUP 1 /* Hangup. */ #define SIGQUIT 3 /* Quit. */ #define SIGTRAP 5 /* Trace/breakpoint trap. */ #define SIGKILL 9 /* Killed. */ #define SIGPIPE 13 /* Broken pipe. */ #define SIGALRM 14 /* Alarm clock. */ /* Archaic names for compatibility. */ #define SIGIO SIGPOLL /* I/O now possible (4.2 BSD). */ #define SIGIOT SIGABRT /* IOT instruction, abort() on a PDP-11. */ #define SIGCLD SIGCHLD /* Old System V name */ /* Not all systems support real-time signals. bits/signum.h indicates that they are supported by overriding __SIGRTMAX to a value greater than __SIGRTMIN. These constants give the kernel-level hard limits, but some real-time signals may be used internally by glibc. Do not use these constants in application code; use SIGRTMIN and SIGRTMAX (defined in signal.h) instead. */ /* Include system specific bits. */ #include <bits/signum-arch.h> /* Biggest signal number + 1 (including real-time signals). */ #define _NSIG (__SIGRTMAX + 1) #endif /* bits/signum-generic.h. */ syslog-ldbl.h 0000644 00000002264 15125171642 0007160 0 ustar 00 /* -mlong-double-64 compatibility mode for syslog functions. Copyright (C) 2006-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _SYS_SYSLOG_H # error "Never include <bits/syslog-ldbl.h> directly; use <sys/syslog.h> instead." #endif __LDBL_REDIR_DECL (syslog) #ifdef __USE_MISC __LDBL_REDIR_DECL (vsyslog) #endif #if __USE_FORTIFY_LEVEL > 0 && defined __fortify_function __LDBL_REDIR2_DECL (syslog_chk) # ifdef __USE_MISC __LDBL_REDIR2_DECL (vsyslog_chk) # endif #endif stdlib-bsearch.h 0000644 00000003025 15125171642 0007607 0 ustar 00 /* Perform binary search - inline version. Copyright (C) 1991-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ __extern_inline void * bsearch (const void *__key, const void *__base, size_t __nmemb, size_t __size, __compar_fn_t __compar) { size_t __l, __u, __idx; const void *__p; int __comparison; __l = 0; __u = __nmemb; while (__l < __u) { __idx = (__l + __u) / 2; __p = (const void *) (((const char *) __base) + (__idx * __size)); __comparison = (*__compar) (__key, __p); if (__comparison < 0) __u = __idx; else if (__comparison > 0) __l = __idx + 1; else { #if __GNUC_PREREQ(4, 6) # pragma GCC diagnostic push # pragma GCC diagnostic ignored "-Wcast-qual" #endif return (void *) __p; #if __GNUC_PREREQ(4, 6) # pragma GCC diagnostic pop #endif } } return NULL; } stdio2-decl.h 0000644 00000010213 15125171642 0007027 0 ustar 00 /* Checking macros for stdio functions. Declarations only. Copyright (C) 2004-2022 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _BITS_STDIO2_DEC_H #define _BITS_STDIO2_DEC_H 1 #ifndef _STDIO_H # error "Never include <bits/stdio2-decl.h> directly; use <stdio.h> instead." #endif extern int __sprintf_chk (char *__restrict __s, int __flag, size_t __slen, const char *__restrict __format, ...) __THROW __attr_access ((__write_only__, 1, 3)); extern int __vsprintf_chk (char *__restrict __s, int __flag, size_t __slen, const char *__restrict __format, __gnuc_va_list __ap) __THROW __attr_access ((__write_only__, 1, 3)); #if defined __USE_ISOC99 || defined __USE_UNIX98 extern int __snprintf_chk (char *__restrict __s, size_t __n, int __flag, size_t __slen, const char *__restrict __format, ...) __THROW __attr_access ((__write_only__, 1, 2)); extern int __vsnprintf_chk (char *__restrict __s, size_t __n, int __flag, size_t __slen, const char *__restrict __format, __gnuc_va_list __ap) __THROW __attr_access ((__write_only__, 1, 2)); #endif #if __USE_FORTIFY_LEVEL > 1 extern int __fprintf_chk (FILE *__restrict __stream, int __flag, const char *__restrict __format, ...); extern int __printf_chk (int __flag, const char *__restrict __format, ...); extern int __vfprintf_chk (FILE *__restrict __stream, int __flag, const char *__restrict __format, __gnuc_va_list __ap); extern int __vprintf_chk (int __flag, const char *__restrict __format, __gnuc_va_list __ap); # ifdef __USE_XOPEN2K8 extern int __dprintf_chk (int __fd, int __flag, const char *__restrict __fmt, ...) __attribute__ ((__format__ (__printf__, 3, 4))); extern int __vdprintf_chk (int __fd, int __flag, const char *__restrict __fmt, __gnuc_va_list __arg) __attribute__ ((__format__ (__printf__, 3, 0))); # endif # ifdef __USE_GNU extern int __asprintf_chk (char **__restrict __ptr, int __flag, const char *__restrict __fmt, ...) __THROW __attribute__ ((__format__ (__printf__, 3, 4))) __wur; extern int __vasprintf_chk (char **__restrict __ptr, int __flag, const char *__restrict __fmt, __gnuc_va_list __arg) __THROW __attribute__ ((__format__ (__printf__, 3, 0))) __wur; extern int __obstack_printf_chk (struct obstack *__restrict __obstack, int __flag, const char *__restrict __format, ...) __THROW __attribute__ ((__format__ (__printf__, 3, 4))); extern int __obstack_vprintf_chk (struct obstack *__restrict __obstack, int __flag, const char *__restrict __format, __gnuc_va_list __args) __THROW __attribute__ ((__format__ (__printf__, 3, 0))); # endif #endif #if __GLIBC_USE (DEPRECATED_GETS) extern char *__gets_chk (char *__str, size_t) __wur; #endif extern char *__fgets_chk (char *__restrict __s, size_t __size, int __n, FILE *__restrict __stream) __wur __attr_access ((__write_only__, 1, 3)); extern size_t __fread_chk (void *__restrict __ptr, size_t __ptrlen, size_t __size, size_t __n, FILE *__restrict __stream) __wur; #ifdef __USE_GNU extern char *__fgets_unlocked_chk (char *__restrict __s, size_t __size, int __n, FILE *__restrict __stream) __wur __attr_access ((__write_only__, 1, 3)); #endif #ifdef __USE_MISC # undef fread_unlocked extern size_t __fread_unlocked_chk (void *__restrict __ptr, size_t __ptrlen, size_t __size, size_t __n, FILE *__restrict __stream) __wur; #endif #endif /* bits/stdio2-decl.h. */ cpu-set.h 0000644 00000010644 15125171642 0006306 0 ustar 00 /* Definition of the cpu_set_t structure used by the POSIX 1003.1b-1993 scheduling interface. Copyright (C) 1996-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _BITS_CPU_SET_H #define _BITS_CPU_SET_H 1 #ifndef _SCHED_H # error "Never include <bits/cpu-set.h> directly; use <sched.h> instead." #endif /* Size definition for CPU sets. */ #define __CPU_SETSIZE 1024 #define __NCPUBITS (8 * sizeof (__cpu_mask)) /* Type for array elements in 'cpu_set_t'. */ typedef __CPU_MASK_TYPE __cpu_mask; /* Basic access functions. */ #define __CPUELT(cpu) ((cpu) / __NCPUBITS) #define __CPUMASK(cpu) ((__cpu_mask) 1 << ((cpu) % __NCPUBITS)) /* Data structure to describe CPU mask. */ typedef struct { __cpu_mask __bits[__CPU_SETSIZE / __NCPUBITS]; } cpu_set_t; /* Access functions for CPU masks. */ #if __GNUC_PREREQ (2, 91) # define __CPU_ZERO_S(setsize, cpusetp) \ do __builtin_memset (cpusetp, '\0', setsize); while (0) #else # define __CPU_ZERO_S(setsize, cpusetp) \ do { \ size_t __i; \ size_t __imax = (setsize) / sizeof (__cpu_mask); \ __cpu_mask *__bits = (cpusetp)->__bits; \ for (__i = 0; __i < __imax; ++__i) \ __bits[__i] = 0; \ } while (0) #endif #define __CPU_SET_S(cpu, setsize, cpusetp) \ (__extension__ \ ({ size_t __cpu = (cpu); \ __cpu / 8 < (setsize) \ ? (((__cpu_mask *) ((cpusetp)->__bits))[__CPUELT (__cpu)] \ |= __CPUMASK (__cpu)) \ : 0; })) #define __CPU_CLR_S(cpu, setsize, cpusetp) \ (__extension__ \ ({ size_t __cpu = (cpu); \ __cpu / 8 < (setsize) \ ? (((__cpu_mask *) ((cpusetp)->__bits))[__CPUELT (__cpu)] \ &= ~__CPUMASK (__cpu)) \ : 0; })) #define __CPU_ISSET_S(cpu, setsize, cpusetp) \ (__extension__ \ ({ size_t __cpu = (cpu); \ __cpu / 8 < (setsize) \ ? ((((const __cpu_mask *) ((cpusetp)->__bits))[__CPUELT (__cpu)] \ & __CPUMASK (__cpu))) != 0 \ : 0; })) #define __CPU_COUNT_S(setsize, cpusetp) \ __sched_cpucount (setsize, cpusetp) #if __GNUC_PREREQ (2, 91) # define __CPU_EQUAL_S(setsize, cpusetp1, cpusetp2) \ (__builtin_memcmp (cpusetp1, cpusetp2, setsize) == 0) #else # define __CPU_EQUAL_S(setsize, cpusetp1, cpusetp2) \ (__extension__ \ ({ const __cpu_mask *__arr1 = (cpusetp1)->__bits; \ const __cpu_mask *__arr2 = (cpusetp2)->__bits; \ size_t __imax = (setsize) / sizeof (__cpu_mask); \ size_t __i; \ for (__i = 0; __i < __imax; ++__i) \ if (__arr1[__i] != __arr2[__i]) \ break; \ __i == __imax; })) #endif #define __CPU_OP_S(setsize, destset, srcset1, srcset2, op) \ (__extension__ \ ({ cpu_set_t *__dest = (destset); \ const __cpu_mask *__arr1 = (srcset1)->__bits; \ const __cpu_mask *__arr2 = (srcset2)->__bits; \ size_t __imax = (setsize) / sizeof (__cpu_mask); \ size_t __i; \ for (__i = 0; __i < __imax; ++__i) \ ((__cpu_mask *) __dest->__bits)[__i] = __arr1[__i] op __arr2[__i]; \ __dest; })) #define __CPU_ALLOC_SIZE(count) \ ((((count) + __NCPUBITS - 1) / __NCPUBITS) * sizeof (__cpu_mask)) #define __CPU_ALLOC(count) __sched_cpualloc (count) #define __CPU_FREE(cpuset) __sched_cpufree (cpuset) __BEGIN_DECLS extern int __sched_cpucount (size_t __setsize, const cpu_set_t *__setp) __THROW; extern cpu_set_t *__sched_cpualloc (size_t __count) __THROW __wur; extern void __sched_cpufree (cpu_set_t *__set) __THROW; __END_DECLS #endif /* bits/cpu-set.h */ struct_stat.h 0000644 00000014056 15125171642 0007306 0 ustar 00 /* Definition for struct stat. Copyright (C) 2020-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library. If not, see <https://www.gnu.org/licenses/>. */ #if !defined _SYS_STAT_H && !defined _FCNTL_H # error "Never include <bits/struct_stat.h> directly; use <sys/stat.h> instead." #endif #ifndef _BITS_STRUCT_STAT_H #define _BITS_STRUCT_STAT_H 1 struct stat { #ifdef __USE_TIME_BITS64 # include <bits/struct_stat_time64_helper.h> #else __dev_t st_dev; /* Device. */ # ifndef __x86_64__ unsigned short int __pad1; # endif # if defined __x86_64__ || !defined __USE_FILE_OFFSET64 __ino_t st_ino; /* File serial number. */ # else __ino_t __st_ino; /* 32bit file serial number. */ # endif # ifndef __x86_64__ __mode_t st_mode; /* File mode. */ __nlink_t st_nlink; /* Link count. */ # else __nlink_t st_nlink; /* Link count. */ __mode_t st_mode; /* File mode. */ # endif __uid_t st_uid; /* User ID of the file's owner. */ __gid_t st_gid; /* Group ID of the file's group.*/ # ifdef __x86_64__ int __pad0; # endif __dev_t st_rdev; /* Device number, if device. */ # ifndef __x86_64__ unsigned short int __pad2; # endif # if defined __x86_64__ || !defined __USE_FILE_OFFSET64 __off_t st_size; /* Size of file, in bytes. */ # else __off64_t st_size; /* Size of file, in bytes. */ # endif __blksize_t st_blksize; /* Optimal block size for I/O. */ # if defined __x86_64__ || !defined __USE_FILE_OFFSET64 __blkcnt_t st_blocks; /* Number 512-byte blocks allocated. */ # else __blkcnt64_t st_blocks; /* Number 512-byte blocks allocated. */ # endif # ifdef __USE_XOPEN2K8 /* Nanosecond resolution timestamps are stored in a format equivalent to 'struct timespec'. This is the type used whenever possible but the Unix namespace rules do not allow the identifier 'timespec' to appear in the <sys/stat.h> header. Therefore we have to handle the use of this header in strictly standard-compliant sources special. */ struct timespec st_atim; /* Time of last access. */ struct timespec st_mtim; /* Time of last modification. */ struct timespec st_ctim; /* Time of last status change. */ # define st_atime st_atim.tv_sec /* Backward compatibility. */ # define st_mtime st_mtim.tv_sec # define st_ctime st_ctim.tv_sec # else __time_t st_atime; /* Time of last access. */ __syscall_ulong_t st_atimensec; /* Nscecs of last access. */ __time_t st_mtime; /* Time of last modification. */ __syscall_ulong_t st_mtimensec; /* Nsecs of last modification. */ __time_t st_ctime; /* Time of last status change. */ __syscall_ulong_t st_ctimensec; /* Nsecs of last status change. */ # endif # ifdef __x86_64__ __syscall_slong_t __glibc_reserved[3]; # else # ifndef __USE_FILE_OFFSET64 unsigned long int __glibc_reserved4; unsigned long int __glibc_reserved5; # else __ino64_t st_ino; /* File serial number. */ # endif # endif #endif /* __USE_TIME_BITS64 */ }; #ifdef __USE_LARGEFILE64 /* Note stat64 has the same shape as stat for x86-64. */ struct stat64 { # ifdef __USE_TIME_BITS64 # include <bits/struct_stat_time64_helper.h> # else __dev_t st_dev; /* Device. */ # ifdef __x86_64__ __ino64_t st_ino; /* File serial number. */ __nlink_t st_nlink; /* Link count. */ __mode_t st_mode; /* File mode. */ # else unsigned int __pad1; __ino_t __st_ino; /* 32bit file serial number. */ __mode_t st_mode; /* File mode. */ __nlink_t st_nlink; /* Link count. */ # endif __uid_t st_uid; /* User ID of the file's owner. */ __gid_t st_gid; /* Group ID of the file's group.*/ # ifdef __x86_64__ int __pad0; __dev_t st_rdev; /* Device number, if device. */ __off_t st_size; /* Size of file, in bytes. */ # else __dev_t st_rdev; /* Device number, if device. */ unsigned int __pad2; __off64_t st_size; /* Size of file, in bytes. */ # endif __blksize_t st_blksize; /* Optimal block size for I/O. */ __blkcnt64_t st_blocks; /* Nr. 512-byte blocks allocated. */ # ifdef __USE_XOPEN2K8 /* Nanosecond resolution timestamps are stored in a format equivalent to 'struct timespec'. This is the type used whenever possible but the Unix namespace rules do not allow the identifier 'timespec' to appear in the <sys/stat.h> header. Therefore we have to handle the use of this header in strictly standard-compliant sources special. */ struct timespec st_atim; /* Time of last access. */ struct timespec st_mtim; /* Time of last modification. */ struct timespec st_ctim; /* Time of last status change. */ # else __time_t st_atime; /* Time of last access. */ __syscall_ulong_t st_atimensec; /* Nscecs of last access. */ __time_t st_mtime; /* Time of last modification. */ __syscall_ulong_t st_mtimensec; /* Nsecs of last modification. */ __time_t st_ctime; /* Time of last status change. */ __syscall_ulong_t st_ctimensec; /* Nsecs of last status change. */ # endif # ifdef __x86_64__ __syscall_slong_t __glibc_reserved[3]; # else __ino64_t st_ino; /* File serial number. */ # endif # endif /* __USE_TIME_BITS64 */ }; #endif /* Tell code we have these members. */ #define _STATBUF_ST_BLKSIZE #define _STATBUF_ST_RDEV /* Nanosecond resolution time values are supported. */ #define _STATBUF_ST_NSEC #endif /* _BITS_STRUCT_STAT_H */ stdio-ldbl.h 0000644 00000006631 15125171642 0006764 0 ustar 00 /* -mlong-double-64 compatibility mode for stdio functions. Copyright (C) 2006-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _STDIO_H # error "Never include <bits/stdio-ldbl.h> directly; use <stdio.h> instead." #endif __LDBL_REDIR_DECL (fprintf) __LDBL_REDIR_DECL (printf) __LDBL_REDIR_DECL (sprintf) __LDBL_REDIR_DECL (vfprintf) __LDBL_REDIR_DECL (vprintf) __LDBL_REDIR_DECL (vsprintf) #if !__GLIBC_USE (DEPRECATED_SCANF) # if defined __LDBL_COMPAT __LDBL_REDIR1_DECL (fscanf, __nldbl___isoc99_fscanf) __LDBL_REDIR1_DECL (scanf, __nldbl___isoc99_scanf) __LDBL_REDIR1_DECL (sscanf, __nldbl___isoc99_sscanf) # elif __LDOUBLE_REDIRECTS_TO_FLOAT128_ABI == 1 __LDBL_REDIR1_DECL (fscanf, __isoc99_fscanfieee128) __LDBL_REDIR1_DECL (scanf, __isoc99_scanfieee128) __LDBL_REDIR1_DECL (sscanf, __isoc99_sscanfieee128) # else # error bits/stdlib-ldbl.h included when no ldbl redirections are required. # endif #else __LDBL_REDIR_DECL (fscanf) __LDBL_REDIR_DECL (scanf) __LDBL_REDIR_DECL (sscanf) #endif #if defined __USE_ISOC99 || defined __USE_UNIX98 __LDBL_REDIR_DECL (snprintf) __LDBL_REDIR_DECL (vsnprintf) #endif #ifdef __USE_ISOC99 # if !__GLIBC_USE (DEPRECATED_SCANF) # if defined __LDBL_COMPAT __LDBL_REDIR1_DECL (vfscanf, __nldbl___isoc99_vfscanf) __LDBL_REDIR1_DECL (vscanf, __nldbl___isoc99_vscanf) __LDBL_REDIR1_DECL (vsscanf, __nldbl___isoc99_vsscanf) # elif __LDOUBLE_REDIRECTS_TO_FLOAT128_ABI == 1 __LDBL_REDIR1_DECL (vfscanf, __isoc99_vfscanfieee128) __LDBL_REDIR1_DECL (vscanf, __isoc99_vscanfieee128) __LDBL_REDIR1_DECL (vsscanf, __isoc99_vsscanfieee128) # else # error bits/stdlib-ldbl.h included when no ldbl redirections are required. # endif # else __LDBL_REDIR_DECL (vfscanf) __LDBL_REDIR_DECL (vsscanf) __LDBL_REDIR_DECL (vscanf) # endif #endif #ifdef __USE_XOPEN2K8 __LDBL_REDIR_DECL (vdprintf) __LDBL_REDIR_DECL (dprintf) #endif #ifdef __USE_GNU __LDBL_REDIR_DECL (vasprintf) __LDBL_REDIR2_DECL (asprintf) __LDBL_REDIR_DECL (asprintf) __LDBL_REDIR_DECL (obstack_printf) __LDBL_REDIR_DECL (obstack_vprintf) #endif #if __USE_FORTIFY_LEVEL > 0 && defined __fortify_function __LDBL_REDIR2_DECL (sprintf_chk) __LDBL_REDIR2_DECL (vsprintf_chk) # if defined __USE_ISOC99 || defined __USE_UNIX98 __LDBL_REDIR2_DECL (snprintf_chk) __LDBL_REDIR2_DECL (vsnprintf_chk) # endif # if __USE_FORTIFY_LEVEL > 1 __LDBL_REDIR2_DECL (fprintf_chk) __LDBL_REDIR2_DECL (printf_chk) __LDBL_REDIR2_DECL (vfprintf_chk) __LDBL_REDIR2_DECL (vprintf_chk) # ifdef __USE_XOPEN2K8 __LDBL_REDIR2_DECL (dprintf_chk) __LDBL_REDIR2_DECL (vdprintf_chk) # endif # ifdef __USE_GNU __LDBL_REDIR2_DECL (asprintf_chk) __LDBL_REDIR2_DECL (vasprintf_chk) __LDBL_REDIR2_DECL (obstack_printf_chk) __LDBL_REDIR2_DECL (obstack_vprintf_chk) # endif # endif #endif timesize.h 0000644 00000002071 15125171642 0006552 0 ustar 00 /* Bit size of the time_t type at glibc build time, x86-64 and x32 case. Copyright (C) 2018-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #if defined __x86_64__ && defined __ILP32__ /* For x32, time is 64-bit even though word size is 32-bit. */ # define __TIMESIZE 64 #else /* For others, time size is word size. */ # define __TIMESIZE __WORDSIZE #endif epoll.h 0000644 00000002057 15125171642 0006040 0 ustar 00 /* Copyright (C) 2002-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _SYS_EPOLL_H # error "Never use <bits/epoll.h> directly; include <sys/epoll.h> instead." #endif /* Flags to be passed to epoll_create1. */ enum { EPOLL_CLOEXEC = 02000000 #define EPOLL_CLOEXEC EPOLL_CLOEXEC }; #define __EPOLL_PACKED __attribute__ ((__packed__)) socket_type.h 0000644 00000004250 15125171642 0007253 0 ustar 00 /* Define enum __socket_type for generic Linux. Copyright (C) 1991-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _SYS_SOCKET_H # error "Never include <bits/socket_type.h> directly; use <sys/socket.h> instead." #endif /* Types of sockets. */ enum __socket_type { SOCK_STREAM = 1, /* Sequenced, reliable, connection-based byte streams. */ #define SOCK_STREAM SOCK_STREAM SOCK_DGRAM = 2, /* Connectionless, unreliable datagrams of fixed maximum length. */ #define SOCK_DGRAM SOCK_DGRAM SOCK_RAW = 3, /* Raw protocol interface. */ #define SOCK_RAW SOCK_RAW SOCK_RDM = 4, /* Reliably-delivered messages. */ #define SOCK_RDM SOCK_RDM SOCK_SEQPACKET = 5, /* Sequenced, reliable, connection-based, datagrams of fixed maximum length. */ #define SOCK_SEQPACKET SOCK_SEQPACKET SOCK_DCCP = 6, /* Datagram Congestion Control Protocol. */ #define SOCK_DCCP SOCK_DCCP SOCK_PACKET = 10, /* Linux specific way of getting packets at the dev level. For writing rarp and other similar things on the user level. */ #define SOCK_PACKET SOCK_PACKET /* Flags to be ORed into the type parameter of socket and socketpair and used for the flags parameter of paccept. */ SOCK_CLOEXEC = 02000000, /* Atomically set close-on-exec flag for the new descriptor(s). */ #define SOCK_CLOEXEC SOCK_CLOEXEC SOCK_NONBLOCK = 00004000 /* Atomically mark descriptor(s) as non-blocking. */ #define SOCK_NONBLOCK SOCK_NONBLOCK }; termios-c_iflag.h 0000644 00000003620 15125171642 0007766 0 ustar 00 /* termios input mode definitions. Linux/generic version. Copyright (C) 2019-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library. If not, see <https://www.gnu.org/licenses/>. */ #ifndef _TERMIOS_H # error "Never include <bits/termios-ciflags.h> directly; use <termios.h> instead." #endif /* c_iflag bits */ #define IGNBRK 0000001 /* Ignore break condition. */ #define BRKINT 0000002 /* Signal interrupt on break. */ #define IGNPAR 0000004 /* Ignore characters with parity errors. */ #define PARMRK 0000010 /* Mark parity and framing errors. */ #define INPCK 0000020 /* Enable input parity check. */ #define ISTRIP 0000040 /* Strip 8th bit off characters. */ #define INLCR 0000100 /* Map NL to CR on input. */ #define IGNCR 0000200 /* Ignore CR. */ #define ICRNL 0000400 /* Map CR to NL on input. */ #define IUCLC 0001000 /* Map uppercase characters to lowercase on input (not in POSIX). */ #define IXON 0002000 /* Enable start/stop output control. */ #define IXANY 0004000 /* Enable any character to restart output. */ #define IXOFF 0010000 /* Enable start/stop input control. */ #define IMAXBEL 0020000 /* Ring bell when input queue is full (not in POSIX). */ #define IUTF8 0040000 /* Input is UTF8 (not in POSIX). */ ipctypes.h 0000644 00000002230 15125171642 0006556 0 ustar 00 /* bits/ipctypes.h -- Define some types used by SysV IPC/MSG/SHM. Copyright (C) 2012-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _SYS_IPC_H # error "Never use <bits/ipctypes.h> directly; include <sys/ipc.h> instead." #endif #ifndef _BITS_IPCTYPES_H #define _BITS_IPCTYPES_H 1 /* Used in `struct shmid_ds'. */ # ifdef __x86_64__ typedef int __ipc_pid_t; # else typedef unsigned short int __ipc_pid_t; # endif #endif /* bits/ipctypes.h */ socket-constants.h 0000644 00000004701 15125171642 0010225 0 ustar 00 /* Socket constants which vary among Linux architectures. Copyright (C) 2019-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _SYS_SOCKET_H # error "Never include <bits/socket-constants.h> directly; use <sys/socket.h> instead." #endif #include <bits/timesize.h> #define SOL_SOCKET 1 #define SO_ACCEPTCONN 30 #define SO_BROADCAST 6 #define SO_DONTROUTE 5 #define SO_ERROR 4 #define SO_KEEPALIVE 9 #define SO_LINGER 13 #define SO_OOBINLINE 10 #define SO_RCVBUF 8 #define SO_RCVLOWAT 18 #define SO_REUSEADDR 2 #define SO_SNDBUF 7 #define SO_SNDLOWAT 19 #define SO_TYPE 3 #if (__TIMESIZE == 64 && __WORDSIZE == 32 \ && (!defined __SYSCALL_WORDSIZE || __SYSCALL_WORDSIZE == 32)) # define SO_RCVTIMEO 66 # define SO_SNDTIMEO 67 # define SO_TIMESTAMP 63 # define SO_TIMESTAMPNS 64 # define SO_TIMESTAMPING 65 #else # if __TIMESIZE == 64 # define SO_RCVTIMEO 20 # define SO_SNDTIMEO 21 # define SO_TIMESTAMP 29 # define SO_TIMESTAMPNS 35 # define SO_TIMESTAMPING 37 # else # define SO_RCVTIMEO_OLD 20 # define SO_SNDTIMEO_OLD 21 # define SO_RCVTIMEO_NEW 66 # define SO_SNDTIMEO_NEW 67 # define SO_TIMESTAMP_OLD 29 # define SO_TIMESTAMPNS_OLD 35 # define SO_TIMESTAMPING_OLD 37 # define SO_TIMESTAMP_NEW 63 # define SO_TIMESTAMPNS_NEW 64 # define SO_TIMESTAMPING_NEW 65 # ifdef __USE_TIME_BITS64 # define SO_RCVTIMEO SO_RCVTIMEO_NEW # define SO_SNDTIMEO SO_SNDTIMEO_NEW # define SO_TIMESTAMP SO_TIMESTAMP_NEW # define SO_TIMESTAMPNS SO_TIMESTAMPNS_NEW # define SO_TIMESTAMPING SO_TIMESTAMPING_NEW # else # define SO_RCVTIMEO SO_RCVTIMEO_OLD # define SO_SNDTIMEO SO_SNDTIMEO_OLD # define SO_TIMESTAMP SO_TIMESTAMP_OLD # define SO_TIMESTAMPNS SO_TIMESTAMPNS_OLD # define SO_TIMESTAMPING SO_TIMESTAMPING_OLD # endif # endif #endif eventfd.h 0000644 00000002151 15125171642 0006353 0 ustar 00 /* Copyright (C) 2007-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _SYS_EVENTFD_H # error "Never use <bits/eventfd.h> directly; include <sys/eventfd.h> instead." #endif /* Flags for eventfd. */ enum { EFD_SEMAPHORE = 00000001, #define EFD_SEMAPHORE EFD_SEMAPHORE EFD_CLOEXEC = 02000000, #define EFD_CLOEXEC EFD_CLOEXEC EFD_NONBLOCK = 00004000 #define EFD_NONBLOCK EFD_NONBLOCK }; stdio.h 0000644 00000012737 15125171642 0006055 0 ustar 00 /* Optimizing macros and inline functions for stdio functions. Copyright (C) 1998-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _BITS_STDIO_H #define _BITS_STDIO_H 1 #ifndef _STDIO_H # error "Never include <bits/stdio.h> directly; use <stdio.h> instead." #endif #ifndef __extern_inline # define __STDIO_INLINE inline #else # define __STDIO_INLINE __extern_inline #endif #ifdef __USE_EXTERN_INLINES /* For -D_FORTIFY_SOURCE{,=2,=3} bits/stdio2.h will define a different inline. */ # if !(__USE_FORTIFY_LEVEL > 0 && defined __fortify_function) /* Write formatted output to stdout from argument list ARG. */ __STDIO_INLINE int vprintf (const char *__restrict __fmt, __gnuc_va_list __arg) { return vfprintf (stdout, __fmt, __arg); } # endif /* Read a character from stdin. */ __STDIO_INLINE int getchar (void) { return getc (stdin); } # ifdef __USE_MISC /* Faster version when locking is not necessary. */ __STDIO_INLINE int fgetc_unlocked (FILE *__fp) { return __getc_unlocked_body (__fp); } # endif /* misc */ # ifdef __USE_POSIX199506 /* This is defined in POSIX.1:1996. */ __STDIO_INLINE int getc_unlocked (FILE *__fp) { return __getc_unlocked_body (__fp); } /* This is defined in POSIX.1:1996. */ __STDIO_INLINE int getchar_unlocked (void) { return __getc_unlocked_body (stdin); } # endif /* POSIX */ /* Write a character to stdout. */ __STDIO_INLINE int putchar (int __c) { return putc (__c, stdout); } # ifdef __USE_MISC /* Faster version when locking is not necessary. */ __STDIO_INLINE int fputc_unlocked (int __c, FILE *__stream) { return __putc_unlocked_body (__c, __stream); } # endif /* misc */ # ifdef __USE_POSIX199506 /* This is defined in POSIX.1:1996. */ __STDIO_INLINE int putc_unlocked (int __c, FILE *__stream) { return __putc_unlocked_body (__c, __stream); } /* This is defined in POSIX.1:1996. */ __STDIO_INLINE int putchar_unlocked (int __c) { return __putc_unlocked_body (__c, stdout); } # endif /* POSIX */ # ifdef __USE_GNU /* Like `getdelim', but reads up to a newline. */ __STDIO_INLINE __ssize_t getline (char **__lineptr, size_t *__n, FILE *__stream) { return __getdelim (__lineptr, __n, '\n', __stream); } # endif /* GNU */ # ifdef __USE_MISC /* Faster versions when locking is not required. */ __STDIO_INLINE int __NTH (feof_unlocked (FILE *__stream)) { return __feof_unlocked_body (__stream); } /* Faster versions when locking is not required. */ __STDIO_INLINE int __NTH (ferror_unlocked (FILE *__stream)) { return __ferror_unlocked_body (__stream); } # endif /* misc */ #endif /* Use extern inlines. */ #if defined __USE_MISC && defined __GNUC__ && defined __OPTIMIZE__ \ && !defined __cplusplus /* Perform some simple optimizations. */ # define fread_unlocked(ptr, size, n, stream) \ (__extension__ ((__builtin_constant_p (size) && __builtin_constant_p (n) \ && (size_t) (size) * (size_t) (n) <= 8 \ && (size_t) (size) != 0) \ ? ({ char *__ptr = (char *) (ptr); \ FILE *__stream = (stream); \ size_t __cnt; \ for (__cnt = (size_t) (size) * (size_t) (n); \ __cnt > 0; --__cnt) \ { \ int __c = getc_unlocked (__stream); \ if (__c == EOF) \ break; \ *__ptr++ = __c; \ } \ ((size_t) (size) * (size_t) (n) - __cnt) \ / (size_t) (size); }) \ : (((__builtin_constant_p (size) && (size_t) (size) == 0) \ || (__builtin_constant_p (n) && (size_t) (n) == 0)) \ /* Evaluate all parameters once. */ \ ? ((void) (ptr), (void) (stream), (void) (size), \ (void) (n), (size_t) 0) \ : fread_unlocked (ptr, size, n, stream)))) # define fwrite_unlocked(ptr, size, n, stream) \ (__extension__ ((__builtin_constant_p (size) && __builtin_constant_p (n) \ && (size_t) (size) * (size_t) (n) <= 8 \ && (size_t) (size) != 0) \ ? ({ const char *__ptr = (const char *) (ptr); \ FILE *__stream = (stream); \ size_t __cnt; \ for (__cnt = (size_t) (size) * (size_t) (n); \ __cnt > 0; --__cnt) \ if (putc_unlocked (*__ptr++, __stream) == EOF) \ break; \ ((size_t) (size) * (size_t) (n) - __cnt) \ / (size_t) (size); }) \ : (((__builtin_constant_p (size) && (size_t) (size) == 0) \ || (__builtin_constant_p (n) && (size_t) (n) == 0)) \ /* Evaluate all parameters once. */ \ ? ((void) (ptr), (void) (stream), (void) (size), \ (void) (n), (size_t) 0) \ : fwrite_unlocked (ptr, size, n, stream)))) #endif /* Define helper macro. */ #undef __STDIO_INLINE #endif /* bits/stdio.h. */ posix_opt.h 0000644 00000013431 15125171642 0006747 0 ustar 00 /* Define POSIX options for Linux. Copyright (C) 1996-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; see the file COPYING.LIB. If not, see <https://www.gnu.org/licenses/>. */ #ifndef _BITS_POSIX_OPT_H #define _BITS_POSIX_OPT_H 1 /* Job control is supported. */ #define _POSIX_JOB_CONTROL 1 /* Processes have a saved set-user-ID and a saved set-group-ID. */ #define _POSIX_SAVED_IDS 1 /* Priority scheduling is not supported with the correct semantics, but GNU/Linux applications expect that the corresponding interfaces are available, even though the semantics do not meet the POSIX requirements. See glibc bug 14829. */ #define _POSIX_PRIORITY_SCHEDULING 200809L /* Synchronizing file data is supported. */ #define _POSIX_SYNCHRONIZED_IO 200809L /* The fsync function is present. */ #define _POSIX_FSYNC 200809L /* Mapping of files to memory is supported. */ #define _POSIX_MAPPED_FILES 200809L /* Locking of all memory is supported. */ #define _POSIX_MEMLOCK 200809L /* Locking of ranges of memory is supported. */ #define _POSIX_MEMLOCK_RANGE 200809L /* Setting of memory protections is supported. */ #define _POSIX_MEMORY_PROTECTION 200809L /* Some filesystems allow all users to change file ownership. */ #define _POSIX_CHOWN_RESTRICTED 0 /* `c_cc' member of 'struct termios' structure can be disabled by using the value _POSIX_VDISABLE. */ #define _POSIX_VDISABLE '\0' /* Filenames are not silently truncated. */ #define _POSIX_NO_TRUNC 1 /* X/Open realtime support is available. */ #define _XOPEN_REALTIME 1 /* X/Open thread realtime support is available. */ #define _XOPEN_REALTIME_THREADS 1 /* XPG4.2 shared memory is supported. */ #define _XOPEN_SHM 1 /* Tell we have POSIX threads. */ #define _POSIX_THREADS 200809L /* We have the reentrant functions described in POSIX. */ #define _POSIX_REENTRANT_FUNCTIONS 1 #define _POSIX_THREAD_SAFE_FUNCTIONS 200809L /* We provide priority scheduling for threads. */ #define _POSIX_THREAD_PRIORITY_SCHEDULING 200809L /* We support user-defined stack sizes. */ #define _POSIX_THREAD_ATTR_STACKSIZE 200809L /* We support user-defined stacks. */ #define _POSIX_THREAD_ATTR_STACKADDR 200809L /* We support priority inheritence. */ #define _POSIX_THREAD_PRIO_INHERIT 200809L /* We support priority protection, though only for non-robust mutexes. */ #define _POSIX_THREAD_PRIO_PROTECT 200809L #ifdef __USE_XOPEN2K8 /* We support priority inheritence for robust mutexes. */ # define _POSIX_THREAD_ROBUST_PRIO_INHERIT 200809L /* We do not support priority protection for robust mutexes. */ # define _POSIX_THREAD_ROBUST_PRIO_PROTECT -1 #endif /* We support POSIX.1b semaphores. */ #define _POSIX_SEMAPHORES 200809L /* Real-time signals are supported. */ #define _POSIX_REALTIME_SIGNALS 200809L /* We support asynchronous I/O. */ #define _POSIX_ASYNCHRONOUS_IO 200809L #define _POSIX_ASYNC_IO 1 /* Alternative name for Unix98. */ #define _LFS_ASYNCHRONOUS_IO 1 /* Support for prioritization is also available. */ #define _POSIX_PRIORITIZED_IO 200809L /* The LFS support in asynchronous I/O is also available. */ #define _LFS64_ASYNCHRONOUS_IO 1 /* The rest of the LFS is also available. */ #define _LFS_LARGEFILE 1 #define _LFS64_LARGEFILE 1 #define _LFS64_STDIO 1 /* POSIX shared memory objects are implemented. */ #define _POSIX_SHARED_MEMORY_OBJECTS 200809L /* CPU-time clocks support needs to be checked at runtime. */ #define _POSIX_CPUTIME 0 /* Clock support in threads must be also checked at runtime. */ #define _POSIX_THREAD_CPUTIME 0 /* GNU libc provides regular expression handling. */ #define _POSIX_REGEXP 1 /* Reader/Writer locks are available. */ #define _POSIX_READER_WRITER_LOCKS 200809L /* We have a POSIX shell. */ #define _POSIX_SHELL 1 /* We support the Timeouts option. */ #define _POSIX_TIMEOUTS 200809L /* We support spinlocks. */ #define _POSIX_SPIN_LOCKS 200809L /* The `spawn' function family is supported. */ #define _POSIX_SPAWN 200809L /* We have POSIX timers. */ #define _POSIX_TIMERS 200809L /* The barrier functions are available. */ #define _POSIX_BARRIERS 200809L /* POSIX message queues are available. */ #define _POSIX_MESSAGE_PASSING 200809L /* Thread process-shared synchronization is supported. */ #define _POSIX_THREAD_PROCESS_SHARED 200809L /* The monotonic clock might be available. */ #define _POSIX_MONOTONIC_CLOCK 0 /* The clock selection interfaces are available. */ #define _POSIX_CLOCK_SELECTION 200809L /* Advisory information interfaces are available. */ #define _POSIX_ADVISORY_INFO 200809L /* IPv6 support is available. */ #define _POSIX_IPV6 200809L /* Raw socket support is available. */ #define _POSIX_RAW_SOCKETS 200809L /* We have at least one terminal. */ #define _POSIX2_CHAR_TERM 200809L /* Neither process nor thread sporadic server interfaces is available. */ #define _POSIX_SPORADIC_SERVER -1 #define _POSIX_THREAD_SPORADIC_SERVER -1 /* trace.h is not available. */ #define _POSIX_TRACE -1 #define _POSIX_TRACE_EVENT_FILTER -1 #define _POSIX_TRACE_INHERIT -1 #define _POSIX_TRACE_LOG -1 /* Typed memory objects are not available. */ #define _POSIX_TYPED_MEMORY_OBJECTS -1 #endif /* bits/posix_opt.h */ uio-ext.h 0000644 00000003603 15125171642 0006315 0 ustar 00 /* Operating system-specific extensions to sys/uio.h - Linux version. Copyright (C) 1996-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _BITS_UIO_EXT_H #define _BITS_UIO_EXT_H 1 #ifndef _SYS_UIO_H # error "Never include <bits/uio-ext.h> directly; use <sys/uio.h> instead." #endif __BEGIN_DECLS /* Read from another process' address space. */ extern ssize_t process_vm_readv (pid_t __pid, const struct iovec *__lvec, unsigned long int __liovcnt, const struct iovec *__rvec, unsigned long int __riovcnt, unsigned long int __flags) __THROW; /* Write to another process' address space. */ extern ssize_t process_vm_writev (pid_t __pid, const struct iovec *__lvec, unsigned long int __liovcnt, const struct iovec *__rvec, unsigned long int __riovcnt, unsigned long int __flags) __THROW; /* Flags for preadv2/pwritev2. */ #define RWF_HIPRI 0x00000001 /* High priority request. */ #define RWF_DSYNC 0x00000002 /* per-IO O_DSYNC. */ #define RWF_SYNC 0x00000004 /* per-IO O_SYNC. */ #define RWF_NOWAIT 0x00000008 /* per-IO nonblocking mode. */ #define RWF_APPEND 0x00000010 /* per-IO O_APPEND. */ __END_DECLS #endif /* bits/uio-ext.h */ termios-c_oflag.h 0000644 00000005406 15125171642 0010000 0 ustar 00 /* termios output mode definitions. Linux/generic version. Copyright (C) 2019-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library. If not, see <https://www.gnu.org/licenses/>. */ #ifndef _TERMIOS_H # error "Never include <bits/termios-c_oflag.h> directly; use <termios.h> instead." #endif /* c_oflag bits */ #define OPOST 0000001 /* Post-process output. */ #define OLCUC 0000002 /* Map lowercase characters to uppercase on output. (not in POSIX). */ #define ONLCR 0000004 /* Map NL to CR-NL on output. */ #define OCRNL 0000010 /* Map CR to NL on output. */ #define ONOCR 0000020 /* No CR output at column 0. */ #define ONLRET 0000040 /* NL performs CR function. */ #define OFILL 0000100 /* Use fill characters for delay. */ #define OFDEL 0000200 /* Fill is DEL. */ #if defined __USE_MISC || defined __USE_XOPEN # define NLDLY 0000400 /* Select newline delays: */ # define NL0 0000000 /* Newline type 0. */ # define NL1 0000400 /* Newline type 1. */ # define CRDLY 0003000 /* Select carriage-return delays: */ # define CR0 0000000 /* Carriage-return delay type 0. */ # define CR1 0001000 /* Carriage-return delay type 1. */ # define CR2 0002000 /* Carriage-return delay type 2. */ # define CR3 0003000 /* Carriage-return delay type 3. */ # define TABDLY 0014000 /* Select horizontal-tab delays: */ # define TAB0 0000000 /* Horizontal-tab delay type 0. */ # define TAB1 0004000 /* Horizontal-tab delay type 1. */ # define TAB2 0010000 /* Horizontal-tab delay type 2. */ # define TAB3 0014000 /* Expand tabs to spaces. */ # define BSDLY 0020000 /* Select backspace delays: */ # define BS0 0000000 /* Backspace-delay type 0. */ # define BS1 0020000 /* Backspace-delay type 1. */ # define FFDLY 0100000 /* Select form-feed delays: */ # define FF0 0000000 /* Form-feed delay type 0. */ # define FF1 0100000 /* Form-feed delay type 1. */ #endif #define VTDLY 0040000 /* Select vertical-tab delays: */ #define VT0 0000000 /* Vertical-tab delay type 0. */ #define VT1 0040000 /* Vertical-tab delay type 1. */ #ifdef __USE_MISC # define XTABS 0014000 #endif ss_flags.h 0000644 00000002244 15125171642 0006524 0 ustar 00 /* ss_flags values for stack_t. Linux version. Copyright (C) 1998-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _BITS_SS_FLAGS_H #define _BITS_SS_FLAGS_H 1 #if !defined _SIGNAL_H && !defined _SYS_UCONTEXT_H # error "Never include this file directly. Use <signal.h> instead" #endif /* Possible values for `ss_flags'. */ enum { SS_ONSTACK = 1, #define SS_ONSTACK SS_ONSTACK SS_DISABLE #define SS_DISABLE SS_DISABLE }; #endif /* bits/ss_flags.h */ stdlib-float.h 0000644 00000002133 15125171642 0007304 0 ustar 00 /* Floating-point inline functions for stdlib.h. Copyright (C) 2012-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _STDLIB_H # error "Never use <bits/stdlib-float.h> directly; include <stdlib.h> instead." #endif #ifdef __USE_EXTERN_INLINES __extern_inline double __NTH (atof (const char *__nptr)) { return strtod (__nptr, (char **) NULL); } #endif /* Optimizing and Inlining. */ posix2_lim.h 0000644 00000005463 15125171642 0007016 0 ustar 00 /* Copyright (C) 1991-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ /* * Never include this file directly; include <limits.h> instead. */ #ifndef _BITS_POSIX2_LIM_H #define _BITS_POSIX2_LIM_H 1 /* The maximum `ibase' and `obase' values allowed by the `bc' utility. */ #define _POSIX2_BC_BASE_MAX 99 /* The maximum number of elements allowed in an array by the `bc' utility. */ #define _POSIX2_BC_DIM_MAX 2048 /* The maximum `scale' value allowed by the `bc' utility. */ #define _POSIX2_BC_SCALE_MAX 99 /* The maximum length of a string constant accepted by the `bc' utility. */ #define _POSIX2_BC_STRING_MAX 1000 /* The maximum number of weights that can be assigned to an entry of the LC_COLLATE `order' keyword in the locale definition file. */ #define _POSIX2_COLL_WEIGHTS_MAX 2 /* The maximum number of expressions that can be nested within parentheses by the `expr' utility. */ #define _POSIX2_EXPR_NEST_MAX 32 /* The maximum length, in bytes, of an input line. */ #define _POSIX2_LINE_MAX 2048 /* The maximum number of repeated occurrences of a regular expression permitted when using the interval notation `\{M,N\}'. */ #define _POSIX2_RE_DUP_MAX 255 /* The maximum number of bytes in a character class name. We have no fixed limit, 2048 is a high number. */ #define _POSIX2_CHARCLASS_NAME_MAX 14 /* These values are implementation-specific, and may vary within the implementation. Their precise values can be obtained from sysconf. */ #ifndef BC_BASE_MAX #define BC_BASE_MAX _POSIX2_BC_BASE_MAX #endif #ifndef BC_DIM_MAX #define BC_DIM_MAX _POSIX2_BC_DIM_MAX #endif #ifndef BC_SCALE_MAX #define BC_SCALE_MAX _POSIX2_BC_SCALE_MAX #endif #ifndef BC_STRING_MAX #define BC_STRING_MAX _POSIX2_BC_STRING_MAX #endif #ifndef COLL_WEIGHTS_MAX #define COLL_WEIGHTS_MAX 255 #endif #ifndef EXPR_NEST_MAX #define EXPR_NEST_MAX _POSIX2_EXPR_NEST_MAX #endif #ifndef LINE_MAX #define LINE_MAX _POSIX2_LINE_MAX #endif #ifndef CHARCLASS_NAME_MAX #define CHARCLASS_NAME_MAX 2048 #endif /* This value is defined like this in regex.h. */ #define RE_DUP_MAX (0x7fff) #endif /* bits/posix2_lim.h */ stdio2.h 0000644 00000023515 15125171642 0006133 0 ustar 00 /* Checking macros for stdio functions. Copyright (C) 2004-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _BITS_STDIO2_H #define _BITS_STDIO2_H 1 #ifndef _STDIO_H # error "Never include <bits/stdio2.h> directly; use <stdio.h> instead." #endif #ifdef __va_arg_pack __fortify_function int __NTH (sprintf (char *__restrict __s, const char *__restrict __fmt, ...)) { return __builtin___sprintf_chk (__s, __USE_FORTIFY_LEVEL - 1, __glibc_objsize (__s), __fmt, __va_arg_pack ()); } #elif !defined __cplusplus # define sprintf(str, ...) \ __builtin___sprintf_chk (str, __USE_FORTIFY_LEVEL - 1, \ __glibc_objsize (str), __VA_ARGS__) #endif __fortify_function int __NTH (vsprintf (char *__restrict __s, const char *__restrict __fmt, __gnuc_va_list __ap)) { return __builtin___vsprintf_chk (__s, __USE_FORTIFY_LEVEL - 1, __glibc_objsize (__s), __fmt, __ap); } #if defined __USE_ISOC99 || defined __USE_UNIX98 # ifdef __va_arg_pack __fortify_function int __NTH (snprintf (char *__restrict __s, size_t __n, const char *__restrict __fmt, ...)) { return __builtin___snprintf_chk (__s, __n, __USE_FORTIFY_LEVEL - 1, __glibc_objsize (__s), __fmt, __va_arg_pack ()); } # elif !defined __cplusplus # define snprintf(str, len, ...) \ __builtin___snprintf_chk (str, len, __USE_FORTIFY_LEVEL - 1, \ __glibc_objsize (str), __VA_ARGS__) # endif __fortify_function int __NTH (vsnprintf (char *__restrict __s, size_t __n, const char *__restrict __fmt, __gnuc_va_list __ap)) { return __builtin___vsnprintf_chk (__s, __n, __USE_FORTIFY_LEVEL - 1, __glibc_objsize (__s), __fmt, __ap); } #endif #if __USE_FORTIFY_LEVEL > 1 # ifdef __va_arg_pack __fortify_function int fprintf (FILE *__restrict __stream, const char *__restrict __fmt, ...) { return __fprintf_chk (__stream, __USE_FORTIFY_LEVEL - 1, __fmt, __va_arg_pack ()); } __fortify_function int printf (const char *__restrict __fmt, ...) { return __printf_chk (__USE_FORTIFY_LEVEL - 1, __fmt, __va_arg_pack ()); } # elif !defined __cplusplus # define printf(...) \ __printf_chk (__USE_FORTIFY_LEVEL - 1, __VA_ARGS__) # define fprintf(stream, ...) \ __fprintf_chk (stream, __USE_FORTIFY_LEVEL - 1, __VA_ARGS__) # endif __fortify_function int vprintf (const char *__restrict __fmt, __gnuc_va_list __ap) { #ifdef __USE_EXTERN_INLINES return __vfprintf_chk (stdout, __USE_FORTIFY_LEVEL - 1, __fmt, __ap); #else return __vprintf_chk (__USE_FORTIFY_LEVEL - 1, __fmt, __ap); #endif } __fortify_function int vfprintf (FILE *__restrict __stream, const char *__restrict __fmt, __gnuc_va_list __ap) { return __vfprintf_chk (__stream, __USE_FORTIFY_LEVEL - 1, __fmt, __ap); } # ifdef __USE_XOPEN2K8 # ifdef __va_arg_pack __fortify_function int dprintf (int __fd, const char *__restrict __fmt, ...) { return __dprintf_chk (__fd, __USE_FORTIFY_LEVEL - 1, __fmt, __va_arg_pack ()); } # elif !defined __cplusplus # define dprintf(fd, ...) \ __dprintf_chk (fd, __USE_FORTIFY_LEVEL - 1, __VA_ARGS__) # endif __fortify_function int vdprintf (int __fd, const char *__restrict __fmt, __gnuc_va_list __ap) { return __vdprintf_chk (__fd, __USE_FORTIFY_LEVEL - 1, __fmt, __ap); } # endif # ifdef __USE_GNU # ifdef __va_arg_pack __fortify_function int __NTH (asprintf (char **__restrict __ptr, const char *__restrict __fmt, ...)) { return __asprintf_chk (__ptr, __USE_FORTIFY_LEVEL - 1, __fmt, __va_arg_pack ()); } __fortify_function int __NTH (__asprintf (char **__restrict __ptr, const char *__restrict __fmt, ...)) { return __asprintf_chk (__ptr, __USE_FORTIFY_LEVEL - 1, __fmt, __va_arg_pack ()); } __fortify_function int __NTH (obstack_printf (struct obstack *__restrict __obstack, const char *__restrict __fmt, ...)) { return __obstack_printf_chk (__obstack, __USE_FORTIFY_LEVEL - 1, __fmt, __va_arg_pack ()); } # elif !defined __cplusplus # define asprintf(ptr, ...) \ __asprintf_chk (ptr, __USE_FORTIFY_LEVEL - 1, __VA_ARGS__) # define __asprintf(ptr, ...) \ __asprintf_chk (ptr, __USE_FORTIFY_LEVEL - 1, __VA_ARGS__) # define obstack_printf(obstack, ...) \ __obstack_printf_chk (obstack, __USE_FORTIFY_LEVEL - 1, __VA_ARGS__) # endif __fortify_function int __NTH (vasprintf (char **__restrict __ptr, const char *__restrict __fmt, __gnuc_va_list __ap)) { return __vasprintf_chk (__ptr, __USE_FORTIFY_LEVEL - 1, __fmt, __ap); } __fortify_function int __NTH (obstack_vprintf (struct obstack *__restrict __obstack, const char *__restrict __fmt, __gnuc_va_list __ap)) { return __obstack_vprintf_chk (__obstack, __USE_FORTIFY_LEVEL - 1, __fmt, __ap); } # endif #endif #if __GLIBC_USE (DEPRECATED_GETS) extern char *__REDIRECT (__gets_warn, (char *__str), gets) __wur __warnattr ("please use fgets or getline instead, gets can't " "specify buffer size"); __fortify_function __wur char * gets (char *__str) { if (__glibc_objsize (__str) != (size_t) -1) return __gets_chk (__str, __glibc_objsize (__str)); return __gets_warn (__str); } #endif extern char *__REDIRECT (__fgets_alias, (char *__restrict __s, int __n, FILE *__restrict __stream), fgets) __wur __attr_access ((__write_only__, 1, 2)); extern char *__REDIRECT (__fgets_chk_warn, (char *__restrict __s, size_t __size, int __n, FILE *__restrict __stream), __fgets_chk) __wur __warnattr ("fgets called with bigger size than length " "of destination buffer"); __fortify_function __wur __fortified_attr_access (__write_only__, 1, 2) char * fgets (char *__restrict __s, int __n, FILE *__restrict __stream) { size_t sz = __glibc_objsize (__s); if (__glibc_safe_or_unknown_len (__n, sizeof (char), sz)) return __fgets_alias (__s, __n, __stream); if (__glibc_unsafe_len (__n, sizeof (char), sz)) return __fgets_chk_warn (__s, sz, __n, __stream); return __fgets_chk (__s, sz, __n, __stream); } extern size_t __REDIRECT (__fread_alias, (void *__restrict __ptr, size_t __size, size_t __n, FILE *__restrict __stream), fread) __wur; extern size_t __REDIRECT (__fread_chk_warn, (void *__restrict __ptr, size_t __ptrlen, size_t __size, size_t __n, FILE *__restrict __stream), __fread_chk) __wur __warnattr ("fread called with bigger size * nmemb than length " "of destination buffer"); __fortify_function __wur size_t fread (void *__restrict __ptr, size_t __size, size_t __n, FILE *__restrict __stream) { size_t sz = __glibc_objsize0 (__ptr); if (__glibc_safe_or_unknown_len (__n, __size, sz)) return __fread_alias (__ptr, __size, __n, __stream); if (__glibc_unsafe_len (__n, __size, sz)) return __fread_chk_warn (__ptr, sz, __size, __n, __stream); return __fread_chk (__ptr, sz, __size, __n, __stream); } #ifdef __USE_GNU extern char *__REDIRECT (__fgets_unlocked_alias, (char *__restrict __s, int __n, FILE *__restrict __stream), fgets_unlocked) __wur __attr_access ((__write_only__, 1, 2)); extern char *__REDIRECT (__fgets_unlocked_chk_warn, (char *__restrict __s, size_t __size, int __n, FILE *__restrict __stream), __fgets_unlocked_chk) __wur __warnattr ("fgets_unlocked called with bigger size than length " "of destination buffer"); __fortify_function __wur __fortified_attr_access (__write_only__, 1, 2) char * fgets_unlocked (char *__restrict __s, int __n, FILE *__restrict __stream) { size_t sz = __glibc_objsize (__s); if (__glibc_safe_or_unknown_len (__n, sizeof (char), sz)) return __fgets_unlocked_alias (__s, __n, __stream); if (__glibc_unsafe_len (__n, sizeof (char), sz)) return __fgets_unlocked_chk_warn (__s, sz, __n, __stream); return __fgets_unlocked_chk (__s, sz, __n, __stream); } #endif #ifdef __USE_MISC # undef fread_unlocked extern size_t __REDIRECT (__fread_unlocked_alias, (void *__restrict __ptr, size_t __size, size_t __n, FILE *__restrict __stream), fread_unlocked) __wur; extern size_t __REDIRECT (__fread_unlocked_chk_warn, (void *__restrict __ptr, size_t __ptrlen, size_t __size, size_t __n, FILE *__restrict __stream), __fread_unlocked_chk) __wur __warnattr ("fread_unlocked called with bigger size * nmemb than " "length of destination buffer"); __fortify_function __wur size_t fread_unlocked (void *__restrict __ptr, size_t __size, size_t __n, FILE *__restrict __stream) { size_t sz = __glibc_objsize0 (__ptr); if (__glibc_safe_or_unknown_len (__n, __size, sz)) { # ifdef __USE_EXTERN_INLINES if (__builtin_constant_p (__size) && __builtin_constant_p (__n) && (__size | __n) < (((size_t) 1) << (8 * sizeof (size_t) / 2)) && __size * __n <= 8) { size_t __cnt = __size * __n; char *__cptr = (char *) __ptr; if (__cnt == 0) return 0; for (; __cnt > 0; --__cnt) { int __c = getc_unlocked (__stream); if (__c == EOF) break; *__cptr++ = __c; } return (__cptr - (char *) __ptr) / __size; } # endif return __fread_unlocked_alias (__ptr, __size, __n, __stream); } if (__glibc_unsafe_len (__n, __size, sz)) return __fread_unlocked_chk_warn (__ptr, sz, __size, __n, __stream); return __fread_unlocked_chk (__ptr, sz, __size, __n, __stream); } #endif #endif /* bits/stdio2.h. */ platform/x86.h 0000644 00000030641 15125171642 0007176 0 ustar 00 /* Constants and data structures for x86 CPU features. This file is part of the GNU C Library. Copyright (C) 2008-2020 Free Software Foundation, Inc. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _SYS_PLATFORM_X86_H # error "Never include <bits/platform/x86.h> directly; use <sys/platform/x86.h> instead." #endif enum { CPUID_INDEX_1 = 0, CPUID_INDEX_7, CPUID_INDEX_80000001, CPUID_INDEX_D_ECX_1, CPUID_INDEX_80000007, CPUID_INDEX_80000008, CPUID_INDEX_7_ECX_1, CPUID_INDEX_19, CPUID_INDEX_14_ECX_0 }; struct cpuid_feature { unsigned int cpuid_array[4]; unsigned int active_array[4]; }; enum cpuid_register_index { cpuid_register_index_eax = 0, cpuid_register_index_ebx, cpuid_register_index_ecx, cpuid_register_index_edx }; /* CPU features. */ enum { x86_cpu_index_1_ecx = (CPUID_INDEX_1 * 8 * 4 * sizeof (unsigned int) + cpuid_register_index_ecx * 8 * sizeof (unsigned int)), x86_cpu_SSE3 = x86_cpu_index_1_ecx, x86_cpu_PCLMULQDQ = x86_cpu_index_1_ecx + 1, x86_cpu_DTES64 = x86_cpu_index_1_ecx + 2, x86_cpu_MONITOR = x86_cpu_index_1_ecx + 3, x86_cpu_DS_CPL = x86_cpu_index_1_ecx + 4, x86_cpu_VMX = x86_cpu_index_1_ecx + 5, x86_cpu_SMX = x86_cpu_index_1_ecx + 6, x86_cpu_EIST = x86_cpu_index_1_ecx + 7, x86_cpu_TM2 = x86_cpu_index_1_ecx + 8, x86_cpu_SSSE3 = x86_cpu_index_1_ecx + 9, x86_cpu_CNXT_ID = x86_cpu_index_1_ecx + 10, x86_cpu_SDBG = x86_cpu_index_1_ecx + 11, x86_cpu_FMA = x86_cpu_index_1_ecx + 12, x86_cpu_CMPXCHG16B = x86_cpu_index_1_ecx + 13, x86_cpu_XTPRUPDCTRL = x86_cpu_index_1_ecx + 14, x86_cpu_PDCM = x86_cpu_index_1_ecx + 15, x86_cpu_INDEX_1_ECX_16 = x86_cpu_index_1_ecx + 16, x86_cpu_PCID = x86_cpu_index_1_ecx + 17, x86_cpu_DCA = x86_cpu_index_1_ecx + 18, x86_cpu_SSE4_1 = x86_cpu_index_1_ecx + 19, x86_cpu_SSE4_2 = x86_cpu_index_1_ecx + 20, x86_cpu_X2APIC = x86_cpu_index_1_ecx + 21, x86_cpu_MOVBE = x86_cpu_index_1_ecx + 22, x86_cpu_POPCNT = x86_cpu_index_1_ecx + 23, x86_cpu_TSC_DEADLINE = x86_cpu_index_1_ecx + 24, x86_cpu_AES = x86_cpu_index_1_ecx + 25, x86_cpu_XSAVE = x86_cpu_index_1_ecx + 26, x86_cpu_OSXSAVE = x86_cpu_index_1_ecx + 27, x86_cpu_AVX = x86_cpu_index_1_ecx + 28, x86_cpu_F16C = x86_cpu_index_1_ecx + 29, x86_cpu_RDRAND = x86_cpu_index_1_ecx + 30, x86_cpu_INDEX_1_ECX_31 = x86_cpu_index_1_ecx + 31, x86_cpu_index_1_edx = (CPUID_INDEX_1 * 8 * 4 * sizeof (unsigned int) + cpuid_register_index_edx * 8 * sizeof (unsigned int)), x86_cpu_FPU = x86_cpu_index_1_edx, x86_cpu_VME = x86_cpu_index_1_edx + 1, x86_cpu_DE = x86_cpu_index_1_edx + 2, x86_cpu_PSE = x86_cpu_index_1_edx + 3, x86_cpu_TSC = x86_cpu_index_1_edx + 4, x86_cpu_MSR = x86_cpu_index_1_edx + 5, x86_cpu_PAE = x86_cpu_index_1_edx + 6, x86_cpu_MCE = x86_cpu_index_1_edx + 7, x86_cpu_CX8 = x86_cpu_index_1_edx + 8, x86_cpu_APIC = x86_cpu_index_1_edx + 9, x86_cpu_INDEX_1_EDX_10 = x86_cpu_index_1_edx + 10, x86_cpu_SEP = x86_cpu_index_1_edx + 11, x86_cpu_MTRR = x86_cpu_index_1_edx + 12, x86_cpu_PGE = x86_cpu_index_1_edx + 13, x86_cpu_MCA = x86_cpu_index_1_edx + 14, x86_cpu_CMOV = x86_cpu_index_1_edx + 15, x86_cpu_PAT = x86_cpu_index_1_edx + 16, x86_cpu_PSE_36 = x86_cpu_index_1_edx + 17, x86_cpu_PSN = x86_cpu_index_1_edx + 18, x86_cpu_CLFSH = x86_cpu_index_1_edx + 19, x86_cpu_INDEX_1_EDX_20 = x86_cpu_index_1_edx + 20, x86_cpu_DS = x86_cpu_index_1_edx + 21, x86_cpu_ACPI = x86_cpu_index_1_edx + 22, x86_cpu_MMX = x86_cpu_index_1_edx + 23, x86_cpu_FXSR = x86_cpu_index_1_edx + 24, x86_cpu_SSE = x86_cpu_index_1_edx + 25, x86_cpu_SSE2 = x86_cpu_index_1_edx + 26, x86_cpu_SS = x86_cpu_index_1_edx + 27, x86_cpu_HTT = x86_cpu_index_1_edx + 28, x86_cpu_TM = x86_cpu_index_1_edx + 29, x86_cpu_INDEX_1_EDX_30 = x86_cpu_index_1_edx + 30, x86_cpu_PBE = x86_cpu_index_1_edx + 31, x86_cpu_index_7_ebx = (CPUID_INDEX_7 * 8 * 4 * sizeof (unsigned int) + cpuid_register_index_ebx * 8 * sizeof (unsigned int)), x86_cpu_FSGSBASE = x86_cpu_index_7_ebx, x86_cpu_TSC_ADJUST = x86_cpu_index_7_ebx + 1, x86_cpu_SGX = x86_cpu_index_7_ebx + 2, x86_cpu_BMI1 = x86_cpu_index_7_ebx + 3, x86_cpu_HLE = x86_cpu_index_7_ebx + 4, x86_cpu_AVX2 = x86_cpu_index_7_ebx + 5, x86_cpu_INDEX_7_EBX_6 = x86_cpu_index_7_ebx + 6, x86_cpu_SMEP = x86_cpu_index_7_ebx + 7, x86_cpu_BMI2 = x86_cpu_index_7_ebx + 8, x86_cpu_ERMS = x86_cpu_index_7_ebx + 9, x86_cpu_INVPCID = x86_cpu_index_7_ebx + 10, x86_cpu_RTM = x86_cpu_index_7_ebx + 11, x86_cpu_RDT_M = x86_cpu_index_7_ebx + 12, x86_cpu_DEPR_FPU_CS_DS = x86_cpu_index_7_ebx + 13, x86_cpu_MPX = x86_cpu_index_7_ebx + 14, x86_cpu_RDT_A = x86_cpu_index_7_ebx + 15, x86_cpu_AVX512F = x86_cpu_index_7_ebx + 16, x86_cpu_AVX512DQ = x86_cpu_index_7_ebx + 17, x86_cpu_RDSEED = x86_cpu_index_7_ebx + 18, x86_cpu_ADX = x86_cpu_index_7_ebx + 19, x86_cpu_SMAP = x86_cpu_index_7_ebx + 20, x86_cpu_AVX512_IFMA = x86_cpu_index_7_ebx + 21, x86_cpu_INDEX_7_EBX_22 = x86_cpu_index_7_ebx + 22, x86_cpu_CLFLUSHOPT = x86_cpu_index_7_ebx + 23, x86_cpu_CLWB = x86_cpu_index_7_ebx + 24, x86_cpu_TRACE = x86_cpu_index_7_ebx + 25, x86_cpu_AVX512PF = x86_cpu_index_7_ebx + 26, x86_cpu_AVX512ER = x86_cpu_index_7_ebx + 27, x86_cpu_AVX512CD = x86_cpu_index_7_ebx + 28, x86_cpu_SHA = x86_cpu_index_7_ebx + 29, x86_cpu_AVX512BW = x86_cpu_index_7_ebx + 30, x86_cpu_AVX512VL = x86_cpu_index_7_ebx + 31, x86_cpu_index_7_ecx = (CPUID_INDEX_7 * 8 * 4 * sizeof (unsigned int) + cpuid_register_index_ecx * 8 * sizeof (unsigned int)), x86_cpu_PREFETCHWT1 = x86_cpu_index_7_ecx, x86_cpu_AVX512_VBMI = x86_cpu_index_7_ecx + 1, x86_cpu_UMIP = x86_cpu_index_7_ecx + 2, x86_cpu_PKU = x86_cpu_index_7_ecx + 3, x86_cpu_OSPKE = x86_cpu_index_7_ecx + 4, x86_cpu_WAITPKG = x86_cpu_index_7_ecx + 5, x86_cpu_AVX512_VBMI2 = x86_cpu_index_7_ecx + 6, x86_cpu_SHSTK = x86_cpu_index_7_ecx + 7, x86_cpu_GFNI = x86_cpu_index_7_ecx + 8, x86_cpu_VAES = x86_cpu_index_7_ecx + 9, x86_cpu_VPCLMULQDQ = x86_cpu_index_7_ecx + 10, x86_cpu_AVX512_VNNI = x86_cpu_index_7_ecx + 11, x86_cpu_AVX512_BITALG = x86_cpu_index_7_ecx + 12, x86_cpu_INDEX_7_ECX_13 = x86_cpu_index_7_ecx + 13, x86_cpu_AVX512_VPOPCNTDQ = x86_cpu_index_7_ecx + 14, x86_cpu_INDEX_7_ECX_1 = x86_cpu_index_7_ecx + 15, x86_cpu_INDEX_7_ECX_16 = x86_cpu_index_7_ecx + 16, /* Note: Bits 17-21: The value of MAWAU used by the BNDLDX and BNDSTX instructions in 64-bit mode. */ x86_cpu_RDPID = x86_cpu_index_7_ecx + 22, x86_cpu_KL = x86_cpu_index_7_ecx + 23, x86_cpu_INDEX_7_ECX_24 = x86_cpu_index_7_ecx + 24, x86_cpu_CLDEMOTE = x86_cpu_index_7_ecx + 25, x86_cpu_INDEX_7_ECX_26 = x86_cpu_index_7_ecx + 26, x86_cpu_MOVDIRI = x86_cpu_index_7_ecx + 27, x86_cpu_MOVDIR64B = x86_cpu_index_7_ecx + 28, x86_cpu_ENQCMD = x86_cpu_index_7_ecx + 29, x86_cpu_SGX_LC = x86_cpu_index_7_ecx + 30, x86_cpu_PKS = x86_cpu_index_7_ecx + 31, x86_cpu_index_7_edx = (CPUID_INDEX_7 * 8 * 4 * sizeof (unsigned int) + cpuid_register_index_edx * 8 * sizeof (unsigned int)), x86_cpu_INDEX_7_EDX_0 = x86_cpu_index_7_edx, x86_cpu_INDEX_7_EDX_1 = x86_cpu_index_7_edx + 1, x86_cpu_AVX512_4VNNIW = x86_cpu_index_7_edx + 2, x86_cpu_AVX512_4FMAPS = x86_cpu_index_7_edx + 3, x86_cpu_FSRM = x86_cpu_index_7_edx + 4, x86_cpu_UINTR = x86_cpu_index_7_edx + 5, x86_cpu_INDEX_7_EDX_6 = x86_cpu_index_7_edx + 6, x86_cpu_INDEX_7_EDX_7 = x86_cpu_index_7_edx + 7, x86_cpu_AVX512_VP2INTERSECT = x86_cpu_index_7_edx + 8, x86_cpu_INDEX_7_EDX_9 = x86_cpu_index_7_edx + 9, x86_cpu_MD_CLEAR = x86_cpu_index_7_edx + 10, x86_cpu_RTM_ALWAYS_ABORT = x86_cpu_index_7_edx + 11, x86_cpu_INDEX_7_EDX_12 = x86_cpu_index_7_edx + 12, x86_cpu_INDEX_7_EDX_13 = x86_cpu_index_7_edx + 13, x86_cpu_SERIALIZE = x86_cpu_index_7_edx + 14, x86_cpu_HYBRID = x86_cpu_index_7_edx + 15, x86_cpu_TSXLDTRK = x86_cpu_index_7_edx + 16, x86_cpu_INDEX_7_EDX_17 = x86_cpu_index_7_edx + 17, x86_cpu_PCONFIG = x86_cpu_index_7_edx + 18, x86_cpu_INDEX_7_EDX_19 = x86_cpu_index_7_edx + 19, x86_cpu_IBT = x86_cpu_index_7_edx + 20, x86_cpu_INDEX_7_EDX_21 = x86_cpu_index_7_edx + 21, x86_cpu_AMX_BF16 = x86_cpu_index_7_edx + 22, x86_cpu_AVX512_FP16 = x86_cpu_index_7_edx + 23, x86_cpu_AMX_TILE = x86_cpu_index_7_edx + 24, x86_cpu_AMX_INT8 = x86_cpu_index_7_edx + 25, x86_cpu_IBRS_IBPB = x86_cpu_index_7_edx + 26, x86_cpu_STIBP = x86_cpu_index_7_edx + 27, x86_cpu_L1D_FLUSH = x86_cpu_index_7_edx + 28, x86_cpu_ARCH_CAPABILITIES = x86_cpu_index_7_edx + 29, x86_cpu_CORE_CAPABILITIES = x86_cpu_index_7_edx + 30, x86_cpu_SSBD = x86_cpu_index_7_edx + 31, x86_cpu_index_80000001_ecx = (CPUID_INDEX_80000001 * 8 * 4 * sizeof (unsigned int) + cpuid_register_index_ecx * 8 * sizeof (unsigned int)), x86_cpu_LAHF64_SAHF64 = x86_cpu_index_80000001_ecx, x86_cpu_SVM = x86_cpu_index_80000001_ecx + 2, x86_cpu_LZCNT = x86_cpu_index_80000001_ecx + 5, x86_cpu_SSE4A = x86_cpu_index_80000001_ecx + 6, x86_cpu_PREFETCHW = x86_cpu_index_80000001_ecx + 8, x86_cpu_XOP = x86_cpu_index_80000001_ecx + 11, x86_cpu_LWP = x86_cpu_index_80000001_ecx + 15, x86_cpu_FMA4 = x86_cpu_index_80000001_ecx + 16, x86_cpu_TBM = x86_cpu_index_80000001_ecx + 21, x86_cpu_index_80000001_edx = (CPUID_INDEX_80000001 * 8 * 4 * sizeof (unsigned int) + cpuid_register_index_edx * 8 * sizeof (unsigned int)), x86_cpu_SYSCALL_SYSRET = x86_cpu_index_80000001_edx + 11, x86_cpu_NX = x86_cpu_index_80000001_edx + 20, x86_cpu_PAGE1GB = x86_cpu_index_80000001_edx + 26, x86_cpu_RDTSCP = x86_cpu_index_80000001_edx + 27, x86_cpu_LM = x86_cpu_index_80000001_edx + 29, x86_cpu_index_d_ecx_1_eax = (CPUID_INDEX_D_ECX_1 * 8 * 4 * sizeof (unsigned int) + cpuid_register_index_eax * 8 * sizeof (unsigned int)), x86_cpu_XSAVEOPT = x86_cpu_index_d_ecx_1_eax, x86_cpu_XSAVEC = x86_cpu_index_d_ecx_1_eax + 1, x86_cpu_XGETBV_ECX_1 = x86_cpu_index_d_ecx_1_eax + 2, x86_cpu_XSAVES = x86_cpu_index_d_ecx_1_eax + 3, x86_cpu_XFD = x86_cpu_index_d_ecx_1_eax + 4, x86_cpu_index_80000007_edx = (CPUID_INDEX_80000007 * 8 * 4 * sizeof (unsigned int) + cpuid_register_index_edx * 8 * sizeof (unsigned int)), x86_cpu_INVARIANT_TSC = x86_cpu_index_80000007_edx + 8, x86_cpu_index_80000008_ebx = (CPUID_INDEX_80000008 * 8 * 4 * sizeof (unsigned int) + cpuid_register_index_ebx * 8 * sizeof (unsigned int)), x86_cpu_WBNOINVD = x86_cpu_index_80000008_ebx + 9, x86_cpu_AMD_IBPB = x86_cpu_index_80000008_ebx + 12, x86_cpu_AMD_IBRS = x86_cpu_index_80000008_ebx + 14, x86_cpu_AMD_STIBP = x86_cpu_index_80000008_ebx + 15, x86_cpu_AMD_SSBD = x86_cpu_index_80000008_ebx + 24, x86_cpu_AMD_VIRT_SSBD = x86_cpu_index_80000008_ebx + 25, x86_cpu_index_7_ecx_1_eax = (CPUID_INDEX_7_ECX_1 * 8 * 4 * sizeof (unsigned int) + cpuid_register_index_eax * 8 * sizeof (unsigned int)), x86_cpu_AVX_VNNI = x86_cpu_index_7_ecx_1_eax + 4, x86_cpu_AVX512_BF16 = x86_cpu_index_7_ecx_1_eax + 5, x86_cpu_FZLRM = x86_cpu_index_7_ecx_1_eax + 10, x86_cpu_FSRS = x86_cpu_index_7_ecx_1_eax + 11, x86_cpu_FSRCS = x86_cpu_index_7_ecx_1_eax + 12, x86_cpu_HRESET = x86_cpu_index_7_ecx_1_eax + 22, x86_cpu_LAM = x86_cpu_index_7_ecx_1_eax + 26, x86_cpu_index_19_ebx = (CPUID_INDEX_19 * 8 * 4 * sizeof (unsigned int) + cpuid_register_index_ebx * 8 * sizeof (unsigned int)), x86_cpu_AESKLE = x86_cpu_index_19_ebx, x86_cpu_WIDE_KL = x86_cpu_index_19_ebx + 2, x86_cpu_index_14_ecx_0_ebx = (CPUID_INDEX_14_ECX_0 * 8 * 4 * sizeof (unsigned int) + cpuid_register_index_ebx * 8 * sizeof (unsigned int)), x86_cpu_PTWRITE = x86_cpu_index_14_ecx_0_ebx + 4 }; endianness.h 0000644 00000000421 15125171642 0007045 0 ustar 00 #ifndef _BITS_ENDIANNESS_H #define _BITS_ENDIANNESS_H 1 #ifndef _BITS_ENDIAN_H # error "Never use <bits/endianness.h> directly; include <endian.h> instead." #endif /* i386/x86_64 are little-endian. */ #define __BYTE_ORDER __LITTLE_ENDIAN #endif /* bits/endianness.h */ siginfo-consts-arch.h 0000644 00000000314 15125171642 0010577 0 ustar 00 /* Architecture-specific additional siginfo constants. */ #ifndef _BITS_SIGINFO_CONSTS_ARCH_H #define _BITS_SIGINFO_CONSTS_ARCH_H 1 /* This architecture has no additional siginfo constants. */ #endif termios-c_lflag.h 0000644 00000005042 15125171642 0007771 0 ustar 00 /* termios local mode definitions. Linux/generic version. Copyright (C) 2019-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library. If not, see <https://www.gnu.org/licenses/>. */ #ifndef _TERMIOS_H # error "Never include <bits/termios-c_lflag.h> directly; use <termios.h> instead." #endif /* c_lflag bits */ #define ISIG 0000001 /* Enable signals. */ #define ICANON 0000002 /* Canonical input (erase and kill processing). */ #if defined __USE_MISC || (defined __USE_XOPEN && !defined __USE_XOPEN2K) # define XCASE 0000004 #endif #define ECHO 0000010 /* Enable echo. */ #define ECHOE 0000020 /* Echo erase character as error-correcting backspace. */ #define ECHOK 0000040 /* Echo KILL. */ #define ECHONL 0000100 /* Echo NL. */ #define NOFLSH 0000200 /* Disable flush after interrupt or quit. */ #define TOSTOP 0000400 /* Send SIGTTOU for background output. */ #ifdef __USE_MISC # define ECHOCTL 0001000 /* If ECHO is also set, terminal special characters other than TAB, NL, START, and STOP are echoed as ^X, where X is the character with ASCII code 0x40 greater than the special character (not in POSIX). */ # define ECHOPRT 0002000 /* If ICANON and ECHO are also set, characters are printed as they are being erased (not in POSIX). */ # define ECHOKE 0004000 /* If ICANON is also set, KILL is echoed by erasing each character on the line, as specified by ECHOE and ECHOPRT (not in POSIX). */ # define FLUSHO 0010000 /* Output is being flushed. This flag is toggled by typing the DISCARD character (not in POSIX). */ # define PENDIN 0040000 /* All characters in the input queue are reprinted when the next character is read (not in POSIX). */ #endif #define IEXTEN 0100000 /* Enable implementation-defined input processing. */ #ifdef __USE_MISC # define EXTPROC 0200000 #endif procfs-id.h 0000644 00000002174 15125171642 0006613 0 ustar 00 /* Types of pr_uid and pr_gid in struct elf_prpsinfo. x86 version. Copyright (C) 2018-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _SYS_PROCFS_H # error "Never include <bits/procfs-id.h> directly; use <sys/procfs.h> instead." #endif #if __WORDSIZE == 32 typedef unsigned short int __pr_uid_t; typedef unsigned short int __pr_gid_t; #else typedef unsigned int __pr_uid_t; typedef unsigned int __pr_gid_t; #endif ptrace-shared.h 0000644 00000007773 15125171642 0007461 0 ustar 00 /* `ptrace' debugger support interface. Linux version, not architecture-specific. Copyright (C) 1996-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _SYS_PTRACE_H # error "Never use <bits/ptrace-shared.h> directly; include <sys/ptrace.h> instead." #endif /* Options set using PTRACE_SETOPTIONS. */ enum __ptrace_setoptions { PTRACE_O_TRACESYSGOOD = 0x00000001, PTRACE_O_TRACEFORK = 0x00000002, PTRACE_O_TRACEVFORK = 0x00000004, PTRACE_O_TRACECLONE = 0x00000008, PTRACE_O_TRACEEXEC = 0x00000010, PTRACE_O_TRACEVFORKDONE = 0x00000020, PTRACE_O_TRACEEXIT = 0x00000040, PTRACE_O_TRACESECCOMP = 0x00000080, PTRACE_O_EXITKILL = 0x00100000, PTRACE_O_SUSPEND_SECCOMP = 0x00200000, PTRACE_O_MASK = 0x003000ff }; enum __ptrace_eventcodes { /* Wait extended result codes for the above trace options. */ PTRACE_EVENT_FORK = 1, PTRACE_EVENT_VFORK = 2, PTRACE_EVENT_CLONE = 3, PTRACE_EVENT_EXEC = 4, PTRACE_EVENT_VFORK_DONE = 5, PTRACE_EVENT_EXIT = 6, PTRACE_EVENT_SECCOMP = 7, /* Extended result codes enabled by means other than options. */ PTRACE_EVENT_STOP = 128 }; /* Type of stop for PTRACE_GET_SYSCALL_INFO. */ enum __ptrace_get_syscall_info_op { PTRACE_SYSCALL_INFO_NONE = 0, PTRACE_SYSCALL_INFO_ENTRY = 1, PTRACE_SYSCALL_INFO_EXIT = 2, PTRACE_SYSCALL_INFO_SECCOMP = 3 }; /* Arguments for PTRACE_PEEKSIGINFO. */ struct __ptrace_peeksiginfo_args { __uint64_t off; /* From which siginfo to start. */ __uint32_t flags; /* Flags for peeksiginfo. */ __int32_t nr; /* How many siginfos to take. */ }; enum __ptrace_peeksiginfo_flags { /* Read signals from a shared (process wide) queue. */ PTRACE_PEEKSIGINFO_SHARED = (1 << 0) }; /* Argument and results of PTRACE_SECCOMP_GET_METADATA. */ struct __ptrace_seccomp_metadata { __uint64_t filter_off; /* Input: which filter. */ __uint64_t flags; /* Output: filter's flags. */ }; /* Results of PTRACE_GET_SYSCALL_INFO. */ struct __ptrace_syscall_info { __uint8_t op; /* One of the enum __ptrace_get_syscall_info_op values. */ __uint32_t arch __attribute__ ((__aligned__ (4))); /* AUDIT_ARCH_* value. */ __uint64_t instruction_pointer; /* Instruction pointer. */ __uint64_t stack_pointer; /* Stack pointer. */ union { /* System call number and arguments, for PTRACE_SYSCALL_INFO_ENTRY. */ struct { __uint64_t nr; __uint64_t args[6]; } entry; /* System call return value and error flag, for PTRACE_SYSCALL_INFO_EXIT. */ struct { __int64_t rval; __uint8_t is_error; } exit; /* System call number, arguments and SECCOMP_RET_DATA portion of SECCOMP_RET_TRACE return value, for PTRACE_SYSCALL_INFO_SECCOMP. */ struct { __uint64_t nr; __uint64_t args[6]; __uint32_t ret_data; } seccomp; }; }; /* Perform process tracing functions. REQUEST is one of the values above, and determines the action to be taken. For all requests except PTRACE_TRACEME, PID specifies the process to be traced. PID and the other arguments described above for the various requests should appear (those that are used for the particular request) as: pid_t PID, void *ADDR, int DATA, void *ADDR2 after REQUEST. */ extern long int ptrace (enum __ptrace_request __request, ...) __THROW; statfs.h 0000644 00000003575 15125171642 0006237 0 ustar 00 /* Copyright (C) 1997-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _SYS_STATFS_H # error "Never include <bits/statfs.h> directly; use <sys/statfs.h> instead." #endif #include <bits/types.h> struct statfs { __fsword_t f_type; __fsword_t f_bsize; #ifndef __USE_FILE_OFFSET64 __fsblkcnt_t f_blocks; __fsblkcnt_t f_bfree; __fsblkcnt_t f_bavail; __fsfilcnt_t f_files; __fsfilcnt_t f_ffree; #else __fsblkcnt64_t f_blocks; __fsblkcnt64_t f_bfree; __fsblkcnt64_t f_bavail; __fsfilcnt64_t f_files; __fsfilcnt64_t f_ffree; #endif __fsid_t f_fsid; __fsword_t f_namelen; __fsword_t f_frsize; __fsword_t f_flags; __fsword_t f_spare[4]; }; #ifdef __USE_LARGEFILE64 struct statfs64 { __fsword_t f_type; __fsword_t f_bsize; __fsblkcnt64_t f_blocks; __fsblkcnt64_t f_bfree; __fsblkcnt64_t f_bavail; __fsfilcnt64_t f_files; __fsfilcnt64_t f_ffree; __fsid_t f_fsid; __fsword_t f_namelen; __fsword_t f_frsize; __fsword_t f_flags; __fsword_t f_spare[4]; }; #endif /* Tell code we have these members. */ #define _STATFS_F_NAMELEN #define _STATFS_F_FRSIZE #define _STATFS_F_FLAGS fcntl.h 0000644 00000004306 15125171642 0006032 0 ustar 00 /* O_*, F_*, FD_* bit values for Linux/x86. Copyright (C) 2001-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _FCNTL_H # error "Never use <bits/fcntl.h> directly; include <fcntl.h> instead." #endif #ifdef __x86_64__ # define __O_LARGEFILE 0 #endif #ifdef __x86_64__ /* Not necessary, we always have 64-bit offsets. */ # define F_GETLK64 5 /* Get record locking info. */ # define F_SETLK64 6 /* Set record locking info (non-blocking). */ # define F_SETLKW64 7 /* Set record locking info (blocking). */ #endif struct flock { short int l_type; /* Type of lock: F_RDLCK, F_WRLCK, or F_UNLCK. */ short int l_whence; /* Where `l_start' is relative to (like `lseek'). */ #ifndef __USE_FILE_OFFSET64 __off_t l_start; /* Offset where the lock begins. */ __off_t l_len; /* Size of the locked area; zero means until EOF. */ #else __off64_t l_start; /* Offset where the lock begins. */ __off64_t l_len; /* Size of the locked area; zero means until EOF. */ #endif __pid_t l_pid; /* Process holding the lock. */ }; #ifdef __USE_LARGEFILE64 struct flock64 { short int l_type; /* Type of lock: F_RDLCK, F_WRLCK, or F_UNLCK. */ short int l_whence; /* Where `l_start' is relative to (like `lseek'). */ __off64_t l_start; /* Offset where the lock begins. */ __off64_t l_len; /* Size of the locked area; zero means until EOF. */ __pid_t l_pid; /* Process holding the lock. */ }; #endif /* Include generic Linux declarations. */ #include <bits/fcntl-linux.h> dl_find_object.h 0000644 00000002132 15125171642 0007644 0 ustar 00 /* x86 definitions for finding objects. Copyright (C) 2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _DLFCN_H # error "Never use <bits/dl_find_object.h> directly; include <dlfcn.h> instead." #endif #ifdef __x86_64__ # define DLFO_STRUCT_HAS_EH_DBASE 0 #else # define DLFO_STRUCT_HAS_EH_DBASE 1 #endif #define DLFO_STRUCT_HAS_EH_COUNT 0 #define DLFO_EH_SEGMENT_TYPE PT_GNU_EH_FRAME monetary-ldbl.h 0000644 00000002027 15125171642 0007473 0 ustar 00 /* -mlong-double-64 compatibility mode for monetary functions. Copyright (C) 2006-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _MONETARY_H # error "Never include <bits/monetary-ldbl.h> directly; use <monetary.h> instead." #endif __LDBL_REDIR_DECL (strfmon) #ifdef __USE_GNU __LDBL_REDIR_DECL (strfmon_l) #endif byteswap.h 0000644 00000004622 15125171642 0006563 0 ustar 00 /* Macros and inline functions to swap the order of bytes in integer values. Copyright (C) 1997-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #if !defined _BYTESWAP_H && !defined _NETINET_IN_H && !defined _ENDIAN_H # error "Never use <bits/byteswap.h> directly; include <byteswap.h> instead." #endif #ifndef _BITS_BYTESWAP_H #define _BITS_BYTESWAP_H 1 #include <features.h> #include <bits/types.h> /* Swap bytes in 16-bit value. */ #define __bswap_constant_16(x) \ ((__uint16_t) ((((x) >> 8) & 0xff) | (((x) & 0xff) << 8))) static __inline __uint16_t __bswap_16 (__uint16_t __bsx) { #if __GNUC_PREREQ (4, 8) return __builtin_bswap16 (__bsx); #else return __bswap_constant_16 (__bsx); #endif } /* Swap bytes in 32-bit value. */ #define __bswap_constant_32(x) \ ((((x) & 0xff000000u) >> 24) | (((x) & 0x00ff0000u) >> 8) \ | (((x) & 0x0000ff00u) << 8) | (((x) & 0x000000ffu) << 24)) static __inline __uint32_t __bswap_32 (__uint32_t __bsx) { #if __GNUC_PREREQ (4, 3) return __builtin_bswap32 (__bsx); #else return __bswap_constant_32 (__bsx); #endif } /* Swap bytes in 64-bit value. */ #define __bswap_constant_64(x) \ ((((x) & 0xff00000000000000ull) >> 56) \ | (((x) & 0x00ff000000000000ull) >> 40) \ | (((x) & 0x0000ff0000000000ull) >> 24) \ | (((x) & 0x000000ff00000000ull) >> 8) \ | (((x) & 0x00000000ff000000ull) << 8) \ | (((x) & 0x0000000000ff0000ull) << 24) \ | (((x) & 0x000000000000ff00ull) << 40) \ | (((x) & 0x00000000000000ffull) << 56)) __extension__ static __inline __uint64_t __bswap_64 (__uint64_t __bsx) { #if __GNUC_PREREQ (4, 3) return __builtin_bswap64 (__bsx); #else return __bswap_constant_64 (__bsx); #endif } #endif /* _BITS_BYTESWAP_H */ shmlba.h 0000644 00000002122 15125171642 0006164 0 ustar 00 /* Define SHMLBA. Generic version. Copyright (C) 2018-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _SYS_SHM_H # error "Never use <bits/shmlba.h> directly; include <sys/shm.h> instead." #endif __BEGIN_DECLS /* Segment low boundary address multiple. */ #define SHMLBA (__getpagesize ()) extern int __getpagesize (void) __THROW __attribute__ ((__const__)); __END_DECLS mman-linux.h 0000644 00000011736 15125171642 0007016 0 ustar 00 /* Definitions for POSIX memory map interface. Linux generic version. Copyright (C) 2001-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _SYS_MMAN_H # error "Never use <bits/mman-linux.h> directly; include <sys/mman.h> instead." #endif /* The following definitions basically come from the kernel headers. But the kernel header is not namespace clean. */ /* Protections are chosen from these bits, OR'd together. The implementation does not necessarily support PROT_EXEC or PROT_WRITE without PROT_READ. The only guarantees are that no writing will be allowed without PROT_WRITE and no access will be allowed for PROT_NONE. */ #define PROT_READ 0x1 /* Page can be read. */ #define PROT_WRITE 0x2 /* Page can be written. */ #define PROT_EXEC 0x4 /* Page can be executed. */ #define PROT_NONE 0x0 /* Page can not be accessed. */ #define PROT_GROWSDOWN 0x01000000 /* Extend change to start of growsdown vma (mprotect only). */ #define PROT_GROWSUP 0x02000000 /* Extend change to start of growsup vma (mprotect only). */ /* Sharing types (must choose one and only one of these). */ #define MAP_SHARED 0x01 /* Share changes. */ #define MAP_PRIVATE 0x02 /* Changes are private. */ #ifdef __USE_MISC # define MAP_SHARED_VALIDATE 0x03 /* Share changes and validate extension flags. */ # define MAP_TYPE 0x0f /* Mask for type of mapping. */ #endif /* Other flags. */ #define MAP_FIXED 0x10 /* Interpret addr exactly. */ #ifdef __USE_MISC # define MAP_FILE 0 # ifdef __MAP_ANONYMOUS # define MAP_ANONYMOUS __MAP_ANONYMOUS /* Don't use a file. */ # else # define MAP_ANONYMOUS 0x20 /* Don't use a file. */ # endif # define MAP_ANON MAP_ANONYMOUS /* When MAP_HUGETLB is set bits [26:31] encode the log2 of the huge page size. */ # define MAP_HUGE_SHIFT 26 # define MAP_HUGE_MASK 0x3f #endif /* Flags to `msync'. */ #define MS_ASYNC 1 /* Sync memory asynchronously. */ #define MS_SYNC 4 /* Synchronous memory sync. */ #define MS_INVALIDATE 2 /* Invalidate the caches. */ /* Advice to `madvise'. */ #ifdef __USE_MISC # define MADV_NORMAL 0 /* No further special treatment. */ # define MADV_RANDOM 1 /* Expect random page references. */ # define MADV_SEQUENTIAL 2 /* Expect sequential page references. */ # define MADV_WILLNEED 3 /* Will need these pages. */ # define MADV_DONTNEED 4 /* Don't need these pages. */ # define MADV_FREE 8 /* Free pages only if memory pressure. */ # define MADV_REMOVE 9 /* Remove these pages and resources. */ # define MADV_DONTFORK 10 /* Do not inherit across fork. */ # define MADV_DOFORK 11 /* Do inherit across fork. */ # define MADV_MERGEABLE 12 /* KSM may merge identical pages. */ # define MADV_UNMERGEABLE 13 /* KSM may not merge identical pages. */ # define MADV_HUGEPAGE 14 /* Worth backing with hugepages. */ # define MADV_NOHUGEPAGE 15 /* Not worth backing with hugepages. */ # define MADV_DONTDUMP 16 /* Explicity exclude from the core dump, overrides the coredump filter bits. */ # define MADV_DODUMP 17 /* Clear the MADV_DONTDUMP flag. */ # define MADV_WIPEONFORK 18 /* Zero memory on fork, child only. */ # define MADV_KEEPONFORK 19 /* Undo MADV_WIPEONFORK. */ # define MADV_COLD 20 /* Deactivate these pages. */ # define MADV_PAGEOUT 21 /* Reclaim these pages. */ # define MADV_POPULATE_READ 22 /* Populate (prefault) page tables readable. */ # define MADV_POPULATE_WRITE 23 /* Populate (prefault) page tables writable. */ # define MADV_HWPOISON 100 /* Poison a page for testing. */ #endif /* The POSIX people had to invent similar names for the same things. */ #ifdef __USE_XOPEN2K # define POSIX_MADV_NORMAL 0 /* No further special treatment. */ # define POSIX_MADV_RANDOM 1 /* Expect random page references. */ # define POSIX_MADV_SEQUENTIAL 2 /* Expect sequential page references. */ # define POSIX_MADV_WILLNEED 3 /* Will need these pages. */ # define POSIX_MADV_DONTNEED 4 /* Don't need these pages. */ #endif /* Flags for `mlockall'. */ #ifndef MCL_CURRENT # define MCL_CURRENT 1 /* Lock all currently mapped pages. */ # define MCL_FUTURE 2 /* Lock all additions to address space. */ # define MCL_ONFAULT 4 /* Lock all pages that are faulted in. */ #endif #include <bits/mman-shared.h> netdb.h 0000644 00000002360 15125171642 0006016 0 ustar 00 /* Copyright (C) 1996-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _NETDB_H # error "Never include <bits/netdb.h> directly; use <netdb.h> instead." #endif /* Description of data base entry for a single network. NOTE: here a poor assumption is made. The network number is expected to fit into an unsigned long int variable. */ struct netent { char *n_name; /* Official name of network. */ char **n_aliases; /* Alias list. */ int n_addrtype; /* Net address type. */ uint32_t n_net; /* Network number. */ }; syslog.h 0000644 00000003661 15125171642 0006247 0 ustar 00 /* Checking macros for syslog functions. Copyright (C) 2005-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _SYS_SYSLOG_H # error "Never include <bits/syslog.h> directly; use <sys/syslog.h> instead." #endif extern void __syslog_chk (int __pri, int __flag, const char *__fmt, ...) __attribute__ ((__format__ (__printf__, 3, 4))); #ifdef __USE_MISC extern void __vsyslog_chk (int __pri, int __flag, const char *__fmt, __gnuc_va_list __ap) __attribute__ ((__format__ (__printf__, 3, 0))); #endif #include <bits/floatn.h> #if defined __LDBL_COMPAT || __LDOUBLE_REDIRECTS_TO_FLOAT128_ABI == 1 # include <bits/syslog-ldbl.h> #endif /* The following functions must be used only after applying all asm redirections, e.g. long double asm redirections. */ #ifdef __va_arg_pack __fortify_function void syslog (int __pri, const char *__fmt, ...) { __syslog_chk (__pri, __USE_FORTIFY_LEVEL - 1, __fmt, __va_arg_pack ()); } #elif !defined __cplusplus # define syslog(pri, ...) \ __syslog_chk (pri, __USE_FORTIFY_LEVEL - 1, __VA_ARGS__) #endif #ifdef __USE_MISC __fortify_function void vsyslog (int __pri, const char *__fmt, __gnuc_va_list __ap) { __vsyslog_chk (__pri, __USE_FORTIFY_LEVEL - 1, __fmt, __ap); } #endif procfs-prregset.h 0000644 00000002032 15125171642 0010043 0 ustar 00 /* Types of prgregset_t and prfpregset_t. Generic Linux version. Copyright (C) 2018-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _SYS_PROCFS_H # error "Never include <bits/procfs-prregset.h> directly; use <sys/procfs.h> instead." #endif typedef elf_gregset_t __prgregset_t; typedef elf_fpregset_t __prfpregset_t; socket.h 0000644 00000032362 15125171642 0006217 0 ustar 00 /* System-specific socket constants and types. Linux version. Copyright (C) 1991-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef __BITS_SOCKET_H #define __BITS_SOCKET_H #ifndef _SYS_SOCKET_H # error "Never include <bits/socket.h> directly; use <sys/socket.h> instead." #endif #define __need_size_t #include <stddef.h> #include <sys/types.h> /* Type for length arguments in socket calls. */ #ifndef __socklen_t_defined typedef __socklen_t socklen_t; # define __socklen_t_defined #endif /* Get the architecture-dependent definition of enum __socket_type. */ #include <bits/socket_type.h> /* Protocol families. */ #define PF_UNSPEC 0 /* Unspecified. */ #define PF_LOCAL 1 /* Local to host (pipes and file-domain). */ #define PF_UNIX PF_LOCAL /* POSIX name for PF_LOCAL. */ #define PF_FILE PF_LOCAL /* Another non-standard name for PF_LOCAL. */ #define PF_INET 2 /* IP protocol family. */ #define PF_AX25 3 /* Amateur Radio AX.25. */ #define PF_IPX 4 /* Novell Internet Protocol. */ #define PF_APPLETALK 5 /* Appletalk DDP. */ #define PF_NETROM 6 /* Amateur radio NetROM. */ #define PF_BRIDGE 7 /* Multiprotocol bridge. */ #define PF_ATMPVC 8 /* ATM PVCs. */ #define PF_X25 9 /* Reserved for X.25 project. */ #define PF_INET6 10 /* IP version 6. */ #define PF_ROSE 11 /* Amateur Radio X.25 PLP. */ #define PF_DECnet 12 /* Reserved for DECnet project. */ #define PF_NETBEUI 13 /* Reserved for 802.2LLC project. */ #define PF_SECURITY 14 /* Security callback pseudo AF. */ #define PF_KEY 15 /* PF_KEY key management API. */ #define PF_NETLINK 16 #define PF_ROUTE PF_NETLINK /* Alias to emulate 4.4BSD. */ #define PF_PACKET 17 /* Packet family. */ #define PF_ASH 18 /* Ash. */ #define PF_ECONET 19 /* Acorn Econet. */ #define PF_ATMSVC 20 /* ATM SVCs. */ #define PF_RDS 21 /* RDS sockets. */ #define PF_SNA 22 /* Linux SNA Project */ #define PF_IRDA 23 /* IRDA sockets. */ #define PF_PPPOX 24 /* PPPoX sockets. */ #define PF_WANPIPE 25 /* Wanpipe API sockets. */ #define PF_LLC 26 /* Linux LLC. */ #define PF_IB 27 /* Native InfiniBand address. */ #define PF_MPLS 28 /* MPLS. */ #define PF_CAN 29 /* Controller Area Network. */ #define PF_TIPC 30 /* TIPC sockets. */ #define PF_BLUETOOTH 31 /* Bluetooth sockets. */ #define PF_IUCV 32 /* IUCV sockets. */ #define PF_RXRPC 33 /* RxRPC sockets. */ #define PF_ISDN 34 /* mISDN sockets. */ #define PF_PHONET 35 /* Phonet sockets. */ #define PF_IEEE802154 36 /* IEEE 802.15.4 sockets. */ #define PF_CAIF 37 /* CAIF sockets. */ #define PF_ALG 38 /* Algorithm sockets. */ #define PF_NFC 39 /* NFC sockets. */ #define PF_VSOCK 40 /* vSockets. */ #define PF_KCM 41 /* Kernel Connection Multiplexor. */ #define PF_QIPCRTR 42 /* Qualcomm IPC Router. */ #define PF_SMC 43 /* SMC sockets. */ #define PF_XDP 44 /* XDP sockets. */ #define PF_MCTP 45 /* Management component transport protocol. */ #define PF_MAX 46 /* For now.. */ /* Address families. */ #define AF_UNSPEC PF_UNSPEC #define AF_LOCAL PF_LOCAL #define AF_UNIX PF_UNIX #define AF_FILE PF_FILE #define AF_INET PF_INET #define AF_AX25 PF_AX25 #define AF_IPX PF_IPX #define AF_APPLETALK PF_APPLETALK #define AF_NETROM PF_NETROM #define AF_BRIDGE PF_BRIDGE #define AF_ATMPVC PF_ATMPVC #define AF_X25 PF_X25 #define AF_INET6 PF_INET6 #define AF_ROSE PF_ROSE #define AF_DECnet PF_DECnet #define AF_NETBEUI PF_NETBEUI #define AF_SECURITY PF_SECURITY #define AF_KEY PF_KEY #define AF_NETLINK PF_NETLINK #define AF_ROUTE PF_ROUTE #define AF_PACKET PF_PACKET #define AF_ASH PF_ASH #define AF_ECONET PF_ECONET #define AF_ATMSVC PF_ATMSVC #define AF_RDS PF_RDS #define AF_SNA PF_SNA #define AF_IRDA PF_IRDA #define AF_PPPOX PF_PPPOX #define AF_WANPIPE PF_WANPIPE #define AF_LLC PF_LLC #define AF_IB PF_IB #define AF_MPLS PF_MPLS #define AF_CAN PF_CAN #define AF_TIPC PF_TIPC #define AF_BLUETOOTH PF_BLUETOOTH #define AF_IUCV PF_IUCV #define AF_RXRPC PF_RXRPC #define AF_ISDN PF_ISDN #define AF_PHONET PF_PHONET #define AF_IEEE802154 PF_IEEE802154 #define AF_CAIF PF_CAIF #define AF_ALG PF_ALG #define AF_NFC PF_NFC #define AF_VSOCK PF_VSOCK #define AF_KCM PF_KCM #define AF_QIPCRTR PF_QIPCRTR #define AF_SMC PF_SMC #define AF_XDP PF_XDP #define AF_MCTP PF_MCTP #define AF_MAX PF_MAX /* Socket level values. Others are defined in the appropriate headers. XXX These definitions also should go into the appropriate headers as far as they are available. */ #define SOL_RAW 255 #define SOL_DECNET 261 #define SOL_X25 262 #define SOL_PACKET 263 #define SOL_ATM 264 /* ATM layer (cell level). */ #define SOL_AAL 265 /* ATM Adaption Layer (packet level). */ #define SOL_IRDA 266 #define SOL_NETBEUI 267 #define SOL_LLC 268 #define SOL_DCCP 269 #define SOL_NETLINK 270 #define SOL_TIPC 271 #define SOL_RXRPC 272 #define SOL_PPPOL2TP 273 #define SOL_BLUETOOTH 274 #define SOL_PNPIPE 275 #define SOL_RDS 276 #define SOL_IUCV 277 #define SOL_CAIF 278 #define SOL_ALG 279 #define SOL_NFC 280 #define SOL_KCM 281 #define SOL_TLS 282 #define SOL_XDP 283 #define SOL_MPTCP 284 #define SOL_MCTP 285 /* Maximum queue length specifiable by listen. */ #define SOMAXCONN 4096 /* Get the definition of the macro to define the common sockaddr members. */ #include <bits/sockaddr.h> /* Structure describing a generic socket address. */ struct sockaddr { __SOCKADDR_COMMON (sa_); /* Common data: address family and length. */ char sa_data[14]; /* Address data. */ }; /* Structure large enough to hold any socket address (with the historical exception of AF_UNIX). */ #define __ss_aligntype unsigned long int #define _SS_PADSIZE \ (_SS_SIZE - __SOCKADDR_COMMON_SIZE - sizeof (__ss_aligntype)) struct sockaddr_storage { __SOCKADDR_COMMON (ss_); /* Address family, etc. */ char __ss_padding[_SS_PADSIZE]; __ss_aligntype __ss_align; /* Force desired alignment. */ }; /* Bits in the FLAGS argument to `send', `recv', et al. */ enum { MSG_OOB = 0x01, /* Process out-of-band data. */ #define MSG_OOB MSG_OOB MSG_PEEK = 0x02, /* Peek at incoming messages. */ #define MSG_PEEK MSG_PEEK MSG_DONTROUTE = 0x04, /* Don't use local routing. */ #define MSG_DONTROUTE MSG_DONTROUTE #ifdef __USE_GNU /* DECnet uses a different name. */ MSG_TRYHARD = MSG_DONTROUTE, # define MSG_TRYHARD MSG_DONTROUTE #endif MSG_CTRUNC = 0x08, /* Control data lost before delivery. */ #define MSG_CTRUNC MSG_CTRUNC MSG_PROXY = 0x10, /* Supply or ask second address. */ #define MSG_PROXY MSG_PROXY MSG_TRUNC = 0x20, #define MSG_TRUNC MSG_TRUNC MSG_DONTWAIT = 0x40, /* Nonblocking IO. */ #define MSG_DONTWAIT MSG_DONTWAIT MSG_EOR = 0x80, /* End of record. */ #define MSG_EOR MSG_EOR MSG_WAITALL = 0x100, /* Wait for a full request. */ #define MSG_WAITALL MSG_WAITALL MSG_FIN = 0x200, #define MSG_FIN MSG_FIN MSG_SYN = 0x400, #define MSG_SYN MSG_SYN MSG_CONFIRM = 0x800, /* Confirm path validity. */ #define MSG_CONFIRM MSG_CONFIRM MSG_RST = 0x1000, #define MSG_RST MSG_RST MSG_ERRQUEUE = 0x2000, /* Fetch message from error queue. */ #define MSG_ERRQUEUE MSG_ERRQUEUE MSG_NOSIGNAL = 0x4000, /* Do not generate SIGPIPE. */ #define MSG_NOSIGNAL MSG_NOSIGNAL MSG_MORE = 0x8000, /* Sender will send more. */ #define MSG_MORE MSG_MORE MSG_WAITFORONE = 0x10000, /* Wait for at least one packet to return.*/ #define MSG_WAITFORONE MSG_WAITFORONE MSG_BATCH = 0x40000, /* sendmmsg: more messages coming. */ #define MSG_BATCH MSG_BATCH MSG_ZEROCOPY = 0x4000000, /* Use user data in kernel path. */ #define MSG_ZEROCOPY MSG_ZEROCOPY MSG_FASTOPEN = 0x20000000, /* Send data in TCP SYN. */ #define MSG_FASTOPEN MSG_FASTOPEN MSG_CMSG_CLOEXEC = 0x40000000 /* Set close_on_exit for file descriptor received through SCM_RIGHTS. */ #define MSG_CMSG_CLOEXEC MSG_CMSG_CLOEXEC }; /* Structure describing messages sent by `sendmsg' and received by `recvmsg'. */ struct msghdr { void *msg_name; /* Address to send to/receive from. */ socklen_t msg_namelen; /* Length of address data. */ struct iovec *msg_iov; /* Vector of data to send/receive into. */ size_t msg_iovlen; /* Number of elements in the vector. */ void *msg_control; /* Ancillary data (eg BSD filedesc passing). */ size_t msg_controllen; /* Ancillary data buffer length. !! The type should be socklen_t but the definition of the kernel is incompatible with this. */ int msg_flags; /* Flags on received message. */ }; /* Structure used for storage of ancillary data object information. */ struct cmsghdr { size_t cmsg_len; /* Length of data in cmsg_data plus length of cmsghdr structure. !! The type should be socklen_t but the definition of the kernel is incompatible with this. */ int cmsg_level; /* Originating protocol. */ int cmsg_type; /* Protocol specific type. */ #if __glibc_c99_flexarr_available __extension__ unsigned char __cmsg_data __flexarr; /* Ancillary data. */ #endif }; /* Ancillary data object manipulation macros. */ #if __glibc_c99_flexarr_available # define CMSG_DATA(cmsg) ((cmsg)->__cmsg_data) #else # define CMSG_DATA(cmsg) ((unsigned char *) ((struct cmsghdr *) (cmsg) + 1)) #endif #define CMSG_NXTHDR(mhdr, cmsg) __cmsg_nxthdr (mhdr, cmsg) #define CMSG_FIRSTHDR(mhdr) \ ((size_t) (mhdr)->msg_controllen >= sizeof (struct cmsghdr) \ ? (struct cmsghdr *) (mhdr)->msg_control : (struct cmsghdr *) 0) #define CMSG_ALIGN(len) (((len) + sizeof (size_t) - 1) \ & (size_t) ~(sizeof (size_t) - 1)) #define CMSG_SPACE(len) (CMSG_ALIGN (len) \ + CMSG_ALIGN (sizeof (struct cmsghdr))) #define CMSG_LEN(len) (CMSG_ALIGN (sizeof (struct cmsghdr)) + (len)) /* Given a length, return the additional padding necessary such that len + __CMSG_PADDING(len) == CMSG_ALIGN (len). */ #define __CMSG_PADDING(len) ((sizeof (size_t) \ - ((len) & (sizeof (size_t) - 1))) \ & (sizeof (size_t) - 1)) extern struct cmsghdr *__cmsg_nxthdr (struct msghdr *__mhdr, struct cmsghdr *__cmsg) __THROW; #ifdef __USE_EXTERN_INLINES # ifndef _EXTERN_INLINE # define _EXTERN_INLINE __extern_inline # endif _EXTERN_INLINE struct cmsghdr * __NTH (__cmsg_nxthdr (struct msghdr *__mhdr, struct cmsghdr *__cmsg)) { /* We may safely assume that __cmsg lies between __mhdr->msg_control and __mhdr->msg_controllen because the user is required to obtain the first cmsg via CMSG_FIRSTHDR, set its length, then obtain subsequent cmsgs via CMSG_NXTHDR, setting lengths along the way. However, we don't yet trust the value of __cmsg->cmsg_len and therefore do not use it in any pointer arithmetic until we check its value. */ unsigned char * __msg_control_ptr = (unsigned char *) __mhdr->msg_control; unsigned char * __cmsg_ptr = (unsigned char *) __cmsg; size_t __size_needed = sizeof (struct cmsghdr) + __CMSG_PADDING (__cmsg->cmsg_len); /* The current header is malformed, too small to be a full header. */ if ((size_t) __cmsg->cmsg_len < sizeof (struct cmsghdr)) return (struct cmsghdr *) 0; /* There isn't enough space between __cmsg and the end of the buffer to hold the current cmsg *and* the next one. */ if (((size_t) (__msg_control_ptr + __mhdr->msg_controllen - __cmsg_ptr) < __size_needed) || ((size_t) (__msg_control_ptr + __mhdr->msg_controllen - __cmsg_ptr - __size_needed) < __cmsg->cmsg_len)) return (struct cmsghdr *) 0; /* Now, we trust cmsg_len and can use it to find the next header. */ __cmsg = (struct cmsghdr *) ((unsigned char *) __cmsg + CMSG_ALIGN (__cmsg->cmsg_len)); return __cmsg; } #endif /* Use `extern inline'. */ /* Socket level message types. This must match the definitions in <linux/socket.h>. */ enum { SCM_RIGHTS = 0x01 /* Transfer file descriptors. */ #define SCM_RIGHTS SCM_RIGHTS #ifdef __USE_GNU , SCM_CREDENTIALS = 0x02 /* Credentials passing. */ # define SCM_CREDENTIALS SCM_CREDENTIALS #endif }; #ifdef __USE_GNU /* User visible structure for SCM_CREDENTIALS message */ struct ucred { pid_t pid; /* PID of sending process. */ uid_t uid; /* UID of sending process. */ gid_t gid; /* GID of sending process. */ }; #endif #ifdef __USE_MISC # include <bits/types/time_t.h> # include <asm/socket.h> #else # define SO_DEBUG 1 # include <bits/socket-constants.h> #endif /* Structure used to manipulate the SO_LINGER option. */ struct linger { int l_onoff; /* Nonzero to linger on close. */ int l_linger; /* Time to linger. */ }; #endif /* bits/socket.h */ rseq.h 0000644 00000002333 15125171642 0005674 0 ustar 00 /* Restartable Sequences Linux x86 architecture header. Copyright (C) 2021 Free Software Foundation, Inc. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _SYS_RSEQ_H # error "Never use <bits/rseq.h> directly; include <sys/rseq.h> instead." #endif /* RSEQ_SIG is a signature required before each abort handler code. RSEQ_SIG is used with the following reserved undefined instructions, which trap in user-space: x86-32: 0f b9 3d 53 30 05 53 ud1 0x53053053,%edi x86-64: 0f b9 3d 53 30 05 53 ud1 0x53053053(%rip),%edi */ #define RSEQ_SIG 0x53053053 stat.h 0000644 00000004267 15125171642 0005705 0 ustar 00 /* Copyright (C) 1992-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #if !defined _SYS_STAT_H && !defined _FCNTL_H # error "Never include <bits/stat.h> directly; use <sys/stat.h> instead." #endif #ifndef _BITS_STAT_H #define _BITS_STAT_H 1 #include <bits/struct_stat.h> /* Encoding of the file mode. */ #define __S_IFMT 0170000 /* These bits determine file type. */ /* File types. */ #define __S_IFDIR 0040000 /* Directory. */ #define __S_IFCHR 0020000 /* Character device. */ #define __S_IFBLK 0060000 /* Block device. */ #define __S_IFREG 0100000 /* Regular file. */ #define __S_IFIFO 0010000 /* FIFO. */ #define __S_IFLNK 0120000 /* Symbolic link. */ #define __S_IFSOCK 0140000 /* Socket. */ /* POSIX.1b objects. Note that these macros always evaluate to zero. But they do it by enforcing the correct use of the macros. */ #define __S_TYPEISMQ(buf) ((buf)->st_mode - (buf)->st_mode) #define __S_TYPEISSEM(buf) ((buf)->st_mode - (buf)->st_mode) #define __S_TYPEISSHM(buf) ((buf)->st_mode - (buf)->st_mode) /* Protection bits. */ #define __S_ISUID 04000 /* Set user ID on execution. */ #define __S_ISGID 02000 /* Set group ID on execution. */ #define __S_ISVTX 01000 /* Save swapped text after use (sticky). */ #define __S_IREAD 0400 /* Read by owner. */ #define __S_IWRITE 0200 /* Write by owner. */ #define __S_IEXEC 0100 /* Execute by owner. */ #ifdef __USE_ATFILE # define UTIME_NOW ((1l << 30) - 1l) # define UTIME_OMIT ((1l << 30) - 2l) #endif #endif /* bits/stat.h */ socket2.h 0000644 00000005735 15125171642 0006305 0 ustar 00 /* Checking macros for socket functions. Copyright (C) 2005-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _SYS_SOCKET_H # error "Never include <bits/socket2.h> directly; use <sys/socket.h> instead." #endif extern ssize_t __recv_chk (int __fd, void *__buf, size_t __n, size_t __buflen, int __flags); extern ssize_t __REDIRECT (__recv_alias, (int __fd, void *__buf, size_t __n, int __flags), recv); extern ssize_t __REDIRECT (__recv_chk_warn, (int __fd, void *__buf, size_t __n, size_t __buflen, int __flags), __recv_chk) __warnattr ("recv called with bigger length than size of destination " "buffer"); __fortify_function ssize_t recv (int __fd, void *__buf, size_t __n, int __flags) { size_t sz = __glibc_objsize0 (__buf); if (__glibc_safe_or_unknown_len (__n, sizeof (char), sz)) return __recv_alias (__fd, __buf, __n, __flags); if (__glibc_unsafe_len (__n, sizeof (char), sz)) return __recv_chk_warn (__fd, __buf, __n, sz, __flags); return __recv_chk (__fd, __buf, __n, sz, __flags); } extern ssize_t __recvfrom_chk (int __fd, void *__restrict __buf, size_t __n, size_t __buflen, int __flags, __SOCKADDR_ARG __addr, socklen_t *__restrict __addr_len); extern ssize_t __REDIRECT (__recvfrom_alias, (int __fd, void *__restrict __buf, size_t __n, int __flags, __SOCKADDR_ARG __addr, socklen_t *__restrict __addr_len), recvfrom); extern ssize_t __REDIRECT (__recvfrom_chk_warn, (int __fd, void *__restrict __buf, size_t __n, size_t __buflen, int __flags, __SOCKADDR_ARG __addr, socklen_t *__restrict __addr_len), __recvfrom_chk) __warnattr ("recvfrom called with bigger length than size of " "destination buffer"); __fortify_function ssize_t recvfrom (int __fd, void *__restrict __buf, size_t __n, int __flags, __SOCKADDR_ARG __addr, socklen_t *__restrict __addr_len) { size_t sz = __glibc_objsize0 (__buf); if (__glibc_safe_or_unknown_len (__n, sizeof (char), sz)) return __recvfrom_alias (__fd, __buf, __n, __flags, __addr, __addr_len); if (__glibc_unsafe_len (__n, sizeof (char), sz)) return __recvfrom_chk_warn (__fd, __buf, __n, sz, __flags, __addr, __addr_len); return __recvfrom_chk (__fd, __buf, __n, sz, __flags, __addr, __addr_len); } waitflags.h 0000644 00000003241 15125171642 0006702 0 ustar 00 /* Definitions of flag bits for `waitpid' et al. Copyright (C) 1992-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #if !defined _SYS_WAIT_H && !defined _STDLIB_H # error "Never include <bits/waitflags.h> directly; use <sys/wait.h> instead." #endif /* Bits in the third argument to `waitpid'. */ #define WNOHANG 1 /* Don't block waiting. */ #define WUNTRACED 2 /* Report status of stopped children. */ /* Bits in the fourth argument to `waitid'. */ #if defined __USE_XOPEN_EXTENDED || defined __USE_XOPEN2K8 # define WSTOPPED 2 /* Report stopped child (same as WUNTRACED). */ # define WEXITED 4 /* Report dead child. */ # define WCONTINUED 8 /* Report continued child. */ # define WNOWAIT 0x01000000 /* Don't reap, just poll status. */ #endif #define __WNOTHREAD 0x20000000 /* Don't wait on children of other threads in this group */ #define __WALL 0x40000000 /* Wait for any child. */ #define __WCLONE 0x80000000 /* Wait for cloned process. */ select2.h 0000644 00000002636 15125171642 0006271 0 ustar 00 /* Checking macros for select functions. Copyright (C) 2011-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _SYS_SELECT_H # error "Never include <bits/select2.h> directly; use <sys/select.h> instead." #endif /* Helper functions to issue warnings and errors when needed. */ extern long int __fdelt_chk (long int __d); extern long int __fdelt_warn (long int __d) __warnattr ("bit outside of fd_set selected"); #undef __FD_ELT #define __FD_ELT(d) \ __extension__ \ ({ long int __d = (d); \ (__builtin_constant_p (__d) \ ? (0 <= __d && __d < __FD_SETSIZE \ ? (__d / __NFDBITS) \ : __fdelt_warn (__d)) \ : __fdelt_chk (__d)); }) termios-struct.h 0000644 00000002631 15125171642 0007727 0 ustar 00 /* struct termios definition. Linux/generic version. Copyright (C) 2019-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library. If not, see <https://www.gnu.org/licenses/>. */ #ifndef _TERMIOS_H # error "Never include <bits/termios-struct.h> directly; use <termios.h> instead." #endif #define NCCS 32 struct termios { tcflag_t c_iflag; /* input mode flags */ tcflag_t c_oflag; /* output mode flags */ tcflag_t c_cflag; /* control mode flags */ tcflag_t c_lflag; /* local mode flags */ cc_t c_line; /* line discipline */ cc_t c_cc[NCCS]; /* control characters */ speed_t c_ispeed; /* input speed */ speed_t c_ospeed; /* output speed */ #define _HAVE_STRUCT_TERMIOS_C_ISPEED 1 #define _HAVE_STRUCT_TERMIOS_C_OSPEED 1 }; struct_mutex.h 0000644 00000003422 15125171642 0007470 0 ustar 00 /* x86 internal mutex struct definitions. Copyright (C) 2019-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <http://www.gnu.org/licenses/>. */ #ifndef _THREAD_MUTEX_INTERNAL_H #define _THREAD_MUTEX_INTERNAL_H 1 struct __pthread_mutex_s { int __lock; unsigned int __count; int __owner; #ifdef __x86_64__ unsigned int __nusers; #endif /* KIND must stay at this position in the structure to maintain binary compatibility with static initializers. */ int __kind; #ifdef __x86_64__ short __spins; short __elision; __pthread_list_t __list; # define __PTHREAD_MUTEX_HAVE_PREV 1 #else unsigned int __nusers; __extension__ union { struct { short __espins; short __eelision; # define __spins __elision_data.__espins # define __elision __elision_data.__eelision } __elision_data; __pthread_slist_t __list; }; # define __PTHREAD_MUTEX_HAVE_PREV 0 #endif }; #ifdef __x86_64__ # define __PTHREAD_MUTEX_INITIALIZER(__kind) \ 0, 0, 0, 0, __kind, 0, 0, { 0, 0 } #else # define __PTHREAD_MUTEX_INITIALIZER(__kind) \ 0, 0, 0, __kind, 0, { { 0, 0 } } #endif #endif confname.h 0000644 00000056424 15125171642 0006522 0 ustar 00 /* `sysconf', `pathconf', and `confstr' NAME values. Generic version. Copyright (C) 1993-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _UNISTD_H # error "Never use <bits/confname.h> directly; include <unistd.h> instead." #endif /* Values for the NAME argument to `pathconf' and `fpathconf'. */ enum { _PC_LINK_MAX, #define _PC_LINK_MAX _PC_LINK_MAX _PC_MAX_CANON, #define _PC_MAX_CANON _PC_MAX_CANON _PC_MAX_INPUT, #define _PC_MAX_INPUT _PC_MAX_INPUT _PC_NAME_MAX, #define _PC_NAME_MAX _PC_NAME_MAX _PC_PATH_MAX, #define _PC_PATH_MAX _PC_PATH_MAX _PC_PIPE_BUF, #define _PC_PIPE_BUF _PC_PIPE_BUF _PC_CHOWN_RESTRICTED, #define _PC_CHOWN_RESTRICTED _PC_CHOWN_RESTRICTED _PC_NO_TRUNC, #define _PC_NO_TRUNC _PC_NO_TRUNC _PC_VDISABLE, #define _PC_VDISABLE _PC_VDISABLE _PC_SYNC_IO, #define _PC_SYNC_IO _PC_SYNC_IO _PC_ASYNC_IO, #define _PC_ASYNC_IO _PC_ASYNC_IO _PC_PRIO_IO, #define _PC_PRIO_IO _PC_PRIO_IO _PC_SOCK_MAXBUF, #define _PC_SOCK_MAXBUF _PC_SOCK_MAXBUF _PC_FILESIZEBITS, #define _PC_FILESIZEBITS _PC_FILESIZEBITS _PC_REC_INCR_XFER_SIZE, #define _PC_REC_INCR_XFER_SIZE _PC_REC_INCR_XFER_SIZE _PC_REC_MAX_XFER_SIZE, #define _PC_REC_MAX_XFER_SIZE _PC_REC_MAX_XFER_SIZE _PC_REC_MIN_XFER_SIZE, #define _PC_REC_MIN_XFER_SIZE _PC_REC_MIN_XFER_SIZE _PC_REC_XFER_ALIGN, #define _PC_REC_XFER_ALIGN _PC_REC_XFER_ALIGN _PC_ALLOC_SIZE_MIN, #define _PC_ALLOC_SIZE_MIN _PC_ALLOC_SIZE_MIN _PC_SYMLINK_MAX, #define _PC_SYMLINK_MAX _PC_SYMLINK_MAX _PC_2_SYMLINKS #define _PC_2_SYMLINKS _PC_2_SYMLINKS }; /* Values for the argument to `sysconf'. */ enum { _SC_ARG_MAX, #define _SC_ARG_MAX _SC_ARG_MAX _SC_CHILD_MAX, #define _SC_CHILD_MAX _SC_CHILD_MAX _SC_CLK_TCK, #define _SC_CLK_TCK _SC_CLK_TCK _SC_NGROUPS_MAX, #define _SC_NGROUPS_MAX _SC_NGROUPS_MAX _SC_OPEN_MAX, #define _SC_OPEN_MAX _SC_OPEN_MAX _SC_STREAM_MAX, #define _SC_STREAM_MAX _SC_STREAM_MAX _SC_TZNAME_MAX, #define _SC_TZNAME_MAX _SC_TZNAME_MAX _SC_JOB_CONTROL, #define _SC_JOB_CONTROL _SC_JOB_CONTROL _SC_SAVED_IDS, #define _SC_SAVED_IDS _SC_SAVED_IDS _SC_REALTIME_SIGNALS, #define _SC_REALTIME_SIGNALS _SC_REALTIME_SIGNALS _SC_PRIORITY_SCHEDULING, #define _SC_PRIORITY_SCHEDULING _SC_PRIORITY_SCHEDULING _SC_TIMERS, #define _SC_TIMERS _SC_TIMERS _SC_ASYNCHRONOUS_IO, #define _SC_ASYNCHRONOUS_IO _SC_ASYNCHRONOUS_IO _SC_PRIORITIZED_IO, #define _SC_PRIORITIZED_IO _SC_PRIORITIZED_IO _SC_SYNCHRONIZED_IO, #define _SC_SYNCHRONIZED_IO _SC_SYNCHRONIZED_IO _SC_FSYNC, #define _SC_FSYNC _SC_FSYNC _SC_MAPPED_FILES, #define _SC_MAPPED_FILES _SC_MAPPED_FILES _SC_MEMLOCK, #define _SC_MEMLOCK _SC_MEMLOCK _SC_MEMLOCK_RANGE, #define _SC_MEMLOCK_RANGE _SC_MEMLOCK_RANGE _SC_MEMORY_PROTECTION, #define _SC_MEMORY_PROTECTION _SC_MEMORY_PROTECTION _SC_MESSAGE_PASSING, #define _SC_MESSAGE_PASSING _SC_MESSAGE_PASSING _SC_SEMAPHORES, #define _SC_SEMAPHORES _SC_SEMAPHORES _SC_SHARED_MEMORY_OBJECTS, #define _SC_SHARED_MEMORY_OBJECTS _SC_SHARED_MEMORY_OBJECTS _SC_AIO_LISTIO_MAX, #define _SC_AIO_LISTIO_MAX _SC_AIO_LISTIO_MAX _SC_AIO_MAX, #define _SC_AIO_MAX _SC_AIO_MAX _SC_AIO_PRIO_DELTA_MAX, #define _SC_AIO_PRIO_DELTA_MAX _SC_AIO_PRIO_DELTA_MAX _SC_DELAYTIMER_MAX, #define _SC_DELAYTIMER_MAX _SC_DELAYTIMER_MAX _SC_MQ_OPEN_MAX, #define _SC_MQ_OPEN_MAX _SC_MQ_OPEN_MAX _SC_MQ_PRIO_MAX, #define _SC_MQ_PRIO_MAX _SC_MQ_PRIO_MAX _SC_VERSION, #define _SC_VERSION _SC_VERSION _SC_PAGESIZE, #define _SC_PAGESIZE _SC_PAGESIZE #define _SC_PAGE_SIZE _SC_PAGESIZE _SC_RTSIG_MAX, #define _SC_RTSIG_MAX _SC_RTSIG_MAX _SC_SEM_NSEMS_MAX, #define _SC_SEM_NSEMS_MAX _SC_SEM_NSEMS_MAX _SC_SEM_VALUE_MAX, #define _SC_SEM_VALUE_MAX _SC_SEM_VALUE_MAX _SC_SIGQUEUE_MAX, #define _SC_SIGQUEUE_MAX _SC_SIGQUEUE_MAX _SC_TIMER_MAX, #define _SC_TIMER_MAX _SC_TIMER_MAX /* Values for the argument to `sysconf' corresponding to _POSIX2_* symbols. */ _SC_BC_BASE_MAX, #define _SC_BC_BASE_MAX _SC_BC_BASE_MAX _SC_BC_DIM_MAX, #define _SC_BC_DIM_MAX _SC_BC_DIM_MAX _SC_BC_SCALE_MAX, #define _SC_BC_SCALE_MAX _SC_BC_SCALE_MAX _SC_BC_STRING_MAX, #define _SC_BC_STRING_MAX _SC_BC_STRING_MAX _SC_COLL_WEIGHTS_MAX, #define _SC_COLL_WEIGHTS_MAX _SC_COLL_WEIGHTS_MAX _SC_EQUIV_CLASS_MAX, #define _SC_EQUIV_CLASS_MAX _SC_EQUIV_CLASS_MAX _SC_EXPR_NEST_MAX, #define _SC_EXPR_NEST_MAX _SC_EXPR_NEST_MAX _SC_LINE_MAX, #define _SC_LINE_MAX _SC_LINE_MAX _SC_RE_DUP_MAX, #define _SC_RE_DUP_MAX _SC_RE_DUP_MAX _SC_CHARCLASS_NAME_MAX, #define _SC_CHARCLASS_NAME_MAX _SC_CHARCLASS_NAME_MAX _SC_2_VERSION, #define _SC_2_VERSION _SC_2_VERSION _SC_2_C_BIND, #define _SC_2_C_BIND _SC_2_C_BIND _SC_2_C_DEV, #define _SC_2_C_DEV _SC_2_C_DEV _SC_2_FORT_DEV, #define _SC_2_FORT_DEV _SC_2_FORT_DEV _SC_2_FORT_RUN, #define _SC_2_FORT_RUN _SC_2_FORT_RUN _SC_2_SW_DEV, #define _SC_2_SW_DEV _SC_2_SW_DEV _SC_2_LOCALEDEF, #define _SC_2_LOCALEDEF _SC_2_LOCALEDEF _SC_PII, #define _SC_PII _SC_PII _SC_PII_XTI, #define _SC_PII_XTI _SC_PII_XTI _SC_PII_SOCKET, #define _SC_PII_SOCKET _SC_PII_SOCKET _SC_PII_INTERNET, #define _SC_PII_INTERNET _SC_PII_INTERNET _SC_PII_OSI, #define _SC_PII_OSI _SC_PII_OSI _SC_POLL, #define _SC_POLL _SC_POLL _SC_SELECT, #define _SC_SELECT _SC_SELECT _SC_UIO_MAXIOV, #define _SC_UIO_MAXIOV _SC_UIO_MAXIOV _SC_IOV_MAX = _SC_UIO_MAXIOV, #define _SC_IOV_MAX _SC_IOV_MAX _SC_PII_INTERNET_STREAM, #define _SC_PII_INTERNET_STREAM _SC_PII_INTERNET_STREAM _SC_PII_INTERNET_DGRAM, #define _SC_PII_INTERNET_DGRAM _SC_PII_INTERNET_DGRAM _SC_PII_OSI_COTS, #define _SC_PII_OSI_COTS _SC_PII_OSI_COTS _SC_PII_OSI_CLTS, #define _SC_PII_OSI_CLTS _SC_PII_OSI_CLTS _SC_PII_OSI_M, #define _SC_PII_OSI_M _SC_PII_OSI_M _SC_T_IOV_MAX, #define _SC_T_IOV_MAX _SC_T_IOV_MAX /* Values according to POSIX 1003.1c (POSIX threads). */ _SC_THREADS, #define _SC_THREADS _SC_THREADS _SC_THREAD_SAFE_FUNCTIONS, #define _SC_THREAD_SAFE_FUNCTIONS _SC_THREAD_SAFE_FUNCTIONS _SC_GETGR_R_SIZE_MAX, #define _SC_GETGR_R_SIZE_MAX _SC_GETGR_R_SIZE_MAX _SC_GETPW_R_SIZE_MAX, #define _SC_GETPW_R_SIZE_MAX _SC_GETPW_R_SIZE_MAX _SC_LOGIN_NAME_MAX, #define _SC_LOGIN_NAME_MAX _SC_LOGIN_NAME_MAX _SC_TTY_NAME_MAX, #define _SC_TTY_NAME_MAX _SC_TTY_NAME_MAX _SC_THREAD_DESTRUCTOR_ITERATIONS, #define _SC_THREAD_DESTRUCTOR_ITERATIONS _SC_THREAD_DESTRUCTOR_ITERATIONS _SC_THREAD_KEYS_MAX, #define _SC_THREAD_KEYS_MAX _SC_THREAD_KEYS_MAX _SC_THREAD_STACK_MIN, #define _SC_THREAD_STACK_MIN _SC_THREAD_STACK_MIN _SC_THREAD_THREADS_MAX, #define _SC_THREAD_THREADS_MAX _SC_THREAD_THREADS_MAX _SC_THREAD_ATTR_STACKADDR, #define _SC_THREAD_ATTR_STACKADDR _SC_THREAD_ATTR_STACKADDR _SC_THREAD_ATTR_STACKSIZE, #define _SC_THREAD_ATTR_STACKSIZE _SC_THREAD_ATTR_STACKSIZE _SC_THREAD_PRIORITY_SCHEDULING, #define _SC_THREAD_PRIORITY_SCHEDULING _SC_THREAD_PRIORITY_SCHEDULING _SC_THREAD_PRIO_INHERIT, #define _SC_THREAD_PRIO_INHERIT _SC_THREAD_PRIO_INHERIT _SC_THREAD_PRIO_PROTECT, #define _SC_THREAD_PRIO_PROTECT _SC_THREAD_PRIO_PROTECT _SC_THREAD_PROCESS_SHARED, #define _SC_THREAD_PROCESS_SHARED _SC_THREAD_PROCESS_SHARED _SC_NPROCESSORS_CONF, #define _SC_NPROCESSORS_CONF _SC_NPROCESSORS_CONF _SC_NPROCESSORS_ONLN, #define _SC_NPROCESSORS_ONLN _SC_NPROCESSORS_ONLN _SC_PHYS_PAGES, #define _SC_PHYS_PAGES _SC_PHYS_PAGES _SC_AVPHYS_PAGES, #define _SC_AVPHYS_PAGES _SC_AVPHYS_PAGES _SC_ATEXIT_MAX, #define _SC_ATEXIT_MAX _SC_ATEXIT_MAX _SC_PASS_MAX, #define _SC_PASS_MAX _SC_PASS_MAX _SC_XOPEN_VERSION, #define _SC_XOPEN_VERSION _SC_XOPEN_VERSION _SC_XOPEN_XCU_VERSION, #define _SC_XOPEN_XCU_VERSION _SC_XOPEN_XCU_VERSION _SC_XOPEN_UNIX, #define _SC_XOPEN_UNIX _SC_XOPEN_UNIX _SC_XOPEN_CRYPT, #define _SC_XOPEN_CRYPT _SC_XOPEN_CRYPT _SC_XOPEN_ENH_I18N, #define _SC_XOPEN_ENH_I18N _SC_XOPEN_ENH_I18N _SC_XOPEN_SHM, #define _SC_XOPEN_SHM _SC_XOPEN_SHM _SC_2_CHAR_TERM, #define _SC_2_CHAR_TERM _SC_2_CHAR_TERM _SC_2_C_VERSION, #define _SC_2_C_VERSION _SC_2_C_VERSION _SC_2_UPE, #define _SC_2_UPE _SC_2_UPE _SC_XOPEN_XPG2, #define _SC_XOPEN_XPG2 _SC_XOPEN_XPG2 _SC_XOPEN_XPG3, #define _SC_XOPEN_XPG3 _SC_XOPEN_XPG3 _SC_XOPEN_XPG4, #define _SC_XOPEN_XPG4 _SC_XOPEN_XPG4 _SC_CHAR_BIT, #define _SC_CHAR_BIT _SC_CHAR_BIT _SC_CHAR_MAX, #define _SC_CHAR_MAX _SC_CHAR_MAX _SC_CHAR_MIN, #define _SC_CHAR_MIN _SC_CHAR_MIN _SC_INT_MAX, #define _SC_INT_MAX _SC_INT_MAX _SC_INT_MIN, #define _SC_INT_MIN _SC_INT_MIN _SC_LONG_BIT, #define _SC_LONG_BIT _SC_LONG_BIT _SC_WORD_BIT, #define _SC_WORD_BIT _SC_WORD_BIT _SC_MB_LEN_MAX, #define _SC_MB_LEN_MAX _SC_MB_LEN_MAX _SC_NZERO, #define _SC_NZERO _SC_NZERO _SC_SSIZE_MAX, #define _SC_SSIZE_MAX _SC_SSIZE_MAX _SC_SCHAR_MAX, #define _SC_SCHAR_MAX _SC_SCHAR_MAX _SC_SCHAR_MIN, #define _SC_SCHAR_MIN _SC_SCHAR_MIN _SC_SHRT_MAX, #define _SC_SHRT_MAX _SC_SHRT_MAX _SC_SHRT_MIN, #define _SC_SHRT_MIN _SC_SHRT_MIN _SC_UCHAR_MAX, #define _SC_UCHAR_MAX _SC_UCHAR_MAX _SC_UINT_MAX, #define _SC_UINT_MAX _SC_UINT_MAX _SC_ULONG_MAX, #define _SC_ULONG_MAX _SC_ULONG_MAX _SC_USHRT_MAX, #define _SC_USHRT_MAX _SC_USHRT_MAX _SC_NL_ARGMAX, #define _SC_NL_ARGMAX _SC_NL_ARGMAX _SC_NL_LANGMAX, #define _SC_NL_LANGMAX _SC_NL_LANGMAX _SC_NL_MSGMAX, #define _SC_NL_MSGMAX _SC_NL_MSGMAX _SC_NL_NMAX, #define _SC_NL_NMAX _SC_NL_NMAX _SC_NL_SETMAX, #define _SC_NL_SETMAX _SC_NL_SETMAX _SC_NL_TEXTMAX, #define _SC_NL_TEXTMAX _SC_NL_TEXTMAX _SC_XBS5_ILP32_OFF32, #define _SC_XBS5_ILP32_OFF32 _SC_XBS5_ILP32_OFF32 _SC_XBS5_ILP32_OFFBIG, #define _SC_XBS5_ILP32_OFFBIG _SC_XBS5_ILP32_OFFBIG _SC_XBS5_LP64_OFF64, #define _SC_XBS5_LP64_OFF64 _SC_XBS5_LP64_OFF64 _SC_XBS5_LPBIG_OFFBIG, #define _SC_XBS5_LPBIG_OFFBIG _SC_XBS5_LPBIG_OFFBIG _SC_XOPEN_LEGACY, #define _SC_XOPEN_LEGACY _SC_XOPEN_LEGACY _SC_XOPEN_REALTIME, #define _SC_XOPEN_REALTIME _SC_XOPEN_REALTIME _SC_XOPEN_REALTIME_THREADS, #define _SC_XOPEN_REALTIME_THREADS _SC_XOPEN_REALTIME_THREADS _SC_ADVISORY_INFO, #define _SC_ADVISORY_INFO _SC_ADVISORY_INFO _SC_BARRIERS, #define _SC_BARRIERS _SC_BARRIERS _SC_BASE, #define _SC_BASE _SC_BASE _SC_C_LANG_SUPPORT, #define _SC_C_LANG_SUPPORT _SC_C_LANG_SUPPORT _SC_C_LANG_SUPPORT_R, #define _SC_C_LANG_SUPPORT_R _SC_C_LANG_SUPPORT_R _SC_CLOCK_SELECTION, #define _SC_CLOCK_SELECTION _SC_CLOCK_SELECTION _SC_CPUTIME, #define _SC_CPUTIME _SC_CPUTIME _SC_THREAD_CPUTIME, #define _SC_THREAD_CPUTIME _SC_THREAD_CPUTIME _SC_DEVICE_IO, #define _SC_DEVICE_IO _SC_DEVICE_IO _SC_DEVICE_SPECIFIC, #define _SC_DEVICE_SPECIFIC _SC_DEVICE_SPECIFIC _SC_DEVICE_SPECIFIC_R, #define _SC_DEVICE_SPECIFIC_R _SC_DEVICE_SPECIFIC_R _SC_FD_MGMT, #define _SC_FD_MGMT _SC_FD_MGMT _SC_FIFO, #define _SC_FIFO _SC_FIFO _SC_PIPE, #define _SC_PIPE _SC_PIPE _SC_FILE_ATTRIBUTES, #define _SC_FILE_ATTRIBUTES _SC_FILE_ATTRIBUTES _SC_FILE_LOCKING, #define _SC_FILE_LOCKING _SC_FILE_LOCKING _SC_FILE_SYSTEM, #define _SC_FILE_SYSTEM _SC_FILE_SYSTEM _SC_MONOTONIC_CLOCK, #define _SC_MONOTONIC_CLOCK _SC_MONOTONIC_CLOCK _SC_MULTI_PROCESS, #define _SC_MULTI_PROCESS _SC_MULTI_PROCESS _SC_SINGLE_PROCESS, #define _SC_SINGLE_PROCESS _SC_SINGLE_PROCESS _SC_NETWORKING, #define _SC_NETWORKING _SC_NETWORKING _SC_READER_WRITER_LOCKS, #define _SC_READER_WRITER_LOCKS _SC_READER_WRITER_LOCKS _SC_SPIN_LOCKS, #define _SC_SPIN_LOCKS _SC_SPIN_LOCKS _SC_REGEXP, #define _SC_REGEXP _SC_REGEXP _SC_REGEX_VERSION, #define _SC_REGEX_VERSION _SC_REGEX_VERSION _SC_SHELL, #define _SC_SHELL _SC_SHELL _SC_SIGNALS, #define _SC_SIGNALS _SC_SIGNALS _SC_SPAWN, #define _SC_SPAWN _SC_SPAWN _SC_SPORADIC_SERVER, #define _SC_SPORADIC_SERVER _SC_SPORADIC_SERVER _SC_THREAD_SPORADIC_SERVER, #define _SC_THREAD_SPORADIC_SERVER _SC_THREAD_SPORADIC_SERVER _SC_SYSTEM_DATABASE, #define _SC_SYSTEM_DATABASE _SC_SYSTEM_DATABASE _SC_SYSTEM_DATABASE_R, #define _SC_SYSTEM_DATABASE_R _SC_SYSTEM_DATABASE_R _SC_TIMEOUTS, #define _SC_TIMEOUTS _SC_TIMEOUTS _SC_TYPED_MEMORY_OBJECTS, #define _SC_TYPED_MEMORY_OBJECTS _SC_TYPED_MEMORY_OBJECTS _SC_USER_GROUPS, #define _SC_USER_GROUPS _SC_USER_GROUPS _SC_USER_GROUPS_R, #define _SC_USER_GROUPS_R _SC_USER_GROUPS_R _SC_2_PBS, #define _SC_2_PBS _SC_2_PBS _SC_2_PBS_ACCOUNTING, #define _SC_2_PBS_ACCOUNTING _SC_2_PBS_ACCOUNTING _SC_2_PBS_LOCATE, #define _SC_2_PBS_LOCATE _SC_2_PBS_LOCATE _SC_2_PBS_MESSAGE, #define _SC_2_PBS_MESSAGE _SC_2_PBS_MESSAGE _SC_2_PBS_TRACK, #define _SC_2_PBS_TRACK _SC_2_PBS_TRACK _SC_SYMLOOP_MAX, #define _SC_SYMLOOP_MAX _SC_SYMLOOP_MAX _SC_STREAMS, #define _SC_STREAMS _SC_STREAMS _SC_2_PBS_CHECKPOINT, #define _SC_2_PBS_CHECKPOINT _SC_2_PBS_CHECKPOINT _SC_V6_ILP32_OFF32, #define _SC_V6_ILP32_OFF32 _SC_V6_ILP32_OFF32 _SC_V6_ILP32_OFFBIG, #define _SC_V6_ILP32_OFFBIG _SC_V6_ILP32_OFFBIG _SC_V6_LP64_OFF64, #define _SC_V6_LP64_OFF64 _SC_V6_LP64_OFF64 _SC_V6_LPBIG_OFFBIG, #define _SC_V6_LPBIG_OFFBIG _SC_V6_LPBIG_OFFBIG _SC_HOST_NAME_MAX, #define _SC_HOST_NAME_MAX _SC_HOST_NAME_MAX _SC_TRACE, #define _SC_TRACE _SC_TRACE _SC_TRACE_EVENT_FILTER, #define _SC_TRACE_EVENT_FILTER _SC_TRACE_EVENT_FILTER _SC_TRACE_INHERIT, #define _SC_TRACE_INHERIT _SC_TRACE_INHERIT _SC_TRACE_LOG, #define _SC_TRACE_LOG _SC_TRACE_LOG _SC_LEVEL1_ICACHE_SIZE, #define _SC_LEVEL1_ICACHE_SIZE _SC_LEVEL1_ICACHE_SIZE _SC_LEVEL1_ICACHE_ASSOC, #define _SC_LEVEL1_ICACHE_ASSOC _SC_LEVEL1_ICACHE_ASSOC _SC_LEVEL1_ICACHE_LINESIZE, #define _SC_LEVEL1_ICACHE_LINESIZE _SC_LEVEL1_ICACHE_LINESIZE _SC_LEVEL1_DCACHE_SIZE, #define _SC_LEVEL1_DCACHE_SIZE _SC_LEVEL1_DCACHE_SIZE _SC_LEVEL1_DCACHE_ASSOC, #define _SC_LEVEL1_DCACHE_ASSOC _SC_LEVEL1_DCACHE_ASSOC _SC_LEVEL1_DCACHE_LINESIZE, #define _SC_LEVEL1_DCACHE_LINESIZE _SC_LEVEL1_DCACHE_LINESIZE _SC_LEVEL2_CACHE_SIZE, #define _SC_LEVEL2_CACHE_SIZE _SC_LEVEL2_CACHE_SIZE _SC_LEVEL2_CACHE_ASSOC, #define _SC_LEVEL2_CACHE_ASSOC _SC_LEVEL2_CACHE_ASSOC _SC_LEVEL2_CACHE_LINESIZE, #define _SC_LEVEL2_CACHE_LINESIZE _SC_LEVEL2_CACHE_LINESIZE _SC_LEVEL3_CACHE_SIZE, #define _SC_LEVEL3_CACHE_SIZE _SC_LEVEL3_CACHE_SIZE _SC_LEVEL3_CACHE_ASSOC, #define _SC_LEVEL3_CACHE_ASSOC _SC_LEVEL3_CACHE_ASSOC _SC_LEVEL3_CACHE_LINESIZE, #define _SC_LEVEL3_CACHE_LINESIZE _SC_LEVEL3_CACHE_LINESIZE _SC_LEVEL4_CACHE_SIZE, #define _SC_LEVEL4_CACHE_SIZE _SC_LEVEL4_CACHE_SIZE _SC_LEVEL4_CACHE_ASSOC, #define _SC_LEVEL4_CACHE_ASSOC _SC_LEVEL4_CACHE_ASSOC _SC_LEVEL4_CACHE_LINESIZE, #define _SC_LEVEL4_CACHE_LINESIZE _SC_LEVEL4_CACHE_LINESIZE /* Leave room here, maybe we need a few more cache levels some day. */ _SC_IPV6 = _SC_LEVEL1_ICACHE_SIZE + 50, #define _SC_IPV6 _SC_IPV6 _SC_RAW_SOCKETS, #define _SC_RAW_SOCKETS _SC_RAW_SOCKETS _SC_V7_ILP32_OFF32, #define _SC_V7_ILP32_OFF32 _SC_V7_ILP32_OFF32 _SC_V7_ILP32_OFFBIG, #define _SC_V7_ILP32_OFFBIG _SC_V7_ILP32_OFFBIG _SC_V7_LP64_OFF64, #define _SC_V7_LP64_OFF64 _SC_V7_LP64_OFF64 _SC_V7_LPBIG_OFFBIG, #define _SC_V7_LPBIG_OFFBIG _SC_V7_LPBIG_OFFBIG _SC_SS_REPL_MAX, #define _SC_SS_REPL_MAX _SC_SS_REPL_MAX _SC_TRACE_EVENT_NAME_MAX, #define _SC_TRACE_EVENT_NAME_MAX _SC_TRACE_EVENT_NAME_MAX _SC_TRACE_NAME_MAX, #define _SC_TRACE_NAME_MAX _SC_TRACE_NAME_MAX _SC_TRACE_SYS_MAX, #define _SC_TRACE_SYS_MAX _SC_TRACE_SYS_MAX _SC_TRACE_USER_EVENT_MAX, #define _SC_TRACE_USER_EVENT_MAX _SC_TRACE_USER_EVENT_MAX _SC_XOPEN_STREAMS, #define _SC_XOPEN_STREAMS _SC_XOPEN_STREAMS _SC_THREAD_ROBUST_PRIO_INHERIT, #define _SC_THREAD_ROBUST_PRIO_INHERIT _SC_THREAD_ROBUST_PRIO_INHERIT _SC_THREAD_ROBUST_PRIO_PROTECT, #define _SC_THREAD_ROBUST_PRIO_PROTECT _SC_THREAD_ROBUST_PRIO_PROTECT _SC_MINSIGSTKSZ, #define _SC_MINSIGSTKSZ _SC_MINSIGSTKSZ _SC_SIGSTKSZ #define _SC_SIGSTKSZ _SC_SIGSTKSZ }; /* Values for the NAME argument to `confstr'. */ enum { _CS_PATH, /* The default search path. */ #define _CS_PATH _CS_PATH _CS_V6_WIDTH_RESTRICTED_ENVS, #define _CS_V6_WIDTH_RESTRICTED_ENVS _CS_V6_WIDTH_RESTRICTED_ENVS #define _CS_POSIX_V6_WIDTH_RESTRICTED_ENVS _CS_V6_WIDTH_RESTRICTED_ENVS _CS_GNU_LIBC_VERSION, #define _CS_GNU_LIBC_VERSION _CS_GNU_LIBC_VERSION _CS_GNU_LIBPTHREAD_VERSION, #define _CS_GNU_LIBPTHREAD_VERSION _CS_GNU_LIBPTHREAD_VERSION _CS_V5_WIDTH_RESTRICTED_ENVS, #define _CS_V5_WIDTH_RESTRICTED_ENVS _CS_V5_WIDTH_RESTRICTED_ENVS #define _CS_POSIX_V5_WIDTH_RESTRICTED_ENVS _CS_V5_WIDTH_RESTRICTED_ENVS _CS_V7_WIDTH_RESTRICTED_ENVS, #define _CS_V7_WIDTH_RESTRICTED_ENVS _CS_V7_WIDTH_RESTRICTED_ENVS #define _CS_POSIX_V7_WIDTH_RESTRICTED_ENVS _CS_V7_WIDTH_RESTRICTED_ENVS _CS_LFS_CFLAGS = 1000, #define _CS_LFS_CFLAGS _CS_LFS_CFLAGS _CS_LFS_LDFLAGS, #define _CS_LFS_LDFLAGS _CS_LFS_LDFLAGS _CS_LFS_LIBS, #define _CS_LFS_LIBS _CS_LFS_LIBS _CS_LFS_LINTFLAGS, #define _CS_LFS_LINTFLAGS _CS_LFS_LINTFLAGS _CS_LFS64_CFLAGS, #define _CS_LFS64_CFLAGS _CS_LFS64_CFLAGS _CS_LFS64_LDFLAGS, #define _CS_LFS64_LDFLAGS _CS_LFS64_LDFLAGS _CS_LFS64_LIBS, #define _CS_LFS64_LIBS _CS_LFS64_LIBS _CS_LFS64_LINTFLAGS, #define _CS_LFS64_LINTFLAGS _CS_LFS64_LINTFLAGS _CS_XBS5_ILP32_OFF32_CFLAGS = 1100, #define _CS_XBS5_ILP32_OFF32_CFLAGS _CS_XBS5_ILP32_OFF32_CFLAGS _CS_XBS5_ILP32_OFF32_LDFLAGS, #define _CS_XBS5_ILP32_OFF32_LDFLAGS _CS_XBS5_ILP32_OFF32_LDFLAGS _CS_XBS5_ILP32_OFF32_LIBS, #define _CS_XBS5_ILP32_OFF32_LIBS _CS_XBS5_ILP32_OFF32_LIBS _CS_XBS5_ILP32_OFF32_LINTFLAGS, #define _CS_XBS5_ILP32_OFF32_LINTFLAGS _CS_XBS5_ILP32_OFF32_LINTFLAGS _CS_XBS5_ILP32_OFFBIG_CFLAGS, #define _CS_XBS5_ILP32_OFFBIG_CFLAGS _CS_XBS5_ILP32_OFFBIG_CFLAGS _CS_XBS5_ILP32_OFFBIG_LDFLAGS, #define _CS_XBS5_ILP32_OFFBIG_LDFLAGS _CS_XBS5_ILP32_OFFBIG_LDFLAGS _CS_XBS5_ILP32_OFFBIG_LIBS, #define _CS_XBS5_ILP32_OFFBIG_LIBS _CS_XBS5_ILP32_OFFBIG_LIBS _CS_XBS5_ILP32_OFFBIG_LINTFLAGS, #define _CS_XBS5_ILP32_OFFBIG_LINTFLAGS _CS_XBS5_ILP32_OFFBIG_LINTFLAGS _CS_XBS5_LP64_OFF64_CFLAGS, #define _CS_XBS5_LP64_OFF64_CFLAGS _CS_XBS5_LP64_OFF64_CFLAGS _CS_XBS5_LP64_OFF64_LDFLAGS, #define _CS_XBS5_LP64_OFF64_LDFLAGS _CS_XBS5_LP64_OFF64_LDFLAGS _CS_XBS5_LP64_OFF64_LIBS, #define _CS_XBS5_LP64_OFF64_LIBS _CS_XBS5_LP64_OFF64_LIBS _CS_XBS5_LP64_OFF64_LINTFLAGS, #define _CS_XBS5_LP64_OFF64_LINTFLAGS _CS_XBS5_LP64_OFF64_LINTFLAGS _CS_XBS5_LPBIG_OFFBIG_CFLAGS, #define _CS_XBS5_LPBIG_OFFBIG_CFLAGS _CS_XBS5_LPBIG_OFFBIG_CFLAGS _CS_XBS5_LPBIG_OFFBIG_LDFLAGS, #define _CS_XBS5_LPBIG_OFFBIG_LDFLAGS _CS_XBS5_LPBIG_OFFBIG_LDFLAGS _CS_XBS5_LPBIG_OFFBIG_LIBS, #define _CS_XBS5_LPBIG_OFFBIG_LIBS _CS_XBS5_LPBIG_OFFBIG_LIBS _CS_XBS5_LPBIG_OFFBIG_LINTFLAGS, #define _CS_XBS5_LPBIG_OFFBIG_LINTFLAGS _CS_XBS5_LPBIG_OFFBIG_LINTFLAGS _CS_POSIX_V6_ILP32_OFF32_CFLAGS, #define _CS_POSIX_V6_ILP32_OFF32_CFLAGS _CS_POSIX_V6_ILP32_OFF32_CFLAGS _CS_POSIX_V6_ILP32_OFF32_LDFLAGS, #define _CS_POSIX_V6_ILP32_OFF32_LDFLAGS _CS_POSIX_V6_ILP32_OFF32_LDFLAGS _CS_POSIX_V6_ILP32_OFF32_LIBS, #define _CS_POSIX_V6_ILP32_OFF32_LIBS _CS_POSIX_V6_ILP32_OFF32_LIBS _CS_POSIX_V6_ILP32_OFF32_LINTFLAGS, #define _CS_POSIX_V6_ILP32_OFF32_LINTFLAGS _CS_POSIX_V6_ILP32_OFF32_LINTFLAGS _CS_POSIX_V6_ILP32_OFFBIG_CFLAGS, #define _CS_POSIX_V6_ILP32_OFFBIG_CFLAGS _CS_POSIX_V6_ILP32_OFFBIG_CFLAGS _CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS, #define _CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS _CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS _CS_POSIX_V6_ILP32_OFFBIG_LIBS, #define _CS_POSIX_V6_ILP32_OFFBIG_LIBS _CS_POSIX_V6_ILP32_OFFBIG_LIBS _CS_POSIX_V6_ILP32_OFFBIG_LINTFLAGS, #define _CS_POSIX_V6_ILP32_OFFBIG_LINTFLAGS _CS_POSIX_V6_ILP32_OFFBIG_LINTFLAGS _CS_POSIX_V6_LP64_OFF64_CFLAGS, #define _CS_POSIX_V6_LP64_OFF64_CFLAGS _CS_POSIX_V6_LP64_OFF64_CFLAGS _CS_POSIX_V6_LP64_OFF64_LDFLAGS, #define _CS_POSIX_V6_LP64_OFF64_LDFLAGS _CS_POSIX_V6_LP64_OFF64_LDFLAGS _CS_POSIX_V6_LP64_OFF64_LIBS, #define _CS_POSIX_V6_LP64_OFF64_LIBS _CS_POSIX_V6_LP64_OFF64_LIBS _CS_POSIX_V6_LP64_OFF64_LINTFLAGS, #define _CS_POSIX_V6_LP64_OFF64_LINTFLAGS _CS_POSIX_V6_LP64_OFF64_LINTFLAGS _CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS, #define _CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS _CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS _CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS, #define _CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS _CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS _CS_POSIX_V6_LPBIG_OFFBIG_LIBS, #define _CS_POSIX_V6_LPBIG_OFFBIG_LIBS _CS_POSIX_V6_LPBIG_OFFBIG_LIBS _CS_POSIX_V6_LPBIG_OFFBIG_LINTFLAGS, #define _CS_POSIX_V6_LPBIG_OFFBIG_LINTFLAGS _CS_POSIX_V6_LPBIG_OFFBIG_LINTFLAGS _CS_POSIX_V7_ILP32_OFF32_CFLAGS, #define _CS_POSIX_V7_ILP32_OFF32_CFLAGS _CS_POSIX_V7_ILP32_OFF32_CFLAGS _CS_POSIX_V7_ILP32_OFF32_LDFLAGS, #define _CS_POSIX_V7_ILP32_OFF32_LDFLAGS _CS_POSIX_V7_ILP32_OFF32_LDFLAGS _CS_POSIX_V7_ILP32_OFF32_LIBS, #define _CS_POSIX_V7_ILP32_OFF32_LIBS _CS_POSIX_V7_ILP32_OFF32_LIBS _CS_POSIX_V7_ILP32_OFF32_LINTFLAGS, #define _CS_POSIX_V7_ILP32_OFF32_LINTFLAGS _CS_POSIX_V7_ILP32_OFF32_LINTFLAGS _CS_POSIX_V7_ILP32_OFFBIG_CFLAGS, #define _CS_POSIX_V7_ILP32_OFFBIG_CFLAGS _CS_POSIX_V7_ILP32_OFFBIG_CFLAGS _CS_POSIX_V7_ILP32_OFFBIG_LDFLAGS, #define _CS_POSIX_V7_ILP32_OFFBIG_LDFLAGS _CS_POSIX_V7_ILP32_OFFBIG_LDFLAGS _CS_POSIX_V7_ILP32_OFFBIG_LIBS, #define _CS_POSIX_V7_ILP32_OFFBIG_LIBS _CS_POSIX_V7_ILP32_OFFBIG_LIBS _CS_POSIX_V7_ILP32_OFFBIG_LINTFLAGS, #define _CS_POSIX_V7_ILP32_OFFBIG_LINTFLAGS _CS_POSIX_V7_ILP32_OFFBIG_LINTFLAGS _CS_POSIX_V7_LP64_OFF64_CFLAGS, #define _CS_POSIX_V7_LP64_OFF64_CFLAGS _CS_POSIX_V7_LP64_OFF64_CFLAGS _CS_POSIX_V7_LP64_OFF64_LDFLAGS, #define _CS_POSIX_V7_LP64_OFF64_LDFLAGS _CS_POSIX_V7_LP64_OFF64_LDFLAGS _CS_POSIX_V7_LP64_OFF64_LIBS, #define _CS_POSIX_V7_LP64_OFF64_LIBS _CS_POSIX_V7_LP64_OFF64_LIBS _CS_POSIX_V7_LP64_OFF64_LINTFLAGS, #define _CS_POSIX_V7_LP64_OFF64_LINTFLAGS _CS_POSIX_V7_LP64_OFF64_LINTFLAGS _CS_POSIX_V7_LPBIG_OFFBIG_CFLAGS, #define _CS_POSIX_V7_LPBIG_OFFBIG_CFLAGS _CS_POSIX_V7_LPBIG_OFFBIG_CFLAGS _CS_POSIX_V7_LPBIG_OFFBIG_LDFLAGS, #define _CS_POSIX_V7_LPBIG_OFFBIG_LDFLAGS _CS_POSIX_V7_LPBIG_OFFBIG_LDFLAGS _CS_POSIX_V7_LPBIG_OFFBIG_LIBS, #define _CS_POSIX_V7_LPBIG_OFFBIG_LIBS _CS_POSIX_V7_LPBIG_OFFBIG_LIBS _CS_POSIX_V7_LPBIG_OFFBIG_LINTFLAGS, #define _CS_POSIX_V7_LPBIG_OFFBIG_LINTFLAGS _CS_POSIX_V7_LPBIG_OFFBIG_LINTFLAGS _CS_V6_ENV, #define _CS_V6_ENV _CS_V6_ENV _CS_V7_ENV #define _CS_V7_ENV _CS_V7_ENV }; error.h 0000644 00000005174 15125171642 0006061 0 ustar 00 /* Specializations for error functions. Copyright (C) 2007-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _ERROR_H # error "Never include <bits/error.h> directly; use <error.h> instead." #endif extern void __REDIRECT (__error_alias, (int __status, int __errnum, const char *__format, ...), error) __attribute__ ((__format__ (__printf__, 3, 4))); extern void __REDIRECT (__error_noreturn, (int __status, int __errnum, const char *__format, ...), error) __attribute__ ((__noreturn__, __format__ (__printf__, 3, 4))); /* If we know the function will never return make sure the compiler realizes that, too. */ __extern_always_inline void error (int __status, int __errnum, const char *__format, ...) { if (__builtin_constant_p (__status) && __status != 0) __error_noreturn (__status, __errnum, __format, __va_arg_pack ()); else __error_alias (__status, __errnum, __format, __va_arg_pack ()); } extern void __REDIRECT (__error_at_line_alias, (int __status, int __errnum, const char *__fname, unsigned int __line, const char *__format, ...), error_at_line) __attribute__ ((__format__ (__printf__, 5, 6))); extern void __REDIRECT (__error_at_line_noreturn, (int __status, int __errnum, const char *__fname, unsigned int __line, const char *__format, ...), error_at_line) __attribute__ ((__noreturn__, __format__ (__printf__, 5, 6))); /* If we know the function will never return make sure the compiler realizes that, too. */ __extern_always_inline void error_at_line (int __status, int __errnum, const char *__fname, unsigned int __line, const char *__format, ...) { if (__builtin_constant_p (__status) && __status != 0) __error_at_line_noreturn (__status, __errnum, __fname, __line, __format, __va_arg_pack ()); else __error_at_line_alias (__status, __errnum, __fname, __line, __format, __va_arg_pack ()); } wchar.h 0000644 00000003562 15125171642 0006033 0 ustar 00 /* wchar_t type related definitions. Copyright (C) 2000-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _BITS_WCHAR_H #define _BITS_WCHAR_H 1 /* The fallback definitions, for when __WCHAR_MAX__ or __WCHAR_MIN__ are not defined, give the right value and type as long as both int and wchar_t are 32-bit types. Adding L'\0' to a constant value ensures that the type is correct; it is necessary to use (L'\0' + 0) rather than just L'\0' so that the type in C++ is the promoted version of wchar_t rather than the distinct wchar_t type itself. Because wchar_t in preprocessor #if expressions is treated as intmax_t or uintmax_t, the expression (L'\0' - 1) would have the wrong value for WCHAR_MAX in such expressions and so cannot be used to define __WCHAR_MAX in the unsigned case. */ #ifdef __WCHAR_MAX__ # define __WCHAR_MAX __WCHAR_MAX__ #elif L'\0' - 1 > 0 # define __WCHAR_MAX (0xffffffffu + L'\0') #else # define __WCHAR_MAX (0x7fffffff + L'\0') #endif #ifdef __WCHAR_MIN__ # define __WCHAR_MIN __WCHAR_MIN__ #elif L'\0' - 1 > 0 # define __WCHAR_MIN (L'\0' + 0) #else # define __WCHAR_MIN (-__WCHAR_MAX - 1) #endif #endif /* bits/wchar.h */ unistd.h 0000644 00000026605 15125171642 0006240 0 ustar 00 /* Checking macros for unistd functions. Copyright (C) 2005-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _UNISTD_H # error "Never include <bits/unistd.h> directly; use <unistd.h> instead." #endif extern ssize_t __read_chk (int __fd, void *__buf, size_t __nbytes, size_t __buflen) __wur __attr_access ((__write_only__, 2, 3)); extern ssize_t __REDIRECT (__read_alias, (int __fd, void *__buf, size_t __nbytes), read) __wur __attr_access ((__write_only__, 2, 3)); extern ssize_t __REDIRECT (__read_chk_warn, (int __fd, void *__buf, size_t __nbytes, size_t __buflen), __read_chk) __wur __warnattr ("read called with bigger length than size of " "the destination buffer"); __fortify_function __wur ssize_t read (int __fd, void *__buf, size_t __nbytes) { return __glibc_fortify (read, __nbytes, sizeof (char), __glibc_objsize0 (__buf), __fd, __buf, __nbytes); } #if defined __USE_UNIX98 || defined __USE_XOPEN2K8 extern ssize_t __pread_chk (int __fd, void *__buf, size_t __nbytes, __off_t __offset, size_t __bufsize) __wur __attr_access ((__write_only__, 2, 3)); extern ssize_t __pread64_chk (int __fd, void *__buf, size_t __nbytes, __off64_t __offset, size_t __bufsize) __wur __attr_access ((__write_only__, 2, 3)); extern ssize_t __REDIRECT (__pread_alias, (int __fd, void *__buf, size_t __nbytes, __off_t __offset), pread) __wur __attr_access ((__write_only__, 2, 3)); extern ssize_t __REDIRECT (__pread64_alias, (int __fd, void *__buf, size_t __nbytes, __off64_t __offset), pread64) __wur __attr_access ((__write_only__, 2, 3)); extern ssize_t __REDIRECT (__pread_chk_warn, (int __fd, void *__buf, size_t __nbytes, __off_t __offset, size_t __bufsize), __pread_chk) __wur __warnattr ("pread called with bigger length than size of " "the destination buffer"); extern ssize_t __REDIRECT (__pread64_chk_warn, (int __fd, void *__buf, size_t __nbytes, __off64_t __offset, size_t __bufsize), __pread64_chk) __wur __warnattr ("pread64 called with bigger length than size of " "the destination buffer"); # ifndef __USE_FILE_OFFSET64 __fortify_function __wur ssize_t pread (int __fd, void *__buf, size_t __nbytes, __off_t __offset) { return __glibc_fortify (pread, __nbytes, sizeof (char), __glibc_objsize0 (__buf), __fd, __buf, __nbytes, __offset); } # else __fortify_function __wur ssize_t pread (int __fd, void *__buf, size_t __nbytes, __off64_t __offset) { return __glibc_fortify (pread64, __nbytes, sizeof (char), __glibc_objsize0 (__buf), __fd, __buf, __nbytes, __offset); } # endif # ifdef __USE_LARGEFILE64 __fortify_function __wur ssize_t pread64 (int __fd, void *__buf, size_t __nbytes, __off64_t __offset) { return __glibc_fortify (pread64, __nbytes, sizeof (char), __glibc_objsize0 (__buf), __fd, __buf, __nbytes, __offset); } # endif #endif #if defined __USE_XOPEN_EXTENDED || defined __USE_XOPEN2K extern ssize_t __readlink_chk (const char *__restrict __path, char *__restrict __buf, size_t __len, size_t __buflen) __THROW __nonnull ((1, 2)) __wur __attr_access ((__write_only__, 2, 3)); extern ssize_t __REDIRECT_NTH (__readlink_alias, (const char *__restrict __path, char *__restrict __buf, size_t __len), readlink) __nonnull ((1, 2)) __wur __attr_access ((__write_only__, 2, 3)); extern ssize_t __REDIRECT_NTH (__readlink_chk_warn, (const char *__restrict __path, char *__restrict __buf, size_t __len, size_t __buflen), __readlink_chk) __nonnull ((1, 2)) __wur __warnattr ("readlink called with bigger length " "than size of destination buffer"); __fortify_function __nonnull ((1, 2)) __wur ssize_t __NTH (readlink (const char *__restrict __path, char *__restrict __buf, size_t __len)) { return __glibc_fortify (readlink, __len, sizeof (char), __glibc_objsize (__buf), __path, __buf, __len); } #endif #ifdef __USE_ATFILE extern ssize_t __readlinkat_chk (int __fd, const char *__restrict __path, char *__restrict __buf, size_t __len, size_t __buflen) __THROW __nonnull ((2, 3)) __wur __attr_access ((__write_only__, 3, 4)); extern ssize_t __REDIRECT_NTH (__readlinkat_alias, (int __fd, const char *__restrict __path, char *__restrict __buf, size_t __len), readlinkat) __nonnull ((2, 3)) __wur __attr_access ((__write_only__, 3, 4)); extern ssize_t __REDIRECT_NTH (__readlinkat_chk_warn, (int __fd, const char *__restrict __path, char *__restrict __buf, size_t __len, size_t __buflen), __readlinkat_chk) __nonnull ((2, 3)) __wur __warnattr ("readlinkat called with bigger " "length than size of destination " "buffer"); __fortify_function __nonnull ((2, 3)) __wur ssize_t __NTH (readlinkat (int __fd, const char *__restrict __path, char *__restrict __buf, size_t __len)) { return __glibc_fortify (readlinkat, __len, sizeof (char), __glibc_objsize (__buf), __fd, __path, __buf, __len); } #endif extern char *__getcwd_chk (char *__buf, size_t __size, size_t __buflen) __THROW __wur; extern char *__REDIRECT_NTH (__getcwd_alias, (char *__buf, size_t __size), getcwd) __wur; extern char *__REDIRECT_NTH (__getcwd_chk_warn, (char *__buf, size_t __size, size_t __buflen), __getcwd_chk) __wur __warnattr ("getcwd caller with bigger length than size of " "destination buffer"); __fortify_function __wur char * __NTH (getcwd (char *__buf, size_t __size)) { return __glibc_fortify (getcwd, __size, sizeof (char), __glibc_objsize (__buf), __buf, __size); } #if defined __USE_MISC || defined __USE_XOPEN_EXTENDED extern char *__getwd_chk (char *__buf, size_t buflen) __THROW __nonnull ((1)) __wur __attr_access ((__write_only__, 1, 2)); extern char *__REDIRECT_NTH (__getwd_warn, (char *__buf), getwd) __nonnull ((1)) __wur __warnattr ("please use getcwd instead, as getwd " "doesn't specify buffer size"); __fortify_function __nonnull ((1)) __attribute_deprecated__ __wur char * __NTH (getwd (char *__buf)) { if (__glibc_objsize (__buf) != (size_t) -1) return __getwd_chk (__buf, __glibc_objsize (__buf)); return __getwd_warn (__buf); } #endif extern size_t __confstr_chk (int __name, char *__buf, size_t __len, size_t __buflen) __THROW __attr_access ((__write_only__, 2, 3)); extern size_t __REDIRECT_NTH (__confstr_alias, (int __name, char *__buf, size_t __len), confstr) __attr_access ((__write_only__, 2, 3)); extern size_t __REDIRECT_NTH (__confstr_chk_warn, (int __name, char *__buf, size_t __len, size_t __buflen), __confstr_chk) __warnattr ("confstr called with bigger length than size of destination " "buffer"); __fortify_function size_t __NTH (confstr (int __name, char *__buf, size_t __len)) { return __glibc_fortify (confstr, __len, sizeof (char), __glibc_objsize (__buf), __name, __buf, __len); } extern int __getgroups_chk (int __size, __gid_t __list[], size_t __listlen) __THROW __wur __attr_access ((__write_only__, 2, 1)); extern int __REDIRECT_NTH (__getgroups_alias, (int __size, __gid_t __list[]), getgroups) __wur __attr_access ((__write_only__, 2, 1)); extern int __REDIRECT_NTH (__getgroups_chk_warn, (int __size, __gid_t __list[], size_t __listlen), __getgroups_chk) __wur __warnattr ("getgroups called with bigger group count than what " "can fit into destination buffer"); __fortify_function int __NTH (getgroups (int __size, __gid_t __list[])) { return __glibc_fortify (getgroups, __size, sizeof (__gid_t), __glibc_objsize (__list), __size, __list); } extern int __ttyname_r_chk (int __fd, char *__buf, size_t __buflen, size_t __nreal) __THROW __nonnull ((2)) __attr_access ((__write_only__, 2, 3)); extern int __REDIRECT_NTH (__ttyname_r_alias, (int __fd, char *__buf, size_t __buflen), ttyname_r) __nonnull ((2)); extern int __REDIRECT_NTH (__ttyname_r_chk_warn, (int __fd, char *__buf, size_t __buflen, size_t __nreal), __ttyname_r_chk) __nonnull ((2)) __warnattr ("ttyname_r called with bigger buflen than " "size of destination buffer"); __fortify_function int __NTH (ttyname_r (int __fd, char *__buf, size_t __buflen)) { return __glibc_fortify (ttyname_r, __buflen, sizeof (char), __glibc_objsize (__buf), __fd, __buf, __buflen); } #ifdef __USE_POSIX199506 extern int __getlogin_r_chk (char *__buf, size_t __buflen, size_t __nreal) __nonnull ((1)) __attr_access ((__write_only__, 1, 2)); extern int __REDIRECT (__getlogin_r_alias, (char *__buf, size_t __buflen), getlogin_r) __nonnull ((1)); extern int __REDIRECT (__getlogin_r_chk_warn, (char *__buf, size_t __buflen, size_t __nreal), __getlogin_r_chk) __nonnull ((1)) __warnattr ("getlogin_r called with bigger buflen than " "size of destination buffer"); __fortify_function int getlogin_r (char *__buf, size_t __buflen) { return __glibc_fortify (getlogin_r, __buflen, sizeof (char), __glibc_objsize (__buf), __buf, __buflen); } #endif #if defined __USE_MISC || defined __USE_UNIX98 extern int __gethostname_chk (char *__buf, size_t __buflen, size_t __nreal) __THROW __nonnull ((1)) __attr_access ((__write_only__, 1, 2)); extern int __REDIRECT_NTH (__gethostname_alias, (char *__buf, size_t __buflen), gethostname) __nonnull ((1)) __attr_access ((__write_only__, 1, 2)); extern int __REDIRECT_NTH (__gethostname_chk_warn, (char *__buf, size_t __buflen, size_t __nreal), __gethostname_chk) __nonnull ((1)) __warnattr ("gethostname called with bigger buflen than " "size of destination buffer"); __fortify_function int __NTH (gethostname (char *__buf, size_t __buflen)) { return __glibc_fortify (gethostname, __buflen, sizeof (char), __glibc_objsize (__buf), __buf, __buflen); } #endif #if defined __USE_MISC || (defined __USE_XOPEN && !defined __USE_UNIX98) extern int __getdomainname_chk (char *__buf, size_t __buflen, size_t __nreal) __THROW __nonnull ((1)) __wur __attr_access ((__write_only__, 1, 2)); extern int __REDIRECT_NTH (__getdomainname_alias, (char *__buf, size_t __buflen), getdomainname) __nonnull ((1)) __wur __attr_access ((__write_only__, 1, 2)); extern int __REDIRECT_NTH (__getdomainname_chk_warn, (char *__buf, size_t __buflen, size_t __nreal), __getdomainname_chk) __nonnull ((1)) __wur __warnattr ("getdomainname called with bigger " "buflen than size of destination " "buffer"); __fortify_function int __NTH (getdomainname (char *__buf, size_t __buflen)) { return __glibc_fortify (getdomainname, __buflen, sizeof (char), __glibc_objsize (__buf), __buf, __buflen); } #endif mathcalls-helper-functions.h 0000644 00000003507 15125171642 0012161 0 ustar 00 /* Prototype declarations for math classification macros helpers. Copyright (C) 2017-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ /* Classify given number. */ __MATHDECL_ALIAS (int, __fpclassify,, (_Mdouble_ __value), fpclassify) __attribute__ ((__const__)); /* Test for negative number. */ __MATHDECL_ALIAS (int, __signbit,, (_Mdouble_ __value), signbit) __attribute__ ((__const__)); /* Return 0 if VALUE is finite or NaN, +1 if it is +Infinity, -1 if it is -Infinity. */ __MATHDECL_ALIAS (int, __isinf,, (_Mdouble_ __value), isinf) __attribute__ ((__const__)); /* Return nonzero if VALUE is finite and not NaN. Used by isfinite macro. */ __MATHDECL_ALIAS (int, __finite,, (_Mdouble_ __value), finite) __attribute__ ((__const__)); /* Return nonzero if VALUE is not a number. */ __MATHDECL_ALIAS (int, __isnan,, (_Mdouble_ __value), isnan) __attribute__ ((__const__)); /* Test equality. */ __MATHDECL_ALIAS (int, __iseqsig,, (_Mdouble_ __x, _Mdouble_ __y), iseqsig); /* Test for signaling NaN. */ __MATHDECL_ALIAS (int, __issignaling,, (_Mdouble_ __value), issignaling) __attribute__ ((__const__)); stdlib.h 0000644 00000013223 15125171642 0006203 0 ustar 00 /* Checking macros for stdlib functions. Copyright (C) 2005-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _STDLIB_H # error "Never include <bits/stdlib.h> directly; use <stdlib.h> instead." #endif extern char *__realpath_chk (const char *__restrict __name, char *__restrict __resolved, size_t __resolvedlen) __THROW __wur; extern char *__REDIRECT_NTH (__realpath_alias, (const char *__restrict __name, char *__restrict __resolved), realpath) __wur; extern char *__REDIRECT_NTH (__realpath_chk_warn, (const char *__restrict __name, char *__restrict __resolved, size_t __resolvedlen), __realpath_chk) __wur __warnattr ("second argument of realpath must be either NULL or at " "least PATH_MAX bytes long buffer"); __fortify_function __wur char * __NTH (realpath (const char *__restrict __name, char *__restrict __resolved)) { size_t sz = __glibc_objsize (__resolved); if (sz == (size_t) -1) return __realpath_alias (__name, __resolved); #if defined _LIBC_LIMITS_H_ && defined PATH_MAX if (__glibc_unsafe_len (PATH_MAX, sizeof (char), sz)) return __realpath_chk_warn (__name, __resolved, sz); #endif return __realpath_chk (__name, __resolved, sz); } extern int __ptsname_r_chk (int __fd, char *__buf, size_t __buflen, size_t __nreal) __THROW __nonnull ((2)) __attr_access ((__write_only__, 2, 3)); extern int __REDIRECT_NTH (__ptsname_r_alias, (int __fd, char *__buf, size_t __buflen), ptsname_r) __nonnull ((2)) __attr_access ((__write_only__, 2, 3)); extern int __REDIRECT_NTH (__ptsname_r_chk_warn, (int __fd, char *__buf, size_t __buflen, size_t __nreal), __ptsname_r_chk) __nonnull ((2)) __warnattr ("ptsname_r called with buflen bigger than " "size of buf"); __fortify_function int __NTH (ptsname_r (int __fd, char *__buf, size_t __buflen)) { return __glibc_fortify (ptsname_r, __buflen, sizeof (char), __glibc_objsize (__buf), __fd, __buf, __buflen); } extern int __wctomb_chk (char *__s, wchar_t __wchar, size_t __buflen) __THROW __wur; extern int __REDIRECT_NTH (__wctomb_alias, (char *__s, wchar_t __wchar), wctomb) __wur; __fortify_function __wur int __NTH (wctomb (char *__s, wchar_t __wchar)) { /* We would have to include <limits.h> to get a definition of MB_LEN_MAX. But this would only disturb the namespace. So we define our own version here. */ #define __STDLIB_MB_LEN_MAX 16 #if defined MB_LEN_MAX && MB_LEN_MAX != __STDLIB_MB_LEN_MAX # error "Assumed value of MB_LEN_MAX wrong" #endif if (__glibc_objsize (__s) != (size_t) -1 && __STDLIB_MB_LEN_MAX > __glibc_objsize (__s)) return __wctomb_chk (__s, __wchar, __glibc_objsize (__s)); return __wctomb_alias (__s, __wchar); } extern size_t __mbstowcs_chk (wchar_t *__restrict __dst, const char *__restrict __src, size_t __len, size_t __dstlen) __THROW __attr_access ((__write_only__, 1, 3)) __attr_access ((__read_only__, 2)); extern size_t __REDIRECT_NTH (__mbstowcs_nulldst, (wchar_t *__restrict __dst, const char *__restrict __src, size_t __len), mbstowcs) __attr_access ((__read_only__, 2)); extern size_t __REDIRECT_NTH (__mbstowcs_alias, (wchar_t *__restrict __dst, const char *__restrict __src, size_t __len), mbstowcs) __attr_access ((__write_only__, 1, 3)) __attr_access ((__read_only__, 2)); extern size_t __REDIRECT_NTH (__mbstowcs_chk_warn, (wchar_t *__restrict __dst, const char *__restrict __src, size_t __len, size_t __dstlen), __mbstowcs_chk) __warnattr ("mbstowcs called with dst buffer smaller than len " "* sizeof (wchar_t)"); __fortify_function size_t __NTH (mbstowcs (wchar_t *__restrict __dst, const char *__restrict __src, size_t __len)) { if (__builtin_constant_p (__dst == NULL) && __dst == NULL) return __mbstowcs_nulldst (__dst, __src, __len); else return __glibc_fortify_n (mbstowcs, __len, sizeof (wchar_t), __glibc_objsize (__dst), __dst, __src, __len); } extern size_t __wcstombs_chk (char *__restrict __dst, const wchar_t *__restrict __src, size_t __len, size_t __dstlen) __THROW __attr_access ((__write_only__, 1, 3)) __attr_access ((__read_only__, 2)); extern size_t __REDIRECT_NTH (__wcstombs_alias, (char *__restrict __dst, const wchar_t *__restrict __src, size_t __len), wcstombs) __attr_access ((__write_only__, 1, 3)) __attr_access ((__read_only__, 2)); extern size_t __REDIRECT_NTH (__wcstombs_chk_warn, (char *__restrict __dst, const wchar_t *__restrict __src, size_t __len, size_t __dstlen), __wcstombs_chk) __warnattr ("wcstombs called with dst buffer smaller than len"); __fortify_function size_t __NTH (wcstombs (char *__restrict __dst, const wchar_t *__restrict __src, size_t __len)) { return __glibc_fortify (wcstombs, __len, sizeof (char), __glibc_objsize (__dst), __dst, __src, __len); } signalfd.h 0000644 00000002053 15125171642 0006510 0 ustar 00 /* Copyright (C) 2007-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _SYS_SIGNALFD_H # error "Never use <bits/signalfd.h> directly; include <sys/signalfd.h> instead." #endif /* Flags for signalfd. */ enum { SFD_CLOEXEC = 02000000, #define SFD_CLOEXEC SFD_CLOEXEC SFD_NONBLOCK = 00004000 #define SFD_NONBLOCK SFD_NONBLOCK }; inet-fortified.h 0000644 00000003401 15125171642 0007627 0 ustar 00 /* Checking macros for inet functions. Copyright (C) 2025 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _BITS_INET_FORTIFIED_H #define _BITS_INET_FORTIFIED_H 1 #ifndef _ARPA_INET_H # error "Never include <bits/inet-fortified.h> directly; use <arpa/inet.h> instead." #endif #include <bits/inet-fortified-decl.h> __fortify_function const char * __NTH (inet_ntop (int __af, const void * __restrict __src, char *__restrict __dst, socklen_t __dst_size)) { return __glibc_fortify (inet_ntop, __dst_size, sizeof (char), __glibc_objsize (__dst), __af, __src, __dst, __dst_size); }; __fortify_function int __NTH (inet_pton (int __af, const char *__restrict __src, void * __restrict __dst)) { size_t __sz = 0; if (__af == AF_INET) __sz = sizeof (struct in_addr); else if (__af == AF_INET6) __sz = sizeof (struct in6_addr); else return __inet_pton_alias (__af, __src, __dst); return __glibc_fortify (inet_pton, __sz, sizeof (char), __glibc_objsize (__dst), __af, __src, __dst); }; #endif /* bits/inet-fortified.h. */ mqueue.h 0000644 00000002336 15125171642 0006226 0 ustar 00 /* Copyright (C) 2004-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _MQUEUE_H # error "Never use <bits/mqueue.h> directly; include <mqueue.h> instead." #endif #include <bits/types.h> typedef int mqd_t; struct mq_attr { __syscall_slong_t mq_flags; /* Message queue flags. */ __syscall_slong_t mq_maxmsg; /* Maximum number of messages. */ __syscall_slong_t mq_msgsize; /* Maximum message size. */ __syscall_slong_t mq_curmsgs; /* Number of messages currently queued. */ __syscall_slong_t __pad[4]; }; timex.h 0000644 00000014066 15125171642 0006056 0 ustar 00 /* Copyright (C) 1995-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _BITS_TIMEX_H #define _BITS_TIMEX_H 1 #include <bits/types.h> #include <bits/types/struct_timeval.h> /* These definitions from linux/timex.h as of 3.18. */ struct timex { # if defined __USE_TIME_BITS64 || (__TIMESIZE == 64 && __WORDSIZE == 32) unsigned int modes; /* mode selector */ int :32; /* pad */ long long offset; /* time offset (usec) */ long long freq; /* frequency offset (scaled ppm) */ long long maxerror; /* maximum error (usec) */ long long esterror; /* estimated error (usec) */ int status; /* clock command/status */ int :32; /* pad */ long long constant; /* pll time constant */ long long precision; /* clock precision (usec) (read only) */ long long tolerance; /* clock frequency tolerance (ppm) (ro) */ struct timeval time; /* (read only, except for ADJ_SETOFFSET) */ long long tick; /* (modified) usecs between clock ticks */ long long ppsfreq; /* pps frequency (scaled ppm) (ro) */ long long jitter; /* pps jitter (us) (ro) */ int shift; /* interval duration (s) (shift) (ro) */ int :32; /* pad */ long long stabil; /* pps stability (scaled ppm) (ro) */ long long jitcnt; /* jitter limit exceeded (ro) */ long long calcnt; /* calibration intervals (ro) */ long long errcnt; /* calibration errors (ro) */ long long stbcnt; /* stability limit exceeded (ro) */ int tai; /* TAI offset (ro) */ int :32; int :32; int :32; int :32; int :32; int :32; int :32; int :32; int :32; int :32; int :32; # else unsigned int modes; /* mode selector */ __syscall_slong_t offset; /* time offset (usec) */ __syscall_slong_t freq; /* frequency offset (scaled ppm) */ __syscall_slong_t maxerror; /* maximum error (usec) */ __syscall_slong_t esterror; /* estimated error (usec) */ int status; /* clock command/status */ __syscall_slong_t constant; /* pll time constant */ __syscall_slong_t precision; /* clock precision (usec) (ro) */ __syscall_slong_t tolerance; /* clock frequency tolerance (ppm) (ro) */ struct timeval time; /* (read only, except for ADJ_SETOFFSET) */ __syscall_slong_t tick; /* (modified) usecs between clock ticks */ __syscall_slong_t ppsfreq; /* pps frequency (scaled ppm) (ro) */ __syscall_slong_t jitter; /* pps jitter (us) (ro) */ int shift; /* interval duration (s) (shift) (ro) */ __syscall_slong_t stabil; /* pps stability (scaled ppm) (ro) */ __syscall_slong_t jitcnt; /* jitter limit exceeded (ro) */ __syscall_slong_t calcnt; /* calibration intervals (ro) */ __syscall_slong_t errcnt; /* calibration errors (ro) */ __syscall_slong_t stbcnt; /* stability limit exceeded (ro) */ int tai; /* TAI offset (ro) */ /* ??? */ int :32; int :32; int :32; int :32; int :32; int :32; int :32; int :32; int :32; int :32; int :32; # endif }; /* Mode codes (timex.mode) */ #define ADJ_OFFSET 0x0001 /* time offset */ #define ADJ_FREQUENCY 0x0002 /* frequency offset */ #define ADJ_MAXERROR 0x0004 /* maximum time error */ #define ADJ_ESTERROR 0x0008 /* estimated time error */ #define ADJ_STATUS 0x0010 /* clock status */ #define ADJ_TIMECONST 0x0020 /* pll time constant */ #define ADJ_TAI 0x0080 /* set TAI offset */ #define ADJ_SETOFFSET 0x0100 /* add 'time' to current time */ #define ADJ_MICRO 0x1000 /* select microsecond resolution */ #define ADJ_NANO 0x2000 /* select nanosecond resolution */ #define ADJ_TICK 0x4000 /* tick value */ #define ADJ_OFFSET_SINGLESHOT 0x8001 /* old-fashioned adjtime */ #define ADJ_OFFSET_SS_READ 0xa001 /* read-only adjtime */ /* xntp 3.4 compatibility names */ #define MOD_OFFSET ADJ_OFFSET #define MOD_FREQUENCY ADJ_FREQUENCY #define MOD_MAXERROR ADJ_MAXERROR #define MOD_ESTERROR ADJ_ESTERROR #define MOD_STATUS ADJ_STATUS #define MOD_TIMECONST ADJ_TIMECONST #define MOD_CLKB ADJ_TICK #define MOD_CLKA ADJ_OFFSET_SINGLESHOT /* 0x8000 in original */ #define MOD_TAI ADJ_TAI #define MOD_MICRO ADJ_MICRO #define MOD_NANO ADJ_NANO /* Status codes (timex.status) */ #define STA_PLL 0x0001 /* enable PLL updates (rw) */ #define STA_PPSFREQ 0x0002 /* enable PPS freq discipline (rw) */ #define STA_PPSTIME 0x0004 /* enable PPS time discipline (rw) */ #define STA_FLL 0x0008 /* select frequency-lock mode (rw) */ #define STA_INS 0x0010 /* insert leap (rw) */ #define STA_DEL 0x0020 /* delete leap (rw) */ #define STA_UNSYNC 0x0040 /* clock unsynchronized (rw) */ #define STA_FREQHOLD 0x0080 /* hold frequency (rw) */ #define STA_PPSSIGNAL 0x0100 /* PPS signal present (ro) */ #define STA_PPSJITTER 0x0200 /* PPS signal jitter exceeded (ro) */ #define STA_PPSWANDER 0x0400 /* PPS signal wander exceeded (ro) */ #define STA_PPSERROR 0x0800 /* PPS signal calibration error (ro) */ #define STA_CLOCKERR 0x1000 /* clock hardware fault (ro) */ #define STA_NANO 0x2000 /* resolution (0 = us, 1 = ns) (ro) */ #define STA_MODE 0x4000 /* mode (0 = PLL, 1 = FLL) (ro) */ #define STA_CLK 0x8000 /* clock source (0 = A, 1 = B) (ro) */ /* Read-only bits */ #define STA_RONLY (STA_PPSSIGNAL | STA_PPSJITTER | STA_PPSWANDER \ | STA_PPSERROR | STA_CLOCKERR | STA_NANO | STA_MODE | STA_CLK) #endif /* bits/timex.h */ stdlib-ldbl.h 0000644 00000003744 15125171642 0007125 0 ustar 00 /* -mlong-double-64 compatibility mode for <stdlib.h> functions. Copyright (C) 2006-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _STDLIB_H # error "Never include <bits/stdlib-ldbl.h> directly; use <stdlib.h> instead." #endif #ifdef __USE_ISOC99 # ifdef __LDBL_COMPAT __LDBL_REDIR1_DECL (strtold, strtod) # else __LDBL_REDIR1_DECL (strtold, __strtoieee128) # endif #endif #ifdef __USE_GNU # ifdef __LDBL_COMPAT __LDBL_REDIR1_DECL (strtold_l, strtod_l) # else __LDBL_REDIR1_DECL (strtold_l, __strtoieee128_l) # endif #endif #if __GLIBC_USE (IEC_60559_BFP_EXT_C2X) # ifdef __LDBL_COMPAT __LDBL_REDIR1_DECL (strfroml, strfromd) # else __LDBL_REDIR1_DECL (strfroml, __strfromieee128) # endif #endif #ifdef __USE_MISC # if defined __LDBL_COMPAT __LDBL_REDIR1_DECL (qecvt, ecvt) __LDBL_REDIR1_DECL (qfcvt, fcvt) __LDBL_REDIR1_DECL (qgcvt, gcvt) __LDBL_REDIR1_DECL (qecvt_r, ecvt_r) __LDBL_REDIR1_DECL (qfcvt_r, fcvt_r) # elif __LDOUBLE_REDIRECTS_TO_FLOAT128_ABI == 1 __LDBL_REDIR1_DECL (qecvt, __qecvtieee128) __LDBL_REDIR1_DECL (qfcvt, __qfcvtieee128) __LDBL_REDIR1_DECL (qgcvt, __qgcvtieee128) __LDBL_REDIR1_DECL (qecvt_r, __qecvtieee128_r) __LDBL_REDIR1_DECL (qfcvt_r, __qfcvtieee128_r) # else # error bits/stdlib-ldbl.h included when no ldbl redirections are required. # endif #endif termios-tcflow.h 0000644 00000002046 15125171642 0007701 0 ustar 00 /* termios tcflag symbolic contants definitions. Linux/generic version. Copyright (C) 2019-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library. If not, see <https://www.gnu.org/licenses/>. */ #ifndef _TERMIOS_H # error "Never include <bits/termios-tcflow.h> directly; use <termios.h> instead." #endif /* tcsetattr uses these. */ #define TCSANOW 0 #define TCSADRAIN 1 #define TCSAFLUSH 2 types.h 0000644 00000021146 15125171642 0006071 0 ustar 00 /* bits/types.h -- definitions of __*_t types underlying *_t types. Copyright (C) 2002-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ /* * Never include this file directly; use <sys/types.h> instead. */ #ifndef _BITS_TYPES_H #define _BITS_TYPES_H 1 #include <features.h> #include <bits/wordsize.h> #include <bits/timesize.h> /* Convenience types. */ typedef unsigned char __u_char; typedef unsigned short int __u_short; typedef unsigned int __u_int; typedef unsigned long int __u_long; /* Fixed-size types, underlying types depend on word size and compiler. */ typedef signed char __int8_t; typedef unsigned char __uint8_t; typedef signed short int __int16_t; typedef unsigned short int __uint16_t; typedef signed int __int32_t; typedef unsigned int __uint32_t; #if __WORDSIZE == 64 typedef signed long int __int64_t; typedef unsigned long int __uint64_t; #else __extension__ typedef signed long long int __int64_t; __extension__ typedef unsigned long long int __uint64_t; #endif /* Smallest types with at least a given width. */ typedef __int8_t __int_least8_t; typedef __uint8_t __uint_least8_t; typedef __int16_t __int_least16_t; typedef __uint16_t __uint_least16_t; typedef __int32_t __int_least32_t; typedef __uint32_t __uint_least32_t; typedef __int64_t __int_least64_t; typedef __uint64_t __uint_least64_t; /* quad_t is also 64 bits. */ #if __WORDSIZE == 64 typedef long int __quad_t; typedef unsigned long int __u_quad_t; #else __extension__ typedef long long int __quad_t; __extension__ typedef unsigned long long int __u_quad_t; #endif /* Largest integral types. */ #if __WORDSIZE == 64 typedef long int __intmax_t; typedef unsigned long int __uintmax_t; #else __extension__ typedef long long int __intmax_t; __extension__ typedef unsigned long long int __uintmax_t; #endif /* The machine-dependent file <bits/typesizes.h> defines __*_T_TYPE macros for each of the OS types we define below. The definitions of those macros must use the following macros for underlying types. We define __S<SIZE>_TYPE and __U<SIZE>_TYPE for the signed and unsigned variants of each of the following integer types on this machine. 16 -- "natural" 16-bit type (always short) 32 -- "natural" 32-bit type (always int) 64 -- "natural" 64-bit type (long or long long) LONG32 -- 32-bit type, traditionally long QUAD -- 64-bit type, traditionally long long WORD -- natural type of __WORDSIZE bits (int or long) LONGWORD -- type of __WORDSIZE bits, traditionally long We distinguish WORD/LONGWORD, 32/LONG32, and 64/QUAD so that the conventional uses of `long' or `long long' type modifiers match the types we define, even when a less-adorned type would be the same size. This matters for (somewhat) portably writing printf/scanf formats for these types, where using the appropriate l or ll format modifiers can make the typedefs and the formats match up across all GNU platforms. If we used `long' when it's 64 bits where `long long' is expected, then the compiler would warn about the formats not matching the argument types, and the programmer changing them to shut up the compiler would break the program's portability. Here we assume what is presently the case in all the GCC configurations we support: long long is always 64 bits, long is always word/address size, and int is always 32 bits. */ #define __S16_TYPE short int #define __U16_TYPE unsigned short int #define __S32_TYPE int #define __U32_TYPE unsigned int #define __SLONGWORD_TYPE long int #define __ULONGWORD_TYPE unsigned long int #if __WORDSIZE == 32 # define __SQUAD_TYPE __int64_t # define __UQUAD_TYPE __uint64_t # define __SWORD_TYPE int # define __UWORD_TYPE unsigned int # define __SLONG32_TYPE long int # define __ULONG32_TYPE unsigned long int # define __S64_TYPE __int64_t # define __U64_TYPE __uint64_t /* We want __extension__ before typedef's that use nonstandard base types such as `long long' in C89 mode. */ # define __STD_TYPE __extension__ typedef #elif __WORDSIZE == 64 # define __SQUAD_TYPE long int # define __UQUAD_TYPE unsigned long int # define __SWORD_TYPE long int # define __UWORD_TYPE unsigned long int # define __SLONG32_TYPE int # define __ULONG32_TYPE unsigned int # define __S64_TYPE long int # define __U64_TYPE unsigned long int /* No need to mark the typedef with __extension__. */ # define __STD_TYPE typedef #else # error #endif #include <bits/typesizes.h> /* Defines __*_T_TYPE macros. */ #include <bits/time64.h> /* Defines __TIME*_T_TYPE macros. */ __STD_TYPE __DEV_T_TYPE __dev_t; /* Type of device numbers. */ __STD_TYPE __UID_T_TYPE __uid_t; /* Type of user identifications. */ __STD_TYPE __GID_T_TYPE __gid_t; /* Type of group identifications. */ __STD_TYPE __INO_T_TYPE __ino_t; /* Type of file serial numbers. */ __STD_TYPE __INO64_T_TYPE __ino64_t; /* Type of file serial numbers (LFS).*/ __STD_TYPE __MODE_T_TYPE __mode_t; /* Type of file attribute bitmasks. */ __STD_TYPE __NLINK_T_TYPE __nlink_t; /* Type of file link counts. */ __STD_TYPE __OFF_T_TYPE __off_t; /* Type of file sizes and offsets. */ __STD_TYPE __OFF64_T_TYPE __off64_t; /* Type of file sizes and offsets (LFS). */ __STD_TYPE __PID_T_TYPE __pid_t; /* Type of process identifications. */ __STD_TYPE __FSID_T_TYPE __fsid_t; /* Type of file system IDs. */ __STD_TYPE __CLOCK_T_TYPE __clock_t; /* Type of CPU usage counts. */ __STD_TYPE __RLIM_T_TYPE __rlim_t; /* Type for resource measurement. */ __STD_TYPE __RLIM64_T_TYPE __rlim64_t; /* Type for resource measurement (LFS). */ __STD_TYPE __ID_T_TYPE __id_t; /* General type for IDs. */ __STD_TYPE __TIME_T_TYPE __time_t; /* Seconds since the Epoch. */ __STD_TYPE __USECONDS_T_TYPE __useconds_t; /* Count of microseconds. */ __STD_TYPE __SUSECONDS_T_TYPE __suseconds_t; /* Signed count of microseconds. */ __STD_TYPE __SUSECONDS64_T_TYPE __suseconds64_t; __STD_TYPE __DADDR_T_TYPE __daddr_t; /* The type of a disk address. */ __STD_TYPE __KEY_T_TYPE __key_t; /* Type of an IPC key. */ /* Clock ID used in clock and timer functions. */ __STD_TYPE __CLOCKID_T_TYPE __clockid_t; /* Timer ID returned by `timer_create'. */ __STD_TYPE __TIMER_T_TYPE __timer_t; /* Type to represent block size. */ __STD_TYPE __BLKSIZE_T_TYPE __blksize_t; /* Types from the Large File Support interface. */ /* Type to count number of disk blocks. */ __STD_TYPE __BLKCNT_T_TYPE __blkcnt_t; __STD_TYPE __BLKCNT64_T_TYPE __blkcnt64_t; /* Type to count file system blocks. */ __STD_TYPE __FSBLKCNT_T_TYPE __fsblkcnt_t; __STD_TYPE __FSBLKCNT64_T_TYPE __fsblkcnt64_t; /* Type to count file system nodes. */ __STD_TYPE __FSFILCNT_T_TYPE __fsfilcnt_t; __STD_TYPE __FSFILCNT64_T_TYPE __fsfilcnt64_t; /* Type of miscellaneous file system fields. */ __STD_TYPE __FSWORD_T_TYPE __fsword_t; __STD_TYPE __SSIZE_T_TYPE __ssize_t; /* Type of a byte count, or error. */ /* Signed long type used in system calls. */ __STD_TYPE __SYSCALL_SLONG_TYPE __syscall_slong_t; /* Unsigned long type used in system calls. */ __STD_TYPE __SYSCALL_ULONG_TYPE __syscall_ulong_t; /* These few don't really vary by system, they always correspond to one of the other defined types. */ typedef __off64_t __loff_t; /* Type of file sizes and offsets (LFS). */ typedef char *__caddr_t; /* Duplicates info from stdint.h but this is used in unistd.h. */ __STD_TYPE __SWORD_TYPE __intptr_t; /* Duplicate info from sys/socket.h. */ __STD_TYPE __U32_TYPE __socklen_t; /* C99: An integer type that can be accessed as an atomic entity, even in the presence of asynchronous interrupts. It is not currently necessary for this to be machine-specific. */ typedef int __sig_atomic_t; /* Seconds since the Epoch, visible to user code when time_t is too narrow only for consistency with the old way of widening too-narrow types. User code should never use __time64_t. */ #if __TIMESIZE == 64 && defined __LIBC # define __time64_t __time_t #elif __TIMESIZE != 64 __STD_TYPE __TIME64_T_TYPE __time64_t; #endif #undef __STD_TYPE #endif /* bits/types.h */ param.h 0000644 00000002631 15125171642 0006023 0 ustar 00 /* Old-style Unix parameters and limits. Linux version. Copyright (C) 1995-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _SYS_PARAM_H # error "Never use <bits/param.h> directly; include <sys/param.h> instead." #endif #ifndef ARG_MAX # define __undef_ARG_MAX #endif #include <linux/limits.h> #include <linux/param.h> /* The kernel headers define ARG_MAX. The value is wrong, though. */ #ifdef __undef_ARG_MAX # undef ARG_MAX # undef __undef_ARG_MAX #endif #define MAXSYMLINKS 20 /* The following are not really correct but it is a value we used for a long time and which seems to be usable. People should not use NOFILE and NCARGS anyway. */ #define NOFILE 256 #define NCARGS 131072 inotify.h 0000644 00000002070 15125171642 0006401 0 ustar 00 /* Copyright (C) 2005-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _SYS_INOTIFY_H # error "Never use <bits/inotify.h> directly; include <sys/inotify.h> instead." #endif /* Flags for the parameter of inotify_init1. */ enum { IN_CLOEXEC = 02000000, #define IN_CLOEXEC IN_CLOEXEC IN_NONBLOCK = 00004000 #define IN_NONBLOCK IN_NONBLOCK }; statvfs.h 0000644 00000006537 15125171642 0006426 0 ustar 00 /* Copyright (C) 1997-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _SYS_STATVFS_H # error "Never include <bits/statvfs.h> directly; use <sys/statvfs.h> instead." #endif #include <bits/types.h> /* For __fsblkcnt_t and __fsfilcnt_t. */ #if (__WORDSIZE == 32 \ && (!defined __SYSCALL_WORDSIZE || __SYSCALL_WORDSIZE == 32)) #define _STATVFSBUF_F_UNUSED #endif struct statvfs { unsigned long int f_bsize; unsigned long int f_frsize; #ifndef __USE_FILE_OFFSET64 __fsblkcnt_t f_blocks; __fsblkcnt_t f_bfree; __fsblkcnt_t f_bavail; __fsfilcnt_t f_files; __fsfilcnt_t f_ffree; __fsfilcnt_t f_favail; #else __fsblkcnt64_t f_blocks; __fsblkcnt64_t f_bfree; __fsblkcnt64_t f_bavail; __fsfilcnt64_t f_files; __fsfilcnt64_t f_ffree; __fsfilcnt64_t f_favail; #endif unsigned long int f_fsid; #ifdef _STATVFSBUF_F_UNUSED int __f_unused; #endif unsigned long int f_flag; unsigned long int f_namemax; int __f_spare[6]; }; #ifdef __USE_LARGEFILE64 struct statvfs64 { unsigned long int f_bsize; unsigned long int f_frsize; __fsblkcnt64_t f_blocks; __fsblkcnt64_t f_bfree; __fsblkcnt64_t f_bavail; __fsfilcnt64_t f_files; __fsfilcnt64_t f_ffree; __fsfilcnt64_t f_favail; unsigned long int f_fsid; #ifdef _STATVFSBUF_F_UNUSED int __f_unused; #endif unsigned long int f_flag; unsigned long int f_namemax; int __f_spare[6]; }; #endif /* Definitions for the flag in `f_flag'. These definitions should be kept in sync with the definitions in <sys/mount.h>. */ enum { ST_RDONLY = 1, /* Mount read-only. */ #define ST_RDONLY ST_RDONLY ST_NOSUID = 2 /* Ignore suid and sgid bits. */ #define ST_NOSUID ST_NOSUID #ifdef __USE_GNU , ST_NODEV = 4, /* Disallow access to device special files. */ # define ST_NODEV ST_NODEV ST_NOEXEC = 8, /* Disallow program execution. */ # define ST_NOEXEC ST_NOEXEC ST_SYNCHRONOUS = 16, /* Writes are synced at once. */ # define ST_SYNCHRONOUS ST_SYNCHRONOUS ST_MANDLOCK = 64, /* Allow mandatory locks on an FS. */ # define ST_MANDLOCK ST_MANDLOCK ST_WRITE = 128, /* Write on file/directory/symlink. */ # define ST_WRITE ST_WRITE ST_APPEND = 256, /* Append-only file. */ # define ST_APPEND ST_APPEND ST_IMMUTABLE = 512, /* Immutable file. */ # define ST_IMMUTABLE ST_IMMUTABLE ST_NOATIME = 1024, /* Do not update access times. */ # define ST_NOATIME ST_NOATIME ST_NODIRATIME = 2048, /* Do not update directory access times. */ # define ST_NODIRATIME ST_NODIRATIME ST_RELATIME = 4096 /* Update atime relative to mtime/ctime. */ # define ST_RELATIME ST_RELATIME #endif /* Use GNU. */ }; long-double.h 0000644 00000001712 15125171642 0007131 0 ustar 00 /* Properties of long double type. ldbl-96 version. Copyright (C) 2016-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ /* long double is distinct from double, so there is nothing to define here. */ #define __LDOUBLE_REDIRECTS_TO_FLOAT128_ABI 0 poll.h 0000644 00000004034 15125171642 0005670 0 ustar 00 /* Copyright (C) 1997-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _SYS_POLL_H # error "Never use <bits/poll.h> directly; include <sys/poll.h> instead." #endif /* Event types that can be polled for. These bits may be set in `events' to indicate the interesting event types; they will appear in `revents' to indicate the status of the file descriptor. */ #define POLLIN 0x001 /* There is data to read. */ #define POLLPRI 0x002 /* There is urgent data to read. */ #define POLLOUT 0x004 /* Writing now will not block. */ #if defined __USE_XOPEN || defined __USE_XOPEN2K8 /* These values are defined in XPG4.2. */ # define POLLRDNORM 0x040 /* Normal data may be read. */ # define POLLRDBAND 0x080 /* Priority data may be read. */ # define POLLWRNORM 0x100 /* Writing now will not block. */ # define POLLWRBAND 0x200 /* Priority data may be written. */ #endif #ifdef __USE_GNU /* These are extensions for Linux. */ # define POLLMSG 0x400 # define POLLREMOVE 0x1000 # define POLLRDHUP 0x2000 #endif /* Event types always implicitly polled for. These bits need not be set in `events', but they will appear in `revents' to indicate the status of the file descriptor. */ #define POLLERR 0x008 /* Error condition. */ #define POLLHUP 0x010 /* Hung up. */ #define POLLNVAL 0x020 /* Invalid polling request. */ termios-c_cc.h 0000644 00000002377 15125171642 0007301 0 ustar 00 /* termios c_cc symbolic constant definitions. Linux/generic version. Copyright (C) 2019-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library. If not, see <https://www.gnu.org/licenses/>. */ #ifndef _TERMIOS_H # error "Never include <bits/termios_c_cc.h> directly; use <termios.h> instead." #endif /* c_cc characters */ #define VINTR 0 #define VQUIT 1 #define VERASE 2 #define VKILL 3 #define VEOF 4 #define VTIME 5 #define VMIN 6 #define VSWTC 7 #define VSTART 8 #define VSTOP 9 #define VSUSP 10 #define VEOL 11 #define VREPRINT 12 #define VDISCARD 13 #define VWERASE 14 #define VLNEXT 15 #define VEOL2 16 elfclass.h 0000644 00000000652 15125171642 0006520 0 ustar 00 /* This file specifies the native word size of the machine, which indicates the ELF file class used for executables and shared objects on this machine. */ #ifndef _LINK_H # error "Never use <bits/elfclass.h> directly; include <link.h> instead." #endif #include <bits/wordsize.h> #define __ELF_NATIVE_CLASS __WORDSIZE /* The entries in the .hash table always have a size of 32 bits. */ typedef uint32_t Elf_Symndx; indirect-return.h 0000644 00000003067 15125171642 0010045 0 ustar 00 /* Definition of __INDIRECT_RETURN. x86 version. Copyright (C) 2018-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _UCONTEXT_H # error "Never include <bits/indirect-return.h> directly; use <ucontext.h> instead." #endif /* On x86, swapcontext returns via indirect branch when the shadow stack is enabled. Define __INDIRECT_RETURN to indicate whether swapcontext returns via indirect branch. */ #if defined __CET__ && (__CET__ & 2) != 0 # if __glibc_has_attribute (__indirect_return__) # define __INDIRECT_RETURN __attribute__ ((__indirect_return__)) # else /* Newer compilers provide the indirect_return attribute, but without it we can use returns_twice to affect the optimizer in the same way and avoid unsafe optimizations. */ # define __INDIRECT_RETURN __attribute__ ((__returns_twice__)) # endif #else # define __INDIRECT_RETURN #endif fcntl2.h 0000644 00000012707 15125171642 0006120 0 ustar 00 /* Checking macros for fcntl functions. Copyright (C) 2007-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _FCNTL_H # error "Never include <bits/fcntl2.h> directly; use <fcntl.h> instead." #endif /* Check that calls to open and openat with O_CREAT or O_TMPFILE set have an appropriate third/fourth parameter. */ #ifndef __USE_FILE_OFFSET64 extern int __open_2 (const char *__path, int __oflag) __nonnull ((1)); extern int __REDIRECT (__open_alias, (const char *__path, int __oflag, ...), open) __nonnull ((1)); #else extern int __REDIRECT (__open_2, (const char *__path, int __oflag), __open64_2) __nonnull ((1)); extern int __REDIRECT (__open_alias, (const char *__path, int __oflag, ...), open64) __nonnull ((1)); #endif __errordecl (__open_too_many_args, "open can be called either with 2 or 3 arguments, not more"); __errordecl (__open_missing_mode, "open with O_CREAT or O_TMPFILE in second argument needs 3 arguments"); __fortify_function int open (const char *__path, int __oflag, ...) { if (__va_arg_pack_len () > 1) __open_too_many_args (); if (__builtin_constant_p (__oflag)) { if (__OPEN_NEEDS_MODE (__oflag) && __va_arg_pack_len () < 1) { __open_missing_mode (); return __open_2 (__path, __oflag); } return __open_alias (__path, __oflag, __va_arg_pack ()); } if (__va_arg_pack_len () < 1) return __open_2 (__path, __oflag); return __open_alias (__path, __oflag, __va_arg_pack ()); } #ifdef __USE_LARGEFILE64 extern int __open64_2 (const char *__path, int __oflag) __nonnull ((1)); extern int __REDIRECT (__open64_alias, (const char *__path, int __oflag, ...), open64) __nonnull ((1)); __errordecl (__open64_too_many_args, "open64 can be called either with 2 or 3 arguments, not more"); __errordecl (__open64_missing_mode, "open64 with O_CREAT or O_TMPFILE in second argument needs 3 arguments"); __fortify_function int open64 (const char *__path, int __oflag, ...) { if (__va_arg_pack_len () > 1) __open64_too_many_args (); if (__builtin_constant_p (__oflag)) { if (__OPEN_NEEDS_MODE (__oflag) && __va_arg_pack_len () < 1) { __open64_missing_mode (); return __open64_2 (__path, __oflag); } return __open64_alias (__path, __oflag, __va_arg_pack ()); } if (__va_arg_pack_len () < 1) return __open64_2 (__path, __oflag); return __open64_alias (__path, __oflag, __va_arg_pack ()); } #endif #ifdef __USE_ATFILE # ifndef __USE_FILE_OFFSET64 extern int __openat_2 (int __fd, const char *__path, int __oflag) __nonnull ((2)); extern int __REDIRECT (__openat_alias, (int __fd, const char *__path, int __oflag, ...), openat) __nonnull ((2)); # else extern int __REDIRECT (__openat_2, (int __fd, const char *__path, int __oflag), __openat64_2) __nonnull ((2)); extern int __REDIRECT (__openat_alias, (int __fd, const char *__path, int __oflag, ...), openat64) __nonnull ((2)); # endif __errordecl (__openat_too_many_args, "openat can be called either with 3 or 4 arguments, not more"); __errordecl (__openat_missing_mode, "openat with O_CREAT or O_TMPFILE in third argument needs 4 arguments"); __fortify_function int openat (int __fd, const char *__path, int __oflag, ...) { if (__va_arg_pack_len () > 1) __openat_too_many_args (); if (__builtin_constant_p (__oflag)) { if (__OPEN_NEEDS_MODE (__oflag) && __va_arg_pack_len () < 1) { __openat_missing_mode (); return __openat_2 (__fd, __path, __oflag); } return __openat_alias (__fd, __path, __oflag, __va_arg_pack ()); } if (__va_arg_pack_len () < 1) return __openat_2 (__fd, __path, __oflag); return __openat_alias (__fd, __path, __oflag, __va_arg_pack ()); } # ifdef __USE_LARGEFILE64 extern int __openat64_2 (int __fd, const char *__path, int __oflag) __nonnull ((2)); extern int __REDIRECT (__openat64_alias, (int __fd, const char *__path, int __oflag, ...), openat64) __nonnull ((2)); __errordecl (__openat64_too_many_args, "openat64 can be called either with 3 or 4 arguments, not more"); __errordecl (__openat64_missing_mode, "openat64 with O_CREAT or O_TMPFILE in third argument needs 4 arguments"); __fortify_function int openat64 (int __fd, const char *__path, int __oflag, ...) { if (__va_arg_pack_len () > 1) __openat64_too_many_args (); if (__builtin_constant_p (__oflag)) { if (__OPEN_NEEDS_MODE (__oflag) && __va_arg_pack_len () < 1) { __openat64_missing_mode (); return __openat64_2 (__fd, __path, __oflag); } return __openat64_alias (__fd, __path, __oflag, __va_arg_pack ()); } if (__va_arg_pack_len () < 1) return __openat64_2 (__fd, __path, __oflag); return __openat64_alias (__fd, __path, __oflag, __va_arg_pack ()); } # endif #endif errno.h 0000644 00000002622 15125171642 0006050 0 ustar 00 /* Error constants. Linux specific version. Copyright (C) 1996-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _BITS_ERRNO_H #define _BITS_ERRNO_H 1 #if !defined _ERRNO_H # error "Never include <bits/errno.h> directly; use <errno.h> instead." #endif # include <linux/errno.h> /* Older Linux headers do not define these constants. */ # ifndef ENOTSUP # define ENOTSUP EOPNOTSUPP # endif # ifndef ECANCELED # define ECANCELED 125 # endif # ifndef EOWNERDEAD # define EOWNERDEAD 130 # endif #ifndef ENOTRECOVERABLE # define ENOTRECOVERABLE 131 # endif # ifndef ERFKILL # define ERFKILL 132 # endif # ifndef EHWPOISON # define EHWPOISON 133 # endif #endif /* bits/errno.h. */ utmp.h 0000644 00000007743 15125171642 0005721 0 ustar 00 /* The `struct utmp' type, describing entries in the utmp file. Copyright (C) 1993-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _UTMP_H # error "Never include <bits/utmp.h> directly; use <utmp.h> instead." #endif #include <paths.h> #include <sys/time.h> #include <sys/types.h> #include <bits/wordsize.h> #define UT_LINESIZE 32 #define UT_NAMESIZE 32 #define UT_HOSTSIZE 256 /* The structure describing an entry in the database of previous logins. */ struct lastlog { #if __WORDSIZE_TIME64_COMPAT32 int32_t ll_time; #else __time_t ll_time; #endif char ll_line[UT_LINESIZE]; char ll_host[UT_HOSTSIZE]; }; /* The structure describing the status of a terminated process. This type is used in `struct utmp' below. */ struct exit_status { short int e_termination; /* Process termination status. */ short int e_exit; /* Process exit status. */ }; /* The structure describing an entry in the user accounting database. */ struct utmp { short int ut_type; /* Type of login. */ pid_t ut_pid; /* Process ID of login process. */ char ut_line[UT_LINESIZE] __attribute_nonstring__; /* Devicename. */ char ut_id[4] __attribute_nonstring__; /* Inittab ID. */ char ut_user[UT_NAMESIZE] __attribute_nonstring__; /* Username. */ char ut_host[UT_HOSTSIZE] __attribute_nonstring__; /* Hostname for remote login. */ struct exit_status ut_exit; /* Exit status of a process marked as DEAD_PROCESS. */ /* The ut_session and ut_tv fields must be the same size when compiled 32- and 64-bit. This allows data files and shared memory to be shared between 32- and 64-bit applications. */ #if __WORDSIZE_TIME64_COMPAT32 int32_t ut_session; /* Session ID, used for windowing. */ struct { int32_t tv_sec; /* Seconds. */ int32_t tv_usec; /* Microseconds. */ } ut_tv; /* Time entry was made. */ #else long int ut_session; /* Session ID, used for windowing. */ struct timeval ut_tv; /* Time entry was made. */ #endif int32_t ut_addr_v6[4]; /* Internet address of remote host. */ char __glibc_reserved[20]; /* Reserved for future use. */ }; /* Backwards compatibility hacks. */ #define ut_name ut_user #ifndef _NO_UT_TIME /* We have a problem here: `ut_time' is also used otherwise. Define _NO_UT_TIME if the compiler complains. */ # define ut_time ut_tv.tv_sec #endif #define ut_xtime ut_tv.tv_sec #define ut_addr ut_addr_v6[0] /* Values for the `ut_type' field of a `struct utmp'. */ #define EMPTY 0 /* No valid user accounting information. */ #define RUN_LVL 1 /* The system's runlevel. */ #define BOOT_TIME 2 /* Time of system boot. */ #define NEW_TIME 3 /* Time after system clock changed. */ #define OLD_TIME 4 /* Time when system clock changed. */ #define INIT_PROCESS 5 /* Process spawned by the init process. */ #define LOGIN_PROCESS 6 /* Session leader of a logged in user. */ #define USER_PROCESS 7 /* Normal process. */ #define DEAD_PROCESS 8 /* Terminated process. */ #define ACCOUNTING 9 /* Old Linux name for the EMPTY type. */ #define UT_UNKNOWN EMPTY /* Tell the user that we have a modern system with UT_HOST, UT_PID, UT_TYPE, UT_ID and UT_TV fields. */ #define _HAVE_UT_TYPE 1 #define _HAVE_UT_PID 1 #define _HAVE_UT_ID 1 #define _HAVE_UT_TV 1 #define _HAVE_UT_HOST 1 argp-ldbl.h 0000644 00000001762 15125171642 0006573 0 ustar 00 /* Redirections for argp functions for -mlong-double-64. Copyright (C) 2019-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _ARGP_H # error "Never include <bits/argp-ldbl.h> directly; use <argp.h> instead." #endif __LDBL_REDIR_DECL (argp_error) __LDBL_REDIR_DECL (argp_failure) poll2.h 0000644 00000005152 15125171642 0005754 0 ustar 00 /* Checking macros for poll functions. Copyright (C) 2012-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _SYS_POLL_H # error "Never include <bits/poll2.h> directly; use <sys/poll.h> instead." #endif __BEGIN_DECLS extern int __REDIRECT (__poll_alias, (struct pollfd *__fds, nfds_t __nfds, int __timeout), poll); extern int __poll_chk (struct pollfd *__fds, nfds_t __nfds, int __timeout, __SIZE_TYPE__ __fdslen) __attr_access ((__write_only__, 1, 2)); extern int __REDIRECT (__poll_chk_warn, (struct pollfd *__fds, nfds_t __nfds, int __timeout, __SIZE_TYPE__ __fdslen), __poll_chk) __warnattr ("poll called with fds buffer too small file nfds entries"); __fortify_function __fortified_attr_access (__write_only__, 1, 2) int poll (struct pollfd *__fds, nfds_t __nfds, int __timeout) { return __glibc_fortify (poll, __nfds, sizeof (*__fds), __glibc_objsize (__fds), __fds, __nfds, __timeout); } #ifdef __USE_GNU extern int __REDIRECT (__ppoll_alias, (struct pollfd *__fds, nfds_t __nfds, const struct timespec *__timeout, const __sigset_t *__ss), ppoll); extern int __ppoll_chk (struct pollfd *__fds, nfds_t __nfds, const struct timespec *__timeout, const __sigset_t *__ss, __SIZE_TYPE__ __fdslen) __attr_access ((__write_only__, 1, 2)); extern int __REDIRECT (__ppoll_chk_warn, (struct pollfd *__fds, nfds_t __nfds, const struct timespec *__timeout, const __sigset_t *__ss, __SIZE_TYPE__ __fdslen), __ppoll_chk) __warnattr ("ppoll called with fds buffer too small file nfds entries"); __fortify_function __fortified_attr_access (__write_only__, 1, 2) int ppoll (struct pollfd *__fds, nfds_t __nfds, const struct timespec *__timeout, const __sigset_t *__ss) { return __glibc_fortify (ppoll, __nfds, sizeof (*__fds), __glibc_objsize (__fds), __fds, __nfds, __timeout, __ss); } #endif __END_DECLS pthreadtypes-arch.h 0000644 00000003456 15125171642 0010360 0 ustar 00 /* Copyright (C) 2002-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _BITS_PTHREADTYPES_ARCH_H #define _BITS_PTHREADTYPES_ARCH_H 1 #include <bits/wordsize.h> #ifdef __x86_64__ # if __WORDSIZE == 64 # define __SIZEOF_PTHREAD_MUTEX_T 40 # define __SIZEOF_PTHREAD_ATTR_T 56 # define __SIZEOF_PTHREAD_RWLOCK_T 56 # define __SIZEOF_PTHREAD_BARRIER_T 32 # else # define __SIZEOF_PTHREAD_MUTEX_T 32 # define __SIZEOF_PTHREAD_ATTR_T 32 # define __SIZEOF_PTHREAD_RWLOCK_T 44 # define __SIZEOF_PTHREAD_BARRIER_T 20 # endif #else # define __SIZEOF_PTHREAD_MUTEX_T 24 # define __SIZEOF_PTHREAD_ATTR_T 36 # define __SIZEOF_PTHREAD_RWLOCK_T 32 # define __SIZEOF_PTHREAD_BARRIER_T 20 #endif #define __SIZEOF_PTHREAD_MUTEXATTR_T 4 #define __SIZEOF_PTHREAD_COND_T 48 #define __SIZEOF_PTHREAD_CONDATTR_T 4 #define __SIZEOF_PTHREAD_RWLOCKATTR_T 8 #define __SIZEOF_PTHREAD_BARRIERATTR_T 4 #define __LOCK_ALIGNMENT #define __ONCE_ALIGNMENT #ifndef __x86_64__ /* Extra attributes for the cleanup functions. */ # define __cleanup_fct_attribute __attribute__ ((__regparm__ (1))) #endif #endif /* bits/pthreadtypes.h */ uio_lim.h 0000644 00000002551 15125171642 0006361 0 ustar 00 /* Implementation limits related to sys/uio.h - Linux version. Copyright (C) 2017-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _BITS_UIO_LIM_H #define _BITS_UIO_LIM_H 1 /* Maximum length of the 'struct iovec' array in a single call to readv or writev. This macro has different values in different kernel versions. The latest versions of the kernel use 1024 and this is good choice. Since the C library implementation of readv/writev is able to emulate the functionality even if the currently running kernel does not support this large value the readv/writev call will not fail because of this. */ #define __IOV_MAX 1024 #endif cmathcalls.h 0000644 00000010053 15125171642 0007033 0 ustar 00 /* Prototype declarations for complex math functions; helper file for <complex.h>. Copyright (C) 1997-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ /* NOTE: Because of the special way this file is used by <complex.h>, this file must NOT be protected from multiple inclusion as header files usually are. This file provides prototype declarations for the math functions. Most functions are declared using the macro: __MATHCALL (NAME, (ARGS...)); This means there is a function `NAME' returning `double' and a function `NAMEf' returning `float'. Each place `_Mdouble_' appears in the prototype, that is actually `double' in the prototype for `NAME' and `float' in the prototype for `NAMEf'. Reentrant variant functions are called `NAME_r' and `NAMEf_r'. Functions returning other types like `int' are declared using the macro: __MATHDECL (TYPE, NAME, (ARGS...)); This is just like __MATHCALL but for a function returning `TYPE' instead of `_Mdouble_'. In all of these cases, there is still both a `NAME' and a `NAMEf' that takes `float' arguments. */ #ifndef _COMPLEX_H #error "Never use <bits/cmathcalls.h> directly; include <complex.h> instead." #endif #ifndef _Mdouble_complex_ # define _Mdouble_complex_ _Mdouble_ _Complex #endif /* Trigonometric functions. */ /* Arc cosine of Z. */ __MATHCALL (cacos, (_Mdouble_complex_ __z)); /* Arc sine of Z. */ __MATHCALL (casin, (_Mdouble_complex_ __z)); /* Arc tangent of Z. */ __MATHCALL (catan, (_Mdouble_complex_ __z)); /* Cosine of Z. */ __MATHCALL (ccos, (_Mdouble_complex_ __z)); /* Sine of Z. */ __MATHCALL (csin, (_Mdouble_complex_ __z)); /* Tangent of Z. */ __MATHCALL (ctan, (_Mdouble_complex_ __z)); /* Hyperbolic functions. */ /* Hyperbolic arc cosine of Z. */ __MATHCALL (cacosh, (_Mdouble_complex_ __z)); /* Hyperbolic arc sine of Z. */ __MATHCALL (casinh, (_Mdouble_complex_ __z)); /* Hyperbolic arc tangent of Z. */ __MATHCALL (catanh, (_Mdouble_complex_ __z)); /* Hyperbolic cosine of Z. */ __MATHCALL (ccosh, (_Mdouble_complex_ __z)); /* Hyperbolic sine of Z. */ __MATHCALL (csinh, (_Mdouble_complex_ __z)); /* Hyperbolic tangent of Z. */ __MATHCALL (ctanh, (_Mdouble_complex_ __z)); /* Exponential and logarithmic functions. */ /* Exponential function of Z. */ __MATHCALL (cexp, (_Mdouble_complex_ __z)); /* Natural logarithm of Z. */ __MATHCALL (clog, (_Mdouble_complex_ __z)); #ifdef __USE_GNU /* The base 10 logarithm is not defined by the standard but to implement the standard C++ library it is handy. */ __MATHCALL (clog10, (_Mdouble_complex_ __z)); #endif /* Power functions. */ /* Return X to the Y power. */ __MATHCALL (cpow, (_Mdouble_complex_ __x, _Mdouble_complex_ __y)); /* Return the square root of Z. */ __MATHCALL (csqrt, (_Mdouble_complex_ __z)); /* Absolute value, conjugates, and projection. */ /* Absolute value of Z. */ __MATHDECL (_Mdouble_,cabs, (_Mdouble_complex_ __z)); /* Argument value of Z. */ __MATHDECL (_Mdouble_,carg, (_Mdouble_complex_ __z)); /* Complex conjugate of Z. */ __MATHCALL (conj, (_Mdouble_complex_ __z)); /* Projection of Z onto the Riemann sphere. */ __MATHCALL (cproj, (_Mdouble_complex_ __z)); /* Decomposing complex values. */ /* Imaginary part of Z. */ __MATHDECL (_Mdouble_,cimag, (_Mdouble_complex_ __z)); /* Real part of Z. */ __MATHDECL (_Mdouble_,creal, (_Mdouble_complex_ __z)); link.h 0000644 00000010276 15125171642 0005664 0 ustar 00 /* Copyright (C) 2004-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _LINK_H # error "Never include <bits/link.h> directly; use <link.h> instead." #endif #ifndef __x86_64__ /* Registers for entry into PLT on IA-32. */ typedef struct La_i86_regs { uint32_t lr_edx; uint32_t lr_ecx; uint32_t lr_eax; uint32_t lr_ebp; uint32_t lr_esp; } La_i86_regs; /* Return values for calls from PLT on IA-32. */ typedef struct La_i86_retval { uint32_t lrv_eax; uint32_t lrv_edx; long double lrv_st0; long double lrv_st1; uint64_t lrv_bnd0; uint64_t lrv_bnd1; } La_i86_retval; __BEGIN_DECLS extern Elf32_Addr la_i86_gnu_pltenter (Elf32_Sym *__sym, unsigned int __ndx, uintptr_t *__refcook, uintptr_t *__defcook, La_i86_regs *__regs, unsigned int *__flags, const char *__symname, long int *__framesizep); extern unsigned int la_i86_gnu_pltexit (Elf32_Sym *__sym, unsigned int __ndx, uintptr_t *__refcook, uintptr_t *__defcook, const La_i86_regs *__inregs, La_i86_retval *__outregs, const char *symname); __END_DECLS #else /* Registers for entry into PLT on x86-64. */ # if __GNUC_PREREQ (4,0) typedef float La_x86_64_xmm __attribute__ ((__vector_size__ (16))); typedef float La_x86_64_ymm __attribute__ ((__vector_size__ (32), __aligned__ (16))); typedef double La_x86_64_zmm __attribute__ ((__vector_size__ (64), __aligned__ (16))); # else typedef float La_x86_64_xmm __attribute__ ((__mode__ (__V4SF__))); # endif typedef union { # if __GNUC_PREREQ (4,0) La_x86_64_ymm ymm[2]; La_x86_64_zmm zmm[1]; # endif La_x86_64_xmm xmm[4]; } La_x86_64_vector __attribute__ ((__aligned__ (16))); typedef struct La_x86_64_regs { uint64_t lr_rdx; uint64_t lr_r8; uint64_t lr_r9; uint64_t lr_rcx; uint64_t lr_rsi; uint64_t lr_rdi; uint64_t lr_rbp; uint64_t lr_rsp; La_x86_64_xmm lr_xmm[8]; La_x86_64_vector lr_vector[8]; #ifndef __ILP32__ __int128_t lr_bnd[4]; #endif } La_x86_64_regs; /* Return values for calls from PLT on x86-64. */ typedef struct La_x86_64_retval { uint64_t lrv_rax; uint64_t lrv_rdx; La_x86_64_xmm lrv_xmm0; La_x86_64_xmm lrv_xmm1; long double lrv_st0; long double lrv_st1; La_x86_64_vector lrv_vector0; La_x86_64_vector lrv_vector1; #ifndef __ILP32__ __int128_t lrv_bnd0; __int128_t lrv_bnd1; #endif } La_x86_64_retval; #define La_x32_regs La_x86_64_regs #define La_x32_retval La_x86_64_retval __BEGIN_DECLS extern Elf64_Addr la_x86_64_gnu_pltenter (Elf64_Sym *__sym, unsigned int __ndx, uintptr_t *__refcook, uintptr_t *__defcook, La_x86_64_regs *__regs, unsigned int *__flags, const char *__symname, long int *__framesizep); extern unsigned int la_x86_64_gnu_pltexit (Elf64_Sym *__sym, unsigned int __ndx, uintptr_t *__refcook, uintptr_t *__defcook, const La_x86_64_regs *__inregs, La_x86_64_retval *__outregs, const char *__symname); extern Elf32_Addr la_x32_gnu_pltenter (Elf32_Sym *__sym, unsigned int __ndx, uintptr_t *__refcook, uintptr_t *__defcook, La_x32_regs *__regs, unsigned int *__flags, const char *__symname, long int *__framesizep); extern unsigned int la_x32_gnu_pltexit (Elf32_Sym *__sym, unsigned int __ndx, uintptr_t *__refcook, uintptr_t *__defcook, const La_x32_regs *__inregs, La_x32_retval *__outregs, const char *__symname); __END_DECLS #endif stdint-intn.h 0000644 00000002015 15125171642 0007172 0 ustar 00 /* Define intN_t types. Copyright (C) 2017-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _BITS_STDINT_INTN_H #define _BITS_STDINT_INTN_H 1 #include <bits/types.h> typedef __int8_t int8_t; typedef __int16_t int16_t; typedef __int32_t int32_t; typedef __int64_t int64_t; #endif /* bits/stdint-intn.h */ time64.h 0000644 00000002474 15125171642 0006040 0 ustar 00 /* bits/time64.h -- underlying types for __time64_t. Generic version. Copyright (C) 2018-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _BITS_TYPES_H # error "Never include <bits/time64.h> directly; use <sys/types.h> instead." #endif #ifndef _BITS_TIME64_H #define _BITS_TIME64_H 1 /* Define __TIME64_T_TYPE so that it is always a 64-bit type. */ #if __TIMESIZE == 64 /* If we already have 64-bit time type then use it. */ # define __TIME64_T_TYPE __TIME_T_TYPE #else /* Define a 64-bit time type alongsize the 32-bit one. */ # define __TIME64_T_TYPE __SQUAD_TYPE #endif #endif /* bits/time64.h */ timerfd.h 0000644 00000002117 15125171642 0006354 0 ustar 00 /* Copyright (C) 2008-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _SYS_TIMERFD_H # error "Never use <bits/timerfd.h> directly; include <sys/timerfd.h> instead." #endif /* Bits to be set in the FLAGS parameter of `timerfd_create'. */ enum { TFD_CLOEXEC = 02000000, #define TFD_CLOEXEC TFD_CLOEXEC TFD_NONBLOCK = 00004000 #define TFD_NONBLOCK TFD_NONBLOCK }; err-ldbl.h 0000644 00000002174 15125171642 0006430 0 ustar 00 /* Redirections for err.h functions for -mlong-double-64. Copyright (C) 2019-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _ERR_H # error "Never include <bits/err-ldbl.h> directly; use <err.h> instead." #endif __LDBL_REDIR_DECL (warn) __LDBL_REDIR_DECL (vwarn) __LDBL_REDIR_DECL (warnx) __LDBL_REDIR_DECL (vwarnx) __LDBL_REDIR_DECL (err) __LDBL_REDIR_DECL (verr) __LDBL_REDIR_DECL (errx) __LDBL_REDIR_DECL (verrx) syscall.h 0000644 00000132674 15125171642 0006410 0 ustar 00 /* Generated at libc build time from syscall list. */ /* The system call list corresponds to kernel 6.9. */ #ifndef _SYSCALL_H # error "Never use <bits/syscall.h> directly; include <sys/syscall.h> instead." #endif #define __GLIBC_LINUX_VERSION_CODE 395520 #ifdef __NR_FAST_atomic_update # define SYS_FAST_atomic_update __NR_FAST_atomic_update #endif #ifdef __NR_FAST_cmpxchg # define SYS_FAST_cmpxchg __NR_FAST_cmpxchg #endif #ifdef __NR_FAST_cmpxchg64 # define SYS_FAST_cmpxchg64 __NR_FAST_cmpxchg64 #endif #ifdef __NR__llseek # define SYS__llseek __NR__llseek #endif #ifdef __NR__newselect # define SYS__newselect __NR__newselect #endif #ifdef __NR__sysctl # define SYS__sysctl __NR__sysctl #endif #ifdef __NR_accept # define SYS_accept __NR_accept #endif #ifdef __NR_accept4 # define SYS_accept4 __NR_accept4 #endif #ifdef __NR_access # define SYS_access __NR_access #endif #ifdef __NR_acct # define SYS_acct __NR_acct #endif #ifdef __NR_acl_get # define SYS_acl_get __NR_acl_get #endif #ifdef __NR_acl_set # define SYS_acl_set __NR_acl_set #endif #ifdef __NR_add_key # define SYS_add_key __NR_add_key #endif #ifdef __NR_adjtimex # define SYS_adjtimex __NR_adjtimex #endif #ifdef __NR_afs_syscall # define SYS_afs_syscall __NR_afs_syscall #endif #ifdef __NR_alarm # define SYS_alarm __NR_alarm #endif #ifdef __NR_alloc_hugepages # define SYS_alloc_hugepages __NR_alloc_hugepages #endif #ifdef __NR_arc_gettls # define SYS_arc_gettls __NR_arc_gettls #endif #ifdef __NR_arc_settls # define SYS_arc_settls __NR_arc_settls #endif #ifdef __NR_arc_usr_cmpxchg # define SYS_arc_usr_cmpxchg __NR_arc_usr_cmpxchg #endif #ifdef __NR_arch_prctl # define SYS_arch_prctl __NR_arch_prctl #endif #ifdef __NR_arm_fadvise64_64 # define SYS_arm_fadvise64_64 __NR_arm_fadvise64_64 #endif #ifdef __NR_arm_sync_file_range # define SYS_arm_sync_file_range __NR_arm_sync_file_range #endif #ifdef __NR_atomic_barrier # define SYS_atomic_barrier __NR_atomic_barrier #endif #ifdef __NR_atomic_cmpxchg_32 # define SYS_atomic_cmpxchg_32 __NR_atomic_cmpxchg_32 #endif #ifdef __NR_attrctl # define SYS_attrctl __NR_attrctl #endif #ifdef __NR_bdflush # define SYS_bdflush __NR_bdflush #endif #ifdef __NR_bind # define SYS_bind __NR_bind #endif #ifdef __NR_bpf # define SYS_bpf __NR_bpf #endif #ifdef __NR_break # define SYS_break __NR_break #endif #ifdef __NR_breakpoint # define SYS_breakpoint __NR_breakpoint #endif #ifdef __NR_brk # define SYS_brk __NR_brk #endif #ifdef __NR_cachectl # define SYS_cachectl __NR_cachectl #endif #ifdef __NR_cacheflush # define SYS_cacheflush __NR_cacheflush #endif #ifdef __NR_cachestat # define SYS_cachestat __NR_cachestat #endif #ifdef __NR_capget # define SYS_capget __NR_capget #endif #ifdef __NR_capset # define SYS_capset __NR_capset #endif #ifdef __NR_chdir # define SYS_chdir __NR_chdir #endif #ifdef __NR_chmod # define SYS_chmod __NR_chmod #endif #ifdef __NR_chown # define SYS_chown __NR_chown #endif #ifdef __NR_chown32 # define SYS_chown32 __NR_chown32 #endif #ifdef __NR_chroot # define SYS_chroot __NR_chroot #endif #ifdef __NR_clock_adjtime # define SYS_clock_adjtime __NR_clock_adjtime #endif #ifdef __NR_clock_adjtime64 # define SYS_clock_adjtime64 __NR_clock_adjtime64 #endif #ifdef __NR_clock_getres # define SYS_clock_getres __NR_clock_getres #endif #ifdef __NR_clock_getres_time64 # define SYS_clock_getres_time64 __NR_clock_getres_time64 #endif #ifdef __NR_clock_gettime # define SYS_clock_gettime __NR_clock_gettime #endif #ifdef __NR_clock_gettime64 # define SYS_clock_gettime64 __NR_clock_gettime64 #endif #ifdef __NR_clock_nanosleep # define SYS_clock_nanosleep __NR_clock_nanosleep #endif #ifdef __NR_clock_nanosleep_time64 # define SYS_clock_nanosleep_time64 __NR_clock_nanosleep_time64 #endif #ifdef __NR_clock_settime # define SYS_clock_settime __NR_clock_settime #endif #ifdef __NR_clock_settime64 # define SYS_clock_settime64 __NR_clock_settime64 #endif #ifdef __NR_clone # define SYS_clone __NR_clone #endif #ifdef __NR_clone2 # define SYS_clone2 __NR_clone2 #endif #ifdef __NR_clone3 # define SYS_clone3 __NR_clone3 #endif #ifdef __NR_close # define SYS_close __NR_close #endif #ifdef __NR_close_range # define SYS_close_range __NR_close_range #endif #ifdef __NR_cmpxchg_badaddr # define SYS_cmpxchg_badaddr __NR_cmpxchg_badaddr #endif #ifdef __NR_connect # define SYS_connect __NR_connect #endif #ifdef __NR_copy_file_range # define SYS_copy_file_range __NR_copy_file_range #endif #ifdef __NR_creat # define SYS_creat __NR_creat #endif #ifdef __NR_create_module # define SYS_create_module __NR_create_module #endif #ifdef __NR_delete_module # define SYS_delete_module __NR_delete_module #endif #ifdef __NR_dipc # define SYS_dipc __NR_dipc #endif #ifdef __NR_dup # define SYS_dup __NR_dup #endif #ifdef __NR_dup2 # define SYS_dup2 __NR_dup2 #endif #ifdef __NR_dup3 # define SYS_dup3 __NR_dup3 #endif #ifdef __NR_epoll_create # define SYS_epoll_create __NR_epoll_create #endif #ifdef __NR_epoll_create1 # define SYS_epoll_create1 __NR_epoll_create1 #endif #ifdef __NR_epoll_ctl # define SYS_epoll_ctl __NR_epoll_ctl #endif #ifdef __NR_epoll_ctl_old # define SYS_epoll_ctl_old __NR_epoll_ctl_old #endif #ifdef __NR_epoll_pwait # define SYS_epoll_pwait __NR_epoll_pwait #endif #ifdef __NR_epoll_pwait2 # define SYS_epoll_pwait2 __NR_epoll_pwait2 #endif #ifdef __NR_epoll_wait # define SYS_epoll_wait __NR_epoll_wait #endif #ifdef __NR_epoll_wait_old # define SYS_epoll_wait_old __NR_epoll_wait_old #endif #ifdef __NR_eventfd # define SYS_eventfd __NR_eventfd #endif #ifdef __NR_eventfd2 # define SYS_eventfd2 __NR_eventfd2 #endif #ifdef __NR_exec_with_loader # define SYS_exec_with_loader __NR_exec_with_loader #endif #ifdef __NR_execv # define SYS_execv __NR_execv #endif #ifdef __NR_execve # define SYS_execve __NR_execve #endif #ifdef __NR_execveat # define SYS_execveat __NR_execveat #endif #ifdef __NR_exit # define SYS_exit __NR_exit #endif #ifdef __NR_exit_group # define SYS_exit_group __NR_exit_group #endif #ifdef __NR_faccessat # define SYS_faccessat __NR_faccessat #endif #ifdef __NR_faccessat2 # define SYS_faccessat2 __NR_faccessat2 #endif #ifdef __NR_fadvise64 # define SYS_fadvise64 __NR_fadvise64 #endif #ifdef __NR_fadvise64_64 # define SYS_fadvise64_64 __NR_fadvise64_64 #endif #ifdef __NR_fallocate # define SYS_fallocate __NR_fallocate #endif #ifdef __NR_fanotify_init # define SYS_fanotify_init __NR_fanotify_init #endif #ifdef __NR_fanotify_mark # define SYS_fanotify_mark __NR_fanotify_mark #endif #ifdef __NR_fchdir # define SYS_fchdir __NR_fchdir #endif #ifdef __NR_fchmod # define SYS_fchmod __NR_fchmod #endif #ifdef __NR_fchmodat # define SYS_fchmodat __NR_fchmodat #endif #ifdef __NR_fchmodat2 # define SYS_fchmodat2 __NR_fchmodat2 #endif #ifdef __NR_fchown # define SYS_fchown __NR_fchown #endif #ifdef __NR_fchown32 # define SYS_fchown32 __NR_fchown32 #endif #ifdef __NR_fchownat # define SYS_fchownat __NR_fchownat #endif #ifdef __NR_fcntl # define SYS_fcntl __NR_fcntl #endif #ifdef __NR_fcntl64 # define SYS_fcntl64 __NR_fcntl64 #endif #ifdef __NR_fdatasync # define SYS_fdatasync __NR_fdatasync #endif #ifdef __NR_fgetxattr # define SYS_fgetxattr __NR_fgetxattr #endif #ifdef __NR_finit_module # define SYS_finit_module __NR_finit_module #endif #ifdef __NR_flistxattr # define SYS_flistxattr __NR_flistxattr #endif #ifdef __NR_flock # define SYS_flock __NR_flock #endif #ifdef __NR_fork # define SYS_fork __NR_fork #endif #ifdef __NR_fp_udfiex_crtl # define SYS_fp_udfiex_crtl __NR_fp_udfiex_crtl #endif #ifdef __NR_free_hugepages # define SYS_free_hugepages __NR_free_hugepages #endif #ifdef __NR_fremovexattr # define SYS_fremovexattr __NR_fremovexattr #endif #ifdef __NR_fsconfig # define SYS_fsconfig __NR_fsconfig #endif #ifdef __NR_fsetxattr # define SYS_fsetxattr __NR_fsetxattr #endif #ifdef __NR_fsmount # define SYS_fsmount __NR_fsmount #endif #ifdef __NR_fsopen # define SYS_fsopen __NR_fsopen #endif #ifdef __NR_fspick # define SYS_fspick __NR_fspick #endif #ifdef __NR_fstat # define SYS_fstat __NR_fstat #endif #ifdef __NR_fstat64 # define SYS_fstat64 __NR_fstat64 #endif #ifdef __NR_fstatat64 # define SYS_fstatat64 __NR_fstatat64 #endif #ifdef __NR_fstatfs # define SYS_fstatfs __NR_fstatfs #endif #ifdef __NR_fstatfs64 # define SYS_fstatfs64 __NR_fstatfs64 #endif #ifdef __NR_fsync # define SYS_fsync __NR_fsync #endif #ifdef __NR_ftime # define SYS_ftime __NR_ftime #endif #ifdef __NR_ftruncate # define SYS_ftruncate __NR_ftruncate #endif #ifdef __NR_ftruncate64 # define SYS_ftruncate64 __NR_ftruncate64 #endif #ifdef __NR_futex # define SYS_futex __NR_futex #endif #ifdef __NR_futex_requeue # define SYS_futex_requeue __NR_futex_requeue #endif #ifdef __NR_futex_time64 # define SYS_futex_time64 __NR_futex_time64 #endif #ifdef __NR_futex_wait # define SYS_futex_wait __NR_futex_wait #endif #ifdef __NR_futex_waitv # define SYS_futex_waitv __NR_futex_waitv #endif #ifdef __NR_futex_wake # define SYS_futex_wake __NR_futex_wake #endif #ifdef __NR_futimesat # define SYS_futimesat __NR_futimesat #endif #ifdef __NR_get_kernel_syms # define SYS_get_kernel_syms __NR_get_kernel_syms #endif #ifdef __NR_get_mempolicy # define SYS_get_mempolicy __NR_get_mempolicy #endif #ifdef __NR_get_robust_list # define SYS_get_robust_list __NR_get_robust_list #endif #ifdef __NR_get_thread_area # define SYS_get_thread_area __NR_get_thread_area #endif #ifdef __NR_get_tls # define SYS_get_tls __NR_get_tls #endif #ifdef __NR_getcpu # define SYS_getcpu __NR_getcpu #endif #ifdef __NR_getcwd # define SYS_getcwd __NR_getcwd #endif #ifdef __NR_getdents # define SYS_getdents __NR_getdents #endif #ifdef __NR_getdents64 # define SYS_getdents64 __NR_getdents64 #endif #ifdef __NR_getdomainname # define SYS_getdomainname __NR_getdomainname #endif #ifdef __NR_getdtablesize # define SYS_getdtablesize __NR_getdtablesize #endif #ifdef __NR_getegid # define SYS_getegid __NR_getegid #endif #ifdef __NR_getegid32 # define SYS_getegid32 __NR_getegid32 #endif #ifdef __NR_geteuid # define SYS_geteuid __NR_geteuid #endif #ifdef __NR_geteuid32 # define SYS_geteuid32 __NR_geteuid32 #endif #ifdef __NR_getgid # define SYS_getgid __NR_getgid #endif #ifdef __NR_getgid32 # define SYS_getgid32 __NR_getgid32 #endif #ifdef __NR_getgroups # define SYS_getgroups __NR_getgroups #endif #ifdef __NR_getgroups32 # define SYS_getgroups32 __NR_getgroups32 #endif #ifdef __NR_gethostname # define SYS_gethostname __NR_gethostname #endif #ifdef __NR_getitimer # define SYS_getitimer __NR_getitimer #endif #ifdef __NR_getpagesize # define SYS_getpagesize __NR_getpagesize #endif #ifdef __NR_getpeername # define SYS_getpeername __NR_getpeername #endif #ifdef __NR_getpgid # define SYS_getpgid __NR_getpgid #endif #ifdef __NR_getpgrp # define SYS_getpgrp __NR_getpgrp #endif #ifdef __NR_getpid # define SYS_getpid __NR_getpid #endif #ifdef __NR_getpmsg # define SYS_getpmsg __NR_getpmsg #endif #ifdef __NR_getppid # define SYS_getppid __NR_getppid #endif #ifdef __NR_getpriority # define SYS_getpriority __NR_getpriority #endif #ifdef __NR_getrandom # define SYS_getrandom __NR_getrandom #endif #ifdef __NR_getresgid # define SYS_getresgid __NR_getresgid #endif #ifdef __NR_getresgid32 # define SYS_getresgid32 __NR_getresgid32 #endif #ifdef __NR_getresuid # define SYS_getresuid __NR_getresuid #endif #ifdef __NR_getresuid32 # define SYS_getresuid32 __NR_getresuid32 #endif #ifdef __NR_getrlimit # define SYS_getrlimit __NR_getrlimit #endif #ifdef __NR_getrusage # define SYS_getrusage __NR_getrusage #endif #ifdef __NR_getsid # define SYS_getsid __NR_getsid #endif #ifdef __NR_getsockname # define SYS_getsockname __NR_getsockname #endif #ifdef __NR_getsockopt # define SYS_getsockopt __NR_getsockopt #endif #ifdef __NR_gettid # define SYS_gettid __NR_gettid #endif #ifdef __NR_gettimeofday # define SYS_gettimeofday __NR_gettimeofday #endif #ifdef __NR_getuid # define SYS_getuid __NR_getuid #endif #ifdef __NR_getuid32 # define SYS_getuid32 __NR_getuid32 #endif #ifdef __NR_getunwind # define SYS_getunwind __NR_getunwind #endif #ifdef __NR_getxattr # define SYS_getxattr __NR_getxattr #endif #ifdef __NR_getxgid # define SYS_getxgid __NR_getxgid #endif #ifdef __NR_getxpid # define SYS_getxpid __NR_getxpid #endif #ifdef __NR_getxuid # define SYS_getxuid __NR_getxuid #endif #ifdef __NR_gtty # define SYS_gtty __NR_gtty #endif #ifdef __NR_idle # define SYS_idle __NR_idle #endif #ifdef __NR_init_module # define SYS_init_module __NR_init_module #endif #ifdef __NR_inotify_add_watch # define SYS_inotify_add_watch __NR_inotify_add_watch #endif #ifdef __NR_inotify_init # define SYS_inotify_init __NR_inotify_init #endif #ifdef __NR_inotify_init1 # define SYS_inotify_init1 __NR_inotify_init1 #endif #ifdef __NR_inotify_rm_watch # define SYS_inotify_rm_watch __NR_inotify_rm_watch #endif #ifdef __NR_io_cancel # define SYS_io_cancel __NR_io_cancel #endif #ifdef __NR_io_destroy # define SYS_io_destroy __NR_io_destroy #endif #ifdef __NR_io_getevents # define SYS_io_getevents __NR_io_getevents #endif #ifdef __NR_io_pgetevents # define SYS_io_pgetevents __NR_io_pgetevents #endif #ifdef __NR_io_pgetevents_time64 # define SYS_io_pgetevents_time64 __NR_io_pgetevents_time64 #endif #ifdef __NR_io_setup # define SYS_io_setup __NR_io_setup #endif #ifdef __NR_io_submit # define SYS_io_submit __NR_io_submit #endif #ifdef __NR_io_uring_enter # define SYS_io_uring_enter __NR_io_uring_enter #endif #ifdef __NR_io_uring_register # define SYS_io_uring_register __NR_io_uring_register #endif #ifdef __NR_io_uring_setup # define SYS_io_uring_setup __NR_io_uring_setup #endif #ifdef __NR_ioctl # define SYS_ioctl __NR_ioctl #endif #ifdef __NR_ioperm # define SYS_ioperm __NR_ioperm #endif #ifdef __NR_iopl # define SYS_iopl __NR_iopl #endif #ifdef __NR_ioprio_get # define SYS_ioprio_get __NR_ioprio_get #endif #ifdef __NR_ioprio_set # define SYS_ioprio_set __NR_ioprio_set #endif #ifdef __NR_ipc # define SYS_ipc __NR_ipc #endif #ifdef __NR_kcmp # define SYS_kcmp __NR_kcmp #endif #ifdef __NR_kern_features # define SYS_kern_features __NR_kern_features #endif #ifdef __NR_kexec_file_load # define SYS_kexec_file_load __NR_kexec_file_load #endif #ifdef __NR_kexec_load # define SYS_kexec_load __NR_kexec_load #endif #ifdef __NR_keyctl # define SYS_keyctl __NR_keyctl #endif #ifdef __NR_kill # define SYS_kill __NR_kill #endif #ifdef __NR_landlock_add_rule # define SYS_landlock_add_rule __NR_landlock_add_rule #endif #ifdef __NR_landlock_create_ruleset # define SYS_landlock_create_ruleset __NR_landlock_create_ruleset #endif #ifdef __NR_landlock_restrict_self # define SYS_landlock_restrict_self __NR_landlock_restrict_self #endif #ifdef __NR_lchown # define SYS_lchown __NR_lchown #endif #ifdef __NR_lchown32 # define SYS_lchown32 __NR_lchown32 #endif #ifdef __NR_lgetxattr # define SYS_lgetxattr __NR_lgetxattr #endif #ifdef __NR_link # define SYS_link __NR_link #endif #ifdef __NR_linkat # define SYS_linkat __NR_linkat #endif #ifdef __NR_listen # define SYS_listen __NR_listen #endif #ifdef __NR_listmount # define SYS_listmount __NR_listmount #endif #ifdef __NR_listxattr # define SYS_listxattr __NR_listxattr #endif #ifdef __NR_llistxattr # define SYS_llistxattr __NR_llistxattr #endif #ifdef __NR_llseek # define SYS_llseek __NR_llseek #endif #ifdef __NR_lock # define SYS_lock __NR_lock #endif #ifdef __NR_lookup_dcookie # define SYS_lookup_dcookie __NR_lookup_dcookie #endif #ifdef __NR_lremovexattr # define SYS_lremovexattr __NR_lremovexattr #endif #ifdef __NR_lseek # define SYS_lseek __NR_lseek #endif #ifdef __NR_lsetxattr # define SYS_lsetxattr __NR_lsetxattr #endif #ifdef __NR_lsm_get_self_attr # define SYS_lsm_get_self_attr __NR_lsm_get_self_attr #endif #ifdef __NR_lsm_list_modules # define SYS_lsm_list_modules __NR_lsm_list_modules #endif #ifdef __NR_lsm_set_self_attr # define SYS_lsm_set_self_attr __NR_lsm_set_self_attr #endif #ifdef __NR_lstat # define SYS_lstat __NR_lstat #endif #ifdef __NR_lstat64 # define SYS_lstat64 __NR_lstat64 #endif #ifdef __NR_madvise # define SYS_madvise __NR_madvise #endif #ifdef __NR_map_shadow_stack # define SYS_map_shadow_stack __NR_map_shadow_stack #endif #ifdef __NR_mbind # define SYS_mbind __NR_mbind #endif #ifdef __NR_membarrier # define SYS_membarrier __NR_membarrier #endif #ifdef __NR_memfd_create # define SYS_memfd_create __NR_memfd_create #endif #ifdef __NR_memfd_secret # define SYS_memfd_secret __NR_memfd_secret #endif #ifdef __NR_memory_ordering # define SYS_memory_ordering __NR_memory_ordering #endif #ifdef __NR_migrate_pages # define SYS_migrate_pages __NR_migrate_pages #endif #ifdef __NR_mincore # define SYS_mincore __NR_mincore #endif #ifdef __NR_mkdir # define SYS_mkdir __NR_mkdir #endif #ifdef __NR_mkdirat # define SYS_mkdirat __NR_mkdirat #endif #ifdef __NR_mknod # define SYS_mknod __NR_mknod #endif #ifdef __NR_mknodat # define SYS_mknodat __NR_mknodat #endif #ifdef __NR_mlock # define SYS_mlock __NR_mlock #endif #ifdef __NR_mlock2 # define SYS_mlock2 __NR_mlock2 #endif #ifdef __NR_mlockall # define SYS_mlockall __NR_mlockall #endif #ifdef __NR_mmap # define SYS_mmap __NR_mmap #endif #ifdef __NR_mmap2 # define SYS_mmap2 __NR_mmap2 #endif #ifdef __NR_modify_ldt # define SYS_modify_ldt __NR_modify_ldt #endif #ifdef __NR_mount # define SYS_mount __NR_mount #endif #ifdef __NR_mount_setattr # define SYS_mount_setattr __NR_mount_setattr #endif #ifdef __NR_move_mount # define SYS_move_mount __NR_move_mount #endif #ifdef __NR_move_pages # define SYS_move_pages __NR_move_pages #endif #ifdef __NR_mprotect # define SYS_mprotect __NR_mprotect #endif #ifdef __NR_mpx # define SYS_mpx __NR_mpx #endif #ifdef __NR_mq_getsetattr # define SYS_mq_getsetattr __NR_mq_getsetattr #endif #ifdef __NR_mq_notify # define SYS_mq_notify __NR_mq_notify #endif #ifdef __NR_mq_open # define SYS_mq_open __NR_mq_open #endif #ifdef __NR_mq_timedreceive # define SYS_mq_timedreceive __NR_mq_timedreceive #endif #ifdef __NR_mq_timedreceive_time64 # define SYS_mq_timedreceive_time64 __NR_mq_timedreceive_time64 #endif #ifdef __NR_mq_timedsend # define SYS_mq_timedsend __NR_mq_timedsend #endif #ifdef __NR_mq_timedsend_time64 # define SYS_mq_timedsend_time64 __NR_mq_timedsend_time64 #endif #ifdef __NR_mq_unlink # define SYS_mq_unlink __NR_mq_unlink #endif #ifdef __NR_mremap # define SYS_mremap __NR_mremap #endif #ifdef __NR_msgctl # define SYS_msgctl __NR_msgctl #endif #ifdef __NR_msgget # define SYS_msgget __NR_msgget #endif #ifdef __NR_msgrcv # define SYS_msgrcv __NR_msgrcv #endif #ifdef __NR_msgsnd # define SYS_msgsnd __NR_msgsnd #endif #ifdef __NR_msync # define SYS_msync __NR_msync #endif #ifdef __NR_multiplexer # define SYS_multiplexer __NR_multiplexer #endif #ifdef __NR_munlock # define SYS_munlock __NR_munlock #endif #ifdef __NR_munlockall # define SYS_munlockall __NR_munlockall #endif #ifdef __NR_munmap # define SYS_munmap __NR_munmap #endif #ifdef __NR_name_to_handle_at # define SYS_name_to_handle_at __NR_name_to_handle_at #endif #ifdef __NR_nanosleep # define SYS_nanosleep __NR_nanosleep #endif #ifdef __NR_newfstatat # define SYS_newfstatat __NR_newfstatat #endif #ifdef __NR_nfsservctl # define SYS_nfsservctl __NR_nfsservctl #endif #ifdef __NR_ni_syscall # define SYS_ni_syscall __NR_ni_syscall #endif #ifdef __NR_nice # define SYS_nice __NR_nice #endif #ifdef __NR_old_adjtimex # define SYS_old_adjtimex __NR_old_adjtimex #endif #ifdef __NR_old_getpagesize # define SYS_old_getpagesize __NR_old_getpagesize #endif #ifdef __NR_oldfstat # define SYS_oldfstat __NR_oldfstat #endif #ifdef __NR_oldlstat # define SYS_oldlstat __NR_oldlstat #endif #ifdef __NR_oldolduname # define SYS_oldolduname __NR_oldolduname #endif #ifdef __NR_oldstat # define SYS_oldstat __NR_oldstat #endif #ifdef __NR_oldumount # define SYS_oldumount __NR_oldumount #endif #ifdef __NR_olduname # define SYS_olduname __NR_olduname #endif #ifdef __NR_open # define SYS_open __NR_open #endif #ifdef __NR_open_by_handle_at # define SYS_open_by_handle_at __NR_open_by_handle_at #endif #ifdef __NR_open_tree # define SYS_open_tree __NR_open_tree #endif #ifdef __NR_openat # define SYS_openat __NR_openat #endif #ifdef __NR_openat2 # define SYS_openat2 __NR_openat2 #endif #ifdef __NR_osf_adjtime # define SYS_osf_adjtime __NR_osf_adjtime #endif #ifdef __NR_osf_afs_syscall # define SYS_osf_afs_syscall __NR_osf_afs_syscall #endif #ifdef __NR_osf_alt_plock # define SYS_osf_alt_plock __NR_osf_alt_plock #endif #ifdef __NR_osf_alt_setsid # define SYS_osf_alt_setsid __NR_osf_alt_setsid #endif #ifdef __NR_osf_alt_sigpending # define SYS_osf_alt_sigpending __NR_osf_alt_sigpending #endif #ifdef __NR_osf_asynch_daemon # define SYS_osf_asynch_daemon __NR_osf_asynch_daemon #endif #ifdef __NR_osf_audcntl # define SYS_osf_audcntl __NR_osf_audcntl #endif #ifdef __NR_osf_audgen # define SYS_osf_audgen __NR_osf_audgen #endif #ifdef __NR_osf_chflags # define SYS_osf_chflags __NR_osf_chflags #endif #ifdef __NR_osf_execve # define SYS_osf_execve __NR_osf_execve #endif #ifdef __NR_osf_exportfs # define SYS_osf_exportfs __NR_osf_exportfs #endif #ifdef __NR_osf_fchflags # define SYS_osf_fchflags __NR_osf_fchflags #endif #ifdef __NR_osf_fdatasync # define SYS_osf_fdatasync __NR_osf_fdatasync #endif #ifdef __NR_osf_fpathconf # define SYS_osf_fpathconf __NR_osf_fpathconf #endif #ifdef __NR_osf_fstat # define SYS_osf_fstat __NR_osf_fstat #endif #ifdef __NR_osf_fstatfs # define SYS_osf_fstatfs __NR_osf_fstatfs #endif #ifdef __NR_osf_fstatfs64 # define SYS_osf_fstatfs64 __NR_osf_fstatfs64 #endif #ifdef __NR_osf_fuser # define SYS_osf_fuser __NR_osf_fuser #endif #ifdef __NR_osf_getaddressconf # define SYS_osf_getaddressconf __NR_osf_getaddressconf #endif #ifdef __NR_osf_getdirentries # define SYS_osf_getdirentries __NR_osf_getdirentries #endif #ifdef __NR_osf_getdomainname # define SYS_osf_getdomainname __NR_osf_getdomainname #endif #ifdef __NR_osf_getfh # define SYS_osf_getfh __NR_osf_getfh #endif #ifdef __NR_osf_getfsstat # define SYS_osf_getfsstat __NR_osf_getfsstat #endif #ifdef __NR_osf_gethostid # define SYS_osf_gethostid __NR_osf_gethostid #endif #ifdef __NR_osf_getitimer # define SYS_osf_getitimer __NR_osf_getitimer #endif #ifdef __NR_osf_getlogin # define SYS_osf_getlogin __NR_osf_getlogin #endif #ifdef __NR_osf_getmnt # define SYS_osf_getmnt __NR_osf_getmnt #endif #ifdef __NR_osf_getrusage # define SYS_osf_getrusage __NR_osf_getrusage #endif #ifdef __NR_osf_getsysinfo # define SYS_osf_getsysinfo __NR_osf_getsysinfo #endif #ifdef __NR_osf_gettimeofday # define SYS_osf_gettimeofday __NR_osf_gettimeofday #endif #ifdef __NR_osf_kloadcall # define SYS_osf_kloadcall __NR_osf_kloadcall #endif #ifdef __NR_osf_kmodcall # define SYS_osf_kmodcall __NR_osf_kmodcall #endif #ifdef __NR_osf_lstat # define SYS_osf_lstat __NR_osf_lstat #endif #ifdef __NR_osf_memcntl # define SYS_osf_memcntl __NR_osf_memcntl #endif #ifdef __NR_osf_mincore # define SYS_osf_mincore __NR_osf_mincore #endif #ifdef __NR_osf_mount # define SYS_osf_mount __NR_osf_mount #endif #ifdef __NR_osf_mremap # define SYS_osf_mremap __NR_osf_mremap #endif #ifdef __NR_osf_msfs_syscall # define SYS_osf_msfs_syscall __NR_osf_msfs_syscall #endif #ifdef __NR_osf_msleep # define SYS_osf_msleep __NR_osf_msleep #endif #ifdef __NR_osf_mvalid # define SYS_osf_mvalid __NR_osf_mvalid #endif #ifdef __NR_osf_mwakeup # define SYS_osf_mwakeup __NR_osf_mwakeup #endif #ifdef __NR_osf_naccept # define SYS_osf_naccept __NR_osf_naccept #endif #ifdef __NR_osf_nfssvc # define SYS_osf_nfssvc __NR_osf_nfssvc #endif #ifdef __NR_osf_ngetpeername # define SYS_osf_ngetpeername __NR_osf_ngetpeername #endif #ifdef __NR_osf_ngetsockname # define SYS_osf_ngetsockname __NR_osf_ngetsockname #endif #ifdef __NR_osf_nrecvfrom # define SYS_osf_nrecvfrom __NR_osf_nrecvfrom #endif #ifdef __NR_osf_nrecvmsg # define SYS_osf_nrecvmsg __NR_osf_nrecvmsg #endif #ifdef __NR_osf_nsendmsg # define SYS_osf_nsendmsg __NR_osf_nsendmsg #endif #ifdef __NR_osf_ntp_adjtime # define SYS_osf_ntp_adjtime __NR_osf_ntp_adjtime #endif #ifdef __NR_osf_ntp_gettime # define SYS_osf_ntp_gettime __NR_osf_ntp_gettime #endif #ifdef __NR_osf_old_creat # define SYS_osf_old_creat __NR_osf_old_creat #endif #ifdef __NR_osf_old_fstat # define SYS_osf_old_fstat __NR_osf_old_fstat #endif #ifdef __NR_osf_old_getpgrp # define SYS_osf_old_getpgrp __NR_osf_old_getpgrp #endif #ifdef __NR_osf_old_killpg # define SYS_osf_old_killpg __NR_osf_old_killpg #endif #ifdef __NR_osf_old_lstat # define SYS_osf_old_lstat __NR_osf_old_lstat #endif #ifdef __NR_osf_old_open # define SYS_osf_old_open __NR_osf_old_open #endif #ifdef __NR_osf_old_sigaction # define SYS_osf_old_sigaction __NR_osf_old_sigaction #endif #ifdef __NR_osf_old_sigblock # define SYS_osf_old_sigblock __NR_osf_old_sigblock #endif #ifdef __NR_osf_old_sigreturn # define SYS_osf_old_sigreturn __NR_osf_old_sigreturn #endif #ifdef __NR_osf_old_sigsetmask # define SYS_osf_old_sigsetmask __NR_osf_old_sigsetmask #endif #ifdef __NR_osf_old_sigvec # define SYS_osf_old_sigvec __NR_osf_old_sigvec #endif #ifdef __NR_osf_old_stat # define SYS_osf_old_stat __NR_osf_old_stat #endif #ifdef __NR_osf_old_vadvise # define SYS_osf_old_vadvise __NR_osf_old_vadvise #endif #ifdef __NR_osf_old_vtrace # define SYS_osf_old_vtrace __NR_osf_old_vtrace #endif #ifdef __NR_osf_old_wait # define SYS_osf_old_wait __NR_osf_old_wait #endif #ifdef __NR_osf_oldquota # define SYS_osf_oldquota __NR_osf_oldquota #endif #ifdef __NR_osf_pathconf # define SYS_osf_pathconf __NR_osf_pathconf #endif #ifdef __NR_osf_pid_block # define SYS_osf_pid_block __NR_osf_pid_block #endif #ifdef __NR_osf_pid_unblock # define SYS_osf_pid_unblock __NR_osf_pid_unblock #endif #ifdef __NR_osf_plock # define SYS_osf_plock __NR_osf_plock #endif #ifdef __NR_osf_priocntlset # define SYS_osf_priocntlset __NR_osf_priocntlset #endif #ifdef __NR_osf_profil # define SYS_osf_profil __NR_osf_profil #endif #ifdef __NR_osf_proplist_syscall # define SYS_osf_proplist_syscall __NR_osf_proplist_syscall #endif #ifdef __NR_osf_reboot # define SYS_osf_reboot __NR_osf_reboot #endif #ifdef __NR_osf_revoke # define SYS_osf_revoke __NR_osf_revoke #endif #ifdef __NR_osf_sbrk # define SYS_osf_sbrk __NR_osf_sbrk #endif #ifdef __NR_osf_security # define SYS_osf_security __NR_osf_security #endif #ifdef __NR_osf_select # define SYS_osf_select __NR_osf_select #endif #ifdef __NR_osf_set_program_attributes # define SYS_osf_set_program_attributes __NR_osf_set_program_attributes #endif #ifdef __NR_osf_set_speculative # define SYS_osf_set_speculative __NR_osf_set_speculative #endif #ifdef __NR_osf_sethostid # define SYS_osf_sethostid __NR_osf_sethostid #endif #ifdef __NR_osf_setitimer # define SYS_osf_setitimer __NR_osf_setitimer #endif #ifdef __NR_osf_setlogin # define SYS_osf_setlogin __NR_osf_setlogin #endif #ifdef __NR_osf_setsysinfo # define SYS_osf_setsysinfo __NR_osf_setsysinfo #endif #ifdef __NR_osf_settimeofday # define SYS_osf_settimeofday __NR_osf_settimeofday #endif #ifdef __NR_osf_shmat # define SYS_osf_shmat __NR_osf_shmat #endif #ifdef __NR_osf_signal # define SYS_osf_signal __NR_osf_signal #endif #ifdef __NR_osf_sigprocmask # define SYS_osf_sigprocmask __NR_osf_sigprocmask #endif #ifdef __NR_osf_sigsendset # define SYS_osf_sigsendset __NR_osf_sigsendset #endif #ifdef __NR_osf_sigstack # define SYS_osf_sigstack __NR_osf_sigstack #endif #ifdef __NR_osf_sigwaitprim # define SYS_osf_sigwaitprim __NR_osf_sigwaitprim #endif #ifdef __NR_osf_sstk # define SYS_osf_sstk __NR_osf_sstk #endif #ifdef __NR_osf_stat # define SYS_osf_stat __NR_osf_stat #endif #ifdef __NR_osf_statfs # define SYS_osf_statfs __NR_osf_statfs #endif #ifdef __NR_osf_statfs64 # define SYS_osf_statfs64 __NR_osf_statfs64 #endif #ifdef __NR_osf_subsys_info # define SYS_osf_subsys_info __NR_osf_subsys_info #endif #ifdef __NR_osf_swapctl # define SYS_osf_swapctl __NR_osf_swapctl #endif #ifdef __NR_osf_swapon # define SYS_osf_swapon __NR_osf_swapon #endif #ifdef __NR_osf_syscall # define SYS_osf_syscall __NR_osf_syscall #endif #ifdef __NR_osf_sysinfo # define SYS_osf_sysinfo __NR_osf_sysinfo #endif #ifdef __NR_osf_table # define SYS_osf_table __NR_osf_table #endif #ifdef __NR_osf_uadmin # define SYS_osf_uadmin __NR_osf_uadmin #endif #ifdef __NR_osf_usleep_thread # define SYS_osf_usleep_thread __NR_osf_usleep_thread #endif #ifdef __NR_osf_uswitch # define SYS_osf_uswitch __NR_osf_uswitch #endif #ifdef __NR_osf_utc_adjtime # define SYS_osf_utc_adjtime __NR_osf_utc_adjtime #endif #ifdef __NR_osf_utc_gettime # define SYS_osf_utc_gettime __NR_osf_utc_gettime #endif #ifdef __NR_osf_utimes # define SYS_osf_utimes __NR_osf_utimes #endif #ifdef __NR_osf_utsname # define SYS_osf_utsname __NR_osf_utsname #endif #ifdef __NR_osf_wait4 # define SYS_osf_wait4 __NR_osf_wait4 #endif #ifdef __NR_osf_waitid # define SYS_osf_waitid __NR_osf_waitid #endif #ifdef __NR_pause # define SYS_pause __NR_pause #endif #ifdef __NR_pciconfig_iobase # define SYS_pciconfig_iobase __NR_pciconfig_iobase #endif #ifdef __NR_pciconfig_read # define SYS_pciconfig_read __NR_pciconfig_read #endif #ifdef __NR_pciconfig_write # define SYS_pciconfig_write __NR_pciconfig_write #endif #ifdef __NR_perf_event_open # define SYS_perf_event_open __NR_perf_event_open #endif #ifdef __NR_perfctr # define SYS_perfctr __NR_perfctr #endif #ifdef __NR_perfmonctl # define SYS_perfmonctl __NR_perfmonctl #endif #ifdef __NR_personality # define SYS_personality __NR_personality #endif #ifdef __NR_pidfd_getfd # define SYS_pidfd_getfd __NR_pidfd_getfd #endif #ifdef __NR_pidfd_open # define SYS_pidfd_open __NR_pidfd_open #endif #ifdef __NR_pidfd_send_signal # define SYS_pidfd_send_signal __NR_pidfd_send_signal #endif #ifdef __NR_pipe # define SYS_pipe __NR_pipe #endif #ifdef __NR_pipe2 # define SYS_pipe2 __NR_pipe2 #endif #ifdef __NR_pivot_root # define SYS_pivot_root __NR_pivot_root #endif #ifdef __NR_pkey_alloc # define SYS_pkey_alloc __NR_pkey_alloc #endif #ifdef __NR_pkey_free # define SYS_pkey_free __NR_pkey_free #endif #ifdef __NR_pkey_mprotect # define SYS_pkey_mprotect __NR_pkey_mprotect #endif #ifdef __NR_poll # define SYS_poll __NR_poll #endif #ifdef __NR_ppoll # define SYS_ppoll __NR_ppoll #endif #ifdef __NR_ppoll_time64 # define SYS_ppoll_time64 __NR_ppoll_time64 #endif #ifdef __NR_prctl # define SYS_prctl __NR_prctl #endif #ifdef __NR_pread64 # define SYS_pread64 __NR_pread64 #endif #ifdef __NR_preadv # define SYS_preadv __NR_preadv #endif #ifdef __NR_preadv2 # define SYS_preadv2 __NR_preadv2 #endif #ifdef __NR_prlimit64 # define SYS_prlimit64 __NR_prlimit64 #endif #ifdef __NR_process_madvise # define SYS_process_madvise __NR_process_madvise #endif #ifdef __NR_process_mrelease # define SYS_process_mrelease __NR_process_mrelease #endif #ifdef __NR_process_vm_readv # define SYS_process_vm_readv __NR_process_vm_readv #endif #ifdef __NR_process_vm_writev # define SYS_process_vm_writev __NR_process_vm_writev #endif #ifdef __NR_prof # define SYS_prof __NR_prof #endif #ifdef __NR_profil # define SYS_profil __NR_profil #endif #ifdef __NR_pselect6 # define SYS_pselect6 __NR_pselect6 #endif #ifdef __NR_pselect6_time64 # define SYS_pselect6_time64 __NR_pselect6_time64 #endif #ifdef __NR_ptrace # define SYS_ptrace __NR_ptrace #endif #ifdef __NR_putpmsg # define SYS_putpmsg __NR_putpmsg #endif #ifdef __NR_pwrite64 # define SYS_pwrite64 __NR_pwrite64 #endif #ifdef __NR_pwritev # define SYS_pwritev __NR_pwritev #endif #ifdef __NR_pwritev2 # define SYS_pwritev2 __NR_pwritev2 #endif #ifdef __NR_query_module # define SYS_query_module __NR_query_module #endif #ifdef __NR_quotactl # define SYS_quotactl __NR_quotactl #endif #ifdef __NR_quotactl_fd # define SYS_quotactl_fd __NR_quotactl_fd #endif #ifdef __NR_read # define SYS_read __NR_read #endif #ifdef __NR_readahead # define SYS_readahead __NR_readahead #endif #ifdef __NR_readdir # define SYS_readdir __NR_readdir #endif #ifdef __NR_readlink # define SYS_readlink __NR_readlink #endif #ifdef __NR_readlinkat # define SYS_readlinkat __NR_readlinkat #endif #ifdef __NR_readv # define SYS_readv __NR_readv #endif #ifdef __NR_reboot # define SYS_reboot __NR_reboot #endif #ifdef __NR_recv # define SYS_recv __NR_recv #endif #ifdef __NR_recvfrom # define SYS_recvfrom __NR_recvfrom #endif #ifdef __NR_recvmmsg # define SYS_recvmmsg __NR_recvmmsg #endif #ifdef __NR_recvmmsg_time64 # define SYS_recvmmsg_time64 __NR_recvmmsg_time64 #endif #ifdef __NR_recvmsg # define SYS_recvmsg __NR_recvmsg #endif #ifdef __NR_remap_file_pages # define SYS_remap_file_pages __NR_remap_file_pages #endif #ifdef __NR_removexattr # define SYS_removexattr __NR_removexattr #endif #ifdef __NR_rename # define SYS_rename __NR_rename #endif #ifdef __NR_renameat # define SYS_renameat __NR_renameat #endif #ifdef __NR_renameat2 # define SYS_renameat2 __NR_renameat2 #endif #ifdef __NR_request_key # define SYS_request_key __NR_request_key #endif #ifdef __NR_restart_syscall # define SYS_restart_syscall __NR_restart_syscall #endif #ifdef __NR_riscv_flush_icache # define SYS_riscv_flush_icache __NR_riscv_flush_icache #endif #ifdef __NR_riscv_hwprobe # define SYS_riscv_hwprobe __NR_riscv_hwprobe #endif #ifdef __NR_rmdir # define SYS_rmdir __NR_rmdir #endif #ifdef __NR_rseq # define SYS_rseq __NR_rseq #endif #ifdef __NR_rt_sigaction # define SYS_rt_sigaction __NR_rt_sigaction #endif #ifdef __NR_rt_sigpending # define SYS_rt_sigpending __NR_rt_sigpending #endif #ifdef __NR_rt_sigprocmask # define SYS_rt_sigprocmask __NR_rt_sigprocmask #endif #ifdef __NR_rt_sigqueueinfo # define SYS_rt_sigqueueinfo __NR_rt_sigqueueinfo #endif #ifdef __NR_rt_sigreturn # define SYS_rt_sigreturn __NR_rt_sigreturn #endif #ifdef __NR_rt_sigsuspend # define SYS_rt_sigsuspend __NR_rt_sigsuspend #endif #ifdef __NR_rt_sigtimedwait # define SYS_rt_sigtimedwait __NR_rt_sigtimedwait #endif #ifdef __NR_rt_sigtimedwait_time64 # define SYS_rt_sigtimedwait_time64 __NR_rt_sigtimedwait_time64 #endif #ifdef __NR_rt_tgsigqueueinfo # define SYS_rt_tgsigqueueinfo __NR_rt_tgsigqueueinfo #endif #ifdef __NR_rtas # define SYS_rtas __NR_rtas #endif #ifdef __NR_s390_guarded_storage # define SYS_s390_guarded_storage __NR_s390_guarded_storage #endif #ifdef __NR_s390_pci_mmio_read # define SYS_s390_pci_mmio_read __NR_s390_pci_mmio_read #endif #ifdef __NR_s390_pci_mmio_write # define SYS_s390_pci_mmio_write __NR_s390_pci_mmio_write #endif #ifdef __NR_s390_runtime_instr # define SYS_s390_runtime_instr __NR_s390_runtime_instr #endif #ifdef __NR_s390_sthyi # define SYS_s390_sthyi __NR_s390_sthyi #endif #ifdef __NR_sched_get_affinity # define SYS_sched_get_affinity __NR_sched_get_affinity #endif #ifdef __NR_sched_get_priority_max # define SYS_sched_get_priority_max __NR_sched_get_priority_max #endif #ifdef __NR_sched_get_priority_min # define SYS_sched_get_priority_min __NR_sched_get_priority_min #endif #ifdef __NR_sched_getaffinity # define SYS_sched_getaffinity __NR_sched_getaffinity #endif #ifdef __NR_sched_getattr # define SYS_sched_getattr __NR_sched_getattr #endif #ifdef __NR_sched_getparam # define SYS_sched_getparam __NR_sched_getparam #endif #ifdef __NR_sched_getscheduler # define SYS_sched_getscheduler __NR_sched_getscheduler #endif #ifdef __NR_sched_rr_get_interval # define SYS_sched_rr_get_interval __NR_sched_rr_get_interval #endif #ifdef __NR_sched_rr_get_interval_time64 # define SYS_sched_rr_get_interval_time64 __NR_sched_rr_get_interval_time64 #endif #ifdef __NR_sched_set_affinity # define SYS_sched_set_affinity __NR_sched_set_affinity #endif #ifdef __NR_sched_setaffinity # define SYS_sched_setaffinity __NR_sched_setaffinity #endif #ifdef __NR_sched_setattr # define SYS_sched_setattr __NR_sched_setattr #endif #ifdef __NR_sched_setparam # define SYS_sched_setparam __NR_sched_setparam #endif #ifdef __NR_sched_setscheduler # define SYS_sched_setscheduler __NR_sched_setscheduler #endif #ifdef __NR_sched_yield # define SYS_sched_yield __NR_sched_yield #endif #ifdef __NR_seccomp # define SYS_seccomp __NR_seccomp #endif #ifdef __NR_security # define SYS_security __NR_security #endif #ifdef __NR_select # define SYS_select __NR_select #endif #ifdef __NR_semctl # define SYS_semctl __NR_semctl #endif #ifdef __NR_semget # define SYS_semget __NR_semget #endif #ifdef __NR_semop # define SYS_semop __NR_semop #endif #ifdef __NR_semtimedop # define SYS_semtimedop __NR_semtimedop #endif #ifdef __NR_semtimedop_time64 # define SYS_semtimedop_time64 __NR_semtimedop_time64 #endif #ifdef __NR_send # define SYS_send __NR_send #endif #ifdef __NR_sendfile # define SYS_sendfile __NR_sendfile #endif #ifdef __NR_sendfile64 # define SYS_sendfile64 __NR_sendfile64 #endif #ifdef __NR_sendmmsg # define SYS_sendmmsg __NR_sendmmsg #endif #ifdef __NR_sendmsg # define SYS_sendmsg __NR_sendmsg #endif #ifdef __NR_sendto # define SYS_sendto __NR_sendto #endif #ifdef __NR_set_mempolicy # define SYS_set_mempolicy __NR_set_mempolicy #endif #ifdef __NR_set_mempolicy_home_node # define SYS_set_mempolicy_home_node __NR_set_mempolicy_home_node #endif #ifdef __NR_set_robust_list # define SYS_set_robust_list __NR_set_robust_list #endif #ifdef __NR_set_thread_area # define SYS_set_thread_area __NR_set_thread_area #endif #ifdef __NR_set_tid_address # define SYS_set_tid_address __NR_set_tid_address #endif #ifdef __NR_set_tls # define SYS_set_tls __NR_set_tls #endif #ifdef __NR_setdomainname # define SYS_setdomainname __NR_setdomainname #endif #ifdef __NR_setfsgid # define SYS_setfsgid __NR_setfsgid #endif #ifdef __NR_setfsgid32 # define SYS_setfsgid32 __NR_setfsgid32 #endif #ifdef __NR_setfsuid # define SYS_setfsuid __NR_setfsuid #endif #ifdef __NR_setfsuid32 # define SYS_setfsuid32 __NR_setfsuid32 #endif #ifdef __NR_setgid # define SYS_setgid __NR_setgid #endif #ifdef __NR_setgid32 # define SYS_setgid32 __NR_setgid32 #endif #ifdef __NR_setgroups # define SYS_setgroups __NR_setgroups #endif #ifdef __NR_setgroups32 # define SYS_setgroups32 __NR_setgroups32 #endif #ifdef __NR_sethae # define SYS_sethae __NR_sethae #endif #ifdef __NR_sethostname # define SYS_sethostname __NR_sethostname #endif #ifdef __NR_setitimer # define SYS_setitimer __NR_setitimer #endif #ifdef __NR_setns # define SYS_setns __NR_setns #endif #ifdef __NR_setpgid # define SYS_setpgid __NR_setpgid #endif #ifdef __NR_setpgrp # define SYS_setpgrp __NR_setpgrp #endif #ifdef __NR_setpriority # define SYS_setpriority __NR_setpriority #endif #ifdef __NR_setregid # define SYS_setregid __NR_setregid #endif #ifdef __NR_setregid32 # define SYS_setregid32 __NR_setregid32 #endif #ifdef __NR_setresgid # define SYS_setresgid __NR_setresgid #endif #ifdef __NR_setresgid32 # define SYS_setresgid32 __NR_setresgid32 #endif #ifdef __NR_setresuid # define SYS_setresuid __NR_setresuid #endif #ifdef __NR_setresuid32 # define SYS_setresuid32 __NR_setresuid32 #endif #ifdef __NR_setreuid # define SYS_setreuid __NR_setreuid #endif #ifdef __NR_setreuid32 # define SYS_setreuid32 __NR_setreuid32 #endif #ifdef __NR_setrlimit # define SYS_setrlimit __NR_setrlimit #endif #ifdef __NR_setsid # define SYS_setsid __NR_setsid #endif #ifdef __NR_setsockopt # define SYS_setsockopt __NR_setsockopt #endif #ifdef __NR_settimeofday # define SYS_settimeofday __NR_settimeofday #endif #ifdef __NR_setuid # define SYS_setuid __NR_setuid #endif #ifdef __NR_setuid32 # define SYS_setuid32 __NR_setuid32 #endif #ifdef __NR_setxattr # define SYS_setxattr __NR_setxattr #endif #ifdef __NR_sgetmask # define SYS_sgetmask __NR_sgetmask #endif #ifdef __NR_shmat # define SYS_shmat __NR_shmat #endif #ifdef __NR_shmctl # define SYS_shmctl __NR_shmctl #endif #ifdef __NR_shmdt # define SYS_shmdt __NR_shmdt #endif #ifdef __NR_shmget # define SYS_shmget __NR_shmget #endif #ifdef __NR_shutdown # define SYS_shutdown __NR_shutdown #endif #ifdef __NR_sigaction # define SYS_sigaction __NR_sigaction #endif #ifdef __NR_sigaltstack # define SYS_sigaltstack __NR_sigaltstack #endif #ifdef __NR_signal # define SYS_signal __NR_signal #endif #ifdef __NR_signalfd # define SYS_signalfd __NR_signalfd #endif #ifdef __NR_signalfd4 # define SYS_signalfd4 __NR_signalfd4 #endif #ifdef __NR_sigpending # define SYS_sigpending __NR_sigpending #endif #ifdef __NR_sigprocmask # define SYS_sigprocmask __NR_sigprocmask #endif #ifdef __NR_sigreturn # define SYS_sigreturn __NR_sigreturn #endif #ifdef __NR_sigsuspend # define SYS_sigsuspend __NR_sigsuspend #endif #ifdef __NR_socket # define SYS_socket __NR_socket #endif #ifdef __NR_socketcall # define SYS_socketcall __NR_socketcall #endif #ifdef __NR_socketpair # define SYS_socketpair __NR_socketpair #endif #ifdef __NR_splice # define SYS_splice __NR_splice #endif #ifdef __NR_spu_create # define SYS_spu_create __NR_spu_create #endif #ifdef __NR_spu_run # define SYS_spu_run __NR_spu_run #endif #ifdef __NR_ssetmask # define SYS_ssetmask __NR_ssetmask #endif #ifdef __NR_stat # define SYS_stat __NR_stat #endif #ifdef __NR_stat64 # define SYS_stat64 __NR_stat64 #endif #ifdef __NR_statfs # define SYS_statfs __NR_statfs #endif #ifdef __NR_statfs64 # define SYS_statfs64 __NR_statfs64 #endif #ifdef __NR_statmount # define SYS_statmount __NR_statmount #endif #ifdef __NR_statx # define SYS_statx __NR_statx #endif #ifdef __NR_stime # define SYS_stime __NR_stime #endif #ifdef __NR_stty # define SYS_stty __NR_stty #endif #ifdef __NR_subpage_prot # define SYS_subpage_prot __NR_subpage_prot #endif #ifdef __NR_swapcontext # define SYS_swapcontext __NR_swapcontext #endif #ifdef __NR_swapoff # define SYS_swapoff __NR_swapoff #endif #ifdef __NR_swapon # define SYS_swapon __NR_swapon #endif #ifdef __NR_switch_endian # define SYS_switch_endian __NR_switch_endian #endif #ifdef __NR_symlink # define SYS_symlink __NR_symlink #endif #ifdef __NR_symlinkat # define SYS_symlinkat __NR_symlinkat #endif #ifdef __NR_sync # define SYS_sync __NR_sync #endif #ifdef __NR_sync_file_range # define SYS_sync_file_range __NR_sync_file_range #endif #ifdef __NR_sync_file_range2 # define SYS_sync_file_range2 __NR_sync_file_range2 #endif #ifdef __NR_syncfs # define SYS_syncfs __NR_syncfs #endif #ifdef __NR_sys_debug_setcontext # define SYS_sys_debug_setcontext __NR_sys_debug_setcontext #endif #ifdef __NR_sys_epoll_create # define SYS_sys_epoll_create __NR_sys_epoll_create #endif #ifdef __NR_sys_epoll_ctl # define SYS_sys_epoll_ctl __NR_sys_epoll_ctl #endif #ifdef __NR_sys_epoll_wait # define SYS_sys_epoll_wait __NR_sys_epoll_wait #endif #ifdef __NR_syscall # define SYS_syscall __NR_syscall #endif #ifdef __NR_sysfs # define SYS_sysfs __NR_sysfs #endif #ifdef __NR_sysinfo # define SYS_sysinfo __NR_sysinfo #endif #ifdef __NR_syslog # define SYS_syslog __NR_syslog #endif #ifdef __NR_sysmips # define SYS_sysmips __NR_sysmips #endif #ifdef __NR_tee # define SYS_tee __NR_tee #endif #ifdef __NR_tgkill # define SYS_tgkill __NR_tgkill #endif #ifdef __NR_time # define SYS_time __NR_time #endif #ifdef __NR_timer_create # define SYS_timer_create __NR_timer_create #endif #ifdef __NR_timer_delete # define SYS_timer_delete __NR_timer_delete #endif #ifdef __NR_timer_getoverrun # define SYS_timer_getoverrun __NR_timer_getoverrun #endif #ifdef __NR_timer_gettime # define SYS_timer_gettime __NR_timer_gettime #endif #ifdef __NR_timer_gettime64 # define SYS_timer_gettime64 __NR_timer_gettime64 #endif #ifdef __NR_timer_settime # define SYS_timer_settime __NR_timer_settime #endif #ifdef __NR_timer_settime64 # define SYS_timer_settime64 __NR_timer_settime64 #endif #ifdef __NR_timerfd # define SYS_timerfd __NR_timerfd #endif #ifdef __NR_timerfd_create # define SYS_timerfd_create __NR_timerfd_create #endif #ifdef __NR_timerfd_gettime # define SYS_timerfd_gettime __NR_timerfd_gettime #endif #ifdef __NR_timerfd_gettime64 # define SYS_timerfd_gettime64 __NR_timerfd_gettime64 #endif #ifdef __NR_timerfd_settime # define SYS_timerfd_settime __NR_timerfd_settime #endif #ifdef __NR_timerfd_settime64 # define SYS_timerfd_settime64 __NR_timerfd_settime64 #endif #ifdef __NR_times # define SYS_times __NR_times #endif #ifdef __NR_tkill # define SYS_tkill __NR_tkill #endif #ifdef __NR_truncate # define SYS_truncate __NR_truncate #endif #ifdef __NR_truncate64 # define SYS_truncate64 __NR_truncate64 #endif #ifdef __NR_tuxcall # define SYS_tuxcall __NR_tuxcall #endif #ifdef __NR_udftrap # define SYS_udftrap __NR_udftrap #endif #ifdef __NR_ugetrlimit # define SYS_ugetrlimit __NR_ugetrlimit #endif #ifdef __NR_ulimit # define SYS_ulimit __NR_ulimit #endif #ifdef __NR_umask # define SYS_umask __NR_umask #endif #ifdef __NR_umount # define SYS_umount __NR_umount #endif #ifdef __NR_umount2 # define SYS_umount2 __NR_umount2 #endif #ifdef __NR_uname # define SYS_uname __NR_uname #endif #ifdef __NR_unlink # define SYS_unlink __NR_unlink #endif #ifdef __NR_unlinkat # define SYS_unlinkat __NR_unlinkat #endif #ifdef __NR_unshare # define SYS_unshare __NR_unshare #endif #ifdef __NR_uselib # define SYS_uselib __NR_uselib #endif #ifdef __NR_userfaultfd # define SYS_userfaultfd __NR_userfaultfd #endif #ifdef __NR_usr26 # define SYS_usr26 __NR_usr26 #endif #ifdef __NR_usr32 # define SYS_usr32 __NR_usr32 #endif #ifdef __NR_ustat # define SYS_ustat __NR_ustat #endif #ifdef __NR_utime # define SYS_utime __NR_utime #endif #ifdef __NR_utimensat # define SYS_utimensat __NR_utimensat #endif #ifdef __NR_utimensat_time64 # define SYS_utimensat_time64 __NR_utimensat_time64 #endif #ifdef __NR_utimes # define SYS_utimes __NR_utimes #endif #ifdef __NR_utrap_install # define SYS_utrap_install __NR_utrap_install #endif #ifdef __NR_vfork # define SYS_vfork __NR_vfork #endif #ifdef __NR_vhangup # define SYS_vhangup __NR_vhangup #endif #ifdef __NR_vm86 # define SYS_vm86 __NR_vm86 #endif #ifdef __NR_vm86old # define SYS_vm86old __NR_vm86old #endif #ifdef __NR_vmsplice # define SYS_vmsplice __NR_vmsplice #endif #ifdef __NR_vserver # define SYS_vserver __NR_vserver #endif #ifdef __NR_wait4 # define SYS_wait4 __NR_wait4 #endif #ifdef __NR_waitid # define SYS_waitid __NR_waitid #endif #ifdef __NR_waitpid # define SYS_waitpid __NR_waitpid #endif #ifdef __NR_write # define SYS_write __NR_write #endif #ifdef __NR_writev # define SYS_writev __NR_writev #endif local_lim.h 0000644 00000006150 15125171642 0006656 0 ustar 00 /* Minimum guaranteed maximum values for system limits. Linux version. Copyright (C) 1993-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; see the file COPYING.LIB. If not, see <https://www.gnu.org/licenses/>. */ /* The kernel header pollutes the namespace with the NR_OPEN symbol and defines LINK_MAX although filesystems have different maxima. A similar thing is true for OPEN_MAX: the limit can be changed at runtime and therefore the macro must not be defined. Remove this after including the header if necessary. */ #ifndef NR_OPEN # define __undef_NR_OPEN #endif #ifndef LINK_MAX # define __undef_LINK_MAX #endif #ifndef OPEN_MAX # define __undef_OPEN_MAX #endif #ifndef ARG_MAX # define __undef_ARG_MAX #endif /* The kernel sources contain a file with all the needed information. */ #include <linux/limits.h> /* Have to remove NR_OPEN? */ #ifdef __undef_NR_OPEN # undef NR_OPEN # undef __undef_NR_OPEN #endif /* Have to remove LINK_MAX? */ #ifdef __undef_LINK_MAX # undef LINK_MAX # undef __undef_LINK_MAX #endif /* Have to remove OPEN_MAX? */ #ifdef __undef_OPEN_MAX # undef OPEN_MAX # undef __undef_OPEN_MAX #endif /* Have to remove ARG_MAX? */ #ifdef __undef_ARG_MAX # undef ARG_MAX # undef __undef_ARG_MAX #endif /* The number of data keys per process. */ #define _POSIX_THREAD_KEYS_MAX 128 /* This is the value this implementation supports. */ #define PTHREAD_KEYS_MAX 1024 /* Controlling the iterations of destructors for thread-specific data. */ #define _POSIX_THREAD_DESTRUCTOR_ITERATIONS 4 /* Number of iterations this implementation does. */ #define PTHREAD_DESTRUCTOR_ITERATIONS _POSIX_THREAD_DESTRUCTOR_ITERATIONS /* The number of threads per process. */ #define _POSIX_THREAD_THREADS_MAX 64 /* We have no predefined limit on the number of threads. */ #undef PTHREAD_THREADS_MAX /* Maximum amount by which a process can descrease its asynchronous I/O priority level. */ #define AIO_PRIO_DELTA_MAX 20 /* Arrange for the definition of PTHREAD_STACK_MIN. */ #include <bits/pthread_stack_min-dynamic.h> /* Maximum number of timer expiration overruns. */ #define DELAYTIMER_MAX 2147483647 /* Maximum tty name length. */ #define TTY_NAME_MAX 32 /* Maximum login name length. This is arbitrary. */ #define LOGIN_NAME_MAX 256 /* Maximum host name length. */ #define HOST_NAME_MAX 64 /* Maximum message queue priority level. */ #define MQ_PRIO_MAX 32768 /* Maximum value the semaphore can have. */ #define SEM_VALUE_MAX (2147483647) typesizes.h 0000644 00000007231 15125171642 0006763 0 ustar 00 /* bits/typesizes.h -- underlying types for *_t. Linux/x86-64 version. Copyright (C) 2012-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _BITS_TYPES_H # error "Never include <bits/typesizes.h> directly; use <sys/types.h> instead." #endif #ifndef _BITS_TYPESIZES_H #define _BITS_TYPESIZES_H 1 /* See <bits/types.h> for the meaning of these macros. This file exists so that <bits/types.h> need not vary across different GNU platforms. */ /* X32 kernel interface is 64-bit. */ #if defined __x86_64__ && defined __ILP32__ # define __SYSCALL_SLONG_TYPE __SQUAD_TYPE # define __SYSCALL_ULONG_TYPE __UQUAD_TYPE #else # define __SYSCALL_SLONG_TYPE __SLONGWORD_TYPE # define __SYSCALL_ULONG_TYPE __ULONGWORD_TYPE #endif #define __DEV_T_TYPE __UQUAD_TYPE #define __UID_T_TYPE __U32_TYPE #define __GID_T_TYPE __U32_TYPE #define __INO_T_TYPE __SYSCALL_ULONG_TYPE #define __INO64_T_TYPE __UQUAD_TYPE #define __MODE_T_TYPE __U32_TYPE #ifdef __x86_64__ # define __NLINK_T_TYPE __SYSCALL_ULONG_TYPE # define __FSWORD_T_TYPE __SYSCALL_SLONG_TYPE #else # define __NLINK_T_TYPE __UWORD_TYPE # define __FSWORD_T_TYPE __SWORD_TYPE #endif #define __OFF_T_TYPE __SYSCALL_SLONG_TYPE #define __OFF64_T_TYPE __SQUAD_TYPE #define __PID_T_TYPE __S32_TYPE #define __RLIM_T_TYPE __SYSCALL_ULONG_TYPE #define __RLIM64_T_TYPE __UQUAD_TYPE #define __BLKCNT_T_TYPE __SYSCALL_SLONG_TYPE #define __BLKCNT64_T_TYPE __SQUAD_TYPE #define __FSBLKCNT_T_TYPE __SYSCALL_ULONG_TYPE #define __FSBLKCNT64_T_TYPE __UQUAD_TYPE #define __FSFILCNT_T_TYPE __SYSCALL_ULONG_TYPE #define __FSFILCNT64_T_TYPE __UQUAD_TYPE #define __ID_T_TYPE __U32_TYPE #define __CLOCK_T_TYPE __SYSCALL_SLONG_TYPE #define __TIME_T_TYPE __SYSCALL_SLONG_TYPE #define __USECONDS_T_TYPE __U32_TYPE #define __SUSECONDS_T_TYPE __SYSCALL_SLONG_TYPE #define __SUSECONDS64_T_TYPE __SQUAD_TYPE #define __DADDR_T_TYPE __S32_TYPE #define __KEY_T_TYPE __S32_TYPE #define __CLOCKID_T_TYPE __S32_TYPE #define __TIMER_T_TYPE void * #define __BLKSIZE_T_TYPE __SYSCALL_SLONG_TYPE #define __FSID_T_TYPE struct { int __val[2]; } #define __SSIZE_T_TYPE __SWORD_TYPE #define __CPU_MASK_TYPE __SYSCALL_ULONG_TYPE #ifdef __x86_64__ /* Tell the libc code that off_t and off64_t are actually the same type for all ABI purposes, even if possibly expressed as different base types for C type-checking purposes. */ # define __OFF_T_MATCHES_OFF64_T 1 /* Same for ino_t and ino64_t. */ # define __INO_T_MATCHES_INO64_T 1 /* And for __rlim_t and __rlim64_t. */ # define __RLIM_T_MATCHES_RLIM64_T 1 /* And for fsblkcnt_t, fsblkcnt64_t, fsfilcnt_t and fsfilcnt64_t. */ # define __STATFS_MATCHES_STATFS64 1 /* And for getitimer, setitimer and rusage */ # define __KERNEL_OLD_TIMEVAL_MATCHES_TIMEVAL64 1 #else # define __RLIM_T_MATCHES_RLIM64_T 0 # define __STATFS_MATCHES_STATFS64 0 # define __KERNEL_OLD_TIMEVAL_MATCHES_TIMEVAL64 0 #endif /* Number of descriptors that can fit in an `fd_set'. */ #define __FD_SETSIZE 1024 #endif /* bits/typesizes.h */ setjmp2.h 0000644 00000003251 15125171642 0006306 0 ustar 00 /* Checking macros for setjmp functions. Copyright (C) 2009-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _SETJMP_H # error "Never include <bits/setjmp2.h> directly; use <setjmp.h> instead." #endif /* Variant of the longjmp functions which perform some sanity checking. */ #ifdef __REDIRECT_NTH extern void __REDIRECT_NTHNL (longjmp, (struct __jmp_buf_tag __env[1], int __val), __longjmp_chk) __attribute__ ((__noreturn__)); extern void __REDIRECT_NTHNL (_longjmp, (struct __jmp_buf_tag __env[1], int __val), __longjmp_chk) __attribute__ ((__noreturn__)); extern void __REDIRECT_NTHNL (siglongjmp, (struct __jmp_buf_tag __env[1], int __val), __longjmp_chk) __attribute__ ((__noreturn__)); #else extern void __longjmp_chk (struct __jmp_buf_tag __env[1], int __val), __THROWNL __attribute__ ((__noreturn__)); # define longjmp __longjmp_chk # define _longjmp __longjmp_chk # define siglongjmp __longjmp_chk #endif shm.h 0000644 00000005316 15125171642 0005515 0 ustar 00 /* Copyright (C) 1995-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _SYS_SHM_H # error "Never include <bits/shm.h> directly; use <sys/shm.h> instead." #endif #include <bits/types.h> #include <bits/wordsize.h> #include <bits/shmlba.h> /* Permission flag for shmget. */ #define SHM_R 0400 /* or S_IRUGO from <linux/stat.h> */ #define SHM_W 0200 /* or S_IWUGO from <linux/stat.h> */ /* Flags for `shmat'. */ #define SHM_RDONLY 010000 /* attach read-only else read-write */ #define SHM_RND 020000 /* round attach address to SHMLBA */ #define SHM_REMAP 040000 /* take-over region on attach */ #define SHM_EXEC 0100000 /* execution access */ /* Commands for `shmctl'. */ #define SHM_LOCK 11 /* lock segment (root only) */ #define SHM_UNLOCK 12 /* unlock segment (root only) */ __BEGIN_DECLS /* Type to count number of attaches. */ typedef __syscall_ulong_t shmatt_t; #include <bits/types/struct_shmid_ds.h> #include <bits/types/struct_shmid64_ds.h> #ifdef __USE_MISC /* ipcs ctl commands */ # define SHM_STAT 13 # define SHM_INFO 14 # define SHM_STAT_ANY 15 /* shm_mode upper byte flags */ # define SHM_DEST 01000 /* segment will be destroyed on last detach */ # define SHM_LOCKED 02000 /* segment will not be swapped */ # define SHM_HUGETLB 04000 /* segment is mapped via hugetlb */ # define SHM_NORESERVE 010000 /* don't check for reservations */ struct shminfo { __syscall_ulong_t shmmax; __syscall_ulong_t shmmin; __syscall_ulong_t shmmni; __syscall_ulong_t shmseg; __syscall_ulong_t shmall; __syscall_ulong_t __glibc_reserved1; __syscall_ulong_t __glibc_reserved2; __syscall_ulong_t __glibc_reserved3; __syscall_ulong_t __glibc_reserved4; }; struct shm_info { int used_ids; __syscall_ulong_t shm_tot; /* total allocated shm */ __syscall_ulong_t shm_rss; /* total resident shm */ __syscall_ulong_t shm_swp; /* total swapped shm */ __syscall_ulong_t swap_attempts; __syscall_ulong_t swap_successes; }; #endif /* __USE_MISC */ __END_DECLS ipc.h 0000644 00000002763 15125171642 0005504 0 ustar 00 /* Copyright (C) 1995-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _SYS_IPC_H # error "Never use <bits/ipc.h> directly; include <sys/ipc.h> instead." #endif #include <bits/types.h> /* Mode bits for `msgget', `semget', and `shmget'. */ #define IPC_CREAT 01000 /* Create key if key does not exist. */ #define IPC_EXCL 02000 /* Fail if key exists. */ #define IPC_NOWAIT 04000 /* Return error on wait. */ /* Control commands for `msgctl', `semctl', and `shmctl'. */ #define IPC_RMID 0 /* Remove identifier. */ #define IPC_SET 1 /* Set `ipc_perm' options. */ #define IPC_STAT 2 /* Get `ipc_perm' options. */ #ifdef __USE_GNU # define IPC_INFO 3 /* See ipcs. */ #endif /* Special key values. */ #define IPC_PRIVATE ((__key_t) 0) /* Private key. */ #include <bits/ipc-perm.h> stdio_lim.h 0000644 00000002275 15125171642 0006712 0 ustar 00 /* Copyright (C) 1994-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _BITS_STDIO_LIM_H #define _BITS_STDIO_LIM_H 1 #ifndef _STDIO_H # error "Never include <bits/stdio_lim.h> directly; use <stdio.h> instead." #endif #define L_tmpnam 20 #define TMP_MAX 238328 #define FILENAME_MAX 4096 #ifdef __USE_POSIX # define L_ctermid 9 # if !defined __USE_XOPEN2K || defined __USE_GNU # define L_cuserid 9 # endif #endif #undef FOPEN_MAX #define FOPEN_MAX 16 #endif /* bits/stdio_lim.h */ sigstksz.h 0000644 00000002376 15125171642 0006612 0 ustar 00 /* Definition of MINSIGSTKSZ and SIGSTKSZ. Linux version. Copyright (C) 2020 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _SIGNAL_H # error "Never include <bits/sigstksz.h> directly; use <signal.h> instead." #endif #if defined __USE_DYNAMIC_STACK_SIZE && __USE_DYNAMIC_STACK_SIZE # include <unistd.h> /* Default stack size for a signal handler: sysconf (SC_SIGSTKSZ). */ # undef SIGSTKSZ # define SIGSTKSZ sysconf (_SC_SIGSTKSZ) /* Minimum stack size for a signal handler: SIGSTKSZ. */ # undef MINSIGSTKSZ # define MINSIGSTKSZ SIGSTKSZ #endif semaphore.h 0000644 00000002277 15125171642 0006714 0 ustar 00 /* Generic POSIX semaphore type layout Copyright (C) 1995-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _SEMAPHORE_H # error "Never use <bits/semaphore.h> directly; include <semaphore.h> instead." #endif #include <bits/wordsize.h> #if __WORDSIZE == 64 # define __SIZEOF_SEM_T 32 #else # define __SIZEOF_SEM_T 16 #endif /* Value returned if `sem_open' failed. */ #define SEM_FAILED ((sem_t *) 0) typedef union { char __size[__SIZEOF_SEM_T]; long int __align; } sem_t; getopt_posix.h 0000644 00000003422 15125171642 0007446 0 ustar 00 /* Declarations for getopt (POSIX compatibility shim). Copyright (C) 1989-2021 Free Software Foundation, Inc. Unlike the bulk of the getopt implementation, this file is NOT part of gnulib. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _GETOPT_POSIX_H #define _GETOPT_POSIX_H 1 #if !defined _UNISTD_H && !defined _STDIO_H #error "Never include getopt_posix.h directly; use unistd.h instead." #endif #include <bits/getopt_core.h> __BEGIN_DECLS #if defined __USE_POSIX2 && !defined __USE_POSIX_IMPLICITLY \ && !defined __USE_GNU && !defined _GETOPT_H /* GNU getopt has more functionality than POSIX getopt. When we are explicitly conforming to POSIX and not GNU, and getopt.h (which is not part of POSIX) has not been included, the extra functionality is disabled. */ # ifdef __REDIRECT extern int __REDIRECT_NTH (getopt, (int ___argc, char *const *___argv, const char *__shortopts), __posix_getopt); # else extern int __posix_getopt (int ___argc, char *const *___argv, const char *__shortopts) __THROW __nonnull ((2, 3)); # define getopt __posix_getopt # endif #endif __END_DECLS #endif /* getopt_posix.h */ statx-generic.h 0000644 00000004213 15125171642 0007476 0 ustar 00 /* Generic statx-related definitions and declarations. Copyright (C) 2018-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ /* This interface is based on <linux/stat.h> in Linux. */ #ifndef _SYS_STAT_H # error Never include <bits/statx-generic.h> directly, include <sys/stat.h> instead. #endif #include <bits/types/struct_statx_timestamp.h> #include <bits/types/struct_statx.h> #ifndef STATX_TYPE # define STATX_TYPE 0x0001U # define STATX_MODE 0x0002U # define STATX_NLINK 0x0004U # define STATX_UID 0x0008U # define STATX_GID 0x0010U # define STATX_ATIME 0x0020U # define STATX_MTIME 0x0040U # define STATX_CTIME 0x0080U # define STATX_INO 0x0100U # define STATX_SIZE 0x0200U # define STATX_BLOCKS 0x0400U # define STATX_BASIC_STATS 0x07ffU # define STATX_ALL 0x0fffU # define STATX_BTIME 0x0800U # define STATX_MNT_ID 0x1000U # define STATX__RESERVED 0x80000000U # define STATX_ATTR_COMPRESSED 0x0004 # define STATX_ATTR_IMMUTABLE 0x0010 # define STATX_ATTR_APPEND 0x0020 # define STATX_ATTR_NODUMP 0x0040 # define STATX_ATTR_ENCRYPTED 0x0800 # define STATX_ATTR_AUTOMOUNT 0x1000 # define STATX_ATTR_MOUNT_ROOT 0x2000 # define STATX_ATTR_VERITY 0x100000 # define STATX_ATTR_DAX 0x200000 #endif /* !STATX_TYPE */ __BEGIN_DECLS /* Fill *BUF with information about PATH in DIRFD. */ int statx (int __dirfd, const char *__restrict __path, int __flags, unsigned int __mask, struct statx *__restrict __buf) __THROW __nonnull ((2, 5)); __END_DECLS in.h 0000644 00000022574 15125171642 0005341 0 ustar 00 /* Copyright (C) 1991-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ /* Linux version. */ #ifndef _NETINET_IN_H # error "Never use <bits/in.h> directly; include <netinet/in.h> instead." #endif /* If the application has already included linux/in6.h from a linux-based kernel then we will not define the IPv6 IPPROTO_* defines, in6_addr (nor the defines), sockaddr_in6, or ipv6_mreq. Same for in6_ptkinfo or ip6_mtuinfo in linux/ipv6.h. The ABI used by the linux-kernel and glibc match exactly. Neither the linux kernel nor glibc should break this ABI without coordination. In upstream kernel 56c176c9 the _UAPI prefix was stripped so we need to check for _LINUX_IN6_H and _IPV6_H now, and keep checking the old versions for maximum backwards compatibility. */ #if defined _UAPI_LINUX_IN6_H \ || defined _UAPI_IPV6_H \ || defined _LINUX_IN6_H \ || defined _IPV6_H /* This is not quite the same API since the kernel always defines s6_addr16 and s6_addr32. This is not a violation of POSIX since POSIX says "at least the following member" and that holds true. */ # define __USE_KERNEL_IPV6_DEFS 1 #else # define __USE_KERNEL_IPV6_DEFS 0 #endif /* Options for use with `getsockopt' and `setsockopt' at the IP level. The first word in the comment at the right is the data type used; "bool" means a boolean value stored in an `int'. */ #define IP_OPTIONS 4 /* ip_opts; IP per-packet options. */ #define IP_HDRINCL 3 /* int; Header is included with data. */ #define IP_TOS 1 /* int; IP type of service and precedence. */ #define IP_TTL 2 /* int; IP time to live. */ #define IP_RECVOPTS 6 /* bool; Receive all IP options w/datagram. */ /* For BSD compatibility. */ #define IP_RECVRETOPTS IP_RETOPTS /* bool; Receive IP options for response. */ #define IP_RETOPTS 7 /* ip_opts; Set/get IP per-packet options. */ #define IP_MULTICAST_IF 32 /* in_addr; set/get IP multicast i/f */ #define IP_MULTICAST_TTL 33 /* unsigned char; set/get IP multicast ttl */ #define IP_MULTICAST_LOOP 34 /* bool; set/get IP multicast loopback */ #define IP_ADD_MEMBERSHIP 35 /* ip_mreq; add an IP group membership */ #define IP_DROP_MEMBERSHIP 36 /* ip_mreq; drop an IP group membership */ #define IP_UNBLOCK_SOURCE 37 /* ip_mreq_source: unblock data from source */ #define IP_BLOCK_SOURCE 38 /* ip_mreq_source: block data from source */ #define IP_ADD_SOURCE_MEMBERSHIP 39 /* ip_mreq_source: join source group */ #define IP_DROP_SOURCE_MEMBERSHIP 40 /* ip_mreq_source: leave source group */ #define IP_MSFILTER 41 #ifdef __USE_MISC # define MCAST_JOIN_GROUP 42 /* group_req: join any-source group */ # define MCAST_BLOCK_SOURCE 43 /* group_source_req: block from given group */ # define MCAST_UNBLOCK_SOURCE 44 /* group_source_req: unblock from given group*/ # define MCAST_LEAVE_GROUP 45 /* group_req: leave any-source group */ # define MCAST_JOIN_SOURCE_GROUP 46 /* group_source_req: join source-spec gr */ # define MCAST_LEAVE_SOURCE_GROUP 47 /* group_source_req: leave source-spec gr*/ # define MCAST_MSFILTER 48 # define IP_MULTICAST_ALL 49 # define IP_UNICAST_IF 50 # define MCAST_EXCLUDE 0 # define MCAST_INCLUDE 1 #endif #define IP_ROUTER_ALERT 5 /* bool */ #define IP_PKTINFO 8 /* bool */ #define IP_PKTOPTIONS 9 #define IP_PMTUDISC 10 /* obsolete name? */ #define IP_MTU_DISCOVER 10 /* int; see below */ #define IP_RECVERR 11 /* bool */ #define IP_RECVTTL 12 /* bool */ #define IP_RECVTOS 13 /* bool */ #define IP_MTU 14 /* int */ #define IP_FREEBIND 15 #define IP_IPSEC_POLICY 16 #define IP_XFRM_POLICY 17 #define IP_PASSSEC 18 #define IP_TRANSPARENT 19 #define IP_MULTICAST_ALL 49 /* bool */ /* TProxy original addresses */ #define IP_ORIGDSTADDR 20 #define IP_RECVORIGDSTADDR IP_ORIGDSTADDR #define IP_MINTTL 21 #define IP_NODEFRAG 22 #define IP_CHECKSUM 23 #define IP_BIND_ADDRESS_NO_PORT 24 #define IP_RECVFRAGSIZE 25 #define IP_RECVERR_RFC4884 26 /* IP_MTU_DISCOVER arguments. */ #define IP_PMTUDISC_DONT 0 /* Never send DF frames. */ #define IP_PMTUDISC_WANT 1 /* Use per route hints. */ #define IP_PMTUDISC_DO 2 /* Always DF. */ #define IP_PMTUDISC_PROBE 3 /* Ignore dst pmtu. */ /* Always use interface mtu (ignores dst pmtu) but don't set DF flag. Also incoming ICMP frag_needed notifications will be ignored on this socket to prevent accepting spoofed ones. */ #define IP_PMTUDISC_INTERFACE 4 /* Like IP_PMTUDISC_INTERFACE but allow packets to be fragmented. */ #define IP_PMTUDISC_OMIT 5 #define IP_MULTICAST_IF 32 #define IP_MULTICAST_TTL 33 #define IP_MULTICAST_LOOP 34 #define IP_ADD_MEMBERSHIP 35 #define IP_DROP_MEMBERSHIP 36 #define IP_UNBLOCK_SOURCE 37 #define IP_BLOCK_SOURCE 38 #define IP_ADD_SOURCE_MEMBERSHIP 39 #define IP_DROP_SOURCE_MEMBERSHIP 40 #define IP_MSFILTER 41 #define IP_MULTICAST_ALL 49 #define IP_UNICAST_IF 50 /* To select the IP level. */ #define SOL_IP 0 #define IP_DEFAULT_MULTICAST_TTL 1 #define IP_DEFAULT_MULTICAST_LOOP 1 #define IP_MAX_MEMBERSHIPS 20 #ifdef __USE_MISC /* Structure used to describe IP options for IP_OPTIONS and IP_RETOPTS. The `ip_dst' field is used for the first-hop gateway when using a source route (this gets put into the header proper). */ struct ip_opts { struct in_addr ip_dst; /* First hop; zero without source route. */ char ip_opts[40]; /* Actually variable in size. */ }; /* Like `struct ip_mreq' but including interface specification by index. */ struct ip_mreqn { struct in_addr imr_multiaddr; /* IP multicast address of group */ struct in_addr imr_address; /* local IP address of interface */ int imr_ifindex; /* Interface index */ }; /* Structure used for IP_PKTINFO. */ struct in_pktinfo { int ipi_ifindex; /* Interface index */ struct in_addr ipi_spec_dst; /* Routing destination address */ struct in_addr ipi_addr; /* Header destination address */ }; #endif /* Options for use with `getsockopt' and `setsockopt' at the IPv6 level. The first word in the comment at the right is the data type used; "bool" means a boolean value stored in an `int'. */ #define IPV6_ADDRFORM 1 #define IPV6_2292PKTINFO 2 #define IPV6_2292HOPOPTS 3 #define IPV6_2292DSTOPTS 4 #define IPV6_2292RTHDR 5 #define IPV6_2292PKTOPTIONS 6 #define IPV6_CHECKSUM 7 #define IPV6_2292HOPLIMIT 8 #define SCM_SRCRT IPV6_RXSRCRT #define IPV6_NEXTHOP 9 #define IPV6_AUTHHDR 10 #define IPV6_UNICAST_HOPS 16 #define IPV6_MULTICAST_IF 17 #define IPV6_MULTICAST_HOPS 18 #define IPV6_MULTICAST_LOOP 19 #define IPV6_JOIN_GROUP 20 #define IPV6_LEAVE_GROUP 21 #define IPV6_ROUTER_ALERT 22 #define IPV6_MTU_DISCOVER 23 #define IPV6_MTU 24 #define IPV6_RECVERR 25 #define IPV6_V6ONLY 26 #define IPV6_JOIN_ANYCAST 27 #define IPV6_LEAVE_ANYCAST 28 #define IPV6_MULTICAST_ALL 29 #define IPV6_ROUTER_ALERT_ISOLATE 30 #define IPV6_RECVERR_RFC4884 31 #define IPV6_IPSEC_POLICY 34 #define IPV6_XFRM_POLICY 35 #define IPV6_HDRINCL 36 /* Advanced API (RFC3542) (1). */ #define IPV6_RECVPKTINFO 49 #define IPV6_PKTINFO 50 #define IPV6_RECVHOPLIMIT 51 #define IPV6_HOPLIMIT 52 #define IPV6_RECVHOPOPTS 53 #define IPV6_HOPOPTS 54 #define IPV6_RTHDRDSTOPTS 55 #define IPV6_RECVRTHDR 56 #define IPV6_RTHDR 57 #define IPV6_RECVDSTOPTS 58 #define IPV6_DSTOPTS 59 #define IPV6_RECVPATHMTU 60 #define IPV6_PATHMTU 61 #define IPV6_DONTFRAG 62 /* Advanced API (RFC3542) (2). */ #define IPV6_RECVTCLASS 66 #define IPV6_TCLASS 67 #define IPV6_AUTOFLOWLABEL 70 /* RFC5014. */ #define IPV6_ADDR_PREFERENCES 72 /* RFC5082. */ #define IPV6_MINHOPCOUNT 73 #define IPV6_ORIGDSTADDR 74 #define IPV6_RECVORIGDSTADDR IPV6_ORIGDSTADDR #define IPV6_TRANSPARENT 75 #define IPV6_UNICAST_IF 76 #define IPV6_RECVFRAGSIZE 77 #define IPV6_FREEBIND 78 /* Obsolete synonyms for the above. */ #if !__USE_KERNEL_IPV6_DEFS # define IPV6_ADD_MEMBERSHIP IPV6_JOIN_GROUP # define IPV6_DROP_MEMBERSHIP IPV6_LEAVE_GROUP #endif #define IPV6_RXHOPOPTS IPV6_HOPOPTS #define IPV6_RXDSTOPTS IPV6_DSTOPTS /* IPV6_MTU_DISCOVER values. */ #define IPV6_PMTUDISC_DONT 0 /* Never send DF frames. */ #define IPV6_PMTUDISC_WANT 1 /* Use per route hints. */ #define IPV6_PMTUDISC_DO 2 /* Always DF. */ #define IPV6_PMTUDISC_PROBE 3 /* Ignore dst pmtu. */ #define IPV6_PMTUDISC_INTERFACE 4 /* See IP_PMTUDISC_INTERFACE. */ #define IPV6_PMTUDISC_OMIT 5 /* See IP_PMTUDISC_OMIT. */ /* Socket level values for IPv6. */ #define SOL_IPV6 41 #define SOL_ICMPV6 58 /* Routing header options for IPv6. */ #define IPV6_RTHDR_LOOSE 0 /* Hop doesn't need to be neighbour. */ #define IPV6_RTHDR_STRICT 1 /* Hop must be a neighbour. */ #define IPV6_RTHDR_TYPE_0 0 /* IPv6 Routing header type 0. */ struct_rwlock.h 0000644 00000003753 15125171642 0007636 0 ustar 00 /* x86 internal rwlock struct definitions. Copyright (C) 2019-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <http://www.gnu.org/licenses/>. */ #ifndef _RWLOCK_INTERNAL_H #define _RWLOCK_INTERNAL_H struct __pthread_rwlock_arch_t { unsigned int __readers; unsigned int __writers; unsigned int __wrphase_futex; unsigned int __writers_futex; unsigned int __pad3; unsigned int __pad4; #ifdef __x86_64__ int __cur_writer; int __shared; signed char __rwelision; # ifdef __ILP32__ unsigned char __pad1[3]; # define __PTHREAD_RWLOCK_ELISION_EXTRA 0, { 0, 0, 0 } # else unsigned char __pad1[7]; # define __PTHREAD_RWLOCK_ELISION_EXTRA 0, { 0, 0, 0, 0, 0, 0, 0 } # endif unsigned long int __pad2; /* FLAGS must stay at this position in the structure to maintain binary compatibility. */ unsigned int __flags; #else /* __x86_64__ */ /* FLAGS must stay at this position in the structure to maintain binary compatibility. */ unsigned char __flags; unsigned char __shared; signed char __rwelision; unsigned char __pad2; int __cur_writer; #endif }; #ifdef __x86_64__ # define __PTHREAD_RWLOCK_INITIALIZER(__flags) \ 0, 0, 0, 0, 0, 0, 0, 0, __PTHREAD_RWLOCK_ELISION_EXTRA, 0, __flags #else # define __PTHREAD_RWLOCK_INITIALIZER(__flags) \ 0, 0, 0, 0, 0, 0, __flags, 0, 0, 0, 0 #endif #endif statx.h 0000644 00000002570 15125171642 0006070 0 ustar 00 /* statx-related definitions and declarations. Linux version. Copyright (C) 2018-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ /* This interface is based on <linux/stat.h> in Linux. */ #ifndef _SYS_STAT_H # error Never include <bits/statx.h> directly, include <sys/stat.h> instead. #endif /* Use the Linux kernel header if available. */ /* Use "" to work around incorrect macro expansion of the __has_include argument (GCC PR 80005). */ #ifdef __has_include # if __has_include ("linux/stat.h") # include "linux/stat.h" # ifdef STATX_TYPE # define __statx_timestamp_defined 1 # define __statx_defined 1 # endif # endif #endif #include <bits/statx-generic.h> environments.h 0000644 00000007317 15125171642 0007460 0 ustar 00 /* Copyright (C) 1999-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _UNISTD_H # error "Never include this file directly. Use <unistd.h> instead" #endif #include <bits/wordsize.h> /* This header should define the following symbols under the described situations. A value `1' means that the model is always supported, `-1' means it is never supported. Undefined means it cannot be statically decided. _POSIX_V7_ILP32_OFF32 32bit int, long, pointers, and off_t type _POSIX_V7_ILP32_OFFBIG 32bit int, long, and pointers and larger off_t type _POSIX_V7_LP64_OFF32 64bit long and pointers and 32bit off_t type _POSIX_V7_LPBIG_OFFBIG 64bit long and pointers and large off_t type The macros _POSIX_V6_ILP32_OFF32, _POSIX_V6_ILP32_OFFBIG, _POSIX_V6_LP64_OFF32, _POSIX_V6_LPBIG_OFFBIG, _XBS5_ILP32_OFF32, _XBS5_ILP32_OFFBIG, _XBS5_LP64_OFF32, and _XBS5_LPBIG_OFFBIG were used in previous versions of the Unix standard and are available only for compatibility. */ #if __WORDSIZE == 64 /* Environments with 32-bit wide pointers are optionally provided. Therefore following macros aren't defined: # undef _POSIX_V7_ILP32_OFF32 # undef _POSIX_V7_ILP32_OFFBIG # undef _POSIX_V6_ILP32_OFF32 # undef _POSIX_V6_ILP32_OFFBIG # undef _XBS5_ILP32_OFF32 # undef _XBS5_ILP32_OFFBIG and users need to check at runtime. */ /* We also have no use (for now) for an environment with bigger pointers and offsets. */ # define _POSIX_V7_LPBIG_OFFBIG -1 # define _POSIX_V6_LPBIG_OFFBIG -1 # define _XBS5_LPBIG_OFFBIG -1 /* By default we have 64-bit wide `long int', pointers and `off_t'. */ # define _POSIX_V7_LP64_OFF64 1 # define _POSIX_V6_LP64_OFF64 1 # define _XBS5_LP64_OFF64 1 #else /* __WORDSIZE == 32 */ /* We have 32-bit wide `int', `long int' and pointers and all platforms support LFS. -mx32 has 64-bit wide `off_t'. */ # define _POSIX_V7_ILP32_OFFBIG 1 # define _POSIX_V6_ILP32_OFFBIG 1 # define _XBS5_ILP32_OFFBIG 1 # ifndef __x86_64__ /* -m32 has 32-bit wide `off_t'. */ # define _POSIX_V7_ILP32_OFF32 1 # define _POSIX_V6_ILP32_OFF32 1 # define _XBS5_ILP32_OFF32 1 # endif /* We optionally provide an environment with the above size but an 64-bit side `off_t'. Therefore we don't define _POSIX_V7_ILP32_OFFBIG. */ /* Environments with 64-bit wide pointers can be provided, so these macros aren't defined: # undef _POSIX_V7_LP64_OFF64 # undef _POSIX_V7_LPBIG_OFFBIG # undef _POSIX_V6_LP64_OFF64 # undef _POSIX_V6_LPBIG_OFFBIG # undef _XBS5_LP64_OFF64 # undef _XBS5_LPBIG_OFFBIG and sysconf tests for it at runtime. */ #endif /* __WORDSIZE == 32 */ #define __ILP32_OFF32_CFLAGS "-m32" #define __ILP32_OFF32_LDFLAGS "-m32" #if defined __x86_64__ && defined __ILP32__ # define __ILP32_OFFBIG_CFLAGS "-mx32" # define __ILP32_OFFBIG_LDFLAGS "-mx32" #else # define __ILP32_OFFBIG_CFLAGS "-m32 -D_LARGEFILE_SOURCE -D_FILE_OFFSET_BITS=64" # define __ILP32_OFFBIG_LDFLAGS "-m32" #endif #define __LP64_OFF64_CFLAGS "-m64" #define __LP64_OFF64_LDFLAGS "-m64" floatn.h 0000644 00000010551 15125171642 0006206 0 ustar 00 /* Macros to control TS 18661-3 glibc features on x86. Copyright (C) 2017-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _BITS_FLOATN_H #define _BITS_FLOATN_H #include <features.h> /* Defined to 1 if the current compiler invocation provides a floating-point type with the IEEE 754 binary128 format, and this glibc includes corresponding *f128 interfaces for it. The required libgcc support was added some time after the basic compiler support, for x86_64 and x86. */ #if (defined __x86_64__ \ ? __GNUC_PREREQ (4, 3) \ : (defined __GNU__ ? __GNUC_PREREQ (4, 5) : __GNUC_PREREQ (4, 4))) # define __HAVE_FLOAT128 1 #else # define __HAVE_FLOAT128 0 #endif /* Defined to 1 if __HAVE_FLOAT128 is 1 and the type is ABI-distinct from the default float, double and long double types in this glibc. */ #if __HAVE_FLOAT128 # define __HAVE_DISTINCT_FLOAT128 1 #else # define __HAVE_DISTINCT_FLOAT128 0 #endif /* Defined to 1 if the current compiler invocation provides a floating-point type with the right format for _Float64x, and this glibc includes corresponding *f64x interfaces for it. */ #define __HAVE_FLOAT64X 1 /* Defined to 1 if __HAVE_FLOAT64X is 1 and _Float64x has the format of long double. Otherwise, if __HAVE_FLOAT64X is 1, _Float64x has the format of _Float128, which must be different from that of long double. */ #define __HAVE_FLOAT64X_LONG_DOUBLE 1 #ifndef __ASSEMBLER__ /* Defined to concatenate the literal suffix to be used with _Float128 types, if __HAVE_FLOAT128 is 1. */ # if __HAVE_FLOAT128 # if !__GNUC_PREREQ (7, 0) || (defined __cplusplus && !__GNUC_PREREQ (13, 0)) /* The literal suffix f128 exists only since GCC 7.0. */ # define __f128(x) x##q # else # define __f128(x) x##f128 # endif # endif /* Defined to a complex binary128 type if __HAVE_FLOAT128 is 1. */ # if __HAVE_FLOAT128 # if !__GNUC_PREREQ (7, 0) || (defined __cplusplus && !__GNUC_PREREQ (13, 0)) /* Add a typedef for older GCC compilers which don't natively support _Complex _Float128. */ typedef _Complex float __cfloat128 __attribute__ ((__mode__ (__TC__))); # define __CFLOAT128 __cfloat128 # else # define __CFLOAT128 _Complex _Float128 # endif # endif /* The remaining of this file provides support for older compilers. */ # if __HAVE_FLOAT128 /* The type _Float128 exists only since GCC 7.0. */ # if !__GNUC_PREREQ (7, 0) || (defined __cplusplus && !__GNUC_PREREQ (13, 0)) typedef __float128 _Float128; # endif /* __builtin_huge_valf128 doesn't exist before GCC 7.0. */ # if !__GNUC_PREREQ (7, 0) # define __builtin_huge_valf128() ((_Float128) __builtin_huge_val ()) # endif /* Older GCC has only a subset of built-in functions for _Float128 on x86, and __builtin_infq is not usable in static initializers. Converting a narrower sNaN to _Float128 produces a quiet NaN, so attempts to use _Float128 sNaNs will not work properly with older compilers. */ # if !__GNUC_PREREQ (7, 0) # define __builtin_copysignf128 __builtin_copysignq # define __builtin_fabsf128 __builtin_fabsq # define __builtin_inff128() ((_Float128) __builtin_inf ()) # define __builtin_nanf128(x) ((_Float128) __builtin_nan (x)) # define __builtin_nansf128(x) ((_Float128) __builtin_nans (x)) # endif /* In math/math.h, __MATH_TG will expand signbit to __builtin_signbit*, e.g.: __builtin_signbitf128, before GCC 6. However, there has never been a __builtin_signbitf128 in GCC and the type-generic builtin is only available since GCC 6. */ # if !__GNUC_PREREQ (6, 0) # define __builtin_signbitf128 __signbitf128 # endif # endif #endif /* !__ASSEMBLER__. */ #include <bits/floatn-common.h> #endif /* _BITS_FLOATN_H */ signal_ext.h 0000644 00000002405 15125171642 0007057 0 ustar 00 /* System-specific extensions of <signal.h>, Linux version. Copyright (C) 2019-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _SIGNAL_H # error "Never include <bits/signal_ext.h> directly; use <signal.h> instead." #endif #ifdef __USE_GNU /* Send SIGNAL to the thread TID in the thread group (process) identified by TGID. This function behaves like kill, but also fails with ESRCH if the specified TID does not belong to the specified thread group. */ extern int tgkill (__pid_t __tgid, __pid_t __tid, int __signal); #endif /* __USE_GNU */ endian.h 0000644 00000003561 15125171642 0006164 0 ustar 00 /* Endian macros for string.h functions Copyright (C) 1992-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <http://www.gnu.org/licenses/>. */ #ifndef _BITS_ENDIAN_H #define _BITS_ENDIAN_H 1 /* Definitions for byte order, according to significance of bytes, from low addresses to high addresses. The value is what you get by putting '4' in the most significant byte, '3' in the second most significant byte, '2' in the second least significant byte, and '1' in the least significant byte, and then writing down one digit for each byte, starting with the byte at the lowest address at the left, and proceeding to the byte with the highest address at the right. */ #define __LITTLE_ENDIAN 1234 #define __BIG_ENDIAN 4321 #define __PDP_ENDIAN 3412 /* This file defines `__BYTE_ORDER' for the particular machine. */ #include <bits/endianness.h> /* Some machines may need to use a different endianness for floating point values. */ #ifndef __FLOAT_WORD_ORDER # define __FLOAT_WORD_ORDER __BYTE_ORDER #endif #if __BYTE_ORDER == __LITTLE_ENDIAN # define __LONG_LONG_PAIR(HI, LO) LO, HI #elif __BYTE_ORDER == __BIG_ENDIAN # define __LONG_LONG_PAIR(HI, LO) HI, LO #endif #endif /* bits/endian.h */ ioctl-types.h 0000644 00000004630 15125171642 0007200 0 ustar 00 /* Structure types for pre-termios terminal ioctls. Linux version. Copyright (C) 1996-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _SYS_IOCTL_H # error "Never use <bits/ioctl-types.h> directly; include <sys/ioctl.h> instead." #endif /* Get definition of constants for use with `ioctl'. */ #include <asm/ioctls.h> struct winsize { unsigned short int ws_row; unsigned short int ws_col; unsigned short int ws_xpixel; unsigned short int ws_ypixel; }; #define NCC 8 struct termio { unsigned short int c_iflag; /* input mode flags */ unsigned short int c_oflag; /* output mode flags */ unsigned short int c_cflag; /* control mode flags */ unsigned short int c_lflag; /* local mode flags */ unsigned char c_line; /* line discipline */ unsigned char c_cc[NCC]; /* control characters */ }; /* modem lines */ #define TIOCM_LE 0x001 #define TIOCM_DTR 0x002 #define TIOCM_RTS 0x004 #define TIOCM_ST 0x008 #define TIOCM_SR 0x010 #define TIOCM_CTS 0x020 #define TIOCM_CAR 0x040 #define TIOCM_RNG 0x080 #define TIOCM_DSR 0x100 #define TIOCM_CD TIOCM_CAR #define TIOCM_RI TIOCM_RNG /* ioctl (fd, TIOCSERGETLSR, &result) where result may be as below */ /* line disciplines */ #define N_TTY 0 #define N_SLIP 1 #define N_MOUSE 2 #define N_PPP 3 #define N_STRIP 4 #define N_AX25 5 #define N_X25 6 /* X.25 async */ #define N_6PACK 7 #define N_MASC 8 /* Mobitex module */ #define N_R3964 9 /* Simatic R3964 module */ #define N_PROFIBUS_FDL 10 /* Profibus */ #define N_IRDA 11 /* Linux IR */ #define N_SMSBLOCK 12 /* SMS block mode */ #define N_HDLC 13 /* synchronous HDLC */ #define N_SYNC_PPP 14 /* synchronous PPP */ #define N_HCI 15 /* Bluetooth HCI UART */ mathcalls-narrow.h 0000644 00000002440 15125171642 0010177 0 ustar 00 /* Declare functions returning a narrower type. Copyright (C) 2018-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _MATH_H # error "Never include <bits/mathcalls-narrow.h> directly; include <math.h> instead." #endif /* Add. */ __MATHCALL_NARROW (__MATHCALL_NAME (add), __MATHCALL_REDIR_NAME (add), 2); /* Divide. */ __MATHCALL_NARROW (__MATHCALL_NAME (div), __MATHCALL_REDIR_NAME (div), 2); /* Multiply. */ __MATHCALL_NARROW (__MATHCALL_NAME (mul), __MATHCALL_REDIR_NAME (mul), 2); /* Subtract. */ __MATHCALL_NARROW (__MATHCALL_NAME (sub), __MATHCALL_REDIR_NAME (sub), 2); procfs-extra.h 0000644 00000001703 15125171642 0007337 0 ustar 00 /* Extra sys/procfs.h definitions. Generic Linux version. Copyright (C) 2018-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _SYS_PROCFS_H # error "Never include <bits/procfs-extra.h> directly; use <sys/procfs.h> instead." #endif dlfcn.h 0000644 00000004731 15125171642 0006014 0 ustar 00 /* System dependent definitions for run-time dynamic loading. Copyright (C) 1996-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _DLFCN_H # error "Never use <bits/dlfcn.h> directly; include <dlfcn.h> instead." #endif /* The MODE argument to `dlopen' contains one of the following: */ #define RTLD_LAZY 0x00001 /* Lazy function call binding. */ #define RTLD_NOW 0x00002 /* Immediate function call binding. */ #define RTLD_BINDING_MASK 0x3 /* Mask of binding time value. */ #define RTLD_NOLOAD 0x00004 /* Do not load the object. */ #define RTLD_DEEPBIND 0x00008 /* Use deep binding. */ /* If the following bit is set in the MODE argument to `dlopen', the symbols of the loaded object and its dependencies are made visible as if the object were linked directly into the program. */ #define RTLD_GLOBAL 0x00100 /* Unix98 demands the following flag which is the inverse to RTLD_GLOBAL. The implementation does this by default and so we can define the value to zero. */ #define RTLD_LOCAL 0 /* Do not delete object when closed. */ #define RTLD_NODELETE 0x01000 #ifdef __USE_GNU /* To support profiling of shared objects it is a good idea to call the function found using `dlsym' using the following macro since these calls do not use the PLT. But this would mean the dynamic loader has no chance to find out when the function is called. The macro applies the necessary magic so that profiling is possible. Rewrite foo = (*fctp) (arg1, arg2); into foo = DL_CALL_FCT (fctp, (arg1, arg2)); */ # define DL_CALL_FCT(fctp, args) \ (_dl_mcount_wrapper_check ((void *) (fctp)), (*(fctp)) args) __BEGIN_DECLS /* This function calls the profiling functions. */ extern void _dl_mcount_wrapper_check (void *__selfpc) __THROW; __END_DECLS #endif fp-fast.h 0000644 00000002300 15125171642 0006254 0 ustar 00 /* Define FP_FAST_* macros. Copyright (C) 2016-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _MATH_H # error "Never use <bits/fp-fast.h> directly; include <math.h> instead." #endif #ifdef __USE_ISOC99 /* The GCC 4.6 compiler will define __FP_FAST_FMA{,F,L} if the fma{,f,l} builtins are supported. */ # ifdef __FP_FAST_FMA # define FP_FAST_FMA 1 # endif # ifdef __FP_FAST_FMAF # define FP_FAST_FMAF 1 # endif # ifdef __FP_FAST_FMAL # define FP_FAST_FMAL 1 # endif #endif mman-map-flags-generic.h 0000644 00000003715 15125171642 0011136 0 ustar 00 /* Definitions for POSIX memory map interface. Linux/generic version. Copyright (C) 1997-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library. If not, see <https://www.gnu.org/licenses/>. */ #ifndef _SYS_MMAN_H # error "Never use <bits/mman-map-flags-generic.h> directly; include <sys/mman.h> instead." #endif /* These definitions are appropriate for architectures that, in the Linux kernel, either have no uapi/asm/mman.h, or have one that includes asm-generic/mman.h without any changes to the values of the MAP_* flags defined in that header. */ #ifdef __USE_MISC # define MAP_GROWSDOWN 0x00100 /* Stack-like segment. */ # define MAP_DENYWRITE 0x00800 /* ETXTBSY. */ # define MAP_EXECUTABLE 0x01000 /* Mark it as an executable. */ # define MAP_LOCKED 0x02000 /* Lock the mapping. */ # define MAP_NORESERVE 0x04000 /* Don't check for reservations. */ # define MAP_POPULATE 0x08000 /* Populate (prefault) pagetables. */ # define MAP_NONBLOCK 0x10000 /* Do not block on IO. */ # define MAP_STACK 0x20000 /* Allocation is for a stack. */ # define MAP_HUGETLB 0x40000 /* Create huge page mapping. */ # define MAP_SYNC 0x80000 /* Perform synchronous page faults for the mapping. */ # define MAP_FIXED_NOREPLACE 0x100000 /* MAP_FIXED but do not unmap underlying mapping. */ #endif mathdef.h 0000644 00000001573 15125171642 0006337 0 ustar 00 /* Copyright (C) 1997-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _COMPLEX_H # error "Never use <bits/mathdef.h> directly; include <complex.h> instead" #endif fenv.h 0000644 00000006452 15125171642 0005666 0 ustar 00 /* Copyright (C) 1997-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _FENV_H # error "Never use <bits/fenv.h> directly; include <fenv.h> instead." #endif /* Define bits representing the exception. We use the bit positions of the appropriate bits in the FPU control word. */ enum { FE_INVALID = #define FE_INVALID 0x01 FE_INVALID, __FE_DENORM = 0x02, FE_DIVBYZERO = #define FE_DIVBYZERO 0x04 FE_DIVBYZERO, FE_OVERFLOW = #define FE_OVERFLOW 0x08 FE_OVERFLOW, FE_UNDERFLOW = #define FE_UNDERFLOW 0x10 FE_UNDERFLOW, FE_INEXACT = #define FE_INEXACT 0x20 FE_INEXACT }; #define FE_ALL_EXCEPT \ (FE_INEXACT | FE_DIVBYZERO | FE_UNDERFLOW | FE_OVERFLOW | FE_INVALID) /* The ix87 FPU supports all of the four defined rounding modes. We use again the bit positions in the FPU control word as the values for the appropriate macros. */ enum { FE_TONEAREST = #define FE_TONEAREST 0 FE_TONEAREST, FE_DOWNWARD = #define FE_DOWNWARD 0x400 FE_DOWNWARD, FE_UPWARD = #define FE_UPWARD 0x800 FE_UPWARD, FE_TOWARDZERO = #define FE_TOWARDZERO 0xc00 FE_TOWARDZERO }; /* Type representing exception flags. */ typedef unsigned short int fexcept_t; /* Type representing floating-point environment. This structure corresponds to the layout of the block written by the `fstenv' instruction and has additional fields for the contents of the MXCSR register as written by the `stmxcsr' instruction. */ typedef struct { unsigned short int __control_word; unsigned short int __glibc_reserved1; unsigned short int __status_word; unsigned short int __glibc_reserved2; unsigned short int __tags; unsigned short int __glibc_reserved3; unsigned int __eip; unsigned short int __cs_selector; unsigned int __opcode:11; unsigned int __glibc_reserved4:5; unsigned int __data_offset; unsigned short int __data_selector; unsigned short int __glibc_reserved5; #ifdef __x86_64__ unsigned int __mxcsr; #endif } fenv_t; /* If the default argument is used we use this value. */ #define FE_DFL_ENV ((const fenv_t *) -1) #ifdef __USE_GNU /* Floating-point environment where none of the exception is masked. */ # define FE_NOMASK_ENV ((const fenv_t *) -2) #endif #if __GLIBC_USE (IEC_60559_BFP_EXT_C2X) /* Type representing floating-point control modes. */ typedef struct { unsigned short int __control_word; unsigned short int __glibc_reserved; unsigned int __mxcsr; } femode_t; /* Default floating-point control modes. */ # define FE_DFL_MODE ((const femode_t *) -1L) #endif sockaddr.h 0000644 00000002752 15125171642 0006521 0 ustar 00 /* Definition of struct sockaddr_* common members and sizes, generic version. Copyright (C) 1995-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ /* * Never include this file directly; use <sys/socket.h> instead. */ #ifndef _BITS_SOCKADDR_H #define _BITS_SOCKADDR_H 1 /* POSIX.1g specifies this type name for the `sa_family' member. */ typedef unsigned short int sa_family_t; /* This macro is used to declare the initial common members of the data types used for socket addresses, `struct sockaddr', `struct sockaddr_in', `struct sockaddr_un', etc. */ #define __SOCKADDR_COMMON(sa_prefix) \ sa_family_t sa_prefix##family #define __SOCKADDR_COMMON_SIZE (sizeof (unsigned short int)) /* Size of struct sockaddr_storage. */ #define _SS_SIZE 128 #endif /* bits/sockaddr.h */ fp-logb.h 0000644 00000001764 15125171642 0006257 0 ustar 00 /* Define __FP_LOGB0_IS_MIN and __FP_LOGBNAN_IS_MIN. x86 version. Copyright (C) 2016-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _MATH_H # error "Never use <bits/fp-logb.h> directly; include <math.h> instead." #endif #define __FP_LOGB0_IS_MIN 1 #define __FP_LOGBNAN_IS_MIN 1 flt-eval-method.h 0000644 00000002277 15125171642 0007721 0 ustar 00 /* Define __GLIBC_FLT_EVAL_METHOD. x86 version. Copyright (C) 2016-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _MATH_H # error "Never use <bits/flt-eval-method.h> directly; include <math.h> instead." #endif #ifdef __FLT_EVAL_METHOD__ # if __FLT_EVAL_METHOD__ == -1 # define __GLIBC_FLT_EVAL_METHOD 2 # else # define __GLIBC_FLT_EVAL_METHOD __FLT_EVAL_METHOD__ # endif #elif defined __x86_64__ # define __GLIBC_FLT_EVAL_METHOD 0 #else # define __GLIBC_FLT_EVAL_METHOD 2 #endif resource.h 0000644 00000014244 15125171642 0006555 0 ustar 00 /* Bit values & structures for resource limits. Linux version. Copyright (C) 1994-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _SYS_RESOURCE_H # error "Never use <bits/resource.h> directly; include <sys/resource.h> instead." #endif #include <bits/types.h> /* Transmute defines to enumerations. The macro re-definitions are necessary because some programs want to test for operating system features with #ifdef RUSAGE_SELF. In ISO C the reflexive definition is a no-op. */ /* Kinds of resource limit. */ enum __rlimit_resource { /* Per-process CPU limit, in seconds. */ RLIMIT_CPU = 0, #define RLIMIT_CPU RLIMIT_CPU /* Largest file that can be created, in bytes. */ RLIMIT_FSIZE = 1, #define RLIMIT_FSIZE RLIMIT_FSIZE /* Maximum size of data segment, in bytes. */ RLIMIT_DATA = 2, #define RLIMIT_DATA RLIMIT_DATA /* Maximum size of stack segment, in bytes. */ RLIMIT_STACK = 3, #define RLIMIT_STACK RLIMIT_STACK /* Largest core file that can be created, in bytes. */ RLIMIT_CORE = 4, #define RLIMIT_CORE RLIMIT_CORE /* Largest resident set size, in bytes. This affects swapping; processes that are exceeding their resident set size will be more likely to have physical memory taken from them. */ __RLIMIT_RSS = 5, #define RLIMIT_RSS __RLIMIT_RSS /* Number of open files. */ RLIMIT_NOFILE = 7, __RLIMIT_OFILE = RLIMIT_NOFILE, /* BSD name for same. */ #define RLIMIT_NOFILE RLIMIT_NOFILE #define RLIMIT_OFILE __RLIMIT_OFILE /* Address space limit. */ RLIMIT_AS = 9, #define RLIMIT_AS RLIMIT_AS /* Number of processes. */ __RLIMIT_NPROC = 6, #define RLIMIT_NPROC __RLIMIT_NPROC /* Locked-in-memory address space. */ __RLIMIT_MEMLOCK = 8, #define RLIMIT_MEMLOCK __RLIMIT_MEMLOCK /* Maximum number of file locks. */ __RLIMIT_LOCKS = 10, #define RLIMIT_LOCKS __RLIMIT_LOCKS /* Maximum number of pending signals. */ __RLIMIT_SIGPENDING = 11, #define RLIMIT_SIGPENDING __RLIMIT_SIGPENDING /* Maximum bytes in POSIX message queues. */ __RLIMIT_MSGQUEUE = 12, #define RLIMIT_MSGQUEUE __RLIMIT_MSGQUEUE /* Maximum nice priority allowed to raise to. Nice levels 19 .. -20 correspond to 0 .. 39 values of this resource limit. */ __RLIMIT_NICE = 13, #define RLIMIT_NICE __RLIMIT_NICE /* Maximum realtime priority allowed for non-priviledged processes. */ __RLIMIT_RTPRIO = 14, #define RLIMIT_RTPRIO __RLIMIT_RTPRIO /* Maximum CPU time in microseconds that a process scheduled under a real-time scheduling policy may consume without making a blocking system call before being forcibly descheduled. */ __RLIMIT_RTTIME = 15, #define RLIMIT_RTTIME __RLIMIT_RTTIME __RLIMIT_NLIMITS = 16, __RLIM_NLIMITS = __RLIMIT_NLIMITS #define RLIMIT_NLIMITS __RLIMIT_NLIMITS #define RLIM_NLIMITS __RLIM_NLIMITS }; /* Value to indicate that there is no limit. */ #ifndef __USE_FILE_OFFSET64 # define RLIM_INFINITY ((__rlim_t) -1) #else # define RLIM_INFINITY 0xffffffffffffffffuLL #endif #ifdef __USE_LARGEFILE64 # define RLIM64_INFINITY 0xffffffffffffffffuLL #endif /* We can represent all limits. */ #define RLIM_SAVED_MAX RLIM_INFINITY #define RLIM_SAVED_CUR RLIM_INFINITY /* Type for resource quantity measurement. */ #ifndef __USE_FILE_OFFSET64 typedef __rlim_t rlim_t; #else typedef __rlim64_t rlim_t; #endif #ifdef __USE_LARGEFILE64 typedef __rlim64_t rlim64_t; #endif struct rlimit { /* The current (soft) limit. */ rlim_t rlim_cur; /* The hard limit. */ rlim_t rlim_max; }; #ifdef __USE_LARGEFILE64 struct rlimit64 { /* The current (soft) limit. */ rlim64_t rlim_cur; /* The hard limit. */ rlim64_t rlim_max; }; #endif /* Whose usage statistics do you want? */ enum __rusage_who { /* The calling process. */ RUSAGE_SELF = 0, #define RUSAGE_SELF RUSAGE_SELF /* All of its terminated child processes. */ RUSAGE_CHILDREN = -1 #define RUSAGE_CHILDREN RUSAGE_CHILDREN #ifdef __USE_GNU , /* The calling thread. */ RUSAGE_THREAD = 1 # define RUSAGE_THREAD RUSAGE_THREAD /* Name for the same functionality on Solaris. */ # define RUSAGE_LWP RUSAGE_THREAD #endif }; #include <bits/types/struct_timeval.h> #include <bits/types/struct_rusage.h> /* Priority limits. */ #define PRIO_MIN -20 /* Minimum priority a process can have. */ #define PRIO_MAX 20 /* Maximum priority a process can have. */ /* The type of the WHICH argument to `getpriority' and `setpriority', indicating what flavor of entity the WHO argument specifies. */ enum __priority_which { PRIO_PROCESS = 0, /* WHO is a process ID. */ #define PRIO_PROCESS PRIO_PROCESS PRIO_PGRP = 1, /* WHO is a process group ID. */ #define PRIO_PGRP PRIO_PGRP PRIO_USER = 2 /* WHO is a user ID. */ #define PRIO_USER PRIO_USER }; __BEGIN_DECLS #ifdef __USE_GNU /* Modify and return resource limits of a process atomically. */ # ifndef __USE_FILE_OFFSET64 extern int prlimit (__pid_t __pid, enum __rlimit_resource __resource, const struct rlimit *__new_limit, struct rlimit *__old_limit) __THROW; # else # ifdef __REDIRECT_NTH extern int __REDIRECT_NTH (prlimit, (__pid_t __pid, enum __rlimit_resource __resource, const struct rlimit *__new_limit, struct rlimit *__old_limit), prlimit64); # else # define prlimit prlimit64 # endif # endif # ifdef __USE_LARGEFILE64 extern int prlimit64 (__pid_t __pid, enum __rlimit_resource __resource, const struct rlimit64 *__new_limit, struct rlimit64 *__old_limit) __THROW; # endif #endif __END_DECLS posix1_lim.h 0000644 00000012116 15125171642 0007006 0 ustar 00 /* Copyright (C) 1991-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ /* * POSIX Standard: 2.9.2 Minimum Values Added to <limits.h> * * Never include this file directly; use <limits.h> instead. */ #ifndef _BITS_POSIX1_LIM_H #define _BITS_POSIX1_LIM_H 1 #include <bits/wordsize.h> /* These are the standard-mandated minimum values. */ /* Minimum number of operations in one list I/O call. */ #define _POSIX_AIO_LISTIO_MAX 2 /* Minimal number of outstanding asynchronous I/O operations. */ #define _POSIX_AIO_MAX 1 /* Maximum length of arguments to `execve', including environment. */ #define _POSIX_ARG_MAX 4096 /* Maximum simultaneous processes per real user ID. */ #ifdef __USE_XOPEN2K # define _POSIX_CHILD_MAX 25 #else # define _POSIX_CHILD_MAX 6 #endif /* Minimal number of timer expiration overruns. */ #define _POSIX_DELAYTIMER_MAX 32 /* Maximum length of a host name (not including the terminating null) as returned from the GETHOSTNAME function. */ #define _POSIX_HOST_NAME_MAX 255 /* Maximum link count of a file. */ #define _POSIX_LINK_MAX 8 /* Maximum length of login name. */ #define _POSIX_LOGIN_NAME_MAX 9 /* Number of bytes in a terminal canonical input queue. */ #define _POSIX_MAX_CANON 255 /* Number of bytes for which space will be available in a terminal input queue. */ #define _POSIX_MAX_INPUT 255 /* Maximum number of message queues open for a process. */ #define _POSIX_MQ_OPEN_MAX 8 /* Maximum number of supported message priorities. */ #define _POSIX_MQ_PRIO_MAX 32 /* Number of bytes in a filename. */ #define _POSIX_NAME_MAX 14 /* Number of simultaneous supplementary group IDs per process. */ #ifdef __USE_XOPEN2K # define _POSIX_NGROUPS_MAX 8 #else # define _POSIX_NGROUPS_MAX 0 #endif /* Number of files one process can have open at once. */ #ifdef __USE_XOPEN2K # define _POSIX_OPEN_MAX 20 #else # define _POSIX_OPEN_MAX 16 #endif #if !defined __USE_XOPEN2K || defined __USE_GNU /* Number of descriptors that a process may examine with `pselect' or `select'. */ # define _POSIX_FD_SETSIZE _POSIX_OPEN_MAX #endif /* Number of bytes in a pathname. */ #define _POSIX_PATH_MAX 256 /* Number of bytes than can be written atomically to a pipe. */ #define _POSIX_PIPE_BUF 512 /* The number of repeated occurrences of a BRE permitted by the REGEXEC and REGCOMP functions when using the interval notation. */ #define _POSIX_RE_DUP_MAX 255 /* Minimal number of realtime signals reserved for the application. */ #define _POSIX_RTSIG_MAX 8 /* Number of semaphores a process can have. */ #define _POSIX_SEM_NSEMS_MAX 256 /* Maximal value of a semaphore. */ #define _POSIX_SEM_VALUE_MAX 32767 /* Number of pending realtime signals. */ #define _POSIX_SIGQUEUE_MAX 32 /* Largest value of a `ssize_t'. */ #define _POSIX_SSIZE_MAX 32767 /* Number of streams a process can have open at once. */ #define _POSIX_STREAM_MAX 8 /* The number of bytes in a symbolic link. */ #define _POSIX_SYMLINK_MAX 255 /* The number of symbolic links that can be traversed in the resolution of a pathname in the absence of a loop. */ #define _POSIX_SYMLOOP_MAX 8 /* Number of timer for a process. */ #define _POSIX_TIMER_MAX 32 /* Maximum number of characters in a tty name. */ #define _POSIX_TTY_NAME_MAX 9 /* Maximum length of a time zone abbreviation (element of 'tzname'). */ #ifdef __USE_XOPEN2K # define _POSIX_TZNAME_MAX 6 #else # define _POSIX_TZNAME_MAX 3 #endif #if !defined __USE_XOPEN2K || defined __USE_GNU /* Maximum number of connections that can be queued on a socket. */ # define _POSIX_QLIMIT 1 /* Maximum number of bytes that can be buffered on a socket for send or receive. */ # define _POSIX_HIWAT _POSIX_PIPE_BUF /* Maximum number of elements in an `iovec' array. */ # define _POSIX_UIO_MAXIOV 16 #endif /* Maximum clock resolution in nanoseconds. */ #define _POSIX_CLOCKRES_MIN 20000000 /* Get the implementation-specific values for the above. */ #include <bits/local_lim.h> #ifndef SSIZE_MAX /* ssize_t is not formally required to be the signed type corresponding to size_t, but it is for all configurations supported by glibc. */ # if __WORDSIZE == 64 || __WORDSIZE32_SIZE_ULONG # define SSIZE_MAX LONG_MAX # else # define SSIZE_MAX INT_MAX # endif #endif /* This value is a guaranteed minimum maximum. The current maximum can be got from `sysconf'. */ #ifndef NGROUPS_MAX # define NGROUPS_MAX 8 #endif #endif /* bits/posix1_lim.h */ iscanonical.h 0000644 00000004657 15125171642 0007220 0 ustar 00 /* Define iscanonical macro. ldbl-96 version. Copyright (C) 2016-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _MATH_H # error "Never use <bits/iscanonical.h> directly; include <math.h> instead." #endif extern int __iscanonicall (long double __x) __THROW __attribute__ ((__const__)); #define __iscanonicalf(x) ((void) (__typeof (x)) (x), 1) #define __iscanonical(x) ((void) (__typeof (x)) (x), 1) #if __HAVE_DISTINCT_FLOAT128 # define __iscanonicalf128(x) ((void) (__typeof (x)) (x), 1) #endif /* Return nonzero value if X is canonical. In IEEE interchange binary formats, all values are canonical, but the argument must still be converted to its semantic type for any exceptions arising from the conversion, before being discarded; in extended precision, there are encodings that are not consistently handled as corresponding to any particular value of the type, and we return 0 for those. */ #ifndef __cplusplus # define iscanonical(x) __MATH_TG ((x), __iscanonical, (x)) #else /* In C++ mode, __MATH_TG cannot be used, because it relies on __builtin_types_compatible_p, which is a C-only builtin. On the other hand, overloading provides the means to distinguish between the floating-point types. The overloading resolution will match the correct parameter (regardless of type qualifiers (i.e.: const and volatile)). */ extern "C++" { inline int iscanonical (float __val) { return __iscanonicalf (__val); } inline int iscanonical (double __val) { return __iscanonical (__val); } inline int iscanonical (long double __val) { return __iscanonicall (__val); } # if __HAVE_DISTINCT_FLOAT128 inline int iscanonical (_Float128 __val) { return __iscanonicalf128 (__val); } # endif } #endif /* __cplusplus */ wchar-ldbl.h 0000644 00000006013 15125171642 0006740 0 ustar 00 /* -mlong-double-64 compatibility mode for <wchar.h> functions. Copyright (C) 2006-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _WCHAR_H # error "Never include <bits/wchar-ldbl.h> directly; use <wchar.h> instead." #endif #if defined __USE_ISOC95 || defined __USE_UNIX98 __LDBL_REDIR_DECL (fwprintf); __LDBL_REDIR_DECL (wprintf); __LDBL_REDIR_DECL (swprintf); __LDBL_REDIR_DECL (vfwprintf); __LDBL_REDIR_DECL (vwprintf); __LDBL_REDIR_DECL (vswprintf); # if !__GLIBC_USE (DEPRECATED_SCANF) # if defined __LDBL_COMPAT __LDBL_REDIR1_DECL (fwscanf, __nldbl___isoc99_fwscanf) __LDBL_REDIR1_DECL (wscanf, __nldbl___isoc99_wscanf) __LDBL_REDIR1_DECL (swscanf, __nldbl___isoc99_swscanf) # elif __LDOUBLE_REDIRECTS_TO_FLOAT128_ABI == 1 __LDBL_REDIR1_DECL (fwscanf, __isoc99_fwscanfieee128) __LDBL_REDIR1_DECL (wscanf, __isoc99_wscanfieee128) __LDBL_REDIR1_DECL (swscanf, __isoc99_swscanfieee128) # else # error bits/stdlib-ldbl.h included when no ldbl redirections are required. # endif # else __LDBL_REDIR_DECL (fwscanf); __LDBL_REDIR_DECL (wscanf); __LDBL_REDIR_DECL (swscanf); # endif #endif #ifdef __USE_ISOC99 # ifdef __LDBL_COMPAT __LDBL_REDIR1_DECL (wcstold, wcstod); # else __LDBL_REDIR1_DECL (wcstold, __wcstoieee128) # endif # if !__GLIBC_USE (DEPRECATED_SCANF) # if defined __LDBL_COMPAT __LDBL_REDIR1_DECL (vfwscanf, __nldbl___isoc99_vfwscanf) __LDBL_REDIR1_DECL (vwscanf, __nldbl___isoc99_vwscanf) __LDBL_REDIR1_DECL (vswscanf, __nldbl___isoc99_vswscanf) # elif __LDOUBLE_REDIRECTS_TO_FLOAT128_ABI == 1 __LDBL_REDIR1_DECL (vfwscanf, __isoc99_vfwscanfieee128) __LDBL_REDIR1_DECL (vwscanf, __isoc99_vwscanfieee128) __LDBL_REDIR1_DECL (vswscanf, __isoc99_vswscanfieee128) # else # error bits/stdlib-ldbl.h included when no ldbl redirections are required. # endif # else __LDBL_REDIR_DECL (vfwscanf); __LDBL_REDIR_DECL (vwscanf); __LDBL_REDIR_DECL (vswscanf); # endif #endif #ifdef __USE_GNU # ifdef __LDBL_COMPAT __LDBL_REDIR1_DECL (wcstold_l, wcstod_l); # else __LDBL_REDIR1_DECL (wcstold_l, __wcstoieee128_l) # endif #endif #if __USE_FORTIFY_LEVEL > 0 && defined __fortify_function __LDBL_REDIR2_DECL (swprintf_chk) __LDBL_REDIR2_DECL (vswprintf_chk) # if __USE_FORTIFY_LEVEL > 1 __LDBL_REDIR2_DECL (fwprintf_chk) __LDBL_REDIR2_DECL (wprintf_chk) __LDBL_REDIR2_DECL (vfwprintf_chk) __LDBL_REDIR2_DECL (vwprintf_chk) # endif #endif sched.h 0000644 00000013051 15125171642 0006007 0 ustar 00 /* Definitions of constants and data structure for POSIX 1003.1b-1993 scheduling interface. Copyright (C) 1996-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _BITS_SCHED_H #define _BITS_SCHED_H 1 #ifndef _SCHED_H # error "Never include <bits/sched.h> directly; use <sched.h> instead." #endif /* Scheduling algorithms. */ #define SCHED_OTHER 0 #define SCHED_FIFO 1 #define SCHED_RR 2 #ifdef __USE_GNU # define SCHED_NORMAL SCHED_OTHER # define SCHED_BATCH 3 # define SCHED_ISO 4 # define SCHED_IDLE 5 # define SCHED_DEADLINE 6 /* Flags that can be used in policy values. */ # define SCHED_RESET_ON_FORK 0x40000000 /* Flags for the sched_flags field in struct sched_attr. */ #define SCHED_FLAG_RESET_ON_FORK 0x01 #define SCHED_FLAG_RECLAIM 0x02 #define SCHED_FLAG_DL_OVERRUN 0x04 #define SCHED_FLAG_KEEP_POLICY 0x08 #define SCHED_FLAG_KEEP_PARAMS 0x10 #define SCHED_FLAG_UTIL_CLAMP_MIN 0x20 #define SCHED_FLAG_UTIL_CLAMP_MAX 0x40 /* Combinations of sched_flags fields. */ #define SCHED_FLAG_KEEP_ALL 0x18 #define SCHED_FLAG_UTIL_CLAMP 0x60 /* Use "" to work around incorrect macro expansion of the __has_include argument (GCC PR 80005). */ # ifdef __has_include # if __has_include ("linux/sched/types.h") /* Some older Linux versions defined sched_param in <linux/sched/types.h>. */ # define sched_param __glibc_mask_sched_param # include <linux/sched/types.h> # undef sched_param # endif # endif # ifndef SCHED_ATTR_SIZE_VER0 # include <linux/types.h> # define SCHED_ATTR_SIZE_VER0 48 # define SCHED_ATTR_SIZE_VER1 56 struct sched_attr { __u32 size; __u32 sched_policy; __u64 sched_flags; __s32 sched_nice; __u32 sched_priority; __u64 sched_runtime; __u64 sched_deadline; __u64 sched_period; __u32 sched_util_min; __u32 sched_util_max; /* Additional fields may be added at the end. */ }; # endif /* !SCHED_ATTR_SIZE_VER0 */ /* Cloning flags. */ # define CSIGNAL 0x000000ff /* Signal mask to be sent at exit. */ # define CLONE_VM 0x00000100 /* Set if VM shared between processes. */ # define CLONE_FS 0x00000200 /* Set if fs info shared between processes. */ # define CLONE_FILES 0x00000400 /* Set if open files shared between processes. */ # define CLONE_SIGHAND 0x00000800 /* Set if signal handlers shared. */ # define CLONE_PIDFD 0x00001000 /* Set if a pidfd should be placed in parent. */ # define CLONE_PTRACE 0x00002000 /* Set if tracing continues on the child. */ # define CLONE_VFORK 0x00004000 /* Set if the parent wants the child to wake it up on mm_release. */ # define CLONE_PARENT 0x00008000 /* Set if we want to have the same parent as the cloner. */ # define CLONE_THREAD 0x00010000 /* Set to add to same thread group. */ # define CLONE_NEWNS 0x00020000 /* Set to create new namespace. */ # define CLONE_SYSVSEM 0x00040000 /* Set to shared SVID SEM_UNDO semantics. */ # define CLONE_SETTLS 0x00080000 /* Set TLS info. */ # define CLONE_PARENT_SETTID 0x00100000 /* Store TID in userlevel buffer before MM copy. */ # define CLONE_CHILD_CLEARTID 0x00200000 /* Register exit futex and memory location to clear. */ # define CLONE_DETACHED 0x00400000 /* Create clone detached. */ # define CLONE_UNTRACED 0x00800000 /* Set if the tracing process can't force CLONE_PTRACE on this clone. */ # define CLONE_CHILD_SETTID 0x01000000 /* Store TID in userlevel buffer in the child. */ # define CLONE_NEWCGROUP 0x02000000 /* New cgroup namespace. */ # define CLONE_NEWUTS 0x04000000 /* New utsname group. */ # define CLONE_NEWIPC 0x08000000 /* New ipcs. */ # define CLONE_NEWUSER 0x10000000 /* New user namespace. */ # define CLONE_NEWPID 0x20000000 /* New pid namespace. */ # define CLONE_NEWNET 0x40000000 /* New network namespace. */ # define CLONE_IO 0x80000000 /* Clone I/O context. */ #endif #include <bits/types/struct_sched_param.h> __BEGIN_DECLS #ifdef __USE_GNU /* Clone current process. */ extern int clone (int (*__fn) (void *__arg), void *__child_stack, int __flags, void *__arg, ...) __THROW; /* Unshare the specified resources. */ extern int unshare (int __flags) __THROW; /* Get index of currently used CPU. */ extern int sched_getcpu (void) __THROW; /* Get currently used CPU and NUMA node. */ extern int getcpu (unsigned int *, unsigned int *) __THROW; /* Switch process to namespace of type NSTYPE indicated by FD. */ extern int setns (int __fd, int __nstype) __THROW; /* Apply the scheduling attributes from *ATTR to the process or thread TID. */ int sched_setattr (pid_t tid, struct sched_attr *attr, unsigned int flags) __THROW __nonnull ((2)); /* Obtain the scheduling attributes of the process or thread TID and store it in *ATTR. */ int sched_getattr (pid_t tid, struct sched_attr *attr, unsigned int size, unsigned int flags) __THROW __nonnull ((2)); #endif __END_DECLS #endif /* bits/sched.h */ uintn-identity.h 0000644 00000003006 15125171642 0007704 0 ustar 00 /* Inline functions to return unsigned integer values unchanged. Copyright (C) 2017-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #if !defined _NETINET_IN_H && !defined _ENDIAN_H # error "Never use <bits/uintn-identity.h> directly; include <netinet/in.h> or <endian.h> instead." #endif #ifndef _BITS_UINTN_IDENTITY_H #define _BITS_UINTN_IDENTITY_H 1 #include <bits/types.h> /* These inline functions are to ensure the appropriate type conversions and associated diagnostics from macros that convert to a given endianness. */ static __inline __uint16_t __uint16_identity (__uint16_t __x) { return __x; } static __inline __uint32_t __uint32_identity (__uint32_t __x) { return __x; } static __inline __uint64_t __uint64_identity (__uint64_t __x) { return __x; } #endif /* _BITS_UINTN_IDENTITY_H. */ stdint-uintn.h 0000644 00000002031 15125171642 0007355 0 ustar 00 /* Define uintN_t types. Copyright (C) 2017-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _BITS_STDINT_UINTN_H #define _BITS_STDINT_UINTN_H 1 #include <bits/types.h> typedef __uint8_t uint8_t; typedef __uint16_t uint16_t; typedef __uint32_t uint32_t; typedef __uint64_t uint64_t; #endif /* bits/stdint-uintn.h */ waitstatus.h 0000644 00000004357 15125171642 0007142 0 ustar 00 /* Definitions of status bits for `wait' et al. Copyright (C) 1992-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #if !defined _SYS_WAIT_H && !defined _STDLIB_H # error "Never include <bits/waitstatus.h> directly; use <sys/wait.h> instead." #endif /* Everything extant so far uses these same bits. */ /* If WIFEXITED(STATUS), the low-order 8 bits of the status. */ #define __WEXITSTATUS(status) (((status) & 0xff00) >> 8) /* If WIFSIGNALED(STATUS), the terminating signal. */ #define __WTERMSIG(status) ((status) & 0x7f) /* If WIFSTOPPED(STATUS), the signal that stopped the child. */ #define __WSTOPSIG(status) __WEXITSTATUS(status) /* Nonzero if STATUS indicates normal termination. */ #define __WIFEXITED(status) (__WTERMSIG(status) == 0) /* Nonzero if STATUS indicates termination by a signal. */ #define __WIFSIGNALED(status) \ (((signed char) (((status) & 0x7f) + 1) >> 1) > 0) /* Nonzero if STATUS indicates the child is stopped. */ #define __WIFSTOPPED(status) (((status) & 0xff) == 0x7f) /* Nonzero if STATUS indicates the child continued after a stop. We only define this if <bits/waitflags.h> provides the WCONTINUED flag bit. */ #ifdef WCONTINUED # define __WIFCONTINUED(status) ((status) == __W_CONTINUED) #endif /* Nonzero if STATUS indicates the child dumped core. */ #define __WCOREDUMP(status) ((status) & __WCOREFLAG) /* Macros for constructing status values. */ #define __W_EXITCODE(ret, sig) ((ret) << 8 | (sig)) #define __W_STOPCODE(sig) ((sig) << 8 | 0x7f) #define __W_CONTINUED 0xffff #define __WCOREFLAG 0x80 getopt_core.h 0000644 00000007123 15125171642 0007236 0 ustar 00 /* Declarations for getopt (basic, portable features only). Copyright (C) 1989-2021 Free Software Foundation, Inc. This file is part of the GNU C Library and is also part of gnulib. Patches to this file should be submitted to both projects. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _GETOPT_CORE_H #define _GETOPT_CORE_H 1 /* This header should not be used directly; include getopt.h or unistd.h instead. Unlike most bits headers, it does not have a protective #error, because the guard macro for getopt.h in gnulib is not fixed. */ __BEGIN_DECLS /* For communication from 'getopt' to the caller. When 'getopt' finds an option that takes an argument, the argument value is returned here. Also, when 'ordering' is RETURN_IN_ORDER, each non-option ARGV-element is returned here. */ extern char *optarg; /* Index in ARGV of the next element to be scanned. This is used for communication to and from the caller and for communication between successive calls to 'getopt'. On entry to 'getopt', zero means this is the first call; initialize. When 'getopt' returns -1, this is the index of the first of the non-option elements that the caller should itself scan. Otherwise, 'optind' communicates from one call to the next how much of ARGV has been scanned so far. */ extern int optind; /* Callers store zero here to inhibit the error message 'getopt' prints for unrecognized options. */ extern int opterr; /* Set to an option character which was unrecognized. */ extern int optopt; /* Get definitions and prototypes for functions to process the arguments in ARGV (ARGC of them, minus the program name) for options given in OPTS. Return the option character from OPTS just read. Return -1 when there are no more options. For unrecognized options, or options missing arguments, 'optopt' is set to the option letter, and '?' is returned. The OPTS string is a list of characters which are recognized option letters, optionally followed by colons, specifying that that letter takes an argument, to be placed in 'optarg'. If a letter in OPTS is followed by two colons, its argument is optional. This behavior is specific to the GNU 'getopt'. The argument '--' causes premature termination of argument scanning, explicitly telling 'getopt' that there are no more options. If OPTS begins with '-', then non-option arguments are treated as arguments to the option '\1'. This behavior is specific to the GNU 'getopt'. If OPTS begins with '+', or POSIXLY_CORRECT is set in the environment, then do not permute arguments. For standards compliance, the 'argv' argument has the type char *const *, but this is inaccurate; if argument permutation is enabled, the argv array (not the strings it points to) must be writable. */ extern int getopt (int ___argc, char *const *___argv, const char *__shortopts) __THROW __nonnull ((2, 3)); __END_DECLS #endif /* getopt_core.h */ strings_fortified.h 0000644 00000002330 15125171642 0010443 0 ustar 00 /* Fortify macros for strings.h functions. Copyright (C) 2017-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef __STRINGS_FORTIFIED # define __STRINGS_FORTIFIED 1 __fortify_function void __NTH (bcopy (const void *__src, void *__dest, size_t __len)) { (void) __builtin___memmove_chk (__dest, __src, __len, __glibc_objsize0 (__dest)); } __fortify_function void __NTH (bzero (void *__dest, size_t __len)) { (void) __builtin___memset_chk (__dest, '\0', __len, __glibc_objsize0 (__dest)); } #endif ioctls.h 0000644 00000010576 15125171642 0006227 0 ustar 00 /* Copyright (C) 1996-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _SYS_IOCTL_H # error "Never use <bits/ioctls.h> directly; include <sys/ioctl.h> instead." #endif /* Use the definitions from the kernel header files. */ #include <asm/ioctls.h> /* Routing table calls. */ #define SIOCADDRT 0x890B /* add routing table entry */ #define SIOCDELRT 0x890C /* delete routing table entry */ #define SIOCRTMSG 0x890D /* call to routing system */ /* Socket configuration controls. */ #define SIOCGIFNAME 0x8910 /* get iface name */ #define SIOCSIFLINK 0x8911 /* set iface channel */ #define SIOCGIFCONF 0x8912 /* get iface list */ #define SIOCGIFFLAGS 0x8913 /* get flags */ #define SIOCSIFFLAGS 0x8914 /* set flags */ #define SIOCGIFADDR 0x8915 /* get PA address */ #define SIOCSIFADDR 0x8916 /* set PA address */ #define SIOCGIFDSTADDR 0x8917 /* get remote PA address */ #define SIOCSIFDSTADDR 0x8918 /* set remote PA address */ #define SIOCGIFBRDADDR 0x8919 /* get broadcast PA address */ #define SIOCSIFBRDADDR 0x891a /* set broadcast PA address */ #define SIOCGIFNETMASK 0x891b /* get network PA mask */ #define SIOCSIFNETMASK 0x891c /* set network PA mask */ #define SIOCGIFMETRIC 0x891d /* get metric */ #define SIOCSIFMETRIC 0x891e /* set metric */ #define SIOCGIFMEM 0x891f /* get memory address (BSD) */ #define SIOCSIFMEM 0x8920 /* set memory address (BSD) */ #define SIOCGIFMTU 0x8921 /* get MTU size */ #define SIOCSIFMTU 0x8922 /* set MTU size */ #define SIOCSIFNAME 0x8923 /* set interface name */ #define SIOCSIFHWADDR 0x8924 /* set hardware address */ #define SIOCGIFENCAP 0x8925 /* get/set encapsulations */ #define SIOCSIFENCAP 0x8926 #define SIOCGIFHWADDR 0x8927 /* Get hardware address */ #define SIOCGIFSLAVE 0x8929 /* Driver slaving support */ #define SIOCSIFSLAVE 0x8930 #define SIOCADDMULTI 0x8931 /* Multicast address lists */ #define SIOCDELMULTI 0x8932 #define SIOCGIFINDEX 0x8933 /* name -> if_index mapping */ #define SIOGIFINDEX SIOCGIFINDEX /* misprint compatibility :-) */ #define SIOCSIFPFLAGS 0x8934 /* set/get extended flags set */ #define SIOCGIFPFLAGS 0x8935 #define SIOCDIFADDR 0x8936 /* delete PA address */ #define SIOCSIFHWBROADCAST 0x8937 /* set hardware broadcast addr */ #define SIOCGIFCOUNT 0x8938 /* get number of devices */ #define SIOCGIFBR 0x8940 /* Bridging support */ #define SIOCSIFBR 0x8941 /* Set bridging options */ #define SIOCGIFTXQLEN 0x8942 /* Get the tx queue length */ #define SIOCSIFTXQLEN 0x8943 /* Set the tx queue length */ /* ARP cache control calls. */ /* 0x8950 - 0x8952 * obsolete calls, don't re-use */ #define SIOCDARP 0x8953 /* delete ARP table entry */ #define SIOCGARP 0x8954 /* get ARP table entry */ #define SIOCSARP 0x8955 /* set ARP table entry */ /* RARP cache control calls. */ #define SIOCDRARP 0x8960 /* delete RARP table entry */ #define SIOCGRARP 0x8961 /* get RARP table entry */ #define SIOCSRARP 0x8962 /* set RARP table entry */ /* Driver configuration calls */ #define SIOCGIFMAP 0x8970 /* Get device parameters */ #define SIOCSIFMAP 0x8971 /* Set device parameters */ /* DLCI configuration calls */ #define SIOCADDDLCI 0x8980 /* Create new DLCI device */ #define SIOCDELDLCI 0x8981 /* Delete DLCI device */ /* Device private ioctl calls. */ /* These 16 ioctls are available to devices via the do_ioctl() device vector. Each device should include this file and redefine these names as their own. Because these are device dependent it is a good idea _NOT_ to issue them to random objects and hope. */ #define SIOCDEVPRIVATE 0x89F0 /* to 89FF */ /* * These 16 ioctl calls are protocol private */ #define SIOCPROTOPRIVATE 0x89E0 /* to 89EF */ mathcalls.h 0000644 00000032111 15125171642 0006667 0 ustar 00 /* Prototype declarations for math functions; helper file for <math.h>. Copyright (C) 1996-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ /* NOTE: Because of the special way this file is used by <math.h>, this file must NOT be protected from multiple inclusion as header files usually are. This file provides prototype declarations for the math functions. Most functions are declared using the macro: __MATHCALL (NAME,[_r], (ARGS...)); This means there is a function `NAME' returning `double' and a function `NAMEf' returning `float'. Each place `_Mdouble_' appears in the prototype, that is actually `double' in the prototype for `NAME' and `float' in the prototype for `NAMEf'. Reentrant variant functions are called `NAME_r' and `NAMEf_r'. Functions returning other types like `int' are declared using the macro: __MATHDECL (TYPE, NAME,[_r], (ARGS...)); This is just like __MATHCALL but for a function returning `TYPE' instead of `_Mdouble_'. In all of these cases, there is still both a `NAME' and a `NAMEf' that takes `float' arguments. Note that there must be no whitespace before the argument passed for NAME, to make token pasting work with -traditional. */ #ifndef _MATH_H # error "Never include <bits/mathcalls.h> directly; include <math.h> instead." #endif /* Trigonometric functions. */ /* Arc cosine of X. */ __MATHCALL (acos,, (_Mdouble_ __x)); /* Arc sine of X. */ __MATHCALL (asin,, (_Mdouble_ __x)); /* Arc tangent of X. */ __MATHCALL (atan,, (_Mdouble_ __x)); /* Arc tangent of Y/X. */ __MATHCALL (atan2,, (_Mdouble_ __y, _Mdouble_ __x)); /* Cosine of X. */ __MATHCALL_VEC (cos,, (_Mdouble_ __x)); /* Sine of X. */ __MATHCALL_VEC (sin,, (_Mdouble_ __x)); /* Tangent of X. */ __MATHCALL (tan,, (_Mdouble_ __x)); /* Hyperbolic functions. */ /* Hyperbolic cosine of X. */ __MATHCALL (cosh,, (_Mdouble_ __x)); /* Hyperbolic sine of X. */ __MATHCALL (sinh,, (_Mdouble_ __x)); /* Hyperbolic tangent of X. */ __MATHCALL (tanh,, (_Mdouble_ __x)); #ifdef __USE_GNU /* Cosine and sine of X. */ __MATHDECL_VEC (void,sincos,, (_Mdouble_ __x, _Mdouble_ *__sinx, _Mdouble_ *__cosx)); #endif #if defined __USE_XOPEN_EXTENDED || defined __USE_ISOC99 /* Hyperbolic arc cosine of X. */ __MATHCALL (acosh,, (_Mdouble_ __x)); /* Hyperbolic arc sine of X. */ __MATHCALL (asinh,, (_Mdouble_ __x)); /* Hyperbolic arc tangent of X. */ __MATHCALL (atanh,, (_Mdouble_ __x)); #endif /* Exponential and logarithmic functions. */ /* Exponential function of X. */ __MATHCALL_VEC (exp,, (_Mdouble_ __x)); /* Break VALUE into a normalized fraction and an integral power of 2. */ __MATHCALL (frexp,, (_Mdouble_ __x, int *__exponent)); /* X times (two to the EXP power). */ __MATHCALL (ldexp,, (_Mdouble_ __x, int __exponent)); /* Natural logarithm of X. */ __MATHCALL_VEC (log,, (_Mdouble_ __x)); /* Base-ten logarithm of X. */ __MATHCALL (log10,, (_Mdouble_ __x)); /* Break VALUE into integral and fractional parts. */ __MATHCALL (modf,, (_Mdouble_ __x, _Mdouble_ *__iptr)) __nonnull ((2)); #if __GLIBC_USE (IEC_60559_FUNCS_EXT_C2X) /* Compute exponent to base ten. */ __MATHCALL (exp10,, (_Mdouble_ __x)); #endif #if defined __USE_XOPEN_EXTENDED || defined __USE_ISOC99 /* Return exp(X) - 1. */ __MATHCALL (expm1,, (_Mdouble_ __x)); /* Return log(1 + X). */ __MATHCALL (log1p,, (_Mdouble_ __x)); /* Return the base 2 signed integral exponent of X. */ __MATHCALL (logb,, (_Mdouble_ __x)); #endif #ifdef __USE_ISOC99 /* Compute base-2 exponential of X. */ __MATHCALL (exp2,, (_Mdouble_ __x)); /* Compute base-2 logarithm of X. */ __MATHCALL (log2,, (_Mdouble_ __x)); #endif /* Power functions. */ /* Return X to the Y power. */ __MATHCALL_VEC (pow,, (_Mdouble_ __x, _Mdouble_ __y)); /* Return the square root of X. */ __MATHCALL (sqrt,, (_Mdouble_ __x)); #if defined __USE_XOPEN || defined __USE_ISOC99 /* Return `sqrt(X*X + Y*Y)'. */ __MATHCALL (hypot,, (_Mdouble_ __x, _Mdouble_ __y)); #endif #if defined __USE_XOPEN_EXTENDED || defined __USE_ISOC99 /* Return the cube root of X. */ __MATHCALL (cbrt,, (_Mdouble_ __x)); #endif /* Nearest integer, absolute value, and remainder functions. */ /* Smallest integral value not less than X. */ __MATHCALLX (ceil,, (_Mdouble_ __x), (__const__)); /* Absolute value of X. */ __MATHCALLX (fabs,, (_Mdouble_ __x), (__const__)); /* Largest integer not greater than X. */ __MATHCALLX (floor,, (_Mdouble_ __x), (__const__)); /* Floating-point modulo remainder of X/Y. */ __MATHCALL (fmod,, (_Mdouble_ __x, _Mdouble_ __y)); #ifdef __USE_MISC # if ((!defined __cplusplus \ || __cplusplus < 201103L /* isinf conflicts with C++11. */ \ || __MATH_DECLARING_DOUBLE == 0)) /* isinff or isinfl don't. */ \ && !__MATH_DECLARING_FLOATN /* Return 0 if VALUE is finite or NaN, +1 if it is +Infinity, -1 if it is -Infinity. */ __MATHDECL_ALIAS (int,isinf,, (_Mdouble_ __value), isinf) __attribute__ ((__const__)); # endif # if !__MATH_DECLARING_FLOATN /* Return nonzero if VALUE is finite and not NaN. */ __MATHDECL_ALIAS (int,finite,, (_Mdouble_ __value), finite) __attribute__ ((__const__)); /* Return the remainder of X/Y. */ __MATHCALL (drem,, (_Mdouble_ __x, _Mdouble_ __y)); /* Return the fractional part of X after dividing out `ilogb (X)'. */ __MATHCALL (significand,, (_Mdouble_ __x)); # endif #endif /* Use misc. */ #ifdef __USE_ISOC99 /* Return X with its signed changed to Y's. */ __MATHCALLX (copysign,, (_Mdouble_ __x, _Mdouble_ __y), (__const__)); #endif #ifdef __USE_ISOC99 /* Return representation of qNaN for double type. */ __MATHCALL (nan,, (const char *__tagb)); #endif #if defined __USE_MISC || (defined __USE_XOPEN && !defined __USE_XOPEN2K) # if ((!defined __cplusplus \ || __cplusplus < 201103L /* isnan conflicts with C++11. */ \ || __MATH_DECLARING_DOUBLE == 0)) /* isnanf or isnanl don't. */ \ && !__MATH_DECLARING_FLOATN /* Return nonzero if VALUE is not a number. */ __MATHDECL_ALIAS (int,isnan,, (_Mdouble_ __value), isnan) __attribute__ ((__const__)); # endif #endif #if defined __USE_MISC || (defined __USE_XOPEN && __MATH_DECLARING_DOUBLE) /* Bessel functions. */ __MATHCALL (j0,, (_Mdouble_)); __MATHCALL (j1,, (_Mdouble_)); __MATHCALL (jn,, (int, _Mdouble_)); __MATHCALL (y0,, (_Mdouble_)); __MATHCALL (y1,, (_Mdouble_)); __MATHCALL (yn,, (int, _Mdouble_)); #endif #if defined __USE_XOPEN || defined __USE_ISOC99 /* Error and gamma functions. */ __MATHCALL (erf,, (_Mdouble_)); __MATHCALL (erfc,, (_Mdouble_)); __MATHCALL (lgamma,, (_Mdouble_)); #endif #ifdef __USE_ISOC99 /* True gamma function. */ __MATHCALL (tgamma,, (_Mdouble_)); #endif #if defined __USE_MISC || (defined __USE_XOPEN && !defined __USE_XOPEN2K) # if !__MATH_DECLARING_FLOATN /* Obsolete alias for `lgamma'. */ __MATHCALL (gamma,, (_Mdouble_)); # endif #endif #ifdef __USE_MISC /* Reentrant version of lgamma. This function uses the global variable `signgam'. The reentrant version instead takes a pointer and stores the value through it. */ __MATHCALL (lgamma,_r, (_Mdouble_, int *__signgamp)); #endif #if defined __USE_XOPEN_EXTENDED || defined __USE_ISOC99 /* Return the integer nearest X in the direction of the prevailing rounding mode. */ __MATHCALL (rint,, (_Mdouble_ __x)); /* Return X + epsilon if X < Y, X - epsilon if X > Y. */ __MATHCALL (nextafter,, (_Mdouble_ __x, _Mdouble_ __y)); # if defined __USE_ISOC99 && !defined __LDBL_COMPAT && !__MATH_DECLARING_FLOATN __MATHCALL (nexttoward,, (_Mdouble_ __x, long double __y)); # endif # if __GLIBC_USE (IEC_60559_BFP_EXT_C2X) || __MATH_DECLARING_FLOATN /* Return X - epsilon. */ __MATHCALL (nextdown,, (_Mdouble_ __x)); /* Return X + epsilon. */ __MATHCALL (nextup,, (_Mdouble_ __x)); # endif /* Return the remainder of integer divison X / Y with infinite precision. */ __MATHCALL (remainder,, (_Mdouble_ __x, _Mdouble_ __y)); # ifdef __USE_ISOC99 /* Return X times (2 to the Nth power). */ __MATHCALL (scalbn,, (_Mdouble_ __x, int __n)); # endif /* Return the binary exponent of X, which must be nonzero. */ __MATHDECL (int,ilogb,, (_Mdouble_ __x)); #endif #if __GLIBC_USE (IEC_60559_BFP_EXT_C2X) || __MATH_DECLARING_FLOATN /* Like ilogb, but returning long int. */ __MATHDECL (long int, llogb,, (_Mdouble_ __x)); #endif #ifdef __USE_ISOC99 /* Return X times (2 to the Nth power). */ __MATHCALL (scalbln,, (_Mdouble_ __x, long int __n)); /* Round X to integral value in floating-point format using current rounding direction, but do not raise inexact exception. */ __MATHCALL (nearbyint,, (_Mdouble_ __x)); /* Round X to nearest integral value, rounding halfway cases away from zero. */ __MATHCALLX (round,, (_Mdouble_ __x), (__const__)); /* Round X to the integral value in floating-point format nearest but not larger in magnitude. */ __MATHCALLX (trunc,, (_Mdouble_ __x), (__const__)); /* Compute remainder of X and Y and put in *QUO a value with sign of x/y and magnitude congruent `mod 2^n' to the magnitude of the integral quotient x/y, with n >= 3. */ __MATHCALL (remquo,, (_Mdouble_ __x, _Mdouble_ __y, int *__quo)); /* Conversion functions. */ /* Round X to nearest integral value according to current rounding direction. */ __MATHDECL (long int,lrint,, (_Mdouble_ __x)); __extension__ __MATHDECL (long long int,llrint,, (_Mdouble_ __x)); /* Round X to nearest integral value, rounding halfway cases away from zero. */ __MATHDECL (long int,lround,, (_Mdouble_ __x)); __extension__ __MATHDECL (long long int,llround,, (_Mdouble_ __x)); /* Return positive difference between X and Y. */ __MATHCALL (fdim,, (_Mdouble_ __x, _Mdouble_ __y)); /* Return maximum numeric value from X and Y. */ __MATHCALLX (fmax,, (_Mdouble_ __x, _Mdouble_ __y), (__const__)); /* Return minimum numeric value from X and Y. */ __MATHCALLX (fmin,, (_Mdouble_ __x, _Mdouble_ __y), (__const__)); /* Multiply-add function computed as a ternary operation. */ __MATHCALL (fma,, (_Mdouble_ __x, _Mdouble_ __y, _Mdouble_ __z)); #endif /* Use ISO C99. */ #if __GLIBC_USE (IEC_60559_BFP_EXT_C2X) || __MATH_DECLARING_FLOATN /* Round X to nearest integer value, rounding halfway cases to even. */ __MATHCALLX (roundeven,, (_Mdouble_ __x), (__const__)); /* Round X to nearest signed integer value, not raising inexact, with control of rounding direction and width of result. */ __MATHDECL (__intmax_t, fromfp,, (_Mdouble_ __x, int __round, unsigned int __width)); /* Round X to nearest unsigned integer value, not raising inexact, with control of rounding direction and width of result. */ __MATHDECL (__uintmax_t, ufromfp,, (_Mdouble_ __x, int __round, unsigned int __width)); /* Round X to nearest signed integer value, raising inexact for non-integers, with control of rounding direction and width of result. */ __MATHDECL (__intmax_t, fromfpx,, (_Mdouble_ __x, int __round, unsigned int __width)); /* Round X to nearest unsigned integer value, raising inexact for non-integers, with control of rounding direction and width of result. */ __MATHDECL (__uintmax_t, ufromfpx,, (_Mdouble_ __x, int __round, unsigned int __width)); /* Canonicalize floating-point representation. */ __MATHDECL_1 (int, canonicalize,, (_Mdouble_ *__cx, const _Mdouble_ *__x)); #endif #if (__GLIBC_USE (IEC_60559_BFP_EXT) \ || (__MATH_DECLARING_FLOATN \ && (defined __USE_GNU || !__GLIBC_USE (ISOC2X)))) /* Return value with maximum magnitude. */ __MATHCALLX (fmaxmag,, (_Mdouble_ __x, _Mdouble_ __y), (__const__)); /* Return value with minimum magnitude. */ __MATHCALLX (fminmag,, (_Mdouble_ __x, _Mdouble_ __y), (__const__)); #endif #if __GLIBC_USE (IEC_60559_EXT) || __MATH_DECLARING_FLOATN /* Total order operation. */ __MATHDECL_1 (int, totalorder,, (const _Mdouble_ *__x, const _Mdouble_ *__y)) __attribute_pure__; /* Total order operation on absolute values. */ __MATHDECL_1 (int, totalordermag,, (const _Mdouble_ *__x, const _Mdouble_ *__y)) __attribute_pure__; /* Get NaN payload. */ __MATHCALL (getpayload,, (const _Mdouble_ *__x)); /* Set quiet NaN payload. */ __MATHDECL_1 (int, setpayload,, (_Mdouble_ *__x, _Mdouble_ __payload)); /* Set signaling NaN payload. */ __MATHDECL_1 (int, setpayloadsig,, (_Mdouble_ *__x, _Mdouble_ __payload)); #endif #if (defined __USE_MISC || (defined __USE_XOPEN_EXTENDED \ && __MATH_DECLARING_DOUBLE \ && !defined __USE_XOPEN2K8)) \ && !__MATH_DECLARING_FLOATN /* Return X times (2 to the Nth power). */ __MATHCALL (scalb,, (_Mdouble_ __x, _Mdouble_ __n)); #endif sigthread.h 0000644 00000003234 15125171642 0006675 0 ustar 00 /* Signal handling function for threaded programs. Copyright (C) 1998-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; see the file COPYING.LIB. If not, see <https://www.gnu.org/licenses/>. */ #ifndef _BITS_SIGTHREAD_H #define _BITS_SIGTHREAD_H 1 #if !defined _SIGNAL_H && !defined _PTHREAD_H # error "Never include this file directly. Use <signal.h> instead" #endif /* Functions for handling signals. */ #include <bits/types/__sigset_t.h> /* Modify the signal mask for the calling thread. The arguments have the same meaning as for sigprocmask(2). */ extern int pthread_sigmask (int __how, const __sigset_t *__restrict __newmask, __sigset_t *__restrict __oldmask)__THROW; /* Send signal SIGNO to the given thread. */ extern int pthread_kill (pthread_t __threadid, int __signo) __THROW; #ifdef __USE_GNU /* Queue signal and data to a thread. */ extern int pthread_sigqueue (pthread_t __threadid, int __signo, const union sigval __value) __THROW; #endif #endif /* bits/sigthread.h */ time.h 0000644 00000006340 15125171642 0005662 0 ustar 00 /* System-dependent timing definitions. Linux version. Copyright (C) 1996-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ /* * Never include this file directly; use <time.h> instead. */ #ifndef _BITS_TIME_H #define _BITS_TIME_H 1 #include <bits/types.h> /* ISO/IEC 9899:1999 7.23.1: Components of time The macro `CLOCKS_PER_SEC' is an expression with type `clock_t' that is the number per second of the value returned by the `clock' function. */ /* CAE XSH, Issue 4, Version 2: <time.h> The value of CLOCKS_PER_SEC is required to be 1 million on all XSI-conformant systems. */ #define CLOCKS_PER_SEC ((__clock_t) 1000000) #if (!defined __STRICT_ANSI__ || defined __USE_POSIX) \ && !defined __USE_XOPEN2K /* Even though CLOCKS_PER_SEC has such a strange value CLK_TCK presents the real value for clock ticks per second for the system. */ extern long int __sysconf (int); # define CLK_TCK ((__clock_t) __sysconf (2)) /* 2 is _SC_CLK_TCK */ #endif #ifdef __USE_POSIX199309 /* Identifier for system-wide realtime clock. */ # define CLOCK_REALTIME 0 /* Monotonic system-wide clock. */ # define CLOCK_MONOTONIC 1 /* High-resolution timer from the CPU. */ # define CLOCK_PROCESS_CPUTIME_ID 2 /* Thread-specific CPU-time clock. */ # define CLOCK_THREAD_CPUTIME_ID 3 /* Monotonic system-wide clock, not adjusted for frequency scaling. */ # define CLOCK_MONOTONIC_RAW 4 /* Identifier for system-wide realtime clock, updated only on ticks. */ # define CLOCK_REALTIME_COARSE 5 /* Monotonic system-wide clock, updated only on ticks. */ # define CLOCK_MONOTONIC_COARSE 6 /* Monotonic system-wide clock that includes time spent in suspension. */ # define CLOCK_BOOTTIME 7 /* Like CLOCK_REALTIME but also wakes suspended system. */ # define CLOCK_REALTIME_ALARM 8 /* Like CLOCK_BOOTTIME but also wakes suspended system. */ # define CLOCK_BOOTTIME_ALARM 9 /* Like CLOCK_REALTIME but in International Atomic Time. */ # define CLOCK_TAI 11 /* Flag to indicate time is absolute. */ # define TIMER_ABSTIME 1 #endif #ifdef __USE_GNU # include <bits/timex.h> __BEGIN_DECLS /* Tune a POSIX clock. */ extern int clock_adjtime (__clockid_t __clock_id, struct timex *__utx) __THROW; #ifdef __USE_TIME_BITS64 # if defined(__REDIRECT_NTH) extern int __REDIRECT_NTH (clock_adjtime, (__clockid_t __clock_id, struct timex *__utx), __clock_adjtime64); # else # define clock_adjtime __clock_adjtime64 # endif #endif __END_DECLS #endif /* use GNU */ #endif /* bits/time.h */ signum-arch.h 0000644 00000005024 15125171642 0007137 0 ustar 00 /* Signal number definitions. Linux version. Copyright (C) 1995-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _BITS_SIGNUM_ARCH_H #define _BITS_SIGNUM_ARCH_H 1 #ifndef _SIGNAL_H #error "Never include <bits/signum-arch.h> directly; use <signal.h> instead." #endif /* Adjustments and additions to the signal number constants for most Linux systems. */ #define SIGSTKFLT 16 /* Stack fault (obsolete). */ #define SIGPWR 30 /* Power failure imminent. */ /* Historical signals specified by POSIX. */ #define SIGBUS 7 /* Bus error. */ #define SIGSYS 31 /* Bad system call. */ /* New(er) POSIX signals (1003.1-2008, 1003.1-2013). */ #define SIGURG 23 /* Urgent data is available at a socket. */ #define SIGSTOP 19 /* Stop, unblockable. */ #define SIGTSTP 20 /* Keyboard stop. */ #define SIGCONT 18 /* Continue. */ #define SIGCHLD 17 /* Child terminated or stopped. */ #define SIGTTIN 21 /* Background read from control terminal. */ #define SIGTTOU 22 /* Background write to control terminal. */ #define SIGPOLL 29 /* Pollable event occurred (System V). */ #define SIGXFSZ 25 /* File size limit exceeded. */ #define SIGXCPU 24 /* CPU time limit exceeded. */ #define SIGVTALRM 26 /* Virtual timer expired. */ #define SIGPROF 27 /* Profiling timer expired. */ #define SIGUSR1 10 /* User-defined signal 1. */ #define SIGUSR2 12 /* User-defined signal 2. */ /* Nonstandard signals found in all modern POSIX systems (including both BSD and Linux). */ #define SIGWINCH 28 /* Window size change (4.3 BSD, Sun). */ /* Archaic names for compatibility. */ #define SIGIO SIGPOLL /* I/O now possible (4.2 BSD). */ #define SIGIOT SIGABRT /* IOT instruction, abort() on a PDP-11. */ #define SIGCLD SIGCHLD /* Old System V name */ #define __SIGRTMIN 32 #define __SIGRTMAX 64 #endif /* <signal.h> included. */ fcntl-linux.h 0000644 00000033342 15125171642 0007171 0 ustar 00 /* O_*, F_*, FD_* bit values for Linux. Copyright (C) 2001-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _FCNTL_H # error "Never use <bits/fcntl-linux.h> directly; include <fcntl.h> instead." #endif /* This file contains shared definitions between Linux architectures and is included by <bits/fcntl.h> to declare them. The various #ifndef cases allow the architecture specific file to define those values with different values. A minimal <bits/fcntl.h> contains just: struct flock {...} #ifdef __USE_LARGEFILE64 struct flock64 {...} #endif #include <bits/fcntl-linux.h> */ #ifdef __USE_GNU # include <bits/types/struct_iovec.h> #endif /* open/fcntl. */ #define O_ACCMODE 0003 #define O_RDONLY 00 #define O_WRONLY 01 #define O_RDWR 02 #ifndef O_CREAT # define O_CREAT 0100 /* Not fcntl. */ #endif #ifndef O_EXCL # define O_EXCL 0200 /* Not fcntl. */ #endif #ifndef O_NOCTTY # define O_NOCTTY 0400 /* Not fcntl. */ #endif #ifndef O_TRUNC # define O_TRUNC 01000 /* Not fcntl. */ #endif #ifndef O_APPEND # define O_APPEND 02000 #endif #ifndef O_NONBLOCK # define O_NONBLOCK 04000 #endif #ifndef O_NDELAY # define O_NDELAY O_NONBLOCK #endif #ifndef O_SYNC # define O_SYNC 04010000 #endif #define O_FSYNC O_SYNC #ifndef O_ASYNC # define O_ASYNC 020000 #endif #ifndef __O_LARGEFILE # define __O_LARGEFILE 0100000 #endif #ifndef __O_DIRECTORY # define __O_DIRECTORY 0200000 #endif #ifndef __O_NOFOLLOW # define __O_NOFOLLOW 0400000 #endif #ifndef __O_CLOEXEC # define __O_CLOEXEC 02000000 #endif #ifndef __O_DIRECT # define __O_DIRECT 040000 #endif #ifndef __O_NOATIME # define __O_NOATIME 01000000 #endif #ifndef __O_PATH # define __O_PATH 010000000 #endif #ifndef __O_DSYNC # define __O_DSYNC 010000 #endif #ifndef __O_TMPFILE # define __O_TMPFILE (020000000 | __O_DIRECTORY) #endif #ifndef F_GETLK # ifndef __USE_FILE_OFFSET64 # define F_GETLK 5 /* Get record locking info. */ # define F_SETLK 6 /* Set record locking info (non-blocking). */ # define F_SETLKW 7 /* Set record locking info (blocking). */ # else # define F_GETLK F_GETLK64 /* Get record locking info. */ # define F_SETLK F_SETLK64 /* Set record locking info (non-blocking).*/ # define F_SETLKW F_SETLKW64 /* Set record locking info (blocking). */ # endif #endif #ifndef F_GETLK64 # define F_GETLK64 12 /* Get record locking info. */ # define F_SETLK64 13 /* Set record locking info (non-blocking). */ # define F_SETLKW64 14 /* Set record locking info (blocking). */ #endif /* open file description locks. Usually record locks held by a process are released on *any* close and are not inherited across a fork. These cmd values will set locks that conflict with process-associated record locks, but are "owned" by the opened file description, not the process. This means that they are inherited across fork or clone with CLONE_FILES like BSD (flock) locks, and they are only released automatically when the last reference to the the file description against which they were acquired is put. */ #ifdef __USE_GNU # define F_OFD_GETLK 36 # define F_OFD_SETLK 37 # define F_OFD_SETLKW 38 #endif #ifdef __USE_LARGEFILE64 # define O_LARGEFILE __O_LARGEFILE #endif #ifdef __USE_XOPEN2K8 # define O_DIRECTORY __O_DIRECTORY /* Must be a directory. */ # define O_NOFOLLOW __O_NOFOLLOW /* Do not follow links. */ # define O_CLOEXEC __O_CLOEXEC /* Set close_on_exec. */ #endif #ifdef __USE_GNU # define O_DIRECT __O_DIRECT /* Direct disk access. */ # define O_NOATIME __O_NOATIME /* Do not set atime. */ # define O_PATH __O_PATH /* Resolve pathname but do not open file. */ # define O_TMPFILE __O_TMPFILE /* Atomically create nameless file. */ #endif /* For now, Linux has no separate synchronicity options for read operations. We define O_RSYNC therefore as the same as O_SYNC since this is a superset. */ #if defined __USE_POSIX199309 || defined __USE_UNIX98 # define O_DSYNC __O_DSYNC /* Synchronize data. */ # if defined __O_RSYNC # define O_RSYNC __O_RSYNC /* Synchronize read operations. */ # else # define O_RSYNC O_SYNC /* Synchronize read operations. */ # endif #endif /* Values for the second argument to `fcntl'. */ #define F_DUPFD 0 /* Duplicate file descriptor. */ #define F_GETFD 1 /* Get file descriptor flags. */ #define F_SETFD 2 /* Set file descriptor flags. */ #define F_GETFL 3 /* Get file status flags. */ #define F_SETFL 4 /* Set file status flags. */ #ifndef __F_SETOWN # define __F_SETOWN 8 # define __F_GETOWN 9 #endif #if defined __USE_UNIX98 || defined __USE_XOPEN2K8 # define F_SETOWN __F_SETOWN /* Get owner (process receiving SIGIO). */ # define F_GETOWN __F_GETOWN /* Set owner (process receiving SIGIO). */ #endif #ifndef __F_SETSIG # define __F_SETSIG 10 /* Set number of signal to be sent. */ # define __F_GETSIG 11 /* Get number of signal to be sent. */ #endif #ifndef __F_SETOWN_EX # define __F_SETOWN_EX 15 /* Get owner (thread receiving SIGIO). */ # define __F_GETOWN_EX 16 /* Set owner (thread receiving SIGIO). */ #endif #ifdef __USE_GNU # define F_SETSIG __F_SETSIG /* Set number of signal to be sent. */ # define F_GETSIG __F_GETSIG /* Get number of signal to be sent. */ # define F_SETOWN_EX __F_SETOWN_EX /* Get owner (thread receiving SIGIO). */ # define F_GETOWN_EX __F_GETOWN_EX /* Set owner (thread receiving SIGIO). */ #endif #ifdef __USE_GNU # define F_SETLEASE 1024 /* Set a lease. */ # define F_GETLEASE 1025 /* Enquire what lease is active. */ # define F_NOTIFY 1026 /* Request notifications on a directory. */ # define F_SETPIPE_SZ 1031 /* Set pipe page size array. */ # define F_GETPIPE_SZ 1032 /* Set pipe page size array. */ # define F_ADD_SEALS 1033 /* Add seals to file. */ # define F_GET_SEALS 1034 /* Get seals for file. */ /* Set / get write life time hints. */ # define F_GET_RW_HINT 1035 # define F_SET_RW_HINT 1036 # define F_GET_FILE_RW_HINT 1037 # define F_SET_FILE_RW_HINT 1038 #endif #ifdef __USE_XOPEN2K8 # define F_DUPFD_CLOEXEC 1030 /* Duplicate file descriptor with close-on-exit set. */ #endif /* For F_[GET|SET]FD. */ #define FD_CLOEXEC 1 /* Actually anything with low bit set goes */ #ifndef F_RDLCK /* For posix fcntl() and `l_type' field of a `struct flock' for lockf(). */ # define F_RDLCK 0 /* Read lock. */ # define F_WRLCK 1 /* Write lock. */ # define F_UNLCK 2 /* Remove lock. */ #endif /* For old implementation of BSD flock. */ #ifndef F_EXLCK # define F_EXLCK 4 /* or 3 */ # define F_SHLCK 8 /* or 4 */ #endif #ifdef __USE_MISC /* Operations for BSD flock, also used by the kernel implementation. */ # define LOCK_SH 1 /* Shared lock. */ # define LOCK_EX 2 /* Exclusive lock. */ # define LOCK_NB 4 /* Or'd with one of the above to prevent blocking. */ # define LOCK_UN 8 /* Remove lock. */ #endif #ifdef __USE_GNU # define LOCK_MAND 32 /* This is a mandatory flock: */ # define LOCK_READ 64 /* ... which allows concurrent read operations. */ # define LOCK_WRITE 128 /* ... which allows concurrent write operations. */ # define LOCK_RW 192 /* ... Which allows concurrent read & write operations. */ #endif #ifdef __USE_GNU /* Types of directory notifications that may be requested with F_NOTIFY. */ # define DN_ACCESS 0x00000001 /* File accessed. */ # define DN_MODIFY 0x00000002 /* File modified. */ # define DN_CREATE 0x00000004 /* File created. */ # define DN_DELETE 0x00000008 /* File removed. */ # define DN_RENAME 0x00000010 /* File renamed. */ # define DN_ATTRIB 0x00000020 /* File changed attributes. */ # define DN_MULTISHOT 0x80000000 /* Don't remove notifier. */ #endif #ifdef __USE_GNU /* Owner types. */ enum __pid_type { F_OWNER_TID = 0, /* Kernel thread. */ F_OWNER_PID, /* Process. */ F_OWNER_PGRP, /* Process group. */ F_OWNER_GID = F_OWNER_PGRP /* Alternative, obsolete name. */ }; /* Structure to use with F_GETOWN_EX and F_SETOWN_EX. */ struct f_owner_ex { enum __pid_type type; /* Owner type of ID. */ __pid_t pid; /* ID of owner. */ }; #endif #ifdef __USE_GNU /* Types of seals. */ # define F_SEAL_SEAL 0x0001 /* Prevent further seals from being set. */ # define F_SEAL_SHRINK 0x0002 /* Prevent file from shrinking. */ # define F_SEAL_GROW 0x0004 /* Prevent file from growing. */ # define F_SEAL_WRITE 0x0008 /* Prevent writes. */ # define F_SEAL_FUTURE_WRITE 0x0010 /* Prevent future writes while mapped. */ #endif #ifdef __USE_GNU /* Hint values for F_{GET,SET}_RW_HINT. */ # define RWH_WRITE_LIFE_NOT_SET 0 # define RWF_WRITE_LIFE_NOT_SET RWH_WRITE_LIFE_NOT_SET # define RWH_WRITE_LIFE_NONE 1 # define RWH_WRITE_LIFE_SHORT 2 # define RWH_WRITE_LIFE_MEDIUM 3 # define RWH_WRITE_LIFE_LONG 4 # define RWH_WRITE_LIFE_EXTREME 5 #endif /* Define some more compatibility macros to be backward compatible with BSD systems which did not managed to hide these kernel macros. */ #ifdef __USE_MISC # define FAPPEND O_APPEND # define FFSYNC O_FSYNC # define FASYNC O_ASYNC # define FNONBLOCK O_NONBLOCK # define FNDELAY O_NDELAY #endif /* Use misc. */ #ifndef __POSIX_FADV_DONTNEED # define __POSIX_FADV_DONTNEED 4 # define __POSIX_FADV_NOREUSE 5 #endif /* Advise to `posix_fadvise'. */ #ifdef __USE_XOPEN2K # define POSIX_FADV_NORMAL 0 /* No further special treatment. */ # define POSIX_FADV_RANDOM 1 /* Expect random page references. */ # define POSIX_FADV_SEQUENTIAL 2 /* Expect sequential page references. */ # define POSIX_FADV_WILLNEED 3 /* Will need these pages. */ # define POSIX_FADV_DONTNEED __POSIX_FADV_DONTNEED /* Don't need these pages. */ # define POSIX_FADV_NOREUSE __POSIX_FADV_NOREUSE /* Data will be accessed once. */ #endif #ifdef __USE_GNU /* Flags for SYNC_FILE_RANGE. */ # define SYNC_FILE_RANGE_WAIT_BEFORE 1 /* Wait upon writeout of all pages in the range before performing the write. */ # define SYNC_FILE_RANGE_WRITE 2 /* Initiate writeout of all those dirty pages in the range which are not presently under writeback. */ # define SYNC_FILE_RANGE_WAIT_AFTER 4 /* Wait upon writeout of all pages in the range after performing the write. */ /* SYNC_FILE_RANGE_WRITE_AND_WAIT ensures all pages in the range are written to disk before returning. */ # define SYNC_FILE_RANGE_WRITE_AND_WAIT (SYNC_FILE_RANGE_WRITE \ | SYNC_FILE_RANGE_WAIT_BEFORE \ | SYNC_FILE_RANGE_WAIT_AFTER) /* Flags for SPLICE and VMSPLICE. */ # define SPLICE_F_MOVE 1 /* Move pages instead of copying. */ # define SPLICE_F_NONBLOCK 2 /* Don't block on the pipe splicing (but we may still block on the fd we splice from/to). */ # define SPLICE_F_MORE 4 /* Expect more data. */ # define SPLICE_F_GIFT 8 /* Pages passed in are a gift. */ /* Flags for fallocate. */ # include <linux/falloc.h> /* File handle structure. */ struct file_handle { unsigned int handle_bytes; int handle_type; /* File identifier. */ unsigned char f_handle[0]; }; /* Maximum handle size (for now). */ # define MAX_HANDLE_SZ 128 #endif __BEGIN_DECLS #ifdef __USE_GNU /* Provide kernel hint to read ahead. */ extern __ssize_t readahead (int __fd, __off64_t __offset, size_t __count) __THROW; /* Selective file content synch'ing. This function is a possible cancellation point and therefore not marked with __THROW. */ extern int sync_file_range (int __fd, __off64_t __offset, __off64_t __count, unsigned int __flags); /* Splice address range into a pipe. This function is a possible cancellation point and therefore not marked with __THROW. */ extern __ssize_t vmsplice (int __fdout, const struct iovec *__iov, size_t __count, unsigned int __flags); /* Splice two files together. This function is a possible cancellation point and therefore not marked with __THROW. */ extern __ssize_t splice (int __fdin, __off64_t *__offin, int __fdout, __off64_t *__offout, size_t __len, unsigned int __flags); /* In-kernel implementation of tee for pipe buffers. This function is a possible cancellation point and therefore not marked with __THROW. */ extern __ssize_t tee (int __fdin, int __fdout, size_t __len, unsigned int __flags); /* Reserve storage for the data of the file associated with FD. This function is a possible cancellation point and therefore not marked with __THROW. */ # ifndef __USE_FILE_OFFSET64 extern int fallocate (int __fd, int __mode, __off_t __offset, __off_t __len); # else # ifdef __REDIRECT extern int __REDIRECT (fallocate, (int __fd, int __mode, __off64_t __offset, __off64_t __len), fallocate64); # else # define fallocate fallocate64 # endif # endif # ifdef __USE_LARGEFILE64 extern int fallocate64 (int __fd, int __mode, __off64_t __offset, __off64_t __len); # endif /* Map file name to file handle. */ extern int name_to_handle_at (int __dfd, const char *__name, struct file_handle *__handle, int *__mnt_id, int __flags) __THROW; /* Open file using the file handle. This function is a possible cancellation point and therefore not marked with __THROW. */ extern int open_by_handle_at (int __mountdirfd, struct file_handle *__handle, int __flags); #endif /* use GNU */ __END_DECLS wctype-wchar.h 0000644 00000014243 15125171642 0007342 0 ustar 00 /* Copyright (C) 1996-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ /* * ISO C99 Standard: 7.25 * Wide character classification and mapping utilities <wctype.h> */ #ifndef _BITS_WCTYPE_WCHAR_H #define _BITS_WCTYPE_WCHAR_H 1 #if !defined _WCTYPE_H && !defined _WCHAR_H #error "Never include <bits/wctype-wchar.h> directly; include <wctype.h> or <wchar.h> instead." #endif #include <bits/types.h> #include <bits/types/wint_t.h> /* The definitions in this header are specified to appear in <wctype.h> in ISO C99, but in <wchar.h> in Unix98. _GNU_SOURCE follows C99. */ /* Scalar type that can hold values which represent locale-specific character classifications. */ typedef unsigned long int wctype_t; # ifndef _ISwbit /* The characteristics are stored always in network byte order (big endian). We define the bit value interpretations here dependent on the machine's byte order. */ # include <bits/endian.h> # if __BYTE_ORDER == __BIG_ENDIAN # define _ISwbit(bit) (1 << (bit)) # else /* __BYTE_ORDER == __LITTLE_ENDIAN */ # define _ISwbit(bit) \ ((bit) < 8 ? (int) ((1UL << (bit)) << 24) \ : ((bit) < 16 ? (int) ((1UL << (bit)) << 8) \ : ((bit) < 24 ? (int) ((1UL << (bit)) >> 8) \ : (int) ((1UL << (bit)) >> 24)))) # endif enum { __ISwupper = 0, /* UPPERCASE. */ __ISwlower = 1, /* lowercase. */ __ISwalpha = 2, /* Alphabetic. */ __ISwdigit = 3, /* Numeric. */ __ISwxdigit = 4, /* Hexadecimal numeric. */ __ISwspace = 5, /* Whitespace. */ __ISwprint = 6, /* Printing. */ __ISwgraph = 7, /* Graphical. */ __ISwblank = 8, /* Blank (usually SPC and TAB). */ __ISwcntrl = 9, /* Control character. */ __ISwpunct = 10, /* Punctuation. */ __ISwalnum = 11, /* Alphanumeric. */ _ISwupper = _ISwbit (__ISwupper), /* UPPERCASE. */ _ISwlower = _ISwbit (__ISwlower), /* lowercase. */ _ISwalpha = _ISwbit (__ISwalpha), /* Alphabetic. */ _ISwdigit = _ISwbit (__ISwdigit), /* Numeric. */ _ISwxdigit = _ISwbit (__ISwxdigit), /* Hexadecimal numeric. */ _ISwspace = _ISwbit (__ISwspace), /* Whitespace. */ _ISwprint = _ISwbit (__ISwprint), /* Printing. */ _ISwgraph = _ISwbit (__ISwgraph), /* Graphical. */ _ISwblank = _ISwbit (__ISwblank), /* Blank (usually SPC and TAB). */ _ISwcntrl = _ISwbit (__ISwcntrl), /* Control character. */ _ISwpunct = _ISwbit (__ISwpunct), /* Punctuation. */ _ISwalnum = _ISwbit (__ISwalnum) /* Alphanumeric. */ }; # endif /* Not _ISwbit */ __BEGIN_DECLS /* * Wide-character classification functions: 7.15.2.1. */ /* Test for any wide character for which `iswalpha' or `iswdigit' is true. */ extern int iswalnum (wint_t __wc) __THROW; /* Test for any wide character for which `iswupper' or 'iswlower' is true, or any wide character that is one of a locale-specific set of wide-characters for which none of `iswcntrl', `iswdigit', `iswpunct', or `iswspace' is true. */ extern int iswalpha (wint_t __wc) __THROW; /* Test for any control wide character. */ extern int iswcntrl (wint_t __wc) __THROW; /* Test for any wide character that corresponds to a decimal-digit character. */ extern int iswdigit (wint_t __wc) __THROW; /* Test for any wide character for which `iswprint' is true and `iswspace' is false. */ extern int iswgraph (wint_t __wc) __THROW; /* Test for any wide character that corresponds to a lowercase letter or is one of a locale-specific set of wide characters for which none of `iswcntrl', `iswdigit', `iswpunct', or `iswspace' is true. */ extern int iswlower (wint_t __wc) __THROW; /* Test for any printing wide character. */ extern int iswprint (wint_t __wc) __THROW; /* Test for any printing wide character that is one of a locale-specific et of wide characters for which neither `iswspace' nor `iswalnum' is true. */ extern int iswpunct (wint_t __wc) __THROW; /* Test for any wide character that corresponds to a locale-specific set of wide characters for which none of `iswalnum', `iswgraph', or `iswpunct' is true. */ extern int iswspace (wint_t __wc) __THROW; /* Test for any wide character that corresponds to an uppercase letter or is one of a locale-specific set of wide character for which none of `iswcntrl', `iswdigit', `iswpunct', or `iswspace' is true. */ extern int iswupper (wint_t __wc) __THROW; /* Test for any wide character that corresponds to a hexadecimal-digit character equivalent to that performed be the functions described in the previous subclause. */ extern int iswxdigit (wint_t __wc) __THROW; /* Test for any wide character that corresponds to a standard blank wide character or a locale-specific set of wide characters for which `iswalnum' is false. */ # ifdef __USE_ISOC99 extern int iswblank (wint_t __wc) __THROW; # endif /* * Extensible wide-character classification functions: 7.15.2.2. */ /* Construct value that describes a class of wide characters identified by the string argument PROPERTY. */ extern wctype_t wctype (const char *__property) __THROW; /* Determine whether the wide-character WC has the property described by DESC. */ extern int iswctype (wint_t __wc, wctype_t __desc) __THROW; /* * Wide-character case-mapping functions: 7.15.3.1. */ /* Converts an uppercase letter to the corresponding lowercase letter. */ extern wint_t towlower (wint_t __wc) __THROW; /* Converts an lowercase letter to the corresponding uppercase letter. */ extern wint_t towupper (wint_t __wc) __THROW; __END_DECLS #endif /* bits/wctype-wchar.h. */ xopen_lim.h 0000644 00000007422 15125171642 0006720 0 ustar 00 /* Copyright (C) 1996-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ /* * Never include this file directly; use <limits.h> instead. */ /* Additional definitions from X/Open Portability Guide, Issue 4, Version 2 System Interfaces and Headers, 4.16 <limits.h> Please note only the values which are not greater than the minimum stated in the standard document are listed. The `sysconf' functions should be used to obtain the actual value. */ #ifndef _XOPEN_LIM_H #define _XOPEN_LIM_H 1 /* We do not provide fixed values for ARG_MAX Maximum length of argument to the `exec' function including environment data. ATEXIT_MAX Maximum number of functions that may be registered with `atexit'. CHILD_MAX Maximum number of simultaneous processes per real user ID. OPEN_MAX Maximum number of files that one process can have open at anyone time. PAGESIZE PAGE_SIZE Size of bytes of a page. PASS_MAX Maximum number of significant bytes in a password. We only provide a fixed limit for IOV_MAX Maximum number of `iovec' structures that one process has available for use with `readv' or writev'. if this is indeed fixed by the underlying system. */ /* Maximum number of `iovec' structures that may be used in a single call to `readv', `writev', etc. */ #define _XOPEN_IOV_MAX _POSIX_UIO_MAXIOV #include <bits/uio_lim.h> #ifdef __IOV_MAX # define IOV_MAX __IOV_MAX #else # undef IOV_MAX #endif /* Maximum value of `digit' in calls to the `printf' and `scanf' functions. We have no limit, so return a reasonable value. */ #define NL_ARGMAX _POSIX_ARG_MAX /* Maximum number of bytes in a `LANG' name. We have no limit. */ #define NL_LANGMAX _POSIX2_LINE_MAX /* Maximum message number. We have no limit. */ #define NL_MSGMAX INT_MAX /* Maximum number of bytes in N-to-1 collation mapping. We have no limit. */ #if defined __USE_GNU || !defined __USE_XOPEN2K8 # define NL_NMAX INT_MAX #endif /* Maximum set number. We have no limit. */ #define NL_SETMAX INT_MAX /* Maximum number of bytes in a message. We have no limit. */ #define NL_TEXTMAX INT_MAX /* Default process priority. */ #define NZERO 20 /* Number of bits in a word of type `int'. */ #ifdef INT_MAX # if INT_MAX == 32767 # define WORD_BIT 16 # else # if INT_MAX == 2147483647 # define WORD_BIT 32 # else /* Safe assumption. */ # define WORD_BIT 64 # endif # endif #elif defined __INT_MAX__ # if __INT_MAX__ == 32767 # define WORD_BIT 16 # else # if __INT_MAX__ == 2147483647 # define WORD_BIT 32 # else /* Safe assumption. */ # define WORD_BIT 64 # endif # endif #else # define WORD_BIT 32 #endif /* Number of bits in a word of type `long int'. */ #ifdef LONG_MAX # if LONG_MAX == 2147483647 # define LONG_BIT 32 # else /* Safe assumption. */ # define LONG_BIT 64 # endif #elif defined __LONG_MAX__ # if __LONG_MAX__ == 2147483647 # define LONG_BIT 32 # else /* Safe assumption. */ # define LONG_BIT 64 # endif #else # include <bits/wordsize.h> # if __WORDSIZE == 64 # define LONG_BIT 64 # else # define LONG_BIT 32 # endif #endif #endif /* bits/xopen_lim.h */ unistd_ext.h 0000644 00000004752 15125171642 0007117 0 ustar 00 /* System-specific extensions of <unistd.h>, Linux version. Copyright (C) 2019-2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ #ifndef _UNISTD_H # error "Never include <bits/unistd_ext.h> directly; use <unistd.h> instead." #endif #ifdef __USE_GNU /* Return the kernel thread ID (TID) of the current thread. The returned value is not subject to caching. Most Linux system calls accept a TID in place of a PID. Using the TID to change properties of a thread that has been created using pthread_create can lead to undefined behavior (comparable to manipulating file descriptors directly that have not been created explicitly). Note that a TID uniquely identifies a thread only while this thread is running; a TID can be reused once a thread has exited, even if the thread is not detached and has not been joined. */ extern __pid_t gettid (void) __THROW; #ifdef __has_include # if __has_include ("linux/close_range.h") # include "linux/close_range.h" # endif #endif /* Unshare the file descriptor table before closing file descriptors. */ #ifndef CLOSE_RANGE_UNSHARE # define CLOSE_RANGE_UNSHARE (1U << 1) #endif /* Set the FD_CLOEXEC bit instead of closing the file descriptor. */ #ifndef CLOSE_RANGE_CLOEXEC # define CLOSE_RANGE_CLOEXEC (1U << 2) #endif /* Close all file descriptors in the range FD up to MAX_FD. The flag FLAGS are define by the CLOSE_RANGE prefix. This function behaves like close on the range, but in a fail-safe where it will either fail and not close any file descriptor or close all of them. Gaps where the file descriptor is invalid are ignored. Returns 0 on successor or -1 for failure (and sets errno accordingly). */ extern int close_range (unsigned int __fd, unsigned int __max_fd, int __flags) __THROW; #endif /* __USE_GNU */ pthread_stack_min.h 0000644 00000001662 15125171642 0010405 0 ustar 00 /* Definition of PTHREAD_STACK_MIN. Linux version. Copyright (C) 2021 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <https://www.gnu.org/licenses/>. */ /* Minimum size for a thread. We are free to choose a reasonable value. */ #define PTHREAD_STACK_MIN 16384
| ver. 1.6 |
Github
|
.
| PHP 8.2.30 | ??????????? ?????????: 0.02 |
proxy
|
phpinfo
|
???????????