int
main(void)
{
time_t *p = tail_alloc(sizeof(time_t));
time_t t = syscall(__NR_time, p);
if ((time_t) -1 == t)
perror_msg_and_skip("time");
printf("time([%jd]) = %jd\n", (intmax_t) *p, (intmax_t) t);
puts("+++ exited with 0 +++");
return 0;
}
int
main(void)
{
struct sock_filter *const filter = tail_alloc(sizeof(*filter) * N);
const void *const efault = tail_alloc(1);
struct sock_fprog *const prog = tail_alloc(sizeof(*prog));
long rc;
prog->filter = filter;
prog->len = N;
rc = syscall(__NR_seccomp, SECCOMP_SET_MODE_FILTER, -1, prog);
printf("seccomp(SECCOMP_SET_MODE_FILTER, %s, {len=%u, filter=%p})"
" = %ld %s (%m)\n", "SECCOMP_FILTER_FLAG_TSYNC|0xfffffffe",
prog->len, prog->filter, rc, errno2name());
rc = syscall(__NR_seccomp, SECCOMP_SET_MODE_FILTER, -2L, efault);
printf("seccomp(SECCOMP_SET_MODE_FILTER, %s, %p) = %ld %s (%m)\n",
"0xfffffffe /* SECCOMP_FILTER_FLAG_??? */",
efault, rc, errno2name());
puts("+++ exited with 0 +++");
return 0;
}
int
main(void)
{
static const long bogus_ctx =
(long) 0xface1e55deadbeefLL;
static const char data2[] =
"\0\1\2\3cat test test test 0123456789abcdef";
const unsigned int sizeof_data0 = 4096;
const unsigned int sizeof_data1 = 8192;
void *data0 = tail_alloc(sizeof_data0);
void *data1 = tail_alloc(sizeof_data1);
const struct iocb proto_cb[] = {
{
.aio_data = (unsigned long) 0xfeedface11111111ULL,
.aio_reqprio = 11,
.aio_buf = (unsigned long) data0,
.aio_offset = (unsigned long) 0xdeface1facefeedULL,
.aio_nbytes = sizeof_data0
},
{
.aio_data = (unsigned long) 0xfeedface22222222ULL,
int
main(void)
{
const unsigned int size = PATH_MAX - 1;
const char *p = tail_alloc(size);
const char *const efault = p + size;
for (; p <= efault; ++p) {
int rc = chdir(p);
printf("chdir(%p) = %d %s (%m)\n", p, rc, errno2name());
}
puts("+++ exited with 0 +++");
return 0;
}
int
main(void)
{
long rc = syscall(__NR_clock_adjtime, CLOCK_MONOTONIC, NULL);
printf("clock_adjtime(CLOCK_MONOTONIC, NULL) = %ld %s (%m)\n",
rc, errno2name());
void *efault = tail_alloc(1);
rc = syscall(__NR_clock_adjtime, CLOCK_REALTIME, efault);
printf("clock_adjtime(CLOCK_REALTIME, %p) = %ld %s (%m)\n",
efault, rc, errno2name());
puts("+++ exited with 0 +++");
return 0;
}
static void
test_fiemap(void)
{
(void) tail_alloc(1);
TAIL_ALLOC_OBJECT_CONST_PTR(struct fiemap, args);
printf("ioctl(-1, FS_IOC_FIEMAP, {fm_start=%" PRI__u64
", fm_length=%" PRI__u64", fm_flags=",
args->fm_start, args->fm_length);
printflags(fiemap_flags, args->fm_flags, "FIEMAP_FLAG_???");
printf(", fm_extent_count=%u})", args->fm_extent_count);
ioctl(-1, FS_IOC_FIEMAP, args);
printf(" = -1 EBADF (%m)\n");
/* The live version of this test is in btrfs.c */
}
int
main(void)
{
struct perf_event_attr *attr = tail_alloc(sizeof(*attr));
attr->type = PERF_TYPE_HARDWARE;
attr->size = sizeof(*attr);
struct {
struct perf_event_attr *attr;
pid_t pid;
int cpu;
int group_fd;
unsigned long flags;
const char *flags_str;
} args[] = {
{ NULL, 0xfacef00d, 0xbadabba7, -1,
(unsigned long) 0xFFFFFFFFFFFFFFFFLLU,
"PERF_FLAG_FD_NO_GROUP|PERF_FLAG_FD_OUTPUT|"
"PERF_FLAG_PID_CGROUP|PERF_FLAG_FD_CLOEXEC|"
"0x" LONG_STR_PREFIX "fffffff0"
},
{ attr + 1, 0, 0, 0,
0, "0" },
{ attr, -1, -1, 1,
PERF_FLAG_FD_CLOEXEC, "PERF_FLAG_FD_CLOEXEC" },
{ attr - 1, -100, 100, 0xface1e55,
PERF_FLAG_FD_NO_GROUP | PERF_FLAG_FD_OUTPUT |
PERF_FLAG_PID_CGROUP | PERF_FLAG_FD_CLOEXEC,
"PERF_FLAG_FD_NO_GROUP|PERF_FLAG_FD_OUTPUT|"
"PERF_FLAG_PID_CGROUP|PERF_FLAG_FD_CLOEXEC" },
};
size_t i;
int rc;
for (i = 0; i < ARRAY_SIZE(args); i++) {
rc = syscall(__NR_perf_event_open, args[i].attr, args[i].pid,
args[i].cpu, args[i].group_fd, args[i].flags);
printf("perf_event_open(%s, %d, %d, %d, %s) = %s\n",
printaddr(args[i].attr), args[i].pid, args[i].cpu,
args[i].group_fd, args[i].flags_str, sprintrc(rc));
}
puts("+++ exited with 0 +++");
return 0;
}
int
main(void)
{
sysinfo(NULL);
printf("sysinfo(NULL) = -1 EFAULT (%m)\n");
struct sysinfo * const si = tail_alloc(sizeof(*si));
if (sysinfo(si))
perror_msg_and_skip("sysinfo");
printf("sysinfo({uptime=%llu"
", loads=[%llu, %llu, %llu]"
", totalram=%llu"
", freeram=%llu"
", sharedram=%llu"
", bufferram=%llu"
", totalswap=%llu"
", freeswap=%llu"
", procs=%u"
", totalhigh=%llu"
", freehigh=%llu"
", mem_unit=%u"
"}) = 0\n"
, (unsigned long long) si->uptime
, (unsigned long long) si->loads[0]
, (unsigned long long) si->loads[1]
, (unsigned long long) si->loads[2]
, (unsigned long long) si->totalram
, (unsigned long long) si->freeram
, (unsigned long long) si->sharedram
, (unsigned long long) si->bufferram
, (unsigned long long) si->totalswap
, (unsigned long long) si->freeswap
, (unsigned) si->procs
, (unsigned long long) si->totalhigh
, (unsigned long long) si->freehigh
, si->mem_unit
);
puts("+++ exited with 0 +++");
return 0;
}
int
main(void)
{
enum { BUF_SIZE = 4096 };
static const uint64_t bogus_cookie =
(uint64_t) 0xf157feeddeadfaceULL;
static const kernel_ulong_t bogus_len =
(kernel_ulong_t) 0xbadc0dedda7a1057ULL;
char *buf = tail_alloc(BUF_SIZE);
do_lookup_cookie(0, NULL, 0);
do_lookup_cookie(bogus_cookie, buf + BUF_SIZE, bogus_len);
do_lookup_cookie(bogus_cookie, buf, BUF_SIZE);
puts("+++ exited with 0 +++");
return 0;
}
int
main(void)
{
static const struct bpf_check checks[] = {
CHK(BPF_MAP_CREATE),
CHK(BPF_MAP_LOOKUP_ELEM),
CHK(BPF_MAP_UPDATE_ELEM),
CHK(BPF_MAP_DELETE_ELEM),
CHK(BPF_MAP_GET_NEXT_KEY),
CHK(BPF_PROG_LOAD),
CHK(BPF_OBJ_PIN),
CHK(BPF_OBJ_GET),
CHK(BPF_PROG_ATTACH),
CHK(BPF_PROG_DETACH),
CHK(BPF_PROG_TEST_RUN),
CHK(BPF_PROG_GET_NEXT_ID),
CHK(BPF_MAP_GET_NEXT_ID),
CHK(BPF_PROG_GET_FD_BY_ID),
CHK(BPF_MAP_GET_FD_BY_ID),
CHK(BPF_OBJ_GET_INFO_BY_FD),
CHK(BPF_PROG_QUERY),
CHK(BPF_RAW_TRACEPOINT_OPEN),
};
page_size = get_page_size();
end_of_page = (unsigned long) tail_alloc(1) + 1;
for (size_t i = 0; i < ARRAY_SIZE(checks); i++)
test_bpf(checks + i);
sys_bpf(0xfacefeed, 0, (kernel_ulong_t) 0xfacefeedbadc0dedULL);
printf("bpf(0xfacefeed /* BPF_??? */, NULL, %u) = %s\n",
0xbadc0dedu, errstr);
sys_bpf(0xfacefeed, end_of_page, 40);
printf("bpf(0xfacefeed /* BPF_??? */, %#lx, 40) = %s\n",
end_of_page, errstr);
puts("+++ exited with 0 +++");
return 0;
}
static void
print_statfs(const char *const sample, const char *magic_str)
{
int fd = open(sample, O_RDONLY);
if (fd < 0)
perror_msg_and_fail("open: %s", sample);
STRUCT_STATFS *const b = tail_alloc(sizeof(*b));
long rc = SYSCALL_INVOKE(sample, fd, b, sizeof(*b));
if (rc)
perror_msg_and_skip(SYSCALL_NAME);
PRINT_SYSCALL_HEADER(sample, fd, sizeof(*b));
if (magic_str)
printf("{f_type=%s", magic_str);
else
print_statfs_type("{f_type=", b->f_type);
PRINT_NUM(f_bsize);
PRINT_NUM(f_blocks);
PRINT_NUM(f_bfree);
PRINT_NUM(f_bavail);
PRINT_NUM(f_files);
PRINT_NUM(f_ffree);
#ifdef PRINT_F_FSID
printf(", f_fsid={%u, %u}",
(unsigned) b->PRINT_F_FSID[0], (unsigned) b->PRINT_F_FSID[1]);
#endif
PRINT_NUM(f_namelen);
#ifdef PRINT_F_FRSIZE
PRINT_NUM(f_frsize);
#endif
#ifdef PRINT_F_FLAGS
if (b->f_flags & ST_VALID) {
printf(", f_flags=");
printflags(statfs_flags, b->f_flags, "ST_???");
}
#endif
printf("}) = 0\n");
}
int
main(void)
{
struct epoll_event *const ev = tail_alloc(sizeof(*ev));
ev->events = EPOLLIN;
long rc = invoke_syscall(-1U, EPOLL_CTL_ADD, -2U, ev);
printf("epoll_ctl(-1, EPOLL_CTL_ADD, -2, {EPOLLIN,"
" {u32=%u, u64=%" PRIu64 "}}) = %ld %s (%m)\n",
ev->data.u32, ev->data.u64, rc, errno2name());
rc = invoke_syscall(-3U, EPOLL_CTL_DEL, -4U, ev);
printf("epoll_ctl(-3, EPOLL_CTL_DEL, -4, %p) = %ld %s (%m)\n",
ev, rc, errno2name());
rc = invoke_syscall(-1UL, EPOLL_CTL_MOD, -16UL, 0);
printf("epoll_ctl(-1, EPOLL_CTL_MOD, -16, NULL) = %ld %s (%m)\n",
rc, errno2name());
puts("+++ exited with 0 +++");
return 0;
}
int
main(void)
{
struct rusage *const usage = tail_alloc(sizeof(struct rusage));
int rc = syscall(__NR_getrusage, RUSAGE_SELF, usage);
printf("getrusage(RUSAGE_SELF, {ru_utime={%ju, %ju}"
", ru_stime={%ju, %ju}, ru_maxrss=%lu, ru_ixrss=%lu"
", ru_idrss=%lu, ru_isrss=%lu, ru_minflt=%lu"
", ru_majflt=%lu, ru_nswap=%lu, ru_inblock=%lu"
", ru_oublock=%lu, ru_msgsnd=%lu, ru_msgrcv=%lu"
", ru_nsignals=%lu, ru_nvcsw=%lu, ru_nivcsw=%lu}) = %d\n",
(uintmax_t) usage->ru_utime.tv_sec,
(uintmax_t) usage->ru_utime.tv_usec,
(uintmax_t) usage->ru_stime.tv_sec,
(uintmax_t) usage->ru_stime.tv_usec,
usage->ru_maxrss, usage->ru_ixrss, usage->ru_idrss,
usage->ru_isrss, usage->ru_minflt, usage->ru_majflt,
usage->ru_nswap, usage->ru_inblock, usage->ru_oublock,
usage->ru_msgsnd, usage->ru_msgrcv, usage->ru_nsignals,
usage->ru_nvcsw, usage->ru_nivcsw, rc);
puts("+++ exited with 0 +++");
return 0;
}
int
main(int ac, const char **av)
{
assert(ac == 2);
struct sockaddr_un addr = { .sun_family = AF_UNIX };
unsigned int sun_path_len = strlen(av[1]);
assert(sun_path_len > 0 && sun_path_len <= sizeof(addr.sun_path));
strncpy(addr.sun_path, av[1], sizeof(addr.sun_path));
struct sockaddr * const listen_sa = tail_memdup(&addr, sizeof(addr));
socklen_t * const len = tail_alloc(sizeof(socklen_t));
*len = offsetof(struct sockaddr_un, sun_path) + strlen(av[1]) + 1;
if (*len > sizeof(addr))
*len = sizeof(addr);
int listen_fd = socket(PF_LOCAL, SOCK_STREAM, 0);
if (listen_fd < 0)
perror_msg_and_skip("socket");
unsigned long listen_inode = inode_of_sockfd(listen_fd);
printf("socket(PF_LOCAL, SOCK_STREAM, 0) = %d<socket:[%lu]>\n",
listen_fd, listen_inode);
(void) unlink(av[1]);
if (bind(listen_fd, listen_sa, *len))
perror_msg_and_skip("bind");
printf("bind(%d<socket:[%lu]>, {sa_family=AF_LOCAL, sun_path=\"%s\"}"
", %u) = 0\n", listen_fd, listen_inode, av[1], (unsigned) *len);
if (listen(listen_fd, 1))
perror_msg_and_skip("listen");
printf("listen(%d<socket:[%lu]>, 1) = 0\n", listen_fd, listen_inode);
unsigned int * const optval = tail_alloc(sizeof(unsigned int));
*len = sizeof(*optval);
if (getsockopt(listen_fd, SOL_SOCKET, SO_PASSCRED, optval, len))
perror_msg_and_fail("getsockopt");
printf("getsockopt(%d<socket:[%lu]>, SOL_SOCKET, SO_PASSCRED"
", [%u], [%u]) = 0\n",
listen_fd, listen_inode, *optval, (unsigned) *len);
memset(listen_sa, 0, sizeof(addr));
*len = sizeof(addr);
if (getsockname(listen_fd, listen_sa, len))
perror_msg_and_fail("getsockname");
printf("getsockname(%d<socket:[%lu]>, {sa_family=AF_LOCAL"
", sun_path=\"%s\"}, [%u]) = 0\n", listen_fd, listen_inode,
av[1], (unsigned) *len);
int connect_fd = socket(PF_LOCAL, SOCK_STREAM, 0);
if (connect_fd < 0)
perror_msg_and_fail("socket");
unsigned long connect_inode = inode_of_sockfd(connect_fd);
printf("socket(PF_LOCAL, SOCK_STREAM, 0) = %d<socket:[%lu]>\n",
connect_fd, connect_inode);
if (connect(connect_fd, listen_sa, *len))
perror_msg_and_fail("connect");
printf("connect(%d<socket:[%lu]>, {sa_family=AF_LOCAL"
", sun_path=\"%s\"}, %u) = 0\n",
connect_fd, connect_inode, av[1], (unsigned) *len);
struct sockaddr * const accept_sa = tail_alloc(sizeof(addr));
memset(accept_sa, 0, sizeof(addr));
*len = sizeof(addr);
int accept_fd = accept(listen_fd, accept_sa, len);
if (accept_fd < 0)
perror_msg_and_fail("accept");
unsigned long accept_inode = inode_of_sockfd(accept_fd);
printf("accept(%d<socket:[%lu]>, {sa_family=AF_LOCAL, NULL}"
", [%u]) = %d<socket:[%lu]>\n",
listen_fd, listen_inode, (unsigned) *len,
accept_fd, accept_inode);
memset(listen_sa, 0, sizeof(addr));
*len = sizeof(addr);
if (getpeername(connect_fd, listen_sa, len))
perror_msg_and_fail("getpeername");
printf("getpeername(%d<socket:[%lu]>, {sa_family=AF_LOCAL"
", sun_path=\"%s\"}, [%u]) = 0\n", connect_fd, connect_inode,
av[1], (unsigned) *len);
char text[] = "text";
assert(sendto(connect_fd, text, sizeof(text) - 1, MSG_DONTWAIT, NULL, 0)
== sizeof(text) - 1);
printf("sendto(%d<socket:[%lu]>, \"%s\", %u, MSG_DONTWAIT"
", NULL, 0) = %u\n",
connect_fd, connect_inode, text,
(unsigned) sizeof(text) - 1, (unsigned) sizeof(text) - 1);
assert(close(connect_fd) == 0);
printf("close(%d<socket:[%lu]>) = 0\n", connect_fd, connect_inode);
assert(recvfrom(accept_fd, text, sizeof(text) - 1, MSG_DONTWAIT, NULL, NULL)
== sizeof(text) - 1);
printf("recvfrom(%d<socket:[%lu]>, \"%s\", %u, MSG_DONTWAIT"
", NULL, NULL) = %u\n",
accept_fd, accept_inode, text,
(unsigned) sizeof(text) - 1, (unsigned) sizeof(text) - 1);
assert(close(accept_fd) == 0);
printf("close(%d<socket:[%lu]>) = 0\n", accept_fd, accept_inode);
connect_fd = socket(PF_LOCAL, SOCK_STREAM, 0);
if (connect_fd < 0)
perror_msg_and_fail("socket");
connect_inode = inode_of_sockfd(connect_fd);
printf("socket(PF_LOCAL, SOCK_STREAM, 0) = %d<socket:[%lu]>\n",
connect_fd, connect_inode);
*optval = 1;
*len = sizeof(*optval);
if (setsockopt(connect_fd, SOL_SOCKET, SO_PASSCRED, optval, *len))
perror_msg_and_fail("setsockopt");
printf("setsockopt(%d<socket:[%lu]>, SOL_SOCKET, SO_PASSCRED"
", [%u], %u) = 0\n",
connect_fd, connect_inode, *optval, (unsigned) *len);
memset(listen_sa, 0, sizeof(addr));
*len = sizeof(addr);
if (getsockname(listen_fd, listen_sa, len))
perror_msg_and_fail("getsockname");
printf("getsockname(%d<socket:[%lu]>, {sa_family=AF_LOCAL"
", sun_path=\"%s\"}, [%u]) = 0\n",
listen_fd, listen_inode, av[1], (unsigned) *len);
if (connect(connect_fd, listen_sa, *len))
perror_msg_and_fail("connect");
printf("connect(%d<socket:[%lu]>, {sa_family=AF_LOCAL"
", sun_path=\"%s\"}, %u) = 0\n",
connect_fd, connect_inode, av[1], (unsigned) *len);
memset(accept_sa, 0, sizeof(addr));
*len = sizeof(addr);
accept_fd = accept(listen_fd, accept_sa, len);
if (accept_fd < 0)
perror_msg_and_fail("accept");
accept_inode = inode_of_sockfd(accept_fd);
const char * const sun_path1 =
((struct sockaddr_un *) accept_sa) -> sun_path + 1;
printf("accept(%d<socket:[%lu]>, {sa_family=AF_LOCAL"
", sun_path=@\"%s\"}, [%u]) = %d<socket:[%lu]>\n",
listen_fd, listen_inode, sun_path1, (unsigned) *len,
accept_fd, accept_inode);
memset(listen_sa, 0, sizeof(addr));
*len = sizeof(addr);
if (getpeername(connect_fd, listen_sa, len))
perror_msg_and_fail("getpeername");
printf("getpeername(%d<socket:[%lu]>, {sa_family=AF_LOCAL"
", sun_path=\"%s\"}, [%u]) = 0\n",
connect_fd, connect_inode, av[1], (unsigned) *len);
memset(accept_sa, 0, sizeof(addr));
*len = sizeof(addr);
if (getsockname(connect_fd, accept_sa, len))
perror_msg_and_fail("getsockname");
printf("getsockname(%d<socket:[%lu]>, {sa_family=AF_LOCAL"
", sun_path=@\"%s\"}, [%u]) = 0\n",
connect_fd, connect_inode, sun_path1, (unsigned) *len);
assert(sendto(connect_fd, text, sizeof(text) - 1, MSG_DONTWAIT, NULL, 0)
== sizeof(text) - 1);
printf("sendto(%d<socket:[%lu]>, \"%s\", %u, MSG_DONTWAIT"
", NULL, 0) = %u\n",
connect_fd, connect_inode, text,
(unsigned) sizeof(text) - 1, (unsigned) sizeof(text) - 1);
assert(close(connect_fd) == 0);
printf("close(%d<socket:[%lu]>) = 0\n", connect_fd, connect_inode);
assert(recvfrom(accept_fd, text, sizeof(text) - 1, MSG_DONTWAIT, NULL, NULL)
== sizeof(text) - 1);
printf("recvfrom(%d<socket:[%lu]>, \"%s\", %u, MSG_DONTWAIT"
", NULL, NULL) = %u\n",
accept_fd, accept_inode, text,
(unsigned) sizeof(text) - 1, (unsigned) sizeof(text) - 1);
assert(close(accept_fd) == 0);
printf("close(%d<socket:[%lu]>) = 0\n", accept_fd, accept_inode);
assert(unlink(av[1]) == 0);
assert(close(listen_fd) == 0);
printf("close(%d<socket:[%lu]>) = 0\n",
listen_fd, listen_inode);
puts("+++ exited with 0 +++");
return 0;
}
int
main(void)
{
int rc;
int fd = syscall(__NR_userfaultfd, O_NONBLOCK);
size_t pagesize = getpagesize();
if (fd < 0)
perror_msg_and_skip("userfaultfd");
/* ---- API ---- */
struct uffdio_api *api_struct = tail_alloc(sizeof(*api_struct));
/* With a bad fd */
memset(api_struct, 0, sizeof(*api_struct));
rc = ioctl(-1, UFFDIO_API, api_struct);
printf("ioctl(-1, UFFDIO_API, {api=0, features=0}) = %d %s (%m)\n",
rc, errno2name());
/* With a bad pointer */
rc = ioctl(fd, UFFDIO_API, NULL);
printf("ioctl(%d, UFFDIO_API, NULL) = %d %s (%m)\n",
fd, rc, errno2name());
/* Normal call */
api_struct->api = UFFD_API;
api_struct->features = 0;
rc = ioctl(fd, UFFDIO_API, api_struct);
printf("ioctl(%d, UFFDIO_API, {api=0xaa, features=0, "
"features.out=%#" PRIx64 ", " "ioctls=1<<_UFFDIO_REGISTER|"
"1<<_UFFDIO_UNREGISTER|1<<_UFFDIO_API",
fd, (uint64_t)api_struct->features);
api_struct->ioctls &= ~(1ull<<_UFFDIO_REGISTER|
1ull<<_UFFDIO_UNREGISTER|
1ull<<_UFFDIO_API);
if (api_struct->ioctls)
printf("|%#" PRIx64, (uint64_t)api_struct->ioctls);
printf("}) = %d\n", rc);
/* For the rest of the tests we need some anonymous memory */
void *area1 = mmap(NULL, pagesize, PROT_READ|PROT_WRITE,
MAP_PRIVATE|MAP_ANONYMOUS,
-1, 0);
if (area1 == MAP_FAILED)
perror_msg_and_fail("mmap area1");
void *area2 = mmap(NULL, pagesize, PROT_READ|PROT_WRITE,
MAP_PRIVATE|MAP_ANONYMOUS,
-1, 0);
if (area2 == MAP_FAILED)
perror_msg_and_fail("mmap area2");
madvise(area2, pagesize, MADV_DONTNEED);
*(char *)area1 = 42;
/* ---- REGISTER ---- */
struct uffdio_register *register_struct =
tail_alloc(sizeof(*register_struct));
memset(register_struct, 0, sizeof(*register_struct));
rc = ioctl(-1, UFFDIO_REGISTER, register_struct);
printf("ioctl(-1, UFFDIO_REGISTER, {range={start=0, len=0}, "
"mode=0}) = %d %s (%m)\n", rc, errno2name());
rc = ioctl(fd, UFFDIO_REGISTER, NULL);
printf("ioctl(%d, UFFDIO_REGISTER, NULL) = %d %s (%m)\n",
fd, rc, errno2name());
register_struct->range.start = (uint64_t)(uintptr_t)area2;
register_struct->range.len = pagesize;
register_struct->mode = UFFDIO_REGISTER_MODE_MISSING;
rc = ioctl(fd, UFFDIO_REGISTER, register_struct);
printf("ioctl(%d, UFFDIO_REGISTER, {range={start=%p, len=%#zx}, "
"mode=UFFDIO_REGISTER_MODE_MISSING, ioctls="
"1<<_UFFDIO_WAKE|1<<_UFFDIO_COPY|1<<_UFFDIO_ZEROPAGE",
fd, area2, pagesize);
register_struct->ioctls &= ~(1ull<<_UFFDIO_WAKE|
1ull<<_UFFDIO_COPY|
1ull<<_UFFDIO_ZEROPAGE);
if (register_struct->ioctls)
printf("|%#" PRIx64, (uint64_t)register_struct->ioctls);
printf("}) = %d\n", rc);
/* With area2 registered we can now do the atomic copies onto it
* but be careful not to access it in any other way otherwise
* userfaultfd will cause us to stall.
*/
/* ---- COPY ---- */
struct uffdio_copy *copy_struct = tail_alloc(sizeof(*copy_struct));
memset(copy_struct, 0, sizeof(*copy_struct));
rc = ioctl(-1, UFFDIO_COPY, copy_struct);
printf("ioctl(-1, UFFDIO_COPY, {dst=0, src=0, len=0, mode=0"
"}) = %d %s (%m)\n", rc, errno2name());
rc = ioctl(fd, UFFDIO_COPY, NULL);
printf("ioctl(%d, UFFDIO_COPY, NULL) = %d %s (%m)\n",
fd, rc, errno2name());
copy_struct->dst = (uint64_t)(uintptr_t)area2;
copy_struct->src = (uint64_t)(uintptr_t)area1;
copy_struct->len = pagesize;
copy_struct->mode = UFFDIO_COPY_MODE_DONTWAKE;
rc = ioctl(fd, UFFDIO_COPY, copy_struct);
printf("ioctl(%d, UFFDIO_COPY, {dst=%p, src=%p, len=%#zx,"
" mode=UFFDIO_COPY_MODE_DONTWAKE, copy=%#zx}) = %d\n",
fd, area2, area1, pagesize, pagesize, rc);
/* ---- ZEROPAGE ---- */
struct uffdio_zeropage *zero_struct = tail_alloc(sizeof(*zero_struct));
madvise(area2, pagesize, MADV_DONTNEED);
memset(zero_struct, 0, sizeof(*zero_struct));
rc = ioctl(-1, UFFDIO_ZEROPAGE, zero_struct);
printf("ioctl(-1, UFFDIO_ZEROPAGE, {range={start=0, len=0}, mode=0"
"}) = %d %s (%m)\n", rc, errno2name());
rc = ioctl(fd, UFFDIO_ZEROPAGE, NULL);
printf("ioctl(%d, UFFDIO_ZEROPAGE, NULL) = %d %s (%m)\n",
fd, rc, errno2name());
zero_struct->range.start = (uint64_t)(uintptr_t)area2;
zero_struct->range.len = pagesize;
zero_struct->mode = UFFDIO_ZEROPAGE_MODE_DONTWAKE;
rc = ioctl(fd, UFFDIO_ZEROPAGE, zero_struct);
printf("ioctl(%d, UFFDIO_ZEROPAGE, {range={start=%p, len=%#zx},"
" mode=UFFDIO_ZEROPAGE_MODE_DONTWAKE, zeropage=%#zx}) = %d\n",
fd, area2, pagesize, pagesize, rc);
/* ---- WAKE ---- */
struct uffdio_range *range_struct = tail_alloc(sizeof(*range_struct));
memset(range_struct, 0, sizeof(*range_struct));
rc = ioctl(-1, UFFDIO_WAKE, range_struct);
printf("ioctl(-1, UFFDIO_WAKE, {start=0, len=0}) = %d %s (%m)\n",
rc, errno2name());
rc = ioctl(fd, UFFDIO_WAKE, NULL);
printf("ioctl(%d, UFFDIO_WAKE, NULL) = %d %s (%m)\n",
fd, rc, errno2name());
range_struct->start = (uint64_t)(uintptr_t)area2;
range_struct->len = pagesize;
rc = ioctl(fd, UFFDIO_WAKE, range_struct);
printf("ioctl(%d, UFFDIO_WAKE, {start=%p, len=%#zx}) = %d\n",
fd, area2, pagesize, rc);
/* ---- UNREGISTER ---- */
memset(range_struct, 0, sizeof(*range_struct));
rc = ioctl(-1, UFFDIO_UNREGISTER, range_struct);
printf("ioctl(-1, UFFDIO_UNREGISTER, {start=0, len=0}) = %d %s (%m)\n",
rc, errno2name());
rc = ioctl(fd, UFFDIO_UNREGISTER, NULL);
printf("ioctl(%d, UFFDIO_UNREGISTER, NULL) = %d %s (%m)\n",
fd, rc, errno2name());
range_struct->start = (uint64_t)(uintptr_t)area2;
range_struct->len = pagesize;
rc = ioctl(fd, UFFDIO_UNREGISTER, range_struct);
printf("ioctl(%d, UFFDIO_UNREGISTER, {start=%p, len=%#zx}) = %d\n",
fd, area2, pagesize, rc);
puts("+++ exited with 0 +++");
return 0;
}
int
main(void)
{
static const kernel_ulong_t bogus_fd =
(kernel_ulong_t) 0xbadc0deddeadbeef;
static const kernel_ulong_t kfdcwd =
(kernel_ulong_t) 0xdefaced00000000 | -100U;
static const char proto_fname[] = "utimensat\nfilename";
static const char qname[] = "\"utimensat\\nfilename\"";
char *const fname = tail_memdup(proto_fname, sizeof(proto_fname));
const kernel_ulong_t kfname = (uintptr_t) fname;
struct timespec *const ts = tail_alloc(sizeof(*ts) * 2);
(void) close(0);
/* dirfd */
k_utimensat(0, kfname, 0, 0);
printf("utimensat(0, %s, NULL, 0) = %s\n", qname, errstr);
k_utimensat(bogus_fd, kfname, 0, 0);
printf("utimensat(%d, %s, NULL, 0) = %s\n",
(int) bogus_fd, qname, errstr);
k_utimensat(-100U, kfname, 0, 0);
printf("utimensat(" str_at_fdcwd ", %s, NULL, 0) = %s\n", qname, errstr);
k_utimensat(kfdcwd, kfname, 0, 0);
printf("utimensat(" str_at_fdcwd ", %s, NULL, 0) = %s\n", qname, errstr);
/* pathname */
k_utimensat(kfdcwd, 0, 0, 0);
printf("utimensat(" str_at_fdcwd ", NULL, NULL, 0) = %s\n", errstr);
k_utimensat(kfdcwd, kfname + sizeof(proto_fname) - 1, 0, 0);
printf("utimensat(" str_at_fdcwd ", \"\", NULL, 0) = %s\n", errstr);
fname[sizeof(proto_fname) - 1] = '+';
k_utimensat(kfdcwd, kfname, 0, 0);
fname[sizeof(proto_fname) - 1] = '\0';
printf("utimensat(" str_at_fdcwd ", %p, NULL, 0) = %s\n", fname, errstr);
if (F8ILL_KULONG_SUPPORTED) {
k_utimensat(kfdcwd, f8ill_ptr_to_kulong(fname), 0, 0);
printf("utimensat(" str_at_fdcwd ", %#jx, NULL, 0) = %s\n",
(uintmax_t) f8ill_ptr_to_kulong(fname), errstr);
}
/* times */
k_utimensat(kfdcwd, kfname, (uintptr_t) (ts + 1), 0);
printf("utimensat(" str_at_fdcwd ", %s, %p, 0) = %s\n",
qname, ts + 1, errstr);
k_utimensat(kfdcwd, kfname, (uintptr_t) (ts + 2), 0);
printf("utimensat(" str_at_fdcwd ", %s, %p, 0)"
" = %s\n", qname, ts + 2, errstr);
ts[0].tv_sec = 1492358706;
ts[0].tv_nsec = 123456789;
ts[1].tv_sec = 1492357068;
ts[1].tv_nsec = 234567890;
k_utimensat(kfdcwd, kfname, (uintptr_t) ts, 0x100);
printf("utimensat(" str_at_fdcwd ", %s, [", qname);
print_ts(&ts[0]);
printf(", ");
print_ts(&ts[1]);
printf("], " str_at_symlink_nofollow ") = %s\n", errstr);
ts[0].tv_sec = -1;
ts[0].tv_nsec = 2000000000;
ts[1].tv_sec = (time_t) -0x100000001LL;
ts[1].tv_nsec = 2345678900U;
k_utimensat(kfdcwd, kfname, (uintptr_t) ts, 0x100);
printf("utimensat(" str_at_fdcwd ", %s, [", qname);
print_ts(&ts[0]);
printf(", ");
print_ts(&ts[1]);
printf("], " str_at_symlink_nofollow ") = %s\n", errstr);
ts[0].tv_sec = 0;
ts[0].tv_nsec = 0;
ts[1].tv_sec = (time_t) 0xcafef00ddeadbeefLL;
ts[1].tv_nsec = 0;
k_utimensat(kfdcwd, kfname, (uintptr_t) ts, 0x100);
printf("utimensat(" str_at_fdcwd ", %s, [", qname);
print_ts(&ts[0]);
printf(", ");
print_ts(&ts[1]);
printf("], " str_at_symlink_nofollow ") = %s\n", errstr);
ts[0].tv_sec = 0xdeadbeefU;
ts[0].tv_nsec = 0xfacefeedU;
ts[1].tv_sec = (time_t) 0xcafef00ddeadbeefLL;
ts[1].tv_nsec = (long) 0xbadc0dedfacefeedLL;
k_utimensat(kfdcwd, kfname, (uintptr_t) ts, 0x100);
printf("utimensat(" str_at_fdcwd ", %s, [", qname);
print_ts(&ts[0]);
printf(", ");
print_ts(&ts[1]);
printf("], " str_at_symlink_nofollow ") = %s\n", errstr);
ts[0].tv_nsec = UTIME_NOW;
ts[1].tv_nsec = UTIME_OMIT;
k_utimensat(kfdcwd, kfname, (uintptr_t) ts, 0x100);
printf("utimensat(" str_at_fdcwd ", %s, " str_utime_now_omit
", " str_at_symlink_nofollow ") = %s\n", qname, errstr);
if (F8ILL_KULONG_SUPPORTED) {
k_utimensat(kfdcwd, kfname, f8ill_ptr_to_kulong(ts), 0);
printf("utimensat(" str_at_fdcwd ", %s, %#jx, 0) = %s\n",
qname, (uintmax_t) f8ill_ptr_to_kulong(ts), errstr);
}
/* flags */
k_utimensat(kfdcwd, kfname, (uintptr_t) ts,
(kernel_ulong_t) 0xdefaced00000200);
printf("utimensat(" str_at_fdcwd ", %s, " str_utime_now_omit
", " str_at_removedir ") = %s\n",
qname, errstr);
k_utimensat(kfdcwd, kfname, (uintptr_t) ts,
(kernel_ulong_t) 0xdefaced00000600);
printf("utimensat(" str_at_fdcwd ", %s, " str_utime_now_omit
", " str_flags1 ") = %s\n",
qname, errstr);
k_utimensat(kfdcwd, kfname, (uintptr_t) ts, (kernel_ulong_t) -1ULL);
printf("utimensat(" str_at_fdcwd ", %s, " str_utime_now_omit
", " str_flags2 ") = %s\n",
qname, errstr);
puts("+++ exited with 0 +++");
return 0;
}
int
main(void)
{
TEST_NULL_ARG(EVIOCGVERSION);
TEST_NULL_ARG(EVIOCGEFFECTS);
TEST_NULL_ARG(EVIOCGID);
TEST_NULL_ARG(EVIOCGKEYCODE);
TEST_NULL_ARG(EVIOCSKEYCODE);
TEST_NULL_ARG(EVIOCSFF);
# ifdef EVIOCGKEYCODE_V2
TEST_NULL_ARG(EVIOCGKEYCODE_V2);
# endif
# ifdef EVIOCSKEYCODE_V2
TEST_NULL_ARG(EVIOCSKEYCODE_V2);
# endif
# ifdef EVIOCGREP
TEST_NULL_ARG(EVIOCGREP);
# endif
# ifdef EVIOCSREP
TEST_NULL_ARG(EVIOCSREP);
# endif
# ifdef EVIOCSCLOCKID
TEST_NULL_ARG(EVIOCSCLOCKID);
# endif
TEST_NULL_ARG(EVIOCGNAME(0));
TEST_NULL_ARG(EVIOCGPHYS(0));
TEST_NULL_ARG(EVIOCGUNIQ(0));
TEST_NULL_ARG(EVIOCGKEY(0));
TEST_NULL_ARG(EVIOCGLED(0));
# ifdef EVIOCGMTSLOTS
TEST_NULL_ARG(EVIOCGMTSLOTS(0));
# endif
# ifdef EVIOCGPROP
TEST_NULL_ARG(EVIOCGPROP(0));
# endif
TEST_NULL_ARG(EVIOCGSND(0));
# ifdef EVIOCGSW
TEST_NULL_ARG(EVIOCGSW(0));
# endif
TEST_NULL_ARG(EVIOCGABS(ABS_X));
TEST_NULL_ARG(EVIOCSABS(ABS_X));
TEST_NULL_ARG(EVIOCGBIT(EV_SYN, 0));
TEST_NULL_ARG(EVIOCGBIT(EV_KEY, 1));
TEST_NULL_ARG(EVIOCGBIT(EV_REL, 2));
TEST_NULL_ARG(EVIOCGBIT(EV_ABS, 3));
TEST_NULL_ARG(EVIOCGBIT(EV_MSC, 4));
# ifdef EV_SW
TEST_NULL_ARG(EVIOCGBIT(EV_SW, 5));
# endif
TEST_NULL_ARG(EVIOCGBIT(EV_LED, 6));
TEST_NULL_ARG(EVIOCGBIT(EV_SND, 7));
TEST_NULL_ARG(EVIOCGBIT(EV_REP, 8));
TEST_NULL_ARG(EVIOCGBIT(EV_FF, 9));
TEST_NULL_ARG(EVIOCGBIT(EV_PWR, 10));
TEST_NULL_ARG(EVIOCGBIT(EV_FF_STATUS, 11));
ioctl(-1, EVIOCGBIT(EV_MAX, 42), 0);
printf("ioctl(-1, EVIOCGBIT(%#x /* EV_??? */, 42), NULL)"
" = -1 EBADF (%m)\n", EV_MAX);
ioctl(-1, EVIOCRMFF, lmagic);
printf("ioctl(-1, EVIOCRMFF, %d) = -1 EBADF (%m)\n", (int) lmagic);
ioctl(-1, EVIOCGRAB, lmagic);
printf("ioctl(-1, EVIOCGRAB, %lu) = -1 EBADF (%m)\n", lmagic);
# ifdef EVIOCREVOKE
ioctl(-1, EVIOCREVOKE, lmagic);
printf("ioctl(-1, EVIOCREVOKE, %lu) = -1 EBADF (%m)\n", lmagic);
# endif
const unsigned int size = get_page_size();
void *const page = tail_alloc(size);
fill_memory(page, size);
int *const val_int = tail_alloc(sizeof(*val_int));
*val_int = magic;
# ifdef EVIOCSCLOCKID
ioctl(-1, EVIOCSCLOCKID, val_int);
printf("ioctl(-1, EVIOCSCLOCKID, [%u]) = -1 EBADF (%m)\n", *val_int);
# endif
int *pair_int = tail_alloc(sizeof(*pair_int) * 2);
pair_int[0] = 0xdeadbeef;
pair_int[1] = 0xbadc0ded;
# ifdef EVIOSGREP
ioctl(-1, EVIOCSREP, pair_int);
printf("ioctl(-1, EVIOCSREP, [%u, %u]) = -1 EBADF (%m)\n",
pair_int[0], pair_int[1]);
# endif
pair_int[1] = 1;
ioctl(-1, EVIOCSKEYCODE, pair_int);
printf("ioctl(-1, EVIOCSKEYCODE, [%u, %s]) = -1 EBADF (%m)\n",
pair_int[0], "KEY_ESC");
# ifdef EVIOCSKEYCODE_V2
struct input_keymap_entry *const ike = tail_alloc(sizeof(*ike));
fill_memory(ike, sizeof(*ike));
ike->keycode = 2;
ioctl(-1, EVIOCSKEYCODE_V2, ike);
printf("ioctl(-1, EVIOCSKEYCODE_V2, {flags=%" PRIu8
", len=%" PRIu8 ", ", ike->flags, ike->len);
# if VERBOSE
printf("index=%" PRIu16 ", keycode=%s, scancode=[",
ike->index, "KEY_1");
unsigned int i;
for (i = 0; i < ARRAY_SIZE(ike->scancode); ++i) {
if (i > 0)
printf(", ");
printf("%" PRIx8, ike->scancode[i]);
}
printf("]");
# else
printf("...");
# endif
errno = EBADF;
printf("}) = -1 EBADF (%m)\n");
# endif
struct ff_effect *const ffe = tail_alloc(sizeof(*ffe));
fill_memory(ffe, sizeof(*ffe));
ffe->type = FF_CONSTANT;
ioctl(-1, EVIOCSFF, ffe);
print_ffe_common(ffe, "FF_CONSTANT");
# if VERBOSE
printf(", constant={level=%hd", ffe->u.constant.level);
print_envelope(&ffe->u.constant.envelope);
printf("}");
# else
printf("...");
# endif
errno = EBADF;
printf("}) = -1 EBADF (%m)\n");
# if VERBOSE
ffe->type = FF_RAMP;
ioctl(-1, EVIOCSFF, ffe);
print_ffe_common(ffe, "FF_RAMP");
printf(", ramp={start_level=%hd, end_level=%hd",
ffe->u.ramp.start_level, ffe->u.ramp.end_level);
print_envelope(&ffe->u.ramp.envelope);
errno = EBADF;
printf("}}) = -1 EBADF (%m)\n");
ffe->type = FF_PERIODIC;
ioctl(-1, EVIOCSFF, ffe);
print_ffe_common(ffe, "FF_PERIODIC");
printf(", periodic={waveform=%hu, period=%hu, magnitude=%hd"
", offset=%hd, phase=%hu",
ffe->u.periodic.waveform, ffe->u.periodic.period,
ffe->u.periodic.magnitude, ffe->u.periodic.offset,
ffe->u.periodic.phase);
print_envelope(&ffe->u.periodic.envelope);
printf(", custom_len=%u, custom_data=%p}",
ffe->u.periodic.custom_len, ffe->u.periodic.custom_data);
errno = EBADF;
printf("}) = -1 EBADF (%m)\n");
ffe->type = FF_RUMBLE;
ioctl(-1, EVIOCSFF, ffe);
print_ffe_common(ffe, "FF_RUMBLE");
printf(", rumble={strong_magnitude=%hu, weak_magnitude=%hu}",
ffe->u.rumble.strong_magnitude, ffe->u.rumble.weak_magnitude);
errno = EBADF;
printf("}) = -1 EBADF (%m)\n");
ffe->type = 0xff;
ioctl(-1, EVIOCSFF, ffe);
print_ffe_common(ffe, "0xff /* FF_??? */");
errno = EBADF;
printf("}) = -1 EBADF (%m)\n");
# endif
ioctl(-1, _IOC(_IOC_READ, 0x45, 0x1, 0xff), lmagic);
printf("ioctl(-1, %s, %#lx) = -1 EBADF (%m)\n",
"_IOC(_IOC_READ, 0x45, 0x1, 0xff)", lmagic);
ioctl(-1, _IOC(_IOC_WRITE, 0x45, 0x1, 0xff), lmagic);
printf("ioctl(-1, %s, %#lx) = -1 EBADF (%m)\n",
"_IOC(_IOC_WRITE, 0x45, 0x1, 0xff)", lmagic);
ioctl(-1, _IOC(_IOC_READ|_IOC_WRITE, 0x45, 0xfe, 0xff), lmagic);
printf("ioctl(-1, %s, %#lx) = -1 EBADF (%m)\n",
"_IOC(_IOC_READ|_IOC_WRITE, 0x45, 0xfe, 0xff)", lmagic);
ioctl(-1, _IOC(_IOC_READ|_IOC_WRITE, 0x45, 0, 0), lmagic);
printf("ioctl(-1, %s, %#lx) = -1 EBADF (%m)\n",
"_IOC(_IOC_READ|_IOC_WRITE, 0x45, 0, 0)", lmagic);
puts("+++ exited with 0 +++");
return 0;
}
.aio_nbytes = sizeof_data1
}
};
const struct iocb *cb = tail_memdup(proto_cb, sizeof(proto_cb));
const long proto_cbs[] = {
(long) &cb[0], (long) &cb[1]
};
const long *cbs = tail_memdup(proto_cbs, sizeof(proto_cbs));
TAIL_ALLOC_OBJECT_CONST_PTR(unsigned long, ctx);
*ctx = 0;
const unsigned int nr = ARRAY_SIZE(proto_cb);
const struct io_event *ev = tail_alloc(nr * sizeof(struct io_event));
TAIL_ALLOC_OBJECT_CONST_PTR(struct timespec, ts);
TAIL_ALLOC_OBJECT_CONST_PTR(struct __aio_sigset, ss);
TAIL_ALLOC_OBJECT_CONST_PTR(sigset_t, sigs);
(void) close(0);
if (open("/dev/zero", O_RDONLY))
perror_msg_and_skip("open: %s", "/dev/zero");
if (syscall(__NR_io_setup, nr, ctx))
perror_msg_and_skip("io_setup");
if (syscall(__NR_io_submit, *ctx, nr, cbs) != (long) nr)
perror_msg_and_skip("io_submit");
sys_io_pgetevents(bogus_ctx, bogus_min_nr, bogus_nr,
int
main(void)
{
const char ** const tail_argv = tail_memdup(argv, sizeof(argv));
const char ** const tail_envp = tail_memdup(envp, sizeof(envp));
syscall(__NR_execveat, -100, FILENAME, tail_argv, tail_envp, 0x1100);
printf("execveat(AT_FDCWD, \"%s\""
", [\"%s\", \"%s\", \"%s\", %p, %p, %p, ???]"
#ifdef VERBOSE_EXECVEAT
", [\"%s\", \"%s\", %p, %p, %p, ???]"
#else
", [/* 5 vars, unterminated */]"
#endif
", AT_SYMLINK_NOFOLLOW|AT_EMPTY_PATH) = -1 %s (%m)\n",
Q_FILENAME, q_argv[0], q_argv[1], q_argv[2],
argv[3], argv[4], argv[5],
#ifdef VERBOSE_EXECVEAT
q_envp[0], q_envp[1], envp[2], envp[3], envp[4],
#endif
errno2name());
tail_argv[ARRAY_SIZE(q_argv)] = NULL;
tail_envp[ARRAY_SIZE(q_envp)] = NULL;
syscall(__NR_execveat, -100, FILENAME, tail_argv, tail_envp, 0x1100);
printf("execveat(AT_FDCWD, \"%s\", [\"%s\", \"%s\", \"%s\"]"
#ifdef VERBOSE_EXECVEAT
", [\"%s\", \"%s\"]"
#else
", [/* 2 vars */]"
#endif
", AT_SYMLINK_NOFOLLOW|AT_EMPTY_PATH) = -1 %s (%m)\n",
Q_FILENAME, q_argv[0], q_argv[1], q_argv[2],
#ifdef VERBOSE_EXECVEAT
q_envp[0], q_envp[1],
#endif
errno2name());
syscall(__NR_execveat, -100, FILENAME, tail_argv + 2, tail_envp + 1, 0x1100);
printf("execveat(AT_FDCWD, \"%s\", [\"%s\"]"
#ifdef VERBOSE_EXECVEAT
", [\"%s\"]"
#else
", [/* 1 var */]"
#endif
", AT_SYMLINK_NOFOLLOW|AT_EMPTY_PATH) = -1 %s (%m)\n",
Q_FILENAME, q_argv[2],
#ifdef VERBOSE_EXECVEAT
q_envp[1],
#endif
errno2name());
char **const empty = tail_alloc(sizeof(*empty));
char **const efault = empty + 1;
*empty = NULL;
syscall(__NR_execveat, -100, FILENAME, empty, empty, 0x1100);
printf("execveat(AT_FDCWD, \"%s\", []"
#ifdef VERBOSE_EXECVEAT
", []"
#else
", [/* 0 vars */]"
#endif
", AT_SYMLINK_NOFOLLOW|AT_EMPTY_PATH) = -1 %s (%m)\n",
Q_FILENAME, errno2name());
char str_a[] = "012345678901234567890123456789012";
char str_b[] = "_abcdefghijklmnopqrstuvwxyz()[]{}";
#define DEFAULT_STRLEN ((unsigned int) sizeof(str_a) - 2)
char **const a = tail_alloc(sizeof(*a) * (DEFAULT_STRLEN + 2));
char **const b = tail_alloc(sizeof(*b) * (DEFAULT_STRLEN + 2));
unsigned int i;
for (i = 0; i <= DEFAULT_STRLEN; ++i) {
a[i] = &str_a[i];
b[i] = &str_b[i];
}
a[i] = b[i] = NULL;
syscall(__NR_execveat, -100, FILENAME, a, b, 0x1100);
printf("execveat(AT_FDCWD, \"%s\", [\"%.*s\"...", Q_FILENAME, DEFAULT_STRLEN, a[0]);
for (i = 1; i < DEFAULT_STRLEN; ++i)
printf(", \"%s\"", a[i]);
#ifdef VERBOSE_EXECVEAT
printf(", \"%s\"", a[i]);
#else
printf(", ...");
#endif
#ifdef VERBOSE_EXECVEAT
printf("], [\"%.*s\"...", DEFAULT_STRLEN, b[0]);
for (i = 1; i <= DEFAULT_STRLEN; ++i)
printf(", \"%s\"", b[i]);
#else
printf("], [/* %u vars */", DEFAULT_STRLEN + 1);
#endif
printf("], AT_SYMLINK_NOFOLLOW|AT_EMPTY_PATH) = -1 %s (%m)\n",
errno2name());
syscall(__NR_execveat, -100, FILENAME, a + 1, b + 1, 0x1100);
printf("execveat(AT_FDCWD, \"%s\", [\"%s\"", Q_FILENAME, a[1]);
for (i = 2; i <= DEFAULT_STRLEN; ++i)
printf(", \"%s\"", a[i]);
#ifdef VERBOSE_EXECVEAT
printf("], [\"%s\"", b[1]);
for (i = 2; i <= DEFAULT_STRLEN; ++i)
printf(", \"%s\"", b[i]);
#else
printf("], [/* %d vars */", DEFAULT_STRLEN);
#endif
printf("], AT_SYMLINK_NOFOLLOW|AT_EMPTY_PATH) = -1 %s (%m)\n",
errno2name());
syscall(__NR_execveat, -100, FILENAME, NULL, efault, 0x1100);
printf("execveat(AT_FDCWD, \"%s\", NULL, %p"
", AT_SYMLINK_NOFOLLOW|AT_EMPTY_PATH) = -1 %s (%m)\n",
Q_FILENAME, efault, errno2name());
syscall(__NR_execveat, -100, FILENAME, efault, NULL, 0x1100);
printf("execveat(AT_FDCWD, \"%s\", %p, NULL"
", AT_SYMLINK_NOFOLLOW|AT_EMPTY_PATH) = -1 %s (%m)\n",
Q_FILENAME, efault, errno2name());
puts("+++ exited with 0 +++");
return 0;
}
" * %u bytes in buffer 0\n"
" | 00000 %-49s %-16s |\n"
" * %u bytes in buffer 1\n"
" | 00000 %-49s %-16s |\n"
" * %u bytes in buffer 2\n"
" | 00000 %-49s %-16s |\n",
w0_c, LENGTH_OF(w0_c),
w1_c, LENGTH_OF(w1_c),
w2_c, LENGTH_OF(w2_c),
ARRAY_SIZE(w_iov_), w_len,
LENGTH_OF(w0_c), w0_d, w0_c,
LENGTH_OF(w1_c), w1_d, w1_c,
LENGTH_OF(w2_c), w2_d, w2_c);
const unsigned int r_len = (w_len + 1) / 2;
void *r0 = tail_alloc(r_len);
const struct iovec r0_iov_[] = {
{
.iov_base = r0,
.iov_len = r_len
}
};
struct iovec *r_iov = tail_memdup(r0_iov_, sizeof(r0_iov_));
const struct msghdr r_mh_ = {
.msg_iov = r_iov,
.msg_iovlen = ARRAY_SIZE(r0_iov_)
};
struct msghdr *r_mh = tail_memdup(&r_mh_, sizeof(r_mh_));
assert(recvmsg(0, r_mh, 0) == (int) r_len);
};
const long *cbs = tail_memdup(proto_cbs, sizeof(proto_cbs));
const long proto_cbvs[] = {
(long) &cbv[0], (long) &cbv[1],
};
const long *cbvs = tail_memdup(proto_cbvs, sizeof(proto_cbvs));
const long proto_cbvs2[] = {
(long) &cbv2[0], (long) &cbv2[1], (long) &cbv2[2],
(long) &cbv2[3], (long) &cbv2[4],
(long) NULL, (long) 0xffffffffffffffffLL,
};
const long *cbvs2 = tail_memdup(proto_cbvs2, sizeof(proto_cbvs2));
unsigned long *ctx = tail_alloc(sizeof(unsigned long));
*ctx = 0;
const unsigned int nr = ARRAY_SIZE(proto_cb);
const unsigned long lnr = (unsigned long) (0xdeadbeef00000000ULL | nr);
const struct io_event *ev = tail_alloc(nr * sizeof(struct io_event));
const struct timespec proto_ts = { .tv_nsec = 123456789 };
const struct timespec *ts = tail_memdup(&proto_ts, sizeof(proto_ts));
(void) close(0);
if (open("/dev/zero", O_RDONLY))
perror_msg_and_skip("open: %s", "/dev/zero");
long rc = syscall(__NR_io_setup, 0xdeadbeef, NULL);
printf("io_setup(%u, NULL) = %s\n", 0xdeadbeef, sprintrc(rc));
int
main(int ac, const char **av)
{
assert(ac == 1);
(void) close(0);
if (open("/dev/zero", O_RDONLY) != 0)
perror_msg_and_skip("open: %s", "/dev/zero");
int sv[2];
if (socketpair(AF_UNIX, SOCK_STREAM, 0, sv))
perror_msg_and_skip("socketpair");
int reg_in = open(av[0], O_RDONLY);
if (reg_in < 0)
perror_msg_and_fail("open: %s", av[0]);
struct stat stb;
assert(fstat(reg_in, &stb) == 0);
const size_t blen = stb.st_size / 3;
const size_t alen = stb.st_size - blen;
assert(S_ISREG(stb.st_mode) && blen > 0);
const size_t page_len = get_page_size();
assert(syscall(__NR_sendfile64, 0, 1, NULL, page_len) == -1);
if (EBADF != errno)
perror_msg_and_skip("sendfile64");
printf("sendfile64(0, 1, NULL, %lu) = -1 EBADF (%m)\n",
(unsigned long) page_len);
uint64_t *p_off = tail_alloc(sizeof(uint64_t));
void *p = p_off + 1;
*p_off = 0;
assert(syscall(__NR_sendfile64, 0, 1, p, page_len) == -1);
printf("sendfile64(0, 1, %#lx, %lu) = -1 EFAULT (%m)\n",
(unsigned long) p, (unsigned long) page_len);
assert(syscall(__NR_sendfile64, sv[1], reg_in, NULL, alen)
== (long) alen);
printf("sendfile64(%d, %d, NULL, %lu) = %lu\n",
sv[1], reg_in, (unsigned long) alen,
(unsigned long) alen);
assert(syscall(__NR_sendfile64, sv[1], reg_in, p_off, alen)
== (long) alen);
printf("sendfile64(%d, %d, [0] => [%lu], %lu) = %lu\n",
sv[1], reg_in, (unsigned long) alen,
(unsigned long) alen, (unsigned long) alen);
assert(syscall(__NR_sendfile64, sv[1], reg_in, p_off, stb.st_size + 1)
== (long) blen);
printf("sendfile64(%d, %d, [%lu] => [%lu], %lu) = %lu\n",
sv[1], reg_in, (unsigned long) alen,
(unsigned long) stb.st_size,
(unsigned long) stb.st_size + 1,
(unsigned long) blen);
*p_off = 0xcafef00dfacefeed;
assert(syscall(__NR_sendfile64, sv[1], reg_in, p_off, 1) == -1);
printf("sendfile64(%d, %d, [14627392582579060461], 1)"
" = -1 EINVAL (%m)\n", sv[1], reg_in);
*p_off = 0xfacefeed;
assert(syscall(__NR_sendfile64, sv[1], reg_in, p_off, 1) == 0);
printf("sendfile64(%d, %d, [4207869677], 1) = 0\n", sv[1], reg_in);
puts("+++ exited with 0 +++");
return 0;
}
int
main(void)
{
ioctl(-1, SG_IO, 0);
printf("ioctl(-1, SG_IO, NULL) = -1 EBADF (%m)\n");
struct sg_io_hdr *const sg_io = tail_alloc(sizeof(*sg_io));
fill_memory(sg_io, sizeof(*sg_io));
const void *const efault = sg_io + 1;
ioctl(-1, SG_IO, efault);
printf("ioctl(-1, SG_IO, %p) = -1 EBADF (%m)\n", efault);
ioctl(-1, SG_IO, sg_io);
printf("ioctl(-1, SG_IO, [%u]) = -1 EBADF (%m)\n", sg_io->interface_id);
unsigned int *const piid = tail_alloc(sizeof(*piid));
*piid = (unsigned char) 'S';
ioctl(-1, SG_IO, piid);
printf("ioctl(-1, SG_IO, {interface_id='S', %p}) = -1 EBADF (%m)\n", piid + 1);
sg_io->interface_id = (unsigned char) 'S';
sg_io->dxfer_direction = -2;
sg_io->flags = -1U;
sg_io->info = -1U;
sg_io->dxferp = (void *) (unsigned long) 0xfacefeedfffffff1ULL;
sg_io->cmdp = (void *) (unsigned long) 0xfacefeedfffffff2ULL;
sg_io->sbp = (void *) (unsigned long) 0xfacefeedfffffff3ULL;
ioctl(-1, SG_IO, sg_io);
printf("ioctl(-1, SG_IO, {interface_id='S'"
", dxfer_direction=SG_DXFER_TO_DEV"
", cmd_len=%u"
", cmdp=%p"
", mx_sb_len=%u"
", iovec_count=%u"
", dxfer_len=%u"
", timeout=%u"
", flags=SG_FLAG_DIRECT_IO|SG_FLAG_UNUSED_LUN_INHIBIT"
"|SG_FLAG_MMAP_IO|SG_FLAG_NO_DXFER"
"|SG_FLAG_Q_AT_TAIL|SG_FLAG_Q_AT_HEAD|0xfffeffc8"
", dxferp=%p"
", status=%#x"
", masked_status=%#x"
", msg_status=%#x"
", sb_len_wr=%u"
", sbp=%p"
", host_status=%#x"
", driver_status=%#x"
", resid=%d"
", duration=%u"
", info=SG_INFO_CHECK|SG_INFO_DIRECT_IO|SG_INFO_MIXED_IO|0xfffffff8"
"}) = -1 EBADF (%m)\n",
sg_io->cmd_len,
sg_io->cmdp,
sg_io->mx_sb_len,
sg_io->iovec_count,
sg_io->dxfer_len,
sg_io->timeout,
sg_io->dxferp,
sg_io->status,
sg_io->masked_status,
sg_io->msg_status,
sg_io->sb_len_wr,
sg_io->sbp,
sg_io->host_status,
sg_io->driver_status,
sg_io->resid,
sg_io->duration);
sg_io->dxfer_direction = -3;
ioctl(-1, SG_IO, sg_io);
printf("ioctl(-1, SG_IO, {interface_id='S'"
", dxfer_direction=SG_DXFER_FROM_DEV"
", cmd_len=%u"
", cmdp=%p"
", mx_sb_len=%u"
", iovec_count=%u"
", dxfer_len=%u"
", timeout=%u"
", flags=SG_FLAG_DIRECT_IO|SG_FLAG_UNUSED_LUN_INHIBIT"
"|SG_FLAG_MMAP_IO|SG_FLAG_NO_DXFER"
"|SG_FLAG_Q_AT_TAIL|SG_FLAG_Q_AT_HEAD|0xfffeffc8"
", dxferp=%p"
", status=%#x"
", masked_status=%#x"
", msg_status=%#x"
", sb_len_wr=%u"
", sbp=%p"
", host_status=%#x"
", driver_status=%#x"
", resid=%d"
", duration=%u"
", info=SG_INFO_CHECK|SG_INFO_DIRECT_IO|SG_INFO_MIXED_IO|0xfffffff8"
"}) = -1 EBADF (%m)\n",
sg_io->cmd_len,
sg_io->cmdp,
sg_io->mx_sb_len,
sg_io->iovec_count,
sg_io->dxfer_len,
sg_io->timeout,
sg_io->dxferp,
sg_io->status,
sg_io->masked_status,
sg_io->msg_status,
sg_io->sb_len_wr,
sg_io->sbp,
sg_io->host_status,
sg_io->driver_status,
sg_io->resid,
sg_io->duration);
const struct iovec iov[] = {
{
.iov_base = (void *) efault - 2,
.iov_len = 2
}, {
.iov_base = (void *) efault - 3,
int
main(void)
{
const unsigned int size = get_page_size();
void *const page = tail_alloc(size);
init_magic(page, size);
struct rtc_time *rt = tail_alloc(sizeof(*rt));
init_magic(rt, sizeof(*rt));
struct rtc_wkalrm *wk = tail_alloc(sizeof(*wk));
init_magic(wk, sizeof(*wk));
struct rtc_pll_info *pll = tail_alloc(sizeof(*pll));
init_magic(pll, sizeof(*pll));
/* RTC_ALM_READ */
ioctl(-1, RTC_ALM_READ, 0);
printf("ioctl(-1, RTC_ALM_READ, NULL) = -1 EBADF (%m)\n");
ioctl(-1, RTC_ALM_READ, page);
printf("ioctl(-1, RTC_ALM_READ, %p) = -1 EBADF (%m)\n", page);
/* RTC_RD_TIME */
ioctl(-1, RTC_RD_TIME, 0);
printf("ioctl(-1, RTC_RD_TIME, NULL) = -1 EBADF (%m)\n");
ioctl(-1, RTC_RD_TIME, page);
printf("ioctl(-1, RTC_RD_TIME, %p) = -1 EBADF (%m)\n", page);
/* RTC_ALM_SET */
ioctl(-1, RTC_ALM_SET, 0);
printf("ioctl(-1, RTC_ALM_SET, NULL) = -1 EBADF (%m)\n");
ioctl(-1, RTC_ALM_SET, rt);
printf("ioctl(-1, RTC_ALM_SET, ");
print_rtc_time(rt);
errno = EBADF;
printf(") = -1 EBADF (%m)\n");
/* RTC_SET_TIME */
ioctl(-1, RTC_SET_TIME, 0);
printf("ioctl(-1, RTC_SET_TIME, NULL) = -1 EBADF (%m)\n");
ioctl(-1, RTC_SET_TIME, rt);
printf("ioctl(-1, RTC_SET_TIME, ");
print_rtc_time(rt);
errno = EBADF;
printf(") = -1 EBADF (%m)\n");
/* RTC_IRQP_SET */
ioctl(-1, RTC_IRQP_SET, lmagic);
printf("ioctl(-1, RTC_IRQP_SET, %lu) = -1 EBADF (%m)\n", lmagic);
/* RTC_EPOCH_SET */
ioctl(-1, RTC_EPOCH_SET, lmagic);
printf("ioctl(-1, RTC_EPOCH_SET, %lu) = -1 EBADF (%m)\n", lmagic);
/* RTC_IRQP_READ */
ioctl(-1, RTC_IRQP_READ, 0);
printf("ioctl(-1, RTC_IRQP_READ, NULL) = -1 EBADF (%m)\n");
ioctl(-1, RTC_IRQP_READ, page);
printf("ioctl(-1, RTC_IRQP_READ, %p) = -1 EBADF (%m)\n", page);
/* RTC_EPOCH_READ */
ioctl(-1, RTC_EPOCH_READ, 0);
printf("ioctl(-1, RTC_EPOCH_READ, NULL) = -1 EBADF (%m)\n");
ioctl(-1, RTC_EPOCH_READ, page);
printf("ioctl(-1, RTC_EPOCH_READ, %p) = -1 EBADF (%m)\n", page);
/* RTC_WKALM_RD */
ioctl(-1, RTC_WKALM_RD, 0);
printf("ioctl(-1, RTC_WKALM_RD, NULL) = -1 EBADF (%m)\n");
ioctl(-1, RTC_WKALM_RD, page);
printf("ioctl(-1, RTC_WKALM_RD, %p) = -1 EBADF (%m)\n", page);
/* RTC_WKALM_SET */
ioctl(-1, RTC_WKALM_SET, 0);
printf("ioctl(-1, RTC_WKALM_SET, NULL) = -1 EBADF (%m)\n");
ioctl(-1, RTC_WKALM_SET, wk);
printf("ioctl(-1, RTC_WKALM_SET, {enabled=%u, pending=%u, time=",
(unsigned) wk->enabled, (unsigned) wk->pending);
print_rtc_time(&wk->time);
errno = EBADF;
printf("}) = -1 EBADF (%m)\n");
/* RTC_PLL_GET */
ioctl(-1, RTC_PLL_GET, 0);
printf("ioctl(-1, RTC_PLL_GET, NULL) = -1 EBADF (%m)\n");
ioctl(-1, RTC_PLL_GET, page);
printf("ioctl(-1, RTC_PLL_GET, %p) = -1 EBADF (%m)\n", page);
/* RTC_PLL_SET */
ioctl(-1, RTC_PLL_SET, 0);
printf("ioctl(-1, RTC_PLL_SET, NULL) = -1 EBADF (%m)\n");
ioctl(-1, RTC_PLL_SET, pll);
printf("ioctl(-1, RTC_PLL_SET, {pll_ctrl=%d, pll_value=%d"
", pll_max=%d, pll_min=%d, pll_posmult=%d, pll_negmult=%d"
", pll_clock=%ld}) = -1 EBADF (%m)\n",
pll->pll_ctrl, pll->pll_value, pll->pll_max, pll->pll_min,
pll->pll_posmult, pll->pll_negmult, pll->pll_clock);
#ifdef RTC_VL_READ
/* RTC_VL_READ */
ioctl(-1, RTC_VL_READ, 0);
printf("ioctl(-1, RTC_VL_READ, NULL) = -1 EBADF (%m)\n");
ioctl(-1, RTC_VL_READ, page);
printf("ioctl(-1, RTC_VL_READ, %p) = -1 EBADF (%m)\n", page);
#endif
unsigned int i;
for (i = 0; i < ARRAY_SIZE(rtc_argless); ++i) {
ioctl(-1, (unsigned long) rtc_argless[i].val, lmagic);
printf("ioctl(-1, %s) = -1 EBADF (%m)\n", rtc_argless[i].str);
}
ioctl(-1, RTC_UIE_OFF, lmagic);
printf("ioctl(-1, %s) = -1 EBADF (%m)\n", "PHN_NOT_OH or RTC_UIE_OFF");
ioctl(-1, RTC_AIE_ON, lmagic);
#ifdef HPPA
printf("ioctl(-1, %s) = -1 EBADF (%m)\n", "PA_PERF_ON or RTC_AIE_ON");
#else
printf("ioctl(-1, %s) = -1 EBADF (%m)\n", "RTC_AIE_ON");
#endif
ioctl(-1, _IO(0x70, 0x40), lmagic);
printf("ioctl(-1, %s, %#lx) = -1 EBADF (%m)\n", "NVRAM_INIT", lmagic);
puts("+++ exited with 0 +++");
return 0;
}
int
main(void)
{
TEST_NULL_ARG(BLKBSZGET);
TEST_NULL_ARG(BLKBSZSET);
TEST_NULL_ARG(BLKFRAGET);
TEST_NULL_ARG(BLKGETSIZE);
TEST_NULL_ARG(BLKGETSIZE64);
TEST_NULL_ARG(BLKPG);
TEST_NULL_ARG(BLKRAGET);
TEST_NULL_ARG(BLKROGET);
TEST_NULL_ARG(BLKROSET);
TEST_NULL_ARG(BLKSECTGET);
TEST_NULL_ARG(BLKSECTGET);
TEST_NULL_ARG(BLKSSZGET);
#ifdef BLKALIGNOFF
TEST_NULL_ARG(BLKALIGNOFF);
#endif
#ifdef BLKDISCARD
TEST_NULL_ARG(BLKDISCARD);
#endif
#ifdef BLKDISCARDZEROES
TEST_NULL_ARG(BLKDISCARDZEROES);
#endif
#ifdef BLKIOMIN
TEST_NULL_ARG(BLKIOMIN);
#endif
#ifdef BLKIOOPT
TEST_NULL_ARG(BLKIOOPT);
#endif
#ifdef BLKPBSZGET
TEST_NULL_ARG(BLKPBSZGET);
#endif
#ifdef BLKROTATIONAL
TEST_NULL_ARG(BLKROTATIONAL);
#endif
#ifdef BLKSECDISCARD
TEST_NULL_ARG(BLKSECDISCARD);
#endif
#ifdef BLKZEROOUT
TEST_NULL_ARG(BLKZEROOUT);
#endif
#if defined BLKTRACESETUP && defined HAVE_STRUCT_BLK_USER_TRACE_SETUP
TEST_NULL_ARG(BLKTRACESETUP);
#endif
ioctl(-1, BLKRASET, lmagic);
printf("ioctl(-1, BLKRASET, %lu) = -1 EBADF (%m)\n", lmagic);
ioctl(-1, BLKFRASET, lmagic);
printf("ioctl(-1, BLKFRASET, %lu) = -1 EBADF (%m)\n", lmagic);
int *const val_int = tail_alloc(sizeof(*val_int));
*val_int = magic;
ioctl(-1, BLKROSET, val_int);
printf("ioctl(-1, BLKROSET, [%d]) = -1 EBADF (%m)\n", *val_int);
ioctl(-1, BLKBSZSET, val_int);
printf("ioctl(-1, BLKBSZSET, [%d]) = -1 EBADF (%m)\n", *val_int);
uint64_t *pair_int64 = tail_alloc(sizeof(*pair_int64) * 2);
pair_int64[0] = 0xdeadbeefbadc0dedULL;
pair_int64[1] = 0xfacefeedcafef00dULL;
#ifdef BLKDISCARD
ioctl(-1, BLKDISCARD, pair_int64);
printf("ioctl(-1, BLKDISCARD, [%" PRIu64 ", %" PRIu64 "])"
" = -1 EBADF (%m)\n", pair_int64[0], pair_int64[1]);
#endif
#ifdef BLKSECDISCARD
ioctl(-1, BLKSECDISCARD, pair_int64);
printf("ioctl(-1, BLKSECDISCARD, [%" PRIu64 ", %" PRIu64 "])"
" = -1 EBADF (%m)\n", pair_int64[0], pair_int64[1]);
#endif
#ifdef BLKZEROOUT
ioctl(-1, BLKZEROOUT, pair_int64);
printf("ioctl(-1, BLKZEROOUT, [%" PRIu64 ", %" PRIu64 "])"
" = -1 EBADF (%m)\n", pair_int64[0], pair_int64[1]);
#endif
struct blkpg_ioctl_arg *const blkpg = tail_alloc(sizeof(*blkpg));
blkpg->op = 3;
blkpg->flags = 0xdeadbeef;
blkpg->datalen = 0xbadc0ded;
blkpg->data = (void *) (unsigned long) 0xcafef00dfffffeedULL;
ioctl(-1, BLKPG, blkpg);
printf("ioctl(-1, BLKPG, {%s, flags=%d, datalen=%d"
", data=%#lx}) = -1 EBADF (%m)\n",
"BLKPG_RESIZE_PARTITION", blkpg->flags, blkpg->datalen,
(unsigned long) blkpg->data);
struct blkpg_partition *const bp = tail_alloc(sizeof(*bp));
bp->start = 0xfac1fed2dad3bef4ULL;
bp->length = 0xfac5fed6dad7bef8ULL;
bp->pno = magic;
memset(bp->devname, 'A', sizeof(bp->devname));
memset(bp->volname, 'B', sizeof(bp->volname));
blkpg->op = 1;
blkpg->data = bp;
ioctl(-1, BLKPG, blkpg);
printf("ioctl(-1, BLKPG, {%s, flags=%d, datalen=%d"
", data={start=%lld, length=%lld, pno=%d"
", devname=\"%.*s\", volname=\"%.*s\"}})"
" = -1 EBADF (%m)\n",
"BLKPG_ADD_PARTITION",
blkpg->flags, blkpg->datalen,
bp->start, bp->length, bp->pno,
(int) sizeof(bp->devname) - 1, bp->devname,
(int) sizeof(bp->volname) - 1, bp->volname);
#if defined BLKTRACESETUP && defined HAVE_STRUCT_BLK_USER_TRACE_SETUP
struct blk_user_trace_setup *const buts = tail_alloc(sizeof(*buts));
fill_memory(buts, sizeof(*buts));
ioctl(-1, BLKTRACESETUP, buts);
printf("ioctl(-1, BLKTRACESETUP, {act_mask=%hu, buf_size=%u, buf_nr=%u"
", start_lba=%" PRI__u64 ", end_lba=%" PRI__u64 ", pid=%u})"
" = -1 EBADF (%m)\n",
buts->act_mask, buts->buf_size, buts->buf_nr,
buts->start_lba, buts->end_lba, buts->pid);
#endif
unsigned int i;
for (i = 0; i < ARRAY_SIZE(block_argless); ++i) {
ioctl(-1, (unsigned long) block_argless[i].val, lmagic);
printf("ioctl(-1, %s) = -1 EBADF (%m)\n", block_argless[i].str);
}
ioctl(-1, _IOC(_IOC_READ, 0x12, 0xfe, 0xff), lmagic);
printf("ioctl(-1, %s, %#lx) = -1 EBADF (%m)\n",
"_IOC(_IOC_READ, 0x12, 0xfe, 0xff)", lmagic);
puts("+++ exited with 0 +++");
return 0;
}
int
main(void)
{
char bogus_special_str[sizeof(void *) * 2 + sizeof("0x")];
char bogus_addr_str[sizeof(void *) * 2 + sizeof("0x")];
char unterminated_str[sizeof(void *) * 2 + sizeof("0x")];
long rc;
struct fs_disk_quota *xdq = tail_alloc(sizeof(*xdq));
struct fs_quota_stat *xqstat = tail_alloc(sizeof(*xqstat));
struct fs_quota_statv *xqstatv = tail_alloc(sizeof(*xqstatv));
uint32_t *flags = tail_alloc(sizeof(*flags));
char *unterminated = tail_memdup(unterminated_data,
sizeof(unterminated_data));
snprintf(bogus_special_str, sizeof(bogus_special_str), "%p",
bogus_special);
snprintf(bogus_addr_str, sizeof(bogus_addr_str), "%p",
bogus_addr);
snprintf(unterminated_str, sizeof(unterminated_str), "%p",
unterminated);
/* Q_XQUOTAON */
*flags = 0xdeadbeef;
check_quota(CQF_ID_SKIP | CQF_ADDR_STR,
ARG_STR(QCMD(Q_XQUOTAON, USRQUOTA)),
ARG_STR("/dev/bogus/"), flags,
"[XFS_QUOTA_UDQ_ACCT|XFS_QUOTA_UDQ_ENFD"
"|XFS_QUOTA_GDQ_ACCT|XFS_QUOTA_GDQ_ENFD"
"|XFS_QUOTA_PDQ_ENFD|0xdeadbec0]");
rc = syscall(__NR_quotactl, QCMD(Q_XQUOTAON, 0xfacefeed), bogus_dev,
bogus_id, bogus_addr);
printf("quotactl(QCMD(Q_XQUOTAON, %#x /* ???QUOTA */)"
", %s, %p) = %s\n",
QCMD_TYPE(QCMD(Q_XQUOTAON, 0xfacefeed)),
bogus_dev_str, bogus_addr, sprintrc(rc));
/* Q_XQUOTAOFF */
check_quota(CQF_ID_SKIP | CQF_ADDR_STR,
ARG_STR(QCMD(Q_XQUOTAOFF, USRQUOTA)),
bogus_special, bogus_special_str,
bogus_addr, bogus_addr_str);
check_quota(CQF_ID_SKIP | CQF_ADDR_STR,
ARG_STR(QCMD(Q_XQUOTAOFF, GRPQUOTA)),
ARG_STR("/dev/bogus/"),
ARG_STR(NULL));
check_quota(CQF_ID_SKIP | CQF_ADDR_STR,
QCMD(Q_XQUOTAOFF, 3),
"QCMD(Q_XQUOTAOFF, 0x3 /* ???QUOTA */)",
ARG_STR("/dev/bogus/"), flags,
"[XFS_QUOTA_UDQ_ACCT|XFS_QUOTA_UDQ_ENFD"
"|XFS_QUOTA_GDQ_ACCT|XFS_QUOTA_GDQ_ENFD"
"|XFS_QUOTA_PDQ_ENFD|0xdeadbec0]");
/* Q_XGETQUOTA */
/* Trying our best to get successful result */
check_quota(CQF_ADDR_CB, ARG_STR(QCMD(Q_GETQUOTA, USRQUOTA)),
ARG_STR("/dev/sda1"), getuid(), xdq, print_xdisk_quota,
(intptr_t) 1);
check_quota(CQF_ADDR_CB, ARG_STR(QCMD(Q_GETQUOTA, GRPQUOTA)),
ARG_STR(NULL), -1, xdq, print_xdisk_quota, (intptr_t) 2);
/* Q_XGETNEXTQUOTA */
check_quota(CQF_ADDR_CB, ARG_STR(QCMD(Q_XGETNEXTQUOTA, USRQUOTA)),
ARG_STR("/dev/sda1"), 0, xdq, print_xdisk_quota,
(intptr_t) 1);
/* Q_XSETQLIM */
check_quota(CQF_NONE, ARG_STR(QCMD(Q_XSETQLIM, PRJQUOTA)),
bogus_special, bogus_special_str, 0, bogus_addr);
fill_memory_ex((char *) xdq, sizeof(*xdq), 0x8e);
check_quota(CQF_ADDR_CB, ARG_STR(QCMD(Q_XSETQLIM, PRJQUOTA)),
bogus_dev, bogus_dev_str, 3141592653U,
xdq, print_xdisk_quota, (intptr_t) 0);
/* Q_XGETQSTAT */
check_quota(CQF_ID_SKIP | CQF_ADDR_CB,
ARG_STR(QCMD(Q_XGETQSTAT, USRQUOTA)),
ARG_STR("/dev/sda1"), xqstat, print_xquota_stat, (intptr_t) 1);
check_quota(CQF_ID_SKIP | CQF_ADDR_CB,
ARG_STR(QCMD(Q_XGETQSTATV, PRJQUOTA)),
unterminated, unterminated_str,
xqstat + 1, print_xquota_stat, (intptr_t) 2);
/* Q_XGETQSTATV */
check_quota(CQF_ID_SKIP | CQF_ADDR_CB,
ARG_STR(QCMD(Q_XGETQSTAT, USRQUOTA)),
ARG_STR("/dev/sda1"), xqstatv, print_xquota_statv, 1);
check_quota(CQF_ID_SKIP | CQF_ADDR_CB,
ARG_STR(QCMD(Q_XGETQSTATV, GRPQUOTA)),
ARG_STR(NULL), xqstatv, print_xquota_statv, (intptr_t) 2);
/* Q_XQUOTARM */
check_quota(CQF_ID_SKIP | CQF_ADDR_STR,
ARG_STR(QCMD(Q_XQUOTARM, PRJQUOTA)),
bogus_special, bogus_special_str, ARG_STR(NULL));
check_quota(CQF_ID_SKIP,
ARG_STR(QCMD(Q_XQUOTARM, USRQUOTA)),
unterminated, unterminated_str, flags + 1);
*flags = 0xdeadbeef;
check_quota(CQF_ID_SKIP | CQF_ADDR_STR,
ARG_STR(QCMD(Q_XQUOTARM, GRPQUOTA)),
ARG_STR(NULL), flags,
"[XFS_USER_QUOTA|XFS_PROJ_QUOTA"
"|XFS_GROUP_QUOTA|0xdeadbee8]");
/* Q_XQUOTASYNC */
check_quota(CQF_ID_SKIP | CQF_ADDR_SKIP,
ARG_STR(QCMD(Q_XQUOTASYNC, USRQUOTA)),
bogus_special, bogus_special_str);
check_quota(CQF_ID_SKIP | CQF_ADDR_SKIP,
QCMD(Q_XQUOTASYNC, 0xfff),
"QCMD(Q_XQUOTASYNC, 0xff /* ???QUOTA */)",
ARG_STR(NULL));
puts("+++ exited with 0 +++");
return 0;
}
int
main(void)
{
static const kernel_ulong_t unknown_perf_cmd =
(kernel_ulong_t) 0xbadc0dedfeed24edULL;
static const kernel_ulong_t magic =
(kernel_ulong_t) 0xdeadbeefbadc0dedULL;
static const uint64_t magic64 = 0xfacefeeddeadc0deULL;
static const char str[] = STR16 STR16 STR16 STR16;
static struct {
unsigned int cmd;
const char *str;
} flag_iocs[] = {
{ ARG_STR(PERF_EVENT_IOC_ENABLE) },
{ ARG_STR(PERF_EVENT_IOC_DISABLE) },
{ ARG_STR(PERF_EVENT_IOC_RESET) },
};
TAIL_ALLOC_OBJECT_CONST_PTR(uint64_t, u64_ptr);
uint64_t *const u64_efault = u64_ptr + 1;
uint32_t *const u32_arr = tail_alloc(sizeof(uint32_t) * 4);
uint32_t *const u32_efault = u32_arr + 4;
char *const str_ptr = tail_memdup(str, sizeof(str));
char *const str_efault = str_ptr + sizeof(str);
TAIL_ALLOC_OBJECT_CONST_PTR(struct perf_event_attr, pea_ptr);
*u64_ptr = magic64;
fill_memory_ex(pea_ptr, sizeof(*pea_ptr), 0xaa, 0x55);
/* Unknown perf commands */
sys_ioctl(-1, unknown_perf_cmd, magic);
printf("ioctl(-1, _IOC(_IOC_READ|_IOC_WRITE%s, 0x24, %#x, %#x), "
"%#lx) = -1 EBADF (%m)\n",
_IOC_DIR((unsigned int) unknown_perf_cmd) & _IOC_NONE ?
"|_IOC_NONE" : "",
_IOC_NR((unsigned int) unknown_perf_cmd),
_IOC_SIZE((unsigned int) unknown_perf_cmd),
(unsigned long) magic);
sys_ioctl(-1, PERF_EVENT_IOC_MODIFY_ATTRIBUTES + 1, magic);
printf("ioctl(-1, _IOC(_IOC_WRITE, 0x24, %#x, %#x), %#lx)"
" = -1 EBADF (%m)\n",
(unsigned int) _IOC_NR(PERF_EVENT_IOC_MODIFY_ATTRIBUTES + 1),
(unsigned int) _IOC_SIZE(PERF_EVENT_IOC_MODIFY_ATTRIBUTES + 1),
(unsigned long) magic);
/* PERF_EVENT_IOC_{ENABLE,DISABLE,RESET} */
for (unsigned i = 0; i < ARRAY_SIZE(flag_iocs); i++) {
ioctl(-1, flag_iocs[i].cmd, 0);
printf("ioctl(-1, %s, 0) = -1 EBADF (%m)\n", flag_iocs[i].str);
ioctl(-1, flag_iocs[i].cmd, 1);
printf("ioctl(-1, %s, PERF_IOC_FLAG_GROUP) = -1 EBADF (%m)\n",
flag_iocs[i].str);
ioctl(-1, flag_iocs[i].cmd, 2);
printf("ioctl(-1, %s, 0x2 /* PERF_IOC_FLAG_??? */) "
"= -1 EBADF (%m)\n",
flag_iocs[i].str);
sys_ioctl(-1, flag_iocs[i].cmd, magic);
printf("ioctl(-1, %s, PERF_IOC_FLAG_GROUP|%#x) "
"= -1 EBADF (%m)\n",
flag_iocs[i].str, (unsigned int) magic & ~1U);
}
/* PERF_EVENT_IOC_REFRESH */
sys_ioctl(-1, PERF_EVENT_IOC_REFRESH, magic);
printf("ioctl(-1, PERF_EVENT_IOC_REFRESH, %d) = -1 EBADF (%m)\n",
(int) magic);
/* PERF_EVENT_IOC_PERIOD */
ioctl(-1, PERF_EVENT_IOC_PERIOD, NULL);
printf("ioctl(-1, PERF_EVENT_IOC_PERIOD, NULL) = -1 EBADF (%m)\n");
ioctl(-1, PERF_EVENT_IOC_PERIOD, u64_efault);
printf("ioctl(-1, PERF_EVENT_IOC_PERIOD, %p) = -1 EBADF (%m)\n",
u64_efault);
ioctl(-1, PERF_EVENT_IOC_PERIOD, u64_ptr);
printf("ioctl(-1, PERF_EVENT_IOC_PERIOD, [%" PRIu64 "])"
" = -1 EBADF (%m)\n",
magic64);
/* PERF_EVENT_IOC_SET_OUTPUT */
sys_ioctl(-1, PERF_EVENT_IOC_SET_OUTPUT, magic);
printf("ioctl(-1, PERF_EVENT_IOC_SET_OUTPUT, %d) = -1 EBADF (%m)\n",
(int) magic);
/* PERF_EVENT_IOC_SET_FILTER */
ioctl(-1, PERF_EVENT_IOC_SET_FILTER, NULL);
printf("ioctl(-1, PERF_EVENT_IOC_SET_FILTER, NULL) = -1 EBADF (%m)\n");
ioctl(-1, PERF_EVENT_IOC_SET_FILTER, str_efault);
printf("ioctl(-1, PERF_EVENT_IOC_SET_FILTER, %p) = -1 EBADF (%m)\n",
str_efault);
ioctl(-1, PERF_EVENT_IOC_SET_FILTER, str_ptr);
printf("ioctl(-1, PERF_EVENT_IOC_SET_FILTER, \"%.32s\"...)"
" = -1 EBADF (%m)\n",
str_ptr);
ioctl(-1, PERF_EVENT_IOC_SET_FILTER, str_ptr + 40);
printf("ioctl(-1, PERF_EVENT_IOC_SET_FILTER, \"%.32s\")"
" = -1 EBADF (%m)\n",
str_ptr + 40);
str_ptr[sizeof(str) - 1] = '0';
ioctl(-1, PERF_EVENT_IOC_SET_FILTER, str_ptr + 40);
printf("ioctl(-1, PERF_EVENT_IOC_SET_FILTER, %p)"
" = -1 EBADF (%m)\n",
str_ptr + 40);
/* PERF_EVENT_IOC_ID */
ioctl(-1, PERF_EVENT_IOC_ID, NULL);
printf("ioctl(-1, PERF_EVENT_IOC_ID, NULL) = -1 EBADF (%m)\n");
ioctl(-1, PERF_EVENT_IOC_ID, u64_efault);
printf("ioctl(-1, PERF_EVENT_IOC_ID, %p) = -1 EBADF (%m)\n",
u64_efault);
ioctl(-1, PERF_EVENT_IOC_ID, u64_ptr);
printf("ioctl(-1, PERF_EVENT_IOC_ID, %p) = -1 EBADF (%m)\n",
u64_ptr);
/* PERF_EVENT_IOC_SET_BPF */
sys_ioctl(-1, PERF_EVENT_IOC_SET_BPF, magic);
printf("ioctl(-1, PERF_EVENT_IOC_SET_BPF, %d) = -1 EBADF (%m)\n",
(int) magic);
/* PERF_EVENT_IOC_PAUSE_OUTPUT */
sys_ioctl(-1, PERF_EVENT_IOC_PAUSE_OUTPUT, magic);
printf("ioctl(-1, PERF_EVENT_IOC_PAUSE_OUTPUT, %lu) = -1 EBADF (%m)\n",
(unsigned long) magic);
/* PERF_EVENT_IOC_QUERY_BPF */
ioctl(-1, PERF_EVENT_IOC_QUERY_BPF, NULL);
printf("ioctl(-1, PERF_EVENT_IOC_QUERY_BPF, NULL) = -1 EBADF (%m)\n");
ioctl(-1, PERF_EVENT_IOC_QUERY_BPF, u32_efault);
printf("ioctl(-1, PERF_EVENT_IOC_QUERY_BPF, %p) = -1 EBADF (%m)\n",
u32_efault);
u32_arr[0] = 0xbadc0ded;
ioctl(-1, PERF_EVENT_IOC_QUERY_BPF, u32_arr);
printf("ioctl(-1, PERF_EVENT_IOC_QUERY_BPF, {ids_len=3134983661, ...})"
" = -1 EBADF (%m)\n");
/* PERF_EVENT_IOC_MODIFY_ATTRIBUTES */
ioctl(-1, PERF_EVENT_IOC_MODIFY_ATTRIBUTES, NULL);
printf("ioctl(-1, PERF_EVENT_IOC_MODIFY_ATTRIBUTES, NULL)"
" = -1 EBADF (%m)\n");
ioctl(-1, PERF_EVENT_IOC_MODIFY_ATTRIBUTES, pea_ptr + 1);
printf("ioctl(-1, PERF_EVENT_IOC_MODIFY_ATTRIBUTES, %p)"
" = -1 EBADF (%m)\n",
pea_ptr + 1);
printf("ioctl(-1, PERF_EVENT_IOC_MODIFY_ATTRIBUTES"
", {type=%#x /* PERF_TYPE_??? */"
", size=%#x /* PERF_ATTR_SIZE_??? */"
", config=%#llx, ...}) = -1 EBADF (%m)\n",
(unsigned int) pea_ptr->type,
(unsigned int) pea_ptr->size,
(unsigned long long) pea_ptr->config);
ioctl(-1, PERF_EVENT_IOC_MODIFY_ATTRIBUTES, pea_ptr);
puts("+++ exited with 0 +++");
return 0;
}
int
main(void)
{
skip_if_unavailable("/proc/self/fd/");
static const struct sockaddr_un addr = {
.sun_family = AF_UNIX,
.sun_path = TEST_SOCKET
};
struct sockaddr * const listen_sa = tail_memdup(&addr, sizeof(addr));
TAIL_ALLOC_OBJECT_CONST_PTR(socklen_t, len);
*len = offsetof(struct sockaddr_un, sun_path) + strlen(TEST_SOCKET) + 1;
if (*len > sizeof(addr))
*len = sizeof(addr);
int listen_fd = socket(AF_UNIX, SOCK_STREAM, 0);
if (listen_fd < 0)
perror_msg_and_skip("socket");
unsigned long listen_inode = inode_of_sockfd(listen_fd);
printf("socket(AF_UNIX, SOCK_STREAM, 0) = %d<socket:[%lu]>\n",
listen_fd, listen_inode);
(void) unlink(TEST_SOCKET);
if (bind(listen_fd, listen_sa, *len))
perror_msg_and_skip("bind");
printf("bind(%d<socket:[%lu]>, {sa_family=AF_UNIX, sun_path=\"%s\"}"
", %u) = 0\n",
listen_fd, listen_inode, TEST_SOCKET, (unsigned) *len);
if (listen(listen_fd, 1))
perror_msg_and_skip("listen");
printf("listen(%d<socket:[%lu]>, 1) = 0\n", listen_fd, listen_inode);
TAIL_ALLOC_OBJECT_CONST_PTR(unsigned int, optval);
*len = sizeof(*optval);
if (getsockopt(listen_fd, SOL_SOCKET, SO_PASSCRED, optval, len))
perror_msg_and_fail("getsockopt");
printf("getsockopt(%d<socket:[%lu]>, SOL_SOCKET, SO_PASSCRED"
", [%u], [%u]) = 0\n",
listen_fd, listen_inode, *optval, (unsigned) *len);
memset(listen_sa, 0, sizeof(addr));
*len = sizeof(addr);
if (getsockname(listen_fd, listen_sa, len))
perror_msg_and_fail("getsockname");
printf("getsockname(%d<socket:[%lu]>, {sa_family=AF_UNIX"
", sun_path=\"%s\"}, [%d->%d]) = 0\n", listen_fd, listen_inode,
TEST_SOCKET, (int) sizeof(addr), (int) *len);
int connect_fd = socket(AF_UNIX, SOCK_STREAM, 0);
if (connect_fd < 0)
perror_msg_and_fail("socket");
unsigned long connect_inode = inode_of_sockfd(connect_fd);
printf("socket(AF_UNIX, SOCK_STREAM, 0) = %d<socket:[%lu]>\n",
connect_fd, connect_inode);
if (connect(connect_fd, listen_sa, *len))
perror_msg_and_fail("connect");
printf("connect(%d<socket:[%lu]>, {sa_family=AF_UNIX"
", sun_path=\"%s\"}, %u) = 0\n",
connect_fd, connect_inode, TEST_SOCKET, (unsigned) *len);
struct sockaddr * const accept_sa = tail_alloc(sizeof(addr));
memset(accept_sa, 0, sizeof(addr));
*len = sizeof(addr);
int accept_fd = accept(listen_fd, accept_sa, len);
if (accept_fd < 0)
perror_msg_and_fail("accept");
unsigned long accept_inode = inode_of_sockfd(accept_fd);
printf("accept(%d<socket:[%lu]>, {sa_family=AF_UNIX}"
", [%d->%d]) = %d<socket:[%lu]>\n",
listen_fd, listen_inode,
(int) sizeof(addr), (int) *len,
accept_fd, accept_inode);
memset(listen_sa, 0, sizeof(addr));
*len = sizeof(addr);
if (getpeername(connect_fd, listen_sa, len))
perror_msg_and_fail("getpeername");
printf("getpeername(%d<socket:[%lu]>, {sa_family=AF_UNIX"
", sun_path=\"%s\"}, [%d->%d]) = 0\n", connect_fd, connect_inode,
TEST_SOCKET, (int) sizeof(addr), (int) *len);
char text[] = "text";
assert(sendto(connect_fd, text, sizeof(text) - 1, MSG_DONTWAIT, NULL, 0)
== sizeof(text) - 1);
printf("sendto(%d<socket:[%lu]>, \"%s\", %u, MSG_DONTWAIT"
", NULL, 0) = %u\n",
connect_fd, connect_inode, text,
(unsigned) sizeof(text) - 1, (unsigned) sizeof(text) - 1);
assert(close(connect_fd) == 0);
printf("close(%d<socket:[%lu]>) = 0\n", connect_fd, connect_inode);
assert(recvfrom(accept_fd, text, sizeof(text) - 1, MSG_DONTWAIT, NULL, NULL)
== sizeof(text) - 1);
printf("recvfrom(%d<socket:[%lu]>, \"%s\", %u, MSG_DONTWAIT"
", NULL, NULL) = %u\n",
accept_fd, accept_inode, text,
(unsigned) sizeof(text) - 1, (unsigned) sizeof(text) - 1);
assert(close(accept_fd) == 0);
printf("close(%d<socket:[%lu]>) = 0\n", accept_fd, accept_inode);
connect_fd = socket(AF_UNIX, SOCK_STREAM, 0);
if (connect_fd < 0)
perror_msg_and_fail("socket");
connect_inode = inode_of_sockfd(connect_fd);
printf("socket(AF_UNIX, SOCK_STREAM, 0) = %d<socket:[%lu]>\n",
connect_fd, connect_inode);
*optval = 1;
*len = sizeof(*optval);
if (setsockopt(connect_fd, SOL_SOCKET, SO_PASSCRED, optval, *len))
perror_msg_and_fail("setsockopt");
printf("setsockopt(%d<socket:[%lu]>, SOL_SOCKET, SO_PASSCRED"
", [%u], %u) = 0\n",
connect_fd, connect_inode, *optval, (unsigned) *len);
memset(listen_sa, 0, sizeof(addr));
*len = sizeof(addr);
if (getsockname(listen_fd, listen_sa, len))
perror_msg_and_fail("getsockname");
printf("getsockname(%d<socket:[%lu]>, {sa_family=AF_UNIX"
", sun_path=\"%s\"}, [%d->%d]) = 0\n",
listen_fd, listen_inode, TEST_SOCKET,
(int) sizeof(addr), (int) *len);
if (connect(connect_fd, listen_sa, *len))
perror_msg_and_fail("connect");
printf("connect(%d<socket:[%lu]>, {sa_family=AF_UNIX"
", sun_path=\"%s\"}, %u) = 0\n",
connect_fd, connect_inode, TEST_SOCKET, (unsigned) *len);
memset(accept_sa, 0, sizeof(addr));
*len = sizeof(addr);
accept_fd = accept(listen_fd, accept_sa, len);
if (accept_fd < 0)
perror_msg_and_fail("accept");
accept_inode = inode_of_sockfd(accept_fd);
const char * const sun_path1 =
((struct sockaddr_un *) accept_sa)->sun_path + 1;
printf("accept(%d<socket:[%lu]>, {sa_family=AF_UNIX"
", sun_path=@\"%s\"}, [%d->%d]) = %d<socket:[%lu]>\n",
listen_fd, listen_inode, sun_path1,
(int) sizeof(addr), (int) *len,
accept_fd, accept_inode);
memset(listen_sa, 0, sizeof(addr));
*len = sizeof(addr);
if (getpeername(connect_fd, listen_sa, len))
perror_msg_and_fail("getpeername");
printf("getpeername(%d<socket:[%lu]>, {sa_family=AF_UNIX"
", sun_path=\"%s\"}, [%d->%d]) = 0\n",
connect_fd, connect_inode, TEST_SOCKET,
(int) sizeof(addr), (int) *len);
memset(accept_sa, 0, sizeof(addr));
*len = sizeof(addr);
if (getsockname(connect_fd, accept_sa, len))
perror_msg_and_fail("getsockname");
printf("getsockname(%d<socket:[%lu]>, {sa_family=AF_UNIX"
", sun_path=@\"%s\"}, [%d->%d]) = 0\n",
connect_fd, connect_inode, sun_path1,
(int) sizeof(addr), (int) *len);
assert(sendto(connect_fd, text, sizeof(text) - 1, MSG_DONTWAIT, NULL, 0)
== sizeof(text) - 1);
printf("sendto(%d<socket:[%lu]>, \"%s\", %u, MSG_DONTWAIT"
", NULL, 0) = %u\n",
connect_fd, connect_inode, text,
(unsigned) sizeof(text) - 1, (unsigned) sizeof(text) - 1);
assert(close(connect_fd) == 0);
printf("close(%d<socket:[%lu]>) = 0\n", connect_fd, connect_inode);
assert(recvfrom(accept_fd, text, sizeof(text) - 1, MSG_DONTWAIT, NULL, NULL)
== sizeof(text) - 1);
printf("recvfrom(%d<socket:[%lu]>, \"%s\", %u, MSG_DONTWAIT"
", NULL, NULL) = %u\n",
accept_fd, accept_inode, text,
(unsigned) sizeof(text) - 1, (unsigned) sizeof(text) - 1);
assert(close(accept_fd) == 0);
printf("close(%d<socket:[%lu]>) = 0\n", accept_fd, accept_inode);
assert(unlink(TEST_SOCKET) == 0);
assert(close(listen_fd) == 0);
printf("close(%d<socket:[%lu]>) = 0\n",
listen_fd, listen_inode);
puts("+++ exited with 0 +++");
return 0;
}
int
main(void)
{
(void) close(0);
if (open("/dev/null", O_WRONLY))
perror_msg_and_fail("open");
char *buf = tail_alloc(LEN);
unsigned i;
for (i = 0; i < LEN; ++i)
buf[i] = i;
struct iovec *iov = tail_alloc(sizeof(*iov) * LEN);
for (i = 0; i < LEN; ++i) {
buf[i] = i;
iov[i].iov_base = &buf[i];
iov[i].iov_len = LEN - i;
}
const off_t offset = 0xdefaceddeadbeefLL;
long rc;
int written = 0;
for (i = 0; i < LEN; ++i) {
written += iov[i].iov_len;
if (pwritev(0, iov, i + 1, offset + i) != written)
perror_msg_and_fail("pwritev");
fputs("pwritev(0, ", stdout);
print_iovec(iov, i + 1, LEN);
printf(", %u, %lld) = %d\n",
i + 1, (long long) offset + i, written);
}
for (i = 0; i <= LEN; ++i) {
unsigned int n = LEN + 1 - i;
fputs("pwritev(0, ", stdout);
print_iovec(iov + i, n, LEN - i);
rc = pwritev(0, iov + i, n, offset + LEN + i);
printf(", %u, %lld) = %ld %s (%m)\n",
n, (long long) offset + LEN + i, rc, errno2name());
}
iov->iov_base = iov + LEN * 2;
rc = pwritev(0, iov, 1, -1);
printf("pwritev(0, [{%p, %d}], 1, -1) = %ld %s (%m)\n",
iov->iov_base, LEN, rc, errno2name());
iov += LEN;
rc = pwritev(0, iov, 42, -2);
printf("pwritev(0, %p, 42, -2) = %ld %s (%m)\n",
iov, rc, errno2name());
rc = pwritev(0, NULL, 1, -3);
printf("pwritev(0, NULL, 1, -3) = %ld %s (%m)\n",
rc, errno2name());
rc = pwritev(0, iov, 0, -4);
printf("pwritev(0, [], 0, -4) = %ld %s (%m)\n",
rc, errno2name());
puts("+++ exited with 0 +++");
return 0;
}
int
main(void)
{
tprintf("%s", "");
const unsigned int big_size = 1024 / 8;
unsigned int set_size;
for (set_size = big_size; set_size; set_size >>= 1) {
if (!k_sigprocmask(SIG_SETMASK, NULL, NULL, set_size))
break;
tprintf("rt_sigprocmask(SIG_SETMASK, NULL, NULL, %u)"
" = -1 EINVAL (%m)\n", set_size);
}
if (!set_size)
perror_msg_and_fail("rt_sigprocmask");
tprintf("rt_sigprocmask(SIG_SETMASK, NULL, NULL, %u) = 0\n",
set_size);
void *const k_set = tail_alloc(set_size);
void *const old_set = tail_alloc(set_size);
sigset_t *const libc_set = tail_alloc(sizeof(sigset_t));
memset(k_set, 0, set_size);
if (k_sigprocmask(SIG_SETMASK, k_set, NULL, set_size))
perror_msg_and_fail("rt_sigprocmask");
tprintf("rt_sigprocmask(SIG_SETMASK, [], NULL, %u) = 0\n", set_size);
if (k_sigprocmask(SIG_UNBLOCK, k_set - set_size, old_set, set_size))
perror_msg_and_fail("rt_sigprocmask");
tprintf("rt_sigprocmask(SIG_UNBLOCK, ~[], [], %u) = 0\n", set_size);
assert(k_sigprocmask(SIG_SETMASK, k_set - set_size,
old_set, set_size << 1) == -1);
tprintf("rt_sigprocmask(SIG_SETMASK, %p, %p, %u) = -1 EINVAL (%m)\n",
k_set - set_size, old_set, set_size << 1);
iterate("~[]", k_set - set_size, old_set, set_size >> 1);
sigemptyset(libc_set);
sigaddset(libc_set, SIGHUP);
memcpy(k_set, libc_set, set_size);
if (k_sigprocmask(SIG_BLOCK, k_set, old_set, set_size))
perror_msg_and_fail("rt_sigprocmask");
tprintf("rt_sigprocmask(SIG_BLOCK, [HUP], [], %u) = 0\n", set_size);
memset(libc_set, -1, sizeof(sigset_t));
sigdelset(libc_set, SIGHUP);
memcpy(k_set, libc_set, set_size);
if (k_sigprocmask(SIG_UNBLOCK, k_set, old_set, set_size))
perror_msg_and_fail("rt_sigprocmask");
tprintf("rt_sigprocmask(SIG_UNBLOCK, ~[HUP], [HUP], %u) = 0\n",
set_size);
sigdelset(libc_set, SIGKILL);
memcpy(k_set, libc_set, set_size);
if (k_sigprocmask(SIG_UNBLOCK, k_set, old_set, set_size))
perror_msg_and_fail("rt_sigprocmask");
tprintf("rt_sigprocmask(SIG_UNBLOCK, ~[HUP KILL], [HUP], %u) = 0\n",
set_size);
sigemptyset(libc_set);
sigaddset(libc_set, SIGHUP);
sigaddset(libc_set, SIGINT);
sigaddset(libc_set, SIGQUIT);
sigaddset(libc_set, SIGALRM);
sigaddset(libc_set, SIGTERM);
memcpy(k_set, libc_set, set_size);
if (k_sigprocmask(SIG_BLOCK, k_set, old_set, set_size))
perror_msg_and_fail("rt_sigprocmask");
tprintf("rt_sigprocmask(SIG_BLOCK, %s, [HUP], %u) = 0\n",
"[HUP INT QUIT ALRM TERM]", set_size);
if (k_sigprocmask(SIG_SETMASK, NULL, old_set, set_size))
perror_msg_and_fail("rt_sigprocmask");
tprintf("rt_sigprocmask(SIG_SETMASK, NULL, %s, %u) = 0\n",
"[HUP INT QUIT ALRM TERM]", set_size);
assert(k_sigprocmask(SIG_SETMASK, k_set + (set_size >> 1), NULL,
set_size) == -1);
tprintf("rt_sigprocmask(SIG_SETMASK, %p, NULL, %u) = -1 EFAULT (%m)\n",
k_set + (set_size >> 1), set_size);
assert(k_sigprocmask(SIG_SETMASK, k_set, old_set + (set_size >> 1),
set_size) == -1);
tprintf("rt_sigprocmask(SIG_SETMASK, %s, %p, %u) = -1 EFAULT (%m)\n",
"[HUP INT QUIT ALRM TERM]",
old_set + (set_size >> 1), set_size);
tprintf("+++ exited with 0 +++\n");
return 0;
}
