tests/tcg/linux-test.c

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