/*
* semaphore_posix_thrash()
* exercise the semaphore
*/
static void *semaphore_posix_thrash(void *arg)
{
const pthread_args_t *p_args = arg;
const args_t *args = p_args->args;
static void *nowt = NULL;
do {
int i;
for (i = 0; g_keep_stressing_flag && i < 1000; i++) {
if (sem_trywait(&sem) < 0) {
if (errno == 0 || errno == EAGAIN)
continue;
if (errno != EINTR)
pr_fail_dbg("sem_trywait");
break;
}
inc_counter(args);
if (sem_post(&sem) < 0) {
pr_fail_dbg("sem_post");
break;
}
if (i & 1)
(void)shim_sched_yield();
else
(void)shim_usleep(0);
}
} while (keep_stressing());
return &nowt;
}
/*
* main syscall ptrace loop
*/
static inline bool stress_syscall_wait(
const args_t *args,
const pid_t pid)
{
while (g_keep_stressing_flag) {
int status;
if (ptrace(PTRACE_SYSCALL, pid, 0, 0) < 0) {
pr_fail_dbg("ptrace");
return true;
}
if (shim_waitpid(pid, &status, 0) < 0) {
if (errno != EINTR)
pr_fail_dbg("waitpid");
return true;
}
if (WIFSTOPPED(status) &&
(WSTOPSIG(status) & 0x80))
return false;
if (WIFEXITED(status))
return true;
}
return true;
}
/*
* semaphore_posix_thrash()
* exercise the semaphore
*/
static void semaphore_posix_thrash(
const char *name,
const uint64_t max_ops,
uint64_t *counter)
{
do {
int i;
struct timespec timeout;
if (clock_gettime(CLOCK_REALTIME, &timeout) < 0) {
pr_fail_dbg(name, "clock_gettime");
return;
}
timeout.tv_sec++;
for (i = 0; i < 1000; i++) {
if (sem_timedwait(&shared->sem_posix.sem, &timeout) < 0) {
if (errno == ETIMEDOUT)
goto timed_out;
if (errno != EINTR)
pr_fail_dbg(name, "sem_wait");
break;
}
(*counter)++;
if (sem_post(&shared->sem_posix.sem) < 0) {
pr_fail_dbg(name, "sem_post");
break;
}
timed_out:
if (!opt_do_run)
break;
}
} while (opt_do_run && (!max_ops || *counter < max_ops));
}
/*
* stress_epoll
* stress by heavy socket I/O
*/
int stress_epoll(
uint64_t *const counter,
const uint32_t instance,
const uint64_t max_ops,
const char *name)
{
pid_t pids[MAX_SERVERS], ppid = getppid();
int i, rc = EXIT_SUCCESS;
if (max_servers == 1) {
pr_dbg(stderr, "%s: process [%d] using socket port %d\n",
name, getpid(),
opt_epoll_port + instance);
} else {
pr_dbg(stderr, "%s: process [%d] using socket ports %d..%d\n",
name, getpid(),
opt_epoll_port + (max_servers * instance),
opt_epoll_port + (max_servers * (instance + 1)) - 1);
}
/*
* Spawn off servers to handle multi port connections.
* The (src address, src port, dst address, dst port) tuple
* is kept in the connection table for a default of 60 seconds
* which means for many fast short connections we can
* fill this table up and new connections get blocked until
* this table empties. One strategy is to reduce TIME_WAIT (not
* good) so the easiest way forward is to just increase the
* number of ports being listened to to increase the tuple
* range and hence allow more connections. See
* http://vincent.bernat.im/en/blog/2014-tcp-time-wait-state-linux.html
* Typically, we are limited to ~500 connections per second
* on a default Linux configuration.
*/
memset(pids, 0, sizeof(pids));
for (i = 0; i < max_servers; i++) {
pids[i] = epoll_spawn(epoll_server, i, counter, instance, max_ops, name, ppid);
if (pids[i] < 0) {
pr_fail_dbg(name, "fork");
goto reap;
}
}
epoll_client(counter, instance, max_ops, name, ppid);
reap:
for (i = 0; i < max_servers; i++) {
int status;
if (pids[i] > 0) {
(void)kill(pids[i], SIGKILL);
if (waitpid(pids[i], &status, 0) < 0) {
pr_fail_dbg(name, "waitpid");
}
}
}
return rc;
}
/*
* stress_wait
* stress wait*() family of calls
*/
int stress_wait(
uint64_t *const counter,
const uint32_t instance,
const uint64_t max_ops,
const char *name)
{
int status, ret = EXIT_SUCCESS;
pid_t pid_r, pid_k;
(void)instance;
pr_dbg(stderr, "%s: waiter started [%d]\n",
name, getpid());
pid_r = spawn(name, runner, 0, counter, max_ops);
if (pid_r < 0) {
pr_fail_dbg(name, "fork");
exit(EXIT_FAILURE);
}
pid_k = spawn(name, killer, pid_r, counter, max_ops);
if (pid_k < 0) {
pr_fail_dbg(name, "fork");
ret = EXIT_FAILURE;
goto tidy;
}
do {
(void)waitpid(pid_r, &status, WCONTINUED);
if (!opt_do_run)
break;
if (WIFCONTINUED(status))
(*counter)++;
#if _SVID_SOURCE || _XOPEN_SOURCE >= 500 || \
_XOPEN_SOURCE && _XOPEN_SOURCE_EXTENDED || \
_POSIX_C_SOURCE >= 200809L
{
siginfo_t info;
(void)waitid(P_PID, pid_r, &info, WCONTINUED);
if (!opt_do_run)
break;
if (WIFCONTINUED(status))
(*counter)++;
}
#endif
} while (opt_do_run && (!max_ops || *counter < max_ops));
(void)kill(pid_k, SIGKILL);
(void)waitpid(pid_k, &status, 0);
tidy:
(void)kill(pid_r, SIGKILL);
(void)waitpid(pid_r, &status, 0);
return ret;
}
/*
* stress_lsearch()
* stress lsearch
*/
static int stress_lsearch(const args_t *args)
{
int32_t *data, *root;
size_t i, max;
uint64_t lsearch_size = DEFAULT_LSEARCH_SIZE;
if (!get_setting("lsearch-size", &lsearch_size)) {
if (g_opt_flags & OPT_FLAGS_MAXIMIZE)
lsearch_size = MAX_LSEARCH_SIZE;
if (g_opt_flags & OPT_FLAGS_MINIMIZE)
lsearch_size = MIN_LSEARCH_SIZE;
}
max = (size_t)lsearch_size;
if ((data = calloc(max, sizeof(*data))) == NULL) {
pr_fail_dbg("malloc");
return EXIT_NO_RESOURCE;
}
if ((root = calloc(max, sizeof(*data))) == NULL) {
free(data);
pr_fail_dbg("malloc");
return EXIT_NO_RESOURCE;
}
do {
size_t n = 0;
/* Step #1, populate with data */
for (i = 0; g_keep_stressing_flag && i < max; i++) {
void *ptr;
data[i] = ((mwc32() & 0xfff) << 20) ^ i;
ptr = lsearch(&data[i], root, &n, sizeof(*data), cmp);
(void)ptr;
}
/* Step #2, find */
for (i = 0; g_keep_stressing_flag && i < n; i++) {
int32_t *result;
result = lfind(&data[i], root, &n, sizeof(*data), cmp);
if (g_opt_flags & OPT_FLAGS_VERIFY) {
if (result == NULL)
pr_fail("%s: element %zu could not be found\n", args->name, i);
else if (*result != data[i])
pr_fail("%s: element %zu found %" PRIu32 ", expecting %" PRIu32 "\n",
args->name, i, *result, data[i]);
}
}
inc_counter(args);
} while (keep_stressing());
free(root);
free(data);
return EXIT_SUCCESS;
}
/*
* stress_vm_rw
* stress vm_read_v/vm_write_v
*/
int stress_vm_rw(
uint64_t *const counter,
const uint32_t instance,
const uint64_t max_ops,
const char *name)
{
context_t ctxt;
uint8_t stack[64*1024];
const ssize_t stack_offset =
stress_get_stack_direction(&ctxt) * (STACK_SIZE - 64);
uint8_t *stack_top = stack + stack_offset;
(void)instance;
if (!set_vm_rw_bytes) {
if (opt_flags & OPT_FLAGS_MAXIMIZE)
opt_vm_rw_bytes = MAX_VM_RW_BYTES;
if (opt_flags & OPT_FLAGS_MINIMIZE)
opt_vm_rw_bytes = MIN_VM_RW_BYTES;
}
ctxt.name = name;
ctxt.page_size = stress_get_pagesize();
ctxt.sz = opt_vm_rw_bytes & ~(ctxt.page_size - 1);
ctxt.counter = counter;
ctxt.max_ops = max_ops;
if (pipe(ctxt.pipe_wr) < 0) {
pr_fail_dbg(name, "pipe");
return EXIT_FAILURE;
}
if (pipe(ctxt.pipe_rd) < 0) {
(void)close(ctxt.pipe_wr[0]);
(void)close(ctxt.pipe_wr[1]);
pr_fail_dbg(name, "pipe");
return EXIT_FAILURE;
}
ctxt.pid = clone(stress_vm_child, align_stack(stack_top),
SIGCHLD | CLONE_VM, &ctxt);
if (ctxt.pid < 0) {
(void)close(ctxt.pipe_wr[0]);
(void)close(ctxt.pipe_wr[1]);
(void)close(ctxt.pipe_rd[0]);
(void)close(ctxt.pipe_rd[1]);
pr_fail_dbg(name, "clone");
return EXIT_FAILURE;
}
return stress_vm_parent(&ctxt);
}
/*
* stress_daemon()
* stress by multiple daemonizing forks
*/
int stress_daemon(
uint64_t *const counter,
const uint32_t instance,
const uint64_t max_ops,
const char *name)
{
int fds[2];
pid_t pid;
(void)instance;
if (pipe(fds) < 0) {
pr_fail_dbg(name, "pipe");
return EXIT_FAILURE;
}
pid = fork();
if (pid < 0) {
pr_fail_dbg(name, "fork");
(void)close(fds[0]);
(void)close(fds[1]);
return EXIT_FAILURE;
} else if (pid == 0) {
/* Children */
(void)close(fds[0]);
daemons(fds[1]);
(void)close(fds[1]);
} else {
/* Parent */
(void)close(fds[1]);
do {
ssize_t n;
char buf[1];
n = read(fds[0], buf, sizeof(buf));
if (n < 0) {
(void)close(fds[0]);
if (errno != EINTR) {
pr_dbg(stderr, "read failed: errno=%d (%s)\n",
errno, strerror(errno));
}
break;
}
(*counter)++;
} while (opt_do_run && (!max_ops || *counter < max_ops));
}
return EXIT_SUCCESS;
}
/*
* stress_socket
* stress by heavy socket I/O
*/
int stress_socket(
uint64_t *const counter,
const uint32_t instance,
const uint64_t max_ops,
const char *name)
{
pid_t pid, ppid = getppid();
pr_dbg(stderr, "%s: process [%d] using socket port %d\n",
name, getpid(), opt_socket_port + instance);
again:
pid = fork();
if (pid < 0) {
if (opt_do_run && (errno == EAGAIN))
goto again;
pr_fail_dbg(name, "fork");
return EXIT_FAILURE;
} else if (pid == 0) {
stress_socket_client(counter, instance, max_ops, name, ppid);
exit(EXIT_SUCCESS);
} else {
return stress_socket_server(counter, instance, max_ops, name, pid, ppid);
}
}
/*
* stress_sigq
* stress by heavy sigqueue message sending
*/
static int stress_sigq(const args_t *args)
{
pid_t pid;
if (stress_sighandler(args->name, SIGUSR1, stress_sigqhandler, NULL) < 0)
return EXIT_FAILURE;
again:
pid = fork();
if (pid < 0) {
if (g_keep_stressing_flag && (errno == EAGAIN))
goto again;
pr_fail_dbg("fork");
return EXIT_FAILURE;
} else if (pid == 0) {
sigset_t mask;
(void)setpgid(0, g_pgrp);
stress_parent_died_alarm();
(void)sigemptyset(&mask);
(void)sigaddset(&mask, SIGUSR1);
while (g_keep_stressing_flag) {
siginfo_t info;
if (sigwaitinfo(&mask, &info) < 0)
break;
if (info.si_value.sival_int)
break;
}
pr_dbg("%s: child got termination notice\n", args->name);
pr_dbg("%s: exited on pid [%d] (instance %" PRIu32 ")\n",
args->name, (int)getpid(), args->instance);
_exit(0);
} else {
/* Parent */
union sigval s;
int status;
do {
(void)memset(&s, 0, sizeof(s));
s.sival_int = 0;
(void)sigqueue(pid, SIGUSR1, s);
inc_counter(args);
} while (keep_stressing());
pr_dbg("%s: parent sent termination notice\n", args->name);
(void)memset(&s, 0, sizeof(s));
s.sival_int = 1;
(void)sigqueue(pid, SIGUSR1, s);
(void)shim_usleep(250);
/* And ensure child is really dead */
(void)kill(pid, SIGKILL);
(void)shim_waitpid(pid, &status, 0);
}
return EXIT_SUCCESS;
}
/*
* stress_socket_pair
* stress by heavy socket_pair I/O
*/
int stress_socket_pair(
uint64_t *const counter,
const uint32_t instance,
const uint64_t max_ops,
const char *name)
{
pid_t pid;
int socket_pair_fds[MAX_SOCKET_PAIRS][2], i, max;
(void)instance;
for (max = 0; max < MAX_SOCKET_PAIRS; max++) {
if (socketpair(AF_UNIX, SOCK_STREAM, 0, socket_pair_fds[max]) < 0)
break;
}
if (max == 0) {
pr_fail_dbg(name, "socket_pair");
return EXIT_FAILURE;
}
again:
pid = fork();
if (pid < 0) {
if (opt_do_run && (errno == EAGAIN))
goto again;
socket_pair_close(socket_pair_fds, max, 0);
socket_pair_close(socket_pair_fds, max, 1);
pr_fail_dbg(name, "fork");
return EXIT_FAILURE;
} else if (pid == 0) {
setpgid(0, pgrp);
stress_parent_died_alarm();
socket_pair_close(socket_pair_fds, max, 1);
while (opt_do_run) {
uint8_t buf[SOCKET_PAIR_BUF];
ssize_t n;
for (i = 0; opt_do_run && (i < max); i++) {
n = read(socket_pair_fds[i][0], buf, sizeof(buf));
if (n <= 0) {
if ((errno == EAGAIN) || (errno == EINTR))
continue;
if (errno == ENFILE) /* Too many files! */
goto abort;
if (errno == EMFILE) /* Occurs on socket shutdown */
goto abort;
if (errno) {
pr_fail_dbg(name, "read");
break;
}
continue;
}
if ((opt_flags & OPT_FLAGS_VERIFY) &&
socket_pair_memchk(buf, (size_t)n)) {
pr_fail(stderr, "%s: socket_pair read error detected, "
"failed to read expected data\n", name);
}
}
}
abort:
socket_pair_close(socket_pair_fds, max, 0);
exit(EXIT_SUCCESS);
} else {
uint8_t buf[SOCKET_PAIR_BUF];
int val = 0, status;
setpgid(pid, pgrp);
/* Parent */
socket_pair_close(socket_pair_fds, max, 0);
do {
for (i = 0; opt_do_run && (i < max); i++) {
ssize_t ret;
socket_pair_memset(buf, val++, sizeof(buf));
ret = write(socket_pair_fds[i][1], buf, sizeof(buf));
if (ret <= 0) {
if ((errno == EAGAIN) || (errno == EINTR))
continue;
if (errno) {
pr_fail_dbg(name, "write");
break;
}
continue;
}
(*counter)++;
}
} while (opt_do_run && (!max_ops || *counter < max_ops));
for (i = 0; i < max; i++) {
if (shutdown(socket_pair_fds[i][1], SHUT_RDWR) < 0)
pr_fail_dbg(name, "socket shutdown");
}
(void)kill(pid, SIGKILL);
(void)waitpid(pid, &status, 0);
socket_pair_close(socket_pair_fds, max, 1);
}
return EXIT_SUCCESS;
}
int stress_vm_parent(context_t *ctxt)
{
/* Parent */
int status;
uint8_t val = 0;
uint8_t *localbuf;
addr_msg_t msg_rd, msg_wr;
setpgid(ctxt->pid, pgrp);
localbuf = mmap(NULL, ctxt->sz, PROT_READ | PROT_WRITE,
MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
if (localbuf == MAP_FAILED) {
(void)close(ctxt->pipe_wr[0]);
(void)close(ctxt->pipe_wr[1]);
(void)close(ctxt->pipe_rd[0]);
(void)close(ctxt->pipe_rd[1]);
pr_fail_dbg(ctxt->name, "mmap");
return EXIT_FAILURE;
}
/* Close unwanted ends */
(void)close(ctxt->pipe_wr[1]);
(void)close(ctxt->pipe_rd[0]);
do {
struct iovec local[1], remote[1];
uint8_t *ptr, *end = localbuf + ctxt->sz;
int ret;
/* Wait for address of child's buffer */
redo_rd2:
if (!opt_do_run)
break;
ret = read(ctxt->pipe_wr[0], &msg_rd, sizeof(msg_rd));
if (ret < 0) {
if ((errno == EAGAIN) || (errno == EINTR))
goto redo_rd2;
pr_fail_dbg(ctxt->name, "read");
break;
}
if (ret == 0)
break;
if (ret != sizeof(msg_rd)) {
pr_fail_dbg(ctxt->name, "read");
break;
}
/* Child telling us it's terminating? */
if (!msg_rd.addr)
break;
/* Perform read from child's memory */
local[0].iov_base = localbuf;
local[0].iov_len = ctxt->sz;
remote[0].iov_base = msg_rd.addr;
remote[0].iov_len = ctxt->sz;
if (process_vm_readv(ctxt->pid, local, 1, remote, 1, 0) < 0) {
pr_fail_dbg(ctxt->name, "process_vm_readv");
break;
}
if (opt_flags & OPT_FLAGS_VERIFY) {
/* Check data is sane */
for (ptr = localbuf; ptr < end; ptr += ctxt->page_size) {
if (*ptr) {
pr_fail(stderr, "%s: memory at %p: %d vs %d\n",
ctxt->name, ptr, *ptr, msg_rd.val);
goto fail;
}
*ptr = 0;
}
/* Set memory */
for (ptr = localbuf; ptr < end; ptr += ctxt->page_size)
*ptr = val;
}
/* Write to child's memory */
msg_wr = msg_rd;
local[0].iov_base = localbuf;
local[0].iov_len = ctxt->sz;
remote[0].iov_base = msg_rd.addr;
remote[0].iov_len = ctxt->sz;
if (process_vm_writev(ctxt->pid, local, 1, remote, 1, 0) < 0) {
pr_fail_dbg(ctxt->name, "process_vm_writev");
break;
}
msg_wr.val = val;
val++;
redo_wr2:
if (!opt_do_run)
break;
/* Inform child that memory has been changed */
ret = write(ctxt->pipe_rd[1], &msg_wr, sizeof(msg_wr));
if (ret < 0) {
if ((errno == EAGAIN) || (errno == EINTR))
goto redo_wr2;
if (errno != EBADF)
pr_fail_dbg(ctxt->name, "write");
break;
}
(*ctxt->counter)++;
} while (opt_do_run && (!ctxt->max_ops || *ctxt->counter < ctxt->max_ops));
fail:
/* Tell child we're done */
msg_wr.addr = NULL;
msg_wr.val = 0;
if (write(ctxt->pipe_wr[0], &msg_wr, sizeof(msg_wr)) < 0) {
if (errno != EBADF)
pr_dbg(stderr, "%s: failed to write "
"termination message "
"over pipe: errno=%d (%s)\n",
ctxt->name, errno, strerror(errno));
}
(void)close(ctxt->pipe_wr[0]);
(void)close(ctxt->pipe_rd[1]);
(void)kill(ctxt->pid, SIGKILL);
(void)waitpid(ctxt->pid, &status, 0);
(void)munmap(localbuf, ctxt->sz);
return EXIT_SUCCESS;
}
/*
* stress_tsearch()
* stress tsearch
*/
static int stress_tsearch(const args_t *args)
{
uint64_t tsearch_size = DEFAULT_TSEARCH_SIZE;
int32_t *data;
size_t i, n;
if (!get_setting("tsearch-size", &tsearch_size)) {
if (g_opt_flags & OPT_FLAGS_MAXIMIZE)
tsearch_size = MAX_TSEARCH_SIZE;
if (g_opt_flags & OPT_FLAGS_MINIMIZE)
tsearch_size = MIN_TSEARCH_SIZE;
}
n = (size_t)tsearch_size;
if ((data = calloc(n, sizeof(*data))) == NULL) {
pr_fail_dbg("calloc");
return EXIT_NO_RESOURCE;
}
do {
void *root = NULL;
/* Step #1, populate tree */
for (i = 0; i < n; i++) {
data[i] = ((mwc32() & 0xfff) << 20) ^ i;
if (tsearch(&data[i], &root, cmp) == NULL) {
size_t j;
pr_err("%s: cannot allocate new "
"tree node\n", args->name);
for (j = 0; j < i; j++)
tdelete(&data[j], &root, cmp);
goto abort;
}
}
/* Step #2, find */
for (i = 0; g_keep_stressing_flag && i < n; i++) {
void **result;
result = tfind(&data[i], &root, cmp);
if (g_opt_flags & OPT_FLAGS_VERIFY) {
if (result == NULL)
pr_fail("%s: element %zu "
"could not be found\n",
args->name, i);
else {
int32_t *val;
val = *result;
if (*val != data[i])
pr_fail("%s: element "
"%zu found %" PRIu32
", expecting %" PRIu32 "\n",
args->name, i, *val, data[i]);
}
}
}
/* Step #3, delete */
for (i = 0; i < n; i++) {
void **result;
result = tdelete(&data[i], &root, cmp);
if ((g_opt_flags & OPT_FLAGS_VERIFY) && (result == NULL))
pr_fail("%s: element %zu could not "
"be found\n", args->name, i);
}
inc_counter(args);
} while (keep_stressing());
abort:
free(data);
return EXIT_SUCCESS;
}
/*
* stress_mergesort()
* stress mergesort
*/
static int stress_mergesort(const args_t *args)
{
uint64_t mergesort_size = DEFAULT_MERGESORT_SIZE;
int32_t *data, *ptr;
size_t n, i;
struct sigaction old_action;
int ret;
if (!get_setting("mergesort-size", &mergesort_size)) {
if (g_opt_flags & OPT_FLAGS_MAXIMIZE)
mergesort_size = MAX_MERGESORT_SIZE;
if (g_opt_flags & OPT_FLAGS_MINIMIZE)
mergesort_size = MIN_MERGESORT_SIZE;
}
n = (size_t)mergesort_size;
if ((data = calloc(n, sizeof(*data))) == NULL) {
pr_fail_dbg("malloc");
return EXIT_NO_RESOURCE;
}
if (stress_sighandler(args->name, SIGALRM, stress_mergesort_handler, &old_action) < 0) {
free(data);
return EXIT_FAILURE;
}
ret = sigsetjmp(jmp_env, 1);
if (ret) {
/*
* We return here if SIGALRM jmp'd back
*/
(void)stress_sigrestore(args->name, SIGALRM, &old_action);
goto tidy;
}
/* This is expensive, do it once */
for (ptr = data, i = 0; i < n; i++)
*ptr++ = mwc32();
do {
/* Sort "random" data */
if (mergesort(data, n, sizeof(*data), stress_mergesort_cmp_1) < 0) {
pr_fail("%s: mergesort of random data failed: %d (%s)\n",
args->name, errno, strerror(errno));
} else {
if (g_opt_flags & OPT_FLAGS_VERIFY) {
for (ptr = data, i = 0; i < n - 1; i++, ptr++) {
if (*ptr > *(ptr+1)) {
pr_fail("%s: sort error "
"detected, incorrect ordering "
"found\n", args->name);
break;
}
}
}
}
if (!g_keep_stressing_flag)
break;
/* Reverse sort */
if (mergesort(data, n, sizeof(*data), stress_mergesort_cmp_2) < 0) {
pr_fail("%s: reversed mergesort of random data failed: %d (%s)\n",
args->name, errno, strerror(errno));
} else {
if (g_opt_flags & OPT_FLAGS_VERIFY) {
for (ptr = data, i = 0; i < n - 1; i++, ptr++) {
if (*ptr < *(ptr+1)) {
pr_fail("%s: reverse sort "
"error detected, incorrect "
"ordering found\n", args->name);
break;
}
}
}
}
if (!g_keep_stressing_flag)
break;
/* And re-order by random compare to remix the data */
if (mergesort(data, n, sizeof(*data), stress_mergesort_cmp_3) < 0) {
pr_fail("%s: mergesort failed: %d (%s)\n",
args->name, errno, strerror(errno));
}
/* Reverse sort this again */
if (mergesort(data, n, sizeof(*data), stress_mergesort_cmp_2) < 0) {
pr_fail("%s: reversed mergesort of random data failed: %d (%s)\n",
args->name, errno, strerror(errno));
}
if (g_opt_flags & OPT_FLAGS_VERIFY) {
for (ptr = data, i = 0; i < n - 1; i++, ptr++) {
if (*ptr < *(ptr+1)) {
pr_fail("%s: reverse sort "
"error detected, incorrect "
"ordering found\n", args->name);
break;
}
}
}
if (!g_keep_stressing_flag)
break;
inc_counter(args);
} while (keep_stressing());
do_jmp = false;
(void)stress_sigrestore(args->name, SIGALRM, &old_action);
tidy:
free(data);
return EXIT_SUCCESS;
}
/*
* stress_switch
* stress by heavy context switching
*/
int stress_switch(
uint64_t *const counter,
const uint32_t instance,
const uint64_t max_ops,
const char *name)
{
pid_t pid;
int pipefds[2];
size_t buf_size;
(void)instance;
#if defined(__linux__) && NEED_GLIBC(2,9,0)
if (pipe2(pipefds, O_DIRECT) < 0) {
pr_fail_dbg(name, "pipe2");
return EXIT_FAILURE;
}
buf_size = 1;
#else
if (pipe(pipefds) < 0) {
pr_fail_dbg(name, "pipe");
return EXIT_FAILURE;
}
buf_size = stress_get_pagesize();
#endif
#if defined(F_SETPIPE_SZ)
if (fcntl(pipefds[0], F_SETPIPE_SZ, buf_size) < 0) {
pr_dbg(stderr, "%s: could not force pipe size to 1 page, "
"errno = %d (%s)\n",
name, errno, strerror(errno));
}
if (fcntl(pipefds[1], F_SETPIPE_SZ, buf_size) < 0) {
pr_dbg(stderr, "%s: could not force pipe size to 1 page, "
"errno = %d (%s)\n",
name, errno, strerror(errno));
}
#endif
again:
pid = fork();
if (pid < 0) {
if (opt_do_run && (errno == EAGAIN))
goto again;
(void)close(pipefds[0]);
(void)close(pipefds[1]);
pr_fail_dbg(name, "fork");
return EXIT_FAILURE;
} else if (pid == 0) {
char buf[buf_size];
setpgid(0, pgrp);
stress_parent_died_alarm();
(void)close(pipefds[1]);
while (opt_do_run) {
ssize_t ret;
ret = read(pipefds[0], buf, sizeof(buf));
if (ret < 0) {
if ((errno == EAGAIN) || (errno == EINTR))
continue;
pr_fail_dbg(name, "read");
break;
}
if (ret == 0)
break;
if (*buf == SWITCH_STOP)
break;
}
(void)close(pipefds[0]);
exit(EXIT_SUCCESS);
} else {
char buf[buf_size];
int status;
/* Parent */
setpgid(pid, pgrp);
(void)close(pipefds[0]);
memset(buf, '_', buf_size);
do {
ssize_t ret;
ret = write(pipefds[1], buf, sizeof(buf));
if (ret <= 0) {
if ((errno == EAGAIN) || (errno == EINTR))
continue;
if (errno) {
pr_fail_dbg(name, "write");
break;
}
continue;
}
(*counter)++;
} while (opt_do_run && (!max_ops || *counter < max_ops));
memset(buf, SWITCH_STOP, sizeof(buf));
if (write(pipefds[1], buf, sizeof(buf)) <= 0)
pr_fail_dbg(name, "termination write");
(void)kill(pid, SIGKILL);
(void)waitpid(pid, &status, 0);
}
return EXIT_SUCCESS;
}
/*
* epoll_client()
* rapidly try to connect to server(s) and
* send a relatively short message
*/
static int epoll_client(
uint64_t *const counter,
const uint32_t instance,
const uint64_t max_ops,
const char *name,
const pid_t ppid)
{
int port_counter = 0;
uint64_t connect_timeouts = 0;
struct sigaction new_action;
struct sigevent sev;
struct itimerspec timer;
struct sockaddr *addr = NULL;
new_action.sa_flags = 0;
new_action.sa_handler = epoll_timer_handler;
sigemptyset(&new_action.sa_mask);
if (sigaction(SIGRTMIN, &new_action, NULL) < 0) {
pr_fail_err(name, "sigaction");
return -1;
}
do {
char buf[4096];
int fd, saved_errno;
int retries = 0;
int ret = -1;
int port = opt_epoll_port + port_counter + (max_servers * instance);
socklen_t addr_len = 0;
/* Cycle through the servers */
port_counter = (port_counter + 1) % max_servers;
retry:
if (!opt_do_run)
break;
if ((fd = socket(opt_epoll_domain, SOCK_STREAM, 0)) < 0) {
pr_fail_dbg(name, "socket");
return -1;
}
sev.sigev_notify = SIGEV_SIGNAL;
sev.sigev_signo = SIGRTMIN;
sev.sigev_value.sival_ptr = &epoll_timerid;
if (timer_create(CLOCK_REALTIME, &sev, &epoll_timerid) < 0) {
pr_fail_err(name, "timer_create");
(void)close(fd);
return -1;
}
/*
* Allow 1 second for connection to occur,
* connect can block if the connection table
* fills up because we're waiting for TIME-OUTs
* to occur on previously closed connections
*/
timer.it_value.tv_sec = 0;
timer.it_value.tv_nsec = 250000000;
timer.it_interval.tv_sec = timer.it_value.tv_sec;
timer.it_interval.tv_nsec = timer.it_value.tv_nsec;
if (timer_settime(epoll_timerid, 0, &timer, NULL) < 0) {
pr_fail_err(name, "timer_settime");
(void)close(fd);
return -1;
}
stress_set_sockaddr(name, instance, ppid,
opt_epoll_domain, port, &addr, &addr_len);
errno = 0;
ret = connect(fd, addr, addr_len);
saved_errno = errno;
/* No longer need timer */
if (timer_delete(epoll_timerid) < 0) {
pr_fail_err(name, "timer_delete");
(void)close(fd);
return -1;
}
if (ret < 0) {
switch (saved_errno) {
case EINTR:
connect_timeouts++;
break;
case ECONNREFUSED: /* No servers yet running */
case ENOENT: /* unix domain not yet created */
break;
default:
pr_dbg(stderr, "%s: connect failed: %d (%s)\n",
name, saved_errno, strerror(saved_errno));
break;
}
(void)close(fd);
usleep(100000); /* Twiddle fingers for a moment */
retries++;
if (retries > 1000) {
/* Sigh, give up.. */
errno = saved_errno;
pr_fail_dbg(name, "too many connects");
return -1;
}
goto retry;
}
memset(buf, 'A' + (*counter % 26), sizeof(buf));
if (send(fd, buf, sizeof(buf), 0) < 0) {
(void)close(fd);
pr_fail_dbg(name, "send");
break;
}
(void)close(fd);
#if defined(_POSIX_PRIORITY_SCHEDULING)
sched_yield();
#endif
(*counter)++;
} while (opt_do_run && (!max_ops || *counter < max_ops));
#ifdef AF_UNIX
if (addr && (opt_epoll_domain == AF_UNIX)) {
struct sockaddr_un *addr_un = (struct sockaddr_un *)addr;
(void)unlink(addr_un->sun_path);
}
#endif
if (connect_timeouts)
pr_dbg(stderr, "%s: %" PRIu64 " x 0.25 second connect timeouts, "
"connection table full (instance %" PRIu32 ")\n",
name, connect_timeouts, instance);
return EXIT_SUCCESS;
}
/*
* stress_kcmp
* stress sys_kcmp
*/
int stress_kcmp(
uint64_t *const counter,
const uint32_t instance,
const uint64_t max_ops,
const char *name)
{
pid_t pid1;
int fd1;
int ret = EXIT_SUCCESS;
(void)instance;
if ((fd1 = open("/dev/null", O_WRONLY)) < 0) {
pr_fail_err(name, "open");
return EXIT_FAILURE;
}
again:
pid1 = fork();
if (pid1 < 0) {
if (opt_do_run && (errno == EAGAIN))
goto again;
pr_fail_dbg(name, "fork");
(void)close(fd1);
return EXIT_FAILURE;
} else if (pid1 == 0) {
setpgid(0, pgrp);
stress_parent_died_alarm();
/* Child */
while (opt_do_run)
pause();
/* will never get here */
(void)close(fd1);
exit(EXIT_SUCCESS);
} else {
/* Parent */
int fd2, status, pid2;
setpgid(pid1, pgrp);
pid2 = getpid();
if ((fd2 = open("/dev/null", O_WRONLY)) < 0) {
pr_fail_err(name, "open");
ret = EXIT_FAILURE;
goto reap;
}
do {
KCMP(pid1, pid2, KCMP_FILE, fd1, fd2);
KCMP(pid1, pid1, KCMP_FILE, fd1, fd1);
KCMP(pid2, pid2, KCMP_FILE, fd1, fd1);
KCMP(pid2, pid2, KCMP_FILE, fd2, fd2);
KCMP(pid1, pid2, KCMP_FILES, 0, 0);
KCMP(pid1, pid1, KCMP_FILES, 0, 0);
KCMP(pid2, pid2, KCMP_FILES, 0, 0);
KCMP(pid1, pid2, KCMP_FS, 0, 0);
KCMP(pid1, pid1, KCMP_FS, 0, 0);
KCMP(pid2, pid2, KCMP_FS, 0, 0);
KCMP(pid1, pid2, KCMP_IO, 0, 0);
KCMP(pid1, pid1, KCMP_IO, 0, 0);
KCMP(pid2, pid2, KCMP_IO, 0, 0);
KCMP(pid1, pid2, KCMP_SIGHAND, 0, 0);
KCMP(pid1, pid1, KCMP_SIGHAND, 0, 0);
KCMP(pid2, pid2, KCMP_SIGHAND, 0, 0);
KCMP(pid1, pid2, KCMP_SYSVSEM, 0, 0);
KCMP(pid1, pid1, KCMP_SYSVSEM, 0, 0);
KCMP(pid2, pid2, KCMP_SYSVSEM, 0, 0);
KCMP(pid1, pid2, KCMP_VM, 0, 0);
KCMP(pid1, pid1, KCMP_VM, 0, 0);
KCMP(pid2, pid2, KCMP_VM, 0, 0);
/* Same simple checks */
if (opt_flags & OPT_FLAGS_VERIFY) {
KCMP_VERIFY(pid1, pid1, KCMP_FILE, fd1, fd1, 0);
KCMP_VERIFY(pid1, pid1, KCMP_FILES, 0, 0, 0);
KCMP_VERIFY(pid1, pid1, KCMP_FS, 0, 0, 0);
KCMP_VERIFY(pid1, pid1, KCMP_IO, 0, 0, 0);
KCMP_VERIFY(pid1, pid1, KCMP_SIGHAND, 0, 0, 0);
KCMP_VERIFY(pid1, pid1, KCMP_SYSVSEM, 0, 0, 0);
KCMP_VERIFY(pid1, pid1, KCMP_VM, 0, 0, 0);
KCMP_VERIFY(pid1, pid2, KCMP_SYSVSEM, 0, 0, 0);
}
(*counter)++;
} while (opt_do_run && (!max_ops || *counter < max_ops));
reap:
if (fd2 >= 0)
(void)close(fd2);
(void)kill(pid1, SIGKILL);
(void)waitpid(pid1, &status, 0);
(void)close(fd1);
}
return ret;
}
/*
* stress_ptrace()
* stress ptracing
*/
static int stress_ptrace(const args_t *args)
{
pid_t pid;
pid = fork();
if (pid < 0) {
pr_fail_dbg("fork");
return EXIT_FAILURE;
} else if (pid == 0) {
(void)setpgid(0, g_pgrp);
stress_parent_died_alarm();
/*
* Child to be traced, we abort if we detect
* we are already being traced by someone else
* as this makes life way too complex
*/
if (ptrace(PTRACE_TRACEME) != 0) {
pr_fail("%s: ptrace child being traced "
"already, aborting\n", args->name);
_exit(0);
}
/* Wait for parent to start tracing me */
(void)kill(getpid(), SIGSTOP);
/*
* A simple mix of system calls
*/
while (g_keep_stressing_flag) {
pid_t pidtmp;
gid_t gidtmp;
uid_t uidtmp;
time_t ttmp;
pidtmp = getppid();
(void)pidtmp;
#if defined(HAVE_GETPGRP)
pidtmp = getpgrp();
(void)pidtmp;
#endif
gidtmp = getgid();
(void)gidtmp;
gidtmp = getegid();
(void)gidtmp;
uidtmp = getuid();
(void)uidtmp;
uidtmp = geteuid();
(void)uidtmp;
ttmp = time(NULL);
(void)ttmp;
}
_exit(0);
} else {
/* Parent to do the tracing */
int status;
(void)setpgid(pid, g_pgrp);
if (shim_waitpid(pid, &status, 0) < 0) {
if (errno != EINTR) {
pr_fail_dbg("waitpid");
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}
if (ptrace(PTRACE_SETOPTIONS, pid,
0, PTRACE_O_TRACESYSGOOD) < 0) {
pr_fail_dbg("ptrace");
return EXIT_FAILURE;
}
do {
/*
* We do two of the following per syscall,
* one at the start, and one at the end to catch
* the return. In this stressor we don't really
* care which is which, we just care about counting
* them
*/
if (stress_syscall_wait(args, pid))
break;
inc_counter(args);
} while (keep_stressing());
/* Terminate child */
(void)kill(pid, SIGKILL);
if (shim_waitpid(pid, &status, 0) < 0)
pr_fail_dbg("waitpid");
}
return EXIT_SUCCESS;
}
/*
* stress_shm_sysv()
* stress SYSTEM V shared memory
*/
int stress_shm_sysv(
uint64_t *const counter,
const uint32_t instance,
const uint64_t max_ops,
const char *name)
{
const size_t page_size = stress_get_pagesize();
size_t orig_sz, sz;
int pipefds[2];
int rc = EXIT_SUCCESS;
ssize_t i;
pid_t pid;
bool retry = true;
uint32_t restarts = 0;
if (!set_shm_sysv_bytes) {
if (opt_flags & OPT_FLAGS_MAXIMIZE)
opt_shm_sysv_bytes = MAX_SHM_SYSV_BYTES;
if (opt_flags & OPT_FLAGS_MINIMIZE)
opt_shm_sysv_bytes = MIN_SHM_SYSV_BYTES;
}
if (!set_shm_sysv_segments) {
if (opt_flags & OPT_FLAGS_MAXIMIZE)
opt_shm_sysv_segments = MAX_SHM_SYSV_SEGMENTS;
if (opt_flags & OPT_FLAGS_MINIMIZE)
opt_shm_sysv_segments = MIN_SHM_SYSV_SEGMENTS;
}
orig_sz = sz = opt_shm_sysv_bytes & ~(page_size - 1);
while (opt_do_run && retry) {
if (pipe(pipefds) < 0) {
pr_fail_dbg(name, "pipe");
return EXIT_FAILURE;
}
fork_again:
pid = fork();
if (pid < 0) {
/* Can't fork, retry? */
if (errno == EAGAIN)
goto fork_again;
pr_err(stderr, "%s: fork failed: errno=%d: (%s)\n",
name, errno, strerror(errno));
(void)close(pipefds[0]);
(void)close(pipefds[1]);
/* Nope, give up! */
return EXIT_FAILURE;
} else if (pid > 0) {
/* Parent */
int status, shm_ids[MAX_SHM_SYSV_SEGMENTS];
ssize_t n;
setpgid(pid, pgrp);
set_oom_adjustment(name, false);
(void)close(pipefds[1]);
for (i = 0; i < (ssize_t)opt_shm_sysv_segments; i++)
shm_ids[i] = -1;
while (opt_do_run) {
shm_msg_t msg;
/*
* Blocking read on child shm ID info
* pipe. We break out if pipe breaks
* on child death, or child tells us
* off its demise.
*/
n = read(pipefds[0], &msg, sizeof(msg));
if (n <= 0) {
if ((errno == EAGAIN) || (errno == EINTR))
continue;
if (errno) {
pr_fail_dbg(name, "read");
break;
}
pr_fail_dbg(name, "zero byte read");
break;
}
if ((msg.index < 0) ||
(msg.index >= MAX_SHM_SYSV_SEGMENTS)) {
retry = false;
break;
}
shm_ids[msg.index] = msg.shm_id;
}
(void)kill(pid, SIGALRM);
(void)waitpid(pid, &status, 0);
if (WIFSIGNALED(status)) {
if ((WTERMSIG(status) == SIGKILL) ||
(WTERMSIG(status) == SIGBUS)) {
pr_dbg(stderr, "%s: assuming killed by OOM killer, "
"restarting again (instance %d)\n",
name, instance);
restarts++;
}
}
(void)close(pipefds[1]);
/*
* The child may have been killed by the OOM killer or
* some other way, so it may have left the shared
* memory segment around. At this point the child
* has died, so we should be able to remove the
* shared memory segment.
*/
for (i = 0; i < (ssize_t)opt_shm_sysv_segments; i++) {
if (shm_ids[i] != -1)
(void)shmctl(shm_ids[i], IPC_RMID, NULL);
}
} else if (pid == 0) {
/* Child, stress memory */
setpgid(0, pgrp);
stress_parent_died_alarm();
/*
* Nicing the child may OOM it first as this
* doubles the OOM score
*/
if (nice(5) < 0)
pr_dbg(stderr, "%s: nice of child failed, "
"(instance %d)\n", name, instance);
(void)close(pipefds[0]);
rc = stress_shm_sysv_child(pipefds[1], counter,
max_ops, name, sz, page_size);
(void)close(pipefds[1]);
_exit(rc);
}
}
if (orig_sz != sz)
pr_dbg(stderr, "%s: reduced shared memory size from "
"%zu to %zu bytes\n", name, orig_sz, sz);
if (restarts) {
pr_dbg(stderr, "%s: OOM restarts: %" PRIu32 "\n",
name, restarts);
}
return rc;
}
/*
* stress_mergesort()
* stress mergesort
*/
int stress_mergesort(
uint64_t *const counter,
const uint32_t instance,
const uint64_t max_ops,
const char *name)
{
int32_t *data, *ptr;
size_t n, i;
struct sigaction old_action;
int ret;
(void)instance;
if (!set_mergesort_size) {
if (opt_flags & OPT_FLAGS_MAXIMIZE)
opt_mergesort_size = MAX_MERGESORT_SIZE;
if (opt_flags & OPT_FLAGS_MINIMIZE)
opt_mergesort_size = MIN_MERGESORT_SIZE;
}
n = (size_t)opt_mergesort_size;
if ((data = calloc(n, sizeof(int32_t))) == NULL) {
pr_fail_dbg(name, "malloc");
return EXIT_FAILURE;
}
if (stress_sighandler(name, SIGALRM, stress_mergesort_handler, &old_action) < 0) {
free(data);
return EXIT_FAILURE;
}
ret = sigsetjmp(jmp_env, 1);
if (ret) {
/*
* We return here if SIGALRM jmp'd back
*/
(void)stress_sigrestore(name, SIGALRM, &old_action);
goto tidy;
}
/* This is expensive, do it once */
for (ptr = data, i = 0; i < n; i++)
*ptr++ = mwc32();
do {
/* Sort "random" data */
mergesort(data, n, sizeof(uint32_t), stress_mergesort_cmp_1);
if (opt_flags & OPT_FLAGS_VERIFY) {
for (ptr = data, i = 0; i < n - 1; i++, ptr++) {
if (*ptr > *(ptr+1)) {
pr_fail(stderr, "%s: sort error "
"detected, incorrect ordering "
"found\n", name);
break;
}
}
}
if (!opt_do_run)
break;
/* Reverse sort */
mergesort(data, n, sizeof(uint32_t), stress_mergesort_cmp_2);
if (opt_flags & OPT_FLAGS_VERIFY) {
for (ptr = data, i = 0; i < n - 1; i++, ptr++) {
if (*ptr < *(ptr+1)) {
pr_fail(stderr, "%s: reverse sort "
"error detected, incorrect "
"ordering found\n", name);
break;
}
}
}
if (!opt_do_run)
break;
/* And re-order by byte compare */
mergesort(data, n * 4, sizeof(uint8_t), stress_mergesort_cmp_3);
/* Reverse sort this again */
mergesort(data, n, sizeof(uint32_t), stress_mergesort_cmp_2);
if (opt_flags & OPT_FLAGS_VERIFY) {
for (ptr = data, i = 0; i < n - 1; i++, ptr++) {
if (*ptr < *(ptr+1)) {
pr_fail(stderr, "%s: reverse sort "
"error detected, incorrect "
"ordering found\n", name);
break;
}
}
}
if (!opt_do_run)
break;
(*counter)++;
} while (opt_do_run && (!max_ops || *counter < max_ops));
do_jmp = false;
(void)stress_sigrestore(name, SIGALRM, &old_action);
tidy:
free(data);
return EXIT_SUCCESS;
}
/*
* stress_socket_server()
* server writer
*/
static int stress_socket_server(
uint64_t *const counter,
const uint32_t instance,
const uint64_t max_ops,
const char *name,
const pid_t pid,
const pid_t ppid)
{
char buf[SOCKET_BUF];
int fd, status;
int so_reuseaddr = 1;
socklen_t addr_len = 0;
struct sockaddr *addr;
uint64_t msgs = 0;
int rc = EXIT_SUCCESS;
setpgid(pid, pgrp);
if (stress_sighandler(name, SIGALRM, handle_socket_sigalrm, NULL) < 0) {
rc = EXIT_FAILURE;
goto die;
}
if ((fd = socket(opt_socket_domain, SOCK_STREAM, 0)) < 0) {
rc = exit_status(errno);
pr_fail_dbg(name, "socket");
goto die;
}
if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR,
&so_reuseaddr, sizeof(so_reuseaddr)) < 0) {
pr_fail_dbg(name, "setsockopt");
rc = EXIT_FAILURE;
goto die_close;
}
stress_set_sockaddr(name, instance, ppid,
opt_socket_domain, opt_socket_port, &addr, &addr_len);
if (bind(fd, addr, addr_len) < 0) {
rc = exit_status(errno);
pr_fail_dbg(name, "bind");
goto die_close;
}
if (listen(fd, 10) < 0) {
pr_fail_dbg(name, "listen");
rc = EXIT_FAILURE;
goto die_close;
}
do {
int sfd = accept(fd, (struct sockaddr *)NULL, NULL);
if (sfd >= 0) {
size_t i, j;
struct sockaddr addr;
socklen_t len;
int sndbuf;
struct msghdr msg;
struct iovec vec[sizeof(buf)/16];
#if defined(HAVE_SENDMMSG)
struct mmsghdr msgvec[MSGVEC_SIZE];
unsigned int msg_len = 0;
#endif
#if defined(SOCKET_NODELAY)
int one = 1;
#endif
len = sizeof(addr);
if (getsockname(fd, &addr, &len) < 0) {
pr_fail_dbg(name, "getsockname");
(void)close(sfd);
break;
}
len = sizeof(sndbuf);
if (getsockopt(fd, SOL_SOCKET, SO_SNDBUF, &sndbuf, &len) < 0) {
pr_fail_dbg(name, "getsockopt");
(void)close(sfd);
break;
}
#if defined(SOCKET_NODELAY)
if (opt_flags & OPT_FLAGS_SOCKET_NODELAY) {
if (setsockopt(fd, SOL_TCP, TCP_NODELAY, &one, sizeof(one)) < 0) {
pr_inf(stderr, "%s: setsockopt TCP_NODELAY "
"failed and disabled, errno=%d (%s)\n",
name, errno, strerror(errno));
opt_flags &= ~OPT_FLAGS_SOCKET_NODELAY;
}
}
#endif
memset(buf, 'A' + (*counter % 26), sizeof(buf));
switch (opt_socket_opts) {
case SOCKET_OPT_SEND:
for (i = 16; i < sizeof(buf); i += 16) {
ssize_t ret = send(sfd, buf, i, 0);
if (ret < 0) {
if (errno != EINTR)
pr_fail_dbg(name, "send");
break;
} else
msgs++;
}
break;
case SOCKET_OPT_SENDMSG:
for (j = 0, i = 16; i < sizeof(buf); i += 16, j++) {
vec[j].iov_base = buf;
vec[j].iov_len = i;
}
memset(&msg, 0, sizeof(msg));
msg.msg_iov = vec;
msg.msg_iovlen = j;
if (sendmsg(sfd, &msg, 0) < 0) {
if (errno != EINTR)
pr_fail_dbg(name, "sendmsg");
} else
msgs += j;
break;
#if defined(HAVE_SENDMMSG)
case SOCKET_OPT_SENDMMSG:
memset(msgvec, 0, sizeof(msgvec));
for (j = 0, i = 16; i < sizeof(buf); i += 16, j++) {
vec[j].iov_base = buf;
vec[j].iov_len = i;
msg_len += i;
}
for (i = 0; i < MSGVEC_SIZE; i++) {
msgvec[i].msg_hdr.msg_iov = vec;
msgvec[i].msg_hdr.msg_iovlen = j;
}
if (sendmmsg(sfd, msgvec, MSGVEC_SIZE, 0) < 0) {
if (errno != EINTR)
pr_fail_dbg(name, "sendmmsg");
} else
msgs += (MSGVEC_SIZE * j);
break;
#endif
default:
/* Should never happen */
pr_err(stderr, "%s: bad option %d\n", name, opt_socket_opts);
(void)close(sfd);
goto die_close;
}
if (getpeername(sfd, &addr, &len) < 0) {
pr_fail_dbg(name, "getpeername");
}
(void)close(sfd);
}
(*counter)++;
} while (opt_do_run && (!max_ops || *counter < max_ops));
die_close:
(void)close(fd);
die:
#ifdef AF_UNIX
if (opt_socket_domain == AF_UNIX) {
struct sockaddr_un *addr_un = (struct sockaddr_un *)addr;
(void)unlink(addr_un->sun_path);
}
#endif
if (pid) {
(void)kill(pid, SIGKILL);
(void)waitpid(pid, &status, 0);
}
pr_dbg(stderr, "%s: %" PRIu64 " messages sent\n", name, msgs);
return rc;
}
/*
* stress_socket_client()
* client reader
*/
static void stress_socket_client(
uint64_t *const counter,
const uint32_t instance,
const uint64_t max_ops,
const char *name,
const pid_t ppid)
{
struct sockaddr *addr;
setpgid(0, pgrp);
stress_parent_died_alarm();
do {
char buf[SOCKET_BUF];
int fd;
int retries = 0;
socklen_t addr_len = 0;
retry:
if (!opt_do_run) {
(void)kill(getppid(), SIGALRM);
exit(EXIT_FAILURE);
}
if ((fd = socket(opt_socket_domain, SOCK_STREAM, 0)) < 0) {
pr_fail_dbg(name, "socket");
/* failed, kick parent to finish */
(void)kill(getppid(), SIGALRM);
exit(EXIT_FAILURE);
}
stress_set_sockaddr(name, instance, ppid,
opt_socket_domain, opt_socket_port,
&addr, &addr_len);
if (connect(fd, addr, addr_len) < 0) {
(void)close(fd);
usleep(10000);
retries++;
if (retries > 100) {
/* Give up.. */
pr_fail_dbg(name, "connect");
(void)kill(getppid(), SIGALRM);
exit(EXIT_FAILURE);
}
goto retry;
}
do {
ssize_t n = recv(fd, buf, sizeof(buf), 0);
if (n == 0)
break;
if (n < 0) {
if (errno != EINTR)
pr_fail_dbg(name, "recv");
break;
}
} while (opt_do_run && (!max_ops || *counter < max_ops));
(void)shutdown(fd, SHUT_RDWR);
(void)close(fd);
} while (opt_do_run && (!max_ops || *counter < max_ops));
#ifdef AF_UNIX
if (opt_socket_domain == AF_UNIX) {
struct sockaddr_un *addr_un = (struct sockaddr_un *)addr;
(void)unlink(addr_un->sun_path);
}
#endif
/* Inform parent we're all done */
(void)kill(getppid(), SIGALRM);
}
int stress_vm_child(void *arg)
{
context_t *ctxt = (context_t *)arg;
uint8_t *buf;
int ret = EXIT_SUCCESS;
addr_msg_t msg_rd, msg_wr;
setpgid(0, pgrp);
stress_parent_died_alarm();
/* Close unwanted ends */
(void)close(ctxt->pipe_wr[0]);
(void)close(ctxt->pipe_rd[1]);
buf = mmap(NULL, ctxt->sz, PROT_READ | PROT_WRITE,
MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
if (buf == MAP_FAILED) {
ret = exit_status(errno);
pr_fail_dbg(ctxt->name, "mmap");
goto cleanup;
}
while (opt_do_run) {
uint8_t *ptr, *end = buf + ctxt->sz;
int ret;
memset(&msg_wr, 0, sizeof(msg_wr));
msg_wr.addr = buf;
msg_wr.val = 0;
/* Send address of buffer to parent */
redo_wr1:
ret = write(ctxt->pipe_wr[1], &msg_wr, sizeof(msg_wr));
if (ret < 0) {
if ((errno == EAGAIN) || (errno == EINTR))
goto redo_wr1;
if (errno != EBADF)
pr_fail_dbg(ctxt->name, "write");
break;
}
redo_rd1:
/* Wait for parent to populate data */
ret = read(ctxt->pipe_rd[0], &msg_rd, sizeof(msg_rd));
if (ret < 0) {
if ((errno == EAGAIN) || (errno == EINTR))
goto redo_rd1;
pr_fail_dbg(ctxt->name, "read");
break;
}
if (ret == 0)
break;
if (ret != sizeof(msg_rd)) {
pr_fail_dbg(ctxt->name, "read");
break;
}
if (opt_flags & OPT_FLAGS_VERIFY) {
/* Check memory altered by parent is sane */
for (ptr = buf; ptr < end; ptr += ctxt->page_size) {
if (*ptr != msg_rd.val) {
pr_fail(stderr, "%s: memory at %p: %d vs %d\n",
ctxt->name, ptr, *ptr, msg_rd.val);
goto cleanup;
}
*ptr = 0;
}
}
}
cleanup:
/* Tell parent we're done */
msg_wr.addr = 0;
msg_wr.val = 0;
if (write(ctxt->pipe_wr[1], &msg_wr, sizeof(msg_wr)) <= 0) {
if (errno != EBADF)
pr_dbg(stderr, "%s: failed to write termination message "
"over pipe: errno=%d (%s)\n",
ctxt->name, errno, strerror(errno));
}
(void)close(ctxt->pipe_wr[1]);
(void)close(ctxt->pipe_rd[0]);
(void)munmap(buf, ctxt->sz);
return ret;
}
/*
* stress_eventfd
* stress eventfd read/writes
*/
int stress_eventfd(
uint64_t *const counter,
const uint32_t instance,
const uint64_t max_ops,
const char *name)
{
pid_t pid;
int fd1, fd2, rc;
(void)instance;
fd1 = eventfd(0, 0);
if (fd1 < 0) {
rc = exit_status(errno);
pr_fail_dbg(name, "eventfd");
return rc;
}
fd2 = eventfd(0, 0);
if (fd2 < 0) {
rc = exit_status(errno);
pr_fail_dbg(name, "eventfd");
(void)close(fd1);
return rc;
}
again:
pid = fork();
if (pid < 0) {
if (opt_do_run && (errno == EAGAIN))
goto again;
pr_fail_dbg(name, "fork");
(void)close(fd1);
(void)close(fd2);
return EXIT_FAILURE;
} else if (pid == 0) {
setpgid(0, pgrp);
stress_parent_died_alarm();
while (opt_do_run) {
uint64_t val;
ssize_t ret;
for (;;) {
if (!opt_do_run)
goto exit_child;
ret = read(fd1, &val, sizeof(val));
if (ret < 0) {
if ((errno == EAGAIN) || (errno == EINTR))
continue;
pr_fail_dbg(name, "child read");
goto exit_child;
}
if (ret < (ssize_t)sizeof(val)) {
pr_fail_dbg(name, "child short read");
goto exit_child;
}
break;
}
val = 1;
for (;;) {
if (!opt_do_run)
goto exit_child;
ret = write(fd2, &val, sizeof(val));
if (ret < 0) {
if ((errno == EAGAIN) || (errno == EINTR))
continue;
pr_fail_dbg(name, "child write");
goto exit_child;
}
if (ret < (ssize_t)sizeof(val)) {
pr_fail_dbg(name, "child short write");
goto exit_child;
}
break;
}
}
exit_child:
(void)close(fd1);
(void)close(fd2);
exit(EXIT_SUCCESS);
} else {
int status;
do {
uint64_t val = 1;
int ret;
for (;;) {
if (!opt_do_run)
goto exit_parent;
ret = write(fd1, &val, sizeof(val));
if (ret < 0) {
if ((errno == EAGAIN) || (errno == EINTR))
continue;
pr_fail_dbg(name, "parent write");
goto exit_parent;
}
if (ret < (ssize_t)sizeof(val)) {
pr_fail_dbg(name, "parent short write");
goto exit_parent;
}
break;
}
for (;;) {
if (!opt_do_run)
goto exit_parent;
ret = read(fd2, &val, sizeof(val));
if (ret < 0) {
if ((errno == EAGAIN) || (errno == EINTR))
continue;
pr_fail_dbg(name, "parent read");
goto exit_parent;
}
if (ret < (ssize_t)sizeof(val)) {
pr_fail_dbg(name, "parent short read");
goto exit_parent;
}
break;
}
(*counter)++;
} while (opt_do_run && (!max_ops || *counter < max_ops));
exit_parent:
(void)kill(pid, SIGKILL);
(void)waitpid(pid, &status, 0);
(void)close(fd1);
(void)close(fd2);
}
return EXIT_SUCCESS;
}
/*
* stress_kcmp
* stress sys_kcmp
*/
static int stress_kcmp(const args_t *args)
{
pid_t pid1;
int fd1;
#if defined(HAVE_SYS_EPOLL_H) && NEED_GLIBC(2,3,2)
int efd, sfd;
int so_reuseaddr = 1;
struct epoll_event ev;
struct sockaddr *addr = NULL;
socklen_t addr_len = 0;
#endif
int ret = EXIT_SUCCESS;
static const char *capfail =
"need CAP_SYS_PTRACE capability to run kcmp stressor, "
"aborting stress test\n";
if ((fd1 = open("/dev/null", O_WRONLY)) < 0) {
pr_fail_err("open");
return EXIT_FAILURE;
}
#if defined(HAVE_SYS_EPOLL_H) && NEED_GLIBC(2,3,2)
efd = -1;
if ((sfd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
sfd = -1;
goto again;
}
if (setsockopt(sfd, SOL_SOCKET, SO_REUSEADDR,
&so_reuseaddr, sizeof(so_reuseaddr)) < 0) {
(void)close(sfd);
sfd = -1;
goto again;
}
stress_set_sockaddr(args->name, args->instance, args->ppid,
AF_INET, 23000, &addr, &addr_len, NET_ADDR_ANY);
if (bind(sfd, addr, addr_len) < 0) {
(void)close(sfd);
sfd = -1;
goto again;
}
if (listen(sfd, SOMAXCONN) < 0) {
(void)close(sfd);
sfd = -1;
goto again;
}
efd = epoll_create1(0);
if (efd < 0) {
(void)close(sfd);
sfd = -1;
efd = -1;
goto again;
}
(void)memset(&ev, 0, sizeof(ev));
ev.data.fd = efd;
ev.events = EPOLLIN | EPOLLET;
if (epoll_ctl(efd, EPOLL_CTL_ADD, sfd, &ev) < 0) {
(void)close(sfd);
(void)close(efd);
sfd = -1;
efd = -1;
}
#endif
again:
pid1 = fork();
if (pid1 < 0) {
if (g_keep_stressing_flag &&
((errno == EAGAIN) || (errno == ENOMEM)))
goto again;
pr_fail_dbg("fork");
(void)close(fd1);
#if defined(HAVE_SYS_EPOLL_H) && NEED_GLIBC(2,3,2)
if (sfd != -1)
(void)close(sfd);
#endif
return EXIT_FAILURE;
} else if (pid1 == 0) {
(void)setpgid(0, g_pgrp);
stress_parent_died_alarm();
/* Child */
while (g_keep_stressing_flag)
(void)pause();
/* will never get here */
(void)close(fd1);
#if defined(HAVE_SYS_EPOLL_H) && NEED_GLIBC(2,3,2)
if (efd != -1)
(void)close(efd);
if (sfd != -1)
(void)close(sfd);
#endif
_exit(EXIT_SUCCESS);
} else {
/* Parent */
int fd2, status, pid2;
(void)setpgid(pid1, g_pgrp);
pid2 = getpid();
if ((fd2 = open("/dev/null", O_WRONLY)) < 0) {
pr_fail_err("open");
ret = EXIT_FAILURE;
goto reap;
}
do {
KCMP(pid1, pid2, SHIM_KCMP_FILE, fd1, fd2);
KCMP(pid1, pid1, SHIM_KCMP_FILE, fd1, fd1);
KCMP(pid2, pid2, SHIM_KCMP_FILE, fd1, fd1);
KCMP(pid2, pid2, SHIM_KCMP_FILE, fd2, fd2);
KCMP(pid1, pid2, SHIM_KCMP_FILES, 0, 0);
KCMP(pid1, pid1, SHIM_KCMP_FILES, 0, 0);
KCMP(pid2, pid2, SHIM_KCMP_FILES, 0, 0);
KCMP(pid1, pid2, SHIM_KCMP_FS, 0, 0);
KCMP(pid1, pid1, SHIM_KCMP_FS, 0, 0);
KCMP(pid2, pid2, SHIM_KCMP_FS, 0, 0);
KCMP(pid1, pid2, SHIM_KCMP_IO, 0, 0);
KCMP(pid1, pid1, SHIM_KCMP_IO, 0, 0);
KCMP(pid2, pid2, SHIM_KCMP_IO, 0, 0);
KCMP(pid1, pid2, SHIM_KCMP_SIGHAND, 0, 0);
KCMP(pid1, pid1, SHIM_KCMP_SIGHAND, 0, 0);
KCMP(pid2, pid2, SHIM_KCMP_SIGHAND, 0, 0);
KCMP(pid1, pid2, SHIM_KCMP_SYSVSEM, 0, 0);
KCMP(pid1, pid1, SHIM_KCMP_SYSVSEM, 0, 0);
KCMP(pid2, pid2, SHIM_KCMP_SYSVSEM, 0, 0);
KCMP(pid1, pid2, SHIM_KCMP_VM, 0, 0);
KCMP(pid1, pid1, SHIM_KCMP_VM, 0, 0);
KCMP(pid2, pid2, SHIM_KCMP_VM, 0, 0);
#if defined(HAVE_SYS_EPOLL_H) && NEED_GLIBC(2,3,2)
if (efd != -1) {
struct kcmp_epoll_slot slot;
slot.efd = efd;
slot.tfd = sfd;
slot.toff = 0;
KCMP(pid1, pid2, SHIM_KCMP_EPOLL_TFD, efd, (unsigned long)&slot);
KCMP(pid2, pid1, SHIM_KCMP_EPOLL_TFD, efd, (unsigned long)&slot);
KCMP(pid2, pid2, SHIM_KCMP_EPOLL_TFD, efd, (unsigned long)&slot);
}
#endif
/* Same simple checks */
if (g_opt_flags & OPT_FLAGS_VERIFY) {
KCMP_VERIFY(pid1, pid1, SHIM_KCMP_FILE, fd1, fd1, 0);
KCMP_VERIFY(pid1, pid1, SHIM_KCMP_FILES, 0, 0, 0);
KCMP_VERIFY(pid1, pid1, SHIM_KCMP_FS, 0, 0, 0);
KCMP_VERIFY(pid1, pid1, SHIM_KCMP_IO, 0, 0, 0);
KCMP_VERIFY(pid1, pid1, SHIM_KCMP_SIGHAND, 0, 0, 0);
KCMP_VERIFY(pid1, pid1, SHIM_KCMP_SYSVSEM, 0, 0, 0);
KCMP_VERIFY(pid1, pid1, SHIM_KCMP_VM, 0, 0, 0);
KCMP_VERIFY(pid1, pid2, SHIM_KCMP_SYSVSEM, 0, 0, 0);
#if defined(HAVE_SYS_EPOLL_H) && NEED_GLIBC(2,3,2)
if (efd != -1) {
struct kcmp_epoll_slot slot;
slot.efd = efd;
slot.tfd = sfd;
slot.toff = 0;
KCMP(pid1, pid2, SHIM_KCMP_EPOLL_TFD, efd, (unsigned long)&slot);
}
#endif
}
inc_counter(args);
} while (keep_stressing());
reap:
if (fd2 >= 0)
(void)close(fd2);
(void)kill(pid1, SIGKILL);
(void)shim_waitpid(pid1, &status, 0);
(void)close(fd1);
}
#if defined(HAVE_SYS_EPOLL_H) && NEED_GLIBC(2,3,2)
if (efd != -1)
(void)close(efd);
if (sfd != -1)
(void)close(sfd);
#endif
return ret;
}
/*
* stress_sigq
* stress by heavy sigqueue message sending
*/
int stress_sigq(
uint64_t *const counter,
const uint32_t instance,
const uint64_t max_ops,
const char *name)
{
pid_t pid;
if (stress_sighandler(name, SIGUSR1, stress_sigqhandler, NULL) < 0)
return EXIT_FAILURE;
again:
pid = fork();
if (pid < 0) {
if (opt_do_run && (errno == EAGAIN))
goto again;
pr_fail_dbg(name, "fork");
return EXIT_FAILURE;
} else if (pid == 0) {
sigset_t mask;
setpgid(0, pgrp);
stress_parent_died_alarm();
sigemptyset(&mask);
sigaddset(&mask, SIGUSR1);
while (opt_do_run) {
siginfo_t info;
sigwaitinfo(&mask, &info);
if (info.si_value.sival_int)
break;
}
pr_dbg(stderr, "%s: child got termination notice\n", name);
pr_dbg(stderr, "%s: exited on pid [%d] (instance %" PRIu32 ")\n",
name, getpid(), instance);
_exit(0);
} else {
/* Parent */
union sigval s;
int status;
do {
memset(&s, 0, sizeof(s));
s.sival_int = 0;
sigqueue(pid, SIGUSR1, s);
(*counter)++;
} while (opt_do_run && (!max_ops || *counter < max_ops));
pr_dbg(stderr, "%s: parent sent termination notice\n", name);
memset(&s, 0, sizeof(s));
s.sival_int = 1;
sigqueue(pid, SIGUSR1, s);
usleep(250);
/* And ensure child is really dead */
(void)kill(pid, SIGKILL);
(void)waitpid(pid, &status, 0);
}
return EXIT_SUCCESS;
}