511 lines
12 KiB
C
511 lines
12 KiB
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, write to the Free Software
|
||
|
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
||
|
*/
|
||
|
#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>
|
||
|
|
||
|
#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, args...) error1(__FILE__, __LINE__, fmt, ##args)
|
||
|
|
||
|
#define chk_error(ret) __chk_error(__FILE__, __LINE__, (ret))
|
||
|
|
||
|
/*******************************************************/
|
||
|
|
||
|
#define FILE_BUF_SIZE 300
|
||
|
|
||
|
void file_test(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;
|
||
|
struct sockaddr_in sockaddr;
|
||
|
socklen_t len;
|
||
|
char buf[512];
|
||
|
|
||
|
server_fd = server_socket();
|
||
|
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);
|
||
|
while (waitpid(pid2, &status2, 0) != pid2);
|
||
|
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));
|
||
|
}
|
||
|
|
||
|
int main(int argc, char **argv)
|
||
|
{
|
||
|
file_test();
|
||
|
test_fork();
|
||
|
test_time();
|
||
|
test_socket();
|
||
|
test_clone();
|
||
|
test_signal();
|
||
|
return 0;
|
||
|
}
|
||
|
|