[qemu.git] / tests / tcg / linux-test.c

/*
 *  linux and CPU test
 *
 *  Copyright (c) 2003 Fabrice Bellard
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, see <http://www.gnu.org/licenses/>.
 */
#define _GNU_SOURCE
#include <stdarg.h>
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include <inttypes.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <errno.h>
#include <utime.h>
#include <time.h>
#include <sys/time.h>
#include <sys/uio.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sched.h>
#include <dirent.h>
#include <setjmp.h>
#include <sys/shm.h>
#include <sched.h>

#define TESTPATH "/tmp/linux-test.tmp"
#define TESTPORT 7654
#define STACK_SIZE 16384

void error1(const char *filename, int line, const char *fmt, ...)
{
    va_list ap;
    va_start(ap, fmt);
    fprintf(stderr, "%s:%d: ", filename, line);
    vfprintf(stderr, fmt, ap);
    fprintf(stderr, "\n");
    va_end(ap);
    exit(1);
}

int __chk_error(const char *filename, int line, int ret)
{
    if (ret < 0) {
        error1(filename, line, "%m (ret=%d, errno=%d)",
               ret, errno);
    }
    return ret;
}

#define error(fmt, ...) error1(__FILE__, __LINE__, fmt, ## __VA_ARGS__)

#define chk_error(ret) __chk_error(__FILE__, __LINE__, (ret))

/*******************************************************/

#define FILE_BUF_SIZE 300

void test_file(void)
{
    int fd, i, len, ret;
    uint8_t buf[FILE_BUF_SIZE];
    uint8_t buf2[FILE_BUF_SIZE];
    uint8_t buf3[FILE_BUF_SIZE];
    char cur_dir[1024];
    struct stat st;
    struct utimbuf tbuf;
    struct iovec vecs[2];
    DIR *dir;
    struct dirent *de;

    /* clean up, just in case */
    unlink(TESTPATH "/file1");
    unlink(TESTPATH "/file2");
    unlink(TESTPATH "/file3");
    rmdir(TESTPATH);

    if (getcwd(cur_dir, sizeof(cur_dir)) == NULL)
        error("getcwd");

    chk_error(mkdir(TESTPATH, 0755));

    chk_error(chdir(TESTPATH));

    /* open/read/write/close/readv/writev/lseek */

    fd = chk_error(open("file1", O_WRONLY | O_TRUNC | O_CREAT, 0644));
    for(i=0;i < FILE_BUF_SIZE; i++)
        buf[i] = i;
    len = chk_error(write(fd, buf, FILE_BUF_SIZE / 2));
    if (len != (FILE_BUF_SIZE / 2))
        error("write");
    vecs[0].iov_base = buf + (FILE_BUF_SIZE / 2);
    vecs[0].iov_len = 16;
    vecs[1].iov_base = buf + (FILE_BUF_SIZE / 2) + 16;
    vecs[1].iov_len = (FILE_BUF_SIZE / 2) - 16;
    len = chk_error(writev(fd, vecs, 2));
    if (len != (FILE_BUF_SIZE / 2))
     error("writev");
    chk_error(close(fd));

    chk_error(rename("file1", "file2"));

    fd = chk_error(open("file2", O_RDONLY));

    len = chk_error(read(fd, buf2, FILE_BUF_SIZE));
    if (len != FILE_BUF_SIZE)
        error("read");
    if (memcmp(buf, buf2, FILE_BUF_SIZE) != 0)
        error("memcmp");

#define FOFFSET 16
    ret = chk_error(lseek(fd, FOFFSET, SEEK_SET));
    if (ret != 16)
        error("lseek");
    vecs[0].iov_base = buf3;
    vecs[0].iov_len = 32;
    vecs[1].iov_base = buf3 + 32;
    vecs[1].iov_len = FILE_BUF_SIZE - FOFFSET - 32;
    len = chk_error(readv(fd, vecs, 2));
    if (len != FILE_BUF_SIZE - FOFFSET)
        error("readv");
    if (memcmp(buf + FOFFSET, buf3, FILE_BUF_SIZE - FOFFSET) != 0)
        error("memcmp");

    chk_error(close(fd));

    /* access */
    chk_error(access("file2", R_OK));

    /* stat/chmod/utime/truncate */

    chk_error(chmod("file2", 0600));
    tbuf.actime = 1001;
    tbuf.modtime = 1000;
    chk_error(truncate("file2", 100));
    chk_error(utime("file2", &tbuf));
    chk_error(stat("file2", &st));
    if (st.st_size != 100)
        error("stat size");
    if (!S_ISREG(st.st_mode))
        error("stat mode");
    if ((st.st_mode & 0777) != 0600)
        error("stat mode2");
    if (st.st_atime != 1001 ||
        st.st_mtime != 1000)
        error("stat time");

    chk_error(stat(TESTPATH, &st));
    if (!S_ISDIR(st.st_mode))
        error("stat mode");

    /* fstat */
    fd = chk_error(open("file2", O_RDWR));
    chk_error(ftruncate(fd, 50));
    chk_error(fstat(fd, &st));
    chk_error(close(fd));

    if (st.st_size != 50)
        error("stat size");
    if (!S_ISREG(st.st_mode))
        error("stat mode");

    /* symlink/lstat */
    chk_error(symlink("file2", "file3"));
    chk_error(lstat("file3", &st));
    if (!S_ISLNK(st.st_mode))
        error("stat mode");

    /* getdents */
    dir = opendir(TESTPATH);
    if (!dir)
        error("opendir");
    len = 0;
    for(;;) {
        de = readdir(dir);
        if (!de)
            break;
        if (strcmp(de->d_name, ".") != 0 &&
            strcmp(de->d_name, "..") != 0 &&
            strcmp(de->d_name, "file2") != 0 &&
            strcmp(de->d_name, "file3") != 0)
            error("readdir");
        len++;
    }
    closedir(dir);
    if (len != 4)
        error("readdir");

    chk_error(unlink("file3"));
    chk_error(unlink("file2"));
    chk_error(chdir(cur_dir));
    chk_error(rmdir(TESTPATH));
}

