/* Basic syscall test, see memcheck/tests/x86-linux/scalar.c for more info. */
#include "scalar.h"
#include "config.h"
#include <bsm/audit.h>
#include <nfs/nfs.h>
#include <nfs/nfssys.h>
#include <sys/acl.h>
#include <sys/door.h>
#include <sys/fcntl.h>
#include <sys/fstyp.h>
#include <sys/lgrp_user.h>
#if defined(HAVE_SYS_LGRP_USER_IMPL_H)
#include <sys/lgrp_user_impl.h>
#endif /* HAVE_SYS_LGRP_USER_IMPL_H */
#include <sys/mman.h>
#include <sys/modctl.h>
#include <sys/mount.h>
#include <sys/port_impl.h>
#include <sys/priocntl.h>
#include <sys/priv.h>
#include <sys/sem_impl.h>
#include <sys/sendfile.h>
#include <sys/shm_impl.h>
#include <sys/termios.h>
#include <sys/ucontext.h>
#include <sys/utsname.h>
#include <sys/tsol/tndb.h>
#include <sys/tsol/tsyscall.h>
/* Helper functions. These are necessary if we've got two tests for a single
syscall. In that case, Memcheck can sometimes merge error messages. Doing
each test in its own function prevents that. */
__attribute__((noinline))
static void sys_mount(void)
{
GO(SYS_mount, "(4-arg, table variant) 4s 2m");
SY(SYS_mount, x0 + 1, x0, x0, x0); FAIL;
}
__attribute__((noinline))
static void sys_mount2(void)
{
GO(SYS_mount, "(4-arg) 4s 3m");
SY(SYS_mount, x0 + 1, x0, x0, x0 + 256); FAIL;
}
__attribute__((noinline))
static void sys_mount3(void)
{
GO(SYS_mount, "(6-arg) 6s 4m");
SY(SYS_mount, x0 + 1, x0, x0 | MS_DATA, x0 + 256, x0 + 1, x0 + 1); FAIL;
}
__attribute__((noinline))
static void sys_mount4(void)
{
GO(SYS_mount, "(8-arg) 8s 5m");
SY(SYS_mount, x0 + 1, x0, x0 | MS_OPTIONSTR, x0 + 256, x0 + 1, x0 + 1,
x0 + 1, x0 + 1); FAIL;
}
__attribute__((noinline))
static void sys_pgrpsys(void)
{
GO(SYS_pgrpsys, "(GETPGRP) 1s 0m");
SY(SYS_pgrpsys, x0); SUCC;
}
__attribute__((noinline))
static void sys_pgrpsys2(void)
{
GO(SYS_pgrpsys, "(GETSID) 2s 0m");
SY(SYS_pgrpsys, x0 + 2, x0); SUCC;
}
__attribute__((noinline))
static void sys_pgrpsys3(void)
{
GO(SYS_pgrpsys, "(GETPGID) 2s 0m");
SY(SYS_pgrpsys, x0 + 4, x0); SUCC;
}
__attribute__((noinline))
static void sys_shmsys(void)
{
GO(SYS_shmsys, "(SHMAT) 4s 0m");
SY(SYS_shmsys, x0 + SHMAT, x0, x0 - 1, x0); FAIL;
}
__attribute__((noinline))
static void sys_shmsys2(void)
{
GO(SYS_shmsys, "(SHMCTL,SHM_LOCK) 3s 0m");
SY(SYS_shmsys, x0 + SHMCTL, x0, x0 + SHM_LOCK); FAIL;
}
__attribute__((noinline))
static void sys_shmsys3(void)
{
GO(SYS_shmsys, "(SHMCTL,SHM_UNLOCK) 3s 0m");
SY(SYS_shmsys, x0 + SHMCTL, x0, x0 + SHM_UNLOCK); FAIL;
}
__attribute__((noinline))
static void sys_shmsys4(void)
{
GO(SYS_shmsys, "(SHMCTL,IPC_RMID) 3s 0m");
SY(SYS_shmsys, x0 + SHMCTL, x0, x0 + IPC_RMID); FAIL;
}
__attribute__((noinline))
static void sys_shmsys5(void)
{
GO(SYS_shmsys, "(SHMCTL,IPC_SET) 4s 3m");
SY(SYS_shmsys, x0 + SHMCTL, x0, x0 + IPC_SET, x0 + 1); FAIL;
}
__attribute__((noinline))
static void sys_shmsys6(void)
{
struct shmid_ds buf;
buf.shm_perm.uid = x0 + 1;
buf.shm_perm.gid = x0 + 1;
buf.shm_perm.mode = x0 + 1;
GO(SYS_shmsys, "(SHMCTL,IPC_SET) 6s 0m");
SY(SYS_shmsys, x0 + SHMCTL, x0, x0 + IPC_SET, &buf); FAIL;
}
__attribute__((noinline))
static void sys_shmsys7(void)
{
GO(SYS_shmsys, "(SHMCTL,IPC_STAT) 4s 1m");
SY(SYS_shmsys, x0 + SHMCTL, x0, x0 + IPC_STAT, x0 + 1); FAIL;
}
__attribute__((noinline))
static void sys_shmsys8(void)
{
GO(SYS_shmsys, "(SHMCTL,IPC_SET64) 4s 3m");
SY(SYS_shmsys, x0 + SHMCTL, x0, x0 + IPC_SET64, x0 + 1); FAIL;
}
__attribute__((noinline))
static void sys_shmsys9(void)
{
struct shmid_ds64 buf;
buf.shmx_perm.ipcx_uid = x0 + 1;
buf.shmx_perm.ipcx_gid = x0 + 1;
buf.shmx_perm.ipcx_mode = x0 + 1;
GO(SYS_shmsys, "(SHMCTL,IPC_SET64) 6s 0m");
SY(SYS_shmsys, x0 + SHMCTL, x0, x0 + IPC_SET64, &buf); FAIL;
}
__attribute__((noinline))
static void sys_shmsys10(void)
{
GO(SYS_shmsys, "(SHMCTL,IPC_STAT64) 4s 1m");
SY(SYS_shmsys, x0 + SHMCTL, x0, x0 + IPC_STAT64, x0 + 1); FAIL;
}
__attribute__((noinline))
static void sys_shmsys11(void)
{
GO(SYS_shmsys, "(SHMDT) 2s 0m");
SY(SYS_shmsys, x0 + SHMDT, x0 - 1); FAIL;
}
__attribute__((noinline))
static void sys_shmsys12(void)
{
GO(SYS_shmsys, "(SHMGET) 4s 0m");
SY(SYS_shmsys, x0 + SHMGET, x0, x0, x0); FAIL;
}
__attribute__((noinline))
static void sys_shmsys13(void)
{
GO(SYS_shmsys, "(SHMIDS) 4s 2m");
SY(SYS_shmsys, x0 + SHMIDS, x0 + 1, x0 + 1, x0 + 1); FAIL;
}
__attribute__((noinline))
static void sys_semsys(void)
{
GO(SYS_semsys, "(SEMCTL,IPC_STAT) 5s 1m");
SY(SYS_semsys, x0 + SEMCTL, x0, x0, x0 + IPC_STAT, x0 + 1); FAIL;
}
__attribute__((noinline))
static void sys_semsys2(void)
{
GO(SYS_semsys, "(SEMCTL,IPC_SET) 5s 1m");
SY(SYS_semsys, x0 + SEMCTL, x0, x0, x0 + IPC_SET, x0 + 1); FAIL;
}
__attribute__((noinline))
static void sys_semsys3(void)
{
GO(SYS_semsys, "(SEMCTL,IPC_STAT64) 5s 1m");
SY(SYS_semsys, x0 + SEMCTL, x0, x0, x0 + IPC_STAT64, x0 + 1); FAIL;
}
__attribute__((noinline))
static void sys_semsys4(void)
{
GO(SYS_semsys, "(SEMCTL,IPC_SET64) 5s 1m");
SY(SYS_semsys, x0 + SEMCTL, x0, x0, x0 + IPC_SET64, x0 + 1); FAIL;
}
__attribute__((noinline))
static void sys_semsys5(void)
{
GO(SYS_semsys, "(SEMCTL,IPC_RMID) 3s 0m");
SY(SYS_semsys, x0 + SEMCTL, x0, x0, x0 + IPC_RMID); FAIL;
}
__attribute__((noinline))
static void sys_semsys6(void)
{
GO(SYS_semsys, "(SEMCTL,GETALL) 4s 0m");
SY(SYS_semsys, x0 + SEMCTL, x0, x0, x0 + GETALL, x0 + 1); FAIL;
}
__attribute__((noinline))
static void sys_semsys7(void)
{
GO(SYS_semsys, "(SEMCTL,SETALL) 4s 0m");
SY(SYS_semsys, x0 + SEMCTL, x0, x0, x0 + SETALL, x0 + 1); FAIL;
}
__attribute__((noinline))
static void sys_semsys8(void)
{
GO(SYS_semsys, "(SEMCTL,GETVAL) 4s 0m");
SY(SYS_semsys, x0 + SEMCTL, x0, x0, x0 + GETVAL); FAIL;
}
__attribute__((noinline))
static void sys_semsys9(void)
{
GO(SYS_semsys, "(SEMCTL,SETVAL) 5s 0m");
SY(SYS_semsys, x0 + SEMCTL, x0, x0, x0 + SETVAL, x0 + 2); FAIL;
}
__attribute__((noinline))
static void sys_semsys10(void)
{
GO(SYS_semsys, "(SEMCTL,GETPID) 4s 0m");
SY(SYS_semsys, x0 + SEMCTL, x0, x0, x0 + GETPID); FAIL;
}
__attribute__((noinline))
static void sys_semsys11(void)
{
GO(SYS_semsys, "(SEMCTL,GETNCNT) 4s 0m");
SY(SYS_semsys, x0 + SEMCTL, x0, x0, x0 + GETNCNT); FAIL;
}
__attribute__((noinline))
static void sys_semsys12(void)
{
GO(SYS_semsys, "(SEMCTL,GETZCNT) 4s 0m");
SY(SYS_semsys, x0 + SEMCTL, x0, x0, x0 + GETZCNT); FAIL;
}
__attribute__((noinline))
static void sys_semsys13(void)
{
GO(SYS_semsys, "(SEMGET) 4s 0m");
SY(SYS_semsys, x0 + SEMGET, x0, x0, x0); FAIL;
}
__attribute__((noinline))
static void sys_semsys14(void)
{
GO(SYS_semsys, "(SEMOP) 4s 1m");
SY(SYS_semsys, x0 + SEMOP, x0, x0 + 1, x0 + 1); FAIL;
}
__attribute__((noinline))
static void sys_semsys15(void)
{
GO(SYS_semsys, "(SEMIDS) 4s 2m");
SY(SYS_semsys, x0 + SEMIDS, x0 + 1, x0 + 1, x0 + 1); FAIL;
}
__attribute__((noinline))
static void sys_semsys16(void)
{
GO(SYS_semsys, "(SEMTIMEDOP) 5s 2m");
SY(SYS_semsys, x0 + SEMTIMEDOP, x0, x0 + 1, x0 + 1, x0 + 1); FAIL;
}
__attribute__((noinline))
static void sys_fcntl(void)
{
GO(SYS_fcntl, "(GETFD) 2s 0m");
SY(SYS_fcntl, x0 - 1, x0 + F_GETFD); FAILx(EBADF);
}
__attribute__((noinline))
static void sys_fcntl2(void)
{
GO(SYS_fcntl, "(DUPFD) 3s 0m");
SY(SYS_fcntl, x0 - 1, x0 + F_DUPFD, x0); FAILx(EBADF);
}
__attribute__((noinline))
static void sys_fcntl3(void)
{
GO(SYS_fcntl, "(DUPFD_CLOEXEC) 3s 0m");
SY(SYS_fcntl, x0 - 1, x0 + F_DUPFD_CLOEXEC, x0); FAILx(EBADF);
}
__attribute__((noinline))
static void sys_fcntl4(void)
{
GO(SYS_fcntl, "(GETLK) 3s 5m");
SY(SYS_fcntl, x0 - 1, x0 + F_GETLK, x0); FAILx(EBADF);
}
__attribute__((noinline))
static void sys_openat(void)
{
GO(SYS_openat, "(3-args) 3s 1m");
SY(SYS_openat, x0 - 1, x0, x0); FAIL;
}
__attribute__((noinline))
static void sys_openat2(void)
{
GO(SYS_openat, "(4-args) 4s 1m");
SY(SYS_openat, x0 - 1, x0, x0 | O_CREAT, x0); FAIL;
}
__attribute__((noinline))
static void sys_tasksys(void)
{
GO(SYS_tasksys, "(settaskid) 3s 0m");
SY(SYS_tasksys, x0 + 0, x0, x0); FAIL;
}
__attribute__((noinline))
static void sys_tasksys2(void)
{
GO(SYS_tasksys, "(gettaskid) 1s 0m");
SY(SYS_tasksys, x0 + 1); SUCC;
}
__attribute__((noinline))
static void sys_tasksys3(void)
{
GO(SYS_tasksys, "(getprojid) 1s 0m");
SY(SYS_tasksys, x0 + 2); SUCC;
}
__attribute__((noinline))
static void sys_tasksys4(void)
{
GO(SYS_tasksys, "(projlist) 3s 1m");
/* ARG2 and ARG3 are ignored */
SY(SYS_tasksys, x0 + 3, x0, x0, x0 + 1, x0 + 2); FAIL;
}
__attribute__((noinline))
static void sys_sendfilev(void)
{
GO(SYS_sendfilev, "(SENDFILEV) 5s 2m");
SY(SYS_sendfilev, x0 + SENDFILEV, x0 - 1, x0 + 1, x0 + 2, x0 + 1); FAIL;
}
__attribute__((noinline))
static void sys_sendfilev2(void)
{
struct sendfilevec vec[2];
vec[0].sfv_fd = SFV_FD_SELF;
vec[0].sfv_off = (off_t)(x0 + 1);
vec[0].sfv_len = x0 + 1;
vec[0].sfv_flag = 0; // should be set to zero according to man page
vec[1].sfv_fd = x0 - 1;
vec[1].sfv_off = x0;
vec[1].sfv_len = x0 + 1;
vec[1].sfv_flag = 0; // should be set to zero according to man page
GO(SYS_sendfilev, "(SENDFILEV) 4s 2m");
SY(SYS_sendfilev, x0 + SENDFILEV, x0 - 1, vec, 2, x0 + 1); FAIL;
}
__attribute__((noinline))
static void sys_sendfilev3(void)
{
GO(SYS_sendfilev, "(SENDFILEV64) 5s 2m");
SY(SYS_sendfilev, x0 + SENDFILEV64, x0 - 1, x0 + 1, x0 + 2, x0 + 1); FAIL;
}
__attribute__((noinline))
static void sys_sendfilev4(void)
{
struct sendfilevec64 vec[2];
vec[0].sfv_fd = SFV_FD_SELF;
vec[0].sfv_off = (off_t)(x0 + 1);
vec[0].sfv_len = x0 + 1;
vec[0].sfv_flag = 0; // should be set to zero according to man page
vec[1].sfv_fd = x0 - 1;
vec[1].sfv_off = x0;
vec[1].sfv_len = x0 + 1;
vec[1].sfv_flag = 0; // should be set to zero according to man page
GO(SYS_sendfilev, "(SENDFILEV64) 4s 2m");
SY(SYS_sendfilev, x0 + SENDFILEV64, x0 - 1, vec, 2, x0 + 1); FAIL;
}
__attribute__((noinline))
static void sys_privsys(void)
{
GO(SYS_privsys, "(PRIVSYS_SETPPRIV) 5s 1m");
SY(SYS_privsys, x0 + PRIVSYS_SETPPRIV, x0, x0, x0, x0 + 1); FAIL;
}
__attribute__((noinline))
static void sys_privsys2(void)
{
GO(SYS_privsys, "(PRIVSYS_GETPPRIV) 5s 1m");
SY(SYS_privsys, x0 + PRIVSYS_GETPPRIV, x0, x0, x0, x0 + 1); FAIL;
}
__attribute__((noinline))
static void sys_privsys3(void)
{
GO(SYS_privsys, "(PRIVSYS_GETIMPLINFO) 5s 1m");
SY(SYS_privsys, x0 + PRIVSYS_GETIMPLINFO, x0, x0, x0, x0 + 1); FAIL;
}
__attribute__((noinline))
static void sys_privsys4(void)
{
GO(SYS_privsys, "(PRIVSYS_SETPFLAGS) 3s 0m");
SY(SYS_privsys, x0 + PRIVSYS_SETPFLAGS, x0, x0 + 2); FAIL;
}
__attribute__((noinline))
static void sys_privsys5(void)
{
GO(SYS_privsys, "(PRIVSYS_GETPFLAGS) 2s 0m");
SY(SYS_privsys, x0 + PRIVSYS_GETPFLAGS, x0); FAIL;
}
__attribute__((noinline))
static void sys_privsys6(void)
{
GO(SYS_privsys, "(PRIVSYS_ISSETUGID) 1s 0m");
SY(SYS_privsys, x0 + PRIVSYS_ISSETUGID); SUCC;
}
__attribute__((noinline))
static void sys_privsys7(void)
{
GO(SYS_privsys, "(PRIVSYS_PFEXEC_REG) 2s 0m");
SY(SYS_privsys, x0 + PRIVSYS_PFEXEC_REG, x0 - 1); FAILx(EBADF);
}
__attribute__((noinline))
static void sys_privsys8(void)
{
GO(SYS_privsys, "(PRIVSYS_PFEXEC_UNREG) 2s 0m");
SY(SYS_privsys, x0 + PRIVSYS_PFEXEC_UNREG, x0 - 1); FAILx(EBADF);
}
__attribute__((noinline))
static void sys_ucredsys(void)
{
GO(SYS_ucredsys, "(UCREDSYS_UCREDGET) 3s 1m");
SY(SYS_ucredsys, x0 + 0, x0, x0 + 1); FAIL;
}
__attribute__((noinline))
static void sys_ucredsys2(void)
{
GO(SYS_ucredsys, "(UCREDSYS_GETPEERUCRED) 3s 1m");
SY(SYS_ucredsys, x0 + 1, x0 - 1, x0 + 1); FAILx(EBADF);
}
__attribute__((noinline))
static void sys_sysfs(void)
{
GO(SYS_sysfs, "(GETFSIND) 2s 1m");
SY(SYS_sysfs, x0 + GETFSIND, x0 + 1); FAIL;
}
__attribute__((noinline))
static void sys_sysfs2(void)
{
GO(SYS_sysfs, "(GETFSTYP) 3s 1m");
SY(SYS_sysfs, x0 + GETFSTYP, x0, x0 + 1); FAIL;
}
__attribute__((noinline))
static void sys_sysfs3(void)
{
GO(SYS_sysfs, "(GETNFSTYP) 1s 0m");
SY(SYS_sysfs, x0 + GETNFSTYP); SUCC;
}
__attribute__((noinline))
static void sys_context(void)
{
GO(SYS_context, "(GETCONTEXT) 2s 1m");
SY(SYS_context, x0 + GETCONTEXT, x0); FAILx(EFAULT);
}
__attribute__((noinline))
static void sys_context2(void)
{
/* The setcontext() wrapper has to call ML_(safe_to_deref) before doing the
PRE_READ_*() stuff, therefore the 0m parameter. */
GO(SYS_context, "(SETCONTEXT) 2s 0m");
SY(SYS_context, x0 + SETCONTEXT, x0 + 1); FAILx(EFAULT);
}
__attribute__((noinline))
static void sys_context3(void)
{
GO(SYS_context, "(GETUSTACK) 2s 1m");
SY(SYS_context, x0 + GETUSTACK, x0); FAILx(EFAULT);
}
__attribute__((noinline))
static void sys_context4(void)
{
GO(SYS_context, "(SETUSTACK) 2s 1m");
SY(SYS_context, x0 + SETUSTACK, x0); FAILx(EFAULT);
}
__attribute__((noinline))
static void sys_statvfs(void)
{
GO(SYS_statvfs, "2s 2m");
SY(SYS_statvfs, x0 + 1, x0 + 1); FAIL;
}
__attribute__((noinline))
static int sys_statvfs2(void)
{
const char path[] = "/";
struct statvfs stats;
GO(SYS_statvfs, "4s 0m");
SY(SYS_statvfs, x0 + path, x0 + &stats); SUCC;
size_t basetype_len = strlen(stats.f_basetype);
size_t fstr_len = strlen(stats.f_fstr);
/* Now check that memory after the strings is reported uninitialized. */
int x = 0;
if (stats.f_basetype[basetype_len + 2] != ' ') x = -1; else x = -2;
if (stats.f_fstr[fstr_len + 2] != ' ') x = -3; else x = -4;
return x;
}
__attribute__((noinline))
static void sys_nfssys(void)
{
GO(SYS_nfssys, "(NFS_REVAUTH) 2s 1m");
SY(SYS_nfssys, x0 + NFS_REVAUTH, x0); FAIL;
}
__attribute__((noinline))
static void sys_priocntlsys(void)
{
pcinfo_t pcinfo;
pcinfo.pc_clname[0] = x0 + 'T';
pcinfo.pc_clname[1] = x0 + 'S';
pcinfo.pc_clname[2] = x0;
GO(SYS_priocntlsys, "(GETCID) 6s 0m");
SY(SYS_priocntlsys, x0 + 1, x0, x0 + PC_GETCID, x0 + &pcinfo, x0); SUCC;
}
__attribute__((noinline))
static void sys_priocntlsys2(void)
{
pcinfo_t pcinfo;
pcinfo.pc_cid = x0 + 1;
GO(SYS_priocntlsys, "(GETCLINFO) 6s 0m");
SY(SYS_priocntlsys, x0 + 1, x0, x0 + PC_GETCLINFO, x0 + &pcinfo, x0); SUCC;
}
__attribute__((noinline))
static void sys_priocntlsys3(void)
{
GO(SYS_priocntlsys, "(SETPARMS) 5s 2m");
SY(SYS_priocntlsys, x0 + 1, x0, x0 + PC_SETPARMS, x0, x0); FAIL;
}
__attribute__((noinline))
static void sys_priocntlsys4(void)
{
GO(SYS_priocntlsys, "(GETPARMS) 5s 2m");
SY(SYS_priocntlsys, x0 + 1, x0, x0 + PC_GETPARMS, x0, x0); FAIL;
}
__attribute__((noinline))
static void sys_priocntlsys5(void)
{
GO(SYS_priocntlsys, "(GETPRIRANGE) 5s 2m");
SY(SYS_priocntlsys, x0 + 1, x0, x0 + PC_GETPRIRANGE, x0, x0); FAIL;
}
__attribute__((noinline))
static void sys_priocntlsys6(void)
{
GO(SYS_priocntlsys, "(DONICE) 5s 2m");
SY(SYS_priocntlsys, x0 + 1, x0, x0 + PC_DONICE, x0, x0); FAIL;
}
__attribute__((noinline))
static void sys_priocntlsys7(void)
{
GO(SYS_priocntlsys, "(SETXPARMS) 5s 3m");
SY(SYS_priocntlsys, x0 + 1, x0, x0 + PC_SETXPARMS, x0, x0 + 1); FAIL;
}
__attribute__((noinline))
static void sys_priocntlsys8(void)
{
GO(SYS_priocntlsys, "(GETXPARMS) 5s 3m");
SY(SYS_priocntlsys, x0 + 1, x0, x0 + PC_GETXPARMS, x0 + 1, x0 + 1); FAIL;
}
__attribute__((noinline))
static void sys_priocntlsys9(void)
{
GO(SYS_priocntlsys, "(SETDFLCL) 5s 1m");
SY(SYS_priocntlsys, x0 + 1, x0, x0 + PC_SETDFLCL, x0, x0); FAIL;
}
__attribute__((noinline))
static void sys_priocntlsys10(void)
{
GO(SYS_priocntlsys, "(GETDFLCL) 5s 1m");
SY(SYS_priocntlsys, x0 + 1, x0, x0 + PC_GETDFLCL, x0 + 1, x0); FAIL;
}
__attribute__((noinline))
static void sys_priocntlsys11(void)
{
GO(SYS_priocntlsys, "(DOPRIO) 5s 2m");
SY(SYS_priocntlsys, x0 + 1, x0, x0 + PC_DOPRIO, x0, x0); FAIL;
}
__attribute__((noinline))
static void sys_uname(void)
{
GO(SYS_uname, "1s 1m");
SY(SYS_uname, x0 + 1); FAIL;
}
__attribute__((noinline))
static int sys_uname2(void)
{
struct utsname name;
GO(SYS_uname, "6s 0m");
SY(SYS_uname, x0 + &name); SUCC;
size_t sysname_len = strlen(name.sysname);
size_t nodename_len = strlen(name.nodename);
size_t release_len = strlen(name.release);
size_t version_len = strlen(name.version);
size_t machine_len = strlen(name.machine);
/* Now check that memory after the strings is reported uninitialized. */
int x = 0;
if (name.sysname[sysname_len + 2] != ' ') x = -1; else x = -2;
if (name.nodename[nodename_len + 2] != ' ') x = -3; else x = -4;
if (name.release[release_len + 2] != ' ') x = -5; else x = -6;
if (name.version[version_len + 2] != ' ') x = -7; else x = -8;
if (name.machine[machine_len + 2] != ' ') x = -9; else x = -10;
return x;
}
__attribute__((noinline))
static void sys_modctl(void)
{
GO(SYS_modctl, "(MODLOAD) 4s 1m");
SY(SYS_modctl, x0 + MODLOAD, x0 + 1, x0 - 1, x0 - 1); FAIL;
}
__attribute__((noinline))
static void sys_modctl2(void)
{
GO(SYS_modctl, "(MODUNLOAD) 2s 0m");
SY(SYS_modctl, x0 + MODUNLOAD, x0 + 1); FAIL;
}
__attribute__((noinline))
static void sys_modctl3(void)
{
GO(SYS_modctl, "(MODINFO) 3s 4m");
SY(SYS_modctl, x0 + MODINFO, x0 + 1, x0 - 1); FAIL;
}
__attribute__((noinline))
static void sys_lgrpsys(void)
{
GO(SYS_lgrpsys, "(LGRP_SYS_MEMINFO) 3s 1m");
SY(SYS_lgrpsys, x0 + LGRP_SYS_MEMINFO, x0 + 0, x0 + 1); FAIL;
}
__attribute__((noinline))
static void sys_lgrpsys2(void)
{
GO(SYS_lgrpsys, "(LGRP_SYS_MEMINFO) 3s 1m");
SY(SYS_lgrpsys, x0 + LGRP_SYS_MEMINFO, x0 + 1, x0 + 1); FAIL;
}
__attribute__((noinline))
static void sys_lgrpsys3(void)
{
meminfo_t minfo;
minfo.mi_inaddr = (void *)(x0 + 1);
minfo.mi_info_req = (void *)(x0 + 1);
minfo.mi_info_count = x0 + 1;
minfo.mi_outdata = (void *)(x0 + 1);
minfo.mi_validity = (void *)(x0 + 1);
GO(SYS_lgrpsys, "(LGRP_SYS_MEMINFO) 4s 4m");
SY(SYS_lgrpsys, x0 + LGRP_SYS_MEMINFO, x0 + 1, x0 + &minfo); FAIL;
}
__attribute__((noinline))
static void sys_lgrpsys4(void)
{
GO(SYS_lgrpsys, "(LGRP_SYS_GENERATION) 2s 0m");
SY(SYS_lgrpsys, x0 + LGRP_SYS_GENERATION, x0 + 0); SUCC;
}
__attribute__((noinline))
static void sys_lgrpsys5(void)
{
GO(SYS_lgrpsys, "(LGRP_SYS_VERSION) 2s 0m");
SY(SYS_lgrpsys, x0 + LGRP_SYS_VERSION, x0 + 0); SUCC;
}
__attribute__((noinline))
static void sys_lgrpsys6(void)
{
GO(SYS_lgrpsys, "(LGRP_SYS_SNAPSHOT) 3s 1m");
SY(SYS_lgrpsys, x0 + LGRP_SYS_SNAPSHOT, x0 + 10, x0 + 1); FAIL;
}
__attribute__((noinline))
static void sys_rusagesys(void)
{
GO(SYS_rusagesys, "(_RUSAGESYS_GETRUSAGE) 2s 1m");
SY(SYS_rusagesys, x0 + _RUSAGESYS_GETRUSAGE, x0 + 1); FAIL;
}
__attribute__((noinline))
static void sys_rusagesys2(void)
{
GO(SYS_rusagesys, "(_RUSAGESYS_GETRUSAGE_CHLD) 2s 1m");
SY(SYS_rusagesys, x0 + _RUSAGESYS_GETRUSAGE_CHLD, x0 + 1); FAIL;
}
__attribute__((noinline))
static void sys_rusagesys3(void)
{
GO(SYS_rusagesys, "(_RUSAGESYS_GETRUSAGE_LWP) 2s 1m");
SY(SYS_rusagesys, x0 + _RUSAGESYS_GETRUSAGE_LWP, x0 + 1); FAIL;
}
__attribute__((noinline))
static void sys_rusagesys4(void)
{
GO(SYS_rusagesys, "(_RUSAGESYS_GETVMUSAGE) 5s 1m");
SY(SYS_rusagesys, x0 + _RUSAGESYS_GETVMUSAGE, x0, x0, x0 + 1, x0 + 1);
FAIL;
}
__attribute__((noinline))
static void sys_rusagesys5(void)
{
size_t nres = 10;
GO(SYS_rusagesys, "(_RUSAGESYS_GETVMUSAGE) 5s 1m");
SY(SYS_rusagesys, x0 + _RUSAGESYS_GETVMUSAGE, x0, x0, x0 + 1, x0 + &nres);
FAIL;
}
__attribute__((noinline))
static void sys_port(void)
{
GO(SYS_port, "(PORT_CREATE) 1s 0m");
SY(SYS_port, (x0 + PORT_CREATE) | PORT_SYS_NOPORT); SUCC;
}
__attribute__((noinline))
static void sys_port2(void)
{
GO(SYS_port, "(PORT_ASSOCIATE,PORT_SOURCE_FD) 6s 0m");
SY(SYS_port, x0 + PORT_ASSOCIATE, x0 - 1, x0 + PORT_SOURCE_FD, x0, x0,
x0); FAILx(EBADF);
}
__attribute__((noinline))
static void sys_port3(void)
{
GO(SYS_port, "(PORT_ASSOCIATE,PORT_SOURCE_FILE) 6s 1m");
SY(SYS_port, x0 + PORT_ASSOCIATE, x0 - 1, x0 + PORT_SOURCE_FILE, x0, x0,
x0); FAILx(EBADF);
}
__attribute__((noinline))
static void sys_port4(void)
{
GO(SYS_port, "(PORT_DISSOCIATE,PORT_SOURCE_FD) 6s 0m");
SY(SYS_port, x0 + PORT_DISSOCIATE, x0 - 1, x0 + PORT_SOURCE_FD, x0, x0,
x0); FAILx(EBADF);
}
__attribute__((noinline))
static void sys_port5(void)
{
GO(SYS_port, "(PORT_DISSOCIATE,PORT_SOURCE_FILE) 6s 1m");
SY(SYS_port, x0 + PORT_DISSOCIATE, x0 - 1, x0 + PORT_SOURCE_FILE, x0, x0,
x0); FAILx(EBADF);
}
__attribute__((noinline))
static void sys_port6(void)
{
GO(SYS_port, "(PORT_SEND) 4s 0m");
SY(SYS_port, x0 + PORT_SEND, x0 - 1, x0, x0); FAILx(EBADF);
}
__attribute__((noinline))
static void sys_port7(void)
{
GO(SYS_port, "(PORT_SENDN) 6s 2m");
SY(SYS_port, (x0 + PORT_SENDN) | PORT_SYS_NOPORT, x0, x0, x0 + 1, x0,
x0); FAIL;
}
__attribute__((noinline))
static void sys_port8(void)
{
GO(SYS_port, "(PORT_GET) 6s 1m");
SY(SYS_port, x0 + PORT_GET, x0 - 1, x0, x0, x0, x0); FAILx(EBADF);
}
__attribute__((noinline))
static void sys_port9(void)
{
GO(SYS_port, "(PORT_GETN) 5s 2m");
SY(SYS_port, x0 + PORT_GETN, x0 - 1, x0, x0 + 1, x0, x0 + 1); FAILx(EBADF);
}
__attribute__((noinline))
static void sys_port10(void)
{
GO(SYS_port, "(PORT_ALERT) 5s 0m");
SY(SYS_port, x0 + PORT_ALERT, x0 - 1, x0, x0, x0); FAILx(EBADF);
}
__attribute__((noinline))
static void sys_port11(void)
{
GO(SYS_port, "(PORT_DISPATCH) 6s 0m");
SY(SYS_port, x0 + PORT_DISPATCH, x0 - 1, x0, x0, x0, x0); FAILx(EBADF);
}
__attribute__((noinline))
static void sys_labelsys(void)
{
GO(SYS_labelsys, "(TSOL_SYSLABELING) 1s 0m");
SY(SYS_labelsys, x0 + TSOL_SYSLABELING); SUCC;
}
__attribute__((noinline))
static void sys_labelsys2(void)
{
GO(SYS_labelsys, "(TSOL_TNRH) 3s 1m");
SY(SYS_labelsys, x0 + TSOL_TNRH, x0 + TNDB_GET, x0 + 1); FAIL;
}
__attribute__((noinline))
static void sys_labelsys3(void)
{
GO(SYS_labelsys, "(TSOL_TNRHTP) 3s 1m");
SY(SYS_labelsys, x0 + TSOL_TNRHTP, x0 + TNDB_GET, x0 + 1); FAIL;
}
__attribute__((noinline))
static void sys_labelsys4(void)
{
GO(SYS_labelsys, "(TSOL_TNMLP) 3s 1m");
SY(SYS_labelsys, x0 + TSOL_TNMLP, x0 + TNDB_GET, x0 + 1); FAIL;
}
__attribute__((noinline))
static void sys_labelsys5(void)
{
GO(SYS_labelsys, "(TSOL_GETLABEL) 3s 2m");
SY(SYS_labelsys, x0 + TSOL_GETLABEL, x0 + 1, x0 + 1); FAIL;
}
__attribute__((noinline))
static void sys_labelsys6(void)
{
GO(SYS_labelsys, "(TSOL_FGETLABEL) 3s 1m");
SY(SYS_labelsys, x0 + TSOL_FGETLABEL, x0 - 1, x0 + 1); FAILx(EBADF);
}
__attribute__((noinline))
static void sys_acl(void)
{
GO(SYS_acl, "(SETACL) 4s 2m");
SY(SYS_acl, x0, x0 + SETACL, x0 + 1, x0 + 1); FAIL;
}
__attribute__((noinline))
static void sys_acl2(void)
{
GO(SYS_acl, "(GETACL) 4s 2m");
SY(SYS_acl, x0, x0 + GETACL, x0 + 1, x0); FAIL;
}
__attribute__((noinline))
static void sys_acl3(void)
{
GO(SYS_acl, "(GETACLCNT) 4s 1m");
SY(SYS_acl, x0, x0 + GETACLCNT, x0, x0); FAIL;
}
__attribute__((noinline))
static void sys_acl4(void)
{
GO(SYS_acl, "(ACE_SETACL) 4s 2m");
SY(SYS_acl, x0, x0 + ACE_SETACL, x0 + 1, x0 + 1); FAIL;
}
__attribute__((noinline))
static void sys_acl5(void)
{
GO(SYS_acl, "(ACE_GETACL) 4s 2m");
SY(SYS_acl, x0, x0 + ACE_GETACL, x0 + 1, x0); FAIL;
}
__attribute__((noinline))
static void sys_acl6(void)
{
GO(SYS_acl, "(ACE_GETACLCNT) 4s 1m");
SY(SYS_acl, x0, x0 + ACE_GETACLCNT, x0, x0); FAIL;
}
__attribute__((noinline))
static void sys_auditsys(void)
{
GO(SYS_auditsys, "(BSM_GETAUID) 2s 1m");
SY(SYS_auditsys, x0 + BSM_GETAUID, x0); FAIL;
}
__attribute__((noinline))
static void sys_auditsys2(void)
{
GO(SYS_auditsys, "(BSM_SETAUID) 2s 1m");
SY(SYS_auditsys, x0 + BSM_SETAUID, x0); FAIL;
}
__attribute__((noinline))
static void sys_auditsys3(void)
{
GO(SYS_auditsys, "(BSM_GETAUDIT) 2s 1m");
SY(SYS_auditsys, x0 + BSM_GETAUDIT, x0); FAIL;
}
__attribute__((noinline))
static void sys_auditsys4(void)
{
GO(SYS_auditsys, "(BSM_SETAUDIT) 2s 1m");
SY(SYS_auditsys, x0 + BSM_SETAUDIT, x0); FAIL;
}
__attribute__((noinline))
static void sys_auditsys5(void)
{
GO(SYS_auditsys, "(BSM_AUDIT) 3s 1m");
/* The following syscall can succeed if auditing is not enabled. */
SY(SYS_auditsys, x0 + BSM_AUDIT, x0, x0 + 1); /*FAIL;*/
}
__attribute__((noinline))
static void sys_auditsys6(void)
{
GO(SYS_auditsys, "(BSM_AUDITCTL,A_GETPOLICY) 3s 1m");
SY(SYS_auditsys, x0 + BSM_AUDITCTL, x0 + A_GETPOLICY, x0); FAIL;
}
__attribute__((noinline))
static void sys_auditsys7(void)
{
GO(SYS_auditsys, "(BSM_AUDITCTL,A_SETPOLICY) 3s 1m");
SY(SYS_auditsys, x0 + BSM_AUDITCTL, x0 + A_SETPOLICY, x0); FAIL;
}
__attribute__((noinline))
static void sys_auditsys8(void)
{
GO(SYS_auditsys, "(BSM_AUDITCTL,A_GETKMASK) 3s 1m");
SY(SYS_auditsys, x0 + BSM_AUDITCTL, x0 + A_GETKMASK, x0); FAIL;
}
__attribute__((noinline))
static void sys_auditsys9(void)
{
GO(SYS_auditsys, "(BSM_AUDITCTL,A_SETKMASK) 3s 1m");
SY(SYS_auditsys, x0 + BSM_AUDITCTL, x0 + A_SETKMASK, x0); FAIL;
}
__attribute__((noinline))
static void sys_auditsys10(void)
{
GO(SYS_auditsys, "(BSM_AUDITCTL,A_GETQCTRL) 3s 1m");
SY(SYS_auditsys, x0 + BSM_AUDITCTL, x0 + A_GETQCTRL, x0); FAIL;
}
__attribute__((noinline))
static void sys_auditsys11(void)
{
GO(SYS_auditsys, "(BSM_AUDITCTL,A_SETQCTRL) 3s 1m");
SY(SYS_auditsys, x0 + BSM_AUDITCTL, x0 + A_SETQCTRL, x0 + 1); FAIL;
}
__attribute__((noinline))
static void sys_auditsys12(void)
{
GO(SYS_auditsys, "(BSM_AUDITCTL,A_GETCWD) 4s 1m");
SY(SYS_auditsys, x0 + BSM_AUDITCTL, x0 + A_GETCWD, x0, x0 + 1); FAIL;
}
__attribute__((noinline))
static void sys_auditsys13(void)
{
GO(SYS_auditsys, "(BSM_AUDITCTL,A_GETCAR) 4s 1m");
SY(SYS_auditsys, x0 + BSM_AUDITCTL, x0 + A_GETCAR, x0, x0 + 1); FAIL;
}
__attribute__((noinline))
static void sys_auditsys14(void)
{
GO(SYS_auditsys, "(BSM_AUDITCTL,A_SETUMASK) 3s 1m");
SY(SYS_auditsys, x0 + BSM_AUDITCTL, x0 + A_SETUMASK, x0); FAIL;
}
__attribute__((noinline))
static void sys_auditsys15(void)
{
GO(SYS_auditsys, "(BSM_AUDITCTL,A_SETSMASK) 3s 1m");
SY(SYS_auditsys, x0 + BSM_AUDITCTL, x0 + A_SETSMASK, x0); FAIL;
}
__attribute__((noinline))
static void sys_auditsys16(void)
{
GO(SYS_auditsys, "(BSM_AUDITCTL,A_GETCOND) 3s 1m");
SY(SYS_auditsys, x0 + BSM_AUDITCTL, x0 + A_GETCOND, x0); FAIL;
}
__attribute__((noinline))
static void sys_auditsys17(void)
{
GO(SYS_auditsys, "(BSM_AUDITCTL,A_SETCOND) 3s 1m");
SY(SYS_auditsys, x0 + BSM_AUDITCTL, x0 + A_SETCOND, x0); FAIL;
}
__attribute__((noinline))
static void sys_auditsys18(void)
{
GO(SYS_auditsys, "(BSM_AUDITCTL,A_GETCLASS) 3s 0m");
SY(SYS_auditsys, x0 + BSM_AUDITCTL, x0 + A_GETCLASS, x0); FAIL;
}
__attribute__((noinline))
static void sys_auditsys19(void)
{
GO(SYS_auditsys, "(BSM_AUDITCTL,A_SETCLASS) 3s 0m");
SY(SYS_auditsys, x0 + BSM_AUDITCTL, x0 + A_SETCLASS, x0 + 1); FAIL;
}
__attribute__((noinline))
static void sys_auditsys20(void)
{
au_evclass_map_t classmap;
classmap.ec_number = x0;
classmap.ec_class = x0;
GO(SYS_auditsys, "(BSM_AUDITCTL,A_SETCLASS) 4s 0m");
SY(SYS_auditsys, x0 + BSM_AUDITCTL, x0 + A_SETCLASS, &classmap); FAIL;
}
__attribute__((noinline))
static void sys_auditsys21(void)
{
GO(SYS_auditsys, "(BSM_AUDITCTL,A_GETPINFO) 3s 0m");
SY(SYS_auditsys, x0 + BSM_AUDITCTL, x0 + A_GETPINFO, x0); FAIL;
}
__attribute__((noinline))
static void sys_auditsys22(void)
{
GO(SYS_auditsys, "(BSM_AUDITCTL,A_SETPMASK) 3s 1m");
SY(SYS_auditsys, x0 + BSM_AUDITCTL, x0 + A_SETPMASK, x0); FAIL;
}
__attribute__((noinline))
static void sys_auditsys23(void)
{
GO(SYS_auditsys, "(BSM_AUDITCTL,A_GETPINFO_ADDR) 4s 0m");
SY(SYS_auditsys, x0 + BSM_AUDITCTL, x0 + A_GETPINFO_ADDR, x0,
x0 + 1); FAIL;
}
__attribute__((noinline))
static void sys_auditsys24(void)
{
GO(SYS_auditsys, "(BSM_AUDITCTL,A_GETKAUDIT) 4s 1m");
SY(SYS_auditsys, x0 + BSM_AUDITCTL, x0 + A_GETKAUDIT, x0, x0 + 1); FAIL;
}
__attribute__((noinline))
static void sys_auditsys25(void)
{
GO(SYS_auditsys, "(BSM_AUDITCTL,A_SETKAUDIT) 4s 1m");
SY(SYS_auditsys, x0 + BSM_AUDITCTL, x0 + A_SETKAUDIT, x0, x0 + 1); FAIL;
}
__attribute__((noinline))
static void sys_auditsys26(void)
{
GO(SYS_auditsys, "(BSM_AUDITCTL,A_GETAMASK) 3s 1m");
SY(SYS_auditsys, x0 + BSM_AUDITCTL, x0 + A_GETAMASK, x0); FAIL;
}
__attribute__((noinline))
static void sys_auditsys27(void)
{
GO(SYS_auditsys, "(BSM_AUDITCTL,A_SETAMASK) 3s 1m");
SY(SYS_auditsys, x0 + BSM_AUDITCTL, x0 + A_SETAMASK, x0); FAIL;
}
__attribute__((noinline))
static void sys_auditsys28(void)
{
GO(SYS_auditsys, "(BSM_GETAUDIT_ADDR) 3s 1m");
SY(SYS_auditsys, x0 + BSM_GETAUDIT_ADDR, x0 + 1, x0 + 1); FAIL;
}
__attribute__((noinline))
static void sys_auditsys29(void)
{
GO(SYS_auditsys, "(BSM_SETAUDIT_ADDR) 3s 1m");
SY(SYS_auditsys, x0 + BSM_SETAUDIT_ADDR, x0, x0 + 1); FAIL;
}
__attribute__((noinline))
static void sys_auditsys30(void)
{
GO(SYS_auditsys, "(BSM_AUDITDOOR) 2s 0m");
SY(SYS_auditsys, x0 + BSM_AUDITDOOR, x0); FAIL;
}
__attribute__((noinline))
static void sys_timer_create(void)
{
GO(SYS_timer_create, "3s 4m");
SY(SYS_timer_create, x0, x0 + 1, x0 + 1); FAIL;
}
__attribute__((noinline))
static void sys_timer_create2(void)
{
struct sigevent evp;
evp.sigev_notify = x0 + SIGEV_THREAD;
evp.sigev_value.sival_ptr = (void *)(x0 + 1);
GO(SYS_timer_create, "5s 2m");
SY(SYS_timer_create, x0, &evp, x0 + 1); FAIL;
}
__attribute__((noinline))
static void sys_facl(void)
{
GO(SYS_facl, "(SETACL) 4s 1m");
SY(SYS_facl, x0 - 1, x0 + SETACL, x0 + 1, x0 + 1); FAILx(EBADF);
}
__attribute__((noinline))
static void sys_facl2(void)
{
GO(SYS_facl, "(GETACL) 4s 1m");
SY(SYS_facl, x0 - 1, x0 + GETACL, x0 + 1, x0); FAILx(EBADF);
}
__attribute__((noinline))
static void sys_facl3(void)
{
GO(SYS_facl, "(GETACLCNT) 4s 0m");
SY(SYS_facl, x0 - 1, x0 + GETACLCNT, x0, x0); FAILx(EBADF);
}
__attribute__((noinline))
static void sys_facl4(void)
{
GO(SYS_facl, "(ACE_SETACL) 4s 1m");
SY(SYS_facl, x0 - 1, x0 + ACE_SETACL, x0 + 1, x0 + 1); FAILx(EBADF);
}
__attribute__((noinline))
static void sys_facl5(void)
{
GO(SYS_facl, "(ACE_GETACL) 4s 1m");
SY(SYS_facl, x0 - 1, x0 + ACE_GETACL, x0 + 1, x0); FAILx(EBADF);
}
__attribute__((noinline))
static void sys_facl6(void)
{
GO(SYS_facl, "(ACE_GETACLCNT) 4s 0m");
SY(SYS_facl, x0 - 1, x0 + ACE_GETACLCNT, x0, x0); FAILx(EBADF);
}
__attribute__((noinline))
static void sys_door(void)
{
GO(SYS_door, "(DOOR_CREATE) 4s 0m");
SY(SYS_door, x0, x0, x0, x0, x0, x0 + DOOR_CREATE); SUCC;
}
__attribute__((noinline))
static void sys_door2(void)
{
GO(SYS_door, "(DOOR_REVOKE) 2s 0m");
SY(SYS_door, x0, x0, x0, x0, x0, x0 + DOOR_REVOKE); FAIL;
}
__attribute__((noinline))
static void sys_door3(void)
{
GO(SYS_door, "(DOOR_INFO) 3s 1m");
SY(SYS_door, x0, x0 - 1, x0, x0, x0, x0 + DOOR_INFO); FAIL;
}
__attribute__((noinline))
static void sys_door4(void)
{
GO(SYS_door, "(DOOR_CALL) 3s 6m");
SY(SYS_door, x0 - 1, x0, x0, x0, x0, x0 + DOOR_CALL); FAILx(EBADF);
}
__attribute__((noinline))
static void sys_door5(void)
{
door_arg_t params;
params.data_ptr = (void *)(x0 + 1);
params.data_size = x0 + 1;
params.desc_ptr = (void *)(x0 + 1);
params.desc_num = x0 + 1;
params.rbuf = (void *)(x0 + 1);
params.rsize = x0 + 1;
GO(SYS_door, "(DOOR_CALL) 9s 2m");
SY(SYS_door, x0, x0 + ¶ms, x0, x0, x0, x0 + DOOR_CALL); FAIL;
}
__attribute__((noinline))
static void sys_door6(void)
{
GO(SYS_door, "(DOOR_SETPARAM) 4s 0m");
SY(SYS_door, x0, x0 - 1, x0 + 1, x0, x0, x0 + DOOR_SETPARAM); FAIL;
}
__attribute__((noinline))
static void sys_pset(void)
{
GO(SYS_pset, "(CREATE) 2s 1m");
SY(SYS_pset, x0 + PSET_CREATE, x0 + 1); FAIL;
}
__attribute__((noinline))
static void sys_pset2(void)
{
GO(SYS_pset, "(DESTROY) 2s 0m");
SY(SYS_pset, x0 + PSET_DESTROY, x0); FAIL;
}
__attribute__((noinline))
static void sys_pset3(void)
{
GO(SYS_pset, "(ASSIGN) 4s 1m");
SY(SYS_pset, x0 + PSET_ASSIGN, x0 + 1, x0 + 1, x0 + 1); FAIL;
}
__attribute__((noinline))
static void sys_pset4(void)
{
GO(SYS_pset, "(INFO) 5s 3m");
SY(SYS_pset, x0 + PSET_INFO, x0 + 1, x0 + 1, x0 + 1, x0 + 1); FAIL;
}
__attribute__((noinline))
static void sys_pset5(void)
{
int type;
uint_t numcpus = x0 + 1;
GO(SYS_pset, "(INFO) 5s 1m");
SY(SYS_pset, x0 + PSET_INFO, x0 + 1, x0 + &type, x0 + &numcpus,
x0 + 1); FAIL;
}
__attribute__((noinline))
static void sys_pset6(void)
{
GO(SYS_pset, "(BIND) 5s 1m");
SY(SYS_pset, x0 + PSET_BIND, x0 + 1, x0 + 1, x0 + 1, x0 + 1); FAIL;
}
__attribute__((noinline))
static void sys_pset7(void)
{
GO(SYS_pset, "(BIND_LWP) 5s 1m");
SY(SYS_pset, x0 + PSET_BIND_LWP, x0 + 1, x0 + 1, x0 + 1, x0 + 1); FAIL;
}
__attribute__((noinline))
static void sys_pset8(void)
{
GO(SYS_pset, "(GETLOADAVG) 4s 1m");
SY(SYS_pset, x0 + PSET_GETLOADAVG, x0 + 1, x0 + 1, x0 + 1); FAIL;
}
__attribute__((noinline))
static void sys_pset9(void)
{
GO(SYS_pset, "(LIST) 3s 1m");
SY(SYS_pset, x0 + PSET_LIST, x0 + 1, x0 + 1); FAIL;
}
__attribute__((noinline))
static void sys_pset10(void)
{
uint_t numpsets = x0 + 1;
GO(SYS_pset, "(LIST) 3s 1m");
SY(SYS_pset, x0 + PSET_LIST, x0 + 1, x0 + &numpsets);
}
__attribute__((noinline))
static void sys_pset11(void)
{
GO(SYS_pset, "(SETATTR) 3s 0m");
SY(SYS_pset, x0 + PSET_SETATTR, x0, x0); FAIL;
}
__attribute__((noinline))
static void sys_pset12(void)
{
GO(SYS_pset, "(GETATTR) 3s 1m");
SY(SYS_pset, x0 + PSET_GETATTR, x0, x0 + 1); FAIL;
}
__attribute__((noinline))
static void sys_pset13(void)
{
GO(SYS_pset, "(ASSIGN_FORCED) 4s 1m");
SY(SYS_pset, x0 + PSET_ASSIGN_FORCED, x0 + 1, x0 + 1, x0 + 1); FAIL;
}
__attribute__((noinline))
static void sys_lwp_rwlock(void)
{
GO(SYS_lwp_rwlock_sys, "(RDLOCK) 3s 8m");
SY(SYS_lwp_rwlock_sys, x0, x0, x0 + 1); FAIL;
}
__attribute__((noinline))
static void sys_lwp_rwlock2(void)
{
GO(SYS_lwp_rwlock_sys, "(WRLOCK) 3s 8m");
SY(SYS_lwp_rwlock_sys, x0 + 1, x0, x0 + 1); FAIL;
}
__attribute__((noinline))
static void sys_lwp_rwlock3(void)
{
GO(SYS_lwp_rwlock_sys, "(TRYRDLOCK) 2s 7m");
SY(SYS_lwp_rwlock_sys, x0 + 2, x0); FAIL;
}
__attribute__((noinline))
static void sys_lwp_rwlock4(void)
{
GO(SYS_lwp_rwlock_sys, "(TRYWRLOCK) 2s 7m");
SY(SYS_lwp_rwlock_sys, x0 + 3, x0); FAIL;
}
__attribute__((noinline))
static void sys_lwp_rwlock5(void)
{
GO(SYS_lwp_rwlock_sys, "(UNLOCK) 2s 2m");
SY(SYS_lwp_rwlock_sys, x0 + 4, x0); FAIL;
}
__attribute__((noinline))
static void sys_zone(void)
{
GO(SYS_zone, "(ZONE_CREATE) 2s 12m");
SY(SYS_zone, x0 + ZONE_CREATE, x0); FAIL;
}
__attribute__((noinline))
static void sys_zone2(void)
{
zone_def zd;
zd.zone_name = (void *)(x0 + 1);
zd.zone_root = (void *)(x0 + 1);
zd.zone_privs = (void *)x0;
zd.zone_privssz = x0 + 1;
zd.rctlbuf = (void *)x0;
zd.rctlbufsz = x0 + 1;
zd.extended_error = (void *)x0;
zd.zfsbuf = (void *)x0;
zd.zfsbufsz = x0 + 1;
zd.match = x0;
zd.doi = x0;
zd.label = (void *)(x0 + 1);
zd.flags = x0;
GO(SYS_zone, "(create) 2s 19m");
SY(SYS_zone, x0 + ZONE_CREATE, x0 + &zd); FAIL;
}
__attribute__((noinline))
static void sys_zone3(void)
{
GO(SYS_zone, "(ZONE_DESTROY) 2s 0m");
SY(SYS_zone, x0 + ZONE_DESTROY, x0); FAIL;
}
__attribute__((noinline))
static void sys_zone4(void)
{
GO(SYS_zone, "(ZONE_GETATTR) 5s 1m");
SY(SYS_zone, x0 + ZONE_GETATTR, x0, x0, x0, x0 + 1); FAIL;
}
__attribute__((noinline))
static void sys_zone5(void)
{
GO(SYS_zone, "(ZONE_ENTER) 2s 0m");
SY(SYS_zone, x0 + ZONE_ENTER, x0); FAIL;
}
__attribute__((noinline))
static void sys_zone6(void)
{
GO(SYS_zone, "(ZONE_LIST) 3s 1m");
SY(SYS_zone, x0 + ZONE_LIST, x0 + 1, x0 + 1); FAIL;
}
__attribute__((noinline))
static void sys_zone7(void)
{
uint_t numzones = x0 + 1;
GO(SYS_zone, "(ZONE_LIST) 3s 1m");
SY(SYS_zone, x0 + ZONE_LIST, x0 + 1, x0 + &numzones); FAIL;
}
__attribute__((noinline))
static void sys_zone8(void)
{
GO(SYS_zone, "(ZONE_SHUTDOWN) 2s 0m");
SY(SYS_zone, x0 + ZONE_SHUTDOWN, x0); FAIL;
}
__attribute__((noinline))
static void sys_zone9(void)
{
GO(SYS_zone, "(ZONE_LOOKUP) 2s 1m");
SY(SYS_zone, x0 + ZONE_LOOKUP, x0 + 1); FAIL;
}
__attribute__((noinline))
static void sys_zone10(void)
{
GO(SYS_zone, "(ZONE_BOOT) 2s 0m");
SY(SYS_zone, x0 + ZONE_BOOT, x0); FAIL;
}
__attribute__((noinline))
static void sys_zone11(void)
{
GO(SYS_zone, "(ZONE_SETATTR) 5s 1m");
SY(SYS_zone, x0 + ZONE_SETATTR, x0, x0, x0, x0 + 1); FAIL;
}
__attribute__((noinline))
static void sys_zone12(void)
{
GO(SYS_zone, "(ZONE_ADD_DATALINK) 3s 0m");
SY(SYS_zone, x0 + ZONE_ADD_DATALINK, x0, x0); FAIL;
}
__attribute__((noinline))
static void sys_zone13(void)
{
GO(SYS_zone, "(ZONE_DEL_DATALINK) 3s 0m");
SY(SYS_zone, x0 + ZONE_DEL_DATALINK, x0, x0); FAIL;
}
__attribute__((noinline))
static void sys_zone14(void)
{
GO(SYS_zone, "(ZONE_CHECK_DATALINK) 3s 1m");
SY(SYS_zone, x0 + ZONE_CHECK_DATALINK, x0, x0); FAIL;
}
__attribute__((noinline))
static void sys_zone15(void)
{
GO(SYS_zone, "(ZONE_LIST_DATALINK) 4s 1m");
SY(SYS_zone, x0 + ZONE_LIST_DATALINK, x0, x0 + 1, x0 + 1); FAIL;
}
__attribute__((noinline))
static void sys_zone16(void)
{
int dlnum = x0 + 1;
GO(SYS_zone, "(ZONE_LIST_DATALINK) 4s 1m");
SY(SYS_zone, x0 + ZONE_LIST_DATALINK, x0, x0 + &dlnum, x0 + 1); FAIL;
}
__attribute__((noinline))
static void sys_getpeername(void)
{
GO(SYS_getpeername, "4s 1m");
SY(SYS_getpeername, x0 - 1, x0 + 1, x0, x0); FAILx(EBADF);
}
__attribute__((noinline))
static void sys_getpeername2(void)
{
socklen_t size = x0 + 10;
GO(SYS_getpeername, "4s 1m");
SY(SYS_getpeername, x0 - 1, x0 + 1, &size, x0); FAILx(EBADF);
}
int main(void)
{
/* Uninitialised, but we know px[0] is 0x0. */
long *px = malloc(sizeof(long));
x0 = px[0];
/* SYS_syscall 0 */
/* SPARC only. */
/* SYS_exit 1 */
/* Tested below. */
/* SYS_read 3 */
GO(SYS_read, "3s 0m");
SY(SYS_read, x0 - 1, x0, x0 + 1); FAILx(EBADF);
/* Note that above should be preferably "3s 1m" test.. */
/* SYS_write 4 */
GO(SYS_write, "3s 1m");
SY(SYS_write, x0 + 1, x0, x0 + 1); FAIL;
/* SYS_open 5 */
/* Tested in scalar_obsolete.c. */
/* SYS_close 6 */
GO(SYS_close, "1s 0m");
SY(SYS_close, x0 - 1); FAILx(EBADF);
/* SYS_linkat 7 */
GO(SYS_linkat, "5s 2m");
SY(SYS_linkat, x0 - 1, x0 + 1, x0 - 1, x0 + 1, x0); FAIL;
/* SYS_link 9 */
/* Tested in scalar_obsolete.c. */
/* SYS_unlink 10 */
/* Tested in scalar_obsolete.c. */
/* SYS_symlinkat 11 */
GO(SYS_symlinkat, "3s 2m");
SY(SYS_symlinkat, x0 + 1, x0 - 1, x0 + 1); FAIL;
/* SYS_chdir 12 */
GO(SYS_chdir, "1s 1m");
SY(SYS_chdir, x0); FAIL;
/* SYS_time 13 */
GO(SYS_time, "0s 0m");
SY(SYS_time); SUCC;
/* SYS_mknod 14 */
/* Tested in scalar_obsolete.c. */
/* SYS_chmod 15 */
/* Tested in scalar_obsolete.c. */
/* SYS_chown 16 */
/* Tested in scalar_obsolete.c. */
/* SYS_brk 17 */
GO(SYS_brk, "1s 0m");
SY(SYS_brk, x0); SUCC;
/* SYS_stat 18 */
/* Tested in scalar_obsolete.c. */
/* SYS_lseek 19 */
GO(SYS_lseek, "3s 0m");
SY(SYS_lseek, x0 - 1, x0, x0); FAILx(EBADF);
/* SYS_getpid 20 */
GO(SYS_getpid, "0s 0m");
SY(SYS_getpid); SUCC;
/* SYS_mount 21 */
sys_mount();
sys_mount2();
sys_mount3();
sys_mount4();
/* SYS_readlinkat 22 */
GO(SYS_readlinkat, "4s 2m");
SY(SYS_readlinkat, x0 - 1, x0, x0, x0 + 1); FAIL;
/* SYS_setuid 23 */
GO(SYS_setuid, "1s 0m");
SY(SYS_setuid, x0 - 1); FAIL;
/* SYS_getuid 24 */
GO(SYS_getuid, "0s 0m");
SY(SYS_getuid); SUCC;
/* SYS_stime 25 */
GO(SYS_stime, "1s 0m");
SY(SYS_stime, x0); FAIL;
/* SYS_pcsample 26 */
/* XXX Missing wrapper. */
/* SYS_alarm 27 */
GO(SYS_alarm, "1s 0m");
SY(SYS_alarm, x0); SUCC;
/* SYS_fstat 28 */
/* Tested in scalar_obsolete.c. */
/* SYS_pause 29 */
/* Don't bother to test this. */
GO(SYS_pause, "ignore");
/* SYS_stty 31 */
GO(SYS_stty, "2s 1m");
SY(SYS_stty, x0 - 1, x0 + 1); FAIL;
/* SYS_gtty 32 */
GO(SYS_gtty, "2s 1m");
SY(SYS_gtty, x0 - 1, x0 + 1); FAIL;
/* SYS_access 33 */
/* Tested in scalar_obsolete.c. */
/* SYS_nice 34 */
/* XXX Missing wrapper. */
/* SYS_statfs 35 */
/* XXX Missing wrapper. */
/* SYS_sync 36 */
/* XXX Missing wrapper. */
/* SYS_kill 37 */
GO(SYS_kill, "2s 0m");
SY(SYS_kill, x0, x0); SUCC;
/* SYS_fstatfs 38 */
/* XXX Missing wrapper. */
/* SYS_pgrpsys 39 */
sys_pgrpsys();
sys_pgrpsys2();
sys_pgrpsys3();
/* SYS_uucopystr 40 */
/* XXX Missing wrapper. */
/* SYS_pipe 42 */
/* Don't bother to test this. */
GO(SYS_pipe, "ignore");
/* SYS_times 43 */
GO(SYS_times, "1s 1m");
SY(SYS_times, x0 + 1); FAIL;
/* SYS_profil 44 */
/* XXX Missing wrapper. */
/* SYS_faccessat 45 */
GO(SYS_faccessat, "4s 1m");
SY(SYS_faccessat, x0 - 1, x0 + 1, x0, x0); FAIL;
/* SYS_setgid 46 */
GO(SYS_setgid, "1s 0m");
SY(SYS_setgid, x0 - 1); FAIL;
/* SYS_getgid 47 */
GO(SYS_getgid, "0s 0m");
SY(SYS_getgid); SUCC;
/* SYS_mknodat 48 */
GO(SYS_mknodat, "4s 1m");
SY(SYS_mknodat, x0 - 1, x0 + 1, x0, x0); FAIL;
/* SYS_msgsys 49 */
/* XXX Missing wrapper. */
/* SYS_sysi86 50 */
/* TODO Add test. */
GO(SYS_sysi86, "incoming");
/* SYS_acct 51 */
/* XXX Missing wrapper. */
/* SYS_shmsys 52 */
sys_shmsys();
sys_shmsys2();
sys_shmsys3();
sys_shmsys4();
sys_shmsys5();
sys_shmsys6();
sys_shmsys7();
sys_shmsys8();
sys_shmsys9();
sys_shmsys10();
sys_shmsys11();
sys_shmsys12();
sys_shmsys13();
/* SYS_semsys 53 */
sys_semsys();
sys_semsys2();
sys_semsys3();
sys_semsys4();
sys_semsys5();
sys_semsys6();
sys_semsys7();
sys_semsys8();
sys_semsys9();
sys_semsys10();
sys_semsys11();
sys_semsys12();
sys_semsys13();
sys_semsys14();
sys_semsys15();
sys_semsys16();
/* SYS_ioctl 54 */
GO(SYS_ioctl, "3s 1m");
SY(SYS_ioctl, x0, x0 + TCGETS, x0); FAIL;
/* SYS_uadmin 55 */
/* XXX Missing wrapper. */
/* SYS_fchownat 56 */
GO(SYS_fchownat, "5s 1m");
SY(SYS_fchownat, x0 - 1, x0 + 1, x0, x0, x0); FAIL;
/* SYS_utssys 57 */
/* XXX Missing wrapper. */
/* SYS_fdsync 58 */
GO(SYS_fdsync, "2s 0m");
SY(SYS_fdsync, x0 - 1, x0); FAILx(EBADF);
/* SYS_execve 59 */
/* illumos ignores the fourth argument. */
GO(SYS_execve, "3s 1m");
SY(SYS_execve, x0, x0, x0, 0); FAIL;
/* More cases tested in execx.c */
/* SYS_umask 60 */
GO(SYS_umask, "1s 0m");
SY(SYS_umask, x0 + 022); SUCC;
/* SYS_chroot 61 */
GO(SYS_chroot, "1s 1m");
SY(SYS_chroot, x0 + 1); FAIL;
/* SYS_fcntl 62 */
sys_fcntl();
sys_fcntl2();
sys_fcntl3();
sys_fcntl4();
/* SYS_ulimit 63 */
/* XXX Missing wrapper. */
/* SYS_renameat 64 */
GO(SYS_renameat, "4s 2m");
SY(SYS_renameat, x0 - 1, x0, x0, x0); FAIL;
/* SYS_unlinkat 65 */
GO(SYS_unlinkat, "3s 1m");
SY(SYS_unlinkat, x0 - 1, x0, x0); FAIL;
/* SYS_fstatat 66 */
GO(SYS_fstatat, "4s 2m");
SY(SYS_fstatat, x0 - 1, x0 + 1, x0, x0); FAIL;
/* SYS_fstatat64 67 */
/* Tested in x86-solaris/scalar.c. */
/* SYS_openat 68 */
sys_openat();
sys_openat2();
/* SYS_openat64 69 */
/* Tested in x86-solaris/scalar.c. */
/* SYS_tasksys 70 */
sys_tasksys();
sys_tasksys2();
sys_tasksys3();
sys_tasksys4();
/* SYS_acctctl 71 */
/* XXX Missing wrapper. */
/* SYS_exacctsys 72 */
/* XXX Missing wrapper. */
/* SYS_getpagesizes 73 */
GO(SYS_getpagesizes, "3s 1m");
SY(SYS_getpagesizes, x0, x0 + 1, x0 + 1); FAIL;
/* SYS_rctlsys 74 */
/* XXX Missing wrapper. */
/* SYS_sidsys 75 */
/* XXX Missing wrapper. */
/* SYS_lwp_park 77 */
/* Don't bother to test this. */
GO(SYS_lwp_park, "ignore");
/* SYS_sendfilev 78 */
sys_sendfilev();
sys_sendfilev2();
sys_sendfilev3();
sys_sendfilev4();
/* SYS_rmdir 79 */
/* Tested in scalar_obsolete.c. */
/* SYS_mkdir 80 */
/* Tested in scalar_obsolete.c. */
/* SYS_getdents 81 */
GO(SYS_getdents, "3s 1m");
SY(SYS_getdents, x0, x0, x0 + 1); FAIL;
/* SYS_Privsys 82 */
sys_privsys();
sys_privsys2();
sys_privsys3();
sys_privsys4();
sys_privsys5();
sys_privsys6();
sys_privsys7();
sys_privsys8();
/* SYS_ucredsys 83 */
sys_ucredsys();
sys_ucredsys2();
/* SYS_sysfs 84 */
sys_sysfs();
sys_sysfs2();
sys_sysfs3();
/* SYS_getmsg 85 */
GO(SYS_getmsg, "4s 1m");
SY(SYS_getmsg, x0, x0, x0, x0); FAIL;
/* SYS_putmsg 86 */
GO(SYS_putmsg, "4s 0m");
SY(SYS_putmsg, x0, x0, x0, x0);
/* SYS_lstat 88 */
/* Tested in scalar_obsolete.c. */
/* SYS_symlink 89 */
/* Tested in scalar_obsolete.c. */
/* SYS_readlink 90 */
/* Tested in scalar_obsolete.c. */
/* SYS_setgroups 91 */
GO(SYS_setgroups, "2s 1m");
SY(SYS_setgroups, x0 + 1, x0 + 1); FAIL;
/* SYS_getgroups 92 */
GO(SYS_getgroups, "2s 1m");
SY(SYS_getgroups, x0 + 1, x0 + 1); FAIL;
/* SYS_fchmod 93 */
/* Tested in scalar_obsolete.c. */
/* SYS_fchown 94 */
/* Tested in scalar_obsolete.c. */
/* SYS_sigprocmask 95 */
GO(SYS_sigprocmask, "3s 2m");
SY(SYS_sigprocmask, x0, x0 + 1, x0 + 1); FAILx(EFAULT);
/* SYS_sigsuspend 96 */
GO(SYS_sigsuspend, "1s 1m");
SY(SYS_sigsuspend, x0 + 1); FAILx(EFAULT);
/* SYS_sigaltstack 97 */
GO(SYS_sigaltstack, "2s 2m");
SY(SYS_sigaltstack, x0 + 1, x0 + 1); FAILx(EFAULT);
/* SYS_sigaction 98 */
GO(SYS_sigaction, "3s 4m");
SY(SYS_sigaction, x0, x0 + 1, x0 + 1); FAILx(EFAULT);
/* SYS_sigpending 99 */
GO(SYS_sigpending, "2s 1m");
SY(SYS_sigpending, x0, x0 + 1);
/* SYS_context 100 */
sys_context();
sys_context2();
sys_context3();
sys_context4();
/* SYS_fchmodat 101 */
GO(SYS_fchmodat, "4s 1m");
SY(SYS_fchmodat, x0 - 1, x0 + 1, x0, x0); FAIL;
/* SYS_mkdirat 102 */
GO(SYS_mkdirat, "3s 1m");
SY(SYS_mkdirat, x0 - 1, x0, x0); FAIL;
/* SYS_statvfs 103 */
sys_statvfs();
sys_statvfs2();
/* SYS_fstatvfs 104 */
GO(SYS_fstatvfs, "2s 1m");
SY(SYS_fstatvfs, x0 - 1, x0 + 1); FAILx(EBADF);
/* SYS_getloadavg 105 */
/* XXX Missing wrapper. */
/* SYS_nfssys 106 */
sys_nfssys();
/* :TODO: Add test cases when other opcodes are implemented. */
/* SYS_waitid 107 */
GO(SYS_waitid, "4s 1m");
SY(SYS_waitid, x0 - 1, x0, x0, x0); FAIL;
/* SYS_sigsendsys 108 */
GO(SYS_sigsendsys, "2s 1m");
SY(SYS_sigsendsys, x0 - 1, x0); FAIL;
/* SYS_hrtsys 109 */
/* XXX Missing wrapper. */
/* SYS_utimesys 110 */
/* SYS_utimensat 110 */
/* Tested in scalar_utimesys and scalar_utimensat. */
/* SYS_sigresend 111 */
GO(SYS_sigresend, "3s 2m");
SY(SYS_sigresend, x0, x0 + 1, x0); FAIL;
/* SYS_priocntlsys 112 */
sys_priocntlsys();
sys_priocntlsys2();
sys_priocntlsys3();
sys_priocntlsys4();
sys_priocntlsys5();
sys_priocntlsys6();
sys_priocntlsys7();
sys_priocntlsys8();
sys_priocntlsys9();
sys_priocntlsys10();
sys_priocntlsys11();
/* SYS_pathconf 113 */
GO(SYS_pathconf, "2s 1m");
SY(SYS_pathconf, x0, x0); FAIL;
/* SYS_mincore 114 */
/* XXX Missing wrapper. */
/* SYS_mmap 115 */
GO(SYS_mmap, "6s 0m");
SY(SYS_mmap, x0, x0, x0, x0, x0, x0); FAILx(EINVAL);
/* SYS_mprotect 116 */
GO(SYS_mprotect, "3s 0m");
SY(SYS_mprotect, x0, x0, x0); FAILx(EINVAL);
/* SYS_munmap 117 */
GO(SYS_munmap, "2s 0m");
SY(SYS_munmap, x0, x0); FAILx(EINVAL);
/* SYS_fpathconf 118 */
/* XXX Missing wrapper. */
/* SYS_vfork 119 */
/* XXX Missing wrapper. */
/* SYS_fchdir 120 */
GO(SYS_fchdir, "1s 0m");
SY(SYS_fchdir, x0 - 1); FAILx(EBADF);
/* SYS_readv 121 */
GO(SYS_readv, "3s 1m");
SY(SYS_readv, x0, x0, x0 + 1); FAIL;
/* SYS_writev 122 */
GO(SYS_writev, "3s 1m");
SY(SYS_writev, x0, x0, x0 + 1); FAIL;
/* SYS_mmapobj 127 */
GO(SYS_mmapobj, "5s 2m");
SY(SYS_mmapobj, x0 - 1, x0 | MMOBJ_PADDING, x0, x0, x0); FAILx(EBADF);
/* SYS_setrlimit 128 */
GO(SYS_setrlimit, "2s 1m");
SY(SYS_setrlimit, x0, x0); FAIL;
/* SYS_getrlimit 129 */
GO(SYS_getrlimit, "2s 1m");
SY(SYS_getrlimit, x0, x0); FAIL;
/* SYS_lchown 130 */
/* Tested in scalar_obsolete.c. */
/* SYS_memcntl 131 */
GO(SYS_memcntl, "6s 1m");
SY(SYS_memcntl, x0, x0, x0 | MC_HAT_ADVISE, x0, x0, x0); FAIL;
/* SYS_getpmsg 132 */
GO(SYS_getpmsg, "5s 2m");
SY(SYS_getpmsg, x0, x0, x0, x0, x0); FAIL;
/* SYS_putpmsg 133 */
GO(SYS_putpmsg, "5s 0m");
SY(SYS_putpmsg, x0, x0, x0, x0, x0); FAIL;
/* SYS_rename 134 */
/* Tested in scalar_obsolete.c. */
/* SYS_uname 135 */
sys_uname();
sys_uname2();
/* SYS_setegid 136 */
GO(SYS_setegid, "1s 0m");
SY(SYS_setegid, x0 - 1); FAIL;
/* SYS_sysconfig 137 */
GO(SYS_sysconfig, "1s 0m");
SY(SYS_sysconfig, x0 - 1); FAIL;
/* SYS_adjtime 138 */
/* XXX Missing wrapper. */
/* SYS_systeminfo 139 */
GO(SYS_systeminfo, "3s 1m");
SY(SYS_systeminfo, x0 + 1, x0, x0 + 1); FAIL;
/* SYS_sharefs 140 */
/* XXX Missing wrapper. */
/* SYS_seteuid 141 */
GO(SYS_seteuid, "1s 0m");
SY(SYS_seteuid, x0 - 1); FAIL;
/* SYS_forksys 142 */
GO(SYS_forksys, "2s 0m");
SY(SYS_forksys, x0, x0 - 1); FAIL;
/* SYS_sigtimedwait 144 */
GO(SYS_sigtimedwait, "3s 3m");
SY(SYS_sigtimedwait, x0 - 1, x0 - 1, x0 - 1); FAIL;
/* SYS_lwp_info 145 */
/* XXX Missing wrapper. */
/* SYS_yield 146 */
GO(SYS_yield, "0s 0m");
SY(SYS_yield); SUCC;
/* SYS_lwp_sema_post 148 */
GO(SYS_lwp_sema_post, "1s 3m");
SY(SYS_lwp_sema_post, x0); FAIL;
/* SYS_lwp_sema_trywait 149 */
/* XXX Missing wrapper. */
/* SYS_lwp_detach 150 */
GO(SYS_lwp_detach, "1s 0m");
SY(SYS_lwp_detach, x0); FAIL;
/* SYS_corectl 151 */
/* XXX Missing wrapper. */
/* SYS_modctl 152 */
sys_modctl();
sys_modctl2();
sys_modctl3();
/* SYS_fchroot 153 */
GO(SYS_fchroot, "1s 0m");
SY(SYS_fchroot, x0 - 1); FAILx(EBADF);
/* SYS_vhangup 155 */
/* XXX Missing wrapper. */
/* SYS_gettimeofday 156 */
GO(SYS_gettimeofday, "1s 1m");
SY(SYS_gettimeofday, x0 + 1); FAIL;
/* SYS_getitimer 157 */
GO(SYS_getitimer, "2s 2m");
SY(SYS_getitimer, x0, x0 + 1); FAIL;
/* SYS_setitimer 158 */
GO(SYS_setitimer, "3s 4m");
SY(SYS_setitimer, x0, x0 + 1, x0 + 1); FAIL;
/* SYS_lwp_create 159 */
/* In the lwp_create() wrapper, we unfortunately have to call
ML_(safe_to_deref) before doing the PRE_READ_*() stuff, therefore only 1m
parameter. */
GO(SYS_lwp_create, "3s 1m");
SY(SYS_lwp_create, x0, x0, x0 + 1); FAILx(EINVAL);
/* SYS_lwp_exit 160 */
/* Don't bother to test this. */
GO(SYS_lwp_exit, "ignore");
/* SYS_lwp_suspend 161 */
GO(SYS_lwp_suspend, "1s 0m");
SY(SYS_lwp_suspend, x0 - 1); FAIL;
/* SYS_lwp_continue 162 */
GO(SYS_lwp_continue, "1s 0m");
SY(SYS_lwp_continue, x0 - 1); FAIL;
/* SYS_lwp_kill 163 */
/* SYS_lwp_sigqueue 163 */
/* Tested in scalar_lwp_kill and scalar_lwp_sigqueue. */
/* SYS_lwp_self 164 */
GO(SYS_lwp_self, "0s 0m");
SY(SYS_lwp_self); SUCC;
/* SYS_lwp_sigmask 165 */
GO(SYS_lwp_sigmask, "5s 0m");
SY(SYS_lwp_sigmask, x0, x0, x0, x0, x0); FAIL;
/* SYS_lwp_private 166 */
/* Tested in amd64-solaris/scalar and x86-solaris/scalar */
/* SYS_lwp_wait 167 */
GO(SYS_lwp_wait, "2s 1m");
SY(SYS_lwp_wait, x0 - 1, x0 + 1); FAIL;
/* SYS_lwp_mutex_wakeup 168 */
GO(SYS_lwp_mutex_wakeup, "2s 2m");
SY(SYS_lwp_mutex_wakeup, x0, x0); FAIL;
/* SYS_lwp_cond_wait 170 */
GO(SYS_lwp_cond_wait, "4s 5m");
SY(SYS_lwp_cond_wait, x0 + 1, x0 + 1, x0 + 1, x0); FAIL;
/* SYS_lwp_cond_signal 171 */
GO(SYS_lwp_cond_signal, "1s 2m");
SY(SYS_lwp_cond_signal, x0); FAIL;
/* SYS_lwp_cond_broadcast 172 */
GO(SYS_lwp_cond_broadcast, "1s 2m");
SY(SYS_lwp_cond_broadcast, x0); FAIL;
/* SYS_pread 173 */
GO(SYS_pread, "4s 1m");
SY(SYS_pread, x0 - 1, x0, x0 + 1, x0); FAILx(EBADF);
/* SYS_pwrite 174 */
GO(SYS_pwrite, "4s 1m");
SY(SYS_pwrite, x0 - 1, x0, x0 + 1, x0); FAILx(EBADF);
/* SYS_llseek 175 */
/* Tested in x86-solaris/scalar.c. */
/* SYS_inst_sync 176 */
/* XXX Missing wrapper. */
/* SYS_brand 177 */
/* XXX Missing wrapper. */
/* SYS_kaio 178 */
/* XXX Missing wrapper. */
/* SYS_cpc 179 */
/* XXX Missing wrapper. */
/* SYS_lgrpsys 180 */
sys_lgrpsys();
sys_lgrpsys2();
sys_lgrpsys3();
sys_lgrpsys4();
sys_lgrpsys5();
sys_lgrpsys6();
/* SYS_rusagesys 181 */
sys_rusagesys();
sys_rusagesys2();
sys_rusagesys3();
sys_rusagesys4();
sys_rusagesys5();
/* SYS_port 182 */
sys_port();
sys_port2();
sys_port3();
sys_port4();
sys_port5();
sys_port6();
sys_port7();
sys_port8();
sys_port9();
sys_port10();
sys_port11();
/* SYS_pollsys 183 */
GO(SYS_pollsys, "4s 5m");
SY(SYS_pollsys, x0, x0 + 1, x0 + 1, x0 + 1); FAIL;
/* SYS_labelsys 184 */
sys_labelsys();
sys_labelsys2();
sys_labelsys3();
sys_labelsys4();
sys_labelsys5();
sys_labelsys6();
/* SYS_acl 185 */
sys_acl();
sys_acl2();
sys_acl3();
sys_acl4();
sys_acl5();
sys_acl6();
/* SYS_auditsys 186 */
sys_auditsys();
sys_auditsys2();
sys_auditsys3();
sys_auditsys4();
sys_auditsys5();
sys_auditsys6();
sys_auditsys7();
sys_auditsys8();
sys_auditsys9();
sys_auditsys10();
sys_auditsys11();
sys_auditsys12();
sys_auditsys13();
sys_auditsys14();
sys_auditsys15();
sys_auditsys16();
sys_auditsys17();
sys_auditsys18();
sys_auditsys19();
sys_auditsys20();
sys_auditsys21();
sys_auditsys22();
sys_auditsys23();
sys_auditsys24();
sys_auditsys25();
sys_auditsys26();
sys_auditsys27();
sys_auditsys28();
sys_auditsys29();
sys_auditsys30();
/* SYS_processor_bind 187 */
/* XXX Missing wrapper. */
/* SYS_processor_info 188 */
/* XXX Missing wrapper. */
/* SYS_p_online 189 */
GO(SYS_p_online, "2s 0m");
SY(SYS_p_online, x0, x0); FAILx(EINVAL);
/* SYS_sigqueue 190 */
GO(SYS_sigqueue, "5s 1m");
SY(SYS_sigqueue, x0 - 1, x0, x0 + 1, x0, x0 - 1); FAIL;
/* SYS_clock_gettime 191 */
GO(SYS_clock_gettime, "2s 1m");
SY(SYS_clock_gettime, x0, x0); FAIL;
/* SYS_clock_settime 192 */
GO(SYS_clock_settime, "2s 1m");
SY(SYS_clock_settime, x0, x0); FAIL;
/* SYS_clock_getres 193 */
GO(SYS_clock_getres, "2s 1m");
SY(SYS_clock_getres, x0 + 1, x0 + 1); FAIL;
/* SYS_timer_create 194 */
sys_timer_create();
sys_timer_create2();
/* SYS_timer_delete 195 */
GO(SYS_timer_delete, "1s 0m");
SY(SYS_timer_delete, x0 + 1); FAIL;
/* SYS_timer_settime 196 */
GO(SYS_timer_settime, "4s 2m");
SY(SYS_timer_settime, x0, x0, x0 + 1, x0 + 2); FAIL;
/* SYS_timer_gettime 197 */
GO(SYS_timer_gettime, "2s 1m");
SY(SYS_timer_gettime, x0, x0 + 1); FAIL;
/* SYS_timer_getoverrun 198 */
GO(SYS_timer_getoverrun, "1s 0m");
SY(SYS_timer_getoverrun, x0); FAIL;
/* SYS_nanosleep 199 */
GO(SYS_nanosleep, "2s 2m");
SY(SYS_nanosleep, x0, x0 + 1); FAIL;
/* SYS_facl 200 */
sys_facl();
sys_facl2();
sys_facl3();
sys_facl4();
sys_facl5();
sys_facl6();
/* SYS_door 201 */
sys_door();
sys_door2();
sys_door3();
sys_door4();
sys_door5();
sys_door6();
/* XXX Additional sys_door variants still unimplemented. */
/* SYS_setreuid 202 */
GO(SYS_setreuid, "2s 0m");
SY(SYS_setreuid, x0 - 1, x0 - 1); SUCC;
/* SYS_setregid 203 */
GO(SYS_setregid, "2s 0m");
SY(SYS_setregid, x0 - 1, x0 - 1); SUCC;
/* SYS_install_utrap 204 */
/* XXX Missing wrapper. */
/* SYS_signotify 205 */
/* XXX Missing wrapper. */
/* SYS_schedctl 206 */
GO(SYS_schedctl, "0s 0m");
SY(SYS_schedctl); SUCC;
/* SYS_pset 207 */
sys_pset();
sys_pset2();
sys_pset3();
sys_pset4();
sys_pset5();
sys_pset6();
sys_pset7();
sys_pset8();
sys_pset9();
sys_pset10();
sys_pset11();
sys_pset12();
sys_pset13();
/* SYS_sparc_utrap_install 208 */
/* XXX Missing wrapper. */
/* SYS_resolvepath 209 */
GO(SYS_resolvepath, "3s 2m");
SY(SYS_resolvepath, x0, x0, x0 + 1); FAIL;
/* SYS_lwp_mutex_timedlock 210 */
GO(SYS_lwp_mutex_timedlock, "3s 7m");
SY(SYS_lwp_mutex_timedlock, x0, x0 + 1, x0); FAIL;
/* SYS_lwp_sema_timedwait 211 */
GO(SYS_lwp_sema_timedwait, "3s 4m");
SY(SYS_lwp_sema_timedwait, x0, x0 + 1, x0); FAIL;
/* SYS_lwp_rwlock_sys 212 */
sys_lwp_rwlock();
sys_lwp_rwlock2();
sys_lwp_rwlock3();
sys_lwp_rwlock4();
sys_lwp_rwlock5();
/* SYS_getdents64 213 */
/* Tested in x86-solaris/scalar.c. */
/* SYS_mmap64 214 */
/* Tested in x86-solaris/scalar.c. */
/* SYS_stat64 215 */
/* Tested in x86-solaris/scalar_obsolete.c. */
/* SYS_lstat64 216 */
/* Tested in x86-solaris/scalar_obsolete.c. */
/* SYS_fstat64 217 */
/* Tested in x86-solaris/scalar_obsolete.c. */
/* SYS_statvfs64 218 */
/* Tested in x86-solaris/scalar.c. */
/* SYS_fstatvfs64 219 */
/* Tested in x86-solaris/scalar.c. */
/* SYS_setrlimit64 220 */
/* Tested in x86-solaris/scalar.c. */
/* SYS_getrlimit64 221 */
/* Tested in x86-solaris/scalar.c. */
/* SYS_pread64 222 */
/* Tested in x86-solaris/scalar.c. */
/* SYS_pwrite64 223 */
/* Tested in x86-solaris/scalar.c. */
/* SYS_open64 225 */
/* Tested in x86-solaris/scalar_obsolete.c. */
/* SYS_rpcsys 226 */
/* XXX Missing wrapper. */
/* SYS_zone 227 */
sys_zone();
sys_zone2();
sys_zone3();
sys_zone4();
sys_zone5();
sys_zone6();
sys_zone7();
sys_zone8();
sys_zone9();
sys_zone10();
sys_zone11();
/*
2013-09-22 Petr Pavlu -- The following test crashes my system because of
a kernel bug (illumos), commenting it out for now.
sys_zone12();
*/
sys_zone13();
/*
2013-09-22 Petr Pavlu -- The following test provides an incorrect result
because of a kernel bug (illumos), commenting it out for now.
sys_zone14();
*/
sys_zone15();
/*
2013-09-22 Petr Pavlu -- The following test provides an incorrect result
because of a kernel bug (illumos), commenting it out for now.
sys_zone16();
*/
/* SYS_autofssys 228 */
/* XXX Missing wrapper. */
/* SYS_getcwd 229 */
GO(SYS_getcwd, "2s 1m");
SY(SYS_getcwd, x0, x0 + 1); FAIL;
/* SYS_so_socket 230 */
GO(SYS_so_socket, "5s 1m");
SY(SYS_so_socket, x0, x0, x0, x0 + 1, x0); FAIL;
/* SYS_so_socketpair 231 */
GO(SYS_so_socketpair, "1s 1m");
SY(SYS_so_socketpair, x0); FAIL;
/* SYS_bind 232 */
GO(SYS_bind, "4s 0m");
SY(SYS_bind, x0, x0, x0, x0); FAIL;
/* SYS_listen 233 */
GO(SYS_listen, "3s 0m");
SY(SYS_listen, x0, x0, x0); FAIL;
/* SYS_accept 234 */
/* Illumos added a new version of the accept() syscall which takes an extra
flag parameter. This is trivially handled in the syscall wrapper but it
is not tested here so it is not necessary to have two versions of the
stderr.exp file. */
GO(SYS_accept, "4s 0m");
SY(SYS_accept, x0, x0, x0, x0, 0); FAIL;
/* SYS_connect 235 */
GO(SYS_connect, "4s 0m");
SY(SYS_connect, x0, x0, x0, x0); FAIL;
/* SYS_shutdown 236 */
GO(SYS_shutdown, "3s 0m");
SY(SYS_shutdown, x0 - 1, x0, x0); FAILx(EBADF);
/* SYS_recv 237 */
GO(SYS_recv, "4s 1m");
SY(SYS_recv, x0, x0, x0 + 1, x0); FAIL;
/* SYS_recvfrom 238 */
GO(SYS_recvfrom, "6s 1m");
SY(SYS_recvfrom, x0, x0, x0 + 1, x0, x0, x0); FAIL;
/* SYS_recvmsg 239 */
GO(SYS_recvmsg, "3s 0m");
SY(SYS_recvmsg, x0, x0, x0); FAIL;
/* SYS_send 240 */
GO(SYS_send, "4s 1m");
SY(SYS_send, x0, x0, x0 + 1, x0); FAIL;
/* SYS_sendmsg 241 */
GO(SYS_sendmsg, "3s 0m");
SY(SYS_sendmsg, x0, x0, x0); FAIL;
/* SYS_sendto 242 */
GO(SYS_sendto, "6s 1m");
SY(SYS_sendto, x0, x0, x0 + 1, x0, x0, x0); FAIL;
/* SYS_getpeername 243 */
sys_getpeername();
sys_getpeername2();
/* SYS_getsockname 244 */
GO(SYS_getsockname, "4s 1m");
SY(SYS_getsockname, x0, x0, x0, x0); FAIL;
/* SYS_getsockopt 245 */
GO(SYS_getsockopt, "6s 0m");
SY(SYS_getsockopt, x0, x0, x0, x0, x0, x0); FAIL;
/* SYS_setsockopt 246 */
GO(SYS_setsockopt, "6s 1m");
SY(SYS_setsockopt, x0, x0, x0, x0, x0 + 1, x0); FAIL;
/* SYS_sockconfig 247 */
/* XXX Missing wrapper. */
/* SYS_ntp_gettime 248 */
/* XXX Missing wrapper. */
/* SYS_ntp_adjtime 249 */
/* XXX Missing wrapper. */
/* SYS_lwp_mutex_unlock 250 */
/* XXX Missing wrapper. */
/* SYS_lwp_mutex_trylock 251 */
/* XXX Missing wrapper. */
/* SYS_lwp_mutex_register 252 */
GO(SYS_lwp_mutex_register, "2s 1m");
SY(SYS_lwp_mutex_register, x0, x0); FAIL;
/* SYS_cladm 253 */
/* XXX Missing wrapper. */
/* SYS_uucopy 254 */
GO(SYS_uucopy, "3s 2m");
SY(SYS_uucopy, x0, x0, x0 + 1); FAIL;
/* SYS_umount2 255 */
GO(SYS_umount2, "2s 1m");
SY(SYS_umount2, x0, x0); FAIL;
/* No such syscall... */
#if 0
GO(9999, "1e");
SY(9999); FAIL;
#endif
/* SYS_exit 1 */
GO(SYS_exit, "1s 0m");
SY(SYS_exit, x0); FAIL;
assert(0);
return 0;
}