15992 lines
490 KiB
Diff
15992 lines
490 KiB
Diff
From 39523fd6c1b4789b12c8db81f4e08a3eb0c6a65c Mon Sep 17 00:00:00 2001
|
|
From: Sunil Kumar Acharya <sheggodu@redhat.com>
|
|
Date: Thu, 17 Oct 2019 13:03:56 +0530
|
|
Subject: [PATCH 335/335] tests: RHEL8 test failure fixes for RHGS
|
|
|
|
- tests/bugs/shard/bug-1272986.t
|
|
https://review.gluster.org/#/c/glusterfs/+/23499/
|
|
https://review.gluster.org/#/c/glusterfs/+/23551/
|
|
|
|
- tests/basic/posix/shared-statfs.t
|
|
https://review.gluster.org/c/glusterfs/+/23550
|
|
|
|
- tests/basic/fops-sanity.t
|
|
https://review.gluster.org/c/glusterfs/+/22210/
|
|
|
|
- tests/bugs/transport/bug-873367.t
|
|
- tests/features/ssl-authz.t
|
|
- tests/bugs/snapshot/bug-1399598-uss-with-ssl.t
|
|
https://review.gluster.org/#/c/glusterfs/+/23587/
|
|
|
|
- remove gnfs relatedtests
|
|
|
|
- tests/bugs/shard/unlinks-and-renames.t
|
|
https://review.gluster.org/#/c/glusterfs/+/23585/
|
|
|
|
- tests/bugs/rpc/bug-954057.t
|
|
- tests/bugs/glusterfs-server/bug-887145.t
|
|
https://review.gluster.org/#/c/glusterfs/+/23710/
|
|
|
|
- tests/features/ssl-ciphers.t
|
|
https://review.gluster.org/#/c/glusterfs/+/23703/
|
|
|
|
- tests/bugs/fuse/bug-985074.t
|
|
https://review.gluster.org/#/c/glusterfs/+/23734/
|
|
|
|
BUG: 1762180
|
|
Change-Id: I97b344a632b49ca9ca332a5a463756b160aee5bd
|
|
Signed-off-by: Sunil Kumar Acharya <sheggodu@redhat.com>
|
|
Reviewed-on: https://code.engineering.redhat.com/gerrit/185716
|
|
Tested-by: RHGS Build Bot <nigelb@redhat.com>
|
|
---
|
|
tests/basic/fops-sanity.c | 1862 ++--
|
|
tests/basic/posix/shared-statfs.t | 11 +-
|
|
tests/bugs/cli/bug-1320388.t | 2 +-
|
|
tests/bugs/fuse/bug-985074.t | 4 +-
|
|
tests/bugs/glusterd/quorum-value-check.t | 35 -
|
|
tests/bugs/glusterfs-server/bug-887145.t | 14 +-
|
|
tests/bugs/nfs/bug-1053579.t | 114 -
|
|
tests/bugs/nfs/bug-1116503.t | 47 -
|
|
tests/bugs/nfs/bug-1143880-fix-gNFSd-auth-crash.t | 24 -
|
|
tests/bugs/nfs/bug-1157223-symlink-mounting.t | 126 -
|
|
tests/bugs/nfs/bug-1161092-nfs-acls.t | 39 -
|
|
tests/bugs/nfs/bug-1166862.t | 69 -
|
|
tests/bugs/nfs/bug-1210338.c | 31 -
|
|
tests/bugs/nfs/bug-1210338.t | 30 -
|
|
tests/bugs/nfs/bug-1302948.t | 13 -
|
|
tests/bugs/nfs/bug-847622.t | 39 -
|
|
tests/bugs/nfs/bug-877885.t | 39 -
|
|
tests/bugs/nfs/bug-904065.t | 100 -
|
|
tests/bugs/nfs/bug-915280.t | 54 -
|
|
tests/bugs/nfs/bug-970070.t | 13 -
|
|
tests/bugs/nfs/bug-974972.t | 41 -
|
|
tests/bugs/nfs/showmount-many-clients.t | 41 -
|
|
tests/bugs/nfs/socket-as-fifo.py | 33 -
|
|
tests/bugs/nfs/socket-as-fifo.t | 25 -
|
|
tests/bugs/nfs/subdir-trailing-slash.t | 32 -
|
|
tests/bugs/nfs/zero-atime.t | 33 -
|
|
tests/bugs/rpc/bug-954057.t | 10 +-
|
|
tests/bugs/shard/bug-1272986.t | 6 +-
|
|
tests/bugs/transport/bug-873367.t | 2 +-
|
|
tests/features/ssl-authz.t | 2 +-
|
|
tests/features/ssl-ciphers.t | 61 +-
|
|
tests/ssl.rc | 2 +-
|
|
xlators/features/shard/src/shard.c | 11754 ++++++++++----------
|
|
33 files changed, 6638 insertions(+), 8070 deletions(-)
|
|
delete mode 100755 tests/bugs/glusterd/quorum-value-check.t
|
|
delete mode 100755 tests/bugs/nfs/bug-1053579.t
|
|
delete mode 100644 tests/bugs/nfs/bug-1116503.t
|
|
delete mode 100644 tests/bugs/nfs/bug-1143880-fix-gNFSd-auth-crash.t
|
|
delete mode 100644 tests/bugs/nfs/bug-1157223-symlink-mounting.t
|
|
delete mode 100644 tests/bugs/nfs/bug-1161092-nfs-acls.t
|
|
delete mode 100755 tests/bugs/nfs/bug-1166862.t
|
|
delete mode 100644 tests/bugs/nfs/bug-1210338.c
|
|
delete mode 100644 tests/bugs/nfs/bug-1210338.t
|
|
delete mode 100755 tests/bugs/nfs/bug-1302948.t
|
|
delete mode 100755 tests/bugs/nfs/bug-847622.t
|
|
delete mode 100755 tests/bugs/nfs/bug-877885.t
|
|
delete mode 100755 tests/bugs/nfs/bug-904065.t
|
|
delete mode 100755 tests/bugs/nfs/bug-915280.t
|
|
delete mode 100755 tests/bugs/nfs/bug-970070.t
|
|
delete mode 100755 tests/bugs/nfs/bug-974972.t
|
|
delete mode 100644 tests/bugs/nfs/showmount-many-clients.t
|
|
delete mode 100755 tests/bugs/nfs/socket-as-fifo.py
|
|
delete mode 100644 tests/bugs/nfs/socket-as-fifo.t
|
|
delete mode 100644 tests/bugs/nfs/subdir-trailing-slash.t
|
|
delete mode 100755 tests/bugs/nfs/zero-atime.t
|
|
|
|
diff --git a/tests/basic/fops-sanity.c b/tests/basic/fops-sanity.c
|
|
index aff72d8..171d003 100644
|
|
--- a/tests/basic/fops-sanity.c
|
|
+++ b/tests/basic/fops-sanity.c
|
|
@@ -17,15 +17,16 @@
|
|
|
|
/* Filesystem basic sanity check, tests all (almost) fops. */
|
|
|
|
-#include <stdio.h>
|
|
+#include <dirent.h>
|
|
+#include <errno.h>
|
|
#include <fcntl.h>
|
|
-#include <unistd.h>
|
|
-#include <sys/types.h>
|
|
+#include <stdio.h>
|
|
+#include <string.h>
|
|
#include <sys/stat.h>
|
|
+#include <sys/sysmacros.h>
|
|
+#include <sys/types.h>
|
|
#include <sys/xattr.h>
|
|
-#include <errno.h>
|
|
-#include <string.h>
|
|
-#include <dirent.h>
|
|
+#include <unistd.h>
|
|
|
|
#ifndef linux
|
|
#include <sys/socket.h>
|
|
@@ -34,904 +35,880 @@
|
|
#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
|
|
|
|
-int
|
|
-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 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;
|
|
}
|
|
|
|
/* Execute all possible fops on a fd which is unlinked */
|
|
-int
|
|
-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_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_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);
|
|
+int 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;
|
|
+ return result;
|
|
}
|
|
|
|
-int
|
|
-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 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");
|
|
|
|
#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;
|
|
- }
|
|
- unlink(newfilename);
|
|
-
|
|
- if (fd)
|
|
- close(fd);
|
|
-
|
|
- unlink(filename);
|
|
- return result;
|
|
-}
|
|
-
|
|
-int
|
|
-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;
|
|
+ fprintf(stderr, "fifo mknod failed: %s\n", strerror(errno));
|
|
+ result |= ret;
|
|
}
|
|
-
|
|
+ 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);
|
|
|
|
- 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;
|
|
+ unlink(filename);
|
|
+ return result;
|
|
}
|
|
|
|
-int
|
|
-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 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
|
|
-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 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
|
|
-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;
|
|
- }
|
|
+int 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;
|
|
+}
|
|
|
|
- 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 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;
|
|
+ }
|
|
|
|
#if 0 /* undefined behaviour, unable to reliably test */
|
|
ret = creat (filename, 0644);
|
|
@@ -943,90 +920,87 @@ 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)
|
|
-{
|
|
- 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;
|
|
+int 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;
|
|
}
|
|
+ }
|
|
|
|
- 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;
|
|
+ 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;
|
|
}
|
|
+ }
|
|
|
|
- /* 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;
|
|
- }
|
|
+ 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 0;
|
|
+ return ret;
|
|
+ }
|
|
+
|
|
+ close(fd);
|
|
+ unlink(filename);
|
|
+ return 0;
|
|
}
|
|
diff --git a/tests/basic/posix/shared-statfs.t b/tests/basic/posix/shared-statfs.t
|
|
index 3343956..0e4a1bb 100644
|
|
--- a/tests/basic/posix/shared-statfs.t
|
|
+++ b/tests/basic/posix/shared-statfs.t
|
|
@@ -20,15 +20,18 @@ TEST mkdir -p $B0/${V0}1 $B0/${V0}2
|
|
TEST MOUNT_LOOP $LO1 $B0/${V0}1
|
|
TEST MOUNT_LOOP $LO2 $B0/${V0}2
|
|
|
|
+total_brick_blocks=$(df -P $B0/${V0}1 $B0/${V0}2 | tail -2 | awk '{sum = sum+$2}END{print sum}')
|
|
+#Account for rounding error
|
|
+brick_blocks_two_percent_less=$((total_brick_blocks*98/100))
|
|
# Create a subdir in mountpoint and use that for volume.
|
|
TEST $CLI volume create $V0 $H0:$B0/${V0}1/1 $H0:$B0/${V0}2/1;
|
|
TEST $CLI volume start $V0
|
|
EXPECT_WITHIN $PROCESS_UP_TIMEOUT "2" online_brick_count
|
|
TEST $GFS --volfile-server=$H0 --volfile-id=$V0 $M0
|
|
-total_space=$(df -P $M0 | tail -1 | awk '{ print $2}')
|
|
+total_mount_blocks=$(df -P $M0 | tail -1 | awk '{ print $2}')
|
|
# Keeping the size less than 200M mainly because XFS will use
|
|
# some storage in brick to keep its own metadata.
|
|
-TEST [ $total_space -gt 194000 -a $total_space -lt 200000 ]
|
|
+TEST [ $total_mount_blocks -gt $brick_blocks_two_percent_less -a $total_mount_blocks -lt 200000 ]
|
|
|
|
|
|
TEST force_umount $M0
|
|
@@ -41,8 +44,8 @@ TEST $CLI volume add-brick $V0 $H0:$B0/${V0}1/2 $H0:$B0/${V0}2/2 $H0:$B0/${V0}1/
|
|
TEST $CLI volume start $V0
|
|
EXPECT_WITHIN $PROCESS_UP_TIMEOUT "6" online_brick_count
|
|
TEST $GFS --volfile-server=$H0 --volfile-id=$V0 $M0
|
|
-total_space=$(df -P $M0 | tail -1 | awk '{ print $2}')
|
|
-TEST [ $total_space -gt 194000 -a $total_space -lt 200000 ]
|
|
+total_mount_blocks=$(df -P $M0 | tail -1 | awk '{ print $2}')
|
|
+TEST [ $total_mount_blocks -gt $brick_blocks_two_percent_less -a $total_mount_blocks -lt 200000 ]
|
|
|
|
TEST force_umount $M0
|
|
TEST $CLI volume stop $V0
|
|
diff --git a/tests/bugs/cli/bug-1320388.t b/tests/bugs/cli/bug-1320388.t
|
|
index 8e5d77b..e719fc5 100755
|
|
--- a/tests/bugs/cli/bug-1320388.t
|
|
+++ b/tests/bugs/cli/bug-1320388.t
|
|
@@ -21,7 +21,7 @@ cleanup;
|
|
rm -f $SSL_BASE/glusterfs.*
|
|
touch "$GLUSTERD_WORKDIR"/secure-access
|
|
|
|
-TEST openssl genrsa -out $SSL_KEY 3072
|
|
+TEST openssl genrsa -out $SSL_KEY 2048
|
|
TEST openssl req -new -x509 -key $SSL_KEY -subj /CN=Anyone -out $SSL_CERT
|
|
ln $SSL_CERT $SSL_CA
|
|
|
|
diff --git a/tests/bugs/fuse/bug-985074.t b/tests/bugs/fuse/bug-985074.t
|
|
index d10fd9f..26d196e 100644
|
|
--- a/tests/bugs/fuse/bug-985074.t
|
|
+++ b/tests/bugs/fuse/bug-985074.t
|
|
@@ -30,7 +30,7 @@ TEST glusterd
|
|
|
|
TEST $CLI volume create $V0 $H0:$B0/$V0
|
|
TEST $CLI volume start $V0
|
|
-TEST $CLI volume set $V0 md-cache-timeout 3
|
|
+TEST $CLI volume set $V0 performance.stat-prefetch off
|
|
|
|
TEST glusterfs --volfile-id=$V0 --volfile-server=$H0 $M0 --entry-timeout=0 --attribute-timeout=0
|
|
TEST glusterfs --volfile-id=$V0 --volfile-server=$H0 $M1 --entry-timeout=0 --attribute-timeout=0
|
|
@@ -40,8 +40,6 @@ TEST ln $M0/file $M0/file.link
|
|
TEST ls -ali $M0 $M1
|
|
TEST rm -f $M1/file.link
|
|
TEST ls -ali $M0 $M1
|
|
-# expire the md-cache timeout
|
|
-sleep 3
|
|
TEST mv $M0/file $M0/file.link
|
|
TEST stat $M0/file.link
|
|
TEST ! stat $M0/file
|
|
diff --git a/tests/bugs/glusterd/quorum-value-check.t b/tests/bugs/glusterd/quorum-value-check.t
|
|
deleted file mode 100755
|
|
index aaf6362..0000000
|
|
--- a/tests/bugs/glusterd/quorum-value-check.t
|
|
+++ /dev/null
|
|
@@ -1,35 +0,0 @@
|
|
-#!/bin/bash
|
|
-
|
|
-. $(dirname $0)/../../include.rc
|
|
-. $(dirname $0)/../../volume.rc
|
|
-
|
|
-function check_quorum_nfs() {
|
|
- local qnfs="$(less /var/lib/glusterd/nfs/nfs-server.vol | grep "quorum-count"| awk '{print $3}')"
|
|
- local qinfo="$($CLI volume info $V0| grep "cluster.quorum-count"| awk '{print $2}')"
|
|
-
|
|
- if [ $qnfs = $qinfo ]; then
|
|
- echo "Y"
|
|
- else
|
|
- echo "N"
|
|
- fi
|
|
-}
|
|
-
|
|
-cleanup;
|
|
-
|
|
-TEST glusterd
|
|
-TEST pidof glusterd
|
|
-TEST $CLI volume create $V0 replica 3 $H0:$B0/${V0}{0,1,2}
|
|
-TEST $CLI volume set $V0 nfs.disable off
|
|
-TEST $CLI volume set $V0 performance.write-behind off
|
|
-TEST $CLI volume set $V0 cluster.self-heal-daemon off
|
|
-TEST $CLI volume set $V0 cluster.quorum-type fixed
|
|
-TEST $CLI volume start $V0
|
|
-
|
|
-TEST $CLI volume set $V0 cluster.quorum-count 1
|
|
-EXPECT_WITHIN $CONFIG_UPDATE_TIMEOUT "Y" check_quorum_nfs
|
|
-TEST $CLI volume set $V0 cluster.quorum-count 2
|
|
-EXPECT_WITHIN $CONFIG_UPDATE_TIMEOUT "Y" check_quorum_nfs
|
|
-TEST $CLI volume set $V0 cluster.quorum-count 3
|
|
-EXPECT_WITHIN $CONFIG_UPDATE_TIMEOUT "Y" check_quorum_nfs
|
|
-
|
|
-cleanup;
|
|
diff --git a/tests/bugs/glusterfs-server/bug-887145.t b/tests/bugs/glusterfs-server/bug-887145.t
|
|
index 82f7cca..f65b1bd 100755
|
|
--- a/tests/bugs/glusterfs-server/bug-887145.t
|
|
+++ b/tests/bugs/glusterfs-server/bug-887145.t
|
|
@@ -29,7 +29,15 @@ chmod 600 $M0/file;
|
|
|
|
TEST mount_nfs $H0:/$V0 $N0 nolock;
|
|
|
|
-chown -R nfsnobody:nfsnobody $M0/dir;
|
|
+grep nfsnobody /etc/passwd > /dev/nul
|
|
+if [ $? -eq 1 ]; then
|
|
+usr=nobody
|
|
+grp=nobody
|
|
+else
|
|
+usr=nfsnobody
|
|
+grp=nfsnobody
|
|
+fi
|
|
+chown -R $usr:$grp $M0/dir;
|
|
chown -R tmp_user:tmp_user $M0/other;
|
|
|
|
TEST $CLI volume set $V0 server.root-squash on;
|
|
@@ -38,7 +46,7 @@ EXPECT_WITHIN $NFS_EXPORT_TIMEOUT "1" is_nfs_export_available;
|
|
|
|
# create files and directories in the root of the glusterfs and nfs mount
|
|
# which is owned by root and hence the right behavior is getting EACCESS
|
|
-# as the fops are executed as nfsnobody.
|
|
+# as the fops are executed as nfsnobody/nobody.
|
|
touch $M0/foo 2>/dev/null;
|
|
TEST [ $? -ne 0 ]
|
|
touch $N0/foo 2>/dev/null;
|
|
@@ -61,7 +69,7 @@ cat $N0/passwd 1>/dev/null;
|
|
TEST [ $? -eq 0 ]
|
|
|
|
# create files and directories should succeed as the fops are being executed
|
|
-# inside the directory owned by nfsnobody
|
|
+# inside the directory owned by nfsnobody/nobody
|
|
TEST touch $M0/dir/file;
|
|
TEST touch $N0/dir/foo;
|
|
TEST mkdir $M0/dir/new;
|
|
diff --git a/tests/bugs/nfs/bug-1053579.t b/tests/bugs/nfs/bug-1053579.t
|
|
deleted file mode 100755
|
|
index 2f53172..0000000
|
|
--- a/tests/bugs/nfs/bug-1053579.t
|
|
+++ /dev/null
|
|
@@ -1,114 +0,0 @@
|
|
-#!/bin/bash
|
|
-
|
|
-. $(dirname $0)/../../include.rc
|
|
-. $(dirname $0)/../../volume.rc
|
|
-. $(dirname $0)/../../nfs.rc
|
|
-
|
|
-#G_TESTDEF_TEST_STATUS_CENTOS6=NFS_TEST
|
|
-
|
|
-cleanup
|
|
-
|
|
-# prepare the users and groups
|
|
-NEW_USER=bug1053579
|
|
-NEW_UID=1053579
|
|
-NEW_GID=1053579
|
|
-LAST_GID=1053779
|
|
-NEW_GIDS=${NEW_GID}
|
|
-
|
|
-# OS-specific overrides
|
|
-case $OSTYPE in
|
|
-NetBSD|Darwin)
|
|
- # only NGROUPS_MAX=16 secondary groups are supported
|
|
- LAST_GID=1053593
|
|
- ;;
|
|
-FreeBSD)
|
|
- # NGROUPS_MAX=1023 (FreeBSD>=8.0), we can afford 200 groups
|
|
- ;;
|
|
-Linux)
|
|
- # NGROUPS_MAX=65536, we can afford 200 groups
|
|
- ;;
|
|
-*)
|
|
- ;;
|
|
-esac
|
|
-
|
|
-# create a user that belongs to many groups
|
|
-for GID in $(seq -f '%6.0f' ${NEW_GID} ${LAST_GID})
|
|
-do
|
|
- groupadd -o -g ${GID} ${NEW_USER}-${GID}
|
|
- NEW_GIDS="${NEW_GIDS},${NEW_USER}-${GID}"
|
|
-done
|
|
-TEST useradd -o -M -u ${NEW_UID} -g ${NEW_GID} -G ${NEW_USER}-${NEW_GIDS} ${NEW_USER}
|
|
-
|
|
-# preparation done, start the tests
|
|
-
|
|
-TEST glusterd
|
|
-TEST pidof glusterd
|
|
-TEST $CLI volume create $V0 $H0:$B0/${V0}1
|
|
-TEST $CLI volume set $V0 nfs.disable false
|
|
-TEST $CLI volume set $V0 nfs.server-aux-gids on
|
|
-TEST $CLI volume start $V0
|
|
-
|
|
-EXPECT_WITHIN $NFS_EXPORT_TIMEOUT "1" is_nfs_export_available
|
|
-
|
|
-# mount the volume
|
|
-TEST mount_nfs $H0:/$V0 $N0 nolock
|
|
-TEST glusterfs --volfile-id=/$V0 --volfile-server=$H0 $M0
|
|
-
|
|
-# the actual test, this used to crash
|
|
-su -m ${NEW_USER} -c "stat $N0/. > /dev/null"
|
|
-TEST [ $? -eq 0 ]
|
|
-
|
|
-# create a file that only a user in a high-group can access
|
|
-echo 'Hello World!' > $N0/README
|
|
-chgrp ${LAST_GID} $N0/README
|
|
-chmod 0640 $N0/README
|
|
-
|
|
-#su -m ${NEW_USER} -c "cat $N0/README 2>&1 > /dev/null"
|
|
-su -m ${NEW_USER} -c "cat $N0/README"
|
|
-ret=$?
|
|
-
|
|
-case $OSTYPE in
|
|
-Linux) # Linux NFS fails with big GID
|
|
- if [ $ret -ne 0 ] ; then
|
|
- res="Y"
|
|
- else
|
|
- res="N"
|
|
- fi
|
|
- ;;
|
|
-*) # Other systems should cope better
|
|
- if [ $ret -eq 0 ] ; then
|
|
- res="Y"
|
|
- else
|
|
- res="N"
|
|
- fi
|
|
- ;;
|
|
-esac
|
|
-TEST [ "x$res" = "xY" ]
|
|
-
|
|
-# This passes only on build.gluster.org, not reproducible on other machines?!
|
|
-#su -m ${NEW_USER} -c "cat $M0/README 2>&1 > /dev/null"
|
|
-#TEST [ $? -ne 0 ]
|
|
-
|
|
-# enable server.manage-gids and things should work
|
|
-TEST $CLI volume set $V0 server.manage-gids on
|
|
-
|
|
-su -m ${NEW_USER} -c "cat $N0/README 2>&1 > /dev/null"
|
|
-TEST [ $? -eq 0 ]
|
|
-su -m ${NEW_USER} -c "cat $M0/README 2>&1 > /dev/null"
|
|
-TEST [ $? -eq 0 ]
|
|
-
|
|
-# cleanup
|
|
-userdel --force ${NEW_USER}
|
|
-for GID in $(seq -f '%6.0f' ${NEW_GID} ${LAST_GID})
|
|
-do
|
|
- groupdel ${NEW_USER}-${GID}
|
|
-done
|
|
-
|
|
-rm -f $N0/README
|
|
-EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $N0
|
|
-EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $M0
|
|
-
|
|
-TEST $CLI volume stop $V0
|
|
-TEST $CLI volume delete $V0
|
|
-
|
|
-cleanup
|
|
diff --git a/tests/bugs/nfs/bug-1116503.t b/tests/bugs/nfs/bug-1116503.t
|
|
deleted file mode 100644
|
|
index dd3998d..0000000
|
|
--- a/tests/bugs/nfs/bug-1116503.t
|
|
+++ /dev/null
|
|
@@ -1,47 +0,0 @@
|
|
-#!/bin/bash
|
|
-#
|
|
-# Verify that mounting NFS over UDP (MOUNT service only) works.
|
|
-#
|
|
-
|
|
-. $(dirname $0)/../../include.rc
|
|
-. $(dirname $0)/../../volume.rc
|
|
-. $(dirname $0)/../../nfs.rc
|
|
-
|
|
-#G_TESTDEF_TEST_STATUS_CENTOS6=NFS_TEST
|
|
-
|
|
-cleanup;
|
|
-TEST glusterd
|
|
-TEST pidof glusterd
|
|
-
|
|
-TEST $CLI volume create $V0 $H0:$B0/$V0
|
|
-TEST $CLI volume set $V0 nfs.disable false
|
|
-TEST $CLI volume set $V0 nfs.mount-udp on
|
|
-
|
|
-TEST $CLI volume start $V0
|
|
-EXPECT_WITHIN $NFS_EXPORT_TIMEOUT "1" is_nfs_export_available;
|
|
-
|
|
-TEST mount_nfs $H0:/$V0 $N0 nolock,mountproto=udp,proto=tcp;
|
|
-TEST mkdir -p $N0/foo/bar
|
|
-TEST ls $N0/foo
|
|
-TEST ls $N0/foo/bar
|
|
-EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $N0
|
|
-
|
|
-EXPECT_WITHIN $NFS_EXPORT_TIMEOUT "1" is_nfs_export_available;
|
|
-TEST mount_nfs $H0:/$V0/foo $N0 nolock,mountproto=udp,proto=tcp;
|
|
-EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $N0
|
|
-
|
|
-EXPECT_WITHIN $NFS_EXPORT_TIMEOUT "1" is_nfs_export_available;
|
|
-TEST mount_nfs $H0:/$V0/foo/bar $N0 nolock,mountproto=udp,proto=tcp;
|
|
-EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $N0
|
|
-
|
|
-TEST $CLI volume set $V0 nfs.addr-namelookup on
|
|
-TEST $CLI volume set $V0 nfs.rpc-auth-allow $H0
|
|
-EXPECT_WITHIN $NFS_EXPORT_TIMEOUT "1" is_nfs_export_available;
|
|
-TEST mount_nfs $H0:/$V0/foo/bar $N0 nolock,mountproto=udp,proto=tcp;
|
|
-EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $N0
|
|
-
|
|
-TEST $CLI volume set $V0 nfs.rpc-auth-reject $H0
|
|
-EXPECT_WITHIN $NFS_EXPORT_TIMEOUT "1" is_nfs_export_available;
|
|
-TEST ! mount_nfs $H0:/$V0/foo/bar $N0 nolock,mountproto=udp,proto=tcp;
|
|
-
|
|
-cleanup;
|
|
diff --git a/tests/bugs/nfs/bug-1143880-fix-gNFSd-auth-crash.t b/tests/bugs/nfs/bug-1143880-fix-gNFSd-auth-crash.t
|
|
deleted file mode 100644
|
|
index c360db4..0000000
|
|
--- a/tests/bugs/nfs/bug-1143880-fix-gNFSd-auth-crash.t
|
|
+++ /dev/null
|
|
@@ -1,24 +0,0 @@
|
|
-#!/bin/bash
|
|
-
|
|
-. $(dirname $0)/../../include.rc
|
|
-. $(dirname $0)/../../nfs.rc
|
|
-
|
|
-#G_TESTDEF_TEST_STATUS_CENTOS6=NFS_TEST
|
|
-
|
|
-cleanup;
|
|
-
|
|
-TEST glusterd
|
|
-TEST pidof glusterd
|
|
-TEST $CLI volume create $V0 replica 2 $H0:$B0/${V0}{1,2}
|
|
-TEST $CLI volume set $V0 nfs.disable false
|
|
-TEST $CLI volume set $V0 performance.open-behind off
|
|
-TEST $CLI volume start $V0
|
|
-
|
|
-EXPECT_WITHIN $NFS_EXPORT_TIMEOUT 1 is_nfs_export_available
|
|
-
|
|
-TEST mount_nfs $H0:/$V0 $N0 nolock
|
|
-TEST mkdir -p $N0/foo
|
|
-EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" umount_nfs $N0
|
|
-TEST mount_nfs $H0:/$V0/foo $N0 nolock
|
|
-EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" umount_nfs $N0
|
|
-cleanup
|
|
diff --git a/tests/bugs/nfs/bug-1157223-symlink-mounting.t b/tests/bugs/nfs/bug-1157223-symlink-mounting.t
|
|
deleted file mode 100644
|
|
index dea609e..0000000
|
|
--- a/tests/bugs/nfs/bug-1157223-symlink-mounting.t
|
|
+++ /dev/null
|
|
@@ -1,126 +0,0 @@
|
|
-#!/bin/bash
|
|
-
|
|
-. $(dirname $0)/../../include.rc
|
|
-. $(dirname $0)/../../nfs.rc
|
|
-
|
|
-#G_TESTDEF_TEST_STATUS_CENTOS6=NFS_TEST
|
|
-
|
|
-cleanup;
|
|
-
|
|
-## Start and create a volume
|
|
-TEST glusterd
|
|
-TEST pidof glusterd
|
|
-
|
|
-TEST $CLI volume info;
|
|
-TEST $CLI volume create $V0 $H0:$B0/$V0
|
|
-TEST $CLI volume set $V0 nfs.disable false
|
|
-TEST $CLI volume start $V0;
|
|
-
|
|
-## Wait for volume to register with rpc.mountd
|
|
-EXPECT_WITHIN $NFS_EXPORT_TIMEOUT "1" is_nfs_export_available;
|
|
-
|
|
-## Mount NFS
|
|
-TEST mount_nfs $H0:/$V0 $N0 nolock;
|
|
-
|
|
-mkdir $N0/dir1;
|
|
-mkdir $N0/dir2;
|
|
-pushd $N0/ ;
|
|
-
|
|
-##link created using relative path
|
|
-ln -s dir1 symlink1;
|
|
-
|
|
-##relative path contains ".."
|
|
-ln -s ../dir1 dir2/symlink2;
|
|
-
|
|
-##link created using absolute path
|
|
-ln -s $N0/dir1 symlink3;
|
|
-
|
|
-##link pointing to another symlinks
|
|
-ln -s symlink1 symlink4
|
|
-ln -s symlink3 symlink5
|
|
-
|
|
-##dead links
|
|
-ln -s does/not/exist symlink6
|
|
-
|
|
-##link which contains ".." points out of glusterfs
|
|
-ln -s ../../ symlink7
|
|
-
|
|
-##links pointing to unauthorized area
|
|
-ln -s .glusterfs symlink8
|
|
-
|
|
-popd ;
|
|
-
|
|
-##Umount the volume
|
|
-EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" umount_nfs $N0
|
|
-
|
|
-## Mount and umount NFS via directory
|
|
-TEST mount_nfs $H0:/$V0/dir1 $N0 nolock;
|
|
-EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" umount_nfs $N0
|
|
-
|
|
-## Mount and umount NFS via symlink1
|
|
-TEST mount_nfs $H0:/$V0/symlink1 $N0 nolock;
|
|
-EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" umount_nfs $N0
|
|
-
|
|
-## Mount and umount NFS via symlink2
|
|
-TEST mount_nfs $H0:/$V0/dir2/symlink2 $N0 nolock;
|
|
-EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" umount_nfs $N0
|
|
-
|
|
-## Mount NFS via symlink3 should fail
|
|
-TEST ! mount_nfs $H0:/$V0/symlink3 $N0 nolock;
|
|
-
|
|
-## Mount and umount NFS via symlink4
|
|
-TEST mount_nfs $H0:/$V0/symlink4 $N0 nolock;
|
|
-EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" umount_nfs $N0
|
|
-
|
|
-## Mount NFS via symlink5 should fail
|
|
-TEST ! mount_nfs $H0:/$V0/symlink5 $N0 nolock;
|
|
-
|
|
-## Mount NFS via symlink6 should fail
|
|
-TEST ! mount_nfs $H0:/$V0/symlink6 $N0 nolock;
|
|
-
|
|
-## Mount NFS via symlink7 should fail
|
|
-TEST ! mount_nfs $H0:/$V0/symlink7 $N0 nolock;
|
|
-
|
|
-## Mount NFS via symlink8 should fail
|
|
-TEST ! mount_nfs $H0:/$V0/symlink8 $N0 nolock;
|
|
-
|
|
-##Similar check for udp mount
|
|
-$CLI volume stop $V0
|
|
-TEST $CLI volume set $V0 nfs.mount-udp on
|
|
-$CLI volume start $V0
|
|
-
|
|
-## Wait for volume to register with rpc.mountd
|
|
-EXPECT_WITHIN $NFS_EXPORT_TIMEOUT "1" is_nfs_export_available;
|
|
-
|
|
-## Mount and umount NFS via directory
|
|
-TEST mount_nfs $H0:/$V0/dir1 $N0 nolock,mountproto=udp,proto=tcp;
|
|
-EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" umount_nfs $N0
|
|
-
|
|
-## Mount and umount NFS via symlink1
|
|
-TEST mount_nfs $H0:/$V0/symlink1 $N0 nolock,mountproto=udp,proto=tcp;
|
|
-EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" umount_nfs $N0
|
|
-
|
|
-## Mount and umount NFS via symlink2
|
|
-TEST mount_nfs $H0:/$V0/dir2/symlink2 $N0 nolock,mountproto=udp,proto=tcp;
|
|
-EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" umount_nfs $N0
|
|
-
|
|
-## Mount NFS via symlink3 should fail
|
|
-TEST ! mount_nfs $H0:/$V0/symlink3 $N0 nolock,mountproto=udp,proto=tcp;
|
|
-
|
|
-## Mount and umount NFS via symlink4
|
|
-TEST mount_nfs $H0:/$V0/symlink4 $N0 nolock,mountproto=udp,proto=tcp;
|
|
-EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" umount_nfs $N0
|
|
-
|
|
-## Mount NFS via symlink5 should fail
|
|
-TEST ! mount_nfs $H0:/$V0/symlink5 $N0 nolock,mountproto=udp,proto=tcp;
|
|
-
|
|
-## Mount NFS via symlink6 should fail
|
|
-TEST ! mount_nfs $H0:/$V0/symlink6 $N0 nolock,mountproto=udp,proto=tcp;
|
|
-
|
|
-##symlink7 is not check here, because in udp mount ../../ resolves into root '/'
|
|
-
|
|
-## Mount NFS via symlink8 should fail
|
|
-TEST ! mount_nfs $H0:/$V0/symlink8 $N0 nolock,mountproto=udp,proto=tcp;
|
|
-
|
|
-rm -rf $H0:$B0/
|
|
-cleanup;
|
|
diff --git a/tests/bugs/nfs/bug-1161092-nfs-acls.t b/tests/bugs/nfs/bug-1161092-nfs-acls.t
|
|
deleted file mode 100644
|
|
index 45a22e7..0000000
|
|
--- a/tests/bugs/nfs/bug-1161092-nfs-acls.t
|
|
+++ /dev/null
|
|
@@ -1,39 +0,0 @@
|
|
-#!/bin/bash
|
|
-
|
|
-. $(dirname $0)/../../include.rc
|
|
-. $(dirname $0)/../../nfs.rc
|
|
-
|
|
-#G_TESTDEF_TEST_STATUS_CENTOS6=NFS_TEST
|
|
-
|
|
-cleanup;
|
|
-
|
|
-TEST glusterd
|
|
-TEST pidof glusterd
|
|
-TEST $CLI volume info
|
|
-
|
|
-TEST $CLI volume create $V0 $H0:$B0/brick1;
|
|
-EXPECT 'Created' volinfo_field $V0 'Status';
|
|
-TEST $CLI volume set $V0 nfs.disable false
|
|
-
|
|
-TEST $CLI volume start $V0;
|
|
-EXPECT 'Started' volinfo_field $V0 'Status';
|
|
-
|
|
-EXPECT_WITHIN $NFS_EXPORT_TIMEOUT 1 is_nfs_export_available
|
|
-TEST mount_nfs $H0:/$V0 $N0
|
|
-
|
|
-TEST touch $N0/file1
|
|
-TEST chmod 700 $N0/file1
|
|
-TEST getfacl $N0/file1
|
|
-
|
|
-TEST $CLI volume set $V0 root-squash on
|
|
-TEST getfacl $N0/file1
|
|
-
|
|
-TEST umount_nfs $H0:/$V0 $N0
|
|
-TEST mount_nfs $H0:/$V0 $N0
|
|
-TEST getfacl $N0/file1
|
|
-
|
|
-## Before killing daemon to avoid deadlocks
|
|
-umount_nfs $N0
|
|
-
|
|
-cleanup;
|
|
-
|
|
diff --git a/tests/bugs/nfs/bug-1166862.t b/tests/bugs/nfs/bug-1166862.t
|
|
deleted file mode 100755
|
|
index c4f51a2..0000000
|
|
--- a/tests/bugs/nfs/bug-1166862.t
|
|
+++ /dev/null
|
|
@@ -1,69 +0,0 @@
|
|
-#!/bin/bash
|
|
-#
|
|
-# When nfs.mount-rmtab is disabled, it should not get updated.
|
|
-#
|
|
-# Based on: bug-904065.t
|
|
-#
|
|
-
|
|
-#G_TESTDEF_TEST_STATUS_CENTOS6=NFS_TEST
|
|
-
|
|
-# count the lines of a file, return 0 if the file does not exist
|
|
-function count_lines()
|
|
-{
|
|
- if [ -n "$1" ]
|
|
- then
|
|
- $@ 2>/dev/null | wc -l
|
|
- else
|
|
- echo 0
|
|
- fi
|
|
-}
|
|
-
|
|
-
|
|
-. $(dirname $0)/../../include.rc
|
|
-. $(dirname $0)/../../nfs.rc
|
|
-. $(dirname $0)/../../volume.rc
|
|
-
|
|
-cleanup
|
|
-
|
|
-TEST glusterd
|
|
-TEST pidof glusterd
|
|
-
|
|
-TEST $CLI volume create $V0 $H0:$B0/brick1
|
|
-EXPECT 'Created' volinfo_field $V0 'Status'
|
|
-TEST $CLI volume set $V0 nfs.disable false
|
|
-
|
|
-TEST $CLI volume start $V0;
|
|
-EXPECT 'Started' volinfo_field $V0 'Status'
|
|
-
|
|
-# glusterfs/nfs needs some time to start up in the background
|
|
-EXPECT_WITHIN $NFS_EXPORT_TIMEOUT 1 is_nfs_export_available
|
|
-
|
|
-# disable the rmtab by settting it to the magic "/-" value
|
|
-TEST $CLI volume set $V0 nfs.mount-rmtab /-
|
|
-
|
|
-# before mounting the rmtab should be empty
|
|
-EXPECT '0' count_lines cat $GLUSTERD_WORKDIR/nfs/rmtab
|
|
-
|
|
-TEST mount_nfs $H0:/$V0 $N0 nolock
|
|
-EXPECT '0' count_lines cat $GLUSTERD_WORKDIR/nfs/rmtab
|
|
-
|
|
-# showmount should list one client
|
|
-EXPECT '1' count_lines showmount --no-headers $H0
|
|
-
|
|
-# unmount
|
|
-EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $N0
|
|
-
|
|
-# after resetting the option, the rmtab should get updated again
|
|
-TEST $CLI volume reset $V0 nfs.mount-rmtab
|
|
-
|
|
-# before mounting the rmtab should be empty
|
|
-EXPECT '0' count_lines cat $GLUSTERD_WORKDIR/nfs/rmtab
|
|
-
|
|
-TEST mount_nfs $H0:/$V0 $N0 nolock
|
|
-EXPECT '2' count_lines cat $GLUSTERD_WORKDIR/nfs/rmtab
|
|
-
|
|
-# removing a mount
|
|
-EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $N0
|
|
-EXPECT '0' count_lines cat $GLUSTERD_WORKDIR/nfs/rmtab
|
|
-
|
|
-cleanup
|
|
diff --git a/tests/bugs/nfs/bug-1210338.c b/tests/bugs/nfs/bug-1210338.c
|
|
deleted file mode 100644
|
|
index d409924..0000000
|
|
--- a/tests/bugs/nfs/bug-1210338.c
|
|
+++ /dev/null
|
|
@@ -1,31 +0,0 @@
|
|
-#include <stdio.h>
|
|
-#include <stdlib.h>
|
|
-#include <unistd.h>
|
|
-#include <string.h>
|
|
-#include <errno.h>
|
|
-#include <sys/types.h>
|
|
-#include <fcntl.h>
|
|
-#include <sys/stat.h>
|
|
-
|
|
-int
|
|
-main(int argc, char *argv[])
|
|
-{
|
|
- int ret = -1;
|
|
- int fd = -1;
|
|
-
|
|
- 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;
|
|
- }
|
|
-
|
|
- ret = 0;
|
|
-
|
|
-out:
|
|
- if (fd > 0)
|
|
- close(fd);
|
|
-
|
|
- return ret;
|
|
-}
|
|
diff --git a/tests/bugs/nfs/bug-1210338.t b/tests/bugs/nfs/bug-1210338.t
|
|
deleted file mode 100644
|
|
index b5c9245..0000000
|
|
--- a/tests/bugs/nfs/bug-1210338.t
|
|
+++ /dev/null
|
|
@@ -1,30 +0,0 @@
|
|
-#!/bin/bash
|
|
-
|
|
-. $(dirname $0)/../../include.rc
|
|
-. $(dirname $0)/../../volume.rc
|
|
-. $(dirname $0)/../../nfs.rc
|
|
-
|
|
-#G_TESTDEF_TEST_STATUS_CENTOS6=NFS_TEST
|
|
-
|
|
-cleanup;
|
|
-
|
|
-NFS_SOURCE=$(dirname $0)/bug-1210338.c
|
|
-NFS_EXEC=$(dirname $0)/excl_create
|
|
-
|
|
-TEST glusterd
|
|
-TEST pidof glusterd
|
|
-
|
|
-TEST $CLI volume create $V0 $H0:$B0/$V0
|
|
-TEST $CLI volume set $V0 nfs.disable false
|
|
-TEST $CLI volume start $V0
|
|
-EXPECT_WITHIN $NFS_EXPORT_TIMEOUT "1" is_nfs_export_available;
|
|
-TEST mount_nfs $H0:/$V0 $N0 nolock
|
|
-
|
|
-build_tester $NFS_SOURCE -o $NFS_EXEC
|
|
-TEST [ -e $NFS_EXEC ]
|
|
-
|
|
-TEST $NFS_EXEC $N0/my_file
|
|
-
|
|
-rm -f $NFS_EXEC;
|
|
-
|
|
-cleanup
|
|
diff --git a/tests/bugs/nfs/bug-1302948.t b/tests/bugs/nfs/bug-1302948.t
|
|
deleted file mode 100755
|
|
index a2fb0e6..0000000
|
|
--- a/tests/bugs/nfs/bug-1302948.t
|
|
+++ /dev/null
|
|
@@ -1,13 +0,0 @@
|
|
-#!/bin/bash
|
|
-# TEST the nfs.rdirplus option
|
|
-. $(dirname $0)/../../include.rc
|
|
-
|
|
-cleanup
|
|
-TEST glusterd
|
|
-TEST pidof glusterd
|
|
-
|
|
-TEST $CLI volume create $V0 $H0:$B0/$V0
|
|
-TEST $CLI volume start $V0
|
|
-TEST $CLI volume set $V0 nfs.rdirplus off
|
|
-TEST $CLI volume set $V0 nfs.rdirplus on
|
|
-cleanup
|
|
diff --git a/tests/bugs/nfs/bug-847622.t b/tests/bugs/nfs/bug-847622.t
|
|
deleted file mode 100755
|
|
index 5ccee72..0000000
|
|
--- a/tests/bugs/nfs/bug-847622.t
|
|
+++ /dev/null
|
|
@@ -1,39 +0,0 @@
|
|
-#!/bin/bash
|
|
-
|
|
-. $(dirname $0)/../../include.rc
|
|
-. $(dirname $0)/../../nfs.rc
|
|
-. $(dirname $0)/../../volume.rc
|
|
-
|
|
-#G_TESTDEF_TEST_STATUS_CENTOS6=NFS_TEST
|
|
-
|
|
-case $OSTYPE in
|
|
-NetBSD)
|
|
- echo "Skip test on ACL which are not available on NetBSD" >&2
|
|
- SKIP_TESTS
|
|
- exit 0
|
|
- ;;
|
|
-*)
|
|
- ;;
|
|
-esac
|
|
-
|
|
-cleanup;
|
|
-
|
|
-TEST glusterd
|
|
-TEST pidof glusterd
|
|
-TEST $CLI volume create $V0 $H0:$B0/brick0
|
|
-TEST $CLI volume set $V0 nfs.disable false
|
|
-TEST $CLI volume start $V0
|
|
-
|
|
-EXPECT_WITHIN $NFS_EXPORT_TIMEOUT "1" is_nfs_export_available;
|
|
-TEST mount_nfs $H0:/$V0 $N0 nolock
|
|
-cd $N0
|
|
-
|
|
-# simple getfacl setfacl commands
|
|
-TEST touch testfile
|
|
-TEST setfacl -m u:14:r testfile
|
|
-TEST getfacl testfile
|
|
-
|
|
-cd
|
|
-EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $N0
|
|
-cleanup
|
|
-
|
|
diff --git a/tests/bugs/nfs/bug-877885.t b/tests/bugs/nfs/bug-877885.t
|
|
deleted file mode 100755
|
|
index dca315a..0000000
|
|
--- a/tests/bugs/nfs/bug-877885.t
|
|
+++ /dev/null
|
|
@@ -1,39 +0,0 @@
|
|
-#!/bin/bash
|
|
-
|
|
-. $(dirname $0)/../../include.rc
|
|
-. $(dirname $0)/../../nfs.rc
|
|
-. $(dirname $0)/../../volume.rc
|
|
-
|
|
-#G_TESTDEF_TEST_STATUS_CENTOS6=NFS_TEST
|
|
-
|
|
-cleanup;
|
|
-
|
|
-TEST glusterd
|
|
-TEST pidof glusterd
|
|
-TEST $CLI volume create $V0 replica 2 $H0:$B0/brick0 $H0:$B0/brick1
|
|
-TEST $CLI volume set $V0 nfs.disable false
|
|
-TEST $CLI volume start $V0
|
|
-
|
|
-## Mount FUSE with caching disabled
|
|
-TEST glusterfs --entry-timeout=0 --attribute-timeout=0 -s $H0 --volfile-id $V0 \
|
|
-$M0;
|
|
-
|
|
-TEST touch $M0/file
|
|
-TEST mkdir $M0/dir
|
|
-
|
|
-EXPECT_WITHIN $NFS_EXPORT_TIMEOUT "1" is_nfs_export_available;
|
|
-TEST mount_nfs $H0:/$V0 $N0 nolock
|
|
-cd $N0
|
|
-
|
|
-rm -rf * &
|
|
-
|
|
-TEST mount_nfs $H0:/$V0 $N1 retry=0,nolock;
|
|
-
|
|
-cd;
|
|
-
|
|
-kill %1;
|
|
-
|
|
-EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $N0
|
|
-EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $N1
|
|
-
|
|
-cleanup
|
|
diff --git a/tests/bugs/nfs/bug-904065.t b/tests/bugs/nfs/bug-904065.t
|
|
deleted file mode 100755
|
|
index 0eba86e..0000000
|
|
--- a/tests/bugs/nfs/bug-904065.t
|
|
+++ /dev/null
|
|
@@ -1,100 +0,0 @@
|
|
-#!/bin/bash
|
|
-#
|
|
-# This test does not use 'showmount' from the nfs-utils package, it would
|
|
-# require setting up a portmapper (either rpcbind or portmap, depending on the
|
|
-# Linux distribution used for testing). The persistancy of the rmtab should not
|
|
-# affect the current showmount outputs, so existing regression tests should be
|
|
-# sufficient.
|
|
-#
|
|
-
|
|
-#G_TESTDEF_TEST_STATUS_CENTOS6=NFS_TEST
|
|
-
|
|
-# count the lines of a file, return 0 if the file does not exist
|
|
-function count_lines()
|
|
-{
|
|
- if [ -e "$1" ]
|
|
- then
|
|
- wc -l < $1
|
|
- else
|
|
- echo 0
|
|
- fi
|
|
-}
|
|
-
|
|
-
|
|
-. $(dirname $0)/../../include.rc
|
|
-. $(dirname $0)/../../nfs.rc
|
|
-. $(dirname $0)/../../volume.rc
|
|
-
|
|
-cleanup
|
|
-
|
|
-TEST glusterd
|
|
-TEST pidof glusterd
|
|
-
|
|
-TEST $CLI volume create $V0 $H0:$B0/brick1
|
|
-EXPECT 'Created' volinfo_field $V0 'Status'
|
|
-TEST $CLI volume set $V0 nfs.disable false
|
|
-
|
|
-TEST $CLI volume start $V0;
|
|
-EXPECT 'Started' volinfo_field $V0 'Status'
|
|
-
|
|
-# glusterfs/nfs needs some time to start up in the background
|
|
-EXPECT_WITHIN $NFS_EXPORT_TIMEOUT 1 is_nfs_export_available
|
|
-
|
|
-# before mounting the rmtab should be empty
|
|
-EXPECT '0' count_lines $GLUSTERD_WORKDIR/nfs/rmtab
|
|
-
|
|
-TEST mount_nfs $H0:/$V0 $N0 nolock
|
|
-# the output would looks similar to:
|
|
-#
|
|
-# hostname-0=172.31.122.104
|
|
-# mountpoint-0=/ufo
|
|
-#
|
|
-EXPECT '2' count_lines $GLUSTERD_WORKDIR/nfs/rmtab
|
|
-
|
|
-# duplicate mounts should not be recorded (client could have crashed)
|
|
-TEST mount_nfs $H0:/$V0 $N1 nolock
|
|
-EXPECT '2' count_lines $GLUSTERD_WORKDIR/nfs/rmtab
|
|
-
|
|
-# removing a mount should (even if there are two) should remove the entry
|
|
-EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $N1
|
|
-EXPECT '0' count_lines $GLUSTERD_WORKDIR/nfs/rmtab
|
|
-
|
|
-# unmounting the other mount should work flawlessly
|
|
-EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $N0
|
|
-EXPECT '0' count_lines $GLUSTERD_WORKDIR/nfs/rmtab
|
|
-
|
|
-TEST glusterfs --entry-timeout=0 --attribute-timeout=0 --volfile-server=$H0 --volfile-id=$V0 $M0
|
|
-
|
|
-# we'll create a fake rmtab here, similar to how an other storage server would do
|
|
-# using an invalid IP address to prevent (unlikely) collisions on the test-machine
|
|
-cat << EOF > $M0/rmtab
|
|
-hostname-0=127.0.0.256
|
|
-mountpoint-0=/ufo
|
|
-EOF
|
|
-EXPECT '2' count_lines $M0/rmtab
|
|
-
|
|
-# reconfigure merges the rmtab with the one on the volume
|
|
-TEST gluster volume set $V0 nfs.mount-rmtab $M0/rmtab
|
|
-
|
|
-# glusterfs/nfs needs some time to restart
|
|
-EXPECT_WITHIN $NFS_EXPORT_TIMEOUT 1 is_nfs_export_available
|
|
-
|
|
-# Apparently "is_nfs_export_available" might return even if the export is
|
|
-# not, in fact, available. (eyeroll) Give it a bit of extra time.
|
|
-#
|
|
-# TBD: fix the broken shell function instead of working around it here
|
|
-sleep 5
|
|
-
|
|
-# a new mount should be added to the rmtab, not overwrite exiting ones
|
|
-TEST mount_nfs $H0:/$V0 $N0 nolock
|
|
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT '4' count_lines $M0/rmtab
|
|
-
|
|
-EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $N0
|
|
-EXPECT '2' count_lines $M0/rmtab
|
|
-
|
|
-# TODO: nfs/reconfigure() is never called and is therefor disabled. When the
|
|
-# NFS-server supports reloading and does not get restarted anymore, we should
|
|
-# add a test that includes the merging of entries in the old rmtab with the new
|
|
-# rmtab.
|
|
-
|
|
-cleanup
|
|
diff --git a/tests/bugs/nfs/bug-915280.t b/tests/bugs/nfs/bug-915280.t
|
|
deleted file mode 100755
|
|
index bd27915..0000000
|
|
--- a/tests/bugs/nfs/bug-915280.t
|
|
+++ /dev/null
|
|
@@ -1,54 +0,0 @@
|
|
-#!/bin/bash
|
|
-
|
|
-. $(dirname $0)/../../include.rc
|
|
-. $(dirname $0)/../../volume.rc
|
|
-. $(dirname $0)/../../nfs.rc
|
|
-
|
|
-#G_TESTDEF_TEST_STATUS_CENTOS6=NFS_TEST
|
|
-
|
|
-cleanup;
|
|
-
|
|
-TEST glusterd
|
|
-TEST pidof glusterd
|
|
-
|
|
-function volinfo_field()
|
|
-{
|
|
- local vol=$1;
|
|
- local field=$2;
|
|
-
|
|
- $CLI volume info $vol | grep "^$field: " | sed 's/.*: //';
|
|
-}
|
|
-
|
|
-TEST $CLI volume create $V0 $H0:$B0/brick1 $H0:$B0/brick2;
|
|
-EXPECT 'Created' volinfo_field $V0 'Status';
|
|
-TEST $CLI volume set $V0 nfs.disable false
|
|
-
|
|
-TEST $CLI volume start $V0;
|
|
-EXPECT 'Started' volinfo_field $V0 'Status';
|
|
-
|
|
-MOUNTDIR=$N0;
|
|
-EXPECT_WITHIN $NFS_EXPORT_TIMEOUT "1" is_nfs_export_available;
|
|
-TEST mount_nfs $H0:/$V0 $N0 nolock,timeo=30,retrans=1
|
|
-TEST touch $N0/testfile
|
|
-
|
|
-TEST $CLI volume set $V0 debug.error-gen client
|
|
-TEST $CLI volume set $V0 debug.error-fops stat
|
|
-TEST $CLI volume set $V0 debug.error-failure 100
|
|
-
|
|
-EXPECT_WITHIN $NFS_EXPORT_TIMEOUT "1" is_nfs_export_available;
|
|
-
|
|
-pid_file=$(read_nfs_pidfile);
|
|
-
|
|
-getfacl $N0/testfile 2>/dev/null
|
|
-
|
|
-nfs_pid=$(get_nfs_pid);
|
|
-if [ ! $nfs_pid ]
|
|
-then
|
|
- nfs_pid=0;
|
|
-fi
|
|
-
|
|
-TEST [ $nfs_pid -eq $pid_file ]
|
|
-
|
|
-EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $MOUNTDIR
|
|
-
|
|
-cleanup;
|
|
diff --git a/tests/bugs/nfs/bug-970070.t b/tests/bugs/nfs/bug-970070.t
|
|
deleted file mode 100755
|
|
index 61be484..0000000
|
|
--- a/tests/bugs/nfs/bug-970070.t
|
|
+++ /dev/null
|
|
@@ -1,13 +0,0 @@
|
|
-#!/bin/bash
|
|
-# TEST the nfs.acl option
|
|
-. $(dirname $0)/../../include.rc
|
|
-
|
|
-cleanup
|
|
-TEST glusterd
|
|
-TEST pidof glusterd
|
|
-
|
|
-TEST $CLI volume create $V0 $H0:$B0/$V0
|
|
-TEST $CLI volume start $V0
|
|
-TEST $CLI volume set $V0 nfs.acl off
|
|
-TEST $CLI volume set $V0 nfs.acl on
|
|
-cleanup
|
|
diff --git a/tests/bugs/nfs/bug-974972.t b/tests/bugs/nfs/bug-974972.t
|
|
deleted file mode 100755
|
|
index 975c46f..0000000
|
|
--- a/tests/bugs/nfs/bug-974972.t
|
|
+++ /dev/null
|
|
@@ -1,41 +0,0 @@
|
|
-#!/bin/bash
|
|
-
|
|
-. $(dirname $0)/../../include.rc
|
|
-. $(dirname $0)/../../volume.rc
|
|
-. $(dirname $0)/../../nfs.rc
|
|
-
|
|
-#G_TESTDEF_TEST_STATUS_CENTOS6=NFS_TEST
|
|
-
|
|
-#This script checks that nfs mount does not fail lookup on files with split-brain
|
|
-cleanup;
|
|
-
|
|
-TEST glusterd
|
|
-TEST pidof glusterd
|
|
-TEST $CLI volume create $V0 replica 2 $H0:$B0/${V0}{0,1}
|
|
-TEST $CLI volume set $V0 self-heal-daemon off
|
|
-TEST $CLI volume set $V0 cluster.eager-lock off
|
|
-TEST $CLI volume set $V0 nfs.disable false
|
|
-TEST $CLI volume start $V0
|
|
-EXPECT_WITHIN $NFS_EXPORT_TIMEOUT "1" is_nfs_export_available;
|
|
-TEST mount_nfs $H0:/$V0 $N0
|
|
-TEST touch $N0/1
|
|
-TEST kill_brick ${V0} ${H0} ${B0}/${V0}1
|
|
-echo abc > $N0/1
|
|
-TEST $CLI volume start $V0 force
|
|
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT "Y" nfs_up_status
|
|
-EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_in_nfs $V0 0
|
|
-EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_in_nfs $V0 1
|
|
-
|
|
-TEST kill_brick ${V0} ${H0} ${B0}/${V0}0
|
|
-echo def > $N0/1
|
|
-TEST $CLI volume start $V0 force
|
|
-EXPECT_WITHIN $PROCESS_UP_TIMEOUT "Y" nfs_up_status
|
|
-EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_in_nfs $V0 0
|
|
-EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" afr_child_up_status_in_nfs $V0 1
|
|
-
|
|
-#Lookup should not fail
|
|
-TEST ls $N0/1
|
|
-TEST ! cat $N0/1
|
|
-
|
|
-EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $N0
|
|
-cleanup
|
|
diff --git a/tests/bugs/nfs/showmount-many-clients.t b/tests/bugs/nfs/showmount-many-clients.t
|
|
deleted file mode 100644
|
|
index f1b6859..0000000
|
|
--- a/tests/bugs/nfs/showmount-many-clients.t
|
|
+++ /dev/null
|
|
@@ -1,41 +0,0 @@
|
|
-#!/bin/bash
|
|
-#
|
|
-# The nfs.rpc-auth-allow volume option is used to generate the list of clients
|
|
-# that are displayed as able to mount the export. The "group" in the export
|
|
-# should be a list of all clients, identified by "name". In previous versions,
|
|
-# the "name" was the copied string from nfs.rpc-auth-allow. This is not
|
|
-# correct, as the volume option should be parsed and split into different
|
|
-# groups.
|
|
-#
|
|
-# When the single string is passed, this testcase fails when the
|
|
-# nfs.rpc-auth-allow volume option is longer than 256 characters. By splitting
|
|
-# the groups into their own structures, this testcase passes.
|
|
-#
|
|
-
|
|
-. $(dirname $0)/../../include.rc
|
|
-. $(dirname $0)/../../nfs.rc
|
|
-. $(dirname $0)/../../volume.rc
|
|
-
|
|
-cleanup
|
|
-
|
|
-TEST glusterd
|
|
-TEST pidof glusterd
|
|
-
|
|
-TEST $CLI volume create $V0 $H0:$B0/brick1
|
|
-EXPECT 'Created' volinfo_field $V0 'Status'
|
|
-TEST $CLI volume set $V0 nfs.disable false
|
|
-
|
|
-CLIENTS=$(echo 127.0.0.{1..128} | tr ' ' ,)
|
|
-TEST $CLI volume set $V0 nfs.rpc-auth-allow ${CLIENTS}
|
|
-TEST $CLI volume set $V0 nfs.rpc-auth-reject all
|
|
-
|
|
-TEST $CLI volume start $V0;
|
|
-EXPECT 'Started' volinfo_field $V0 'Status'
|
|
-
|
|
-# glusterfs/nfs needs some time to start up in the background
|
|
-EXPECT_WITHIN $NFS_EXPORT_TIMEOUT 1 is_nfs_export_available
|
|
-
|
|
-# showmount should not timeout (no reply is sent on error)
|
|
-TEST showmount -e $H0
|
|
-
|
|
-cleanup
|
|
diff --git a/tests/bugs/nfs/socket-as-fifo.py b/tests/bugs/nfs/socket-as-fifo.py
|
|
deleted file mode 100755
|
|
index eb507e1..0000000
|
|
--- a/tests/bugs/nfs/socket-as-fifo.py
|
|
+++ /dev/null
|
|
@@ -1,33 +0,0 @@
|
|
-#
|
|
-# Create a unix domain socket and test if it is a socket (and not a fifo/pipe).
|
|
-#
|
|
-# Author: Niels de Vos <ndevos@redhat.com>
|
|
-#
|
|
-
|
|
-from __future__ import print_function
|
|
-import os
|
|
-import stat
|
|
-import sys
|
|
-import socket
|
|
-
|
|
-ret = 1
|
|
-
|
|
-if len(sys.argv) != 2:
|
|
- print('Usage: %s <socket>' % (sys.argv[0]))
|
|
- sys.exit(ret)
|
|
-
|
|
-path = sys.argv[1]
|
|
-
|
|
-sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
|
|
-sock.bind(path)
|
|
-
|
|
-stbuf = os.stat(path)
|
|
-mode = stbuf.st_mode
|
|
-
|
|
-if stat.S_ISSOCK(mode):
|
|
- ret = 0
|
|
-
|
|
-sock.close()
|
|
-os.unlink(path)
|
|
-
|
|
-sys.exit(ret)
|
|
diff --git a/tests/bugs/nfs/socket-as-fifo.t b/tests/bugs/nfs/socket-as-fifo.t
|
|
deleted file mode 100644
|
|
index d9b9e95..0000000
|
|
--- a/tests/bugs/nfs/socket-as-fifo.t
|
|
+++ /dev/null
|
|
@@ -1,25 +0,0 @@
|
|
-#!/bin/bash
|
|
-
|
|
-. $(dirname $0)/../../include.rc
|
|
-. $(dirname $0)/../../volume.rc
|
|
-. $(dirname $0)/../../nfs.rc
|
|
-
|
|
-#G_TESTDEF_TEST_STATUS_CENTOS6=NFS_TEST
|
|
-
|
|
-cleanup;
|
|
-
|
|
-TEST glusterd
|
|
-TEST pidof glusterd
|
|
-
|
|
-TEST $CLI volume create $V0 $H0:$B0/$V0
|
|
-TEST $CLI volume set $V0 nfs.disable false
|
|
-TEST $CLI volume start $V0
|
|
-EXPECT_WITHIN $NFS_EXPORT_TIMEOUT "1" is_nfs_export_available;
|
|
-TEST mount_nfs $H0:/$V0 $N0 nolock
|
|
-
|
|
-# this is the actual test
|
|
-TEST $PYTHON $(dirname $0)/socket-as-fifo.py $N0/not-a-fifo.socket
|
|
-
|
|
-TEST umount_nfs $N0
|
|
-
|
|
-cleanup
|
|
diff --git a/tests/bugs/nfs/subdir-trailing-slash.t b/tests/bugs/nfs/subdir-trailing-slash.t
|
|
deleted file mode 100644
|
|
index 6a11487..0000000
|
|
--- a/tests/bugs/nfs/subdir-trailing-slash.t
|
|
+++ /dev/null
|
|
@@ -1,32 +0,0 @@
|
|
-#!/bin/bash
|
|
-#
|
|
-# Verify that mounting a subdir over NFS works, even with a trailing /
|
|
-#
|
|
-# For example:
|
|
-# mount -t nfs server.example.com:/volume/subdir/
|
|
-#
|
|
-
|
|
-. $(dirname $0)/../../include.rc
|
|
-. $(dirname $0)/../../volume.rc
|
|
-. $(dirname $0)/../../nfs.rc
|
|
-
|
|
-#G_TESTDEF_TEST_STATUS_CENTOS6=NFS_TEST
|
|
-
|
|
-cleanup;
|
|
-TEST glusterd
|
|
-TEST pidof glusterd
|
|
-
|
|
-TEST $CLI volume create $V0 $H0:$B0/$V0
|
|
-TEST $CLI volume set $V0 nfs.disable false
|
|
-
|
|
-TEST $CLI volume start $V0
|
|
-EXPECT_WITHIN $NFS_EXPORT_TIMEOUT "1" is_nfs_export_available
|
|
-
|
|
-TEST mount_nfs $H0:/$V0 $N0 nolock
|
|
-TEST mkdir -p $N0/subdir
|
|
-EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $N0
|
|
-
|
|
-TEST mount_nfs $H0:/$V0/subdir/ $N0 nolock
|
|
-EXPECT_WITHIN $UMOUNT_TIMEOUT "Y" force_umount $N0
|
|
-
|
|
-cleanup
|
|
diff --git a/tests/bugs/nfs/zero-atime.t b/tests/bugs/nfs/zero-atime.t
|
|
deleted file mode 100755
|
|
index 2a94009..0000000
|
|
--- a/tests/bugs/nfs/zero-atime.t
|
|
+++ /dev/null
|
|
@@ -1,33 +0,0 @@
|
|
-#!/bin/bash
|
|
-#
|
|
-# posix_do_utimes() sets atime and mtime to the values in the passed IATT. If
|
|
-# not set, these values are 0 and cause a atime/mtime set to the Epoch.
|
|
-#
|
|
-
|
|
-. $(dirname $0)/../../include.rc
|
|
-. $(dirname $0)/../../volume.rc
|
|
-. $(dirname $0)/../../nfs.rc
|
|
-
|
|
-#G_TESTDEF_TEST_STATUS_CENTOS6=NFS_TEST
|
|
-
|
|
-cleanup
|
|
-
|
|
-TEST glusterd
|
|
-TEST pidof glusterd
|
|
-
|
|
-TEST $CLI volume create $V0 $H0:$B0/$V0
|
|
-TEST $CLI volume set $V0 nfs.disable false
|
|
-TEST $CLI volume start $V0
|
|
-EXPECT_WITHIN $NFS_EXPORT_TIMEOUT "1" is_nfs_export_available;
|
|
-TEST mount_nfs $H0:/$V0 $N0 nolock
|
|
-
|
|
-# create a file for testing
|
|
-TEST dd if=/dev/urandom of=$M0/small count=1 bs=1024k
|
|
-
|
|
-# timezone in UTC results in atime=0 if not set correctly
|
|
-TEST TZ=UTC dd if=/dev/urandom of=$M0/small bs=64k count=1 conv=nocreat
|
|
-TEST [ "$(stat --format=%X $M0/small)" != "0" ]
|
|
-
|
|
-TEST rm $M0/small
|
|
-
|
|
-cleanup
|
|
diff --git a/tests/bugs/rpc/bug-954057.t b/tests/bugs/rpc/bug-954057.t
|
|
index 65af274..9ad0ab2 100755
|
|
--- a/tests/bugs/rpc/bug-954057.t
|
|
+++ b/tests/bugs/rpc/bug-954057.t
|
|
@@ -25,7 +25,15 @@ TEST $GFS --volfile-id=/$V0 --volfile-server=$H0 $M0
|
|
|
|
TEST mkdir $M0/dir
|
|
TEST mkdir $M0/nobody
|
|
-TEST chown nfsnobody:nfsnobody $M0/nobody
|
|
+grep nfsnobody /etc/passwd > /dev/nul
|
|
+if [ $? -eq 1 ]; then
|
|
+usr=nobody
|
|
+grp=nobody
|
|
+else
|
|
+usr=nfsnobody
|
|
+grp=nfsnobody
|
|
+fi
|
|
+TEST chown $usr:$grp $M0/nobody
|
|
TEST `echo "file" >> $M0/file`
|
|
TEST cp $M0/file $M0/new
|
|
TEST chmod 700 $M0/new
|
|
diff --git a/tests/bugs/shard/bug-1272986.t b/tests/bugs/shard/bug-1272986.t
|
|
index 7628870..66e896a 100644
|
|
--- a/tests/bugs/shard/bug-1272986.t
|
|
+++ b/tests/bugs/shard/bug-1272986.t
|
|
@@ -16,16 +16,16 @@ TEST glusterfs --volfile-id=$V0 --volfile-server=$H0 $M0
|
|
TEST glusterfs --volfile-id=$V0 --volfile-server=$H0 $M1
|
|
|
|
# Write some data into a file, such that its size crosses the shard block size.
|
|
-TEST dd if=/dev/zero of=$M1/file bs=1M count=5 conv=notrunc
|
|
+TEST dd if=/dev/urandom of=$M1/file bs=1M count=5 conv=notrunc oflag=direct
|
|
|
|
md5sum1_reader=$(md5sum $M0/file | awk '{print $1}')
|
|
|
|
EXPECT "$md5sum1_reader" echo `md5sum $M1/file | awk '{print $1}'`
|
|
|
|
# Append some more data into the file.
|
|
-TEST `echo "abcdefg" >> $M1/file`
|
|
+TEST dd if=/dev/urandom of=$M1/file bs=256k count=1 conv=notrunc oflag=direct
|
|
|
|
-md5sum2_reader=$(md5sum $M0/file | awk '{print $1}')
|
|
+md5sum2_reader=$(dd if=$M0/file iflag=direct bs=256k| md5sum | awk '{print $1}')
|
|
|
|
# Test to see if the reader refreshes its cache correctly as part of the reads
|
|
# triggered through md5sum. If it does, then the md5sum on the reader and writer
|
|
diff --git a/tests/bugs/transport/bug-873367.t b/tests/bugs/transport/bug-873367.t
|
|
index d4c0702..8070bc1 100755
|
|
--- a/tests/bugs/transport/bug-873367.t
|
|
+++ b/tests/bugs/transport/bug-873367.t
|
|
@@ -13,7 +13,7 @@ rm -f $SSL_BASE/glusterfs.*
|
|
mkdir -p $B0/1
|
|
mkdir -p $M0
|
|
|
|
-TEST openssl genrsa -out $SSL_KEY 1024
|
|
+TEST openssl genrsa -out $SSL_KEY 2048
|
|
TEST openssl req -new -x509 -key $SSL_KEY -subj /CN=Anyone -out $SSL_CERT
|
|
ln $SSL_CERT $SSL_CA
|
|
|
|
diff --git a/tests/features/ssl-authz.t b/tests/features/ssl-authz.t
|
|
index 3cb45b5..cae010c 100755
|
|
--- a/tests/features/ssl-authz.t
|
|
+++ b/tests/features/ssl-authz.t
|
|
@@ -41,7 +41,7 @@ function valid_ciphers {
|
|
-e '/:$/s///'
|
|
}
|
|
|
|
-TEST openssl genrsa -out $SSL_KEY 1024
|
|
+TEST openssl genrsa -out $SSL_KEY 2048
|
|
TEST openssl req -new -x509 -key $SSL_KEY -subj /CN=Anyone -out $SSL_CERT
|
|
ln $SSL_CERT $SSL_CA
|
|
|
|
diff --git a/tests/features/ssl-ciphers.t b/tests/features/ssl-ciphers.t
|
|
index 7e1e199..e4bcdf5 100644
|
|
--- a/tests/features/ssl-ciphers.t
|
|
+++ b/tests/features/ssl-ciphers.t
|
|
@@ -33,18 +33,26 @@ wait_mount() {
|
|
openssl_connect() {
|
|
ssl_opt="-verify 3 -verify_return_error -CAfile $SSL_CA"
|
|
ssl_opt="$ssl_opt -crl_check_all -CApath $TMPDIR"
|
|
- #echo openssl s_client $ssl_opt $@ > /dev/tty
|
|
- #read -p "Continue? " nothing
|
|
- CIPHER=`echo "" |
|
|
- openssl s_client $ssl_opt $@ 2>/dev/null |
|
|
- awk '/^ Cipher/{print $3}'`
|
|
- if [ "x${CIPHER}" = "x" -o "x${CIPHER}" = "x0000" ] ; then
|
|
+ cmd="echo "" | openssl s_client $ssl_opt $@ 2>/dev/null"
|
|
+ CIPHER=$(eval $cmd | awk -F "Cipher is" '{print $2}' | tr -d '[:space:]' | awk -F " " '{print $1}')
|
|
+ if [ "x${CIPHER}" = "x" -o "x${CIPHER}" = "x0000" -o "x${CIPHER}" = "x(NONE)" ] ; then
|
|
echo "N"
|
|
else
|
|
echo "Y"
|
|
fi
|
|
}
|
|
|
|
+#Validate the cipher to pass EXPECT test case before call openssl_connect
|
|
+check_cipher() {
|
|
+ cmd="echo "" | openssl s_client $@ 2> /dev/null"
|
|
+ cipher=$(eval $cmd |awk -F "Cipher is" '{print $2}' | tr -d '[:space:]' | awk -F " " '{print $1}')
|
|
+ if [ "x${cipher}" = "x" -o "x${cipher}" = "x0000" -o "x${cipher}" = "x(NONE)" ] ; then
|
|
+ echo "N"
|
|
+ else
|
|
+ echo "Y"
|
|
+ fi
|
|
+}
|
|
+
|
|
cleanup;
|
|
mkdir -p $B0
|
|
mkdir -p $M0
|
|
@@ -65,7 +73,7 @@ TEST glusterd
|
|
TEST pidof glusterd
|
|
TEST $CLI volume info;
|
|
|
|
-TEST openssl genrsa -out $SSL_KEY 1024 2>/dev/null
|
|
+TEST openssl genrsa -out $SSL_KEY 2048 2>/dev/null
|
|
TEST openssl req -config $SSL_CFG -new -key $SSL_KEY -x509 \
|
|
-subj /CN=CA -out $SSL_CA
|
|
TEST openssl req -config $SSL_CFG -new -key $SSL_KEY \
|
|
@@ -106,28 +114,36 @@ EXPECT "N" openssl_connect -ssl3 -connect $H0:$BRICK_PORT
|
|
EXPECT "N" openssl_connect -tls1 -connect $H0:$BRICK_PORT
|
|
|
|
# Test a HIGH CBC cipher
|
|
-EXPECT "Y" openssl_connect -cipher AES256-SHA -connect $H0:$BRICK_PORT
|
|
+cph=`check_cipher -cipher AES256-SHA -connect $H0:$BRICK_PORT`
|
|
+EXPECT "$cph" openssl_connect -cipher AES256-SHA -connect $H0:$BRICK_PORT
|
|
|
|
# Test EECDH
|
|
-EXPECT "Y" openssl_connect -cipher EECDH -connect $H0:$BRICK_PORT
|
|
+cph=`check_cipher -cipher EECDH -connect $H0:$BRICK_PORT`
|
|
+EXPECT "$cph" openssl_connect -cipher EECDH -connect $H0:$BRICK_PORT
|
|
|
|
# test MD5 fails
|
|
-EXPECT "N" openssl_connect -cipher DES-CBC3-MD5 -connect $H0:$BRICK_PORT
|
|
+cph=`check_cipher -cipher DES-CBC3-MD5 -connect $H0:$BRICK_PORT`
|
|
+EXPECT "$cph" openssl_connect -cipher DES-CBC3-MD5 -connect $H0:$BRICK_PORT
|
|
|
|
# test RC4 fails
|
|
-EXPECT "N" openssl_connect -cipher RC4-SHA -connect $H0:$BRICK_PORT
|
|
+cph=`check_cipher -cipher RC4-SHA -connect $H0:$BRICK_PORT`
|
|
+EXPECT "$cph" openssl_connect -cipher RC4-SHA -connect $H0:$BRICK_PORT
|
|
|
|
# test eNULL fails
|
|
-EXPECT "N" openssl_connect -cipher NULL-SHA256 -connect $H0:$BRICK_PORT
|
|
+cph=`check_cipher -cipher NULL-SHA256 -connect $H0:$BRICK_PORT`
|
|
+EXPECT "$cph" openssl_connect -cipher NULL-SHA256 -connect $H0:$BRICK_PORT
|
|
|
|
# test SHA2
|
|
-EXPECT "Y" openssl_connect -cipher AES256-SHA256 -connect $H0:$BRICK_PORT
|
|
+cph=`check_cipher -cipher AES256-SHA256 -connect $H0:$BRICK_PORT`
|
|
+EXPECT "$cph" openssl_connect -cipher AES256-SHA256 -connect $H0:$BRICK_PORT
|
|
|
|
# test GCM
|
|
-EXPECT "Y" openssl_connect -cipher AES256-GCM-SHA384 -connect $H0:$BRICK_PORT
|
|
+cph=`check_cipher -cipher AES256-GCM-SHA384 -connect $H0:$BRICK_PORT`
|
|
+EXPECT "$cph" openssl_connect -cipher AES256-GCM-SHA384 -connect $H0:$BRICK_PORT
|
|
|
|
# Test DH fails without DH params
|
|
-EXPECT "N" openssl_connect -cipher EDH -connect $H0:$BRICK_PORT
|
|
+cph=`check_cipher -cipher EDH -connect $H0:$BRICK_PORT`
|
|
+EXPECT "$cph" openssl_connect -cipher EDH -connect $H0:$BRICK_PORT
|
|
|
|
# Test DH with DH params
|
|
TEST $CLI volume set $V0 ssl.dh-param `pwd`/`dirname $0`/dh1024.pem
|
|
@@ -145,8 +161,10 @@ TEST $CLI volume stop $V0
|
|
TEST $CLI volume start $V0
|
|
EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" online_brick_count
|
|
BRICK_PORT=`brick_port $V0`
|
|
-EXPECT "Y" openssl_connect -cipher AES256-SHA -connect $H0:$BRICK_PORT
|
|
-EXPECT "N" openssl_connect -cipher AES128-SHA -connect $H0:$BRICK_PORT
|
|
+cph=`check_cipher -cipher AES256-SHA -connect $H0:$BRICK_PORT`
|
|
+EXPECT "$cph" openssl_connect -cipher AES256-SHA -connect $H0:$BRICK_PORT
|
|
+cph=`check_cipher -cipher AES128-SHA -connect $H0:$BRICK_PORT`
|
|
+EXPECT "$cph" openssl_connect -cipher AES128-SHA -connect $H0:$BRICK_PORT
|
|
|
|
# Test the ec-curve option
|
|
TEST $CLI volume set $V0 ssl.cipher-list EECDH:EDH:!TLSv1
|
|
@@ -155,8 +173,10 @@ TEST $CLI volume stop $V0
|
|
TEST $CLI volume start $V0
|
|
EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" online_brick_count
|
|
BRICK_PORT=`brick_port $V0`
|
|
-EXPECT "N" openssl_connect -cipher AES256-SHA -connect $H0:$BRICK_PORT
|
|
-EXPECT "Y" openssl_connect -cipher EECDH -connect $H0:$BRICK_PORT
|
|
+cph=`check_cipher -cipher AES256-SHA -connect $H0:$BRICK_PORT`
|
|
+EXPECT "$cph" openssl_connect -cipher AES256-SHA -connect $H0:$BRICK_PORT
|
|
+cph=`check_cipher -cipher EECDH -connect $H0:$BRICK_PORT`
|
|
+EXPECT "$cph" openssl_connect -cipher EECDH -connect $H0:$BRICK_PORT
|
|
|
|
TEST $CLI volume set $V0 ssl.ec-curve invalid
|
|
EXPECT invalid volume_option $V0 ssl.ec-curve
|
|
@@ -164,7 +184,8 @@ TEST $CLI volume stop $V0
|
|
TEST $CLI volume start $V0
|
|
EXPECT_WITHIN $CHILD_UP_TIMEOUT "1" online_brick_count
|
|
BRICK_PORT=`brick_port $V0`
|
|
-EXPECT "N" openssl_connect -cipher EECDH -connect $H0:$BRICK_PORT
|
|
+cph=`check_cipher -cipher EECDH -connect $H0:$BRICK_PORT`
|
|
+EXPECT "$cph" openssl_connect -cipher EECDH -connect $H0:$BRICK_PORT
|
|
|
|
TEST $CLI volume set $V0 ssl.ec-curve secp521r1
|
|
EXPECT secp521r1 volume_option $V0 ssl.ec-curve
|
|
diff --git a/tests/ssl.rc b/tests/ssl.rc
|
|
index 127f83f..b1ccc4c 100644
|
|
--- a/tests/ssl.rc
|
|
+++ b/tests/ssl.rc
|
|
@@ -20,7 +20,7 @@ SSL_CA=$SSL_BASE/glusterfs.ca
|
|
|
|
# Create self-signed certificates
|
|
function create_self_signed_certs (){
|
|
- openssl genrsa -out $SSL_KEY 1024
|
|
+ openssl genrsa -out $SSL_KEY 2048
|
|
openssl req -new -x509 -key $SSL_KEY -subj /CN=Anyone -out $SSL_CERT
|
|
ln $SSL_CERT $SSL_CA
|
|
return $?
|
|
diff --git a/xlators/features/shard/src/shard.c b/xlators/features/shard/src/shard.c
|
|
index b248767..b224abd 100644
|
|
--- a/xlators/features/shard/src/shard.c
|
|
+++ b/xlators/features/shard/src/shard.c
|
|
@@ -10,6883 +10,6417 @@
|
|
|
|
#include <unistd.h>
|
|
|
|
-#include "shard.h"
|
|
#include "shard-mem-types.h"
|
|
+#include "shard.h"
|
|
#include <glusterfs/byte-order.h>
|
|
#include <glusterfs/defaults.h>
|
|
#include <glusterfs/statedump.h>
|
|
|
|
-static gf_boolean_t
|
|
-__is_shard_dir(uuid_t gfid)
|
|
-{
|
|
- shard_priv_t *priv = THIS->private;
|
|
+static gf_boolean_t __is_shard_dir(uuid_t gfid) {
|
|
+ shard_priv_t *priv = THIS->private;
|
|
|
|
- if (gf_uuid_compare(gfid, priv->dot_shard_gfid) == 0)
|
|
- return _gf_true;
|
|
+ if (gf_uuid_compare(gfid, priv->dot_shard_gfid) == 0)
|
|
+ return _gf_true;
|
|
|
|
- return _gf_false;
|
|
+ return _gf_false;
|
|
}
|
|
|
|
-static gf_boolean_t
|
|
-__is_gsyncd_on_shard_dir(call_frame_t *frame, loc_t *loc)
|
|
-{
|
|
- if (frame->root->pid == GF_CLIENT_PID_GSYNCD &&
|
|
- (__is_shard_dir(loc->pargfid) ||
|
|
- (loc->parent && __is_shard_dir(loc->parent->gfid))))
|
|
- return _gf_true;
|
|
+static gf_boolean_t __is_gsyncd_on_shard_dir(call_frame_t *frame, loc_t *loc) {
|
|
+ if (frame->root->pid == GF_CLIENT_PID_GSYNCD &&
|
|
+ (__is_shard_dir(loc->pargfid) ||
|
|
+ (loc->parent && __is_shard_dir(loc->parent->gfid))))
|
|
+ return _gf_true;
|
|
|
|
- return _gf_false;
|
|
+ return _gf_false;
|
|
}
|
|
|
|
-void
|
|
-shard_make_block_bname(int block_num, uuid_t gfid, char *buf, size_t len)
|
|
-{
|
|
- char gfid_str[GF_UUID_BUF_SIZE] = {
|
|
- 0,
|
|
- };
|
|
+void shard_make_block_bname(int block_num, uuid_t gfid, char *buf, size_t len) {
|
|
+ char gfid_str[GF_UUID_BUF_SIZE] = {
|
|
+ 0,
|
|
+ };
|
|
|
|
- gf_uuid_unparse(gfid, gfid_str);
|
|
- snprintf(buf, len, "%s.%d", gfid_str, block_num);
|
|
+ gf_uuid_unparse(gfid, gfid_str);
|
|
+ snprintf(buf, len, "%s.%d", gfid_str, block_num);
|
|
}
|
|
|
|
-void
|
|
-shard_make_block_abspath(int block_num, uuid_t gfid, char *filepath, size_t len)
|
|
-{
|
|
- char gfid_str[GF_UUID_BUF_SIZE] = {
|
|
- 0,
|
|
- };
|
|
+void shard_make_block_abspath(int block_num, uuid_t gfid, char *filepath,
|
|
+ size_t len) {
|
|
+ char gfid_str[GF_UUID_BUF_SIZE] = {
|
|
+ 0,
|
|
+ };
|
|
|
|
- gf_uuid_unparse(gfid, gfid_str);
|
|
- snprintf(filepath, len, "/%s/%s.%d", GF_SHARD_DIR, gfid_str, block_num);
|
|
+ gf_uuid_unparse(gfid, gfid_str);
|
|
+ snprintf(filepath, len, "/%s/%s.%d", GF_SHARD_DIR, gfid_str, block_num);
|
|
}
|
|
|
|
-int
|
|
-__shard_inode_ctx_get(inode_t *inode, xlator_t *this, shard_inode_ctx_t **ctx)
|
|
-{
|
|
- int ret = -1;
|
|
- uint64_t ctx_uint = 0;
|
|
- shard_inode_ctx_t *ctx_p = NULL;
|
|
+int __shard_inode_ctx_get(inode_t *inode, xlator_t *this,
|
|
+ shard_inode_ctx_t **ctx) {
|
|
+ int ret = -1;
|
|
+ uint64_t ctx_uint = 0;
|
|
+ shard_inode_ctx_t *ctx_p = NULL;
|
|
|
|
- ret = __inode_ctx_get(inode, this, &ctx_uint);
|
|
- if (ret == 0) {
|
|
- *ctx = (shard_inode_ctx_t *)(uintptr_t)ctx_uint;
|
|
- return ret;
|
|
- }
|
|
+ ret = __inode_ctx_get(inode, this, &ctx_uint);
|
|
+ if (ret == 0) {
|
|
+ *ctx = (shard_inode_ctx_t *)(uintptr_t)ctx_uint;
|
|
+ return ret;
|
|
+ }
|
|
|
|
- ctx_p = GF_CALLOC(1, sizeof(*ctx_p), gf_shard_mt_inode_ctx_t);
|
|
- if (!ctx_p)
|
|
- return ret;
|
|
+ ctx_p = GF_CALLOC(1, sizeof(*ctx_p), gf_shard_mt_inode_ctx_t);
|
|
+ if (!ctx_p)
|
|
+ return ret;
|
|
|
|
- INIT_LIST_HEAD(&ctx_p->ilist);
|
|
- INIT_LIST_HEAD(&ctx_p->to_fsync_list);
|
|
+ INIT_LIST_HEAD(&ctx_p->ilist);
|
|
+ INIT_LIST_HEAD(&ctx_p->to_fsync_list);
|
|
|
|
- ret = __inode_ctx_set(inode, this, (uint64_t *)&ctx_p);
|
|
- if (ret < 0) {
|
|
- GF_FREE(ctx_p);
|
|
- return ret;
|
|
- }
|
|
+ ret = __inode_ctx_set(inode, this, (uint64_t *)&ctx_p);
|
|
+ if (ret < 0) {
|
|
+ GF_FREE(ctx_p);
|
|
+ return ret;
|
|
+ }
|
|
|
|
- *ctx = ctx_p;
|
|
+ *ctx = ctx_p;
|
|
|
|
- return ret;
|
|
+ return ret;
|
|
}
|
|
|
|
-int
|
|
-shard_inode_ctx_get(inode_t *inode, xlator_t *this, shard_inode_ctx_t **ctx)
|
|
-{
|
|
- int ret = 0;
|
|
+int shard_inode_ctx_get(inode_t *inode, xlator_t *this,
|
|
+ shard_inode_ctx_t **ctx) {
|
|
+ int ret = 0;
|
|
|
|
- LOCK(&inode->lock);
|
|
- {
|
|
- ret = __shard_inode_ctx_get(inode, this, ctx);
|
|
- }
|
|
- UNLOCK(&inode->lock);
|
|
+ LOCK(&inode->lock);
|
|
+ { ret = __shard_inode_ctx_get(inode, this, ctx); }
|
|
+ UNLOCK(&inode->lock);
|
|
|
|
- return ret;
|
|
+ return ret;
|
|
}
|
|
|
|
-int
|
|
-__shard_inode_ctx_set(inode_t *inode, xlator_t *this, struct iatt *stbuf,
|
|
- uint64_t block_size, int32_t valid)
|
|
-{
|
|
- int ret = -1;
|
|
- shard_inode_ctx_t *ctx = NULL;
|
|
+int __shard_inode_ctx_set(inode_t *inode, xlator_t *this, struct iatt *stbuf,
|
|
+ uint64_t block_size, int32_t valid) {
|
|
+ int ret = -1;
|
|
+ shard_inode_ctx_t *ctx = NULL;
|
|
|
|
- ret = __shard_inode_ctx_get(inode, this, &ctx);
|
|
- if (ret)
|
|
- return ret;
|
|
+ ret = __shard_inode_ctx_get(inode, this, &ctx);
|
|
+ if (ret)
|
|
+ return ret;
|
|
|
|
- if (valid & SHARD_MASK_BLOCK_SIZE)
|
|
- ctx->block_size = block_size;
|
|
+ if (valid & SHARD_MASK_BLOCK_SIZE)
|
|
+ ctx->block_size = block_size;
|
|
|
|
- if (valid & SHARD_MASK_PROT)
|
|
- ctx->stat.ia_prot = stbuf->ia_prot;
|
|
+ if (valid & SHARD_MASK_PROT)
|
|
+ ctx->stat.ia_prot = stbuf->ia_prot;
|
|
|
|
- if (valid & SHARD_MASK_NLINK)
|
|
- ctx->stat.ia_nlink = stbuf->ia_nlink;
|
|
+ if (valid & SHARD_MASK_NLINK)
|
|
+ ctx->stat.ia_nlink = stbuf->ia_nlink;
|
|
|
|
- if (valid & SHARD_MASK_UID)
|
|
- ctx->stat.ia_uid = stbuf->ia_uid;
|
|
+ if (valid & SHARD_MASK_UID)
|
|
+ ctx->stat.ia_uid = stbuf->ia_uid;
|
|
|
|
- if (valid & SHARD_MASK_GID)
|
|
- ctx->stat.ia_gid = stbuf->ia_gid;
|
|
+ if (valid & SHARD_MASK_GID)
|
|
+ ctx->stat.ia_gid = stbuf->ia_gid;
|
|
|
|
- if (valid & SHARD_MASK_SIZE)
|
|
- ctx->stat.ia_size = stbuf->ia_size;
|
|
+ if (valid & SHARD_MASK_SIZE)
|
|
+ ctx->stat.ia_size = stbuf->ia_size;
|
|
|
|
- if (valid & SHARD_MASK_BLOCKS)
|
|
- ctx->stat.ia_blocks = stbuf->ia_blocks;
|
|
+ if (valid & SHARD_MASK_BLOCKS)
|
|
+ ctx->stat.ia_blocks = stbuf->ia_blocks;
|
|
|
|
- if (valid & SHARD_MASK_TIMES) {
|
|
- SHARD_TIME_UPDATE(ctx->stat.ia_mtime, ctx->stat.ia_mtime_nsec,
|
|
- stbuf->ia_mtime, stbuf->ia_mtime_nsec);
|
|
- SHARD_TIME_UPDATE(ctx->stat.ia_ctime, ctx->stat.ia_ctime_nsec,
|
|
- stbuf->ia_ctime, stbuf->ia_ctime_nsec);
|
|
- SHARD_TIME_UPDATE(ctx->stat.ia_atime, ctx->stat.ia_atime_nsec,
|
|
- stbuf->ia_atime, stbuf->ia_atime_nsec);
|
|
- }
|
|
+ if (valid & SHARD_MASK_TIMES) {
|
|
+ SHARD_TIME_UPDATE(ctx->stat.ia_mtime, ctx->stat.ia_mtime_nsec,
|
|
+ stbuf->ia_mtime, stbuf->ia_mtime_nsec);
|
|
+ SHARD_TIME_UPDATE(ctx->stat.ia_ctime, ctx->stat.ia_ctime_nsec,
|
|
+ stbuf->ia_ctime, stbuf->ia_ctime_nsec);
|
|
+ SHARD_TIME_UPDATE(ctx->stat.ia_atime, ctx->stat.ia_atime_nsec,
|
|
+ stbuf->ia_atime, stbuf->ia_atime_nsec);
|
|
+ }
|
|
|
|
- if (valid & SHARD_MASK_OTHERS) {
|
|
- ctx->stat.ia_ino = stbuf->ia_ino;
|
|
- gf_uuid_copy(ctx->stat.ia_gfid, stbuf->ia_gfid);
|
|
- ctx->stat.ia_dev = stbuf->ia_dev;
|
|
- ctx->stat.ia_type = stbuf->ia_type;
|
|
- ctx->stat.ia_rdev = stbuf->ia_rdev;
|
|
- ctx->stat.ia_blksize = stbuf->ia_blksize;
|
|
- }
|
|
+ if (valid & SHARD_MASK_OTHERS) {
|
|
+ ctx->stat.ia_ino = stbuf->ia_ino;
|
|
+ gf_uuid_copy(ctx->stat.ia_gfid, stbuf->ia_gfid);
|
|
+ ctx->stat.ia_dev = stbuf->ia_dev;
|
|
+ ctx->stat.ia_type = stbuf->ia_type;
|
|
+ ctx->stat.ia_rdev = stbuf->ia_rdev;
|
|
+ ctx->stat.ia_blksize = stbuf->ia_blksize;
|
|
+ }
|
|
|
|
- if (valid & SHARD_MASK_REFRESH_RESET)
|
|
- ctx->refresh = _gf_false;
|
|
+ if (valid & SHARD_MASK_REFRESH_RESET)
|
|
+ ctx->refresh = _gf_false;
|
|
|
|
- return 0;
|
|
+ return 0;
|
|
}
|
|
|
|
-int
|
|
-shard_inode_ctx_set(inode_t *inode, xlator_t *this, struct iatt *stbuf,
|
|
- uint64_t block_size, int32_t valid)
|
|
-{
|
|
- int ret = -1;
|
|
+int shard_inode_ctx_set(inode_t *inode, xlator_t *this, struct iatt *stbuf,
|
|
+ uint64_t block_size, int32_t valid) {
|
|
+ int ret = -1;
|
|
|
|
- LOCK(&inode->lock);
|
|
- {
|
|
- ret = __shard_inode_ctx_set(inode, this, stbuf, block_size, valid);
|
|
- }
|
|
- UNLOCK(&inode->lock);
|
|
+ LOCK(&inode->lock);
|
|
+ { ret = __shard_inode_ctx_set(inode, this, stbuf, block_size, valid); }
|
|
+ UNLOCK(&inode->lock);
|
|
|
|
- return ret;
|
|
+ return ret;
|
|
}
|
|
|
|
-int
|
|
-__shard_inode_ctx_set_refresh_flag(inode_t *inode, xlator_t *this)
|
|
-{
|
|
- int ret = -1;
|
|
- shard_inode_ctx_t *ctx = NULL;
|
|
+int __shard_inode_ctx_set_refresh_flag(inode_t *inode, xlator_t *this) {
|
|
+ int ret = -1;
|
|
+ shard_inode_ctx_t *ctx = NULL;
|
|
|
|
- ret = __shard_inode_ctx_get(inode, this, &ctx);
|
|
- if (ret)
|
|
- return ret;
|
|
+ ret = __shard_inode_ctx_get(inode, this, &ctx);
|
|
+ if (ret)
|
|
+ return ret;
|
|
|
|
- ctx->refresh = _gf_true;
|
|
+ ctx->refresh = _gf_true;
|
|
|
|
- return 0;
|
|
+ return 0;
|
|
}
|
|
-int
|
|
-shard_inode_ctx_set_refresh_flag(inode_t *inode, xlator_t *this)
|
|
-{
|
|
- int ret = -1;
|
|
+int shard_inode_ctx_set_refresh_flag(inode_t *inode, xlator_t *this) {
|
|
+ int ret = -1;
|
|
|
|
- LOCK(&inode->lock);
|
|
- {
|
|
- ret = __shard_inode_ctx_set_refresh_flag(inode, this);
|
|
- }
|
|
- UNLOCK(&inode->lock);
|
|
+ LOCK(&inode->lock);
|
|
+ { ret = __shard_inode_ctx_set_refresh_flag(inode, this); }
|
|
+ UNLOCK(&inode->lock);
|
|
|
|
- return ret;
|
|
+ return ret;
|
|
}
|
|
|
|
-int
|
|
-__shard_inode_ctx_mark_dir_refreshed(inode_t *inode, xlator_t *this)
|
|
-{
|
|
- int ret = -1;
|
|
- shard_inode_ctx_t *ctx = NULL;
|
|
+int __shard_inode_ctx_mark_dir_refreshed(inode_t *inode, xlator_t *this) {
|
|
+ int ret = -1;
|
|
+ shard_inode_ctx_t *ctx = NULL;
|
|
|
|
- ret = __shard_inode_ctx_get(inode, this, &ctx);
|
|
- if (ret)
|
|
- return ret;
|
|
+ ret = __shard_inode_ctx_get(inode, this, &ctx);
|
|
+ if (ret)
|
|
+ return ret;
|
|
|
|
- ctx->refreshed = _gf_true;
|
|
- return 0;
|
|
+ ctx->refreshed = _gf_true;
|
|
+ return 0;
|
|
}
|
|
|
|
-int
|
|
-shard_inode_ctx_mark_dir_refreshed(inode_t *inode, xlator_t *this)
|
|
-{
|
|
- int ret = -1;
|
|
+int shard_inode_ctx_mark_dir_refreshed(inode_t *inode, xlator_t *this) {
|
|
+ int ret = -1;
|
|
|
|
- LOCK(&inode->lock);
|
|
- {
|
|
- ret = __shard_inode_ctx_mark_dir_refreshed(inode, this);
|
|
- }
|
|
- UNLOCK(&inode->lock);
|
|
+ LOCK(&inode->lock);
|
|
+ { ret = __shard_inode_ctx_mark_dir_refreshed(inode, this); }
|
|
+ UNLOCK(&inode->lock);
|
|
|
|
- return ret;
|
|
+ return ret;
|
|
}
|
|
|
|
-int
|
|
-__shard_inode_ctx_add_to_fsync_list(inode_t *base_inode, xlator_t *this,
|
|
- inode_t *shard_inode)
|
|
-{
|
|
- int ret = -1;
|
|
- shard_inode_ctx_t *base_ictx = NULL;
|
|
- shard_inode_ctx_t *shard_ictx = NULL;
|
|
-
|
|
- ret = __shard_inode_ctx_get(base_inode, this, &base_ictx);
|
|
- if (ret)
|
|
- return ret;
|
|
+int __shard_inode_ctx_add_to_fsync_list(inode_t *base_inode, xlator_t *this,
|
|
+ inode_t *shard_inode) {
|
|
+ int ret = -1;
|
|
+ shard_inode_ctx_t *base_ictx = NULL;
|
|
+ shard_inode_ctx_t *shard_ictx = NULL;
|
|
|
|
- ret = __shard_inode_ctx_get(shard_inode, this, &shard_ictx);
|
|
- if (ret)
|
|
- return ret;
|
|
+ ret = __shard_inode_ctx_get(base_inode, this, &base_ictx);
|
|
+ if (ret)
|
|
+ return ret;
|
|
|
|
- if (shard_ictx->fsync_needed) {
|
|
- shard_ictx->fsync_needed++;
|
|
- return 1;
|
|
- }
|
|
+ ret = __shard_inode_ctx_get(shard_inode, this, &shard_ictx);
|
|
+ if (ret)
|
|
+ return ret;
|
|
|
|
- list_add_tail(&shard_ictx->to_fsync_list, &base_ictx->to_fsync_list);
|
|
- shard_ictx->inode = shard_inode;
|
|
+ if (shard_ictx->fsync_needed) {
|
|
shard_ictx->fsync_needed++;
|
|
- base_ictx->fsync_count++;
|
|
- shard_ictx->base_inode = base_inode;
|
|
+ return 1;
|
|
+ }
|
|
|
|
- return 0;
|
|
+ list_add_tail(&shard_ictx->to_fsync_list, &base_ictx->to_fsync_list);
|
|
+ shard_ictx->inode = shard_inode;
|
|
+ shard_ictx->fsync_needed++;
|
|
+ base_ictx->fsync_count++;
|
|
+ shard_ictx->base_inode = base_inode;
|
|
+
|
|
+ return 0;
|
|
}
|
|
|
|
-int
|
|
-shard_inode_ctx_add_to_fsync_list(inode_t *base_inode, xlator_t *this,
|
|
- inode_t *shard_inode)
|
|
-{
|
|
- int ret = -1;
|
|
+int shard_inode_ctx_add_to_fsync_list(inode_t *base_inode, xlator_t *this,
|
|
+ inode_t *shard_inode) {
|
|
+ int ret = -1;
|
|
|
|
- /* This ref acts as a refkeepr on the base inode. We
|
|
- * need to keep this inode alive as it holds the head
|
|
- * of the to_fsync_list.
|
|
- */
|
|
- inode_ref(base_inode);
|
|
- inode_ref(shard_inode);
|
|
+ /* This ref acts as a refkeepr on the base inode. We
|
|
+ * need to keep this inode alive as it holds the head
|
|
+ * of the to_fsync_list.
|
|
+ */
|
|
+ inode_ref(base_inode);
|
|
+ inode_ref(shard_inode);
|
|
|
|
- LOCK(&base_inode->lock);
|
|
- LOCK(&shard_inode->lock);
|
|
- {
|
|
- ret = __shard_inode_ctx_add_to_fsync_list(base_inode, this,
|
|
- shard_inode);
|
|
- }
|
|
- UNLOCK(&shard_inode->lock);
|
|
- UNLOCK(&base_inode->lock);
|
|
+ LOCK(&base_inode->lock);
|
|
+ LOCK(&shard_inode->lock);
|
|
+ { ret = __shard_inode_ctx_add_to_fsync_list(base_inode, this, shard_inode); }
|
|
+ UNLOCK(&shard_inode->lock);
|
|
+ UNLOCK(&base_inode->lock);
|
|
|
|
- /* Unref the base inode corresponding to the ref above, if the shard is
|
|
- * found to be already part of the fsync list.
|
|
- */
|
|
- if (ret != 0) {
|
|
- inode_unref(base_inode);
|
|
- inode_unref(shard_inode);
|
|
- }
|
|
- return ret;
|
|
+ /* Unref the base inode corresponding to the ref above, if the shard is
|
|
+ * found to be already part of the fsync list.
|
|
+ */
|
|
+ if (ret != 0) {
|
|
+ inode_unref(base_inode);
|
|
+ inode_unref(shard_inode);
|
|
+ }
|
|
+ return ret;
|
|
}
|
|
|
|
-gf_boolean_t
|
|
-__shard_inode_ctx_needs_lookup(inode_t *inode, xlator_t *this)
|
|
-{
|
|
- int ret = -1;
|
|
- shard_inode_ctx_t *ctx = NULL;
|
|
+gf_boolean_t __shard_inode_ctx_needs_lookup(inode_t *inode, xlator_t *this) {
|
|
+ int ret = -1;
|
|
+ shard_inode_ctx_t *ctx = NULL;
|
|
|
|
- ret = __shard_inode_ctx_get(inode, this, &ctx);
|
|
- /* If inode ctx get fails, better to err on the side of caution and
|
|
- * try again? Unless the failure is due to mem-allocation.
|
|
- */
|
|
- if (ret)
|
|
- return _gf_true;
|
|
+ ret = __shard_inode_ctx_get(inode, this, &ctx);
|
|
+ /* If inode ctx get fails, better to err on the side of caution and
|
|
+ * try again? Unless the failure is due to mem-allocation.
|
|
+ */
|
|
+ if (ret)
|
|
+ return _gf_true;
|
|
|
|
- return !ctx->refreshed;
|
|
+ return !ctx->refreshed;
|
|
}
|
|
|
|
-gf_boolean_t
|
|
-shard_inode_ctx_needs_lookup(inode_t *inode, xlator_t *this)
|
|
-{
|
|
- gf_boolean_t flag = _gf_false;
|
|
+gf_boolean_t shard_inode_ctx_needs_lookup(inode_t *inode, xlator_t *this) {
|
|
+ gf_boolean_t flag = _gf_false;
|
|
|
|
- LOCK(&inode->lock);
|
|
- {
|
|
- flag = __shard_inode_ctx_needs_lookup(inode, this);
|
|
- }
|
|
- UNLOCK(&inode->lock);
|
|
+ LOCK(&inode->lock);
|
|
+ { flag = __shard_inode_ctx_needs_lookup(inode, this); }
|
|
+ UNLOCK(&inode->lock);
|
|
|
|
- return flag;
|
|
+ return flag;
|
|
}
|
|
-int
|
|
-__shard_inode_ctx_invalidate(inode_t *inode, xlator_t *this, struct iatt *stbuf)
|
|
-{
|
|
- int ret = -1;
|
|
- shard_inode_ctx_t *ctx = NULL;
|
|
+int __shard_inode_ctx_invalidate(inode_t *inode, xlator_t *this,
|
|
+ struct iatt *stbuf) {
|
|
+ int ret = -1;
|
|
+ shard_inode_ctx_t *ctx = NULL;
|
|
|
|
- ret = __shard_inode_ctx_get(inode, this, &ctx);
|
|
- if (ret)
|
|
- return ret;
|
|
+ ret = __shard_inode_ctx_get(inode, this, &ctx);
|
|
+ if (ret)
|
|
+ return ret;
|
|
|
|
- if ((stbuf->ia_size != ctx->stat.ia_size) ||
|
|
- (stbuf->ia_blocks != ctx->stat.ia_blocks))
|
|
- ctx->refresh = _gf_true;
|
|
+ if ((stbuf->ia_size != ctx->stat.ia_size) ||
|
|
+ (stbuf->ia_blocks != ctx->stat.ia_blocks))
|
|
+ ctx->refresh = _gf_true;
|
|
|
|
- return 0;
|
|
+ return 0;
|
|
}
|
|
|
|
-int
|
|
-shard_inode_ctx_invalidate(inode_t *inode, xlator_t *this, struct iatt *stbuf)
|
|
-{
|
|
- int ret = -1;
|
|
+int shard_inode_ctx_invalidate(inode_t *inode, xlator_t *this,
|
|
+ struct iatt *stbuf) {
|
|
+ int ret = -1;
|
|
|
|
- LOCK(&inode->lock);
|
|
- {
|
|
- ret = __shard_inode_ctx_invalidate(inode, this, stbuf);
|
|
- }
|
|
- UNLOCK(&inode->lock);
|
|
+ LOCK(&inode->lock);
|
|
+ { ret = __shard_inode_ctx_invalidate(inode, this, stbuf); }
|
|
+ UNLOCK(&inode->lock);
|
|
|
|
- return ret;
|
|
+ return ret;
|
|
}
|
|
|
|
-int
|
|
-__shard_inode_ctx_get_block_size(inode_t *inode, xlator_t *this,
|
|
- uint64_t *block_size)
|
|
-{
|
|
- int ret = -1;
|
|
- uint64_t ctx_uint = 0;
|
|
- shard_inode_ctx_t *ctx = NULL;
|
|
+int __shard_inode_ctx_get_block_size(inode_t *inode, xlator_t *this,
|
|
+ uint64_t *block_size) {
|
|
+ int ret = -1;
|
|
+ uint64_t ctx_uint = 0;
|
|
+ shard_inode_ctx_t *ctx = NULL;
|
|
|
|
- ret = __inode_ctx_get(inode, this, &ctx_uint);
|
|
- if (ret < 0)
|
|
- return ret;
|
|
+ ret = __inode_ctx_get(inode, this, &ctx_uint);
|
|
+ if (ret < 0)
|
|
+ return ret;
|
|
|
|
- ctx = (shard_inode_ctx_t *)(uintptr_t)ctx_uint;
|
|
+ ctx = (shard_inode_ctx_t *)(uintptr_t)ctx_uint;
|
|
|
|
- *block_size = ctx->block_size;
|
|
+ *block_size = ctx->block_size;
|
|
|
|
- return 0;
|
|
+ return 0;
|
|
}
|
|
|
|
-int
|
|
-shard_inode_ctx_get_block_size(inode_t *inode, xlator_t *this,
|
|
- uint64_t *block_size)
|
|
-{
|
|
- int ret = -1;
|
|
+int shard_inode_ctx_get_block_size(inode_t *inode, xlator_t *this,
|
|
+ uint64_t *block_size) {
|
|
+ int ret = -1;
|
|
|
|
- LOCK(&inode->lock);
|
|
- {
|
|
- ret = __shard_inode_ctx_get_block_size(inode, this, block_size);
|
|
- }
|
|
- UNLOCK(&inode->lock);
|
|
+ LOCK(&inode->lock);
|
|
+ { ret = __shard_inode_ctx_get_block_size(inode, this, block_size); }
|
|
+ UNLOCK(&inode->lock);
|
|
|
|
- return ret;
|
|
+ return ret;
|
|
}
|
|
|
|
-int
|
|
-__shard_inode_ctx_get_fsync_count(inode_t *inode, xlator_t *this,
|
|
- int *fsync_count)
|
|
-{
|
|
- int ret = -1;
|
|
- uint64_t ctx_uint = 0;
|
|
- shard_inode_ctx_t *ctx = NULL;
|
|
+int __shard_inode_ctx_get_fsync_count(inode_t *inode, xlator_t *this,
|
|
+ int *fsync_count) {
|
|
+ int ret = -1;
|
|
+ uint64_t ctx_uint = 0;
|
|
+ shard_inode_ctx_t *ctx = NULL;
|
|
|
|
- ret = __inode_ctx_get(inode, this, &ctx_uint);
|
|
- if (ret < 0)
|
|
- return ret;
|
|
+ ret = __inode_ctx_get(inode, this, &ctx_uint);
|
|
+ if (ret < 0)
|
|
+ return ret;
|
|
|
|
- ctx = (shard_inode_ctx_t *)(uintptr_t)ctx_uint;
|
|
+ ctx = (shard_inode_ctx_t *)(uintptr_t)ctx_uint;
|
|
|
|
- *fsync_count = ctx->fsync_needed;
|
|
+ *fsync_count = ctx->fsync_needed;
|
|
|
|
- return 0;
|
|
+ return 0;
|
|
}
|
|
|
|
-int
|
|
-shard_inode_ctx_get_fsync_count(inode_t *inode, xlator_t *this,
|
|
- int *fsync_count)
|
|
-{
|
|
- int ret = -1;
|
|
+int shard_inode_ctx_get_fsync_count(inode_t *inode, xlator_t *this,
|
|
+ int *fsync_count) {
|
|
+ int ret = -1;
|
|
|
|
- LOCK(&inode->lock);
|
|
- {
|
|
- ret = __shard_inode_ctx_get_fsync_count(inode, this, fsync_count);
|
|
- }
|
|
- UNLOCK(&inode->lock);
|
|
+ LOCK(&inode->lock);
|
|
+ { ret = __shard_inode_ctx_get_fsync_count(inode, this, fsync_count); }
|
|
+ UNLOCK(&inode->lock);
|
|
|
|
- return ret;
|
|
+ return ret;
|
|
}
|
|
-int
|
|
-__shard_inode_ctx_get_all(inode_t *inode, xlator_t *this,
|
|
- shard_inode_ctx_t *ctx_out)
|
|
-{
|
|
- int ret = -1;
|
|
- uint64_t ctx_uint = 0;
|
|
- shard_inode_ctx_t *ctx = NULL;
|
|
+int __shard_inode_ctx_get_all(inode_t *inode, xlator_t *this,
|
|
+ shard_inode_ctx_t *ctx_out) {
|
|
+ int ret = -1;
|
|
+ uint64_t ctx_uint = 0;
|
|
+ shard_inode_ctx_t *ctx = NULL;
|
|
|
|
- ret = __inode_ctx_get(inode, this, &ctx_uint);
|
|
- if (ret < 0)
|
|
- return ret;
|
|
+ ret = __inode_ctx_get(inode, this, &ctx_uint);
|
|
+ if (ret < 0)
|
|
+ return ret;
|
|
|
|
- ctx = (shard_inode_ctx_t *)(uintptr_t)ctx_uint;
|
|
+ ctx = (shard_inode_ctx_t *)(uintptr_t)ctx_uint;
|
|
|
|
- memcpy(ctx_out, ctx, sizeof(shard_inode_ctx_t));
|
|
- return 0;
|
|
+ memcpy(ctx_out, ctx, sizeof(shard_inode_ctx_t));
|
|
+ return 0;
|
|
}
|
|
|
|
-int
|
|
-shard_inode_ctx_get_all(inode_t *inode, xlator_t *this,
|
|
- shard_inode_ctx_t *ctx_out)
|
|
-{
|
|
- int ret = -1;
|
|
+int shard_inode_ctx_get_all(inode_t *inode, xlator_t *this,
|
|
+ shard_inode_ctx_t *ctx_out) {
|
|
+ int ret = -1;
|
|
|
|
- LOCK(&inode->lock);
|
|
- {
|
|
- ret = __shard_inode_ctx_get_all(inode, this, ctx_out);
|
|
- }
|
|
- UNLOCK(&inode->lock);
|
|
+ LOCK(&inode->lock);
|
|
+ { ret = __shard_inode_ctx_get_all(inode, this, ctx_out); }
|
|
+ UNLOCK(&inode->lock);
|
|
|
|
- return ret;
|
|
+ return ret;
|
|
}
|
|
|
|
-int
|
|
-__shard_inode_ctx_fill_iatt_from_cache(inode_t *inode, xlator_t *this,
|
|
- struct iatt *buf,
|
|
- gf_boolean_t *need_refresh)
|
|
-{
|
|
- int ret = -1;
|
|
- uint64_t ctx_uint = 0;
|
|
- shard_inode_ctx_t *ctx = NULL;
|
|
+int __shard_inode_ctx_fill_iatt_from_cache(inode_t *inode, xlator_t *this,
|
|
+ struct iatt *buf,
|
|
+ gf_boolean_t *need_refresh) {
|
|
+ int ret = -1;
|
|
+ uint64_t ctx_uint = 0;
|
|
+ shard_inode_ctx_t *ctx = NULL;
|
|
|
|
- ret = __inode_ctx_get(inode, this, &ctx_uint);
|
|
- if (ret < 0)
|
|
- return ret;
|
|
+ ret = __inode_ctx_get(inode, this, &ctx_uint);
|
|
+ if (ret < 0)
|
|
+ return ret;
|
|
|
|
- ctx = (shard_inode_ctx_t *)(uintptr_t)ctx_uint;
|
|
+ ctx = (shard_inode_ctx_t *)(uintptr_t)ctx_uint;
|
|
|
|
- if (ctx->refresh == _gf_false)
|
|
- *buf = ctx->stat;
|
|
- else
|
|
- *need_refresh = _gf_true;
|
|
+ if (ctx->refresh == _gf_false)
|
|
+ *buf = ctx->stat;
|
|
+ else
|
|
+ *need_refresh = _gf_true;
|
|
|
|
- return 0;
|
|
+ return 0;
|
|
}
|
|
|
|
-int
|
|
-shard_inode_ctx_fill_iatt_from_cache(inode_t *inode, xlator_t *this,
|
|
- struct iatt *buf,
|
|
- gf_boolean_t *need_refresh)
|
|
-{
|
|
- int ret = -1;
|
|
+int shard_inode_ctx_fill_iatt_from_cache(inode_t *inode, xlator_t *this,
|
|
+ struct iatt *buf,
|
|
+ gf_boolean_t *need_refresh) {
|
|
+ int ret = -1;
|
|
|
|
- LOCK(&inode->lock);
|
|
- {
|
|
- ret = __shard_inode_ctx_fill_iatt_from_cache(inode, this, buf,
|
|
- need_refresh);
|
|
- }
|
|
- UNLOCK(&inode->lock);
|
|
+ LOCK(&inode->lock);
|
|
+ {
|
|
+ ret =
|
|
+ __shard_inode_ctx_fill_iatt_from_cache(inode, this, buf, need_refresh);
|
|
+ }
|
|
+ UNLOCK(&inode->lock);
|
|
|
|
- return ret;
|
|
+ return ret;
|
|
}
|
|
|
|
-void
|
|
-shard_local_wipe(shard_local_t *local)
|
|
-{
|
|
- int i = 0;
|
|
- int count = 0;
|
|
-
|
|
- count = local->num_blocks;
|
|
-
|
|
- syncbarrier_destroy(&local->barrier);
|
|
- loc_wipe(&local->loc);
|
|
- loc_wipe(&local->dot_shard_loc);
|
|
- loc_wipe(&local->dot_shard_rm_loc);
|
|
- loc_wipe(&local->loc2);
|
|
- loc_wipe(&local->tmp_loc);
|
|
- loc_wipe(&local->int_inodelk.loc);
|
|
- loc_wipe(&local->int_entrylk.loc);
|
|
- loc_wipe(&local->newloc);
|
|
-
|
|
- if (local->int_entrylk.basename)
|
|
- GF_FREE(local->int_entrylk.basename);
|
|
- if (local->fd)
|
|
- fd_unref(local->fd);
|
|
-
|
|
- if (local->xattr_req)
|
|
- dict_unref(local->xattr_req);
|
|
- if (local->xattr_rsp)
|
|
- dict_unref(local->xattr_rsp);
|
|
-
|
|
- for (i = 0; i < count; i++) {
|
|
- if (!local->inode_list)
|
|
- break;
|
|
-
|
|
- if (local->inode_list[i])
|
|
- inode_unref(local->inode_list[i]);
|
|
- }
|
|
-
|
|
- GF_FREE(local->inode_list);
|
|
-
|
|
- GF_FREE(local->vector);
|
|
- if (local->iobref)
|
|
- iobref_unref(local->iobref);
|
|
- if (local->list_inited)
|
|
- gf_dirent_free(&local->entries_head);
|
|
- if (local->inodelk_frame)
|
|
- SHARD_STACK_DESTROY(local->inodelk_frame);
|
|
- if (local->entrylk_frame)
|
|
- SHARD_STACK_DESTROY(local->entrylk_frame);
|
|
-}
|
|
-
|
|
-int
|
|
-shard_modify_size_and_block_count(struct iatt *stbuf, dict_t *dict)
|
|
-{
|
|
- int ret = -1;
|
|
- void *size_attr = NULL;
|
|
- uint64_t size_array[4];
|
|
-
|
|
- ret = dict_get_ptr(dict, GF_XATTR_SHARD_FILE_SIZE, &size_attr);
|
|
- if (ret) {
|
|
- gf_msg_callingfn(THIS->name, GF_LOG_ERROR, 0,
|
|
- SHARD_MSG_INTERNAL_XATTR_MISSING,
|
|
- "Failed to "
|
|
- "get " GF_XATTR_SHARD_FILE_SIZE " for %s",
|
|
- uuid_utoa(stbuf->ia_gfid));
|
|
- return ret;
|
|
- }
|
|
+void shard_local_wipe(shard_local_t *local) {
|
|
+ int i = 0;
|
|
+ int count = 0;
|
|
|
|
- memcpy(size_array, size_attr, sizeof(size_array));
|
|
+ count = local->num_blocks;
|
|
|
|
- stbuf->ia_size = ntoh64(size_array[0]);
|
|
- stbuf->ia_blocks = ntoh64(size_array[2]);
|
|
+ syncbarrier_destroy(&local->barrier);
|
|
+ loc_wipe(&local->loc);
|
|
+ loc_wipe(&local->dot_shard_loc);
|
|
+ loc_wipe(&local->dot_shard_rm_loc);
|
|
+ loc_wipe(&local->loc2);
|
|
+ loc_wipe(&local->tmp_loc);
|
|
+ loc_wipe(&local->int_inodelk.loc);
|
|
+ loc_wipe(&local->int_entrylk.loc);
|
|
+ loc_wipe(&local->newloc);
|
|
|
|
- return 0;
|
|
-}
|
|
+ if (local->int_entrylk.basename)
|
|
+ GF_FREE(local->int_entrylk.basename);
|
|
+ if (local->fd)
|
|
+ fd_unref(local->fd);
|
|
|
|
-int
|
|
-shard_call_count_return(call_frame_t *frame)
|
|
-{
|
|
- int call_count = 0;
|
|
- shard_local_t *local = NULL;
|
|
+ if (local->xattr_req)
|
|
+ dict_unref(local->xattr_req);
|
|
+ if (local->xattr_rsp)
|
|
+ dict_unref(local->xattr_rsp);
|
|
|
|
- local = frame->local;
|
|
+ for (i = 0; i < count; i++) {
|
|
+ if (!local->inode_list)
|
|
+ break;
|
|
+
|
|
+ if (local->inode_list[i])
|
|
+ inode_unref(local->inode_list[i]);
|
|
+ }
|
|
+
|
|
+ GF_FREE(local->inode_list);
|
|
+
|
|
+ GF_FREE(local->vector);
|
|
+ if (local->iobref)
|
|
+ iobref_unref(local->iobref);
|
|
+ if (local->list_inited)
|
|
+ gf_dirent_free(&local->entries_head);
|
|
+ if (local->inodelk_frame)
|
|
+ SHARD_STACK_DESTROY(local->inodelk_frame);
|
|
+ if (local->entrylk_frame)
|
|
+ SHARD_STACK_DESTROY(local->entrylk_frame);
|
|
+}
|
|
+
|
|
+int shard_modify_size_and_block_count(struct iatt *stbuf, dict_t *dict) {
|
|
+ int ret = -1;
|
|
+ void *size_attr = NULL;
|
|
+ uint64_t size_array[4];
|
|
+
|
|
+ ret = dict_get_ptr(dict, GF_XATTR_SHARD_FILE_SIZE, &size_attr);
|
|
+ if (ret) {
|
|
+ gf_msg_callingfn(THIS->name, GF_LOG_ERROR, 0,
|
|
+ SHARD_MSG_INTERNAL_XATTR_MISSING,
|
|
+ "Failed to "
|
|
+ "get " GF_XATTR_SHARD_FILE_SIZE " for %s",
|
|
+ uuid_utoa(stbuf->ia_gfid));
|
|
+ return ret;
|
|
+ }
|
|
+
|
|
+ memcpy(size_array, size_attr, sizeof(size_array));
|
|
+
|
|
+ stbuf->ia_size = ntoh64(size_array[0]);
|
|
+ stbuf->ia_blocks = ntoh64(size_array[2]);
|
|
+
|
|
+ return 0;
|
|
+}
|
|
+
|
|
+int shard_call_count_return(call_frame_t *frame) {
|
|
+ int call_count = 0;
|
|
+ shard_local_t *local = NULL;
|
|
+
|
|
+ local = frame->local;
|
|
+
|
|
+ LOCK(&frame->lock);
|
|
+ { call_count = --local->call_count; }
|
|
+ UNLOCK(&frame->lock);
|
|
+
|
|
+ return call_count;
|
|
+}
|
|
+
|
|
+static char *shard_internal_dir_string(shard_internal_dir_type_t type) {
|
|
+ char *str = NULL;
|
|
+
|
|
+ switch (type) {
|
|
+ case SHARD_INTERNAL_DIR_DOT_SHARD:
|
|
+ str = GF_SHARD_DIR;
|
|
+ break;
|
|
+ case SHARD_INTERNAL_DIR_DOT_SHARD_REMOVE_ME:
|
|
+ str = GF_SHARD_REMOVE_ME_DIR;
|
|
+ break;
|
|
+ default:
|
|
+ break;
|
|
+ }
|
|
+ return str;
|
|
+}
|
|
+
|
|
+static int shard_init_internal_dir_loc(xlator_t *this, shard_local_t *local,
|
|
+ shard_internal_dir_type_t type) {
|
|
+ int ret = -1;
|
|
+ char *bname = NULL;
|
|
+ inode_t *parent = NULL;
|
|
+ loc_t *internal_dir_loc = NULL;
|
|
+ shard_priv_t *priv = NULL;
|
|
+
|
|
+ priv = this->private;
|
|
+ if (!local)
|
|
+ return -1;
|
|
+
|
|
+ switch (type) {
|
|
+ case SHARD_INTERNAL_DIR_DOT_SHARD:
|
|
+ internal_dir_loc = &local->dot_shard_loc;
|
|
+ bname = GF_SHARD_DIR;
|
|
+ parent = inode_ref(this->itable->root);
|
|
+ break;
|
|
+ case SHARD_INTERNAL_DIR_DOT_SHARD_REMOVE_ME:
|
|
+ internal_dir_loc = &local->dot_shard_rm_loc;
|
|
+ bname = GF_SHARD_REMOVE_ME_DIR;
|
|
+ parent = inode_ref(priv->dot_shard_inode);
|
|
+ break;
|
|
+ default:
|
|
+ break;
|
|
+ }
|
|
+
|
|
+ internal_dir_loc->inode = inode_new(this->itable);
|
|
+ internal_dir_loc->parent = parent;
|
|
+ ret = inode_path(internal_dir_loc->parent, bname,
|
|
+ (char **)&internal_dir_loc->path);
|
|
+ if (ret < 0 || !(internal_dir_loc->inode)) {
|
|
+ gf_msg(this->name, GF_LOG_ERROR, 0, SHARD_MSG_INODE_PATH_FAILED,
|
|
+ "Inode path failed on %s", bname);
|
|
+ goto out;
|
|
+ }
|
|
+
|
|
+ internal_dir_loc->name = strrchr(internal_dir_loc->path, '/');
|
|
+ if (internal_dir_loc->name)
|
|
+ internal_dir_loc->name++;
|
|
+
|
|
+ ret = 0;
|
|
+out:
|
|
+ return ret;
|
|
+}
|
|
+
|
|
+inode_t *__shard_update_shards_inode_list(inode_t *linked_inode, xlator_t *this,
|
|
+ inode_t *base_inode, int block_num,
|
|
+ uuid_t gfid) {
|
|
+ char block_bname[256] = {
|
|
+ 0,
|
|
+ };
|
|
+ inode_t *lru_inode = NULL;
|
|
+ shard_priv_t *priv = NULL;
|
|
+ shard_inode_ctx_t *ctx = NULL;
|
|
+ shard_inode_ctx_t *lru_inode_ctx = NULL;
|
|
+ shard_inode_ctx_t *lru_base_inode_ctx = NULL;
|
|
+ inode_t *fsync_inode = NULL;
|
|
+ inode_t *lru_base_inode = NULL;
|
|
+ gf_boolean_t do_fsync = _gf_false;
|
|
+
|
|
+ priv = this->private;
|
|
+
|
|
+ shard_inode_ctx_get(linked_inode, this, &ctx);
|
|
+
|
|
+ if (list_empty(&ctx->ilist)) {
|
|
+ if (priv->inode_count + 1 <= priv->lru_limit) {
|
|
+ /* If this inode was linked here for the first time (indicated
|
|
+ * by empty list), and if there is still space in the priv list,
|
|
+ * add this ctx to the tail of the list.
|
|
+ */
|
|
+ /* For as long as an inode is in lru list, we try to
|
|
+ * keep it alive by holding a ref on it.
|
|
+ */
|
|
+ inode_ref(linked_inode);
|
|
+ if (base_inode)
|
|
+ gf_uuid_copy(ctx->base_gfid, base_inode->gfid);
|
|
+ else
|
|
+ gf_uuid_copy(ctx->base_gfid, gfid);
|
|
+ ctx->block_num = block_num;
|
|
+ list_add_tail(&ctx->ilist, &priv->ilist_head);
|
|
+ priv->inode_count++;
|
|
+ ctx->base_inode = inode_ref(base_inode);
|
|
+ } else {
|
|
+ /*If on the other hand there is no available slot for this inode
|
|
+ * in the list, delete the lru inode from the head of the list,
|
|
+ * unlink it. And in its place add this new inode into the list.
|
|
+ */
|
|
+ lru_inode_ctx =
|
|
+ list_first_entry(&priv->ilist_head, shard_inode_ctx_t, ilist);
|
|
+ GF_ASSERT(lru_inode_ctx->block_num > 0);
|
|
+ lru_base_inode = lru_inode_ctx->base_inode;
|
|
+ list_del_init(&lru_inode_ctx->ilist);
|
|
+ lru_inode = inode_find(linked_inode->table, lru_inode_ctx->stat.ia_gfid);
|
|
+ /* If the lru inode was part of the pending-fsync list,
|
|
+ * the base inode needs to be unref'd, the lru inode
|
|
+ * deleted from fsync list and fsync'd in a new frame,
|
|
+ * and then unlinked in memory and forgotten.
|
|
+ */
|
|
+ if (!lru_base_inode)
|
|
+ goto after_fsync_check;
|
|
+ LOCK(&lru_base_inode->lock);
|
|
+ LOCK(&lru_inode->lock);
|
|
+ {
|
|
+ if (!list_empty(&lru_inode_ctx->to_fsync_list)) {
|
|
+ list_del_init(&lru_inode_ctx->to_fsync_list);
|
|
+ lru_inode_ctx->fsync_needed = 0;
|
|
+ do_fsync = _gf_true;
|
|
+ __shard_inode_ctx_get(lru_base_inode, this, &lru_base_inode_ctx);
|
|
+ lru_base_inode_ctx->fsync_count--;
|
|
+ }
|
|
+ }
|
|
+ UNLOCK(&lru_inode->lock);
|
|
+ UNLOCK(&lru_base_inode->lock);
|
|
+
|
|
+ after_fsync_check:
|
|
+ if (!do_fsync) {
|
|
+ shard_make_block_bname(lru_inode_ctx->block_num,
|
|
+ lru_inode_ctx->base_gfid, block_bname,
|
|
+ sizeof(block_bname));
|
|
+ /* The following unref corresponds to the ref held at
|
|
+ * the time the shard was added to the lru list.
|
|
+ */
|
|
+ inode_unref(lru_inode);
|
|
+ inode_unlink(lru_inode, priv->dot_shard_inode, block_bname);
|
|
+ inode_forget(lru_inode, 0);
|
|
+ } else {
|
|
+ /* The following unref corresponds to the ref
|
|
+ * held when the shard was added to fsync list.
|
|
+ */
|
|
+ inode_unref(lru_inode);
|
|
+ fsync_inode = lru_inode;
|
|
+ if (lru_base_inode)
|
|
+ inode_unref(lru_base_inode);
|
|
+ }
|
|
+ /* The following unref corresponds to the ref
|
|
+ * held by inode_find() above.
|
|
+ */
|
|
+ inode_unref(lru_inode);
|
|
+
|
|
+ /* The following unref corresponds to the ref held on the base shard
|
|
+ * at the time of adding shard inode to lru list
|
|
+ */
|
|
+ if (lru_base_inode)
|
|
+ inode_unref(lru_base_inode);
|
|
+
|
|
+ /* For as long as an inode is in lru list, we try to
|
|
+ * keep it alive by holding a ref on it.
|
|
+ */
|
|
+ inode_ref(linked_inode);
|
|
+ if (base_inode)
|
|
+ gf_uuid_copy(ctx->base_gfid, base_inode->gfid);
|
|
+ else
|
|
+ gf_uuid_copy(ctx->base_gfid, gfid);
|
|
+ ctx->block_num = block_num;
|
|
+ ctx->base_inode = inode_ref(base_inode);
|
|
+ list_add_tail(&ctx->ilist, &priv->ilist_head);
|
|
+ }
|
|
+ } else {
|
|
+ /* If this is not the first time this inode is being operated on, move
|
|
+ * it to the most recently used end of the list.
|
|
+ */
|
|
+ list_move_tail(&ctx->ilist, &priv->ilist_head);
|
|
+ }
|
|
+ return fsync_inode;
|
|
+}
|
|
+
|
|
+int shard_common_failure_unwind(glusterfs_fop_t fop, call_frame_t *frame,
|
|
+ int32_t op_ret, int32_t op_errno) {
|
|
+ switch (fop) {
|
|
+ case GF_FOP_LOOKUP:
|
|
+ SHARD_STACK_UNWIND(lookup, frame, op_ret, op_errno, NULL, NULL, NULL, NULL);
|
|
+ break;
|
|
+ case GF_FOP_STAT:
|
|
+ SHARD_STACK_UNWIND(stat, frame, op_ret, op_errno, NULL, NULL);
|
|
+ break;
|
|
+ case GF_FOP_FSTAT:
|
|
+ SHARD_STACK_UNWIND(fstat, frame, op_ret, op_errno, NULL, NULL);
|
|
+ break;
|
|
+ case GF_FOP_TRUNCATE:
|
|
+ SHARD_STACK_UNWIND(truncate, frame, op_ret, op_errno, NULL, NULL, NULL);
|
|
+ break;
|
|
+ case GF_FOP_FTRUNCATE:
|
|
+ SHARD_STACK_UNWIND(ftruncate, frame, op_ret, op_errno, NULL, NULL, NULL);
|
|
+ break;
|
|
+ case GF_FOP_MKNOD:
|
|
+ SHARD_STACK_UNWIND(mknod, frame, op_ret, op_errno, NULL, NULL, NULL, NULL,
|
|
+ NULL);
|
|
+ break;
|
|
+ case GF_FOP_LINK:
|
|
+ SHARD_STACK_UNWIND(link, frame, op_ret, op_errno, NULL, NULL, NULL, NULL,
|
|
+ NULL);
|
|
+ break;
|
|
+ case GF_FOP_CREATE:
|
|
+ SHARD_STACK_UNWIND(create, frame, op_ret, op_errno, NULL, NULL, NULL, NULL,
|
|
+ NULL, NULL);
|
|
+ break;
|
|
+ case GF_FOP_UNLINK:
|
|
+ SHARD_STACK_UNWIND(unlink, frame, op_ret, op_errno, NULL, NULL, NULL);
|
|
+ break;
|
|
+ case GF_FOP_RENAME:
|
|
+ SHARD_STACK_UNWIND(rename, frame, op_ret, op_errno, NULL, NULL, NULL, NULL,
|
|
+ NULL, NULL);
|
|
+ break;
|
|
+ case GF_FOP_WRITE:
|
|
+ SHARD_STACK_UNWIND(writev, frame, op_ret, op_errno, NULL, NULL, NULL);
|
|
+ break;
|
|
+ case GF_FOP_FALLOCATE:
|
|
+ SHARD_STACK_UNWIND(fallocate, frame, op_ret, op_errno, NULL, NULL, NULL);
|
|
+ break;
|
|
+ case GF_FOP_ZEROFILL:
|
|
+ SHARD_STACK_UNWIND(zerofill, frame, op_ret, op_errno, NULL, NULL, NULL);
|
|
+ break;
|
|
+ case GF_FOP_DISCARD:
|
|
+ SHARD_STACK_UNWIND(discard, frame, op_ret, op_errno, NULL, NULL, NULL);
|
|
+ break;
|
|
+ case GF_FOP_READ:
|
|
+ SHARD_STACK_UNWIND(readv, frame, op_ret, op_errno, NULL, -1, NULL, NULL,
|
|
+ NULL);
|
|
+ break;
|
|
+ case GF_FOP_FSYNC:
|
|
+ SHARD_STACK_UNWIND(fsync, frame, op_ret, op_errno, NULL, NULL, NULL);
|
|
+ break;
|
|
+ case GF_FOP_REMOVEXATTR:
|
|
+ SHARD_STACK_UNWIND(removexattr, frame, op_ret, op_errno, NULL);
|
|
+ break;
|
|
+ case GF_FOP_FREMOVEXATTR:
|
|
+ SHARD_STACK_UNWIND(fremovexattr, frame, op_ret, op_errno, NULL);
|
|
+ break;
|
|
+ case GF_FOP_FGETXATTR:
|
|
+ SHARD_STACK_UNWIND(fgetxattr, frame, op_ret, op_errno, NULL, NULL);
|
|
+ break;
|
|
+ case GF_FOP_GETXATTR:
|
|
+ SHARD_STACK_UNWIND(getxattr, frame, op_ret, op_errno, NULL, NULL);
|
|
+ break;
|
|
+ case GF_FOP_FSETXATTR:
|
|
+ SHARD_STACK_UNWIND(fsetxattr, frame, op_ret, op_errno, NULL);
|
|
+ break;
|
|
+ case GF_FOP_SETXATTR:
|
|
+ SHARD_STACK_UNWIND(setxattr, frame, op_ret, op_errno, NULL);
|
|
+ break;
|
|
+ case GF_FOP_SETATTR:
|
|
+ SHARD_STACK_UNWIND(setattr, frame, op_ret, op_errno, NULL, NULL, NULL);
|
|
+ break;
|
|
+ case GF_FOP_FSETATTR:
|
|
+ SHARD_STACK_UNWIND(fsetattr, frame, op_ret, op_errno, NULL, NULL, NULL);
|
|
+ break;
|
|
+ case GF_FOP_SEEK:
|
|
+ SHARD_STACK_UNWIND(seek, frame, op_ret, op_errno, 0, NULL);
|
|
+ break;
|
|
+ default:
|
|
+ gf_msg(THIS->name, GF_LOG_WARNING, 0, SHARD_MSG_INVALID_FOP,
|
|
+ "Invalid fop id = %d", fop);
|
|
+ break;
|
|
+ }
|
|
+ return 0;
|
|
+}
|
|
+
|
|
+int shard_common_inode_write_success_unwind(glusterfs_fop_t fop,
|
|
+ call_frame_t *frame,
|
|
+ int32_t op_ret) {
|
|
+ shard_local_t *local = NULL;
|
|
+
|
|
+ local = frame->local;
|
|
+
|
|
+ switch (fop) {
|
|
+ case GF_FOP_WRITE:
|
|
+ SHARD_STACK_UNWIND(writev, frame, op_ret, 0, &local->prebuf,
|
|
+ &local->postbuf, local->xattr_rsp);
|
|
+ break;
|
|
+ case GF_FOP_FALLOCATE:
|
|
+ SHARD_STACK_UNWIND(fallocate, frame, op_ret, 0, &local->prebuf,
|
|
+ &local->postbuf, local->xattr_rsp);
|
|
+ break;
|
|
+ case GF_FOP_ZEROFILL:
|
|
+ SHARD_STACK_UNWIND(zerofill, frame, op_ret, 0, &local->prebuf,
|
|
+ &local->postbuf, local->xattr_rsp);
|
|
+ break;
|
|
+ case GF_FOP_DISCARD:
|
|
+ SHARD_STACK_UNWIND(discard, frame, op_ret, 0, &local->prebuf,
|
|
+ &local->postbuf, local->xattr_rsp);
|
|
+ break;
|
|
+ default:
|
|
+ gf_msg(THIS->name, GF_LOG_WARNING, 0, SHARD_MSG_INVALID_FOP,
|
|
+ "Invalid fop id = %d", fop);
|
|
+ break;
|
|
+ }
|
|
+ return 0;
|
|
+}
|
|
+
|
|
+int shard_evicted_inode_fsync_cbk(call_frame_t *frame, void *cookie,
|
|
+ xlator_t *this, int32_t op_ret,
|
|
+ int32_t op_errno, struct iatt *prebuf,
|
|
+ struct iatt *postbuf, dict_t *xdata) {
|
|
+ char block_bname[256] = {
|
|
+ 0,
|
|
+ };
|
|
+ fd_t *anon_fd = cookie;
|
|
+ inode_t *shard_inode = NULL;
|
|
+ shard_inode_ctx_t *ctx = NULL;
|
|
+ shard_priv_t *priv = NULL;
|
|
+
|
|
+ priv = this->private;
|
|
+
|
|
+ if (anon_fd == NULL || op_ret < 0) {
|
|
+ gf_msg(this->name, GF_LOG_WARNING, op_errno, SHARD_MSG_MEMALLOC_FAILED,
|
|
+ "fsync failed on shard");
|
|
+ goto out;
|
|
+ }
|
|
+ shard_inode = anon_fd->inode;
|
|
+
|
|
+ LOCK(&priv->lock);
|
|
+ LOCK(&shard_inode->lock);
|
|
+ {
|
|
+ __shard_inode_ctx_get(shard_inode, this, &ctx);
|
|
+ if ((list_empty(&ctx->to_fsync_list)) && (list_empty(&ctx->ilist))) {
|
|
+ shard_make_block_bname(ctx->block_num, shard_inode->gfid, block_bname,
|
|
+ sizeof(block_bname));
|
|
+ inode_unlink(shard_inode, priv->dot_shard_inode, block_bname);
|
|
+ /* The following unref corresponds to the ref held by
|
|
+ * inode_link() at the time the shard was created or
|
|
+ * looked up
|
|
+ */
|
|
+ inode_unref(shard_inode);
|
|
+ inode_forget(shard_inode, 0);
|
|
+ }
|
|
+ }
|
|
+ UNLOCK(&shard_inode->lock);
|
|
+ UNLOCK(&priv->lock);
|
|
|
|
- LOCK(&frame->lock);
|
|
- {
|
|
- call_count = --local->call_count;
|
|
+out:
|
|
+ if (anon_fd)
|
|
+ fd_unref(anon_fd);
|
|
+ STACK_DESTROY(frame->root);
|
|
+ return 0;
|
|
+}
|
|
+
|
|
+int shard_initiate_evicted_inode_fsync(xlator_t *this, inode_t *inode) {
|
|
+ fd_t *anon_fd = NULL;
|
|
+ call_frame_t *fsync_frame = NULL;
|
|
+
|
|
+ fsync_frame = create_frame(this, this->ctx->pool);
|
|
+ if (!fsync_frame) {
|
|
+ gf_msg(this->name, GF_LOG_WARNING, ENOMEM, SHARD_MSG_MEMALLOC_FAILED,
|
|
+ "Failed to create new frame "
|
|
+ "to fsync shard");
|
|
+ return -1;
|
|
+ }
|
|
+
|
|
+ anon_fd = fd_anonymous(inode);
|
|
+ if (!anon_fd) {
|
|
+ gf_msg(this->name, GF_LOG_WARNING, ENOMEM, SHARD_MSG_MEMALLOC_FAILED,
|
|
+ "Failed to create anon fd to"
|
|
+ " fsync shard");
|
|
+ STACK_DESTROY(fsync_frame->root);
|
|
+ return -1;
|
|
+ }
|
|
+
|
|
+ STACK_WIND_COOKIE(fsync_frame, shard_evicted_inode_fsync_cbk, anon_fd,
|
|
+ FIRST_CHILD(this), FIRST_CHILD(this)->fops->fsync, anon_fd,
|
|
+ 1, NULL);
|
|
+ return 0;
|
|
+}
|
|
+
|
|
+int shard_common_resolve_shards(
|
|
+ call_frame_t *frame, xlator_t *this,
|
|
+ shard_post_resolve_fop_handler_t post_res_handler) {
|
|
+ int i = -1;
|
|
+ uint32_t shard_idx_iter = 0;
|
|
+ char path[PATH_MAX] = {
|
|
+ 0,
|
|
+ };
|
|
+ uuid_t gfid = {
|
|
+ 0,
|
|
+ };
|
|
+ inode_t *inode = NULL;
|
|
+ inode_t *res_inode = NULL;
|
|
+ inode_t *fsync_inode = NULL;
|
|
+ shard_priv_t *priv = NULL;
|
|
+ shard_local_t *local = NULL;
|
|
+
|
|
+ priv = this->private;
|
|
+ local = frame->local;
|
|
+ local->call_count = 0;
|
|
+ shard_idx_iter = local->first_block;
|
|
+ res_inode = local->resolver_base_inode;
|
|
+ if (res_inode)
|
|
+ gf_uuid_copy(gfid, res_inode->gfid);
|
|
+ else
|
|
+ gf_uuid_copy(gfid, local->base_gfid);
|
|
+
|
|
+ if ((local->op_ret < 0) || (local->resolve_not))
|
|
+ goto out;
|
|
+
|
|
+ while (shard_idx_iter <= local->last_block) {
|
|
+ i++;
|
|
+ if (shard_idx_iter == 0) {
|
|
+ local->inode_list[i] = inode_ref(res_inode);
|
|
+ shard_idx_iter++;
|
|
+ continue;
|
|
+ }
|
|
+
|
|
+ shard_make_block_abspath(shard_idx_iter, gfid, path, sizeof(path));
|
|
+
|
|
+ inode = NULL;
|
|
+ inode = inode_resolve(this->itable, path);
|
|
+ if (inode) {
|
|
+ gf_msg_debug(this->name, 0, "Shard %d already "
|
|
+ "present. gfid=%s. Saving inode for future.",
|
|
+ shard_idx_iter, uuid_utoa(inode->gfid));
|
|
+ local->inode_list[i] = inode;
|
|
+ /* Let the ref on the inodes that are already present
|
|
+ * in inode table still be held so that they don't get
|
|
+ * forgotten by the time the fop reaches the actual
|
|
+ * write stage.
|
|
+ */
|
|
+ LOCK(&priv->lock);
|
|
+ {
|
|
+ fsync_inode = __shard_update_shards_inode_list(inode, this, res_inode,
|
|
+ shard_idx_iter, gfid);
|
|
+ }
|
|
+ UNLOCK(&priv->lock);
|
|
+ shard_idx_iter++;
|
|
+ if (fsync_inode)
|
|
+ shard_initiate_evicted_inode_fsync(this, fsync_inode);
|
|
+ continue;
|
|
+ } else {
|
|
+ local->call_count++;
|
|
+ shard_idx_iter++;
|
|
}
|
|
- UNLOCK(&frame->lock);
|
|
+ }
|
|
+out:
|
|
+ post_res_handler(frame, this);
|
|
+ return 0;
|
|
+}
|
|
+
|
|
+int shard_update_file_size_cbk(call_frame_t *frame, void *cookie,
|
|
+ xlator_t *this, int32_t op_ret, int32_t op_errno,
|
|
+ dict_t *dict, dict_t *xdata) {
|
|
+ inode_t *inode = NULL;
|
|
+ shard_local_t *local = NULL;
|
|
+
|
|
+ local = frame->local;
|
|
+
|
|
+ if ((local->fd) && (local->fd->inode))
|
|
+ inode = local->fd->inode;
|
|
+ else if (local->loc.inode)
|
|
+ inode = local->loc.inode;
|
|
+
|
|
+ if (op_ret < 0) {
|
|
+ gf_msg(this->name, GF_LOG_ERROR, op_errno,
|
|
+ SHARD_MSG_UPDATE_FILE_SIZE_FAILED, "Update to file size"
|
|
+ " xattr failed on %s",
|
|
+ uuid_utoa(inode->gfid));
|
|
+ local->op_ret = op_ret;
|
|
+ local->op_errno = op_errno;
|
|
+ goto err;
|
|
+ }
|
|
|
|
- return call_count;
|
|
+ if (shard_modify_size_and_block_count(&local->postbuf, dict)) {
|
|
+ local->op_ret = -1;
|
|
+ local->op_errno = ENOMEM;
|
|
+ goto err;
|
|
+ }
|
|
+err:
|
|
+ local->post_update_size_handler(frame, this);
|
|
+ return 0;
|
|
}
|
|
|
|
-static char *
|
|
-shard_internal_dir_string(shard_internal_dir_type_t type)
|
|
-{
|
|
- char *str = NULL;
|
|
+int shard_set_size_attrs(int64_t size, int64_t block_count,
|
|
+ int64_t **size_attr_p) {
|
|
+ int ret = -1;
|
|
+ int64_t *size_attr = NULL;
|
|
|
|
- switch (type) {
|
|
- case SHARD_INTERNAL_DIR_DOT_SHARD:
|
|
- str = GF_SHARD_DIR;
|
|
- break;
|
|
- case SHARD_INTERNAL_DIR_DOT_SHARD_REMOVE_ME:
|
|
- str = GF_SHARD_REMOVE_ME_DIR;
|
|
- break;
|
|
- default:
|
|
- break;
|
|
- }
|
|
- return str;
|
|
-}
|
|
-
|
|
-static int
|
|
-shard_init_internal_dir_loc(xlator_t *this, shard_local_t *local,
|
|
- shard_internal_dir_type_t type)
|
|
-{
|
|
- int ret = -1;
|
|
- char *bname = NULL;
|
|
- inode_t *parent = NULL;
|
|
- loc_t *internal_dir_loc = NULL;
|
|
- shard_priv_t *priv = NULL;
|
|
-
|
|
- priv = this->private;
|
|
- if (!local)
|
|
- return -1;
|
|
-
|
|
- switch (type) {
|
|
- case SHARD_INTERNAL_DIR_DOT_SHARD:
|
|
- internal_dir_loc = &local->dot_shard_loc;
|
|
- bname = GF_SHARD_DIR;
|
|
- parent = inode_ref(this->itable->root);
|
|
- break;
|
|
- case SHARD_INTERNAL_DIR_DOT_SHARD_REMOVE_ME:
|
|
- internal_dir_loc = &local->dot_shard_rm_loc;
|
|
- bname = GF_SHARD_REMOVE_ME_DIR;
|
|
- parent = inode_ref(priv->dot_shard_inode);
|
|
- break;
|
|
- default:
|
|
- break;
|
|
- }
|
|
+ if (!size_attr_p)
|
|
+ goto out;
|
|
|
|
- internal_dir_loc->inode = inode_new(this->itable);
|
|
- internal_dir_loc->parent = parent;
|
|
- ret = inode_path(internal_dir_loc->parent, bname,
|
|
- (char **)&internal_dir_loc->path);
|
|
- if (ret < 0 || !(internal_dir_loc->inode)) {
|
|
- gf_msg(this->name, GF_LOG_ERROR, 0, SHARD_MSG_INODE_PATH_FAILED,
|
|
- "Inode path failed on %s", bname);
|
|
- goto out;
|
|
- }
|
|
+ size_attr = GF_CALLOC(4, sizeof(int64_t), gf_shard_mt_int64_t);
|
|
+ if (!size_attr)
|
|
+ goto out;
|
|
|
|
- internal_dir_loc->name = strrchr(internal_dir_loc->path, '/');
|
|
- if (internal_dir_loc->name)
|
|
- internal_dir_loc->name++;
|
|
+ size_attr[0] = hton64(size);
|
|
+ /* As sharding evolves, it _may_ be necessary to embed more pieces of
|
|
+ * information within the same xattr. So allocating slots for them in
|
|
+ * advance. For now, only bytes 0-63 and 128-191 which would make up the
|
|
+ * current size and block count respectively of the file are valid.
|
|
+ */
|
|
+ size_attr[2] = hton64(block_count);
|
|
|
|
- ret = 0;
|
|
+ *size_attr_p = size_attr;
|
|
+
|
|
+ ret = 0;
|
|
out:
|
|
- return ret;
|
|
+ return ret;
|
|
}
|
|
|
|
-inode_t *
|
|
-__shard_update_shards_inode_list(inode_t *linked_inode, xlator_t *this,
|
|
- inode_t *base_inode, int block_num,
|
|
- uuid_t gfid)
|
|
-{
|
|
- char block_bname[256] = {
|
|
- 0,
|
|
- };
|
|
- inode_t *lru_inode = NULL;
|
|
- shard_priv_t *priv = NULL;
|
|
- shard_inode_ctx_t *ctx = NULL;
|
|
- shard_inode_ctx_t *lru_inode_ctx = NULL;
|
|
- shard_inode_ctx_t *lru_base_inode_ctx = NULL;
|
|
- inode_t *fsync_inode = NULL;
|
|
- inode_t *lru_base_inode = NULL;
|
|
- gf_boolean_t do_fsync = _gf_false;
|
|
-
|
|
- priv = this->private;
|
|
-
|
|
- shard_inode_ctx_get(linked_inode, this, &ctx);
|
|
-
|
|
- if (list_empty(&ctx->ilist)) {
|
|
- if (priv->inode_count + 1 <= priv->lru_limit) {
|
|
- /* If this inode was linked here for the first time (indicated
|
|
- * by empty list), and if there is still space in the priv list,
|
|
- * add this ctx to the tail of the list.
|
|
- */
|
|
- /* For as long as an inode is in lru list, we try to
|
|
- * keep it alive by holding a ref on it.
|
|
- */
|
|
- inode_ref(linked_inode);
|
|
- if (base_inode)
|
|
- gf_uuid_copy(ctx->base_gfid, base_inode->gfid);
|
|
- else
|
|
- gf_uuid_copy(ctx->base_gfid, gfid);
|
|
- ctx->block_num = block_num;
|
|
- list_add_tail(&ctx->ilist, &priv->ilist_head);
|
|
- priv->inode_count++;
|
|
- ctx->base_inode = inode_ref(base_inode);
|
|
- } else {
|
|
- /*If on the other hand there is no available slot for this inode
|
|
- * in the list, delete the lru inode from the head of the list,
|
|
- * unlink it. And in its place add this new inode into the list.
|
|
- */
|
|
- lru_inode_ctx = list_first_entry(&priv->ilist_head,
|
|
- shard_inode_ctx_t, ilist);
|
|
- GF_ASSERT(lru_inode_ctx->block_num > 0);
|
|
- lru_base_inode = lru_inode_ctx->base_inode;
|
|
- list_del_init(&lru_inode_ctx->ilist);
|
|
- lru_inode = inode_find(linked_inode->table,
|
|
- lru_inode_ctx->stat.ia_gfid);
|
|
- /* If the lru inode was part of the pending-fsync list,
|
|
- * the base inode needs to be unref'd, the lru inode
|
|
- * deleted from fsync list and fsync'd in a new frame,
|
|
- * and then unlinked in memory and forgotten.
|
|
- */
|
|
- if (!lru_base_inode)
|
|
- goto after_fsync_check;
|
|
- LOCK(&lru_base_inode->lock);
|
|
- LOCK(&lru_inode->lock);
|
|
- {
|
|
- if (!list_empty(&lru_inode_ctx->to_fsync_list)) {
|
|
- list_del_init(&lru_inode_ctx->to_fsync_list);
|
|
- lru_inode_ctx->fsync_needed = 0;
|
|
- do_fsync = _gf_true;
|
|
- __shard_inode_ctx_get(lru_base_inode, this,
|
|
- &lru_base_inode_ctx);
|
|
- lru_base_inode_ctx->fsync_count--;
|
|
- }
|
|
- }
|
|
- UNLOCK(&lru_inode->lock);
|
|
- UNLOCK(&lru_base_inode->lock);
|
|
-
|
|
- after_fsync_check:
|
|
- if (!do_fsync) {
|
|
- shard_make_block_bname(lru_inode_ctx->block_num,
|
|
- lru_inode_ctx->base_gfid, block_bname,
|
|
- sizeof(block_bname));
|
|
- /* The following unref corresponds to the ref held at
|
|
- * the time the shard was added to the lru list.
|
|
- */
|
|
- inode_unref(lru_inode);
|
|
- inode_unlink(lru_inode, priv->dot_shard_inode, block_bname);
|
|
- inode_forget(lru_inode, 0);
|
|
- } else {
|
|
- /* The following unref corresponds to the ref
|
|
- * held when the shard was added to fsync list.
|
|
- */
|
|
- inode_unref(lru_inode);
|
|
- fsync_inode = lru_inode;
|
|
- if (lru_base_inode)
|
|
- inode_unref(lru_base_inode);
|
|
- }
|
|
- /* The following unref corresponds to the ref
|
|
- * held by inode_find() above.
|
|
- */
|
|
- inode_unref(lru_inode);
|
|
-
|
|
- /* The following unref corresponds to the ref held on the base shard
|
|
- * at the time of adding shard inode to lru list
|
|
- */
|
|
- if (lru_base_inode)
|
|
- inode_unref(lru_base_inode);
|
|
-
|
|
- /* For as long as an inode is in lru list, we try to
|
|
- * keep it alive by holding a ref on it.
|
|
- */
|
|
- inode_ref(linked_inode);
|
|
- if (base_inode)
|
|
- gf_uuid_copy(ctx->base_gfid, base_inode->gfid);
|
|
- else
|
|
- gf_uuid_copy(ctx->base_gfid, gfid);
|
|
- ctx->block_num = block_num;
|
|
- ctx->base_inode = inode_ref(base_inode);
|
|
- list_add_tail(&ctx->ilist, &priv->ilist_head);
|
|
- }
|
|
- } else {
|
|
- /* If this is not the first time this inode is being operated on, move
|
|
- * it to the most recently used end of the list.
|
|
- */
|
|
- list_move_tail(&ctx->ilist, &priv->ilist_head);
|
|
- }
|
|
- return fsync_inode;
|
|
-}
|
|
+int shard_update_file_size(call_frame_t *frame, xlator_t *this, fd_t *fd,
|
|
+ loc_t *loc,
|
|
+ shard_post_update_size_fop_handler_t handler) {
|
|
+ int ret = -1;
|
|
+ int64_t *size_attr = NULL;
|
|
+ int64_t delta_blocks = 0;
|
|
+ inode_t *inode = NULL;
|
|
+ shard_local_t *local = NULL;
|
|
+ dict_t *xattr_req = NULL;
|
|
|
|
-int
|
|
-shard_common_failure_unwind(glusterfs_fop_t fop, call_frame_t *frame,
|
|
- int32_t op_ret, int32_t op_errno)
|
|
-{
|
|
- switch (fop) {
|
|
- case GF_FOP_LOOKUP:
|
|
- SHARD_STACK_UNWIND(lookup, frame, op_ret, op_errno, NULL, NULL,
|
|
- NULL, NULL);
|
|
- break;
|
|
- case GF_FOP_STAT:
|
|
- SHARD_STACK_UNWIND(stat, frame, op_ret, op_errno, NULL, NULL);
|
|
- break;
|
|
- case GF_FOP_FSTAT:
|
|
- SHARD_STACK_UNWIND(fstat, frame, op_ret, op_errno, NULL, NULL);
|
|
- break;
|
|
- case GF_FOP_TRUNCATE:
|
|
- SHARD_STACK_UNWIND(truncate, frame, op_ret, op_errno, NULL, NULL,
|
|
- NULL);
|
|
- break;
|
|
- case GF_FOP_FTRUNCATE:
|
|
- SHARD_STACK_UNWIND(ftruncate, frame, op_ret, op_errno, NULL, NULL,
|
|
- NULL);
|
|
- break;
|
|
- case GF_FOP_MKNOD:
|
|
- SHARD_STACK_UNWIND(mknod, frame, op_ret, op_errno, NULL, NULL, NULL,
|
|
- NULL, NULL);
|
|
- break;
|
|
- case GF_FOP_LINK:
|
|
- SHARD_STACK_UNWIND(link, frame, op_ret, op_errno, NULL, NULL, NULL,
|
|
- NULL, NULL);
|
|
- break;
|
|
- case GF_FOP_CREATE:
|
|
- SHARD_STACK_UNWIND(create, frame, op_ret, op_errno, NULL, NULL,
|
|
- NULL, NULL, NULL, NULL);
|
|
- break;
|
|
- case GF_FOP_UNLINK:
|
|
- SHARD_STACK_UNWIND(unlink, frame, op_ret, op_errno, NULL, NULL,
|
|
- NULL);
|
|
- break;
|
|
- case GF_FOP_RENAME:
|
|
- SHARD_STACK_UNWIND(rename, frame, op_ret, op_errno, NULL, NULL,
|
|
- NULL, NULL, NULL, NULL);
|
|
- break;
|
|
- case GF_FOP_WRITE:
|
|
- SHARD_STACK_UNWIND(writev, frame, op_ret, op_errno, NULL, NULL,
|
|
- NULL);
|
|
- break;
|
|
- case GF_FOP_FALLOCATE:
|
|
- SHARD_STACK_UNWIND(fallocate, frame, op_ret, op_errno, NULL, NULL,
|
|
- NULL);
|
|
- break;
|
|
- case GF_FOP_ZEROFILL:
|
|
- SHARD_STACK_UNWIND(zerofill, frame, op_ret, op_errno, NULL, NULL,
|
|
- NULL);
|
|
- break;
|
|
- case GF_FOP_DISCARD:
|
|
- SHARD_STACK_UNWIND(discard, frame, op_ret, op_errno, NULL, NULL,
|
|
- NULL);
|
|
- break;
|
|
- case GF_FOP_READ:
|
|
- SHARD_STACK_UNWIND(readv, frame, op_ret, op_errno, NULL, -1, NULL,
|
|
- NULL, NULL);
|
|
- break;
|
|
- case GF_FOP_FSYNC:
|
|
- SHARD_STACK_UNWIND(fsync, frame, op_ret, op_errno, NULL, NULL,
|
|
- NULL);
|
|
- break;
|
|
- case GF_FOP_REMOVEXATTR:
|
|
- SHARD_STACK_UNWIND(removexattr, frame, op_ret, op_errno, NULL);
|
|
- break;
|
|
- case GF_FOP_FREMOVEXATTR:
|
|
- SHARD_STACK_UNWIND(fremovexattr, frame, op_ret, op_errno, NULL);
|
|
- break;
|
|
- case GF_FOP_FGETXATTR:
|
|
- SHARD_STACK_UNWIND(fgetxattr, frame, op_ret, op_errno, NULL, NULL);
|
|
- break;
|
|
- case GF_FOP_GETXATTR:
|
|
- SHARD_STACK_UNWIND(getxattr, frame, op_ret, op_errno, NULL, NULL);
|
|
- break;
|
|
- case GF_FOP_FSETXATTR:
|
|
- SHARD_STACK_UNWIND(fsetxattr, frame, op_ret, op_errno, NULL);
|
|
- break;
|
|
- case GF_FOP_SETXATTR:
|
|
- SHARD_STACK_UNWIND(setxattr, frame, op_ret, op_errno, NULL);
|
|
- break;
|
|
- case GF_FOP_SETATTR:
|
|
- SHARD_STACK_UNWIND(setattr, frame, op_ret, op_errno, NULL, NULL,
|
|
- NULL);
|
|
- break;
|
|
- case GF_FOP_FSETATTR:
|
|
- SHARD_STACK_UNWIND(fsetattr, frame, op_ret, op_errno, NULL, NULL,
|
|
- NULL);
|
|
- break;
|
|
- case GF_FOP_SEEK:
|
|
- SHARD_STACK_UNWIND(seek, frame, op_ret, op_errno, 0, NULL);
|
|
- break;
|
|
- default:
|
|
- gf_msg(THIS->name, GF_LOG_WARNING, 0, SHARD_MSG_INVALID_FOP,
|
|
- "Invalid fop id = %d", fop);
|
|
- break;
|
|
- }
|
|
- return 0;
|
|
-}
|
|
+ local = frame->local;
|
|
+ local->post_update_size_handler = handler;
|
|
|
|
-int
|
|
-shard_common_inode_write_success_unwind(glusterfs_fop_t fop,
|
|
- call_frame_t *frame, int32_t op_ret)
|
|
-{
|
|
- shard_local_t *local = NULL;
|
|
+ xattr_req = dict_new();
|
|
+ if (!xattr_req) {
|
|
+ local->op_ret = -1;
|
|
+ local->op_errno = ENOMEM;
|
|
+ goto out;
|
|
+ }
|
|
+
|
|
+ if (fd)
|
|
+ inode = fd->inode;
|
|
+ else
|
|
+ inode = loc->inode;
|
|
+
|
|
+ /* If both size and block count have not changed, then skip the xattrop.
|
|
+ */
|
|
+ delta_blocks = GF_ATOMIC_GET(local->delta_blocks);
|
|
+ if ((local->delta_size + local->hole_size == 0) && (delta_blocks == 0)) {
|
|
+ goto out;
|
|
+ }
|
|
+
|
|
+ ret = shard_set_size_attrs(local->delta_size + local->hole_size, delta_blocks,
|
|
+ &size_attr);
|
|
+ if (ret) {
|
|
+ gf_msg(this->name, GF_LOG_ERROR, 0, SHARD_MSG_SIZE_SET_FAILED,
|
|
+ "Failed to set size attrs for %s", uuid_utoa(inode->gfid));
|
|
+ local->op_ret = -1;
|
|
+ local->op_errno = ENOMEM;
|
|
+ goto out;
|
|
+ }
|
|
+
|
|
+ ret = dict_set_bin(xattr_req, GF_XATTR_SHARD_FILE_SIZE, size_attr, 8 * 4);
|
|
+ if (ret) {
|
|
+ gf_msg(this->name, GF_LOG_ERROR, 0, SHARD_MSG_DICT_OP_FAILED,
|
|
+ "Failed to set key %s into dict. gfid=%s", GF_XATTR_SHARD_FILE_SIZE,
|
|
+ uuid_utoa(inode->gfid));
|
|
+ GF_FREE(size_attr);
|
|
+ local->op_ret = -1;
|
|
+ local->op_errno = ENOMEM;
|
|
+ goto out;
|
|
+ }
|
|
|
|
- local = frame->local;
|
|
+ if (fd)
|
|
+ STACK_WIND(frame, shard_update_file_size_cbk, FIRST_CHILD(this),
|
|
+ FIRST_CHILD(this)->fops->fxattrop, fd, GF_XATTROP_ADD_ARRAY64,
|
|
+ xattr_req, NULL);
|
|
+ else
|
|
+ STACK_WIND(frame, shard_update_file_size_cbk, FIRST_CHILD(this),
|
|
+ FIRST_CHILD(this)->fops->xattrop, loc, GF_XATTROP_ADD_ARRAY64,
|
|
+ xattr_req, NULL);
|
|
|
|
- switch (fop) {
|
|
- case GF_FOP_WRITE:
|
|
- SHARD_STACK_UNWIND(writev, frame, op_ret, 0, &local->prebuf,
|
|
- &local->postbuf, local->xattr_rsp);
|
|
- break;
|
|
- case GF_FOP_FALLOCATE:
|
|
- SHARD_STACK_UNWIND(fallocate, frame, op_ret, 0, &local->prebuf,
|
|
- &local->postbuf, local->xattr_rsp);
|
|
- break;
|
|
- case GF_FOP_ZEROFILL:
|
|
- SHARD_STACK_UNWIND(zerofill, frame, op_ret, 0, &local->prebuf,
|
|
- &local->postbuf, local->xattr_rsp);
|
|
- break;
|
|
- case GF_FOP_DISCARD:
|
|
- SHARD_STACK_UNWIND(discard, frame, op_ret, 0, &local->prebuf,
|
|
- &local->postbuf, local->xattr_rsp);
|
|
- break;
|
|
- default:
|
|
- gf_msg(THIS->name, GF_LOG_WARNING, 0, SHARD_MSG_INVALID_FOP,
|
|
- "Invalid fop id = %d", fop);
|
|
- break;
|
|
- }
|
|
- return 0;
|
|
-}
|
|
+ dict_unref(xattr_req);
|
|
+ return 0;
|
|
|
|
-int
|
|
-shard_evicted_inode_fsync_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
|
|
- int32_t op_ret, int32_t op_errno,
|
|
- struct iatt *prebuf, struct iatt *postbuf,
|
|
- dict_t *xdata)
|
|
-{
|
|
- char block_bname[256] = {
|
|
- 0,
|
|
- };
|
|
- fd_t *anon_fd = cookie;
|
|
- inode_t *shard_inode = NULL;
|
|
- shard_inode_ctx_t *ctx = NULL;
|
|
- shard_priv_t *priv = NULL;
|
|
+out:
|
|
+ if (xattr_req)
|
|
+ dict_unref(xattr_req);
|
|
+ handler(frame, this);
|
|
+ return 0;
|
|
+}
|
|
+
|
|
+static inode_t *shard_link_internal_dir_inode(shard_local_t *local,
|
|
+ inode_t *inode, struct iatt *buf,
|
|
+ shard_internal_dir_type_t type) {
|
|
+ inode_t *linked_inode = NULL;
|
|
+ shard_priv_t *priv = NULL;
|
|
+ char *bname = NULL;
|
|
+ inode_t **priv_inode = NULL;
|
|
+ inode_t *parent = NULL;
|
|
+
|
|
+ priv = THIS->private;
|
|
+
|
|
+ switch (type) {
|
|
+ case SHARD_INTERNAL_DIR_DOT_SHARD:
|
|
+ bname = GF_SHARD_DIR;
|
|
+ priv_inode = &priv->dot_shard_inode;
|
|
+ parent = inode->table->root;
|
|
+ break;
|
|
+ case SHARD_INTERNAL_DIR_DOT_SHARD_REMOVE_ME:
|
|
+ bname = GF_SHARD_REMOVE_ME_DIR;
|
|
+ priv_inode = &priv->dot_shard_rm_inode;
|
|
+ parent = priv->dot_shard_inode;
|
|
+ break;
|
|
+ default:
|
|
+ break;
|
|
+ }
|
|
+
|
|
+ linked_inode = inode_link(inode, parent, bname, buf);
|
|
+ inode_lookup(linked_inode);
|
|
+ *priv_inode = linked_inode;
|
|
+ return linked_inode;
|
|
+}
|
|
+
|
|
+int shard_refresh_internal_dir_cbk(call_frame_t *frame, void *cookie,
|
|
+ xlator_t *this, int32_t op_ret,
|
|
+ int32_t op_errno, inode_t *inode,
|
|
+ struct iatt *buf, dict_t *xdata,
|
|
+ struct iatt *postparent) {
|
|
+ shard_local_t *local = NULL;
|
|
+ inode_t *linked_inode = NULL;
|
|
+ shard_internal_dir_type_t type = (shard_internal_dir_type_t)cookie;
|
|
+
|
|
+ local = frame->local;
|
|
+
|
|
+ if (op_ret) {
|
|
+ local->op_ret = op_ret;
|
|
+ local->op_errno = op_errno;
|
|
+ goto out;
|
|
+ }
|
|
+
|
|
+ /* To-Do: Fix refcount increment per call to
|
|
+ * shard_link_internal_dir_inode().
|
|
+ */
|
|
+ linked_inode = shard_link_internal_dir_inode(local, inode, buf, type);
|
|
+ shard_inode_ctx_mark_dir_refreshed(linked_inode, this);
|
|
+out:
|
|
+ shard_common_resolve_shards(frame, this, local->post_res_handler);
|
|
+ return 0;
|
|
+}
|
|
+
|
|
+int shard_refresh_internal_dir(call_frame_t *frame, xlator_t *this,
|
|
+ shard_internal_dir_type_t type) {
|
|
+ loc_t loc = {
|
|
+ 0,
|
|
+ };
|
|
+ inode_t *inode = NULL;
|
|
+ shard_priv_t *priv = NULL;
|
|
+ shard_local_t *local = NULL;
|
|
+ uuid_t gfid = {
|
|
+ 0,
|
|
+ };
|
|
+
|
|
+ local = frame->local;
|
|
+ priv = this->private;
|
|
+
|
|
+ switch (type) {
|
|
+ case SHARD_INTERNAL_DIR_DOT_SHARD:
|
|
+ gf_uuid_copy(gfid, priv->dot_shard_gfid);
|
|
+ break;
|
|
+ case SHARD_INTERNAL_DIR_DOT_SHARD_REMOVE_ME:
|
|
+ gf_uuid_copy(gfid, priv->dot_shard_rm_gfid);
|
|
+ break;
|
|
+ default:
|
|
+ break;
|
|
+ }
|
|
+
|
|
+ inode = inode_find(this->itable, gfid);
|
|
+
|
|
+ if (!shard_inode_ctx_needs_lookup(inode, this)) {
|
|
+ local->op_ret = 0;
|
|
+ goto out;
|
|
+ }
|
|
|
|
- priv = this->private;
|
|
+ /* Plain assignment because the ref is already taken above through
|
|
+ * call to inode_find()
|
|
+ */
|
|
+ loc.inode = inode;
|
|
+ gf_uuid_copy(loc.gfid, gfid);
|
|
|
|
- if (anon_fd == NULL || op_ret < 0) {
|
|
- gf_msg(this->name, GF_LOG_WARNING, op_errno, SHARD_MSG_MEMALLOC_FAILED,
|
|
- "fsync failed on shard");
|
|
- goto out;
|
|
- }
|
|
- shard_inode = anon_fd->inode;
|
|
+ STACK_WIND_COOKIE(frame, shard_refresh_internal_dir_cbk, (void *)(long)type,
|
|
+ FIRST_CHILD(this), FIRST_CHILD(this)->fops->lookup, &loc,
|
|
+ NULL);
|
|
+ loc_wipe(&loc);
|
|
|
|
- LOCK(&priv->lock);
|
|
- LOCK(&shard_inode->lock);
|
|
- {
|
|
- __shard_inode_ctx_get(shard_inode, this, &ctx);
|
|
- if ((list_empty(&ctx->to_fsync_list)) && (list_empty(&ctx->ilist))) {
|
|
- shard_make_block_bname(ctx->block_num, shard_inode->gfid,
|
|
- block_bname, sizeof(block_bname));
|
|
- inode_unlink(shard_inode, priv->dot_shard_inode, block_bname);
|
|
- /* The following unref corresponds to the ref held by
|
|
- * inode_link() at the time the shard was created or
|
|
- * looked up
|
|
- */
|
|
- inode_unref(shard_inode);
|
|
- inode_forget(shard_inode, 0);
|
|
- }
|
|
- }
|
|
- UNLOCK(&shard_inode->lock);
|
|
- UNLOCK(&priv->lock);
|
|
+ return 0;
|
|
|
|
out:
|
|
- if (anon_fd)
|
|
- fd_unref(anon_fd);
|
|
- STACK_DESTROY(frame->root);
|
|
- return 0;
|
|
+ shard_common_resolve_shards(frame, this, local->post_res_handler);
|
|
+ return 0;
|
|
}
|
|
|
|
-int
|
|
-shard_initiate_evicted_inode_fsync(xlator_t *this, inode_t *inode)
|
|
-{
|
|
- fd_t *anon_fd = NULL;
|
|
- call_frame_t *fsync_frame = NULL;
|
|
+int shard_lookup_internal_dir_cbk(call_frame_t *frame, void *cookie,
|
|
+ xlator_t *this, int32_t op_ret,
|
|
+ int32_t op_errno, inode_t *inode,
|
|
+ struct iatt *buf, dict_t *xdata,
|
|
+ struct iatt *postparent) {
|
|
+ inode_t *link_inode = NULL;
|
|
+ shard_local_t *local = NULL;
|
|
+ shard_internal_dir_type_t type = (shard_internal_dir_type_t)cookie;
|
|
|
|
- fsync_frame = create_frame(this, this->ctx->pool);
|
|
- if (!fsync_frame) {
|
|
- gf_msg(this->name, GF_LOG_WARNING, ENOMEM, SHARD_MSG_MEMALLOC_FAILED,
|
|
- "Failed to create new frame "
|
|
- "to fsync shard");
|
|
- return -1;
|
|
- }
|
|
+ local = frame->local;
|
|
|
|
- anon_fd = fd_anonymous(inode);
|
|
- if (!anon_fd) {
|
|
- gf_msg(this->name, GF_LOG_WARNING, ENOMEM, SHARD_MSG_MEMALLOC_FAILED,
|
|
- "Failed to create anon fd to"
|
|
- " fsync shard");
|
|
- STACK_DESTROY(fsync_frame->root);
|
|
- return -1;
|
|
- }
|
|
+ if (op_ret) {
|
|
+ local->op_ret = op_ret;
|
|
+ local->op_errno = op_errno;
|
|
+ goto unwind;
|
|
+ }
|
|
+
|
|
+ if (!IA_ISDIR(buf->ia_type)) {
|
|
+ gf_msg(this->name, GF_LOG_CRITICAL, 0, SHARD_MSG_DOT_SHARD_NODIR,
|
|
+ "%s already exists and "
|
|
+ "is not a directory. Please remove it from all bricks "
|
|
+ "and try again",
|
|
+ shard_internal_dir_string(type));
|
|
+ local->op_ret = -1;
|
|
+ local->op_errno = EIO;
|
|
+ goto unwind;
|
|
+ }
|
|
+
|
|
+ link_inode = shard_link_internal_dir_inode(local, inode, buf, type);
|
|
+ if (link_inode != inode) {
|
|
+ shard_refresh_internal_dir(frame, this, type);
|
|
+ } else {
|
|
+ shard_inode_ctx_mark_dir_refreshed(link_inode, this);
|
|
+ shard_common_resolve_shards(frame, this, local->post_res_handler);
|
|
+ }
|
|
+ return 0;
|
|
|
|
- STACK_WIND_COOKIE(fsync_frame, shard_evicted_inode_fsync_cbk, anon_fd,
|
|
- FIRST_CHILD(this), FIRST_CHILD(this)->fops->fsync,
|
|
- anon_fd, 1, NULL);
|
|
- return 0;
|
|
-}
|
|
+unwind:
|
|
+ local->post_res_handler(frame, this);
|
|
+ return 0;
|
|
+}
|
|
+
|
|
+int shard_lookup_internal_dir(call_frame_t *frame, xlator_t *this,
|
|
+ shard_post_resolve_fop_handler_t post_res_handler,
|
|
+ shard_internal_dir_type_t type) {
|
|
+ int ret = -1;
|
|
+ dict_t *xattr_req = NULL;
|
|
+ shard_priv_t *priv = NULL;
|
|
+ shard_local_t *local = NULL;
|
|
+ uuid_t *gfid = NULL;
|
|
+ loc_t *loc = NULL;
|
|
+ gf_boolean_t free_gfid = _gf_true;
|
|
+
|
|
+ local = frame->local;
|
|
+ priv = this->private;
|
|
+ local->post_res_handler = post_res_handler;
|
|
+
|
|
+ gfid = GF_MALLOC(sizeof(uuid_t), gf_common_mt_uuid_t);
|
|
+ if (!gfid)
|
|
+ goto err;
|
|
+
|
|
+ xattr_req = dict_new();
|
|
+ if (!xattr_req) {
|
|
+ local->op_ret = -1;
|
|
+ local->op_errno = ENOMEM;
|
|
+ goto err;
|
|
+ }
|
|
+
|
|
+ switch (type) {
|
|
+ case SHARD_INTERNAL_DIR_DOT_SHARD:
|
|
+ gf_uuid_copy(*gfid, priv->dot_shard_gfid);
|
|
+ loc = &local->dot_shard_loc;
|
|
+ break;
|
|
+ case SHARD_INTERNAL_DIR_DOT_SHARD_REMOVE_ME:
|
|
+ gf_uuid_copy(*gfid, priv->dot_shard_rm_gfid);
|
|
+ loc = &local->dot_shard_rm_loc;
|
|
+ break;
|
|
+ default:
|
|
+ bzero(*gfid, sizeof(uuid_t));
|
|
+ break;
|
|
+ }
|
|
+
|
|
+ ret = dict_set_gfuuid(xattr_req, "gfid-req", *gfid, false);
|
|
+ if (ret) {
|
|
+ gf_msg(this->name, GF_LOG_ERROR, 0, SHARD_MSG_DICT_OP_FAILED,
|
|
+ "Failed to set gfid of %s into dict",
|
|
+ shard_internal_dir_string(type));
|
|
+ local->op_ret = -1;
|
|
+ local->op_errno = ENOMEM;
|
|
+ goto err;
|
|
+ } else {
|
|
+ free_gfid = _gf_false;
|
|
+ }
|
|
|
|
-int
|
|
-shard_common_resolve_shards(call_frame_t *frame, xlator_t *this,
|
|
- shard_post_resolve_fop_handler_t post_res_handler)
|
|
-{
|
|
- int i = -1;
|
|
- uint32_t shard_idx_iter = 0;
|
|
- char path[PATH_MAX] = {
|
|
- 0,
|
|
- };
|
|
- uuid_t gfid = {
|
|
- 0,
|
|
- };
|
|
- inode_t *inode = NULL;
|
|
- inode_t *res_inode = NULL;
|
|
- inode_t *fsync_inode = NULL;
|
|
- shard_priv_t *priv = NULL;
|
|
- shard_local_t *local = NULL;
|
|
-
|
|
- priv = this->private;
|
|
- local = frame->local;
|
|
- local->call_count = 0;
|
|
- shard_idx_iter = local->first_block;
|
|
- res_inode = local->resolver_base_inode;
|
|
- if (res_inode)
|
|
- gf_uuid_copy(gfid, res_inode->gfid);
|
|
- else
|
|
- gf_uuid_copy(gfid, local->base_gfid);
|
|
+ STACK_WIND_COOKIE(frame, shard_lookup_internal_dir_cbk, (void *)(long)type,
|
|
+ FIRST_CHILD(this), FIRST_CHILD(this)->fops->lookup, loc,
|
|
+ xattr_req);
|
|
|
|
- if ((local->op_ret < 0) || (local->resolve_not))
|
|
- goto out;
|
|
+ dict_unref(xattr_req);
|
|
+ return 0;
|
|
|
|
- while (shard_idx_iter <= local->last_block) {
|
|
- i++;
|
|
- if (shard_idx_iter == 0) {
|
|
- local->inode_list[i] = inode_ref(res_inode);
|
|
- shard_idx_iter++;
|
|
- continue;
|
|
- }
|
|
+err:
|
|
+ if (xattr_req)
|
|
+ dict_unref(xattr_req);
|
|
+ if (free_gfid)
|
|
+ GF_FREE(gfid);
|
|
+ post_res_handler(frame, this);
|
|
+ return 0;
|
|
+}
|
|
+
|
|
+static void shard_inode_ctx_update(inode_t *inode, xlator_t *this,
|
|
+ dict_t *xdata, struct iatt *buf) {
|
|
+ int ret = 0;
|
|
+ uint64_t size = 0;
|
|
+ void *bsize = NULL;
|
|
+
|
|
+ if (shard_inode_ctx_get_block_size(inode, this, &size)) {
|
|
+ /* Fresh lookup */
|
|
+ ret = dict_get_ptr(xdata, GF_XATTR_SHARD_BLOCK_SIZE, &bsize);
|
|
+ if (!ret)
|
|
+ size = ntoh64(*((uint64_t *)bsize));
|
|
+ /* If the file is sharded, set its block size, otherwise just
|
|
+ * set 0.
|
|
+ */
|
|
|
|
- shard_make_block_abspath(shard_idx_iter, gfid, path, sizeof(path));
|
|
-
|
|
- inode = NULL;
|
|
- inode = inode_resolve(this->itable, path);
|
|
- if (inode) {
|
|
- gf_msg_debug(this->name, 0,
|
|
- "Shard %d already "
|
|
- "present. gfid=%s. Saving inode for future.",
|
|
- shard_idx_iter, uuid_utoa(inode->gfid));
|
|
- local->inode_list[i] = inode;
|
|
- /* Let the ref on the inodes that are already present
|
|
- * in inode table still be held so that they don't get
|
|
- * forgotten by the time the fop reaches the actual
|
|
- * write stage.
|
|
- */
|
|
- LOCK(&priv->lock);
|
|
- {
|
|
- fsync_inode = __shard_update_shards_inode_list(
|
|
- inode, this, res_inode, shard_idx_iter, gfid);
|
|
- }
|
|
- UNLOCK(&priv->lock);
|
|
- shard_idx_iter++;
|
|
- if (fsync_inode)
|
|
- shard_initiate_evicted_inode_fsync(this, fsync_inode);
|
|
- continue;
|
|
- } else {
|
|
- local->call_count++;
|
|
- shard_idx_iter++;
|
|
- }
|
|
- }
|
|
-out:
|
|
- post_res_handler(frame, this);
|
|
- return 0;
|
|
+ shard_inode_ctx_set(inode, this, buf, size, SHARD_MASK_BLOCK_SIZE);
|
|
+ }
|
|
+ /* If the file is sharded, also set the remaining attributes,
|
|
+ * except for ia_size and ia_blocks.
|
|
+ */
|
|
+ if (size) {
|
|
+ shard_inode_ctx_set(inode, this, buf, 0, SHARD_LOOKUP_MASK);
|
|
+ (void)shard_inode_ctx_invalidate(inode, this, buf);
|
|
+ }
|
|
+}
|
|
+
|
|
+int shard_delete_shards(void *opaque);
|
|
+
|
|
+int shard_delete_shards_cbk(int ret, call_frame_t *frame, void *data);
|
|
+
|
|
+int shard_start_background_deletion(xlator_t *this) {
|
|
+ int ret = 0;
|
|
+ gf_boolean_t i_cleanup = _gf_true;
|
|
+ shard_priv_t *priv = NULL;
|
|
+ call_frame_t *cleanup_frame = NULL;
|
|
+
|
|
+ priv = this->private;
|
|
+
|
|
+ LOCK(&priv->lock);
|
|
+ {
|
|
+ switch (priv->bg_del_state) {
|
|
+ case SHARD_BG_DELETION_NONE:
|
|
+ i_cleanup = _gf_true;
|
|
+ priv->bg_del_state = SHARD_BG_DELETION_LAUNCHING;
|
|
+ break;
|
|
+ case SHARD_BG_DELETION_LAUNCHING:
|
|
+ i_cleanup = _gf_false;
|
|
+ break;
|
|
+ case SHARD_BG_DELETION_IN_PROGRESS:
|
|
+ priv->bg_del_state = SHARD_BG_DELETION_LAUNCHING;
|
|
+ i_cleanup = _gf_false;
|
|
+ break;
|
|
+ default:
|
|
+ break;
|
|
+ }
|
|
+ }
|
|
+ UNLOCK(&priv->lock);
|
|
+ if (!i_cleanup)
|
|
+ return 0;
|
|
+
|
|
+ cleanup_frame = create_frame(this, this->ctx->pool);
|
|
+ if (!cleanup_frame) {
|
|
+ gf_msg(this->name, GF_LOG_WARNING, ENOMEM, SHARD_MSG_MEMALLOC_FAILED,
|
|
+ "Failed to create "
|
|
+ "new frame to delete shards");
|
|
+ ret = -ENOMEM;
|
|
+ goto err;
|
|
+ }
|
|
+
|
|
+ set_lk_owner_from_ptr(&cleanup_frame->root->lk_owner, cleanup_frame->root);
|
|
+
|
|
+ ret = synctask_new(this->ctx->env, shard_delete_shards,
|
|
+ shard_delete_shards_cbk, cleanup_frame, cleanup_frame);
|
|
+ if (ret < 0) {
|
|
+ gf_msg(this->name, GF_LOG_WARNING, errno, SHARD_MSG_SHARDS_DELETION_FAILED,
|
|
+ "failed to create task to do background "
|
|
+ "cleanup of shards");
|
|
+ STACK_DESTROY(cleanup_frame->root);
|
|
+ goto err;
|
|
+ }
|
|
+ return 0;
|
|
+
|
|
+err:
|
|
+ LOCK(&priv->lock);
|
|
+ { priv->bg_del_state = SHARD_BG_DELETION_NONE; }
|
|
+ UNLOCK(&priv->lock);
|
|
+ return ret;
|
|
}
|
|
|
|
-int
|
|
-shard_update_file_size_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
|
|
- int32_t op_ret, int32_t op_errno, dict_t *dict,
|
|
- dict_t *xdata)
|
|
-{
|
|
- inode_t *inode = NULL;
|
|
- shard_local_t *local = NULL;
|
|
+int shard_lookup_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
|
|
+ int32_t op_ret, int32_t op_errno, inode_t *inode,
|
|
+ struct iatt *buf, dict_t *xdata, struct iatt *postparent) {
|
|
+ int ret = -1;
|
|
+ shard_priv_t *priv = NULL;
|
|
+ gf_boolean_t i_start_cleanup = _gf_false;
|
|
|
|
- local = frame->local;
|
|
+ priv = this->private;
|
|
|
|
- if ((local->fd) && (local->fd->inode))
|
|
- inode = local->fd->inode;
|
|
- else if (local->loc.inode)
|
|
- inode = local->loc.inode;
|
|
+ if (op_ret < 0)
|
|
+ goto unwind;
|
|
|
|
- if (op_ret < 0) {
|
|
- gf_msg(this->name, GF_LOG_ERROR, op_errno,
|
|
- SHARD_MSG_UPDATE_FILE_SIZE_FAILED,
|
|
- "Update to file size"
|
|
- " xattr failed on %s",
|
|
- uuid_utoa(inode->gfid));
|
|
- local->op_ret = op_ret;
|
|
- local->op_errno = op_errno;
|
|
- goto err;
|
|
- }
|
|
+ if (IA_ISDIR(buf->ia_type))
|
|
+ goto unwind;
|
|
|
|
- if (shard_modify_size_and_block_count(&local->postbuf, dict)) {
|
|
- local->op_ret = -1;
|
|
- local->op_errno = ENOMEM;
|
|
- goto err;
|
|
- }
|
|
-err:
|
|
- local->post_update_size_handler(frame, this);
|
|
- return 0;
|
|
-}
|
|
+ /* Also, if the file is sharded, get the file size and block cnt xattr,
|
|
+ * and store them in the stbuf appropriately.
|
|
+ */
|
|
|
|
-int
|
|
-shard_set_size_attrs(int64_t size, int64_t block_count, int64_t **size_attr_p)
|
|
-{
|
|
- int ret = -1;
|
|
- int64_t *size_attr = NULL;
|
|
+ if (dict_get(xdata, GF_XATTR_SHARD_FILE_SIZE) &&
|
|
+ frame->root->pid != GF_CLIENT_PID_GSYNCD)
|
|
+ shard_modify_size_and_block_count(buf, xdata);
|
|
|
|
- if (!size_attr_p)
|
|
- goto out;
|
|
+ /* If this was a fresh lookup, there are two possibilities:
|
|
+ * 1) If the file is sharded (indicated by the presence of block size
|
|
+ * xattr), store this block size, along with rdev and mode in its
|
|
+ * inode ctx.
|
|
+ * 2) If the file is not sharded, store size along with rdev and mode
|
|
+ * (which are anyway don't cares) in inode ctx. Since @ctx_tmp is
|
|
+ * already initialised to all zeroes, nothing more needs to be done.
|
|
+ */
|
|
|
|
- size_attr = GF_CALLOC(4, sizeof(int64_t), gf_shard_mt_int64_t);
|
|
- if (!size_attr)
|
|
- goto out;
|
|
+ (void)shard_inode_ctx_update(inode, this, xdata, buf);
|
|
|
|
- size_attr[0] = hton64(size);
|
|
- /* As sharding evolves, it _may_ be necessary to embed more pieces of
|
|
- * information within the same xattr. So allocating slots for them in
|
|
- * advance. For now, only bytes 0-63 and 128-191 which would make up the
|
|
- * current size and block count respectively of the file are valid.
|
|
- */
|
|
- size_attr[2] = hton64(block_count);
|
|
+ LOCK(&priv->lock);
|
|
+ {
|
|
+ if (priv->first_lookup_done == _gf_false) {
|
|
+ priv->first_lookup_done = _gf_true;
|
|
+ i_start_cleanup = _gf_true;
|
|
+ }
|
|
+ }
|
|
+ UNLOCK(&priv->lock);
|
|
|
|
- *size_attr_p = size_attr;
|
|
+ if (!i_start_cleanup)
|
|
+ goto unwind;
|
|
|
|
- ret = 0;
|
|
-out:
|
|
- return ret;
|
|
+ ret = shard_start_background_deletion(this);
|
|
+ if (ret < 0) {
|
|
+ LOCK(&priv->lock);
|
|
+ { priv->first_lookup_done = _gf_false; }
|
|
+ UNLOCK(&priv->lock);
|
|
+ }
|
|
+
|
|
+unwind:
|
|
+ SHARD_STACK_UNWIND(lookup, frame, op_ret, op_errno, inode, buf, xdata,
|
|
+ postparent);
|
|
+ return 0;
|
|
}
|
|
|
|
-int
|
|
-shard_update_file_size(call_frame_t *frame, xlator_t *this, fd_t *fd,
|
|
- loc_t *loc, shard_post_update_size_fop_handler_t handler)
|
|
-{
|
|
- int ret = -1;
|
|
- int64_t *size_attr = NULL;
|
|
- int64_t delta_blocks = 0;
|
|
- inode_t *inode = NULL;
|
|
- shard_local_t *local = NULL;
|
|
- dict_t *xattr_req = NULL;
|
|
+int shard_lookup(call_frame_t *frame, xlator_t *this, loc_t *loc,
|
|
+ dict_t *xattr_req) {
|
|
+ int ret = -1;
|
|
+ int32_t op_errno = ENOMEM;
|
|
+ uint64_t block_size = 0;
|
|
+ shard_local_t *local = NULL;
|
|
|
|
- local = frame->local;
|
|
- local->post_update_size_handler = handler;
|
|
+ this->itable = loc->inode->table;
|
|
+ if (frame->root->pid != GF_CLIENT_PID_GSYNCD) {
|
|
+ SHARD_ENTRY_FOP_CHECK(loc, op_errno, err);
|
|
+ }
|
|
|
|
- xattr_req = dict_new();
|
|
- if (!xattr_req) {
|
|
- local->op_ret = -1;
|
|
- local->op_errno = ENOMEM;
|
|
- goto out;
|
|
- }
|
|
+ local = mem_get0(this->local_pool);
|
|
+ if (!local)
|
|
+ goto err;
|
|
|
|
- if (fd)
|
|
- inode = fd->inode;
|
|
- else
|
|
- inode = loc->inode;
|
|
+ frame->local = local;
|
|
|
|
- /* If both size and block count have not changed, then skip the xattrop.
|
|
- */
|
|
- delta_blocks = GF_ATOMIC_GET(local->delta_blocks);
|
|
- if ((local->delta_size + local->hole_size == 0) && (delta_blocks == 0)) {
|
|
- goto out;
|
|
- }
|
|
+ loc_copy(&local->loc, loc);
|
|
|
|
- ret = shard_set_size_attrs(local->delta_size + local->hole_size,
|
|
- delta_blocks, &size_attr);
|
|
+ local->xattr_req = xattr_req ? dict_ref(xattr_req) : dict_new();
|
|
+ if (!local->xattr_req)
|
|
+ goto err;
|
|
+
|
|
+ if (shard_inode_ctx_get_block_size(loc->inode, this, &block_size)) {
|
|
+ ret = dict_set_uint64(local->xattr_req, GF_XATTR_SHARD_BLOCK_SIZE, 0);
|
|
if (ret) {
|
|
- gf_msg(this->name, GF_LOG_ERROR, 0, SHARD_MSG_SIZE_SET_FAILED,
|
|
- "Failed to set size attrs for %s", uuid_utoa(inode->gfid));
|
|
- local->op_ret = -1;
|
|
- local->op_errno = ENOMEM;
|
|
- goto out;
|
|
+ gf_msg(this->name, GF_LOG_WARNING, 0, SHARD_MSG_DICT_OP_FAILED,
|
|
+ "Failed to set dict"
|
|
+ " value: key:%s for path %s",
|
|
+ GF_XATTR_SHARD_BLOCK_SIZE, loc->path);
|
|
+ goto err;
|
|
}
|
|
+ }
|
|
|
|
- ret = dict_set_bin(xattr_req, GF_XATTR_SHARD_FILE_SIZE, size_attr, 8 * 4);
|
|
+ if (frame->root->pid != GF_CLIENT_PID_GSYNCD) {
|
|
+ ret = dict_set_uint64(local->xattr_req, GF_XATTR_SHARD_FILE_SIZE, 8 * 4);
|
|
if (ret) {
|
|
- gf_msg(this->name, GF_LOG_ERROR, 0, SHARD_MSG_DICT_OP_FAILED,
|
|
- "Failed to set key %s into dict. gfid=%s",
|
|
- GF_XATTR_SHARD_FILE_SIZE, uuid_utoa(inode->gfid));
|
|
- GF_FREE(size_attr);
|
|
- local->op_ret = -1;
|
|
- local->op_errno = ENOMEM;
|
|
- goto out;
|
|
+ gf_msg(this->name, GF_LOG_WARNING, 0, SHARD_MSG_DICT_OP_FAILED,
|
|
+ "Failed to set dict value: key:%s for path %s.",
|
|
+ GF_XATTR_SHARD_FILE_SIZE, loc->path);
|
|
+ goto err;
|
|
}
|
|
+ }
|
|
|
|
- if (fd)
|
|
- STACK_WIND(frame, shard_update_file_size_cbk, FIRST_CHILD(this),
|
|
- FIRST_CHILD(this)->fops->fxattrop, fd,
|
|
- GF_XATTROP_ADD_ARRAY64, xattr_req, NULL);
|
|
- else
|
|
- STACK_WIND(frame, shard_update_file_size_cbk, FIRST_CHILD(this),
|
|
- FIRST_CHILD(this)->fops->xattrop, loc,
|
|
- GF_XATTROP_ADD_ARRAY64, xattr_req, NULL);
|
|
-
|
|
- dict_unref(xattr_req);
|
|
- return 0;
|
|
-
|
|
-out:
|
|
- if (xattr_req)
|
|
- dict_unref(xattr_req);
|
|
- handler(frame, this);
|
|
- return 0;
|
|
-}
|
|
-
|
|
-static inode_t *
|
|
-shard_link_internal_dir_inode(shard_local_t *local, inode_t *inode,
|
|
- struct iatt *buf, shard_internal_dir_type_t type)
|
|
-{
|
|
- inode_t *linked_inode = NULL;
|
|
- shard_priv_t *priv = NULL;
|
|
- char *bname = NULL;
|
|
- inode_t **priv_inode = NULL;
|
|
- inode_t *parent = NULL;
|
|
-
|
|
- priv = THIS->private;
|
|
-
|
|
- switch (type) {
|
|
- case SHARD_INTERNAL_DIR_DOT_SHARD:
|
|
- bname = GF_SHARD_DIR;
|
|
- priv_inode = &priv->dot_shard_inode;
|
|
- parent = inode->table->root;
|
|
- break;
|
|
- case SHARD_INTERNAL_DIR_DOT_SHARD_REMOVE_ME:
|
|
- bname = GF_SHARD_REMOVE_ME_DIR;
|
|
- priv_inode = &priv->dot_shard_rm_inode;
|
|
- parent = priv->dot_shard_inode;
|
|
- break;
|
|
- default:
|
|
- break;
|
|
- }
|
|
+ if ((xattr_req) && (dict_get(xattr_req, GF_CONTENT_KEY)))
|
|
+ dict_del(xattr_req, GF_CONTENT_KEY);
|
|
|
|
- linked_inode = inode_link(inode, parent, bname, buf);
|
|
- inode_lookup(linked_inode);
|
|
- *priv_inode = linked_inode;
|
|
- return linked_inode;
|
|
+ STACK_WIND(frame, shard_lookup_cbk, FIRST_CHILD(this),
|
|
+ FIRST_CHILD(this)->fops->lookup, loc, local->xattr_req);
|
|
+ return 0;
|
|
+err:
|
|
+ shard_common_failure_unwind(GF_FOP_LOOKUP, frame, -1, op_errno);
|
|
+ return 0;
|
|
}
|
|
|
|
-int
|
|
-shard_refresh_internal_dir_cbk(call_frame_t *frame, void *cookie,
|
|
+int shard_lookup_base_file_cbk(call_frame_t *frame, void *cookie,
|
|
xlator_t *this, int32_t op_ret, int32_t op_errno,
|
|
inode_t *inode, struct iatt *buf, dict_t *xdata,
|
|
- struct iatt *postparent)
|
|
-{
|
|
- shard_local_t *local = NULL;
|
|
- inode_t *linked_inode = NULL;
|
|
- shard_internal_dir_type_t type = (shard_internal_dir_type_t)cookie;
|
|
-
|
|
- local = frame->local;
|
|
-
|
|
- if (op_ret) {
|
|
- local->op_ret = op_ret;
|
|
- local->op_errno = op_errno;
|
|
- goto out;
|
|
- }
|
|
+ struct iatt *postparent) {
|
|
+ int ret = -1;
|
|
+ int32_t mask = SHARD_INODE_WRITE_MASK;
|
|
+ shard_local_t *local = NULL;
|
|
+ shard_inode_ctx_t ctx = {
|
|
+ 0,
|
|
+ };
|
|
+
|
|
+ local = frame->local;
|
|
+
|
|
+ if (op_ret < 0) {
|
|
+ gf_msg(this->name, GF_LOG_ERROR, op_errno,
|
|
+ SHARD_MSG_BASE_FILE_LOOKUP_FAILED, "Lookup on base file"
|
|
+ " failed : %s",
|
|
+ loc_gfid_utoa(&(local->loc)));
|
|
+ local->op_ret = op_ret;
|
|
+ local->op_errno = op_errno;
|
|
+ goto unwind;
|
|
+ }
|
|
+
|
|
+ local->prebuf = *buf;
|
|
+ if (shard_modify_size_and_block_count(&local->prebuf, xdata)) {
|
|
+ local->op_ret = -1;
|
|
+ local->op_errno = EINVAL;
|
|
+ goto unwind;
|
|
+ }
|
|
+
|
|
+ if (shard_inode_ctx_get_all(inode, this, &ctx))
|
|
+ mask = SHARD_ALL_MASK;
|
|
+
|
|
+ ret = shard_inode_ctx_set(inode, this, &local->prebuf, 0,
|
|
+ (mask | SHARD_MASK_REFRESH_RESET));
|
|
+ if (ret) {
|
|
+ gf_msg(this->name, GF_LOG_ERROR, SHARD_MSG_INODE_CTX_SET_FAILED, 0,
|
|
+ "Failed to set inode"
|
|
+ " write params into inode ctx for %s",
|
|
+ uuid_utoa(buf->ia_gfid));
|
|
+ local->op_ret = -1;
|
|
+ local->op_errno = ENOMEM;
|
|
+ goto unwind;
|
|
+ }
|
|
+
|
|
+unwind:
|
|
+ local->handler(frame, this);
|
|
+ return 0;
|
|
+}
|
|
+
|
|
+int shard_lookup_base_file(call_frame_t *frame, xlator_t *this, loc_t *loc,
|
|
+ shard_post_fop_handler_t handler) {
|
|
+ int ret = -1;
|
|
+ shard_local_t *local = NULL;
|
|
+ dict_t *xattr_req = NULL;
|
|
+ gf_boolean_t need_refresh = _gf_false;
|
|
+
|
|
+ local = frame->local;
|
|
+ local->handler = handler;
|
|
+
|
|
+ ret = shard_inode_ctx_fill_iatt_from_cache(loc->inode, this, &local->prebuf,
|
|
+ &need_refresh);
|
|
+ /* By this time, inode ctx should have been created either in create,
|
|
+ * mknod, readdirp or lookup. If not it is a bug!
|
|
+ */
|
|
+ if ((ret == 0) && (need_refresh == _gf_false)) {
|
|
+ gf_msg_debug(this->name, 0, "Skipping lookup on base file: %s"
|
|
+ "Serving prebuf off the inode ctx cache",
|
|
+ uuid_utoa(loc->gfid));
|
|
+ goto out;
|
|
+ }
|
|
+
|
|
+ xattr_req = dict_new();
|
|
+ if (!xattr_req) {
|
|
+ local->op_ret = -1;
|
|
+ local->op_errno = ENOMEM;
|
|
+ goto out;
|
|
+ }
|
|
+
|
|
+ SHARD_MD_READ_FOP_INIT_REQ_DICT(this, xattr_req, loc->gfid, local, out);
|
|
+
|
|
+ STACK_WIND(frame, shard_lookup_base_file_cbk, FIRST_CHILD(this),
|
|
+ FIRST_CHILD(this)->fops->lookup, loc, xattr_req);
|
|
+
|
|
+ dict_unref(xattr_req);
|
|
+ return 0;
|
|
|
|
- /* To-Do: Fix refcount increment per call to
|
|
- * shard_link_internal_dir_inode().
|
|
- */
|
|
- linked_inode = shard_link_internal_dir_inode(local, inode, buf, type);
|
|
- shard_inode_ctx_mark_dir_refreshed(linked_inode, this);
|
|
out:
|
|
- shard_common_resolve_shards(frame, this, local->post_res_handler);
|
|
- return 0;
|
|
+ if (xattr_req)
|
|
+ dict_unref(xattr_req);
|
|
+ handler(frame, this);
|
|
+ return 0;
|
|
}
|
|
|
|
-int
|
|
-shard_refresh_internal_dir(call_frame_t *frame, xlator_t *this,
|
|
- shard_internal_dir_type_t type)
|
|
-{
|
|
- loc_t loc = {
|
|
- 0,
|
|
- };
|
|
- inode_t *inode = NULL;
|
|
- shard_priv_t *priv = NULL;
|
|
- shard_local_t *local = NULL;
|
|
- uuid_t gfid = {
|
|
- 0,
|
|
- };
|
|
+int shard_post_fstat_handler(call_frame_t *frame, xlator_t *this) {
|
|
+ shard_local_t *local = NULL;
|
|
|
|
- local = frame->local;
|
|
- priv = this->private;
|
|
-
|
|
- switch (type) {
|
|
- case SHARD_INTERNAL_DIR_DOT_SHARD:
|
|
- gf_uuid_copy(gfid, priv->dot_shard_gfid);
|
|
- break;
|
|
- case SHARD_INTERNAL_DIR_DOT_SHARD_REMOVE_ME:
|
|
- gf_uuid_copy(gfid, priv->dot_shard_rm_gfid);
|
|
- break;
|
|
- default:
|
|
- break;
|
|
- }
|
|
+ local = frame->local;
|
|
|
|
- inode = inode_find(this->itable, gfid);
|
|
+ if (local->op_ret >= 0)
|
|
+ shard_inode_ctx_set(local->fd->inode, this, &local->prebuf, 0,
|
|
+ SHARD_LOOKUP_MASK);
|
|
|
|
- if (!shard_inode_ctx_needs_lookup(inode, this)) {
|
|
- local->op_ret = 0;
|
|
- goto out;
|
|
- }
|
|
+ SHARD_STACK_UNWIND(fstat, frame, local->op_ret, local->op_errno,
|
|
+ &local->prebuf, local->xattr_rsp);
|
|
+ return 0;
|
|
+}
|
|
|
|
- /* Plain assignment because the ref is already taken above through
|
|
- * call to inode_find()
|
|
- */
|
|
- loc.inode = inode;
|
|
- gf_uuid_copy(loc.gfid, gfid);
|
|
+int shard_post_stat_handler(call_frame_t *frame, xlator_t *this) {
|
|
+ shard_local_t *local = NULL;
|
|
|
|
- STACK_WIND_COOKIE(frame, shard_refresh_internal_dir_cbk, (void *)(long)type,
|
|
- FIRST_CHILD(this), FIRST_CHILD(this)->fops->lookup, &loc,
|
|
- NULL);
|
|
- loc_wipe(&loc);
|
|
+ local = frame->local;
|
|
|
|
- return 0;
|
|
+ if (local->op_ret >= 0)
|
|
+ shard_inode_ctx_set(local->loc.inode, this, &local->prebuf, 0,
|
|
+ SHARD_LOOKUP_MASK);
|
|
|
|
-out:
|
|
- shard_common_resolve_shards(frame, this, local->post_res_handler);
|
|
- return 0;
|
|
+ SHARD_STACK_UNWIND(stat, frame, local->op_ret, local->op_errno,
|
|
+ &local->prebuf, local->xattr_rsp);
|
|
+ return 0;
|
|
}
|
|
|
|
-int
|
|
-shard_lookup_internal_dir_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
|
|
- int32_t op_ret, int32_t op_errno, inode_t *inode,
|
|
- struct iatt *buf, dict_t *xdata,
|
|
- struct iatt *postparent)
|
|
-{
|
|
- inode_t *link_inode = NULL;
|
|
- shard_local_t *local = NULL;
|
|
- shard_internal_dir_type_t type = (shard_internal_dir_type_t)cookie;
|
|
+int shard_common_stat_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
|
|
+ int32_t op_ret, int32_t op_errno, struct iatt *buf,
|
|
+ dict_t *xdata) {
|
|
+ inode_t *inode = NULL;
|
|
+ shard_local_t *local = NULL;
|
|
|
|
- local = frame->local;
|
|
+ local = frame->local;
|
|
|
|
- if (op_ret) {
|
|
- local->op_ret = op_ret;
|
|
- local->op_errno = op_errno;
|
|
- goto unwind;
|
|
- }
|
|
+ if (op_ret < 0) {
|
|
+ gf_msg(this->name, GF_LOG_ERROR, op_errno, SHARD_MSG_STAT_FAILED,
|
|
+ "stat failed: %s", local->fd ? uuid_utoa(local->fd->inode->gfid)
|
|
+ : uuid_utoa((local->loc.inode)->gfid));
|
|
+ local->op_ret = op_ret;
|
|
+ local->op_errno = op_errno;
|
|
+ goto unwind;
|
|
+ }
|
|
|
|
- if (!IA_ISDIR(buf->ia_type)) {
|
|
- gf_msg(this->name, GF_LOG_CRITICAL, 0, SHARD_MSG_DOT_SHARD_NODIR,
|
|
- "%s already exists and "
|
|
- "is not a directory. Please remove it from all bricks "
|
|
- "and try again",
|
|
- shard_internal_dir_string(type));
|
|
- local->op_ret = -1;
|
|
- local->op_errno = EIO;
|
|
- goto unwind;
|
|
- }
|
|
+ local->prebuf = *buf;
|
|
+ if (shard_modify_size_and_block_count(&local->prebuf, xdata)) {
|
|
+ local->op_ret = -1;
|
|
+ local->op_errno = EINVAL;
|
|
+ goto unwind;
|
|
+ }
|
|
+ local->xattr_rsp = dict_ref(xdata);
|
|
|
|
- link_inode = shard_link_internal_dir_inode(local, inode, buf, type);
|
|
- if (link_inode != inode) {
|
|
- shard_refresh_internal_dir(frame, this, type);
|
|
- } else {
|
|
- shard_inode_ctx_mark_dir_refreshed(link_inode, this);
|
|
- shard_common_resolve_shards(frame, this, local->post_res_handler);
|
|
- }
|
|
- return 0;
|
|
+ if (local->loc.inode)
|
|
+ inode = local->loc.inode;
|
|
+ else
|
|
+ inode = local->fd->inode;
|
|
+
|
|
+ shard_inode_ctx_invalidate(inode, this, &local->prebuf);
|
|
|
|
unwind:
|
|
- local->post_res_handler(frame, this);
|
|
- return 0;
|
|
+ local->handler(frame, this);
|
|
+ return 0;
|
|
}
|
|
|
|
-int
|
|
-shard_lookup_internal_dir(call_frame_t *frame, xlator_t *this,
|
|
- shard_post_resolve_fop_handler_t post_res_handler,
|
|
- shard_internal_dir_type_t type)
|
|
-{
|
|
- int ret = -1;
|
|
- dict_t *xattr_req = NULL;
|
|
- shard_priv_t *priv = NULL;
|
|
- shard_local_t *local = NULL;
|
|
- uuid_t *gfid = NULL;
|
|
- loc_t *loc = NULL;
|
|
- gf_boolean_t free_gfid = _gf_true;
|
|
-
|
|
- local = frame->local;
|
|
- priv = this->private;
|
|
- local->post_res_handler = post_res_handler;
|
|
-
|
|
- gfid = GF_MALLOC(sizeof(uuid_t), gf_common_mt_uuid_t);
|
|
- if (!gfid)
|
|
- goto err;
|
|
-
|
|
- xattr_req = dict_new();
|
|
- if (!xattr_req) {
|
|
- local->op_ret = -1;
|
|
- local->op_errno = ENOMEM;
|
|
- goto err;
|
|
- }
|
|
-
|
|
- switch (type) {
|
|
- case SHARD_INTERNAL_DIR_DOT_SHARD:
|
|
- gf_uuid_copy(*gfid, priv->dot_shard_gfid);
|
|
- loc = &local->dot_shard_loc;
|
|
- break;
|
|
- case SHARD_INTERNAL_DIR_DOT_SHARD_REMOVE_ME:
|
|
- gf_uuid_copy(*gfid, priv->dot_shard_rm_gfid);
|
|
- loc = &local->dot_shard_rm_loc;
|
|
- break;
|
|
- default:
|
|
- bzero(*gfid, sizeof(uuid_t));
|
|
- break;
|
|
- }
|
|
+int shard_stat(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata) {
|
|
+ int ret = -1;
|
|
+ uint64_t block_size = 0;
|
|
+ shard_local_t *local = NULL;
|
|
|
|
- ret = dict_set_gfuuid(xattr_req, "gfid-req", *gfid, false);
|
|
- if (ret) {
|
|
- gf_msg(this->name, GF_LOG_ERROR, 0, SHARD_MSG_DICT_OP_FAILED,
|
|
- "Failed to set gfid of %s into dict",
|
|
- shard_internal_dir_string(type));
|
|
- local->op_ret = -1;
|
|
- local->op_errno = ENOMEM;
|
|
- goto err;
|
|
- } else {
|
|
- free_gfid = _gf_false;
|
|
- }
|
|
+ if ((IA_ISDIR(loc->inode->ia_type)) || (IA_ISLNK(loc->inode->ia_type))) {
|
|
+ STACK_WIND(frame, default_stat_cbk, FIRST_CHILD(this),
|
|
+ FIRST_CHILD(this)->fops->stat, loc, xdata);
|
|
+ return 0;
|
|
+ }
|
|
|
|
- STACK_WIND_COOKIE(frame, shard_lookup_internal_dir_cbk, (void *)(long)type,
|
|
- FIRST_CHILD(this), FIRST_CHILD(this)->fops->lookup, loc,
|
|
- xattr_req);
|
|
+ ret = shard_inode_ctx_get_block_size(loc->inode, this, &block_size);
|
|
+ if (ret) {
|
|
+ gf_msg(this->name, GF_LOG_ERROR, 0, SHARD_MSG_INODE_CTX_GET_FAILED,
|
|
+ "Failed to get block "
|
|
+ "size from inode ctx of %s",
|
|
+ uuid_utoa(loc->inode->gfid));
|
|
+ goto err;
|
|
+ }
|
|
|
|
- dict_unref(xattr_req);
|
|
+ if (!block_size || frame->root->pid == GF_CLIENT_PID_GSYNCD) {
|
|
+ STACK_WIND(frame, default_stat_cbk, FIRST_CHILD(this),
|
|
+ FIRST_CHILD(this)->fops->stat, loc, xdata);
|
|
return 0;
|
|
+ }
|
|
+
|
|
+ local = mem_get0(this->local_pool);
|
|
+ if (!local)
|
|
+ goto err;
|
|
|
|
+ frame->local = local;
|
|
+
|
|
+ local->handler = shard_post_stat_handler;
|
|
+ loc_copy(&local->loc, loc);
|
|
+ local->xattr_req = (xdata) ? dict_ref(xdata) : dict_new();
|
|
+ if (!local->xattr_req)
|
|
+ goto err;
|
|
+
|
|
+ SHARD_MD_READ_FOP_INIT_REQ_DICT(this, local->xattr_req, local->loc.gfid,
|
|
+ local, err);
|
|
+
|
|
+ STACK_WIND(frame, shard_common_stat_cbk, FIRST_CHILD(this),
|
|
+ FIRST_CHILD(this)->fops->stat, loc, local->xattr_req);
|
|
+ return 0;
|
|
err:
|
|
- if (xattr_req)
|
|
- dict_unref(xattr_req);
|
|
- if (free_gfid)
|
|
- GF_FREE(gfid);
|
|
- post_res_handler(frame, this);
|
|
- return 0;
|
|
+ shard_common_failure_unwind(GF_FOP_STAT, frame, -1, ENOMEM);
|
|
+ return 0;
|
|
}
|
|
|
|
-static void
|
|
-shard_inode_ctx_update(inode_t *inode, xlator_t *this, dict_t *xdata,
|
|
- struct iatt *buf)
|
|
-{
|
|
- int ret = 0;
|
|
- uint64_t size = 0;
|
|
- void *bsize = NULL;
|
|
-
|
|
- if (shard_inode_ctx_get_block_size(inode, this, &size)) {
|
|
- /* Fresh lookup */
|
|
- ret = dict_get_ptr(xdata, GF_XATTR_SHARD_BLOCK_SIZE, &bsize);
|
|
- if (!ret)
|
|
- size = ntoh64(*((uint64_t *)bsize));
|
|
- /* If the file is sharded, set its block size, otherwise just
|
|
- * set 0.
|
|
- */
|
|
+int shard_fstat(call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata) {
|
|
+ int ret = -1;
|
|
+ uint64_t block_size = 0;
|
|
+ shard_local_t *local = NULL;
|
|
|
|
- shard_inode_ctx_set(inode, this, buf, size, SHARD_MASK_BLOCK_SIZE);
|
|
- }
|
|
- /* If the file is sharded, also set the remaining attributes,
|
|
- * except for ia_size and ia_blocks.
|
|
- */
|
|
- if (size) {
|
|
- shard_inode_ctx_set(inode, this, buf, 0, SHARD_LOOKUP_MASK);
|
|
- (void)shard_inode_ctx_invalidate(inode, this, buf);
|
|
- }
|
|
-}
|
|
+ if ((IA_ISDIR(fd->inode->ia_type)) || (IA_ISLNK(fd->inode->ia_type))) {
|
|
+ STACK_WIND(frame, default_fstat_cbk, FIRST_CHILD(this),
|
|
+ FIRST_CHILD(this)->fops->fstat, fd, xdata);
|
|
+ return 0;
|
|
+ }
|
|
|
|
-int
|
|
-shard_delete_shards(void *opaque);
|
|
+ ret = shard_inode_ctx_get_block_size(fd->inode, this, &block_size);
|
|
+ if (ret) {
|
|
+ gf_msg(this->name, GF_LOG_ERROR, 0, SHARD_MSG_INODE_CTX_GET_FAILED,
|
|
+ "Failed to get block "
|
|
+ "size from inode ctx of %s",
|
|
+ uuid_utoa(fd->inode->gfid));
|
|
+ goto err;
|
|
+ }
|
|
|
|
-int
|
|
-shard_delete_shards_cbk(int ret, call_frame_t *frame, void *data);
|
|
+ if (!block_size || frame->root->pid == GF_CLIENT_PID_GSYNCD) {
|
|
+ STACK_WIND(frame, default_fstat_cbk, FIRST_CHILD(this),
|
|
+ FIRST_CHILD(this)->fops->fstat, fd, xdata);
|
|
+ return 0;
|
|
+ }
|
|
|
|
-int
|
|
-shard_start_background_deletion(xlator_t *this)
|
|
-{
|
|
- int ret = 0;
|
|
- gf_boolean_t i_cleanup = _gf_true;
|
|
- shard_priv_t *priv = NULL;
|
|
- call_frame_t *cleanup_frame = NULL;
|
|
+ if (!this->itable)
|
|
+ this->itable = fd->inode->table;
|
|
|
|
- priv = this->private;
|
|
+ local = mem_get0(this->local_pool);
|
|
+ if (!local)
|
|
+ goto err;
|
|
|
|
- LOCK(&priv->lock);
|
|
- {
|
|
- switch (priv->bg_del_state) {
|
|
- case SHARD_BG_DELETION_NONE:
|
|
- i_cleanup = _gf_true;
|
|
- priv->bg_del_state = SHARD_BG_DELETION_LAUNCHING;
|
|
- break;
|
|
- case SHARD_BG_DELETION_LAUNCHING:
|
|
- i_cleanup = _gf_false;
|
|
- break;
|
|
- case SHARD_BG_DELETION_IN_PROGRESS:
|
|
- priv->bg_del_state = SHARD_BG_DELETION_LAUNCHING;
|
|
- i_cleanup = _gf_false;
|
|
- break;
|
|
- default:
|
|
- break;
|
|
- }
|
|
- }
|
|
- UNLOCK(&priv->lock);
|
|
- if (!i_cleanup)
|
|
- return 0;
|
|
-
|
|
- cleanup_frame = create_frame(this, this->ctx->pool);
|
|
- if (!cleanup_frame) {
|
|
- gf_msg(this->name, GF_LOG_WARNING, ENOMEM, SHARD_MSG_MEMALLOC_FAILED,
|
|
- "Failed to create "
|
|
- "new frame to delete shards");
|
|
- ret = -ENOMEM;
|
|
- goto err;
|
|
- }
|
|
+ frame->local = local;
|
|
|
|
- set_lk_owner_from_ptr(&cleanup_frame->root->lk_owner, cleanup_frame->root);
|
|
+ local->handler = shard_post_fstat_handler;
|
|
+ local->fd = fd_ref(fd);
|
|
+ local->xattr_req = (xdata) ? dict_ref(xdata) : dict_new();
|
|
+ if (!local->xattr_req)
|
|
+ goto err;
|
|
|
|
- ret = synctask_new(this->ctx->env, shard_delete_shards,
|
|
- shard_delete_shards_cbk, cleanup_frame, cleanup_frame);
|
|
- if (ret < 0) {
|
|
- gf_msg(this->name, GF_LOG_WARNING, errno,
|
|
- SHARD_MSG_SHARDS_DELETION_FAILED,
|
|
- "failed to create task to do background "
|
|
- "cleanup of shards");
|
|
- STACK_DESTROY(cleanup_frame->root);
|
|
- goto err;
|
|
- }
|
|
- return 0;
|
|
+ SHARD_MD_READ_FOP_INIT_REQ_DICT(this, local->xattr_req, fd->inode->gfid,
|
|
+ local, err);
|
|
|
|
+ STACK_WIND(frame, shard_common_stat_cbk, FIRST_CHILD(this),
|
|
+ FIRST_CHILD(this)->fops->fstat, fd, local->xattr_req);
|
|
+ return 0;
|
|
err:
|
|
- LOCK(&priv->lock);
|
|
- {
|
|
- priv->bg_del_state = SHARD_BG_DELETION_NONE;
|
|
- }
|
|
- UNLOCK(&priv->lock);
|
|
- return ret;
|
|
+ shard_common_failure_unwind(GF_FOP_FSTAT, frame, -1, ENOMEM);
|
|
+ return 0;
|
|
}
|
|
|
|
-int
|
|
-shard_lookup_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
|
|
- int32_t op_ret, int32_t op_errno, inode_t *inode,
|
|
- struct iatt *buf, dict_t *xdata, struct iatt *postparent)
|
|
-{
|
|
- int ret = -1;
|
|
- shard_priv_t *priv = NULL;
|
|
- gf_boolean_t i_start_cleanup = _gf_false;
|
|
+int shard_post_update_size_truncate_handler(call_frame_t *frame,
|
|
+ xlator_t *this) {
|
|
+ shard_local_t *local = NULL;
|
|
|
|
- priv = this->private;
|
|
+ local = frame->local;
|
|
|
|
- if (op_ret < 0)
|
|
- goto unwind;
|
|
+ if (local->fop == GF_FOP_TRUNCATE)
|
|
+ SHARD_STACK_UNWIND(truncate, frame, local->op_ret, local->op_errno,
|
|
+ &local->prebuf, &local->postbuf, NULL);
|
|
+ else
|
|
+ SHARD_STACK_UNWIND(ftruncate, frame, local->op_ret, local->op_errno,
|
|
+ &local->prebuf, &local->postbuf, NULL);
|
|
+ return 0;
|
|
+}
|
|
|
|
- if (IA_ISDIR(buf->ia_type))
|
|
- goto unwind;
|
|
+int shard_truncate_last_shard_cbk(call_frame_t *frame, void *cookie,
|
|
+ xlator_t *this, int32_t op_ret,
|
|
+ int32_t op_errno, struct iatt *prebuf,
|
|
+ struct iatt *postbuf, dict_t *xdata) {
|
|
+ inode_t *inode = NULL;
|
|
+ int64_t delta_blocks = 0;
|
|
+ shard_local_t *local = NULL;
|
|
|
|
- /* Also, if the file is sharded, get the file size and block cnt xattr,
|
|
- * and store them in the stbuf appropriately.
|
|
- */
|
|
+ local = frame->local;
|
|
|
|
- if (dict_get(xdata, GF_XATTR_SHARD_FILE_SIZE) &&
|
|
- frame->root->pid != GF_CLIENT_PID_GSYNCD)
|
|
- shard_modify_size_and_block_count(buf, xdata);
|
|
-
|
|
- /* If this was a fresh lookup, there are two possibilities:
|
|
- * 1) If the file is sharded (indicated by the presence of block size
|
|
- * xattr), store this block size, along with rdev and mode in its
|
|
- * inode ctx.
|
|
- * 2) If the file is not sharded, store size along with rdev and mode
|
|
- * (which are anyway don't cares) in inode ctx. Since @ctx_tmp is
|
|
- * already initialised to all zeroes, nothing more needs to be done.
|
|
- */
|
|
+ SHARD_UNSET_ROOT_FS_ID(frame, local);
|
|
|
|
- (void)shard_inode_ctx_update(inode, this, xdata, buf);
|
|
+ inode = (local->fop == GF_FOP_TRUNCATE) ? local->loc.inode : local->fd->inode;
|
|
+ if (op_ret < 0) {
|
|
+ gf_msg(this->name, GF_LOG_ERROR, op_errno,
|
|
+ SHARD_MSG_TRUNCATE_LAST_SHARD_FAILED, "truncate on last"
|
|
+ " shard failed : %s",
|
|
+ uuid_utoa(inode->gfid));
|
|
+ local->op_ret = op_ret;
|
|
+ local->op_errno = op_errno;
|
|
+ goto err;
|
|
+ }
|
|
+
|
|
+ local->postbuf.ia_size = local->offset;
|
|
+ /* Let the delta be negative. We want xattrop to do subtraction */
|
|
+ local->delta_size = local->postbuf.ia_size - local->prebuf.ia_size;
|
|
+ delta_blocks = GF_ATOMIC_ADD(local->delta_blocks,
|
|
+ postbuf->ia_blocks - prebuf->ia_blocks);
|
|
+ GF_ASSERT(delta_blocks <= 0);
|
|
+ local->postbuf.ia_blocks += delta_blocks;
|
|
+ local->hole_size = 0;
|
|
+
|
|
+ shard_inode_ctx_set(inode, this, &local->postbuf, 0, SHARD_MASK_TIMES);
|
|
+ shard_update_file_size(frame, this, NULL, &local->loc,
|
|
+ shard_post_update_size_truncate_handler);
|
|
+ return 0;
|
|
+err:
|
|
+ shard_common_failure_unwind(local->fop, frame, local->op_ret,
|
|
+ local->op_errno);
|
|
+ return 0;
|
|
+}
|
|
+
|
|
+int shard_truncate_last_shard(call_frame_t *frame, xlator_t *this,
|
|
+ inode_t *inode) {
|
|
+ size_t last_shard_size_after = 0;
|
|
+ loc_t loc = {
|
|
+ 0,
|
|
+ };
|
|
+ shard_local_t *local = NULL;
|
|
+
|
|
+ local = frame->local;
|
|
+
|
|
+ /* A NULL inode could be due to the fact that the last shard which
|
|
+ * needs to be truncated does not exist due to it lying in a hole
|
|
+ * region. So the only thing left to do in that case would be an
|
|
+ * update to file size xattr.
|
|
+ */
|
|
+ if (!inode) {
|
|
+ gf_msg_debug(this->name, 0,
|
|
+ "Last shard to be truncated absent"
|
|
+ " in backend: %s. Directly proceeding to update "
|
|
+ "file size",
|
|
+ uuid_utoa(inode->gfid));
|
|
+ shard_update_file_size(frame, this, NULL, &local->loc,
|
|
+ shard_post_update_size_truncate_handler);
|
|
+ return 0;
|
|
+ }
|
|
|
|
- LOCK(&priv->lock);
|
|
- {
|
|
- if (priv->first_lookup_done == _gf_false) {
|
|
- priv->first_lookup_done = _gf_true;
|
|
- i_start_cleanup = _gf_true;
|
|
- }
|
|
- }
|
|
- UNLOCK(&priv->lock);
|
|
+ SHARD_SET_ROOT_FS_ID(frame, local);
|
|
|
|
- if (!i_start_cleanup)
|
|
- goto unwind;
|
|
+ loc.inode = inode_ref(inode);
|
|
+ gf_uuid_copy(loc.gfid, inode->gfid);
|
|
|
|
- ret = shard_start_background_deletion(this);
|
|
- if (ret < 0) {
|
|
- LOCK(&priv->lock);
|
|
- {
|
|
- priv->first_lookup_done = _gf_false;
|
|
- }
|
|
- UNLOCK(&priv->lock);
|
|
- }
|
|
+ last_shard_size_after = (local->offset % local->block_size);
|
|
|
|
-unwind:
|
|
- SHARD_STACK_UNWIND(lookup, frame, op_ret, op_errno, inode, buf, xdata,
|
|
- postparent);
|
|
- return 0;
|
|
+ STACK_WIND(frame, shard_truncate_last_shard_cbk, FIRST_CHILD(this),
|
|
+ FIRST_CHILD(this)->fops->truncate, &loc, last_shard_size_after,
|
|
+ NULL);
|
|
+ loc_wipe(&loc);
|
|
+ return 0;
|
|
}
|
|
|
|
-int
|
|
-shard_lookup(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xattr_req)
|
|
-{
|
|
- int ret = -1;
|
|
- int32_t op_errno = ENOMEM;
|
|
- uint64_t block_size = 0;
|
|
- shard_local_t *local = NULL;
|
|
-
|
|
- this->itable = loc->inode->table;
|
|
- if (frame->root->pid != GF_CLIENT_PID_GSYNCD) {
|
|
- SHARD_ENTRY_FOP_CHECK(loc, op_errno, err);
|
|
- }
|
|
+void shard_unlink_block_inode(shard_local_t *local, int shard_block_num);
|
|
|
|
- local = mem_get0(this->local_pool);
|
|
- if (!local)
|
|
- goto err;
|
|
+int shard_truncate_htol_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
|
|
+ int32_t op_ret, int32_t op_errno,
|
|
+ struct iatt *preparent, struct iatt *postparent,
|
|
+ dict_t *xdata) {
|
|
+ int ret = 0;
|
|
+ int call_count = 0;
|
|
+ int shard_block_num = (long)cookie;
|
|
+ uint64_t block_count = 0;
|
|
+ shard_local_t *local = NULL;
|
|
|
|
- frame->local = local;
|
|
+ local = frame->local;
|
|
|
|
- loc_copy(&local->loc, loc);
|
|
+ if (op_ret < 0) {
|
|
+ local->op_ret = op_ret;
|
|
+ local->op_errno = op_errno;
|
|
+ goto done;
|
|
+ }
|
|
+ ret = dict_get_uint64(xdata, GF_GET_FILE_BLOCK_COUNT, &block_count);
|
|
+ if (!ret) {
|
|
+ GF_ATOMIC_SUB(local->delta_blocks, block_count);
|
|
+ } else {
|
|
+ /* dict_get failed possibly due to a heterogeneous cluster? */
|
|
+ gf_msg(this->name, GF_LOG_WARNING, 0, SHARD_MSG_DICT_OP_FAILED,
|
|
+ "Failed to get key %s from dict during truncate of gfid %s",
|
|
+ GF_GET_FILE_BLOCK_COUNT,
|
|
+ uuid_utoa(local->resolver_base_inode->gfid));
|
|
+ }
|
|
+
|
|
+ shard_unlink_block_inode(local, shard_block_num);
|
|
+done:
|
|
+ call_count = shard_call_count_return(frame);
|
|
+ if (call_count == 0) {
|
|
+ SHARD_UNSET_ROOT_FS_ID(frame, local);
|
|
+ shard_truncate_last_shard(frame, this, local->inode_list[0]);
|
|
+ }
|
|
+ return 0;
|
|
+}
|
|
+
|
|
+int shard_truncate_htol(call_frame_t *frame, xlator_t *this, inode_t *inode) {
|
|
+ int i = 1;
|
|
+ int ret = -1;
|
|
+ int call_count = 0;
|
|
+ uint32_t cur_block = 0;
|
|
+ uint32_t last_block = 0;
|
|
+ char path[PATH_MAX] = {
|
|
+ 0,
|
|
+ };
|
|
+ char *bname = NULL;
|
|
+ loc_t loc = {
|
|
+ 0,
|
|
+ };
|
|
+ gf_boolean_t wind_failed = _gf_false;
|
|
+ shard_local_t *local = NULL;
|
|
+ shard_priv_t *priv = NULL;
|
|
+ dict_t *xdata_req = NULL;
|
|
+
|
|
+ local = frame->local;
|
|
+ priv = this->private;
|
|
+
|
|
+ cur_block = local->first_block + 1;
|
|
+ last_block = local->last_block;
|
|
+
|
|
+ /* Determine call count */
|
|
+ for (i = 1; i < local->num_blocks; i++) {
|
|
+ if (!local->inode_list[i])
|
|
+ continue;
|
|
+ call_count++;
|
|
+ }
|
|
+
|
|
+ if (!call_count) {
|
|
+ /* Call count = 0 implies that all of the shards that need to be
|
|
+ * unlinked do not exist. So shard xlator would now proceed to
|
|
+ * do the final truncate + size updates.
|
|
+ */
|
|
+ gf_msg_debug(this->name, 0, "Shards to be unlinked as part of "
|
|
+ "truncate absent in backend: %s. Directly "
|
|
+ "proceeding to update file size",
|
|
+ uuid_utoa(inode->gfid));
|
|
+ local->postbuf.ia_size = local->offset;
|
|
+ local->postbuf.ia_blocks = local->prebuf.ia_blocks;
|
|
+ local->delta_size = local->postbuf.ia_size - local->prebuf.ia_size;
|
|
+ GF_ATOMIC_INIT(local->delta_blocks, 0);
|
|
+ local->hole_size = 0;
|
|
+ shard_update_file_size(frame, this, local->fd, &local->loc,
|
|
+ shard_post_update_size_truncate_handler);
|
|
+ return 0;
|
|
+ }
|
|
|
|
- local->xattr_req = xattr_req ? dict_ref(xattr_req) : dict_new();
|
|
- if (!local->xattr_req)
|
|
- goto err;
|
|
+ local->call_count = call_count;
|
|
+ i = 1;
|
|
+ xdata_req = dict_new();
|
|
+ if (!xdata_req) {
|
|
+ shard_common_failure_unwind(local->fop, frame, -1, ENOMEM);
|
|
+ return 0;
|
|
+ }
|
|
+ ret = dict_set_uint64(xdata_req, GF_GET_FILE_BLOCK_COUNT, 8 * 8);
|
|
+ if (ret) {
|
|
+ gf_msg(this->name, GF_LOG_WARNING, 0, SHARD_MSG_DICT_OP_FAILED,
|
|
+ "Failed to set key %s into dict during truncate of %s",
|
|
+ GF_GET_FILE_BLOCK_COUNT,
|
|
+ uuid_utoa(local->resolver_base_inode->gfid));
|
|
+ dict_unref(xdata_req);
|
|
+ shard_common_failure_unwind(local->fop, frame, -1, ENOMEM);
|
|
+ return 0;
|
|
+ }
|
|
|
|
- if (shard_inode_ctx_get_block_size(loc->inode, this, &block_size)) {
|
|
- ret = dict_set_uint64(local->xattr_req, GF_XATTR_SHARD_BLOCK_SIZE, 0);
|
|
- if (ret) {
|
|
- gf_msg(this->name, GF_LOG_WARNING, 0, SHARD_MSG_DICT_OP_FAILED,
|
|
- "Failed to set dict"
|
|
- " value: key:%s for path %s",
|
|
- GF_XATTR_SHARD_BLOCK_SIZE, loc->path);
|
|
- goto err;
|
|
- }
|
|
+ SHARD_SET_ROOT_FS_ID(frame, local);
|
|
+ while (cur_block <= last_block) {
|
|
+ if (!local->inode_list[i]) {
|
|
+ cur_block++;
|
|
+ i++;
|
|
+ continue;
|
|
+ }
|
|
+ if (wind_failed) {
|
|
+ shard_truncate_htol_cbk(frame, (void *)(long)cur_block, this, -1, ENOMEM,
|
|
+ NULL, NULL, NULL);
|
|
+ goto next;
|
|
}
|
|
|
|
- if (frame->root->pid != GF_CLIENT_PID_GSYNCD) {
|
|
- ret = dict_set_uint64(local->xattr_req, GF_XATTR_SHARD_FILE_SIZE,
|
|
- 8 * 4);
|
|
- if (ret) {
|
|
- gf_msg(this->name, GF_LOG_WARNING, 0, SHARD_MSG_DICT_OP_FAILED,
|
|
- "Failed to set dict value: key:%s for path %s.",
|
|
- GF_XATTR_SHARD_FILE_SIZE, loc->path);
|
|
- goto err;
|
|
- }
|
|
+ shard_make_block_abspath(cur_block, inode->gfid, path, sizeof(path));
|
|
+ bname = strrchr(path, '/') + 1;
|
|
+ loc.parent = inode_ref(priv->dot_shard_inode);
|
|
+ ret = inode_path(loc.parent, bname, (char **)&(loc.path));
|
|
+ if (ret < 0) {
|
|
+ gf_msg(this->name, GF_LOG_ERROR, 0, SHARD_MSG_INODE_PATH_FAILED,
|
|
+ "Inode path failed"
|
|
+ " on %s. Base file gfid = %s",
|
|
+ bname, uuid_utoa(inode->gfid));
|
|
+ local->op_ret = -1;
|
|
+ local->op_errno = ENOMEM;
|
|
+ loc_wipe(&loc);
|
|
+ wind_failed = _gf_true;
|
|
+ shard_truncate_htol_cbk(frame, (void *)(long)cur_block, this, -1, ENOMEM,
|
|
+ NULL, NULL, NULL);
|
|
+ goto next;
|
|
}
|
|
+ loc.name = strrchr(loc.path, '/');
|
|
+ if (loc.name)
|
|
+ loc.name++;
|
|
+ loc.inode = inode_ref(local->inode_list[i]);
|
|
|
|
- if ((xattr_req) && (dict_get(xattr_req, GF_CONTENT_KEY)))
|
|
- dict_del(xattr_req, GF_CONTENT_KEY);
|
|
+ STACK_WIND_COOKIE(frame, shard_truncate_htol_cbk, (void *)(long)cur_block,
|
|
+ FIRST_CHILD(this), FIRST_CHILD(this)->fops->unlink, &loc,
|
|
+ 0, xdata_req);
|
|
+ loc_wipe(&loc);
|
|
+ next:
|
|
+ i++;
|
|
+ cur_block++;
|
|
+ if (!--call_count)
|
|
+ break;
|
|
+ }
|
|
+ dict_unref(xdata_req);
|
|
+ return 0;
|
|
+}
|
|
|
|
- STACK_WIND(frame, shard_lookup_cbk, FIRST_CHILD(this),
|
|
- FIRST_CHILD(this)->fops->lookup, loc, local->xattr_req);
|
|
- return 0;
|
|
-err:
|
|
- shard_common_failure_unwind(GF_FOP_LOOKUP, frame, -1, op_errno);
|
|
+int shard_truncate_do(call_frame_t *frame, xlator_t *this) {
|
|
+ shard_local_t *local = NULL;
|
|
+
|
|
+ local = frame->local;
|
|
+
|
|
+ if (local->num_blocks == 1) {
|
|
+ /* This means that there are no shards to be unlinked.
|
|
+ * The fop boils down to truncating the last shard, updating
|
|
+ * the size and unwinding.
|
|
+ */
|
|
+ shard_truncate_last_shard(frame, this, local->inode_list[0]);
|
|
return 0;
|
|
+ } else {
|
|
+ shard_truncate_htol(frame, this, local->loc.inode);
|
|
+ }
|
|
+ return 0;
|
|
}
|
|
|
|
-int
|
|
-shard_lookup_base_file_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
|
|
- int32_t op_ret, int32_t op_errno, inode_t *inode,
|
|
- struct iatt *buf, dict_t *xdata,
|
|
- struct iatt *postparent)
|
|
-{
|
|
- int ret = -1;
|
|
- int32_t mask = SHARD_INODE_WRITE_MASK;
|
|
- shard_local_t *local = NULL;
|
|
- shard_inode_ctx_t ctx = {
|
|
- 0,
|
|
- };
|
|
-
|
|
- local = frame->local;
|
|
+int shard_post_lookup_shards_truncate_handler(call_frame_t *frame,
|
|
+ xlator_t *this) {
|
|
+ shard_local_t *local = NULL;
|
|
|
|
- if (op_ret < 0) {
|
|
- gf_msg(this->name, GF_LOG_ERROR, op_errno,
|
|
- SHARD_MSG_BASE_FILE_LOOKUP_FAILED,
|
|
- "Lookup on base file"
|
|
- " failed : %s",
|
|
- loc_gfid_utoa(&(local->loc)));
|
|
- local->op_ret = op_ret;
|
|
- local->op_errno = op_errno;
|
|
- goto unwind;
|
|
- }
|
|
+ local = frame->local;
|
|
|
|
- local->prebuf = *buf;
|
|
- if (shard_modify_size_and_block_count(&local->prebuf, xdata)) {
|
|
- local->op_ret = -1;
|
|
- local->op_errno = EINVAL;
|
|
- goto unwind;
|
|
+ if (local->op_ret < 0) {
|
|
+ shard_common_failure_unwind(local->fop, frame, local->op_ret,
|
|
+ local->op_errno);
|
|
+ return 0;
|
|
+ }
|
|
+
|
|
+ shard_truncate_do(frame, this);
|
|
+ return 0;
|
|
+}
|
|
+
|
|
+void shard_link_block_inode(shard_local_t *local, int block_num, inode_t *inode,
|
|
+ struct iatt *buf) {
|
|
+ int list_index = 0;
|
|
+ char block_bname[256] = {
|
|
+ 0,
|
|
+ };
|
|
+ uuid_t gfid = {
|
|
+ 0,
|
|
+ };
|
|
+ inode_t *linked_inode = NULL;
|
|
+ xlator_t *this = NULL;
|
|
+ inode_t *fsync_inode = NULL;
|
|
+ shard_priv_t *priv = NULL;
|
|
+ inode_t *base_inode = NULL;
|
|
+
|
|
+ this = THIS;
|
|
+ priv = this->private;
|
|
+ if (local->loc.inode) {
|
|
+ gf_uuid_copy(gfid, local->loc.inode->gfid);
|
|
+ base_inode = local->loc.inode;
|
|
+ } else if (local->resolver_base_inode) {
|
|
+ gf_uuid_copy(gfid, local->resolver_base_inode->gfid);
|
|
+ base_inode = local->resolver_base_inode;
|
|
+ } else {
|
|
+ gf_uuid_copy(gfid, local->base_gfid);
|
|
+ }
|
|
+
|
|
+ shard_make_block_bname(block_num, gfid, block_bname, sizeof(block_bname));
|
|
+
|
|
+ shard_inode_ctx_set(inode, this, buf, 0, SHARD_LOOKUP_MASK);
|
|
+ linked_inode = inode_link(inode, priv->dot_shard_inode, block_bname, buf);
|
|
+ inode_lookup(linked_inode);
|
|
+ list_index = block_num - local->first_block;
|
|
+ local->inode_list[list_index] = linked_inode;
|
|
+
|
|
+ LOCK(&priv->lock);
|
|
+ {
|
|
+ fsync_inode = __shard_update_shards_inode_list(linked_inode, this,
|
|
+ base_inode, block_num, gfid);
|
|
+ }
|
|
+ UNLOCK(&priv->lock);
|
|
+ if (fsync_inode)
|
|
+ shard_initiate_evicted_inode_fsync(this, fsync_inode);
|
|
+}
|
|
+
|
|
+int shard_common_lookup_shards_cbk(call_frame_t *frame, void *cookie,
|
|
+ xlator_t *this, int32_t op_ret,
|
|
+ int32_t op_errno, inode_t *inode,
|
|
+ struct iatt *buf, dict_t *xdata,
|
|
+ struct iatt *postparent) {
|
|
+ int call_count = 0;
|
|
+ int shard_block_num = (long)cookie;
|
|
+ uuid_t gfid = {
|
|
+ 0,
|
|
+ };
|
|
+ shard_local_t *local = NULL;
|
|
+
|
|
+ local = frame->local;
|
|
+ if (local->resolver_base_inode)
|
|
+ gf_uuid_copy(gfid, local->resolver_base_inode->gfid);
|
|
+ else
|
|
+ gf_uuid_copy(gfid, local->base_gfid);
|
|
+
|
|
+ if (op_ret < 0) {
|
|
+ /* Ignore absence of shards in the backend in truncate fop. */
|
|
+ switch (local->fop) {
|
|
+ case GF_FOP_TRUNCATE:
|
|
+ case GF_FOP_FTRUNCATE:
|
|
+ case GF_FOP_RENAME:
|
|
+ case GF_FOP_UNLINK:
|
|
+ if (op_errno == ENOENT)
|
|
+ goto done;
|
|
+ break;
|
|
+ case GF_FOP_WRITE:
|
|
+ case GF_FOP_READ:
|
|
+ case GF_FOP_ZEROFILL:
|
|
+ case GF_FOP_DISCARD:
|
|
+ case GF_FOP_FALLOCATE:
|
|
+ if ((!local->first_lookup_done) && (op_errno == ENOENT)) {
|
|
+ LOCK(&frame->lock);
|
|
+ { local->create_count++; }
|
|
+ UNLOCK(&frame->lock);
|
|
+ goto done;
|
|
+ }
|
|
+ break;
|
|
+ default:
|
|
+ break;
|
|
}
|
|
|
|
- if (shard_inode_ctx_get_all(inode, this, &ctx))
|
|
- mask = SHARD_ALL_MASK;
|
|
+ /* else */
|
|
+ gf_msg(this->name, GF_LOG_ERROR, op_errno, SHARD_MSG_LOOKUP_SHARD_FAILED,
|
|
+ "Lookup on shard %d "
|
|
+ "failed. Base file gfid = %s",
|
|
+ shard_block_num, uuid_utoa(gfid));
|
|
+ local->op_ret = op_ret;
|
|
+ local->op_errno = op_errno;
|
|
+ goto done;
|
|
+ }
|
|
|
|
- ret = shard_inode_ctx_set(inode, this, &local->prebuf, 0,
|
|
- (mask | SHARD_MASK_REFRESH_RESET));
|
|
- if (ret) {
|
|
- gf_msg(this->name, GF_LOG_ERROR, SHARD_MSG_INODE_CTX_SET_FAILED, 0,
|
|
- "Failed to set inode"
|
|
- " write params into inode ctx for %s",
|
|
- uuid_utoa(buf->ia_gfid));
|
|
- local->op_ret = -1;
|
|
- local->op_errno = ENOMEM;
|
|
- goto unwind;
|
|
- }
|
|
+ shard_link_block_inode(local, shard_block_num, inode, buf);
|
|
|
|
-unwind:
|
|
- local->handler(frame, this);
|
|
+done:
|
|
+ if (local->lookup_shards_barriered) {
|
|
+ syncbarrier_wake(&local->barrier);
|
|
return 0;
|
|
+ } else {
|
|
+ call_count = shard_call_count_return(frame);
|
|
+ if (call_count == 0) {
|
|
+ if (!local->first_lookup_done)
|
|
+ local->first_lookup_done = _gf_true;
|
|
+ local->pls_fop_handler(frame, this);
|
|
+ }
|
|
+ }
|
|
+ return 0;
|
|
}
|
|
|
|
-int
|
|
-shard_lookup_base_file(call_frame_t *frame, xlator_t *this, loc_t *loc,
|
|
- shard_post_fop_handler_t handler)
|
|
-{
|
|
- int ret = -1;
|
|
- shard_local_t *local = NULL;
|
|
- dict_t *xattr_req = NULL;
|
|
- gf_boolean_t need_refresh = _gf_false;
|
|
+dict_t *shard_create_gfid_dict(dict_t *dict) {
|
|
+ int ret = 0;
|
|
+ dict_t *new = NULL;
|
|
+ unsigned char *gfid = NULL;
|
|
|
|
- local = frame->local;
|
|
- local->handler = handler;
|
|
+ new = dict_copy_with_ref(dict, NULL);
|
|
+ if (!new)
|
|
+ return NULL;
|
|
|
|
- ret = shard_inode_ctx_fill_iatt_from_cache(loc->inode, this, &local->prebuf,
|
|
- &need_refresh);
|
|
- /* By this time, inode ctx should have been created either in create,
|
|
- * mknod, readdirp or lookup. If not it is a bug!
|
|
- */
|
|
- if ((ret == 0) && (need_refresh == _gf_false)) {
|
|
- gf_msg_debug(this->name, 0,
|
|
- "Skipping lookup on base file: %s"
|
|
- "Serving prebuf off the inode ctx cache",
|
|
- uuid_utoa(loc->gfid));
|
|
- goto out;
|
|
+ gfid = GF_MALLOC(sizeof(uuid_t), gf_common_mt_char);
|
|
+ if (!gfid) {
|
|
+ ret = -1;
|
|
+ goto out;
|
|
+ }
|
|
+
|
|
+ gf_uuid_generate(gfid);
|
|
+
|
|
+ ret = dict_set_gfuuid(new, "gfid-req", gfid, false);
|
|
+
|
|
+out:
|
|
+ if (ret) {
|
|
+ dict_unref(new);
|
|
+ new = NULL;
|
|
+ GF_FREE(gfid);
|
|
+ }
|
|
+
|
|
+ return new;
|
|
+}
|
|
+
|
|
+int shard_common_lookup_shards(call_frame_t *frame, xlator_t *this,
|
|
+ inode_t *inode,
|
|
+ shard_post_lookup_shards_fop_handler_t handler) {
|
|
+ int i = 0;
|
|
+ int ret = 0;
|
|
+ int count = 0;
|
|
+ int call_count = 0;
|
|
+ int32_t shard_idx_iter = 0;
|
|
+ int last_block = 0;
|
|
+ char path[PATH_MAX] = {
|
|
+ 0,
|
|
+ };
|
|
+ char *bname = NULL;
|
|
+ uuid_t gfid = {
|
|
+ 0,
|
|
+ };
|
|
+ loc_t loc = {
|
|
+ 0,
|
|
+ };
|
|
+ shard_local_t *local = NULL;
|
|
+ shard_priv_t *priv = NULL;
|
|
+ gf_boolean_t wind_failed = _gf_false;
|
|
+ dict_t *xattr_req = NULL;
|
|
+
|
|
+ priv = this->private;
|
|
+ local = frame->local;
|
|
+ count = call_count = local->call_count;
|
|
+ shard_idx_iter = local->first_block;
|
|
+ last_block = local->last_block;
|
|
+ local->pls_fop_handler = handler;
|
|
+ if (local->lookup_shards_barriered)
|
|
+ local->barrier.waitfor = local->call_count;
|
|
+
|
|
+ if (inode)
|
|
+ gf_uuid_copy(gfid, inode->gfid);
|
|
+ else
|
|
+ gf_uuid_copy(gfid, local->base_gfid);
|
|
+
|
|
+ while (shard_idx_iter <= last_block) {
|
|
+ if (local->inode_list[i]) {
|
|
+ i++;
|
|
+ shard_idx_iter++;
|
|
+ continue;
|
|
+ }
|
|
+
|
|
+ if (wind_failed) {
|
|
+ shard_common_lookup_shards_cbk(frame, (void *)(long)shard_idx_iter, this,
|
|
+ -1, ENOMEM, NULL, NULL, NULL, NULL);
|
|
+ goto next;
|
|
+ }
|
|
+
|
|
+ shard_make_block_abspath(shard_idx_iter, gfid, path, sizeof(path));
|
|
+
|
|
+ bname = strrchr(path, '/') + 1;
|
|
+ loc.inode = inode_new(this->itable);
|
|
+ loc.parent = inode_ref(priv->dot_shard_inode);
|
|
+ gf_uuid_copy(loc.pargfid, priv->dot_shard_gfid);
|
|
+ ret = inode_path(loc.parent, bname, (char **)&(loc.path));
|
|
+ if (ret < 0 || !(loc.inode)) {
|
|
+ gf_msg(this->name, GF_LOG_ERROR, 0, SHARD_MSG_INODE_PATH_FAILED,
|
|
+ "Inode path failed"
|
|
+ " on %s, base file gfid = %s",
|
|
+ bname, uuid_utoa(gfid));
|
|
+ local->op_ret = -1;
|
|
+ local->op_errno = ENOMEM;
|
|
+ loc_wipe(&loc);
|
|
+ wind_failed = _gf_true;
|
|
+ shard_common_lookup_shards_cbk(frame, (void *)(long)shard_idx_iter, this,
|
|
+ -1, ENOMEM, NULL, NULL, NULL, NULL);
|
|
+ goto next;
|
|
}
|
|
|
|
- xattr_req = dict_new();
|
|
+ loc.name = strrchr(loc.path, '/');
|
|
+ if (loc.name)
|
|
+ loc.name++;
|
|
+
|
|
+ xattr_req = shard_create_gfid_dict(local->xattr_req);
|
|
if (!xattr_req) {
|
|
- local->op_ret = -1;
|
|
- local->op_errno = ENOMEM;
|
|
- goto out;
|
|
+ local->op_ret = -1;
|
|
+ local->op_errno = ENOMEM;
|
|
+ wind_failed = _gf_true;
|
|
+ loc_wipe(&loc);
|
|
+ shard_common_lookup_shards_cbk(frame, (void *)(long)shard_idx_iter, this,
|
|
+ -1, ENOMEM, NULL, NULL, NULL, NULL);
|
|
+ goto next;
|
|
+ }
|
|
+
|
|
+ STACK_WIND_COOKIE(frame, shard_common_lookup_shards_cbk,
|
|
+ (void *)(long)shard_idx_iter, FIRST_CHILD(this),
|
|
+ FIRST_CHILD(this)->fops->lookup, &loc, xattr_req);
|
|
+ loc_wipe(&loc);
|
|
+ dict_unref(xattr_req);
|
|
+ next:
|
|
+ shard_idx_iter++;
|
|
+ i++;
|
|
+
|
|
+ if (!--call_count)
|
|
+ break;
|
|
+ }
|
|
+ if (local->lookup_shards_barriered) {
|
|
+ syncbarrier_wait(&local->barrier, count);
|
|
+ local->pls_fop_handler(frame, this);
|
|
+ }
|
|
+ return 0;
|
|
+}
|
|
+
|
|
+int shard_post_resolve_truncate_handler(call_frame_t *frame, xlator_t *this) {
|
|
+ shard_local_t *local = NULL;
|
|
+
|
|
+ local = frame->local;
|
|
+
|
|
+ if (local->op_ret < 0) {
|
|
+ if (local->op_errno == ENOENT) {
|
|
+ /* If lookup on /.shard fails with ENOENT, it means that
|
|
+ * the file was 0-byte in size but truncated sometime in
|
|
+ * the past to a higher size which is reflected in the
|
|
+ * size xattr, and now being truncated to a lower size.
|
|
+ * In this case, the only thing that needs to be done is
|
|
+ * to update the size xattr of the file and unwind.
|
|
+ */
|
|
+ local->first_block = local->last_block = 0;
|
|
+ local->num_blocks = 1;
|
|
+ local->call_count = 0;
|
|
+ local->op_ret = 0;
|
|
+ local->postbuf.ia_size = local->offset;
|
|
+ shard_update_file_size(frame, this, local->fd, &local->loc,
|
|
+ shard_post_update_size_truncate_handler);
|
|
+ return 0;
|
|
+ } else {
|
|
+ shard_common_failure_unwind(local->fop, frame, local->op_ret,
|
|
+ local->op_errno);
|
|
+ return 0;
|
|
}
|
|
+ }
|
|
|
|
- SHARD_MD_READ_FOP_INIT_REQ_DICT(this, xattr_req, loc->gfid, local, out);
|
|
+ if (!local->call_count)
|
|
+ shard_truncate_do(frame, this);
|
|
+ else
|
|
+ shard_common_lookup_shards(frame, this, local->loc.inode,
|
|
+ shard_post_lookup_shards_truncate_handler);
|
|
+
|
|
+ return 0;
|
|
+}
|
|
+
|
|
+int shard_truncate_begin(call_frame_t *frame, xlator_t *this) {
|
|
+ int ret = 0;
|
|
+ shard_local_t *local = NULL;
|
|
+ shard_priv_t *priv = NULL;
|
|
+
|
|
+ priv = this->private;
|
|
+ local = frame->local;
|
|
+
|
|
+ /* First participant block here is the lowest numbered block that would
|
|
+ * hold the last byte of the file post successful truncation.
|
|
+ * Last participant block is the block that contains the last byte in
|
|
+ * the current state of the file.
|
|
+ * If (first block == last_block):
|
|
+ * then that means that the file only needs truncation of the
|
|
+ * first (or last since both are same) block.
|
|
+ * Else
|
|
+ * if (new_size % block_size == 0)
|
|
+ * then that means there is no truncate to be done with
|
|
+ * only shards from first_block + 1 through the last
|
|
+ * block needing to be unlinked.
|
|
+ * else
|
|
+ * both truncate of the first block and unlink of the
|
|
+ * remaining shards until end of file is required.
|
|
+ */
|
|
+ local->first_block =
|
|
+ (local->offset == 0) ? 0 : get_lowest_block(local->offset - 1,
|
|
+ local->block_size);
|
|
+ local->last_block =
|
|
+ get_highest_block(0, local->prebuf.ia_size, local->block_size);
|
|
+
|
|
+ local->num_blocks = local->last_block - local->first_block + 1;
|
|
+ local->resolver_base_inode =
|
|
+ (local->fop == GF_FOP_TRUNCATE) ? local->loc.inode : local->fd->inode;
|
|
+
|
|
+ if ((local->first_block == 0) && (local->num_blocks == 1)) {
|
|
+ if (local->fop == GF_FOP_TRUNCATE)
|
|
+ STACK_WIND(frame, shard_truncate_last_shard_cbk, FIRST_CHILD(this),
|
|
+ FIRST_CHILD(this)->fops->truncate, &local->loc, local->offset,
|
|
+ local->xattr_req);
|
|
+ else
|
|
+ STACK_WIND(frame, shard_truncate_last_shard_cbk, FIRST_CHILD(this),
|
|
+ FIRST_CHILD(this)->fops->ftruncate, local->fd, local->offset,
|
|
+ local->xattr_req);
|
|
+ return 0;
|
|
+ }
|
|
|
|
- STACK_WIND(frame, shard_lookup_base_file_cbk, FIRST_CHILD(this),
|
|
- FIRST_CHILD(this)->fops->lookup, loc, xattr_req);
|
|
+ local->inode_list =
|
|
+ GF_CALLOC(local->num_blocks, sizeof(inode_t *), gf_shard_mt_inode_list);
|
|
+ if (!local->inode_list)
|
|
+ goto err;
|
|
|
|
- dict_unref(xattr_req);
|
|
- return 0;
|
|
+ local->dot_shard_loc.inode = inode_find(this->itable, priv->dot_shard_gfid);
|
|
+ if (!local->dot_shard_loc.inode) {
|
|
+ ret =
|
|
+ shard_init_internal_dir_loc(this, local, SHARD_INTERNAL_DIR_DOT_SHARD);
|
|
+ if (ret)
|
|
+ goto err;
|
|
+ shard_lookup_internal_dir(frame, this, shard_post_resolve_truncate_handler,
|
|
+ SHARD_INTERNAL_DIR_DOT_SHARD);
|
|
+ } else {
|
|
+ local->post_res_handler = shard_post_resolve_truncate_handler;
|
|
+ shard_refresh_internal_dir(frame, this, SHARD_INTERNAL_DIR_DOT_SHARD);
|
|
+ }
|
|
+ return 0;
|
|
|
|
-out:
|
|
- if (xattr_req)
|
|
- dict_unref(xattr_req);
|
|
- handler(frame, this);
|
|
- return 0;
|
|
+err:
|
|
+ shard_common_failure_unwind(local->fop, frame, -1, ENOMEM);
|
|
+ return 0;
|
|
}
|
|
|
|
-int
|
|
-shard_post_fstat_handler(call_frame_t *frame, xlator_t *this)
|
|
-{
|
|
- shard_local_t *local = NULL;
|
|
+int shard_post_lookup_truncate_handler(call_frame_t *frame, xlator_t *this) {
|
|
+ shard_local_t *local = NULL;
|
|
+ struct iatt tmp_stbuf = {
|
|
+ 0,
|
|
+ };
|
|
|
|
- local = frame->local;
|
|
-
|
|
- if (local->op_ret >= 0)
|
|
- shard_inode_ctx_set(local->fd->inode, this, &local->prebuf, 0,
|
|
- SHARD_LOOKUP_MASK);
|
|
+ local = frame->local;
|
|
|
|
- SHARD_STACK_UNWIND(fstat, frame, local->op_ret, local->op_errno,
|
|
- &local->prebuf, local->xattr_rsp);
|
|
+ if (local->op_ret < 0) {
|
|
+ shard_common_failure_unwind(local->fop, frame, local->op_ret,
|
|
+ local->op_errno);
|
|
return 0;
|
|
+ }
|
|
+
|
|
+ local->postbuf = tmp_stbuf = local->prebuf;
|
|
+
|
|
+ if (local->prebuf.ia_size == local->offset) {
|
|
+ /* If the file size is same as requested size, unwind the call
|
|
+ * immediately.
|
|
+ */
|
|
+ if (local->fop == GF_FOP_TRUNCATE)
|
|
+ SHARD_STACK_UNWIND(truncate, frame, 0, 0, &local->prebuf, &local->postbuf,
|
|
+ NULL);
|
|
+ else
|
|
+ SHARD_STACK_UNWIND(ftruncate, frame, 0, 0, &local->prebuf,
|
|
+ &local->postbuf, NULL);
|
|
+ } else if (local->offset > local->prebuf.ia_size) {
|
|
+ /* If the truncate is from a lower to a higher size, set the
|
|
+ * new size xattr and unwind.
|
|
+ */
|
|
+ local->hole_size = local->offset - local->prebuf.ia_size;
|
|
+ local->delta_size = 0;
|
|
+ GF_ATOMIC_INIT(local->delta_blocks, 0);
|
|
+ local->postbuf.ia_size = local->offset;
|
|
+ tmp_stbuf.ia_size = local->offset;
|
|
+ shard_inode_ctx_set(local->loc.inode, this, &tmp_stbuf, 0,
|
|
+ SHARD_INODE_WRITE_MASK);
|
|
+ shard_update_file_size(frame, this, NULL, &local->loc,
|
|
+ shard_post_update_size_truncate_handler);
|
|
+ } else {
|
|
+ /* ... else
|
|
+ * i. unlink all shards that need to be unlinked.
|
|
+ * ii. truncate the last of the shards.
|
|
+ * iii. update the new size using setxattr.
|
|
+ * and unwind the fop.
|
|
+ */
|
|
+ local->hole_size = 0;
|
|
+ local->delta_size = (local->offset - local->prebuf.ia_size);
|
|
+ GF_ATOMIC_INIT(local->delta_blocks, 0);
|
|
+ tmp_stbuf.ia_size = local->offset;
|
|
+ shard_inode_ctx_set(local->loc.inode, this, &tmp_stbuf, 0,
|
|
+ SHARD_INODE_WRITE_MASK);
|
|
+ shard_truncate_begin(frame, this);
|
|
+ }
|
|
+ return 0;
|
|
}
|
|
|
|
-int
|
|
-shard_post_stat_handler(call_frame_t *frame, xlator_t *this)
|
|
-{
|
|
- shard_local_t *local = NULL;
|
|
+/* TO-DO:
|
|
+ * Fix updates to size and block count with racing write(s) and truncate(s).
|
|
+ */
|
|
|
|
- local = frame->local;
|
|
+int shard_truncate(call_frame_t *frame, xlator_t *this, loc_t *loc,
|
|
+ off_t offset, dict_t *xdata) {
|
|
+ int ret = -1;
|
|
+ uint64_t block_size = 0;
|
|
+ shard_local_t *local = NULL;
|
|
|
|
- if (local->op_ret >= 0)
|
|
- shard_inode_ctx_set(local->loc.inode, this, &local->prebuf, 0,
|
|
- SHARD_LOOKUP_MASK);
|
|
+ ret = shard_inode_ctx_get_block_size(loc->inode, this, &block_size);
|
|
+ if (ret) {
|
|
+ gf_msg(this->name, GF_LOG_ERROR, 0, SHARD_MSG_INODE_CTX_GET_FAILED,
|
|
+ "Failed to get block "
|
|
+ "size from inode ctx of %s",
|
|
+ uuid_utoa(loc->inode->gfid));
|
|
+ goto err;
|
|
+ }
|
|
|
|
- SHARD_STACK_UNWIND(stat, frame, local->op_ret, local->op_errno,
|
|
- &local->prebuf, local->xattr_rsp);
|
|
+ if (!block_size || frame->root->pid == GF_CLIENT_PID_GSYNCD) {
|
|
+ STACK_WIND(frame, default_truncate_cbk, FIRST_CHILD(this),
|
|
+ FIRST_CHILD(this)->fops->truncate, loc, offset, xdata);
|
|
return 0;
|
|
-}
|
|
+ }
|
|
|
|
-int
|
|
-shard_common_stat_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
|
|
- int32_t op_ret, int32_t op_errno, struct iatt *buf,
|
|
- dict_t *xdata)
|
|
-{
|
|
- inode_t *inode = NULL;
|
|
- shard_local_t *local = NULL;
|
|
+ if (!this->itable)
|
|
+ this->itable = loc->inode->table;
|
|
|
|
- local = frame->local;
|
|
+ local = mem_get0(this->local_pool);
|
|
+ if (!local)
|
|
+ goto err;
|
|
+
|
|
+ frame->local = local;
|
|
+
|
|
+ ret = syncbarrier_init(&local->barrier);
|
|
+ if (ret)
|
|
+ goto err;
|
|
+ loc_copy(&local->loc, loc);
|
|
+ local->offset = offset;
|
|
+ local->block_size = block_size;
|
|
+ local->fop = GF_FOP_TRUNCATE;
|
|
+ local->xattr_req = (xdata) ? dict_ref(xdata) : dict_new();
|
|
+ if (!local->xattr_req)
|
|
+ goto err;
|
|
+ local->resolver_base_inode = loc->inode;
|
|
+ GF_ATOMIC_INIT(local->delta_blocks, 0);
|
|
+
|
|
+ shard_lookup_base_file(frame, this, &local->loc,
|
|
+ shard_post_lookup_truncate_handler);
|
|
+ return 0;
|
|
|
|
- if (op_ret < 0) {
|
|
- gf_msg(this->name, GF_LOG_ERROR, op_errno, SHARD_MSG_STAT_FAILED,
|
|
- "stat failed: %s",
|
|
- local->fd ? uuid_utoa(local->fd->inode->gfid)
|
|
- : uuid_utoa((local->loc.inode)->gfid));
|
|
- local->op_ret = op_ret;
|
|
- local->op_errno = op_errno;
|
|
- goto unwind;
|
|
- }
|
|
+err:
|
|
+ shard_common_failure_unwind(GF_FOP_TRUNCATE, frame, -1, ENOMEM);
|
|
+ return 0;
|
|
+}
|
|
+
|
|
+int shard_ftruncate(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
|
|
+ dict_t *xdata) {
|
|
+ int ret = -1;
|
|
+ uint64_t block_size = 0;
|
|
+ shard_local_t *local = NULL;
|
|
+
|
|
+ ret = shard_inode_ctx_get_block_size(fd->inode, this, &block_size);
|
|
+ if (ret) {
|
|
+ gf_msg(this->name, GF_LOG_ERROR, 0, SHARD_MSG_INODE_CTX_GET_FAILED,
|
|
+ "Failed to get block "
|
|
+ "size from inode ctx of %s",
|
|
+ uuid_utoa(fd->inode->gfid));
|
|
+ goto err;
|
|
+ }
|
|
+
|
|
+ if (!block_size || frame->root->pid == GF_CLIENT_PID_GSYNCD) {
|
|
+ STACK_WIND(frame, default_ftruncate_cbk, FIRST_CHILD(this),
|
|
+ FIRST_CHILD(this)->fops->ftruncate, fd, offset, xdata);
|
|
+ return 0;
|
|
+ }
|
|
+
|
|
+ if (!this->itable)
|
|
+ this->itable = fd->inode->table;
|
|
+
|
|
+ local = mem_get0(this->local_pool);
|
|
+ if (!local)
|
|
+ goto err;
|
|
+
|
|
+ frame->local = local;
|
|
+ ret = syncbarrier_init(&local->barrier);
|
|
+ if (ret)
|
|
+ goto err;
|
|
+ local->fd = fd_ref(fd);
|
|
+ local->offset = offset;
|
|
+ local->block_size = block_size;
|
|
+ local->xattr_req = (xdata) ? dict_ref(xdata) : dict_new();
|
|
+ if (!local->xattr_req)
|
|
+ goto err;
|
|
+ local->fop = GF_FOP_FTRUNCATE;
|
|
+
|
|
+ local->loc.inode = inode_ref(fd->inode);
|
|
+ gf_uuid_copy(local->loc.gfid, fd->inode->gfid);
|
|
+ local->resolver_base_inode = fd->inode;
|
|
+ GF_ATOMIC_INIT(local->delta_blocks, 0);
|
|
+
|
|
+ shard_lookup_base_file(frame, this, &local->loc,
|
|
+ shard_post_lookup_truncate_handler);
|
|
+ return 0;
|
|
+err:
|
|
+ shard_common_failure_unwind(GF_FOP_FTRUNCATE, frame, -1, ENOMEM);
|
|
+ return 0;
|
|
+}
|
|
|
|
- local->prebuf = *buf;
|
|
- if (shard_modify_size_and_block_count(&local->prebuf, xdata)) {
|
|
- local->op_ret = -1;
|
|
- local->op_errno = EINVAL;
|
|
- goto unwind;
|
|
- }
|
|
- local->xattr_rsp = dict_ref(xdata);
|
|
+int shard_mknod_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
|
|
+ int32_t op_ret, int32_t op_errno, inode_t *inode,
|
|
+ struct iatt *buf, struct iatt *preparent,
|
|
+ struct iatt *postparent, dict_t *xdata) {
|
|
+ int ret = -1;
|
|
+ shard_local_t *local = NULL;
|
|
|
|
- if (local->loc.inode)
|
|
- inode = local->loc.inode;
|
|
- else
|
|
- inode = local->fd->inode;
|
|
+ local = frame->local;
|
|
|
|
- shard_inode_ctx_invalidate(inode, this, &local->prebuf);
|
|
+ if (op_ret == -1)
|
|
+ goto unwind;
|
|
+
|
|
+ ret =
|
|
+ shard_inode_ctx_set(inode, this, buf, local->block_size, SHARD_ALL_MASK);
|
|
+ if (ret)
|
|
+ gf_msg(this->name, GF_LOG_WARNING, 0, SHARD_MSG_INODE_CTX_SET_FAILED,
|
|
+ "Failed to set inode "
|
|
+ "ctx for %s",
|
|
+ uuid_utoa(inode->gfid));
|
|
|
|
unwind:
|
|
- local->handler(frame, this);
|
|
- return 0;
|
|
-}
|
|
+ SHARD_STACK_UNWIND(mknod, frame, op_ret, op_errno, inode, buf, preparent,
|
|
+ postparent, xdata);
|
|
|
|
-int
|
|
-shard_stat(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata)
|
|
-{
|
|
- int ret = -1;
|
|
- uint64_t block_size = 0;
|
|
- shard_local_t *local = NULL;
|
|
+ return 0;
|
|
+}
|
|
|
|
- if ((IA_ISDIR(loc->inode->ia_type)) || (IA_ISLNK(loc->inode->ia_type))) {
|
|
- STACK_WIND(frame, default_stat_cbk, FIRST_CHILD(this),
|
|
- FIRST_CHILD(this)->fops->stat, loc, xdata);
|
|
- return 0;
|
|
- }
|
|
+int shard_mknod(call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode,
|
|
+ dev_t rdev, mode_t umask, dict_t *xdata) {
|
|
+ shard_priv_t *priv = NULL;
|
|
+ shard_local_t *local = NULL;
|
|
|
|
- ret = shard_inode_ctx_get_block_size(loc->inode, this, &block_size);
|
|
- if (ret) {
|
|
- gf_msg(this->name, GF_LOG_ERROR, 0, SHARD_MSG_INODE_CTX_GET_FAILED,
|
|
- "Failed to get block "
|
|
- "size from inode ctx of %s",
|
|
- uuid_utoa(loc->inode->gfid));
|
|
- goto err;
|
|
- }
|
|
+ priv = this->private;
|
|
+ local = mem_get0(this->local_pool);
|
|
+ if (!local)
|
|
+ goto err;
|
|
|
|
- if (!block_size || frame->root->pid == GF_CLIENT_PID_GSYNCD) {
|
|
- STACK_WIND(frame, default_stat_cbk, FIRST_CHILD(this),
|
|
- FIRST_CHILD(this)->fops->stat, loc, xdata);
|
|
- return 0;
|
|
- }
|
|
+ frame->local = local;
|
|
+ local->block_size = priv->block_size;
|
|
+ if (!__is_gsyncd_on_shard_dir(frame, loc)) {
|
|
+ SHARD_INODE_CREATE_INIT(this, local->block_size, xdata, loc, 0, 0, err);
|
|
+ }
|
|
|
|
- local = mem_get0(this->local_pool);
|
|
- if (!local)
|
|
- goto err;
|
|
+ STACK_WIND(frame, shard_mknod_cbk, FIRST_CHILD(this),
|
|
+ FIRST_CHILD(this)->fops->mknod, loc, mode, rdev, umask, xdata);
|
|
+ return 0;
|
|
+err:
|
|
+ shard_common_failure_unwind(GF_FOP_MKNOD, frame, -1, ENOMEM);
|
|
+ return 0;
|
|
+}
|
|
|
|
- frame->local = local;
|
|
+int32_t shard_link_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
|
|
+ int32_t op_ret, int32_t op_errno, inode_t *inode,
|
|
+ struct iatt *buf, struct iatt *preparent,
|
|
+ struct iatt *postparent, dict_t *xdata) {
|
|
+ shard_local_t *local = NULL;
|
|
|
|
- local->handler = shard_post_stat_handler;
|
|
- loc_copy(&local->loc, loc);
|
|
- local->xattr_req = (xdata) ? dict_ref(xdata) : dict_new();
|
|
- if (!local->xattr_req)
|
|
- goto err;
|
|
+ local = frame->local;
|
|
+ if (op_ret < 0)
|
|
+ goto err;
|
|
|
|
- SHARD_MD_READ_FOP_INIT_REQ_DICT(this, local->xattr_req, local->loc.gfid,
|
|
- local, err);
|
|
+ shard_inode_ctx_set(inode, this, buf, 0, SHARD_MASK_NLINK | SHARD_MASK_TIMES);
|
|
+ buf->ia_size = local->prebuf.ia_size;
|
|
+ buf->ia_blocks = local->prebuf.ia_blocks;
|
|
|
|
- STACK_WIND(frame, shard_common_stat_cbk, FIRST_CHILD(this),
|
|
- FIRST_CHILD(this)->fops->stat, loc, local->xattr_req);
|
|
- return 0;
|
|
+ SHARD_STACK_UNWIND(link, frame, op_ret, op_errno, inode, buf, preparent,
|
|
+ postparent, xdata);
|
|
+ return 0;
|
|
err:
|
|
- shard_common_failure_unwind(GF_FOP_STAT, frame, -1, ENOMEM);
|
|
- return 0;
|
|
+ shard_common_failure_unwind(GF_FOP_LINK, frame, op_ret, op_errno);
|
|
+ return 0;
|
|
}
|
|
|
|
-int
|
|
-shard_fstat(call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata)
|
|
-{
|
|
- int ret = -1;
|
|
- uint64_t block_size = 0;
|
|
- shard_local_t *local = NULL;
|
|
+int shard_post_lookup_link_handler(call_frame_t *frame, xlator_t *this) {
|
|
+ shard_local_t *local = NULL;
|
|
|
|
- if ((IA_ISDIR(fd->inode->ia_type)) || (IA_ISLNK(fd->inode->ia_type))) {
|
|
- STACK_WIND(frame, default_fstat_cbk, FIRST_CHILD(this),
|
|
- FIRST_CHILD(this)->fops->fstat, fd, xdata);
|
|
- return 0;
|
|
- }
|
|
+ local = frame->local;
|
|
|
|
- ret = shard_inode_ctx_get_block_size(fd->inode, this, &block_size);
|
|
- if (ret) {
|
|
- gf_msg(this->name, GF_LOG_ERROR, 0, SHARD_MSG_INODE_CTX_GET_FAILED,
|
|
- "Failed to get block "
|
|
- "size from inode ctx of %s",
|
|
- uuid_utoa(fd->inode->gfid));
|
|
- goto err;
|
|
- }
|
|
+ if (local->op_ret < 0) {
|
|
+ SHARD_STACK_UNWIND(link, frame, local->op_ret, local->op_errno, NULL, NULL,
|
|
+ NULL, NULL, NULL);
|
|
+ return 0;
|
|
+ }
|
|
|
|
- if (!block_size || frame->root->pid == GF_CLIENT_PID_GSYNCD) {
|
|
- STACK_WIND(frame, default_fstat_cbk, FIRST_CHILD(this),
|
|
- FIRST_CHILD(this)->fops->fstat, fd, xdata);
|
|
- return 0;
|
|
- }
|
|
+ STACK_WIND(frame, shard_link_cbk, FIRST_CHILD(this),
|
|
+ FIRST_CHILD(this)->fops->link, &local->loc, &local->loc2,
|
|
+ local->xattr_req);
|
|
+ return 0;
|
|
+}
|
|
|
|
- if (!this->itable)
|
|
- this->itable = fd->inode->table;
|
|
+int32_t shard_link(call_frame_t *frame, xlator_t *this, loc_t *oldloc,
|
|
+ loc_t *newloc, dict_t *xdata) {
|
|
+ int ret = -1;
|
|
+ uint64_t block_size = 0;
|
|
+ shard_local_t *local = NULL;
|
|
|
|
- local = mem_get0(this->local_pool);
|
|
- if (!local)
|
|
- goto err;
|
|
+ ret = shard_inode_ctx_get_block_size(oldloc->inode, this, &block_size);
|
|
+ if (ret) {
|
|
+ gf_msg(this->name, GF_LOG_ERROR, 0, SHARD_MSG_INODE_CTX_GET_FAILED,
|
|
+ "Failed to get block "
|
|
+ "size from inode ctx of %s",
|
|
+ uuid_utoa(oldloc->inode->gfid));
|
|
+ goto err;
|
|
+ }
|
|
|
|
- frame->local = local;
|
|
+ if (!block_size) {
|
|
+ STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->link,
|
|
+ oldloc, newloc, xdata);
|
|
+ return 0;
|
|
+ }
|
|
|
|
- local->handler = shard_post_fstat_handler;
|
|
- local->fd = fd_ref(fd);
|
|
- local->xattr_req = (xdata) ? dict_ref(xdata) : dict_new();
|
|
- if (!local->xattr_req)
|
|
- goto err;
|
|
+ if (!this->itable)
|
|
+ this->itable = oldloc->inode->table;
|
|
|
|
- SHARD_MD_READ_FOP_INIT_REQ_DICT(this, local->xattr_req, fd->inode->gfid,
|
|
- local, err);
|
|
+ local = mem_get0(this->local_pool);
|
|
+ if (!local)
|
|
+ goto err;
|
|
|
|
- STACK_WIND(frame, shard_common_stat_cbk, FIRST_CHILD(this),
|
|
- FIRST_CHILD(this)->fops->fstat, fd, local->xattr_req);
|
|
- return 0;
|
|
+ frame->local = local;
|
|
+
|
|
+ loc_copy(&local->loc, oldloc);
|
|
+ loc_copy(&local->loc2, newloc);
|
|
+ local->xattr_req = (xdata) ? dict_ref(xdata) : dict_new();
|
|
+ if (!local->xattr_req)
|
|
+ goto err;
|
|
+
|
|
+ shard_lookup_base_file(frame, this, &local->loc,
|
|
+ shard_post_lookup_link_handler);
|
|
+ return 0;
|
|
err:
|
|
- shard_common_failure_unwind(GF_FOP_FSTAT, frame, -1, ENOMEM);
|
|
- return 0;
|
|
+ shard_common_failure_unwind(GF_FOP_LINK, frame, -1, ENOMEM);
|
|
+ return 0;
|
|
}
|
|
|
|
-int
|
|
-shard_post_update_size_truncate_handler(call_frame_t *frame, xlator_t *this)
|
|
-{
|
|
- shard_local_t *local = NULL;
|
|
+int shard_unlink_shards_do(call_frame_t *frame, xlator_t *this, inode_t *inode);
|
|
|
|
- local = frame->local;
|
|
+int shard_post_lookup_shards_unlink_handler(call_frame_t *frame,
|
|
+ xlator_t *this) {
|
|
+ shard_local_t *local = NULL;
|
|
|
|
- if (local->fop == GF_FOP_TRUNCATE)
|
|
- SHARD_STACK_UNWIND(truncate, frame, local->op_ret, local->op_errno,
|
|
- &local->prebuf, &local->postbuf, NULL);
|
|
- else
|
|
- SHARD_STACK_UNWIND(ftruncate, frame, local->op_ret, local->op_errno,
|
|
- &local->prebuf, &local->postbuf, NULL);
|
|
+ local = frame->local;
|
|
+
|
|
+ if ((local->op_ret < 0) && (local->op_errno != ENOENT)) {
|
|
+ gf_msg(this->name, GF_LOG_ERROR, local->op_errno, SHARD_MSG_FOP_FAILED,
|
|
+ "failed to delete shards of %s",
|
|
+ uuid_utoa(local->resolver_base_inode->gfid));
|
|
return 0;
|
|
-}
|
|
+ }
|
|
+ local->op_ret = 0;
|
|
+ local->op_errno = 0;
|
|
|
|
-int
|
|
-shard_truncate_last_shard_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
|
|
- int32_t op_ret, int32_t op_errno,
|
|
- struct iatt *prebuf, struct iatt *postbuf,
|
|
- dict_t *xdata)
|
|
-{
|
|
- inode_t *inode = NULL;
|
|
- int64_t delta_blocks = 0;
|
|
- shard_local_t *local = NULL;
|
|
+ shard_unlink_shards_do(frame, this, local->resolver_base_inode);
|
|
+ return 0;
|
|
+}
|
|
|
|
- local = frame->local;
|
|
+int shard_post_resolve_unlink_handler(call_frame_t *frame, xlator_t *this) {
|
|
+ shard_local_t *local = NULL;
|
|
|
|
- SHARD_UNSET_ROOT_FS_ID(frame, local);
|
|
+ local = frame->local;
|
|
+ local->lookup_shards_barriered = _gf_true;
|
|
|
|
- inode = (local->fop == GF_FOP_TRUNCATE) ? local->loc.inode
|
|
- : local->fd->inode;
|
|
- if (op_ret < 0) {
|
|
- gf_msg(this->name, GF_LOG_ERROR, op_errno,
|
|
- SHARD_MSG_TRUNCATE_LAST_SHARD_FAILED,
|
|
- "truncate on last"
|
|
- " shard failed : %s",
|
|
- uuid_utoa(inode->gfid));
|
|
- local->op_ret = op_ret;
|
|
- local->op_errno = op_errno;
|
|
- goto err;
|
|
- }
|
|
+ if (!local->call_count)
|
|
+ shard_unlink_shards_do(frame, this, local->resolver_base_inode);
|
|
+ else
|
|
+ shard_common_lookup_shards(frame, this, local->resolver_base_inode,
|
|
+ shard_post_lookup_shards_unlink_handler);
|
|
+ return 0;
|
|
+}
|
|
+
|
|
+void shard_unlink_block_inode(shard_local_t *local, int shard_block_num) {
|
|
+ char block_bname[256] = {
|
|
+ 0,
|
|
+ };
|
|
+ uuid_t gfid = {
|
|
+ 0,
|
|
+ };
|
|
+ inode_t *inode = NULL;
|
|
+ inode_t *base_inode = NULL;
|
|
+ xlator_t *this = NULL;
|
|
+ shard_priv_t *priv = NULL;
|
|
+ shard_inode_ctx_t *ctx = NULL;
|
|
+ shard_inode_ctx_t *base_ictx = NULL;
|
|
+ int unref_base_inode = 0;
|
|
+ int unref_shard_inode = 0;
|
|
+
|
|
+ this = THIS;
|
|
+ priv = this->private;
|
|
+
|
|
+ inode = local->inode_list[shard_block_num - local->first_block];
|
|
+ shard_inode_ctx_get(inode, this, &ctx);
|
|
+ base_inode = ctx->base_inode;
|
|
+ if (base_inode)
|
|
+ gf_uuid_copy(gfid, base_inode->gfid);
|
|
+ else
|
|
+ gf_uuid_copy(gfid, ctx->base_gfid);
|
|
+ shard_make_block_bname(shard_block_num, gfid, block_bname,
|
|
+ sizeof(block_bname));
|
|
+
|
|
+ LOCK(&priv->lock);
|
|
+ if (base_inode)
|
|
+ LOCK(&base_inode->lock);
|
|
+ LOCK(&inode->lock);
|
|
+ {
|
|
+ __shard_inode_ctx_get(inode, this, &ctx);
|
|
+ if (!list_empty(&ctx->ilist)) {
|
|
+ list_del_init(&ctx->ilist);
|
|
+ priv->inode_count--;
|
|
+ unref_base_inode++;
|
|
+ unref_shard_inode++;
|
|
+ GF_ASSERT(priv->inode_count >= 0);
|
|
+ }
|
|
+ if (ctx->fsync_needed) {
|
|
+ unref_base_inode++;
|
|
+ unref_shard_inode++;
|
|
+ list_del_init(&ctx->to_fsync_list);
|
|
+ if (base_inode) {
|
|
+ __shard_inode_ctx_get(base_inode, this, &base_ictx);
|
|
+ base_ictx->fsync_count--;
|
|
+ }
|
|
+ }
|
|
+ }
|
|
+ UNLOCK(&inode->lock);
|
|
+ if (base_inode)
|
|
+ UNLOCK(&base_inode->lock);
|
|
|
|
- local->postbuf.ia_size = local->offset;
|
|
- /* Let the delta be negative. We want xattrop to do subtraction */
|
|
- local->delta_size = local->postbuf.ia_size - local->prebuf.ia_size;
|
|
- delta_blocks = GF_ATOMIC_ADD(local->delta_blocks,
|
|
- postbuf->ia_blocks - prebuf->ia_blocks);
|
|
- GF_ASSERT(delta_blocks <= 0);
|
|
- local->postbuf.ia_blocks += delta_blocks;
|
|
- local->hole_size = 0;
|
|
+ inode_unlink(inode, priv->dot_shard_inode, block_bname);
|
|
+ inode_ref_reduce_by_n(inode, unref_shard_inode);
|
|
+ inode_forget(inode, 0);
|
|
|
|
- shard_inode_ctx_set(inode, this, &local->postbuf, 0, SHARD_MASK_TIMES);
|
|
- shard_update_file_size(frame, this, NULL, &local->loc,
|
|
- shard_post_update_size_truncate_handler);
|
|
- return 0;
|
|
-err:
|
|
- shard_common_failure_unwind(local->fop, frame, local->op_ret,
|
|
- local->op_errno);
|
|
- return 0;
|
|
+ if (base_inode && unref_base_inode)
|
|
+ inode_ref_reduce_by_n(base_inode, unref_base_inode);
|
|
+ UNLOCK(&priv->lock);
|
|
}
|
|
|
|
-int
|
|
-shard_truncate_last_shard(call_frame_t *frame, xlator_t *this, inode_t *inode)
|
|
-{
|
|
- size_t last_shard_size_after = 0;
|
|
- loc_t loc = {
|
|
- 0,
|
|
- };
|
|
- shard_local_t *local = NULL;
|
|
+int shard_rename_cbk(call_frame_t *frame, xlator_t *this) {
|
|
+ shard_local_t *local = NULL;
|
|
|
|
- local = frame->local;
|
|
+ local = frame->local;
|
|
|
|
- /* A NULL inode could be due to the fact that the last shard which
|
|
- * needs to be truncated does not exist due to it lying in a hole
|
|
- * region. So the only thing left to do in that case would be an
|
|
- * update to file size xattr.
|
|
- */
|
|
- if (!inode) {
|
|
- gf_msg_debug(this->name, 0,
|
|
- "Last shard to be truncated absent"
|
|
- " in backend: %s. Directly proceeding to update "
|
|
- "file size",
|
|
- uuid_utoa(inode->gfid));
|
|
- shard_update_file_size(frame, this, NULL, &local->loc,
|
|
- shard_post_update_size_truncate_handler);
|
|
- return 0;
|
|
- }
|
|
+ SHARD_STACK_UNWIND(rename, frame, local->op_ret, local->op_errno,
|
|
+ &local->prebuf, &local->preoldparent,
|
|
+ &local->postoldparent, &local->prenewparent,
|
|
+ &local->postnewparent, local->xattr_rsp);
|
|
+ return 0;
|
|
+}
|
|
|
|
- SHARD_SET_ROOT_FS_ID(frame, local);
|
|
+int32_t shard_unlink_cbk(call_frame_t *frame, xlator_t *this) {
|
|
+ shard_local_t *local = frame->local;
|
|
|
|
- loc.inode = inode_ref(inode);
|
|
- gf_uuid_copy(loc.gfid, inode->gfid);
|
|
+ SHARD_STACK_UNWIND(unlink, frame, local->op_ret, local->op_errno,
|
|
+ &local->preoldparent, &local->postoldparent,
|
|
+ local->xattr_rsp);
|
|
+ return 0;
|
|
+}
|
|
|
|
- last_shard_size_after = (local->offset % local->block_size);
|
|
+int shard_unlink_shards_do_cbk(call_frame_t *frame, void *cookie,
|
|
+ xlator_t *this, int32_t op_ret, int32_t op_errno,
|
|
+ struct iatt *preparent, struct iatt *postparent,
|
|
+ dict_t *xdata) {
|
|
+ int shard_block_num = (long)cookie;
|
|
+ shard_local_t *local = NULL;
|
|
|
|
- STACK_WIND(frame, shard_truncate_last_shard_cbk, FIRST_CHILD(this),
|
|
- FIRST_CHILD(this)->fops->truncate, &loc, last_shard_size_after,
|
|
- NULL);
|
|
- loc_wipe(&loc);
|
|
- return 0;
|
|
-}
|
|
+ local = frame->local;
|
|
|
|
-void
|
|
-shard_unlink_block_inode(shard_local_t *local, int shard_block_num);
|
|
+ if (op_ret < 0) {
|
|
+ local->op_ret = op_ret;
|
|
+ local->op_errno = op_errno;
|
|
+ goto done;
|
|
+ }
|
|
|
|
-int
|
|
-shard_truncate_htol_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
|
|
- int32_t op_ret, int32_t op_errno,
|
|
- struct iatt *preparent, struct iatt *postparent,
|
|
- dict_t *xdata)
|
|
-{
|
|
- int ret = 0;
|
|
- int call_count = 0;
|
|
- int shard_block_num = (long)cookie;
|
|
- uint64_t block_count = 0;
|
|
- shard_local_t *local = NULL;
|
|
+ shard_unlink_block_inode(local, shard_block_num);
|
|
+done:
|
|
+ syncbarrier_wake(&local->barrier);
|
|
+ return 0;
|
|
+}
|
|
+
|
|
+int shard_unlink_shards_do(call_frame_t *frame, xlator_t *this,
|
|
+ inode_t *inode) {
|
|
+ int i = 0;
|
|
+ int ret = -1;
|
|
+ int count = 0;
|
|
+ uint32_t cur_block = 0;
|
|
+ uint32_t cur_block_idx = 0; /*this is idx into inode_list[] array */
|
|
+ char *bname = NULL;
|
|
+ char path[PATH_MAX] = {
|
|
+ 0,
|
|
+ };
|
|
+ uuid_t gfid = {
|
|
+ 0,
|
|
+ };
|
|
+ loc_t loc = {
|
|
+ 0,
|
|
+ };
|
|
+ gf_boolean_t wind_failed = _gf_false;
|
|
+ shard_local_t *local = NULL;
|
|
+ shard_priv_t *priv = NULL;
|
|
+
|
|
+ priv = this->private;
|
|
+ local = frame->local;
|
|
+
|
|
+ if (inode)
|
|
+ gf_uuid_copy(gfid, inode->gfid);
|
|
+ else
|
|
+ gf_uuid_copy(gfid, local->base_gfid);
|
|
+
|
|
+ for (i = 0; i < local->num_blocks; i++) {
|
|
+ if (!local->inode_list[i])
|
|
+ continue;
|
|
+ count++;
|
|
+ }
|
|
+
|
|
+ if (!count) {
|
|
+ /* callcount = 0 implies that all of the shards that need to be
|
|
+ * unlinked are non-existent (in other words the file is full of
|
|
+ * holes).
|
|
+ */
|
|
+ gf_msg_debug(this->name, 0, "All shards that need to be "
|
|
+ "unlinked are non-existent: %s",
|
|
+ uuid_utoa(gfid));
|
|
+ return 0;
|
|
+ }
|
|
|
|
- local = frame->local;
|
|
+ SHARD_SET_ROOT_FS_ID(frame, local);
|
|
+ local->barrier.waitfor = count;
|
|
+ cur_block = cur_block_idx + local->first_block;
|
|
|
|
- if (op_ret < 0) {
|
|
- local->op_ret = op_ret;
|
|
- local->op_errno = op_errno;
|
|
- goto done;
|
|
- }
|
|
- ret = dict_get_uint64(xdata, GF_GET_FILE_BLOCK_COUNT, &block_count);
|
|
- if (!ret) {
|
|
- GF_ATOMIC_SUB(local->delta_blocks, block_count);
|
|
- } else {
|
|
- /* dict_get failed possibly due to a heterogeneous cluster? */
|
|
- gf_msg(this->name, GF_LOG_WARNING, 0, SHARD_MSG_DICT_OP_FAILED,
|
|
- "Failed to get key %s from dict during truncate of gfid %s",
|
|
- GF_GET_FILE_BLOCK_COUNT,
|
|
- uuid_utoa(local->resolver_base_inode->gfid));
|
|
- }
|
|
-
|
|
- shard_unlink_block_inode(local, shard_block_num);
|
|
-done:
|
|
- call_count = shard_call_count_return(frame);
|
|
- if (call_count == 0) {
|
|
- SHARD_UNSET_ROOT_FS_ID(frame, local);
|
|
- shard_truncate_last_shard(frame, this, local->inode_list[0]);
|
|
- }
|
|
- return 0;
|
|
-}
|
|
-
|
|
-int
|
|
-shard_truncate_htol(call_frame_t *frame, xlator_t *this, inode_t *inode)
|
|
-{
|
|
- int i = 1;
|
|
- int ret = -1;
|
|
- int call_count = 0;
|
|
- uint32_t cur_block = 0;
|
|
- uint32_t last_block = 0;
|
|
- char path[PATH_MAX] = {
|
|
- 0,
|
|
- };
|
|
- char *bname = NULL;
|
|
- loc_t loc = {
|
|
- 0,
|
|
- };
|
|
- gf_boolean_t wind_failed = _gf_false;
|
|
- shard_local_t *local = NULL;
|
|
- shard_priv_t *priv = NULL;
|
|
- dict_t *xdata_req = NULL;
|
|
-
|
|
- local = frame->local;
|
|
- priv = this->private;
|
|
-
|
|
- cur_block = local->first_block + 1;
|
|
- last_block = local->last_block;
|
|
-
|
|
- /* Determine call count */
|
|
- for (i = 1; i < local->num_blocks; i++) {
|
|
- if (!local->inode_list[i])
|
|
- continue;
|
|
- call_count++;
|
|
- }
|
|
+ while (cur_block_idx < local->num_blocks) {
|
|
+ if (!local->inode_list[cur_block_idx])
|
|
+ goto next;
|
|
|
|
- if (!call_count) {
|
|
- /* Call count = 0 implies that all of the shards that need to be
|
|
- * unlinked do not exist. So shard xlator would now proceed to
|
|
- * do the final truncate + size updates.
|
|
- */
|
|
- gf_msg_debug(this->name, 0,
|
|
- "Shards to be unlinked as part of "
|
|
- "truncate absent in backend: %s. Directly "
|
|
- "proceeding to update file size",
|
|
- uuid_utoa(inode->gfid));
|
|
- local->postbuf.ia_size = local->offset;
|
|
- local->postbuf.ia_blocks = local->prebuf.ia_blocks;
|
|
- local->delta_size = local->postbuf.ia_size - local->prebuf.ia_size;
|
|
- GF_ATOMIC_INIT(local->delta_blocks, 0);
|
|
- local->hole_size = 0;
|
|
- shard_update_file_size(frame, this, local->fd, &local->loc,
|
|
- shard_post_update_size_truncate_handler);
|
|
- return 0;
|
|
+ if (wind_failed) {
|
|
+ shard_unlink_shards_do_cbk(frame, (void *)(long)cur_block, this, -1,
|
|
+ ENOMEM, NULL, NULL, NULL);
|
|
+ goto next;
|
|
}
|
|
|
|
- local->call_count = call_count;
|
|
- i = 1;
|
|
- xdata_req = dict_new();
|
|
- if (!xdata_req) {
|
|
- shard_common_failure_unwind(local->fop, frame, -1, ENOMEM);
|
|
- return 0;
|
|
- }
|
|
- ret = dict_set_uint64(xdata_req, GF_GET_FILE_BLOCK_COUNT, 8 * 8);
|
|
- if (ret) {
|
|
- gf_msg(this->name, GF_LOG_WARNING, 0, SHARD_MSG_DICT_OP_FAILED,
|
|
- "Failed to set key %s into dict during truncate of %s",
|
|
- GF_GET_FILE_BLOCK_COUNT,
|
|
- uuid_utoa(local->resolver_base_inode->gfid));
|
|
- dict_unref(xdata_req);
|
|
- shard_common_failure_unwind(local->fop, frame, -1, ENOMEM);
|
|
- return 0;
|
|
+ shard_make_block_abspath(cur_block, gfid, path, sizeof(path));
|
|
+ bname = strrchr(path, '/') + 1;
|
|
+ loc.parent = inode_ref(priv->dot_shard_inode);
|
|
+ ret = inode_path(loc.parent, bname, (char **)&(loc.path));
|
|
+ if (ret < 0) {
|
|
+ gf_msg(this->name, GF_LOG_ERROR, 0, SHARD_MSG_INODE_PATH_FAILED,
|
|
+ "Inode path failed"
|
|
+ " on %s, base file gfid = %s",
|
|
+ bname, uuid_utoa(gfid));
|
|
+ local->op_ret = -1;
|
|
+ local->op_errno = ENOMEM;
|
|
+ loc_wipe(&loc);
|
|
+ wind_failed = _gf_true;
|
|
+ shard_unlink_shards_do_cbk(frame, (void *)(long)cur_block, this, -1,
|
|
+ ENOMEM, NULL, NULL, NULL);
|
|
+ goto next;
|
|
}
|
|
|
|
- SHARD_SET_ROOT_FS_ID(frame, local);
|
|
- while (cur_block <= last_block) {
|
|
- if (!local->inode_list[i]) {
|
|
- cur_block++;
|
|
- i++;
|
|
- continue;
|
|
- }
|
|
- if (wind_failed) {
|
|
- shard_truncate_htol_cbk(frame, (void *)(long)cur_block, this, -1,
|
|
- ENOMEM, NULL, NULL, NULL);
|
|
- goto next;
|
|
- }
|
|
-
|
|
- shard_make_block_abspath(cur_block, inode->gfid, path, sizeof(path));
|
|
- bname = strrchr(path, '/') + 1;
|
|
- loc.parent = inode_ref(priv->dot_shard_inode);
|
|
- ret = inode_path(loc.parent, bname, (char **)&(loc.path));
|
|
- if (ret < 0) {
|
|
- gf_msg(this->name, GF_LOG_ERROR, 0, SHARD_MSG_INODE_PATH_FAILED,
|
|
- "Inode path failed"
|
|
- " on %s. Base file gfid = %s",
|
|
- bname, uuid_utoa(inode->gfid));
|
|
- local->op_ret = -1;
|
|
- local->op_errno = ENOMEM;
|
|
- loc_wipe(&loc);
|
|
- wind_failed = _gf_true;
|
|
- shard_truncate_htol_cbk(frame, (void *)(long)cur_block, this, -1,
|
|
- ENOMEM, NULL, NULL, NULL);
|
|
- goto next;
|
|
- }
|
|
- loc.name = strrchr(loc.path, '/');
|
|
- if (loc.name)
|
|
- loc.name++;
|
|
- loc.inode = inode_ref(local->inode_list[i]);
|
|
-
|
|
- STACK_WIND_COOKIE(frame, shard_truncate_htol_cbk,
|
|
- (void *)(long)cur_block, FIRST_CHILD(this),
|
|
- FIRST_CHILD(this)->fops->unlink, &loc, 0, xdata_req);
|
|
- loc_wipe(&loc);
|
|
- next:
|
|
- i++;
|
|
- cur_block++;
|
|
- if (!--call_count)
|
|
- break;
|
|
- }
|
|
- dict_unref(xdata_req);
|
|
- return 0;
|
|
-}
|
|
+ loc.name = strrchr(loc.path, '/');
|
|
+ if (loc.name)
|
|
+ loc.name++;
|
|
+ loc.inode = inode_ref(local->inode_list[cur_block_idx]);
|
|
|
|
-int
|
|
-shard_truncate_do(call_frame_t *frame, xlator_t *this)
|
|
-{
|
|
- shard_local_t *local = NULL;
|
|
+ STACK_WIND_COOKIE(frame, shard_unlink_shards_do_cbk,
|
|
+ (void *)(long)cur_block, FIRST_CHILD(this),
|
|
+ FIRST_CHILD(this)->fops->unlink, &loc, local->xflag,
|
|
+ local->xattr_req);
|
|
+ loc_wipe(&loc);
|
|
+ next:
|
|
+ cur_block++;
|
|
+ cur_block_idx++;
|
|
+ }
|
|
+ syncbarrier_wait(&local->barrier, count);
|
|
+ SHARD_UNSET_ROOT_FS_ID(frame, local);
|
|
+ return 0;
|
|
+}
|
|
+
|
|
+int shard_regulated_shards_deletion(call_frame_t *cleanup_frame, xlator_t *this,
|
|
+ int now, int first_block,
|
|
+ gf_dirent_t *entry) {
|
|
+ int i = 0;
|
|
+ int ret = 0;
|
|
+ shard_local_t *local = NULL;
|
|
+ uuid_t gfid = {
|
|
+ 0,
|
|
+ };
|
|
+
|
|
+ local = cleanup_frame->local;
|
|
+
|
|
+ local->inode_list = GF_CALLOC(now, sizeof(inode_t *), gf_shard_mt_inode_list);
|
|
+ if (!local->inode_list)
|
|
+ return -ENOMEM;
|
|
+
|
|
+ local->first_block = first_block;
|
|
+ local->last_block = first_block + now - 1;
|
|
+ local->num_blocks = now;
|
|
+ gf_uuid_parse(entry->d_name, gfid);
|
|
+ gf_uuid_copy(local->base_gfid, gfid);
|
|
+ local->resolver_base_inode = inode_find(this->itable, gfid);
|
|
+ local->call_count = 0;
|
|
+ ret = syncbarrier_init(&local->barrier);
|
|
+ if (ret) {
|
|
+ GF_FREE(local->inode_list);
|
|
+ local->inode_list = NULL;
|
|
+ inode_unref(local->resolver_base_inode);
|
|
+ local->resolver_base_inode = NULL;
|
|
+ return -errno;
|
|
+ }
|
|
+ shard_common_resolve_shards(cleanup_frame, this,
|
|
+ shard_post_resolve_unlink_handler);
|
|
+
|
|
+ for (i = 0; i < local->num_blocks; i++) {
|
|
+ if (local->inode_list[i])
|
|
+ inode_unref(local->inode_list[i]);
|
|
+ }
|
|
+ GF_FREE(local->inode_list);
|
|
+ local->inode_list = NULL;
|
|
+ if (local->op_ret)
|
|
+ ret = -local->op_errno;
|
|
+ syncbarrier_destroy(&local->barrier);
|
|
+ inode_unref(local->resolver_base_inode);
|
|
+ local->resolver_base_inode = NULL;
|
|
+ STACK_RESET(cleanup_frame->root);
|
|
+ return ret;
|
|
+}
|
|
+
|
|
+int __shard_delete_shards_of_entry(call_frame_t *cleanup_frame, xlator_t *this,
|
|
+ gf_dirent_t *entry, inode_t *inode) {
|
|
+ int ret = 0;
|
|
+ int shard_count = 0;
|
|
+ int first_block = 0;
|
|
+ int now = 0;
|
|
+ uint64_t size = 0;
|
|
+ uint64_t block_size = 0;
|
|
+ uint64_t size_array[4] = {
|
|
+ 0,
|
|
+ };
|
|
+ void *bsize = NULL;
|
|
+ void *size_attr = NULL;
|
|
+ dict_t *xattr_rsp = NULL;
|
|
+ loc_t loc = {
|
|
+ 0,
|
|
+ };
|
|
+ shard_local_t *local = NULL;
|
|
+ shard_priv_t *priv = NULL;
|
|
+
|
|
+ priv = this->private;
|
|
+ local = cleanup_frame->local;
|
|
+ ret = dict_reset(local->xattr_req);
|
|
+ if (ret) {
|
|
+ gf_msg(this->name, GF_LOG_WARNING, 0, SHARD_MSG_DICT_OP_FAILED,
|
|
+ "Failed to reset dict");
|
|
+ ret = -ENOMEM;
|
|
+ goto err;
|
|
+ }
|
|
+
|
|
+ ret = dict_set_uint64(local->xattr_req, GF_XATTR_SHARD_BLOCK_SIZE, 0);
|
|
+ if (ret) {
|
|
+ gf_msg(this->name, GF_LOG_WARNING, 0, SHARD_MSG_DICT_OP_FAILED,
|
|
+ "Failed to set dict value: key:%s", GF_XATTR_SHARD_BLOCK_SIZE);
|
|
+ ret = -ENOMEM;
|
|
+ goto err;
|
|
+ }
|
|
+
|
|
+ ret = dict_set_uint64(local->xattr_req, GF_XATTR_SHARD_FILE_SIZE, 8 * 4);
|
|
+ if (ret) {
|
|
+ gf_msg(this->name, GF_LOG_WARNING, 0, SHARD_MSG_DICT_OP_FAILED,
|
|
+ "Failed to set dict value: key:%s", GF_XATTR_SHARD_FILE_SIZE);
|
|
+ ret = -ENOMEM;
|
|
+ goto err;
|
|
+ }
|
|
+
|
|
+ loc.inode = inode_ref(inode);
|
|
+ loc.parent = inode_ref(priv->dot_shard_rm_inode);
|
|
+ ret = inode_path(loc.parent, entry->d_name, (char **)&(loc.path));
|
|
+ if (ret < 0) {
|
|
+ gf_msg(this->name, GF_LOG_ERROR, 0, SHARD_MSG_INODE_PATH_FAILED,
|
|
+ "Inode path failed on %s", entry->d_name);
|
|
+ ret = -ENOMEM;
|
|
+ goto err;
|
|
+ }
|
|
+
|
|
+ loc.name = strrchr(loc.path, '/');
|
|
+ if (loc.name)
|
|
+ loc.name++;
|
|
+ ret = syncop_lookup(FIRST_CHILD(this), &loc, NULL, NULL, local->xattr_req,
|
|
+ &xattr_rsp);
|
|
+ if (ret)
|
|
+ goto err;
|
|
+
|
|
+ ret = dict_get_ptr(xattr_rsp, GF_XATTR_SHARD_BLOCK_SIZE, &bsize);
|
|
+ if (ret) {
|
|
+ gf_msg(this->name, GF_LOG_ERROR, 0, SHARD_MSG_DICT_OP_FAILED,
|
|
+ "Failed to get dict value: key:%s", GF_XATTR_SHARD_BLOCK_SIZE);
|
|
+ goto err;
|
|
+ }
|
|
+ block_size = ntoh64(*((uint64_t *)bsize));
|
|
+
|
|
+ ret = dict_get_ptr(xattr_rsp, GF_XATTR_SHARD_FILE_SIZE, &size_attr);
|
|
+ if (ret) {
|
|
+ gf_msg(this->name, GF_LOG_ERROR, 0, SHARD_MSG_DICT_OP_FAILED,
|
|
+ "Failed to get dict value: key:%s", GF_XATTR_SHARD_FILE_SIZE);
|
|
+ goto err;
|
|
+ }
|
|
+
|
|
+ memcpy(size_array, size_attr, sizeof(size_array));
|
|
+ size = ntoh64(size_array[0]);
|
|
+
|
|
+ shard_count = (size / block_size) - 1;
|
|
+ if (shard_count < 0) {
|
|
+ gf_msg_debug(this->name, 0, "Size of %s hasn't grown beyond "
|
|
+ "its shard-block-size. Nothing to delete. "
|
|
+ "Returning",
|
|
+ entry->d_name);
|
|
+ /* File size < shard-block-size, so nothing to delete */
|
|
+ ret = 0;
|
|
+ goto delete_marker;
|
|
+ }
|
|
+ if ((size % block_size) > 0)
|
|
+ shard_count++;
|
|
+
|
|
+ if (shard_count == 0) {
|
|
+ gf_msg_debug(this->name, 0, "Size of %s is exactly equal to "
|
|
+ "its shard-block-size. Nothing to delete. "
|
|
+ "Returning",
|
|
+ entry->d_name);
|
|
+ ret = 0;
|
|
+ goto delete_marker;
|
|
+ }
|
|
+ gf_msg_debug(this->name, 0,
|
|
+ "base file = %s, "
|
|
+ "shard-block-size=%" PRIu64 ", file-size=%" PRIu64 ", "
|
|
+ "shard_count=%d",
|
|
+ entry->d_name, block_size, size, shard_count);
|
|
+
|
|
+ /* Perform a gfid-based lookup to see if gfid corresponding to marker
|
|
+ * file's base name exists.
|
|
+ */
|
|
+ loc_wipe(&loc);
|
|
+ loc.inode = inode_new(this->itable);
|
|
+ if (!loc.inode) {
|
|
+ ret = -ENOMEM;
|
|
+ goto err;
|
|
+ }
|
|
+ gf_uuid_parse(entry->d_name, loc.gfid);
|
|
+ ret = syncop_lookup(FIRST_CHILD(this), &loc, NULL, NULL, NULL, NULL);
|
|
+ if (!ret) {
|
|
+ gf_msg_debug(this->name, 0, "Base shard corresponding to gfid "
|
|
+ "%s is present. Skipping shard deletion. "
|
|
+ "Returning",
|
|
+ entry->d_name);
|
|
+ ret = 0;
|
|
+ goto delete_marker;
|
|
+ }
|
|
|
|
- local = frame->local;
|
|
+ first_block = 1;
|
|
|
|
- if (local->num_blocks == 1) {
|
|
- /* This means that there are no shards to be unlinked.
|
|
- * The fop boils down to truncating the last shard, updating
|
|
- * the size and unwinding.
|
|
- */
|
|
- shard_truncate_last_shard(frame, this, local->inode_list[0]);
|
|
- return 0;
|
|
+ while (shard_count) {
|
|
+ if (shard_count < local->deletion_rate) {
|
|
+ now = shard_count;
|
|
+ shard_count = 0;
|
|
} else {
|
|
- shard_truncate_htol(frame, this, local->loc.inode);
|
|
- }
|
|
- return 0;
|
|
-}
|
|
-
|
|
-int
|
|
-shard_post_lookup_shards_truncate_handler(call_frame_t *frame, xlator_t *this)
|
|
-{
|
|
- shard_local_t *local = NULL;
|
|
-
|
|
- local = frame->local;
|
|
-
|
|
- if (local->op_ret < 0) {
|
|
- shard_common_failure_unwind(local->fop, frame, local->op_ret,
|
|
- local->op_errno);
|
|
- return 0;
|
|
+ now = local->deletion_rate;
|
|
+ shard_count -= local->deletion_rate;
|
|
}
|
|
|
|
- shard_truncate_do(frame, this);
|
|
- return 0;
|
|
-}
|
|
+ gf_msg_debug(this->name, 0, "deleting %d shards starting from "
|
|
+ "block %d of gfid %s",
|
|
+ now, first_block, entry->d_name);
|
|
+ ret = shard_regulated_shards_deletion(cleanup_frame, this, now, first_block,
|
|
+ entry);
|
|
+ if (ret)
|
|
+ goto err;
|
|
+ first_block += now;
|
|
+ }
|
|
|
|
-void
|
|
-shard_link_block_inode(shard_local_t *local, int block_num, inode_t *inode,
|
|
- struct iatt *buf)
|
|
-{
|
|
- int list_index = 0;
|
|
- char block_bname[256] = {
|
|
- 0,
|
|
- };
|
|
- uuid_t gfid = {
|
|
- 0,
|
|
- };
|
|
- inode_t *linked_inode = NULL;
|
|
- xlator_t *this = NULL;
|
|
- inode_t *fsync_inode = NULL;
|
|
- shard_priv_t *priv = NULL;
|
|
- inode_t *base_inode = NULL;
|
|
-
|
|
- this = THIS;
|
|
- priv = this->private;
|
|
- if (local->loc.inode) {
|
|
- gf_uuid_copy(gfid, local->loc.inode->gfid);
|
|
- base_inode = local->loc.inode;
|
|
- } else if (local->resolver_base_inode) {
|
|
- gf_uuid_copy(gfid, local->resolver_base_inode->gfid);
|
|
- base_inode = local->resolver_base_inode;
|
|
+delete_marker:
|
|
+ loc_wipe(&loc);
|
|
+ loc.inode = inode_ref(inode);
|
|
+ loc.parent = inode_ref(priv->dot_shard_rm_inode);
|
|
+ ret = inode_path(loc.parent, entry->d_name, (char **)&(loc.path));
|
|
+ if (ret < 0) {
|
|
+ gf_msg(this->name, GF_LOG_ERROR, 0, SHARD_MSG_INODE_PATH_FAILED,
|
|
+ "Inode path failed on %s", entry->d_name);
|
|
+ ret = -ENOMEM;
|
|
+ goto err;
|
|
+ }
|
|
+ loc.name = strrchr(loc.path, '/');
|
|
+ if (loc.name)
|
|
+ loc.name++;
|
|
+ ret = syncop_unlink(FIRST_CHILD(this), &loc, NULL, NULL);
|
|
+ if (ret)
|
|
+ gf_msg(this->name, GF_LOG_ERROR, 0, SHARD_MSG_SHARDS_DELETION_FAILED,
|
|
+ "Failed to delete %s "
|
|
+ "from /%s",
|
|
+ entry->d_name, GF_SHARD_REMOVE_ME_DIR);
|
|
+err:
|
|
+ if (xattr_rsp)
|
|
+ dict_unref(xattr_rsp);
|
|
+ loc_wipe(&loc);
|
|
+ return ret;
|
|
+}
|
|
+
|
|
+int shard_delete_shards_of_entry(call_frame_t *cleanup_frame, xlator_t *this,
|
|
+ gf_dirent_t *entry, inode_t *inode) {
|
|
+ int ret = -1;
|
|
+ loc_t loc = {
|
|
+ 0,
|
|
+ };
|
|
+ shard_priv_t *priv = NULL;
|
|
+
|
|
+ priv = this->private;
|
|
+ loc.inode = inode_ref(priv->dot_shard_rm_inode);
|
|
+
|
|
+ ret = syncop_entrylk(FIRST_CHILD(this), this->name, &loc, entry->d_name,
|
|
+ ENTRYLK_LOCK_NB, ENTRYLK_WRLCK, NULL, NULL);
|
|
+ if (ret < 0) {
|
|
+ if (ret == -EAGAIN) {
|
|
+ ret = 0;
|
|
+ }
|
|
+ goto out;
|
|
+ }
|
|
+ { ret = __shard_delete_shards_of_entry(cleanup_frame, this, entry, inode); }
|
|
+ syncop_entrylk(FIRST_CHILD(this), this->name, &loc, entry->d_name,
|
|
+ ENTRYLK_UNLOCK, ENTRYLK_WRLCK, NULL, NULL);
|
|
+out:
|
|
+ loc_wipe(&loc);
|
|
+ return ret;
|
|
+}
|
|
+
|
|
+int shard_delete_shards_cbk(int ret, call_frame_t *frame, void *data) {
|
|
+ SHARD_STACK_DESTROY(frame);
|
|
+ return 0;
|
|
+}
|
|
+
|
|
+int shard_resolve_internal_dir(xlator_t *this, shard_local_t *local,
|
|
+ shard_internal_dir_type_t type) {
|
|
+ int ret = 0;
|
|
+ char *bname = NULL;
|
|
+ loc_t *loc = NULL;
|
|
+ shard_priv_t *priv = NULL;
|
|
+ uuid_t gfid = {
|
|
+ 0,
|
|
+ };
|
|
+ struct iatt stbuf = {
|
|
+ 0,
|
|
+ };
|
|
+
|
|
+ priv = this->private;
|
|
+
|
|
+ switch (type) {
|
|
+ case SHARD_INTERNAL_DIR_DOT_SHARD:
|
|
+ loc = &local->dot_shard_loc;
|
|
+ gf_uuid_copy(gfid, priv->dot_shard_gfid);
|
|
+ bname = GF_SHARD_DIR;
|
|
+ break;
|
|
+ case SHARD_INTERNAL_DIR_DOT_SHARD_REMOVE_ME:
|
|
+ loc = &local->dot_shard_rm_loc;
|
|
+ gf_uuid_copy(gfid, priv->dot_shard_rm_gfid);
|
|
+ bname = GF_SHARD_REMOVE_ME_DIR;
|
|
+ break;
|
|
+ default:
|
|
+ break;
|
|
+ }
|
|
+
|
|
+ loc->inode = inode_find(this->itable, gfid);
|
|
+ if (!loc->inode) {
|
|
+ ret = shard_init_internal_dir_loc(this, local, type);
|
|
+ if (ret)
|
|
+ goto err;
|
|
+ ret = dict_reset(local->xattr_req);
|
|
+ if (ret) {
|
|
+ gf_msg(this->name, GF_LOG_WARNING, 0, SHARD_MSG_DICT_OP_FAILED,
|
|
+ "Failed to reset "
|
|
+ "dict");
|
|
+ ret = -ENOMEM;
|
|
+ goto err;
|
|
+ }
|
|
+ ret = dict_set_gfuuid(local->xattr_req, "gfid-req", gfid, true);
|
|
+ ret = syncop_lookup(FIRST_CHILD(this), loc, &stbuf, NULL, local->xattr_req,
|
|
+ NULL);
|
|
+ if (ret < 0) {
|
|
+ if (ret != -ENOENT)
|
|
+ gf_msg(this->name, GF_LOG_ERROR, -ret, SHARD_MSG_SHARDS_DELETION_FAILED,
|
|
+ "Lookup on %s failed, exiting", bname);
|
|
+ goto err;
|
|
} else {
|
|
- gf_uuid_copy(gfid, local->base_gfid);
|
|
+ shard_link_internal_dir_inode(local, loc->inode, &stbuf, type);
|
|
}
|
|
+ }
|
|
+ ret = 0;
|
|
+err:
|
|
+ return ret;
|
|
+}
|
|
+
|
|
+int shard_lookup_marker_entry(xlator_t *this, shard_local_t *local,
|
|
+ gf_dirent_t *entry) {
|
|
+ int ret = 0;
|
|
+ loc_t loc = {
|
|
+ 0,
|
|
+ };
|
|
+
|
|
+ loc.inode = inode_new(this->itable);
|
|
+ if (!loc.inode) {
|
|
+ ret = -ENOMEM;
|
|
+ goto err;
|
|
+ }
|
|
+ loc.parent = inode_ref(local->fd->inode);
|
|
+
|
|
+ ret = inode_path(loc.parent, entry->d_name, (char **)&(loc.path));
|
|
+ if (ret < 0) {
|
|
+ gf_msg(this->name, GF_LOG_ERROR, 0, SHARD_MSG_INODE_PATH_FAILED,
|
|
+ "Inode path failed on %s", entry->d_name);
|
|
+ ret = -ENOMEM;
|
|
+ goto err;
|
|
+ }
|
|
+
|
|
+ loc.name = strrchr(loc.path, '/');
|
|
+ if (loc.name)
|
|
+ loc.name++;
|
|
+
|
|
+ ret = syncop_lookup(FIRST_CHILD(this), &loc, NULL, NULL, NULL, NULL);
|
|
+ if (ret < 0) {
|
|
+ goto err;
|
|
+ }
|
|
+ entry->inode = inode_ref(loc.inode);
|
|
+ ret = 0;
|
|
+err:
|
|
+ loc_wipe(&loc);
|
|
+ return ret;
|
|
+}
|
|
+
|
|
+int shard_delete_shards(void *opaque) {
|
|
+ int ret = 0;
|
|
+ off_t offset = 0;
|
|
+ loc_t loc = {
|
|
+ 0,
|
|
+ };
|
|
+ inode_t *link_inode = NULL;
|
|
+ xlator_t *this = NULL;
|
|
+ shard_priv_t *priv = NULL;
|
|
+ shard_local_t *local = NULL;
|
|
+ gf_dirent_t entries;
|
|
+ gf_dirent_t *entry = NULL;
|
|
+ call_frame_t *cleanup_frame = NULL;
|
|
+ gf_boolean_t done = _gf_false;
|
|
+
|
|
+ this = THIS;
|
|
+ priv = this->private;
|
|
+ INIT_LIST_HEAD(&entries.list);
|
|
+
|
|
+ cleanup_frame = opaque;
|
|
+
|
|
+ local = mem_get0(this->local_pool);
|
|
+ if (!local) {
|
|
+ gf_msg(this->name, GF_LOG_WARNING, ENOMEM, SHARD_MSG_MEMALLOC_FAILED,
|
|
+ "Failed to create local to "
|
|
+ "delete shards");
|
|
+ ret = -ENOMEM;
|
|
+ goto err;
|
|
+ }
|
|
+ cleanup_frame->local = local;
|
|
+ local->fop = GF_FOP_UNLINK;
|
|
+
|
|
+ local->xattr_req = dict_new();
|
|
+ if (!local->xattr_req) {
|
|
+ ret = -ENOMEM;
|
|
+ goto err;
|
|
+ }
|
|
+ local->deletion_rate = priv->deletion_rate;
|
|
+
|
|
+ ret = shard_resolve_internal_dir(this, local, SHARD_INTERNAL_DIR_DOT_SHARD);
|
|
+ if (ret == -ENOENT) {
|
|
+ gf_msg_debug(this->name, 0, ".shard absent. Nothing to"
|
|
+ " delete. Exiting");
|
|
+ ret = 0;
|
|
+ goto err;
|
|
+ } else if (ret < 0) {
|
|
+ goto err;
|
|
+ }
|
|
|
|
- shard_make_block_bname(block_num, gfid, block_bname, sizeof(block_bname));
|
|
-
|
|
- shard_inode_ctx_set(inode, this, buf, 0, SHARD_LOOKUP_MASK);
|
|
- linked_inode = inode_link(inode, priv->dot_shard_inode, block_bname, buf);
|
|
- inode_lookup(linked_inode);
|
|
- list_index = block_num - local->first_block;
|
|
- local->inode_list[list_index] = linked_inode;
|
|
-
|
|
+ ret = shard_resolve_internal_dir(this, local,
|
|
+ SHARD_INTERNAL_DIR_DOT_SHARD_REMOVE_ME);
|
|
+ if (ret == -ENOENT) {
|
|
+ gf_msg_debug(this->name, 0, ".remove_me absent. "
|
|
+ "Nothing to delete. Exiting");
|
|
+ ret = 0;
|
|
+ goto err;
|
|
+ } else if (ret < 0) {
|
|
+ goto err;
|
|
+ }
|
|
+
|
|
+ local->fd = fd_anonymous(local->dot_shard_rm_loc.inode);
|
|
+ if (!local->fd) {
|
|
+ ret = -ENOMEM;
|
|
+ goto err;
|
|
+ }
|
|
+
|
|
+ for (;;) {
|
|
+ offset = 0;
|
|
LOCK(&priv->lock);
|
|
{
|
|
- fsync_inode = __shard_update_shards_inode_list(
|
|
- linked_inode, this, base_inode, block_num, gfid);
|
|
+ if (priv->bg_del_state == SHARD_BG_DELETION_LAUNCHING) {
|
|
+ priv->bg_del_state = SHARD_BG_DELETION_IN_PROGRESS;
|
|
+ } else if (priv->bg_del_state == SHARD_BG_DELETION_IN_PROGRESS) {
|
|
+ priv->bg_del_state = SHARD_BG_DELETION_NONE;
|
|
+ done = _gf_true;
|
|
+ }
|
|
}
|
|
UNLOCK(&priv->lock);
|
|
- if (fsync_inode)
|
|
- shard_initiate_evicted_inode_fsync(this, fsync_inode);
|
|
-}
|
|
-
|
|
-int
|
|
-shard_common_lookup_shards_cbk(call_frame_t *frame, void *cookie,
|
|
- xlator_t *this, int32_t op_ret, int32_t op_errno,
|
|
- inode_t *inode, struct iatt *buf, dict_t *xdata,
|
|
- struct iatt *postparent)
|
|
-{
|
|
- int call_count = 0;
|
|
- int shard_block_num = (long)cookie;
|
|
- uuid_t gfid = {
|
|
- 0,
|
|
- };
|
|
- shard_local_t *local = NULL;
|
|
-
|
|
- local = frame->local;
|
|
- if (local->resolver_base_inode)
|
|
- gf_uuid_copy(gfid, local->resolver_base_inode->gfid);
|
|
- else
|
|
- gf_uuid_copy(gfid, local->base_gfid);
|
|
-
|
|
- if (op_ret < 0) {
|
|
- /* Ignore absence of shards in the backend in truncate fop. */
|
|
- switch (local->fop) {
|
|
- case GF_FOP_TRUNCATE:
|
|
- case GF_FOP_FTRUNCATE:
|
|
- case GF_FOP_RENAME:
|
|
- case GF_FOP_UNLINK:
|
|
- if (op_errno == ENOENT)
|
|
- goto done;
|
|
- break;
|
|
- case GF_FOP_WRITE:
|
|
- case GF_FOP_READ:
|
|
- case GF_FOP_ZEROFILL:
|
|
- case GF_FOP_DISCARD:
|
|
- case GF_FOP_FALLOCATE:
|
|
- if ((!local->first_lookup_done) && (op_errno == ENOENT)) {
|
|
- LOCK(&frame->lock);
|
|
- {
|
|
- local->create_count++;
|
|
- }
|
|
- UNLOCK(&frame->lock);
|
|
- goto done;
|
|
- }
|
|
- break;
|
|
- default:
|
|
- break;
|
|
- }
|
|
-
|
|
- /* else */
|
|
- gf_msg(this->name, GF_LOG_ERROR, op_errno,
|
|
- SHARD_MSG_LOOKUP_SHARD_FAILED,
|
|
- "Lookup on shard %d "
|
|
- "failed. Base file gfid = %s",
|
|
- shard_block_num, uuid_utoa(gfid));
|
|
- local->op_ret = op_ret;
|
|
- local->op_errno = op_errno;
|
|
- goto done;
|
|
- }
|
|
-
|
|
- shard_link_block_inode(local, shard_block_num, inode, buf);
|
|
-
|
|
-done:
|
|
- if (local->lookup_shards_barriered) {
|
|
- syncbarrier_wake(&local->barrier);
|
|
- return 0;
|
|
- } else {
|
|
- call_count = shard_call_count_return(frame);
|
|
- if (call_count == 0) {
|
|
- if (!local->first_lookup_done)
|
|
- local->first_lookup_done = _gf_true;
|
|
- local->pls_fop_handler(frame, this);
|
|
- }
|
|
- }
|
|
- return 0;
|
|
-}
|
|
-
|
|
-dict_t *
|
|
-shard_create_gfid_dict(dict_t *dict)
|
|
-{
|
|
- int ret = 0;
|
|
- dict_t *new = NULL;
|
|
- unsigned char *gfid = NULL;
|
|
-
|
|
- new = dict_copy_with_ref(dict, NULL);
|
|
- if (!new)
|
|
- return NULL;
|
|
-
|
|
- gfid = GF_MALLOC(sizeof(uuid_t), gf_common_mt_char);
|
|
- if (!gfid) {
|
|
- ret = -1;
|
|
- goto out;
|
|
- }
|
|
-
|
|
- gf_uuid_generate(gfid);
|
|
-
|
|
- ret = dict_set_gfuuid(new, "gfid-req", gfid, false);
|
|
-
|
|
-out:
|
|
- if (ret) {
|
|
- dict_unref(new);
|
|
- new = NULL;
|
|
- GF_FREE(gfid);
|
|
- }
|
|
-
|
|
- return new;
|
|
-}
|
|
+ if (done)
|
|
+ break;
|
|
+ while ((ret = syncop_readdirp(FIRST_CHILD(this), local->fd, 131072, offset,
|
|
+ &entries, local->xattr_req, NULL))) {
|
|
+ if (ret > 0)
|
|
+ ret = 0;
|
|
+ list_for_each_entry(entry, &entries.list, list) {
|
|
+ offset = entry->d_off;
|
|
|
|
-int
|
|
-shard_common_lookup_shards(call_frame_t *frame, xlator_t *this, inode_t *inode,
|
|
- shard_post_lookup_shards_fop_handler_t handler)
|
|
-{
|
|
- int i = 0;
|
|
- int ret = 0;
|
|
- int count = 0;
|
|
- int call_count = 0;
|
|
- int32_t shard_idx_iter = 0;
|
|
- int last_block = 0;
|
|
- char path[PATH_MAX] = {
|
|
- 0,
|
|
- };
|
|
- char *bname = NULL;
|
|
- uuid_t gfid = {
|
|
- 0,
|
|
- };
|
|
- loc_t loc = {
|
|
- 0,
|
|
- };
|
|
- shard_local_t *local = NULL;
|
|
- shard_priv_t *priv = NULL;
|
|
- gf_boolean_t wind_failed = _gf_false;
|
|
- dict_t *xattr_req = NULL;
|
|
-
|
|
- priv = this->private;
|
|
- local = frame->local;
|
|
- count = call_count = local->call_count;
|
|
- shard_idx_iter = local->first_block;
|
|
- last_block = local->last_block;
|
|
- local->pls_fop_handler = handler;
|
|
- if (local->lookup_shards_barriered)
|
|
- local->barrier.waitfor = local->call_count;
|
|
-
|
|
- if (inode)
|
|
- gf_uuid_copy(gfid, inode->gfid);
|
|
- else
|
|
- gf_uuid_copy(gfid, local->base_gfid);
|
|
+ if (!strcmp(entry->d_name, ".") || !strcmp(entry->d_name, ".."))
|
|
+ continue;
|
|
|
|
- while (shard_idx_iter <= last_block) {
|
|
- if (local->inode_list[i]) {
|
|
- i++;
|
|
- shard_idx_iter++;
|
|
+ if (!entry->inode) {
|
|
+ ret = shard_lookup_marker_entry(this, local, entry);
|
|
+ if (ret < 0)
|
|
continue;
|
|
}
|
|
+ link_inode = inode_link(entry->inode, local->fd->inode, entry->d_name,
|
|
+ &entry->d_stat);
|
|
|
|
- if (wind_failed) {
|
|
- shard_common_lookup_shards_cbk(frame, (void *)(long)shard_idx_iter,
|
|
- this, -1, ENOMEM, NULL, NULL, NULL,
|
|
- NULL);
|
|
- goto next;
|
|
- }
|
|
-
|
|
- shard_make_block_abspath(shard_idx_iter, gfid, path, sizeof(path));
|
|
-
|
|
- bname = strrchr(path, '/') + 1;
|
|
- loc.inode = inode_new(this->itable);
|
|
- loc.parent = inode_ref(priv->dot_shard_inode);
|
|
- gf_uuid_copy(loc.pargfid, priv->dot_shard_gfid);
|
|
- ret = inode_path(loc.parent, bname, (char **)&(loc.path));
|
|
- if (ret < 0 || !(loc.inode)) {
|
|
- gf_msg(this->name, GF_LOG_ERROR, 0, SHARD_MSG_INODE_PATH_FAILED,
|
|
- "Inode path failed"
|
|
- " on %s, base file gfid = %s",
|
|
- bname, uuid_utoa(gfid));
|
|
- local->op_ret = -1;
|
|
- local->op_errno = ENOMEM;
|
|
- loc_wipe(&loc);
|
|
- wind_failed = _gf_true;
|
|
- shard_common_lookup_shards_cbk(frame, (void *)(long)shard_idx_iter,
|
|
- this, -1, ENOMEM, NULL, NULL, NULL,
|
|
- NULL);
|
|
- goto next;
|
|
- }
|
|
-
|
|
- loc.name = strrchr(loc.path, '/');
|
|
- if (loc.name)
|
|
- loc.name++;
|
|
-
|
|
- xattr_req = shard_create_gfid_dict(local->xattr_req);
|
|
- if (!xattr_req) {
|
|
- local->op_ret = -1;
|
|
- local->op_errno = ENOMEM;
|
|
- wind_failed = _gf_true;
|
|
- loc_wipe(&loc);
|
|
- shard_common_lookup_shards_cbk(frame, (void *)(long)shard_idx_iter,
|
|
- this, -1, ENOMEM, NULL, NULL, NULL,
|
|
- NULL);
|
|
- goto next;
|
|
+ gf_msg_debug(this->name, 0, "Initiating deletion of "
|
|
+ "shards of gfid %s",
|
|
+ entry->d_name);
|
|
+ ret = shard_delete_shards_of_entry(cleanup_frame, this, entry,
|
|
+ link_inode);
|
|
+ inode_unlink(link_inode, local->fd->inode, entry->d_name);
|
|
+ inode_unref(link_inode);
|
|
+ if (ret) {
|
|
+ gf_msg(this->name, GF_LOG_ERROR, -ret,
|
|
+ SHARD_MSG_SHARDS_DELETION_FAILED,
|
|
+ "Failed to clean up shards of gfid %s", entry->d_name);
|
|
+ continue;
|
|
}
|
|
+ gf_msg(this->name, GF_LOG_INFO, 0, SHARD_MSG_SHARD_DELETION_COMPLETED,
|
|
+ "Deleted "
|
|
+ "shards of gfid=%s from backend",
|
|
+ entry->d_name);
|
|
+ }
|
|
+ gf_dirent_free(&entries);
|
|
+ if (ret)
|
|
+ break;
|
|
+ }
|
|
+ }
|
|
+ ret = 0;
|
|
+ loc_wipe(&loc);
|
|
+ return ret;
|
|
|
|
- STACK_WIND_COOKIE(frame, shard_common_lookup_shards_cbk,
|
|
- (void *)(long)shard_idx_iter, FIRST_CHILD(this),
|
|
- FIRST_CHILD(this)->fops->lookup, &loc, xattr_req);
|
|
- loc_wipe(&loc);
|
|
- dict_unref(xattr_req);
|
|
- next:
|
|
- shard_idx_iter++;
|
|
- i++;
|
|
-
|
|
- if (!--call_count)
|
|
- break;
|
|
- }
|
|
- if (local->lookup_shards_barriered) {
|
|
- syncbarrier_wait(&local->barrier, count);
|
|
- local->pls_fop_handler(frame, this);
|
|
- }
|
|
- return 0;
|
|
+err:
|
|
+ LOCK(&priv->lock);
|
|
+ { priv->bg_del_state = SHARD_BG_DELETION_NONE; }
|
|
+ UNLOCK(&priv->lock);
|
|
+ loc_wipe(&loc);
|
|
+ return ret;
|
|
+}
|
|
+
|
|
+int shard_unlock_inodelk_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
|
|
+ int32_t op_ret, int32_t op_errno, dict_t *xdata) {
|
|
+ if (op_ret)
|
|
+ gf_msg(this->name, GF_LOG_ERROR, op_errno, SHARD_MSG_FOP_FAILED,
|
|
+ "Unlock failed. Please check brick logs for "
|
|
+ "more details");
|
|
+ SHARD_STACK_DESTROY(frame);
|
|
+ return 0;
|
|
+}
|
|
+
|
|
+int shard_unlock_inodelk(call_frame_t *frame, xlator_t *this) {
|
|
+ loc_t *loc = NULL;
|
|
+ call_frame_t *lk_frame = NULL;
|
|
+ shard_local_t *local = NULL;
|
|
+ shard_local_t *lk_local = NULL;
|
|
+ shard_inodelk_t *lock = NULL;
|
|
+
|
|
+ local = frame->local;
|
|
+ lk_frame = local->inodelk_frame;
|
|
+ lk_local = lk_frame->local;
|
|
+ local->inodelk_frame = NULL;
|
|
+ loc = &local->int_inodelk.loc;
|
|
+ lock = &lk_local->int_inodelk;
|
|
+ lock->flock.l_type = F_UNLCK;
|
|
+
|
|
+ STACK_WIND(lk_frame, shard_unlock_inodelk_cbk, FIRST_CHILD(this),
|
|
+ FIRST_CHILD(this)->fops->inodelk, lock->domain, loc, F_SETLK,
|
|
+ &lock->flock, NULL);
|
|
+ local->int_inodelk.acquired_lock = _gf_false;
|
|
+ return 0;
|
|
+}
|
|
+
|
|
+int shard_rename_src_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
|
|
+ int32_t op_ret, int32_t op_errno, struct iatt *buf,
|
|
+ struct iatt *preoldparent, struct iatt *postoldparent,
|
|
+ struct iatt *prenewparent, struct iatt *postnewparent,
|
|
+ dict_t *xdata);
|
|
+int shard_rename_src_base_file(call_frame_t *frame, xlator_t *this) {
|
|
+ int ret = 0;
|
|
+ loc_t *dst_loc = NULL;
|
|
+ loc_t tmp_loc = {
|
|
+ 0,
|
|
+ };
|
|
+ shard_local_t *local = frame->local;
|
|
+
|
|
+ if (local->dst_block_size) {
|
|
+ tmp_loc.parent = inode_ref(local->loc2.parent);
|
|
+ ret = inode_path(tmp_loc.parent, local->loc2.name, (char **)&tmp_loc.path);
|
|
+ if (ret < 0) {
|
|
+ gf_msg(this->name, GF_LOG_ERROR, 0, SHARD_MSG_INODE_PATH_FAILED,
|
|
+ "Inode path failed"
|
|
+ " on pargfid=%s bname=%s",
|
|
+ uuid_utoa(tmp_loc.parent->gfid), local->loc2.name);
|
|
+ local->op_ret = -1;
|
|
+ local->op_errno = ENOMEM;
|
|
+ goto err;
|
|
+ }
|
|
+
|
|
+ tmp_loc.name = strrchr(tmp_loc.path, '/');
|
|
+ if (tmp_loc.name)
|
|
+ tmp_loc.name++;
|
|
+ dst_loc = &tmp_loc;
|
|
+ } else {
|
|
+ dst_loc = &local->loc2;
|
|
+ }
|
|
+
|
|
+ /* To-Do: Request open-fd count on dst base file */
|
|
+ STACK_WIND(frame, shard_rename_src_cbk, FIRST_CHILD(this),
|
|
+ FIRST_CHILD(this)->fops->rename, &local->loc, dst_loc,
|
|
+ local->xattr_req);
|
|
+ loc_wipe(&tmp_loc);
|
|
+ return 0;
|
|
+err:
|
|
+ loc_wipe(&tmp_loc);
|
|
+ shard_common_failure_unwind(local->fop, frame, local->op_ret,
|
|
+ local->op_errno);
|
|
+ return 0;
|
|
+}
|
|
+
|
|
+int shard_unlink_base_file(call_frame_t *frame, xlator_t *this);
|
|
+
|
|
+int shard_set_size_attrs_on_marker_file_cbk(call_frame_t *frame, void *cookie,
|
|
+ xlator_t *this, int32_t op_ret,
|
|
+ int32_t op_errno, dict_t *dict,
|
|
+ dict_t *xdata) {
|
|
+ shard_priv_t *priv = NULL;
|
|
+ shard_local_t *local = NULL;
|
|
+
|
|
+ priv = this->private;
|
|
+ local = frame->local;
|
|
+ if (op_ret < 0) {
|
|
+ gf_msg(this->name, GF_LOG_ERROR, op_errno, SHARD_MSG_FOP_FAILED,
|
|
+ "Xattrop on marker file failed "
|
|
+ "while performing %s; entry gfid=%s",
|
|
+ gf_fop_string(local->fop), local->newloc.name);
|
|
+ goto err;
|
|
+ }
|
|
+
|
|
+ inode_unlink(local->newloc.inode, priv->dot_shard_rm_inode,
|
|
+ local->newloc.name);
|
|
+
|
|
+ if (local->fop == GF_FOP_UNLINK)
|
|
+ shard_unlink_base_file(frame, this);
|
|
+ else if (local->fop == GF_FOP_RENAME)
|
|
+ shard_rename_src_base_file(frame, this);
|
|
+ return 0;
|
|
+err:
|
|
+ shard_common_failure_unwind(local->fop, frame, op_ret, op_errno);
|
|
+ return 0;
|
|
+}
|
|
+
|
|
+int shard_set_size_attrs_on_marker_file(call_frame_t *frame, xlator_t *this) {
|
|
+ int op_errno = ENOMEM;
|
|
+ uint64_t bs = 0;
|
|
+ dict_t *xdata = NULL;
|
|
+ shard_local_t *local = NULL;
|
|
+
|
|
+ local = frame->local;
|
|
+ xdata = dict_new();
|
|
+ if (!xdata)
|
|
+ goto err;
|
|
+
|
|
+ if (local->fop == GF_FOP_UNLINK)
|
|
+ bs = local->block_size;
|
|
+ else if (local->fop == GF_FOP_RENAME)
|
|
+ bs = local->dst_block_size;
|
|
+ SHARD_INODE_CREATE_INIT(this, bs, xdata, &local->newloc,
|
|
+ local->prebuf.ia_size, 0, err);
|
|
+ STACK_WIND(frame, shard_set_size_attrs_on_marker_file_cbk, FIRST_CHILD(this),
|
|
+ FIRST_CHILD(this)->fops->xattrop, &local->newloc,
|
|
+ GF_XATTROP_GET_AND_SET, xdata, NULL);
|
|
+ dict_unref(xdata);
|
|
+ return 0;
|
|
+err:
|
|
+ if (xdata)
|
|
+ dict_unref(xdata);
|
|
+ shard_common_failure_unwind(local->fop, frame, -1, op_errno);
|
|
+ return 0;
|
|
}
|
|
|
|
-int
|
|
-shard_post_resolve_truncate_handler(call_frame_t *frame, xlator_t *this)
|
|
-{
|
|
- shard_local_t *local = NULL;
|
|
-
|
|
- local = frame->local;
|
|
-
|
|
- if (local->op_ret < 0) {
|
|
- if (local->op_errno == ENOENT) {
|
|
- /* If lookup on /.shard fails with ENOENT, it means that
|
|
- * the file was 0-byte in size but truncated sometime in
|
|
- * the past to a higher size which is reflected in the
|
|
- * size xattr, and now being truncated to a lower size.
|
|
- * In this case, the only thing that needs to be done is
|
|
- * to update the size xattr of the file and unwind.
|
|
- */
|
|
- local->first_block = local->last_block = 0;
|
|
- local->num_blocks = 1;
|
|
- local->call_count = 0;
|
|
- local->op_ret = 0;
|
|
- local->postbuf.ia_size = local->offset;
|
|
- shard_update_file_size(frame, this, local->fd, &local->loc,
|
|
- shard_post_update_size_truncate_handler);
|
|
- return 0;
|
|
- } else {
|
|
- shard_common_failure_unwind(local->fop, frame, local->op_ret,
|
|
- local->op_errno);
|
|
- return 0;
|
|
- }
|
|
- }
|
|
-
|
|
- if (!local->call_count)
|
|
- shard_truncate_do(frame, this);
|
|
- else
|
|
- shard_common_lookup_shards(frame, this, local->loc.inode,
|
|
- shard_post_lookup_shards_truncate_handler);
|
|
-
|
|
- return 0;
|
|
+int shard_lookup_marker_file_cbk(call_frame_t *frame, void *cookie,
|
|
+ xlator_t *this, int32_t op_ret,
|
|
+ int32_t op_errno, inode_t *inode,
|
|
+ struct iatt *buf, dict_t *xdata,
|
|
+ struct iatt *postparent) {
|
|
+ inode_t *linked_inode = NULL;
|
|
+ shard_priv_t *priv = NULL;
|
|
+ shard_local_t *local = NULL;
|
|
+
|
|
+ local = frame->local;
|
|
+ priv = this->private;
|
|
+
|
|
+ if (op_ret < 0) {
|
|
+ gf_msg(this->name, GF_LOG_ERROR, op_errno, SHARD_MSG_FOP_FAILED,
|
|
+ "Lookup on marker file failed "
|
|
+ "while performing %s; entry gfid=%s",
|
|
+ gf_fop_string(local->fop), local->newloc.name);
|
|
+ goto err;
|
|
+ }
|
|
+
|
|
+ linked_inode =
|
|
+ inode_link(inode, priv->dot_shard_rm_inode, local->newloc.name, buf);
|
|
+ inode_unref(local->newloc.inode);
|
|
+ local->newloc.inode = linked_inode;
|
|
+ shard_set_size_attrs_on_marker_file(frame, this);
|
|
+ return 0;
|
|
+err:
|
|
+ shard_common_failure_unwind(local->fop, frame, op_ret, op_errno);
|
|
+ return 0;
|
|
}
|
|
|
|
-int
|
|
-shard_truncate_begin(call_frame_t *frame, xlator_t *this)
|
|
-{
|
|
- int ret = 0;
|
|
- shard_local_t *local = NULL;
|
|
- shard_priv_t *priv = NULL;
|
|
-
|
|
- priv = this->private;
|
|
- local = frame->local;
|
|
-
|
|
- /* First participant block here is the lowest numbered block that would
|
|
- * hold the last byte of the file post successful truncation.
|
|
- * Last participant block is the block that contains the last byte in
|
|
- * the current state of the file.
|
|
- * If (first block == last_block):
|
|
- * then that means that the file only needs truncation of the
|
|
- * first (or last since both are same) block.
|
|
- * Else
|
|
- * if (new_size % block_size == 0)
|
|
- * then that means there is no truncate to be done with
|
|
- * only shards from first_block + 1 through the last
|
|
- * block needing to be unlinked.
|
|
- * else
|
|
- * both truncate of the first block and unlink of the
|
|
- * remaining shards until end of file is required.
|
|
- */
|
|
- local->first_block = (local->offset == 0)
|
|
- ? 0
|
|
- : get_lowest_block(local->offset - 1,
|
|
- local->block_size);
|
|
- local->last_block = get_highest_block(0, local->prebuf.ia_size,
|
|
- local->block_size);
|
|
-
|
|
- local->num_blocks = local->last_block - local->first_block + 1;
|
|
- local->resolver_base_inode = (local->fop == GF_FOP_TRUNCATE)
|
|
- ? local->loc.inode
|
|
- : local->fd->inode;
|
|
-
|
|
- if ((local->first_block == 0) && (local->num_blocks == 1)) {
|
|
- if (local->fop == GF_FOP_TRUNCATE)
|
|
- STACK_WIND(frame, shard_truncate_last_shard_cbk, FIRST_CHILD(this),
|
|
- FIRST_CHILD(this)->fops->truncate, &local->loc,
|
|
- local->offset, local->xattr_req);
|
|
- else
|
|
- STACK_WIND(frame, shard_truncate_last_shard_cbk, FIRST_CHILD(this),
|
|
- FIRST_CHILD(this)->fops->ftruncate, local->fd,
|
|
- local->offset, local->xattr_req);
|
|
- return 0;
|
|
- }
|
|
+int shard_lookup_marker_file(call_frame_t *frame, xlator_t *this) {
|
|
+ int op_errno = ENOMEM;
|
|
+ dict_t *xattr_req = NULL;
|
|
+ shard_local_t *local = NULL;
|
|
|
|
- local->inode_list = GF_CALLOC(local->num_blocks, sizeof(inode_t *),
|
|
- gf_shard_mt_inode_list);
|
|
- if (!local->inode_list)
|
|
- goto err;
|
|
+ local = frame->local;
|
|
|
|
- local->dot_shard_loc.inode = inode_find(this->itable, priv->dot_shard_gfid);
|
|
- if (!local->dot_shard_loc.inode) {
|
|
- ret = shard_init_internal_dir_loc(this, local,
|
|
- SHARD_INTERNAL_DIR_DOT_SHARD);
|
|
- if (ret)
|
|
- goto err;
|
|
- shard_lookup_internal_dir(frame, this,
|
|
- shard_post_resolve_truncate_handler,
|
|
- SHARD_INTERNAL_DIR_DOT_SHARD);
|
|
- } else {
|
|
- local->post_res_handler = shard_post_resolve_truncate_handler;
|
|
- shard_refresh_internal_dir(frame, this, SHARD_INTERNAL_DIR_DOT_SHARD);
|
|
- }
|
|
- return 0;
|
|
+ xattr_req = shard_create_gfid_dict(local->xattr_req);
|
|
+ if (!xattr_req)
|
|
+ goto err;
|
|
|
|
+ STACK_WIND(frame, shard_lookup_marker_file_cbk, FIRST_CHILD(this),
|
|
+ FIRST_CHILD(this)->fops->lookup, &local->newloc, xattr_req);
|
|
+ dict_unref(xattr_req);
|
|
+ return 0;
|
|
err:
|
|
- shard_common_failure_unwind(local->fop, frame, -1, ENOMEM);
|
|
- return 0;
|
|
+ shard_common_failure_unwind(local->fop, frame, -1, op_errno);
|
|
+ return 0;
|
|
}
|
|
|
|
-int
|
|
-shard_post_lookup_truncate_handler(call_frame_t *frame, xlator_t *this)
|
|
-{
|
|
- shard_local_t *local = NULL;
|
|
- struct iatt tmp_stbuf = {
|
|
- 0,
|
|
- };
|
|
-
|
|
- local = frame->local;
|
|
-
|
|
- if (local->op_ret < 0) {
|
|
- shard_common_failure_unwind(local->fop, frame, local->op_ret,
|
|
- local->op_errno);
|
|
- return 0;
|
|
- }
|
|
-
|
|
- local->postbuf = tmp_stbuf = local->prebuf;
|
|
-
|
|
- if (local->prebuf.ia_size == local->offset) {
|
|
- /* If the file size is same as requested size, unwind the call
|
|
- * immediately.
|
|
- */
|
|
- if (local->fop == GF_FOP_TRUNCATE)
|
|
- SHARD_STACK_UNWIND(truncate, frame, 0, 0, &local->prebuf,
|
|
- &local->postbuf, NULL);
|
|
- else
|
|
- SHARD_STACK_UNWIND(ftruncate, frame, 0, 0, &local->prebuf,
|
|
- &local->postbuf, NULL);
|
|
- } else if (local->offset > local->prebuf.ia_size) {
|
|
- /* If the truncate is from a lower to a higher size, set the
|
|
- * new size xattr and unwind.
|
|
- */
|
|
- local->hole_size = local->offset - local->prebuf.ia_size;
|
|
- local->delta_size = 0;
|
|
- GF_ATOMIC_INIT(local->delta_blocks, 0);
|
|
- local->postbuf.ia_size = local->offset;
|
|
- tmp_stbuf.ia_size = local->offset;
|
|
- shard_inode_ctx_set(local->loc.inode, this, &tmp_stbuf, 0,
|
|
- SHARD_INODE_WRITE_MASK);
|
|
- shard_update_file_size(frame, this, NULL, &local->loc,
|
|
- shard_post_update_size_truncate_handler);
|
|
+int shard_create_marker_file_under_remove_me_cbk(
|
|
+ call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret,
|
|
+ int32_t op_errno, inode_t *inode, struct iatt *buf, struct iatt *preparent,
|
|
+ struct iatt *postparent, dict_t *xdata) {
|
|
+ inode_t *linked_inode = NULL;
|
|
+ shard_priv_t *priv = NULL;
|
|
+ shard_local_t *local = NULL;
|
|
+
|
|
+ local = frame->local;
|
|
+ priv = this->private;
|
|
+
|
|
+ SHARD_UNSET_ROOT_FS_ID(frame, local);
|
|
+ if (op_ret < 0) {
|
|
+ if ((op_errno != EEXIST) && (op_errno != ENODATA)) {
|
|
+ local->op_ret = op_ret;
|
|
+ local->op_errno = op_errno;
|
|
+ gf_msg(this->name, GF_LOG_ERROR, op_errno, SHARD_MSG_FOP_FAILED,
|
|
+ "Marker file creation "
|
|
+ "failed while performing %s; entry gfid=%s",
|
|
+ gf_fop_string(local->fop), local->newloc.name);
|
|
+ goto err;
|
|
} else {
|
|
- /* ... else
|
|
- * i. unlink all shards that need to be unlinked.
|
|
- * ii. truncate the last of the shards.
|
|
- * iii. update the new size using setxattr.
|
|
- * and unwind the fop.
|
|
- */
|
|
- local->hole_size = 0;
|
|
- local->delta_size = (local->offset - local->prebuf.ia_size);
|
|
- GF_ATOMIC_INIT(local->delta_blocks, 0);
|
|
- tmp_stbuf.ia_size = local->offset;
|
|
- shard_inode_ctx_set(local->loc.inode, this, &tmp_stbuf, 0,
|
|
- SHARD_INODE_WRITE_MASK);
|
|
- shard_truncate_begin(frame, this);
|
|
- }
|
|
- return 0;
|
|
-}
|
|
-
|
|
-/* TO-DO:
|
|
- * Fix updates to size and block count with racing write(s) and truncate(s).
|
|
- */
|
|
-
|
|
-int
|
|
-shard_truncate(call_frame_t *frame, xlator_t *this, loc_t *loc, off_t offset,
|
|
- dict_t *xdata)
|
|
-{
|
|
- int ret = -1;
|
|
- uint64_t block_size = 0;
|
|
- shard_local_t *local = NULL;
|
|
-
|
|
- ret = shard_inode_ctx_get_block_size(loc->inode, this, &block_size);
|
|
- if (ret) {
|
|
- gf_msg(this->name, GF_LOG_ERROR, 0, SHARD_MSG_INODE_CTX_GET_FAILED,
|
|
- "Failed to get block "
|
|
- "size from inode ctx of %s",
|
|
- uuid_utoa(loc->inode->gfid));
|
|
- goto err;
|
|
+ shard_lookup_marker_file(frame, this);
|
|
+ return 0;
|
|
}
|
|
+ }
|
|
|
|
- if (!block_size || frame->root->pid == GF_CLIENT_PID_GSYNCD) {
|
|
- STACK_WIND(frame, default_truncate_cbk, FIRST_CHILD(this),
|
|
- FIRST_CHILD(this)->fops->truncate, loc, offset, xdata);
|
|
- return 0;
|
|
- }
|
|
-
|
|
- if (!this->itable)
|
|
- this->itable = loc->inode->table;
|
|
-
|
|
- local = mem_get0(this->local_pool);
|
|
- if (!local)
|
|
- goto err;
|
|
-
|
|
- frame->local = local;
|
|
-
|
|
- ret = syncbarrier_init(&local->barrier);
|
|
- if (ret)
|
|
- goto err;
|
|
- loc_copy(&local->loc, loc);
|
|
- local->offset = offset;
|
|
- local->block_size = block_size;
|
|
- local->fop = GF_FOP_TRUNCATE;
|
|
- local->xattr_req = (xdata) ? dict_ref(xdata) : dict_new();
|
|
- if (!local->xattr_req)
|
|
- goto err;
|
|
- local->resolver_base_inode = loc->inode;
|
|
- GF_ATOMIC_INIT(local->delta_blocks, 0);
|
|
-
|
|
- shard_lookup_base_file(frame, this, &local->loc,
|
|
- shard_post_lookup_truncate_handler);
|
|
- return 0;
|
|
+ linked_inode =
|
|
+ inode_link(inode, priv->dot_shard_rm_inode, local->newloc.name, buf);
|
|
+ inode_unref(local->newloc.inode);
|
|
+ local->newloc.inode = linked_inode;
|
|
|
|
+ if (local->fop == GF_FOP_UNLINK)
|
|
+ shard_unlink_base_file(frame, this);
|
|
+ else if (local->fop == GF_FOP_RENAME)
|
|
+ shard_rename_src_base_file(frame, this);
|
|
+ return 0;
|
|
err:
|
|
- shard_common_failure_unwind(GF_FOP_TRUNCATE, frame, -1, ENOMEM);
|
|
- return 0;
|
|
-}
|
|
-
|
|
-int
|
|
-shard_ftruncate(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
|
|
- dict_t *xdata)
|
|
-{
|
|
- int ret = -1;
|
|
- uint64_t block_size = 0;
|
|
- shard_local_t *local = NULL;
|
|
-
|
|
- ret = shard_inode_ctx_get_block_size(fd->inode, this, &block_size);
|
|
- if (ret) {
|
|
- gf_msg(this->name, GF_LOG_ERROR, 0, SHARD_MSG_INODE_CTX_GET_FAILED,
|
|
- "Failed to get block "
|
|
- "size from inode ctx of %s",
|
|
- uuid_utoa(fd->inode->gfid));
|
|
- goto err;
|
|
- }
|
|
-
|
|
- if (!block_size || frame->root->pid == GF_CLIENT_PID_GSYNCD) {
|
|
- STACK_WIND(frame, default_ftruncate_cbk, FIRST_CHILD(this),
|
|
- FIRST_CHILD(this)->fops->ftruncate, fd, offset, xdata);
|
|
- return 0;
|
|
- }
|
|
-
|
|
- if (!this->itable)
|
|
- this->itable = fd->inode->table;
|
|
-
|
|
- local = mem_get0(this->local_pool);
|
|
- if (!local)
|
|
- goto err;
|
|
-
|
|
- frame->local = local;
|
|
- ret = syncbarrier_init(&local->barrier);
|
|
- if (ret)
|
|
- goto err;
|
|
- local->fd = fd_ref(fd);
|
|
- local->offset = offset;
|
|
- local->block_size = block_size;
|
|
- local->xattr_req = (xdata) ? dict_ref(xdata) : dict_new();
|
|
- if (!local->xattr_req)
|
|
- goto err;
|
|
- local->fop = GF_FOP_FTRUNCATE;
|
|
+ shard_common_failure_unwind(local->fop, frame, -1, local->op_errno);
|
|
+ return 0;
|
|
+}
|
|
+
|
|
+int shard_create_marker_file_under_remove_me(call_frame_t *frame,
|
|
+ xlator_t *this, loc_t *loc) {
|
|
+ int ret = 0;
|
|
+ int op_errno = ENOMEM;
|
|
+ uint64_t bs = 0;
|
|
+ char g1[64] = {
|
|
+ 0,
|
|
+ };
|
|
+ char g2[64] = {
|
|
+ 0,
|
|
+ };
|
|
+ dict_t *xattr_req = NULL;
|
|
+ shard_priv_t *priv = NULL;
|
|
+ shard_local_t *local = NULL;
|
|
+
|
|
+ priv = this->private;
|
|
+ local = frame->local;
|
|
+
|
|
+ SHARD_SET_ROOT_FS_ID(frame, local);
|
|
+
|
|
+ xattr_req = shard_create_gfid_dict(local->xattr_req);
|
|
+ if (!xattr_req)
|
|
+ goto err;
|
|
+
|
|
+ local->newloc.inode = inode_new(this->itable);
|
|
+ local->newloc.parent = inode_ref(priv->dot_shard_rm_inode);
|
|
+ ret = inode_path(local->newloc.parent, uuid_utoa(loc->inode->gfid),
|
|
+ (char **)&local->newloc.path);
|
|
+ if (ret < 0) {
|
|
+ gf_msg(this->name, GF_LOG_ERROR, 0, SHARD_MSG_INODE_PATH_FAILED,
|
|
+ "Inode path failed on "
|
|
+ "pargfid=%s bname=%s",
|
|
+ uuid_utoa_r(priv->dot_shard_rm_gfid, g1),
|
|
+ uuid_utoa_r(loc->inode->gfid, g2));
|
|
+ goto err;
|
|
+ }
|
|
+ local->newloc.name = strrchr(local->newloc.path, '/');
|
|
+ if (local->newloc.name)
|
|
+ local->newloc.name++;
|
|
+
|
|
+ if (local->fop == GF_FOP_UNLINK)
|
|
+ bs = local->block_size;
|
|
+ else if (local->fop == GF_FOP_RENAME)
|
|
+ bs = local->dst_block_size;
|
|
+
|
|
+ SHARD_INODE_CREATE_INIT(this, bs, xattr_req, &local->newloc,
|
|
+ local->prebuf.ia_size, 0, err);
|
|
+
|
|
+ STACK_WIND(frame, shard_create_marker_file_under_remove_me_cbk,
|
|
+ FIRST_CHILD(this), FIRST_CHILD(this)->fops->mknod, &local->newloc,
|
|
+ 0, 0, 0644, xattr_req);
|
|
+ dict_unref(xattr_req);
|
|
+ return 0;
|
|
|
|
- local->loc.inode = inode_ref(fd->inode);
|
|
- gf_uuid_copy(local->loc.gfid, fd->inode->gfid);
|
|
- local->resolver_base_inode = fd->inode;
|
|
- GF_ATOMIC_INIT(local->delta_blocks, 0);
|
|
-
|
|
- shard_lookup_base_file(frame, this, &local->loc,
|
|
- shard_post_lookup_truncate_handler);
|
|
- return 0;
|
|
err:
|
|
- shard_common_failure_unwind(GF_FOP_FTRUNCATE, frame, -1, ENOMEM);
|
|
- return 0;
|
|
+ if (xattr_req)
|
|
+ dict_unref(xattr_req);
|
|
+ shard_create_marker_file_under_remove_me_cbk(frame, 0, this, -1, op_errno,
|
|
+ NULL, NULL, NULL, NULL, NULL);
|
|
+ return 0;
|
|
}
|
|
|
|
-int
|
|
-shard_mknod_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
|
|
- int32_t op_ret, int32_t op_errno, inode_t *inode,
|
|
- struct iatt *buf, struct iatt *preparent,
|
|
- struct iatt *postparent, dict_t *xdata)
|
|
-{
|
|
- int ret = -1;
|
|
- shard_local_t *local = NULL;
|
|
-
|
|
- local = frame->local;
|
|
-
|
|
- if (op_ret == -1)
|
|
- goto unwind;
|
|
-
|
|
- ret = shard_inode_ctx_set(inode, this, buf, local->block_size,
|
|
- SHARD_ALL_MASK);
|
|
- if (ret)
|
|
- gf_msg(this->name, GF_LOG_WARNING, 0, SHARD_MSG_INODE_CTX_SET_FAILED,
|
|
- "Failed to set inode "
|
|
- "ctx for %s",
|
|
- uuid_utoa(inode->gfid));
|
|
-
|
|
-unwind:
|
|
- SHARD_STACK_UNWIND(mknod, frame, op_ret, op_errno, inode, buf, preparent,
|
|
- postparent, xdata);
|
|
+int shard_unlock_entrylk(call_frame_t *frame, xlator_t *this);
|
|
|
|
- return 0;
|
|
-}
|
|
+int shard_unlink_base_file_cbk(call_frame_t *frame, void *cookie,
|
|
+ xlator_t *this, int32_t op_ret, int32_t op_errno,
|
|
+ struct iatt *preparent, struct iatt *postparent,
|
|
+ dict_t *xdata) {
|
|
+ int ret = 0;
|
|
+ shard_local_t *local = NULL;
|
|
|
|
-int
|
|
-shard_mknod(call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode,
|
|
- dev_t rdev, mode_t umask, dict_t *xdata)
|
|
-{
|
|
- shard_priv_t *priv = NULL;
|
|
- shard_local_t *local = NULL;
|
|
+ local = frame->local;
|
|
|
|
- priv = this->private;
|
|
- local = mem_get0(this->local_pool);
|
|
- if (!local)
|
|
- goto err;
|
|
+ if (op_ret < 0) {
|
|
+ local->op_ret = op_ret;
|
|
+ local->op_errno = op_errno;
|
|
+ } else {
|
|
+ shard_inode_ctx_set_refresh_flag(local->int_inodelk.loc.inode, this);
|
|
+ local->preoldparent = *preparent;
|
|
+ local->postoldparent = *postparent;
|
|
+ if (xdata)
|
|
+ local->xattr_rsp = dict_ref(xdata);
|
|
+ if (local->cleanup_required)
|
|
+ shard_start_background_deletion(this);
|
|
+ }
|
|
|
|
- frame->local = local;
|
|
- local->block_size = priv->block_size;
|
|
- if (!__is_gsyncd_on_shard_dir(frame, loc)) {
|
|
- SHARD_INODE_CREATE_INIT(this, local->block_size, xdata, loc, 0, 0, err);
|
|
+ if (local->entrylk_frame) {
|
|
+ ret = shard_unlock_entrylk(frame, this);
|
|
+ if (ret < 0) {
|
|
+ local->op_ret = -1;
|
|
+ local->op_errno = -ret;
|
|
}
|
|
+ }
|
|
|
|
- STACK_WIND(frame, shard_mknod_cbk, FIRST_CHILD(this),
|
|
- FIRST_CHILD(this)->fops->mknod, loc, mode, rdev, umask, xdata);
|
|
- return 0;
|
|
-err:
|
|
- shard_common_failure_unwind(GF_FOP_MKNOD, frame, -1, ENOMEM);
|
|
- return 0;
|
|
-}
|
|
-
|
|
-int32_t
|
|
-shard_link_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
|
|
- int32_t op_ret, int32_t op_errno, inode_t *inode,
|
|
- struct iatt *buf, struct iatt *preparent,
|
|
- struct iatt *postparent, dict_t *xdata)
|
|
-{
|
|
- shard_local_t *local = NULL;
|
|
-
|
|
- local = frame->local;
|
|
- if (op_ret < 0)
|
|
- goto err;
|
|
-
|
|
- shard_inode_ctx_set(inode, this, buf, 0,
|
|
- SHARD_MASK_NLINK | SHARD_MASK_TIMES);
|
|
- buf->ia_size = local->prebuf.ia_size;
|
|
- buf->ia_blocks = local->prebuf.ia_blocks;
|
|
-
|
|
- SHARD_STACK_UNWIND(link, frame, op_ret, op_errno, inode, buf, preparent,
|
|
- postparent, xdata);
|
|
- return 0;
|
|
+ ret = shard_unlock_inodelk(frame, this);
|
|
+ if (ret < 0) {
|
|
+ local->op_ret = -1;
|
|
+ local->op_errno = -ret;
|
|
+ }
|
|
+
|
|
+ shard_unlink_cbk(frame, this);
|
|
+ return 0;
|
|
+}
|
|
+
|
|
+int shard_unlink_base_file(call_frame_t *frame, xlator_t *this) {
|
|
+ shard_local_t *local = frame->local;
|
|
+
|
|
+ /* To-Do: Request open-fd count on base file */
|
|
+ STACK_WIND(frame, shard_unlink_base_file_cbk, FIRST_CHILD(this),
|
|
+ FIRST_CHILD(this)->fops->unlink, &local->loc, local->xflag,
|
|
+ local->xattr_req);
|
|
+ return 0;
|
|
+}
|
|
+
|
|
+int shard_unlock_entrylk_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
|
|
+ int32_t op_ret, int32_t op_errno, dict_t *xdata) {
|
|
+ if (op_ret)
|
|
+ gf_msg(this->name, GF_LOG_ERROR, op_errno, SHARD_MSG_FOP_FAILED,
|
|
+ "Unlock failed. Please check brick logs for "
|
|
+ "more details");
|
|
+ SHARD_STACK_DESTROY(frame);
|
|
+ return 0;
|
|
+}
|
|
+
|
|
+int shard_unlock_entrylk(call_frame_t *frame, xlator_t *this) {
|
|
+ loc_t *loc = NULL;
|
|
+ call_frame_t *lk_frame = NULL;
|
|
+ shard_local_t *local = NULL;
|
|
+ shard_local_t *lk_local = NULL;
|
|
+ shard_entrylk_t *lock = NULL;
|
|
+
|
|
+ local = frame->local;
|
|
+ lk_frame = local->entrylk_frame;
|
|
+ lk_local = lk_frame->local;
|
|
+ local->entrylk_frame = NULL;
|
|
+ lock = &lk_local->int_entrylk;
|
|
+ loc = &lock->loc;
|
|
+
|
|
+ STACK_WIND(lk_frame, shard_unlock_entrylk_cbk, FIRST_CHILD(this),
|
|
+ FIRST_CHILD(this)->fops->entrylk, this->name, loc,
|
|
+ lk_local->int_entrylk.basename, ENTRYLK_UNLOCK, ENTRYLK_WRLCK,
|
|
+ NULL);
|
|
+ local->int_entrylk.acquired_lock = _gf_false;
|
|
+ return 0;
|
|
+}
|
|
+
|
|
+int shard_post_entrylk_fop_handler(call_frame_t *frame, xlator_t *this) {
|
|
+ shard_local_t *local = NULL;
|
|
+
|
|
+ local = frame->local;
|
|
+
|
|
+ switch (local->fop) {
|
|
+ case GF_FOP_UNLINK:
|
|
+ case GF_FOP_RENAME:
|
|
+ shard_create_marker_file_under_remove_me(frame, this,
|
|
+ &local->int_inodelk.loc);
|
|
+ break;
|
|
+ default:
|
|
+ gf_msg(this->name, GF_LOG_WARNING, 0, SHARD_MSG_INVALID_FOP,
|
|
+ "post-entrylk handler not defined. This case should not"
|
|
+ " be hit");
|
|
+ break;
|
|
+ }
|
|
+ return 0;
|
|
+}
|
|
+
|
|
+int shard_acquire_entrylk_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
|
|
+ int32_t op_ret, int32_t op_errno, dict_t *xdata) {
|
|
+ call_frame_t *main_frame = NULL;
|
|
+ shard_local_t *local = NULL;
|
|
+ shard_local_t *main_local = NULL;
|
|
+
|
|
+ local = frame->local;
|
|
+ main_frame = local->main_frame;
|
|
+ main_local = main_frame->local;
|
|
+
|
|
+ if (local->op_ret < 0) {
|
|
+ shard_common_failure_unwind(main_local->fop, main_frame, op_ret, op_errno);
|
|
+ return 0;
|
|
+ }
|
|
+ main_local->int_entrylk.acquired_lock = _gf_true;
|
|
+ shard_post_entrylk_fop_handler(main_frame, this);
|
|
+ return 0;
|
|
+}
|
|
+
|
|
+int shard_acquire_entrylk(call_frame_t *frame, xlator_t *this, inode_t *inode,
|
|
+ uuid_t gfid) {
|
|
+ char gfid_str[GF_UUID_BUF_SIZE] = {
|
|
+ 0,
|
|
+ };
|
|
+ shard_local_t *local = NULL;
|
|
+ shard_local_t *entrylk_local = NULL;
|
|
+ shard_entrylk_t *int_entrylk = NULL;
|
|
+ call_frame_t *entrylk_frame = NULL;
|
|
+
|
|
+ local = frame->local;
|
|
+ entrylk_frame = create_frame(this, this->ctx->pool);
|
|
+ if (!entrylk_frame) {
|
|
+ gf_msg(this->name, GF_LOG_WARNING, ENOMEM, SHARD_MSG_MEMALLOC_FAILED,
|
|
+ "Failed to create new frame "
|
|
+ "to lock marker file");
|
|
+ goto err;
|
|
+ }
|
|
+
|
|
+ entrylk_local = mem_get0(this->local_pool);
|
|
+ if (!entrylk_local) {
|
|
+ STACK_DESTROY(entrylk_frame->root);
|
|
+ goto err;
|
|
+ }
|
|
+
|
|
+ entrylk_frame->local = entrylk_local;
|
|
+ entrylk_local->main_frame = frame;
|
|
+ int_entrylk = &entrylk_local->int_entrylk;
|
|
+
|
|
+ int_entrylk->loc.inode = inode_ref(inode);
|
|
+ set_lk_owner_from_ptr(&entrylk_frame->root->lk_owner, entrylk_frame->root);
|
|
+ local->entrylk_frame = entrylk_frame;
|
|
+ gf_uuid_unparse(gfid, gfid_str);
|
|
+ int_entrylk->basename = gf_strdup(gfid_str);
|
|
+
|
|
+ STACK_WIND(entrylk_frame, shard_acquire_entrylk_cbk, FIRST_CHILD(this),
|
|
+ FIRST_CHILD(this)->fops->entrylk, this->name, &int_entrylk->loc,
|
|
+ int_entrylk->basename, ENTRYLK_LOCK, ENTRYLK_WRLCK, NULL);
|
|
+ return 0;
|
|
err:
|
|
- shard_common_failure_unwind(GF_FOP_LINK, frame, op_ret, op_errno);
|
|
- return 0;
|
|
-}
|
|
-
|
|
-int
|
|
-shard_post_lookup_link_handler(call_frame_t *frame, xlator_t *this)
|
|
-{
|
|
- shard_local_t *local = NULL;
|
|
-
|
|
- local = frame->local;
|
|
-
|
|
- if (local->op_ret < 0) {
|
|
- SHARD_STACK_UNWIND(link, frame, local->op_ret, local->op_errno, NULL,
|
|
- NULL, NULL, NULL, NULL);
|
|
- return 0;
|
|
- }
|
|
-
|
|
- STACK_WIND(frame, shard_link_cbk, FIRST_CHILD(this),
|
|
- FIRST_CHILD(this)->fops->link, &local->loc, &local->loc2,
|
|
- local->xattr_req);
|
|
- return 0;
|
|
+ shard_common_failure_unwind(local->fop, frame, -1, ENOMEM);
|
|
+ return 0;
|
|
}
|
|
|
|
-int32_t
|
|
-shard_link(call_frame_t *frame, xlator_t *this, loc_t *oldloc, loc_t *newloc,
|
|
- dict_t *xdata)
|
|
-{
|
|
- int ret = -1;
|
|
- uint64_t block_size = 0;
|
|
- shard_local_t *local = NULL;
|
|
-
|
|
- ret = shard_inode_ctx_get_block_size(oldloc->inode, this, &block_size);
|
|
- if (ret) {
|
|
- gf_msg(this->name, GF_LOG_ERROR, 0, SHARD_MSG_INODE_CTX_GET_FAILED,
|
|
- "Failed to get block "
|
|
- "size from inode ctx of %s",
|
|
- uuid_utoa(oldloc->inode->gfid));
|
|
- goto err;
|
|
- }
|
|
-
|
|
- if (!block_size) {
|
|
- STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->link,
|
|
- oldloc, newloc, xdata);
|
|
- return 0;
|
|
- }
|
|
-
|
|
- if (!this->itable)
|
|
- this->itable = oldloc->inode->table;
|
|
-
|
|
- local = mem_get0(this->local_pool);
|
|
- if (!local)
|
|
- goto err;
|
|
-
|
|
- frame->local = local;
|
|
-
|
|
- loc_copy(&local->loc, oldloc);
|
|
- loc_copy(&local->loc2, newloc);
|
|
- local->xattr_req = (xdata) ? dict_ref(xdata) : dict_new();
|
|
- if (!local->xattr_req)
|
|
- goto err;
|
|
-
|
|
- shard_lookup_base_file(frame, this, &local->loc,
|
|
- shard_post_lookup_link_handler);
|
|
- return 0;
|
|
-err:
|
|
- shard_common_failure_unwind(GF_FOP_LINK, frame, -1, ENOMEM);
|
|
- return 0;
|
|
-}
|
|
-
|
|
-int
|
|
-shard_unlink_shards_do(call_frame_t *frame, xlator_t *this, inode_t *inode);
|
|
-
|
|
-int
|
|
-shard_post_lookup_shards_unlink_handler(call_frame_t *frame, xlator_t *this)
|
|
-{
|
|
- shard_local_t *local = NULL;
|
|
-
|
|
- local = frame->local;
|
|
-
|
|
- if ((local->op_ret < 0) && (local->op_errno != ENOENT)) {
|
|
- gf_msg(this->name, GF_LOG_ERROR, local->op_errno, SHARD_MSG_FOP_FAILED,
|
|
- "failed to delete shards of %s",
|
|
- uuid_utoa(local->resolver_base_inode->gfid));
|
|
- return 0;
|
|
- }
|
|
- local->op_ret = 0;
|
|
- local->op_errno = 0;
|
|
-
|
|
- shard_unlink_shards_do(frame, this, local->resolver_base_inode);
|
|
- return 0;
|
|
-}
|
|
-
|
|
-int
|
|
-shard_post_resolve_unlink_handler(call_frame_t *frame, xlator_t *this)
|
|
-{
|
|
- shard_local_t *local = NULL;
|
|
-
|
|
- local = frame->local;
|
|
- local->lookup_shards_barriered = _gf_true;
|
|
-
|
|
- if (!local->call_count)
|
|
- shard_unlink_shards_do(frame, this, local->resolver_base_inode);
|
|
- else
|
|
- shard_common_lookup_shards(frame, this, local->resolver_base_inode,
|
|
- shard_post_lookup_shards_unlink_handler);
|
|
- return 0;
|
|
-}
|
|
-
|
|
-void
|
|
-shard_unlink_block_inode(shard_local_t *local, int shard_block_num)
|
|
-{
|
|
- char block_bname[256] = {
|
|
- 0,
|
|
- };
|
|
- uuid_t gfid = {
|
|
- 0,
|
|
- };
|
|
- inode_t *inode = NULL;
|
|
- inode_t *base_inode = NULL;
|
|
- xlator_t *this = NULL;
|
|
- shard_priv_t *priv = NULL;
|
|
- shard_inode_ctx_t *ctx = NULL;
|
|
- shard_inode_ctx_t *base_ictx = NULL;
|
|
- int unref_base_inode = 0;
|
|
- int unref_shard_inode = 0;
|
|
-
|
|
- this = THIS;
|
|
- priv = this->private;
|
|
-
|
|
- inode = local->inode_list[shard_block_num - local->first_block];
|
|
- shard_inode_ctx_get(inode, this, &ctx);
|
|
- base_inode = ctx->base_inode;
|
|
- if (base_inode)
|
|
- gf_uuid_copy(gfid, base_inode->gfid);
|
|
- else
|
|
- gf_uuid_copy(gfid, ctx->base_gfid);
|
|
- shard_make_block_bname(shard_block_num, gfid, block_bname,
|
|
- sizeof(block_bname));
|
|
-
|
|
- LOCK(&priv->lock);
|
|
- if (base_inode)
|
|
- LOCK(&base_inode->lock);
|
|
- LOCK(&inode->lock);
|
|
- {
|
|
- __shard_inode_ctx_get(inode, this, &ctx);
|
|
- if (!list_empty(&ctx->ilist)) {
|
|
- list_del_init(&ctx->ilist);
|
|
- priv->inode_count--;
|
|
- unref_base_inode++;
|
|
- unref_shard_inode++;
|
|
- GF_ASSERT(priv->inode_count >= 0);
|
|
- }
|
|
- if (ctx->fsync_needed) {
|
|
- unref_base_inode++;
|
|
- unref_shard_inode++;
|
|
- list_del_init(&ctx->to_fsync_list);
|
|
- if (base_inode) {
|
|
- __shard_inode_ctx_get(base_inode, this, &base_ictx);
|
|
- base_ictx->fsync_count--;
|
|
- }
|
|
- }
|
|
- }
|
|
- UNLOCK(&inode->lock);
|
|
- if (base_inode)
|
|
- UNLOCK(&base_inode->lock);
|
|
-
|
|
- inode_unlink(inode, priv->dot_shard_inode, block_bname);
|
|
- inode_ref_reduce_by_n(inode, unref_shard_inode);
|
|
- inode_forget(inode, 0);
|
|
-
|
|
- if (base_inode && unref_base_inode)
|
|
- inode_ref_reduce_by_n(base_inode, unref_base_inode);
|
|
- UNLOCK(&priv->lock);
|
|
-}
|
|
-
|
|
-int
|
|
-shard_rename_cbk(call_frame_t *frame, xlator_t *this)
|
|
-{
|
|
- shard_local_t *local = NULL;
|
|
-
|
|
- local = frame->local;
|
|
-
|
|
- SHARD_STACK_UNWIND(rename, frame, local->op_ret, local->op_errno,
|
|
- &local->prebuf, &local->preoldparent,
|
|
- &local->postoldparent, &local->prenewparent,
|
|
- &local->postnewparent, local->xattr_rsp);
|
|
- return 0;
|
|
-}
|
|
-
|
|
-int32_t
|
|
-shard_unlink_cbk(call_frame_t *frame, xlator_t *this)
|
|
-{
|
|
- shard_local_t *local = frame->local;
|
|
-
|
|
- SHARD_STACK_UNWIND(unlink, frame, local->op_ret, local->op_errno,
|
|
- &local->preoldparent, &local->postoldparent,
|
|
- local->xattr_rsp);
|
|
- return 0;
|
|
-}
|
|
-
|
|
-int
|
|
-shard_unlink_shards_do_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
|
|
- int32_t op_ret, int32_t op_errno,
|
|
- struct iatt *preparent, struct iatt *postparent,
|
|
- dict_t *xdata)
|
|
-{
|
|
- int shard_block_num = (long)cookie;
|
|
- shard_local_t *local = NULL;
|
|
-
|
|
- local = frame->local;
|
|
-
|
|
- if (op_ret < 0) {
|
|
- local->op_ret = op_ret;
|
|
- local->op_errno = op_errno;
|
|
- goto done;
|
|
- }
|
|
-
|
|
- shard_unlink_block_inode(local, shard_block_num);
|
|
-done:
|
|
- syncbarrier_wake(&local->barrier);
|
|
- return 0;
|
|
-}
|
|
-
|
|
-int
|
|
-shard_unlink_shards_do(call_frame_t *frame, xlator_t *this, inode_t *inode)
|
|
-{
|
|
- int i = 0;
|
|
- int ret = -1;
|
|
- int count = 0;
|
|
- uint32_t cur_block = 0;
|
|
- uint32_t cur_block_idx = 0; /*this is idx into inode_list[] array */
|
|
- char *bname = NULL;
|
|
- char path[PATH_MAX] = {
|
|
- 0,
|
|
- };
|
|
- uuid_t gfid = {
|
|
- 0,
|
|
- };
|
|
- loc_t loc = {
|
|
- 0,
|
|
- };
|
|
- gf_boolean_t wind_failed = _gf_false;
|
|
- shard_local_t *local = NULL;
|
|
- shard_priv_t *priv = NULL;
|
|
-
|
|
- priv = this->private;
|
|
- local = frame->local;
|
|
-
|
|
- if (inode)
|
|
- gf_uuid_copy(gfid, inode->gfid);
|
|
- else
|
|
- gf_uuid_copy(gfid, local->base_gfid);
|
|
-
|
|
- for (i = 0; i < local->num_blocks; i++) {
|
|
- if (!local->inode_list[i])
|
|
- continue;
|
|
- count++;
|
|
- }
|
|
-
|
|
- if (!count) {
|
|
- /* callcount = 0 implies that all of the shards that need to be
|
|
- * unlinked are non-existent (in other words the file is full of
|
|
- * holes).
|
|
- */
|
|
- gf_msg_debug(this->name, 0,
|
|
- "All shards that need to be "
|
|
- "unlinked are non-existent: %s",
|
|
- uuid_utoa(gfid));
|
|
- return 0;
|
|
- }
|
|
-
|
|
- SHARD_SET_ROOT_FS_ID(frame, local);
|
|
- local->barrier.waitfor = count;
|
|
- cur_block = cur_block_idx + local->first_block;
|
|
-
|
|
- while (cur_block_idx < local->num_blocks) {
|
|
- if (!local->inode_list[cur_block_idx])
|
|
- goto next;
|
|
-
|
|
- if (wind_failed) {
|
|
- shard_unlink_shards_do_cbk(frame, (void *)(long)cur_block, this, -1,
|
|
- ENOMEM, NULL, NULL, NULL);
|
|
- goto next;
|
|
- }
|
|
-
|
|
- shard_make_block_abspath(cur_block, gfid, path, sizeof(path));
|
|
- bname = strrchr(path, '/') + 1;
|
|
- loc.parent = inode_ref(priv->dot_shard_inode);
|
|
- ret = inode_path(loc.parent, bname, (char **)&(loc.path));
|
|
- if (ret < 0) {
|
|
- gf_msg(this->name, GF_LOG_ERROR, 0, SHARD_MSG_INODE_PATH_FAILED,
|
|
- "Inode path failed"
|
|
- " on %s, base file gfid = %s",
|
|
- bname, uuid_utoa(gfid));
|
|
- local->op_ret = -1;
|
|
- local->op_errno = ENOMEM;
|
|
- loc_wipe(&loc);
|
|
- wind_failed = _gf_true;
|
|
- shard_unlink_shards_do_cbk(frame, (void *)(long)cur_block, this, -1,
|
|
- ENOMEM, NULL, NULL, NULL);
|
|
- goto next;
|
|
- }
|
|
-
|
|
- loc.name = strrchr(loc.path, '/');
|
|
- if (loc.name)
|
|
- loc.name++;
|
|
- loc.inode = inode_ref(local->inode_list[cur_block_idx]);
|
|
-
|
|
- STACK_WIND_COOKIE(frame, shard_unlink_shards_do_cbk,
|
|
- (void *)(long)cur_block, FIRST_CHILD(this),
|
|
- FIRST_CHILD(this)->fops->unlink, &loc, local->xflag,
|
|
- local->xattr_req);
|
|
- loc_wipe(&loc);
|
|
- next:
|
|
- cur_block++;
|
|
- cur_block_idx++;
|
|
- }
|
|
- syncbarrier_wait(&local->barrier, count);
|
|
- SHARD_UNSET_ROOT_FS_ID(frame, local);
|
|
- return 0;
|
|
-}
|
|
-
|
|
-int
|
|
-shard_regulated_shards_deletion(call_frame_t *cleanup_frame, xlator_t *this,
|
|
- int now, int first_block, gf_dirent_t *entry)
|
|
-{
|
|
- int i = 0;
|
|
- int ret = 0;
|
|
- shard_local_t *local = NULL;
|
|
- uuid_t gfid = {
|
|
- 0,
|
|
- };
|
|
-
|
|
- local = cleanup_frame->local;
|
|
-
|
|
- local->inode_list = GF_CALLOC(now, sizeof(inode_t *),
|
|
- gf_shard_mt_inode_list);
|
|
- if (!local->inode_list)
|
|
- return -ENOMEM;
|
|
-
|
|
- local->first_block = first_block;
|
|
- local->last_block = first_block + now - 1;
|
|
- local->num_blocks = now;
|
|
- gf_uuid_parse(entry->d_name, gfid);
|
|
- gf_uuid_copy(local->base_gfid, gfid);
|
|
- local->resolver_base_inode = inode_find(this->itable, gfid);
|
|
- local->call_count = 0;
|
|
- ret = syncbarrier_init(&local->barrier);
|
|
- if (ret) {
|
|
- GF_FREE(local->inode_list);
|
|
- local->inode_list = NULL;
|
|
- inode_unref(local->resolver_base_inode);
|
|
- local->resolver_base_inode = NULL;
|
|
- return -errno;
|
|
- }
|
|
- shard_common_resolve_shards(cleanup_frame, this,
|
|
- shard_post_resolve_unlink_handler);
|
|
-
|
|
- for (i = 0; i < local->num_blocks; i++) {
|
|
- if (local->inode_list[i])
|
|
- inode_unref(local->inode_list[i]);
|
|
- }
|
|
- GF_FREE(local->inode_list);
|
|
- local->inode_list = NULL;
|
|
- if (local->op_ret)
|
|
- ret = -local->op_errno;
|
|
- syncbarrier_destroy(&local->barrier);
|
|
- inode_unref(local->resolver_base_inode);
|
|
- local->resolver_base_inode = NULL;
|
|
- STACK_RESET(cleanup_frame->root);
|
|
- return ret;
|
|
-}
|
|
-
|
|
-int
|
|
-__shard_delete_shards_of_entry(call_frame_t *cleanup_frame, xlator_t *this,
|
|
- gf_dirent_t *entry, inode_t *inode)
|
|
-{
|
|
- int ret = 0;
|
|
- int shard_count = 0;
|
|
- int first_block = 0;
|
|
- int now = 0;
|
|
- uint64_t size = 0;
|
|
- uint64_t block_size = 0;
|
|
- uint64_t size_array[4] = {
|
|
- 0,
|
|
- };
|
|
- void *bsize = NULL;
|
|
- void *size_attr = NULL;
|
|
- dict_t *xattr_rsp = NULL;
|
|
- loc_t loc = {
|
|
- 0,
|
|
- };
|
|
- shard_local_t *local = NULL;
|
|
- shard_priv_t *priv = NULL;
|
|
-
|
|
- priv = this->private;
|
|
- local = cleanup_frame->local;
|
|
- ret = dict_reset(local->xattr_req);
|
|
- if (ret) {
|
|
- gf_msg(this->name, GF_LOG_WARNING, 0, SHARD_MSG_DICT_OP_FAILED,
|
|
- "Failed to reset dict");
|
|
- ret = -ENOMEM;
|
|
- goto err;
|
|
- }
|
|
-
|
|
- ret = dict_set_uint64(local->xattr_req, GF_XATTR_SHARD_BLOCK_SIZE, 0);
|
|
- if (ret) {
|
|
- gf_msg(this->name, GF_LOG_WARNING, 0, SHARD_MSG_DICT_OP_FAILED,
|
|
- "Failed to set dict value: key:%s", GF_XATTR_SHARD_BLOCK_SIZE);
|
|
- ret = -ENOMEM;
|
|
- goto err;
|
|
- }
|
|
-
|
|
- ret = dict_set_uint64(local->xattr_req, GF_XATTR_SHARD_FILE_SIZE, 8 * 4);
|
|
- if (ret) {
|
|
- gf_msg(this->name, GF_LOG_WARNING, 0, SHARD_MSG_DICT_OP_FAILED,
|
|
- "Failed to set dict value: key:%s", GF_XATTR_SHARD_FILE_SIZE);
|
|
- ret = -ENOMEM;
|
|
- goto err;
|
|
- }
|
|
-
|
|
- loc.inode = inode_ref(inode);
|
|
- loc.parent = inode_ref(priv->dot_shard_rm_inode);
|
|
- ret = inode_path(loc.parent, entry->d_name, (char **)&(loc.path));
|
|
- if (ret < 0) {
|
|
- gf_msg(this->name, GF_LOG_ERROR, 0, SHARD_MSG_INODE_PATH_FAILED,
|
|
- "Inode path failed on %s", entry->d_name);
|
|
- ret = -ENOMEM;
|
|
- goto err;
|
|
- }
|
|
-
|
|
- loc.name = strrchr(loc.path, '/');
|
|
- if (loc.name)
|
|
- loc.name++;
|
|
- ret = syncop_lookup(FIRST_CHILD(this), &loc, NULL, NULL, local->xattr_req,
|
|
- &xattr_rsp);
|
|
- if (ret)
|
|
- goto err;
|
|
-
|
|
- ret = dict_get_ptr(xattr_rsp, GF_XATTR_SHARD_BLOCK_SIZE, &bsize);
|
|
- if (ret) {
|
|
- gf_msg(this->name, GF_LOG_ERROR, 0, SHARD_MSG_DICT_OP_FAILED,
|
|
- "Failed to get dict value: key:%s", GF_XATTR_SHARD_BLOCK_SIZE);
|
|
- goto err;
|
|
- }
|
|
- block_size = ntoh64(*((uint64_t *)bsize));
|
|
-
|
|
- ret = dict_get_ptr(xattr_rsp, GF_XATTR_SHARD_FILE_SIZE, &size_attr);
|
|
- if (ret) {
|
|
- gf_msg(this->name, GF_LOG_ERROR, 0, SHARD_MSG_DICT_OP_FAILED,
|
|
- "Failed to get dict value: key:%s", GF_XATTR_SHARD_FILE_SIZE);
|
|
- goto err;
|
|
- }
|
|
-
|
|
- memcpy(size_array, size_attr, sizeof(size_array));
|
|
- size = ntoh64(size_array[0]);
|
|
-
|
|
- shard_count = (size / block_size) - 1;
|
|
- if (shard_count < 0) {
|
|
- gf_msg_debug(this->name, 0,
|
|
- "Size of %s hasn't grown beyond "
|
|
- "its shard-block-size. Nothing to delete. "
|
|
- "Returning",
|
|
- entry->d_name);
|
|
- /* File size < shard-block-size, so nothing to delete */
|
|
- ret = 0;
|
|
- goto delete_marker;
|
|
- }
|
|
- if ((size % block_size) > 0)
|
|
- shard_count++;
|
|
-
|
|
- if (shard_count == 0) {
|
|
- gf_msg_debug(this->name, 0,
|
|
- "Size of %s is exactly equal to "
|
|
- "its shard-block-size. Nothing to delete. "
|
|
- "Returning",
|
|
- entry->d_name);
|
|
- ret = 0;
|
|
- goto delete_marker;
|
|
- }
|
|
- gf_msg_debug(this->name, 0,
|
|
- "base file = %s, "
|
|
- "shard-block-size=%" PRIu64 ", file-size=%" PRIu64
|
|
- ", "
|
|
- "shard_count=%d",
|
|
- entry->d_name, block_size, size, shard_count);
|
|
-
|
|
- /* Perform a gfid-based lookup to see if gfid corresponding to marker
|
|
- * file's base name exists.
|
|
- */
|
|
- loc_wipe(&loc);
|
|
- loc.inode = inode_new(this->itable);
|
|
- if (!loc.inode) {
|
|
- ret = -ENOMEM;
|
|
- goto err;
|
|
- }
|
|
- gf_uuid_parse(entry->d_name, loc.gfid);
|
|
- ret = syncop_lookup(FIRST_CHILD(this), &loc, NULL, NULL, NULL, NULL);
|
|
- if (!ret) {
|
|
- gf_msg_debug(this->name, 0,
|
|
- "Base shard corresponding to gfid "
|
|
- "%s is present. Skipping shard deletion. "
|
|
- "Returning",
|
|
- entry->d_name);
|
|
- ret = 0;
|
|
- goto delete_marker;
|
|
- }
|
|
-
|
|
- first_block = 1;
|
|
-
|
|
- while (shard_count) {
|
|
- if (shard_count < local->deletion_rate) {
|
|
- now = shard_count;
|
|
- shard_count = 0;
|
|
- } else {
|
|
- now = local->deletion_rate;
|
|
- shard_count -= local->deletion_rate;
|
|
- }
|
|
-
|
|
- gf_msg_debug(this->name, 0,
|
|
- "deleting %d shards starting from "
|
|
- "block %d of gfid %s",
|
|
- now, first_block, entry->d_name);
|
|
- ret = shard_regulated_shards_deletion(cleanup_frame, this, now,
|
|
- first_block, entry);
|
|
- if (ret)
|
|
- goto err;
|
|
- first_block += now;
|
|
- }
|
|
-
|
|
-delete_marker:
|
|
- loc_wipe(&loc);
|
|
- loc.inode = inode_ref(inode);
|
|
- loc.parent = inode_ref(priv->dot_shard_rm_inode);
|
|
- ret = inode_path(loc.parent, entry->d_name, (char **)&(loc.path));
|
|
- if (ret < 0) {
|
|
- gf_msg(this->name, GF_LOG_ERROR, 0, SHARD_MSG_INODE_PATH_FAILED,
|
|
- "Inode path failed on %s", entry->d_name);
|
|
- ret = -ENOMEM;
|
|
- goto err;
|
|
- }
|
|
- loc.name = strrchr(loc.path, '/');
|
|
- if (loc.name)
|
|
- loc.name++;
|
|
- ret = syncop_unlink(FIRST_CHILD(this), &loc, NULL, NULL);
|
|
- if (ret)
|
|
- gf_msg(this->name, GF_LOG_ERROR, 0, SHARD_MSG_SHARDS_DELETION_FAILED,
|
|
- "Failed to delete %s "
|
|
- "from /%s",
|
|
- entry->d_name, GF_SHARD_REMOVE_ME_DIR);
|
|
-err:
|
|
- if (xattr_rsp)
|
|
- dict_unref(xattr_rsp);
|
|
- loc_wipe(&loc);
|
|
- return ret;
|
|
-}
|
|
-
|
|
-int
|
|
-shard_delete_shards_of_entry(call_frame_t *cleanup_frame, xlator_t *this,
|
|
- gf_dirent_t *entry, inode_t *inode)
|
|
-{
|
|
- int ret = -1;
|
|
- loc_t loc = {
|
|
- 0,
|
|
- };
|
|
- shard_priv_t *priv = NULL;
|
|
-
|
|
- priv = this->private;
|
|
- loc.inode = inode_ref(priv->dot_shard_rm_inode);
|
|
-
|
|
- ret = syncop_entrylk(FIRST_CHILD(this), this->name, &loc, entry->d_name,
|
|
- ENTRYLK_LOCK_NB, ENTRYLK_WRLCK, NULL, NULL);
|
|
- if (ret < 0) {
|
|
- if (ret == -EAGAIN) {
|
|
- ret = 0;
|
|
- }
|
|
- goto out;
|
|
- }
|
|
- {
|
|
- ret = __shard_delete_shards_of_entry(cleanup_frame, this, entry, inode);
|
|
- }
|
|
- syncop_entrylk(FIRST_CHILD(this), this->name, &loc, entry->d_name,
|
|
- ENTRYLK_UNLOCK, ENTRYLK_WRLCK, NULL, NULL);
|
|
-out:
|
|
- loc_wipe(&loc);
|
|
- return ret;
|
|
-}
|
|
-
|
|
-int
|
|
-shard_delete_shards_cbk(int ret, call_frame_t *frame, void *data)
|
|
-{
|
|
- SHARD_STACK_DESTROY(frame);
|
|
- return 0;
|
|
-}
|
|
-
|
|
-int
|
|
-shard_resolve_internal_dir(xlator_t *this, shard_local_t *local,
|
|
- shard_internal_dir_type_t type)
|
|
-{
|
|
- int ret = 0;
|
|
- char *bname = NULL;
|
|
- loc_t *loc = NULL;
|
|
- shard_priv_t *priv = NULL;
|
|
- uuid_t gfid = {
|
|
- 0,
|
|
- };
|
|
- struct iatt stbuf = {
|
|
- 0,
|
|
- };
|
|
-
|
|
- priv = this->private;
|
|
-
|
|
- switch (type) {
|
|
- case SHARD_INTERNAL_DIR_DOT_SHARD:
|
|
- loc = &local->dot_shard_loc;
|
|
- gf_uuid_copy(gfid, priv->dot_shard_gfid);
|
|
- bname = GF_SHARD_DIR;
|
|
- break;
|
|
- case SHARD_INTERNAL_DIR_DOT_SHARD_REMOVE_ME:
|
|
- loc = &local->dot_shard_rm_loc;
|
|
- gf_uuid_copy(gfid, priv->dot_shard_rm_gfid);
|
|
- bname = GF_SHARD_REMOVE_ME_DIR;
|
|
- break;
|
|
- default:
|
|
- break;
|
|
- }
|
|
-
|
|
- loc->inode = inode_find(this->itable, gfid);
|
|
- if (!loc->inode) {
|
|
- ret = shard_init_internal_dir_loc(this, local, type);
|
|
- if (ret)
|
|
- goto err;
|
|
- ret = dict_reset(local->xattr_req);
|
|
- if (ret) {
|
|
- gf_msg(this->name, GF_LOG_WARNING, 0, SHARD_MSG_DICT_OP_FAILED,
|
|
- "Failed to reset "
|
|
- "dict");
|
|
- ret = -ENOMEM;
|
|
- goto err;
|
|
- }
|
|
- ret = dict_set_gfuuid(local->xattr_req, "gfid-req", gfid, true);
|
|
- ret = syncop_lookup(FIRST_CHILD(this), loc, &stbuf, NULL,
|
|
- local->xattr_req, NULL);
|
|
- if (ret < 0) {
|
|
- if (ret != -ENOENT)
|
|
- gf_msg(this->name, GF_LOG_ERROR, -ret,
|
|
- SHARD_MSG_SHARDS_DELETION_FAILED,
|
|
- "Lookup on %s failed, exiting", bname);
|
|
- goto err;
|
|
- } else {
|
|
- shard_link_internal_dir_inode(local, loc->inode, &stbuf, type);
|
|
- }
|
|
- }
|
|
- ret = 0;
|
|
-err:
|
|
- return ret;
|
|
-}
|
|
-
|
|
-int
|
|
-shard_lookup_marker_entry(xlator_t *this, shard_local_t *local,
|
|
- gf_dirent_t *entry)
|
|
-{
|
|
- int ret = 0;
|
|
- loc_t loc = {
|
|
- 0,
|
|
- };
|
|
-
|
|
- loc.inode = inode_new(this->itable);
|
|
- if (!loc.inode) {
|
|
- ret = -ENOMEM;
|
|
- goto err;
|
|
- }
|
|
- loc.parent = inode_ref(local->fd->inode);
|
|
-
|
|
- ret = inode_path(loc.parent, entry->d_name, (char **)&(loc.path));
|
|
- if (ret < 0) {
|
|
- gf_msg(this->name, GF_LOG_ERROR, 0, SHARD_MSG_INODE_PATH_FAILED,
|
|
- "Inode path failed on %s", entry->d_name);
|
|
- ret = -ENOMEM;
|
|
- goto err;
|
|
- }
|
|
-
|
|
- loc.name = strrchr(loc.path, '/');
|
|
- if (loc.name)
|
|
- loc.name++;
|
|
-
|
|
- ret = syncop_lookup(FIRST_CHILD(this), &loc, NULL, NULL, NULL, NULL);
|
|
- if (ret < 0) {
|
|
- goto err;
|
|
- }
|
|
- entry->inode = inode_ref(loc.inode);
|
|
- ret = 0;
|
|
-err:
|
|
- loc_wipe(&loc);
|
|
- return ret;
|
|
-}
|
|
-
|
|
-int
|
|
-shard_delete_shards(void *opaque)
|
|
-{
|
|
- int ret = 0;
|
|
- off_t offset = 0;
|
|
- loc_t loc = {
|
|
- 0,
|
|
- };
|
|
- inode_t *link_inode = NULL;
|
|
- xlator_t *this = NULL;
|
|
- shard_priv_t *priv = NULL;
|
|
- shard_local_t *local = NULL;
|
|
- gf_dirent_t entries;
|
|
- gf_dirent_t *entry = NULL;
|
|
- call_frame_t *cleanup_frame = NULL;
|
|
- gf_boolean_t done = _gf_false;
|
|
-
|
|
- this = THIS;
|
|
- priv = this->private;
|
|
- INIT_LIST_HEAD(&entries.list);
|
|
-
|
|
- cleanup_frame = opaque;
|
|
-
|
|
- local = mem_get0(this->local_pool);
|
|
- if (!local) {
|
|
- gf_msg(this->name, GF_LOG_WARNING, ENOMEM, SHARD_MSG_MEMALLOC_FAILED,
|
|
- "Failed to create local to "
|
|
- "delete shards");
|
|
- ret = -ENOMEM;
|
|
- goto err;
|
|
- }
|
|
- cleanup_frame->local = local;
|
|
- local->fop = GF_FOP_UNLINK;
|
|
-
|
|
- local->xattr_req = dict_new();
|
|
- if (!local->xattr_req) {
|
|
- ret = -ENOMEM;
|
|
- goto err;
|
|
- }
|
|
- local->deletion_rate = priv->deletion_rate;
|
|
-
|
|
- ret = shard_resolve_internal_dir(this, local, SHARD_INTERNAL_DIR_DOT_SHARD);
|
|
- if (ret == -ENOENT) {
|
|
- gf_msg_debug(this->name, 0,
|
|
- ".shard absent. Nothing to"
|
|
- " delete. Exiting");
|
|
- ret = 0;
|
|
- goto err;
|
|
- } else if (ret < 0) {
|
|
- goto err;
|
|
- }
|
|
-
|
|
- ret = shard_resolve_internal_dir(this, local,
|
|
- SHARD_INTERNAL_DIR_DOT_SHARD_REMOVE_ME);
|
|
- if (ret == -ENOENT) {
|
|
- gf_msg_debug(this->name, 0,
|
|
- ".remove_me absent. "
|
|
- "Nothing to delete. Exiting");
|
|
- ret = 0;
|
|
- goto err;
|
|
- } else if (ret < 0) {
|
|
- goto err;
|
|
- }
|
|
-
|
|
- local->fd = fd_anonymous(local->dot_shard_rm_loc.inode);
|
|
- if (!local->fd) {
|
|
- ret = -ENOMEM;
|
|
- goto err;
|
|
- }
|
|
-
|
|
- for (;;) {
|
|
- offset = 0;
|
|
- LOCK(&priv->lock);
|
|
- {
|
|
- if (priv->bg_del_state == SHARD_BG_DELETION_LAUNCHING) {
|
|
- priv->bg_del_state = SHARD_BG_DELETION_IN_PROGRESS;
|
|
- } else if (priv->bg_del_state == SHARD_BG_DELETION_IN_PROGRESS) {
|
|
- priv->bg_del_state = SHARD_BG_DELETION_NONE;
|
|
- done = _gf_true;
|
|
- }
|
|
- }
|
|
- UNLOCK(&priv->lock);
|
|
- if (done)
|
|
- break;
|
|
- while (
|
|
- (ret = syncop_readdirp(FIRST_CHILD(this), local->fd, 131072, offset,
|
|
- &entries, local->xattr_req, NULL))) {
|
|
- if (ret > 0)
|
|
- ret = 0;
|
|
- list_for_each_entry(entry, &entries.list, list)
|
|
- {
|
|
- offset = entry->d_off;
|
|
-
|
|
- if (!strcmp(entry->d_name, ".") || !strcmp(entry->d_name, ".."))
|
|
- continue;
|
|
-
|
|
- if (!entry->inode) {
|
|
- ret = shard_lookup_marker_entry(this, local, entry);
|
|
- if (ret < 0)
|
|
- continue;
|
|
- }
|
|
- link_inode = inode_link(entry->inode, local->fd->inode,
|
|
- entry->d_name, &entry->d_stat);
|
|
-
|
|
- gf_msg_debug(this->name, 0,
|
|
- "Initiating deletion of "
|
|
- "shards of gfid %s",
|
|
- entry->d_name);
|
|
- ret = shard_delete_shards_of_entry(cleanup_frame, this, entry,
|
|
- link_inode);
|
|
- inode_unlink(link_inode, local->fd->inode, entry->d_name);
|
|
- inode_unref(link_inode);
|
|
- if (ret) {
|
|
- gf_msg(this->name, GF_LOG_ERROR, -ret,
|
|
- SHARD_MSG_SHARDS_DELETION_FAILED,
|
|
- "Failed to clean up shards of gfid %s",
|
|
- entry->d_name);
|
|
- continue;
|
|
- }
|
|
- gf_msg(this->name, GF_LOG_INFO, 0,
|
|
- SHARD_MSG_SHARD_DELETION_COMPLETED,
|
|
- "Deleted "
|
|
- "shards of gfid=%s from backend",
|
|
- entry->d_name);
|
|
- }
|
|
- gf_dirent_free(&entries);
|
|
- if (ret)
|
|
- break;
|
|
- }
|
|
- }
|
|
- ret = 0;
|
|
- loc_wipe(&loc);
|
|
- return ret;
|
|
-
|
|
-err:
|
|
- LOCK(&priv->lock);
|
|
- {
|
|
- priv->bg_del_state = SHARD_BG_DELETION_NONE;
|
|
- }
|
|
- UNLOCK(&priv->lock);
|
|
- loc_wipe(&loc);
|
|
- return ret;
|
|
-}
|
|
-
|
|
-int
|
|
-shard_unlock_inodelk_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
|
|
- int32_t op_ret, int32_t op_errno, dict_t *xdata)
|
|
-{
|
|
- if (op_ret)
|
|
- gf_msg(this->name, GF_LOG_ERROR, op_errno, SHARD_MSG_FOP_FAILED,
|
|
- "Unlock failed. Please check brick logs for "
|
|
- "more details");
|
|
- SHARD_STACK_DESTROY(frame);
|
|
- return 0;
|
|
-}
|
|
-
|
|
-int
|
|
-shard_unlock_inodelk(call_frame_t *frame, xlator_t *this)
|
|
-{
|
|
- loc_t *loc = NULL;
|
|
- call_frame_t *lk_frame = NULL;
|
|
- shard_local_t *local = NULL;
|
|
- shard_local_t *lk_local = NULL;
|
|
- shard_inodelk_t *lock = NULL;
|
|
-
|
|
- local = frame->local;
|
|
- lk_frame = local->inodelk_frame;
|
|
- lk_local = lk_frame->local;
|
|
- local->inodelk_frame = NULL;
|
|
- loc = &local->int_inodelk.loc;
|
|
- lock = &lk_local->int_inodelk;
|
|
- lock->flock.l_type = F_UNLCK;
|
|
-
|
|
- STACK_WIND(lk_frame, shard_unlock_inodelk_cbk, FIRST_CHILD(this),
|
|
- FIRST_CHILD(this)->fops->inodelk, lock->domain, loc, F_SETLK,
|
|
- &lock->flock, NULL);
|
|
- local->int_inodelk.acquired_lock = _gf_false;
|
|
- return 0;
|
|
-}
|
|
-
|
|
-int
|
|
-shard_rename_src_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
|
|
- int32_t op_ret, int32_t op_errno, struct iatt *buf,
|
|
- struct iatt *preoldparent, struct iatt *postoldparent,
|
|
- struct iatt *prenewparent, struct iatt *postnewparent,
|
|
- dict_t *xdata);
|
|
-int
|
|
-shard_rename_src_base_file(call_frame_t *frame, xlator_t *this)
|
|
-{
|
|
- int ret = 0;
|
|
- loc_t *dst_loc = NULL;
|
|
- loc_t tmp_loc = {
|
|
- 0,
|
|
- };
|
|
- shard_local_t *local = frame->local;
|
|
-
|
|
- if (local->dst_block_size) {
|
|
- tmp_loc.parent = inode_ref(local->loc2.parent);
|
|
- ret = inode_path(tmp_loc.parent, local->loc2.name,
|
|
- (char **)&tmp_loc.path);
|
|
- if (ret < 0) {
|
|
- gf_msg(this->name, GF_LOG_ERROR, 0, SHARD_MSG_INODE_PATH_FAILED,
|
|
- "Inode path failed"
|
|
- " on pargfid=%s bname=%s",
|
|
- uuid_utoa(tmp_loc.parent->gfid), local->loc2.name);
|
|
- local->op_ret = -1;
|
|
- local->op_errno = ENOMEM;
|
|
- goto err;
|
|
- }
|
|
-
|
|
- tmp_loc.name = strrchr(tmp_loc.path, '/');
|
|
- if (tmp_loc.name)
|
|
- tmp_loc.name++;
|
|
- dst_loc = &tmp_loc;
|
|
- } else {
|
|
- dst_loc = &local->loc2;
|
|
- }
|
|
-
|
|
- /* To-Do: Request open-fd count on dst base file */
|
|
- STACK_WIND(frame, shard_rename_src_cbk, FIRST_CHILD(this),
|
|
- FIRST_CHILD(this)->fops->rename, &local->loc, dst_loc,
|
|
- local->xattr_req);
|
|
- loc_wipe(&tmp_loc);
|
|
- return 0;
|
|
-err:
|
|
- loc_wipe(&tmp_loc);
|
|
- shard_common_failure_unwind(local->fop, frame, local->op_ret,
|
|
- local->op_errno);
|
|
- return 0;
|
|
-}
|
|
-
|
|
-int
|
|
-shard_unlink_base_file(call_frame_t *frame, xlator_t *this);
|
|
-
|
|
-int
|
|
-shard_set_size_attrs_on_marker_file_cbk(call_frame_t *frame, void *cookie,
|
|
- xlator_t *this, int32_t op_ret,
|
|
- int32_t op_errno, dict_t *dict,
|
|
- dict_t *xdata)
|
|
-{
|
|
- shard_priv_t *priv = NULL;
|
|
- shard_local_t *local = NULL;
|
|
-
|
|
- priv = this->private;
|
|
- local = frame->local;
|
|
- if (op_ret < 0) {
|
|
- gf_msg(this->name, GF_LOG_ERROR, op_errno, SHARD_MSG_FOP_FAILED,
|
|
- "Xattrop on marker file failed "
|
|
- "while performing %s; entry gfid=%s",
|
|
- gf_fop_string(local->fop), local->newloc.name);
|
|
- goto err;
|
|
- }
|
|
-
|
|
- inode_unlink(local->newloc.inode, priv->dot_shard_rm_inode,
|
|
- local->newloc.name);
|
|
-
|
|
- if (local->fop == GF_FOP_UNLINK)
|
|
- shard_unlink_base_file(frame, this);
|
|
- else if (local->fop == GF_FOP_RENAME)
|
|
- shard_rename_src_base_file(frame, this);
|
|
- return 0;
|
|
-err:
|
|
- shard_common_failure_unwind(local->fop, frame, op_ret, op_errno);
|
|
- return 0;
|
|
-}
|
|
-
|
|
-int
|
|
-shard_set_size_attrs_on_marker_file(call_frame_t *frame, xlator_t *this)
|
|
-{
|
|
- int op_errno = ENOMEM;
|
|
- uint64_t bs = 0;
|
|
- dict_t *xdata = NULL;
|
|
- shard_local_t *local = NULL;
|
|
-
|
|
- local = frame->local;
|
|
- xdata = dict_new();
|
|
- if (!xdata)
|
|
- goto err;
|
|
-
|
|
- if (local->fop == GF_FOP_UNLINK)
|
|
- bs = local->block_size;
|
|
- else if (local->fop == GF_FOP_RENAME)
|
|
- bs = local->dst_block_size;
|
|
- SHARD_INODE_CREATE_INIT(this, bs, xdata, &local->newloc,
|
|
- local->prebuf.ia_size, 0, err);
|
|
- STACK_WIND(frame, shard_set_size_attrs_on_marker_file_cbk,
|
|
- FIRST_CHILD(this), FIRST_CHILD(this)->fops->xattrop,
|
|
- &local->newloc, GF_XATTROP_GET_AND_SET, xdata, NULL);
|
|
- dict_unref(xdata);
|
|
- return 0;
|
|
-err:
|
|
- if (xdata)
|
|
- dict_unref(xdata);
|
|
- shard_common_failure_unwind(local->fop, frame, -1, op_errno);
|
|
- return 0;
|
|
-}
|
|
-
|
|
-int
|
|
-shard_lookup_marker_file_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
|
|
- int32_t op_ret, int32_t op_errno, inode_t *inode,
|
|
- struct iatt *buf, dict_t *xdata,
|
|
- struct iatt *postparent)
|
|
-{
|
|
- inode_t *linked_inode = NULL;
|
|
- shard_priv_t *priv = NULL;
|
|
- shard_local_t *local = NULL;
|
|
-
|
|
- local = frame->local;
|
|
- priv = this->private;
|
|
-
|
|
- if (op_ret < 0) {
|
|
- gf_msg(this->name, GF_LOG_ERROR, op_errno, SHARD_MSG_FOP_FAILED,
|
|
- "Lookup on marker file failed "
|
|
- "while performing %s; entry gfid=%s",
|
|
- gf_fop_string(local->fop), local->newloc.name);
|
|
- goto err;
|
|
- }
|
|
-
|
|
- linked_inode = inode_link(inode, priv->dot_shard_rm_inode,
|
|
- local->newloc.name, buf);
|
|
- inode_unref(local->newloc.inode);
|
|
- local->newloc.inode = linked_inode;
|
|
- shard_set_size_attrs_on_marker_file(frame, this);
|
|
- return 0;
|
|
-err:
|
|
- shard_common_failure_unwind(local->fop, frame, op_ret, op_errno);
|
|
- return 0;
|
|
-}
|
|
-
|
|
-int
|
|
-shard_lookup_marker_file(call_frame_t *frame, xlator_t *this)
|
|
-{
|
|
- int op_errno = ENOMEM;
|
|
- dict_t *xattr_req = NULL;
|
|
- shard_local_t *local = NULL;
|
|
-
|
|
- local = frame->local;
|
|
-
|
|
- xattr_req = shard_create_gfid_dict(local->xattr_req);
|
|
- if (!xattr_req)
|
|
- goto err;
|
|
-
|
|
- STACK_WIND(frame, shard_lookup_marker_file_cbk, FIRST_CHILD(this),
|
|
- FIRST_CHILD(this)->fops->lookup, &local->newloc, xattr_req);
|
|
- dict_unref(xattr_req);
|
|
- return 0;
|
|
-err:
|
|
- shard_common_failure_unwind(local->fop, frame, -1, op_errno);
|
|
- return 0;
|
|
-}
|
|
-
|
|
-int
|
|
-shard_create_marker_file_under_remove_me_cbk(
|
|
- call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret,
|
|
- int32_t op_errno, inode_t *inode, struct iatt *buf, struct iatt *preparent,
|
|
- struct iatt *postparent, dict_t *xdata)
|
|
-{
|
|
- inode_t *linked_inode = NULL;
|
|
- shard_priv_t *priv = NULL;
|
|
- shard_local_t *local = NULL;
|
|
-
|
|
- local = frame->local;
|
|
- priv = this->private;
|
|
-
|
|
- SHARD_UNSET_ROOT_FS_ID(frame, local);
|
|
- if (op_ret < 0) {
|
|
- if ((op_errno != EEXIST) && (op_errno != ENODATA)) {
|
|
- local->op_ret = op_ret;
|
|
- local->op_errno = op_errno;
|
|
- gf_msg(this->name, GF_LOG_ERROR, op_errno, SHARD_MSG_FOP_FAILED,
|
|
- "Marker file creation "
|
|
- "failed while performing %s; entry gfid=%s",
|
|
- gf_fop_string(local->fop), local->newloc.name);
|
|
- goto err;
|
|
- } else {
|
|
- shard_lookup_marker_file(frame, this);
|
|
- return 0;
|
|
- }
|
|
- }
|
|
-
|
|
- linked_inode = inode_link(inode, priv->dot_shard_rm_inode,
|
|
- local->newloc.name, buf);
|
|
- inode_unref(local->newloc.inode);
|
|
- local->newloc.inode = linked_inode;
|
|
-
|
|
- if (local->fop == GF_FOP_UNLINK)
|
|
- shard_unlink_base_file(frame, this);
|
|
- else if (local->fop == GF_FOP_RENAME)
|
|
- shard_rename_src_base_file(frame, this);
|
|
- return 0;
|
|
-err:
|
|
- shard_common_failure_unwind(local->fop, frame, -1, local->op_errno);
|
|
- return 0;
|
|
-}
|
|
-
|
|
-int
|
|
-shard_create_marker_file_under_remove_me(call_frame_t *frame, xlator_t *this,
|
|
- loc_t *loc)
|
|
-{
|
|
- int ret = 0;
|
|
- int op_errno = ENOMEM;
|
|
- uint64_t bs = 0;
|
|
- char g1[64] = {
|
|
- 0,
|
|
- };
|
|
- char g2[64] = {
|
|
- 0,
|
|
- };
|
|
- dict_t *xattr_req = NULL;
|
|
- shard_priv_t *priv = NULL;
|
|
- shard_local_t *local = NULL;
|
|
-
|
|
- priv = this->private;
|
|
- local = frame->local;
|
|
-
|
|
- SHARD_SET_ROOT_FS_ID(frame, local);
|
|
-
|
|
- xattr_req = shard_create_gfid_dict(local->xattr_req);
|
|
- if (!xattr_req)
|
|
- goto err;
|
|
-
|
|
- local->newloc.inode = inode_new(this->itable);
|
|
- local->newloc.parent = inode_ref(priv->dot_shard_rm_inode);
|
|
- ret = inode_path(local->newloc.parent, uuid_utoa(loc->inode->gfid),
|
|
- (char **)&local->newloc.path);
|
|
- if (ret < 0) {
|
|
- gf_msg(this->name, GF_LOG_ERROR, 0, SHARD_MSG_INODE_PATH_FAILED,
|
|
- "Inode path failed on "
|
|
- "pargfid=%s bname=%s",
|
|
- uuid_utoa_r(priv->dot_shard_rm_gfid, g1),
|
|
- uuid_utoa_r(loc->inode->gfid, g2));
|
|
- goto err;
|
|
- }
|
|
- local->newloc.name = strrchr(local->newloc.path, '/');
|
|
- if (local->newloc.name)
|
|
- local->newloc.name++;
|
|
-
|
|
- if (local->fop == GF_FOP_UNLINK)
|
|
- bs = local->block_size;
|
|
- else if (local->fop == GF_FOP_RENAME)
|
|
- bs = local->dst_block_size;
|
|
-
|
|
- SHARD_INODE_CREATE_INIT(this, bs, xattr_req, &local->newloc,
|
|
- local->prebuf.ia_size, 0, err);
|
|
-
|
|
- STACK_WIND(frame, shard_create_marker_file_under_remove_me_cbk,
|
|
- FIRST_CHILD(this), FIRST_CHILD(this)->fops->mknod,
|
|
- &local->newloc, 0, 0, 0644, xattr_req);
|
|
- dict_unref(xattr_req);
|
|
- return 0;
|
|
-
|
|
-err:
|
|
- if (xattr_req)
|
|
- dict_unref(xattr_req);
|
|
- shard_create_marker_file_under_remove_me_cbk(frame, 0, this, -1, op_errno,
|
|
- NULL, NULL, NULL, NULL, NULL);
|
|
- return 0;
|
|
-}
|
|
-
|
|
-int
|
|
-shard_unlock_entrylk(call_frame_t *frame, xlator_t *this);
|
|
-
|
|
-int
|
|
-shard_unlink_base_file_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
|
|
- int32_t op_ret, int32_t op_errno,
|
|
- struct iatt *preparent, struct iatt *postparent,
|
|
- dict_t *xdata)
|
|
-{
|
|
- int ret = 0;
|
|
- shard_local_t *local = NULL;
|
|
-
|
|
- local = frame->local;
|
|
-
|
|
- if (op_ret < 0) {
|
|
- local->op_ret = op_ret;
|
|
- local->op_errno = op_errno;
|
|
- } else {
|
|
- local->preoldparent = *preparent;
|
|
- local->postoldparent = *postparent;
|
|
- if (xdata)
|
|
- local->xattr_rsp = dict_ref(xdata);
|
|
- if (local->cleanup_required)
|
|
- shard_start_background_deletion(this);
|
|
- }
|
|
-
|
|
- if (local->entrylk_frame) {
|
|
- ret = shard_unlock_entrylk(frame, this);
|
|
- if (ret < 0) {
|
|
- local->op_ret = -1;
|
|
- local->op_errno = -ret;
|
|
- }
|
|
- }
|
|
-
|
|
- ret = shard_unlock_inodelk(frame, this);
|
|
- if (ret < 0) {
|
|
- local->op_ret = -1;
|
|
- local->op_errno = -ret;
|
|
- }
|
|
-
|
|
- shard_unlink_cbk(frame, this);
|
|
- return 0;
|
|
-}
|
|
-
|
|
-int
|
|
-shard_unlink_base_file(call_frame_t *frame, xlator_t *this)
|
|
-{
|
|
- shard_local_t *local = frame->local;
|
|
-
|
|
- /* To-Do: Request open-fd count on base file */
|
|
- STACK_WIND(frame, shard_unlink_base_file_cbk, FIRST_CHILD(this),
|
|
- FIRST_CHILD(this)->fops->unlink, &local->loc, local->xflag,
|
|
- local->xattr_req);
|
|
- return 0;
|
|
-}
|
|
-
|
|
-int
|
|
-shard_unlock_entrylk_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
|
|
- int32_t op_ret, int32_t op_errno, dict_t *xdata)
|
|
-{
|
|
- if (op_ret)
|
|
- gf_msg(this->name, GF_LOG_ERROR, op_errno, SHARD_MSG_FOP_FAILED,
|
|
- "Unlock failed. Please check brick logs for "
|
|
- "more details");
|
|
- SHARD_STACK_DESTROY(frame);
|
|
- return 0;
|
|
-}
|
|
-
|
|
-int
|
|
-shard_unlock_entrylk(call_frame_t *frame, xlator_t *this)
|
|
-{
|
|
- loc_t *loc = NULL;
|
|
- call_frame_t *lk_frame = NULL;
|
|
- shard_local_t *local = NULL;
|
|
- shard_local_t *lk_local = NULL;
|
|
- shard_entrylk_t *lock = NULL;
|
|
-
|
|
- local = frame->local;
|
|
- lk_frame = local->entrylk_frame;
|
|
- lk_local = lk_frame->local;
|
|
- local->entrylk_frame = NULL;
|
|
- lock = &lk_local->int_entrylk;
|
|
- loc = &lock->loc;
|
|
-
|
|
- STACK_WIND(lk_frame, shard_unlock_entrylk_cbk, FIRST_CHILD(this),
|
|
- FIRST_CHILD(this)->fops->entrylk, this->name, loc,
|
|
- lk_local->int_entrylk.basename, ENTRYLK_UNLOCK, ENTRYLK_WRLCK,
|
|
- NULL);
|
|
- local->int_entrylk.acquired_lock = _gf_false;
|
|
- return 0;
|
|
-}
|
|
-
|
|
-int
|
|
-shard_post_entrylk_fop_handler(call_frame_t *frame, xlator_t *this)
|
|
-{
|
|
- shard_local_t *local = NULL;
|
|
-
|
|
- local = frame->local;
|
|
-
|
|
- switch (local->fop) {
|
|
- case GF_FOP_UNLINK:
|
|
- case GF_FOP_RENAME:
|
|
- shard_create_marker_file_under_remove_me(frame, this,
|
|
- &local->int_inodelk.loc);
|
|
- break;
|
|
- default:
|
|
- gf_msg(this->name, GF_LOG_WARNING, 0, SHARD_MSG_INVALID_FOP,
|
|
- "post-entrylk handler not defined. This case should not"
|
|
- " be hit");
|
|
- break;
|
|
- }
|
|
- return 0;
|
|
-}
|
|
-
|
|
-int
|
|
-shard_acquire_entrylk_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
|
|
- int32_t op_ret, int32_t op_errno, dict_t *xdata)
|
|
-{
|
|
- call_frame_t *main_frame = NULL;
|
|
- shard_local_t *local = NULL;
|
|
- shard_local_t *main_local = NULL;
|
|
-
|
|
- local = frame->local;
|
|
- main_frame = local->main_frame;
|
|
- main_local = main_frame->local;
|
|
-
|
|
- if (local->op_ret < 0) {
|
|
- shard_common_failure_unwind(main_local->fop, main_frame, op_ret,
|
|
- op_errno);
|
|
- return 0;
|
|
- }
|
|
- main_local->int_entrylk.acquired_lock = _gf_true;
|
|
- shard_post_entrylk_fop_handler(main_frame, this);
|
|
- return 0;
|
|
-}
|
|
-
|
|
-int
|
|
-shard_acquire_entrylk(call_frame_t *frame, xlator_t *this, inode_t *inode,
|
|
- uuid_t gfid)
|
|
-{
|
|
- char gfid_str[GF_UUID_BUF_SIZE] = {
|
|
- 0,
|
|
- };
|
|
- shard_local_t *local = NULL;
|
|
- shard_local_t *entrylk_local = NULL;
|
|
- shard_entrylk_t *int_entrylk = NULL;
|
|
- call_frame_t *entrylk_frame = NULL;
|
|
-
|
|
- local = frame->local;
|
|
- entrylk_frame = create_frame(this, this->ctx->pool);
|
|
- if (!entrylk_frame) {
|
|
- gf_msg(this->name, GF_LOG_WARNING, ENOMEM, SHARD_MSG_MEMALLOC_FAILED,
|
|
- "Failed to create new frame "
|
|
- "to lock marker file");
|
|
- goto err;
|
|
- }
|
|
-
|
|
- entrylk_local = mem_get0(this->local_pool);
|
|
- if (!entrylk_local) {
|
|
- STACK_DESTROY(entrylk_frame->root);
|
|
- goto err;
|
|
- }
|
|
-
|
|
- entrylk_frame->local = entrylk_local;
|
|
- entrylk_local->main_frame = frame;
|
|
- int_entrylk = &entrylk_local->int_entrylk;
|
|
-
|
|
- int_entrylk->loc.inode = inode_ref(inode);
|
|
- set_lk_owner_from_ptr(&entrylk_frame->root->lk_owner, entrylk_frame->root);
|
|
- local->entrylk_frame = entrylk_frame;
|
|
- gf_uuid_unparse(gfid, gfid_str);
|
|
- int_entrylk->basename = gf_strdup(gfid_str);
|
|
-
|
|
- STACK_WIND(entrylk_frame, shard_acquire_entrylk_cbk, FIRST_CHILD(this),
|
|
- FIRST_CHILD(this)->fops->entrylk, this->name, &int_entrylk->loc,
|
|
- int_entrylk->basename, ENTRYLK_LOCK, ENTRYLK_WRLCK, NULL);
|
|
- return 0;
|
|
-err:
|
|
- shard_common_failure_unwind(local->fop, frame, -1, ENOMEM);
|
|
- return 0;
|
|
-}
|
|
-
|
|
-int
|
|
-shard_post_lookup_base_shard_rm_handler(call_frame_t *frame, xlator_t *this)
|
|
-{
|
|
- shard_local_t *local = NULL;
|
|
- shard_priv_t *priv = NULL;
|
|
-
|
|
- priv = this->private;
|
|
- local = frame->local;
|
|
-
|
|
- if (local->op_ret < 0) {
|
|
- shard_common_failure_unwind(local->fop, frame, -1, local->op_errno);
|
|
- return 0;
|
|
- }
|
|
-
|
|
- if (local->prebuf.ia_nlink > 1) {
|
|
- gf_msg_debug(this->name, 0,
|
|
- "link count on %s > 1:%d, "
|
|
- "performing rename()/unlink()",
|
|
- local->int_inodelk.loc.path, local->prebuf.ia_nlink);
|
|
- if (local->fop == GF_FOP_RENAME)
|
|
- shard_rename_src_base_file(frame, this);
|
|
- else if (local->fop == GF_FOP_UNLINK)
|
|
- shard_unlink_base_file(frame, this);
|
|
- } else {
|
|
- gf_msg_debug(this->name, 0,
|
|
- "link count on %s = 1, creating "
|
|
- "file under .remove_me",
|
|
- local->int_inodelk.loc.path);
|
|
- local->cleanup_required = _gf_true;
|
|
- shard_acquire_entrylk(frame, this, priv->dot_shard_rm_inode,
|
|
- local->prebuf.ia_gfid);
|
|
- }
|
|
- return 0;
|
|
-}
|
|
-
|
|
-int
|
|
-shard_post_inodelk_fop_handler(call_frame_t *frame, xlator_t *this)
|
|
-{
|
|
- shard_local_t *local = NULL;
|
|
-
|
|
- local = frame->local;
|
|
-
|
|
- switch (local->fop) {
|
|
- case GF_FOP_UNLINK:
|
|
- case GF_FOP_RENAME:
|
|
- shard_lookup_base_file(frame, this, &local->int_inodelk.loc,
|
|
- shard_post_lookup_base_shard_rm_handler);
|
|
- break;
|
|
- default:
|
|
- gf_msg(this->name, GF_LOG_WARNING, 0, SHARD_MSG_INVALID_FOP,
|
|
- "post-inodelk handler not defined. This case should not"
|
|
- " be hit");
|
|
- break;
|
|
- }
|
|
- return 0;
|
|
-}
|
|
-
|
|
-int
|
|
-shard_acquire_inodelk_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
|
|
- int32_t op_ret, int32_t op_errno, dict_t *xdata)
|
|
-{
|
|
- call_frame_t *main_frame = NULL;
|
|
- shard_local_t *local = NULL;
|
|
- shard_local_t *main_local = NULL;
|
|
-
|
|
- local = frame->local;
|
|
- main_frame = local->main_frame;
|
|
- main_local = main_frame->local;
|
|
-
|
|
- if (local->op_ret < 0) {
|
|
- shard_common_failure_unwind(main_local->fop, main_frame, op_ret,
|
|
- op_errno);
|
|
- return 0;
|
|
- }
|
|
- main_local->int_inodelk.acquired_lock = _gf_true;
|
|
- shard_post_inodelk_fop_handler(main_frame, this);
|
|
- return 0;
|
|
-}
|
|
-
|
|
-int
|
|
-shard_acquire_inodelk(call_frame_t *frame, xlator_t *this, loc_t *loc)
|
|
-{
|
|
- call_frame_t *lk_frame = NULL;
|
|
- shard_local_t *local = NULL;
|
|
- shard_local_t *lk_local = NULL;
|
|
- shard_inodelk_t *int_inodelk = NULL;
|
|
-
|
|
- local = frame->local;
|
|
- lk_frame = create_frame(this, this->ctx->pool);
|
|
- if (!lk_frame) {
|
|
- gf_msg(this->name, GF_LOG_WARNING, ENOMEM, SHARD_MSG_MEMALLOC_FAILED,
|
|
- "Failed to create new frame "
|
|
- "to lock base shard");
|
|
- goto err;
|
|
- }
|
|
- lk_local = mem_get0(this->local_pool);
|
|
- if (!lk_local) {
|
|
- STACK_DESTROY(lk_frame->root);
|
|
- goto err;
|
|
- }
|
|
-
|
|
- lk_frame->local = lk_local;
|
|
- lk_local->main_frame = frame;
|
|
- int_inodelk = &lk_local->int_inodelk;
|
|
-
|
|
- int_inodelk->flock.l_len = 0;
|
|
- int_inodelk->flock.l_start = 0;
|
|
- int_inodelk->domain = this->name;
|
|
- int_inodelk->flock.l_type = F_WRLCK;
|
|
- loc_copy(&local->int_inodelk.loc, loc);
|
|
- set_lk_owner_from_ptr(&lk_frame->root->lk_owner, lk_frame->root);
|
|
- local->inodelk_frame = lk_frame;
|
|
-
|
|
- STACK_WIND(lk_frame, shard_acquire_inodelk_cbk, FIRST_CHILD(this),
|
|
- FIRST_CHILD(this)->fops->inodelk, int_inodelk->domain,
|
|
- &local->int_inodelk.loc, F_SETLKW, &int_inodelk->flock, NULL);
|
|
- return 0;
|
|
-err:
|
|
- shard_common_failure_unwind(local->fop, frame, -1, ENOMEM);
|
|
- return 0;
|
|
-}
|
|
-
|
|
-int
|
|
-shard_post_mkdir_rm_handler(call_frame_t *frame, xlator_t *this)
|
|
-{
|
|
- loc_t *loc = NULL;
|
|
- shard_local_t *local = NULL;
|
|
-
|
|
- local = frame->local;
|
|
-
|
|
- if (local->op_ret < 0) {
|
|
- shard_common_failure_unwind(local->fop, frame, -1, local->op_errno);
|
|
- return 0;
|
|
- }
|
|
- if (local->fop == GF_FOP_UNLINK)
|
|
- loc = &local->loc;
|
|
- else if (local->fop == GF_FOP_RENAME)
|
|
- loc = &local->loc2;
|
|
- shard_acquire_inodelk(frame, this, loc);
|
|
- return 0;
|
|
-}
|
|
-
|
|
-int
|
|
-shard_mkdir_internal_dir(call_frame_t *frame, xlator_t *this,
|
|
- shard_post_resolve_fop_handler_t handler,
|
|
- shard_internal_dir_type_t type);
|
|
-int
|
|
-shard_pre_mkdir_rm_handler(call_frame_t *frame, xlator_t *this)
|
|
-{
|
|
- shard_local_t *local = NULL;
|
|
-
|
|
- local = frame->local;
|
|
-
|
|
- if (local->op_ret < 0) {
|
|
- shard_common_failure_unwind(local->fop, frame, -1, local->op_errno);
|
|
- return 0;
|
|
- }
|
|
- shard_mkdir_internal_dir(frame, this, shard_post_mkdir_rm_handler,
|
|
- SHARD_INTERNAL_DIR_DOT_SHARD_REMOVE_ME);
|
|
- return 0;
|
|
-}
|
|
-
|
|
-void
|
|
-shard_begin_rm_resolution(call_frame_t *frame, xlator_t *this)
|
|
-{
|
|
- shard_priv_t *priv = NULL;
|
|
- shard_local_t *local = NULL;
|
|
-
|
|
- priv = this->private;
|
|
- local = frame->local;
|
|
-
|
|
- local->dot_shard_rm_loc.inode = inode_find(this->itable,
|
|
- priv->dot_shard_rm_gfid);
|
|
- if (!local->dot_shard_rm_loc.inode) {
|
|
- local->dot_shard_loc.inode = inode_find(this->itable,
|
|
- priv->dot_shard_gfid);
|
|
- if (!local->dot_shard_loc.inode) {
|
|
- shard_mkdir_internal_dir(frame, this, shard_pre_mkdir_rm_handler,
|
|
- SHARD_INTERNAL_DIR_DOT_SHARD);
|
|
- } else {
|
|
- local->post_res_handler = shard_pre_mkdir_rm_handler;
|
|
- shard_refresh_internal_dir(frame, this,
|
|
- SHARD_INTERNAL_DIR_DOT_SHARD);
|
|
- }
|
|
- } else {
|
|
- local->post_res_handler = shard_post_mkdir_rm_handler;
|
|
- shard_refresh_internal_dir(frame, this,
|
|
- SHARD_INTERNAL_DIR_DOT_SHARD_REMOVE_ME);
|
|
- }
|
|
-}
|
|
-
|
|
-int
|
|
-shard_unlink(call_frame_t *frame, xlator_t *this, loc_t *loc, int xflag,
|
|
- dict_t *xdata)
|
|
-{
|
|
- int ret = -1;
|
|
- uint64_t block_size = 0;
|
|
- shard_local_t *local = NULL;
|
|
-
|
|
- ret = shard_inode_ctx_get_block_size(loc->inode, this, &block_size);
|
|
- if ((ret) && (!IA_ISLNK(loc->inode->ia_type))) {
|
|
- gf_msg(this->name, GF_LOG_ERROR, 0, SHARD_MSG_INODE_CTX_GET_FAILED,
|
|
- "Failed to get block "
|
|
- "size from inode ctx of %s",
|
|
- uuid_utoa(loc->inode->gfid));
|
|
- goto err;
|
|
- }
|
|
-
|
|
- if (!block_size || frame->root->pid == GF_CLIENT_PID_GSYNCD) {
|
|
- STACK_WIND(frame, default_unlink_cbk, FIRST_CHILD(this),
|
|
- FIRST_CHILD(this)->fops->unlink, loc, xflag, xdata);
|
|
- return 0;
|
|
- }
|
|
-
|
|
- local = mem_get0(this->local_pool);
|
|
- if (!local)
|
|
- goto err;
|
|
-
|
|
- frame->local = local;
|
|
-
|
|
- loc_copy(&local->loc, loc);
|
|
- local->xflag = xflag;
|
|
- local->xattr_req = (xdata) ? dict_ref(xdata) : dict_new();
|
|
- local->block_size = block_size;
|
|
- local->resolver_base_inode = loc->inode;
|
|
- local->fop = GF_FOP_UNLINK;
|
|
- if (!this->itable)
|
|
- this->itable = (local->loc.inode)->table;
|
|
-
|
|
- local->resolve_not = _gf_true;
|
|
- shard_begin_rm_resolution(frame, this);
|
|
- return 0;
|
|
-err:
|
|
- shard_common_failure_unwind(GF_FOP_UNLINK, frame, -1, ENOMEM);
|
|
- return 0;
|
|
-}
|
|
-
|
|
-int
|
|
-shard_post_rename_lookup_handler(call_frame_t *frame, xlator_t *this)
|
|
-{
|
|
- shard_rename_cbk(frame, this);
|
|
- return 0;
|
|
-}
|
|
-
|
|
-int
|
|
-shard_rename_src_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
|
|
- int32_t op_ret, int32_t op_errno, struct iatt *buf,
|
|
- struct iatt *preoldparent, struct iatt *postoldparent,
|
|
- struct iatt *prenewparent, struct iatt *postnewparent,
|
|
- dict_t *xdata)
|
|
-{
|
|
- int ret = 0;
|
|
- shard_local_t *local = NULL;
|
|
-
|
|
- local = frame->local;
|
|
-
|
|
- if (op_ret < 0) {
|
|
- local->op_ret = op_ret;
|
|
- local->op_errno = op_errno;
|
|
- goto err;
|
|
- }
|
|
- /* Set ctx->refresh to TRUE to force a lookup on disk when
|
|
- * shard_lookup_base_file() is called next to refresh the hard link
|
|
- * count in ctx. Note that this is applicable only to the case where
|
|
- * the rename dst is already existent and sharded.
|
|
- */
|
|
- if ((local->dst_block_size) && (!local->cleanup_required))
|
|
- shard_inode_ctx_set_refresh_flag(local->int_inodelk.loc.inode, this);
|
|
-
|
|
- local->prebuf = *buf;
|
|
- local->preoldparent = *preoldparent;
|
|
- local->postoldparent = *postoldparent;
|
|
- local->prenewparent = *prenewparent;
|
|
- local->postnewparent = *postnewparent;
|
|
- if (xdata)
|
|
- local->xattr_rsp = dict_ref(xdata);
|
|
-
|
|
- if (local->dst_block_size) {
|
|
- if (local->entrylk_frame) {
|
|
- ret = shard_unlock_entrylk(frame, this);
|
|
- if (ret < 0) {
|
|
- local->op_ret = -1;
|
|
- local->op_errno = -ret;
|
|
- }
|
|
- }
|
|
-
|
|
- ret = shard_unlock_inodelk(frame, this);
|
|
- if (ret < 0) {
|
|
- local->op_ret = -1;
|
|
- local->op_errno = -ret;
|
|
- goto err;
|
|
- }
|
|
- if (local->cleanup_required)
|
|
- shard_start_background_deletion(this);
|
|
- }
|
|
-
|
|
- /* Now the base file of src, if sharded, is looked up to gather ia_size
|
|
- * and ia_blocks.*/
|
|
- if (local->block_size) {
|
|
- local->tmp_loc.inode = inode_new(this->itable);
|
|
- gf_uuid_copy(local->tmp_loc.gfid, (local->loc.inode)->gfid);
|
|
- shard_lookup_base_file(frame, this, &local->tmp_loc,
|
|
- shard_post_rename_lookup_handler);
|
|
- } else {
|
|
- shard_rename_cbk(frame, this);
|
|
- }
|
|
- return 0;
|
|
-err:
|
|
- shard_common_failure_unwind(local->fop, frame, local->op_ret,
|
|
- local->op_errno);
|
|
- return 0;
|
|
-}
|
|
-
|
|
-int
|
|
-shard_post_lookup_dst_base_file_handler(call_frame_t *frame, xlator_t *this)
|
|
-{
|
|
- shard_local_t *local = NULL;
|
|
-
|
|
- local = frame->local;
|
|
-
|
|
- if (local->op_ret < 0) {
|
|
- shard_common_failure_unwind(local->fop, frame, local->op_ret,
|
|
- local->op_errno);
|
|
- return 0;
|
|
- }
|
|
-
|
|
- /* Save dst base file attributes into postbuf so the information is not
|
|
- * lost when it is overwritten after lookup on base file of src in
|
|
- * shard_lookup_base_file_cbk().
|
|
- */
|
|
- local->postbuf = local->prebuf;
|
|
- shard_rename_src_base_file(frame, this);
|
|
- return 0;
|
|
-}
|
|
-
|
|
-int
|
|
-shard_rename(call_frame_t *frame, xlator_t *this, loc_t *oldloc, loc_t *newloc,
|
|
- dict_t *xdata)
|
|
-{
|
|
- int ret = -1;
|
|
- uint64_t block_size = 0;
|
|
- uint64_t dst_block_size = 0;
|
|
- shard_local_t *local = NULL;
|
|
-
|
|
- if (IA_ISDIR(oldloc->inode->ia_type)) {
|
|
- STACK_WIND(frame, default_rename_cbk, FIRST_CHILD(this),
|
|
- FIRST_CHILD(this)->fops->rename, oldloc, newloc, xdata);
|
|
- return 0;
|
|
- }
|
|
-
|
|
- ret = shard_inode_ctx_get_block_size(oldloc->inode, this, &block_size);
|
|
- if ((ret) && (!IA_ISLNK(oldloc->inode->ia_type))) {
|
|
- gf_msg(this->name, GF_LOG_ERROR, 0, SHARD_MSG_INODE_CTX_GET_FAILED,
|
|
- "Failed to get block "
|
|
- "size from inode ctx of %s",
|
|
- uuid_utoa(oldloc->inode->gfid));
|
|
- goto err;
|
|
- }
|
|
-
|
|
- if (newloc->inode)
|
|
- ret = shard_inode_ctx_get_block_size(newloc->inode, this,
|
|
- &dst_block_size);
|
|
-
|
|
- /* The following stack_wind covers the case where:
|
|
- * a. the src file is not sharded and dst doesn't exist, OR
|
|
- * b. the src and dst both exist but are not sharded.
|
|
- */
|
|
- if (((!block_size) && (!dst_block_size)) ||
|
|
- frame->root->pid == GF_CLIENT_PID_GSYNCD) {
|
|
- STACK_WIND(frame, default_rename_cbk, FIRST_CHILD(this),
|
|
- FIRST_CHILD(this)->fops->rename, oldloc, newloc, xdata);
|
|
- return 0;
|
|
- }
|
|
-
|
|
- local = mem_get0(this->local_pool);
|
|
- if (!local)
|
|
- goto err;
|
|
-
|
|
- frame->local = local;
|
|
- loc_copy(&local->loc, oldloc);
|
|
- loc_copy(&local->loc2, newloc);
|
|
- local->resolver_base_inode = newloc->inode;
|
|
- local->fop = GF_FOP_RENAME;
|
|
- local->xattr_req = (xdata) ? dict_ref(xdata) : dict_new();
|
|
- if (!local->xattr_req)
|
|
- goto err;
|
|
-
|
|
- local->block_size = block_size;
|
|
- local->dst_block_size = dst_block_size;
|
|
- if (!this->itable)
|
|
- this->itable = (local->loc.inode)->table;
|
|
- local->resolve_not = _gf_true;
|
|
-
|
|
- /* The following if-block covers the case where the dst file exists
|
|
- * and is sharded.
|
|
- */
|
|
- if (local->dst_block_size) {
|
|
- shard_begin_rm_resolution(frame, this);
|
|
- } else {
|
|
- /* The following block covers the case where the dst either doesn't
|
|
- * exist or is NOT sharded but the src is sharded. In this case, shard
|
|
- * xlator would go ahead and rename src to dst. Once done, it would also
|
|
- * lookup the base shard of src to get the ia_size and ia_blocks xattr
|
|
- * values.
|
|
- */
|
|
- shard_rename_src_base_file(frame, this);
|
|
- }
|
|
- return 0;
|
|
-
|
|
-err:
|
|
- shard_common_failure_unwind(GF_FOP_RENAME, frame, -1, ENOMEM);
|
|
- return 0;
|
|
-}
|
|
-
|
|
-int
|
|
-shard_create_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
|
|
- int32_t op_ret, int32_t op_errno, fd_t *fd, inode_t *inode,
|
|
- struct iatt *stbuf, struct iatt *preparent,
|
|
- struct iatt *postparent, dict_t *xdata)
|
|
-{
|
|
- int ret = -1;
|
|
- shard_local_t *local = NULL;
|
|
-
|
|
- local = frame->local;
|
|
-
|
|
- if (op_ret == -1)
|
|
- goto unwind;
|
|
-
|
|
- ret = shard_inode_ctx_set(inode, this, stbuf, local->block_size,
|
|
- SHARD_ALL_MASK);
|
|
- if (ret)
|
|
- gf_msg(this->name, GF_LOG_WARNING, 0, SHARD_MSG_INODE_CTX_SET_FAILED,
|
|
- "Failed to set inode "
|
|
- "ctx for %s",
|
|
- uuid_utoa(inode->gfid));
|
|
-
|
|
-unwind:
|
|
- SHARD_STACK_UNWIND(create, frame, op_ret, op_errno, fd, inode, stbuf,
|
|
- preparent, postparent, xdata);
|
|
- return 0;
|
|
-}
|
|
-
|
|
-int
|
|
-shard_create(call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags,
|
|
- mode_t mode, mode_t umask, fd_t *fd, dict_t *xdata)
|
|
-{
|
|
- shard_priv_t *priv = NULL;
|
|
- shard_local_t *local = NULL;
|
|
-
|
|
- priv = this->private;
|
|
- local = mem_get0(this->local_pool);
|
|
- if (!local)
|
|
- goto err;
|
|
-
|
|
- frame->local = local;
|
|
- local->block_size = priv->block_size;
|
|
-
|
|
- if (!__is_gsyncd_on_shard_dir(frame, loc)) {
|
|
- SHARD_INODE_CREATE_INIT(this, local->block_size, xdata, loc, 0, 0, err);
|
|
- }
|
|
-
|
|
- STACK_WIND(frame, shard_create_cbk, FIRST_CHILD(this),
|
|
- FIRST_CHILD(this)->fops->create, loc, flags, mode, umask, fd,
|
|
- xdata);
|
|
- return 0;
|
|
-err:
|
|
- shard_common_failure_unwind(GF_FOP_CREATE, frame, -1, ENOMEM);
|
|
- return 0;
|
|
-}
|
|
-
|
|
-int
|
|
-shard_open_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
|
|
- int32_t op_ret, int32_t op_errno, fd_t *fd, dict_t *xdata)
|
|
-{
|
|
- /* To-Do: Handle open with O_TRUNC under locks */
|
|
- SHARD_STACK_UNWIND(open, frame, op_ret, op_errno, fd, xdata);
|
|
- return 0;
|
|
-}
|
|
-
|
|
-int
|
|
-shard_open(call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags,
|
|
- fd_t *fd, dict_t *xdata)
|
|
-{
|
|
- STACK_WIND(frame, shard_open_cbk, FIRST_CHILD(this),
|
|
- FIRST_CHILD(this)->fops->open, loc, flags, fd, xdata);
|
|
- return 0;
|
|
-}
|
|
-
|
|
-int
|
|
-shard_readv_do_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
|
|
- int32_t op_ret, int32_t op_errno, struct iovec *vector,
|
|
- int32_t count, struct iatt *stbuf, struct iobref *iobref,
|
|
- dict_t *xdata)
|
|
-{
|
|
- int i = 0;
|
|
- int call_count = 0;
|
|
- void *address = NULL;
|
|
- uint64_t block_num = 0;
|
|
- off_t off = 0;
|
|
- struct iovec vec = {
|
|
- 0,
|
|
- };
|
|
- shard_local_t *local = NULL;
|
|
- fd_t *anon_fd = cookie;
|
|
- shard_inode_ctx_t *ctx = NULL;
|
|
-
|
|
- local = frame->local;
|
|
-
|
|
- /* If shard has already seen a failure here before, there is no point
|
|
- * in aggregating subsequent reads, so just go to out.
|
|
- */
|
|
- if (local->op_ret < 0)
|
|
- goto out;
|
|
-
|
|
- if (op_ret < 0) {
|
|
- local->op_ret = op_ret;
|
|
- local->op_errno = op_errno;
|
|
- goto out;
|
|
- }
|
|
-
|
|
- if (local->op_ret >= 0)
|
|
- local->op_ret += op_ret;
|
|
-
|
|
- shard_inode_ctx_get(anon_fd->inode, this, &ctx);
|
|
- block_num = ctx->block_num;
|
|
-
|
|
- if (block_num == local->first_block) {
|
|
- address = local->iobuf->ptr;
|
|
- } else {
|
|
- /* else
|
|
- * address to start writing to = beginning of buffer +
|
|
- * number of bytes until end of first block +
|
|
- * + block_size times number of blocks
|
|
- * between the current block and the first
|
|
- */
|
|
- address = (char *)local->iobuf->ptr +
|
|
- (local->block_size - (local->offset % local->block_size)) +
|
|
- ((block_num - local->first_block - 1) * local->block_size);
|
|
- }
|
|
-
|
|
- for (i = 0; i < count; i++) {
|
|
- address = (char *)address + off;
|
|
- memcpy(address, vector[i].iov_base, vector[i].iov_len);
|
|
- off += vector[i].iov_len;
|
|
- }
|
|
-
|
|
-out:
|
|
- if (anon_fd)
|
|
- fd_unref(anon_fd);
|
|
- call_count = shard_call_count_return(frame);
|
|
- if (call_count == 0) {
|
|
- SHARD_UNSET_ROOT_FS_ID(frame, local);
|
|
- if (local->op_ret < 0) {
|
|
- shard_common_failure_unwind(GF_FOP_READ, frame, local->op_ret,
|
|
- local->op_errno);
|
|
- } else {
|
|
- if (xdata)
|
|
- local->xattr_rsp = dict_ref(xdata);
|
|
- vec.iov_base = local->iobuf->ptr;
|
|
- vec.iov_len = local->total_size;
|
|
- local->op_ret = local->total_size;
|
|
- SHARD_STACK_UNWIND(readv, frame, local->op_ret, local->op_errno,
|
|
- &vec, 1, &local->prebuf, local->iobref,
|
|
- local->xattr_rsp);
|
|
- return 0;
|
|
- }
|
|
- }
|
|
-
|
|
- return 0;
|
|
-}
|
|
-
|
|
-int
|
|
-shard_readv_do(call_frame_t *frame, xlator_t *this)
|
|
-{
|
|
- int i = 0;
|
|
- int call_count = 0;
|
|
- int last_block = 0;
|
|
- int cur_block = 0;
|
|
- off_t orig_offset = 0;
|
|
- off_t shard_offset = 0;
|
|
- size_t read_size = 0;
|
|
- size_t remaining_size = 0;
|
|
- fd_t *fd = NULL;
|
|
- fd_t *anon_fd = NULL;
|
|
- shard_local_t *local = NULL;
|
|
- gf_boolean_t wind_failed = _gf_false;
|
|
-
|
|
- local = frame->local;
|
|
- fd = local->fd;
|
|
-
|
|
- orig_offset = local->offset;
|
|
- cur_block = local->first_block;
|
|
- last_block = local->last_block;
|
|
- remaining_size = local->total_size;
|
|
- local->call_count = call_count = local->num_blocks;
|
|
-
|
|
- SHARD_SET_ROOT_FS_ID(frame, local);
|
|
-
|
|
- if (fd->flags & O_DIRECT)
|
|
- local->flags = O_DIRECT;
|
|
-
|
|
- while (cur_block <= last_block) {
|
|
- if (wind_failed) {
|
|
- shard_readv_do_cbk(frame, (void *)(long)0, this, -1, ENOMEM, NULL,
|
|
- 0, NULL, NULL, NULL);
|
|
- goto next;
|
|
- }
|
|
-
|
|
- shard_offset = orig_offset % local->block_size;
|
|
- read_size = local->block_size - shard_offset;
|
|
- if (read_size > remaining_size)
|
|
- read_size = remaining_size;
|
|
-
|
|
- remaining_size -= read_size;
|
|
-
|
|
- if (cur_block == 0) {
|
|
- anon_fd = fd_ref(fd);
|
|
- } else {
|
|
- anon_fd = fd_anonymous(local->inode_list[i]);
|
|
- if (!anon_fd) {
|
|
- local->op_ret = -1;
|
|
- local->op_errno = ENOMEM;
|
|
- wind_failed = _gf_true;
|
|
- shard_readv_do_cbk(frame, (void *)(long)anon_fd, this, -1,
|
|
- ENOMEM, NULL, 0, NULL, NULL, NULL);
|
|
- goto next;
|
|
- }
|
|
- }
|
|
+int shard_post_lookup_base_shard_rm_handler(call_frame_t *frame,
|
|
+ xlator_t *this) {
|
|
+ shard_local_t *local = NULL;
|
|
+ shard_priv_t *priv = NULL;
|
|
|
|
- STACK_WIND_COOKIE(frame, shard_readv_do_cbk, anon_fd, FIRST_CHILD(this),
|
|
- FIRST_CHILD(this)->fops->readv, anon_fd, read_size,
|
|
- shard_offset, local->flags, local->xattr_req);
|
|
+ priv = this->private;
|
|
+ local = frame->local;
|
|
|
|
- orig_offset += read_size;
|
|
- next:
|
|
- cur_block++;
|
|
- i++;
|
|
- call_count--;
|
|
- }
|
|
+ if (local->op_ret < 0) {
|
|
+ shard_common_failure_unwind(local->fop, frame, -1, local->op_errno);
|
|
return 0;
|
|
+ }
|
|
+
|
|
+ if (local->prebuf.ia_nlink > 1) {
|
|
+ gf_msg_debug(this->name, 0, "link count on %s > 1:%d, "
|
|
+ "performing rename()/unlink()",
|
|
+ local->int_inodelk.loc.path, local->prebuf.ia_nlink);
|
|
+ if (local->fop == GF_FOP_RENAME)
|
|
+ shard_rename_src_base_file(frame, this);
|
|
+ else if (local->fop == GF_FOP_UNLINK)
|
|
+ shard_unlink_base_file(frame, this);
|
|
+ } else {
|
|
+ gf_msg_debug(this->name, 0, "link count on %s = 1, creating "
|
|
+ "file under .remove_me",
|
|
+ local->int_inodelk.loc.path);
|
|
+ local->cleanup_required = _gf_true;
|
|
+ shard_acquire_entrylk(frame, this, priv->dot_shard_rm_inode,
|
|
+ local->prebuf.ia_gfid);
|
|
+ }
|
|
+ return 0;
|
|
+}
|
|
+
|
|
+int shard_post_inodelk_fop_handler(call_frame_t *frame, xlator_t *this) {
|
|
+ shard_local_t *local = NULL;
|
|
+
|
|
+ local = frame->local;
|
|
+
|
|
+ switch (local->fop) {
|
|
+ case GF_FOP_UNLINK:
|
|
+ case GF_FOP_RENAME:
|
|
+ shard_lookup_base_file(frame, this, &local->int_inodelk.loc,
|
|
+ shard_post_lookup_base_shard_rm_handler);
|
|
+ break;
|
|
+ default:
|
|
+ gf_msg(this->name, GF_LOG_WARNING, 0, SHARD_MSG_INVALID_FOP,
|
|
+ "post-inodelk handler not defined. This case should not"
|
|
+ " be hit");
|
|
+ break;
|
|
+ }
|
|
+ return 0;
|
|
+}
|
|
+
|
|
+int shard_acquire_inodelk_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
|
|
+ int32_t op_ret, int32_t op_errno, dict_t *xdata) {
|
|
+ call_frame_t *main_frame = NULL;
|
|
+ shard_local_t *local = NULL;
|
|
+ shard_local_t *main_local = NULL;
|
|
+
|
|
+ local = frame->local;
|
|
+ main_frame = local->main_frame;
|
|
+ main_local = main_frame->local;
|
|
+
|
|
+ if (local->op_ret < 0) {
|
|
+ shard_common_failure_unwind(main_local->fop, main_frame, op_ret, op_errno);
|
|
+ return 0;
|
|
+ }
|
|
+ main_local->int_inodelk.acquired_lock = _gf_true;
|
|
+ shard_post_inodelk_fop_handler(main_frame, this);
|
|
+ return 0;
|
|
+}
|
|
+
|
|
+int shard_acquire_inodelk(call_frame_t *frame, xlator_t *this, loc_t *loc) {
|
|
+ call_frame_t *lk_frame = NULL;
|
|
+ shard_local_t *local = NULL;
|
|
+ shard_local_t *lk_local = NULL;
|
|
+ shard_inodelk_t *int_inodelk = NULL;
|
|
+
|
|
+ local = frame->local;
|
|
+ lk_frame = create_frame(this, this->ctx->pool);
|
|
+ if (!lk_frame) {
|
|
+ gf_msg(this->name, GF_LOG_WARNING, ENOMEM, SHARD_MSG_MEMALLOC_FAILED,
|
|
+ "Failed to create new frame "
|
|
+ "to lock base shard");
|
|
+ goto err;
|
|
+ }
|
|
+ lk_local = mem_get0(this->local_pool);
|
|
+ if (!lk_local) {
|
|
+ STACK_DESTROY(lk_frame->root);
|
|
+ goto err;
|
|
+ }
|
|
+
|
|
+ lk_frame->local = lk_local;
|
|
+ lk_local->main_frame = frame;
|
|
+ int_inodelk = &lk_local->int_inodelk;
|
|
+
|
|
+ int_inodelk->flock.l_len = 0;
|
|
+ int_inodelk->flock.l_start = 0;
|
|
+ int_inodelk->domain = this->name;
|
|
+ int_inodelk->flock.l_type = F_WRLCK;
|
|
+ loc_copy(&local->int_inodelk.loc, loc);
|
|
+ set_lk_owner_from_ptr(&lk_frame->root->lk_owner, lk_frame->root);
|
|
+ local->inodelk_frame = lk_frame;
|
|
+
|
|
+ STACK_WIND(lk_frame, shard_acquire_inodelk_cbk, FIRST_CHILD(this),
|
|
+ FIRST_CHILD(this)->fops->inodelk, int_inodelk->domain,
|
|
+ &local->int_inodelk.loc, F_SETLKW, &int_inodelk->flock, NULL);
|
|
+ return 0;
|
|
+err:
|
|
+ shard_common_failure_unwind(local->fop, frame, -1, ENOMEM);
|
|
+ return 0;
|
|
}
|
|
|
|
-int
|
|
-shard_common_mknod_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
|
|
- int32_t op_ret, int32_t op_errno, inode_t *inode,
|
|
- struct iatt *buf, struct iatt *preparent,
|
|
- struct iatt *postparent, dict_t *xdata)
|
|
-{
|
|
- int shard_block_num = (long)cookie;
|
|
- int call_count = 0;
|
|
- shard_local_t *local = NULL;
|
|
+int shard_post_mkdir_rm_handler(call_frame_t *frame, xlator_t *this) {
|
|
+ loc_t *loc = NULL;
|
|
+ shard_local_t *local = NULL;
|
|
|
|
- local = frame->local;
|
|
+ local = frame->local;
|
|
|
|
- if (op_ret < 0) {
|
|
- if (op_errno == EEXIST) {
|
|
- LOCK(&frame->lock);
|
|
- {
|
|
- local->eexist_count++;
|
|
- }
|
|
- UNLOCK(&frame->lock);
|
|
- } else {
|
|
- local->op_ret = op_ret;
|
|
- local->op_errno = op_errno;
|
|
- }
|
|
- gf_msg_debug(this->name, 0,
|
|
- "mknod of shard %d "
|
|
- "failed: %s",
|
|
- shard_block_num, strerror(op_errno));
|
|
- goto done;
|
|
- }
|
|
+ if (local->op_ret < 0) {
|
|
+ shard_common_failure_unwind(local->fop, frame, -1, local->op_errno);
|
|
+ return 0;
|
|
+ }
|
|
+ if (local->fop == GF_FOP_UNLINK)
|
|
+ loc = &local->loc;
|
|
+ else if (local->fop == GF_FOP_RENAME)
|
|
+ loc = &local->loc2;
|
|
+ shard_acquire_inodelk(frame, this, loc);
|
|
+ return 0;
|
|
+}
|
|
|
|
- shard_link_block_inode(local, shard_block_num, inode, buf);
|
|
+int shard_mkdir_internal_dir(call_frame_t *frame, xlator_t *this,
|
|
+ shard_post_resolve_fop_handler_t handler,
|
|
+ shard_internal_dir_type_t type);
|
|
+int shard_pre_mkdir_rm_handler(call_frame_t *frame, xlator_t *this) {
|
|
+ shard_local_t *local = NULL;
|
|
|
|
-done:
|
|
- call_count = shard_call_count_return(frame);
|
|
- if (call_count == 0) {
|
|
- SHARD_UNSET_ROOT_FS_ID(frame, local);
|
|
- local->create_count = 0;
|
|
- local->post_mknod_handler(frame, this);
|
|
- }
|
|
+ local = frame->local;
|
|
|
|
+ if (local->op_ret < 0) {
|
|
+ shard_common_failure_unwind(local->fop, frame, -1, local->op_errno);
|
|
return 0;
|
|
+ }
|
|
+ shard_mkdir_internal_dir(frame, this, shard_post_mkdir_rm_handler,
|
|
+ SHARD_INTERNAL_DIR_DOT_SHARD_REMOVE_ME);
|
|
+ return 0;
|
|
}
|
|
|
|
-int
|
|
-shard_common_resume_mknod(call_frame_t *frame, xlator_t *this,
|
|
- shard_post_mknod_fop_handler_t post_mknod_handler)
|
|
-{
|
|
- int i = 0;
|
|
- int shard_idx_iter = 0;
|
|
- int last_block = 0;
|
|
- int ret = 0;
|
|
- int call_count = 0;
|
|
- char path[PATH_MAX] = {
|
|
- 0,
|
|
- };
|
|
- mode_t mode = 0;
|
|
- char *bname = NULL;
|
|
- shard_priv_t *priv = NULL;
|
|
- shard_inode_ctx_t ctx_tmp = {
|
|
- 0,
|
|
- };
|
|
- shard_local_t *local = NULL;
|
|
- gf_boolean_t wind_failed = _gf_false;
|
|
- fd_t *fd = NULL;
|
|
- loc_t loc = {
|
|
- 0,
|
|
- };
|
|
- dict_t *xattr_req = NULL;
|
|
-
|
|
- local = frame->local;
|
|
- priv = this->private;
|
|
- fd = local->fd;
|
|
- shard_idx_iter = local->first_block;
|
|
- last_block = local->last_block;
|
|
- call_count = local->call_count = local->create_count;
|
|
- local->post_mknod_handler = post_mknod_handler;
|
|
+void shard_begin_rm_resolution(call_frame_t *frame, xlator_t *this) {
|
|
+ shard_priv_t *priv = NULL;
|
|
+ shard_local_t *local = NULL;
|
|
|
|
- SHARD_SET_ROOT_FS_ID(frame, local);
|
|
+ priv = this->private;
|
|
+ local = frame->local;
|
|
|
|
- ret = shard_inode_ctx_get_all(fd->inode, this, &ctx_tmp);
|
|
- if (ret) {
|
|
- gf_msg(this->name, GF_LOG_ERROR, 0, SHARD_MSG_INODE_CTX_GET_FAILED,
|
|
- "Failed to get inode "
|
|
- "ctx for %s",
|
|
- uuid_utoa(fd->inode->gfid));
|
|
- local->op_ret = -1;
|
|
- local->op_errno = ENOMEM;
|
|
- goto err;
|
|
- }
|
|
- mode = st_mode_from_ia(ctx_tmp.stat.ia_prot, ctx_tmp.stat.ia_type);
|
|
+ local->dot_shard_rm_loc.inode =
|
|
+ inode_find(this->itable, priv->dot_shard_rm_gfid);
|
|
+ if (!local->dot_shard_rm_loc.inode) {
|
|
+ local->dot_shard_loc.inode = inode_find(this->itable, priv->dot_shard_gfid);
|
|
+ if (!local->dot_shard_loc.inode) {
|
|
+ shard_mkdir_internal_dir(frame, this, shard_pre_mkdir_rm_handler,
|
|
+ SHARD_INTERNAL_DIR_DOT_SHARD);
|
|
+ } else {
|
|
+ local->post_res_handler = shard_pre_mkdir_rm_handler;
|
|
+ shard_refresh_internal_dir(frame, this, SHARD_INTERNAL_DIR_DOT_SHARD);
|
|
+ }
|
|
+ } else {
|
|
+ local->post_res_handler = shard_post_mkdir_rm_handler;
|
|
+ shard_refresh_internal_dir(frame, this,
|
|
+ SHARD_INTERNAL_DIR_DOT_SHARD_REMOVE_ME);
|
|
+ }
|
|
+}
|
|
+
|
|
+int shard_unlink(call_frame_t *frame, xlator_t *this, loc_t *loc, int xflag,
|
|
+ dict_t *xdata) {
|
|
+ int ret = -1;
|
|
+ uint64_t block_size = 0;
|
|
+ shard_local_t *local = NULL;
|
|
+
|
|
+ ret = shard_inode_ctx_get_block_size(loc->inode, this, &block_size);
|
|
+ if ((ret) && (!IA_ISLNK(loc->inode->ia_type))) {
|
|
+ gf_msg(this->name, GF_LOG_ERROR, 0, SHARD_MSG_INODE_CTX_GET_FAILED,
|
|
+ "Failed to get block "
|
|
+ "size from inode ctx of %s",
|
|
+ uuid_utoa(loc->inode->gfid));
|
|
+ goto err;
|
|
+ }
|
|
+
|
|
+ if (!block_size || frame->root->pid == GF_CLIENT_PID_GSYNCD) {
|
|
+ STACK_WIND(frame, default_unlink_cbk, FIRST_CHILD(this),
|
|
+ FIRST_CHILD(this)->fops->unlink, loc, xflag, xdata);
|
|
+ return 0;
|
|
+ }
|
|
+
|
|
+ local = mem_get0(this->local_pool);
|
|
+ if (!local)
|
|
+ goto err;
|
|
+
|
|
+ frame->local = local;
|
|
+
|
|
+ loc_copy(&local->loc, loc);
|
|
+ local->xflag = xflag;
|
|
+ local->xattr_req = (xdata) ? dict_ref(xdata) : dict_new();
|
|
+ local->block_size = block_size;
|
|
+ local->resolver_base_inode = loc->inode;
|
|
+ local->fop = GF_FOP_UNLINK;
|
|
+ if (!this->itable)
|
|
+ this->itable = (local->loc.inode)->table;
|
|
+
|
|
+ local->resolve_not = _gf_true;
|
|
+ shard_begin_rm_resolution(frame, this);
|
|
+ return 0;
|
|
+err:
|
|
+ shard_common_failure_unwind(GF_FOP_UNLINK, frame, -1, ENOMEM);
|
|
+ return 0;
|
|
+}
|
|
|
|
- while (shard_idx_iter <= last_block) {
|
|
- if (local->inode_list[i]) {
|
|
- shard_idx_iter++;
|
|
- i++;
|
|
- continue;
|
|
- }
|
|
+int shard_post_rename_lookup_handler(call_frame_t *frame, xlator_t *this) {
|
|
+ shard_rename_cbk(frame, this);
|
|
+ return 0;
|
|
+}
|
|
|
|
- if (wind_failed) {
|
|
- shard_common_mknod_cbk(frame, (void *)(long)shard_idx_iter, this,
|
|
- -1, ENOMEM, NULL, NULL, NULL, NULL, NULL);
|
|
- goto next;
|
|
- }
|
|
+int shard_rename_src_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
|
|
+ int32_t op_ret, int32_t op_errno, struct iatt *buf,
|
|
+ struct iatt *preoldparent, struct iatt *postoldparent,
|
|
+ struct iatt *prenewparent, struct iatt *postnewparent,
|
|
+ dict_t *xdata) {
|
|
+ int ret = 0;
|
|
+ shard_local_t *local = NULL;
|
|
|
|
- shard_make_block_abspath(shard_idx_iter, fd->inode->gfid, path,
|
|
- sizeof(path));
|
|
-
|
|
- xattr_req = shard_create_gfid_dict(local->xattr_req);
|
|
- if (!xattr_req) {
|
|
- local->op_ret = -1;
|
|
- local->op_errno = ENOMEM;
|
|
- wind_failed = _gf_true;
|
|
- shard_common_mknod_cbk(frame, (void *)(long)shard_idx_iter, this,
|
|
- -1, ENOMEM, NULL, NULL, NULL, NULL, NULL);
|
|
- goto next;
|
|
- }
|
|
+ local = frame->local;
|
|
|
|
- bname = strrchr(path, '/') + 1;
|
|
- loc.inode = inode_new(this->itable);
|
|
- loc.parent = inode_ref(priv->dot_shard_inode);
|
|
- ret = inode_path(loc.parent, bname, (char **)&(loc.path));
|
|
- if (ret < 0 || !(loc.inode)) {
|
|
- gf_msg(this->name, GF_LOG_ERROR, 0, SHARD_MSG_INODE_PATH_FAILED,
|
|
- "Inode path failed"
|
|
- "on %s, base file gfid = %s",
|
|
- bname, uuid_utoa(fd->inode->gfid));
|
|
- local->op_ret = -1;
|
|
- local->op_errno = ENOMEM;
|
|
- wind_failed = _gf_true;
|
|
- loc_wipe(&loc);
|
|
- dict_unref(xattr_req);
|
|
- shard_common_mknod_cbk(frame, (void *)(long)shard_idx_iter, this,
|
|
- -1, ENOMEM, NULL, NULL, NULL, NULL, NULL);
|
|
- goto next;
|
|
- }
|
|
+ if (op_ret < 0) {
|
|
+ local->op_ret = op_ret;
|
|
+ local->op_errno = op_errno;
|
|
+ goto err;
|
|
+ }
|
|
+ /* Set ctx->refresh to TRUE to force a lookup on disk when
|
|
+ * shard_lookup_base_file() is called next to refresh the hard link
|
|
+ * count in ctx. Note that this is applicable only to the case where
|
|
+ * the rename dst is already existent and sharded.
|
|
+ */
|
|
+ if ((local->dst_block_size) && (!local->cleanup_required))
|
|
+ shard_inode_ctx_set_refresh_flag(local->int_inodelk.loc.inode, this);
|
|
+
|
|
+ local->prebuf = *buf;
|
|
+ local->preoldparent = *preoldparent;
|
|
+ local->postoldparent = *postoldparent;
|
|
+ local->prenewparent = *prenewparent;
|
|
+ local->postnewparent = *postnewparent;
|
|
+ if (xdata)
|
|
+ local->xattr_rsp = dict_ref(xdata);
|
|
|
|
- loc.name = strrchr(loc.path, '/');
|
|
- if (loc.name)
|
|
- loc.name++;
|
|
-
|
|
- STACK_WIND_COOKIE(frame, shard_common_mknod_cbk,
|
|
- (void *)(long)shard_idx_iter, FIRST_CHILD(this),
|
|
- FIRST_CHILD(this)->fops->mknod, &loc, mode,
|
|
- ctx_tmp.stat.ia_rdev, 0, xattr_req);
|
|
- loc_wipe(&loc);
|
|
- dict_unref(xattr_req);
|
|
-
|
|
- next:
|
|
- shard_idx_iter++;
|
|
- i++;
|
|
- if (!--call_count)
|
|
- break;
|
|
+ if (local->dst_block_size) {
|
|
+ if (local->entrylk_frame) {
|
|
+ ret = shard_unlock_entrylk(frame, this);
|
|
+ if (ret < 0) {
|
|
+ local->op_ret = -1;
|
|
+ local->op_errno = -ret;
|
|
+ }
|
|
}
|
|
|
|
- return 0;
|
|
+ ret = shard_unlock_inodelk(frame, this);
|
|
+ if (ret < 0) {
|
|
+ local->op_ret = -1;
|
|
+ local->op_errno = -ret;
|
|
+ goto err;
|
|
+ }
|
|
+ if (local->cleanup_required)
|
|
+ shard_start_background_deletion(this);
|
|
+ }
|
|
+
|
|
+ /* Now the base file of src, if sharded, is looked up to gather ia_size
|
|
+ * and ia_blocks.*/
|
|
+ if (local->block_size) {
|
|
+ local->tmp_loc.inode = inode_new(this->itable);
|
|
+ gf_uuid_copy(local->tmp_loc.gfid, (local->loc.inode)->gfid);
|
|
+ shard_lookup_base_file(frame, this, &local->tmp_loc,
|
|
+ shard_post_rename_lookup_handler);
|
|
+ } else {
|
|
+ shard_rename_cbk(frame, this);
|
|
+ }
|
|
+ return 0;
|
|
err:
|
|
- /*
|
|
- * This block is for handling failure in shard_inode_ctx_get_all().
|
|
- * Failures in the while-loop are handled within the loop.
|
|
- */
|
|
- SHARD_UNSET_ROOT_FS_ID(frame, local);
|
|
- post_mknod_handler(frame, this);
|
|
- return 0;
|
|
+ shard_common_failure_unwind(local->fop, frame, local->op_ret,
|
|
+ local->op_errno);
|
|
+ return 0;
|
|
}
|
|
|
|
-int
|
|
-shard_post_mknod_readv_handler(call_frame_t *frame, xlator_t *this);
|
|
-
|
|
-int
|
|
-shard_post_lookup_shards_readv_handler(call_frame_t *frame, xlator_t *this)
|
|
-{
|
|
- shard_local_t *local = NULL;
|
|
-
|
|
- local = frame->local;
|
|
-
|
|
- if (local->op_ret < 0) {
|
|
- shard_common_failure_unwind(GF_FOP_READ, frame, local->op_ret,
|
|
- local->op_errno);
|
|
- return 0;
|
|
- }
|
|
+int shard_post_lookup_dst_base_file_handler(call_frame_t *frame,
|
|
+ xlator_t *this) {
|
|
+ shard_local_t *local = NULL;
|
|
|
|
- if (local->create_count) {
|
|
- shard_common_resume_mknod(frame, this, shard_post_mknod_readv_handler);
|
|
- } else {
|
|
- shard_readv_do(frame, this);
|
|
- }
|
|
+ local = frame->local;
|
|
|
|
+ if (local->op_ret < 0) {
|
|
+ shard_common_failure_unwind(local->fop, frame, local->op_ret,
|
|
+ local->op_errno);
|
|
return 0;
|
|
+ }
|
|
+
|
|
+ /* Save dst base file attributes into postbuf so the information is not
|
|
+ * lost when it is overwritten after lookup on base file of src in
|
|
+ * shard_lookup_base_file_cbk().
|
|
+ */
|
|
+ local->postbuf = local->prebuf;
|
|
+ shard_rename_src_base_file(frame, this);
|
|
+ return 0;
|
|
+}
|
|
+
|
|
+int shard_rename(call_frame_t *frame, xlator_t *this, loc_t *oldloc,
|
|
+ loc_t *newloc, dict_t *xdata) {
|
|
+ int ret = -1;
|
|
+ uint64_t block_size = 0;
|
|
+ uint64_t dst_block_size = 0;
|
|
+ shard_local_t *local = NULL;
|
|
+
|
|
+ if (IA_ISDIR(oldloc->inode->ia_type)) {
|
|
+ STACK_WIND(frame, default_rename_cbk, FIRST_CHILD(this),
|
|
+ FIRST_CHILD(this)->fops->rename, oldloc, newloc, xdata);
|
|
+ return 0;
|
|
+ }
|
|
+
|
|
+ ret = shard_inode_ctx_get_block_size(oldloc->inode, this, &block_size);
|
|
+ if ((ret) && (!IA_ISLNK(oldloc->inode->ia_type))) {
|
|
+ gf_msg(this->name, GF_LOG_ERROR, 0, SHARD_MSG_INODE_CTX_GET_FAILED,
|
|
+ "Failed to get block "
|
|
+ "size from inode ctx of %s",
|
|
+ uuid_utoa(oldloc->inode->gfid));
|
|
+ goto err;
|
|
+ }
|
|
+
|
|
+ if (newloc->inode)
|
|
+ ret = shard_inode_ctx_get_block_size(newloc->inode, this, &dst_block_size);
|
|
+
|
|
+ /* The following stack_wind covers the case where:
|
|
+ * a. the src file is not sharded and dst doesn't exist, OR
|
|
+ * b. the src and dst both exist but are not sharded.
|
|
+ */
|
|
+ if (((!block_size) && (!dst_block_size)) ||
|
|
+ frame->root->pid == GF_CLIENT_PID_GSYNCD) {
|
|
+ STACK_WIND(frame, default_rename_cbk, FIRST_CHILD(this),
|
|
+ FIRST_CHILD(this)->fops->rename, oldloc, newloc, xdata);
|
|
+ return 0;
|
|
+ }
|
|
+
|
|
+ local = mem_get0(this->local_pool);
|
|
+ if (!local)
|
|
+ goto err;
|
|
+
|
|
+ frame->local = local;
|
|
+ loc_copy(&local->loc, oldloc);
|
|
+ loc_copy(&local->loc2, newloc);
|
|
+ local->resolver_base_inode = newloc->inode;
|
|
+ local->fop = GF_FOP_RENAME;
|
|
+ local->xattr_req = (xdata) ? dict_ref(xdata) : dict_new();
|
|
+ if (!local->xattr_req)
|
|
+ goto err;
|
|
+
|
|
+ local->block_size = block_size;
|
|
+ local->dst_block_size = dst_block_size;
|
|
+ if (!this->itable)
|
|
+ this->itable = (local->loc.inode)->table;
|
|
+ local->resolve_not = _gf_true;
|
|
+
|
|
+ /* The following if-block covers the case where the dst file exists
|
|
+ * and is sharded.
|
|
+ */
|
|
+ if (local->dst_block_size) {
|
|
+ shard_begin_rm_resolution(frame, this);
|
|
+ } else {
|
|
+ /* The following block covers the case where the dst either doesn't
|
|
+ * exist or is NOT sharded but the src is sharded. In this case, shard
|
|
+ * xlator would go ahead and rename src to dst. Once done, it would also
|
|
+ * lookup the base shard of src to get the ia_size and ia_blocks xattr
|
|
+ * values.
|
|
+ */
|
|
+ shard_rename_src_base_file(frame, this);
|
|
+ }
|
|
+ return 0;
|
|
+
|
|
+err:
|
|
+ shard_common_failure_unwind(GF_FOP_RENAME, frame, -1, ENOMEM);
|
|
+ return 0;
|
|
}
|
|
|
|
-int
|
|
-shard_post_mknod_readv_handler(call_frame_t *frame, xlator_t *this)
|
|
-{
|
|
- shard_local_t *local = NULL;
|
|
+int shard_create_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
|
|
+ int32_t op_ret, int32_t op_errno, fd_t *fd, inode_t *inode,
|
|
+ struct iatt *stbuf, struct iatt *preparent,
|
|
+ struct iatt *postparent, dict_t *xdata) {
|
|
+ int ret = -1;
|
|
+ shard_local_t *local = NULL;
|
|
|
|
- local = frame->local;
|
|
+ local = frame->local;
|
|
|
|
- if (local->op_ret < 0) {
|
|
- shard_common_failure_unwind(GF_FOP_READ, frame, local->op_ret,
|
|
- local->op_errno);
|
|
- return 0;
|
|
- }
|
|
+ if (op_ret == -1)
|
|
+ goto unwind;
|
|
|
|
- if (!local->eexist_count) {
|
|
- shard_readv_do(frame, this);
|
|
- } else {
|
|
- local->call_count = local->eexist_count;
|
|
- shard_common_lookup_shards(frame, this, local->loc.inode,
|
|
- shard_post_lookup_shards_readv_handler);
|
|
- }
|
|
- return 0;
|
|
+ ret = shard_inode_ctx_set(inode, this, stbuf, local->block_size,
|
|
+ SHARD_ALL_MASK);
|
|
+ if (ret)
|
|
+ gf_msg(this->name, GF_LOG_WARNING, 0, SHARD_MSG_INODE_CTX_SET_FAILED,
|
|
+ "Failed to set inode "
|
|
+ "ctx for %s",
|
|
+ uuid_utoa(inode->gfid));
|
|
+
|
|
+unwind:
|
|
+ SHARD_STACK_UNWIND(create, frame, op_ret, op_errno, fd, inode, stbuf,
|
|
+ preparent, postparent, xdata);
|
|
+ return 0;
|
|
}
|
|
|
|
-int
|
|
-shard_post_resolve_readv_handler(call_frame_t *frame, xlator_t *this)
|
|
-{
|
|
- shard_local_t *local = NULL;
|
|
+int shard_create(call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags,
|
|
+ mode_t mode, mode_t umask, fd_t *fd, dict_t *xdata) {
|
|
+ shard_priv_t *priv = NULL;
|
|
+ shard_local_t *local = NULL;
|
|
|
|
- local = frame->local;
|
|
+ priv = this->private;
|
|
+ local = mem_get0(this->local_pool);
|
|
+ if (!local)
|
|
+ goto err;
|
|
|
|
- if (local->op_ret < 0) {
|
|
- if (local->op_errno != ENOENT) {
|
|
- shard_common_failure_unwind(GF_FOP_READ, frame, local->op_ret,
|
|
- local->op_errno);
|
|
- return 0;
|
|
- } else {
|
|
- struct iovec vec = {
|
|
- 0,
|
|
- };
|
|
-
|
|
- vec.iov_base = local->iobuf->ptr;
|
|
- vec.iov_len = local->total_size;
|
|
- local->op_ret = local->total_size;
|
|
- SHARD_STACK_UNWIND(readv, frame, local->op_ret, 0, &vec, 1,
|
|
- &local->prebuf, local->iobref, NULL);
|
|
- return 0;
|
|
- }
|
|
- }
|
|
+ frame->local = local;
|
|
+ local->block_size = priv->block_size;
|
|
|
|
- if (local->call_count) {
|
|
- shard_common_lookup_shards(frame, this, local->resolver_base_inode,
|
|
- shard_post_lookup_shards_readv_handler);
|
|
- } else {
|
|
- shard_readv_do(frame, this);
|
|
- }
|
|
+ if (!__is_gsyncd_on_shard_dir(frame, loc)) {
|
|
+ SHARD_INODE_CREATE_INIT(this, local->block_size, xdata, loc, 0, 0, err);
|
|
+ }
|
|
|
|
- return 0;
|
|
-}
|
|
+ STACK_WIND(frame, shard_create_cbk, FIRST_CHILD(this),
|
|
+ FIRST_CHILD(this)->fops->create, loc, flags, mode, umask, fd,
|
|
+ xdata);
|
|
+ return 0;
|
|
+err:
|
|
+ shard_common_failure_unwind(GF_FOP_CREATE, frame, -1, ENOMEM);
|
|
+ return 0;
|
|
+}
|
|
+
|
|
+int shard_open_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
|
|
+ int32_t op_ret, int32_t op_errno, fd_t *fd, dict_t *xdata) {
|
|
+ /* To-Do: Handle open with O_TRUNC under locks */
|
|
+ SHARD_STACK_UNWIND(open, frame, op_ret, op_errno, fd, xdata);
|
|
+ return 0;
|
|
+}
|
|
+
|
|
+int shard_open(call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags,
|
|
+ fd_t *fd, dict_t *xdata) {
|
|
+ STACK_WIND(frame, shard_open_cbk, FIRST_CHILD(this),
|
|
+ FIRST_CHILD(this)->fops->open, loc, flags, fd, xdata);
|
|
+ return 0;
|
|
+}
|
|
+
|
|
+int shard_readv_do_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
|
|
+ int32_t op_ret, int32_t op_errno, struct iovec *vector,
|
|
+ int32_t count, struct iatt *stbuf, struct iobref *iobref,
|
|
+ dict_t *xdata) {
|
|
+ int i = 0;
|
|
+ int call_count = 0;
|
|
+ void *address = NULL;
|
|
+ uint64_t block_num = 0;
|
|
+ off_t off = 0;
|
|
+ struct iovec vec = {
|
|
+ 0,
|
|
+ };
|
|
+ shard_local_t *local = NULL;
|
|
+ fd_t *anon_fd = cookie;
|
|
+ shard_inode_ctx_t *ctx = NULL;
|
|
+
|
|
+ local = frame->local;
|
|
+
|
|
+ /* If shard has already seen a failure here before, there is no point
|
|
+ * in aggregating subsequent reads, so just go to out.
|
|
+ */
|
|
+ if (local->op_ret < 0)
|
|
+ goto out;
|
|
+
|
|
+ if (op_ret < 0) {
|
|
+ local->op_ret = op_ret;
|
|
+ local->op_errno = op_errno;
|
|
+ goto out;
|
|
+ }
|
|
+
|
|
+ if (local->op_ret >= 0)
|
|
+ local->op_ret += op_ret;
|
|
|
|
-int
|
|
-shard_post_lookup_readv_handler(call_frame_t *frame, xlator_t *this)
|
|
-{
|
|
- int ret = 0;
|
|
- struct iobuf *iobuf = NULL;
|
|
- shard_local_t *local = NULL;
|
|
- shard_priv_t *priv = NULL;
|
|
+ shard_inode_ctx_get(anon_fd->inode, this, &ctx);
|
|
+ block_num = ctx->block_num;
|
|
+
|
|
+ if (block_num == local->first_block) {
|
|
+ address = local->iobuf->ptr;
|
|
+ } else {
|
|
+ /* else
|
|
+ * address to start writing to = beginning of buffer +
|
|
+ * number of bytes until end of first block +
|
|
+ * + block_size times number of blocks
|
|
+ * between the current block and the first
|
|
+ */
|
|
+ address = (char *)local->iobuf->ptr +
|
|
+ (local->block_size - (local->offset % local->block_size)) +
|
|
+ ((block_num - local->first_block - 1) * local->block_size);
|
|
+ }
|
|
|
|
- priv = this->private;
|
|
- local = frame->local;
|
|
+ for (i = 0; i < count; i++) {
|
|
+ address = (char *)address + off;
|
|
+ memcpy(address, vector[i].iov_base, vector[i].iov_len);
|
|
+ off += vector[i].iov_len;
|
|
+ }
|
|
|
|
+out:
|
|
+ if (anon_fd)
|
|
+ fd_unref(anon_fd);
|
|
+ call_count = shard_call_count_return(frame);
|
|
+ if (call_count == 0) {
|
|
+ SHARD_UNSET_ROOT_FS_ID(frame, local);
|
|
if (local->op_ret < 0) {
|
|
- shard_common_failure_unwind(GF_FOP_READ, frame, local->op_ret,
|
|
- local->op_errno);
|
|
- return 0;
|
|
+ shard_common_failure_unwind(GF_FOP_READ, frame, local->op_ret,
|
|
+ local->op_errno);
|
|
+ } else {
|
|
+ if (xdata)
|
|
+ local->xattr_rsp = dict_ref(xdata);
|
|
+ vec.iov_base = local->iobuf->ptr;
|
|
+ vec.iov_len = local->total_size;
|
|
+ local->op_ret = local->total_size;
|
|
+ SHARD_STACK_UNWIND(readv, frame, local->op_ret, local->op_errno, &vec, 1,
|
|
+ &local->prebuf, local->iobref, local->xattr_rsp);
|
|
+ return 0;
|
|
+ }
|
|
+ }
|
|
+
|
|
+ return 0;
|
|
+}
|
|
+
|
|
+int shard_readv_do(call_frame_t *frame, xlator_t *this) {
|
|
+ int i = 0;
|
|
+ int call_count = 0;
|
|
+ int last_block = 0;
|
|
+ int cur_block = 0;
|
|
+ off_t orig_offset = 0;
|
|
+ off_t shard_offset = 0;
|
|
+ size_t read_size = 0;
|
|
+ size_t remaining_size = 0;
|
|
+ fd_t *fd = NULL;
|
|
+ fd_t *anon_fd = NULL;
|
|
+ shard_local_t *local = NULL;
|
|
+ gf_boolean_t wind_failed = _gf_false;
|
|
+
|
|
+ local = frame->local;
|
|
+ fd = local->fd;
|
|
+
|
|
+ orig_offset = local->offset;
|
|
+ cur_block = local->first_block;
|
|
+ last_block = local->last_block;
|
|
+ remaining_size = local->total_size;
|
|
+ local->call_count = call_count = local->num_blocks;
|
|
+
|
|
+ SHARD_SET_ROOT_FS_ID(frame, local);
|
|
+
|
|
+ if (fd->flags & O_DIRECT)
|
|
+ local->flags = O_DIRECT;
|
|
+
|
|
+ while (cur_block <= last_block) {
|
|
+ if (wind_failed) {
|
|
+ shard_readv_do_cbk(frame, (void *)(long)0, this, -1, ENOMEM, NULL, 0,
|
|
+ NULL, NULL, NULL);
|
|
+ goto next;
|
|
+ }
|
|
+
|
|
+ shard_offset = orig_offset % local->block_size;
|
|
+ read_size = local->block_size - shard_offset;
|
|
+ if (read_size > remaining_size)
|
|
+ read_size = remaining_size;
|
|
+
|
|
+ remaining_size -= read_size;
|
|
+
|
|
+ if (cur_block == 0) {
|
|
+ anon_fd = fd_ref(fd);
|
|
+ } else {
|
|
+ anon_fd = fd_anonymous(local->inode_list[i]);
|
|
+ if (!anon_fd) {
|
|
+ local->op_ret = -1;
|
|
+ local->op_errno = ENOMEM;
|
|
+ wind_failed = _gf_true;
|
|
+ shard_readv_do_cbk(frame, (void *)(long)anon_fd, this, -1, ENOMEM, NULL,
|
|
+ 0, NULL, NULL, NULL);
|
|
+ goto next;
|
|
+ }
|
|
}
|
|
|
|
- if (local->offset >= local->prebuf.ia_size) {
|
|
- /* If the read is being performed past the end of the file,
|
|
- * unwind the FOP with 0 bytes read as status.
|
|
- */
|
|
- struct iovec vec = {
|
|
- 0,
|
|
- };
|
|
-
|
|
- iobuf = iobuf_get2(this->ctx->iobuf_pool, local->req_size);
|
|
- if (!iobuf)
|
|
- goto err;
|
|
-
|
|
- vec.iov_base = iobuf->ptr;
|
|
- vec.iov_len = 0;
|
|
- local->iobref = iobref_new();
|
|
- iobref_add(local->iobref, iobuf);
|
|
- iobuf_unref(iobuf);
|
|
-
|
|
- SHARD_STACK_UNWIND(readv, frame, 0, 0, &vec, 1, &local->prebuf,
|
|
- local->iobref, NULL);
|
|
- return 0;
|
|
- }
|
|
+ STACK_WIND_COOKIE(frame, shard_readv_do_cbk, anon_fd, FIRST_CHILD(this),
|
|
+ FIRST_CHILD(this)->fops->readv, anon_fd, read_size,
|
|
+ shard_offset, local->flags, local->xattr_req);
|
|
+
|
|
+ orig_offset += read_size;
|
|
+ next:
|
|
+ cur_block++;
|
|
+ i++;
|
|
+ call_count--;
|
|
+ }
|
|
+ return 0;
|
|
+}
|
|
|
|
- local->first_block = get_lowest_block(local->offset, local->block_size);
|
|
+int shard_common_mknod_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
|
|
+ int32_t op_ret, int32_t op_errno, inode_t *inode,
|
|
+ struct iatt *buf, struct iatt *preparent,
|
|
+ struct iatt *postparent, dict_t *xdata) {
|
|
+ int shard_block_num = (long)cookie;
|
|
+ int call_count = 0;
|
|
+ shard_local_t *local = NULL;
|
|
+
|
|
+ local = frame->local;
|
|
+
|
|
+ if (op_ret < 0) {
|
|
+ if (op_errno == EEXIST) {
|
|
+ LOCK(&frame->lock);
|
|
+ { local->eexist_count++; }
|
|
+ UNLOCK(&frame->lock);
|
|
+ } else {
|
|
+ local->op_ret = op_ret;
|
|
+ local->op_errno = op_errno;
|
|
+ }
|
|
+ gf_msg_debug(this->name, 0, "mknod of shard %d "
|
|
+ "failed: %s",
|
|
+ shard_block_num, strerror(op_errno));
|
|
+ goto done;
|
|
+ }
|
|
|
|
- local->total_size = local->req_size;
|
|
+ shard_link_block_inode(local, shard_block_num, inode, buf);
|
|
|
|
- local->last_block = get_highest_block(local->offset, local->total_size,
|
|
- local->block_size);
|
|
+done:
|
|
+ call_count = shard_call_count_return(frame);
|
|
+ if (call_count == 0) {
|
|
+ SHARD_UNSET_ROOT_FS_ID(frame, local);
|
|
+ local->create_count = 0;
|
|
+ local->post_mknod_handler(frame, this);
|
|
+ }
|
|
+
|
|
+ return 0;
|
|
+}
|
|
+
|
|
+int shard_common_resume_mknod(
|
|
+ call_frame_t *frame, xlator_t *this,
|
|
+ shard_post_mknod_fop_handler_t post_mknod_handler) {
|
|
+ int i = 0;
|
|
+ int shard_idx_iter = 0;
|
|
+ int last_block = 0;
|
|
+ int ret = 0;
|
|
+ int call_count = 0;
|
|
+ char path[PATH_MAX] = {
|
|
+ 0,
|
|
+ };
|
|
+ mode_t mode = 0;
|
|
+ char *bname = NULL;
|
|
+ shard_priv_t *priv = NULL;
|
|
+ shard_inode_ctx_t ctx_tmp = {
|
|
+ 0,
|
|
+ };
|
|
+ shard_local_t *local = NULL;
|
|
+ gf_boolean_t wind_failed = _gf_false;
|
|
+ fd_t *fd = NULL;
|
|
+ loc_t loc = {
|
|
+ 0,
|
|
+ };
|
|
+ dict_t *xattr_req = NULL;
|
|
+
|
|
+ local = frame->local;
|
|
+ priv = this->private;
|
|
+ fd = local->fd;
|
|
+ shard_idx_iter = local->first_block;
|
|
+ last_block = local->last_block;
|
|
+ call_count = local->call_count = local->create_count;
|
|
+ local->post_mknod_handler = post_mknod_handler;
|
|
+
|
|
+ SHARD_SET_ROOT_FS_ID(frame, local);
|
|
+
|
|
+ ret = shard_inode_ctx_get_all(fd->inode, this, &ctx_tmp);
|
|
+ if (ret) {
|
|
+ gf_msg(this->name, GF_LOG_ERROR, 0, SHARD_MSG_INODE_CTX_GET_FAILED,
|
|
+ "Failed to get inode "
|
|
+ "ctx for %s",
|
|
+ uuid_utoa(fd->inode->gfid));
|
|
+ local->op_ret = -1;
|
|
+ local->op_errno = ENOMEM;
|
|
+ goto err;
|
|
+ }
|
|
+ mode = st_mode_from_ia(ctx_tmp.stat.ia_prot, ctx_tmp.stat.ia_type);
|
|
|
|
- local->num_blocks = local->last_block - local->first_block + 1;
|
|
- local->resolver_base_inode = local->loc.inode;
|
|
+ while (shard_idx_iter <= last_block) {
|
|
+ if (local->inode_list[i]) {
|
|
+ shard_idx_iter++;
|
|
+ i++;
|
|
+ continue;
|
|
+ }
|
|
|
|
- local->inode_list = GF_CALLOC(local->num_blocks, sizeof(inode_t *),
|
|
- gf_shard_mt_inode_list);
|
|
- if (!local->inode_list)
|
|
- goto err;
|
|
+ if (wind_failed) {
|
|
+ shard_common_mknod_cbk(frame, (void *)(long)shard_idx_iter, this, -1,
|
|
+ ENOMEM, NULL, NULL, NULL, NULL, NULL);
|
|
+ goto next;
|
|
+ }
|
|
|
|
- iobuf = iobuf_get2(this->ctx->iobuf_pool, local->total_size);
|
|
- if (!iobuf)
|
|
- goto err;
|
|
+ shard_make_block_abspath(shard_idx_iter, fd->inode->gfid, path,
|
|
+ sizeof(path));
|
|
|
|
- local->iobref = iobref_new();
|
|
- if (!local->iobref) {
|
|
- iobuf_unref(iobuf);
|
|
- goto err;
|
|
+ xattr_req = shard_create_gfid_dict(local->xattr_req);
|
|
+ if (!xattr_req) {
|
|
+ local->op_ret = -1;
|
|
+ local->op_errno = ENOMEM;
|
|
+ wind_failed = _gf_true;
|
|
+ shard_common_mknod_cbk(frame, (void *)(long)shard_idx_iter, this, -1,
|
|
+ ENOMEM, NULL, NULL, NULL, NULL, NULL);
|
|
+ goto next;
|
|
}
|
|
|
|
- if (iobref_add(local->iobref, iobuf) != 0) {
|
|
- iobuf_unref(iobuf);
|
|
- goto err;
|
|
+ bname = strrchr(path, '/') + 1;
|
|
+ loc.inode = inode_new(this->itable);
|
|
+ loc.parent = inode_ref(priv->dot_shard_inode);
|
|
+ ret = inode_path(loc.parent, bname, (char **)&(loc.path));
|
|
+ if (ret < 0 || !(loc.inode)) {
|
|
+ gf_msg(this->name, GF_LOG_ERROR, 0, SHARD_MSG_INODE_PATH_FAILED,
|
|
+ "Inode path failed"
|
|
+ "on %s, base file gfid = %s",
|
|
+ bname, uuid_utoa(fd->inode->gfid));
|
|
+ local->op_ret = -1;
|
|
+ local->op_errno = ENOMEM;
|
|
+ wind_failed = _gf_true;
|
|
+ loc_wipe(&loc);
|
|
+ dict_unref(xattr_req);
|
|
+ shard_common_mknod_cbk(frame, (void *)(long)shard_idx_iter, this, -1,
|
|
+ ENOMEM, NULL, NULL, NULL, NULL, NULL);
|
|
+ goto next;
|
|
}
|
|
|
|
- memset(iobuf->ptr, 0, local->total_size);
|
|
- iobuf_unref(iobuf);
|
|
- local->iobuf = iobuf;
|
|
+ loc.name = strrchr(loc.path, '/');
|
|
+ if (loc.name)
|
|
+ loc.name++;
|
|
|
|
- local->dot_shard_loc.inode = inode_find(this->itable, priv->dot_shard_gfid);
|
|
- if (!local->dot_shard_loc.inode) {
|
|
- ret = shard_init_internal_dir_loc(this, local,
|
|
- SHARD_INTERNAL_DIR_DOT_SHARD);
|
|
- if (ret)
|
|
- goto err;
|
|
- shard_lookup_internal_dir(frame, this, shard_post_resolve_readv_handler,
|
|
- SHARD_INTERNAL_DIR_DOT_SHARD);
|
|
- } else {
|
|
- local->post_res_handler = shard_post_resolve_readv_handler;
|
|
- shard_refresh_internal_dir(frame, this, SHARD_INTERNAL_DIR_DOT_SHARD);
|
|
- }
|
|
- return 0;
|
|
+ STACK_WIND_COOKIE(frame, shard_common_mknod_cbk,
|
|
+ (void *)(long)shard_idx_iter, FIRST_CHILD(this),
|
|
+ FIRST_CHILD(this)->fops->mknod, &loc, mode,
|
|
+ ctx_tmp.stat.ia_rdev, 0, xattr_req);
|
|
+ loc_wipe(&loc);
|
|
+ dict_unref(xattr_req);
|
|
+
|
|
+ next:
|
|
+ shard_idx_iter++;
|
|
+ i++;
|
|
+ if (!--call_count)
|
|
+ break;
|
|
+ }
|
|
+
|
|
+ return 0;
|
|
err:
|
|
- shard_common_failure_unwind(GF_FOP_READ, frame, -1, ENOMEM);
|
|
- return 0;
|
|
+ /*
|
|
+ * This block is for handling failure in shard_inode_ctx_get_all().
|
|
+ * Failures in the while-loop are handled within the loop.
|
|
+ */
|
|
+ SHARD_UNSET_ROOT_FS_ID(frame, local);
|
|
+ post_mknod_handler(frame, this);
|
|
+ return 0;
|
|
}
|
|
|
|
-int
|
|
-shard_readv(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
|
|
- off_t offset, uint32_t flags, dict_t *xdata)
|
|
-{
|
|
- int ret = 0;
|
|
- uint64_t block_size = 0;
|
|
- shard_local_t *local = NULL;
|
|
+int shard_post_mknod_readv_handler(call_frame_t *frame, xlator_t *this);
|
|
|
|
- ret = shard_inode_ctx_get_block_size(fd->inode, this, &block_size);
|
|
- if (ret) {
|
|
- gf_msg(this->name, GF_LOG_ERROR, 0, SHARD_MSG_INODE_CTX_GET_FAILED,
|
|
- "Failed to get block "
|
|
- "size for %s from its inode ctx",
|
|
- uuid_utoa(fd->inode->gfid));
|
|
- goto err;
|
|
- }
|
|
+int shard_post_lookup_shards_readv_handler(call_frame_t *frame,
|
|
+ xlator_t *this) {
|
|
+ shard_local_t *local = NULL;
|
|
|
|
- if (!block_size || frame->root->pid == GF_CLIENT_PID_GSYNCD) {
|
|
- /* block_size = 0 means that the file was created before
|
|
- * sharding was enabled on the volume.
|
|
- */
|
|
- STACK_WIND(frame, default_readv_cbk, FIRST_CHILD(this),
|
|
- FIRST_CHILD(this)->fops->readv, fd, size, offset, flags,
|
|
- xdata);
|
|
- return 0;
|
|
- }
|
|
+ local = frame->local;
|
|
|
|
- if (!this->itable)
|
|
- this->itable = fd->inode->table;
|
|
+ if (local->op_ret < 0) {
|
|
+ shard_common_failure_unwind(GF_FOP_READ, frame, local->op_ret,
|
|
+ local->op_errno);
|
|
+ return 0;
|
|
+ }
|
|
|
|
- local = mem_get0(this->local_pool);
|
|
- if (!local)
|
|
- goto err;
|
|
+ if (local->create_count) {
|
|
+ shard_common_resume_mknod(frame, this, shard_post_mknod_readv_handler);
|
|
+ } else {
|
|
+ shard_readv_do(frame, this);
|
|
+ }
|
|
|
|
- frame->local = local;
|
|
+ return 0;
|
|
+}
|
|
|
|
- ret = syncbarrier_init(&local->barrier);
|
|
- if (ret)
|
|
- goto err;
|
|
- local->fd = fd_ref(fd);
|
|
- local->block_size = block_size;
|
|
- local->offset = offset;
|
|
- local->req_size = size;
|
|
- local->flags = flags;
|
|
- local->fop = GF_FOP_READ;
|
|
- local->xattr_req = (xdata) ? dict_ref(xdata) : dict_new();
|
|
- if (!local->xattr_req)
|
|
- goto err;
|
|
+int shard_post_mknod_readv_handler(call_frame_t *frame, xlator_t *this) {
|
|
+ shard_local_t *local = NULL;
|
|
|
|
- local->loc.inode = inode_ref(fd->inode);
|
|
- gf_uuid_copy(local->loc.gfid, fd->inode->gfid);
|
|
+ local = frame->local;
|
|
|
|
- shard_lookup_base_file(frame, this, &local->loc,
|
|
- shard_post_lookup_readv_handler);
|
|
- return 0;
|
|
-err:
|
|
- shard_common_failure_unwind(GF_FOP_READ, frame, -1, ENOMEM);
|
|
+ if (local->op_ret < 0) {
|
|
+ shard_common_failure_unwind(GF_FOP_READ, frame, local->op_ret,
|
|
+ local->op_errno);
|
|
return 0;
|
|
+ }
|
|
+
|
|
+ if (!local->eexist_count) {
|
|
+ shard_readv_do(frame, this);
|
|
+ } else {
|
|
+ local->call_count = local->eexist_count;
|
|
+ shard_common_lookup_shards(frame, this, local->loc.inode,
|
|
+ shard_post_lookup_shards_readv_handler);
|
|
+ }
|
|
+ return 0;
|
|
}
|
|
|
|
-int
|
|
-shard_common_inode_write_post_update_size_handler(call_frame_t *frame,
|
|
- xlator_t *this)
|
|
-{
|
|
- shard_local_t *local = NULL;
|
|
+int shard_post_resolve_readv_handler(call_frame_t *frame, xlator_t *this) {
|
|
+ shard_local_t *local = NULL;
|
|
|
|
- local = frame->local;
|
|
+ local = frame->local;
|
|
|
|
- if (local->op_ret < 0) {
|
|
- shard_common_failure_unwind(local->fop, frame, local->op_ret,
|
|
- local->op_errno);
|
|
+ if (local->op_ret < 0) {
|
|
+ if (local->op_errno != ENOENT) {
|
|
+ shard_common_failure_unwind(GF_FOP_READ, frame, local->op_ret,
|
|
+ local->op_errno);
|
|
+ return 0;
|
|
} else {
|
|
- shard_common_inode_write_success_unwind(local->fop, frame,
|
|
- local->written_size);
|
|
+ struct iovec vec = {
|
|
+ 0,
|
|
+ };
|
|
+
|
|
+ vec.iov_base = local->iobuf->ptr;
|
|
+ vec.iov_len = local->total_size;
|
|
+ local->op_ret = local->total_size;
|
|
+ SHARD_STACK_UNWIND(readv, frame, local->op_ret, 0, &vec, 1,
|
|
+ &local->prebuf, local->iobref, NULL);
|
|
+ return 0;
|
|
}
|
|
- return 0;
|
|
-}
|
|
+ }
|
|
|
|
-static gf_boolean_t
|
|
-shard_is_appending_write(shard_local_t *local)
|
|
-{
|
|
- if (local->fop != GF_FOP_WRITE)
|
|
- return _gf_false;
|
|
- if (local->flags & O_APPEND)
|
|
- return _gf_true;
|
|
- if (local->fd->flags & O_APPEND)
|
|
- return _gf_true;
|
|
- return _gf_false;
|
|
+ if (local->call_count) {
|
|
+ shard_common_lookup_shards(frame, this, local->resolver_base_inode,
|
|
+ shard_post_lookup_shards_readv_handler);
|
|
+ } else {
|
|
+ shard_readv_do(frame, this);
|
|
+ }
|
|
+
|
|
+ return 0;
|
|
}
|
|
|
|
-int
|
|
-__shard_get_delta_size_from_inode_ctx(shard_local_t *local, inode_t *inode,
|
|
- xlator_t *this)
|
|
-{
|
|
- int ret = -1;
|
|
- uint64_t ctx_uint = 0;
|
|
- shard_inode_ctx_t *ctx = NULL;
|
|
+int shard_post_lookup_readv_handler(call_frame_t *frame, xlator_t *this) {
|
|
+ int ret = 0;
|
|
+ struct iobuf *iobuf = NULL;
|
|
+ shard_local_t *local = NULL;
|
|
+ shard_priv_t *priv = NULL;
|
|
+
|
|
+ priv = this->private;
|
|
+ local = frame->local;
|
|
|
|
- ret = __inode_ctx_get(inode, this, &ctx_uint);
|
|
- if (ret < 0)
|
|
- return ret;
|
|
+ if (local->op_ret < 0) {
|
|
+ shard_common_failure_unwind(GF_FOP_READ, frame, local->op_ret,
|
|
+ local->op_errno);
|
|
+ return 0;
|
|
+ }
|
|
|
|
- ctx = (shard_inode_ctx_t *)(uintptr_t)ctx_uint;
|
|
+ if (local->offset >= local->prebuf.ia_size) {
|
|
+ /* If the read is being performed past the end of the file,
|
|
+ * unwind the FOP with 0 bytes read as status.
|
|
+ */
|
|
+ struct iovec vec = {
|
|
+ 0,
|
|
+ };
|
|
|
|
- if (shard_is_appending_write(local)) {
|
|
- local->delta_size = local->total_size;
|
|
- } else if (local->offset + local->total_size > ctx->stat.ia_size) {
|
|
- local->delta_size = (local->offset + local->total_size) -
|
|
- ctx->stat.ia_size;
|
|
- } else {
|
|
- local->delta_size = 0;
|
|
- }
|
|
- ctx->stat.ia_size += (local->delta_size);
|
|
- local->postbuf = ctx->stat;
|
|
+ iobuf = iobuf_get2(this->ctx->iobuf_pool, local->req_size);
|
|
+ if (!iobuf)
|
|
+ goto err;
|
|
+
|
|
+ vec.iov_base = iobuf->ptr;
|
|
+ vec.iov_len = 0;
|
|
+ local->iobref = iobref_new();
|
|
+ iobref_add(local->iobref, iobuf);
|
|
+ iobuf_unref(iobuf);
|
|
|
|
+ SHARD_STACK_UNWIND(readv, frame, 0, 0, &vec, 1, &local->prebuf,
|
|
+ local->iobref, NULL);
|
|
return 0;
|
|
-}
|
|
+ }
|
|
|
|
-int
|
|
-shard_get_delta_size_from_inode_ctx(shard_local_t *local, inode_t *inode,
|
|
- xlator_t *this)
|
|
-{
|
|
- int ret = -1;
|
|
+ local->first_block = get_lowest_block(local->offset, local->block_size);
|
|
|
|
- LOCK(&inode->lock);
|
|
- {
|
|
- ret = __shard_get_delta_size_from_inode_ctx(local, inode, this);
|
|
- }
|
|
- UNLOCK(&inode->lock);
|
|
+ local->total_size = local->req_size;
|
|
|
|
- return ret;
|
|
-}
|
|
+ local->last_block =
|
|
+ get_highest_block(local->offset, local->total_size, local->block_size);
|
|
|
|
-int
|
|
-shard_common_inode_write_do_cbk(call_frame_t *frame, void *cookie,
|
|
- xlator_t *this, int32_t op_ret,
|
|
- int32_t op_errno, struct iatt *pre,
|
|
- struct iatt *post, dict_t *xdata)
|
|
-{
|
|
- int call_count = 0;
|
|
- fd_t *anon_fd = cookie;
|
|
- shard_local_t *local = NULL;
|
|
- glusterfs_fop_t fop = 0;
|
|
+ local->num_blocks = local->last_block - local->first_block + 1;
|
|
+ local->resolver_base_inode = local->loc.inode;
|
|
|
|
- local = frame->local;
|
|
- fop = local->fop;
|
|
+ local->inode_list =
|
|
+ GF_CALLOC(local->num_blocks, sizeof(inode_t *), gf_shard_mt_inode_list);
|
|
+ if (!local->inode_list)
|
|
+ goto err;
|
|
|
|
- LOCK(&frame->lock);
|
|
- {
|
|
- if (op_ret < 0) {
|
|
- local->op_ret = op_ret;
|
|
- local->op_errno = op_errno;
|
|
- } else {
|
|
- local->written_size += op_ret;
|
|
- GF_ATOMIC_ADD(local->delta_blocks,
|
|
- post->ia_blocks - pre->ia_blocks);
|
|
- local->delta_size += (post->ia_size - pre->ia_size);
|
|
- shard_inode_ctx_set(local->fd->inode, this, post, 0,
|
|
- SHARD_MASK_TIMES);
|
|
- if (local->fd->inode != anon_fd->inode)
|
|
- shard_inode_ctx_add_to_fsync_list(local->fd->inode, this,
|
|
- anon_fd->inode);
|
|
- }
|
|
- }
|
|
- UNLOCK(&frame->lock);
|
|
+ iobuf = iobuf_get2(this->ctx->iobuf_pool, local->total_size);
|
|
+ if (!iobuf)
|
|
+ goto err;
|
|
|
|
- if (anon_fd)
|
|
- fd_unref(anon_fd);
|
|
+ local->iobref = iobref_new();
|
|
+ if (!local->iobref) {
|
|
+ iobuf_unref(iobuf);
|
|
+ goto err;
|
|
+ }
|
|
|
|
- call_count = shard_call_count_return(frame);
|
|
- if (call_count == 0) {
|
|
- SHARD_UNSET_ROOT_FS_ID(frame, local);
|
|
- if (local->op_ret < 0) {
|
|
- shard_common_failure_unwind(fop, frame, local->op_ret,
|
|
- local->op_errno);
|
|
- } else {
|
|
- shard_get_delta_size_from_inode_ctx(local, local->fd->inode, this);
|
|
- local->hole_size = 0;
|
|
- if (xdata)
|
|
- local->xattr_rsp = dict_ref(xdata);
|
|
- shard_update_file_size(
|
|
- frame, this, local->fd, NULL,
|
|
- shard_common_inode_write_post_update_size_handler);
|
|
- }
|
|
- }
|
|
+ if (iobref_add(local->iobref, iobuf) != 0) {
|
|
+ iobuf_unref(iobuf);
|
|
+ goto err;
|
|
+ }
|
|
|
|
- return 0;
|
|
+ memset(iobuf->ptr, 0, local->total_size);
|
|
+ iobuf_unref(iobuf);
|
|
+ local->iobuf = iobuf;
|
|
+
|
|
+ local->dot_shard_loc.inode = inode_find(this->itable, priv->dot_shard_gfid);
|
|
+ if (!local->dot_shard_loc.inode) {
|
|
+ ret =
|
|
+ shard_init_internal_dir_loc(this, local, SHARD_INTERNAL_DIR_DOT_SHARD);
|
|
+ if (ret)
|
|
+ goto err;
|
|
+ shard_lookup_internal_dir(frame, this, shard_post_resolve_readv_handler,
|
|
+ SHARD_INTERNAL_DIR_DOT_SHARD);
|
|
+ } else {
|
|
+ local->post_res_handler = shard_post_resolve_readv_handler;
|
|
+ shard_refresh_internal_dir(frame, this, SHARD_INTERNAL_DIR_DOT_SHARD);
|
|
+ }
|
|
+ return 0;
|
|
+err:
|
|
+ shard_common_failure_unwind(GF_FOP_READ, frame, -1, ENOMEM);
|
|
+ return 0;
|
|
+}
|
|
+
|
|
+int shard_readv(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
|
|
+ off_t offset, uint32_t flags, dict_t *xdata) {
|
|
+ int ret = 0;
|
|
+ uint64_t block_size = 0;
|
|
+ shard_local_t *local = NULL;
|
|
+
|
|
+ ret = shard_inode_ctx_get_block_size(fd->inode, this, &block_size);
|
|
+ if (ret) {
|
|
+ gf_msg(this->name, GF_LOG_ERROR, 0, SHARD_MSG_INODE_CTX_GET_FAILED,
|
|
+ "Failed to get block "
|
|
+ "size for %s from its inode ctx",
|
|
+ uuid_utoa(fd->inode->gfid));
|
|
+ goto err;
|
|
+ }
|
|
+
|
|
+ if (!block_size || frame->root->pid == GF_CLIENT_PID_GSYNCD) {
|
|
+ /* block_size = 0 means that the file was created before
|
|
+ * sharding was enabled on the volume.
|
|
+ */
|
|
+ STACK_WIND(frame, default_readv_cbk, FIRST_CHILD(this),
|
|
+ FIRST_CHILD(this)->fops->readv, fd, size, offset, flags, xdata);
|
|
+ return 0;
|
|
+ }
|
|
+
|
|
+ if (!this->itable)
|
|
+ this->itable = fd->inode->table;
|
|
+
|
|
+ local = mem_get0(this->local_pool);
|
|
+ if (!local)
|
|
+ goto err;
|
|
+
|
|
+ frame->local = local;
|
|
+
|
|
+ ret = syncbarrier_init(&local->barrier);
|
|
+ if (ret)
|
|
+ goto err;
|
|
+ local->fd = fd_ref(fd);
|
|
+ local->block_size = block_size;
|
|
+ local->offset = offset;
|
|
+ local->req_size = size;
|
|
+ local->flags = flags;
|
|
+ local->fop = GF_FOP_READ;
|
|
+ local->xattr_req = (xdata) ? dict_ref(xdata) : dict_new();
|
|
+ if (!local->xattr_req)
|
|
+ goto err;
|
|
+
|
|
+ local->loc.inode = inode_ref(fd->inode);
|
|
+ gf_uuid_copy(local->loc.gfid, fd->inode->gfid);
|
|
+
|
|
+ shard_lookup_base_file(frame, this, &local->loc,
|
|
+ shard_post_lookup_readv_handler);
|
|
+ return 0;
|
|
+err:
|
|
+ shard_common_failure_unwind(GF_FOP_READ, frame, -1, ENOMEM);
|
|
+ return 0;
|
|
}
|
|
|
|
-int
|
|
-shard_common_inode_write_wind(call_frame_t *frame, xlator_t *this, fd_t *fd,
|
|
- struct iovec *vec, int count, off_t shard_offset,
|
|
- size_t size)
|
|
-{
|
|
- shard_local_t *local = NULL;
|
|
+int shard_common_inode_write_post_update_size_handler(call_frame_t *frame,
|
|
+ xlator_t *this) {
|
|
+ shard_local_t *local = NULL;
|
|
|
|
- local = frame->local;
|
|
+ local = frame->local;
|
|
|
|
- switch (local->fop) {
|
|
- case GF_FOP_WRITE:
|
|
- STACK_WIND_COOKIE(
|
|
- frame, shard_common_inode_write_do_cbk, fd, FIRST_CHILD(this),
|
|
- FIRST_CHILD(this)->fops->writev, fd, vec, count, shard_offset,
|
|
- local->flags, local->iobref, local->xattr_req);
|
|
- break;
|
|
- case GF_FOP_FALLOCATE:
|
|
- STACK_WIND_COOKIE(
|
|
- frame, shard_common_inode_write_do_cbk, fd, FIRST_CHILD(this),
|
|
- FIRST_CHILD(this)->fops->fallocate, fd, local->flags,
|
|
- shard_offset, size, local->xattr_req);
|
|
- break;
|
|
- case GF_FOP_ZEROFILL:
|
|
- STACK_WIND_COOKIE(frame, shard_common_inode_write_do_cbk, fd,
|
|
- FIRST_CHILD(this),
|
|
- FIRST_CHILD(this)->fops->zerofill, fd,
|
|
- shard_offset, size, local->xattr_req);
|
|
- break;
|
|
- case GF_FOP_DISCARD:
|
|
- STACK_WIND_COOKIE(frame, shard_common_inode_write_do_cbk, fd,
|
|
- FIRST_CHILD(this),
|
|
- FIRST_CHILD(this)->fops->discard, fd,
|
|
- shard_offset, size, local->xattr_req);
|
|
- break;
|
|
- default:
|
|
- gf_msg(this->name, GF_LOG_WARNING, 0, SHARD_MSG_INVALID_FOP,
|
|
- "Invalid fop id = %d", local->fop);
|
|
- break;
|
|
- }
|
|
- return 0;
|
|
+ if (local->op_ret < 0) {
|
|
+ shard_common_failure_unwind(local->fop, frame, local->op_ret,
|
|
+ local->op_errno);
|
|
+ } else {
|
|
+ shard_common_inode_write_success_unwind(local->fop, frame,
|
|
+ local->written_size);
|
|
+ }
|
|
+ return 0;
|
|
}
|
|
|
|
-int
|
|
-shard_common_inode_write_do(call_frame_t *frame, xlator_t *this)
|
|
-{
|
|
- int i = 0;
|
|
- int count = 0;
|
|
- int call_count = 0;
|
|
- int last_block = 0;
|
|
- uint32_t cur_block = 0;
|
|
- fd_t *fd = NULL;
|
|
- fd_t *anon_fd = NULL;
|
|
- shard_local_t *local = NULL;
|
|
- struct iovec *vec = NULL;
|
|
- gf_boolean_t wind_failed = _gf_false;
|
|
- gf_boolean_t odirect = _gf_false;
|
|
- off_t orig_offset = 0;
|
|
- off_t shard_offset = 0;
|
|
- off_t vec_offset = 0;
|
|
- size_t remaining_size = 0;
|
|
- size_t shard_write_size = 0;
|
|
-
|
|
- local = frame->local;
|
|
- fd = local->fd;
|
|
-
|
|
- orig_offset = local->offset;
|
|
- remaining_size = local->total_size;
|
|
- cur_block = local->first_block;
|
|
- local->call_count = call_count = local->num_blocks;
|
|
- last_block = local->last_block;
|
|
-
|
|
- SHARD_SET_ROOT_FS_ID(frame, local);
|
|
-
|
|
- if (dict_set_uint32(local->xattr_req, GLUSTERFS_WRITE_UPDATE_ATOMIC, 4)) {
|
|
- gf_msg(this->name, GF_LOG_ERROR, 0, SHARD_MSG_DICT_OP_FAILED,
|
|
- "Failed to set " GLUSTERFS_WRITE_UPDATE_ATOMIC
|
|
- " into "
|
|
- "dict: %s",
|
|
- uuid_utoa(fd->inode->gfid));
|
|
- local->op_ret = -1;
|
|
- local->op_errno = ENOMEM;
|
|
- local->call_count = 1;
|
|
- shard_common_inode_write_do_cbk(frame, (void *)(long)0, this, -1,
|
|
- ENOMEM, NULL, NULL, NULL);
|
|
- return 0;
|
|
- }
|
|
+static gf_boolean_t shard_is_appending_write(shard_local_t *local) {
|
|
+ if (local->fop != GF_FOP_WRITE)
|
|
+ return _gf_false;
|
|
+ if (local->flags & O_APPEND)
|
|
+ return _gf_true;
|
|
+ if (local->fd->flags & O_APPEND)
|
|
+ return _gf_true;
|
|
+ return _gf_false;
|
|
+}
|
|
|
|
- if ((fd->flags & O_DIRECT) && (local->fop == GF_FOP_WRITE))
|
|
- odirect = _gf_true;
|
|
+int __shard_get_delta_size_from_inode_ctx(shard_local_t *local, inode_t *inode,
|
|
+ xlator_t *this) {
|
|
+ int ret = -1;
|
|
+ uint64_t ctx_uint = 0;
|
|
+ shard_inode_ctx_t *ctx = NULL;
|
|
|
|
- while (cur_block <= last_block) {
|
|
- if (wind_failed) {
|
|
- shard_common_inode_write_do_cbk(frame, (void *)(long)0, this, -1,
|
|
- ENOMEM, NULL, NULL, NULL);
|
|
- goto next;
|
|
- }
|
|
+ ret = __inode_ctx_get(inode, this, &ctx_uint);
|
|
+ if (ret < 0)
|
|
+ return ret;
|
|
|
|
- shard_offset = orig_offset % local->block_size;
|
|
- shard_write_size = local->block_size - shard_offset;
|
|
- if (shard_write_size > remaining_size)
|
|
- shard_write_size = remaining_size;
|
|
-
|
|
- remaining_size -= shard_write_size;
|
|
-
|
|
- if (local->fop == GF_FOP_WRITE) {
|
|
- count = iov_subset(local->vector, local->count, vec_offset,
|
|
- vec_offset + shard_write_size, NULL);
|
|
-
|
|
- vec = GF_CALLOC(count, sizeof(struct iovec), gf_shard_mt_iovec);
|
|
- if (!vec) {
|
|
- local->op_ret = -1;
|
|
- local->op_errno = ENOMEM;
|
|
- wind_failed = _gf_true;
|
|
- GF_FREE(vec);
|
|
- shard_common_inode_write_do_cbk(frame, (void *)(long)0, this,
|
|
- -1, ENOMEM, NULL, NULL, NULL);
|
|
- goto next;
|
|
- }
|
|
- count = iov_subset(local->vector, local->count, vec_offset,
|
|
- vec_offset + shard_write_size, vec);
|
|
- }
|
|
+ ctx = (shard_inode_ctx_t *)(uintptr_t)ctx_uint;
|
|
|
|
- if (cur_block == 0) {
|
|
- anon_fd = fd_ref(fd);
|
|
- } else {
|
|
- anon_fd = fd_anonymous(local->inode_list[i]);
|
|
- if (!anon_fd) {
|
|
- local->op_ret = -1;
|
|
- local->op_errno = ENOMEM;
|
|
- wind_failed = _gf_true;
|
|
- GF_FREE(vec);
|
|
- shard_common_inode_write_do_cbk(frame, (void *)(long)anon_fd,
|
|
- this, -1, ENOMEM, NULL, NULL,
|
|
- NULL);
|
|
- goto next;
|
|
- }
|
|
-
|
|
- if (local->fop == GF_FOP_WRITE) {
|
|
- if (odirect)
|
|
- local->flags = O_DIRECT;
|
|
- else
|
|
- local->flags = GF_ANON_FD_FLAGS;
|
|
- }
|
|
- }
|
|
+ if (shard_is_appending_write(local)) {
|
|
+ local->delta_size = local->total_size;
|
|
+ } else if (local->offset + local->total_size > ctx->stat.ia_size) {
|
|
+ local->delta_size = (local->offset + local->total_size) - ctx->stat.ia_size;
|
|
+ } else {
|
|
+ local->delta_size = 0;
|
|
+ }
|
|
+ ctx->stat.ia_size += (local->delta_size);
|
|
+ local->postbuf = ctx->stat;
|
|
|
|
- shard_common_inode_write_wind(frame, this, anon_fd, vec, count,
|
|
- shard_offset, shard_write_size);
|
|
- if (vec)
|
|
- vec_offset += shard_write_size;
|
|
- orig_offset += shard_write_size;
|
|
- GF_FREE(vec);
|
|
- vec = NULL;
|
|
- next:
|
|
- cur_block++;
|
|
- i++;
|
|
- call_count--;
|
|
- }
|
|
- return 0;
|
|
+ return 0;
|
|
}
|
|
|
|
-int
|
|
-shard_common_inode_write_post_mknod_handler(call_frame_t *frame,
|
|
- xlator_t *this);
|
|
+int shard_get_delta_size_from_inode_ctx(shard_local_t *local, inode_t *inode,
|
|
+ xlator_t *this) {
|
|
+ int ret = -1;
|
|
+
|
|
+ LOCK(&inode->lock);
|
|
+ { ret = __shard_get_delta_size_from_inode_ctx(local, inode, this); }
|
|
+ UNLOCK(&inode->lock);
|
|
|
|
-int
|
|
-shard_common_inode_write_post_lookup_shards_handler(call_frame_t *frame,
|
|
- xlator_t *this)
|
|
-{
|
|
- shard_local_t *local = NULL;
|
|
+ return ret;
|
|
+}
|
|
|
|
- local = frame->local;
|
|
+int shard_common_inode_write_do_cbk(call_frame_t *frame, void *cookie,
|
|
+ xlator_t *this, int32_t op_ret,
|
|
+ int32_t op_errno, struct iatt *pre,
|
|
+ struct iatt *post, dict_t *xdata) {
|
|
+ int call_count = 0;
|
|
+ fd_t *anon_fd = cookie;
|
|
+ shard_local_t *local = NULL;
|
|
+ glusterfs_fop_t fop = 0;
|
|
|
|
- if (local->op_ret < 0) {
|
|
- shard_common_failure_unwind(local->fop, frame, local->op_ret,
|
|
- local->op_errno);
|
|
- return 0;
|
|
- }
|
|
+ local = frame->local;
|
|
+ fop = local->fop;
|
|
|
|
- if (local->create_count) {
|
|
- shard_common_resume_mknod(frame, this,
|
|
- shard_common_inode_write_post_mknod_handler);
|
|
+ LOCK(&frame->lock);
|
|
+ {
|
|
+ if (op_ret < 0) {
|
|
+ local->op_ret = op_ret;
|
|
+ local->op_errno = op_errno;
|
|
} else {
|
|
- shard_common_inode_write_do(frame, this);
|
|
+ local->written_size += op_ret;
|
|
+ GF_ATOMIC_ADD(local->delta_blocks, post->ia_blocks - pre->ia_blocks);
|
|
+ local->delta_size += (post->ia_size - pre->ia_size);
|
|
+ shard_inode_ctx_set(local->fd->inode, this, post, 0, SHARD_MASK_TIMES);
|
|
+ if (local->fd->inode != anon_fd->inode)
|
|
+ shard_inode_ctx_add_to_fsync_list(local->fd->inode, this,
|
|
+ anon_fd->inode);
|
|
+ }
|
|
+ }
|
|
+ UNLOCK(&frame->lock);
|
|
+
|
|
+ if (anon_fd)
|
|
+ fd_unref(anon_fd);
|
|
+
|
|
+ call_count = shard_call_count_return(frame);
|
|
+ if (call_count == 0) {
|
|
+ SHARD_UNSET_ROOT_FS_ID(frame, local);
|
|
+ if (local->op_ret < 0) {
|
|
+ shard_common_failure_unwind(fop, frame, local->op_ret, local->op_errno);
|
|
+ } else {
|
|
+ shard_get_delta_size_from_inode_ctx(local, local->fd->inode, this);
|
|
+ local->hole_size = 0;
|
|
+ if (xdata)
|
|
+ local->xattr_rsp = dict_ref(xdata);
|
|
+ shard_update_file_size(frame, this, local->fd, NULL,
|
|
+ shard_common_inode_write_post_update_size_handler);
|
|
}
|
|
+ }
|
|
|
|
- return 0;
|
|
+ return 0;
|
|
}
|
|
|
|
-int
|
|
-shard_common_inode_write_post_mknod_handler(call_frame_t *frame, xlator_t *this)
|
|
-{
|
|
- shard_local_t *local = NULL;
|
|
+int shard_common_inode_write_wind(call_frame_t *frame, xlator_t *this, fd_t *fd,
|
|
+ struct iovec *vec, int count,
|
|
+ off_t shard_offset, size_t size) {
|
|
+ shard_local_t *local = NULL;
|
|
|
|
- local = frame->local;
|
|
+ local = frame->local;
|
|
|
|
- if (local->op_ret < 0) {
|
|
- shard_common_failure_unwind(local->fop, frame, local->op_ret,
|
|
- local->op_errno);
|
|
- return 0;
|
|
- }
|
|
+ switch (local->fop) {
|
|
+ case GF_FOP_WRITE:
|
|
+ STACK_WIND_COOKIE(frame, shard_common_inode_write_do_cbk, fd,
|
|
+ FIRST_CHILD(this), FIRST_CHILD(this)->fops->writev, fd,
|
|
+ vec, count, shard_offset, local->flags, local->iobref,
|
|
+ local->xattr_req);
|
|
+ break;
|
|
+ case GF_FOP_FALLOCATE:
|
|
+ STACK_WIND_COOKIE(frame, shard_common_inode_write_do_cbk, fd,
|
|
+ FIRST_CHILD(this), FIRST_CHILD(this)->fops->fallocate, fd,
|
|
+ local->flags, shard_offset, size, local->xattr_req);
|
|
+ break;
|
|
+ case GF_FOP_ZEROFILL:
|
|
+ STACK_WIND_COOKIE(frame, shard_common_inode_write_do_cbk, fd,
|
|
+ FIRST_CHILD(this), FIRST_CHILD(this)->fops->zerofill, fd,
|
|
+ shard_offset, size, local->xattr_req);
|
|
+ break;
|
|
+ case GF_FOP_DISCARD:
|
|
+ STACK_WIND_COOKIE(frame, shard_common_inode_write_do_cbk, fd,
|
|
+ FIRST_CHILD(this), FIRST_CHILD(this)->fops->discard, fd,
|
|
+ shard_offset, size, local->xattr_req);
|
|
+ break;
|
|
+ default:
|
|
+ gf_msg(this->name, GF_LOG_WARNING, 0, SHARD_MSG_INVALID_FOP,
|
|
+ "Invalid fop id = %d", local->fop);
|
|
+ break;
|
|
+ }
|
|
+ return 0;
|
|
+}
|
|
+
|
|
+int shard_common_inode_write_do(call_frame_t *frame, xlator_t *this) {
|
|
+ int i = 0;
|
|
+ int count = 0;
|
|
+ int call_count = 0;
|
|
+ int last_block = 0;
|
|
+ uint32_t cur_block = 0;
|
|
+ fd_t *fd = NULL;
|
|
+ fd_t *anon_fd = NULL;
|
|
+ shard_local_t *local = NULL;
|
|
+ struct iovec *vec = NULL;
|
|
+ gf_boolean_t wind_failed = _gf_false;
|
|
+ gf_boolean_t odirect = _gf_false;
|
|
+ off_t orig_offset = 0;
|
|
+ off_t shard_offset = 0;
|
|
+ off_t vec_offset = 0;
|
|
+ size_t remaining_size = 0;
|
|
+ size_t shard_write_size = 0;
|
|
+
|
|
+ local = frame->local;
|
|
+ fd = local->fd;
|
|
+
|
|
+ orig_offset = local->offset;
|
|
+ remaining_size = local->total_size;
|
|
+ cur_block = local->first_block;
|
|
+ local->call_count = call_count = local->num_blocks;
|
|
+ last_block = local->last_block;
|
|
+
|
|
+ SHARD_SET_ROOT_FS_ID(frame, local);
|
|
+
|
|
+ if (dict_set_uint32(local->xattr_req, GLUSTERFS_WRITE_UPDATE_ATOMIC, 4)) {
|
|
+ gf_msg(this->name, GF_LOG_ERROR, 0, SHARD_MSG_DICT_OP_FAILED,
|
|
+ "Failed to set " GLUSTERFS_WRITE_UPDATE_ATOMIC " into "
|
|
+ "dict: %s",
|
|
+ uuid_utoa(fd->inode->gfid));
|
|
+ local->op_ret = -1;
|
|
+ local->op_errno = ENOMEM;
|
|
+ local->call_count = 1;
|
|
+ shard_common_inode_write_do_cbk(frame, (void *)(long)0, this, -1, ENOMEM,
|
|
+ NULL, NULL, NULL);
|
|
+ return 0;
|
|
+ }
|
|
|
|
- if (!local->eexist_count) {
|
|
- shard_common_inode_write_do(frame, this);
|
|
- } else {
|
|
- local->call_count = local->eexist_count;
|
|
- shard_common_lookup_shards(
|
|
- frame, this, local->loc.inode,
|
|
- shard_common_inode_write_post_lookup_shards_handler);
|
|
+ if ((fd->flags & O_DIRECT) && (local->fop == GF_FOP_WRITE))
|
|
+ odirect = _gf_true;
|
|
+
|
|
+ while (cur_block <= last_block) {
|
|
+ if (wind_failed) {
|
|
+ shard_common_inode_write_do_cbk(frame, (void *)(long)0, this, -1, ENOMEM,
|
|
+ NULL, NULL, NULL);
|
|
+ goto next;
|
|
}
|
|
|
|
- return 0;
|
|
-}
|
|
+ shard_offset = orig_offset % local->block_size;
|
|
+ shard_write_size = local->block_size - shard_offset;
|
|
+ if (shard_write_size > remaining_size)
|
|
+ shard_write_size = remaining_size;
|
|
|
|
-int
|
|
-shard_common_inode_write_post_resolve_handler(call_frame_t *frame,
|
|
- xlator_t *this)
|
|
-{
|
|
- shard_local_t *local = NULL;
|
|
+ remaining_size -= shard_write_size;
|
|
|
|
- local = frame->local;
|
|
+ if (local->fop == GF_FOP_WRITE) {
|
|
+ count = iov_subset(local->vector, local->count, vec_offset,
|
|
+ vec_offset + shard_write_size, NULL);
|
|
|
|
- if (local->op_ret < 0) {
|
|
- shard_common_failure_unwind(local->fop, frame, local->op_ret,
|
|
- local->op_errno);
|
|
- return 0;
|
|
+ vec = GF_CALLOC(count, sizeof(struct iovec), gf_shard_mt_iovec);
|
|
+ if (!vec) {
|
|
+ local->op_ret = -1;
|
|
+ local->op_errno = ENOMEM;
|
|
+ wind_failed = _gf_true;
|
|
+ GF_FREE(vec);
|
|
+ shard_common_inode_write_do_cbk(frame, (void *)(long)0, this, -1,
|
|
+ ENOMEM, NULL, NULL, NULL);
|
|
+ goto next;
|
|
+ }
|
|
+ count = iov_subset(local->vector, local->count, vec_offset,
|
|
+ vec_offset + shard_write_size, vec);
|
|
}
|
|
|
|
- if (local->call_count) {
|
|
- shard_common_lookup_shards(
|
|
- frame, this, local->resolver_base_inode,
|
|
- shard_common_inode_write_post_lookup_shards_handler);
|
|
+ if (cur_block == 0) {
|
|
+ anon_fd = fd_ref(fd);
|
|
} else {
|
|
- shard_common_inode_write_do(frame, this);
|
|
- }
|
|
+ anon_fd = fd_anonymous(local->inode_list[i]);
|
|
+ if (!anon_fd) {
|
|
+ local->op_ret = -1;
|
|
+ local->op_errno = ENOMEM;
|
|
+ wind_failed = _gf_true;
|
|
+ GF_FREE(vec);
|
|
+ shard_common_inode_write_do_cbk(frame, (void *)(long)anon_fd, this, -1,
|
|
+ ENOMEM, NULL, NULL, NULL);
|
|
+ goto next;
|
|
+ }
|
|
|
|
- return 0;
|
|
+ if (local->fop == GF_FOP_WRITE) {
|
|
+ if (odirect)
|
|
+ local->flags = O_DIRECT;
|
|
+ else
|
|
+ local->flags = GF_ANON_FD_FLAGS;
|
|
+ }
|
|
+ }
|
|
+
|
|
+ shard_common_inode_write_wind(frame, this, anon_fd, vec, count,
|
|
+ shard_offset, shard_write_size);
|
|
+ if (vec)
|
|
+ vec_offset += shard_write_size;
|
|
+ orig_offset += shard_write_size;
|
|
+ GF_FREE(vec);
|
|
+ vec = NULL;
|
|
+ next:
|
|
+ cur_block++;
|
|
+ i++;
|
|
+ call_count--;
|
|
+ }
|
|
+ return 0;
|
|
}
|
|
|
|
-int
|
|
-shard_common_inode_write_post_lookup_handler(call_frame_t *frame,
|
|
- xlator_t *this)
|
|
-{
|
|
- shard_local_t *local = frame->local;
|
|
- shard_priv_t *priv = this->private;
|
|
-
|
|
- if (local->op_ret < 0) {
|
|
- shard_common_failure_unwind(local->fop, frame, local->op_ret,
|
|
- local->op_errno);
|
|
- return 0;
|
|
- }
|
|
-
|
|
- local->postbuf = local->prebuf;
|
|
-
|
|
- /*Adjust offset to EOF so that correct shard is chosen for append*/
|
|
- if (shard_is_appending_write(local))
|
|
- local->offset = local->prebuf.ia_size;
|
|
-
|
|
- local->first_block = get_lowest_block(local->offset, local->block_size);
|
|
- local->last_block = get_highest_block(local->offset, local->total_size,
|
|
- local->block_size);
|
|
- local->num_blocks = local->last_block - local->first_block + 1;
|
|
- local->inode_list = GF_CALLOC(local->num_blocks, sizeof(inode_t *),
|
|
- gf_shard_mt_inode_list);
|
|
- if (!local->inode_list) {
|
|
- shard_common_failure_unwind(local->fop, frame, -1, ENOMEM);
|
|
- return 0;
|
|
- }
|
|
+int shard_common_inode_write_post_mknod_handler(call_frame_t *frame,
|
|
+ xlator_t *this);
|
|
|
|
- gf_msg_trace(this->name, 0,
|
|
- "%s: gfid=%s first_block=%" PRIu32
|
|
- " "
|
|
- "last_block=%" PRIu32 " num_blocks=%" PRIu32 " offset=%" PRId64
|
|
- " total_size=%zu flags=%" PRId32 "",
|
|
- gf_fop_list[local->fop],
|
|
- uuid_utoa(local->resolver_base_inode->gfid),
|
|
- local->first_block, local->last_block, local->num_blocks,
|
|
- local->offset, local->total_size, local->flags);
|
|
+int shard_common_inode_write_post_lookup_shards_handler(call_frame_t *frame,
|
|
+ xlator_t *this) {
|
|
+ shard_local_t *local = NULL;
|
|
|
|
- local->dot_shard_loc.inode = inode_find(this->itable, priv->dot_shard_gfid);
|
|
+ local = frame->local;
|
|
|
|
- if (!local->dot_shard_loc.inode) {
|
|
- /*change handler*/
|
|
- shard_mkdir_internal_dir(frame, this,
|
|
- shard_common_inode_write_post_resolve_handler,
|
|
- SHARD_INTERNAL_DIR_DOT_SHARD);
|
|
- } else {
|
|
- /*change handler*/
|
|
- local->post_res_handler = shard_common_inode_write_post_resolve_handler;
|
|
- shard_refresh_internal_dir(frame, this, SHARD_INTERNAL_DIR_DOT_SHARD);
|
|
- }
|
|
+ if (local->op_ret < 0) {
|
|
+ shard_common_failure_unwind(local->fop, frame, local->op_ret,
|
|
+ local->op_errno);
|
|
return 0;
|
|
-}
|
|
-
|
|
-int
|
|
-shard_mkdir_internal_dir_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
|
|
- int32_t op_ret, int32_t op_errno, inode_t *inode,
|
|
- struct iatt *buf, struct iatt *preparent,
|
|
- struct iatt *postparent, dict_t *xdata)
|
|
-{
|
|
- inode_t *link_inode = NULL;
|
|
- shard_local_t *local = NULL;
|
|
- shard_internal_dir_type_t type = (shard_internal_dir_type_t)cookie;
|
|
+ }
|
|
|
|
- local = frame->local;
|
|
+ if (local->create_count) {
|
|
+ shard_common_resume_mknod(frame, this,
|
|
+ shard_common_inode_write_post_mknod_handler);
|
|
+ } else {
|
|
+ shard_common_inode_write_do(frame, this);
|
|
+ }
|
|
|
|
- SHARD_UNSET_ROOT_FS_ID(frame, local);
|
|
+ return 0;
|
|
+}
|
|
|
|
- if (op_ret == -1) {
|
|
- if (op_errno != EEXIST) {
|
|
- local->op_ret = op_ret;
|
|
- local->op_errno = op_errno;
|
|
- goto unwind;
|
|
- } else {
|
|
- gf_msg_debug(this->name, 0,
|
|
- "mkdir on %s failed "
|
|
- "with EEXIST. Attempting lookup now",
|
|
- shard_internal_dir_string(type));
|
|
- shard_lookup_internal_dir(frame, this, local->post_res_handler,
|
|
- type);
|
|
- return 0;
|
|
- }
|
|
- }
|
|
+int shard_common_inode_write_post_mknod_handler(call_frame_t *frame,
|
|
+ xlator_t *this) {
|
|
+ shard_local_t *local = NULL;
|
|
|
|
- link_inode = shard_link_internal_dir_inode(local, inode, buf, type);
|
|
- if (link_inode != inode) {
|
|
- shard_refresh_internal_dir(frame, this, type);
|
|
- } else {
|
|
- shard_inode_ctx_mark_dir_refreshed(link_inode, this);
|
|
- shard_common_resolve_shards(frame, this, local->post_res_handler);
|
|
- }
|
|
- return 0;
|
|
-unwind:
|
|
- shard_common_resolve_shards(frame, this, local->post_res_handler);
|
|
- return 0;
|
|
-}
|
|
+ local = frame->local;
|
|
|
|
-int
|
|
-shard_mkdir_internal_dir(call_frame_t *frame, xlator_t *this,
|
|
- shard_post_resolve_fop_handler_t handler,
|
|
- shard_internal_dir_type_t type)
|
|
-{
|
|
- int ret = -1;
|
|
- shard_local_t *local = NULL;
|
|
- shard_priv_t *priv = NULL;
|
|
- dict_t *xattr_req = NULL;
|
|
- uuid_t *gfid = NULL;
|
|
- loc_t *loc = NULL;
|
|
- gf_boolean_t free_gfid = _gf_true;
|
|
-
|
|
- local = frame->local;
|
|
- priv = this->private;
|
|
-
|
|
- local->post_res_handler = handler;
|
|
- gfid = GF_MALLOC(sizeof(uuid_t), gf_common_mt_uuid_t);
|
|
- if (!gfid)
|
|
- goto err;
|
|
-
|
|
- switch (type) {
|
|
- case SHARD_INTERNAL_DIR_DOT_SHARD:
|
|
- gf_uuid_copy(*gfid, priv->dot_shard_gfid);
|
|
- loc = &local->dot_shard_loc;
|
|
- break;
|
|
- case SHARD_INTERNAL_DIR_DOT_SHARD_REMOVE_ME:
|
|
- gf_uuid_copy(*gfid, priv->dot_shard_rm_gfid);
|
|
- loc = &local->dot_shard_rm_loc;
|
|
- break;
|
|
- default:
|
|
- bzero(*gfid, sizeof(uuid_t));
|
|
- break;
|
|
- }
|
|
+ if (local->op_ret < 0) {
|
|
+ shard_common_failure_unwind(local->fop, frame, local->op_ret,
|
|
+ local->op_errno);
|
|
+ return 0;
|
|
+ }
|
|
|
|
- xattr_req = dict_new();
|
|
- if (!xattr_req)
|
|
- goto err;
|
|
+ if (!local->eexist_count) {
|
|
+ shard_common_inode_write_do(frame, this);
|
|
+ } else {
|
|
+ local->call_count = local->eexist_count;
|
|
+ shard_common_lookup_shards(
|
|
+ frame, this, local->loc.inode,
|
|
+ shard_common_inode_write_post_lookup_shards_handler);
|
|
+ }
|
|
|
|
- ret = shard_init_internal_dir_loc(this, local, type);
|
|
- if (ret)
|
|
- goto err;
|
|
+ return 0;
|
|
+}
|
|
|
|
- ret = dict_set_gfuuid(xattr_req, "gfid-req", *gfid, false);
|
|
- if (ret) {
|
|
- gf_msg(this->name, GF_LOG_ERROR, 0, SHARD_MSG_DICT_OP_FAILED,
|
|
- "Failed to set gfid-req for %s",
|
|
- shard_internal_dir_string(type));
|
|
- goto err;
|
|
- } else {
|
|
- free_gfid = _gf_false;
|
|
- }
|
|
+int shard_common_inode_write_post_resolve_handler(call_frame_t *frame,
|
|
+ xlator_t *this) {
|
|
+ shard_local_t *local = NULL;
|
|
|
|
- SHARD_SET_ROOT_FS_ID(frame, local);
|
|
+ local = frame->local;
|
|
|
|
- STACK_WIND_COOKIE(frame, shard_mkdir_internal_dir_cbk, (void *)(long)type,
|
|
- FIRST_CHILD(this), FIRST_CHILD(this)->fops->mkdir, loc,
|
|
- 0755, 0, xattr_req);
|
|
- dict_unref(xattr_req);
|
|
+ if (local->op_ret < 0) {
|
|
+ shard_common_failure_unwind(local->fop, frame, local->op_ret,
|
|
+ local->op_errno);
|
|
return 0;
|
|
+ }
|
|
|
|
-err:
|
|
- if (xattr_req)
|
|
- dict_unref(xattr_req);
|
|
- local->op_ret = -1;
|
|
- local->op_errno = ENOMEM;
|
|
- if (free_gfid)
|
|
- GF_FREE(gfid);
|
|
- handler(frame, this);
|
|
- return 0;
|
|
-}
|
|
+ if (local->call_count) {
|
|
+ shard_common_lookup_shards(
|
|
+ frame, this, local->resolver_base_inode,
|
|
+ shard_common_inode_write_post_lookup_shards_handler);
|
|
+ } else {
|
|
+ shard_common_inode_write_do(frame, this);
|
|
+ }
|
|
|
|
-int
|
|
-shard_flush_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
|
|
- int32_t op_ret, int32_t op_errno, dict_t *xdata)
|
|
-{
|
|
- /* To-Do: Wind flush on all shards of the file */
|
|
- SHARD_STACK_UNWIND(flush, frame, op_ret, op_errno, xdata);
|
|
- return 0;
|
|
+ return 0;
|
|
}
|
|
|
|
-int
|
|
-shard_flush(call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata)
|
|
-{
|
|
- STACK_WIND(frame, shard_flush_cbk, FIRST_CHILD(this),
|
|
- FIRST_CHILD(this)->fops->flush, fd, xdata);
|
|
+int shard_common_inode_write_post_lookup_handler(call_frame_t *frame,
|
|
+ xlator_t *this) {
|
|
+ shard_local_t *local = frame->local;
|
|
+ shard_priv_t *priv = this->private;
|
|
+
|
|
+ if (local->op_ret < 0) {
|
|
+ shard_common_failure_unwind(local->fop, frame, local->op_ret,
|
|
+ local->op_errno);
|
|
return 0;
|
|
-}
|
|
+ }
|
|
|
|
-int
|
|
-__shard_get_timestamps_from_inode_ctx(shard_local_t *local, inode_t *inode,
|
|
- xlator_t *this)
|
|
-{
|
|
- int ret = -1;
|
|
- uint64_t ctx_uint = 0;
|
|
- shard_inode_ctx_t *ctx = NULL;
|
|
+ local->postbuf = local->prebuf;
|
|
|
|
- ret = __inode_ctx_get(inode, this, &ctx_uint);
|
|
- if (ret < 0)
|
|
- return ret;
|
|
+ /*Adjust offset to EOF so that correct shard is chosen for append*/
|
|
+ if (shard_is_appending_write(local))
|
|
+ local->offset = local->prebuf.ia_size;
|
|
|
|
- ctx = (shard_inode_ctx_t *)(uintptr_t)ctx_uint;
|
|
+ local->first_block = get_lowest_block(local->offset, local->block_size);
|
|
+ local->last_block =
|
|
+ get_highest_block(local->offset, local->total_size, local->block_size);
|
|
+ local->num_blocks = local->last_block - local->first_block + 1;
|
|
+ local->inode_list =
|
|
+ GF_CALLOC(local->num_blocks, sizeof(inode_t *), gf_shard_mt_inode_list);
|
|
+ if (!local->inode_list) {
|
|
+ shard_common_failure_unwind(local->fop, frame, -1, ENOMEM);
|
|
+ return 0;
|
|
+ }
|
|
|
|
- local->postbuf.ia_ctime = ctx->stat.ia_ctime;
|
|
- local->postbuf.ia_ctime_nsec = ctx->stat.ia_ctime_nsec;
|
|
- local->postbuf.ia_atime = ctx->stat.ia_atime;
|
|
- local->postbuf.ia_atime_nsec = ctx->stat.ia_atime_nsec;
|
|
- local->postbuf.ia_mtime = ctx->stat.ia_mtime;
|
|
- local->postbuf.ia_mtime_nsec = ctx->stat.ia_mtime_nsec;
|
|
+ gf_msg_trace(
|
|
+ this->name, 0, "%s: gfid=%s first_block=%" PRIu32 " "
|
|
+ "last_block=%" PRIu32 " num_blocks=%" PRIu32
|
|
+ " offset=%" PRId64 " total_size=%zu flags=%" PRId32 "",
|
|
+ gf_fop_list[local->fop], uuid_utoa(local->resolver_base_inode->gfid),
|
|
+ local->first_block, local->last_block, local->num_blocks, local->offset,
|
|
+ local->total_size, local->flags);
|
|
|
|
- return 0;
|
|
-}
|
|
+ local->dot_shard_loc.inode = inode_find(this->itable, priv->dot_shard_gfid);
|
|
|
|
-int
|
|
-shard_get_timestamps_from_inode_ctx(shard_local_t *local, inode_t *inode,
|
|
- xlator_t *this)
|
|
-{
|
|
- int ret = 0;
|
|
+ if (!local->dot_shard_loc.inode) {
|
|
+ /*change handler*/
|
|
+ shard_mkdir_internal_dir(frame, this,
|
|
+ shard_common_inode_write_post_resolve_handler,
|
|
+ SHARD_INTERNAL_DIR_DOT_SHARD);
|
|
+ } else {
|
|
+ /*change handler*/
|
|
+ local->post_res_handler = shard_common_inode_write_post_resolve_handler;
|
|
+ shard_refresh_internal_dir(frame, this, SHARD_INTERNAL_DIR_DOT_SHARD);
|
|
+ }
|
|
+ return 0;
|
|
+}
|
|
|
|
- LOCK(&inode->lock);
|
|
- {
|
|
- ret = __shard_get_timestamps_from_inode_ctx(local, inode, this);
|
|
- }
|
|
- UNLOCK(&inode->lock);
|
|
+int shard_mkdir_internal_dir_cbk(call_frame_t *frame, void *cookie,
|
|
+ xlator_t *this, int32_t op_ret,
|
|
+ int32_t op_errno, inode_t *inode,
|
|
+ struct iatt *buf, struct iatt *preparent,
|
|
+ struct iatt *postparent, dict_t *xdata) {
|
|
+ inode_t *link_inode = NULL;
|
|
+ shard_local_t *local = NULL;
|
|
+ shard_internal_dir_type_t type = (shard_internal_dir_type_t)cookie;
|
|
+
|
|
+ local = frame->local;
|
|
+
|
|
+ SHARD_UNSET_ROOT_FS_ID(frame, local);
|
|
+
|
|
+ if (op_ret == -1) {
|
|
+ if (op_errno != EEXIST) {
|
|
+ local->op_ret = op_ret;
|
|
+ local->op_errno = op_errno;
|
|
+ goto unwind;
|
|
+ } else {
|
|
+ gf_msg_debug(this->name, 0, "mkdir on %s failed "
|
|
+ "with EEXIST. Attempting lookup now",
|
|
+ shard_internal_dir_string(type));
|
|
+ shard_lookup_internal_dir(frame, this, local->post_res_handler, type);
|
|
+ return 0;
|
|
+ }
|
|
+ }
|
|
+
|
|
+ link_inode = shard_link_internal_dir_inode(local, inode, buf, type);
|
|
+ if (link_inode != inode) {
|
|
+ shard_refresh_internal_dir(frame, this, type);
|
|
+ } else {
|
|
+ shard_inode_ctx_mark_dir_refreshed(link_inode, this);
|
|
+ shard_common_resolve_shards(frame, this, local->post_res_handler);
|
|
+ }
|
|
+ return 0;
|
|
+unwind:
|
|
+ shard_common_resolve_shards(frame, this, local->post_res_handler);
|
|
+ return 0;
|
|
+}
|
|
+
|
|
+int shard_mkdir_internal_dir(call_frame_t *frame, xlator_t *this,
|
|
+ shard_post_resolve_fop_handler_t handler,
|
|
+ shard_internal_dir_type_t type) {
|
|
+ int ret = -1;
|
|
+ shard_local_t *local = NULL;
|
|
+ shard_priv_t *priv = NULL;
|
|
+ dict_t *xattr_req = NULL;
|
|
+ uuid_t *gfid = NULL;
|
|
+ loc_t *loc = NULL;
|
|
+ gf_boolean_t free_gfid = _gf_true;
|
|
+
|
|
+ local = frame->local;
|
|
+ priv = this->private;
|
|
+
|
|
+ local->post_res_handler = handler;
|
|
+ gfid = GF_MALLOC(sizeof(uuid_t), gf_common_mt_uuid_t);
|
|
+ if (!gfid)
|
|
+ goto err;
|
|
+
|
|
+ switch (type) {
|
|
+ case SHARD_INTERNAL_DIR_DOT_SHARD:
|
|
+ gf_uuid_copy(*gfid, priv->dot_shard_gfid);
|
|
+ loc = &local->dot_shard_loc;
|
|
+ break;
|
|
+ case SHARD_INTERNAL_DIR_DOT_SHARD_REMOVE_ME:
|
|
+ gf_uuid_copy(*gfid, priv->dot_shard_rm_gfid);
|
|
+ loc = &local->dot_shard_rm_loc;
|
|
+ break;
|
|
+ default:
|
|
+ bzero(*gfid, sizeof(uuid_t));
|
|
+ break;
|
|
+ }
|
|
+
|
|
+ xattr_req = dict_new();
|
|
+ if (!xattr_req)
|
|
+ goto err;
|
|
+
|
|
+ ret = shard_init_internal_dir_loc(this, local, type);
|
|
+ if (ret)
|
|
+ goto err;
|
|
+
|
|
+ ret = dict_set_gfuuid(xattr_req, "gfid-req", *gfid, false);
|
|
+ if (ret) {
|
|
+ gf_msg(this->name, GF_LOG_ERROR, 0, SHARD_MSG_DICT_OP_FAILED,
|
|
+ "Failed to set gfid-req for %s", shard_internal_dir_string(type));
|
|
+ goto err;
|
|
+ } else {
|
|
+ free_gfid = _gf_false;
|
|
+ }
|
|
+
|
|
+ SHARD_SET_ROOT_FS_ID(frame, local);
|
|
+
|
|
+ STACK_WIND_COOKIE(frame, shard_mkdir_internal_dir_cbk, (void *)(long)type,
|
|
+ FIRST_CHILD(this), FIRST_CHILD(this)->fops->mkdir, loc,
|
|
+ 0755, 0, xattr_req);
|
|
+ dict_unref(xattr_req);
|
|
+ return 0;
|
|
|
|
- return ret;
|
|
+err:
|
|
+ if (xattr_req)
|
|
+ dict_unref(xattr_req);
|
|
+ local->op_ret = -1;
|
|
+ local->op_errno = ENOMEM;
|
|
+ if (free_gfid)
|
|
+ GF_FREE(gfid);
|
|
+ handler(frame, this);
|
|
+ return 0;
|
|
}
|
|
|
|
-int
|
|
-shard_fsync_shards_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
|
|
- int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
|
|
- struct iatt *postbuf, dict_t *xdata)
|
|
-{
|
|
- int call_count = 0;
|
|
- uint64_t fsync_count = 0;
|
|
- fd_t *anon_fd = cookie;
|
|
- shard_local_t *local = NULL;
|
|
- shard_inode_ctx_t *ctx = NULL;
|
|
- shard_inode_ctx_t *base_ictx = NULL;
|
|
- inode_t *base_inode = NULL;
|
|
- gf_boolean_t unref_shard_inode = _gf_false;
|
|
+int shard_flush_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
|
|
+ int32_t op_ret, int32_t op_errno, dict_t *xdata) {
|
|
+ /* To-Do: Wind flush on all shards of the file */
|
|
+ SHARD_STACK_UNWIND(flush, frame, op_ret, op_errno, xdata);
|
|
+ return 0;
|
|
+}
|
|
|
|
- local = frame->local;
|
|
- base_inode = local->fd->inode;
|
|
+int shard_flush(call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata) {
|
|
+ STACK_WIND(frame, shard_flush_cbk, FIRST_CHILD(this),
|
|
+ FIRST_CHILD(this)->fops->flush, fd, xdata);
|
|
+ return 0;
|
|
+}
|
|
|
|
- if (local->op_ret < 0)
|
|
- goto out;
|
|
+int __shard_get_timestamps_from_inode_ctx(shard_local_t *local, inode_t *inode,
|
|
+ xlator_t *this) {
|
|
+ int ret = -1;
|
|
+ uint64_t ctx_uint = 0;
|
|
+ shard_inode_ctx_t *ctx = NULL;
|
|
|
|
- LOCK(&frame->lock);
|
|
- {
|
|
- if (op_ret < 0) {
|
|
- local->op_ret = op_ret;
|
|
- local->op_errno = op_errno;
|
|
- UNLOCK(&frame->lock);
|
|
- goto out;
|
|
- }
|
|
- shard_inode_ctx_set(local->fd->inode, this, postbuf, 0,
|
|
- SHARD_MASK_TIMES);
|
|
- }
|
|
- UNLOCK(&frame->lock);
|
|
- fd_ctx_get(anon_fd, this, &fsync_count);
|
|
-out:
|
|
- if (anon_fd && (base_inode != anon_fd->inode)) {
|
|
- LOCK(&base_inode->lock);
|
|
- LOCK(&anon_fd->inode->lock);
|
|
- {
|
|
- __shard_inode_ctx_get(anon_fd->inode, this, &ctx);
|
|
- __shard_inode_ctx_get(base_inode, this, &base_ictx);
|
|
- if (op_ret == 0)
|
|
- ctx->fsync_needed -= fsync_count;
|
|
- GF_ASSERT(ctx->fsync_needed >= 0);
|
|
- if (ctx->fsync_needed != 0) {
|
|
- list_add_tail(&ctx->to_fsync_list, &base_ictx->to_fsync_list);
|
|
- base_ictx->fsync_count++;
|
|
- } else {
|
|
- unref_shard_inode = _gf_true;
|
|
- }
|
|
- }
|
|
- UNLOCK(&anon_fd->inode->lock);
|
|
- UNLOCK(&base_inode->lock);
|
|
- }
|
|
+ ret = __inode_ctx_get(inode, this, &ctx_uint);
|
|
+ if (ret < 0)
|
|
+ return ret;
|
|
|
|
- if (unref_shard_inode)
|
|
- inode_unref(anon_fd->inode);
|
|
- if (anon_fd)
|
|
- fd_unref(anon_fd);
|
|
+ ctx = (shard_inode_ctx_t *)(uintptr_t)ctx_uint;
|
|
|
|
- call_count = shard_call_count_return(frame);
|
|
- if (call_count != 0)
|
|
- return 0;
|
|
+ local->postbuf.ia_ctime = ctx->stat.ia_ctime;
|
|
+ local->postbuf.ia_ctime_nsec = ctx->stat.ia_ctime_nsec;
|
|
+ local->postbuf.ia_atime = ctx->stat.ia_atime;
|
|
+ local->postbuf.ia_atime_nsec = ctx->stat.ia_atime_nsec;
|
|
+ local->postbuf.ia_mtime = ctx->stat.ia_mtime;
|
|
+ local->postbuf.ia_mtime_nsec = ctx->stat.ia_mtime_nsec;
|
|
|
|
- if (local->op_ret < 0) {
|
|
- shard_common_failure_unwind(GF_FOP_FSYNC, frame, local->op_ret,
|
|
- local->op_errno);
|
|
- } else {
|
|
- shard_get_timestamps_from_inode_ctx(local, base_inode, this);
|
|
- SHARD_STACK_UNWIND(fsync, frame, local->op_ret, local->op_errno,
|
|
- &local->prebuf, &local->postbuf, local->xattr_rsp);
|
|
- }
|
|
- return 0;
|
|
+ return 0;
|
|
}
|
|
|
|
-int
|
|
-shard_post_lookup_fsync_handler(call_frame_t *frame, xlator_t *this)
|
|
-{
|
|
- int ret = 0;
|
|
- int call_count = 0;
|
|
- int fsync_count = 0;
|
|
- fd_t *anon_fd = NULL;
|
|
- inode_t *base_inode = NULL;
|
|
- shard_local_t *local = NULL;
|
|
- shard_inode_ctx_t *ctx = NULL;
|
|
- shard_inode_ctx_t *iter = NULL;
|
|
- struct list_head copy = {
|
|
- 0,
|
|
- };
|
|
- shard_inode_ctx_t *tmp = NULL;
|
|
+int shard_get_timestamps_from_inode_ctx(shard_local_t *local, inode_t *inode,
|
|
+ xlator_t *this) {
|
|
+ int ret = 0;
|
|
|
|
- local = frame->local;
|
|
- base_inode = local->fd->inode;
|
|
- local->postbuf = local->prebuf;
|
|
- INIT_LIST_HEAD(©);
|
|
+ LOCK(&inode->lock);
|
|
+ { ret = __shard_get_timestamps_from_inode_ctx(local, inode, this); }
|
|
+ UNLOCK(&inode->lock);
|
|
|
|
- if (local->op_ret < 0) {
|
|
- shard_common_failure_unwind(GF_FOP_FSYNC, frame, local->op_ret,
|
|
- local->op_errno);
|
|
- return 0;
|
|
- }
|
|
+ return ret;
|
|
+}
|
|
|
|
+int shard_fsync_shards_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
|
|
+ int32_t op_ret, int32_t op_errno,
|
|
+ struct iatt *prebuf, struct iatt *postbuf,
|
|
+ dict_t *xdata) {
|
|
+ int call_count = 0;
|
|
+ uint64_t fsync_count = 0;
|
|
+ fd_t *anon_fd = cookie;
|
|
+ shard_local_t *local = NULL;
|
|
+ shard_inode_ctx_t *ctx = NULL;
|
|
+ shard_inode_ctx_t *base_ictx = NULL;
|
|
+ inode_t *base_inode = NULL;
|
|
+ gf_boolean_t unref_shard_inode = _gf_false;
|
|
+
|
|
+ local = frame->local;
|
|
+ base_inode = local->fd->inode;
|
|
+
|
|
+ if (local->op_ret < 0)
|
|
+ goto out;
|
|
+
|
|
+ LOCK(&frame->lock);
|
|
+ {
|
|
+ if (op_ret < 0) {
|
|
+ local->op_ret = op_ret;
|
|
+ local->op_errno = op_errno;
|
|
+ UNLOCK(&frame->lock);
|
|
+ goto out;
|
|
+ }
|
|
+ shard_inode_ctx_set(local->fd->inode, this, postbuf, 0, SHARD_MASK_TIMES);
|
|
+ }
|
|
+ UNLOCK(&frame->lock);
|
|
+ fd_ctx_get(anon_fd, this, &fsync_count);
|
|
+out:
|
|
+ if (anon_fd && (base_inode != anon_fd->inode)) {
|
|
LOCK(&base_inode->lock);
|
|
+ LOCK(&anon_fd->inode->lock);
|
|
{
|
|
- __shard_inode_ctx_get(base_inode, this, &ctx);
|
|
- list_splice_init(&ctx->to_fsync_list, ©);
|
|
- call_count = ctx->fsync_count;
|
|
- ctx->fsync_count = 0;
|
|
- }
|
|
+ __shard_inode_ctx_get(anon_fd->inode, this, &ctx);
|
|
+ __shard_inode_ctx_get(base_inode, this, &base_ictx);
|
|
+ if (op_ret == 0)
|
|
+ ctx->fsync_needed -= fsync_count;
|
|
+ GF_ASSERT(ctx->fsync_needed >= 0);
|
|
+ if (ctx->fsync_needed != 0) {
|
|
+ list_add_tail(&ctx->to_fsync_list, &base_ictx->to_fsync_list);
|
|
+ base_ictx->fsync_count++;
|
|
+ } else {
|
|
+ unref_shard_inode = _gf_true;
|
|
+ }
|
|
+ }
|
|
+ UNLOCK(&anon_fd->inode->lock);
|
|
UNLOCK(&base_inode->lock);
|
|
+ }
|
|
+
|
|
+ if (unref_shard_inode)
|
|
+ inode_unref(anon_fd->inode);
|
|
+ if (anon_fd)
|
|
+ fd_unref(anon_fd);
|
|
+
|
|
+ call_count = shard_call_count_return(frame);
|
|
+ if (call_count != 0)
|
|
+ return 0;
|
|
|
|
- local->call_count = ++call_count;
|
|
+ if (local->op_ret < 0) {
|
|
+ shard_common_failure_unwind(GF_FOP_FSYNC, frame, local->op_ret,
|
|
+ local->op_errno);
|
|
+ } else {
|
|
+ shard_get_timestamps_from_inode_ctx(local, base_inode, this);
|
|
+ SHARD_STACK_UNWIND(fsync, frame, local->op_ret, local->op_errno,
|
|
+ &local->prebuf, &local->postbuf, local->xattr_rsp);
|
|
+ }
|
|
+ return 0;
|
|
+}
|
|
+
|
|
+int shard_post_lookup_fsync_handler(call_frame_t *frame, xlator_t *this) {
|
|
+ int ret = 0;
|
|
+ int call_count = 0;
|
|
+ int fsync_count = 0;
|
|
+ fd_t *anon_fd = NULL;
|
|
+ inode_t *base_inode = NULL;
|
|
+ shard_local_t *local = NULL;
|
|
+ shard_inode_ctx_t *ctx = NULL;
|
|
+ shard_inode_ctx_t *iter = NULL;
|
|
+ struct list_head copy = {
|
|
+ 0,
|
|
+ };
|
|
+ shard_inode_ctx_t *tmp = NULL;
|
|
+
|
|
+ local = frame->local;
|
|
+ base_inode = local->fd->inode;
|
|
+ local->postbuf = local->prebuf;
|
|
+ INIT_LIST_HEAD(©);
|
|
+
|
|
+ if (local->op_ret < 0) {
|
|
+ shard_common_failure_unwind(GF_FOP_FSYNC, frame, local->op_ret,
|
|
+ local->op_errno);
|
|
+ return 0;
|
|
+ }
|
|
+
|
|
+ LOCK(&base_inode->lock);
|
|
+ {
|
|
+ __shard_inode_ctx_get(base_inode, this, &ctx);
|
|
+ list_splice_init(&ctx->to_fsync_list, ©);
|
|
+ call_count = ctx->fsync_count;
|
|
+ ctx->fsync_count = 0;
|
|
+ }
|
|
+ UNLOCK(&base_inode->lock);
|
|
+
|
|
+ local->call_count = ++call_count;
|
|
+
|
|
+ /* Send fsync() on the base shard first */
|
|
+ anon_fd = fd_ref(local->fd);
|
|
+ STACK_WIND_COOKIE(frame, shard_fsync_shards_cbk, anon_fd, FIRST_CHILD(this),
|
|
+ FIRST_CHILD(this)->fops->fsync, anon_fd, local->datasync,
|
|
+ local->xattr_req);
|
|
+ call_count--;
|
|
+ anon_fd = NULL;
|
|
+
|
|
+ list_for_each_entry_safe(iter, tmp, ©, to_fsync_list) {
|
|
+ list_del_init(&iter->to_fsync_list);
|
|
+ fsync_count = 0;
|
|
+ shard_inode_ctx_get_fsync_count(iter->inode, this, &fsync_count);
|
|
+ GF_ASSERT(fsync_count > 0);
|
|
+ anon_fd = fd_anonymous(iter->inode);
|
|
+ if (!anon_fd) {
|
|
+ local->op_ret = -1;
|
|
+ local->op_errno = ENOMEM;
|
|
+ gf_msg(this->name, GF_LOG_WARNING, ENOMEM, SHARD_MSG_MEMALLOC_FAILED,
|
|
+ "Failed to create "
|
|
+ "anon fd to fsync shard");
|
|
+ shard_fsync_shards_cbk(frame, (void *)(long)anon_fd, this, -1, ENOMEM,
|
|
+ NULL, NULL, NULL);
|
|
+ continue;
|
|
+ }
|
|
|
|
- /* Send fsync() on the base shard first */
|
|
- anon_fd = fd_ref(local->fd);
|
|
+ ret = fd_ctx_set(anon_fd, this, fsync_count);
|
|
+ if (ret) {
|
|
+ gf_msg(this->name, GF_LOG_ERROR, 0, SHARD_MSG_FD_CTX_SET_FAILED,
|
|
+ "Failed to set fd "
|
|
+ "ctx for shard inode gfid=%s",
|
|
+ uuid_utoa(iter->inode->gfid));
|
|
+ local->op_ret = -1;
|
|
+ local->op_errno = ENOMEM;
|
|
+ shard_fsync_shards_cbk(frame, (void *)(long)anon_fd, this, -1, ENOMEM,
|
|
+ NULL, NULL, NULL);
|
|
+ continue;
|
|
+ }
|
|
STACK_WIND_COOKIE(frame, shard_fsync_shards_cbk, anon_fd, FIRST_CHILD(this),
|
|
FIRST_CHILD(this)->fops->fsync, anon_fd, local->datasync,
|
|
local->xattr_req);
|
|
call_count--;
|
|
- anon_fd = NULL;
|
|
-
|
|
- list_for_each_entry_safe(iter, tmp, ©, to_fsync_list)
|
|
- {
|
|
- list_del_init(&iter->to_fsync_list);
|
|
- fsync_count = 0;
|
|
- shard_inode_ctx_get_fsync_count(iter->inode, this, &fsync_count);
|
|
- GF_ASSERT(fsync_count > 0);
|
|
- anon_fd = fd_anonymous(iter->inode);
|
|
- if (!anon_fd) {
|
|
- local->op_ret = -1;
|
|
- local->op_errno = ENOMEM;
|
|
- gf_msg(this->name, GF_LOG_WARNING, ENOMEM,
|
|
- SHARD_MSG_MEMALLOC_FAILED,
|
|
- "Failed to create "
|
|
- "anon fd to fsync shard");
|
|
- shard_fsync_shards_cbk(frame, (void *)(long)anon_fd, this, -1,
|
|
- ENOMEM, NULL, NULL, NULL);
|
|
- continue;
|
|
- }
|
|
-
|
|
- ret = fd_ctx_set(anon_fd, this, fsync_count);
|
|
- if (ret) {
|
|
- gf_msg(this->name, GF_LOG_ERROR, 0, SHARD_MSG_FD_CTX_SET_FAILED,
|
|
- "Failed to set fd "
|
|
- "ctx for shard inode gfid=%s",
|
|
- uuid_utoa(iter->inode->gfid));
|
|
- local->op_ret = -1;
|
|
- local->op_errno = ENOMEM;
|
|
- shard_fsync_shards_cbk(frame, (void *)(long)anon_fd, this, -1,
|
|
- ENOMEM, NULL, NULL, NULL);
|
|
- continue;
|
|
- }
|
|
- STACK_WIND_COOKIE(frame, shard_fsync_shards_cbk, anon_fd,
|
|
- FIRST_CHILD(this), FIRST_CHILD(this)->fops->fsync,
|
|
- anon_fd, local->datasync, local->xattr_req);
|
|
- call_count--;
|
|
- }
|
|
+ }
|
|
|
|
- return 0;
|
|
+ return 0;
|
|
}
|
|
|
|
-int
|
|
-shard_fsync(call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t datasync,
|
|
- dict_t *xdata)
|
|
-{
|
|
- int ret = 0;
|
|
- uint64_t block_size = 0;
|
|
- shard_local_t *local = NULL;
|
|
+int shard_fsync(call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t datasync,
|
|
+ dict_t *xdata) {
|
|
+ int ret = 0;
|
|
+ uint64_t block_size = 0;
|
|
+ shard_local_t *local = NULL;
|
|
|
|
- ret = shard_inode_ctx_get_block_size(fd->inode, this, &block_size);
|
|
- if (ret) {
|
|
- gf_msg(this->name, GF_LOG_ERROR, 0, SHARD_MSG_INODE_CTX_GET_FAILED,
|
|
- "Failed to get block "
|
|
- "size for %s from its inode ctx",
|
|
- uuid_utoa(fd->inode->gfid));
|
|
- goto err;
|
|
- }
|
|
+ ret = shard_inode_ctx_get_block_size(fd->inode, this, &block_size);
|
|
+ if (ret) {
|
|
+ gf_msg(this->name, GF_LOG_ERROR, 0, SHARD_MSG_INODE_CTX_GET_FAILED,
|
|
+ "Failed to get block "
|
|
+ "size for %s from its inode ctx",
|
|
+ uuid_utoa(fd->inode->gfid));
|
|
+ goto err;
|
|
+ }
|
|
|
|
- if (!block_size || frame->root->pid == GF_CLIENT_PID_GSYNCD) {
|
|
- STACK_WIND(frame, default_fsync_cbk, FIRST_CHILD(this),
|
|
- FIRST_CHILD(this)->fops->fsync, fd, datasync, xdata);
|
|
- return 0;
|
|
- }
|
|
+ if (!block_size || frame->root->pid == GF_CLIENT_PID_GSYNCD) {
|
|
+ STACK_WIND(frame, default_fsync_cbk, FIRST_CHILD(this),
|
|
+ FIRST_CHILD(this)->fops->fsync, fd, datasync, xdata);
|
|
+ return 0;
|
|
+ }
|
|
|
|
- if (!this->itable)
|
|
- this->itable = fd->inode->table;
|
|
+ if (!this->itable)
|
|
+ this->itable = fd->inode->table;
|
|
|
|
- local = mem_get0(this->local_pool);
|
|
- if (!local)
|
|
- goto err;
|
|
+ local = mem_get0(this->local_pool);
|
|
+ if (!local)
|
|
+ goto err;
|
|
|
|
- frame->local = local;
|
|
+ frame->local = local;
|
|
|
|
- local->fd = fd_ref(fd);
|
|
- local->fop = GF_FOP_FSYNC;
|
|
- local->datasync = datasync;
|
|
- local->xattr_req = (xdata) ? dict_ref(xdata) : dict_new();
|
|
- if (!local->xattr_req)
|
|
- goto err;
|
|
+ local->fd = fd_ref(fd);
|
|
+ local->fop = GF_FOP_FSYNC;
|
|
+ local->datasync = datasync;
|
|
+ local->xattr_req = (xdata) ? dict_ref(xdata) : dict_new();
|
|
+ if (!local->xattr_req)
|
|
+ goto err;
|
|
|
|
- local->loc.inode = inode_ref(fd->inode);
|
|
- gf_uuid_copy(local->loc.gfid, fd->inode->gfid);
|
|
+ local->loc.inode = inode_ref(fd->inode);
|
|
+ gf_uuid_copy(local->loc.gfid, fd->inode->gfid);
|
|
|
|
- shard_lookup_base_file(frame, this, &local->loc,
|
|
- shard_post_lookup_fsync_handler);
|
|
- return 0;
|
|
+ shard_lookup_base_file(frame, this, &local->loc,
|
|
+ shard_post_lookup_fsync_handler);
|
|
+ return 0;
|
|
err:
|
|
- shard_common_failure_unwind(GF_FOP_FSYNC, frame, -1, ENOMEM);
|
|
- return 0;
|
|
+ shard_common_failure_unwind(GF_FOP_FSYNC, frame, -1, ENOMEM);
|
|
+ return 0;
|
|
}
|
|
|
|
-int
|
|
-shard_readdir_past_dot_shard_cbk(call_frame_t *frame, void *cookie,
|
|
- xlator_t *this, int32_t op_ret,
|
|
- int32_t op_errno, gf_dirent_t *orig_entries,
|
|
- dict_t *xdata)
|
|
-{
|
|
- gf_dirent_t *entry = NULL;
|
|
- gf_dirent_t *tmp = NULL;
|
|
- shard_local_t *local = NULL;
|
|
+int shard_readdir_past_dot_shard_cbk(call_frame_t *frame, void *cookie,
|
|
+ xlator_t *this, int32_t op_ret,
|
|
+ int32_t op_errno,
|
|
+ gf_dirent_t *orig_entries, dict_t *xdata) {
|
|
+ gf_dirent_t *entry = NULL;
|
|
+ gf_dirent_t *tmp = NULL;
|
|
+ shard_local_t *local = NULL;
|
|
|
|
- local = frame->local;
|
|
+ local = frame->local;
|
|
|
|
- if (op_ret < 0)
|
|
- goto unwind;
|
|
+ if (op_ret < 0)
|
|
+ goto unwind;
|
|
|
|
- list_for_each_entry_safe(entry, tmp, (&orig_entries->list), list)
|
|
- {
|
|
- list_del_init(&entry->list);
|
|
- list_add_tail(&entry->list, &local->entries_head.list);
|
|
+ list_for_each_entry_safe(entry, tmp, (&orig_entries->list), list) {
|
|
+ list_del_init(&entry->list);
|
|
+ list_add_tail(&entry->list, &local->entries_head.list);
|
|
|
|
- if (!entry->dict)
|
|
- continue;
|
|
+ if (!entry->dict)
|
|
+ continue;
|
|
|
|
- if (IA_ISDIR(entry->d_stat.ia_type))
|
|
- continue;
|
|
+ if (IA_ISDIR(entry->d_stat.ia_type))
|
|
+ continue;
|
|
|
|
- if (dict_get(entry->dict, GF_XATTR_SHARD_FILE_SIZE))
|
|
- shard_modify_size_and_block_count(&entry->d_stat, entry->dict);
|
|
- if (!entry->inode)
|
|
- continue;
|
|
+ if (dict_get(entry->dict, GF_XATTR_SHARD_FILE_SIZE))
|
|
+ shard_modify_size_and_block_count(&entry->d_stat, entry->dict);
|
|
+ if (!entry->inode)
|
|
+ continue;
|
|
|
|
- shard_inode_ctx_update(entry->inode, this, entry->dict, &entry->d_stat);
|
|
- }
|
|
- local->op_ret += op_ret;
|
|
+ shard_inode_ctx_update(entry->inode, this, entry->dict, &entry->d_stat);
|
|
+ }
|
|
+ local->op_ret += op_ret;
|
|
|
|
unwind:
|
|
- if (local->fop == GF_FOP_READDIR)
|
|
- SHARD_STACK_UNWIND(readdir, frame, local->op_ret, local->op_errno,
|
|
- &local->entries_head, xdata);
|
|
- else
|
|
- SHARD_STACK_UNWIND(readdirp, frame, op_ret, op_errno,
|
|
- &local->entries_head, xdata);
|
|
- return 0;
|
|
+ if (local->fop == GF_FOP_READDIR)
|
|
+ SHARD_STACK_UNWIND(readdir, frame, local->op_ret, local->op_errno,
|
|
+ &local->entries_head, xdata);
|
|
+ else
|
|
+ SHARD_STACK_UNWIND(readdirp, frame, op_ret, op_errno, &local->entries_head,
|
|
+ xdata);
|
|
+ return 0;
|
|
}
|
|
|
|
-int32_t
|
|
-shard_readdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
|
|
- int32_t op_ret, int32_t op_errno, gf_dirent_t *orig_entries,
|
|
- dict_t *xdata)
|
|
-{
|
|
- fd_t *fd = NULL;
|
|
- gf_dirent_t *entry = NULL;
|
|
- gf_dirent_t *tmp = NULL;
|
|
- shard_local_t *local = NULL;
|
|
- gf_boolean_t last_entry = _gf_false;
|
|
+int32_t shard_readdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
|
|
+ int32_t op_ret, int32_t op_errno,
|
|
+ gf_dirent_t *orig_entries, dict_t *xdata) {
|
|
+ fd_t *fd = NULL;
|
|
+ gf_dirent_t *entry = NULL;
|
|
+ gf_dirent_t *tmp = NULL;
|
|
+ shard_local_t *local = NULL;
|
|
+ gf_boolean_t last_entry = _gf_false;
|
|
|
|
- local = frame->local;
|
|
- fd = local->fd;
|
|
+ local = frame->local;
|
|
+ fd = local->fd;
|
|
|
|
- if (op_ret < 0)
|
|
- goto unwind;
|
|
+ if (op_ret < 0)
|
|
+ goto unwind;
|
|
|
|
- list_for_each_entry_safe(entry, tmp, (&orig_entries->list), list)
|
|
- {
|
|
- if (last_entry)
|
|
- last_entry = _gf_false;
|
|
-
|
|
- if (__is_root_gfid(fd->inode->gfid) &&
|
|
- !(strcmp(entry->d_name, GF_SHARD_DIR))) {
|
|
- local->offset = entry->d_off;
|
|
- op_ret--;
|
|
- last_entry = _gf_true;
|
|
- continue;
|
|
- }
|
|
+ list_for_each_entry_safe(entry, tmp, (&orig_entries->list), list) {
|
|
+ if (last_entry)
|
|
+ last_entry = _gf_false;
|
|
|
|
- list_del_init(&entry->list);
|
|
- list_add_tail(&entry->list, &local->entries_head.list);
|
|
+ if (__is_root_gfid(fd->inode->gfid) &&
|
|
+ !(strcmp(entry->d_name, GF_SHARD_DIR))) {
|
|
+ local->offset = entry->d_off;
|
|
+ op_ret--;
|
|
+ last_entry = _gf_true;
|
|
+ continue;
|
|
+ }
|
|
|
|
- if (!entry->dict)
|
|
- continue;
|
|
+ list_del_init(&entry->list);
|
|
+ list_add_tail(&entry->list, &local->entries_head.list);
|
|
|
|
- if (IA_ISDIR(entry->d_stat.ia_type))
|
|
- continue;
|
|
+ if (!entry->dict)
|
|
+ continue;
|
|
|
|
- if (dict_get(entry->dict, GF_XATTR_SHARD_FILE_SIZE) &&
|
|
- frame->root->pid != GF_CLIENT_PID_GSYNCD)
|
|
- shard_modify_size_and_block_count(&entry->d_stat, entry->dict);
|
|
+ if (IA_ISDIR(entry->d_stat.ia_type))
|
|
+ continue;
|
|
|
|
- if (!entry->inode)
|
|
- continue;
|
|
+ if (dict_get(entry->dict, GF_XATTR_SHARD_FILE_SIZE) &&
|
|
+ frame->root->pid != GF_CLIENT_PID_GSYNCD)
|
|
+ shard_modify_size_and_block_count(&entry->d_stat, entry->dict);
|
|
|
|
- shard_inode_ctx_update(entry->inode, this, entry->dict, &entry->d_stat);
|
|
- }
|
|
+ if (!entry->inode)
|
|
+ continue;
|
|
|
|
- local->op_ret = op_ret;
|
|
+ shard_inode_ctx_update(entry->inode, this, entry->dict, &entry->d_stat);
|
|
+ }
|
|
|
|
- if (last_entry) {
|
|
- if (local->fop == GF_FOP_READDIR)
|
|
- STACK_WIND(frame, shard_readdir_past_dot_shard_cbk,
|
|
- FIRST_CHILD(this), FIRST_CHILD(this)->fops->readdir,
|
|
- local->fd, local->readdir_size, local->offset,
|
|
- local->xattr_req);
|
|
- else
|
|
- STACK_WIND(frame, shard_readdir_past_dot_shard_cbk,
|
|
- FIRST_CHILD(this), FIRST_CHILD(this)->fops->readdirp,
|
|
- local->fd, local->readdir_size, local->offset,
|
|
- local->xattr_req);
|
|
- return 0;
|
|
- }
|
|
+ local->op_ret = op_ret;
|
|
|
|
-unwind:
|
|
+ if (last_entry) {
|
|
if (local->fop == GF_FOP_READDIR)
|
|
- SHARD_STACK_UNWIND(readdir, frame, op_ret, op_errno,
|
|
- &local->entries_head, xdata);
|
|
+ STACK_WIND(frame, shard_readdir_past_dot_shard_cbk, FIRST_CHILD(this),
|
|
+ FIRST_CHILD(this)->fops->readdir, local->fd,
|
|
+ local->readdir_size, local->offset, local->xattr_req);
|
|
else
|
|
- SHARD_STACK_UNWIND(readdirp, frame, op_ret, op_errno,
|
|
- &local->entries_head, xdata);
|
|
+ STACK_WIND(frame, shard_readdir_past_dot_shard_cbk, FIRST_CHILD(this),
|
|
+ FIRST_CHILD(this)->fops->readdirp, local->fd,
|
|
+ local->readdir_size, local->offset, local->xattr_req);
|
|
return 0;
|
|
-}
|
|
+ }
|
|
|
|
-int
|
|
-shard_readdir_do(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
|
|
- off_t offset, int whichop, dict_t *xdata)
|
|
-{
|
|
- int ret = 0;
|
|
- shard_local_t *local = NULL;
|
|
-
|
|
- local = mem_get0(this->local_pool);
|
|
- if (!local) {
|
|
- goto err;
|
|
+unwind:
|
|
+ if (local->fop == GF_FOP_READDIR)
|
|
+ SHARD_STACK_UNWIND(readdir, frame, op_ret, op_errno, &local->entries_head,
|
|
+ xdata);
|
|
+ else
|
|
+ SHARD_STACK_UNWIND(readdirp, frame, op_ret, op_errno, &local->entries_head,
|
|
+ xdata);
|
|
+ return 0;
|
|
+}
|
|
+
|
|
+int shard_readdir_do(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
|
|
+ off_t offset, int whichop, dict_t *xdata) {
|
|
+ int ret = 0;
|
|
+ shard_local_t *local = NULL;
|
|
+
|
|
+ local = mem_get0(this->local_pool);
|
|
+ if (!local) {
|
|
+ goto err;
|
|
+ }
|
|
+
|
|
+ frame->local = local;
|
|
+
|
|
+ local->fd = fd_ref(fd);
|
|
+ local->fop = whichop;
|
|
+ local->readdir_size = size;
|
|
+ INIT_LIST_HEAD(&local->entries_head.list);
|
|
+ local->list_inited = _gf_true;
|
|
+
|
|
+ if (whichop == GF_FOP_READDIR) {
|
|
+ STACK_WIND(frame, shard_readdir_cbk, FIRST_CHILD(this),
|
|
+ FIRST_CHILD(this)->fops->readdir, fd, size, offset, xdata);
|
|
+ } else {
|
|
+ local->xattr_req = (xdata) ? dict_ref(xdata) : dict_new();
|
|
+ SHARD_MD_READ_FOP_INIT_REQ_DICT(this, local->xattr_req, fd->inode->gfid,
|
|
+ local, err);
|
|
+ ret = dict_set_uint64(local->xattr_req, GF_XATTR_SHARD_BLOCK_SIZE, 0);
|
|
+ if (ret) {
|
|
+ gf_log(this->name, GF_LOG_WARNING,
|
|
+ "Failed to set "
|
|
+ "dict value: key:%s, directory gfid=%s",
|
|
+ GF_XATTR_SHARD_BLOCK_SIZE, uuid_utoa(fd->inode->gfid));
|
|
+ goto err;
|
|
}
|
|
|
|
- frame->local = local;
|
|
-
|
|
- local->fd = fd_ref(fd);
|
|
- local->fop = whichop;
|
|
- local->readdir_size = size;
|
|
- INIT_LIST_HEAD(&local->entries_head.list);
|
|
- local->list_inited = _gf_true;
|
|
-
|
|
- if (whichop == GF_FOP_READDIR) {
|
|
- STACK_WIND(frame, shard_readdir_cbk, FIRST_CHILD(this),
|
|
- FIRST_CHILD(this)->fops->readdir, fd, size, offset, xdata);
|
|
- } else {
|
|
- local->xattr_req = (xdata) ? dict_ref(xdata) : dict_new();
|
|
- SHARD_MD_READ_FOP_INIT_REQ_DICT(this, local->xattr_req, fd->inode->gfid,
|
|
- local, err);
|
|
- ret = dict_set_uint64(local->xattr_req, GF_XATTR_SHARD_BLOCK_SIZE, 0);
|
|
- if (ret) {
|
|
- gf_log(this->name, GF_LOG_WARNING,
|
|
- "Failed to set "
|
|
- "dict value: key:%s, directory gfid=%s",
|
|
- GF_XATTR_SHARD_BLOCK_SIZE, uuid_utoa(fd->inode->gfid));
|
|
- goto err;
|
|
- }
|
|
-
|
|
- STACK_WIND(frame, shard_readdir_cbk, FIRST_CHILD(this),
|
|
- FIRST_CHILD(this)->fops->readdirp, fd, size, offset,
|
|
- local->xattr_req);
|
|
- }
|
|
+ STACK_WIND(frame, shard_readdir_cbk, FIRST_CHILD(this),
|
|
+ FIRST_CHILD(this)->fops->readdirp, fd, size, offset,
|
|
+ local->xattr_req);
|
|
+ }
|
|
|
|
- return 0;
|
|
+ return 0;
|
|
|
|
err:
|
|
- STACK_UNWIND_STRICT(readdir, frame, -1, ENOMEM, NULL, NULL);
|
|
- return 0;
|
|
+ STACK_UNWIND_STRICT(readdir, frame, -1, ENOMEM, NULL, NULL);
|
|
+ return 0;
|
|
}
|
|
|
|
-int32_t
|
|
-shard_readdir(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
|
|
- off_t offset, dict_t *xdata)
|
|
-{
|
|
- shard_readdir_do(frame, this, fd, size, offset, GF_FOP_READDIR, xdata);
|
|
- return 0;
|
|
+int32_t shard_readdir(call_frame_t *frame, xlator_t *this, fd_t *fd,
|
|
+ size_t size, off_t offset, dict_t *xdata) {
|
|
+ shard_readdir_do(frame, this, fd, size, offset, GF_FOP_READDIR, xdata);
|
|
+ return 0;
|
|
}
|
|
|
|
-int32_t
|
|
-shard_readdirp(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
|
|
- off_t offset, dict_t *xdata)
|
|
-{
|
|
- shard_readdir_do(frame, this, fd, size, offset, GF_FOP_READDIRP, xdata);
|
|
- return 0;
|
|
+int32_t shard_readdirp(call_frame_t *frame, xlator_t *this, fd_t *fd,
|
|
+ size_t size, off_t offset, dict_t *xdata) {
|
|
+ shard_readdir_do(frame, this, fd, size, offset, GF_FOP_READDIRP, xdata);
|
|
+ return 0;
|
|
}
|
|
|
|
-int32_t
|
|
-shard_removexattr(call_frame_t *frame, xlator_t *this, loc_t *loc,
|
|
- const char *name, dict_t *xdata)
|
|
-{
|
|
- int op_errno = EINVAL;
|
|
+int32_t shard_removexattr(call_frame_t *frame, xlator_t *this, loc_t *loc,
|
|
+ const char *name, dict_t *xdata) {
|
|
+ int op_errno = EINVAL;
|
|
|
|
- if (frame->root->pid != GF_CLIENT_PID_GSYNCD) {
|
|
- GF_IF_NATIVE_XATTR_GOTO(SHARD_XATTR_PREFIX "*", name, op_errno, out);
|
|
- }
|
|
+ if (frame->root->pid != GF_CLIENT_PID_GSYNCD) {
|
|
+ GF_IF_NATIVE_XATTR_GOTO(SHARD_XATTR_PREFIX "*", name, op_errno, out);
|
|
+ }
|
|
|
|
- if (xdata && (frame->root->pid != GF_CLIENT_PID_GSYNCD)) {
|
|
- dict_del(xdata, GF_XATTR_SHARD_BLOCK_SIZE);
|
|
- dict_del(xdata, GF_XATTR_SHARD_FILE_SIZE);
|
|
- }
|
|
+ if (xdata && (frame->root->pid != GF_CLIENT_PID_GSYNCD)) {
|
|
+ dict_del(xdata, GF_XATTR_SHARD_BLOCK_SIZE);
|
|
+ dict_del(xdata, GF_XATTR_SHARD_FILE_SIZE);
|
|
+ }
|
|
|
|
- STACK_WIND_TAIL(frame, FIRST_CHILD(this),
|
|
- FIRST_CHILD(this)->fops->removexattr, loc, name, xdata);
|
|
- return 0;
|
|
+ STACK_WIND_TAIL(frame, FIRST_CHILD(this),
|
|
+ FIRST_CHILD(this)->fops->removexattr, loc, name, xdata);
|
|
+ return 0;
|
|
out:
|
|
- shard_common_failure_unwind(GF_FOP_REMOVEXATTR, frame, -1, op_errno);
|
|
- return 0;
|
|
+ shard_common_failure_unwind(GF_FOP_REMOVEXATTR, frame, -1, op_errno);
|
|
+ return 0;
|
|
}
|
|
|
|
-int32_t
|
|
-shard_fremovexattr(call_frame_t *frame, xlator_t *this, fd_t *fd,
|
|
- const char *name, dict_t *xdata)
|
|
-{
|
|
- int op_errno = EINVAL;
|
|
+int32_t shard_fremovexattr(call_frame_t *frame, xlator_t *this, fd_t *fd,
|
|
+ const char *name, dict_t *xdata) {
|
|
+ int op_errno = EINVAL;
|
|
|
|
- if (frame->root->pid != GF_CLIENT_PID_GSYNCD) {
|
|
- GF_IF_NATIVE_XATTR_GOTO(SHARD_XATTR_PREFIX "*", name, op_errno, out);
|
|
- }
|
|
+ if (frame->root->pid != GF_CLIENT_PID_GSYNCD) {
|
|
+ GF_IF_NATIVE_XATTR_GOTO(SHARD_XATTR_PREFIX "*", name, op_errno, out);
|
|
+ }
|
|
|
|
- if (xdata && (frame->root->pid != GF_CLIENT_PID_GSYNCD)) {
|
|
- dict_del(xdata, GF_XATTR_SHARD_BLOCK_SIZE);
|
|
- dict_del(xdata, GF_XATTR_SHARD_FILE_SIZE);
|
|
- }
|
|
+ if (xdata && (frame->root->pid != GF_CLIENT_PID_GSYNCD)) {
|
|
+ dict_del(xdata, GF_XATTR_SHARD_BLOCK_SIZE);
|
|
+ dict_del(xdata, GF_XATTR_SHARD_FILE_SIZE);
|
|
+ }
|
|
|
|
- STACK_WIND_TAIL(frame, FIRST_CHILD(this),
|
|
- FIRST_CHILD(this)->fops->fremovexattr, fd, name, xdata);
|
|
- return 0;
|
|
+ STACK_WIND_TAIL(frame, FIRST_CHILD(this),
|
|
+ FIRST_CHILD(this)->fops->fremovexattr, fd, name, xdata);
|
|
+ return 0;
|
|
out:
|
|
- shard_common_failure_unwind(GF_FOP_FREMOVEXATTR, frame, -1, op_errno);
|
|
- return 0;
|
|
+ shard_common_failure_unwind(GF_FOP_FREMOVEXATTR, frame, -1, op_errno);
|
|
+ return 0;
|
|
}
|
|
|
|
-int32_t
|
|
-shard_fgetxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
|
|
- int32_t op_ret, int32_t op_errno, dict_t *dict,
|
|
- dict_t *xdata)
|
|
-{
|
|
- if (op_ret < 0)
|
|
- goto unwind;
|
|
+int32_t shard_fgetxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
|
|
+ int32_t op_ret, int32_t op_errno, dict_t *dict,
|
|
+ dict_t *xdata) {
|
|
+ if (op_ret < 0)
|
|
+ goto unwind;
|
|
|
|
- if (dict && (frame->root->pid != GF_CLIENT_PID_GSYNCD)) {
|
|
- dict_del(dict, GF_XATTR_SHARD_BLOCK_SIZE);
|
|
- dict_del(dict, GF_XATTR_SHARD_FILE_SIZE);
|
|
- }
|
|
+ if (dict && (frame->root->pid != GF_CLIENT_PID_GSYNCD)) {
|
|
+ dict_del(dict, GF_XATTR_SHARD_BLOCK_SIZE);
|
|
+ dict_del(dict, GF_XATTR_SHARD_FILE_SIZE);
|
|
+ }
|
|
|
|
unwind:
|
|
- SHARD_STACK_UNWIND(fgetxattr, frame, op_ret, op_errno, dict, xdata);
|
|
- return 0;
|
|
+ SHARD_STACK_UNWIND(fgetxattr, frame, op_ret, op_errno, dict, xdata);
|
|
+ return 0;
|
|
}
|
|
|
|
-int32_t
|
|
-shard_fgetxattr(call_frame_t *frame, xlator_t *this, fd_t *fd, const char *name,
|
|
- dict_t *xdata)
|
|
-{
|
|
- int op_errno = EINVAL;
|
|
+int32_t shard_fgetxattr(call_frame_t *frame, xlator_t *this, fd_t *fd,
|
|
+ const char *name, dict_t *xdata) {
|
|
+ int op_errno = EINVAL;
|
|
|
|
- if ((frame->root->pid != GF_CLIENT_PID_GSYNCD) && (name) &&
|
|
- (!strncmp(name, SHARD_XATTR_PREFIX, SLEN(SHARD_XATTR_PREFIX)))) {
|
|
- op_errno = ENODATA;
|
|
- goto out;
|
|
- }
|
|
+ if ((frame->root->pid != GF_CLIENT_PID_GSYNCD) && (name) &&
|
|
+ (!strncmp(name, SHARD_XATTR_PREFIX, SLEN(SHARD_XATTR_PREFIX)))) {
|
|
+ op_errno = ENODATA;
|
|
+ goto out;
|
|
+ }
|
|
|
|
- STACK_WIND(frame, shard_fgetxattr_cbk, FIRST_CHILD(this),
|
|
- FIRST_CHILD(this)->fops->fgetxattr, fd, name, xdata);
|
|
- return 0;
|
|
+ STACK_WIND(frame, shard_fgetxattr_cbk, FIRST_CHILD(this),
|
|
+ FIRST_CHILD(this)->fops->fgetxattr, fd, name, xdata);
|
|
+ return 0;
|
|
out:
|
|
- shard_common_failure_unwind(GF_FOP_FGETXATTR, frame, -1, op_errno);
|
|
- return 0;
|
|
+ shard_common_failure_unwind(GF_FOP_FGETXATTR, frame, -1, op_errno);
|
|
+ return 0;
|
|
}
|
|
|
|
-int32_t
|
|
-shard_getxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
|
|
- int32_t op_ret, int32_t op_errno, dict_t *dict,
|
|
- dict_t *xdata)
|
|
-{
|
|
- if (op_ret < 0)
|
|
- goto unwind;
|
|
+int32_t shard_getxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
|
|
+ int32_t op_ret, int32_t op_errno, dict_t *dict,
|
|
+ dict_t *xdata) {
|
|
+ if (op_ret < 0)
|
|
+ goto unwind;
|
|
|
|
- if (dict && (frame->root->pid != GF_CLIENT_PID_GSYNCD)) {
|
|
- dict_del(dict, GF_XATTR_SHARD_BLOCK_SIZE);
|
|
- dict_del(dict, GF_XATTR_SHARD_FILE_SIZE);
|
|
- }
|
|
+ if (dict && (frame->root->pid != GF_CLIENT_PID_GSYNCD)) {
|
|
+ dict_del(dict, GF_XATTR_SHARD_BLOCK_SIZE);
|
|
+ dict_del(dict, GF_XATTR_SHARD_FILE_SIZE);
|
|
+ }
|
|
|
|
unwind:
|
|
- SHARD_STACK_UNWIND(getxattr, frame, op_ret, op_errno, dict, xdata);
|
|
- return 0;
|
|
+ SHARD_STACK_UNWIND(getxattr, frame, op_ret, op_errno, dict, xdata);
|
|
+ return 0;
|
|
}
|
|
|
|
-int32_t
|
|
-shard_getxattr(call_frame_t *frame, xlator_t *this, loc_t *loc,
|
|
- const char *name, dict_t *xdata)
|
|
-{
|
|
- int op_errno = EINVAL;
|
|
+int32_t shard_getxattr(call_frame_t *frame, xlator_t *this, loc_t *loc,
|
|
+ const char *name, dict_t *xdata) {
|
|
+ int op_errno = EINVAL;
|
|
|
|
- if ((frame->root->pid != GF_CLIENT_PID_GSYNCD) && (name) &&
|
|
- (!strncmp(name, SHARD_XATTR_PREFIX, sizeof(SHARD_XATTR_PREFIX) - 1))) {
|
|
- op_errno = ENODATA;
|
|
- goto out;
|
|
- }
|
|
+ if ((frame->root->pid != GF_CLIENT_PID_GSYNCD) && (name) &&
|
|
+ (!strncmp(name, SHARD_XATTR_PREFIX, sizeof(SHARD_XATTR_PREFIX) - 1))) {
|
|
+ op_errno = ENODATA;
|
|
+ goto out;
|
|
+ }
|
|
|
|
- STACK_WIND(frame, shard_getxattr_cbk, FIRST_CHILD(this),
|
|
- FIRST_CHILD(this)->fops->getxattr, loc, name, xdata);
|
|
- return 0;
|
|
+ STACK_WIND(frame, shard_getxattr_cbk, FIRST_CHILD(this),
|
|
+ FIRST_CHILD(this)->fops->getxattr, loc, name, xdata);
|
|
+ return 0;
|
|
out:
|
|
- shard_common_failure_unwind(GF_FOP_GETXATTR, frame, -1, op_errno);
|
|
- return 0;
|
|
+ shard_common_failure_unwind(GF_FOP_GETXATTR, frame, -1, op_errno);
|
|
+ return 0;
|
|
}
|
|
|
|
-int32_t
|
|
-shard_fsetxattr(call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *dict,
|
|
- int32_t flags, dict_t *xdata)
|
|
-{
|
|
- int op_errno = EINVAL;
|
|
+int32_t shard_fsetxattr(call_frame_t *frame, xlator_t *this, fd_t *fd,
|
|
+ dict_t *dict, int32_t flags, dict_t *xdata) {
|
|
+ int op_errno = EINVAL;
|
|
|
|
- if (frame->root->pid != GF_CLIENT_PID_GSYNCD) {
|
|
- GF_IF_INTERNAL_XATTR_GOTO(SHARD_XATTR_PREFIX "*", dict, op_errno, out);
|
|
- }
|
|
+ if (frame->root->pid != GF_CLIENT_PID_GSYNCD) {
|
|
+ GF_IF_INTERNAL_XATTR_GOTO(SHARD_XATTR_PREFIX "*", dict, op_errno, out);
|
|
+ }
|
|
|
|
- STACK_WIND_TAIL(frame, FIRST_CHILD(this),
|
|
- FIRST_CHILD(this)->fops->fsetxattr, fd, dict, flags, xdata);
|
|
- return 0;
|
|
+ STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->fsetxattr,
|
|
+ fd, dict, flags, xdata);
|
|
+ return 0;
|
|
out:
|
|
- shard_common_failure_unwind(GF_FOP_FSETXATTR, frame, -1, op_errno);
|
|
- return 0;
|
|
+ shard_common_failure_unwind(GF_FOP_FSETXATTR, frame, -1, op_errno);
|
|
+ return 0;
|
|
}
|
|
|
|
-int32_t
|
|
-shard_setxattr(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *dict,
|
|
- int32_t flags, dict_t *xdata)
|
|
-{
|
|
- int op_errno = EINVAL;
|
|
+int32_t shard_setxattr(call_frame_t *frame, xlator_t *this, loc_t *loc,
|
|
+ dict_t *dict, int32_t flags, dict_t *xdata) {
|
|
+ int op_errno = EINVAL;
|
|
|
|
- if (frame->root->pid != GF_CLIENT_PID_GSYNCD) {
|
|
- GF_IF_INTERNAL_XATTR_GOTO(SHARD_XATTR_PREFIX "*", dict, op_errno, out);
|
|
- }
|
|
+ if (frame->root->pid != GF_CLIENT_PID_GSYNCD) {
|
|
+ GF_IF_INTERNAL_XATTR_GOTO(SHARD_XATTR_PREFIX "*", dict, op_errno, out);
|
|
+ }
|
|
|
|
- STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->setxattr,
|
|
- loc, dict, flags, xdata);
|
|
- return 0;
|
|
+ STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->setxattr,
|
|
+ loc, dict, flags, xdata);
|
|
+ return 0;
|
|
out:
|
|
- shard_common_failure_unwind(GF_FOP_SETXATTR, frame, -1, op_errno);
|
|
- return 0;
|
|
+ shard_common_failure_unwind(GF_FOP_SETXATTR, frame, -1, op_errno);
|
|
+ return 0;
|
|
}
|
|
|
|
-int
|
|
-shard_post_setattr_handler(call_frame_t *frame, xlator_t *this)
|
|
-{
|
|
- shard_local_t *local = NULL;
|
|
-
|
|
- local = frame->local;
|
|
-
|
|
- if (local->fop == GF_FOP_SETATTR) {
|
|
- if (local->op_ret >= 0)
|
|
- shard_inode_ctx_set(local->loc.inode, this, &local->postbuf, 0,
|
|
- SHARD_LOOKUP_MASK);
|
|
- SHARD_STACK_UNWIND(setattr, frame, local->op_ret, local->op_errno,
|
|
- &local->prebuf, &local->postbuf, local->xattr_rsp);
|
|
- } else if (local->fop == GF_FOP_FSETATTR) {
|
|
- if (local->op_ret >= 0)
|
|
- shard_inode_ctx_set(local->fd->inode, this, &local->postbuf, 0,
|
|
- SHARD_LOOKUP_MASK);
|
|
- SHARD_STACK_UNWIND(fsetattr, frame, local->op_ret, local->op_errno,
|
|
- &local->prebuf, &local->postbuf, local->xattr_rsp);
|
|
- }
|
|
-
|
|
- return 0;
|
|
-}
|
|
+int shard_post_setattr_handler(call_frame_t *frame, xlator_t *this) {
|
|
+ shard_local_t *local = NULL;
|
|
|
|
-int
|
|
-shard_common_setattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
|
|
- int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
|
|
- struct iatt *postbuf, dict_t *xdata)
|
|
-{
|
|
- shard_local_t *local = NULL;
|
|
-
|
|
- local = frame->local;
|
|
-
|
|
- if (op_ret < 0) {
|
|
- local->op_ret = op_ret;
|
|
- local->op_errno = op_errno;
|
|
- goto unwind;
|
|
- }
|
|
+ local = frame->local;
|
|
|
|
- local->prebuf = *prebuf;
|
|
- if (shard_modify_size_and_block_count(&local->prebuf, xdata)) {
|
|
- local->op_ret = -1;
|
|
- local->op_errno = EINVAL;
|
|
- goto unwind;
|
|
- }
|
|
- if (xdata)
|
|
- local->xattr_rsp = dict_ref(xdata);
|
|
- local->postbuf = *postbuf;
|
|
- local->postbuf.ia_size = local->prebuf.ia_size;
|
|
- local->postbuf.ia_blocks = local->prebuf.ia_blocks;
|
|
+ if (local->fop == GF_FOP_SETATTR) {
|
|
+ if (local->op_ret >= 0)
|
|
+ shard_inode_ctx_set(local->loc.inode, this, &local->postbuf, 0,
|
|
+ SHARD_LOOKUP_MASK);
|
|
+ SHARD_STACK_UNWIND(setattr, frame, local->op_ret, local->op_errno,
|
|
+ &local->prebuf, &local->postbuf, local->xattr_rsp);
|
|
+ } else if (local->fop == GF_FOP_FSETATTR) {
|
|
+ if (local->op_ret >= 0)
|
|
+ shard_inode_ctx_set(local->fd->inode, this, &local->postbuf, 0,
|
|
+ SHARD_LOOKUP_MASK);
|
|
+ SHARD_STACK_UNWIND(fsetattr, frame, local->op_ret, local->op_errno,
|
|
+ &local->prebuf, &local->postbuf, local->xattr_rsp);
|
|
+ }
|
|
|
|
-unwind:
|
|
- local->handler(frame, this);
|
|
- return 0;
|
|
+ return 0;
|
|
}
|
|
|
|
-int
|
|
-shard_setattr(call_frame_t *frame, xlator_t *this, loc_t *loc,
|
|
- struct iatt *stbuf, int32_t valid, dict_t *xdata)
|
|
-{
|
|
- int ret = -1;
|
|
- uint64_t block_size = 0;
|
|
- shard_local_t *local = NULL;
|
|
-
|
|
- if ((IA_ISDIR(loc->inode->ia_type)) || (IA_ISLNK(loc->inode->ia_type))) {
|
|
- STACK_WIND(frame, default_setattr_cbk, FIRST_CHILD(this),
|
|
- FIRST_CHILD(this)->fops->setattr, loc, stbuf, valid, xdata);
|
|
- return 0;
|
|
- }
|
|
-
|
|
- ret = shard_inode_ctx_get_block_size(loc->inode, this, &block_size);
|
|
- if (ret) {
|
|
- gf_msg(this->name, GF_LOG_ERROR, 0, SHARD_MSG_INODE_CTX_GET_FAILED,
|
|
- "Failed to get block size from inode ctx of %s",
|
|
- uuid_utoa(loc->inode->gfid));
|
|
- goto err;
|
|
- }
|
|
-
|
|
- if (!block_size || frame->root->pid == GF_CLIENT_PID_GSYNCD) {
|
|
- STACK_WIND(frame, default_setattr_cbk, FIRST_CHILD(this),
|
|
- FIRST_CHILD(this)->fops->setattr, loc, stbuf, valid, xdata);
|
|
- return 0;
|
|
- }
|
|
-
|
|
- local = mem_get0(this->local_pool);
|
|
- if (!local)
|
|
- goto err;
|
|
+int shard_common_setattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
|
|
+ int32_t op_ret, int32_t op_errno,
|
|
+ struct iatt *prebuf, struct iatt *postbuf,
|
|
+ dict_t *xdata) {
|
|
+ shard_local_t *local = NULL;
|
|
|
|
- frame->local = local;
|
|
+ local = frame->local;
|
|
|
|
- local->handler = shard_post_setattr_handler;
|
|
- local->xattr_req = (xdata) ? dict_ref(xdata) : dict_new();
|
|
- if (!local->xattr_req)
|
|
- goto err;
|
|
- local->fop = GF_FOP_SETATTR;
|
|
- loc_copy(&local->loc, loc);
|
|
+ if (op_ret < 0) {
|
|
+ local->op_ret = op_ret;
|
|
+ local->op_errno = op_errno;
|
|
+ goto unwind;
|
|
+ }
|
|
|
|
- SHARD_MD_READ_FOP_INIT_REQ_DICT(this, local->xattr_req, local->loc.gfid,
|
|
- local, err);
|
|
+ local->prebuf = *prebuf;
|
|
+ if (shard_modify_size_and_block_count(&local->prebuf, xdata)) {
|
|
+ local->op_ret = -1;
|
|
+ local->op_errno = EINVAL;
|
|
+ goto unwind;
|
|
+ }
|
|
+ if (xdata)
|
|
+ local->xattr_rsp = dict_ref(xdata);
|
|
+ local->postbuf = *postbuf;
|
|
+ local->postbuf.ia_size = local->prebuf.ia_size;
|
|
+ local->postbuf.ia_blocks = local->prebuf.ia_blocks;
|
|
|
|
- STACK_WIND(frame, shard_common_setattr_cbk, FIRST_CHILD(this),
|
|
- FIRST_CHILD(this)->fops->setattr, loc, stbuf, valid,
|
|
- local->xattr_req);
|
|
- return 0;
|
|
-err:
|
|
- shard_common_failure_unwind(GF_FOP_SETATTR, frame, -1, ENOMEM);
|
|
- return 0;
|
|
+unwind:
|
|
+ local->handler(frame, this);
|
|
+ return 0;
|
|
}
|
|
|
|
-int
|
|
-shard_fsetattr(call_frame_t *frame, xlator_t *this, fd_t *fd,
|
|
- struct iatt *stbuf, int32_t valid, dict_t *xdata)
|
|
-{
|
|
- int ret = -1;
|
|
- uint64_t block_size = 0;
|
|
- shard_local_t *local = NULL;
|
|
-
|
|
- if ((IA_ISDIR(fd->inode->ia_type)) || (IA_ISLNK(fd->inode->ia_type))) {
|
|
- STACK_WIND(frame, default_fsetattr_cbk, FIRST_CHILD(this),
|
|
- FIRST_CHILD(this)->fops->fsetattr, fd, stbuf, valid, xdata);
|
|
- return 0;
|
|
- }
|
|
+int shard_setattr(call_frame_t *frame, xlator_t *this, loc_t *loc,
|
|
+ struct iatt *stbuf, int32_t valid, dict_t *xdata) {
|
|
+ int ret = -1;
|
|
+ uint64_t block_size = 0;
|
|
+ shard_local_t *local = NULL;
|
|
|
|
- ret = shard_inode_ctx_get_block_size(fd->inode, this, &block_size);
|
|
- if (ret) {
|
|
- gf_msg(this->name, GF_LOG_ERROR, 0, SHARD_MSG_INODE_CTX_GET_FAILED,
|
|
- "Failed to get block size from inode ctx of %s",
|
|
- uuid_utoa(fd->inode->gfid));
|
|
- goto err;
|
|
- }
|
|
+ if ((IA_ISDIR(loc->inode->ia_type)) || (IA_ISLNK(loc->inode->ia_type))) {
|
|
+ STACK_WIND(frame, default_setattr_cbk, FIRST_CHILD(this),
|
|
+ FIRST_CHILD(this)->fops->setattr, loc, stbuf, valid, xdata);
|
|
+ return 0;
|
|
+ }
|
|
|
|
- if (!block_size || frame->root->pid == GF_CLIENT_PID_GSYNCD) {
|
|
- STACK_WIND(frame, default_fsetattr_cbk, FIRST_CHILD(this),
|
|
- FIRST_CHILD(this)->fops->fsetattr, fd, stbuf, valid, xdata);
|
|
- return 0;
|
|
- }
|
|
+ ret = shard_inode_ctx_get_block_size(loc->inode, this, &block_size);
|
|
+ if (ret) {
|
|
+ gf_msg(this->name, GF_LOG_ERROR, 0, SHARD_MSG_INODE_CTX_GET_FAILED,
|
|
+ "Failed to get block size from inode ctx of %s",
|
|
+ uuid_utoa(loc->inode->gfid));
|
|
+ goto err;
|
|
+ }
|
|
|
|
- if (!this->itable)
|
|
- this->itable = fd->inode->table;
|
|
+ if (!block_size || frame->root->pid == GF_CLIENT_PID_GSYNCD) {
|
|
+ STACK_WIND(frame, default_setattr_cbk, FIRST_CHILD(this),
|
|
+ FIRST_CHILD(this)->fops->setattr, loc, stbuf, valid, xdata);
|
|
+ return 0;
|
|
+ }
|
|
|
|
- local = mem_get0(this->local_pool);
|
|
- if (!local)
|
|
- goto err;
|
|
+ local = mem_get0(this->local_pool);
|
|
+ if (!local)
|
|
+ goto err;
|
|
|
|
- frame->local = local;
|
|
+ frame->local = local;
|
|
|
|
- local->handler = shard_post_setattr_handler;
|
|
- local->xattr_req = (xdata) ? dict_ref(xdata) : dict_new();
|
|
- if (!local->xattr_req)
|
|
- goto err;
|
|
- local->fop = GF_FOP_FSETATTR;
|
|
- local->fd = fd_ref(fd);
|
|
+ local->handler = shard_post_setattr_handler;
|
|
+ local->xattr_req = (xdata) ? dict_ref(xdata) : dict_new();
|
|
+ if (!local->xattr_req)
|
|
+ goto err;
|
|
+ local->fop = GF_FOP_SETATTR;
|
|
+ loc_copy(&local->loc, loc);
|
|
|
|
- SHARD_MD_READ_FOP_INIT_REQ_DICT(this, local->xattr_req, fd->inode->gfid,
|
|
- local, err);
|
|
+ SHARD_MD_READ_FOP_INIT_REQ_DICT(this, local->xattr_req, local->loc.gfid,
|
|
+ local, err);
|
|
|
|
- STACK_WIND(frame, shard_common_setattr_cbk, FIRST_CHILD(this),
|
|
- FIRST_CHILD(this)->fops->fsetattr, fd, stbuf, valid,
|
|
- local->xattr_req);
|
|
- return 0;
|
|
+ STACK_WIND(frame, shard_common_setattr_cbk, FIRST_CHILD(this),
|
|
+ FIRST_CHILD(this)->fops->setattr, loc, stbuf, valid,
|
|
+ local->xattr_req);
|
|
+ return 0;
|
|
err:
|
|
- shard_common_failure_unwind(GF_FOP_FSETATTR, frame, -1, ENOMEM);
|
|
- return 0;
|
|
+ shard_common_failure_unwind(GF_FOP_SETATTR, frame, -1, ENOMEM);
|
|
+ return 0;
|
|
}
|
|
|
|
-int
|
|
-shard_common_inode_write_begin(call_frame_t *frame, xlator_t *this,
|
|
- glusterfs_fop_t fop, fd_t *fd,
|
|
- struct iovec *vector, int32_t count,
|
|
- off_t offset, uint32_t flags, size_t len,
|
|
- struct iobref *iobref, dict_t *xdata)
|
|
-{
|
|
- int ret = 0;
|
|
- int i = 0;
|
|
- uint64_t block_size = 0;
|
|
- shard_local_t *local = NULL;
|
|
+int shard_fsetattr(call_frame_t *frame, xlator_t *this, fd_t *fd,
|
|
+ struct iatt *stbuf, int32_t valid, dict_t *xdata) {
|
|
+ int ret = -1;
|
|
+ uint64_t block_size = 0;
|
|
+ shard_local_t *local = NULL;
|
|
|
|
- ret = shard_inode_ctx_get_block_size(fd->inode, this, &block_size);
|
|
- if (ret) {
|
|
- gf_msg(this->name, GF_LOG_ERROR, 0, SHARD_MSG_INODE_CTX_GET_FAILED,
|
|
- "Failed to get block "
|
|
- "size for %s from its inode ctx",
|
|
- uuid_utoa(fd->inode->gfid));
|
|
- goto out;
|
|
- }
|
|
+ if ((IA_ISDIR(fd->inode->ia_type)) || (IA_ISLNK(fd->inode->ia_type))) {
|
|
+ STACK_WIND(frame, default_fsetattr_cbk, FIRST_CHILD(this),
|
|
+ FIRST_CHILD(this)->fops->fsetattr, fd, stbuf, valid, xdata);
|
|
+ return 0;
|
|
+ }
|
|
|
|
- if (!block_size || frame->root->pid == GF_CLIENT_PID_GSYNCD) {
|
|
- /* block_size = 0 means that the file was created before
|
|
- * sharding was enabled on the volume.
|
|
- */
|
|
- switch (fop) {
|
|
- case GF_FOP_WRITE:
|
|
- STACK_WIND_TAIL(frame, FIRST_CHILD(this),
|
|
- FIRST_CHILD(this)->fops->writev, fd, vector,
|
|
- count, offset, flags, iobref, xdata);
|
|
- break;
|
|
- case GF_FOP_FALLOCATE:
|
|
- STACK_WIND_TAIL(frame, FIRST_CHILD(this),
|
|
- FIRST_CHILD(this)->fops->fallocate, fd, flags,
|
|
- offset, len, xdata);
|
|
- break;
|
|
- case GF_FOP_ZEROFILL:
|
|
- STACK_WIND_TAIL(frame, FIRST_CHILD(this),
|
|
- FIRST_CHILD(this)->fops->zerofill, fd, offset,
|
|
- len, xdata);
|
|
- break;
|
|
- case GF_FOP_DISCARD:
|
|
- STACK_WIND_TAIL(frame, FIRST_CHILD(this),
|
|
- FIRST_CHILD(this)->fops->discard, fd, offset,
|
|
- len, xdata);
|
|
- break;
|
|
- default:
|
|
- gf_msg(this->name, GF_LOG_WARNING, 0, SHARD_MSG_INVALID_FOP,
|
|
- "Invalid fop id = %d", fop);
|
|
- break;
|
|
- }
|
|
- return 0;
|
|
- }
|
|
+ ret = shard_inode_ctx_get_block_size(fd->inode, this, &block_size);
|
|
+ if (ret) {
|
|
+ gf_msg(this->name, GF_LOG_ERROR, 0, SHARD_MSG_INODE_CTX_GET_FAILED,
|
|
+ "Failed to get block size from inode ctx of %s",
|
|
+ uuid_utoa(fd->inode->gfid));
|
|
+ goto err;
|
|
+ }
|
|
|
|
- if (!this->itable)
|
|
- this->itable = fd->inode->table;
|
|
+ if (!block_size || frame->root->pid == GF_CLIENT_PID_GSYNCD) {
|
|
+ STACK_WIND(frame, default_fsetattr_cbk, FIRST_CHILD(this),
|
|
+ FIRST_CHILD(this)->fops->fsetattr, fd, stbuf, valid, xdata);
|
|
+ return 0;
|
|
+ }
|
|
|
|
- local = mem_get0(this->local_pool);
|
|
- if (!local)
|
|
- goto out;
|
|
+ if (!this->itable)
|
|
+ this->itable = fd->inode->table;
|
|
|
|
- frame->local = local;
|
|
+ local = mem_get0(this->local_pool);
|
|
+ if (!local)
|
|
+ goto err;
|
|
|
|
- ret = syncbarrier_init(&local->barrier);
|
|
- if (ret)
|
|
- goto out;
|
|
- local->xattr_req = (xdata) ? dict_ref(xdata) : dict_new();
|
|
- if (!local->xattr_req)
|
|
- goto out;
|
|
-
|
|
- if (vector) {
|
|
- local->vector = iov_dup(vector, count);
|
|
- if (!local->vector)
|
|
- goto out;
|
|
- for (i = 0; i < count; i++)
|
|
- local->total_size += vector[i].iov_len;
|
|
- local->count = count;
|
|
- } else {
|
|
- local->total_size = len;
|
|
- }
|
|
+ frame->local = local;
|
|
|
|
- local->fop = fop;
|
|
- local->offset = offset;
|
|
- local->flags = flags;
|
|
- if (iobref)
|
|
- local->iobref = iobref_ref(iobref);
|
|
- local->fd = fd_ref(fd);
|
|
- local->block_size = block_size;
|
|
- local->resolver_base_inode = local->fd->inode;
|
|
- GF_ATOMIC_INIT(local->delta_blocks, 0);
|
|
+ local->handler = shard_post_setattr_handler;
|
|
+ local->xattr_req = (xdata) ? dict_ref(xdata) : dict_new();
|
|
+ if (!local->xattr_req)
|
|
+ goto err;
|
|
+ local->fop = GF_FOP_FSETATTR;
|
|
+ local->fd = fd_ref(fd);
|
|
|
|
- local->loc.inode = inode_ref(fd->inode);
|
|
- gf_uuid_copy(local->loc.gfid, fd->inode->gfid);
|
|
+ SHARD_MD_READ_FOP_INIT_REQ_DICT(this, local->xattr_req, fd->inode->gfid,
|
|
+ local, err);
|
|
|
|
- shard_lookup_base_file(frame, this, &local->loc,
|
|
- shard_common_inode_write_post_lookup_handler);
|
|
- return 0;
|
|
+ STACK_WIND(frame, shard_common_setattr_cbk, FIRST_CHILD(this),
|
|
+ FIRST_CHILD(this)->fops->fsetattr, fd, stbuf, valid,
|
|
+ local->xattr_req);
|
|
+ return 0;
|
|
+err:
|
|
+ shard_common_failure_unwind(GF_FOP_FSETATTR, frame, -1, ENOMEM);
|
|
+ return 0;
|
|
+}
|
|
+
|
|
+int shard_common_inode_write_begin(call_frame_t *frame, xlator_t *this,
|
|
+ glusterfs_fop_t fop, fd_t *fd,
|
|
+ struct iovec *vector, int32_t count,
|
|
+ off_t offset, uint32_t flags, size_t len,
|
|
+ struct iobref *iobref, dict_t *xdata) {
|
|
+ int ret = 0;
|
|
+ int i = 0;
|
|
+ uint64_t block_size = 0;
|
|
+ shard_local_t *local = NULL;
|
|
+
|
|
+ ret = shard_inode_ctx_get_block_size(fd->inode, this, &block_size);
|
|
+ if (ret) {
|
|
+ gf_msg(this->name, GF_LOG_ERROR, 0, SHARD_MSG_INODE_CTX_GET_FAILED,
|
|
+ "Failed to get block "
|
|
+ "size for %s from its inode ctx",
|
|
+ uuid_utoa(fd->inode->gfid));
|
|
+ goto out;
|
|
+ }
|
|
+
|
|
+ if (!block_size || frame->root->pid == GF_CLIENT_PID_GSYNCD) {
|
|
+ /* block_size = 0 means that the file was created before
|
|
+ * sharding was enabled on the volume.
|
|
+ */
|
|
+ switch (fop) {
|
|
+ case GF_FOP_WRITE:
|
|
+ STACK_WIND_TAIL(frame, FIRST_CHILD(this), FIRST_CHILD(this)->fops->writev,
|
|
+ fd, vector, count, offset, flags, iobref, xdata);
|
|
+ break;
|
|
+ case GF_FOP_FALLOCATE:
|
|
+ STACK_WIND_TAIL(frame, FIRST_CHILD(this),
|
|
+ FIRST_CHILD(this)->fops->fallocate, fd, flags, offset,
|
|
+ len, xdata);
|
|
+ break;
|
|
+ case GF_FOP_ZEROFILL:
|
|
+ STACK_WIND_TAIL(frame, FIRST_CHILD(this),
|
|
+ FIRST_CHILD(this)->fops->zerofill, fd, offset, len,
|
|
+ xdata);
|
|
+ break;
|
|
+ case GF_FOP_DISCARD:
|
|
+ STACK_WIND_TAIL(frame, FIRST_CHILD(this),
|
|
+ FIRST_CHILD(this)->fops->discard, fd, offset, len, xdata);
|
|
+ break;
|
|
+ default:
|
|
+ gf_msg(this->name, GF_LOG_WARNING, 0, SHARD_MSG_INVALID_FOP,
|
|
+ "Invalid fop id = %d", fop);
|
|
+ break;
|
|
+ }
|
|
+ return 0;
|
|
+ }
|
|
+
|
|
+ if (!this->itable)
|
|
+ this->itable = fd->inode->table;
|
|
+
|
|
+ local = mem_get0(this->local_pool);
|
|
+ if (!local)
|
|
+ goto out;
|
|
+
|
|
+ frame->local = local;
|
|
+
|
|
+ ret = syncbarrier_init(&local->barrier);
|
|
+ if (ret)
|
|
+ goto out;
|
|
+ local->xattr_req = (xdata) ? dict_ref(xdata) : dict_new();
|
|
+ if (!local->xattr_req)
|
|
+ goto out;
|
|
+
|
|
+ if (vector) {
|
|
+ local->vector = iov_dup(vector, count);
|
|
+ if (!local->vector)
|
|
+ goto out;
|
|
+ for (i = 0; i < count; i++)
|
|
+ local->total_size += vector[i].iov_len;
|
|
+ local->count = count;
|
|
+ } else {
|
|
+ local->total_size = len;
|
|
+ }
|
|
+
|
|
+ local->fop = fop;
|
|
+ local->offset = offset;
|
|
+ local->flags = flags;
|
|
+ if (iobref)
|
|
+ local->iobref = iobref_ref(iobref);
|
|
+ local->fd = fd_ref(fd);
|
|
+ local->block_size = block_size;
|
|
+ local->resolver_base_inode = local->fd->inode;
|
|
+ GF_ATOMIC_INIT(local->delta_blocks, 0);
|
|
+
|
|
+ local->loc.inode = inode_ref(fd->inode);
|
|
+ gf_uuid_copy(local->loc.gfid, fd->inode->gfid);
|
|
+
|
|
+ shard_lookup_base_file(frame, this, &local->loc,
|
|
+ shard_common_inode_write_post_lookup_handler);
|
|
+ return 0;
|
|
out:
|
|
- shard_common_failure_unwind(fop, frame, -1, ENOMEM);
|
|
- return 0;
|
|
+ shard_common_failure_unwind(fop, frame, -1, ENOMEM);
|
|
+ return 0;
|
|
}
|
|
|
|
-int
|
|
-shard_writev(call_frame_t *frame, xlator_t *this, fd_t *fd,
|
|
- struct iovec *vector, int32_t count, off_t offset, uint32_t flags,
|
|
- struct iobref *iobref, dict_t *xdata)
|
|
-{
|
|
- shard_common_inode_write_begin(frame, this, GF_FOP_WRITE, fd, vector, count,
|
|
- offset, flags, 0, iobref, xdata);
|
|
- return 0;
|
|
+int shard_writev(call_frame_t *frame, xlator_t *this, fd_t *fd,
|
|
+ struct iovec *vector, int32_t count, off_t offset,
|
|
+ uint32_t flags, struct iobref *iobref, dict_t *xdata) {
|
|
+ shard_common_inode_write_begin(frame, this, GF_FOP_WRITE, fd, vector, count,
|
|
+ offset, flags, 0, iobref, xdata);
|
|
+ return 0;
|
|
}
|
|
|
|
-int
|
|
-shard_fallocate(call_frame_t *frame, xlator_t *this, fd_t *fd,
|
|
- int32_t keep_size, off_t offset, size_t len, dict_t *xdata)
|
|
-{
|
|
- if ((keep_size != 0) && (keep_size != FALLOC_FL_ZERO_RANGE) &&
|
|
- (keep_size != (FALLOC_FL_KEEP_SIZE | FALLOC_FL_PUNCH_HOLE)))
|
|
- goto out;
|
|
+int shard_fallocate(call_frame_t *frame, xlator_t *this, fd_t *fd,
|
|
+ int32_t keep_size, off_t offset, size_t len,
|
|
+ dict_t *xdata) {
|
|
+ if ((keep_size != 0) && (keep_size != FALLOC_FL_ZERO_RANGE) &&
|
|
+ (keep_size != (FALLOC_FL_KEEP_SIZE | FALLOC_FL_PUNCH_HOLE)))
|
|
+ goto out;
|
|
|
|
- shard_common_inode_write_begin(frame, this, GF_FOP_FALLOCATE, fd, NULL, 0,
|
|
- offset, keep_size, len, NULL, xdata);
|
|
- return 0;
|
|
+ shard_common_inode_write_begin(frame, this, GF_FOP_FALLOCATE, fd, NULL, 0,
|
|
+ offset, keep_size, len, NULL, xdata);
|
|
+ return 0;
|
|
out:
|
|
- shard_common_failure_unwind(GF_FOP_FALLOCATE, frame, -1, ENOTSUP);
|
|
- return 0;
|
|
+ shard_common_failure_unwind(GF_FOP_FALLOCATE, frame, -1, ENOTSUP);
|
|
+ return 0;
|
|
}
|
|
|
|
-int
|
|
-shard_zerofill(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
|
|
- off_t len, dict_t *xdata)
|
|
-{
|
|
- shard_common_inode_write_begin(frame, this, GF_FOP_ZEROFILL, fd, NULL, 0,
|
|
- offset, 0, len, NULL, xdata);
|
|
- return 0;
|
|
+int shard_zerofill(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
|
|
+ off_t len, dict_t *xdata) {
|
|
+ shard_common_inode_write_begin(frame, this, GF_FOP_ZEROFILL, fd, NULL, 0,
|
|
+ offset, 0, len, NULL, xdata);
|
|
+ return 0;
|
|
}
|
|
|
|
-int
|
|
-shard_discard(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
|
|
- size_t len, dict_t *xdata)
|
|
-{
|
|
- shard_common_inode_write_begin(frame, this, GF_FOP_DISCARD, fd, NULL, 0,
|
|
- offset, 0, len, NULL, xdata);
|
|
- return 0;
|
|
+int shard_discard(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
|
|
+ size_t len, dict_t *xdata) {
|
|
+ shard_common_inode_write_begin(frame, this, GF_FOP_DISCARD, fd, NULL, 0,
|
|
+ offset, 0, len, NULL, xdata);
|
|
+ return 0;
|
|
}
|
|
|
|
-int32_t
|
|
-shard_seek(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
|
|
- gf_seek_what_t what, dict_t *xdata)
|
|
-{
|
|
- /* TBD */
|
|
- gf_msg(this->name, GF_LOG_INFO, ENOTSUP, SHARD_MSG_FOP_NOT_SUPPORTED,
|
|
- "seek called on %s.", uuid_utoa(fd->inode->gfid));
|
|
- shard_common_failure_unwind(GF_FOP_SEEK, frame, -1, ENOTSUP);
|
|
- return 0;
|
|
+int32_t shard_seek(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
|
|
+ gf_seek_what_t what, dict_t *xdata) {
|
|
+ /* TBD */
|
|
+ gf_msg(this->name, GF_LOG_INFO, ENOTSUP, SHARD_MSG_FOP_NOT_SUPPORTED,
|
|
+ "seek called on %s.", uuid_utoa(fd->inode->gfid));
|
|
+ shard_common_failure_unwind(GF_FOP_SEEK, frame, -1, ENOTSUP);
|
|
+ return 0;
|
|
}
|
|
|
|
-int32_t
|
|
-mem_acct_init(xlator_t *this)
|
|
-{
|
|
- int ret = -1;
|
|
-
|
|
- if (!this)
|
|
- return ret;
|
|
+int32_t mem_acct_init(xlator_t *this) {
|
|
+ int ret = -1;
|
|
|
|
- ret = xlator_mem_acct_init(this, gf_shard_mt_end + 1);
|
|
+ if (!this)
|
|
+ return ret;
|
|
|
|
- if (ret != 0) {
|
|
- gf_msg(this->name, GF_LOG_ERROR, 0, SHARD_MSG_MEM_ACCT_INIT_FAILED,
|
|
- "Memory accounting init"
|
|
- "failed");
|
|
- return ret;
|
|
- }
|
|
+ ret = xlator_mem_acct_init(this, gf_shard_mt_end + 1);
|
|
|
|
+ if (ret != 0) {
|
|
+ gf_msg(this->name, GF_LOG_ERROR, 0, SHARD_MSG_MEM_ACCT_INIT_FAILED,
|
|
+ "Memory accounting init"
|
|
+ "failed");
|
|
return ret;
|
|
+ }
|
|
+
|
|
+ return ret;
|
|
}
|
|
|
|
-int
|
|
-init(xlator_t *this)
|
|
-{
|
|
- int ret = -1;
|
|
- shard_priv_t *priv = NULL;
|
|
+int init(xlator_t *this) {
|
|
+ int ret = -1;
|
|
+ shard_priv_t *priv = NULL;
|
|
|
|
- if (!this) {
|
|
- gf_msg("shard", GF_LOG_ERROR, 0, SHARD_MSG_NULL_THIS,
|
|
- "this is NULL. init() failed");
|
|
- return -1;
|
|
- }
|
|
+ if (!this) {
|
|
+ gf_msg("shard", GF_LOG_ERROR, 0, SHARD_MSG_NULL_THIS,
|
|
+ "this is NULL. init() failed");
|
|
+ return -1;
|
|
+ }
|
|
|
|
- if (!this->parents) {
|
|
- gf_msg(this->name, GF_LOG_ERROR, 0, SHARD_MSG_INVALID_VOLFILE,
|
|
- "Dangling volume. Check volfile");
|
|
- goto out;
|
|
- }
|
|
+ if (!this->parents) {
|
|
+ gf_msg(this->name, GF_LOG_ERROR, 0, SHARD_MSG_INVALID_VOLFILE,
|
|
+ "Dangling volume. Check volfile");
|
|
+ goto out;
|
|
+ }
|
|
|
|
- if (!this->children || this->children->next) {
|
|
- gf_msg(this->name, GF_LOG_ERROR, 0, SHARD_MSG_INVALID_VOLFILE,
|
|
- "shard not configured with exactly one sub-volume. "
|
|
- "Check volfile");
|
|
- goto out;
|
|
- }
|
|
+ if (!this->children || this->children->next) {
|
|
+ gf_msg(this->name, GF_LOG_ERROR, 0, SHARD_MSG_INVALID_VOLFILE,
|
|
+ "shard not configured with exactly one sub-volume. "
|
|
+ "Check volfile");
|
|
+ goto out;
|
|
+ }
|
|
|
|
- priv = GF_CALLOC(1, sizeof(shard_priv_t), gf_shard_mt_priv_t);
|
|
- if (!priv)
|
|
- goto out;
|
|
+ priv = GF_CALLOC(1, sizeof(shard_priv_t), gf_shard_mt_priv_t);
|
|
+ if (!priv)
|
|
+ goto out;
|
|
|
|
- GF_OPTION_INIT("shard-block-size", priv->block_size, size_uint64, out);
|
|
+ GF_OPTION_INIT("shard-block-size", priv->block_size, size_uint64, out);
|
|
|
|
- GF_OPTION_INIT("shard-deletion-rate", priv->deletion_rate, uint32, out);
|
|
+ GF_OPTION_INIT("shard-deletion-rate", priv->deletion_rate, uint32, out);
|
|
|
|
- GF_OPTION_INIT("shard-lru-limit", priv->lru_limit, uint64, out);
|
|
+ GF_OPTION_INIT("shard-lru-limit", priv->lru_limit, uint64, out);
|
|
|
|
- this->local_pool = mem_pool_new(shard_local_t, 128);
|
|
- if (!this->local_pool) {
|
|
- ret = -1;
|
|
- goto out;
|
|
- }
|
|
- gf_uuid_parse(SHARD_ROOT_GFID, priv->dot_shard_gfid);
|
|
- gf_uuid_parse(DOT_SHARD_REMOVE_ME_GFID, priv->dot_shard_rm_gfid);
|
|
+ this->local_pool = mem_pool_new(shard_local_t, 128);
|
|
+ if (!this->local_pool) {
|
|
+ ret = -1;
|
|
+ goto out;
|
|
+ }
|
|
+ gf_uuid_parse(SHARD_ROOT_GFID, priv->dot_shard_gfid);
|
|
+ gf_uuid_parse(DOT_SHARD_REMOVE_ME_GFID, priv->dot_shard_rm_gfid);
|
|
|
|
- this->private = priv;
|
|
- LOCK_INIT(&priv->lock);
|
|
- INIT_LIST_HEAD(&priv->ilist_head);
|
|
- ret = 0;
|
|
+ this->private = priv;
|
|
+ LOCK_INIT(&priv->lock);
|
|
+ INIT_LIST_HEAD(&priv->ilist_head);
|
|
+ ret = 0;
|
|
out:
|
|
- if (ret) {
|
|
- GF_FREE(priv);
|
|
- mem_pool_destroy(this->local_pool);
|
|
- }
|
|
+ if (ret) {
|
|
+ GF_FREE(priv);
|
|
+ mem_pool_destroy(this->local_pool);
|
|
+ }
|
|
|
|
- return ret;
|
|
+ return ret;
|
|
}
|
|
|
|
-void
|
|
-fini(xlator_t *this)
|
|
-{
|
|
- shard_priv_t *priv = NULL;
|
|
+void fini(xlator_t *this) {
|
|
+ shard_priv_t *priv = NULL;
|
|
|
|
- GF_VALIDATE_OR_GOTO("shard", this, out);
|
|
+ GF_VALIDATE_OR_GOTO("shard", this, out);
|
|
|
|
- mem_pool_destroy(this->local_pool);
|
|
- this->local_pool = NULL;
|
|
+ mem_pool_destroy(this->local_pool);
|
|
+ this->local_pool = NULL;
|
|
|
|
- priv = this->private;
|
|
- if (!priv)
|
|
- goto out;
|
|
+ priv = this->private;
|
|
+ if (!priv)
|
|
+ goto out;
|
|
|
|
- this->private = NULL;
|
|
- LOCK_DESTROY(&priv->lock);
|
|
- GF_FREE(priv);
|
|
+ this->private = NULL;
|
|
+ LOCK_DESTROY(&priv->lock);
|
|
+ GF_FREE(priv);
|
|
|
|
out:
|
|
- return;
|
|
+ return;
|
|
}
|
|
|
|
-int
|
|
-reconfigure(xlator_t *this, dict_t *options)
|
|
-{
|
|
- int ret = -1;
|
|
- shard_priv_t *priv = NULL;
|
|
+int reconfigure(xlator_t *this, dict_t *options) {
|
|
+ int ret = -1;
|
|
+ shard_priv_t *priv = NULL;
|
|
|
|
- priv = this->private;
|
|
+ priv = this->private;
|
|
|
|
- GF_OPTION_RECONF("shard-block-size", priv->block_size, options, size, out);
|
|
+ GF_OPTION_RECONF("shard-block-size", priv->block_size, options, size, out);
|
|
|
|
- GF_OPTION_RECONF("shard-deletion-rate", priv->deletion_rate, options,
|
|
- uint32, out);
|
|
- ret = 0;
|
|
+ GF_OPTION_RECONF("shard-deletion-rate", priv->deletion_rate, options, uint32,
|
|
+ out);
|
|
+ ret = 0;
|
|
|
|
out:
|
|
- return ret;
|
|
+ return ret;
|
|
}
|
|
|
|
-int
|
|
-shard_forget(xlator_t *this, inode_t *inode)
|
|
-{
|
|
- uint64_t ctx_uint = 0;
|
|
- shard_inode_ctx_t *ctx = NULL;
|
|
- shard_priv_t *priv = NULL;
|
|
+int shard_forget(xlator_t *this, inode_t *inode) {
|
|
+ uint64_t ctx_uint = 0;
|
|
+ shard_inode_ctx_t *ctx = NULL;
|
|
+ shard_priv_t *priv = NULL;
|
|
|
|
- priv = this->private;
|
|
- if (!priv)
|
|
- return 0;
|
|
+ priv = this->private;
|
|
+ if (!priv)
|
|
+ return 0;
|
|
|
|
- inode_ctx_del(inode, this, &ctx_uint);
|
|
- if (!ctx_uint)
|
|
- return 0;
|
|
+ inode_ctx_del(inode, this, &ctx_uint);
|
|
+ if (!ctx_uint)
|
|
+ return 0;
|
|
|
|
- ctx = (shard_inode_ctx_t *)(uintptr_t)ctx_uint;
|
|
+ ctx = (shard_inode_ctx_t *)(uintptr_t)ctx_uint;
|
|
|
|
- /* When LRU limit reaches inode will be forcefully removed from the
|
|
- * table, inode needs to be removed from LRU of shard as well.
|
|
- */
|
|
- if (!list_empty(&ctx->ilist)) {
|
|
- LOCK(&priv->lock);
|
|
- {
|
|
- list_del_init(&ctx->ilist);
|
|
- priv->inode_count--;
|
|
- }
|
|
- UNLOCK(&priv->lock);
|
|
+ /* When LRU limit reaches inode will be forcefully removed from the
|
|
+ * table, inode needs to be removed from LRU of shard as well.
|
|
+ */
|
|
+ if (!list_empty(&ctx->ilist)) {
|
|
+ LOCK(&priv->lock);
|
|
+ {
|
|
+ list_del_init(&ctx->ilist);
|
|
+ priv->inode_count--;
|
|
}
|
|
- GF_FREE(ctx);
|
|
+ UNLOCK(&priv->lock);
|
|
+ }
|
|
+ GF_FREE(ctx);
|
|
|
|
- return 0;
|
|
+ return 0;
|
|
}
|
|
|
|
-int
|
|
-shard_release(xlator_t *this, fd_t *fd)
|
|
-{
|
|
- /* TBD */
|
|
- return 0;
|
|
+int shard_release(xlator_t *this, fd_t *fd) {
|
|
+ /* TBD */
|
|
+ return 0;
|
|
}
|
|
|
|
-int
|
|
-shard_priv_dump(xlator_t *this)
|
|
-{
|
|
- shard_priv_t *priv = NULL;
|
|
- char key_prefix[GF_DUMP_MAX_BUF_LEN] = {
|
|
- 0,
|
|
- };
|
|
- char *str = NULL;
|
|
+int shard_priv_dump(xlator_t *this) {
|
|
+ shard_priv_t *priv = NULL;
|
|
+ char key_prefix[GF_DUMP_MAX_BUF_LEN] = {
|
|
+ 0,
|
|
+ };
|
|
+ char *str = NULL;
|
|
|
|
- priv = this->private;
|
|
+ priv = this->private;
|
|
|
|
- snprintf(key_prefix, GF_DUMP_MAX_BUF_LEN, "%s.%s", this->type, this->name);
|
|
- gf_proc_dump_add_section("%s", key_prefix);
|
|
- str = gf_uint64_2human_readable(priv->block_size);
|
|
- gf_proc_dump_write("shard-block-size", "%s", str);
|
|
- gf_proc_dump_write("inode-count", "%d", priv->inode_count);
|
|
- gf_proc_dump_write("ilist_head", "%p", &priv->ilist_head);
|
|
- gf_proc_dump_write("lru-max-limit", "%" PRIu64, priv->lru_limit);
|
|
+ snprintf(key_prefix, GF_DUMP_MAX_BUF_LEN, "%s.%s", this->type, this->name);
|
|
+ gf_proc_dump_add_section("%s", key_prefix);
|
|
+ str = gf_uint64_2human_readable(priv->block_size);
|
|
+ gf_proc_dump_write("shard-block-size", "%s", str);
|
|
+ gf_proc_dump_write("inode-count", "%d", priv->inode_count);
|
|
+ gf_proc_dump_write("ilist_head", "%p", &priv->ilist_head);
|
|
+ gf_proc_dump_write("lru-max-limit", "%" PRIu64, priv->lru_limit);
|
|
|
|
- GF_FREE(str);
|
|
+ GF_FREE(str);
|
|
|
|
- return 0;
|
|
+ return 0;
|
|
}
|
|
|
|
-int
|
|
-shard_releasedir(xlator_t *this, fd_t *fd)
|
|
-{
|
|
- return 0;
|
|
-}
|
|
+int shard_releasedir(xlator_t *this, fd_t *fd) { return 0; }
|
|
|
|
struct xlator_fops fops = {
|
|
.lookup = shard_lookup,
|
|
--
|
|
1.8.3.1
|
|
|