};
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 },
};
#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 },
};
#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 },
};
#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 },
};
#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 },
};
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 },
};
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 }
};
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 }
};
};
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 */
# 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 },
};
}
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 },
};
}
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 },
};
/* 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 },
};
#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 }
};
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 },
};
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 },
};
}
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 },
};
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 }
};
}
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 }
};
}
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 }
};
# 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 }
};
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 },
};
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 },
};
#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 },
};
}
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
* 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 },
};
}
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 }
};
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 },
};
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}
};
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 },
};
#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 },
};
#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 }
};
#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 },
};
}
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 },
};
static const struct xlat domains[] = {
#ifdef PF_UNSPEC
- { PF_UNSPEC, "PF_UNSPEC" },
+ XLAT(PF_UNSPEC),
#endif
#ifdef PF_LOCAL
- { PF_LOCAL, "PF_LOCAL" },
+ XLAT(PF_LOCAL),
#endif
#ifdef PF_UNIX
- { PF_UNIX, "PF_UNIX" },
+ XLAT(PF_UNIX),
#endif
#ifdef PF_INET
- { PF_INET, "PF_INET" },
+ XLAT(PF_INET),
#endif
#ifdef PF_AX25
- { PF_AX25, "PF_AX25" },
+ XLAT(PF_AX25),
#endif
#ifdef PF_IPX
- { PF_IPX, "PF_IPX" },
+ XLAT(PF_IPX),
#endif
#ifdef PF_APPLETALK
- { PF_APPLETALK, "PF_APPLETALK" },
+ XLAT(PF_APPLETALK),
#endif
#ifdef PF_NETROM
- { PF_NETROM, "PF_NETROM" },
+ XLAT(PF_NETROM),
#endif
#ifdef PF_BRIDGE
- { PF_BRIDGE, "PF_BRIDGE" },
+ XLAT(PF_BRIDGE),
#endif
#ifdef PF_ATMPVC
- { PF_ATMPVC, "PF_ATMPVC" },
+ XLAT(PF_ATMPVC),
#endif
#ifdef PF_X25
- { PF_X25, "PF_X25" },
+ XLAT(PF_X25),
#endif
#ifdef PF_INET6
- { PF_INET6, "PF_INET6" },
+ XLAT(PF_INET6),
#endif
#ifdef PF_ROSE
- { PF_ROSE, "PF_ROSE" },
+ XLAT(PF_ROSE),
#endif
#ifdef PF_DECnet
- { PF_DECnet, "PF_DECnet" },
+ XLAT(PF_DECnet),
#endif
#ifdef PF_NETBEUI
- { PF_NETBEUI, "PF_NETBEUI" },
+ XLAT(PF_NETBEUI),
#endif
#ifdef PF_SECURITY
- { PF_SECURITY, "PF_SECURITY" },
+ XLAT(PF_SECURITY),
#endif
#ifdef PF_KEY
- { PF_KEY, "PF_KEY" },
+ XLAT(PF_KEY),
#endif
#ifdef PF_NETLINK
- { PF_NETLINK, "PF_NETLINK" },
+ XLAT(PF_NETLINK),
#endif
#ifdef PF_ROUTE
- { PF_ROUTE, "PF_ROUTE" },
+ XLAT(PF_ROUTE),
#endif
#ifdef PF_PACKET
- { PF_PACKET, "PF_PACKET" },
+ XLAT(PF_PACKET),
#endif
#ifdef PF_ASH
- { PF_ASH, "PF_ASH" },
+ XLAT(PF_ASH),
#endif
#ifdef PF_ECONET
- { PF_ECONET, "PF_ECONET" },
+ XLAT(PF_ECONET),
#endif
#ifdef PF_ATMSVC
- { PF_ATMSVC, "PF_ATMSVC" },
+ XLAT(PF_ATMSVC),
#endif
#ifdef PF_RDS
- { PF_RDS, "PF_RDS" },
+ XLAT(PF_RDS),
#endif
#ifdef PF_SNA
- { PF_SNA, "PF_SNA" },
+ XLAT(PF_SNA),
#endif
#ifdef PF_IRDA
- { PF_IRDA, "PF_IRDA" },
+ XLAT(PF_IRDA),
#endif
#ifdef PF_PPPOX
- { PF_PPPOX, "PF_PPPOX" },
+ XLAT(PF_PPPOX),
#endif
#ifdef PF_WANPIPE
- { PF_WANPIPE, "PF_WANPIPE" },
+ XLAT(PF_WANPIPE),
#endif
#ifdef PF_LLC
- { PF_LLC, "PF_LLC" },
+ XLAT(PF_LLC),
#endif
#ifdef PF_CAN
- { PF_CAN, "PF_CAN" },
+ XLAT(PF_CAN),
#endif
#ifdef PF_TIPC
- { PF_TIPC, "PF_TIPC" },
+ XLAT(PF_TIPC),
#endif
#ifdef PF_BLUETOOTH
- { PF_BLUETOOTH, "PF_BLUETOOTH" },
+ XLAT(PF_BLUETOOTH),
#endif
#ifdef PF_IUCV
- { PF_IUCV, "PF_IUCV" },
+ XLAT(PF_IUCV),
#endif
#ifdef PF_RXRPC
- { PF_RXRPC, "PF_RXRPC" },
+ XLAT(PF_RXRPC),
#endif
#ifdef PF_ISDN
- { PF_ISDN, "PF_ISDN" },
+ XLAT(PF_ISDN),
#endif
#ifdef PF_PHONET
- { PF_PHONET, "PF_PHONET" },
+ XLAT(PF_PHONET),
#endif
#ifdef PF_IEEE802154
- { PF_IEEE802154,"PF_IEEE802154" },
+ XLAT(PF_IEEE802154),
#endif
#ifdef PF_CAIF
- { PF_CAIF, "PF_CAIF" },
+ XLAT(PF_CAIF),
#endif
#ifdef PF_ALG
- { PF_ALG, "PF_ALG" },
+ XLAT(PF_ALG),
#endif
#ifdef PF_NFC
- { PF_NFC, "PF_NFC" },
+ XLAT(PF_NFC),
#endif
#ifdef PF_VSOCK
- { PF_VSOCK, "PF_VSOCK" },
+ XLAT(PF_VSOCK),
#endif
{ 0, NULL },
};
const struct xlat addrfams[] = {
#ifdef AF_UNSPEC
- { AF_UNSPEC, "AF_UNSPEC" },
+ XLAT(AF_UNSPEC),
#endif
#ifdef AF_LOCAL
- { AF_LOCAL, "AF_LOCAL" },
+ XLAT(AF_LOCAL),
#endif
#ifdef AF_UNIX
- { AF_UNIX, "AF_UNIX" },
+ XLAT(AF_UNIX),
#endif
#ifdef AF_INET
- { AF_INET, "AF_INET" },
+ XLAT(AF_INET),
#endif
#ifdef AF_AX25
- { AF_AX25, "AF_AX25" },
+ XLAT(AF_AX25),
#endif
#ifdef AF_IPX
- { AF_IPX, "AF_IPX" },
+ XLAT(AF_IPX),
#endif
#ifdef AF_APPLETALK
- { AF_APPLETALK, "AF_APPLETALK" },
+ XLAT(AF_APPLETALK),
#endif
#ifdef AF_NETROM
- { AF_NETROM, "AF_NETROM" },
+ XLAT(AF_NETROM),
#endif
#ifdef AF_BRIDGE
- { AF_BRIDGE, "AF_BRIDGE" },
+ XLAT(AF_BRIDGE),
#endif
#ifdef AF_ATMPVC
- { AF_ATMPVC, "AF_ATMPVC" },
+ XLAT(AF_ATMPVC),
#endif
#ifdef AF_X25
- { AF_X25, "AF_X25" },
+ XLAT(AF_X25),
#endif
#ifdef AF_INET6
- { AF_INET6, "AF_INET6" },
+ XLAT(AF_INET6),
#endif
#ifdef AF_ROSE
- { AF_ROSE, "AF_ROSE" },
+ XLAT(AF_ROSE),
#endif
#ifdef AF_DECnet
- { AF_DECnet, "AF_DECnet" },
+ XLAT(AF_DECnet),
#endif
#ifdef AF_NETBEUI
- { AF_NETBEUI, "AF_NETBEUI" },
+ XLAT(AF_NETBEUI),
#endif
#ifdef AF_SECURITY
- { AF_SECURITY, "AF_SECURITY" },
+ XLAT(AF_SECURITY),
#endif
#ifdef AF_KEY
- { AF_KEY, "AF_KEY" },
+ XLAT(AF_KEY),
#endif
#ifdef AF_NETLINK
- { AF_NETLINK, "AF_NETLINK" },
+ XLAT(AF_NETLINK),
#endif
#ifdef AF_ROUTE
- { AF_ROUTE, "AF_ROUTE" },
+ XLAT(AF_ROUTE),
#endif
#ifdef AF_PACKET
- { AF_PACKET, "AF_PACKET" },
+ XLAT(AF_PACKET),
#endif
#ifdef AF_ASH
- { AF_ASH, "AF_ASH" },
+ XLAT(AF_ASH),
#endif
#ifdef AF_ECONET
- { AF_ECONET, "AF_ECONET" },
+ XLAT(AF_ECONET),
#endif
#ifdef AF_ATMSVC
- { AF_ATMSVC, "AF_ATMSVC" },
+ XLAT(AF_ATMSVC),
#endif
#ifdef AF_RDS
- { AF_RDS, "AF_RDS" },
+ XLAT(AF_RDS),
#endif
#ifdef AF_SNA
- { AF_SNA, "AF_SNA" },
+ XLAT(AF_SNA),
#endif
#ifdef AF_IRDA
- { AF_IRDA, "AF_IRDA" },
+ XLAT(AF_IRDA),
#endif
#ifdef AF_PPPOX
- { AF_PPPOX, "AF_PPPOX" },
+ XLAT(AF_PPPOX),
#endif
#ifdef AF_WANPIPE
- { AF_WANPIPE, "AF_WANPIPE" },
+ XLAT(AF_WANPIPE),
#endif
#ifdef AF_LLC
- { AF_LLC, "AF_LLC" },
+ XLAT(AF_LLC),
#endif
#ifdef AF_CAN
- { AF_CAN, "AF_CAN" },
+ XLAT(AF_CAN),
#endif
#ifdef AF_TIPC
- { AF_TIPC, "AF_TIPC" },
+ XLAT(AF_TIPC),
#endif
#ifdef AF_BLUETOOTH
- { AF_BLUETOOTH, "AF_BLUETOOTH" },
+ XLAT(AF_BLUETOOTH),
#endif
#ifdef AF_IUCV
- { AF_IUCV, "AF_IUCV" },
+ XLAT(AF_IUCV),
#endif
#ifdef AF_RXRPC
- { AF_RXRPC, "AF_RXRPC" },
+ XLAT(AF_RXRPC),
#endif
#ifdef AF_ISDN
- { AF_ISDN, "AF_ISDN" },
+ XLAT(AF_ISDN),
#endif
#ifdef AF_PHONET
- { AF_PHONET, "AF_PHONET" },
+ XLAT(AF_PHONET),
#endif
#ifdef AF_IEEE802154
- { AF_IEEE802154,"AF_IEEE802154" },
+ XLAT(AF_IEEE802154),
#endif
#ifdef AF_CAIF
- { AF_CAIF, "AF_CAIF" },
+ XLAT(AF_CAIF),
#endif
#ifdef AF_ALG
- { AF_ALG, "AF_ALG" },
+ XLAT(AF_ALG),
#endif
#ifdef AF_NFC
- { AF_NFC, "AF_NFC" },
+ XLAT(AF_NFC),
#endif
#ifdef AF_VSOCK
- { AF_VSOCK, "AF_VSOCK" },
+ XLAT(AF_VSOCK),
#endif
{ 0, NULL },
};
static const struct xlat socktypes[] = {
- { SOCK_STREAM, "SOCK_STREAM" },
- { SOCK_DGRAM, "SOCK_DGRAM" },
+ XLAT(SOCK_STREAM),
+ XLAT(SOCK_DGRAM),
#ifdef SOCK_RAW
- { SOCK_RAW, "SOCK_RAW" },
+ XLAT(SOCK_RAW),
#endif
#ifdef SOCK_RDM
- { SOCK_RDM, "SOCK_RDM" },
+ XLAT(SOCK_RDM),
#endif
#ifdef SOCK_SEQPACKET
- { SOCK_SEQPACKET,"SOCK_SEQPACKET"},
+ XLAT(SOCK_SEQPACKET),
#endif
#ifdef SOCK_DCCP
- { SOCK_DCCP, "SOCK_DCCP" },
+ XLAT(SOCK_DCCP),
#endif
#ifdef SOCK_PACKET
- { SOCK_PACKET, "SOCK_PACKET" },
+ XLAT(SOCK_PACKET),
#endif
{ 0, NULL },
};
static const struct xlat sock_type_flags[] = {
#ifdef SOCK_CLOEXEC
- { SOCK_CLOEXEC, "SOCK_CLOEXEC" },
+ XLAT(SOCK_CLOEXEC),
#endif
#ifdef SOCK_NONBLOCK
- { SOCK_NONBLOCK,"SOCK_NONBLOCK" },
+ XLAT(SOCK_NONBLOCK),
#endif
{ 0, NULL },
};
#endif
static const struct xlat socketlayers[] = {
#if defined(SOL_IP)
- { SOL_IP, "SOL_IP" },
+ XLAT(SOL_IP),
#endif
#if defined(SOL_ICMP)
- { SOL_ICMP, "SOL_ICMP" },
+ XLAT(SOL_ICMP),
#endif
#if defined(SOL_TCP)
- { SOL_TCP, "SOL_TCP" },
+ XLAT(SOL_TCP),
#endif
#if defined(SOL_UDP)
- { SOL_UDP, "SOL_UDP" },
+ XLAT(SOL_UDP),
#endif
#if defined(SOL_IPV6)
- { SOL_IPV6, "SOL_IPV6" },
+ XLAT(SOL_IPV6),
#endif
#if defined(SOL_ICMPV6)
- { SOL_ICMPV6, "SOL_ICMPV6" },
+ XLAT(SOL_ICMPV6),
#endif
#if defined(SOL_SCTP)
- { SOL_SCTP, "SOL_SCTP" },
+ XLAT(SOL_SCTP),
#endif
#if defined(SOL_UDPLITE)
- { SOL_UDPLITE, "SOL_UDPLITE" },
+ XLAT(SOL_UDPLITE),
#endif
#if defined(SOL_RAW)
- { SOL_RAW, "SOL_RAW" },
+ XLAT(SOL_RAW),
#endif
#if defined(SOL_IPX)
- { SOL_IPX, "SOL_IPX" },
+ XLAT(SOL_IPX),
#endif
#if defined(SOL_AX25)
- { SOL_AX25, "SOL_AX25" },
+ XLAT(SOL_AX25),
#endif
#if defined(SOL_ATALK)
- { SOL_ATALK, "SOL_ATALK" },
+ XLAT(SOL_ATALK),
#endif
#if defined(SOL_NETROM)
- { SOL_NETROM, "SOL_NETROM" },
+ XLAT(SOL_NETROM),
#endif
#if defined(SOL_ROSE)
- { SOL_ROSE, "SOL_ROSE" },
+ XLAT(SOL_ROSE),
#endif
#if defined(SOL_DECNET)
- { SOL_DECNET, "SOL_DECNET" },
+ XLAT(SOL_DECNET),
#endif
#if defined(SOL_X25)
- { SOL_X25, "SOL_X25" },
+ XLAT(SOL_X25),
#endif
#if defined(SOL_PACKET)
- { SOL_PACKET, "SOL_PACKET" },
+ XLAT(SOL_PACKET),
#endif
#if defined(SOL_ATM)
- { SOL_ATM, "SOL_ATM" },
+ XLAT(SOL_ATM),
#endif
#if defined(SOL_AAL)
- { SOL_AAL, "SOL_AAL" },
+ XLAT(SOL_AAL),
#endif
#if defined(SOL_IRDA)
- { SOL_IRDA, "SOL_IRDA" },
+ XLAT(SOL_IRDA),
#endif
#if defined(SOL_NETBEUI)
- { SOL_NETBEUI, "SOL_NETBEUI" },
+ XLAT(SOL_NETBEUI),
#endif
#if defined(SOL_LLC)
- { SOL_LLC, "SOL_LLC" },
+ XLAT(SOL_LLC),
#endif
#if defined(SOL_DCCP)
- { SOL_DCCP, "SOL_DCCP" },
+ XLAT(SOL_DCCP),
#endif
#if defined(SOL_NETLINK)
- { SOL_NETLINK, "SOL_NETLINK" },
+ XLAT(SOL_NETLINK),
#endif
#if defined(SOL_TIPC)
- { SOL_TIPC, "SOL_TIPC" },
+ XLAT(SOL_TIPC),
#endif
#if defined(SOL_RXRPC)
- { SOL_RXRPC, "SOL_RXRPC" },
+ XLAT(SOL_RXRPC),
#endif
#if defined(SOL_PPPOL2TP)
- { SOL_PPPOL2TP, "SOL_PPPOL2TP" },
+ XLAT(SOL_PPPOL2TP),
#endif
#if defined(SOL_BLUETOOTH)
- { SOL_BLUETOOTH,"SOL_BLUETOOTH" },
+ XLAT(SOL_BLUETOOTH),
#endif
#if defined(SOL_PNPIPE)
- { SOL_PNPIPE, "SOL_PNPIPE" },
+ XLAT(SOL_PNPIPE),
#endif
#if defined(SOL_RDS)
- { SOL_RDS, "SOL_RDS" },
+ XLAT(SOL_RDS),
#endif
#if defined(SOL_IUVC)
- { SOL_IUCV, "SOL_IUCV" },
+ XLAT(SOL_IUCV),
#endif
#if defined(SOL_CAIF)
- { SOL_CAIF, "SOL_CAIF" },
+ XLAT(SOL_CAIF),
#endif
- { SOL_SOCKET, "SOL_SOCKET" }, /* Never used! */
+ XLAT(SOL_SOCKET), /* Never used! */
/* The SOL_* array should remain not NULL-terminated. */
};
/*** WARNING: DANGER WILL ROBINSON: NOTE "socketlayers" array above
falls into "protocols" array below!!!! This is intended!!! ***/
static const struct xlat protocols[] = {
- { IPPROTO_IP, "IPPROTO_IP" },
- { IPPROTO_ICMP, "IPPROTO_ICMP" },
- { IPPROTO_TCP, "IPPROTO_TCP" },
- { IPPROTO_UDP, "IPPROTO_UDP" },
+ XLAT(IPPROTO_IP),
+ XLAT(IPPROTO_ICMP),
+ XLAT(IPPROTO_TCP),
+ XLAT(IPPROTO_UDP),
#ifdef IPPROTO_IGMP
- { IPPROTO_IGMP, "IPPROTO_IGMP" },
+ XLAT(IPPROTO_IGMP),
#endif
#ifdef IPPROTO_GGP
- { IPPROTO_GGP, "IPPROTO_GGP" },
+ XLAT(IPPROTO_GGP),
#endif
#ifdef IPPROTO_IPIP
- { IPPROTO_IPIP, "IPPROTO_IPIP" },
+ XLAT(IPPROTO_IPIP),
#endif
#ifdef IPPROTO_EGP
- { IPPROTO_EGP, "IPPROTO_EGP" },
+ XLAT(IPPROTO_EGP),
#endif
#ifdef IPPROTO_PUP
- { IPPROTO_PUP, "IPPROTO_PUP" },
+ XLAT(IPPROTO_PUP),
#endif
#ifdef IPPROTO_IDP
- { IPPROTO_IDP, "IPPROTO_IDP" },
+ XLAT(IPPROTO_IDP),
#endif
#ifdef IPPROTO_TP
- { IPPROTO_TP, "IPPROTO_TP" },
+ XLAT(IPPROTO_TP),
#endif
#ifdef IPPROTO_DCCP
- { IPPROTO_DCCP, "IPPROTO_DCCP" },
+ XLAT(IPPROTO_DCCP),
#endif
#ifdef IPPROTO_IPV6
- { IPPROTO_IPV6, "IPPROTO_IPV6" },
+ XLAT(IPPROTO_IPV6),
#endif
#ifdef IPPROTO_ROUTING
- { IPPROTO_ROUTING, "IPPROTO_ROUTING" },
+ XLAT(IPPROTO_ROUTING),
#endif
#ifdef IPPROTO_FRAGMENT
- { IPPROTO_FRAGMENT, "IPPROTO_FRAGMENT" },
+ XLAT(IPPROTO_FRAGMENT),
#endif
#ifdef IPPROTO_RSVP
- { IPPROTO_RSVP, "IPPROTO_RSVP" },
+ XLAT(IPPROTO_RSVP),
#endif
#ifdef IPPROTO_GRE
- { IPPROTO_GRE, "IPPROTO_GRE" },
+ XLAT(IPPROTO_GRE),
#endif
#ifdef IPPROTO_ESP
- { IPPROTO_ESP, "IPPROTO_ESP" },
+ XLAT(IPPROTO_ESP),
#endif
#ifdef IPPROTO_AH
- { IPPROTO_AH, "IPPROTO_AH" },
+ XLAT(IPPROTO_AH),
#endif
#ifdef IPPROTO_ICMPV6
- { IPPROTO_ICMPV6, "IPPROTO_ICMPV6" },
+ XLAT(IPPROTO_ICMPV6),
#endif
#ifdef IPPROTO_NONE
- { IPPROTO_NONE, "IPPROTO_NONE" },
+ XLAT(IPPROTO_NONE),
#endif
#ifdef IPPROTO_DSTOPTS
- { IPPROTO_DSTOPTS, "IPPROTO_DSTOPTS" },
+ XLAT(IPPROTO_DSTOPTS),
#endif
#ifdef IPPROTO_HELLO
- { IPPROTO_HELLO, "IPPROTO_HELLO" },
+ XLAT(IPPROTO_HELLO),
#endif
#ifdef IPPROTO_ND
- { IPPROTO_ND, "IPPROTO_ND" },
+ XLAT(IPPROTO_ND),
#endif
#ifdef IPPROTO_MTP
- { IPPROTO_MTP, "IPPROTO_MTP" },
+ XLAT(IPPROTO_MTP),
#endif
#ifdef IPPROTO_ENCAP
- { IPPROTO_ENCAP, "IPPROTO_ENCAP" },
+ XLAT(IPPROTO_ENCAP),
#endif
#ifdef IPPROTO_PIM
- { IPPROTO_PIM, "IPPROTO_PIM" },
+ XLAT(IPPROTO_PIM),
#endif
#ifdef IPPROTO_COMP
- { IPPROTO_COMP, "IPPROTO_COMP" },
+ XLAT(IPPROTO_COMP),
#endif
#ifdef IPPROTO_SCTP
- { IPPROTO_SCTP, "IPPROTO_SCTP" },
+ XLAT(IPPROTO_SCTP),
#endif
#ifdef IPPROTO_UDPLITE
- { IPPROTO_UDPLITE, "IPPROTO_UDPLITE" },
+ XLAT(IPPROTO_UDPLITE),
#endif
#ifdef IPPROTO_RAW
- { IPPROTO_RAW, "IPPROTO_RAW" },
+ XLAT(IPPROTO_RAW),
#endif
#ifdef IPPROTO_MAX
- { IPPROTO_MAX, "IPPROTO_MAX" },
+ XLAT(IPPROTO_MAX),
#endif
{ 0, NULL },
};
static const struct xlat msg_flags[] = {
- { MSG_OOB, "MSG_OOB" },
+ XLAT(MSG_OOB),
#ifdef MSG_PEEK
- { MSG_PEEK, "MSG_PEEK" },
+ XLAT(MSG_PEEK),
#endif
#ifdef MSG_DONTROUTE
- { MSG_DONTROUTE, "MSG_DONTROUTE" },
+ XLAT(MSG_DONTROUTE),
#endif
#ifdef MSG_CTRUNC
- { MSG_CTRUNC, "MSG_CTRUNC" },
+ XLAT(MSG_CTRUNC),
#endif
#ifdef MSG_PROBE
- { MSG_PROBE, "MSG_PROBE" },
+ XLAT(MSG_PROBE),
#endif
#ifdef MSG_TRUNC
- { MSG_TRUNC, "MSG_TRUNC" },
+ XLAT(MSG_TRUNC),
#endif
#ifdef MSG_DONTWAIT
- { MSG_DONTWAIT, "MSG_DONTWAIT" },
+ XLAT(MSG_DONTWAIT),
#endif
#ifdef MSG_EOR
- { MSG_EOR, "MSG_EOR" },
+ XLAT(MSG_EOR),
#endif
#ifdef MSG_WAITALL
- { MSG_WAITALL, "MSG_WAITALL" },
+ XLAT(MSG_WAITALL),
#endif
#ifdef MSG_FIN
- { MSG_FIN, "MSG_FIN" },
+ XLAT(MSG_FIN),
#endif
#ifdef MSG_SYN
- { MSG_SYN, "MSG_SYN" },
+ XLAT(MSG_SYN),
#endif
#ifdef MSG_CONFIRM
- { MSG_CONFIRM, "MSG_CONFIRM" },
+ XLAT(MSG_CONFIRM),
#endif
#ifdef MSG_RST
- { MSG_RST, "MSG_RST" },
+ XLAT(MSG_RST),
#endif
#ifdef MSG_ERRQUEUE
- { MSG_ERRQUEUE, "MSG_ERRQUEUE" },
+ XLAT(MSG_ERRQUEUE),
#endif
#ifdef MSG_NOSIGNAL
- { MSG_NOSIGNAL, "MSG_NOSIGNAL" },
+ XLAT(MSG_NOSIGNAL),
#endif
#ifdef MSG_MORE
- { MSG_MORE, "MSG_MORE" },
+ XLAT(MSG_MORE),
#endif
#ifdef MSG_WAITFORONE
- { MSG_WAITFORONE, "MSG_WAITFORONE" },
+ XLAT(MSG_WAITFORONE),
#endif
#ifdef MSG_EOF
- { MSG_EOF, "MSG_EOF" },
+ XLAT(MSG_EOF),
#endif
#ifdef MSG_FASTOPEN
- { MSG_FASTOPEN, "MSG_FASTOPEN" },
+ XLAT(MSG_FASTOPEN),
#endif
#ifdef MSG_CMSG_CLOEXEC
- { MSG_CMSG_CLOEXEC, "MSG_CMSG_CLOEXEC" },
+ XLAT(MSG_CMSG_CLOEXEC),
#endif
{ 0, NULL },
};
static const struct xlat sockoptions[] = {
#ifdef SO_ACCEPTCONN
- { SO_ACCEPTCONN, "SO_ACCEPTCONN" },
+ XLAT(SO_ACCEPTCONN),
#endif
#ifdef SO_ALLRAW
- { SO_ALLRAW, "SO_ALLRAW" },
+ XLAT(SO_ALLRAW),
#endif
#ifdef SO_ATTACH_FILTER
- { SO_ATTACH_FILTER, "SO_ATTACH_FILTER" },
+ XLAT(SO_ATTACH_FILTER),
#endif
#ifdef SO_BINDTODEVICE
- { SO_BINDTODEVICE, "SO_BINDTODEVICE" },
+ XLAT(SO_BINDTODEVICE),
#endif
#ifdef SO_BROADCAST
- { SO_BROADCAST, "SO_BROADCAST" },
+ XLAT(SO_BROADCAST),
#endif
#ifdef SO_BSDCOMPAT
- { SO_BSDCOMPAT, "SO_BSDCOMPAT" },
+ XLAT(SO_BSDCOMPAT),
#endif
#ifdef SO_DEBUG
- { SO_DEBUG, "SO_DEBUG" },
+ XLAT(SO_DEBUG),
#endif
#ifdef SO_DETACH_FILTER
- { SO_DETACH_FILTER, "SO_DETACH_FILTER" },
+ XLAT(SO_DETACH_FILTER),
#endif
#ifdef SO_DONTROUTE
- { SO_DONTROUTE, "SO_DONTROUTE" },
+ XLAT(SO_DONTROUTE),
#endif
#ifdef SO_ERROR
- { SO_ERROR, "SO_ERROR" },
+ XLAT(SO_ERROR),
#endif
#ifdef SO_ICS
- { SO_ICS, "SO_ICS" },
+ XLAT(SO_ICS),
#endif
#ifdef SO_IMASOCKET
- { SO_IMASOCKET, "SO_IMASOCKET" },
+ XLAT(SO_IMASOCKET),
#endif
#ifdef SO_KEEPALIVE
- { SO_KEEPALIVE, "SO_KEEPALIVE" },
+ XLAT(SO_KEEPALIVE),
#endif
#ifdef SO_LINGER
- { SO_LINGER, "SO_LINGER" },
+ XLAT(SO_LINGER),
#endif
#ifdef SO_LISTENING
- { SO_LISTENING, "SO_LISTENING" },
+ XLAT(SO_LISTENING),
#endif
#ifdef SO_MGMT
- { SO_MGMT, "SO_MGMT" },
+ XLAT(SO_MGMT),
#endif
#ifdef SO_NO_CHECK
- { SO_NO_CHECK, "SO_NO_CHECK" },
+ XLAT(SO_NO_CHECK),
#endif
#ifdef SO_OOBINLINE
- { SO_OOBINLINE, "SO_OOBINLINE" },
+ XLAT(SO_OOBINLINE),
#endif
#ifdef SO_ORDREL
- { SO_ORDREL, "SO_ORDREL" },
+ XLAT(SO_ORDREL),
#endif
#ifdef SO_PARALLELSVR
- { SO_PARALLELSVR, "SO_PARALLELSVR" },
+ XLAT(SO_PARALLELSVR),
#endif
#ifdef SO_PASSCRED
- { SO_PASSCRED, "SO_PASSCRED" },
+ XLAT(SO_PASSCRED),
#endif
#ifdef SO_PEERCRED
- { SO_PEERCRED, "SO_PEERCRED" },
+ XLAT(SO_PEERCRED),
#endif
#ifdef SO_PEERNAME
- { SO_PEERNAME, "SO_PEERNAME" },
+ XLAT(SO_PEERNAME),
#endif
#ifdef SO_PEERSEC
- { SO_PEERSEC, "SO_PEERSEC" },
+ XLAT(SO_PEERSEC),
#endif
#ifdef SO_PRIORITY
- { SO_PRIORITY, "SO_PRIORITY" },
+ XLAT(SO_PRIORITY),
#endif
#ifdef SO_PROTOTYPE
- { SO_PROTOTYPE, "SO_PROTOTYPE" },
+ XLAT(SO_PROTOTYPE),
#endif
#ifdef SO_RCVBUF
- { SO_RCVBUF, "SO_RCVBUF" },
+ XLAT(SO_RCVBUF),
#endif
#ifdef SO_RCVLOWAT
- { SO_RCVLOWAT, "SO_RCVLOWAT" },
+ XLAT(SO_RCVLOWAT),
#endif
#ifdef SO_RCVTIMEO
- { SO_RCVTIMEO, "SO_RCVTIMEO" },
+ XLAT(SO_RCVTIMEO),
#endif
#ifdef SO_RDWR
- { SO_RDWR, "SO_RDWR" },
+ XLAT(SO_RDWR),
#endif
#ifdef SO_REUSEADDR
- { SO_REUSEADDR, "SO_REUSEADDR" },
+ XLAT(SO_REUSEADDR),
#endif
#ifdef SO_REUSEPORT
- { SO_REUSEPORT, "SO_REUSEPORT" },
+ XLAT(SO_REUSEPORT),
#endif
#ifdef SO_SECURITY_AUTHENTICATION
- { SO_SECURITY_AUTHENTICATION,"SO_SECURITY_AUTHENTICATION"},
+ XLAT(SO_SECURITY_AUTHENTICATION),
#endif
#ifdef SO_SECURITY_ENCRYPTION_NETWORK
- { SO_SECURITY_ENCRYPTION_NETWORK,"SO_SECURITY_ENCRYPTION_NETWORK"},
+ XLAT(SO_SECURITY_ENCRYPTION_NETWORK),
#endif
#ifdef SO_SECURITY_ENCRYPTION_TRANSPORT
- { SO_SECURITY_ENCRYPTION_TRANSPORT,"SO_SECURITY_ENCRYPTION_TRANSPORT"},
+ XLAT(SO_SECURITY_ENCRYPTION_TRANSPORT),
#endif
#ifdef SO_SEMA
- { SO_SEMA, "SO_SEMA" },
+ XLAT(SO_SEMA),
#endif
#ifdef SO_SNDBUF
- { SO_SNDBUF, "SO_SNDBUF" },
+ XLAT(SO_SNDBUF),
#endif
#ifdef SO_SNDLOWAT
- { SO_SNDLOWAT, "SO_SNDLOWAT" },
+ XLAT(SO_SNDLOWAT),
#endif
#ifdef SO_SNDTIMEO
- { SO_SNDTIMEO, "SO_SNDTIMEO" },
+ XLAT(SO_SNDTIMEO),
#endif
#ifdef SO_TIMESTAMP
- { SO_TIMESTAMP, "SO_TIMESTAMP" },
+ XLAT(SO_TIMESTAMP),
#endif
#ifdef SO_TYPE
- { SO_TYPE, "SO_TYPE" },
+ XLAT(SO_TYPE),
#endif
#ifdef SO_USELOOPBACK
- { SO_USELOOPBACK, "SO_USELOOPBACK" },
+ XLAT(SO_USELOOPBACK),
#endif
{ 0, NULL },
};
#ifdef SOL_IP
static const struct xlat sockipoptions[] = {
#ifdef IP_TOS
- { IP_TOS, "IP_TOS" },
+ XLAT(IP_TOS),
#endif
#ifdef IP_TTL
- { IP_TTL, "IP_TTL" },
+ XLAT(IP_TTL),
#endif
#ifdef IP_HDRINCL
- { IP_HDRINCL, "IP_HDRINCL" },
+ XLAT(IP_HDRINCL),
#endif
#ifdef IP_OPTIONS
- { IP_OPTIONS, "IP_OPTIONS" },
+ XLAT(IP_OPTIONS),
#endif
#ifdef IP_ROUTER_ALERT
- { IP_ROUTER_ALERT, "IP_ROUTER_ALERT" },
+ XLAT(IP_ROUTER_ALERT),
#endif
#ifdef IP_RECVOPTIONS
- { IP_RECVOPTIONS, "IP_RECVOPTIONS" },
+ XLAT(IP_RECVOPTIONS),
#endif
#ifdef IP_RECVOPTS
- { IP_RECVOPTS, "IP_RECVOPTS" },
+ XLAT(IP_RECVOPTS),
#endif
#ifdef IP_RECVRETOPTS
- { IP_RECVRETOPTS, "IP_RECVRETOPTS" },
+ XLAT(IP_RECVRETOPTS),
#endif
#ifdef IP_RECVDSTADDR
- { IP_RECVDSTADDR, "IP_RECVDSTADDR" },
+ XLAT(IP_RECVDSTADDR),
#endif
#ifdef IP_RETOPTS
- { IP_RETOPTS, "IP_RETOPTS" },
+ XLAT(IP_RETOPTS),
#endif
#ifdef IP_PKTINFO
- { IP_PKTINFO, "IP_PKTINFO" },
+ XLAT(IP_PKTINFO),
#endif
#ifdef IP_PKTOPTIONS
- { IP_PKTOPTIONS, "IP_PKTOPTIONS" },
+ XLAT(IP_PKTOPTIONS),
#endif
#ifdef IP_MTU_DISCOVER
- { IP_MTU_DISCOVER, "IP_MTU_DISCOVER" },
+ XLAT(IP_MTU_DISCOVER),
#endif
#ifdef IP_RECVERR
- { IP_RECVERR, "IP_RECVERR" },
+ XLAT(IP_RECVERR),
#endif
#ifdef IP_RECVTTL
- { IP_RECVTTL, "IP_RECVTTL" },
+ XLAT(IP_RECVTTL),
#endif
#ifdef IP_RECVTOS
- { IP_RECVTOS, "IP_RECVTOS" },
+ XLAT(IP_RECVTOS),
#endif
#ifdef IP_MTU
- { IP_MTU, "IP_MTU" },
+ XLAT(IP_MTU),
#endif
#ifdef IP_MULTICAST_IF
- { IP_MULTICAST_IF, "IP_MULTICAST_IF" },
+ XLAT(IP_MULTICAST_IF),
#endif
#ifdef IP_MULTICAST_TTL
- { IP_MULTICAST_TTL, "IP_MULTICAST_TTL" },
+ XLAT(IP_MULTICAST_TTL),
#endif
#ifdef IP_MULTICAST_LOOP
- { IP_MULTICAST_LOOP, "IP_MULTICAST_LOOP" },
+ XLAT(IP_MULTICAST_LOOP),
#endif
#ifdef IP_ADD_MEMBERSHIP
- { IP_ADD_MEMBERSHIP, "IP_ADD_MEMBERSHIP" },
+ XLAT(IP_ADD_MEMBERSHIP),
#endif
#ifdef IP_DROP_MEMBERSHIP
- { IP_DROP_MEMBERSHIP, "IP_DROP_MEMBERSHIP" },
+ XLAT(IP_DROP_MEMBERSHIP),
#endif
#ifdef IP_BROADCAST_IF
- { IP_BROADCAST_IF, "IP_BROADCAST_IF" },
+ XLAT(IP_BROADCAST_IF),
#endif
#ifdef IP_RECVIFINDEX
- { IP_RECVIFINDEX, "IP_RECVIFINDEX" },
+ XLAT(IP_RECVIFINDEX),
#endif
#ifdef IP_MSFILTER
- { IP_MSFILTER, "IP_MSFILTER" },
+ XLAT(IP_MSFILTER),
#endif
#ifdef MCAST_MSFILTER
- { MCAST_MSFILTER, "MCAST_MSFILTER" },
+ XLAT(MCAST_MSFILTER),
#endif
#ifdef IP_FREEBIND
- { IP_FREEBIND, "IP_FREEBIND" },
+ XLAT(IP_FREEBIND),
#endif
#ifdef IP_IPSEC_POLICY
- { IP_IPSEC_POLICY, "IP_IPSEC_POLICY" },
+ XLAT(IP_IPSEC_POLICY),
#endif
#ifdef IP_XFRM_POLICY
- { IP_XFRM_POLICY, "IP_XFRM_POLICY" },
+ XLAT(IP_XFRM_POLICY),
#endif
#ifdef IP_PASSSEC
- { IP_PASSSEC, "IP_PASSSEC" },
+ XLAT(IP_PASSSEC),
#endif
#ifdef IP_TRANSPARENT
- { IP_TRANSPARENT, "IP_TRANSPARENT" },
+ XLAT(IP_TRANSPARENT),
#endif
#ifdef IP_ORIGDSTADDR
- { IP_ORIGDSTADDR, "IP_ORIGDSTADDR" },
+ XLAT(IP_ORIGDSTADDR),
#endif
#ifdef IP_RECVORIGDSTADDR
- { IP_RECVORIGDSTADDR, "IP_RECVORIGDSTADDR" },
+ XLAT(IP_RECVORIGDSTADDR),
#endif
#ifdef IP_MINTTL
- { IP_MINTTL, "IP_MINTTL" },
+ XLAT(IP_MINTTL),
#endif
#ifdef IP_NODEFRAG
- { IP_NODEFRAG, "IP_NODEFRAG" },
+ XLAT(IP_NODEFRAG),
#endif
#ifdef IP_UNBLOCK_SOURCE
- { IP_UNBLOCK_SOURCE, "IP_UNBLOCK_SOURCE" },
+ XLAT(IP_UNBLOCK_SOURCE),
#endif
#ifdef IP_BLOCK_SOURCE
- { IP_BLOCK_SOURCE, "IP_BLOCK_SOURCE" },
+ XLAT(IP_BLOCK_SOURCE),
#endif
#ifdef IP_ADD_SOURCE_MEMBERSHIP
- { IP_ADD_SOURCE_MEMBERSHIP, "IP_ADD_SOURCE_MEMBERSHIP" },
+ XLAT(IP_ADD_SOURCE_MEMBERSHIP),
#endif
#ifdef IP_DROP_SOURCE_MEMBERSHIP
- { IP_DROP_SOURCE_MEMBERSHIP, "IP_DROP_SOURCE_MEMBERSHIP" },
+ XLAT(IP_DROP_SOURCE_MEMBERSHIP),
#endif
#ifdef MCAST_JOIN_GROUP
- { MCAST_JOIN_GROUP, "MCAST_JOIN_GROUP" },
+ XLAT(MCAST_JOIN_GROUP),
#endif
#ifdef MCAST_BLOCK_SOURCE
- { MCAST_BLOCK_SOURCE, "MCAST_BLOCK_SOURCE" },
+ XLAT(MCAST_BLOCK_SOURCE),
#endif
#ifdef MCAST_UNBLOCK_SOURCE
- { MCAST_UNBLOCK_SOURCE, "MCAST_UNBLOCK_SOURCE" },
+ XLAT(MCAST_UNBLOCK_SOURCE),
#endif
#ifdef MCAST_LEAVE_GROUP
- { MCAST_LEAVE_GROUP, "MCAST_LEAVE_GROUP" },
+ XLAT(MCAST_LEAVE_GROUP),
#endif
#ifdef MCAST_JOIN_SOURCE_GROUP
- { MCAST_JOIN_SOURCE_GROUP, "MCAST_JOIN_SOURCE_GROUP" },
+ XLAT(MCAST_JOIN_SOURCE_GROUP),
#endif
#ifdef MCAST_LEAVE_SOURCE_GROUP
- { MCAST_LEAVE_SOURCE_GROUP, "MCAST_LEAVE_SOURCE_GROUP" },
+ XLAT(MCAST_LEAVE_SOURCE_GROUP),
#endif
#ifdef IP_MULTICAST_ALL
- { IP_MULTICAST_ALL, "IP_MULTICAST_ALL" },
+ XLAT(IP_MULTICAST_ALL),
#endif
#ifdef IP_UNICAST_IF
- { IP_UNICAST_IF, "IP_UNICAST_IF" },
+ XLAT(IP_UNICAST_IF),
#endif
{ 0, NULL },
};
#ifdef SOL_IPV6
static const struct xlat sockipv6options[] = {
#ifdef IPV6_ADDRFORM
- { IPV6_ADDRFORM, "IPV6_ADDRFORM" },
+ XLAT(IPV6_ADDRFORM),
#endif
#ifdef MCAST_FILTER
- { MCAST_FILTER, "MCAST_FILTER" },
+ XLAT(MCAST_FILTER),
#endif
#ifdef IPV6_PKTOPTIONS
- { IPV6_PKTOPTIONS, "IPV6_PKTOPTIONS" },
+ XLAT(IPV6_PKTOPTIONS),
#endif
#ifdef IPV6_MTU
- { IPV6_MTU, "IPV6_MTU" },
+ XLAT(IPV6_MTU),
#endif
#ifdef IPV6_V6ONLY
- { IPV6_V6ONLY, "IPV6_V6ONLY" },
+ XLAT(IPV6_V6ONLY),
#endif
#ifdef IPV6_PKTINFO
- { IPV6_PKTINFO, "IPV6_PKTINFO" },
+ XLAT(IPV6_PKTINFO),
#endif
#ifdef IPV6_HOPLIMIT
- { IPV6_HOPLIMIT, "IPV6_HOPLIMIT" },
+ XLAT(IPV6_HOPLIMIT),
#endif
#ifdef IPV6_RTHDR
- { IPV6_RTHDR, "IPV6_RTHDR" },
+ XLAT(IPV6_RTHDR),
#endif
#ifdef IPV6_HOPOPTS
- { IPV6_HOPOPTS, "IPV6_HOPOPTS" },
+ XLAT(IPV6_HOPOPTS),
#endif
#ifdef IPV6_DSTOPTS
- { IPV6_DSTOPTS, "IPV6_DSTOPTS" },
+ XLAT(IPV6_DSTOPTS),
#endif
#ifdef IPV6_FLOWINFO
- { IPV6_FLOWINFO, "IPV6_FLOWINFO" },
+ XLAT(IPV6_FLOWINFO),
#endif
#ifdef IPV6_UNICAST_HOPS
- { IPV6_UNICAST_HOPS, "IPV6_UNICAST_HOPS" },
+ XLAT(IPV6_UNICAST_HOPS),
#endif
#ifdef IPV6_MULTICAST_HOPS
- { IPV6_MULTICAST_HOPS, "IPV6_MULTICAST_HOPS" },
+ XLAT(IPV6_MULTICAST_HOPS),
#endif
#ifdef IPV6_MULTICAST_LOOP
- { IPV6_MULTICAST_LOOP, "IPV6_MULTICAST_LOOP" },
+ XLAT(IPV6_MULTICAST_LOOP),
#endif
#ifdef IPV6_MULTICAST_IF
- { IPV6_MULTICAST_IF, "IPV6_MULTICAST_IF" },
+ XLAT(IPV6_MULTICAST_IF),
#endif
#ifdef IPV6_MTU_DISCOVER
- { IPV6_MTU_DISCOVER, "IPV6_MTU_DISCOVER" },
+ XLAT(IPV6_MTU_DISCOVER),
#endif
#ifdef IPV6_RECVERR
- { IPV6_RECVERR, "IPV6_RECVERR" },
+ XLAT(IPV6_RECVERR),
#endif
#ifdef IPV6_FLOWINFO_SEND
- { IPV6_FLOWINFO_SEND, "IPV6_FLOWINFO_SEND" },
+ XLAT(IPV6_FLOWINFO_SEND),
#endif
#ifdef IPV6_ADD_MEMBERSHIP
- { IPV6_ADD_MEMBERSHIP, "IPV6_ADD_MEMBERSHIP" },
+ XLAT(IPV6_ADD_MEMBERSHIP),
#endif
#ifdef IPV6_DROP_MEMBERSHIP
- { IPV6_DROP_MEMBERSHIP, "IPV6_DROP_MEMBERSHIP" },
+ XLAT(IPV6_DROP_MEMBERSHIP),
#endif
#ifdef IPV6_ROUTER_ALERT
- { IPV6_ROUTER_ALERT, "IPV6_ROUTER_ALERT" },
+ XLAT(IPV6_ROUTER_ALERT),
#endif
{ 0, NULL },
};
#ifdef SOL_IPX
static const struct xlat sockipxoptions[] = {
- { IPX_TYPE, "IPX_TYPE" },
+ XLAT(IPX_TYPE),
{ 0, NULL },
};
#endif /* SOL_IPX */
#ifdef SOL_RAW
static const struct xlat sockrawoptions[] = {
#if defined(ICMP_FILTER)
- { ICMP_FILTER, "ICMP_FILTER" },
+ XLAT(ICMP_FILTER),
#endif
{ 0, NULL },
};
#ifdef SOL_PACKET
static const struct xlat sockpacketoptions[] = {
#ifdef PACKET_ADD_MEMBERSHIP
- { PACKET_ADD_MEMBERSHIP, "PACKET_ADD_MEMBERSHIP" },
+ XLAT(PACKET_ADD_MEMBERSHIP),
#endif
#ifdef PACKET_DROP_MEMBERSHIP
- { PACKET_DROP_MEMBERSHIP, "PACKET_DROP_MEMBERSHIP"},
+ XLAT(PACKET_DROP_MEMBERSHIP),
#endif
#if defined(PACKET_RECV_OUTPUT)
- { PACKET_RECV_OUTPUT, "PACKET_RECV_OUTPUT" },
+ XLAT(PACKET_RECV_OUTPUT),
#endif
#if defined(PACKET_RX_RING)
- { PACKET_RX_RING, "PACKET_RX_RING" },
+ XLAT(PACKET_RX_RING),
#endif
#if defined(PACKET_STATISTICS)
- { PACKET_STATISTICS, "PACKET_STATISTICS" },
+ XLAT(PACKET_STATISTICS),
#endif
#if defined(PACKET_COPY_THRESH)
- { PACKET_COPY_THRESH, "PACKET_COPY_THRESH" },
+ XLAT(PACKET_COPY_THRESH),
#endif
#if defined(PACKET_AUXDATA)
- { PACKET_AUXDATA, "PACKET_AUXDATA" },
+ XLAT(PACKET_AUXDATA),
#endif
#if defined(PACKET_ORIGDEV)
- { PACKET_ORIGDEV, "PACKET_ORIGDEV" },
+ XLAT(PACKET_ORIGDEV),
#endif
#if defined(PACKET_VERSION)
- { PACKET_VERSION, "PACKET_VERSION" },
+ XLAT(PACKET_VERSION),
#endif
#if defined(PACKET_HDRLEN)
- { PACKET_HDRLEN, "PACKET_HDRLEN" },
+ XLAT(PACKET_HDRLEN),
#endif
#if defined(PACKET_RESERVE)
- { PACKET_RESERVE, "PACKET_RESERVE" },
+ XLAT(PACKET_RESERVE),
#endif
#if defined(PACKET_TX_RING)
- { PACKET_TX_RING, "PACKET_TX_RING" },
+ XLAT(PACKET_TX_RING),
#endif
#if defined(PACKET_LOSS)
- { PACKET_LOSS, "PACKET_LOSS" },
+ XLAT(PACKET_LOSS),
#endif
{ 0, NULL },
};
#ifdef SOL_SCTP
static const struct xlat socksctpoptions[] = {
#if defined(SCTP_RTOINFO)
- { SCTP_RTOINFO, "SCTP_RTOINFO" },
+ XLAT(SCTP_RTOINFO),
#endif
#if defined(SCTP_ASSOCINFO)
- { SCTP_ASSOCINFO, "SCTP_ASSOCINFO"},
+ XLAT(SCTP_ASSOCINFO),
#endif
#if defined(SCTP_INITMSG)
- { SCTP_INITMSG, "SCTP_INITMSG" },
+ XLAT(SCTP_INITMSG),
#endif
#if defined(SCTP_NODELAY)
- { SCTP_NODELAY, "SCTP_NODELAY" },
+ XLAT(SCTP_NODELAY),
#endif
#if defined(SCTP_AUTOCLOSE)
- { SCTP_AUTOCLOSE, "SCTP_AUTOCLOSE"},
+ XLAT(SCTP_AUTOCLOSE),
#endif
#if defined(SCTP_SET_PEER_PRIMARY_ADDR)
- { SCTP_SET_PEER_PRIMARY_ADDR, "SCTP_SET_PEER_PRIMARY_ADDR"},
+ XLAT(SCTP_SET_PEER_PRIMARY_ADDR),
#endif
#if defined(SCTP_PRIMARY_ADDR)
- { SCTP_PRIMARY_ADDR, "SCTP_PRIMARY_ADDR" },
+ XLAT(SCTP_PRIMARY_ADDR),
#endif
#if defined(SCTP_ADAPTATION_LAYER)
- { SCTP_ADAPTATION_LAYER, "SCTP_ADAPTATION_LAYER" },
+ XLAT(SCTP_ADAPTATION_LAYER),
#endif
#if defined(SCTP_DISABLE_FRAGMENTS)
- { SCTP_DISABLE_FRAGMENTS, "SCTP_DISABLE_FRAGMENTS"},
+ XLAT(SCTP_DISABLE_FRAGMENTS),
#endif
#if defined(SCTP_PEER_ADDR_PARAMS)
- { SCTP_PEER_ADDR_PARAMS, "SCTP_PEER_ADDR_PARAMS" },
+ XLAT(SCTP_PEER_ADDR_PARAMS),
#endif
#if defined(SCTP_DEFAULT_SEND_PARAM)
- { SCTP_DEFAULT_SEND_PARAM, "SCTP_DEFAULT_SEND_PARAM"},
+ XLAT(SCTP_DEFAULT_SEND_PARAM),
#endif
#if defined(SCTP_EVENTS)
- { SCTP_EVENTS, "SCTP_EVENTS" },
+ XLAT(SCTP_EVENTS),
#endif
#if defined(SCTP_I_WANT_MAPPED_V4_ADDR)
- { SCTP_I_WANT_MAPPED_V4_ADDR, "SCTP_I_WANT_MAPPED_V4_ADDR"},
+ XLAT(SCTP_I_WANT_MAPPED_V4_ADDR),
#endif
#if defined(SCTP_MAXSEG)
- { SCTP_MAXSEG, "SCTP_MAXSEG" },
+ XLAT(SCTP_MAXSEG),
#endif
#if defined(SCTP_STATUS)
- { SCTP_STATUS, "SCTP_STATUS" },
+ XLAT(SCTP_STATUS),
#endif
#if defined(SCTP_GET_PEER_ADDR_INFO)
- { SCTP_GET_PEER_ADDR_INFO, "SCTP_GET_PEER_ADDR_INFO"},
+ XLAT(SCTP_GET_PEER_ADDR_INFO),
#endif
#if defined(SCTP_DELAYED_ACK)
- { SCTP_DELAYED_ACK, "SCTP_DELAYED_ACK" },
+ XLAT(SCTP_DELAYED_ACK),
#endif
#if defined(SCTP_CONTEXT)
- { SCTP_CONTEXT, "SCTP_CONTEXT" },
+ XLAT(SCTP_CONTEXT),
#endif
#if defined(SCTP_FRAGMENT_INTERLEAVE)
- { SCTP_FRAGMENT_INTERLEAVE, "SCTP_FRAGMENT_INTERLEAVE"},
+ XLAT(SCTP_FRAGMENT_INTERLEAVE),
#endif
#if defined(SCTP_PARTIAL_DELIVERY_POINT)
- { SCTP_PARTIAL_DELIVERY_POINT, "SCTP_PARTIAL_DELIVERY_POINT"},
+ XLAT(SCTP_PARTIAL_DELIVERY_POINT),
#endif
#if defined(SCTP_MAX_BURST)
- { SCTP_MAX_BURST, "SCTP_MAX_BURST" },
+ XLAT(SCTP_MAX_BURST),
#endif
#if defined(SCTP_AUTH_CHUNK)
- { SCTP_AUTH_CHUNK, "SCTP_AUTH_CHUNK" },
+ XLAT(SCTP_AUTH_CHUNK),
#endif
#if defined(SCTP_HMAC_IDENT)
- { SCTP_HMAC_IDENT, "SCTP_HMAC_IDENT" },
+ XLAT(SCTP_HMAC_IDENT),
#endif
#if defined(SCTP_AUTH_KEY)
- { SCTP_AUTH_KEY, "SCTP_AUTH_KEY" },
+ XLAT(SCTP_AUTH_KEY),
#endif
#if defined(SCTP_AUTH_ACTIVE_KEY)
- { SCTP_AUTH_ACTIVE_KEY, "SCTP_AUTH_ACTIVE_KEY" },
+ XLAT(SCTP_AUTH_ACTIVE_KEY),
#endif
#if defined(SCTP_AUTH_DELETE_KEY)
- { SCTP_AUTH_DELETE_KEY, "SCTP_AUTH_DELETE_KEY" },
+ XLAT(SCTP_AUTH_DELETE_KEY),
#endif
#if defined(SCTP_PEER_AUTH_CHUNKS)
- { SCTP_PEER_AUTH_CHUNKS, "SCTP_PEER_AUTH_CHUNKS" },
+ XLAT(SCTP_PEER_AUTH_CHUNKS),
#endif
#if defined(SCTP_LOCAL_AUTH_CHUNKS)
- { SCTP_LOCAL_AUTH_CHUNKS, "SCTP_LOCAL_AUTH_CHUNKS"},
+ XLAT(SCTP_LOCAL_AUTH_CHUNKS),
#endif
#if defined(SCTP_GET_ASSOC_NUMBER)
- { SCTP_GET_ASSOC_NUMBER, "SCTP_GET_ASSOC_NUMBER" },
+ XLAT(SCTP_GET_ASSOC_NUMBER),
#endif
/* linux specific things */
#if defined(SCTP_SOCKOPT_BINDX_ADD)
- { SCTP_SOCKOPT_BINDX_ADD, "SCTP_SOCKOPT_BINDX_ADD" },
+ XLAT(SCTP_SOCKOPT_BINDX_ADD),
#endif
#if defined(SCTP_SOCKOPT_BINDX_REM)
- { SCTP_SOCKOPT_BINDX_REM, "SCTP_SOCKOPT_BINDX_REM" },
+ XLAT(SCTP_SOCKOPT_BINDX_REM),
#endif
#if defined(SCTP_SOCKOPT_PEELOFF)
- { SCTP_SOCKOPT_PEELOFF, "SCTP_SOCKOPT_PEELOFF" },
+ XLAT(SCTP_SOCKOPT_PEELOFF),
#endif
#if defined(SCTP_GET_PEER_ADDRS_NUM_OLD)
- { SCTP_GET_PEER_ADDRS_NUM_OLD, "SCTP_GET_PEER_ADDRS_NUM_OLD" },
+ XLAT(SCTP_GET_PEER_ADDRS_NUM_OLD),
#endif
#if defined(SCTP_GET_PEER_ADDRS_OLD)
- { SCTP_GET_PEER_ADDRS_OLD, "SCTP_GET_PEER_ADDRS_OLD" },
+ XLAT(SCTP_GET_PEER_ADDRS_OLD),
#endif
#if defined(SCTP_GET_LOCAL_ADDRS_NUM_OLD)
- { SCTP_GET_LOCAL_ADDRS_NUM_OLD, "SCTP_GET_LOCAL_ADDRS_NUM_OLD" },
+ XLAT(SCTP_GET_LOCAL_ADDRS_NUM_OLD),
#endif
#if defined(SCTP_GET_LOCAL_ADDRS_OLD)
- { SCTP_GET_LOCAL_ADDRS_OLD, "SCTP_GET_LOCAL_ADDRS_OLD" },
+ XLAT(SCTP_GET_LOCAL_ADDRS_OLD),
#endif
#if defined(SCTP_SOCKOPT_CONNECTX_OLD)
- { SCTP_SOCKOPT_CONNECTX_OLD, "SCTP_SOCKOPT_CONNECTX_OLD" },
+ XLAT(SCTP_SOCKOPT_CONNECTX_OLD),
#endif
#if defined(SCTP_GET_PEER_ADDRS)
- { SCTP_GET_PEER_ADDRS, "SCTP_GET_PEER_ADDRS" },
+ XLAT(SCTP_GET_PEER_ADDRS),
#endif
#if defined(SCTP_GET_LOCAL_ADDRS)
- { SCTP_GET_LOCAL_ADDRS, "SCTP_GET_LOCAL_ADDRS" },
+ XLAT(SCTP_GET_LOCAL_ADDRS),
#endif
{ 0, NULL },
#ifdef SOL_TCP
static const struct xlat socktcpoptions[] = {
- { TCP_NODELAY, "TCP_NODELAY" },
- { TCP_MAXSEG, "TCP_MAXSEG" },
+ XLAT(TCP_NODELAY),
+ XLAT(TCP_MAXSEG),
#ifdef TCP_CORK
- { TCP_CORK, "TCP_CORK" },
+ XLAT(TCP_CORK),
#endif
#ifdef TCP_KEEPIDLE
- { TCP_KEEPIDLE, "TCP_KEEPIDLE" },
+ XLAT(TCP_KEEPIDLE),
#endif
#ifdef TCP_KEEPINTVL
- { TCP_KEEPINTVL, "TCP_KEEPINTVL" },
+ XLAT(TCP_KEEPINTVL),
#endif
#ifdef TCP_KEEPCNT
- { TCP_KEEPCNT, "TCP_KEEPCNT" },
+ XLAT(TCP_KEEPCNT),
#endif
#ifdef TCP_SYNCNT
- { TCP_SYNCNT, "TCP_SYNCNT" },
+ XLAT(TCP_SYNCNT),
#endif
#ifdef TCP_LINGER2
- { TCP_LINGER2, "TCP_LINGER2" },
+ XLAT(TCP_LINGER2),
#endif
#ifdef TCP_DEFER_ACCEPT
- { TCP_DEFER_ACCEPT, "TCP_DEFER_ACCEPT" },
+ XLAT(TCP_DEFER_ACCEPT),
#endif
#ifdef TCP_WINDOW_CLAMP
- { TCP_WINDOW_CLAMP, "TCP_WINDOW_CLAMP" },
+ XLAT(TCP_WINDOW_CLAMP),
#endif
#ifdef TCP_INFO
- { TCP_INFO, "TCP_INFO" },
+ XLAT(TCP_INFO),
#endif
#ifdef TCP_QUICKACK
- { TCP_QUICKACK, "TCP_QUICKACK" },
+ XLAT(TCP_QUICKACK),
#endif
#ifdef TCP_CONGESTION
- { TCP_CONGESTION, "TCP_CONGESTION" },
+ XLAT(TCP_CONGESTION),
#endif
#ifdef TCP_MD5SIG
- { TCP_MD5SIG, "TCP_MD5SIG" },
+ XLAT(TCP_MD5SIG),
#endif
#ifdef TCP_COOKIE_TRANSACTIONS
- { TCP_COOKIE_TRANSACTIONS, "TCP_COOKIE_TRANSACTIONS" },
+ XLAT(TCP_COOKIE_TRANSACTIONS),
#endif
#ifdef TCP_THIN_LINEAR_TIMEOUTS
- { TCP_THIN_LINEAR_TIMEOUTS, "TCP_THIN_LINEAR_TIMEOUTS" },
+ XLAT(TCP_THIN_LINEAR_TIMEOUTS),
#endif
#ifdef TCP_THIN_DUPACK
- { TCP_THIN_DUPACK, "TCP_THIN_DUPACK" },
+ XLAT(TCP_THIN_DUPACK),
#endif
#ifdef TCP_USER_TIMEOUT
- { TCP_USER_TIMEOUT, "TCP_USER_TIMEOUT" },
+ XLAT(TCP_USER_TIMEOUT),
#endif
#ifdef TCP_REPAIR
- { TCP_REPAIR, "TCP_REPAIR" },
+ XLAT(TCP_REPAIR),
#endif
#ifdef TCP_REPAIR_QUEUE
- { TCP_REPAIR_QUEUE, "TCP_REPAIR_QUEUE" },
+ XLAT(TCP_REPAIR_QUEUE),
#endif
#ifdef TCP_QUEUE_SEQ
- { TCP_QUEUE_SEQ, "TCP_QUEUE_SEQ" },
+ XLAT(TCP_QUEUE_SEQ),
#endif
#ifdef TCP_REPAIR_OPTIONS
- { TCP_REPAIR_OPTIONS, "TCP_REPAIR_OPTIONS" },
+ XLAT(TCP_REPAIR_OPTIONS),
#endif
#ifdef TCP_FASTOPEN
- { TCP_FASTOPEN, "TCP_FASTOPEN" },
+ XLAT(TCP_FASTOPEN),
#endif
#ifdef TCP_TIMESTAMP
- { TCP_TIMESTAMP, "TCP_TIMESTAMP" },
+ XLAT(TCP_TIMESTAMP),
#endif
{ 0, NULL },
};
#if defined(AF_PACKET) /* from e.g. linux/if_packet.h */
static const struct xlat af_packet_types[] = {
#if defined(PACKET_HOST)
- { PACKET_HOST, "PACKET_HOST" },
+ XLAT(PACKET_HOST),
#endif
#if defined(PACKET_BROADCAST)
- { PACKET_BROADCAST, "PACKET_BROADCAST" },
+ XLAT(PACKET_BROADCAST),
#endif
#if defined(PACKET_MULTICAST)
- { PACKET_MULTICAST, "PACKET_MULTICAST" },
+ XLAT(PACKET_MULTICAST),
#endif
#if defined(PACKET_OTHERHOST)
- { PACKET_OTHERHOST, "PACKET_OTHERHOST" },
+ XLAT(PACKET_OTHERHOST),
#endif
#if defined(PACKET_OUTGOING)
- { PACKET_OUTGOING, "PACKET_OUTGOING" },
+ XLAT(PACKET_OUTGOING),
#endif
#if defined(PACKET_LOOPBACK)
- { PACKET_LOOPBACK, "PACKET_LOOPBACK" },
+ XLAT(PACKET_LOOPBACK),
#endif
#if defined(PACKET_FASTROUTE)
- { PACKET_FASTROUTE, "PACKET_FASTROUTE" },
+ XLAT(PACKET_FASTROUTE),
#endif
{ 0, NULL },
};
#if HAVE_SENDMSG
static const struct xlat scmvals[] = {
#ifdef SCM_RIGHTS
- { SCM_RIGHTS, "SCM_RIGHTS" },
+ XLAT(SCM_RIGHTS),
#endif
#ifdef SCM_CREDENTIALS
- { SCM_CREDENTIALS, "SCM_CREDENTIALS" },
+ XLAT(SCM_CREDENTIALS),
#endif
{ 0, NULL }
};
static const struct xlat prctl_options[] = {
#ifdef PR_MAXPROCS
- { PR_MAXPROCS, "PR_MAXPROCS" },
+ XLAT(PR_MAXPROCS),
#endif
#ifdef PR_ISBLOCKED
- { PR_ISBLOCKED, "PR_ISBLOCKED" },
+ XLAT(PR_ISBLOCKED),
#endif
#ifdef PR_SETSTACKSIZE
- { PR_SETSTACKSIZE, "PR_SETSTACKSIZE" },
+ XLAT(PR_SETSTACKSIZE),
#endif
#ifdef PR_GETSTACKSIZE
- { PR_GETSTACKSIZE, "PR_GETSTACKSIZE" },
+ XLAT(PR_GETSTACKSIZE),
#endif
#ifdef PR_MAXPPROCS
- { PR_MAXPPROCS, "PR_MAXPPROCS" },
+ XLAT(PR_MAXPPROCS),
#endif
#ifdef PR_UNBLKONEXEC
- { PR_UNBLKONEXEC, "PR_UNBLKONEXEC" },
+ XLAT(PR_UNBLKONEXEC),
#endif
#ifdef PR_ATOMICSIM
- { PR_ATOMICSIM, "PR_ATOMICSIM" },
+ XLAT(PR_ATOMICSIM),
#endif
#ifdef PR_SETEXITSIG
- { PR_SETEXITSIG, "PR_SETEXITSIG" },
+ XLAT(PR_SETEXITSIG),
#endif
#ifdef PR_RESIDENT
- { PR_RESIDENT, "PR_RESIDENT" },
+ XLAT(PR_RESIDENT),
#endif
#ifdef PR_ATTACHADDR
- { PR_ATTACHADDR, "PR_ATTACHADDR" },
+ XLAT(PR_ATTACHADDR),
#endif
#ifdef PR_DETACHADDR
- { PR_DETACHADDR, "PR_DETACHADDR" },
+ XLAT(PR_DETACHADDR),
#endif
#ifdef PR_TERMCHILD
- { PR_TERMCHILD, "PR_TERMCHILD" },
+ XLAT(PR_TERMCHILD),
#endif
#ifdef PR_GETSHMASK
- { PR_GETSHMASK, "PR_GETSHMASK" },
+ XLAT(PR_GETSHMASK),
#endif
#ifdef PR_GETNSHARE
- { PR_GETNSHARE, "PR_GETNSHARE" },
+ XLAT(PR_GETNSHARE),
#endif
#ifdef PR_COREPID
- { PR_COREPID, "PR_COREPID" },
+ XLAT(PR_COREPID),
#endif
#ifdef PR_ATTACHADDRPERM
- { PR_ATTACHADDRPERM, "PR_ATTACHADDRPERM" },
+ XLAT(PR_ATTACHADDRPERM),
#endif
#ifdef PR_PTHREADEXIT
- { PR_PTHREADEXIT, "PR_PTHREADEXIT" },
+ XLAT(PR_PTHREADEXIT),
#endif
#ifdef PR_SET_PDEATHSIG
- { PR_SET_PDEATHSIG, "PR_SET_PDEATHSIG" },
+ XLAT(PR_SET_PDEATHSIG),
#endif
#ifdef PR_GET_PDEATHSIG
- { PR_GET_PDEATHSIG, "PR_GET_PDEATHSIG" },
+ XLAT(PR_GET_PDEATHSIG),
#endif
#ifdef PR_GET_DUMPABLE
- { PR_GET_DUMPABLE, "PR_GET_DUMPABLE" },
+ XLAT(PR_GET_DUMPABLE),
#endif
#ifdef PR_SET_DUMPABLE
- { PR_SET_DUMPABLE, "PR_SET_DUMPABLE" },
+ XLAT(PR_SET_DUMPABLE),
#endif
#ifdef PR_GET_UNALIGN
- { PR_GET_UNALIGN, "PR_GET_UNALIGN" },
+ XLAT(PR_GET_UNALIGN),
#endif
#ifdef PR_SET_UNALIGN
- { PR_SET_UNALIGN, "PR_SET_UNALIGN" },
+ XLAT(PR_SET_UNALIGN),
#endif
#ifdef PR_GET_KEEPCAPS
- { PR_GET_KEEPCAPS, "PR_GET_KEEPCAPS" },
+ XLAT(PR_GET_KEEPCAPS),
#endif
#ifdef PR_SET_KEEPCAPS
- { PR_SET_KEEPCAPS, "PR_SET_KEEPCAPS" },
+ XLAT(PR_SET_KEEPCAPS),
#endif
#ifdef PR_GET_FPEMU
- { PR_GET_FPEMU, "PR_GET_FPEMU" },
+ XLAT(PR_GET_FPEMU),
#endif
#ifdef PR_SET_FPEMU
- { PR_SET_FPEMU, "PR_SET_FPEMU" },
+ XLAT(PR_SET_FPEMU),
#endif
#ifdef PR_GET_FPEXC
- { PR_GET_FPEXC, "PR_GET_FPEXC" },
+ XLAT(PR_GET_FPEXC),
#endif
#ifdef PR_SET_FPEXC
- { PR_SET_FPEXC, "PR_SET_FPEXC" },
+ XLAT(PR_SET_FPEXC),
#endif
#ifdef PR_GET_TIMING
- { PR_GET_TIMING, "PR_GET_TIMING" },
+ XLAT(PR_GET_TIMING),
#endif
#ifdef PR_SET_TIMING
- { PR_SET_TIMING, "PR_SET_TIMING" },
+ XLAT(PR_SET_TIMING),
#endif
#ifdef PR_SET_NAME
- { PR_SET_NAME, "PR_SET_NAME" },
+ XLAT(PR_SET_NAME),
#endif
#ifdef PR_GET_NAME
- { PR_GET_NAME, "PR_GET_NAME" },
+ XLAT(PR_GET_NAME),
#endif
#ifdef PR_GET_ENDIAN
- { PR_GET_ENDIAN, "PR_GET_ENDIAN" },
+ XLAT(PR_GET_ENDIAN),
#endif
#ifdef PR_SET_ENDIAN
- { PR_SET_ENDIAN, "PR_SET_ENDIAN" },
+ XLAT(PR_SET_ENDIAN),
#endif
#ifdef PR_GET_SECCOMP
- { PR_GET_SECCOMP, "PR_GET_SECCOMP" },
+ XLAT(PR_GET_SECCOMP),
#endif
#ifdef PR_SET_SECCOMP
- { PR_SET_SECCOMP, "PR_SET_SECCOMP" },
+ XLAT(PR_SET_SECCOMP),
#endif
#ifdef PR_CAPBSET_READ
- { PR_CAPBSET_READ, "PR_CAPBSET_READ" },
+ XLAT(PR_CAPBSET_READ),
#endif
#ifdef PR_CAPBSET_DROP
- { PR_CAPBSET_DROP, "PR_CAPBSET_DROP" },
+ XLAT(PR_CAPBSET_DROP),
#endif
#ifdef PR_GET_TSC
- { PR_GET_TSC, "PR_GET_TSC" },
+ XLAT(PR_GET_TSC),
#endif
#ifdef PR_SET_TSC
- { PR_SET_TSC, "PR_SET_TSC" },
+ XLAT(PR_SET_TSC),
#endif
#ifdef PR_GET_SECUREBITS
- { PR_GET_SECUREBITS, "PR_GET_SECUREBITS" },
+ XLAT(PR_GET_SECUREBITS),
#endif
#ifdef PR_SET_SECUREBITS
- { PR_SET_SECUREBITS, "PR_SET_SECUREBITS" },
+ XLAT(PR_SET_SECUREBITS),
#endif
#ifdef PR_SET_TIMERSLACK
- { PR_SET_TIMERSLACK, "PR_SET_TIMERSLACK" },
+ XLAT(PR_SET_TIMERSLACK),
#endif
#ifdef PR_GET_TIMERSLACK
- { PR_GET_TIMERSLACK, "PR_GET_TIMERSLACK" },
+ XLAT(PR_GET_TIMERSLACK),
#endif
#ifdef PR_TASK_PERF_EVENTS_DISABLE
- { PR_TASK_PERF_EVENTS_DISABLE, "PR_TASK_PERF_EVENTS_DISABLE" },
+ XLAT(PR_TASK_PERF_EVENTS_DISABLE),
#endif
#ifdef PR_TASK_PERF_EVENTS_ENABLE
- { PR_TASK_PERF_EVENTS_ENABLE, "PR_TASK_PERF_EVENTS_ENABLE" },
+ XLAT(PR_TASK_PERF_EVENTS_ENABLE),
#endif
#ifdef PR_MCE_KILL
- { PR_MCE_KILL, "PR_MCE_KILL" },
+ XLAT(PR_MCE_KILL),
#endif
#ifdef PR_MCE_KILL_GET
- { PR_MCE_KILL_GET, "PR_MCE_KILL_GET" },
+ XLAT(PR_MCE_KILL_GET),
#endif
#ifdef PR_SET_MM
- { PR_SET_MM, "PR_SET_MM" },
+ XLAT(PR_SET_MM),
#endif
#ifdef PR_SET_PTRACER
- { PR_SET_PTRACER, "PR_SET_PTRACER" },
+ XLAT(PR_SET_PTRACER),
#endif
#ifdef PR_SET_CHILD_SUBREAPER
- { PR_SET_CHILD_SUBREAPER, "PR_SET_CHILD_SUBREAPER" },
+ XLAT(PR_SET_CHILD_SUBREAPER),
#endif
#ifdef PR_GET_CHILD_SUBREAPER
- { PR_GET_CHILD_SUBREAPER, "PR_GET_CHILD_SUBREAPER" },
+ XLAT(PR_GET_CHILD_SUBREAPER),
#endif
#ifdef PR_SET_NO_NEW_PRIVS
- { PR_SET_NO_NEW_PRIVS, "PR_SET_NO_NEW_PRIVS" },
+ XLAT(PR_SET_NO_NEW_PRIVS),
#endif
#ifdef PR_GET_NO_NEW_PRIVS
- { PR_GET_NO_NEW_PRIVS, "PR_GET_NO_NEW_PRIVS" },
+ XLAT(PR_GET_NO_NEW_PRIVS),
#endif
#ifdef PR_GET_TID_ADDRESS
- { PR_GET_TID_ADDRESS, "PR_GET_TID_ADDRESS" },
+ XLAT(PR_GET_TID_ADDRESS),
#endif
{ 0, NULL },
};
#define CLONE_IO 0x80000000 /* Clone io context */
static const struct xlat clone_flags[] = {
- { CLONE_VM, "CLONE_VM" },
- { CLONE_FS, "CLONE_FS" },
- { CLONE_FILES, "CLONE_FILES" },
- { CLONE_SIGHAND, "CLONE_SIGHAND" },
- { CLONE_IDLETASK, "CLONE_IDLETASK" },
- { CLONE_PTRACE, "CLONE_PTRACE" },
- { CLONE_VFORK, "CLONE_VFORK" },
- { CLONE_PARENT, "CLONE_PARENT" },
- { CLONE_THREAD, "CLONE_THREAD" },
- { CLONE_NEWNS, "CLONE_NEWNS" },
- { CLONE_SYSVSEM, "CLONE_SYSVSEM" },
- { CLONE_SETTLS, "CLONE_SETTLS" },
- { CLONE_PARENT_SETTID, "CLONE_PARENT_SETTID" },
- { CLONE_CHILD_CLEARTID, "CLONE_CHILD_CLEARTID" },
- { CLONE_UNTRACED, "CLONE_UNTRACED" },
- { CLONE_CHILD_SETTID, "CLONE_CHILD_SETTID" },
- { CLONE_STOPPED, "CLONE_STOPPED" },
- { CLONE_NEWUTS, "CLONE_NEWUTS" },
- { CLONE_NEWIPC, "CLONE_NEWIPC" },
- { CLONE_NEWUSER, "CLONE_NEWUSER" },
- { CLONE_NEWPID, "CLONE_NEWPID" },
- { CLONE_NEWNET, "CLONE_NEWNET" },
- { CLONE_IO, "CLONE_IO" },
+ XLAT(CLONE_VM),
+ XLAT(CLONE_FS),
+ XLAT(CLONE_FILES),
+ XLAT(CLONE_SIGHAND),
+ XLAT(CLONE_IDLETASK),
+ XLAT(CLONE_PTRACE),
+ XLAT(CLONE_VFORK),
+ XLAT(CLONE_PARENT),
+ XLAT(CLONE_THREAD),
+ XLAT(CLONE_NEWNS),
+ XLAT(CLONE_SYSVSEM),
+ XLAT(CLONE_SETTLS),
+ XLAT(CLONE_PARENT_SETTID),
+ XLAT(CLONE_CHILD_CLEARTID),
+ XLAT(CLONE_UNTRACED),
+ XLAT(CLONE_CHILD_SETTID),
+ XLAT(CLONE_STOPPED),
+ XLAT(CLONE_NEWUTS),
+ XLAT(CLONE_NEWIPC),
+ XLAT(CLONE_NEWUSER),
+ XLAT(CLONE_NEWPID),
+ XLAT(CLONE_NEWNET),
+ XLAT(CLONE_IO),
{ 0, NULL },
};
#endif
static const struct xlat wait4_options[] = {
- { WNOHANG, "WNOHANG" },
+ XLAT(WNOHANG),
#ifndef WSTOPPED
- { WUNTRACED, "WUNTRACED" },
+ XLAT(WUNTRACED),
#endif
#ifdef WEXITED
- { WEXITED, "WEXITED" },
+ XLAT(WEXITED),
#endif
#ifdef WTRAPPED
- { WTRAPPED, "WTRAPPED" },
+ XLAT(WTRAPPED),
#endif
#ifdef WSTOPPED
- { WSTOPPED, "WSTOPPED" },
+ XLAT(WSTOPPED),
#endif
#ifdef WCONTINUED
- { WCONTINUED, "WCONTINUED" },
+ XLAT(WCONTINUED),
#endif
#ifdef WNOWAIT
- { WNOWAIT, "WNOWAIT" },
+ XLAT(WNOWAIT),
#endif
#ifdef __WCLONE
- { __WCLONE, "__WCLONE" },
+ XLAT(__WCLONE),
#endif
#ifdef __WALL
- { __WALL, "__WALL" },
+ XLAT(__WALL),
#endif
#ifdef __WNOTHREAD
- { __WNOTHREAD, "__WNOTHREAD" },
+ XLAT(__WNOTHREAD),
#endif
{ 0, NULL },
};
#endif
static const struct xlat waitid_types[] = {
- { P_PID, "P_PID" },
+ XLAT(P_PID),
#ifdef P_PPID
- { P_PPID, "P_PPID" },
+ XLAT(P_PPID),
#endif
- { P_PGID, "P_PGID" },
+ XLAT(P_PGID),
#ifdef P_SID
- { P_SID, "P_SID" },
+ XLAT(P_SID),
#endif
#ifdef P_CID
- { P_CID, "P_CID" },
+ XLAT(P_CID),
#endif
#ifdef P_UID
- { P_UID, "P_UID" },
+ XLAT(P_UID),
#endif
#ifdef P_GID
- { P_GID, "P_GID" },
+ XLAT(P_GID),
#endif
- { P_ALL, "P_ALL" },
+ XLAT(P_ALL),
#ifdef P_LWPID
- { P_LWPID, "P_LWPID" },
+ XLAT(P_LWPID),
#endif
{ 0, NULL },
};
}
static const struct xlat ptrace_cmds[] = {
- { PTRACE_TRACEME, "PTRACE_TRACEME" },
- { PTRACE_PEEKTEXT, "PTRACE_PEEKTEXT" },
- { PTRACE_PEEKDATA, "PTRACE_PEEKDATA" },
- { PTRACE_PEEKUSER, "PTRACE_PEEKUSER" },
- { PTRACE_POKETEXT, "PTRACE_POKETEXT" },
- { PTRACE_POKEDATA, "PTRACE_POKEDATA" },
- { PTRACE_POKEUSER, "PTRACE_POKEUSER" },
- { PTRACE_CONT, "PTRACE_CONT" },
- { PTRACE_KILL, "PTRACE_KILL" },
- { PTRACE_SINGLESTEP, "PTRACE_SINGLESTEP" },
- { PTRACE_ATTACH, "PTRACE_ATTACH" },
- { PTRACE_DETACH, "PTRACE_DETACH" },
+ XLAT(PTRACE_TRACEME),
+ XLAT(PTRACE_PEEKTEXT),
+ XLAT(PTRACE_PEEKDATA),
+ XLAT(PTRACE_PEEKUSER),
+ XLAT(PTRACE_POKETEXT),
+ XLAT(PTRACE_POKEDATA),
+ XLAT(PTRACE_POKEUSER),
+ XLAT(PTRACE_CONT),
+ XLAT(PTRACE_KILL),
+ XLAT(PTRACE_SINGLESTEP),
+ XLAT(PTRACE_ATTACH),
+ XLAT(PTRACE_DETACH),
#ifdef PTRACE_GETREGS
- { PTRACE_GETREGS, "PTRACE_GETREGS" },
+ XLAT(PTRACE_GETREGS),
#endif
#ifdef PTRACE_SETREGS
- { PTRACE_SETREGS, "PTRACE_SETREGS" },
+ XLAT(PTRACE_SETREGS),
#endif
#ifdef PTRACE_GETFPREGS
- { PTRACE_GETFPREGS, "PTRACE_GETFPREGS" },
+ XLAT(PTRACE_GETFPREGS),
#endif
#ifdef PTRACE_SETFPREGS
- { PTRACE_SETFPREGS, "PTRACE_SETFPREGS" },
+ XLAT(PTRACE_SETFPREGS),
#endif
#ifdef PTRACE_GETFPXREGS
- { PTRACE_GETFPXREGS, "PTRACE_GETFPXREGS" },
+ XLAT(PTRACE_GETFPXREGS),
#endif
#ifdef PTRACE_SETFPXREGS
- { PTRACE_SETFPXREGS, "PTRACE_SETFPXREGS" },
+ XLAT(PTRACE_SETFPXREGS),
#endif
#ifdef PTRACE_GETVRREGS
- { PTRACE_GETVRREGS, "PTRACE_GETVRREGS" },
+ XLAT(PTRACE_GETVRREGS),
#endif
#ifdef PTRACE_SETVRREGS
- { PTRACE_SETVRREGS, "PTRACE_SETVRREGS" },
+ XLAT(PTRACE_SETVRREGS),
#endif
#ifdef PTRACE_SETOPTIONS
- { PTRACE_SETOPTIONS, "PTRACE_SETOPTIONS" },
+ XLAT(PTRACE_SETOPTIONS),
#endif
#ifdef PTRACE_GETEVENTMSG
- { PTRACE_GETEVENTMSG, "PTRACE_GETEVENTMSG" },
+ XLAT(PTRACE_GETEVENTMSG),
#endif
#ifdef PTRACE_GETSIGINFO
- { PTRACE_GETSIGINFO, "PTRACE_GETSIGINFO" },
+ XLAT(PTRACE_GETSIGINFO),
#endif
#ifdef PTRACE_SETSIGINFO
- { PTRACE_SETSIGINFO, "PTRACE_SETSIGINFO" },
+ XLAT(PTRACE_SETSIGINFO),
#endif
#ifdef PTRACE_GETREGSET
- { PTRACE_GETREGSET, "PTRACE_GETREGSET" },
+ XLAT(PTRACE_GETREGSET),
#endif
#ifdef PTRACE_SETREGSET
- { PTRACE_SETREGSET, "PTRACE_SETREGSET" },
+ XLAT(PTRACE_SETREGSET),
#endif
#ifdef PTRACE_SET_SYSCALL
- { PTRACE_SET_SYSCALL, "PTRACE_SET_SYSCALL" },
+ XLAT(PTRACE_SET_SYSCALL),
#endif
#ifdef PTRACE_SEIZE
- { PTRACE_SEIZE, "PTRACE_SEIZE" },
+ XLAT(PTRACE_SEIZE),
#endif
#ifdef PTRACE_INTERRUPT
- { PTRACE_INTERRUPT, "PTRACE_INTERRUPT" },
+ XLAT(PTRACE_INTERRUPT),
#endif
#ifdef PTRACE_LISTEN
- { PTRACE_LISTEN, "PTRACE_LISTEN" },
+ XLAT(PTRACE_LISTEN),
#endif
- { PTRACE_SYSCALL, "PTRACE_SYSCALL" },
+ XLAT(PTRACE_SYSCALL),
{ 0, NULL },
};
#ifdef PTRACE_SETOPTIONS
static const struct xlat ptrace_setoptions_flags[] = {
# ifdef PTRACE_O_TRACESYSGOOD
- { PTRACE_O_TRACESYSGOOD,"PTRACE_O_TRACESYSGOOD" },
+ XLAT(PTRACE_O_TRACESYSGOOD),
# endif
# ifdef PTRACE_O_TRACEFORK
- { PTRACE_O_TRACEFORK, "PTRACE_O_TRACEFORK" },
+ XLAT(PTRACE_O_TRACEFORK),
# endif
# ifdef PTRACE_O_TRACEVFORK
- { PTRACE_O_TRACEVFORK, "PTRACE_O_TRACEVFORK" },
+ XLAT(PTRACE_O_TRACEVFORK),
# endif
# ifdef PTRACE_O_TRACECLONE
- { PTRACE_O_TRACECLONE, "PTRACE_O_TRACECLONE" },
+ XLAT(PTRACE_O_TRACECLONE),
# endif
# ifdef PTRACE_O_TRACEEXEC
- { PTRACE_O_TRACEEXEC, "PTRACE_O_TRACEEXEC" },
+ XLAT(PTRACE_O_TRACEEXEC),
# endif
# ifdef PTRACE_O_TRACEVFORKDONE
- { PTRACE_O_TRACEVFORKDONE,"PTRACE_O_TRACEVFORKDONE"},
+ XLAT(PTRACE_O_TRACEVFORKDONE),
# endif
# ifdef PTRACE_O_TRACEEXIT
- { PTRACE_O_TRACEEXIT, "PTRACE_O_TRACEEXIT" },
+ XLAT(PTRACE_O_TRACEEXIT),
# endif
# ifdef PTRACE_O_TRACESECCOMP
- { PTRACE_O_TRACESECCOMP,"PTRACE_O_TRACESECCOMP" },
+ XLAT(PTRACE_O_TRACESECCOMP),
# endif
# ifdef PTRACE_O_EXITKILL
- { PTRACE_O_EXITKILL, "PTRACE_O_EXITKILL" },
+ XLAT(PTRACE_O_EXITKILL),
# endif
{ 0, NULL },
};
static const struct xlat nt_descriptor_types[] = {
#ifdef NT_PRSTATUS
- { NT_PRSTATUS, "NT_PRSTATUS" },
+ XLAT(NT_PRSTATUS),
#endif
#ifdef NT_FPREGSET
- { NT_FPREGSET, "NT_FPREGSET" },
+ XLAT(NT_FPREGSET),
#endif
#ifdef NT_PRPSINFO
- { NT_PRPSINFO, "NT_PRPSINFO" },
+ XLAT(NT_PRPSINFO),
#endif
#ifdef NT_PRXREG
- { NT_PRXREG, "NT_PRXREG" },
+ XLAT(NT_PRXREG),
#endif
#ifdef NT_TASKSTRUCT
- { NT_TASKSTRUCT, "NT_TASKSTRUCT" },
+ XLAT(NT_TASKSTRUCT),
#endif
#ifdef NT_PLATFORM
- { NT_PLATFORM, "NT_PLATFORM" },
+ XLAT(NT_PLATFORM),
#endif
#ifdef NT_AUXV
- { NT_AUXV, "NT_AUXV" },
+ XLAT(NT_AUXV),
#endif
#ifdef NT_GWINDOWS
- { NT_GWINDOWS, "NT_GWINDOWS" },
+ XLAT(NT_GWINDOWS),
#endif
#ifdef NT_ASRS
- { NT_ASRS, "NT_ASRS" },
+ XLAT(NT_ASRS),
#endif
#ifdef NT_PSTATUS
- { NT_PSTATUS, "NT_PSTATUS" },
+ XLAT(NT_PSTATUS),
#endif
#ifdef NT_PSINFO
- { NT_PSINFO, "NT_PSINFO" },
+ XLAT(NT_PSINFO),
#endif
#ifdef NT_PRCRED
- { NT_PRCRED, "NT_PRCRED" },
+ XLAT(NT_PRCRED),
#endif
#ifdef NT_UTSNAME
- { NT_UTSNAME, "NT_UTSNAME" },
+ XLAT(NT_UTSNAME),
#endif
#ifdef NT_LWPSTATUS
- { NT_LWPSTATUS, "NT_LWPSTATUS" },
+ XLAT(NT_LWPSTATUS),
#endif
#ifdef NT_LWPSINFO
- { NT_LWPSINFO, "NT_LWPSINFO" },
+ XLAT(NT_LWPSINFO),
#endif
#ifdef NT_PRFPXREG
- { NT_PRFPXREG, "NT_PRFPXREG" },
+ XLAT(NT_PRFPXREG),
#endif
#ifdef NT_PRXFPREG
- { NT_PRXFPREG, "NT_PRXFPREG" },
+ XLAT(NT_PRXFPREG),
#endif
#ifdef NT_PPC_VMX
- { NT_PPC_VMX, "NT_PPC_VMX" },
+ XLAT(NT_PPC_VMX),
#endif
#ifdef NT_PPC_SPE
- { NT_PPC_SPE, "NT_PPC_SPE" },
+ XLAT(NT_PPC_SPE),
#endif
#ifdef NT_PPC_VSX
- { NT_PPC_VSX, "NT_PPC_VSX" },
+ XLAT(NT_PPC_VSX),
#endif
#ifdef NT_386_TLS
- { NT_386_TLS, "NT_386_TLS" },
+ XLAT(NT_386_TLS),
#endif
#ifdef NT_386_IOPERM
- { NT_386_IOPERM, "NT_386_IOPERM" },
+ XLAT(NT_386_IOPERM),
#endif
#ifdef NT_X86_XSTATE
- { NT_X86_XSTATE, "NT_X86_XSTATE" },
+ XLAT(NT_X86_XSTATE),
#endif
{ 0, NULL },
};
# endif
{ PT_DBR, "dbr" }, { PT_IBR, "ibr" }, { PT_PMD, "pmd" },
#elif defined(I386)
- { 4*EBX, "4*EBX" },
- { 4*ECX, "4*ECX" },
- { 4*EDX, "4*EDX" },
- { 4*ESI, "4*ESI" },
- { 4*EDI, "4*EDI" },
- { 4*EBP, "4*EBP" },
- { 4*EAX, "4*EAX" },
- { 4*DS, "4*DS" },
- { 4*ES, "4*ES" },
- { 4*FS, "4*FS" },
- { 4*GS, "4*GS" },
- { 4*ORIG_EAX, "4*ORIG_EAX" },
- { 4*EIP, "4*EIP" },
- { 4*CS, "4*CS" },
- { 4*EFL, "4*EFL" },
- { 4*UESP, "4*UESP" },
- { 4*SS, "4*SS" },
+ XLAT(4*EBX),
+ XLAT(4*ECX),
+ XLAT(4*EDX),
+ XLAT(4*ESI),
+ XLAT(4*EDI),
+ XLAT(4*EBP),
+ XLAT(4*EAX),
+ XLAT(4*DS),
+ XLAT(4*ES),
+ XLAT(4*FS),
+ XLAT(4*GS),
+ XLAT(4*ORIG_EAX),
+ XLAT(4*EIP),
+ XLAT(4*CS),
+ XLAT(4*EFL),
+ XLAT(4*UESP),
+ XLAT(4*SS),
#elif defined(X86_64) || defined(X32)
- { 8*R15, "8*R15" },
- { 8*R14, "8*R14" },
- { 8*R13, "8*R13" },
- { 8*R12, "8*R12" },
- { 8*RBP, "8*RBP" },
- { 8*RBX, "8*RBX" },
- { 8*R11, "8*R11" },
- { 8*R10, "8*R10" },
- { 8*R9, "8*R9" },
- { 8*R8, "8*R8" },
- { 8*RAX, "8*RAX" },
- { 8*RCX, "8*RCX" },
- { 8*RDX, "8*RDX" },
- { 8*RSI, "8*RSI" },
- { 8*RDI, "8*RDI" },
- { 8*ORIG_RAX, "8*ORIG_RAX" },
- { 8*RIP, "8*RIP" },
- { 8*CS, "8*CS" },
+ XLAT(8*R15),
+ XLAT(8*R14),
+ XLAT(8*R13),
+ XLAT(8*R12),
+ XLAT(8*RBP),
+ XLAT(8*RBX),
+ XLAT(8*R11),
+ XLAT(8*R10),
+ XLAT(8*R9),
+ XLAT(8*R8),
+ XLAT(8*RAX),
+ XLAT(8*RCX),
+ XLAT(8*RDX),
+ XLAT(8*RSI),
+ XLAT(8*RDI),
+ XLAT(8*ORIG_RAX),
+ XLAT(8*RIP),
+ XLAT(8*CS),
{ 8*EFLAGS, "8*EFL" },
- { 8*RSP, "8*RSP" },
- { 8*SS, "8*SS" },
+ XLAT(8*RSP),
+ XLAT(8*SS),
#elif defined(M68K)
- { 4*PT_D1, "4*PT_D1" },
- { 4*PT_D2, "4*PT_D2" },
- { 4*PT_D3, "4*PT_D3" },
- { 4*PT_D4, "4*PT_D4" },
- { 4*PT_D5, "4*PT_D5" },
- { 4*PT_D6, "4*PT_D6" },
- { 4*PT_D7, "4*PT_D7" },
- { 4*PT_A0, "4*PT_A0" },
- { 4*PT_A1, "4*PT_A1" },
- { 4*PT_A2, "4*PT_A2" },
- { 4*PT_A3, "4*PT_A3" },
- { 4*PT_A4, "4*PT_A4" },
- { 4*PT_A5, "4*PT_A5" },
- { 4*PT_A6, "4*PT_A6" },
- { 4*PT_D0, "4*PT_D0" },
- { 4*PT_USP, "4*PT_USP" },
- { 4*PT_ORIG_D0, "4*PT_ORIG_D0" },
- { 4*PT_SR, "4*PT_SR" },
- { 4*PT_PC, "4*PT_PC" },
+ XLAT(4*PT_D1),
+ XLAT(4*PT_D2),
+ XLAT(4*PT_D3),
+ XLAT(4*PT_D4),
+ XLAT(4*PT_D5),
+ XLAT(4*PT_D6),
+ XLAT(4*PT_D7),
+ XLAT(4*PT_A0),
+ XLAT(4*PT_A1),
+ XLAT(4*PT_A2),
+ XLAT(4*PT_A3),
+ XLAT(4*PT_A4),
+ XLAT(4*PT_A5),
+ XLAT(4*PT_A6),
+ XLAT(4*PT_D0),
+ XLAT(4*PT_USP),
+ XLAT(4*PT_ORIG_D0),
+ XLAT(4*PT_SR),
+ XLAT(4*PT_PC),
#elif defined(SH)
- { 4*REG_REG0, "4*REG_REG0" },
+ XLAT(4*REG_REG0),
{ 4*(REG_REG0+1), "4*REG_REG1" },
{ 4*(REG_REG0+2), "4*REG_REG2" },
{ 4*(REG_REG0+3), "4*REG_REG3" },
{ 4*(REG_REG0+12), "4*REG_REG12" },
{ 4*(REG_REG0+13), "4*REG_REG13" },
{ 4*(REG_REG0+14), "4*REG_REG14" },
- { 4*REG_REG15, "4*REG_REG15" },
- { 4*REG_PC, "4*REG_PC" },
- { 4*REG_PR, "4*REG_PR" },
- { 4*REG_SR, "4*REG_SR" },
- { 4*REG_GBR, "4*REG_GBR" },
- { 4*REG_MACH, "4*REG_MACH" },
- { 4*REG_MACL, "4*REG_MACL" },
- { 4*REG_SYSCALL, "4*REG_SYSCALL" },
- { 4*REG_FPUL, "4*REG_FPUL" },
- { 4*REG_FPREG0, "4*REG_FPREG0" },
+ XLAT(4*REG_REG15),
+ XLAT(4*REG_PC),
+ XLAT(4*REG_PR),
+ XLAT(4*REG_SR),
+ XLAT(4*REG_GBR),
+ XLAT(4*REG_MACH),
+ XLAT(4*REG_MACL),
+ XLAT(4*REG_SYSCALL),
+ XLAT(4*REG_FPUL),
+ XLAT(4*REG_FPREG0),
{ 4*(REG_FPREG0+1), "4*REG_FPREG1" },
{ 4*(REG_FPREG0+2), "4*REG_FPREG2" },
{ 4*(REG_FPREG0+3), "4*REG_FPREG3" },
{ 4*(REG_FPREG0+12), "4*REG_FPREG12" },
{ 4*(REG_FPREG0+13), "4*REG_FPREG13" },
{ 4*(REG_FPREG0+14), "4*REG_FPREG14" },
- { 4*REG_FPREG15, "4*REG_FPREG15" },
+ XLAT(4*REG_FPREG15),
# ifdef REG_XDREG0
- { 4*REG_XDREG0, "4*REG_XDREG0" },
+ XLAT(4*REG_XDREG0),
{ 4*(REG_XDREG0+2), "4*REG_XDREG2" },
{ 4*(REG_XDREG0+4), "4*REG_XDREG4" },
{ 4*(REG_XDREG0+6), "4*REG_XDREG6" },
{ 4*(REG_XDREG0+8), "4*REG_XDREG8" },
{ 4*(REG_XDREG0+10), "4*REG_XDREG10" },
{ 4*(REG_XDREG0+12), "4*REG_XDREG12" },
- { 4*REG_XDREG14, "4*REG_XDREG14" },
+ XLAT(4*REG_XDREG14),
# endif
- { 4*REG_FPSCR, "4*REG_FPSCR" },
+ XLAT(4*REG_FPSCR),
#elif defined(SH64)
{ 0, "PC(L)" },
{ 4, "PC(U)" },
{ PTREGS_OFFSET_FLAGS, "flags" },
#endif
#ifdef CRISV10
- { 4*PT_FRAMETYPE, "4*PT_FRAMETYPE" },
- { 4*PT_ORIG_R10, "4*PT_ORIG_R10" },
- { 4*PT_R13, "4*PT_R13" },
- { 4*PT_R12, "4*PT_R12" },
- { 4*PT_R11, "4*PT_R11" },
- { 4*PT_R10, "4*PT_R10" },
- { 4*PT_R9, "4*PT_R9" },
- { 4*PT_R8, "4*PT_R8" },
- { 4*PT_R7, "4*PT_R7" },
- { 4*PT_R6, "4*PT_R6" },
- { 4*PT_R5, "4*PT_R5" },
- { 4*PT_R4, "4*PT_R4" },
- { 4*PT_R3, "4*PT_R3" },
- { 4*PT_R2, "4*PT_R2" },
- { 4*PT_R1, "4*PT_R1" },
- { 4*PT_R0, "4*PT_R0" },
- { 4*PT_MOF, "4*PT_MOF" },
- { 4*PT_DCCR, "4*PT_DCCR" },
- { 4*PT_SRP, "4*PT_SRP" },
- { 4*PT_IRP, "4*PT_IRP" },
- { 4*PT_CSRINSTR, "4*PT_CSRINSTR" },
- { 4*PT_CSRADDR, "4*PT_CSRADDR" },
- { 4*PT_CSRDATA, "4*PT_CSRDATA" },
- { 4*PT_USP, "4*PT_USP" },
+ XLAT(4*PT_FRAMETYPE),
+ XLAT(4*PT_ORIG_R10),
+ XLAT(4*PT_R13),
+ XLAT(4*PT_R12),
+ XLAT(4*PT_R11),
+ XLAT(4*PT_R10),
+ XLAT(4*PT_R9),
+ XLAT(4*PT_R8),
+ XLAT(4*PT_R7),
+ XLAT(4*PT_R6),
+ XLAT(4*PT_R5),
+ XLAT(4*PT_R4),
+ XLAT(4*PT_R3),
+ XLAT(4*PT_R2),
+ XLAT(4*PT_R1),
+ XLAT(4*PT_R0),
+ XLAT(4*PT_MOF),
+ XLAT(4*PT_DCCR),
+ XLAT(4*PT_SRP),
+ XLAT(4*PT_IRP),
+ XLAT(4*PT_CSRINSTR),
+ XLAT(4*PT_CSRADDR),
+ XLAT(4*PT_CSRDATA),
+ XLAT(4*PT_USP),
#endif
#ifdef CRISV32
- { 4*PT_ORIG_R10, "4*PT_ORIG_R10" },
- { 4*PT_R0, "4*PT_R0" },
- { 4*PT_R1, "4*PT_R1" },
- { 4*PT_R2, "4*PT_R2" },
- { 4*PT_R3, "4*PT_R3" },
- { 4*PT_R4, "4*PT_R4" },
- { 4*PT_R5, "4*PT_R5" },
- { 4*PT_R6, "4*PT_R6" },
- { 4*PT_R7, "4*PT_R7" },
- { 4*PT_R8, "4*PT_R8" },
- { 4*PT_R9, "4*PT_R9" },
- { 4*PT_R10, "4*PT_R10" },
- { 4*PT_R11, "4*PT_R11" },
- { 4*PT_R12, "4*PT_R12" },
- { 4*PT_R13, "4*PT_R13" },
- { 4*PT_ACR, "4*PT_ACR" },
- { 4*PT_SRS, "4*PT_SRS" },
- { 4*PT_MOF, "4*PT_MOF" },
- { 4*PT_SPC, "4*PT_SPC" },
- { 4*PT_CCS, "4*PT_CCS" },
- { 4*PT_SRP, "4*PT_SRP" },
- { 4*PT_ERP, "4*PT_ERP" },
- { 4*PT_EXS, "4*PT_EXS" },
- { 4*PT_EDA, "4*PT_EDA" },
- { 4*PT_USP, "4*PT_USP" },
- { 4*PT_PPC, "4*PT_PPC" },
- { 4*PT_BP_CTRL, "4*PT_BP_CTRL" },
- { 4*PT_BP+4, "4*PT_BP+4" },
- { 4*PT_BP+8, "4*PT_BP+8" },
- { 4*PT_BP+12, "4*PT_BP+12" },
- { 4*PT_BP+16, "4*PT_BP+16" },
- { 4*PT_BP+20, "4*PT_BP+20" },
- { 4*PT_BP+24, "4*PT_BP+24" },
- { 4*PT_BP+28, "4*PT_BP+28" },
- { 4*PT_BP+32, "4*PT_BP+32" },
- { 4*PT_BP+36, "4*PT_BP+36" },
- { 4*PT_BP+40, "4*PT_BP+40" },
- { 4*PT_BP+44, "4*PT_BP+44" },
- { 4*PT_BP+48, "4*PT_BP+48" },
- { 4*PT_BP+52, "4*PT_BP+52" },
- { 4*PT_BP+56, "4*PT_BP+56" },
+ XLAT(4*PT_ORIG_R10),
+ XLAT(4*PT_R0),
+ XLAT(4*PT_R1),
+ XLAT(4*PT_R2),
+ XLAT(4*PT_R3),
+ XLAT(4*PT_R4),
+ XLAT(4*PT_R5),
+ XLAT(4*PT_R6),
+ XLAT(4*PT_R7),
+ XLAT(4*PT_R8),
+ XLAT(4*PT_R9),
+ XLAT(4*PT_R10),
+ XLAT(4*PT_R11),
+ XLAT(4*PT_R12),
+ XLAT(4*PT_R13),
+ XLAT(4*PT_ACR),
+ XLAT(4*PT_SRS),
+ XLAT(4*PT_MOF),
+ XLAT(4*PT_SPC),
+ XLAT(4*PT_CCS),
+ XLAT(4*PT_SRP),
+ XLAT(4*PT_ERP),
+ XLAT(4*PT_EXS),
+ XLAT(4*PT_EDA),
+ XLAT(4*PT_USP),
+ XLAT(4*PT_PPC),
+ XLAT(4*PT_BP_CTRL),
+ XLAT(4*PT_BP+4),
+ XLAT(4*PT_BP+8),
+ XLAT(4*PT_BP+12),
+ XLAT(4*PT_BP+16),
+ XLAT(4*PT_BP+20),
+ XLAT(4*PT_BP+24),
+ XLAT(4*PT_BP+28),
+ XLAT(4*PT_BP+32),
+ XLAT(4*PT_BP+36),
+ XLAT(4*PT_BP+40),
+ XLAT(4*PT_BP+44),
+ XLAT(4*PT_BP+48),
+ XLAT(4*PT_BP+52),
+ XLAT(4*PT_BP+56),
#endif
#ifdef MICROBLAZE
{ PT_GPR(0), "r0" },
# define FUTEX_CLOCK_REALTIME 256
#endif
static const struct xlat futexops[] = {
- { FUTEX_WAIT, "FUTEX_WAIT" },
- { FUTEX_WAKE, "FUTEX_WAKE" },
- { FUTEX_FD, "FUTEX_FD" },
- { FUTEX_REQUEUE, "FUTEX_REQUEUE" },
- { FUTEX_CMP_REQUEUE, "FUTEX_CMP_REQUEUE" },
- { FUTEX_WAKE_OP, "FUTEX_WAKE_OP" },
- { FUTEX_LOCK_PI, "FUTEX_LOCK_PI" },
- { FUTEX_UNLOCK_PI, "FUTEX_UNLOCK_PI" },
- { FUTEX_TRYLOCK_PI, "FUTEX_TRYLOCK_PI" },
- { FUTEX_WAIT_BITSET, "FUTEX_WAIT_BITSET" },
- { FUTEX_WAKE_BITSET, "FUTEX_WAKE_BITSET" },
- { FUTEX_WAIT_REQUEUE_PI, "FUTEX_WAIT_REQUEUE_PI" },
- { FUTEX_CMP_REQUEUE_PI, "FUTEX_CMP_REQUEUE_PI" },
+ XLAT(FUTEX_WAIT),
+ XLAT(FUTEX_WAKE),
+ XLAT(FUTEX_FD),
+ XLAT(FUTEX_REQUEUE),
+ XLAT(FUTEX_CMP_REQUEUE),
+ XLAT(FUTEX_WAKE_OP),
+ XLAT(FUTEX_LOCK_PI),
+ XLAT(FUTEX_UNLOCK_PI),
+ XLAT(FUTEX_TRYLOCK_PI),
+ XLAT(FUTEX_WAIT_BITSET),
+ XLAT(FUTEX_WAKE_BITSET),
+ XLAT(FUTEX_WAIT_REQUEUE_PI),
+ XLAT(FUTEX_CMP_REQUEUE_PI),
{ FUTEX_WAIT|FUTEX_PRIVATE_FLAG, "FUTEX_WAIT_PRIVATE" },
{ FUTEX_WAKE|FUTEX_PRIVATE_FLAG, "FUTEX_WAKE_PRIVATE" },
{ FUTEX_FD|FUTEX_PRIVATE_FLAG, "FUTEX_FD_PRIVATE" },
{ FUTEX_WAKE_BITSET|FUTEX_PRIVATE_FLAG, "FUTEX_WAKE_BITSET_PRIVATE" },
{ FUTEX_WAIT_REQUEUE_PI|FUTEX_PRIVATE_FLAG, "FUTEX_WAIT_REQUEUE_PI_PRIVATE" },
{ FUTEX_CMP_REQUEUE_PI|FUTEX_PRIVATE_FLAG, "FUTEX_CMP_REQUEUE_PI_PRIVATE" },
- { FUTEX_WAIT_BITSET|FUTEX_CLOCK_REALTIME, "FUTEX_WAIT_BITSET|FUTEX_CLOCK_REALTIME" },
+ XLAT(FUTEX_WAIT_BITSET|FUTEX_CLOCK_REALTIME),
{ FUTEX_WAIT_BITSET|FUTEX_PRIVATE_FLAG|FUTEX_CLOCK_REALTIME, "FUTEX_WAIT_BITSET_PRIVATE|FUTEX_CLOCK_REALTIME" },
- { FUTEX_WAIT_REQUEUE_PI|FUTEX_CLOCK_REALTIME, "FUTEX_WAIT_REQUEUE_PI|FUTEX_CLOCK_REALTIME" },
+ XLAT(FUTEX_WAIT_REQUEUE_PI|FUTEX_CLOCK_REALTIME),
{ FUTEX_WAIT_REQUEUE_PI|FUTEX_PRIVATE_FLAG|FUTEX_CLOCK_REALTIME, "FUTEX_WAIT_REQUEUE_PI_PRIVATE|FUTEX_CLOCK_REALTIME" },
{ 0, NULL }
};
# define FUTEX_OP_CMP_GE 5
#endif
static const struct xlat futexwakeops[] = {
- { FUTEX_OP_SET, "FUTEX_OP_SET" },
- { FUTEX_OP_ADD, "FUTEX_OP_ADD" },
- { FUTEX_OP_OR, "FUTEX_OP_OR" },
- { FUTEX_OP_ANDN, "FUTEX_OP_ANDN" },
- { FUTEX_OP_XOR, "FUTEX_OP_XOR" },
+ XLAT(FUTEX_OP_SET),
+ XLAT(FUTEX_OP_ADD),
+ XLAT(FUTEX_OP_OR),
+ XLAT(FUTEX_OP_ANDN),
+ XLAT(FUTEX_OP_XOR),
{ 0, NULL }
};
static const struct xlat futexwakecmps[] = {
- { FUTEX_OP_CMP_EQ, "FUTEX_OP_CMP_EQ" },
- { FUTEX_OP_CMP_NE, "FUTEX_OP_CMP_NE" },
- { FUTEX_OP_CMP_LT, "FUTEX_OP_CMP_LT" },
- { FUTEX_OP_CMP_LE, "FUTEX_OP_CMP_LE" },
- { FUTEX_OP_CMP_GT, "FUTEX_OP_CMP_GT" },
- { FUTEX_OP_CMP_GE, "FUTEX_OP_CMP_GE" },
+ XLAT(FUTEX_OP_CMP_EQ),
+ XLAT(FUTEX_OP_CMP_NE),
+ XLAT(FUTEX_OP_CMP_LT),
+ XLAT(FUTEX_OP_CMP_LE),
+ XLAT(FUTEX_OP_CMP_GT),
+ XLAT(FUTEX_OP_CMP_GE),
{ 0, NULL }
};
}
static const struct xlat schedulers[] = {
- { SCHED_OTHER, "SCHED_OTHER" },
- { SCHED_RR, "SCHED_RR" },
- { SCHED_FIFO, "SCHED_FIFO" },
+ XLAT(SCHED_OTHER),
+ XLAT(SCHED_RR),
+ XLAT(SCHED_FIFO),
{ 0, NULL }
};
# include <asm/prctl.h>
static const struct xlat archvals[] = {
- { ARCH_SET_GS, "ARCH_SET_GS" },
- { ARCH_SET_FS, "ARCH_SET_FS" },
- { ARCH_GET_FS, "ARCH_GET_FS" },
- { ARCH_GET_GS, "ARCH_GET_GS" },
+ XLAT(ARCH_SET_GS),
+ XLAT(ARCH_SET_FS),
+ XLAT(ARCH_GET_FS),
+ XLAT(ARCH_GET_GS),
{ 0, NULL },
};
#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 }
};
#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"},
-
- {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"},
-
- {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"},
-
- {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_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),
+
+ 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),
+
+ XLAT(Q_SYNC),
+ XLAT(Q_QUOTAON),
+ XLAT(Q_QUOTAOFF),
+ XLAT(Q_GETFMT),
+ XLAT(Q_GETINFO),
+ XLAT(Q_SETINFO),
+ XLAT(Q_GETQUOTA),
+ XLAT(Q_SETQUOTA),
+
+ XLAT(Q_XQUOTAON),
+ XLAT(Q_XQUOTAOFF),
+ XLAT(Q_XGETQUOTA),
+ XLAT(Q_XSETQLIM),
+ XLAT(Q_XGETQSTAT),
+ XLAT(Q_XQUOTARM),
+ XLAT(Q_XQUOTASYNC),
{0, NULL},
};
#define GRPQUOTA 1
static const struct xlat quotatypes[] = {
- {USRQUOTA, "USRQUOTA"},
- {GRPQUOTA, "GRPQUOTA"},
+ XLAT(USRQUOTA),
+ XLAT(GRPQUOTA),
{0, NULL},
};
#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},
};
#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}
};
#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}
};
#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}
};
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 }
};
}
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 },
};
}
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 },
};
#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}
};
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 },
};
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 },
};
#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 },
};
#endif
static const struct xlat sigaltstack_flags[] = {
- { SS_ONSTACK, "SS_ONSTACK" },
- { SS_DISABLE, "SS_DISABLE" },
+ XLAT(SS_ONSTACK),
+ XLAT(SS_DISABLE),
{ 0, NULL },
};
#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 }
};
# endif
static const struct xlat msgflags[] = {
- { RS_HIPRI, "RS_HIPRI" },
+ XLAT(RS_HIPRI),
{ 0, NULL },
};
# 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 },
};
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 },
};
#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 },
};
#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 },
};
};
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 }
};
#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 },
};
#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 },
};
#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 },
};
#include <asm/cachectl.h>
static const struct xlat cacheflush_flags[] = {
- { ICACHE, "ICACHE" },
- { DCACHE, "DCACHE" },
- { BCACHE, "BCACHE" },
+ XLAT(ICACHE),
+ XLAT(DCACHE),
+ XLAT(BCACHE),
{ 0, NULL },
};
#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 },
};
#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 }
};
# 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 }
};
#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 }
};
#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, },
};
}
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 },
};
#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 }
};
}
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
#endif
static const struct xlat timerfdflags[] = {
- { TFD_TIMER_ABSTIME, "TFD_TIMER_ABSTIME" },
+ XLAT(TFD_TIMER_ABSTIME),
{ 0, NULL }
};
projects / strace / commitdiff