void test_fork(void)
{
    int pid, status;

    pid = chk_error(fork());
    if (pid == 0) {
        /* child */
        exit(2);
    }
    chk_error(waitpid(pid, &status, 0));
    if (!WIFEXITED(status) || WEXITSTATUS(status) != 2)
        error("waitpid status=0x%x", status);
}

void test_time(void)
{
    struct timeval tv, tv2;
    struct timespec ts, rem;
    struct rusage rusg1, rusg2;
    int ti, i;

    chk_error(gettimeofday(&tv, NULL));
    rem.tv_sec = 1;
    ts.tv_sec = 0;
    ts.tv_nsec = 20 * 1000000;
    chk_error(nanosleep(&ts, &rem));
    if (rem.tv_sec != 1)
        error("nanosleep");
    chk_error(gettimeofday(&tv2, NULL));
    ti = tv2.tv_sec - tv.tv_sec;
    if (ti >= 2)
        error("gettimeofday");

    chk_error(getrusage(RUSAGE_SELF, &rusg1));
    for(i = 0;i < 10000; i++);
    chk_error(getrusage(RUSAGE_SELF, &rusg2));
    if ((rusg2.ru_utime.tv_sec - rusg1.ru_utime.tv_sec) < 0 ||
        (rusg2.ru_stime.tv_sec - rusg1.ru_stime.tv_sec) < 0)
        error("getrusage");
}

void pstrcpy(char *buf, int buf_size, const char *str)
{
    int c;
    char *q = buf;

    if (buf_size <= 0)
        return;

    for(;;) {
        c = *str++;
        if (c == 0 || q >= buf + buf_size - 1)
            break;
        *q++ = c;
    }
    *q = '\0';
}

/* strcat and truncate. */
char *pstrcat(char *buf, int buf_size, const char *s)
{
    int len;
    len = strlen(buf);
    if (len < buf_size)
        pstrcpy(buf + len, buf_size - len, s);
    return buf;
}

int server_socket(void)
{
    int val, fd;
    struct sockaddr_in sockaddr;

    /* server socket */
    fd = chk_error(socket(PF_INET, SOCK_STREAM, 0));

    val = 1;
    chk_error(setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &val, sizeof(val)));

    sockaddr.sin_family = AF_INET;
    sockaddr.sin_port = htons(TESTPORT);
    sockaddr.sin_addr.s_addr = 0;
    chk_error(bind(fd, (struct sockaddr *)&sockaddr, sizeof(sockaddr)));
    chk_error(listen(fd, 0));
    return fd;

}

int client_socket(void)
{
    int fd;
    struct sockaddr_in sockaddr;

    /* server socket */
    fd = chk_error(socket(PF_INET, SOCK_STREAM, 0));
    sockaddr.sin_family = AF_INET;
    sockaddr.sin_port = htons(TESTPORT);
    inet_aton("127.0.0.1", &sockaddr.sin_addr);
    chk_error(connect(fd, (struct sockaddr *)&sockaddr, sizeof(sockaddr)));
    return fd;
}

