| /* |
| * |
| * Copyright (c) International Business Machines Corp., 2001 |
| * |
| * This program is free software; you can redistribute it and/or modify |
| * it under the terms of the GNU General Public License as published by |
| * the Free Software Foundation; either version 2 of the License, or |
| * (at your option) any later version. |
| * |
| * This program is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See |
| * the GNU General Public License for more details. |
| * |
| * You should have received a copy of the GNU General Public License |
| * along with this program; if not, write to the Free Software |
| * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
| * |
| */ |
| |
| /****************************************************************************** |
| |
| File: epoll-ltp.c |
| |
| Description: |
| Test the epoll_* system calls. This test program attempts to |
| be very thorough in exercising epoll_* system calls. Large |
| combinations of valid and invalid parameters are passed with |
| valid and invalid sequences. Due to the combinatorial nature |
| of this test program the test may take a "long" time to |
| execute. |
| |
| Total Tests: 2 (2 system calls are being tested for) |
| |
| Test Name: epoll_create, epoll_ctl |
| |
| Test Assertion |
| & Strategy: Test a variety of incorrect parameters for epoll_create |
| |
| Then run a reasonable epoll_create and get a fd for the epoll |
| set. |
| |
| Next run epoll_ctl on that fd (epoll_fd) with a variety of |
| incorrect parameters and a couple correct ones. |
| |
| Finally ?How to thoroughly test epoll_wait? |
| |
| Author: Matt Helsley <matthltc@us.ibm.com> |
| |
| History: Created - May 22 2003 - Matt Helsley <matthltc@us.ibm.com> |
| Added - |
| |
| Notes: Currently we assume that the OS will never allocate an fd s.t. |
| fd == INT_MAX and that it will instead choose to allocate fds |
| from the "low" numbers. -MH |
| |
| Currently pokes epoll_create several times in 2 + NUM_RAND_ATTEMPTS ways |
| pokes epoll_ctl 27648 - (2 + NUM_RAND_ATTEMPTS) ways |
| does not poke epoll_wait |
| |
| TODO: change errno test code to build lists of possible errno values for |
| each erroneous parameter. Check that the errno value is in one |
| of the lists. Currently errno is not checked at all when multiple |
| erroneous parameters are passed in. |
| |
| test epoll_ctl with a large number of file descriptor events in the |
| set |
| |
| Link against epoll and ltp (-lepoll -lltp) |
| |
| *******************************************************************************/ |
| |
| #ifndef _GNU_SOURCE |
| #define _GNU_SOURCE |
| #endif |
| |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <unistd.h> |
| #include <fcntl.h> |
| #include <stdarg.h> |
| #include <string.h> |
| #include <signal.h> |
| #include <assert.h> |
| #include <limits.h> |
| #include <ctype.h> |
| #include <time.h> |
| #include <errno.h> |
| #include <signal.h> |
| #include <sys/types.h> |
| #include <sys/time.h> |
| #include <sys/file.h> |
| #include <sys/ioctl.h> |
| #include <sys/mman.h> |
| #include <sys/select.h> |
| #include <sys/wait.h> |
| |
| #include "config.h" |
| #include "test.h" |
| |
| char *TCID = "epoll01"; |
| int TST_TOTAL = 1; |
| |
| #ifdef HAVE_SYS_EPOLL_H |
| |
| #include <sys/epoll.h> |
| |
| /* Local Defines */ |
| #if !defined(TRUE) && !defined(FALSE) |
| #define TRUE 1 |
| #define FALSE 0 |
| #endif |
| |
| #define NUM_RAND_ATTEMPTS 16 |
| #define BACKING_STORE_SIZE_HINT 32 |
| |
| /* |
| Define the beginning of a "protected region". |
| This is a region where a wide variety of errors |
| could occur or signals could arrive (including |
| SIGSEGV and SIGKILL). |
| $ |
| The test program uses this to catch those |
| conditions as best it can and continue testing. |
| |
| The region MUST be marked by a corresponding |
| PROTECT_REGION_END. |
| |
| DO NOT nest protected regions! i.e. Do not build |
| code of the form: |
| |
| PROTECT_REGION_START |
| ... |
| PROTECT_REGION_START |
| ... |
| PROTECT_REGION_END |
| ... |
| PROTECT_REGION_END |
| */ |
| #define PROTECT_REGION_START \ |
| do { \ |
| pid_t kid_pid; \ |
| int kid_status; \ |
| \ |
| tst_flush(); \ |
| kid_pid = FORK_OR_VFORK(); \ |
| if (kid_pid == 0) { |
| |
| #define PROTECT_REGION_EXIT(errval) return (errval); |
| |
| #define PROTECT_REGION_END(result, errval) \ |
| return 0; \ |
| } else { \ |
| waitpid(kid_pid, &kid_status, 0); \ |
| if (WIFEXITED(kid_status)) { \ |
| (result) = WEXITSTATUS(kid_status); \ |
| } else { /* Must have been signaled */ \ |
| (result) = (errval); \ |
| if (WIFSIGNALED(kid_status)) \ |
| tst_resm(TFAIL, "Protected function test exitted due to signal %d (%s)", \ |
| WTERMSIG(kid_status), strsignal(WTERMSIG(kid_status))); \ |
| } \ |
| } \ |
| } while (0) |
| |
| /* |
| * Call a function in a "protected" context. |
| * This protects the test program proper from segfaults |
| * and allows for the extraction of an integer return |
| * code. |
| * |
| * return only integer results. |
| */ |
| #define PROTECT_FUNC(fn, errval, epoll_fd) ( \ |
| { \ |
| pid_t kid_pid; \ |
| int kid_status; \ |
| \ |
| tst_flush(); \ |
| kid_pid = FORK_OR_VFORK(); \ |
| if (kid_pid == 0) { /* Run the function */ \ |
| return fn(epoll_fd); \ |
| } else { \ |
| waitpid(kid_pid, &kid_status, 0); \ |
| if (WIFEXITED(kid_status)) { \ |
| kid_status = WEXITSTATUS(kid_status); \ |
| } else { /* Must have been signaled */ \ |
| kid_status = (errval); \ |
| if (WIFSIGNALED(kid_status)) \ |
| tst_resm(TFAIL, "Protected function test exitted due to signal %d (%s)", \ |
| WTERMSIG(kid_status), strsignal(WTERMSIG(kid_status))); \ |
| } \ |
| } \ |
| kid_status = kid_status;}) |
| |
| /* |
| * Given the number of random size requests to test, |
| * test various boundary cases of epoll_create(). |
| * |
| * Return the number of tests that failed. 0 indicates |
| * 100% passed. |
| */ |
| int test_epoll_create(unsigned int num_rand_attempts) |
| { |
| int epoll_fd = -1; |
| int fd_set_size = -1; |
| unsigned int attempt_count; |
| unsigned int num_epoll_create_test_fails = 0; |
| unsigned int num_epoll_create_test_calls = 0; |
| |
| /* Negative set sizes */ |
| errno = 0; |
| fd_set_size = -1; |
| num_epoll_create_test_calls++; |
| epoll_fd = epoll_create(fd_set_size); |
| if (epoll_fd >= 0) { |
| tst_resm(TFAIL | TERRNO, |
| "epoll_create with negative set size succeeded unexpectedly"); |
| num_epoll_create_test_fails++; |
| close(epoll_fd); |
| } else { |
| if (errno != EINVAL) { |
| tst_resm(TFAIL | TERRNO, |
| "epoll_create with negative set size didn't set errno to EINVAL"); |
| num_epoll_create_test_fails++; |
| } else { |
| tst_resm(TPASS, "epoll_create with negative set size"); |
| } |
| } |
| |
| /* Large set sizes -- try several less than or equal to INT_MAX by some |
| small amount (expect num_rand_attempts to be approximately the |
| amount we'd like to go below INT_MAX). */ |
| fd_set_size = INT_MAX; |
| for (attempt_count = num_rand_attempts; attempt_count > 0; |
| attempt_count--, fd_set_size--) { |
| num_epoll_create_test_calls++; |
| epoll_fd = epoll_create(fd_set_size); |
| if (epoll_fd == -1) { |
| if (errno != ENOMEM) { |
| tst_resm(TFAIL, |
| "epoll_create with large set size (size = %d)", |
| fd_set_size); |
| num_epoll_create_test_fails++; |
| } else { |
| tst_resm(TPASS, |
| "epoll_create with large set size (size = %d)", |
| fd_set_size); |
| } |
| } else { |
| tst_resm(TPASS, |
| "epoll_create with large set size (size = %d)", |
| fd_set_size); |
| close(epoll_fd); |
| } |
| } |
| |
| /* Random large set sizes */ |
| for (attempt_count = num_rand_attempts; attempt_count > 0; |
| attempt_count--) { |
| fd_set_size = abs(rand() + SHRT_MAX) % INT_MAX; |
| errno = 0; |
| num_epoll_create_test_calls++; |
| epoll_fd = epoll_create(fd_set_size); |
| if (epoll_fd < 0) { |
| if (errno != ENOMEM) { |
| tst_resm(TFAIL, |
| "epoll_create with random random large set size (size = %d)", |
| fd_set_size); |
| num_epoll_create_test_fails++; |
| } else { |
| tst_resm(TPASS, |
| "epoll_create with random random large set size (size = %d)", |
| fd_set_size); |
| } |
| } else { |
| tst_resm(TPASS, |
| "epoll_create with random large set size (size = %d)", |
| fd_set_size); |
| close(epoll_fd); |
| } |
| } |
| |
| tst_resm(TINFO, |
| "Summary: Of %d tests, epoll_create failed %d (%3.0f%% passed).", |
| num_epoll_create_test_calls, num_epoll_create_test_fails, |
| ((float) |
| (num_epoll_create_test_calls - num_epoll_create_test_fails) |
| * 100.0f / (float) |
| num_epoll_create_test_calls)); |
| /* Return 0 on success. */ |
| |
| return num_epoll_create_test_fails; |
| } |
| |
| /* RES_PASS indicates a PASS result */ |
| #define RES_PASS 0 |
| |
| /* |
| * RES_FAIL_* indicates a FAIL result |
| * In brief, there are two things that can go wrong in a |
| * failiure. The return value (result = epoll_ctl(...)) and |
| * the errno value may not match expectations. In this notation, |
| * MIS -> mismatch, MAT -> match, BAD -> bad, and IGN -> ignored. |
| * |
| * RETV_MIS_* indicates the return value was either 0 or 1, but did |
| * not match the expected return value |
| * |
| * _RETV_MAT_* indicates that the return value was 0 xor 1 and did |
| * match the expected value |
| * |
| *_RETV_BAD_* the return value was neither 0 nor 1. |
| *_ERRNO_MAT the error number matched the expected number |
| *_ERRNO_MIS the error number did not match the expected number |
| *_ERRNO_IGN no error number was expected and so errno was ignored |
| * |
| * Keep these values below 256 as only 1 byte gets passed as a |
| * return value for the process. Note that RES_PASS is 0 which |
| * LTP interprets as a PASS. |
| */ |
| |
| /* Did not get the expected return value, but errno value was expected */ |
| #define RES_FAIL_RETV_MIS_ERRNO_MAT 1 |
| /* Did not get the expected return value, but errno value was expected */ |
| #define RES_FAIL_RETV_BAD_ERRNO_MAT 2 |
| /* Did get the expected return value, and errno value was not expected */ |
| #define RES_FAIL_RETV_MAT_ERRNO_MIS 3 |
| /* Return value was neither 0 nor -1. Mismatch in value of errno */ |
| #define RES_FAIL_RETV_BAD_ERRNO_MIS 4 |
| /* Did not get the expected return value and errno is irrelevant */ |
| #define RES_FAIL_RETV_MIS_ERRNO_IGN 5 |
| /* Return value was neither 0 nor -1. value of errno is irrelevant */ |
| #define RES_FAIL_RETV_BAD_ERRNO_IGN 6 |
| /* We expected multiple errors so we were unable to check errno for conformance */ |
| #define RES_PASS_RETV_MAT_ERRNO_IGN 7 |
| |
| static const char *result_strings[] = { |
| "Passed", |
| "Return value mismatched yet errno matched.", |
| "Return value was bad yet errno matched.", |
| "Return value matched yet errno mismatched.", |
| "Return value was bad and errno mismatched.", |
| "Return value mismatched so errno ignored.", |
| "Return value was bad so errno ignored.", |
| "Return value matched but errno ignored. (multiple errors expected)" |
| }; |
| |
| /****************************************************************************************/ |
| /* This macro helps keep the code below understandable. It prints out the |
| failiure message passed to it plus the parameters to the system call. */ |
| #define EPOLL_CTL_TEST_RESULTS_SHOW_PARAMS 1 |
| #if EPOLL_CTL_TEST_RESULTS_SHOW_PARAMS |
| #define EPOLL_CTL_TEST_FAIL(msg , ...) \ |
| ({ \ |
| if (ev_ptr != NULL) { \ |
| tst_resm(TFAIL, ( "(epoll_ctl(%d,%08x,%d,%p = {%08x,%08d}) returned %d:%s)" ) , ##__VA_ARGS__ , \ |
| epoll_fds[epfd_index], epoll_ctl_ops[op_index], \ |
| epoll_fds[fd_index], ev_ptr, ev_ptr->events, ev_ptr->data.fd, errno, \ |
| strerror(errno)); \ |
| } else { \ |
| tst_resm(TFAIL, ( "(epoll_ctl(%d,%08x,%d,%p) returned %d:%s)" ) , ##__VA_ARGS__ , \ |
| epoll_fds[epfd_index], epoll_ctl_ops[op_index], \ |
| epoll_fds[fd_index], ev_ptr, errno, strerror(errno)); \ |
| } \ |
| }) |
| |
| #define EPOLL_CTL_TEST_PASS(msg , ...) \ |
| ({ \ |
| if (ev_ptr != NULL) { \ |
| tst_resm(TPASS, ( "(epoll_ctl(%d,%08x,%d,%p = {%08x,%08d}) returned %d:%s)" ) , ##__VA_ARGS__ , \ |
| epoll_fds[epfd_index], epoll_ctl_ops[op_index], \ |
| epoll_fds[fd_index], ev_ptr, ev_ptr->events, ev_ptr->data.fd, errno, \ |
| strerror(errno)); \ |
| } else { \ |
| tst_resm(TPASS, ( "(epoll_ctl(%d,%08x,%d,%p) returned %d:%s)" ) , ##__VA_ARGS__ , \ |
| epoll_fds[epfd_index], epoll_ctl_ops[op_index], \ |
| epoll_fds[fd_index], ev_ptr, errno, strerror(errno)); \ |
| } \ |
| }) |
| #else |
| #define EPOLL_CTL_TEST_FAIL(msg , ...) tst_resm(TFAIL, msg , ##__VA_ARGS__) |
| #define EPOLL_CTL_TEST_PASS(msg , ...) tst_resm(TPASS, msg , ##__VA_ARGS__) |
| #endif |
| |
| /****************************************************************************************/ |
| |
| int test_epoll_ctl(int epoll_fd) |
| { |
| int fds[] = { -1, INT_MAX }; |
| int epoll_fds[] = { 0, -1, 0, INT_MAX }; |
| int epoll_events[64]; |
| /* The list of operations to try AND THE ORDER THEY ARE TRIED IN */ |
| int epoll_ctl_ops[] = |
| { EPOLL_CTL_DEL, EPOLL_CTL_MOD, EPOLL_CTL_ADD, EPOLL_CTL_MOD, |
| EPOLL_CTL_DEL, EPOLL_CTL_MOD, EPOLL_CTL_DEL, INT_MAX, -1 |
| }; |
| struct epoll_event event; |
| char event_mem[sizeof(struct epoll_event) * 2]; |
| struct epoll_event *unaligned_event_ptr; |
| |
| /* Indices into lists */ |
| int index = 0; /* multi-use index. First uses are to initialize |
| lists. Second use is to iterate over the implicit |
| list of structs to pass in */ |
| unsigned int epfd_index; /* index into fd list for the epfd parameter */ |
| unsigned int event_index; /* index into event list for the events field of the |
| struct epoll_event parameter */ |
| unsigned int fd_index; /* index into fd list for the fd parameter */ |
| unsigned int op_index; /* index into the list of operations for the op |
| parameter */ |
| unsigned int num_epoll_ctl_test_fails = 0; |
| unsigned int num_epoll_ctl_test_calls = 0; |
| |
| /* Generate all possible combinations of events (2^6 == 64) |
| Assume we know nothing about the EPOLL event types _except_ |
| that they describe bits in a set. */ |
| for (index = 0; index < 64; index++) { |
| epoll_events[index] = ((EPOLLIN * ((index & 0x01) >> 0)) | |
| (EPOLLOUT * ((index & 0x02) >> 1)) | |
| (EPOLLPRI * ((index & 0x04) >> 2)) | |
| (EPOLLERR * ((index & 0x08) >> 3)) | |
| (EPOLLHUP * ((index & 0x10) >> 4)) | |
| (EPOLLET * ((index & 0x20) >> 5))); |
| } |
| |
| /* Get a pointer to an unaligned struct epoll_event */ |
| { |
| char *unalign_ptr = event_mem; |
| |
| unalign_ptr = |
| unalign_ptr + (((unsigned long)unalign_ptr & 1) ? 0 : 1); |
| unaligned_event_ptr = (struct epoll_event *)unalign_ptr; |
| } |
| |
| /* One of the fds we want to test is the valid one */ |
| epoll_fds[0] = epoll_fd; |
| |
| /* Test out all of the interesting combinations. This is going to |
| take a while (in compute cycles). It took less than 1 minute to |
| run on a PIII 500 without checking the results. */ |
| for (index = 0; index < 3; index++) { |
| struct epoll_event *ev_ptr = NULL; |
| |
| switch (index) { |
| case 0: /* Pass aligned struct */ |
| event.data.u64 = 0; |
| ev_ptr = &event; |
| break; |
| case 1: /* Pass unaligned struct */ |
| unaligned_event_ptr->data.u64 = 0; |
| ev_ptr = unaligned_event_ptr; |
| break; |
| case 2: |
| default: /* Pass NULL ptr */ |
| ev_ptr = NULL; |
| break; |
| } |
| |
| for (epfd_index = 0; |
| epfd_index < (sizeof(epoll_fds) / sizeof(int)); |
| epfd_index++) { |
| for (event_index = 0; |
| event_index < (sizeof(epoll_events) / sizeof(int)); |
| event_index++) { |
| for (fd_index = 0; |
| fd_index < (sizeof(fds) / sizeof(int)); |
| fd_index++) { |
| /* Now epoll_fd is a descriptor that references the set of |
| file descriptors we are interested in. Next we test epoll_ctl */ |
| for (op_index = 0; |
| op_index < |
| (sizeof(epoll_ctl_ops) / |
| sizeof(int)); op_index++) { |
| int result; |
| int expected_errno = 0; |
| int num_errors_expected = 0; |
| |
| if (ev_ptr != NULL) |
| ev_ptr->events = |
| epoll_events |
| [event_index]; |
| |
| /* Perform the call itself. Put it in a protected region which |
| returns -1 in the variable result if a protection violation |
| occurs (see PROTECT_REGION_END for the result) */ |
| PROTECT_REGION_START errno = 0; |
| |
| /* NOTE that we are assuming that epoll will operate across |
| a fork() call such that a subsequent fork() in the parent |
| will also manipulate the same set */ |
| result = |
| epoll_ctl(epoll_fds |
| [epfd_index], |
| epoll_ctl_ops |
| [op_index], |
| fds[fd_index], |
| ev_ptr); |
| |
| /* We can't test errno resulting from the epoll_ctl call outside of |
| the PROTECT_REGION hence we do not have a PROTECT_REGION_END |
| here */ |
| |
| /* |
| Test the results. Look for appropriate error conditions |
| */ |
| |
| /* Check the epfd */ |
| if (epoll_fds[epfd_index] != |
| epoll_fd) { |
| /* Expect an error */ |
| if (epoll_fds |
| [epfd_index] == 0) |
| expected_errno = |
| EINVAL; |
| else /* epfd is not a valid file descriptor since it is |
| neither epoll_fd nor stdin */ |
| expected_errno = |
| EBADF; |
| num_errors_expected++; |
| } |
| |
| switch (epoll_ctl_ops[op_index]) { |
| case EPOLL_CTL_ADD: |
| case EPOLL_CTL_MOD: |
| case EPOLL_CTL_DEL: |
| break; |
| default: /* Expect an error */ |
| expected_errno = EINVAL; |
| num_errors_expected++; |
| break; |
| } |
| |
| expected_errno = EPERM; |
| num_errors_expected++; |
| |
| if (ev_ptr == NULL) { |
| expected_errno = EINVAL; |
| num_errors_expected++; |
| } else if ((ev_ptr == &event) |
| || (ev_ptr == |
| unaligned_event_ptr)) |
| { |
| if (ev_ptr->events == 0) { |
| expected_errno = |
| EINVAL; |
| num_errors_expected++; |
| } |
| |
| for (index = 1; |
| index < 64; |
| index++) { |
| if (ev_ptr->events != epoll_events[index]) { |
| expected_errno |
| = |
| EINVAL; |
| num_errors_expected++; |
| } |
| } |
| } else { |
| /* Do not expect an error */ |
| } |
| |
| if (num_errors_expected == 0) { |
| /* We did not expect an error */ |
| if (result == 0) { |
| /* We didn't get an error. Think of this as RES_PASS_RETV_MAT_ERRNO_IGN */ |
| return RES_PASS; |
| } else if (result == -1) { /* The return value is -1, so it's not bad */ |
| return |
| RES_FAIL_RETV_MIS_ERRNO_IGN; |
| } else { |
| return |
| RES_FAIL_RETV_BAD_ERRNO_IGN; |
| } |
| } else if (num_errors_expected |
| == 1) { |
| /* We expected an error */ |
| if (result == 0) { |
| return RES_FAIL_RETV_MIS_ERRNO_IGN; /* Unexpected success */ |
| } else if (result == -1) { |
| /* We got an error. Check errno */ |
| if (errno == |
| expected_errno) |
| { |
| return RES_PASS; /* think of this as RETV_MAT_ERRNO_MAT */ |
| } else { |
| return |
| RES_FAIL_RETV_MAT_ERRNO_MIS; |
| } |
| } else { |
| /* We got a bad return code! Interpret this as |
| getting an error and check errno. */ |
| if (errno == |
| expected_errno) |
| return |
| RES_FAIL_RETV_BAD_ERRNO_MAT; |
| else |
| return |
| RES_FAIL_RETV_BAD_ERRNO_MIS; |
| } |
| } else if (num_errors_expected > |
| 1) { |
| /* We expected multiple errors */ |
| if (result == 0) { |
| return RES_FAIL_RETV_MIS_ERRNO_IGN; /* Unexpected success */ |
| } else if (result == -1) { |
| /* We got an error. Check errno */ |
| if (errno == |
| expected_errno) |
| { |
| return RES_PASS; /* think of this as RETV_MAT_ERRNO_MAT */ |
| } else { |
| /* Ignore errno because the desired value is unknowable |
| without looking at the structure of the code. */ |
| return |
| RES_PASS_RETV_MAT_ERRNO_IGN; |
| } |
| } else { |
| /* We got a bad return code! Interpret this as |
| getting an error and check errno. */ |
| if (errno == |
| expected_errno) |
| /* Don't Ignore errno because the desired value |
| happened to match what we expected. */ |
| return |
| RES_FAIL_RETV_BAD_ERRNO_MAT; |
| else |
| /* Ignore errno because the desired value is unknowable |
| without looking at the structure of the code. */ |
| return |
| RES_FAIL_RETV_BAD_ERRNO_IGN; |
| } |
| } |
| |
| /* All "return"s between PROTECT_REGION_BEGIN |
| and PROTECT_REGION_END place their value in |
| the result parameter. If the region caused |
| a protection violation (segfault or otherwise) |
| then the result is set to the second parameter's |
| value (-1 in this case). */ |
| PROTECT_REGION_END(result, -1); |
| |
| /* Count the number of tests run */ |
| num_epoll_ctl_test_calls++; |
| |
| /* Now test the result */ |
| if (!((result == RES_PASS) |
| || (result == |
| RES_PASS_RETV_MAT_ERRNO_IGN))) |
| { |
| if (result > |
| (sizeof |
| (result_strings) / |
| sizeof(const char |
| *))) { |
| /* Returned a result which has no corresponding text description */ |
| EPOLL_CTL_TEST_FAIL |
| ("FIXME FIX ME BUG in Test Program itself!"); |
| } else { |
| if (result == -1) /* Segfault during epoll_ctl call */ |
| EPOLL_CTL_TEST_FAIL |
| ("Test arguments caused abnormal exit."); |
| else /* The 'normal' failiure */ |
| EPOLL_CTL_TEST_FAIL |
| ((result_strings[result])); |
| } |
| num_epoll_ctl_test_fails++; |
| #ifdef DEBUG |
| } else /* The call of epoll_ctl behaved as expected */ |
| EPOLL_CTL_TEST_PASS((result_strings[result])); |
| #else |
| } |
| #endif |
| } |
| } |
| } |
| } |
| close(epoll_fd); |
| } |
| |
| tst_resm(TINFO, |
| "Summary: Of %d tests, epoll_ctl failed %d (%3.0f%% passed).", |
| num_epoll_ctl_test_calls, num_epoll_ctl_test_fails, |
| ((float)(num_epoll_ctl_test_calls - num_epoll_ctl_test_fails) * |
| 100.0f / (float)num_epoll_ctl_test_calls)); |
| return (num_epoll_ctl_test_fails / num_epoll_ctl_test_calls); |
| } |
| |
| int main(int argc, char **argv) |
| { |
| int epoll_fd; |
| struct timeval tv; |
| int last_result; |
| |
| tst_resm(TINFO, "testing if epoll() system call works"); |
| |
| /* Get the current time */ |
| if (gettimeofday(&tv, NULL) != 0) { |
| tst_brkm(TBROK | TERRNO, NULL, "gettimeofday failed"); |
| } else { |
| tst_resm(TINFO, "gettimeofday() works"); |
| } |
| |
| /* Set up RNG */ |
| srand(tv.tv_usec); |
| tst_resm(TINFO, |
| "random number seeded with gettimeofday() [seed = %ld] works", |
| tv.tv_usec); |
| |
| tst_resm(TINFO, "Testing epoll_create"); |
| /* Testing epoll_create with some different sizes */ |
| last_result = PROTECT_FUNC(test_epoll_create, -1, NUM_RAND_ATTEMPTS); |
| if (last_result != 0) { |
| /* create test(s) failed */ |
| } |
| |
| /* Create an epoll_fd for testing epoll_ctl */ |
| epoll_fd = epoll_create(BACKING_STORE_SIZE_HINT); |
| if (epoll_fd < 0) { |
| tst_brkm(TFAIL | TERRNO, NULL, "epoll_create failed"); |
| } |
| |
| tst_resm(TINFO, "Testing epoll_ctl"); |
| last_result = PROTECT_FUNC(test_epoll_ctl, -1, epoll_fd); |
| if (last_result != 0) { |
| /* ctl test(s) failed */ |
| } |
| |
| tst_exit(); |
| } |
| |
| #else |
| |
| int main(void) |
| { |
| tst_brkm(TCONF, NULL, "No epoll support found."); |
| } |
| |
| #endif |