File:  [Qemu by Fabrice Bellard] / qemu / tests / linux-test.c
Revision 1.1.1.5 (vendor branch): download - view: text, annotated - select for diffs
Tue Apr 24 18:57:16 2018 UTC (3 years, 3 months ago) by root
Branches: qemu, MAIN
CVS tags: qemu1001, qemu1000, qemu0151, HEAD
qemu 0.15.1

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

unix.superglobalmegacorp.com