int main(void)
{
RT_TASK main_tcb;
RT_TASK tcb;
mqd_t mq;
int i;
mlockall(MCL_CURRENT | MCL_FUTURE);
fprintf(stderr, "Checking select service with posix message queues\n");
rt_task_shadow(&main_tcb, NULL, 0, 0);
mq = mq_open("/select_test_mq", O_RDWR | O_CREAT | O_NONBLOCK, 0, NULL);
check_unix(mq == -1 ? -1 : 0);
check_native(rt_task_create(&tcb, "select_test", 0, 1, T_JOINABLE));
check_native(rt_task_start(&tcb, task, (void *)(long)mq));
alarm(30);
for(i = 0; i < sizeof(tunes) / sizeof(tunes[0]); i++) {
check_unix(mq_send(mq, tunes[i], strlen(tunes[i]) + 1, 0));
sleep(1);
}
check_native(rt_task_join(&tcb));
fprintf(stderr, "select service with posix message queues: success\n");
return EXIT_SUCCESS;
}
void task(void *cookie)
{
mqd_t mqd = (mqd_t)(long)cookie;
fd_set inset;
unsigned i;
FD_ZERO(&inset);
FD_SET(mqd, &inset);
for(i = 0; i < sizeof(tunes)/sizeof(tunes[0]); i++) {
fd_set tmp_inset = inset;
unsigned prio;
char buf[128];
check_unix(select(mqd + 1, &tmp_inset, NULL, NULL, NULL));
check_unix(mq_receive(mqd, buf, sizeof(buf), &prio));
if (strcmp(buf, tunes[i])) {
fprintf(stderr, "Received %s instead of %s\n",
buf, tunes[i]);
exit(EXIT_FAILURE);
}
fprintf(stderr, "Received %s\n", buf);
}
}
static inline void subprocess_leak(void)
{
struct sigevent sevt;
pthread_mutex_t mutex;
pthread_cond_t cond;
pthread_t thread;
sem_t sem, *psem;
timer_t tm;
int fd;
check_pthread(pthread_create(&thread, NULL, empty, NULL));
check_pthread(pthread_mutex_init(&mutex, NULL));
check_pthread(pthread_cond_init(&cond, NULL));
check_unix(sem_init(&sem, 0, 0));
check_unix(-!(psem = sem_open(SEM_NAME, O_CREAT, 0644, 1)));
sevt.sigev_notify = SIGEV_THREAD_ID;
sevt.sigev_signo = SIGALRM;
sevt.sigev_notify_thread_id = syscall(__NR_gettid);
check_unix(timer_create(CLOCK_MONOTONIC, &sevt, &tm));
check_unix(fd = mq_open(MQ_NAME, O_RDWR | O_CREAT, 0644, NULL));
}
void x11_test(void) {
// check regular display 0 sockets
if (check_unix("/tmp/.X11-unix/X0") == 0)
printf("MAYBE: X11 socket /tmp/.X11-unix/X0 is available\n");
if (check_unix("@/tmp/.X11-unix/X0") == 0)
printf("MAYBE: X11 socket @/tmp/.X11-unix/X0 is available\n");
// check all unix sockets in /tmp/.X11-unix directory
DIR *dir;
if (!(dir = opendir("/tmp/.X11-unix"))) {
// sleep 2 seconds and try again
sleep(2);
if (!(dir = opendir("/tmp/.X11-unix"))) {
;
}
}
if (dir == NULL)
printf("GOOD: cannot open /tmp/.X11-unix directory\n");
else {
struct dirent *entry;
while ((entry = readdir(dir)) != NULL) {
if (strcmp(entry->d_name, "X0") == 0)
continue;
if (strcmp(entry->d_name, ".") == 0)
continue;
if (strcmp(entry->d_name, "..") == 0)
continue;
char *name;
if (asprintf(&name, "/tmp/.X11-unix/%s", entry->d_name) == -1)
errExit("asprintf");
if (check_unix(name) == 0)
printf("MAYBE: X11 socket %s is available\n", name);
free(name);
}
closedir(dir);
}
}
void cond_destroy_whilewait(void)
{
unsigned long long start;
mutex_t mutex;
cond_t cond;
struct cond_mutex cm = {
.mutex = &mutex,
.cond = &cond,
.tid = thread_self(),
};
thread_t cond_destroyer_tid;
struct sigaction sa = {
.sa_handler = sighandler,
.sa_flags = SA_RESTART,
};
sigemptyset(&sa.sa_mask);
fprintf(stderr, "%s\n", __FUNCTION__);
check_unix("sigaction", sigaction(SIGRTMIN, &sa, NULL), 0);
check("mutex_init", mutex_init(&mutex, PTHREAD_MUTEX_DEFAULT, 0), 0);
check("cond_init", cond_init(&cond, 0), 0);
check("mutex_lock", mutex_lock(&mutex), 0);
check("thread_spawn",
thread_spawn(&cond_destroyer_tid, 2, cond_destroyer, &cm), 0);
thread_msleep(11);
start = rt_timer_tsc();
#ifdef XENO_POSIX
check("cond_wait", cond_wait(&cond, &mutex, 10 * NS_PER_MS), -ETIMEDOUT);
check_sleep("cond_wait", start);
thread_msleep(10);
check("mutex_unlock", mutex_unlock(&mutex), 0);
#else /* native */
check("cond_wait", cond_wait(&cond, &mutex, XN_INFINITE), -EIDRM);
check_sleep("cond_wait", start);
#endif /* native */
check("thread_join", thread_join(cond_destroyer_tid), 0);
check("mutex_destroy", mutex_destroy(&mutex), 0);
#ifdef XENO_POSIX
check("cond_destroy", cond_destroy(&cond), 0);
#else /* native */
check("cond_destroy", cond_destroy(&cond), -ESRCH);
#endif /* native */
}
int main(int argc, char **argv)
{
unsigned char *zero_mem, *test1_mem, *test2_mem;
struct sched_param param = { .sched_priority = 1 };
struct timespec zero = { .tv_sec = 0, .tv_nsec = 0 };
struct sigaction sa;
zero_mem = check_mmap(mmap(0, MEMSIZE, PROT_READ,
MAP_PRIVATE | MAP_ANONYMOUS, 0, 0));
test1_mem = check_mmap(mmap(0, MEMSIZE, PROT_READ,
MAP_PRIVATE | MAP_ANONYMOUS, 0, 0));
sigemptyset(&sa.sa_mask);
sa.sa_sigaction = sigdebug_handler;
sa.sa_flags = SA_SIGINFO;
check_unix(sigaction(SIGDEBUG, &sa, NULL));
check_unix(mlockall(MCL_CURRENT | MCL_FUTURE));
check_pthread(pthread_setschedparam(pthread_self(), SCHED_FIFO, ¶m));
printf("memory read\n");
check_value("read mem", test1_mem[0], 0);
pthread_set_mode_np(PTHREAD_WARNSW, 0);
test2_mem = check_mmap(mmap(0, MEMSIZE, PROT_READ | PROT_WRITE,
MAP_PRIVATE | MAP_ANONYMOUS, 0, 0));
check_unix(mprotect(test2_mem, MEMSIZE,
PROT_READ | PROT_WRITE | PROT_EXEC));
nanosleep(&zero, NULL);
pthread_set_mode_np(0, PTHREAD_WARNSW);
printf("memory write after exec enable\n");
test2_mem[0] = 0xff;
pthread_set_mode_np(PTHREAD_WARNSW, 0);
check_unix(mprotect(test1_mem, MEMSIZE, PROT_READ | PROT_WRITE));
nanosleep(&zero, NULL);
pthread_set_mode_np(0, PTHREAD_WARNSW);
printf("memory write after write enable\n");
test1_mem[0] = 0xff;
check_value("read zero", zero_mem[0], 0);
pthread_set_mode_np(PTHREAD_WARNSW, 0);
test1_mem = check_mmap(mmap(0, MEMSIZE, PROT_NONE,
MAP_PRIVATE | MAP_ANONYMOUS, 0, 0));
check_unix(mprotect(test1_mem, MEMSIZE, PROT_READ | PROT_WRITE));
printf("memory read/write after access enable\n");
check_value("read mem", test1_mem[0], 0);
test1_mem[0] = 0xff;
check_value("read zero", zero_mem[0], 0);
fprintf(stderr, "Test OK\n");
return 0;
}
int main(void)
{
unsigned long long before;
struct sigevent sevt;
pthread_mutex_t mutex;
pthread_cond_t cond;
int fd, failed = 0;
pthread_t thread;
sem_t sem, *psem;
timer_t tm;
__maybe_unused pid_t child;
mlockall(MCL_CURRENT|MCL_FUTURE);
fprintf(stderr, "Checking for leaks in posix skin objects\n");
before = get_used();
check_pthread(pthread_create(&thread, NULL, empty, NULL));
check_pthread(pthread_join(thread, NULL));
sleep(1); /* Leave some time for xnheap
* deferred free */
check_used("thread", before, failed);
before = get_used();
check_pthread(pthread_mutex_init(&mutex, NULL));
check_pthread(pthread_mutex_destroy(&mutex));
check_used("mutex", before, failed);
before = get_used();
check_pthread(pthread_cond_init(&cond, NULL));
check_pthread(pthread_cond_destroy(&cond));
check_used("cond", before, failed);
before = get_used();
check_unix(sem_init(&sem, 0, 0));
check_unix(sem_destroy(&sem));
check_used("sem", before, failed);
before = get_used();
check_unix(-!(psem = sem_open(SEM_NAME, O_CREAT, 0644, 1)));
check_unix(sem_close(psem));
check_unix(sem_unlink(SEM_NAME));
check_used("named sem", before, failed);
before = get_used();
sevt.sigev_notify = SIGEV_THREAD_ID;
sevt.sigev_signo = SIGALRM;
sevt.sigev_notify_thread_id = syscall(__NR_gettid);
check_unix(timer_create(CLOCK_MONOTONIC, &sevt, &tm));
check_unix(timer_delete(tm));
check_used("timer", before, failed);
before = get_used();
check_unix(fd = mq_open(MQ_NAME, O_RDWR | O_CREAT, 0644, NULL));
check_unix(mq_close(fd));
check_unix(mq_unlink(MQ_NAME));
check_used("mq", before, failed);
#ifdef HAVE_FORK
before = get_used();
check_unix(child = fork());
if (!child) {
subprocess_leak();
return EXIT_SUCCESS;
}
while (waitpid(child, NULL, 0) == -1 && errno == EINTR);
sleep(1); /* Leave some time for xnheap
* deferred free */
check_unix(sem_unlink(SEM_NAME));
check_unix(mq_unlink(MQ_NAME));
check_used("fork", before, failed);
#endif
return failed ? EXIT_FAILURE : EXIT_SUCCESS;
}
void sig_norestart_double(void)
{
unsigned long long start;
mutex_t mutex;
cond_t cond;
struct cond_mutex cm = {
.mutex = &mutex,
.cond = &cond,
.tid = thread_self(),
};
thread_t double_killer_tid;
struct sigaction sa = {
.sa_handler = sighandler,
.sa_flags = 0,
};
sigemptyset(&sa.sa_mask);
fprintf(stderr, "%s\n", __FUNCTION__);
check_unix("sigaction", sigaction(SIGRTMIN, &sa, NULL), 0);
check("mutex_init", mutex_init(&mutex, PTHREAD_MUTEX_DEFAULT, 0), 0);
check("cond_init", cond_init(&cond, 0), 0);
check("mutex_lock", mutex_lock(&mutex), 0);
check("thread_spawn",
thread_spawn(&double_killer_tid, 2, double_killer, &cm), 0);
thread_msleep(11);
sig_seen = 0;
start = rt_timer_tsc();
check("cond_wait", cond_wait(&cond, &mutex, XN_INFINITE), 0);
check_sleep("cond_wait", start);
check("sig_seen", sig_seen, 2);
thread_msleep(10);
check("mutex_unlock", mutex_unlock(&mutex), 0);
check("thread_join", thread_join(double_killer_tid), 0);
check("mutex_destroy", mutex_destroy(&mutex), 0);
check("cond_destroy", cond_destroy(&cond), 0);
}
void sig_restart_double(void)
{
unsigned long long start;
mutex_t mutex;
cond_t cond;
struct cond_mutex cm = {
.mutex = &mutex,
.cond = &cond,
.tid = thread_self(),
};
thread_t double_killer_tid;
struct sigaction sa = {
.sa_handler = sighandler,
.sa_flags = SA_RESTART,
};
sigemptyset(&sa.sa_mask);
fprintf(stderr, "%s\n", __FUNCTION__);
check_unix("sigaction", sigaction(SIGRTMIN, &sa, NULL), 0);
check("mutex_init", mutex_init(&mutex, PTHREAD_MUTEX_DEFAULT, 0), 0);
check("cond_init", cond_init(&cond, 0), 0);
check("mutex_lock", mutex_lock(&mutex), 0);
check("thread_spawn",
thread_spawn(&double_killer_tid, 2, double_killer, &cm), 0);
thread_msleep(11);
sig_seen = 0;
start = rt_timer_tsc();
check("cond_wait", cond_wait(&cond, &mutex, XN_INFINITE), 0);
check_sleep("cond_wait", start);
check("sig_seen", sig_seen, 2);
thread_msleep(10);
check("mutex_unlock", mutex_unlock(&mutex), 0);
check("thread_join", thread_join(double_killer_tid), 0);
check("mutex_destroy", mutex_destroy(&mutex), 0);
check("cond_destroy", cond_destroy(&cond), 0);
}
void sig_norestart_condwait(void)
{
unsigned long long start;
mutex_t mutex;
cond_t cond;
struct cond_mutex cm = {
.mutex = &mutex,
.cond = &cond,
.tid = thread_self(),
};
thread_t cond_killer_tid;
struct sigaction sa = {
.sa_handler = sighandler,
.sa_flags = 0,
};
sigemptyset(&sa.sa_mask);
fprintf(stderr, "%s\n", __FUNCTION__);
check_unix("sigaction", sigaction(SIGRTMIN, &sa, NULL), 0);
check("mutex_init", mutex_init(&mutex, PTHREAD_MUTEX_DEFAULT, 0), 0);
check("cond_init", cond_init(&cond, 0), 0);
check("mutex_lock", mutex_lock(&mutex), 0);
check("thread_spawn",
thread_spawn(&cond_killer_tid, 2, cond_killer, &cm), 0);
thread_msleep(11);
start = rt_timer_tsc();
sig_seen = 0;
#ifdef XENO_POSIX
check("cond_wait", cond_wait(&cond, &mutex, XN_INFINITE), 0);
#else /* native */
{
int err = cond_wait(&cond, &mutex, XN_INFINITE);
if (err == 0)
err = -EINTR;
check("cond_wait", err, -EINTR);
}
#endif /* native */
check_sleep("cond_wait", start);
check("sig_seen", sig_seen, 1);
check("mutex_unlock", mutex_unlock(&mutex), 0);
check("thread_join", thread_join(cond_killer_tid), 0);
check("mutex_destroy", mutex_destroy(&mutex), 0);
check("cond_destroy", cond_destroy(&cond), 0);
}
void sig_restart_condwait(void)
{
unsigned long long start;
mutex_t mutex;
cond_t cond;
struct cond_mutex cm = {
.mutex = &mutex,
.cond = &cond,
.tid = thread_self(),
};
thread_t cond_killer_tid;
struct sigaction sa = {
.sa_handler = sighandler,
.sa_flags = 0,
};
sigemptyset(&sa.sa_mask);
fprintf(stderr, "%s\n", __FUNCTION__);
check_unix("sigaction", sigaction(SIGRTMIN, &sa, NULL), 0);
check("mutex_init", mutex_init(&mutex, PTHREAD_MUTEX_DEFAULT, 0), 0);
check("cond_init", cond_init(&cond, 0), 0);
check("mutex_lock", mutex_lock(&mutex), 0);
check("thread_spawn",
thread_spawn(&cond_killer_tid, 2, cond_killer, &cm), 0);
thread_msleep(11);
start = rt_timer_tsc();
sig_seen = 0;
#ifdef XENO_POSIX
check("cond_wait", cond_wait(&cond, &mutex, XN_INFINITE), 0);
#else /* native */
{
int err = cond_wait(&cond, &mutex, XN_INFINITE);
if (err == 0)
err = -EINTR;
check("cond_wait", err, -EINTR);
}
#endif /* native */
check_sleep("cond_wait", start);
check("sig_seen", sig_seen, 1);
check("mutex_unlock", mutex_unlock(&mutex), 0);
check("thread_join", thread_join(cond_killer_tid), 0);
check("mutex_destroy", mutex_destroy(&mutex), 0);
check("cond_destroy", cond_destroy(&cond), 0);
}
void *mutex_killer(void *cookie)
{
unsigned long long start;
struct cond_mutex *cm = cookie;
start = rt_timer_tsc();
check("mutex_lock", mutex_lock(cm->mutex), 0);
check_sleep("mutex_lock", start);
check("cond_signal", cond_signal(cm->cond), 0);
thread_msleep(10);
check("thread_kill", thread_kill(cm->tid, SIGRTMIN), 0);
check("mutex_unlock", mutex_unlock(cm->mutex), 0);
return NULL;
}
int main(void)
{
unsigned long long before;
struct sigevent sevt;
pthread_mutex_t mutex;
pthread_cond_t cond;
int fd, failed = 0;
pthread_t thread;
sem_t sem, *psem;
timer_t tm;
void *shm;
mlockall(MCL_CURRENT|MCL_FUTURE);
fprintf(stderr, "Checking for leaks in posix skin objects\n");
before = get_used();
check_pthread(pthread_create(&thread, NULL, empty, NULL));
check_pthread(pthread_join(thread, NULL));
sleep(1); /* Leave some time for xnheap
* deferred free */
check_used("thread", before, failed);
before = get_used();
check_pthread(pthread_mutex_init(&mutex, NULL));
check_pthread(pthread_mutex_destroy(&mutex));
check_used("mutex", before, failed);
before = get_used();
check_pthread(pthread_cond_init(&cond, NULL));
check_pthread(pthread_cond_destroy(&cond));
check_used("cond", before, failed);
before = get_used();
check_unix(sem_init(&sem, 0, 0));
check_unix(sem_destroy(&sem));
check_used("sem", before, failed);
before = get_used();
check_unix(-!(psem = sem_open(SEM_NAME, O_CREAT, 0644, 1)));
check_unix(sem_close(psem));
check_unix(sem_unlink(SEM_NAME));
check_used("named sem", before, failed);
before = get_used();
sevt.sigev_notify = SIGEV_SIGNAL;
sevt.sigev_signo = SIGALRM;
check_unix(timer_create(CLOCK_MONOTONIC, &sevt, &tm));
check_unix(timer_delete(tm));
check_used("timer", before, failed);
before = get_used();
check_unix(fd = shm_open(SHM_NAME, O_CREAT | O_RDWR, 0644));
check_unix(ftruncate(fd, SHM_SZ));
shm = mmap(NULL, SHM_SZ, PROT_READ, MAP_SHARED, fd, 0);
check_unix(shm == MAP_FAILED ? -1 : 0);
check_unix(munmap(shm, SHM_SZ));
check_unix(close(fd));
check_unix(shm_unlink(SHM_NAME));
check_used("shm", before, failed);
before = get_used();
check_unix(fd = mq_open(MQ_NAME, O_RDWR | O_CREAT, 0644, NULL));
check_unix(mq_close(fd));
check_unix(mq_unlink(MQ_NAME));
check_used("mq", before, failed);
return failed ? EXIT_FAILURE : EXIT_SUCCESS;
}
