diff options
Diffstat (limited to 'tests')
65 files changed, 7651 insertions, 7508 deletions
diff --git a/tests/basic/ctime/ctime-glfs-init.c b/tests/basic/ctime/ctime-glfs-init.c index 57a3dc7820e..e4f197b8f30 100644 --- a/tests/basic/ctime/ctime-glfs-init.c +++ b/tests/basic/ctime/ctime-glfs-init.c @@ -10,58 +10,59 @@ #include <glusterfs/api/glfs.h> #include <glusterfs/api/glfs-handles.h> -#define LOG_ERR(msg) do { \ - fprintf (stderr, "%s : Error (%s)\n", msg, strerror (errno)); \ - } while (0) +#define LOG_ERR(msg) \ + do { \ + fprintf(stderr, "%s : Error (%s)\n", msg, strerror(errno)); \ + } while (0) int -main (int argc, char *argv[]) +main(int argc, char *argv[]) { - int ret = 0; - char *hostname = NULL; - char *volname = NULL; - char *logfile = NULL; - glfs_t *fs = NULL; + int ret = 0; + char *hostname = NULL; + char *volname = NULL; + char *logfile = NULL; + glfs_t *fs = NULL; - if (argc != 4) { - fprintf (stderr, "Invalid argument\n"); - exit(1); - } + if (argc != 4) { + fprintf(stderr, "Invalid argument\n"); + exit(1); + } - hostname = argv[1]; - volname = argv[2]; - logfile = argv[3]; + hostname = argv[1]; + volname = argv[2]; + logfile = argv[3]; - fs = glfs_new (volname); - if (!fs) { - LOG_ERR ("glfs_new failed"); - return -1; - } + fs = glfs_new(volname); + if (!fs) { + LOG_ERR("glfs_new failed"); + return -1; + } - ret = glfs_set_volfile_server (fs, "tcp", hostname, 24007); - if (ret < 0) { - LOG_ERR ("glfs_set_volfile_server failed"); - goto err; - } + ret = glfs_set_volfile_server(fs, "tcp", hostname, 24007); + if (ret < 0) { + LOG_ERR("glfs_set_volfile_server failed"); + goto err; + } - ret = glfs_set_logging (fs, logfile, 7); - if (ret < 0) { - LOG_ERR ("glfs_set_logging failed"); - goto err; - } + ret = glfs_set_logging(fs, logfile, 7); + if (ret < 0) { + LOG_ERR("glfs_set_logging failed"); + goto err; + } - ret = glfs_init (fs); - if (ret < 0) { - LOG_ERR ("glfs_init failed"); - goto err; - } + ret = glfs_init(fs); + if (ret < 0) { + LOG_ERR("glfs_init failed"); + goto err; + } - glfs_fini (fs); - fs = NULL; - return 0; + glfs_fini(fs); + fs = NULL; + return 0; err: - glfs_fini (fs); - fs = NULL; + glfs_fini(fs); + fs = NULL; - return -1; + return -1; } diff --git a/tests/basic/ec/ec-fast-fgetxattr.c b/tests/basic/ec/ec-fast-fgetxattr.c index b40dda65de5..bf982151861 100644 --- a/tests/basic/ec/ec-fast-fgetxattr.c +++ b/tests/basic/ec/ec-fast-fgetxattr.c @@ -12,123 +12,118 @@ int cbk_complete = 0; ssize_t cbk_ret_val = 0; int -fill_iov (struct iovec *iov, char fillchar, int count) +fill_iov(struct iovec *iov, char fillchar, int count) { - int ret = -1; - - iov->iov_base = malloc (count + 1); - if (iov->iov_base == NULL) { - return ret; - } else { - iov->iov_len = count; - ret = 0; - } - memset (iov->iov_base, fillchar, count); - memset (iov->iov_base + count, '\0', 1); + int ret = -1; + iov->iov_base = malloc(count + 1); + if (iov->iov_base == NULL) { return ret; + } else { + iov->iov_len = count; + ret = 0; + } + memset(iov->iov_base, fillchar, count); + memset(iov->iov_base + count, '\0', 1); + + return ret; } void -write_async_cbk (glfs_fd_t *fd, ssize_t ret, struct stat *prestat, - struct stat *poststat, void *cookie) +write_async_cbk(glfs_fd_t *fd, ssize_t ret, struct stat *prestat, + struct stat *poststat, void *cookie) { - - if (ret < 0) { - fprintf (stderr, "glfs_write failed"); - } - cbk_ret_val = ret; - cbk_complete = 1; + if (ret < 0) { + fprintf(stderr, "glfs_write failed"); + } + cbk_ret_val = ret; + cbk_complete = 1; } int -write_async (glfs_t *fs, glfs_fd_t *glfd, int char_count) +write_async(glfs_t *fs, glfs_fd_t *glfd, int char_count) { - ssize_t ret = -1; - int flags = O_RDWR; - struct iovec iov = {0}; - - + ssize_t ret = -1; + int flags = O_RDWR; + struct iovec iov = {0}; - ret = fill_iov (&iov, 'a', char_count); - if (ret) { - fprintf (stderr, "failed to create iov"); - goto out; - } + ret = fill_iov(&iov, 'a', char_count); + if (ret) { + fprintf(stderr, "failed to create iov"); + goto out; + } - ret = glfs_pwritev_async (glfd, &iov, 1, 0, flags, write_async_cbk, - NULL); + ret = glfs_pwritev_async(glfd, &iov, 1, 0, flags, write_async_cbk, NULL); out: - if (ret < 0) { - fprintf (stderr, "glfs_pwritev async failed"); - } - return ret; - + if (ret < 0) { + fprintf(stderr, "glfs_pwritev async failed"); + } + return ret; } int -main (int argc, char *argv[]) +main(int argc, char *argv[]) { - glfs_t *fs = NULL; - glfs_fd_t *fd = NULL; - int ret = 1; - char buf[1024] = {0}; - - if (argc != 4) { - fprintf (stderr, "Syntax: %s <host> <volname> <file>\n", argv[0]); - return 1; - } - - fs = glfs_new (argv[2]); - if (!fs) { - fprintf (stderr, "glfs_new: returned NULL\n"); - return 1; - } - - ret = glfs_set_volfile_server (fs, "tcp", argv[1], 24007); - if (ret != 0) { - fprintf (stderr, "glfs_set_volfile_server: returned %d\n", ret); - goto out; - } - ret = glfs_set_logging (fs, "/tmp/ec-fgetxattr.log", 7); - if (ret != 0) { - fprintf (stderr, "glfs_set_logging: returned %d\n", ret); - goto out; - } - ret = glfs_init (fs); - if (ret != 0) { - fprintf (stderr, "glfs_init: returned %d\n", ret); - goto out; - } - - fd = glfs_open (fs, argv[3], O_RDWR | O_TRUNC); - if (fd == NULL) { - fprintf (stderr, "glfs_open: returned NULL\n"); - goto out; - } - - ret = write_async (fs, fd, 16); - if (ret) { - fprintf (stderr, "write_async failed\n"); - } - - sleep (1); - ret = glfs_fgetxattr (fd, "trusted.glusterfs.abc", buf, sizeof buf); - while (cbk_complete != 1) { - /* ret will be -ve as xattr doesn't exist, and fgetxattr should - * return waaaayyy before writev */ - ret = 0; - sleep (1); - } - if (cbk_ret_val < 0) { - fprintf (stderr, "cbk_ret_val is -ve\n"); - ret = -1; - } - glfs_close(fd); + glfs_t *fs = NULL; + glfs_fd_t *fd = NULL; + int ret = 1; + char buf[1024] = {0}; + + if (argc != 4) { + fprintf(stderr, "Syntax: %s <host> <volname> <file>\n", argv[0]); + return 1; + } + + fs = glfs_new(argv[2]); + if (!fs) { + fprintf(stderr, "glfs_new: returned NULL\n"); + return 1; + } + + ret = glfs_set_volfile_server(fs, "tcp", argv[1], 24007); + if (ret != 0) { + fprintf(stderr, "glfs_set_volfile_server: returned %d\n", ret); + goto out; + } + ret = glfs_set_logging(fs, "/tmp/ec-fgetxattr.log", 7); + if (ret != 0) { + fprintf(stderr, "glfs_set_logging: returned %d\n", ret); + goto out; + } + ret = glfs_init(fs); + if (ret != 0) { + fprintf(stderr, "glfs_init: returned %d\n", ret); + goto out; + } + + fd = glfs_open(fs, argv[3], O_RDWR | O_TRUNC); + if (fd == NULL) { + fprintf(stderr, "glfs_open: returned NULL\n"); + goto out; + } + + ret = write_async(fs, fd, 16); + if (ret) { + fprintf(stderr, "write_async failed\n"); + } + + sleep(1); + ret = glfs_fgetxattr(fd, "trusted.glusterfs.abc", buf, sizeof buf); + while (cbk_complete != 1) { + /* ret will be -ve as xattr doesn't exist, and fgetxattr should + * return waaaayyy before writev */ + ret = 0; + sleep(1); + } + if (cbk_ret_val < 0) { + fprintf(stderr, "cbk_ret_val is -ve\n"); + ret = -1; + } + glfs_close(fd); out: - unlink ("/tmp/ec-fgetxattr.log"); - glfs_fini (fs); + unlink("/tmp/ec-fgetxattr.log"); + glfs_fini(fs); - return ret; + return ret; } diff --git a/tests/basic/ec/seek.c b/tests/basic/ec/seek.c index 67036ad4e75..54fa6f463af 100644 --- a/tests/basic/ec/seek.c +++ b/tests/basic/ec/seek.c @@ -15,171 +15,168 @@ static char buffer[65536]; static int parse_int(const char *text, size_t *value) { - char *ptr; - size_t val; + char *ptr; + size_t val; - val = strtoul(text, &ptr, 0); - if (*ptr != 0) { - return 0; - } + val = strtoul(text, &ptr, 0); + if (*ptr != 0) { + return 0; + } - *value = val; + *value = val; - return 1; + return 1; } static int fill_area(int fd, off_t offset, size_t size) { - size_t len; - ssize_t res; - - while (size > 0) { - len = sizeof(buffer); - if (len > size) { - len = size; - } - res = pwrite(fd, buffer, len, offset); - if (res < 0) { - fprintf(stderr, - "pwrite(%d, %p, %lu, %lu) failed: %d\n", - fd, buffer, size, offset, errno); - return 0; - } - if (res != len) { - fprintf(stderr, - "pwrite(%d, %p, %lu, %lu) didn't wrote all " - "data: %lu/%lu\n", - fd, buffer, size, offset, res, len); - return 0; - } - offset += len; - size -= len; + size_t len; + ssize_t res; + + while (size > 0) { + len = sizeof(buffer); + if (len > size) { + len = size; + } + res = pwrite(fd, buffer, len, offset); + if (res < 0) { + fprintf(stderr, "pwrite(%d, %p, %lu, %lu) failed: %d\n", fd, buffer, + size, offset, errno); + return 0; + } + if (res != len) { + fprintf(stderr, + "pwrite(%d, %p, %lu, %lu) didn't wrote all " + "data: %lu/%lu\n", + fd, buffer, size, offset, res, len); + return 0; } + offset += len; + size -= len; + } - return 1; + return 1; } static void syntax(void) { - fprintf(stderr, "Syntax: seek create <path> <offset> <size> [...]\n"); - fprintf(stderr, " seek scan <path> data|hole <offset>\n"); + fprintf(stderr, "Syntax: seek create <path> <offset> <size> [...]\n"); + fprintf(stderr, " seek scan <path> data|hole <offset>\n"); } static int seek_create(const char *path, int argc, char *argv[]) { - size_t off, size; - int fd; - int ret = 1; - - fd = open(path, O_CREAT | O_TRUNC | O_RDWR, 0644); - if (fd < 0) { - fprintf(stderr, "Failed to create the file\n"); - goto out; + size_t off, size; + int fd; + int ret = 1; + + fd = open(path, O_CREAT | O_TRUNC | O_RDWR, 0644); + if (fd < 0) { + fprintf(stderr, "Failed to create the file\n"); + goto out; + } + + while (argc > 0) { + if (!parse_int(argv[0], &off) || !parse_int(argv[1], &size)) { + syntax(); + goto out_close; } - - while (argc > 0) { - if (!parse_int(argv[0], &off) || - !parse_int(argv[1], &size)) { - syntax(); - goto out_close; - } - if (!fill_area(fd, off, size)) { - goto out_close; - } - argv += 2; - argc -= 2; + if (!fill_area(fd, off, size)) { + goto out_close; } + argv += 2; + argc -= 2; + } - ret = 0; + ret = 0; out_close: - close(fd); + close(fd); out: - return ret; + return ret; } static int seek_scan(const char *path, const char *type, const char *pos) { - size_t off, res; - int fd, whence; - int ret = 1; - - if (strcmp(type, "data") == 0) { - whence = SEEK_DATA; - } else if (strcmp(type, "hole") == 0) { - whence = SEEK_HOLE; - } else { - syntax(); - goto out; - } - - if (!parse_int(pos, &off)) { - syntax(); - goto out; + size_t off, res; + int fd, whence; + int ret = 1; + + if (strcmp(type, "data") == 0) { + whence = SEEK_DATA; + } else if (strcmp(type, "hole") == 0) { + whence = SEEK_HOLE; + } else { + syntax(); + goto out; + } + + if (!parse_int(pos, &off)) { + syntax(); + goto out; + } + + fd = open(path, O_RDWR); + if (fd < 0) { + fprintf(stderr, "Failed to open the file\n"); + goto out; + } + + res = lseek(fd, off, whence); + if (res == (off_t)-1) { + if (errno != ENXIO) { + fprintf(stderr, "seek(%d, %lu, %d) failed: %d\n", fd, off, whence, + errno); + goto out_close; } + fprintf(stdout, "ENXIO\n"); + } else { + fprintf(stdout, "%lu\n", res); + } - fd = open(path, O_RDWR); - if (fd < 0) { - fprintf(stderr, "Failed to open the file\n"); - goto out; - } - - res = lseek(fd, off, whence); - if (res == (off_t)-1) { - if (errno != ENXIO) { - fprintf(stderr, "seek(%d, %lu, %d) failed: %d\n", fd, - off, whence, errno); - goto out_close; - } - fprintf(stdout, "ENXIO\n"); - } else { - fprintf(stdout, "%lu\n", res); - } - - ret = 0; + ret = 0; out_close: - close(fd); + close(fd); out: - return ret; + return ret; } int main(int argc, char *argv[]) { - int ret = 1; + int ret = 1; - memset(buffer, 0x55, sizeof(buffer)); + memset(buffer, 0x55, sizeof(buffer)); - if (argc < 3) { - syntax(); - goto out; - } + if (argc < 3) { + syntax(); + goto out; + } - if (strcmp(argv[1], "create") == 0) { - if (((argc - 3) & 1) != 0) { - syntax(); - goto out; - } - ret = seek_create(argv[2], argc - 3, argv + 3); - } else if (strcmp(argv[1], "scan") == 0) { - if (argc != 5) { - syntax(); - goto out; - } - ret = seek_scan(argv[2], argv[3], argv[4]); - } else { - syntax(); - goto out; + if (strcmp(argv[1], "create") == 0) { + if (((argc - 3) & 1) != 0) { + syntax(); + goto out; + } + ret = seek_create(argv[2], argc - 3, argv + 3); + } else if (strcmp(argv[1], "scan") == 0) { + if (argc != 5) { + syntax(); + goto out; } + ret = seek_scan(argv[2], argv[3], argv[4]); + } else { + syntax(); + goto out; + } - ret = 0; + ret = 0; out: - return ret; + return ret; } - diff --git a/tests/basic/fops-sanity.c b/tests/basic/fops-sanity.c index 1e2ccde6bd8..aff72d89ca1 100644 --- a/tests/basic/fops-sanity.c +++ b/tests/basic/fops-sanity.c @@ -34,858 +34,904 @@ #endif /* for fd based fops after unlink */ -int fd_based_fops_1 (char *filename); +int +fd_based_fops_1(char *filename); /* for fd based fops before unlink */ -int fd_based_fops_2 (char *filename); +int +fd_based_fops_2(char *filename); /* fops based on fd after dup */ -int dup_fd_based_fops (char *filename); +int +dup_fd_based_fops(char *filename); /* for fops based on path */ -int path_based_fops (char *filename); +int +path_based_fops(char *filename); /* for fops which operate on directory */ -int dir_based_fops (char *filename); +int +dir_based_fops(char *filename); /* for fops which operate in link files (symlinks) */ -int link_based_fops (char *filename); +int +link_based_fops(char *filename); /* to test open syscall with open modes available. */ -int test_open_modes (char *filename); +int +test_open_modes(char *filename); /* generic function which does open write and read. */ -int generic_open_read_write (char *filename, int flag, mode_t mode); +int +generic_open_read_write(char *filename, int flag, mode_t mode); -#define OPEN_MODE 0666 +#define OPEN_MODE 0666 int -main (int argc, char *argv[]) +main(int argc, char *argv[]) { - int ret = -1; - int result = 0; - char filename[255] = {0,}; - - if (argc > 1) - strcpy(filename, argv[1]); - else - strcpy(filename, "temp-xattr-test-file"); - - ret = fd_based_fops_1 (strcat(filename, "_1")); - if (ret < 0) { - fprintf (stderr, "fd based file operation 1 failed\n"); - result |= ret; - } else { - fprintf (stdout, "fd based file operation 1 passed\n"); - } - - ret = fd_based_fops_2 (strcat(filename, "_2")); - if (ret < 0) { - result |= ret; - fprintf (stderr, "fd based file operation 2 failed\n"); - } else { - fprintf (stdout, "fd based file operation 2 passed\n"); - } - - ret = dup_fd_based_fops (strcat (filename, "_3")); - if (ret < 0) { - result |= ret; - fprintf (stderr, "dup fd based file operation failed\n"); - } else { - fprintf (stdout, "dup fd based file operation passed\n"); - } - - ret = path_based_fops (strcat (filename, "_4")); - if (ret < 0) { - result |= ret; - fprintf (stderr, "path based file operation failed\n"); - } else { - fprintf (stdout, "path based file operation passed\n"); - } - - ret = dir_based_fops (strcat (filename, "_5")); - if (ret < 0) { - result |= ret; - fprintf (stderr, "directory based file operation failed\n"); - } else { - fprintf (stdout, "directory based file operation passed\n"); - } - - ret = link_based_fops (strcat (filename, "_5")); - if (ret < 0) { - result |= ret; - fprintf (stderr, "link based file operation failed\n"); - } else { - fprintf (stdout, "link based file operation passed\n"); - } - - ret = test_open_modes (strcat (filename, "_5")); - if (ret < 0) { - result |= ret; - fprintf (stderr, "testing modes of `open' call failed\n"); - } else { - fprintf (stdout, "testing modes of `open' call passed\n"); - } - return result; + int ret = -1; + int result = 0; + char filename[255] = { + 0, + }; + + if (argc > 1) + strcpy(filename, argv[1]); + else + strcpy(filename, "temp-xattr-test-file"); + + ret = fd_based_fops_1(strcat(filename, "_1")); + if (ret < 0) { + fprintf(stderr, "fd based file operation 1 failed\n"); + result |= ret; + } else { + fprintf(stdout, "fd based file operation 1 passed\n"); + } + + ret = fd_based_fops_2(strcat(filename, "_2")); + if (ret < 0) { + result |= ret; + fprintf(stderr, "fd based file operation 2 failed\n"); + } else { + fprintf(stdout, "fd based file operation 2 passed\n"); + } + + ret = dup_fd_based_fops(strcat(filename, "_3")); + if (ret < 0) { + result |= ret; + fprintf(stderr, "dup fd based file operation failed\n"); + } else { + fprintf(stdout, "dup fd based file operation passed\n"); + } + + ret = path_based_fops(strcat(filename, "_4")); + if (ret < 0) { + result |= ret; + fprintf(stderr, "path based file operation failed\n"); + } else { + fprintf(stdout, "path based file operation passed\n"); + } + + ret = dir_based_fops(strcat(filename, "_5")); + if (ret < 0) { + result |= ret; + fprintf(stderr, "directory based file operation failed\n"); + } else { + fprintf(stdout, "directory based file operation passed\n"); + } + + ret = link_based_fops(strcat(filename, "_5")); + if (ret < 0) { + result |= ret; + fprintf(stderr, "link based file operation failed\n"); + } else { + fprintf(stdout, "link based file operation passed\n"); + } + + ret = test_open_modes(strcat(filename, "_5")); + if (ret < 0) { + result |= ret; + fprintf(stderr, "testing modes of `open' call failed\n"); + } else { + fprintf(stdout, "testing modes of `open' call passed\n"); + } + return result; } /* Execute all possible fops on a fd which is unlinked */ int -fd_based_fops_1 (char *filename) +fd_based_fops_1(char *filename) { - int fd = 0; - int ret = -1; - int result = 0; - struct stat stbuf = {0,}; - char wstr[50] = {0,}; - char rstr[50] = {0,}; - - fd = open (filename, O_RDWR|O_CREAT, OPEN_MODE); - if (fd < 0) { - fprintf (stderr, "open failed : %s\n", strerror (errno)); - return ret; - } - - ret = unlink (filename); - if (ret < 0) { - fprintf (stderr, "unlink failed : %s\n", strerror (errno)); - result |= ret; - } - - strcpy (wstr, "This is my string\n"); - ret = write (fd, wstr, strlen(wstr)); - if (ret <= 0) { - fprintf (stderr, "write failed: %s\n", strerror (errno)); - result |= ret; - } - - ret = lseek (fd, 0, SEEK_SET); - if (ret < 0) { - fprintf (stderr, "lseek failed: %s\n", strerror (errno)); - result |= ret; - } - - ret = read (fd, rstr, strlen(wstr)); - if (ret <= 0) { - fprintf (stderr, "read failed: %s\n", strerror (errno)); - result |= ret; - } - - ret = memcmp (rstr, wstr, strlen (wstr)); - if (ret != 0) { - fprintf (stderr, "read returning junk\n"); - result |= ret; - } - - ret = ftruncate (fd, 0); - if (ret < 0) { - fprintf (stderr, "ftruncate failed : %s\n", strerror (errno)); - result |= ret; - } - - ret = fstat (fd, &stbuf); - if (ret < 0) { - fprintf (stderr, "fstat failed : %s\n", strerror (errno)); - result |= ret; - } - - ret = fsync (fd); - if (ret < 0) { - fprintf (stderr, "fsync failed : %s\n", strerror (errno)); - result |= ret; - } - - ret = fdatasync (fd); - if (ret < 0) { - fprintf (stderr, "fdatasync failed : %s\n", strerror (errno)); - result |= ret; - } - -/* - * These metadata operations fail at the moment because kernel doesn't - * pass the client fd in the operation. - * The following bug tracks this change. - * https://bugzilla.redhat.com/show_bug.cgi?id=1084422 - * ret = fchmod (fd, 0640); - * if (ret < 0) { - * fprintf (stderr, "fchmod failed : %s\n", strerror (errno)); - * result |= ret; - * } - - * ret = fchown (fd, 10001, 10001); - * if (ret < 0) { - * fprintf (stderr, "fchown failed : %s\n", strerror (errno)); - * result |= ret; - * } - - * ret = fsetxattr (fd, "trusted.xattr-test", "working", 8, 0); - * if (ret < 0) { - * fprintf (stderr, "fsetxattr failed : %s\n", strerror (errno)); - * result |= ret; - * } - - * ret = flistxattr (fd, NULL, 0); - * if (ret <= 0) { - * fprintf (stderr, "flistxattr failed : %s\n", strerror (errno)); - * result |= ret; - * } - - * ret = fgetxattr (fd, "trusted.xattr-test", NULL, 0); - * if (ret <= 0) { - * fprintf (stderr, "fgetxattr failed : %s\n", strerror (errno)); - * result |= ret; - * } - - * ret = fremovexattr (fd, "trusted.xattr-test"); - * if (ret < 0) { - * fprintf (stderr, "fremovexattr failed : %s\n", strerror (errno)); - * result |= ret; - * } - */ - - if (fd) - close(fd); - return result; + int fd = 0; + int ret = -1; + int result = 0; + struct stat stbuf = { + 0, + }; + char wstr[50] = { + 0, + }; + char rstr[50] = { + 0, + }; + + fd = open(filename, O_RDWR | O_CREAT, OPEN_MODE); + if (fd < 0) { + fprintf(stderr, "open failed : %s\n", strerror(errno)); + return ret; + } + + ret = unlink(filename); + if (ret < 0) { + fprintf(stderr, "unlink failed : %s\n", strerror(errno)); + result |= ret; + } + + strcpy(wstr, "This is my string\n"); + ret = write(fd, wstr, strlen(wstr)); + if (ret <= 0) { + fprintf(stderr, "write failed: %s\n", strerror(errno)); + result |= ret; + } + + ret = lseek(fd, 0, SEEK_SET); + if (ret < 0) { + fprintf(stderr, "lseek failed: %s\n", strerror(errno)); + result |= ret; + } + + ret = read(fd, rstr, strlen(wstr)); + if (ret <= 0) { + fprintf(stderr, "read failed: %s\n", strerror(errno)); + result |= ret; + } + + ret = memcmp(rstr, wstr, strlen(wstr)); + if (ret != 0) { + fprintf(stderr, "read returning junk\n"); + result |= ret; + } + + ret = ftruncate(fd, 0); + if (ret < 0) { + fprintf(stderr, "ftruncate failed : %s\n", strerror(errno)); + result |= ret; + } + + ret = fstat(fd, &stbuf); + if (ret < 0) { + fprintf(stderr, "fstat failed : %s\n", strerror(errno)); + result |= ret; + } + + ret = fsync(fd); + if (ret < 0) { + fprintf(stderr, "fsync failed : %s\n", strerror(errno)); + result |= ret; + } + + ret = fdatasync(fd); + if (ret < 0) { + fprintf(stderr, "fdatasync failed : %s\n", strerror(errno)); + result |= ret; + } + + /* + * These metadata operations fail at the moment because kernel doesn't + * pass the client fd in the operation. + * The following bug tracks this change. + * https://bugzilla.redhat.com/show_bug.cgi?id=1084422 + * ret = fchmod (fd, 0640); + * if (ret < 0) { + * fprintf (stderr, "fchmod failed : %s\n", strerror (errno)); + * result |= ret; + * } + + * ret = fchown (fd, 10001, 10001); + * if (ret < 0) { + * fprintf (stderr, "fchown failed : %s\n", strerror (errno)); + * result |= ret; + * } + + * ret = fsetxattr (fd, "trusted.xattr-test", "working", 8, 0); + * if (ret < 0) { + * fprintf (stderr, "fsetxattr failed : %s\n", strerror + (errno)); + * result |= ret; + * } + + * ret = flistxattr (fd, NULL, 0); + * if (ret <= 0) { + * fprintf (stderr, "flistxattr failed : %s\n", strerror + (errno)); + * result |= ret; + * } + + * ret = fgetxattr (fd, "trusted.xattr-test", NULL, 0); + * if (ret <= 0) { + * fprintf (stderr, "fgetxattr failed : %s\n", strerror + (errno)); + * result |= ret; + * } + + * ret = fremovexattr (fd, "trusted.xattr-test"); + * if (ret < 0) { + * fprintf (stderr, "fremovexattr failed : %s\n", strerror + (errno)); + * result |= ret; + * } + */ + + if (fd) + close(fd); + return result; } - int -fd_based_fops_2 (char *filename) +fd_based_fops_2(char *filename) { - int fd = 0; - int ret = -1; - int result = 0; - struct stat stbuf = {0,}; - char wstr[50] = {0,}; - char rstr[50] = {0,}; - - fd = open (filename, O_RDWR|O_CREAT, OPEN_MODE); - if (fd < 0) { - fprintf (stderr, "open failed : %s\n", strerror (errno)); - return ret; - } - - ret = ftruncate (fd, 0); - if (ret < 0) { - fprintf (stderr, "ftruncate failed : %s\n", strerror (errno)); - result |= ret; - } - - strcpy (wstr, "This is my second string\n"); - ret = write (fd, wstr, strlen (wstr)); - if (ret < 0) { - fprintf (stderr, "write failed: %s\n", strerror (errno)); - result |= ret; - } - - lseek (fd, 0, SEEK_SET); - if (ret < 0) { - fprintf (stderr, "lseek failed: %s\n", strerror (errno)); - result |= ret; - } - - ret = read (fd, rstr, strlen (wstr)); - if (ret <= 0) { - fprintf (stderr, "read failed: %s\n", strerror (errno)); - result |= ret; - } - - ret = memcmp (rstr, wstr, strlen (wstr)); - if (ret != 0) { - fprintf (stderr, "read returning junk\n"); - result |= ret; - } - - ret = fstat (fd, &stbuf); - if (ret < 0) { - fprintf (stderr, "fstat failed : %s\n", strerror (errno)); - result |= ret; - } - - ret = fchmod (fd, 0640); - if (ret < 0) { - fprintf (stderr, "fchmod failed : %s\n", strerror (errno)); - result |= ret; - } - - ret = fchown (fd, 10001, 10001); - if (ret < 0) { - fprintf (stderr, "fchown failed : %s\n", strerror (errno)); - result |= ret; - } - - ret = fsync (fd); - if (ret < 0) { - fprintf (stderr, "fsync failed : %s\n", strerror (errno)); - result |= ret; - } - - ret = fsetxattr (fd, "trusted.xattr-test", "working", 8, 0); - if (ret < 0) { - fprintf (stderr, "fsetxattr failed : %s\n", strerror (errno)); - result |= ret; - } - - ret = fdatasync (fd); - if (ret < 0) { - fprintf (stderr, "fdatasync failed : %s\n", strerror (errno)); - result |= ret; - } - - ret = flistxattr (fd, NULL, 0); - if (ret <= 0) { - fprintf (stderr, "flistxattr failed : %s\n", strerror (errno)); - result |= ret; - } - - ret = fgetxattr (fd, "trusted.xattr-test", NULL, 0); - if (ret <= 0) { - fprintf (stderr, "fgetxattr failed : %s\n", strerror (errno)); - result |= ret; - } - - ret = fremovexattr (fd, "trusted.xattr-test"); - if (ret < 0) { - fprintf (stderr, "fremovexattr failed : %s\n", strerror (errno)); - result |= ret; - } - - if (fd) - close (fd); - unlink (filename); - - return result; + int fd = 0; + int ret = -1; + int result = 0; + struct stat stbuf = { + 0, + }; + char wstr[50] = { + 0, + }; + char rstr[50] = { + 0, + }; + + fd = open(filename, O_RDWR | O_CREAT, OPEN_MODE); + if (fd < 0) { + fprintf(stderr, "open failed : %s\n", strerror(errno)); + return ret; + } + + ret = ftruncate(fd, 0); + if (ret < 0) { + fprintf(stderr, "ftruncate failed : %s\n", strerror(errno)); + result |= ret; + } + + strcpy(wstr, "This is my second string\n"); + ret = write(fd, wstr, strlen(wstr)); + if (ret < 0) { + fprintf(stderr, "write failed: %s\n", strerror(errno)); + result |= ret; + } + + lseek(fd, 0, SEEK_SET); + if (ret < 0) { + fprintf(stderr, "lseek failed: %s\n", strerror(errno)); + result |= ret; + } + + ret = read(fd, rstr, strlen(wstr)); + if (ret <= 0) { + fprintf(stderr, "read failed: %s\n", strerror(errno)); + result |= ret; + } + + ret = memcmp(rstr, wstr, strlen(wstr)); + if (ret != 0) { + fprintf(stderr, "read returning junk\n"); + result |= ret; + } + + ret = fstat(fd, &stbuf); + if (ret < 0) { + fprintf(stderr, "fstat failed : %s\n", strerror(errno)); + result |= ret; + } + + ret = fchmod(fd, 0640); + if (ret < 0) { + fprintf(stderr, "fchmod failed : %s\n", strerror(errno)); + result |= ret; + } + + ret = fchown(fd, 10001, 10001); + if (ret < 0) { + fprintf(stderr, "fchown failed : %s\n", strerror(errno)); + result |= ret; + } + + ret = fsync(fd); + if (ret < 0) { + fprintf(stderr, "fsync failed : %s\n", strerror(errno)); + result |= ret; + } + + ret = fsetxattr(fd, "trusted.xattr-test", "working", 8, 0); + if (ret < 0) { + fprintf(stderr, "fsetxattr failed : %s\n", strerror(errno)); + result |= ret; + } + + ret = fdatasync(fd); + if (ret < 0) { + fprintf(stderr, "fdatasync failed : %s\n", strerror(errno)); + result |= ret; + } + + ret = flistxattr(fd, NULL, 0); + if (ret <= 0) { + fprintf(stderr, "flistxattr failed : %s\n", strerror(errno)); + result |= ret; + } + + ret = fgetxattr(fd, "trusted.xattr-test", NULL, 0); + if (ret <= 0) { + fprintf(stderr, "fgetxattr failed : %s\n", strerror(errno)); + result |= ret; + } + + ret = fremovexattr(fd, "trusted.xattr-test"); + if (ret < 0) { + fprintf(stderr, "fremovexattr failed : %s\n", strerror(errno)); + result |= ret; + } + + if (fd) + close(fd); + unlink(filename); + + return result; } int -path_based_fops (char *filename) +path_based_fops(char *filename) { - int ret = -1; - int fd = 0; - int result = 0; - struct stat stbuf = {0,}; - char newfilename[255] = {0,}; - char *hardlink = "linkfile-hard.txt"; - char *symlnk = "linkfile-soft.txt"; - char buf[1024] = {0,}; - - fd = creat (filename, 0644); - if (fd < 0) { - fprintf (stderr, "creat failed: %s\n", strerror (errno)); - return ret; - } - - ret = truncate (filename, 0); - if (ret < 0) { - fprintf (stderr, "truncate failed: %s\n", strerror (errno)); - result |= ret; - } - - ret = stat (filename, &stbuf); - if (ret < 0) { - fprintf (stderr, "stat failed: %s\n", strerror (errno)); - result |= ret; - } - - ret = chmod (filename, 0640); - if (ret < 0) { - fprintf (stderr, "chmod failed: %s\n", strerror (errno)); - result |= ret; - } - - ret = chown (filename, 10001, 10001); - if (ret < 0) { - fprintf (stderr, "chown failed: %s\n", strerror (errno)); - result |= ret; - } - - ret = setxattr (filename, "trusted.xattr-test", "working", 8, 0); - if (ret < 0) { - fprintf (stderr, "setxattr failed: %s\n", strerror (errno)); - result |= ret; - } - - ret = listxattr (filename, NULL, 0); - if (ret <= 0) { - ret = -1; - fprintf (stderr, "listxattr failed: %s\n", strerror (errno)); - result |= ret; - } - - ret = getxattr (filename, "trusted.xattr-test", NULL, 0); - if (ret <= 0) { - fprintf (stderr, "getxattr failed: %s\n", strerror (errno)); - result |= ret; - } - - ret = removexattr (filename, "trusted.xattr-test"); - if (ret < 0) { - fprintf (stderr, "removexattr failed: %s\n", strerror (errno)); - result |= ret; - } - - ret = access (filename, R_OK|W_OK); - if (ret < 0) { - fprintf (stderr, "access failed: %s\n", strerror (errno)); - result |= ret; - } - - ret = link (filename, hardlink); - if (ret < 0) { - fprintf (stderr, "link failed: %s\n", strerror(errno)); - result |= ret; - } - unlink(hardlink); - - ret = symlink (filename, symlnk); - if (ret < 0) { - fprintf (stderr, "symlink failed: %s\n", strerror(errno)); - result |= ret; - } - - ret = readlink (symlnk, buf, sizeof(buf)); - if (ret < 0) { - fprintf (stderr, "readlink failed: %s\n", strerror(errno)); - result |= ret; - } - unlink(symlnk); - - /* Create a character special file */ - ret = mknod ("cspecial", S_IFCHR|S_IRWXU|S_IRWXG, makedev(2,3)); - if (ret < 0) { - fprintf (stderr, "cpsecial mknod failed: %s\n", - strerror(errno)); - result |= ret; - } - unlink("cspecial"); - - ret = mknod ("bspecial", S_IFBLK|S_IRWXU|S_IRWXG, makedev(4,5)); - if (ret < 0) { - fprintf (stderr, "bspecial mknod failed: %s\n", - strerror(errno)); - result |= ret; - } - unlink("bspecial"); + int ret = -1; + int fd = 0; + int result = 0; + struct stat stbuf = { + 0, + }; + char newfilename[255] = { + 0, + }; + char *hardlink = "linkfile-hard.txt"; + char *symlnk = "linkfile-soft.txt"; + char buf[1024] = { + 0, + }; + + fd = creat(filename, 0644); + if (fd < 0) { + fprintf(stderr, "creat failed: %s\n", strerror(errno)); + return ret; + } + + ret = truncate(filename, 0); + if (ret < 0) { + fprintf(stderr, "truncate failed: %s\n", strerror(errno)); + result |= ret; + } + + ret = stat(filename, &stbuf); + if (ret < 0) { + fprintf(stderr, "stat failed: %s\n", strerror(errno)); + result |= ret; + } + + ret = chmod(filename, 0640); + if (ret < 0) { + fprintf(stderr, "chmod failed: %s\n", strerror(errno)); + result |= ret; + } + + ret = chown(filename, 10001, 10001); + if (ret < 0) { + fprintf(stderr, "chown failed: %s\n", strerror(errno)); + result |= ret; + } + + ret = setxattr(filename, "trusted.xattr-test", "working", 8, 0); + if (ret < 0) { + fprintf(stderr, "setxattr failed: %s\n", strerror(errno)); + result |= ret; + } + + ret = listxattr(filename, NULL, 0); + if (ret <= 0) { + ret = -1; + fprintf(stderr, "listxattr failed: %s\n", strerror(errno)); + result |= ret; + } + + ret = getxattr(filename, "trusted.xattr-test", NULL, 0); + if (ret <= 0) { + fprintf(stderr, "getxattr failed: %s\n", strerror(errno)); + result |= ret; + } + + ret = removexattr(filename, "trusted.xattr-test"); + if (ret < 0) { + fprintf(stderr, "removexattr failed: %s\n", strerror(errno)); + result |= ret; + } + + ret = access(filename, R_OK | W_OK); + if (ret < 0) { + fprintf(stderr, "access failed: %s\n", strerror(errno)); + result |= ret; + } + + ret = link(filename, hardlink); + if (ret < 0) { + fprintf(stderr, "link failed: %s\n", strerror(errno)); + result |= ret; + } + unlink(hardlink); + + ret = symlink(filename, symlnk); + if (ret < 0) { + fprintf(stderr, "symlink failed: %s\n", strerror(errno)); + result |= ret; + } + + ret = readlink(symlnk, buf, sizeof(buf)); + if (ret < 0) { + fprintf(stderr, "readlink failed: %s\n", strerror(errno)); + result |= ret; + } + unlink(symlnk); + + /* Create a character special file */ + ret = mknod("cspecial", S_IFCHR | S_IRWXU | S_IRWXG, makedev(2, 3)); + if (ret < 0) { + fprintf(stderr, "cpsecial mknod failed: %s\n", strerror(errno)); + result |= ret; + } + unlink("cspecial"); + + ret = mknod("bspecial", S_IFBLK | S_IRWXU | S_IRWXG, makedev(4, 5)); + if (ret < 0) { + fprintf(stderr, "bspecial mknod failed: %s\n", strerror(errno)); + result |= ret; + } + unlink("bspecial"); #ifdef linux - ret = mknod ("fifo", S_IFIFO|S_IRWXU|S_IRWXG, 0); + ret = mknod("fifo", S_IFIFO | S_IRWXU | S_IRWXG, 0); #else - ret = mkfifo ("fifo", 0); + ret = mkfifo("fifo", 0); #endif - if (ret < 0) { - fprintf (stderr, "fifo mknod failed: %s\n", - strerror(errno)); - result |= ret; - } - unlink("fifo"); + if (ret < 0) { + fprintf(stderr, "fifo mknod failed: %s\n", strerror(errno)); + result |= ret; + } + unlink("fifo"); #ifdef linux - ret = mknod ("sock", S_IFSOCK|S_IRWXU|S_IRWXG, 0); - if (ret < 0) { - fprintf (stderr, "sock mknod failed: %s\n", - strerror(errno)); - result |= ret; - } + ret = mknod("sock", S_IFSOCK | S_IRWXU | S_IRWXG, 0); + if (ret < 0) { + fprintf(stderr, "sock mknod failed: %s\n", strerror(errno)); + result |= ret; + } #else - { - int s; - const char *pathname = "sock"; - struct sockaddr_un addr; - - s = socket(PF_LOCAL, SOCK_STREAM, 0); - memset(&addr, 0, sizeof(addr)); - strncpy(addr.sun_path, pathname, sizeof(addr.sun_path)); - ret = bind(s, (const struct sockaddr *)&addr, SUN_LEN(&addr)); - if (ret < 0) { - fprintf (stderr, "fifo mknod failed: %s\n", - strerror(errno)); - result |= ret; - } - close(s); - } -#endif - unlink("sock"); + { + int s; + const char *pathname = "sock"; + struct sockaddr_un addr; - strcpy (newfilename, filename); - strcat(newfilename, "_new"); - ret = rename (filename, newfilename); + s = socket(PF_LOCAL, SOCK_STREAM, 0); + memset(&addr, 0, sizeof(addr)); + strncpy(addr.sun_path, pathname, sizeof(addr.sun_path)); + ret = bind(s, (const struct sockaddr *)&addr, SUN_LEN(&addr)); if (ret < 0) { - fprintf (stderr, "rename failed: %s\n", strerror (errno)); - result |= ret; + fprintf(stderr, "fifo mknod failed: %s\n", strerror(errno)); + result |= ret; } - unlink (newfilename); - - if (fd) - close (fd); - - unlink (filename); - return result; + close(s); + } +#endif + unlink("sock"); + + strcpy(newfilename, filename); + strcat(newfilename, "_new"); + ret = rename(filename, newfilename); + if (ret < 0) { + fprintf(stderr, "rename failed: %s\n", strerror(errno)); + result |= ret; + } + unlink(newfilename); + + if (fd) + close(fd); + + unlink(filename); + return result; } int -dup_fd_based_fops (char *filename) +dup_fd_based_fops(char *filename) { - int fd = 0; - int result = 0; - int newfd = 0; - int ret = -1; - struct stat stbuf = {0,}; - char wstr[50] = {0,}; - char rstr[50] = {0,}; - - fd = open (filename, O_RDWR|O_CREAT, OPEN_MODE); - if (fd < 0) { - fprintf (stderr, "open failed : %s\n", strerror (errno)); - return ret; - } - - newfd = dup (fd); - if (newfd < 0) { - fprintf (stderr, "dup failed: %s\n", strerror (errno)); - result |= ret; - } - - close (fd); - - strcpy (wstr, "This is my string\n"); - ret = write (newfd, wstr, strlen(wstr)); - if (ret <= 0) { - fprintf (stderr, "write failed: %s\n", strerror (errno)); - result |= ret; - } - - ret = lseek (newfd, 0, SEEK_SET); - if (ret < 0) { - fprintf (stderr, "lseek failed: %s\n", strerror (errno)); - result |= ret; - } - - ret = read (newfd, rstr, strlen(wstr)); - if (ret <= 0) { - fprintf (stderr, "read failed: %s\n", strerror (errno)); - result |= ret; - } - - ret = memcmp (rstr, wstr, strlen (wstr)); - if (ret != 0) { - fprintf (stderr, "read returning junk\n"); - result |= ret; - } - - ret = ftruncate (newfd, 0); - if (ret < 0) { - fprintf (stderr, "ftruncate failed : %s\n", strerror (errno)); - result |= ret; - } - - ret = fstat (newfd, &stbuf); - if (ret < 0) { - fprintf (stderr, "fstat failed : %s\n", strerror (errno)); - result |= ret; - } - - ret = fchmod (newfd, 0640); - if (ret < 0) { - fprintf (stderr, "fchmod failed : %s\n", strerror (errno)); - result |= ret; - } - - ret = fchown (newfd, 10001, 10001); - if (ret < 0) { - fprintf (stderr, "fchown failed : %s\n", strerror (errno)); - result |= ret; - } - - ret = fsync (newfd); - if (ret < 0) { - fprintf (stderr, "fsync failed : %s\n", strerror (errno)); - result |= ret; - } - - ret = fsetxattr (newfd, "trusted.xattr-test", "working", 8, 0); - if (ret < 0) { - fprintf (stderr, "fsetxattr failed : %s\n", strerror (errno)); - result |= ret; - } - - ret = fdatasync (newfd); - if (ret < 0) { - fprintf (stderr, "fdatasync failed : %s\n", strerror (errno)); - result |= ret; - } - - ret = flistxattr (newfd, NULL, 0); - if (ret <= 0) { - fprintf (stderr, "flistxattr failed : %s\n", strerror (errno)); - result |= ret; - } - - ret = fgetxattr (newfd, "trusted.xattr-test", NULL, 0); - if (ret <= 0) { - fprintf (stderr, "fgetxattr failed : %s\n", strerror (errno)); - result |= ret; - } - - ret = fremovexattr (newfd, "trusted.xattr-test"); - if (ret < 0) { - fprintf (stderr, "fremovexattr failed : %s\n", strerror (errno)); - result |= ret; - } - - if (newfd) - close (newfd); - ret = unlink (filename); - if (ret < 0) { - fprintf (stderr, "unlink failed : %s\n", strerror (errno)); - result |= ret; - } - return result; + int fd = 0; + int result = 0; + int newfd = 0; + int ret = -1; + struct stat stbuf = { + 0, + }; + char wstr[50] = { + 0, + }; + char rstr[50] = { + 0, + }; + + fd = open(filename, O_RDWR | O_CREAT, OPEN_MODE); + if (fd < 0) { + fprintf(stderr, "open failed : %s\n", strerror(errno)); + return ret; + } + + newfd = dup(fd); + if (newfd < 0) { + fprintf(stderr, "dup failed: %s\n", strerror(errno)); + result |= ret; + } + + close(fd); + + strcpy(wstr, "This is my string\n"); + ret = write(newfd, wstr, strlen(wstr)); + if (ret <= 0) { + fprintf(stderr, "write failed: %s\n", strerror(errno)); + result |= ret; + } + + ret = lseek(newfd, 0, SEEK_SET); + if (ret < 0) { + fprintf(stderr, "lseek failed: %s\n", strerror(errno)); + result |= ret; + } + + ret = read(newfd, rstr, strlen(wstr)); + if (ret <= 0) { + fprintf(stderr, "read failed: %s\n", strerror(errno)); + result |= ret; + } + + ret = memcmp(rstr, wstr, strlen(wstr)); + if (ret != 0) { + fprintf(stderr, "read returning junk\n"); + result |= ret; + } + + ret = ftruncate(newfd, 0); + if (ret < 0) { + fprintf(stderr, "ftruncate failed : %s\n", strerror(errno)); + result |= ret; + } + + ret = fstat(newfd, &stbuf); + if (ret < 0) { + fprintf(stderr, "fstat failed : %s\n", strerror(errno)); + result |= ret; + } + + ret = fchmod(newfd, 0640); + if (ret < 0) { + fprintf(stderr, "fchmod failed : %s\n", strerror(errno)); + result |= ret; + } + + ret = fchown(newfd, 10001, 10001); + if (ret < 0) { + fprintf(stderr, "fchown failed : %s\n", strerror(errno)); + result |= ret; + } + + ret = fsync(newfd); + if (ret < 0) { + fprintf(stderr, "fsync failed : %s\n", strerror(errno)); + result |= ret; + } + + ret = fsetxattr(newfd, "trusted.xattr-test", "working", 8, 0); + if (ret < 0) { + fprintf(stderr, "fsetxattr failed : %s\n", strerror(errno)); + result |= ret; + } + + ret = fdatasync(newfd); + if (ret < 0) { + fprintf(stderr, "fdatasync failed : %s\n", strerror(errno)); + result |= ret; + } + + ret = flistxattr(newfd, NULL, 0); + if (ret <= 0) { + fprintf(stderr, "flistxattr failed : %s\n", strerror(errno)); + result |= ret; + } + + ret = fgetxattr(newfd, "trusted.xattr-test", NULL, 0); + if (ret <= 0) { + fprintf(stderr, "fgetxattr failed : %s\n", strerror(errno)); + result |= ret; + } + + ret = fremovexattr(newfd, "trusted.xattr-test"); + if (ret < 0) { + fprintf(stderr, "fremovexattr failed : %s\n", strerror(errno)); + result |= ret; + } + + if (newfd) + close(newfd); + ret = unlink(filename); + if (ret < 0) { + fprintf(stderr, "unlink failed : %s\n", strerror(errno)); + result |= ret; + } + return result; } int -dir_based_fops (char *dirname) +dir_based_fops(char *dirname) { - int ret = -1; - int result = 0; - DIR *dp = NULL; - char buff[255] = {0,}; - struct dirent *dbuff = {0,}; - struct stat stbuff = {0,}; - char newdname[255] = {0,}; - char *cwd = NULL; - - ret = mkdir (dirname, 0755); - if (ret < 0) { - fprintf (stderr, "mkdir failed: %s\n", strerror (errno)); - return ret; - } - - dp = opendir (dirname); - if (dp == NULL) { - fprintf (stderr, "opendir failed: %s\n", strerror (errno)); - result |= ret; - } - - dbuff = readdir (dp); - if (NULL == dbuff) { - fprintf (stderr, "readdir failed: %s\n", strerror (errno)); - result |= ret; - } - - ret = closedir (dp); - if (ret < 0) { - fprintf (stderr, "closedir failed: %s\n", strerror (errno)); - result |= ret; - } - - ret = stat (dirname, &stbuff); - if (ret < 0) { - fprintf (stderr, "stat failed: %s\n", strerror (errno)); - result |= ret; - } - - ret = chmod (dirname, 0744); - if (ret < 0) { - fprintf (stderr, "chmod failed: %s\n", strerror (errno)); - result |= ret; - } - - ret = chown (dirname, 10001, 10001); - if (ret < 0) { - fprintf (stderr, "chmod failed: %s\n", strerror (errno)); - result |= ret; - } - - ret = setxattr (dirname, "trusted.xattr-test", "working", 8, 0); - if (ret < 0) { - fprintf (stderr, "setxattr failed: %s\n", strerror (errno)); - result |= ret; - } - - ret = listxattr (dirname, NULL, 0); - if (ret <= 0) { - ret = -1; - fprintf (stderr, "listxattr failed: %s\n", strerror (errno)); - result |= ret; - } - - ret = getxattr (dirname, "trusted.xattr-test", NULL, 0); - if (ret <= 0) { - ret = -1; - fprintf (stderr, "getxattr failed: %s\n", strerror (errno)); - result |= ret; - } - - ret = removexattr (dirname, "trusted.xattr-test"); - if (ret < 0) { - fprintf (stderr, "removexattr failed: %s\n", strerror (errno)); - result |= ret; - } - - strcpy (newdname, dirname); - strcat (newdname, "/../"); - ret = chdir (newdname); - if (ret < 0) { - fprintf (stderr, "chdir failed: %s\n", strerror (errno)); - result |= ret; - } - - cwd = getcwd (buff, 255); - if (NULL == cwd) { - fprintf (stderr, "getcwd failed: %s\n", strerror (errno)); - result |= ret; - } - - strcpy (newdname, dirname); - strcat (newdname, "new"); - ret = rename (dirname, newdname); - if (ret < 0) { - fprintf (stderr, "rename failed: %s\n", strerror (errno)); - result |= ret; - } - - ret = rmdir (newdname); - if (ret < 0) { - fprintf (stderr, "rmdir failed: %s\n", strerror (errno)); - result |= ret; - } - - rmdir (dirname); - return result; + int ret = -1; + int result = 0; + DIR *dp = NULL; + char buff[255] = { + 0, + }; + struct dirent *dbuff = { + 0, + }; + struct stat stbuff = { + 0, + }; + char newdname[255] = { + 0, + }; + char *cwd = NULL; + + ret = mkdir(dirname, 0755); + if (ret < 0) { + fprintf(stderr, "mkdir failed: %s\n", strerror(errno)); + return ret; + } + + dp = opendir(dirname); + if (dp == NULL) { + fprintf(stderr, "opendir failed: %s\n", strerror(errno)); + result |= ret; + } + + dbuff = readdir(dp); + if (NULL == dbuff) { + fprintf(stderr, "readdir failed: %s\n", strerror(errno)); + result |= ret; + } + + ret = closedir(dp); + if (ret < 0) { + fprintf(stderr, "closedir failed: %s\n", strerror(errno)); + result |= ret; + } + + ret = stat(dirname, &stbuff); + if (ret < 0) { + fprintf(stderr, "stat failed: %s\n", strerror(errno)); + result |= ret; + } + + ret = chmod(dirname, 0744); + if (ret < 0) { + fprintf(stderr, "chmod failed: %s\n", strerror(errno)); + result |= ret; + } + + ret = chown(dirname, 10001, 10001); + if (ret < 0) { + fprintf(stderr, "chmod failed: %s\n", strerror(errno)); + result |= ret; + } + + ret = setxattr(dirname, "trusted.xattr-test", "working", 8, 0); + if (ret < 0) { + fprintf(stderr, "setxattr failed: %s\n", strerror(errno)); + result |= ret; + } + + ret = listxattr(dirname, NULL, 0); + if (ret <= 0) { + ret = -1; + fprintf(stderr, "listxattr failed: %s\n", strerror(errno)); + result |= ret; + } + + ret = getxattr(dirname, "trusted.xattr-test", NULL, 0); + if (ret <= 0) { + ret = -1; + fprintf(stderr, "getxattr failed: %s\n", strerror(errno)); + result |= ret; + } + + ret = removexattr(dirname, "trusted.xattr-test"); + if (ret < 0) { + fprintf(stderr, "removexattr failed: %s\n", strerror(errno)); + result |= ret; + } + + strcpy(newdname, dirname); + strcat(newdname, "/../"); + ret = chdir(newdname); + if (ret < 0) { + fprintf(stderr, "chdir failed: %s\n", strerror(errno)); + result |= ret; + } + + cwd = getcwd(buff, 255); + if (NULL == cwd) { + fprintf(stderr, "getcwd failed: %s\n", strerror(errno)); + result |= ret; + } + + strcpy(newdname, dirname); + strcat(newdname, "new"); + ret = rename(dirname, newdname); + if (ret < 0) { + fprintf(stderr, "rename failed: %s\n", strerror(errno)); + result |= ret; + } + + ret = rmdir(newdname); + if (ret < 0) { + fprintf(stderr, "rmdir failed: %s\n", strerror(errno)); + result |= ret; + } + + rmdir(dirname); + return result; } int -link_based_fops (char *filename) +link_based_fops(char *filename) { - int ret = -1; - int result = 0; - int fd = 0; - char newname[255] = {0,}; - char linkname[255] = {0,}; - struct stat lstbuf = {0,}; - - fd = creat (filename, 0644); - if (fd < 0) { - fd = 0; - fprintf (stderr, "creat failed: %s\n", strerror (errno)); - return ret; - } - - strcpy (newname, filename); - strcat (newname, "_hlink"); - ret = link (filename, newname); - if (ret < 0) { - fprintf (stderr, "link failed: %s\n", strerror (errno)); - result |= ret; - } - - ret = unlink (filename); - if (ret < 0) { - fprintf (stderr, "unlink failed: %s\n", strerror (errno)); - result |= ret; - } - - strcpy (linkname, filename); - strcat (linkname, "_slink"); - ret = symlink (newname, linkname); - if (ret < 0) { - fprintf (stderr, "symlink failed: %s\n", strerror (errno)); - result |= ret; - } - - ret = lstat (linkname, &lstbuf); - if (ret < 0) { - fprintf (stderr, "lstbuf failed: %s\n", strerror (errno)); - result |= ret; - } - - ret = lchown (linkname, 10001, 10001); - if (ret < 0) { - fprintf (stderr, "lchown failed: %s\n", strerror (errno)); - result |= ret; - } - - ret = lsetxattr (linkname, "trusted.lxattr-test", "working", 8, 0); - if (ret < 0) { - fprintf (stderr, "lsetxattr failed: %s\n", strerror (errno)); - result |= ret; - } - - ret = llistxattr (linkname, NULL, 0); - if (ret < 0) { - ret = -1; - fprintf (stderr, "llistxattr failed: %s\n", strerror (errno)); - result |= ret; - } - - ret = lgetxattr (linkname, "trusted.lxattr-test", NULL, 0); - if (ret < 0) { - ret = -1; - fprintf (stderr, "lgetxattr failed: %s\n", strerror (errno)); - result |= ret; - } - - ret = lremovexattr (linkname, "trusted.lxattr-test"); - if (ret < 0) { - fprintf (stderr, "lremovexattr failed: %s\n", strerror (errno)); - result |= ret; - } - - if (fd) - close(fd); - unlink (linkname); - unlink (newname); - return result; + int ret = -1; + int result = 0; + int fd = 0; + char newname[255] = { + 0, + }; + char linkname[255] = { + 0, + }; + struct stat lstbuf = { + 0, + }; + + fd = creat(filename, 0644); + if (fd < 0) { + fd = 0; + fprintf(stderr, "creat failed: %s\n", strerror(errno)); + return ret; + } + + strcpy(newname, filename); + strcat(newname, "_hlink"); + ret = link(filename, newname); + if (ret < 0) { + fprintf(stderr, "link failed: %s\n", strerror(errno)); + result |= ret; + } + + ret = unlink(filename); + if (ret < 0) { + fprintf(stderr, "unlink failed: %s\n", strerror(errno)); + result |= ret; + } + + strcpy(linkname, filename); + strcat(linkname, "_slink"); + ret = symlink(newname, linkname); + if (ret < 0) { + fprintf(stderr, "symlink failed: %s\n", strerror(errno)); + result |= ret; + } + + ret = lstat(linkname, &lstbuf); + if (ret < 0) { + fprintf(stderr, "lstbuf failed: %s\n", strerror(errno)); + result |= ret; + } + + ret = lchown(linkname, 10001, 10001); + if (ret < 0) { + fprintf(stderr, "lchown failed: %s\n", strerror(errno)); + result |= ret; + } + + ret = lsetxattr(linkname, "trusted.lxattr-test", "working", 8, 0); + if (ret < 0) { + fprintf(stderr, "lsetxattr failed: %s\n", strerror(errno)); + result |= ret; + } + + ret = llistxattr(linkname, NULL, 0); + if (ret < 0) { + ret = -1; + fprintf(stderr, "llistxattr failed: %s\n", strerror(errno)); + result |= ret; + } + + ret = lgetxattr(linkname, "trusted.lxattr-test", NULL, 0); + if (ret < 0) { + ret = -1; + fprintf(stderr, "lgetxattr failed: %s\n", strerror(errno)); + result |= ret; + } + + ret = lremovexattr(linkname, "trusted.lxattr-test"); + if (ret < 0) { + fprintf(stderr, "lremovexattr failed: %s\n", strerror(errno)); + result |= ret; + } + + if (fd) + close(fd); + unlink(linkname); + unlink(newname); + return result; } int -test_open_modes (char *filename) +test_open_modes(char *filename) { - int ret = -1; - int result = 0; - - ret = generic_open_read_write (filename, O_CREAT|O_WRONLY, OPEN_MODE); - if (ret != 0) { - fprintf (stderr, "flag O_CREAT|O_WRONLY failed: \n"); - result |= ret; - } - - ret = generic_open_read_write (filename, O_CREAT|O_RDWR, OPEN_MODE); - if (ret != 0) { - fprintf (stderr, "flag O_CREAT|O_RDWR failed\n"); - result |= ret; - } - - ret = generic_open_read_write (filename, O_CREAT|O_RDONLY, OPEN_MODE); - if (ret != 0) { - fprintf (stderr, "flag O_CREAT|O_RDONLY failed\n"); - result |= ret; - } - - ret = creat (filename, 0644); - close (ret); - ret = generic_open_read_write (filename, O_WRONLY, 0); - if (ret != 0) { - fprintf (stderr, "flag O_WRONLY failed\n"); - result |= ret; - } - - ret = creat (filename, 0644); - close (ret); - ret = generic_open_read_write (filename, O_RDWR, 0); - if (0 != ret) { - fprintf (stderr, "flag O_RDWR failed\n"); - result |= ret; - } - - ret = creat (filename, 0644); - close (ret); - ret = generic_open_read_write (filename, O_RDONLY, 0); - if (0 != ret) { - fprintf (stderr, "flag O_RDONLY failed\n"); - result |= ret; - } - - ret = creat (filename, 0644); - close (ret); - ret = generic_open_read_write (filename, O_TRUNC|O_WRONLY, 0); - if (0 != ret) { - fprintf (stderr, "flag O_TRUNC|O_WRONLY failed\n"); - result |= ret; - } + int ret = -1; + int result = 0; + + ret = generic_open_read_write(filename, O_CREAT | O_WRONLY, OPEN_MODE); + if (ret != 0) { + fprintf(stderr, "flag O_CREAT|O_WRONLY failed: \n"); + result |= ret; + } + + ret = generic_open_read_write(filename, O_CREAT | O_RDWR, OPEN_MODE); + if (ret != 0) { + fprintf(stderr, "flag O_CREAT|O_RDWR failed\n"); + result |= ret; + } + + ret = generic_open_read_write(filename, O_CREAT | O_RDONLY, OPEN_MODE); + if (ret != 0) { + fprintf(stderr, "flag O_CREAT|O_RDONLY failed\n"); + result |= ret; + } + + ret = creat(filename, 0644); + close(ret); + ret = generic_open_read_write(filename, O_WRONLY, 0); + if (ret != 0) { + fprintf(stderr, "flag O_WRONLY failed\n"); + result |= ret; + } + + ret = creat(filename, 0644); + close(ret); + ret = generic_open_read_write(filename, O_RDWR, 0); + if (0 != ret) { + fprintf(stderr, "flag O_RDWR failed\n"); + result |= ret; + } + + ret = creat(filename, 0644); + close(ret); + ret = generic_open_read_write(filename, O_RDONLY, 0); + if (0 != ret) { + fprintf(stderr, "flag O_RDONLY failed\n"); + result |= ret; + } + + ret = creat(filename, 0644); + close(ret); + ret = generic_open_read_write(filename, O_TRUNC | O_WRONLY, 0); + if (0 != ret) { + fprintf(stderr, "flag O_TRUNC|O_WRONLY failed\n"); + result |= ret; + } #if 0 /* undefined behaviour, unable to reliably test */ ret = creat (filename, 0644); @@ -897,87 +943,90 @@ test_open_modes (char *filename) } #endif - ret = generic_open_read_write (filename, O_CREAT|O_RDWR|O_SYNC, - OPEN_MODE); - if (0 != ret) { - fprintf (stderr, "flag O_CREAT|O_RDWR|O_SYNC failed\n"); - result |= ret; - } - - ret = creat (filename, 0644); - close (ret); - ret = generic_open_read_write (filename, O_CREAT|O_EXCL, OPEN_MODE); - if (0 != ret) { - fprintf (stderr, "flag O_CREAT|O_EXCL failed\n"); - result |= ret; - } - - return result; + ret = generic_open_read_write(filename, O_CREAT | O_RDWR | O_SYNC, + OPEN_MODE); + if (0 != ret) { + fprintf(stderr, "flag O_CREAT|O_RDWR|O_SYNC failed\n"); + result |= ret; + } + + ret = creat(filename, 0644); + close(ret); + ret = generic_open_read_write(filename, O_CREAT | O_EXCL, OPEN_MODE); + if (0 != ret) { + fprintf(stderr, "flag O_CREAT|O_EXCL failed\n"); + result |= ret; + } + + return result; } int -generic_open_read_write (char *filename, int flag, mode_t mode) +generic_open_read_write(char *filename, int flag, mode_t mode) { - int fd = 0; - int ret = -1; - char wstring[50] = {0,}; - char rstring[50] = {0,}; - - fd = open (filename, flag, mode); - if (fd < 0) { - if (flag == (O_CREAT|O_EXCL) && errno == EEXIST) { - unlink (filename); - return 0; - } - else { - fprintf (stderr, "open failed: %s\n", strerror (errno)); - return -1; - } - } - - strcpy (wstring, "My string to write\n"); - ret = write (fd, wstring, strlen(wstring)); - if (ret <= 0) { - if (errno != EBADF) { - fprintf (stderr, "write failed: %s\n", strerror (errno)); - close (fd); - unlink(filename); - return ret; - } - } - - ret = lseek (fd, 0, SEEK_SET); - if (ret < 0) { - close (fd); - unlink(filename); - return ret; - } - - ret = read (fd, rstring, strlen(wstring)); - if (ret < 0 && flag != (O_CREAT|O_WRONLY) && flag != O_WRONLY && \ - flag != (O_TRUNC|O_WRONLY)) { - close (fd); - unlink (filename); - return ret; - } - - /* Compare the rstring with wstring. But we do not want to return - * error when the flag is either O_RDONLY, O_CREAT|O_RDONLY or - * O_TRUNC|O_RDONLY. Because in that case we are not writing - * anything to the file.*/ - - ret = memcmp (wstring, rstring, strlen (wstring)); - if (0 != ret && flag != (O_TRUNC|O_WRONLY) && flag != O_WRONLY && \ - flag != (O_CREAT|O_WRONLY) && !(flag == \ - (O_CREAT|O_RDONLY) || flag == O_RDONLY \ - || flag == (O_TRUNC|O_RDONLY))) { - fprintf (stderr, "read is returning junk\n"); - close (fd); - unlink (filename); - return ret; - } - - close (fd); - unlink (filename); - return 0; + int fd = 0; + int ret = -1; + char wstring[50] = { + 0, + }; + char rstring[50] = { + 0, + }; + + fd = open(filename, flag, mode); + if (fd < 0) { + if (flag == (O_CREAT | O_EXCL) && errno == EEXIST) { + unlink(filename); + return 0; + } else { + fprintf(stderr, "open failed: %s\n", strerror(errno)); + return -1; + } + } + + strcpy(wstring, "My string to write\n"); + ret = write(fd, wstring, strlen(wstring)); + if (ret <= 0) { + if (errno != EBADF) { + fprintf(stderr, "write failed: %s\n", strerror(errno)); + close(fd); + unlink(filename); + return ret; + } + } + + ret = lseek(fd, 0, SEEK_SET); + if (ret < 0) { + close(fd); + unlink(filename); + return ret; + } + + ret = read(fd, rstring, strlen(wstring)); + if (ret < 0 && flag != (O_CREAT | O_WRONLY) && flag != O_WRONLY && + flag != (O_TRUNC | O_WRONLY)) { + close(fd); + unlink(filename); + return ret; + } + + /* Compare the rstring with wstring. But we do not want to return + * error when the flag is either O_RDONLY, O_CREAT|O_RDONLY or + * O_TRUNC|O_RDONLY. Because in that case we are not writing + * anything to the file.*/ + + ret = memcmp(wstring, rstring, strlen(wstring)); + if (0 != ret && flag != (O_TRUNC | O_WRONLY) && flag != O_WRONLY && + flag != (O_CREAT | O_WRONLY) && + !(flag == (O_CREAT | O_RDONLY) || flag == O_RDONLY || + flag == (O_TRUNC | O_RDONLY))) { + fprintf(stderr, "read is returning junk\n"); + close(fd); + unlink(filename); + return ret; + } + + close(fd); + unlink(filename); + return 0; } diff --git a/tests/basic/fuse/seek.c b/tests/basic/fuse/seek.c index e4db41c03d7..30943ad0f33 100644 --- a/tests/basic/fuse/seek.c +++ b/tests/basic/fuse/seek.c @@ -17,64 +17,66 @@ #include <unistd.h> int -main (int argc, char **argv) +main(int argc, char **argv) { - int ret = EXIT_SUCCESS; - int fd = -1; - char *filename = NULL; - struct stat st = { 0, }; - off_t hole_start = 0; - off_t hole_end = 0; + int ret = EXIT_SUCCESS; + int fd = -1; + char *filename = NULL; + struct stat st = { + 0, + }; + off_t hole_start = 0; + off_t hole_end = 0; - if (argc != 2) { - fprintf (stderr, "Invalid argument, use %s <file>\n", argv[0]); - return EXIT_FAILURE; - } - - filename = argv[1]; + if (argc != 2) { + fprintf(stderr, "Invalid argument, use %s <file>\n", argv[0]); + return EXIT_FAILURE; + } - fd = open (filename, O_RDONLY); - if (fd <= 0) { - perror ("open"); - return EXIT_FAILURE; - } + filename = argv[1]; - if (fstat (fd, &st)) { - perror ("fstat"); - return EXIT_FAILURE; - } + fd = open(filename, O_RDONLY); + if (fd <= 0) { + perror("open"); + return EXIT_FAILURE; + } - while (hole_end < st.st_size) { - hole_start = lseek (fd, hole_end, SEEK_HOLE); - if (hole_start == -1 && errno == ENXIO) { - /* no more holes */ - break; - } else if (hole_start == -1 && errno == ENOTSUP) { - /* SEEK_HOLE is not supported */ - perror ("lseek(SEEK_HOLE)"); - ret = EXIT_FAILURE; - break; - } else if (hole_start == -1) { - perror ("no more holes"); - break; - } + if (fstat(fd, &st)) { + perror("fstat"); + return EXIT_FAILURE; + } - hole_end = lseek (fd, hole_start, SEEK_DATA); - if (hole_end == -1 && errno == ENXIO) { - /* no more data */ - break; - } else if (hole_end == -1 && errno == ENOTSUP) { - /* SEEK_DATA is not supported */ - perror ("lseek(SEEK_DATA)"); - ret = EXIT_FAILURE; - break; - } + while (hole_end < st.st_size) { + hole_start = lseek(fd, hole_end, SEEK_HOLE); + if (hole_start == -1 && errno == ENXIO) { + /* no more holes */ + break; + } else if (hole_start == -1 && errno == ENOTSUP) { + /* SEEK_HOLE is not supported */ + perror("lseek(SEEK_HOLE)"); + ret = EXIT_FAILURE; + break; + } else if (hole_start == -1) { + perror("no more holes"); + break; + } - printf ("HOLE found: %ld - %ld%s\n", hole_start, hole_end, - (hole_end == st.st_size) ? " (EOF)" : ""); + hole_end = lseek(fd, hole_start, SEEK_DATA); + if (hole_end == -1 && errno == ENXIO) { + /* no more data */ + break; + } else if (hole_end == -1 && errno == ENOTSUP) { + /* SEEK_DATA is not supported */ + perror("lseek(SEEK_DATA)"); + ret = EXIT_FAILURE; + break; } - close (fd); + printf("HOLE found: %ld - %ld%s\n", hole_start, hole_end, + (hole_end == st.st_size) ? " (EOF)" : ""); + } + + close(fd); - return ret; + return ret; } diff --git a/tests/basic/gfapi/anonymous_fd_read_write.c b/tests/basic/gfapi/anonymous_fd_read_write.c index 6945dd634f0..fc276ca4310 100644 --- a/tests/basic/gfapi/anonymous_fd_read_write.c +++ b/tests/basic/gfapi/anonymous_fd_read_write.c @@ -9,95 +9,98 @@ #include <glusterfs/api/glfs.h> #include <glusterfs/api/glfs-handles.h> -#define LOG_ERR(func, ret) do { \ - if (ret != 0) { \ - fprintf (stderr, "%s : returned error %d (%s)\n", \ - func, ret, strerror (errno)); \ - goto out; \ - } else { \ - fprintf (stderr, "%s : returned %d\n", func, ret); \ - } \ - } while (0) +#define LOG_ERR(func, ret) \ + do { \ + if (ret != 0) { \ + fprintf(stderr, "%s : returned error %d (%s)\n", func, ret, \ + strerror(errno)); \ + goto out; \ + } else { \ + fprintf(stderr, "%s : returned %d\n", func, ret); \ + } \ + } while (0) int -main (int argc, char *argv[]) +main(int argc, char *argv[]) { - int ret = 0; - glfs_t *fs = NULL; - struct glfs_object *root = NULL, *file_obj = NULL; - struct stat sb = {0, }; - char readbuf[32], writebuf[32]; - char *filename = "file.txt"; - char *logfile = NULL; - char *volname = NULL; - char *hostname = NULL; - - if (argc != 4) { - fprintf (stderr, "Invalid argument\n"); - exit(1); - } - - hostname = argv[1]; - volname = argv[2]; - logfile = argv[3]; - - fs = glfs_new (volname); - if (!fs) { - fprintf (stderr, "glfs_new: returned NULL\n"); - ret = -1; - } - - ret = glfs_set_volfile_server (fs, "tcp", hostname, 24007); - LOG_ERR("glfs_set_volfile_server", ret); - - ret = glfs_set_logging (fs, logfile, 7); - LOG_ERR("glfs_set_logging", ret); - - ret = glfs_init (fs); - LOG_ERR("glfs_init", ret); - - root = glfs_h_lookupat (fs, NULL, "/", &sb, 0); - if (root == NULL) { - fprintf (stderr, "glfs_h_lookupat: error on lookup of / ,%s\n", - strerror (errno)); - goto out; - } - - file_obj = glfs_h_creat (fs, root, filename, O_CREAT, 0644, &sb); - if (file_obj == NULL) { - fprintf (stderr, "glfs_h_creat: error on create of %s: from (%p),%s\n", - filename, root, strerror (errno)); - goto out; - } - - /* test read/write based on anonymous fd */ - memcpy (writebuf, "abcdefghijklmnopqrstuvwxyz012345", 32); - - ret = glfs_h_anonymous_write (fs, file_obj, writebuf, 32, 0); - if (ret < 0) - LOG_ERR ("glfs_h_anonymous_write", ret); - - ret = glfs_h_anonymous_read (fs, file_obj, readbuf, 32, 0); - if (ret < 0) - LOG_ERR ("glfs_h_anonymous_read", ret); - - if (memcmp (readbuf, writebuf, 32)) { - fprintf (stderr, "Failed to read what I wrote: %s %s\n", readbuf, - writebuf); - ret = -1; - goto out; - } - - ret = 0; + int ret = 0; + glfs_t *fs = NULL; + struct glfs_object *root = NULL, *file_obj = NULL; + struct stat sb = { + 0, + }; + char readbuf[32], writebuf[32]; + char *filename = "file.txt"; + char *logfile = NULL; + char *volname = NULL; + char *hostname = NULL; + + if (argc != 4) { + fprintf(stderr, "Invalid argument\n"); + exit(1); + } + + hostname = argv[1]; + volname = argv[2]; + logfile = argv[3]; + + fs = glfs_new(volname); + if (!fs) { + fprintf(stderr, "glfs_new: returned NULL\n"); + ret = -1; + } + + ret = glfs_set_volfile_server(fs, "tcp", hostname, 24007); + LOG_ERR("glfs_set_volfile_server", ret); + + ret = glfs_set_logging(fs, logfile, 7); + LOG_ERR("glfs_set_logging", ret); + + ret = glfs_init(fs); + LOG_ERR("glfs_init", ret); + + root = glfs_h_lookupat(fs, NULL, "/", &sb, 0); + if (root == NULL) { + fprintf(stderr, "glfs_h_lookupat: error on lookup of / ,%s\n", + strerror(errno)); + goto out; + } + + file_obj = glfs_h_creat(fs, root, filename, O_CREAT, 0644, &sb); + if (file_obj == NULL) { + fprintf(stderr, "glfs_h_creat: error on create of %s: from (%p),%s\n", + filename, root, strerror(errno)); + goto out; + } + + /* test read/write based on anonymous fd */ + memcpy(writebuf, "abcdefghijklmnopqrstuvwxyz012345", 32); + + ret = glfs_h_anonymous_write(fs, file_obj, writebuf, 32, 0); + if (ret < 0) + LOG_ERR("glfs_h_anonymous_write", ret); + + ret = glfs_h_anonymous_read(fs, file_obj, readbuf, 32, 0); + if (ret < 0) + LOG_ERR("glfs_h_anonymous_read", ret); + + if (memcmp(readbuf, writebuf, 32)) { + fprintf(stderr, "Failed to read what I wrote: %s %s\n", readbuf, + writebuf); + ret = -1; + goto out; + } + + ret = 0; out: - if (file_obj) - glfs_h_close (file_obj); - - if (fs) { - ret = glfs_fini(fs); - fprintf (stderr, "glfs_fini(fs) returned %d \n", ret); - } - if (ret) - exit(1); - exit(0); + if (file_obj) + glfs_h_close(file_obj); + + if (fs) { + ret = glfs_fini(fs); + fprintf(stderr, "glfs_fini(fs) returned %d \n", ret); + } + if (ret) + exit(1); + exit(0); } diff --git a/tests/basic/gfapi/bug-1241104.c b/tests/basic/gfapi/bug-1241104.c index 311323f672a..78c87595a71 100644 --- a/tests/basic/gfapi/bug-1241104.c +++ b/tests/basic/gfapi/bug-1241104.c @@ -12,81 +12,82 @@ int gfapi = 1; -#define LOG_ERR(func, ret) do { \ - if (ret != 0) { \ - fprintf (stderr, "%s : returned error %d (%s)\n", \ - func, ret, strerror (errno)); \ - goto out; \ - } else { \ - fprintf (stderr, "%s : returned %d\n", func, ret); \ - } \ - } while (0) +#define LOG_ERR(func, ret) \ + do { \ + if (ret != 0) { \ + fprintf(stderr, "%s : returned error %d (%s)\n", func, ret, \ + strerror(errno)); \ + goto out; \ + } else { \ + fprintf(stderr, "%s : returned %d\n", func, ret); \ + } \ + } while (0) int -main (int argc, char *argv[]) +main(int argc, char *argv[]) { - glfs_t *fs = NULL; - int ret = 0, i, status = 0; - glfs_fd_t *fd = NULL; - char *filename = "file_tmp"; - char *volname = NULL; - char *logfile = NULL; - char *hostname = NULL; - struct flock lock = {0, }; - - if (argc != 4) { - fprintf (stderr, "Invalid argument\n"); - exit(1); - } - - hostname = argv[1]; - volname = argv[2]; - logfile = argv[3]; - - fs = glfs_new (volname); - if (!fs) { - fprintf (stderr, "glfs_new: returned NULL\n"); - return -1; - } - - ret = glfs_set_volfile_server (fs, "tcp", hostname, 24007); - LOG_ERR("glfs_set_volfile_server", ret); - - ret = glfs_set_logging (fs, logfile, 7); - LOG_ERR("glfs_set_logging", ret); - - ret = glfs_init (fs); - LOG_ERR("glfs_init", ret); - - fd = glfs_creat(fs, filename, O_RDWR|O_SYNC, 0644); - if (fd <= 0) { - ret = -1; - LOG_ERR ("glfs_creat", ret); - } - fprintf (stderr, "glfs-create fd - %d\n", fd); - - /* validate locks for negative range */ - lock.l_type = F_WRLCK; - lock.l_whence = SEEK_SET; - lock.l_start = 10; - lock.l_len = -9; - - ret = glfs_posix_lock (fd, F_SETLK, &lock); - LOG_ERR ("glfs_posix_lock", ret); + glfs_t *fs = NULL; + int ret = 0, i, status = 0; + glfs_fd_t *fd = NULL; + char *filename = "file_tmp"; + char *volname = NULL; + char *logfile = NULL; + char *hostname = NULL; + struct flock lock = { + 0, + }; + + if (argc != 4) { + fprintf(stderr, "Invalid argument\n"); + exit(1); + } + + hostname = argv[1]; + volname = argv[2]; + logfile = argv[3]; + + fs = glfs_new(volname); + if (!fs) { + fprintf(stderr, "glfs_new: returned NULL\n"); + return -1; + } + + ret = glfs_set_volfile_server(fs, "tcp", hostname, 24007); + LOG_ERR("glfs_set_volfile_server", ret); + + ret = glfs_set_logging(fs, logfile, 7); + LOG_ERR("glfs_set_logging", ret); + + ret = glfs_init(fs); + LOG_ERR("glfs_init", ret); + + fd = glfs_creat(fs, filename, O_RDWR | O_SYNC, 0644); + if (fd <= 0) { + ret = -1; + LOG_ERR("glfs_creat", ret); + } + fprintf(stderr, "glfs-create fd - %d\n", fd); + + /* validate locks for negative range */ + lock.l_type = F_WRLCK; + lock.l_whence = SEEK_SET; + lock.l_start = 10; + lock.l_len = -9; + + ret = glfs_posix_lock(fd, F_SETLK, &lock); + LOG_ERR("glfs_posix_lock", ret); err: - glfs_close(fd); - LOG_ERR ("glfs_close", ret); + glfs_close(fd); + LOG_ERR("glfs_close", ret); out: - if (fs) { - ret = glfs_fini(fs); - fprintf (stderr, "glfs_fini(fs) returned %d \n", ret); - } - - if (ret) - exit(1); - exit(0); + if (fs) { + ret = glfs_fini(fs); + fprintf(stderr, "glfs_fini(fs) returned %d \n", ret); + } + + if (ret) + exit(1); + exit(0); } - - diff --git a/tests/basic/gfapi/bug1283983.c b/tests/basic/gfapi/bug1283983.c index 3334b290d9e..b920013d0e0 100644 --- a/tests/basic/gfapi/bug1283983.c +++ b/tests/basic/gfapi/bug1283983.c @@ -10,114 +10,113 @@ #include <glusterfs/api/glfs-handles.h> int gfapi = 1; -#define LOG_ERR(func, ret) do { \ - if (ret != 0) { \ - fprintf (stderr, "%s : returned error ret(%d), errno(%d)\n", \ - func, ret, errno); \ - exit(1); \ - } else { \ - fprintf (stderr, "%s : returned %d\n", func, ret); \ - } \ - } while (0) -#define LOG_IF_NO_ERR(func, ret) do { \ - if (ret == 0) { \ - fprintf (stderr, "%s : hasn't returned error %d\n", \ - func, ret); \ - exit(1); \ - } else { \ - fprintf (stderr, "%s : returned %d\n", func, ret); \ - } \ - } while (0) +#define LOG_ERR(func, ret) \ + do { \ + if (ret != 0) { \ + fprintf(stderr, "%s : returned error ret(%d), errno(%d)\n", func, \ + ret, errno); \ + exit(1); \ + } else { \ + fprintf(stderr, "%s : returned %d\n", func, ret); \ + } \ + } while (0) +#define LOG_IF_NO_ERR(func, ret) \ + do { \ + if (ret == 0) { \ + fprintf(stderr, "%s : hasn't returned error %d\n", func, ret); \ + exit(1); \ + } else { \ + fprintf(stderr, "%s : returned %d\n", func, ret); \ + } \ + } while (0) int -main (int argc, char *argv[]) +main(int argc, char *argv[]) { - glfs_t *fs = NULL; - int ret = 0, i; - glfs_fd_t *fd = NULL; - char *filename = "/a1"; - char *filename2 = "/a2"; - struct stat sb = {0, }; - struct glfs_upcall *cbk = NULL; - char *logfile = NULL; - char *volname = NULL; - int cnt = 1; - struct glfs_upcall_inode *in_arg = NULL; - struct glfs_object *root = NULL, *leaf = NULL; - - fprintf (stderr, "Starting libgfapi_fini\n"); - if (argc != 4) { - fprintf (stderr, "Invalid argument\n"); - exit(1); + glfs_t *fs = NULL; + int ret = 0, i; + glfs_fd_t *fd = NULL; + char *filename = "/a1"; + char *filename2 = "/a2"; + struct stat sb = { + 0, + }; + struct glfs_upcall *cbk = NULL; + char *logfile = NULL; + char *volname = NULL; + int cnt = 1; + struct glfs_upcall_inode *in_arg = NULL; + struct glfs_object *root = NULL, *leaf = NULL; + + fprintf(stderr, "Starting libgfapi_fini\n"); + if (argc != 4) { + fprintf(stderr, "Invalid argument\n"); + exit(1); + } + + hostname = argv[1] volname = argv[2]; + logfile = argv[3]; + + fs = glfs_new(volname); + if (!fs) { + fprintf(stderr, "glfs_new: returned NULL\n"); + return 1; + } + + ret = glfs_set_volfile_server(fs, "tcp", hostname, 24007); + LOG_ERR("glfs_set_volfile_server", ret); + + ret = glfs_set_logging(fs, logfile, 7); + LOG_ERR("glfs_set_logging", ret); + + ret = glfs_init(fs); + LOG_ERR("glfs_init", ret); + + sleep(2); + root = glfs_h_lookupat(fs, NULL, "/", &sb, 0); + if (!root) { + ret = -1; + LOG_ERR("glfs_h_lookupat root", ret); + } + leaf = glfs_h_lookupat(fs, root, filename, &sb, 0); + if (!leaf) { + ret = -1; + LOG_IF_NO_ERR("glfs_h_lookupat leaf", ret); + } + + leaf = glfs_h_creat(fs, root, filename, O_RDWR, 0644, &sb); + if (!leaf) { + ret = -1; + LOG_ERR("glfs_h_lookupat leaf", ret); + } + fprintf(stderr, "glfs_h_create leaf - %p\n", leaf); + + leaf = glfs_h_lookupat(fs, root, filename2, &sb, 0); + if (!leaf) { + ret = -1; + LOG_IF_NO_ERR("glfs_h_lookupat leaf", ret); + } + + ret = glfs_h_rename(fs, root, filename, root, filename2); + LOG_ERR("glfs_rename", ret); + + while (cnt++ < 5) { + ret = glfs_h_poll_upcall(fs, &cbk); + LOG_ERR("glfs_h_poll_upcall", ret); + + /* There should not be any upcalls sent */ + if (glfs_upcall_get_reason(cbk) != GLFS_UPCALL_EVENT_NULL) { + fprintf(stderr, "Error: Upcall received(%d)\n", + glfs_upcall_get_reason(cbk)); + exit(1); } - hostname = argv[1] - volname = argv[2]; - logfile = argv[3]; + glfs_free(cbk); + } + ret = glfs_fini(fs); + LOG_ERR("glfs_fini", ret); - fs = glfs_new (volname); - if (!fs) { - fprintf (stderr, "glfs_new: returned NULL\n"); - return 1; - } - - ret = glfs_set_volfile_server (fs, "tcp", hostname, 24007); - LOG_ERR("glfs_set_volfile_server", ret); - - ret = glfs_set_logging (fs, logfile, 7); - LOG_ERR("glfs_set_logging", ret); - - ret = glfs_init (fs); - LOG_ERR("glfs_init", ret); - - sleep (2); - root = glfs_h_lookupat (fs, NULL, "/", &sb, 0); - if (!root) { - ret = -1; - LOG_ERR ("glfs_h_lookupat root", ret); - } - leaf = glfs_h_lookupat (fs, root, filename, &sb, 0); - if (!leaf) { - ret = -1; - LOG_IF_NO_ERR ("glfs_h_lookupat leaf", ret); - } - - leaf = glfs_h_creat (fs, root, filename, O_RDWR, 0644, &sb); - if (!leaf) { - ret = -1; - LOG_ERR ("glfs_h_lookupat leaf", ret); - } - fprintf (stderr, "glfs_h_create leaf - %p\n", leaf); - - leaf = glfs_h_lookupat (fs, root, filename2, &sb, 0); - if (!leaf) { - ret = -1; - LOG_IF_NO_ERR ("glfs_h_lookupat leaf", ret); - } - - ret = glfs_h_rename (fs, root, filename, root, filename2); - LOG_ERR("glfs_rename", ret); - - while (cnt++ < 5) { - ret = glfs_h_poll_upcall(fs, &cbk); - LOG_ERR ("glfs_h_poll_upcall", ret); - - /* There should not be any upcalls sent */ - if (glfs_upcall_get_reason(cbk) != GLFS_UPCALL_EVENT_NULL) { - fprintf (stderr, "Error: Upcall received(%d)\n", - glfs_upcall_get_reason(cbk)); - exit (1); - } - - glfs_free (cbk); - } - - ret = glfs_fini(fs); - LOG_ERR("glfs_fini", ret); - - fprintf (stderr, "End of libgfapi_fini\n"); + fprintf(stderr, "End of libgfapi_fini\n"); - exit(0); + exit(0); } - - diff --git a/tests/basic/gfapi/bug1291259.c b/tests/basic/gfapi/bug1291259.c index 26fc1e01449..cd7bc65268b 100644 --- a/tests/basic/gfapi/bug1291259.c +++ b/tests/basic/gfapi/bug1291259.c @@ -10,174 +10,172 @@ #include <glusterfs/api/glfs-handles.h> int gfapi = 1; -#define LOG_ERR(func, ret) do { \ - if (ret != 0) { \ - fprintf (stderr, "%s : returned error ret(%d), errno(%d)\n", \ - func, ret, errno); \ - exit(1); \ - } else { \ - fprintf (stderr, "%s : returned %d\n", func, ret); \ - } \ - } while (0) -#define LOG_IF_NO_ERR(func, ret) do { \ - if (ret == 0) { \ - fprintf (stderr, "%s : hasn't returned error %d\n", \ - func, ret); \ - exit(1); \ - } else { \ - fprintf (stderr, "%s : returned %d\n", func, ret); \ - } \ - } while (0) +#define LOG_ERR(func, ret) \ + do { \ + if (ret != 0) { \ + fprintf(stderr, "%s : returned error ret(%d), errno(%d)\n", func, \ + ret, errno); \ + exit(1); \ + } else { \ + fprintf(stderr, "%s : returned %d\n", func, ret); \ + } \ + } while (0) +#define LOG_IF_NO_ERR(func, ret) \ + do { \ + if (ret == 0) { \ + fprintf(stderr, "%s : hasn't returned error %d\n", func, ret); \ + exit(1); \ + } else { \ + fprintf(stderr, "%s : returned %d\n", func, ret); \ + } \ + } while (0) #define GLAPI_UUID_LENGTH 16 int -main (int argc, char *argv[]) +main(int argc, char *argv[]) { - glfs_t *fs = NULL; - glfs_t *fs2 = NULL; - int ret = 0, i; - glfs_fd_t *fd = NULL; - char *filename = "/a1"; - char *filename2 = "/a2"; - struct stat sb = {0, }; - char *logfile = NULL; - char *volname = NULL; - char *hostname = NULL; - int cnt = 1; - int upcall_received = 0; - struct glfs_upcall *cbk = NULL; - struct glfs_object *root = NULL, *leaf = NULL; - unsigned char globjhdl[GFAPI_HANDLE_LENGTH]; - unsigned char globjhdl2[GFAPI_HANDLE_LENGTH]; - - fprintf (stderr, "Starting libgfapi_fini\n"); - if (argc != 4) { - fprintf (stderr, "Invalid argument\n"); - exit(1); - } + glfs_t *fs = NULL; + glfs_t *fs2 = NULL; + int ret = 0, i; + glfs_fd_t *fd = NULL; + char *filename = "/a1"; + char *filename2 = "/a2"; + struct stat sb = { + 0, + }; + char *logfile = NULL; + char *volname = NULL; + char *hostname = NULL; + int cnt = 1; + int upcall_received = 0; + struct glfs_upcall *cbk = NULL; + struct glfs_object *root = NULL, *leaf = NULL; + unsigned char globjhdl[GFAPI_HANDLE_LENGTH]; + unsigned char globjhdl2[GFAPI_HANDLE_LENGTH]; + + fprintf(stderr, "Starting libgfapi_fini\n"); + if (argc != 4) { + fprintf(stderr, "Invalid argument\n"); + exit(1); + } + + hostname = argv[1]; + volname = argv[2]; + logfile = argv[3]; + + fs = glfs_new(volname); + if (!fs) { + fprintf(stderr, "glfs_new: returned NULL\n"); + return 1; + } + + ret = glfs_set_volfile_server(fs, "tcp", hostname, 24007); + LOG_ERR("glfs_set_volfile_server", ret); + + ret = glfs_set_logging(fs, logfile, 7); + LOG_ERR("glfs_set_logging", ret); + + ret = glfs_init(fs); + LOG_ERR("glfs_init", ret); + + /* This does not block, but enables caching of events. Real + * applications like NFS-Ganesha run this in a thread before activity + * on the fs (through this instance) happens. */ + ret = glfs_h_poll_upcall(fs, &cbk); + LOG_ERR("glfs_h_poll_upcall", ret); + + fs2 = glfs_new(volname); + if (!fs) { + fprintf(stderr, "glfs_new: returned NULL\n"); + return 1; + } + + ret = glfs_set_volfile_server(fs2, "tcp", hostname, 24007); + LOG_ERR("glfs_set_volfile_server", ret); + + ret = glfs_set_logging(fs2, logfile, 7); + LOG_ERR("glfs_set_logging", ret); + + ret = glfs_init(fs2); + LOG_ERR("glfs_init", ret); + + sleep(2); + root = glfs_h_lookupat(fs, NULL, "/", &sb, 0); + if (!root) { + ret = -1; + LOG_ERR("glfs_h_lookupat root", ret); + } + leaf = glfs_h_lookupat(fs, root, filename, &sb, 0); + if (!leaf) { + ret = -1; + LOG_IF_NO_ERR("glfs_h_lookupat leaf", ret); + } + + root = glfs_h_lookupat(fs2, NULL, "/", &sb, 0); + if (!root) { + ret = -1; + LOG_ERR("glfs_h_lookupat root", ret); + } + leaf = glfs_h_creat(fs2, root, filename, O_RDWR, 0644, &sb); + if (!leaf) { + ret = -1; + LOG_ERR("glfs_h_lookupat leaf", ret); + } + fprintf(stderr, "glfs_h_create leaf - %p\n", leaf); + + while (cnt++ < 5 && !upcall_received) { + enum glfs_upcall_reason reason = 0; + struct glfs_upcall_inode *in_arg = NULL; - hostname = argv[1]; - volname = argv[2]; - logfile = argv[3]; + ret = glfs_h_poll_upcall(fs, &cbk); + LOG_ERR("glfs_h_poll_upcall", ret); + if (ret) + goto retry; + reason = glfs_upcall_get_reason(cbk); + fprintf(stderr, "Upcall received(%d)\n", reason); - fs = glfs_new (volname); - if (!fs) { - fprintf (stderr, "glfs_new: returned NULL\n"); - return 1; - } + if (reason == GLFS_UPCALL_INODE_INVALIDATE) { + struct glfs_object *object = NULL; - ret = glfs_set_volfile_server (fs, "tcp", hostname, 24007); - LOG_ERR("glfs_set_volfile_server", ret); + in_arg = glfs_upcall_get_event(cbk); + object = glfs_upcall_inode_get_object(in_arg); - ret = glfs_set_logging (fs, logfile, 7); - LOG_ERR("glfs_set_logging", ret); + ret = glfs_h_extract_handle(root, globjhdl + GLAPI_UUID_LENGTH, + GFAPI_HANDLE_LENGTH); + LOG_ERR("glfs_h_extract_handle", (ret != 16)); - ret = glfs_init (fs); - LOG_ERR("glfs_init", ret); + ret = glfs_h_extract_handle(object, globjhdl2 + GLAPI_UUID_LENGTH, + GFAPI_HANDLE_LENGTH); + LOG_ERR("glfs_h_extract_handle", (ret != 16)); - /* This does not block, but enables caching of events. Real - * applications like NFS-Ganesha run this in a thread before activity - * on the fs (through this instance) happens. */ - ret = glfs_h_poll_upcall(fs, &cbk); - LOG_ERR ("glfs_h_poll_upcall", ret); - - fs2 = glfs_new (volname); - if (!fs) { - fprintf (stderr, "glfs_new: returned NULL\n"); - return 1; + if (memcmp(globjhdl + GLAPI_UUID_LENGTH, + globjhdl2 + GLAPI_UUID_LENGTH, 16)) { + fprintf(stderr, "Error: gfid mismatch\n"); + exit(1); + } + upcall_received = 1; } - ret = glfs_set_volfile_server (fs2, "tcp", hostname, 24007); - LOG_ERR("glfs_set_volfile_server", ret); - - ret = glfs_set_logging (fs2, logfile, 7); - LOG_ERR("glfs_set_logging", ret); - - ret = glfs_init (fs2); - LOG_ERR("glfs_init", ret); + retry: + if (!upcall_received) + sleep(1); /* glfs_h_poll_upcall() does not block */ - sleep (2); - root = glfs_h_lookupat (fs, NULL, "/", &sb, 0); - if (!root) { - ret = -1; - LOG_ERR ("glfs_h_lookupat root", ret); - } - leaf = glfs_h_lookupat (fs, root, filename, &sb, 0); - if (!leaf) { - ret = -1; - LOG_IF_NO_ERR ("glfs_h_lookupat leaf", ret); - } - - root = glfs_h_lookupat (fs2, NULL, "/", &sb, 0); - if (!root) { - ret = -1; - LOG_ERR ("glfs_h_lookupat root", ret); - } - leaf = glfs_h_creat (fs2, root, filename, O_RDWR, 0644, &sb); - if (!leaf) { - ret = -1; - LOG_ERR ("glfs_h_lookupat leaf", ret); - } - fprintf (stderr, "glfs_h_create leaf - %p\n", leaf); - - while (cnt++ < 5 && !upcall_received) { - enum glfs_upcall_reason reason = 0; - struct glfs_upcall_inode *in_arg = NULL; - - ret = glfs_h_poll_upcall(fs, &cbk); - LOG_ERR ("glfs_h_poll_upcall", ret); - if (ret) - goto retry; - - reason = glfs_upcall_get_reason (cbk); - fprintf (stderr, "Upcall received(%d)\n", reason); - - if (reason == GLFS_UPCALL_INODE_INVALIDATE) { - struct glfs_object *object = NULL; - - in_arg = glfs_upcall_get_event (cbk); - object = glfs_upcall_inode_get_object (in_arg); - - ret = glfs_h_extract_handle (root, - globjhdl+GLAPI_UUID_LENGTH, - GFAPI_HANDLE_LENGTH); - LOG_ERR("glfs_h_extract_handle", (ret != 16)); - - ret = glfs_h_extract_handle (object, - globjhdl2+GLAPI_UUID_LENGTH, - GFAPI_HANDLE_LENGTH); - LOG_ERR("glfs_h_extract_handle", (ret != 16)); - - if (memcmp (globjhdl+GLAPI_UUID_LENGTH, - globjhdl2+GLAPI_UUID_LENGTH, 16)) { - fprintf (stderr, "Error: gfid mismatch\n"); - exit (1); - } - upcall_received = 1; - } - -retry: - if (!upcall_received) - sleep (1); /* glfs_h_poll_upcall() does not block */ - - if (!ret) { - glfs_free (cbk); - cbk = NULL; - } + if (!ret) { + glfs_free(cbk); + cbk = NULL; } + } - if (!upcall_received) { - fprintf (stderr, "Error: Upcall not received\n"); - exit (1); - } + if (!upcall_received) { + fprintf(stderr, "Error: Upcall not received\n"); + exit(1); + } - ret = glfs_fini(fs); - LOG_ERR("glfs_fini", ret); + ret = glfs_fini(fs); + LOG_ERR("glfs_fini", ret); - fprintf (stderr, "End of libgfapi_fini\n"); + fprintf(stderr, "End of libgfapi_fini\n"); - exit(0); + exit(0); } - - diff --git a/tests/basic/gfapi/bug1613098.c b/tests/basic/gfapi/bug1613098.c index cdb69fdedfa..ee67e97a034 100644 --- a/tests/basic/gfapi/bug1613098.c +++ b/tests/basic/gfapi/bug1613098.c @@ -6,90 +6,91 @@ #include <glusterfs/api/glfs.h> #include <glusterfs/api/glfs-handles.h> -#define ACL_TYPE_ACCESS (0x8000) +#define ACL_TYPE_ACCESS (0x8000) -#define VALIDATE_AND_GOTO_LABEL_ON_ERROR(func, ret, label) do { \ - if (ret < 0) { \ - fprintf (stderr, "%s : returned error %d (%s)\n", \ - func, ret, strerror (errno)); \ - goto label; \ - } \ - } while (0) +#define VALIDATE_AND_GOTO_LABEL_ON_ERROR(func, ret, label) \ + do { \ + if (ret < 0) { \ + fprintf(stderr, "%s : returned error %d (%s)\n", func, ret, \ + strerror(errno)); \ + goto label; \ + } \ + } while (0) int -main (int argc, char *argv[]) +main(int argc, char *argv[]) { - int ret = -1; - int flags = O_RDWR|O_SYNC; - glfs_t *fs = NULL; - glfs_fd_t *fd = NULL; - char *volname = NULL; - char *logfile = NULL; - const char *filename = "file_tmp"; - struct glfs_object *object = NULL; - acl_t acl = NULL; - struct stat sb; - - if (argc != 3) { - fprintf (stderr, "Invalid argument\n"); - return 1; - } - - volname = argv[1]; - logfile = argv[2]; - - fs = glfs_new (volname); - if (!fs) - VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_new", ret, out); - - ret = glfs_set_volfile_server (fs, "tcp", "localhost", 24007); - VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_set_volfile_server", ret, out); - - ret = glfs_set_logging (fs, logfile, 7); - VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_set_logging", ret, out); - - ret = glfs_init (fs); - VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_init", ret, out); - - fd = glfs_creat(fs, filename, flags, 0044); - if (fd == NULL) { - ret = -1; - VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_creat", ret, out); - } - glfs_close(fd); - - object = glfs_h_lookupat(fs, NULL, filename, NULL, 0); - if (object == NULL) { - ret = -1; - VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_h_lookupat", ret, out); - } - - ret = glfs_chown(fs, filename, 99, 99); - VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_chown", ret, out); - - ret = glfs_setfsuid(99); - VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_setfsuid", ret, out); - - ret = glfs_setfsgid(99); - VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_setfsgid", ret, out); - - acl = glfs_h_acl_get(fs, object, ACL_TYPE_ACCESS); - if (acl == NULL) { - ret = -1; - VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_h_acl_get", ret, out); - } - - ret = glfs_h_acl_set(fs, object, ACL_TYPE_ACCESS, acl); - VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_h_acl_get", ret, out); + int ret = -1; + int flags = O_RDWR | O_SYNC; + glfs_t *fs = NULL; + glfs_fd_t *fd = NULL; + char *volname = NULL; + char *logfile = NULL; + const char *filename = "file_tmp"; + struct glfs_object *object = NULL; + acl_t acl = NULL; + struct stat sb; + + if (argc != 3) { + fprintf(stderr, "Invalid argument\n"); + return 1; + } + + volname = argv[1]; + logfile = argv[2]; + + fs = glfs_new(volname); + if (!fs) + VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_new", ret, out); + + ret = glfs_set_volfile_server(fs, "tcp", "localhost", 24007); + VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_set_volfile_server", ret, out); + + ret = glfs_set_logging(fs, logfile, 7); + VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_set_logging", ret, out); + + ret = glfs_init(fs); + VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_init", ret, out); + + fd = glfs_creat(fs, filename, flags, 0044); + if (fd == NULL) { + ret = -1; + VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_creat", ret, out); + } + glfs_close(fd); + + object = glfs_h_lookupat(fs, NULL, filename, NULL, 0); + if (object == NULL) { + ret = -1; + VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_h_lookupat", ret, out); + } + + ret = glfs_chown(fs, filename, 99, 99); + VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_chown", ret, out); + + ret = glfs_setfsuid(99); + VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_setfsuid", ret, out); + + ret = glfs_setfsgid(99); + VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_setfsgid", ret, out); + + acl = glfs_h_acl_get(fs, object, ACL_TYPE_ACCESS); + if (acl == NULL) { + ret = -1; + VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_h_acl_get", ret, out); + } + + ret = glfs_h_acl_set(fs, object, ACL_TYPE_ACCESS, acl); + VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_h_acl_get", ret, out); out: - glfs_setfsuid(0); - glfs_setfsgid(0); + glfs_setfsuid(0); + glfs_setfsgid(0); - if (object) - glfs_h_close(object); + if (object) + glfs_h_close(object); - if (fs) - glfs_fini(fs); + if (fs) + glfs_fini(fs); - return ret; + return ret; } diff --git a/tests/basic/gfapi/gfapi-async-calls-test.c b/tests/basic/gfapi/gfapi-async-calls-test.c index b9f29a44ac0..5a291c3c76b 100644 --- a/tests/basic/gfapi/gfapi-async-calls-test.c +++ b/tests/basic/gfapi/gfapi-async-calls-test.c @@ -9,170 +9,164 @@ #include <glusterfs/api/glfs.h> #include <glusterfs/api/glfs-handles.h> -#define LOG_ERR(msg) do { \ - fprintf (stderr, "%s : Error (%s)\n", msg, strerror (errno)); \ - } while (0) +#define LOG_ERR(msg) \ + do { \ + fprintf(stderr, "%s : Error (%s)\n", msg, strerror(errno)); \ + } while (0) int cbk_complete = 0; int cbk_ret_val = -1; int -fill_iov (struct iovec *iov, char fillchar, int count) +fill_iov(struct iovec *iov, char fillchar, int count) { - int ret = -1; - - iov->iov_base = malloc (count + 1); - if (iov->iov_base == NULL) { - return ret; - } else { - iov->iov_len = count; - ret = 0; - } - memset (iov->iov_base, fillchar, count); - memset (iov->iov_base + count, '\0', 1); + int ret = -1; + iov->iov_base = malloc(count + 1); + if (iov->iov_base == NULL) { return ret; + } else { + iov->iov_len = count; + ret = 0; + } + memset(iov->iov_base, fillchar, count); + memset(iov->iov_base + count, '\0', 1); + + return ret; } glfs_t * -init_glfs (const char *hostname, const char *volname, - const char *logfile) +init_glfs(const char *hostname, const char *volname, const char *logfile) { - int ret = -1; - glfs_t *fs = NULL; - - fs = glfs_new (volname); - if (!fs) { - LOG_ERR ("glfs_new failed"); - return NULL; - } - - ret = glfs_set_volfile_server (fs, "tcp", hostname, 24007); - if (ret < 0) { - LOG_ERR ("glfs_set_volfile_server failed"); - goto out; - } - - ret = glfs_set_logging (fs, logfile, 7); - if (ret < 0) { - LOG_ERR ("glfs_set_logging failed"); - goto out; - } - - ret = glfs_init (fs); - if (ret < 0) { - LOG_ERR ("glfs_init failed"); - goto out; - } - - ret = 0; + int ret = -1; + glfs_t *fs = NULL; + + fs = glfs_new(volname); + if (!fs) { + LOG_ERR("glfs_new failed"); + return NULL; + } + + ret = glfs_set_volfile_server(fs, "tcp", hostname, 24007); + if (ret < 0) { + LOG_ERR("glfs_set_volfile_server failed"); + goto out; + } + + ret = glfs_set_logging(fs, logfile, 7); + if (ret < 0) { + LOG_ERR("glfs_set_logging failed"); + goto out; + } + + ret = glfs_init(fs); + if (ret < 0) { + LOG_ERR("glfs_init failed"); + goto out; + } + + ret = 0; out: - if (ret) { - glfs_fini (fs); - fs = NULL; - } + if (ret) { + glfs_fini(fs); + fs = NULL; + } - return fs; + return fs; } void -write_async_cbk (glfs_fd_t *fd, ssize_t ret, struct stat *prestat, - struct stat *poststat, void *cookie) +write_async_cbk(glfs_fd_t *fd, ssize_t ret, struct stat *prestat, + struct stat *poststat, void *cookie) { - - if (ret < 0) { - LOG_ERR ("glfs_write failed"); - } - cbk_ret_val = ret; - cbk_complete = 1; + if (ret < 0) { + LOG_ERR("glfs_write failed"); + } + cbk_ret_val = ret; + cbk_complete = 1; } int -write_async (glfs_t *fs, glfs_fd_t *glfd, int char_count) +write_async(glfs_t *fs, glfs_fd_t *glfd, int char_count) { - ssize_t ret = -1; - int flags = O_RDWR; - const char *buff = "This is from my prog\n"; - struct iovec iov = {0}; - void *write_cookie = NULL; - void *read_cookie = NULL; - - - - ret = fill_iov (&iov, 'a', char_count); - if (ret) { - LOG_ERR ("failed to create iov"); - goto out; - } - - write_cookie = strdup ("write_cookie"); - ret = glfs_pwritev_async (glfd, &iov, 1, 0, flags, write_async_cbk, - &write_cookie); + ssize_t ret = -1; + int flags = O_RDWR; + const char *buff = "This is from my prog\n"; + struct iovec iov = {0}; + void *write_cookie = NULL; + void *read_cookie = NULL; + + ret = fill_iov(&iov, 'a', char_count); + if (ret) { + LOG_ERR("failed to create iov"); + goto out; + } + + write_cookie = strdup("write_cookie"); + ret = glfs_pwritev_async(glfd, &iov, 1, 0, flags, write_async_cbk, + &write_cookie); out: - if (ret < 0) { - LOG_ERR ("glfs_pwritev async failed"); - } - return ret; - + if (ret < 0) { + LOG_ERR("glfs_pwritev async failed"); + } + return ret; } int -main (int argc, char *argv[]) +main(int argc, char *argv[]) { - int ret = 0; - char *hostname = NULL; - char *volname = NULL; - char *logfile = NULL; - glfs_t *fs = NULL; - const char *filename = "glfs_test.txt"; - int flags = (O_RDWR|O_CREAT); - glfs_fd_t *glfd = NULL; - int count = 200; - - if (argc != 4) { - fprintf (stderr, "Invalid argument\n"); - exit(1); - } - - hostname = argv[1]; - volname = argv[2]; - logfile = argv[3]; - - fs = init_glfs (hostname, volname, logfile); - if (fs == NULL) { - LOG_ERR ("init_glfs failed"); - return -1; - } - - glfd = glfs_creat (fs, filename, flags, 0644); - if (glfd == NULL) { - LOG_ERR ("glfs_creat failed"); - exit(1); - } - - ret = write_async (fs, glfd, count); - if (ret) { - LOG_ERR ("glfs_test_function failed"); - exit(1); - } - - while (cbk_complete != 1) { - sleep(1); - } - - ret = glfs_close (glfd); - if (ret < 0) { - LOG_ERR ("glfs close failed"); - } - - /* - * skipping fini - */ - - if (cbk_ret_val == count) - return 0; - else - return -1; + int ret = 0; + char *hostname = NULL; + char *volname = NULL; + char *logfile = NULL; + glfs_t *fs = NULL; + const char *filename = "glfs_test.txt"; + int flags = (O_RDWR | O_CREAT); + glfs_fd_t *glfd = NULL; + int count = 200; + + if (argc != 4) { + fprintf(stderr, "Invalid argument\n"); + exit(1); + } + + hostname = argv[1]; + volname = argv[2]; + logfile = argv[3]; + + fs = init_glfs(hostname, volname, logfile); + if (fs == NULL) { + LOG_ERR("init_glfs failed"); + return -1; + } + + glfd = glfs_creat(fs, filename, flags, 0644); + if (glfd == NULL) { + LOG_ERR("glfs_creat failed"); + exit(1); + } + + ret = write_async(fs, glfd, count); + if (ret) { + LOG_ERR("glfs_test_function failed"); + exit(1); + } + + while (cbk_complete != 1) { + sleep(1); + } + + ret = glfs_close(glfd); + if (ret < 0) { + LOG_ERR("glfs close failed"); + } + + /* + * skipping fini + */ + + if (cbk_ret_val == count) + return 0; + else + return -1; } - - diff --git a/tests/basic/gfapi/gfapi-dup.c b/tests/basic/gfapi/gfapi-dup.c index 96f133eae33..028108e4590 100644 --- a/tests/basic/gfapi/gfapi-dup.c +++ b/tests/basic/gfapi/gfapi-dup.c @@ -4,81 +4,81 @@ #include <glusterfs/api/glfs.h> #include <glusterfs/api/glfs-handles.h> -#define VALIDATE_AND_GOTO_LABEL_ON_ERROR(func, ret, label) do { \ - if (ret < 0) { \ - fprintf (stderr, "%s : returned error %d (%s)\n", \ - func, ret, strerror (errno)); \ - goto label; \ - } \ - } while (0) +#define VALIDATE_AND_GOTO_LABEL_ON_ERROR(func, ret, label) \ + do { \ + if (ret < 0) { \ + fprintf(stderr, "%s : returned error %d (%s)\n", func, ret, \ + strerror(errno)); \ + goto label; \ + } \ + } while (0) int -main (int argc, char *argv[]) +main(int argc, char *argv[]) { - int ret = -1; - int flags = O_RDWR|O_SYNC; - glfs_t *fs = NULL; - glfs_fd_t *fd1 = NULL; - glfs_fd_t *fd2 = NULL; - char *volname = NULL; - char *logfile = NULL; - char *hostname = NULL; - const char *filename = "file_tmp"; - const char *buff = "An opinion should be the result of thought, " - "not a substitute for it."; - - if (argc != 4) { - fprintf (stderr, "Invalid argument\n"); - return 1; - } - - hostname = argv[1]; - volname = argv[2]; - logfile = argv[3]; - - fs = glfs_new (volname); - if (!fs) - VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_new", ret, out); - - ret = glfs_set_volfile_server (fs, "tcp", hostname, 24007); - VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_set_volfile_server", ret, out); - - ret = glfs_set_logging (fs, logfile, 7); - VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_set_logging", ret, out); - - ret = glfs_init (fs); - VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_init", ret, out); - - fd1 = glfs_creat(fs, filename, flags, 0644); - if (fd1 == NULL) { - ret = -1; - VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_creat", ret, out); - } - - ret = glfs_write (fd1, buff, strlen (buff), flags); - VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_write", ret, out); - - fd2 = glfs_dup(fd1); - if (fd2 == NULL) { - ret = -1; - VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_dup", ret, out); - } - - ret = glfs_lseek (fd2, 0, SEEK_SET); - VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_lseek", ret, out); + int ret = -1; + int flags = O_RDWR | O_SYNC; + glfs_t *fs = NULL; + glfs_fd_t *fd1 = NULL; + glfs_fd_t *fd2 = NULL; + char *volname = NULL; + char *logfile = NULL; + char *hostname = NULL; + const char *filename = "file_tmp"; + const char *buff = + "An opinion should be the result of thought, " + "not a substitute for it."; + + if (argc != 4) { + fprintf(stderr, "Invalid argument\n"); + return 1; + } + + hostname = argv[1]; + volname = argv[2]; + logfile = argv[3]; + + fs = glfs_new(volname); + if (!fs) + VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_new", ret, out); + + ret = glfs_set_volfile_server(fs, "tcp", hostname, 24007); + VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_set_volfile_server", ret, out); + + ret = glfs_set_logging(fs, logfile, 7); + VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_set_logging", ret, out); + + ret = glfs_init(fs); + VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_init", ret, out); + + fd1 = glfs_creat(fs, filename, flags, 0644); + if (fd1 == NULL) { + ret = -1; + VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_creat", ret, out); + } + + ret = glfs_write(fd1, buff, strlen(buff), flags); + VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_write", ret, out); + + fd2 = glfs_dup(fd1); + if (fd2 == NULL) { + ret = -1; + VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_dup", ret, out); + } + + ret = glfs_lseek(fd2, 0, SEEK_SET); + VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_lseek", ret, out); out: - if (fd1 != NULL) - glfs_close(fd1); - if (fd2 != NULL) - glfs_close(fd2); - if (fs) { - ret = glfs_fini(fs); - if (ret) - fprintf (stderr, "glfs_fini(fs) returned %d\n", ret); - } - - return ret; + if (fd1 != NULL) + glfs_close(fd1); + if (fd2 != NULL) + glfs_close(fd2); + if (fs) { + ret = glfs_fini(fs); + if (ret) + fprintf(stderr, "glfs_fini(fs) returned %d\n", ret); + } + + return ret; } - - diff --git a/tests/basic/gfapi/gfapi-load-volfile.c b/tests/basic/gfapi/gfapi-load-volfile.c index 79502f7a44f..fbfc6045cd7 100644 --- a/tests/basic/gfapi/gfapi-load-volfile.c +++ b/tests/basic/gfapi/gfapi-load-volfile.c @@ -16,50 +16,50 @@ void usage(FILE *output) { - fprintf(output, "Usage: " PROGNAME " <volfile>\n"); + fprintf(output, "Usage: " PROGNAME " <volfile>\n"); } void main(int argc, char **argv) { - int ret = 0; - glfs_t *fs = NULL; + int ret = 0; + glfs_t *fs = NULL; - if (argc != 2) { - usage(stderr); - exit(EXIT_FAILURE); - } + if (argc != 2) { + usage(stderr); + exit(EXIT_FAILURE); + } - if (!strcmp(argv[1], "-h") || !strcmp(argv[1], "-h")) { - usage(stdout); - exit(EXIT_SUCCESS); - } + if (!strcmp(argv[1], "-h") || !strcmp(argv[1], "-h")) { + usage(stdout); + exit(EXIT_SUCCESS); + } - fs = glfs_new(PROGNAME); - if (!fs) { - perror("glfs_new failed"); - exit(EXIT_FAILURE); - } + fs = glfs_new(PROGNAME); + if (!fs) { + perror("glfs_new failed"); + exit(EXIT_FAILURE); + } - glfs_set_logging(fs, PROGNAME ".log", 9); + glfs_set_logging(fs, PROGNAME ".log", 9); - ret = glfs_set_volfile(fs, argv[1]); - if (ret) { - perror("glfs_set_volfile failed"); - ret = EXIT_FAILURE; - goto out; - } + ret = glfs_set_volfile(fs, argv[1]); + if (ret) { + perror("glfs_set_volfile failed"); + ret = EXIT_FAILURE; + goto out; + } - ret = glfs_init(fs); - if (ret) { - perror("glfs_init failed"); - ret = EXIT_FAILURE; - goto out; - } + ret = glfs_init(fs); + if (ret) { + perror("glfs_init failed"); + ret = EXIT_FAILURE; + goto out; + } - ret = EXIT_SUCCESS; + ret = EXIT_SUCCESS; out: - glfs_fini(fs); + glfs_fini(fs); - exit(ret); + exit(ret); } diff --git a/tests/basic/gfapi/gfapi-ssl-test.c b/tests/basic/gfapi/gfapi-ssl-test.c index 41126bdc6db..a27b5233702 100644 --- a/tests/basic/gfapi/gfapi-ssl-test.c +++ b/tests/basic/gfapi/gfapi-ssl-test.c @@ -9,118 +9,116 @@ #include <glusterfs/api/glfs.h> #include <glusterfs/api/glfs-handles.h> -#define LOG_ERR(msg) do { \ - fprintf (stderr, "%s : Error (%s)\n", msg, strerror (errno)); \ - } while (0) +#define LOG_ERR(msg) \ + do { \ + fprintf(stderr, "%s : Error (%s)\n", msg, strerror(errno)); \ + } while (0) glfs_t * -init_glfs (const char *hostname, const char *volname, - const char *logfile) +init_glfs(const char *hostname, const char *volname, const char *logfile) { - int ret = -1; - glfs_t *fs = NULL; - - fs = glfs_new (volname); - if (!fs) { - LOG_ERR ("glfs_new failed"); - return NULL; - } - - ret = glfs_set_volfile_server (fs, "tcp", hostname, 24007); - if (ret < 0) { - LOG_ERR ("glfs_set_volfile_server failed"); - goto out; - } - - ret = glfs_set_logging (fs, logfile, 7); - if (ret < 0) { - LOG_ERR ("glfs_set_logging failed"); - goto out; - } - - ret = glfs_init (fs); - if (ret < 0) { - LOG_ERR ("glfs_init failed"); - goto out; - } - - ret = 0; + int ret = -1; + glfs_t *fs = NULL; + + fs = glfs_new(volname); + if (!fs) { + LOG_ERR("glfs_new failed"); + return NULL; + } + + ret = glfs_set_volfile_server(fs, "tcp", hostname, 24007); + if (ret < 0) { + LOG_ERR("glfs_set_volfile_server failed"); + goto out; + } + + ret = glfs_set_logging(fs, logfile, 7); + if (ret < 0) { + LOG_ERR("glfs_set_logging failed"); + goto out; + } + + ret = glfs_init(fs); + if (ret < 0) { + LOG_ERR("glfs_init failed"); + goto out; + } + + ret = 0; out: - if (ret) { - glfs_fini (fs); - fs = NULL; - } + if (ret) { + glfs_fini(fs); + fs = NULL; + } - return fs; + return fs; } int -glfs_test_function (const char *hostname, const char *volname, - const char *logfile) +glfs_test_function(const char *hostname, const char *volname, + const char *logfile) { - int ret = -1; - int flags = O_CREAT | O_RDWR; - glfs_t *fs = NULL; - glfs_fd_t *glfd = NULL; - const char *buff = "This is from my prog\n"; - const char *filename = "glfs_test.txt"; - - fs = init_glfs (hostname, volname, logfile); - if (fs == NULL) { - LOG_ERR ("init_glfs failed"); - return -1; - } - - glfd = glfs_creat (fs, filename, flags, 0644); - if (glfd == NULL) { - LOG_ERR ("glfs_creat failed"); - goto out; - } - - ret = glfs_write (glfd, buff, strlen (buff), flags); - if (ret < 0) { - LOG_ERR ("glfs_write failed"); - goto out; - } - - ret = glfs_close (glfd); - if (ret < 0) { - LOG_ERR ("glfs_write failed"); - goto out; - } + int ret = -1; + int flags = O_CREAT | O_RDWR; + glfs_t *fs = NULL; + glfs_fd_t *glfd = NULL; + const char *buff = "This is from my prog\n"; + const char *filename = "glfs_test.txt"; + + fs = init_glfs(hostname, volname, logfile); + if (fs == NULL) { + LOG_ERR("init_glfs failed"); + return -1; + } + + glfd = glfs_creat(fs, filename, flags, 0644); + if (glfd == NULL) { + LOG_ERR("glfs_creat failed"); + goto out; + } + + ret = glfs_write(glfd, buff, strlen(buff), flags); + if (ret < 0) { + LOG_ERR("glfs_write failed"); + goto out; + } + + ret = glfs_close(glfd); + if (ret < 0) { + LOG_ERR("glfs_write failed"); + goto out; + } out: - ret = glfs_fini (fs); - if (ret) { - LOG_ERR ("glfs_fini failed"); - } + ret = glfs_fini(fs); + if (ret) { + LOG_ERR("glfs_fini failed"); + } - return ret; + return ret; } int -main (int argc, char *argv[]) +main(int argc, char *argv[]) { - int ret = 0; - char *hostname = NULL; - char *volname = NULL; - char *logfile = NULL; - - if (argc != 4) { - fprintf (stderr, "Invalid argument\n"); - exit(1); - } - - hostname = argv[1]; - volname = argv[2]; - logfile = argv[3]; - - ret = glfs_test_function (hostname, volname, logfile); - if (ret) { - LOG_ERR ("glfs_test_function failed"); - } - - return ret; + int ret = 0; + char *hostname = NULL; + char *volname = NULL; + char *logfile = NULL; + + if (argc != 4) { + fprintf(stderr, "Invalid argument\n"); + exit(1); + } + + hostname = argv[1]; + volname = argv[2]; + logfile = argv[3]; + + ret = glfs_test_function(hostname, volname, logfile); + if (ret) { + LOG_ERR("glfs_test_function failed"); + } + + return ret; } - - diff --git a/tests/basic/gfapi/gfapi-trunc.c b/tests/basic/gfapi/gfapi-trunc.c index af187e50c78..769f6cfa1d9 100644 --- a/tests/basic/gfapi/gfapi-trunc.c +++ b/tests/basic/gfapi/gfapi-trunc.c @@ -5,86 +5,85 @@ #include <glusterfs/api/glfs.h> #include <glusterfs/api/glfs-handles.h> -#define VALIDATE_AND_GOTO_LABEL_ON_ERROR(func, ret, label) do { \ - if (ret < 0) { \ - fprintf (stderr, "%s : returned error %d (%s)\n", \ - func, ret, strerror (errno)); \ - goto label; \ - } \ - } while (0) - -#define WRITE_SIZE 4096 -#define TRUNC_SIZE 1234 +#define VALIDATE_AND_GOTO_LABEL_ON_ERROR(func, ret, label) \ + do { \ + if (ret < 0) { \ + fprintf(stderr, "%s : returned error %d (%s)\n", func, ret, \ + strerror(errno)); \ + goto label; \ + } \ + } while (0) + +#define WRITE_SIZE 4096 +#define TRUNC_SIZE 1234 /* Make sure TRUNC_SIZE is smaller than WRITE_SIZE at compile time. */ -typedef char _size_check[WRITE_SIZE-TRUNC_SIZE]; +typedef char _size_check[WRITE_SIZE - TRUNC_SIZE]; int -main (int argc, char *argv[]) +main(int argc, char *argv[]) { - int ret = -1; - int flags = O_RDWR|O_SYNC; - glfs_t *fs = NULL; - glfs_fd_t *fd1 = NULL; - char *volname = NULL; - char *logfile = NULL; - const char *filename = "file_tmp"; - const char buff[WRITE_SIZE]; - struct stat sb; - - if (argc != 3) { - fprintf (stderr, "Invalid argument\n"); - return 1; - } - - volname = argv[1]; - logfile = argv[2]; - - fs = glfs_new (volname); - if (!fs) - VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_new", ret, out); - - ret = glfs_set_volfile_server (fs, "tcp", "localhost", 24007); - VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_set_volfile_server", ret, out); - - ret = glfs_set_logging (fs, logfile, 7); - VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_set_logging", ret, out); - - ret = glfs_init (fs); - VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_init", ret, out); - - fd1 = glfs_creat(fs, filename, flags, 0644); - if (fd1 == NULL) { - ret = -1; - VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_creat", ret, out); - } - - ret = glfs_write (fd1, buff, WRITE_SIZE, flags); - VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_write", ret, out); - - ret = glfs_truncate (fs, filename, TRUNC_SIZE); - VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_truncate", ret, out); - - ret = glfs_fstat (fd1, &sb); - VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_fstat", ret, out); - - if (sb.st_size != TRUNC_SIZE) { - fprintf (stderr, "wrong size %jd should be %jd\n", - (intmax_t)sb.st_size, (intmax_t)2048); - ret = -1; - } + int ret = -1; + int flags = O_RDWR | O_SYNC; + glfs_t *fs = NULL; + glfs_fd_t *fd1 = NULL; + char *volname = NULL; + char *logfile = NULL; + const char *filename = "file_tmp"; + const char buff[WRITE_SIZE]; + struct stat sb; + + if (argc != 3) { + fprintf(stderr, "Invalid argument\n"); + return 1; + } + + volname = argv[1]; + logfile = argv[2]; + + fs = glfs_new(volname); + if (!fs) + VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_new", ret, out); + + ret = glfs_set_volfile_server(fs, "tcp", "localhost", 24007); + VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_set_volfile_server", ret, out); + + ret = glfs_set_logging(fs, logfile, 7); + VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_set_logging", ret, out); + + ret = glfs_init(fs); + VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_init", ret, out); + + fd1 = glfs_creat(fs, filename, flags, 0644); + if (fd1 == NULL) { + ret = -1; + VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_creat", ret, out); + } + + ret = glfs_write(fd1, buff, WRITE_SIZE, flags); + VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_write", ret, out); + + ret = glfs_truncate(fs, filename, TRUNC_SIZE); + VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_truncate", ret, out); + + ret = glfs_fstat(fd1, &sb); + VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_fstat", ret, out); + + if (sb.st_size != TRUNC_SIZE) { + fprintf(stderr, "wrong size %jd should be %jd\n", (intmax_t)sb.st_size, + (intmax_t)2048); + ret = -1; + } out: - if (fd1 != NULL) - glfs_close(fd1); - if (fs) { - /* - * If this fails (as it does on Special Snowflake NetBSD for no - * good reason), it shouldn't affect the result of the test. - */ - (void) glfs_fini(fs); - } - - return ret; + if (fd1 != NULL) + glfs_close(fd1); + if (fs) { + /* + * If this fails (as it does on Special Snowflake NetBSD for no + * good reason), it shouldn't affect the result of the test. + */ + (void)glfs_fini(fs); + } + + return ret; } - - diff --git a/tests/basic/gfapi/glfd-lkowner.c b/tests/basic/gfapi/glfd-lkowner.c index 031a076683c..ec0429dc3c4 100644 --- a/tests/basic/gfapi/glfd-lkowner.c +++ b/tests/basic/gfapi/glfd-lkowner.c @@ -13,200 +13,202 @@ int gfapi = 1; -#define LOG_ERR(func, ret) do { \ - if (ret != 0) { \ - fprintf (stderr, "%s : returned error %d (%s)\n", \ - func, ret, strerror (errno)); \ - goto out; \ - } else { \ - fprintf (stderr, "%s : returned %d\n", func, ret); \ - } \ - } while (0) +#define LOG_ERR(func, ret) \ + do { \ + if (ret != 0) { \ + fprintf(stderr, "%s : returned error %d (%s)\n", func, ret, \ + strerror(errno)); \ + goto out; \ + } else { \ + fprintf(stderr, "%s : returned %d\n", func, ret); \ + } \ + } while (0) char lownera[8] = "lownera", lownerb[8] = "lownerb"; char lownerc[8] = "lownerc"; -int lock_test (glfs_fd_t *glfd1, glfs_fd_t *glfd2, bool should_fail, - int l1_start, int l1_len, char *l1_owner, int lo1_len, - int l2_start, int l2_len, char *l2_owner, int lo2_len) +int +lock_test(glfs_fd_t *glfd1, glfs_fd_t *glfd2, bool should_fail, int l1_start, + int l1_len, char *l1_owner, int lo1_len, int l2_start, int l2_len, + char *l2_owner, int lo2_len) { - int ret = -1, f_ret = -1; - struct flock lock1 = {0, }, lock2 = {0, }; + int ret = -1, f_ret = -1; + struct flock lock1 = + { + 0, + }, + lock2 = { + 0, + }; lock1: - if (!glfd1) - goto lock2; + if (!glfd1) + goto lock2; - /* lock on glfd1 */ - lock1.l_type = F_WRLCK; - lock1.l_whence = SEEK_SET; - lock1.l_start = l1_start; - lock1.l_len = l1_len; + /* lock on glfd1 */ + lock1.l_type = F_WRLCK; + lock1.l_whence = SEEK_SET; + lock1.l_start = l1_start; + lock1.l_len = l1_len; - ret = glfs_fd_set_lkowner (glfd1, l1_owner, lo1_len); - LOG_ERR ("glfs_fd_set_lkowner on glfd1", ret); + ret = glfs_fd_set_lkowner(glfd1, l1_owner, lo1_len); + LOG_ERR("glfs_fd_set_lkowner on glfd1", ret); - ret = glfs_posix_lock (glfd1, F_SETLK, &lock1); - LOG_ERR ("glfs_posix_lock on glfd1", ret); + ret = glfs_posix_lock(glfd1, F_SETLK, &lock1); + LOG_ERR("glfs_posix_lock on glfd1", ret); lock2: - if (!glfd2) - goto out; - - /* lock on glfd2 */ - lock2.l_type = F_WRLCK; - lock2.l_whence = SEEK_SET; - lock2.l_start = l2_start; - lock2.l_len = l2_len; - - ret = glfs_fd_set_lkowner (glfd2, l2_owner, lo2_len); - LOG_ERR ("glfs_fd_set_lkowner on glfd2", ret); - - ret = glfs_posix_lock (glfd2, F_SETLK, &lock2); - - if (should_fail && ret) { - f_ret = 0; - } else if (!ret && !should_fail) { - f_ret = 0; - } else { - f_ret = -1; - } + if (!glfd2) + goto out; + + /* lock on glfd2 */ + lock2.l_type = F_WRLCK; + lock2.l_whence = SEEK_SET; + lock2.l_start = l2_start; + lock2.l_len = l2_len; + + ret = glfs_fd_set_lkowner(glfd2, l2_owner, lo2_len); + LOG_ERR("glfs_fd_set_lkowner on glfd2", ret); + + ret = glfs_posix_lock(glfd2, F_SETLK, &lock2); + + if (should_fail && ret) { + f_ret = 0; + } else if (!ret && !should_fail) { + f_ret = 0; + } else { + f_ret = -1; + } out: - fprintf (stderr, "Lock test on glfd1 (start(%d), len(%d)," - " lk_owner(%s)) and glfd2 (start(%d), len(%d), " - "lk_owner(%s)) - expected(%s) - result(%s)\n", - l1_start, l1_len, l1_owner, l2_start, l2_len, l2_owner, - (should_fail ? "FAIL" : "SUCCESS"), - (ret ? "FAIL" : "SUCCESS")); - return f_ret; + fprintf(stderr, + "Lock test on glfd1 (start(%d), len(%d)," + " lk_owner(%s)) and glfd2 (start(%d), len(%d), " + "lk_owner(%s)) - expected(%s) - result(%s)\n", + l1_start, l1_len, l1_owner, l2_start, l2_len, l2_owner, + (should_fail ? "FAIL" : "SUCCESS"), (ret ? "FAIL" : "SUCCESS")); + return f_ret; } int -main (int argc, char *argv[]) +main(int argc, char *argv[]) { - glfs_t *fs = NULL; - int ret = 0, i, status = 0; - glfs_fd_t *fd1 = NULL; - glfs_fd_t *fd2 = NULL; - glfs_fd_t *fd3 = NULL; - char *filename = "file_tmp"; - char *volname = NULL; - char *logfile = NULL; - char *hostname = NULL; - - if (argc != 4) { - fprintf (stderr, "Invalid argument\n"); - exit(1); - } - - hostname = argv[1]; - volname = argv[2]; - logfile = argv[3]; - - fs = glfs_new (volname); - if (!fs) { - fprintf (stderr, "glfs_new: returned NULL\n"); - return -1; - } - - ret = glfs_set_volfile_server (fs, "tcp", hostname, 24007); - LOG_ERR("glfs_set_volfile_server", ret); - - ret = glfs_set_logging (fs, logfile, 7); - LOG_ERR("glfs_set_logging", ret); - - ret = glfs_init (fs); - LOG_ERR("glfs_init", ret); - - fd1 = glfs_creat(fs, filename, O_RDWR|O_SYNC, 0644); - if (fd1 <= 0) { - ret = -1; - LOG_ERR ("glfs_creat", ret); - } - fprintf (stderr, "glfs-create fd1 - %d\n", fd1); - - fd2 = glfs_dup(fd1); - fprintf (stderr, "glfs-dup fd2 - %d\n", fd2); - - fd3 = glfs_open(fs, filename, O_RDWR|O_SYNC); - if (fd2 <= 0) { - ret = -1; - LOG_ERR ("glfs_open", ret); - } - fprintf (stderr, "glfs-open fd3 - %d\n", fd3); - - /* TEST 1: Conflicting ranges, same lk_owner - * lock1 (0, 10, lownera) - * lock2 (5, 10, lownera) - * Expected: should not fail but get merged - */ - ret = lock_test (fd1, fd2, false, 0, 10, lownera, 8, - 5, 10, lownera, 8); - LOG_ERR ("==== glfs_lock_test_1", ret); - - /* TEST 2: Conflicting ranges, different lk_owner - * lock1 (0, 10, lownera) - already taken - * lock2 (5, 10, lownerb) - * Expected: should fail and not get merged - */ - ret = lock_test (NULL, fd2, true, 0, 10, lownera, 8, - 5, 10, lownerb, 8); - LOG_ERR ("==== glfs_lock_test_2", ret); - - /* TEST 3: Different ranges, same lk_owner - * lock1 (0, 10, lownera) - already taken - * lock2 (30, 10, lownera) - * Expected: should not fail - */ - ret = lock_test (NULL, fd2, false, 0, 10, lownera, 8, - 30, 10, lownera, 8); - LOG_ERR ("==== glfs_lock_test_3", ret); - - /* TEST 4: Conflicting ranges, different lk_owner - * lock1 (0, 10, lownera) - already taken - * lock2 (50, 10, lownerb) - * Expected: should not fail - */ - ret = lock_test (NULL, fd2, false, 0, 10, lownera, 8, - 50, 10, lownerb, 8); - LOG_ERR ("==== glfs_lock_test_4", ret); - - /* TEST 5: Close fd1 & retry TEST2 - * lock1 (not applicable) - * lock2 (5, 10, lownerb) - * Expected: should succeed now - */ - ret = glfs_close(fd1); - LOG_ERR ("glfs_close", ret); - - ret = lock_test (NULL, fd2, false, 0, 10, lownera, 8, - 5, 10, lownerb, 8); - LOG_ERR ("==== glfs_lock_test_5", ret); - - /* TEST 6: Check closing fd1 doesn't flush fd2 locks - * retry TEST 4 but with fd2 and fd3. - * lock1 (50, 10, lownerb) - already taken - * lock2 (55, 10, lownerc) - * Expected: should fail - */ - ret = lock_test (NULL, fd3, true, 50, 10, lownerb, 8, - 55, 10, lownerc, 8); - LOG_ERR ("==== glfs_lock_test_6", ret); + glfs_t *fs = NULL; + int ret = 0, i, status = 0; + glfs_fd_t *fd1 = NULL; + glfs_fd_t *fd2 = NULL; + glfs_fd_t *fd3 = NULL; + char *filename = "file_tmp"; + char *volname = NULL; + char *logfile = NULL; + char *hostname = NULL; + + if (argc != 4) { + fprintf(stderr, "Invalid argument\n"); + exit(1); + } + + hostname = argv[1]; + volname = argv[2]; + logfile = argv[3]; + + fs = glfs_new(volname); + if (!fs) { + fprintf(stderr, "glfs_new: returned NULL\n"); + return -1; + } + + ret = glfs_set_volfile_server(fs, "tcp", hostname, 24007); + LOG_ERR("glfs_set_volfile_server", ret); + + ret = glfs_set_logging(fs, logfile, 7); + LOG_ERR("glfs_set_logging", ret); + + ret = glfs_init(fs); + LOG_ERR("glfs_init", ret); + + fd1 = glfs_creat(fs, filename, O_RDWR | O_SYNC, 0644); + if (fd1 <= 0) { + ret = -1; + LOG_ERR("glfs_creat", ret); + } + fprintf(stderr, "glfs-create fd1 - %d\n", fd1); + + fd2 = glfs_dup(fd1); + fprintf(stderr, "glfs-dup fd2 - %d\n", fd2); + + fd3 = glfs_open(fs, filename, O_RDWR | O_SYNC); + if (fd2 <= 0) { + ret = -1; + LOG_ERR("glfs_open", ret); + } + fprintf(stderr, "glfs-open fd3 - %d\n", fd3); + + /* TEST 1: Conflicting ranges, same lk_owner + * lock1 (0, 10, lownera) + * lock2 (5, 10, lownera) + * Expected: should not fail but get merged + */ + ret = lock_test(fd1, fd2, false, 0, 10, lownera, 8, 5, 10, lownera, 8); + LOG_ERR("==== glfs_lock_test_1", ret); + + /* TEST 2: Conflicting ranges, different lk_owner + * lock1 (0, 10, lownera) - already taken + * lock2 (5, 10, lownerb) + * Expected: should fail and not get merged + */ + ret = lock_test(NULL, fd2, true, 0, 10, lownera, 8, 5, 10, lownerb, 8); + LOG_ERR("==== glfs_lock_test_2", ret); + + /* TEST 3: Different ranges, same lk_owner + * lock1 (0, 10, lownera) - already taken + * lock2 (30, 10, lownera) + * Expected: should not fail + */ + ret = lock_test(NULL, fd2, false, 0, 10, lownera, 8, 30, 10, lownera, 8); + LOG_ERR("==== glfs_lock_test_3", ret); + + /* TEST 4: Conflicting ranges, different lk_owner + * lock1 (0, 10, lownera) - already taken + * lock2 (50, 10, lownerb) + * Expected: should not fail + */ + ret = lock_test(NULL, fd2, false, 0, 10, lownera, 8, 50, 10, lownerb, 8); + LOG_ERR("==== glfs_lock_test_4", ret); + + /* TEST 5: Close fd1 & retry TEST2 + * lock1 (not applicable) + * lock2 (5, 10, lownerb) + * Expected: should succeed now + */ + ret = glfs_close(fd1); + LOG_ERR("glfs_close", ret); + + ret = lock_test(NULL, fd2, false, 0, 10, lownera, 8, 5, 10, lownerb, 8); + LOG_ERR("==== glfs_lock_test_5", ret); + + /* TEST 6: Check closing fd1 doesn't flush fd2 locks + * retry TEST 4 but with fd2 and fd3. + * lock1 (50, 10, lownerb) - already taken + * lock2 (55, 10, lownerc) + * Expected: should fail + */ + ret = lock_test(NULL, fd3, true, 50, 10, lownerb, 8, 55, 10, lownerc, 8); + LOG_ERR("==== glfs_lock_test_6", ret); err: - ret = glfs_close(fd2); - LOG_ERR ("glfs_close", ret); + ret = glfs_close(fd2); + LOG_ERR("glfs_close", ret); - ret = glfs_close(fd3); - LOG_ERR ("glfs_close", ret); + ret = glfs_close(fd3); + LOG_ERR("glfs_close", ret); out: - if (fs) { - ret = glfs_fini(fs); - fprintf (stderr, "glfs_fini(fs) returned %d\n", ret); - } - - if (ret) - exit(1); - exit(0); + if (fs) { + ret = glfs_fini(fs); + fprintf(stderr, "glfs_fini(fs) returned %d\n", ret); + } + + if (ret) + exit(1); + exit(0); } diff --git a/tests/basic/gfapi/glfs_sysrq.c b/tests/basic/gfapi/glfs_sysrq.c index c843c2a3559..13e06be6df2 100644 --- a/tests/basic/gfapi/glfs_sysrq.c +++ b/tests/basic/gfapi/glfs_sysrq.c @@ -10,52 +10,51 @@ #include <glusterfs/api/glfs.h> int -main (int argc, char *argv[]) +main(int argc, char *argv[]) { - /* cmdline arguments */ - char *host = NULL; - char *volume = NULL; - char *logfile = NULL; - - /* other variables */ - glfs_t *fs = NULL; - int ret = 0; - - if (argc != 4) { - fprintf (stderr, "Usage: %s <host> <volume> <logfile>\n", - argv[0]); - return -1; - } - - host = argv[1]; - volume = argv[2]; - logfile = argv[3]; - - fs = glfs_new (volume); - if (!fs) { - return -1; - } - - ret = glfs_set_logging (fs, logfile, 7); - if (ret < 0) { - return -1; - } - - ret = glfs_set_volfile_server (fs, "tcp", host, 24007); - if (ret < 0) { - return -1; - } - - ret = glfs_init (fs); - if (ret < 0) { - return -1; - } - - /* checking of the results is easier in the script running this test */ - glfs_sysrq (fs, GLFS_SYSRQ_HELP); - glfs_sysrq (fs, GLFS_SYSRQ_STATEDUMP); - - glfs_fini (fs); - - return 0; + /* cmdline arguments */ + char *host = NULL; + char *volume = NULL; + char *logfile = NULL; + + /* other variables */ + glfs_t *fs = NULL; + int ret = 0; + + if (argc != 4) { + fprintf(stderr, "Usage: %s <host> <volume> <logfile>\n", argv[0]); + return -1; + } + + host = argv[1]; + volume = argv[2]; + logfile = argv[3]; + + fs = glfs_new(volume); + if (!fs) { + return -1; + } + + ret = glfs_set_logging(fs, logfile, 7); + if (ret < 0) { + return -1; + } + + ret = glfs_set_volfile_server(fs, "tcp", host, 24007); + if (ret < 0) { + return -1; + } + + ret = glfs_init(fs); + if (ret < 0) { + return -1; + } + + /* checking of the results is easier in the script running this test */ + glfs_sysrq(fs, GLFS_SYSRQ_HELP); + glfs_sysrq(fs, GLFS_SYSRQ_STATEDUMP); + + glfs_fini(fs); + + return 0; } diff --git a/tests/basic/gfapi/glfs_xreaddirplus_r.c b/tests/basic/gfapi/glfs_xreaddirplus_r.c index 17f4d1b1d57..0c4c79123eb 100644 --- a/tests/basic/gfapi/glfs_xreaddirplus_r.c +++ b/tests/basic/gfapi/glfs_xreaddirplus_r.c @@ -6,237 +6,237 @@ #include <glusterfs/api/glfs-handles.h> #include <time.h> -#define VALIDATE_AND_GOTO_LABEL_ON_ERROR(func, ret, label) do { \ - if (ret < 0) { \ - fprintf (stderr, "%s : returned error %d (%s)\n", \ - func, ret, strerror (errno)); \ - goto label; \ - } \ - } while (0) - -#define VALIDATE_BOOL_AND_GOTO_LABEL_ON_ERROR(func, bool_var, ret, label) do { \ - if (!bool_var) { \ - fprintf (stderr, "%s : returned error (%s)\n", \ - func, strerror (errno)); \ - ret = -1; \ - goto label; \ - } \ - } while (0) +#define VALIDATE_AND_GOTO_LABEL_ON_ERROR(func, ret, label) \ + do { \ + if (ret < 0) { \ + fprintf(stderr, "%s : returned error %d (%s)\n", func, ret, \ + strerror(errno)); \ + goto label; \ + } \ + } while (0) + +#define VALIDATE_BOOL_AND_GOTO_LABEL_ON_ERROR(func, bool_var, ret, label) \ + do { \ + if (!bool_var) { \ + fprintf(stderr, "%s : returned error (%s)\n", func, \ + strerror(errno)); \ + ret = -1; \ + goto label; \ + } \ + } while (0) #define MAX_FILES_CREATE 10 -#define MAXPATHNAME 512 +#define MAXPATHNAME 512 void -assimilatetime (struct timespec *ts, struct timespec ts_st, - struct timespec ts_ed) +assimilatetime(struct timespec *ts, struct timespec ts_st, + struct timespec ts_ed) { - if ((ts_ed.tv_nsec - ts_st.tv_nsec) < 0) { - ts->tv_sec += ts_ed.tv_sec - ts_st.tv_sec - 1; - ts->tv_nsec += 1000000000 + ts_ed.tv_nsec - ts_st.tv_nsec; - } else { - ts->tv_sec += ts_ed.tv_sec - ts_st.tv_sec; - ts->tv_nsec += ts_ed.tv_nsec - ts_st.tv_nsec; - } - - if (ts->tv_nsec > 1000000000) { - ts->tv_nsec = ts->tv_nsec - 1000000000; - ts->tv_sec += 1; - } - - return; + if ((ts_ed.tv_nsec - ts_st.tv_nsec) < 0) { + ts->tv_sec += ts_ed.tv_sec - ts_st.tv_sec - 1; + ts->tv_nsec += 1000000000 + ts_ed.tv_nsec - ts_st.tv_nsec; + } else { + ts->tv_sec += ts_ed.tv_sec - ts_st.tv_sec; + ts->tv_nsec += ts_ed.tv_nsec - ts_st.tv_nsec; + } + + if (ts->tv_nsec > 1000000000) { + ts->tv_nsec = ts->tv_nsec - 1000000000; + ts->tv_sec += 1; + } + + return; } /* * Returns '%' difference between ts1 & ts2 */ int -comparetime (struct timespec ts1, struct timespec ts2) +comparetime(struct timespec ts1, struct timespec ts2) { - uint64_t ts1_n, ts2_n; - int pct = 0; + uint64_t ts1_n, ts2_n; + int pct = 0; - ts1_n = (ts1.tv_sec * 1000000000) + ts1.tv_nsec; - ts2_n = (ts2.tv_sec * 1000000000) + ts2.tv_nsec; + ts1_n = (ts1.tv_sec * 1000000000) + ts1.tv_nsec; + ts2_n = (ts2.tv_sec * 1000000000) + ts2.tv_nsec; - pct = ((ts1_n - ts2_n)*100)/ts1_n; + pct = ((ts1_n - ts2_n) * 100) / ts1_n; - return pct; + return pct; } int -old_readdir (glfs_t *fs) +old_readdir(glfs_t *fs) { - struct glfs_object *root = NULL; - struct glfs_fd *fd = NULL; - struct stat *sb = NULL; - char buf[512]; - struct dirent *entry = NULL; - int ret = -1; - struct glfs_object *glhandle = NULL; - - if (!fs) - return -1; - - root = glfs_h_lookupat (fs, NULL, "/", sb, 0); - VALIDATE_BOOL_AND_GOTO_LABEL_ON_ERROR ("glfs_h_lookupat", !!root, ret, out); - - fd = glfs_opendir (fs, "/"); - VALIDATE_BOOL_AND_GOTO_LABEL_ON_ERROR ("glfs_opendir", !!fd, ret, out); - - while (glfs_readdir_r (fd, (struct dirent *)buf, &entry), entry) { - if (strcmp(entry->d_name, ".") && strcmp(entry->d_name, "..")) { - glhandle = glfs_h_lookupat (fs, root, "/", sb, 0); - VALIDATE_BOOL_AND_GOTO_LABEL_ON_ERROR ("glfs_h_lookupat", !!glhandle, ret, out); - } + struct glfs_object *root = NULL; + struct glfs_fd *fd = NULL; + struct stat *sb = NULL; + char buf[512]; + struct dirent *entry = NULL; + int ret = -1; + struct glfs_object *glhandle = NULL; + + if (!fs) + return -1; + + root = glfs_h_lookupat(fs, NULL, "/", sb, 0); + VALIDATE_BOOL_AND_GOTO_LABEL_ON_ERROR("glfs_h_lookupat", !!root, ret, out); + + fd = glfs_opendir(fs, "/"); + VALIDATE_BOOL_AND_GOTO_LABEL_ON_ERROR("glfs_opendir", !!fd, ret, out); + + while (glfs_readdir_r(fd, (struct dirent *)buf, &entry), entry) { + if (strcmp(entry->d_name, ".") && strcmp(entry->d_name, "..")) { + glhandle = glfs_h_lookupat(fs, root, "/", sb, 0); + VALIDATE_BOOL_AND_GOTO_LABEL_ON_ERROR("glfs_h_lookupat", !!glhandle, + ret, out); } + } - glfs_closedir (fd); + glfs_closedir(fd); - ret = 0; + ret = 0; out: - return ret; + return ret; } int -new_xreaddirplus (glfs_t *fs) +new_xreaddirplus(glfs_t *fs) { - struct glfs_fd *fd = NULL; - struct stat *sb = NULL; - int ret = -1; - uint32_t rflags = (GFAPI_XREADDIRP_STAT | - GFAPI_XREADDIRP_HANDLE); - struct glfs_xreaddirp_stat *xstat = NULL; - struct dirent de; - struct dirent *pde = NULL; - struct glfs_object *glhandle = NULL; - - if (!fs) - return -1; - - fd = glfs_opendir (fs, "/"); - VALIDATE_BOOL_AND_GOTO_LABEL_ON_ERROR ("glfs_opendir", !!fd, ret, out); - - ret = glfs_xreaddirplus_r(fd, rflags, &xstat, &de, &pde); - while (ret > 0 && pde != NULL) { - if (xstat) { - sb = glfs_xreaddirplus_get_stat (xstat); - VALIDATE_BOOL_AND_GOTO_LABEL_ON_ERROR ("glfs_xreaddirplus_get_stat", !!sb, ret, out); - - if (strcmp(de.d_name, ".") && strcmp(de.d_name, "..")) { - glhandle = glfs_xreaddirplus_get_object (xstat); - VALIDATE_BOOL_AND_GOTO_LABEL_ON_ERROR ("glfs_xreaddirplus_get_object", !!glhandle, ret, out); - } - } - - if (xstat) { - glfs_free(xstat); - xstat = NULL; - } + struct glfs_fd *fd = NULL; + struct stat *sb = NULL; + int ret = -1; + uint32_t rflags = (GFAPI_XREADDIRP_STAT | GFAPI_XREADDIRP_HANDLE); + struct glfs_xreaddirp_stat *xstat = NULL; + struct dirent de; + struct dirent *pde = NULL; + struct glfs_object *glhandle = NULL; + + if (!fs) + return -1; + + fd = glfs_opendir(fs, "/"); + VALIDATE_BOOL_AND_GOTO_LABEL_ON_ERROR("glfs_opendir", !!fd, ret, out); + + ret = glfs_xreaddirplus_r(fd, rflags, &xstat, &de, &pde); + while (ret > 0 && pde != NULL) { + if (xstat) { + sb = glfs_xreaddirplus_get_stat(xstat); + VALIDATE_BOOL_AND_GOTO_LABEL_ON_ERROR("glfs_xreaddirplus_get_stat", + !!sb, ret, out); + + if (strcmp(de.d_name, ".") && strcmp(de.d_name, "..")) { + glhandle = glfs_xreaddirplus_get_object(xstat); + VALIDATE_BOOL_AND_GOTO_LABEL_ON_ERROR( + "glfs_xreaddirplus_get_object", !!glhandle, ret, out); + } + } - ret = glfs_xreaddirplus_r(fd, rflags, &xstat, &de, &pde); + if (xstat) { + glfs_free(xstat); + xstat = NULL; + } - VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_xreaddirp_r", ret, out); + ret = glfs_xreaddirplus_r(fd, rflags, &xstat, &de, &pde); - } + VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_xreaddirp_r", ret, out); + } - if (xstat) - glfs_free(xstat); + if (xstat) + glfs_free(xstat); - ret = 0; + ret = 0; out: - return ret; + return ret; } int -main (int argc, char *argv[]) +main(int argc, char *argv[]) { - int ret = -1; - glfs_t *fs = NULL; - char *volname = NULL; - char *logfile = NULL; - char *hostname = NULL; - char *my_file = "file_"; - char my_file_name[MAXPATHNAME]; - uint32_t flags = O_RDWR|O_SYNC; - struct glfs_fd *fd = NULL; - int i = 0; - int pct = 0; - struct timespec timestamp = {0, 0}, st_timestamp, ed_timestamp; - struct timespec otimestamp = {0, 0}, ost_timestamp, oed_timestamp; - - if (argc != 4) { - fprintf (stderr, "Invalid argument\n"); - return 1; - } + int ret = -1; + glfs_t *fs = NULL; + char *volname = NULL; + char *logfile = NULL; + char *hostname = NULL; + char *my_file = "file_"; + char my_file_name[MAXPATHNAME]; + uint32_t flags = O_RDWR | O_SYNC; + struct glfs_fd *fd = NULL; + int i = 0; + int pct = 0; + struct timespec timestamp = {0, 0}, st_timestamp, ed_timestamp; + struct timespec otimestamp = {0, 0}, ost_timestamp, oed_timestamp; - hostname = argv[1]; - volname = argv[2]; - logfile = argv[3]; + if (argc != 4) { + fprintf(stderr, "Invalid argument\n"); + return 1; + } - fs = glfs_new (volname); - VALIDATE_BOOL_AND_GOTO_LABEL_ON_ERROR ("glfs_new", !!fs, ret, out); + hostname = argv[1]; + volname = argv[2]; + logfile = argv[3]; - ret = glfs_set_volfile_server (fs, "tcp", hostname, 24007); - VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_set_volfile_server", ret, out); + fs = glfs_new(volname); + VALIDATE_BOOL_AND_GOTO_LABEL_ON_ERROR("glfs_new", !!fs, ret, out); - ret = glfs_set_logging (fs, logfile, 7); - VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_set_logging", ret, out); + ret = glfs_set_volfile_server(fs, "tcp", hostname, 24007); + VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_set_volfile_server", ret, out); - ret = glfs_init (fs); - VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_init", ret, out); + ret = glfs_set_logging(fs, logfile, 7); + VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_set_logging", ret, out); - for (i = 0; i < MAX_FILES_CREATE; i++) { - sprintf (my_file_name, "%s%d", my_file, i); + ret = glfs_init(fs); + VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_init", ret, out); - fd = glfs_creat(fs, my_file_name, flags, 0644); - VALIDATE_BOOL_AND_GOTO_LABEL_ON_ERROR ("glfs_creat", !!fd, ret, out); + for (i = 0; i < MAX_FILES_CREATE; i++) { + sprintf(my_file_name, "%s%d", my_file, i); - glfs_close (fd); - } + fd = glfs_creat(fs, my_file_name, flags, 0644); + VALIDATE_BOOL_AND_GOTO_LABEL_ON_ERROR("glfs_creat", !!fd, ret, out); - /* measure performance using old readdir call and new xreaddirplus call and compare */ - ret = clock_gettime (CLOCK_REALTIME, &ost_timestamp); - VALIDATE_AND_GOTO_LABEL_ON_ERROR ("clock_gettime", ret, out); + glfs_close(fd); + } - ret = old_readdir (fs); - VALIDATE_AND_GOTO_LABEL_ON_ERROR ("old_readdir", ret, out); + /* measure performance using old readdir call and new xreaddirplus call and + * compare */ + ret = clock_gettime(CLOCK_REALTIME, &ost_timestamp); + VALIDATE_AND_GOTO_LABEL_ON_ERROR("clock_gettime", ret, out); - ret = clock_gettime (CLOCK_REALTIME, &oed_timestamp); - VALIDATE_AND_GOTO_LABEL_ON_ERROR ("clock_gettime", ret, out); + ret = old_readdir(fs); + VALIDATE_AND_GOTO_LABEL_ON_ERROR("old_readdir", ret, out); - assimilatetime (&otimestamp, ost_timestamp, oed_timestamp); + ret = clock_gettime(CLOCK_REALTIME, &oed_timestamp); + VALIDATE_AND_GOTO_LABEL_ON_ERROR("clock_gettime", ret, out); - printf ("\tOverall time using readdir:\n\t\tSecs:%ld\n\t\tnSecs:%ld\n", - otimestamp.tv_sec, otimestamp.tv_nsec); + assimilatetime(&otimestamp, ost_timestamp, oed_timestamp); + printf("\tOverall time using readdir:\n\t\tSecs:%ld\n\t\tnSecs:%ld\n", + otimestamp.tv_sec, otimestamp.tv_nsec); - ret = clock_gettime (CLOCK_REALTIME, &st_timestamp); - VALIDATE_AND_GOTO_LABEL_ON_ERROR ("clock_gettime", ret, out); + ret = clock_gettime(CLOCK_REALTIME, &st_timestamp); + VALIDATE_AND_GOTO_LABEL_ON_ERROR("clock_gettime", ret, out); - ret = new_xreaddirplus (fs); - VALIDATE_AND_GOTO_LABEL_ON_ERROR ("new_xreaddirplus", ret, out); + ret = new_xreaddirplus(fs); + VALIDATE_AND_GOTO_LABEL_ON_ERROR("new_xreaddirplus", ret, out); - ret = clock_gettime (CLOCK_REALTIME, &ed_timestamp); - VALIDATE_AND_GOTO_LABEL_ON_ERROR ("clock_gettime", ret, out); + ret = clock_gettime(CLOCK_REALTIME, &ed_timestamp); + VALIDATE_AND_GOTO_LABEL_ON_ERROR("clock_gettime", ret, out); - assimilatetime (×tamp, st_timestamp, ed_timestamp); + assimilatetime(×tamp, st_timestamp, ed_timestamp); - printf ("\tOverall time using xreaddirplus:\n\t\tSecs:%ld\n\t\tnSecs:%ld\n", - timestamp.tv_sec, timestamp.tv_nsec); + printf("\tOverall time using xreaddirplus:\n\t\tSecs:%ld\n\t\tnSecs:%ld\n", + timestamp.tv_sec, timestamp.tv_nsec); + pct = comparetime(otimestamp, timestamp); + printf("There is improvement by %d%%\n", pct); - pct = comparetime (otimestamp, timestamp); - printf ("There is improvement by %d%%\n", pct); - - ret = 0; + ret = 0; out: - if (fs) { - ret = glfs_fini(fs); - if (ret) - fprintf (stderr, "glfs_fini(fs) returned %d\n", ret); - } + if (fs) { + ret = glfs_fini(fs); + if (ret) + fprintf(stderr, "glfs_fini(fs) returned %d\n", ret); + } - return ret; + return ret; } - - diff --git a/tests/basic/gfapi/libgfapi-fini-hang.c b/tests/basic/gfapi/libgfapi-fini-hang.c index e192751f295..37800e3188b 100644 --- a/tests/basic/gfapi/libgfapi-fini-hang.c +++ b/tests/basic/gfapi/libgfapi-fini-hang.c @@ -8,56 +8,55 @@ #include <glusterfs/api/glfs.h> #include <glusterfs/api/glfs-handles.h> -#define LOG_ERR(func, ret) do { \ - if (ret != 0) { \ - fprintf (stderr, "%s : returned error %d\n", func, ret); \ - exit(1); \ - } else { \ - fprintf (stderr, "%s : returned %d\n", func, ret); \ - } \ -} while (0) +#define LOG_ERR(func, ret) \ + do { \ + if (ret != 0) { \ + fprintf(stderr, "%s : returned error %d\n", func, ret); \ + exit(1); \ + } else { \ + fprintf(stderr, "%s : returned %d\n", func, ret); \ + } \ + } while (0) int -main (int argc, char *argv[]) +main(int argc, char *argv[]) { - glfs_t *fs = NULL; - int ret = 0, i; - glfs_fd_t *fd = NULL; - char readbuf[32]; - char *logname = NULL; - char *hostname = NULL; - char *volname = NULL; - - fprintf (stderr, "Starting libgfapi_fini\n"); - - if (argc < 4) { - fprintf (stderr, "Invalid argument\n"); - exit(1); - } - - hostname = argv[1]; - volname = argv[2]; - logname = argv[3]; - - fs = glfs_new (volname); - if (!fs) { - fprintf (stderr, "glfs_new: returned NULL\n"); - exit(1); - } - - ret = glfs_set_volfile_server (fs, "tcp", hostname, 0); - LOG_ERR("glfs_set_volfile_server", ret); - - ret = glfs_set_logging (fs, logname, 7); - LOG_ERR("glfs_set_logging", ret); - - /* Do not call glfs_init. - * glfs_fini() shouldn't hang in that case*/ - ret = glfs_fini(fs); - LOG_ERR("glfs_fini", ret); - fprintf (stderr, "End of libgfapi_fini\n"); - - exit(0); + glfs_t *fs = NULL; + int ret = 0, i; + glfs_fd_t *fd = NULL; + char readbuf[32]; + char *logname = NULL; + char *hostname = NULL; + char *volname = NULL; + + fprintf(stderr, "Starting libgfapi_fini\n"); + + if (argc < 4) { + fprintf(stderr, "Invalid argument\n"); + exit(1); + } + + hostname = argv[1]; + volname = argv[2]; + logname = argv[3]; + + fs = glfs_new(volname); + if (!fs) { + fprintf(stderr, "glfs_new: returned NULL\n"); + exit(1); + } + + ret = glfs_set_volfile_server(fs, "tcp", hostname, 0); + LOG_ERR("glfs_set_volfile_server", ret); + + ret = glfs_set_logging(fs, logname, 7); + LOG_ERR("glfs_set_logging", ret); + + /* Do not call glfs_init. + * glfs_fini() shouldn't hang in that case*/ + ret = glfs_fini(fs); + LOG_ERR("glfs_fini", ret); + fprintf(stderr, "End of libgfapi_fini\n"); + + exit(0); } - - diff --git a/tests/basic/gfapi/mandatory-lock-optimal.c b/tests/basic/gfapi/mandatory-lock-optimal.c index 4142258c06d..34fef8d0b80 100644 --- a/tests/basic/gfapi/mandatory-lock-optimal.c +++ b/tests/basic/gfapi/mandatory-lock-optimal.c @@ -1,11 +1,13 @@ /* Pre-requisites:- * - * 1. Make sure that performance translators are switched off while running this test. + * 1. Make sure that performance translators are switched off while running this + * test. * 2. Perform the following volume set operation: * # gluster volume set <VOLNAME> locks.mandatory-locking optimal * 3. For installation under non-standard paths, export LD_LIBRARY_PATH to * automatically load exact libgfapi.so and compile this C file as follows: - * $ gcc mandatory-lock-optimal.c -lgfapi -I <include path for api/glfs.h> -L <include path for libgfapi shared library> + * $ gcc mandatory-lock-optimal.c -lgfapi -I <include path for api/glfs.h> -L + * <include path for libgfapi shared library> */ #include <errno.h> @@ -70,434 +72,461 @@ off_t offset; Expected result : First write should fail with EAGAIN. Second write should pass. */ -#define LOG_ERR(func, err) do { \ - if (!fp) \ - fprintf (stderr, "\n%s : returned error (%s)\n", func, strerror (err)); \ - else \ - fprintf (fp, "\n%s : returned error (%s)\n", func, strerror (err)); \ - cleanup_and_exit (err); \ -} while (0) - -void cleanup_and_exit (int exit_status) { - if (exit_status || test_count != TOTAL_TEST_COUNT) { - fprintf (fp, "\nAborting due to some test failures.\n"); - exit_status = 1; - } else - fprintf (fp, "\nAll tests ran successfully.\n"); - if (fp) - fclose (fp); - if (fd) - glfs_close (fd); - if (fd1) - glfs_close (fd1); - if (fd2) - glfs_close (fd2); - - glfs_unlink (fs1, fname); - - if (fs1) - glfs_fini (fs1); - if (fs2) - glfs_fini (fs2); - - exit (exit_status); +#define LOG_ERR(func, err) \ + do { \ + if (!fp) \ + fprintf(stderr, "\n%s : returned error (%s)\n", func, \ + strerror(err)); \ + else \ + fprintf(fp, "\n%s : returned error (%s)\n", func, strerror(err)); \ + cleanup_and_exit(err); \ + } while (0) + +void +cleanup_and_exit(int exit_status) +{ + if (exit_status || test_count != TOTAL_TEST_COUNT) { + fprintf(fp, "\nAborting due to some test failures.\n"); + exit_status = 1; + } else + fprintf(fp, "\nAll tests ran successfully.\n"); + if (fp) + fclose(fp); + if (fd) + glfs_close(fd); + if (fd1) + glfs_close(fd1); + if (fd2) + glfs_close(fd2); + + glfs_unlink(fs1, fname); + + if (fs1) + glfs_fini(fs1); + if (fs2) + glfs_fini(fs2); + + exit(exit_status); } -glfs_t *new_client_create (char *hostname, char *volname, char *logfile_name) { - glfs_t *fs = NULL; +glfs_t * +new_client_create(char *hostname, char *volname, char *logfile_name) +{ + glfs_t *fs = NULL; - fs = glfs_new (volname); - if (!fs) - LOG_ERR ("glfs_new", errno); + fs = glfs_new(volname); + if (!fs) + LOG_ERR("glfs_new", errno); - ret = glfs_set_volfile_server (fs, "tcp", hostname, 24007); - if (ret) - LOG_ERR ("glfs_set_volfile_server", errno); + ret = glfs_set_volfile_server(fs, "tcp", hostname, 24007); + if (ret) + LOG_ERR("glfs_set_volfile_server", errno); - ret = glfs_set_logging (fs, logfile_name, 7); - if (ret) - LOG_ERR ("glfs_set_logging", errno); + ret = glfs_set_logging(fs, logfile_name, 7); + if (ret) + LOG_ERR("glfs_set_logging", errno); - ret = glfs_init (fs); - if (ret) - LOG_ERR ("glfs_init", errno); + ret = glfs_init(fs); + if (ret) + LOG_ERR("glfs_init", errno); - return fs; + return fs; } -void run_test_1 (int i) { - fprintf (fp, "\nRunning Test-%d . . . ", i); - - fd1 = glfs_open (fs1, fname, O_RDONLY | O_NONBLOCK); - if (!fd1) - LOG_ERR ("glfs_open", errno); - - lock.l_type = F_RDLCK; - lock.l_whence = SEEK_SET; - lock.l_start = 0L; - lock.l_len = 5L; - - ret = glfs_file_lock (fd1, F_SETLK, &lock, GLFS_LK_MANDATORY); - if (ret) - LOG_ERR ("glfs_file_lock", errno); - - fd2 = glfs_open (fs2, fname, O_RDONLY | O_NONBLOCK); - if (!fd2) - LOG_ERR ("glfs_open", errno); - - /* On successful read, 0 is returned as there is no content inside the - * file - */ - ret = glfs_read (fd2, buf1, 10, 0); - if (ret) - LOG_ERR ("glfs_read", errno); - - ret = glfs_close (fd1); - if (ret) - LOG_ERR ("glfs_close", errno); - fd1 = NULL; - - ret = glfs_close (fd2); - if (ret) - LOG_ERR ("glfs_close", errno); - fd2 = NULL; - - test_count++; - fprintf (fp, "OK\n", i); +void +run_test_1(int i) +{ + fprintf(fp, "\nRunning Test-%d . . . ", i); + + fd1 = glfs_open(fs1, fname, O_RDONLY | O_NONBLOCK); + if (!fd1) + LOG_ERR("glfs_open", errno); + + lock.l_type = F_RDLCK; + lock.l_whence = SEEK_SET; + lock.l_start = 0L; + lock.l_len = 5L; + + ret = glfs_file_lock(fd1, F_SETLK, &lock, GLFS_LK_MANDATORY); + if (ret) + LOG_ERR("glfs_file_lock", errno); + + fd2 = glfs_open(fs2, fname, O_RDONLY | O_NONBLOCK); + if (!fd2) + LOG_ERR("glfs_open", errno); + + /* On successful read, 0 is returned as there is no content inside the + * file + */ + ret = glfs_read(fd2, buf1, 10, 0); + if (ret) + LOG_ERR("glfs_read", errno); + + ret = glfs_close(fd1); + if (ret) + LOG_ERR("glfs_close", errno); + fd1 = NULL; + + ret = glfs_close(fd2); + if (ret) + LOG_ERR("glfs_close", errno); + fd2 = NULL; + + test_count++; + fprintf(fp, "OK\n", i); } -void run_test_2 (int i) { - fprintf (fp, "\nRunning Test-%d . . . ", i); +void +run_test_2(int i) +{ + fprintf(fp, "\nRunning Test-%d . . . ", i); - fd1 = glfs_open (fs1, fname, O_RDONLY | O_NONBLOCK); - if (!fd1) - LOG_ERR ("glfs_open", errno); + fd1 = glfs_open(fs1, fname, O_RDONLY | O_NONBLOCK); + if (!fd1) + LOG_ERR("glfs_open", errno); - lock.l_type = F_RDLCK; - lock.l_whence = SEEK_SET; - lock.l_start = 0L; - lock.l_len = 5L; + lock.l_type = F_RDLCK; + lock.l_whence = SEEK_SET; + lock.l_start = 0L; + lock.l_len = 5L; - ret = glfs_file_lock (fd1, F_SETLK, &lock, GLFS_LK_MANDATORY); - if (ret) - LOG_ERR ("glfs_file_lock", errno); + ret = glfs_file_lock(fd1, F_SETLK, &lock, GLFS_LK_MANDATORY); + if (ret) + LOG_ERR("glfs_file_lock", errno); - fd2 = glfs_open (fs2, fname, O_WRONLY | O_NONBLOCK); - if (!fd2) - LOG_ERR ("glfs_open", errno); + fd2 = glfs_open(fs2, fname, O_WRONLY | O_NONBLOCK); + if (!fd2) + LOG_ERR("glfs_open", errno); - ret = glfs_write (fd2, buf2, 10, 0); - if (ret == 10 || errno != EAGAIN) - LOG_ERR ("glfs_write", errno); + ret = glfs_write(fd2, buf2, 10, 0); + if (ret == 10 || errno != EAGAIN) + LOG_ERR("glfs_write", errno); - ret = glfs_close (fd1); - if (ret) - LOG_ERR ("glfs_close", errno); - fd1 = NULL; + ret = glfs_close(fd1); + if (ret) + LOG_ERR("glfs_close", errno); + fd1 = NULL; - ret = glfs_close (fd2); - if (ret) - LOG_ERR ("glfs_close", errno); - fd2 = NULL; + ret = glfs_close(fd2); + if (ret) + LOG_ERR("glfs_close", errno); + fd2 = NULL; - test_count++; - fprintf (fp, "OK\n", i); + test_count++; + fprintf(fp, "OK\n", i); } -void run_test_3 (int i) { - fprintf (fp, "\nRunning Test-%d . . . ", i); - - fd1 = glfs_open (fs1, fname, O_WRONLY | O_NONBLOCK); - if (!fd1) - LOG_ERR ("glfs_open", errno); - - lock.l_type = F_WRLCK; - lock.l_whence = SEEK_SET; - lock.l_start = 0L; - lock.l_len = 5L; - - ret = glfs_file_lock (fd1, F_SETLK, &lock, GLFS_LK_ADVISORY); - if (ret) - LOG_ERR ("glfs_file_lock", errno); - - fd2 = glfs_open (fs2, fname, O_RDONLY | O_NONBLOCK); - if (!fd2) - LOG_ERR ("glfs_open", errno); - - /* Still there is no content inside file. So following read should - * return 0 - */ - ret = glfs_read (fd2, buf1, 10, 0); - if (ret) - LOG_ERR ("glfs_read", errno); - - ret = glfs_close (fd1); - if (ret) - LOG_ERR ("glfs_close", errno); - fd1 = NULL; - - ret = glfs_close (fd2); - if (ret) - LOG_ERR ("glfs_close", errno); - fd2 = NULL; - - test_count++; - fprintf (fp, "OK\n", i); +void +run_test_3(int i) +{ + fprintf(fp, "\nRunning Test-%d . . . ", i); + + fd1 = glfs_open(fs1, fname, O_WRONLY | O_NONBLOCK); + if (!fd1) + LOG_ERR("glfs_open", errno); + + lock.l_type = F_WRLCK; + lock.l_whence = SEEK_SET; + lock.l_start = 0L; + lock.l_len = 5L; + + ret = glfs_file_lock(fd1, F_SETLK, &lock, GLFS_LK_ADVISORY); + if (ret) + LOG_ERR("glfs_file_lock", errno); + + fd2 = glfs_open(fs2, fname, O_RDONLY | O_NONBLOCK); + if (!fd2) + LOG_ERR("glfs_open", errno); + + /* Still there is no content inside file. So following read should + * return 0 + */ + ret = glfs_read(fd2, buf1, 10, 0); + if (ret) + LOG_ERR("glfs_read", errno); + + ret = glfs_close(fd1); + if (ret) + LOG_ERR("glfs_close", errno); + fd1 = NULL; + + ret = glfs_close(fd2); + if (ret) + LOG_ERR("glfs_close", errno); + fd2 = NULL; + + test_count++; + fprintf(fp, "OK\n", i); } -void run_test_4 (int i) { - fprintf (fp, "\nRunning Test-%d . . . ", i); +void +run_test_4(int i) +{ + fprintf(fp, "\nRunning Test-%d . . . ", i); - fd1 = glfs_open (fs1, fname, O_WRONLY | O_NONBLOCK); - if (!fd1) - LOG_ERR ("glfs_open", errno); + fd1 = glfs_open(fs1, fname, O_WRONLY | O_NONBLOCK); + if (!fd1) + LOG_ERR("glfs_open", errno); - lock.l_type = F_WRLCK; - lock.l_whence = SEEK_SET; - lock.l_start = 0L; - lock.l_len = 5L; + lock.l_type = F_WRLCK; + lock.l_whence = SEEK_SET; + lock.l_start = 0L; + lock.l_len = 5L; - ret = glfs_file_lock (fd1, F_SETLK, &lock, GLFS_LK_ADVISORY); - if (ret) - LOG_ERR ("glfs_file_lock", errno); + ret = glfs_file_lock(fd1, F_SETLK, &lock, GLFS_LK_ADVISORY); + if (ret) + LOG_ERR("glfs_file_lock", errno); - fd2 = glfs_open (fs2, fname, O_WRONLY | O_NONBLOCK); - if (!fd2) - LOG_ERR ("glfs_open", errno); + fd2 = glfs_open(fs2, fname, O_WRONLY | O_NONBLOCK); + if (!fd2) + LOG_ERR("glfs_open", errno); - ret = glfs_write (fd2, buf2, 10, 0); - if (ret != 10) - LOG_ERR ("glfs_write", errno); + ret = glfs_write(fd2, buf2, 10, 0); + if (ret != 10) + LOG_ERR("glfs_write", errno); - ret = glfs_close (fd1); - if (ret) - LOG_ERR ("glfs_close", errno); - fd1 = NULL; + ret = glfs_close(fd1); + if (ret) + LOG_ERR("glfs_close", errno); + fd1 = NULL; - ret = glfs_close (fd2); - if (ret) - LOG_ERR ("glfs_close", errno); - fd2 = NULL; + ret = glfs_close(fd2); + if (ret) + LOG_ERR("glfs_close", errno); + fd2 = NULL; - test_count++; - fprintf (fp, "OK\n", i); + test_count++; + fprintf(fp, "OK\n", i); } -void run_test_5 (int i) { - fprintf (fp, "\nRunning Test-%d . . . ", i); +void +run_test_5(int i) +{ + fprintf(fp, "\nRunning Test-%d . . . ", i); - fd1 = glfs_open (fs1, fname, O_RDONLY | O_NONBLOCK); - if (!fd1) - LOG_ERR ("glfs_open", errno); + fd1 = glfs_open(fs1, fname, O_RDONLY | O_NONBLOCK); + if (!fd1) + LOG_ERR("glfs_open", errno); - lock.l_type = F_RDLCK; - lock.l_whence = SEEK_SET; - lock.l_start = 0L; - lock.l_len = 5L; + lock.l_type = F_RDLCK; + lock.l_whence = SEEK_SET; + lock.l_start = 0L; + lock.l_len = 5L; - ret = glfs_file_lock (fd1, F_SETLK, &lock, GLFS_LK_ADVISORY); - if (ret) - LOG_ERR ("glfs_file_lock", errno); + ret = glfs_file_lock(fd1, F_SETLK, &lock, GLFS_LK_ADVISORY); + if (ret) + LOG_ERR("glfs_file_lock", errno); - fd2 = glfs_open (fs2, fname, O_RDONLY | O_NONBLOCK | O_TRUNC); - if (!fd2) - LOG_ERR ("glfs_open", errno); + fd2 = glfs_open(fs2, fname, O_RDONLY | O_NONBLOCK | O_TRUNC); + if (!fd2) + LOG_ERR("glfs_open", errno); - ret = glfs_close (fd1); - if (ret) - LOG_ERR ("glfs_close", errno); - fd1 = NULL; + ret = glfs_close(fd1); + if (ret) + LOG_ERR("glfs_close", errno); + fd1 = NULL; - ret = glfs_close (fd2); - if (ret) - LOG_ERR ("glfs_close", errno); - fd2 = NULL; + ret = glfs_close(fd2); + if (ret) + LOG_ERR("glfs_close", errno); + fd2 = NULL; - test_count++; - fprintf (fp, "OK\n", i); + test_count++; + fprintf(fp, "OK\n", i); } -void run_test_6 (int i) { - fprintf (fp, "\nRunning Test-%d . . . ", i); +void +run_test_6(int i) +{ + fprintf(fp, "\nRunning Test-%d . . . ", i); - fd1 = glfs_open (fs1, fname, O_RDONLY | O_NONBLOCK); - if (!fd1) - LOG_ERR ("glfs_open", errno); + fd1 = glfs_open(fs1, fname, O_RDONLY | O_NONBLOCK); + if (!fd1) + LOG_ERR("glfs_open", errno); - lock.l_type = F_RDLCK; - lock.l_whence = SEEK_SET; - lock.l_start = 0L; - lock.l_len = 5L; + lock.l_type = F_RDLCK; + lock.l_whence = SEEK_SET; + lock.l_start = 0L; + lock.l_len = 5L; - ret = glfs_file_lock (fd1, F_SETLK, &lock, GLFS_LK_MANDATORY); - if (ret) - LOG_ERR ("glfs_file_lock", errno); + ret = glfs_file_lock(fd1, F_SETLK, &lock, GLFS_LK_MANDATORY); + if (ret) + LOG_ERR("glfs_file_lock", errno); - fd2 = glfs_open (fs2, fname, O_RDONLY | O_NONBLOCK | O_TRUNC); - if (fd2) - LOG_ERR ("glfs_open", errno); + fd2 = glfs_open(fs2, fname, O_RDONLY | O_NONBLOCK | O_TRUNC); + if (fd2) + LOG_ERR("glfs_open", errno); - ret = glfs_close (fd1); - if (ret) - LOG_ERR ("glfs_close", errno); - fd1 = NULL; + ret = glfs_close(fd1); + if (ret) + LOG_ERR("glfs_close", errno); + fd1 = NULL; - test_count++; - fprintf (fp, "OK\n", i); + test_count++; + fprintf(fp, "OK\n", i); } -void run_test_7 (int i) { - fprintf (fp, "\nRunning Test-%d . . . ", i); +void +run_test_7(int i) +{ + fprintf(fp, "\nRunning Test-%d . . . ", i); - fd1 = glfs_open (fs1, fname, O_RDONLY | O_NONBLOCK); - if (!fd1) - LOG_ERR ("glfs_open", errno); + fd1 = glfs_open(fs1, fname, O_RDONLY | O_NONBLOCK); + if (!fd1) + LOG_ERR("glfs_open", errno); - lock.l_type = F_RDLCK; - lock.l_whence = SEEK_SET; - lock.l_start = 0L; - lock.l_len = 5L; + lock.l_type = F_RDLCK; + lock.l_whence = SEEK_SET; + lock.l_start = 0L; + lock.l_len = 5L; - ret = glfs_file_lock (fd1, F_SETLK, &lock, GLFS_LK_MANDATORY); - if (ret) - LOG_ERR ("glfs_file_lock", errno); + ret = glfs_file_lock(fd1, F_SETLK, &lock, GLFS_LK_MANDATORY); + if (ret) + LOG_ERR("glfs_file_lock", errno); - fd2 = glfs_open (fs2, fname, O_RDWR | O_NONBLOCK); - if (!fd2) - LOG_ERR ("glfs_open", errno); + fd2 = glfs_open(fs2, fname, O_RDWR | O_NONBLOCK); + if (!fd2) + LOG_ERR("glfs_open", errno); - ret = glfs_ftruncate (fd2, 4, NULL, NULL); - if (ret == 0 || errno != EAGAIN) - LOG_ERR ("glfs_ftruncate", errno); + ret = glfs_ftruncate(fd2, 4, NULL, NULL); + if (ret == 0 || errno != EAGAIN) + LOG_ERR("glfs_ftruncate", errno); - ret = glfs_close (fd1); - if (ret) - LOG_ERR ("glfs_close", errno); - fd1 = NULL; + ret = glfs_close(fd1); + if (ret) + LOG_ERR("glfs_close", errno); + fd1 = NULL; - ret = glfs_close (fd2); - if (ret) - LOG_ERR ("glfs_close", errno); - fd2 = NULL; + ret = glfs_close(fd2); + if (ret) + LOG_ERR("glfs_close", errno); + fd2 = NULL; - test_count++; - fprintf (fp, "OK\n", i); + test_count++; + fprintf(fp, "OK\n", i); } -void run_test_8 (int i) { - fprintf (fp, "\nRunning Test-%d . . . ", i); - - fd1 = glfs_open (fs1, fname, O_RDONLY | O_NONBLOCK); - if (!fd1) - LOG_ERR ("glfs_open", errno); - - lock.l_type = F_RDLCK; - lock.l_whence = SEEK_SET; - lock.l_start = 0L; - lock.l_len = 10L; - - ret = glfs_file_lock (fd1, F_SETLK, &lock, GLFS_LK_ADVISORY); - if (ret) - LOG_ERR ("glfs_file_lock", errno); - - fd2 = glfs_open (fs2, fname, O_RDONLY | O_NONBLOCK); - if (!fd2) - LOG_ERR ("glfs_open", errno); - - lock.l_type = F_RDLCK; - lock.l_whence = SEEK_SET; - lock.l_start = 5L; - lock.l_len = 2L; - - ret = glfs_file_lock (fd2, F_SETLK, &lock, GLFS_LK_MANDATORY); - if (ret) - LOG_ERR ("glfs_file_lock", errno); - - fd3 = glfs_open (fs3, fname, O_RDWR | O_NONBLOCK); - if (!fd3) - LOG_ERR ("glfs_open", errno); - - offset = glfs_lseek (fd3, 5L, SEEK_SET); - if (offset != 5) - LOG_ERR ("glfs_lseek", errno); - - ret = glfs_write (fd3, buf2, 10, 0); - if (ret == 10 || errno != EAGAIN) - LOG_ERR ("glfs_write", errno); - - offset = glfs_lseek (fd3, 8L, SEEK_SET); - if (offset != 8) - LOG_ERR ("glfs_lseek", errno); - - ret = glfs_write (fd3, buf2, 10, 0); - if (ret != 10) - LOG_ERR ("glfs_write", errno); - - ret = glfs_close (fd1); - if (ret) - LOG_ERR ("glfs_close", errno); - fd1 = NULL; - - ret = glfs_close (fd2); - if (ret) - LOG_ERR ("glfs_close", errno); - fd2 = NULL; - - ret = glfs_close (fd3); - if (ret) - LOG_ERR ("glfs_close", errno); - fd3 = NULL; - - test_count++; - fprintf (fp, "OK\n", i); +void +run_test_8(int i) +{ + fprintf(fp, "\nRunning Test-%d . . . ", i); + + fd1 = glfs_open(fs1, fname, O_RDONLY | O_NONBLOCK); + if (!fd1) + LOG_ERR("glfs_open", errno); + + lock.l_type = F_RDLCK; + lock.l_whence = SEEK_SET; + lock.l_start = 0L; + lock.l_len = 10L; + + ret = glfs_file_lock(fd1, F_SETLK, &lock, GLFS_LK_ADVISORY); + if (ret) + LOG_ERR("glfs_file_lock", errno); + + fd2 = glfs_open(fs2, fname, O_RDONLY | O_NONBLOCK); + if (!fd2) + LOG_ERR("glfs_open", errno); + + lock.l_type = F_RDLCK; + lock.l_whence = SEEK_SET; + lock.l_start = 5L; + lock.l_len = 2L; + + ret = glfs_file_lock(fd2, F_SETLK, &lock, GLFS_LK_MANDATORY); + if (ret) + LOG_ERR("glfs_file_lock", errno); + + fd3 = glfs_open(fs3, fname, O_RDWR | O_NONBLOCK); + if (!fd3) + LOG_ERR("glfs_open", errno); + + offset = glfs_lseek(fd3, 5L, SEEK_SET); + if (offset != 5) + LOG_ERR("glfs_lseek", errno); + + ret = glfs_write(fd3, buf2, 10, 0); + if (ret == 10 || errno != EAGAIN) + LOG_ERR("glfs_write", errno); + + offset = glfs_lseek(fd3, 8L, SEEK_SET); + if (offset != 8) + LOG_ERR("glfs_lseek", errno); + + ret = glfs_write(fd3, buf2, 10, 0); + if (ret != 10) + LOG_ERR("glfs_write", errno); + + ret = glfs_close(fd1); + if (ret) + LOG_ERR("glfs_close", errno); + fd1 = NULL; + + ret = glfs_close(fd2); + if (ret) + LOG_ERR("glfs_close", errno); + fd2 = NULL; + + ret = glfs_close(fd3); + if (ret) + LOG_ERR("glfs_close", errno); + fd3 = NULL; + + test_count++; + fprintf(fp, "OK\n", i); } -int main (int argc, char *argv[]) { - char logfile[50]; - - if (argc != 4) { - fprintf (stderr, "Usage: %s <server ip/hostname> <volume name> <test log directory>\n", argv[0]); - return 0; - } - - sprintf (logfile, "%s/%s", argv[3], "mandatory-lock-optimal-test.log"); - fp = fopen (logfile, "w"); - if (!fp) { - fprintf (stderr, "\n%s\n", logfile); - LOG_ERR ("Log file creation", errno); - } - - sprintf (logfile, "%s/%s", argv[3], "glfs-client-1.log"); - fs1 = new_client_create (argv[1], argv[2], logfile); - if (!fs1) - LOG_ERR ("client-1 creation", EINVAL); - - sprintf (logfile, "%s/%s", argv[3], "glfs-client-2.log"); - fs2 = new_client_create (argv[1], argv[2], logfile); - if (!fs2) - LOG_ERR ("client-2 creation", EINVAL); - - sprintf (logfile, "%s/%s", argv[3], "glfs-client-3.log"); - fs3 = new_client_create (argv[1], argv[2], logfile); - if (!fs3) - LOG_ERR ("client-3 creation", EINVAL); - - fd = glfs_creat (fs1, fname, O_RDWR, 0644); - if (!fd) - LOG_ERR ("glfs_creat", errno); - - test_count = 0; - - run_test_1 (1); - run_test_2 (2); - run_test_3 (3); - run_test_4 (4); - run_test_5 (5); - run_test_6 (6); - run_test_7 (7); - run_test_8 (8); - - cleanup_and_exit (0); +int +main(int argc, char *argv[]) +{ + char logfile[50]; + if (argc != 4) { + fprintf(stderr, + "Usage: %s <server ip/hostname> <volume name> <test log " + "directory>\n", + argv[0]); return 0; + } + + sprintf(logfile, "%s/%s", argv[3], "mandatory-lock-optimal-test.log"); + fp = fopen(logfile, "w"); + if (!fp) { + fprintf(stderr, "\n%s\n", logfile); + LOG_ERR("Log file creation", errno); + } + + sprintf(logfile, "%s/%s", argv[3], "glfs-client-1.log"); + fs1 = new_client_create(argv[1], argv[2], logfile); + if (!fs1) + LOG_ERR("client-1 creation", EINVAL); + + sprintf(logfile, "%s/%s", argv[3], "glfs-client-2.log"); + fs2 = new_client_create(argv[1], argv[2], logfile); + if (!fs2) + LOG_ERR("client-2 creation", EINVAL); + + sprintf(logfile, "%s/%s", argv[3], "glfs-client-3.log"); + fs3 = new_client_create(argv[1], argv[2], logfile); + if (!fs3) + LOG_ERR("client-3 creation", EINVAL); + + fd = glfs_creat(fs1, fname, O_RDWR, 0644); + if (!fd) + LOG_ERR("glfs_creat", errno); + + test_count = 0; + + run_test_1(1); + run_test_2(2); + run_test_3(3); + run_test_4(4); + run_test_5(5); + run_test_6(6); + run_test_7(7); + run_test_8(8); + + cleanup_and_exit(0); + + return 0; } diff --git a/tests/basic/gfapi/seek.c b/tests/basic/gfapi/seek.c index fb2f6361bf3..85ea9b88141 100644 --- a/tests/basic/gfapi/seek.c +++ b/tests/basic/gfapi/seek.c @@ -18,80 +18,82 @@ #include <glusterfs/api/glfs-handles.h> int -main (int argc, char **argv) +main(int argc, char **argv) { - glfs_t *fs = NULL; - int ret = 0; - glfs_fd_t *fd = NULL; - char *filename = NULL; - char *volname = NULL; - char *hostname = NULL; - struct stat st = { 0, }; - off_t hole_start = 0; - off_t hole_end = 0; - - if (argc != 4) { - fprintf (stderr, "Invalid argument, use %s <hostname> <vol> <file>\n", - argv[0]); - exit (1); + glfs_t *fs = NULL; + int ret = 0; + glfs_fd_t *fd = NULL; + char *filename = NULL; + char *volname = NULL; + char *hostname = NULL; + struct stat st = { + 0, + }; + off_t hole_start = 0; + off_t hole_end = 0; + + if (argc != 4) { + fprintf(stderr, "Invalid argument, use %s <hostname> <vol> <file>\n", + argv[0]); + exit(1); + } + + hostname = argv[1]; + volname = argv[2]; + filename = argv[3]; + + fs = glfs_new(volname); + if (!fs) { + perror("glfs_new() returned NULL"); + return 1; + } + + if (glfs_set_volfile_server(fs, "tcp", hostname, 24007)) { + perror("glfs_set_volfile_server"); + return 1; + } + + if (glfs_init(fs)) { + perror("glfs_init"); + return 1; + } + + fd = glfs_open(fs, filename, O_RDONLY); + if (fd <= 0) { + perror("glfs_open"); + return 1; + } + + if (glfs_fstat(fd, &st)) { + perror("glfs_fstat"); + return 1; + } + + while (hole_end < st.st_size) { + hole_start = glfs_lseek(fd, hole_end, SEEK_HOLE); + if (hole_start == -1 && errno == ENXIO) + /* no more holes */ + break; + if (hole_start == -1) { + perror("no more holes"); + break; } - hostname = argv[1]; - volname = argv[2]; - filename = argv[3]; - - fs = glfs_new (volname); - if (!fs) { - perror ("glfs_new() returned NULL"); - return 1; - } - - if (glfs_set_volfile_server (fs, "tcp", hostname, 24007)) { - perror ("glfs_set_volfile_server"); - return 1; + hole_end = glfs_lseek(fd, hole_start, SEEK_DATA); + if (hole_end == -1 && errno == ENXIO) { + /* no more data */ + break; } - if (glfs_init (fs)) { - perror ("glfs_init"); - return 1; - } + printf("HOLE found: %ld - %ld%s\n", hole_start, hole_end, + (hole_end == st.st_size) ? " (EOF)" : ""); + } - fd = glfs_open (fs, filename, O_RDONLY); - if (fd <= 0) { - perror ("glfs_open"); - return 1; - } + glfs_close(fd); - if (glfs_fstat (fd, &st)) { - perror ("glfs_fstat"); - return 1; - } - - while (hole_end < st.st_size) { - hole_start = glfs_lseek (fd, hole_end, SEEK_HOLE); - if (hole_start == -1 && errno == ENXIO) - /* no more holes */ - break; - if (hole_start == -1) { - perror ("no more holes"); - break; - } - - hole_end = glfs_lseek (fd, hole_start, SEEK_DATA); - if (hole_end == -1 && errno == ENXIO) { - /* no more data */ - break; - } - - printf ("HOLE found: %ld - %ld%s\n", hole_start, hole_end, - (hole_end == st.st_size) ? " (EOF)" : ""); - } - - glfs_close (fd); - - if (fs) { - glfs_fini (fs); - } + if (fs) { + glfs_fini(fs); + } - return ret; + return ret; } diff --git a/tests/basic/gfapi/upcall-cache-invalidate.c b/tests/basic/gfapi/upcall-cache-invalidate.c index 2014bb9dccf..078286a8956 100644 --- a/tests/basic/gfapi/upcall-cache-invalidate.c +++ b/tests/basic/gfapi/upcall-cache-invalidate.c @@ -9,204 +9,201 @@ #include <glusterfs/api/glfs.h> #include <glusterfs/api/glfs-handles.h> -#define LOG_ERR(func, ret) do { \ - if (ret != 0) { \ - fprintf (stderr, "%s : returned error %d (%s)\n", \ - func, ret, strerror (errno)); \ - goto out; \ - } else { \ - fprintf (stderr, "%s : returned %d\n", func, ret); \ - } \ - } while (0) +#define LOG_ERR(func, ret) \ + do { \ + if (ret != 0) { \ + fprintf(stderr, "%s : returned error %d (%s)\n", func, ret, \ + strerror(errno)); \ + goto out; \ + } else { \ + fprintf(stderr, "%s : returned %d\n", func, ret); \ + } \ + } while (0) int -main (int argc, char *argv[]) +main(int argc, char *argv[]) { - glfs_t *fs = NULL; - glfs_t *fs2 = NULL; - glfs_t *fs_tmp = NULL; - glfs_t *fs_tmp2 = NULL; - int ret = 0, i; - glfs_fd_t *fd = NULL; - glfs_fd_t *fd2 = NULL; - glfs_fd_t *fd_tmp = NULL; - glfs_fd_t *fd_tmp2 = NULL; - char readbuf[32]; - char *filename = "file_tmp"; - char *writebuf = NULL; - char *vol_id = NULL; - unsigned int cnt = 1; - struct glfs_upcall *cbk = NULL; - char *logfile = NULL; - char *volname = NULL; - char *hostname = NULL; - - if (argc != 4) { - fprintf (stderr, "Invalid argument\n"); - exit(1); + glfs_t *fs = NULL; + glfs_t *fs2 = NULL; + glfs_t *fs_tmp = NULL; + glfs_t *fs_tmp2 = NULL; + int ret = 0, i; + glfs_fd_t *fd = NULL; + glfs_fd_t *fd2 = NULL; + glfs_fd_t *fd_tmp = NULL; + glfs_fd_t *fd_tmp2 = NULL; + char readbuf[32]; + char *filename = "file_tmp"; + char *writebuf = NULL; + char *vol_id = NULL; + unsigned int cnt = 1; + struct glfs_upcall *cbk = NULL; + char *logfile = NULL; + char *volname = NULL; + char *hostname = NULL; + + if (argc != 4) { + fprintf(stderr, "Invalid argument\n"); + exit(1); + } + + hostname = argv[1]; + volname = argv[2]; + logfile = argv[3]; + + fs = glfs_new(volname); + if (!fs) { + fprintf(stderr, "glfs_new: returned NULL\n"); + return -1; + } + + ret = glfs_set_volfile_server(fs, "tcp", hostname, 24007); + LOG_ERR("glfs_set_volfile_server", ret); + + ret = glfs_set_logging(fs, logfile, 7); + LOG_ERR("glfs_set_logging", ret); + + ret = glfs_init(fs); + LOG_ERR("glfs_init", ret); + + /* This does not block, but enables caching of events. Real + * applications like NFS-Ganesha run this in a thread before activity + * on the fs (through this instance) happens. */ + ret = glfs_h_poll_upcall(fs_tmp, &cbk); + LOG_ERR("glfs_h_poll_upcall", ret); + + fs2 = glfs_new(volname); + if (!fs2) { + fprintf(stderr, "glfs_new fs2: returned NULL\n"); + return 1; + } + + ret = glfs_set_volfile_server(fs2, "tcp", hostname, 24007); + LOG_ERR("glfs_set_volfile_server-fs2", ret); + + ret = glfs_set_logging(fs2, logfile, 7); + LOG_ERR("glfs_set_logging-fs2", ret); + + ret = glfs_init(fs2); + LOG_ERR("glfs_init-fs2", ret); + + fd = glfs_creat(fs, filename, O_RDWR | O_SYNC, 0644); + if (fd <= 0) { + ret = -1; + LOG_ERR("glfs_creat", ret); + } + fprintf(stderr, "glfs-create fd - %d\n", fd); + + fd2 = glfs_open(fs2, filename, O_SYNC | O_RDWR | O_CREAT); + if (fd2 <= 0) { + ret = -1; + LOG_ERR("glfs_open-fs2", ret); + } + fprintf(stderr, "glfs-open fd2 - %d\n", fd2); + + do { + if (cnt % 2) { + fd_tmp = fd; + fs_tmp = fs; + fd_tmp2 = fd2; + fs_tmp2 = fs2; + } else { + fd_tmp = fd2; + fs_tmp = fs2; + fd_tmp2 = fd; + fs_tmp2 = fs; } - hostname = argv[1]; - volname = argv[2]; - logfile = argv[3]; - - fs = glfs_new (volname); - if (!fs) { - fprintf (stderr, "glfs_new: returned NULL\n"); - return -1; + /* WRITE on fd_tmp */ + writebuf = malloc(10); + if (writebuf) { + memcpy(writebuf, "abcd", 4); + ret = glfs_write(fd_tmp, writebuf, 4, 0); + if (ret <= 0) { + ret = -1; + LOG_ERR("glfs_write", ret); + } else { + fprintf(stderr, "glfs_write succeeded\n"); + } + free(writebuf); + } else { + fprintf(stderr, "Could not allocate writebuf\n"); + return -1; } - ret = glfs_set_volfile_server (fs, "tcp", hostname, 24007); - LOG_ERR("glfs_set_volfile_server", ret); - - ret = glfs_set_logging (fs, logfile, 7); - LOG_ERR("glfs_set_logging", ret); - - ret = glfs_init (fs); - LOG_ERR("glfs_init", ret); + /* READ on fd_tmp2 */ + ret = glfs_lseek(fd_tmp2, 0, SEEK_SET); + LOG_ERR("glfs_lseek", ret); - /* This does not block, but enables caching of events. Real - * applications like NFS-Ganesha run this in a thread before activity - * on the fs (through this instance) happens. */ - ret = glfs_h_poll_upcall(fs_tmp, &cbk); - LOG_ERR ("glfs_h_poll_upcall", ret); + memset(readbuf, 0, sizeof(readbuf)); + ret = glfs_pread(fd_tmp2, readbuf, 4, 0, 0, NULL); - fs2 = glfs_new (volname); - if (!fs2) { - fprintf (stderr, "glfs_new fs2: returned NULL\n"); - return 1; + if (ret <= 0) { + ret = -1; + LOG_ERR("glfs_pread", ret); + } else { + fprintf(stderr, "glfs_read: %s\n", readbuf); } - ret = glfs_set_volfile_server (fs2, "tcp", hostname, 24007); - LOG_ERR("glfs_set_volfile_server-fs2", ret); - - ret = glfs_set_logging (fs2, logfile, 7); - LOG_ERR("glfs_set_logging-fs2", ret); - - ret = glfs_init (fs2); - LOG_ERR("glfs_init-fs2", ret); - - fd = glfs_creat(fs, filename, O_RDWR|O_SYNC, 0644); - if (fd <= 0) { + /* Open() fops seem to be not performed on server side until + * there are I/Os on that fd + */ + if (cnt > 2) { + struct glfs_upcall_inode *in_arg = NULL; + enum glfs_upcall_reason reason = 0; + struct glfs_object *object = NULL; + uint64_t flags = 0; + uint64_t expire = 0; + + ret = glfs_h_poll_upcall(fs_tmp, &cbk); + LOG_ERR("glfs_h_poll_upcall", ret); + + reason = glfs_upcall_get_reason(cbk); + + /* Expect 'GLFS_INODE_INVALIDATE' upcall event. */ + if (reason == GLFS_UPCALL_INODE_INVALIDATE) { + in_arg = glfs_upcall_get_event(cbk); + + object = glfs_upcall_inode_get_object(in_arg); + flags = glfs_upcall_inode_get_flags(in_arg); + expire = glfs_upcall_inode_get_expire(in_arg); + + fprintf(stderr, + " upcall event type - %d," + " object(%p), flags(%d), " + " expire_time_attr(%d)\n", + reason, object, flags, expire); + } else { + fprintf(stderr, "Didn't receive upcall notify event"); ret = -1; - LOG_ERR ("glfs_creat", ret); - } - fprintf (stderr, "glfs-create fd - %d\n", fd); + goto err; + } - fd2 = glfs_open(fs2, filename, O_SYNC|O_RDWR|O_CREAT); - if (fd2 <= 0) { - ret = -1; - LOG_ERR ("glfs_open-fs2", ret); + glfs_free(cbk); } - fprintf (stderr, "glfs-open fd2 - %d\n", fd2); - - do { - if (cnt%2) { - fd_tmp = fd; - fs_tmp = fs; - fd_tmp2 = fd2; - fs_tmp2 = fs2; - } else { - fd_tmp = fd2; - fs_tmp = fs2; - fd_tmp2 = fd; - fs_tmp2 = fs; - } - - /* WRITE on fd_tmp */ - writebuf = malloc(10); - if (writebuf) { - memcpy (writebuf, "abcd", 4); - ret = glfs_write (fd_tmp, writebuf, 4, 0); - if (ret <= 0) { - ret = -1; - LOG_ERR ("glfs_write", ret); - } else { - fprintf (stderr, - "glfs_write succeeded\n"); - } - free(writebuf); - } else { - fprintf (stderr, - "Could not allocate writebuf\n"); - return -1; - } - - /* READ on fd_tmp2 */ - ret = glfs_lseek (fd_tmp2, 0, SEEK_SET); - LOG_ERR ("glfs_lseek", ret); - - memset (readbuf, 0, sizeof(readbuf)); - ret = glfs_pread (fd_tmp2, readbuf, 4, 0, 0, NULL); - - if (ret <= 0) { - ret = -1; - LOG_ERR ("glfs_pread", ret); - } else { - fprintf (stderr, "glfs_read: %s\n", readbuf); - } - - /* Open() fops seem to be not performed on server side until - * there are I/Os on that fd - */ - if (cnt > 2) { - struct glfs_upcall_inode *in_arg = NULL; - enum glfs_upcall_reason reason = 0; - struct glfs_object *object = NULL; - uint64_t flags = 0; - uint64_t expire = 0; - - ret = glfs_h_poll_upcall(fs_tmp, &cbk); - LOG_ERR ("glfs_h_poll_upcall", ret); - - reason = glfs_upcall_get_reason (cbk); - - /* Expect 'GLFS_INODE_INVALIDATE' upcall event. */ - if (reason == GLFS_UPCALL_INODE_INVALIDATE) { - in_arg = glfs_upcall_get_event (cbk); - - object = glfs_upcall_inode_get_object (in_arg); - flags = glfs_upcall_inode_get_flags (in_arg); - expire = glfs_upcall_inode_get_expire (in_arg); - - fprintf (stderr, " upcall event type - %d," - " object(%p), flags(%d), " - " expire_time_attr(%d)\n" , - reason, object, flags, expire); - } else { - fprintf (stderr, - "Didn't receive upcall notify event"); - ret = -1; - goto err; - } - - glfs_free (cbk); - } - - sleep(5); - } while (++cnt < 5); + + sleep(5); + } while (++cnt < 5); err: - glfs_close(fd); - LOG_ERR ("glfs_close", ret); + glfs_close(fd); + LOG_ERR("glfs_close", ret); - glfs_close(fd2); - LOG_ERR ("glfs_close-fd2", ret); + glfs_close(fd2); + LOG_ERR("glfs_close-fd2", ret); out: - if (fs) { - ret = glfs_fini(fs); - fprintf (stderr, "glfs_fini(fs) returned %d \n", ret); - } - - if (fs2) { - ret = glfs_fini(fs2); - fprintf (stderr, "glfs_fini(fs2) returned %d \n", ret); - } - - if (ret) - exit(1); - exit(0); + if (fs) { + ret = glfs_fini(fs); + fprintf(stderr, "glfs_fini(fs) returned %d \n", ret); + } + + if (fs2) { + ret = glfs_fini(fs2); + fprintf(stderr, "glfs_fini(fs2) returned %d \n", ret); + } + + if (ret) + exit(1); + exit(0); } - - diff --git a/tests/basic/gfapi/upcall-register-api.c b/tests/basic/gfapi/upcall-register-api.c index 994069c0446..78594dbb108 100644 --- a/tests/basic/gfapi/upcall-register-api.c +++ b/tests/basic/gfapi/upcall-register-api.c @@ -9,273 +9,278 @@ #include <glusterfs/api/glfs.h> #include <glusterfs/api/glfs-handles.h> -#define LOG_ERR(func, ret) do { \ - if (ret != 0) { \ - fprintf (stderr, "%s : returned error %d (%s)\n", \ - func, ret, strerror (errno)); \ - goto out; \ - } else { \ - fprintf (stderr, "%s : returned %d\n", func, ret); \ - } \ - } while (0) +#define LOG_ERR(func, ret) \ + do { \ + if (ret != 0) { \ + fprintf(stderr, "%s : returned error %d (%s)\n", func, ret, \ + strerror(errno)); \ + goto out; \ + } else { \ + fprintf(stderr, "%s : returned %d\n", func, ret); \ + } \ + } while (0) int upcall_recv = 0; -void up_async_invalidate (struct glfs_upcall *up_arg, void *data) +void +up_async_invalidate(struct glfs_upcall *up_arg, void *data) { - struct glfs_upcall_inode *in_arg = NULL; - enum glfs_upcall_reason reason = 0; - struct glfs_object *object = NULL; - uint64_t flags = 0; - uint64_t expire = 0; + struct glfs_upcall_inode *in_arg = NULL; + enum glfs_upcall_reason reason = 0; + struct glfs_object *object = NULL; + uint64_t flags = 0; + uint64_t expire = 0; - if (!up_arg) - return; - - reason = glfs_upcall_get_reason (up_arg); - - /* Expect 'GLFS_INODE_INVALIDATE' upcall event. */ - - if (reason == GLFS_UPCALL_INODE_INVALIDATE) { - in_arg = glfs_upcall_get_event (up_arg); - - object = glfs_upcall_inode_get_object (in_arg); - flags = glfs_upcall_inode_get_flags (in_arg); - expire = glfs_upcall_inode_get_expire (in_arg); - - fprintf (stderr, " upcall event type - %d," - " object(%p), flags(%d), " - " expire_time_attr(%d)\n" , - reason, object, flags, expire); - upcall_recv++; - } - - glfs_free (up_arg); + if (!up_arg) return; -} -int perform_io (glfs_t *fs, glfs_t *fs2, int cnt) -{ - glfs_t *fs_tmp = NULL; - glfs_t *fs_tmp2 = NULL; - glfs_fd_t *fd_tmp = NULL; - glfs_fd_t *fd_tmp2 = NULL; - char readbuf[32]; - char *writebuf = NULL; - glfs_fd_t *fd = NULL; - glfs_fd_t *fd2 = NULL; - char *filename = "file_tmp"; - int ret = -1; - - if (!fs || !fs2) - return -1; - - /* Create file from fs and open it from fs2 */ - fd = glfs_creat(fs, filename, O_RDWR|O_SYNC, 0644); - if (fd <= 0) { - ret = -1; - LOG_ERR ("glfs_creat", ret); - } + reason = glfs_upcall_get_reason(up_arg); - fd2 = glfs_open(fs2, filename, O_SYNC|O_RDWR|O_CREAT); - if (fd2 <= 0) { - ret = -1; - LOG_ERR ("glfs_open-fs2", ret); - } + /* Expect 'GLFS_INODE_INVALIDATE' upcall event. */ - do { - if (cnt%2) { - fd_tmp = fd; - fs_tmp = fs; - fd_tmp2 = fd2; - fs_tmp2 = fs2; - } else { - fd_tmp = fd2; - fs_tmp = fs2; - fd_tmp2 = fd; - fs_tmp2 = fs; - } - - /* WRITE on fd_tmp */ - writebuf = malloc(10); - if (writebuf) { - memcpy (writebuf, "abcd", 4); - ret = glfs_write (fd_tmp, writebuf, 4, 0); - if (ret <= 0) { - ret = -1; - LOG_ERR ("glfs_write", ret); - } - free(writebuf); - } else { - fprintf (stderr, - "Could not allocate writebuf\n"); - return -1; - } - - /* READ on fd_tmp2 */ - ret = glfs_lseek (fd_tmp2, 0, SEEK_SET); - LOG_ERR ("glfs_lseek", ret); - - memset (readbuf, 0, sizeof(readbuf)); - ret = glfs_pread (fd_tmp2, readbuf, 4, 0, 0, NULL); - - if (ret <= 0) { - ret = -1; - LOG_ERR ("glfs_pread", ret); - } - - sleep(2); - } while (--cnt > 0); + if (reason == GLFS_UPCALL_INODE_INVALIDATE) { + in_arg = glfs_upcall_get_event(up_arg); - sleep(2); + object = glfs_upcall_inode_get_object(in_arg); + flags = glfs_upcall_inode_get_flags(in_arg); + expire = glfs_upcall_inode_get_expire(in_arg); - ret = 0; -err: - glfs_close(fd); + fprintf(stderr, + " upcall event type - %d," + " object(%p), flags(%d), " + " expire_time_attr(%d)\n", + reason, object, flags, expire); + upcall_recv++; + } - glfs_close(fd2); - -out: - return ret; + glfs_free(up_arg); + return; } int -main (int argc, char *argv[]) +perform_io(glfs_t *fs, glfs_t *fs2, int cnt) { - glfs_t *fs = NULL; - glfs_t *fs2 = NULL; - int ret = 0, i; - char *vol_id = NULL; - unsigned int cnt = 5; - struct glfs_upcall *cbk = NULL; - char *logfile = NULL; - char *volname = NULL; - char *hostname = NULL; - int up_events = GLFS_EVENT_ANY; - - if (argc != 4) { - fprintf (stderr, "Invalid argument\n"); - exit(1); - } - - hostname = argv[1]; - volname = argv[2]; - logfile = argv[3]; - - /* Initialize fs */ - fs = glfs_new (volname); - if (!fs) { - fprintf (stderr, "glfs_new: returned NULL\n"); - return -1; - } - - ret = glfs_set_volfile_server (fs, "tcp", hostname, 24007); - LOG_ERR("glfs_set_volfile_server", ret); - - ret = glfs_set_logging (fs, logfile, 7); - LOG_ERR("glfs_set_logging", ret); - - ret = glfs_init (fs); - LOG_ERR("glfs_init", ret); - - /* Initialize fs2 */ - fs2 = glfs_new (volname); - if (!fs2) { - fprintf (stderr, "glfs_new fs2: returned NULL\n"); - return 1; - } - - ret = glfs_set_volfile_server (fs2, "tcp", hostname, 24007); - LOG_ERR("glfs_set_volfile_server-fs2", ret); - - ret = glfs_set_logging (fs2, logfile, 7); - LOG_ERR("glfs_set_logging-fs2", ret); - - ret = glfs_init (fs2); - LOG_ERR("glfs_init-fs2", ret); - - /* Register Upcalls */ - ret = glfs_upcall_register (fs, up_events, up_async_invalidate, NULL); - - /* Check if the return mask contains the event */ - if (!(ret & GLFS_EVENT_INODE_INVALIDATE)) { - fprintf (stderr, "glfs_upcall_register return doesn't contain" - " upcall event\n"); - return -1; - } - - ret = glfs_upcall_register (fs2, up_events, up_async_invalidate, NULL); - - /* Check if the return mask contains the event */ - if ((ret < 0) || !(ret & GLFS_EVENT_INODE_INVALIDATE)) { - fprintf (stderr, "glfs_upcall_register return doesn't contain" - " upcall event\n"); - return -1; + glfs_t *fs_tmp = NULL; + glfs_t *fs_tmp2 = NULL; + glfs_fd_t *fd_tmp = NULL; + glfs_fd_t *fd_tmp2 = NULL; + char readbuf[32]; + char *writebuf = NULL; + glfs_fd_t *fd = NULL; + glfs_fd_t *fd2 = NULL; + char *filename = "file_tmp"; + int ret = -1; + + if (!fs || !fs2) + return -1; + + /* Create file from fs and open it from fs2 */ + fd = glfs_creat(fs, filename, O_RDWR | O_SYNC, 0644); + if (fd <= 0) { + ret = -1; + LOG_ERR("glfs_creat", ret); + } + + fd2 = glfs_open(fs2, filename, O_SYNC | O_RDWR | O_CREAT); + if (fd2 <= 0) { + ret = -1; + LOG_ERR("glfs_open-fs2", ret); + } + + do { + if (cnt % 2) { + fd_tmp = fd; + fs_tmp = fs; + fd_tmp2 = fd2; + fs_tmp2 = fs2; + } else { + fd_tmp = fd2; + fs_tmp = fs2; + fd_tmp2 = fd; + fs_tmp2 = fs; } - /* Perform I/O */ - ret = perform_io (fs, fs2, cnt); - LOG_ERR("perform_io", ret); - - if (upcall_recv == 0) { - fprintf (stderr, "Upcalls are not received.\n"); + /* WRITE on fd_tmp */ + writebuf = malloc(10); + if (writebuf) { + memcpy(writebuf, "abcd", 4); + ret = glfs_write(fd_tmp, writebuf, 4, 0); + if (ret <= 0) { ret = -1; + LOG_ERR("glfs_write", ret); + } + free(writebuf); } else { - fprintf (stderr, "Received %d upcalls as expected\n", - upcall_recv); - ret = 0; + fprintf(stderr, "Could not allocate writebuf\n"); + return -1; } - sleep(5); /* to flush out previous upcalls if any */ + /* READ on fd_tmp2 */ + ret = glfs_lseek(fd_tmp2, 0, SEEK_SET); + LOG_ERR("glfs_lseek", ret); - /* Now unregister and check there are no upcall events received */ - ret = glfs_upcall_unregister (fs, up_events); + memset(readbuf, 0, sizeof(readbuf)); + ret = glfs_pread(fd_tmp2, readbuf, 4, 0, 0, NULL); - /* Check if the return mask contains the event */ - if ((ret < 0) || !(ret & GLFS_EVENT_INODE_INVALIDATE)) { - fprintf (stderr, "glfs_upcall_register return doesn't contain" - " upcall event\n"); - return -1; + if (ret <= 0) { + ret = -1; + LOG_ERR("glfs_pread", ret); } - ret = glfs_upcall_unregister (fs2, up_events); + sleep(2); + } while (--cnt > 0); - /* Check if the return mask contains the event */ - if ((ret < 0) || !(ret & GLFS_EVENT_INODE_INVALIDATE)) { - fprintf (stderr, "glfs_upcall_register return doesn't contain" - " upcall event\n"); - return -1; - } + sleep(2); - upcall_recv = 0; + ret = 0; +err: + glfs_close(fd); - ret = perform_io (fs, fs2, cnt); - LOG_ERR("perform_io", ret); - - if (upcall_recv != 0) { - fprintf (stderr, "%d upcalls received even after unregister.\n", - upcall_recv); - ret = -1; - } else { - fprintf (stderr, "Post unregister, no upcalls received as" - " expected\n"); - ret = 0; - } + glfs_close(fd2); out: - if (fs) { - ret = glfs_fini(fs); - fprintf (stderr, "glfs_fini(fs) returned %d\n", ret); - } - - if (fs2) { - ret = glfs_fini(fs2); - fprintf (stderr, "glfs_fini(fs2) returned %d\n", ret); - } - - if (ret) - exit(1); - exit(0); + return ret; } +int +main(int argc, char *argv[]) +{ + glfs_t *fs = NULL; + glfs_t *fs2 = NULL; + int ret = 0, i; + char *vol_id = NULL; + unsigned int cnt = 5; + struct glfs_upcall *cbk = NULL; + char *logfile = NULL; + char *volname = NULL; + char *hostname = NULL; + int up_events = GLFS_EVENT_ANY; + + if (argc != 4) { + fprintf(stderr, "Invalid argument\n"); + exit(1); + } + + hostname = argv[1]; + volname = argv[2]; + logfile = argv[3]; + + /* Initialize fs */ + fs = glfs_new(volname); + if (!fs) { + fprintf(stderr, "glfs_new: returned NULL\n"); + return -1; + } + + ret = glfs_set_volfile_server(fs, "tcp", hostname, 24007); + LOG_ERR("glfs_set_volfile_server", ret); + + ret = glfs_set_logging(fs, logfile, 7); + LOG_ERR("glfs_set_logging", ret); + + ret = glfs_init(fs); + LOG_ERR("glfs_init", ret); + + /* Initialize fs2 */ + fs2 = glfs_new(volname); + if (!fs2) { + fprintf(stderr, "glfs_new fs2: returned NULL\n"); + return 1; + } + + ret = glfs_set_volfile_server(fs2, "tcp", hostname, 24007); + LOG_ERR("glfs_set_volfile_server-fs2", ret); + + ret = glfs_set_logging(fs2, logfile, 7); + LOG_ERR("glfs_set_logging-fs2", ret); + + ret = glfs_init(fs2); + LOG_ERR("glfs_init-fs2", ret); + + /* Register Upcalls */ + ret = glfs_upcall_register(fs, up_events, up_async_invalidate, NULL); + + /* Check if the return mask contains the event */ + if (!(ret & GLFS_EVENT_INODE_INVALIDATE)) { + fprintf(stderr, + "glfs_upcall_register return doesn't contain" + " upcall event\n"); + return -1; + } + + ret = glfs_upcall_register(fs2, up_events, up_async_invalidate, NULL); + + /* Check if the return mask contains the event */ + if ((ret < 0) || !(ret & GLFS_EVENT_INODE_INVALIDATE)) { + fprintf(stderr, + "glfs_upcall_register return doesn't contain" + " upcall event\n"); + return -1; + } + + /* Perform I/O */ + ret = perform_io(fs, fs2, cnt); + LOG_ERR("perform_io", ret); + + if (upcall_recv == 0) { + fprintf(stderr, "Upcalls are not received.\n"); + ret = -1; + } else { + fprintf(stderr, "Received %d upcalls as expected\n", upcall_recv); + ret = 0; + } + + sleep(5); /* to flush out previous upcalls if any */ + + /* Now unregister and check there are no upcall events received */ + ret = glfs_upcall_unregister(fs, up_events); + + /* Check if the return mask contains the event */ + if ((ret < 0) || !(ret & GLFS_EVENT_INODE_INVALIDATE)) { + fprintf(stderr, + "glfs_upcall_register return doesn't contain" + " upcall event\n"); + return -1; + } + + ret = glfs_upcall_unregister(fs2, up_events); + + /* Check if the return mask contains the event */ + if ((ret < 0) || !(ret & GLFS_EVENT_INODE_INVALIDATE)) { + fprintf(stderr, + "glfs_upcall_register return doesn't contain" + " upcall event\n"); + return -1; + } + + upcall_recv = 0; + + ret = perform_io(fs, fs2, cnt); + LOG_ERR("perform_io", ret); + + if (upcall_recv != 0) { + fprintf(stderr, "%d upcalls received even after unregister.\n", + upcall_recv); + ret = -1; + } else { + fprintf(stderr, + "Post unregister, no upcalls received as" + " expected\n"); + ret = 0; + } +out: + if (fs) { + ret = glfs_fini(fs); + fprintf(stderr, "glfs_fini(fs) returned %d\n", ret); + } + + if (fs2) { + ret = glfs_fini(fs2); + fprintf(stderr, "glfs_fini(fs2) returned %d\n", ret); + } + + if (ret) + exit(1); + exit(0); +} diff --git a/tests/basic/logchecks.c b/tests/basic/logchecks.c index a40278b0d77..86891057230 100644 --- a/tests/basic/logchecks.c +++ b/tests/basic/logchecks.c @@ -18,191 +18,197 @@ #include "logchecks-messages.h" #include "../../libglusterfs/src/logging.h" -glusterfs_ctx_t *ctx = NULL; +glusterfs_ctx_t *ctx = NULL; -#define TEST_FILENAME "/tmp/logchecks.log" -#define GF_LOG_CONTROL_FILE "/etc/glusterfs/logger.conf" +#define TEST_FILENAME "/tmp/logchecks.log" +#define GF_LOG_CONTROL_FILE "/etc/glusterfs/logger.conf" int go_log_vargs(gf_loglevel_t level, const char *fmt, ...) { - va_list ap; + va_list ap; - va_start (ap, fmt); - gf_msg_vplain (level, fmt, ap); - va_end (ap); + va_start(ap, fmt); + gf_msg_vplain(level, fmt, ap); + va_end(ap); - return 0; + return 0; } int -go_log (void) +go_log(void) { - /*** gf_msg ***/ - gf_msg ("logchecks", GF_LOG_INFO, 0, logchecks_msg_1); - gf_msg ("logchecks", GF_LOG_INFO, 22, logchecks_msg_2, 42, "Forty-Two", - 42); - /* change criticality */ - gf_msg ("logchecks", GF_LOG_CRITICAL, 0, logchecks_msg_3); - gf_msg ("logchecks", GF_LOG_CRITICAL, 22, logchecks_msg_4, 42, - "Forty-Two", 42); - - /*** msg_nomem ***/ - gf_msg_nomem ("logchecks", GF_LOG_ALERT, 555); - gf_msg_nomem ("logchecks", GF_LOG_INFO, 555); - - /*** msg_plain ***/ - gf_msg_plain (GF_LOG_INFO, "Informational: gf_msg_plain with" - " args %d:%s:%x", 42, "Forty-Two", 42); - gf_msg_plain (GF_LOG_ALERT, "Alert: gf_msg_plain with" - " args %d:%s:%x", 42, "Forty-Two", 42); - - /*** msg_vplain ***/ - go_log_vargs (GF_LOG_INFO, "Informational: gf_msg_vplain: No args!!!"); - go_log_vargs (GF_LOG_INFO, "Informational: gf_msg_vplain: Some" - " args %d:%s:%x", 42, "Forty-Two", 42); - go_log_vargs (GF_LOG_INFO, "Critical: gf_msg_vplain: No args!!!"); - go_log_vargs (GF_LOG_INFO, "Critical: gf_msg_vplain: Some" - " args %d:%s:%x", 42, "Forty-Two", 42); - - /*** msg_plain_nomem ***/ - gf_msg_plain_nomem (GF_LOG_INFO, "Informational: gf_msg_plain_nomem"); - gf_msg_plain_nomem (GF_LOG_ALERT, "Alert: gf_msg_plain_nomem"); - - /*** msg_backtrace_nomem ***/ - // TODO: Need to create a stack depth and then call - gf_msg_backtrace_nomem (GF_LOG_INFO, 5); - gf_msg_backtrace_nomem (GF_LOG_ALERT, 5); - - /*** gf_msg_callingfn ***/ - // TODO: Need to create a stack depth and then call - gf_msg_callingfn ("logchecks", GF_LOG_INFO, 0, logchecks_msg_7); - gf_msg_callingfn ("logchecks", GF_LOG_INFO, 0, logchecks_msg_8, 42, - "Forty-Two", 42); - gf_msg_callingfn ("logchecks", GF_LOG_CRITICAL, 0, logchecks_msg_9); - gf_msg_callingfn ("logchecks", GF_LOG_CRITICAL, 0, logchecks_msg_10, 42, - "Forty-Two", 42); - - /*** gf_msg_debug ***/ - gf_msg_debug ("logchecks", 0, "Debug: Hello World!!!"); - gf_msg_debug ("logchecks", 22, "Debug: With args %d:%s:%x", 42, - "Forty-Two", 42); - - /*** gf_msg_trace ***/ - gf_msg_trace ("logchecks", 0, "Trace: Hello World!!!"); - gf_msg_trace ("logchecks", 22, "Trace: With args %d:%s:%x", 42, - "Forty-Two", 42); - - /*** gf_msg_backtrace ***/ - // TODO: Test with lower callstr values to check truncation - - return 0; + /*** gf_msg ***/ + gf_msg("logchecks", GF_LOG_INFO, 0, logchecks_msg_1); + gf_msg("logchecks", GF_LOG_INFO, 22, logchecks_msg_2, 42, "Forty-Two", 42); + /* change criticality */ + gf_msg("logchecks", GF_LOG_CRITICAL, 0, logchecks_msg_3); + gf_msg("logchecks", GF_LOG_CRITICAL, 22, logchecks_msg_4, 42, "Forty-Two", + 42); + + /*** msg_nomem ***/ + gf_msg_nomem("logchecks", GF_LOG_ALERT, 555); + gf_msg_nomem("logchecks", GF_LOG_INFO, 555); + + /*** msg_plain ***/ + gf_msg_plain(GF_LOG_INFO, + "Informational: gf_msg_plain with" + " args %d:%s:%x", + 42, "Forty-Two", 42); + gf_msg_plain(GF_LOG_ALERT, + "Alert: gf_msg_plain with" + " args %d:%s:%x", + 42, "Forty-Two", 42); + + /*** msg_vplain ***/ + go_log_vargs(GF_LOG_INFO, "Informational: gf_msg_vplain: No args!!!"); + go_log_vargs(GF_LOG_INFO, + "Informational: gf_msg_vplain: Some" + " args %d:%s:%x", + 42, "Forty-Two", 42); + go_log_vargs(GF_LOG_INFO, "Critical: gf_msg_vplain: No args!!!"); + go_log_vargs(GF_LOG_INFO, + "Critical: gf_msg_vplain: Some" + " args %d:%s:%x", + 42, "Forty-Two", 42); + + /*** msg_plain_nomem ***/ + gf_msg_plain_nomem(GF_LOG_INFO, "Informational: gf_msg_plain_nomem"); + gf_msg_plain_nomem(GF_LOG_ALERT, "Alert: gf_msg_plain_nomem"); + + /*** msg_backtrace_nomem ***/ + // TODO: Need to create a stack depth and then call + gf_msg_backtrace_nomem(GF_LOG_INFO, 5); + gf_msg_backtrace_nomem(GF_LOG_ALERT, 5); + + /*** gf_msg_callingfn ***/ + // TODO: Need to create a stack depth and then call + gf_msg_callingfn("logchecks", GF_LOG_INFO, 0, logchecks_msg_7); + gf_msg_callingfn("logchecks", GF_LOG_INFO, 0, logchecks_msg_8, 42, + "Forty-Two", 42); + gf_msg_callingfn("logchecks", GF_LOG_CRITICAL, 0, logchecks_msg_9); + gf_msg_callingfn("logchecks", GF_LOG_CRITICAL, 0, logchecks_msg_10, 42, + "Forty-Two", 42); + + /*** gf_msg_debug ***/ + gf_msg_debug("logchecks", 0, "Debug: Hello World!!!"); + gf_msg_debug("logchecks", 22, "Debug: With args %d:%s:%x", 42, "Forty-Two", + 42); + + /*** gf_msg_trace ***/ + gf_msg_trace("logchecks", 0, "Trace: Hello World!!!"); + gf_msg_trace("logchecks", 22, "Trace: With args %d:%s:%x", 42, "Forty-Two", + 42); + + /*** gf_msg_backtrace ***/ + // TODO: Test with lower callstr values to check truncation + + return 0; } int -main (int argc, char *argv[]) +main(int argc, char *argv[]) { - int ret = -1; - - unlink (GF_LOG_CONTROL_FILE); - creat (GF_LOG_CONTROL_FILE, O_RDONLY); - ctx = glusterfs_ctx_new (); - if (!ctx) - return -1; - - ret = glusterfs_globals_init (ctx); - if (ret) { - printf ("Error from glusterfs_globals_init [%s]\n", - strerror (errno)); - return ret; - } - - /* Pre init test, message should not be printed */ - gf_msg ("logchecks", GF_LOG_ALERT, 0, logchecks_msg_19); - - THIS->ctx = ctx; - - /* TEST 1: messages before initializing the log, goes to stderr - * and syslog based on criticality */ - gf_msg ("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11); - gf_msg ("logchecks", GF_LOG_ALERT, 0, logchecks_msg_12); - go_log (); - gf_msg ("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11); - - /* TEST 2: messages post initialization, goes to glusterlog and - * syslog based on severity */ - ret = gf_log_init(ctx, TEST_FILENAME, "logchecks"); - if (ret != 0) { - printf ("Error from gf_log_init [%s]\n", strerror (errno)); - return -1; - } - gf_msg ("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11); - gf_msg ("logchecks", GF_LOG_ALERT, 0, logchecks_msg_13); - go_log (); - gf_msg ("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11); - - /* TEST 3: Test rotation */ - gf_msg ("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11); - gf_log_logrotate (0); - gf_msg ("logchecks", GF_LOG_CRITICAL, 0, logchecks_msg_5); - gf_msg ("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11); - - /* TEST 4: Check flush, nothing noticeable should occur :) */ - gf_msg ("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11); - gf_log_flush (); - gf_msg ("logchecks", GF_LOG_CRITICAL, 0, logchecks_msg_6); - gf_msg ("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11); - - /* TEST 5: Change format */ - gf_msg ("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11); - gf_log_set_logformat (gf_logformat_traditional); - gf_msg ("logchecks", GF_LOG_ALERT, 0, logchecks_msg_14); - go_log (); - gf_msg ("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11); - - /* TEST 6: Change level */ - gf_msg ("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11); - gf_log_set_loglevel (ctx, GF_LOG_CRITICAL); - gf_msg ("logchecks", GF_LOG_ALERT, 0, logchecks_msg_15); - go_log (); - gf_msg ("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11); - - /* Reset to run with syslog */ - gf_log_set_logformat (gf_logformat_withmsgid); - gf_log_set_loglevel (ctx, GF_LOG_INFO); - - /* Run tests with logger changed to syslog */ - /* TEST 7: No more gluster logs */ - gf_msg ("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11); - gf_log_set_logger (gf_logger_syslog); - gf_msg ("logchecks", GF_LOG_ALERT, 0, logchecks_msg_16); - go_log (); - gf_msg ("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11); - - /* TEST 8: Change format */ - gf_msg ("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11); - gf_log_set_logformat (gf_logformat_traditional); - gf_msg ("logchecks", GF_LOG_ALERT, 0, logchecks_msg_14); - go_log (); - gf_msg ("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11); - - /* TEST 9: Change level */ - gf_msg ("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11); - gf_log_set_loglevel (ctx, GF_LOG_CRITICAL); - gf_msg ("logchecks", GF_LOG_ALERT, 0, logchecks_msg_15); - go_log (); - gf_msg ("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11); - - // TODO: signal crash prints, but not yet feasible here - // TODO: Graph printing - // TODO: Multi threaded logging - - /* Close out the logging */ - gf_log_fini (ctx); - gf_log_globals_fini (); - - unlink (GF_LOG_CONTROL_FILE); - unlink (TEST_FILENAME); - - return 0; + int ret = -1; + + unlink(GF_LOG_CONTROL_FILE); + creat(GF_LOG_CONTROL_FILE, O_RDONLY); + ctx = glusterfs_ctx_new(); + if (!ctx) + return -1; + + ret = glusterfs_globals_init(ctx); + if (ret) { + printf("Error from glusterfs_globals_init [%s]\n", strerror(errno)); + return ret; + } + + /* Pre init test, message should not be printed */ + gf_msg("logchecks", GF_LOG_ALERT, 0, logchecks_msg_19); + + THIS->ctx = ctx; + + /* TEST 1: messages before initializing the log, goes to stderr + * and syslog based on criticality */ + gf_msg("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11); + gf_msg("logchecks", GF_LOG_ALERT, 0, logchecks_msg_12); + go_log(); + gf_msg("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11); + + /* TEST 2: messages post initialization, goes to glusterlog and + * syslog based on severity */ + ret = gf_log_init(ctx, TEST_FILENAME, "logchecks"); + if (ret != 0) { + printf("Error from gf_log_init [%s]\n", strerror(errno)); + return -1; + } + gf_msg("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11); + gf_msg("logchecks", GF_LOG_ALERT, 0, logchecks_msg_13); + go_log(); + gf_msg("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11); + + /* TEST 3: Test rotation */ + gf_msg("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11); + gf_log_logrotate(0); + gf_msg("logchecks", GF_LOG_CRITICAL, 0, logchecks_msg_5); + gf_msg("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11); + + /* TEST 4: Check flush, nothing noticeable should occur :) */ + gf_msg("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11); + gf_log_flush(); + gf_msg("logchecks", GF_LOG_CRITICAL, 0, logchecks_msg_6); + gf_msg("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11); + + /* TEST 5: Change format */ + gf_msg("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11); + gf_log_set_logformat(gf_logformat_traditional); + gf_msg("logchecks", GF_LOG_ALERT, 0, logchecks_msg_14); + go_log(); + gf_msg("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11); + + /* TEST 6: Change level */ + gf_msg("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11); + gf_log_set_loglevel(ctx, GF_LOG_CRITICAL); + gf_msg("logchecks", GF_LOG_ALERT, 0, logchecks_msg_15); + go_log(); + gf_msg("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11); + + /* Reset to run with syslog */ + gf_log_set_logformat(gf_logformat_withmsgid); + gf_log_set_loglevel(ctx, GF_LOG_INFO); + + /* Run tests with logger changed to syslog */ + /* TEST 7: No more gluster logs */ + gf_msg("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11); + gf_log_set_logger(gf_logger_syslog); + gf_msg("logchecks", GF_LOG_ALERT, 0, logchecks_msg_16); + go_log(); + gf_msg("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11); + + /* TEST 8: Change format */ + gf_msg("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11); + gf_log_set_logformat(gf_logformat_traditional); + gf_msg("logchecks", GF_LOG_ALERT, 0, logchecks_msg_14); + go_log(); + gf_msg("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11); + + /* TEST 9: Change level */ + gf_msg("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11); + gf_log_set_loglevel(ctx, GF_LOG_CRITICAL); + gf_msg("logchecks", GF_LOG_ALERT, 0, logchecks_msg_15); + go_log(); + gf_msg("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11); + + // TODO: signal crash prints, but not yet feasible here + // TODO: Graph printing + // TODO: Multi threaded logging + + /* Close out the logging */ + gf_log_fini(ctx); + gf_log_globals_fini(); + + unlink(GF_LOG_CONTROL_FILE); + unlink(TEST_FILENAME); + + return 0; } diff --git a/tests/basic/posix/zero-fill-enospace.c b/tests/basic/posix/zero-fill-enospace.c index 7c0d31128b3..1371ff59a5f 100644 --- a/tests/basic/posix/zero-fill-enospace.c +++ b/tests/basic/posix/zero-fill-enospace.c @@ -3,62 +3,64 @@ #include <glusterfs/api/glfs-handles.h> int -main (int argc, char *argv[]) +main(int argc, char *argv[]) { - glfs_t *fs = NULL; - glfs_fd_t *fd = NULL; - int ret = 1; - int size = 0; + glfs_t *fs = NULL; + glfs_fd_t *fd = NULL; + int ret = 1; + int size = 0; - if (argc != 6) { - fprintf (stderr, "Syntax: %s <host> <volname> <file-path> <log-file> <size>\n", argv[0]); - return 1; - } + if (argc != 6) { + fprintf(stderr, + "Syntax: %s <host> <volname> <file-path> <log-file> <size>\n", + argv[0]); + return 1; + } - fs = glfs_new (argv[2]); - if (!fs) { - fprintf (stderr, "glfs_new: returned NULL\n"); - return 1; - } + fs = glfs_new(argv[2]); + if (!fs) { + fprintf(stderr, "glfs_new: returned NULL\n"); + return 1; + } - ret = glfs_set_volfile_server (fs, "tcp", argv[1], 24007); - if (ret != 0) { - fprintf (stderr, "glfs_set_volfile_server: returned %d\n", ret); - goto out; - } - ret = glfs_set_logging (fs, argv[4], 7); - if (ret != 0) { - fprintf (stderr, "glfs_set_logging: returned %d\n", ret); - goto out; - } - ret = glfs_init (fs); - if (ret != 0) { - fprintf (stderr, "glfs_init: returned %d\n", ret); - goto out; - } + ret = glfs_set_volfile_server(fs, "tcp", argv[1], 24007); + if (ret != 0) { + fprintf(stderr, "glfs_set_volfile_server: returned %d\n", ret); + goto out; + } + ret = glfs_set_logging(fs, argv[4], 7); + if (ret != 0) { + fprintf(stderr, "glfs_set_logging: returned %d\n", ret); + goto out; + } + ret = glfs_init(fs); + if (ret != 0) { + fprintf(stderr, "glfs_init: returned %d\n", ret); + goto out; + } - fd = glfs_open (fs, argv[3], O_RDWR); - if (fd == NULL) { - fprintf (stderr, "glfs_open: returned NULL\n"); - goto out; - } + fd = glfs_open(fs, argv[3], O_RDWR); + if (fd == NULL) { + fprintf(stderr, "glfs_open: returned NULL\n"); + goto out; + } - size = atoi(argv[5]); - if (size < 0) { - fprintf (stderr, "Wrong size %s", argv[5]); - goto out; - } - ret = glfs_zerofill (fd, 0, atoi(argv[5])); - if (ret <= 0) { - fprintf (stderr, "glfs_zerofill: returned %d\n", ret); - goto out; - } + size = atoi(argv[5]); + if (size < 0) { + fprintf(stderr, "Wrong size %s", argv[5]); + goto out; + } + ret = glfs_zerofill(fd, 0, atoi(argv[5])); + if (ret <= 0) { + fprintf(stderr, "glfs_zerofill: returned %d\n", ret); + goto out; + } - ret = 0; + ret = 0; out: - if (fd) - glfs_close(fd); - glfs_fini (fs); - return ret; + if (fd) + glfs_close(fd); + glfs_fini(fs); + return ret; } diff --git a/tests/basic/quota.c b/tests/basic/quota.c index f69b0ea9bc5..809ceb8e54c 100644 --- a/tests/basic/quota.c +++ b/tests/basic/quota.c @@ -8,83 +8,82 @@ #include <unistd.h> ssize_t -nwrite (int fd, const void *buf, size_t count) +nwrite(int fd, const void *buf, size_t count) { - ssize_t ret = 0; - ssize_t written = 0; + ssize_t ret = 0; + ssize_t written = 0; - for (written = 0; written != count; written += ret) { - ret = write (fd, buf + written, count - written); - if (ret < 0) { - if (errno == EINTR) - ret = 0; - else - goto out; - } + for (written = 0; written != count; written += ret) { + ret = write(fd, buf + written, count - written); + if (ret < 0) { + if (errno == EINTR) + ret = 0; + else + goto out; } + } - ret = written; + ret = written; out: - return ret; + return ret; } int -file_write (char *filename, int bs, int count) +file_write(char *filename, int bs, int count) { - int fd = 0; - int ret = -1; - int i = 0; - char *buf = NULL; + int fd = 0; + int ret = -1; + int i = 0; + char *buf = NULL; - bs = bs * 1024; + bs = bs * 1024; - buf = (char *) malloc (bs); - if (buf == NULL) - goto out; + buf = (char *)malloc(bs); + if (buf == NULL) + goto out; - memset (buf, 0, bs); + memset(buf, 0, bs); - fd = open (filename, O_RDWR|O_CREAT|O_SYNC, 0600); - while (i < count) { - ret = nwrite(fd, buf, bs); - if (ret == -1) { - close (fd); - goto out; - } - i++; + fd = open(filename, O_RDWR | O_CREAT | O_SYNC, 0600); + while (i < count) { + ret = nwrite(fd, buf, bs); + if (ret == -1) { + close(fd); + goto out; } + i++; + } - ret = fdatasync(fd); - if (ret) { - close (fd); - goto out; - } + ret = fdatasync(fd); + if (ret) { + close(fd); + goto out; + } - ret = close(fd); - if (ret) - goto out; + ret = close(fd); + if (ret) + goto out; - ret = 0; + ret = 0; out: - if (buf) - free (buf); - return ret; + if (buf) + free(buf); + return ret; } int -main (int argc, char **argv) +main(int argc, char **argv) { - if (argc != 4) { - printf("Usage: %s <filename> <block size in k> <count>\n", - argv[0]); - return EXIT_FAILURE; - } + if (argc != 4) { + printf("Usage: %s <filename> <block size in k> <count>\n", argv[0]); + return EXIT_FAILURE; + } - if (file_write (argv[1], atoi(argv[2]), atoi(argv[3])) < 0) { - perror ("write failed"); - return EXIT_FAILURE; - } + if (file_write(argv[1], atoi(argv[2]), atoi(argv[3])) < 0) { + perror("write failed"); + return EXIT_FAILURE; + } - return EXIT_SUCCESS; + return EXIT_SUCCESS; } diff --git a/tests/basic/tier/file_lock.c b/tests/basic/tier/file_lock.c index 730cca92e42..20fdbc0f668 100644 --- a/tests/basic/tier/file_lock.c +++ b/tests/basic/tier/file_lock.c @@ -3,73 +3,70 @@ #include <unistd.h> #include <fcntl.h> - -void usage (void) +void +usage(void) { - - printf ("Usage: testlock <filepath> [R|W]\n"); - return; + printf("Usage: testlock <filepath> [R|W]\n"); + return; } - -int main (int argc, char *argv[]) +int +main(int argc, char *argv[]) { - char *file_path = NULL; - int fd = -1; - struct flock lock = {0}; - int ret = -1; - int c = 0; - - if (argc != 3) { - usage (); - exit (1); - } - - file_path = argv[1]; - fd = open (file_path, O_RDWR); - - if (-1 == fd) { - printf ("Failed to open file %s. %m\n", file_path); - exit (1); - } - - /* TODO: Check for invalid input*/ - - if (!strcmp (argv[2], "W")) { - lock.l_type = F_WRLCK; - printf("Taking write lock\n"); - - } else { - lock.l_type = F_RDLCK; - printf("Taking read lock\n"); - } - - lock.l_whence = SEEK_SET; - lock.l_start = 0; - lock.l_len = 0; - lock.l_pid = getpid (); - - - printf ("Acquiring lock on %s\n", file_path); - ret = fcntl (fd, F_SETLK, &lock); - if (ret) { - printf ("Failed to acquire lock on %s (%m)\n", file_path); - close (fd); - exit (1); - } - - sleep(10); - - /*Unlock*/ - - printf ("Releasing lock on %s\n", file_path); - lock.l_type = F_UNLCK; - ret = fcntl (fd, F_SETLK, &lock); - if (ret) { - printf ("Failed to release lock on %s (%m)\n", file_path); - } - - close (fd); - return ret; - + char *file_path = NULL; + int fd = -1; + struct flock lock = {0}; + int ret = -1; + int c = 0; + + if (argc != 3) { + usage(); + exit(1); + } + + file_path = argv[1]; + fd = open(file_path, O_RDWR); + + if (-1 == fd) { + printf("Failed to open file %s. %m\n", file_path); + exit(1); + } + + /* TODO: Check for invalid input*/ + + if (!strcmp(argv[2], "W")) { + lock.l_type = F_WRLCK; + printf("Taking write lock\n"); + + } else { + lock.l_type = F_RDLCK; + printf("Taking read lock\n"); + } + + lock.l_whence = SEEK_SET; + lock.l_start = 0; + lock.l_len = 0; + lock.l_pid = getpid(); + + printf("Acquiring lock on %s\n", file_path); + ret = fcntl(fd, F_SETLK, &lock); + if (ret) { + printf("Failed to acquire lock on %s (%m)\n", file_path); + close(fd); + exit(1); + } + + sleep(10); + + /*Unlock*/ + + printf("Releasing lock on %s\n", file_path); + lock.l_type = F_UNLCK; + ret = fcntl(fd, F_SETLK, &lock); + if (ret) { + printf("Failed to release lock on %s (%m)\n", file_path); + } + + close(fd); + return ret; } diff --git a/tests/bitrot/br-stub.c b/tests/bitrot/br-stub.c index 5b862832e77..1111f710f59 100644 --- a/tests/bitrot/br-stub.c +++ b/tests/bitrot/br-stub.c @@ -15,179 +15,181 @@ /* NOTE: no size discovery */ int -brstub_validate_version (char *bpath, unsigned long version) +brstub_validate_version(char *bpath, unsigned long version) { - int ret = 0; - int match = 0; - size_t xsize = 0; - br_version_t *xv = NULL; - - xsize = sizeof (br_version_t); - - xv = calloc (1, xsize); - if (!xv) { - match = -1; - goto err; - } - - ret = getxattr (bpath, "trusted.bit-rot.version", xv, xsize); - if (ret < 0) { - if (errno == ENODATA) - match = -2; - goto err; - } - - if (xv->ongoingversion != version) { - match = -3; - fprintf (stderr, "ongoingversion: %lu\n", xv->ongoingversion); - } - free (xv); - - err: - return match; + int ret = 0; + int match = 0; + size_t xsize = 0; + br_version_t *xv = NULL; + + xsize = sizeof(br_version_t); + + xv = calloc(1, xsize); + if (!xv) { + match = -1; + goto err; + } + + ret = getxattr(bpath, "trusted.bit-rot.version", xv, xsize); + if (ret < 0) { + if (errno == ENODATA) + match = -2; + goto err; + } + + if (xv->ongoingversion != version) { + match = -3; + fprintf(stderr, "ongoingversion: %lu\n", xv->ongoingversion); + } + free(xv); + +err: + return match; } int -brstub_write_validation (char *filp, char *bpath, unsigned long startversion) +brstub_write_validation(char *filp, char *bpath, unsigned long startversion) { - int fd1 = 0; - int fd2 = 0; - int ret = 0; - char *string = "string\n"; - - /* read only check */ - fd1 = open (filp, O_RDONLY); - if (fd1 < 0) - goto err; - close (fd1); - - ret = brstub_validate_version (bpath, startversion); - if (ret != -2) - goto err; - - /* single open (write/) check */ - fd1 = open (filp, O_RDWR); - if (fd1 < 0) - goto err; - - ret = write (fd1, string, strlen (string)); - if (ret <= 0) - goto err; - /** - * Fsync is done so that the write call has properly reached the - * disk. For fuse mounts write-behind xlator would have held the - * writes with itself and for nfs, client would have held the - * write in its cache. So write fop would not have triggered the - * versioning as it would have not reached the bit-rot-stub. - */ - fsync (fd1); - ret = brstub_validate_version (bpath, startversion); - if (ret != 0) - goto err; - ret = write (fd1, string, strlen (string)); - if (ret <= 0) - goto err; - fsync (fd1); /* let it reach the disk */ - - ret = brstub_validate_version (bpath, startversion); - if (ret != 0) - goto err; - - close (fd1); - - /** - * Well, this is not a _real_ test per se . For this test to pass - * the inode should not get a forget() in the interim. Therefore, - * perform this test asap. - */ - - /* multi open (write/) check */ - fd1 = open (filp, O_RDWR); - if (fd1 < 0) - goto err; - fd2 = open (filp, O_WRONLY); - if (fd1 < 0) - goto err; - - ret = write (fd1, string, strlen (string)); - if (ret <= 0) - goto err; - - ret = write (fd2, string, strlen (string)); - if (ret <= 0) - goto err; - - /* probably do a syncfs() */ - fsync (fd1); - fsync (fd2); - - close (fd1); - close (fd2); - - /** - * incremented once per write()/write().../close()/close() sequence - */ - ret = brstub_validate_version (bpath, startversion); - if (ret != 0) - goto err; - - return 0; - - err: - return -1; + int fd1 = 0; + int fd2 = 0; + int ret = 0; + char *string = "string\n"; + + /* read only check */ + fd1 = open(filp, O_RDONLY); + if (fd1 < 0) + goto err; + close(fd1); + + ret = brstub_validate_version(bpath, startversion); + if (ret != -2) + goto err; + + /* single open (write/) check */ + fd1 = open(filp, O_RDWR); + if (fd1 < 0) + goto err; + + ret = write(fd1, string, strlen(string)); + if (ret <= 0) + goto err; + /** + * Fsync is done so that the write call has properly reached the + * disk. For fuse mounts write-behind xlator would have held the + * writes with itself and for nfs, client would have held the + * write in its cache. So write fop would not have triggered the + * versioning as it would have not reached the bit-rot-stub. + */ + fsync(fd1); + ret = brstub_validate_version(bpath, startversion); + if (ret != 0) + goto err; + ret = write(fd1, string, strlen(string)); + if (ret <= 0) + goto err; + fsync(fd1); /* let it reach the disk */ + + ret = brstub_validate_version(bpath, startversion); + if (ret != 0) + goto err; + + close(fd1); + + /** + * Well, this is not a _real_ test per se . For this test to pass + * the inode should not get a forget() in the interim. Therefore, + * perform this test asap. + */ + + /* multi open (write/) check */ + fd1 = open(filp, O_RDWR); + if (fd1 < 0) + goto err; + fd2 = open(filp, O_WRONLY); + if (fd1 < 0) + goto err; + + ret = write(fd1, string, strlen(string)); + if (ret <= 0) + goto err; + + ret = write(fd2, string, strlen(string)); + if (ret <= 0) + goto err; + + /* probably do a syncfs() */ + fsync(fd1); + fsync(fd2); + + close(fd1); + close(fd2); + + /** + * incremented once per write()/write().../close()/close() sequence + */ + ret = brstub_validate_version(bpath, startversion); + if (ret != 0) + goto err; + + return 0; + +err: + return -1; } int -brstub_new_object_validate (char *filp, char *brick) +brstub_new_object_validate(char *filp, char *brick) { - int ret = 0; - char *fname = NULL; - char bpath[PATH_MAX] = {0,}; + int ret = 0; + char *fname = NULL; + char bpath[PATH_MAX] = { + 0, + }; - fname = basename (filp); - if (!fname) - goto err; + fname = basename(filp); + if (!fname) + goto err; - (void) snprintf (bpath, PATH_MAX, "%s/%s", brick, fname); + (void)snprintf(bpath, PATH_MAX, "%s/%s", brick, fname); - printf ("Validating initial version..\n"); - ret = brstub_validate_version (bpath, 2); - if (ret != -2) /* version _should_ be missing */ - goto err; + printf("Validating initial version..\n"); + ret = brstub_validate_version(bpath, 2); + if (ret != -2) /* version _should_ be missing */ + goto err; - printf ("Validating version on modifications..\n"); - ret = brstub_write_validation (filp, bpath, 2); - if (ret < 0) - goto err; + printf("Validating version on modifications..\n"); + ret = brstub_write_validation(filp, bpath, 2); + if (ret < 0) + goto err; - return 0; + return 0; - err: - return -1; +err: + return -1; } int -main (int argc, char **argv) +main(int argc, char **argv) { - int ret = 0; - char *filp = NULL; - char *brick = NULL; + int ret = 0; + char *filp = NULL; + char *brick = NULL; - if (argc != 3) { - printf ("Usage: %s <path> <brick>\n", argv[0]); - goto err; - } + if (argc != 3) { + printf("Usage: %s <path> <brick>\n", argv[0]); + goto err; + } - filp = argv[1]; - brick = argv[2]; + filp = argv[1]; + brick = argv[2]; - printf ("Validating object version [%s]\n", filp); - ret = brstub_new_object_validate (filp, brick); - if (ret < 0) - goto err; + printf("Validating object version [%s]\n", filp); + ret = brstub_new_object_validate(filp, brick); + if (ret < 0) + goto err; - return 0; + return 0; - err: - return -1; +err: + return -1; } diff --git a/tests/bugs/access-control/bug-1051896.c b/tests/bugs/access-control/bug-1051896.c index 27aa1559453..31799d97a71 100644 --- a/tests/bugs/access-control/bug-1051896.c +++ b/tests/bugs/access-control/bug-1051896.c @@ -13,85 +13,82 @@ #include <utime.h> #include <sys/acl.h> -int do_setfacl(const char *path, const char *options, const char *textacl) +int +do_setfacl(const char *path, const char *options, const char *textacl) { - int r; - int type; - acl_t acl; - int dob; - int dok; - int dom; - struct stat st; - char textmode[30]; + int r; + int type; + acl_t acl; + int dob; + int dok; + int dom; + struct stat st; + char textmode[30]; - r = 0; - dob = strchr(options, 'b') != (char *)NULL; - dok = strchr(options, 'k') != (char *)NULL; - dom = strchr(options, 'm') != (char *)NULL; - if ((dom && !textacl) - || (!dom && (textacl || (!dok && !dob) || - strchr(options, 'd')))) { - errno = EBADRQC; /* "bad request" */ - r = -1; - } else { - if (dob || dok) { - r = acl_delete_def_file(path); - } - if (dob && !r) { - if (!stat(path, &st)) { - sprintf(textmode, - "u::%c%c%c,g::%c%c%c,o::%c%c%c", - (st.st_mode & 0400 ? 'r' : '-'), - (st.st_mode & 0200 ? 'w' : '-'), - (st.st_mode & 0100 ? 'x' : '-'), - (st.st_mode & 0040 ? 'r' : '-'), - (st.st_mode & 0020 ? 'w' : '-'), - (st.st_mode & 0010 ? 'x' : '-'), - (st.st_mode & 004 ? 'r' : '-'), - (st.st_mode & 002 ? 'w' : '-'), - (st.st_mode & 001 ? 'x' : '-')); - acl = acl_from_text(textmode); - if (acl) { - r = acl_set_file(path, - ACL_TYPE_ACCESS, acl); - acl_free(acl); - } else - r = -1; - } else - r = -1; - } - if (!r && dom) { - if (strchr(options, 'd')) - type = ACL_TYPE_DEFAULT; - else - type = ACL_TYPE_ACCESS; - acl = acl_from_text(textacl); - if (acl) { - r = acl_set_file(path, type, acl); - acl_free(acl); - } else - r = -1; - } - } - if (r) - r = -errno; - return r; + r = 0; + dob = strchr(options, 'b') != (char *)NULL; + dok = strchr(options, 'k') != (char *)NULL; + dom = strchr(options, 'm') != (char *)NULL; + if ((dom && !textacl) || + (!dom && (textacl || (!dok && !dob) || strchr(options, 'd')))) { + errno = EBADRQC; /* "bad request" */ + r = -1; + } else { + if (dob || dok) { + r = acl_delete_def_file(path); + } + if (dob && !r) { + if (!stat(path, &st)) { + sprintf(textmode, "u::%c%c%c,g::%c%c%c,o::%c%c%c", + (st.st_mode & 0400 ? 'r' : '-'), + (st.st_mode & 0200 ? 'w' : '-'), + (st.st_mode & 0100 ? 'x' : '-'), + (st.st_mode & 0040 ? 'r' : '-'), + (st.st_mode & 0020 ? 'w' : '-'), + (st.st_mode & 0010 ? 'x' : '-'), + (st.st_mode & 004 ? 'r' : '-'), + (st.st_mode & 002 ? 'w' : '-'), + (st.st_mode & 001 ? 'x' : '-')); + acl = acl_from_text(textmode); + if (acl) { + r = acl_set_file(path, ACL_TYPE_ACCESS, acl); + acl_free(acl); + } else + r = -1; + } else + r = -1; + } + if (!r && dom) { + if (strchr(options, 'd')) + type = ACL_TYPE_DEFAULT; + else + type = ACL_TYPE_ACCESS; + acl = acl_from_text(textacl); + if (acl) { + r = acl_set_file(path, type, acl); + acl_free(acl); + } else + r = -1; + } + } + if (r) + r = -errno; + return r; } - -int main(int argc, char *argv[]) +int +main(int argc, char *argv[]) { - int rc = 0; + int rc = 0; - if (argc != 4) { - fprintf(stderr, - "usage: ./setfacl_test <path> <options> <textacl>\n"); - return 0; - } - rc = do_setfacl(argv[1], argv[2], argv[3]); - if (rc != 0) { - fprintf(stderr, "do_setfacl failed: %s\n", strerror(errno)); - return rc; - } - return 0; + if (argc != 4) { + fprintf(stderr, "usage: ./setfacl_test <path> <options> <textacl>\n"); + return 0; + } + rc = do_setfacl(argv[1], argv[2], argv[3]); + if (rc != 0) { + fprintf(stderr, "do_setfacl failed: %s\n", strerror(errno)); + return rc; + } + return 0; } diff --git a/tests/bugs/access-control/bug-1387241.c b/tests/bugs/access-control/bug-1387241.c index 04e0d6ea11f..e2e843a2fda 100644 --- a/tests/bugs/access-control/bug-1387241.c +++ b/tests/bugs/access-control/bug-1387241.c @@ -3,15 +3,16 @@ #include <unistd.h> #include <fcntl.h> -int main(int argc, char *argv[]) +int +main(int argc, char *argv[]) { - int ret = EXIT_FAILURE; - int fd = open(argv[1], O_RDONLY|O_TRUNC); + int ret = EXIT_FAILURE; + int fd = open(argv[1], O_RDONLY | O_TRUNC); - if (fd) { - ret = EXIT_SUCCESS; - close(fd); - } + if (fd) { + ret = EXIT_SUCCESS; + close(fd); + } - return ret; + return ret; } diff --git a/tests/bugs/cli/bug-1169302.c b/tests/bugs/cli/bug-1169302.c index aa9f950abf2..7c6b5fbf856 100644 --- a/tests/bugs/cli/bug-1169302.c +++ b/tests/bugs/cli/bug-1169302.c @@ -7,72 +7,73 @@ int keep_running = 1; -void stop_running(int sig) +void +stop_running(int sig) { - if (sig == SIGTERM) - keep_running = 0; + if (sig == SIGTERM) + keep_running = 0; } int -main (int argc, char *argv[]) +main(int argc, char *argv[]) { - glfs_t *fs = NULL; - int ret = 0; - glfs_fd_t *fd = NULL; - char *filename = NULL; - char *logfile = NULL; - char *host = NULL; - - if (argc != 5) { - return -1; - } - - host = argv[2]; - logfile = argv[3]; - filename = argv[4]; - - /* setup signal handler for exiting */ - signal (SIGTERM, stop_running); - - fs = glfs_new (argv[1]); - if (!fs) { - return -1; - } - - ret = glfs_set_volfile_server (fs, "tcp", host, 24007); - if (ret < 0) { - return -1; - } - - ret = glfs_set_logging (fs, logfile, 7); - if (ret < 0) { - return -1; - } - - ret = glfs_init (fs); - if (ret < 0) { - return -1; - } - - fd = glfs_creat (fs, filename, O_RDWR, 0644); - if (!fd) { - return -1; - } - - /* sleep until SIGTERM has been received */ - while (keep_running) { - sleep (1); - } - - ret = glfs_close (fd); - if (ret < 0) { - return -1; - } - - ret = glfs_fini (fs); - if (ret < 0) { - return -1; - } - - return 0; + glfs_t *fs = NULL; + int ret = 0; + glfs_fd_t *fd = NULL; + char *filename = NULL; + char *logfile = NULL; + char *host = NULL; + + if (argc != 5) { + return -1; + } + + host = argv[2]; + logfile = argv[3]; + filename = argv[4]; + + /* setup signal handler for exiting */ + signal(SIGTERM, stop_running); + + fs = glfs_new(argv[1]); + if (!fs) { + return -1; + } + + ret = glfs_set_volfile_server(fs, "tcp", host, 24007); + if (ret < 0) { + return -1; + } + + ret = glfs_set_logging(fs, logfile, 7); + if (ret < 0) { + return -1; + } + + ret = glfs_init(fs); + if (ret < 0) { + return -1; + } + + fd = glfs_creat(fs, filename, O_RDWR, 0644); + if (!fd) { + return -1; + } + + /* sleep until SIGTERM has been received */ + while (keep_running) { + sleep(1); + } + + ret = glfs_close(fd); + if (ret < 0) { + return -1; + } + + ret = glfs_fini(fs); + if (ret < 0) { + return -1; + } + + return 0; } diff --git a/tests/bugs/core/bug-834465.c b/tests/bugs/core/bug-834465.c index 61d3deac077..33dd270b112 100644 --- a/tests/bugs/core/bug-834465.c +++ b/tests/bugs/core/bug-834465.c @@ -7,55 +7,54 @@ #include <fcntl.h> int -main (int argc, char *argv[]) +main(int argc, char *argv[]) { - int fd = -1; - char *filename = NULL; - struct flock lock = {0, }; - int i = 0; - int ret = -1; - - if (argc != 2) { - fprintf (stderr, "Usage: %s <filename> ", argv[0]); - goto out; + int fd = -1; + char *filename = NULL; + struct flock lock = { + 0, + }; + int i = 0; + int ret = -1; + + if (argc != 2) { + fprintf(stderr, "Usage: %s <filename> ", argv[0]); + goto out; + } + + filename = argv[1]; + + fd = open(filename, O_RDWR | O_CREAT, 0); + if (fd < 0) { + fprintf(stderr, "open (%s) failed (%s)\n", filename, strerror(errno)); + goto out; + } + + lock.l_type = F_WRLCK; + lock.l_whence = SEEK_SET; + lock.l_start = 1; + lock.l_len = 1; + + while (i < 100) { + lock.l_type = F_WRLCK; + ret = fcntl(fd, F_SETLK, &lock); + if (ret < 0) { + fprintf(stderr, "fcntl setlk failed (%s)\n", strerror(errno)); + goto out; } - filename = argv[1]; - - fd = open (filename, O_RDWR | O_CREAT, 0); - if (fd < 0) { - fprintf (stderr, "open (%s) failed (%s)\n", filename, - strerror (errno)); - goto out; + lock.l_type = F_UNLCK; + ret = fcntl(fd, F_SETLK, &lock); + if (ret < 0) { + fprintf(stderr, "fcntl setlk failed (%s)\n", strerror(errno)); + goto out; } - lock.l_type = F_WRLCK; - lock.l_whence = SEEK_SET; - lock.l_start = 1; - lock.l_len = 1; - - while (i < 100) { - lock.l_type = F_WRLCK; - ret = fcntl (fd, F_SETLK, &lock); - if (ret < 0) { - fprintf (stderr, "fcntl setlk failed (%s)\n", - strerror (errno)); - goto out; - } - - lock.l_type = F_UNLCK; - ret = fcntl (fd, F_SETLK, &lock); - if (ret < 0) { - fprintf (stderr, "fcntl setlk failed (%s)\n", - strerror (errno)); - goto out; - } - - i++; - } + i++; + } - ret = 0; + ret = 0; out: - return ret; + return ret; } diff --git a/tests/bugs/distribute/bug-1193636.c b/tests/bugs/distribute/bug-1193636.c index 438efa8e686..ea3f79a4e06 100644 --- a/tests/bugs/distribute/bug-1193636.c +++ b/tests/bugs/distribute/bug-1193636.c @@ -5,66 +5,64 @@ #include <fcntl.h> #include <string.h> +#define MY_XATTR_NAME "user.ftest" +#define MY_XATTR_VAL "ftestval" -#define MY_XATTR_NAME "user.ftest" -#define MY_XATTR_VAL "ftestval" - - -void usage (void) +void +usage(void) { - printf ("Usage : bug-1193636 <filename> <xattr_name> <op>\n"); - printf (" op : 0 - set, 1 - remove\n"); + printf("Usage : bug-1193636 <filename> <xattr_name> <op>\n"); + printf(" op : 0 - set, 1 - remove\n"); } - -int main (int argc, char **argv) +int +main(int argc, char **argv) { - int fd; - int err = 0; - char *xattr_name = NULL; - int op = 0; - - if (argc != 4) { - usage (); - exit (1); - } - - op = atoi (argv[3]); - - if ((op != 0) && (op != 1)) { - printf ("Invalid operation specified.\n"); - usage (); - exit (1); + int fd; + int err = 0; + char *xattr_name = NULL; + int op = 0; + + if (argc != 4) { + usage(); + exit(1); + } + + op = atoi(argv[3]); + + if ((op != 0) && (op != 1)) { + printf("Invalid operation specified.\n"); + usage(); + exit(1); + } + + xattr_name = argv[2]; + + fd = open(argv[1], O_RDWR); + if (fd == -1) { + printf("Failed to open file %s\n", argv[1]); + exit(1); + } + + if (!op) { + err = fsetxattr(fd, xattr_name, MY_XATTR_VAL, strlen(MY_XATTR_VAL) + 1, + XATTR_CREATE); + + if (err) { + printf("Failed to set xattr %s: %m\n", xattr_name); + exit(1); } - xattr_name = argv[2]; + } else { + err = fremovexattr(fd, xattr_name); - fd = open(argv[1], O_RDWR); - if (fd == -1) { - printf ("Failed to open file %s\n", argv[1]); - exit (1); + if (err) { + printf("Failed to remove xattr %s: %m\n", xattr_name); + exit(1); } + } - if (!op) { - err = fsetxattr (fd, xattr_name, MY_XATTR_VAL, - strlen (MY_XATTR_VAL) + 1, XATTR_CREATE); + close(fd); - if (err) { - printf ("Failed to set xattr %s: %m\n", xattr_name); - exit (1); - } - - } else { - err = fremovexattr (fd, xattr_name); - - if (err) { - printf ("Failed to remove xattr %s: %m\n", xattr_name); - exit (1); - } - } - - close (fd); - - return 0; + return 0; } - diff --git a/tests/bugs/distribute/bug-860663.c b/tests/bugs/distribute/bug-860663.c index bee4e7d40b1..ca0c31ffe8f 100644 --- a/tests/bugs/distribute/bug-860663.c +++ b/tests/bugs/distribute/bug-860663.c @@ -6,38 +6,36 @@ #include <err.h> #include <sys/param.h> -int -main(argc, argv) - int argc; - char **argv; +int main(argc, argv) int argc; +char **argv; { - char *basepath; - char path[MAXPATHLEN + 1]; - unsigned int count; - int i, fd; + char *basepath; + char path[MAXPATHLEN + 1]; + unsigned int count; + int i, fd; - if (argc != 3) - errx(1, "usage: %s path count", argv[0]); + if (argc != 3) + errx(1, "usage: %s path count", argv[0]); - basepath = argv[1]; - count = atoi(argv[2]); + basepath = argv[1]; + count = atoi(argv[2]); - if (count > 999999) - errx(1, "count too big"); + if (count > 999999) + errx(1, "count too big"); - if (strlen(basepath) > MAXPATHLEN - 6) - errx(1, "path too long"); + if (strlen(basepath) > MAXPATHLEN - 6) + errx(1, "path too long"); - for (i = 0; i < count; i++) { - (void)sprintf(path, "%s%06d", basepath, i); + for (i = 0; i < count; i++) { + (void)sprintf(path, "%s%06d", basepath, i); - fd = open(path, O_CREAT|O_RDWR, 0644); - if (fd == -1) - err(1, "create %s failed", path); + fd = open(path, O_CREAT | O_RDWR, 0644); + if (fd == -1) + err(1, "create %s failed", path); - if (close(fd) != 0) - warn("close %s failed", path); - } + if (close(fd) != 0) + warn("close %s failed", path); + } - return 0; + return 0; } diff --git a/tests/bugs/ec/bug-1161886.c b/tests/bugs/ec/bug-1161886.c index 1faae831898..1f12650ea6d 100644 --- a/tests/bugs/ec/bug-1161886.c +++ b/tests/bugs/ec/bug-1161886.c @@ -4,50 +4,50 @@ #include <glusterfs/api/glfs-handles.h> int -main (int argc, char *argv[]) +main(int argc, char *argv[]) { - glfs_t *fs = NULL; - glfs_fd_t *fd = NULL; - int ret = 1; - - if (argc != 4) { - fprintf (stderr, "Syntax: %s <host> <volname> <file>\n", argv[0]); - return 1; - } - - fs = glfs_new (argv[2]); - if (!fs) { - fprintf (stderr, "glfs_new: returned NULL\n"); - return 1; - } - - ret = glfs_set_volfile_server (fs, "tcp", argv[1], 24007); - if (ret != 0) { - fprintf (stderr, "glfs_set_volfile_server: returned %d\n", ret); - goto out; - } - ret = glfs_set_logging (fs, "/dev/null", 7); - if (ret != 0) { - fprintf (stderr, "glfs_set_logging: returned %d\n", ret); - goto out; - } - ret = glfs_init (fs); - if (ret != 0) { - fprintf (stderr, "glfs_init: returned %d\n", ret); - goto out; - } - - fd = glfs_open (fs, argv[3], O_RDWR | O_TRUNC); - if (fd == NULL) { - fprintf (stderr, "glfs_open: returned NULL\n"); - goto out; - } - glfs_close(fd); - - ret = 0; + glfs_t *fs = NULL; + glfs_fd_t *fd = NULL; + int ret = 1; + + if (argc != 4) { + fprintf(stderr, "Syntax: %s <host> <volname> <file>\n", argv[0]); + return 1; + } + + fs = glfs_new(argv[2]); + if (!fs) { + fprintf(stderr, "glfs_new: returned NULL\n"); + return 1; + } + + ret = glfs_set_volfile_server(fs, "tcp", argv[1], 24007); + if (ret != 0) { + fprintf(stderr, "glfs_set_volfile_server: returned %d\n", ret); + goto out; + } + ret = glfs_set_logging(fs, "/dev/null", 7); + if (ret != 0) { + fprintf(stderr, "glfs_set_logging: returned %d\n", ret); + goto out; + } + ret = glfs_init(fs); + if (ret != 0) { + fprintf(stderr, "glfs_init: returned %d\n", ret); + goto out; + } + + fd = glfs_open(fs, argv[3], O_RDWR | O_TRUNC); + if (fd == NULL) { + fprintf(stderr, "glfs_open: returned NULL\n"); + goto out; + } + glfs_close(fd); + + ret = 0; out: - glfs_fini (fs); + glfs_fini(fs); - return ret; + return ret; } diff --git a/tests/bugs/fuse/bug-1126048.c b/tests/bugs/fuse/bug-1126048.c index 01c3484172d..19165ecf6f7 100644 --- a/tests/bugs/fuse/bug-1126048.c +++ b/tests/bugs/fuse/bug-1126048.c @@ -12,30 +12,32 @@ * fsync should fail without crashing the mount process. */ int -main (int argc, char **argv) +main(int argc, char **argv) { - int ret = 0; - int fd = 0; - char *cmd = argv[1]; - struct stat stbuf = {0, }; + int ret = 0; + int fd = 0; + char *cmd = argv[1]; + struct stat stbuf = { + 0, + }; - printf ("cmd is: %s\n", cmd); - fd = open("a.txt", O_CREAT|O_RDWR, 0644); - if (fd < 0) - printf ("open failed: %s\n", strerror(errno)); + printf("cmd is: %s\n", cmd); + fd = open("a.txt", O_CREAT | O_RDWR, 0644); + if (fd < 0) + printf("open failed: %s\n", strerror(errno)); - ret = unlink("a.txt"); - if (ret < 0) - printf ("unlink failed: %s\n", strerror(errno)); - if (write (fd, "abc", 3) < 0) - printf ("Not able to print %s\n", strerror (errno)); - system(cmd); - sleep(1); /* No way to confirm graph switch so sleep 1 */ - ret = fstat (fd, &stbuf); - if (ret < 0) - printf ("fstat failed %\n", strerror (errno)); - ret = fsync(fd); - if (ret < 0) - printf ("Not able to fsync %s\n", strerror (errno)); - return 0; + ret = unlink("a.txt"); + if (ret < 0) + printf("unlink failed: %s\n", strerror(errno)); + if (write(fd, "abc", 3) < 0) + printf("Not able to print %s\n", strerror(errno)); + system(cmd); + sleep(1); /* No way to confirm graph switch so sleep 1 */ + ret = fstat(fd, &stbuf); + if (ret < 0) + printf("fstat failed %\n", strerror(errno)); + ret = fsync(fd); + if (ret < 0) + printf("Not able to fsync %s\n", strerror(errno)); + return 0; } diff --git a/tests/bugs/gfapi/bug-1093594.c b/tests/bugs/gfapi/bug-1093594.c index aff271e4caf..f7a06dd5ba8 100644 --- a/tests/bugs/gfapi/bug-1093594.c +++ b/tests/bugs/gfapi/bug-1093594.c @@ -5,7 +5,7 @@ #include <stdlib.h> #include <string.h> -#define WRITE_SIZE (128*1024) +#define WRITE_SIZE (128 * 1024) #define READ_WRITE_LOOP 100 #define FOP_LOOP_COUNT 20 #define TEST_CASE_LOOP 20 @@ -14,304 +14,298 @@ int gfapi = 1; static int extension = 1; static int -large_number_of_fops (glfs_t *fs) { - int ret = 0; - int i = 0; - glfs_fd_t *fd = NULL; - glfs_fd_t *fd1 = NULL; - char *dir1 = NULL, *dir2 = NULL, *filename1 = NULL, *filename2 = NULL; - char *buf = NULL; - struct stat sb = {0, }; - - for (i = 0 ; i < FOP_LOOP_COUNT ; i++) { - ret = asprintf (&dir1, "dir%d", extension); - if (ret < 0) { - fprintf (stderr, "cannot construct filename (%s)", - strerror (errno)); - return ret; - } - - extension++; - - ret = glfs_mkdir (fs, dir1, 0755); - if (ret < 0) { - fprintf (stderr, "mkdir(%s): %s\n", dir1, strerror (errno)); - return -1; - } - - fd = glfs_opendir (fs, dir1); - if (!fd) { - fprintf (stderr, "/: %s\n", strerror (errno)); - return -1; - } - - ret = glfs_fsetxattr (fd, "user.dirfattr", "fsetxattr", 8, 0); - if (ret < 0) { - fprintf (stderr, "fsetxattr(%s): %d (%s)\n", dir1, ret, - strerror (errno)); - return -1; - } - - ret = glfs_closedir (fd); - if (ret < 0) { - fprintf (stderr, "glfs_closedir failed with ret: %d (%s)\n", - ret, strerror (errno)); - return -1; - } - - ret = glfs_rmdir (fs, dir1); - if (ret < 0) { - fprintf (stderr, "glfs_unlink failed with ret: %d (%s)\n", - ret, strerror (errno)); - return -1; - } - - ret = asprintf (&filename1, "file%d", extension); - if (ret < 0) { - fprintf (stderr, "cannot construct filename (%s)", - strerror (errno)); - return ret; - } - - ret = asprintf (&filename2, "file-%d", extension); - if (ret < 0) { - fprintf (stderr, "cannot construct filename (%s)", - strerror (errno)); - return ret; - } - - extension++; - - fd = glfs_creat (fs, filename1, O_RDWR, 0644); - if (!fd) { - fprintf (stderr, "%s: (%p) %s\n", filename1, fd, - strerror (errno)); - return -1; - } - - ret = glfs_rename (fs, filename1, filename2); - if (ret < 0) { - fprintf (stderr, "glfs_rename failed with ret: %d (%s)\n", - ret, strerror (errno)); - return -1; - } - - ret = glfs_lstat (fs, filename2, &sb); - if (ret < 0) { - fprintf (stderr, "glfs_lstat failed with ret: %d (%s)\n", - ret, strerror (errno)); - return -1; - } - - ret = glfs_close (fd); - if (ret < 0) { - fprintf (stderr, "glfs_close failed with ret: %d (%s)\n", - ret, strerror (errno)); - return -1; - } - - ret = glfs_unlink (fs, filename2); - if (ret < 0) { - fprintf (stderr, "glfs_unlink failed with ret: %d (%s)\n", - ret, strerror (errno)); - return -1; - } +large_number_of_fops(glfs_t *fs) +{ + int ret = 0; + int i = 0; + glfs_fd_t *fd = NULL; + glfs_fd_t *fd1 = NULL; + char *dir1 = NULL, *dir2 = NULL, *filename1 = NULL, *filename2 = NULL; + char *buf = NULL; + struct stat sb = { + 0, + }; + + for (i = 0; i < FOP_LOOP_COUNT; i++) { + ret = asprintf(&dir1, "dir%d", extension); + if (ret < 0) { + fprintf(stderr, "cannot construct filename (%s)", strerror(errno)); + return ret; } -} -static int -large_read_write (glfs_t *fs) { + extension++; - int ret = 0; - int j = 0; - glfs_fd_t *fd = NULL; - glfs_fd_t *fd1 = NULL; - char *filename = NULL; - char *buf = NULL; + ret = glfs_mkdir(fs, dir1, 0755); + if (ret < 0) { + fprintf(stderr, "mkdir(%s): %s\n", dir1, strerror(errno)); + return -1; + } - ret = asprintf (&filename, "filerw%d", extension); + fd = glfs_opendir(fs, dir1); + if (!fd) { + fprintf(stderr, "/: %s\n", strerror(errno)); + return -1; + } + + ret = glfs_fsetxattr(fd, "user.dirfattr", "fsetxattr", 8, 0); if (ret < 0) { - fprintf (stderr, "cannot construct filename (%s)", - strerror (errno)); - return ret; + fprintf(stderr, "fsetxattr(%s): %d (%s)\n", dir1, ret, + strerror(errno)); + return -1; } - extension++; + ret = glfs_closedir(fd); + if (ret < 0) { + fprintf(stderr, "glfs_closedir failed with ret: %d (%s)\n", ret, + strerror(errno)); + return -1; + } - fd = glfs_creat (fs, filename, O_RDWR, 0644); - if (!fd) { - fprintf (stderr, "%s: (%p) %s\n", filename, fd, - strerror (errno)); - return -1; + ret = glfs_rmdir(fs, dir1); + if (ret < 0) { + fprintf(stderr, "glfs_unlink failed with ret: %d (%s)\n", ret, + strerror(errno)); + return -1; } - buf = (char *) malloc (WRITE_SIZE); - memset (buf, '-', WRITE_SIZE); + ret = asprintf(&filename1, "file%d", extension); + if (ret < 0) { + fprintf(stderr, "cannot construct filename (%s)", strerror(errno)); + return ret; + } - for (j = 0; j < READ_WRITE_LOOP; j++) { - ret = glfs_write (fd, buf, WRITE_SIZE, 0); - if (ret < 0) { - fprintf (stderr, "Write(%s): %d (%s)\n", filename, ret, - strerror (errno)); - return ret; - } + ret = asprintf(&filename2, "file-%d", extension); + if (ret < 0) { + fprintf(stderr, "cannot construct filename (%s)", strerror(errno)); + return ret; } - fd1 = glfs_open (fs, filename, O_RDWR); - if (fd1 < 0) { - fprintf (stderr, "Open(%s): %d (%s)\n", filename, ret, - strerror (errno)); - return -1; + extension++; + + fd = glfs_creat(fs, filename1, O_RDWR, 0644); + if (!fd) { + fprintf(stderr, "%s: (%p) %s\n", filename1, fd, strerror(errno)); + return -1; } - glfs_lseek (fd1, 0, SEEK_SET); - for (j = 0; j < READ_WRITE_LOOP; j++) { - ret = glfs_read (fd1, buf, WRITE_SIZE, 0); - if (ret < 0) { - fprintf (stderr, "Read(%s): %d (%s)\n", filename, ret, - strerror (errno)); - return ret; - } + ret = glfs_rename(fs, filename1, filename2); + if (ret < 0) { + fprintf(stderr, "glfs_rename failed with ret: %d (%s)\n", ret, + strerror(errno)); + return -1; } - for (j = 0; j < READ_WRITE_LOOP; j++) { - ret = glfs_write (fd1, buf, WRITE_SIZE, 0); - if (ret < 0) { - fprintf (stderr, "Write(%s): %d (%s)\n", filename, ret, - strerror (errno)); - return ret; - } + ret = glfs_lstat(fs, filename2, &sb); + if (ret < 0) { + fprintf(stderr, "glfs_lstat failed with ret: %d (%s)\n", ret, + strerror(errno)); + return -1; } - glfs_close (fd); - glfs_close (fd1); - ret = glfs_unlink (fs, filename); + ret = glfs_close(fd); if (ret < 0) { - fprintf (stderr, "glfs_unlink failed with ret: %d (%s)\n", - ret, strerror (errno)); - return -1; + fprintf(stderr, "glfs_close failed with ret: %d (%s)\n", ret, + strerror(errno)); + return -1; } - free (buf); - free (filename); + ret = glfs_unlink(fs, filename2); + if (ret < 0) { + fprintf(stderr, "glfs_unlink failed with ret: %d (%s)\n", ret, + strerror(errno)); + return -1; + } + } } static int -volfile_change (const char *volname) { - int ret = 0; - char *cmd = NULL, *cmd1 = NULL; +large_read_write(glfs_t *fs) +{ + int ret = 0; + int j = 0; + glfs_fd_t *fd = NULL; + glfs_fd_t *fd1 = NULL; + char *filename = NULL; + char *buf = NULL; + + ret = asprintf(&filename, "filerw%d", extension); + if (ret < 0) { + fprintf(stderr, "cannot construct filename (%s)", strerror(errno)); + return ret; + } - ret = asprintf (&cmd, "gluster volume set %s stat-prefetch off", - volname); - if (ret < 0) { - fprintf (stderr, "cannot construct cli command string (%s)", - strerror (errno)); - return ret; - } + extension++; - ret = asprintf (&cmd1, "gluster volume set %s stat-prefetch on", - volname); + fd = glfs_creat(fs, filename, O_RDWR, 0644); + if (!fd) { + fprintf(stderr, "%s: (%p) %s\n", filename, fd, strerror(errno)); + return -1; + } + + buf = (char *)malloc(WRITE_SIZE); + memset(buf, '-', WRITE_SIZE); + + for (j = 0; j < READ_WRITE_LOOP; j++) { + ret = glfs_write(fd, buf, WRITE_SIZE, 0); if (ret < 0) { - fprintf (stderr, "cannot construct cli command string (%s)", - strerror (errno)); - return ret; + fprintf(stderr, "Write(%s): %d (%s)\n", filename, ret, + strerror(errno)); + return ret; } + } - ret = system (cmd); + fd1 = glfs_open(fs, filename, O_RDWR); + if (fd1 < 0) { + fprintf(stderr, "Open(%s): %d (%s)\n", filename, ret, strerror(errno)); + return -1; + } + + glfs_lseek(fd1, 0, SEEK_SET); + for (j = 0; j < READ_WRITE_LOOP; j++) { + ret = glfs_read(fd1, buf, WRITE_SIZE, 0); if (ret < 0) { - fprintf (stderr, "stat-prefetch off on (%s) failed", volname); - return ret; + fprintf(stderr, "Read(%s): %d (%s)\n", filename, ret, + strerror(errno)); + return ret; } + } - ret = system (cmd1); + for (j = 0; j < READ_WRITE_LOOP; j++) { + ret = glfs_write(fd1, buf, WRITE_SIZE, 0); if (ret < 0) { - fprintf (stderr, "stat-prefetch on on (%s) failed", volname); - return ret; + fprintf(stderr, "Write(%s): %d (%s)\n", filename, ret, + strerror(errno)); + return ret; } + } + + glfs_close(fd); + glfs_close(fd1); + ret = glfs_unlink(fs, filename); + if (ret < 0) { + fprintf(stderr, "glfs_unlink failed with ret: %d (%s)\n", ret, + strerror(errno)); + return -1; + } + + free(buf); + free(filename); +} - free (cmd); - free (cmd1); +static int +volfile_change(const char *volname) +{ + int ret = 0; + char *cmd = NULL, *cmd1 = NULL; + + ret = asprintf(&cmd, "gluster volume set %s stat-prefetch off", volname); + if (ret < 0) { + fprintf(stderr, "cannot construct cli command string (%s)", + strerror(errno)); return ret; + } + + ret = asprintf(&cmd1, "gluster volume set %s stat-prefetch on", volname); + if (ret < 0) { + fprintf(stderr, "cannot construct cli command string (%s)", + strerror(errno)); + return ret; + } + + ret = system(cmd); + if (ret < 0) { + fprintf(stderr, "stat-prefetch off on (%s) failed", volname); + return ret; + } + + ret = system(cmd1); + if (ret < 0) { + fprintf(stderr, "stat-prefetch on on (%s) failed", volname); + return ret; + } + + free(cmd); + free(cmd1); + return ret; } int -main (int argc, char *argv[]) +main(int argc, char *argv[]) { - glfs_t *fs = NULL; - int ret = 0; - int i = 0; - glfs_fd_t *fd = NULL; - glfs_fd_t *fd1 = NULL; - char *topdir = "topdir", *filename = "file1"; - char *buf = NULL; - char *logfile = NULL; - char *hostname = NULL; - - if (argc != 4) { - fprintf (stderr, - "Expect following args %s <hostname> <Vol> <log file>\n" - , argv[0]); - return -1; + glfs_t *fs = NULL; + int ret = 0; + int i = 0; + glfs_fd_t *fd = NULL; + glfs_fd_t *fd1 = NULL; + char *topdir = "topdir", *filename = "file1"; + char *buf = NULL; + char *logfile = NULL; + char *hostname = NULL; + + if (argc != 4) { + fprintf(stderr, + "Expect following args %s <hostname> <Vol> <log file>\n", + argv[0]); + return -1; + } + + hostname = argv[1]; + logfile = argv[3]; + + for (i = 0; i < TEST_CASE_LOOP; i++) { + fs = glfs_new(argv[2]); + if (!fs) { + fprintf(stderr, "glfs_new: returned NULL (%s)\n", strerror(errno)); + return -1; } - hostname = argv[1]; - logfile = argv[3]; - - for (i = 0; i < TEST_CASE_LOOP; i++) { - fs = glfs_new (argv[2]); - if (!fs) { - fprintf (stderr, "glfs_new: returned NULL (%s)\n", - strerror (errno)); - return -1; - } - - ret = glfs_set_volfile_server (fs, "tcp", hostname, 24007); - if (ret < 0) { - fprintf (stderr, "glfs_set_volfile_server failed ret:%d (%s)\n", - ret, strerror (errno)); - return -1; - } - - ret = glfs_set_logging (fs, logfile, 7); - if (ret < 0) { - fprintf (stderr, "glfs_set_logging failed with ret: %d (%s)\n", - ret, strerror (errno)); - return -1; - } - - ret = glfs_init (fs); - if (ret < 0) { - fprintf (stderr, "glfs_init failed with ret: %d (%s)\n", - ret, strerror (errno)); - return -1; - } - - ret = large_number_of_fops (fs); - if (ret < 0) - return -1; - - ret = large_read_write (fs); - if (ret < 0) - return -1; - - ret = volfile_change (argv[2]); - if (ret < 0) - return -1; - - ret = large_number_of_fops (fs); - if (ret < 0) - return -1; - - ret = large_read_write (fs); - if (ret < 0) - return -1; - - ret = glfs_fini (fs); - if (ret < 0) { - fprintf (stderr, "glfs_fini failed with ret: %d (%s)\n", - ret, strerror (errno)); - return -1; - } + ret = glfs_set_volfile_server(fs, "tcp", hostname, 24007); + if (ret < 0) { + fprintf(stderr, "glfs_set_volfile_server failed ret:%d (%s)\n", ret, + strerror(errno)); + return -1; + } + + ret = glfs_set_logging(fs, logfile, 7); + if (ret < 0) { + fprintf(stderr, "glfs_set_logging failed with ret: %d (%s)\n", ret, + strerror(errno)); + return -1; + } + + ret = glfs_init(fs); + if (ret < 0) { + fprintf(stderr, "glfs_init failed with ret: %d (%s)\n", ret, + strerror(errno)); + return -1; + } + + ret = large_number_of_fops(fs); + if (ret < 0) + return -1; + + ret = large_read_write(fs); + if (ret < 0) + return -1; + + ret = volfile_change(argv[2]); + if (ret < 0) + return -1; + + ret = large_number_of_fops(fs); + if (ret < 0) + return -1; + + ret = large_read_write(fs); + if (ret < 0) + return -1; + + ret = glfs_fini(fs); + if (ret < 0) { + fprintf(stderr, "glfs_fini failed with ret: %d (%s)\n", ret, + strerror(errno)); + return -1; } - return 0; + } + return 0; } diff --git a/tests/bugs/gfapi/bug-1319374.c b/tests/bugs/gfapi/bug-1319374.c index bf2da998d6e..bd80462e3ba 100644 --- a/tests/bugs/gfapi/bug-1319374.c +++ b/tests/bugs/gfapi/bug-1319374.c @@ -9,122 +9,122 @@ glfs_t * setup_new_client(char *hostname, char *volname, char *log_file, int flag) { - int ret = 0; - glfs_t *fs = NULL; - - fs = glfs_new (volname); - if (!fs) { - fprintf (stderr, "\nglfs_new: returned NULL (%s)\n", - strerror (errno)); - goto error; - } - - ret = glfs_set_volfile_server (fs, "tcp", hostname, 24007); - if (ret < 0) { - fprintf (stderr, "\nglfs_set_volfile_server failed ret:%d (%s)\n", - ret, strerror (errno)); - goto error; - } - - ret = glfs_set_logging (fs, log_file, 7); - if (ret < 0) { - fprintf (stderr, "\nglfs_set_logging failed with ret: %d (%s)\n", - ret, strerror (errno)); - goto error; - } - - if (flag == NO_INIT) - goto out; - - ret = glfs_init (fs); - if (ret < 0) { - fprintf (stderr, "\nglfs_init failed with ret: %d (%s)\n", - ret, strerror (errno)); - goto error; - } + int ret = 0; + glfs_t *fs = NULL; + + fs = glfs_new(volname); + if (!fs) { + fprintf(stderr, "\nglfs_new: returned NULL (%s)\n", strerror(errno)); + goto error; + } + + ret = glfs_set_volfile_server(fs, "tcp", hostname, 24007); + if (ret < 0) { + fprintf(stderr, "\nglfs_set_volfile_server failed ret:%d (%s)\n", ret, + strerror(errno)); + goto error; + } + + ret = glfs_set_logging(fs, log_file, 7); + if (ret < 0) { + fprintf(stderr, "\nglfs_set_logging failed with ret: %d (%s)\n", ret, + strerror(errno)); + goto error; + } + + if (flag == NO_INIT) + goto out; + + ret = glfs_init(fs); + if (ret < 0) { + fprintf(stderr, "\nglfs_init failed with ret: %d (%s)\n", ret, + strerror(errno)); + goto error; + } out: - return fs; + return fs; error: - return NULL; + return NULL; } int -main (int argc, char *argv[]) +main(int argc, char *argv[]) { - int ret = 0; - glfs_t *fs1 = NULL; - glfs_t *fs2 = NULL; - glfs_t *fs3 = NULL; - char *volname = NULL; - char *log_file = NULL; - char *hostname = NULL; - - if (argc != 4) { - fprintf (stderr, - "Expect following args %s <hostname> <Vol> <log file location>\n" - , argv[0]); - return -1; - } - - hostname = argv[1]; - volname = argv[2]; - log_file = argv[3]; - - fs1 = setup_new_client (hostname, volname, log_file, NO_INIT); - if (!fs1) { - fprintf (stderr, "\nsetup_new_client: returned NULL (%s)\n", - strerror (errno)); - goto error; - } - - fs2 = setup_new_client (hostname, volname, log_file, 0); - if (!fs2) { - fprintf (stderr, "\nsetup_new_client: returned NULL (%s)\n", - strerror (errno)); - goto error; - } - - fs3 = setup_new_client (hostname, volname, log_file, 0); - if (!fs3) { - fprintf (stderr, "\nsetup_new_client: returned NULL (%s)\n", - strerror (errno)); - goto error; - } - - ret = glfs_fini (fs3); - if (ret < 0) { - fprintf (stderr, "glfs_fini failed with ret: %d (%s)\n", - ret, strerror (errno)); - goto error; - } - - /* The crash is seen in gf_log_flush_timeout_cbk(), and this gets - * triggered when 30s timer expires, hence the sleep of 31s - */ - sleep (31); - ret = glfs_fini (fs2); - if (ret < 0) { - fprintf (stderr, "glfs_fini failed with ret: %d (%s)\n", - ret, strerror (errno)); - goto error; - } - - ret = glfs_init (fs1); - if (ret < 0) { - fprintf (stderr, "\nglfs_init failed with ret: %d (%s)\n", - ret, strerror (errno)); - goto error; - } - - ret = glfs_fini (fs1); - if (ret < 0) { - fprintf (stderr, "glfs_fini failed with ret: %d (%s)\n", - ret, strerror (errno)); - goto error; - } - - return 0; -error: + int ret = 0; + glfs_t *fs1 = NULL; + glfs_t *fs2 = NULL; + glfs_t *fs3 = NULL; + char *volname = NULL; + char *log_file = NULL; + char *hostname = NULL; + + if (argc != 4) { + fprintf( + stderr, + "Expect following args %s <hostname> <Vol> <log file location>\n", + argv[0]); return -1; + } + + hostname = argv[1]; + volname = argv[2]; + log_file = argv[3]; + + fs1 = setup_new_client(hostname, volname, log_file, NO_INIT); + if (!fs1) { + fprintf(stderr, "\nsetup_new_client: returned NULL (%s)\n", + strerror(errno)); + goto error; + } + + fs2 = setup_new_client(hostname, volname, log_file, 0); + if (!fs2) { + fprintf(stderr, "\nsetup_new_client: returned NULL (%s)\n", + strerror(errno)); + goto error; + } + + fs3 = setup_new_client(hostname, volname, log_file, 0); + if (!fs3) { + fprintf(stderr, "\nsetup_new_client: returned NULL (%s)\n", + strerror(errno)); + goto error; + } + + ret = glfs_fini(fs3); + if (ret < 0) { + fprintf(stderr, "glfs_fini failed with ret: %d (%s)\n", ret, + strerror(errno)); + goto error; + } + + /* The crash is seen in gf_log_flush_timeout_cbk(), and this gets + * triggered when 30s timer expires, hence the sleep of 31s + */ + sleep(31); + ret = glfs_fini(fs2); + if (ret < 0) { + fprintf(stderr, "glfs_fini failed with ret: %d (%s)\n", ret, + strerror(errno)); + goto error; + } + + ret = glfs_init(fs1); + if (ret < 0) { + fprintf(stderr, "\nglfs_init failed with ret: %d (%s)\n", ret, + strerror(errno)); + goto error; + } + + ret = glfs_fini(fs1); + if (ret < 0) { + fprintf(stderr, "glfs_fini failed with ret: %d (%s)\n", ret, + strerror(errno)); + goto error; + } + + return 0; +error: + return -1; } diff --git a/tests/bugs/gfapi/bug-1447266/1460514.c b/tests/bugs/gfapi/bug-1447266/1460514.c index f04d2d1463f..c721559a668 100644 --- a/tests/bugs/gfapi/bug-1447266/1460514.c +++ b/tests/bugs/gfapi/bug-1447266/1460514.c @@ -9,135 +9,142 @@ #include <glusterfs/api/glfs.h> #include <glusterfs/api/glfs-handles.h> -#define LOG_ERR(func, ret) do { \ - if (ret != 0) { \ - fprintf (stderr, "%s : returned error %d (%s)\n", \ - func, ret, strerror (errno)); \ - goto out; \ - } else { \ - fprintf (stderr, "%s : returned %d\n", func, ret); \ - } \ - } while (0) +#define LOG_ERR(func, ret) \ + do { \ + if (ret != 0) { \ + fprintf(stderr, "%s : returned error %d (%s)\n", func, ret, \ + strerror(errno)); \ + goto out; \ + } else { \ + fprintf(stderr, "%s : returned %d\n", func, ret); \ + } \ + } while (0) int -main (int argc, char *argv[]) +main(int argc, char *argv[]) { - int ret = 0; - glfs_t *fs = NULL; - struct glfs_object *root = NULL, *dir = NULL, *subdir = NULL; - struct stat sb = {0, }; - char *dirname = "dir"; - char *subdirname = "subdir"; - char *logfile = NULL; - char *volname = NULL; - char *hostname = NULL; - unsigned char subdir_handle[GFAPI_HANDLE_LENGTH] = {'\0'}; - - if (argc != 4) { - fprintf (stderr, "Invalid argument\n"); - exit(1); - } - - hostname = argv[1]; - volname = argv[2]; - logfile = argv[3]; - - fs = glfs_new (volname); - if (!fs) { - fprintf (stderr, "glfs_new: returned NULL\n"); - ret = -1; - goto out; - } - - ret = glfs_set_volfile_server (fs, "tcp", hostname, 24007); - LOG_ERR("glfs_set_volfile_server", ret); - - ret = glfs_set_logging (fs, logfile, 7); - LOG_ERR("glfs_set_logging", ret); - - ret = glfs_init (fs); - LOG_ERR("first attempt glfs_init", ret); - - root = glfs_h_lookupat (fs, NULL, "/", &sb, 0); - if (root == NULL) { - fprintf (stderr, "glfs_h_lookupat: error on lookup of / ,%s\n", - strerror (errno)); - goto out; - } - dir = glfs_h_mkdir (fs, root, dirname, 0644, &sb); - if (dir == NULL) { - fprintf (stderr, "glfs_h_mkdir: error on directory creation dir ,%s\n", - strerror (errno)); - goto out; - } - subdir = glfs_h_mkdir (fs, root, subdirname, 0644, &sb); - if (subdir == NULL) { - fprintf (stderr, "glfs_h_mkdir: error on directory creation subdir ,%s\n", - strerror (errno)); - goto out; - } - ret = glfs_h_extract_handle (subdir, subdir_handle, - GFAPI_HANDLE_LENGTH); - if (ret < 0) { - fprintf (stderr, "glfs_h_extract_handle: error extracting handle of %s: %s\n", - subdirname, strerror (errno)); - goto out; - } - - glfs_h_close (subdir); - subdir = NULL; - glfs_h_close (dir); - dir = NULL; - - if (fs) { - ret = glfs_fini(fs); - fprintf (stderr, "glfs_fini(fs) returned %d \n", ret); - } - - fs = NULL; - - fs = glfs_new (volname); - if (!fs) { - fprintf (stderr, "glfs_new: returned NULL\n"); - ret = -1; - goto out; - } - - ret = glfs_set_volfile_server (fs, "tcp", hostname, 24007); - LOG_ERR("glfs_set_volfile_server", ret); - - ret = glfs_set_logging (fs, logfile, 7); - LOG_ERR("glfs_set_logging", ret); - - ret = glfs_init (fs); - LOG_ERR("second attempt glfs_init", ret); - - subdir = glfs_h_create_from_handle (fs, subdir_handle, GFAPI_HANDLE_LENGTH, - &sb); - if (subdir == NULL) { - fprintf (stderr, "glfs_h_create_from_handle: error on create of %s: from (%p),%s\n", - subdirname, subdir_handle, strerror (errno)); - goto out; - } - dir = glfs_h_lookupat (fs, subdir, "..", &sb, 0); - if (dir == NULL) { - fprintf (stderr, "glfs_h_lookupat: error on directory lookup dir using .. ,%s\n", - strerror (errno)); - goto out; - } + int ret = 0; + glfs_t *fs = NULL; + struct glfs_object *root = NULL, *dir = NULL, *subdir = NULL; + struct stat sb = { + 0, + }; + char *dirname = "dir"; + char *subdirname = "subdir"; + char *logfile = NULL; + char *volname = NULL; + char *hostname = NULL; + unsigned char subdir_handle[GFAPI_HANDLE_LENGTH] = {'\0'}; + + if (argc != 4) { + fprintf(stderr, "Invalid argument\n"); + exit(1); + } + + hostname = argv[1]; + volname = argv[2]; + logfile = argv[3]; + + fs = glfs_new(volname); + if (!fs) { + fprintf(stderr, "glfs_new: returned NULL\n"); + ret = -1; + goto out; + } + + ret = glfs_set_volfile_server(fs, "tcp", hostname, 24007); + LOG_ERR("glfs_set_volfile_server", ret); + + ret = glfs_set_logging(fs, logfile, 7); + LOG_ERR("glfs_set_logging", ret); + + ret = glfs_init(fs); + LOG_ERR("first attempt glfs_init", ret); + + root = glfs_h_lookupat(fs, NULL, "/", &sb, 0); + if (root == NULL) { + fprintf(stderr, "glfs_h_lookupat: error on lookup of / ,%s\n", + strerror(errno)); + goto out; + } + dir = glfs_h_mkdir(fs, root, dirname, 0644, &sb); + if (dir == NULL) { + fprintf(stderr, "glfs_h_mkdir: error on directory creation dir ,%s\n", + strerror(errno)); + goto out; + } + subdir = glfs_h_mkdir(fs, root, subdirname, 0644, &sb); + if (subdir == NULL) { + fprintf(stderr, + "glfs_h_mkdir: error on directory creation subdir ,%s\n", + strerror(errno)); + goto out; + } + ret = glfs_h_extract_handle(subdir, subdir_handle, GFAPI_HANDLE_LENGTH); + if (ret < 0) { + fprintf(stderr, + "glfs_h_extract_handle: error extracting handle of %s: %s\n", + subdirname, strerror(errno)); + goto out; + } + + glfs_h_close(subdir); + subdir = NULL; + glfs_h_close(dir); + dir = NULL; + + if (fs) { + ret = glfs_fini(fs); + fprintf(stderr, "glfs_fini(fs) returned %d \n", ret); + } + + fs = NULL; + + fs = glfs_new(volname); + if (!fs) { + fprintf(stderr, "glfs_new: returned NULL\n"); + ret = -1; + goto out; + } + + ret = glfs_set_volfile_server(fs, "tcp", hostname, 24007); + LOG_ERR("glfs_set_volfile_server", ret); + + ret = glfs_set_logging(fs, logfile, 7); + LOG_ERR("glfs_set_logging", ret); + + ret = glfs_init(fs); + LOG_ERR("second attempt glfs_init", ret); + + subdir = glfs_h_create_from_handle(fs, subdir_handle, GFAPI_HANDLE_LENGTH, + &sb); + if (subdir == NULL) { + fprintf( + stderr, + "glfs_h_create_from_handle: error on create of %s: from (%p),%s\n", + subdirname, subdir_handle, strerror(errno)); + goto out; + } + dir = glfs_h_lookupat(fs, subdir, "..", &sb, 0); + if (dir == NULL) { + fprintf(stderr, + "glfs_h_lookupat: error on directory lookup dir using .. ,%s\n", + strerror(errno)); + goto out; + } out: - if (subdir) - glfs_h_close (subdir); - if (dir) - glfs_h_close (dir); - - if (fs) { - ret = glfs_fini(fs); - fprintf (stderr, "glfs_fini(fs) returned %d \n", ret); - } - - if (ret) - exit(1); - exit(0); + if (subdir) + glfs_h_close(subdir); + if (dir) + glfs_h_close(dir); + + if (fs) { + ret = glfs_fini(fs); + fprintf(stderr, "glfs_fini(fs) returned %d \n", ret); + } + + if (ret) + exit(1); + exit(0); } diff --git a/tests/bugs/gfapi/bug-1447266/bug-1447266.c b/tests/bugs/gfapi/bug-1447266/bug-1447266.c index e4b3c888a57..2b7e2d627fe 100644 --- a/tests/bugs/gfapi/bug-1447266/bug-1447266.c +++ b/tests/bugs/gfapi/bug-1447266/bug-1447266.c @@ -4,102 +4,104 @@ #include <string.h> #include <stdlib.h> #define TOTAL_ARGS 4 -int main(int argc, char *argv[]) +int +main(int argc, char *argv[]) { - char *cwd = (char *)malloc(PATH_MAX*sizeof(char *)); - char *resolved = NULL; - char *result = NULL; - char *buf = NULL; - struct stat st; - char *path = NULL; - int ret; - - if (argc != TOTAL_ARGS) { - printf ("Please give all required command line args.\n" - "Format : <volname> <server_ip> <path_name>\n"); - goto out; - } - - glfs_t *fs = glfs_new (argv[1]); - - if (fs == NULL) { - printf ("glfs_new: %s\n", strerror(errno)); - /* No need to fail the test for this error */ - ret = 0; - goto out; - } - - ret = glfs_set_volfile_server(fs, "tcp", argv[2], 24007); - if (ret) { - printf ("glfs_set_volfile_server: %s\n", strerror(errno)); - /* No need to fail the test for this error */ - ret = 0; - goto out; - } - - path = argv[3]; - - ret = glfs_set_logging(fs, "/tmp/gfapi.log", 7); - if (ret) { - printf ("glfs_set_logging: %s\n", strerror(errno)); - /* No need to fail the test for this error */ - ret = 0; - goto out; - } - - ret = glfs_init(fs); - if (ret) { - printf ("glfs_init: %s\n", strerror(errno)); - /* No need to fail the test for this error */ - ret = 0; - goto out; - } - - sleep(1); - - ret = glfs_chdir(fs, path); - if (ret) { - printf ("glfs_chdir: %s\n", strerror(errno)); - goto out; - } - - buf = glfs_getcwd(fs, cwd, PATH_MAX); - if (cwd == NULL) { - printf ("glfs_getcwd: %s\n", strerror(errno)); - goto out; - } - - printf ("\ncwd = %s\n\n", cwd); - - result = glfs_realpath(fs, path, resolved); - if (result == NULL) { - printf ("glfs_realpath: %s\n", strerror(errno)); - goto out; - } - - ret = glfs_stat(fs, path, &st); - if (ret) { - printf ("glfs_stat: %s\n", strerror(errno)); - goto out; - } - if (cwd) - free(cwd); - - result = glfs_realpath(fs, path, resolved); - if (result == NULL) { - printf ("glfs_realpath: %s\n", strerror(errno)); - goto out; - } - - ret = glfs_fini(fs); - if (ret) { - printf ("glfs_fini: %s\n", strerror(errno)); - /* No need to fail the test for this error */ - ret = 0; - goto out; - } - - printf ("\n"); + char *cwd = (char *)malloc(PATH_MAX * sizeof(char *)); + char *resolved = NULL; + char *result = NULL; + char *buf = NULL; + struct stat st; + char *path = NULL; + int ret; + + if (argc != TOTAL_ARGS) { + printf( + "Please give all required command line args.\n" + "Format : <volname> <server_ip> <path_name>\n"); + goto out; + } + + glfs_t *fs = glfs_new(argv[1]); + + if (fs == NULL) { + printf("glfs_new: %s\n", strerror(errno)); + /* No need to fail the test for this error */ + ret = 0; + goto out; + } + + ret = glfs_set_volfile_server(fs, "tcp", argv[2], 24007); + if (ret) { + printf("glfs_set_volfile_server: %s\n", strerror(errno)); + /* No need to fail the test for this error */ + ret = 0; + goto out; + } + + path = argv[3]; + + ret = glfs_set_logging(fs, "/tmp/gfapi.log", 7); + if (ret) { + printf("glfs_set_logging: %s\n", strerror(errno)); + /* No need to fail the test for this error */ + ret = 0; + goto out; + } + + ret = glfs_init(fs); + if (ret) { + printf("glfs_init: %s\n", strerror(errno)); + /* No need to fail the test for this error */ + ret = 0; + goto out; + } + + sleep(1); + + ret = glfs_chdir(fs, path); + if (ret) { + printf("glfs_chdir: %s\n", strerror(errno)); + goto out; + } + + buf = glfs_getcwd(fs, cwd, PATH_MAX); + if (cwd == NULL) { + printf("glfs_getcwd: %s\n", strerror(errno)); + goto out; + } + + printf("\ncwd = %s\n\n", cwd); + + result = glfs_realpath(fs, path, resolved); + if (result == NULL) { + printf("glfs_realpath: %s\n", strerror(errno)); + goto out; + } + + ret = glfs_stat(fs, path, &st); + if (ret) { + printf("glfs_stat: %s\n", strerror(errno)); + goto out; + } + if (cwd) + free(cwd); + + result = glfs_realpath(fs, path, resolved); + if (result == NULL) { + printf("glfs_realpath: %s\n", strerror(errno)); + goto out; + } + + ret = glfs_fini(fs); + if (ret) { + printf("glfs_fini: %s\n", strerror(errno)); + /* No need to fail the test for this error */ + ret = 0; + goto out; + } + + printf("\n"); out: - return ret; + return ret; } diff --git a/tests/bugs/gfapi/glfs_vol_set_IO_ERR.c b/tests/bugs/gfapi/glfs_vol_set_IO_ERR.c index 68011171744..f38f01144d3 100644 --- a/tests/bugs/gfapi/glfs_vol_set_IO_ERR.c +++ b/tests/bugs/gfapi/glfs_vol_set_IO_ERR.c @@ -10,156 +10,154 @@ glfs_t * setup_new_client(char *hostname, char *volname, char *log_fileile) { - int ret = 0; - glfs_t *fs = NULL; - - fs = glfs_new (volname); - if (!fs) { - fprintf (stderr, "\nglfs_new: returned NULL (%s)\n", - strerror (errno)); - goto error; - } - - ret = glfs_set_volfile_server (fs, "tcp", hostname, 24007); - if (ret < 0) { - fprintf (stderr, "\nglfs_set_volfile_server failed ret:%d (%s)\n", - ret, strerror (errno)); - goto error; - } - - ret = glfs_set_logging (fs, log_fileile, 7); - if (ret < 0) { - fprintf (stderr, "\nglfs_set_logging failed with ret: %d (%s)\n", - ret, strerror (errno)); - goto error; - } - - ret = glfs_init (fs); - if (ret < 0) { - fprintf (stderr, "\nglfs_init failed with ret: %d (%s)\n", - ret, strerror (errno)); - goto error; - } - return fs; + int ret = 0; + glfs_t *fs = NULL; + + fs = glfs_new(volname); + if (!fs) { + fprintf(stderr, "\nglfs_new: returned NULL (%s)\n", strerror(errno)); + goto error; + } + + ret = glfs_set_volfile_server(fs, "tcp", hostname, 24007); + if (ret < 0) { + fprintf(stderr, "\nglfs_set_volfile_server failed ret:%d (%s)\n", ret, + strerror(errno)); + goto error; + } + + ret = glfs_set_logging(fs, log_fileile, 7); + if (ret < 0) { + fprintf(stderr, "\nglfs_set_logging failed with ret: %d (%s)\n", ret, + strerror(errno)); + goto error; + } + + ret = glfs_init(fs); + if (ret < 0) { + fprintf(stderr, "\nglfs_init failed with ret: %d (%s)\n", ret, + strerror(errno)); + goto error; + } + return fs; error: - return NULL; + return NULL; } int -write_something (glfs_t *fs) +write_something(glfs_t *fs) { - glfs_fd_t *fd = NULL; - char *buf = NULL; - int ret = 0; - int j = 0; - - fd = glfs_creat (fs, "filename", O_RDWR, 0644); - if (!fd) { - fprintf (stderr, "%s: (%p) %s\n", "filename", fd, - strerror (errno)); - return -1; - } + glfs_fd_t *fd = NULL; + char *buf = NULL; + int ret = 0; + int j = 0; + + fd = glfs_creat(fs, "filename", O_RDWR, 0644); + if (!fd) { + fprintf(stderr, "%s: (%p) %s\n", "filename", fd, strerror(errno)); + return -1; + } + + buf = (char *)malloc(WRITE_SIZE); + memset(buf, '-', WRITE_SIZE); - buf = (char *) malloc (WRITE_SIZE); - memset (buf, '-', WRITE_SIZE); - - for (j = 0; j < 4; j++) { - ret = glfs_write (fd, buf, WRITE_SIZE, 0); - if (ret < 0) { - fprintf (stderr, "Write(%s): %d (%s)\n", "filename", ret, - strerror (errno)); - return ret; - } - glfs_lseek (fd, 0, SEEK_SET); + for (j = 0; j < 4; j++) { + ret = glfs_write(fd, buf, WRITE_SIZE, 0); + if (ret < 0) { + fprintf(stderr, "Write(%s): %d (%s)\n", "filename", ret, + strerror(errno)); + return ret; } - return 0; + glfs_lseek(fd, 0, SEEK_SET); + } + return 0; } static int -volfile_change (const char *volname) { - int ret = 0; - char *cmd = NULL, *cmd1 = NULL; - - ret = asprintf (&cmd, "gluster volume set %s quick-read on", - volname); - if (ret < 0) { - fprintf (stderr, "cannot construct cli command string (%s)", - strerror (errno)); - return ret; - } +volfile_change(const char *volname) +{ + int ret = 0; + char *cmd = NULL, *cmd1 = NULL; - ret = asprintf (&cmd1, "gluster volume set %s quick-read off", - volname); - if (ret < 0) { - fprintf (stderr, "cannot construct cli command string (%s)", - strerror (errno)); - return ret; - } + ret = asprintf(&cmd, "gluster volume set %s quick-read on", volname); + if (ret < 0) { + fprintf(stderr, "cannot construct cli command string (%s)", + strerror(errno)); + return ret; + } - ret = system (cmd); - if (ret < 0) { - fprintf (stderr, "quick-read off on (%s) failed", volname); - return ret; - } + ret = asprintf(&cmd1, "gluster volume set %s quick-read off", volname); + if (ret < 0) { + fprintf(stderr, "cannot construct cli command string (%s)", + strerror(errno)); + return ret; + } - ret = system (cmd1); - if (ret < 0) { - fprintf (stderr, "quick-read on on (%s) failed", volname); - return ret; - } + ret = system(cmd); + if (ret < 0) { + fprintf(stderr, "quick-read off on (%s) failed", volname); + return ret; + } - ret = system (cmd); - if (ret < 0) { - fprintf (stderr, "quick-read off on (%s) failed", volname); - return ret; - } + ret = system(cmd1); + if (ret < 0) { + fprintf(stderr, "quick-read on on (%s) failed", volname); + return ret; + } - free (cmd); - free (cmd1); + ret = system(cmd); + if (ret < 0) { + fprintf(stderr, "quick-read off on (%s) failed", volname); return ret; + } + + free(cmd); + free(cmd1); + return ret; } int -main (int argc, char *argv[]) +main(int argc, char *argv[]) { - int ret = 0; - glfs_t *fs = NULL; - char buf[100]; - glfs_fd_t *fd = NULL; - - if (argc != 4) { - fprintf (stderr, - "Expect following args %s <hostname> <Vol> <log file location>\n" - , argv[0]); - return -1; - } - - fs = setup_new_client (argv[1], argv[2], argv[3]); - if (!fs) - goto error; - - ret = volfile_change (argv[2]); - if (ret < 0) - goto error; - - /* This is required as volfile change takes a while to reach this - * gfapi client and precess the graph change. Without this the issue - * cannot be reproduced as in cannot be tested. - */ - sleep (10); - - ret = write_something (fs); - if (ret < 0) - goto error; - - ret = glfs_fini (fs); - if (ret < 0) { - fprintf (stderr, "glfs_fini failed with ret: %d (%s)\n", - ret, strerror (errno)); - goto error; - } - - return 0; -error: + int ret = 0; + glfs_t *fs = NULL; + char buf[100]; + glfs_fd_t *fd = NULL; + + if (argc != 4) { + fprintf( + stderr, + "Expect following args %s <hostname> <Vol> <log file location>\n", + argv[0]); return -1; + } + + fs = setup_new_client(argv[1], argv[2], argv[3]); + if (!fs) + goto error; + + ret = volfile_change(argv[2]); + if (ret < 0) + goto error; + + /* This is required as volfile change takes a while to reach this + * gfapi client and precess the graph change. Without this the issue + * cannot be reproduced as in cannot be tested. + */ + sleep(10); + + ret = write_something(fs); + if (ret < 0) + goto error; + + ret = glfs_fini(fs); + if (ret < 0) { + fprintf(stderr, "glfs_fini failed with ret: %d (%s)\n", ret, + strerror(errno)); + goto error; + } + + return 0; +error: + return -1; } diff --git a/tests/bugs/glusterd/bug-824753-file-locker.c b/tests/bugs/glusterd/bug-824753-file-locker.c index 915161b626b..f5dababad30 100644 --- a/tests/bugs/glusterd/bug-824753-file-locker.c +++ b/tests/bugs/glusterd/bug-824753-file-locker.c @@ -5,13 +5,13 @@ #include <unistd.h> #include <stdlib.h> - -int main (int argc, char *argv[]) +int +main(int argc, char *argv[]) { - int fd = -1; - int ret = -1; - char command[2048] = ""; - char filepath[255] = ""; + int fd = -1; + int ret = -1; + char command[2048] = ""; + char filepath[255] = ""; struct flock fl; fl.l_type = F_WRLCK; @@ -36,7 +36,7 @@ int main (int argc, char *argv[]) " grep %s | awk -F'..: ' '{print $1}' | grep %s:%s/%s", argv[1], argv[5], argv[2], argv[2], argv[3], argv[1]); - ret = system (command); + ret = system(command); close(fd); if (ret) diff --git a/tests/bugs/glusterfs-server/bug-905864.c b/tests/bugs/glusterfs-server/bug-905864.c index 3cc4cc5d232..f70003736e7 100644 --- a/tests/bugs/glusterfs-server/bug-905864.c +++ b/tests/bugs/glusterfs-server/bug-905864.c @@ -4,10 +4,9 @@ #include <fcntl.h> #include <pthread.h> - -pthread_t th[5] = {0}; +pthread_t th[5] = {0}; void -flock_init (struct flock *f, short int type, off_t start, off_t len) +flock_init(struct flock *f, short int type, off_t start, off_t len) { f->l_type = type; f->l_start = start; @@ -15,68 +14,70 @@ flock_init (struct flock *f, short int type, off_t start, off_t len) } int -flock_range_in_steps (int fd, int is_set, short l_type, - int start, int end, int step) +flock_range_in_steps(int fd, int is_set, short l_type, int start, int end, + int step) { - int ret = 0; - int i = 0; - struct flock f = {0,}; + int ret = 0; + int i = 0; + struct flock f = { + 0, + }; - for (i = start; i+step < end; i += step) { - flock_init (&f, l_type, i, step); - ret = fcntl (fd, (is_set) ? F_SETLKW : F_GETLK, &f); - if (ret) { - perror ("fcntl"); - goto out; - } + for (i = start; i + step < end; i += step) { + flock_init(&f, l_type, i, step); + ret = fcntl(fd, (is_set) ? F_SETLKW : F_GETLK, &f); + if (ret) { + perror("fcntl"); + goto out; } + } out: - return ret; + return ret; } void * -random_locker (void *arg) +random_locker(void *arg) { - int fd = *(int *)arg; - int i = 0; - int is_set = 0; + int fd = *(int *)arg; + int i = 0; + int is_set = 0; - /* use thread id to choose GETLK or SETLK operation*/ - is_set = pthread_self () % 2; - (void)flock_range_in_steps (fd, is_set, F_WRLCK, 0, 400, 1); + /* use thread id to choose GETLK or SETLK operation*/ + is_set = pthread_self() % 2; + (void)flock_range_in_steps(fd, is_set, F_WRLCK, 0, 400, 1); - return NULL; + return NULL; } - -int main (int argc, char **argv) +int +main(int argc, char **argv) { - int fd = -1; - int ret = 1; - int i = 0; - char *fname = NULL; + int fd = -1; + int ret = 1; + int i = 0; + char *fname = NULL; - if (argc < 2) - goto out; + if (argc < 2) + goto out; - fname = argv[1]; - fd = open (fname, O_RDWR); - if (fd == -1) { - perror ("open"); - goto out; - } + fname = argv[1]; + fd = open(fname, O_RDWR); + if (fd == -1) { + perror("open"); + goto out; + } - ret = flock_range_in_steps (fd, 1, F_WRLCK, 0, 2000, 2); - for (i = 0; i < 5; i++) { - pthread_create (&th[i], NULL, random_locker, (void *) &fd); - } - ret = flock_range_in_steps (fd, 1, F_WRLCK, 0, 2000, 2); - for (i = 0; i < 5; i++) { - pthread_join (th[i], NULL); - } + ret = flock_range_in_steps(fd, 1, F_WRLCK, 0, 2000, 2); + for (i = 0; i < 5; i++) { + pthread_create(&th[i], NULL, random_locker, (void *)&fd); + } + ret = flock_range_in_steps(fd, 1, F_WRLCK, 0, 2000, 2); + for (i = 0; i < 5; i++) { + pthread_join(th[i], NULL); + } out: - if (fd != -1) - close (fd); + if (fd != -1) + close(fd); - return ret; + return ret; } diff --git a/tests/bugs/glusterfs/getlk_owner.c b/tests/bugs/glusterfs/getlk_owner.c index 85fd1042496..cbe277318c1 100644 --- a/tests/bugs/glusterfs/getlk_owner.c +++ b/tests/bugs/glusterfs/getlk_owner.c @@ -3,24 +3,24 @@ #include <fcntl.h> #include <string.h> -#define GETLK_OWNER_CHECK(f, cp, label) \ - do { \ - switch (f.l_type) { \ - case F_RDLCK: \ - case F_WRLCK: \ - ret = 1; \ - goto label; \ - case F_UNLCK: \ - if (!are_flocks_sane (&f, &cp)) { \ - ret = 1; \ - goto label; \ - } \ - break; \ - } \ +#define GETLK_OWNER_CHECK(f, cp, label) \ + do { \ + switch (f.l_type) { \ + case F_RDLCK: \ + case F_WRLCK: \ + ret = 1; \ + goto label; \ + case F_UNLCK: \ + if (!are_flocks_sane(&f, &cp)) { \ + ret = 1; \ + goto label; \ + } \ + break; \ + } \ } while (0) void -flock_init (struct flock *f, short int type, off_t start, off_t len) +flock_init(struct flock *f, short int type, off_t start, off_t len) { f->l_type = type; f->l_start = start; @@ -28,17 +28,16 @@ flock_init (struct flock *f, short int type, off_t start, off_t len) } int -flock_cp (struct flock *dst, struct flock *src) +flock_cp(struct flock *dst, struct flock *src) { - memcpy ((void *) dst, (void *) src, sizeof (struct flock)); + memcpy((void *)dst, (void *)src, sizeof(struct flock)); } int -are_flocks_sane (struct flock *src, struct flock *cpy) +are_flocks_sane(struct flock *src, struct flock *cpy) { return ((src->l_whence == cpy->l_whence) && - (src->l_start == cpy->l_start) && - (src->l_len == cpy->l_len)); + (src->l_start == cpy->l_start) && (src->l_len == cpy->l_len)); } /* @@ -53,68 +52,73 @@ are_flocks_sane (struct flock *src, struct flock *cpy) * * */ -int main (int argc, char **argv) +int +main(int argc, char **argv) { int fd = -1; int ret = 1; char *fname = NULL; - struct flock f = {0,}; - struct flock cp = {0,}; + struct flock f = { + 0, + }; + struct flock cp = { + 0, + }; if (argc < 2) goto out; fname = argv[1]; - fd = open (fname, O_RDWR); + fd = open(fname, O_RDWR); if (fd == -1) { - perror ("open"); + perror("open"); goto out; } - flock_init (&f, F_WRLCK, 0, 3); - flock_cp (&cp, &f); - ret = fcntl (fd, F_SETLK, &f); + flock_init(&f, F_WRLCK, 0, 3); + flock_cp(&cp, &f); + ret = fcntl(fd, F_SETLK, &f); if (ret) { - perror ("fcntl"); + perror("fcntl"); goto out; } - if (!are_flocks_sane (&f, &cp)) { + if (!are_flocks_sane(&f, &cp)) { ret = 1; goto out; } - flock_init (&f, F_WRLCK, 3, 3); - flock_cp (&cp, &f); - ret = fcntl (fd, F_SETLK, &f); + flock_init(&f, F_WRLCK, 3, 3); + flock_cp(&cp, &f); + ret = fcntl(fd, F_SETLK, &f); if (ret) { - perror ("fcntl"); + perror("fcntl"); goto out; } - if (!are_flocks_sane (&f, &cp)) { + if (!are_flocks_sane(&f, &cp)) { ret = 1; goto out; } - flock_init (&f, F_WRLCK, 3, 3); - flock_cp (&cp, &f); - ret = fcntl (fd, F_GETLK, &f); + flock_init(&f, F_WRLCK, 3, 3); + flock_cp(&cp, &f); + ret = fcntl(fd, F_GETLK, &f); if (ret) { - perror ("fcntl"); + perror("fcntl"); return 1; } - GETLK_OWNER_CHECK (f, cp, out); + GETLK_OWNER_CHECK(f, cp, out); - flock_init (&f, F_RDLCK, 3, 3); - flock_cp (&cp, &f); - ret = fcntl (fd, F_GETLK, &f); + flock_init(&f, F_RDLCK, 3, 3); + flock_cp(&cp, &f); + ret = fcntl(fd, F_GETLK, &f); if (ret) { - perror ("fcntl"); + perror("fcntl"); return 1; } - GETLK_OWNER_CHECK (f, cp, out); + GETLK_OWNER_CHECK(f, cp, out); out: if (fd != -1) - close (fd); + close(fd); return ret; } diff --git a/tests/bugs/io-cache/bug-858242.c b/tests/bugs/io-cache/bug-858242.c index b6a412d578c..ac87a15533e 100644 --- a/tests/bugs/io-cache/bug-858242.c +++ b/tests/bugs/io-cache/bug-858242.c @@ -10,72 +10,75 @@ #include <unistd.h> int -main (int argc, char *argv[]) +main(int argc, char *argv[]) { - char *filename = NULL, *volname = NULL, *cmd = NULL; - char buffer[1024] = {0, }; - int fd = -1; - int ret = -1; - struct stat statbuf = {0, }; + char *filename = NULL, *volname = NULL, *cmd = NULL; + char buffer[1024] = { + 0, + }; + int fd = -1; + int ret = -1; + struct stat statbuf = { + 0, + }; - if (argc != 3) { - fprintf (stderr, "usage: %s <file-name> <volname>\n", argv[0]); - goto out; - } + if (argc != 3) { + fprintf(stderr, "usage: %s <file-name> <volname>\n", argv[0]); + goto out; + } - filename = argv[1]; - volname = argv[2]; + filename = argv[1]; + volname = argv[2]; - fd = open (filename, O_RDWR | O_CREAT, 0); - if (fd < 0) { - fprintf (stderr, "open (%s) failed (%s)\n", filename, - strerror (errno)); - goto out; - } + fd = open(filename, O_RDWR | O_CREAT, 0); + if (fd < 0) { + fprintf(stderr, "open (%s) failed (%s)\n", filename, strerror(errno)); + goto out; + } - ret = write (fd, "test-content", 12); - if (ret < 0) { - fprintf (stderr, "write failed (%s)", strerror (errno)); - goto out; - } + ret = write(fd, "test-content", 12); + if (ret < 0) { + fprintf(stderr, "write failed (%s)", strerror(errno)); + goto out; + } - ret = fsync (fd); - if (ret < 0) { - fprintf (stderr, "fsync failed (%s)", strerror (errno)); - goto out; - } + ret = fsync(fd); + if (ret < 0) { + fprintf(stderr, "fsync failed (%s)", strerror(errno)); + goto out; + } - ret = fstat (fd, &statbuf); - if (ret < 0) { - fprintf (stderr, "fstat failed (%s)", strerror (errno)); - goto out; - } + ret = fstat(fd, &statbuf); + if (ret < 0) { + fprintf(stderr, "fstat failed (%s)", strerror(errno)); + goto out; + } - ret = asprintf (&cmd, "gluster --mode=script volume stop %s force", - volname); - if (ret < 0) { - fprintf (stderr, "cannot construct cli command string (%s)", - strerror (errno)); - goto out; - } + ret = asprintf(&cmd, "gluster --mode=script volume stop %s force", volname); + if (ret < 0) { + fprintf(stderr, "cannot construct cli command string (%s)", + strerror(errno)); + goto out; + } - ret = system (cmd); - if (ret < 0) { - fprintf (stderr, "stopping volume (%s) failed", volname); - goto out; - } + ret = system(cmd); + if (ret < 0) { + fprintf(stderr, "stopping volume (%s) failed", volname); + goto out; + } - sleep (3); + sleep(3); - ret = read (fd, buffer, 1024); - if (ret >= 0) { - fprintf (stderr, "read should've returned error, " - "but is successful\n"); - ret = -1; - goto out; - } + ret = read(fd, buffer, 1024); + if (ret >= 0) { + fprintf(stderr, + "read should've returned error, " + "but is successful\n"); + ret = -1; + goto out; + } - ret = 0; + ret = 0; out: - return ret; + return ret; } diff --git a/tests/bugs/io-cache/bug-read-hang.c b/tests/bugs/io-cache/bug-read-hang.c index 7709a41719d..e1fae97e7e8 100644 --- a/tests/bugs/io-cache/bug-read-hang.c +++ b/tests/bugs/io-cache/bug-read-hang.c @@ -9,117 +9,117 @@ int count = 0; void -read_cbk (glfs_fd_t *fd, ssize_t ret, void *data) { -count++; +read_cbk(glfs_fd_t *fd, ssize_t ret, void *data) +{ + count++; } glfs_t * setup_new_client(char *hostname, char *volname, char *log_file, int flag) { - int ret = 0; - glfs_t *fs = NULL; - - fs = glfs_new (volname); - if (!fs) { - fprintf (stderr, "\nglfs_new: returned NULL (%s)\n", - strerror (errno)); - goto error; - } - - ret = glfs_set_volfile_server (fs, "tcp", hostname, 24007); - if (ret < 0) { - fprintf (stderr, "\nglfs_set_volfile_server failed ret:%d (%s)\n", - ret, strerror (errno)); - goto error; - } - - ret = glfs_set_logging (fs, log_file, 7); - if (ret < 0) { - fprintf (stderr, "\nglfs_set_logging failed with ret: %d (%s)\n", - ret, strerror (errno)); - goto error; - } - - if (flag == NO_INIT) - goto out; - - ret = glfs_init (fs); - if (ret < 0) { - fprintf (stderr, "\nglfs_init failed with ret: %d (%s)\n", - ret, strerror (errno)); - goto error; - } + int ret = 0; + glfs_t *fs = NULL; + + fs = glfs_new(volname); + if (!fs) { + fprintf(stderr, "\nglfs_new: returned NULL (%s)\n", strerror(errno)); + goto error; + } + + ret = glfs_set_volfile_server(fs, "tcp", hostname, 24007); + if (ret < 0) { + fprintf(stderr, "\nglfs_set_volfile_server failed ret:%d (%s)\n", ret, + strerror(errno)); + goto error; + } + + ret = glfs_set_logging(fs, log_file, 7); + if (ret < 0) { + fprintf(stderr, "\nglfs_set_logging failed with ret: %d (%s)\n", ret, + strerror(errno)); + goto error; + } + + if (flag == NO_INIT) + goto out; + + ret = glfs_init(fs); + if (ret < 0) { + fprintf(stderr, "\nglfs_init failed with ret: %d (%s)\n", ret, + strerror(errno)); + goto error; + } out: - return fs; + return fs; error: - return NULL; + return NULL; } int -main (int argc, char *argv[]) +main(int argc, char *argv[]) { - int ret = 0; - glfs_t *fs = NULL; - struct glfs_fd *fd = NULL; - char *volname = NULL; - char *log_file = NULL; - char *hostname = NULL; - char *buf = NULL; - struct stat stat; - - if (argc != 4) { - fprintf (stderr, - "Expect following args %s <hostname> <Vol> <log file location>\n" - , argv[0]); - return -1; - } - - hostname = argv[1]; - volname = argv[2]; - log_file = argv[3]; - - fs = setup_new_client (hostname, volname, log_file, 0); - if (!fs) { - fprintf (stderr, "\nsetup_new_client: returned NULL (%s)\n", - strerror (errno)); - goto error; - } - - fd = glfs_opendir (fs, "/"); - if (!fd) { - fprintf (stderr, "/: %s\n", strerror (errno)); - return -1; - } - - glfs_readdirplus (fd, &stat); - - fd = glfs_open (fs, "/test", O_RDWR); - if (fd == NULL) { - fprintf (stderr, "glfs_open: returned NULL\n"); - goto error; - } - - buf = (char *) malloc (5); - - ret = glfs_pread (fd, buf, 5, 0, 0, NULL); - if (ret < 0) { - fprintf (stderr, "Read(%s): %d (%s)\n", "test", ret, - strerror (errno)); - return ret; - } - - free (buf); - glfs_close (fd); - - ret = glfs_fini (fs); - if (ret < 0) { - fprintf (stderr, "glfs_fini failed with ret: %d (%s)\n", - ret, strerror (errno)); - return -1; - } - - return 0; -error: + int ret = 0; + glfs_t *fs = NULL; + struct glfs_fd *fd = NULL; + char *volname = NULL; + char *log_file = NULL; + char *hostname = NULL; + char *buf = NULL; + struct stat stat; + + if (argc != 4) { + fprintf( + stderr, + "Expect following args %s <hostname> <Vol> <log file location>\n", + argv[0]); + return -1; + } + + hostname = argv[1]; + volname = argv[2]; + log_file = argv[3]; + + fs = setup_new_client(hostname, volname, log_file, 0); + if (!fs) { + fprintf(stderr, "\nsetup_new_client: returned NULL (%s)\n", + strerror(errno)); + goto error; + } + + fd = glfs_opendir(fs, "/"); + if (!fd) { + fprintf(stderr, "/: %s\n", strerror(errno)); + return -1; + } + + glfs_readdirplus(fd, &stat); + + fd = glfs_open(fs, "/test", O_RDWR); + if (fd == NULL) { + fprintf(stderr, "glfs_open: returned NULL\n"); + goto error; + } + + buf = (char *)malloc(5); + + ret = glfs_pread(fd, buf, 5, 0, 0, NULL); + if (ret < 0) { + fprintf(stderr, "Read(%s): %d (%s)\n", "test", ret, strerror(errno)); + return ret; + } + + free(buf); + glfs_close(fd); + + ret = glfs_fini(fs); + if (ret < 0) { + fprintf(stderr, "glfs_fini failed with ret: %d (%s)\n", ret, + strerror(errno)); return -1; + } + + return 0; +error: + return -1; } diff --git a/tests/bugs/nfs/bug-1210338.c b/tests/bugs/nfs/bug-1210338.c index 7a17b9d68ce..d4099244176 100644 --- a/tests/bugs/nfs/bug-1210338.c +++ b/tests/bugs/nfs/bug-1210338.c @@ -7,26 +7,25 @@ #include <fcntl.h> #include <sys/stat.h> - int -main (int argc, char *argv[]) +main(int argc, char *argv[]) { - int ret = -1; - int fd = -1; + int ret = -1; + int fd = -1; - fd = open (argv[1], O_CREAT|O_EXCL, 0644); + fd = open(argv[1], O_CREAT | O_EXCL, 0644); - if (fd == -1) { - fprintf (stderr, "creation of the file %s failed (%s)\n", argv[1], - strerror (errno)); - goto out; - } + if (fd == -1) { + fprintf(stderr, "creation of the file %s failed (%s)\n", argv[1], + strerror(errno)); + goto out; + } - ret = 0; + ret = 0; out: - if (fd > 0) - close (fd); + if (fd > 0) + close(fd); - return ret; + return ret; } diff --git a/tests/bugs/posix/bug-1175711.c b/tests/bugs/posix/bug-1175711.c index fbbea3f636b..8ab193c4014 100644 --- a/tests/bugs/posix/bug-1175711.c +++ b/tests/bugs/posix/bug-1175711.c @@ -6,32 +6,32 @@ int main(int argc, char **argv) { - DIR *dir = NULL; - struct dirent *entry = NULL; - int ret = 0; - char *path = NULL; + DIR *dir = NULL; + struct dirent *entry = NULL; + int ret = 0; + char *path = NULL; - assert (argc == 2); - path = argv[1]; + assert(argc == 2); + path = argv[1]; - dir = opendir(path); - if (!dir) { - printf("opendir(%s) failed.\n", path); - return -1; - } + dir = opendir(path); + if (!dir) { + printf("opendir(%s) failed.\n", path); + return -1; + } #ifdef _DIRENT_HAVE_D_TYPE - while ((entry = readdir(dir)) != NULL) { - if (entry->d_type == DT_UNKNOWN) { - printf("d_type found to be DT_UNKNOWN\n"); - ret = -1; - break; - } + while ((entry = readdir(dir)) != NULL) { + if (entry->d_type == DT_UNKNOWN) { + printf("d_type found to be DT_UNKNOWN\n"); + ret = -1; + break; } + } #endif - if (dir) - closedir(dir); + if (dir) + closedir(dir); - return ret; + return ret; } diff --git a/tests/bugs/posix/disallow-gfid-volumeid-fremovexattr.c b/tests/bugs/posix/disallow-gfid-volumeid-fremovexattr.c index 325edbbed97..4ed3181d48f 100644 --- a/tests/bugs/posix/disallow-gfid-volumeid-fremovexattr.c +++ b/tests/bugs/posix/disallow-gfid-volumeid-fremovexattr.c @@ -5,94 +5,100 @@ #include <string.h> int -main (int argc, char *argv[]) +main(int argc, char *argv[]) { - glfs_t *fs = NULL; - int ret = 0; - int i = 0; - glfs_fd_t *fd = NULL; - char *logfile = NULL; - char *hostname = NULL; + glfs_t *fs = NULL; + int ret = 0; + int i = 0; + glfs_fd_t *fd = NULL; + char *logfile = NULL; + char *hostname = NULL; - if (argc != 4) { - fprintf (stderr, - "Expect following args %s <hostname> <Vol> <log file>\n" - , argv[0]); - return -1; - } + if (argc != 4) { + fprintf(stderr, + "Expect following args %s <hostname> <Vol> <log file>\n", + argv[0]); + return -1; + } - hostname = argv[1]; - logfile = argv[3]; + hostname = argv[1]; + logfile = argv[3]; - fs = glfs_new (argv[2]); - if (!fs) { - fprintf (stderr, "glfs_new: returned NULL (%s)\n", - strerror (errno)); - return -1; - } + fs = glfs_new(argv[2]); + if (!fs) { + fprintf(stderr, "glfs_new: returned NULL (%s)\n", strerror(errno)); + return -1; + } - ret = glfs_set_volfile_server (fs, "tcp", hostname, 24007); - if (ret < 0) { - fprintf (stderr, "glfs_set_volfile_server failed ret:%d (%s)\n", - ret, strerror (errno)); - return -1; - } + ret = glfs_set_volfile_server(fs, "tcp", hostname, 24007); + if (ret < 0) { + fprintf(stderr, "glfs_set_volfile_server failed ret:%d (%s)\n", ret, + strerror(errno)); + return -1; + } - ret = glfs_set_logging (fs, logfile, 7); - if (ret < 0) { - fprintf (stderr, "glfs_set_logging failed with ret: %d (%s)\n", - ret, strerror (errno)); - return -1; - } + ret = glfs_set_logging(fs, logfile, 7); + if (ret < 0) { + fprintf(stderr, "glfs_set_logging failed with ret: %d (%s)\n", ret, + strerror(errno)); + return -1; + } - ret = glfs_init (fs); - if (ret < 0) { - fprintf (stderr, "glfs_init failed with ret: %d (%s)\n", - ret, strerror (errno)); - return -1; - } + ret = glfs_init(fs); + if (ret < 0) { + fprintf(stderr, "glfs_init failed with ret: %d (%s)\n", ret, + strerror(errno)); + return -1; + } - fd = glfs_opendir (fs, "/"); - if (!fd) { - fprintf (stderr, "glfs_opendir failed with (%s)\n", - strerror (errno)); - return -1; - } + fd = glfs_opendir(fs, "/"); + if (!fd) { + fprintf(stderr, "glfs_opendir failed with (%s)\n", strerror(errno)); + return -1; + } - ret = glfs_fremovexattr (fd, "trusted.gfid"); - if (ret == 0 || errno != EPERM) { - fprintf (stderr, "glfs_fremovexattr gfid exited with ret: " - "%d (%s)\n", ret, strerror (errno)); - return -1; - } + ret = glfs_fremovexattr(fd, "trusted.gfid"); + if (ret == 0 || errno != EPERM) { + fprintf(stderr, + "glfs_fremovexattr gfid exited with ret: " + "%d (%s)\n", + ret, strerror(errno)); + return -1; + } - ret = glfs_fremovexattr (fd, "trusted.glusterfs.volume-id"); - if (ret == 0 || errno != EPERM) { - fprintf (stderr, "glfs_fremovexattr volume-id exited with ret: " - "%d (%s)\n", ret, strerror (errno)); - return -1; - } + ret = glfs_fremovexattr(fd, "trusted.glusterfs.volume-id"); + if (ret == 0 || errno != EPERM) { + fprintf(stderr, + "glfs_fremovexattr volume-id exited with ret: " + "%d (%s)\n", + ret, strerror(errno)); + return -1; + } - ret = glfs_fsetxattr (fd, "trusted.abc", "abc", 3, 0); - if (ret < 0) { - fprintf (stderr, "glfs_fsetxattr trusted.abc exited with ret: " - "%d (%s)\n", ret, strerror (errno)); - return -1; - } + ret = glfs_fsetxattr(fd, "trusted.abc", "abc", 3, 0); + if (ret < 0) { + fprintf(stderr, + "glfs_fsetxattr trusted.abc exited with ret: " + "%d (%s)\n", + ret, strerror(errno)); + return -1; + } - ret = glfs_fremovexattr (fd, "trusted.abc"); - if (ret < 0) { - fprintf (stderr, "glfs_fremovexattr trusted.abc exited with " - "ret: %d (%s)\n", ret, strerror (errno)); - return -1; - } + ret = glfs_fremovexattr(fd, "trusted.abc"); + if (ret < 0) { + fprintf(stderr, + "glfs_fremovexattr trusted.abc exited with " + "ret: %d (%s)\n", + ret, strerror(errno)); + return -1; + } - (void) glfs_closedir(fd); - ret = glfs_fini (fs); - if (ret < 0) { - fprintf (stderr, "glfs_fini failed with ret: %d (%s)\n", - ret, strerror (errno)); - return -1; - } - return 0; + (void)glfs_closedir(fd); + ret = glfs_fini(fs); + if (ret < 0) { + fprintf(stderr, "glfs_fini failed with ret: %d (%s)\n", ret, + strerror(errno)); + return -1; + } + return 0; } diff --git a/tests/bugs/protocol/bug-808400-fcntl.c b/tests/bugs/protocol/bug-808400-fcntl.c index 87a83f317b8..a703ca5c120 100644 --- a/tests/bugs/protocol/bug-808400-fcntl.c +++ b/tests/bugs/protocol/bug-808400-fcntl.c @@ -12,106 +12,113 @@ #endif int -run_child (char *filename) +run_child(char *filename) { - int fd = -1, ret = -1; - struct flock lock = {0, }; - int ppid = 0; - - fd = open (filename, O_RDWR); - if (fd < 0) { - fprintf (stderr, "open failed (%s)\n", strerror (errno)); - goto out; - } - - ppid = getppid (); - - lock.l_type = F_WRLCK; - lock.l_whence = SEEK_SET; - lock.l_start = 0; - lock.l_len = 0; - - ret = fcntl (fd, F_GETLK, &lock); - if (ret < 0) { - fprintf (stderr, "GETLK failed (%s)\n", strerror (errno)); - goto out; - } - - if ((lock.l_type == F_UNLCK) || - (ppid != lock.l_pid)) { - fprintf (stderr, "no locks present, though parent has held " - "one\n"); - ret = -1; - goto out; - } - - ret = 0; + int fd = -1, ret = -1; + struct flock lock = { + 0, + }; + int ppid = 0; + + fd = open(filename, O_RDWR); + if (fd < 0) { + fprintf(stderr, "open failed (%s)\n", strerror(errno)); + goto out; + } + + ppid = getppid(); + + lock.l_type = F_WRLCK; + lock.l_whence = SEEK_SET; + lock.l_start = 0; + lock.l_len = 0; + + ret = fcntl(fd, F_GETLK, &lock); + if (ret < 0) { + fprintf(stderr, "GETLK failed (%s)\n", strerror(errno)); + goto out; + } + + if ((lock.l_type == F_UNLCK) || (ppid != lock.l_pid)) { + fprintf(stderr, + "no locks present, though parent has held " + "one\n"); + ret = -1; + goto out; + } + + ret = 0; out: - return ret; + return ret; } int -main (int argc, char *argv[]) +main(int argc, char *argv[]) { - int fd = -1, ret = -1, status = 0; - char *filename = NULL, *cmd = NULL; - struct stat stbuf = {0, }; - struct flock lock = {0, }; - - if (argc != 3) { - fprintf (stderr, "Usage: %s <filename> " - "<gluster-cmd-to-trigger-graph-switch>\n", argv[0]); - goto out; - } - - filename = argv[1]; - cmd = argv[2]; - - fd = open (filename, O_RDWR | O_CREAT, 0); - if (fd < 0) { - fprintf (stderr, "open (%s) failed (%s)\n", filename, - strerror (errno)); - goto out; - } - - lock.l_type = F_WRLCK; - lock.l_whence = SEEK_SET; - lock.l_start = 0; - lock.l_len = 0; - - ret = fcntl (fd, F_SETLK, &lock); - if (ret < 0) { - fprintf (stderr, "fcntl failed (%s)\n", strerror (errno)); - goto out; - } - - system (cmd); - - /* wait till graph switch completes */ - ret = fstat64 (fd, &stbuf); - if (ret < 0) { - fprintf (stderr, "fstat64 failure (%s)\n", strerror (errno)); - goto out; - } - - sleep (10); - - /* By now old-graph would be disconnected and locks should be cleaned - * up if they are not migrated. Check that by trying to acquire a lock - * on a new fd opened by another process on same file. - */ - ret = fork (); - if (ret == 0) { - ret = run_child (filename); + int fd = -1, ret = -1, status = 0; + char *filename = NULL, *cmd = NULL; + struct stat stbuf = { + 0, + }; + struct flock lock = { + 0, + }; + + if (argc != 3) { + fprintf(stderr, + "Usage: %s <filename> " + "<gluster-cmd-to-trigger-graph-switch>\n", + argv[0]); + goto out; + } + + filename = argv[1]; + cmd = argv[2]; + + fd = open(filename, O_RDWR | O_CREAT, 0); + if (fd < 0) { + fprintf(stderr, "open (%s) failed (%s)\n", filename, strerror(errno)); + goto out; + } + + lock.l_type = F_WRLCK; + lock.l_whence = SEEK_SET; + lock.l_start = 0; + lock.l_len = 0; + + ret = fcntl(fd, F_SETLK, &lock); + if (ret < 0) { + fprintf(stderr, "fcntl failed (%s)\n", strerror(errno)); + goto out; + } + + system(cmd); + + /* wait till graph switch completes */ + ret = fstat64(fd, &stbuf); + if (ret < 0) { + fprintf(stderr, "fstat64 failure (%s)\n", strerror(errno)); + goto out; + } + + sleep(10); + + /* By now old-graph would be disconnected and locks should be cleaned + * up if they are not migrated. Check that by trying to acquire a lock + * on a new fd opened by another process on same file. + */ + ret = fork(); + if (ret == 0) { + ret = run_child(filename); + } else { + wait(&status); + if (WIFEXITED(status)) { + ret = WEXITSTATUS(status); } else { - wait (&status); - if (WIFEXITED(status)) { - ret = WEXITSTATUS(status); - } else { - ret = 0; - } + ret = 0; } + } out: - return ret; + return ret; } diff --git a/tests/bugs/protocol/bug-808400-flock.c b/tests/bugs/protocol/bug-808400-flock.c index bd2ce8cfb01..54a507cc227 100644 --- a/tests/bugs/protocol/bug-808400-flock.c +++ b/tests/bugs/protocol/bug-808400-flock.c @@ -12,85 +12,89 @@ #endif int -run_child (char *filename) +run_child(char *filename) { - int fd = -1, ret = -1; + int fd = -1, ret = -1; - fd = open (filename, O_RDWR); - if (fd < 0) { - fprintf (stderr, "open failed (%s)\n", strerror (errno)); - goto out; - } + fd = open(filename, O_RDWR); + if (fd < 0) { + fprintf(stderr, "open failed (%s)\n", strerror(errno)); + goto out; + } - ret = flock (fd, LOCK_EX | LOCK_NB); - if ((ret == 0) || (errno != EWOULDBLOCK)) { - fprintf (stderr, "no locks present, though parent has held " - "one\n"); - ret = -1; - goto out; - } + ret = flock(fd, LOCK_EX | LOCK_NB); + if ((ret == 0) || (errno != EWOULDBLOCK)) { + fprintf(stderr, + "no locks present, though parent has held " + "one\n"); + ret = -1; + goto out; + } - ret = 0; + ret = 0; out: - return ret; + return ret; } int -main (int argc, char *argv[]) +main(int argc, char *argv[]) { - int fd = -1, ret = -1, status = 0; - char *filename = NULL, *cmd = NULL; - struct stat stbuf = {0, }; + int fd = -1, ret = -1, status = 0; + char *filename = NULL, *cmd = NULL; + struct stat stbuf = { + 0, + }; - if (argc != 3) { - fprintf (stderr, "Usage: %s <filename> " - "<gluster-cmd-to-trigger-graph-switch>\n", argv[0]); - goto out; - } + if (argc != 3) { + fprintf(stderr, + "Usage: %s <filename> " + "<gluster-cmd-to-trigger-graph-switch>\n", + argv[0]); + goto out; + } - filename = argv[1]; - cmd = argv[2]; + filename = argv[1]; + cmd = argv[2]; - fd = open (filename, O_RDWR | O_CREAT, 0); - if (fd < 0) { - fprintf (stderr, "open (%s) failed (%s)\n", filename, - strerror (errno)); - goto out; - } + fd = open(filename, O_RDWR | O_CREAT, 0); + if (fd < 0) { + fprintf(stderr, "open (%s) failed (%s)\n", filename, strerror(errno)); + goto out; + } - ret = flock (fd, LOCK_EX); - if (ret < 0) { - fprintf (stderr, "flock failed (%s)\n", strerror (errno)); - goto out; - } + ret = flock(fd, LOCK_EX); + if (ret < 0) { + fprintf(stderr, "flock failed (%s)\n", strerror(errno)); + goto out; + } - system (cmd); + system(cmd); - /* wait till graph switch completes */ - ret = fstat64 (fd, &stbuf); - if (ret < 0) { - fprintf (stderr, "fstat64 failure (%s)\n", strerror (errno)); - goto out; - } + /* wait till graph switch completes */ + ret = fstat64(fd, &stbuf); + if (ret < 0) { + fprintf(stderr, "fstat64 failure (%s)\n", strerror(errno)); + goto out; + } - sleep (10); + sleep(10); - /* By now old-graph would be disconnected and locks should be cleaned - * up if they are not migrated. Check that by trying to acquire a lock - * on a new fd opened by another process on same file - */ - ret = fork (); - if (ret == 0) { - ret = run_child (filename); + /* By now old-graph would be disconnected and locks should be cleaned + * up if they are not migrated. Check that by trying to acquire a lock + * on a new fd opened by another process on same file + */ + ret = fork(); + if (ret == 0) { + ret = run_child(filename); + } else { + wait(&status); + if (WIFEXITED(status)) { + ret = WEXITSTATUS(status); } else { - wait (&status); - if (WIFEXITED(status)) { - ret = WEXITSTATUS(status); - } else { - ret = 0; - } + ret = 0; } + } out: - return ret; + return ret; } diff --git a/tests/bugs/quick-read/bz1523599/test_bz1523599.c b/tests/bugs/quick-read/bz1523599/test_bz1523599.c index 843408680a7..5076a9447f3 100644 --- a/tests/bugs/quick-read/bz1523599/test_bz1523599.c +++ b/tests/bugs/quick-read/bz1523599/test_bz1523599.c @@ -1,7 +1,8 @@ /* * ./test_bz1523599 0 vm140-111 gv0 test211 log * ./test_bz1523599 1 vm140-111 gv0 test211 log - * Open - Discard - Read - Then check read information to see if the initial TEST_STR_LEN/2 bytes read zero + * Open - Discard - Read - Then check read information to see if the initial + * TEST_STR_LEN/2 bytes read zero */ #define _GNU_SOURCE @@ -15,182 +16,183 @@ #define TEST_STR_LEN 2048 enum fallocate_flag { - TEST_WRITE, - TEST_DISCARD, - TEST_ZEROFILL, + TEST_WRITE, + TEST_DISCARD, + TEST_ZEROFILL, }; -void print_str(char *str, int len) +void +print_str(char *str, int len) { - int i, addr; - - printf("%07x\t", 0); - for (i = 0; i < len; i++) { - printf("%02x", str[i]); - if (i) { - if ((i + 1) % 16 == 0) - printf("\n%07x\t", i+1); - else if ((i + 1) % 4 == 0) - printf(" "); - } - } - printf("\n"); + int i, addr; + + printf("%07x\t", 0); + for (i = 0; i < len; i++) { + printf("%02x", str[i]); + if (i) { + if ((i + 1) % 16 == 0) + printf("\n%07x\t", i + 1); + else if ((i + 1) % 4 == 0) + printf(" "); + } + } + printf("\n"); } int test_read(char *str, int total_length, int len_zero) { - int i; - int ret = 0; - - for (i = 0; i < len_zero; i++) { - if (str[i]) { - fprintf(stderr, "char at position %d not zeroed out\n", - i); - ret = -EIO; - goto out; - } - } - - for (i = len_zero; i < total_length; i++) { - if (str[i] != 0x11) { - fprintf(stderr, - "char at position %d does not contain pattern\n", - i); - ret = -EIO; - goto out; - } - } + int i; + int ret = 0; + + for (i = 0; i < len_zero; i++) { + if (str[i]) { + fprintf(stderr, "char at position %d not zeroed out\n", i); + ret = -EIO; + goto out; + } + } + + for (i = len_zero; i < total_length; i++) { + if (str[i] != 0x11) { + fprintf(stderr, "char at position %d does not contain pattern\n", + i); + ret = -EIO; + goto out; + } + } out: - return ret; + return ret; } -int main(int argc, char *argv[]) +int +main(int argc, char *argv[]) { - int opcode; - char *host_name, *volume_name, *file_path, *glfs_log_path; - glfs_t *fs = NULL; - glfs_fd_t *fd = NULL; - off_t offset = 0; - size_t len_zero = TEST_STR_LEN / 2; - char writestr[TEST_STR_LEN]; - char readstr[TEST_STR_LEN]; - struct iovec iov = {&readstr, TEST_STR_LEN}; - int i; - int ret = 1; - - for (i = 0; i < TEST_STR_LEN; i++) - writestr[i] = 0x11; - for (i = 0; i < TEST_STR_LEN; i++) - readstr[i] = 0x22; - - if (argc != 6) { - fprintf(stderr, - "Syntax: %s <test type> <host> <volname> <file-path> <log-file>\n", - argv[0]); - return 1; - } - - opcode = atoi(argv[1]); - host_name = argv[2]; - volume_name = argv[3]; - file_path = argv[4]; - glfs_log_path = argv[5]; - - fs = glfs_new(volume_name); - if (!fs) { - perror("glfs_new"); - return 1; - } - - ret = glfs_set_volfile_server(fs, "tcp", host_name, 24007); - if (ret != 0) { - perror("glfs_set_volfile_server"); - goto out; - } - - ret = glfs_set_logging(fs, glfs_log_path, 7); - if (ret != 0) { - perror("glfs_set_logging"); - goto out; - } - - ret = glfs_init(fs); - if (ret != 0) { - perror("glfs_init"); - goto out; - } - - fd = glfs_creat(fs, file_path, O_RDWR, 0777); - if (fd == NULL) { - perror("glfs_creat"); - ret = -1; - goto out; - } - - switch (opcode) { - case TEST_WRITE: - fprintf(stderr, "Test Write\n"); - ret = glfs_write(fd, writestr, TEST_STR_LEN, 0); - if (ret < 0) { - perror("glfs_write"); - goto out; - } else if (ret != TEST_STR_LEN) { - fprintf(stderr, "insufficient data written %d \n", ret); - ret = -EIO; - goto out; - } - ret = 0; - goto out; - case TEST_DISCARD: - fprintf(stderr, "Test Discard\n"); - ret = glfs_discard(fd, offset, len_zero); - if (ret < 0) { - if (errno == EOPNOTSUPP) { - fprintf(stderr, "Operation not supported\n"); - ret = 0; - goto out; - } - perror("glfs_discard"); - goto out; - } - goto test_read; - case TEST_ZEROFILL: - fprintf(stderr, "Test Zerofill\n"); - ret = glfs_zerofill(fd, offset, len_zero); - if (ret < 0) { - if (errno == EOPNOTSUPP) { - fprintf(stderr, "Operation not supported\n"); - ret = 0; - goto out; - } - perror("glfs_zerofill"); - goto out; - } - goto test_read; - default: - ret = -1; - fprintf(stderr, "Incorrect test code %d\n", opcode); - goto out; - } + int opcode; + char *host_name, *volume_name, *file_path, *glfs_log_path; + glfs_t *fs = NULL; + glfs_fd_t *fd = NULL; + off_t offset = 0; + size_t len_zero = TEST_STR_LEN / 2; + char writestr[TEST_STR_LEN]; + char readstr[TEST_STR_LEN]; + struct iovec iov = {&readstr, TEST_STR_LEN}; + int i; + int ret = 1; + + for (i = 0; i < TEST_STR_LEN; i++) + writestr[i] = 0x11; + for (i = 0; i < TEST_STR_LEN; i++) + readstr[i] = 0x22; + + if (argc != 6) { + fprintf( + stderr, + "Syntax: %s <test type> <host> <volname> <file-path> <log-file>\n", + argv[0]); + return 1; + } + + opcode = atoi(argv[1]); + host_name = argv[2]; + volume_name = argv[3]; + file_path = argv[4]; + glfs_log_path = argv[5]; + + fs = glfs_new(volume_name); + if (!fs) { + perror("glfs_new"); + return 1; + } + + ret = glfs_set_volfile_server(fs, "tcp", host_name, 24007); + if (ret != 0) { + perror("glfs_set_volfile_server"); + goto out; + } + + ret = glfs_set_logging(fs, glfs_log_path, 7); + if (ret != 0) { + perror("glfs_set_logging"); + goto out; + } + + ret = glfs_init(fs); + if (ret != 0) { + perror("glfs_init"); + goto out; + } + + fd = glfs_creat(fs, file_path, O_RDWR, 0777); + if (fd == NULL) { + perror("glfs_creat"); + ret = -1; + goto out; + } + + switch (opcode) { + case TEST_WRITE: + fprintf(stderr, "Test Write\n"); + ret = glfs_write(fd, writestr, TEST_STR_LEN, 0); + if (ret < 0) { + perror("glfs_write"); + goto out; + } else if (ret != TEST_STR_LEN) { + fprintf(stderr, "insufficient data written %d \n", ret); + ret = -EIO; + goto out; + } + ret = 0; + goto out; + case TEST_DISCARD: + fprintf(stderr, "Test Discard\n"); + ret = glfs_discard(fd, offset, len_zero); + if (ret < 0) { + if (errno == EOPNOTSUPP) { + fprintf(stderr, "Operation not supported\n"); + ret = 0; + goto out; + } + perror("glfs_discard"); + goto out; + } + goto test_read; + case TEST_ZEROFILL: + fprintf(stderr, "Test Zerofill\n"); + ret = glfs_zerofill(fd, offset, len_zero); + if (ret < 0) { + if (errno == EOPNOTSUPP) { + fprintf(stderr, "Operation not supported\n"); + ret = 0; + goto out; + } + perror("glfs_zerofill"); + goto out; + } + goto test_read; + default: + ret = -1; + fprintf(stderr, "Incorrect test code %d\n", opcode); + goto out; + } test_read: - ret = glfs_readv(fd, &iov, 1, 0); - if (ret < 0) { - perror("glfs_readv"); - goto out; - } + ret = glfs_readv(fd, &iov, 1, 0); + if (ret < 0) { + perror("glfs_readv"); + goto out; + } - /* printf("Read str\n"); print_str(readstr, TEST_STR_LEN); printf("\n"); */ - ret = test_read(readstr, TEST_STR_LEN, len_zero); + /* printf("Read str\n"); print_str(readstr, TEST_STR_LEN); printf("\n"); */ + ret = test_read(readstr, TEST_STR_LEN, len_zero); out: - if (fd) - glfs_close(fd); - glfs_fini(fs); + if (fd) + glfs_close(fd); + glfs_fini(fs); - if (ret) - return -1; + if (ret) + return -1; - return 0; + return 0; } diff --git a/tests/bugs/readdir-ahead/bug-1390050.c b/tests/bugs/readdir-ahead/bug-1390050.c index 5593a1d4c0c..9578df2dd90 100644 --- a/tests/bugs/readdir-ahead/bug-1390050.c +++ b/tests/bugs/readdir-ahead/bug-1390050.c @@ -8,63 +8,65 @@ #include <errno.h> int -main (int argc, char *argv[]) +main(int argc, char *argv[]) { - const char *glfs_dir = NULL, *filepath = NULL; - DIR *dirfd = NULL; - int filefd = 0, ret = 0; - struct stat stbuf = {0, }; - size_t size_before_write = 0; + const char *glfs_dir = NULL, *filepath = NULL; + DIR *dirfd = NULL; + int filefd = 0, ret = 0; + struct stat stbuf = { + 0, + }; + size_t size_before_write = 0; - glfs_dir = argv[1]; - filepath = argv[2]; - dirfd = opendir (glfs_dir); - if (dirfd == NULL) { - fprintf (stderr, "opening directory failed (%s)\n", - strerror (errno)); - goto err; - } + glfs_dir = argv[1]; + filepath = argv[2]; + dirfd = opendir(glfs_dir); + if (dirfd == NULL) { + fprintf(stderr, "opening directory failed (%s)\n", strerror(errno)); + goto err; + } - filefd = open (filepath, O_RDWR); - if (filefd < 0) { - fprintf (stderr, "open failed on path %s (%s)\n", filepath, - strerror (errno)); - goto err; - } + filefd = open(filepath, O_RDWR); + if (filefd < 0) { + fprintf(stderr, "open failed on path %s (%s)\n", filepath, + strerror(errno)); + goto err; + } - ret = stat (filepath, &stbuf); - if (ret < 0) { - fprintf (stderr, "stat failed on path %s (%s)\n", filepath, - strerror (errno)); - goto err; - } + ret = stat(filepath, &stbuf); + if (ret < 0) { + fprintf(stderr, "stat failed on path %s (%s)\n", filepath, + strerror(errno)); + goto err; + } - size_before_write = stbuf.st_size; + size_before_write = stbuf.st_size; - ret = write (filefd, "testdata", strlen ("testdata123") + 1); - if (ret <= 0) { - fprintf (stderr, "write failed (%s)\n", strerror (errno)); - goto err; - } + ret = write(filefd, "testdata", strlen("testdata123") + 1); + if (ret <= 0) { + fprintf(stderr, "write failed (%s)\n", strerror(errno)); + goto err; + } - while (readdir (dirfd)) { - /* do nothing */ - } + while (readdir(dirfd)) { + /* do nothing */ + } - ret = stat (filepath, &stbuf); - if (ret < 0) { - fprintf (stderr, "stat failed on path %s (%s)\n", - strerror (errno)); - goto err; - } + ret = stat(filepath, &stbuf); + if (ret < 0) { + fprintf(stderr, "stat failed on path %s (%s)\n", strerror(errno)); + goto err; + } - if (stbuf.st_size == size_before_write) { - fprintf (stderr, "file size (%lu) has not changed even after " - "its written to\n", stbuf.st_size); - goto err; - } + if (stbuf.st_size == size_before_write) { + fprintf(stderr, + "file size (%lu) has not changed even after " + "its written to\n", + stbuf.st_size); + goto err; + } - return 0; + return 0; err: - return -1; + return -1; } diff --git a/tests/bugs/replicate/bug-1250170-fsync.c b/tests/bugs/replicate/bug-1250170-fsync.c index 421fb5c5067..21fd96594aa 100644 --- a/tests/bugs/replicate/bug-1250170-fsync.c +++ b/tests/bugs/replicate/bug-1250170-fsync.c @@ -7,50 +7,50 @@ #include <unistd.h> #include <string.h> -int main (int argc, char **argv) +int +main(int argc, char **argv) { - char *file = NULL; - int fd = -1; - char *buffer = NULL; - size_t buf_size = 0; - size_t written = 0; - int ret = 0; - off_t offset = 0; - int i = 0; - int loop_count = 5; + char *file = NULL; + int fd = -1; + char *buffer = NULL; + size_t buf_size = 0; + size_t written = 0; + int ret = 0; + off_t offset = 0; + int i = 0; + int loop_count = 5; - if (argc < 2) { - printf ("Usage:%s <filename>\n", argv[0]); - return -1; - } + if (argc < 2) { + printf("Usage:%s <filename>\n", argv[0]); + return -1; + } - file = argv[1]; - buf_size = 1024; - buffer = malloc(buf_size); - if (!buffer) { - perror("malloc"); - return -1; - } - memset (buffer, 'R', buf_size); + file = argv[1]; + buf_size = 1024; + buffer = malloc(buf_size); + if (!buffer) { + perror("malloc"); + return -1; + } + memset(buffer, 'R', buf_size); - fd = open(file, O_WRONLY); - if (fd == -1) { - perror("open"); - return -1; - } + fd = open(file, O_WRONLY); + if (fd == -1) { + perror("open"); + return -1; + } - for (i = 0; i < loop_count; i++) { - ret = write (fd, buffer, buf_size); - if (ret == -1) { - perror("write"); - return ret; - } else { - written += ret; - } - offset = lseek (fd, 0 , SEEK_SET); + for (i = 0; i < loop_count; i++) { + ret = write(fd, buffer, buf_size); + if (ret == -1) { + perror("write"); + return ret; + } else { + written += ret; } + offset = lseek(fd, 0, SEEK_SET); + } - free(buffer); - return 0; - + free(buffer); + return 0; } diff --git a/tests/bugs/shard/bug-shard-discard.c b/tests/bugs/shard/bug-shard-discard.c index b1268278fa5..15dca6c2181 100644 --- a/tests/bugs/shard/bug-shard-discard.c +++ b/tests/bugs/shard/bug-shard-discard.c @@ -4,63 +4,66 @@ #include <glusterfs/api/glfs-handles.h> int -main (int argc, char *argv[]) +main(int argc, char *argv[]) { - int ret = 0; - off_t off = 0; - size_t len = 0; - glfs_t *fs = NULL; - glfs_fd_t *fd = NULL; + int ret = 0; + off_t off = 0; + size_t len = 0; + glfs_t *fs = NULL; + glfs_fd_t *fd = NULL; - if (argc != 7) { - fprintf (stderr, "Syntax: %s <host> <volname> <file-path> <off> <len> <log-file>\n", argv[0]); - return 1; - } + if (argc != 7) { + fprintf( + stderr, + "Syntax: %s <host> <volname> <file-path> <off> <len> <log-file>\n", + argv[0]); + return 1; + } - fs = glfs_new (argv[2]); - if (!fs) { - fprintf (stderr, "glfs_new: returned NULL\n"); - return 1; - } + fs = glfs_new(argv[2]); + if (!fs) { + fprintf(stderr, "glfs_new: returned NULL\n"); + return 1; + } - ret = glfs_set_volfile_server (fs, "tcp", argv[1], 24007); - if (ret != 0) { - fprintf (stderr, "glfs_set_volfile_server: returned %d\n", ret); - goto out; - } + ret = glfs_set_volfile_server(fs, "tcp", argv[1], 24007); + if (ret != 0) { + fprintf(stderr, "glfs_set_volfile_server: returned %d\n", ret); + goto out; + } - ret = glfs_set_logging (fs, argv[6], 7); - if (ret != 0) { - fprintf (stderr, "glfs_set_logging: returned %d\n", ret); - goto out; - } + ret = glfs_set_logging(fs, argv[6], 7); + if (ret != 0) { + fprintf(stderr, "glfs_set_logging: returned %d\n", ret); + goto out; + } - ret = glfs_init (fs); - if (ret != 0) { - fprintf (stderr, "glfs_init: returned %d\n", ret); - goto out; - } + ret = glfs_init(fs); + if (ret != 0) { + fprintf(stderr, "glfs_init: returned %d\n", ret); + goto out; + } - fd = glfs_open (fs, argv[3], O_RDWR); - if (fd == NULL) { - fprintf (stderr, "glfs_open: returned NULL\n"); - goto out; - } + fd = glfs_open(fs, argv[3], O_RDWR); + if (fd == NULL) { + fprintf(stderr, "glfs_open: returned NULL\n"); + goto out; + } - off = atoi (argv[4]); - len = atoi (argv[5]); + off = atoi(argv[4]); + len = atoi(argv[5]); - ret = glfs_discard (fd, off, len); - if (ret <= 0) { - fprintf (stderr, "glfs_discard: returned %d\n", ret); - goto out; - } + ret = glfs_discard(fd, off, len); + if (ret <= 0) { + fprintf(stderr, "glfs_discard: returned %d\n", ret); + goto out; + } - ret = 0; + ret = 0; out: - if (fd) - glfs_close (fd); - glfs_fini (fs); - return ret; + if (fd) + glfs_close(fd); + glfs_fini(fs); + return ret; } diff --git a/tests/bugs/shard/bug-shard-zerofill.c b/tests/bugs/shard/bug-shard-zerofill.c index c0525a58afc..ed4c8c54dc2 100644 --- a/tests/bugs/shard/bug-shard-zerofill.c +++ b/tests/bugs/shard/bug-shard-zerofill.c @@ -3,57 +3,58 @@ #include <glusterfs/api/glfs-handles.h> int -main (int argc, char *argv[]) +main(int argc, char *argv[]) { - glfs_t *fs = NULL; - glfs_fd_t *fd = NULL; - int ret = 1; - - if (argc != 5) { - fprintf (stderr, "Syntax: %s <host> <volname> <file-path> <log-file>\n", argv[0]); - return 1; - } - - fs = glfs_new (argv[2]); - if (!fs) { - fprintf (stderr, "glfs_new: returned NULL\n"); - return 1; - } - - ret = glfs_set_volfile_server (fs, "tcp", argv[1], 24007); - if (ret != 0) { - fprintf (stderr, "glfs_set_volfile_server: returned %d\n", ret); - goto out; - } - ret = glfs_set_logging (fs, argv[4], 7); - if (ret != 0) { - fprintf (stderr, "glfs_set_logging: returned %d\n", ret); - goto out; - } - ret = glfs_init (fs); - if (ret != 0) { - fprintf (stderr, "glfs_init: returned %d\n", ret); - goto out; - } - - fd = glfs_open (fs, argv[3], O_RDWR); - if (fd == NULL) { - fprintf (stderr, "glfs_open: returned NULL\n"); - goto out; - } - - /* Zero-fill "foo" with 10MB of data */ - ret = glfs_zerofill (fd, 0, 10485760); - if (ret <= 0) { - fprintf (stderr, "glfs_zerofill: returned %d\n", ret); - goto out; - } - - ret = 0; + glfs_t *fs = NULL; + glfs_fd_t *fd = NULL; + int ret = 1; + + if (argc != 5) { + fprintf(stderr, "Syntax: %s <host> <volname> <file-path> <log-file>\n", + argv[0]); + return 1; + } + + fs = glfs_new(argv[2]); + if (!fs) { + fprintf(stderr, "glfs_new: returned NULL\n"); + return 1; + } + + ret = glfs_set_volfile_server(fs, "tcp", argv[1], 24007); + if (ret != 0) { + fprintf(stderr, "glfs_set_volfile_server: returned %d\n", ret); + goto out; + } + ret = glfs_set_logging(fs, argv[4], 7); + if (ret != 0) { + fprintf(stderr, "glfs_set_logging: returned %d\n", ret); + goto out; + } + ret = glfs_init(fs); + if (ret != 0) { + fprintf(stderr, "glfs_init: returned %d\n", ret); + goto out; + } + + fd = glfs_open(fs, argv[3], O_RDWR); + if (fd == NULL) { + fprintf(stderr, "glfs_open: returned NULL\n"); + goto out; + } + + /* Zero-fill "foo" with 10MB of data */ + ret = glfs_zerofill(fd, 0, 10485760); + if (ret <= 0) { + fprintf(stderr, "glfs_zerofill: returned %d\n", ret); + goto out; + } + + ret = 0; out: - if (fd) - glfs_close(fd); - glfs_fini (fs); - return ret; + if (fd) + glfs_close(fd); + glfs_fini(fs); + return ret; } diff --git a/tests/bugs/shard/shard-append-test.c b/tests/bugs/shard/shard-append-test.c index 92dff3d078d..c7debb2b182 100644 --- a/tests/bugs/shard/shard-append-test.c +++ b/tests/bugs/shard/shard-append-test.c @@ -10,9 +10,10 @@ #include <glusterfs/api/glfs.h> #include <glusterfs/api/glfs-handles.h> -#define LOG_ERR(msg) do { \ - fprintf (stderr, "%s : Error (%s)\n", msg, strerror (errno)); \ - } while (0) +#define LOG_ERR(msg) \ + do { \ + fprintf(stderr, "%s : Error (%s)\n", msg, strerror(errno)); \ + } while (0) /*This test tests that shard xlator handles offset in appending writes * correctly. This test performs writes of 1025 bytes 1025 times, in 5 threads @@ -26,154 +27,157 @@ pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER; int thread_data = '1'; glfs_t * -init_glfs (const char *hostname, const char *volname, - const char *logfile) +init_glfs(const char *hostname, const char *volname, const char *logfile) { - int ret = -1; - glfs_t *fs = NULL; + int ret = -1; + glfs_t *fs = NULL; - fs = glfs_new (volname); - if (!fs) { - LOG_ERR ("glfs_new failed"); - return NULL; - } - - ret = glfs_set_volfile_server (fs, "tcp", hostname, 24007); - if (ret < 0) { - LOG_ERR ("glfs_set_volfile_server failed"); - goto out; - } - - ret = glfs_set_logging (fs, logfile, 7); - if (ret < 0) { - LOG_ERR ("glfs_set_logging failed"); - goto out; - } - - ret = glfs_init (fs); - if (ret < 0) { - LOG_ERR ("glfs_init failed"); - goto out; - } - - ret = 0; + fs = glfs_new(volname); + if (!fs) { + LOG_ERR("glfs_new failed"); + return NULL; + } + + ret = glfs_set_volfile_server(fs, "tcp", hostname, 24007); + if (ret < 0) { + LOG_ERR("glfs_set_volfile_server failed"); + goto out; + } + + ret = glfs_set_logging(fs, logfile, 7); + if (ret < 0) { + LOG_ERR("glfs_set_logging failed"); + goto out; + } + + ret = glfs_init(fs); + if (ret < 0) { + LOG_ERR("glfs_init failed"); + goto out; + } + + ret = 0; out: - if (ret) { - glfs_fini (fs); - fs = NULL; - } + if (ret) { + glfs_fini(fs); + fs = NULL; + } - return fs; + return fs; } -void* -write_data (void *data) +void * +write_data(void *data) { - char buf[1025] = {0}; - glfs_fd_t *glfd = NULL; - glfs_t *fs = data; - int i = 0; - - pthread_mutex_lock (&lock); - { - memset(buf, thread_data, sizeof(buf)); - thread_data++; + char buf[1025] = {0}; + glfs_fd_t *glfd = NULL; + glfs_t *fs = data; + int i = 0; + + pthread_mutex_lock(&lock); + { + memset(buf, thread_data, sizeof(buf)); + thread_data++; + } + pthread_mutex_unlock(&lock); + + for (i = 0; i < 1025; i++) { + glfd = glfs_creat(fs, "parallel-write.txt", O_WRONLY | O_APPEND, + S_IRUSR | S_IWUSR | O_SYNC); + if (!glfd) { + LOG_ERR("Failed to create file"); + exit(1); } - pthread_mutex_unlock (&lock); - - for (i = 0; i < 1025; i++) { - glfd = glfs_creat(fs, "parallel-write.txt", O_WRONLY | O_APPEND, - S_IRUSR | S_IWUSR | O_SYNC); - if (!glfd) { - LOG_ERR ("Failed to create file"); - exit(1); - } - - if (glfs_write (glfd, buf, sizeof(buf), 0) < 0) { - LOG_ERR ("Failed to write to file"); - exit(1); - } - if (glfs_close(glfd) != 0) { - LOG_ERR ("Failed to close file"); - exit(1); - } + + if (glfs_write(glfd, buf, sizeof(buf), 0) < 0) { + LOG_ERR("Failed to write to file"); + exit(1); } - return NULL; + if (glfs_close(glfd) != 0) { + LOG_ERR("Failed to close file"); + exit(1); + } + } + return NULL; } int -main (int argc, char *argv[]) +main(int argc, char *argv[]) { - pthread_t tid[5] = {0}; - char buf[1025] = {0}; - char cmp_buf[1025] = {0}; - int ret = 0; - char *hostname = NULL; - char *volname = NULL; - char *logfile = NULL; - glfs_t *fs = NULL; - glfs_fd_t *glfd = NULL; - ssize_t bytes_read = 0; - ssize_t total_bytes_read = 0; - int i = 0; - - if (argc != 4) { - fprintf (stderr, "Invalid argument\n"); - exit(1); - } - - hostname = argv[1]; - volname = argv[2]; - logfile = argv[3]; - - fs = init_glfs (hostname, volname, logfile); - if (fs == NULL) { - LOG_ERR ("init_glfs failed"); - return -1; - } - - for (i = 0; i < 5; i++) { - pthread_create(&tid[i], NULL, write_data, fs); - } - - for (i = 0; i < 5; i++) { - pthread_join(tid[i], NULL); - } - glfd = glfs_open(fs, "parallel-write.txt", O_RDONLY); - if (!glfd) { - LOG_ERR ("Failed to open file for reading"); - exit(1); + pthread_t tid[5] = {0}; + char buf[1025] = {0}; + char cmp_buf[1025] = {0}; + int ret = 0; + char *hostname = NULL; + char *volname = NULL; + char *logfile = NULL; + glfs_t *fs = NULL; + glfs_fd_t *glfd = NULL; + ssize_t bytes_read = 0; + ssize_t total_bytes_read = 0; + int i = 0; + + if (argc != 4) { + fprintf(stderr, "Invalid argument\n"); + exit(1); + } + + hostname = argv[1]; + volname = argv[2]; + logfile = argv[3]; + + fs = init_glfs(hostname, volname, logfile); + if (fs == NULL) { + LOG_ERR("init_glfs failed"); + return -1; + } + + for (i = 0; i < 5; i++) { + pthread_create(&tid[i], NULL, write_data, fs); + } + + for (i = 0; i < 5; i++) { + pthread_join(tid[i], NULL); + } + glfd = glfs_open(fs, "parallel-write.txt", O_RDONLY); + if (!glfd) { + LOG_ERR("Failed to open file for reading"); + exit(1); + } + + while ((bytes_read = glfs_read(glfd, buf, sizeof(buf), 0)) > 0) { + if (bytes_read != sizeof(buf)) { + fprintf(stderr, + "Didn't read complete data read: %zd " + "expected: %lu", + bytes_read, sizeof(buf)); + exit(1); } - while ((bytes_read = glfs_read (glfd, buf, sizeof(buf), 0)) > 0) { - if (bytes_read != sizeof(buf)) { - fprintf (stderr, "Didn't read complete data read: %zd " - "expected: %lu", bytes_read, sizeof(buf)); - exit(1); - } - - total_bytes_read += bytes_read; - if (buf[0] < '1' || buf[0] >= thread_data) { - fprintf(stderr, "Invalid character found: %c", buf[0]); - exit(1); - } - memset(cmp_buf, buf[0], sizeof(cmp_buf)); - if (memcmp(cmp_buf, buf, sizeof(cmp_buf))) { - LOG_ERR ("Data corrupted"); - exit(1); - } - memset(cmp_buf, 0, sizeof(cmp_buf)); + total_bytes_read += bytes_read; + if (buf[0] < '1' || buf[0] >= thread_data) { + fprintf(stderr, "Invalid character found: %c", buf[0]); + exit(1); } - - if (total_bytes_read != 5*1025*1025) { - fprintf(stderr, "Failed to read what is written, read; %zd, " - "expected %zu", total_bytes_read, 5*1025*1025); - exit(1); - } - - if (glfs_close(glfd) != 0) { - LOG_ERR ("Failed to close"); - exit(1); + memset(cmp_buf, buf[0], sizeof(cmp_buf)); + if (memcmp(cmp_buf, buf, sizeof(cmp_buf))) { + LOG_ERR("Data corrupted"); + exit(1); } - return 0; + memset(cmp_buf, 0, sizeof(cmp_buf)); + } + + if (total_bytes_read != 5 * 1025 * 1025) { + fprintf(stderr, + "Failed to read what is written, read; %zd, " + "expected %zu", + total_bytes_read, 5 * 1025 * 1025); + exit(1); + } + + if (glfs_close(glfd) != 0) { + LOG_ERR("Failed to close"); + exit(1); + } + return 0; } diff --git a/tests/bugs/shard/shard-fallocate.c b/tests/bugs/shard/shard-fallocate.c index 8745c0ece1d..3a784d3c02c 100644 --- a/tests/bugs/shard/shard-fallocate.c +++ b/tests/bugs/shard/shard-fallocate.c @@ -6,104 +6,107 @@ #include <glusterfs/api/glfs-handles.h> enum fallocate_flag { - TEST_FALLOCATE_NONE, - TEST_FALLOCATE_KEEP_SIZE, - TEST_FALLOCATE_ZERO_RANGE, - TEST_FALLOCATE_PUNCH_HOLE, - TEST_FALLOCATE_MAX, + TEST_FALLOCATE_NONE, + TEST_FALLOCATE_KEEP_SIZE, + TEST_FALLOCATE_ZERO_RANGE, + TEST_FALLOCATE_PUNCH_HOLE, + TEST_FALLOCATE_MAX, }; int -get_fallocate_flag (int opcode) +get_fallocate_flag(int opcode) { - int ret = 0; + int ret = 0; - switch (opcode) { + switch (opcode) { case TEST_FALLOCATE_NONE: - ret = 0; - break; + ret = 0; + break; case TEST_FALLOCATE_KEEP_SIZE: - ret = FALLOC_FL_KEEP_SIZE; - break; + ret = FALLOC_FL_KEEP_SIZE; + break; case TEST_FALLOCATE_ZERO_RANGE: - ret = FALLOC_FL_ZERO_RANGE; - break; + ret = FALLOC_FL_ZERO_RANGE; + break; case TEST_FALLOCATE_PUNCH_HOLE: - ret = FALLOC_FL_PUNCH_HOLE; - break; + ret = FALLOC_FL_PUNCH_HOLE; + break; default: - ret = -1; - break; - } - return ret; + ret = -1; + break; + } + return ret; } int -main (int argc, char *argv[]) +main(int argc, char *argv[]) { - int ret = 1; - int opcode = -1; - off_t offset = 0; - size_t len = 0; - glfs_t *fs = NULL; - glfs_fd_t *fd = NULL; + int ret = 1; + int opcode = -1; + off_t offset = 0; + size_t len = 0; + glfs_t *fs = NULL; + glfs_fd_t *fd = NULL; - if (argc != 8) { - fprintf (stderr, "Syntax: %s <host> <volname> <opcode> <offset> <len> <file-path> <log-file>\n", argv[0]); - return 1; - } + if (argc != 8) { + fprintf(stderr, + "Syntax: %s <host> <volname> <opcode> <offset> <len> " + "<file-path> <log-file>\n", + argv[0]); + return 1; + } - fs = glfs_new (argv[2]); - if (!fs) { - fprintf (stderr, "glfs_new: returned NULL\n"); - return 1; - } + fs = glfs_new(argv[2]); + if (!fs) { + fprintf(stderr, "glfs_new: returned NULL\n"); + return 1; + } - ret = glfs_set_volfile_server (fs, "tcp", argv[1], 24007); - if (ret != 0) { - fprintf (stderr, "glfs_set_volfile_server: returned %d\n", ret); - goto out; - } + ret = glfs_set_volfile_server(fs, "tcp", argv[1], 24007); + if (ret != 0) { + fprintf(stderr, "glfs_set_volfile_server: returned %d\n", ret); + goto out; + } - ret = glfs_set_logging (fs, argv[7], 7); - if (ret != 0) { - fprintf (stderr, "glfs_set_logging: returned %d\n", ret); - goto out; - } + ret = glfs_set_logging(fs, argv[7], 7); + if (ret != 0) { + fprintf(stderr, "glfs_set_logging: returned %d\n", ret); + goto out; + } - ret = glfs_init (fs); - if (ret != 0) { - fprintf (stderr, "glfs_init: returned %d\n", ret); - goto out; - } + ret = glfs_init(fs); + if (ret != 0) { + fprintf(stderr, "glfs_init: returned %d\n", ret); + goto out; + } - opcode = atoi (argv[3]); - opcode = get_fallocate_flag (opcode); - if (opcode < 0) { - fprintf (stderr, "get_fallocate_flag: invalid flag \n"); - goto out; - } + opcode = atoi(argv[3]); + opcode = get_fallocate_flag(opcode); + if (opcode < 0) { + fprintf(stderr, "get_fallocate_flag: invalid flag \n"); + goto out; + } - offset = atoi (argv[4]); - len = atoi (argv[5]); + offset = atoi(argv[4]); + len = atoi(argv[5]); - fd = glfs_open (fs, argv[6], O_RDWR); - if (fd == NULL) { - fprintf (stderr, "glfs_open: returned NULL\n"); - goto out; - } + fd = glfs_open(fs, argv[6], O_RDWR); + if (fd == NULL) { + fprintf(stderr, "glfs_open: returned NULL\n"); + goto out; + } - ret = glfs_fallocate (fd, opcode, offset, len); - if (ret <= 0) { - fprintf (stderr, "glfs_fallocate: returned %d\n", ret); - goto out; - } + ret = glfs_fallocate(fd, opcode, offset, len); + if (ret <= 0) { + fprintf(stderr, "glfs_fallocate: returned %d\n", ret); + goto out; + } - ret = 0; + ret = 0; out: - if (fd) - glfs_close(fd); - glfs_fini (fs); - return ret; + if (fd) + glfs_close(fd); + glfs_fini(fs); + return ret; } diff --git a/tests/bugs/write-behind/bug-1058663.c b/tests/bugs/write-behind/bug-1058663.c index 5e522e98048..aedf97d7487 100644 --- a/tests/bugs/write-behind/bug-1058663.c +++ b/tests/bugs/write-behind/bug-1058663.c @@ -19,101 +19,105 @@ static int sigbus_received; /* test for truncate()/seek()/write()/mmap() * There should ne no SIGBUS triggered. */ -void seek_write(char *filename) +void +seek_write(char *filename) { - int fd; - uint8_t *map; - int i; - - fd = open(filename, O_RDWR|O_CREAT|O_TRUNC, 0600); - lseek(fd, FILE_SIZE - 1, SEEK_SET); - write(fd, "\xff", 1); - - map = mmap(NULL, FILE_SIZE, PROT_READ, MAP_PRIVATE, fd, 0); - for (i = 0; i < (FILE_SIZE - 1); i++) { - if (map[i] != 0) /* should never be true */ - abort(); - } - munmap(map, FILE_SIZE); - - close(fd); + int fd; + uint8_t *map; + int i; + + fd = open(filename, O_RDWR | O_CREAT | O_TRUNC, 0600); + lseek(fd, FILE_SIZE - 1, SEEK_SET); + write(fd, "\xff", 1); + + map = mmap(NULL, FILE_SIZE, PROT_READ, MAP_PRIVATE, fd, 0); + for (i = 0; i < (FILE_SIZE - 1); i++) { + if (map[i] != 0) /* should never be true */ + abort(); + } + munmap(map, FILE_SIZE); + + close(fd); } -int read_after_eof(char *filename) +int +read_after_eof(char *filename) { - int ret = 0; - int fd; - char *data; - uint8_t *map; - - fd = open(filename, O_RDWR|O_CREAT|O_TRUNC, 0600); - lseek(fd, FILE_SIZE - 1, SEEK_SET); - write(fd, "\xff", 1); - - /* trigger verify that reading after EOF fails */ - ret = read(fd, data, FILE_SIZE / 2); - if (ret != 0) - return 1; - - /* map an area of 1 byte after FILE_SIZE */ - map = mmap(NULL, 1, PROT_READ, MAP_PRIVATE, fd, FILE_SIZE); - /* map[0] is an access after EOF, it should trigger SIGBUS */ - if (map[0] != 0) - /* it is expected that we exit before we get here */ - if (!sigbus_received) - return 1; - munmap(map, FILE_SIZE); - - close(fd); - - return ret; + int ret = 0; + int fd; + char *data; + uint8_t *map; + + fd = open(filename, O_RDWR | O_CREAT | O_TRUNC, 0600); + lseek(fd, FILE_SIZE - 1, SEEK_SET); + write(fd, "\xff", 1); + + /* trigger verify that reading after EOF fails */ + ret = read(fd, data, FILE_SIZE / 2); + if (ret != 0) + return 1; + + /* map an area of 1 byte after FILE_SIZE */ + map = mmap(NULL, 1, PROT_READ, MAP_PRIVATE, fd, FILE_SIZE); + /* map[0] is an access after EOF, it should trigger SIGBUS */ + if (map[0] != 0) + /* it is expected that we exit before we get here */ + if (!sigbus_received) + return 1; + munmap(map, FILE_SIZE); + + close(fd); + + return ret; } /* signal handler for SIGBUS */ -void catch_sigbus(int signum) +void +catch_sigbus(int signum) { - switch (signum) { + switch (signum) { #ifdef __NetBSD__ - /* Depending on architecture, we can get SIGSEGV */ - case SIGSEGV: /* FALLTHROUGH */ + /* Depending on architecture, we can get SIGSEGV */ + case SIGSEGV: /* FALLTHROUGH */ #endif - case SIGBUS: - sigbus_received++; - if (!expect_sigbus) - exit(EXIT_FAILURE); - if (sigbus_received >= MAX_SIGBUS) - exit(EXIT_SUCCESS); - break; - default: - printf("Unexpected signal received: %d\n", signum); - } + case SIGBUS: + sigbus_received++; + if (!expect_sigbus) + exit(EXIT_FAILURE); + if (sigbus_received >= MAX_SIGBUS) + exit(EXIT_SUCCESS); + break; + default: + printf("Unexpected signal received: %d\n", signum); + } } -int main(int argc, char **argv) +int +main(int argc, char **argv) { - int i = 0; + int i = 0; - if (argc == 1) { - printf("Usage: %s <filename>\n", argv[0]); - return EXIT_FAILURE; - } + if (argc == 1) { + printf("Usage: %s <filename>\n", argv[0]); + return EXIT_FAILURE; + } #ifdef __NetBSD__ - /* Depending on architecture, we can get SIGSEGV */ - signal(SIGSEGV, catch_sigbus); + /* Depending on architecture, we can get SIGSEGV */ + signal(SIGSEGV, catch_sigbus); #endif - signal(SIGBUS, catch_sigbus); + signal(SIGBUS, catch_sigbus); - /* the next test should not trigger SIGBUS */ - expect_sigbus = 0; - for (i = 0; i < RUN_LOOP; i++) { - seek_write(argv[1]); - } + /* the next test should not trigger SIGBUS */ + expect_sigbus = 0; + for (i = 0; i < RUN_LOOP; i++) { + seek_write(argv[1]); + } - /* the next test should trigger SIGBUS */ - expect_sigbus = 1; - if (read_after_eof(argv[1])) - return EXIT_FAILURE; + /* the next test should trigger SIGBUS */ + expect_sigbus = 1; + if (read_after_eof(argv[1])) + return EXIT_FAILURE; - return EXIT_SUCCESS; + return EXIT_SUCCESS; } diff --git a/tests/bugs/write-behind/bug-1279730.c b/tests/bugs/write-behind/bug-1279730.c index 535d289c582..706ae67b102 100644 --- a/tests/bugs/write-behind/bug-1279730.c +++ b/tests/bugs/write-behind/bug-1279730.c @@ -8,124 +8,142 @@ #include <assert.h> int -main (int argc, char *argv[]) +main(int argc, char *argv[]) { - int fd = -1, ret = -1, len = 0; - char *path = NULL, buf[128] = {0, }, *cmd = NULL; - struct stat stbuf = {0, }; - int write_to_child[2] = {0, }, write_to_parent[2] = {0, }; + int fd = -1, ret = -1, len = 0; + char *path = NULL, + buf[128] = + { + 0, + }, + *cmd = NULL; + struct stat stbuf = { + 0, + }; + int write_to_child[2] = + { + 0, + }, + write_to_parent[2] = { + 0, + }; + + path = argv[1]; + cmd = argv[2]; + + assert(argc == 3); + + ret = pipe(write_to_child); + if (ret < 0) { + fprintf(stderr, + "creation of write-to-child pipe failed " + "(%s)\n", + strerror(errno)); + goto out; + } + + ret = pipe(write_to_parent); + if (ret < 0) { + fprintf(stderr, + "creation of write-to-parent pipe failed " + "(%s)\n", + strerror(errno)); + goto out; + } + + ret = fork(); + switch (ret) { + case 0: + close(write_to_child[1]); + close(write_to_parent[0]); + + /* child, wait for instructions to execute command */ + ret = read(write_to_child[0], buf, 128); + if (ret < 0) { + fprintf(stderr, "child: read on pipe failed (%s)\n", + strerror(errno)); + goto out; + } - path = argv[1]; - cmd = argv[2]; + system(cmd); + + ret = write(write_to_parent[1], "1", 2); + if (ret < 0) { + fprintf(stderr, "child: write to pipe failed (%s)\n", + strerror(errno)); + goto out; + } + break; - assert (argc == 3); + case -1: + fprintf(stderr, "fork failed (%s)\n", strerror(errno)); + goto out; + + default: + close(write_to_parent[1]); + close(write_to_child[0]); - ret = pipe (write_to_child); - if (ret < 0) { - fprintf (stderr, "creation of write-to-child pipe failed " - "(%s)\n", strerror (errno)); + fd = open(path, O_CREAT | O_RDWR | O_APPEND, S_IRWXU); + if (fd < 0) { + fprintf(stderr, "open failed (%s)\n", strerror(errno)); goto out; - } + } + + len = strlen("test-content") + 1; + ret = write(fd, "test-content", len); + + if (ret < len) { + fprintf(stderr, "write failed %d (%s)\n", ret, strerror(errno)); + } + + ret = pread(fd, buf, 128, 0); + if ((ret == len) && (strcmp(buf, "test-content") == 0)) { + fprintf(stderr, + "read should've failed as previous " + "write would've failed with EDQUOT, but its " + "successful"); + ret = -1; + goto out; + } - ret = pipe (write_to_parent); - if (ret < 0) { - fprintf (stderr, "creation of write-to-parent pipe failed " - "(%s)\n", strerror (errno)); + ret = write(write_to_child[1], "1", 2); + if (ret < 0) { + fprintf(stderr, "parent: write to pipe failed (%s)\n", + strerror(errno)); goto out; - } + } - ret = fork (); - switch (ret) { - case 0: - close (write_to_child[1]); - close (write_to_parent[0]); - - /* child, wait for instructions to execute command */ - ret = read (write_to_child[0], buf, 128); - if (ret < 0) { - fprintf (stderr, "child: read on pipe failed (%s)\n", - strerror (errno)); - goto out; - } - - system (cmd); - - ret = write (write_to_parent[1], "1", 2); - if (ret < 0) { - fprintf (stderr, "child: write to pipe failed (%s)\n", - strerror (errno)); - goto out; - } - break; + ret = read(write_to_parent[0], buf, 128); + if (ret < 0) { + fprintf(stderr, "parent: read from pipe failed (%s)\n", + strerror(errno)); + goto out; + } + + /* this will force a sync on cached-write and now that quota + limit is increased, sync will be successful. ignore return + value as fstat would fail with EDQUOT (picked up from + cached-write because of previous sync failure. + */ + fstat(fd, &stbuf); + + ret = pread(fd, buf, 128, 0); + if (ret != len) { + fprintf(stderr, + "post cmd read failed %d (data:%s) " + "(error:%s)\n", + ret, buf, strerror(errno)); + goto out; + } - case -1: - fprintf (stderr, "fork failed (%s)\n", strerror (errno)); + if (strcmp(buf, "test-content")) { + fprintf(stderr, "wrong data (%s)\n", buf); goto out; + } + } - default: - close (write_to_parent[1]); - close (write_to_child[0]); - - fd = open (path, O_CREAT | O_RDWR | O_APPEND, S_IRWXU); - if (fd < 0) { - fprintf (stderr, "open failed (%s)\n", - strerror (errno)); - goto out; - } - - len = strlen ("test-content") + 1; - ret = write (fd, "test-content", len); - - if (ret < len) { - fprintf (stderr, "write failed %d (%s)\n", ret, - strerror (errno)); - } - - ret = pread (fd, buf, 128, 0); - if ((ret == len) && (strcmp (buf, "test-content") == 0)) { - fprintf (stderr, "read should've failed as previous " - "write would've failed with EDQUOT, but its " - "successful"); - ret = -1; - goto out; - } - - ret = write (write_to_child[1], "1", 2); - if (ret < 0) { - fprintf (stderr, "parent: write to pipe failed (%s)\n", - strerror (errno)); - goto out; - } - - ret = read (write_to_parent[0], buf, 128); - if (ret < 0) { - fprintf (stderr, "parent: read from pipe failed (%s)\n", - strerror (errno)); - goto out; - } - - /* this will force a sync on cached-write and now that quota - limit is increased, sync will be successful. ignore return - value as fstat would fail with EDQUOT (picked up from - cached-write because of previous sync failure. - */ - fstat (fd, &stbuf); - - ret = pread (fd, buf, 128, 0); - if (ret != len) { - fprintf (stderr, "post cmd read failed %d (data:%s) " - "(error:%s)\n", ret, buf, strerror (errno)); - goto out; - } - - if (strcmp (buf, "test-content")) { - fprintf (stderr, "wrong data (%s)\n", buf); - goto out; - } - } - - ret = 0; + ret = 0; out: - return ret; + return ret; } diff --git a/tests/encryption/frag.c b/tests/encryption/frag.c index 86da037c607..7b4510f6a4d 100644 --- a/tests/encryption/frag.c +++ b/tests/encryption/frag.c @@ -20,300 +20,296 @@ #define MAX_NUM_OPS (1 << 20) #define MAX_FILE_SIZE (1 << 30) -typedef enum { - READ_OP, - WRITE_OP, - TRUNC_OP, - LAST_OP -} frag_op; +typedef enum { READ_OP, WRITE_OP, TRUNC_OP, LAST_OP } frag_op; struct frag_ctx { - int test_fd; - int good_fd; - char *test_buf; - char *good_buf; - char *content; - int max_file_size; + int test_fd; + int good_fd; + char *test_buf; + char *good_buf; + char *content; + int max_file_size; }; typedef int (*frag_op_t)(struct frag_ctx *ctx, off_t offset, size_t count); -static int doread(int fd, off_t offset, size_t count, - char *buf, int max_file_size) +static int +doread(int fd, off_t offset, size_t count, char *buf, int max_file_size) { - int ret = 0; - int was_read = 0; + int ret = 0; + int was_read = 0; - if (lseek(fd, offset, SEEK_SET) == -1) { - perror("lseek failed"); - return -1; - } - while (count) { - ret = read(fd, buf + offset + was_read, count); - if (ret < 0) - return -1; - if (ret == 0) - break; - if (ret > count) { - fprintf(stderr, "READ: read more than asked\n"); - return -1; - } - count -= ret; - was_read += ret; - } - return ret; + if (lseek(fd, offset, SEEK_SET) == -1) { + perror("lseek failed"); + return -1; + } + while (count) { + ret = read(fd, buf + offset + was_read, count); + if (ret < 0) + return -1; + if (ret == 0) + break; + if (ret > count) { + fprintf(stderr, "READ: read more than asked\n"); + return -1; + } + count -= ret; + was_read += ret; + } + return ret; } -static int dowrite(int fd, off_t offset, size_t count, char *buf) +static int +dowrite(int fd, off_t offset, size_t count, char *buf) { - int ret; + int ret; - ret = lseek(fd, offset, SEEK_SET); - if (ret == -1) - return ret; - return write(fd, buf, count); + ret = lseek(fd, offset, SEEK_SET); + if (ret == -1) + return ret; + return write(fd, buf, count); } -static int dotrunc(int fd, off_t offset) +static int +dotrunc(int fd, off_t offset) { - int ret; + int ret; - ret = ftruncate(fd, offset); - if (ret == -1) - perror("truncate failed"); - return ret; + ret = ftruncate(fd, offset); + if (ret == -1) + perror("truncate failed"); + return ret; } -static int prepare_file(char *filename, int *fd, char **buf, int max_file_size) +static int +prepare_file(char *filename, int *fd, char **buf, int max_file_size) { - int ret; + int ret; - *buf = malloc(max_file_size); - if (*buf == NULL) { - perror("malloc failed"); - return -1; - } - *fd = open(filename, O_CREAT | O_RDWR, S_IRWXU); - if (*fd == -1) { - perror("open failed"); - free(*buf); - *buf = NULL; - return -1; - } - return 0; + *buf = malloc(max_file_size); + if (*buf == NULL) { + perror("malloc failed"); + return -1; + } + *fd = open(filename, O_CREAT | O_RDWR, S_IRWXU); + if (*fd == -1) { + perror("open failed"); + free(*buf); + *buf = NULL; + return -1; + } + return 0; } /* * @offset, @count: random values from [0, max_file_size - 1] */ -static int frag_write(struct frag_ctx *ctx, off_t offset, size_t count) +static int +frag_write(struct frag_ctx *ctx, off_t offset, size_t count) { - int ret; - struct stat test_stbuf; - struct stat good_stbuf; + int ret; + struct stat test_stbuf; + struct stat good_stbuf; - if (offset + count > ctx->max_file_size) - offset = offset / 2; - if (offset + count > ctx->max_file_size) - count = count / 2; + if (offset + count > ctx->max_file_size) + offset = offset / 2; + if (offset + count > ctx->max_file_size) + count = count / 2; - if (fstat(ctx->test_fd, &test_stbuf)) { - fprintf(stderr, "WRITE: fstat of test file failed\n"); - return -1; - } - if (offset > test_stbuf.st_size) - printf("writing hole\n"); + if (fstat(ctx->test_fd, &test_stbuf)) { + fprintf(stderr, "WRITE: fstat of test file failed\n"); + return -1; + } + if (offset > test_stbuf.st_size) + printf("writing hole\n"); - ret = dowrite(ctx->test_fd, offset, count, ctx->content); - if (ret < 0 || ret != count){ - fprintf(stderr, "WRITE: failed to write test file\n"); - return -1; - } - ret = dowrite(ctx->good_fd, offset, count, ctx->content); - if (ret < 0 || ret != count) { - fprintf(stderr, "WRITE: failed to write test file\n"); - return -1; - } - if (fstat(ctx->test_fd, &test_stbuf)) { - fprintf(stderr, "WRITE: fstat of test file failed\n"); - return -1; - } - if (fstat(ctx->good_fd, &good_stbuf)) { - fprintf(stderr, "WRITE: fstat of good file failed\n"); - return -1; - } - if (test_stbuf.st_size != good_stbuf.st_size) { - fprintf(stderr, - "READ: Bad file size %d (expected %d)\n", - (int)test_stbuf.st_size, - (int)good_stbuf.st_size); - return -1; - } - return 0; + ret = dowrite(ctx->test_fd, offset, count, ctx->content); + if (ret < 0 || ret != count) { + fprintf(stderr, "WRITE: failed to write test file\n"); + return -1; + } + ret = dowrite(ctx->good_fd, offset, count, ctx->content); + if (ret < 0 || ret != count) { + fprintf(stderr, "WRITE: failed to write test file\n"); + return -1; + } + if (fstat(ctx->test_fd, &test_stbuf)) { + fprintf(stderr, "WRITE: fstat of test file failed\n"); + return -1; + } + if (fstat(ctx->good_fd, &good_stbuf)) { + fprintf(stderr, "WRITE: fstat of good file failed\n"); + return -1; + } + if (test_stbuf.st_size != good_stbuf.st_size) { + fprintf(stderr, "READ: Bad file size %d (expected %d)\n", + (int)test_stbuf.st_size, (int)good_stbuf.st_size); + return -1; + } + return 0; } /* * @offset, @count: random values from [0, max_file_size - 1] */ -static int frag_read(struct frag_ctx *ctx, off_t offset, size_t count) +static int +frag_read(struct frag_ctx *ctx, off_t offset, size_t count) { - ssize_t test_ret; - ssize_t good_ret; + ssize_t test_ret; + ssize_t good_ret; - test_ret = doread(ctx->test_fd, - offset, count, ctx->test_buf, ctx->max_file_size); - if (test_ret < 0) { - fprintf(stderr, "READ: failed to read test file\n"); - return -1; - } - good_ret = doread(ctx->good_fd, - offset, count, ctx->good_buf, ctx->max_file_size); - if (good_ret < 0) { - fprintf(stderr, "READ: failed to read good file\n"); - return -1; - } - if (test_ret != good_ret) { - fprintf(stderr, - "READ: Bad return value %d (expected %d\n)", - test_ret, good_ret); - return -1; - } - if (memcmp(ctx->test_buf + offset, ctx->good_buf + offset, good_ret)) { - fprintf(stderr, "READ: bad data\n"); - return -1; - } - return 0; + test_ret = doread(ctx->test_fd, offset, count, ctx->test_buf, + ctx->max_file_size); + if (test_ret < 0) { + fprintf(stderr, "READ: failed to read test file\n"); + return -1; + } + good_ret = doread(ctx->good_fd, offset, count, ctx->good_buf, + ctx->max_file_size); + if (good_ret < 0) { + fprintf(stderr, "READ: failed to read good file\n"); + return -1; + } + if (test_ret != good_ret) { + fprintf(stderr, "READ: Bad return value %d (expected %d\n)", test_ret, + good_ret); + return -1; + } + if (memcmp(ctx->test_buf + offset, ctx->good_buf + offset, good_ret)) { + fprintf(stderr, "READ: bad data\n"); + return -1; + } + return 0; } /* * @offset: random value from [0, max_file_size - 1] */ -static int frag_truncate(struct frag_ctx *ctx, - off_t offset, __attribute__((unused))size_t count) +static int +frag_truncate(struct frag_ctx *ctx, off_t offset, + __attribute__((unused)) size_t count) { - int ret; - struct stat test_stbuf; - struct stat good_stbuf; + int ret; + struct stat test_stbuf; + struct stat good_stbuf; + + if (fstat(ctx->test_fd, &test_stbuf)) { + fprintf(stderr, "TRUNCATE: fstat of test file failed\n"); + return -1; + } + if (offset > test_stbuf.st_size) + printf("expanding truncate to %d\n", offset); + else if (offset < test_stbuf.st_size) + printf("shrinking truncate to %d\n", offset); + else + printf("trivial truncate\n"); - if (fstat(ctx->test_fd, &test_stbuf)) { - fprintf(stderr, "TRUNCATE: fstat of test file failed\n"); - return -1; - } - if (offset > test_stbuf.st_size) - printf("expanding truncate to %d\n", offset); - else if (offset < test_stbuf.st_size) - printf("shrinking truncate to %d\n", offset); - else - printf("trivial truncate\n"); - - ret = dotrunc(ctx->test_fd, offset); - if (ret == -1) { - fprintf(stderr, "TRUNCATE: failed for test file\n"); - return -1; - } - ret = dotrunc(ctx->good_fd, offset); - if (ret == -1) { - fprintf(stderr, "TRUNCATE: failed for good file\n"); - return -1; - } - if (fstat(ctx->test_fd, &test_stbuf)) { - fprintf(stderr, "TRUNCATE: fstat of test file failed\n"); - return -1; - } - if (fstat(ctx->good_fd, &good_stbuf)) { - fprintf(stderr, "TRUNCATE: fstat of good file failed\n"); - return -1; - } - if (test_stbuf.st_size != good_stbuf.st_size) { - fprintf(stderr, - "TRUNCATE: bad test file size %d (expected %d)\n", - test_stbuf.st_size, - good_stbuf.st_size); - return -1; - } - return 0; + ret = dotrunc(ctx->test_fd, offset); + if (ret == -1) { + fprintf(stderr, "TRUNCATE: failed for test file\n"); + return -1; + } + ret = dotrunc(ctx->good_fd, offset); + if (ret == -1) { + fprintf(stderr, "TRUNCATE: failed for good file\n"); + return -1; + } + if (fstat(ctx->test_fd, &test_stbuf)) { + fprintf(stderr, "TRUNCATE: fstat of test file failed\n"); + return -1; + } + if (fstat(ctx->good_fd, &good_stbuf)) { + fprintf(stderr, "TRUNCATE: fstat of good file failed\n"); + return -1; + } + if (test_stbuf.st_size != good_stbuf.st_size) { + fprintf(stderr, "TRUNCATE: bad test file size %d (expected %d)\n", + test_stbuf.st_size, good_stbuf.st_size); + return -1; + } + return 0; } -frag_op_t frag_ops[LAST_OP] = { - [READ_OP] = frag_read, - [WRITE_OP] = frag_write, - [TRUNC_OP] = frag_truncate -}; +frag_op_t frag_ops[LAST_OP] = {[READ_OP] = frag_read, + [WRITE_OP] = frag_write, + [TRUNC_OP] = frag_truncate}; -static void put_ctx(struct frag_ctx *ctx) +static void +put_ctx(struct frag_ctx *ctx) { - if (ctx->test_buf) - free(ctx->test_buf); - if (ctx->good_buf) - free(ctx->good_buf); - if (ctx->content) - free(ctx->content); + if (ctx->test_buf) + free(ctx->test_buf); + if (ctx->good_buf) + free(ctx->good_buf); + if (ctx->content) + free(ctx->content); } -main (int argc, char *argv[]) +main(int argc, char *argv[]) { - int i; - int ret = 0; - struct frag_ctx ctx; - char *test_filename = NULL; - char *good_filename = NULL; - int num_ops; - int max_file_size; + int i; + int ret = 0; + struct frag_ctx ctx; + char *test_filename = NULL; + char *good_filename = NULL; + int num_ops; + int max_file_size; - memset(&ctx, 0, sizeof(ctx)); - if (argc != 5) { - fprintf(stderr, - "usage: %s <test-file-name> <good-file-name> <max-file-size> <number-of-operations>\n", - argv[0]); - ret = -1; - goto exit; - } - test_filename = argv[1]; - good_filename = argv[2]; - max_file_size = atoi(argv[3]); - if (max_file_size > MAX_FILE_SIZE) - max_file_size = MAX_FILE_SIZE; - num_ops = atoi(argv[4]); - if (num_ops > MAX_NUM_OPS) - num_ops = MAX_NUM_OPS; + memset(&ctx, 0, sizeof(ctx)); + if (argc != 5) { + fprintf(stderr, + "usage: %s <test-file-name> <good-file-name> <max-file-size> " + "<number-of-operations>\n", + argv[0]); + ret = -1; + goto exit; + } + test_filename = argv[1]; + good_filename = argv[2]; + max_file_size = atoi(argv[3]); + if (max_file_size > MAX_FILE_SIZE) + max_file_size = MAX_FILE_SIZE; + num_ops = atoi(argv[4]); + if (num_ops > MAX_NUM_OPS) + num_ops = MAX_NUM_OPS; - ret = prepare_file(test_filename, - &ctx.test_fd, &ctx.test_buf, max_file_size); - if (ret) - goto exit; - ret = prepare_file(good_filename, - &ctx.good_fd, &ctx.good_buf, max_file_size); - if (ret) { - if (close(ctx.test_fd) == -1) - perror("close test_buf failed"); - goto exit; - } - ctx.content = malloc(max_file_size); - if (!ctx.content) { - perror("malloc failed"); - goto close; - } - ctx.max_file_size = max_file_size; - for (i = 0; i < max_file_size; i++) - ctx.content[i] = random() % 256; + ret = prepare_file(test_filename, &ctx.test_fd, &ctx.test_buf, + max_file_size); + if (ret) + goto exit; + ret = prepare_file(good_filename, &ctx.good_fd, &ctx.good_buf, + max_file_size); + if (ret) { + if (close(ctx.test_fd) == -1) + perror("close test_buf failed"); + goto exit; + } + ctx.content = malloc(max_file_size); + if (!ctx.content) { + perror("malloc failed"); + goto close; + } + ctx.max_file_size = max_file_size; + for (i = 0; i < max_file_size; i++) + ctx.content[i] = random() % 256; - for (i = 0; i < num_ops; i++) { - ret = frag_ops[random() % LAST_OP](&ctx, - random() % max_file_size, /* offset */ - random() % max_file_size /* count */); - if (ret) - break; - } - close: - if (close(ctx.test_fd) == -1) - perror("close test_fd failed"); - if (close(ctx.good_fd) == -1) - perror("close good_fd failed"); - exit: - put_ctx(&ctx); - if (ret) - exit(1); - exit(0); + for (i = 0; i < num_ops; i++) { + ret = frag_ops[random() % LAST_OP]( + &ctx, random() % max_file_size, /* offset */ + random() % max_file_size /* count */); + if (ret) + break; + } +close: + if (close(ctx.test_fd) == -1) + perror("close test_fd failed"); + if (close(ctx.good_fd) == -1) + perror("close good_fd failed"); +exit: + put_ctx(&ctx); + if (ret) + exit(1); + exit(0); } /* diff --git a/tests/features/glfs-lease.c b/tests/features/glfs-lease.c index 535b3019a8c..f781f46c4ca 100644 --- a/tests/features/glfs-lease.c +++ b/tests/features/glfs-lease.c @@ -8,16 +8,20 @@ #include <sys/stat.h> /* Few rules: - * 1. A client may have multiple lease keys, but a lease key cannot be shared by multiple clients. - * 2. Lease key can be set before open, or in glfs_lease request. A lease key set like this is - * valid for the lifetime of the fd, i.e. a fd cannot have multiple lease key. But a lease key - * can be shared across multiple fds. + * 1. A client may have multiple lease keys, but a lease key cannot be shared by + * multiple clients. + * 2. Lease key can be set before open, or in glfs_lease request. A lease key + * set like this is valid for the lifetime of the fd, i.e. a fd cannot have + * multiple lease key. But a lease key can be shared across multiple fds. */ glfs_t *client1 = NULL, *client2 = NULL, *client3 = NULL, *client4 = NULL; glfs_fd_t *fd1 = NULL, *fd2 = NULL, *fd3 = NULL, *fd4 = NULL; FILE *log_file = NULL; -char lid1[GLFS_LEASE_ID_SIZE] = "lid1-clnt1", lid2[GLFS_LEASE_ID_SIZE] = "lid2-clnt2"; -char lid3[GLFS_LEASE_ID_SIZE] = "lid3-clnt2", lid4[GLFS_LEASE_ID_SIZE] = {0,}; +char lid1[GLFS_LEASE_ID_SIZE] = "lid1-clnt1", + lid2[GLFS_LEASE_ID_SIZE] = "lid2-clnt2"; +char lid3[GLFS_LEASE_ID_SIZE] = "lid3-clnt2", lid4[GLFS_LEASE_ID_SIZE] = { + 0, +}; char *volname = NULL, *glfs_log_file = NULL; #define MAX_CLIENTS 4 @@ -28,668 +32,686 @@ char *volname = NULL, *glfs_log_file = NULL; #define NONE 0 static void -recall_cbk (struct glfs_lease lease, void *data); +recall_cbk(struct glfs_lease lease, void *data); static int -set_read_lease (glfs_fd_t *fd, char ld[]) +set_read_lease(glfs_fd_t *fd, char ld[]) { - struct glfs_lease lease = {0, }; - int ret = 0; - - memset (&lease, 0, sizeof (lease)); - lease.cmd = GLFS_SET_LEASE; - lease.lease_type = GLFS_RD_LEASE; - memcpy(&lease.lease_id, ld, GLFS_LEASE_ID_SIZE); - ret = glfs_lease (fd, &lease, &recall_cbk, fd); - if (ret < 0) { - fprintf (log_file, "\n RD_LEASE failed with ret: %d (%s)", - ret, strerror (errno)); - return -1; - } - fprintf (log_file, "\n Took RD_LEASE"); - return ret; + struct glfs_lease lease = { + 0, + }; + int ret = 0; + + memset(&lease, 0, sizeof(lease)); + lease.cmd = GLFS_SET_LEASE; + lease.lease_type = GLFS_RD_LEASE; + memcpy(&lease.lease_id, ld, GLFS_LEASE_ID_SIZE); + ret = glfs_lease(fd, &lease, &recall_cbk, fd); + if (ret < 0) { + fprintf(log_file, "\n RD_LEASE failed with ret: %d (%s)", ret, + strerror(errno)); + return -1; + } + fprintf(log_file, "\n Took RD_LEASE"); + return ret; } static int -set_write_lease (glfs_fd_t *fd, char ld[]) +set_write_lease(glfs_fd_t *fd, char ld[]) { - struct glfs_lease lease = {0, }; - int ret = 0; - - memset (&lease, 0, sizeof (lease)); - lease.cmd = GLFS_SET_LEASE; - lease.lease_type = GLFS_RW_LEASE; - memcpy(&lease.lease_id, ld, GLFS_LEASE_ID_SIZE); - ret = glfs_lease (fd, &lease, &recall_cbk, NULL); - if (ret < 0) { - fprintf (log_file, "\n RW_LEASE failed with ret: %d (%s)", - ret, strerror (errno)); - return -1; - } - fprintf (log_file, "\n Took RW_LEASE"); - return ret; + struct glfs_lease lease = { + 0, + }; + int ret = 0; + + memset(&lease, 0, sizeof(lease)); + lease.cmd = GLFS_SET_LEASE; + lease.lease_type = GLFS_RW_LEASE; + memcpy(&lease.lease_id, ld, GLFS_LEASE_ID_SIZE); + ret = glfs_lease(fd, &lease, &recall_cbk, NULL); + if (ret < 0) { + fprintf(log_file, "\n RW_LEASE failed with ret: %d (%s)", ret, + strerror(errno)); + return -1; + } + fprintf(log_file, "\n Took RW_LEASE"); + return ret; } static int -get_lease (glfs_fd_t *fd, char ld[]) +get_lease(glfs_fd_t *fd, char ld[]) { - struct glfs_lease lease = {0, }; - int ret = 0; - - memset (&lease, 0, sizeof (lease)); - lease.cmd = GLFS_GET_LEASE; - lease.lease_type = -1; - memcpy(&lease.lease_id, ld, GLFS_LEASE_ID_SIZE); - ret = glfs_lease (fd, &lease, &recall_cbk, NULL); - if (ret < 0) { - fprintf (log_file, "\n GET_LEASE failed with ret: %d (%s)", - ret, strerror (errno)); - return -1; - } - if (lease.lease_type == GLFS_RD_LEASE) - fprintf (log_file, "\n Esisting Lease: RD_LEASE"); - else if (lease.lease_type == GLFS_RW_LEASE) - fprintf (log_file, "\n Esisting Lease: RW_LEASE"); - else if (lease.lease_type == 3) - fprintf (log_file, "\n Esisting Lease: RD_LEASE|RW_LEASE"); - else if (lease.lease_type == 0) - fprintf (log_file, "\n Esisting Lease: NONE"); - else - fprintf (log_file, "\n Existing lease type:%d", lease.lease_type); - return lease.lease_type; + struct glfs_lease lease = { + 0, + }; + int ret = 0; + + memset(&lease, 0, sizeof(lease)); + lease.cmd = GLFS_GET_LEASE; + lease.lease_type = -1; + memcpy(&lease.lease_id, ld, GLFS_LEASE_ID_SIZE); + ret = glfs_lease(fd, &lease, &recall_cbk, NULL); + if (ret < 0) { + fprintf(log_file, "\n GET_LEASE failed with ret: %d (%s)", ret, + strerror(errno)); + return -1; + } + if (lease.lease_type == GLFS_RD_LEASE) + fprintf(log_file, "\n Esisting Lease: RD_LEASE"); + else if (lease.lease_type == GLFS_RW_LEASE) + fprintf(log_file, "\n Esisting Lease: RW_LEASE"); + else if (lease.lease_type == 3) + fprintf(log_file, "\n Esisting Lease: RD_LEASE|RW_LEASE"); + else if (lease.lease_type == 0) + fprintf(log_file, "\n Esisting Lease: NONE"); + else + fprintf(log_file, "\n Existing lease type:%d", lease.lease_type); + return lease.lease_type; } static int -unlk_write_lease (glfs_fd_t *fd, char ld[]) +unlk_write_lease(glfs_fd_t *fd, char ld[]) { - struct glfs_lease lease = {0, }; - int ret = 0; - - memset (&lease, 0, sizeof (lease)); - lease.cmd = GLFS_UNLK_LEASE; - lease.lease_type = GLFS_RW_LEASE; - memcpy(&lease.lease_id, ld, GLFS_LEASE_ID_SIZE); - ret = glfs_lease (fd, &lease, &recall_cbk, NULL); - if (ret < 0) { - fprintf (log_file, "\n Unlock RW_LESAE failed with ret: %d (%s)", - ret, strerror (errno)); - return -1; - } - fprintf (log_file, "\n Unlocked RW_LEASE"); - return ret; + struct glfs_lease lease = { + 0, + }; + int ret = 0; + + memset(&lease, 0, sizeof(lease)); + lease.cmd = GLFS_UNLK_LEASE; + lease.lease_type = GLFS_RW_LEASE; + memcpy(&lease.lease_id, ld, GLFS_LEASE_ID_SIZE); + ret = glfs_lease(fd, &lease, &recall_cbk, NULL); + if (ret < 0) { + fprintf(log_file, "\n Unlock RW_LESAE failed with ret: %d (%s)", ret, + strerror(errno)); + return -1; + } + fprintf(log_file, "\n Unlocked RW_LEASE"); + return ret; } static int -unlk_read_lease (glfs_fd_t *fd, char ld[]) +unlk_read_lease(glfs_fd_t *fd, char ld[]) { - struct glfs_lease lease = {0, }; - int ret = 0; - - memset (&lease, 0, sizeof (lease)); - lease.cmd = GLFS_UNLK_LEASE; - lease.lease_type = GLFS_RD_LEASE; - memcpy(&lease.lease_id, ld, GLFS_LEASE_ID_SIZE); - - ret = glfs_lease (fd, &lease, &recall_cbk, NULL); - if (ret < 0) { - fprintf (log_file, "\n Unlock RD_LEASE failed with ret: %d (%s)", - ret, strerror (errno)); - return -1; - } - fprintf (log_file, "\n Unlocked RD_LEASE"); - return ret; + struct glfs_lease lease = { + 0, + }; + int ret = 0; + + memset(&lease, 0, sizeof(lease)); + lease.cmd = GLFS_UNLK_LEASE; + lease.lease_type = GLFS_RD_LEASE; + memcpy(&lease.lease_id, ld, GLFS_LEASE_ID_SIZE); + + ret = glfs_lease(fd, &lease, &recall_cbk, NULL); + if (ret < 0) { + fprintf(log_file, "\n Unlock RD_LEASE failed with ret: %d (%s)", ret, + strerror(errno)); + return -1; + } + fprintf(log_file, "\n Unlocked RD_LEASE"); + return ret; } glfs_t * setup_new_client(char *volname, char *log_fileile) { - int ret = 0; - glfs_t *fs = NULL; - - fs = glfs_new (volname); - if (!fs) { - fprintf (log_file, "\nglfs_new: returned NULL (%s)\n", - strerror (errno)); - goto error; - } - - ret = glfs_set_volfile_server (fs, "tcp", "localhost", 24007); - if (ret < 0) { - fprintf (log_file, "\nglfs_set_volfile_server failed ret:%d (%s)\n", - ret, strerror (errno)); - goto error; - } - - ret = glfs_set_logging (fs, log_fileile, 7); - if (ret < 0) { - fprintf (log_file, "\nglfs_set_logging failed with ret: %d (%s)\n", - ret, strerror (errno)); - goto error; - } - - ret = glfs_init (fs); - if (ret < 0) { - fprintf (log_file, "\nglfs_init failed with ret: %d (%s)\n", - ret, strerror (errno)); - goto error; - } - return fs; + int ret = 0; + glfs_t *fs = NULL; + + fs = glfs_new(volname); + if (!fs) { + fprintf(log_file, "\nglfs_new: returned NULL (%s)\n", strerror(errno)); + goto error; + } + + ret = glfs_set_volfile_server(fs, "tcp", "localhost", 24007); + if (ret < 0) { + fprintf(log_file, "\nglfs_set_volfile_server failed ret:%d (%s)\n", ret, + strerror(errno)); + goto error; + } + + ret = glfs_set_logging(fs, log_fileile, 7); + if (ret < 0) { + fprintf(log_file, "\nglfs_set_logging failed with ret: %d (%s)\n", ret, + strerror(errno)); + goto error; + } + + ret = glfs_init(fs); + if (ret < 0) { + fprintf(log_file, "\nglfs_init failed with ret: %d (%s)\n", ret, + strerror(errno)); + goto error; + } + return fs; error: - return NULL; + return NULL; } -#define OPEN(client, flags, fd, lease_id) \ -do { \ - int ret_val = 0; \ - ret_val = glfs_setfsleaseid (lease_id); \ - if (ret_val) { \ - fprintf (log_file, "\nglfs_setfsleaseid failed with ret: %d (%s)\n", \ - ret, strerror (errno)); \ - return -1; \ - } \ - fd = glfs_open (client, TEST_FILE, flags); \ - if (fd == NULL) { \ - fprintf (log_file, "\nglfs_open failed with ret: %d (%s)\n", \ - ret, strerror (errno)); \ - return -1; \ - } \ -} while (0) \ - -#define VERIFY_RESULT(test_case, ret, value) \ -do { \ - if (ret != value) { \ - fprintf (log_file, "\n Testcase %d failed, ret = %d, value=%d\n", test_case, ret, value); \ - goto error; /*test unsuccessful*/ \ - } \ - fprintf (log_file, "\n Testcase %d Succeeded\n", test_case); \ -} while (0) \ +#define OPEN(client, flags, fd, lease_id) \ + do { \ + int ret_val = 0; \ + ret_val = glfs_setfsleaseid(lease_id); \ + if (ret_val) { \ + fprintf(log_file, \ + "\nglfs_setfsleaseid failed with ret: %d (%s)\n", ret, \ + strerror(errno)); \ + return -1; \ + } \ + fd = glfs_open(client, TEST_FILE, flags); \ + if (fd == NULL) { \ + fprintf(log_file, "\nglfs_open failed with ret: %d (%s)\n", ret, \ + strerror(errno)); \ + return -1; \ + } \ + } while (0) + +#define VERIFY_RESULT(test_case, ret, value) \ + do { \ + if (ret != value) { \ + fprintf(log_file, \ + "\n Testcase %d failed, ret = %d, value=%d\n", \ + test_case, ret, value); \ + goto error; /*test unsuccessful*/ \ + } \ + fprintf(log_file, "\n Testcase %d Succeeded\n", test_case); \ + } while (0) static void -recall_cbk (struct glfs_lease lease, void *data) +recall_cbk(struct glfs_lease lease, void *data) { - int ret = -1; - char ld[GLFS_LEASE_ID_SIZE] = ""; + int ret = -1; + char ld[GLFS_LEASE_ID_SIZE] = ""; - fprintf (log_file, "\nRECALL received on lease_id:(%s)", lease.lease_id); - memcpy (ld, lease.lease_id, GLFS_LEASE_ID_SIZE); - ret = unlk_write_lease ((glfs_fd_t *)data, ld); - VERIFY_RESULT (500, ret, SHUD_PASS); + fprintf(log_file, "\nRECALL received on lease_id:(%s)", lease.lease_id); + memcpy(ld, lease.lease_id, GLFS_LEASE_ID_SIZE); + ret = unlk_write_lease((glfs_fd_t *)data, ld); + VERIFY_RESULT(500, ret, SHUD_PASS); error: - return; + return; } - static int -testcase1_rd_lease () +testcase1_rd_lease() { - glfs_fd_t *fd1 = NULL; - int ret = 0; + glfs_fd_t *fd1 = NULL; + int ret = 0; - fprintf (log_file, "\n Basic test case for Read lease:"); - /* Open fd on client 1 in RD mode */ - OPEN (client1, O_RDONLY, fd1, lid1); - ret = set_write_lease (fd1, lid1); - VERIFY_RESULT (1, ret, SHUD_FAIL); + fprintf(log_file, "\n Basic test case for Read lease:"); + /* Open fd on client 1 in RD mode */ + OPEN(client1, O_RDONLY, fd1, lid1); + ret = set_write_lease(fd1, lid1); + VERIFY_RESULT(1, ret, SHUD_FAIL); - ret = set_read_lease (fd1, lid1); - VERIFY_RESULT (2, ret, SHUD_PASS); + ret = set_read_lease(fd1, lid1); + VERIFY_RESULT(2, ret, SHUD_PASS); - ret = get_lease (fd1, lid1); - VERIFY_RESULT (3, ret, GLFS_RD_LEASE); + ret = get_lease(fd1, lid1); + VERIFY_RESULT(3, ret, GLFS_RD_LEASE); - ret = unlk_write_lease (fd1, lid1); - VERIFY_RESULT (4, ret, SHUD_FAIL); + ret = unlk_write_lease(fd1, lid1); + VERIFY_RESULT(4, ret, SHUD_FAIL); - ret = unlk_read_lease (fd1, lid1); - VERIFY_RESULT (5, ret, SHUD_PASS); + ret = unlk_read_lease(fd1, lid1); + VERIFY_RESULT(5, ret, SHUD_PASS); - ret = get_lease (fd1, lid1); - VERIFY_RESULT (6, ret, NONE); + ret = get_lease(fd1, lid1); + VERIFY_RESULT(6, ret, NONE); - ret = unlk_read_lease (fd1, lid1); - VERIFY_RESULT (7, ret, SHUD_FAIL); + ret = unlk_read_lease(fd1, lid1); + VERIFY_RESULT(7, ret, SHUD_FAIL); - ret = glfs_close (fd1); - VERIFY_RESULT (8, ret, SHUD_PASS); + ret = glfs_close(fd1); + VERIFY_RESULT(8, ret, SHUD_PASS); - return 0; + return 0; error: - return -1; + return -1; } static int -testcase2_wr_lease () +testcase2_wr_lease() { - glfs_fd_t *fd1 = NULL; - int ret = 0; + glfs_fd_t *fd1 = NULL; + int ret = 0; - fprintf (log_file, "\n Basic test case for Write lease:"); - /* Open fd on client 1 in WRonly mode */ - OPEN (client1, O_WRONLY, fd1, lid1); - ret = set_read_lease (fd1, lid1); - VERIFY_RESULT (1, ret, SHUD_FAIL); + fprintf(log_file, "\n Basic test case for Write lease:"); + /* Open fd on client 1 in WRonly mode */ + OPEN(client1, O_WRONLY, fd1, lid1); + ret = set_read_lease(fd1, lid1); + VERIFY_RESULT(1, ret, SHUD_FAIL); - ret = unlk_write_lease (fd1, lid1); - VERIFY_RESULT (2, ret, SHUD_FAIL); + ret = unlk_write_lease(fd1, lid1); + VERIFY_RESULT(2, ret, SHUD_FAIL); - ret = set_write_lease (fd1, lid1); - VERIFY_RESULT (3, ret, SHUD_PASS); + ret = set_write_lease(fd1, lid1); + VERIFY_RESULT(3, ret, SHUD_PASS); - ret = get_lease (fd1, lid1); - VERIFY_RESULT (4, ret, GLFS_RW_LEASE); + ret = get_lease(fd1, lid1); + VERIFY_RESULT(4, ret, GLFS_RW_LEASE); - ret = unlk_write_lease (fd1, lid1); - VERIFY_RESULT (5, ret, SHUD_PASS); + ret = unlk_write_lease(fd1, lid1); + VERIFY_RESULT(5, ret, SHUD_PASS); - ret = get_lease (fd1, lid1); - VERIFY_RESULT (6, ret, NONE); + ret = get_lease(fd1, lid1); + VERIFY_RESULT(6, ret, NONE); - ret = unlk_read_lease (fd1, lid1); - VERIFY_RESULT (7, ret, SHUD_FAIL); + ret = unlk_read_lease(fd1, lid1); + VERIFY_RESULT(7, ret, SHUD_FAIL); - ret = glfs_close (fd1); - VERIFY_RESULT (8, ret, SHUD_PASS); + ret = glfs_close(fd1); + VERIFY_RESULT(8, ret, SHUD_PASS); - return 0; + return 0; error: - return -1; + return -1; } static int -testcase3_rd_wr_lease () +testcase3_rd_wr_lease() { - glfs_fd_t *fd1 = NULL; - int ret = 0; + glfs_fd_t *fd1 = NULL; + int ret = 0; - fprintf (log_file, "\n Basic test case for Read Write lease:"); - /* Open fd on client 1 in WRonly mode */ - OPEN (client1, O_RDWR, fd1, lid1); - ret = set_read_lease (fd1, lid1); - VERIFY_RESULT (1, ret, SHUD_PASS); + fprintf(log_file, "\n Basic test case for Read Write lease:"); + /* Open fd on client 1 in WRonly mode */ + OPEN(client1, O_RDWR, fd1, lid1); + ret = set_read_lease(fd1, lid1); + VERIFY_RESULT(1, ret, SHUD_PASS); - ret = set_write_lease (fd1, lid1); - VERIFY_RESULT (2, ret, SHUD_PASS); + ret = set_write_lease(fd1, lid1); + VERIFY_RESULT(2, ret, SHUD_PASS); - ret = get_lease (fd1, lid1); - VERIFY_RESULT (3, ret, (GLFS_RW_LEASE | GLFS_RD_LEASE)); + ret = get_lease(fd1, lid1); + VERIFY_RESULT(3, ret, (GLFS_RW_LEASE | GLFS_RD_LEASE)); - ret = unlk_write_lease (fd1, lid1); - VERIFY_RESULT (4, ret, SHUD_PASS); + ret = unlk_write_lease(fd1, lid1); + VERIFY_RESULT(4, ret, SHUD_PASS); - ret = get_lease (fd1, lid1); - VERIFY_RESULT (5, ret, GLFS_RD_LEASE); + ret = get_lease(fd1, lid1); + VERIFY_RESULT(5, ret, GLFS_RD_LEASE); - ret = unlk_read_lease (fd1, lid1); - VERIFY_RESULT (6, ret, SHUD_PASS); + ret = unlk_read_lease(fd1, lid1); + VERIFY_RESULT(6, ret, SHUD_PASS); - ret = get_lease (fd1, lid1); - VERIFY_RESULT (7, ret, NONE); + ret = get_lease(fd1, lid1); + VERIFY_RESULT(7, ret, NONE); - ret = glfs_close (fd1); - VERIFY_RESULT (8, ret, SHUD_PASS); + ret = glfs_close(fd1); + VERIFY_RESULT(8, ret, SHUD_PASS); - return 0; + return 0; error: - return -1; + return -1; } static int -testcase4_rd_lease_multi_clnt () +testcase4_rd_lease_multi_clnt() { - glfs_fd_t *fd1 = NULL; - glfs_fd_t *fd2 = NULL; - int ret = 0; + glfs_fd_t *fd1 = NULL; + glfs_fd_t *fd2 = NULL; + int ret = 0; - fprintf (log_file, "\n Basic test case for multi client Read lease:"); + fprintf(log_file, "\n Basic test case for multi client Read lease:"); - /* Open fd on client 1 in RD mode */ - OPEN (client1, O_RDONLY, fd1, lid1); + /* Open fd on client 1 in RD mode */ + OPEN(client1, O_RDONLY, fd1, lid1); - /* Open fd on client 2 in RW mode */ - OPEN (client2, O_RDONLY, fd2, lid2); + /* Open fd on client 2 in RW mode */ + OPEN(client2, O_RDONLY, fd2, lid2); - ret = set_read_lease (fd1, lid1); - VERIFY_RESULT (1, ret, SHUD_PASS); + ret = set_read_lease(fd1, lid1); + VERIFY_RESULT(1, ret, SHUD_PASS); - ret = set_read_lease (fd2, lid2); - VERIFY_RESULT (2, ret, SHUD_PASS); + ret = set_read_lease(fd2, lid2); + VERIFY_RESULT(2, ret, SHUD_PASS); - ret = get_lease (fd1, lid1); - VERIFY_RESULT (3, ret, GLFS_RD_LEASE); + ret = get_lease(fd1, lid1); + VERIFY_RESULT(3, ret, GLFS_RD_LEASE); - ret = unlk_read_lease (fd1, lid1); - VERIFY_RESULT (4, ret, SHUD_PASS); + ret = unlk_read_lease(fd1, lid1); + VERIFY_RESULT(4, ret, SHUD_PASS); - ret = unlk_read_lease (fd2, lid2); - VERIFY_RESULT (5, ret, SHUD_PASS); + ret = unlk_read_lease(fd2, lid2); + VERIFY_RESULT(5, ret, SHUD_PASS); - ret = get_lease (fd1, lid1); - VERIFY_RESULT (6, ret, NONE); + ret = get_lease(fd1, lid1); + VERIFY_RESULT(6, ret, NONE); - ret = get_lease (fd2, lid2); - VERIFY_RESULT (7, ret, NONE); + ret = get_lease(fd2, lid2); + VERIFY_RESULT(7, ret, NONE); - ret = glfs_close (fd1); - VERIFY_RESULT (8, ret, SHUD_PASS); + ret = glfs_close(fd1); + VERIFY_RESULT(8, ret, SHUD_PASS); - ret = glfs_close (fd2); - VERIFY_RESULT (9, ret, SHUD_PASS); + ret = glfs_close(fd2); + VERIFY_RESULT(9, ret, SHUD_PASS); - return 0; + return 0; error: - return -1; + return -1; } static int -testcase5_openfd_multi_lid () +testcase5_openfd_multi_lid() { - glfs_fd_t *fd1 = NULL; - glfs_fd_t *fd2 = NULL; - glfs_fd_t *fd3 = NULL; - int ret = 0; + glfs_fd_t *fd1 = NULL; + glfs_fd_t *fd2 = NULL; + glfs_fd_t *fd3 = NULL; + int ret = 0; - fprintf (log_file, "\n Basic test case for multi lid openfd check:"); + fprintf(log_file, "\n Basic test case for multi lid openfd check:"); - /* Open fd on client 1 in RD mode */ - OPEN (client1, O_RDONLY, fd1, lid1); + /* Open fd on client 1 in RD mode */ + OPEN(client1, O_RDONLY, fd1, lid1); - /* Open fd on client 2 in RW mode */ - OPEN (client2, O_RDWR, fd2, lid2); - OPEN (client2, O_RDWR, fd3, lid2); + /* Open fd on client 2 in RW mode */ + OPEN(client2, O_RDWR, fd2, lid2); + OPEN(client2, O_RDWR, fd3, lid2); - ret = set_read_lease (fd1, lid1); - VERIFY_RESULT (1, ret, SHUD_FAIL); /*As there are other openfds in WR mode from diff lid*/ + ret = set_read_lease(fd1, lid1); + VERIFY_RESULT( + 1, ret, + SHUD_FAIL); /*As there are other openfds in WR mode from diff lid*/ - ret = set_write_lease (fd2, lid2); - VERIFY_RESULT (2, ret, SHUD_FAIL); /*As thers is another fd in RD mode from diff lid */ + ret = set_write_lease(fd2, lid2); + VERIFY_RESULT( + 2, ret, SHUD_FAIL); /*As thers is another fd in RD mode from diff lid */ - ret = glfs_close (fd1); - VERIFY_RESULT (3, ret, SHUD_PASS); + ret = glfs_close(fd1); + VERIFY_RESULT(3, ret, SHUD_PASS); - ret = set_write_lease (fd2, lid2); - VERIFY_RESULT (4, ret, SHUD_PASS); + ret = set_write_lease(fd2, lid2); + VERIFY_RESULT(4, ret, SHUD_PASS); - ret = unlk_write_lease (fd2, lid2); - VERIFY_RESULT (5, ret, SHUD_PASS); + ret = unlk_write_lease(fd2, lid2); + VERIFY_RESULT(5, ret, SHUD_PASS); - ret = glfs_close (fd2); - VERIFY_RESULT (6, ret, SHUD_PASS); + ret = glfs_close(fd2); + VERIFY_RESULT(6, ret, SHUD_PASS); - ret = glfs_close (fd3); - VERIFY_RESULT (7, ret, SHUD_PASS); + ret = glfs_close(fd3); + VERIFY_RESULT(7, ret, SHUD_PASS); - return 0; + return 0; error: - return -1; + return -1; } static int -testcase6_openfd_same_lid () +testcase6_openfd_same_lid() { - glfs_fd_t *fd1 = NULL; - glfs_fd_t *fd2 = NULL; - glfs_fd_t *fd3 = NULL; - int ret = 0; + glfs_fd_t *fd1 = NULL; + glfs_fd_t *fd2 = NULL; + glfs_fd_t *fd3 = NULL; + int ret = 0; - fprintf (log_file, "\n Basic test case for same lid openfd check:"); + fprintf(log_file, "\n Basic test case for same lid openfd check:"); - /* Open fd on client 2 in RW mode */ - OPEN (client1, O_RDWR, fd1, lid2); - OPEN (client1, O_RDWR, fd2, lid2); + /* Open fd on client 2 in RW mode */ + OPEN(client1, O_RDWR, fd1, lid2); + OPEN(client1, O_RDWR, fd2, lid2); - ret = set_write_lease (fd1, lid2); - VERIFY_RESULT (4, ret, SHUD_PASS); + ret = set_write_lease(fd1, lid2); + VERIFY_RESULT(4, ret, SHUD_PASS); - ret = set_write_lease (fd2, lid2); - VERIFY_RESULT (4, ret, SHUD_PASS); + ret = set_write_lease(fd2, lid2); + VERIFY_RESULT(4, ret, SHUD_PASS); - ret = set_read_lease (fd2, lid2); - VERIFY_RESULT (4, ret, SHUD_PASS); + ret = set_read_lease(fd2, lid2); + VERIFY_RESULT(4, ret, SHUD_PASS); - ret = unlk_write_lease (fd1, lid2); - VERIFY_RESULT (5, ret, SHUD_PASS); + ret = unlk_write_lease(fd1, lid2); + VERIFY_RESULT(5, ret, SHUD_PASS); - ret = unlk_read_lease (fd2, lid2); - VERIFY_RESULT (5, ret, SHUD_PASS); + ret = unlk_read_lease(fd2, lid2); + VERIFY_RESULT(5, ret, SHUD_PASS); - ret = unlk_write_lease (fd2, lid2); - VERIFY_RESULT (5, ret, SHUD_PASS); + ret = unlk_write_lease(fd2, lid2); + VERIFY_RESULT(5, ret, SHUD_PASS); - ret = glfs_close (fd1); - VERIFY_RESULT (6, ret, SHUD_PASS); + ret = glfs_close(fd1); + VERIFY_RESULT(6, ret, SHUD_PASS); - ret = glfs_close (fd2); - VERIFY_RESULT (7, ret, SHUD_PASS); + ret = glfs_close(fd2); + VERIFY_RESULT(7, ret, SHUD_PASS); - return 0; + return 0; error: - return -1; + return -1; } static int -testcase7_rd_multi_lid () +testcase7_rd_multi_lid() { - glfs_fd_t *fd1 = NULL; - glfs_fd_t *fd2 = NULL; - int ret = 0; + glfs_fd_t *fd1 = NULL; + glfs_fd_t *fd2 = NULL; + int ret = 0; - fprintf (log_file, "\n Basic test case for multi lease id Read lease:"); + fprintf(log_file, "\n Basic test case for multi lease id Read lease:"); - /* Open fd on client 1 in RD mode */ - OPEN (client2, O_RDONLY, fd1, lid2); + /* Open fd on client 1 in RD mode */ + OPEN(client2, O_RDONLY, fd1, lid2); - /* Open fd on client 2 in RD mode */ - OPEN (client2, O_RDONLY, fd2, lid3); + /* Open fd on client 2 in RD mode */ + OPEN(client2, O_RDONLY, fd2, lid3); - ret = set_read_lease (fd1, lid2); - VERIFY_RESULT (1, ret, SHUD_PASS); + ret = set_read_lease(fd1, lid2); + VERIFY_RESULT(1, ret, SHUD_PASS); - ret = set_read_lease (fd2, lid3); - VERIFY_RESULT (2, ret, SHUD_PASS); + ret = set_read_lease(fd2, lid3); + VERIFY_RESULT(2, ret, SHUD_PASS); - ret = get_lease (fd1, lid2); - VERIFY_RESULT (3, ret, GLFS_RD_LEASE); + ret = get_lease(fd1, lid2); + VERIFY_RESULT(3, ret, GLFS_RD_LEASE); - ret = unlk_read_lease (fd1, lid2); - VERIFY_RESULT (4, ret, SHUD_PASS); + ret = unlk_read_lease(fd1, lid2); + VERIFY_RESULT(4, ret, SHUD_PASS); - ret = unlk_read_lease (fd2, lid3); - VERIFY_RESULT (5, ret, SHUD_PASS); + ret = unlk_read_lease(fd2, lid3); + VERIFY_RESULT(5, ret, SHUD_PASS); - ret = get_lease (fd1, lid2); - VERIFY_RESULT (6, ret, NONE); + ret = get_lease(fd1, lid2); + VERIFY_RESULT(6, ret, NONE); - ret = get_lease (fd2, lid3); - VERIFY_RESULT (7, ret, NONE); + ret = get_lease(fd2, lid3); + VERIFY_RESULT(7, ret, NONE); - ret = glfs_close (fd1); - VERIFY_RESULT (8, ret, SHUD_PASS); + ret = glfs_close(fd1); + VERIFY_RESULT(8, ret, SHUD_PASS); - ret = glfs_close (fd2); - VERIFY_RESULT (9, ret, SHUD_PASS); + ret = glfs_close(fd2); + VERIFY_RESULT(9, ret, SHUD_PASS); - return 0; + return 0; error: - return -1; + return -1; } static int -testcase8_client_disconnect () +testcase8_client_disconnect() { - glfs_fd_t *fd1 = NULL; - glfs_fd_t *fd2 = NULL; - int ret = 0; + glfs_fd_t *fd1 = NULL; + glfs_fd_t *fd2 = NULL; + int ret = 0; - fprintf (log_file, "\n Basic test case for client disconnect cleanup"); + fprintf(log_file, "\n Basic test case for client disconnect cleanup"); - /* Open fd on client 1 in RD mode */ - OPEN (client1, O_RDWR, fd1, lid1); + /* Open fd on client 1 in RD mode */ + OPEN(client1, O_RDWR, fd1, lid1); - ret = set_read_lease (fd1, lid1); - VERIFY_RESULT (1, ret, SHUD_PASS); + ret = set_read_lease(fd1, lid1); + VERIFY_RESULT(1, ret, SHUD_PASS); - ret = get_lease (fd1, lid1); - VERIFY_RESULT (2, ret, GLFS_RD_LEASE); + ret = get_lease(fd1, lid1); + VERIFY_RESULT(2, ret, GLFS_RD_LEASE); - ret = set_write_lease (fd1, lid1); - VERIFY_RESULT (3, ret, SHUD_PASS); + ret = set_write_lease(fd1, lid1); + VERIFY_RESULT(3, ret, SHUD_PASS); - ret = get_lease (fd1, lid1); - VERIFY_RESULT (4, ret, (GLFS_RD_LEASE | GLFS_RW_LEASE)); + ret = get_lease(fd1, lid1); + VERIFY_RESULT(4, ret, (GLFS_RD_LEASE | GLFS_RW_LEASE)); - ret = glfs_fini (client1); - VERIFY_RESULT (5, ret, SHUD_PASS); + ret = glfs_fini(client1); + VERIFY_RESULT(5, ret, SHUD_PASS); - /* Open fd on client 2 in RD mode */ - OPEN (client2, O_RDONLY, fd2, lid3); + /* Open fd on client 2 in RD mode */ + OPEN(client2, O_RDONLY, fd2, lid3); - ret = get_lease (fd2, lid3); - VERIFY_RESULT (6, ret, NONE); + ret = get_lease(fd2, lid3); + VERIFY_RESULT(6, ret, NONE); - ret = glfs_close (fd2); - VERIFY_RESULT (7, ret, SHUD_PASS); + ret = glfs_close(fd2); + VERIFY_RESULT(7, ret, SHUD_PASS); - client1 = setup_new_client (volname, glfs_log_file); + client1 = setup_new_client(volname, glfs_log_file); - return 0; + return 0; error: - return -1; + return -1; } static int -testcase9_recall_conflict_lease () +testcase9_recall_conflict_lease() { - struct glfs_object *obj = NULL; - glfs_fd_t *fd1 = NULL; - int ret = 0; - struct glfs_lease lease = {0, }; - - fprintf (log_file, "\n Basic test case for conflicting lease causing recall"); - - memset (&lease, 0, sizeof (lease)); - lease.cmd = GLFS_SET_LEASE; - lease.lease_type = GLFS_RD_LEASE; - memcpy(&lease.lease_id, lid2, GLFS_LEASE_ID_SIZE); - /* Open fd on client 1 in RD mode */ - OPEN (client1, O_RDWR, fd1, lid1); - ret = set_write_lease (fd1, lid1); - VERIFY_RESULT (1, ret, SHUD_PASS); - - obj = glfs_h_lookupat (client2, NULL, TEST_FILE, NULL, 0); - ret = glfs_h_lease (client2, obj, &lease); - VERIFY_RESULT (2, ret, SHUD_FAIL); - - ret = unlk_write_lease (fd1, lid1); - VERIFY_RESULT (5, ret, SHUD_PASS); - - sleep (3); - ret = glfs_h_close (obj); - VERIFY_RESULT (3, ret, SHUD_PASS); - ret = glfs_close (fd1); - VERIFY_RESULT (4, ret, SHUD_PASS); - - return 0; + struct glfs_object *obj = NULL; + glfs_fd_t *fd1 = NULL; + int ret = 0; + struct glfs_lease lease = { + 0, + }; + + fprintf(log_file, + "\n Basic test case for conflicting lease causing recall"); + + memset(&lease, 0, sizeof(lease)); + lease.cmd = GLFS_SET_LEASE; + lease.lease_type = GLFS_RD_LEASE; + memcpy(&lease.lease_id, lid2, GLFS_LEASE_ID_SIZE); + /* Open fd on client 1 in RD mode */ + OPEN(client1, O_RDWR, fd1, lid1); + ret = set_write_lease(fd1, lid1); + VERIFY_RESULT(1, ret, SHUD_PASS); + + obj = glfs_h_lookupat(client2, NULL, TEST_FILE, NULL, 0); + ret = glfs_h_lease(client2, obj, &lease); + VERIFY_RESULT(2, ret, SHUD_FAIL); + + ret = unlk_write_lease(fd1, lid1); + VERIFY_RESULT(5, ret, SHUD_PASS); + + sleep(3); + ret = glfs_h_close(obj); + VERIFY_RESULT(3, ret, SHUD_PASS); + ret = glfs_close(fd1); + VERIFY_RESULT(4, ret, SHUD_PASS); + + return 0; error: - return -1; + return -1; } static int -testcase10_recall_open_conflict () +testcase10_recall_open_conflict() { - glfs_fd_t *fd1 = NULL; - glfs_fd_t *fd2 = NULL; - int ret = 0; + glfs_fd_t *fd1 = NULL; + glfs_fd_t *fd2 = NULL; + int ret = 0; - fprintf (log_file, "\n Basic test case for conflicting open causing recall"); + fprintf(log_file, "\n Basic test case for conflicting open causing recall"); - /* Open fd on client 1 in RW mode */ - OPEN (client1, O_RDWR, fd1, lid1); + /* Open fd on client 1 in RW mode */ + OPEN(client1, O_RDWR, fd1, lid1); - ret = set_write_lease (fd1, lid1); - VERIFY_RESULT (1, ret, SHUD_PASS); + ret = set_write_lease(fd1, lid1); + VERIFY_RESULT(1, ret, SHUD_PASS); - /* Open fd on client 1 in RW mode */ - OPEN (client2, O_RDWR, fd2, lid2); + /* Open fd on client 1 in RW mode */ + OPEN(client2, O_RDWR, fd2, lid2); - /* TODO: Check for recall cbk functionality */ - ret = glfs_close (fd1); - VERIFY_RESULT (2, ret, SHUD_PASS); + /* TODO: Check for recall cbk functionality */ + ret = glfs_close(fd1); + VERIFY_RESULT(2, ret, SHUD_PASS); - ret = glfs_close (fd2); - VERIFY_RESULT (3, ret, SHUD_PASS); + ret = glfs_close(fd2); + VERIFY_RESULT(3, ret, SHUD_PASS); - return 0; + return 0; error: - return -1; + return -1; } int -main (int argc, char *argv[]) +main(int argc, char *argv[]) { - int ret = 0; - int i = 0; - glfs_fd_t *fd = NULL; - glfs_fd_t *fd1 = NULL; - char *topdir = "topdir", *filename = "file1"; - char *buf = NULL; - int x = 0; - ssize_t xattr_size = -1; - - if (argc != 4) { - fprintf (stderr, - "Expect following args %s <Vol> <glfs client log file> <testcase log file>\n" - , argv[0]); - return -1; - } + int ret = 0; + int i = 0; + glfs_fd_t *fd = NULL; + glfs_fd_t *fd1 = NULL; + char *topdir = "topdir", *filename = "file1"; + char *buf = NULL; + int x = 0; + ssize_t xattr_size = -1; + + if (argc != 4) { + fprintf(stderr, + "Expect following args %s <Vol> <glfs client log file> " + "<testcase log file>\n", + argv[0]); + return -1; + } - log_file = fopen (argv[3], "w"); - if (!log_file) - goto error; + log_file = fopen(argv[3], "w"); + if (!log_file) + goto error; - volname = argv[1]; - glfs_log_file = argv[2]; + volname = argv[1]; + glfs_log_file = argv[2]; - /* Setup 3 clients */ - client1 = setup_new_client (volname, glfs_log_file); - client2 = setup_new_client (volname, glfs_log_file); - client3 = setup_new_client (volname, glfs_log_file); + /* Setup 3 clients */ + client1 = setup_new_client(volname, glfs_log_file); + client2 = setup_new_client(volname, glfs_log_file); + client3 = setup_new_client(volname, glfs_log_file); - ret = testcase1_rd_lease (); - VERIFY_RESULT (101, ret, SHUD_PASS); + ret = testcase1_rd_lease(); + VERIFY_RESULT(101, ret, SHUD_PASS); - ret = testcase2_wr_lease (); - VERIFY_RESULT (102, ret, SHUD_PASS); + ret = testcase2_wr_lease(); + VERIFY_RESULT(102, ret, SHUD_PASS); - ret = testcase3_rd_wr_lease (); - VERIFY_RESULT (103, ret, SHUD_PASS); + ret = testcase3_rd_wr_lease(); + VERIFY_RESULT(103, ret, SHUD_PASS); - ret = testcase4_rd_lease_multi_clnt (); - VERIFY_RESULT (104, ret, SHUD_PASS); + ret = testcase4_rd_lease_multi_clnt(); + VERIFY_RESULT(104, ret, SHUD_PASS); - ret = testcase5_openfd_multi_lid (); - VERIFY_RESULT (105, ret, SHUD_PASS); + ret = testcase5_openfd_multi_lid(); + VERIFY_RESULT(105, ret, SHUD_PASS); - ret = testcase6_openfd_same_lid (); - VERIFY_RESULT (106, ret, SHUD_PASS); + ret = testcase6_openfd_same_lid(); + VERIFY_RESULT(106, ret, SHUD_PASS); - ret = testcase7_rd_multi_lid (); - VERIFY_RESULT (107, ret, SHUD_PASS); + ret = testcase7_rd_multi_lid(); + VERIFY_RESULT(107, ret, SHUD_PASS); - ret = testcase8_client_disconnect (); - VERIFY_RESULT (108, ret, SHUD_PASS); + ret = testcase8_client_disconnect(); + VERIFY_RESULT(108, ret, SHUD_PASS); - ret = testcase9_recall_conflict_lease (); - VERIFY_RESULT (109, ret, SHUD_PASS); + ret = testcase9_recall_conflict_lease(); + VERIFY_RESULT(109, ret, SHUD_PASS); - ret = testcase10_recall_open_conflict (); - VERIFY_RESULT (110, ret, SHUD_PASS); + ret = testcase10_recall_open_conflict(); + VERIFY_RESULT(110, ret, SHUD_PASS); - glfs_fini (client1); - glfs_fini (client2); - glfs_fini (client3); + glfs_fini(client1); + glfs_fini(client2); + glfs_fini(client3); - fclose (log_file); - return 0; + fclose(log_file); + return 0; error: - return -1; + return -1; } diff --git a/tests/features/mandatory-lock-forced.c b/tests/features/mandatory-lock-forced.c index f37206845f1..4028d6c6eaf 100644 --- a/tests/features/mandatory-lock-forced.c +++ b/tests/features/mandatory-lock-forced.c @@ -6,133 +6,138 @@ #include <string.h> #include <sys/wait.h> -#define LOG_ERR(func, err) do { \ - fprintf (stderr, "%s : returned error (%s)\n", func, strerror(err)); \ - exit (err); \ -} while (0) - -int fd; -struct flock lock; -char *buf = "ten bytes!"; -char *fname = "/mnt/glusterfs/0/mand.lock"; -int open_flags, child, err, status, blocked = 0; - -int do_child (char *argv[]) { - /* Initialize file open flags */ - if (strcmp (argv[2], "BLOCK") == 0) - open_flags = O_RDWR; - else if (strcmp (argv[2], "TRUNC") == 0) - open_flags = O_RDWR | O_TRUNC | O_NONBLOCK; - else if (strcmp (argv[2], "NONE") == 0) - open_flags = O_RDWR | O_NONBLOCK; - else - LOG_ERR ("Invalid option:", EINVAL); - - /* Open the file */ - fd = open (fname, open_flags); - if (fd == -1) - LOG_ERR ("Child open", errno); - - /* Perform the file operation*/ - if (strcmp (argv[3], "READ") == 0) { - buf = NULL; - err = read (fd, buf, 10); - if (err == -1) - LOG_ERR ("Child read", errno); - } else if (strcmp (argv[3], "WRITE") == 0) { - err = write (fd, buf, 10); - if (err == -1) - LOG_ERR ("Child write", errno); - } else if (strcmp (argv[3], "FTRUNCATE") == 0) { - err = ftruncate (fd, 5); - if (err) - LOG_ERR ("Child ftruncate", errno); - } else - LOG_ERR ("Invalid operation:", EINVAL); - - /* Close child fd */ - err = close (fd); +#define LOG_ERR(func, err) \ + do { \ + fprintf(stderr, "%s : returned error (%s)\n", func, strerror(err)); \ + exit(err); \ + } while (0) + +int fd; +struct flock lock; +char *buf = "ten bytes!"; +char *fname = "/mnt/glusterfs/0/mand.lock"; +int open_flags, child, err, status, blocked = 0; + +int +do_child(char *argv[]) +{ + /* Initialize file open flags */ + if (strcmp(argv[2], "BLOCK") == 0) + open_flags = O_RDWR; + else if (strcmp(argv[2], "TRUNC") == 0) + open_flags = O_RDWR | O_TRUNC | O_NONBLOCK; + else if (strcmp(argv[2], "NONE") == 0) + open_flags = O_RDWR | O_NONBLOCK; + else + LOG_ERR("Invalid option:", EINVAL); + + /* Open the file */ + fd = open(fname, open_flags); + if (fd == -1) + LOG_ERR("Child open", errno); + + /* Perform the file operation*/ + if (strcmp(argv[3], "READ") == 0) { + buf = NULL; + err = read(fd, buf, 10); + if (err == -1) + LOG_ERR("Child read", errno); + } else if (strcmp(argv[3], "WRITE") == 0) { + err = write(fd, buf, 10); + if (err == -1) + LOG_ERR("Child write", errno); + } else if (strcmp(argv[3], "FTRUNCATE") == 0) { + err = ftruncate(fd, 5); if (err) - LOG_ERR ("Child close", errno); + LOG_ERR("Child ftruncate", errno); + } else + LOG_ERR("Invalid operation:", EINVAL); - /* Exit success */ - exit (0); + /* Close child fd */ + err = close(fd); + if (err) + LOG_ERR("Child close", errno); + + /* Exit success */ + exit(0); } -int main (int argc, char *argv[]) { - if (argc < 4) { - fprintf (stderr, "Wrong usage: Use as ./mandatory-lock " - "<RD_LCK/WR_LCK> <BLOCK/TRUNC/NONE> " - "<READ/WRITE/FTRUNCATE\n"); - exit(EINVAL); +int +main(int argc, char *argv[]) +{ + if (argc < 4) { + fprintf(stderr, + "Wrong usage: Use as ./mandatory-lock " + "<RD_LCK/WR_LCK> <BLOCK/TRUNC/NONE> " + "<READ/WRITE/FTRUNCATE\n"); + exit(EINVAL); + } + /* Create an empty lock file */ + fd = open(fname, O_CREAT | O_RDWR, 0755); + if (fd == -1) + LOG_ERR("Parent create", errno); + + /* Determine the type of lock */ + if (strcmp(argv[1], "RD_LCK") == 0) + lock.l_type = F_RDLCK; + else if (strcmp(argv[1], "WR_LCK") == 0) + lock.l_type = F_WRLCK; + else + LOG_ERR("Parent lock type", EINVAL); + + lock.l_whence = SEEK_SET; + lock.l_start = 0L; + lock.l_len = 0L; + + /* Let parent acquire the initial lock */ + err = fcntl(fd, F_SETLK, &lock); + if (err) + LOG_ERR("Parent lock", errno); + + /* Now fork a child */ + child = fork(); + if (child == 0) + /* Perform the child operations */ + do_child(argv); + else { + /* If blocking mode, then sleep for 2 seconds + * and wait for the child */ + if (strcmp(argv[2], "NONE") != 0) { + sleep(2); + if (waitpid(child, &status, WNOHANG) == 0) + blocked = 1; + /* Release the parent lock so that the + * child can terminate */ + lock.l_type = F_UNLCK; + err = fcntl(fd, F_SETLK, &lock); + if (err) + LOG_ERR("Parent unlock", errno); } - /* Create an empty lock file */ - fd = open (fname, O_CREAT | O_RDWR, 0755); - if (fd == -1) - LOG_ERR ("Parent create", errno); - - /* Determine the type of lock */ - if (strcmp (argv[1], "RD_LCK") == 0) - lock.l_type = F_RDLCK; - else if (strcmp (argv[1], "WR_LCK") == 0) - lock.l_type = F_WRLCK; - else - LOG_ERR ("Parent lock type", EINVAL); - - lock.l_whence = SEEK_SET; - lock.l_start = 0L; - lock.l_len = 0L; - - /* Let parent acquire the initial lock */ - err = fcntl (fd, F_SETLK, &lock); + + /* Wait for child to finish */ + waitpid(child, &status, 0); + + /* Close the parent fd */ + err = close(fd); if (err) - LOG_ERR ("Parent lock", errno); - - /* Now fork a child */ - child = fork (); - if (child == 0) - /* Perform the child operations */ - do_child (argv); - else { - /* If blocking mode, then sleep for 2 seconds - * and wait for the child */ - if (strcmp (argv[2], "NONE") != 0) { - sleep (2); - if (waitpid (child, &status, WNOHANG) == 0) - blocked = 1; - /* Release the parent lock so that the - * child can terminate */ - lock.l_type = F_UNLCK; - err = fcntl (fd, F_SETLK, &lock); - if (err) - LOG_ERR ("Parent unlock", errno); - } - - /* Wait for child to finish */ - waitpid (child, &status, 0); - - /* Close the parent fd */ - err = close (fd); - if (err) - LOG_ERR ("Parent close", errno); - - /* Remove the lock file*/ - err = unlink (fname); - if (err) - LOG_ERR ("Parent unlink", errno); - - /* If not blocked, exit with child exit status*/ - errno = WEXITSTATUS(status); - - /* If blocked, exit with corresponding - * error code */ - if (blocked) - errno = EWOULDBLOCK; - - if (errno != 0) - printf ("%s\n", strerror(errno)); - - exit (errno); + LOG_ERR("Parent close", errno); - } + /* Remove the lock file*/ + err = unlink(fname); + if (err) + LOG_ERR("Parent unlink", errno); + + /* If not blocked, exit with child exit status*/ + errno = WEXITSTATUS(status); + + /* If blocked, exit with corresponding + * error code */ + if (blocked) + errno = EWOULDBLOCK; + + if (errno != 0) + printf("%s\n", strerror(errno)); + + exit(errno); + } } diff --git a/tests/utils/arequal-checksum.c b/tests/utils/arequal-checksum.c index 6ab68f38db8..b51a054162b 100644 --- a/tests/utils/arequal-checksum.c +++ b/tests/utils/arequal-checksum.c @@ -41,605 +41,593 @@ int debug = 0; typedef struct { - char test_directory[4096]; - char **ignored_directory; - unsigned int directories_ignored; + char test_directory[4096]; + char **ignored_directory; + unsigned int directories_ignored; } arequal_config_t; static arequal_config_t arequal_config; static error_t -arequal_parse_opts (int key, char *arg, struct argp_state *_state); +arequal_parse_opts(int key, char *arg, struct argp_state *_state); static struct argp_option arequal_options[] = { - { "ignore", 'i', "IGNORED", 0, - "entry in the given path to be ignored"}, - { "path", 'p', "PATH", 0, "path where arequal has to be run"}, - {0, 0, 0, 0, 0} -}; - -#define DBG(fmt ...) do { \ - if (debug) { \ - fprintf (stderr, "D "); \ - fprintf (stderr, fmt); \ - } \ - } while (0) + {"ignore", 'i', "IGNORED", 0, "entry in the given path to be ignored"}, + {"path", 'p', "PATH", 0, "path where arequal has to be run"}, + {0, 0, 0, 0, 0}}; + +#define DBG(fmt...) \ + do { \ + if (debug) { \ + fprintf(stderr, "D "); \ + fprintf(stderr, fmt); \ + } \ + } while (0) void -add_to_list (char *arg); +add_to_list(char *arg); void -get_absolute_path (char directory[], char *arg); +get_absolute_path(char directory[], char *arg); -static int roof(int a, int b) +static int +roof(int a, int b) { - return ((((a)+(b)-1)/((b)?(b):1))*(b)); + return ((((a) + (b)-1) / ((b) ? (b) : 1)) * (b)); } void -add_to_list (char *arg) +add_to_list(char *arg) { - char *string = NULL; - int index = 0; + char *string = NULL; + int index = 0; - index = arequal_config.directories_ignored - 1; - string = strdup (arg); + index = arequal_config.directories_ignored - 1; + string = strdup(arg); - if (!arequal_config.ignored_directory) { - arequal_config.ignored_directory = calloc (1, sizeof (char *)); - } else - arequal_config.ignored_directory = - realloc (arequal_config.ignored_directory, - sizeof (char *) * (index+1)); + if (!arequal_config.ignored_directory) { + arequal_config.ignored_directory = calloc(1, sizeof(char *)); + } else + arequal_config.ignored_directory = realloc( + arequal_config.ignored_directory, sizeof(char *) * (index + 1)); - arequal_config.ignored_directory[index] = string; + arequal_config.ignored_directory[index] = string; } static error_t -arequal_parse_opts (int key, char *arg, struct argp_state *_state) +arequal_parse_opts(int key, char *arg, struct argp_state *_state) { - switch (key) { - case 'i': - { - arequal_config.directories_ignored++; - add_to_list (arg); - } - break; - case 'p': - { - if (arg[0] == '/') - strcpy (arequal_config.test_directory, arg); - else - get_absolute_path (arequal_config.test_directory, arg); - - if (arequal_config.test_directory - [strlen(arequal_config.test_directory) - 1] == '/') - arequal_config.test_directory - [strlen(arequal_config.test_directory) - 1] = '\0'; - } - break; + switch (key) { + case 'i': { + arequal_config.directories_ignored++; + add_to_list(arg); + } break; + case 'p': { + if (arg[0] == '/') + strcpy(arequal_config.test_directory, arg); + else + get_absolute_path(arequal_config.test_directory, arg); + + if (arequal_config + .test_directory[strlen(arequal_config.test_directory) - + 1] == '/') + arequal_config + .test_directory[strlen(arequal_config.test_directory) - 1] = + '\0'; + } break; case ARGP_KEY_NO_ARGS: - break; + break; case ARGP_KEY_ARG: - break; + break; case ARGP_KEY_END: - if (_state->argc == 1) { - argp_usage (_state); - } + if (_state->argc == 1) { + argp_usage(_state); + } + } - } - - return 0; + return 0; } void -get_absolute_path (char directory[], char *arg) +get_absolute_path(char directory[], char *arg) { - char cwd[4096] = {0,}; - - if (getcwd (cwd, sizeof (cwd)) == NULL) - printf ("some error in getting cwd\n"); - - if (strcmp (arg, ".") != 0) { - if (cwd[strlen(cwd)] != '/') - cwd[strlen (cwd)] = '/'; - strcat (cwd, arg); - } - strcpy (directory, cwd); + char cwd[4096] = { + 0, + }; + + if (getcwd(cwd, sizeof(cwd)) == NULL) + printf("some error in getting cwd\n"); + + if (strcmp(arg, ".") != 0) { + if (cwd[strlen(cwd)] != '/') + cwd[strlen(cwd)] = '/'; + strcat(cwd, arg); + } + strcpy(directory, cwd); } static struct argp argp = { - arequal_options, - arequal_parse_opts, - "", - "arequal - Tool which calculates the checksum of all the entries" - "present in a given directory" -}; + arequal_options, arequal_parse_opts, "", + "arequal - Tool which calculates the checksum of all the entries" + "present in a given directory"}; /* All this runs in single thread, hence using 'global' variables */ -unsigned long long avg_uid_file = 0; -unsigned long long avg_uid_dir = 0; -unsigned long long avg_uid_symlink = 0; -unsigned long long avg_uid_other = 0; +unsigned long long avg_uid_file = 0; +unsigned long long avg_uid_dir = 0; +unsigned long long avg_uid_symlink = 0; +unsigned long long avg_uid_other = 0; -unsigned long long avg_gid_file = 0; -unsigned long long avg_gid_dir = 0; -unsigned long long avg_gid_symlink = 0; -unsigned long long avg_gid_other = 0; +unsigned long long avg_gid_file = 0; +unsigned long long avg_gid_dir = 0; +unsigned long long avg_gid_symlink = 0; +unsigned long long avg_gid_other = 0; -unsigned long long avg_mode_file = 0; -unsigned long long avg_mode_dir = 0; -unsigned long long avg_mode_symlink = 0; -unsigned long long avg_mode_other = 0; +unsigned long long avg_mode_file = 0; +unsigned long long avg_mode_dir = 0; +unsigned long long avg_mode_symlink = 0; +unsigned long long avg_mode_other = 0; unsigned long long global_ctime_checksum = 0; +unsigned long long count_dir = 0; +unsigned long long count_file = 0; +unsigned long long count_symlink = 0; +unsigned long long count_other = 0; -unsigned long long count_dir = 0; -unsigned long long count_file = 0; -unsigned long long count_symlink = 0; -unsigned long long count_other = 0; +unsigned long long checksum_file1 = 0; +unsigned long long checksum_file2 = 0; +unsigned long long checksum_dir = 0; +unsigned long long checksum_symlink = 0; +unsigned long long checksum_other = 0; +unsigned long long +checksum_path(const char *path) +{ + unsigned long long csum = 0; + unsigned long long *nums = 0; + int len = 0; + int cnt = 0; -unsigned long long checksum_file1 = 0; -unsigned long long checksum_file2 = 0; -unsigned long long checksum_dir = 0; -unsigned long long checksum_symlink = 0; -unsigned long long checksum_other = 0; + len = roof(strlen(path), sizeof(csum)); + cnt = len / sizeof(csum); + nums = __builtin_alloca(len); + memset(nums, 0, len); + strcpy((char *)nums, path); -unsigned long long -checksum_path (const char *path) -{ - unsigned long long csum = 0; - unsigned long long *nums = 0; - int len = 0; - int cnt = 0; - - len = roof (strlen (path), sizeof (csum)); - cnt = len / sizeof (csum); - - nums = __builtin_alloca (len); - memset (nums, 0, len); - strcpy ((char *)nums, path); - - while (cnt) { - csum ^= *nums; - nums++; - cnt--; - } + while (cnt) { + csum ^= *nums; + nums++; + cnt--; + } - return csum; + return csum; } int -checksum_md5 (const char *path, const struct stat *sb) +checksum_md5(const char *path, const struct stat *sb) { - uint64_t this_data_checksum = 0; - FILE *filep = NULL; - char *cmd = NULL; - char strvalue[17] = {0,}; - int ret = -1; - int len = 0; - const char *pos = NULL; - char *cpos = NULL; - - /* Have to escape single-quotes in filename. - * First, calculate the size of the buffer I'll need. - */ - for (pos = path; *pos; pos++) { - if ( *pos == '\'' ) - len += 4; - else - len += 1; - } - - cmd = malloc(sizeof(char) * (len + 20)); - cmd[0] = '\0'; - - /* Now, build the command with single quotes escaped. */ - - cpos = cmd; + uint64_t this_data_checksum = 0; + FILE *filep = NULL; + char *cmd = NULL; + char strvalue[17] = { + 0, + }; + int ret = -1; + int len = 0; + const char *pos = NULL; + char *cpos = NULL; + + /* Have to escape single-quotes in filename. + * First, calculate the size of the buffer I'll need. + */ + for (pos = path; *pos; pos++) { + if (*pos == '\'') + len += 4; + else + len += 1; + } + + cmd = malloc(sizeof(char) * (len + 20)); + cmd[0] = '\0'; + + /* Now, build the command with single quotes escaped. */ + + cpos = cmd; #if defined(linux) - strcpy(cpos, "md5sum '"); - cpos += 8; + strcpy(cpos, "md5sum '"); + cpos += 8; #elif defined(__NetBSD__) - strcpy(cpos, "md5 -n '"); - cpos += 8; + strcpy(cpos, "md5 -n '"); + cpos += 8; #elif defined(__FreeBSD__) || defined(__APPLE__) - strcpy(cpos, "md5 -q '"); - cpos += 8; + strcpy(cpos, "md5 -q '"); + cpos += 8; #else #error "Please add system-specific md5 command" #endif - /* Add the file path, with every single quotes replaced with this sequence: - * '\'' - */ - - for (pos = path; *pos; pos++) { - if ( *pos == '\'' ) { - strcpy(cpos, "'\\''"); - cpos += 4; - } else { - *cpos = *pos; - cpos++; - } - } - - /* Add on the trailing single-quote and null-terminate. */ - strcpy(cpos, "'"); - - filep = popen (cmd, "r"); - if (!filep) { - perror (path); - goto out; - } - - if (fread (strvalue, sizeof (char), 16, filep) != 16) { - fprintf (stderr, "%s: short read\n", path); - goto out; + /* Add the file path, with every single quotes replaced with this sequence: + * '\'' + */ + + for (pos = path; *pos; pos++) { + if (*pos == '\'') { + strcpy(cpos, "'\\''"); + cpos += 4; + } else { + *cpos = *pos; + cpos++; } - - this_data_checksum = strtoull (strvalue, NULL, 16); - if (-1 == this_data_checksum) { - fprintf (stderr, "%s: %s\n", strvalue, strerror (errno)); - goto out; - } - checksum_file1 ^= this_data_checksum; - - if (fread (strvalue, sizeof (char), 16, filep) != 16) { - fprintf (stderr, "%s: short read\n", path); - goto out; - } - - this_data_checksum = strtoull (strvalue, NULL, 16); - if (-1 == this_data_checksum) { - fprintf (stderr, "%s: %s\n", strvalue, strerror (errno)); - goto out; - } - checksum_file2 ^= this_data_checksum; - - ret = 0; + } + + /* Add on the trailing single-quote and null-terminate. */ + strcpy(cpos, "'"); + + filep = popen(cmd, "r"); + if (!filep) { + perror(path); + goto out; + } + + if (fread(strvalue, sizeof(char), 16, filep) != 16) { + fprintf(stderr, "%s: short read\n", path); + goto out; + } + + this_data_checksum = strtoull(strvalue, NULL, 16); + if (-1 == this_data_checksum) { + fprintf(stderr, "%s: %s\n", strvalue, strerror(errno)); + goto out; + } + checksum_file1 ^= this_data_checksum; + + if (fread(strvalue, sizeof(char), 16, filep) != 16) { + fprintf(stderr, "%s: short read\n", path); + goto out; + } + + this_data_checksum = strtoull(strvalue, NULL, 16); + if (-1 == this_data_checksum) { + fprintf(stderr, "%s: %s\n", strvalue, strerror(errno)); + goto out; + } + checksum_file2 ^= this_data_checksum; + + ret = 0; out: - if (filep) - pclose (filep); + if (filep) + pclose(filep); - if (cmd) - free(cmd); + if (cmd) + free(cmd); - return ret; + return ret; } int -checksum_filenames (const char *path, const struct stat *sb) +checksum_filenames(const char *path, const struct stat *sb) { - DIR *dirp = NULL; - struct dirent *entry = NULL; - unsigned long long csum = 0; - int i = 0; - int found = 0; - - dirp = opendir (path); - if (!dirp) { - perror (path); - goto out; - } - - errno = 0; - while ((entry = readdir (dirp))) { - /* do not calculate the checksum of the entries which user has - told to ignore and proceed to other siblings.*/ - if (arequal_config.ignored_directory) { - for (i = 0;i < arequal_config.directories_ignored;i++) { - if ((strcmp (entry->d_name, - arequal_config.ignored_directory[i]) - == 0)) { - found = 1; - DBG ("ignoring the entry %s\n", - entry->d_name); - break; - } - } - if (found == 1) { - found = 0; - continue; - } + DIR *dirp = NULL; + struct dirent *entry = NULL; + unsigned long long csum = 0; + int i = 0; + int found = 0; + + dirp = opendir(path); + if (!dirp) { + perror(path); + goto out; + } + + errno = 0; + while ((entry = readdir(dirp))) { + /* do not calculate the checksum of the entries which user has + told to ignore and proceed to other siblings.*/ + if (arequal_config.ignored_directory) { + for (i = 0; i < arequal_config.directories_ignored; i++) { + if ((strcmp(entry->d_name, + arequal_config.ignored_directory[i]) == 0)) { + found = 1; + DBG("ignoring the entry %s\n", entry->d_name); + break; } - csum = checksum_path (entry->d_name); - checksum_dir ^= csum; + } + if (found == 1) { + found = 0; + continue; + } } + csum = checksum_path(entry->d_name); + checksum_dir ^= csum; + } - if (errno) { - perror (path); - goto out; - } + if (errno) { + perror(path); + goto out; + } out: - if (dirp) - closedir (dirp); + if (dirp) + closedir(dirp); - return 0; + return 0; } - int -process_file (const char *path, const struct stat *sb) +process_file(const char *path, const struct stat *sb) { - int ret = 0; + int ret = 0; - count_file++; + count_file++; - avg_uid_file ^= sb->st_uid; - avg_gid_file ^= sb->st_gid; - avg_mode_file ^= sb->st_mode; + avg_uid_file ^= sb->st_uid; + avg_gid_file ^= sb->st_gid; + avg_mode_file ^= sb->st_mode; - ret = checksum_md5 (path, sb); + ret = checksum_md5(path, sb); - return ret; + return ret; } - int -process_dir (const char *path, const struct stat *sb) +process_dir(const char *path, const struct stat *sb) { - unsigned long long csum = 0; + unsigned long long csum = 0; - count_dir++; + count_dir++; - avg_uid_dir ^= sb->st_uid; - avg_gid_dir ^= sb->st_gid; - avg_mode_dir ^= sb->st_mode; + avg_uid_dir ^= sb->st_uid; + avg_gid_dir ^= sb->st_gid; + avg_mode_dir ^= sb->st_mode; - csum = checksum_filenames (path, sb); + csum = checksum_filenames(path, sb); - checksum_dir ^= csum; + checksum_dir ^= csum; - return 0; + return 0; } - int -process_symlink (const char *path, const struct stat *sb) +process_symlink(const char *path, const struct stat *sb) { - int ret = 0; - char buf[4096] = {0, }; - unsigned long long csum = 0; + int ret = 0; + char buf[4096] = { + 0, + }; + unsigned long long csum = 0; - count_symlink++; + count_symlink++; - avg_uid_symlink ^= sb->st_uid; - avg_gid_symlink ^= sb->st_gid; - avg_mode_symlink ^= sb->st_mode; + avg_uid_symlink ^= sb->st_uid; + avg_gid_symlink ^= sb->st_gid; + avg_mode_symlink ^= sb->st_mode; - ret = readlink (path, buf, 4096); - if (ret < 0) { - perror (path); - goto out; - } + ret = readlink(path, buf, 4096); + if (ret < 0) { + perror(path); + goto out; + } - DBG ("readlink (%s) => %s\n", path, buf); + DBG("readlink (%s) => %s\n", path, buf); - csum = checksum_path (buf); + csum = checksum_path(buf); - DBG ("checksum_path (%s) => %llx\n", buf, csum); + DBG("checksum_path (%s) => %llx\n", buf, csum); - checksum_symlink ^= csum; + checksum_symlink ^= csum; - ret = 0; + ret = 0; out: - return ret; + return ret; } - int -process_other (const char *path, const struct stat *sb) +process_other(const char *path, const struct stat *sb) { - count_other++; + count_other++; - avg_uid_other ^= sb->st_uid; - avg_gid_other ^= sb->st_gid; - avg_mode_other ^= sb->st_mode; + avg_uid_other ^= sb->st_uid; + avg_gid_other ^= sb->st_gid; + avg_mode_other ^= sb->st_mode; - checksum_other ^= sb->st_rdev; + checksum_other ^= sb->st_rdev; - return 0; + return 0; } static int ignore_entry(const char *bname, const char *dname) { - int i; + int i; - for (i = 0; i < arequal_config.directories_ignored; i++) { - if (strcmp(bname, arequal_config.ignored_directory[i]) == 0 && - strncmp(arequal_config.test_directory, dname, - strlen(arequal_config.test_directory)) == 0) - return 1; - } + for (i = 0; i < arequal_config.directories_ignored; i++) { + if (strcmp(bname, arequal_config.ignored_directory[i]) == 0 && + strncmp(arequal_config.test_directory, dname, + strlen(arequal_config.test_directory)) == 0) + return 1; + } - return 0; + return 0; } int -process_entry (const char *path, const struct stat *sb, - int typeflag, struct FTW *ftwbuf) +process_entry(const char *path, const struct stat *sb, int typeflag, + struct FTW *ftwbuf) { - int ret = 0; - char *name = NULL; - char *bname = NULL; - char *dname = NULL; - int i = 0; - - /* The if condition below helps in ignoring some directories in - the given path. If the name of the entry is one of the directory - names that the user told to ignore, then that directory will not - be processed and will return FTW_SKIP_SUBTREE to nftw which will - not crawl this directory and move on to other siblings. - Note that for nftw to recognize FTW_SKIP_TREE, FTW_ACTIONRETVAL - should be passed as an argument to nftw. - - This mainly helps in calculating the checksum of network filesystems - (client-server), where the server might have some hidden directories - for managing the filesystem. So to calculate the sanity of filesystem - one has to get the checksum of the client and then the export directory - of server by telling arequal to ignore some of the directories which - are not part of the namespace. - */ - - if (arequal_config.ignored_directory) { + int ret = 0; + char *name = NULL; + char *bname = NULL; + char *dname = NULL; + int i = 0; + + /* The if condition below helps in ignoring some directories in + the given path. If the name of the entry is one of the directory + names that the user told to ignore, then that directory will not + be processed and will return FTW_SKIP_SUBTREE to nftw which will + not crawl this directory and move on to other siblings. + Note that for nftw to recognize FTW_SKIP_TREE, FTW_ACTIONRETVAL + should be passed as an argument to nftw. + + This mainly helps in calculating the checksum of network filesystems + (client-server), where the server might have some hidden directories + for managing the filesystem. So to calculate the sanity of filesystem + one has to get the checksum of the client and then the export directory + of server by telling arequal to ignore some of the directories which + are not part of the namespace. + */ + + if (arequal_config.ignored_directory) { #ifndef FTW_SKIP_SUBTREE - char *cp; - - name = strdup (path); - dname = dirname (name); - - for (cp = strtok(name, "/"); cp; cp = strtok(NULL, "/")) { - if (ignore_entry(cp, dname)) { - DBG ("ignoring %s\n", path); - if (name) - free (name); - return 0; - } - } -#else /* FTW_SKIP_SUBTREE */ - name = strdup (path); - - name[strlen(name)] = '\0'; - - bname = strrchr (name, '/'); - if (bname) - bname++; - - dname = dirname (name); - if (ignore_entry(bname, dname)) { - DBG ("ignoring %s\n", bname); - ret = FTW_SKIP_SUBTREE; - if (name) - free (name); - return ret; - } -#endif /* FTW_SKIP_SUBTREE */ + char *cp; + + name = strdup(path); + dname = dirname(name); + + for (cp = strtok(name, "/"); cp; cp = strtok(NULL, "/")) { + if (ignore_entry(cp, dname)) { + DBG("ignoring %s\n", path); + if (name) + free(name); + return 0; + } } +#else /* FTW_SKIP_SUBTREE */ + name = strdup(path); + + name[strlen(name)] = '\0'; + + bname = strrchr(name, '/'); + if (bname) + bname++; + + dname = dirname(name); + if (ignore_entry(bname, dname)) { + DBG("ignoring %s\n", bname); + ret = FTW_SKIP_SUBTREE; + if (name) + free(name); + return ret; + } +#endif /* FTW_SKIP_SUBTREE */ + } - DBG ("processing entry %s\n", path); + DBG("processing entry %s\n", path); - switch ((S_IFMT & sb->st_mode)) { + switch ((S_IFMT & sb->st_mode)) { case S_IFDIR: - ret = process_dir (path, sb); - break; + ret = process_dir(path, sb); + break; case S_IFREG: - ret = process_file (path, sb); - break; + ret = process_file(path, sb); + break; case S_IFLNK: - ret = process_symlink (path, sb); - break; + ret = process_symlink(path, sb); + break; default: - ret = process_other (path, sb); - break; - } + ret = process_other(path, sb); + break; + } - if (name) - free (name); - return ret; + if (name) + free(name); + return ret; } - int -display_counts (FILE *fp) +display_counts(FILE *fp) { - fprintf (fp, "\n"); - fprintf (fp, "Entry counts\n"); - fprintf (fp, "Regular files : %lld\n", count_file); - fprintf (fp, "Directories : %lld\n", count_dir); - fprintf (fp, "Symbolic links : %lld\n", count_symlink); - fprintf (fp, "Other : %lld\n", count_other); - fprintf (fp, "Total : %lld\n", - (count_file + count_dir + count_symlink + count_other)); - - return 0; + fprintf(fp, "\n"); + fprintf(fp, "Entry counts\n"); + fprintf(fp, "Regular files : %lld\n", count_file); + fprintf(fp, "Directories : %lld\n", count_dir); + fprintf(fp, "Symbolic links : %lld\n", count_symlink); + fprintf(fp, "Other : %lld\n", count_other); + fprintf(fp, "Total : %lld\n", + (count_file + count_dir + count_symlink + count_other)); + + return 0; } - int -display_checksums (FILE *fp) +display_checksums(FILE *fp) { - fprintf (fp, "\n"); - fprintf (fp, "Checksums\n"); - fprintf (fp, "Regular files : %llx%llx\n", checksum_file1, checksum_file2); - fprintf (fp, "Directories : %llx\n", checksum_dir); - fprintf (fp, "Symbolic links : %llx\n", checksum_symlink); - fprintf (fp, "Other : %llx\n", checksum_other); - fprintf (fp, "Total : %llx\n", - (checksum_file1 ^ checksum_file2 ^ checksum_dir ^ checksum_symlink ^ checksum_other)); - - return 0; + fprintf(fp, "\n"); + fprintf(fp, "Checksums\n"); + fprintf(fp, "Regular files : %llx%llx\n", checksum_file1, checksum_file2); + fprintf(fp, "Directories : %llx\n", checksum_dir); + fprintf(fp, "Symbolic links : %llx\n", checksum_symlink); + fprintf(fp, "Other : %llx\n", checksum_other); + fprintf(fp, "Total : %llx\n", + (checksum_file1 ^ checksum_file2 ^ checksum_dir ^ checksum_symlink ^ + checksum_other)); + + return 0; } - int -display_metadata (FILE *fp) +display_metadata(FILE *fp) { - fprintf (fp, "\n"); - fprintf (fp, "Metadata checksums\n"); - fprintf (fp, "Regular files : %llx\n", - (avg_uid_file + 13) * (avg_gid_file + 11) * (avg_mode_file + 7)); - fprintf (fp, "Directories : %llx\n", - (avg_uid_dir + 13) * (avg_gid_dir + 11) * (avg_mode_dir + 7)); - fprintf (fp, "Symbolic links : %llx\n", - (avg_uid_symlink + 13) * (avg_gid_symlink + 11) * (avg_mode_symlink + 7)); - fprintf (fp, "Other : %llx\n", - (avg_uid_other + 13) * (avg_gid_other + 11) * (avg_mode_other + 7)); - - return 0; + fprintf(fp, "\n"); + fprintf(fp, "Metadata checksums\n"); + fprintf(fp, "Regular files : %llx\n", + (avg_uid_file + 13) * (avg_gid_file + 11) * (avg_mode_file + 7)); + fprintf(fp, "Directories : %llx\n", + (avg_uid_dir + 13) * (avg_gid_dir + 11) * (avg_mode_dir + 7)); + fprintf(fp, "Symbolic links : %llx\n", + (avg_uid_symlink + 13) * (avg_gid_symlink + 11) * + (avg_mode_symlink + 7)); + fprintf(fp, "Other : %llx\n", + (avg_uid_other + 13) * (avg_gid_other + 11) * (avg_mode_other + 7)); + + return 0; } int -display_stats (FILE *fp) +display_stats(FILE *fp) { - display_counts (fp); + display_counts(fp); - display_metadata (fp); + display_metadata(fp); - display_checksums (fp); + display_checksums(fp); - return 0; + return 0; } - int main(int argc, char *argv[]) { - int ret = 0; - int i = 0; - - ret = argp_parse (&argp, argc, argv, 0, 0, NULL); - if (ret != 0) { - fprintf (stderr, "parsing arguments failed\n"); - return -2; - } - - /* Use FTW_ACTIONRETVAL to take decision on what to do depending upon */ - /* the return value of the callback function */ - /* (process_entry in this case) */ - ret = nftw (arequal_config.test_directory, process_entry, 30, - FTW_ACTIONRETVAL|FTW_PHYS|FTW_MOUNT); - if (ret != 0) { - fprintf (stderr, "ftw (%s) returned %d (%s), terminating\n", - argv[1], ret, strerror (errno)); - return 1; - } - - display_stats (stdout); - - if (arequal_config.ignored_directory) { - for (i = 0; i < arequal_config.directories_ignored; i++) { - if (arequal_config.ignored_directory[i]) - free (arequal_config.ignored_directory[i]); - } - free (arequal_config.ignored_directory); + int ret = 0; + int i = 0; + + ret = argp_parse(&argp, argc, argv, 0, 0, NULL); + if (ret != 0) { + fprintf(stderr, "parsing arguments failed\n"); + return -2; + } + + /* Use FTW_ACTIONRETVAL to take decision on what to do depending upon */ + /* the return value of the callback function */ + /* (process_entry in this case) */ + ret = nftw(arequal_config.test_directory, process_entry, 30, + FTW_ACTIONRETVAL | FTW_PHYS | FTW_MOUNT); + if (ret != 0) { + fprintf(stderr, "ftw (%s) returned %d (%s), terminating\n", argv[1], + ret, strerror(errno)); + return 1; + } + + display_stats(stdout); + + if (arequal_config.ignored_directory) { + for (i = 0; i < arequal_config.directories_ignored; i++) { + if (arequal_config.ignored_directory[i]) + free(arequal_config.ignored_directory[i]); } + free(arequal_config.ignored_directory); + } - return 0; + return 0; } diff --git a/tests/utils/changelog/get-history.c b/tests/utils/changelog/get-history.c index 29dc60987ae..9963ab76958 100644 --- a/tests/utils/changelog/get-history.c +++ b/tests/utils/changelog/get-history.c @@ -27,47 +27,45 @@ #include "changelog.h" int -main (int argc, char **argv) +main(int argc, char **argv) { - int ret = 0; - unsigned long end_ts = 0; - int start = 0; - int end = 0; + int ret = 0; + unsigned long end_ts = 0; + int start = 0; + int end = 0; - ret = gf_changelog_init (NULL); - if (ret) { - printf ("-1"); - fflush(stdout); - return -1; - } - - ret = gf_changelog_register ("/d/backends/patchy0", - "/tmp/scratch_v1", - "/var/log/glusterfs/changes.log", - 9, 5); - if (ret) { - printf ("-2"); - fflush(stdout); - return -1; - } + ret = gf_changelog_init(NULL); + if (ret) { + printf("-1"); + fflush(stdout); + return -1; + } - start = atoi(argv[1]); - end = atoi(argv[2]); + ret = gf_changelog_register("/d/backends/patchy0", "/tmp/scratch_v1", + "/var/log/glusterfs/changes.log", 9, 5); + if (ret) { + printf("-2"); + fflush(stdout); + return -1; + } - ret = gf_history_changelog ("/d/backends/patchy0/.glusterfs/changelogs", - start, end, 3, &end_ts); - if (ret < 0) { - printf ("-3"); - fflush(stdout); - return -1; - } else if (ret == 1) { - printf ("1"); - fflush(stdout); - return 0; - } + start = atoi(argv[1]); + end = atoi(argv[2]); -out: - printf ("0"); + ret = gf_history_changelog("/d/backends/patchy0/.glusterfs/changelogs", + start, end, 3, &end_ts); + if (ret < 0) { + printf("-3"); + fflush(stdout); + return -1; + } else if (ret == 1) { + printf("1"); fflush(stdout); return 0; + } + +out: + printf("0"); + fflush(stdout); + return 0; } |