glebfm/strace
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Use XLAT macro

Browse Source 
Automatically convert all xlat structures to XLAT form
using the following sed regexp:
s/^[[:space:]]*{[[:space:]]*\([^",}[:space:]]\+\)[[:space:]]*,[[:space:]]*"\1",\?[[:space:]]*}[[:space:]]*/\tXLAT(\1)/
This commit is contained in:
Дмитрий Левин 2014-02-05 01:33:50 +00:00
parent a69ddcb672
commit bce0cc6a2d
21 changed files with 1564 additions and 1564 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
bjm.c
View File

@ -70,23 +70,23 @@ struct module_info
};
static const struct xlat which[] = {
{ 0, "0" },
{ QM_MODULES, "QM_MODULES" },
{ QM_DEPS, "QM_DEPS" },
{ QM_REFS, "QM_REFS" },
{ QM_SYMBOLS, "QM_SYMBOLS" },
{ QM_INFO, "QM_INFO" },
XLAT(0),
XLAT(QM_MODULES),
XLAT(QM_DEPS),
XLAT(QM_REFS),
XLAT(QM_SYMBOLS),
XLAT(QM_INFO),
{ 0, NULL },
};
static const struct xlat modflags[] = {
{ MOD_UNINITIALIZED, "MOD_UNINITIALIZED" },
{ MOD_RUNNING, "MOD_RUNNING" },
{ MOD_DELETED, "MOD_DELETED" },
{ MOD_AUTOCLEAN, "MOD_AUTOCLEAN" },
{ MOD_VISITED, "MOD_VISITED" },
{ MOD_USED_ONCE, "MOD_USED_ONCE" },
{ MOD_JUST_FREED, "MOD_JUST_FREED" },
XLAT(MOD_UNINITIALIZED),
XLAT(MOD_RUNNING),
XLAT(MOD_DELETED),
XLAT(MOD_AUTOCLEAN),
XLAT(MOD_VISITED),
XLAT(MOD_USED_ONCE),
XLAT(MOD_JUST_FREED),
{ 0, NULL },
};

4
block.c
View File

@ -80,8 +80,8 @@ struct blk_user_trace_setup {
#endif
static const struct xlat blkpg_ops[] = {
{ BLKPG_ADD_PARTITION, "BLKPG_ADD_PARTITION", },
{ BLKPG_DEL_PARTITION, "BLKPG_DEL_PARTITION", },
XLAT(BLKPG_ADD_PARTITION),
XLAT(BLKPG_DEL_PARTITION),
{ 0, NULL },
};

160
desc.c
View File

@ -39,118 +39,118 @@
#endif
static const struct xlat fcntlcmds[] = {
{ F_DUPFD, "F_DUPFD" },
{ F_GETFD, "F_GETFD" },
{ F_SETFD, "F_SETFD" },
{ F_GETFL, "F_GETFL" },
{ F_SETFL, "F_SETFL" },
{ F_GETLK, "F_GETLK" },
{ F_SETLK, "F_SETLK" },
{ F_SETLKW, "F_SETLKW" },
{ F_GETOWN, "F_GETOWN" },
{ F_SETOWN, "F_SETOWN" },
XLAT(F_DUPFD),
XLAT(F_GETFD),
XLAT(F_SETFD),
XLAT(F_GETFL),
XLAT(F_SETFL),
XLAT(F_GETLK),
XLAT(F_SETLK),
XLAT(F_SETLKW),
XLAT(F_GETOWN),
XLAT(F_SETOWN),
#ifdef F_RSETLK
{ F_RSETLK, "F_RSETLK" },
XLAT(F_RSETLK),
#endif
#ifdef F_RSETLKW
{ F_RSETLKW, "F_RSETLKW" },
XLAT(F_RSETLKW),
#endif
#ifdef F_RGETLK
{ F_RGETLK, "F_RGETLK" },
XLAT(F_RGETLK),
#endif
#ifdef F_CNVT
{ F_CNVT, "F_CNVT" },
XLAT(F_CNVT),
#endif
#ifdef F_SETSIG
{ F_SETSIG, "F_SETSIG" },
XLAT(F_SETSIG),
#endif
#ifdef F_GETSIG
{ F_GETSIG, "F_GETSIG" },
XLAT(F_GETSIG),
#endif
#ifdef F_CHKFL
{ F_CHKFL, "F_CHKFL" },
XLAT(F_CHKFL),
#endif
#ifdef F_DUP2FD
{ F_DUP2FD, "F_DUP2FD" },
XLAT(F_DUP2FD),
#endif
#ifdef F_ALLOCSP
{ F_ALLOCSP, "F_ALLOCSP" },
XLAT(F_ALLOCSP),
#endif
#ifdef F_ISSTREAM
{ F_ISSTREAM, "F_ISSTREAM" },
XLAT(F_ISSTREAM),
#endif
#ifdef F_PRIV
{ F_PRIV, "F_PRIV" },
XLAT(F_PRIV),
#endif
#ifdef F_NPRIV
{ F_NPRIV, "F_NPRIV" },
XLAT(F_NPRIV),
#endif
#ifdef F_QUOTACL
{ F_QUOTACL, "F_QUOTACL" },
XLAT(F_QUOTACL),
#endif
#ifdef F_BLOCKS
{ F_BLOCKS, "F_BLOCKS" },
XLAT(F_BLOCKS),
#endif
#ifdef F_BLKSIZE
{ F_BLKSIZE, "F_BLKSIZE" },
XLAT(F_BLKSIZE),
#endif
#ifdef F_GETOWN
{ F_GETOWN, "F_GETOWN" },
XLAT(F_GETOWN),
#endif
#ifdef F_SETOWN
{ F_SETOWN, "F_SETOWN" },
XLAT(F_SETOWN),
#endif
#ifdef F_REVOKE
{ F_REVOKE, "F_REVOKE" },
XLAT(F_REVOKE),
#endif
#ifdef F_SETLK
{ F_SETLK, "F_SETLK" },
XLAT(F_SETLK),
#endif
#ifdef F_SETLKW
{ F_SETLKW, "F_SETLKW" },
XLAT(F_SETLKW),
#endif
#ifdef F_FREESP
{ F_FREESP, "F_FREESP" },
XLAT(F_FREESP),
#endif
#ifdef F_GETLK
{ F_GETLK, "F_GETLK" },
XLAT(F_GETLK),
#endif
#ifdef F_SETLK64
{ F_SETLK64, "F_SETLK64" },
XLAT(F_SETLK64),
#endif
#ifdef F_SETLKW64
{ F_SETLKW64, "F_SETLKW64" },
XLAT(F_SETLKW64),
#endif
#ifdef F_FREESP64
{ F_FREESP64, "F_FREESP64" },
XLAT(F_FREESP64),
#endif
#ifdef F_GETLK64
{ F_GETLK64, "F_GETLK64" },
XLAT(F_GETLK64),
#endif
#ifdef F_SHARE
{ F_SHARE, "F_SHARE" },
XLAT(F_SHARE),
#endif
#ifdef F_UNSHARE
{ F_UNSHARE, "F_UNSHARE" },
XLAT(F_UNSHARE),
#endif
#ifdef F_SETLEASE
{ F_SETLEASE, "F_SETLEASE" },
XLAT(F_SETLEASE),
#endif
#ifdef F_GETLEASE
{ F_GETLEASE, "F_GETLEASE" },
XLAT(F_GETLEASE),
#endif
#ifdef F_NOTIFY
{ F_NOTIFY, "F_NOTIFY" },
XLAT(F_NOTIFY),
#endif
#ifdef F_DUPFD_CLOEXEC
{ F_DUPFD_CLOEXEC,"F_DUPFD_CLOEXEC"},
XLAT(F_DUPFD_CLOEXEC),
#endif
{ 0, NULL },
};
static const struct xlat fdflags[] = {
#ifdef FD_CLOEXEC
{ FD_CLOEXEC, "FD_CLOEXEC" },
XLAT(FD_CLOEXEC),
#endif
{ 0, NULL },
};
@ -158,24 +158,24 @@ static const struct xlat fdflags[] = {
#ifdef LOCK_SH
static const struct xlat flockcmds[] = {
{ LOCK_SH, "LOCK_SH" },
{ LOCK_EX, "LOCK_EX" },
{ LOCK_NB, "LOCK_NB" },
{ LOCK_UN, "LOCK_UN" },
XLAT(LOCK_SH),
XLAT(LOCK_EX),
XLAT(LOCK_NB),
XLAT(LOCK_UN),
{ 0, NULL },
};
#endif /* LOCK_SH */
static const struct xlat lockfcmds[] = {
{ F_RDLCK, "F_RDLCK" },
{ F_WRLCK, "F_WRLCK" },
{ F_UNLCK, "F_UNLCK" },
XLAT(F_RDLCK),
XLAT(F_WRLCK),
XLAT(F_UNLCK),
#ifdef F_EXLCK
{ F_EXLCK, "F_EXLCK" },
XLAT(F_EXLCK),
#endif
#ifdef F_SHLCK
{ F_SHLCK, "F_SHLCK" },
XLAT(F_SHLCK),
#endif
{ 0, NULL },
};
@ -183,25 +183,25 @@ static const struct xlat lockfcmds[] = {
#ifdef F_NOTIFY
static const struct xlat notifyflags[] = {
#ifdef DN_ACCESS
{ DN_ACCESS, "DN_ACCESS" },
XLAT(DN_ACCESS),
#endif
#ifdef DN_MODIFY
{ DN_MODIFY, "DN_MODIFY" },
XLAT(DN_MODIFY),
#endif
#ifdef DN_CREATE
{ DN_CREATE, "DN_CREATE" },
XLAT(DN_CREATE),
#endif
#ifdef DN_DELETE
{ DN_DELETE, "DN_DELETE" },
XLAT(DN_DELETE),
#endif
#ifdef DN_RENAME
{ DN_RENAME, "DN_RENAME" },
XLAT(DN_RENAME),
#endif
#ifdef DN_ATTRIB
{ DN_ATTRIB, "DN_ATTRIB" },
XLAT(DN_ATTRIB),
#endif
#ifdef DN_MULTISHOT
{ DN_MULTISHOT, "DN_MULTISHOT" },
XLAT(DN_MULTISHOT),
#endif
{ 0, NULL },
};
@ -209,13 +209,13 @@ static const struct xlat notifyflags[] = {
static const struct xlat perf_event_open_flags[] = {
#ifdef PERF_FLAG_FD_NO_GROUP
{ PERF_FLAG_FD_NO_GROUP, "PERF_FLAG_FD_NO_GROUP" },
XLAT(PERF_FLAG_FD_NO_GROUP),
#endif
#ifdef PERF_FLAG_FD_OUTPUT
{ PERF_FLAG_FD_OUTPUT, "PERF_FLAG_FD_OUTPUT" },
XLAT(PERF_FLAG_FD_OUTPUT),
#endif
#ifdef PERF_FLAG_PID_CGROUP
{ PERF_FLAG_PID_CGROUP, "PERF_FLAG_PID_CGROUP" },
XLAT(PERF_FLAG_PID_CGROUP),
#endif
{ 0, NULL },
};
@ -655,56 +655,56 @@ sys_osf_select(struct tcb *tcp)
static const struct xlat epollctls[] = {
#ifdef EPOLL_CTL_ADD
{ EPOLL_CTL_ADD, "EPOLL_CTL_ADD" },
XLAT(EPOLL_CTL_ADD),
#endif
#ifdef EPOLL_CTL_MOD
{ EPOLL_CTL_MOD, "EPOLL_CTL_MOD" },
XLAT(EPOLL_CTL_MOD),
#endif
#ifdef EPOLL_CTL_DEL
{ EPOLL_CTL_DEL, "EPOLL_CTL_DEL" },
XLAT(EPOLL_CTL_DEL),
#endif
{ 0, NULL }
};
static const struct xlat epollevents[] = {
#ifdef EPOLLIN
{ EPOLLIN, "EPOLLIN" },
XLAT(EPOLLIN),
#endif
#ifdef EPOLLPRI
{ EPOLLPRI, "EPOLLPRI" },
XLAT(EPOLLPRI),
#endif
#ifdef EPOLLOUT
{ EPOLLOUT, "EPOLLOUT" },
XLAT(EPOLLOUT),
#endif
#ifdef EPOLLRDNORM
{ EPOLLRDNORM, "EPOLLRDNORM" },
XLAT(EPOLLRDNORM),
#endif
#ifdef EPOLLRDBAND
{ EPOLLRDBAND, "EPOLLRDBAND" },
XLAT(EPOLLRDBAND),
#endif
#ifdef EPOLLWRNORM
{ EPOLLWRNORM, "EPOLLWRNORM" },
XLAT(EPOLLWRNORM),
#endif
#ifdef EPOLLWRBAND
{ EPOLLWRBAND, "EPOLLWRBAND" },
XLAT(EPOLLWRBAND),
#endif
#ifdef EPOLLMSG
{ EPOLLMSG, "EPOLLMSG" },
XLAT(EPOLLMSG),
#endif
#ifdef EPOLLERR
{ EPOLLERR, "EPOLLERR" },
XLAT(EPOLLERR),
#endif
#ifdef EPOLLHUP
{ EPOLLHUP, "EPOLLHUP" },
XLAT(EPOLLHUP),
#endif
#ifdef EPOLLRDHUP
{ EPOLLRDHUP, "EPOLLRDHUP" },
XLAT(EPOLLRDHUP),
#endif
#ifdef EPOLLONESHOT
{ EPOLLONESHOT, "EPOLLONESHOT" },
XLAT(EPOLLONESHOT),
#endif
#ifdef EPOLLET
{ EPOLLET, "EPOLLET" },
XLAT(EPOLLET),
#endif
{ 0, NULL }
};
@ -718,10 +718,10 @@ sys_epoll_create(struct tcb *tcp)
static const struct xlat epollflags[] = {
#ifdef EPOLL_CLOEXEC
{ EPOLL_CLOEXEC, "EPOLL_CLOEXEC" },
XLAT(EPOLL_CLOEXEC),
#endif
#ifdef EPOLL_NONBLOCK
{ EPOLL_NONBLOCK, "EPOLL_NONBLOCK" },
XLAT(EPOLL_NONBLOCK),
#endif
{ 0, NULL }
};

184
file.c
View File

@ -212,42 +212,42 @@ struct kernel_dirent {
};
const struct xlat open_access_modes[] = {
{ O_RDONLY, "O_RDONLY" },
{ O_WRONLY, "O_WRONLY" },
{ O_RDWR, "O_RDWR" },
XLAT(O_RDONLY),
XLAT(O_WRONLY),
XLAT(O_RDWR),
#ifdef O_ACCMODE
{ O_ACCMODE, "O_ACCMODE" },
XLAT(O_ACCMODE),
#endif
{ 0, NULL },
};
const struct xlat open_mode_flags[] = {
{ O_CREAT, "O_CREAT" },
{ O_EXCL, "O_EXCL" },
{ O_NOCTTY, "O_NOCTTY" },
{ O_TRUNC, "O_TRUNC" },
{ O_APPEND, "O_APPEND" },
{ O_NONBLOCK, "O_NONBLOCK" },
XLAT(O_CREAT),
XLAT(O_EXCL),
XLAT(O_NOCTTY),
XLAT(O_TRUNC),
XLAT(O_APPEND),
XLAT(O_NONBLOCK),
#ifdef O_SYNC
{ O_SYNC, "O_SYNC" },
XLAT(O_SYNC),
#endif
#ifdef O_ASYNC
{ O_ASYNC, "O_ASYNC" },
XLAT(O_ASYNC),
#endif
#ifdef O_DSYNC
{ O_DSYNC, "O_DSYNC" },
XLAT(O_DSYNC),
#endif
#ifdef O_RSYNC
{ O_RSYNC, "O_RSYNC" },
XLAT(O_RSYNC),
#endif
#if defined(O_NDELAY) && (O_NDELAY != O_NONBLOCK)
{ O_NDELAY, "O_NDELAY" },
XLAT(O_NDELAY),
#endif
#ifdef O_PRIV
{ O_PRIV, "O_PRIV" },
XLAT(O_PRIV),
#endif
#ifdef O_DIRECT
{ O_DIRECT, "O_DIRECT" },
XLAT(O_DIRECT),
#endif
#ifdef O_LARGEFILE
# if O_LARGEFILE == 0 /* biarch platforms in 64-bit mode */
@ -259,68 +259,68 @@ const struct xlat open_mode_flags[] = {
# endif
# endif
# ifdef O_LARGEFILE
{ O_LARGEFILE, "O_LARGEFILE" },
XLAT(O_LARGEFILE),
# endif
#endif
#ifdef O_DIRECTORY
{ O_DIRECTORY, "O_DIRECTORY" },
XLAT(O_DIRECTORY),
#endif
#ifdef O_NOFOLLOW
{ O_NOFOLLOW, "O_NOFOLLOW" },
XLAT(O_NOFOLLOW),
#endif
#ifdef O_NOATIME
{ O_NOATIME, "O_NOATIME" },
XLAT(O_NOATIME),
#endif
#ifdef O_CLOEXEC
{ O_CLOEXEC, "O_CLOEXEC" },
XLAT(O_CLOEXEC),
#endif
#ifdef O_PATH
{ O_PATH, "O_PATH" },
XLAT(O_PATH),
#endif
#ifdef FNDELAY
{ FNDELAY, "FNDELAY" },
XLAT(FNDELAY),
#endif
#ifdef FAPPEND
{ FAPPEND, "FAPPEND" },
XLAT(FAPPEND),
#endif
#ifdef FMARK
{ FMARK, "FMARK" },
XLAT(FMARK),
#endif
#ifdef FDEFER
{ FDEFER, "FDEFER" },
XLAT(FDEFER),
#endif
#ifdef FASYNC
{ FASYNC, "FASYNC" },
XLAT(FASYNC),
#endif
#ifdef FSHLOCK
{ FSHLOCK, "FSHLOCK" },
XLAT(FSHLOCK),
#endif
#ifdef FEXLOCK
{ FEXLOCK, "FEXLOCK" },
XLAT(FEXLOCK),
#endif
#ifdef FCREAT
{ FCREAT, "FCREAT" },
XLAT(FCREAT),
#endif
#ifdef FTRUNC
{ FTRUNC, "FTRUNC" },
XLAT(FTRUNC),
#endif
#ifdef FEXCL
{ FEXCL, "FEXCL" },
XLAT(FEXCL),
#endif
#ifdef FNBIO
{ FNBIO, "FNBIO" },
XLAT(FNBIO),
#endif
#ifdef FSYNC
{ FSYNC, "FSYNC" },
XLAT(FSYNC),
#endif
#ifdef FNOCTTY
{ FNOCTTY, "FNOCTTY" },
XLAT(FNOCTTY),
#endif
#ifdef O_SHLOCK
{ O_SHLOCK, "O_SHLOCK" },
XLAT(O_SHLOCK),
#endif
#ifdef O_EXLOCK
{ O_EXLOCK, "O_EXLOCK" },
XLAT(O_EXLOCK),
#endif
{ 0, NULL },
};
@ -468,15 +468,15 @@ sys_creat(struct tcb *tcp)
}
static const struct xlat access_flags[] = {
{ F_OK, "F_OK", },
{ R_OK, "R_OK" },
{ W_OK, "W_OK" },
{ X_OK, "X_OK" },
XLAT(F_OK),
XLAT(R_OK),
XLAT(W_OK),
XLAT(X_OK),
#ifdef EFF_ONLY_OK
{ EFF_ONLY_OK, "EFF_ONLY_OK" },
XLAT(EFF_ONLY_OK),
#endif
#ifdef EX_OK
{ EX_OK, "EX_OK" },
XLAT(EX_OK),
#endif
{ 0, NULL },
};
@ -516,14 +516,14 @@ sys_umask(struct tcb *tcp)
}
const struct xlat whence_codes[] = {
{ SEEK_SET, "SEEK_SET" },
{ SEEK_CUR, "SEEK_CUR" },
{ SEEK_END, "SEEK_END" },
XLAT(SEEK_SET),
XLAT(SEEK_CUR),
XLAT(SEEK_END),
#ifdef SEEK_DATA
{ SEEK_DATA, "SEEK_DATA" },
XLAT(SEEK_DATA),
#endif
#ifdef SEEK_HOLE
{ SEEK_HOLE, "SEEK_HOLE" },
XLAT(SEEK_HOLE),
#endif
{ 0, NULL },
};
@ -668,13 +668,13 @@ sys_ftruncate64(struct tcb *tcp)
/* several stats */
static const struct xlat modetypes[] = {
{ S_IFREG, "S_IFREG" },
{ S_IFSOCK, "S_IFSOCK" },
{ S_IFIFO, "S_IFIFO" },
{ S_IFLNK, "S_IFLNK" },
{ S_IFDIR, "S_IFDIR" },
{ S_IFBLK, "S_IFBLK" },
{ S_IFCHR, "S_IFCHR" },
XLAT(S_IFREG),
XLAT(S_IFSOCK),
XLAT(S_IFIFO),
XLAT(S_IFLNK),
XLAT(S_IFDIR),
XLAT(S_IFBLK),
XLAT(S_IFCHR),
{ 0, NULL },
};
@ -1323,11 +1323,11 @@ sys_stat64(struct tcb *tcp)
#endif
static const struct xlat at_flags[] = {
{ AT_SYMLINK_NOFOLLOW, "AT_SYMLINK_NOFOLLOW" },
{ AT_REMOVEDIR, "AT_REMOVEDIR" },
{ AT_SYMLINK_FOLLOW, "AT_SYMLINK_FOLLOW" },
{ AT_NO_AUTOMOUNT, "AT_NO_AUTOMOUNT" },
{ AT_EMPTY_PATH, "AT_EMPTY_PATH" },
XLAT(AT_SYMLINK_NOFOLLOW),
XLAT(AT_REMOVEDIR),
XLAT(AT_SYMLINK_FOLLOW),
XLAT(AT_NO_AUTOMOUNT),
XLAT(AT_EMPTY_PATH),
{ 0, NULL }
};
@ -1497,22 +1497,22 @@ sys_xmknod(struct tcb *tcp)
static const struct xlat aclcmds[] = {
# ifdef SETACL
{ SETACL, "SETACL" },
XLAT(SETACL),
# endif
# ifdef GETACL
{ GETACL, "GETACL" },
XLAT(GETACL),
# endif
# ifdef GETACLCNT
{ GETACLCNT, "GETACLCNT" },
XLAT(GETACLCNT),
# endif
# ifdef ACL_GET
{ ACL_GET, "ACL_GET" },
XLAT(ACL_GET),
# endif
# ifdef ACL_SET
{ ACL_SET, "ACL_SET" },
XLAT(ACL_SET),
# endif
# ifdef ACL_CNT
{ ACL_CNT, "ACL_CNT" },
XLAT(ACL_CNT),
# endif
{ 0, NULL },
};
@ -1558,13 +1558,13 @@ sys_facl(struct tcb *tcp)
static const struct xlat aclipc[] = {
# ifdef IPC_SHM
{ IPC_SHM, "IPC_SHM" },
XLAT(IPC_SHM),
# endif
# ifdef IPC_SEM
{ IPC_SEM, "IPC_SEM" },
XLAT(IPC_SEM),
# endif
# ifdef IPC_MSG
{ IPC_MSG, "IPC_MSG" },
XLAT(IPC_MSG),
# endif
{ 0, NULL },
};
@ -2240,15 +2240,15 @@ sys_readdir(struct tcb *tcp)
}
static const struct xlat direnttypes[] = {
{ DT_UNKNOWN, "DT_UNKNOWN" },
{ DT_FIFO, "DT_FIFO" },
{ DT_CHR, "DT_CHR" },
{ DT_DIR, "DT_DIR" },
{ DT_BLK, "DT_BLK" },
{ DT_REG, "DT_REG" },
{ DT_LNK, "DT_LNK" },
{ DT_SOCK, "DT_SOCK" },
{ DT_WHT, "DT_WHT" },
XLAT(DT_UNKNOWN),
XLAT(DT_FIFO),
XLAT(DT_CHR),
XLAT(DT_DIR),
XLAT(DT_BLK),
XLAT(DT_REG),
XLAT(DT_LNK),
XLAT(DT_SOCK),
XLAT(DT_WHT),
{ 0, NULL },
};
@ -2464,8 +2464,8 @@ sys_aiocancel(struct tcb *tcp)
static const struct xlat xattrflags[] = {
#ifdef XATTR_CREATE
{ XATTR_CREATE, "XATTR_CREATE" },
{ XATTR_REPLACE, "XATTR_REPLACE" },
XLAT(XATTR_CREATE),
XLAT(XATTR_REPLACE),
#endif
{ 0, NULL }
};
@ -2632,12 +2632,12 @@ sys_fremovexattr(struct tcb *tcp)
}
static const struct xlat advise[] = {
{ POSIX_FADV_NORMAL, "POSIX_FADV_NORMAL" },
{ POSIX_FADV_RANDOM, "POSIX_FADV_RANDOM" },
{ POSIX_FADV_SEQUENTIAL, "POSIX_FADV_SEQUENTIAL" },
{ POSIX_FADV_WILLNEED, "POSIX_FADV_WILLNEED" },
{ POSIX_FADV_DONTNEED, "POSIX_FADV_DONTNEED" },
{ POSIX_FADV_NOREUSE, "POSIX_FADV_NOREUSE" },
XLAT(POSIX_FADV_NORMAL),
XLAT(POSIX_FADV_RANDOM),
XLAT(POSIX_FADV_SEQUENTIAL),
XLAT(POSIX_FADV_WILLNEED),
XLAT(POSIX_FADV_DONTNEED),
XLAT(POSIX_FADV_NOREUSE),
{ 0, NULL }
};
@ -2672,9 +2672,9 @@ sys_fadvise64_64(struct tcb *tcp)
}
static const struct xlat sync_file_range_flags[] = {
{ SYNC_FILE_RANGE_WAIT_BEFORE, "SYNC_FILE_RANGE_WAIT_BEFORE" },
{ SYNC_FILE_RANGE_WRITE, "SYNC_FILE_RANGE_WRITE" },
{ SYNC_FILE_RANGE_WAIT_AFTER, "SYNC_FILE_RANGE_WAIT_AFTER" },
XLAT(SYNC_FILE_RANGE_WAIT_BEFORE),
XLAT(SYNC_FILE_RANGE_WRITE),
XLAT(SYNC_FILE_RANGE_WAIT_AFTER),
{ 0, NULL }
};
@ -2787,8 +2787,8 @@ sys_fallocate(struct tcb *tcp)
# define SWAP_FLAG_DISCARD 0x10000
#endif
static const struct xlat swap_flags[] = {
{ SWAP_FLAG_PREFER, "SWAP_FLAG_PREFER" },
{ SWAP_FLAG_DISCARD, "SWAP_FLAG_DISCARD" },
XLAT(SWAP_FLAG_PREFER),
XLAT(SWAP_FLAG_DISCARD),
{ 0, NULL }
};

8
io.c
View File

@ -319,16 +319,16 @@ sys_sendfile64(struct tcb *tcp)
static const struct xlat splice_flags[] = {
#ifdef SPLICE_F_MOVE
{ SPLICE_F_MOVE, "SPLICE_F_MOVE" },
XLAT(SPLICE_F_MOVE),
#endif
#ifdef SPLICE_F_NONBLOCK
{ SPLICE_F_NONBLOCK, "SPLICE_F_NONBLOCK" },
XLAT(SPLICE_F_NONBLOCK),
#endif
#ifdef SPLICE_F_MORE
{ SPLICE_F_MORE, "SPLICE_F_MORE" },
XLAT(SPLICE_F_MORE),
#endif
#ifdef SPLICE_F_GIFT
{ SPLICE_F_GIFT, "SPLICE_F_GIFT" },
XLAT(SPLICE_F_GIFT),
#endif
{ 0, NULL },
};

82
ipc.c
View File

@ -64,81 +64,81 @@
extern void printsigevent(struct tcb *tcp, long arg);
static const struct xlat msgctl_flags[] = {
{ IPC_RMID, "IPC_RMID" },
{ IPC_SET, "IPC_SET" },
{ IPC_STAT, "IPC_STAT" },
{ IPC_INFO, "IPC_INFO" },
{ MSG_STAT, "MSG_STAT" },
{ MSG_INFO, "MSG_INFO" },
XLAT(IPC_RMID),
XLAT(IPC_SET),
XLAT(IPC_STAT),
XLAT(IPC_INFO),
XLAT(MSG_STAT),
XLAT(MSG_INFO),
{ 0, NULL },
};
static const struct xlat semctl_flags[] = {
{ IPC_RMID, "IPC_RMID" },
{ IPC_SET, "IPC_SET" },
{ IPC_STAT, "IPC_STAT" },
{ IPC_INFO, "IPC_INFO" },
{ SEM_STAT, "SEM_STAT" },
{ SEM_INFO, "SEM_INFO" },
{ GETPID, "GETPID" },
{ GETVAL, "GETVAL" },
{ GETALL, "GETALL" },
{ GETNCNT, "GETNCNT" },
{ GETZCNT, "GETZCNT" },
{ SETVAL, "SETVAL" },
{ SETALL, "SETALL" },
XLAT(IPC_RMID),
XLAT(IPC_SET),
XLAT(IPC_STAT),
XLAT(IPC_INFO),
XLAT(SEM_STAT),
XLAT(SEM_INFO),
XLAT(GETPID),
XLAT(GETVAL),
XLAT(GETALL),
XLAT(GETNCNT),
XLAT(GETZCNT),
XLAT(SETVAL),
XLAT(SETALL),
{ 0, NULL },
};
static const struct xlat shmctl_flags[] = {
{ IPC_RMID, "IPC_RMID" },
{ IPC_SET, "IPC_SET" },
{ IPC_STAT, "IPC_STAT" },
{ IPC_INFO, "IPC_INFO" },
{ SHM_STAT, "SHM_STAT" },
{ SHM_INFO, "SHM_INFO" },
XLAT(IPC_RMID),
XLAT(IPC_SET),
XLAT(IPC_STAT),
XLAT(IPC_INFO),
XLAT(SHM_STAT),
XLAT(SHM_INFO),
#ifdef SHM_LOCK
{ SHM_LOCK, "SHM_LOCK" },
XLAT(SHM_LOCK),
#endif
#ifdef SHM_UNLOCK
{ SHM_UNLOCK, "SHM_UNLOCK" },
XLAT(SHM_UNLOCK),
#endif
{ 0, NULL },
};
static const struct xlat resource_flags[] = {
{ IPC_CREAT, "IPC_CREAT" },
{ IPC_EXCL, "IPC_EXCL" },
{ IPC_NOWAIT, "IPC_NOWAIT" },
XLAT(IPC_CREAT),
XLAT(IPC_EXCL),
XLAT(IPC_NOWAIT),
{ 0, NULL },
};
static const struct xlat shm_resource_flags[] = {
{ IPC_CREAT, "IPC_CREAT" },
{ IPC_EXCL, "IPC_EXCL" },
XLAT(IPC_CREAT),
XLAT(IPC_EXCL),
#ifdef SHM_HUGETLB
{ SHM_HUGETLB, "SHM_HUGETLB" },
XLAT(SHM_HUGETLB),
#endif
{ 0, NULL },
};
static const struct xlat shm_flags[] = {
{ SHM_REMAP, "SHM_REMAP" },
{ SHM_RDONLY, "SHM_RDONLY" },
{ SHM_RND, "SHM_RND" },
XLAT(SHM_REMAP),
XLAT(SHM_RDONLY),
XLAT(SHM_RND),
{ 0, NULL },
};
static const struct xlat msg_flags[] = {
{ MSG_NOERROR, "MSG_NOERROR" },
{ MSG_EXCEPT, "MSG_EXCEPT" },
{ IPC_NOWAIT, "IPC_NOWAIT" },
XLAT(MSG_NOERROR),
XLAT(MSG_EXCEPT),
XLAT(IPC_NOWAIT),
{ 0, NULL },
};
static const struct xlat semop_flags[] = {
{ SEM_UNDO, "SEM_UNDO" },
{ IPC_NOWAIT, "IPC_NOWAIT" },
XLAT(SEM_UNDO),
XLAT(IPC_NOWAIT),
{ 0, NULL },
};

26
loop.c
View File

@ -32,27 +32,27 @@
#include <linux/loop.h>
static const struct xlat loop_flags_options[] = {
{ LO_FLAGS_READ_ONLY, "LO_FLAGS_READ_ONLY" },
XLAT(LO_FLAGS_READ_ONLY),
#if HAVE_DECL_LO_FLAGS_AUTOCLEAR
{ LO_FLAGS_AUTOCLEAR, "LO_FLAGS_AUTOCLEAR" },
XLAT(LO_FLAGS_AUTOCLEAR),
#endif
#if HAVE_DECL_LO_FLAGS_PARTSCAN
{ LO_FLAGS_PARTSCAN, "LO_FLAGS_PARTSCAN" },
XLAT(LO_FLAGS_PARTSCAN),
#endif
{ 0, NULL },
};
static const struct xlat loop_crypt_type_options[] = {
{ LO_CRYPT_NONE, "LO_CRYPT_NONE" },
{ LO_CRYPT_XOR, "LO_CRYPT_XOR" },
{ LO_CRYPT_DES, "LO_CRYPT_DES" },
{ LO_CRYPT_FISH2, "LO_CRYPT_FISH2" },
{ LO_CRYPT_BLOW, "LO_CRYPT_BLOW" },
{ LO_CRYPT_CAST128, "LO_CRYPT_CAST128" },
{ LO_CRYPT_IDEA, "LO_CRYPT_IDEA" },
{ LO_CRYPT_DUMMY, "LO_CRYPT_DUMMY" },
{ LO_CRYPT_SKIPJACK, "LO_CRYPT_SKIPJACK" },
{ LO_CRYPT_CRYPTOAPI, "LO_CRYPT_CRYPTOAPI" },
XLAT(LO_CRYPT_NONE),
XLAT(LO_CRYPT_XOR),
XLAT(LO_CRYPT_DES),
XLAT(LO_CRYPT_FISH2),
XLAT(LO_CRYPT_BLOW),
XLAT(LO_CRYPT_CAST128),
XLAT(LO_CRYPT_IDEA),
XLAT(LO_CRYPT_DUMMY),
XLAT(LO_CRYPT_SKIPJACK),
XLAT(LO_CRYPT_CRYPTOAPI),
{ 0, NULL },
};

144
mem.c
View File

@ -60,46 +60,46 @@ sys_brk(struct tcb *tcp)
}
static const struct xlat mmap_prot[] = {
{ PROT_NONE, "PROT_NONE", },
{ PROT_READ, "PROT_READ" },
{ PROT_WRITE, "PROT_WRITE" },
{ PROT_EXEC, "PROT_EXEC" },
XLAT(PROT_NONE),
XLAT(PROT_READ),
XLAT(PROT_WRITE),
XLAT(PROT_EXEC),
#ifdef PROT_SEM
{ PROT_SEM, "PROT_SEM" },
XLAT(PROT_SEM),
#endif
#ifdef PROT_GROWSDOWN
{ PROT_GROWSDOWN,"PROT_GROWSDOWN"},
XLAT(PROT_GROWSDOWN),
#endif
#ifdef PROT_GROWSUP
{ PROT_GROWSUP, "PROT_GROWSUP" },
XLAT(PROT_GROWSUP),
#endif
#ifdef PROT_SAO
{ PROT_SAO, "PROT_SAO" },
XLAT(PROT_SAO),
#endif
{ 0, NULL },
};
static const struct xlat mmap_flags[] = {
{ MAP_SHARED, "MAP_SHARED" },
{ MAP_PRIVATE, "MAP_PRIVATE" },
{ MAP_FIXED, "MAP_FIXED" },
XLAT(MAP_SHARED),
XLAT(MAP_PRIVATE),
XLAT(MAP_FIXED),
#ifdef MAP_ANONYMOUS
{ MAP_ANONYMOUS,"MAP_ANONYMOUS" },
XLAT(MAP_ANONYMOUS),
#endif
#ifdef MAP_32BIT
{ MAP_32BIT, "MAP_32BIT" },
XLAT(MAP_32BIT),
#endif
#ifdef MAP_RENAME
{ MAP_RENAME, "MAP_RENAME" },
XLAT(MAP_RENAME),
#endif
#ifdef MAP_NORESERVE
{ MAP_NORESERVE,"MAP_NORESERVE" },
XLAT(MAP_NORESERVE),
#endif
#ifdef MAP_POPULATE
{ MAP_POPULATE, "MAP_POPULATE" },
XLAT(MAP_POPULATE),
#endif
#ifdef MAP_NONBLOCK
{ MAP_NONBLOCK, "MAP_NONBLOCK" },
XLAT(MAP_NONBLOCK),
#endif
/*
* XXX - this was introduced in SunOS 4.x to distinguish between
@ -129,47 +129,47 @@ static const struct xlat mmap_flags[] = {
* and calls with it as "mmap()".
*/
#ifdef _MAP_NEW
{ _MAP_NEW, "_MAP_NEW" },
XLAT(_MAP_NEW),
#endif
#ifdef MAP_GROWSDOWN
{ MAP_GROWSDOWN,"MAP_GROWSDOWN" },
XLAT(MAP_GROWSDOWN),
#endif
#ifdef MAP_DENYWRITE
{ MAP_DENYWRITE,"MAP_DENYWRITE" },
XLAT(MAP_DENYWRITE),
#endif
#ifdef MAP_EXECUTABLE
{ MAP_EXECUTABLE,"MAP_EXECUTABLE"},
XLAT(MAP_EXECUTABLE),
#endif
#ifdef MAP_INHERIT
{ MAP_INHERIT, "MAP_INHERIT" },
XLAT(MAP_INHERIT),
#endif
#ifdef MAP_FILE
{ MAP_FILE, "MAP_FILE" },
XLAT(MAP_FILE),
#endif
#ifdef MAP_LOCKED
{ MAP_LOCKED, "MAP_LOCKED" },
XLAT(MAP_LOCKED),
#endif
/* FreeBSD ones */
#if defined(MAP_ANON) && (!defined(MAP_ANONYMOUS) || MAP_ANON != MAP_ANONYMOUS)
{ MAP_ANON, "MAP_ANON" },
XLAT(MAP_ANON),
#endif
#ifdef MAP_HASSEMAPHORE
{ MAP_HASSEMAPHORE,"MAP_HASSEMAPHORE"},
XLAT(MAP_HASSEMAPHORE),
#endif
#ifdef MAP_STACK
{ MAP_STACK, "MAP_STACK" },
XLAT(MAP_STACK),
#endif
#ifdef MAP_HUGETLB
{ MAP_HUGETLB, "MAP_HUGETLB" },
XLAT(MAP_HUGETLB),
#endif
#if defined MAP_UNINITIALIZED && MAP_UNINITIALIZED > 0
{ MAP_UNINITIALIZED,"MAP_UNINITIALIZED"},
XLAT(MAP_UNINITIALIZED),
#endif
#ifdef MAP_NOSYNC
{ MAP_NOSYNC, "MAP_NOSYNC" },
XLAT(MAP_NOSYNC),
#endif
#ifdef MAP_NOCORE
{ MAP_NOCORE, "MAP_NOCORE" },
XLAT(MAP_NOCORE),
#endif
{ 0, NULL },
};
@ -322,9 +322,9 @@ sys_mprotect(struct tcb *tcp)
}
static const struct xlat mremap_flags[] = {
{ MREMAP_MAYMOVE, "MREMAP_MAYMOVE" },
XLAT(MREMAP_MAYMOVE),
#ifdef MREMAP_FIXED
{ MREMAP_FIXED, "MREMAP_FIXED" },
XLAT(MREMAP_FIXED),
#endif
{ 0, NULL }
};
@ -347,52 +347,52 @@ sys_mremap(struct tcb *tcp)
static const struct xlat madvise_cmds[] = {
#ifdef MADV_NORMAL
{ MADV_NORMAL, "MADV_NORMAL" },
XLAT(MADV_NORMAL),
#endif
#ifdef MADV_RANDOM
{ MADV_RANDOM, "MADV_RANDOM" },
XLAT(MADV_RANDOM),
#endif
#ifdef MADV_SEQUENTIAL
{ MADV_SEQUENTIAL, "MADV_SEQUENTIAL" },
XLAT(MADV_SEQUENTIAL),
#endif
#ifdef MADV_WILLNEED
{ MADV_WILLNEED, "MADV_WILLNEED" },
XLAT(MADV_WILLNEED),
#endif
#ifdef MADV_DONTNEED
{ MADV_DONTNEED, "MADV_DONTNEED" },
XLAT(MADV_DONTNEED),
#endif
#ifdef MADV_REMOVE
{ MADV_REMOVE, "MADV_REMOVE" },
XLAT(MADV_REMOVE),
#endif
#ifdef MADV_DONTFORK
{ MADV_DONTFORK, "MADV_DONTFORK" },
XLAT(MADV_DONTFORK),
#endif
#ifdef MADV_DOFORK
{ MADV_DOFORK, "MADV_DOFORK" },
XLAT(MADV_DOFORK),
#endif
#ifdef MADV_HWPOISON
{ MADV_HWPOISON, "MADV_HWPOISON" },
XLAT(MADV_HWPOISON),
#endif
#ifdef MADV_SOFT_OFFLINE
{ MADV_SOFT_OFFLINE, "MADV_SOFT_OFFLINE" },
XLAT(MADV_SOFT_OFFLINE),
#endif
#ifdef MADV_MERGEABLE
{ MADV_MERGEABLE, "MADV_MERGEABLE" },
XLAT(MADV_MERGEABLE),
#endif
#ifdef MADV_UNMERGEABLE
{ MADV_UNMERGEABLE, "MADV_UNMERGEABLE" },
XLAT(MADV_UNMERGEABLE),
#endif
#ifdef MADV_HUGEPAGE
{ MADV_HUGEPAGE, "MADV_HUGEPAGE" },
XLAT(MADV_HUGEPAGE),
#endif
#ifdef MADV_NOHUGEPAGE
{ MADV_NOHUGEPAGE, "MADV_NOHUGEPAGE" },
XLAT(MADV_NOHUGEPAGE),
#endif
#ifdef MADV_DONTDUMP
{ MADV_DONTDUMP, "MADV_DONTDUMP" },
XLAT(MADV_DONTDUMP),
#endif
#ifdef MADV_DODUMP
{ MADV_DODUMP, "MADV_DODUMP" },
XLAT(MADV_DODUMP),
#endif
{ 0, NULL },
};
@ -409,10 +409,10 @@ sys_madvise(struct tcb *tcp)
static const struct xlat mlockall_flags[] = {
#ifdef MCL_CURRENT
{ MCL_CURRENT, "MCL_CURRENT" },
XLAT(MCL_CURRENT),
#endif
#ifdef MCL_FUTURE
{ MCL_FUTURE, "MCL_FUTURE" },
XLAT(MCL_FUTURE),
#endif
{ 0, NULL}
};
@ -430,10 +430,10 @@ sys_mlockall(struct tcb *tcp)
static const struct xlat mctl_sync[] = {
#ifdef MS_SYNC
{ MS_SYNC, "MS_SYNC" },
XLAT(MS_SYNC),
#endif
{ MS_ASYNC, "MS_ASYNC" },
{ MS_INVALIDATE,"MS_INVALIDATE" },
XLAT(MS_ASYNC),
XLAT(MS_INVALIDATE),
{ 0, NULL },
};
@ -456,17 +456,17 @@ sys_msync(struct tcb *tcp)
#ifdef MC_SYNC
static const struct xlat mctl_funcs[] = {
{ MC_LOCK, "MC_LOCK" },
{ MC_LOCKAS, "MC_LOCKAS" },
{ MC_SYNC, "MC_SYNC" },
{ MC_UNLOCK, "MC_UNLOCK" },
{ MC_UNLOCKAS, "MC_UNLOCKAS" },
XLAT(MC_LOCK),
XLAT(MC_LOCKAS),
XLAT(MC_SYNC),
XLAT(MC_UNLOCK),
XLAT(MC_UNLOCKAS),
{ 0, NULL },
};
static const struct xlat mctl_lockas[] = {
{ MCL_CURRENT, "MCL_CURRENT" },
{ MCL_FUTURE, "MCL_FUTURE" },
XLAT(MCL_CURRENT),
XLAT(MCL_FUTURE),
{ 0, NULL },
};
@ -684,29 +684,29 @@ sys_remap_file_pages(struct tcb *tcp)
#define MPOL_MF_MOVE_ALL (1<<2)
static const struct xlat policies[] = {
{ MPOL_DEFAULT, "MPOL_DEFAULT" },
{ MPOL_PREFERRED, "MPOL_PREFERRED" },
{ MPOL_BIND, "MPOL_BIND" },
{ MPOL_INTERLEAVE, "MPOL_INTERLEAVE" },
XLAT(MPOL_DEFAULT),
XLAT(MPOL_PREFERRED),
XLAT(MPOL_BIND),
XLAT(MPOL_INTERLEAVE),
{ 0, NULL }
};
static const struct xlat mbindflags[] = {
{ MPOL_MF_STRICT, "MPOL_MF_STRICT" },
{ MPOL_MF_MOVE, "MPOL_MF_MOVE" },
{ MPOL_MF_MOVE_ALL, "MPOL_MF_MOVE_ALL" },
XLAT(MPOL_MF_STRICT),
XLAT(MPOL_MF_MOVE),
XLAT(MPOL_MF_MOVE_ALL),
{ 0, NULL }
};
static const struct xlat mempolicyflags[] = {
{ MPOL_F_NODE, "MPOL_F_NODE" },
{ MPOL_F_ADDR, "MPOL_F_ADDR" },
XLAT(MPOL_F_NODE),
XLAT(MPOL_F_ADDR),
{ 0, NULL }
};
static const struct xlat move_pages_flags[] = {
{ MPOL_MF_MOVE, "MPOL_MF_MOVE" },
{ MPOL_MF_MOVE_ALL, "MPOL_MF_MOVE_ALL" },
XLAT(MPOL_MF_MOVE),
XLAT(MPOL_MF_MOVE_ALL),
{ 0, NULL }
};

