Statistics
| Branch: | Revision:

root / tests / linux-test.c @ 5fafdf24

History | View | Annotate | Download (12.8 kB)

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, write to the Free Software
18
 *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19
 */
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, args...) error1(__FILE__, __LINE__, fmt, ##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
    while (waitpid(pid2, &status2, 0) != pid2);
431
    if (thread1_res != 5 ||
432
        thread2_res != 6)
433
        error("clone");
434
}
435

    
436
/***********************************/
437

    
438
volatile int alarm_count;
439
jmp_buf jmp_env;
440

    
441
void sig_alarm(int sig)
442
{
443
    if (sig != SIGALRM)
444
        error("signal");
445
    alarm_count++;
446
}
447

    
448
void sig_segv(int sig, siginfo_t *info, void *puc)
449
{
450
    if (sig != SIGSEGV)
451
        error("signal");
452
    longjmp(jmp_env, 1);
453
}
454

    
455
void test_signal(void)
456
{
457
    struct sigaction act;
458
    struct itimerval it, oit;
459

    
460
    /* timer test */
461

    
462
    alarm_count = 0;
463

    
464
    act.sa_handler = sig_alarm;
465
    sigemptyset(&act.sa_mask);
466
    act.sa_flags = 0;
467
    chk_error(sigaction(SIGALRM, &act, NULL));
468
   
469
    it.it_interval.tv_sec = 0;
470
    it.it_interval.tv_usec = 10 * 1000;
471
    it.it_value.tv_sec = 0;
472
    it.it_value.tv_usec = 10 * 1000;
473
    chk_error(setitimer(ITIMER_REAL, &it, NULL));
474
    chk_error(getitimer(ITIMER_REAL, &oit));
475
    if (oit.it_value.tv_sec != it.it_value.tv_sec ||
476
        oit.it_value.tv_usec != it.it_value.tv_usec)
477
        error("itimer");
478
   
479
    while (alarm_count < 5) {
480
        usleep(10 * 1000);
481
    }
482

    
483
    it.it_interval.tv_sec = 0;
484
    it.it_interval.tv_usec = 0;
485
    it.it_value.tv_sec = 0;
486
    it.it_value.tv_usec = 0;
487
    memset(&oit, 0xff, sizeof(oit));
488
    chk_error(setitimer(ITIMER_REAL, &it, &oit));
489
    if (oit.it_value.tv_sec != 0 ||
490
        oit.it_value.tv_usec != 10 * 1000)
491
        error("setitimer");
492

    
493
    /* SIGSEGV test */
494
    act.sa_sigaction = sig_segv;
495
    sigemptyset(&act.sa_mask);
496
    act.sa_flags = SA_SIGINFO;
497
    chk_error(sigaction(SIGSEGV, &act, NULL));
498
    if (setjmp(jmp_env) == 0) {
499
        *(uint8_t *)0 = 0;
500
    }
501
   
502
    act.sa_handler = SIG_DFL;
503
    sigemptyset(&act.sa_mask);
504
    act.sa_flags = 0;
505
    chk_error(sigaction(SIGSEGV, &act, NULL));
506
}
507

    
508
#define SHM_SIZE 32768
509

    
510
void test_shm(void)
511
{
512
    void *ptr;
513
    int shmid;
514

    
515
    shmid = chk_error(shmget(IPC_PRIVATE, SHM_SIZE, IPC_CREAT | 0777));
516
    ptr = shmat(shmid, NULL, 0);
517
    if (!ptr)
518
        error("shmat");
519

    
520
    memset(ptr, 0, SHM_SIZE);
521

    
522
    chk_error(shmctl(shmid, IPC_RMID, 0));
523
    chk_error(shmdt(ptr));
524
}
525

    
526
int main(int argc, char **argv)
527
{
528
    test_file();
529
    test_fork();
530
    test_time();
531
    test_socket();
532
    //    test_clone();
533
    test_signal();
534
    test_shm();
535
    return 0;
536
}