diff options
Diffstat (limited to 'extras')
| -rw-r--r-- | extras/test/ld-preload-test/Makefile | 28 | ||||
| -rw-r--r-- | extras/test/ld-preload-test/README | 40 | ||||
| -rw-r--r-- | extras/test/ld-preload-test/ld-preload-lib.c | 637 | ||||
| -rw-r--r-- | extras/test/ld-preload-test/ld-preload-test.c | 377 | ||||
| -rwxr-xr-x | extras/test/ld-preload-test/test-preload.sh | 7 |
5 files changed, 1089 insertions, 0 deletions
diff --git a/extras/test/ld-preload-test/Makefile b/extras/test/ld-preload-test/Makefile new file mode 100644 index 000000000..97aa01651 --- /dev/null +++ b/extras/test/ld-preload-test/Makefile @@ -0,0 +1,28 @@ +TOOL_CFLAGS32=-g -O0 -Wall +TOOL_CFLAGS64=-g -O0 -D_GNU_SOURCE -Wall -D_FILE_OFFSET_BITS=64 +LIB_CFLAGS=-g -O0 -fPIC -Wall -shared -ldl +%LIB_CFLAGS=-g -O0 -D_GNU_SOURCE -fPIC -Wall -shared -D_FILE_OFFSET_BITS=64 -ldl + +all: ld-preload-test32 ld-preload-test64 ld-preload-lib + + +copy32: + cp ld-preload-test.c test32.c + +ld-preload-test32: copy32 + gcc ${TOOL_CFLAGS32} test32.c -o ld-preload-test32 + rm -f test32.c + +copy64: + cp ld-preload-test.c test64.c + +ld-preload-test64: copy64 + gcc ${TOOL_CFLAGS64} test64.c -o ld-preload-test64 + rm -f test64.c + +ld-preload-lib: ld-preload-lib.c + gcc ${LIB_CFLAGS} ld-preload-lib.c -o ld-preload-lib.so + +clean: + rm -f ld-preload-test32 ld-preload-test64 ld-preload-lib.so + diff --git a/extras/test/ld-preload-test/README b/extras/test/ld-preload-test/README new file mode 100644 index 000000000..725b94023 --- /dev/null +++ b/extras/test/ld-preload-test/README @@ -0,0 +1,40 @@ +ld-preload-test +=============== +1. The idea of this test tool is to check the sanity of the LD_PRELOAD +mechanism in libc for the system on which booster needs to run. + +2. Basically, this test tool calls various system calls for which there is +support in the booster library. Combined with the logging output from this +tool and the preload-test-lib, one can determine whether the +pre-loading mechanism is working working in order for booster to initialize. + +3. This tool does not test GlusterFS functionality running under booster +although the path specified to the tool can be a GlusterFS mountpoint but +that is not very useful. + +4. This tool is incomplete without the preload-test-lib and the +accompanyung shell script that needs to be run for running the test. + +ld-preload-lib.so +================= +A very simple library that intercepts booster supported system calls +and prints a log message to stdout. +Combined with the ld-preload-test, we cam determine whether all system calls +are getting redirected into this library when LD_PRELOAD'ed. This helps us +conduct a basic test to ensure that the required syscalls actually will +be intercepted by the booster library. + + +Instructions +============ + +1. Build the binaries. + $ make + +(We've tested the tool on Debian and CentOS. If there are build errors or +warnings, please do report them to glusterfs-devel@nongnu.org.) + +2. Run the test. + $ ./test-preload.sh > preload.log + +3. Mail the log to glusterfs-devel@nongnu.org. diff --git a/extras/test/ld-preload-test/ld-preload-lib.c b/extras/test/ld-preload-test/ld-preload-lib.c new file mode 100644 index 000000000..8a7504e9c --- /dev/null +++ b/extras/test/ld-preload-test/ld-preload-lib.c @@ -0,0 +1,637 @@ +/* + Copyright (c) 2007-2009 Z RESEARCH, Inc. <http://www.zresearch.com> + This file is part of GlusterFS. + + GlusterFS 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 3 of the License, + or (at your option) any later version. + + GlusterFS 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, see + <http://www.gnu.org/licenses/>. +*/ + + +/* LD PRELOAD'able library + * A very simple library that intercepts booster supported system calls + * and prints a log message to stdout. + * + * Combined with the ld-preload-test, we cam determine whether all system calls + * are getting redirected into this library when LD_PRELOAD'ed. This helps us + * conduct a basic test to ensure that the required syscalls actually will + * be intercepted by the booster library. + */ + +#include <dlfcn.h> +#include <sys/types.h> +#include <sys/uio.h> +#include <stdio.h> +#include <stdarg.h> +#include <stdlib.h> +#include <inttypes.h> +#include <string.h> +#include <assert.h> +#include <errno.h> +#include <utime.h> +#include <sys/statfs.h> +#include <sys/statvfs.h> +#include <fcntl.h> +#include <sys/stat.h> +#include <dirent.h> +#include <attr/xattr.h> +#include <sys/sendfile.h> + +/* Err number that is assigned to errno so that test application can + * verify that the function was intercepted correctly. + */ +#define PRELOAD_ERRNO_VERF 6449 +#define set_errno() (errno = PRELOAD_ERRNO_VERF) + +inline void +intercept (char *call, int tabs) +{ + while (tabs > 0) { + fprintf (stdout, "\t"); + --tabs; + } + + fprintf (stdout, "Intercepted by %s", call); +} + +int +creat64 (const char *pathname, mode_t mode) +{ + intercept ("creat64", 2); + set_errno (); + return -1; +} + +int +creat (const char *pathname, mode_t mode) +{ + intercept ("creat", 2); + set_errno (); + return -1; +} + + +int +close (int fd) +{ + intercept ("close", 2); + set_errno (); + return -1; +} + +int +open64 (const char *pathname, int flags, ...) +{ + intercept ("open64", 2); + set_errno (); + return -1; +} + + +int +open (const char *pathname, int flags, ...) +{ + intercept ("open", 2); + set_errno (); + return -1; +} + +ssize_t +read (int fd, void *buf, size_t count) +{ + intercept ("read", 2); + set_errno (); + return -1; +} + +ssize_t +readv (int fd, const struct iovec *vector, int count) +{ + intercept ("readv", 2); + set_errno (); + return -1; +} + +ssize_t +pread (int fd, void *buf, size_t count, unsigned long offset) +{ + intercept ("pread", 2); + set_errno (); + return -1; +} + + +ssize_t +pread64 (int fd, void *buf, size_t count, uint64_t offset) +{ + intercept ("pread64", 2); + set_errno (); + return -1; +} + +ssize_t +write (int fd, const void *buf, size_t count) +{ + intercept ("write", 2); + set_errno (); + return -1; +} + +ssize_t +writev (int fd, const struct iovec *vector, int count) +{ + intercept ("writev", 2); + set_errno (); + return -1; +} + +ssize_t +pwrite (int fd, const void *buf, size_t count, unsigned long offset) +{ + intercept ("pwrite", 2); + set_errno (); + return -1; +} + +ssize_t +pwrite64 (int fd, const void *buf, size_t count, uint64_t offset) +{ + intercept ("pwrite64", 2); + set_errno (); + return -1; +} + + +off_t +lseek (int fildes, unsigned long offset, int whence) +{ + intercept ("lseek", 2); + set_errno (); + return -1; +} + +off_t +lseek64 (int fildes, uint64_t offset, int whence) +{ + intercept ("lseek64", 2); + set_errno (); + return -1; +} + + +int +dup (int fd) +{ + intercept ("dup", 2); + set_errno (); + return -1; +} + +int +dup2 (int oldfd, int newfd) +{ + intercept ("dup2", 2); + set_errno (); + return -1; +} + +int +mkdir (const char *pathname, mode_t mode) +{ + intercept ("mkdir", 2); + set_errno (); + return -1; +} + +int +rmdir (const char *pathname) +{ + intercept ("rmdir", 2); + set_errno (); + return -1; +} + +int +chmod (const char *pathname, mode_t mode) +{ + intercept ("chmod", 2); + set_errno (); + return -1; +} + +int +chown (const char *pathname, uid_t owner, gid_t group) +{ + intercept ("chown", 2); + set_errno (); + return -1; +} + +int +fchmod (int fd, mode_t mode) +{ + intercept ("fchmod", 2); + set_errno (); + return -1; +} + +int +fchown (int fd, uid_t uid, gid_t gid) +{ + intercept ("fchown", 2); + set_errno (); + return -1; +} + +int fsync (int fd) +{ + intercept ("fsync", 2); + set_errno (); + return -1; +} + + +int +ftruncate (int fd, off_t length) +{ + intercept ("ftruncate", 1); + set_errno (); + return -1; +} + + +int +ftruncate64 (int fd, off_t length) +{ + intercept ("ftruncate64", 1); + set_errno (); + return -1; +} + +int +link (const char *oldpath, const char *newname) +{ + intercept ("link", 2); + set_errno (); + return -1; +} + +int +rename (const char *oldpath, const char *newpath) +{ + intercept ("rename", 2); + set_errno (); + return -1; +} + +int +utimes (const char *path, const struct timeval times[2]) +{ + intercept ("utimes", 2); + set_errno (); + return -1; +} + +int +utime (const char *path, const struct utimbuf *buf) +{ + intercept ("utime", 2); + set_errno (); + return -1; +} + + +int +mknod (const char *path, mode_t mode, dev_t dev) +{ + intercept ("mknod", 2); + set_errno (); + return -1; +} + +int +__xmknod (int ver, const char *path, mode_t mode, dev_t *dev) +{ + intercept ("__xmknod", 2); + set_errno (); + return -1; +} + +int +mkfifo (const char *path, mode_t mode) +{ + intercept ("mkfifo", 2); + set_errno (); + return -1; +} + +int +unlink (const char *path) +{ + intercept ("unlink", 2); + set_errno (); + return -1; +} + + +int +symlink (const char *oldpath, const char *newpath) +{ + intercept ("symlink", 2); + set_errno (); + return -1; +} + +int +readlink (const char *path, char *buf, size_t bufsize) +{ + intercept ("readlink", 1); + set_errno (); + return -1; +} + + +char * +realpath (const char *path, char *resolved) +{ + intercept ("realpath", 1); + set_errno (); + return NULL; +} + + +DIR * +opendir (const char *path) +{ + intercept ("opendir", 2); + set_errno (); + return NULL; +} + + +struct dirent * +readdir (DIR *dir) +{ + intercept ("readdir\t", 2); + set_errno (); + return NULL; +} + +struct dirent * +readdir64 (DIR *dir) +{ + intercept ("readdir64", 2); + set_errno (); + return NULL; +} + + +int +readdir_r (DIR *dir, struct dirent *entry, struct dirent **result) +{ + intercept ("readdir_r", 1); + set_errno (); + return -1; +} + +int +readdir64_r (DIR *dir, struct dirent *entry, struct dirent **result) +{ + intercept ("readdir64_r", 1); + set_errno (); + return -1; +} + + +int +closedir (DIR *dh) +{ + intercept ("closedir", 1); + set_errno (); + return -1; +} + +int +__xstat (int ver, const char *path, struct stat *buf) +{ + intercept ("__xstat\t", 2); + set_errno (); + return -1; +} + + +int +__xstat64 (int ver, const char *path, struct stat *buf) +{ + intercept ("__xstat64", 2); + set_errno (); + return -1; +} + +int +stat (const char *path, struct stat *buf) +{ + intercept ("stat", 2); + set_errno (); + return -1; +} + +int +stat64 (const char *path, struct stat *buf) +{ + intercept ("stat64", 2); + set_errno (); + return -1; +} + +int +__fxstat (int ver, int fd, struct stat *buf) +{ + intercept ("__fxstat\t", 2); + set_errno (); + return -1; +} + + +int +__fxstat64 (int ver, int fd, struct stat *buf) +{ + intercept ("__fxstat64", 2); + set_errno (); + return -1; +} + +int +fstat (int fd, struct stat *buf) +{ + intercept ("fstat", 2); + set_errno (); + return -1; +} + +int +fstat64 (int fd , struct stat *buf) +{ + intercept ("fstat64", 2); + set_errno (); + return -1; +} + +int +__lxstat (int ver, const char *path, struct stat *buf) +{ + intercept ("__lxstat\t", 2); + set_errno (); + return -1; +} + +int +__lxstat64 (int ver, const char *path, struct stat *buf) +{ + intercept ("__lxstat64", 2); + set_errno (); + return -1; +} + +int +lstat (const char *path, struct stat *buf) +{ + intercept ("lstat", 2); + set_errno (); + return -1; +} + +int +lstat64 (const char *path, struct stat *buf) +{ + intercept ("lstat64", 2); + set_errno (); + return -1; +} + +int +statfs (const char *path, struct statfs *buf) +{ + intercept ("statfs", 2); + set_errno (); + return -1; +} + + +int +statfs64 (const char *path, struct statfs *buf) +{ + intercept ("statfs64", 2); + set_errno (); + return -1; +} + +int +statvfs (const char *path, struct statvfs *buf) +{ + intercept ("statvfs\t", 2); + set_errno (); + return -1; +} + + +int +statvfs64 (const char *path, struct statvfs *buf) +{ + intercept ("statvfs64", 2); + set_errno (); + return -1; +} + +ssize_t +getxattr (const char *path, const char *name, void *value, size_t size) +{ + intercept ("getxattr", 1); + set_errno (); + return -1; +} + +ssize_t +lgetxattr (const char *path, const char *name, void *value, size_t size) +{ + intercept ("lgetxattr", 1); + set_errno (); + return -1; +} + + +int +remove (const char* path) +{ + intercept ("remove", 2); + set_errno (); + return -1; +} + +int +lchown (const char *path, uid_t owner, gid_t group) +{ + intercept ("lchown", 2); + set_errno (); + return -1; +} + +void +rewinddir (DIR *dirp) +{ + intercept ("rewinddir", 1); + set_errno (); + return; +} + +void +seekdir (DIR *dirp, off_t offset) +{ + intercept ("seekdir", 2); + set_errno (); + return; +} + +off_t +telldir (DIR *dirp) +{ + intercept ("telldir", 2); + set_errno (); + return -1; +} + +ssize_t +sendfile (int out_fd, int in_fd, off_t *offset, size_t count) +{ + intercept ("sendfile\t", 1); + set_errno (); + return -1; +} + +ssize_t +sendfile64 (int out_fd, int in_fd, off_t *offset, size_t count) +{ + intercept ("sendfile64", 1); + set_errno (); + return -1; +} + + +int +fcntl (int fd, int cmd, ...) +{ + intercept ("fcntl", 2); + set_errno (); + return -1; +} + diff --git a/extras/test/ld-preload-test/ld-preload-test.c b/extras/test/ld-preload-test/ld-preload-test.c new file mode 100644 index 000000000..d4e9c675c --- /dev/null +++ b/extras/test/ld-preload-test/ld-preload-test.c @@ -0,0 +1,377 @@ +/* + Copyright (c) 2007-2009 Z RESEARCH, Inc. <http://www.zresearch.com> + This file is part of GlusterFS. + + GlusterFS 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 3 of the License, + or (at your option) any later version. + + GlusterFS 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, see + <http://www.gnu.org/licenses/>. +*/ + + +/* + * LD PRELOAD Test Tool + * + * 1. The idea of this test tool is to check the sanity of the LD_PRELOAD + * mechanism in libc for the system on which booster needs to run. + * + * 2. Basically, this test tool calls various system calls for which there is + * support in the booster library. Combined with the logging output from this + * tool and the preload-test-lib, one can determine whether the + * pre-loading mechanism is working working in order for booster to initialize. + * + * 3. This tool does not test GlusterFS functionality running under booster + * although the path specified to the tool can be a GlusterFS mountpoint but + * that is not very useful. + * + * 4. This tool is incomplete without the preload-test-lib and the + * accompanyung shell script that needs to be run for running the test. + */ +#define _XOPEN_SOURCE 500 + +#include <dlfcn.h> +#include <sys/types.h> +#include <stdio.h> +#include <stdarg.h> +#include <stdlib.h> +#include <inttypes.h> +#include <string.h> +#include <assert.h> +#include <errno.h> +#include <dirent.h> +#include <sys/statfs.h> +#include <sys/statvfs.h> +#include <sys/stat.h> +#include <fcntl.h> +#include <unistd.h> +#include <sys/uio.h> +#include <utime.h> +#include <sys/time.h> +#include <attr/xattr.h> +#include <sys/sendfile.h> + + +#define PRELOAD_ERRNO_VERF 6449 +inline void +check_err(int ret, char *call, int tabs) +{ + while (tabs > 0) { + fprintf (stdout, "\t"); + --tabs; + } + if (ret != -1) { + fprintf (stdout, "Not intercepted: %s\n", call); + return; + } + + if (errno != PRELOAD_ERRNO_VERF) { + fprintf (stdout, "Not intercepted: %s: err: %s\n", call, + strerror (errno)); + return; + } + + fprintf (stdout, "Intercept verified: %s\n", call); + return; +} + +void +usage (FILE *fp) +{ + fprintf (fp, "Usage: ld-preload-test <Options>\n"); + fprintf (fp, "Options\n"); + fprintf (fp, "\t--path\t\tPathname is used as the file/directory" + " created for the test.\n"); + +} + + +int +run_file_tests (char *testfile) +{ + int ret = -1; + struct stat buf; + + assert (testfile); + fprintf (stdout, "Testing creat"); + ret = creat (testfile, S_IRWXU); + check_err (ret, "creat", 2); + + fprintf (stdout, "Testing close"); + ret = close (ret); + check_err (ret, "close", 2); + + fprintf (stdout, "Testing open"); + ret = open (testfile, O_RDONLY); + check_err (ret, "open", 2); + + fprintf (stdout, "Testing read"); + ret = read (0, NULL, 0); + check_err (ret, "read", 2); + + fprintf (stdout, "Testing readv"); + ret = readv (0, NULL, 0); + check_err (ret, "readv", 2); + + fprintf (stdout, "Testing pread"); + ret = pread (0, NULL, 0, 0); + check_err (ret, "pread", 2); + + fprintf (stdout, "Testing write"); + ret = write (0, NULL, 0); + check_err (ret, "write", 2); + + fprintf (stdout, "Testing writev"); + ret = writev (0, NULL, 0); + check_err (ret, "writev", 2); + + fprintf (stdout, "Testing pwrite"); + ret = pwrite (0, NULL, 0, 0); + check_err (ret, "pwrite", 2); + + fprintf (stdout, "Testing lseek"); + ret = lseek (0, 0, 0); + check_err (ret, "lseek", 2); + + fprintf (stdout, "Testing dup"); + ret = dup (0); + check_err (ret, "dup", 2); + + fprintf (stdout, "Testing dup2"); + ret = dup2 (0, 0); + check_err (ret, "dup2", 2); + + fprintf (stdout, "Testing fchmod"); + ret = fchmod (0, 0); + check_err (ret, "fchmod", 2); + + fprintf (stdout, "Testing fchown"); + ret = fchown (0, 0, 0); + check_err (ret, "fchown", 2); + + fprintf (stdout, "Testing fsync"); + ret = fsync (0); + check_err (ret, "fsync", 2); + + fprintf (stdout, "Testing ftruncate"); + ret = ftruncate (0, 0); + check_err (ret, "ftruncate", 1); + + fprintf (stdout, "Testing fstat"); + ret = fstat (0, &buf); + check_err (ret, "fstat", 1); + + fprintf (stdout, "Testing sendfile"); + ret = sendfile (0, 0, NULL, 0); + check_err (ret, "sendfile", 1); + + fprintf (stdout, "Testing fcntl"); + ret = fcntl (0, 0, NULL); + check_err (ret, "fcntl", 2); + + fprintf (stdout, "Testing close"); + ret = close (ret); + check_err (ret, "close", 2); + + fprintf (stdout, "Testing remove"); + ret = remove (testfile); + check_err (ret, "remove", 2); + + return ret; +} + + +int +run_attr_tests (char *testfile) +{ + int ret = -1; + char *res = NULL; + struct stat buf; + struct statfs sbuf; + struct statvfs svbuf; + + assert (testfile); + + fprintf (stdout, "Testing chmod"); + ret = chmod (testfile, 0); + check_err (ret, "chmod", 2); + + fprintf (stdout, "Testing chown"); + ret = chown (testfile, 0, 0); + check_err (ret, "chown", 2); + + fprintf (stdout, "Testing link"); + ret = link (testfile, testfile); + check_err (ret, "link", 2); + + fprintf (stdout, "Testing rename"); + ret = rename (testfile, testfile); + check_err (ret, "rename", 2); + + fprintf (stdout, "Testing utimes"); + ret = utimes (testfile, NULL); + check_err (ret, "utimes", 2); + + fprintf (stdout, "Testing utime"); + ret = utime (testfile, NULL); + check_err (ret, "utime", 2); + + fprintf (stdout, "Testing unlink"); + ret = unlink (testfile); + check_err (ret, "unlink", 2); + + fprintf (stdout, "Testing symlink"); + ret = symlink (testfile, testfile); + check_err (ret, "symlink", 2); + + fprintf (stdout, "Testing readlink"); + ret = readlink (testfile, testfile, 0); + check_err (ret, "readlink", 2); + + fprintf (stdout, "Testing realpath"); + ret = 0; + res = realpath ((const char *)testfile, testfile); + if (!res) + ret = -1; + check_err (ret, "realpath", 2); + + fprintf (stdout, "Testing stat"); + ret = stat (testfile, &buf); + check_err (ret, "stat", 1); + + fprintf (stdout, "Testing lstat"); + ret = lstat (testfile, &buf); + check_err (ret, "lstat", 1); + + fprintf (stdout, "Testing statfs"); + ret = statfs (testfile, &sbuf); + check_err (ret, "statfs", 2); + + fprintf (stdout, "Testing statvfs"); + ret = statvfs (testfile, &svbuf); + check_err (ret, "statvfs", 1); + + fprintf (stdout, "Testing getxattr"); + ret = getxattr (testfile, NULL, NULL, 0); + check_err (ret, "getxattr", 2); + + fprintf (stdout, "Testing lgetxattr"); + ret = lgetxattr (testfile, NULL, NULL, 0); + check_err (ret, "lgetxattr", 1); + + fprintf (stdout, "Testing lchown"); + ret = lchown (testfile, 0, 0); + check_err (ret, "lchown", 2); + return 0; +} + + +int +run_dev_tests (char *testfile) +{ + int ret = -1; + + assert (testfile); + + fprintf (stdout, "Testing mknod"); + ret = mknod (testfile, 0, 0); + check_err (ret, "mknod", 2); + + fprintf (stdout, "Testing mkfifo"); + ret = mkfifo (testfile, 0); + check_err (ret, "mkfifo", 2); + return 0; +} + +int +run_dir_tests (char *testpath) +{ + int ret = -1; + DIR *dh = NULL; + struct dirent *dire = NULL; + + assert (testpath); + + fprintf (stdout, "Testing mkdir"); + ret = mkdir (testpath, 0); + check_err (ret, "mkdir", 2); + + fprintf (stdout, "Testing rmdir"); + ret = rmdir (testpath); + check_err (ret, "rmdir", 2); + + fprintf (stdout, "Testing opendir"); + ret = 0; + dh = opendir (testpath); + if (!dh) + ret = -1; + check_err (ret, "opendir", 2); + + fprintf (stdout, "Testing readdir"); + ret = 0; + dire = readdir (dh); + if (!dire) + ret = -1; + check_err (ret, "readdir", 1); + + fprintf (stdout, "Testing readdir_r"); + ret = readdir_r (dh, dire, &dire); + check_err (ret, "readdir_r", 1); + + fprintf (stdout, "Testing rewinddir"); + rewinddir (dh); + check_err (-1, "rewinddir", 1); + + fprintf (stdout, "Testing seekdir"); + seekdir (dh, 0); + check_err (-1, "seekdir", 2); + + fprintf (stdout, "Testing telldir"); + ret = telldir (dh); + check_err (ret, "telldir", 2); + + fprintf (stdout, "Testing closedir"); + ret = closedir (dh); + check_err (ret, "closedir", 2); + return 0; +} + + + +int +main (int argc, char *argv[]) +{ + char *testpath = NULL; + int x = 0; + + for (;x < argc; ++x) { + if (strcmp (argv[x], "--path") == 0) { + testpath = argv[x+1]; + continue; + } + + } + + if (!testpath) { + fprintf (stderr, "--path not specified\n"); + usage (stderr); + return -1; + } + + run_file_tests (testpath); + run_dir_tests (testpath); + run_attr_tests (testpath); + run_dev_tests (testpath); + + return 0; +} + + diff --git a/extras/test/ld-preload-test/test-preload.sh b/extras/test/ld-preload-test/test-preload.sh new file mode 100755 index 000000000..faed5cee3 --- /dev/null +++ b/extras/test/ld-preload-test/test-preload.sh @@ -0,0 +1,7 @@ +#!/bin/sh + +echo "Testing 32-bit offsets build" +LD_PRELOAD="$(pwd)/ld-preload-lib.so" $(pwd)/ld-preload-test32 --path /tmp/testfile +echo +echo "Testing 64-bit offsets build" +LD_PRELOAD="$(pwd)/ld-preload-lib.so" $(pwd)/ld-preload-test64 --path /tmp/testfile |