52
mtd.c
View File

@ -42,45 +42,45 @@
#endif
static const struct xlat mtd_mode_options[] = {
{ MTD_OPS_PLACE_OOB, "MTD_OPS_PLACE_OOB" },
{ MTD_OPS_AUTO_OOB, "MTD_OPS_AUTO_OOB" },
{ MTD_OPS_RAW, "MTD_OPS_RAW" },
XLAT(MTD_OPS_PLACE_OOB),
XLAT(MTD_OPS_AUTO_OOB),
XLAT(MTD_OPS_RAW),
{ 0, NULL },
};
static const struct xlat mtd_type_options[] = {
{ MTD_ABSENT, "MTD_ABSENT" },
{ MTD_RAM, "MTD_RAM" },
{ MTD_ROM, "MTD_ROM" },
{ MTD_NORFLASH, "MTD_NORFLASH" },
{ MTD_NANDFLASH, "MTD_NANDFLASH" },
{ MTD_DATAFLASH, "MTD_DATAFLASH" },
{ MTD_UBIVOLUME, "MTD_UBIVOLUME" },
{ MTD_MLCNANDFLASH, "MTD_MLCNANDFLASH" },
XLAT(MTD_ABSENT),
XLAT(MTD_RAM),
XLAT(MTD_ROM),
XLAT(MTD_NORFLASH),
XLAT(MTD_NANDFLASH),
XLAT(MTD_DATAFLASH),
XLAT(MTD_UBIVOLUME),
XLAT(MTD_MLCNANDFLASH),
{ 0, NULL },
};
static const struct xlat mtd_flags_options[] = {
{ MTD_WRITEABLE, "MTD_WRITEABLE" },
{ MTD_BIT_WRITEABLE, "MTD_BIT_WRITEABLE" },
{ MTD_NO_ERASE, "MTD_NO_ERASE" },
{ MTD_POWERUP_LOCK, "MTD_POWERUP_LOCK" },
XLAT(MTD_WRITEABLE),
XLAT(MTD_BIT_WRITEABLE),
XLAT(MTD_NO_ERASE),
XLAT(MTD_POWERUP_LOCK),
{ 0, NULL },
};
static const struct xlat mtd_otp_options[] = {
{ MTD_OTP_OFF, "MTD_OTP_OFF" },
{ MTD_OTP_FACTORY, "MTD_OTP_FACTORY" },
{ MTD_OTP_USER, "MTD_OTP_USER" },
XLAT(MTD_OTP_OFF),
XLAT(MTD_OTP_FACTORY),
XLAT(MTD_OTP_USER),
{ 0, NULL },
};
static const struct xlat mtd_nandecc_options[] = {
{ MTD_NANDECC_OFF, "MTD_NANDECC_OFF" },
{ MTD_NANDECC_PLACE, "MTD_NANDECC_PLACE" },
{ MTD_NANDECC_AUTOPLACE, "MTD_NANDECC_AUTOPLACE" },
{ MTD_NANDECC_PLACEONLY, "MTD_NANDECC_PLACEONLY" },
{ MTD_NANDECC_AUTOPL_USR, "MTD_NANDECC_AUTOPL_USR" },
XLAT(MTD_NANDECC_OFF),
XLAT(MTD_NANDECC_PLACE),
XLAT(MTD_NANDECC_AUTOPLACE),
XLAT(MTD_NANDECC_PLACEONLY),
XLAT(MTD_NANDECC_AUTOPL_USR),
{ 0, NULL },
};
@ -287,13 +287,13 @@ int mtd_ioctl(struct tcb *tcp, long code, long arg)
}
static const struct xlat ubi_volume_types[] = {
{ UBI_DYNAMIC_VOLUME, "UBI_DYNAMIC_VOLUME" },
{ UBI_STATIC_VOLUME, "UBI_STATIC_VOLUME" },
XLAT(UBI_DYNAMIC_VOLUME),
XLAT(UBI_STATIC_VOLUME),
{ 0, NULL },
};
static const struct xlat ubi_volume_props[] = {
{ UBI_VOL_PROP_DIRECT_WRITE, "UBI_VOL_PROP_DIRECT_WRITE" },
XLAT(UBI_VOL_PROP_DIRECT_WRITE),
{ 0, NULL },
};