const char socket_msg[] = "hello socket\n";

void test_socket(void)
{
    int server_fd, client_fd, fd, pid, ret, val;
    struct sockaddr_in sockaddr;
    socklen_t len;
    char buf[512];

    server_fd = server_socket();

    /* test a few socket options */
    len = sizeof(val);
    chk_error(getsockopt(server_fd, SOL_SOCKET, SO_TYPE, &val, &len));
    if (val != SOCK_STREAM)
        error("getsockopt");

    pid = chk_error(fork());
    if (pid == 0) {
        client_fd = client_socket();
        send(client_fd, socket_msg, sizeof(socket_msg), 0);
        close(client_fd);
        exit(0);
    }
    len = sizeof(sockaddr);
    fd = chk_error(accept(server_fd, (struct sockaddr *)&sockaddr, &len));

    ret = chk_error(recv(fd, buf, sizeof(buf), 0));
    if (ret != sizeof(socket_msg))
        error("recv");
    if (memcmp(buf, socket_msg, sizeof(socket_msg)) != 0)
        error("socket_msg");
    chk_error(close(fd));
    chk_error(close(server_fd));
}

#define WCOUNT_MAX 512

void test_pipe(void)
{
    fd_set rfds, wfds;
    int fds[2], fd_max, ret;
    uint8_t ch;
    int wcount, rcount;

    chk_error(pipe(fds));
    chk_error(fcntl(fds[0], F_SETFL, O_NONBLOCK));
    chk_error(fcntl(fds[1], F_SETFL, O_NONBLOCK));
    wcount = 0;
    rcount = 0;
    for(;;) {
        FD_ZERO(&rfds);
        fd_max = fds[0];
        FD_SET(fds[0], &rfds);

        FD_ZERO(&wfds);
        FD_SET(fds[1], &wfds);
        if (fds[1] > fd_max)
            fd_max = fds[1];

        ret = chk_error(select(fd_max + 1, &rfds, &wfds, NULL, NULL));
        if (ret > 0) {
            if (FD_ISSET(fds[0], &rfds)) {
                chk_error(read(fds[0], &ch, 1));
                rcount++;
                if (rcount >= WCOUNT_MAX)
                    break;
            }
            if (FD_ISSET(fds[1], &wfds)) {
                ch = 'a';
                chk_error(write(fds[0], &ch, 1));
                wcount++;
            }
        }
    }
    chk_error(close(fds[0]));
    chk_error(close(fds[1]));
}

int thread1_res;
int thread2_res;

int thread1_func(void *arg)
{
    int i;
    for(i=0;i<5;i++) {
        thread1_res++;
        usleep(10 * 1000);
    }
    return 0;
}

int thread2_func(void *arg)
{
    int i;
    for(i=0;i<6;i++) {
        thread2_res++;
        usleep(10 * 1000);
    }
    return 0;
}

void test_clone(void)
{
    uint8_t *stack1, *stack2;
    int pid1, pid2, status1, status2;

    stack1 = malloc(STACK_SIZE);
    pid1 = chk_error(clone(thread1_func, stack1 + STACK_SIZE,
                           CLONE_VM | CLONE_FS | CLONE_FILES | SIGCHLD, "hello1"));

    stack2 = malloc(STACK_SIZE);
    pid2 = chk_error(clone(thread2_func, stack2 + STACK_SIZE,
                           CLONE_VM | CLONE_FS | CLONE_FILES | SIGCHLD, "hello2"));

    while (waitpid(pid1, &status1, 0) != pid1);
    free(stack1);
    while (waitpid(pid2, &status2, 0) != pid2);
    free(stack2);
    if (thread1_res != 5 ||
        thread2_res != 6)
        error("clone");
}

/***********************************/

volatile int alarm_count;
jmp_buf jmp_env;

void sig_alarm(int sig)
{
    if (sig != SIGALRM)
        error("signal");
    alarm_count++;
}

void sig_segv(int sig, siginfo_t *info, void *puc)
{
    if (sig != SIGSEGV)
        error("signal");
    longjmp(jmp_env, 1);
}

