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     if (sigaction(SIGKILL, &act, NULL) == 0) {
501         error("sigaction(SIGKILL, &act, NULL) must not succeed");
502     }
503     if (sigaction(SIGSTOP, &act, NULL) == 0) {
504         error("sigaction(SIGSTOP, &act, NULL) must not succeed");
505     }
506     chk_error(sigaction(SIGKILL, NULL, &act));
507     chk_error(sigaction(SIGSTOP, NULL, &act));
508 }
509 
510 #define SHM_SIZE 32768
511 
512 static 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 == (void *)-1) {
520         error("shmat");
521     }
522 
523     memset(ptr, 0, SHM_SIZE);
524 
525     chk_error(shmctl(shmid, IPC_RMID, 0));
526     chk_error(shmdt(ptr));
527 }
528 
529 int main(int argc, char **argv)
530 {
531     test_file();
532     test_pipe();
533     test_fork();
534     test_time();
535     test_socket();
536 
537     if (argc > 1) {
538         printf("test_clone still considered buggy\n");
539         test_clone();
540     }
541 
542     test_signal();
543     test_shm();
544     return 0;
545 }
546