├── .tarball-version
├── .version
├── AUTHORS
├── COPYING
├── CREDITS
├── ChangeLog
├── ChangeLog-CVS
├── INSTALL
├── Makefile.am
├── Makefile.in
├── NEWS
├── README
├── README-linux
├── README-linux-ptrace
├── aclocal.m4
├── aio.c
├── bjm.c
├── block.c
├── compile
├── config.guess
├── config.h.in
├── config.sub
├── configure
├── configure.ac
├── count.c
├── debian
    ├── changelog
    ├── compat
    ├── control
    ├── copyright
    ├── rules
    ├── source
    │   └── format
    ├── strace-udeb.install
    ├── strace.docs
    ├── strace.examples
    ├── strace.install
    ├── strace.manpages
    ├── strace64.install
    ├── strace64.manpages
    └── watch
├── defs.h
├── depcomp
├── desc.c
├── errnoent.sh
├── fanotify.c
├── file.c
├── inotify.c
├── install-sh
├── io.c
├── ioctl.c
├── ioprio.c
├── ipc.c
├── kexec.c
├── keyctl.c
├── ldt.c
├── linux
    ├── aarch64
    │   ├── errnoent1.h
    │   ├── ioctlent.h.in
    │   ├── ioctlent1.h
    │   ├── signalent1.h
    │   ├── syscallent.h
    │   └── syscallent1.h
    ├── alpha
    │   ├── errnoent.h
    │   ├── ioctlent.h.in
    │   ├── signalent.h
    │   └── syscallent.h
    ├── arc
    │   ├── ioctlent.h.in
    │   └── syscallent.h
    ├── arm
    │   ├── ioctlent.h.in
    │   └── syscallent.h
    ├── avr32
    │   ├── ioctlent.h.in
    │   └── syscallent.h
    ├── bfin
    │   ├── ioctlent.h.in
    │   └── syscallent.h
    ├── dummy.h
    ├── errnoent.h
    ├── fanotify.h
    ├── hppa
    │   ├── errnoent.h
    │   ├── ioctlent.h.in
    │   ├── signalent.h
    │   └── syscallent.h
    ├── i386
    │   ├── ioctlent.h.in
    │   └── syscallent.h
    ├── ia64
    │   ├── ioctlent.h.in
    │   ├── signalent.h
    │   └── syscallent.h
    ├── inotify.h
    ├── ioctlent-filter.awk
    ├── ioctlent.h.in
    ├── ioctlent.sh
    ├── ioctlsort.c
    ├── kexec.h
    ├── keyctl.h
    ├── m68k
    │   ├── ioctlent.h.in
    │   └── syscallent.h
    ├── metag
    │   ├── ioctlent.h.in
    │   └── syscallent.h
    ├── microblaze
    │   ├── ioctlent.h.in
    │   └── syscallent.h
    ├── mips
    │   ├── errnoent.h
    │   ├── ioctlent.h.in
    │   ├── ioctlent.sh
    │   ├── signalent.h
    │   ├── syscallent-compat.h
    │   ├── syscallent-n32.h
    │   ├── syscallent-n64.h
    │   ├── syscallent-o32.h
    │   └── syscallent.h
    ├── mtd-abi.h
    ├── or1k
    │   ├── ioctlent.h.in
    │   └── syscallent.h
    ├── personality.h
    ├── powerpc
    │   ├── errnoent1.h
    │   ├── ioctlent.h.in
    │   ├── ioctlent1.h
    │   ├── signalent1.h
    │   ├── syscallent.h
    │   └── syscallent1.h
    ├── ptp_clock.h
    ├── reboot.h
    ├── riscv
    │   ├── errnoent1.h
    │   ├── ioctlent.h.in
    │   ├── ioctlent1.h
    │   ├── signalent1.h
    │   ├── syscallent.h
    │   └── syscallent1.h
    ├── s390
    │   ├── ioctlent.h.in
    │   └── syscallent.h
    ├── s390x
    │   ├── ioctlent.h.in
    │   └── syscallent.h
    ├── sh
    │   ├── ioctlent.h.in
    │   └── syscallent.h
    ├── sh64
    │   ├── ioctlent.h.in
    │   └── syscallent.h
    ├── signalent.h
    ├── sparc
    │   ├── dummy2.h
    │   ├── errnoent.h
    │   ├── errnoent1.h
    │   ├── gen.pl
    │   ├── ioctlent.h.in
    │   ├── ioctlent1.h
    │   ├── signalent.h
    │   ├── signalent1.h
    │   ├── syscall1.h
    │   ├── syscallent.h
    │   └── syscallent1.h
    ├── sparc64
    │   ├── dummy2.h
    │   ├── errnoent.h
    │   ├── errnoent1.h
    │   ├── errnoent2.h
    │   ├── ioctlent.h.in
    │   ├── ioctlent1.h
    │   ├── ioctlent2.h
    │   ├── signalent.h
    │   ├── signalent1.h
    │   ├── signalent2.h
    │   ├── syscall1.h
    │   ├── syscallent.h
    │   ├── syscallent1.h
    │   └── syscallent2.h
    ├── subcall.h
    ├── syscall.h
    ├── tile
    │   ├── errnoent1.h
    │   ├── ioctlent.h.in
    │   ├── ioctlent1.h
    │   ├── signalent1.h
    │   ├── syscallent.h
    │   └── syscallent1.h
    ├── ubi-user.h
    ├── x32
    │   ├── errnoent.h
    │   ├── errnoent1.h
    │   ├── ioctlent.h.in
    │   ├── ioctlent1.h
    │   ├── signalent.h
    │   ├── signalent1.h
    │   ├── syscallent.h
    │   └── syscallent1.h
    ├── x86_64
    │   ├── errnoent1.h
    │   ├── errnoent2.h
    │   ├── gentab.pl
    │   ├── ioctlent.h.in
    │   ├── ioctlent1.h
    │   ├── ioctlent2.h
    │   ├── signalent1.h
    │   ├── signalent2.h
    │   ├── syscallent.h
    │   ├── syscallent1.h
    │   └── syscallent2.h
    └── xtensa
    │   ├── ioctlent.h.in
    │   └── syscallent.h
├── loop.c
├── m4
    ├── includedir.m4
    ├── long_long.m4
    ├── stat.m4
    ├── statfs.m4
    └── warnings.m4
├── mem.c
├── missing
├── mtd.c
├── net.c
├── pathtrace.c
├── process.c
├── ptp.c
├── quota.c
├── reboot.c
├── resource.c
├── scsi.c
├── signal.c
├── signalent.sh
├── sock.c
├── strace-graph
├── strace-log-merge
├── strace.1
├── strace.c
├── strace.spec
├── stream.c
├── syscall.c
├── syscallent.sh
├── system.c
├── term.c
├── test-driver
├── tests
    ├── Makefile.am
    ├── Makefile.in
    ├── count.test
    ├── detach-running.test
    ├── detach-sleeping.test
    ├── detach-stopped.test
    ├── init.sh
    ├── net-accept-connect.c
    ├── net-fd.test
    ├── net.test
    ├── ptrace_setoptions.test
    ├── qual_syscall.test
    ├── run.sh
    ├── scm_rights-fd.test
    ├── scm_rights.c
    ├── set_ptracer_any.c
    ├── sigaction.awk
    ├── sigaction.c
    ├── sigaction.test
    ├── stack-fcall-0.c
    ├── stack-fcall-1.c
    ├── stack-fcall-2.c
    ├── stack-fcall-3.c
    ├── stack-fcall.c
    ├── stat.test
    ├── strace-f.test
    ├── strace-k.test
    ├── uio.c
    └── uio.test
├── time.c
├── unwind.c
├── util.c
├── vsprintf.c
├── xlat
    ├── Makemodule.am
    ├── access_flags.h
    ├── access_flags.in
    ├── aclcmds.h
    ├── aclcmds.in
    ├── aclipc.h
    ├── aclipc.in
    ├── addrfams.h
    ├── addrfams.in
    ├── adjtimex_modes.h
    ├── adjtimex_modes.in
    ├── adjtimex_state.h
    ├── adjtimex_state.in
    ├── adjtimex_status.h
    ├── adjtimex_status.in
    ├── advise.h
    ├── advise.in
    ├── af_packet_types.h
    ├── af_packet_types.in
    ├── archvals.h
    ├── archvals.in
    ├── at_flags.h
    ├── at_flags.in
    ├── atomic_ops.h
    ├── atomic_ops.in
    ├── baud_options.h
    ├── baud_options.in
    ├── blkpg_ops.h
    ├── blkpg_ops.in
    ├── bootflags1.h
    ├── bootflags1.in
    ├── bootflags2.h
    ├── bootflags2.in
    ├── bootflags3.h
    ├── bootflags3.in
    ├── cacheflush_scope.h
    ├── cacheflush_scope.in
    ├── cap_version.h
    ├── cap_version.in
    ├── capabilities.h
    ├── capabilities.in
    ├── clockflags.h
    ├── clockflags.in
    ├── clocknames.h
    ├── clocknames.in
    ├── clone_flags.h
    ├── clone_flags.in
    ├── cpuclocknames.h
    ├── cpuclocknames.in
    ├── delete_module_flags.h
    ├── delete_module_flags.in
    ├── direnttypes.h
    ├── direnttypes.in
    ├── domains.h
    ├── domains.in
    ├── epollctls.h
    ├── epollctls.in
    ├── epollevents.h
    ├── epollevents.in
    ├── epollflags.h
    ├── epollflags.in
    ├── fan_classes.h
    ├── fan_classes.in
    ├── fan_event_flags.h
    ├── fan_event_flags.in
    ├── fan_init_flags.h
    ├── fan_init_flags.in
    ├── fan_mark_flags.h
    ├── fan_mark_flags.in
    ├── fcntlcmds.h
    ├── fcntlcmds.in
    ├── fdflags.h
    ├── fdflags.in
    ├── fileflags.h
    ├── fileflags.in
    ├── flockcmds.h
    ├── flockcmds.in
    ├── fsmagic.h
    ├── fsmagic.in
    ├── futexops.h
    ├── futexops.in
    ├── futexwakecmps.h
    ├── futexwakecmps.in
    ├── futexwakeops.h
    ├── futexwakeops.in
    ├── gen.sh
    ├── icmpfilterflags.h
    ├── icmpfilterflags.in
    ├── if_dqblk_valid.h
    ├── if_dqblk_valid.in
    ├── if_dqinfo_valid.h
    ├── if_dqinfo_valid.in
    ├── iffflags.h
    ├── iffflags.in
    ├── inet_protocols.h
    ├── inet_protocols.in
    ├── inotify_flags.h
    ├── inotify_flags.in
    ├── inotify_init_flags.h
    ├── inotify_init_flags.in
    ├── ioprio_class.h
    ├── ioprio_class.in
    ├── ioprio_who.h
    ├── ioprio_who.in
    ├── ipc_msg_flags.h
    ├── ipc_msg_flags.in
    ├── itimer_which.h
    ├── itimer_which.in
    ├── kexec_arch_values.h
    ├── kexec_arch_values.in
    ├── kexec_flags.h
    ├── kexec_flags.in
    ├── key_perms.h
    ├── key_perms.in
    ├── key_reqkeys.h
    ├── key_reqkeys.in
    ├── key_spec.h
    ├── key_spec.in
    ├── keyctl_commands.h
    ├── keyctl_commands.in
    ├── lockfcmds.h
    ├── lockfcmds.in
    ├── loop_crypt_type_options.h
    ├── loop_crypt_type_options.in
    ├── loop_flags_options.h
    ├── loop_flags_options.in
    ├── madvise_cmds.h
    ├── madvise_cmds.in
    ├── mbindflags.h
    ├── mbindflags.in
    ├── mctl_funcs.h
    ├── mctl_funcs.in
    ├── mctl_lockas.h
    ├── mctl_lockas.in
    ├── mctl_sync.h
    ├── mctl_sync.in
    ├── mempolicyflags.h
    ├── mempolicyflags.in
    ├── mlockall_flags.h
    ├── mlockall_flags.in
    ├── mmap_flags.h
    ├── mmap_flags.in
    ├── mmap_prot.h
    ├── mmap_prot.in
    ├── modem_flags.h
    ├── modem_flags.in
    ├── modetypes.h
    ├── modetypes.in
    ├── modflags.h
    ├── modflags.in
    ├── module_init_flags.h
    ├── module_init_flags.in
    ├── mount_flags.h
    ├── mount_flags.in
    ├── move_pages_flags.h
    ├── move_pages_flags.in
    ├── mremap_flags.h
    ├── mremap_flags.in
    ├── msg_flags.h
    ├── msg_flags.in
    ├── msgctl_flags.h
    ├── msgctl_flags.in
    ├── msgflags.h
    ├── msgflags.in
    ├── mtd_flags_options.h
    ├── mtd_flags_options.in
    ├── mtd_mode_options.h
    ├── mtd_mode_options.in
    ├── mtd_nandecc_options.h
    ├── mtd_nandecc_options.in
    ├── mtd_otp_options.h
    ├── mtd_otp_options.in
    ├── mtd_type_options.h
    ├── mtd_type_options.in
    ├── netlink_protocols.h
    ├── netlink_protocols.in
    ├── notifyflags.h
    ├── notifyflags.in
    ├── nt_descriptor_types.h
    ├── nt_descriptor_types.in
    ├── open_access_modes.h
    ├── open_access_modes.in
    ├── open_mode_flags.h
    ├── open_mode_flags.in
    ├── openmodessol.h
    ├── openmodessol.in
    ├── perf_event_open_flags.h
    ├── perf_event_open_flags.in
    ├── personality_options.h
    ├── personality_options.in
    ├── pmsgflags.h
    ├── pmsgflags.in
    ├── policies.h
    ├── policies.in
    ├── pollflags.h
    ├── pollflags.in
    ├── prctl_options.h
    ├── prctl_options.in
    ├── priorities.h
    ├── priorities.in
    ├── ptp_flags_options.h
    ├── ptp_flags_options.in
    ├── ptrace_cmds.h
    ├── ptrace_cmds.in
    ├── ptrace_setoptions_flags.h
    ├── ptrace_setoptions_flags.in
    ├── qm_which.h
    ├── qm_which.in
    ├── quota_formats.h
    ├── quota_formats.in
    ├── quotacmds.h
    ├── quotacmds.in
    ├── quotatypes.h
    ├── quotatypes.in
    ├── rename_flags.h
    ├── rename_flags.in
    ├── resource_flags.h
    ├── resource_flags.in
    ├── resources.h
    ├── resources.in
    ├── schedulers.h
    ├── schedulers.in
    ├── scmvals.h
    ├── scmvals.in
    ├── semctl_flags.h
    ├── semctl_flags.in
    ├── semop_flags.h
    ├── semop_flags.in
    ├── sg_io_dxfer_direction.h
    ├── sg_io_dxfer_direction.in
    ├── shm_flags.h
    ├── shm_flags.in
    ├── shm_resource_flags.h
    ├── shm_resource_flags.in
    ├── shmctl_flags.h
    ├── shmctl_flags.in
    ├── shutdown_modes.h
    ├── shutdown_modes.in
    ├── sigact_flags.h
    ├── sigact_flags.in
    ├── sigaltstack_flags.h
    ├── sigaltstack_flags.in
    ├── sigbus_codes.h
    ├── sigbus_codes.in
    ├── sigchld_codes.h
    ├── sigchld_codes.in
    ├── sigemt_codes.h
    ├── sigemt_codes.in
    ├── sigev_value.h
    ├── sigev_value.in
    ├── sigfpe_codes.h
    ├── sigfpe_codes.in
    ├── sigill_codes.h
    ├── sigill_codes.in
    ├── siginfo_codes.h
    ├── siginfo_codes.in
    ├── sigpoll_codes.h
    ├── sigpoll_codes.in
    ├── sigprocmaskcmds.h
    ├── sigprocmaskcmds.in
    ├── sigprof_codes.h
    ├── sigprof_codes.in
    ├── sigsegv_codes.h
    ├── sigsegv_codes.in
    ├── sigsys_codes.h
    ├── sigsys_codes.in
    ├── sigtrap_codes.h
    ├── sigtrap_codes.in
    ├── sock_type_flags.h
    ├── sock_type_flags.in
    ├── socketlayers.h
    ├── socketlayers.in
    ├── sockipoptions.h
    ├── sockipoptions.in
    ├── sockipv6options.h
    ├── sockipv6options.in
    ├── sockipxoptions.h
    ├── sockipxoptions.in
    ├── sockoptions.h
    ├── sockoptions.in
    ├── sockpacketoptions.h
    ├── sockpacketoptions.in
    ├── sockrawoptions.h
    ├── sockrawoptions.in
    ├── socksctpoptions.h
    ├── socksctpoptions.in
    ├── socktcpoptions.h
    ├── socktcpoptions.in
    ├── socktypes.h
    ├── socktypes.in
    ├── splice_flags.h
    ├── splice_flags.in
    ├── sram_alloc_flags.h
    ├── sram_alloc_flags.in
    ├── swap_flags.h
    ├── swap_flags.in
    ├── sync_file_range_flags.h
    ├── sync_file_range_flags.in
    ├── sysctl_kern.h
    ├── sysctl_kern.in
    ├── sysctl_net.h
    ├── sysctl_net.in
    ├── sysctl_net_core.h
    ├── sysctl_net_core.in
    ├── sysctl_net_ipv4.h
    ├── sysctl_net_ipv4.in
    ├── sysctl_net_ipv4_conf.h
    ├── sysctl_net_ipv4_conf.in
    ├── sysctl_net_ipv4_route.h
    ├── sysctl_net_ipv4_route.in
    ├── sysctl_net_ipv6.h
    ├── sysctl_net_ipv6.in
    ├── sysctl_net_ipv6_route.h
    ├── sysctl_net_ipv6_route.in
    ├── sysctl_net_unix.h
    ├── sysctl_net_unix.in
    ├── sysctl_root.h
    ├── sysctl_root.in
    ├── sysctl_vm.h
    ├── sysctl_vm.in
    ├── syslog_action_type.h
    ├── syslog_action_type.in
    ├── sysmips_operations.h
    ├── sysmips_operations.in
    ├── tcflsh_options.h
    ├── tcflsh_options.in
    ├── tcxonc_options.h
    ├── tcxonc_options.in
    ├── timerfdflags.h
    ├── timerfdflags.in
    ├── ubi_volume_props.h
    ├── ubi_volume_props.in
    ├── ubi_volume_types.h
    ├── ubi_volume_types.in
    ├── umount_flags.h
    ├── umount_flags.in
    ├── usagewho.h
    ├── usagewho.in
    ├── wait4_options.h
    ├── wait4_options.in
    ├── waitid_types.h
    ├── waitid_types.in
    ├── whence_codes.h
    ├── whence_codes.in
    ├── xattrflags.h
    ├── xattrflags.in
    ├── xfs_dqblk_flags.h
    ├── xfs_dqblk_flags.in
    ├── xfs_quota_flags.h
    └── xfs_quota_flags.in
└── xlate.el


/.tarball-version:
--------------------------------------------------------------------------------
1 | 4.9
2 | 


--------------------------------------------------------------------------------
/.version:
--------------------------------------------------------------------------------
1 | 4.9
2 | 


--------------------------------------------------------------------------------
/AUTHORS:
--------------------------------------------------------------------------------
1 | See the file CREDITS.  Automake likes us to have this file called AUTHORS.
2 | 


--------------------------------------------------------------------------------
/README:
--------------------------------------------------------------------------------
 1 | This is strace, a system call tracer for Linux.
 2 | 
 3 | strace is released under a Berkeley-style license at the request
 4 | of Paul Kranenburg; see the file COPYING for details.
 5 | 
 6 | See the file CREDITS for a list of authors and other contributors.
 7 | 
 8 | See the file INSTALL for compilation and installation instructions.
 9 | 
10 | See the file NEWS for information on what has changed in recent
11 | versions.
12 | 
13 | You can get the latest version of strace from its homepage at
14 | http://sourceforge.net/projects/strace/ .
15 | 
16 | Please send bug reports and enhancements to the strace
17 | mailinglist at strace-devel@lists.sourceforge.net.
18 | 


--------------------------------------------------------------------------------
/README-linux:
--------------------------------------------------------------------------------
 1 | 
 2 | Strace has been ported by Branko Lankester <branko@hacktic.nl>
 3 | to run on Linux systems.  Since then it has been greatly modified
 4 | by various other people.
 5 | 
 6 | If you want to compile strace on a Linux system please make sure that
 7 | you use recent kernel headers. Strace needs those to get the proper data
 8 | structures and constatns used by the kernel, since these can be
 9 | different from the structures that the C library uses. Currently you
10 | will need at least a 2.2.7 or newer kernel.
11 | 
12 | To complicate things a bit further strace might not compile if you are
13 | using development kernels. These tend to have headers that conflict with
14 | the headers from libc which makes it impossible to use them.
15 | 
16 | There are three ways to compile strace with other kernel headers:
17 | * Specify the location in CFLAGS when running configure
18 | 
19 |      CFLAGS=-I/usr/src/linux/include ./configure
20 | 
21 | * you can tell make where your kernel sources are. For example if you
22 |   have your kernelsource in /usr/src/linux, you can invoke make like
23 |   this:
24 | 
25 |      make CFLAGS="\$CFLAGS -I/usr/src/linux/include"
26 | 
27 |   (the extra \$CFLAGS is there to make sure we don't override any CFLAGS
28 |   settings that configure has found).
29 | 
30 | * you can link /usr/include/linux and /usr/include/asm to the
31 |   corresponding directories in your kernel source-tree.
32 | 


--------------------------------------------------------------------------------
/debian/compat:
--------------------------------------------------------------------------------
1 | 7
2 | 


--------------------------------------------------------------------------------
/debian/source/format:
--------------------------------------------------------------------------------
1 | 3.0 (quilt)
2 | 


--------------------------------------------------------------------------------
/debian/strace-udeb.install:
--------------------------------------------------------------------------------
1 | build/strace usr/bin
2 | 


--------------------------------------------------------------------------------
/debian/strace.docs:
--------------------------------------------------------------------------------
1 | NEWS
2 | 


--------------------------------------------------------------------------------
/debian/strace.examples:
--------------------------------------------------------------------------------
1 | strace-graph
2 | 


--------------------------------------------------------------------------------
/debian/strace.install:
--------------------------------------------------------------------------------
1 | build/strace usr/bin
2 | 


--------------------------------------------------------------------------------
/debian/strace.manpages:
--------------------------------------------------------------------------------
1 | strace.1
2 | 


--------------------------------------------------------------------------------
/debian/strace64.install:
--------------------------------------------------------------------------------
1 | build64/strace64 usr/bin
2 | 


--------------------------------------------------------------------------------
/debian/strace64.manpages:
--------------------------------------------------------------------------------
1 | strace64.1
2 | 


--------------------------------------------------------------------------------
/debian/watch:
--------------------------------------------------------------------------------
1 | version=3
2 | opts="uversionmangle=s/-/./g" http://sf.net/strace/strace-([[:digit:].-]*)\.tar\.xz
3 | 


--------------------------------------------------------------------------------
/fanotify.c:
--------------------------------------------------------------------------------
 1 | #include "defs.h"
 2 | #include <linux/fanotify.h>
 3 | 
 4 | #include "xlat/fan_classes.h"
 5 | #include "xlat/fan_init_flags.h"
 6 | 
 7 | int
 8 | sys_fanotify_init(struct tcb *tcp)
 9 | {
10 | 	unsigned flags;
11 | 
12 | 	if (exiting(tcp))
13 | 		return 0;
14 | 
15 | 	flags = tcp->u_arg[0];
16 | 	printxval(fan_classes, flags & FAN_ALL_CLASS_BITS, "FAN_CLASS_???");
17 | 	flags &= ~FAN_ALL_CLASS_BITS;
18 | 	if (flags) {
19 | 		tprints("|");
20 | 		printflags(fan_init_flags, flags, "FAN_???");
21 | 	}
22 | 	tprints(", ");
23 | 	tprint_open_modes((unsigned) tcp->u_arg[1]);
24 | 
25 | 	return 0;
26 | }
27 | 
28 | #include "xlat/fan_mark_flags.h"
29 | #include "xlat/fan_event_flags.h"
30 | 
31 | int
32 | sys_fanotify_mark(struct tcb *tcp)
33 | {
34 | 	if (exiting(tcp))
35 | 		return 0;
36 | 
37 | 	printfd(tcp, tcp->u_arg[0]);
38 | 	tprints(", ");
39 | 	printflags(fan_mark_flags, (unsigned) tcp->u_arg[1], "FAN_MARK_???");
40 | 	tprints(", ");
41 | 	printflags(fan_event_flags, tcp->u_arg[2], "FAN_???");
42 | 	tprints(", ");
43 | 	if ((int) tcp->u_arg[3] == FAN_NOFD)
44 | 		tprints("FAN_NOFD, ");
45 | 	else
46 | 		print_dirfd(tcp, tcp->u_arg[3]);
47 | 	printpath(tcp, tcp->u_arg[4]);
48 | 
49 | 	return 0;
50 | }
51 | 


--------------------------------------------------------------------------------
/inotify.c:
--------------------------------------------------------------------------------
 1 | #include "defs.h"
 2 | #include <fcntl.h>
 3 | #include <linux/inotify.h>
 4 | 
 5 | #include "xlat/inotify_flags.h"
 6 | #include "xlat/inotify_init_flags.h"
 7 | 
 8 | int
 9 | sys_inotify_add_watch(struct tcb *tcp)
10 | {
11 | 	if (entering(tcp)) {
12 | 		/* file descriptor */
13 | 		printfd(tcp, tcp->u_arg[0]);
14 | 		tprints(", ");
15 | 		/* pathname */
16 | 		printpath(tcp, tcp->u_arg[1]);
17 | 		tprints(", ");
18 | 		/* mask */
19 | 		printflags(inotify_flags, tcp->u_arg[2], "IN_???");
20 | 	}
21 | 	return 0;
22 | }
23 | 
24 | int
25 | sys_inotify_rm_watch(struct tcb *tcp)
26 | {
27 | 	if (entering(tcp)) {
28 | 		/* file descriptor */
29 | 		printfd(tcp, tcp->u_arg[0]);
30 | 		/* watch descriptor */
31 | 		tprintf(", %d", (int) tcp->u_arg[1]);
32 | 	}
33 | 	return 0;
34 | }
35 | 
36 | int
37 | sys_inotify_init1(struct tcb *tcp)
38 | {
39 | 	if (entering(tcp))
40 | 		printflags(inotify_init_flags, tcp->u_arg[0], "IN_???");
41 | 	return 0;
42 | }
43 | 


--------------------------------------------------------------------------------
/linux/aarch64/errnoent1.h:
--------------------------------------------------------------------------------
1 | /* Native AArch64 */
2 | #include "../errnoent.h"
3 | 


--------------------------------------------------------------------------------
/linux/aarch64/ioctlent.h.in:
--------------------------------------------------------------------------------
1 | #include "../arm/ioctlent.h.in"
2 | 


--------------------------------------------------------------------------------
/linux/aarch64/ioctlent1.h:
--------------------------------------------------------------------------------
1 | #include "ioctlent.h"
2 | 


--------------------------------------------------------------------------------
/linux/aarch64/signalent1.h:
--------------------------------------------------------------------------------
1 | #include "../signalent.h"
2 | 


--------------------------------------------------------------------------------
/linux/aarch64/syscallent.h:
--------------------------------------------------------------------------------
1 | #include "../arm/syscallent.h"
2 | 


--------------------------------------------------------------------------------
/linux/alpha/signalent.h:
--------------------------------------------------------------------------------
 1 | 	"SIG_0",	/* 0 */
 2 | 	"SIGHUP",	/* 1 */
 3 | 	"SIGINT",	/* 2 */
 4 | 	"SIGQUIT",	/* 3 */
 5 | 	"SIGILL",	/* 4 */
 6 | 	"SIGTRAP",	/* 5 */
 7 | 	"SIGABRT",	/* 6 */
 8 | 	"SIGEMT",	/* 7 */
 9 | 	"SIGFPE",	/* 8 */
10 | 	"SIGKILL",	/* 9 */
11 | 	"SIGBUS",	/* 10 */
12 | 	"SIGSEGV",	/* 11 */
13 | 	"SIGSYS",	/* 12 */
14 | 	"SIGPIPE",	/* 13 */
15 | 	"SIGALRM",	/* 14 */
16 | 	"SIGTERM",	/* 15 */
17 | 	"SIGURG",	/* 16 */
18 | 	"SIGSTOP",	/* 17 */
19 | 	"SIGTSTP",	/* 18 */
20 | 	"SIGCONT",	/* 19 */
21 | 	"SIGCHLD",	/* 20 */
22 | 	"SIGTTIN",	/* 21 */
23 | 	"SIGTTOU",	/* 22 */
24 | 	"SIGIO",	/* 23 */
25 | 	"SIGXCPU",	/* 24 */
26 | 	"SIGXFSZ",	/* 25 */
27 | 	"SIGVTALRM",	/* 26 */
28 | 	"SIGPROF",	/* 27 */
29 | 	"SIGWINCH",	/* 28 */
30 | 	"SIGINFO",	/* 29 */
31 | 	"SIGUSR1",	/* 30 */
32 | 	"SIGUSR2",	/* 31 */
33 | 


--------------------------------------------------------------------------------
/linux/arc/ioctlent.h.in:
--------------------------------------------------------------------------------
1 | #include "../i386/ioctlent.h.in"
2 | 


--------------------------------------------------------------------------------
/linux/arm/ioctlent.h.in:
--------------------------------------------------------------------------------
1 | #include "../i386/ioctlent.h.in"
2 | 


--------------------------------------------------------------------------------
/linux/avr32/ioctlent.h.in:
--------------------------------------------------------------------------------
1 | #include "../i386/ioctlent.h.in"
2 | 


--------------------------------------------------------------------------------
/linux/bfin/ioctlent.h.in:
--------------------------------------------------------------------------------
1 | 	{"asm/bfin_sport.h",	"SPORT_IOC_CONFIG",	0x5001},
2 | 	{"asm/bfin_sport.h",	"SPORT_IOC_GET_SYSTEMCLOCK",	0x5002},
3 | 	{"asm/bfin_sport.h",	"SPORT_IOC_SET_BAUDRATE",	0x5003},
4 | 	{"asm/ioctls.h",	"FIOQSIZE",	0x545e},
5 | 	{"asm/bfin_simple_timer.h",	"BFIN_SIMPLE_TIMER_SET_PERIOD",	0x7402},
6 | 	{"asm/bfin_simple_timer.h",	"BFIN_SIMPLE_TIMER_START",	0x7406},
7 | 	{"asm/bfin_simple_timer.h",	"BFIN_SIMPLE_TIMER_STOP",	0x7408},
8 | 	{"asm/bfin_simple_timer.h",	"BFIN_SIMPLE_TIMER_READ",	0x740a},
9 | 


--------------------------------------------------------------------------------
/linux/hppa/ioctlent.h.in:
--------------------------------------------------------------------------------
1 | #include "../i386/ioctlent.h.in"
2 | 


--------------------------------------------------------------------------------
/linux/hppa/signalent.h:
--------------------------------------------------------------------------------
 1 | 	"SIG_0",	/* 0 */
 2 | 	"SIGHUP",	/* 1 */
 3 | 	"SIGINT",	/* 2 */
 4 | 	"SIGQUIT",	/* 3 */
 5 | 	"SIGILL",	/* 4 */
 6 | 	"SIGTRAP",	/* 5 */
 7 | 	"SIGABRT",	/* 6 */
 8 | 	"SIGEMT",	/* 7 */
 9 | 	"SIGFPE",	/* 8 */
10 | 	"SIGKILL",	/* 9 */
11 | 	"SIGBUS",	/* 10 */
12 | 	"SIGSEGV",	/* 11 */
13 | 	"SIGSYS",	/* 12 */
14 | 	"SIGPIPE",	/* 13 */
15 | 	"SIGALRM",	/* 14 */
16 | 	"SIGTERM",	/* 15 */
17 | 	"SIGUSR1",	/* 16 */
18 | 	"SIGUSR2",	/* 17 */
19 | 	"SIGCHLD",	/* 18 */
20 | 	"SIGPWR",	/* 19 */
21 | 	"SIGVTALRM",	/* 20 */
22 | 	"SIGPROF",	/* 21 */
23 | 	"SIGIO",	/* 22 */
24 | 	"SIGWINCH",	/* 23 */
25 | 	"SIGSTOP",	/* 24 */
26 | 	"SIGTSTP",	/* 25 */
27 | 	"SIGCONT",	/* 26 */
28 | 	"SIGTTIN",	/* 27 */
29 | 	"SIGTTOU",	/* 28 */
30 | 	"SIGURG",	/* 29 */
31 | 	"SIGLOST",	/* 30 */
32 | 	"SIGUNUSED",	/* 31 */
33 | 	"SIG_32",	/* 32 */
34 | 	"SIGXCPU",	/* 33 */
35 | 	"SIGXFSZ",	/* 34 */
36 | 	"SIG_35",	/* 35 */
37 | 	"SIGSTKFLT",	/* 36 */
38 | 	"SIGRTMIN",	/* 37 */
39 | 


--------------------------------------------------------------------------------
/linux/i386/ioctlent.h.in:
--------------------------------------------------------------------------------
 1 | 	{"asm/mtrr.h",	"MTRRIOC_ADD_ENTRY",	0x4d00},
 2 | 	{"asm/mce.h",	"MCE_GET_RECORD_LEN",	0x4d01},
 3 | 	{"asm/mtrr.h",	"MTRRIOC_SET_ENTRY",	0x4d01},
 4 | 	{"asm/mce.h",	"MCE_GET_LOG_LEN",	0x4d02},
 5 | 	{"asm/mtrr.h",	"MTRRIOC_DEL_ENTRY",	0x4d02},
 6 | 	{"asm/mce.h",	"MCE_GETCLEAR_FLAGS",	0x4d03},
 7 | 	{"asm/mtrr.h",	"MTRRIOC_GET_ENTRY",	0x4d03},
 8 | 	{"asm/mtrr.h",	"MTRRIOC_KILL_ENTRY",	0x4d04},
 9 | 	{"asm/mtrr.h",	"MTRRIOC_ADD_PAGE_ENTRY",	0x4d05},
10 | 	{"asm/mtrr.h",	"MTRRIOC_SET_PAGE_ENTRY",	0x4d06},
11 | 	{"asm/mtrr.h",	"MTRRIOC_DEL_PAGE_ENTRY",	0x4d07},
12 | 	{"asm/mtrr.h",	"MTRRIOC_GET_PAGE_ENTRY",	0x4d08},
13 | 	{"asm/mtrr.h",	"MTRRIOC_KILL_PAGE_ENTRY",	0x4d09},
14 | 	{"asm/msr.h",	"X86_IOC_RDMSR_REGS",	0x63a0},
15 | 	{"asm/msr.h",	"X86_IOC_WRMSR_REGS",	0x63a1},
16 | 


--------------------------------------------------------------------------------
/linux/ia64/signalent.h:
--------------------------------------------------------------------------------
 1 | 	"SIG_0",	/* 0 */
 2 | 	"SIGHUP",	/* 1 */
 3 | 	"SIGINT",	/* 2 */
 4 | 	"SIGQUIT",	/* 3 */
 5 | 	"SIGILL",	/* 4 */
 6 | 	"SIGTRAP",	/* 5 */
 7 | 	"SIGABRT",	/* 6 */
 8 | 	"SIGBUS",	/* 7 */
 9 | 	"SIGFPE",	/* 8 */
10 | 	"SIGKILL",	/* 9 */
11 | 	"SIGUSR1",	/* 10 */
12 | 	"SIGSEGV",	/* 11 */
13 | 	"SIGUSR2",	/* 12 */
14 | 	"SIGPIPE",	/* 13 */
15 | 	"SIGALRM",	/* 14 */
16 | 	"SIGTERM",	/* 15 */
17 | 	"SIGSTKFLT",	/* 16 */
18 | 	"SIGCHLD",	/* 17 */
19 | 	"SIGCONT",	/* 18 */
20 | 	"SIGSTOP",	/* 19 */
21 | 	"SIGTSTP",	/* 20 */
22 | 	"SIGTTIN",	/* 21 */
23 | 	"SIGTTOU",	/* 22 */
24 | 	"SIGURG",	/* 23 */
25 | 	"SIGXCPU",	/* 24 */
26 | 	"SIGXFSZ",	/* 25 */
27 | 	"SIGVTALRM",	/* 26 */
28 | 	"SIGPROF",	/* 27 */
29 | 	"SIGWINCH",	/* 28 */
30 | 	"SIGIO",	/* 29 */
31 | 	"SIGPWR",	/* 30 */
32 | 	"SIGSYS",	/* 31 */
33 | 	"SIGRT0",	/* 32 */
34 | 	"SIGRT1",	/* 33 */
35 | 	"SIGRT2",	/* 34 */
36 | 	"SIGRT3",	/* 35 */
37 | 	"SIGRT4",	/* 36 */
38 | 	"SIGRT5",	/* 37 */
39 | 	"SIGRT6",	/* 38 */
40 | 	"SIGRT7",	/* 39 */
41 | 	"SIGRT8",	/* 40 */
42 | 	"SIGRT9",	/* 41 */
43 | 	"SIGRT10",	/* 42 */
44 | 	"SIGRT11",	/* 43 */
45 | 	"SIGRT12",	/* 44 */
46 | 	"SIGRT13",	/* 45 */
47 | 	"SIGRT14",	/* 46 */
48 | 	"SIGRT15",	/* 47 */
49 | 	"SIGRT16",	/* 48 */
50 | 	"SIGRT17",	/* 49 */
51 | 	"SIGRT18",	/* 50 */
52 | 	"SIGRT19",	/* 51 */
53 | 	"SIGRT20",	/* 52 */
54 | 	"SIGRT21",	/* 53 */
55 | 	"SIGRT22",	/* 54 */
56 | 	"SIGRT23",	/* 55 */
57 | 	"SIGRT24",	/* 56 */
58 | 	"SIGRT25",	/* 57 */
59 | 	"SIGRT26",	/* 58 */
60 | 	"SIGRT27",	/* 59 */
61 | 	"SIGRT28",	/* 60 */
62 | 	"SIGRT29",	/* 61 */
63 | 	"SIGRT30",	/* 62 */
64 | 	"SIGRT31",	/* 63 */
65 | 


--------------------------------------------------------------------------------
/linux/ioctlent-filter.awk:
--------------------------------------------------------------------------------
 1 | #!/bin/awk -f
 2 | # Filter out redundant "*32" symbols.
 3 | 
 4 | BEGIN {
 5 | 	s=""
 6 | 	c=""
 7 | }
 8 | 
 9 | NF == 3 && $2 ~ /^"[^",]*",$/ {
10 | 	if ($2 == s && $3 == c)
11 | 		next
12 | 	s = $2
13 | 	sub(/",$/, "32\",", s)
14 | 	c = $3
15 | }
16 | 
17 | {
18 | 	print
19 | }
20 | 


--------------------------------------------------------------------------------
/linux/ioctlsort.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | #include <stdlib.h>
 3 | #include <string.h>
 4 | #include <sys/types.h>
 5 | #include <stdint.h>
 6 | 
 7 | #include <asm/ioctl.h>
 8 | #include <linux/types.h>
 9 | 
10 | #include "ioctldefs.h"
11 | #include <linux/atmioc.h>
12 | 
13 | struct ioctlent {
14 | 	const char*	header;
15 | 	const char*	name;
16 | 	unsigned long	code;
17 | };
18 | 
19 | struct ioctlent ioctls[] = {
20 | #include "ioctls.h"
21 | };
22 | 
23 | int nioctls = sizeof(ioctls) / sizeof(ioctls[0]);
24 | 
25 | int compare(const void* a, const void* b) {
26 | 	unsigned long code1 = ((struct ioctlent *) a)->code;
27 | 	unsigned long code2 = ((struct ioctlent *) b)->code;
28 | 	const char *name1 = ((struct ioctlent *) a)->name;
29 | 	const char *name2 = ((struct ioctlent *) b)->name;
30 | 	return (code1 > code2) ? 1 : (code1 < code2) ? -1 : strcmp(name1, name2);
31 | }
32 | 
33 | int main(int argc, char** argv) {
34 | 	int i;
35 | 
36 | 	/* ioctl_lookup() only looks at the NR and TYPE bits atm. */
37 | 	for (i = 0; i < nioctls; i++)
38 | 		ioctls[i].code &= (_IOC_NRMASK << _IOC_NRSHIFT) |
39 | 				  (_IOC_TYPEMASK << _IOC_TYPESHIFT);
40 | 
41 | 	qsort(ioctls, nioctls, sizeof(ioctls[0]), compare);
42 | 	puts("\t/* Generated by ioctlsort */");
43 | 	for (i = 0; i < nioctls; i++)
44 | 		if (i == 0 || ioctls[i].code != ioctls[i-1].code ||
45 | 		    strcmp(ioctls[i].name, ioctls[i-1].name))
46 | 			printf("\t{\"%s\",\t\"%s\",\t%#06lx},\n",
47 | 				ioctls[i].header, ioctls[i].name, ioctls[i].code);
48 | 
49 | 	return 0;
50 | }
51 | 


--------------------------------------------------------------------------------
/linux/m68k/ioctlent.h.in:
--------------------------------------------------------------------------------
1 | #include "../i386/ioctlent.h.in"
2 | 


--------------------------------------------------------------------------------
/linux/metag/ioctlent.h.in:
--------------------------------------------------------------------------------
1 | #include "../i386/ioctlent.h.in"
2 | 


--------------------------------------------------------------------------------
/linux/microblaze/ioctlent.h.in:
--------------------------------------------------------------------------------
1 | #include "../i386/ioctlent.h.in"
2 | 


--------------------------------------------------------------------------------
/linux/mips/signalent.h:
--------------------------------------------------------------------------------
 1 | 	"SIG_0",	/* 0 */
 2 | 	"SIGHUP",	/* 1 */
 3 | 	"SIGINT",	/* 2 */
 4 | 	"SIGQUIT",	/* 3 */
 5 | 	"SIGILL",	/* 4 */
 6 | 	"SIGTRAP",	/* 5 */
 7 | 	"SIGIOT",	/* 6 */
 8 | 	"SIGEMT",	/* 7 */
 9 | 	"SIGFPE",	/* 8 */
10 | 	"SIGKILL",	/* 9 */
11 | 	"SIGBUS",	/* 10 */
12 | 	"SIGSEGV",	/* 11 */
13 | 	"SIGSYS",	/* 12 */
14 | 	"SIGPIPE",	/* 13 */
15 | 	"SIGALRM",	/* 14 */
16 | 	"SIGTERM",	/* 15 */
17 | 	"SIGUSR1",	/* 16 */
18 | 	"SIGUSR2",	/* 17 */
19 | 	"SIGCHLD",	/* 18 */
20 | 	"SIGPWR",	/* 19 */
21 | 	"SIGWINCH",	/* 20 */
22 | 	"SIGURG",	/* 21 */
23 | 	"SIGIO",	/* 22 */
24 | 	"SIGSTOP",	/* 23 */
25 | 	"SIGTSTP",	/* 24 */
26 | 	"SIGCONT",	/* 25 */
27 | 	"SIGTTIN",	/* 26 */
28 | 	"SIGTTOU",	/* 27 */
29 | 	"SIGVTALRM",	/* 28 */
30 | 	"SIGPROF",	/* 29 */
31 | 	"SIGXCPU",	/* 30 */
32 | 	"SIGXFSZ",	/* 31 */
33 | 


--------------------------------------------------------------------------------
/linux/mips/syscallent.h:
--------------------------------------------------------------------------------
1 | #include "../dummy.h"
2 | #include "syscallent-compat.h"
3 | #include "syscallent-o32.h"
4 | #include "syscallent-n64.h"
5 | #include "syscallent-n32.h"
6 | 


--------------------------------------------------------------------------------
/linux/or1k/ioctlent.h.in:
--------------------------------------------------------------------------------
1 | #include "../i386/ioctlent.h.in"
2 | 


--------------------------------------------------------------------------------
/linux/powerpc/errnoent1.h:
--------------------------------------------------------------------------------
1 | #include "../errnoent.h"
2 | 


--------------------------------------------------------------------------------
/linux/powerpc/ioctlent1.h:
--------------------------------------------------------------------------------
1 | #include "ioctlent.h"
2 | 


--------------------------------------------------------------------------------
/linux/powerpc/signalent1.h:
--------------------------------------------------------------------------------
1 | #include "../signalent.h"
2 | 


--------------------------------------------------------------------------------
/linux/powerpc/syscallent1.h:
--------------------------------------------------------------------------------
1 | #include "syscallent.h"
2 | 


--------------------------------------------------------------------------------
/linux/reboot.h:
--------------------------------------------------------------------------------
 1 | #ifndef _LINUX_REBOOT_H
 2 | #define _LINUX_REBOOT_H
 3 | 
 4 | /*
 5 |  * Magic values required to use _reboot() system call.
 6 |  */
 7 | 
 8 | #define	LINUX_REBOOT_MAGIC1	0xfee1dead
 9 | #define	LINUX_REBOOT_MAGIC2	672274793
10 | #define	LINUX_REBOOT_MAGIC2A	85072278
11 | #define	LINUX_REBOOT_MAGIC2B	369367448
12 | #define	LINUX_REBOOT_MAGIC2C	537993216
13 | 
14 | 
15 | /*
16 |  * Commands accepted by the _reboot() system call.
17 |  *
18 |  * RESTART     Restart system using default command and mode.
19 |  * HALT        Stop OS and give system control to ROM monitor, if any.
20 |  * CAD_ON      Ctrl-Alt-Del sequence causes RESTART command.
21 |  * CAD_OFF     Ctrl-Alt-Del sequence sends SIGINT to init task.
22 |  * POWER_OFF   Stop OS and remove all power from system, if possible.
23 |  * RESTART2    Restart system using given command string.
24 |  * SW_SUSPEND  Suspend system using software suspend if compiled in.
25 |  * KEXEC       Restart system using a previously loaded Linux kernel
26 |  */
27 | 
28 | #define	LINUX_REBOOT_CMD_RESTART	0x01234567
29 | #define	LINUX_REBOOT_CMD_HALT		0xCDEF0123
30 | #define	LINUX_REBOOT_CMD_CAD_ON		0x89ABCDEF
31 | #define	LINUX_REBOOT_CMD_CAD_OFF	0x00000000
32 | #define	LINUX_REBOOT_CMD_POWER_OFF	0x4321FEDC
33 | #define	LINUX_REBOOT_CMD_RESTART2	0xA1B2C3D4
34 | #define	LINUX_REBOOT_CMD_SW_SUSPEND	0xD000FCE2
35 | #define	LINUX_REBOOT_CMD_KEXEC		0x45584543
36 | 
37 | 
38 | 
39 | #endif /* _LINUX_REBOOT_H */
40 | 


--------------------------------------------------------------------------------
/linux/riscv/errnoent1.h:
--------------------------------------------------------------------------------
1 | /* RISC-V rv32 and rv64 */
2 | #include "../errnoent.h"
3 | 


--------------------------------------------------------------------------------
/linux/riscv/ioctlent.h.in:
--------------------------------------------------------------------------------
1 | #include "../i386/ioctlent.h.in"
2 | 


--------------------------------------------------------------------------------
/linux/riscv/ioctlent1.h:
--------------------------------------------------------------------------------
1 | /* RISC-V rv32 and rv64 */
2 | #include "ioctlent.h"
3 | 


--------------------------------------------------------------------------------
/linux/riscv/signalent1.h:
--------------------------------------------------------------------------------
1 | /* RISC-V rv32 and rv64 */
2 | #include "../signalent.h"
3 | 


--------------------------------------------------------------------------------
/linux/s390x/ioctlent.h.in:
--------------------------------------------------------------------------------
1 | #include "../s390/ioctlent.h.in"
2 | 


--------------------------------------------------------------------------------
/linux/sh64/ioctlent.h.in:
--------------------------------------------------------------------------------
1 | #include "../sh/ioctlent.h.in"
2 | 


--------------------------------------------------------------------------------
/linux/signalent.h:
--------------------------------------------------------------------------------
 1 | 	"SIG_0",	/* 0 */
 2 | 	"SIGHUP",	/* 1 */
 3 | 	"SIGINT",	/* 2 */
 4 | 	"SIGQUIT",	/* 3 */
 5 | 	"SIGILL",	/* 4 */
 6 | 	"SIGTRAP",	/* 5 */
 7 | 	"SIGABRT",	/* 6 */
 8 | 	"SIGBUS",	/* 7 */
 9 | 	"SIGFPE",	/* 8 */
10 | 	"SIGKILL",	/* 9 */
11 | 	"SIGUSR1",	/* 10 */
12 | 	"SIGSEGV",	/* 11 */
13 | 	"SIGUSR2",	/* 12 */
14 | 	"SIGPIPE",	/* 13 */
15 | 	"SIGALRM",	/* 14 */
16 | 	"SIGTERM",	/* 15 */
17 | 	"SIGSTKFLT",	/* 16 */
18 | 	"SIGCHLD",	/* 17 */
19 | 	"SIGCONT",	/* 18 */
20 | 	"SIGSTOP",	/* 19 */
21 | 	"SIGTSTP",	/* 20 */
22 | 	"SIGTTIN",	/* 21 */
23 | 	"SIGTTOU",	/* 22 */
24 | 	"SIGURG",	/* 23 */
25 | 	"SIGXCPU",	/* 24 */
26 | 	"SIGXFSZ",	/* 25 */
27 | 	"SIGVTALRM",	/* 26 */
28 | 	"SIGPROF",	/* 27 */
29 | 	"SIGWINCH",	/* 28 */
30 | 	"SIGIO",	/* 29 */
31 | 	"SIGPWR",	/* 30 */
32 | 	"SIGSYS",	/* 31 */
33 | 	"SIGRTMIN",	/* 32 */
34 | 


--------------------------------------------------------------------------------
/linux/sparc/gen.pl:
--------------------------------------------------------------------------------
 1 | open SPARC, "syscallent.h" || die "no puedo abrir el de la sparc";
 2 | open ALPHA, "../alpha/syscallent.h" || die "no puedo abrir el de la alpha";
 3 | open PC, "../i386/syscallent.h" || die "no puedo abrir PC\n";
 4 | 
 5 | while (<SPARC>) {
 6 |     chop;
 7 |     ($i1, $i2, $i3, $syscall, $syscall_name) = split;
 8 |     $strn[$index]   = $syscall_name;
 9 |     $name[$index++] = $syscall;
10 | }
11 | 
12 | while (<ALPHA>){
13 |     if (/\{/) {
14 | 	($i1, $n, $pr, $syscall) = split;
15 | 	$par{$syscall} = $n;
16 | 	$prr{$syscall} = $pr;
17 |     }
18 | }
19 | 
20 | while (<PC>){
21 |     if (/\{/) {
22 | 	($i1, $n, $pr, $syscall) = split;
23 | 	$par{$syscall} = $n;
24 | 	$prr{$syscall} = $pr;
25 |     }
26 | }
27 | 
28 | print "missing \n";
29 | 
30 | for ($i = 0; $i < $index; $i++){
31 |     $x = $name[$i];
32 |     $y = $strn[$i];
33 |     $n = $par{$x};
34 |     $p = $prr{$x};
35 |     $j++;
36 |     print "\t{ $n\t$p\t$x\t$y },\t /* $j */\n";
37 | }
38 | 


--------------------------------------------------------------------------------
/linux/sparc/signalent.h:
--------------------------------------------------------------------------------
 1 | 	"SIG_0",	/* 0 */
 2 | 	"SIGHUP",	/* 1 */
 3 | 	"SIGINT",	/* 2 */
 4 | 	"SIGQUIT",	/* 3 */
 5 | 	"SIGILL",	/* 4 */
 6 | 	"SIGTRAP",	/* 5 */
 7 | 	"SIGABRT",	/* 6 */
 8 | 	"SIGEMT",	/* 7 */
 9 | 	"SIGFPE",	/* 8 */
10 | 	"SIGKILL",	/* 9 */
11 | 	"SIGBUS",	/* 10 */
12 | 	"SIGSEGV",	/* 11 */
13 | 	"SIGSYS",	/* 12 */
14 | 	"SIGPIPE",	/* 13 */
15 | 	"SIGALRM",	/* 14 */
16 | 	"SIGTERM",	/* 15 */
17 | 	"SIGURG",	/* 16 */
18 | 	"SIGSTOP",	/* 17 */
19 | 	"SIGTSTP",	/* 18 */
20 | 	"SIGCONT",	/* 19 */
21 | 	"SIGCHLD",	/* 20 */
22 | 	"SIGTTIN",	/* 21 */
23 | 	"SIGTTOU",	/* 22 */
24 | 	"SIGIO",	/* 23 */
25 | 	"SIGXCPU",	/* 24 */
26 | 	"SIGXFSZ",	/* 25 */
27 | 	"SIGVTALRM",	/* 26 */
28 | 	"SIGPROF",	/* 27 */
29 | 	"SIGWINCH",	/* 28 */
30 | 	"SIGLOST",	/* 29 */
31 | 	"SIGUSR1",	/* 30 */
32 | 	"SIGUSR2",	/* 31 */
33 | 


--------------------------------------------------------------------------------
/linux/sparc/signalent1.h:
--------------------------------------------------------------------------------
 1 | 	"SIG_0",	/* 0 */
 2 | 	"SIGHUP",	/* 1 */
 3 | 	"SIGINT",	/* 2 */
 4 | 	"SIGQUIT",	/* 3 */
 5 | 	"SIGILL",	/* 4 */
 6 | 	"SIGTRAP",	/* 5 */
 7 | 	"SIGABRT",	/* 6 */
 8 | 	"SIGEMT",	/* 7 */
 9 | 	"SIGFPE",	/* 8 */
10 | 	"SIGKILL",	/* 9 */
11 | 	"SIGBUS",	/* 10 */
12 | 	"SIGSEGV",	/* 11 */
13 | 	"SIGSYS",	/* 12 */
14 | 	"SIGPIPE",	/* 13 */
15 | 	"SIGALRM",	/* 14 */
16 | 	"SIGTERM",	/* 15 */
17 | 	"SIGUSR1",	/* 16 */
18 | 	"SIGUSR2",	/* 17 */
19 | 	"SIGCHLD",	/* 18 */
20 | 	"SIGPWR",	/* 19 */
21 | 	"SIGWINCH",	/* 20 */
22 | 	"SIGURG",	/* 21 */
23 | 	"SIGPOLL",	/* 22 */
24 | 	"SIGSTOP",	/* 23 */
25 | 	"SIGTSTP",	/* 24 */
26 | 	"SIGCONT",	/* 25 */
27 | 	"SIGTTIN",	/* 26 */
28 | 	"SIGTTOU",	/* 27 */
29 | 	"SIGVTALRM",	/* 28 */
30 | 	"SIGPROF",	/* 29 */
31 | 	"SIGXCPU",	/* 30 */
32 | 	"SIGXFSZ",	/* 31 */
33 | 	"SIGWAITING",	/* 32 */
34 | 	"SIGLWP",	/* 33 */
35 | 	"SIGFREEZE",	/* 34 */
36 | 	"SIGTHAW",	/* 35 */
37 | 


--------------------------------------------------------------------------------
/linux/sparc64/errnoent1.h:
--------------------------------------------------------------------------------
1 | #include "../sparc/errnoent1.h"
2 | 


--------------------------------------------------------------------------------
/linux/sparc64/ioctlent.h.in:
--------------------------------------------------------------------------------
1 | #include "../sparc/ioctlent.h.in"
2 | 


--------------------------------------------------------------------------------
/linux/sparc64/ioctlent1.h:
--------------------------------------------------------------------------------
1 | #include "../sparc/ioctlent1.h"
2 | 


--------------------------------------------------------------------------------
/linux/sparc64/signalent.h:
--------------------------------------------------------------------------------
 1 | 	"SIG_0",	/* 0 */
 2 | 	"SIGHUP",	/* 1 */
 3 | 	"SIGINT",	/* 2 */
 4 | 	"SIGQUIT",	/* 3 */
 5 | 	"SIGILL",	/* 4 */
 6 | 	"SIGTRAP",	/* 5 */
 7 | 	"SIGABRT",	/* 6 */
 8 | 	"SIGEMT",	/* 7 */
 9 | 	"SIGFPE",	/* 8 */
10 | 	"SIGKILL",	/* 9 */
11 | 	"SIGBUS",	/* 10 */
12 | 	"SIGSEGV",	/* 11 */
13 | 	"SIGSYS",	/* 12 */
14 | 	"SIGPIPE",	/* 13 */
15 | 	"SIGALRM",	/* 14 */
16 | 	"SIGTERM",	/* 15 */
17 | 	"SIGURG",	/* 16 */
18 | 	"SIGSTOP",	/* 17 */
19 | 	"SIGTSTP",	/* 18 */
20 | 	"SIGCONT",	/* 19 */
21 | 	"SIGCHLD",	/* 20 */
22 | 	"SIGTTIN",	/* 21 */
23 | 	"SIGTTOU",	/* 22 */
24 | 	"SIGIO",	/* 23 */
25 | 	"SIGXCPU",	/* 24 */
26 | 	"SIGXFSZ",	/* 25 */
27 | 	"SIGVTALRM",	/* 26 */
28 | 	"SIGPROF",	/* 27 */
29 | 	"SIGWINCH",	/* 28 */
30 | 	"SIGLOST",	/* 29 */
31 | 	"SIGUSR1",	/* 30 */
32 | 	"SIGUSR2",	/* 31 */
33 | 


--------------------------------------------------------------------------------
/linux/sparc64/signalent1.h:
--------------------------------------------------------------------------------
1 | #include "../sparc/signalent1.h"
2 | 


--------------------------------------------------------------------------------
/linux/sparc64/signalent2.h:
--------------------------------------------------------------------------------
 1 | 	"SIG_0",	/* 0 */
 2 | 	"SIGHUP",	/* 1 */
 3 | 	"SIGINT",	/* 2 */
 4 | 	"SIGQUIT",	/* 3 */
 5 | 	"SIGILL",	/* 4 */
 6 | 	"SIGTRAP",	/* 5 */
 7 | 	"SIGABRT",	/* 6 */
 8 | 	"SIGEMT",	/* 7 */
 9 | 	"SIGFPE",	/* 8 */
10 | 	"SIGKILL",	/* 9 */
11 | 	"SIGBUS",	/* 10 */
12 | 	"SIGSEGV",	/* 11 */
13 | 	"SIGSYS",	/* 12 */
14 | 	"SIGPIPE",	/* 13 */
15 | 	"SIGALRM",	/* 14 */
16 | 	"SIGTERM",	/* 15 */
17 | 	"SIGURG",	/* 16 */
18 | 	"SIGSTOP",	/* 17 */
19 | 	"SIGTSTP",	/* 18 */
20 | 	"SIGCONT",	/* 19 */
21 | 	"SIGCHLD",	/* 20 */
22 | 	"SIGTTIN",	/* 21 */
23 | 	"SIGTTOU",	/* 22 */
24 | 	"SIGIO",	/* 23 */
25 | 	"SIGXCPU",	/* 24 */
26 | 	"SIGXFSZ",	/* 25 */
27 | 	"SIGVTALRM",	/* 26 */
28 | 	"SIGPROF",	/* 27 */
29 | 	"SIGWINCH",	/* 28 */
30 | 	"SIGLOST",	/* 29 */
31 | 	"SIGUSR1",	/* 30 */
32 | 	"SIGUSR2",	/* 31 */
33 | 


--------------------------------------------------------------------------------
/linux/sparc64/syscallent.h:
--------------------------------------------------------------------------------
1 | #include "../sparc/syscallent.h"
2 | 


--------------------------------------------------------------------------------
/linux/sparc64/syscallent1.h:
--------------------------------------------------------------------------------
1 | #include "../sparc/syscallent1.h"
2 | 


--------------------------------------------------------------------------------
/linux/sparc64/syscallent2.h:
--------------------------------------------------------------------------------
1 | #include "../sparc/syscallent.h"
2 | 


--------------------------------------------------------------------------------
/linux/subcall.h:
--------------------------------------------------------------------------------
1 | #ifndef SYS_socket_subcall
2 | # error SYS_socket_subcall is not defined
3 | #endif
4 | #define SYS_socket_nsubcalls	20
5 | #define SYS_ipc_subcall		((SYS_socket_subcall)+(SYS_socket_nsubcalls))
6 | #define SYS_ipc_nsubcalls	25
7 | 


--------------------------------------------------------------------------------
/linux/tile/errnoent1.h:
--------------------------------------------------------------------------------
1 | /* tilegx32/tilepro */
2 | #include "../errnoent.h"
3 | 


--------------------------------------------------------------------------------
/linux/tile/ioctlent.h.in:
--------------------------------------------------------------------------------
1 | #include "../i386/ioctlent.h.in"
2 | 


--------------------------------------------------------------------------------
/linux/tile/ioctlent1.h:
--------------------------------------------------------------------------------
1 | /* tilegx32/tilepro */
2 | #include "ioctlent.h"
3 | 


--------------------------------------------------------------------------------
/linux/tile/signalent1.h:
--------------------------------------------------------------------------------
1 | /* tilegx32/tilepro */
2 | #include "../signalent.h"
3 | 


--------------------------------------------------------------------------------
/linux/x32/errnoent.h:
--------------------------------------------------------------------------------
1 | #include "../errnoent.h"
2 | 


--------------------------------------------------------------------------------
/linux/x32/errnoent1.h:
--------------------------------------------------------------------------------
1 | /* i386 personality */
2 | #include "../errnoent.h"
3 | 


--------------------------------------------------------------------------------
/linux/x32/ioctlent.h.in:
--------------------------------------------------------------------------------
1 | #include "../i386/ioctlent.h.in"
2 | 


--------------------------------------------------------------------------------
/linux/x32/ioctlent1.h:
--------------------------------------------------------------------------------
1 | /* i386 personality */
2 | #include "ioctlent.h"
3 | 


--------------------------------------------------------------------------------
/linux/x32/signalent.h:
--------------------------------------------------------------------------------
1 | #include "../signalent.h"
2 | 


--------------------------------------------------------------------------------
/linux/x32/signalent1.h:
--------------------------------------------------------------------------------
1 | /* i386 personality */
2 | #include "../signalent.h"
3 | 


--------------------------------------------------------------------------------
/linux/x32/syscallent1.h:
--------------------------------------------------------------------------------
1 | /* Our second set comes from the i386 files.  */
2 | 
3 | #include "../i386/syscallent.h"
4 | 


--------------------------------------------------------------------------------
/linux/x86_64/errnoent1.h:
--------------------------------------------------------------------------------
1 | /* i386 personality */
2 | #include "../errnoent.h"
3 | 


--------------------------------------------------------------------------------
/linux/x86_64/errnoent2.h:
--------------------------------------------------------------------------------
1 | /* x32 personality */
2 | #include "../errnoent.h"
3 | 


--------------------------------------------------------------------------------
/linux/x86_64/ioctlent.h.in:
--------------------------------------------------------------------------------
1 | #include "../i386/ioctlent.h.in"
2 | 


--------------------------------------------------------------------------------
/linux/x86_64/ioctlent1.h:
--------------------------------------------------------------------------------
1 | /* i386 personality */
2 | #include "ioctlent.h"
3 | 


--------------------------------------------------------------------------------
/linux/x86_64/ioctlent2.h:
--------------------------------------------------------------------------------
1 | /* x32 personality */
2 | #include "ioctlent.h"
3 | 


--------------------------------------------------------------------------------
/linux/x86_64/signalent1.h:
--------------------------------------------------------------------------------
1 | /* i386 personality */
2 | #include "../signalent.h"
3 | 


--------------------------------------------------------------------------------
/linux/x86_64/signalent2.h:
--------------------------------------------------------------------------------
1 | /* x32 personality */
2 | #include "../signalent.h"
3 | 


--------------------------------------------------------------------------------
/linux/x86_64/syscallent1.h:
--------------------------------------------------------------------------------
1 | /* Our second set comes from the i386 files.  */
2 | 
3 | #include "../i386/syscallent.h"
4 | 


--------------------------------------------------------------------------------
/linux/x86_64/syscallent2.h:
--------------------------------------------------------------------------------
1 | /* x32 personality */
2 | #include "../x32/syscallent.h"
3 | 


--------------------------------------------------------------------------------
/linux/xtensa/ioctlent.h.in:
--------------------------------------------------------------------------------
1 | /* intentionally empty */
2 | 


--------------------------------------------------------------------------------
/m4/includedir.m4:
--------------------------------------------------------------------------------
 1 | dnl ### A macro to find the include directory, useful for cross-compiling.
 2 | AC_DEFUN([AC_INCLUDEDIR],
 3 | [AC_REQUIRE([AC_PROG_AWK])dnl
 4 | AC_SUBST(includedir)
 5 | AC_MSG_CHECKING(for primary include directory)
 6 | includedir=/usr/include
 7 | if test -n "$GCC"
 8 | then
 9 | 	>conftest.c
10 | 	new_includedir=`
11 | 		$CC -v -E conftest.c 2>&1 | $AWK '
12 | 			/^End of search list/ { print last; exit }
13 | 			{ last = [$]1 }
14 | 		'
15 | 	`
16 | 	rm -f conftest.c
17 | 	if test -n "$new_includedir" && test -d "$new_includedir"
18 | 	then
19 | 		includedir=$new_includedir
20 | 	fi
21 | fi
22 | AC_MSG_RESULT($includedir)
23 | ])
24 | 


--------------------------------------------------------------------------------
/m4/long_long.m4:
--------------------------------------------------------------------------------
 1 | dnl ### A macro to determine endianness of long long
 2 | AC_DEFUN([AC_LITTLE_ENDIAN_LONG_LONG],
 3 | [AC_MSG_CHECKING(for little endian long long)
 4 | AC_CACHE_VAL(ac_cv_have_little_endian_long_long,
 5 | [AC_RUN_IFELSE([AC_LANG_SOURCE([[
 6 | int main () {
 7 | 	union {
 8 | 		long long ll;
 9 | 		int l [2];
10 | 	} u;
11 | 	u.ll = 0x12345678;
12 | 	if (u.l[0] == 0x12345678)
13 | 		return 0;
14 | 	return 1;
15 | }
16 | ]])],[ac_cv_have_little_endian_long_long=yes],[ac_cv_have_little_endian_long_long=no],[
17 | if test "x$ac_cv_c_bigendian" = "xyes"; then
18 | 	ac_cv_have_little_endian_long_long=no
19 | else
20 | 	ac_cv_have_little_endian_long_long=yes
21 | fi
22 | ])])
23 | AC_MSG_RESULT($ac_cv_have_little_endian_long_long)
24 | if test "$ac_cv_have_little_endian_long_long" = yes
25 | then
26 | 	AC_DEFINE([HAVE_LITTLE_ENDIAN_LONG_LONG], 1,
27 | [Define if long long is little-endian.])
28 | fi
29 | ])
30 | 


--------------------------------------------------------------------------------
/m4/stat.m4:
--------------------------------------------------------------------------------
 1 | dnl ### A macro to determine whether stat64 is defined.
 2 | AC_DEFUN([AC_STAT64],
 3 | [AC_MSG_CHECKING(for stat64 in (asm|sys)/stat.h)
 4 | AC_CACHE_VAL(ac_cv_type_stat64,
 5 | [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
 6 | #include <sys/types.h>
 7 | #include <linux/types.h>
 8 | #include <asm/stat.h>
 9 | ]], [[struct stat64 st;]])],[ac_cv_type_stat64=yes],[ac_cv_type_stat64=no])])
10 | AC_MSG_RESULT($ac_cv_type_stat64)
11 | if test "$ac_cv_type_stat64" = yes
12 | then
13 | 	AC_DEFINE([HAVE_STAT64], 1,
14 | [Define if stat64 is available in asm/stat.h.])
15 | fi
16 | ])
17 | 


--------------------------------------------------------------------------------
/m4/statfs.m4:
--------------------------------------------------------------------------------
 1 | dnl ### A macro to determine whether statfs64 is defined.
 2 | AC_DEFUN([AC_STATFS64],
 3 | [AC_MSG_CHECKING(for statfs64 in sys/vfs.h)
 4 | AC_CACHE_VAL(ac_cv_type_statfs64,
 5 | [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
 6 | #include <linux/types.h>
 7 | #include <sys/vfs.h>
 8 | ]], [[struct statfs64 st;]])],[ac_cv_type_statfs64=yes],[ac_cv_type_statfs64=no])])
 9 | AC_MSG_RESULT($ac_cv_type_statfs64)
10 | if test "$ac_cv_type_statfs64" = yes
11 | then
12 | 	AC_DEFINE([HAVE_STATFS64], 1,
13 | [Define if statfs64 is available in sys/vfs.h.])
14 | fi
15 | ])
16 | 


--------------------------------------------------------------------------------
/m4/warnings.m4:
--------------------------------------------------------------------------------
 1 | # warnings.m4 serial 2
 2 | dnl Copyright (C) 2008, 2009, 2010 Free Software Foundation, Inc.
 3 | dnl This file is free software; the Free Software Foundation
 4 | dnl gives unlimited permission to copy and/or distribute it,
 5 | dnl with or without modifications, as long as this notice is preserved.
 6 | 
 7 | dnl From Simon Josefsson
 8 | 
 9 | # gl_AS_VAR_APPEND(VAR, VALUE)
10 | # ----------------------------
11 | # Provide the functionality of AS_VAR_APPEND if Autoconf does not have it.
12 | m4_ifdef([AS_VAR_APPEND],
13 | [m4_copy([AS_VAR_APPEND], [gl_AS_VAR_APPEND])],
14 | [m4_define([gl_AS_VAR_APPEND],
15 | [AS_VAR_SET([$1], [AS_VAR_GET([$1])$2])])])
16 | 
17 | # gl_WARN_ADD(PARAMETER, [VARIABLE = WARN_CFLAGS])
18 | # ------------------------------------------------
19 | # Adds parameter to WARN_CFLAGS if the compiler supports it.  For example,
20 | # gl_WARN_ADD([-Wparentheses]).
21 | AC_DEFUN([gl_WARN_ADD],
22 | [AS_VAR_PUSHDEF([gl_Warn], [gl_cv_warn_$1])dnl
23 | AC_CACHE_CHECK([whether compiler handles $1], [gl_Warn], [
24 |   save_CPPFLAGS="$CPPFLAGS"
25 |   CPPFLAGS="${CPPFLAGS} $1"
26 |   AC_PREPROC_IFELSE([AC_LANG_PROGRAM([])],
27 |                     [AS_VAR_SET([gl_Warn], [yes])],
28 |                     [AS_VAR_SET([gl_Warn], [no])])
29 |   CPPFLAGS="$save_CPPFLAGS"
30 | ])
31 | AS_VAR_PUSHDEF([gl_Flags], m4_if([$2], [], [[WARN_CFLAGS]], [[$2]]))dnl
32 | AS_VAR_IF([gl_Warn], [yes], [gl_AS_VAR_APPEND([gl_Flags], [" $1"])])
33 | AS_VAR_POPDEF([gl_Flags])dnl
34 | AS_VAR_POPDEF([gl_Warn])dnl
35 | m4_ifval([$2], [AS_LITERAL_IF([$2], [AC_SUBST([$2])], [])])dnl
36 | ])
37 | 


--------------------------------------------------------------------------------
/reboot.c:
--------------------------------------------------------------------------------
 1 | #include "defs.h"
 2 | #include <linux/reboot.h>
 3 | 
 4 | #include "xlat/bootflags1.h"
 5 | #include "xlat/bootflags2.h"
 6 | #include "xlat/bootflags3.h"
 7 | 
 8 | int
 9 | sys_reboot(struct tcb *tcp)
10 | {
11 | 	if (exiting(tcp))
12 | 		return 0;
13 | 
14 | 	printflags(bootflags1, tcp->u_arg[0], "LINUX_REBOOT_MAGIC_???");
15 | 	tprints(", ");
16 | 	printflags(bootflags2, tcp->u_arg[1], "LINUX_REBOOT_MAGIC_???");
17 | 	tprints(", ");
18 | 	printflags(bootflags3, tcp->u_arg[2], "LINUX_REBOOT_CMD_???");
19 | 	if (tcp->u_arg[2] == LINUX_REBOOT_CMD_RESTART2) {
20 | 		tprints(", ");
21 | 		printstr(tcp, tcp->u_arg[3], -1);
22 | 	}
23 | 	return 0;
24 | }
25 | 


--------------------------------------------------------------------------------
/strace-log-merge:
--------------------------------------------------------------------------------
 1 | #!/bin/sh
 2 | 
 3 | show_usage()
 4 | {
 5 | 	cat <<__EOF__
 6 | Usage: ${0##*/} STRACE_LOG
 7 | 
 8 | Finds all STRACE_LOG.PID files, adds PID prefix to every line,
 9 | then combines and sorts them, and prints result to standard output.
10 | 
11 | It is assumed that STRACE_LOGs were produced by strace with -tt[t]
12 | option which prints timestamps (otherwise sorting won't do any good).
13 | __EOF__
14 | }
15 | 
16 | if [ $# -ne 1 ]; then
17 | 	show_usage >&2
18 | 	exit 1
19 | elif [ "$1" = '--help' ]; then
20 | 	show_usage
21 | 	exit 0
22 | fi
23 | 
24 | logfile=$1
25 | 
26 | for file in "$logfile".*; do
27 | 	[ -f "$file" ] || continue
28 | 	suffix=${file#"$logfile".}
29 | 	[ "$suffix" -gt 0 ] 2> /dev/null ||
30 | 		continue
31 | 	pid=$(printf "%-5s" $suffix)
32 | 	# Some strace logs have last line which is not '\n' terminated,
33 | 	# so add extra newline to every file.
34 | 	# grep -v '^$' removes empty lines which may result.
35 | 	sed "s/^/$pid /" < "$file"
36 | 	echo
37 | done \
38 | | sort -s -k2,2 | grep -v '^$'
39 | 
40 | rc=$?
41 | [ $rc -eq 1 ] &&
42 | 	echo >&2 "${0##*/}: $logfile: strace output not found"
43 | exit $rc
44 | 


--------------------------------------------------------------------------------
/tests/Makefile.am:
--------------------------------------------------------------------------------
 1 | # Automake input for strace tests.
 2 | 
 3 | AM_CFLAGS = $(WARN_CFLAGS)
 4 | 
 5 | check_PROGRAMS = \
 6 | 	net-accept-connect \
 7 | 	scm_rights \
 8 | 	set_ptracer_any \
 9 | 	sigaction \
10 | 	stack-fcall \
11 | 	uio
12 | 
13 | uio_CFLAGS = $(AM_CFLAGS) -D_FILE_OFFSET_BITS=64
14 | stack_fcall_SOURCES = stack-fcall.c \
15 | 	stack-fcall-0.c stack-fcall-1.c stack-fcall-2.c stack-fcall-3.c
16 | 
17 | TESTS = \
18 | 	ptrace_setoptions.test \
19 | 	strace-f.test \
20 | 	qual_syscall.test \
21 | 	scm_rights-fd.test \
22 | 	sigaction.test \
23 | 	stat.test \
24 | 	net.test \
25 | 	net-fd.test \
26 | 	uio.test \
27 | 	count.test \
28 | 	detach-sleeping.test \
29 | 	detach-stopped.test \
30 | 	detach-running.test \
31 | 	strace-k.test
32 | 
33 | net-fd.log: net.log
34 | 
35 | TEST_LOG_COMPILER = $(srcdir)/run.sh
36 | 
37 | EXTRA_DIST = init.sh run.sh sigaction.awk $(TESTS)
38 | 
39 | CLEANFILES = $(TESTS:=.tmp)
40 | 


--------------------------------------------------------------------------------
/tests/count.test:
--------------------------------------------------------------------------------
 1 | #!/bin/sh
 2 | 
 3 | # Check whether -c and -w options work.
 4 | 
 5 | . "${srcdir=.}/init.sh"
 6 | 
 7 | check_prog sleep
 8 | check_prog grep
 9 | 
10 | make_log()
11 | {
12 | 	$STRACE $args > $LOG 2>&1 || {
13 | 		cat $LOG
14 | 		fail_ "$STRACE $args failed"
15 | 	}
16 | }
17 | 
18 | grep_log()
19 | {
20 | 	LC_ALL=C grep -E -x -e "$*" $LOG > /dev/null || {
21 | 		cat $LOG
22 | 		fail_ "unexpected output from $STRACE $args"
23 | 	}
24 | }
25 | 
26 | args='-c sleep 1'
27 | make_log
28 | grep nanosleep $LOG > /dev/null ||
29 | 	skip_ 'sleep does not use nanosleep'
30 | grep_log ' *[^ ]+ +0\.0[^n]*nanosleep'
31 | 
32 | args='-c -enanosleep sleep 1'
33 | make_log
34 | grep_log ' *[^ ]+ +0\.0[^n]*nanosleep'
35 | 
36 | args='-cw sleep 1'
37 | make_log
38 | grep_log ' *[^ ]+ +(1\.0|0\.99)[^n]*nanosleep'
39 | 
40 | args='-cw -enanosleep sleep 1'
41 | make_log
42 | grep_log '100\.00 +(1\.0|0\.99)[^n]*nanosleep'
43 | 
44 | exit 0
45 | 


--------------------------------------------------------------------------------
/tests/detach-running.test:
--------------------------------------------------------------------------------
 1 | #!/bin/sh
 2 | 
 3 | # Ensure that strace can detach from running processes.
 4 | 
 5 | . "${srcdir=.}/init.sh"
 6 | 
 7 | check_prog sleep
 8 | check_prog grep
 9 | 
10 | set -e
11 | 
12 | ./set_ptracer_any sh -c "echo > $LOG; while :; do :; done" > /dev/null &
13 | 
14 | while ! [ -s $LOG ]; do
15 | 	kill -0 $! 2> /dev/null ||
16 | 		fail_ 'set_ptracer_any sh failed'
17 | 	$SLEEP_A_BIT
18 | done
19 | 
20 | tracee_pid=$!
21 | 
22 | cleanup()
23 | {
24 | 	set +e
25 | 	kill $tracee_pid
26 | 	wait $tracee_pid 2> /dev/null
27 | 	return 0
28 | }
29 | 
30 | rm -f $LOG
31 | $STRACE -p $tracee_pid 2> $LOG &
32 | 
33 | while ! grep -F "Process $tracee_pid attached" $LOG > /dev/null; do
34 | 	kill -0 $! 2> /dev/null ||
35 | 		{ cat $LOG; cleanup; fail_ 'strace -p does not work'; }
36 | 	$SLEEP_A_BIT
37 | done
38 | 
39 | kill -INT $!
40 | wait $!
41 | 
42 | grep -F "Process $tracee_pid detached" $LOG > /dev/null ||
43 | 	{ cat $LOG; cleanup; fail_ 'strace -p failed to detach'; }
44 | 
45 | if [ -f /proc/self/status ]; then
46 | 	$SLEEP_A_BIT
47 | 	test -d /proc/$tracee_pid ||
48 | 		{ cat $LOG; cleanup; fail_ 'tracee died after detach'; }
49 | 	grep '^State:.*R (running)' < /proc/$tracee_pid/status > /dev/null || {
50 | 		cat $LOG
51 | 		grep '^State:' < /proc/$tracee_pid/status
52 | 		cleanup
53 | 		fail_ 'tracee is not running after detach'
54 | 	}
55 | fi
56 | 
57 | cleanup
58 | exit 0
59 | 


--------------------------------------------------------------------------------
/tests/detach-sleeping.test:
--------------------------------------------------------------------------------
 1 | #!/bin/sh
 2 | 
 3 | # Ensure that strace can detach from sleeping processes.
 4 | 
 5 | . "${srcdir=.}/init.sh"
 6 | 
 7 | check_prog sleep
 8 | check_prog grep
 9 | 
10 | set -e
11 | 
12 | rm -f $LOG
13 | ./set_ptracer_any sleep $((2*$TIMEOUT_DURATION)) > $LOG &
14 | 
15 | while ! [ -s $LOG ]; do
16 | 	kill -0 $! 2> /dev/null ||
17 | 		fail_ 'set_ptracer_any sleep failed'
18 | 	$SLEEP_A_BIT
19 | done
20 | 
21 | tracee_pid=$!
22 | 
23 | cleanup()
24 | {
25 | 	set +e
26 | 	kill $tracee_pid
27 | 	wait $tracee_pid 2> /dev/null
28 | 	return 0
29 | }
30 | 
31 | rm -f $LOG
32 | $STRACE -p $tracee_pid 2> $LOG &
33 | 
34 | while ! grep -F "Process $tracee_pid attached" $LOG > /dev/null; do
35 | 	kill -0 $! 2> /dev/null ||
36 | 		{ cat $LOG; cleanup; fail_ 'strace -p does not work'; }
37 | 	$SLEEP_A_BIT
38 | done
39 | 
40 | kill -INT $!
41 | wait $!
42 | 
43 | grep -F "Process $tracee_pid detached" $LOG > /dev/null ||
44 | 	{ cat $LOG; cleanup; fail_ 'strace -p failed to detach'; }
45 | 
46 | if [ -f /proc/self/status ]; then
47 | 	$SLEEP_A_BIT
48 | 	test -d /proc/$tracee_pid ||
49 | 		{ cat $LOG; cleanup; fail_ 'tracee died after detach'; }
50 | 	grep '^State:.*S (sleeping)' < /proc/$tracee_pid/status > /dev/null || {
51 | 		cat $LOG
52 | 		grep '^State:' < /proc/$tracee_pid/status
53 | 		cleanup
54 | 		fail_ 'tracee is not sleeping after detach'
55 | 	}
56 | fi
57 | 
58 | cleanup
59 | exit 0
60 | 


--------------------------------------------------------------------------------
/tests/init.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/sh
 2 | 
 3 | ME_="${0##*/}"
 4 | 
 5 | LOG="$ME_.tmp"
 6 | rm -f "$LOG"
 7 | 
 8 | warn_() { printf >&2 '%s\n' "$*"; }
 9 | fail_() { warn_ "$ME_: failed test: $*"; exit 1; }
10 | skip_() { warn_ "$ME_: skipped test: $*"; exit 77; }
11 | framework_failure_() { warn_ "$ME_: framework failure: $*"; exit 99; }
12 | framework_skip_() { warn_ "$ME_: framework skip: $*"; exit 77; }
13 | 
14 | check_prog()
15 | {
16 | 	type "$@" > /dev/null 2>&1 ||
17 | 		framework_skip_ "$* is not available"
18 | }
19 | 
20 | : "${STRACE:=../strace}"
21 | : "${TIMEOUT_DURATION:=60}"
22 | : "${SLEEP_A_BIT:=sleep 1}"
23 | 


--------------------------------------------------------------------------------
/tests/net-accept-connect.c:
--------------------------------------------------------------------------------
 1 | #include <assert.h>
 2 | #include <stddef.h>
 3 | #include <string.h>
 4 | #include <unistd.h>
 5 | #include <sys/wait.h>
 6 | #include <sys/socket.h>
 7 | #include <sys/un.h>
 8 | 
 9 | #define SUN_PATH "local-stream"
10 | int main(void)
11 | {
12 | 	struct sockaddr_un addr = {
13 | 		.sun_family = AF_UNIX,
14 | 		.sun_path = SUN_PATH
15 | 	};
16 | 	socklen_t len = offsetof(struct sockaddr_un, sun_path) + sizeof SUN_PATH;
17 | 
18 | 	unlink(SUN_PATH);
19 | 	close(0);
20 | 	close(1);
21 | 
22 | 	assert(socket(PF_LOCAL, SOCK_STREAM, 0) == 0);
23 | 	assert(bind(0, (struct sockaddr *) &addr, len) == 0);
24 | 	assert(listen(0, 5) == 0);
25 | 
26 | 	memset(&addr, 0, sizeof addr);
27 | 	assert(getsockname(0, (struct sockaddr *) &addr, &len) == 0);
28 | 
29 | 	pid_t pid = fork();
30 | 	assert(pid >= 0);
31 | 
32 | 	if (pid) {
33 | 		assert(accept(0, (struct sockaddr *) &addr, &len) == 1);
34 | 		assert(close(0) == 0);
35 | 		int status;
36 | 		assert(waitpid(pid, &status, 0) == pid);
37 | 		assert(status == 0);
38 | 		assert(close(1) == 0);
39 | 	} else {
40 | 		assert(socket(PF_LOCAL, SOCK_STREAM, 0) == 1);
41 | 		assert(close(0) == 0);
42 | 		assert(connect(1, (struct sockaddr *) &addr, len) == 0);
43 | 		assert(close(1) == 0);
44 | 		return 0;
45 | 	}
46 | 
47 | 	unlink(SUN_PATH);
48 | 	return 0;
49 | }
50 | 


--------------------------------------------------------------------------------
/tests/net-fd.test:
--------------------------------------------------------------------------------
 1 | #!/bin/sh
 2 | 
 3 | # Check how network syscalls are traced when decoding socket descriptors
 4 | 
 5 | . "${srcdir=.}/init.sh"
 6 | 
 7 | # strace -y is implemented using /proc/self/fd
 8 | [ -d /proc/self/fd/ ] ||
 9 | 	framework_skip_ '/proc/self/fd/ is not available'
10 | 
11 | check_prog grep
12 | check_prog rm
13 | 
14 | rm -f $LOG.*
15 | 
16 | ./net-accept-connect ||
17 | 	fail_ 'net-accept-connect failed'
18 | 
19 | # using -y to test socket descriptors 'paths' decoding
20 | args="-tt -ff -y -o $LOG -enetwork ./net-accept-connect"
21 | $STRACE $args ||
22 | 	fail_ "strace $args failed"
23 | 
24 | "$srcdir"/../strace-log-merge $LOG > $LOG || {
25 | 	cat $LOG
26 | 	fail_ 'strace-log-merge failed'
27 | }
28 | 
29 | rm -f $LOG.*
30 | 
31 | grep_log()
32 | {
33 | 	local syscall="$1"; shift
34 | 	local prefix='[1-9][0-9]* +[0-9]+:[0-9]+:[0-9]+\.[0-9]+ +'
35 | 
36 | 	LC_ALL=C grep -E -x "$prefix$syscall$@" $LOG > /dev/null || {
37 | 		cat $LOG
38 | 		fail_ "strace -enetwork failed to trace \"$syscall\" properly"
39 | 	}
40 | }
41 | grep_log bind '\(0<socket:\[[0-9]+\]>, \{sa_family=AF_(LOCAL|UNIX|FILE), sun_path="local-stream"\}, 15\) += 0'
42 | grep_log listen '\(0<socket:\[[0-9]+\]>, 5\) += 0'
43 | grep_log getsockname '\(0<socket:\[[0-9]+\]>, \{sa_family=AF_(LOCAL|UNIX|FILE), sun_path="local-stream"\}, \[15\]\) += 0'
44 | grep_log accept '\(0<socket:\[[0-9]+\]>, \{sa_family=AF_(LOCAL|UNIX|FILE), NULL\}, \[2\]\) += 1<socket:\[[0-9]+\]>'
45 | grep_log connect '\(1<socket:\[[0-9]+\]>, \{sa_family=AF_(LOCAL|UNIX|FILE), sun_path="local-stream"\}, 15\) += 0'
46 | 
47 | exit 0
48 | 


--------------------------------------------------------------------------------
/tests/net.test:
--------------------------------------------------------------------------------
 1 | #!/bin/sh
 2 | 
 3 | # Check how network syscalls are traced.
 4 | 
 5 | . "${srcdir=.}/init.sh"
 6 | 
 7 | check_prog grep
 8 | check_prog rm
 9 | 
10 | rm -f $LOG.*
11 | 
12 | ./net-accept-connect ||
13 | 	fail_ 'net-accept-connect failed'
14 | 
15 | args="-tt -ff -o $LOG -enetwork ./net-accept-connect"
16 | $STRACE $args ||
17 | 	fail_ "strace $args failed"
18 | 
19 | "$srcdir"/../strace-log-merge $LOG > $LOG || {
20 | 	cat $LOG
21 | 	fail_ 'strace-log-merge failed'
22 | }
23 | 
24 | rm -f $LOG.*
25 | 
26 | grep_log()
27 | {
28 | 	local syscall="$1"; shift
29 | 	local prefix='[1-9][0-9]* +[0-9]+:[0-9]+:[0-9]+\.[0-9]+ +'
30 | 
31 | 	LC_ALL=C grep -E -x "$prefix$syscall$@" $LOG > /dev/null || {
32 | 		cat $LOG
33 | 		fail_ "strace -enetwork failed to trace \"$syscall\" properly"
34 | 	}
35 | }
36 | 
37 | grep_log socket '\(PF_(LOCAL|UNIX|FILE), SOCK_STREAM, 0\) += 0'
38 | grep_log socket '\(PF_(LOCAL|UNIX|FILE), SOCK_STREAM, 0\) += 1'
39 | grep_log bind '\(0, \{sa_family=AF_(LOCAL|UNIX|FILE), sun_path="local-stream"\}, 15\) += 0'
40 | grep_log listen '\(0, 5\) += 0'
41 | grep_log getsockname '\(0, \{sa_family=AF_(LOCAL|UNIX|FILE), sun_path="local-stream"\}, \[15\]\) += 0'
42 | grep_log accept '\(0, \{sa_family=AF_(LOCAL|UNIX|FILE), NULL\}, \[2\]\) += 1'
43 | grep_log connect '\(1, \{sa_family=AF_(LOCAL|UNIX|FILE), sun_path="local-stream"\}, 15\) += 0'
44 | 
45 | exit 0
46 | 


--------------------------------------------------------------------------------
/tests/ptrace_setoptions.test:
--------------------------------------------------------------------------------
 1 | #!/bin/sh
 2 | 
 3 | # Ensure that strace tests kernel PTRACE_O_TRACECLONE
 4 | # and PTRACE_O_TRACESYSGOOD support properly.
 5 | 
 6 | . "${srcdir=.}/init.sh"
 7 | 
 8 | [ "$(uname -s)" = Linux ] ||
 9 | 	skip_ 'The kernel is not a Linux kernel'
10 | case "$(uname -r)" in
11 | 	2.[6-9]*|2.[1-5][0-9]*|[3-9].*|[12][0-9]*) ;;
12 | 	*) skip_ 'The kernel is not Linux 2.6.* or newer' ;;
13 | esac
14 | 
15 | $STRACE -df -enone / > /dev/null 2> $LOG
16 | grep -F -x 'ptrace_setoptions = 0xe' $LOG > /dev/null || {
17 | 	cat $LOG
18 | 	fail_ 'strace -f failed to recognize proper kernel PTRACE_O_TRACECLONE support'
19 | }
20 | 
21 | grep -F -x 'ptrace_setoptions = 0x1f' $LOG > /dev/null || {
22 | 	cat $LOG
23 | 	fail_ 'strace -f failed to recognize proper kernel PTRACE_O_TRACESYSGOOD support'
24 | }
25 | 
26 | $STRACE -d -enone / > /dev/null 2> $LOG
27 | grep -F -x 'ptrace_setoptions = 0x11' $LOG > /dev/null || {
28 | 	cat $LOG
29 | 	fail_ 'strace failed to recognize proper kernel PTRACE_O_TRACESYSGOOD support'
30 | }
31 | 


--------------------------------------------------------------------------------
/tests/qual_syscall.test:
--------------------------------------------------------------------------------
 1 | #!/bin/sh
 2 | 
 3 | # Ensure that strace -e trace=set works.
 4 | 
 5 | . "${srcdir=.}/init.sh"
 6 | 
 7 | check_prog ls
 8 | check_prog grep
 9 | 
10 | $STRACE -e execve ls > /dev/null 2> $LOG &&
11 | grep '^execve(' $LOG > /dev/null ||
12 | 	{ cat $LOG; fail_ 'strace -e execve does not work'; }
13 | 
14 | grep -v '^execve(' $LOG |
15 | LC_ALL=C grep '^[[:alnum:]_]*(' > /dev/null &&
16 | 	{ cat $LOG; fail_ 'strace -e execve does not work properly'; }
17 | 
18 | $STRACE -e trace=process ls > /dev/null 2> $LOG &&
19 | grep '^execve(' $LOG > /dev/null ||
20 | 	{ cat $LOG; fail_ 'strace -e trace=process does not work'; }
21 | 
22 | grep '^open' $LOG > /dev/null &&
23 | 	{ cat $LOG; fail_ 'strace -e trace=process does not work properly'; }
24 | 
25 | exit 0
26 | 


--------------------------------------------------------------------------------
/tests/run.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/sh
 2 | 
 3 | . "${srcdir=.}/init.sh"
 4 | 
 5 | $STRACE -V > /dev/null ||
 6 | 	framework_failure_ "$STRACE is not available"
 7 | 
 8 | TIMEOUT="timeout -s 9 $TIMEOUT_DURATION"
 9 | $TIMEOUT true > /dev/null 2>&1 ||
10 | 	TIMEOUT=
11 | 
12 | exec $TIMEOUT "$@"
13 | 


--------------------------------------------------------------------------------
/tests/scm_rights-fd.test:
--------------------------------------------------------------------------------
 1 | #!/bin/sh
 2 | 
 3 | # Check how SCM_RIGHTS control messages are decoded in -y mode.
 4 | 
 5 | . "${srcdir=.}/init.sh"
 6 | 
 7 | # strace -y is implemented using /proc/$pid/fd
 8 | [ -d /proc/self/fd/ ] ||
 9 | 	framework_skip_ '/proc/self/fd/ is not available'
10 | 
11 | check_prog grep
12 | check_prog rm
13 | 
14 | rm -f $LOG.*
15 | 
16 | ./scm_rights ||
17 | 	fail_ 'scm_rights failed'
18 | 
19 | args="-tt -ff -y -xx -enetwork -o $LOG ./scm_rights"
20 | $STRACE $args ||
21 | 	fail_ "$STRACE $args failed"
22 | 
23 | "$srcdir"/../strace-log-merge $LOG > $LOG || {
24 | 	cat $LOG
25 | 	fail_ 'strace-log-merge failed'
26 | }
27 | rm -f $LOG.*
28 | 
29 | grep_log()
30 | {
31 | 	local syscall="$1"; shift
32 | 	local prefix='[1-9][0-9]* +[0-9]+:[0-9]+:[0-9]+\.[0-9]+ +'
33 | 
34 | 	LC_ALL=C grep -E -x "$prefix$syscall$*" $LOG > /dev/null || {
35 | 		cat $LOG
36 | 		fail_ "$STRACE $args failed to trace \"$syscall\" properly"
37 | 	}
38 | }
39 | 
40 | grep_log sendmsg '\(1<socket:\[[0-9]+\]>, \{msg_name\(0\)=NULL, msg_iov\(1\)=\[\{"\\x00\\x00\\x00\\x00[^"]*", [1-9][0-9]*\}\], msg_controllen=[1-9][0-9]*, \{cmsg_len=[1-9][0-9]*, cmsg_level=SOL_SOCKET, cmsg_type=SCM_RIGHTS, \{3</dev/null>\}\}, msg_flags=0\}, 0\) += [1-9][0-9]*'
41 | grep_log recvmsg '\(0<socket:\[[0-9]+\]>, \{msg_name\(0\)=NULL, msg_iov\(1\)=\[\{"\\x00\\x00\\x00\\x00[^"]*", [1-9][0-9]*\}\], msg_controllen=[1-9][0-9]*, \{cmsg_len=[1-9][0-9]*, cmsg_level=SOL_SOCKET, cmsg_type=SCM_RIGHTS, \{3</dev/null>\}\}, msg_flags=0\}, 0\) += [1-9][0-9]*'
42 | 
43 | exit 0
44 | 


--------------------------------------------------------------------------------
/tests/set_ptracer_any.c:
--------------------------------------------------------------------------------
 1 | #ifdef HAVE_CONFIG_H
 2 | # include "config.h"
 3 | #endif
 4 | #include <stdio.h>
 5 | #include <unistd.h>
 6 | #ifdef HAVE_PRCTL
 7 | # include <sys/prctl.h>
 8 | #endif
 9 | 
10 | int main(int argc, char **argv)
11 | {
12 | 	if (argc < 2)
13 | 		return 99;
14 | #if defined HAVE_PRCTL && defined PR_SET_PTRACER && defined PR_SET_PTRACER_ANY
15 | 	/* Turn off restrictions on tracing if applicable.  If the options
16 | 	 * aren't available on this system, that's OK too.  */
17 | 	(void) prctl(PR_SET_PTRACER, PR_SET_PTRACER_ANY);
18 | #endif
19 | 	if (write(1, "\n", 1) != 1) {
20 | 		perror("write");
21 | 		return 99;
22 | 	}
23 | 	(void) execvp(argv[1], argv + 1);
24 | 	perror(argv[1]);
25 | 	return 99;
26 | }
27 | 


--------------------------------------------------------------------------------
/tests/sigaction.c:
--------------------------------------------------------------------------------
 1 | #include <assert.h>
 2 | #include <stdlib.h>
 3 | #include <unistd.h>
 4 | #include <signal.h>
 5 | 
 6 | static void handle_signal(int no)
 7 | {
 8 | 	_exit(128 + no);
 9 | }
10 | 
11 | int
12 | main(void)
13 | {
14 | 	struct sigaction sa, sa0;
15 | 
16 | 	sa.sa_handler = SIG_IGN;
17 | 	sigemptyset(&sa.sa_mask);
18 | 	sigaddset(&sa.sa_mask, SIGHUP);
19 | 	sigaddset(&sa.sa_mask, SIGINT);
20 | 	sa.sa_flags = SA_RESTART;
21 | 	assert(!sigaction(SIGUSR2, &sa, &sa0));
22 | 
23 | 	sa.sa_handler = handle_signal;
24 | 	sigemptyset(&sa.sa_mask);
25 | 	sigaddset(&sa.sa_mask, SIGQUIT);
26 | 	sigaddset(&sa.sa_mask, SIGTERM);
27 | 	sa.sa_flags = SA_SIGINFO;
28 | 	assert(!sigaction(SIGUSR2, &sa, &sa0));
29 | 
30 | 	sa.sa_handler = SIG_DFL;
31 | 	sigemptyset(&sa.sa_mask);
32 | 	sa.sa_flags = 0;
33 | 	assert(!sigaction(SIGUSR2, &sa, &sa0));
34 | 
35 | 	sigfillset(&sa.sa_mask);
36 | 	sigdelset(&sa.sa_mask, SIGHUP);
37 | 	assert(!sigaction(SIGUSR2, &sa, &sa0));
38 | 
39 | 	return 0;
40 | }
41 | 


--------------------------------------------------------------------------------
/tests/sigaction.test:
--------------------------------------------------------------------------------
 1 | #!/bin/sh
 2 | 
 3 | # Check rt_sigaction decoding.
 4 | 
 5 | . "${srcdir=.}/init.sh"
 6 | 
 7 | check_prog awk
 8 | 
 9 | ./sigaction ||
10 | 	fail_ 'sigaction failed'
11 | 
12 | args="-o $LOG -ert_sigaction ./sigaction"
13 | $STRACE $args ||
14 | 	fail_ "strace $args failed"
15 | 
16 | awk -f "$srcdir"/sigaction.awk $LOG ||
17 | 	{ cat $LOG; fail_ 'unexpected output'; }
18 | 
19 | exit 0
20 | 


--------------------------------------------------------------------------------
/tests/stack-fcall-0.c:
--------------------------------------------------------------------------------
1 | int f1(int i);
2 | 
3 | int f0(int i)
4 | {
5 | 	return f1(i) - i;
6 | }
7 | 


--------------------------------------------------------------------------------
/tests/stack-fcall-1.c:
--------------------------------------------------------------------------------
1 | int f2(int i);
2 | 
3 | int f1(int i)
4 | {
5 | 	return f2(i) + i;
6 | }
7 | 


--------------------------------------------------------------------------------
/tests/stack-fcall-2.c:
--------------------------------------------------------------------------------
1 | int f3(int i);
2 | 
3 | int f2(int i)
4 | {
5 | 	return f3(i) - i;
6 | }
7 | 


--------------------------------------------------------------------------------
/tests/stack-fcall-3.c:
--------------------------------------------------------------------------------
1 | #include <unistd.h>
2 | 
3 | int f3(int i)
4 | {
5 | 	return getpid() + i;
6 | }
7 | 


--------------------------------------------------------------------------------
/tests/stack-fcall.c:
--------------------------------------------------------------------------------
1 | int f0(int i);
2 | 
3 | int main(int argc, char** argv)
4 | {
5 | 	f0(argc);
6 | 	return 0;
7 | }
8 | 


--------------------------------------------------------------------------------
/tests/strace-f.test:
--------------------------------------------------------------------------------
 1 | #!/bin/sh
 2 | 
 3 | # Ensure that strace -f works.
 4 | 
 5 | . "${srcdir=.}/init.sh"
 6 | 
 7 | time=/usr/bin/time
 8 | check_prog $time
 9 | 
10 | $STRACE -f $time /bin/ls > $LOG 2>&1 ||
11 | 	{ cat $LOG; fail_ 'strace -f does not work'; }
12 | 


--------------------------------------------------------------------------------
/tests/strace-k.test:
--------------------------------------------------------------------------------
 1 | #!/bin/sh
 2 | 
 3 | # Ensure that strace -k works.
 4 | 
 5 | . "${srcdir=.}/init.sh"
 6 | 
 7 | # strace -k is implemented using /proc/$pid/maps
 8 | [ -f /proc/self/maps ] ||
 9 | 	framework_skip_ '/proc/self/maps is not available'
10 | 
11 | check_prog sed
12 | check_prog tr
13 | 
14 | ./stack-fcall ||
15 | 	fail_ 'stack-fcall failed'
16 | 
17 | $STRACE -h | grep '^-k' > /dev/null ||
18 | 	skip_ 'strace -k is not available'
19 | 
20 | args="-e getpid -k ./stack-fcall"
21 | $STRACE $args > $LOG 2>&1 || {
22 | 	cat $LOG
23 | 	fail_ "$STRACE $args failed"
24 | }
25 | 
26 | expected='getpid f3 f2 f1 f0 main '
27 | result=$(sed -n '1,/(main+0x[a-f0-9]\+) .*/ s/^.*(\([^+]\+\)+0x[a-f0-9]\+) .*/\1/p' $LOG |
28 | 	tr '\n' ' ')
29 | 
30 | test "$result" = "$expected" || {
31 | 	cat $LOG
32 | 	echo "expected: \"$expected\""
33 | 	echo "result: \"$result\""
34 | 	fail_ "unexpected output from $STRACE $args"
35 | }
36 | 
37 | exit 0
38 | 


--------------------------------------------------------------------------------
/tests/uio.c:
--------------------------------------------------------------------------------
 1 | #ifdef HAVE_CONFIG_H
 2 | # include "config.h"
 3 | #endif
 4 | #include <fcntl.h>
 5 | #include <unistd.h>
 6 | #include <sys/uio.h>
 7 | #include <assert.h>
 8 | 
 9 | int
10 | main(void)
11 | {
12 | #if defined(HAVE_PREADV) && defined(HAVE_PWRITEV)
13 | 	const off_t offset = 0xdefaceddeadbeefLL;
14 | 	int fd;
15 | 	char buf[4];
16 | 	struct iovec iov = { buf, sizeof buf };
17 | 
18 | 	assert((fd = open("/dev/zero", O_RDONLY)) >= 0);
19 | 	assert(pread(fd, buf, sizeof buf, offset) == 4);
20 | 	assert(preadv(fd, &iov, 1, offset) == 4);
21 | 	assert(!close(fd));
22 | 
23 | 	assert((fd = open("/dev/null", O_WRONLY)) >= 0);
24 | 	assert(pwrite(fd, buf, sizeof buf, offset) == 4);
25 | 	assert(pwritev(fd, &iov, 1, offset) == 4);
26 | 	assert(!close(fd));
27 | 
28 | 	return 0;
29 | #else
30 | 	return 77;
31 | #endif
32 | }
33 | 


--------------------------------------------------------------------------------
/tests/uio.test:
--------------------------------------------------------------------------------
 1 | #!/bin/sh
 2 | 
 3 | # Check how pread/pwrite and preadv/pwritev syscalls are traced.
 4 | 
 5 | . "${srcdir=.}/init.sh"
 6 | 
 7 | check_prog grep
 8 | check_prog rm
 9 | 
10 | ./uio || {
11 | 	if [ $? -eq 77 ]; then
12 | 		framework_skip_ 'preadv/pwritev syscalls are not available'
13 | 	else
14 | 		fail_ 'uio failed'
15 | 	fi
16 | }
17 | 
18 | args="-edesc ./uio"
19 | $STRACE $args > $LOG 2>&1 || {
20 | 	cat $LOG
21 | 	fail_ "$STRACE $args failed"
22 | }
23 | 
24 | grep_log()
25 | {
26 | 	local syscall="$1"; shift
27 | 
28 | 	LC_ALL=C grep -E -x "$syscall$*" $LOG > /dev/null || {
29 | 		cat $LOG
30 | 		fail_ "$STRACE $args failed to trace \"$syscall\" properly"
31 | 	}
32 | }
33 | 
34 | grep_log 'pread(64)?' '\(3, "\\0\\0\\0\\0", 4, 1004211379570065135\) += 4'
35 | grep_log 'preadv' '\(3, \[{"\\0\\0\\0\\0", 4}\], 1, 1004211379570065135\) += 4'
36 | grep_log 'pwrite(64)?' '\(3, "\\0\\0\\0\\0", 4, 1004211379570065135\) += 4'
37 | grep_log 'pwritev' '\(3, \[{"\\0\\0\\0\\0", 4}\], 1, 1004211379570065135\) += 4'
38 | 
39 | exit 0
40 | 


--------------------------------------------------------------------------------
/xlat/access_flags.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/access_flags.in; do not edit. */
 2 | 
 3 | static const struct xlat access_flags[] = {
 4 | #if defined(F_OK) || (defined(HAVE_DECL_F_OK) && HAVE_DECL_F_OK)
 5 | 	XLAT(F_OK),
 6 | #endif
 7 | #if defined(R_OK) || (defined(HAVE_DECL_R_OK) && HAVE_DECL_R_OK)
 8 | 	XLAT(R_OK),
 9 | #endif
10 | #if defined(W_OK) || (defined(HAVE_DECL_W_OK) && HAVE_DECL_W_OK)
11 | 	XLAT(W_OK),
12 | #endif
13 | #if defined(X_OK) || (defined(HAVE_DECL_X_OK) && HAVE_DECL_X_OK)
14 | 	XLAT(X_OK),
15 | #endif
16 | #if defined(EFF_ONLY_OK) || (defined(HAVE_DECL_EFF_ONLY_OK) && HAVE_DECL_EFF_ONLY_OK)
17 | 	XLAT(EFF_ONLY_OK),
18 | #endif
19 | #if defined(EX_OK) || (defined(HAVE_DECL_EX_OK) && HAVE_DECL_EX_OK)
20 | 	XLAT(EX_OK),
21 | #endif
22 | 	XLAT_END
23 | };
24 | 


--------------------------------------------------------------------------------
/xlat/access_flags.in:
--------------------------------------------------------------------------------
1 | F_OK
2 | R_OK
3 | W_OK
4 | X_OK
5 | EFF_ONLY_OK
6 | EX_OK
7 | 


--------------------------------------------------------------------------------
/xlat/aclcmds.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/aclcmds.in; do not edit. */
 2 | 
 3 | static const struct xlat aclcmds[] = {
 4 | #if defined(SETACL) || (defined(HAVE_DECL_SETACL) && HAVE_DECL_SETACL)
 5 | 	XLAT(SETACL),
 6 | #endif
 7 | #if defined(GETACL) || (defined(HAVE_DECL_GETACL) && HAVE_DECL_GETACL)
 8 | 	XLAT(GETACL),
 9 | #endif
10 | #if defined(GETACLCNT) || (defined(HAVE_DECL_GETACLCNT) && HAVE_DECL_GETACLCNT)
11 | 	XLAT(GETACLCNT),
12 | #endif
13 | #if defined(ACL_GET) || (defined(HAVE_DECL_ACL_GET) && HAVE_DECL_ACL_GET)
14 | 	XLAT(ACL_GET),
15 | #endif
16 | #if defined(ACL_SET) || (defined(HAVE_DECL_ACL_SET) && HAVE_DECL_ACL_SET)
17 | 	XLAT(ACL_SET),
18 | #endif
19 | #if defined(ACL_CNT) || (defined(HAVE_DECL_ACL_CNT) && HAVE_DECL_ACL_CNT)
20 | 	XLAT(ACL_CNT),
21 | #endif
22 | 	XLAT_END
23 | };
24 | 


--------------------------------------------------------------------------------
/xlat/aclcmds.in:
--------------------------------------------------------------------------------
1 | SETACL
2 | GETACL
3 | GETACLCNT
4 | ACL_GET
5 | ACL_SET
6 | ACL_CNT
7 | 


--------------------------------------------------------------------------------
/xlat/aclipc.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/aclipc.in; do not edit. */
 2 | 
 3 | static const struct xlat aclipc[] = {
 4 | #if defined(IPC_SHM) || (defined(HAVE_DECL_IPC_SHM) && HAVE_DECL_IPC_SHM)
 5 | 	XLAT(IPC_SHM),
 6 | #endif
 7 | #if defined(IPC_SEM) || (defined(HAVE_DECL_IPC_SEM) && HAVE_DECL_IPC_SEM)
 8 | 	XLAT(IPC_SEM),
 9 | #endif
10 | #if defined(IPC_MSG) || (defined(HAVE_DECL_IPC_MSG) && HAVE_DECL_IPC_MSG)
11 | 	XLAT(IPC_MSG),
12 | #endif
13 | 	XLAT_END
14 | };
15 | 


--------------------------------------------------------------------------------
/xlat/aclipc.in:
--------------------------------------------------------------------------------
1 | IPC_SHM
2 | IPC_SEM
3 | IPC_MSG
4 | 


--------------------------------------------------------------------------------
/xlat/addrfams.in:
--------------------------------------------------------------------------------
 1 | AF_UNSPEC
 2 | AF_LOCAL
 3 | AF_UNIX
 4 | AF_INET
 5 | AF_AX25
 6 | AF_IPX
 7 | AF_APPLETALK
 8 | AF_NETROM
 9 | AF_BRIDGE
10 | AF_ATMPVC
11 | AF_X25
12 | AF_INET6
13 | AF_ROSE
14 | AF_DECnet
15 | AF_NETBEUI
16 | AF_SECURITY
17 | AF_KEY
18 | AF_NETLINK
19 | AF_ROUTE
20 | AF_PACKET
21 | AF_ASH
22 | AF_ECONET
23 | AF_ATMSVC
24 | AF_RDS
25 | AF_SNA
26 | AF_IRDA
27 | AF_PPPOX
28 | AF_WANPIPE
29 | AF_LLC
30 | AF_CAN
31 | AF_TIPC
32 | AF_BLUETOOTH
33 | AF_IUCV
34 | AF_RXRPC
35 | AF_ISDN
36 | AF_PHONET
37 | AF_IEEE802154
38 | AF_CAIF
39 | AF_ALG
40 | AF_NFC
41 | AF_VSOCK
42 | 


--------------------------------------------------------------------------------
/xlat/adjtimex_modes.in:
--------------------------------------------------------------------------------
 1 | 0
 2 | ADJ_OFFSET
 3 | ADJ_FREQUENCY
 4 | ADJ_MAXERROR
 5 | ADJ_ESTERROR
 6 | ADJ_STATUS
 7 | ADJ_TIMECONST
 8 | ADJ_TAI
 9 | ADJ_SETOFFSET
10 | ADJ_MICRO
11 | ADJ_NANO
12 | ADJ_TICK
13 | ADJ_OFFSET_SINGLESHOT
14 | ADJ_OFFSET_SS_READ
15 | 


--------------------------------------------------------------------------------
/xlat/adjtimex_state.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/adjtimex_state.in; do not edit. */
 2 | 
 3 | static const struct xlat adjtimex_state[] = {
 4 | #if defined(TIME_OK) || (defined(HAVE_DECL_TIME_OK) && HAVE_DECL_TIME_OK)
 5 | 	XLAT(TIME_OK),
 6 | #endif
 7 | #if defined(TIME_INS) || (defined(HAVE_DECL_TIME_INS) && HAVE_DECL_TIME_INS)
 8 | 	XLAT(TIME_INS),
 9 | #endif
10 | #if defined(TIME_DEL) || (defined(HAVE_DECL_TIME_DEL) && HAVE_DECL_TIME_DEL)
11 | 	XLAT(TIME_DEL),
12 | #endif
13 | #if defined(TIME_OOP) || (defined(HAVE_DECL_TIME_OOP) && HAVE_DECL_TIME_OOP)
14 | 	XLAT(TIME_OOP),
15 | #endif
16 | #if defined(TIME_WAIT) || (defined(HAVE_DECL_TIME_WAIT) && HAVE_DECL_TIME_WAIT)
17 | 	XLAT(TIME_WAIT),
18 | #endif
19 | #if defined(TIME_ERROR) || (defined(HAVE_DECL_TIME_ERROR) && HAVE_DECL_TIME_ERROR)
20 | 	XLAT(TIME_ERROR),
21 | #endif
22 | 	XLAT_END
23 | };
24 | 


--------------------------------------------------------------------------------
/xlat/adjtimex_state.in:
--------------------------------------------------------------------------------
1 | TIME_OK
2 | TIME_INS
3 | TIME_DEL
4 | TIME_OOP
5 | TIME_WAIT
6 | TIME_ERROR
7 | 


--------------------------------------------------------------------------------
/xlat/adjtimex_status.in:
--------------------------------------------------------------------------------
 1 | STA_PLL
 2 | STA_PPSFREQ
 3 | STA_PPSTIME
 4 | STA_FLL
 5 | STA_INS
 6 | STA_DEL
 7 | STA_UNSYNC
 8 | STA_FREQHOLD
 9 | STA_PPSSIGNAL
10 | STA_PPSJITTER
11 | STA_PPSWANDER
12 | STA_PPSERROR
13 | STA_CLOCKERR
14 | STA_NANO
15 | STA_MODE
16 | STA_CLK
17 | 


--------------------------------------------------------------------------------
/xlat/advise.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/advise.in; do not edit. */
 2 | 
 3 | static const struct xlat advise[] = {
 4 | #if defined(POSIX_FADV_NORMAL) || (defined(HAVE_DECL_POSIX_FADV_NORMAL) && HAVE_DECL_POSIX_FADV_NORMAL)
 5 | 	XLAT(POSIX_FADV_NORMAL),
 6 | #endif
 7 | #if defined(POSIX_FADV_RANDOM) || (defined(HAVE_DECL_POSIX_FADV_RANDOM) && HAVE_DECL_POSIX_FADV_RANDOM)
 8 | 	XLAT(POSIX_FADV_RANDOM),
 9 | #endif
10 | #if defined(POSIX_FADV_SEQUENTIAL) || (defined(HAVE_DECL_POSIX_FADV_SEQUENTIAL) && HAVE_DECL_POSIX_FADV_SEQUENTIAL)
11 | 	XLAT(POSIX_FADV_SEQUENTIAL),
12 | #endif
13 | #if defined(POSIX_FADV_WILLNEED) || (defined(HAVE_DECL_POSIX_FADV_WILLNEED) && HAVE_DECL_POSIX_FADV_WILLNEED)
14 | 	XLAT(POSIX_FADV_WILLNEED),
15 | #endif
16 | #if defined(POSIX_FADV_DONTNEED) || (defined(HAVE_DECL_POSIX_FADV_DONTNEED) && HAVE_DECL_POSIX_FADV_DONTNEED)
17 | 	XLAT(POSIX_FADV_DONTNEED),
18 | #endif
19 | #if defined(POSIX_FADV_NOREUSE) || (defined(HAVE_DECL_POSIX_FADV_NOREUSE) && HAVE_DECL_POSIX_FADV_NOREUSE)
20 | 	XLAT(POSIX_FADV_NOREUSE),
21 | #endif
22 | 	XLAT_END
23 | };
24 | 


--------------------------------------------------------------------------------
/xlat/advise.in:
--------------------------------------------------------------------------------
1 | POSIX_FADV_NORMAL
2 | POSIX_FADV_RANDOM
3 | POSIX_FADV_SEQUENTIAL
4 | POSIX_FADV_WILLNEED
5 | POSIX_FADV_DONTNEED
6 | POSIX_FADV_NOREUSE
7 | 


--------------------------------------------------------------------------------
/xlat/af_packet_types.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/af_packet_types.in; do not edit. */
 2 | 
 3 | static const struct xlat af_packet_types[] = {
 4 | #if defined(PACKET_HOST) || (defined(HAVE_DECL_PACKET_HOST) && HAVE_DECL_PACKET_HOST)
 5 | 	XLAT(PACKET_HOST),
 6 | #endif
 7 | #if defined(PACKET_BROADCAST) || (defined(HAVE_DECL_PACKET_BROADCAST) && HAVE_DECL_PACKET_BROADCAST)
 8 | 	XLAT(PACKET_BROADCAST),
 9 | #endif
10 | #if defined(PACKET_MULTICAST) || (defined(HAVE_DECL_PACKET_MULTICAST) && HAVE_DECL_PACKET_MULTICAST)
11 | 	XLAT(PACKET_MULTICAST),
12 | #endif
13 | #if defined(PACKET_OTHERHOST) || (defined(HAVE_DECL_PACKET_OTHERHOST) && HAVE_DECL_PACKET_OTHERHOST)
14 | 	XLAT(PACKET_OTHERHOST),
15 | #endif
16 | #if defined(PACKET_OUTGOING) || (defined(HAVE_DECL_PACKET_OUTGOING) && HAVE_DECL_PACKET_OUTGOING)
17 | 	XLAT(PACKET_OUTGOING),
18 | #endif
19 | #if defined(PACKET_LOOPBACK) || (defined(HAVE_DECL_PACKET_LOOPBACK) && HAVE_DECL_PACKET_LOOPBACK)
20 | 	XLAT(PACKET_LOOPBACK),
21 | #endif
22 | #if defined(PACKET_FASTROUTE) || (defined(HAVE_DECL_PACKET_FASTROUTE) && HAVE_DECL_PACKET_FASTROUTE)
23 | 	XLAT(PACKET_FASTROUTE),
24 | #endif
25 | 	XLAT_END
26 | };
27 | 


--------------------------------------------------------------------------------
/xlat/af_packet_types.in:
--------------------------------------------------------------------------------
1 | PACKET_HOST
2 | PACKET_BROADCAST
3 | PACKET_MULTICAST
4 | PACKET_OTHERHOST
5 | PACKET_OUTGOING
6 | PACKET_LOOPBACK
7 | PACKET_FASTROUTE
8 | 


--------------------------------------------------------------------------------
/xlat/archvals.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/archvals.in; do not edit. */
 2 | 
 3 | static const struct xlat archvals[] = {
 4 | #if defined(ARCH_SET_GS) || (defined(HAVE_DECL_ARCH_SET_GS) && HAVE_DECL_ARCH_SET_GS)
 5 | 	XLAT(ARCH_SET_GS),
 6 | #endif
 7 | #if defined(ARCH_SET_FS) || (defined(HAVE_DECL_ARCH_SET_FS) && HAVE_DECL_ARCH_SET_FS)
 8 | 	XLAT(ARCH_SET_FS),
 9 | #endif
10 | #if defined(ARCH_GET_FS) || (defined(HAVE_DECL_ARCH_GET_FS) && HAVE_DECL_ARCH_GET_FS)
11 | 	XLAT(ARCH_GET_FS),
12 | #endif
13 | #if defined(ARCH_GET_GS) || (defined(HAVE_DECL_ARCH_GET_GS) && HAVE_DECL_ARCH_GET_GS)
14 | 	XLAT(ARCH_GET_GS),
15 | #endif
16 | 	XLAT_END
17 | };
18 | 


--------------------------------------------------------------------------------
/xlat/archvals.in:
--------------------------------------------------------------------------------
1 | ARCH_SET_GS
2 | ARCH_SET_FS
3 | ARCH_GET_FS
4 | ARCH_GET_GS
5 | 


--------------------------------------------------------------------------------
/xlat/at_flags.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/at_flags.in; do not edit. */
 2 | 
 3 | static const struct xlat at_flags[] = {
 4 | #if defined(AT_SYMLINK_NOFOLLOW) || (defined(HAVE_DECL_AT_SYMLINK_NOFOLLOW) && HAVE_DECL_AT_SYMLINK_NOFOLLOW)
 5 | 	XLAT(AT_SYMLINK_NOFOLLOW),
 6 | #endif
 7 | #if defined(AT_REMOVEDIR) || (defined(HAVE_DECL_AT_REMOVEDIR) && HAVE_DECL_AT_REMOVEDIR)
 8 | 	XLAT(AT_REMOVEDIR),
 9 | #endif
10 | #if defined(AT_SYMLINK_FOLLOW) || (defined(HAVE_DECL_AT_SYMLINK_FOLLOW) && HAVE_DECL_AT_SYMLINK_FOLLOW)
11 | 	XLAT(AT_SYMLINK_FOLLOW),
12 | #endif
13 | #if defined(AT_NO_AUTOMOUNT) || (defined(HAVE_DECL_AT_NO_AUTOMOUNT) && HAVE_DECL_AT_NO_AUTOMOUNT)
14 | 	XLAT(AT_NO_AUTOMOUNT),
15 | #endif
16 | #if defined(AT_EMPTY_PATH) || (defined(HAVE_DECL_AT_EMPTY_PATH) && HAVE_DECL_AT_EMPTY_PATH)
17 | 	XLAT(AT_EMPTY_PATH),
18 | #endif
19 | 	XLAT_END
20 | };
21 | 


--------------------------------------------------------------------------------
/xlat/at_flags.in:
--------------------------------------------------------------------------------
1 | AT_SYMLINK_NOFOLLOW
2 | AT_REMOVEDIR
3 | AT_SYMLINK_FOLLOW
4 | AT_NO_AUTOMOUNT
5 | AT_EMPTY_PATH
6 | 


--------------------------------------------------------------------------------
/xlat/atomic_ops.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/atomic_ops.in; do not edit. */
 2 | 
 3 | static const struct xlat atomic_ops[] = {
 4 | { OR1K_ATOMIC_SWAP,		"SWAP"		},
 5 | { OR1K_ATOMIC_CMPXCHG,		"CMPXCHG"	},
 6 | { OR1K_ATOMIC_XCHG,		"XCHG"		},
 7 | { OR1K_ATOMIC_ADD,		"ADD"		},
 8 | { OR1K_ATOMIC_DECPOS,		"DECPOS"	},
 9 | { OR1K_ATOMIC_AND,		"AND"		},
10 | { OR1K_ATOMIC_OR,		"OR"		},
11 | { OR1K_ATOMIC_UMAX,		"UMAX"		},
12 | { OR1K_ATOMIC_UMIN,		"UMIN"		},
13 | 	XLAT_END
14 | };
15 | 


--------------------------------------------------------------------------------
/xlat/atomic_ops.in:
--------------------------------------------------------------------------------
 1 | 	{ OR1K_ATOMIC_SWAP,		"SWAP"		},
 2 | 	{ OR1K_ATOMIC_CMPXCHG,		"CMPXCHG"	},
 3 | 	{ OR1K_ATOMIC_XCHG,		"XCHG"		},
 4 | 	{ OR1K_ATOMIC_ADD,		"ADD"		},
 5 | 	{ OR1K_ATOMIC_DECPOS,		"DECPOS"	},
 6 | 	{ OR1K_ATOMIC_AND,		"AND"		},
 7 | 	{ OR1K_ATOMIC_OR,		"OR"		},
 8 | 	{ OR1K_ATOMIC_UMAX,		"UMAX"		},
 9 | 	{ OR1K_ATOMIC_UMIN,		"UMIN"		},
10 | 


--------------------------------------------------------------------------------
/xlat/baud_options.in:
--------------------------------------------------------------------------------
 1 | B0
 2 | B50
 3 | B75
 4 | B110
 5 | B134
 6 | B150
 7 | B200
 8 | B300
 9 | B600
10 | B1200
11 | B1800
12 | B2400
13 | B4800
14 | B9600
15 | B19200
16 | B38400
17 | B57600
18 | B115200
19 | B230400
20 | B460800
21 | B500000
22 | B576000
23 | B921600
24 | B1000000
25 | B1152000
26 | B1500000
27 | B2000000
28 | B2500000
29 | B3000000
30 | B3500000
31 | B4000000
32 | EXTA
33 | EXTB
34 | 


--------------------------------------------------------------------------------
/xlat/blkpg_ops.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/blkpg_ops.in; do not edit. */
 2 | 
 3 | static const struct xlat blkpg_ops[] = {
 4 | #if defined(BLKPG_ADD_PARTITION) || (defined(HAVE_DECL_BLKPG_ADD_PARTITION) && HAVE_DECL_BLKPG_ADD_PARTITION)
 5 | 	XLAT(BLKPG_ADD_PARTITION),
 6 | #endif
 7 | #if defined(BLKPG_DEL_PARTITION) || (defined(HAVE_DECL_BLKPG_DEL_PARTITION) && HAVE_DECL_BLKPG_DEL_PARTITION)
 8 | 	XLAT(BLKPG_DEL_PARTITION),
 9 | #endif
10 | 	XLAT_END
11 | };
12 | 


--------------------------------------------------------------------------------
/xlat/blkpg_ops.in:
--------------------------------------------------------------------------------
1 | BLKPG_ADD_PARTITION
2 | BLKPG_DEL_PARTITION
3 | 


--------------------------------------------------------------------------------
/xlat/bootflags1.h:
--------------------------------------------------------------------------------
1 | /* Generated by ./xlat/gen.sh from ./xlat/bootflags1.in; do not edit. */
2 | 
3 | static const struct xlat bootflags1[] = {
4 | #if defined(LINUX_REBOOT_MAGIC1) || (defined(HAVE_DECL_LINUX_REBOOT_MAGIC1) && HAVE_DECL_LINUX_REBOOT_MAGIC1)
5 | 	XLAT(LINUX_REBOOT_MAGIC1),
6 | #endif
7 | 	XLAT_END
8 | };
9 | 


--------------------------------------------------------------------------------
/xlat/bootflags1.in:
--------------------------------------------------------------------------------
1 | LINUX_REBOOT_MAGIC1
2 | 


--------------------------------------------------------------------------------
/xlat/bootflags2.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/bootflags2.in; do not edit. */
 2 | 
 3 | static const struct xlat bootflags2[] = {
 4 | #if defined(LINUX_REBOOT_MAGIC2) || (defined(HAVE_DECL_LINUX_REBOOT_MAGIC2) && HAVE_DECL_LINUX_REBOOT_MAGIC2)
 5 | 	XLAT(LINUX_REBOOT_MAGIC2),
 6 | #endif
 7 | #if defined(LINUX_REBOOT_MAGIC2A) || (defined(HAVE_DECL_LINUX_REBOOT_MAGIC2A) && HAVE_DECL_LINUX_REBOOT_MAGIC2A)
 8 | 	XLAT(LINUX_REBOOT_MAGIC2A),
 9 | #endif
10 | #if defined(LINUX_REBOOT_MAGIC2B) || (defined(HAVE_DECL_LINUX_REBOOT_MAGIC2B) && HAVE_DECL_LINUX_REBOOT_MAGIC2B)
11 | 	XLAT(LINUX_REBOOT_MAGIC2B),
12 | #endif
13 | #if defined(LINUX_REBOOT_MAGIC2C) || (defined(HAVE_DECL_LINUX_REBOOT_MAGIC2C) && HAVE_DECL_LINUX_REBOOT_MAGIC2C)
14 | 	XLAT(LINUX_REBOOT_MAGIC2C),
15 | #endif
16 | 	XLAT_END
17 | };
18 | 


--------------------------------------------------------------------------------
/xlat/bootflags2.in:
--------------------------------------------------------------------------------
1 | LINUX_REBOOT_MAGIC2
2 | LINUX_REBOOT_MAGIC2A
3 | LINUX_REBOOT_MAGIC2B
4 | LINUX_REBOOT_MAGIC2C
5 | 


--------------------------------------------------------------------------------
/xlat/bootflags3.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/bootflags3.in; do not edit. */
 2 | 
 3 | static const struct xlat bootflags3[] = {
 4 | #if defined(LINUX_REBOOT_CMD_RESTART) || (defined(HAVE_DECL_LINUX_REBOOT_CMD_RESTART) && HAVE_DECL_LINUX_REBOOT_CMD_RESTART)
 5 | 	XLAT(LINUX_REBOOT_CMD_RESTART),
 6 | #endif
 7 | #if defined(LINUX_REBOOT_CMD_HALT) || (defined(HAVE_DECL_LINUX_REBOOT_CMD_HALT) && HAVE_DECL_LINUX_REBOOT_CMD_HALT)
 8 | 	XLAT(LINUX_REBOOT_CMD_HALT),
 9 | #endif
10 | #if defined(LINUX_REBOOT_CMD_CAD_ON) || (defined(HAVE_DECL_LINUX_REBOOT_CMD_CAD_ON) && HAVE_DECL_LINUX_REBOOT_CMD_CAD_ON)
11 | 	XLAT(LINUX_REBOOT_CMD_CAD_ON),
12 | #endif
13 | #if defined(LINUX_REBOOT_CMD_CAD_OFF) || (defined(HAVE_DECL_LINUX_REBOOT_CMD_CAD_OFF) && HAVE_DECL_LINUX_REBOOT_CMD_CAD_OFF)
14 | 	XLAT(LINUX_REBOOT_CMD_CAD_OFF),
15 | #endif
16 | #if defined(LINUX_REBOOT_CMD_POWER_OFF) || (defined(HAVE_DECL_LINUX_REBOOT_CMD_POWER_OFF) && HAVE_DECL_LINUX_REBOOT_CMD_POWER_OFF)
17 | 	XLAT(LINUX_REBOOT_CMD_POWER_OFF),
18 | #endif
19 | #if defined(LINUX_REBOOT_CMD_RESTART2) || (defined(HAVE_DECL_LINUX_REBOOT_CMD_RESTART2) && HAVE_DECL_LINUX_REBOOT_CMD_RESTART2)
20 | 	XLAT(LINUX_REBOOT_CMD_RESTART2),
21 | #endif
22 | #if defined(LINUX_REBOOT_CMD_SW_SUSPEND) || (defined(HAVE_DECL_LINUX_REBOOT_CMD_SW_SUSPEND) && HAVE_DECL_LINUX_REBOOT_CMD_SW_SUSPEND)
23 | 	XLAT(LINUX_REBOOT_CMD_SW_SUSPEND),
24 | #endif
25 | #if defined(LINUX_REBOOT_CMD_KEXEC) || (defined(HAVE_DECL_LINUX_REBOOT_CMD_KEXEC) && HAVE_DECL_LINUX_REBOOT_CMD_KEXEC)
26 | 	XLAT(LINUX_REBOOT_CMD_KEXEC),
27 | #endif
28 | 	XLAT_END
29 | };
30 | 


--------------------------------------------------------------------------------
/xlat/bootflags3.in:
--------------------------------------------------------------------------------
1 | LINUX_REBOOT_CMD_RESTART
2 | LINUX_REBOOT_CMD_HALT
3 | LINUX_REBOOT_CMD_CAD_ON
4 | LINUX_REBOOT_CMD_CAD_OFF
5 | LINUX_REBOOT_CMD_POWER_OFF
6 | LINUX_REBOOT_CMD_RESTART2
7 | LINUX_REBOOT_CMD_SW_SUSPEND
8 | LINUX_REBOOT_CMD_KEXEC
9 | 


--------------------------------------------------------------------------------
/xlat/cacheflush_scope.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/cacheflush_scope.in; do not edit. */
 2 | 
 3 | static const struct xlat cacheflush_scope[] = {
 4 | #if defined(FLUSH_SCOPE_LINE) || (defined(HAVE_DECL_FLUSH_SCOPE_LINE) && HAVE_DECL_FLUSH_SCOPE_LINE)
 5 | 	XLAT(FLUSH_SCOPE_LINE),
 6 | #endif
 7 | #if defined(FLUSH_SCOPE_PAGE) || (defined(HAVE_DECL_FLUSH_SCOPE_PAGE) && HAVE_DECL_FLUSH_SCOPE_PAGE)
 8 | 	XLAT(FLUSH_SCOPE_PAGE),
 9 | #endif
10 | #if defined(FLUSH_SCOPE_ALL) || (defined(HAVE_DECL_FLUSH_SCOPE_ALL) && HAVE_DECL_FLUSH_SCOPE_ALL)
11 | 	XLAT(FLUSH_SCOPE_ALL),
12 | #endif
13 | 	XLAT_END
14 | };
15 | 


--------------------------------------------------------------------------------
/xlat/cacheflush_scope.in:
--------------------------------------------------------------------------------
1 | FLUSH_SCOPE_LINE
2 | FLUSH_SCOPE_PAGE
3 | FLUSH_SCOPE_ALL
4 | 


--------------------------------------------------------------------------------
/xlat/cap_version.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/cap_version.in; do not edit. */
 2 | 
 3 | static const struct xlat cap_version[] = {
 4 | #if defined(_LINUX_CAPABILITY_VERSION_1) || (defined(HAVE_DECL__LINUX_CAPABILITY_VERSION_1) && HAVE_DECL__LINUX_CAPABILITY_VERSION_1)
 5 | 	XLAT(_LINUX_CAPABILITY_VERSION_1),
 6 | #endif
 7 | #if defined(_LINUX_CAPABILITY_VERSION_2) || (defined(HAVE_DECL__LINUX_CAPABILITY_VERSION_2) && HAVE_DECL__LINUX_CAPABILITY_VERSION_2)
 8 | 	XLAT(_LINUX_CAPABILITY_VERSION_2),
 9 | #endif
10 | #if defined(_LINUX_CAPABILITY_VERSION_3) || (defined(HAVE_DECL__LINUX_CAPABILITY_VERSION_3) && HAVE_DECL__LINUX_CAPABILITY_VERSION_3)
11 | 	XLAT(_LINUX_CAPABILITY_VERSION_3),
12 | #endif
13 | 	XLAT_END
14 | };
15 | 


--------------------------------------------------------------------------------
/xlat/cap_version.in:
--------------------------------------------------------------------------------
1 | _LINUX_CAPABILITY_VERSION_1
2 | _LINUX_CAPABILITY_VERSION_2
3 | _LINUX_CAPABILITY_VERSION_3
4 | 


--------------------------------------------------------------------------------
/xlat/capabilities.in:
--------------------------------------------------------------------------------
 1 | 1<<CAP_CHOWN
 2 | 1<<CAP_DAC_OVERRIDE
 3 | 1<<CAP_DAC_READ_SEARCH
 4 | 1<<CAP_FOWNER
 5 | 1<<CAP_FSETID
 6 | 1<<CAP_KILL
 7 | 1<<CAP_SETGID
 8 | 1<<CAP_SETUID
 9 | 1<<CAP_SETPCAP
10 | 1<<CAP_LINUX_IMMUTABLE
11 | 1<<CAP_NET_BIND_SERVICE
12 | 1<<CAP_NET_BROADCAST
13 | 1<<CAP_NET_ADMIN
14 | 1<<CAP_NET_RAW
15 | 1<<CAP_IPC_LOCK
16 | 1<<CAP_IPC_OWNER
17 | 1<<CAP_SYS_MODULE
18 | 1<<CAP_SYS_RAWIO
19 | 1<<CAP_SYS_CHROOT
20 | 1<<CAP_SYS_PTRACE
21 | 1<<CAP_SYS_PACCT
22 | 1<<CAP_SYS_ADMIN
23 | 1<<CAP_SYS_BOOT
24 | 1<<CAP_SYS_NICE
25 | 1<<CAP_SYS_RESOURCE
26 | 1<<CAP_SYS_TIME
27 | 1<<CAP_SYS_TTY_CONFIG
28 | 1<<CAP_MKNOD
29 | 1<<CAP_LEASE
30 | 1<<CAP_AUDIT_WRITE
31 | 1<<CAP_AUDIT_CONTROL
32 | 1<<CAP_SETFCAP
33 | 


--------------------------------------------------------------------------------
/xlat/clockflags.h:
--------------------------------------------------------------------------------
1 | /* Generated by ./xlat/gen.sh from ./xlat/clockflags.in; do not edit. */
2 | 
3 | static const struct xlat clockflags[] = {
4 | #if defined(TIMER_ABSTIME) || (defined(HAVE_DECL_TIMER_ABSTIME) && HAVE_DECL_TIMER_ABSTIME)
5 | 	XLAT(TIMER_ABSTIME),
6 | #endif
7 | 	XLAT_END
8 | };
9 | 


--------------------------------------------------------------------------------
/xlat/clockflags.in:
--------------------------------------------------------------------------------
1 | TIMER_ABSTIME
2 | 


--------------------------------------------------------------------------------
/xlat/clocknames.in:
--------------------------------------------------------------------------------
 1 | CLOCK_REALTIME
 2 | CLOCK_MONOTONIC
 3 | CLOCK_PROCESS_CPUTIME_ID
 4 | CLOCK_THREAD_CPUTIME_ID
 5 | CLOCK_MONOTONIC_RAW
 6 | CLOCK_REALTIME_COARSE
 7 | CLOCK_MONOTONIC_COARSE
 8 | CLOCK_BOOTTIME
 9 | CLOCK_REALTIME_ALARM
10 | CLOCK_BOOTTIME_ALARM
11 | CLOCK_SGI_CYCLE
12 | CLOCK_TAI
13 | 


--------------------------------------------------------------------------------
/xlat/clone_flags.in:
--------------------------------------------------------------------------------
 1 | CLONE_VM
 2 | CLONE_FS
 3 | CLONE_FILES
 4 | CLONE_SIGHAND
 5 | CLONE_IDLETASK
 6 | CLONE_PTRACE
 7 | CLONE_VFORK
 8 | CLONE_PARENT
 9 | CLONE_THREAD
10 | CLONE_NEWNS
11 | CLONE_SYSVSEM
12 | CLONE_SETTLS
13 | CLONE_PARENT_SETTID
14 | CLONE_CHILD_CLEARTID
15 | CLONE_UNTRACED
16 | CLONE_CHILD_SETTID
17 | CLONE_STOPPED
18 | CLONE_NEWUTS
19 | CLONE_NEWIPC
20 | CLONE_NEWUSER
21 | CLONE_NEWPID
22 | CLONE_NEWNET
23 | CLONE_IO
24 | 


--------------------------------------------------------------------------------
/xlat/cpuclocknames.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/cpuclocknames.in; do not edit. */
 2 | 
 3 | static const struct xlat cpuclocknames[] = {
 4 | #if defined(CPUCLOCK_PROF) || (defined(HAVE_DECL_CPUCLOCK_PROF) && HAVE_DECL_CPUCLOCK_PROF)
 5 | 	XLAT(CPUCLOCK_PROF),
 6 | #endif
 7 | #if defined(CPUCLOCK_VIRT) || (defined(HAVE_DECL_CPUCLOCK_VIRT) && HAVE_DECL_CPUCLOCK_VIRT)
 8 | 	XLAT(CPUCLOCK_VIRT),
 9 | #endif
10 | #if defined(CPUCLOCK_SCHED) || (defined(HAVE_DECL_CPUCLOCK_SCHED) && HAVE_DECL_CPUCLOCK_SCHED)
11 | 	XLAT(CPUCLOCK_SCHED),
12 | #endif
13 | 	XLAT_END
14 | };
15 | 


--------------------------------------------------------------------------------
/xlat/cpuclocknames.in:
--------------------------------------------------------------------------------
1 | CPUCLOCK_PROF
2 | CPUCLOCK_VIRT
3 | CPUCLOCK_SCHED
4 | 


--------------------------------------------------------------------------------
/xlat/delete_module_flags.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/delete_module_flags.in; do not edit. */
 2 | 
 3 | static const struct xlat delete_module_flags[] = {
 4 | #if defined(O_NONBLOCK) || (defined(HAVE_DECL_O_NONBLOCK) && HAVE_DECL_O_NONBLOCK)
 5 | 	XLAT(O_NONBLOCK),
 6 | #endif
 7 | #if defined(O_TRUNC) || (defined(HAVE_DECL_O_TRUNC) && HAVE_DECL_O_TRUNC)
 8 | 	XLAT(O_TRUNC),
 9 | #endif
10 | 	XLAT_END
11 | };
12 | 


--------------------------------------------------------------------------------
/xlat/delete_module_flags.in:
--------------------------------------------------------------------------------
1 | O_NONBLOCK
2 | O_TRUNC
3 | 


--------------------------------------------------------------------------------
/xlat/direnttypes.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/direnttypes.in; do not edit. */
 2 | 
 3 | static const struct xlat direnttypes[] = {
 4 | #if defined(DT_UNKNOWN) || (defined(HAVE_DECL_DT_UNKNOWN) && HAVE_DECL_DT_UNKNOWN)
 5 | 	XLAT(DT_UNKNOWN),
 6 | #endif
 7 | #if defined(DT_FIFO) || (defined(HAVE_DECL_DT_FIFO) && HAVE_DECL_DT_FIFO)
 8 | 	XLAT(DT_FIFO),
 9 | #endif
10 | #if defined(DT_CHR) || (defined(HAVE_DECL_DT_CHR) && HAVE_DECL_DT_CHR)
11 | 	XLAT(DT_CHR),
12 | #endif
13 | #if defined(DT_DIR) || (defined(HAVE_DECL_DT_DIR) && HAVE_DECL_DT_DIR)
14 | 	XLAT(DT_DIR),
15 | #endif
16 | #if defined(DT_BLK) || (defined(HAVE_DECL_DT_BLK) && HAVE_DECL_DT_BLK)
17 | 	XLAT(DT_BLK),
18 | #endif
19 | #if defined(DT_REG) || (defined(HAVE_DECL_DT_REG) && HAVE_DECL_DT_REG)
20 | 	XLAT(DT_REG),
21 | #endif
22 | #if defined(DT_LNK) || (defined(HAVE_DECL_DT_LNK) && HAVE_DECL_DT_LNK)
23 | 	XLAT(DT_LNK),
24 | #endif
25 | #if defined(DT_SOCK) || (defined(HAVE_DECL_DT_SOCK) && HAVE_DECL_DT_SOCK)
26 | 	XLAT(DT_SOCK),
27 | #endif
28 | #if defined(DT_WHT) || (defined(HAVE_DECL_DT_WHT) && HAVE_DECL_DT_WHT)
29 | 	XLAT(DT_WHT),
30 | #endif
31 | 	XLAT_END
32 | };
33 | 


--------------------------------------------------------------------------------
/xlat/direnttypes.in:
--------------------------------------------------------------------------------
 1 | DT_UNKNOWN
 2 | DT_FIFO
 3 | DT_CHR
 4 | DT_DIR
 5 | DT_BLK
 6 | DT_REG
 7 | DT_LNK
 8 | DT_SOCK
 9 | DT_WHT
10 | 


--------------------------------------------------------------------------------
/xlat/domains.in:
--------------------------------------------------------------------------------
 1 | PF_UNSPEC
 2 | PF_LOCAL
 3 | PF_UNIX
 4 | PF_INET
 5 | PF_AX25
 6 | PF_IPX
 7 | PF_APPLETALK
 8 | PF_NETROM
 9 | PF_BRIDGE
10 | PF_ATMPVC
11 | PF_X25
12 | PF_INET6
13 | PF_ROSE
14 | PF_DECnet
15 | PF_NETBEUI
16 | PF_SECURITY
17 | PF_KEY
18 | PF_NETLINK
19 | PF_ROUTE
20 | PF_PACKET
21 | PF_ASH
22 | PF_ECONET
23 | PF_ATMSVC
24 | PF_RDS
25 | PF_SNA
26 | PF_IRDA
27 | PF_PPPOX
28 | PF_WANPIPE
29 | PF_LLC
30 | PF_CAN
31 | PF_TIPC
32 | PF_BLUETOOTH
33 | PF_IUCV
34 | PF_RXRPC
35 | PF_ISDN
36 | PF_PHONET
37 | PF_IEEE802154
38 | PF_CAIF
39 | PF_ALG
40 | PF_NFC
41 | PF_VSOCK
42 | 


--------------------------------------------------------------------------------
/xlat/epollctls.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/epollctls.in; do not edit. */
 2 | 
 3 | static const struct xlat epollctls[] = {
 4 | #if defined(EPOLL_CTL_ADD) || (defined(HAVE_DECL_EPOLL_CTL_ADD) && HAVE_DECL_EPOLL_CTL_ADD)
 5 | 	XLAT(EPOLL_CTL_ADD),
 6 | #endif
 7 | #if defined(EPOLL_CTL_MOD) || (defined(HAVE_DECL_EPOLL_CTL_MOD) && HAVE_DECL_EPOLL_CTL_MOD)
 8 | 	XLAT(EPOLL_CTL_MOD),
 9 | #endif
10 | #if defined(EPOLL_CTL_DEL) || (defined(HAVE_DECL_EPOLL_CTL_DEL) && HAVE_DECL_EPOLL_CTL_DEL)
11 | 	XLAT(EPOLL_CTL_DEL),
12 | #endif
13 | 	XLAT_END
14 | };
15 | 


--------------------------------------------------------------------------------
/xlat/epollctls.in:
--------------------------------------------------------------------------------
1 | EPOLL_CTL_ADD
2 | EPOLL_CTL_MOD
3 | EPOLL_CTL_DEL
4 | 


--------------------------------------------------------------------------------
/xlat/epollevents.in:
--------------------------------------------------------------------------------
 1 | EPOLLIN
 2 | EPOLLPRI
 3 | EPOLLOUT
 4 | EPOLLRDNORM
 5 | EPOLLRDBAND
 6 | EPOLLWRNORM
 7 | EPOLLWRBAND
 8 | EPOLLMSG
 9 | EPOLLERR
10 | EPOLLHUP
11 | EPOLLRDHUP
12 | EPOLLONESHOT
13 | EPOLLET
14 | 


--------------------------------------------------------------------------------
/xlat/epollflags.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/epollflags.in; do not edit. */
 2 | 
 3 | static const struct xlat epollflags[] = {
 4 | #if defined(EPOLL_CLOEXEC) || (defined(HAVE_DECL_EPOLL_CLOEXEC) && HAVE_DECL_EPOLL_CLOEXEC)
 5 | 	XLAT(EPOLL_CLOEXEC),
 6 | #endif
 7 | #if defined(EPOLL_NONBLOCK) || (defined(HAVE_DECL_EPOLL_NONBLOCK) && HAVE_DECL_EPOLL_NONBLOCK)
 8 | 	XLAT(EPOLL_NONBLOCK),
 9 | #endif
10 | 	XLAT_END
11 | };
12 | 


--------------------------------------------------------------------------------
/xlat/epollflags.in:
--------------------------------------------------------------------------------
1 | EPOLL_CLOEXEC
2 | EPOLL_NONBLOCK
3 | 


--------------------------------------------------------------------------------
/xlat/fan_classes.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/fan_classes.in; do not edit. */
 2 | 
 3 | static const struct xlat fan_classes[] = {
 4 | #if defined(FAN_CLASS_NOTIF) || (defined(HAVE_DECL_FAN_CLASS_NOTIF) && HAVE_DECL_FAN_CLASS_NOTIF)
 5 | 	XLAT(FAN_CLASS_NOTIF),
 6 | #endif
 7 | #if defined(FAN_CLASS_CONTENT) || (defined(HAVE_DECL_FAN_CLASS_CONTENT) && HAVE_DECL_FAN_CLASS_CONTENT)
 8 | 	XLAT(FAN_CLASS_CONTENT),
 9 | #endif
10 | #if defined(FAN_CLASS_PRE_CONTENT) || (defined(HAVE_DECL_FAN_CLASS_PRE_CONTENT) && HAVE_DECL_FAN_CLASS_PRE_CONTENT)
11 | 	XLAT(FAN_CLASS_PRE_CONTENT),
12 | #endif
13 | 	XLAT_END
14 | };
15 | 


--------------------------------------------------------------------------------
/xlat/fan_classes.in:
--------------------------------------------------------------------------------
1 | FAN_CLASS_NOTIF
2 | FAN_CLASS_CONTENT
3 | FAN_CLASS_PRE_CONTENT
4 | 


--------------------------------------------------------------------------------
/xlat/fan_event_flags.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/fan_event_flags.in; do not edit. */
 2 | 
 3 | static const struct xlat fan_event_flags[] = {
 4 | #if defined(FAN_ACCESS) || (defined(HAVE_DECL_FAN_ACCESS) && HAVE_DECL_FAN_ACCESS)
 5 | 	XLAT(FAN_ACCESS),
 6 | #endif
 7 | #if defined(FAN_MODIFY) || (defined(HAVE_DECL_FAN_MODIFY) && HAVE_DECL_FAN_MODIFY)
 8 | 	XLAT(FAN_MODIFY),
 9 | #endif
10 | #if defined(FAN_CLOSE) || (defined(HAVE_DECL_FAN_CLOSE) && HAVE_DECL_FAN_CLOSE)
11 | 	XLAT(FAN_CLOSE),
12 | #endif
13 | #if defined(FAN_CLOSE_WRITE) || (defined(HAVE_DECL_FAN_CLOSE_WRITE) && HAVE_DECL_FAN_CLOSE_WRITE)
14 | 	XLAT(FAN_CLOSE_WRITE),
15 | #endif
16 | #if defined(FAN_CLOSE_NOWRITE) || (defined(HAVE_DECL_FAN_CLOSE_NOWRITE) && HAVE_DECL_FAN_CLOSE_NOWRITE)
17 | 	XLAT(FAN_CLOSE_NOWRITE),
18 | #endif
19 | #if defined(FAN_OPEN) || (defined(HAVE_DECL_FAN_OPEN) && HAVE_DECL_FAN_OPEN)
20 | 	XLAT(FAN_OPEN),
21 | #endif
22 | #if defined(FAN_Q_OVERFLOW) || (defined(HAVE_DECL_FAN_Q_OVERFLOW) && HAVE_DECL_FAN_Q_OVERFLOW)
23 | 	XLAT(FAN_Q_OVERFLOW),
24 | #endif
25 | #if defined(FAN_OPEN_PERM) || (defined(HAVE_DECL_FAN_OPEN_PERM) && HAVE_DECL_FAN_OPEN_PERM)
26 | 	XLAT(FAN_OPEN_PERM),
27 | #endif
28 | #if defined(FAN_ACCESS_PERM) || (defined(HAVE_DECL_FAN_ACCESS_PERM) && HAVE_DECL_FAN_ACCESS_PERM)
29 | 	XLAT(FAN_ACCESS_PERM),
30 | #endif
31 | #if defined(FAN_ONDIR) || (defined(HAVE_DECL_FAN_ONDIR) && HAVE_DECL_FAN_ONDIR)
32 | 	XLAT(FAN_ONDIR),
33 | #endif
34 | #if defined(FAN_EVENT_ON_CHILD) || (defined(HAVE_DECL_FAN_EVENT_ON_CHILD) && HAVE_DECL_FAN_EVENT_ON_CHILD)
35 | 	XLAT(FAN_EVENT_ON_CHILD),
36 | #endif
37 | 	XLAT_END
38 | };
39 | 


--------------------------------------------------------------------------------
/xlat/fan_event_flags.in:
--------------------------------------------------------------------------------
 1 | FAN_ACCESS
 2 | FAN_MODIFY
 3 | FAN_CLOSE
 4 | FAN_CLOSE_WRITE
 5 | FAN_CLOSE_NOWRITE
 6 | FAN_OPEN
 7 | FAN_Q_OVERFLOW
 8 | FAN_OPEN_PERM
 9 | FAN_ACCESS_PERM
10 | FAN_ONDIR
11 | FAN_EVENT_ON_CHILD
12 | 


--------------------------------------------------------------------------------
/xlat/fan_init_flags.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/fan_init_flags.in; do not edit. */
 2 | 
 3 | static const struct xlat fan_init_flags[] = {
 4 | #if defined(FAN_CLOEXEC) || (defined(HAVE_DECL_FAN_CLOEXEC) && HAVE_DECL_FAN_CLOEXEC)
 5 | 	XLAT(FAN_CLOEXEC),
 6 | #endif
 7 | #if defined(FAN_NONBLOCK) || (defined(HAVE_DECL_FAN_NONBLOCK) && HAVE_DECL_FAN_NONBLOCK)
 8 | 	XLAT(FAN_NONBLOCK),
 9 | #endif
10 | #if defined(FAN_UNLIMITED_QUEUE) || (defined(HAVE_DECL_FAN_UNLIMITED_QUEUE) && HAVE_DECL_FAN_UNLIMITED_QUEUE)
11 | 	XLAT(FAN_UNLIMITED_QUEUE),
12 | #endif
13 | #if defined(FAN_UNLIMITED_MARKS) || (defined(HAVE_DECL_FAN_UNLIMITED_MARKS) && HAVE_DECL_FAN_UNLIMITED_MARKS)
14 | 	XLAT(FAN_UNLIMITED_MARKS),
15 | #endif
16 | 	XLAT_END
17 | };
18 | 


--------------------------------------------------------------------------------
/xlat/fan_init_flags.in:
--------------------------------------------------------------------------------
1 | FAN_CLOEXEC
2 | FAN_NONBLOCK
3 | FAN_UNLIMITED_QUEUE
4 | FAN_UNLIMITED_MARKS
5 | 


--------------------------------------------------------------------------------
/xlat/fan_mark_flags.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/fan_mark_flags.in; do not edit. */
 2 | 
 3 | static const struct xlat fan_mark_flags[] = {
 4 | #if defined(FAN_MARK_ADD) || (defined(HAVE_DECL_FAN_MARK_ADD) && HAVE_DECL_FAN_MARK_ADD)
 5 | 	XLAT(FAN_MARK_ADD),
 6 | #endif
 7 | #if defined(FAN_MARK_REMOVE) || (defined(HAVE_DECL_FAN_MARK_REMOVE) && HAVE_DECL_FAN_MARK_REMOVE)
 8 | 	XLAT(FAN_MARK_REMOVE),
 9 | #endif
10 | #if defined(FAN_MARK_DONT_FOLLOW) || (defined(HAVE_DECL_FAN_MARK_DONT_FOLLOW) && HAVE_DECL_FAN_MARK_DONT_FOLLOW)
11 | 	XLAT(FAN_MARK_DONT_FOLLOW),
12 | #endif
13 | #if defined(FAN_MARK_ONLYDIR) || (defined(HAVE_DECL_FAN_MARK_ONLYDIR) && HAVE_DECL_FAN_MARK_ONLYDIR)
14 | 	XLAT(FAN_MARK_ONLYDIR),
15 | #endif
16 | #if defined(FAN_MARK_MOUNT) || (defined(HAVE_DECL_FAN_MARK_MOUNT) && HAVE_DECL_FAN_MARK_MOUNT)
17 | 	XLAT(FAN_MARK_MOUNT),
18 | #endif
19 | #if defined(FAN_MARK_IGNORED_MASK) || (defined(HAVE_DECL_FAN_MARK_IGNORED_MASK) && HAVE_DECL_FAN_MARK_IGNORED_MASK)
20 | 	XLAT(FAN_MARK_IGNORED_MASK),
21 | #endif
22 | #if defined(FAN_MARK_IGNORED_SURV_MODIFY) || (defined(HAVE_DECL_FAN_MARK_IGNORED_SURV_MODIFY) && HAVE_DECL_FAN_MARK_IGNORED_SURV_MODIFY)
23 | 	XLAT(FAN_MARK_IGNORED_SURV_MODIFY),
24 | #endif
25 | #if defined(FAN_MARK_FLUSH) || (defined(HAVE_DECL_FAN_MARK_FLUSH) && HAVE_DECL_FAN_MARK_FLUSH)
26 | 	XLAT(FAN_MARK_FLUSH),
27 | #endif
28 | 	XLAT_END
29 | };
30 | 


--------------------------------------------------------------------------------
/xlat/fan_mark_flags.in:
--------------------------------------------------------------------------------
1 | FAN_MARK_ADD
2 | FAN_MARK_REMOVE
3 | FAN_MARK_DONT_FOLLOW
4 | FAN_MARK_ONLYDIR
5 | FAN_MARK_MOUNT
6 | FAN_MARK_IGNORED_MASK
7 | FAN_MARK_IGNORED_SURV_MODIFY
8 | FAN_MARK_FLUSH
9 | 


--------------------------------------------------------------------------------
/xlat/fcntlcmds.in:
--------------------------------------------------------------------------------
 1 | F_DUPFD
 2 | F_GETFD
 3 | F_SETFD
 4 | F_GETFL
 5 | F_SETFL
 6 | F_GETLK
 7 | F_SETLK
 8 | F_SETLKW
 9 | F_GETOWN
10 | F_SETOWN
11 | F_RSETLK
12 | F_RSETLKW
13 | F_RGETLK
14 | F_CNVT
15 | F_SETSIG
16 | F_GETSIG
17 | F_CHKFL
18 | F_DUP2FD
19 | F_ALLOCSP
20 | F_ISSTREAM
21 | F_PRIV
22 | F_NPRIV
23 | F_QUOTACL
24 | F_BLOCKS
25 | F_BLKSIZE
26 | F_GETOWN
27 | F_SETOWN
28 | F_REVOKE
29 | F_SETLK
30 | F_SETLKW
31 | F_GETLK
32 | F_SETLK64
33 | F_SETLKW64
34 | F_GETLK64
35 | F_SHARE
36 | F_UNSHARE
37 | F_SETLEASE
38 | F_GETLEASE
39 | F_NOTIFY
40 | F_DUPFD_CLOEXEC
41 | 


--------------------------------------------------------------------------------
/xlat/fdflags.h:
--------------------------------------------------------------------------------
1 | /* Generated by ./xlat/gen.sh from ./xlat/fdflags.in; do not edit. */
2 | 
3 | static const struct xlat fdflags[] = {
4 | #if defined(FD_CLOEXEC) || (defined(HAVE_DECL_FD_CLOEXEC) && HAVE_DECL_FD_CLOEXEC)
5 | 	XLAT(FD_CLOEXEC),
6 | #endif
7 | 	XLAT_END
8 | };
9 | 


--------------------------------------------------------------------------------
/xlat/fdflags.in:
--------------------------------------------------------------------------------
1 | FD_CLOEXEC
2 | 


--------------------------------------------------------------------------------
/xlat/fileflags.h:
--------------------------------------------------------------------------------
1 | /* Generated by ./xlat/gen.sh from ./xlat/fileflags.in; do not edit. */
2 | 
3 | static const struct xlat fileflags[] = {
4 | 	XLAT_END
5 | };
6 | 


--------------------------------------------------------------------------------
/xlat/fileflags.in:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/riscvarchive/riscv-strace/f320e1897832fd07a62e18ed288e75d8e79f4c5b/xlat/fileflags.in


--------------------------------------------------------------------------------
/xlat/flockcmds.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/flockcmds.in; do not edit. */
 2 | 
 3 | static const struct xlat flockcmds[] = {
 4 | #if defined(LOCK_SH) || (defined(HAVE_DECL_LOCK_SH) && HAVE_DECL_LOCK_SH)
 5 | 	XLAT(LOCK_SH),
 6 | #endif
 7 | #if defined(LOCK_EX) || (defined(HAVE_DECL_LOCK_EX) && HAVE_DECL_LOCK_EX)
 8 | 	XLAT(LOCK_EX),
 9 | #endif
10 | #if defined(LOCK_NB) || (defined(HAVE_DECL_LOCK_NB) && HAVE_DECL_LOCK_NB)
11 | 	XLAT(LOCK_NB),
12 | #endif
13 | #if defined(LOCK_UN) || (defined(HAVE_DECL_LOCK_UN) && HAVE_DECL_LOCK_UN)
14 | 	XLAT(LOCK_UN),
15 | #endif
16 | 	XLAT_END
17 | };
18 | 


--------------------------------------------------------------------------------
/xlat/flockcmds.in:
--------------------------------------------------------------------------------
1 | LOCK_SH
2 | LOCK_EX
3 | LOCK_NB
4 | LOCK_UN
5 | 


--------------------------------------------------------------------------------
/xlat/fsmagic.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/fsmagic.in; do not edit. */
 2 | 
 3 | static const struct xlat fsmagic[] = {
 4 | { 0x73757245,	"CODA_SUPER_MAGIC"	},
 5 | { 0x012ff7b7,	"COH_SUPER_MAGIC"	},
 6 | { 0x1373,	"DEVFS_SUPER_MAGIC"	},
 7 | { 0x1cd1,	"DEVPTS_SUPER_MAGIC"	},
 8 | { 0x414A53,	"EFS_SUPER_MAGIC"	},
 9 | { 0xef51,	"EXT2_OLD_SUPER_MAGIC"	},
10 | { 0xef53,	"EXT2_SUPER_MAGIC"	},
11 | { 0x137d,	"EXT_SUPER_MAGIC"	},
12 | { 0xf995e849,	"HPFS_SUPER_MAGIC"	},
13 | { 0x9660,	"ISOFS_SUPER_MAGIC"	},
14 | { 0x137f,	"MINIX_SUPER_MAGIC"	},
15 | { 0x138f,	"MINIX_SUPER_MAGIC2"	},
16 | { 0x2468,	"MINIX2_SUPER_MAGIC"	},
17 | { 0x2478,	"MINIX2_SUPER_MAGIC2"	},
18 | { 0x4d44,	"MSDOS_SUPER_MAGIC"	},
19 | { 0x564c,	"NCP_SUPER_MAGIC"	},
20 | { 0x6969,	"NFS_SUPER_MAGIC"	},
21 | { 0x9fa0,	"PROC_SUPER_MAGIC"	},
22 | { 0x002f,	"QNX4_SUPER_MAGIC"	},
23 | { 0x52654973,	"REISERFS_SUPER_MAGIC"	},
24 | { 0x02011994,	"SHMFS_SUPER_MAGIC"	},
25 | { 0x517b,	"SMB_SUPER_MAGIC"	},
26 | { 0x012ff7b6,	"SYSV2_SUPER_MAGIC"	},
27 | { 0x012ff7b5,	"SYSV4_SUPER_MAGIC"	},
28 | { 0x00011954,	"UFS_MAGIC"		},
29 | { 0x54190100,	"UFS_CIGAM"		},
30 | { 0x012ff7b4,	"XENIX_SUPER_MAGIC"	},
31 | { 0x012fd16d,	"XIAFS_SUPER_MAGIC"	},
32 | { 0x62656572,	"SYSFS_MAGIC"		},
33 | 	XLAT_END
34 | };
35 | 


--------------------------------------------------------------------------------
/xlat/fsmagic.in:
--------------------------------------------------------------------------------
 1 | 	{ 0x73757245,	"CODA_SUPER_MAGIC"	},
 2 | 	{ 0x012ff7b7,	"COH_SUPER_MAGIC"	},
 3 | 	{ 0x1373,	"DEVFS_SUPER_MAGIC"	},
 4 | 	{ 0x1cd1,	"DEVPTS_SUPER_MAGIC"	},
 5 | 	{ 0x414A53,	"EFS_SUPER_MAGIC"	},
 6 | 	{ 0xef51,	"EXT2_OLD_SUPER_MAGIC"	},
 7 | 	{ 0xef53,	"EXT2_SUPER_MAGIC"	},
 8 | 	{ 0x137d,	"EXT_SUPER_MAGIC"	},
 9 | 	{ 0xf995e849,	"HPFS_SUPER_MAGIC"	},
10 | 	{ 0x9660,	"ISOFS_SUPER_MAGIC"	},
11 | 	{ 0x137f,	"MINIX_SUPER_MAGIC"	},
12 | 	{ 0x138f,	"MINIX_SUPER_MAGIC2"	},
13 | 	{ 0x2468,	"MINIX2_SUPER_MAGIC"	},
14 | 	{ 0x2478,	"MINIX2_SUPER_MAGIC2"	},
15 | 	{ 0x4d44,	"MSDOS_SUPER_MAGIC"	},
16 | 	{ 0x564c,	"NCP_SUPER_MAGIC"	},
17 | 	{ 0x6969,	"NFS_SUPER_MAGIC"	},
18 | 	{ 0x9fa0,	"PROC_SUPER_MAGIC"	},
19 | 	{ 0x002f,	"QNX4_SUPER_MAGIC"	},
20 | 	{ 0x52654973,	"REISERFS_SUPER_MAGIC"	},
21 | 	{ 0x02011994,	"SHMFS_SUPER_MAGIC"	},
22 | 	{ 0x517b,	"SMB_SUPER_MAGIC"	},
23 | 	{ 0x012ff7b6,	"SYSV2_SUPER_MAGIC"	},
24 | 	{ 0x012ff7b5,	"SYSV4_SUPER_MAGIC"	},
25 | 	{ 0x00011954,	"UFS_MAGIC"		},
26 | 	{ 0x54190100,	"UFS_CIGAM"		},
27 | 	{ 0x012ff7b4,	"XENIX_SUPER_MAGIC"	},
28 | 	{ 0x012fd16d,	"XIAFS_SUPER_MAGIC"	},
29 | 	{ 0x62656572,	"SYSFS_MAGIC"		},
30 | 


--------------------------------------------------------------------------------
/xlat/futexops.in:
--------------------------------------------------------------------------------
 1 | FUTEX_WAIT
 2 | FUTEX_WAKE
 3 | FUTEX_FD
 4 | FUTEX_REQUEUE
 5 | FUTEX_CMP_REQUEUE
 6 | FUTEX_WAKE_OP
 7 | FUTEX_LOCK_PI
 8 | FUTEX_UNLOCK_PI
 9 | FUTEX_TRYLOCK_PI
10 | FUTEX_WAIT_BITSET
11 | FUTEX_WAKE_BITSET
12 | FUTEX_WAIT_REQUEUE_PI
13 | FUTEX_CMP_REQUEUE_PI
14 | FUTEX_WAIT_PRIVATE
15 | FUTEX_WAKE_PRIVATE
16 | FUTEX_FD|FUTEX_PRIVATE_FLAG
17 | FUTEX_REQUEUE_PRIVATE
18 | FUTEX_CMP_REQUEUE_PRIVATE
19 | FUTEX_WAKE_OP_PRIVATE
20 | FUTEX_LOCK_PI_PRIVATE
21 | FUTEX_UNLOCK_PI_PRIVATE
22 | FUTEX_TRYLOCK_PI_PRIVATE
23 | FUTEX_WAIT_BITSET_PRIVATE
24 | FUTEX_WAKE_BITSET_PRIVATE
25 | FUTEX_WAIT_REQUEUE_PI_PRIVATE
26 | FUTEX_CMP_REQUEUE_PI_PRIVATE
27 | FUTEX_WAIT_BITSET|FUTEX_CLOCK_REALTIME
28 | FUTEX_WAIT_BITSET_PRIVATE|FUTEX_CLOCK_REALTIME
29 | FUTEX_WAIT_REQUEUE_PI|FUTEX_CLOCK_REALTIME
30 | FUTEX_WAIT_REQUEUE_PI_PRIVATE|FUTEX_CLOCK_REALTIME
31 | 


--------------------------------------------------------------------------------
/xlat/futexwakecmps.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/futexwakecmps.in; do not edit. */
 2 | 
 3 | static const struct xlat futexwakecmps[] = {
 4 | #if defined(FUTEX_OP_CMP_EQ) || (defined(HAVE_DECL_FUTEX_OP_CMP_EQ) && HAVE_DECL_FUTEX_OP_CMP_EQ)
 5 | 	XLAT(FUTEX_OP_CMP_EQ),
 6 | #endif
 7 | #if defined(FUTEX_OP_CMP_NE) || (defined(HAVE_DECL_FUTEX_OP_CMP_NE) && HAVE_DECL_FUTEX_OP_CMP_NE)
 8 | 	XLAT(FUTEX_OP_CMP_NE),
 9 | #endif
10 | #if defined(FUTEX_OP_CMP_LT) || (defined(HAVE_DECL_FUTEX_OP_CMP_LT) && HAVE_DECL_FUTEX_OP_CMP_LT)
11 | 	XLAT(FUTEX_OP_CMP_LT),
12 | #endif
13 | #if defined(FUTEX_OP_CMP_LE) || (defined(HAVE_DECL_FUTEX_OP_CMP_LE) && HAVE_DECL_FUTEX_OP_CMP_LE)
14 | 	XLAT(FUTEX_OP_CMP_LE),
15 | #endif
16 | #if defined(FUTEX_OP_CMP_GT) || (defined(HAVE_DECL_FUTEX_OP_CMP_GT) && HAVE_DECL_FUTEX_OP_CMP_GT)
17 | 	XLAT(FUTEX_OP_CMP_GT),
18 | #endif
19 | #if defined(FUTEX_OP_CMP_GE) || (defined(HAVE_DECL_FUTEX_OP_CMP_GE) && HAVE_DECL_FUTEX_OP_CMP_GE)
20 | 	XLAT(FUTEX_OP_CMP_GE),
21 | #endif
22 | 	XLAT_END
23 | };
24 | 


--------------------------------------------------------------------------------
/xlat/futexwakecmps.in:
--------------------------------------------------------------------------------
1 | FUTEX_OP_CMP_EQ
2 | FUTEX_OP_CMP_NE
3 | FUTEX_OP_CMP_LT
4 | FUTEX_OP_CMP_LE
5 | FUTEX_OP_CMP_GT
6 | FUTEX_OP_CMP_GE
7 | 


--------------------------------------------------------------------------------
/xlat/futexwakeops.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/futexwakeops.in; do not edit. */
 2 | 
 3 | static const struct xlat futexwakeops[] = {
 4 | #if defined(FUTEX_OP_SET) || (defined(HAVE_DECL_FUTEX_OP_SET) && HAVE_DECL_FUTEX_OP_SET)
 5 | 	XLAT(FUTEX_OP_SET),
 6 | #endif
 7 | #if defined(FUTEX_OP_ADD) || (defined(HAVE_DECL_FUTEX_OP_ADD) && HAVE_DECL_FUTEX_OP_ADD)
 8 | 	XLAT(FUTEX_OP_ADD),
 9 | #endif
10 | #if defined(FUTEX_OP_OR) || (defined(HAVE_DECL_FUTEX_OP_OR) && HAVE_DECL_FUTEX_OP_OR)
11 | 	XLAT(FUTEX_OP_OR),
12 | #endif
13 | #if defined(FUTEX_OP_ANDN) || (defined(HAVE_DECL_FUTEX_OP_ANDN) && HAVE_DECL_FUTEX_OP_ANDN)
14 | 	XLAT(FUTEX_OP_ANDN),
15 | #endif
16 | #if defined(FUTEX_OP_XOR) || (defined(HAVE_DECL_FUTEX_OP_XOR) && HAVE_DECL_FUTEX_OP_XOR)
17 | 	XLAT(FUTEX_OP_XOR),
18 | #endif
19 | 	XLAT_END
20 | };
21 | 


--------------------------------------------------------------------------------
/xlat/futexwakeops.in:
--------------------------------------------------------------------------------
1 | FUTEX_OP_SET
2 | FUTEX_OP_ADD
3 | FUTEX_OP_OR
4 | FUTEX_OP_ANDN
5 | FUTEX_OP_XOR
6 | 


--------------------------------------------------------------------------------
/xlat/icmpfilterflags.in:
--------------------------------------------------------------------------------
 1 | 1<<ICMP_ECHOREPLY
 2 | 1<<ICMP_DEST_UNREACH
 3 | 1<<ICMP_SOURCE_QUENCH
 4 | 1<<ICMP_REDIRECT
 5 | 1<<ICMP_ECHO
 6 | 1<<ICMP_TIME_EXCEEDED
 7 | 1<<ICMP_PARAMETERPROB
 8 | 1<<ICMP_TIMESTAMP
 9 | 1<<ICMP_TIMESTAMPREPLY
10 | 1<<ICMP_INFO_REQUEST
11 | 1<<ICMP_INFO_REPLY
12 | 1<<ICMP_ADDRESS
13 | 1<<ICMP_ADDRESSREPLY
14 | 


--------------------------------------------------------------------------------
/xlat/if_dqblk_valid.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/if_dqblk_valid.in; do not edit. */
 2 | 
 3 | static const struct xlat if_dqblk_valid[] = {
 4 | #if defined(QIF_BLIMITS) || (defined(HAVE_DECL_QIF_BLIMITS) && HAVE_DECL_QIF_BLIMITS)
 5 | 	XLAT(QIF_BLIMITS),
 6 | #endif
 7 | #if defined(QIF_SPACE) || (defined(HAVE_DECL_QIF_SPACE) && HAVE_DECL_QIF_SPACE)
 8 | 	XLAT(QIF_SPACE),
 9 | #endif
10 | #if defined(QIF_ILIMITS) || (defined(HAVE_DECL_QIF_ILIMITS) && HAVE_DECL_QIF_ILIMITS)
11 | 	XLAT(QIF_ILIMITS),
12 | #endif
13 | #if defined(QIF_INODES) || (defined(HAVE_DECL_QIF_INODES) && HAVE_DECL_QIF_INODES)
14 | 	XLAT(QIF_INODES),
15 | #endif
16 | #if defined(QIF_BTIME) || (defined(HAVE_DECL_QIF_BTIME) && HAVE_DECL_QIF_BTIME)
17 | 	XLAT(QIF_BTIME),
18 | #endif
19 | #if defined(QIF_ITIME) || (defined(HAVE_DECL_QIF_ITIME) && HAVE_DECL_QIF_ITIME)
20 | 	XLAT(QIF_ITIME),
21 | #endif
22 | 	XLAT_END
23 | };
24 | 


--------------------------------------------------------------------------------
/xlat/if_dqblk_valid.in:
--------------------------------------------------------------------------------
1 | QIF_BLIMITS
2 | QIF_SPACE
3 | QIF_ILIMITS
4 | QIF_INODES
5 | QIF_BTIME
6 | QIF_ITIME
7 | 


--------------------------------------------------------------------------------
/xlat/if_dqinfo_valid.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/if_dqinfo_valid.in; do not edit. */
 2 | 
 3 | static const struct xlat if_dqinfo_valid[] = {
 4 | #if defined(IIF_BGRACE) || (defined(HAVE_DECL_IIF_BGRACE) && HAVE_DECL_IIF_BGRACE)
 5 | 	XLAT(IIF_BGRACE),
 6 | #endif
 7 | #if defined(IIF_IGRACE) || (defined(HAVE_DECL_IIF_IGRACE) && HAVE_DECL_IIF_IGRACE)
 8 | 	XLAT(IIF_IGRACE),
 9 | #endif
10 | #if defined(IIF_FLAGS) || (defined(HAVE_DECL_IIF_FLAGS) && HAVE_DECL_IIF_FLAGS)
11 | 	XLAT(IIF_FLAGS),
12 | #endif
13 | 	XLAT_END
14 | };
15 | 


--------------------------------------------------------------------------------
/xlat/if_dqinfo_valid.in:
--------------------------------------------------------------------------------
1 | IIF_BGRACE
2 | IIF_IGRACE
3 | IIF_FLAGS
4 | 


--------------------------------------------------------------------------------
/xlat/iffflags.in:
--------------------------------------------------------------------------------
 1 | IFF_UP
 2 | IFF_BROADCAST
 3 | IFF_DEBUG
 4 | IFF_LOOPBACK
 5 | IFF_POINTOPOINT
 6 | IFF_NOTRAILERS
 7 | IFF_RUNNING
 8 | IFF_NOARP
 9 | IFF_PROMISC
10 | IFF_ALLMULTI
11 | IFF_MASTER
12 | IFF_SLAVE
13 | IFF_MULTICAST
14 | IFF_PORTSEL
15 | IFF_AUTOMEDIA
16 | 


--------------------------------------------------------------------------------
/xlat/inet_protocols.in:
--------------------------------------------------------------------------------
 1 | IPPROTO_IP
 2 | IPPROTO_ICMP
 3 | IPPROTO_TCP
 4 | IPPROTO_UDP
 5 | IPPROTO_IGMP
 6 | IPPROTO_GGP
 7 | IPPROTO_IPIP
 8 | IPPROTO_EGP
 9 | IPPROTO_PUP
10 | IPPROTO_IDP
11 | IPPROTO_TP
12 | IPPROTO_DCCP
13 | IPPROTO_IPV6
14 | IPPROTO_ROUTING
15 | IPPROTO_FRAGMENT
16 | IPPROTO_RSVP
17 | IPPROTO_GRE
18 | IPPROTO_ESP
19 | IPPROTO_AH
20 | IPPROTO_ICMPV6
21 | IPPROTO_NONE
22 | IPPROTO_DSTOPTS
23 | IPPROTO_HELLO
24 | IPPROTO_ND
25 | IPPROTO_MTP
26 | IPPROTO_ENCAP
27 | IPPROTO_PIM
28 | IPPROTO_COMP
29 | IPPROTO_SCTP
30 | IPPROTO_UDPLITE
31 | IPPROTO_RAW
32 | IPPROTO_MAX
33 | 


--------------------------------------------------------------------------------
/xlat/inotify_flags.in:
--------------------------------------------------------------------------------
 1 | IN_ACCESS
 2 | IN_MODIFY
 3 | IN_ATTRIB
 4 | IN_CLOSE
 5 | IN_CLOSE_WRITE
 6 | IN_CLOSE_NOWRITE
 7 | IN_OPEN
 8 | IN_MOVE
 9 | IN_MOVED_FROM
10 | IN_MOVED_TO
11 | IN_CREATE
12 | IN_DELETE
13 | IN_DELETE_SELF
14 | IN_MOVE_SELF
15 | IN_UNMOUNT
16 | IN_Q_OVERFLOW
17 | IN_IGNORED
18 | IN_ONLYDIR
19 | IN_DONT_FOLLOW
20 | IN_EXCL_UNLINK
21 | IN_MASK_ADD
22 | IN_ISDIR
23 | IN_ONESHOT
24 | 


--------------------------------------------------------------------------------
/xlat/inotify_init_flags.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/inotify_init_flags.in; do not edit. */
 2 | 
 3 | static const struct xlat inotify_init_flags[] = {
 4 | #if defined(O_NONBLOCK) || (defined(HAVE_DECL_O_NONBLOCK) && HAVE_DECL_O_NONBLOCK)
 5 | 	XLAT(O_NONBLOCK),
 6 | #endif
 7 | #if defined(O_CLOEXEC) || (defined(HAVE_DECL_O_CLOEXEC) && HAVE_DECL_O_CLOEXEC)
 8 | 	XLAT(O_CLOEXEC),
 9 | #endif
10 | 	XLAT_END
11 | };
12 | 


--------------------------------------------------------------------------------
/xlat/inotify_init_flags.in:
--------------------------------------------------------------------------------
1 | O_NONBLOCK
2 | O_CLOEXEC
3 | 


--------------------------------------------------------------------------------
/xlat/ioprio_class.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/ioprio_class.in; do not edit. */
 2 | 
 3 | static const struct xlat ioprio_class[] = {
 4 | 	XLAT(IOPRIO_CLASS_NONE),
 5 | 	XLAT(IOPRIO_CLASS_RT),
 6 | 	XLAT(IOPRIO_CLASS_BE),
 7 | 	XLAT(IOPRIO_CLASS_IDLE),
 8 | 	XLAT_END
 9 | };
10 | 


--------------------------------------------------------------------------------
/xlat/ioprio_class.in:
--------------------------------------------------------------------------------
1 | #unconditional
2 | IOPRIO_CLASS_NONE
3 | IOPRIO_CLASS_RT
4 | IOPRIO_CLASS_BE
5 | IOPRIO_CLASS_IDLE
6 | 


--------------------------------------------------------------------------------
/xlat/ioprio_who.h:
--------------------------------------------------------------------------------
1 | /* Generated by ./xlat/gen.sh from ./xlat/ioprio_who.in; do not edit. */
2 | 
3 | static const struct xlat ioprio_who[] = {
4 | 	XLAT(IOPRIO_WHO_PROCESS),
5 | 	XLAT(IOPRIO_WHO_PGRP),
6 | 	XLAT(IOPRIO_WHO_USER),
7 | 	XLAT_END
8 | };
9 | 


--------------------------------------------------------------------------------
/xlat/ioprio_who.in:
--------------------------------------------------------------------------------
1 | #unconditional
2 | IOPRIO_WHO_PROCESS
3 | IOPRIO_WHO_PGRP
4 | IOPRIO_WHO_USER
5 | 


--------------------------------------------------------------------------------
/xlat/ipc_msg_flags.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/ipc_msg_flags.in; do not edit. */
 2 | 
 3 | static const struct xlat ipc_msg_flags[] = {
 4 | #if defined(MSG_NOERROR) || (defined(HAVE_DECL_MSG_NOERROR) && HAVE_DECL_MSG_NOERROR)
 5 | 	XLAT(MSG_NOERROR),
 6 | #endif
 7 | #if defined(MSG_EXCEPT) || (defined(HAVE_DECL_MSG_EXCEPT) && HAVE_DECL_MSG_EXCEPT)
 8 | 	XLAT(MSG_EXCEPT),
 9 | #endif
10 | #if defined(IPC_NOWAIT) || (defined(HAVE_DECL_IPC_NOWAIT) && HAVE_DECL_IPC_NOWAIT)
11 | 	XLAT(IPC_NOWAIT),
12 | #endif
13 | 	XLAT_END
14 | };
15 | 


--------------------------------------------------------------------------------
/xlat/ipc_msg_flags.in:
--------------------------------------------------------------------------------
1 | MSG_NOERROR
2 | MSG_EXCEPT
3 | IPC_NOWAIT
4 | 


--------------------------------------------------------------------------------
/xlat/itimer_which.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/itimer_which.in; do not edit. */
 2 | 
 3 | static const struct xlat itimer_which[] = {
 4 | #if defined(ITIMER_REAL) || (defined(HAVE_DECL_ITIMER_REAL) && HAVE_DECL_ITIMER_REAL)
 5 | 	XLAT(ITIMER_REAL),
 6 | #endif
 7 | #if defined(ITIMER_VIRTUAL) || (defined(HAVE_DECL_ITIMER_VIRTUAL) && HAVE_DECL_ITIMER_VIRTUAL)
 8 | 	XLAT(ITIMER_VIRTUAL),
 9 | #endif
10 | #if defined(ITIMER_PROF) || (defined(HAVE_DECL_ITIMER_PROF) && HAVE_DECL_ITIMER_PROF)
11 | 	XLAT(ITIMER_PROF),
12 | #endif
13 | 	XLAT_END
14 | };
15 | 


--------------------------------------------------------------------------------
/xlat/itimer_which.in:
--------------------------------------------------------------------------------
1 | ITIMER_REAL
2 | ITIMER_VIRTUAL
3 | ITIMER_PROF
4 | 


--------------------------------------------------------------------------------
/xlat/kexec_arch_values.in:
--------------------------------------------------------------------------------
 1 | KEXEC_ARCH_DEFAULT
 2 | KEXEC_ARCH_386
 3 | KEXEC_ARCH_X86_64
 4 | KEXEC_ARCH_PPC
 5 | KEXEC_ARCH_PPC64
 6 | KEXEC_ARCH_IA_64
 7 | KEXEC_ARCH_ARM
 8 | KEXEC_ARCH_S390
 9 | KEXEC_ARCH_SH
10 | KEXEC_ARCH_MIPS_LE
11 | KEXEC_ARCH_MIPS
12 | 


--------------------------------------------------------------------------------
/xlat/kexec_flags.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/kexec_flags.in; do not edit. */
 2 | 
 3 | static const struct xlat kexec_flags[] = {
 4 | #if defined(KEXEC_ON_CRASH) || (defined(HAVE_DECL_KEXEC_ON_CRASH) && HAVE_DECL_KEXEC_ON_CRASH)
 5 | 	XLAT(KEXEC_ON_CRASH),
 6 | #endif
 7 | #if defined(KEXEC_PRESERVE_CONTEXT) || (defined(HAVE_DECL_KEXEC_PRESERVE_CONTEXT) && HAVE_DECL_KEXEC_PRESERVE_CONTEXT)
 8 | 	XLAT(KEXEC_PRESERVE_CONTEXT),
 9 | #endif
10 | 	XLAT_END
11 | };
12 | 


--------------------------------------------------------------------------------
/xlat/kexec_flags.in:
--------------------------------------------------------------------------------
1 | KEXEC_ON_CRASH
2 | KEXEC_PRESERVE_CONTEXT
3 | 


--------------------------------------------------------------------------------
/xlat/key_perms.in:
--------------------------------------------------------------------------------
 1 | KEY_POS_VIEW
 2 | KEY_POS_READ
 3 | KEY_POS_WRITE
 4 | KEY_POS_SEARCH
 5 | KEY_POS_LINK
 6 | KEY_POS_SETATTR
 7 | KEY_POS_ALL
 8 | KEY_USR_VIEW
 9 | KEY_USR_READ
10 | KEY_USR_WRITE
11 | KEY_USR_SEARCH
12 | KEY_USR_LINK
13 | KEY_USR_SETATTR
14 | KEY_USR_ALL
15 | KEY_GRP_VIEW
16 | KEY_GRP_READ
17 | KEY_GRP_WRITE
18 | KEY_GRP_SEARCH
19 | KEY_GRP_LINK
20 | KEY_GRP_SETATTR
21 | KEY_GRP_ALL
22 | KEY_OTH_VIEW
23 | KEY_OTH_READ
24 | KEY_OTH_WRITE
25 | KEY_OTH_SEARCH
26 | KEY_OTH_LINK
27 | KEY_OTH_SETATTR
28 | KEY_OTH_ALL
29 | 


--------------------------------------------------------------------------------
/xlat/key_reqkeys.in:
--------------------------------------------------------------------------------
 1 | KEY_REQKEY_DEFL_NO_CHANGE
 2 | KEY_REQKEY_DEFL_DEFAULT
 3 | KEY_REQKEY_DEFL_THREAD_KEYRING
 4 | KEY_REQKEY_DEFL_PROCESS_KEYRING
 5 | KEY_REQKEY_DEFL_SESSION_KEYRING
 6 | KEY_REQKEY_DEFL_USER_KEYRING
 7 | KEY_REQKEY_DEFL_USER_SESSION_KEYRING
 8 | KEY_REQKEY_DEFL_GROUP_KEYRING
 9 | KEY_REQKEY_DEFL_REQUESTOR_KEYRING
10 | 


--------------------------------------------------------------------------------
/xlat/key_spec.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/key_spec.in; do not edit. */
 2 | 
 3 | static const struct xlat key_spec[] = {
 4 | #if defined(KEY_SPEC_THREAD_KEYRING) || (defined(HAVE_DECL_KEY_SPEC_THREAD_KEYRING) && HAVE_DECL_KEY_SPEC_THREAD_KEYRING)
 5 | 	XLAT(KEY_SPEC_THREAD_KEYRING),
 6 | #endif
 7 | #if defined(KEY_SPEC_PROCESS_KEYRING) || (defined(HAVE_DECL_KEY_SPEC_PROCESS_KEYRING) && HAVE_DECL_KEY_SPEC_PROCESS_KEYRING)
 8 | 	XLAT(KEY_SPEC_PROCESS_KEYRING),
 9 | #endif
10 | #if defined(KEY_SPEC_SESSION_KEYRING) || (defined(HAVE_DECL_KEY_SPEC_SESSION_KEYRING) && HAVE_DECL_KEY_SPEC_SESSION_KEYRING)
11 | 	XLAT(KEY_SPEC_SESSION_KEYRING),
12 | #endif
13 | #if defined(KEY_SPEC_USER_KEYRING) || (defined(HAVE_DECL_KEY_SPEC_USER_KEYRING) && HAVE_DECL_KEY_SPEC_USER_KEYRING)
14 | 	XLAT(KEY_SPEC_USER_KEYRING),
15 | #endif
16 | #if defined(KEY_SPEC_USER_SESSION_KEYRING) || (defined(HAVE_DECL_KEY_SPEC_USER_SESSION_KEYRING) && HAVE_DECL_KEY_SPEC_USER_SESSION_KEYRING)
17 | 	XLAT(KEY_SPEC_USER_SESSION_KEYRING),
18 | #endif
19 | #if defined(KEY_SPEC_GROUP_KEYRING) || (defined(HAVE_DECL_KEY_SPEC_GROUP_KEYRING) && HAVE_DECL_KEY_SPEC_GROUP_KEYRING)
20 | 	XLAT(KEY_SPEC_GROUP_KEYRING),
21 | #endif
22 | #if defined(KEY_SPEC_REQKEY_AUTH_KEY) || (defined(HAVE_DECL_KEY_SPEC_REQKEY_AUTH_KEY) && HAVE_DECL_KEY_SPEC_REQKEY_AUTH_KEY)
23 | 	XLAT(KEY_SPEC_REQKEY_AUTH_KEY),
24 | #endif
25 | #if defined(KEY_SPEC_REQUESTOR_KEYRING) || (defined(HAVE_DECL_KEY_SPEC_REQUESTOR_KEYRING) && HAVE_DECL_KEY_SPEC_REQUESTOR_KEYRING)
26 | 	XLAT(KEY_SPEC_REQUESTOR_KEYRING),
27 | #endif
28 | 	XLAT_END
29 | };
30 | 


--------------------------------------------------------------------------------
/xlat/key_spec.in:
--------------------------------------------------------------------------------
1 | KEY_SPEC_THREAD_KEYRING
2 | KEY_SPEC_PROCESS_KEYRING
3 | KEY_SPEC_SESSION_KEYRING
4 | KEY_SPEC_USER_KEYRING
5 | KEY_SPEC_USER_SESSION_KEYRING
6 | KEY_SPEC_GROUP_KEYRING
7 | KEY_SPEC_REQKEY_AUTH_KEY
8 | KEY_SPEC_REQUESTOR_KEYRING
9 | 


--------------------------------------------------------------------------------
/xlat/keyctl_commands.in:
--------------------------------------------------------------------------------
 1 | KEYCTL_GET_KEYRING_ID
 2 | KEYCTL_JOIN_SESSION_KEYRING
 3 | KEYCTL_UPDATE
 4 | KEYCTL_REVOKE
 5 | KEYCTL_CHOWN
 6 | KEYCTL_SETPERM
 7 | KEYCTL_DESCRIBE
 8 | KEYCTL_CLEAR
 9 | KEYCTL_LINK
10 | KEYCTL_UNLINK
11 | KEYCTL_SEARCH
12 | KEYCTL_READ
13 | KEYCTL_INSTANTIATE
14 | KEYCTL_NEGATE
15 | KEYCTL_SET_REQKEY_KEYRING
16 | KEYCTL_SET_TIMEOUT
17 | KEYCTL_ASSUME_AUTHORITY
18 | KEYCTL_GET_SECURITY
19 | KEYCTL_SESSION_TO_PARENT
20 | KEYCTL_REJECT
21 | KEYCTL_INSTANTIATE_IOV
22 | KEYCTL_INVALIDATE
23 | KEYCTL_GET_PERSISTENT
24 | 


--------------------------------------------------------------------------------
/xlat/lockfcmds.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/lockfcmds.in; do not edit. */
 2 | 
 3 | static const struct xlat lockfcmds[] = {
 4 | #if defined(F_RDLCK) || (defined(HAVE_DECL_F_RDLCK) && HAVE_DECL_F_RDLCK)
 5 | 	XLAT(F_RDLCK),
 6 | #endif
 7 | #if defined(F_WRLCK) || (defined(HAVE_DECL_F_WRLCK) && HAVE_DECL_F_WRLCK)
 8 | 	XLAT(F_WRLCK),
 9 | #endif
10 | #if defined(F_UNLCK) || (defined(HAVE_DECL_F_UNLCK) && HAVE_DECL_F_UNLCK)
11 | 	XLAT(F_UNLCK),
12 | #endif
13 | #if defined(F_EXLCK) || (defined(HAVE_DECL_F_EXLCK) && HAVE_DECL_F_EXLCK)
14 | 	XLAT(F_EXLCK),
15 | #endif
16 | #if defined(F_SHLCK) || (defined(HAVE_DECL_F_SHLCK) && HAVE_DECL_F_SHLCK)
17 | 	XLAT(F_SHLCK),
18 | #endif
19 | 	XLAT_END
20 | };
21 | 


--------------------------------------------------------------------------------
/xlat/lockfcmds.in:
--------------------------------------------------------------------------------
1 | F_RDLCK
2 | F_WRLCK
3 | F_UNLCK
4 | F_EXLCK
5 | F_SHLCK
6 | 


--------------------------------------------------------------------------------
/xlat/loop_crypt_type_options.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/loop_crypt_type_options.in; do not edit. */
 2 | 
 3 | static const struct xlat loop_crypt_type_options[] = {
 4 | #if defined(LO_CRYPT_NONE) || (defined(HAVE_DECL_LO_CRYPT_NONE) && HAVE_DECL_LO_CRYPT_NONE)
 5 | 	XLAT(LO_CRYPT_NONE),
 6 | #endif
 7 | #if defined(LO_CRYPT_XOR) || (defined(HAVE_DECL_LO_CRYPT_XOR) && HAVE_DECL_LO_CRYPT_XOR)
 8 | 	XLAT(LO_CRYPT_XOR),
 9 | #endif
10 | #if defined(LO_CRYPT_DES) || (defined(HAVE_DECL_LO_CRYPT_DES) && HAVE_DECL_LO_CRYPT_DES)
11 | 	XLAT(LO_CRYPT_DES),
12 | #endif
13 | #if defined(LO_CRYPT_FISH2) || (defined(HAVE_DECL_LO_CRYPT_FISH2) && HAVE_DECL_LO_CRYPT_FISH2)
14 | 	XLAT(LO_CRYPT_FISH2),
15 | #endif
16 | #if defined(LO_CRYPT_BLOW) || (defined(HAVE_DECL_LO_CRYPT_BLOW) && HAVE_DECL_LO_CRYPT_BLOW)
17 | 	XLAT(LO_CRYPT_BLOW),
18 | #endif
19 | #if defined(LO_CRYPT_CAST128) || (defined(HAVE_DECL_LO_CRYPT_CAST128) && HAVE_DECL_LO_CRYPT_CAST128)
20 | 	XLAT(LO_CRYPT_CAST128),
21 | #endif
22 | #if defined(LO_CRYPT_IDEA) || (defined(HAVE_DECL_LO_CRYPT_IDEA) && HAVE_DECL_LO_CRYPT_IDEA)
23 | 	XLAT(LO_CRYPT_IDEA),
24 | #endif
25 | #if defined(LO_CRYPT_DUMMY) || (defined(HAVE_DECL_LO_CRYPT_DUMMY) && HAVE_DECL_LO_CRYPT_DUMMY)
26 | 	XLAT(LO_CRYPT_DUMMY),
27 | #endif
28 | #if defined(LO_CRYPT_SKIPJACK) || (defined(HAVE_DECL_LO_CRYPT_SKIPJACK) && HAVE_DECL_LO_CRYPT_SKIPJACK)
29 | 	XLAT(LO_CRYPT_SKIPJACK),
30 | #endif
31 | #if defined(LO_CRYPT_CRYPTOAPI) || (defined(HAVE_DECL_LO_CRYPT_CRYPTOAPI) && HAVE_DECL_LO_CRYPT_CRYPTOAPI)
32 | 	XLAT(LO_CRYPT_CRYPTOAPI),
33 | #endif
34 | 	XLAT_END
35 | };
36 | 


--------------------------------------------------------------------------------
/xlat/loop_crypt_type_options.in:
--------------------------------------------------------------------------------
 1 | LO_CRYPT_NONE
 2 | LO_CRYPT_XOR
 3 | LO_CRYPT_DES
 4 | LO_CRYPT_FISH2
 5 | LO_CRYPT_BLOW
 6 | LO_CRYPT_CAST128
 7 | LO_CRYPT_IDEA
 8 | LO_CRYPT_DUMMY
 9 | LO_CRYPT_SKIPJACK
10 | LO_CRYPT_CRYPTOAPI
11 | 


--------------------------------------------------------------------------------
/xlat/loop_flags_options.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/loop_flags_options.in; do not edit. */
 2 | 
 3 | static const struct xlat loop_flags_options[] = {
 4 | #if defined(LO_FLAGS_READ_ONLY) || (defined(HAVE_DECL_LO_FLAGS_READ_ONLY) && HAVE_DECL_LO_FLAGS_READ_ONLY)
 5 | 	XLAT(LO_FLAGS_READ_ONLY),
 6 | #endif
 7 | #if defined(LO_FLAGS_AUTOCLEAR) || (defined(HAVE_DECL_LO_FLAGS_AUTOCLEAR) && HAVE_DECL_LO_FLAGS_AUTOCLEAR)
 8 | 	XLAT(LO_FLAGS_AUTOCLEAR),
 9 | #endif
10 | #if defined(LO_FLAGS_PARTSCAN) || (defined(HAVE_DECL_LO_FLAGS_PARTSCAN) && HAVE_DECL_LO_FLAGS_PARTSCAN)
11 | 	XLAT(LO_FLAGS_PARTSCAN),
12 | #endif
13 | 	XLAT_END
14 | };
15 | 


--------------------------------------------------------------------------------
/xlat/loop_flags_options.in:
--------------------------------------------------------------------------------
1 | LO_FLAGS_READ_ONLY
2 | LO_FLAGS_AUTOCLEAR
3 | LO_FLAGS_PARTSCAN
4 | 


--------------------------------------------------------------------------------
/xlat/madvise_cmds.in:
--------------------------------------------------------------------------------
 1 | MADV_NORMAL
 2 | MADV_RANDOM
 3 | MADV_SEQUENTIAL
 4 | MADV_WILLNEED
 5 | MADV_DONTNEED
 6 | MADV_REMOVE
 7 | MADV_DONTFORK
 8 | MADV_DOFORK
 9 | MADV_HWPOISON
10 | MADV_SOFT_OFFLINE
11 | MADV_MERGEABLE
12 | MADV_UNMERGEABLE
13 | MADV_HUGEPAGE
14 | MADV_NOHUGEPAGE
15 | MADV_DONTDUMP
16 | MADV_DODUMP
17 | 


--------------------------------------------------------------------------------
/xlat/mbindflags.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/mbindflags.in; do not edit. */
 2 | 
 3 | static const struct xlat mbindflags[] = {
 4 | #if defined(MPOL_MF_STRICT) || (defined(HAVE_DECL_MPOL_MF_STRICT) && HAVE_DECL_MPOL_MF_STRICT)
 5 | 	XLAT(MPOL_MF_STRICT),
 6 | #endif
 7 | #if defined(MPOL_MF_MOVE) || (defined(HAVE_DECL_MPOL_MF_MOVE) && HAVE_DECL_MPOL_MF_MOVE)
 8 | 	XLAT(MPOL_MF_MOVE),
 9 | #endif
10 | #if defined(MPOL_MF_MOVE_ALL) || (defined(HAVE_DECL_MPOL_MF_MOVE_ALL) && HAVE_DECL_MPOL_MF_MOVE_ALL)
11 | 	XLAT(MPOL_MF_MOVE_ALL),
12 | #endif
13 | 	XLAT_END
14 | };
15 | 


--------------------------------------------------------------------------------
/xlat/mbindflags.in:
--------------------------------------------------------------------------------
1 | MPOL_MF_STRICT
2 | MPOL_MF_MOVE
3 | MPOL_MF_MOVE_ALL
4 | 


--------------------------------------------------------------------------------
/xlat/mctl_funcs.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/mctl_funcs.in; do not edit. */
 2 | 
 3 | static const struct xlat mctl_funcs[] = {
 4 | #if defined(MC_LOCK) || (defined(HAVE_DECL_MC_LOCK) && HAVE_DECL_MC_LOCK)
 5 | 	XLAT(MC_LOCK),
 6 | #endif
 7 | #if defined(MC_LOCKAS) || (defined(HAVE_DECL_MC_LOCKAS) && HAVE_DECL_MC_LOCKAS)
 8 | 	XLAT(MC_LOCKAS),
 9 | #endif
10 | #if defined(MC_SYNC) || (defined(HAVE_DECL_MC_SYNC) && HAVE_DECL_MC_SYNC)
11 | 	XLAT(MC_SYNC),
12 | #endif
13 | #if defined(MC_UNLOCK) || (defined(HAVE_DECL_MC_UNLOCK) && HAVE_DECL_MC_UNLOCK)
14 | 	XLAT(MC_UNLOCK),
15 | #endif
16 | #if defined(MC_UNLOCKAS) || (defined(HAVE_DECL_MC_UNLOCKAS) && HAVE_DECL_MC_UNLOCKAS)
17 | 	XLAT(MC_UNLOCKAS),
18 | #endif
19 | 	XLAT_END
20 | };
21 | 


--------------------------------------------------------------------------------
/xlat/mctl_funcs.in:
--------------------------------------------------------------------------------
1 | MC_LOCK
2 | MC_LOCKAS
3 | MC_SYNC
4 | MC_UNLOCK
5 | MC_UNLOCKAS
6 | 


--------------------------------------------------------------------------------
/xlat/mctl_lockas.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/mctl_lockas.in; do not edit. */
 2 | 
 3 | static const struct xlat mctl_lockas[] = {
 4 | #if defined(MCL_CURRENT) || (defined(HAVE_DECL_MCL_CURRENT) && HAVE_DECL_MCL_CURRENT)
 5 | 	XLAT(MCL_CURRENT),
 6 | #endif
 7 | #if defined(MCL_FUTURE) || (defined(HAVE_DECL_MCL_FUTURE) && HAVE_DECL_MCL_FUTURE)
 8 | 	XLAT(MCL_FUTURE),
 9 | #endif
10 | 	XLAT_END
11 | };
12 | 


--------------------------------------------------------------------------------
/xlat/mctl_lockas.in:
--------------------------------------------------------------------------------
1 | MCL_CURRENT
2 | MCL_FUTURE
3 | 


--------------------------------------------------------------------------------
/xlat/mctl_sync.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/mctl_sync.in; do not edit. */
 2 | 
 3 | static const struct xlat mctl_sync[] = {
 4 | #if defined(MS_SYNC) || (defined(HAVE_DECL_MS_SYNC) && HAVE_DECL_MS_SYNC)
 5 | 	XLAT(MS_SYNC),
 6 | #endif
 7 | #if defined(MS_ASYNC) || (defined(HAVE_DECL_MS_ASYNC) && HAVE_DECL_MS_ASYNC)
 8 | 	XLAT(MS_ASYNC),
 9 | #endif
10 | #if defined(MS_INVALIDATE) || (defined(HAVE_DECL_MS_INVALIDATE) && HAVE_DECL_MS_INVALIDATE)
11 | 	XLAT(MS_INVALIDATE),
12 | #endif
13 | 	XLAT_END
14 | };
15 | 


--------------------------------------------------------------------------------
/xlat/mctl_sync.in:
--------------------------------------------------------------------------------
1 | MS_SYNC
2 | MS_ASYNC
3 | MS_INVALIDATE
4 | 


--------------------------------------------------------------------------------
/xlat/mempolicyflags.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/mempolicyflags.in; do not edit. */
 2 | 
 3 | static const struct xlat mempolicyflags[] = {
 4 | #if defined(MPOL_F_NODE) || (defined(HAVE_DECL_MPOL_F_NODE) && HAVE_DECL_MPOL_F_NODE)
 5 | 	XLAT(MPOL_F_NODE),
 6 | #endif
 7 | #if defined(MPOL_F_ADDR) || (defined(HAVE_DECL_MPOL_F_ADDR) && HAVE_DECL_MPOL_F_ADDR)
 8 | 	XLAT(MPOL_F_ADDR),
 9 | #endif
10 | 	XLAT_END
11 | };
12 | 


--------------------------------------------------------------------------------
/xlat/mempolicyflags.in:
--------------------------------------------------------------------------------
1 | MPOL_F_NODE
2 | MPOL_F_ADDR
3 | 


--------------------------------------------------------------------------------
/xlat/mlockall_flags.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/mlockall_flags.in; do not edit. */
 2 | 
 3 | static const struct xlat mlockall_flags[] = {
 4 | #if defined(MCL_CURRENT) || (defined(HAVE_DECL_MCL_CURRENT) && HAVE_DECL_MCL_CURRENT)
 5 | 	XLAT(MCL_CURRENT),
 6 | #endif
 7 | #if defined(MCL_FUTURE) || (defined(HAVE_DECL_MCL_FUTURE) && HAVE_DECL_MCL_FUTURE)
 8 | 	XLAT(MCL_FUTURE),
 9 | #endif
10 | 	XLAT_END
11 | };
12 | 


--------------------------------------------------------------------------------
/xlat/mlockall_flags.in:
--------------------------------------------------------------------------------
1 | MCL_CURRENT
2 | MCL_FUTURE
3 | 


--------------------------------------------------------------------------------
/xlat/mmap_flags.in:
--------------------------------------------------------------------------------
 1 | MAP_SHARED
 2 | MAP_PRIVATE
 3 | MAP_FIXED
 4 | MAP_ANONYMOUS
 5 | MAP_32BIT
 6 | MAP_RENAME
 7 | MAP_NORESERVE
 8 | MAP_POPULATE
 9 | MAP_NONBLOCK
10 | /*
11 |  * XXX - this was introduced in SunOS 4.x to distinguish between
12 |  * the old pre-4.x "mmap()", which:
13 |  *
14 |  *	only let you map devices with an "mmap" routine (e.g.,
15 |  *	frame buffers) in;
16 |  *
17 |  *	required you to specify the mapping address;
18 |  *
19 |  *	returned 0 on success and -1 on failure;
20 |  *
21 |  * memory and which, and the 4.x "mmap()" which:
22 |  *
23 |  *	can map plain files;
24 |  *
25 |  *	can be asked to pick where to map the file;
26 |  *
27 |  *	returns the address where it mapped the file on success
28 |  *	and -1 on failure.
29 |  *
30 |  * It's not actually used in source code that calls "mmap()"; the
31 |  * "mmap()" routine adds it for you.
32 |  *
33 |  * It'd be nice to come up with some way of eliminating it from
34 |  * the flags, e.g. reporting calls *without* it as "old_mmap()"
35 |  * and calls with it as "mmap()".
36 |  */
37 | _MAP_NEW
38 | MAP_GROWSDOWN
39 | MAP_DENYWRITE
40 | MAP_EXECUTABLE
41 | MAP_INHERIT
42 | MAP_FILE
43 | MAP_LOCKED
44 | /* FreeBSD ones */
45 | #if defined(MAP_ANON) && (!defined(MAP_ANONYMOUS) || MAP_ANON != MAP_ANONYMOUS)
46 | MAP_ANON
47 | #endif
48 | MAP_HASSEMAPHORE
49 | MAP_STACK
50 | MAP_HUGETLB
51 | #if defined MAP_UNINITIALIZED && MAP_UNINITIALIZED > 0
52 | MAP_UNINITIALIZED
53 | #endif
54 | MAP_NOSYNC
55 | MAP_NOCORE
56 | 


--------------------------------------------------------------------------------
/xlat/mmap_prot.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/mmap_prot.in; do not edit. */
 2 | 
 3 | static const struct xlat mmap_prot[] = {
 4 | #if defined(PROT_NONE) || (defined(HAVE_DECL_PROT_NONE) && HAVE_DECL_PROT_NONE)
 5 | 	XLAT(PROT_NONE),
 6 | #endif
 7 | #if defined(PROT_READ) || (defined(HAVE_DECL_PROT_READ) && HAVE_DECL_PROT_READ)
 8 | 	XLAT(PROT_READ),
 9 | #endif
10 | #if defined(PROT_WRITE) || (defined(HAVE_DECL_PROT_WRITE) && HAVE_DECL_PROT_WRITE)
11 | 	XLAT(PROT_WRITE),
12 | #endif
13 | #if defined(PROT_EXEC) || (defined(HAVE_DECL_PROT_EXEC) && HAVE_DECL_PROT_EXEC)
14 | 	XLAT(PROT_EXEC),
15 | #endif
16 | #if defined(PROT_SEM) || (defined(HAVE_DECL_PROT_SEM) && HAVE_DECL_PROT_SEM)
17 | 	XLAT(PROT_SEM),
18 | #endif
19 | #if defined(PROT_GROWSDOWN) || (defined(HAVE_DECL_PROT_GROWSDOWN) && HAVE_DECL_PROT_GROWSDOWN)
20 | 	XLAT(PROT_GROWSDOWN),
21 | #endif
22 | #if defined(PROT_GROWSUP) || (defined(HAVE_DECL_PROT_GROWSUP) && HAVE_DECL_PROT_GROWSUP)
23 | 	XLAT(PROT_GROWSUP),
24 | #endif
25 | #if defined(PROT_SAO) || (defined(HAVE_DECL_PROT_SAO) && HAVE_DECL_PROT_SAO)
26 | 	XLAT(PROT_SAO),
27 | #endif
28 | 	XLAT_END
29 | };
30 | 


--------------------------------------------------------------------------------
/xlat/mmap_prot.in:
--------------------------------------------------------------------------------
1 | PROT_NONE
2 | PROT_READ
3 | PROT_WRITE
4 | PROT_EXEC
5 | PROT_SEM
6 | PROT_GROWSDOWN
7 | PROT_GROWSUP
8 | PROT_SAO
9 | 


--------------------------------------------------------------------------------
/xlat/modem_flags.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/modem_flags.in; do not edit. */
 2 | 
 3 | static const struct xlat modem_flags[] = {
 4 | #if defined(TIOCM_LE) || (defined(HAVE_DECL_TIOCM_LE) && HAVE_DECL_TIOCM_LE)
 5 | 	XLAT(TIOCM_LE),
 6 | #endif
 7 | #if defined(TIOCM_DTR) || (defined(HAVE_DECL_TIOCM_DTR) && HAVE_DECL_TIOCM_DTR)
 8 | 	XLAT(TIOCM_DTR),
 9 | #endif
10 | #if defined(TIOCM_RTS) || (defined(HAVE_DECL_TIOCM_RTS) && HAVE_DECL_TIOCM_RTS)
11 | 	XLAT(TIOCM_RTS),
12 | #endif
13 | #if defined(TIOCM_ST) || (defined(HAVE_DECL_TIOCM_ST) && HAVE_DECL_TIOCM_ST)
14 | 	XLAT(TIOCM_ST),
15 | #endif
16 | #if defined(TIOCM_SR) || (defined(HAVE_DECL_TIOCM_SR) && HAVE_DECL_TIOCM_SR)
17 | 	XLAT(TIOCM_SR),
18 | #endif
19 | #if defined(TIOCM_CTS) || (defined(HAVE_DECL_TIOCM_CTS) && HAVE_DECL_TIOCM_CTS)
20 | 	XLAT(TIOCM_CTS),
21 | #endif
22 | #if defined(TIOCM_CAR) || (defined(HAVE_DECL_TIOCM_CAR) && HAVE_DECL_TIOCM_CAR)
23 | 	XLAT(TIOCM_CAR),
24 | #endif
25 | #if defined(TIOCM_CD) || (defined(HAVE_DECL_TIOCM_CD) && HAVE_DECL_TIOCM_CD)
26 | 	XLAT(TIOCM_CD),
27 | #endif
28 | #if defined(TIOCM_RNG) || (defined(HAVE_DECL_TIOCM_RNG) && HAVE_DECL_TIOCM_RNG)
29 | 	XLAT(TIOCM_RNG),
30 | #endif
31 | #if defined(TIOCM_RI) || (defined(HAVE_DECL_TIOCM_RI) && HAVE_DECL_TIOCM_RI)
32 | 	XLAT(TIOCM_RI),
33 | #endif
34 | #if defined(TIOCM_DSR) || (defined(HAVE_DECL_TIOCM_DSR) && HAVE_DECL_TIOCM_DSR)
35 | 	XLAT(TIOCM_DSR),
36 | #endif
37 | 	XLAT_END
38 | };
39 | 


--------------------------------------------------------------------------------
/xlat/modem_flags.in:
--------------------------------------------------------------------------------
 1 | TIOCM_LE
 2 | TIOCM_DTR
 3 | TIOCM_RTS
 4 | TIOCM_ST
 5 | TIOCM_SR
 6 | TIOCM_CTS
 7 | TIOCM_CAR
 8 | TIOCM_CD
 9 | TIOCM_RNG
10 | TIOCM_RI
11 | TIOCM_DSR
12 | 


--------------------------------------------------------------------------------
/xlat/modetypes.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/modetypes.in; do not edit. */
 2 | 
 3 | static const struct xlat modetypes[] = {
 4 | #if defined(S_IFREG) || (defined(HAVE_DECL_S_IFREG) && HAVE_DECL_S_IFREG)
 5 | 	XLAT(S_IFREG),
 6 | #endif
 7 | #if defined(S_IFSOCK) || (defined(HAVE_DECL_S_IFSOCK) && HAVE_DECL_S_IFSOCK)
 8 | 	XLAT(S_IFSOCK),
 9 | #endif
10 | #if defined(S_IFIFO) || (defined(HAVE_DECL_S_IFIFO) && HAVE_DECL_S_IFIFO)
11 | 	XLAT(S_IFIFO),
12 | #endif
13 | #if defined(S_IFLNK) || (defined(HAVE_DECL_S_IFLNK) && HAVE_DECL_S_IFLNK)
14 | 	XLAT(S_IFLNK),
15 | #endif
16 | #if defined(S_IFDIR) || (defined(HAVE_DECL_S_IFDIR) && HAVE_DECL_S_IFDIR)
17 | 	XLAT(S_IFDIR),
18 | #endif
19 | #if defined(S_IFBLK) || (defined(HAVE_DECL_S_IFBLK) && HAVE_DECL_S_IFBLK)
20 | 	XLAT(S_IFBLK),
21 | #endif
22 | #if defined(S_IFCHR) || (defined(HAVE_DECL_S_IFCHR) && HAVE_DECL_S_IFCHR)
23 | 	XLAT(S_IFCHR),
24 | #endif
25 | 	XLAT_END
26 | };
27 | 


--------------------------------------------------------------------------------
/xlat/modetypes.in:
--------------------------------------------------------------------------------
1 | S_IFREG
2 | S_IFSOCK
3 | S_IFIFO
4 | S_IFLNK
5 | S_IFDIR
6 | S_IFBLK
7 | S_IFCHR
8 | 


--------------------------------------------------------------------------------
/xlat/modflags.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/modflags.in; do not edit. */
 2 | 
 3 | static const struct xlat modflags[] = {
 4 | #if defined(MOD_UNINITIALIZED) || (defined(HAVE_DECL_MOD_UNINITIALIZED) && HAVE_DECL_MOD_UNINITIALIZED)
 5 | 	XLAT(MOD_UNINITIALIZED),
 6 | #endif
 7 | #if defined(MOD_RUNNING) || (defined(HAVE_DECL_MOD_RUNNING) && HAVE_DECL_MOD_RUNNING)
 8 | 	XLAT(MOD_RUNNING),
 9 | #endif
10 | #if defined(MOD_DELETED) || (defined(HAVE_DECL_MOD_DELETED) && HAVE_DECL_MOD_DELETED)
11 | 	XLAT(MOD_DELETED),
12 | #endif
13 | #if defined(MOD_AUTOCLEAN) || (defined(HAVE_DECL_MOD_AUTOCLEAN) && HAVE_DECL_MOD_AUTOCLEAN)
14 | 	XLAT(MOD_AUTOCLEAN),
15 | #endif
16 | #if defined(MOD_VISITED) || (defined(HAVE_DECL_MOD_VISITED) && HAVE_DECL_MOD_VISITED)
17 | 	XLAT(MOD_VISITED),
18 | #endif
19 | #if defined(MOD_USED_ONCE) || (defined(HAVE_DECL_MOD_USED_ONCE) && HAVE_DECL_MOD_USED_ONCE)
20 | 	XLAT(MOD_USED_ONCE),
21 | #endif
22 | #if defined(MOD_JUST_FREED) || (defined(HAVE_DECL_MOD_JUST_FREED) && HAVE_DECL_MOD_JUST_FREED)
23 | 	XLAT(MOD_JUST_FREED),
24 | #endif
25 | 	XLAT_END
26 | };
27 | 


--------------------------------------------------------------------------------
/xlat/modflags.in:
--------------------------------------------------------------------------------
1 | MOD_UNINITIALIZED
2 | MOD_RUNNING
3 | MOD_DELETED
4 | MOD_AUTOCLEAN
5 | MOD_VISITED
6 | MOD_USED_ONCE
7 | MOD_JUST_FREED
8 | 


--------------------------------------------------------------------------------
/xlat/module_init_flags.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/module_init_flags.in; do not edit. */
 2 | 
 3 | static const struct xlat module_init_flags[] = {
 4 | #if defined(MODULE_INIT_IGNORE_MODVERSIONS) || (defined(HAVE_DECL_MODULE_INIT_IGNORE_MODVERSIONS) && HAVE_DECL_MODULE_INIT_IGNORE_MODVERSIONS)
 5 | 	XLAT(MODULE_INIT_IGNORE_MODVERSIONS),
 6 | #endif
 7 | #if defined(MODULE_INIT_IGNORE_VERMAGIC) || (defined(HAVE_DECL_MODULE_INIT_IGNORE_VERMAGIC) && HAVE_DECL_MODULE_INIT_IGNORE_VERMAGIC)
 8 | 	XLAT(MODULE_INIT_IGNORE_VERMAGIC),
 9 | #endif
10 | 	XLAT_END
11 | };
12 | 


--------------------------------------------------------------------------------
/xlat/module_init_flags.in:
--------------------------------------------------------------------------------
1 | MODULE_INIT_IGNORE_MODVERSIONS
2 | MODULE_INIT_IGNORE_VERMAGIC
3 | 


--------------------------------------------------------------------------------
/xlat/mount_flags.in:
--------------------------------------------------------------------------------
 1 | MS_MGC_VAL
 2 | MS_RDONLY
 3 | MS_NOSUID
 4 | MS_NODEV
 5 | MS_NOEXEC
 6 | MS_SYNCHRONOUS
 7 | MS_REMOUNT
 8 | MS_RELATIME
 9 | MS_KERNMOUNT
10 | MS_I_VERSION
11 | MS_STRICTATIME
12 | MS_NOSEC
13 | MS_BORN
14 | MS_MANDLOCK
15 | MS_NOATIME
16 | MS_NODIRATIME
17 | MS_BIND
18 | MS_MOVE
19 | MS_REC
20 | MS_SILENT
21 | MS_POSIXACL
22 | MS_UNBINDABLE
23 | MS_PRIVATE
24 | MS_SLAVE
25 | MS_SHARED
26 | MS_ACTIVE
27 | MS_NOUSER
28 | 


--------------------------------------------------------------------------------
/xlat/move_pages_flags.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/move_pages_flags.in; do not edit. */
 2 | 
 3 | static const struct xlat move_pages_flags[] = {
 4 | #if defined(MPOL_MF_MOVE) || (defined(HAVE_DECL_MPOL_MF_MOVE) && HAVE_DECL_MPOL_MF_MOVE)
 5 | 	XLAT(MPOL_MF_MOVE),
 6 | #endif
 7 | #if defined(MPOL_MF_MOVE_ALL) || (defined(HAVE_DECL_MPOL_MF_MOVE_ALL) && HAVE_DECL_MPOL_MF_MOVE_ALL)
 8 | 	XLAT(MPOL_MF_MOVE_ALL),
 9 | #endif
10 | 	XLAT_END
11 | };
12 | 


--------------------------------------------------------------------------------
/xlat/move_pages_flags.in:
--------------------------------------------------------------------------------
1 | MPOL_MF_MOVE
2 | MPOL_MF_MOVE_ALL
3 | 


--------------------------------------------------------------------------------
/xlat/mremap_flags.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/mremap_flags.in; do not edit. */
 2 | 
 3 | static const struct xlat mremap_flags[] = {
 4 | #if defined(MREMAP_MAYMOVE) || (defined(HAVE_DECL_MREMAP_MAYMOVE) && HAVE_DECL_MREMAP_MAYMOVE)
 5 | 	XLAT(MREMAP_MAYMOVE),
 6 | #endif
 7 | #if defined(MREMAP_FIXED) || (defined(HAVE_DECL_MREMAP_FIXED) && HAVE_DECL_MREMAP_FIXED)
 8 | 	XLAT(MREMAP_FIXED),
 9 | #endif
10 | 	XLAT_END
11 | };
12 | 


--------------------------------------------------------------------------------
/xlat/mremap_flags.in:
--------------------------------------------------------------------------------
1 | MREMAP_MAYMOVE
2 | MREMAP_FIXED
3 | 


--------------------------------------------------------------------------------
/xlat/msg_flags.in:
--------------------------------------------------------------------------------
 1 | MSG_OOB
 2 | MSG_PEEK
 3 | MSG_DONTROUTE
 4 | MSG_CTRUNC
 5 | MSG_PROBE
 6 | MSG_TRUNC
 7 | MSG_DONTWAIT
 8 | MSG_EOR
 9 | MSG_WAITALL
10 | MSG_FIN
11 | MSG_SYN
12 | MSG_CONFIRM
13 | MSG_RST
14 | MSG_ERRQUEUE
15 | MSG_NOSIGNAL
16 | MSG_MORE
17 | MSG_WAITFORONE
18 | MSG_EOF
19 | MSG_FASTOPEN
20 | MSG_CMSG_CLOEXEC
21 | 


--------------------------------------------------------------------------------
/xlat/msgctl_flags.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/msgctl_flags.in; do not edit. */
 2 | 
 3 | static const struct xlat msgctl_flags[] = {
 4 | #if defined(IPC_RMID) || (defined(HAVE_DECL_IPC_RMID) && HAVE_DECL_IPC_RMID)
 5 | 	XLAT(IPC_RMID),
 6 | #endif
 7 | #if defined(IPC_SET) || (defined(HAVE_DECL_IPC_SET) && HAVE_DECL_IPC_SET)
 8 | 	XLAT(IPC_SET),
 9 | #endif
10 | #if defined(IPC_STAT) || (defined(HAVE_DECL_IPC_STAT) && HAVE_DECL_IPC_STAT)
11 | 	XLAT(IPC_STAT),
12 | #endif
13 | #if defined(IPC_INFO) || (defined(HAVE_DECL_IPC_INFO) && HAVE_DECL_IPC_INFO)
14 | 	XLAT(IPC_INFO),
15 | #endif
16 | #if defined(MSG_STAT) || (defined(HAVE_DECL_MSG_STAT) && HAVE_DECL_MSG_STAT)
17 | 	XLAT(MSG_STAT),
18 | #endif
19 | #if defined(MSG_INFO) || (defined(HAVE_DECL_MSG_INFO) && HAVE_DECL_MSG_INFO)
20 | 	XLAT(MSG_INFO),
21 | #endif
22 | 	XLAT_END
23 | };
24 | 


--------------------------------------------------------------------------------
/xlat/msgctl_flags.in:
--------------------------------------------------------------------------------
1 | IPC_RMID
2 | IPC_SET
3 | IPC_STAT
4 | IPC_INFO
5 | MSG_STAT
6 | MSG_INFO
7 | 


--------------------------------------------------------------------------------
/xlat/msgflags.h:
--------------------------------------------------------------------------------
1 | /* Generated by ./xlat/gen.sh from ./xlat/msgflags.in; do not edit. */
2 | 
3 | static const struct xlat msgflags[] = {
4 | #if defined(RS_HIPRI) || (defined(HAVE_DECL_RS_HIPRI) && HAVE_DECL_RS_HIPRI)
5 | 	XLAT(RS_HIPRI),
6 | #endif
7 | 	XLAT_END
8 | };
9 | 


--------------------------------------------------------------------------------
/xlat/msgflags.in:
--------------------------------------------------------------------------------
1 | RS_HIPRI
2 | 


--------------------------------------------------------------------------------
/xlat/mtd_flags_options.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/mtd_flags_options.in; do not edit. */
 2 | 
 3 | static const struct xlat mtd_flags_options[] = {
 4 | #if defined(MTD_WRITEABLE) || (defined(HAVE_DECL_MTD_WRITEABLE) && HAVE_DECL_MTD_WRITEABLE)
 5 | 	XLAT(MTD_WRITEABLE),
 6 | #endif
 7 | #if defined(MTD_BIT_WRITEABLE) || (defined(HAVE_DECL_MTD_BIT_WRITEABLE) && HAVE_DECL_MTD_BIT_WRITEABLE)
 8 | 	XLAT(MTD_BIT_WRITEABLE),
 9 | #endif
10 | #if defined(MTD_NO_ERASE) || (defined(HAVE_DECL_MTD_NO_ERASE) && HAVE_DECL_MTD_NO_ERASE)
11 | 	XLAT(MTD_NO_ERASE),
12 | #endif
13 | #if defined(MTD_POWERUP_LOCK) || (defined(HAVE_DECL_MTD_POWERUP_LOCK) && HAVE_DECL_MTD_POWERUP_LOCK)
14 | 	XLAT(MTD_POWERUP_LOCK),
15 | #endif
16 | 	XLAT_END
17 | };
18 | 


--------------------------------------------------------------------------------
/xlat/mtd_flags_options.in:
--------------------------------------------------------------------------------
1 | MTD_WRITEABLE
2 | MTD_BIT_WRITEABLE
3 | MTD_NO_ERASE
4 | MTD_POWERUP_LOCK
5 | 


--------------------------------------------------------------------------------
/xlat/mtd_mode_options.h:
--------------------------------------------------------------------------------
1 | /* Generated by ./xlat/gen.sh from ./xlat/mtd_mode_options.in; do not edit. */
2 | 
3 | static const struct xlat mtd_mode_options[] = {
4 | 	XLAT(MTD_OPS_PLACE_OOB),
5 | 	XLAT(MTD_OPS_AUTO_OOB),
6 | 	XLAT(MTD_OPS_RAW),
7 | 	XLAT_END
8 | };
9 | 


--------------------------------------------------------------------------------
/xlat/mtd_mode_options.in:
--------------------------------------------------------------------------------
1 | #unconditional
2 | MTD_OPS_PLACE_OOB
3 | MTD_OPS_AUTO_OOB
4 | MTD_OPS_RAW
5 | 


--------------------------------------------------------------------------------
/xlat/mtd_nandecc_options.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/mtd_nandecc_options.in; do not edit. */
 2 | 
 3 | static const struct xlat mtd_nandecc_options[] = {
 4 | #if defined(MTD_NANDECC_OFF) || (defined(HAVE_DECL_MTD_NANDECC_OFF) && HAVE_DECL_MTD_NANDECC_OFF)
 5 | 	XLAT(MTD_NANDECC_OFF),
 6 | #endif
 7 | #if defined(MTD_NANDECC_PLACE) || (defined(HAVE_DECL_MTD_NANDECC_PLACE) && HAVE_DECL_MTD_NANDECC_PLACE)
 8 | 	XLAT(MTD_NANDECC_PLACE),
 9 | #endif
10 | #if defined(MTD_NANDECC_AUTOPLACE) || (defined(HAVE_DECL_MTD_NANDECC_AUTOPLACE) && HAVE_DECL_MTD_NANDECC_AUTOPLACE)
11 | 	XLAT(MTD_NANDECC_AUTOPLACE),
12 | #endif
13 | #if defined(MTD_NANDECC_PLACEONLY) || (defined(HAVE_DECL_MTD_NANDECC_PLACEONLY) && HAVE_DECL_MTD_NANDECC_PLACEONLY)
14 | 	XLAT(MTD_NANDECC_PLACEONLY),
15 | #endif
16 | #if defined(MTD_NANDECC_AUTOPL_USR) || (defined(HAVE_DECL_MTD_NANDECC_AUTOPL_USR) && HAVE_DECL_MTD_NANDECC_AUTOPL_USR)
17 | 	XLAT(MTD_NANDECC_AUTOPL_USR),
18 | #endif
19 | 	XLAT_END
20 | };
21 | 


--------------------------------------------------------------------------------
/xlat/mtd_nandecc_options.in:
--------------------------------------------------------------------------------
1 | MTD_NANDECC_OFF
2 | MTD_NANDECC_PLACE
3 | MTD_NANDECC_AUTOPLACE
4 | MTD_NANDECC_PLACEONLY
5 | MTD_NANDECC_AUTOPL_USR
6 | 


--------------------------------------------------------------------------------
/xlat/mtd_otp_options.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/mtd_otp_options.in; do not edit. */
 2 | 
 3 | static const struct xlat mtd_otp_options[] = {
 4 | #if defined(MTD_OTP_OFF) || (defined(HAVE_DECL_MTD_OTP_OFF) && HAVE_DECL_MTD_OTP_OFF)
 5 | 	XLAT(MTD_OTP_OFF),
 6 | #endif
 7 | #if defined(MTD_OTP_FACTORY) || (defined(HAVE_DECL_MTD_OTP_FACTORY) && HAVE_DECL_MTD_OTP_FACTORY)
 8 | 	XLAT(MTD_OTP_FACTORY),
 9 | #endif
10 | #if defined(MTD_OTP_USER) || (defined(HAVE_DECL_MTD_OTP_USER) && HAVE_DECL_MTD_OTP_USER)
11 | 	XLAT(MTD_OTP_USER),
12 | #endif
13 | 	XLAT_END
14 | };
15 | 


--------------------------------------------------------------------------------
/xlat/mtd_otp_options.in:
--------------------------------------------------------------------------------
1 | MTD_OTP_OFF
2 | MTD_OTP_FACTORY
3 | MTD_OTP_USER
4 | 


--------------------------------------------------------------------------------
/xlat/mtd_type_options.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/mtd_type_options.in; do not edit. */
 2 | 
 3 | static const struct xlat mtd_type_options[] = {
 4 | #if defined(MTD_ABSENT) || (defined(HAVE_DECL_MTD_ABSENT) && HAVE_DECL_MTD_ABSENT)
 5 | 	XLAT(MTD_ABSENT),
 6 | #endif
 7 | #if defined(MTD_RAM) || (defined(HAVE_DECL_MTD_RAM) && HAVE_DECL_MTD_RAM)
 8 | 	XLAT(MTD_RAM),
 9 | #endif
10 | #if defined(MTD_ROM) || (defined(HAVE_DECL_MTD_ROM) && HAVE_DECL_MTD_ROM)
11 | 	XLAT(MTD_ROM),
12 | #endif
13 | #if defined(MTD_NORFLASH) || (defined(HAVE_DECL_MTD_NORFLASH) && HAVE_DECL_MTD_NORFLASH)
14 | 	XLAT(MTD_NORFLASH),
15 | #endif
16 | #if defined(MTD_NANDFLASH) || (defined(HAVE_DECL_MTD_NANDFLASH) && HAVE_DECL_MTD_NANDFLASH)
17 | 	XLAT(MTD_NANDFLASH),
18 | #endif
19 | #if defined(MTD_DATAFLASH) || (defined(HAVE_DECL_MTD_DATAFLASH) && HAVE_DECL_MTD_DATAFLASH)
20 | 	XLAT(MTD_DATAFLASH),
21 | #endif
22 | #if defined(MTD_UBIVOLUME) || (defined(HAVE_DECL_MTD_UBIVOLUME) && HAVE_DECL_MTD_UBIVOLUME)
23 | 	XLAT(MTD_UBIVOLUME),
24 | #endif
25 | #if defined(MTD_MLCNANDFLASH) || (defined(HAVE_DECL_MTD_MLCNANDFLASH) && HAVE_DECL_MTD_MLCNANDFLASH)
26 | 	XLAT(MTD_MLCNANDFLASH),
27 | #endif
28 | 	XLAT_END
29 | };
30 | 


--------------------------------------------------------------------------------
/xlat/mtd_type_options.in:
--------------------------------------------------------------------------------
1 | MTD_ABSENT
2 | MTD_RAM
3 | MTD_ROM
4 | MTD_NORFLASH
5 | MTD_NANDFLASH
6 | MTD_DATAFLASH
7 | MTD_UBIVOLUME
8 | MTD_MLCNANDFLASH
9 | 


--------------------------------------------------------------------------------
/xlat/netlink_protocols.in:
--------------------------------------------------------------------------------
 1 | NETLINK_ROUTE
 2 | NETLINK_UNUSED
 3 | NETLINK_USERSOCK
 4 | NETLINK_FIREWALL
 5 | NETLINK_SOCK_DIAG
 6 | NETLINK_NFLOG
 7 | NETLINK_XFRM
 8 | NETLINK_SELINUX
 9 | NETLINK_ISCSI
10 | NETLINK_AUDIT
11 | NETLINK_FIB_LOOKUP
12 | NETLINK_CONNECTOR
13 | NETLINK_NETFILTER
14 | NETLINK_IP6_FW
15 | NETLINK_DNRTMSG
16 | NETLINK_KOBJECT_UEVENT
17 | NETLINK_GENERIC
18 | NETLINK_SCSITRANSPORT
19 | NETLINK_ECRYPTFS
20 | NETLINK_RDMA
21 | NETLINK_CRYPTO
22 | 


--------------------------------------------------------------------------------
/xlat/notifyflags.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/notifyflags.in; do not edit. */
 2 | 
 3 | static const struct xlat notifyflags[] = {
 4 | #if defined(DN_ACCESS) || (defined(HAVE_DECL_DN_ACCESS) && HAVE_DECL_DN_ACCESS)
 5 | 	XLAT(DN_ACCESS),
 6 | #endif
 7 | #if defined(DN_MODIFY) || (defined(HAVE_DECL_DN_MODIFY) && HAVE_DECL_DN_MODIFY)
 8 | 	XLAT(DN_MODIFY),
 9 | #endif
10 | #if defined(DN_CREATE) || (defined(HAVE_DECL_DN_CREATE) && HAVE_DECL_DN_CREATE)
11 | 	XLAT(DN_CREATE),
12 | #endif
13 | #if defined(DN_DELETE) || (defined(HAVE_DECL_DN_DELETE) && HAVE_DECL_DN_DELETE)
14 | 	XLAT(DN_DELETE),
15 | #endif
16 | #if defined(DN_RENAME) || (defined(HAVE_DECL_DN_RENAME) && HAVE_DECL_DN_RENAME)
17 | 	XLAT(DN_RENAME),
18 | #endif
19 | #if defined(DN_ATTRIB) || (defined(HAVE_DECL_DN_ATTRIB) && HAVE_DECL_DN_ATTRIB)
20 | 	XLAT(DN_ATTRIB),
21 | #endif
22 | #if defined(DN_MULTISHOT) || (defined(HAVE_DECL_DN_MULTISHOT) && HAVE_DECL_DN_MULTISHOT)
23 | 	XLAT(DN_MULTISHOT),
24 | #endif
25 | 	XLAT_END
26 | };
27 | 


--------------------------------------------------------------------------------
/xlat/notifyflags.in:
--------------------------------------------------------------------------------
1 | DN_ACCESS
2 | DN_MODIFY
3 | DN_CREATE
4 | DN_DELETE
5 | DN_RENAME
6 | DN_ATTRIB
7 | DN_MULTISHOT
8 | 


--------------------------------------------------------------------------------
/xlat/nt_descriptor_types.in:
--------------------------------------------------------------------------------
 1 | NT_PRSTATUS
 2 | NT_FPREGSET
 3 | NT_PRPSINFO
 4 | NT_PRXREG
 5 | NT_TASKSTRUCT
 6 | NT_PLATFORM
 7 | NT_AUXV
 8 | NT_GWINDOWS
 9 | NT_ASRS
10 | NT_PSTATUS
11 | NT_PSINFO
12 | NT_PRCRED
13 | NT_UTSNAME
14 | NT_LWPSTATUS
15 | NT_LWPSINFO
16 | NT_PRFPXREG
17 | NT_PRXFPREG
18 | NT_PPC_VMX
19 | NT_PPC_SPE
20 | NT_PPC_VSX
21 | NT_386_TLS
22 | NT_386_IOPERM
23 | NT_X86_XSTATE
24 | 


--------------------------------------------------------------------------------
/xlat/open_access_modes.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/open_access_modes.in; do not edit. */
 2 | 
 3 | const struct xlat open_access_modes[] = {
 4 | #if defined(O_RDONLY) || (defined(HAVE_DECL_O_RDONLY) && HAVE_DECL_O_RDONLY)
 5 | 	XLAT(O_RDONLY),
 6 | #endif
 7 | #if defined(O_WRONLY) || (defined(HAVE_DECL_O_WRONLY) && HAVE_DECL_O_WRONLY)
 8 | 	XLAT(O_WRONLY),
 9 | #endif
10 | #if defined(O_RDWR) || (defined(HAVE_DECL_O_RDWR) && HAVE_DECL_O_RDWR)
11 | 	XLAT(O_RDWR),
12 | #endif
13 | #if defined(O_ACCMODE) || (defined(HAVE_DECL_O_ACCMODE) && HAVE_DECL_O_ACCMODE)
14 | 	XLAT(O_ACCMODE),
15 | #endif
16 | 	XLAT_END
17 | };
18 | 


--------------------------------------------------------------------------------
/xlat/open_access_modes.in:
--------------------------------------------------------------------------------
1 | O_RDONLY
2 | O_WRONLY
3 | O_RDWR
4 | O_ACCMODE
5 | 


--------------------------------------------------------------------------------
/xlat/open_mode_flags.in:
--------------------------------------------------------------------------------
 1 | O_CREAT
 2 | O_EXCL
 3 | O_NOCTTY
 4 | O_TRUNC
 5 | O_APPEND
 6 | O_NONBLOCK
 7 | O_SYNC
 8 | O_ASYNC
 9 | O_DSYNC
10 | O_RSYNC
11 | #if defined(O_NDELAY) && (O_NDELAY != O_NONBLOCK)
12 | O_NDELAY
13 | #endif
14 | O_PRIV
15 | O_DIRECT
16 | O_LARGEFILE
17 | O_DIRECTORY
18 | O_NOFOLLOW
19 | O_NOATIME
20 | O_CLOEXEC
21 | O_PATH
22 | FNDELAY
23 | FAPPEND
24 | FMARK
25 | FDEFER
26 | FASYNC
27 | FSHLOCK
28 | FEXLOCK
29 | FCREAT
30 | FTRUNC
31 | FEXCL
32 | FNBIO
33 | FSYNC
34 | FNOCTTY
35 | O_SHLOCK
36 | O_EXLOCK
37 | 


--------------------------------------------------------------------------------
/xlat/openmodessol.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/openmodessol.in; do not edit. */
 2 | 
 3 | static const struct xlat openmodessol[] = {
 4 | { 0,		"O_RDWR"	},
 5 | { 1,		"O_RDONLY"	},
 6 | { 2,		"O_WRONLY"	},
 7 | { 0x80,		"O_NONBLOCK"	},
 8 | { 8,		"O_APPEND"	},
 9 | { 0x100,	"O_CREAT"	},
10 | { 0x200,	"O_TRUNC"	},
11 | { 0x400,	"O_EXCL"	},
12 | { 0x800,	"O_NOCTTY"	},
13 | { 0x10,		"O_SYNC"	},
14 | { 0x40,		"O_DSYNC"	},
15 | { 0x8000,	"O_RSYNC"	},
16 | { 4,		"O_NDELAY"	},
17 | { 0x1000,	"O_PRIV"	},
18 | 	XLAT_END
19 | };
20 | 


--------------------------------------------------------------------------------
/xlat/openmodessol.in:
--------------------------------------------------------------------------------
 1 | 	{ 0,		"O_RDWR"	},
 2 | 	{ 1,		"O_RDONLY"	},
 3 | 	{ 2,		"O_WRONLY"	},
 4 | 	{ 0x80,		"O_NONBLOCK"	},
 5 | 	{ 8,		"O_APPEND"	},
 6 | 	{ 0x100,	"O_CREAT"	},
 7 | 	{ 0x200,	"O_TRUNC"	},
 8 | 	{ 0x400,	"O_EXCL"	},
 9 | 	{ 0x800,	"O_NOCTTY"	},
10 | 	{ 0x10,		"O_SYNC"	},
11 | 	{ 0x40,		"O_DSYNC"	},
12 | 	{ 0x8000,	"O_RSYNC"	},
13 | 	{ 4,		"O_NDELAY"	},
14 | 	{ 0x1000,	"O_PRIV"	},
15 | 


--------------------------------------------------------------------------------
/xlat/perf_event_open_flags.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/perf_event_open_flags.in; do not edit. */
 2 | 
 3 | static const struct xlat perf_event_open_flags[] = {
 4 | #if defined(PERF_FLAG_FD_NO_GROUP) || (defined(HAVE_DECL_PERF_FLAG_FD_NO_GROUP) && HAVE_DECL_PERF_FLAG_FD_NO_GROUP)
 5 | 	XLAT(PERF_FLAG_FD_NO_GROUP),
 6 | #endif
 7 | #if defined(PERF_FLAG_FD_OUTPUT) || (defined(HAVE_DECL_PERF_FLAG_FD_OUTPUT) && HAVE_DECL_PERF_FLAG_FD_OUTPUT)
 8 | 	XLAT(PERF_FLAG_FD_OUTPUT),
 9 | #endif
10 | #if defined(PERF_FLAG_PID_CGROUP) || (defined(HAVE_DECL_PERF_FLAG_PID_CGROUP) && HAVE_DECL_PERF_FLAG_PID_CGROUP)
11 | 	XLAT(PERF_FLAG_PID_CGROUP),
12 | #endif
13 | 	XLAT_END
14 | };
15 | 


--------------------------------------------------------------------------------
/xlat/perf_event_open_flags.in:
--------------------------------------------------------------------------------
1 | PERF_FLAG_FD_NO_GROUP
2 | PERF_FLAG_FD_OUTPUT
3 | PERF_FLAG_PID_CGROUP
4 | 


--------------------------------------------------------------------------------
/xlat/personality_options.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/personality_options.in; do not edit. */
 2 | 
 3 | static const struct xlat personality_options[] = {
 4 | 	XLAT(PER_LINUX),
 5 | 	XLAT(PER_LINUX_32BIT),
 6 | 	XLAT(PER_LINUX_FDPIC),
 7 | 	XLAT(PER_SVR4),
 8 | 	XLAT(PER_SVR3),
 9 | 	XLAT(PER_SCOSVR3),
10 | 	XLAT(PER_OSR5),
11 | 	XLAT(PER_WYSEV386),
12 | 	XLAT(PER_ISCR4),
13 | 	XLAT(PER_BSD),
14 | 	XLAT(PER_SUNOS),
15 | 	XLAT(PER_XENIX),
16 | 	XLAT(PER_LINUX32),
17 | 	XLAT(PER_LINUX32_3GB),
18 | 	XLAT(PER_IRIX32),
19 | 	XLAT(PER_IRIXN32),
20 | 	XLAT(PER_IRIX64),
21 | 	XLAT(PER_RISCOS),
22 | 	XLAT(PER_SOLARIS),
23 | 	XLAT(PER_UW7),
24 | 	XLAT(PER_OSF4),
25 | 	XLAT(PER_HPUX),
26 | 	XLAT_END
27 | };
28 | 


--------------------------------------------------------------------------------
/xlat/personality_options.in:
--------------------------------------------------------------------------------
 1 | #unconditional
 2 | PER_LINUX
 3 | PER_LINUX_32BIT
 4 | PER_LINUX_FDPIC
 5 | PER_SVR4
 6 | PER_SVR3
 7 | PER_SCOSVR3
 8 | PER_OSR5
 9 | PER_WYSEV386
10 | PER_ISCR4
11 | PER_BSD
12 | PER_SUNOS
13 | PER_XENIX
14 | PER_LINUX32
15 | PER_LINUX32_3GB
16 | PER_IRIX32
17 | PER_IRIXN32
18 | PER_IRIX64
19 | PER_RISCOS
20 | PER_SOLARIS
21 | PER_UW7
22 | PER_OSF4
23 | PER_HPUX
24 | 


--------------------------------------------------------------------------------
/xlat/pmsgflags.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/pmsgflags.in; do not edit. */
 2 | 
 3 | static const struct xlat pmsgflags[] = {
 4 | #if defined(MSG_HIPRI) || (defined(HAVE_DECL_MSG_HIPRI) && HAVE_DECL_MSG_HIPRI)
 5 | 	XLAT(MSG_HIPRI),
 6 | #endif
 7 | #if defined(MSG_ANY) || (defined(HAVE_DECL_MSG_ANY) && HAVE_DECL_MSG_ANY)
 8 | 	XLAT(MSG_ANY),
 9 | #endif
10 | #if defined(MSG_BAND) || (defined(HAVE_DECL_MSG_BAND) && HAVE_DECL_MSG_BAND)
11 | 	XLAT(MSG_BAND),
12 | #endif
13 | 	XLAT_END
14 | };
15 | 


--------------------------------------------------------------------------------
/xlat/pmsgflags.in:
--------------------------------------------------------------------------------
1 | MSG_HIPRI
2 | MSG_ANY
3 | MSG_BAND
4 | 


--------------------------------------------------------------------------------
/xlat/policies.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/policies.in; do not edit. */
 2 | 
 3 | static const struct xlat policies[] = {
 4 | #if defined(MPOL_DEFAULT) || (defined(HAVE_DECL_MPOL_DEFAULT) && HAVE_DECL_MPOL_DEFAULT)
 5 | 	XLAT(MPOL_DEFAULT),
 6 | #endif
 7 | #if defined(MPOL_PREFERRED) || (defined(HAVE_DECL_MPOL_PREFERRED) && HAVE_DECL_MPOL_PREFERRED)
 8 | 	XLAT(MPOL_PREFERRED),
 9 | #endif
10 | #if defined(MPOL_BIND) || (defined(HAVE_DECL_MPOL_BIND) && HAVE_DECL_MPOL_BIND)
11 | 	XLAT(MPOL_BIND),
12 | #endif
13 | #if defined(MPOL_INTERLEAVE) || (defined(HAVE_DECL_MPOL_INTERLEAVE) && HAVE_DECL_MPOL_INTERLEAVE)
14 | 	XLAT(MPOL_INTERLEAVE),
15 | #endif
16 | 	XLAT_END
17 | };
18 | 


--------------------------------------------------------------------------------
/xlat/policies.in:
--------------------------------------------------------------------------------
1 | MPOL_DEFAULT
2 | MPOL_PREFERRED
3 | MPOL_BIND
4 | MPOL_INTERLEAVE
5 | 


--------------------------------------------------------------------------------
/xlat/pollflags.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/pollflags.in; do not edit. */
 2 | 
 3 | static const struct xlat pollflags[] = {
 4 | #if defined(POLLIN) || (defined(HAVE_DECL_POLLIN) && HAVE_DECL_POLLIN)
 5 | 	XLAT(POLLIN),
 6 | #endif
 7 | #if defined(POLLPRI) || (defined(HAVE_DECL_POLLPRI) && HAVE_DECL_POLLPRI)
 8 | 	XLAT(POLLPRI),
 9 | #endif
10 | #if defined(POLLOUT) || (defined(HAVE_DECL_POLLOUT) && HAVE_DECL_POLLOUT)
11 | 	XLAT(POLLOUT),
12 | #endif
13 | #if defined(POLLRDNORM) || (defined(HAVE_DECL_POLLRDNORM) && HAVE_DECL_POLLRDNORM)
14 | 	XLAT(POLLRDNORM),
15 | #endif
16 | #if defined(POLLWRNORM) || (defined(HAVE_DECL_POLLWRNORM) && HAVE_DECL_POLLWRNORM)
17 | 	XLAT(POLLWRNORM),
18 | #endif
19 | #if defined(POLLRDBAND) || (defined(HAVE_DECL_POLLRDBAND) && HAVE_DECL_POLLRDBAND)
20 | 	XLAT(POLLRDBAND),
21 | #endif
22 | #if defined(POLLWRBAND) || (defined(HAVE_DECL_POLLWRBAND) && HAVE_DECL_POLLWRBAND)
23 | 	XLAT(POLLWRBAND),
24 | #endif
25 | #if defined(POLLERR) || (defined(HAVE_DECL_POLLERR) && HAVE_DECL_POLLERR)
26 | 	XLAT(POLLERR),
27 | #endif
28 | #if defined(POLLHUP) || (defined(HAVE_DECL_POLLHUP) && HAVE_DECL_POLLHUP)
29 | 	XLAT(POLLHUP),
30 | #endif
31 | #if defined(POLLNVAL) || (defined(HAVE_DECL_POLLNVAL) && HAVE_DECL_POLLNVAL)
32 | 	XLAT(POLLNVAL),
33 | #endif
34 | 	XLAT_END
35 | };
36 | 


--------------------------------------------------------------------------------
/xlat/pollflags.in:
--------------------------------------------------------------------------------
 1 | POLLIN
 2 | POLLPRI
 3 | POLLOUT
 4 | POLLRDNORM
 5 | POLLWRNORM
 6 | POLLRDBAND
 7 | POLLWRBAND
 8 | POLLERR
 9 | POLLHUP
10 | POLLNVAL
11 | 


--------------------------------------------------------------------------------
/xlat/prctl_options.in:
--------------------------------------------------------------------------------
 1 | PR_MAXPROCS
 2 | PR_ISBLOCKED
 3 | PR_SETSTACKSIZE
 4 | PR_GETSTACKSIZE
 5 | PR_MAXPPROCS
 6 | PR_UNBLKONEXEC
 7 | PR_ATOMICSIM
 8 | PR_SETEXITSIG
 9 | PR_RESIDENT
10 | PR_ATTACHADDR
11 | PR_DETACHADDR
12 | PR_TERMCHILD
13 | PR_GETSHMASK
14 | PR_GETNSHARE
15 | PR_COREPID
16 | PR_ATTACHADDRPERM
17 | PR_PTHREADEXIT
18 | PR_SET_PDEATHSIG
19 | PR_GET_PDEATHSIG
20 | PR_GET_DUMPABLE
21 | PR_SET_DUMPABLE
22 | PR_GET_UNALIGN
23 | PR_SET_UNALIGN
24 | PR_GET_KEEPCAPS
25 | PR_SET_KEEPCAPS
26 | PR_GET_FPEMU
27 | PR_SET_FPEMU
28 | PR_GET_FPEXC
29 | PR_SET_FPEXC
30 | PR_GET_TIMING
31 | PR_SET_TIMING
32 | PR_SET_NAME
33 | PR_GET_NAME
34 | PR_GET_ENDIAN
35 | PR_SET_ENDIAN
36 | PR_GET_SECCOMP
37 | PR_SET_SECCOMP
38 | PR_CAPBSET_READ
39 | PR_CAPBSET_DROP
40 | PR_GET_TSC
41 | PR_SET_TSC
42 | PR_GET_SECUREBITS
43 | PR_SET_SECUREBITS
44 | PR_SET_TIMERSLACK
45 | PR_GET_TIMERSLACK
46 | PR_TASK_PERF_EVENTS_DISABLE
47 | PR_TASK_PERF_EVENTS_ENABLE
48 | PR_MCE_KILL
49 | PR_MCE_KILL_GET
50 | PR_SET_MM
51 | PR_SET_PTRACER
52 | PR_SET_CHILD_SUBREAPER
53 | PR_GET_CHILD_SUBREAPER
54 | PR_SET_NO_NEW_PRIVS
55 | PR_GET_NO_NEW_PRIVS
56 | PR_GET_TID_ADDRESS
57 | 


--------------------------------------------------------------------------------
/xlat/priorities.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/priorities.in; do not edit. */
 2 | 
 3 | static const struct xlat priorities[] = {
 4 | #if defined(PRIO_PROCESS) || (defined(HAVE_DECL_PRIO_PROCESS) && HAVE_DECL_PRIO_PROCESS)
 5 | 	XLAT(PRIO_PROCESS),
 6 | #endif
 7 | #if defined(PRIO_PGRP) || (defined(HAVE_DECL_PRIO_PGRP) && HAVE_DECL_PRIO_PGRP)
 8 | 	XLAT(PRIO_PGRP),
 9 | #endif
10 | #if defined(PRIO_USER) || (defined(HAVE_DECL_PRIO_USER) && HAVE_DECL_PRIO_USER)
11 | 	XLAT(PRIO_USER),
12 | #endif
13 | 	XLAT_END
14 | };
15 | 


--------------------------------------------------------------------------------
/xlat/priorities.in:
--------------------------------------------------------------------------------
1 | PRIO_PROCESS
2 | PRIO_PGRP
3 | PRIO_USER
4 | 


--------------------------------------------------------------------------------
/xlat/ptp_flags_options.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/ptp_flags_options.in; do not edit. */
 2 | 
 3 | static const struct xlat ptp_flags_options[] = {
 4 | #if defined(PTP_ENABLE_FEATURE) || (defined(HAVE_DECL_PTP_ENABLE_FEATURE) && HAVE_DECL_PTP_ENABLE_FEATURE)
 5 | 	XLAT(PTP_ENABLE_FEATURE),
 6 | #endif
 7 | #if defined(PTP_RISING_EDGE) || (defined(HAVE_DECL_PTP_RISING_EDGE) && HAVE_DECL_PTP_RISING_EDGE)
 8 | 	XLAT(PTP_RISING_EDGE),
 9 | #endif
10 | #if defined(PTP_FALLING_EDGE) || (defined(HAVE_DECL_PTP_FALLING_EDGE) && HAVE_DECL_PTP_FALLING_EDGE)
11 | 	XLAT(PTP_FALLING_EDGE),
12 | #endif
13 | 	XLAT_END
14 | };
15 | 


--------------------------------------------------------------------------------
/xlat/ptp_flags_options.in:
--------------------------------------------------------------------------------
1 | PTP_ENABLE_FEATURE
2 | PTP_RISING_EDGE
3 | PTP_FALLING_EDGE
4 | 


--------------------------------------------------------------------------------
/xlat/ptrace_cmds.in:
--------------------------------------------------------------------------------
 1 | PTRACE_TRACEME
 2 | PTRACE_PEEKTEXT
 3 | PTRACE_PEEKDATA
 4 | PTRACE_PEEKUSER
 5 | PTRACE_POKETEXT
 6 | PTRACE_POKEDATA
 7 | PTRACE_POKEUSER
 8 | PTRACE_CONT
 9 | PTRACE_KILL
10 | PTRACE_SINGLESTEP
11 | PTRACE_ATTACH
12 | PTRACE_DETACH
13 | PTRACE_GETREGS
14 | PTRACE_SETREGS
15 | PTRACE_GETFPREGS
16 | PTRACE_SETFPREGS
17 | PTRACE_GETFPXREGS
18 | PTRACE_SETFPXREGS
19 | PTRACE_GETVRREGS
20 | PTRACE_SETVRREGS
21 | PTRACE_SETOPTIONS
22 | PTRACE_GETEVENTMSG
23 | PTRACE_GETSIGINFO
24 | PTRACE_SETSIGINFO
25 | PTRACE_GETREGSET
26 | PTRACE_SETREGSET
27 | PTRACE_SET_SYSCALL
28 | PTRACE_SEIZE
29 | PTRACE_INTERRUPT
30 | PTRACE_LISTEN
31 | PTRACE_SYSCALL
32 | 


--------------------------------------------------------------------------------
/xlat/ptrace_setoptions_flags.in:
--------------------------------------------------------------------------------
 1 | PTRACE_O_TRACESYSGOOD
 2 | PTRACE_O_TRACEFORK
 3 | PTRACE_O_TRACEVFORK
 4 | PTRACE_O_TRACECLONE
 5 | PTRACE_O_TRACEEXEC
 6 | PTRACE_O_TRACEVFORKDONE
 7 | PTRACE_O_TRACEEXIT
 8 | PTRACE_O_TRACESECCOMP
 9 | PTRACE_O_EXITKILL
10 | 


--------------------------------------------------------------------------------
/xlat/qm_which.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/qm_which.in; do not edit. */
 2 | 
 3 | static const struct xlat qm_which[] = {
 4 | 	XLAT(0),
 5 | #if defined(QM_MODULES) || (defined(HAVE_DECL_QM_MODULES) && HAVE_DECL_QM_MODULES)
 6 | 	XLAT(QM_MODULES),
 7 | #endif
 8 | #if defined(QM_DEPS) || (defined(HAVE_DECL_QM_DEPS) && HAVE_DECL_QM_DEPS)
 9 | 	XLAT(QM_DEPS),
10 | #endif
11 | #if defined(QM_REFS) || (defined(HAVE_DECL_QM_REFS) && HAVE_DECL_QM_REFS)
12 | 	XLAT(QM_REFS),
13 | #endif
14 | #if defined(QM_SYMBOLS) || (defined(HAVE_DECL_QM_SYMBOLS) && HAVE_DECL_QM_SYMBOLS)
15 | 	XLAT(QM_SYMBOLS),
16 | #endif
17 | #if defined(QM_INFO) || (defined(HAVE_DECL_QM_INFO) && HAVE_DECL_QM_INFO)
18 | 	XLAT(QM_INFO),
19 | #endif
20 | 	XLAT_END
21 | };
22 | 


--------------------------------------------------------------------------------
/xlat/qm_which.in:
--------------------------------------------------------------------------------
1 | 0
2 | QM_MODULES
3 | QM_DEPS
4 | QM_REFS
5 | QM_SYMBOLS
6 | QM_INFO
7 | 


--------------------------------------------------------------------------------
/xlat/quota_formats.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/quota_formats.in; do not edit. */
 2 | 
 3 | static const struct xlat quota_formats[] = {
 4 | #if defined(QFMT_VFS_OLD) || (defined(HAVE_DECL_QFMT_VFS_OLD) && HAVE_DECL_QFMT_VFS_OLD)
 5 | 	XLAT(QFMT_VFS_OLD),
 6 | #endif
 7 | #if defined(QFMT_VFS_V0) || (defined(HAVE_DECL_QFMT_VFS_V0) && HAVE_DECL_QFMT_VFS_V0)
 8 | 	XLAT(QFMT_VFS_V0),
 9 | #endif
10 | 	XLAT_END
11 | };
12 | 


--------------------------------------------------------------------------------
/xlat/quota_formats.in:
--------------------------------------------------------------------------------
1 | QFMT_VFS_OLD
2 | QFMT_VFS_V0
3 | 


--------------------------------------------------------------------------------
/xlat/quotacmds.in:
--------------------------------------------------------------------------------
 1 | Q_V1_QUOTAON
 2 | Q_V1_QUOTAOFF
 3 | Q_V1_GETQUOTA
 4 | Q_V1_SETQUOTA
 5 | Q_V1_SETUSE
 6 | Q_V1_SYNC
 7 | Q_SETQLIM
 8 | Q_V1_GETSTATS
 9 | Q_V1_RSQUASH
10 | Q_V2_GETQUOTA
11 | Q_V2_SETQUOTA
12 | Q_V2_SETUSE
13 | Q_V2_GETINFO
14 | Q_V2_SETINFO
15 | Q_V2_SETGRACE
16 | Q_V2_SETFLAGS
17 | Q_V2_GETSTATS
18 | Q_SYNC
19 | Q_QUOTAON
20 | Q_QUOTAOFF
21 | Q_GETFMT
22 | Q_GETINFO
23 | Q_SETINFO
24 | Q_GETQUOTA
25 | Q_SETQUOTA
26 | Q_XQUOTAON
27 | Q_XQUOTAOFF
28 | Q_XGETQUOTA
29 | Q_XSETQLIM
30 | Q_XGETQSTAT
31 | Q_XQUOTARM
32 | Q_XQUOTASYNC
33 | 


--------------------------------------------------------------------------------
/xlat/quotatypes.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/quotatypes.in; do not edit. */
 2 | 
 3 | static const struct xlat quotatypes[] = {
 4 | #if defined(USRQUOTA) || (defined(HAVE_DECL_USRQUOTA) && HAVE_DECL_USRQUOTA)
 5 | 	XLAT(USRQUOTA),
 6 | #endif
 7 | #if defined(GRPQUOTA) || (defined(HAVE_DECL_GRPQUOTA) && HAVE_DECL_GRPQUOTA)
 8 | 	XLAT(GRPQUOTA),
 9 | #endif
10 | 	XLAT_END
11 | };
12 | 


--------------------------------------------------------------------------------
/xlat/quotatypes.in:
--------------------------------------------------------------------------------
1 | USRQUOTA
2 | GRPQUOTA
3 | 


--------------------------------------------------------------------------------
/xlat/rename_flags.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/rename_flags.in; do not edit. */
 2 | 
 3 | static const struct xlat rename_flags[] = {
 4 | #if defined(RENAME_NOREPLACE) || (defined(HAVE_DECL_RENAME_NOREPLACE) && HAVE_DECL_RENAME_NOREPLACE)
 5 | 	XLAT(RENAME_NOREPLACE),
 6 | #endif
 7 | #if defined(RENAME_EXCHANGE) || (defined(HAVE_DECL_RENAME_EXCHANGE) && HAVE_DECL_RENAME_EXCHANGE)
 8 | 	XLAT(RENAME_EXCHANGE),
 9 | #endif
10 | 	XLAT_END
11 | };
12 | 


--------------------------------------------------------------------------------
/xlat/rename_flags.in:
--------------------------------------------------------------------------------
1 | RENAME_NOREPLACE
2 | RENAME_EXCHANGE
3 | 


--------------------------------------------------------------------------------
/xlat/resource_flags.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/resource_flags.in; do not edit. */
 2 | 
 3 | static const struct xlat resource_flags[] = {
 4 | #if defined(IPC_CREAT) || (defined(HAVE_DECL_IPC_CREAT) && HAVE_DECL_IPC_CREAT)
 5 | 	XLAT(IPC_CREAT),
 6 | #endif
 7 | #if defined(IPC_EXCL) || (defined(HAVE_DECL_IPC_EXCL) && HAVE_DECL_IPC_EXCL)
 8 | 	XLAT(IPC_EXCL),
 9 | #endif
10 | #if defined(IPC_NOWAIT) || (defined(HAVE_DECL_IPC_NOWAIT) && HAVE_DECL_IPC_NOWAIT)
11 | 	XLAT(IPC_NOWAIT),
12 | #endif
13 | 	XLAT_END
14 | };
15 | 


--------------------------------------------------------------------------------
/xlat/resource_flags.in:
--------------------------------------------------------------------------------
1 | IPC_CREAT
2 | IPC_EXCL
3 | IPC_NOWAIT
4 | 


--------------------------------------------------------------------------------
/xlat/resources.in:
--------------------------------------------------------------------------------
 1 | RLIMIT_AS
 2 | RLIMIT_CORE
 3 | RLIMIT_CPU
 4 | RLIMIT_DATA
 5 | RLIMIT_FSIZE
 6 | RLIMIT_LOCKS
 7 | RLIMIT_MEMLOCK
 8 | RLIMIT_MSGQUEUE
 9 | RLIMIT_NICE
10 | RLIMIT_NOFILE
11 | RLIMIT_NPROC
12 | RLIMIT_RSS
13 | RLIMIT_RTPRIO
14 | RLIMIT_RTTIME
15 | RLIMIT_SIGPENDING
16 | RLIMIT_STACK
17 | RLIMIT_VMEM
18 | 


--------------------------------------------------------------------------------
/xlat/schedulers.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/schedulers.in; do not edit. */
 2 | 
 3 | static const struct xlat schedulers[] = {
 4 | #if defined(SCHED_OTHER) || (defined(HAVE_DECL_SCHED_OTHER) && HAVE_DECL_SCHED_OTHER)
 5 | 	XLAT(SCHED_OTHER),
 6 | #endif
 7 | #if defined(SCHED_RR) || (defined(HAVE_DECL_SCHED_RR) && HAVE_DECL_SCHED_RR)
 8 | 	XLAT(SCHED_RR),
 9 | #endif
10 | #if defined(SCHED_FIFO) || (defined(HAVE_DECL_SCHED_FIFO) && HAVE_DECL_SCHED_FIFO)
11 | 	XLAT(SCHED_FIFO),
12 | #endif
13 | 	XLAT_END
14 | };
15 | 


--------------------------------------------------------------------------------
/xlat/schedulers.in:
--------------------------------------------------------------------------------
1 | SCHED_OTHER
2 | SCHED_RR
3 | SCHED_FIFO
4 | 


--------------------------------------------------------------------------------
/xlat/scmvals.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/scmvals.in; do not edit. */
 2 | 
 3 | static const struct xlat scmvals[] = {
 4 | #if defined(SCM_RIGHTS) || (defined(HAVE_DECL_SCM_RIGHTS) && HAVE_DECL_SCM_RIGHTS)
 5 | 	XLAT(SCM_RIGHTS),
 6 | #endif
 7 | #if defined(SCM_CREDENTIALS) || (defined(HAVE_DECL_SCM_CREDENTIALS) && HAVE_DECL_SCM_CREDENTIALS)
 8 | 	XLAT(SCM_CREDENTIALS),
 9 | #endif
10 | 	XLAT_END
11 | };
12 | 


--------------------------------------------------------------------------------
/xlat/scmvals.in:
--------------------------------------------------------------------------------
1 | SCM_RIGHTS
2 | SCM_CREDENTIALS
3 | 


--------------------------------------------------------------------------------
/xlat/semctl_flags.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/semctl_flags.in; do not edit. */
 2 | 
 3 | static const struct xlat semctl_flags[] = {
 4 | #if defined(IPC_RMID) || (defined(HAVE_DECL_IPC_RMID) && HAVE_DECL_IPC_RMID)
 5 | 	XLAT(IPC_RMID),
 6 | #endif
 7 | #if defined(IPC_SET) || (defined(HAVE_DECL_IPC_SET) && HAVE_DECL_IPC_SET)
 8 | 	XLAT(IPC_SET),
 9 | #endif
10 | #if defined(IPC_STAT) || (defined(HAVE_DECL_IPC_STAT) && HAVE_DECL_IPC_STAT)
11 | 	XLAT(IPC_STAT),
12 | #endif
13 | #if defined(IPC_INFO) || (defined(HAVE_DECL_IPC_INFO) && HAVE_DECL_IPC_INFO)
14 | 	XLAT(IPC_INFO),
15 | #endif
16 | #if defined(SEM_STAT) || (defined(HAVE_DECL_SEM_STAT) && HAVE_DECL_SEM_STAT)
17 | 	XLAT(SEM_STAT),
18 | #endif
19 | #if defined(SEM_INFO) || (defined(HAVE_DECL_SEM_INFO) && HAVE_DECL_SEM_INFO)
20 | 	XLAT(SEM_INFO),
21 | #endif
22 | #if defined(GETPID) || (defined(HAVE_DECL_GETPID) && HAVE_DECL_GETPID)
23 | 	XLAT(GETPID),
24 | #endif
25 | #if defined(GETVAL) || (defined(HAVE_DECL_GETVAL) && HAVE_DECL_GETVAL)
26 | 	XLAT(GETVAL),
27 | #endif
28 | #if defined(GETALL) || (defined(HAVE_DECL_GETALL) && HAVE_DECL_GETALL)
29 | 	XLAT(GETALL),
30 | #endif
31 | #if defined(GETNCNT) || (defined(HAVE_DECL_GETNCNT) && HAVE_DECL_GETNCNT)
32 | 	XLAT(GETNCNT),
33 | #endif
34 | #if defined(GETZCNT) || (defined(HAVE_DECL_GETZCNT) && HAVE_DECL_GETZCNT)
35 | 	XLAT(GETZCNT),
36 | #endif
37 | #if defined(SETVAL) || (defined(HAVE_DECL_SETVAL) && HAVE_DECL_SETVAL)
38 | 	XLAT(SETVAL),
39 | #endif
40 | #if defined(SETALL) || (defined(HAVE_DECL_SETALL) && HAVE_DECL_SETALL)
41 | 	XLAT(SETALL),
42 | #endif
43 | 	XLAT_END
44 | };
45 | 


--------------------------------------------------------------------------------
/xlat/semctl_flags.in:
--------------------------------------------------------------------------------
 1 | IPC_RMID
 2 | IPC_SET
 3 | IPC_STAT
 4 | IPC_INFO
 5 | SEM_STAT
 6 | SEM_INFO
 7 | GETPID
 8 | GETVAL
 9 | GETALL
10 | GETNCNT
11 | GETZCNT
12 | SETVAL
13 | SETALL
14 | 


--------------------------------------------------------------------------------
/xlat/semop_flags.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/semop_flags.in; do not edit. */
 2 | 
 3 | static const struct xlat semop_flags[] = {
 4 | #if defined(SEM_UNDO) || (defined(HAVE_DECL_SEM_UNDO) && HAVE_DECL_SEM_UNDO)
 5 | 	XLAT(SEM_UNDO),
 6 | #endif
 7 | #if defined(IPC_NOWAIT) || (defined(HAVE_DECL_IPC_NOWAIT) && HAVE_DECL_IPC_NOWAIT)
 8 | 	XLAT(IPC_NOWAIT),
 9 | #endif
10 | 	XLAT_END
11 | };
12 | 


--------------------------------------------------------------------------------
/xlat/semop_flags.in:
--------------------------------------------------------------------------------
1 | SEM_UNDO
2 | IPC_NOWAIT
3 | 


--------------------------------------------------------------------------------
/xlat/sg_io_dxfer_direction.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/sg_io_dxfer_direction.in; do not edit. */
 2 | 
 3 | static const struct xlat sg_io_dxfer_direction[] = {
 4 | #if defined(SG_DXFER_NONE) || (defined(HAVE_DECL_SG_DXFER_NONE) && HAVE_DECL_SG_DXFER_NONE)
 5 | 	XLAT(SG_DXFER_NONE),
 6 | #endif
 7 | #if defined(SG_DXFER_TO_DEV) || (defined(HAVE_DECL_SG_DXFER_TO_DEV) && HAVE_DECL_SG_DXFER_TO_DEV)
 8 | 	XLAT(SG_DXFER_TO_DEV),
 9 | #endif
10 | #if defined(SG_DXFER_FROM_DEV) || (defined(HAVE_DECL_SG_DXFER_FROM_DEV) && HAVE_DECL_SG_DXFER_FROM_DEV)
11 | 	XLAT(SG_DXFER_FROM_DEV),
12 | #endif
13 | #if defined(SG_DXFER_TO_FROM_DEV) || (defined(HAVE_DECL_SG_DXFER_TO_FROM_DEV) && HAVE_DECL_SG_DXFER_TO_FROM_DEV)
14 | 	XLAT(SG_DXFER_TO_FROM_DEV),
15 | #endif
16 | 	XLAT_END
17 | };
18 | 


--------------------------------------------------------------------------------
/xlat/sg_io_dxfer_direction.in:
--------------------------------------------------------------------------------
1 | SG_DXFER_NONE
2 | SG_DXFER_TO_DEV
3 | SG_DXFER_FROM_DEV
4 | SG_DXFER_TO_FROM_DEV
5 | 


--------------------------------------------------------------------------------
/xlat/shm_flags.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/shm_flags.in; do not edit. */
 2 | 
 3 | static const struct xlat shm_flags[] = {
 4 | #if defined(SHM_REMAP) || (defined(HAVE_DECL_SHM_REMAP) && HAVE_DECL_SHM_REMAP)
 5 | 	XLAT(SHM_REMAP),
 6 | #endif
 7 | #if defined(SHM_RDONLY) || (defined(HAVE_DECL_SHM_RDONLY) && HAVE_DECL_SHM_RDONLY)
 8 | 	XLAT(SHM_RDONLY),
 9 | #endif
10 | #if defined(SHM_RND) || (defined(HAVE_DECL_SHM_RND) && HAVE_DECL_SHM_RND)
11 | 	XLAT(SHM_RND),
12 | #endif
13 | 	XLAT_END
14 | };
15 | 


--------------------------------------------------------------------------------
/xlat/shm_flags.in:
--------------------------------------------------------------------------------
1 | SHM_REMAP
2 | SHM_RDONLY
3 | SHM_RND
4 | 


--------------------------------------------------------------------------------
/xlat/shm_resource_flags.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/shm_resource_flags.in; do not edit. */
 2 | 
 3 | static const struct xlat shm_resource_flags[] = {
 4 | #if defined(IPC_CREAT) || (defined(HAVE_DECL_IPC_CREAT) && HAVE_DECL_IPC_CREAT)
 5 | 	XLAT(IPC_CREAT),
 6 | #endif
 7 | #if defined(IPC_EXCL) || (defined(HAVE_DECL_IPC_EXCL) && HAVE_DECL_IPC_EXCL)
 8 | 	XLAT(IPC_EXCL),
 9 | #endif
10 | #if defined(SHM_HUGETLB) || (defined(HAVE_DECL_SHM_HUGETLB) && HAVE_DECL_SHM_HUGETLB)
11 | 	XLAT(SHM_HUGETLB),
12 | #endif
13 | 	XLAT_END
14 | };
15 | 


--------------------------------------------------------------------------------
/xlat/shm_resource_flags.in:
--------------------------------------------------------------------------------
1 | IPC_CREAT
2 | IPC_EXCL
3 | SHM_HUGETLB
4 | 


--------------------------------------------------------------------------------
/xlat/shmctl_flags.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/shmctl_flags.in; do not edit. */
 2 | 
 3 | static const struct xlat shmctl_flags[] = {
 4 | #if defined(IPC_RMID) || (defined(HAVE_DECL_IPC_RMID) && HAVE_DECL_IPC_RMID)
 5 | 	XLAT(IPC_RMID),
 6 | #endif
 7 | #if defined(IPC_SET) || (defined(HAVE_DECL_IPC_SET) && HAVE_DECL_IPC_SET)
 8 | 	XLAT(IPC_SET),
 9 | #endif
10 | #if defined(IPC_STAT) || (defined(HAVE_DECL_IPC_STAT) && HAVE_DECL_IPC_STAT)
11 | 	XLAT(IPC_STAT),
12 | #endif
13 | #if defined(IPC_INFO) || (defined(HAVE_DECL_IPC_INFO) && HAVE_DECL_IPC_INFO)
14 | 	XLAT(IPC_INFO),
15 | #endif
16 | #if defined(SHM_STAT) || (defined(HAVE_DECL_SHM_STAT) && HAVE_DECL_SHM_STAT)
17 | 	XLAT(SHM_STAT),
18 | #endif
19 | #if defined(SHM_INFO) || (defined(HAVE_DECL_SHM_INFO) && HAVE_DECL_SHM_INFO)
20 | 	XLAT(SHM_INFO),
21 | #endif
22 | #if defined(SHM_LOCK) || (defined(HAVE_DECL_SHM_LOCK) && HAVE_DECL_SHM_LOCK)
23 | 	XLAT(SHM_LOCK),
24 | #endif
25 | #if defined(SHM_UNLOCK) || (defined(HAVE_DECL_SHM_UNLOCK) && HAVE_DECL_SHM_UNLOCK)
26 | 	XLAT(SHM_UNLOCK),
27 | #endif
28 | 	XLAT_END
29 | };
30 | 


--------------------------------------------------------------------------------
/xlat/shmctl_flags.in:
--------------------------------------------------------------------------------
1 | IPC_RMID
2 | IPC_SET
3 | IPC_STAT
4 | IPC_INFO
5 | SHM_STAT
6 | SHM_INFO
7 | SHM_LOCK
8 | SHM_UNLOCK
9 | 


--------------------------------------------------------------------------------
/xlat/shutdown_modes.h:
--------------------------------------------------------------------------------
1 | /* Generated by ./xlat/gen.sh from ./xlat/shutdown_modes.in; do not edit. */
2 | 
3 | static const struct xlat shutdown_modes[] = {
4 | { 0,	"SHUT_RD"	},
5 | { 1,	"SHUT_WR"	},
6 | { 2,	"SHUT_RDWR"	},
7 | 	XLAT_END
8 | };
9 | 


--------------------------------------------------------------------------------
/xlat/shutdown_modes.in:
--------------------------------------------------------------------------------
1 | 	{ 0,	"SHUT_RD"	},
2 | 	{ 1,	"SHUT_WR"	},
3 | 	{ 2,	"SHUT_RDWR"	},
4 | 


--------------------------------------------------------------------------------
/xlat/sigact_flags.in:
--------------------------------------------------------------------------------
 1 | SA_RESTORER
 2 | SA_STACK
 3 | SA_RESTART
 4 | SA_INTERRUPT
 5 | SA_NODEFER
 6 | #if defined SA_NOMASK && SA_NODEFER != SA_NOMASK
 7 | SA_NOMASK
 8 | #endif
 9 | SA_RESETHAND
10 | #if defined SA_ONESHOT && SA_ONESHOT != SA_RESETHAND
11 | SA_ONESHOT
12 | #endif
13 | SA_SIGINFO
14 | SA_RESETHAND
15 | SA_ONSTACK
16 | SA_NODEFER
17 | SA_NOCLDSTOP
18 | SA_NOCLDWAIT
19 | _SA_BSDCALL
20 | SA_NOPTRACE
21 | 


--------------------------------------------------------------------------------
/xlat/sigaltstack_flags.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/sigaltstack_flags.in; do not edit. */
 2 | 
 3 | static const struct xlat sigaltstack_flags[] = {
 4 | #if defined(SS_ONSTACK) || (defined(HAVE_DECL_SS_ONSTACK) && HAVE_DECL_SS_ONSTACK)
 5 | 	XLAT(SS_ONSTACK),
 6 | #endif
 7 | #if defined(SS_DISABLE) || (defined(HAVE_DECL_SS_DISABLE) && HAVE_DECL_SS_DISABLE)
 8 | 	XLAT(SS_DISABLE),
 9 | #endif
10 | 	XLAT_END
11 | };
12 | 


--------------------------------------------------------------------------------
/xlat/sigaltstack_flags.in:
--------------------------------------------------------------------------------
1 | SS_ONSTACK
2 | SS_DISABLE
3 | 


--------------------------------------------------------------------------------
/xlat/sigbus_codes.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/sigbus_codes.in; do not edit. */
 2 | 
 3 | static const struct xlat sigbus_codes[] = {
 4 | #if defined(BUS_ADRALN) || (defined(HAVE_DECL_BUS_ADRALN) && HAVE_DECL_BUS_ADRALN)
 5 | 	XLAT(BUS_ADRALN),
 6 | #endif
 7 | #if defined(BUS_ADRERR) || (defined(HAVE_DECL_BUS_ADRERR) && HAVE_DECL_BUS_ADRERR)
 8 | 	XLAT(BUS_ADRERR),
 9 | #endif
10 | #if defined(BUS_OBJERR) || (defined(HAVE_DECL_BUS_OBJERR) && HAVE_DECL_BUS_OBJERR)
11 | 	XLAT(BUS_OBJERR),
12 | #endif
13 | 	XLAT_END
14 | };
15 | 


--------------------------------------------------------------------------------
/xlat/sigbus_codes.in:
--------------------------------------------------------------------------------
1 | BUS_ADRALN
2 | BUS_ADRERR
3 | BUS_OBJERR
4 | 


--------------------------------------------------------------------------------
/xlat/sigchld_codes.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/sigchld_codes.in; do not edit. */
 2 | 
 3 | static const struct xlat sigchld_codes[] = {
 4 | #if defined(CLD_EXITED) || (defined(HAVE_DECL_CLD_EXITED) && HAVE_DECL_CLD_EXITED)
 5 | 	XLAT(CLD_EXITED),
 6 | #endif
 7 | #if defined(CLD_KILLED) || (defined(HAVE_DECL_CLD_KILLED) && HAVE_DECL_CLD_KILLED)
 8 | 	XLAT(CLD_KILLED),
 9 | #endif
10 | #if defined(CLD_DUMPED) || (defined(HAVE_DECL_CLD_DUMPED) && HAVE_DECL_CLD_DUMPED)
11 | 	XLAT(CLD_DUMPED),
12 | #endif
13 | #if defined(CLD_TRAPPED) || (defined(HAVE_DECL_CLD_TRAPPED) && HAVE_DECL_CLD_TRAPPED)
14 | 	XLAT(CLD_TRAPPED),
15 | #endif
16 | #if defined(CLD_STOPPED) || (defined(HAVE_DECL_CLD_STOPPED) && HAVE_DECL_CLD_STOPPED)
17 | 	XLAT(CLD_STOPPED),
18 | #endif
19 | #if defined(CLD_CONTINUED) || (defined(HAVE_DECL_CLD_CONTINUED) && HAVE_DECL_CLD_CONTINUED)
20 | 	XLAT(CLD_CONTINUED),
21 | #endif
22 | 	XLAT_END
23 | };
24 | 


--------------------------------------------------------------------------------
/xlat/sigchld_codes.in:
--------------------------------------------------------------------------------
1 | CLD_EXITED
2 | CLD_KILLED
3 | CLD_DUMPED
4 | CLD_TRAPPED
5 | CLD_STOPPED
6 | CLD_CONTINUED
7 | 


--------------------------------------------------------------------------------
/xlat/sigemt_codes.h:
--------------------------------------------------------------------------------
1 | /* Generated by ./xlat/gen.sh from ./xlat/sigemt_codes.in; do not edit. */
2 | 
3 | static const struct xlat sigemt_codes[] = {
4 | #if defined(EMT_TAGOVF) || (defined(HAVE_DECL_EMT_TAGOVF) && HAVE_DECL_EMT_TAGOVF)
5 | 	XLAT(EMT_TAGOVF),
6 | #endif
7 | 	XLAT_END
8 | };
9 | 


--------------------------------------------------------------------------------
/xlat/sigemt_codes.in:
--------------------------------------------------------------------------------
1 | EMT_TAGOVF
2 | 


--------------------------------------------------------------------------------
/xlat/sigev_value.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/sigev_value.in; do not edit. */
 2 | 
 3 | static const struct xlat sigev_value[] = {
 4 | #if defined(SIGEV_SIGNAL) || (defined(HAVE_DECL_SIGEV_SIGNAL) && HAVE_DECL_SIGEV_SIGNAL)
 5 | 	XLAT(SIGEV_SIGNAL),
 6 | #endif
 7 | #if defined(SIGEV_NONE) || (defined(HAVE_DECL_SIGEV_NONE) && HAVE_DECL_SIGEV_NONE)
 8 | 	XLAT(SIGEV_NONE),
 9 | #endif
10 | #if defined(SIGEV_THREAD) || (defined(HAVE_DECL_SIGEV_THREAD) && HAVE_DECL_SIGEV_THREAD)
11 | 	XLAT(SIGEV_THREAD),
12 | #endif
13 | #if defined(SIGEV_THREAD_ID) || (defined(HAVE_DECL_SIGEV_THREAD_ID) && HAVE_DECL_SIGEV_THREAD_ID)
14 | 	XLAT(SIGEV_THREAD_ID),
15 | #endif
16 | 	XLAT_END
17 | };
18 | 


--------------------------------------------------------------------------------
/xlat/sigev_value.in:
--------------------------------------------------------------------------------
1 | SIGEV_SIGNAL
2 | SIGEV_NONE
3 | SIGEV_THREAD
4 | SIGEV_THREAD_ID
5 | 


--------------------------------------------------------------------------------
/xlat/sigfpe_codes.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/sigfpe_codes.in; do not edit. */
 2 | 
 3 | static const struct xlat sigfpe_codes[] = {
 4 | #if defined(FPE_INTDIV) || (defined(HAVE_DECL_FPE_INTDIV) && HAVE_DECL_FPE_INTDIV)
 5 | 	XLAT(FPE_INTDIV),
 6 | #endif
 7 | #if defined(FPE_INTOVF) || (defined(HAVE_DECL_FPE_INTOVF) && HAVE_DECL_FPE_INTOVF)
 8 | 	XLAT(FPE_INTOVF),
 9 | #endif
10 | #if defined(FPE_FLTDIV) || (defined(HAVE_DECL_FPE_FLTDIV) && HAVE_DECL_FPE_FLTDIV)
11 | 	XLAT(FPE_FLTDIV),
12 | #endif
13 | #if defined(FPE_FLTOVF) || (defined(HAVE_DECL_FPE_FLTOVF) && HAVE_DECL_FPE_FLTOVF)
14 | 	XLAT(FPE_FLTOVF),
15 | #endif
16 | #if defined(FPE_FLTUND) || (defined(HAVE_DECL_FPE_FLTUND) && HAVE_DECL_FPE_FLTUND)
17 | 	XLAT(FPE_FLTUND),
18 | #endif
19 | #if defined(FPE_FLTRES) || (defined(HAVE_DECL_FPE_FLTRES) && HAVE_DECL_FPE_FLTRES)
20 | 	XLAT(FPE_FLTRES),
21 | #endif
22 | #if defined(FPE_FLTINV) || (defined(HAVE_DECL_FPE_FLTINV) && HAVE_DECL_FPE_FLTINV)
23 | 	XLAT(FPE_FLTINV),
24 | #endif
25 | #if defined(FPE_FLTSUB) || (defined(HAVE_DECL_FPE_FLTSUB) && HAVE_DECL_FPE_FLTSUB)
26 | 	XLAT(FPE_FLTSUB),
27 | #endif
28 | 	XLAT_END
29 | };
30 | 


--------------------------------------------------------------------------------
/xlat/sigfpe_codes.in:
--------------------------------------------------------------------------------
1 | FPE_INTDIV
2 | FPE_INTOVF
3 | FPE_FLTDIV
4 | FPE_FLTOVF
5 | FPE_FLTUND
6 | FPE_FLTRES
7 | FPE_FLTINV
8 | FPE_FLTSUB
9 | 


--------------------------------------------------------------------------------
/xlat/sigill_codes.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/sigill_codes.in; do not edit. */
 2 | 
 3 | static const struct xlat sigill_codes[] = {
 4 | #if defined(ILL_ILLOPC) || (defined(HAVE_DECL_ILL_ILLOPC) && HAVE_DECL_ILL_ILLOPC)
 5 | 	XLAT(ILL_ILLOPC),
 6 | #endif
 7 | #if defined(ILL_ILLOPN) || (defined(HAVE_DECL_ILL_ILLOPN) && HAVE_DECL_ILL_ILLOPN)
 8 | 	XLAT(ILL_ILLOPN),
 9 | #endif
10 | #if defined(ILL_ILLADR) || (defined(HAVE_DECL_ILL_ILLADR) && HAVE_DECL_ILL_ILLADR)
11 | 	XLAT(ILL_ILLADR),
12 | #endif
13 | #if defined(ILL_ILLTRP) || (defined(HAVE_DECL_ILL_ILLTRP) && HAVE_DECL_ILL_ILLTRP)
14 | 	XLAT(ILL_ILLTRP),
15 | #endif
16 | #if defined(ILL_PRVOPC) || (defined(HAVE_DECL_ILL_PRVOPC) && HAVE_DECL_ILL_PRVOPC)
17 | 	XLAT(ILL_PRVOPC),
18 | #endif
19 | #if defined(ILL_PRVREG) || (defined(HAVE_DECL_ILL_PRVREG) && HAVE_DECL_ILL_PRVREG)
20 | 	XLAT(ILL_PRVREG),
21 | #endif
22 | #if defined(ILL_COPROC) || (defined(HAVE_DECL_ILL_COPROC) && HAVE_DECL_ILL_COPROC)
23 | 	XLAT(ILL_COPROC),
24 | #endif
25 | #if defined(ILL_BADSTK) || (defined(HAVE_DECL_ILL_BADSTK) && HAVE_DECL_ILL_BADSTK)
26 | 	XLAT(ILL_BADSTK),
27 | #endif
28 | 	XLAT_END
29 | };
30 | 


--------------------------------------------------------------------------------
/xlat/sigill_codes.in:
--------------------------------------------------------------------------------
1 | ILL_ILLOPC
2 | ILL_ILLOPN
3 | ILL_ILLADR
4 | ILL_ILLTRP
5 | ILL_PRVOPC
6 | ILL_PRVREG
7 | ILL_COPROC
8 | ILL_BADSTK
9 | 


--------------------------------------------------------------------------------
/xlat/siginfo_codes.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/siginfo_codes.in; do not edit. */
 2 | 
 3 | static const struct xlat siginfo_codes[] = {
 4 | #if defined(SI_KERNEL) || (defined(HAVE_DECL_SI_KERNEL) && HAVE_DECL_SI_KERNEL)
 5 | 	XLAT(SI_KERNEL),
 6 | #endif
 7 | #if defined(SI_USER) || (defined(HAVE_DECL_SI_USER) && HAVE_DECL_SI_USER)
 8 | 	XLAT(SI_USER),
 9 | #endif
10 | #if defined(SI_QUEUE) || (defined(HAVE_DECL_SI_QUEUE) && HAVE_DECL_SI_QUEUE)
11 | 	XLAT(SI_QUEUE),
12 | #endif
13 | #if defined(SI_TIMER) || (defined(HAVE_DECL_SI_TIMER) && HAVE_DECL_SI_TIMER)
14 | 	XLAT(SI_TIMER),
15 | #endif
16 | #if defined(SI_MESGQ) || (defined(HAVE_DECL_SI_MESGQ) && HAVE_DECL_SI_MESGQ)
17 | 	XLAT(SI_MESGQ),
18 | #endif
19 | #if defined(SI_ASYNCIO) || (defined(HAVE_DECL_SI_ASYNCIO) && HAVE_DECL_SI_ASYNCIO)
20 | 	XLAT(SI_ASYNCIO),
21 | #endif
22 | #if defined(SI_SIGIO) || (defined(HAVE_DECL_SI_SIGIO) && HAVE_DECL_SI_SIGIO)
23 | 	XLAT(SI_SIGIO),
24 | #endif
25 | #if defined(SI_TKILL) || (defined(HAVE_DECL_SI_TKILL) && HAVE_DECL_SI_TKILL)
26 | 	XLAT(SI_TKILL),
27 | #endif
28 | #if defined(SI_DETHREAD) || (defined(HAVE_DECL_SI_DETHREAD) && HAVE_DECL_SI_DETHREAD)
29 | 	XLAT(SI_DETHREAD),
30 | #endif
31 | #if defined(SI_ASYNCNL) || (defined(HAVE_DECL_SI_ASYNCNL) && HAVE_DECL_SI_ASYNCNL)
32 | 	XLAT(SI_ASYNCNL),
33 | #endif
34 | #if defined(SI_NOINFO) || (defined(HAVE_DECL_SI_NOINFO) && HAVE_DECL_SI_NOINFO)
35 | 	XLAT(SI_NOINFO),
36 | #endif
37 | #if defined(SI_LWP) || (defined(HAVE_DECL_SI_LWP) && HAVE_DECL_SI_LWP)
38 | 	XLAT(SI_LWP),
39 | #endif
40 | 	XLAT_END
41 | };
42 | 


--------------------------------------------------------------------------------
/xlat/siginfo_codes.in:
--------------------------------------------------------------------------------
 1 | SI_KERNEL
 2 | SI_USER
 3 | SI_QUEUE
 4 | SI_TIMER
 5 | SI_MESGQ
 6 | SI_ASYNCIO
 7 | SI_SIGIO
 8 | SI_TKILL
 9 | SI_DETHREAD
10 | SI_ASYNCNL
11 | SI_NOINFO
12 | SI_LWP
13 | 


--------------------------------------------------------------------------------
/xlat/sigpoll_codes.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/sigpoll_codes.in; do not edit. */
 2 | 
 3 | static const struct xlat sigpoll_codes[] = {
 4 | #if defined(POLL_IN) || (defined(HAVE_DECL_POLL_IN) && HAVE_DECL_POLL_IN)
 5 | 	XLAT(POLL_IN),
 6 | #endif
 7 | #if defined(POLL_OUT) || (defined(HAVE_DECL_POLL_OUT) && HAVE_DECL_POLL_OUT)
 8 | 	XLAT(POLL_OUT),
 9 | #endif
10 | #if defined(POLL_MSG) || (defined(HAVE_DECL_POLL_MSG) && HAVE_DECL_POLL_MSG)
11 | 	XLAT(POLL_MSG),
12 | #endif
13 | #if defined(POLL_ERR) || (defined(HAVE_DECL_POLL_ERR) && HAVE_DECL_POLL_ERR)
14 | 	XLAT(POLL_ERR),
15 | #endif
16 | #if defined(POLL_PRI) || (defined(HAVE_DECL_POLL_PRI) && HAVE_DECL_POLL_PRI)
17 | 	XLAT(POLL_PRI),
18 | #endif
19 | #if defined(POLL_HUP) || (defined(HAVE_DECL_POLL_HUP) && HAVE_DECL_POLL_HUP)
20 | 	XLAT(POLL_HUP),
21 | #endif
22 | 	XLAT_END
23 | };
24 | 


--------------------------------------------------------------------------------
/xlat/sigpoll_codes.in:
--------------------------------------------------------------------------------
1 | POLL_IN
2 | POLL_OUT
3 | POLL_MSG
4 | POLL_ERR
5 | POLL_PRI
6 | POLL_HUP
7 | 


--------------------------------------------------------------------------------
/xlat/sigprocmaskcmds.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/sigprocmaskcmds.in; do not edit. */
 2 | 
 3 | static const struct xlat sigprocmaskcmds[] = {
 4 | #if defined(SIG_BLOCK) || (defined(HAVE_DECL_SIG_BLOCK) && HAVE_DECL_SIG_BLOCK)
 5 | 	XLAT(SIG_BLOCK),
 6 | #endif
 7 | #if defined(SIG_UNBLOCK) || (defined(HAVE_DECL_SIG_UNBLOCK) && HAVE_DECL_SIG_UNBLOCK)
 8 | 	XLAT(SIG_UNBLOCK),
 9 | #endif
10 | #if defined(SIG_SETMASK) || (defined(HAVE_DECL_SIG_SETMASK) && HAVE_DECL_SIG_SETMASK)
11 | 	XLAT(SIG_SETMASK),
12 | #endif
13 | #if defined(SIG_SETMASK32) || (defined(HAVE_DECL_SIG_SETMASK32) && HAVE_DECL_SIG_SETMASK32)
14 | 	XLAT(SIG_SETMASK32),
15 | #endif
16 | 	XLAT_END
17 | };
18 | 


--------------------------------------------------------------------------------
/xlat/sigprocmaskcmds.in:
--------------------------------------------------------------------------------
1 | SIG_BLOCK
2 | SIG_UNBLOCK
3 | SIG_SETMASK
4 | SIG_SETMASK32
5 | 


--------------------------------------------------------------------------------
/xlat/sigprof_codes.h:
--------------------------------------------------------------------------------
1 | /* Generated by ./xlat/gen.sh from ./xlat/sigprof_codes.in; do not edit. */
2 | 
3 | static const struct xlat sigprof_codes[] = {
4 | #if defined(PROF_SIG) || (defined(HAVE_DECL_PROF_SIG) && HAVE_DECL_PROF_SIG)
5 | 	XLAT(PROF_SIG),
6 | #endif
7 | 	XLAT_END
8 | };
9 | 


--------------------------------------------------------------------------------
/xlat/sigprof_codes.in:
--------------------------------------------------------------------------------
1 | PROF_SIG
2 | 


--------------------------------------------------------------------------------
/xlat/sigsegv_codes.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/sigsegv_codes.in; do not edit. */
 2 | 
 3 | static const struct xlat sigsegv_codes[] = {
 4 | #if defined(SEGV_MAPERR) || (defined(HAVE_DECL_SEGV_MAPERR) && HAVE_DECL_SEGV_MAPERR)
 5 | 	XLAT(SEGV_MAPERR),
 6 | #endif
 7 | #if defined(SEGV_ACCERR) || (defined(HAVE_DECL_SEGV_ACCERR) && HAVE_DECL_SEGV_ACCERR)
 8 | 	XLAT(SEGV_ACCERR),
 9 | #endif
10 | 	XLAT_END
11 | };
12 | 


--------------------------------------------------------------------------------
/xlat/sigsegv_codes.in:
--------------------------------------------------------------------------------
1 | SEGV_MAPERR
2 | SEGV_ACCERR
3 | 


--------------------------------------------------------------------------------
/xlat/sigsys_codes.h:
--------------------------------------------------------------------------------
1 | /* Generated by ./xlat/gen.sh from ./xlat/sigsys_codes.in; do not edit. */
2 | 
3 | static const struct xlat sigsys_codes[] = {
4 | #if defined(SYS_SECCOMP) || (defined(HAVE_DECL_SYS_SECCOMP) && HAVE_DECL_SYS_SECCOMP)
5 | 	XLAT(SYS_SECCOMP),
6 | #endif
7 | 	XLAT_END
8 | };
9 | 


--------------------------------------------------------------------------------
/xlat/sigsys_codes.in:
--------------------------------------------------------------------------------
1 | SYS_SECCOMP
2 | 


--------------------------------------------------------------------------------
/xlat/sigtrap_codes.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/sigtrap_codes.in; do not edit. */
 2 | 
 3 | static const struct xlat sigtrap_codes[] = {
 4 | #if defined(TRAP_BRKPT) || (defined(HAVE_DECL_TRAP_BRKPT) && HAVE_DECL_TRAP_BRKPT)
 5 | 	XLAT(TRAP_BRKPT),
 6 | #endif
 7 | #if defined(TRAP_TRACE) || (defined(HAVE_DECL_TRAP_TRACE) && HAVE_DECL_TRAP_TRACE)
 8 | 	XLAT(TRAP_TRACE),
 9 | #endif
10 | 	XLAT_END
11 | };
12 | 


--------------------------------------------------------------------------------
/xlat/sigtrap_codes.in:
--------------------------------------------------------------------------------
1 | TRAP_BRKPT
2 | TRAP_TRACE
3 | 


--------------------------------------------------------------------------------
/xlat/sock_type_flags.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/sock_type_flags.in; do not edit. */
 2 | 
 3 | static const struct xlat sock_type_flags[] = {
 4 | #if defined(SOCK_CLOEXEC) || (defined(HAVE_DECL_SOCK_CLOEXEC) && HAVE_DECL_SOCK_CLOEXEC)
 5 | 	XLAT(SOCK_CLOEXEC),
 6 | #endif
 7 | #if defined(SOCK_NONBLOCK) || (defined(HAVE_DECL_SOCK_NONBLOCK) && HAVE_DECL_SOCK_NONBLOCK)
 8 | 	XLAT(SOCK_NONBLOCK),
 9 | #endif
10 | 	XLAT_END
11 | };
12 | 


--------------------------------------------------------------------------------
/xlat/sock_type_flags.in:
--------------------------------------------------------------------------------
1 | SOCK_CLOEXEC
2 | SOCK_NONBLOCK
3 | 


--------------------------------------------------------------------------------
/xlat/socketlayers.in:
--------------------------------------------------------------------------------
 1 | SOL_IP
 2 | SOL_ICMP
 3 | SOL_TCP
 4 | SOL_UDP
 5 | SOL_IPV6
 6 | SOL_ICMPV6
 7 | SOL_SCTP
 8 | SOL_UDPLITE
 9 | SOL_RAW
10 | SOL_IPX
11 | SOL_AX25
12 | SOL_ATALK
13 | SOL_NETROM
14 | SOL_ROSE
15 | SOL_DECNET
16 | SOL_X25
17 | SOL_PACKET
18 | SOL_ATM
19 | SOL_AAL
20 | SOL_IRDA
21 | SOL_NETBEUI
22 | SOL_LLC
23 | SOL_DCCP
24 | SOL_NETLINK
25 | SOL_TIPC
26 | SOL_RXRPC
27 | SOL_PPPOL2TP
28 | SOL_BLUETOOTH
29 | SOL_PNPIPE
30 | SOL_RDS
31 | SOL_IUCV
32 | SOL_CAIF
33 | SOL_SOCKET
34 | #unterminated
35 | 


--------------------------------------------------------------------------------
/xlat/sockipoptions.in:
--------------------------------------------------------------------------------
 1 | IP_TOS
 2 | IP_TTL
 3 | IP_HDRINCL
 4 | IP_OPTIONS
 5 | IP_ROUTER_ALERT
 6 | IP_RECVOPTIONS
 7 | IP_RECVOPTS
 8 | IP_RECVRETOPTS
 9 | IP_RECVDSTADDR
10 | IP_RETOPTS
11 | IP_PKTINFO
12 | IP_PKTOPTIONS
13 | IP_MTU_DISCOVER
14 | IP_RECVERR
15 | IP_RECVTTL
16 | IP_RECVTOS
17 | IP_MTU
18 | IP_MULTICAST_IF
19 | IP_MULTICAST_TTL
20 | IP_MULTICAST_LOOP
21 | IP_ADD_MEMBERSHIP
22 | IP_DROP_MEMBERSHIP
23 | IP_BROADCAST_IF
24 | IP_RECVIFINDEX
25 | IP_MSFILTER
26 | MCAST_MSFILTER
27 | IP_FREEBIND
28 | IP_IPSEC_POLICY
29 | IP_XFRM_POLICY
30 | IP_PASSSEC
31 | IP_TRANSPARENT
32 | IP_ORIGDSTADDR
33 | IP_RECVORIGDSTADDR
34 | IP_MINTTL
35 | IP_NODEFRAG
36 | IP_UNBLOCK_SOURCE
37 | IP_BLOCK_SOURCE
38 | IP_ADD_SOURCE_MEMBERSHIP
39 | IP_DROP_SOURCE_MEMBERSHIP
40 | MCAST_JOIN_GROUP
41 | MCAST_BLOCK_SOURCE
42 | MCAST_UNBLOCK_SOURCE
43 | MCAST_LEAVE_GROUP
44 | MCAST_JOIN_SOURCE_GROUP
45 | MCAST_LEAVE_SOURCE_GROUP
46 | IP_MULTICAST_ALL
47 | IP_UNICAST_IF
48 | 


--------------------------------------------------------------------------------
/xlat/sockipv6options.in:
--------------------------------------------------------------------------------
 1 | IPV6_ADDRFORM
 2 | MCAST_FILTER
 3 | IPV6_PKTOPTIONS
 4 | IPV6_MTU
 5 | IPV6_V6ONLY
 6 | IPV6_PKTINFO
 7 | IPV6_HOPLIMIT
 8 | IPV6_RTHDR
 9 | IPV6_HOPOPTS
10 | IPV6_DSTOPTS
11 | IPV6_FLOWINFO
12 | IPV6_UNICAST_HOPS
13 | IPV6_MULTICAST_HOPS
14 | IPV6_MULTICAST_LOOP
15 | IPV6_MULTICAST_IF
16 | IPV6_MTU_DISCOVER
17 | IPV6_RECVERR
18 | IPV6_FLOWINFO_SEND
19 | IPV6_ADD_MEMBERSHIP
20 | IPV6_DROP_MEMBERSHIP
21 | IPV6_ROUTER_ALERT
22 | 


--------------------------------------------------------------------------------
/xlat/sockipxoptions.h:
--------------------------------------------------------------------------------
1 | /* Generated by ./xlat/gen.sh from ./xlat/sockipxoptions.in; do not edit. */
2 | 
3 | static const struct xlat sockipxoptions[] = {
4 | #if defined(IPX_TYPE) || (defined(HAVE_DECL_IPX_TYPE) && HAVE_DECL_IPX_TYPE)
5 | 	XLAT(IPX_TYPE),
6 | #endif
7 | 	XLAT_END
8 | };
9 | 


--------------------------------------------------------------------------------
/xlat/sockipxoptions.in:
--------------------------------------------------------------------------------
1 | IPX_TYPE
2 | 


--------------------------------------------------------------------------------
/xlat/sockoptions.in:
--------------------------------------------------------------------------------
 1 | SO_ACCEPTCONN
 2 | SO_ALLRAW
 3 | SO_ATTACH_FILTER
 4 | SO_BINDTODEVICE
 5 | SO_BROADCAST
 6 | SO_BSDCOMPAT
 7 | SO_DEBUG
 8 | SO_DETACH_FILTER
 9 | SO_DONTROUTE
10 | SO_ERROR
11 | SO_ICS
12 | SO_IMASOCKET
13 | SO_KEEPALIVE
14 | SO_LINGER
15 | SO_LISTENING
16 | SO_MGMT
17 | SO_NO_CHECK
18 | SO_OOBINLINE
19 | SO_ORDREL
20 | SO_PARALLELSVR
21 | SO_PASSCRED
22 | SO_PEERCRED
23 | SO_PEERNAME
24 | SO_PEERSEC
25 | SO_PRIORITY
26 | SO_PROTOTYPE
27 | SO_RCVBUF
28 | SO_RCVLOWAT
29 | SO_RCVTIMEO
30 | SO_RDWR
31 | SO_REUSEADDR
32 | SO_REUSEPORT
33 | SO_SECURITY_AUTHENTICATION
34 | SO_SECURITY_ENCRYPTION_NETWORK
35 | SO_SECURITY_ENCRYPTION_TRANSPORT
36 | SO_SEMA
37 | SO_SNDBUF
38 | SO_SNDLOWAT
39 | SO_SNDTIMEO
40 | SO_TIMESTAMP
41 | SO_TYPE
42 | SO_USELOOPBACK
43 | 


--------------------------------------------------------------------------------
/xlat/sockpacketoptions.in:
--------------------------------------------------------------------------------
 1 | PACKET_ADD_MEMBERSHIP
 2 | PACKET_DROP_MEMBERSHIP
 3 | PACKET_RECV_OUTPUT
 4 | PACKET_RX_RING
 5 | PACKET_STATISTICS
 6 | PACKET_COPY_THRESH
 7 | PACKET_AUXDATA
 8 | PACKET_ORIGDEV
 9 | PACKET_VERSION
10 | PACKET_HDRLEN
11 | PACKET_RESERVE
12 | PACKET_TX_RING
13 | PACKET_LOSS
14 | 


--------------------------------------------------------------------------------
/xlat/sockrawoptions.h:
--------------------------------------------------------------------------------
1 | /* Generated by ./xlat/gen.sh from ./xlat/sockrawoptions.in; do not edit. */
2 | 
3 | static const struct xlat sockrawoptions[] = {
4 | #if defined(ICMP_FILTER) || (defined(HAVE_DECL_ICMP_FILTER) && HAVE_DECL_ICMP_FILTER)
5 | 	XLAT(ICMP_FILTER),
6 | #endif
7 | 	XLAT_END
8 | };
9 | 


--------------------------------------------------------------------------------
/xlat/sockrawoptions.in:
--------------------------------------------------------------------------------
1 | ICMP_FILTER
2 | 


--------------------------------------------------------------------------------
/xlat/socksctpoptions.in:
--------------------------------------------------------------------------------
 1 | SCTP_RTOINFO
 2 | SCTP_ASSOCINFO
 3 | SCTP_INITMSG
 4 | SCTP_NODELAY
 5 | SCTP_AUTOCLOSE
 6 | SCTP_SET_PEER_PRIMARY_ADDR
 7 | SCTP_PRIMARY_ADDR
 8 | SCTP_ADAPTATION_LAYER
 9 | SCTP_DISABLE_FRAGMENTS
10 | SCTP_PEER_ADDR_PARAMS
11 | SCTP_DEFAULT_SEND_PARAM
12 | SCTP_EVENTS
13 | SCTP_I_WANT_MAPPED_V4_ADDR
14 | SCTP_MAXSEG
15 | SCTP_STATUS
16 | SCTP_GET_PEER_ADDR_INFO
17 | SCTP_DELAYED_ACK
18 | SCTP_CONTEXT
19 | SCTP_FRAGMENT_INTERLEAVE
20 | SCTP_PARTIAL_DELIVERY_POINT
21 | SCTP_MAX_BURST
22 | SCTP_AUTH_CHUNK
23 | SCTP_HMAC_IDENT
24 | SCTP_AUTH_KEY
25 | SCTP_AUTH_ACTIVE_KEY
26 | SCTP_AUTH_DELETE_KEY
27 | SCTP_PEER_AUTH_CHUNKS
28 | SCTP_LOCAL_AUTH_CHUNKS
29 | SCTP_GET_ASSOC_NUMBER
30 | /* linux specific things */
31 | SCTP_SOCKOPT_BINDX_ADD
32 | SCTP_SOCKOPT_BINDX_REM
33 | SCTP_SOCKOPT_PEELOFF
34 | SCTP_GET_PEER_ADDRS_NUM_OLD
35 | SCTP_GET_PEER_ADDRS_OLD
36 | SCTP_GET_LOCAL_ADDRS_NUM_OLD
37 | SCTP_GET_LOCAL_ADDRS_OLD
38 | SCTP_SOCKOPT_CONNECTX_OLD
39 | SCTP_GET_PEER_ADDRS
40 | SCTP_GET_LOCAL_ADDRS
41 | 


--------------------------------------------------------------------------------
/xlat/socktcpoptions.in:
--------------------------------------------------------------------------------
 1 | TCP_NODELAY
 2 | TCP_MAXSEG
 3 | TCP_CORK
 4 | TCP_KEEPIDLE
 5 | TCP_KEEPINTVL
 6 | TCP_KEEPCNT
 7 | TCP_SYNCNT
 8 | TCP_LINGER2
 9 | TCP_DEFER_ACCEPT
10 | TCP_WINDOW_CLAMP
11 | TCP_INFO
12 | TCP_QUICKACK
13 | TCP_CONGESTION
14 | TCP_MD5SIG
15 | TCP_COOKIE_TRANSACTIONS
16 | TCP_THIN_LINEAR_TIMEOUTS
17 | TCP_THIN_DUPACK
18 | TCP_USER_TIMEOUT
19 | TCP_REPAIR
20 | TCP_REPAIR_QUEUE
21 | TCP_QUEUE_SEQ
22 | TCP_REPAIR_OPTIONS
23 | TCP_FASTOPEN
24 | TCP_TIMESTAMP
25 | 


--------------------------------------------------------------------------------
/xlat/socktypes.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/socktypes.in; do not edit. */
 2 | 
 3 | static const struct xlat socktypes[] = {
 4 | #if defined(SOCK_STREAM) || (defined(HAVE_DECL_SOCK_STREAM) && HAVE_DECL_SOCK_STREAM)
 5 | 	XLAT(SOCK_STREAM),
 6 | #endif
 7 | #if defined(SOCK_DGRAM) || (defined(HAVE_DECL_SOCK_DGRAM) && HAVE_DECL_SOCK_DGRAM)
 8 | 	XLAT(SOCK_DGRAM),
 9 | #endif
10 | #if defined(SOCK_RAW) || (defined(HAVE_DECL_SOCK_RAW) && HAVE_DECL_SOCK_RAW)
11 | 	XLAT(SOCK_RAW),
12 | #endif
13 | #if defined(SOCK_RDM) || (defined(HAVE_DECL_SOCK_RDM) && HAVE_DECL_SOCK_RDM)
14 | 	XLAT(SOCK_RDM),
15 | #endif
16 | #if defined(SOCK_SEQPACKET) || (defined(HAVE_DECL_SOCK_SEQPACKET) && HAVE_DECL_SOCK_SEQPACKET)
17 | 	XLAT(SOCK_SEQPACKET),
18 | #endif
19 | #if defined(SOCK_DCCP) || (defined(HAVE_DECL_SOCK_DCCP) && HAVE_DECL_SOCK_DCCP)
20 | 	XLAT(SOCK_DCCP),
21 | #endif
22 | #if defined(SOCK_PACKET) || (defined(HAVE_DECL_SOCK_PACKET) && HAVE_DECL_SOCK_PACKET)
23 | 	XLAT(SOCK_PACKET),
24 | #endif
25 | 	XLAT_END
26 | };
27 | 


--------------------------------------------------------------------------------
/xlat/socktypes.in:
--------------------------------------------------------------------------------
1 | SOCK_STREAM
2 | SOCK_DGRAM
3 | SOCK_RAW
4 | SOCK_RDM
5 | SOCK_SEQPACKET
6 | SOCK_DCCP
7 | SOCK_PACKET
8 | 


--------------------------------------------------------------------------------
/xlat/splice_flags.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/splice_flags.in; do not edit. */
 2 | 
 3 | static const struct xlat splice_flags[] = {
 4 | #if defined(SPLICE_F_MOVE) || (defined(HAVE_DECL_SPLICE_F_MOVE) && HAVE_DECL_SPLICE_F_MOVE)
 5 | 	XLAT(SPLICE_F_MOVE),
 6 | #endif
 7 | #if defined(SPLICE_F_NONBLOCK) || (defined(HAVE_DECL_SPLICE_F_NONBLOCK) && HAVE_DECL_SPLICE_F_NONBLOCK)
 8 | 	XLAT(SPLICE_F_NONBLOCK),
 9 | #endif
10 | #if defined(SPLICE_F_MORE) || (defined(HAVE_DECL_SPLICE_F_MORE) && HAVE_DECL_SPLICE_F_MORE)
11 | 	XLAT(SPLICE_F_MORE),
12 | #endif
13 | #if defined(SPLICE_F_GIFT) || (defined(HAVE_DECL_SPLICE_F_GIFT) && HAVE_DECL_SPLICE_F_GIFT)
14 | 	XLAT(SPLICE_F_GIFT),
15 | #endif
16 | 	XLAT_END
17 | };
18 | 


--------------------------------------------------------------------------------
/xlat/splice_flags.in:
--------------------------------------------------------------------------------
1 | SPLICE_F_MOVE
2 | SPLICE_F_NONBLOCK
3 | SPLICE_F_MORE
4 | SPLICE_F_GIFT
5 | 


--------------------------------------------------------------------------------
/xlat/sram_alloc_flags.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/sram_alloc_flags.in; do not edit. */
 2 | 
 3 | static const struct xlat sram_alloc_flags[] = {
 4 | #if defined(L1_INST_SRAM) || (defined(HAVE_DECL_L1_INST_SRAM) && HAVE_DECL_L1_INST_SRAM)
 5 | 	XLAT(L1_INST_SRAM),
 6 | #endif
 7 | #if defined(L1_DATA_A_SRAM) || (defined(HAVE_DECL_L1_DATA_A_SRAM) && HAVE_DECL_L1_DATA_A_SRAM)
 8 | 	XLAT(L1_DATA_A_SRAM),
 9 | #endif
10 | #if defined(L1_DATA_B_SRAM) || (defined(HAVE_DECL_L1_DATA_B_SRAM) && HAVE_DECL_L1_DATA_B_SRAM)
11 | 	XLAT(L1_DATA_B_SRAM),
12 | #endif
13 | #if defined(L1_DATA_SRAM) || (defined(HAVE_DECL_L1_DATA_SRAM) && HAVE_DECL_L1_DATA_SRAM)
14 | 	XLAT(L1_DATA_SRAM),
15 | #endif
16 | #if defined(L2_SRAM) || (defined(HAVE_DECL_L2_SRAM) && HAVE_DECL_L2_SRAM)
17 | 	XLAT(L2_SRAM),
18 | #endif
19 | 	XLAT_END
20 | };
21 | 


--------------------------------------------------------------------------------
/xlat/sram_alloc_flags.in:
--------------------------------------------------------------------------------
1 | L1_INST_SRAM
2 | L1_DATA_A_SRAM
3 | L1_DATA_B_SRAM
4 | L1_DATA_SRAM
5 | L2_SRAM
6 | 


--------------------------------------------------------------------------------
/xlat/swap_flags.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/swap_flags.in; do not edit. */
 2 | 
 3 | static const struct xlat swap_flags[] = {
 4 | #if defined(SWAP_FLAG_PREFER) || (defined(HAVE_DECL_SWAP_FLAG_PREFER) && HAVE_DECL_SWAP_FLAG_PREFER)
 5 | 	XLAT(SWAP_FLAG_PREFER),
 6 | #endif
 7 | #if defined(SWAP_FLAG_DISCARD) || (defined(HAVE_DECL_SWAP_FLAG_DISCARD) && HAVE_DECL_SWAP_FLAG_DISCARD)
 8 | 	XLAT(SWAP_FLAG_DISCARD),
 9 | #endif
10 | 	XLAT_END
11 | };
12 | 


--------------------------------------------------------------------------------
/xlat/swap_flags.in:
--------------------------------------------------------------------------------
1 | SWAP_FLAG_PREFER
2 | SWAP_FLAG_DISCARD
3 | 


--------------------------------------------------------------------------------
/xlat/sync_file_range_flags.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/sync_file_range_flags.in; do not edit. */
 2 | 
 3 | static const struct xlat sync_file_range_flags[] = {
 4 | #if defined(SYNC_FILE_RANGE_WAIT_BEFORE) || (defined(HAVE_DECL_SYNC_FILE_RANGE_WAIT_BEFORE) && HAVE_DECL_SYNC_FILE_RANGE_WAIT_BEFORE)
 5 | 	XLAT(SYNC_FILE_RANGE_WAIT_BEFORE),
 6 | #endif
 7 | #if defined(SYNC_FILE_RANGE_WRITE) || (defined(HAVE_DECL_SYNC_FILE_RANGE_WRITE) && HAVE_DECL_SYNC_FILE_RANGE_WRITE)
 8 | 	XLAT(SYNC_FILE_RANGE_WRITE),
 9 | #endif
10 | #if defined(SYNC_FILE_RANGE_WAIT_AFTER) || (defined(HAVE_DECL_SYNC_FILE_RANGE_WAIT_AFTER) && HAVE_DECL_SYNC_FILE_RANGE_WAIT_AFTER)
11 | 	XLAT(SYNC_FILE_RANGE_WAIT_AFTER),
12 | #endif
13 | 	XLAT_END
14 | };
15 | 


--------------------------------------------------------------------------------
/xlat/sync_file_range_flags.in:
--------------------------------------------------------------------------------
1 | SYNC_FILE_RANGE_WAIT_BEFORE
2 | SYNC_FILE_RANGE_WRITE
3 | SYNC_FILE_RANGE_WAIT_AFTER
4 | 


--------------------------------------------------------------------------------
/xlat/sysctl_kern.in:
--------------------------------------------------------------------------------
 1 | KERN_OSTYPE
 2 | KERN_OSRELEASE
 3 | KERN_OSREV
 4 | KERN_VERSION
 5 | KERN_SECUREMASK
 6 | KERN_PROF
 7 | KERN_NODENAME
 8 | KERN_DOMAINNAME
 9 | KERN_PANIC
10 | KERN_REALROOTDEV
11 | KERN_SPARC_REBOOT
12 | KERN_CTLALTDEL
13 | KERN_PRINTK
14 | KERN_NAMETRANS
15 | KERN_PPC_HTABRECLAIM
16 | KERN_PPC_ZEROPAGED
17 | KERN_PPC_POWERSAVE_NAP
18 | KERN_MODPROBE
19 | KERN_SG_BIG_BUFF
20 | KERN_ACCT
21 | KERN_PPC_L2CR
22 | KERN_RTSIGNR
23 | KERN_RTSIGMAX
24 | KERN_SHMMAX
25 | KERN_MSGMAX
26 | KERN_MSGMNB
27 | KERN_MSGPOOL
28 | KERN_SYSRQ
29 | KERN_MAX_THREADS
30 | KERN_RANDOM
31 | KERN_SHMALL
32 | KERN_MSGMNI
33 | KERN_SEM
34 | KERN_SPARC_STOP_A
35 | KERN_SHMMNI
36 | KERN_OVERFLOWUID
37 | KERN_OVERFLOWGID
38 | KERN_SHMPATH
39 | KERN_HOTPLUG
40 | KERN_IEEE_EMULATION_WARNINGS
41 | KERN_S390_USER_DEBUG_LOGGING
42 | KERN_CORE_USES_PID
43 | KERN_TAINTED
44 | KERN_CADPID
45 | KERN_PIDMAX
46 | KERN_CORE_PATTERN
47 | KERN_PANIC_ON_OOPS
48 | KERN_HPPA_PWRSW
49 | KERN_HPPA_UNALIGNED
50 | KERN_PRINTK_RATELIMIT
51 | KERN_PRINTK_RATELIMIT_BURST
52 | KERN_PTY
53 | KERN_NGROUPS_MAX
54 | KERN_SPARC_SCONS_PWROFF
55 | KERN_HZ_TIMER
56 | KERN_UNKNOWN_NMI_PANIC
57 | KERN_BOOTLOADER_TYPE
58 | KERN_RANDOMIZE
59 | KERN_SETUID_DUMPABLE
60 | KERN_SPIN_RETRY
61 | KERN_ACPI_VIDEO_FLAGS
62 | KERN_IA64_UNALIGNED
63 | KERN_COMPAT_LOG
64 | KERN_MAX_LOCK_DEPTH
65 | KERN_NMI_WATCHDOG
66 | KERN_PANIC_ON_NMI
67 | 


--------------------------------------------------------------------------------
/xlat/sysctl_net.in:
--------------------------------------------------------------------------------
 1 | NET_CORE
 2 | NET_ETHER
 3 | NET_802
 4 | NET_UNIX
 5 | NET_IPV4
 6 | NET_IPX
 7 | NET_ATALK
 8 | NET_NETROM
 9 | NET_AX25
10 | NET_BRIDGE
11 | NET_ROSE
12 | NET_IPV6
13 | NET_X25
14 | NET_TR
15 | NET_DECNET
16 | NET_ECONET
17 | NET_SCTP
18 | NET_LLC
19 | NET_NETFILTER
20 | NET_DCCP
21 | NET_IRDA
22 | 


--------------------------------------------------------------------------------
/xlat/sysctl_net_core.in:
--------------------------------------------------------------------------------
 1 | NET_CORE_WMEM_MAX
 2 | NET_CORE_RMEM_MAX
 3 | NET_CORE_WMEM_DEFAULT
 4 | NET_CORE_RMEM_DEFAULT
 5 | NET_CORE_DESTROY_DELAY
 6 | NET_CORE_MAX_BACKLOG
 7 | NET_CORE_FASTROUTE
 8 | NET_CORE_MSG_COST
 9 | NET_CORE_MSG_BURST
10 | NET_CORE_OPTMEM_MAX
11 | NET_CORE_HOT_LIST_LENGTH
12 | NET_CORE_DIVERT_VERSION
13 | NET_CORE_NO_CONG_THRESH
14 | NET_CORE_NO_CONG
15 | NET_CORE_LO_CONG
16 | NET_CORE_MOD_CONG
17 | NET_CORE_DEV_WEIGHT
18 | NET_CORE_SOMAXCONN
19 | NET_CORE_BUDGET
20 | NET_CORE_AEVENT_ETIME
21 | NET_CORE_AEVENT_RSEQTH
22 | NET_CORE_WARNINGS
23 | 


--------------------------------------------------------------------------------
/xlat/sysctl_net_ipv4_conf.in:
--------------------------------------------------------------------------------
 1 | NET_IPV4_CONF_FORWARDING
 2 | NET_IPV4_CONF_MC_FORWARDING
 3 | NET_IPV4_CONF_PROXY_ARP
 4 | NET_IPV4_CONF_ACCEPT_REDIRECTS
 5 | NET_IPV4_CONF_SECURE_REDIRECTS
 6 | NET_IPV4_CONF_SEND_REDIRECTS
 7 | NET_IPV4_CONF_SHARED_MEDIA
 8 | NET_IPV4_CONF_RP_FILTER
 9 | NET_IPV4_CONF_ACCEPT_SOURCE_ROUTE
10 | NET_IPV4_CONF_BOOTP_RELAY
11 | NET_IPV4_CONF_LOG_MARTIANS
12 | NET_IPV4_CONF_TAG
13 | NET_IPV4_CONF_ARPFILTER
14 | NET_IPV4_CONF_MEDIUM_ID
15 | NET_IPV4_CONF_NOXFRM
16 | NET_IPV4_CONF_NOPOLICY
17 | NET_IPV4_CONF_FORCE_IGMP_VERSION
18 | NET_IPV4_CONF_ARP_ANNOUNCE
19 | NET_IPV4_CONF_ARP_IGNORE
20 | NET_IPV4_CONF_PROMOTE_SECONDARIES
21 | NET_IPV4_CONF_ARP_ACCEPT
22 | NET_IPV4_CONF_ARP_NOTIFY
23 | 


--------------------------------------------------------------------------------
/xlat/sysctl_net_ipv4_route.in:
--------------------------------------------------------------------------------
 1 | NET_IPV4_ROUTE_FLUSH
 2 | NET_IPV4_ROUTE_MIN_DELAY
 3 | NET_IPV4_ROUTE_MAX_DELAY
 4 | NET_IPV4_ROUTE_GC_THRESH
 5 | NET_IPV4_ROUTE_MAX_SIZE
 6 | NET_IPV4_ROUTE_GC_MIN_INTERVAL
 7 | NET_IPV4_ROUTE_GC_TIMEOUT
 8 | NET_IPV4_ROUTE_GC_INTERVAL
 9 | NET_IPV4_ROUTE_REDIRECT_LOAD
10 | NET_IPV4_ROUTE_REDIRECT_NUMBER
11 | NET_IPV4_ROUTE_REDIRECT_SILENCE
12 | NET_IPV4_ROUTE_ERROR_COST
13 | NET_IPV4_ROUTE_ERROR_BURST
14 | NET_IPV4_ROUTE_GC_ELASTICITY
15 | NET_IPV4_ROUTE_MTU_EXPIRES
16 | NET_IPV4_ROUTE_MIN_PMTU
17 | NET_IPV4_ROUTE_MIN_ADVMSS
18 | NET_IPV4_ROUTE_SECRET_INTERVAL
19 | NET_IPV4_ROUTE_GC_MIN_INTERVAL_MS
20 | 


--------------------------------------------------------------------------------
/xlat/sysctl_net_ipv6.in:
--------------------------------------------------------------------------------
 1 | NET_IPV6_CONF
 2 | NET_IPV6_NEIGH
 3 | NET_IPV6_ROUTE
 4 | NET_IPV6_ICMP
 5 | NET_IPV6_BINDV6ONLY
 6 | NET_IPV6_IP6FRAG_HIGH_THRESH
 7 | NET_IPV6_IP6FRAG_LOW_THRESH
 8 | NET_IPV6_IP6FRAG_TIME
 9 | NET_IPV6_IP6FRAG_SECRET_INTERVAL
10 | NET_IPV6_MLD_MAX_MSF
11 | 


--------------------------------------------------------------------------------
/xlat/sysctl_net_ipv6_route.in:
--------------------------------------------------------------------------------
 1 | NET_IPV6_ROUTE_FLUSH
 2 | NET_IPV6_ROUTE_GC_THRESH
 3 | NET_IPV6_ROUTE_MAX_SIZE
 4 | NET_IPV6_ROUTE_GC_MIN_INTERVAL
 5 | NET_IPV6_ROUTE_GC_TIMEOUT
 6 | NET_IPV6_ROUTE_GC_INTERVAL
 7 | NET_IPV6_ROUTE_GC_ELASTICITY
 8 | NET_IPV6_ROUTE_MTU_EXPIRES
 9 | NET_IPV6_ROUTE_MIN_ADVMSS
10 | NET_IPV6_ROUTE_GC_MIN_INTERVAL_MS
11 | 


--------------------------------------------------------------------------------
/xlat/sysctl_net_unix.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/sysctl_net_unix.in; do not edit. */
 2 | 
 3 | static const struct xlat sysctl_net_unix[] = {
 4 | #if defined(NET_UNIX_DESTROY_DELAY) || (defined(HAVE_DECL_NET_UNIX_DESTROY_DELAY) && HAVE_DECL_NET_UNIX_DESTROY_DELAY)
 5 | 	XLAT(NET_UNIX_DESTROY_DELAY),
 6 | #endif
 7 | #if defined(NET_UNIX_DELETE_DELAY) || (defined(HAVE_DECL_NET_UNIX_DELETE_DELAY) && HAVE_DECL_NET_UNIX_DELETE_DELAY)
 8 | 	XLAT(NET_UNIX_DELETE_DELAY),
 9 | #endif
10 | #if defined(NET_UNIX_MAX_DGRAM_QLEN) || (defined(HAVE_DECL_NET_UNIX_MAX_DGRAM_QLEN) && HAVE_DECL_NET_UNIX_MAX_DGRAM_QLEN)
11 | 	XLAT(NET_UNIX_MAX_DGRAM_QLEN),
12 | #endif
13 | 	XLAT_END
14 | };
15 | 


--------------------------------------------------------------------------------
/xlat/sysctl_net_unix.in:
--------------------------------------------------------------------------------
1 | NET_UNIX_DESTROY_DELAY
2 | NET_UNIX_DELETE_DELAY
3 | NET_UNIX_MAX_DGRAM_QLEN
4 | 


--------------------------------------------------------------------------------
/xlat/sysctl_root.in:
--------------------------------------------------------------------------------
 1 | CTL_KERN
 2 | CTL_VM
 3 | CTL_NET
 4 | CTL_PROC
 5 | CTL_FS
 6 | CTL_DEBUG
 7 | CTL_DEV
 8 | CTL_BUS
 9 | CTL_ABI
10 | CTL_CPU
11 | CTL_ARLAN
12 | CTL_S390DBF
13 | CTL_SUNRPC
14 | CTL_PM
15 | CTL_FRV
16 | 


--------------------------------------------------------------------------------
/xlat/sysctl_vm.in:
--------------------------------------------------------------------------------
 1 | VM_OVERCOMMIT_MEMORY
 2 | VM_PAGE_CLUSTER
 3 | VM_DIRTY_BACKGROUND
 4 | VM_DIRTY_RATIO
 5 | VM_DIRTY_WB_CS
 6 | VM_DIRTY_EXPIRE_CS
 7 | VM_NR_PDFLUSH_THREADS
 8 | VM_OVERCOMMIT_RATIO
 9 | VM_PAGEBUF
10 | VM_HUGETLB_PAGES
11 | VM_SWAPPINESS
12 | VM_LOWMEM_RESERVE_RATIO
13 | VM_MIN_FREE_KBYTES
14 | VM_MAX_MAP_COUNT
15 | VM_LAPTOP_MODE
16 | VM_BLOCK_DUMP
17 | VM_HUGETLB_GROUP
18 | VM_VFS_CACHE_PRESSURE
19 | VM_LEGACY_VA_LAYOUT
20 | VM_SWAP_TOKEN_TIMEOUT
21 | 


--------------------------------------------------------------------------------
/xlat/syslog_action_type.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/syslog_action_type.in; do not edit. */
 2 | 
 3 | static const struct xlat syslog_action_type[] = {
 4 | 	XLAT(SYSLOG_ACTION_CLOSE),
 5 | 	XLAT(SYSLOG_ACTION_OPEN),
 6 | 	XLAT(SYSLOG_ACTION_READ),
 7 | 	XLAT(SYSLOG_ACTION_READ_ALL),
 8 | 	XLAT(SYSLOG_ACTION_READ_CLEAR),
 9 | 	XLAT(SYSLOG_ACTION_CLEAR),
10 | 	XLAT(SYSLOG_ACTION_CONSOLE_OFF),
11 | 	XLAT(SYSLOG_ACTION_CONSOLE_ON),
12 | 	XLAT(SYSLOG_ACTION_CONSOLE_LEVEL),
13 | 	XLAT(SYSLOG_ACTION_SIZE_UNREAD),
14 | 	XLAT(SYSLOG_ACTION_SIZE_BUFFER),
15 | 	XLAT_END
16 | };
17 | 


--------------------------------------------------------------------------------
/xlat/syslog_action_type.in:
--------------------------------------------------------------------------------
 1 | #unconditional
 2 | SYSLOG_ACTION_CLOSE
 3 | SYSLOG_ACTION_OPEN
 4 | SYSLOG_ACTION_READ
 5 | SYSLOG_ACTION_READ_ALL
 6 | SYSLOG_ACTION_READ_CLEAR
 7 | SYSLOG_ACTION_CLEAR
 8 | SYSLOG_ACTION_CONSOLE_OFF
 9 | SYSLOG_ACTION_CONSOLE_ON
10 | SYSLOG_ACTION_CONSOLE_LEVEL
11 | SYSLOG_ACTION_SIZE_UNREAD
12 | SYSLOG_ACTION_SIZE_BUFFER
13 | 


--------------------------------------------------------------------------------
/xlat/sysmips_operations.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/sysmips_operations.in; do not edit. */
 2 | 
 3 | static const struct xlat sysmips_operations[] = {
 4 | #if defined(SETNAME) || (defined(HAVE_DECL_SETNAME) && HAVE_DECL_SETNAME)
 5 | 	XLAT(SETNAME),
 6 | #endif
 7 | #if defined(FLUSH_CACHE) || (defined(HAVE_DECL_FLUSH_CACHE) && HAVE_DECL_FLUSH_CACHE)
 8 | 	XLAT(FLUSH_CACHE),
 9 | #endif
10 | #if defined(MIPS_FIXADE) || (defined(HAVE_DECL_MIPS_FIXADE) && HAVE_DECL_MIPS_FIXADE)
11 | 	XLAT(MIPS_FIXADE),
12 | #endif
13 | #if defined(MIPS_RDNVRAM) || (defined(HAVE_DECL_MIPS_RDNVRAM) && HAVE_DECL_MIPS_RDNVRAM)
14 | 	XLAT(MIPS_RDNVRAM),
15 | #endif
16 | #if defined(MIPS_ATOMIC_SET) || (defined(HAVE_DECL_MIPS_ATOMIC_SET) && HAVE_DECL_MIPS_ATOMIC_SET)
17 | 	XLAT(MIPS_ATOMIC_SET),
18 | #endif
19 | 	XLAT_END
20 | };
21 | 


--------------------------------------------------------------------------------
/xlat/sysmips_operations.in:
--------------------------------------------------------------------------------
1 | SETNAME
2 | FLUSH_CACHE
3 | MIPS_FIXADE
4 | MIPS_RDNVRAM
5 | MIPS_ATOMIC_SET
6 | 


--------------------------------------------------------------------------------
/xlat/tcflsh_options.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/tcflsh_options.in; do not edit. */
 2 | 
 3 | static const struct xlat tcflsh_options[] = {
 4 | #if defined(TCIFLUSH) || (defined(HAVE_DECL_TCIFLUSH) && HAVE_DECL_TCIFLUSH)
 5 | 	XLAT(TCIFLUSH),
 6 | #endif
 7 | #if defined(TCOFLUSH) || (defined(HAVE_DECL_TCOFLUSH) && HAVE_DECL_TCOFLUSH)
 8 | 	XLAT(TCOFLUSH),
 9 | #endif
10 | #if defined(TCIOFLUSH) || (defined(HAVE_DECL_TCIOFLUSH) && HAVE_DECL_TCIOFLUSH)
11 | 	XLAT(TCIOFLUSH),
12 | #endif
13 | 	XLAT_END
14 | };
15 | 


--------------------------------------------------------------------------------
/xlat/tcflsh_options.in:
--------------------------------------------------------------------------------
1 | TCIFLUSH
2 | TCOFLUSH
3 | TCIOFLUSH
4 | 


--------------------------------------------------------------------------------
/xlat/tcxonc_options.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/tcxonc_options.in; do not edit. */
 2 | 
 3 | static const struct xlat tcxonc_options[] = {
 4 | #if defined(TCOOFF) || (defined(HAVE_DECL_TCOOFF) && HAVE_DECL_TCOOFF)
 5 | 	XLAT(TCOOFF),
 6 | #endif
 7 | #if defined(TCOON) || (defined(HAVE_DECL_TCOON) && HAVE_DECL_TCOON)
 8 | 	XLAT(TCOON),
 9 | #endif
10 | #if defined(TCIOFF) || (defined(HAVE_DECL_TCIOFF) && HAVE_DECL_TCIOFF)
11 | 	XLAT(TCIOFF),
12 | #endif
13 | #if defined(TCION) || (defined(HAVE_DECL_TCION) && HAVE_DECL_TCION)
14 | 	XLAT(TCION),
15 | #endif
16 | 	XLAT_END
17 | };
18 | 


--------------------------------------------------------------------------------
/xlat/tcxonc_options.in:
--------------------------------------------------------------------------------
1 | TCOOFF
2 | TCOON
3 | TCIOFF
4 | TCION
5 | 


--------------------------------------------------------------------------------
/xlat/timerfdflags.h:
--------------------------------------------------------------------------------
1 | /* Generated by ./xlat/gen.sh from ./xlat/timerfdflags.in; do not edit. */
2 | 
3 | static const struct xlat timerfdflags[] = {
4 | #if defined(TFD_TIMER_ABSTIME) || (defined(HAVE_DECL_TFD_TIMER_ABSTIME) && HAVE_DECL_TFD_TIMER_ABSTIME)
5 | 	XLAT(TFD_TIMER_ABSTIME),
6 | #endif
7 | 	XLAT_END
8 | };
9 | 


--------------------------------------------------------------------------------
/xlat/timerfdflags.in:
--------------------------------------------------------------------------------
1 | TFD_TIMER_ABSTIME
2 | 


--------------------------------------------------------------------------------
/xlat/ubi_volume_props.h:
--------------------------------------------------------------------------------
1 | /* Generated by ./xlat/gen.sh from ./xlat/ubi_volume_props.in; do not edit. */
2 | 
3 | static const struct xlat ubi_volume_props[] = {
4 | 	XLAT(UBI_VOL_PROP_DIRECT_WRITE),
5 | 	XLAT_END
6 | };
7 | 


--------------------------------------------------------------------------------
/xlat/ubi_volume_props.in:
--------------------------------------------------------------------------------
1 | #unconditional
2 | UBI_VOL_PROP_DIRECT_WRITE
3 | 


--------------------------------------------------------------------------------
/xlat/ubi_volume_types.h:
--------------------------------------------------------------------------------
1 | /* Generated by ./xlat/gen.sh from ./xlat/ubi_volume_types.in; do not edit. */
2 | 
3 | static const struct xlat ubi_volume_types[] = {
4 | 	XLAT(UBI_DYNAMIC_VOLUME),
5 | 	XLAT(UBI_STATIC_VOLUME),
6 | 	XLAT_END
7 | };
8 | 


--------------------------------------------------------------------------------
/xlat/ubi_volume_types.in:
--------------------------------------------------------------------------------
1 | #unconditional
2 | UBI_DYNAMIC_VOLUME
3 | UBI_STATIC_VOLUME
4 | 


--------------------------------------------------------------------------------
/xlat/umount_flags.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/umount_flags.in; do not edit. */
 2 | 
 3 | static const struct xlat umount_flags[] = {
 4 | #if defined(MNT_FORCE) || (defined(HAVE_DECL_MNT_FORCE) && HAVE_DECL_MNT_FORCE)
 5 | 	XLAT(MNT_FORCE),
 6 | #endif
 7 | #if defined(MNT_DETACH) || (defined(HAVE_DECL_MNT_DETACH) && HAVE_DECL_MNT_DETACH)
 8 | 	XLAT(MNT_DETACH),
 9 | #endif
10 | #if defined(MNT_EXPIRE) || (defined(HAVE_DECL_MNT_EXPIRE) && HAVE_DECL_MNT_EXPIRE)
11 | 	XLAT(MNT_EXPIRE),
12 | #endif
13 | 	XLAT_END
14 | };
15 | 


--------------------------------------------------------------------------------
/xlat/umount_flags.in:
--------------------------------------------------------------------------------
1 | MNT_FORCE
2 | MNT_DETACH
3 | MNT_EXPIRE
4 | 


--------------------------------------------------------------------------------
/xlat/usagewho.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/usagewho.in; do not edit. */
 2 | 
 3 | static const struct xlat usagewho[] = {
 4 | #if defined(RUSAGE_SELF) || (defined(HAVE_DECL_RUSAGE_SELF) && HAVE_DECL_RUSAGE_SELF)
 5 | 	XLAT(RUSAGE_SELF),
 6 | #endif
 7 | #if defined(RUSAGE_CHILDREN) || (defined(HAVE_DECL_RUSAGE_CHILDREN) && HAVE_DECL_RUSAGE_CHILDREN)
 8 | 	XLAT(RUSAGE_CHILDREN),
 9 | #endif
10 | #if defined(RUSAGE_BOTH) || (defined(HAVE_DECL_RUSAGE_BOTH) && HAVE_DECL_RUSAGE_BOTH)
11 | 	XLAT(RUSAGE_BOTH),
12 | #endif
13 | 	XLAT_END
14 | };
15 | 


--------------------------------------------------------------------------------
/xlat/usagewho.in:
--------------------------------------------------------------------------------
1 | RUSAGE_SELF
2 | RUSAGE_CHILDREN
3 | RUSAGE_BOTH
4 | 


--------------------------------------------------------------------------------
/xlat/wait4_options.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/wait4_options.in; do not edit. */
 2 | 
 3 | static const struct xlat wait4_options[] = {
 4 | #if defined(WNOHANG) || (defined(HAVE_DECL_WNOHANG) && HAVE_DECL_WNOHANG)
 5 | 	XLAT(WNOHANG),
 6 | #endif
 7 | #ifndef WSTOPPED
 8 | #if defined(WUNTRACED) || (defined(HAVE_DECL_WUNTRACED) && HAVE_DECL_WUNTRACED)
 9 | 	XLAT(WUNTRACED),
10 | #endif
11 | #endif
12 | #if defined(WEXITED) || (defined(HAVE_DECL_WEXITED) && HAVE_DECL_WEXITED)
13 | 	XLAT(WEXITED),
14 | #endif
15 | #if defined(WTRAPPED) || (defined(HAVE_DECL_WTRAPPED) && HAVE_DECL_WTRAPPED)
16 | 	XLAT(WTRAPPED),
17 | #endif
18 | #if defined(WSTOPPED) || (defined(HAVE_DECL_WSTOPPED) && HAVE_DECL_WSTOPPED)
19 | 	XLAT(WSTOPPED),
20 | #endif
21 | #if defined(WCONTINUED) || (defined(HAVE_DECL_WCONTINUED) && HAVE_DECL_WCONTINUED)
22 | 	XLAT(WCONTINUED),
23 | #endif
24 | #if defined(WNOWAIT) || (defined(HAVE_DECL_WNOWAIT) && HAVE_DECL_WNOWAIT)
25 | 	XLAT(WNOWAIT),
26 | #endif
27 | #if defined(__WCLONE) || (defined(HAVE_DECL___WCLONE) && HAVE_DECL___WCLONE)
28 | 	XLAT(__WCLONE),
29 | #endif
30 | #if defined(__WALL) || (defined(HAVE_DECL___WALL) && HAVE_DECL___WALL)
31 | 	XLAT(__WALL),
32 | #endif
33 | #if defined(__WNOTHREAD) || (defined(HAVE_DECL___WNOTHREAD) && HAVE_DECL___WNOTHREAD)
34 | 	XLAT(__WNOTHREAD),
35 | #endif
36 | 	XLAT_END
37 | };
38 | 


--------------------------------------------------------------------------------
/xlat/wait4_options.in:
--------------------------------------------------------------------------------
 1 | WNOHANG
 2 | #ifndef WSTOPPED
 3 | WUNTRACED
 4 | #endif
 5 | WEXITED
 6 | WTRAPPED
 7 | WSTOPPED
 8 | WCONTINUED
 9 | WNOWAIT
10 | __WCLONE
11 | __WALL
12 | __WNOTHREAD
13 | 


--------------------------------------------------------------------------------
/xlat/waitid_types.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/waitid_types.in; do not edit. */
 2 | 
 3 | static const struct xlat waitid_types[] = {
 4 | #if defined(P_PID) || (defined(HAVE_DECL_P_PID) && HAVE_DECL_P_PID)
 5 | 	XLAT(P_PID),
 6 | #endif
 7 | #if defined(P_PPID) || (defined(HAVE_DECL_P_PPID) && HAVE_DECL_P_PPID)
 8 | 	XLAT(P_PPID),
 9 | #endif
10 | #if defined(P_PGID) || (defined(HAVE_DECL_P_PGID) && HAVE_DECL_P_PGID)
11 | 	XLAT(P_PGID),
12 | #endif
13 | #if defined(P_SID) || (defined(HAVE_DECL_P_SID) && HAVE_DECL_P_SID)
14 | 	XLAT(P_SID),
15 | #endif
16 | #if defined(P_CID) || (defined(HAVE_DECL_P_CID) && HAVE_DECL_P_CID)
17 | 	XLAT(P_CID),
18 | #endif
19 | #if defined(P_UID) || (defined(HAVE_DECL_P_UID) && HAVE_DECL_P_UID)
20 | 	XLAT(P_UID),
21 | #endif
22 | #if defined(P_GID) || (defined(HAVE_DECL_P_GID) && HAVE_DECL_P_GID)
23 | 	XLAT(P_GID),
24 | #endif
25 | #if defined(P_ALL) || (defined(HAVE_DECL_P_ALL) && HAVE_DECL_P_ALL)
26 | 	XLAT(P_ALL),
27 | #endif
28 | #if defined(P_LWPID) || (defined(HAVE_DECL_P_LWPID) && HAVE_DECL_P_LWPID)
29 | 	XLAT(P_LWPID),
30 | #endif
31 | 	XLAT_END
32 | };
33 | 


--------------------------------------------------------------------------------
/xlat/waitid_types.in:
--------------------------------------------------------------------------------
 1 | P_PID
 2 | P_PPID
 3 | P_PGID
 4 | P_SID
 5 | P_CID
 6 | P_UID
 7 | P_GID
 8 | P_ALL
 9 | P_LWPID
10 | 


--------------------------------------------------------------------------------
/xlat/whence_codes.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/whence_codes.in; do not edit. */
 2 | 
 3 | const struct xlat whence_codes[] = {
 4 | #if defined(SEEK_SET) || (defined(HAVE_DECL_SEEK_SET) && HAVE_DECL_SEEK_SET)
 5 | 	XLAT(SEEK_SET),
 6 | #endif
 7 | #if defined(SEEK_CUR) || (defined(HAVE_DECL_SEEK_CUR) && HAVE_DECL_SEEK_CUR)
 8 | 	XLAT(SEEK_CUR),
 9 | #endif
10 | #if defined(SEEK_END) || (defined(HAVE_DECL_SEEK_END) && HAVE_DECL_SEEK_END)
11 | 	XLAT(SEEK_END),
12 | #endif
13 | #if defined(SEEK_DATA) || (defined(HAVE_DECL_SEEK_DATA) && HAVE_DECL_SEEK_DATA)
14 | 	XLAT(SEEK_DATA),
15 | #endif
16 | #if defined(SEEK_HOLE) || (defined(HAVE_DECL_SEEK_HOLE) && HAVE_DECL_SEEK_HOLE)
17 | 	XLAT(SEEK_HOLE),
18 | #endif
19 | 	XLAT_END
20 | };
21 | 


--------------------------------------------------------------------------------
/xlat/whence_codes.in:
--------------------------------------------------------------------------------
1 | SEEK_SET
2 | SEEK_CUR
3 | SEEK_END
4 | SEEK_DATA
5 | SEEK_HOLE
6 | 


--------------------------------------------------------------------------------
/xlat/xattrflags.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/xattrflags.in; do not edit. */
 2 | 
 3 | static const struct xlat xattrflags[] = {
 4 | #if defined(XATTR_CREATE) || (defined(HAVE_DECL_XATTR_CREATE) && HAVE_DECL_XATTR_CREATE)
 5 | 	XLAT(XATTR_CREATE),
 6 | #endif
 7 | #if defined(XATTR_REPLACE) || (defined(HAVE_DECL_XATTR_REPLACE) && HAVE_DECL_XATTR_REPLACE)
 8 | 	XLAT(XATTR_REPLACE),
 9 | #endif
10 | 	XLAT_END
11 | };
12 | 


--------------------------------------------------------------------------------
/xlat/xattrflags.in:
--------------------------------------------------------------------------------
1 | XATTR_CREATE
2 | XATTR_REPLACE
3 | 


--------------------------------------------------------------------------------
/xlat/xfs_dqblk_flags.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/xfs_dqblk_flags.in; do not edit. */
 2 | 
 3 | static const struct xlat xfs_dqblk_flags[] = {
 4 | #if defined(XFS_USER_QUOTA) || (defined(HAVE_DECL_XFS_USER_QUOTA) && HAVE_DECL_XFS_USER_QUOTA)
 5 | 	XLAT(XFS_USER_QUOTA),
 6 | #endif
 7 | #if defined(XFS_PROJ_QUOTA) || (defined(HAVE_DECL_XFS_PROJ_QUOTA) && HAVE_DECL_XFS_PROJ_QUOTA)
 8 | 	XLAT(XFS_PROJ_QUOTA),
 9 | #endif
10 | #if defined(XFS_GROUP_QUOTA) || (defined(HAVE_DECL_XFS_GROUP_QUOTA) && HAVE_DECL_XFS_GROUP_QUOTA)
11 | 	XLAT(XFS_GROUP_QUOTA),
12 | #endif
13 | 	XLAT_END
14 | };
15 | 


--------------------------------------------------------------------------------
/xlat/xfs_dqblk_flags.in:
--------------------------------------------------------------------------------
1 | XFS_USER_QUOTA
2 | XFS_PROJ_QUOTA
3 | XFS_GROUP_QUOTA
4 | 


--------------------------------------------------------------------------------
/xlat/xfs_quota_flags.h:
--------------------------------------------------------------------------------
 1 | /* Generated by ./xlat/gen.sh from ./xlat/xfs_quota_flags.in; do not edit. */
 2 | 
 3 | static const struct xlat xfs_quota_flags[] = {
 4 | #if defined(XFS_QUOTA_UDQ_ACCT) || (defined(HAVE_DECL_XFS_QUOTA_UDQ_ACCT) && HAVE_DECL_XFS_QUOTA_UDQ_ACCT)
 5 | 	XLAT(XFS_QUOTA_UDQ_ACCT),
 6 | #endif
 7 | #if defined(XFS_QUOTA_UDQ_ENFD) || (defined(HAVE_DECL_XFS_QUOTA_UDQ_ENFD) && HAVE_DECL_XFS_QUOTA_UDQ_ENFD)
 8 | 	XLAT(XFS_QUOTA_UDQ_ENFD),
 9 | #endif
10 | #if defined(XFS_QUOTA_GDQ_ACCT) || (defined(HAVE_DECL_XFS_QUOTA_GDQ_ACCT) && HAVE_DECL_XFS_QUOTA_GDQ_ACCT)
11 | 	XLAT(XFS_QUOTA_GDQ_ACCT),
12 | #endif
13 | #if defined(XFS_QUOTA_GDQ_ENFD) || (defined(HAVE_DECL_XFS_QUOTA_GDQ_ENFD) && HAVE_DECL_XFS_QUOTA_GDQ_ENFD)
14 | 	XLAT(XFS_QUOTA_GDQ_ENFD),
15 | #endif
16 | 	XLAT_END
17 | };
18 | 


--------------------------------------------------------------------------------
/xlat/xfs_quota_flags.in:
--------------------------------------------------------------------------------
1 | XFS_QUOTA_UDQ_ACCT
2 | XFS_QUOTA_UDQ_ENFD
3 | XFS_QUOTA_GDQ_ACCT
4 | XFS_QUOTA_GDQ_ENFD
5 | 


--------------------------------------------------------------------------------