void test_signal(void)
{
    struct sigaction act;
    struct itimerval it, oit;

    /* timer test */

    alarm_count = 0;

    act.sa_handler = sig_alarm;
    sigemptyset(&act.sa_mask);
    act.sa_flags = 0;
    chk_error(sigaction(SIGALRM, &act, NULL));

    it.it_interval.tv_sec = 0;
    it.it_interval.tv_usec = 10 * 1000;
    it.it_value.tv_sec = 0;
    it.it_value.tv_usec = 10 * 1000;
    chk_error(setitimer(ITIMER_REAL, &it, NULL));
    chk_error(getitimer(ITIMER_REAL, &oit));
    if (oit.it_value.tv_sec != it.it_value.tv_sec ||
        oit.it_value.tv_usec != it.it_value.tv_usec)
        error("itimer");

    while (alarm_count < 5) {
        usleep(10 * 1000);
    }

    it.it_interval.tv_sec = 0;
    it.it_interval.tv_usec = 0;
    it.it_value.tv_sec = 0;
    it.it_value.tv_usec = 0;
    memset(&oit, 0xff, sizeof(oit));
    chk_error(setitimer(ITIMER_REAL, &it, &oit));
    if (oit.it_value.tv_sec != 0 ||
        oit.it_value.tv_usec != 10 * 1000)
        error("setitimer");

    /* SIGSEGV test */
    act.sa_sigaction = sig_segv;
    sigemptyset(&act.sa_mask);
    act.sa_flags = SA_SIGINFO;
    chk_error(sigaction(SIGSEGV, &act, NULL));
    if (setjmp(jmp_env) == 0) {
        *(uint8_t *)0 = 0;
    }

    act.sa_handler = SIG_DFL;
    sigemptyset(&act.sa_mask);
    act.sa_flags = 0;
    chk_error(sigaction(SIGSEGV, &act, NULL));
}

#define SHM_SIZE 32768

void test_shm(void)
{
    void *ptr;
    int shmid;

    shmid = chk_error(shmget(IPC_PRIVATE, SHM_SIZE, IPC_CREAT | 0777));
    ptr = shmat(shmid, NULL, 0);
    if (!ptr)
        error("shmat");

    memset(ptr, 0, SHM_SIZE);

    chk_error(shmctl(shmid, IPC_RMID, 0));
    chk_error(shmdt(ptr));
}

int main(int argc, char **argv)
{
    test_file();
    test_fork();
    test_time();
    test_socket();
    //    test_clone();
    test_signal();
    test_shm();
    return 0;
}
Commit	Line	Data
196ad109 FB	1	/*
196ad109 FB	2	* linux and CPU test
5fafdf24	3	*
196ad109 FB	4	* Copyright (c) 2003 Fabrice Bellard
	5	*
	6	* This program is free software; you can redistribute it and/or modify
	7	* it under the terms of the GNU General Public License as published by
	8	* the Free Software Foundation; either version 2 of the License, or
	9	* (at your option) any later version.
	10	*
	11	* This program is distributed in the hope that it will be useful,
	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	* GNU General Public License for more details.
	15	*
	16	* You should have received a copy of the GNU General Public License
8167ee88	17	* along with this program; if not, see <http://www.gnu.org/licenses/>.
196ad109	18	*/
f62cb1b6	19	#define _GNU_SOURCE
196ad109 FB	20	#include <stdarg.h>
	21	#include <stdlib.h>
	22	#include <stdio.h>
	23	#include <unistd.h>
	24	#include <fcntl.h>
	25	#include <inttypes.h>
	26	#include <string.h>
	27	#include <sys/types.h>
	28	#include <sys/stat.h>
	29	#include <sys/wait.h>
	30	#include <errno.h>
	31	#include <utime.h>
	32	#include <time.h>
	33	#include <sys/time.h>
	34	#include <sys/uio.h>
	35	#include <sys/socket.h>
	36	#include <netinet/in.h>
	37	#include <arpa/inet.h>
	38	#include <sched.h>
	39	#include <dirent.h>
	40	#include <setjmp.h>
e374bfa3	41	#include <sys/shm.h>
f62cb1b6	42	#include <sched.h>
196ad109 FB	43
	44	#define TESTPATH "/tmp/linux-test.tmp"
	45	#define TESTPORT 7654
	46	#define STACK_SIZE 16384
	47
	48	void error1(const char filename, int line, const char fmt, ...)
	49	{
	50	va_list ap;
	51	va_start(ap, fmt);
	52	fprintf(stderr, "%s:%d: ", filename, line);
	53	vfprintf(stderr, fmt, ap);
	54	fprintf(stderr, "\n");
	55	va_end(ap);
	56	exit(1);
	57	}
	58
	59	int __chk_error(const char *filename, int line, int ret)
	60	{
	61	if (ret < 0) {
5fafdf24	62	error1(filename, line, "%m (ret=%d, errno=%d)",
196ad109 FB	63	ret, errno);
	64	}
	65	return ret;
	66	}
	67
