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