746
net.c
View File

File diff suppressed because it is too large Load Diff

660
process.c
View File

File diff suppressed because it is too large Load Diff

6
ptp.c
View File

@ -3,9 +3,9 @@
#include <linux/ptp_clock.h>
static const struct xlat ptp_flags_options[] = {
{ PTP_ENABLE_FEATURE, "PTP_ENABLE_FEATURE" },
{ PTP_RISING_EDGE, "PTP_RISING_EDGE" },
{ PTP_FALLING_EDGE, "PTP_FALLING_EDGE" },
XLAT(PTP_ENABLE_FEATURE),
XLAT(PTP_RISING_EDGE),
XLAT(PTP_FALLING_EDGE),
{ 0, NULL }
};

104
quota.c
View File

@ -77,41 +77,41 @@
#define Q_XQUOTASYNC XQM_CMD(0x7)
static const struct xlat quotacmds[] = {
{Q_V1_QUOTAON, "Q_V1_QUOTAON"},
{Q_V1_QUOTAOFF, "Q_V1_QUOTAOFF"},
{Q_V1_GETQUOTA, "Q_V1_GETQUOTA"},
{Q_V1_SETQUOTA, "Q_V1_SETQUOTA"},
{Q_V1_SETUSE, "Q_V1_SETUSE"},
{Q_V1_SYNC, "Q_V1_SYNC"},
{Q_SETQLIM, "Q_SETQLIM"},
{Q_V1_GETSTATS, "Q_V1_GETSTATS"},
{Q_V1_RSQUASH, "Q_V1_RSQUASH"},
XLAT(Q_V1_QUOTAON),
XLAT(Q_V1_QUOTAOFF),
XLAT(Q_V1_GETQUOTA),
XLAT(Q_V1_SETQUOTA),
XLAT(Q_V1_SETUSE),
XLAT(Q_V1_SYNC),
XLAT(Q_SETQLIM),
XLAT(Q_V1_GETSTATS),
XLAT(Q_V1_RSQUASH),
{Q_V2_GETQUOTA, "Q_V2_GETQUOTA"},
{Q_V2_SETQUOTA, "Q_V2_SETQUOTA"},
{Q_V2_SETUSE, "Q_V2_SETUSE"},
{Q_V2_GETINFO, "Q_V2_GETINFO"},
{Q_V2_SETINFO, "Q_V2_SETINFO"},
{Q_V2_SETGRACE, "Q_V2_SETGRACE"},
{Q_V2_SETFLAGS, "Q_V2_SETFLAGS"},
{Q_V2_GETSTATS, "Q_V2_GETSTATS"},
XLAT(Q_V2_GETQUOTA),
XLAT(Q_V2_SETQUOTA),
XLAT(Q_V2_SETUSE),
XLAT(Q_V2_GETINFO),
XLAT(Q_V2_SETINFO),
XLAT(Q_V2_SETGRACE),
XLAT(Q_V2_SETFLAGS),
XLAT(Q_V2_GETSTATS),
{Q_SYNC, "Q_SYNC"},
{Q_QUOTAON, "Q_QUOTAON"},
{Q_QUOTAOFF, "Q_QUOTAOFF"},
{Q_GETFMT, "Q_GETFMT"},
{Q_GETINFO, "Q_GETINFO"},
{Q_SETINFO, "Q_SETINFO"},
{Q_GETQUOTA, "Q_GETQUOTA"},
{Q_SETQUOTA, "Q_SETQUOTA"},
XLAT(Q_SYNC),
XLAT(Q_QUOTAON),
XLAT(Q_QUOTAOFF),
XLAT(Q_GETFMT),
XLAT(Q_GETINFO),
XLAT(Q_SETINFO),
XLAT(Q_GETQUOTA),
XLAT(Q_SETQUOTA),
{Q_XQUOTAON, "Q_XQUOTAON"},
{Q_XQUOTAOFF, "Q_XQUOTAOFF"},
{Q_XGETQUOTA, "Q_XGETQUOTA"},
{Q_XSETQLIM, "Q_XSETQLIM"},
{Q_XGETQSTAT, "Q_XGETQSTAT"},
{Q_XQUOTARM, "Q_XQUOTARM"},
{Q_XQUOTASYNC, "Q_XQUOTASYNC"},
XLAT(Q_XQUOTAON),
XLAT(Q_XQUOTAOFF),
XLAT(Q_XGETQUOTA),
XLAT(Q_XSETQLIM),
XLAT(Q_XGETQSTAT),
XLAT(Q_XQUOTARM),
XLAT(Q_XQUOTASYNC),
{0, NULL},
};
@ -120,8 +120,8 @@ static const struct xlat quotacmds[] = {
#define GRPQUOTA 1
static const struct xlat quotatypes[] = {
{USRQUOTA, "USRQUOTA"},
{GRPQUOTA, "GRPQUOTA"},
XLAT(USRQUOTA),
XLAT(GRPQUOTA),
{0, NULL},
};
@ -130,8 +130,8 @@ static const struct xlat quotatypes[] = {
#define QFMT_VFS_V0 2
static const struct xlat quota_formats[] = {
{QFMT_VFS_OLD, "QFMT_VFS_OLD"},
{QFMT_VFS_V0, "QFMT_VFS_V0"},
XLAT(QFMT_VFS_OLD),
XLAT(QFMT_VFS_V0),
{0, NULL},
};
@ -145,17 +145,17 @@ static const struct xlat quota_formats[] = {
#define XFS_GROUP_QUOTA (1<<2) /* group quota type */
static const struct xlat xfs_quota_flags[] = {
{XFS_QUOTA_UDQ_ACCT, "XFS_QUOTA_UDQ_ACCT"},
{XFS_QUOTA_UDQ_ENFD, "XFS_QUOTA_UDQ_ENFD"},
{XFS_QUOTA_GDQ_ACCT, "XFS_QUOTA_GDQ_ACCT"},
{XFS_QUOTA_GDQ_ENFD, "XFS_QUOTA_GDQ_ENFD"},
XLAT(XFS_QUOTA_UDQ_ACCT),
XLAT(XFS_QUOTA_UDQ_ENFD),
XLAT(XFS_QUOTA_GDQ_ACCT),
XLAT(XFS_QUOTA_GDQ_ENFD),
{0, NULL}
};
static const struct xlat xfs_dqblk_flags[] = {
{XFS_USER_QUOTA, "XFS_USER_QUOTA"},
{XFS_PROJ_QUOTA, "XFS_PROJ_QUOTA"},
{XFS_GROUP_QUOTA, "XFS_GROUP_QUOTA"},
XLAT(XFS_USER_QUOTA),
XLAT(XFS_PROJ_QUOTA),
XLAT(XFS_GROUP_QUOTA),
{0, NULL}
};
@ -170,12 +170,12 @@ static const struct xlat xfs_dqblk_flags[] = {
#define QIF_ITIME 32
static const struct xlat if_dqblk_valid[] = {
{QIF_BLIMITS, "QIF_BLIMITS"},
{QIF_SPACE, "QIF_SPACE"},
{QIF_ILIMITS, "QIF_ILIMITS"},
{QIF_INODES, "QIF_INODES"},
{QIF_BTIME, "QIF_BTIME"},
{QIF_ITIME, "QIF_ITIME"},
XLAT(QIF_BLIMITS),
XLAT(QIF_SPACE),
XLAT(QIF_ILIMITS),
XLAT(QIF_INODES),
XLAT(QIF_BTIME),
XLAT(QIF_ITIME),
{0, NULL}
};
@ -250,9 +250,9 @@ struct xfs_dqblk
#define IIF_FLAGS 4
static const struct xlat if_dqinfo_valid[] = {
{IIF_BGRACE, "IIF_BGRACE"},
{IIF_IGRACE, "IIF_IGRACE"},
{IIF_FLAGS, "IIF_FLAGS"},
XLAT(IIF_BGRACE),
XLAT(IIF_IGRACE),
XLAT(IIF_FLAGS),
{0, NULL}
};

46
resource.c
View File

@ -35,55 +35,55 @@
static const struct xlat resources[] = {
#ifdef RLIMIT_AS
{ RLIMIT_AS, "RLIMIT_AS" },
XLAT(RLIMIT_AS),
#endif
#ifdef RLIMIT_CORE
{ RLIMIT_CORE, "RLIMIT_CORE" },
XLAT(RLIMIT_CORE),
#endif
#ifdef RLIMIT_CPU
{ RLIMIT_CPU, "RLIMIT_CPU" },
XLAT(RLIMIT_CPU),
#endif
#ifdef RLIMIT_DATA
{ RLIMIT_DATA, "RLIMIT_DATA" },
XLAT(RLIMIT_DATA),
#endif
#ifdef RLIMIT_FSIZE
{ RLIMIT_FSIZE, "RLIMIT_FSIZE" },
XLAT(RLIMIT_FSIZE),
#endif
#ifdef RLIMIT_LOCKS
{ RLIMIT_LOCKS, "RLIMIT_LOCKS" },
XLAT(RLIMIT_LOCKS),
#endif
#ifdef RLIMIT_MEMLOCK
{ RLIMIT_MEMLOCK, "RLIMIT_MEMLOCK" },
XLAT(RLIMIT_MEMLOCK),
#endif
#ifdef RLIMIT_MSGQUEUE
{ RLIMIT_MSGQUEUE, "RLIMIT_MSGQUEUE" },
XLAT(RLIMIT_MSGQUEUE),
#endif
#ifdef RLIMIT_NICE
{ RLIMIT_NICE, "RLIMIT_NICE" },
XLAT(RLIMIT_NICE),
#endif
#ifdef RLIMIT_NOFILE
{ RLIMIT_NOFILE, "RLIMIT_NOFILE" },
XLAT(RLIMIT_NOFILE),
#endif
#ifdef RLIMIT_NPROC
{ RLIMIT_NPROC, "RLIMIT_NPROC" },
XLAT(RLIMIT_NPROC),
#endif
#ifdef RLIMIT_RSS
{ RLIMIT_RSS, "RLIMIT_RSS" },
XLAT(RLIMIT_RSS),
#endif
#ifdef RLIMIT_RTPRIO
{ RLIMIT_RTPRIO, "RLIMIT_RTPRIO" },
XLAT(RLIMIT_RTPRIO),
#endif
#ifdef RLIMIT_RTTIME
{ RLIMIT_RTTIME, "RLIMIT_RTTIME" },
XLAT(RLIMIT_RTTIME),
#endif
#ifdef RLIMIT_SIGPENDING
{ RLIMIT_SIGPENDING, "RLIMIT_SIGPENDING" },
XLAT(RLIMIT_SIGPENDING),
#endif
#ifdef RLIMIT_STACK
{ RLIMIT_STACK, "RLIMIT_STACK" },
XLAT(RLIMIT_STACK),
#endif
#ifdef RLIMIT_VMEM
{ RLIMIT_VMEM, "RLIMIT_VMEM" },
XLAT(RLIMIT_VMEM),
#endif
{ 0, NULL }
};
@ -233,10 +233,10 @@ sys_prlimit64(struct tcb *tcp)
}
static const struct xlat usagewho[] = {
{ RUSAGE_SELF, "RUSAGE_SELF" },
{ RUSAGE_CHILDREN, "RUSAGE_CHILDREN" },
XLAT(RUSAGE_SELF),
XLAT(RUSAGE_CHILDREN),
#ifdef RUSAGE_BOTH
{ RUSAGE_BOTH, "RUSAGE_BOTH" },
XLAT(RUSAGE_BOTH),
#endif
{ 0, NULL },
};
@ -387,9 +387,9 @@ sys_sysinfo(struct tcb *tcp)
}
static const struct xlat priorities[] = {
{ PRIO_PROCESS, "PRIO_PROCESS" },
{ PRIO_PGRP, "PRIO_PGRP" },
{ PRIO_USER, "PRIO_USER" },
XLAT(PRIO_PROCESS),
XLAT(PRIO_PGRP),
XLAT(PRIO_USER),
{ 0, NULL },
};

8
scsi.c
View File

@ -31,10 +31,10 @@
#include <scsi/sg.h>
static const struct xlat sg_io_dxfer_direction[] = {
{SG_DXFER_NONE, "SG_DXFER_NONE"},
{SG_DXFER_TO_DEV, "SG_DXFER_TO_DEV"},
{SG_DXFER_FROM_DEV, "SG_DXFER_FROM_DEV"},
{SG_DXFER_TO_FROM_DEV, "SG_DXFER_TO_FROM_DEV"},
XLAT(SG_DXFER_NONE),
XLAT(SG_DXFER_TO_DEV),
XLAT(SG_DXFER_FROM_DEV),
XLAT(SG_DXFER_TO_FROM_DEV),
{0, NULL}
};

140
signal.c
View File

@ -100,62 +100,62 @@ struct sigcontext {
static const struct xlat sigact_flags[] = {
#ifdef SA_RESTORER
{ SA_RESTORER, "SA_RESTORER" },
XLAT(SA_RESTORER),
#endif
#ifdef SA_STACK
{ SA_STACK, "SA_STACK" },
XLAT(SA_STACK),
#endif
#ifdef SA_RESTART
{ SA_RESTART, "SA_RESTART" },
XLAT(SA_RESTART),
#endif
#ifdef SA_INTERRUPT
{ SA_INTERRUPT, "SA_INTERRUPT" },
XLAT(SA_INTERRUPT),
#endif
#ifdef SA_NODEFER
{ SA_NODEFER, "SA_NODEFER" },
XLAT(SA_NODEFER),
#endif
#if defined SA_NOMASK && SA_NODEFER != SA_NOMASK
{ SA_NOMASK, "SA_NOMASK" },
XLAT(SA_NOMASK),
#endif
#ifdef SA_RESETHAND
{ SA_RESETHAND, "SA_RESETHAND" },
XLAT(SA_RESETHAND),
#endif
#if defined SA_ONESHOT && SA_ONESHOT != SA_RESETHAND
{ SA_ONESHOT, "SA_ONESHOT" },
XLAT(SA_ONESHOT),
#endif
#ifdef SA_SIGINFO
{ SA_SIGINFO, "SA_SIGINFO" },
XLAT(SA_SIGINFO),
#endif
#ifdef SA_RESETHAND
{ SA_RESETHAND, "SA_RESETHAND" },
XLAT(SA_RESETHAND),
#endif
#ifdef SA_ONSTACK
{ SA_ONSTACK, "SA_ONSTACK" },
XLAT(SA_ONSTACK),
#endif
#ifdef SA_NODEFER
{ SA_NODEFER, "SA_NODEFER" },
XLAT(SA_NODEFER),
#endif
#ifdef SA_NOCLDSTOP
{ SA_NOCLDSTOP, "SA_NOCLDSTOP" },
XLAT(SA_NOCLDSTOP),
#endif
#ifdef SA_NOCLDWAIT
{ SA_NOCLDWAIT, "SA_NOCLDWAIT" },
XLAT(SA_NOCLDWAIT),
#endif
#ifdef _SA_BSDCALL
{ _SA_BSDCALL, "_SA_BSDCALL" },
XLAT(_SA_BSDCALL),
#endif
#ifdef SA_NOPTRACE
{ SA_NOPTRACE, "SA_NOPTRACE" },
XLAT(SA_NOPTRACE),
#endif
{ 0, NULL },
};
static const struct xlat sigprocmaskcmds[] = {
{ SIG_BLOCK, "SIG_BLOCK" },
{ SIG_UNBLOCK, "SIG_UNBLOCK" },
{ SIG_SETMASK, "SIG_SETMASK" },
XLAT(SIG_BLOCK),
XLAT(SIG_UNBLOCK),
XLAT(SIG_SETMASK),
#ifdef SIG_SETMASK32
{ SIG_SETMASK32,"SIG_SETMASK32" },
XLAT(SIG_SETMASK32),
#endif
{ 0, NULL },
};
@ -376,94 +376,94 @@ print_sigset_addr_len(struct tcb *tcp, long addr, long len)
static const struct xlat siginfo_codes[] = {
#ifdef SI_KERNEL
{ SI_KERNEL, "SI_KERNEL" },
XLAT(SI_KERNEL),
#endif
#ifdef SI_USER
{ SI_USER, "SI_USER" },
XLAT(SI_USER),
#endif
#ifdef SI_QUEUE
{ SI_QUEUE, "SI_QUEUE" },
XLAT(SI_QUEUE),
#endif
#ifdef SI_TIMER
{ SI_TIMER, "SI_TIMER" },
XLAT(SI_TIMER),
#endif
#ifdef SI_MESGQ
{ SI_MESGQ, "SI_MESGQ" },
XLAT(SI_MESGQ),
#endif
#ifdef SI_ASYNCIO
{ SI_ASYNCIO, "SI_ASYNCIO" },
XLAT(SI_ASYNCIO),
#endif
#ifdef SI_SIGIO
{ SI_SIGIO, "SI_SIGIO" },
XLAT(SI_SIGIO),
#endif
#ifdef SI_TKILL
{ SI_TKILL, "SI_TKILL" },
XLAT(SI_TKILL),
#endif
#ifdef SI_ASYNCNL
{ SI_ASYNCNL, "SI_ASYNCNL" },
XLAT(SI_ASYNCNL),
#endif
#ifdef SI_NOINFO
{ SI_NOINFO, "SI_NOINFO" },
XLAT(SI_NOINFO),
#endif
#ifdef SI_LWP
{ SI_LWP, "SI_LWP" },
XLAT(SI_LWP),
#endif
{ 0, NULL },
};
static const struct xlat sigill_codes[] = {
{ ILL_ILLOPC, "ILL_ILLOPC" },
{ ILL_ILLOPN, "ILL_ILLOPN" },
{ ILL_ILLADR, "ILL_ILLADR" },
{ ILL_ILLTRP, "ILL_ILLTRP" },
{ ILL_PRVOPC, "ILL_PRVOPC" },
{ ILL_PRVREG, "ILL_PRVREG" },
{ ILL_COPROC, "ILL_COPROC" },
{ ILL_BADSTK, "ILL_BADSTK" },
XLAT(ILL_ILLOPC),
XLAT(ILL_ILLOPN),
XLAT(ILL_ILLADR),
XLAT(ILL_ILLTRP),
XLAT(ILL_PRVOPC),
XLAT(ILL_PRVREG),
XLAT(ILL_COPROC),
XLAT(ILL_BADSTK),
{ 0, NULL },
};
static const struct xlat sigfpe_codes[] = {
{ FPE_INTDIV, "FPE_INTDIV" },
{ FPE_INTOVF, "FPE_INTOVF" },
{ FPE_FLTDIV, "FPE_FLTDIV" },
{ FPE_FLTOVF, "FPE_FLTOVF" },
{ FPE_FLTUND, "FPE_FLTUND" },
{ FPE_FLTRES, "FPE_FLTRES" },
{ FPE_FLTINV, "FPE_FLTINV" },
{ FPE_FLTSUB, "FPE_FLTSUB" },
XLAT(FPE_INTDIV),
XLAT(FPE_INTOVF),
XLAT(FPE_FLTDIV),
XLAT(FPE_FLTOVF),
XLAT(FPE_FLTUND),
XLAT(FPE_FLTRES),
XLAT(FPE_FLTINV),
XLAT(FPE_FLTSUB),
{ 0, NULL },
};
static const struct xlat sigtrap_codes[] = {
{ TRAP_BRKPT, "TRAP_BRKPT" },
{ TRAP_TRACE, "TRAP_TRACE" },
XLAT(TRAP_BRKPT),
XLAT(TRAP_TRACE),
{ 0, NULL },
};
static const struct xlat sigchld_codes[] = {
{ CLD_EXITED, "CLD_EXITED" },
{ CLD_KILLED, "CLD_KILLED" },
{ CLD_DUMPED, "CLD_DUMPED" },
{ CLD_TRAPPED, "CLD_TRAPPED" },
{ CLD_STOPPED, "CLD_STOPPED" },
{ CLD_CONTINUED,"CLD_CONTINUED" },
XLAT(CLD_EXITED),
XLAT(CLD_KILLED),
XLAT(CLD_DUMPED),
XLAT(CLD_TRAPPED),
XLAT(CLD_STOPPED),
XLAT(CLD_CONTINUED),
{ 0, NULL },
};
static const struct xlat sigpoll_codes[] = {
{ POLL_IN, "POLL_IN" },
{ POLL_OUT, "POLL_OUT" },
{ POLL_MSG, "POLL_MSG" },
{ POLL_ERR, "POLL_ERR" },
{ POLL_PRI, "POLL_PRI" },
{ POLL_HUP, "POLL_HUP" },
XLAT(POLL_IN),
XLAT(POLL_OUT),
XLAT(POLL_MSG),
XLAT(POLL_ERR),
XLAT(POLL_PRI),
XLAT(POLL_HUP),
{ 0, NULL },
};
static const struct xlat sigprof_codes[] = {
#ifdef PROF_SIG
{ PROF_SIG, "PROF_SIG" },
XLAT(PROF_SIG),
#endif
{ 0, NULL },
};
@ -471,22 +471,22 @@ static const struct xlat sigprof_codes[] = {
#ifdef SIGEMT
static const struct xlat sigemt_codes[] = {
#ifdef EMT_TAGOVF
{ EMT_TAGOVF, "EMT_TAGOVF" },
XLAT(EMT_TAGOVF),
#endif
{ 0, NULL },
};
#endif
static const struct xlat sigsegv_codes[] = {
{ SEGV_MAPERR, "SEGV_MAPERR" },
{ SEGV_ACCERR, "SEGV_ACCERR" },
XLAT(SEGV_MAPERR),
XLAT(SEGV_ACCERR),
{ 0, NULL },
};
static const struct xlat sigbus_codes[] = {
{ BUS_ADRALN, "BUS_ADRALN" },
{ BUS_ADRERR, "BUS_ADRERR" },
{ BUS_OBJERR, "BUS_OBJERR" },
XLAT(BUS_ADRALN),
XLAT(BUS_ADRERR),
XLAT(BUS_OBJERR),
{ 0, NULL },
};
@ -1081,8 +1081,8 @@ sys_sigsuspend(struct tcb *tcp)
#endif
static const struct xlat sigaltstack_flags[] = {
{ SS_ONSTACK, "SS_ONSTACK" },
{ SS_DISABLE, "SS_DISABLE" },
XLAT(SS_ONSTACK),
XLAT(SS_DISABLE),
{ 0, NULL },
};

30
sock.c
View File

@ -39,21 +39,21 @@
#include <net/if.h>
static const struct xlat iffflags[] = {
{ IFF_UP, "IFF_UP" },
{ IFF_BROADCAST, "IFF_BROADCAST" },
{ IFF_DEBUG, "IFF_DEBUG" },
{ IFF_LOOPBACK, "IFF_LOOPBACK" },
{ IFF_POINTOPOINT, "IFF_POINTOPOINT" },
{ IFF_NOTRAILERS, "IFF_NOTRAILERS" },
{ IFF_RUNNING, "IFF_RUNNING" },
{ IFF_NOARP, "IFF_NOARP" },
{ IFF_PROMISC, "IFF_PROMISC" },
{ IFF_ALLMULTI, "IFF_ALLMULTI" },
{ IFF_MASTER, "IFF_MASTER" },
{ IFF_SLAVE, "IFF_SLAVE" },
{ IFF_MULTICAST, "IFF_MULTICAST" },
{ IFF_PORTSEL, "IFF_PORTSEL" },
{ IFF_AUTOMEDIA, "IFF_AUTOMEDIA" },
XLAT(IFF_UP),
XLAT(IFF_BROADCAST),
XLAT(IFF_DEBUG),
XLAT(IFF_LOOPBACK),
XLAT(IFF_POINTOPOINT),
XLAT(IFF_NOTRAILERS),
XLAT(IFF_RUNNING),
XLAT(IFF_NOARP),
XLAT(IFF_PROMISC),
XLAT(IFF_ALLMULTI),
XLAT(IFF_MASTER),
XLAT(IFF_SLAVE),
XLAT(IFF_MULTICAST),
XLAT(IFF_PORTSEL),
XLAT(IFF_AUTOMEDIA),
{ 0, NULL }
};

28
stream.c
View File

@ -56,7 +56,7 @@ struct strbuf {
# endif
static const struct xlat msgflags[] = {
{ RS_HIPRI, "RS_HIPRI" },
XLAT(RS_HIPRI),
{ 0, NULL },
};
@ -155,13 +155,13 @@ sys_getmsg(struct tcb *tcp)
# if defined SYS_putpmsg || defined SYS_getpmsg
static const struct xlat pmsgflags[] = {
# ifdef MSG_HIPRI
{ MSG_HIPRI, "MSG_HIPRI" },
XLAT(MSG_HIPRI),
# endif
# ifdef MSG_AND
{ MSG_ANY, "MSG_ANY" },
XLAT(MSG_ANY),
# endif
# ifdef MSG_BAND
{ MSG_BAND, "MSG_BAND" },
XLAT(MSG_BAND),
# endif
{ 0, NULL },
};
@ -244,24 +244,24 @@ sys_getpmsg(struct tcb *tcp)
static const struct xlat pollflags[] = {
# ifdef POLLIN
{ POLLIN, "POLLIN" },
{ POLLPRI, "POLLPRI" },
{ POLLOUT, "POLLOUT" },
XLAT(POLLIN),
XLAT(POLLPRI),
XLAT(POLLOUT),
# ifdef POLLRDNORM
{ POLLRDNORM, "POLLRDNORM" },
XLAT(POLLRDNORM),
# endif
# ifdef POLLWRNORM
{ POLLWRNORM, "POLLWRNORM" },
XLAT(POLLWRNORM),
# endif
# ifdef POLLRDBAND
{ POLLRDBAND, "POLLRDBAND" },
XLAT(POLLRDBAND),
# endif
# ifdef POLLWRBAND
{ POLLWRBAND, "POLLWRBAND" },
XLAT(POLLWRBAND),
# endif
{ POLLERR, "POLLERR" },
{ POLLHUP, "POLLHUP" },
{ POLLNVAL, "POLLNVAL" },
XLAT(POLLERR),
XLAT(POLLHUP),
XLAT(POLLNVAL),
# endif
{ 0, NULL },
};

470
system.c
View File

@ -81,33 +81,33 @@
#include <linux/sysctl.h>
static const struct xlat mount_flags[] = {
{ MS_MGC_VAL, "MS_MGC_VAL" },
{ MS_RDONLY, "MS_RDONLY" },
{ MS_NOSUID, "MS_NOSUID" },
{ MS_NODEV, "MS_NODEV" },
{ MS_NOEXEC, "MS_NOEXEC" },
{ MS_SYNCHRONOUS,"MS_SYNCHRONOUS"},
{ MS_REMOUNT, "MS_REMOUNT" },
{ MS_RELATIME, "MS_RELATIME" },
{ MS_KERNMOUNT, "MS_KERNMOUNT" },
{ MS_I_VERSION, "MS_I_VERSION" },
{ MS_STRICTATIME,"MS_STRICTATIME"},
{ MS_NOSEC, "MS_NOSEC" },
{ MS_BORN, "MS_BORN" },
{ MS_MANDLOCK, "MS_MANDLOCK" },
{ MS_NOATIME, "MS_NOATIME" },
{ MS_NODIRATIME,"MS_NODIRATIME" },
{ MS_BIND, "MS_BIND" },
{ MS_MOVE, "MS_MOVE" },
{ MS_REC, "MS_REC" },
{ MS_SILENT, "MS_SILENT" },
{ MS_POSIXACL, "MS_POSIXACL" },
{ MS_UNBINDABLE,"MS_UNBINDABLE" },
{ MS_PRIVATE, "MS_PRIVATE" },
{ MS_SLAVE, "MS_SLAVE" },
{ MS_SHARED, "MS_SHARED" },
{ MS_ACTIVE, "MS_ACTIVE" },
{ MS_NOUSER, "MS_NOUSER" },
XLAT(MS_MGC_VAL),
XLAT(MS_RDONLY),
XLAT(MS_NOSUID),
XLAT(MS_NODEV),
XLAT(MS_NOEXEC),
XLAT(MS_SYNCHRONOUS),
XLAT(MS_REMOUNT),
XLAT(MS_RELATIME),
XLAT(MS_KERNMOUNT),
XLAT(MS_I_VERSION),
XLAT(MS_STRICTATIME),
XLAT(MS_NOSEC),
XLAT(MS_BORN),
XLAT(MS_MANDLOCK),
XLAT(MS_NOATIME),
XLAT(MS_NODIRATIME),
XLAT(MS_BIND),
XLAT(MS_MOVE),
XLAT(MS_REC),
XLAT(MS_SILENT),
XLAT(MS_POSIXACL),
XLAT(MS_UNBINDABLE),
XLAT(MS_PRIVATE),
XLAT(MS_SLAVE),
XLAT(MS_SHARED),
XLAT(MS_ACTIVE),
XLAT(MS_NOUSER),
{ 0, NULL },
};
@ -155,9 +155,9 @@ sys_mount(struct tcb *tcp)
#define MNT_EXPIRE 0x00000004 /* Mark for expiry */
static const struct xlat umount_flags[] = {
{ MNT_FORCE, "MNT_FORCE" },
{ MNT_DETACH, "MNT_DETACH" },
{ MNT_EXPIRE, "MNT_EXPIRE" },
XLAT(MNT_FORCE),
XLAT(MNT_DETACH),
XLAT(MNT_EXPIRE),
{ 0, NULL },
};
@ -222,17 +222,17 @@ enum {
};
static const struct xlat syslog_action_type[] = {
{ SYSLOG_ACTION_CLOSE, "SYSLOG_ACTION_CLOSE" },
{ SYSLOG_ACTION_OPEN, "SYSLOG_ACTION_OPEN" },
{ SYSLOG_ACTION_READ, "SYSLOG_ACTION_READ" },
{ SYSLOG_ACTION_READ_ALL, "SYSLOG_ACTION_READ_ALL" },
{ SYSLOG_ACTION_READ_CLEAR, "SYSLOG_ACTION_READ_CLEAR" },
{ SYSLOG_ACTION_CLEAR, "SYSLOG_ACTION_CLEAR" },
{ SYSLOG_ACTION_CONSOLE_OFF, "SYSLOG_ACTION_CONSOLE_OFF" },
{ SYSLOG_ACTION_CONSOLE_ON, "SYSLOG_ACTION_CONSOLE_ON" },
{ SYSLOG_ACTION_CONSOLE_LEVEL, "SYSLOG_ACTION_CONSOLE_LEVEL" },
{ SYSLOG_ACTION_SIZE_UNREAD, "SYSLOG_ACTION_SIZE_UNREAD" },
{ SYSLOG_ACTION_SIZE_BUFFER, "SYSLOG_ACTION_SIZE_BUFFER" },
XLAT(SYSLOG_ACTION_CLOSE),
XLAT(SYSLOG_ACTION_OPEN),
XLAT(SYSLOG_ACTION_READ),
XLAT(SYSLOG_ACTION_READ_ALL),
XLAT(SYSLOG_ACTION_READ_CLEAR),
XLAT(SYSLOG_ACTION_CLEAR),
XLAT(SYSLOG_ACTION_CONSOLE_OFF),
XLAT(SYSLOG_ACTION_CONSOLE_ON),
XLAT(SYSLOG_ACTION_CONSOLE_LEVEL),
XLAT(SYSLOG_ACTION_SIZE_UNREAD),
XLAT(SYSLOG_ACTION_SIZE_BUFFER),
{ 0, NULL }
};
@ -275,24 +275,24 @@ sys_syslog(struct tcb *tcp)
#include <linux/reboot.h>
static const struct xlat bootflags1[] = {
{ LINUX_REBOOT_MAGIC1, "LINUX_REBOOT_MAGIC1" },
XLAT(LINUX_REBOOT_MAGIC1),
{ 0, NULL },
};
static const struct xlat bootflags2[] = {
{ LINUX_REBOOT_MAGIC2, "LINUX_REBOOT_MAGIC2" },
{ LINUX_REBOOT_MAGIC2A, "LINUX_REBOOT_MAGIC2A" },
{ LINUX_REBOOT_MAGIC2B, "LINUX_REBOOT_MAGIC2B" },
XLAT(LINUX_REBOOT_MAGIC2),
XLAT(LINUX_REBOOT_MAGIC2A),
XLAT(LINUX_REBOOT_MAGIC2B),
{ 0, NULL },
};
static const struct xlat bootflags3[] = {
{ LINUX_REBOOT_CMD_CAD_OFF, "LINUX_REBOOT_CMD_CAD_OFF" },
{ LINUX_REBOOT_CMD_RESTART, "LINUX_REBOOT_CMD_RESTART" },
{ LINUX_REBOOT_CMD_HALT, "LINUX_REBOOT_CMD_HALT" },
{ LINUX_REBOOT_CMD_CAD_ON, "LINUX_REBOOT_CMD_CAD_ON" },
{ LINUX_REBOOT_CMD_POWER_OFF, "LINUX_REBOOT_CMD_POWER_OFF" },
{ LINUX_REBOOT_CMD_RESTART2, "LINUX_REBOOT_CMD_RESTART2" },
XLAT(LINUX_REBOOT_CMD_CAD_OFF),
XLAT(LINUX_REBOOT_CMD_RESTART),
XLAT(LINUX_REBOOT_CMD_HALT),
XLAT(LINUX_REBOOT_CMD_CAD_ON),
XLAT(LINUX_REBOOT_CMD_POWER_OFF),
XLAT(LINUX_REBOOT_CMD_RESTART2),
{ 0, NULL },
};
@ -316,26 +316,26 @@ sys_reboot(struct tcb *tcp)
#ifdef M68K
static const struct xlat cacheflush_scope[] = {
#ifdef FLUSH_SCOPE_LINE
{ FLUSH_SCOPE_LINE, "FLUSH_SCOPE_LINE" },
XLAT(FLUSH_SCOPE_LINE),
#endif
#ifdef FLUSH_SCOPE_PAGE
{ FLUSH_SCOPE_PAGE, "FLUSH_SCOPE_PAGE" },
XLAT(FLUSH_SCOPE_PAGE),
#endif
#ifdef FLUSH_SCOPE_ALL
{ FLUSH_SCOPE_ALL, "FLUSH_SCOPE_ALL" },
XLAT(FLUSH_SCOPE_ALL),
#endif
{ 0, NULL },
};
static const struct xlat cacheflush_flags[] = {
#ifdef FLUSH_CACHE_BOTH
{ FLUSH_CACHE_BOTH, "FLUSH_CACHE_BOTH" },
XLAT(FLUSH_CACHE_BOTH),
#endif
#ifdef FLUSH_CACHE_DATA
{ FLUSH_CACHE_DATA, "FLUSH_CACHE_DATA" },
XLAT(FLUSH_CACHE_DATA),
#endif
#ifdef FLUSH_CACHE_INSN
{ FLUSH_CACHE_INSN, "FLUSH_CACHE_INSN" },
XLAT(FLUSH_CACHE_INSN),
#endif
{ 0, NULL },
};
@ -363,11 +363,11 @@ sys_cacheflush(struct tcb *tcp)
#include <bfin_sram.h>
static const struct xlat sram_alloc_flags[] = {
{ L1_INST_SRAM, "L1_INST_SRAM" },
{ L1_DATA_A_SRAM, "L1_DATA_A_SRAM" },
{ L1_DATA_B_SRAM, "L1_DATA_B_SRAM" },
{ L1_DATA_SRAM, "L1_DATA_SRAM" },
{ L2_SRAM, "L2_SRAM" },
XLAT(L1_INST_SRAM),
XLAT(L1_DATA_A_SRAM),
XLAT(L1_DATA_B_SRAM),
XLAT(L1_DATA_SRAM),
XLAT(L2_SRAM),
{ 0, NULL },
};
@ -386,9 +386,9 @@ sys_sram_alloc(struct tcb *tcp)
#include <asm/cachectl.h>
static const struct xlat cacheflush_flags[] = {
{ ICACHE, "ICACHE" },
{ DCACHE, "DCACHE" },
{ BCACHE, "BCACHE" },
XLAT(ICACHE),
XLAT(DCACHE),
XLAT(BCACHE),
{ 0, NULL },
};
@ -411,16 +411,16 @@ sys_cacheflush(struct tcb *tcp)
#ifdef SH
static const struct xlat cacheflush_flags[] = {
#ifdef CACHEFLUSH_D_INVAL
{ CACHEFLUSH_D_INVAL, "CACHEFLUSH_D_INVAL" },
XLAT(CACHEFLUSH_D_INVAL),
#endif
#ifdef CACHEFLUSH_D_WB
{ CACHEFLUSH_D_WB, "CACHEFLUSH_D_WB" },
XLAT(CACHEFLUSH_D_WB),
#endif
#ifdef CACHEFLUSH_D_PURGE
{ CACHEFLUSH_D_PURGE, "CACHEFLUSH_D_PURGE" },
XLAT(CACHEFLUSH_D_PURGE),
#endif
#ifdef CACHEFLUSH_I
{ CACHEFLUSH_I, "CACHEFLUSH_I" },
XLAT(CACHEFLUSH_I),
#endif
{ 0, NULL },
};
@ -499,9 +499,9 @@ static const struct xlat capabilities[] = {
#endif
static const struct xlat cap_version[] = {
{ _LINUX_CAPABILITY_VERSION_1, "_LINUX_CAPABILITY_VERSION_1" },
{ _LINUX_CAPABILITY_VERSION_2, "_LINUX_CAPABILITY_VERSION_3" },
{ _LINUX_CAPABILITY_VERSION_3, "_LINUX_CAPABILITY_VERSION_3" },
XLAT(_LINUX_CAPABILITY_VERSION_1),
XLAT(_LINUX_CAPABILITY_VERSION_2),
XLAT(_LINUX_CAPABILITY_VERSION_3),
{ 0, NULL }
};
@ -590,244 +590,244 @@ int sys_capset(struct tcb *tcp)
# define CTL_PROC 4
# define CTL_CPU 10 /* older headers lack */
static const struct xlat sysctl_root[] = {
{ CTL_KERN, "CTL_KERN" },
{ CTL_VM, "CTL_VM" },
{ CTL_NET, "CTL_NET" },
{ CTL_PROC, "CTL_PROC" },
{ CTL_FS, "CTL_FS" },
{ CTL_DEBUG, "CTL_DEBUG" },
{ CTL_DEV, "CTL_DEV" },
{ CTL_BUS, "CTL_BUS" },
{ CTL_ABI, "CTL_ABI" },
{ CTL_CPU, "CTL_CPU" },
XLAT(CTL_KERN),
XLAT(CTL_VM),
XLAT(CTL_NET),
XLAT(CTL_PROC),
XLAT(CTL_FS),
XLAT(CTL_DEBUG),
XLAT(CTL_DEV),
XLAT(CTL_BUS),
XLAT(CTL_ABI),
XLAT(CTL_CPU),
{ 0, NULL }
};
static const struct xlat sysctl_kern[] = {
{ KERN_OSTYPE, "KERN_OSTYPE" },
{ KERN_OSRELEASE, "KERN_OSRELEASE" },
{ KERN_OSREV, "KERN_OSREV" },
{ KERN_VERSION, "KERN_VERSION" },
{ KERN_SECUREMASK, "KERN_SECUREMASK" },
{ KERN_PROF, "KERN_PROF" },
{ KERN_NODENAME, "KERN_NODENAME" },
{ KERN_DOMAINNAME, "KERN_DOMAINNAME" },
XLAT(KERN_OSTYPE),
XLAT(KERN_OSRELEASE),
XLAT(KERN_OSREV),
XLAT(KERN_VERSION),
XLAT(KERN_SECUREMASK),
XLAT(KERN_PROF),
XLAT(KERN_NODENAME),
XLAT(KERN_DOMAINNAME),
#ifdef KERN_SECURELVL
{ KERN_SECURELVL, "KERN_SECURELVL" },
XLAT(KERN_SECURELVL),
#endif
{ KERN_PANIC, "KERN_PANIC" },
XLAT(KERN_PANIC),
#ifdef KERN_REALROOTDEV
{ KERN_REALROOTDEV, "KERN_REALROOTDEV" },
XLAT(KERN_REALROOTDEV),
#endif
#ifdef KERN_JAVA_INTERPRETER
{ KERN_JAVA_INTERPRETER, "KERN_JAVA_INTERPRETER" },
XLAT(KERN_JAVA_INTERPRETER),
#endif
#ifdef KERN_JAVA_APPLETVIEWER
{ KERN_JAVA_APPLETVIEWER, "KERN_JAVA_APPLETVIEWER" },
XLAT(KERN_JAVA_APPLETVIEWER),
#endif
{ KERN_SPARC_REBOOT, "KERN_SPARC_REBOOT" },
{ KERN_CTLALTDEL, "KERN_CTLALTDEL" },
{ KERN_PRINTK, "KERN_PRINTK" },
{ KERN_NAMETRANS, "KERN_NAMETRANS" },
{ KERN_PPC_HTABRECLAIM, "KERN_PPC_HTABRECLAIM" },
{ KERN_PPC_ZEROPAGED, "KERN_PPC_ZEROPAGED" },
{ KERN_PPC_POWERSAVE_NAP, "KERN_PPC_POWERSAVE_NAP" },
{ KERN_MODPROBE, "KERN_MODPROBE" },
{ KERN_SG_BIG_BUFF, "KERN_SG_BIG_BUFF" },
{ KERN_ACCT, "KERN_ACCT" },
{ KERN_PPC_L2CR, "KERN_PPC_L2CR" },
{ KERN_RTSIGNR, "KERN_RTSIGNR" },
{ KERN_RTSIGMAX, "KERN_RTSIGMAX" },
{ KERN_SHMMAX, "KERN_SHMMAX" },
{ KERN_MSGMAX, "KERN_MSGMAX" },
{ KERN_MSGMNB, "KERN_MSGMNB" },
{ KERN_MSGPOOL, "KERN_MSGPOOL" },
XLAT(KERN_SPARC_REBOOT),
XLAT(KERN_CTLALTDEL),
XLAT(KERN_PRINTK),
XLAT(KERN_NAMETRANS),
XLAT(KERN_PPC_HTABRECLAIM),
XLAT(KERN_PPC_ZEROPAGED),
XLAT(KERN_PPC_POWERSAVE_NAP),
XLAT(KERN_MODPROBE),
XLAT(KERN_SG_BIG_BUFF),
XLAT(KERN_ACCT),
XLAT(KERN_PPC_L2CR),
XLAT(KERN_RTSIGNR),
XLAT(KERN_RTSIGMAX),
XLAT(KERN_SHMMAX),
XLAT(KERN_MSGMAX),
XLAT(KERN_MSGMNB),
XLAT(KERN_MSGPOOL),
{ 0, NULL }
};
static const struct xlat sysctl_vm[] = {
#ifdef VM_SWAPCTL
{ VM_SWAPCTL, "VM_SWAPCTL" },
XLAT(VM_SWAPCTL),
#endif
#ifdef VM_UNUSED1
{ VM_UNUSED1, "VM_UNUSED1" },
XLAT(VM_UNUSED1),
#endif
#ifdef VM_SWAPOUT
{ VM_SWAPOUT, "VM_SWAPOUT" },
XLAT(VM_SWAPOUT),
#endif
#ifdef VM_UNUSED2
{ VM_UNUSED2, "VM_UNUSED2" },
XLAT(VM_UNUSED2),
#endif
#ifdef VM_FREEPG
{ VM_FREEPG, "VM_FREEPG" },
XLAT(VM_FREEPG),
#endif
#ifdef VM_UNUSED3
{ VM_UNUSED3, "VM_UNUSED3" },
XLAT(VM_UNUSED3),
#endif
#ifdef VM_BDFLUSH
{ VM_BDFLUSH, "VM_BDFLUSH" },
XLAT(VM_BDFLUSH),
#endif
#ifdef VM_UNUSED4
{ VM_UNUSED4, "VM_UNUSED4" },
XLAT(VM_UNUSED4),
#endif
{ VM_OVERCOMMIT_MEMORY, "VM_OVERCOMMIT_MEMORY" },
XLAT(VM_OVERCOMMIT_MEMORY),
#ifdef VM_BUFFERMEM
{ VM_BUFFERMEM, "VM_BUFFERMEM" },
XLAT(VM_BUFFERMEM),
#endif
#ifdef VM_UNUSED5
{ VM_UNUSED5, "VM_UNUSED5" },
XLAT(VM_UNUSED5),
#endif
#ifdef VM_PAGECACHE
{ VM_PAGECACHE, "VM_PAGECACHE" },
XLAT(VM_PAGECACHE),
#endif
#ifdef VM_UNUSED7
{ VM_UNUSED7, "VM_UNUSED7" },
XLAT(VM_UNUSED7),
#endif
#ifdef VM_PAGERDAEMON
{ VM_PAGERDAEMON, "VM_PAGERDAEMON" },
XLAT(VM_PAGERDAEMON),
#endif
#ifdef VM_UNUSED8
{ VM_UNUSED8, "VM_UNUSED8" },
XLAT(VM_UNUSED8),
#endif
#ifdef VM_PGT_CACHE
{ VM_PGT_CACHE, "VM_PGT_CACHE" },
XLAT(VM_PGT_CACHE),
#endif
#ifdef VM_UNUSED9
{ VM_UNUSED9, "VM_UNUSED9" },
XLAT(VM_UNUSED9),
#endif
{ VM_PAGE_CLUSTER, "VM_PAGE_CLUSTER" },
XLAT(VM_PAGE_CLUSTER),
{ 0, NULL },
};
static const struct xlat sysctl_net[] = {
{ NET_CORE, "NET_CORE" },
{ NET_ETHER, "NET_ETHER" },
{ NET_802, "NET_802" },
{ NET_UNIX, "NET_UNIX" },
{ NET_IPV4, "NET_IPV4" },
{ NET_IPX, "NET_IPX" },
{ NET_ATALK, "NET_ATALK" },
{ NET_NETROM, "NET_NETROM" },
{ NET_AX25, "NET_AX25" },
{ NET_BRIDGE, "NET_BRIDGE" },
{ NET_ROSE, "NET_ROSE" },
{ NET_IPV6, "NET_IPV6" },
{ NET_X25, "NET_X25" },
{ NET_TR, "NET_TR" },
{ NET_DECNET, "NET_DECNET" },
XLAT(NET_CORE),
XLAT(NET_ETHER),
XLAT(NET_802),
XLAT(NET_UNIX),
XLAT(NET_IPV4),
XLAT(NET_IPX),
XLAT(NET_ATALK),
XLAT(NET_NETROM),
XLAT(NET_AX25),
XLAT(NET_BRIDGE),
XLAT(NET_ROSE),
XLAT(NET_IPV6),
XLAT(NET_X25),
XLAT(NET_TR),
XLAT(NET_DECNET),
{ 0, NULL }
};
static const struct xlat sysctl_net_core[] = {
{ NET_CORE_WMEM_MAX, "NET_CORE_WMEM_MAX" },
{ NET_CORE_RMEM_MAX, "NET_CORE_RMEM_MAX" },
{ NET_CORE_WMEM_DEFAULT, "NET_CORE_WMEM_DEFAULT" },
{ NET_CORE_RMEM_DEFAULT, "NET_CORE_RMEM_DEFAULT" },
{ NET_CORE_MAX_BACKLOG, "NET_CORE_MAX_BACKLOG" },
{ NET_CORE_FASTROUTE, "NET_CORE_FASTROUTE" },
{ NET_CORE_MSG_COST, "NET_CORE_MSG_COST" },
{ NET_CORE_MSG_BURST, "NET_CORE_MSG_BURST" },
{ NET_CORE_OPTMEM_MAX, "NET_CORE_OPTMEM_MAX" },
XLAT(NET_CORE_WMEM_MAX),
XLAT(NET_CORE_RMEM_MAX),
XLAT(NET_CORE_WMEM_DEFAULT),
XLAT(NET_CORE_RMEM_DEFAULT),
XLAT(NET_CORE_MAX_BACKLOG),
XLAT(NET_CORE_FASTROUTE),
XLAT(NET_CORE_MSG_COST),
XLAT(NET_CORE_MSG_BURST),
XLAT(NET_CORE_OPTMEM_MAX),
{ 0, NULL }
};
static const struct xlat sysctl_net_unix[] = {
{ NET_UNIX_DESTROY_DELAY, "NET_UNIX_DESTROY_DELAY" },
{ NET_UNIX_DELETE_DELAY, "NET_UNIX_DELETE_DELAY" },
XLAT(NET_UNIX_DESTROY_DELAY),
XLAT(NET_UNIX_DELETE_DELAY),
{ 0, NULL }
};
static const struct xlat sysctl_net_ipv4[] = {
{ NET_IPV4_FORWARD, "NET_IPV4_FORWARD" },
{ NET_IPV4_DYNADDR, "NET_IPV4_DYNADDR" },
{ NET_IPV4_CONF, "NET_IPV4_CONF" },
{ NET_IPV4_NEIGH, "NET_IPV4_NEIGH" },
{ NET_IPV4_ROUTE, "NET_IPV4_ROUTE" },
{ NET_IPV4_FIB_HASH, "NET_IPV4_FIB_HASH" },
{ NET_IPV4_TCP_TIMESTAMPS, "NET_IPV4_TCP_TIMESTAMPS" },
{ NET_IPV4_TCP_WINDOW_SCALING, "NET_IPV4_TCP_WINDOW_SCALING" },
{ NET_IPV4_TCP_SACK, "NET_IPV4_TCP_SACK" },
{ NET_IPV4_TCP_RETRANS_COLLAPSE, "NET_IPV4_TCP_RETRANS_COLLAPSE" },
{ NET_IPV4_DEFAULT_TTL, "NET_IPV4_DEFAULT_TTL" },
{ NET_IPV4_AUTOCONFIG, "NET_IPV4_AUTOCONFIG" },
{ NET_IPV4_NO_PMTU_DISC, "NET_IPV4_NO_PMTU_DISC" },
{ NET_IPV4_TCP_SYN_RETRIES, "NET_IPV4_TCP_SYN_RETRIES" },
{ NET_IPV4_IPFRAG_HIGH_THRESH, "NET_IPV4_IPFRAG_HIGH_THRESH" },
{ NET_IPV4_IPFRAG_LOW_THRESH, "NET_IPV4_IPFRAG_LOW_THRESH" },
{ NET_IPV4_IPFRAG_TIME, "NET_IPV4_IPFRAG_TIME" },
{ NET_IPV4_TCP_MAX_KA_PROBES, "NET_IPV4_TCP_MAX_KA_PROBES" },
{ NET_IPV4_TCP_KEEPALIVE_TIME, "NET_IPV4_TCP_KEEPALIVE_TIME" },
{ NET_IPV4_TCP_KEEPALIVE_PROBES, "NET_IPV4_TCP_KEEPALIVE_PROBES" },
{ NET_IPV4_TCP_RETRIES1, "NET_IPV4_TCP_RETRIES1" },
{ NET_IPV4_TCP_RETRIES2, "NET_IPV4_TCP_RETRIES2" },
{ NET_IPV4_TCP_FIN_TIMEOUT, "NET_IPV4_TCP_FIN_TIMEOUT" },
{ NET_IPV4_IP_MASQ_DEBUG, "NET_IPV4_IP_MASQ_DEBUG" },
{ NET_TCP_SYNCOOKIES, "NET_TCP_SYNCOOKIES" },
{ NET_TCP_STDURG, "NET_TCP_STDURG" },
{ NET_TCP_RFC1337, "NET_TCP_RFC1337" },
{ NET_TCP_SYN_TAILDROP, "NET_TCP_SYN_TAILDROP" },
{ NET_TCP_MAX_SYN_BACKLOG, "NET_TCP_MAX_SYN_BACKLOG" },
{ NET_IPV4_LOCAL_PORT_RANGE, "NET_IPV4_LOCAL_PORT_RANGE" },
{ NET_IPV4_ICMP_ECHO_IGNORE_ALL, "NET_IPV4_ICMP_ECHO_IGNORE_ALL" },
{ NET_IPV4_ICMP_ECHO_IGNORE_BROADCASTS, "NET_IPV4_ICMP_ECHO_IGNORE_BROADCASTS" },
{ NET_IPV4_ICMP_SOURCEQUENCH_RATE, "NET_IPV4_ICMP_SOURCEQUENCH_RATE" },
{ NET_IPV4_ICMP_DESTUNREACH_RATE, "NET_IPV4_ICMP_DESTUNREACH_RATE" },
{ NET_IPV4_ICMP_TIMEEXCEED_RATE, "NET_IPV4_ICMP_TIMEEXCEED_RATE" },
{ NET_IPV4_ICMP_PARAMPROB_RATE, "NET_IPV4_ICMP_PARAMPROB_RATE" },
{ NET_IPV4_ICMP_ECHOREPLY_RATE, "NET_IPV4_ICMP_ECHOREPLY_RATE" },
{ NET_IPV4_ICMP_IGNORE_BOGUS_ERROR_RESPONSES, "NET_IPV4_ICMP_IGNORE_BOGUS_ERROR_RESPONSES" },
{ NET_IPV4_IGMP_MAX_MEMBERSHIPS, "NET_IPV4_IGMP_MAX_MEMBERSHIPS" },
XLAT(NET_IPV4_FORWARD),
XLAT(NET_IPV4_DYNADDR),
XLAT(NET_IPV4_CONF),
XLAT(NET_IPV4_NEIGH),
XLAT(NET_IPV4_ROUTE),
XLAT(NET_IPV4_FIB_HASH),
XLAT(NET_IPV4_TCP_TIMESTAMPS),
XLAT(NET_IPV4_TCP_WINDOW_SCALING),
XLAT(NET_IPV4_TCP_SACK),
XLAT(NET_IPV4_TCP_RETRANS_COLLAPSE),
XLAT(NET_IPV4_DEFAULT_TTL),
XLAT(NET_IPV4_AUTOCONFIG),
XLAT(NET_IPV4_NO_PMTU_DISC),
XLAT(NET_IPV4_TCP_SYN_RETRIES),
XLAT(NET_IPV4_IPFRAG_HIGH_THRESH),
XLAT(NET_IPV4_IPFRAG_LOW_THRESH),
XLAT(NET_IPV4_IPFRAG_TIME),
XLAT(NET_IPV4_TCP_MAX_KA_PROBES),
XLAT(NET_IPV4_TCP_KEEPALIVE_TIME),
XLAT(NET_IPV4_TCP_KEEPALIVE_PROBES),
XLAT(NET_IPV4_TCP_RETRIES1),
XLAT(NET_IPV4_TCP_RETRIES2),
XLAT(NET_IPV4_TCP_FIN_TIMEOUT),
XLAT(NET_IPV4_IP_MASQ_DEBUG),
XLAT(NET_TCP_SYNCOOKIES),
XLAT(NET_TCP_STDURG),
XLAT(NET_TCP_RFC1337),
XLAT(NET_TCP_SYN_TAILDROP),
XLAT(NET_TCP_MAX_SYN_BACKLOG),
XLAT(NET_IPV4_LOCAL_PORT_RANGE),
XLAT(NET_IPV4_ICMP_ECHO_IGNORE_ALL),
XLAT(NET_IPV4_ICMP_ECHO_IGNORE_BROADCASTS),
XLAT(NET_IPV4_ICMP_SOURCEQUENCH_RATE),
XLAT(NET_IPV4_ICMP_DESTUNREACH_RATE),
XLAT(NET_IPV4_ICMP_TIMEEXCEED_RATE),
XLAT(NET_IPV4_ICMP_PARAMPROB_RATE),
XLAT(NET_IPV4_ICMP_ECHOREPLY_RATE),
XLAT(NET_IPV4_ICMP_IGNORE_BOGUS_ERROR_RESPONSES),
XLAT(NET_IPV4_IGMP_MAX_MEMBERSHIPS),
{ 0, NULL }
};
static const struct xlat sysctl_net_ipv4_route[] = {
{ NET_IPV4_ROUTE_FLUSH, "NET_IPV4_ROUTE_FLUSH" },
{ NET_IPV4_ROUTE_MIN_DELAY, "NET_IPV4_ROUTE_MIN_DELAY" },
{ NET_IPV4_ROUTE_MAX_DELAY, "NET_IPV4_ROUTE_MAX_DELAY" },
{ NET_IPV4_ROUTE_GC_THRESH, "NET_IPV4_ROUTE_GC_THRESH" },
{ NET_IPV4_ROUTE_MAX_SIZE, "NET_IPV4_ROUTE_MAX_SIZE" },
{ NET_IPV4_ROUTE_GC_MIN_INTERVAL, "NET_IPV4_ROUTE_GC_MIN_INTERVAL" },
{ NET_IPV4_ROUTE_GC_TIMEOUT, "NET_IPV4_ROUTE_GC_TIMEOUT" },
{ NET_IPV4_ROUTE_GC_INTERVAL, "NET_IPV4_ROUTE_GC_INTERVAL" },
{ NET_IPV4_ROUTE_REDIRECT_LOAD, "NET_IPV4_ROUTE_REDIRECT_LOAD" },
{ NET_IPV4_ROUTE_REDIRECT_NUMBER, "NET_IPV4_ROUTE_REDIRECT_NUMBER" },
{ NET_IPV4_ROUTE_REDIRECT_SILENCE, "NET_IPV4_ROUTE_REDIRECT_SILENCE" },
{ NET_IPV4_ROUTE_ERROR_COST, "NET_IPV4_ROUTE_ERROR_COST" },
{ NET_IPV4_ROUTE_ERROR_BURST, "NET_IPV4_ROUTE_ERROR_BURST" },
{ NET_IPV4_ROUTE_GC_ELASTICITY, "NET_IPV4_ROUTE_GC_ELASTICITY" },
XLAT(NET_IPV4_ROUTE_FLUSH),
XLAT(NET_IPV4_ROUTE_MIN_DELAY),
XLAT(NET_IPV4_ROUTE_MAX_DELAY),
XLAT(NET_IPV4_ROUTE_GC_THRESH),
XLAT(NET_IPV4_ROUTE_MAX_SIZE),
XLAT(NET_IPV4_ROUTE_GC_MIN_INTERVAL),
XLAT(NET_IPV4_ROUTE_GC_TIMEOUT),
XLAT(NET_IPV4_ROUTE_GC_INTERVAL),
XLAT(NET_IPV4_ROUTE_REDIRECT_LOAD),
XLAT(NET_IPV4_ROUTE_REDIRECT_NUMBER),
XLAT(NET_IPV4_ROUTE_REDIRECT_SILENCE),
XLAT(NET_IPV4_ROUTE_ERROR_COST),
XLAT(NET_IPV4_ROUTE_ERROR_BURST),
XLAT(NET_IPV4_ROUTE_GC_ELASTICITY),
{ 0, NULL }
};
static const struct xlat sysctl_net_ipv4_conf[] = {
{ NET_IPV4_CONF_FORWARDING, "NET_IPV4_CONF_FORWARDING" },
{ NET_IPV4_CONF_MC_FORWARDING, "NET_IPV4_CONF_MC_FORWARDING" },
{ NET_IPV4_CONF_PROXY_ARP, "NET_IPV4_CONF_PROXY_ARP" },
{ NET_IPV4_CONF_ACCEPT_REDIRECTS, "NET_IPV4_CONF_ACCEPT_REDIRECTS" },
{ NET_IPV4_CONF_SECURE_REDIRECTS, "NET_IPV4_CONF_SECURE_REDIRECTS" },
{ NET_IPV4_CONF_SEND_REDIRECTS, "NET_IPV4_CONF_SEND_REDIRECTS" },
{ NET_IPV4_CONF_SHARED_MEDIA, "NET_IPV4_CONF_SHARED_MEDIA" },
{ NET_IPV4_CONF_RP_FILTER, "NET_IPV4_CONF_RP_FILTER" },
{ NET_IPV4_CONF_ACCEPT_SOURCE_ROUTE, "NET_IPV4_CONF_ACCEPT_SOURCE_ROUTE" },
{ NET_IPV4_CONF_BOOTP_RELAY, "NET_IPV4_CONF_BOOTP_RELAY" },
{ NET_IPV4_CONF_LOG_MARTIANS, "NET_IPV4_CONF_LOG_MARTIANS" },
XLAT(NET_IPV4_CONF_FORWARDING),
XLAT(NET_IPV4_CONF_MC_FORWARDING),
XLAT(NET_IPV4_CONF_PROXY_ARP),
XLAT(NET_IPV4_CONF_ACCEPT_REDIRECTS),
XLAT(NET_IPV4_CONF_SECURE_REDIRECTS),
XLAT(NET_IPV4_CONF_SEND_REDIRECTS),
XLAT(NET_IPV4_CONF_SHARED_MEDIA),
XLAT(NET_IPV4_CONF_RP_FILTER),
XLAT(NET_IPV4_CONF_ACCEPT_SOURCE_ROUTE),
XLAT(NET_IPV4_CONF_BOOTP_RELAY),
XLAT(NET_IPV4_CONF_LOG_MARTIANS),
{ 0, NULL }
};
static const struct xlat sysctl_net_ipv6[] = {
{ NET_IPV6_CONF, "NET_IPV6_CONF" },
{ NET_IPV6_NEIGH, "NET_IPV6_NEIGH" },
{ NET_IPV6_ROUTE, "NET_IPV6_ROUTE" },
XLAT(NET_IPV6_CONF),
XLAT(NET_IPV6_NEIGH),
XLAT(NET_IPV6_ROUTE),
{ 0, NULL }
};
static const struct xlat sysctl_net_ipv6_route[] = {
{ NET_IPV6_ROUTE_FLUSH, "NET_IPV6_ROUTE_FLUSH" },
{ NET_IPV6_ROUTE_GC_THRESH, "NET_IPV6_ROUTE_GC_THRESH" },
{ NET_IPV6_ROUTE_MAX_SIZE, "NET_IPV6_ROUTE_MAX_SIZE" },
{ NET_IPV6_ROUTE_GC_MIN_INTERVAL, "NET_IPV6_ROUTE_GC_MIN_INTERVAL" },
{ NET_IPV6_ROUTE_GC_TIMEOUT, "NET_IPV6_ROUTE_GC_TIMEOUT" },
{ NET_IPV6_ROUTE_GC_INTERVAL, "NET_IPV6_ROUTE_GC_INTERVAL" },
{ NET_IPV6_ROUTE_GC_ELASTICITY, "NET_IPV6_ROUTE_GC_ELASTICITY" },
XLAT(NET_IPV6_ROUTE_FLUSH),
XLAT(NET_IPV6_ROUTE_GC_THRESH),
XLAT(NET_IPV6_ROUTE_MAX_SIZE),
XLAT(NET_IPV6_ROUTE_GC_MIN_INTERVAL),
XLAT(NET_IPV6_ROUTE_GC_TIMEOUT),
XLAT(NET_IPV6_ROUTE_GC_INTERVAL),
XLAT(NET_IPV6_ROUTE_GC_ELASTICITY),
{ 0, NULL }
};
@ -993,11 +993,11 @@ sys_sysctl(struct tcb *tcp)
#endif
static const struct xlat sysmips_operations[] = {
{ SETNAME, "SETNAME" },
{ FLUSH_CACHE, "FLUSH_CACHE" },
{ MIPS_FIXADE, "MIPS_FIXADE" },
{ MIPS_RDNVRAM, "MIPS_RDNVRAM" },
{ MIPS_ATOMIC_SET, "MIPS_ATOMIC_SET" },
XLAT(SETNAME),
XLAT(FLUSH_CACHE),
XLAT(MIPS_FIXADE),
XLAT(MIPS_RDNVRAM),
XLAT(MIPS_ATOMIC_SET),
{ 0, NULL }
};

102
term.c
View File

@ -36,130 +36,130 @@
#endif
static const struct xlat tcxonc_options[] = {
{ TCOOFF, "TCOOFF" },
{ TCOON, "TCOON" },
{ TCIOFF, "TCIOFF" },
{ TCION, "TCION" },
XLAT(TCOOFF),
XLAT(TCOON),
XLAT(TCIOFF),
XLAT(TCION),
{ 0, NULL },
};
#ifdef TCLFLSH
static const struct xlat tcflsh_options[] = {
{ TCIFLUSH, "TCIFLUSH" },
{ TCOFLUSH, "TCOFLUSH" },
{ TCIOFLUSH, "TCIOFLUSH" },
XLAT(TCIFLUSH),
XLAT(TCOFLUSH),
XLAT(TCIOFLUSH),
{ 0, NULL },
};
#endif
static const struct xlat baud_options[] = {
{ B0, "B0" },
{ B50, "B50" },
{ B75, "B75" },
{ B110, "B110" },
{ B134, "B134" },
{ B150, "B150" },
{ B200, "B200" },
{ B300, "B300" },
{ B600, "B600" },
{ B1200, "B1200" },
{ B1800, "B1800" },
{ B2400, "B2400" },
{ B4800, "B4800" },
{ B9600, "B9600" },
XLAT(B0),
XLAT(B50),
XLAT(B75),
XLAT(B110),
XLAT(B134),
XLAT(B150),
XLAT(B200),
XLAT(B300),
XLAT(B600),
XLAT(B1200),
XLAT(B1800),
XLAT(B2400),
XLAT(B4800),
XLAT(B9600),
#ifdef B19200
{ B19200, "B19200" },
XLAT(B19200),
#endif
#ifdef B38400
{ B38400, "B38400" },
XLAT(B38400),
#endif
#ifdef B57600
{ B57600, "B57600" },
XLAT(B57600),
#endif
#ifdef B115200
{ B115200, "B115200" },
XLAT(B115200),
#endif
#ifdef B230400
{ B230400, "B230400" },
XLAT(B230400),
#endif
#ifdef B460800
{ B460800, "B460800" },
XLAT(B460800),
#endif
#ifdef B500000
{ B500000, "B500000" },
XLAT(B500000),
#endif
#ifdef B576000
{ B576000, "B576000" },
XLAT(B576000),
#endif
#ifdef B921600
{ B921600, "B921600" },
XLAT(B921600),
#endif
#ifdef B1000000
{ B1000000, "B1000000" },
XLAT(B1000000),
#endif
#ifdef B1152000
{ B1152000, "B1152000" },
XLAT(B1152000),
#endif
#ifdef B1500000
{ B1500000, "B1500000" },
XLAT(B1500000),
#endif
#ifdef B2000000
{ B2000000, "B2000000" },
XLAT(B2000000),
#endif
#ifdef B2500000
{ B2500000, "B2500000" },
XLAT(B2500000),
#endif
#ifdef B3000000
{ B3000000, "B3000000" },
XLAT(B3000000),
#endif
#ifdef B3500000
{ B3500000, "B3500000" },
XLAT(B3500000),
#endif
#ifdef B4000000
{ B4000000, "B4000000" },
XLAT(B4000000),
#endif
#ifdef EXTA
{ EXTA, "EXTA" },
XLAT(EXTA),
#endif
#ifdef EXTB
{ EXTB, "EXTB" },
XLAT(EXTB),
#endif
{ 0, NULL },
};
static const struct xlat modem_flags[] = {
#ifdef TIOCM_LE
{ TIOCM_LE, "TIOCM_LE", },
XLAT(TIOCM_LE),
#endif
#ifdef TIOCM_DTR
{ TIOCM_DTR, "TIOCM_DTR", },
XLAT(TIOCM_DTR),
#endif
#ifdef TIOCM_RTS
{ TIOCM_RTS, "TIOCM_RTS", },
XLAT(TIOCM_RTS),
#endif
#ifdef TIOCM_ST
{ TIOCM_ST, "TIOCM_ST", },
XLAT(TIOCM_ST),
#endif
#ifdef TIOCM_SR
{ TIOCM_SR, "TIOCM_SR", },
XLAT(TIOCM_SR),
#endif
#ifdef TIOCM_CTS
{ TIOCM_CTS, "TIOCM_CTS", },
XLAT(TIOCM_CTS),
#endif
#ifdef TIOCM_CAR
{ TIOCM_CAR, "TIOCM_CAR", },
XLAT(TIOCM_CAR),
#endif
#ifdef TIOCM_CD
{ TIOCM_CD, "TIOCM_CD", },
XLAT(TIOCM_CD),
#endif
#ifdef TIOCM_RNG
{ TIOCM_RNG, "TIOCM_RNG", },
XLAT(TIOCM_RNG),
#endif
#ifdef TIOCM_RI
{ TIOCM_RI, "TIOCM_RI", },
XLAT(TIOCM_RI),
#endif
#ifdef TIOCM_DSR
{ TIOCM_DSR, "TIOCM_DSR", },
XLAT(TIOCM_DSR),
#endif
{ 0, NULL, },
};

102
time.c
View File

@ -280,9 +280,9 @@ sys_nanosleep(struct tcb *tcp)
}
static const struct xlat which[] = {
{ ITIMER_REAL, "ITIMER_REAL" },
{ ITIMER_VIRTUAL,"ITIMER_VIRTUAL"},
{ ITIMER_PROF, "ITIMER_PROF" },
XLAT(ITIMER_REAL),
XLAT(ITIMER_VIRTUAL),
XLAT(ITIMER_PROF),
{ 0, NULL },
};
@ -403,119 +403,119 @@ sys_osf_setitimer(struct tcb *tcp)
#endif
static const struct xlat adjtimex_modes[] = {
{ 0, "0" },
XLAT(0),
#ifdef ADJ_OFFSET
{ ADJ_OFFSET, "ADJ_OFFSET" },
XLAT(ADJ_OFFSET),
#endif
#ifdef ADJ_FREQUENCY
{ ADJ_FREQUENCY, "ADJ_FREQUENCY" },
XLAT(ADJ_FREQUENCY),
#endif
#ifdef ADJ_MAXERROR
{ ADJ_MAXERROR, "ADJ_MAXERROR" },
XLAT(ADJ_MAXERROR),
#endif
#ifdef ADJ_ESTERROR
{ ADJ_ESTERROR, "ADJ_ESTERROR" },
XLAT(ADJ_ESTERROR),
#endif
#ifdef ADJ_STATUS
{ ADJ_STATUS, "ADJ_STATUS" },
XLAT(ADJ_STATUS),
#endif
#ifdef ADJ_TIMECONST
{ ADJ_TIMECONST, "ADJ_TIMECONST" },
XLAT(ADJ_TIMECONST),
#endif
#ifdef ADJ_TAI
{ ADJ_TAI, "ADJ_TAI" },
XLAT(ADJ_TAI),
#endif
#ifdef ADJ_SETOFFSET
{ ADJ_SETOFFSET, "ADJ_SETOFFSET" },
XLAT(ADJ_SETOFFSET),
#endif
#ifdef ADJ_MICRO
{ ADJ_MICRO, "ADJ_MICRO" },
XLAT(ADJ_MICRO),
#endif
#ifdef ADJ_NANO
{ ADJ_NANO, "ADJ_NANO" },
XLAT(ADJ_NANO),
#endif
#ifdef ADJ_TICK
{ ADJ_TICK, "ADJ_TICK" },
XLAT(ADJ_TICK),
#endif
#ifdef ADJ_OFFSET_SINGLESHOT
{ ADJ_OFFSET_SINGLESHOT, "ADJ_OFFSET_SINGLESHOT" },
XLAT(ADJ_OFFSET_SINGLESHOT),
#endif
#ifdef ADJ_OFFSET_SS_READ
{ ADJ_OFFSET_SS_READ, "ADJ_OFFSET_SS_READ" },
XLAT(ADJ_OFFSET_SS_READ),
#endif
{ 0, NULL }
};
static const struct xlat adjtimex_status[] = {
#ifdef STA_PLL
{ STA_PLL, "STA_PLL" },
XLAT(STA_PLL),
#endif
#ifdef STA_PPSFREQ
{ STA_PPSFREQ, "STA_PPSFREQ" },
XLAT(STA_PPSFREQ),
#endif
#ifdef STA_PPSTIME
{ STA_PPSTIME, "STA_PPSTIME" },
XLAT(STA_PPSTIME),
#endif
#ifdef STA_FLL
{ STA_FLL, "STA_FLL" },
XLAT(STA_FLL),
#endif
#ifdef STA_INS
{ STA_INS, "STA_INS" },
XLAT(STA_INS),
#endif
#ifdef STA_DEL
{ STA_DEL, "STA_DEL" },
XLAT(STA_DEL),
#endif
#ifdef STA_UNSYNC
{ STA_UNSYNC, "STA_UNSYNC" },
XLAT(STA_UNSYNC),
#endif
#ifdef STA_FREQHOLD
{ STA_FREQHOLD, "STA_FREQHOLD" },
XLAT(STA_FREQHOLD),
#endif
#ifdef STA_PPSSIGNAL
{ STA_PPSSIGNAL, "STA_PPSSIGNAL" },
XLAT(STA_PPSSIGNAL),
#endif
#ifdef STA_PPSJITTER
{ STA_PPSJITTER, "STA_PPSJITTER" },
XLAT(STA_PPSJITTER),
#endif
#ifdef STA_PPSWANDER
{ STA_PPSWANDER, "STA_PPSWANDER" },
XLAT(STA_PPSWANDER),
#endif
#ifdef STA_PPSERROR
{ STA_PPSERROR, "STA_PPSERROR" },
XLAT(STA_PPSERROR),
#endif
#ifdef STA_CLOCKERR
{ STA_CLOCKERR, "STA_CLOCKERR" },
XLAT(STA_CLOCKERR),
#endif
#ifdef STA_NANO
{ STA_NANO, "STA_NANO" },
XLAT(STA_NANO),
#endif
#ifdef STA_MODE
{ STA_MODE, "STA_MODE" },
XLAT(STA_MODE),
#endif
#ifdef STA_CLK
{ STA_CLK, "STA_CLK" },
XLAT(STA_CLK),
#endif
{ 0, NULL }
};
static const struct xlat adjtimex_state[] = {
#ifdef TIME_OK
{ TIME_OK, "TIME_OK" },
XLAT(TIME_OK),
#endif
#ifdef TIME_INS
{ TIME_INS, "TIME_INS" },
XLAT(TIME_INS),
#endif
#ifdef TIME_DEL
{ TIME_DEL, "TIME_DEL" },
XLAT(TIME_DEL),
#endif
#ifdef TIME_OOP
{ TIME_OOP, "TIME_OOP" },
XLAT(TIME_OOP),
#endif
#ifdef TIME_WAIT
{ TIME_WAIT, "TIME_WAIT" },
XLAT(TIME_WAIT),
#endif
#ifdef TIME_ERROR
{ TIME_ERROR, "TIME_ERROR" },
XLAT(TIME_ERROR),
#endif
{ 0, NULL }
};
@ -639,40 +639,40 @@ sys_adjtimex(struct tcb *tcp)
}
static const struct xlat clockflags[] = {
{ TIMER_ABSTIME, "TIMER_ABSTIME" },
XLAT(TIMER_ABSTIME),
{ 0, NULL }
};
static const struct xlat clocknames[] = {
#ifdef CLOCK_REALTIME
{ CLOCK_REALTIME, "CLOCK_REALTIME" },
XLAT(CLOCK_REALTIME),
#endif
#ifdef CLOCK_MONOTONIC
{ CLOCK_MONOTONIC, "CLOCK_MONOTONIC" },
XLAT(CLOCK_MONOTONIC),
#endif
#ifdef CLOCK_PROCESS_CPUTIME_ID
{ CLOCK_PROCESS_CPUTIME_ID, "CLOCK_PROCESS_CPUTIME_ID" },
XLAT(CLOCK_PROCESS_CPUTIME_ID),
#endif
#ifdef CLOCK_THREAD_CPUTIME_ID
{ CLOCK_THREAD_CPUTIME_ID, "CLOCK_THREAD_CPUTIME_ID" },
XLAT(CLOCK_THREAD_CPUTIME_ID),
#endif
#ifdef CLOCK_MONOTONIC_RAW
{ CLOCK_MONOTONIC_RAW, "CLOCK_MONOTONIC_RAW" },
XLAT(CLOCK_MONOTONIC_RAW),
#endif
#ifdef CLOCK_REALTIME_COARSE
{ CLOCK_REALTIME_COARSE, "CLOCK_REALTIME_COARSE" },
XLAT(CLOCK_REALTIME_COARSE),
#endif
#ifdef CLOCK_MONOTONIC_COARSE
{ CLOCK_MONOTONIC_COARSE, "CLOCK_MONOTONIC_COARSE" },
XLAT(CLOCK_MONOTONIC_COARSE),
#endif
{ 0, NULL }
};
#ifdef CLOCKID_TO_FD
static const struct xlat cpuclocknames[] = {
{ CPUCLOCK_PROF, "CPUCLOCK_PROF" },
{ CPUCLOCK_VIRT, "CPUCLOCK_VIRT" },
{ CPUCLOCK_SCHED, "CPUCLOCK_SCHED" },
XLAT(CPUCLOCK_PROF),
XLAT(CPUCLOCK_VIRT),
XLAT(CPUCLOCK_SCHED),
{ 0, NULL }
};
#endif
@ -988,7 +988,7 @@ rtc_ioctl(struct tcb *tcp, long code, long arg)
#endif
static const struct xlat timerfdflags[] = {
{ TFD_TIMER_ABSTIME, "TFD_TIMER_ABSTIME" },
XLAT(TFD_TIMER_ABSTIME),
{ 0, NULL }
};