001faf32	68	#define error(fmt, ...) error1(__FILE__, __LINE__, fmt, ## __VA_ARGS__)
196ad109 FB	69
	70	#define chk_error(ret) __chk_error(__FILE__, __LINE__, (ret))
	71
	72	/*******************************************************/
	73
	74	#define FILE_BUF_SIZE 300
	75
285dc330	76	void test_file(void)
196ad109 FB	77	{
	78	int fd, i, len, ret;
	79	uint8_t buf[FILE_BUF_SIZE];
	80	uint8_t buf2[FILE_BUF_SIZE];
	81	uint8_t buf3[FILE_BUF_SIZE];
	82	char cur_dir[1024];
	83	struct stat st;
	84	struct utimbuf tbuf;
	85	struct iovec vecs[2];
	86	DIR *dir;
	87	struct dirent *de;
	88
	89	/* clean up, just in case */
	90	unlink(TESTPATH "/file1");
	91	unlink(TESTPATH "/file2");
	92	unlink(TESTPATH "/file3");
	93	rmdir(TESTPATH);
	94
	95	if (getcwd(cur_dir, sizeof(cur_dir)) == NULL)
	96	error("getcwd");
3b46e624	97
196ad109	98	chk_error(mkdir(TESTPATH, 0755));
3b46e624	99
196ad109	100	chk_error(chdir(TESTPATH));
3b46e624	101
196ad109 FB	102	/* open/read/write/close/readv/writev/lseek */
	103
	104	fd = chk_error(open("file1", O_WRONLY \| O_TRUNC \| O_CREAT, 0644));
	105	for(i=0;i < FILE_BUF_SIZE; i++)
	106	buf[i] = i;
	107	len = chk_error(write(fd, buf, FILE_BUF_SIZE / 2));
	108	if (len != (FILE_BUF_SIZE / 2))
	109	error("write");
	110	vecs[0].iov_base = buf + (FILE_BUF_SIZE / 2);
	111	vecs[0].iov_len = 16;
	112	vecs[1].iov_base = buf + (FILE_BUF_SIZE / 2) + 16;
	113	vecs[1].iov_len = (FILE_BUF_SIZE / 2) - 16;
	114	len = chk_error(writev(fd, vecs, 2));
	115	if (len != (FILE_BUF_SIZE / 2))
	116	error("writev");
	117	chk_error(close(fd));
	118
	119	chk_error(rename("file1", "file2"));
	120
	121	fd = chk_error(open("file2", O_RDONLY));
	122
	123	len = chk_error(read(fd, buf2, FILE_BUF_SIZE));
	124	if (len != FILE_BUF_SIZE)
	125	error("read");
	126	if (memcmp(buf, buf2, FILE_BUF_SIZE) != 0)
	127	error("memcmp");
3b46e624	128
196ad109 FB	129	#define FOFFSET 16
	130	ret = chk_error(lseek(fd, FOFFSET, SEEK_SET));
	131	if (ret != 16)
	132	error("lseek");
	133	vecs[0].iov_base = buf3;
	134	vecs[0].iov_len = 32;
	135	vecs[1].iov_base = buf3 + 32;
	136	vecs[1].iov_len = FILE_BUF_SIZE - FOFFSET - 32;
	137	len = chk_error(readv(fd, vecs, 2));
	138	if (len != FILE_BUF_SIZE - FOFFSET)
	139	error("readv");
	140	if (memcmp(buf + FOFFSET, buf3, FILE_BUF_SIZE - FOFFSET) != 0)
	141	error("memcmp");
3b46e624	142
196ad109 FB	143	chk_error(close(fd));
	144
	145	/* access */
	146	chk_error(access("file2", R_OK));
	147
	148	/* stat/chmod/utime/truncate */
	149
	150	chk_error(chmod("file2", 0600));
	151	tbuf.actime = 1001;
	152	tbuf.modtime = 1000;
	153	chk_error(truncate("file2", 100));
	154	chk_error(utime("file2", &tbuf));
	155	chk_error(stat("file2", &st));
	156	if (st.st_size != 100)
	157	error("stat size");
	158	if (!S_ISREG(st.st_mode))
	159	error("stat mode");
	160	if ((st.st_mode & 0777) != 0600)
	161	error("stat mode2");
	162	if (st.st_atime != 1001 \|\|
	163	st.st_mtime != 1000)
	164	error("stat time");
	165
	166	chk_error(stat(TESTPATH, &st));
	167	if (!S_ISDIR(st.st_mode))
	168	error("stat mode");
	169
	170	/* fstat */
	171	fd = chk_error(open("file2", O_RDWR));
	172	chk_error(ftruncate(fd, 50));
	173	chk_error(fstat(fd, &st));
	174	chk_error(close(fd));
3b46e624	175
196ad109 FB	176	if (st.st_size != 50)
	177	error("stat size");
	178	if (!S_ISREG(st.st_mode))
	179	error("stat mode");
3b46e624	180
196ad109 FB	181	/* symlink/lstat */
	182	chk_error(symlink("file2", "file3"));
	183	chk_error(lstat("file3", &st));
	184	if (!S_ISLNK(st.st_mode))
	185	error("stat mode");
3b46e624	186
196ad109 FB	187	/* getdents */
	188	dir = opendir(TESTPATH);
	189	if (!dir)
	190	error("opendir");
	191	len = 0;
	192	for(;;) {
	193	de = readdir(dir);
	194	if (!de)
	195	break;
	196	if (strcmp(de->d_name, ".") != 0 &&
	197	strcmp(de->d_name, "..") != 0 &&
	198	strcmp(de->d_name, "file2") != 0 &&
	199	strcmp(de->d_name, "file3") != 0)
	200	error("readdir");
	201	len++;
	202	}
	203	closedir(dir);
	204	if (len != 4)
	205	error("readdir");
	206
	207	chk_error(unlink("file3"));
	208	chk_error(unlink("file2"));
	209	chk_error(chdir(cur_dir));
	210	chk_error(rmdir(TESTPATH));
	211	}
	212
	213	void test_fork(void)
	214	{
	215	int pid, status;
	216
	217	pid = chk_error(fork());
	218	if (pid == 0) {
	219	/* child */
	220	exit(2);
	221	}
	222	chk_error(waitpid(pid, &status, 0));
	223	if (!WIFEXITED(status) \|\| WEXITSTATUS(status) != 2)
	224	error("waitpid status=0x%x", status);
	225	}
	226
	227	void test_time(void)
	228	{
	229	struct timeval tv, tv2;
	230	struct timespec ts, rem;
	231	struct rusage rusg1, rusg2;
	232	int ti, i;
	233
	234	chk_error(gettimeofday(&tv, NULL));
	235	rem.tv_sec = 1;
	236	ts.tv_sec = 0;
	237	ts.tv_nsec = 20 * 1000000;
	238	chk_error(nanosleep(&ts, &rem));
	239	if (rem.tv_sec != 1)
	240	error("nanosleep");
	241	chk_error(gettimeofday(&tv2, NULL));
	242	ti = tv2.tv_sec - tv.tv_sec;
	243	if (ti >= 2)
	244	error("gettimeofday");
3b46e624	245
196ad109 FB	246	chk_error(getrusage(RUSAGE_SELF, &rusg1));
	247	for(i = 0;i < 10000; i++);
	248	chk_error(getrusage(RUSAGE_SELF, &rusg2));
	249	if ((rusg2.ru_utime.tv_sec - rusg1.ru_utime.tv_sec) < 0 \|\|
	250	(rusg2.ru_stime.tv_sec - rusg1.ru_stime.tv_sec) < 0)
	251	error("getrusage");
	252	}
	253
	254	void pstrcpy(char buf, int buf_size, const char str)
	255	{
	256	int c;
	257	char *q = buf;
	258
	259	if (buf_size <= 0)
	260	return;
	261
	262	for(;;) {
	263	c = *str++;
	264	if (c == 0 \|\| q >= buf + buf_size - 1)
	265	break;
	266	*q++ = c;
	267	}
	268	*q = '\0';
	269	}
	270
	271	/* strcat and truncate. */
	272	char pstrcat(char buf, int buf_size, const char *s)
	273	{
	274	int len;
	275	len = strlen(buf);
5fafdf24	276	if (len < buf_size)
196ad109 FB	277	pstrcpy(buf + len, buf_size - len, s);
	278	return buf;
	279	}
	280
	281	int server_socket(void)
	282	{
	283	int val, fd;
	284	struct sockaddr_in sockaddr;
	285
	286	/* server socket */
	287	fd = chk_error(socket(PF_INET, SOCK_STREAM, 0));
	288
	289	val = 1;
	290	chk_error(setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &val, sizeof(val)));
	291
	292	sockaddr.sin_family = AF_INET;
	293	sockaddr.sin_port = htons(TESTPORT);
	294	sockaddr.sin_addr.s_addr = 0;
	295	chk_error(bind(fd, (struct sockaddr *)&sockaddr, sizeof(sockaddr)));
	296	chk_error(listen(fd, 0));
	297	return fd;
	298
	299	}
	300
	301	int client_socket(void)
	302	{
	303	int fd;
	304	struct sockaddr_in sockaddr;
	305
	306	/* server socket */
	307	fd = chk_error(socket(PF_INET, SOCK_STREAM, 0));
	308	sockaddr.sin_family = AF_INET;
	309	sockaddr.sin_port = htons(TESTPORT);
	310	inet_aton("127.0.0.1", &sockaddr.sin_addr);
	311	chk_error(connect(fd, (struct sockaddr *)&sockaddr, sizeof(sockaddr)));
	312	return fd;
	313	}
	314
	315	const char socket_msg[] = "hello socket\n";
	316
	317	void test_socket(void)
	318	{
e374bfa3	319	int server_fd, client_fd, fd, pid, ret, val;
196ad109 FB	320	struct sockaddr_in sockaddr;
	321	socklen_t len;
	322	char buf[512];
	323
	324	server_fd = server_socket();
e374bfa3 FB	325
	326	/* test a few socket options */
	327	len = sizeof(val);
	328	chk_error(getsockopt(server_fd, SOL_SOCKET, SO_TYPE, &val, &len));
	329	if (val != SOCK_STREAM)
	330	error("getsockopt");
3b46e624	331
196ad109 FB	332	pid = chk_error(fork());
	333	if (pid == 0) {
	334	client_fd = client_socket();
	335	send(client_fd, socket_msg, sizeof(socket_msg), 0);
	336	close(client_fd);
	337	exit(0);
	338	}
	339	len = sizeof(sockaddr);
	340	fd = chk_error(accept(server_fd, (struct sockaddr *)&sockaddr, &len));
	341
	342	ret = chk_error(recv(fd, buf, sizeof(buf), 0));
	343	if (ret != sizeof(socket_msg))
	344	error("recv");
	345	if (memcmp(buf, socket_msg, sizeof(socket_msg)) != 0)
	346	error("socket_msg");
	347	chk_error(close(fd));
	348	chk_error(close(server_fd));
	349	}
	350
	351	#define WCOUNT_MAX 512
	352
	353	void test_pipe(void)
	354	{
	355	fd_set rfds, wfds;
	356	int fds[2], fd_max, ret;
	357	uint8_t ch;
	358	int wcount, rcount;
	359
	360	chk_error(pipe(fds));
	361	chk_error(fcntl(fds[0], F_SETFL, O_NONBLOCK));
	362	chk_error(fcntl(fds[1], F_SETFL, O_NONBLOCK));
	363	wcount = 0;
	364	rcount = 0;
	365	for(;;) {
	366	FD_ZERO(&rfds);
	367	fd_max = fds[0];
	368	FD_SET(fds[0], &rfds);
	369
	370	FD_ZERO(&wfds);
	371	FD_SET(fds[1], &wfds);
	372	if (fds[1] > fd_max)
	373	fd_max = fds[1];
	374
	375	ret = chk_error(select(fd_max + 1, &rfds, &wfds, NULL, NULL));
	376	if (ret > 0) {
	377	if (FD_ISSET(fds[0], &rfds)) {
	378	chk_error(read(fds[0], &ch, 1));
	379	rcount++;
	380	if (rcount >= WCOUNT_MAX)
	381	break;
	382	}
	383	if (FD_ISSET(fds[1], &wfds)) {
	384	ch = 'a';
	385	chk_error(write(fds[0], &ch, 1));
	386	wcount++;
	387	}
	388	}
	389	}
	390	chk_error(close(fds[0]));
	391	chk_error(close(fds[1]));
	392	}
	393
	394	int thread1_res;
	395	int thread2_res;
396
397	int thread1_func(void *arg)
398	{
399	int i;
400	for(i=0;i<5;i++) {
401	thread1_res++;
402	usleep(10 * 1000);
403	}
404	return 0;
405	}
406
407	int thread2_func(void *arg)
408	{
409	int i;
410	for(i=0;i<6;i++) {
411	thread2_res++;
412	usleep(10 * 1000);
413	}
414	return 0;
415	}
416
417	void test_clone(void)
418	{
419	uint8_t stack1, stack2;
420	int pid1, pid2, status1, status2;
421
422	stack1 = malloc(STACK_SIZE);
5fafdf24	423	pid1 = chk_error(clone(thread1_func, stack1 + STACK_SIZE,
196ad109 FB	424	CLONE_VM \| CLONE_FS \| CLONE_FILES \| SIGCHLD, "hello1"));
	425
	426	stack2 = malloc(STACK_SIZE);
5fafdf24	427	pid2 = chk_error(clone(thread2_func, stack2 + STACK_SIZE,
196ad109 FB	428	CLONE_VM \| CLONE_FS \| CLONE_FILES \| SIGCHLD, "hello2"));
	429
	430	while (waitpid(pid1, &status1, 0) != pid1);
8da91fff	431	free(stack1);
196ad109	432	while (waitpid(pid2, &status2, 0) != pid2);
8da91fff	433	free(stack2);
196ad109 FB	434	if (thread1_res != 5 \|\|
	435	thread2_res != 6)
	436	error("clone");
	437	}
	438
	439	/***********************************/
	440
	441	volatile int alarm_count;
	442	jmp_buf jmp_env;
	443
	444	void sig_alarm(int sig)
	445	{
	446	if (sig != SIGALRM)
	447	error("signal");
	448	alarm_count++;
	449	}
	450
	451	void sig_segv(int sig, siginfo_t info, void puc)
	452	{
	453	if (sig != SIGSEGV)
	454	error("signal");
	455	longjmp(jmp_env, 1);
	456	}
	457
	458	void test_signal(void)
	459	{
	460	struct sigaction act;
	461	struct itimerval it, oit;
	462
	463	/* timer test */
	464
	465	alarm_count = 0;
	466
	467	act.sa_handler = sig_alarm;
	468	sigemptyset(&act.sa_mask);
	469	act.sa_flags = 0;
	470	chk_error(sigaction(SIGALRM, &act, NULL));
3b46e624	471
196ad109 FB	472	it.it_interval.tv_sec = 0;
	473	it.it_interval.tv_usec = 10 * 1000;
	474	it.it_value.tv_sec = 0;
	475	it.it_value.tv_usec = 10 * 1000;
	476	chk_error(setitimer(ITIMER_REAL, &it, NULL));
	477	chk_error(getitimer(ITIMER_REAL, &oit));
	478	if (oit.it_value.tv_sec != it.it_value.tv_sec \|\|
	479	oit.it_value.tv_usec != it.it_value.tv_usec)
	480	error("itimer");
3b46e624	481
196ad109 FB	482	while (alarm_count < 5) {
	483	usleep(10 * 1000);
	484	}
	485
	486	it.it_interval.tv_sec = 0;
	487	it.it_interval.tv_usec = 0;
	488	it.it_value.tv_sec = 0;
	489	it.it_value.tv_usec = 0;
	490	memset(&oit, 0xff, sizeof(oit));
	491	chk_error(setitimer(ITIMER_REAL, &it, &oit));
	492	if (oit.it_value.tv_sec != 0 \|\|
	493	oit.it_value.tv_usec != 10 * 1000)
	494	error("setitimer");
	495
	496	/* SIGSEGV test */
	497	act.sa_sigaction = sig_segv;
	498	sigemptyset(&act.sa_mask);
	499	act.sa_flags = SA_SIGINFO;
	500	chk_error(sigaction(SIGSEGV, &act, NULL));
	501	if (setjmp(jmp_env) == 0) {
	502	(uint8_t )0 = 0;
	503	}
3b46e624	504
196ad109 FB	505	act.sa_handler = SIG_DFL;
	506	sigemptyset(&act.sa_mask);
	507	act.sa_flags = 0;
	508	chk_error(sigaction(SIGSEGV, &act, NULL));
	509	}
	510
e374bfa3 FB	511	#define SHM_SIZE 32768
	512
	513	void test_shm(void)
	514	{
	515	void *ptr;
	516	int shmid;
	517
	518	shmid = chk_error(shmget(IPC_PRIVATE, SHM_SIZE, IPC_CREAT \| 0777));
	519	ptr = shmat(shmid, NULL, 0);
	520	if (!ptr)
	521	error("shmat");
	522
	523	memset(ptr, 0, SHM_SIZE);
	524
	525	chk_error(shmctl(shmid, IPC_RMID, 0));
	526	chk_error(shmdt(ptr));
	527	}
	528
196ad109 FB	529	int main(int argc, char **argv)
196ad109 FB	530	{
285dc330	531	test_file();
196ad109 FB	532	test_fork();
	533	test_time();
	534	test_socket();
e374bfa3	535	// test_clone();
196ad109	536	test_signal();
e374bfa3	537	test_shm();
196ad109 FB	538	return 0;
196ad109 FB	539	}