From 43442dfe72dbdf4b89cb8b17bd3113ed11240cd0 Mon Sep 17 00:00:00 2001 From: Atin Mukherjee Date: Mon, 14 Apr 2014 17:39:43 +0530 Subject: doc : remove brick usage change This patch takes care of changing admin guide (admin_managing_volumes.md) for remove-brick usage change. 3.6 version onwards remove-brick requires an explicit option (start/force etc). Change-Id: If6c5b0bf2c30c2b9a8c7644d314e2593006818c2 BUG: 1086737 Signed-off-by: Atin Mukherjee Reviewed-on: http://review.gluster.org/7474 Reviewed-by: Lalatendu Mohanty Tested-by: Gluster Build System Reviewed-by: Vijay Bellur --- doc/admin-guide/en-US/markdown/admin_managing_volumes.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/doc/admin-guide/en-US/markdown/admin_managing_volumes.md b/doc/admin-guide/en-US/markdown/admin_managing_volumes.md index f59134b80..b456e27af 100644 --- a/doc/admin-guide/en-US/markdown/admin_managing_volumes.md +++ b/doc/admin-guide/en-US/markdown/admin_managing_volumes.md @@ -188,7 +188,7 @@ set). For example, to remove server2:/exp2: - # gluster volume remove-brick test-volume server2:/exp2 + # gluster volume remove-brick test-volume server2:/exp2 force Removing brick(s) can result in data loss. Do you want to Continue? (y/n) -- cgit From b6cc23204f1941184cb08ec3d84beecd2d06fd91 Mon Sep 17 00:00:00 2001 From: Atin Mukherjee Date: Wed, 9 Apr 2014 11:53:33 +0530 Subject: glusterfs-server : barrier timeout tuning fix Problem : Reconfiguration of barrier timeout through gluster volume set shows a success but it never changes the default timeout value which is 120 seconds. After digging into the code deeper, it was found that timeout is never modified in reconfigure() as the first check i.e. whether barrier is already enabled or disabled always fails since barrier option is not modified in this request. Fix : Introduced notify() in barrier translator which will take care of the rpc request to enable/disable barrier. reconfigure() will simply set barrier enable/disable and timeout options blindly without any validation. Please note this patch only contains the changes in barrier translator however from complete code flow perspective the caller in the glusterfsd mgmt should call notify instead of reconfigure to fix this problem. Change-Id: I1371b294935f6054da7c1dc6a9a19f1d861e60fb BUG: 1085671 Signed-off-by: Atin Mukherjee Reviewed-on: http://review.gluster.org/7428 Reviewed-by: Varun Shastry Reviewed-by: Krishnan Parthasarathi Tested-by: Gluster Build System Reviewed-by: Vijay Bellur --- xlators/features/barrier/src/barrier.c | 82 +++++++++++++++++++++++++++++----- 1 file changed, 70 insertions(+), 12 deletions(-) diff --git a/xlators/features/barrier/src/barrier.c b/xlators/features/barrier/src/barrier.c index e5465d1b4..9937698ed 100644 --- a/xlators/features/barrier/src/barrier.c +++ b/xlators/features/barrier/src/barrier.c @@ -333,6 +333,74 @@ out: return ret; } +int +notify (xlator_t *this, int event, void *data, ...) +{ + barrier_priv_t *priv = NULL; + dict_t *dict = NULL; + gf_boolean_t past = _gf_false; + int ret = -1; + gf_boolean_t barrier_enabled = _gf_false; + struct list_head queue = {0,}; + + priv = this->private; + GF_ASSERT (priv); + INIT_LIST_HEAD (&queue); + + switch (event) { + case GF_EVENT_TRANSLATOR_OP: + { + dict = data; + GF_OPTION_RECONF ("barrier", barrier_enabled, dict, + bool, out); + + LOCK (&priv->lock); + { + past = priv->barrier_enabled; + + switch (past) { + case _gf_false: + if (barrier_enabled) { + ret = __barrier_enable (this,priv); + if (ret) + goto unlock; + } else { + gf_log (this->name, GF_LOG_ERROR, + "Already disabled."); + goto unlock; + } + break; + + case _gf_true: + if (!barrier_enabled) { + __barrier_disable(this, &queue); + } else { + gf_log (this->name, GF_LOG_ERROR, + "Already enabled"); + goto unlock; + } + break; + } + ret = 0; + } +unlock: + UNLOCK (&priv->lock); + + if (!list_empty (&queue)) + barrier_dequeue_all (this, &queue); + // missing break is intentional + } + default: + { + default_notify (this, event, data); + ret = 0; + goto out; + } + } +out: + return ret; +} + int reconfigure (xlator_t *this, dict_t *options) { @@ -359,13 +427,9 @@ reconfigure (xlator_t *this, dict_t *options) case _gf_false: if (barrier_enabled) { ret = __barrier_enable (this, priv); - if (ret) + if (ret) { goto unlock; - - } else { - gf_log (this->name, GF_LOG_ERROR, - "Already disabled"); - goto unlock; + } } break; @@ -373,16 +437,10 @@ reconfigure (xlator_t *this, dict_t *options) if (!barrier_enabled) { __barrier_disable (this, &queue); - } else { - gf_log (this->name, GF_LOG_ERROR, - "Already enabled"); - goto unlock; } break; } - priv->timeout.tv_sec = timeout; - ret = 0; } unlock: -- cgit From 00e247ee44067f2b3e7ca5f7e6dc2f7934c97181 Mon Sep 17 00:00:00 2001 From: Santosh Kumar Pradhan Date: Wed, 9 Apr 2014 10:19:43 +0530 Subject: gNFS: Support wildcard in RPC auth allow/reject RFE: Support wildcard in "nfs.rpc-auth-allow" and "nfs.rpc-auth-reject". e.g. *.redhat.com 192.168.1[1-5].* 192.168.1[1-5].*, *.redhat.com, 192.168.21.9 Along with wildcard, support for subnetwork or IP range e.g. 192.168.10.23/24 The option will be validated for following categories: 1) Anonymous i.e. "*" 2) Wildcard pattern i.e. string containing any ('*', '?', '[') 3) IPv4 address 4) IPv6 address 5) FQDN 6) subnetwork or IPv4 range Currently this does not support IPv6 subnetwork. Change-Id: Iac8caf5e490c8174d61111dad47fd547d4f67bf4 BUG: 1086097 Signed-off-by: Santosh Kumar Pradhan Reviewed-on: http://review.gluster.org/7485 Reviewed-by: Poornima G Reviewed-by: Harshavardhana Tested-by: Gluster Build System Reviewed-by: Vijay Bellur --- libglusterfs/src/common-utils.c | 123 ++++++++++++++++++++++++++++++++++++++++ libglusterfs/src/common-utils.h | 5 +- libglusterfs/src/options.c | 40 +++++++++++++ libglusterfs/src/options.h | 1 + rpc/rpc-lib/src/rpcsvc.c | 91 ++++++++++++++++++++++++++++- tests/bugs/bug-822830.t | 24 +++++++- xlators/nfs/server/src/nfs.c | 8 +-- 7 files changed, 281 insertions(+), 11 deletions(-) diff --git a/libglusterfs/src/common-utils.c b/libglusterfs/src/common-utils.c index 80d9d2940..b7d06d925 100644 --- a/libglusterfs/src/common-utils.c +++ b/libglusterfs/src/common-utils.c @@ -1858,6 +1858,70 @@ out: return ret; } +/** + * valid_ipv4_subnetwork() takes the pattern and checks if it contains + * a valid ipv4 subnetwork pattern i.e. xx.xx.xx.xx/n. IPv4 address + * part (xx.xx.xx.xx) and mask bits lengh part (n). The mask bits lengh + * must be in 0-32 range (ipv4 addr is 32 bit). The pattern must be + * in this format. + * + * Returns _gf_true if both IP addr and mask bits len are valid + * _gf_false otherwise. + */ +gf_boolean_t +valid_ipv4_subnetwork (const char *address) +{ + char *slash = NULL; + char *paddr = NULL; + char *endptr = NULL; + long prefixlen = -1; + gf_boolean_t retv = _gf_true; + + if (address == NULL) { + gf_log_callingfn (THIS->name, GF_LOG_WARNING, + "argument invalid"); + return _gf_false; + } + + paddr = gf_strdup (address); + if (paddr == NULL) /* ENOMEM */ + return _gf_false; + + /* + * INVALID: If '/' is not present OR + * Nothing specified after '/' + */ + slash = strchr(paddr, '/'); + if ((slash == NULL) || (slash[1] == '\0')) { + gf_log_callingfn (THIS->name, GF_LOG_WARNING, + "Invalid IPv4 subnetwork format"); + retv = _gf_false; + goto out; + } + + *slash = '\0'; + retv = valid_ipv4_address (paddr, strlen(paddr), _gf_false); + if (retv == _gf_false) { + gf_log_callingfn (THIS->name, GF_LOG_WARNING, + "Invalid IPv4 subnetwork address"); + goto out; + } + + prefixlen = strtol (slash + 1, &endptr, 10); + if ((errno != 0) || (*endptr != '\0') || + (prefixlen < 0) || (prefixlen > 32)) { + gf_log_callingfn (THIS->name, GF_LOG_WARNING, + "Invalid IPv4 subnetwork mask"); + retv = _gf_false; + goto out; + } + + retv = _gf_true; +out: + GF_FREE (paddr); + return retv; +} + char valid_ipv6_address (char *address, int length, gf_boolean_t wildcard_acc) { @@ -1938,6 +2002,65 @@ out: return ret; } +/** + * valid_mount_auth_address - Validate the rpc-auth.addr.allow/reject pattern + * + * @param address - Pattern to be validated + * + * @return _gf_true if "address" is "*" (anonymous) 'OR' + * if "address" is valid FQDN or valid IPv4/6 address 'OR' + * if "address" contains wildcard chars e.g. "'*' or '?' or '['" + * if "address" is valid ipv4 subnet pattern (xx.xx.xx.xx/n) + * _gf_false otherwise + * + * + * NB: If the user/admin set for wildcard pattern, then it does not have + * to be validated. Make it similar to the way exportfs (kNFS) works. + */ +gf_boolean_t +valid_mount_auth_address (char *address) +{ + int length = 0; + char *cp = NULL; + + /* 1. Check for "NULL and empty string */ + if ((address == NULL) || (address[0] == '\0')){ + gf_log_callingfn (THIS->name, + GF_LOG_WARNING, "argument invalid"); + return _gf_false; + } + + /* 2. Check for Anonymous */ + if (strcmp(address, "*") == 0) + return _gf_true; + + for (cp = address; *cp; cp++) { + /* 3. Check for wildcard pattern */ + if (*cp == '*' || *cp == '?' || *cp == '[') { + return _gf_true; + } + + /* + * 4. check for IPv4 subnetwork i.e. xx.xx.xx.xx/n + * TODO: check for IPv6 subnetwork + * NB: Wildcard must not be mixed with subnetwork. + */ + if (*cp == '/') { + return valid_ipv4_subnetwork (address); + } + } + + /* 5. Check for v4/v6 IP addr and FQDN/hostname */ + length = strlen (address); + if ((valid_ipv4_address (address, length, _gf_false)) || + (valid_ipv6_address (address, length, _gf_false)) || + (valid_host_name (address, length))) { + return _gf_true; + } + + return _gf_false; +} + /** * gf_sock_union_equal_addr - check if two given gf_sock_unions have same addr * diff --git a/libglusterfs/src/common-utils.h b/libglusterfs/src/common-utils.h index e17029dba..3a58a9331 100644 --- a/libglusterfs/src/common-utils.h +++ b/libglusterfs/src/common-utils.h @@ -580,9 +580,8 @@ char valid_host_name (char *address, int length); char valid_ipv4_address (char *address, int length, gf_boolean_t wildcard_acc); char valid_ipv6_address (char *address, int length, gf_boolean_t wildcard_acc); char valid_internet_address (char *address, gf_boolean_t wildcard_acc); -char valid_ipv4_wildcard_check (char *address); -char valid_ipv6_wildcard_check (char *address); -char valid_wildcard_internet_address (char *address); +gf_boolean_t valid_mount_auth_address (char *address); +gf_boolean_t valid_ipv4_subnetwork (const char *address); gf_boolean_t gf_sock_union_equal_addr (union gf_sock_union *a, union gf_sock_union *b); diff --git a/libglusterfs/src/options.c b/libglusterfs/src/options.c index 31e5a681d..a0881b4ad 100644 --- a/libglusterfs/src/options.c +++ b/libglusterfs/src/options.c @@ -574,6 +574,45 @@ out: return ret; } +static int +xlator_option_validate_mntauth (xlator_t *xl, const char *key, + const char *value, volume_option_t *opt, + char **op_errstr) +{ + int ret = -1; + char *dup_val = NULL; + char *addr_tok = NULL; + char *save_ptr = NULL; + char errstr[4096] = {0,}; + + dup_val = gf_strdup (value); + if (!dup_val) + goto out; + + addr_tok = strtok_r (dup_val, ",", &save_ptr); + if (addr_tok == NULL) + goto out; + while (addr_tok) { + if (!valid_mount_auth_address (addr_tok)) + goto out; + + addr_tok = strtok_r (NULL, ",", &save_ptr); + } + ret = 0; + +out: + if (ret) { + snprintf (errstr, sizeof (errstr), "option %s %s: '%s' is not " + "a valid mount-auth-address", key, value, value); + gf_log (xl->name, GF_LOG_ERROR, "%s", errstr); + if (op_errstr) + *op_errstr = gf_strdup (errstr); + } + GF_FREE (dup_val); + + return ret; +} + /*XXX: the rules to validate are as per block-size required for stripe xlator */ static int gf_validate_size (const char *sizestr, volume_option_t *opt) @@ -744,6 +783,7 @@ xlator_option_validate (xlator_t *xl, char *key, char *value, xlator_option_validate_priority_list, [GF_OPTION_TYPE_SIZE_LIST] = xlator_option_validate_size_list, [GF_OPTION_TYPE_ANY] = xlator_option_validate_any, + [GF_OPTION_TYPE_CLIENT_AUTH_ADDR] = xlator_option_validate_mntauth, [GF_OPTION_TYPE_MAX] = NULL, }; diff --git a/libglusterfs/src/options.h b/libglusterfs/src/options.h index 62f4ee92e..134cc3602 100644 --- a/libglusterfs/src/options.h +++ b/libglusterfs/src/options.h @@ -38,6 +38,7 @@ typedef enum { GF_OPTION_TYPE_INTERNET_ADDRESS_LIST, GF_OPTION_TYPE_PRIORITY_LIST, GF_OPTION_TYPE_SIZE_LIST, + GF_OPTION_TYPE_CLIENT_AUTH_ADDR, GF_OPTION_TYPE_MAX, } volume_option_type_t; diff --git a/rpc/rpc-lib/src/rpcsvc.c b/rpc/rpc-lib/src/rpcsvc.c index 8be64c18a..34ee6f21b 100644 --- a/rpc/rpc-lib/src/rpcsvc.c +++ b/rpc/rpc-lib/src/rpcsvc.c @@ -59,6 +59,9 @@ int rpcsvc_notify (rpc_transport_t *trans, void *mydata, rpc_transport_event_t event, void *data, ...); +static int +match_subnet_v4 (const char *addrtok, const char *ipaddr); + rpcsvc_notify_wrapper_t * rpcsvc_notify_wrapper_alloc (void) { @@ -2181,6 +2184,13 @@ rpcsvc_transport_peer_check_search (dict_t *options, char *pattern, goto err; } + /* Compare IPv4 subnetwork */ + if (strchr (addrtok, '/')) { + ret = match_subnet_v4 (addrtok, ip); + if (ret == 0) + goto err; + } + addrtok = strtok_r (NULL, ",", &svptr); } @@ -2327,8 +2337,20 @@ rpcsvc_auth_check (rpcsvc_t *svc, char *volname, ret = dict_get_str (options, srchstr, &reject_str); GF_FREE (srchstr); - if (reject_str == NULL && !strcmp ("*", allow_str)) - return RPCSVC_AUTH_ACCEPT; + + /* + * If "reject_str" is being set as '*' (anonymous), then NFS-server + * would reject everything. If the "reject_str" is not set and + * "allow_str" is set as '*' (anonymous), then NFS-server would + * accept mount requests from all clients. + */ + if (reject_str != NULL) { + if (!strcmp ("*", reject_str)) + return RPCSVC_AUTH_REJECT; + } else { + if (!strcmp ("*", allow_str)) + return RPCSVC_AUTH_ACCEPT; + } /* Non-default rule, authenticate */ if (!get_host_name (client_ip, &ip)) @@ -2461,6 +2483,71 @@ out: return addrstr; } +/* + * match_subnet_v4() takes subnetwork address pattern and checks + * if the target IPv4 address has the same network address with + * the help of network mask. + * + * Returns 0 for SUCCESS and -1 otherwise. + * + * NB: Validation of subnetwork address pattern is not required + * as it's already being done at the time of CLI SET. + */ +static int +match_subnet_v4 (const char *addrtok, const char *ipaddr) +{ + char *slash = NULL; + char *netaddr = NULL; + long prefixlen = -1; + int ret = -1; + uint32_t shift = 0; + struct sockaddr_in sin1 = {0, }; + struct sockaddr_in sin2 = {0, }; + struct sockaddr_in mask = {0, }; + + /* Copy the input */ + netaddr = gf_strdup (addrtok); + if (netaddr == NULL) /* ENOMEM */ + goto out; + + /* Find the network socket addr of target */ + if (inet_pton (AF_INET, ipaddr, &sin1.sin_addr) == 0) + goto out; + + /* Find the network socket addr of subnet pattern */ + slash = strchr (netaddr, '/'); + *slash = '\0'; + if (inet_pton (AF_INET, netaddr, &sin2.sin_addr) == 0) + goto out; + + /* + * Find the network mask in network byte order. + * NB: 32 : Max len of IPv4 address. + */ + prefixlen = atoi (slash + 1); + shift = 32 - (uint32_t)prefixlen; + mask.sin_addr.s_addr = htonl ((uint32_t)~0 << shift); + + /* + * Check if both have same network address. + * Extract the network address from the IP addr by applying the + * network mask. If they match, return SUCCESS. i.e. + * + * (x == y) <=> (x ^ y == 0) + * (x & y) ^ (x & z) <=> x & (y ^ z) + * + * ((ip1 & mask) == (ip2 & mask)) <=> ((mask & (ip1 ^ ip2)) == 0) + */ + if (((mask.sin_addr.s_addr) & + (sin1.sin_addr.s_addr ^ sin2.sin_addr.s_addr)) != 0) + goto out; + + ret = 0; /* SUCCESS */ +out: + GF_FREE (netaddr); + return ret; +} + rpcsvc_actor_t gluster_dump_actors[] = { [GF_DUMP_NULL] = {"NULL", GF_DUMP_NULL, NULL, NULL, 0, DRC_NA}, diff --git a/tests/bugs/bug-822830.t b/tests/bugs/bug-822830.t index 000d99f03..b7a5704cd 100755 --- a/tests/bugs/bug-822830.t +++ b/tests/bugs/bug-822830.t @@ -18,18 +18,38 @@ EXPECT 'Created' volinfo_field $V0 'Status'; TEST $CLI volume start $V0; EXPECT 'Started' volinfo_field $V0 'Status'; -## Setting nfs.rpc-auth-reject as 192.*..* -TEST ! $CLI volume set $V0 nfs.rpc-auth-reject 192.*..* +## Setting nfs.rpc-auth-reject as 192.{}.1.2 +TEST ! $CLI volume set $V0 nfs.rpc-auth-reject 192.{}.1.2 EXPECT '' volinfo_field $V0 'nfs.rpc-auth-reject'; # Setting nfs.rpc-auth-allow as a.a. TEST ! $CLI volume set $V0 nfs.rpc-auth-allow a.a. EXPECT '' volinfo_field $V0 'nfs.rpc-auth-allow'; +## Setting nfs.rpc-auth-reject as 192.*..* +TEST $CLI volume set $V0 nfs.rpc-auth-reject 192.*..* +EXPECT '192.*..*' volinfo_field $V0 'nfs.rpc-auth-reject'; + # Setting nfs.rpc-auth-allow as a.a TEST $CLI volume set $V0 nfs.rpc-auth-allow a.a EXPECT 'a.a' volinfo_field $V0 'nfs.rpc-auth-allow'; +# Setting nfs.rpc-auth-allow as *.redhat.com +TEST $CLI volume set $V0 nfs.rpc-auth-allow *.redhat.com +EXPECT '\*.redhat.com' volinfo_field $V0 'nfs.rpc-auth-allow'; + +# Setting nfs.rpc-auth-allow as 192.168.10.[1-5] +TEST $CLI volume set $V0 nfs.rpc-auth-allow 192.168.10.[1-5] +EXPECT '192.168.10.\[1-5]' volinfo_field $V0 'nfs.rpc-auth-allow'; + +# Setting nfs.rpc-auth-allow as 192.168.70.? +TEST $CLI volume set $V0 nfs.rpc-auth-allow 192.168.70.? +EXPECT '192.168.70.?' volinfo_field $V0 'nfs.rpc-auth-allow'; + +# Setting nfs.rpc-auth-reject as 192.168.10.5/16 +TEST $CLI volume set $V0 nfs.rpc-auth-reject 192.168.10.5/16 +EXPECT '192.168.10.5/16' volinfo_field $V0 'nfs.rpc-auth-reject'; + ## Setting nfs.rpc-auth-reject as 192.*.* TEST $CLI volume set $V0 nfs.rpc-auth-reject 192.*.* EXPECT '192.*.*' volinfo_field $V0 'nfs.rpc-auth-reject'; diff --git a/xlators/nfs/server/src/nfs.c b/xlators/nfs/server/src/nfs.c index 04cf030dc..d962663ba 100644 --- a/xlators/nfs/server/src/nfs.c +++ b/xlators/nfs/server/src/nfs.c @@ -1665,7 +1665,7 @@ struct volume_options options[] = { "unrecognized option warnings." }, { .key = {"rpc-auth.addr.allow"}, - .type = GF_OPTION_TYPE_INTERNET_ADDRESS_LIST, + .type = GF_OPTION_TYPE_CLIENT_AUTH_ADDR, .default_value = "all", .description = "Allow a comma separated list of addresses and/or" " hostnames to connect to the server. By default, all" @@ -1673,7 +1673,7 @@ struct volume_options options[] = { "define a general rule for all exported volumes." }, { .key = {"rpc-auth.addr.reject"}, - .type = GF_OPTION_TYPE_INTERNET_ADDRESS_LIST, + .type = GF_OPTION_TYPE_CLIENT_AUTH_ADDR, .default_value = "none", .description = "Reject a comma separated list of addresses and/or" " hostnames from connecting to the server. By default," @@ -1681,7 +1681,7 @@ struct volume_options options[] = { "define a general rule for all exported volumes." }, { .key = {"rpc-auth.addr.*.allow"}, - .type = GF_OPTION_TYPE_INTERNET_ADDRESS_LIST, + .type = GF_OPTION_TYPE_CLIENT_AUTH_ADDR, .default_value = "all", .description = "Allow a comma separated list of addresses and/or" " hostnames to connect to the server. By default, all" @@ -1689,7 +1689,7 @@ struct volume_options options[] = { "define a rule for a specific exported volume." }, { .key = {"rpc-auth.addr.*.reject"}, - .type = GF_OPTION_TYPE_INTERNET_ADDRESS_LIST, + .type = GF_OPTION_TYPE_CLIENT_AUTH_ADDR, .default_value = "none", .description = "Reject a comma separated list of addresses and/or" " hostnames from connecting to the server. By default," -- cgit From 9c13471b109587a639662fc690384285bee02bc6 Mon Sep 17 00:00:00 2001 From: Jeff Darcy Date: Wed, 23 Apr 2014 15:53:41 +0000 Subject: tests: print info about failed tests It's a bit frustrating to run a test normally (e.g. during development), see a failure, and then have to re-run it with DEBUG=1 to see what actually failed. This tiny patch prints out the command line of the test that just failed, even if DEBUG=0 (in fact only if DEBUG=0 since otherwise it would be redundant). Change-Id: Icffa096d0bcc6f35176f0e47d9d1bc538698ca2c Signed-off-by: Jeff Darcy Reviewed-on: http://review.gluster.org/7537 Tested-by: Gluster Build System Reviewed-by: Anand Avati --- tests/include.rc | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/tests/include.rc b/tests/include.rc index 452e6d7ca..35b0ddd5d 100644 --- a/tests/include.rc +++ b/tests/include.rc @@ -40,6 +40,7 @@ function test_header() { dbg "========================="; dbg "TEST $t (line $TESTLINE): $*"; + saved_cmd="$*" } @@ -52,6 +53,10 @@ function test_footer() echo "ok $t"; else echo "not ok $t $err"; + # With DEBUG, this was already printed out, so skip it. + if [ x"$DEBUG" = x"0" ]; then + echo "FAILED COMMAND: $saved_cmd" + fi if [ "$EXIT_EARLY" = "1" ]; then exit $RET fi -- cgit From a3cb38e3edf005bef73da4c9cfd958474a14d50f Mon Sep 17 00:00:00 2001 From: Harshavardhana Date: Thu, 17 Apr 2014 15:54:34 -0700 Subject: build: MacOSX Porting fixes git@forge.gluster.org:~schafdog/glusterfs-core/osx-glusterfs Working functionality on MacOSX - GlusterD (management daemon) - GlusterCLI (management cli) - GlusterFS FUSE (using OSXFUSE) - GlusterNFS (without NLM - issues with rpc.statd) Change-Id: I20193d3f8904388e47344e523b3787dbeab044ac BUG: 1089172 Signed-off-by: Harshavardhana Signed-off-by: Dennis Schafroth Tested-by: Harshavardhana Tested-by: Dennis Schafroth Reviewed-on: http://review.gluster.org/7503 Tested-by: Gluster Build System Reviewed-by: Anand Avati --- .gitignore | 14 +- api/src/glfs-mgmt.c | 1 + cli/src/Makefile.am | 2 +- cli/src/cli-cmd-parser.c | 6 +- cli/src/cli-cmd-volume.c | 4 +- cli/src/cli-rpc-ops.c | 10 +- cli/src/cli-xml-output.c | 2 +- cli/src/cli.c | 2 +- configure.ac | 138 +++-- contrib/argp-standalone/configure.ac | 11 +- contrib/fuse-include/fuse_kernel_macfuse.h | 9 + contrib/fuse-lib/mount-gluster-compat.h | 12 +- contrib/fuse-util/Makefile.am | 2 +- contrib/fuse-util/fusermount.c | 24 +- contrib/macfuse/fuse_param.h | 97 ++-- contrib/macfuse/mount_darwin.c | 27 +- contrib/mount/mntent.c | 163 ++++++ contrib/mount/mntent_compat.h | 35 ++ contrib/qemu/include/qemu/bswap.h | 7 + contrib/qemu/util/cutils.c | 2 +- contrib/sunrpc/xdr_sizeof.c | 204 +++++++ contrib/uuid/gen_uuid.c | 17 +- contrib/uuid/uuid_time.c | 4 +- extras/geo-rep/Makefile.am | 1 + gen-headers.py | 5 + gf-error-codes.h.template | 3 +- glusterfsd/src/Makefile.am | 2 +- glusterfsd/src/glusterfsd.c | 2 +- libglusterfs/src/Makefile.am | 7 +- libglusterfs/src/client_t.c | 2 +- libglusterfs/src/common-utils.c | 42 +- libglusterfs/src/common-utils.h | 9 +- libglusterfs/src/compat.h | 53 +- libglusterfs/src/dict.c | 6 +- libglusterfs/src/fd.c | 2 +- libglusterfs/src/glusterfs.h | 2 +- libglusterfs/src/logging.c | 20 +- libglusterfs/src/logging.h | 12 +- libglusterfs/src/lvm-defaults.h | 25 + libglusterfs/src/options.c | 38 +- libglusterfs/src/options.h | 12 +- libglusterfs/src/syscall.c | 99 +++- libglusterfs/src/syscall.h | 53 +- libglusterfs/src/timespec.c | 41 +- libglusterfs/src/timespec.h | 2 +- rpc/rpc-lib/src/Makefile.am | 4 +- rpc/rpc-lib/src/rpc-clnt.c | 7 +- rpc/rpc-lib/src/rpc-drc.c | 2 +- rpc/rpc-lib/src/rpcsvc.c | 39 +- rpc/rpc-lib/src/xdr-common.h | 6 +- rpc/rpc-lib/src/xdr-rpc.h | 17 + rpc/rpc-transport/rdma/src/Makefile.am | 4 +- rpc/rpc-transport/rdma/src/rdma.c | 6 +- rpc/rpc-transport/socket/src/socket.c | 4 +- rpc/xdr/src/nlm4-xdr.h | 16 +- rpc/xdr/src/xdr-generic.c | 6 +- rpc/xdr/src/xdr-nfs3.h | 1 + tests/basic/pgfid-feat.t | 3 +- tests/basic/volume-snapshot.t | 3 +- tests/bugs/bug-1045333.t | 1 + tests/bugs/bug-1049834.t | 2 +- tests/snapshot.rc | 8 +- xlators/cluster/afr/src/afr-inode-write.c | 3 - xlators/cluster/afr/src/afr-self-heal-entry.c | 4 +- xlators/cluster/afr/src/afr-self-heal-metadata.c | 1 - xlators/cluster/afr/src/afr.c | 6 +- xlators/cluster/dht/src/Makefile.am | 1 - xlators/cluster/dht/src/dht-common.h | 4 +- xlators/cluster/dht/src/dht-shared.c | 5 +- xlators/cluster/stripe/src/Makefile.am | 1 - xlators/cluster/stripe/src/stripe-helpers.c | 10 +- xlators/cluster/stripe/src/stripe.c | 10 +- xlators/debug/io-stats/src/io-stats.c | 2 +- xlators/debug/trace/src/trace.c | 38 ++ xlators/debug/trace/src/trace.h | 37 -- xlators/encryption/crypt/src/crypt.c | 8 +- xlators/encryption/crypt/src/crypt.h | 15 +- xlators/features/changelog/src/Makefile.am | 2 +- xlators/features/changelog/src/changelog-helpers.h | 14 +- xlators/features/compress/src/Makefile.am | 2 +- xlators/features/index/src/index.c | 4 +- xlators/features/locks/src/inodelk.c | 2 +- xlators/features/locks/src/posix.c | 11 +- xlators/features/mac-compat/src/Makefile.am | 5 +- xlators/features/mac-compat/src/mac-compat.c | 246 ++++++--- xlators/features/mac-compat/src/mac-compat.h | 41 ++ xlators/features/marker/src/marker-quota-helper.h | 2 +- xlators/features/marker/src/marker-quota.c | 6 +- xlators/features/marker/src/marker.c | 32 +- xlators/features/quota/src/quota.c | 8 +- xlators/features/quota/src/quotad-aggregator.c | 2 +- xlators/mgmt/glusterd/src/Makefile.am | 2 +- xlators/mgmt/glusterd/src/glusterd-hooks.c | 2 +- xlators/mgmt/glusterd/src/glusterd-op-sm.c | 7 +- xlators/mgmt/glusterd/src/glusterd-quota.c | 6 +- xlators/mgmt/glusterd/src/glusterd-snapshot.c | 92 ++-- xlators/mgmt/glusterd/src/glusterd-store.c | 4 +- xlators/mgmt/glusterd/src/glusterd-utils.c | 31 +- xlators/mgmt/glusterd/src/glusterd-utils.h | 8 +- xlators/mgmt/glusterd/src/glusterd-volgen.c | 20 +- xlators/mgmt/glusterd/src/glusterd-volume-ops.c | 2 +- xlators/mgmt/glusterd/src/glusterd-volume-set.c | 24 +- xlators/mgmt/glusterd/src/glusterd.c | 9 +- xlators/mount/fuse/src/fuse-bridge.c | 108 ++-- xlators/mount/fuse/src/fuse-helpers.c | 2 +- xlators/mount/fuse/utils/mount_glusterfs.in | 600 ++++++++++++++++----- xlators/nfs/server/src/nfs-fops.c | 11 +- xlators/nfs/server/src/nfs.c | 70 ++- xlators/nfs/server/src/nfs.h | 2 + xlators/nfs/server/src/nfs3-helpers.c | 4 +- xlators/nfs/server/src/nfs3.c | 6 +- xlators/nfs/server/src/nlm4.c | 38 +- xlators/nfs/server/src/nlm4.h | 9 + xlators/performance/io-cache/src/io-cache.c | 21 +- xlators/performance/quick-read/src/quick-read.c | 6 +- xlators/performance/read-ahead/src/read-ahead.c | 5 +- .../performance/readdir-ahead/src/readdir-ahead.c | 8 +- .../performance/write-behind/src/write-behind.c | 4 +- xlators/protocol/client/src/client.c | 3 +- xlators/protocol/server/src/server-handshake.c | 2 +- xlators/protocol/server/src/server-helpers.c | 3 +- xlators/protocol/server/src/server-rpc-fops.c | 4 +- xlators/protocol/server/src/server.c | 2 +- xlators/storage/bd/src/bd-helper.c | 2 +- xlators/storage/bd/src/bd.c | 9 +- xlators/storage/bd/src/bd.h | 6 +- xlators/storage/posix/src/posix-helpers.c | 39 +- xlators/storage/posix/src/posix.c | 182 ++++++- xlators/storage/posix/src/posix.h | 10 + 129 files changed, 2444 insertions(+), 801 deletions(-) create mode 100644 contrib/mount/mntent.c create mode 100644 contrib/mount/mntent_compat.h create mode 100644 contrib/sunrpc/xdr_sizeof.c create mode 100644 libglusterfs/src/lvm-defaults.h create mode 100644 xlators/features/mac-compat/src/mac-compat.h diff --git a/.gitignore b/.gitignore index adedb3585..7e8e11c70 100644 --- a/.gitignore +++ b/.gitignore @@ -8,7 +8,7 @@ install-sh ltmain.sh Makefile.in missing -py-compile +*compile *.gcda *.gcno *.sw? @@ -24,6 +24,9 @@ py-compile .deps Makefile stamp-h1 +# Softlinks to test and log +log +*.vol # Generated files api/examples/__init__.py @@ -39,11 +42,14 @@ extras/systemd/glusterd.service extras/ocf/glusterd extras/ocf/volume extras/who-wrote-glusterfs/gitdm +extras/geo-rep/gsync-sync-gfid glusterfs-api.pc glusterfs.spec glusterfsd/src/glusterfsd +glusterfsd/src/glusterd +glusterfsd/src/glusterfs libgfchangelog.pc -libglusterfs/src/spec.lex.c +libglusterfs/src/graph.lex.c libglusterfs/src/y.tab.c libglusterfs/src/y.tab.h libglusterfs/src/gf-error-codes.h @@ -54,3 +60,7 @@ xlators/mount/fuse/utils/mount_glusterfs xlators/features/glupy/src/setup.py geo-replication/src/peer_add_secret_pub geo-replication/src/peer_gsec_create +geo-replication/src/gsyncd +cli/src/gluster +contrib/fuse-util/fusermount-glusterfs +geo-replication/src/gsyncd diff --git a/api/src/glfs-mgmt.c b/api/src/glfs-mgmt.c index e2a52c324..5c7e8b2fc 100644 --- a/api/src/glfs-mgmt.c +++ b/api/src/glfs-mgmt.c @@ -31,6 +31,7 @@ #include "protocol-common.h" #include "glusterfs3.h" #include "portmap-xdr.h" +#include "xdr-common.h" #include "xdr-generic.h" #include "syncop.h" diff --git a/cli/src/Makefile.am b/cli/src/Makefile.am index 4f8f23935..923600fbd 100644 --- a/cli/src/Makefile.am +++ b/cli/src/Makefile.am @@ -21,7 +21,7 @@ AM_CPPFLAGS = $(GF_CPPFLAGS) \ -DSYNCDAEMON_COMPILE=$(SYNCDAEMON_COMPILE) -DSBIN_DIR=\"$(sbindir)\"\ $(XML_CPPFLAGS) -AM_CFLAGS = -Wall $(GF_GLUSTERFS_CFLAGS) +AM_CFLAGS = -Wall $(GF_CFLAGS) CLEANFILES = diff --git a/cli/src/cli-cmd-parser.c b/cli/src/cli-cmd-parser.c index 9714449c1..36f710f03 100644 --- a/cli/src/cli-cmd-parser.c +++ b/cli/src/cli-cmd-parser.c @@ -620,7 +620,7 @@ cli_cmd_quota_parse (const char **words, int wordcount, dict_t **options) goto out; } - ret = gf_string2bytesize (words[5], &value); + ret = gf_string2bytesize_uint64 (words[5], &value); if (ret != 0) { if (errno == ERANGE) cli_err ("Value too large: %s", words[5]); @@ -1750,7 +1750,7 @@ config_parse (const char **words, int wordcount, dict_t *dict, ret = -1; goto out; } - snprintf (append_str, 300, "now:%ld.%06ld", + snprintf (append_str, 300, "now:%" GF_PRI_SECOND ".%06"GF_PRI_SUSECONDS, tv.tv_sec, tv.tv_usec); } @@ -3025,7 +3025,7 @@ cli_snap_create_parse (dict_t *dict, const char **words, int wordcount) { && (strcmp (words[i], "force") != 0); i++) { volcount++; /* volume index starts from 1 */ - ret = snprintf (key, sizeof (key), "volname%ld", volcount); + ret = snprintf (key, sizeof (key), "volname%"PRIu64, volcount); if (ret < 0) { goto out; } diff --git a/cli/src/cli-cmd-volume.c b/cli/src/cli-cmd-volume.c index 3b927d2bd..53c94c687 100644 --- a/cli/src/cli-cmd-volume.c +++ b/cli/src/cli-cmd-volume.c @@ -2008,14 +2008,14 @@ cli_print_detailed_status (cli_volume_status_t *status) if (status->total_inodes) { - cli_out ("%-20s : %-20ld", "Inode Count", + cli_out ("%-20s : %-20"GF_PRI_INODE, "Inode Count", status->total_inodes); } else { cli_out ("%-20s : %-20s", "Inode Count", "N/A"); } if (status->free_inodes) { - cli_out ("%-20s : %-20ld", "Free Inodes", + cli_out ("%-20s : %-20"GF_PRI_INODE, "Free Inodes", status->free_inodes); } else { cli_out ("%-20s : %-20s", "Free Inodes", "N/A"); diff --git a/cli/src/cli-rpc-ops.c b/cli/src/cli-rpc-ops.c index ebabf6b3d..8481d468c 100644 --- a/cli/src/cli-rpc-ops.c +++ b/cli/src/cli-rpc-ops.c @@ -5211,7 +5211,7 @@ gf_cli_top_volume_cbk (struct rpc_req *req, struct iovec *iov, gf_time_fmt (timestr, sizeof timestr, time_sec, gf_timefmt_FT); snprintf (timestr + strlen (timestr), sizeof timestr - strlen (timestr), - ".%"GF_PRI_SUSECONDS, time_usec); + ".%ld", time_usec); if (strlen (filename) < VOL_TOP_PERF_FILENAME_DEF_WIDTH) cli_out ("%*"PRIu64" %-*s %-*s", VOL_TOP_PERF_SPEED_WIDTH, @@ -7766,7 +7766,7 @@ cli_snapshot_config_display (dict_t *dict, gf_cli_rsp *rsp) } for (i = 0; i < voldisplaycount; i++) { - snprintf (buf, sizeof(buf), "volume%ld-volname", i); + snprintf (buf, sizeof(buf), "volume%"PRIu64"-volname", i); ret = dict_get_str (dict, buf, &volname); if (ret) { gf_log ("cli", GF_LOG_ERROR, "Could not fetch " @@ -7777,7 +7777,7 @@ cli_snapshot_config_display (dict_t *dict, gf_cli_rsp *rsp) cli_out ("\nVolume : %s", volname); snprintf (buf, sizeof(buf), - "volume%ld-snap-max-hard-limit", i); + "volume%"PRIu64"-snap-max-hard-limit", i); ret = dict_get_uint64 (dict, buf, &value); if (ret) { gf_log ("cli", GF_LOG_ERROR, "Could not fetch " @@ -7788,7 +7788,7 @@ cli_snapshot_config_display (dict_t *dict, gf_cli_rsp *rsp) cli_out ("snap-max-hard-limit : %"PRIu64, value); snprintf (buf, sizeof(buf), - "volume%ld-active-hard-limit", i); + "volume%"PRIu64"-active-hard-limit", i); ret = dict_get_uint64 (dict, buf, &value); if (ret) { gf_log ("cli", GF_LOG_ERROR, "Could not fetch" @@ -7801,7 +7801,7 @@ cli_snapshot_config_display (dict_t *dict, gf_cli_rsp *rsp) value); snprintf (buf, sizeof(buf), - "volume%ld-snap-max-soft-limit", i); + "volume%"PRIu64"-snap-max-soft-limit", i); ret = dict_get_uint64 (dict, buf, &value); if (ret) { gf_log ("cli", GF_LOG_ERROR, "Could not fetch " diff --git a/cli/src/cli-xml-output.c b/cli/src/cli-xml-output.c index 863e8a4a6..0eb23bff2 100644 --- a/cli/src/cli-xml-output.c +++ b/cli/src/cli-xml-output.c @@ -2299,7 +2299,7 @@ cli_xml_output_vol_profile (dict_t *dict, int op_ret, int op_errno, goto out; ret = xmlTextWriterWriteFormatElement - (writer, (xmlChar *)"clearStats", "%s", + (writer, (xmlChar *)"clearStats", "%s", stats_cleared ? "Cleared stats." : "Failed to clear stats."); if (ret) diff --git a/cli/src/cli.c b/cli/src/cli.c index 2c703689b..745b0b45b 100644 --- a/cli/src/cli.c +++ b/cli/src/cli.c @@ -179,7 +179,7 @@ logging_init (glusterfs_ctx_t *ctx, struct cli_state *state) /* CLI should not have something to DEBUG after the release, hence defaulting to INFO loglevel */ - gf_log_set_loglevel ((state->log_level == -1) ? GF_LOG_INFO : + gf_log_set_loglevel ((state->log_level == GF_LOG_NONE) ? GF_LOG_INFO : state->log_level); return 0; diff --git a/configure.ac b/configure.ac index 65e8cb753..9cc45a41e 100644 --- a/configure.ac +++ b/configure.ac @@ -14,6 +14,9 @@ AC_SUBST([PACKAGE_RELEASE], [m4_esyscmd([build-aux/pkg-version --release])]) AM_INIT_AUTOMAKE +# Removes warnings when using automake 1.14 around (...but option 'subdir-objects' is disabled ) +#but libglusterfs fails to build with contrib (Then are not set up that way?) +#AM_INIT_AUTOMAKE([subdir-objects]) m4_ifdef([AM_SILENT_RULES], [AM_SILENT_RULES(yes)]) @@ -104,10 +107,10 @@ AC_CONFIG_FILES([Makefile xlators/protocol/server/Makefile xlators/protocol/server/src/Makefile xlators/features/Makefile - xlators/features/changelog/Makefile - xlators/features/changelog/src/Makefile - xlators/features/changelog/lib/Makefile - xlators/features/changelog/lib/src/Makefile + xlators/features/changelog/Makefile + xlators/features/changelog/src/Makefile + xlators/features/changelog/lib/Makefile + xlators/features/changelog/lib/src/Makefile xlators/features/glupy/Makefile xlators/features/glupy/examples/Makefile xlators/features/glupy/src/Makefile @@ -142,8 +145,8 @@ AC_CONFIG_FILES([Makefile xlators/encryption/rot-13/src/Makefile xlators/encryption/crypt/Makefile xlators/encryption/crypt/src/Makefile - xlators/features/qemu-block/Makefile - xlators/features/qemu-block/src/Makefile + xlators/features/qemu-block/Makefile + xlators/features/qemu-block/src/Makefile xlators/system/Makefile xlators/system/posix-acl/Makefile xlators/system/posix-acl/src/Makefile @@ -189,9 +192,9 @@ AC_CONFIG_FILES([Makefile api/examples/Makefile api/examples/__init__.py api/examples/setup.py - geo-replication/Makefile - geo-replication/src/Makefile - geo-replication/syncdaemon/Makefile + geo-replication/Makefile + geo-replication/src/Makefile + geo-replication/syncdaemon/Makefile glusterfs.spec]) AC_CANONICAL_HOST @@ -286,20 +289,24 @@ AC_CHECK_LIB([pthread], [pthread_mutex_init], , AC_MSG_ERROR([Posix threads libr AC_CHECK_FUNC([dlopen], [has_dlopen=yes], AC_CHECK_LIB([dl], [dlopen], , AC_MSG_ERROR([Dynamic linking library required to build glusterfs]))) -AC_CHECK_FUNC([gettext], [has_gettext=yes], AC_CHECK_LIB([intl], [gettext], , AC_MSG_ERROR([gettext support is required to build glusterfs]))) +AC_CHECK_LIB([readline], [rl_do_undo], [RL_UNDO="yes"], [RL_UNDO="no"]) AC_CHECK_HEADERS([sys/xattr.h]) +AC_CHECK_HEADERS([sys/ioctl.h], AC_DEFINE(HAVE_IOCTL_IN_SYS_IOCTL_H, 1, [have sys/ioctl.h])) + AC_CHECK_HEADERS([sys/extattr.h]) AC_CHECK_HEADERS([openssl/md5.h]) AC_CHECK_HEADERS([linux/falloc.h]) +AC_CHECK_HEADERS([libintl.h]) + case $host_os in darwin*) - if ! test "`/usr/bin/sw_vers | grep ProductVersion: | cut -f 2 | cut -d. -f2`" -ge 5; then - AC_MSG_ERROR([You need at least OS X 10.5 (Leopard) to build Glusterfs]) + if ! test "`/usr/bin/sw_vers | grep ProductVersion: | cut -f 2 | cut -d. -f2`" -ge 7; then + AC_MSG_ERROR([You need at least OS X 10.7 (Lion) to build Glusterfs]) fi ;; esac @@ -326,6 +333,12 @@ if test "x${have_setfsuid}" = "xyes" -a "x${have_setfsgid}" = "xyes"; then AC_DEFINE(HAVE_SET_FSID, 1, [define if found setfsuid setfsgid]) fi +dnl test umount2 function +AC_CHECK_FUNC([umount2], [have_umount2=yes]) + +if test "x${have_umount2}" = "xyes"; then + AC_DEFINE(HAVE_UMOUNT2, 1, [define if found umount2]) +fi # FUSE section AC_ARG_ENABLE([fuse-client], @@ -383,8 +396,7 @@ AC_ARG_ENABLE([crypt-xlator], AC_HELP_STRING([--enable-crypt-xlator], [Build crypt encryption xlator])) if test "x$enable_crypt_xlator" = "xyes" -a "x$have_cmac_h" = "xno"; then - echo "Encryption xlator requires OpenSSL with cmac.h" - exit 1 + AC_MSG_ERROR([Encryption xlator requires OpenSSL with cmac.h]) fi BUILD_CRYPT_XLATOR=no @@ -439,7 +451,6 @@ if test "x${enable_qemu_block}" != "xno" -a "x${HAVE_GLIB_2}" = "xyes"; then Block translator enabled]) fi -AM_CONDITIONAL([ENABLE_QEMU_BLOCK], [test x$BUILD_QEMU_BLOCK = xyes]) # end QEMU_BLOCK section @@ -669,7 +680,7 @@ if test "x${have_llistxattr}" = "xyes"; then AC_DEFINE(HAVE_LLISTXATTR, 1, [define if llistxattr exists]) fi -AC_CHECK_FUNC([fdatasync], [have_fdatasync=yes]) +AC_CHECK_FUNC([fdatasync], [have_fdatasync=no]) if test "x${have_fdatasync}" = "xyes"; then AC_DEFINE(HAVE_FDATASYNC, 1, [define if fdatasync exists]) fi @@ -707,35 +718,52 @@ AC_SUBST(GF_DISTRIBUTION) GF_HOST_OS="" GF_LDFLAGS="-rdynamic" -# check for gcc -Werror=format-security -saved_CFLAGS=$CFLAGS -CFLAGS="-Wformat -Werror=format-security" +dnl check for gcc -Werror=format-security +saved_GF_CFLAGS="-Wformat -Werror=format-security" AC_MSG_CHECKING([whether $CC accepts -Werror=format-security]) AC_COMPILE_IFELSE([AC_LANG_PROGRAM()], [cc_werror_format_security=yes], [cc_werror_format_security=no]) echo $cc_werror_format_security if test "x$cc_werror_format_security" = "xno"; then - CFLAGS="$saved_CFLAGS" + GF_CFLAGS="$GF_CFLAGS" else - CFLAGS="$saved_CFLAGS $CFLAGS" + GF_CFLAGS="$saved_GF_CFLAGS $GF_CFLAGS" fi -# check for gcc -Werror=implicit-function-declaration -saved_CFLAGS=$CFLAGS -CFLAGS="-Werror=implicit-function-declaration" +dnl check for gcc -Werror=implicit-function-declaration +saved_GF_CFLAGS=$GF_CFLAGS +GF_CFLAGS="-Werror=implicit-function-declaration" AC_MSG_CHECKING([whether $CC accepts -Werror=implicit-function-declaration]) AC_COMPILE_IFELSE([AC_LANG_PROGRAM()], [cc_werror_implicit=yes], [cc_werror_implicit=no]) echo $cc_werror_implicit if test "x$cc_werror_implicit" = "xno"; then - CFLAGS="$saved_CFLAGS" + GF_CFLAGS="$saved_GF_CFLAGS" else - CFLAGS="$saved_CFLAGS $CFLAGS" + GF_CFLAGS="$saved_GF_CFLAGS $GF_CFLAGS" fi +dnl clang is mostly GCC-compatible, but its version is much lower, +dnl so we have to check for it. +AC_MSG_CHECKING([if compiling with clang]) + +AC_COMPILE_IFELSE( +[AC_LANG_PROGRAM([], [[ +#ifndef __clang__ + not clang +#endif +]])], +[CLANG=yes], [CLANG=no]) + +AC_MSG_RESULT([$CLANG]) + +if test "x$CLANG" = "xyes"; then + GF_COMPILER_FLAGS="-Wno-gnu -Wno-unknown-pragmas -Wno-deprecated-declarations -Wno-enum-conversion" +fi + + case $host_os in linux*) GF_HOST_OS="GF_LINUX_HOST_OS" GF_CFLAGS="${ARGP_STANDALONE_CPPFLAGS}" - GF_GLUSTERFS_CFLAGS="${GF_CFLAGS}" GF_LDADD="${ARGP_STANDALONE_LDADD}" GF_FUSE_CFLAGS="-DFUSERMOUNT_DIR=\\\"\$(bindir)\\\"" ;; @@ -743,7 +771,6 @@ case $host_os in GF_HOST_OS="GF_SOLARIS_HOST_OS" GF_CFLAGS="${ARGP_STANDALONE_CPPFLAGS} -D_REENTRANT -D_POSIX_PTHREAD_SEMANTICS -m64" GF_LDFLAGS="" - GF_GLUSTERFS_CFLAGS="${GF_CFLAGS}" GF_LDADD="${ARGP_STANDALONE_LDADD}" GF_GLUSTERFS_LIBS="-lnsl -lresolv -lsocket" BUILD_FUSE_CLIENT=no @@ -754,7 +781,6 @@ case $host_os in GF_CFLAGS="${ARGP_STANDALONE_CPPFLAGS} -D_INCOMPLETE_XOPEN_C063" GF_CFLAGS="${GF_CFLAGS} -DTHREAD_UNSAFE_BASENAME" GF_CFLAGS="${GF_CFLAGS} -DTHREAD_UNSAFE_DIRNAME" - GF_GLUSTERFS_CFLAGS="${GF_CFLAGS}" GF_LDADD="${ARGP_STANDALONE_LDADD}" if test "x$ac_cv_header_execinfo_h" = "xyes"; then GF_GLUSTERFS_LIBS="-lexecinfo" @@ -768,7 +794,6 @@ case $host_os in GF_CFLAGS="${ARGP_STANDALONE_CPPFLAGS}" GF_CFLAGS="${GF_CFLAGS} -DTHREAD_UNSAFE_BASENAME" GF_CFLAGS="${GF_CFLAGS} -DTHREAD_UNSAFE_DIRNAME" - GF_GLUSTERFS_CFLAGS="${GF_CFLAGS}" GF_LDADD="${ARGP_STANDALONE_LDADD}" if test "x$ac_cv_header_execinfo_h" = "xyes"; then GF_GLUSTERFS_LIBS="-lexecinfo" @@ -778,24 +803,32 @@ case $host_os in darwin*) GF_HOST_OS="GF_DARWIN_HOST_OS" LIBTOOL=glibtool - GF_CFLAGS="${ARGP_STANDALONE_CPPFLAGS} -D__DARWIN_64_BIT_INO_T -bundle -undefined suppress -flat_namespace -D_XOPEN_SOURCE" + GF_CFLAGS="${GF_COMPILER_FLAGS} ${ARGP_STANDALONE_CPPFLAGS} -D__DARWIN_64_BIT_INO_T -D_XOPEN_SOURCE " GF_CFLAGS="${GF_CFLAGS} -DTHREAD_UNSAFE_BASENAME" GF_CFLAGS="${GF_CFLAGS} -DTHREAD_UNSAFE_DIRNAME" - GF_GLUSTERFS_CFLAGS="${ARGP_STANDALONE_CPPFLAGS} -D__DARWIN_64_BIT_INO_T -undefined suppress -flat_namespace" GF_LDADD="${ARGP_STANDALONE_LDADD}" + GF_LDFLAGS="" GF_FUSE_CFLAGS="-I\$(CONTRIBDIR)/macfuse" + BUILD_FUSERMOUNT="no" + BUILD_QEMU_BLOCK="no" + FUSERMOUNT_SUBDIR="" ;; esac +# enable/disable QEMU +AM_CONDITIONAL([ENABLE_QEMU_BLOCK], [test x$BUILD_QEMU_BLOCK = xyes]) + + # enable debug section AC_ARG_ENABLE([debug], AC_HELP_STRING([--enable-debug], [Enable debug build options.])) + # syslog section AC_ARG_ENABLE([syslog], - AC_HELP_STRING([--disable-syslog], - [Disable syslog for logging])) + AC_HELP_STRING([--disable-syslog], + [Disable syslog for logging])) USE_SYSLOG="yes" if test "x$enable_syslog" != "xno"; then @@ -812,8 +845,13 @@ AC_CHECK_LIB([readline -ltermcap],[readline],[RLLIBS="-lreadline -ltermcap"]) AC_CHECK_LIB([readline -lncurses],[readline],[RLLIBS="-lreadline -lncurses"]) if test "x$RLLIBS" != "x"; then - AC_DEFINE(HAVE_READLINE, 1, [readline enabled CLI]) - BUILD_READLINE=yes + if test "x$RL_UNDO" == "xyes"; then + AC_DEFINE(HAVE_READLINE, 1, [readline enabled CLI]) + BUILD_READLINE=yes + else + BUILD_READLINE="no (present but missing undo)" + fi + fi BUILD_LIBAIO=no @@ -838,9 +876,20 @@ fi saved_CFLAGS=$CFLAGS saved_CPPFLAGS=$CPPFLAGS saved_LDFLAGS=$LDFLAGS -CFLAGS=`${PYTHON}-config --cflags` -CPPFLAGS=$CFLAGS -LDFLAGS="-L`${PYTHON}-config --prefix`/lib `${PYTHON}-config --ldflags`" + +case $host_os in + linux*) + CFLAGS="`${PYTHON}-config --cflags`" + CPPFLAGS=$CFLAGS + LDFLAGS="-L`${PYTHON}-config --prefix`/lib `${PYTHON}-config --ldflags`" + ;; + darwin*) + CFLAGS="`${PYTHON}-config --cflags` -Wno-error=unused-command-line-argument-hard-error-in-future" + CPPFLAGS=$CFLAGS + LDFLAGS="-L`${PYTHON}-config --prefix`/lib `${PYTHON}-config --ldflags`" + ;; +esac + AC_CHECK_HEADERS([python$PYTHON_VERSION/Python.h],[have_Python_h=yes],[]) AC_ARG_ENABLE([glupy], AS_HELP_STRING([--enable-glupy], @@ -848,7 +897,7 @@ AC_ARG_ENABLE([glupy], case x$enable_glupy in xyes) if test "x$have_python2" = "xyes" -a "x$have_Python_h" = "xyes"; then - BUILD_GLUPY=yes + BUILD_GLUPY=yes PYTHONDEV_CFLAGS="$CFLAGS" PYTHONDEV_CPPFLAGS="$CPPFLAGS" PYTHONDEV_LDFLAGS="$LDFLAGS" @@ -856,14 +905,14 @@ case x$enable_glupy in AC_SUBST(PYTHONDEV_CPPFLAGS) AC_SUBST(PYTHONDEV_LDFLAGS) else - AC_MSG_ERROR([glupy requires python-devel/python-dev package and python2.x]) + AC_MSG_ERROR([glupy requires python-devel/python-dev package and python2.x]) fi ;; xno) ;; *) if test "x$have_python2" = "xyes" -a "x$have_Python_h" = "xyes"; then - BUILD_GLUPY=yes + BUILD_GLUPY=yes PYTHONDEV_CFLAGS="$CFLAGS" PYTHONDEV_CPPFLAGS="$CPPFLAGS" PYTHONDEV_LDFLAGS="$LDFLAGS" @@ -871,7 +920,7 @@ case x$enable_glupy in AC_SUBST(PYTHONDEV_CPPFLAGS) AC_SUBST(PYTHONDEV_LDFLAGS) else - AC_MSG_WARN([ + AC_MSG_WARN([ --------------------------------------------------------------------------------- cannot build glupy. python 2.x and python-devel/python-dev package are required. ---------------------------------------------------------------------------------]) @@ -903,7 +952,6 @@ AC_SUBST(CFLAGS) AC_SUBST(GF_HOST_OS) AC_SUBST([GF_GLUSTERFS_LIBS]) -AC_SUBST(GF_GLUSTERFS_CFLAGS) AC_SUBST(GF_CFLAGS) AC_SUBST(GF_LDFLAGS) AC_SUBST(GF_LDADD) @@ -918,7 +966,7 @@ CONTRIBDIR='$(top_srcdir)/contrib' AC_SUBST(CONTRIBDIR) GF_CPPDEFINES='-D_FILE_OFFSET_BITS=64 -D_GNU_SOURCE -D$(GF_HOST_OS)' -GF_CPPINCLUDES='-I$(top_srcdir)/libglusterfs/src -I$(CONTRIBDIR)/uuid $(UNITTEST_CPPFLAGS)' +GF_CPPINCLUDES='-I$(top_srcdir)/libglusterfs/src -I$(CONTRIBDIR)/uuid' GF_CPPFLAGS="$GF_CPPDEFINES $GF_CPPINCLUDES" AC_SUBST([GF_CPPFLAGS]) diff --git a/contrib/argp-standalone/configure.ac b/contrib/argp-standalone/configure.ac index 4e4e67692..167b234fc 100644 --- a/contrib/argp-standalone/configure.ac +++ b/contrib/argp-standalone/configure.ac @@ -56,12 +56,12 @@ AC_DEFUN([ARGP_CHECK_FUNC], [Define to 1 if you have the `]ac_func[' function.]) AC_CACHE_CHECK([for $2], ac_var, [AC_TRY_LINK([$1], [$2], - [AS_VAR_SET(ac_var, yes)], - [AS_VAR_SET(ac_var, no)])]) + [AS_VAR_SET(ac_var, yes)], + [AS_VAR_SET(ac_var, no)])]) if test AS_VAR_GET(ac_var) = yes ; then ifelse([$3],, - [AC_DEFINE_UNQUOTED(AS_TR_CPP(HAVE_[]ac_func))], - [$3 + [AC_DEFINE_UNQUOTED(AS_TR_CPP(HAVE_[]ac_func))], + [$3 ]) else ifelse([$4],, true, [$4]) @@ -99,4 +99,7 @@ fi CPPFLAGS="$CPPFLAGS -I$srcdir" +dnl Added for C99 standards +CFLAGS="$CFLAGS -std=gnu89" + AC_OUTPUT(Makefile) diff --git a/contrib/fuse-include/fuse_kernel_macfuse.h b/contrib/fuse-include/fuse_kernel_macfuse.h index 3fbf24f70..a003f825a 100644 --- a/contrib/fuse-include/fuse_kernel_macfuse.h +++ b/contrib/fuse-include/fuse_kernel_macfuse.h @@ -189,6 +189,15 @@ enum fuse_opcode { FUSE_INTERRUPT = 36, FUSE_BMAP = 37, FUSE_DESTROY = 38, + /* + FUSE_IOCTL = 39, + FUSE_POLL = 40, + FUSE_NOTIFY_REPLY = 41, + FUSE_BATCH_FORGET = 42, + FUSE_FALLOCATE = 43, + FUSE_READDIRPLUS = 44, + */ + #if (__FreeBSD__ >= 10) FUSE_SETVOLNAME = 61, FUSE_GETXTIMES = 62, diff --git a/contrib/fuse-lib/mount-gluster-compat.h b/contrib/fuse-lib/mount-gluster-compat.h index 4fc20623b..1f76241ab 100644 --- a/contrib/fuse-lib/mount-gluster-compat.h +++ b/contrib/fuse-lib/mount-gluster-compat.h @@ -21,7 +21,7 @@ #include #include #include -#ifndef __NetBSD__ +#if !defined(__NetBSD__) && !defined(GF_DARWIN_HOST_OS) #include #endif /* __NetBSD__ */ #include @@ -36,7 +36,15 @@ #define MS_RDONLY MNT_RDONLY #endif -#ifdef linux +#ifdef GF_DARWIN_HOST_OS +#include +#include +#define umount2(dir, flags) unmount(dir, ((flags) != 0) ? MNT_FORCE : 0) +#define MS_RDONLY MNT_RDONLY +#endif + + +#ifdef GF_LINUX_HOST_OS #define _PATH_MOUNT "/bin/mount" #else /* NetBSD, MacOS X */ #define _PATH_MOUNT "/sbin/mount" diff --git a/contrib/fuse-util/Makefile.am b/contrib/fuse-util/Makefile.am index 971d3d220..abbc10eb6 100644 --- a/contrib/fuse-util/Makefile.am +++ b/contrib/fuse-util/Makefile.am @@ -3,7 +3,7 @@ bin_PROGRAMS = fusermount-glusterfs fusermount_glusterfs_SOURCES = fusermount.c mount_util.c $(CONTRIBDIR)/fuse-lib/mount-common.c noinst_HEADERS = $(CONTRIBDIR)/fuse-include/mount_util.h -AM_CPPFLAGS = $(GF_CPPFLAGS) -DFUSE_UTIL -I$(CONTRIBDIR)/fuse-include +AM_CPPFLAGS = $(GF_CPPFLAGS) -DFUSE_UTIL -I$(CONTRIBDIR)/fuse-include -I$(CONTRIBDIR)/fuse-lib AM_CFLAGS = -Wall $(GF_CFLAGS) diff --git a/contrib/fuse-util/fusermount.c b/contrib/fuse-util/fusermount.c index 0ff8d9039..a64d8e102 100644 --- a/contrib/fuse-util/fusermount.c +++ b/contrib/fuse-util/fusermount.c @@ -10,6 +10,11 @@ #include #include "mount_util.h" + +#ifndef HAVE_UMOUNT2 +#include "mount-gluster-compat.h" +#endif + #include #include #include @@ -20,11 +25,18 @@ #include #include #include +#if !defined(__NetBSD__) && !defined(GF_DARWIN_HOST_OS) #include +#endif /* __NetBSD__ */ #include #include -#include +#ifdef HAVE_SET_FSID #include +#endif +#ifdef GF_DARWIN_HOST_OS +#include +#endif +#include #include #include #include @@ -63,22 +75,32 @@ static const char *get_user_name(void) } } +#ifdef HAVE_SET_FSID static uid_t oldfsuid; static gid_t oldfsgid; +#endif static void drop_privs(void) { if (getuid() != 0) { +#ifdef HAVE_SET_FSID oldfsuid = setfsuid(getuid()); oldfsgid = setfsgid(getgid()); +#else + fprintf(stderr, "%s: Implement alternative setfsuid/gid \n", progname); +#endif } } static void restore_privs(void) { if (getuid() != 0) { +#ifdef HAVE_SET_FSID setfsuid(oldfsuid); setfsgid(oldfsgid); +#else + fprintf(stderr, "%s: Implement alternative setfsuid/gid \n", progname); +#endif } } diff --git a/contrib/macfuse/fuse_param.h b/contrib/macfuse/fuse_param.h index 81d753c6c..347db9464 100644 --- a/contrib/macfuse/fuse_param.h +++ b/contrib/macfuse/fuse_param.h @@ -1,3 +1,8 @@ +/* + * 'rebel' branch modifications: + * Copyright (C) 2010 Tuxera. All Rights Reserved. + */ + /* * Copyright (C) 2006-2008 Google. All Rights Reserved. * Amit Singh @@ -6,69 +11,81 @@ #ifndef _FUSE_PARAM_H_ #define _FUSE_PARAM_H_ -/* Compile-time tunables (M_MACFUSE*) */ - -#define M_MACFUSE_ENABLE_FIFOFS 0 -#define M_MACFUSE_ENABLE_INTERRUPT 1 -#define M_MACFUSE_ENABLE_SPECFS 0 -#define M_MACFUSE_ENABLE_TSLOCKING 0 -#define M_MACFUSE_ENABLE_UNSUPPORTED 1 -#define M_MACFUSE_ENABLE_XATTR 1 - -#if M_MACFUSE_ENABLE_UNSUPPORTED - #define M_MACFUSE_ENABLE_DSELECT 0 - #define M_MACFUSE_ENABLE_EXCHANGE 1 - #define M_MACFUSE_ENABLE_KQUEUE 1 - #define M_MACFUSE_ENABLE_KUNC 0 -#if __LP64__ - #define M_MACFUSE_ENABLE_INTERIM_FSNODE_LOCK 1 -#endif /* __LP64__ */ -#endif /* M_MACFUSE_ENABLE_UNSUPPORTED */ - -#if M_MACFUSE_ENABLE_INTERIM_FSNODE_LOCK -#define FUSE_VNOP_EXPORT __private_extern__ +#include + +/* Compile-time tunables (M_OSXFUSE*) */ + +#define M_OSXFUSE_ENABLE_FIFOFS 0 +#define M_OSXFUSE_ENABLE_INTERRUPT 1 +#define M_OSXFUSE_ENABLE_SPECFS 0 +#define M_OSXFUSE_ENABLE_TSLOCKING 1 +#define M_OSXFUSE_ENABLE_UNSUPPORTED 1 +#define M_OSXFUSE_ENABLE_XATTR 1 +#define M_OSXFUSE_ENABLE_DSELECT 1 + +#if M_OSXFUSE_ENABLE_UNSUPPORTED +# define M_OSXFUSE_ENABLE_EXCHANGE 1 +# define M_OSXFUSE_ENABLE_KUNC 0 +# define M_OSXFUSE_ENABLE_INTERIM_FSNODE_LOCK 1 +#endif /* M_OSXFUSE_ENABLE_UNSUPPORTED */ + +#if MAC_OS_X_VERSION_MIN_REQUIRED < 1060 +# if M_OSXFUSE_ENABLE_UNSUPPORTED + /* + * In Mac OS X 10.5 the file system implementation is responsible for + * posting kqueue events. Starting with Mac OS X 10.6 VFS took over that + * job. + */ +# define M_OSXFUSE_ENABLE_KQUEUE 1 +# endif +#endif /* MAC_OS_X_VERSION_MIN_REQUIRED < 1060 */ + +#if M_OSXFUSE_ENABLE_INTERIM_FSNODE_LOCK +# define M_OSXFUSE_ENABLE_HUGE_LOCK 0 +# define M_OSXFUSE_ENABLE_LOCK_LOGGING 0 +# define FUSE_VNOP_EXPORT __private_extern__ #else -#define FUSE_VNOP_EXPORT static -#endif /* M_MACFUSE_ENABLE_INTERIM_FSNODE_LOCK */ +# define FUSE_VNOP_EXPORT static +#endif /* M_OSXFUSE_ENABLE_INTERIM_FSNODE_LOCK */ /* User Control */ -#define MACFUSE_POSTUNMOUNT_SIGNAL SIGKILL +#define OSXFUSE_POSTUNMOUNT_SIGNAL SIGKILL #define MACOSX_ADMIN_GROUP_NAME "admin" -#define SYSCTL_MACFUSE_TUNABLES_ADMIN "macfuse.tunables.admin_group" -#define SYSCTL_MACFUSE_VERSION_NUMBER "macfuse.version.number" +#define SYSCTL_OSXFUSE_TUNABLES_ADMIN "osxfuse.tunables.admin_group" +#define SYSCTL_OSXFUSE_VERSION_NUMBER "osxfuse.version.number" /* Paths */ -#define MACFUSE_BUNDLE_PATH "/Library/Filesystems/fusefs.fs" -#define MACFUSE_KEXT MACFUSE_BUNDLE_PATH "/Support/fusefs.kext" -#define MACFUSE_LOAD_PROG MACFUSE_BUNDLE_PATH "/Support/load_fusefs" -#define MACFUSE_MOUNT_PROG MACFUSE_BUNDLE_PATH "/Support/mount_fusefs" +#define OSXFUSE_BUNDLE_PATH "/Library/Filesystems/osxfusefs.fs" +#define OSXFUSE_KEXT OSXFUSE_BUNDLE_PATH "/Support/osxfusefs.kext" +#define OSXFUSE_LOAD_PROG OSXFUSE_BUNDLE_PATH "/Support/load_osxfusefs" +#define OSXFUSE_MOUNT_PROG OSXFUSE_BUNDLE_PATH "/Support/mount_osxfusefs" #define SYSTEM_KEXTLOAD "/sbin/kextload" #define SYSTEM_KEXTUNLOAD "/sbin/kextunload" /* Compatible API version */ -#define MACFUSE_MIN_USER_VERSION_MAJOR 7 -#define MACFUSE_MIN_USER_VERSION_MINOR 5 +#define OSXFUSE_MIN_USER_VERSION_MAJOR 7 +#define OSXFUSE_MIN_USER_VERSION_MINOR 5 /* Device Interface */ /* - * This is the prefix ("fuse" by default) of the name of a FUSE device node - * in devfs. The suffix is the device number. "/dev/fuse0" is the first FUSE + * This is the prefix ("osxfuse" by default) of the name of a FUSE device node + * in devfs. The suffix is the device number. "/dev/osxfuse0" is the first FUSE * device by default. If you change the prefix from the default to something * else, the user-space FUSE library will need to know about it too. */ -#define MACFUSE_DEVICE_BASENAME "fuse" +#define OSXFUSE_DEVICE_BASENAME "osxfuse" /* - * This is the number of /dev/fuse nodes we will create. goes from - * 0 to (FUSE_NDEVICES - 1). + * This is the number of /dev/osxfuse nodes we will create. goes from + * 0 to (OSXFUSE_NDEVICES - 1). */ -#define MACFUSE_NDEVICES 24 +#define OSXFUSE_NDEVICES 24 /* * This is the default block size of the virtual storage devices that are @@ -131,13 +148,13 @@ /* User-Kernel IPC Buffer */ #define FUSE_MIN_USERKERNEL_BUFSIZE (128 * 1024) -#define FUSE_MAX_USERKERNEL_BUFSIZE (4096 * 1024) +#define FUSE_MAX_USERKERNEL_BUFSIZE (16 * 1024 * 1024) #define FUSE_REASONABLE_XATTRSIZE FUSE_MIN_USERKERNEL_BUFSIZE #endif /* KERNEL */ -#define FUSE_DEFAULT_USERKERNEL_BUFSIZE (4096 * 1024) +#define FUSE_DEFAULT_USERKERNEL_BUFSIZE (16 * 1024 * 1024) #define FUSE_LINK_MAX LINK_MAX #define FUSE_UIO_BACKUP_MAX 8 diff --git a/contrib/macfuse/mount_darwin.c b/contrib/macfuse/mount_darwin.c index c485583e9..cac158249 100644 --- a/contrib/macfuse/mount_darwin.c +++ b/contrib/macfuse/mount_darwin.c @@ -105,7 +105,7 @@ loadkmod(void) pid = fork(); if (pid == 0) { - execl(MACFUSE_LOAD_PROG, MACFUSE_LOAD_PROG, NULL); + execl(OSXFUSE_LOAD_PROG, OSXFUSE_LOAD_PROG, NULL); /* exec failed */ exit(ENOENT); @@ -133,13 +133,17 @@ Return: } int +gf_fuse_mount (const char *mountpoint, char *fsname, + unsigned long mountflags, char *mnt_param, + pid_t *mnt_pid, int status_fd) /* Not used on OS X */ +/* int gf_fuse_mount (const char *mountpoint, char *fsname, char *mnt_param, - pid_t *mtab_pid /* not used on OS X */) +pid_t *mtab_pid) */ { int fd, pid; int result; char *fdnam, *dev; - const char *mountprog = MACFUSE_MOUNT_PROG; + const char *mountprog = OSXFUSE_MOUNT_PROG; sig_t chldf; /* mount_fusefs should not try to spawn the daemon */ @@ -170,7 +174,8 @@ gf_fuse_mount (const char *mountpoint, char *fsname, char *mnt_param, size_t version_len = MAXHOSTNAMELEN; size_t version_len_desired = 0; - result = sysctlbyname(SYSCTL_MACFUSE_VERSION_NUMBER, version, + result = sysctlbyname(SYSCTL_OSXFUSE_VERSION_NUMBER + , version, &version_len, NULL, (size_t)0); if (result == 0) { /* sysctlbyname() includes the trailing '\0' in version_len */ @@ -197,10 +202,12 @@ gf_fuse_mount (const char *mountpoint, char *fsname, char *mnt_param, gf_log("glusterfs-fuse", GF_LOG_INFO, "MacFUSE kext version %s", version); } + // TODO Bypass version check + result = 0; if (result != 0) - GFFUSE_LOGERR("MacFUSE version %s is not supported", version); + GFFUSE_LOGERR("MacFUSE version %s is not supported", version); } else - GFFUSE_LOGERR("cannot load MacFUSE kext"); + GFFUSE_LOGERR("cannot load MacFUSE kext"); if (result != 0) return -1; @@ -228,9 +235,9 @@ gf_fuse_mount (const char *mountpoint, char *fsname, char *mnt_param, int r, devidx = -1; char devpath[MAXPATHLEN]; - for (r = 0; r < MACFUSE_NDEVICES; r++) { + for (r = 0; r < OSXFUSE_NDEVICES; r++) { snprintf(devpath, MAXPATHLEN - 1, - _PATH_DEV MACFUSE_DEVICE_BASENAME "%d", r); + _PATH_DEV OSXFUSE_DEVICE_BASENAME "%d", r); fd = open(devpath, O_RDWR); if (fd >= 0) { dev = devpath; @@ -336,8 +343,8 @@ gf_fuse_unmount(const char *mountpoint, int fd) devname_r(sbuf.st_rdev, S_IFCHR, dev, 128); - if (strncmp(dev, MACFUSE_DEVICE_BASENAME, - sizeof(MACFUSE_DEVICE_BASENAME) - 1)) { + if (strncmp(dev, OSXFUSE_DEVICE_BASENAME, + sizeof(OSXFUSE_DEVICE_BASENAME) - 1)) { return; } diff --git a/contrib/mount/mntent.c b/contrib/mount/mntent.c new file mode 100644 index 000000000..5ab5ac19e --- /dev/null +++ b/contrib/mount/mntent.c @@ -0,0 +1,163 @@ +/* + * Copyright (c) 1980, 1989, 1993, 1994 + * The Regents of the University of California. All rights reserved. + * Copyright (c) 2001 + * David Rufino + * Copyright (c) 2014 + * Red Hat, Inc. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * This product includes software developed by the University of + * California, Berkeley and its contributors. + * 4. Neither the name of the University nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifdef GF_DARWIN_HOST_OS +#include +#include +#include +#include +#include +#include "mntent_compat.h" + +static int pos = -1; +static int mntsize = -1; +static struct mntent _mntent; + +char * +hasmntopt (const struct mntent *mnt, const char *option) +{ + int found; + char *opt, *optbuf; + + optbuf = strdup(mnt->mnt_opts); + found = 0; + for (opt = optbuf; (opt = strtok(opt, " ")) != NULL; opt = NULL) { + if (!strcasecmp(opt, option)) { + opt = opt - optbuf + mnt->mnt_opts; + free (optbuf); + return (opt); + } + } + free (optbuf); + return (NULL); +} + +static char * +concatopt (char *s0, const char *s1) +{ + size_t i; + char *cp; + + if (s1 == NULL || *s1 == '\0') + return s0; + if (s0 && *s0) { + i = strlen(s0) + strlen(s1) + 1 + 1; + if ((cp = (char *)malloc(i)) == NULL) + return (NULL); + (void)snprintf(cp, i, "%s %s", s0, s1); + } else + cp = strdup(s1); + + if (s0) + free(s0); + return (cp); +} + + +static char * +flags2opts (int flags) +{ + char *res; + res = NULL; + res = concatopt(res, (flags & MNT_RDONLY) ? "ro" : "rw"); + if (flags & MNT_SYNCHRONOUS) res = concatopt(res, "sync"); + if (flags & MNT_NOEXEC) res = concatopt(res, "noexec"); + if (flags & MNT_NOSUID) res = concatopt(res, "nosuid"); + if (flags & MNT_NODEV) res = concatopt(res, "nodev"); + if (flags & MNT_UNION) res = concatopt(res, "union"); + if (flags & MNT_ASYNC) res = concatopt(res, "async"); +#if !defined(GF_DARWIN_HOST_OS) + if (flags & MNT_NOATIME) res = concatopt(res, "noatime"); + if (flags & MNT_NOCLUSTERR) res = concatopt(res, "noclusterr"); + if (flags & MNT_NOCLUSTERW) res = concatopt(res, "noclusterw"); + if (flags & MNT_NOSYMFOLLOW) res = concatopt(res, "nosymfollow"); + if (flags & MNT_SUIDDIR) res = concatopt(res, "suiddir"); +#endif + return res; +} + +static struct mntent * +statfs_to_mntent (struct statfs *mntbuf) +{ + static char opts_buf[40], *tmp; + + _mntent.mnt_fsname = mntbuf->f_mntfromname; + _mntent.mnt_dir = mntbuf->f_mntonname; + _mntent.mnt_type = mntbuf->f_fstypename; + tmp = flags2opts (mntbuf->f_flags); + if (tmp) { + opts_buf[sizeof(opts_buf)-1] = '\0'; + strncpy (opts_buf, tmp, sizeof(opts_buf)-1); + free (tmp); + } else { + *opts_buf = '\0'; + } + _mntent.mnt_opts = opts_buf; + _mntent.mnt_freq = _mntent.mnt_passno = 0; + return (&_mntent); +} + +struct mntent * +getmntent (FILE *fp) +{ + struct statfs *mntbuf; + + if (pos == -1 || mntsize == -1) + mntsize = getmntinfo (&mntbuf, MNT_NOWAIT); + + ++pos; + if (pos == mntsize) { + pos = mntsize = -1; + return (NULL); + } + + return (statfs_to_mntent (&mntbuf[pos])); +} + +/* Dummy functions */ +FILE * +setmntent(const char *filename, const char *type) +{ + return (FILE *)0x1; +} + +int +endmntent (FILE *fp) +{ + return 1; +} +#endif /* GF_DARWIN_HOST_OS */ diff --git a/contrib/mount/mntent_compat.h b/contrib/mount/mntent_compat.h new file mode 100644 index 000000000..76a75754b --- /dev/null +++ b/contrib/mount/mntent_compat.h @@ -0,0 +1,35 @@ +/* + Copyright (c) 2014 Red Hat, Inc. + This file is part of GlusterFS. + + This file is licensed to you under your choice of the GNU Lesser + General Public License, version 3 or any later version (LGPLv3 or + later), or the GNU General Public License, version 2 (GPLv2), in all + cases as published by the Free Software Foundation. +*/ + +#ifndef _MNTENT_H +#define _MNTENT_H + +#ifdef GF_DARWIN_HOST_OS +#include + +struct mntent { + char *mnt_fsname; + char *mnt_dir; + char *mnt_type; + char *mnt_opts; + int mnt_freq; + int mnt_passno; +}; + +struct mntent *getmntent (FILE *fp); +FILE *setmntent (const char *filename, const char *type); +int endmntent(FILE *fp); +char * hasmntopt (const struct mntent *mnt, const char *option); + +/* Dummy - /etc/mtab has no meaning on OSX platform */ +#define _PATH_MOUNTED "/etc/mtab" + +#endif /* GF_DARWIN_HOST_OS */ +#endif /* _MNTENT_H */ diff --git a/contrib/qemu/include/qemu/bswap.h b/contrib/qemu/include/qemu/bswap.h index 14a5f657c..1ea5b101e 100644 --- a/contrib/qemu/include/qemu/bswap.h +++ b/contrib/qemu/include/qemu/bswap.h @@ -12,7 +12,14 @@ # include # include #elif defined(CONFIG_BYTESWAP_H) +#ifdef GF_DARWIN_HOST_OS +# include +#define bswap_16(x) OSSwapInt16(x) +#define bswap_32(x) OSSwapInt32(x) +#define bswap_64(x) OSSwapInt64(x) +#else # include +#endif static inline uint16_t bswap16(uint16_t x) { diff --git a/contrib/qemu/util/cutils.c b/contrib/qemu/util/cutils.c index 0116fcde7..6caa4b8dd 100644 --- a/contrib/qemu/util/cutils.c +++ b/contrib/qemu/util/cutils.c @@ -156,7 +156,7 @@ int qemu_fls(int i) */ int qemu_fdatasync(int fd) { -#ifdef CONFIG_FDATASYNC +#ifdef HAVE_FDATASYNC return fdatasync(fd); #else return fsync(fd); diff --git a/contrib/sunrpc/xdr_sizeof.c b/contrib/sunrpc/xdr_sizeof.c new file mode 100644 index 000000000..ca1f7bf0a --- /dev/null +++ b/contrib/sunrpc/xdr_sizeof.c @@ -0,0 +1,204 @@ +/* + * Copyright (c) 1999 Apple Computer, Inc. All rights reserved. + * + * @APPLE_LICENSE_HEADER_START@ + * + * Portions Copyright (c) 1999 Apple Computer, Inc. All Rights + * Reserved. This file contains Original Code and/or Modifications of + * Original Code as defined in and that are subject to the Apple Public + * Source License Version 1.1 (the "License"). You may not use this file + * except in compliance with the License. Please obtain a copy of the + * License at http://www.apple.com/publicsource and read it before using + * this file. + * + * The Original Code and all software distributed under the License are + * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER + * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, + * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE OR NON- INFRINGEMENT. Please see the + * License for the specific language governing rights and limitations + * under the License. + * + * @APPLE_LICENSE_HEADER_END@ + */ + +/* + * Sun RPC is a product of Sun Microsystems, Inc. and is provided for + * unrestricted use provided that this legend is included on all tape + * media and as a part of the software program in whole or part. Users + * may copy or modify Sun RPC without charge, but are not authorized + * to license or distribute it to anyone else except as part of a product or + * program developed by the user. + * + * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE + * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR + * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE. + * + * Sun RPC is provided with no support and without any obligation on the + * part of Sun Microsystems, Inc. to assist in its use, correction, + * modification or enhancement. + * + * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE + * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC + * OR ANY PART THEREOF. + * + * In no event will Sun Microsystems, Inc. be liable for any lost revenue + * or profits or other special, indirect and consequential damages, even if + * Sun has been advised of the possibility of such damages. + * + * Sun Microsystems, Inc. + * 2550 Garcia Avenue + * Mountain View, California 94043 + */ + +/* + * xdr_sizeof.c + * + * Copyright 1990 Sun Microsystems, Inc. + * + * General purpose routine to see how much space something will use + * when serialized using XDR. + */ + +#ifdef GF_DARWIN_HOST_OS + +#include +#include +#include +#include + +#include + +/* ARGSUSED */ +#ifdef GF_DARWIN_HOST_OS +static bool_t +x_putlong (XDR *xdrs, const int *longp) +{ + xdrs->x_handy += BYTES_PER_XDR_UNIT; + return TRUE; +} + +#else +static bool_t +x_putlong (XDR *xdrs, const long *longp) +{ + xdrs->x_handy += BYTES_PER_XDR_UNIT; + return TRUE; +} +#endif + +/* ARGSUSED */ +static bool_t +x_putbytes (XDR *xdrs, const char *bp, u_int len) +{ + xdrs->x_handy += len; + return TRUE; +} + +#ifdef GF_DARWIN_HOST_OS +static u_int +x_getpostn (XDR *xdrs) +{ + return xdrs->x_handy; +} +#else +static u_int +x_getpostn (const XDR *xdrs) +{ + return xdrs->x_handy; +} +#endif + +/* ARGSUSED */ +static bool_t +x_setpostn (XDR *xdrs, u_int len) +{ + /* This is not allowed */ + return FALSE; +} + +static int32_t * +x_inline (XDR *xdrs, u_int len) +{ + if (len == 0) + return NULL; + if (xdrs->x_op != XDR_ENCODE) + return NULL; + if (len < (u_int) (long int) xdrs->x_base) + { + /* x_private was already allocated */ + xdrs->x_handy += len; + return (int32_t *) xdrs->x_private; + } + else + { + /* Free the earlier space and allocate new area */ + free (xdrs->x_private); + if ((xdrs->x_private = (caddr_t) malloc (len)) == NULL) + { + xdrs->x_base = 0; + return NULL; + } + xdrs->x_base = (void *) (long) len; + xdrs->x_handy += len; + return (int32_t *) xdrs->x_private; + } +} + +static int +harmless (void) +{ + /* Always return FALSE/NULL, as the case may be */ + return 0; +} + +static void +x_destroy (XDR *xdrs) +{ + xdrs->x_handy = 0; + xdrs->x_base = 0; + if (xdrs->x_private) + { + free (xdrs->x_private); + xdrs->x_private = NULL; + } + return; +} + +unsigned long +xdr_sizeof (xdrproc_t func, void *data) +{ + XDR x; + struct xdr_ops ops; + bool_t stat; + +#ifdef GF_DARWIN_HOST_OS + typedef bool_t (*dummyfunc1) (XDR *, int *); +#else + typedef bool_t (*dummyfunc1) (XDR *, long *); +#endif + typedef bool_t (*dummyfunc2) (XDR *, caddr_t, u_int); + + ops.x_putlong = x_putlong; + ops.x_putbytes = x_putbytes; + ops.x_inline = x_inline; + ops.x_getpostn = x_getpostn; + ops.x_setpostn = x_setpostn; + ops.x_destroy = x_destroy; + + /* the other harmless ones */ + ops.x_getlong = (dummyfunc1) harmless; + ops.x_getbytes = (dummyfunc2) harmless; + + x.x_op = XDR_ENCODE; + x.x_ops = &ops; + x.x_handy = 0; + x.x_private = (caddr_t) NULL; + x.x_base = (caddr_t) 0; + + stat = func (&x, data, 0); + if (x.x_private) + free (x.x_private); + return (stat == TRUE ? (unsigned) x.x_handy : 0); +} +#endif /* GF_DARWIN_HOST_OS */ diff --git a/contrib/uuid/gen_uuid.c b/contrib/uuid/gen_uuid.c index b3eda9de3..79923cd54 100644 --- a/contrib/uuid/gen_uuid.c +++ b/contrib/uuid/gen_uuid.c @@ -44,6 +44,18 @@ #include #define UUID MYUUID #endif + +#ifdef __APPLE__ +#define PRI_TIME "ld" +#define PRI_TIME_USEC "d" +#define SCAN_TIME "lu" +#else +#define PRI_TIME "lu" +#define PRI_TIME_USEC "lu" +#define SCAN_TIME "ld" +#endif + + #include #ifdef HAVE_UNISTD_H #include @@ -354,8 +366,7 @@ static int get_clock(uint32_t *clock_high, uint32_t *clock_low, unsigned int cl; unsigned long tv1, tv2; int a; - - if (fscanf(state_f, "clock: %04x tv: %lu %lu adj: %d\n", + if (fscanf(state_f, "clock: %04x tv: %" SCAN_TIME " %" SCAN_TIME " adj: %d\n", &cl, &tv1, &tv2, &a) == 4) { clock_seq = cl & 0x3FFF; last.tv_sec = tv1; @@ -404,7 +415,7 @@ try_again: if (state_fd > 0) { rewind(state_f); len = fprintf(state_f, - "clock: %04x tv: %016lu %08lu adj: %08d\n", + "clock: %04x tv: %016" PRI_TIME "%08" PRI_TIME_USEC "adj: %08d\n", clock_seq, last.tv_sec, last.tv_usec, adjustment); fflush(state_f); if (ftruncate(state_fd, len) < 0) { diff --git a/contrib/uuid/uuid_time.c b/contrib/uuid/uuid_time.c index f25f5c90f..ccaa542fe 100644 --- a/contrib/uuid/uuid_time.c +++ b/contrib/uuid/uuid_time.c @@ -52,6 +52,7 @@ #include #include "uuidP.h" +#include "logging.h" time_t uuid_time(const uuid_t uu, struct timeval *ret_tv) { @@ -163,8 +164,7 @@ main(int argc, char **argv) printf("Warning: not a time-based UUID, so UUID time " "decoding will likely not work!\n"); } - printf("UUID time is: (%ld, %ld): %s\n", tv.tv_sec, tv.tv_usec, - ctime(&time_reg)); + printf("UUID time is: (%" GF_PRI_SECOND ", %" GF_PRI_USEC "): %s\n", tv.tv_sec, tv.tv_usec, ctime(&time_reg)); return 0; } diff --git a/extras/geo-rep/Makefile.am b/extras/geo-rep/Makefile.am index 9435861cf..6d3d10b88 100644 --- a/extras/geo-rep/Makefile.am +++ b/extras/geo-rep/Makefile.am @@ -4,6 +4,7 @@ scripts_DATA = gsync-upgrade.sh generate-gfid-file.sh get-gfid.sh \ scripts_PROGRAMS = gsync-sync-gfid gsync_sync_gfid_CFLAGS = $(GF_CFLAGS) -Wall -I$(top_srcdir)/libglusterfs/src +gsync_sync_gfid_LDFLAGS = $(GF_LDFLAGS) gsync_sync_gfid_LDADD = $(GF_LIBS) $(top_builddir)/libglusterfs/src/libglusterfs.la gsync_sync_gfid_SOURCES = gsync-sync-gfid.c diff --git a/gen-headers.py b/gen-headers.py index ef9fa7711..6e40580f6 100755 --- a/gen-headers.py +++ b/gen-headers.py @@ -32,8 +32,13 @@ def genCHeader(logBook, defineLines.append("#define %-20s %d" % (nameDef, code)) defineLines.append("#define %-20s %s" % (msgNameDef, json.dumps(msg))) + caseLines.append("#ifdef HAVE_LIBINTL_H") caseLines.append(" case %s: return _(%s);" % \ (nameDef, msgNameDef)) + caseLines.append("#else") + caseLines.append(" case %s: return %s;" % \ + (nameDef, msgNameDef)) + caseLines.append("#endif") d = {'DEFINES': "\n".join(defineLines), 'CASES': "\n".join(caseLines)} diff --git a/gf-error-codes.h.template b/gf-error-codes.h.template index ab6020d64..5ca64fd90 100644 --- a/gf-error-codes.h.template +++ b/gf-error-codes.h.template @@ -9,10 +9,11 @@ #ifndef _GF_ERROR_CODES_H #define _GF_ERROR_CODES_H +#ifdef HAVE_LIBINTL_H #include #define _(STRING) gettext(STRING) - +#endif /** START: ERROR CODE DEFINITIONS **/ $DEFINES diff --git a/glusterfsd/src/Makefile.am b/glusterfsd/src/Makefile.am index 1797c32be..e66d8ed31 100644 --- a/glusterfsd/src/Makefile.am +++ b/glusterfsd/src/Makefile.am @@ -13,7 +13,7 @@ AM_CPPFLAGS = $(GF_CPPFLAGS) \ -DCONFDIR=\"$(sysconfdir)/glusterfs\" \ -I$(top_srcdir)/rpc/rpc-lib/src -I$(top_srcdir)/rpc/xdr/src -AM_CFLAGS = -Wall $(GF_GLUSTERFS_CFLAGS) +AM_CFLAGS = -Wall $(GF_CFLAGS) CLEANFILES = diff --git a/glusterfsd/src/glusterfsd.c b/glusterfsd/src/glusterfsd.c index 531932619..219088025 100644 --- a/glusterfsd/src/glusterfsd.c +++ b/glusterfsd/src/glusterfsd.c @@ -1516,7 +1516,7 @@ parse_cmdline (int argc, char *argv[], glusterfs_ctx_t *ctx) #ifdef GF_DARWIN_HOST_OS if (cmd_args->mount_point) - cmd_args->mac_compat = GF_OPTION_DEFERRED; + cmd_args->mac_compat = GF_OPTION_DEFERRED; #endif ret = 0; diff --git a/libglusterfs/src/Makefile.am b/libglusterfs/src/Makefile.am index 8934b35f2..569d69be3 100644 --- a/libglusterfs/src/Makefile.am +++ b/libglusterfs/src/Makefile.am @@ -26,8 +26,8 @@ libglusterfs_la_SOURCES = dict.c xlator.c logging.c \ graph-print.c trie.c run.c options.c fd-lk.c circ-buff.c \ event-history.c gidcache.c ctx.c client_t.c event-poll.c event-epoll.c \ $(CONTRIBDIR)/libgen/basename_r.c $(CONTRIBDIR)/libgen/dirname_r.c \ - $(CONTRIBDIR)/stdlib/gf_mkostemp.c strfd.c - + $(CONTRIBDIR)/stdlib/gf_mkostemp.c strfd.c \ + $(CONTRIBDIR)/mount/mntent.c nodist_libglusterfs_la_SOURCES = y.tab.c graph.lex.c gf-error-codes.h @@ -43,7 +43,8 @@ noinst_HEADERS = common-utils.h defaults.h dict.h glusterfs.h hashfn.h timespec. $(CONTRIB_BUILDDIR)/uuid/uuid_types.h syncop.h graph-utils.h trie.h \ run.h options.h lkowner.h fd-lk.h circ-buff.h event-history.h \ gidcache.h client_t.h glusterfs-acl.h glfs-message-id.h \ - template-component-messages.h strfd.h + template-component-messages.h strfd.h \ + $(CONTRIBDIR)/mount/mntent_compat.h lvm-defaults.h EXTRA_DIST = graph.l graph.y diff --git a/libglusterfs/src/client_t.c b/libglusterfs/src/client_t.c index 1bf3de3f5..bdaf5289d 100644 --- a/libglusterfs/src/client_t.c +++ b/libglusterfs/src/client_t.c @@ -52,7 +52,7 @@ gf_client_clienttable_expand (clienttable_t *clienttable, uint32_t nr) uint32_t oldmax_clients = -1; int ret = -1; - if (clienttable == NULL || nr < 0) { + if (clienttable == NULL || nr > UINT32_MAX) { gf_log_callingfn ("client_t", GF_LOG_ERROR, "invalid argument"); ret = EINVAL; goto out; diff --git a/libglusterfs/src/common-utils.c b/libglusterfs/src/common-utils.c index b7d06d925..e63ffa142 100644 --- a/libglusterfs/src/common-utils.c +++ b/libglusterfs/src/common-utils.c @@ -1170,7 +1170,7 @@ gf_string2uint8 (const char *str, uint8_t *n) if (rv != 0) return rv; - if (l >= 0 && l <= UINT8_MAX) { + if (l <= UINT8_MAX) { *n = (uint8_t) l; return 0; } @@ -1189,7 +1189,7 @@ gf_string2uint16 (const char *str, uint16_t *n) if (rv != 0) return rv; - if (l >= 0 && l <= UINT16_MAX) { + if (l <= UINT16_MAX) { *n = (uint16_t) l; return 0; } @@ -1208,7 +1208,7 @@ gf_string2uint32 (const char *str, uint32_t *n) if (rv != 0) return rv; - if (l >= 0 && l <= UINT32_MAX) { + if (l <= UINT32_MAX) { *n = (uint32_t) l; return 0; } @@ -1227,7 +1227,7 @@ gf_string2uint64 (const char *str, uint64_t *n) if (rv != 0) return rv; - if (l >= 0 && l <= UINT64_MAX) { + if (l <= UINT64_MAX) { *n = (uint64_t) l; return 0; } @@ -1258,7 +1258,7 @@ gf_string2uint8_base10 (const char *str, uint8_t *n) if (rv != 0) return rv; - if (l >= 0 && l <= UINT8_MAX) { + if (l <= UINT8_MAX) { *n = (uint8_t) l; return 0; } @@ -1277,7 +1277,7 @@ gf_string2uint16_base10 (const char *str, uint16_t *n) if (rv != 0) return rv; - if (l >= 0 && l <= UINT16_MAX) { + if (l <= UINT16_MAX) { *n = (uint16_t) l; return 0; } @@ -1296,7 +1296,7 @@ gf_string2uint32_base10 (const char *str, uint32_t *n) if (rv != 0) return rv; - if (l >= 0 && l <= UINT32_MAX) { + if (l <= UINT32_MAX) { *n = (uint32_t) l; return 0; } @@ -1315,7 +1315,7 @@ gf_string2uint64_base10 (const char *str, uint64_t *n) if (rv != 0) return rv; - if (l >= 0 && l <= UINT64_MAX) { + if (l <= UINT64_MAX) { *n = (uint64_t) l; return 0; } @@ -1361,7 +1361,7 @@ err: } int -gf_string2bytesize (const char *str, uint64_t *n) +gf_string2bytesize_range (const char *str, uint64_t *n, uint64_t max) { double value = 0.0; char *tail = NULL; @@ -1410,7 +1410,7 @@ gf_string2bytesize (const char *str, uint64_t *n) return -1; } - if ((UINT64_MAX - value) < 0) { + if ((max - value) < 0) { errno = ERANGE; return -1; } @@ -1420,6 +1420,28 @@ gf_string2bytesize (const char *str, uint64_t *n) return 0; } +int +gf_string2bytesize_size (const char *str, size_t *n) +{ + uint64_t u64; + size_t max = (size_t) - 1; + int val = gf_string2bytesize_range (str, &u64, max); + *n = (size_t) u64; + return val; +} + +int +gf_string2bytesize (const char *str, uint64_t *n) +{ + return gf_string2bytesize_range(str, n, UINT64_MAX); +} + +int +gf_string2bytesize_uint64 (const char *str, uint64_t *n) +{ + return gf_string2bytesize_range(str, n, UINT64_MAX); +} + int gf_string2percent_or_bytesize (const char *str, uint64_t *n, diff --git a/libglusterfs/src/common-utils.h b/libglusterfs/src/common-utils.h index 3a58a9331..f11c95fa8 100644 --- a/libglusterfs/src/common-utils.h +++ b/libglusterfs/src/common-utils.h @@ -488,12 +488,12 @@ static inline void gf_time_fmt (char *dst, size_t sz_dst, time_t utime, unsigned int fmt) { extern void _gf_timestuff (gf_timefmts *, const char ***, const char ***); - static gf_timefmts timefmt_last = (gf_timefmts) -1; + static gf_timefmts timefmt_last = (gf_timefmts) - 1; static const char **fmts; static const char **zeros; struct tm tm; - if (timefmt_last == -1) + if (timefmt_last == (gf_timefmts) - 1) _gf_timestuff (&timefmt_last, &fmts, &zeros); if (timefmt_last < fmt) fmt = gf_timefmt_default; if (utime && gmtime_r (&utime, &tm) != NULL) { @@ -552,8 +552,9 @@ int gf_string2uint8_base10 (const char *str, uint8_t *n); int gf_string2uint16_base10 (const char *str, uint16_t *n); int gf_string2uint32_base10 (const char *str, uint32_t *n); int gf_string2uint64_base10 (const char *str, uint64_t *n); - int gf_string2bytesize (const char *str, uint64_t *n); +int gf_string2bytesize_size (const char *str, size_t *n); +int gf_string2bytesize_uint64 (const char *str, uint64_t *n); int gf_string2percent_or_bytesize (const char *str, uint64_t *n, gf_boolean_t *is_percent); @@ -626,7 +627,7 @@ gf_skip_header_section (int fd, int header_len); struct iatt; struct _dict; -inline gf_boolean_t +gf_boolean_t dht_is_linkfile (struct iatt *buf, struct _dict *dict); int diff --git a/libglusterfs/src/compat.h b/libglusterfs/src/compat.h index 359a4a3b5..81408dbd0 100644 --- a/libglusterfs/src/compat.h +++ b/libglusterfs/src/compat.h @@ -31,11 +31,21 @@ #include #include #include +#include #include #ifdef HAVE_LINUX_FALLOC_H #include #endif +#ifdef HAVE_ENDIAN_H +#include +#endif +#endif /* GF_LINUX_HOST_OS */ + +#ifdef HAVE_XATTR_H +#include +#endif + /* * Define the fallocate flags in case we do not have the header. This also * accounts for older systems that do not define FALLOC_FL_PUNCH_HOLE. @@ -61,7 +71,29 @@ #define lsetxattr(path,key,value,size,flags) setxattr(path,key,value,size,flags) #endif /* HAVE_LLISTXATTR */ -#endif /* GF_LINUX_HOST_OS */ + + +#ifdef GF_DARWIN_HOST_OS +#include +#include + +#define htobe16(x) OSSwapHostToBigInt16(x) +#define htole16(x) OSSwapHostToLittleInt16(x) +#define be16toh(x) OSSwapBigToHostInt16(x) +#define le16toh(x) OSSwapLittleToHostInt16(x) + +#define htobe32(x) OSSwapHostToBigInt32(x) +#define htole32(x) OSSwapHostToLittleInt32(x) +#define be32toh(x) OSSwapBigToHostInt32(x) +#define le32toh(x) OSSwapLittleToHostInt32(x) + +#define htobe64(x) OSSwapHostToBigInt64(x) +#define htole64(x) OSSwapHostToLittleInt64(x) +#define be64toh(x) OSSwapBigToHostInt64(x) +#define le64toh(x) OSSwapLittleToHostInt64(x) + +#endif + #ifdef GF_BSD_HOST_OS /* In case of FreeBSD and NetBSD */ @@ -125,12 +157,29 @@ enum { #endif /* GF_BSD_HOST_OS */ #ifdef GF_DARWIN_HOST_OS +#include +#include + +#define htobe16(x) OSSwapHostToBigInt16(x) +#define htole16(x) OSSwapHostToLittleInt16(x) +#define be16toh(x) OSSwapBigToHostInt16(x) +#define le16toh(x) OSSwapLittleToHostInt16(x) + +#define htobe32(x) OSSwapHostToBigInt32(x) +#define htole32(x) OSSwapHostToLittleInt32(x) +#define be32toh(x) OSSwapBigToHostInt32(x) +#define le32toh(x) OSSwapLittleToHostInt32(x) + +#define htobe64(x) OSSwapHostToBigInt64(x) +#define htole64(x) OSSwapHostToLittleInt64(x) +#define be64toh(x) OSSwapBigToHostInt64(x) +#define le64toh(x) OSSwapLittleToHostInt64(x) #define UNIX_PATH_MAX 104 +#define AT_SYMLINK_NOFOLLOW 0x100 #include #include -#include #include #include diff --git a/libglusterfs/src/dict.c b/libglusterfs/src/dict.c index 1bed8bf9b..1198c65b1 100644 --- a/libglusterfs/src/dict.c +++ b/libglusterfs/src/dict.c @@ -1041,7 +1041,7 @@ data_to_uint8 (data_t *data) errno = 0; value = strtol (str, NULL, 0); - if ((UCHAR_MAX - value) < 0) { + if ((UCHAR_MAX - (uint8_t)value) < 0) { errno = ERANGE; gf_log_callingfn ("dict", GF_LOG_WARNING, "data conversion overflow detected (%s)", @@ -2157,7 +2157,7 @@ dict_set_bin (dict_t *this, char *key, void *ptr, size_t size) data_t * data = NULL; int ret = 0; - if (!ptr || (size < 0)) { + if (!ptr || (size > ULONG_MAX)) { ret = -EINVAL; goto err; } @@ -2185,7 +2185,7 @@ dict_set_static_bin (dict_t *this, char *key, void *ptr, size_t size) data_t * data = NULL; int ret = 0; - if (!ptr || (size < 0)) { + if (!ptr || (size > ULONG_MAX)) { ret = -EINVAL; goto err; } diff --git a/libglusterfs/src/fd.c b/libglusterfs/src/fd.c index 36cc4d056..2d50aa62e 100644 --- a/libglusterfs/src/fd.c +++ b/libglusterfs/src/fd.c @@ -59,7 +59,7 @@ gf_fd_fdtable_expand (fdtable_t *fdtable, uint32_t nr) uint32_t oldmax_fds = -1; int ret = -1; - if (fdtable == NULL || nr < 0) { + if (fdtable == NULL || nr > UINT32_MAX) { gf_log_callingfn ("fd", GF_LOG_ERROR, "invalid argument"); ret = EINVAL; goto out; diff --git a/libglusterfs/src/glusterfs.h b/libglusterfs/src/glusterfs.h index c419308f9..96a203770 100644 --- a/libglusterfs/src/glusterfs.h +++ b/libglusterfs/src/glusterfs.h @@ -162,7 +162,7 @@ /* TODO: Keeping it to 200, so that we can fit in 2KB buffer for auth data * in RPC server code, if there is ever need for having more aux-gids, then * we have to add aux-gid in payload of actors */ -#define GF_MAX_AUX_GROUPS 65536 +#define GF_MAX_AUX_GROUPS 65535 #define GF_UUID_BUF_SIZE 50 diff --git a/libglusterfs/src/logging.c b/libglusterfs/src/logging.c index f343731c7..2afa2f354 100644 --- a/libglusterfs/src/logging.c +++ b/libglusterfs/src/logging.c @@ -21,9 +21,16 @@ #include #include #include +#include +#ifdef HAVE_LIBINTL_H #include -#include +#endif + +#ifdef HAVE_BACKTRACE +#include +#endif + #include #include "gf-error-codes.h" @@ -40,14 +47,6 @@ #include "defaults.h" #include "glusterfs.h" -#ifdef GF_LINUX_HOST_OS -#include -#endif - -#ifdef HAVE_BACKTRACE -#include -#endif - static char *gf_level_strings[] = {"", /* NONE */ "M", /* EMERGENCY */ "A", /* ALERT */ @@ -374,9 +373,10 @@ gf_openlog (const char *ident, int option, int facility) /* TODO: Should check for errors here and return appropriately */ setlocale(LC_ALL, ""); +#ifdef HAVE_LIBINTL_H bindtextdomain("gluster", "/usr/share/locale"); textdomain("gluster"); - +#endif /* close the previous syslog if open as we are changing settings */ closelog (); openlog(ident, _option, _facility); diff --git a/libglusterfs/src/logging.h b/libglusterfs/src/logging.h index 210602c32..3c83ebbc0 100644 --- a/libglusterfs/src/logging.h +++ b/libglusterfs/src/logging.h @@ -24,17 +24,27 @@ #ifdef GF_DARWIN_HOST_OS #define GF_PRI_FSBLK "u" #define GF_PRI_DEV PRId32 -#define GF_PRI_NLINK PRIu16 +#define GF_PRI_INODE PRIu64 +#define GF_PRI_NLINK PRIu32 +#define GF_PRI_SECOND "ld" #define GF_PRI_SUSECONDS "06d" +#define GF_PRI_USEC "d" #else #define GF_PRI_FSBLK PRIu64 #define GF_PRI_DEV PRIu64 +#define GF_PRI_INODE PRIu64 #define GF_PRI_NLINK PRIu32 +#define GF_PRI_SECOND "lu" #define GF_PRI_SUSECONDS "06ld" #endif #define GF_PRI_BLKSIZE PRId32 #define GF_PRI_SIZET "zu" +#ifdef GF_DARWIN_HOST_OS +#define GF_PRI_TIME "ld" +#else +#define GF_PRI_TIME PRIu64 +#endif #if 0 /* Syslog definitions :-) */ diff --git a/libglusterfs/src/lvm-defaults.h b/libglusterfs/src/lvm-defaults.h new file mode 100644 index 000000000..4d3b010b2 --- /dev/null +++ b/libglusterfs/src/lvm-defaults.h @@ -0,0 +1,25 @@ +/* + Copyright (c) 2014 Red Hat, Inc. + This file is part of GlusterFS. + + This file is licensed to you under your choice of the GNU Lesser + General Public License, version 3 or any later version (LGPLv3 or + later), or the GNU General Public License, version 2 (GPLv2), in all + cases as published by the Free Software Foundation. +*/ + +#ifndef _LVM_DEFAULTS_H +#define _LVM_DEFAULTS_H + +#ifndef _CONFIG_H +#define _CONFIG_H +#include "config.h" +#endif + +#define LVM_RESIZE "/sbin/lvresize" +#define LVM_CREATE "/sbin/lvcreate" +#define LVM_CONVERT "/sbin/lvconvert" +#define LVM_REMOVE "/sbin/lvremove" +#define LVS "/sbin/lvs" + +#endif /* _LVM_DEFAULTS_H */ diff --git a/libglusterfs/src/options.c b/libglusterfs/src/options.c index a0881b4ad..f63c60476 100644 --- a/libglusterfs/src/options.c +++ b/libglusterfs/src/options.c @@ -79,7 +79,7 @@ xlator_option_validate_int (xlator_t *xl, const char *key, const char *value, goto out; } - if ((opt->validate == GF_OPT_VALIDATE_MIN)) { + if (opt->validate == GF_OPT_VALIDATE_MIN) { if (inputll < opt->min) { snprintf (errstr, 256, "'%lld' in 'option %s %s' is smaller than " @@ -88,8 +88,8 @@ xlator_option_validate_int (xlator_t *xl, const char *key, const char *value, gf_log (xl->name, GF_LOG_ERROR, "%s", errstr); goto out; } - } else if ((opt->validate == GF_OPT_VALIDATE_MAX)) { - if ((inputll > opt->max)) { + } else if (opt->validate == GF_OPT_VALIDATE_MAX) { + if (inputll > opt->max) { snprintf (errstr, 256, "'%lld' in 'option %s %s' is greater than " "maximum value '%.0f'", inputll, key, @@ -118,12 +118,12 @@ static int xlator_option_validate_sizet (xlator_t *xl, const char *key, const char *value, volume_option_t *opt, char **op_errstr) { - uint64_t size = 0; + size_t size = 0; int ret = 0; char errstr[256]; /* Check the range */ - if (gf_string2bytesize (value, &size) != 0) { + if (gf_string2bytesize_size (value, &size) != 0) { snprintf (errstr, 256, "invalid number format \"%s\" in option \"%s\"", value, key); @@ -142,13 +142,13 @@ xlator_option_validate_sizet (xlator_t *xl, const char *key, const char *value, if ((size < opt->min) || (size > opt->max)) { if ((strncmp (key, "cache-size", 10) == 0) && (size > opt->max)) { - snprintf (errstr, 256, "Cache size %"PRId64" is out of " + snprintf (errstr, 256, "Cache size %" GF_PRI_SIZET " is out of " "range [%.0f - %.0f]", size, opt->min, opt->max); gf_log (xl->name, GF_LOG_WARNING, "%s", errstr); } else { snprintf (errstr, 256, - "'%"PRId64"' in 'option %s %s' " + "'%" GF_PRI_SIZET "' in 'option %s %s' " "is out of range [%.0f - %.0f]", size, key, value, opt->min, opt->max); gf_log (xl->name, GF_LOG_ERROR, "%s", errstr); @@ -478,7 +478,7 @@ xlator_option_validate_double (xlator_t *xl, const char *key, const char *value, goto out; } - if ((opt->validate == GF_OPT_VALIDATE_MIN)) { + if (opt->validate == GF_OPT_VALIDATE_MIN) { if (input < opt->min) { snprintf (errstr, 256, "'%f' in 'option %s %s' is smaller than " @@ -487,8 +487,8 @@ xlator_option_validate_double (xlator_t *xl, const char *key, const char *value, gf_log (xl->name, GF_LOG_ERROR, "%s", errstr); goto out; } - } else if ((opt->validate == GF_OPT_VALIDATE_MAX)) { - if ((input > opt->max)) { + } else if (opt->validate == GF_OPT_VALIDATE_MAX) { + if (input > opt->max) { snprintf (errstr, 256, "'%f' in 'option %s %s' is greater than " "maximum value '%f'", input, key, @@ -617,12 +617,12 @@ out: static int gf_validate_size (const char *sizestr, volume_option_t *opt) { - uint64_t value = 0; + size_t value = 0; int ret = 0; GF_ASSERT (opt); - if (gf_string2bytesize (sizestr, &value) != 0 || + if (gf_string2bytesize_size (sizestr, &value) != 0 || value < opt->min || value % 512) { ret = -1; @@ -787,7 +787,7 @@ xlator_option_validate (xlator_t *xl, char *key, char *value, [GF_OPTION_TYPE_MAX] = NULL, }; - if (opt->type < 0 || opt->type >= GF_OPTION_TYPE_MAX) { + if (opt->type > GF_OPTION_TYPE_MAX) { gf_log (xl->name, GF_LOG_ERROR, "unknown option type '%d'", opt->type); goto out; @@ -1120,18 +1120,18 @@ pc_or_size (char *in, double *out) { double pc = 0; int ret = 0; - uint64_t size = 0; + size_t size = 0; if (gf_string2percent (in, &pc) == 0) { if (pc > 100.0) { - ret = gf_string2bytesize (in, &size); + ret = gf_string2bytesize_size (in, &size); if (!ret) *out = size; } else { *out = pc; } } else { - ret = gf_string2bytesize (in, &size); + ret = gf_string2bytesize_size (in, &size); if (!ret) *out = size; } @@ -1143,7 +1143,8 @@ DEFINE_INIT_OPT(uint64_t, uint64, gf_string2uint64); DEFINE_INIT_OPT(int64_t, int64, gf_string2int64); DEFINE_INIT_OPT(uint32_t, uint32, gf_string2uint32); DEFINE_INIT_OPT(int32_t, int32, gf_string2int32); -DEFINE_INIT_OPT(uint64_t, size, gf_string2bytesize); +DEFINE_INIT_OPT(size_t, size, gf_string2bytesize_size); +DEFINE_INIT_OPT(uint64_t, size_uint64, gf_string2bytesize_uint64); DEFINE_INIT_OPT(double, percent, gf_string2percent); DEFINE_INIT_OPT(double, percent_or_size, pc_or_size); DEFINE_INIT_OPT(gf_boolean_t, bool, gf_string2boolean); @@ -1158,7 +1159,8 @@ DEFINE_RECONF_OPT(uint64_t, uint64, gf_string2uint64); DEFINE_RECONF_OPT(int64_t, int64, gf_string2int64); DEFINE_RECONF_OPT(uint32_t, uint32, gf_string2uint32); DEFINE_RECONF_OPT(int32_t, int32, gf_string2int32); -DEFINE_RECONF_OPT(uint64_t, size, gf_string2bytesize); +DEFINE_RECONF_OPT(size_t, size, gf_string2bytesize_size); +DEFINE_RECONF_OPT(uint64_t, size_uint64, gf_string2bytesize_uint64); DEFINE_RECONF_OPT(double, percent, gf_string2percent); DEFINE_RECONF_OPT(double, percent_or_size, pc_or_size); DEFINE_RECONF_OPT(gf_boolean_t, bool, gf_string2boolean); diff --git a/libglusterfs/src/options.h b/libglusterfs/src/options.h index 134cc3602..05a3d4332 100644 --- a/libglusterfs/src/options.h +++ b/libglusterfs/src/options.h @@ -108,7 +108,8 @@ DECLARE_INIT_OPT(uint64_t, uint64); DECLARE_INIT_OPT(int64_t, int64); DECLARE_INIT_OPT(uint32_t, uint32); DECLARE_INIT_OPT(int32_t, int32); -DECLARE_INIT_OPT(uint64_t, size); +DECLARE_INIT_OPT(size_t, size); +DECLARE_INIT_OPT(uint64_t, size_uint64); DECLARE_INIT_OPT(double, percent); DECLARE_INIT_OPT(double, percent_or_size); DECLARE_INIT_OPT(gf_boolean_t, bool); @@ -163,8 +164,12 @@ xlator_option_init_##type (xlator_t *this, dict_t *options, char *key, \ THIS = this; \ ret = conv (value, val_p); \ THIS = old_THIS; \ - if (ret) \ + if (ret) { \ + gf_log (this->name, GF_LOG_INFO, \ + "option %s convertion failed value %s", \ + key, value); \ return ret; \ + } \ ret = xlator_option_validate (this, key, value, opt, NULL); \ return ret; \ } @@ -189,7 +194,8 @@ DECLARE_RECONF_OPT(uint64_t, uint64); DECLARE_RECONF_OPT(int64_t, int64); DECLARE_RECONF_OPT(uint32_t, uint32); DECLARE_RECONF_OPT(int32_t, int32); -DECLARE_RECONF_OPT(uint64_t, size); +DECLARE_RECONF_OPT(size_t, size); +DECLARE_RECONF_OPT(uint64_t, size_uint64); DECLARE_RECONF_OPT(double, percent); DECLARE_RECONF_OPT(double, percent_or_size); DECLARE_RECONF_OPT(gf_boolean_t, bool); diff --git a/libglusterfs/src/syscall.c b/libglusterfs/src/syscall.c index d1b9ef84c..723695867 100644 --- a/libglusterfs/src/syscall.c +++ b/libglusterfs/src/syscall.c @@ -19,6 +19,7 @@ #include #include #include +#include int sys_lstat (const char *path, struct stat *buf) @@ -41,12 +42,58 @@ sys_fstat (int fd, struct stat *buf) } +int +sys_fstatat(int dirfd, const char *pathname, struct stat *buf, int flags) +{ +#ifdef GF_DARWIN_HOST_OS + if (fchdir(dirfd) < 0) + return -1; + if(flags & AT_SYMLINK_NOFOLLOW) + return lstat(pathname, buf); + else + return stat(pathname, buf); +#else + return fstatat (dirfd, pathname, buf, flags); +#endif +} + + +int +sys_openat(int dirfd, const char *pathname, int flags, ...) +{ + mode_t mode = 0; + if (flags & O_CREAT) { + va_list ap; + va_start(ap, flags); + mode = va_arg(ap, int); + va_end(ap); + } + +#ifdef GF_DARWIN_HOST_OS + if (fchdir(dirfd) < 0) + return -1; + return open (pathname, flags, mode); +#else + return openat (dirfd, pathname, flags, mode); +#endif +} + DIR * sys_opendir (const char *name) { return opendir (name); } +int sys_mkdirat(int dirfd, const char *pathname, mode_t mode) +{ +#ifdef GF_DARWIN_HOST_OS + if(fchdir(dirfd) < 0) + return -1; + return mkdir(pathname, mode); +#else + return mkdirat (dirfd, pathname, mode); +#endif +} struct dirent * sys_readdir (DIR *dir) @@ -262,13 +309,43 @@ sys_fsync (int fd) int sys_fdatasync (int fd) { -#ifdef HAVE_FDATASYNC - return fdatasync (fd); +#ifdef GF_DARWIN_HOST_OS + return fcntl (fd, F_FULLFSYNC); #else - return 0; + return fdatasync (fd); #endif } +void +gf_add_prefix(const char *ns, const char *key, char **newkey) +{ + /* if we dont have any namespace, append USER NS */ + if (strncmp(key, XATTR_USER_PREFIX, XATTR_USER_PREFIX_LEN) && + strncmp(key, XATTR_TRUSTED_PREFIX, XATTR_TRUSTED_PREFIX_LEN) && + strncmp(key, XATTR_SECURITY_PREFIX, XATTR_TRUSTED_PREFIX_LEN) && + strncmp(key, XATTR_SYSTEM_PREFIX, XATTR_SYSTEM_PREFIX_LEN)) { + int ns_length = strlen(ns); + *newkey = GF_MALLOC(ns_length + strlen(key) + 10, + gf_common_mt_char); + strcpy(*newkey, ns); + strcat(*newkey, key); + } else { + *newkey = gf_strdup(key); + } +} + +void +gf_remove_prefix(const char *ns, const char *key, char **newkey) +{ + int ns_length = strlen(ns); + if (strncmp(key, ns, ns_length) == 0) { + *newkey = GF_MALLOC(-ns_length + strlen(key) + 10, + gf_common_mt_char); + strcpy(*newkey, key + ns_length); + } else { + *newkey = gf_strdup(key); + } +} int sys_lsetxattr (const char *path, const char *name, const void *value, @@ -289,8 +366,11 @@ sys_lsetxattr (const char *path, const char *name, const void *value, #endif #ifdef GF_DARWIN_HOST_OS + /* OS X clients will carry other flags, which will be used on a + OS X host, but masked out on others. GF assume NOFOLLOW on Linux, + enforcing */ return setxattr (path, name, value, size, 0, - flags|XATTR_NOFOLLOW); + (flags & ~XATTR_NOSECURITY) | XATTR_NOFOLLOW); #endif } @@ -313,12 +393,10 @@ sys_llistxattr (const char *path, char *list, size_t size) #endif #ifdef GF_DARWIN_HOST_OS - return listxattr (path, list, size, XATTR_NOFOLLOW); + return listxattr (path, list, size, XATTR_NOFOLLOW); #endif - } - ssize_t sys_lgetxattr (const char *path, const char *name, void *value, size_t size) { @@ -337,7 +415,7 @@ sys_lgetxattr (const char *path, const char *name, void *value, size_t size) #endif #ifdef GF_DARWIN_HOST_OS - return getxattr (path, name, value, size, 0, XATTR_NOFOLLOW); + return getxattr (path, name, value, size, 0, XATTR_NOFOLLOW); #endif } @@ -412,7 +490,7 @@ sys_fsetxattr (int filedes, const char *name, const void *value, #endif #ifdef GF_DARWIN_HOST_OS - return fsetxattr (filedes, name, value, size, 0, flags); + return fsetxattr (filedes, name, value, size, 0, flags & ~XATTR_NOSECURITY); #endif } @@ -435,7 +513,7 @@ sys_flistxattr (int filedes, char *list, size_t size) #endif #ifdef GF_DARWIN_HOST_OS - return flistxattr (filedes, list, size, XATTR_NOFOLLOW); + return flistxattr (filedes, list, size, XATTR_NOFOLLOW); #endif } @@ -491,4 +569,3 @@ sys_fallocate(int fd, int mode, off_t offset, off_t len) errno = ENOSYS; return -1; } - diff --git a/libglusterfs/src/syscall.h b/libglusterfs/src/syscall.h index f1c9f58c3..bbf23bef0 100644 --- a/libglusterfs/src/syscall.h +++ b/libglusterfs/src/syscall.h @@ -11,6 +11,41 @@ #ifndef __SYSCALL_H__ #define __SYSCALL_H__ +/* GF follows the Linux XATTR definition, which differs in Darwin. */ +#define GF_XATTR_CREATE 0x1 /* set value, fail if attr already exists */ +#define GF_XATTR_REPLACE 0x2 /* set value, fail if attr does not exist */ + +/* Linux kernel version 2.6.x don't have these defined + define if not defined */ + +#ifndef XATTR_SECURITY_PREFIX +#define XATTR_SECURITY_PREFIX "security." +#define XATTR_SECURITY_PREFIX_LEN (sizeof (XATTR_SECURITY_PREFIX) - 1) +#endif + +#ifndef XATTR_SYSTEM_PREFIX +#define XATTR_SYSTEM_PREFIX "system." +#define XATTR_SYSTEM_PREFIX_LEN (sizeof (XATTR_SYSTEM_PREFIX) - 1) +#endif + +#ifndef XATTR_TRUSTED_PREFIX +#define XATTR_TRUSTED_PREFIX "trusted." +#define XATTR_TRUSTED_PREFIX_LEN (sizeof (XATTR_TRUSTED_PREFIX) - 1) +#endif + +#ifndef XATTR_USER_PREFIX +#define XATTR_USER_PREFIX "user." +#define XATTR_USER_PREFIX_LEN (sizeof (XATTR_USER_PREFIX) - 1) +#endif + +#if defined(GF_DARWIN_HOST_OS) +#include +#define XATTR_DARWIN_NOSECURITY XATTR_NOSECURITY +#define XATTR_DARWIN_NODEFAULT XATTR_NODEFAULT +#define XATTR_DARWIN_SHOWCOMPRESSION XATTR_SHOWCOMPRESSION +#endif + + int sys_lstat (const char *path, struct stat *buf); @@ -20,8 +55,13 @@ sys_stat (const char *path, struct stat *buf); int sys_fstat (int fd, struct stat *buf); -DIR * -sys_opendir (const char *name); +int +sys_fstatat (int dirfd, const char *pathname, struct stat *buf, + int flags); +int +sys_openat (int dirfd, const char *pathname, int flags, ...); + +DIR *sys_opendir (const char *name); struct dirent * sys_readdir (DIR *dir); @@ -38,6 +78,9 @@ sys_mknod (const char *pathname, mode_t mode, dev_t dev); int sys_mkdir (const char *pathname, mode_t mode); +int +sys_mkdirat (int dirfd, const char *pathname, mode_t mode); + int sys_unlink (const char *pathname); @@ -107,6 +150,12 @@ sys_fsync (int fd); int sys_fdatasync (int fd); +void +gf_add_prefix(const char *ns, const char *key, char **newkey); + +void +gf_remove_prefix(const char *ns, const char *key, char **newkey); + int sys_lsetxattr (const char *path, const char *name, const void *value, size_t size, int flags); diff --git a/libglusterfs/src/timespec.c b/libglusterfs/src/timespec.c index a0c281a1e..5242ecc8c 100644 --- a/libglusterfs/src/timespec.c +++ b/libglusterfs/src/timespec.c @@ -10,54 +10,51 @@ #include #include -#if defined GF_LINUX_HOST_OS || defined GF_SOLARIS_HOST_OS || defined GF_BSD_HOST_OS #include #include -#endif #if defined GF_DARWIN_HOST_OS #include +static mach_timebase_info_data_t gf_timebase; #endif #include "logging.h" -#include "time.h" - - -void tv2ts (struct timeval tv, struct timespec *ts) -{ - ts->tv_sec = tv.tv_sec; - ts->tv_nsec = tv.tv_usec * 1000; -} +#include "timespec.h" void timespec_now (struct timespec *ts) { #if defined GF_LINUX_HOST_OS || defined GF_SOLARIS_HOST_OS || defined GF_BSD_HOST_OS - if (0 == clock_gettime(CLOCK_MONOTONIC, ts)) return; else { struct timeval tv; if (0 == gettimeofday(&tv, NULL)) - tv2ts(tv, ts); + TIMEVAL_TO_TIMESPEC(&tv, ts); } #elif defined GF_DARWIN_HOST_OS - mach_timebase_info_data_t tb = { 0 }; - static double timebase = 0.0; - uint64_t time = 0; - mach_timebase_info (&tb); + uint64_t time = mach_absolute_time(); + static double scaling = 0.0; - timebase *= info.numer; - timebase /= info.denom; + if (mach_timebase_info(&gf_timebase) != KERN_SUCCESS) { + gf_timebase.numer = 1; + gf_timebase.denom = 1; + } + if (gf_timebase.denom == 0) { + gf_timebase.numer = 1; + gf_timebase.denom = 1; + } - time = mach_absolute_time(); - time *= timebase; + scaling = (double) gf_timebase.numer / (double) gf_timebase.denom; + time *= scaling; ts->tv_sec = (time * NANO); - ts->tv_nsec = (time - (ts.tv_sec * GIGA)); + ts->tv_nsec = (time - (ts->tv_sec * GIGA)); #endif /* Platform verification */ - gf_log_callingfn ("timer", GF_LOG_DEBUG, "%"PRIu64".%09"PRIu64, + /* + gf_log_callingfn ("timer", GF_LOG_TRACE, "%"GF_PRI_TIME".%09"GF_PRI_TIME, ts->tv_sec, ts->tv_nsec); + */ } void timespec_adjust_delta (struct timespec *ts, struct timespec delta) diff --git a/libglusterfs/src/timespec.h b/libglusterfs/src/timespec.h index 490255df9..f37194b97 100644 --- a/libglusterfs/src/timespec.h +++ b/libglusterfs/src/timespec.h @@ -12,12 +12,12 @@ #define __INCLUDE_TIMESPEC_H__ #include +#include #define TS(ts) ((ts.tv_sec * 1000000000LL) + ts.tv_nsec) #define NANO (+1.0E-9) #define GIGA UINT64_C(1000000000) -void tv2ts (struct timeval tv, struct timespec *ts); void timespec_now (struct timespec *ts); void timespec_adjust_delta (struct timespec *ts, struct timespec delta); diff --git a/rpc/rpc-lib/src/Makefile.am b/rpc/rpc-lib/src/Makefile.am index 4cdeaad0b..ee2f27b25 100644 --- a/rpc/rpc-lib/src/Makefile.am +++ b/rpc/rpc-lib/src/Makefile.am @@ -2,10 +2,10 @@ lib_LTLIBRARIES = libgfrpc.la libgfrpc_la_SOURCES = auth-unix.c rpcsvc-auth.c rpcsvc.c auth-null.c \ rpc-transport.c xdr-rpc.c xdr-rpcclnt.c rpc-clnt.c auth-glusterfs.c \ - rpc-drc.c + rpc-drc.c $(CONTRIBDIR)/sunrpc/xdr_sizeof.c libgfrpc_la_LIBADD = $(top_builddir)/libglusterfs/src/libglusterfs.la -libgfrpc_la_LDFLAGS = -version-info $(LIBGFRPC_LT_VERSION) +libgfrpc_la_LDFLAGS = -version-info $(LIBGFRPC_LT_VERSION) $(GF_LDFLAGS) noinst_HEADERS = rpcsvc.h rpc-transport.h xdr-common.h xdr-rpc.h xdr-rpcclnt.h \ rpc-clnt.h rpcsvc-common.h protocol-common.h rpc-drc.h diff --git a/rpc/rpc-lib/src/rpc-clnt.c b/rpc/rpc-lib/src/rpc-clnt.c index e095c55b3..3106342e9 100644 --- a/rpc/rpc-lib/src/rpc-clnt.c +++ b/rpc/rpc-lib/src/rpc-clnt.c @@ -717,8 +717,9 @@ rpc_clnt_handle_cbk (struct rpc_clnt *clnt, rpc_transport_pollin_t *msg) } gf_log (clnt->conn.name, GF_LOG_TRACE, - "received rpc message (XID: 0x%lx, " - "Ver: %ld, Program: %ld, ProgVers: %ld, Proc: %ld) " + "receivd rpc message (XID: 0x%" GF_PRI_RPC_XID ", " + "Ver: %" GF_PRI_RPC_VERSION ", Program: %" GF_PRI_RPC_PROG_ID ", " + "ProgVers: %" GF_PRI_RPC_PROG_VERS ", Proc: %" GF_PRI_RPC_PROC ") " "from rpc-transport (%s)", rpc_call_xid (&rpcmsg), rpc_call_rpcvers (&rpcmsg), rpc_call_program (&rpcmsg), rpc_call_progver (&rpcmsg), rpc_call_progproc (&rpcmsg), @@ -1141,7 +1142,7 @@ xdr_serialize_glusterfs_auth (char *dest, struct auth_glusterfs_parms_v2 *au) { ssize_t ret = -1; XDR xdr; - uint64_t ngroups = 0; + u_long ngroups = 0; int max_groups = 0; if ((!dest) || (!au)) diff --git a/rpc/rpc-lib/src/rpc-drc.c b/rpc/rpc-lib/src/rpc-drc.c index 7e77e038e..0babb9bc4 100644 --- a/rpc/rpc-lib/src/rpc-drc.c +++ b/rpc/rpc-lib/src/rpc-drc.c @@ -460,7 +460,7 @@ rpcsvc_vacate_drc_entries (rpcsvc_drc_globals_t *drc) client = reply->client; - (void *)rb_delete (client->rbtree, reply); + rb_delete (client->rbtree, reply); rpcsvc_drc_op_destroy (drc, reply); rpcsvc_drc_client_unref (drc, client); diff --git a/rpc/rpc-lib/src/rpcsvc.c b/rpc/rpc-lib/src/rpcsvc.c index 34ee6f21b..f2cdfb238 100644 --- a/rpc/rpc-lib/src/rpcsvc.c +++ b/rpc/rpc-lib/src/rpcsvc.c @@ -423,9 +423,10 @@ rpcsvc_request_create (rpcsvc_t *svc, rpc_transport_t *trans, ret = -1; rpcsvc_request_init (svc, trans, &rpcmsg, progmsg, msg, req); - gf_log (GF_RPCSVC, GF_LOG_TRACE, "received rpc-message (XID: 0x%lx, " - "Ver: %ld, Program: %ld, ProgVers: %ld, Proc: %ld) from" - " rpc-transport (%s)", rpc_call_xid (&rpcmsg), + gf_log (GF_RPCSVC, GF_LOG_TRACE, "received rpc-message " + "(XID: 0x%" GF_PRI_RPC_XID ", Ver: %" GF_PRI_RPC_VERSION ", Program: %" GF_PRI_RPC_PROG_ID ", " + "ProgVers: %" GF_PRI_RPC_PROG_VERS ", Proc: %" GF_PRI_RPC_PROC ") " + "from rpc-transport (%s)", rpc_call_xid (&rpcmsg), rpc_call_rpcvers (&rpcmsg), rpc_call_program (&rpcmsg), rpc_call_progver (&rpcmsg), rpc_call_progproc (&rpcmsg), trans->name); @@ -434,8 +435,9 @@ rpcsvc_request_create (rpcsvc_t *svc, rpc_transport_t *trans, /* LOG- TODO: print rpc version, also print the peerinfo from transport */ gf_log (GF_RPCSVC, GF_LOG_ERROR, "RPC version not supported " - "(XID: 0x%lx, Ver: %ld, Prog: %ld, ProgVers: %ld, " - "Proc: %ld) from trans (%s)", rpc_call_xid (&rpcmsg), + "(XID: 0x%" GF_PRI_RPC_XID ", Ver: %" GF_PRI_RPC_VERSION ", Program: %" GF_PRI_RPC_PROG_ID ", " + "ProgVers: %" GF_PRI_RPC_PROG_VERS ", Proc: %" GF_PRI_RPC_PROC ") " + "from trans (%s)", rpc_call_xid (&rpcmsg), rpc_call_rpcvers (&rpcmsg), rpc_call_program (&rpcmsg), rpc_call_progver (&rpcmsg), rpc_call_progproc (&rpcmsg), trans->name); @@ -451,8 +453,9 @@ rpcsvc_request_create (rpcsvc_t *svc, rpc_transport_t *trans, */ rpcsvc_request_seterr (req, AUTH_ERROR); gf_log (GF_RPCSVC, GF_LOG_ERROR, "auth failed on request. " - "(XID: 0x%lx, Ver: %ld, Prog: %ld, ProgVers: %ld, " - "Proc: %ld) from trans (%s)", rpc_call_xid (&rpcmsg), + "(XID: 0x%" GF_PRI_RPC_XID ", Ver: %" GF_PRI_RPC_VERSION ", Program: %" GF_PRI_RPC_PROG_ID ", " + "ProgVers: %" GF_PRI_RPC_PROG_VERS ", Proc: %" GF_PRI_RPC_PROC ") " + "from trans (%s)", rpc_call_xid (&rpcmsg), rpc_call_rpcvers (&rpcmsg), rpc_call_program (&rpcmsg), rpc_call_progver (&rpcmsg), rpc_call_progproc (&rpcmsg), trans->name); @@ -797,15 +800,9 @@ err: return txrecord; } -static inline int -rpcsvc_get_callid (rpcsvc_t *rpc) -{ - return GF_UNIVERSAL_ANSWER; -} - int rpcsvc_fill_callback (int prognum, int progver, int procnum, int payload, - uint64_t xid, struct rpc_msg *request) + uint32_t xid, struct rpc_msg *request) { int ret = -1; @@ -870,9 +867,9 @@ out: return txrecord; } -struct iobuf * +static struct iobuf * rpcsvc_callback_build_record (rpcsvc_t *rpc, int prognum, int progver, - int procnum, size_t payload, uint64_t xid, + int procnum, size_t payload, u_long xid, struct iovec *recbuf) { struct rpc_msg request = {0, }; @@ -892,7 +889,7 @@ rpcsvc_callback_build_record (rpcsvc_t *rpc, int prognum, int progver, &request); if (ret == -1) { gf_log ("rpcsvc", GF_LOG_WARNING, "cannot build a rpc-request " - "xid (%"PRIu64")", xid); + "xid (%" GF_PRI_RPC_XID ")", xid); goto out; } @@ -939,7 +936,6 @@ rpcsvc_callback_submit (rpcsvc_t *rpc, rpc_transport_t *trans, rpc_transport_req_t req; int ret = -1; int proglen = 0; - uint64_t callid = 0; if (!rpc) { goto out; @@ -947,15 +943,14 @@ rpcsvc_callback_submit (rpcsvc_t *rpc, rpc_transport_t *trans, memset (&req, 0, sizeof (req)); - callid = rpcsvc_get_callid (rpc); - if (proghdr) { proglen += iov_length (proghdr, proghdrcount); } request_iob = rpcsvc_callback_build_record (rpc, prog->prognum, prog->progver, procnum, - proglen, callid, + proglen, + GF_UNIVERSAL_ANSWER, &rpchdr); if (!request_iob) { gf_log ("rpcsvc", GF_LOG_WARNING, @@ -1256,7 +1251,7 @@ rpcsvc_program_register_portmap (rpcsvc_program_t *newprog, uint32_t port) if (!(pmap_set (newprog->prognum, newprog->progver, IPPROTO_TCP, port))) { gf_log (GF_RPCSVC, GF_LOG_ERROR, "Could not register with" - " portmap"); + " portmap %d %d %u", newprog->prognum, newprog->progver, port); goto out; } diff --git a/rpc/rpc-lib/src/xdr-common.h b/rpc/rpc-lib/src/xdr-common.h index f221192ad..78c72e509 100644 --- a/rpc/rpc-lib/src/xdr-common.h +++ b/rpc/rpc-lib/src/xdr-common.h @@ -18,8 +18,8 @@ #include #include -#include #include +#include #include #ifdef __NetBSD__ @@ -68,7 +68,9 @@ enum gf_dump_procnum { #define xdr_u_quad_t xdr_u_int64_t #define xdr_quad_t xdr_int64_t #define xdr_uint32_t xdr_u_int32_t -#define uint64_t u_int64_t +#define xdr_uint64_t xdr_u_int64_t + +unsigned long xdr_sizeof (xdrproc_t func, void *data); #endif #if defined(__NetBSD__) diff --git a/rpc/rpc-lib/src/xdr-rpc.h b/rpc/rpc-lib/src/xdr-rpc.h index f5f4a941e..4663ef796 100644 --- a/rpc/rpc-lib/src/xdr-rpc.h +++ b/rpc/rpc-lib/src/xdr-rpc.h @@ -78,4 +78,21 @@ xdr_to_auth_unix_cred (char *msgbuf, int msglen, struct authunix_parms *au, #define rpc_call_verf_flavour(call) (rpc_opaque_auth_flavour ((&(call)->ru.RM_cmb.cb_verf))) #define rpc_call_verf_len(call) (rpc_opaque_auth_len ((&(call)->ru.RM_cmb.cb_verf))) + +#ifdef GF_DARWIN_HOST_OS +#define GF_PRI_RPC_XID PRIu32 +#define GF_PRI_RPC_VERSION PRIu32 +#define GF_PRI_RPC_PROG_ID PRIu32 +#define GF_PRI_RPC_PROG_VERS PRIu32 +#define GF_PRI_RPC_PROC PRIu32 +#define GF_PRI_RPC_PROC_VERSION PRIu32 +#else +#define GF_PRI_RPC_XID PRIu64 +#define GF_PRI_RPC_VERSION PRIu64 +#define GF_PRI_RPC_PROG_ID PRIu64 +#define GF_PRI_RPC_PROG_VERS PRIu64 +#define GF_PRI_RPC_PROC PRIu64 +#define GF_PRI_RPC_PROC_VERSION PRIu64 +#endif + #endif diff --git a/rpc/rpc-transport/rdma/src/Makefile.am b/rpc/rpc-transport/rdma/src/Makefile.am index 2bf7cf238..e66006e52 100644 --- a/rpc/rpc-transport/rdma/src/Makefile.am +++ b/rpc/rpc-transport/rdma/src/Makefile.am @@ -3,7 +3,7 @@ transport_LTLIBRARIES = rdma.la transportdir = $(libdir)/glusterfs/$(PACKAGE_VERSION)/rpc-transport -rdma_la_LDFLAGS = -module -avoid-version +rdma_la_LDFLAGS = -module -avoid-version -nostartfiles rdma_la_SOURCES = rdma.c name.c rdma_la_LIBADD = $(top_builddir)/libglusterfs/src/libglusterfs.la \ @@ -11,7 +11,7 @@ rdma_la_LIBADD = $(top_builddir)/libglusterfs/src/libglusterfs.la \ noinst_HEADERS = rdma.h name.h -I$(top_srcdir)/libglusterfs/src -I$(top_srcdir)/rpc/rpc-lib/src/ \ - -I$(top_srcdir)/xlators/protocol/lib/src/ -shared -nostartfiles $(GF_CFLAGS) + -I$(top_srcdir)/xlators/protocol/lib/src/ -shared $(GF_CFLAGS) AM_CPPFLAGS = $(GF_CPPFLAGS) \ -I$(top_srcdir)/libglusterfs/src -I$(top_srcdir)/rpc/rpc-lib/src/ \ diff --git a/rpc/rpc-transport/rdma/src/rdma.c b/rpc/rpc-transport/rdma/src/rdma.c index 701abdba7..c7510f6bb 100644 --- a/rpc/rpc-transport/rdma/src/rdma.c +++ b/rpc/rpc-transport/rdma/src/rdma.c @@ -2027,7 +2027,7 @@ out: } -inline int32_t +static inline int32_t __gf_rdma_register_local_mr_for_rdma (gf_rdma_peer_t *peer, struct iovec *vector, int count, gf_rdma_post_context_t *ctx) @@ -3074,7 +3074,7 @@ out: } -inline int32_t +static inline int32_t gf_rdma_decode_error_msg (gf_rdma_peer_t *peer, gf_rdma_post_t *post, size_t bytes_in_post) { @@ -3616,7 +3616,7 @@ out: } -inline int32_t +static inline int32_t gf_rdma_recv_request (gf_rdma_peer_t *peer, gf_rdma_post_t *post, gf_rdma_read_chunk_t *readch) { diff --git a/rpc/rpc-transport/socket/src/socket.c b/rpc/rpc-transport/socket/src/socket.c index c5e8b889f..6f566e493 100644 --- a/rpc/rpc-transport/socket/src/socket.c +++ b/rpc/rpc-transport/socket/src/socket.c @@ -3346,7 +3346,7 @@ reconfigure (rpc_transport_t *this, dict_t *options) optstr = NULL; if (dict_get_str (this->options, "tcp-window-size", &optstr) == 0) { - if (gf_string2bytesize (optstr, &windowsize) != 0) { + if (gf_string2uint64 (optstr, &windowsize) != 0) { gf_log (this->name, GF_LOG_ERROR, "invalid number format: %s", optstr); goto out; @@ -3467,7 +3467,7 @@ socket_init (rpc_transport_t *this) optstr = NULL; if (dict_get_str (this->options, "tcp-window-size", &optstr) == 0) { - if (gf_string2bytesize (optstr, &windowsize) != 0) { + if (gf_string2uint64 (optstr, &windowsize) != 0) { gf_log (this->name, GF_LOG_ERROR, "invalid number format: %s", optstr); return -1; diff --git a/rpc/xdr/src/nlm4-xdr.h b/rpc/xdr/src/nlm4-xdr.h index 4391a4790..8545694a6 100644 --- a/rpc/xdr/src/nlm4-xdr.h +++ b/rpc/xdr/src/nlm4-xdr.h @@ -17,13 +17,7 @@ #define _NLM_H_RPCGEN #include - -#if defined(__NetBSD__) -#define xdr_u_quad_t xdr_u_int64_t -#define xdr_quad_t xdr_int64_t -#define xdr_uint32_t xdr_u_int32_t -#define xdr_uint64_t xdr_u_int64_t -#endif +#include "xdr-common.h" #ifdef __cplusplus extern "C" { @@ -33,6 +27,14 @@ extern "C" { #define LM_MAXSTRLEN 1024 #define MAXNAMELEN 1025 +#if defined(GF_DARWIN_HOST_OS) +#define xdr_u_quad_t xdr_u_int64_t +#define xdr_quad_t xdr_int64_t +#define xdr_uint32_t xdr_u_int32_t +#define xdr_uint64_t xdr_u_int64_t +#define uint64_t u_int64_t +#endif + #if defined(__NetBSD__) #define xdr_u_quad_t xdr_u_int64_t #define xdr_quad_t xdr_int64_t diff --git a/rpc/xdr/src/xdr-generic.c b/rpc/xdr/src/xdr-generic.c index 58d1ee77e..ee29f3dfa 100644 --- a/rpc/xdr/src/xdr-generic.c +++ b/rpc/xdr/src/xdr-generic.c @@ -24,7 +24,7 @@ xdr_serialize_generic (struct iovec outmsg, void *res, xdrproc_t proc) xdrmem_create (&xdr, outmsg.iov_base, (unsigned int)outmsg.iov_len, XDR_ENCODE); - if (!proc (&xdr, res)) { + if (!proc (&xdr, res, 0)) { ret = -1; goto ret; } @@ -48,7 +48,7 @@ xdr_to_generic (struct iovec inmsg, void *args, xdrproc_t proc) xdrmem_create (&xdr, inmsg.iov_base, (unsigned int)inmsg.iov_len, XDR_DECODE); - if (!proc (&xdr, args)) { + if (!proc (&xdr, args, 0)) { ret = -1; goto ret; } @@ -72,7 +72,7 @@ xdr_to_generic_payload (struct iovec inmsg, void *args, xdrproc_t proc, xdrmem_create (&xdr, inmsg.iov_base, (unsigned int)inmsg.iov_len, XDR_DECODE); - if (!proc (&xdr, args)) { + if (!proc (&xdr, args, 0)) { ret = -1; goto ret; } diff --git a/rpc/xdr/src/xdr-nfs3.h b/rpc/xdr/src/xdr-nfs3.h index 6f6b0e1f9..3861771e2 100644 --- a/rpc/xdr/src/xdr-nfs3.h +++ b/rpc/xdr/src/xdr-nfs3.h @@ -95,6 +95,7 @@ enum nfsstat3 { NFS3ERR_SERVERFAULT = 10006, NFS3ERR_BADTYPE = 10007, NFS3ERR_JUKEBOX = 10008, + NFS3ERR_END_OF_LIST = -1, }; typedef enum nfsstat3 nfsstat3; diff --git a/tests/basic/pgfid-feat.t b/tests/basic/pgfid-feat.t index 8784cc7bf..3978f9c97 100644 --- a/tests/basic/pgfid-feat.t +++ b/tests/basic/pgfid-feat.t @@ -24,11 +24,10 @@ TEST $CLI volume set $V0 build-pgfid on; TEST mkdir $M0/a; TEST touch $M0/a/b; -getfattr -e text -n glusterfs.ancestry.path "$M0/a/b" | grep "^glusterfs.ancestry.path" | cut -d"=" -f2 | tr -d \"; EXPECT "/a/b" get_ancestry_path "/a/b"; TEST $CLI volume set $V0 build-pgfid off; -TEST ! getfattr -e text -n "glusterfs.ancestry.path" $M0/a/b; +EXPECT "" get_ancestry_path "/a/b"; TEST $CLI volume stop $V0; TEST $CLI volume delete $V0; diff --git a/tests/basic/volume-snapshot.t b/tests/basic/volume-snapshot.t index c826631ca..e6c47f0d5 100755 --- a/tests/basic/volume-snapshot.t +++ b/tests/basic/volume-snapshot.t @@ -5,6 +5,7 @@ . $(dirname $0)/../cluster.rc . $(dirname $0)/../snapshot.rc + V1="patchy2" function create_volumes() { @@ -48,6 +49,7 @@ function restore_snapshots() { } cleanup; +TEST verify_lvm_version; #Create cluster with 3 nodes TEST launch_cluster 3; TEST setup_lvm 3 @@ -92,4 +94,3 @@ TEST ! volume_exists $V0 TEST ! volume_exists $V1 cleanup; - diff --git a/tests/bugs/bug-1045333.t b/tests/bugs/bug-1045333.t index 8f4798ebc..f5985d29c 100755 --- a/tests/bugs/bug-1045333.t +++ b/tests/bugs/bug-1045333.t @@ -4,6 +4,7 @@ . $(dirname $0)/../snapshot.rc cleanup; +TEST verify_lvm_version; TEST glusterd; TEST pidof glusterd; diff --git a/tests/bugs/bug-1049834.t b/tests/bugs/bug-1049834.t index c1b126ba1..eea3297ed 100755 --- a/tests/bugs/bug-1049834.t +++ b/tests/bugs/bug-1049834.t @@ -6,7 +6,7 @@ . $(dirname $0)/../snapshot.rc cleanup; - +TEST verify_lvm_version TEST launch_cluster 2 TEST setup_lvm 2 diff --git a/tests/snapshot.rc b/tests/snapshot.rc index 440059fc1..87ea0df91 100755 --- a/tests/snapshot.rc +++ b/tests/snapshot.rc @@ -46,6 +46,13 @@ function init_lvm() { return 0 } +function verify_lvm_version() { + if `/sbin/lvcreate --help | grep -q thin`; then + return 0; + fi + return 1; +} + function setup_lvm() { init_lvm $@ || return 1 _setup_lvm @@ -287,4 +294,3 @@ function volume_exists() { return 0 fi } - diff --git a/xlators/cluster/afr/src/afr-inode-write.c b/xlators/cluster/afr/src/afr-inode-write.c index 3013ae730..00e0d2676 100644 --- a/xlators/cluster/afr/src/afr-inode-write.c +++ b/xlators/cluster/afr/src/afr-inode-write.c @@ -37,7 +37,6 @@ #include "afr.h" #include "afr-transaction.h" -//#include "afr-self-heal-common.h" static void @@ -1750,5 +1749,3 @@ out: } /* }}} */ - - diff --git a/xlators/cluster/afr/src/afr-self-heal-entry.c b/xlators/cluster/afr/src/afr-self-heal-entry.c index 9605d69f4..9e714b026 100644 --- a/xlators/cluster/afr/src/afr-self-heal-entry.c +++ b/xlators/cluster/afr/src/afr-self-heal-entry.c @@ -585,12 +585,10 @@ afr_selfheal_data_opendir (xlator_t *this, inode_t *inode) } loc_wipe (&loc); - - return fd; + return fd; } - int afr_selfheal_entry (call_frame_t *frame, xlator_t *this, inode_t *inode) { diff --git a/xlators/cluster/afr/src/afr-self-heal-metadata.c b/xlators/cluster/afr/src/afr-self-heal-metadata.c index b31a33237..83628297f 100644 --- a/xlators/cluster/afr/src/afr-self-heal-metadata.c +++ b/xlators/cluster/afr/src/afr-self-heal-metadata.c @@ -18,7 +18,6 @@ #include "afr-self-heal.h" #include "byte-order.h" - #define AFR_HEAL_ATTR (GF_SET_ATTR_UID|GF_SET_ATTR_GID|GF_SET_ATTR_MODE) int diff --git a/xlators/cluster/afr/src/afr.c b/xlators/cluster/afr/src/afr.c index 5e12910b7..ead08425f 100644 --- a/xlators/cluster/afr/src/afr.c +++ b/xlators/cluster/afr/src/afr.c @@ -185,7 +185,7 @@ reconfigure (xlator_t *this, dict_t *options) uint32, out); GF_OPTION_RECONF (AFR_SH_READDIR_SIZE_KEY, priv->sh_readdir_size, - options, size, out); + options, size_uint64, out); /* Reset this so we re-discover in case the topology changed. */ GF_OPTION_RECONF ("ensure-durability", priv->ensure_durability, options, bool, out); @@ -331,7 +331,7 @@ init (xlator_t *this) GF_OPTION_INIT ("eager-lock", priv->eager_lock, bool, out); GF_OPTION_INIT ("quorum-type", qtype, str, out); GF_OPTION_INIT ("quorum-count", priv->quorum_count, uint32, out); - GF_OPTION_INIT (AFR_SH_READDIR_SIZE_KEY, priv->sh_readdir_size, size, + GF_OPTION_INIT (AFR_SH_READDIR_SIZE_KEY, priv->sh_readdir_size, size_uint64, out); fix_quorum_options(this,priv,qtype); @@ -436,7 +436,7 @@ fini (xlator_t *this) priv = this->private; this->private = NULL; afr_priv_destroy (priv); - if (this->itable);//I dont see any destroy func + //if (this->itable);//I dont see any destroy func return 0; } diff --git a/xlators/cluster/dht/src/Makefile.am b/xlators/cluster/dht/src/Makefile.am index 174bea841..3fc29bf81 100644 --- a/xlators/cluster/dht/src/Makefile.am +++ b/xlators/cluster/dht/src/Makefile.am @@ -1,4 +1,3 @@ - xlator_LTLIBRARIES = dht.la nufa.la switch.la xlatordir = $(libdir)/glusterfs/$(PACKAGE_VERSION)/xlator/cluster diff --git a/xlators/cluster/dht/src/dht-common.h b/xlators/cluster/dht/src/dht-common.h index d74d0dfd4..2ece28a61 100644 --- a/xlators/cluster/dht/src/dht-common.h +++ b/xlators/cluster/dht/src/dht-common.h @@ -47,7 +47,7 @@ struct dht_layout { int gen; int type; int ref; /* use with dht_conf_t->layout_lock */ - int search_unhashed; + gf_boolean_t search_unhashed; struct { int err; /* 0 = normal -1 = dir exists and no xattr @@ -263,7 +263,7 @@ struct dht_conf { int gen; dht_du_t *du_stats; double min_free_disk; - double min_free_inodes; + double min_free_inodes; char disk_unit; int32_t refresh_interval; gf_boolean_t unhashed_sticky_bit; diff --git a/xlators/cluster/dht/src/dht-shared.c b/xlators/cluster/dht/src/dht-shared.c index 36c073973..f2e7467ab 100644 --- a/xlators/cluster/dht/src/dht-shared.c +++ b/xlators/cluster/dht/src/dht-shared.c @@ -366,7 +366,6 @@ dht_reconfigure (xlator_t *this, dict_t *options) " lookup-unhashed should be boolean," " not (%s), defaulting to (%d)", temp_str, conf->search_unhashed); - //return -1; ret = -1; goto out; } @@ -449,11 +448,11 @@ gf_defrag_pattern_list_fill (xlator_t *this, gf_defrag_info_t *defrag, char *dat if (!pattern) goto out; if (!num) { - if (gf_string2bytesize(pattern, &pattern_list->size) + if (gf_string2bytesize_uint64(pattern, &pattern_list->size) == 0) { pattern = "*"; } - } else if (gf_string2bytesize (num, &pattern_list->size) != 0) { + } else if (gf_string2bytesize_uint64 (num, &pattern_list->size) != 0) { gf_log (this->name, GF_LOG_ERROR, "invalid number format \"%s\"", num); goto out; diff --git a/xlators/cluster/stripe/src/Makefile.am b/xlators/cluster/stripe/src/Makefile.am index 2d151422a..4268d6f03 100644 --- a/xlators/cluster/stripe/src/Makefile.am +++ b/xlators/cluster/stripe/src/Makefile.am @@ -1,4 +1,3 @@ - xlator_LTLIBRARIES = stripe.la xlatordir = $(libdir)/glusterfs/$(PACKAGE_VERSION)/xlator/cluster diff --git a/xlators/cluster/stripe/src/stripe-helpers.c b/xlators/cluster/stripe/src/stripe-helpers.c index a047d4a2e..3c12809d6 100644 --- a/xlators/cluster/stripe/src/stripe-helpers.c +++ b/xlators/cluster/stripe/src/stripe-helpers.c @@ -13,6 +13,7 @@ #include "stripe.h" #include "byte-order.h" #include "mem-types.h" +#include "logging.h" void stripe_local_wipe (stripe_local_t *local) @@ -260,8 +261,8 @@ stripe_fill_pathinfo_xattr (xlator_t *this, stripe_local_t *local, goto out; } - (void) snprintf (stripe_size_str, 20, "%ld", - (local->fctx) ? local->fctx->stripe_size : 0); + (void) snprintf (stripe_size_str, 20, "%"PRId64, + (long long) (local->fctx) ? local->fctx->stripe_size : 0); /* extra bytes for decorations (brackets and <>'s) */ padding = strlen (this->name) + strlen (STRIPE_PATHINFO_HEADER) @@ -504,7 +505,7 @@ set_default_block_size (stripe_private_t *priv, char *num) GF_VALIDATE_OR_GOTO (THIS->name, num, out); - if (gf_string2bytesize (num, &priv->block_size) != 0) { + if (gf_string2bytesize_uint64 (num, &priv->block_size) != 0) { gf_log (THIS->name, GF_LOG_ERROR, "invalid number format \"%s\"", num); goto out; @@ -554,7 +555,7 @@ set_stripe_block_size (xlator_t *this, stripe_private_t *priv, char *data) if (ret) goto out; } - if (gf_string2bytesize (num, &stripe_opt->block_size) != 0) { + if (gf_string2bytesize_uint64 (num, &stripe_opt->block_size) != 0) { gf_log (this->name, GF_LOG_ERROR, "invalid number format \"%s\"", num); goto out; @@ -674,4 +675,3 @@ uncoalesced_size(off_t size, uint64_t stripe_size, int stripe_count, return size; } - diff --git a/xlators/cluster/stripe/src/stripe.c b/xlators/cluster/stripe/src/stripe.c index 79e80b513..0ebea8168 100644 --- a/xlators/cluster/stripe/src/stripe.c +++ b/xlators/cluster/stripe/src/stripe.c @@ -4459,7 +4459,7 @@ stripe_is_bd (dict_t *this, char *key, data_t *value, void *data) return 0; } -inline gf_boolean_t +static inline gf_boolean_t stripe_setxattr_is_bd (dict_t *dict) { gf_boolean_t is_bd = _gf_false; @@ -4628,7 +4628,7 @@ out: return ret; } -inline gf_boolean_t +static inline gf_boolean_t stripe_fsetxattr_is_special (dict_t *dict) { gf_boolean_t is_spl = _gf_false; @@ -5080,7 +5080,7 @@ reconfigure (xlator_t *this, dict_t *options) goto unlock; } - if (gf_string2bytesize (opt->default_value, &priv->block_size)){ + if (gf_string2bytesize_uint64 (opt->default_value, &priv->block_size)){ gf_log (this->name, GF_LOG_ERROR, "Unable to set default block-size "); ret = -1; @@ -5187,7 +5187,7 @@ init (xlator_t *this) ret = -1; goto unlock; } - if (gf_string2bytesize (opt->default_value, &priv->block_size)){ + if (gf_string2bytesize_uint64 (opt->default_value, &priv->block_size)){ gf_log (this->name, GF_LOG_ERROR, "Unable to set default block-size "); ret = -1; @@ -5601,7 +5601,7 @@ err: return 0; } -inline gf_boolean_t +static inline gf_boolean_t stripe_is_special_xattr (const char *name) { gf_boolean_t is_spl = _gf_false; diff --git a/xlators/debug/io-stats/src/io-stats.c b/xlators/debug/io-stats/src/io-stats.c index d63fbb26c..5b4c833fb 100644 --- a/xlators/debug/io-stats/src/io-stats.c +++ b/xlators/debug/io-stats/src/io-stats.c @@ -509,7 +509,7 @@ out: return 0; } -inline int +static inline int ios_stats_cleanup (xlator_t *this, inode_t *inode) { diff --git a/xlators/debug/trace/src/trace.c b/xlators/debug/trace/src/trace.c index c9d839356..1efd50e65 100644 --- a/xlators/debug/trace/src/trace.c +++ b/xlators/debug/trace/src/trace.c @@ -18,6 +18,44 @@ * Very helpful translator for debugging. */ +static inline void +trace_stat_to_str(struct iatt *buf, char *str) +{ + char atime_buf[256] = {0,}; + char mtime_buf[256] = {0,}; + char ctime_buf[256] = {0,}; + uint64_t ia_time = 0; + + if (!buf) + return; + + ia_time = buf->ia_atime; + strftime (atime_buf, 256, "[%b %d %H:%M:%S]", + localtime ((time_t *)&ia_time)); + ia_time = buf->ia_mtime; + strftime (mtime_buf, 256, "[%b %d %H:%M:%S]", + localtime ((time_t *)&ia_time)); + + ia_time = buf->ia_ctime; + strftime (ctime_buf, 256, "[%b %d %H:%M:%S]", + localtime ((time_t *)&ia_time)); + + snprintf (str, sizeof (str), + "gfid=%s ino=%"PRIu64", mode=%o, " + "nlink=%"GF_PRI_NLINK", uid=%u, " + "gid=%u, size=%"PRIu64", " + "blocks=%"PRIu64", atime=%s, " + "mtime=%s, ctime=%s", + uuid_utoa (buf->ia_gfid), + buf->ia_ino, + st_mode_from_ia (buf->ia_prot, buf->ia_type), + buf->ia_nlink, buf->ia_uid, + buf->ia_gid, buf->ia_size, + buf->ia_blocks, atime_buf, + mtime_buf, ctime_buf); +} + + int dump_history_trace (circular_buffer_t *cb, void *data) { diff --git a/xlators/debug/trace/src/trace.h b/xlators/debug/trace/src/trace.h index 045eefb36..62d1bc9c9 100644 --- a/xlators/debug/trace/src/trace.h +++ b/xlators/debug/trace/src/trace.h @@ -59,40 +59,3 @@ typedef struct { "%s", _string); \ } \ } while (0); - -#define trace_stat_to_str(buf, statstr) \ - do { \ - char atime_buf[256] = {0,}; \ - char mtime_buf[256] = {0,}; \ - char ctime_buf[256] = {0,}; \ - uint64_t ia_time = 0; \ - \ - if (!buf) \ - break; \ - \ - ia_time = buf->ia_atime; \ - strftime (atime_buf, 256, "[%b %d %H:%M:%S]", \ - localtime ((time_t *)&ia_time)); \ - \ - ia_time = buf->ia_mtime; \ - strftime (mtime_buf, 256, "[%b %d %H:%M:%S]", \ - localtime ((time_t *)&ia_time)); \ - \ - ia_time = buf->ia_ctime; \ - strftime (ctime_buf, 256, "[%b %d %H:%M:%S]", \ - localtime ((time_t *)&ia_time)); \ - \ - snprintf (statstr, sizeof (statstr), \ - "gfid=%s ino=%"PRIu64", mode=%o, " \ - "nlink=%"GF_PRI_NLINK", uid=%u, " \ - "gid=%u, size=%"PRIu64", " \ - "blocks=%"PRIu64", atime=%s, " \ - "mtime=%s, ctime=%s", \ - uuid_utoa (buf->ia_gfid), buf->ia_ino, \ - st_mode_from_ia (buf->ia_prot, \ - buf->ia_type), \ - buf->ia_nlink, buf->ia_uid, \ - buf->ia_gid, buf->ia_size, \ - buf->ia_blocks, atime_buf, \ - mtime_buf, ctime_buf); \ - } while (0); diff --git a/xlators/encryption/crypt/src/crypt.c b/xlators/encryption/crypt/src/crypt.c index 1abdad31d..13b1bd962 100644 --- a/xlators/encryption/crypt/src/crypt.c +++ b/xlators/encryption/crypt/src/crypt.c @@ -4169,9 +4169,9 @@ int32_t master_set_block_size (xlator_t *this, crypt_private_t *priv, if (options != NULL) GF_OPTION_RECONF("block-size", block_size, options, - size, error); + size_uint64, error); else - GF_OPTION_INIT("block-size", block_size, size, error); + GF_OPTION_INIT("block-size", block_size, size_uint64, error); switch (block_size) { case 512: @@ -4224,9 +4224,9 @@ static int master_set_data_key_size (xlator_t *this, crypt_private_t *priv, if (options != NULL) GF_OPTION_RECONF("data-key-size", key_size, options, - size, error); + uint64, error); else - GF_OPTION_INIT("data-key-size", key_size, size, error); + GF_OPTION_INIT("data-key-size", key_size, uint64, error); ret = data_cipher_algs[master->m_alg][master->m_mode].check_key(key_size); if (ret) { diff --git a/xlators/encryption/crypt/src/crypt.h b/xlators/encryption/crypt/src/crypt.h index ff8eb571b..eb7291f13 100644 --- a/xlators/encryption/crypt/src/crypt.h +++ b/xlators/encryption/crypt/src/crypt.h @@ -22,6 +22,7 @@ #include #include #include "crypt-mem-types.h" +#include "compat.h" #define CRYPT_XLATOR_ID (0) @@ -38,13 +39,17 @@ #define MASTER_VOL_KEY_SIZE (32) #define NMTD_VOL_KEY_SIZE (16) -#ifdef __NetBSD__ +#if defined(__NetBSD__) typedef off_t loff_t; #endif +#if defined(GF_DARWIN_HOST_OS) +typedef uint64_t loff_t; +#endif + struct crypt_key { uint32_t len; - const char *label; + const char *label; }; /* @@ -124,7 +129,7 @@ struct master_cipher_info { * master key */ unsigned char m_key[MASTER_VOL_KEY_SIZE]; - /* + /* * volume key for oid authentication */ unsigned char m_nmtd_key[NMTD_VOL_KEY_SIZE]; @@ -870,8 +875,8 @@ static inline linkop_unwind_handler_t linkop_unwind_dispatch(glusterfs_fop_t fop return rename_unwind; default: gf_log("crypt", GF_LOG_ERROR, "Bad link operation %d", fop); - return NULL; - } + return NULL; + } } static inline mtd_op_t linkop_mtdop_dispatch(glusterfs_fop_t fop) diff --git a/xlators/features/changelog/src/Makefile.am b/xlators/features/changelog/src/Makefile.am index 54c21ac21..c5d5e100e 100644 --- a/xlators/features/changelog/src/Makefile.am +++ b/xlators/features/changelog/src/Makefile.am @@ -12,7 +12,7 @@ changelog_la_SOURCES = changelog.c changelog-rt.c changelog-helpers.c \ changelog_la_LIBADD = $(top_builddir)/libglusterfs/src/libglusterfs.la AM_CPPFLAGS = $(GF_CPPFLAGS) -I$(top_srcdir)/libglusterfs/src -fPIC -D_FILE_OFFSET_BITS=64 \ - -D_GNU_SOURCE -D$(GF_HOST_OS) -shared -nostartfiles -DDATADIR=\"$(localstatedir)\" + -D_GNU_SOURCE -D$(GF_HOST_OS) -shared -DDATADIR=\"$(localstatedir)\" AM_CFLAGS = -Wall $(GF_CFLAGS) diff --git a/xlators/features/changelog/src/changelog-helpers.h b/xlators/features/changelog/src/changelog-helpers.h index b441f7068..53588f55e 100644 --- a/xlators/features/changelog/src/changelog-helpers.h +++ b/xlators/features/changelog/src/changelog-helpers.h @@ -268,9 +268,11 @@ typedef struct { void changelog_thread_cleanup (xlator_t *this, pthread_t thr_id); -inline void * + +void * changelog_get_usable_buffer (changelog_local_t *local); -inline void + +void changelog_set_usable_record_and_length (changelog_local_t *local, size_t len, int xr); void @@ -290,16 +292,16 @@ int changelog_inject_single_event (xlator_t *this, changelog_priv_t *priv, changelog_log_data_t *cld); -inline size_t +size_t changelog_entry_length (); -inline int +int changelog_write (int fd, char *buffer, size_t len); int changelog_write_change (changelog_priv_t *priv, char *buffer, size_t len); -inline int +int changelog_handle_change (xlator_t *this, changelog_priv_t *priv, changelog_log_data_t *cld); -inline void +void changelog_update (xlator_t *this, changelog_priv_t *priv, changelog_local_t *local, changelog_log_type type); void * diff --git a/xlators/features/compress/src/Makefile.am b/xlators/features/compress/src/Makefile.am index 0bf757c06..263b21b78 100644 --- a/xlators/features/compress/src/Makefile.am +++ b/xlators/features/compress/src/Makefile.am @@ -10,7 +10,7 @@ cdc_la_SOURCES = cdc.c cdc-helper.c cdc_la_LIBADD = $(top_builddir)/libglusterfs/src/libglusterfs.la AM_CPPFLAGS = $(GF_CPPFLAGS) -I$(top_srcdir)/libglusterfs/src -fPIC -D_FILE_OFFSET_BITS=64 -D_GNU_SOURCE -D$(GF_HOST_OS) \ --shared -nostartfiles $(LIBZ_CFLAGS) +-shared $(LIBZ_CFLAGS) AM_CFLAGS = -Wall $(GF_CFLAGS) diff --git a/xlators/features/index/src/index.c b/xlators/features/index/src/index.c index 5c1c65fbd..4b2eb2e29 100644 --- a/xlators/features/index/src/index.c +++ b/xlators/features/index/src/index.c @@ -497,13 +497,13 @@ fop_fxattrop_index_action (xlator_t *this, inode_t *inode, dict_t *xattr) _xattrop_index_action (this, inode, xattr); } -inline gf_boolean_t +static inline gf_boolean_t index_xattrop_track (loc_t *loc, gf_xattrop_flags_t flags, dict_t *dict) { return (flags == GF_XATTROP_ADD_ARRAY); } -inline gf_boolean_t +static inline gf_boolean_t index_fxattrop_track (fd_t *fd, gf_xattrop_flags_t flags, dict_t *dict) { return (flags == GF_XATTROP_ADD_ARRAY); diff --git a/xlators/features/locks/src/inodelk.c b/xlators/features/locks/src/inodelk.c index e7093e60e..2d9aa83ec 100644 --- a/xlators/features/locks/src/inodelk.c +++ b/xlators/features/locks/src/inodelk.c @@ -35,7 +35,7 @@ __pl_inodelk_ref (pl_inode_lock_t *lock) lock->ref++; } -void +inline void __pl_inodelk_unref (pl_inode_lock_t *lock) { lock->ref--; diff --git a/xlators/features/locks/src/posix.c b/xlators/features/locks/src/posix.c index 2db327687..337623d65 100644 --- a/xlators/features/locks/src/posix.c +++ b/xlators/features/locks/src/posix.c @@ -294,7 +294,7 @@ pl_locks_by_fd (pl_inode_t *pl_inode, fd_t *fd) { list_for_each_entry (l, &pl_inode->ext_list, list) { - if ((l->fd_num == fd_to_fdnum(fd))) { + if (l->fd_num == fd_to_fdnum(fd)) { found = 1; break; } @@ -319,7 +319,7 @@ delete_locks_of_fd (xlator_t *this, pl_inode_t *pl_inode, fd_t *fd) { list_for_each_entry_safe (l, tmp, &pl_inode->ext_list, list) { - if ((l->fd_num == fd_to_fdnum(fd))) { + if (l->fd_num == fd_to_fdnum(fd)) { if (l->blocked) { list_move_tail (&l->list, &blocked_list); continue; @@ -644,7 +644,8 @@ pl_fgetxattr_handle_lockinfo (xlator_t *this, fd_t *fd, pl_inode_t *pl_inode = NULL; char *key = NULL, *buf = NULL; int32_t op_ret = 0; - unsigned long fdnum = 0, len = 0; + unsigned long fdnum = 0; + int32_t len = 0; dict_t *tmp = NULL; pl_inode = pl_inode_get (this, fd->inode); @@ -1340,7 +1341,7 @@ __fd_has_locks (pl_inode_t *pl_inode, fd_t *fd) posix_lock_t *l = NULL; list_for_each_entry (l, &pl_inode->ext_list, list) { - if ((l->fd_num == fd_to_fdnum(fd))) { + if (l->fd_num == fd_to_fdnum(fd)) { found = 1; break; } @@ -1369,7 +1370,7 @@ __dup_locks_to_fdctx (pl_inode_t *pl_inode, fd_t *fd, int ret = 0; list_for_each_entry (l, &pl_inode->ext_list, list) { - if ((l->fd_num == fd_to_fdnum(fd))) { + if (l->fd_num == fd_to_fdnum(fd)) { duplock = lock_dup (l); if (!duplock) { ret = -1; diff --git a/xlators/features/mac-compat/src/Makefile.am b/xlators/features/mac-compat/src/Makefile.am index f8567edce..42ed350e9 100644 --- a/xlators/features/mac-compat/src/Makefile.am +++ b/xlators/features/mac-compat/src/Makefile.am @@ -6,9 +6,10 @@ mac_compat_la_LDFLAGS = -module -avoid-version mac_compat_la_SOURCES = mac-compat.c mac_compat_la_LIBADD = $(top_builddir)/libglusterfs/src/libglusterfs.la +noinst_HEADERS = mac-compat.h + AM_CPPFLAGS = $(GF_CPPFLAGS) -I$(top_srcdir)/libglusterfs/src AM_CFLAGS = -Wall $(GF_CFLAGS) -CLEANFILES = - +CLEANFILES = diff --git a/xlators/features/mac-compat/src/mac-compat.c b/xlators/features/mac-compat/src/mac-compat.c index 7cb550ad5..0eaf563e8 100644 --- a/xlators/features/mac-compat/src/mac-compat.c +++ b/xlators/features/mac-compat/src/mac-compat.c @@ -15,35 +15,28 @@ #include "xlator.h" #include "defaults.h" #include "compat-errno.h" +#include "syscall.h" +#include "mem-pool.h" +#include "mac-compat.h" - -enum apple_xattr { - GF_FINDER_INFO_XATTR, - GF_RESOURCE_FORK_XATTR, - GF_XATTR_ALL, - GF_XATTR_NONE -}; - -static char *apple_xattr_name[] = { - [GF_FINDER_INFO_XATTR] = "com.apple.FinderInfo", - [GF_RESOURCE_FORK_XATTR] = "com.apple.ResourceFork" -}; - -static const char *apple_xattr_value[] = { - [GF_FINDER_INFO_XATTR] = - /* 1 2 3 4 5 6 7 8 */ - "\0\0\0\0\0\0\0\0" - "\0\0\0\0\0\0\0\0" - "\0\0\0\0\0\0\0\0" - "\0\0\0\0\0\0\0\0", - [GF_RESOURCE_FORK_XATTR] = "" -}; - -static int32_t apple_xattr_len[] = { - [GF_FINDER_INFO_XATTR] = 32, - [GF_RESOURCE_FORK_XATTR] = 1 -}; - +static int +dict_key_remove_namespace(dict_t *dict, char *key, data_t *value, void *data) +{ + /* + char buffer[3*value->len+1]; + int index = 0; + for (index = 0; index < value->len; index++) + sprintf(buffer+3*index, " %02x", value->data[index]); + */ + xlator_t *this = (xlator_t *) data; + if (strncmp(key, "user.", 5) == 0) { + dict_set (dict, key + 5, value); + gf_log (this->name, GF_LOG_DEBUG, + "remove_namespace_dict: %s -> %s ", key, key + 5); + dict_del (dict, key); + } + return 0; +} int32_t maccomp_getxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this, @@ -53,54 +46,91 @@ maccomp_getxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this, intptr_t ax = (intptr_t)this->private; int i = 0; + gf_log (this->name, GF_LOG_DEBUG, + "getxattr_cbk: dict %p private: %p xdata %p ", dict, + this->private, xdata); + + if (dict) { + dict_foreach(dict, dict_key_remove_namespace, this); + } + else { + // TODO: we expect dict to exist here, don't know why this + // this is needed + dict = dict_new(); + } + gf_log (this->name, GF_LOG_DEBUG, + "getxattr_cbk: dict %p ax: %ld op_ret %d op_err %d ", dict, ax, + op_ret, op_errno); if ((ax == GF_XATTR_ALL && op_ret >= 0) || ax != GF_XATTR_NONE) { op_ret = op_errno = 0; - for (i = 0; i < GF_XATTR_ALL; i++) { if (dict_get (dict, apple_xattr_name[i])) continue; - + /* set dummy data */ + gf_log (this->name, GF_LOG_DEBUG, + "getxattr_cbk: setting dummy data %p, %s", dict, + apple_xattr_name[i]); if (dict_set (dict, apple_xattr_name[i], bin_to_data ((void *)apple_xattr_value[i], apple_xattr_len[i])) == -1) { op_ret = -1; - op_errno = ENOMEM; + op_errno = ENOATTR; break; } } } - STACK_UNWIND_STRICT (getxattr, frame, op_ret, op_errno, dict, xdata); - return 0; } -int32_t -maccomp_getxattr (call_frame_t *frame, xlator_t *this, loc_t *loc, - const char *name, dict_t *xdata) +static +int prepend_xattr_user_namespace(dict_t *dict, char *key, data_t *value, void *obj) { - intptr_t ax = GF_XATTR_NONE; - int i = 0; + xlator_t *this = (xlator_t *) obj; + dict_t *newdict = (dict_t *) this->private; + char *newkey = NULL; + gf_add_prefix(XATTR_USER_PREFIX, key, &newkey); + key = newkey; + dict_set(newdict, (char *)key, value); + if (newkey) + GF_FREE(newkey); + return 0; +} +intptr_t +check_name(const char *name, char **newkey) +{ + intptr_t ax = GF_XATTR_NONE; if (name) { + int i = 0; for (i = 0; i < GF_XATTR_ALL; i++) { if (strcmp (apple_xattr_name[i], name) == 0) { ax = i; - break; } } + gf_add_prefix("user.", name, newkey); } else ax = GF_XATTR_ALL; + return ax; +} - this->private = (void *)ax; +int32_t +maccomp_getxattr (call_frame_t *frame, xlator_t *this, loc_t *loc, + const char *name, dict_t *xdata) +{ + char *newkey = NULL; + this->private = (void *) check_name(name, &newkey); + gf_log (this->name, GF_LOG_DEBUG, + "getxattr: name %s private: %p xdata %p ", name, + this->private, xdata); STACK_WIND (frame, maccomp_getxattr_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->getxattr, - loc, name, xdata); + loc, newkey, xdata); return 0; } @@ -109,30 +139,17 @@ int32_t maccomp_fgetxattr (call_frame_t *frame, xlator_t *this, fd_t *fd, const char *name, dict_t *xdata) { - intptr_t ax = GF_XATTR_NONE; - int i = 0; - - if (name) { - for (i = 0; i < GF_XATTR_ALL; i++) { - if (strcmp (apple_xattr_name[i], name) == 0) { - ax = i; - - break; - } - } - } else - ax = GF_XATTR_ALL; - - this->private = (void *)ax; + char *newkey = NULL; + this->private = (void *) check_name(name, &newkey); STACK_WIND (frame, maccomp_getxattr_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->fgetxattr, - fd, name, xdata); + fd, newkey, xdata); + GF_FREE(newkey); return 0; } - int32_t maccomp_setxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret, int32_t op_errno, dict_t *xdata) @@ -141,12 +158,56 @@ maccomp_setxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this, if (op_ret == -1 && ax != GF_XATTR_NONE) op_ret = op_errno = 0; - + gf_log (this->name, GF_LOG_DEBUG, + "setxattr_cbk op_ret %d op_errno %d private: %p xdata %p ", + op_ret, op_errno, this->private, xdata); STACK_UNWIND_STRICT (setxattr, frame, op_ret, op_errno, xdata); + return 0; +} +int32_t +maccomp_setattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this, + int32_t op_ret, int32_t op_errno, struct iatt *iatt1, + struct iatt *iattr2, dict_t *xdata) +{ + gf_log (this->name, GF_LOG_DEBUG, + "setattr_cbk op_ret %d op_errno %d private: %p xdata %p ", + op_ret, op_errno, this->private, xdata); + STACK_UNWIND_STRICT (setattr, frame, op_ret, op_errno, + iatt1, iattr2, xdata); return 0; } +int map_flags(int flags) +{ + /* DARWIN has different defines on XATTR_ flags. + There do not seem to be a POSIX standard + Parse any other flags over. + NOFOLLOW is always true on Linux and Darwin + */ + int linux_flags = flags & ~(GF_XATTR_CREATE | GF_XATTR_REPLACE | XATTR_REPLACE); + if (XATTR_CREATE & flags) + linux_flags |= GF_XATTR_CREATE; + if (XATTR_REPLACE & flags) + linux_flags |= GF_XATTR_REPLACE; + return linux_flags; +} + +int32_t +maccomp_fremovexattr (call_frame_t *frame, xlator_t *this, fd_t *fd, + const char *name, dict_t *xdata) +{ + char *newkey = NULL; + + this->private = (void *) check_name(name, &newkey); + + STACK_WIND (frame, default_fremovexattr_cbk, + FIRST_CHILD(this), + FIRST_CHILD(this)->fops->fremovexattr, + fd, newkey, xdata); + GF_FREE(newkey); + return 0; +} int32_t maccomp_setxattr (call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *dict, @@ -162,16 +223,56 @@ maccomp_setxattr (call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *dict, break; } } + dict_t *newdict = dict_new(); + this->private = (void *) newdict; + dict_foreach(dict, prepend_xattr_user_namespace, this); this->private = (void *)ax; - + int linux_flags = map_flags(flags); + gf_log (this->name, GF_LOG_DEBUG, + "setxattr flags: %d -> %d dict %p private: %p xdata %p ", + flags, linux_flags, dict, this->private, xdata); STACK_WIND (frame, maccomp_setxattr_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->setxattr, - loc, dict, flags, xdata); + loc, newdict, linux_flags, xdata); + dict_unref(newdict); return 0; } +int32_t +maccomp_setattr (call_frame_t *frame, xlator_t *this, loc_t *loc, struct iatt *iattr, + int32_t flags, dict_t *xdata) +{ + gf_log (this->name, GF_LOG_DEBUG, + "setattr iattr %p private: %p xdata %p ", + iattr, this->private, xdata); + STACK_WIND (frame, maccomp_setattr_cbk, + FIRST_CHILD(this), + FIRST_CHILD(this)->fops->setattr, + loc, iattr, flags, xdata); + return 0; +} + +int32_t +maccomp_removexattr (call_frame_t *frame, xlator_t *this, loc_t *loc, + const char *name, dict_t *xdata) +{ + char *newkey = NULL; + this->private = (void *) check_name(name, &newkey); + + STACK_WIND (frame, default_removexattr_cbk, + FIRST_CHILD(this), + FIRST_CHILD(this)->fops->removexattr, + loc, newkey, xdata); + + gf_log (this->name, GF_LOG_TRACE, + "removeattr name %p private: %p xdata %p ", + name, this->private, xdata); + GF_FREE(newkey); + return 0; + +} int32_t maccomp_fsetxattr (call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *dict, @@ -188,12 +289,20 @@ maccomp_fsetxattr (call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *dict, } } - this->private = (void *)ax; + dict_t *newdict = dict_new(); + this->private = (void *) newdict; + dict_foreach(dict, prepend_xattr_user_namespace, this); + this->private = (void *)ax; + int linux_flags = map_flags(flags); + gf_log (this->name, GF_LOG_DEBUG, + "fsetxattr flags: %d -> %d dict %p private: %p xdata %p ", + flags, linux_flags, dict, this->private, xdata); STACK_WIND (frame, maccomp_setxattr_cbk, FIRST_CHILD(this), FIRST_CHILD(this)->fops->fsetxattr, - fd, dict, flags, xdata); + fd, newdict, linux_flags, xdata); + dict_unref(newdict); return 0; } @@ -224,10 +333,13 @@ fini (xlator_t *this) struct xlator_fops fops = { - .getxattr = maccomp_getxattr, - .fgetxattr = maccomp_fgetxattr, - .setxattr = maccomp_setxattr, - .fsetxattr = maccomp_fsetxattr, + .getxattr = maccomp_getxattr, + .fgetxattr = maccomp_fgetxattr, + .setxattr = maccomp_setxattr, + .setattr = maccomp_setattr, + .fsetxattr = maccomp_fsetxattr, + .removexattr = maccomp_removexattr, + .fremovexattr = maccomp_fremovexattr, }; struct xlator_cbks cbks; diff --git a/xlators/features/mac-compat/src/mac-compat.h b/xlators/features/mac-compat/src/mac-compat.h new file mode 100644 index 000000000..b033ca0e4 --- /dev/null +++ b/xlators/features/mac-compat/src/mac-compat.h @@ -0,0 +1,41 @@ +/* + Copyright (c) 2014 Red Hat, Inc. + This file is part of GlusterFS. + + This file is licensed to you under your choice of the GNU Lesser + General Public License, version 3 or any later version (LGPLv3 or + later), or the GNU General Public License, version 2 (GPLv2), in all + cases as published by the Free Software Foundation. +*/ + +#ifndef __MAC_COMPAT_H__ +#define __MAC_COMPAT_H__ + +enum apple_xattr { + GF_FINDER_INFO_XATTR, + GF_RESOURCE_FORK_XATTR, + GF_XATTR_ALL, + GF_XATTR_NONE +}; + +static char *apple_xattr_name[] = { + [GF_FINDER_INFO_XATTR] = "com.apple.FinderInfo", + [GF_RESOURCE_FORK_XATTR] = "com.apple.ResourceFork" +}; + +static const char *apple_xattr_value[] = { + [GF_FINDER_INFO_XATTR] = + /* 1 2 3 4 5 6 7 8 */ + "\0\0\0\0\0\0\0\0" + "\0\0\0\0\0\0\0\0" + "\0\0\0\0\0\0\0\0" + "\0\0\0\0\0\0\0\0", + [GF_RESOURCE_FORK_XATTR] = "" +}; + +static int32_t apple_xattr_len[] = { + [GF_FINDER_INFO_XATTR] = 32, + [GF_RESOURCE_FORK_XATTR] = 1 +}; + +#endif /* __MAC_COMPAT_H__ */ diff --git a/xlators/features/marker/src/marker-quota-helper.h b/xlators/features/marker/src/marker-quota-helper.h index 6cdd14881..b200413b0 100644 --- a/xlators/features/marker/src/marker-quota-helper.h +++ b/xlators/features/marker/src/marker-quota-helper.h @@ -9,7 +9,7 @@ */ #ifndef _MARKER_QUOTA_HELPER_H -#define _MARKER_QUOTA_HELPER +#define _MARKER_QUOTA_HELPER_H #ifndef _CONFIG_H #define _CONFIG_H diff --git a/xlators/features/marker/src/marker-quota.c b/xlators/features/marker/src/marker-quota.c index a758e938f..1903fdc40 100644 --- a/xlators/features/marker/src/marker-quota.c +++ b/xlators/features/marker/src/marker-quota.c @@ -365,7 +365,10 @@ mq_update_size_xattr (call_frame_t *frame, void *cookie, xlator_t *this, local->loc.path, ntoh64 (*delta)); new_dict = dict_new (); - if (!new_dict); + if (!new_dict) { + errno = ENOMEM; + goto err; + } ret = dict_set_bin (new_dict, QUOTA_SIZE_KEY, delta, 8); if (ret) @@ -385,7 +388,6 @@ mq_update_size_xattr (call_frame_t *frame, void *cookie, xlator_t *this, err: if (op_ret == -1 || ret == -1) { local->err = -1; - mq_release_lock_on_dirty_inode (frame, NULL, this, 0, 0, NULL); } diff --git a/xlators/features/marker/src/marker.c b/xlators/features/marker/src/marker.c index a27a266f0..adcf3d8e7 100644 --- a/xlators/features/marker/src/marker.c +++ b/xlators/features/marker/src/marker.c @@ -255,18 +255,18 @@ out: return 0; } -int32_t +gf_boolean_t call_from_special_client (call_frame_t *frame, xlator_t *this, const char *name) { struct volume_mark *vol_mark = NULL; marker_conf_t *priv = NULL; - gf_boolean_t ret = _gf_true; + gf_boolean_t is_true = _gf_true; priv = (marker_conf_t *)this->private; if (frame->root->pid != GF_CLIENT_PID_GSYNCD || name == NULL || strcmp (name, MARKER_XATTR_PREFIX "." VOLUME_MARK) != 0) { - ret = _gf_false; + is_true = _gf_false; goto out; } @@ -274,7 +274,7 @@ call_from_special_client (call_frame_t *frame, xlator_t *this, const char *name) marker_getxattr_stampfile_cbk (frame, this, name, vol_mark, NULL); out: - return ret; + return is_true; } int32_t @@ -348,10 +348,10 @@ int32_t marker_getxattr (call_frame_t *frame, xlator_t *this, loc_t *loc, const char *name, dict_t *xdata) { - gf_boolean_t ret = _gf_false; - marker_conf_t *priv = NULL; - unsigned long cookie = 0; - marker_local_t *local = NULL; + gf_boolean_t is_true = _gf_false; + marker_conf_t *priv = NULL; + unsigned long cookie = 0; + marker_local_t *local = NULL; priv = this->private; @@ -362,16 +362,15 @@ marker_getxattr (call_frame_t *frame, xlator_t *this, loc_t *loc, MARKER_INIT_LOCAL (frame, local); - ret = loc_copy (&local->loc, loc); - if (ret < 0) - goto out; + if ((loc_copy (&local->loc, loc)) < 0) + goto out; gf_log (this->name, GF_LOG_DEBUG, "USER:PID = %d", frame->root->pid); if (priv && priv->feature_enabled & GF_XTIME) - ret = call_from_special_client (frame, this, name); + is_true = call_from_special_client (frame, this, name); - if (ret == _gf_false) { + if (is_true == _gf_false) { if (name == NULL) { /* Signifies that marker translator * has to filter the quota's xattr's, @@ -380,10 +379,11 @@ marker_getxattr (call_frame_t *frame, xlator_t *this, loc_t *loc, */ cookie = 1; } - STACK_WIND_COOKIE (frame, marker_getxattr_cbk, (void *)cookie, + STACK_WIND_COOKIE (frame, marker_getxattr_cbk, + (void *)cookie, FIRST_CHILD(this), - FIRST_CHILD(this)->fops->getxattr, loc, - name, xdata); + FIRST_CHILD(this)->fops->getxattr, + loc, name, xdata); } return 0; diff --git a/xlators/features/quota/src/quota.c b/xlators/features/quota/src/quota.c index 4beaae341..2ca4da0c1 100644 --- a/xlators/features/quota/src/quota.c +++ b/xlators/features/quota/src/quota.c @@ -244,7 +244,7 @@ out: return; } -inline void +static inline void quota_link_count_decrement (quota_local_t *local) { call_stub_t *stub = NULL; @@ -270,7 +270,7 @@ out: return; } -inline void +static inline void quota_handle_validate_error (quota_local_t *local, int32_t op_ret, int32_t op_errno) { @@ -377,7 +377,7 @@ quota_timeout (struct timeval *tv, int32_t timeout) return timed_out; } -inline void +static inline void quota_add_parent (quota_dentry_t *dentry, struct list_head *list) { quota_dentry_t *entry = NULL; @@ -928,7 +928,7 @@ err: return 0; } -inline int +static inline int quota_get_limits (xlator_t *this, dict_t *dict, int64_t *hard_lim, int64_t *soft_lim) { diff --git a/xlators/features/quota/src/quotad-aggregator.c b/xlators/features/quota/src/quotad-aggregator.c index f3f65ca2a..5f13fd251 100644 --- a/xlators/features/quota/src/quotad-aggregator.c +++ b/xlators/features/quota/src/quotad-aggregator.c @@ -227,7 +227,7 @@ quotad_aggregator_getlimit (rpcsvc_request_t *req) if (ret) goto err; - ret = dict_set_int32 (state->xdata, GET_ANCESTRY_PATH_KEY,42); + ret = dict_set_int32 (state->xdata, GET_ANCESTRY_PATH_KEY, 42); if (ret) goto err; diff --git a/xlators/mgmt/glusterd/src/Makefile.am b/xlators/mgmt/glusterd/src/Makefile.am index 933c44019..b89ec6ddc 100644 --- a/xlators/mgmt/glusterd/src/Makefile.am +++ b/xlators/mgmt/glusterd/src/Makefile.am @@ -29,7 +29,7 @@ noinst_HEADERS = glusterd.h glusterd-utils.h glusterd-op-sm.h \ AM_CPPFLAGS = $(GF_CPPFLAGS) -I$(top_srcdir)/libglusterfs/src \ -I$(rpclibdir) -I$(CONTRIBDIR)/rbtree \ -I$(top_srcdir)/rpc/xdr/src -I$(top_srcdir)/rpc/rpc-lib/src \ - -I$(CONTRIBDIR)/uuid \ + -I$(CONTRIBDIR)/uuid -I$(CONTRIBDIR)/mount \ -DSBIN_DIR=\"$(sbindir)\" -DDATADIR=\"$(localstatedir)\" \ -DGSYNCD_PREFIX=\"$(libexecdir)/glusterfs\"\ -DSYNCDAEMON_COMPILE=$(SYNCDAEMON_COMPILE) $(XML_CPPFLAGS) diff --git a/xlators/mgmt/glusterd/src/glusterd-hooks.c b/xlators/mgmt/glusterd/src/glusterd-hooks.c index 352b6ba11..78730a564 100644 --- a/xlators/mgmt/glusterd/src/glusterd-hooks.c +++ b/xlators/mgmt/glusterd/src/glusterd-hooks.c @@ -181,7 +181,7 @@ glusterd_hooks_set_volume_args (dict_t *dict, runner_t *runner) goto out; runner_add_arg (runner, "-o"); - for (i = 1; (ret == 0); i++) { + for (i = 1; ret == 0; i++) { snprintf (query, sizeof (query), "key%d", i); ret = dict_get_str (dict, query, &key); if (ret) diff --git a/xlators/mgmt/glusterd/src/glusterd-op-sm.c b/xlators/mgmt/glusterd/src/glusterd-op-sm.c index fb5e097d9..c22c2ea63 100644 --- a/xlators/mgmt/glusterd/src/glusterd-op-sm.c +++ b/xlators/mgmt/glusterd/src/glusterd-op-sm.c @@ -1020,7 +1020,7 @@ glusterd_op_stage_reset_volume (dict_t *dict, char **op_errstr) { int ret = 0; char *volname = NULL; - gf_boolean_t exists = _gf_false; + int exists = 0; char msg[2048] = {0}; char *key = NULL; char *key_fixed = NULL; @@ -1068,6 +1068,7 @@ glusterd_op_stage_reset_volume (dict_t *dict, char **op_errstr) ret = -1; goto out; } + if (!exists) { ret = snprintf (msg, sizeof (msg), "Option %s does not exist", key); @@ -1819,7 +1820,7 @@ glusterd_op_set_volume (dict_t *dict) if (dict_count == 0) { ret = glusterd_volset_help (NULL, &op_errstr); if (ret) { - gf_log (this->name, GF_LOG_ERROR, "%s", + gf_log (this->name, GF_LOG_ERROR, "%s", (op_errstr)? op_errstr: "Volume set help internal error"); } @@ -3262,7 +3263,7 @@ glusterd_is_get_op (xlator_t *this, glusterd_op_t op, dict_t *dict) if (op == GD_OP_STATUS_VOLUME) return _gf_true; - if ((op == GD_OP_SET_VOLUME)) { + if (op == GD_OP_SET_VOLUME) { //check for set volume help ret = dict_get_str (dict, "volname", &volname); if (volname && diff --git a/xlators/mgmt/glusterd/src/glusterd-quota.c b/xlators/mgmt/glusterd/src/glusterd-quota.c index cf23b6404..7f798ad26 100644 --- a/xlators/mgmt/glusterd/src/glusterd-quota.c +++ b/xlators/mgmt/glusterd/src/glusterd-quota.c @@ -474,7 +474,7 @@ glusterd_set_quota_limit (char *volname, char *path, char *hard_limit, new_limit.sl = hton64 (new_limit.sl); - ret = gf_string2bytesize (hard_limit, (uint64_t*)&new_limit.hl); + ret = gf_string2bytesize_uint64 (hard_limit, (uint64_t*)&new_limit.hl); if (ret) goto out; @@ -1400,13 +1400,13 @@ glusterd_op_stage_quota (dict_t *dict, char **op_errstr, dict_t *rsp_dict) "Faild to get hard-limit from dict"); goto out; } - ret = gf_string2bytesize (hard_limit_str, &hard_limit); + ret = gf_string2bytesize_uint64 (hard_limit_str, &hard_limit); if (ret) { gf_log (this->name, GF_LOG_ERROR, "Failed to convert hard-limit string to value"); goto out; } - if (hard_limit > INT64_MAX) { + if (hard_limit > UINT64_MAX) { ret = -1; ret = gf_asprintf (op_errstr, "Hard-limit %s is greater" " than %"PRId64"bytes. Please set a " diff --git a/xlators/mgmt/glusterd/src/glusterd-snapshot.c b/xlators/mgmt/glusterd/src/glusterd-snapshot.c index d11abee70..b294d1bc6 100644 --- a/xlators/mgmt/glusterd/src/glusterd-snapshot.c +++ b/xlators/mgmt/glusterd/src/glusterd-snapshot.c @@ -18,6 +18,14 @@ #include #include #include +#include + + +#if !defined(__NetBSD__) && !defined(GF_DARWIN_HOST_OS) +#include +#else +#include "mntent_compat.h" +#endif #include "globals.h" #include "compat.h" @@ -40,9 +48,7 @@ #include "cli1-xdr.h" #include "xdr-generic.h" -#ifdef GF_LINUX_HOST_OS -#include -#endif +#include "lvm-defaults.h" char snap_mount_folder[PATH_MAX]; @@ -267,7 +273,7 @@ out: int snap_max_hard_limits_validate (dict_t *dict, char *volname, - uint64_t value, char **op_errstr) + uint64_t value, char **op_errstr) { char err_str[PATH_MAX] = ""; glusterd_conf_t *conf = NULL; @@ -449,7 +455,7 @@ glusterd_snap_create_pre_val_use_rsp_dict (dict_t *dst, dict_t *src) for (i = 0; i < volume_count; i++) { memset (snapbrckcnt, '\0', sizeof(snapbrckcnt)); ret = snprintf (snapbrckcnt, sizeof(snapbrckcnt) - 1, - "vol%ld_brickcount", i+1); + "vol%"PRId64"_brickcount", i+1); ret = dict_get_int64 (src, snapbrckcnt, &brick_count); if (ret) { gf_log (this->name, GF_LOG_TRACE, @@ -460,7 +466,7 @@ glusterd_snap_create_pre_val_use_rsp_dict (dict_t *dst, dict_t *src) for (j = 0; j < brick_count; j++) { /* Fetching data from source dict */ snprintf (key, sizeof(key) - 1, - "vol%ld.brickdir%ld", i+1, j); + "vol%"PRId64".brickdir%"PRId64, i+1, j); ret = dict_get_ptr (src, key, (void **)&snap_brick_dir); @@ -471,7 +477,7 @@ glusterd_snap_create_pre_val_use_rsp_dict (dict_t *dst, dict_t *src) } snprintf (key, sizeof(key) - 1, - "vol%ld.brick_snapdevice%ld", i+1, j); + "vol%"PRId64".brick_snapdevice%"PRId64, i+1, j); ret = dict_get_ptr (src, key, (void **)&snap_device); @@ -482,7 +488,7 @@ glusterd_snap_create_pre_val_use_rsp_dict (dict_t *dst, dict_t *src) } snprintf (snapbrckord, sizeof(snapbrckord) - 1, - "vol%ld.brick%ld.order", i+1, j); + "vol%"PRId64".brick%"PRId64".order", i+1, j); ret = dict_get_int64 (src, snapbrckord, &brick_order); if (ret) { @@ -493,7 +499,7 @@ glusterd_snap_create_pre_val_use_rsp_dict (dict_t *dst, dict_t *src) /* Adding the data in the dst dict */ snprintf (key, sizeof(key) - 1, - "vol%ld.brickdir%ld", i+1, brick_order); + "vol%"PRId64".brickdir%"PRId64, i+1, brick_order); tmpstr = gf_strdup (snap_brick_dir); if (!tmpstr) { @@ -511,7 +517,7 @@ glusterd_snap_create_pre_val_use_rsp_dict (dict_t *dst, dict_t *src) } snprintf (key, sizeof(key) - 1, - "vol%ld.brick_snapdevice%ld", + "vol%"PRId64".brick_snapdevice%"PRId64, i+1, brick_order); tmpstr = gf_strdup (snap_device); @@ -618,8 +624,8 @@ glusterd_snapshot_create_prevalidate (dict_t *dict, char **op_errstr, goto out; } if (volcount <= 0) { - snprintf (err_str, sizeof (err_str), "Invalid volume count %ld " - "supplied", volcount); + snprintf (err_str, sizeof (err_str), "Invalid volume count %"PRId64 + " supplied", volcount); ret = -1; goto out; } @@ -638,7 +644,7 @@ glusterd_snapshot_create_prevalidate (dict_t *dict, char **op_errstr, } for (i = 1; i <= volcount; i++) { - snprintf (key, sizeof (key), "volname%ld", i); + snprintf (key, sizeof (key), "volname%"PRId64, i); ret = dict_get_str (dict, key, &volname); if (ret) { snprintf (err_str, sizeof (err_str), @@ -690,7 +696,7 @@ glusterd_snapshot_create_prevalidate (dict_t *dict, char **op_errstr, goto out; } - snprintf (key, sizeof(key) - 1, "vol%ld_volid", i); + snprintf (key, sizeof(key) - 1, "vol%"PRId64"_volid", i); ret = dict_get_bin (dict, key, (void **)&snap_volid); if (ret) { gf_log (this->name, GF_LOG_ERROR, @@ -745,7 +751,7 @@ glusterd_snapshot_create_prevalidate (dict_t *dict, char **op_errstr, } snprintf (key, sizeof(key), - "vol%ld.brick_snapdevice%ld", i, + "vol%"PRId64".brick_snapdevice%"PRId64, i, brick_count); ret = dict_set_dynstr (rsp_dict, key, device); if (ret) { @@ -783,7 +789,7 @@ glusterd_snapshot_create_prevalidate (dict_t *dict, char **op_errstr, ret = -1; goto out; } - snprintf (key, sizeof(key), "vol%ld.brickdir%ld", i, + snprintf (key, sizeof(key), "vol%"PRId64".brickdir%"PRId64, i, brick_count); ret = dict_set_dynstr (rsp_dict, key, tmpstr); if (ret) { @@ -793,7 +799,7 @@ glusterd_snapshot_create_prevalidate (dict_t *dict, char **op_errstr, } tmpstr = NULL; - snprintf (key, sizeof(key) - 1, "vol%ld.brick%ld.order", + snprintf (key, sizeof(key) - 1, "vol%"PRId64".brick%"PRId64".order", i, brick_count); ret = dict_set_int64 (rsp_dict, key, brick_order); if (ret) { @@ -805,7 +811,7 @@ glusterd_snapshot_create_prevalidate (dict_t *dict, char **op_errstr, brick_count++; brick_order++; } - snprintf (key, sizeof(key) - 1, "vol%ld_brickcount", i); + snprintf (key, sizeof(key) - 1, "vol%"PRId64"_brickcount", i); ret = dict_set_int64 (rsp_dict, key, brick_count); if (ret) { gf_log (this->name, GF_LOG_ERROR, "Failed to set %s", @@ -1002,7 +1008,7 @@ glusterd_do_lvm_snapshot_remove (glusterd_volinfo_t *snap_vol, snprintf (msg, sizeof(msg), "remove snapshot of the brick %s:%s, " "device: %s", brickinfo->hostname, brickinfo->path, snap_device); - runner_add_args (&runner, "/sbin/lvremove", "-f", snap_device, NULL); + runner_add_args (&runner, LVM_REMOVE, "-f", snap_device, NULL); runner_log (&runner, "", GF_LOG_DEBUG, msg); ret = runner_run (&runner); @@ -2047,8 +2053,8 @@ glusterd_handle_snapshot_create (rpcsvc_request_t *req, glusterd_op_t op, goto out; } if (volcount <= 0) { - gf_log (this->name, GF_LOG_ERROR, "Invalid volume count %ld " - "supplied", volcount); + gf_log (this->name, GF_LOG_ERROR, "Invalid volume count %"PRId64 + " supplied", volcount); ret = -1; goto out; } @@ -2476,7 +2482,7 @@ glusterd_create_snap_object (dict_t *dict, dict_t *rsp_dict) } if (time_stamp <= 0) { ret = -1; - gf_log (this->name, GF_LOG_ERROR, "Invalid time-stamp: %ld", + gf_log (this->name, GF_LOG_ERROR, "Invalid time-stamp: %"PRId64, time_stamp); goto out; } @@ -2715,7 +2721,7 @@ glusterd_take_lvm_snapshot (glusterd_volinfo_t *snap_vol, /* Figuring out if setactivationskip flag is supported or not */ runinit (&runner); snprintf (msg, sizeof (msg), "running lvcreate help"); - runner_add_args (&runner, "/sbin/lvcreate", "--help", NULL); + runner_add_args (&runner, LVM_CREATE, "--help", NULL); runner_log (&runner, "", GF_LOG_DEBUG, msg); runner_redir (&runner, STDOUT_FILENO, RUN_PIPE); ret = runner_start (&runner); @@ -2744,11 +2750,11 @@ glusterd_take_lvm_snapshot (glusterd_volinfo_t *snap_vol, snprintf (msg, sizeof (msg), "taking snapshot of the brick %s:%s", brickinfo->hostname, brickinfo->path); if (match == _gf_true) - runner_add_args (&runner, "/sbin/lvcreate", "-s", device, + runner_add_args (&runner, LVM_CREATE, "-s", device, "--setactivationskip", "n", "--name", snap_vol->volname, NULL); else - runner_add_args (&runner, "/sbin/lvcreate", "-s", device, + runner_add_args (&runner, LVM_CREATE, "-s", device, "--name", snap_vol->volname, NULL); runner_log (&runner, "", GF_LOG_DEBUG, msg); ret = runner_start (&runner); @@ -2862,7 +2868,11 @@ out: if (ret) { gf_log (this->name, GF_LOG_WARNING, "unmounting the snap brick" " mount %s", snap_brick_mount_path); +#if !defined(GF_DARWIN_HOST_OS) umount (snap_brick_mount_path); +#else + unmount (snap_brick_mount_path, 0); +#endif } gf_log (this->name, GF_LOG_TRACE, "Returning %d", ret); @@ -2893,7 +2903,7 @@ glusterd_add_bricks_to_snap_volume (dict_t *dict, dict_t *rsp_dict, GF_ASSERT (snap_brickinfo); GF_ASSERT (snap_brick_dir); - snprintf (key, sizeof(key) - 1, "vol%ld.brickdir%d", volcount, + snprintf (key, sizeof(key) - 1, "vol%"PRId64".brickdir%d", volcount, brick_count); ret = dict_get_ptr (dict, key, (void **)snap_brick_dir); if (ret) { @@ -2951,7 +2961,7 @@ glusterd_add_bricks_to_snap_volume (dict_t *dict, dict_t *rsp_dict, } } - snprintf (key, sizeof(key), "vol%ld.brick_snapdevice%d", + snprintf (key, sizeof(key), "vol%"PRId64".brick_snapdevice%d", volcount, brick_count); ret = dict_get_ptr (dict, key, (void **)&snap_device); if (ret) { @@ -3129,7 +3139,7 @@ glusterd_do_snap_vol (glusterd_volinfo_t *origin_vol, glusterd_snap_t *snap, GF_ASSERT (rsp_dict); /* fetch username, password and vol_id from dict*/ - snprintf (key, sizeof(key), "volume%ld_username", volcount); + snprintf (key, sizeof(key), "volume%"PRId64"_username", volcount); ret = dict_get_str (dict, key, &username); if (ret) { gf_log (this->name, GF_LOG_ERROR, "Failed to get %s for " @@ -3137,7 +3147,7 @@ glusterd_do_snap_vol (glusterd_volinfo_t *origin_vol, glusterd_snap_t *snap, goto out; } - snprintf (key, sizeof(key), "volume%ld_password", volcount); + snprintf (key, sizeof(key), "volume%"PRId64"_password", volcount); ret = dict_get_str (dict, key, &password); if (ret) { gf_log (this->name, GF_LOG_ERROR, "Failed to get %s for " @@ -3145,7 +3155,7 @@ glusterd_do_snap_vol (glusterd_volinfo_t *origin_vol, glusterd_snap_t *snap, goto out; } - snprintf (key, sizeof(key) - 1, "vol%ld_volid", volcount); + snprintf (key, sizeof(key) - 1, "vol%"PRId64"_volid", volcount); ret = dict_get_bin (dict, key, (void **)&snap_volid); if (ret) { gf_log (this->name, GF_LOG_ERROR, @@ -3367,7 +3377,7 @@ glusterd_handle_snapshot_remove (rpcsvc_request_t *req, glusterd_op_t op, goto out; } - snprintf (key, sizeof (key), "volname%ld", volcount); + snprintf (key, sizeof (key), "volname%"PRId64, volcount); ret = dict_set_dynstr (dict, key, volname); if (ret) { gf_log (this->name, GF_LOG_ERROR, "Failed to set " @@ -3771,7 +3781,7 @@ glusterd_snapshot_create_commit (dict_t *dict, char **op_errstr, } for (i = 1; i <= volcount; i++) { - snprintf (key, sizeof (key), "volname%ld", i); + snprintf (key, sizeof (key), "volname%"PRId64, i); ret = dict_get_str (dict, key, &volname); if (ret) { gf_log (this->name, GF_LOG_ERROR, @@ -3922,7 +3932,7 @@ snap_max_limits_display_commit (dict_t *rsp_dict, char *volname, soft_limit_value = (active_hard_limit * conf->snap_max_soft_limit) / 100; - snprintf (buf, sizeof(buf), "volume%ld-volname", count); + snprintf (buf, sizeof(buf), "volume%"PRIu64"-volname", count); ret = dict_set_str (rsp_dict, buf, volinfo->volname); if (ret) { snprintf (err_str, PATH_MAX, @@ -3931,7 +3941,7 @@ snap_max_limits_display_commit (dict_t *rsp_dict, char *volname, } snprintf (buf, sizeof(buf), - "volume%ld-snap-max-hard-limit", count); + "volume%"PRIu64"-snap-max-hard-limit", count); ret = dict_set_uint64 (rsp_dict, buf, snap_max_limit); if (ret) { snprintf (err_str, PATH_MAX, @@ -3940,7 +3950,7 @@ snap_max_limits_display_commit (dict_t *rsp_dict, char *volname, } snprintf (buf, sizeof(buf), - "volume%ld-active-hard-limit", count); + "volume%"PRIu64"-active-hard-limit", count); ret = dict_set_uint64 (rsp_dict, buf, active_hard_limit); if (ret) { @@ -3950,7 +3960,7 @@ snap_max_limits_display_commit (dict_t *rsp_dict, char *volname, } snprintf (buf, sizeof(buf), - "volume%ld-snap-max-soft-limit", count); + "volume%"PRIu64"-snap-max-soft-limit", count); ret = dict_set_uint64 (rsp_dict, buf, soft_limit_value); if (ret) { snprintf (err_str, PATH_MAX, @@ -3984,7 +3994,7 @@ snap_max_limits_display_commit (dict_t *rsp_dict, char *volname, soft_limit_value = (active_hard_limit * conf->snap_max_soft_limit) / 100; - snprintf (buf, sizeof(buf), "volume%ld-volname", count); + snprintf (buf, sizeof(buf), "volume%"PRIu64"-volname", count); ret = dict_set_str (rsp_dict, buf, volinfo->volname); if (ret) { snprintf (err_str, PATH_MAX, @@ -3993,7 +4003,7 @@ snap_max_limits_display_commit (dict_t *rsp_dict, char *volname, } snprintf (buf, sizeof(buf), - "volume%ld-snap-max-hard-limit", count); + "volume%"PRIu64"-snap-max-hard-limit", count); ret = dict_set_uint64 (rsp_dict, buf, snap_max_limit); if (ret) { snprintf (err_str, PATH_MAX, @@ -4002,7 +4012,7 @@ snap_max_limits_display_commit (dict_t *rsp_dict, char *volname, } snprintf (buf, sizeof(buf), - "volume%ld-active-hard-limit", count); + "volume%"PRIu64"-active-hard-limit", count); ret = dict_set_uint64 (rsp_dict, buf, active_hard_limit); if (ret) { snprintf (err_str, PATH_MAX, @@ -4011,7 +4021,7 @@ snap_max_limits_display_commit (dict_t *rsp_dict, char *volname, } snprintf (buf, sizeof(buf), - "volume%ld-snap-max-soft-limit", count); + "volume%"PRIu64"-snap-max-soft-limit", count); ret = dict_set_uint64 (rsp_dict, buf, soft_limit_value); if (ret) { snprintf (err_str, PATH_MAX, @@ -4196,7 +4206,7 @@ glusterd_get_brick_lvm_details (dict_t *rsp_dict, * for the above given command with separator ":", * The output will be "vgname:lvsize" */ - runner_add_args (&runner, "lvs", device, "--noheading", "-o", + runner_add_args (&runner, LVS, device, "--noheading", "-o", "vg_name,data_percent,lv_size", "--separator", ":", NULL); runner_redir (&runner, STDOUT_FILENO, RUN_PIPE); diff --git a/xlators/mgmt/glusterd/src/glusterd-store.c b/xlators/mgmt/glusterd/src/glusterd-store.c index e28a30c5a..b803ba282 100644 --- a/xlators/mgmt/glusterd/src/glusterd-store.c +++ b/xlators/mgmt/glusterd/src/glusterd-store.c @@ -2615,7 +2615,7 @@ out: return volinfo; } -inline void +static inline void glusterd_store_set_options_path (glusterd_conf_t *conf, char *path, size_t len) { snprintf (path, len, "%s/options", conf->workdir); @@ -3722,7 +3722,7 @@ glusterd_store_retrieve_quota_version (glusterd_volinfo_t *volinfo) } version = strtoul (version_str, &tmp, 10); - if (version < 0) { + if ((errno == ERANGE) || (errno == EINVAL)) { gf_log (this->name, GF_LOG_DEBUG, "Invalid version number"); goto out; } diff --git a/xlators/mgmt/glusterd/src/glusterd-utils.c b/xlators/mgmt/glusterd/src/glusterd-utils.c index bb8028003..be2022da4 100644 --- a/xlators/mgmt/glusterd/src/glusterd-utils.c +++ b/xlators/mgmt/glusterd/src/glusterd-utils.c @@ -13,6 +13,12 @@ #endif #include +#if !defined(__NetBSD__) && !defined(GF_DARWIN_HOST_OS) +#include +#else +#include "mntent_compat.h" +#endif + #include "globals.h" #include "glusterfs.h" #include "compat.h" @@ -44,7 +50,6 @@ #include #include #include -#include #include #include #include @@ -56,11 +61,6 @@ #include #endif - -#ifdef GF_LINUX_HOST_OS -#include -#endif - #ifdef GF_SOLARIS_HOST_OS #include #endif @@ -4520,14 +4520,16 @@ glusterd_nodesvc_start (char *server, gf_boolean_t wait) "--trace-children=yes", "--track-origins=yes", NULL); runner_argprintf (&runner, "--log-file=%s", valgrind_logfile); - } + } runner_add_args (&runner, SBIN_DIR"/glusterfs", "-s", "localhost", "--volfile-id", volfileid, "-p", pidfile, "-l", logfile, - "-S", sockfpath, NULL); + "-S", sockfpath, + "-L", "DEBUG", + NULL); if (!strcmp (server, "glustershd")) { snprintf (glusterd_uuid_option, sizeof (glusterd_uuid_option), @@ -5454,7 +5456,6 @@ out: return -1; } -#ifdef GF_LINUX_HOST_OS int glusterd_get_brick_root (char *path, char **mount_point) { @@ -5750,7 +5751,6 @@ out: return device; } -#endif int glusterd_add_brick_detail_to_dict (glusterd_volinfo_t *volinfo, @@ -5824,13 +5824,12 @@ glusterd_add_brick_detail_to_dict (glusterd_volinfo_t *volinfo, if (ret) goto out; } -#ifdef GF_LINUX_HOST_OS + ret = glusterd_add_brick_mount_details (brickinfo, dict, count); if (ret) goto out; ret = glusterd_add_inode_size_to_dict (dict, count); -#endif out: if (ret) gf_log (this->name, GF_LOG_DEBUG, "Error adding brick" @@ -8828,7 +8827,7 @@ glusterd_snap_config_use_rsp_dict (dict_t *dst, dict_t *src) } for (i = 0; i < voldisplaycount; i++) { - snprintf (buf, sizeof(buf), "volume%ld-volname", i); + snprintf (buf, sizeof(buf), "volume%"PRIu64"-volname", i); ret = dict_get_str (src, buf, &volname); if (ret) { gf_log ("", GF_LOG_ERROR, @@ -8843,7 +8842,7 @@ glusterd_snap_config_use_rsp_dict (dict_t *dst, dict_t *src) } snprintf (buf, sizeof(buf), - "volume%ld-snap-max-hard-limit", i); + "volume%"PRIu64"-snap-max-hard-limit", i); ret = dict_get_uint64 (src, buf, &value); if (ret) { gf_log ("", GF_LOG_ERROR, @@ -8858,7 +8857,7 @@ glusterd_snap_config_use_rsp_dict (dict_t *dst, dict_t *src) } snprintf (buf, sizeof(buf), - "volume%ld-active-hard-limit", i); + "volume%"PRIu64"-active-hard-limit", i); ret = dict_get_uint64 (src, buf, &value); if (ret) { gf_log ("", GF_LOG_ERROR, @@ -8873,7 +8872,7 @@ glusterd_snap_config_use_rsp_dict (dict_t *dst, dict_t *src) } snprintf (buf, sizeof(buf), - "volume%ld-snap-max-soft-limit", i); + "volume%"PRIu64"-snap-max-soft-limit", i); ret = dict_get_uint64 (src, buf, &value); if (ret) { gf_log ("", GF_LOG_ERROR, diff --git a/xlators/mgmt/glusterd/src/glusterd-utils.h b/xlators/mgmt/glusterd/src/glusterd-utils.h index 23f8ad7f6..d2121778a 100644 --- a/xlators/mgmt/glusterd/src/glusterd-utils.h +++ b/xlators/mgmt/glusterd/src/glusterd-utils.h @@ -8,7 +8,7 @@ cases as published by the Free Software Foundation. */ #ifndef _GLUSTERD_UTILS_H -#define _GLUSTERD_UTILS_H_ +#define _GLUSTERD_UTILS_H #ifndef _CONFIG_H #define _CONFIG_H @@ -684,14 +684,16 @@ glusterd_rpc_clnt_unref (glusterd_conf_t *conf, rpc_clnt_t *rpc); int32_t glusterd_compare_volume_name(struct list_head *, struct list_head *); -#ifdef GF_LINUX_HOST_OS + char* glusterd_get_brick_mount_details (glusterd_brickinfo_t *brickinfo); + struct mntent * glusterd_get_mnt_entry_info (char *mnt_pt, FILE *mtab); + int glusterd_get_brick_root (char *path, char **mount_point); -#endif //LINUX_HOST + int glusterd_compare_snap_time(struct list_head *, struct list_head *); diff --git a/xlators/mgmt/glusterd/src/glusterd-volgen.c b/xlators/mgmt/glusterd/src/glusterd-volgen.c index ca799aefc..316b70f77 100644 --- a/xlators/mgmt/glusterd/src/glusterd-volgen.c +++ b/xlators/mgmt/glusterd/src/glusterd-volgen.c @@ -741,7 +741,7 @@ int glusterd_volinfo_get_boolean (glusterd_volinfo_t *volinfo, char *key) { char *val = NULL; - gf_boolean_t boo = _gf_false; + gf_boolean_t enabled = _gf_false; int ret = 0; ret = glusterd_volinfo_get (volinfo, key, &val); @@ -749,14 +749,14 @@ glusterd_volinfo_get_boolean (glusterd_volinfo_t *volinfo, char *key) return -1; if (val) - ret = gf_string2boolean (val, &boo); + ret = gf_string2boolean (val, &enabled); if (ret) { gf_log ("", GF_LOG_ERROR, "value for %s option is not valid", key); return -1; } - return boo; + return enabled; } gf_boolean_t @@ -1258,8 +1258,8 @@ static int server_check_marker_off (volgen_graph_t *graph, struct volopt_map_entry *vme, glusterd_volinfo_t *volinfo) { - gf_boolean_t bool = _gf_false; - int ret = 0; + gf_boolean_t enabled = _gf_false; + int ret = 0; GF_ASSERT (volinfo); GF_ASSERT (vme); @@ -1267,8 +1267,8 @@ server_check_marker_off (volgen_graph_t *graph, struct volopt_map_entry *vme, if (strcmp (vme->option, "!xtime") != 0) return 0; - ret = gf_string2boolean (vme->value, &bool); - if (ret || bool) + ret = gf_string2boolean (vme->value, &enabled); + if (ret || enabled) goto out; ret = glusterd_volinfo_get_boolean (volinfo, VKEY_MARKER_XTIME); @@ -1279,10 +1279,10 @@ server_check_marker_off (volgen_graph_t *graph, struct volopt_map_entry *vme, } if (ret) { - bool = _gf_false; - ret = glusterd_check_gsync_running (volinfo, &bool); + enabled = _gf_false; + ret = glusterd_check_gsync_running (volinfo, &enabled); - if (bool) { + if (enabled) { gf_log ("", GF_LOG_WARNING, GEOREP" sessions active" "for the volume %s, cannot disable marker " ,volinfo->volname); diff --git a/xlators/mgmt/glusterd/src/glusterd-volume-ops.c b/xlators/mgmt/glusterd/src/glusterd-volume-ops.c index eac926d95..504aeb839 100644 --- a/xlators/mgmt/glusterd/src/glusterd-volume-ops.c +++ b/xlators/mgmt/glusterd/src/glusterd-volume-ops.c @@ -1213,7 +1213,7 @@ glusterd_op_stage_delete_volume (dict_t *dict, char **op_errstr) if (volinfo->snap_count > 0 || !list_empty(&volinfo->snap_volumes)) { snprintf (msg, sizeof (msg), "Cannot delete Volume %s ," - "as it has %ld snapshots. " + "as it has %"PRIu64" snapshots. " "To delete the volume, " "first delete all the snapshots under it.", volname, volinfo->snap_count); diff --git a/xlators/mgmt/glusterd/src/glusterd-volume-set.c b/xlators/mgmt/glusterd/src/glusterd-volume-set.c index 29e9f2b87..1c5d359d9 100644 --- a/xlators/mgmt/glusterd/src/glusterd-volume-set.c +++ b/xlators/mgmt/glusterd/src/glusterd-volume-set.c @@ -116,8 +116,8 @@ validate_cache_max_min_size (dict_t *dict, char *key, char *value, "performance.cache-max-file-size", ¤t_max_value); if (current_max_value) { - gf_string2bytesize (current_max_value, &max_value); - gf_string2bytesize (value, &min_value); + gf_string2bytesize_uint64 (current_max_value, &max_value); + gf_string2bytesize_uint64 (value, &min_value); current_min_value = value; } } else if ((!strcmp (key, "performance.cache-max-file-size")) || @@ -126,8 +126,8 @@ validate_cache_max_min_size (dict_t *dict, char *key, char *value, "performance.cache-min-file-size", ¤t_min_value); if (current_min_value) { - gf_string2bytesize (current_min_value, &min_value); - gf_string2bytesize (value, &max_value); + gf_string2bytesize_uint64 (current_min_value, &min_value); + gf_string2bytesize_uint64 (value, &max_value); current_max_value = value; } } @@ -1370,6 +1370,18 @@ struct volopt_map_entry glusterd_volopt_map[] = { .type = GLOBAL_DOC, .op_version = 1 }, + { .key = "nfs.rpc-statd", + .voltype = "nfs/server", + .option = "nfs.rpc-statd", + .type = NO_DOC, + .op_version = 4, + }, + { .key = "nfs.log-level", + .voltype = "nfs/server", + .option = "nfs.log-level", + .type = NO_DOC, + .op_version = 4, + }, { .key = "nfs.server-aux-gids", .voltype = "nfs/server", .option = "nfs.server-aux-gids", @@ -1434,6 +1446,10 @@ struct volopt_map_entry glusterd_volopt_map[] = { .voltype = "storage/posix", .op_version = 3 }, + { .key = "storage.xattr-user-namespace-mode", + .voltype = "storage/posix", + .op_version = 4 + }, { .key = "storage.owner-uid", .voltype = "storage/posix", .option = "brick-uid", diff --git a/xlators/mgmt/glusterd/src/glusterd.c b/xlators/mgmt/glusterd/src/glusterd.c index 85a6b920a..abef538d8 100644 --- a/xlators/mgmt/glusterd/src/glusterd.c +++ b/xlators/mgmt/glusterd/src/glusterd.c @@ -30,6 +30,7 @@ #include "dict.h" #include "compat.h" #include "compat-errno.h" +#include "syscall.h" #include "statedump.h" #include "glusterd-sm.h" #include "glusterd-op-sm.h" @@ -311,7 +312,7 @@ out: } -inline int32_t +static inline int32_t glusterd_program_register (xlator_t *this, rpcsvc_t *svc, rpcsvc_program_t *prog) { @@ -804,7 +805,7 @@ check_prepare_mountbroker_root (char *mountbroker_root) dfd0 = dup (dfd); for (;;) { - ret = openat (dfd, "..", O_RDONLY); + ret = sys_openat (dfd, "..", O_RDONLY); if (ret != -1) { dfd2 = ret; ret = fstat (dfd2, &st2); @@ -839,11 +840,11 @@ check_prepare_mountbroker_root (char *mountbroker_root) st = st2; } - ret = mkdirat (dfd0, MB_HIVE, 0711); + ret = sys_mkdirat (dfd0, MB_HIVE, 0711); if (ret == -1 && errno == EEXIST) ret = 0; if (ret != -1) - ret = fstatat (dfd0, MB_HIVE, &st, AT_SYMLINK_NOFOLLOW); + ret = sys_fstatat (dfd0, MB_HIVE, &st, AT_SYMLINK_NOFOLLOW); if (ret == -1 || st.st_mode != (S_IFDIR|0711)) { gf_log ("", GF_LOG_ERROR, "failed to set up mountbroker-root directory %s", diff --git a/xlators/mount/fuse/src/fuse-bridge.c b/xlators/mount/fuse/src/fuse-bridge.c index fd44c4fb5..745617a71 100644 --- a/xlators/mount/fuse/src/fuse-bridge.c +++ b/xlators/mount/fuse/src/fuse-bridge.c @@ -29,6 +29,7 @@ static void fuse_invalidate_inode(xlator_t *this, uint64_t fuse_ino); * Send an invalidate notification up to fuse to purge the file from local * page cache. */ + static int32_t fuse_invalidate(xlator_t *this, inode_t *inode) { @@ -45,8 +46,8 @@ fuse_invalidate(xlator_t *this, inode_t *inode) return 0; nodeid = inode_to_fuse_nodeid(inode); - gf_log(this->name, GF_LOG_DEBUG, "Invalidate inode id %lu.", nodeid); - fuse_log_eh (this, "Sending invalidate inode id: %lu gfid: %s", nodeid, + gf_log(this->name, GF_LOG_DEBUG, "Invalidate inode id %"GF_PRI_INODE"." , nodeid); + fuse_log_eh (this, "Sending invalidate inode id: %"GF_PRI_INODE" gfid: %s", nodeid, uuid_utoa (inode->gfid)); fuse_invalidate_inode(this, nodeid); @@ -236,6 +237,7 @@ send_fuse_data (xlator_t *this, fuse_in_header_t *finh, void *data, size_t size) send_fuse_data (this, finh, obj, sizeof (*(obj))) +#if FUSE_KERNEL_MINOR_VERSION >= 11 static void fuse_invalidate_entry (xlator_t *this, uint64_t fuse_ino) { @@ -293,6 +295,7 @@ fuse_invalidate_entry (xlator_t *this, uint64_t fuse_ino) if (inode) inode_unref (inode); } +#endif /* * Send an inval inode notification to fuse. This causes an invalidation of the @@ -301,6 +304,7 @@ fuse_invalidate_entry (xlator_t *this, uint64_t fuse_ino) static void fuse_invalidate_inode(xlator_t *this, uint64_t fuse_ino) { +#if FUSE_KERNEL_MINOR_VERSION >= 11 struct fuse_out_header *fouh = NULL; struct fuse_notify_inval_inode_out *fniio = NULL; fuse_private_t *priv = NULL; @@ -346,8 +350,13 @@ fuse_invalidate_inode(xlator_t *this, uint64_t fuse_ino) if (inode) inode_unref (inode); +#else + gf_log ("glusterfs-fuse", GF_LOG_WARNING, + "fuse_invalidate_inode not implemented on OS X due to missing FUSE notification"); +#endif } + int send_fuse_err (xlator_t *this, fuse_in_header_t *finh, int error) { @@ -368,7 +377,7 @@ send_fuse_err (xlator_t *this, fuse_in_header_t *finh, int error) uuid_utoa (inode->gfid)); } else { fuse_log_eh (this, "Sending %s for operation %d on " - "inode %ld", strerror (error), + "inode %" GF_PRI_INODE, strerror (error), finh->opcode, finh->nodeid); } } @@ -624,6 +633,7 @@ fuse_forget (xlator_t *this, fuse_in_header_t *finh, void *msg) GF_FREE (finh); } +#if FUSE_KERNEL_MINOR_VERSION >= 16 static void fuse_batch_forget(xlator_t *this, fuse_in_header_t *finh, void *msg) { @@ -640,9 +650,9 @@ fuse_batch_forget(xlator_t *this, fuse_in_header_t *finh, void *msg) continue; do_forget(this, finh->unique, ffo[i].nodeid, ffo[i].nlookup); } - GF_FREE(finh); } +#endif static int fuse_truncate_cbk (call_frame_t *frame, void *cookie, xlator_t *this, @@ -1142,7 +1152,9 @@ fuse_setattr (xlator_t *this, fuse_in_header_t *finh, void *msg) { struct fuse_setattr_in *fsi = msg; +#if FUSE_KERNEL_MINOR_VERSION >= 9 fuse_private_t *priv = NULL; +#endif fuse_state_t *state = NULL; GET_STATE (this, finh, state); @@ -1170,8 +1182,8 @@ fuse_setattr (xlator_t *this, fuse_in_header_t *finh, void *msg) * http://git.kernel.org/?p=linux/kernel/git/torvalds/ * linux-2.6.git;a=commit;h=v2.6.23-5896-gf333211 */ - priv = this->private; #if FUSE_KERNEL_MINOR_VERSION >= 9 + priv = this->private; if (priv->proto_minor >= 9 && fsi->valid & FATTR_LOCKOWNER) state->lk_owner = fsi->lock_owner; #endif @@ -1448,11 +1460,11 @@ fuse_mknod (xlator_t *this, fuse_in_header_t *finh, void *msg) char *name = (char *)(fmi + 1); fuse_state_t *state = NULL; +#if FUSE_KERNEL_MINOR_VERSION >= 12 fuse_private_t *priv = NULL; - int32_t ret = -1; + int32_t ret = -1; priv = this->private; -#if FUSE_KERNEL_MINOR_VERSION >= 12 if (priv->proto_minor < 12) name = (char *)msg + FUSE_COMPAT_MKNOD_IN_SIZE; #endif @@ -1466,8 +1478,8 @@ fuse_mknod (xlator_t *this, fuse_in_header_t *finh, void *msg) state->mode = fmi->mode; state->rdev = fmi->rdev; - priv = this->private; #if FUSE_KERNEL_MINOR_VERSION >=12 + priv = this->private; FUSE_ENTRY_CREATE(this, priv, finh, state, fmi, "MKNOD"); #endif @@ -1515,10 +1527,12 @@ fuse_mkdir (xlator_t *this, fuse_in_header_t *finh, void *msg) { struct fuse_mkdir_in *fmi = msg; char *name = (char *)(fmi + 1); +#if FUSE_KERNEL_MINOR_VERSION >=12 fuse_private_t *priv = NULL; + int32_t ret = -1; +#endif fuse_state_t *state; - int32_t ret = -1; GET_STATE (this, finh, state); @@ -1528,8 +1542,8 @@ fuse_mkdir (xlator_t *this, fuse_in_header_t *finh, void *msg) state->mode = fmi->mode; - priv = this->private; #if FUSE_KERNEL_MINOR_VERSION >=12 + priv = this->private; FUSE_ENTRY_CREATE(this, priv, finh, state, fmi, "MKDIR"); #endif @@ -2004,17 +2018,17 @@ fuse_create (xlator_t *this, fuse_in_header_t *finh, void *msg) { #if FUSE_KERNEL_MINOR_VERSION >= 12 struct fuse_create_in *fci = msg; + fuse_private_t *priv = NULL; + int32_t ret = -1; #else struct fuse_open_in *fci = msg; #endif char *name = (char *)(fci + 1); - fuse_private_t *priv = NULL; fuse_state_t *state = NULL; - int32_t ret = -1; - priv = this->private; #if FUSE_KERNEL_MINOR_VERSION >= 12 + priv = this->private; if (priv->proto_minor < 12) name = (char *)((struct fuse_open_in *)msg + 1); #endif @@ -2028,8 +2042,8 @@ fuse_create (xlator_t *this, fuse_in_header_t *finh, void *msg) state->mode = fci->mode; state->flags = fci->flags; - priv = this->private; #if FUSE_KERNEL_MINOR_VERSION >=12 + priv = this->private; FUSE_ENTRY_CREATE(this, priv, finh, state, fci, "CREATE"); #endif fuse_resolve_and_resume (state, fuse_create_resume); @@ -2167,7 +2181,9 @@ fuse_readv (xlator_t *this, fuse_in_header_t *finh, void *msg) { struct fuse_read_in *fri = msg; +#if FUSE_KERNEL_MINOR_VERSION >= 9 fuse_private_t *priv = NULL; +#endif fuse_state_t *state = NULL; fd_t *fd = NULL; @@ -2179,8 +2195,8 @@ fuse_readv (xlator_t *this, fuse_in_header_t *finh, void *msg) fuse_resolve_fd_init (state, &state->resolve, fd); /* See comment by similar code in fuse_settatr */ - priv = this->private; #if FUSE_KERNEL_MINOR_VERSION >= 9 + priv = this->private; if (priv->proto_minor >= 9 && fri->read_flags & FUSE_READ_LOCKOWNER) state->lk_owner = fri->lock_owner; #endif @@ -2188,8 +2204,9 @@ fuse_readv (xlator_t *this, fuse_in_header_t *finh, void *msg) state->size = fri->size; state->off = fri->offset; /* lets ignore 'fri->read_flags', but just consider 'fri->flags' */ +#if FUSE_KERNEL_MINOR_VERSION >= 9 state->io_flags = fri->flags; - +#endif fuse_resolve_and_resume (state, fuse_readv_resume); } @@ -2270,11 +2287,12 @@ fuse_write (xlator_t *this, fuse_in_header_t *finh, void *msg) struct fuse_write_in *fwi = (struct fuse_write_in *) (finh + 1); - fuse_private_t *priv = NULL; fuse_state_t *state = NULL; fd_t *fd = NULL; - +#if FUSE_KERNEL_MINOR_VERSION >= 9 + fuse_private_t *priv = NULL; priv = this->private; +#endif GET_STATE (this, finh, state); fd = FH_TO_FD (fwi->fh); @@ -2283,7 +2301,11 @@ fuse_write (xlator_t *this, fuse_in_header_t *finh, void *msg) state->off = fwi->offset; /* lets ignore 'fwi->write_flags', but just consider 'fwi->flags' */ +#if FUSE_KERNEL_MINOR_VERSION >= 9 state->io_flags = fwi->flags; +#else + state->io_flags = fwi->write_flags; +#endif /* TODO: may need to handle below flag (fwi->write_flags & FUSE_WRITE_CACHE); */ @@ -2292,8 +2314,8 @@ fuse_write (xlator_t *this, fuse_in_header_t *finh, void *msg) fuse_resolve_fd_init (state, &state->resolve, fd); /* See comment by similar code in fuse_settatr */ - priv = this->private; #if FUSE_KERNEL_MINOR_VERSION >= 9 + priv = this->private; if (priv->proto_minor >= 9 && fwi->write_flags & FUSE_WRITE_LOCKOWNER) state->lk_owner = fwi->lock_owner; #endif @@ -2636,7 +2658,7 @@ fuse_readdir (xlator_t *this, fuse_in_header_t *finh, void *msg) fuse_resolve_and_resume (state, fuse_readdir_resume); } - +#if FUSE_KERNEL_MINOR_VERSION >= 20 static int fuse_readdirp_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret, int32_t op_errno, gf_dirent_t *entries, @@ -2751,7 +2773,6 @@ out: } - void fuse_readdirp_resume (fuse_state_t *state) { @@ -2782,7 +2803,9 @@ fuse_readdirp (xlator_t *this, fuse_in_header_t *finh, void *msg) fuse_resolve_and_resume (state, fuse_readdirp_resume); } +#endif +#if FUSE_KERNEL_MINOR_VERSION >= 19 #ifdef FALLOC_FL_KEEP_SIZE static int fuse_fallocate_cbk(call_frame_t *frame, void *cookie, xlator_t *this, @@ -2825,7 +2848,7 @@ fuse_fallocate(xlator_t *this, fuse_in_header_t *finh, void *msg) fuse_resolve_and_resume(state, fuse_fallocate_resume); } #endif /* FALLOC_FL_KEEP_SIZE */ - +#endif /* FUSE minor version >= 19 */ static void fuse_releasedir (xlator_t *this, fuse_in_header_t *finh, void *msg) @@ -3097,7 +3120,9 @@ fuse_setxattr (xlator_t *this, fuse_in_header_t *finh, void *msg) gf_log ("fuse", GF_LOG_TRACE, "got request to invalidate %"PRIu64, finh->nodeid); send_fuse_err (this, finh, 0); +#if FUSE_KERNEL_MINOR_VERSION >= 11 fuse_invalidate_entry (this, finh->nodeid); +#endif GF_FREE (finh); return; } @@ -3746,7 +3771,7 @@ fuse_setlk (xlator_t *this, fuse_in_header_t *finh, void *msg) return; } - +#if FUSE_KERNEL_MINOR_VERSION >= 11 static void * notify_kernel_loop (void *data) { @@ -3782,7 +3807,7 @@ notify_kernel_loop (void *data) return NULL; } - +#endif static void fuse_init (xlator_t *this, fuse_in_header_t *finh, void *msg) @@ -3791,8 +3816,10 @@ fuse_init (xlator_t *this, fuse_in_header_t *finh, void *msg) struct fuse_init_out fino = {0,}; fuse_private_t *priv = NULL; int ret = 0; +#if FUSE_KERNEL_MINOR_VERSION >= 9 int pfd[2] = {0,}; pthread_t messenger; +#endif priv = this->private; @@ -3885,16 +3912,17 @@ fuse_init (xlator_t *this, fuse_in_header_t *finh, void *msg) } if (fini->minor < 9) *priv->msg0_len_p = sizeof(*finh) + FUSE_COMPAT_WRITE_IN_SIZE; -#endif + if (priv->use_readdirp) { if (fini->flags & FUSE_DO_READDIRPLUS) fino.flags |= FUSE_DO_READDIRPLUS; } - +#endif if (priv->fopen_keep_cache == 2) { /* If user did not explicitly set --fopen-keep-cache[=off], then check if kernel support FUSE_AUTO_INVAL_DATA and ... */ +#if FUSE_KERNEL_MINOR_VERSION >= 20 if (fini->flags & FUSE_AUTO_INVAL_DATA) { /* ... enable fopen_keep_cache mode if supported. */ @@ -3903,7 +3931,10 @@ fuse_init (xlator_t *this, fuse_in_header_t *finh, void *msg) "fopen_keep_cache automatically."); fino.flags |= FUSE_AUTO_INVAL_DATA; priv->fopen_keep_cache = 1; - } else { + } else +#endif + { + gf_log ("glusterfs-fuse", GF_LOG_DEBUG, "No support " "for FUSE_AUTO_INVAL_DATA. Disabling " "fopen_keep_cache."); @@ -3914,20 +3945,24 @@ fuse_init (xlator_t *this, fuse_in_header_t *finh, void *msg) /* If user explicitly set --fopen-keep-cache[=on], then enable FUSE_AUTO_INVAL_DATA if possible. */ +#if FUSE_KERNEL_MINOR_VERSION >= 20 if (fini->flags & FUSE_AUTO_INVAL_DATA) { gf_log ("glusterfs-fuse", GF_LOG_DEBUG, "fopen_keep_cache " "is explicitly set. Enabling FUSE_AUTO_INVAL_DATA"); fino.flags |= FUSE_AUTO_INVAL_DATA; - } else { + } else +#endif + { gf_log ("glusterfs-fuse", GF_LOG_WARNING, "fopen_keep_cache " "is explicitly set. Support for " "FUSE_AUTO_INVAL_DATA is missing"); } } +#if FUSE_KERNEL_MINOR_VERSION >= 22 if (fini->flags & FUSE_ASYNC_DIO) fino.flags |= FUSE_ASYNC_DIO; - +#endif ret = send_fuse_obj (this, finh, &fino); if (ret == 0) gf_log ("glusterfs-fuse", GF_LOG_INFO, @@ -5142,11 +5177,20 @@ static fuse_handler_t *fuse_std_ops[FUSE_OP_HIGH] = { /* [FUSE_IOCTL] */ /* [FUSE_POLL] */ /* [FUSE_NOTIFY_REPLY] */ + +#if FUSE_KERNEL_MINOR_VERSION >= 16 [FUSE_BATCH_FORGET]= fuse_batch_forget, +#endif + +#if FUSE_KERNEL_MINOR_VERSION >= 19 #ifdef FALLOC_FL_KEEP_SIZE [FUSE_FALLOCATE] = fuse_fallocate, #endif /* FALLOC_FL_KEEP_SIZE */ +#endif + +#if FUSE_KERNEL_MINOR_VERSION >= 21 [FUSE_READDIRPLUS] = fuse_readdirp, +#endif }; @@ -5279,13 +5323,13 @@ init (xlator_t *this_xl) goto cleanup_exit; } - GF_OPTION_INIT ("attribute-timeout", priv->attribute_timeout, double, + GF_OPTION_INIT (ZR_ATTR_TIMEOUT_OPT, priv->attribute_timeout, double, cleanup_exit); - GF_OPTION_INIT ("entry-timeout", priv->entry_timeout, double, + GF_OPTION_INIT (ZR_ENTRY_TIMEOUT_OPT, priv->entry_timeout, double, cleanup_exit); - GF_OPTION_INIT ("negative-timeout", priv->negative_timeout, double, + GF_OPTION_INIT (ZR_NEGATIVE_TIMEOUT_OPT, priv->negative_timeout, double, cleanup_exit); GF_OPTION_INIT ("client-pid", priv->client_pid, int32, cleanup_exit); diff --git a/xlators/mount/fuse/src/fuse-helpers.c b/xlators/mount/fuse/src/fuse-helpers.c index 2774bdaa8..0936d6311 100644 --- a/xlators/mount/fuse/src/fuse-helpers.c +++ b/xlators/mount/fuse/src/fuse-helpers.c @@ -235,7 +235,7 @@ out: if (sysctl(name, namelen, &kp, &kplen, NULL, 0) != 0) return; - ngroups = MIN(kp.kp_eproc.e_ucred.cr_ngroups, GF_MAX_AUX_GROUPS); + ngroups = MIN(kp.kp_eproc.e_ucred.cr_ngroups, NGROUPS_MAX); if (call_stack_alloc_groups (frame->root, ngroups) != 0) return; for (i = 0; i < ngroups; i++) diff --git a/xlators/mount/fuse/utils/mount_glusterfs.in b/xlators/mount/fuse/utils/mount_glusterfs.in index b12b4e04e..539b0f558 100755 --- a/xlators/mount/fuse/utils/mount_glusterfs.in +++ b/xlators/mount/fuse/utils/mount_glusterfs.in @@ -1,188 +1,538 @@ #!/bin/sh -# (C) 2008 Gluster Inc. -# +# (C) 2014 Red Hat Inc. +# # This program is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License as # published by the Free Software Foundation; either version 2 of # the License, or (at your option) any later version. -# +# # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. -# +# # You should have received a copy of the GNU General Public # License along with this program; if not, write to the Free # Software Foundation, Inc., 51 Franklin Street, Fifth Floor, # Boston, MA 02110-1301 USA +warn () +{ + echo "$@" >/dev/stderr +} _init () { + # log level definitions LOG_NONE=NONE; LOG_CRITICAL=CRITICAL; LOG_ERROR=ERROR; LOG_WARNING=WARNING; - LOG_INFO=INFO; + LOG_INFO=INFO LOG_DEBUG=DEBUG; + LOG_TRACE=TRACE; - # set default log level to ERROR - log_level=$LOG_INFO; -} + HOST_NAME_MAX=64; -start_glusterfs () -{ prefix="@prefix@"; exec_prefix=@exec_prefix@; cmd_line=$(echo "@sbindir@/glusterfs"); - + + alias lsL='ls -L' + uname_s=`uname -s` + case ${uname_s} in + Darwin) + getinode="stat -f %i" + getdev="stat -f %d" + ;; + esac +} + +is_valid_hostname () +{ + local server=$1 + + length=$(echo $server | wc -c) + if [ ${length} -gt ${HOST_NAME_MAX} ]; then + return 1 + fi +} + +parse_backup_volfile_servers () +{ + local server_list=$1 + local servers="" + local new_servers="" + + servers=$(echo ${server_list} | sed 's/\:/ /g') + for server in ${servers}; do + is_valid_hostname ${server} + if [ $? -eq 1 ]; then + continue + fi + new_servers=$(echo "${new_servers} ${server}") + done + + echo ${new_servers} +} + +parse_volfile_servers () +{ + local server_list=$1 + local servers="" + local new_servers="" + + servers=$(echo ${server_list} | sed 's/,/ /g') + for server in ${servers}; do + is_valid_hostname ${server} + if [ $? -eq 1 ]; then + continue + fi + new_servers=$(echo "${new_servers} ${server}") + done + + echo ${new_servers} +} + +start_glusterfs () +{ if [ -n "$log_level_str" ]; then - case "$log_level_str" in - "ERROR") - log_level=$LOG_ERROR; - ;; + case "$( echo $log_level_str | awk '{print toupper($0)}')" in + "ERROR") + log_level=$LOG_ERROR; + ;; "INFO") log_level=$LOG_INFO; ;; - "DEBUG") - log_level=$LOG_DEBUG; - ;; - "CRITICAL") - log_level=$LOG_CRITICAL; - ;; - "WARNING") - log_level=$LOG_WARNING; - ;; - "NONE") - log_level=$LOG_NONE; - ;; - *) - echo "invalid log level $log_level_str, using INFO"; - log_level=$LOG_INFO; - ;; - esac - fi - cmd_line=$(echo "$cmd_line --log-level=$log_level"); - - if [ -n "$log_file" ]; then - cmd_line=$(echo "$cmd_line --log-file=$log_file"); + "DEBUG") + log_level=$LOG_DEBUG; + ;; + "CRITICAL") + log_level=$LOG_CRITICAL; + ;; + "WARNING") + log_level=$LOG_WARNING; + ;; + "TRACE") + log_level=$LOG_TRACE; + ;; + "NONE") + log_level=$LOG_NONE; + ;; + *) + warn "invalid log level $log_level_str, using INFO"; + log_level=$LOG_INFO; + ;; + esac + fi + + # options without values start here + if [ -n "$read_only" ]; then + cmd_line=$(echo "$cmd_line --read-only"); + fi + + if [ -n "$acl" ]; then + cmd_line=$(echo "$cmd_line --acl"); + fi + + if [ -n "$selinux" ]; then + cmd_line=$(echo "$cmd_line --selinux"); + fi + + if [ -n "$enable_ino32" ]; then + cmd_line=$(echo "$cmd_line --enable-ino32"); + fi + + if [ -n "$worm" ]; then + cmd_line=$(echo "$cmd_line --worm"); + fi + if [ -n "$volfile_max_fetch_attempts" ]; then + cmd_line=$(echo "$cmd_line --volfile-max-fetch-attempts=$volfile_max_fetch_attempts") + fi + + if [ -n "$fopen_keep_cache" ]; then + cmd_line=$(echo "$cmd_line --fopen-keep-cache"); fi if [ -n "$volfile_check" ]; then - cmd_line=$(echo "$cmd_line --volfile-check"); + cmd_line=$(echo "$cmd_line --volfile-check"); + fi + + if [ -n "$mem_accounting" ]; then + cmd_line=$(echo "$cmd_line --mem-accounting"); + fi + + if [ -n "$aux_gfid_mount" ]; then + cmd_line=$(echo "$cmd_line --aux-gfid-mount"); + fi + + if [ -n "$no_root_squash" ]; then + cmd_line=$(echo "$cmd_line --no-root-squash"); + fi + +#options with values start here + if [ -n "$log_level" ]; then + cmd_line=$(echo "$cmd_line --log-level=$log_level"); + fi + + if [ -n "$log_file" ]; then + cmd_line=$(echo "$cmd_line --log-file=$log_file"); fi if [ -n "$direct_io_mode" ]; then - cmd_line=$(echo "$cmd_line --disable-direct-io-mode"); + cmd_line=$(echo "$cmd_line --direct-io-mode=$direct_io_mode"); fi - - if [ -z "$volfile_loc" ]; then - if [ -n "$transport" ]; then - cmd_line=$(echo "$cmd_line \ ---volfile-server=$server_ip \ ---volfile-server-transport=$transport"); - else - cmd_line=$(echo "$cmd_line \ ---volfile-server=$server_ip"); - fi - else - cmd_line=$(echo "$cmd_line --volfile=$volfile_loc"); + + if [ -n "$mac_compat" ]; then + cmd_line=$(echo "$cmd_line --mac-compat=$mac_compat"); + fi + + if [ -n "$use_readdirp" ]; then + cmd_line=$(echo "$cmd_line --use-readdirp=$use_readdirp"); fi if [ -n "$volume_name" ]; then cmd_line=$(echo "$cmd_line --volume-name=$volume_name"); fi - - if [ -n "$volume_id" ]; then - cmd_line=$(echo "$cmd_line --volfile-id=$volume_id"); + + if [ -n "$attribute_timeout" ]; then + cmd_line=$(echo "$cmd_line --attribute-timeout=$attribute_timeout"); + fi + + if [ -n "$entry_timeout" ]; then + cmd_line=$(echo "$cmd_line --entry-timeout=$entry_timeout"); + fi + + if [ -n "$negative_timeout" ]; then + cmd_line=$(echo "$cmd_line --negative-timeout=$negative_timeout"); + fi + + if [ -n "$gid_timeout" ]; then + cmd_line=$(echo "$cmd_line --gid-timeout=$gid_timeout"); + fi + + if [ -n "$bg_qlen" ]; then + cmd_line=$(echo "$cmd_line --background-qlen=$bg_qlen"); + fi + + if [ -n "$cong_threshold" ]; then + cmd_line=$(echo "$cmd_line --congestion-threshold=$cong_threshold"); + fi + + if [ -n "$fuse_mountopts" ]; then + cmd_line=$(echo "$cmd_line --fuse-mountopts=$fuse_mountopts"); + fi + + if [ -n "$xlator_option" ]; then + cmd_line=$(echo "$cmd_line --xlator-option=$xlator_option"); + fi + + # for rdma volume, we have to fetch volfile with '.rdma' added + # to volume name, so that it fetches the right client vol file + volume_id_rdma=""; + + if [ -z "$volfile_loc" ]; then + if [ -n "$server_ip" ]; then + + servers=$(parse_volfile_servers ${server_ip}); + if [ -n "$servers" ]; then + for i in $(echo ${servers}); do + cmd_line=$(echo "$cmd_line --volfile-server=$i"); + done + else + warn "ERROR: No valid servers found on command line.. exiting" + print_usage + exit 1 + fi + + if [ -n "$backupvolfile_server" ]; then + if [ -z "$backup_volfile_servers" ]; then + is_valid_hostname ${backupvolfile_server}; + if [ $? -eq 1 ]; then + warn "ERROR: Invalid backup server specified.. exiting" + exit 1 + fi + cmd_line=$(echo "$cmd_line --volfile-server=$backupvolfile_server"); + fi + fi + + if [ -n "$backup_volfile_servers" ]; then + backup_servers=$(parse_backup_volfile_servers ${backup_volfile_servers}) + for i in $(echo ${backup_servers}); do + cmd_line=$(echo "$cmd_line --volfile-server=$i"); + done + fi + + if [ -n "$server_port" ]; then + cmd_line=$(echo "$cmd_line --volfile-server-port=$server_port"); + fi + + if [ -n "$transport" ]; then + cmd_line=$(echo "$cmd_line --volfile-server-transport=$transport"); + if [ "$transport" = "rdma" ]; then + volume_id_rdma=".rdma"; + fi + fi + + if [ -n "$volume_id" ]; then + if [ -n "$volume_id_rdma" ]; then + volume_id="$volume_id$volume_id_rdma"; + fi + cmd_line=$(echo "$cmd_line --volfile-id=$volume_id"); + fi + fi + else + cmd_line=$(echo "$cmd_line --volfile=$volfile_loc"); + fi + + if [ -n "$fuse_mountopts" ]; then + cmd_line=$(echo "$cmd_line --fuse-mountopts=$fuse_mountopts"); fi cmd_line=$(echo "$cmd_line $mount_point"); - exec $cmd_line; + $cmd_line; + + if [ $? -ne 0 ]; then + exit 1; + fi } +print_usage () +{ +cat << EOF >/dev/stderr +Usage: $0 : -o +Options: +man 8 $0 +To display the version number of the mount helper: $0 -V +EOF +} -main () +with_options() { - - new_log_level="" - log_file="" - transport="" - direct_io_mode="" - volume_name="" - new_fs_options="" - volfile_check="" - - while getopts o: opt; do - case "$opt" in - o) - options=$(echo $OPTARG | sed -n 's/.*\-o[ ]*\([^ ]*\).*/\1/p'); - [ -z $new_log_level ] && { - new_log_level=$(echo "$options" | sed -n 's/.*log-level=\([^,]*\).*/\1/p'); - } - - [ -z $log_file ] && { - log_file=$(echo "$options" | sed -n 's/.*log-file=\([^,]*\).*/\1/p'); - } - - [ -z $transport ] && { - transport=$(echo "$options" | sed -n 's/.*transport=\([^,]*\).*/\1/p'); - } - - [ -z $direct_io_mode ] && { - direct_io_mode=$(echo "$options" | sed -n 's/.*direct-io-mode=\([^,]*\).*/\1/p'); - } - - [ -z $volfile_check ] && { - volfile_check=$(echo "$options" | sed -n 's/.*volfile-check=\([^,]*\).*/\1/p'); - } - - [ -z $volume_name ] && { - volume_name=$(echo "$options" | sed -n 's/.*volume-name=\([^,]*\).*/\1/p'); - } - - [ -z $volume_id ] && { - volume_id=$(echo "$options" | sed -n 's/.*volume-id=\([^,]*\).*/\1/p'); - } - - this_option=$(echo "$options" | sed -e 's/[,]*log-file=[^,]*//' \ - -e 's/[,]*log-level=[^,]*//' \ - -e 's/[,]*volume-name=[^,]*//' \ - -e 's/[,]*volfile-check=[^,]*//' \ - -e 's/[,]*direct-io-mode=[^,]*//' \ - -e 's/[,]*transport=[^,]*//' \ - -e 's/[,]*volume-id=[^,]*//'); - new_fs_options="$new_fs_options $this_option"; - ;; - esac + local key=$1 + local value=$2 + + # Handle options with values. + case "$key" in + "log-level") + log_level_str=$value + ;; + "log-file") + log_file=$value + ;; + "transport") + transport=$value + ;; + "direct-io-mode") + direct_io_mode=$value + ;; + "mac-compat") + mac_compat=$value + ;; + "volume-name") + volume_name=$value + ;; + "volume-id") + volume_id=$value + ;; + "volfile-check") + volfile_check=$value + ;; + "server-port") + server_port=$value + ;; + "attribute-timeout") + attribute_timeout=$value + ;; + "entry-timeout") + entry_timeout=$value + ;; + "negative-timeout") + negative_timeout=$value + ;; + "gid-timeout") + gid_timeout=$value + ;; + "background-qlen") + bg_qlen=$value + ;; + "backup-volfile-servers") + backup_volfile_servers=$value + ;; + "backupvolfile-server") + backupvolfile_server=$value + ;; + "fetch-attempts") + volfile_max_fetch_attempts=$value + ;; + "congestion-threshold") + cong_threshold=$value + ;; + "xlator-option") + xlator_option=$value + ;; + "fuse-mountopts") + fuse_mountopts=$value + ;; + "use-readdirp") + use_readdirp=$value + ;; + "no-root-squash") + if [ $value == "yes" ] || + [ $value == "on" ] || + [ $value == "enable" ] || + [ $value == "true" ] ; then + no_root_squash=1; + fi ;; + "root-squash") + if [ $value == "no" ] || + [ $value == "off" ] || + [ $value == "disable" ] || + [ $value == "false" ] ; then + no_root_squash=1; + fi ;; + *) + warn "Invalid option: $key" + exit 1 + ;; + esac +} + +without_options() +{ + local option=$1 + # Handle options without values. + case "$option" in + "ro") + read_only=1 + ;; + "acl") + acl=1 + ;; + "selinux") + selinux=1 + ;; + "worm") + worm=1 + ;; + "fopen-keep-cache") + fopen_keep_cache=1 + ;; + "enable-ino32") + enable_ino32=1 + ;; + "mem-accounting") + mem_accounting=1 + ;; + "aux-gfid-mount") + if [ ${uname_s} = "Linux" ]; then + aux_gfid_mount=1 + fi + ;; + # "mount -t glusterfs" sends this, but it's useless. + "rw") + ;; + # these ones are interpreted during system initialization + "noauto") + ;; + "_netdev") + ;; + *) + warn "Invalid option $option"; + exit 1 + ;; + esac +} + +parse_options() +{ + local optarg=${1} + for pair in $(echo ${optarg//,/ }); do + key=$(echo "$pair" | cut -f1 -d'='); + value=$(echo "$pair" | cut -f2- -d'='); + if [ "$key" = "$value" ]; then + without_options $pair; + else + with_options $key $value; + fi done +} - [ -n "$new_log_level" ] && { - log_level_str="$new_log_level"; - } +main () +{ + ## `mount` on OSX specifies options as first argument + if [[ $1 =~ "-o" ]]; then + volfile_loc=$3 + mount_point=$4 + else + volfile_loc=$1 + mount_point=$2 + fi - # TODO: use getopt. This is very much darwin specific - volfile_loc="$1"; - while [ "$volfile_loc" = "-o" ] ; do - shift ; - shift ; - volfile_loc="$1"; + while getopts "Vo:h" opt; do + case "${opt}" in + o) + parse_options ${OPTARG}; + ;; + V) + ${cmd_line} -V; + exit 0; + ;; + h) + print_usage; + exit 0; + ;; + ?) + print_usage; + exit 0; + ;; + esac done - + [ -r "$volfile_loc" ] || { server_ip=$(echo "$volfile_loc" | sed -n 's/\([a-zA-Z0-9:.\-]*\):.*/\1/p'); - volume_id=$(echo "$volfile_loc" | sed -n 's/[a-zA-Z0-9:.\-]*:\(.*\)/\1/p'); - volfile_loc=""; + volume_str=$(echo "$volfile_loc" | sed -n 's/.*:\([^ ]*\).*/\1/p'); + [ -n "$volume_str" ] && { + volume_id="$volume_str"; + } + volfile_loc=""; + } + + [ -z "$volume_id" -o -z "$server_ip" ] && { + cat </dev/stderr +ERROR: Server name/volume name unspecified cannot proceed further.. +Please specify correct format +Usage: +man 8 $0 +EOF + exit 1; + } + + grep_ret=$(echo ${mount_point} | grep '^\-o'); + [ "x" != "x${grep_ret}" ] && { + cat </dev/stderr +ERROR: -o options cannot be specified in either first two arguments.. +Please specify correct style +Usage: +man 8 $0 +EOF + exit 1; + } + + # No need to do a ! -d test, it is taken care while initializing the + # variable mount_point + [ -z "$mount_point" -o ! -d "$mount_point" ] && { + cat </dev/stderr +ERROR: Mount point does not exist +Please specify a mount point +Usage: +man 8 $0 +EOF + exit 1; } - # following line is product of love towards sed - # $2=$(echo "$@" | sed -n 's/[^ ]* \([^ ]*\).*/\1/p'); - - mount_point="$2"; - fs_options=$(echo "$fs_options,$new_fs_options"); - start_glusterfs; } diff --git a/xlators/nfs/server/src/nfs-fops.c b/xlators/nfs/server/src/nfs-fops.c index b91f73a53..56d4cba47 100644 --- a/xlators/nfs/server/src/nfs-fops.c +++ b/xlators/nfs/server/src/nfs-fops.c @@ -38,20 +38,25 @@ nfs_fix_groups (xlator_t *this, call_stack_t *root) struct passwd mypw; char mystrs[1024]; struct passwd *result; +#ifdef GF_DARWIN_HOST_OS + /* BSD/DARWIN does not correctly uses gid_t in getgrouplist */ + int mygroups[GF_MAX_AUX_GROUPS]; +#else gid_t mygroups[GF_MAX_AUX_GROUPS]; +#endif int ngroups; int i; int max_groups; struct nfs_state *priv = this->private; const gid_list_t *agl; - gid_list_t gl; + gid_list_t gl; if (!priv->server_aux_gids) { return; } - /* RPC enforces the GF_AUTH_GLUSTERFS_MAX_GROUPS limit */ - max_groups = GF_AUTH_GLUSTERFS_MAX_GROUPS(root->lk_owner.len); + /* RPC enforces the GF_AUTH_GLUSTERFS_MAX_GROUPS limit */ + max_groups = GF_AUTH_GLUSTERFS_MAX_GROUPS(root->lk_owner.len); agl = gid_cache_lookup(&priv->gid_cache, root->uid, 0, 0); if (agl) { diff --git a/xlators/nfs/server/src/nfs.c b/xlators/nfs/server/src/nfs.c index d962663ba..918e86312 100644 --- a/xlators/nfs/server/src/nfs.c +++ b/xlators/nfs/server/src/nfs.c @@ -35,12 +35,16 @@ #include "options.h" #include "acl3.h" #include "rpc-drc.h" +#include "syscall.h" #define STRINGIFY(val) #val #define TOSTRING(val) STRINGIFY(val) #define OPT_SERVER_AUX_GIDS "nfs.server-aux-gids" #define OPT_SERVER_GID_CACHE_TIMEOUT "nfs.server.aux-gid-timeout" +#define OPT_SERVER_RPC_STATD "nfs.rpc-statd" +#define OPT_SERVER_RPC_STATD_PIDFILE "nfs.rpc-statd-pidfile" +#define OPT_SERVER_RPC_STATD_NOTIFY_PIDFILE "nfs.rpc-statd-notify-pidfile" /* TODO: DATADIR should be based on configure's $(localstatedir) */ #define DATADIR "/var/lib/glusterd" @@ -942,10 +946,14 @@ nfs_init_state (xlator_t *this) goto free_foppool; } } + GF_OPTION_INIT (OPT_SERVER_RPC_STATD, nfs->rpc_statd, path, free_foppool); + + GF_OPTION_INIT (OPT_SERVER_RPC_STATD_PIDFILE, nfs->rpc_statd_pid_file, path, free_foppool); GF_OPTION_INIT (OPT_SERVER_AUX_GIDS, nfs->server_aux_gids, bool, free_foppool); - GF_OPTION_INIT (OPT_SERVER_GID_CACHE_TIMEOUT, nfs->server_aux_gids_max_age, + GF_OPTION_INIT (OPT_SERVER_GID_CACHE_TIMEOUT, + nfs->server_aux_gids_max_age, uint32, free_foppool); if (gid_cache_init(&nfs->gid_cache, nfs->server_aux_gids_max_age) < 0) { @@ -953,9 +961,17 @@ nfs_init_state (xlator_t *this) goto free_foppool; } - if (stat("/sbin/rpc.statd", &stbuf) == -1) { - gf_log (GF_NFS, GF_LOG_WARNING, "/sbin/rpc.statd not found. " - "Disabling NLM"); + ret = sys_access (nfs->rpc_statd, X_OK); + if (ret) { + gf_log (GF_NFS, GF_LOG_WARNING, "%s not enough permissions to" + " access. Disabling NLM", nfs->rpc_statd); + nfs->enable_nlm = _gf_false; + } + + ret = sys_stat (nfs->rpc_statd, &stbuf); + if (ret || !S_ISREG (stbuf.st_mode)) { + gf_log (GF_NFS, GF_LOG_WARNING, "%s not a regular file." + " Disabling NLM", nfs->rpc_statd); nfs->enable_nlm = _gf_false; } @@ -968,8 +984,8 @@ nfs_init_state (xlator_t *this) } ret = rpcsvc_set_outstanding_rpc_limit (nfs->rpcsvc, - this->options, - RPCSVC_DEF_NFS_OUTSTANDING_RPC_LIMIT); + this->options, + RPCSVC_DEF_NFS_OUTSTANDING_RPC_LIMIT); if (ret < 0) { gf_log (GF_NFS, GF_LOG_ERROR, "Failed to configure outstanding-rpc-limit"); @@ -1023,7 +1039,8 @@ nfs_reconfigure_state (xlator_t *this, dict_t *options) { int ret = 0; int keyindx = 0; - char *optstr = NULL; + char *rmtab = NULL; + char *rpc_statd = NULL; gf_boolean_t optbool; uint32_t optuint32; struct nfs_state *nfs = NULL; @@ -1068,19 +1085,36 @@ nfs_reconfigure_state (xlator_t *this, dict_t *options) goto out; } + /* reconfig nfs.rpc-statd... */ + rpc_statd = GF_RPC_STATD_PROG; + if (dict_get (options, OPT_SERVER_RPC_STATD_PIDFILE)) { + ret = dict_get_str (options, "nfs.rpc-statd", &rpc_statd); + if (ret < 0) { + gf_log (GF_NFS, GF_LOG_ERROR, "Failed to read " + "reconfigured option: nfs.rpc-statd"); + goto out; + } + } + + if (strcmp(nfs->rpc_statd, rpc_statd) != 0) { + gf_log (GF_NFS, GF_LOG_INFO, + "Reconfiguring nfs.rpc-statd needs NFS restart"); + goto out; + } + /* reconfig nfs.mount-rmtab */ - optstr = NFS_DATADIR "/rmtab"; + rmtab = NFS_DATADIR "/rmtab"; if (dict_get (options, "nfs.mount-rmtab")) { - ret = dict_get_str (options, "nfs.mount-rmtab", &optstr); + ret = dict_get_str (options, "nfs.mount-rmtab", &rmtab); if (ret < 0) { gf_log (GF_NFS, GF_LOG_ERROR, "Failed to read " "reconfigured option: nfs.mount-rmtab"); goto out; } - gf_path_strip_trailing_slashes (optstr); + gf_path_strip_trailing_slashes (rmtab); } - if (strcmp (nfs->rmtab, optstr) != 0) { - mount_rewrite_rmtab (nfs->mstate, optstr); + if (strcmp (nfs->rmtab, rmtab) != 0) { + mount_rewrite_rmtab (nfs->mstate, rmtab); gf_log (GF_NFS, GF_LOG_INFO, "Reconfigured nfs.mount-rmtab path: %s", nfs->rmtab); @@ -1819,6 +1853,18 @@ struct volume_options options[] = { "storage, all GlusterFS servers will update and " "output (with 'showmount') the same list." }, + { .key = {OPT_SERVER_RPC_STATD}, + .type = GF_OPTION_TYPE_PATH, + .default_value = GF_RPC_STATD_PROG, + .description = "The executable of RPC statd utility. " + "Defaults to " GF_RPC_STATD_PROG + }, + { .key = {OPT_SERVER_RPC_STATD_PIDFILE}, + .type = GF_OPTION_TYPE_PATH, + .default_value = GF_RPC_STATD_PIDFILE, + .description = "The pid file of RPC statd utility. " + "Defaults to " GF_RPC_STATD_PIDFILE + }, { .key = {OPT_SERVER_AUX_GIDS}, .type = GF_OPTION_TYPE_BOOL, .default_value = "off", diff --git a/xlators/nfs/server/src/nfs.h b/xlators/nfs/server/src/nfs.h index 00c7f8046..fc745fbbd 100644 --- a/xlators/nfs/server/src/nfs.h +++ b/xlators/nfs/server/src/nfs.h @@ -86,6 +86,8 @@ struct nfs_state { gid_cache_t gid_cache; uint32_t generation; gf_boolean_t register_portmap; + char *rpc_statd; + char *rpc_statd_pid_file; }; struct nfs_inode_ctx { diff --git a/xlators/nfs/server/src/nfs3-helpers.c b/xlators/nfs/server/src/nfs3-helpers.c index 9059fc341..f67cccf1a 100644 --- a/xlators/nfs/server/src/nfs3-helpers.c +++ b/xlators/nfs/server/src/nfs3-helpers.c @@ -85,7 +85,7 @@ struct nfs3stat_strerror nfs3stat_strerror_table[] = { { NFS3ERR_SERVERFAULT, "Error occurred on the server or IO Error" }, { NFS3ERR_BADTYPE, "Type not supported by the server" }, { NFS3ERR_JUKEBOX, "Cannot complete server initiated request" }, - { -1, "IO Error" }, + { NFS3ERR_END_OF_LIST, "IO Error" }, }; @@ -543,7 +543,7 @@ char * nfsstat3_strerror(int stat) { int i; - for(i = 0; nfs3stat_strerror_table[i].stat != -1; i++) { + for(i = 0; nfs3stat_strerror_table[i].stat != NFS3ERR_END_OF_LIST ; i++) { if (nfs3stat_strerror_table[i].stat == stat) return nfs3stat_strerror_table[i].strerror; } diff --git a/xlators/nfs/server/src/nfs3.c b/xlators/nfs/server/src/nfs3.c index 0fea135c7..6361f9e20 100644 --- a/xlators/nfs/server/src/nfs3.c +++ b/xlators/nfs/server/src/nfs3.c @@ -5186,7 +5186,7 @@ nfs3_init_options (struct nfs3_state *nfs3, dict_t *options) goto err; } - ret = gf_string2bytesize (optstr, &size64); + ret = gf_string2uint64 (optstr, &size64); if (ret == -1) { gf_log (GF_NFS3, GF_LOG_ERROR, "Failed to format" " option: nfs3.read-size"); @@ -5209,7 +5209,7 @@ nfs3_init_options (struct nfs3_state *nfs3, dict_t *options) goto err; } - ret = gf_string2bytesize (optstr, &size64); + ret = gf_string2uint64 (optstr, &size64); if (ret == -1) { gf_log (GF_NFS3, GF_LOG_ERROR, "Failed to format" " option: nfs3.write-size"); @@ -5232,7 +5232,7 @@ nfs3_init_options (struct nfs3_state *nfs3, dict_t *options) goto err; } - ret = gf_string2bytesize (optstr, &size64); + ret = gf_string2uint64 (optstr, &size64); if (ret == -1) { gf_log (GF_NFS3, GF_LOG_ERROR, "Failed to format" " option: nfs3.readdir-size"); diff --git a/xlators/nfs/server/src/nlm4.c b/xlators/nfs/server/src/nlm4.c index c186537ea..d0caa97c2 100644 --- a/xlators/nfs/server/src/nlm4.c +++ b/xlators/nfs/server/src/nlm4.c @@ -2423,9 +2423,21 @@ nlm4svc_init(xlator_t *nfsx) /* unlink sm-notify.pid so that when we restart rpc.statd/sm-notify * it thinks that the machine has restarted and sends NOTIFY to clients. */ - ret = unlink ("/var/run/sm-notify.pid"); + + /* TODO: + notify/rpc.statd is done differently on OSX + + On OSX rpc.statd is controlled by rpc.lockd and are part for launchd + (unified service management framework) + + A runcmd() should be invoking "launchctl start com.apple.lockd" + instead. This is still a theory but we need to thoroughly test it + out. Until then NLM support is non-existent on OSX. + */ + ret = unlink (GF_SM_NOTIFY_PIDFILE); if (ret == -1 && errno != ENOENT) { - gf_log (GF_NLM, GF_LOG_ERROR, "unable to unlink sm-notify"); + gf_log (GF_NLM, GF_LOG_ERROR, "unable to unlink %s: %d", + GF_SM_NOTIFY_PIDFILE, errno); goto err; } /* temporary work around to restart statd, not distro/OS independant. @@ -2433,37 +2445,43 @@ nlm4svc_init(xlator_t *nfsx) * killall will cause problems on solaris. */ - pidfile = fopen ("/var/run/rpc.statd.pid", "r"); + char *pid_file = GF_RPC_STATD_PIDFILE; + if (nfs->rpc_statd_pid_file) + pid_file = nfs->rpc_statd_pid_file; + pidfile = fopen (pid_file, "r"); if (pidfile) { ret = fscanf (pidfile, "%d", &pid); if (ret <= 0) { gf_log (GF_NLM, GF_LOG_WARNING, "unable to get pid of " - "rpc.statd"); + "rpc.statd from %s ", GF_RPC_STATD_PIDFILE); ret = runcmd ("killall", "-9", "rpc.statd", NULL); } else kill (pid, SIGKILL); fclose (pidfile); } else { - gf_log (GF_NLM, GF_LOG_WARNING, "opening the pid file of " - "rpc.statd failed (%s)", strerror (errno)); + gf_log (GF_NLM, GF_LOG_WARNING, "opening %s of " + "rpc.statd failed (%s)", pid_file, strerror (errno)); /* if ret == -1, do nothing - case either statd was not * running or was running in valgrind mode */ ret = runcmd ("killall", "-9", "rpc.statd", NULL); } - ret = unlink ("/var/run/rpc.statd.pid"); + ret = unlink (GF_RPC_STATD_PIDFILE); if (ret == -1 && errno != ENOENT) { - gf_log (GF_NLM, GF_LOG_ERROR, "unable to unlink rpc.statd"); + gf_log (GF_NLM, GF_LOG_ERROR, "unable to unlink %s", pid_file); goto err; } - ret = runcmd ("/sbin/rpc.statd", NULL); + ret = runcmd (nfs->rpc_statd, NULL); if (ret == -1) { - gf_log (GF_NLM, GF_LOG_ERROR, "unable to start rpc.statd"); + gf_log (GF_NLM, GF_LOG_ERROR, "unable to start %s", + nfs->rpc_statd); goto err; } + + pthread_create (&thr, NULL, nsm_thread, (void*)NULL); timeout.tv_sec = nlm_grace_period; diff --git a/xlators/nfs/server/src/nlm4.h b/xlators/nfs/server/src/nlm4.h index 9b5d54081..5b6296110 100644 --- a/xlators/nfs/server/src/nlm4.h +++ b/xlators/nfs/server/src/nlm4.h @@ -34,6 +34,15 @@ /* Registered with portmap */ #define GF_NLM4_PORT 38468 #define GF_NLM GF_NFS"-NLM" +#ifdef GF_DARWIN_HOST_OS +#define GF_RPC_STATD_PROG "/usr/sbin/rpc.statd" +#define GF_RPC_STATD_PIDFILE "/var/run/statd.pid" +#define GF_SM_NOTIFY_PIDFILE "/var/run/statd.notify.pid" +#else +#define GF_RPC_STATD_PROG "/sbin/rpc.stat" +#define GF_RPC_STATD_PIDFILE "/var/run/rpc.statd.pid" +#define GF_SM_NOTIFY_PIDFILE "/var/run/sm-notify.pid" +#endif extern rpcsvc_program_t * nlm4svc_init (xlator_t *nfsx); diff --git a/xlators/performance/io-cache/src/io-cache.c b/xlators/performance/io-cache/src/io-cache.c index 8febfc8fb..facff5038 100644 --- a/xlators/performance/io-cache/src/io-cache.c +++ b/xlators/performance/io-cache/src/io-cache.c @@ -41,6 +41,9 @@ ioc_hashfn (void *data, int len) return (offset >> ioc_log2_page_size); } +/* TODO: This function is not used, uncomment when we find a + usage for this function. + static inline ioc_inode_t * ioc_inode_reupdate (ioc_inode_t *ioc_inode) { @@ -54,6 +57,7 @@ ioc_inode_reupdate (ioc_inode_t *ioc_inode) return ioc_inode; } + static inline ioc_inode_t * ioc_get_inode (dict_t *dict, char *name) { @@ -77,6 +81,7 @@ ioc_get_inode (dict_t *dict, char *name) return ioc_inode; } +*/ int32_t ioc_inode_need_revalidate (ioc_inode_t *ioc_inode) @@ -1663,12 +1668,12 @@ reconfigure (xlator_t *this, dict_t *options) } GF_OPTION_RECONF ("max-file-size", table->max_file_size, - options, size, unlock); + options, size_uint64, unlock); GF_OPTION_RECONF ("min-file-size", table->min_file_size, - options, size, unlock); + options, size_uint64, unlock); - if ((table->max_file_size >= 0) && + if ((table->max_file_size <= UINT64_MAX) && (table->min_file_size > table->max_file_size)) { gf_log (this->name, GF_LOG_ERROR, "minimum size (%" PRIu64") of a file that can be cached is " @@ -1679,7 +1684,7 @@ reconfigure (xlator_t *this, dict_t *options) } GF_OPTION_RECONF ("cache-size", cache_size_new, - options, size, unlock); + options, size_uint64, unlock); if (!check_cache_size_ok (this, cache_size_new)) { ret = -1; gf_log (this->name, GF_LOG_ERROR, @@ -1736,13 +1741,13 @@ init (xlator_t *this) table->xl = this; table->page_size = this->ctx->page_size; - GF_OPTION_INIT ("cache-size", table->cache_size, size, out); + GF_OPTION_INIT ("cache-size", table->cache_size, size_uint64, out); GF_OPTION_INIT ("cache-timeout", table->cache_timeout, int32, out); - GF_OPTION_INIT ("min-file-size", table->min_file_size, size, out); + GF_OPTION_INIT ("min-file-size", table->min_file_size, size_uint64, out); - GF_OPTION_INIT ("max-file-size", table->max_file_size, size, out); + GF_OPTION_INIT ("max-file-size", table->max_file_size, size_uint64, out); if (!check_cache_size_ok (this, table->cache_size)) { ret = -1; @@ -1768,7 +1773,7 @@ init (xlator_t *this) INIT_LIST_HEAD (&table->inodes); - if ((table->max_file_size >= 0) + if ((table->max_file_size <= UINT64_MAX) && (table->min_file_size > table->max_file_size)) { gf_log ("io-cache", GF_LOG_ERROR, "minimum size (%" PRIu64") of a file that can be cached is " diff --git a/xlators/performance/quick-read/src/quick-read.c b/xlators/performance/quick-read/src/quick-read.c index 402da886f..b8b4c5326 100644 --- a/xlators/performance/quick-read/src/quick-read.c +++ b/xlators/performance/quick-read/src/quick-read.c @@ -854,7 +854,7 @@ reconfigure (xlator_t *this, dict_t *options) GF_OPTION_RECONF ("cache-timeout", conf->cache_timeout, options, int32, out); - GF_OPTION_RECONF ("cache-size", cache_size_new, options, size, out); + GF_OPTION_RECONF ("cache-size", cache_size_new, options, size_uint64, out); if (!check_cache_size_ok (this, cache_size_new)) { ret = -1; gf_log (this->name, GF_LOG_ERROR, @@ -995,11 +995,11 @@ init (xlator_t *this) LOCK_INIT (&priv->table.lock); conf = &priv->conf; - GF_OPTION_INIT ("max-file-size", conf->max_file_size, size, out); + GF_OPTION_INIT ("max-file-size", conf->max_file_size, size_uint64, out); GF_OPTION_INIT ("cache-timeout", conf->cache_timeout, int32, out); - GF_OPTION_INIT ("cache-size", conf->cache_size, size, out); + GF_OPTION_INIT ("cache-size", conf->cache_size, size_uint64, out); if (!check_cache_size_ok (this, conf->cache_size)) { ret = -1; goto out; diff --git a/xlators/performance/read-ahead/src/read-ahead.c b/xlators/performance/read-ahead/src/read-ahead.c index 6e2d84591..01c861d52 100644 --- a/xlators/performance/read-ahead/src/read-ahead.c +++ b/xlators/performance/read-ahead/src/read-ahead.c @@ -1124,7 +1124,8 @@ reconfigure (xlator_t *this, dict_t *options) GF_OPTION_RECONF ("page-count", conf->page_count, options, uint32, out); - GF_OPTION_RECONF ("page-size", conf->page_size, options, size, out); + GF_OPTION_RECONF ("page-size", conf->page_size, options, size_uint64, + out); ret = 0; out: @@ -1158,7 +1159,7 @@ init (xlator_t *this) conf->page_size = this->ctx->page_size; - GF_OPTION_INIT ("page-size", conf->page_size, size, out); + GF_OPTION_INIT ("page-size", conf->page_size, size_uint64, out); GF_OPTION_INIT ("page-count", conf->page_count, uint32, out); diff --git a/xlators/performance/readdir-ahead/src/readdir-ahead.c b/xlators/performance/readdir-ahead/src/readdir-ahead.c index 53e6756f0..ba96bfcd3 100644 --- a/xlators/performance/readdir-ahead/src/readdir-ahead.c +++ b/xlators/performance/readdir-ahead/src/readdir-ahead.c @@ -459,9 +459,9 @@ reconfigure(xlator_t *this, dict_t *options) GF_OPTION_RECONF("rda-request-size", priv->rda_req_size, options, uint32, err); - GF_OPTION_RECONF("rda-low-wmark", priv->rda_low_wmark, options, size, + GF_OPTION_RECONF("rda-low-wmark", priv->rda_low_wmark, options, size_uint64, err); - GF_OPTION_RECONF("rda-high-wmark", priv->rda_high_wmark, options, size, + GF_OPTION_RECONF("rda-high-wmark", priv->rda_high_wmark, options, size_uint64, err); return 0; @@ -498,8 +498,8 @@ init(xlator_t *this) goto err; GF_OPTION_INIT("rda-request-size", priv->rda_req_size, uint32, err); - GF_OPTION_INIT("rda-low-wmark", priv->rda_low_wmark, size, err); - GF_OPTION_INIT("rda-high-wmark", priv->rda_high_wmark, size, err); + GF_OPTION_INIT("rda-low-wmark", priv->rda_low_wmark, size_uint64, err); + GF_OPTION_INIT("rda-high-wmark", priv->rda_high_wmark, size_uint64, err); return 0; diff --git a/xlators/performance/write-behind/src/write-behind.c b/xlators/performance/write-behind/src/write-behind.c index 00457338d..3cb0d449b 100644 --- a/xlators/performance/write-behind/src/write-behind.c +++ b/xlators/performance/write-behind/src/write-behind.c @@ -2116,7 +2116,7 @@ reconfigure (xlator_t *this, dict_t *options) conf = this->private; - GF_OPTION_RECONF ("cache-size", conf->window_size, options, size, out); + GF_OPTION_RECONF ("cache-size", conf->window_size, options, size_uint64, out); GF_OPTION_RECONF ("flush-behind", conf->flush_behind, options, bool, out); @@ -2163,7 +2163,7 @@ init (xlator_t *this) conf->aggregate_size = WB_AGGREGATE_SIZE; /* configure 'option window-size ' */ - GF_OPTION_INIT ("cache-size", conf->window_size, size, out); + GF_OPTION_INIT ("cache-size", conf->window_size, size_uint64, out); if (!conf->window_size && conf->aggregate_size) { gf_log (this->name, GF_LOG_WARNING, diff --git a/xlators/protocol/client/src/client.c b/xlators/protocol/client/src/client.c index 306e555ef..98fb10c34 100644 --- a/xlators/protocol/client/src/client.c +++ b/xlators/protocol/client/src/client.c @@ -21,6 +21,7 @@ #include "statedump.h" #include "compat-errno.h" +#include "xdr-rpc.h" #include "glusterfs3.h" extern rpc_clnt_prog_t clnt_handshake_prog; @@ -2458,7 +2459,7 @@ client_init_grace_timer (xlator_t *this, dict_t *options, conf->grace_ts.tv_nsec = 0; gf_log (this->name, GF_LOG_DEBUG, "Client grace timeout " - "value = %"PRIu64, conf->grace_ts.tv_sec); + "value = %"GF_PRI_SECOND, conf->grace_ts.tv_sec); ret = 0; out: diff --git a/xlators/protocol/server/src/server-handshake.c b/xlators/protocol/server/src/server-handshake.c index 708acd936..a459f89e1 100644 --- a/xlators/protocol/server/src/server-handshake.c +++ b/xlators/protocol/server/src/server-handshake.c @@ -645,7 +645,7 @@ server_setvolume (rpcsvc_request_t *req) fail: rsp.dict.dict_len = dict_serialized_length (reply); - if (rsp.dict.dict_len < 0) { + if (rsp.dict.dict_len > UINT_MAX) { gf_log ("server-handshake", GF_LOG_DEBUG, "failed to get serialized length of reply dict"); op_ret = -1; diff --git a/xlators/protocol/server/src/server-helpers.c b/xlators/protocol/server/src/server-helpers.c index 76c0036e0..600a311c3 100644 --- a/xlators/protocol/server/src/server-helpers.c +++ b/xlators/protocol/server/src/server-helpers.c @@ -33,6 +33,7 @@ server_decode_groups (call_frame_t *frame, rpcsvc_request_t *req) if (frame->root->ngrps == 0) return 0; + /* ngrps cannot be bigger than USHRT_MAX(65535) */ if (frame->root->ngrps > GF_MAX_AUX_GROUPS) return -1; @@ -744,7 +745,7 @@ serialize_rsp_direntp (gf_dirent_t *entries, gfs3_readdirp_rsp *rsp) /* if 'dict' is present, pack it */ if (entry->dict) { trav->dict.dict_len = dict_serialized_length (entry->dict); - if (trav->dict.dict_len < 0) { + if (trav->dict.dict_len > UINT_MAX) { gf_log (THIS->name, GF_LOG_ERROR, "failed to get serialized length " "of reply dict"); diff --git a/xlators/protocol/server/src/server-rpc-fops.c b/xlators/protocol/server/src/server-rpc-fops.c index 8bdadec6b..ebe62ae7c 100644 --- a/xlators/protocol/server/src/server-rpc-fops.c +++ b/xlators/protocol/server/src/server-rpc-fops.c @@ -1611,8 +1611,8 @@ server_create_cbk (call_frame_t *frame, void *cookie, xlator_t *this, fd_no = gf_fd_unused_get (serv_ctx->fdtable, fd); fd_ref (fd); - if ((fd_no < 0) || (fd == 0)) { - op_ret = fd_no; + if ((fd_no > UINT64_MAX) || (fd == 0)) { + op_ret = -1; op_errno = errno; } diff --git a/xlators/protocol/server/src/server.c b/xlators/protocol/server/src/server.c index 785517058..6bd00cac0 100644 --- a/xlators/protocol/server/src/server.c +++ b/xlators/protocol/server/src/server.c @@ -688,7 +688,7 @@ server_init_grace_timer (xlator_t *this, dict_t *options, conf->grace_ts.tv_sec = 10; gf_log (this->name, GF_LOG_DEBUG, "Server grace timeout " - "value = %"PRIu64, conf->grace_ts.tv_sec); + "value = %"GF_PRI_SECOND, conf->grace_ts.tv_sec); conf->grace_ts.tv_nsec = 0; diff --git a/xlators/storage/bd/src/bd-helper.c b/xlators/storage/bd/src/bd-helper.c index 4bd1d6111..d598e5755 100644 --- a/xlators/storage/bd/src/bd-helper.c +++ b/xlators/storage/bd/src/bd-helper.c @@ -11,6 +11,7 @@ #include "bd.h" #include "bd-mem-types.h" #include "run.h" +#include "lvm-defaults.h" int bd_inode_ctx_set (inode_t *inode, xlator_t *this, bd_attr_t *ctx) @@ -1018,4 +1019,3 @@ out: return ret; } - diff --git a/xlators/storage/bd/src/bd.c b/xlators/storage/bd/src/bd.c index 0954b553d..750b00943 100644 --- a/xlators/storage/bd/src/bd.c +++ b/xlators/storage/bd/src/bd.c @@ -38,6 +38,8 @@ #include "run.h" #include "protocol-common.h" #include "checksum.h" +#include "syscall.h" +#include "lvm-defaults.h" /* * Call back function for setxattr and removexattr. @@ -719,9 +721,8 @@ bd_do_fsync (int fd, int datasync) { int op_errno = 0; -#ifdef HAVE_FDATASYNC if (datasync) { - if (fdatasync (fd)) { + if (sys_fdatasync (fd)) { op_errno = errno; gf_log (THIS->name, GF_LOG_ERROR, "fdatasync on fd=%d failed: %s", @@ -729,9 +730,9 @@ bd_do_fsync (int fd, int datasync) } } else -#endif + { - if (fsync (fd)) { + if (sys_fsync (fd)) { op_errno = errno; gf_log (THIS->name, GF_LOG_ERROR, "fsync on fd=%d failed: %s", diff --git a/xlators/storage/bd/src/bd.h b/xlators/storage/bd/src/bd.h index 5307ca407..62add16cd 100644 --- a/xlators/storage/bd/src/bd.h +++ b/xlators/storage/bd/src/bd.h @@ -38,10 +38,6 @@ #define BD_LV "lv" #define BD_THIN "thin" -#define LVM_RESIZE "/sbin/lvresize" -#define LVM_CREATE "/sbin/lvcreate" -#define LVM_CONVERT "/sbin/lvconvert" - #define VOL_TYPE "volume.type" #define VOL_CAPS "volume.caps" @@ -165,7 +161,7 @@ int bd_clone (bd_local_t *local, bd_priv_t *priv); int bd_merge (bd_priv_t *priv, uuid_t gfid); int bd_get_origin (bd_priv_t *priv, loc_t *loc, fd_t *fd, dict_t *dict); -inline void bd_update_amtime(struct iatt *iatt, int flag); +void bd_update_amtime(struct iatt *iatt, int flag); int bd_snapshot_create (bd_local_t *local, bd_priv_t *priv); int bd_clone (bd_local_t *local, bd_priv_t *priv); int bd_merge (bd_priv_t *priv, uuid_t gfid); diff --git a/xlators/storage/posix/src/posix-helpers.c b/xlators/storage/posix/src/posix-helpers.c index 5725cad7d..ab46f7f7e 100644 --- a/xlators/storage/posix/src/posix-helpers.c +++ b/xlators/storage/posix/src/posix-helpers.c @@ -784,6 +784,27 @@ out: return op_ret; } +#ifdef GF_DARWIN_HOST_OS +static +void posix_dump_buffer (xlator_t *this, const char *real_path, const char *key, + data_t *value, int flags) +{ + char buffer[3*value->len+1]; + int index = 0; + buffer[0] = 0; + gf_loglevel_t log_level = gf_log_get_loglevel (); + if (log_level == GF_LOG_TRACE) { + char *data = (char *) value->data; + for (index = 0; index < value->len; index++) + sprintf(buffer+3*index, " %02x", data[index]); + } + gf_log (this->name, GF_LOG_DEBUG, + "Dump %s: key:%s flags: %u length:%u data:%s ", + real_path, key, flags, value->len, + (log_level == GF_LOG_TRACE ? buffer : "")); +} +#endif + static int gf_xattr_enotsup_log; int @@ -802,7 +823,9 @@ posix_handle_pair (xlator_t *this, const char *real_path, } else { sys_ret = sys_lsetxattr (real_path, key, value->data, value->len, flags); - +#ifdef GF_DARWIN_HOST_OS + posix_dump_buffer(this, real_path, key, value, flags); +#endif if (sys_ret < 0) { ret = -errno; if (errno == ENOTSUP) { @@ -825,13 +848,13 @@ posix_handle_pair (xlator_t *this, const char *real_path, gf_log (this->name, ((errno == EINVAL) ? GF_LOG_DEBUG : GF_LOG_ERROR), - "%s: key:%s error:%s", - real_path, key, + "%s: key:%s flags: %u length:%d error:%s", + real_path, key, flags, value->len, strerror (errno)); #else /* ! DARWIN */ gf_log (this->name, GF_LOG_ERROR, - "%s: key:%s error:%s", - real_path, key, + "%s: key:%s flags: %u length:%d error:%s", + real_path, key, flags, value->len, strerror (errno)); #endif /* DARWIN */ } @@ -1430,12 +1453,10 @@ posix_fsyncer_process (xlator_t *this, call_stub_t *stub, gf_boolean_t do_fsync) } if (do_fsync) { -#ifdef HAVE_FDATASYNC if (stub->args.datasync) - ret = fdatasync (pfd->fd); + ret = sys_fdatasync (pfd->fd); else -#endif - ret = fsync (pfd->fd); + ret = sys_fsync (pfd->fd); } else { ret = 0; } diff --git a/xlators/storage/posix/src/posix.c b/xlators/storage/posix/src/posix.c index 588079d92..d33b5027e 100644 --- a/xlators/storage/posix/src/posix.c +++ b/xlators/storage/posix/src/posix.c @@ -761,7 +761,7 @@ posix_do_zerofill(call_frame_t *frame, xlator_t *this, fd_t *fd, if (ret < 0) { ret = -errno; gf_log(this->name, GF_LOG_ERROR, - "zerofill failed on fd %d length %ld %s", + "zerofill failed on fd %d length %" PRId64 " %s", pfd->fd, len, strerror(errno)); goto out; } @@ -2859,16 +2859,14 @@ posix_fsync (call_frame_t *frame, xlator_t *this, if (datasync) { ; -#ifdef HAVE_FDATASYNC - op_ret = fdatasync (_fd); + op_ret = sys_fdatasync (_fd); if (op_ret == -1) { gf_log (this->name, GF_LOG_ERROR, "fdatasync on fd=%p failed: %s", fd, strerror (errno)); } -#endif } else { - op_ret = fsync (_fd); + op_ret = sys_fsync (_fd); if (op_ret == -1) { op_errno = errno; gf_log (this->name, GF_LOG_ERROR, @@ -2911,6 +2909,23 @@ _handle_setxattr_keyvalue_pair (dict_t *d, char *k, data_t *v, filler->flags); } +#ifdef GF_DARWIN_HOST_OS +static inline int +map_xattr_flags(int flags) +{ + /* DARWIN has different defines on XATTR_ flags. + There do not seem to be a POSIX standard + Parse any other flags over. + */ + int darwinflags = flags & ~(GF_XATTR_CREATE | GF_XATTR_REPLACE | XATTR_REPLACE); + if (GF_XATTR_CREATE & flags) + darwinflags |= XATTR_CREATE; + if (GF_XATTR_REPLACE & flags) + darwinflags |= XATTR_REPLACE; + return darwinflags; +} +#endif + int32_t posix_setxattr (call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *dict, int flags, dict_t *xdata) @@ -2937,7 +2952,11 @@ posix_setxattr (call_frame_t *frame, xlator_t *this, filler.real_path = real_path; filler.this = this; +#ifdef GF_DARWIN_HOST_OS + filler.flags = map_xattr_flags(flags); +#else filler.flags = flags; +#endif op_ret = dict_foreach (dict, _handle_setxattr_keyvalue_pair, &filler); if (op_ret < 0) { @@ -3354,7 +3373,7 @@ posix_getxattr (call_frame_t *frame, xlator_t *this, char *list = NULL; int32_t list_offset = 0; size_t remaining_size = 0; - char key[4096] = {0,}; + char keybuffer[4096] = {0,}; DECLARE_OLD_FS_ID_VAR; @@ -3522,8 +3541,20 @@ posix_getxattr (call_frame_t *frame, xlator_t *this, } if (name) { - strcpy (key, name); - + strcpy (keybuffer, name); + char *key = keybuffer; +#if defined(GF_DARWIN_HOST_OS_DISABLED) + if (priv->xattr_user_namespace == XATTR_STRIP) { + if (strncmp(key, "user.",5) == 0) { + key += 5; + gf_log (this->name, + GF_LOG_DEBUG, + "getxattr for file %s" + " stripping user key: %s -> %s", + real_path, keybuffer, key); + } + } +#endif size = sys_lgetxattr (real_path, key, NULL, 0); if (size <= 0) { op_errno = errno; @@ -3611,14 +3642,13 @@ posix_getxattr (call_frame_t *frame, xlator_t *this, while (remaining_size > 0) { if (*(list + list_offset) == '\0') break; - - strcpy (key, list + list_offset); - size = sys_lgetxattr (real_path, key, NULL, 0); + strcpy (keybuffer, list + list_offset); + size = sys_lgetxattr (real_path, keybuffer, NULL, 0); if (size == -1) { op_ret = -1; op_errno = errno; gf_log (this->name, GF_LOG_ERROR, "getxattr failed on " - "%s: key = %s (%s)", real_path, key, + "%s: key = %s (%s)", real_path, keybuffer, strerror (op_errno)); break; } @@ -3630,29 +3660,37 @@ posix_getxattr (call_frame_t *frame, xlator_t *this, goto out; } - size = sys_lgetxattr (real_path, key, value, size); + size = sys_lgetxattr (real_path, keybuffer, value, size); if (size == -1) { op_ret = -1; op_errno = errno; gf_log (this->name, GF_LOG_ERROR, "getxattr failed on " - "%s: key = %s (%s)", real_path, key, + "%s: key = %s (%s)", real_path, keybuffer, strerror (op_errno)); GF_FREE (value); break; } value [size] = '\0'; - op_ret = dict_set_dynptr (dict, key, value, size); +#ifdef GF_DARWIN_HOST_OS + /* The protocol expect namespace for now */ + char *newkey = NULL; + gf_add_prefix (XATTR_USER_PREFIX, keybuffer, &newkey); + strcpy (keybuffer, newkey); + GF_FREE (newkey); +#endif + op_ret = dict_set_dynptr (dict, keybuffer, value, size); if (op_ret < 0) { op_errno = -op_ret; gf_log (this->name, GF_LOG_ERROR, "dict set operation " - "on %s for the key %s failed.", real_path, key); + "on %s for the key %s failed.", real_path, + keybuffer); GF_FREE (value); goto out; } - remaining_size -= strlen (key) + 1; - list_offset += strlen (key) + 1; + remaining_size -= strlen (keybuffer) + 1; + list_offset += strlen (keybuffer) + 1; } /* while (remaining_size > 0) */ @@ -3729,7 +3767,16 @@ posix_fgetxattr (call_frame_t *frame, xlator_t *this, if (name) { strcpy (key, name); - +#ifdef GF_DARWIN_HOST_OS + struct posix_private *priv = NULL; + priv = this->private; + if (priv->xattr_user_namespace == XATTR_STRIP) { + char *newkey = NULL; + gf_add_prefix (XATTR_USER_PREFIX, key, &newkey); + strcpy (key, newkey); + GF_FREE (newkey); + } +#endif size = sys_fgetxattr (_fd, key, NULL, 0); if (size <= 0) { op_errno = errno; @@ -3832,6 +3879,7 @@ posix_fgetxattr (call_frame_t *frame, xlator_t *this, } value [size] = '\0'; + op_ret = dict_set_dynptr (dict, key, value, size); if (op_ret) { gf_log (this->name, GF_LOG_ERROR, "dict set operation " @@ -3910,7 +3958,11 @@ posix_fsetxattr (call_frame_t *frame, xlator_t *this, filler.fd = _fd; filler.this = this; +#ifdef GF_DARWIN_HOST_OS + filler.flags = map_xattr_flags(flags); +#else filler.flags = flags; +#endif op_ret = dict_foreach (dict, _handle_fsetxattr_keyvalue_pair, &filler); if (op_ret < 0) { @@ -3935,7 +3987,17 @@ _posix_remove_xattr (dict_t *dict, char *key, data_t *value, void *data) filler = (posix_xattr_filler_t *) data; this = filler->this; - +#ifdef GF_DARWIN_HOST_OS + struct posix_private *priv = NULL; + priv = (struct posix_private *) this->private; + char *newkey = NULL; + if (priv->xattr_user_namespace == XATTR_STRIP) { + gf_remove_prefix (XATTR_USER_PREFIX, key, &newkey); + gf_log("remove_xattr", GF_LOG_DEBUG, "key %s => %s" , key, + newkey); + key = newkey; + } +#endif op_ret = sys_lremovexattr (filler->real_path, key); if (op_ret == -1) { filler->op_errno = errno; @@ -3944,7 +4006,9 @@ _posix_remove_xattr (dict_t *dict, char *key, data_t *value, void *data) "removexattr failed on %s (for %s): %s", filler->real_path, key, strerror (errno)); } - +#ifdef GF_DARWIN_HOST_OS + GF_FREE(newkey); +#endif return op_ret; } @@ -4176,10 +4240,19 @@ _posix_handle_xattr_keyvalue_pair (dict_t *d, char *k, data_t *v, optype = (gf_xattrop_flags_t)(filler->flags); this = filler->this; inode = filler->inode; - count = v->len; array = GF_CALLOC (count, sizeof (char), gf_posix_mt_char); +#ifdef GF_DARWIN_HOST_OS + struct posix_private *priv = NULL; + priv = this->private; + if (priv->xattr_user_namespace == XATTR_STRIP) { + if (strncmp(k, XATTR_USER_PREFIX, XATTR_USER_PREFIX_LEN) == 0) { + k += XATTR_USER_PREFIX_LEN; + } + } +#endif + LOCK (&inode->lock); { if (filler->real_path) { @@ -5135,6 +5208,23 @@ set_batch_fsync_mode (struct posix_private *priv, const char *str) return 0; } +#ifdef GF_DARWIN_HOST_OS +static int +set_xattr_user_namespace_mode (struct posix_private *priv, const char *str) +{ + if (strcmp (str, "none") == 0) + priv->xattr_user_namespace = XATTR_NONE; + else if (strcmp (str, "strip") == 0) + priv->xattr_user_namespace = XATTR_STRIP; + else if (strcmp (str, "append") == 0) + priv->xattr_user_namespace = XATTR_APPEND; + else if (strcmp (str, "both") == 0) + priv->xattr_user_namespace = XATTR_BOTH; + else + return -1; + return 0; +} +#endif int reconfigure (xlator_t *this, dict_t *options) @@ -5164,6 +5254,21 @@ reconfigure (xlator_t *this, dict_t *options) goto out; } +#ifdef GF_DARWIN_HOST_OS + + char *xattr_user_namespace_mode_str = NULL; + + GF_OPTION_RECONF ("xattr-user-namespace-mode", xattr_user_namespace_mode_str, + options, str, out); + + if (set_xattr_user_namespace_mode (priv, xattr_user_namespace_mode_str) != 0) { + gf_log (this->name, GF_LOG_ERROR, "Unknown xattr user namespace mode string: %s", + xattr_user_namespace_mode_str); + goto out; + } + +#endif + GF_OPTION_RECONF ("linux-aio", priv->aio_configured, options, bool, out); @@ -5351,7 +5456,8 @@ init (xlator_t *this) dir_data->data); ret = -1; goto out; - } else if ((size == -1) && (errno != ENODATA)) { + } else if ((size == -1) && (errno != ENODATA) && + (errno != ENOATTR)) { /* Wrong 'gfid' is set, it should be error */ gf_log (this->name, GF_LOG_WARNING, "%s: failed to fetch gfid (%s)", @@ -5610,8 +5716,24 @@ init (xlator_t *this) goto out; } - GF_OPTION_INIT ("batch-fsync-delay-usec", _private->batch_fsync_delay_usec, - uint32, out); +#ifdef GF_DARWIN_HOST_OS + + char *xattr_user_namespace_mode_str = NULL; + + GF_OPTION_INIT ("xattr-user-namespace-mode", + xattr_user_namespace_mode_str, str, out); + + if (set_xattr_user_namespace_mode (_private, + xattr_user_namespace_mode_str) != 0) { + gf_log (this->name, GF_LOG_ERROR, + "Unknown xattr user namespace mode string: %s", + xattr_user_namespace_mode_str); + goto out; + } +#endif + + GF_OPTION_INIT ("batch-fsync-delay-usec", _private->batch_fsync_delay_usec, + uint32, out); out: return ret; } @@ -5769,5 +5891,15 @@ struct volume_options options[] = { .default_value = "off", .description = "Enable placeholders for gfid to path conversion" }, +#if GF_DARWIN_HOST_OS + { .key = {"xattr-user-namespace-mode"}, + .type = GF_OPTION_TYPE_STR, + .default_value = "none", + .description = "Option to control XATTR user namespace on the raw filesystem: " + "\t- None: Will use the user namespace, so files will be exchangable with Linux.\n" + " The raw filesystem will not be compatible with OS X Finder.\n" + "\t- Strip: Will strip the user namespace before setting. The raw filesystem will work in OS X.\n" + }, +#endif { .key = {NULL} } }; diff --git a/xlators/storage/posix/src/posix.h b/xlators/storage/posix/src/posix.h index 91e0664ed..c9bfc984d 100644 --- a/xlators/storage/posix/src/posix.h +++ b/xlators/storage/posix/src/posix.h @@ -158,6 +158,16 @@ struct posix_private { uint32_t health_check_interval; pthread_t health_check; gf_boolean_t health_check_active; + +#ifdef GF_DARWIN_HOST_OS + enum { + XATTR_NONE = 0, + XATTR_STRIP, + XATTR_APPEND, + XATTR_BOTH, + } xattr_user_namespace; +#endif + }; typedef struct { -- cgit From bc434b3ca961757ade8c6093f4ff0dbe4b3a4672 Mon Sep 17 00:00:00 2001 From: Pranith Kumar K Date: Wed, 23 Apr 2014 14:05:10 +0530 Subject: rpcsvc: Ignore INODELK/ENTRYLK/LK for throttling Problem: When iozone is in progress, number of blocking inodelks sometimes becomes greater than the threshold number of rpc requests allowed for that client (RPCSVC_DEFAULT_OUTSTANDING_RPC_LIMIT). Subsequent requests from that client will not be read until all the outstanding requests are processed and replied to. But because no more requests are read from that client, unlocks on the already granted locks will never come thus the number of outstanding requests would never come down. This leads to a ping-timeout on the client. Fix: Do not account INODELK/ENTRYLK/LK for throttling Change-Id: I59c6b54e7ec24ed7375ff977e817a9cb73469806 BUG: 1089470 Signed-off-by: Pranith Kumar K Reviewed-on: http://review.gluster.org/7531 Tested-by: Gluster Build System Reviewed-by: Krutika Dhananjay Reviewed-by: Anand Avati --- rpc/rpc-lib/src/rpcsvc.c | 70 +++++++++++++++++++++++++++++++++++++----------- 1 file changed, 54 insertions(+), 16 deletions(-) diff --git a/rpc/rpc-lib/src/rpcsvc.c b/rpc/rpc-lib/src/rpcsvc.c index f2cdfb238..1c13048f2 100644 --- a/rpc/rpc-lib/src/rpcsvc.c +++ b/rpc/rpc-lib/src/rpcsvc.c @@ -29,6 +29,7 @@ #include "rpc-common-xdr.h" #include "syncop.h" #include "rpc-drc.h" +#include "protocol-common.h" #include #include @@ -132,32 +133,67 @@ rpcsvc_get_program_vector_sizer (rpcsvc_t *svc, uint32_t prognum, return NULL; } +gf_boolean_t +rpcsvc_can_outstanding_req_be_ignored (rpcsvc_request_t *req) +{ + /* + * If outstanding_rpc_limit is reached because of blocked locks and + * throttling is attempted then no unlock requests will be received. So + * the outstanding request count will never change i.e. it will always + * be equal to the limit. This also leads to ping timer expiry on + * client. + */ + + /* + * This is a hack and a necessity until grantedlock == fop completion. + * Ideally if we get a blocking lock request which cannot be granted + * right now, we should unwind the fop saying “request registered, will + * notify you when granted”, which is very hard to implement at the + * moment. Until we bring in such mechanism, we will need to live with + * not rate-limiting INODELK/ENTRYLK/LK fops + */ + + if ((req->prognum == GLUSTER_FOP_PROGRAM) && + (req->progver == GLUSTER_FOP_VERSION)) { + if ((req->procnum == GFS3_OP_INODELK) || + (req->procnum == GFS3_OP_FINODELK) || + (req->procnum == GFS3_OP_ENTRYLK) || + (req->procnum == GFS3_OP_FENTRYLK) || + (req->procnum == GFS3_OP_LK)) + return _gf_true; + } + return _gf_false; +} + int -rpcsvc_request_outstanding (rpcsvc_t *svc, rpc_transport_t *trans, int delta) +rpcsvc_request_outstanding (rpcsvc_request_t *req, int delta) { int ret = 0; int old_count = 0; int new_count = 0; int limit = 0; - pthread_mutex_lock (&trans->lock); + if (rpcsvc_can_outstanding_req_be_ignored (req)) + return 0; + + pthread_mutex_lock (&req->trans->lock); { - limit = svc->outstanding_rpc_limit; + limit = req->svc->outstanding_rpc_limit; if (!limit) goto unlock; - old_count = trans->outstanding_rpc_count; - trans->outstanding_rpc_count += delta; - new_count = trans->outstanding_rpc_count; + old_count = req->trans->outstanding_rpc_count; + req->trans->outstanding_rpc_count += delta; + new_count = req->trans->outstanding_rpc_count; if (old_count <= limit && new_count > limit) - ret = rpc_transport_throttle (trans, _gf_true); + ret = rpc_transport_throttle (req->trans, _gf_true); if (old_count > limit && new_count <= limit) - ret = rpc_transport_throttle (trans, _gf_false); + ret = rpc_transport_throttle (req->trans, _gf_false); } unlock: - pthread_mutex_unlock (&trans->lock); + pthread_mutex_unlock (&req->trans->lock); return ret; } @@ -318,7 +354,8 @@ rpcsvc_request_destroy (rpcsvc_request_t *req) to the client. It is time to decrement the outstanding request counter by 1. */ - rpcsvc_request_outstanding (req->svc, req->trans, -1); + if (req->prognum) //Only for initialized requests + rpcsvc_request_outstanding (req, -1); rpc_transport_unref (req->trans); @@ -400,12 +437,6 @@ rpcsvc_request_create (rpcsvc_t *svc, rpc_transport_t *trans, goto err; } - /* We just received a new request from the wire. Account for - it in the outsanding request counter to make sure we don't - ingest too many concurrent requests from the same client. - */ - ret = rpcsvc_request_outstanding (svc, trans, +1); - msgbuf = msg->vector[0].iov_base; msglen = msg->vector[0].iov_len; @@ -431,6 +462,13 @@ rpcsvc_request_create (rpcsvc_t *svc, rpc_transport_t *trans, rpc_call_progver (&rpcmsg), rpc_call_progproc (&rpcmsg), trans->name); + /* We just received a new request from the wire. Account for + it in the outsanding request counter to make sure we don't + ingest too many concurrent requests from the same client. + */ + if (req->prognum) //Only for initialized requests + ret = rpcsvc_request_outstanding (req, +1); + if (rpc_call_rpcvers (&rpcmsg) != 2) { /* LOG- TODO: print rpc version, also print the peerinfo from transport */ -- cgit From 500a656c91558dd7913f572369f20b8550e9e98d Mon Sep 17 00:00:00 2001 From: Krutika Dhananjay Date: Sat, 19 Apr 2014 20:03:38 +0530 Subject: features/locks: Remove stale inodelk objects from 'blocked_locks' list * In the event of a DISCONNECT from a client, as part of cleanup, inodelk objects are not removed from the blocked_locks list before being unref'd and freed, causing the brick process to crash at some point when the (now) stale object is accessed again in the list. * Also during cleanup, it is pointless to try and grant lock to a previously blocked inodelk (say L1) as part of releasing another conflicting lock (L2), (which is a side-effect of L1 not being deleted from blocked_locks list before grant_blocked_inode_locks() in cleanup) if L1 is also associated with the DISCONNECTing client. This patch fixes the problem. * Also, the codepath in cleanup of entrylks seems to be granting blocked inodelks, when it should be attempting to grant blocked entrylks, which is fixed in this patch. Change-Id: I8493365c33020333b3f61aa15f505e4e7e6a9891 BUG: 1089470 Signed-off-by: Krutika Dhananjay Reviewed-on: http://review.gluster.org/7512 Reviewed-by: Raghavendra G Reviewed-by: Pranith Kumar Karampuri Tested-by: Gluster Build System Reviewed-by: Krishnan Parthasarathi Reviewed-by: Anand Avati --- xlators/features/locks/src/entrylk.c | 2 +- xlators/features/locks/src/inodelk.c | 56 ++++++++++++++++++++++++++++++++---- 2 files changed, 52 insertions(+), 6 deletions(-) diff --git a/xlators/features/locks/src/entrylk.c b/xlators/features/locks/src/entrylk.c index dc86512be..4f5d8aca2 100644 --- a/xlators/features/locks/src/entrylk.c +++ b/xlators/features/locks/src/entrylk.c @@ -749,7 +749,7 @@ pl_entrylk_client_cleanup (xlator_t *this, pl_ctx_t *ctx) dom = get_domain (pinode, l->volume); - grant_blocked_inode_locks (this, pinode, dom); + grant_blocked_entry_locks (this, pinode, dom); pthread_mutex_lock (&pinode->mutex); { diff --git a/xlators/features/locks/src/inodelk.c b/xlators/features/locks/src/inodelk.c index 2d9aa83ec..d105e14f2 100644 --- a/xlators/features/locks/src/inodelk.c +++ b/xlators/features/locks/src/inodelk.c @@ -404,7 +404,7 @@ pl_inodelk_log_cleanup (pl_inode_lock_t *lock) } -/* Release all entrylks from this client */ +/* Release all inodelks from this client */ int pl_inodelk_client_cleanup (xlator_t *this, pl_ctx_t *ctx) { @@ -414,15 +414,16 @@ pl_inodelk_client_cleanup (xlator_t *this, pl_ctx_t *ctx) pl_inode_t *pl_inode = NULL; struct list_head released; + struct list_head unwind; INIT_LIST_HEAD (&released); + INIT_LIST_HEAD (&unwind); pthread_mutex_lock (&ctx->lock); { list_for_each_entry_safe (l, tmp, &ctx->inodelk_lockers, client_list) { list_del_init (&l->client_list); - list_add_tail (&l->client_list, &released); pl_inodelk_log_cleanup (l); @@ -430,19 +431,64 @@ pl_inodelk_client_cleanup (xlator_t *this, pl_ctx_t *ctx) pthread_mutex_lock (&pl_inode->mutex); { - __delete_inode_lock (l); + /* If the inodelk object is part of granted list but not + * blocked list, then perform the following actions: + * i. delete the object from granted list; + * ii. grant other locks (from other clients) that may + * have been blocked on this inodelk; and + * iii. unref the object. + * + * If the inodelk object (L1) is part of both granted + * and blocked lists, then this means that a parallel + * unlock on another inodelk (L2 say) may have 'granted' + * L1 and added it to 'granted' list in + * __grant_blocked_node_locks() (although using the + * 'blocked_locks' member). In that case, the cleanup + * codepath must try and grant other overlapping + * blocked inodelks from other clients, now that L1 is + * out of their way and then unref L1 in the end, and + * leave it to the other thread (the one executing + * unlock codepath) to unwind L1's frame, delete it from + * blocked_locks list, and perform the last unref on L1. + * + * If the inodelk object (L1) is part of blocked list + * only, the cleanup code path must: + * i. delete it from the blocked_locks list inside + * this critical section, + * ii. unwind its frame with EAGAIN, + * iii. try and grant blocked inode locks from other + * clients that were otherwise grantable, but just + * got blocked to avoid leaving L1 to starve + * forever. + * iv. unref the object. + */ + if (!list_empty (&l->list)) { + __delete_inode_lock (l); + list_add_tail (&l->client_list, + &released); + } else { + list_del_init(&l->blocked_locks); + list_add_tail (&l->client_list, + &unwind); + } } pthread_mutex_unlock (&pl_inode->mutex); } } pthread_mutex_unlock (&ctx->lock); - list_for_each_entry_safe (l, tmp, &released, client_list) { + list_for_each_entry_safe (l, tmp, &unwind, client_list) { list_del_init (&l->client_list); - if (l->frame) + if (l->frame) STACK_UNWIND_STRICT (inodelk, l->frame, -1, EAGAIN, NULL); + list_add_tail (&l->client_list, &released); + + } + + list_for_each_entry_safe (l, tmp, &released, client_list) { + list_del_init (&l->client_list); pl_inode = l->pl_inode; -- cgit From 841ac48b413f0e108d25af36429568b6d34dab39 Mon Sep 17 00:00:00 2001 From: Harshavardhana Date: Thu, 24 Apr 2014 17:09:24 -0700 Subject: osx: Compilation fixes Change-Id: I822936cbeb4ec8af46be8e94644ea666b919ae5c BUG: 1089172 Signed-off-by: Harshavardhana Reviewed-on: http://review.gluster.org/7556 Tested-by: Gluster Build System Reviewed-by: Anand Avati --- configure.ac | 10 ++++++++-- xlators/mount/fuse/src/Makefile.am | 4 +++- 2 files changed, 11 insertions(+), 3 deletions(-) diff --git a/configure.ac b/configure.ac index 9cc45a41e..ae945b291 100644 --- a/configure.ac +++ b/configure.ac @@ -672,6 +672,7 @@ fi AC_SUBST(ARGP_STANDALONE_CPPFLAGS) AC_SUBST(ARGP_STANDALONE_LDADD) +AC_SUBST(ARGP_STANDALONE_DIR) AC_CHECK_HEADER([malloc.h], AC_DEFINE(HAVE_MALLOC_H, 1, [have malloc.h])) @@ -695,7 +696,6 @@ if test "x${have_posix_fallocate}" = "xyes"; then AC_DEFINE(HAVE_POSIX_FALLOCATE, 1, [define if posix_fallocate exists]) fi - # Check the distribution where you are compiling glusterfs on GF_DISTRIBUTION= @@ -884,7 +884,7 @@ case $host_os in LDFLAGS="-L`${PYTHON}-config --prefix`/lib `${PYTHON}-config --ldflags`" ;; darwin*) - CFLAGS="`${PYTHON}-config --cflags` -Wno-error=unused-command-line-argument-hard-error-in-future" + CFLAGS="`${PYTHON}-config --cflags`" CPPFLAGS=$CFLAGS LDFLAGS="-L`${PYTHON}-config --prefix`/lib `${PYTHON}-config --ldflags`" ;; @@ -932,6 +932,12 @@ CFLAGS=$saved_CFLAGS CPPFLAGS=$saved_CPPFLAGS LDFLAGS=$saved_LDFLAGS +case $host_os in + darwin*) + BUILD_GLUPY=no + ;; +esac + if test "x$BUILD_GLUPY" = "xyes"; then BUILD_PYTHON_INC=`$PYTHON -c "from distutils import sysconfig; print sysconfig.get_python_inc()"` BUILD_PYTHON_LIB=python$PYTHON_VERSION diff --git a/xlators/mount/fuse/src/Makefile.am b/xlators/mount/fuse/src/Makefile.am index 653121d18..7d1f93447 100644 --- a/xlators/mount/fuse/src/Makefile.am +++ b/xlators/mount/fuse/src/Makefile.am @@ -1,7 +1,9 @@ noinst_HEADERS_linux = $(CONTRIBDIR)/fuse-include/fuse_kernel.h\ $(CONTRIBDIR)/fuse-include/mount_util.h\ $(CONTRIBDIR)/fuse-lib/mount-gluster-compat.h -noinst_HEADERS_darwin = $(CONTRIBDIR)/fuse-include/fuse_kernel_macfuse.h +noinst_HEADERS_darwin = $(CONTRIBDIR)/fuse-include/fuse_kernel_macfuse.h\ + $(CONTRIBDIR)/macfuse/fuse_param.h\ + $(CONTRIBDIR)/macfuse/fuse_ioctl.h noinst_HEADERS_common = $(CONTRIBDIR)/fuse-include/fuse-mount.h\ $(CONTRIBDIR)/fuse-include/fuse-misc.h fuse-mem-types.h \ fuse-bridge.h -- cgit From 40675af8b4a1a90331e353295c75c0ea63457cf6 Mon Sep 17 00:00:00 2001 From: Kotresh H R Date: Thu, 24 Apr 2014 14:21:46 +0530 Subject: feature/changelog: Change default rollover and fsync-interval time This will change the following default configurables. 1. rollover-time: from 60 to 15. 2. fsync-interval: from 0 to 5. Change-Id: I9c8db01376967c4f19547ec87f54833f8b139d29 Signed-off-by: Kotresh H R Reviewed-on: http://review.gluster.org/7545 Reviewed-by: Venky Shankar Tested-by: Venky Shankar --- xlators/features/changelog/src/changelog.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/xlators/features/changelog/src/changelog.c b/xlators/features/changelog/src/changelog.c index 5fe3b4362..3e40984f6 100644 --- a/xlators/features/changelog/src/changelog.c +++ b/xlators/features/changelog/src/changelog.c @@ -1553,13 +1553,13 @@ struct volume_options options[] = { .description = "encoding type for changelogs" }, {.key = {"rollover-time"}, - .default_value = "60", + .default_value = "15", .type = GF_OPTION_TYPE_TIME, .description = "time to switch to a new changelog file (in seconds)" }, {.key = {"fsync-interval"}, .type = GF_OPTION_TYPE_TIME, - .default_value = "0", + .default_value = "5", .description = "do not open CHANGELOG file with O_SYNC mode." " instead perform fsync() at specified intervals" }, -- cgit From 9819fcedf10f1430d4969c86e6df4dfe975b7dcf Mon Sep 17 00:00:00 2001 From: Harshavardhana Date: Tue, 22 Apr 2014 13:27:35 -0700 Subject: rpcgen: Remove autogenerated files instead build on demand Avoid modifying autogenerated files and keeping them in repository - autogenerate them on demand from ".x" files Change-Id: I2cdb1fe9b99768ceb80a8cb100fa00bd1d8fe2c6 BUG: 1090807 Signed-off-by: Harshavardhana Reviewed-on: http://review.gluster.org/7526 Tested-by: Gluster Build System Reviewed-by: Niels de Vos Reviewed-by: Anand Avati --- Makefile.am | 1 + build-aux/xdrgen | 93 ++ configure.ac | 5 + extras/generate-xdr-files.sh | 98 -- rpc/Makefile.am | 2 +- rpc/rpc-lib/src/xdr-common.h | 13 +- rpc/xdr/src/.gitignore | 18 + rpc/xdr/src/Makefile.am | 33 +- rpc/xdr/src/acl.x | 48 - rpc/xdr/src/acl3-xdr.c | 94 -- rpc/xdr/src/acl3-xdr.h | 107 -- rpc/xdr/src/acl3-xdr.x | 47 + rpc/xdr/src/cli1-xdr.c | 376 ------- rpc/xdr/src/cli1-xdr.h | 386 ------- rpc/xdr/src/cli1-xdr.x | 54 +- rpc/xdr/src/glusterd1-xdr.c | 923 ---------------- rpc/xdr/src/glusterd1-xdr.h | 418 ------- rpc/xdr/src/glusterfs3-xdr.c | 2058 ----------------------------------- rpc/xdr/src/glusterfs3-xdr.h | 1394 ------------------------ rpc/xdr/src/nlm4-xdr.c | 245 ----- rpc/xdr/src/nlm4-xdr.h | 260 ----- rpc/xdr/src/nlm4-xdr.x | 160 +++ rpc/xdr/src/nlm4.x | 154 --- rpc/xdr/src/nlmcbk-xdr.c | 28 - rpc/xdr/src/nlmcbk-xdr.h | 65 -- rpc/xdr/src/nlmcbk.x | 24 - rpc/xdr/src/nsm-xdr.c | 96 -- rpc/xdr/src/nsm-xdr.h | 95 -- rpc/xdr/src/nsm-xdr.x | 47 + rpc/xdr/src/nsm.x | 47 - rpc/xdr/src/portmap-xdr.c | 237 ---- rpc/xdr/src/portmap-xdr.h | 130 --- rpc/xdr/src/rpc-common-xdr.c | 223 ---- rpc/xdr/src/rpc-common-xdr.h | 104 -- rpc/xdr/src/xdr-generic.h | 1 - rpc/xdr/src/xdr-nfs3.c | 9 - xlators/nfs/server/src/acl3.h | 5 + xlators/nfs/server/src/nlm4.c | 45 +- xlators/nfs/server/src/nlm4.h | 26 + xlators/nfs/server/src/nlmcbk_svc.c | 1 - 40 files changed, 482 insertions(+), 7688 deletions(-) create mode 100755 build-aux/xdrgen delete mode 100755 extras/generate-xdr-files.sh create mode 100644 rpc/xdr/src/.gitignore delete mode 100644 rpc/xdr/src/acl.x delete mode 100644 rpc/xdr/src/acl3-xdr.c delete mode 100644 rpc/xdr/src/acl3-xdr.h create mode 100644 rpc/xdr/src/acl3-xdr.x delete mode 100644 rpc/xdr/src/cli1-xdr.c delete mode 100644 rpc/xdr/src/cli1-xdr.h delete mode 100644 rpc/xdr/src/glusterd1-xdr.c delete mode 100644 rpc/xdr/src/glusterd1-xdr.h delete mode 100644 rpc/xdr/src/glusterfs3-xdr.c delete mode 100644 rpc/xdr/src/glusterfs3-xdr.h delete mode 100644 rpc/xdr/src/nlm4-xdr.c delete mode 100644 rpc/xdr/src/nlm4-xdr.h create mode 100644 rpc/xdr/src/nlm4-xdr.x delete mode 100644 rpc/xdr/src/nlm4.x delete mode 100644 rpc/xdr/src/nlmcbk-xdr.c delete mode 100644 rpc/xdr/src/nlmcbk-xdr.h delete mode 100644 rpc/xdr/src/nlmcbk.x delete mode 100644 rpc/xdr/src/nsm-xdr.c delete mode 100644 rpc/xdr/src/nsm-xdr.h create mode 100644 rpc/xdr/src/nsm-xdr.x delete mode 100644 rpc/xdr/src/nsm.x delete mode 100644 rpc/xdr/src/portmap-xdr.c delete mode 100644 rpc/xdr/src/portmap-xdr.h delete mode 100644 rpc/xdr/src/rpc-common-xdr.c delete mode 100644 rpc/xdr/src/rpc-common-xdr.h diff --git a/Makefile.am b/Makefile.am index b42071db2..41859a2ea 100644 --- a/Makefile.am +++ b/Makefile.am @@ -5,6 +5,7 @@ EXTRA_DIST = autogen.sh \ error-codes.json gf-error-codes.h.template \ gen-headers.py run-tests.sh \ build-aux/pkg-version \ + build-aux/xdrgen \ contrib/argp-standalone \ $(shell find $(top_srcdir)/tests -type f -print) diff --git a/build-aux/xdrgen b/build-aux/xdrgen new file mode 100755 index 000000000..dd5571baa --- /dev/null +++ b/build-aux/xdrgen @@ -0,0 +1,93 @@ +#!/bin/sh + +_init () +{ + xfile="$1"; + + cfile="${1%.x}.c"; + hfile="${1%.x}.h"; + + tmp_cfile="$1.c"; + + tmp1_hfile="$1.h.tmp"; + tmp1_cfile="$1.c.tmp"; + +} + +append_licence_header () +{ + src_file=$1; + dst_file=$2; + + cat >$dst_file < + This file is part of GlusterFS. + + This file is licensed to you under your choice of the GNU Lesser + General Public License, version 3 or any later version (LGPLv3 or + later), or the GNU General Public License, version 2 (GPLv2), in all + cases as published by the Free Software Foundation. +*/ + +#include "compat.h" +#include "xdr-common.h" +#include "xdr-nfs3.h" + +#if defined(__GNUC__) +#if __GNUC__ >= 4 +#pragma GCC diagnostic ignored "-Wunused-but-set-variable" +#pragma GCC diagnostic ignored "-Wunused-variable" +#endif +#endif + +EOF + + cat $src_file >> $dst_file; + +} + +main () +{ + if [ $# -ne 1 ]; then + echo "wrong number of arguments given" + echo " $0 .x" + exit 1; + fi + + + echo -n "writing the XDR routine file ($tmp_cfile) ... "; + rm -f $tmp_cfile; + rpcgen -c -o $tmp_cfile $xfile; + + echo "OK"; + + # no need for a temporary file here as there are no changes from glusterfs + echo -n "writing the XDR header file ($hfile) ... "; + rm -f $hfile; + rpcgen -h -o $hfile $xfile; + + # the '#ifdef' part of file should be fixed + sed -i -e 's/-/_/g' $hfile; + + echo "OK"; + + echo -n "writing licence header to the generated files ... "; + # Write header to temp file and append generated file + append_licence_header $hfile $tmp1_hfile; + append_licence_header $tmp_cfile $tmp1_cfile; + echo "OK" + + # now move the destination file to actual original file + echo -n "updating existing files ... "; + mv $tmp1_hfile $hfile; + mv $tmp1_cfile $cfile; + + # remove unwanted temporary files (if any) + rm -f $tmp_cfile $tmp1_cfile $tmp1_hfile + + echo "OK" + +} + +_init "$@" && main "$@"; diff --git a/configure.ac b/configure.ac index ae945b291..ae0bc78c4 100644 --- a/configure.ac +++ b/configure.ac @@ -203,6 +203,11 @@ AC_PROG_CC AC_DISABLE_STATIC AC_PROG_LIBTOOL +AC_CHECK_PROG([RPCGEN], [rpcgen], [yes], [no]) + +if test "x$RPCGEN" = "xno"; then + AC_MSG_ERROR([`rpcgen` not found, glusterfs needs `rpcgen` exiting..]) +fi # Initialize CFLAGS before usage AC_ARG_ENABLE([debug], diff --git a/extras/generate-xdr-files.sh b/extras/generate-xdr-files.sh deleted file mode 100755 index bc02f77c9..000000000 --- a/extras/generate-xdr-files.sh +++ /dev/null @@ -1,98 +0,0 @@ -#!/bin/sh - -_init () -{ - xfile="$1"; - # TODO: check the validity of .x file - - cfile="${1%.x}.c"; - hfile="${1%.x}.h"; - - tmp_cfile="$1.c"; - - tmp1_hfile="$1.h.tmp"; - tmp1_cfile="$1.c.tmp"; - -} - -append_licence_header () -{ - src_file=$1; - dst_file=$2; - - cat >$dst_file < - This file is part of GlusterFS. - - This file is licensed to you under your choice of the GNU Lesser - General Public License, version 3 or any later version (LGPLv3 or - later), or the GNU General Public License, version 2 (GPLv2), in all - cases as published by the Free Software Foundation. -*/ - -#include "xdr-common.h" -#include "compat.h" - -#if defined(__GNUC__) -#if __GNUC__ >= 4 -#pragma GCC diagnostic ignored "-Wunused-but-set-variable" -#endif -#endif - -EOF - - cat $src_file >> $dst_file; - -} - -main () -{ - if [ $# -ne 1 ]; then - echo "wrong number of arguments given" - echo " $0 .x" - exit 1; - fi - - - echo -n "writing the XDR routine file ($tmp_cfile) ... "; - rm -f $tmp_cfile; - rpcgen -c -o $tmp_cfile $xfile; - - # get rid of warnings in xdr .c file due to "unused variable 'buf'" - sed -i -e 's:buf;$:buf;\ - buf = NULL;:' $tmp_cfile; - - sed -i '/int i;/d' $tmp_cfile; - - echo "OK"; - - # no need for a temporary file here as there are no changes from glusterfs - echo -n "writing the XDR header file ($hfile) ... "; - rm -f $hfile; - rpcgen -h -o $hfile $xfile; - - # the '#ifdef' part of file should be fixed - sed -i -e 's/-/_/g' $hfile; - - echo "OK"; - - echo -n "writing licence header to the generated files ... "; - # Write header to temp file and append generated file - append_licence_header $hfile $tmp1_hfile; - append_licence_header $tmp_cfile $tmp1_cfile; - echo "OK" - - # now move the destination file to actual original file - echo -n "updating existing files ... "; - mv $tmp1_hfile $hfile; - mv $tmp1_cfile $cfile; - - # remove unwanted temporary files (if any) - rm -f $tmp_cfile $tmp1_cfile $tmp1_hfile - - echo "OK" - -} - -_init "$@" && main "$@"; diff --git a/rpc/Makefile.am b/rpc/Makefile.am index ffb76e901..183b7a035 100644 --- a/rpc/Makefile.am +++ b/rpc/Makefile.am @@ -1 +1 @@ -SUBDIRS = rpc-lib rpc-transport xdr +SUBDIRS = xdr rpc-lib rpc-transport diff --git a/rpc/rpc-lib/src/xdr-common.h b/rpc/rpc-lib/src/xdr-common.h index 78c72e509..631f4b284 100644 --- a/rpc/rpc-lib/src/xdr-common.h +++ b/rpc/rpc-lib/src/xdr-common.h @@ -64,12 +64,17 @@ enum gf_dump_procnum { #define GF_AUTH_GLUSTERFS_MAX_LKOWNER(groups_len) \ (95 - groups_len) -#if GF_DARWIN_HOST_OS +#ifdef GF_LINUX_HOST_OS +#define xdr_u_int32_t xdr_uint32_t +#define xdr_u_int64_t xdr_uint64_t +#endif + +#ifdef GF_DARWIN_HOST_OS #define xdr_u_quad_t xdr_u_int64_t #define xdr_quad_t xdr_int64_t #define xdr_uint32_t xdr_u_int32_t #define xdr_uint64_t xdr_u_int64_t - +#define uint64_t u_int64_t unsigned long xdr_sizeof (xdrproc_t func, void *data); #endif @@ -80,13 +85,11 @@ unsigned long xdr_sizeof (xdrproc_t func, void *data); #define xdr_uint64_t xdr_u_int64_t #endif - -#if GF_SOLARIS_HOST_OS +#ifdef GF_SOLARIS_HOST_OS #define u_quad_t uint64_t #define quad_t int64_t #define xdr_u_quad_t xdr_uint64_t #define xdr_quad_t xdr_int64_t -#define xdr_uint32_t xdr_uint32_t #endif /* Returns the address of the byte that follows the diff --git a/rpc/xdr/src/.gitignore b/rpc/xdr/src/.gitignore new file mode 100644 index 000000000..407f135c5 --- /dev/null +++ b/rpc/xdr/src/.gitignore @@ -0,0 +1,18 @@ +acl3-xdr.c +acl3-xdr.h +nlmcbk-xdr.c +nlmcbk-xdr.h +nsm-xdr.c +nsm-xdr.h +cli1-xdr.c +cli1-xdr.h +glusterd1-xdr.c +glusterd1-xdr.h +glusterfs3-xdr.c +glusterfs3-xdr.h +nlm4-xdr.c +nlm4-xdr.h +portmap-xdr.c +portmap-xdr.h +rpc-common-xdr.c +rpc-common-xdr.h diff --git a/rpc/xdr/src/Makefile.am b/rpc/xdr/src/Makefile.am index 0ec96e464..e39c677a9 100644 --- a/rpc/xdr/src/Makefile.am +++ b/rpc/xdr/src/Makefile.am @@ -5,23 +5,22 @@ libgfxdr_la_CFLAGS = -Wall $(GF_CFLAGS) $(GF_DARWIN_LIBGLUSTERFS_CFLAGS) libgfxdr_la_CPPFLAGS = $(GF_CPPFLAGS) -D__USE_FILE_OFFSET64 \ -I$(top_srcdir)/libglusterfs/src -I$(top_srcdir)/rpc/rpc-lib/src -libgfxdr_la_LIBADD = $(top_builddir)/libglusterfs/src/libglusterfs.la \ - $(top_builddir)/rpc/rpc-lib/src/libgfrpc.la +libgfxdr_la_LIBADD = $(top_builddir)/libglusterfs/src/libglusterfs.la libgfxdr_la_LDFLAGS = -version-info $(LIBGFXDR_LT_VERSION) -libgfxdr_la_SOURCES = xdr-generic.c rpc-common-xdr.c \ - glusterfs3-xdr.c \ - cli1-xdr.c \ - glusterd1-xdr.c \ - portmap-xdr.c \ - nlm4-xdr.c xdr-nfs3.c msg-nfs3.c nsm-xdr.c \ - nlmcbk-xdr.c acl3-xdr.c - -noinst_HEADERS = xdr-generic.h rpc-common-xdr.h \ - glusterfs3-xdr.h glusterfs3.h \ - cli1-xdr.h \ - glusterd1-xdr.h \ - portmap-xdr.h \ - nlm4-xdr.h xdr-nfs3.h msg-nfs3.h nsm-xdr.h \ - nlmcbk-xdr.h acl3-xdr.h +libgfxdr_la_SOURCES = $(XDRSOURCES) xdr-generic.c xdr-nfs3.c msg-nfs3.c + +noinst_HEADERS = $(XDRHEADERS) xdr-generic.h xdr-nfs3.h msg-nfs3.h glusterfs3.h + +XDRSOURCES = glusterfs3-xdr.c cli1-xdr.c nlm4-xdr.c nsm-xdr.c \ + rpc-common-xdr.c glusterd1-xdr.c acl3-xdr.c portmap-xdr.c +XDRHEADERS = glusterfs3-xdr.h cli1-xdr.h nlm4-xdr.h nsm-xdr.h \ + rpc-common-xdr.h glusterd1-xdr.h acl3-xdr.h portmap-xdr.h + +%.h:%.x + $(top_srcdir)/build-aux/xdrgen $(top_srcdir)/rpc/xdr/src/$*.x +%.c:%.x + $(top_srcdir)/build-aux/xdrgen $(top_srcdir)/rpc/xdr/src/$*.x + +CLEANFILES = $(XDRSOURCES) $(XDRHEADERS) diff --git a/rpc/xdr/src/acl.x b/rpc/xdr/src/acl.x deleted file mode 100644 index 6cf4f1d3b..000000000 --- a/rpc/xdr/src/acl.x +++ /dev/null @@ -1,48 +0,0 @@ -/* - * Copyright (c) 2012 Red Hat, Inc. - * This file is part of GlusterFS. - * - * This file is licensed to you under your choice of the GNU Lesser - * General Public License, version 3 or any later version (LGPLv3 or - * later), or the GNU General Public License, version 2 (GPLv2), in all - * cases as published by the Free Software Foundation. - */ - - -struct aclentry { - int type; - int uid; - int perm; -}; - -struct getaclargs { - netobj fh; - int mask; -}; - -struct getaclreply { - int status; - int attr_follows; - struct fattr3 attr; - int mask; - int aclcount; - struct aclentry aclentry<>; - int daclcount; - struct aclentry daclentry<>; -}; - -struct setaclargs { - netobj fh; - int mask; - int aclcount; - struct aclentry aclentry<>; - int daclcount; - struct aclentry daclentry<>; -}; - -struct setaclreply { - int status; - int attr_follows; - struct fattr3 attr; -}; - diff --git a/rpc/xdr/src/acl3-xdr.c b/rpc/xdr/src/acl3-xdr.c deleted file mode 100644 index 8fbaeff16..000000000 --- a/rpc/xdr/src/acl3-xdr.c +++ /dev/null @@ -1,94 +0,0 @@ -/* - * Copyright (c) 2012 Red Hat, Inc. - * This file is part of GlusterFS. - * - * This file is licensed to you under your choice of the GNU Lesser - * General Public License, version 3 or any later version (LGPLv3 or - * later), or the GNU General Public License, version 2 (GPLv2), in all - * cases as published by the Free Software Foundation. - */ - -/* - * Please do not edit this file. - * It was generated using rpcgen. - */ - -#include "acl3-xdr.h" - -bool_t -xdr_aclentry (XDR *xdrs, aclentry *objp) -{ - if (!xdr_int (xdrs, &objp->type)) - return FALSE; - if (!xdr_int (xdrs, &objp->uid)) - return FALSE; - if (!xdr_int (xdrs, &objp->perm)) - return FALSE; - return TRUE; -} - -bool_t -xdr_getaclargs (XDR *xdrs, getaclargs *objp) -{ - if (!xdr_netobj (xdrs, &objp->fh)) - return FALSE; - if (!xdr_int (xdrs, &objp->mask)) - return FALSE; - return TRUE; -} - -bool_t -xdr_getaclreply (XDR *xdrs, getaclreply *objp) -{ - if (!xdr_int (xdrs, &objp->status)) - return FALSE; - if (!xdr_int (xdrs, &objp->attr_follows)) - return FALSE; - if (!xdr_fattr3 (xdrs, &objp->attr)) - return FALSE; - if (!xdr_int (xdrs, &objp->mask)) - return FALSE; - if (!xdr_int (xdrs, &objp->aclcount)) - return FALSE; - if (!xdr_array (xdrs, (char **)&objp->aclentry.aclentry_val, (u_int *) &objp->aclentry.aclentry_len, ~0, - sizeof (aclentry), (xdrproc_t) xdr_aclentry)) - return FALSE; - if (!xdr_int (xdrs, &objp->daclcount)) - return FALSE; - if (!xdr_array (xdrs, (char **)&objp->daclentry.daclentry_val, (u_int *) &objp->daclentry.daclentry_len, ~0, - sizeof (aclentry), (xdrproc_t) xdr_aclentry)) - return FALSE; - return TRUE; -} - -bool_t -xdr_setaclargs (XDR *xdrs, setaclargs *objp) -{ - if (!xdr_netobj (xdrs, &objp->fh)) - return FALSE; - if (!xdr_int (xdrs, &objp->mask)) - return FALSE; - if (!xdr_int (xdrs, &objp->aclcount)) - return FALSE; - if (!xdr_array (xdrs, (char **)&objp->aclentry.aclentry_val, (u_int *) &objp->aclentry.aclentry_len, ~0, - sizeof (aclentry), (xdrproc_t) xdr_aclentry)) - return FALSE; - if (!xdr_int (xdrs, &objp->daclcount)) - return FALSE; - if (!xdr_array (xdrs, (char **)&objp->daclentry.daclentry_val, (u_int *) &objp->daclentry.daclentry_len, ~0, - sizeof (aclentry), (xdrproc_t) xdr_aclentry)) - return FALSE; - return TRUE; -} - -bool_t -xdr_setaclreply (XDR *xdrs, setaclreply *objp) -{ - if (!xdr_int (xdrs, &objp->status)) - return FALSE; - if (!xdr_int (xdrs, &objp->attr_follows)) - return FALSE; - if (!xdr_fattr3 (xdrs, &objp->attr)) - return FALSE; - return TRUE; -} diff --git a/rpc/xdr/src/acl3-xdr.h b/rpc/xdr/src/acl3-xdr.h deleted file mode 100644 index 7cebaed69..000000000 --- a/rpc/xdr/src/acl3-xdr.h +++ /dev/null @@ -1,107 +0,0 @@ -/* - * Copyright (c) 2012 Red Hat, Inc. - * This file is part of GlusterFS. - * - * This file is licensed to you under your choice of the GNU Lesser - * General Public License, version 3 or any later version (LGPLv3 or - * later), or the GNU General Public License, version 2 (GPLv2), in all - * cases as published by the Free Software Foundation. - */ - -/* - * Please do not edit this file. - * It was generated using rpcgen. - */ - -#ifndef _ACL_H_RPCGEN -#define _ACL_H_RPCGEN - -#include -#include "xdr-nfs3.h" - -#ifdef __cplusplus -extern "C" { -#endif - - -struct aclentry { - int type; - int uid; - int perm; -}; -typedef struct aclentry aclentry; - -struct getaclargs { - netobj fh; - int mask; -}; -typedef struct getaclargs getaclargs; - -struct getaclreply { - int status; - int attr_follows; - struct fattr3 attr; - int mask; - int aclcount; - struct { - u_int aclentry_len; - struct aclentry *aclentry_val; - } aclentry; - int daclcount; - struct { - u_int daclentry_len; - struct aclentry *daclentry_val; - } daclentry; -}; -typedef struct getaclreply getaclreply; - -struct setaclargs { - netobj fh; - int mask; - int aclcount; - struct { - u_int aclentry_len; - struct aclentry *aclentry_val; - } aclentry; - int daclcount; - struct { - u_int daclentry_len; - struct aclentry *daclentry_val; - } daclentry; -}; -typedef struct setaclargs setaclargs; - -struct setaclreply { - int status; - int attr_follows; - struct fattr3 attr; -}; -typedef struct setaclreply setaclreply; - -#define ACL3_NULL 0 -#define ACL3_GETACL 1 -#define ACL3_SETACL 2 -#define ACL3_PROC_COUNT 3 -/* the xdr functions */ - -#if defined(__STDC__) || defined(__cplusplus) -extern bool_t xdr_aclentry (XDR *, aclentry*); -extern bool_t xdr_getaclargs (XDR *, getaclargs*); -extern bool_t xdr_getaclreply (XDR *, getaclreply*); -extern bool_t xdr_setaclargs (XDR *, setaclargs*); -extern bool_t xdr_setaclreply (XDR *, setaclreply*); - -#else /* K&R C */ -extern bool_t xdr_aclentry (); -extern bool_t xdr_getaclargs (); -extern bool_t xdr_getaclreply (); -extern bool_t xdr_setaclargs (); -extern bool_t xdr_setaclreply (); - -#endif /* K&R C */ - -#ifdef __cplusplus -} -#endif - -#endif /* !_ACL_H_RPCGEN */ diff --git a/rpc/xdr/src/acl3-xdr.x b/rpc/xdr/src/acl3-xdr.x new file mode 100644 index 000000000..8ca6e84b5 --- /dev/null +++ b/rpc/xdr/src/acl3-xdr.x @@ -0,0 +1,47 @@ +/* + * Copyright (c) 2012 Red Hat, Inc. + * This file is part of GlusterFS. + * + * This file is licensed to you under your choice of the GNU Lesser + * General Public License, version 3 or any later version (LGPLv3 or + * later), or the GNU General Public License, version 2 (GPLv2), in all + * cases as published by the Free Software Foundation. + */ + + +struct aclentry { + int type; + int uid; + int perm; +}; + +struct getaclargs { + netobj fh; + int mask; +}; + +struct getaclreply { + int status; + int attr_follows; + struct fattr3 attr; + int mask; + int aclcount; + struct aclentry aclentry<>; + int daclcount; + struct aclentry daclentry<>; +}; + +struct setaclargs { + netobj fh; + int mask; + int aclcount; + struct aclentry aclentry<>; + int daclcount; + struct aclentry daclentry<>; +}; + +struct setaclreply { + int status; + int attr_follows; + struct fattr3 attr; +}; diff --git a/rpc/xdr/src/cli1-xdr.c b/rpc/xdr/src/cli1-xdr.c deleted file mode 100644 index cbb248587..000000000 --- a/rpc/xdr/src/cli1-xdr.c +++ /dev/null @@ -1,376 +0,0 @@ -/* - Copyright (c) 2007-2012 Red Hat, Inc. - This file is part of GlusterFS. - - This file is licensed to you under your choice of the GNU Lesser - General Public License, version 3 or any later version (LGPLv3 or - later), or the GNU General Public License, version 2 (GPLv2), in all - cases as published by the Free Software Foundation. -*/ - -#include "xdr-common.h" -#include "compat.h" - -#if defined(__GNUC__) -#if __GNUC__ >= 4 -#pragma GCC diagnostic ignored "-Wunused-but-set-variable" -#endif -#endif - -/* - * Please do not edit this file. - * It was generated using rpcgen. - */ - -#include "cli1-xdr.h" - -bool_t -xdr_gf_cli_defrag_type (XDR *xdrs, gf_cli_defrag_type *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_enum (xdrs, (enum_t *) objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gf_defrag_status_t (XDR *xdrs, gf_defrag_status_t *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_enum (xdrs, (enum_t *) objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gf1_cluster_type (XDR *xdrs, gf1_cluster_type *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_enum (xdrs, (enum_t *) objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gf1_cli_replace_op (XDR *xdrs, gf1_cli_replace_op *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_enum (xdrs, (enum_t *) objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gf1_op_commands (XDR *xdrs, gf1_op_commands *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_enum (xdrs, (enum_t *) objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gf_quota_type (XDR *xdrs, gf_quota_type *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_enum (xdrs, (enum_t *) objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gf1_cli_friends_list (XDR *xdrs, gf1_cli_friends_list *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_enum (xdrs, (enum_t *) objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gf1_cli_get_volume (XDR *xdrs, gf1_cli_get_volume *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_enum (xdrs, (enum_t *) objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gf1_cli_sync_volume (XDR *xdrs, gf1_cli_sync_volume *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_enum (xdrs, (enum_t *) objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gf1_cli_op_flags (XDR *xdrs, gf1_cli_op_flags *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_enum (xdrs, (enum_t *) objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gf1_cli_gsync_set (XDR *xdrs, gf1_cli_gsync_set *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_enum (xdrs, (enum_t *) objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gf1_cli_stats_op (XDR *xdrs, gf1_cli_stats_op *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_enum (xdrs, (enum_t *) objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gf1_cli_info_op (XDR *xdrs, gf1_cli_info_op *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_enum (xdrs, (enum_t *) objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gf1_cli_top_op (XDR *xdrs, gf1_cli_top_op *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_enum (xdrs, (enum_t *) objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gf_cli_status_type (XDR *xdrs, gf_cli_status_type *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_enum (xdrs, (enum_t *) objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gf1_cli_snapshot (XDR *xdrs, gf1_cli_snapshot *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_enum (xdrs, (enum_t *) objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gf1_cli_snapshot_config (XDR *xdrs, gf1_cli_snapshot_config *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_enum (xdrs, (enum_t *) objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gf_cli_req (XDR *xdrs, gf_cli_req *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_bytes (xdrs, (char **)&objp->dict.dict_val, (u_int *) &objp->dict.dict_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gf_cli_rsp (XDR *xdrs, gf_cli_rsp *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_int (xdrs, &objp->op_ret)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_errno)) - return FALSE; - if (!xdr_string (xdrs, &objp->op_errstr, ~0)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->dict.dict_val, (u_int *) &objp->dict.dict_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gf1_cli_peer_list_req (XDR *xdrs, gf1_cli_peer_list_req *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_int (xdrs, &objp->flags)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->dict.dict_val, (u_int *) &objp->dict.dict_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gf1_cli_peer_list_rsp (XDR *xdrs, gf1_cli_peer_list_rsp *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_int (xdrs, &objp->op_ret)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_errno)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->friends.friends_val, (u_int *) &objp->friends.friends_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gf1_cli_fsm_log_req (XDR *xdrs, gf1_cli_fsm_log_req *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_string (xdrs, &objp->name, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gf1_cli_fsm_log_rsp (XDR *xdrs, gf1_cli_fsm_log_rsp *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_int (xdrs, &objp->op_ret)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_errno)) - return FALSE; - if (!xdr_string (xdrs, &objp->op_errstr, ~0)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->fsm_log.fsm_log_val, (u_int *) &objp->fsm_log.fsm_log_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gf1_cli_getwd_req (XDR *xdrs, gf1_cli_getwd_req *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_int (xdrs, &objp->unused)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gf1_cli_getwd_rsp (XDR *xdrs, gf1_cli_getwd_rsp *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_int (xdrs, &objp->op_ret)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_errno)) - return FALSE; - if (!xdr_string (xdrs, &objp->wd, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gf1_cli_mount_req (XDR *xdrs, gf1_cli_mount_req *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_string (xdrs, &objp->label, ~0)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->dict.dict_val, (u_int *) &objp->dict.dict_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gf1_cli_mount_rsp (XDR *xdrs, gf1_cli_mount_rsp *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_int (xdrs, &objp->op_ret)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_errno)) - return FALSE; - if (!xdr_string (xdrs, &objp->path, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gf1_cli_umount_req (XDR *xdrs, gf1_cli_umount_req *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_int (xdrs, &objp->lazy)) - return FALSE; - if (!xdr_string (xdrs, &objp->path, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gf1_cli_umount_rsp (XDR *xdrs, gf1_cli_umount_rsp *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_int (xdrs, &objp->op_ret)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_errno)) - return FALSE; - return TRUE; -} diff --git a/rpc/xdr/src/cli1-xdr.h b/rpc/xdr/src/cli1-xdr.h deleted file mode 100644 index f4251e6a2..000000000 --- a/rpc/xdr/src/cli1-xdr.h +++ /dev/null @@ -1,386 +0,0 @@ -/* - Copyright (c) 2007-2012 Red Hat, Inc. - This file is part of GlusterFS. - - This file is licensed to you under your choice of the GNU Lesser - General Public License, version 3 or any later version (LGPLv3 or - later), or the GNU General Public License, version 2 (GPLv2), in all - cases as published by the Free Software Foundation. -*/ - -#include "xdr-common.h" -#include "compat.h" - -#if defined(__GNUC__) -#if __GNUC__ >= 4 -#pragma GCC diagnostic ignored "-Wunused-but-set-variable" -#endif -#endif - -/* - * Please do not edit this file. - * It was generated using rpcgen. - */ - -#ifndef _CLI1_XDR_H_RPCGEN -#define _CLI1_XDR_H_RPCGEN - -#include - - -#ifdef __cplusplus -extern "C" { -#endif - - -enum gf_cli_defrag_type { - GF_DEFRAG_CMD_START = 1, - GF_DEFRAG_CMD_STOP = 1 + 1, - GF_DEFRAG_CMD_STATUS = 1 + 2, - GF_DEFRAG_CMD_START_LAYOUT_FIX = 1 + 3, - GF_DEFRAG_CMD_START_FORCE = 1 + 4, -}; -typedef enum gf_cli_defrag_type gf_cli_defrag_type; - -enum gf_defrag_status_t { - GF_DEFRAG_STATUS_NOT_STARTED = 0, - GF_DEFRAG_STATUS_STARTED = 1, - GF_DEFRAG_STATUS_STOPPED = 2, - GF_DEFRAG_STATUS_COMPLETE = 3, - GF_DEFRAG_STATUS_FAILED = 4, - GF_DEFRAG_STATUS_LAYOUT_FIX_STARTED = 5, - GF_DEFRAG_STATUS_LAYOUT_FIX_STOPPED = 6, - GF_DEFRAG_STATUS_LAYOUT_FIX_COMPLETE = 7, - GF_DEFRAG_STATUS_LAYOUT_FIX_FAILED = 8, - GF_DEFRAG_STATUS_MAX = 9, -}; -typedef enum gf_defrag_status_t gf_defrag_status_t; - -enum gf1_cluster_type { - GF_CLUSTER_TYPE_NONE = 0, - GF_CLUSTER_TYPE_STRIPE = 0 + 1, - GF_CLUSTER_TYPE_REPLICATE = 0 + 2, - GF_CLUSTER_TYPE_STRIPE_REPLICATE = 0 + 3, -}; -typedef enum gf1_cluster_type gf1_cluster_type; - -enum gf1_cli_replace_op { - GF_REPLACE_OP_NONE = 0, - GF_REPLACE_OP_START = 0 + 1, - GF_REPLACE_OP_COMMIT = 0 + 2, - GF_REPLACE_OP_PAUSE = 0 + 3, - GF_REPLACE_OP_ABORT = 0 + 4, - GF_REPLACE_OP_STATUS = 0 + 5, - GF_REPLACE_OP_COMMIT_FORCE = 0 + 6, -}; -typedef enum gf1_cli_replace_op gf1_cli_replace_op; - -enum gf1_op_commands { - GF_OP_CMD_NONE = 0, - GF_OP_CMD_START = 0 + 1, - GF_OP_CMD_COMMIT = 0 + 2, - GF_OP_CMD_STOP = 0 + 3, - GF_OP_CMD_STATUS = 0 + 4, - GF_OP_CMD_COMMIT_FORCE = 0 + 5, -}; -typedef enum gf1_op_commands gf1_op_commands; - -enum gf_quota_type { - GF_QUOTA_OPTION_TYPE_NONE = 0, - GF_QUOTA_OPTION_TYPE_ENABLE = 0 + 1, - GF_QUOTA_OPTION_TYPE_DISABLE = 0 + 2, - GF_QUOTA_OPTION_TYPE_LIMIT_USAGE = 0 + 3, - GF_QUOTA_OPTION_TYPE_REMOVE = 0 + 4, - GF_QUOTA_OPTION_TYPE_LIST = 0 + 5, - GF_QUOTA_OPTION_TYPE_VERSION = 0 + 6, - GF_QUOTA_OPTION_TYPE_ALERT_TIME = 0 + 7, - GF_QUOTA_OPTION_TYPE_SOFT_TIMEOUT = 0 + 8, - GF_QUOTA_OPTION_TYPE_HARD_TIMEOUT = 0 + 9, - GF_QUOTA_OPTION_TYPE_DEFAULT_SOFT_LIMIT = 0 + 10, -}; -typedef enum gf_quota_type gf_quota_type; - -enum gf1_cli_friends_list { - GF_CLI_LIST_PEERS = 1, - GF_CLI_LIST_POOL_NODES = 2, -}; -typedef enum gf1_cli_friends_list gf1_cli_friends_list; - -enum gf1_cli_get_volume { - GF_CLI_GET_VOLUME_ALL = 1, - GF_CLI_GET_VOLUME = 1 + 1, - GF_CLI_GET_NEXT_VOLUME = 1 + 2, -}; -typedef enum gf1_cli_get_volume gf1_cli_get_volume; - -enum gf1_cli_sync_volume { - GF_CLI_SYNC_ALL = 1, -}; -typedef enum gf1_cli_sync_volume gf1_cli_sync_volume; - -enum gf1_cli_op_flags { - GF_CLI_FLAG_OP_FORCE = 1, -}; -typedef enum gf1_cli_op_flags gf1_cli_op_flags; - -enum gf1_cli_gsync_set { - GF_GSYNC_OPTION_TYPE_NONE = 0, - GF_GSYNC_OPTION_TYPE_START = 1, - GF_GSYNC_OPTION_TYPE_STOP = 2, - GF_GSYNC_OPTION_TYPE_CONFIG = 3, - GF_GSYNC_OPTION_TYPE_STATUS = 4, - GF_GSYNC_OPTION_TYPE_ROTATE = 5, - GF_GSYNC_OPTION_TYPE_CREATE = 6, - GF_GSYNC_OPTION_TYPE_DELETE = 7, -}; -typedef enum gf1_cli_gsync_set gf1_cli_gsync_set; - -enum gf1_cli_stats_op { - GF_CLI_STATS_NONE = 0, - GF_CLI_STATS_START = 1, - GF_CLI_STATS_STOP = 2, - GF_CLI_STATS_INFO = 3, - GF_CLI_STATS_TOP = 4, -}; -typedef enum gf1_cli_stats_op gf1_cli_stats_op; - -enum gf1_cli_info_op { - GF_CLI_INFO_NONE = 0, - GF_CLI_INFO_ALL = 1, - GF_CLI_INFO_INCREMENTAL = 2, - GF_CLI_INFO_CUMULATIVE = 3, - GF_CLI_INFO_CLEAR = 4, -}; -typedef enum gf1_cli_info_op gf1_cli_info_op; - -enum gf1_cli_top_op { - GF_CLI_TOP_NONE = 0, - GF_CLI_TOP_OPEN = 0 + 1, - GF_CLI_TOP_READ = 0 + 2, - GF_CLI_TOP_WRITE = 0 + 3, - GF_CLI_TOP_OPENDIR = 0 + 4, - GF_CLI_TOP_READDIR = 0 + 5, - GF_CLI_TOP_READ_PERF = 0 + 6, - GF_CLI_TOP_WRITE_PERF = 0 + 7, -}; -typedef enum gf1_cli_top_op gf1_cli_top_op; - -enum gf_cli_status_type { - GF_CLI_STATUS_NONE = 0x0000, - GF_CLI_STATUS_MEM = 0x0001, - GF_CLI_STATUS_CLIENTS = 0x0002, - GF_CLI_STATUS_INODE = 0x0004, - GF_CLI_STATUS_FD = 0x0008, - GF_CLI_STATUS_CALLPOOL = 0x0010, - GF_CLI_STATUS_DETAIL = 0x0020, - GF_CLI_STATUS_TASKS = 0x0040, - GF_CLI_STATUS_MASK = 0x00FF, - GF_CLI_STATUS_VOL = 0x0100, - GF_CLI_STATUS_ALL = 0x0200, - GF_CLI_STATUS_BRICK = 0x0400, - GF_CLI_STATUS_NFS = 0x0800, - GF_CLI_STATUS_SHD = 0x1000, - GF_CLI_STATUS_QUOTAD = 0x2000, -}; -typedef enum gf_cli_status_type gf_cli_status_type; - -enum gf1_cli_snapshot { - GF_SNAP_OPTION_TYPE_NONE = 0, - GF_SNAP_OPTION_TYPE_CREATE = 1, - GF_SNAP_OPTION_TYPE_DELETE = 2, - GF_SNAP_OPTION_TYPE_RESTORE = 3, - GF_SNAP_OPTION_TYPE_START = 4, - GF_SNAP_OPTION_TYPE_STOP = 5, - GF_SNAP_OPTION_TYPE_LIST = 6, - GF_SNAP_OPTION_TYPE_STATUS = 7, - GF_SNAP_OPTION_TYPE_CONFIG = 8, - GF_SNAP_OPTION_TYPE_INFO = 9, -}; -typedef enum gf1_cli_snapshot gf1_cli_snapshot; - -enum gf1_cli_snapshot_info { - GF_SNAP_INFO_TYPE_ALL = 0, - GF_SNAP_INFO_TYPE_SNAP = 1, - GF_SNAP_INFO_TYPE_VOL = 2, -}; -typedef enum gf1_cli_snapshot_info gf1_cli_snapshot_info; - -enum gf1_cli_snapshot_config { - GF_SNAP_CONFIG_TYPE_NONE = 0, - GF_SNAP_CONFIG_TYPE_SET = 1, - GF_SNAP_CONFIG_DISPLAY = 2, -}; -typedef enum gf1_cli_snapshot_config gf1_cli_snapshot_config; - -enum gf1_cli_snapshot_status { - GF_SNAP_STATUS_TYPE_ALL = 0, - GF_SNAP_STATUS_TYPE_SNAP = 1, - GF_SNAP_STATUS_TYPE_VOL = 2, -}; -typedef enum gf1_cli_snapshot_status gf1_cli_snapshot_status; - -struct gf_cli_req { - struct { - u_int dict_len; - char *dict_val; - } dict; -}; -typedef struct gf_cli_req gf_cli_req; - -struct gf_cli_rsp { - int op_ret; - int op_errno; - char *op_errstr; - struct { - u_int dict_len; - char *dict_val; - } dict; -}; -typedef struct gf_cli_rsp gf_cli_rsp; - -struct gf1_cli_peer_list_req { - int flags; - struct { - u_int dict_len; - char *dict_val; - } dict; -}; -typedef struct gf1_cli_peer_list_req gf1_cli_peer_list_req; - -struct gf1_cli_peer_list_rsp { - int op_ret; - int op_errno; - struct { - u_int friends_len; - char *friends_val; - } friends; -}; -typedef struct gf1_cli_peer_list_rsp gf1_cli_peer_list_rsp; - -struct gf1_cli_fsm_log_req { - char *name; -}; -typedef struct gf1_cli_fsm_log_req gf1_cli_fsm_log_req; - -struct gf1_cli_fsm_log_rsp { - int op_ret; - int op_errno; - char *op_errstr; - struct { - u_int fsm_log_len; - char *fsm_log_val; - } fsm_log; -}; -typedef struct gf1_cli_fsm_log_rsp gf1_cli_fsm_log_rsp; - -struct gf1_cli_getwd_req { - int unused; -}; -typedef struct gf1_cli_getwd_req gf1_cli_getwd_req; - -struct gf1_cli_getwd_rsp { - int op_ret; - int op_errno; - char *wd; -}; -typedef struct gf1_cli_getwd_rsp gf1_cli_getwd_rsp; - -struct gf1_cli_mount_req { - char *label; - struct { - u_int dict_len; - char *dict_val; - } dict; -}; -typedef struct gf1_cli_mount_req gf1_cli_mount_req; - -struct gf1_cli_mount_rsp { - int op_ret; - int op_errno; - char *path; -}; -typedef struct gf1_cli_mount_rsp gf1_cli_mount_rsp; - -struct gf1_cli_umount_req { - int lazy; - char *path; -}; -typedef struct gf1_cli_umount_req gf1_cli_umount_req; - -struct gf1_cli_umount_rsp { - int op_ret; - int op_errno; -}; -typedef struct gf1_cli_umount_rsp gf1_cli_umount_rsp; - -/* the xdr functions */ - -#if defined(__STDC__) || defined(__cplusplus) -extern bool_t xdr_gf_cli_defrag_type (XDR *, gf_cli_defrag_type*); -extern bool_t xdr_gf_defrag_status_t (XDR *, gf_defrag_status_t*); -extern bool_t xdr_gf1_cluster_type (XDR *, gf1_cluster_type*); -extern bool_t xdr_gf1_cli_replace_op (XDR *, gf1_cli_replace_op*); -extern bool_t xdr_gf1_op_commands (XDR *, gf1_op_commands*); -extern bool_t xdr_gf_quota_type (XDR *, gf_quota_type*); -extern bool_t xdr_gf1_cli_friends_list (XDR *, gf1_cli_friends_list*); -extern bool_t xdr_gf1_cli_get_volume (XDR *, gf1_cli_get_volume*); -extern bool_t xdr_gf1_cli_sync_volume (XDR *, gf1_cli_sync_volume*); -extern bool_t xdr_gf1_cli_op_flags (XDR *, gf1_cli_op_flags*); -extern bool_t xdr_gf1_cli_gsync_set (XDR *, gf1_cli_gsync_set*); -extern bool_t xdr_gf1_cli_stats_op (XDR *, gf1_cli_stats_op*); -extern bool_t xdr_gf1_cli_info_op (XDR *, gf1_cli_info_op*); -extern bool_t xdr_gf1_cli_top_op (XDR *, gf1_cli_top_op*); -extern bool_t xdr_gf_cli_status_type (XDR *, gf_cli_status_type*); -extern bool_t xdr_gf1_cli_snapshot (XDR *, gf1_cli_snapshot*); -extern bool_t xdr_gf1_cli_snapshot_config (XDR *, gf1_cli_snapshot_config*); -extern bool_t xdr_gf_cli_req (XDR *, gf_cli_req*); -extern bool_t xdr_gf_cli_rsp (XDR *, gf_cli_rsp*); -extern bool_t xdr_gf1_cli_peer_list_req (XDR *, gf1_cli_peer_list_req*); -extern bool_t xdr_gf1_cli_peer_list_rsp (XDR *, gf1_cli_peer_list_rsp*); -extern bool_t xdr_gf1_cli_fsm_log_req (XDR *, gf1_cli_fsm_log_req*); -extern bool_t xdr_gf1_cli_fsm_log_rsp (XDR *, gf1_cli_fsm_log_rsp*); -extern bool_t xdr_gf1_cli_getwd_req (XDR *, gf1_cli_getwd_req*); -extern bool_t xdr_gf1_cli_getwd_rsp (XDR *, gf1_cli_getwd_rsp*); -extern bool_t xdr_gf1_cli_mount_req (XDR *, gf1_cli_mount_req*); -extern bool_t xdr_gf1_cli_mount_rsp (XDR *, gf1_cli_mount_rsp*); -extern bool_t xdr_gf1_cli_umount_req (XDR *, gf1_cli_umount_req*); -extern bool_t xdr_gf1_cli_umount_rsp (XDR *, gf1_cli_umount_rsp*); - -#else /* K&R C */ -extern bool_t xdr_gf_cli_defrag_type (); -extern bool_t xdr_gf_defrag_status_t (); -extern bool_t xdr_gf1_cluster_type (); -extern bool_t xdr_gf1_cli_replace_op (); -extern bool_t xdr_gf1_op_commands (); -extern bool_t xdr_gf_quota_type (); -extern bool_t xdr_gf1_cli_friends_list (); -extern bool_t xdr_gf1_cli_get_volume (); -extern bool_t xdr_gf1_cli_sync_volume (); -extern bool_t xdr_gf1_cli_op_flags (); -extern bool_t xdr_gf1_cli_gsync_set (); -extern bool_t xdr_gf1_cli_stats_op (); -extern bool_t xdr_gf1_cli_info_op (); -extern bool_t xdr_gf1_cli_top_op (); -extern bool_t xdr_gf_cli_status_type (); -extern bool_t xdr_gf1_cli_snapshot (); -extern bool_t xdr_gf1_cli_snapshot_config (); -extern bool_t xdr_gf_cli_req (); -extern bool_t xdr_gf_cli_rsp (); -extern bool_t xdr_gf1_cli_peer_list_req (); -extern bool_t xdr_gf1_cli_peer_list_rsp (); -extern bool_t xdr_gf1_cli_fsm_log_req (); -extern bool_t xdr_gf1_cli_fsm_log_rsp (); -extern bool_t xdr_gf1_cli_getwd_req (); -extern bool_t xdr_gf1_cli_getwd_rsp (); -extern bool_t xdr_gf1_cli_mount_req (); -extern bool_t xdr_gf1_cli_mount_rsp (); -extern bool_t xdr_gf1_cli_umount_req (); -extern bool_t xdr_gf1_cli_umount_rsp (); - -#endif /* K&R C */ - -#ifdef __cplusplus -} -#endif - -#endif /* !_CLI1_XDR_H_RPCGEN */ diff --git a/rpc/xdr/src/cli1-xdr.x b/rpc/xdr/src/cli1-xdr.x index 6e5e44410..0e4e0376e 100644 --- a/rpc/xdr/src/cli1-xdr.x +++ b/rpc/xdr/src/cli1-xdr.x @@ -4,7 +4,7 @@ GF_DEFRAG_CMD_STATUS, GF_DEFRAG_CMD_START_LAYOUT_FIX, GF_DEFRAG_CMD_START_FORCE /* used by remove-brick data migration */ -} ; +}; enum gf_defrag_status_t { GF_DEFRAG_STATUS_NOT_STARTED, @@ -17,14 +17,14 @@ GF_DEFRAG_STATUS_LAYOUT_FIX_COMPLETE, GF_DEFRAG_STATUS_LAYOUT_FIX_FAILED, GF_DEFRAG_STATUS_MAX -} ; +}; enum gf1_cluster_type { GF_CLUSTER_TYPE_NONE = 0, GF_CLUSTER_TYPE_STRIPE, GF_CLUSTER_TYPE_REPLICATE, GF_CLUSTER_TYPE_STRIPE_REPLICATE -} ; +}; enum gf1_cli_replace_op { GF_REPLACE_OP_NONE = 0, @@ -34,7 +34,7 @@ GF_REPLACE_OP_ABORT, GF_REPLACE_OP_STATUS, GF_REPLACE_OP_COMMIT_FORCE -} ; +}; enum gf1_op_commands { GF_OP_CMD_NONE = 0, @@ -43,7 +43,7 @@ GF_OP_CMD_STOP, GF_OP_CMD_STATUS, GF_OP_CMD_COMMIT_FORCE -} ; +}; enum gf_quota_type { GF_QUOTA_OPTION_TYPE_NONE = 0, @@ -62,17 +62,17 @@ enum gf_quota_type { enum gf1_cli_friends_list { GF_CLI_LIST_PEERS = 1, GF_CLI_LIST_POOL_NODES = 2 -} ; +}; enum gf1_cli_get_volume { GF_CLI_GET_VOLUME_ALL = 1, GF_CLI_GET_VOLUME, GF_CLI_GET_NEXT_VOLUME -} ; +}; enum gf1_cli_sync_volume { GF_CLI_SYNC_ALL = 1 -} ; +}; enum gf1_cli_op_flags { GF_CLI_FLAG_OP_FORCE = 1 @@ -98,11 +98,11 @@ enum gf1_cli_stats_op { }; enum gf1_cli_info_op { - GF_CLI_INFO_NONE = 0, - GF_CLI_INFO_ALL = 1, - GF_CLI_INFO_INCREMENTAL = 2, - GF_CLI_INFO_CUMULATIVE = 3, - GF_CLI_INFO_CLEAR = 4 + GF_CLI_INFO_NONE = 0, + GF_CLI_INFO_ALL = 1, + GF_CLI_INFO_INCREMENTAL = 2, + GF_CLI_INFO_CUMULATIVE = 3, + GF_CLI_INFO_CLEAR = 4 }; enum gf1_cli_top_op { @@ -146,37 +146,49 @@ enum gf1_cli_snapshot { GF_SNAP_OPTION_TYPE_STOP, GF_SNAP_OPTION_TYPE_LIST, GF_SNAP_OPTION_TYPE_STATUS, - GF_SNAP_OPTION_TYPE_CONFIG + GF_SNAP_OPTION_TYPE_CONFIG, + GF_SNAP_OPTION_TYPE_INFO +}; + +enum gf1_cli_snapshot_info { + GF_SNAP_INFO_TYPE_ALL = 0, + GF_SNAP_INFO_TYPE_SNAP = 1, + GF_SNAP_INFO_TYPE_VOL = 2 }; enum gf1_cli_snapshot_config { GF_SNAP_CONFIG_TYPE_NONE = 0, GF_SNAP_CONFIG_TYPE_SET, - GF_SNAP_CONFIG_DISPLAY, + GF_SNAP_CONFIG_DISPLAY +}; +enum gf1_cli_snapshot_status { + GF_SNAP_STATUS_TYPE_ALL = 0, + GF_SNAP_STATUS_TYPE_SNAP = 1, + GF_SNAP_STATUS_TYPE_VOL = 2 }; - struct gf_cli_req { +struct gf_cli_req { opaque dict<>; -} ; +}; struct gf_cli_rsp { int op_ret; int op_errno; string op_errstr<>; opaque dict<>; -} ; +}; struct gf1_cli_peer_list_req { int flags; opaque dict<>; -} ; +}; struct gf1_cli_peer_list_rsp { int op_ret; int op_errno; opaque friends<>; -} ; +}; struct gf1_cli_fsm_log_req { string name<>; @@ -191,7 +203,7 @@ struct gf1_cli_fsm_log_rsp { struct gf1_cli_getwd_req { int unused; -} ; +}; struct gf1_cli_getwd_rsp { int op_ret; diff --git a/rpc/xdr/src/glusterd1-xdr.c b/rpc/xdr/src/glusterd1-xdr.c deleted file mode 100644 index 7fa98aaeb..000000000 --- a/rpc/xdr/src/glusterd1-xdr.c +++ /dev/null @@ -1,923 +0,0 @@ -/* - Copyright (c) 2007-2012 Red Hat, Inc. - This file is part of GlusterFS. - - This file is licensed to you under your choice of the GNU Lesser - General Public License, version 3 or any later version (LGPLv3 or - later), or the GNU General Public License, version 2 (GPLv2), in all - cases as published by the Free Software Foundation. -*/ - -#include "xdr-common.h" -#include "compat.h" - -#if defined(__GNUC__) -#if __GNUC__ >= 4 -#pragma GCC diagnostic ignored "-Wunused-but-set-variable" -#endif -#endif - -/* - * Please do not edit this file. - * It was generated using rpcgen. - */ - -#include "glusterd1-xdr.h" - -bool_t -xdr_glusterd_volume_status (XDR *xdrs, glusterd_volume_status *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_enum (xdrs, (enum_t *) objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gd1_mgmt_probe_req (XDR *xdrs, gd1_mgmt_probe_req *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_vector (xdrs, (char *)objp->uuid, 16, - sizeof (u_char), (xdrproc_t) xdr_u_char)) - return FALSE; - if (!xdr_string (xdrs, &objp->hostname, ~0)) - return FALSE; - if (!xdr_int (xdrs, &objp->port)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gd1_mgmt_probe_rsp (XDR *xdrs, gd1_mgmt_probe_rsp *objp) -{ - register int32_t *buf; - buf = NULL; - - - if (xdrs->x_op == XDR_ENCODE) { - if (!xdr_vector (xdrs, (char *)objp->uuid, 16, - sizeof (u_char), (xdrproc_t) xdr_u_char)) - return FALSE; - if (!xdr_string (xdrs, &objp->hostname, ~0)) - return FALSE; - buf = XDR_INLINE (xdrs, 3 * BYTES_PER_XDR_UNIT); - if (buf == NULL) { - if (!xdr_int (xdrs, &objp->port)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_ret)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_errno)) - return FALSE; - - } else { - IXDR_PUT_LONG(buf, objp->port); - IXDR_PUT_LONG(buf, objp->op_ret); - IXDR_PUT_LONG(buf, objp->op_errno); - } - if (!xdr_string (xdrs, &objp->op_errstr, ~0)) - return FALSE; - return TRUE; - } else if (xdrs->x_op == XDR_DECODE) { - if (!xdr_vector (xdrs, (char *)objp->uuid, 16, - sizeof (u_char), (xdrproc_t) xdr_u_char)) - return FALSE; - if (!xdr_string (xdrs, &objp->hostname, ~0)) - return FALSE; - buf = XDR_INLINE (xdrs, 3 * BYTES_PER_XDR_UNIT); - if (buf == NULL) { - if (!xdr_int (xdrs, &objp->port)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_ret)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_errno)) - return FALSE; - - } else { - objp->port = IXDR_GET_LONG(buf); - objp->op_ret = IXDR_GET_LONG(buf); - objp->op_errno = IXDR_GET_LONG(buf); - } - if (!xdr_string (xdrs, &objp->op_errstr, ~0)) - return FALSE; - return TRUE; - } - - if (!xdr_vector (xdrs, (char *)objp->uuid, 16, - sizeof (u_char), (xdrproc_t) xdr_u_char)) - return FALSE; - if (!xdr_string (xdrs, &objp->hostname, ~0)) - return FALSE; - if (!xdr_int (xdrs, &objp->port)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_ret)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_errno)) - return FALSE; - if (!xdr_string (xdrs, &objp->op_errstr, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gd1_mgmt_friend_req (XDR *xdrs, gd1_mgmt_friend_req *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_vector (xdrs, (char *)objp->uuid, 16, - sizeof (u_char), (xdrproc_t) xdr_u_char)) - return FALSE; - if (!xdr_string (xdrs, &objp->hostname, ~0)) - return FALSE; - if (!xdr_int (xdrs, &objp->port)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->vols.vols_val, (u_int *) &objp->vols.vols_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gd1_mgmt_friend_rsp (XDR *xdrs, gd1_mgmt_friend_rsp *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_vector (xdrs, (char *)objp->uuid, 16, - sizeof (u_char), (xdrproc_t) xdr_u_char)) - return FALSE; - if (!xdr_string (xdrs, &objp->hostname, ~0)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_ret)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_errno)) - return FALSE; - if (!xdr_int (xdrs, &objp->port)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gd1_mgmt_unfriend_req (XDR *xdrs, gd1_mgmt_unfriend_req *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_vector (xdrs, (char *)objp->uuid, 16, - sizeof (u_char), (xdrproc_t) xdr_u_char)) - return FALSE; - if (!xdr_string (xdrs, &objp->hostname, ~0)) - return FALSE; - if (!xdr_int (xdrs, &objp->port)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gd1_mgmt_unfriend_rsp (XDR *xdrs, gd1_mgmt_unfriend_rsp *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_vector (xdrs, (char *)objp->uuid, 16, - sizeof (u_char), (xdrproc_t) xdr_u_char)) - return FALSE; - if (!xdr_string (xdrs, &objp->hostname, ~0)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_ret)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_errno)) - return FALSE; - if (!xdr_int (xdrs, &objp->port)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gd1_mgmt_cluster_lock_req (XDR *xdrs, gd1_mgmt_cluster_lock_req *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_vector (xdrs, (char *)objp->uuid, 16, - sizeof (u_char), (xdrproc_t) xdr_u_char)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gd1_mgmt_cluster_lock_rsp (XDR *xdrs, gd1_mgmt_cluster_lock_rsp *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_vector (xdrs, (char *)objp->uuid, 16, - sizeof (u_char), (xdrproc_t) xdr_u_char)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_ret)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_errno)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gd1_mgmt_cluster_unlock_req (XDR *xdrs, gd1_mgmt_cluster_unlock_req *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_vector (xdrs, (char *)objp->uuid, 16, - sizeof (u_char), (xdrproc_t) xdr_u_char)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gd1_mgmt_cluster_unlock_rsp (XDR *xdrs, gd1_mgmt_cluster_unlock_rsp *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_vector (xdrs, (char *)objp->uuid, 16, - sizeof (u_char), (xdrproc_t) xdr_u_char)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_ret)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_errno)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gd1_mgmt_stage_op_req (XDR *xdrs, gd1_mgmt_stage_op_req *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_vector (xdrs, (char *)objp->uuid, 16, - sizeof (u_char), (xdrproc_t) xdr_u_char)) - return FALSE; - if (!xdr_int (xdrs, &objp->op)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->buf.buf_val, (u_int *) &objp->buf.buf_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gd1_mgmt_stage_op_rsp (XDR *xdrs, gd1_mgmt_stage_op_rsp *objp) -{ - register int32_t *buf; - buf = NULL; - - - if (xdrs->x_op == XDR_ENCODE) { - if (!xdr_vector (xdrs, (char *)objp->uuid, 16, - sizeof (u_char), (xdrproc_t) xdr_u_char)) - return FALSE; - buf = XDR_INLINE (xdrs, 3 * BYTES_PER_XDR_UNIT); - if (buf == NULL) { - if (!xdr_int (xdrs, &objp->op)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_ret)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_errno)) - return FALSE; - - } else { - IXDR_PUT_LONG(buf, objp->op); - IXDR_PUT_LONG(buf, objp->op_ret); - IXDR_PUT_LONG(buf, objp->op_errno); - } - if (!xdr_string (xdrs, &objp->op_errstr, ~0)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->dict.dict_val, (u_int *) &objp->dict.dict_len, ~0)) - return FALSE; - return TRUE; - } else if (xdrs->x_op == XDR_DECODE) { - if (!xdr_vector (xdrs, (char *)objp->uuid, 16, - sizeof (u_char), (xdrproc_t) xdr_u_char)) - return FALSE; - buf = XDR_INLINE (xdrs, 3 * BYTES_PER_XDR_UNIT); - if (buf == NULL) { - if (!xdr_int (xdrs, &objp->op)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_ret)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_errno)) - return FALSE; - - } else { - objp->op = IXDR_GET_LONG(buf); - objp->op_ret = IXDR_GET_LONG(buf); - objp->op_errno = IXDR_GET_LONG(buf); - } - if (!xdr_string (xdrs, &objp->op_errstr, ~0)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->dict.dict_val, (u_int *) &objp->dict.dict_len, ~0)) - return FALSE; - return TRUE; - } - - if (!xdr_vector (xdrs, (char *)objp->uuid, 16, - sizeof (u_char), (xdrproc_t) xdr_u_char)) - return FALSE; - if (!xdr_int (xdrs, &objp->op)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_ret)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_errno)) - return FALSE; - if (!xdr_string (xdrs, &objp->op_errstr, ~0)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->dict.dict_val, (u_int *) &objp->dict.dict_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gd1_mgmt_commit_op_req (XDR *xdrs, gd1_mgmt_commit_op_req *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_vector (xdrs, (char *)objp->uuid, 16, - sizeof (u_char), (xdrproc_t) xdr_u_char)) - return FALSE; - if (!xdr_int (xdrs, &objp->op)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->buf.buf_val, (u_int *) &objp->buf.buf_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gd1_mgmt_commit_op_rsp (XDR *xdrs, gd1_mgmt_commit_op_rsp *objp) -{ - register int32_t *buf; - buf = NULL; - - - if (xdrs->x_op == XDR_ENCODE) { - if (!xdr_vector (xdrs, (char *)objp->uuid, 16, - sizeof (u_char), (xdrproc_t) xdr_u_char)) - return FALSE; - buf = XDR_INLINE (xdrs, 3 * BYTES_PER_XDR_UNIT); - if (buf == NULL) { - if (!xdr_int (xdrs, &objp->op)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_ret)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_errno)) - return FALSE; - - } else { - IXDR_PUT_LONG(buf, objp->op); - IXDR_PUT_LONG(buf, objp->op_ret); - IXDR_PUT_LONG(buf, objp->op_errno); - } - if (!xdr_bytes (xdrs, (char **)&objp->dict.dict_val, (u_int *) &objp->dict.dict_len, ~0)) - return FALSE; - if (!xdr_string (xdrs, &objp->op_errstr, ~0)) - return FALSE; - return TRUE; - } else if (xdrs->x_op == XDR_DECODE) { - if (!xdr_vector (xdrs, (char *)objp->uuid, 16, - sizeof (u_char), (xdrproc_t) xdr_u_char)) - return FALSE; - buf = XDR_INLINE (xdrs, 3 * BYTES_PER_XDR_UNIT); - if (buf == NULL) { - if (!xdr_int (xdrs, &objp->op)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_ret)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_errno)) - return FALSE; - - } else { - objp->op = IXDR_GET_LONG(buf); - objp->op_ret = IXDR_GET_LONG(buf); - objp->op_errno = IXDR_GET_LONG(buf); - } - if (!xdr_bytes (xdrs, (char **)&objp->dict.dict_val, (u_int *) &objp->dict.dict_len, ~0)) - return FALSE; - if (!xdr_string (xdrs, &objp->op_errstr, ~0)) - return FALSE; - return TRUE; - } - - if (!xdr_vector (xdrs, (char *)objp->uuid, 16, - sizeof (u_char), (xdrproc_t) xdr_u_char)) - return FALSE; - if (!xdr_int (xdrs, &objp->op)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_ret)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_errno)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->dict.dict_val, (u_int *) &objp->dict.dict_len, ~0)) - return FALSE; - if (!xdr_string (xdrs, &objp->op_errstr, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gd1_mgmt_friend_update (XDR *xdrs, gd1_mgmt_friend_update *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_vector (xdrs, (char *)objp->uuid, 16, - sizeof (u_char), (xdrproc_t) xdr_u_char)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->friends.friends_val, (u_int *) &objp->friends.friends_len, ~0)) - return FALSE; - if (!xdr_int (xdrs, &objp->port)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gd1_mgmt_friend_update_rsp (XDR *xdrs, gd1_mgmt_friend_update_rsp *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_vector (xdrs, (char *)objp->uuid, 16, - sizeof (u_char), (xdrproc_t) xdr_u_char)) - return FALSE; - if (!xdr_int (xdrs, &objp->op)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_ret)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_errno)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gd1_mgmt_brick_op_req (XDR *xdrs, gd1_mgmt_brick_op_req *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_string (xdrs, &objp->name, ~0)) - return FALSE; - if (!xdr_int (xdrs, &objp->op)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->input.input_val, (u_int *) &objp->input.input_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gd1_mgmt_brick_op_rsp (XDR *xdrs, gd1_mgmt_brick_op_rsp *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_int (xdrs, &objp->op_ret)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_errno)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->output.output_val, (u_int *) &objp->output.output_len, ~0)) - return FALSE; - if (!xdr_string (xdrs, &objp->op_errstr, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gd1_mgmt_v3_lock_req (XDR *xdrs, gd1_mgmt_v3_lock_req *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_vector (xdrs, (char *)objp->uuid, 16, - sizeof (u_char), (xdrproc_t) xdr_u_char)) - return FALSE; - if (!xdr_vector (xdrs, (char *)objp->txn_id, 16, - sizeof (u_char), (xdrproc_t) xdr_u_char)) - return FALSE; - if (!xdr_int (xdrs, &objp->op)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->dict.dict_val, (u_int *) &objp->dict.dict_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gd1_mgmt_v3_lock_rsp (XDR *xdrs, gd1_mgmt_v3_lock_rsp *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_vector (xdrs, (char *)objp->uuid, 16, - sizeof (u_char), (xdrproc_t) xdr_u_char)) - return FALSE; - if (!xdr_vector (xdrs, (char *)objp->txn_id, 16, - sizeof (u_char), (xdrproc_t) xdr_u_char)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->dict.dict_val, (u_int *) &objp->dict.dict_len, ~0)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_ret)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_errno)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gd1_mgmt_v3_pre_val_req (XDR *xdrs, gd1_mgmt_v3_pre_val_req *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_vector (xdrs, (char *)objp->uuid, 16, - sizeof (u_char), (xdrproc_t) xdr_u_char)) - return FALSE; - if (!xdr_int (xdrs, &objp->op)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->dict.dict_val, (u_int *) &objp->dict.dict_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gd1_mgmt_v3_pre_val_rsp (XDR *xdrs, gd1_mgmt_v3_pre_val_rsp *objp) -{ - register int32_t *buf; - buf = NULL; - - - if (xdrs->x_op == XDR_ENCODE) { - if (!xdr_vector (xdrs, (char *)objp->uuid, 16, - sizeof (u_char), (xdrproc_t) xdr_u_char)) - return FALSE; - buf = XDR_INLINE (xdrs, 3 * BYTES_PER_XDR_UNIT); - if (buf == NULL) { - if (!xdr_int (xdrs, &objp->op)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_ret)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_errno)) - return FALSE; - - } else { - IXDR_PUT_LONG(buf, objp->op); - IXDR_PUT_LONG(buf, objp->op_ret); - IXDR_PUT_LONG(buf, objp->op_errno); - } - if (!xdr_string (xdrs, &objp->op_errstr, ~0)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->dict.dict_val, (u_int *) &objp->dict.dict_len, ~0)) - return FALSE; - return TRUE; - } else if (xdrs->x_op == XDR_DECODE) { - if (!xdr_vector (xdrs, (char *)objp->uuid, 16, - sizeof (u_char), (xdrproc_t) xdr_u_char)) - return FALSE; - buf = XDR_INLINE (xdrs, 3 * BYTES_PER_XDR_UNIT); - if (buf == NULL) { - if (!xdr_int (xdrs, &objp->op)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_ret)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_errno)) - return FALSE; - - } else { - objp->op = IXDR_GET_LONG(buf); - objp->op_ret = IXDR_GET_LONG(buf); - objp->op_errno = IXDR_GET_LONG(buf); - } - if (!xdr_string (xdrs, &objp->op_errstr, ~0)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->dict.dict_val, (u_int *) &objp->dict.dict_len, ~0)) - return FALSE; - return TRUE; - } - - if (!xdr_vector (xdrs, (char *)objp->uuid, 16, - sizeof (u_char), (xdrproc_t) xdr_u_char)) - return FALSE; - if (!xdr_int (xdrs, &objp->op)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_ret)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_errno)) - return FALSE; - if (!xdr_string (xdrs, &objp->op_errstr, ~0)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->dict.dict_val, (u_int *) &objp->dict.dict_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gd1_mgmt_v3_brick_op_req (XDR *xdrs, gd1_mgmt_v3_brick_op_req *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_vector (xdrs, (char *)objp->uuid, 16, - sizeof (u_char), (xdrproc_t) xdr_u_char)) - return FALSE; - if (!xdr_int (xdrs, &objp->op)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->dict.dict_val, (u_int *) &objp->dict.dict_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gd1_mgmt_v3_brick_op_rsp (XDR *xdrs, gd1_mgmt_v3_brick_op_rsp *objp) -{ - register int32_t *buf; - buf = NULL; - - - if (xdrs->x_op == XDR_ENCODE) { - if (!xdr_vector (xdrs, (char *)objp->uuid, 16, - sizeof (u_char), (xdrproc_t) xdr_u_char)) - return FALSE; - buf = XDR_INLINE (xdrs, 3 * BYTES_PER_XDR_UNIT); - if (buf == NULL) { - if (!xdr_int (xdrs, &objp->op)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_ret)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_errno)) - return FALSE; - - } else { - IXDR_PUT_LONG(buf, objp->op); - IXDR_PUT_LONG(buf, objp->op_ret); - IXDR_PUT_LONG(buf, objp->op_errno); - } - if (!xdr_string (xdrs, &objp->op_errstr, ~0)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->dict.dict_val, (u_int *) &objp->dict.dict_len, ~0)) - return FALSE; - return TRUE; - } else if (xdrs->x_op == XDR_DECODE) { - if (!xdr_vector (xdrs, (char *)objp->uuid, 16, - sizeof (u_char), (xdrproc_t) xdr_u_char)) - return FALSE; - buf = XDR_INLINE (xdrs, 3 * BYTES_PER_XDR_UNIT); - if (buf == NULL) { - if (!xdr_int (xdrs, &objp->op)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_ret)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_errno)) - return FALSE; - - } else { - objp->op = IXDR_GET_LONG(buf); - objp->op_ret = IXDR_GET_LONG(buf); - objp->op_errno = IXDR_GET_LONG(buf); - } - if (!xdr_string (xdrs, &objp->op_errstr, ~0)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->dict.dict_val, (u_int *) &objp->dict.dict_len, ~0)) - return FALSE; - return TRUE; - } - - if (!xdr_vector (xdrs, (char *)objp->uuid, 16, - sizeof (u_char), (xdrproc_t) xdr_u_char)) - return FALSE; - if (!xdr_int (xdrs, &objp->op)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_ret)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_errno)) - return FALSE; - if (!xdr_string (xdrs, &objp->op_errstr, ~0)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->dict.dict_val, (u_int *) &objp->dict.dict_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gd1_mgmt_v3_commit_req (XDR *xdrs, gd1_mgmt_v3_commit_req *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_vector (xdrs, (char *)objp->uuid, 16, - sizeof (u_char), (xdrproc_t) xdr_u_char)) - return FALSE; - if (!xdr_int (xdrs, &objp->op)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->dict.dict_val, (u_int *) &objp->dict.dict_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gd1_mgmt_v3_commit_rsp (XDR *xdrs, gd1_mgmt_v3_commit_rsp *objp) -{ - register int32_t *buf; - buf = NULL; - - - if (xdrs->x_op == XDR_ENCODE) { - if (!xdr_vector (xdrs, (char *)objp->uuid, 16, - sizeof (u_char), (xdrproc_t) xdr_u_char)) - return FALSE; - buf = XDR_INLINE (xdrs, 3 * BYTES_PER_XDR_UNIT); - if (buf == NULL) { - if (!xdr_int (xdrs, &objp->op)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_ret)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_errno)) - return FALSE; - - } else { - IXDR_PUT_LONG(buf, objp->op); - IXDR_PUT_LONG(buf, objp->op_ret); - IXDR_PUT_LONG(buf, objp->op_errno); - } - if (!xdr_bytes (xdrs, (char **)&objp->dict.dict_val, (u_int *) &objp->dict.dict_len, ~0)) - return FALSE; - if (!xdr_string (xdrs, &objp->op_errstr, ~0)) - return FALSE; - return TRUE; - } else if (xdrs->x_op == XDR_DECODE) { - if (!xdr_vector (xdrs, (char *)objp->uuid, 16, - sizeof (u_char), (xdrproc_t) xdr_u_char)) - return FALSE; - buf = XDR_INLINE (xdrs, 3 * BYTES_PER_XDR_UNIT); - if (buf == NULL) { - if (!xdr_int (xdrs, &objp->op)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_ret)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_errno)) - return FALSE; - - } else { - objp->op = IXDR_GET_LONG(buf); - objp->op_ret = IXDR_GET_LONG(buf); - objp->op_errno = IXDR_GET_LONG(buf); - } - if (!xdr_bytes (xdrs, (char **)&objp->dict.dict_val, (u_int *) &objp->dict.dict_len, ~0)) - return FALSE; - if (!xdr_string (xdrs, &objp->op_errstr, ~0)) - return FALSE; - return TRUE; - } - - if (!xdr_vector (xdrs, (char *)objp->uuid, 16, - sizeof (u_char), (xdrproc_t) xdr_u_char)) - return FALSE; - if (!xdr_int (xdrs, &objp->op)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_ret)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_errno)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->dict.dict_val, (u_int *) &objp->dict.dict_len, ~0)) - return FALSE; - if (!xdr_string (xdrs, &objp->op_errstr, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gd1_mgmt_v3_post_val_req (XDR *xdrs, gd1_mgmt_v3_post_val_req *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_vector (xdrs, (char *)objp->uuid, 16, - sizeof (u_char), (xdrproc_t) xdr_u_char)) - return FALSE; - if (!xdr_int (xdrs, &objp->op)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_ret)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->dict.dict_val, (u_int *) &objp->dict.dict_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gd1_mgmt_v3_post_val_rsp (XDR *xdrs, gd1_mgmt_v3_post_val_rsp *objp) -{ - register int32_t *buf; - buf = NULL; - - - if (xdrs->x_op == XDR_ENCODE) { - if (!xdr_vector (xdrs, (char *)objp->uuid, 16, - sizeof (u_char), (xdrproc_t) xdr_u_char)) - return FALSE; - buf = XDR_INLINE (xdrs, 3 * BYTES_PER_XDR_UNIT); - if (buf == NULL) { - if (!xdr_int (xdrs, &objp->op)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_ret)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_errno)) - return FALSE; - - } else { - IXDR_PUT_LONG(buf, objp->op); - IXDR_PUT_LONG(buf, objp->op_ret); - IXDR_PUT_LONG(buf, objp->op_errno); - } - if (!xdr_string (xdrs, &objp->op_errstr, ~0)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->dict.dict_val, (u_int *) &objp->dict.dict_len, ~0)) - return FALSE; - return TRUE; - } else if (xdrs->x_op == XDR_DECODE) { - if (!xdr_vector (xdrs, (char *)objp->uuid, 16, - sizeof (u_char), (xdrproc_t) xdr_u_char)) - return FALSE; - buf = XDR_INLINE (xdrs, 3 * BYTES_PER_XDR_UNIT); - if (buf == NULL) { - if (!xdr_int (xdrs, &objp->op)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_ret)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_errno)) - return FALSE; - - } else { - objp->op = IXDR_GET_LONG(buf); - objp->op_ret = IXDR_GET_LONG(buf); - objp->op_errno = IXDR_GET_LONG(buf); - } - if (!xdr_string (xdrs, &objp->op_errstr, ~0)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->dict.dict_val, (u_int *) &objp->dict.dict_len, ~0)) - return FALSE; - return TRUE; - } - - if (!xdr_vector (xdrs, (char *)objp->uuid, 16, - sizeof (u_char), (xdrproc_t) xdr_u_char)) - return FALSE; - if (!xdr_int (xdrs, &objp->op)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_ret)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_errno)) - return FALSE; - if (!xdr_string (xdrs, &objp->op_errstr, ~0)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->dict.dict_val, (u_int *) &objp->dict.dict_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gd1_mgmt_v3_unlock_req (XDR *xdrs, gd1_mgmt_v3_unlock_req *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_vector (xdrs, (char *)objp->uuid, 16, - sizeof (u_char), (xdrproc_t) xdr_u_char)) - return FALSE; - if (!xdr_vector (xdrs, (char *)objp->txn_id, 16, - sizeof (u_char), (xdrproc_t) xdr_u_char)) - return FALSE; - if (!xdr_int (xdrs, &objp->op)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->dict.dict_val, (u_int *) &objp->dict.dict_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gd1_mgmt_v3_unlock_rsp (XDR *xdrs, gd1_mgmt_v3_unlock_rsp *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_vector (xdrs, (char *)objp->uuid, 16, - sizeof (u_char), (xdrproc_t) xdr_u_char)) - return FALSE; - if (!xdr_vector (xdrs, (char *)objp->txn_id, 16, - sizeof (u_char), (xdrproc_t) xdr_u_char)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->dict.dict_val, (u_int *) &objp->dict.dict_len, ~0)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_ret)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_errno)) - return FALSE; - return TRUE; -} diff --git a/rpc/xdr/src/glusterd1-xdr.h b/rpc/xdr/src/glusterd1-xdr.h deleted file mode 100644 index b6be23d06..000000000 --- a/rpc/xdr/src/glusterd1-xdr.h +++ /dev/null @@ -1,418 +0,0 @@ -/* - Copyright (c) 2007-2012 Red Hat, Inc. - This file is part of GlusterFS. - - This file is licensed to you under your choice of the GNU Lesser - General Public License, version 3 or any later version (LGPLv3 or - later), or the GNU General Public License, version 2 (GPLv2), in all - cases as published by the Free Software Foundation. -*/ - -#include "xdr-common.h" -#include "compat.h" - -#if defined(__GNUC__) -#if __GNUC__ >= 4 -#pragma GCC diagnostic ignored "-Wunused-but-set-variable" -#endif -#endif - -/* - * Please do not edit this file. - * It was generated using rpcgen. - */ - -#ifndef _GLUSTERD1_XDR_H_RPCGEN -#define _GLUSTERD1_XDR_H_RPCGEN - -#include - - -#ifdef __cplusplus -extern "C" { -#endif - - -enum glusterd_volume_status { - GLUSTERD_STATUS_NONE = 0, - GLUSTERD_STATUS_STARTED = 0 + 1, - GLUSTERD_STATUS_STOPPED = 0 + 2, -}; -typedef enum glusterd_volume_status glusterd_volume_status; - -struct gd1_mgmt_probe_req { - u_char uuid[16]; - char *hostname; - int port; -}; -typedef struct gd1_mgmt_probe_req gd1_mgmt_probe_req; - -struct gd1_mgmt_probe_rsp { - u_char uuid[16]; - char *hostname; - int port; - int op_ret; - int op_errno; - char *op_errstr; -}; -typedef struct gd1_mgmt_probe_rsp gd1_mgmt_probe_rsp; - -struct gd1_mgmt_friend_req { - u_char uuid[16]; - char *hostname; - int port; - struct { - u_int vols_len; - char *vols_val; - } vols; -}; -typedef struct gd1_mgmt_friend_req gd1_mgmt_friend_req; - -struct gd1_mgmt_friend_rsp { - u_char uuid[16]; - char *hostname; - int op_ret; - int op_errno; - int port; -}; -typedef struct gd1_mgmt_friend_rsp gd1_mgmt_friend_rsp; - -struct gd1_mgmt_unfriend_req { - u_char uuid[16]; - char *hostname; - int port; -}; -typedef struct gd1_mgmt_unfriend_req gd1_mgmt_unfriend_req; - -struct gd1_mgmt_unfriend_rsp { - u_char uuid[16]; - char *hostname; - int op_ret; - int op_errno; - int port; -}; -typedef struct gd1_mgmt_unfriend_rsp gd1_mgmt_unfriend_rsp; - -struct gd1_mgmt_cluster_lock_req { - u_char uuid[16]; -}; -typedef struct gd1_mgmt_cluster_lock_req gd1_mgmt_cluster_lock_req; - -struct gd1_mgmt_cluster_lock_rsp { - u_char uuid[16]; - int op_ret; - int op_errno; -}; -typedef struct gd1_mgmt_cluster_lock_rsp gd1_mgmt_cluster_lock_rsp; - -struct gd1_mgmt_cluster_unlock_req { - u_char uuid[16]; -}; -typedef struct gd1_mgmt_cluster_unlock_req gd1_mgmt_cluster_unlock_req; - -struct gd1_mgmt_cluster_unlock_rsp { - u_char uuid[16]; - int op_ret; - int op_errno; -}; -typedef struct gd1_mgmt_cluster_unlock_rsp gd1_mgmt_cluster_unlock_rsp; - -struct gd1_mgmt_stage_op_req { - u_char uuid[16]; - int op; - struct { - u_int buf_len; - char *buf_val; - } buf; -}; -typedef struct gd1_mgmt_stage_op_req gd1_mgmt_stage_op_req; - -struct gd1_mgmt_stage_op_rsp { - u_char uuid[16]; - int op; - int op_ret; - int op_errno; - char *op_errstr; - struct { - u_int dict_len; - char *dict_val; - } dict; -}; -typedef struct gd1_mgmt_stage_op_rsp gd1_mgmt_stage_op_rsp; - -struct gd1_mgmt_commit_op_req { - u_char uuid[16]; - int op; - struct { - u_int buf_len; - char *buf_val; - } buf; -}; -typedef struct gd1_mgmt_commit_op_req gd1_mgmt_commit_op_req; - -struct gd1_mgmt_commit_op_rsp { - u_char uuid[16]; - int op; - int op_ret; - int op_errno; - struct { - u_int dict_len; - char *dict_val; - } dict; - char *op_errstr; -}; -typedef struct gd1_mgmt_commit_op_rsp gd1_mgmt_commit_op_rsp; - -struct gd1_mgmt_friend_update { - u_char uuid[16]; - struct { - u_int friends_len; - char *friends_val; - } friends; - int port; -}; -typedef struct gd1_mgmt_friend_update gd1_mgmt_friend_update; - -struct gd1_mgmt_friend_update_rsp { - u_char uuid[16]; - int op; - int op_ret; - int op_errno; -}; -typedef struct gd1_mgmt_friend_update_rsp gd1_mgmt_friend_update_rsp; - -struct gd1_mgmt_brick_op_req { - char *name; - int op; - struct { - u_int input_len; - char *input_val; - } input; -}; -typedef struct gd1_mgmt_brick_op_req gd1_mgmt_brick_op_req; - -struct gd1_mgmt_brick_op_rsp { - int op_ret; - int op_errno; - struct { - u_int output_len; - char *output_val; - } output; - char *op_errstr; -}; -typedef struct gd1_mgmt_brick_op_rsp gd1_mgmt_brick_op_rsp; - -struct gd1_mgmt_v3_lock_req { - u_char uuid[16]; - u_char txn_id[16]; - int op; - struct { - u_int dict_len; - char *dict_val; - } dict; -}; -typedef struct gd1_mgmt_v3_lock_req gd1_mgmt_v3_lock_req; - -struct gd1_mgmt_v3_lock_rsp { - u_char uuid[16]; - u_char txn_id[16]; - struct { - u_int dict_len; - char *dict_val; - } dict; - int op_ret; - int op_errno; -}; -typedef struct gd1_mgmt_v3_lock_rsp gd1_mgmt_v3_lock_rsp; - -struct gd1_mgmt_v3_pre_val_req { - u_char uuid[16]; - int op; - struct { - u_int dict_len; - char *dict_val; - } dict; -}; -typedef struct gd1_mgmt_v3_pre_val_req gd1_mgmt_v3_pre_val_req; - -struct gd1_mgmt_v3_pre_val_rsp { - u_char uuid[16]; - int op; - int op_ret; - int op_errno; - char *op_errstr; - struct { - u_int dict_len; - char *dict_val; - } dict; -}; -typedef struct gd1_mgmt_v3_pre_val_rsp gd1_mgmt_v3_pre_val_rsp; - -struct gd1_mgmt_v3_brick_op_req { - u_char uuid[16]; - int op; - struct { - u_int dict_len; - char *dict_val; - } dict; -}; -typedef struct gd1_mgmt_v3_brick_op_req gd1_mgmt_v3_brick_op_req; - -struct gd1_mgmt_v3_brick_op_rsp { - u_char uuid[16]; - int op; - int op_ret; - int op_errno; - char *op_errstr; - struct { - u_int dict_len; - char *dict_val; - } dict; -}; -typedef struct gd1_mgmt_v3_brick_op_rsp gd1_mgmt_v3_brick_op_rsp; - -struct gd1_mgmt_v3_commit_req { - u_char uuid[16]; - int op; - struct { - u_int dict_len; - char *dict_val; - } dict; -}; -typedef struct gd1_mgmt_v3_commit_req gd1_mgmt_v3_commit_req; - -struct gd1_mgmt_v3_commit_rsp { - u_char uuid[16]; - int op; - int op_ret; - int op_errno; - struct { - u_int dict_len; - char *dict_val; - } dict; - char *op_errstr; -}; -typedef struct gd1_mgmt_v3_commit_rsp gd1_mgmt_v3_commit_rsp; - -struct gd1_mgmt_v3_post_val_req { - u_char uuid[16]; - int op; - int op_ret; - struct { - u_int dict_len; - char *dict_val; - } dict; -}; -typedef struct gd1_mgmt_v3_post_val_req gd1_mgmt_v3_post_val_req; - -struct gd1_mgmt_v3_post_val_rsp { - u_char uuid[16]; - int op; - int op_ret; - int op_errno; - char *op_errstr; - struct { - u_int dict_len; - char *dict_val; - } dict; -}; -typedef struct gd1_mgmt_v3_post_val_rsp gd1_mgmt_v3_post_val_rsp; - -struct gd1_mgmt_v3_unlock_req { - u_char uuid[16]; - u_char txn_id[16]; - int op; - struct { - u_int dict_len; - char *dict_val; - } dict; -}; -typedef struct gd1_mgmt_v3_unlock_req gd1_mgmt_v3_unlock_req; - -struct gd1_mgmt_v3_unlock_rsp { - u_char uuid[16]; - u_char txn_id[16]; - struct { - u_int dict_len; - char *dict_val; - } dict; - int op_ret; - int op_errno; -}; -typedef struct gd1_mgmt_v3_unlock_rsp gd1_mgmt_v3_unlock_rsp; - -/* the xdr functions */ - -#if defined(__STDC__) || defined(__cplusplus) -extern bool_t xdr_glusterd_volume_status (XDR *, glusterd_volume_status*); -extern bool_t xdr_gd1_mgmt_probe_req (XDR *, gd1_mgmt_probe_req*); -extern bool_t xdr_gd1_mgmt_probe_rsp (XDR *, gd1_mgmt_probe_rsp*); -extern bool_t xdr_gd1_mgmt_friend_req (XDR *, gd1_mgmt_friend_req*); -extern bool_t xdr_gd1_mgmt_friend_rsp (XDR *, gd1_mgmt_friend_rsp*); -extern bool_t xdr_gd1_mgmt_unfriend_req (XDR *, gd1_mgmt_unfriend_req*); -extern bool_t xdr_gd1_mgmt_unfriend_rsp (XDR *, gd1_mgmt_unfriend_rsp*); -extern bool_t xdr_gd1_mgmt_cluster_lock_req (XDR *, gd1_mgmt_cluster_lock_req*); -extern bool_t xdr_gd1_mgmt_cluster_lock_rsp (XDR *, gd1_mgmt_cluster_lock_rsp*); -extern bool_t xdr_gd1_mgmt_cluster_unlock_req (XDR *, gd1_mgmt_cluster_unlock_req*); -extern bool_t xdr_gd1_mgmt_cluster_unlock_rsp (XDR *, gd1_mgmt_cluster_unlock_rsp*); -extern bool_t xdr_gd1_mgmt_stage_op_req (XDR *, gd1_mgmt_stage_op_req*); -extern bool_t xdr_gd1_mgmt_stage_op_rsp (XDR *, gd1_mgmt_stage_op_rsp*); -extern bool_t xdr_gd1_mgmt_commit_op_req (XDR *, gd1_mgmt_commit_op_req*); -extern bool_t xdr_gd1_mgmt_commit_op_rsp (XDR *, gd1_mgmt_commit_op_rsp*); -extern bool_t xdr_gd1_mgmt_friend_update (XDR *, gd1_mgmt_friend_update*); -extern bool_t xdr_gd1_mgmt_friend_update_rsp (XDR *, gd1_mgmt_friend_update_rsp*); -extern bool_t xdr_gd1_mgmt_brick_op_req (XDR *, gd1_mgmt_brick_op_req*); -extern bool_t xdr_gd1_mgmt_brick_op_rsp (XDR *, gd1_mgmt_brick_op_rsp*); -extern bool_t xdr_gd1_mgmt_v3_lock_req (XDR *, gd1_mgmt_v3_lock_req*); -extern bool_t xdr_gd1_mgmt_v3_lock_rsp (XDR *, gd1_mgmt_v3_lock_rsp*); -extern bool_t xdr_gd1_mgmt_v3_pre_val_req (XDR *, gd1_mgmt_v3_pre_val_req*); -extern bool_t xdr_gd1_mgmt_v3_pre_val_rsp (XDR *, gd1_mgmt_v3_pre_val_rsp*); -extern bool_t xdr_gd1_mgmt_v3_brick_op_req (XDR *, gd1_mgmt_v3_brick_op_req*); -extern bool_t xdr_gd1_mgmt_v3_brick_op_rsp (XDR *, gd1_mgmt_v3_brick_op_rsp*); -extern bool_t xdr_gd1_mgmt_v3_commit_req (XDR *, gd1_mgmt_v3_commit_req*); -extern bool_t xdr_gd1_mgmt_v3_commit_rsp (XDR *, gd1_mgmt_v3_commit_rsp*); -extern bool_t xdr_gd1_mgmt_v3_post_val_req (XDR *, gd1_mgmt_v3_post_val_req*); -extern bool_t xdr_gd1_mgmt_v3_post_val_rsp (XDR *, gd1_mgmt_v3_post_val_rsp*); -extern bool_t xdr_gd1_mgmt_v3_unlock_req (XDR *, gd1_mgmt_v3_unlock_req*); -extern bool_t xdr_gd1_mgmt_v3_unlock_rsp (XDR *, gd1_mgmt_v3_unlock_rsp*); - -#else /* K&R C */ -extern bool_t xdr_glusterd_volume_status (); -extern bool_t xdr_gd1_mgmt_probe_req (); -extern bool_t xdr_gd1_mgmt_probe_rsp (); -extern bool_t xdr_gd1_mgmt_friend_req (); -extern bool_t xdr_gd1_mgmt_friend_rsp (); -extern bool_t xdr_gd1_mgmt_unfriend_req (); -extern bool_t xdr_gd1_mgmt_unfriend_rsp (); -extern bool_t xdr_gd1_mgmt_cluster_lock_req (); -extern bool_t xdr_gd1_mgmt_cluster_lock_rsp (); -extern bool_t xdr_gd1_mgmt_cluster_unlock_req (); -extern bool_t xdr_gd1_mgmt_cluster_unlock_rsp (); -extern bool_t xdr_gd1_mgmt_stage_op_req (); -extern bool_t xdr_gd1_mgmt_stage_op_rsp (); -extern bool_t xdr_gd1_mgmt_commit_op_req (); -extern bool_t xdr_gd1_mgmt_commit_op_rsp (); -extern bool_t xdr_gd1_mgmt_friend_update (); -extern bool_t xdr_gd1_mgmt_friend_update_rsp (); -extern bool_t xdr_gd1_mgmt_brick_op_req (); -extern bool_t xdr_gd1_mgmt_brick_op_rsp (); -extern bool_t xdr_gd1_mgmt_v3_lock_req (); -extern bool_t xdr_gd1_mgmt_v3_lock_rsp (); -extern bool_t xdr_gd1_mgmt_v3_pre_val_req (); -extern bool_t xdr_gd1_mgmt_v3_pre_val_rsp (); -extern bool_t xdr_gd1_mgmt_v3_brick_op_req (); -extern bool_t xdr_gd1_mgmt_v3_brick_op_rsp (); -extern bool_t xdr_gd1_mgmt_v3_commit_req (); -extern bool_t xdr_gd1_mgmt_v3_commit_rsp (); -extern bool_t xdr_gd1_mgmt_v3_post_val_req (); -extern bool_t xdr_gd1_mgmt_v3_post_val_rsp (); -extern bool_t xdr_gd1_mgmt_v3_unlock_req (); -extern bool_t xdr_gd1_mgmt_v3_unlock_rsp (); - -#endif /* K&R C */ - -#ifdef __cplusplus -} -#endif - -#endif /* !_GLUSTERD1_XDR_H_RPCGEN */ diff --git a/rpc/xdr/src/glusterfs3-xdr.c b/rpc/xdr/src/glusterfs3-xdr.c deleted file mode 100644 index 3205c551e..000000000 --- a/rpc/xdr/src/glusterfs3-xdr.c +++ /dev/null @@ -1,2058 +0,0 @@ -/* - Copyright (c) 2007-2012 Red Hat, Inc. - This file is part of GlusterFS. - - This file is licensed to you under your choice of the GNU Lesser - General Public License, version 3 or any later version (LGPLv3 or - later), or the GNU General Public License, version 2 (GPLv2), in all - cases as published by the Free Software Foundation. -*/ - -#include "xdr-common.h" -#include "compat.h" - -#if defined(__GNUC__) -#if __GNUC__ >= 4 -#pragma GCC diagnostic ignored "-Wunused-but-set-variable" -#endif -#endif - -/* - * Please do not edit this file. - * It was generated using rpcgen. - */ - -#include "glusterfs3-xdr.h" - -bool_t -xdr_gf_statfs (XDR *xdrs, gf_statfs *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_u_quad_t (xdrs, &objp->bsize)) - return FALSE; - if (!xdr_u_quad_t (xdrs, &objp->frsize)) - return FALSE; - if (!xdr_u_quad_t (xdrs, &objp->blocks)) - return FALSE; - if (!xdr_u_quad_t (xdrs, &objp->bfree)) - return FALSE; - if (!xdr_u_quad_t (xdrs, &objp->bavail)) - return FALSE; - if (!xdr_u_quad_t (xdrs, &objp->files)) - return FALSE; - if (!xdr_u_quad_t (xdrs, &objp->ffree)) - return FALSE; - if (!xdr_u_quad_t (xdrs, &objp->favail)) - return FALSE; - if (!xdr_u_quad_t (xdrs, &objp->fsid)) - return FALSE; - if (!xdr_u_quad_t (xdrs, &objp->flag)) - return FALSE; - if (!xdr_u_quad_t (xdrs, &objp->namemax)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gf_proto_flock (XDR *xdrs, gf_proto_flock *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_u_int (xdrs, &objp->type)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->whence)) - return FALSE; - if (!xdr_u_quad_t (xdrs, &objp->start)) - return FALSE; - if (!xdr_u_quad_t (xdrs, &objp->len)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->pid)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->lk_owner.lk_owner_val, (u_int *) &objp->lk_owner.lk_owner_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gf_iatt (XDR *xdrs, gf_iatt *objp) -{ - register int32_t *buf; - buf = NULL; - - - if (xdrs->x_op == XDR_ENCODE) { - if (!xdr_opaque (xdrs, objp->ia_gfid, 16)) - return FALSE; - if (!xdr_u_quad_t (xdrs, &objp->ia_ino)) - return FALSE; - if (!xdr_u_quad_t (xdrs, &objp->ia_dev)) - return FALSE; - buf = XDR_INLINE (xdrs, 4 * BYTES_PER_XDR_UNIT); - if (buf == NULL) { - if (!xdr_u_int (xdrs, &objp->mode)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->ia_nlink)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->ia_uid)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->ia_gid)) - return FALSE; - - } else { - IXDR_PUT_U_LONG(buf, objp->mode); - IXDR_PUT_U_LONG(buf, objp->ia_nlink); - IXDR_PUT_U_LONG(buf, objp->ia_uid); - IXDR_PUT_U_LONG(buf, objp->ia_gid); - } - if (!xdr_u_quad_t (xdrs, &objp->ia_rdev)) - return FALSE; - if (!xdr_u_quad_t (xdrs, &objp->ia_size)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->ia_blksize)) - return FALSE; - if (!xdr_u_quad_t (xdrs, &objp->ia_blocks)) - return FALSE; - buf = XDR_INLINE (xdrs, 6 * BYTES_PER_XDR_UNIT); - if (buf == NULL) { - if (!xdr_u_int (xdrs, &objp->ia_atime)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->ia_atime_nsec)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->ia_mtime)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->ia_mtime_nsec)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->ia_ctime)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->ia_ctime_nsec)) - return FALSE; - } else { - IXDR_PUT_U_LONG(buf, objp->ia_atime); - IXDR_PUT_U_LONG(buf, objp->ia_atime_nsec); - IXDR_PUT_U_LONG(buf, objp->ia_mtime); - IXDR_PUT_U_LONG(buf, objp->ia_mtime_nsec); - IXDR_PUT_U_LONG(buf, objp->ia_ctime); - IXDR_PUT_U_LONG(buf, objp->ia_ctime_nsec); - } - return TRUE; - } else if (xdrs->x_op == XDR_DECODE) { - if (!xdr_opaque (xdrs, objp->ia_gfid, 16)) - return FALSE; - if (!xdr_u_quad_t (xdrs, &objp->ia_ino)) - return FALSE; - if (!xdr_u_quad_t (xdrs, &objp->ia_dev)) - return FALSE; - buf = XDR_INLINE (xdrs, 4 * BYTES_PER_XDR_UNIT); - if (buf == NULL) { - if (!xdr_u_int (xdrs, &objp->mode)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->ia_nlink)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->ia_uid)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->ia_gid)) - return FALSE; - - } else { - objp->mode = IXDR_GET_U_LONG(buf); - objp->ia_nlink = IXDR_GET_U_LONG(buf); - objp->ia_uid = IXDR_GET_U_LONG(buf); - objp->ia_gid = IXDR_GET_U_LONG(buf); - } - if (!xdr_u_quad_t (xdrs, &objp->ia_rdev)) - return FALSE; - if (!xdr_u_quad_t (xdrs, &objp->ia_size)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->ia_blksize)) - return FALSE; - if (!xdr_u_quad_t (xdrs, &objp->ia_blocks)) - return FALSE; - buf = XDR_INLINE (xdrs, 6 * BYTES_PER_XDR_UNIT); - if (buf == NULL) { - if (!xdr_u_int (xdrs, &objp->ia_atime)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->ia_atime_nsec)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->ia_mtime)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->ia_mtime_nsec)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->ia_ctime)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->ia_ctime_nsec)) - return FALSE; - } else { - objp->ia_atime = IXDR_GET_U_LONG(buf); - objp->ia_atime_nsec = IXDR_GET_U_LONG(buf); - objp->ia_mtime = IXDR_GET_U_LONG(buf); - objp->ia_mtime_nsec = IXDR_GET_U_LONG(buf); - objp->ia_ctime = IXDR_GET_U_LONG(buf); - objp->ia_ctime_nsec = IXDR_GET_U_LONG(buf); - } - return TRUE; - } - - if (!xdr_opaque (xdrs, objp->ia_gfid, 16)) - return FALSE; - if (!xdr_u_quad_t (xdrs, &objp->ia_ino)) - return FALSE; - if (!xdr_u_quad_t (xdrs, &objp->ia_dev)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->mode)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->ia_nlink)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->ia_uid)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->ia_gid)) - return FALSE; - if (!xdr_u_quad_t (xdrs, &objp->ia_rdev)) - return FALSE; - if (!xdr_u_quad_t (xdrs, &objp->ia_size)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->ia_blksize)) - return FALSE; - if (!xdr_u_quad_t (xdrs, &objp->ia_blocks)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->ia_atime)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->ia_atime_nsec)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->ia_mtime)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->ia_mtime_nsec)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->ia_ctime)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->ia_ctime_nsec)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gfs3_stat_req (XDR *xdrs, gfs3_stat_req *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_opaque (xdrs, objp->gfid, 16)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->xdata.xdata_val, (u_int *) &objp->xdata.xdata_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gfs3_stat_rsp (XDR *xdrs, gfs3_stat_rsp *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_int (xdrs, &objp->op_ret)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_errno)) - return FALSE; - if (!xdr_gf_iatt (xdrs, &objp->stat)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->xdata.xdata_val, (u_int *) &objp->xdata.xdata_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gfs3_readlink_req (XDR *xdrs, gfs3_readlink_req *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_opaque (xdrs, objp->gfid, 16)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->size)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->xdata.xdata_val, (u_int *) &objp->xdata.xdata_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gfs3_readlink_rsp (XDR *xdrs, gfs3_readlink_rsp *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_int (xdrs, &objp->op_ret)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_errno)) - return FALSE; - if (!xdr_gf_iatt (xdrs, &objp->buf)) - return FALSE; - if (!xdr_string (xdrs, &objp->path, ~0)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->xdata.xdata_val, (u_int *) &objp->xdata.xdata_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gfs3_mknod_req (XDR *xdrs, gfs3_mknod_req *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_opaque (xdrs, objp->pargfid, 16)) - return FALSE; - if (!xdr_u_quad_t (xdrs, &objp->dev)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->mode)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->umask)) - return FALSE; - if (!xdr_string (xdrs, &objp->bname, ~0)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->xdata.xdata_val, (u_int *) &objp->xdata.xdata_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gfs3_mknod_rsp (XDR *xdrs, gfs3_mknod_rsp *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_int (xdrs, &objp->op_ret)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_errno)) - return FALSE; - if (!xdr_gf_iatt (xdrs, &objp->stat)) - return FALSE; - if (!xdr_gf_iatt (xdrs, &objp->preparent)) - return FALSE; - if (!xdr_gf_iatt (xdrs, &objp->postparent)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->xdata.xdata_val, (u_int *) &objp->xdata.xdata_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gfs3_mkdir_req (XDR *xdrs, gfs3_mkdir_req *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_opaque (xdrs, objp->pargfid, 16)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->mode)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->umask)) - return FALSE; - if (!xdr_string (xdrs, &objp->bname, ~0)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->xdata.xdata_val, (u_int *) &objp->xdata.xdata_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gfs3_mkdir_rsp (XDR *xdrs, gfs3_mkdir_rsp *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_int (xdrs, &objp->op_ret)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_errno)) - return FALSE; - if (!xdr_gf_iatt (xdrs, &objp->stat)) - return FALSE; - if (!xdr_gf_iatt (xdrs, &objp->preparent)) - return FALSE; - if (!xdr_gf_iatt (xdrs, &objp->postparent)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->xdata.xdata_val, (u_int *) &objp->xdata.xdata_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gfs3_unlink_req (XDR *xdrs, gfs3_unlink_req *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_opaque (xdrs, objp->pargfid, 16)) - return FALSE; - if (!xdr_string (xdrs, &objp->bname, ~0)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->xflags)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->xdata.xdata_val, (u_int *) &objp->xdata.xdata_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gfs3_unlink_rsp (XDR *xdrs, gfs3_unlink_rsp *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_int (xdrs, &objp->op_ret)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_errno)) - return FALSE; - if (!xdr_gf_iatt (xdrs, &objp->preparent)) - return FALSE; - if (!xdr_gf_iatt (xdrs, &objp->postparent)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->xdata.xdata_val, (u_int *) &objp->xdata.xdata_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gfs3_rmdir_req (XDR *xdrs, gfs3_rmdir_req *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_opaque (xdrs, objp->pargfid, 16)) - return FALSE; - if (!xdr_int (xdrs, &objp->xflags)) - return FALSE; - if (!xdr_string (xdrs, &objp->bname, ~0)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->xdata.xdata_val, (u_int *) &objp->xdata.xdata_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gfs3_rmdir_rsp (XDR *xdrs, gfs3_rmdir_rsp *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_int (xdrs, &objp->op_ret)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_errno)) - return FALSE; - if (!xdr_gf_iatt (xdrs, &objp->preparent)) - return FALSE; - if (!xdr_gf_iatt (xdrs, &objp->postparent)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->xdata.xdata_val, (u_int *) &objp->xdata.xdata_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gfs3_symlink_req (XDR *xdrs, gfs3_symlink_req *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_opaque (xdrs, objp->pargfid, 16)) - return FALSE; - if (!xdr_string (xdrs, &objp->bname, ~0)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->umask)) - return FALSE; - if (!xdr_string (xdrs, &objp->linkname, ~0)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->xdata.xdata_val, (u_int *) &objp->xdata.xdata_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gfs3_symlink_rsp (XDR *xdrs, gfs3_symlink_rsp *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_int (xdrs, &objp->op_ret)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_errno)) - return FALSE; - if (!xdr_gf_iatt (xdrs, &objp->stat)) - return FALSE; - if (!xdr_gf_iatt (xdrs, &objp->preparent)) - return FALSE; - if (!xdr_gf_iatt (xdrs, &objp->postparent)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->xdata.xdata_val, (u_int *) &objp->xdata.xdata_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gfs3_rename_req (XDR *xdrs, gfs3_rename_req *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_opaque (xdrs, objp->oldgfid, 16)) - return FALSE; - if (!xdr_opaque (xdrs, objp->newgfid, 16)) - return FALSE; - if (!xdr_string (xdrs, &objp->oldbname, ~0)) - return FALSE; - if (!xdr_string (xdrs, &objp->newbname, ~0)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->xdata.xdata_val, (u_int *) &objp->xdata.xdata_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gfs3_rename_rsp (XDR *xdrs, gfs3_rename_rsp *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_int (xdrs, &objp->op_ret)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_errno)) - return FALSE; - if (!xdr_gf_iatt (xdrs, &objp->stat)) - return FALSE; - if (!xdr_gf_iatt (xdrs, &objp->preoldparent)) - return FALSE; - if (!xdr_gf_iatt (xdrs, &objp->postoldparent)) - return FALSE; - if (!xdr_gf_iatt (xdrs, &objp->prenewparent)) - return FALSE; - if (!xdr_gf_iatt (xdrs, &objp->postnewparent)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->xdata.xdata_val, (u_int *) &objp->xdata.xdata_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gfs3_link_req (XDR *xdrs, gfs3_link_req *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_opaque (xdrs, objp->oldgfid, 16)) - return FALSE; - if (!xdr_opaque (xdrs, objp->newgfid, 16)) - return FALSE; - if (!xdr_string (xdrs, &objp->newbname, ~0)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->xdata.xdata_val, (u_int *) &objp->xdata.xdata_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gfs3_link_rsp (XDR *xdrs, gfs3_link_rsp *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_int (xdrs, &objp->op_ret)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_errno)) - return FALSE; - if (!xdr_gf_iatt (xdrs, &objp->stat)) - return FALSE; - if (!xdr_gf_iatt (xdrs, &objp->preparent)) - return FALSE; - if (!xdr_gf_iatt (xdrs, &objp->postparent)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->xdata.xdata_val, (u_int *) &objp->xdata.xdata_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gfs3_truncate_req (XDR *xdrs, gfs3_truncate_req *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_opaque (xdrs, objp->gfid, 16)) - return FALSE; - if (!xdr_u_quad_t (xdrs, &objp->offset)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->xdata.xdata_val, (u_int *) &objp->xdata.xdata_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gfs3_truncate_rsp (XDR *xdrs, gfs3_truncate_rsp *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_int (xdrs, &objp->op_ret)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_errno)) - return FALSE; - if (!xdr_gf_iatt (xdrs, &objp->prestat)) - return FALSE; - if (!xdr_gf_iatt (xdrs, &objp->poststat)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->xdata.xdata_val, (u_int *) &objp->xdata.xdata_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gfs3_open_req (XDR *xdrs, gfs3_open_req *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_opaque (xdrs, objp->gfid, 16)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->flags)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->xdata.xdata_val, (u_int *) &objp->xdata.xdata_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gfs3_open_rsp (XDR *xdrs, gfs3_open_rsp *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_int (xdrs, &objp->op_ret)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_errno)) - return FALSE; - if (!xdr_quad_t (xdrs, &objp->fd)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->xdata.xdata_val, (u_int *) &objp->xdata.xdata_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gfs3_read_req (XDR *xdrs, gfs3_read_req *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_opaque (xdrs, objp->gfid, 16)) - return FALSE; - if (!xdr_quad_t (xdrs, &objp->fd)) - return FALSE; - if (!xdr_u_quad_t (xdrs, &objp->offset)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->size)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->flag)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->xdata.xdata_val, (u_int *) &objp->xdata.xdata_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gfs3_read_rsp (XDR *xdrs, gfs3_read_rsp *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_int (xdrs, &objp->op_ret)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_errno)) - return FALSE; - if (!xdr_gf_iatt (xdrs, &objp->stat)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->size)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->xdata.xdata_val, (u_int *) &objp->xdata.xdata_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gfs3_lookup_req (XDR *xdrs, gfs3_lookup_req *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_opaque (xdrs, objp->gfid, 16)) - return FALSE; - if (!xdr_opaque (xdrs, objp->pargfid, 16)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->flags)) - return FALSE; - if (!xdr_string (xdrs, &objp->bname, ~0)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->xdata.xdata_val, (u_int *) &objp->xdata.xdata_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gfs3_lookup_rsp (XDR *xdrs, gfs3_lookup_rsp *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_int (xdrs, &objp->op_ret)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_errno)) - return FALSE; - if (!xdr_gf_iatt (xdrs, &objp->stat)) - return FALSE; - if (!xdr_gf_iatt (xdrs, &objp->postparent)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->xdata.xdata_val, (u_int *) &objp->xdata.xdata_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gfs3_write_req (XDR *xdrs, gfs3_write_req *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_opaque (xdrs, objp->gfid, 16)) - return FALSE; - if (!xdr_quad_t (xdrs, &objp->fd)) - return FALSE; - if (!xdr_u_quad_t (xdrs, &objp->offset)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->size)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->flag)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->xdata.xdata_val, (u_int *) &objp->xdata.xdata_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gfs3_write_rsp (XDR *xdrs, gfs3_write_rsp *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_int (xdrs, &objp->op_ret)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_errno)) - return FALSE; - if (!xdr_gf_iatt (xdrs, &objp->prestat)) - return FALSE; - if (!xdr_gf_iatt (xdrs, &objp->poststat)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->xdata.xdata_val, (u_int *) &objp->xdata.xdata_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gfs3_statfs_req (XDR *xdrs, gfs3_statfs_req *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_opaque (xdrs, objp->gfid, 16)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->xdata.xdata_val, (u_int *) &objp->xdata.xdata_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gfs3_statfs_rsp (XDR *xdrs, gfs3_statfs_rsp *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_int (xdrs, &objp->op_ret)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_errno)) - return FALSE; - if (!xdr_gf_statfs (xdrs, &objp->statfs)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->xdata.xdata_val, (u_int *) &objp->xdata.xdata_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gfs3_lk_req (XDR *xdrs, gfs3_lk_req *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_opaque (xdrs, objp->gfid, 16)) - return FALSE; - if (!xdr_quad_t (xdrs, &objp->fd)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->cmd)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->type)) - return FALSE; - if (!xdr_gf_proto_flock (xdrs, &objp->flock)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->xdata.xdata_val, (u_int *) &objp->xdata.xdata_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gfs3_lk_rsp (XDR *xdrs, gfs3_lk_rsp *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_int (xdrs, &objp->op_ret)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_errno)) - return FALSE; - if (!xdr_gf_proto_flock (xdrs, &objp->flock)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->xdata.xdata_val, (u_int *) &objp->xdata.xdata_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gfs3_inodelk_req (XDR *xdrs, gfs3_inodelk_req *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_opaque (xdrs, objp->gfid, 16)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->cmd)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->type)) - return FALSE; - if (!xdr_gf_proto_flock (xdrs, &objp->flock)) - return FALSE; - if (!xdr_string (xdrs, &objp->volume, ~0)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->xdata.xdata_val, (u_int *) &objp->xdata.xdata_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gfs3_finodelk_req (XDR *xdrs, gfs3_finodelk_req *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_opaque (xdrs, objp->gfid, 16)) - return FALSE; - if (!xdr_quad_t (xdrs, &objp->fd)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->cmd)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->type)) - return FALSE; - if (!xdr_gf_proto_flock (xdrs, &objp->flock)) - return FALSE; - if (!xdr_string (xdrs, &objp->volume, ~0)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->xdata.xdata_val, (u_int *) &objp->xdata.xdata_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gfs3_flush_req (XDR *xdrs, gfs3_flush_req *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_opaque (xdrs, objp->gfid, 16)) - return FALSE; - if (!xdr_quad_t (xdrs, &objp->fd)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->xdata.xdata_val, (u_int *) &objp->xdata.xdata_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gfs3_fsync_req (XDR *xdrs, gfs3_fsync_req *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_opaque (xdrs, objp->gfid, 16)) - return FALSE; - if (!xdr_quad_t (xdrs, &objp->fd)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->data)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->xdata.xdata_val, (u_int *) &objp->xdata.xdata_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gfs3_fsync_rsp (XDR *xdrs, gfs3_fsync_rsp *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_int (xdrs, &objp->op_ret)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_errno)) - return FALSE; - if (!xdr_gf_iatt (xdrs, &objp->prestat)) - return FALSE; - if (!xdr_gf_iatt (xdrs, &objp->poststat)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->xdata.xdata_val, (u_int *) &objp->xdata.xdata_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gfs3_setxattr_req (XDR *xdrs, gfs3_setxattr_req *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_opaque (xdrs, objp->gfid, 16)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->flags)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->dict.dict_val, (u_int *) &objp->dict.dict_len, ~0)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->xdata.xdata_val, (u_int *) &objp->xdata.xdata_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gfs3_fsetxattr_req (XDR *xdrs, gfs3_fsetxattr_req *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_opaque (xdrs, objp->gfid, 16)) - return FALSE; - if (!xdr_quad_t (xdrs, &objp->fd)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->flags)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->dict.dict_val, (u_int *) &objp->dict.dict_len, ~0)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->xdata.xdata_val, (u_int *) &objp->xdata.xdata_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gfs3_xattrop_req (XDR *xdrs, gfs3_xattrop_req *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_opaque (xdrs, objp->gfid, 16)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->flags)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->dict.dict_val, (u_int *) &objp->dict.dict_len, ~0)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->xdata.xdata_val, (u_int *) &objp->xdata.xdata_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gfs3_xattrop_rsp (XDR *xdrs, gfs3_xattrop_rsp *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_int (xdrs, &objp->op_ret)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_errno)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->dict.dict_val, (u_int *) &objp->dict.dict_len, ~0)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->xdata.xdata_val, (u_int *) &objp->xdata.xdata_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gfs3_fxattrop_req (XDR *xdrs, gfs3_fxattrop_req *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_opaque (xdrs, objp->gfid, 16)) - return FALSE; - if (!xdr_quad_t (xdrs, &objp->fd)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->flags)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->dict.dict_val, (u_int *) &objp->dict.dict_len, ~0)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->xdata.xdata_val, (u_int *) &objp->xdata.xdata_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gfs3_fxattrop_rsp (XDR *xdrs, gfs3_fxattrop_rsp *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_int (xdrs, &objp->op_ret)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_errno)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->dict.dict_val, (u_int *) &objp->dict.dict_len, ~0)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->xdata.xdata_val, (u_int *) &objp->xdata.xdata_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gfs3_getxattr_req (XDR *xdrs, gfs3_getxattr_req *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_opaque (xdrs, objp->gfid, 16)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->namelen)) - return FALSE; - if (!xdr_string (xdrs, &objp->name, ~0)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->xdata.xdata_val, (u_int *) &objp->xdata.xdata_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gfs3_getxattr_rsp (XDR *xdrs, gfs3_getxattr_rsp *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_int (xdrs, &objp->op_ret)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_errno)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->dict.dict_val, (u_int *) &objp->dict.dict_len, ~0)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->xdata.xdata_val, (u_int *) &objp->xdata.xdata_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gfs3_fgetxattr_req (XDR *xdrs, gfs3_fgetxattr_req *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_opaque (xdrs, objp->gfid, 16)) - return FALSE; - if (!xdr_quad_t (xdrs, &objp->fd)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->namelen)) - return FALSE; - if (!xdr_string (xdrs, &objp->name, ~0)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->xdata.xdata_val, (u_int *) &objp->xdata.xdata_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gfs3_fgetxattr_rsp (XDR *xdrs, gfs3_fgetxattr_rsp *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_int (xdrs, &objp->op_ret)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_errno)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->dict.dict_val, (u_int *) &objp->dict.dict_len, ~0)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->xdata.xdata_val, (u_int *) &objp->xdata.xdata_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gfs3_removexattr_req (XDR *xdrs, gfs3_removexattr_req *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_opaque (xdrs, objp->gfid, 16)) - return FALSE; - if (!xdr_string (xdrs, &objp->name, ~0)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->xdata.xdata_val, (u_int *) &objp->xdata.xdata_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gfs3_fremovexattr_req (XDR *xdrs, gfs3_fremovexattr_req *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_opaque (xdrs, objp->gfid, 16)) - return FALSE; - if (!xdr_quad_t (xdrs, &objp->fd)) - return FALSE; - if (!xdr_string (xdrs, &objp->name, ~0)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->xdata.xdata_val, (u_int *) &objp->xdata.xdata_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gfs3_opendir_req (XDR *xdrs, gfs3_opendir_req *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_opaque (xdrs, objp->gfid, 16)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->xdata.xdata_val, (u_int *) &objp->xdata.xdata_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gfs3_opendir_rsp (XDR *xdrs, gfs3_opendir_rsp *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_int (xdrs, &objp->op_ret)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_errno)) - return FALSE; - if (!xdr_quad_t (xdrs, &objp->fd)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->xdata.xdata_val, (u_int *) &objp->xdata.xdata_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gfs3_fsyncdir_req (XDR *xdrs, gfs3_fsyncdir_req *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_opaque (xdrs, objp->gfid, 16)) - return FALSE; - if (!xdr_quad_t (xdrs, &objp->fd)) - return FALSE; - if (!xdr_int (xdrs, &objp->data)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->xdata.xdata_val, (u_int *) &objp->xdata.xdata_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gfs3_readdir_req (XDR *xdrs, gfs3_readdir_req *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_opaque (xdrs, objp->gfid, 16)) - return FALSE; - if (!xdr_quad_t (xdrs, &objp->fd)) - return FALSE; - if (!xdr_u_quad_t (xdrs, &objp->offset)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->size)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->xdata.xdata_val, (u_int *) &objp->xdata.xdata_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gfs3_readdirp_req (XDR *xdrs, gfs3_readdirp_req *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_opaque (xdrs, objp->gfid, 16)) - return FALSE; - if (!xdr_quad_t (xdrs, &objp->fd)) - return FALSE; - if (!xdr_u_quad_t (xdrs, &objp->offset)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->size)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->dict.dict_val, (u_int *) &objp->dict.dict_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gfs3_access_req (XDR *xdrs, gfs3_access_req *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_opaque (xdrs, objp->gfid, 16)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->mask)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->xdata.xdata_val, (u_int *) &objp->xdata.xdata_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gfs3_create_req (XDR *xdrs, gfs3_create_req *objp) -{ - register int32_t *buf; - buf = NULL; - - - if (xdrs->x_op == XDR_ENCODE) { - if (!xdr_opaque (xdrs, objp->pargfid, 16)) - return FALSE; - buf = XDR_INLINE (xdrs, 3 * BYTES_PER_XDR_UNIT); - if (buf == NULL) { - if (!xdr_u_int (xdrs, &objp->flags)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->mode)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->umask)) - return FALSE; - - } else { - IXDR_PUT_U_LONG(buf, objp->flags); - IXDR_PUT_U_LONG(buf, objp->mode); - IXDR_PUT_U_LONG(buf, objp->umask); - } - if (!xdr_string (xdrs, &objp->bname, ~0)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->xdata.xdata_val, (u_int *) &objp->xdata.xdata_len, ~0)) - return FALSE; - return TRUE; - } else if (xdrs->x_op == XDR_DECODE) { - if (!xdr_opaque (xdrs, objp->pargfid, 16)) - return FALSE; - buf = XDR_INLINE (xdrs, 3 * BYTES_PER_XDR_UNIT); - if (buf == NULL) { - if (!xdr_u_int (xdrs, &objp->flags)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->mode)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->umask)) - return FALSE; - - } else { - objp->flags = IXDR_GET_U_LONG(buf); - objp->mode = IXDR_GET_U_LONG(buf); - objp->umask = IXDR_GET_U_LONG(buf); - } - if (!xdr_string (xdrs, &objp->bname, ~0)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->xdata.xdata_val, (u_int *) &objp->xdata.xdata_len, ~0)) - return FALSE; - return TRUE; - } - - if (!xdr_opaque (xdrs, objp->pargfid, 16)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->flags)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->mode)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->umask)) - return FALSE; - if (!xdr_string (xdrs, &objp->bname, ~0)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->xdata.xdata_val, (u_int *) &objp->xdata.xdata_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gfs3_create_rsp (XDR *xdrs, gfs3_create_rsp *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_int (xdrs, &objp->op_ret)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_errno)) - return FALSE; - if (!xdr_gf_iatt (xdrs, &objp->stat)) - return FALSE; - if (!xdr_u_quad_t (xdrs, &objp->fd)) - return FALSE; - if (!xdr_gf_iatt (xdrs, &objp->preparent)) - return FALSE; - if (!xdr_gf_iatt (xdrs, &objp->postparent)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->xdata.xdata_val, (u_int *) &objp->xdata.xdata_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gfs3_ftruncate_req (XDR *xdrs, gfs3_ftruncate_req *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_opaque (xdrs, objp->gfid, 16)) - return FALSE; - if (!xdr_quad_t (xdrs, &objp->fd)) - return FALSE; - if (!xdr_u_quad_t (xdrs, &objp->offset)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->xdata.xdata_val, (u_int *) &objp->xdata.xdata_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gfs3_ftruncate_rsp (XDR *xdrs, gfs3_ftruncate_rsp *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_int (xdrs, &objp->op_ret)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_errno)) - return FALSE; - if (!xdr_gf_iatt (xdrs, &objp->prestat)) - return FALSE; - if (!xdr_gf_iatt (xdrs, &objp->poststat)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->xdata.xdata_val, (u_int *) &objp->xdata.xdata_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gfs3_fstat_req (XDR *xdrs, gfs3_fstat_req *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_opaque (xdrs, objp->gfid, 16)) - return FALSE; - if (!xdr_quad_t (xdrs, &objp->fd)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->xdata.xdata_val, (u_int *) &objp->xdata.xdata_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gfs3_fstat_rsp (XDR *xdrs, gfs3_fstat_rsp *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_int (xdrs, &objp->op_ret)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_errno)) - return FALSE; - if (!xdr_gf_iatt (xdrs, &objp->stat)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->xdata.xdata_val, (u_int *) &objp->xdata.xdata_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gfs3_entrylk_req (XDR *xdrs, gfs3_entrylk_req *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_opaque (xdrs, objp->gfid, 16)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->cmd)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->type)) - return FALSE; - if (!xdr_u_quad_t (xdrs, &objp->namelen)) - return FALSE; - if (!xdr_string (xdrs, &objp->name, ~0)) - return FALSE; - if (!xdr_string (xdrs, &objp->volume, ~0)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->xdata.xdata_val, (u_int *) &objp->xdata.xdata_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gfs3_fentrylk_req (XDR *xdrs, gfs3_fentrylk_req *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_opaque (xdrs, objp->gfid, 16)) - return FALSE; - if (!xdr_quad_t (xdrs, &objp->fd)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->cmd)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->type)) - return FALSE; - if (!xdr_u_quad_t (xdrs, &objp->namelen)) - return FALSE; - if (!xdr_string (xdrs, &objp->name, ~0)) - return FALSE; - if (!xdr_string (xdrs, &objp->volume, ~0)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->xdata.xdata_val, (u_int *) &objp->xdata.xdata_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gfs3_setattr_req (XDR *xdrs, gfs3_setattr_req *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_opaque (xdrs, objp->gfid, 16)) - return FALSE; - if (!xdr_gf_iatt (xdrs, &objp->stbuf)) - return FALSE; - if (!xdr_int (xdrs, &objp->valid)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->xdata.xdata_val, (u_int *) &objp->xdata.xdata_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gfs3_setattr_rsp (XDR *xdrs, gfs3_setattr_rsp *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_int (xdrs, &objp->op_ret)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_errno)) - return FALSE; - if (!xdr_gf_iatt (xdrs, &objp->statpre)) - return FALSE; - if (!xdr_gf_iatt (xdrs, &objp->statpost)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->xdata.xdata_val, (u_int *) &objp->xdata.xdata_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gfs3_fsetattr_req (XDR *xdrs, gfs3_fsetattr_req *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_quad_t (xdrs, &objp->fd)) - return FALSE; - if (!xdr_gf_iatt (xdrs, &objp->stbuf)) - return FALSE; - if (!xdr_int (xdrs, &objp->valid)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->xdata.xdata_val, (u_int *) &objp->xdata.xdata_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gfs3_fsetattr_rsp (XDR *xdrs, gfs3_fsetattr_rsp *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_int (xdrs, &objp->op_ret)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_errno)) - return FALSE; - if (!xdr_gf_iatt (xdrs, &objp->statpre)) - return FALSE; - if (!xdr_gf_iatt (xdrs, &objp->statpost)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->xdata.xdata_val, (u_int *) &objp->xdata.xdata_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gfs3_fallocate_req (XDR *xdrs, gfs3_fallocate_req *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_opaque (xdrs, objp->gfid, 16)) - return FALSE; - if (!xdr_quad_t (xdrs, &objp->fd)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->flags)) - return FALSE; - if (!xdr_u_quad_t (xdrs, &objp->offset)) - return FALSE; - if (!xdr_u_quad_t (xdrs, &objp->size)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->xdata.xdata_val, (u_int *) &objp->xdata.xdata_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gfs3_fallocate_rsp (XDR *xdrs, gfs3_fallocate_rsp *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_int (xdrs, &objp->op_ret)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_errno)) - return FALSE; - if (!xdr_gf_iatt (xdrs, &objp->statpre)) - return FALSE; - if (!xdr_gf_iatt (xdrs, &objp->statpost)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->xdata.xdata_val, (u_int *) &objp->xdata.xdata_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gfs3_discard_req (XDR *xdrs, gfs3_discard_req *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_opaque (xdrs, objp->gfid, 16)) - return FALSE; - if (!xdr_quad_t (xdrs, &objp->fd)) - return FALSE; - if (!xdr_u_quad_t (xdrs, &objp->offset)) - return FALSE; - if (!xdr_u_quad_t (xdrs, &objp->size)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->xdata.xdata_val, (u_int *) &objp->xdata.xdata_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gfs3_discard_rsp (XDR *xdrs, gfs3_discard_rsp *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_int (xdrs, &objp->op_ret)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_errno)) - return FALSE; - if (!xdr_gf_iatt (xdrs, &objp->statpre)) - return FALSE; - if (!xdr_gf_iatt (xdrs, &objp->statpost)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->xdata.xdata_val, (u_int *) &objp->xdata.xdata_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gfs3_zerofill_req (XDR *xdrs, gfs3_zerofill_req *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_opaque (xdrs, objp->gfid, 16)) - return FALSE; - if (!xdr_quad_t (xdrs, &objp->fd)) - return FALSE; - if (!xdr_u_quad_t (xdrs, &objp->offset)) - return FALSE; - if (!xdr_u_quad_t (xdrs, &objp->size)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->xdata.xdata_val, - (u_int *) &objp->xdata.xdata_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gfs3_zerofill_rsp (XDR *xdrs, gfs3_zerofill_rsp *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_int (xdrs, &objp->op_ret)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_errno)) - return FALSE; - if (!xdr_gf_iatt (xdrs, &objp->statpre)) - return FALSE; - if (!xdr_gf_iatt (xdrs, &objp->statpost)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->xdata.xdata_val, - (u_int *) &objp->xdata.xdata_len, ~0)) - return FALSE; - return TRUE; -} - - -bool_t -xdr_gfs3_rchecksum_req (XDR *xdrs, gfs3_rchecksum_req *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_quad_t (xdrs, &objp->fd)) - return FALSE; - if (!xdr_u_quad_t (xdrs, &objp->offset)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->len)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->xdata.xdata_val, (u_int *) &objp->xdata.xdata_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gfs3_rchecksum_rsp (XDR *xdrs, gfs3_rchecksum_rsp *objp) -{ - register int32_t *buf; - buf = NULL; - - - if (xdrs->x_op == XDR_ENCODE) { - buf = XDR_INLINE (xdrs, 3 * BYTES_PER_XDR_UNIT); - if (buf == NULL) { - if (!xdr_int (xdrs, &objp->op_ret)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_errno)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->weak_checksum)) - return FALSE; - - } else { - IXDR_PUT_LONG(buf, objp->op_ret); - IXDR_PUT_LONG(buf, objp->op_errno); - IXDR_PUT_U_LONG(buf, objp->weak_checksum); - } - if (!xdr_bytes (xdrs, (char **)&objp->strong_checksum.strong_checksum_val, (u_int *) &objp->strong_checksum.strong_checksum_len, ~0)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->xdata.xdata_val, (u_int *) &objp->xdata.xdata_len, ~0)) - return FALSE; - return TRUE; - } else if (xdrs->x_op == XDR_DECODE) { - buf = XDR_INLINE (xdrs, 3 * BYTES_PER_XDR_UNIT); - if (buf == NULL) { - if (!xdr_int (xdrs, &objp->op_ret)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_errno)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->weak_checksum)) - return FALSE; - - } else { - objp->op_ret = IXDR_GET_LONG(buf); - objp->op_errno = IXDR_GET_LONG(buf); - objp->weak_checksum = IXDR_GET_U_LONG(buf); - } - if (!xdr_bytes (xdrs, (char **)&objp->strong_checksum.strong_checksum_val, (u_int *) &objp->strong_checksum.strong_checksum_len, ~0)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->xdata.xdata_val, (u_int *) &objp->xdata.xdata_len, ~0)) - return FALSE; - return TRUE; - } - - if (!xdr_int (xdrs, &objp->op_ret)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_errno)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->weak_checksum)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->strong_checksum.strong_checksum_val, (u_int *) &objp->strong_checksum.strong_checksum_len, ~0)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->xdata.xdata_val, (u_int *) &objp->xdata.xdata_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gf_setvolume_req (XDR *xdrs, gf_setvolume_req *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_bytes (xdrs, (char **)&objp->dict.dict_val, (u_int *) &objp->dict.dict_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gf_setvolume_rsp (XDR *xdrs, gf_setvolume_rsp *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_int (xdrs, &objp->op_ret)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_errno)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->dict.dict_val, (u_int *) &objp->dict.dict_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gf_getspec_req (XDR *xdrs, gf_getspec_req *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_u_int (xdrs, &objp->flags)) - return FALSE; - if (!xdr_string (xdrs, &objp->key, ~0)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->xdata.xdata_val, (u_int *) &objp->xdata.xdata_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gf_getspec_rsp (XDR *xdrs, gf_getspec_rsp *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_int (xdrs, &objp->op_ret)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_errno)) - return FALSE; - if (!xdr_string (xdrs, &objp->spec, ~0)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->xdata.xdata_val, (u_int *) &objp->xdata.xdata_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gf_mgmt_hndsk_req (XDR *xdrs, gf_mgmt_hndsk_req *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_bytes (xdrs, (char **)&objp->hndsk.hndsk_val, (u_int *) &objp->hndsk.hndsk_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gf_mgmt_hndsk_rsp (XDR *xdrs, gf_mgmt_hndsk_rsp *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_int (xdrs, &objp->op_ret)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_errno)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->hndsk.hndsk_val, (u_int *) &objp->hndsk.hndsk_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gf_log_req (XDR *xdrs, gf_log_req *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_bytes (xdrs, (char **)&objp->msg.msg_val, (u_int *) &objp->msg.msg_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gf_notify_req (XDR *xdrs, gf_notify_req *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_u_int (xdrs, &objp->flags)) - return FALSE; - if (!xdr_string (xdrs, &objp->buf, ~0)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->xdata.xdata_val, (u_int *) &objp->xdata.xdata_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gf_notify_rsp (XDR *xdrs, gf_notify_rsp *objp) -{ - register int32_t *buf; - buf = NULL; - - - if (xdrs->x_op == XDR_ENCODE) { - buf = XDR_INLINE (xdrs, 3 * BYTES_PER_XDR_UNIT); - if (buf == NULL) { - if (!xdr_int (xdrs, &objp->op_ret)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_errno)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->flags)) - return FALSE; - - } else { - IXDR_PUT_LONG(buf, objp->op_ret); - IXDR_PUT_LONG(buf, objp->op_errno); - IXDR_PUT_U_LONG(buf, objp->flags); - } - if (!xdr_string (xdrs, &objp->buf, ~0)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->xdata.xdata_val, (u_int *) &objp->xdata.xdata_len, ~0)) - return FALSE; - return TRUE; - } else if (xdrs->x_op == XDR_DECODE) { - buf = XDR_INLINE (xdrs, 3 * BYTES_PER_XDR_UNIT); - if (buf == NULL) { - if (!xdr_int (xdrs, &objp->op_ret)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_errno)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->flags)) - return FALSE; - - } else { - objp->op_ret = IXDR_GET_LONG(buf); - objp->op_errno = IXDR_GET_LONG(buf); - objp->flags = IXDR_GET_U_LONG(buf); - } - if (!xdr_string (xdrs, &objp->buf, ~0)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->xdata.xdata_val, (u_int *) &objp->xdata.xdata_len, ~0)) - return FALSE; - return TRUE; - } - - if (!xdr_int (xdrs, &objp->op_ret)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_errno)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->flags)) - return FALSE; - if (!xdr_string (xdrs, &objp->buf, ~0)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->xdata.xdata_val, (u_int *) &objp->xdata.xdata_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gfs3_releasedir_req (XDR *xdrs, gfs3_releasedir_req *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_opaque (xdrs, objp->gfid, 16)) - return FALSE; - if (!xdr_quad_t (xdrs, &objp->fd)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->xdata.xdata_val, (u_int *) &objp->xdata.xdata_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gfs3_release_req (XDR *xdrs, gfs3_release_req *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_opaque (xdrs, objp->gfid, 16)) - return FALSE; - if (!xdr_quad_t (xdrs, &objp->fd)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->xdata.xdata_val, (u_int *) &objp->xdata.xdata_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gf_common_rsp (XDR *xdrs, gf_common_rsp *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_int (xdrs, &objp->op_ret)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_errno)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->xdata.xdata_val, (u_int *) &objp->xdata.xdata_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gfs3_dirlist (XDR *xdrs, gfs3_dirlist *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_u_quad_t (xdrs, &objp->d_ino)) - return FALSE; - if (!xdr_u_quad_t (xdrs, &objp->d_off)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->d_len)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->d_type)) - return FALSE; - if (!xdr_string (xdrs, &objp->name, ~0)) - return FALSE; - if (!xdr_pointer (xdrs, (char **)&objp->nextentry, sizeof (gfs3_dirlist), (xdrproc_t) xdr_gfs3_dirlist)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gfs3_readdir_rsp (XDR *xdrs, gfs3_readdir_rsp *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_int (xdrs, &objp->op_ret)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_errno)) - return FALSE; - if (!xdr_pointer (xdrs, (char **)&objp->reply, sizeof (gfs3_dirlist), (xdrproc_t) xdr_gfs3_dirlist)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->xdata.xdata_val, (u_int *) &objp->xdata.xdata_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gfs3_dirplist (XDR *xdrs, gfs3_dirplist *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_u_quad_t (xdrs, &objp->d_ino)) - return FALSE; - if (!xdr_u_quad_t (xdrs, &objp->d_off)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->d_len)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->d_type)) - return FALSE; - if (!xdr_string (xdrs, &objp->name, ~0)) - return FALSE; - if (!xdr_gf_iatt (xdrs, &objp->stat)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->dict.dict_val, (u_int *) &objp->dict.dict_len, ~0)) - return FALSE; - if (!xdr_pointer (xdrs, (char **)&objp->nextentry, sizeof (gfs3_dirplist), (xdrproc_t) xdr_gfs3_dirplist)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gfs3_readdirp_rsp (XDR *xdrs, gfs3_readdirp_rsp *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_int (xdrs, &objp->op_ret)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_errno)) - return FALSE; - if (!xdr_pointer (xdrs, (char **)&objp->reply, sizeof (gfs3_dirplist), (xdrproc_t) xdr_gfs3_dirplist)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->xdata.xdata_val, (u_int *) &objp->xdata.xdata_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gf_set_lk_ver_rsp (XDR *xdrs, gf_set_lk_ver_rsp *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_int (xdrs, &objp->op_ret)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_errno)) - return FALSE; - if (!xdr_int (xdrs, &objp->lk_ver)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gf_set_lk_ver_req (XDR *xdrs, gf_set_lk_ver_req *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_string (xdrs, &objp->uid, ~0)) - return FALSE; - if (!xdr_int (xdrs, &objp->lk_ver)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gf_event_notify_req (XDR *xdrs, gf_event_notify_req *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_int (xdrs, &objp->op)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->dict.dict_val, (u_int *) &objp->dict.dict_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gf_event_notify_rsp (XDR *xdrs, gf_event_notify_rsp *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_int (xdrs, &objp->op_ret)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_errno)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->dict.dict_val, (u_int *) &objp->dict.dict_len, ~0)) - return FALSE; - return TRUE; -} diff --git a/rpc/xdr/src/glusterfs3-xdr.h b/rpc/xdr/src/glusterfs3-xdr.h deleted file mode 100644 index 13566e694..000000000 --- a/rpc/xdr/src/glusterfs3-xdr.h +++ /dev/null @@ -1,1394 +0,0 @@ -/* - Copyright (c) 2007-2012 Red Hat, Inc. - This file is part of GlusterFS. - - This file is licensed to you under your choice of the GNU Lesser - General Public License, version 3 or any later version (LGPLv3 or - later), or the GNU General Public License, version 2 (GPLv2), in all - cases as published by the Free Software Foundation. -*/ - -#include "xdr-common.h" -#include "compat.h" - -#if defined(__GNUC__) -#if __GNUC__ >= 4 -#pragma GCC diagnostic ignored "-Wunused-but-set-variable" -#endif -#endif - -/* - * Please do not edit this file. - * It was generated using rpcgen. - */ - -#ifndef _GLUSTERFS3_XDR_H_RPCGEN -#define _GLUSTERFS3_XDR_H_RPCGEN - -#include - - -#ifdef __cplusplus -extern "C" { -#endif - - -struct gf_statfs { - u_quad_t bsize; - u_quad_t frsize; - u_quad_t blocks; - u_quad_t bfree; - u_quad_t bavail; - u_quad_t files; - u_quad_t ffree; - u_quad_t favail; - u_quad_t fsid; - u_quad_t flag; - u_quad_t namemax; -}; -typedef struct gf_statfs gf_statfs; - -struct gf_proto_flock { - u_int type; - u_int whence; - u_quad_t start; - u_quad_t len; - u_int pid; - struct { - u_int lk_owner_len; - char *lk_owner_val; - } lk_owner; -}; -typedef struct gf_proto_flock gf_proto_flock; - -struct gf_iatt { - char ia_gfid[16]; - u_quad_t ia_ino; - u_quad_t ia_dev; - u_int mode; - u_int ia_nlink; - u_int ia_uid; - u_int ia_gid; - u_quad_t ia_rdev; - u_quad_t ia_size; - u_int ia_blksize; - u_quad_t ia_blocks; - u_int ia_atime; - u_int ia_atime_nsec; - u_int ia_mtime; - u_int ia_mtime_nsec; - u_int ia_ctime; - u_int ia_ctime_nsec; -}; -typedef struct gf_iatt gf_iatt; - -struct gfs3_stat_req { - char gfid[16]; - struct { - u_int xdata_len; - char *xdata_val; - } xdata; -}; -typedef struct gfs3_stat_req gfs3_stat_req; - -struct gfs3_stat_rsp { - int op_ret; - int op_errno; - struct gf_iatt stat; - struct { - u_int xdata_len; - char *xdata_val; - } xdata; -}; -typedef struct gfs3_stat_rsp gfs3_stat_rsp; - -struct gfs3_readlink_req { - char gfid[16]; - u_int size; - struct { - u_int xdata_len; - char *xdata_val; - } xdata; -}; -typedef struct gfs3_readlink_req gfs3_readlink_req; - -struct gfs3_readlink_rsp { - int op_ret; - int op_errno; - struct gf_iatt buf; - char *path; - struct { - u_int xdata_len; - char *xdata_val; - } xdata; -}; -typedef struct gfs3_readlink_rsp gfs3_readlink_rsp; - -struct gfs3_mknod_req { - char pargfid[16]; - u_quad_t dev; - u_int mode; - u_int umask; - char *bname; - struct { - u_int xdata_len; - char *xdata_val; - } xdata; -}; -typedef struct gfs3_mknod_req gfs3_mknod_req; - -struct gfs3_mknod_rsp { - int op_ret; - int op_errno; - struct gf_iatt stat; - struct gf_iatt preparent; - struct gf_iatt postparent; - struct { - u_int xdata_len; - char *xdata_val; - } xdata; -}; -typedef struct gfs3_mknod_rsp gfs3_mknod_rsp; - -struct gfs3_mkdir_req { - char pargfid[16]; - u_int mode; - u_int umask; - char *bname; - struct { - u_int xdata_len; - char *xdata_val; - } xdata; -}; -typedef struct gfs3_mkdir_req gfs3_mkdir_req; - -struct gfs3_mkdir_rsp { - int op_ret; - int op_errno; - struct gf_iatt stat; - struct gf_iatt preparent; - struct gf_iatt postparent; - struct { - u_int xdata_len; - char *xdata_val; - } xdata; -}; -typedef struct gfs3_mkdir_rsp gfs3_mkdir_rsp; - -struct gfs3_unlink_req { - char pargfid[16]; - char *bname; - u_int xflags; - struct { - u_int xdata_len; - char *xdata_val; - } xdata; -}; -typedef struct gfs3_unlink_req gfs3_unlink_req; - -struct gfs3_unlink_rsp { - int op_ret; - int op_errno; - struct gf_iatt preparent; - struct gf_iatt postparent; - struct { - u_int xdata_len; - char *xdata_val; - } xdata; -}; -typedef struct gfs3_unlink_rsp gfs3_unlink_rsp; - -struct gfs3_rmdir_req { - char pargfid[16]; - int xflags; - char *bname; - struct { - u_int xdata_len; - char *xdata_val; - } xdata; -}; -typedef struct gfs3_rmdir_req gfs3_rmdir_req; - -struct gfs3_rmdir_rsp { - int op_ret; - int op_errno; - struct gf_iatt preparent; - struct gf_iatt postparent; - struct { - u_int xdata_len; - char *xdata_val; - } xdata; -}; -typedef struct gfs3_rmdir_rsp gfs3_rmdir_rsp; - -struct gfs3_symlink_req { - char pargfid[16]; - char *bname; - u_int umask; - char *linkname; - struct { - u_int xdata_len; - char *xdata_val; - } xdata; -}; -typedef struct gfs3_symlink_req gfs3_symlink_req; - -struct gfs3_symlink_rsp { - int op_ret; - int op_errno; - struct gf_iatt stat; - struct gf_iatt preparent; - struct gf_iatt postparent; - struct { - u_int xdata_len; - char *xdata_val; - } xdata; -}; -typedef struct gfs3_symlink_rsp gfs3_symlink_rsp; - -struct gfs3_rename_req { - char oldgfid[16]; - char newgfid[16]; - char *oldbname; - char *newbname; - struct { - u_int xdata_len; - char *xdata_val; - } xdata; -}; -typedef struct gfs3_rename_req gfs3_rename_req; - -struct gfs3_rename_rsp { - int op_ret; - int op_errno; - struct gf_iatt stat; - struct gf_iatt preoldparent; - struct gf_iatt postoldparent; - struct gf_iatt prenewparent; - struct gf_iatt postnewparent; - struct { - u_int xdata_len; - char *xdata_val; - } xdata; -}; -typedef struct gfs3_rename_rsp gfs3_rename_rsp; - -struct gfs3_link_req { - char oldgfid[16]; - char newgfid[16]; - char *newbname; - struct { - u_int xdata_len; - char *xdata_val; - } xdata; -}; -typedef struct gfs3_link_req gfs3_link_req; - -struct gfs3_link_rsp { - int op_ret; - int op_errno; - struct gf_iatt stat; - struct gf_iatt preparent; - struct gf_iatt postparent; - struct { - u_int xdata_len; - char *xdata_val; - } xdata; -}; -typedef struct gfs3_link_rsp gfs3_link_rsp; - -struct gfs3_truncate_req { - char gfid[16]; - u_quad_t offset; - struct { - u_int xdata_len; - char *xdata_val; - } xdata; -}; -typedef struct gfs3_truncate_req gfs3_truncate_req; - -struct gfs3_truncate_rsp { - int op_ret; - int op_errno; - struct gf_iatt prestat; - struct gf_iatt poststat; - struct { - u_int xdata_len; - char *xdata_val; - } xdata; -}; -typedef struct gfs3_truncate_rsp gfs3_truncate_rsp; - -struct gfs3_open_req { - char gfid[16]; - u_int flags; - struct { - u_int xdata_len; - char *xdata_val; - } xdata; -}; -typedef struct gfs3_open_req gfs3_open_req; - -struct gfs3_open_rsp { - int op_ret; - int op_errno; - quad_t fd; - struct { - u_int xdata_len; - char *xdata_val; - } xdata; -}; -typedef struct gfs3_open_rsp gfs3_open_rsp; - -struct gfs3_read_req { - char gfid[16]; - quad_t fd; - u_quad_t offset; - u_int size; - u_int flag; - struct { - u_int xdata_len; - char *xdata_val; - } xdata; -}; -typedef struct gfs3_read_req gfs3_read_req; - -struct gfs3_read_rsp { - int op_ret; - int op_errno; - struct gf_iatt stat; - u_int size; - struct { - u_int xdata_len; - char *xdata_val; - } xdata; -}; -typedef struct gfs3_read_rsp gfs3_read_rsp; - -struct gfs3_lookup_req { - char gfid[16]; - char pargfid[16]; - u_int flags; - char *bname; - struct { - u_int xdata_len; - char *xdata_val; - } xdata; -}; -typedef struct gfs3_lookup_req gfs3_lookup_req; - -struct gfs3_lookup_rsp { - int op_ret; - int op_errno; - struct gf_iatt stat; - struct gf_iatt postparent; - struct { - u_int xdata_len; - char *xdata_val; - } xdata; -}; -typedef struct gfs3_lookup_rsp gfs3_lookup_rsp; - -struct gfs3_write_req { - char gfid[16]; - quad_t fd; - u_quad_t offset; - u_int size; - u_int flag; - struct { - u_int xdata_len; - char *xdata_val; - } xdata; -}; -typedef struct gfs3_write_req gfs3_write_req; - -struct gfs3_write_rsp { - int op_ret; - int op_errno; - struct gf_iatt prestat; - struct gf_iatt poststat; - struct { - u_int xdata_len; - char *xdata_val; - } xdata; -}; -typedef struct gfs3_write_rsp gfs3_write_rsp; - -struct gfs3_statfs_req { - char gfid[16]; - struct { - u_int xdata_len; - char *xdata_val; - } xdata; -}; -typedef struct gfs3_statfs_req gfs3_statfs_req; - -struct gfs3_statfs_rsp { - int op_ret; - int op_errno; - struct gf_statfs statfs; - struct { - u_int xdata_len; - char *xdata_val; - } xdata; -}; -typedef struct gfs3_statfs_rsp gfs3_statfs_rsp; - -struct gfs3_lk_req { - char gfid[16]; - quad_t fd; - u_int cmd; - u_int type; - struct gf_proto_flock flock; - struct { - u_int xdata_len; - char *xdata_val; - } xdata; -}; -typedef struct gfs3_lk_req gfs3_lk_req; - -struct gfs3_lk_rsp { - int op_ret; - int op_errno; - struct gf_proto_flock flock; - struct { - u_int xdata_len; - char *xdata_val; - } xdata; -}; -typedef struct gfs3_lk_rsp gfs3_lk_rsp; - -struct gfs3_inodelk_req { - char gfid[16]; - u_int cmd; - u_int type; - struct gf_proto_flock flock; - char *volume; - struct { - u_int xdata_len; - char *xdata_val; - } xdata; -}; -typedef struct gfs3_inodelk_req gfs3_inodelk_req; - -struct gfs3_finodelk_req { - char gfid[16]; - quad_t fd; - u_int cmd; - u_int type; - struct gf_proto_flock flock; - char *volume; - struct { - u_int xdata_len; - char *xdata_val; - } xdata; -}; -typedef struct gfs3_finodelk_req gfs3_finodelk_req; - -struct gfs3_flush_req { - char gfid[16]; - quad_t fd; - struct { - u_int xdata_len; - char *xdata_val; - } xdata; -}; -typedef struct gfs3_flush_req gfs3_flush_req; - -struct gfs3_fsync_req { - char gfid[16]; - quad_t fd; - u_int data; - struct { - u_int xdata_len; - char *xdata_val; - } xdata; -}; -typedef struct gfs3_fsync_req gfs3_fsync_req; - -struct gfs3_fsync_rsp { - int op_ret; - int op_errno; - struct gf_iatt prestat; - struct gf_iatt poststat; - struct { - u_int xdata_len; - char *xdata_val; - } xdata; -}; -typedef struct gfs3_fsync_rsp gfs3_fsync_rsp; - -struct gfs3_setxattr_req { - char gfid[16]; - u_int flags; - struct { - u_int dict_len; - char *dict_val; - } dict; - struct { - u_int xdata_len; - char *xdata_val; - } xdata; -}; -typedef struct gfs3_setxattr_req gfs3_setxattr_req; - -struct gfs3_fsetxattr_req { - char gfid[16]; - quad_t fd; - u_int flags; - struct { - u_int dict_len; - char *dict_val; - } dict; - struct { - u_int xdata_len; - char *xdata_val; - } xdata; -}; -typedef struct gfs3_fsetxattr_req gfs3_fsetxattr_req; - -struct gfs3_xattrop_req { - char gfid[16]; - u_int flags; - struct { - u_int dict_len; - char *dict_val; - } dict; - struct { - u_int xdata_len; - char *xdata_val; - } xdata; -}; -typedef struct gfs3_xattrop_req gfs3_xattrop_req; - -struct gfs3_xattrop_rsp { - int op_ret; - int op_errno; - struct { - u_int dict_len; - char *dict_val; - } dict; - struct { - u_int xdata_len; - char *xdata_val; - } xdata; -}; -typedef struct gfs3_xattrop_rsp gfs3_xattrop_rsp; - -struct gfs3_fxattrop_req { - char gfid[16]; - quad_t fd; - u_int flags; - struct { - u_int dict_len; - char *dict_val; - } dict; - struct { - u_int xdata_len; - char *xdata_val; - } xdata; -}; -typedef struct gfs3_fxattrop_req gfs3_fxattrop_req; - -struct gfs3_fxattrop_rsp { - int op_ret; - int op_errno; - struct { - u_int dict_len; - char *dict_val; - } dict; - struct { - u_int xdata_len; - char *xdata_val; - } xdata; -}; -typedef struct gfs3_fxattrop_rsp gfs3_fxattrop_rsp; - -struct gfs3_getxattr_req { - char gfid[16]; - u_int namelen; - char *name; - struct { - u_int xdata_len; - char *xdata_val; - } xdata; -}; -typedef struct gfs3_getxattr_req gfs3_getxattr_req; - -struct gfs3_getxattr_rsp { - int op_ret; - int op_errno; - struct { - u_int dict_len; - char *dict_val; - } dict; - struct { - u_int xdata_len; - char *xdata_val; - } xdata; -}; -typedef struct gfs3_getxattr_rsp gfs3_getxattr_rsp; - -struct gfs3_fgetxattr_req { - char gfid[16]; - quad_t fd; - u_int namelen; - char *name; - struct { - u_int xdata_len; - char *xdata_val; - } xdata; -}; -typedef struct gfs3_fgetxattr_req gfs3_fgetxattr_req; - -struct gfs3_fgetxattr_rsp { - int op_ret; - int op_errno; - struct { - u_int dict_len; - char *dict_val; - } dict; - struct { - u_int xdata_len; - char *xdata_val; - } xdata; -}; -typedef struct gfs3_fgetxattr_rsp gfs3_fgetxattr_rsp; - -struct gfs3_removexattr_req { - char gfid[16]; - char *name; - struct { - u_int xdata_len; - char *xdata_val; - } xdata; -}; -typedef struct gfs3_removexattr_req gfs3_removexattr_req; - -struct gfs3_fremovexattr_req { - char gfid[16]; - quad_t fd; - char *name; - struct { - u_int xdata_len; - char *xdata_val; - } xdata; -}; -typedef struct gfs3_fremovexattr_req gfs3_fremovexattr_req; - -struct gfs3_opendir_req { - char gfid[16]; - struct { - u_int xdata_len; - char *xdata_val; - } xdata; -}; -typedef struct gfs3_opendir_req gfs3_opendir_req; - -struct gfs3_opendir_rsp { - int op_ret; - int op_errno; - quad_t fd; - struct { - u_int xdata_len; - char *xdata_val; - } xdata; -}; -typedef struct gfs3_opendir_rsp gfs3_opendir_rsp; - -struct gfs3_fsyncdir_req { - char gfid[16]; - quad_t fd; - int data; - struct { - u_int xdata_len; - char *xdata_val; - } xdata; -}; -typedef struct gfs3_fsyncdir_req gfs3_fsyncdir_req; - -struct gfs3_readdir_req { - char gfid[16]; - quad_t fd; - u_quad_t offset; - u_int size; - struct { - u_int xdata_len; - char *xdata_val; - } xdata; -}; -typedef struct gfs3_readdir_req gfs3_readdir_req; - -struct gfs3_readdirp_req { - char gfid[16]; - quad_t fd; - u_quad_t offset; - u_int size; - struct { - u_int dict_len; - char *dict_val; - } dict; -}; -typedef struct gfs3_readdirp_req gfs3_readdirp_req; - -struct gfs3_access_req { - char gfid[16]; - u_int mask; - struct { - u_int xdata_len; - char *xdata_val; - } xdata; -}; -typedef struct gfs3_access_req gfs3_access_req; - -struct gfs3_create_req { - char pargfid[16]; - u_int flags; - u_int mode; - u_int umask; - char *bname; - struct { - u_int xdata_len; - char *xdata_val; - } xdata; -}; -typedef struct gfs3_create_req gfs3_create_req; - -struct gfs3_create_rsp { - int op_ret; - int op_errno; - struct gf_iatt stat; - u_quad_t fd; - struct gf_iatt preparent; - struct gf_iatt postparent; - struct { - u_int xdata_len; - char *xdata_val; - } xdata; -}; -typedef struct gfs3_create_rsp gfs3_create_rsp; - -struct gfs3_ftruncate_req { - char gfid[16]; - quad_t fd; - u_quad_t offset; - struct { - u_int xdata_len; - char *xdata_val; - } xdata; -}; -typedef struct gfs3_ftruncate_req gfs3_ftruncate_req; - -struct gfs3_ftruncate_rsp { - int op_ret; - int op_errno; - struct gf_iatt prestat; - struct gf_iatt poststat; - struct { - u_int xdata_len; - char *xdata_val; - } xdata; -}; -typedef struct gfs3_ftruncate_rsp gfs3_ftruncate_rsp; - -struct gfs3_fstat_req { - char gfid[16]; - quad_t fd; - struct { - u_int xdata_len; - char *xdata_val; - } xdata; -}; -typedef struct gfs3_fstat_req gfs3_fstat_req; - -struct gfs3_fstat_rsp { - int op_ret; - int op_errno; - struct gf_iatt stat; - struct { - u_int xdata_len; - char *xdata_val; - } xdata; -}; -typedef struct gfs3_fstat_rsp gfs3_fstat_rsp; - -struct gfs3_entrylk_req { - char gfid[16]; - u_int cmd; - u_int type; - u_quad_t namelen; - char *name; - char *volume; - struct { - u_int xdata_len; - char *xdata_val; - } xdata; -}; -typedef struct gfs3_entrylk_req gfs3_entrylk_req; - -struct gfs3_fentrylk_req { - char gfid[16]; - quad_t fd; - u_int cmd; - u_int type; - u_quad_t namelen; - char *name; - char *volume; - struct { - u_int xdata_len; - char *xdata_val; - } xdata; -}; -typedef struct gfs3_fentrylk_req gfs3_fentrylk_req; - -struct gfs3_setattr_req { - char gfid[16]; - struct gf_iatt stbuf; - int valid; - struct { - u_int xdata_len; - char *xdata_val; - } xdata; -}; -typedef struct gfs3_setattr_req gfs3_setattr_req; - -struct gfs3_setattr_rsp { - int op_ret; - int op_errno; - struct gf_iatt statpre; - struct gf_iatt statpost; - struct { - u_int xdata_len; - char *xdata_val; - } xdata; -}; -typedef struct gfs3_setattr_rsp gfs3_setattr_rsp; - -struct gfs3_fsetattr_req { - quad_t fd; - struct gf_iatt stbuf; - int valid; - struct { - u_int xdata_len; - char *xdata_val; - } xdata; -}; -typedef struct gfs3_fsetattr_req gfs3_fsetattr_req; - -struct gfs3_fsetattr_rsp { - int op_ret; - int op_errno; - struct gf_iatt statpre; - struct gf_iatt statpost; - struct { - u_int xdata_len; - char *xdata_val; - } xdata; -}; -typedef struct gfs3_fsetattr_rsp gfs3_fsetattr_rsp; - -struct gfs3_fallocate_req { - char gfid[16]; - quad_t fd; - u_int flags; - u_quad_t offset; - u_quad_t size; - struct { - u_int xdata_len; - char *xdata_val; - } xdata; -}; -typedef struct gfs3_fallocate_req gfs3_fallocate_req; - -struct gfs3_fallocate_rsp { - int op_ret; - int op_errno; - struct gf_iatt statpre; - struct gf_iatt statpost; - struct { - u_int xdata_len; - char *xdata_val; - } xdata; -}; -typedef struct gfs3_fallocate_rsp gfs3_fallocate_rsp; - -struct gfs3_discard_req { - char gfid[16]; - quad_t fd; - u_quad_t offset; - u_quad_t size; - struct { - u_int xdata_len; - char *xdata_val; - } xdata; -}; -typedef struct gfs3_discard_req gfs3_discard_req; - -struct gfs3_discard_rsp { - int op_ret; - int op_errno; - struct gf_iatt statpre; - struct gf_iatt statpost; - struct { - u_int xdata_len; - char *xdata_val; - } xdata; -}; -typedef struct gfs3_discard_rsp gfs3_discard_rsp; - -struct gfs3_zerofill_req { - char gfid[16]; - quad_t fd; - u_quad_t offset; - u_quad_t size; - struct { - u_int xdata_len; - char *xdata_val; - } xdata; -}; -typedef struct gfs3_zerofill_req gfs3_zerofill_req; - -struct gfs3_zerofill_rsp { - int op_ret; - int op_errno; - struct gf_iatt statpre; - struct gf_iatt statpost; - struct { - u_int xdata_len; - char *xdata_val; - } xdata; -}; -typedef struct gfs3_zerofill_rsp gfs3_zerofill_rsp; - - -struct gfs3_rchecksum_req { - quad_t fd; - u_quad_t offset; - u_int len; - struct { - u_int xdata_len; - char *xdata_val; - } xdata; -}; -typedef struct gfs3_rchecksum_req gfs3_rchecksum_req; - -struct gfs3_rchecksum_rsp { - int op_ret; - int op_errno; - u_int weak_checksum; - struct { - u_int strong_checksum_len; - char *strong_checksum_val; - } strong_checksum; - struct { - u_int xdata_len; - char *xdata_val; - } xdata; -}; -typedef struct gfs3_rchecksum_rsp gfs3_rchecksum_rsp; - -struct gf_setvolume_req { - struct { - u_int dict_len; - char *dict_val; - } dict; -}; -typedef struct gf_setvolume_req gf_setvolume_req; - -struct gf_setvolume_rsp { - int op_ret; - int op_errno; - struct { - u_int dict_len; - char *dict_val; - } dict; -}; -typedef struct gf_setvolume_rsp gf_setvolume_rsp; - -struct gf_getspec_req { - u_int flags; - char *key; - struct { - u_int xdata_len; - char *xdata_val; - } xdata; -}; -typedef struct gf_getspec_req gf_getspec_req; - -struct gf_getspec_rsp { - int op_ret; - int op_errno; - char *spec; - struct { - u_int xdata_len; - char *xdata_val; - } xdata; -}; -typedef struct gf_getspec_rsp gf_getspec_rsp; - -struct gf_mgmt_hndsk_req { - struct { - u_int hndsk_len; - char *hndsk_val; - } hndsk; -}; -typedef struct gf_mgmt_hndsk_req gf_mgmt_hndsk_req; - -struct gf_mgmt_hndsk_rsp { - int op_ret; - int op_errno; - struct { - u_int hndsk_len; - char *hndsk_val; - } hndsk; -}; -typedef struct gf_mgmt_hndsk_rsp gf_mgmt_hndsk_rsp; - -struct gf_log_req { - struct { - u_int msg_len; - char *msg_val; - } msg; -}; -typedef struct gf_log_req gf_log_req; - -struct gf_notify_req { - u_int flags; - char *buf; - struct { - u_int xdata_len; - char *xdata_val; - } xdata; -}; -typedef struct gf_notify_req gf_notify_req; - -struct gf_notify_rsp { - int op_ret; - int op_errno; - u_int flags; - char *buf; - struct { - u_int xdata_len; - char *xdata_val; - } xdata; -}; -typedef struct gf_notify_rsp gf_notify_rsp; - -struct gfs3_releasedir_req { - char gfid[16]; - quad_t fd; - struct { - u_int xdata_len; - char *xdata_val; - } xdata; -}; -typedef struct gfs3_releasedir_req gfs3_releasedir_req; - -struct gfs3_release_req { - char gfid[16]; - quad_t fd; - struct { - u_int xdata_len; - char *xdata_val; - } xdata; -}; -typedef struct gfs3_release_req gfs3_release_req; - -struct gf_common_rsp { - int op_ret; - int op_errno; - struct { - u_int xdata_len; - char *xdata_val; - } xdata; -}; -typedef struct gf_common_rsp gf_common_rsp; - -struct gfs3_dirlist { - u_quad_t d_ino; - u_quad_t d_off; - u_int d_len; - u_int d_type; - char *name; - struct gfs3_dirlist *nextentry; -}; -typedef struct gfs3_dirlist gfs3_dirlist; - -struct gfs3_readdir_rsp { - int op_ret; - int op_errno; - struct gfs3_dirlist *reply; - struct { - u_int xdata_len; - char *xdata_val; - } xdata; -}; -typedef struct gfs3_readdir_rsp gfs3_readdir_rsp; - -struct gfs3_dirplist { - u_quad_t d_ino; - u_quad_t d_off; - u_int d_len; - u_int d_type; - char *name; - struct gf_iatt stat; - struct { - u_int dict_len; - char *dict_val; - } dict; - struct gfs3_dirplist *nextentry; -}; -typedef struct gfs3_dirplist gfs3_dirplist; - -struct gfs3_readdirp_rsp { - int op_ret; - int op_errno; - struct gfs3_dirplist *reply; - struct { - u_int xdata_len; - char *xdata_val; - } xdata; -}; -typedef struct gfs3_readdirp_rsp gfs3_readdirp_rsp; - -struct gf_set_lk_ver_rsp { - int op_ret; - int op_errno; - int lk_ver; -}; -typedef struct gf_set_lk_ver_rsp gf_set_lk_ver_rsp; - -struct gf_set_lk_ver_req { - char *uid; - int lk_ver; -}; -typedef struct gf_set_lk_ver_req gf_set_lk_ver_req; - -struct gf_event_notify_req { - int op; - struct { - u_int dict_len; - char *dict_val; - } dict; -}; -typedef struct gf_event_notify_req gf_event_notify_req; - -struct gf_event_notify_rsp { - int op_ret; - int op_errno; - struct { - u_int dict_len; - char *dict_val; - } dict; -}; -typedef struct gf_event_notify_rsp gf_event_notify_rsp; - -/* the xdr functions */ - -#if defined(__STDC__) || defined(__cplusplus) -extern bool_t xdr_gf_statfs (XDR *, gf_statfs*); -extern bool_t xdr_gf_proto_flock (XDR *, gf_proto_flock*); -extern bool_t xdr_gf_iatt (XDR *, gf_iatt*); -extern bool_t xdr_gfs3_stat_req (XDR *, gfs3_stat_req*); -extern bool_t xdr_gfs3_stat_rsp (XDR *, gfs3_stat_rsp*); -extern bool_t xdr_gfs3_readlink_req (XDR *, gfs3_readlink_req*); -extern bool_t xdr_gfs3_readlink_rsp (XDR *, gfs3_readlink_rsp*); -extern bool_t xdr_gfs3_mknod_req (XDR *, gfs3_mknod_req*); -extern bool_t xdr_gfs3_mknod_rsp (XDR *, gfs3_mknod_rsp*); -extern bool_t xdr_gfs3_mkdir_req (XDR *, gfs3_mkdir_req*); -extern bool_t xdr_gfs3_mkdir_rsp (XDR *, gfs3_mkdir_rsp*); -extern bool_t xdr_gfs3_unlink_req (XDR *, gfs3_unlink_req*); -extern bool_t xdr_gfs3_unlink_rsp (XDR *, gfs3_unlink_rsp*); -extern bool_t xdr_gfs3_rmdir_req (XDR *, gfs3_rmdir_req*); -extern bool_t xdr_gfs3_rmdir_rsp (XDR *, gfs3_rmdir_rsp*); -extern bool_t xdr_gfs3_symlink_req (XDR *, gfs3_symlink_req*); -extern bool_t xdr_gfs3_symlink_rsp (XDR *, gfs3_symlink_rsp*); -extern bool_t xdr_gfs3_rename_req (XDR *, gfs3_rename_req*); -extern bool_t xdr_gfs3_rename_rsp (XDR *, gfs3_rename_rsp*); -extern bool_t xdr_gfs3_link_req (XDR *, gfs3_link_req*); -extern bool_t xdr_gfs3_link_rsp (XDR *, gfs3_link_rsp*); -extern bool_t xdr_gfs3_truncate_req (XDR *, gfs3_truncate_req*); -extern bool_t xdr_gfs3_truncate_rsp (XDR *, gfs3_truncate_rsp*); -extern bool_t xdr_gfs3_open_req (XDR *, gfs3_open_req*); -extern bool_t xdr_gfs3_open_rsp (XDR *, gfs3_open_rsp*); -extern bool_t xdr_gfs3_read_req (XDR *, gfs3_read_req*); -extern bool_t xdr_gfs3_read_rsp (XDR *, gfs3_read_rsp*); -extern bool_t xdr_gfs3_lookup_req (XDR *, gfs3_lookup_req*); -extern bool_t xdr_gfs3_lookup_rsp (XDR *, gfs3_lookup_rsp*); -extern bool_t xdr_gfs3_write_req (XDR *, gfs3_write_req*); -extern bool_t xdr_gfs3_write_rsp (XDR *, gfs3_write_rsp*); -extern bool_t xdr_gfs3_statfs_req (XDR *, gfs3_statfs_req*); -extern bool_t xdr_gfs3_statfs_rsp (XDR *, gfs3_statfs_rsp*); -extern bool_t xdr_gfs3_lk_req (XDR *, gfs3_lk_req*); -extern bool_t xdr_gfs3_lk_rsp (XDR *, gfs3_lk_rsp*); -extern bool_t xdr_gfs3_inodelk_req (XDR *, gfs3_inodelk_req*); -extern bool_t xdr_gfs3_finodelk_req (XDR *, gfs3_finodelk_req*); -extern bool_t xdr_gfs3_flush_req (XDR *, gfs3_flush_req*); -extern bool_t xdr_gfs3_fsync_req (XDR *, gfs3_fsync_req*); -extern bool_t xdr_gfs3_fsync_rsp (XDR *, gfs3_fsync_rsp*); -extern bool_t xdr_gfs3_setxattr_req (XDR *, gfs3_setxattr_req*); -extern bool_t xdr_gfs3_fsetxattr_req (XDR *, gfs3_fsetxattr_req*); -extern bool_t xdr_gfs3_xattrop_req (XDR *, gfs3_xattrop_req*); -extern bool_t xdr_gfs3_xattrop_rsp (XDR *, gfs3_xattrop_rsp*); -extern bool_t xdr_gfs3_fxattrop_req (XDR *, gfs3_fxattrop_req*); -extern bool_t xdr_gfs3_fxattrop_rsp (XDR *, gfs3_fxattrop_rsp*); -extern bool_t xdr_gfs3_getxattr_req (XDR *, gfs3_getxattr_req*); -extern bool_t xdr_gfs3_getxattr_rsp (XDR *, gfs3_getxattr_rsp*); -extern bool_t xdr_gfs3_fgetxattr_req (XDR *, gfs3_fgetxattr_req*); -extern bool_t xdr_gfs3_fgetxattr_rsp (XDR *, gfs3_fgetxattr_rsp*); -extern bool_t xdr_gfs3_removexattr_req (XDR *, gfs3_removexattr_req*); -extern bool_t xdr_gfs3_fremovexattr_req (XDR *, gfs3_fremovexattr_req*); -extern bool_t xdr_gfs3_opendir_req (XDR *, gfs3_opendir_req*); -extern bool_t xdr_gfs3_opendir_rsp (XDR *, gfs3_opendir_rsp*); -extern bool_t xdr_gfs3_fsyncdir_req (XDR *, gfs3_fsyncdir_req*); -extern bool_t xdr_gfs3_readdir_req (XDR *, gfs3_readdir_req*); -extern bool_t xdr_gfs3_readdirp_req (XDR *, gfs3_readdirp_req*); -extern bool_t xdr_gfs3_access_req (XDR *, gfs3_access_req*); -extern bool_t xdr_gfs3_create_req (XDR *, gfs3_create_req*); -extern bool_t xdr_gfs3_create_rsp (XDR *, gfs3_create_rsp*); -extern bool_t xdr_gfs3_ftruncate_req (XDR *, gfs3_ftruncate_req*); -extern bool_t xdr_gfs3_ftruncate_rsp (XDR *, gfs3_ftruncate_rsp*); -extern bool_t xdr_gfs3_fstat_req (XDR *, gfs3_fstat_req*); -extern bool_t xdr_gfs3_fstat_rsp (XDR *, gfs3_fstat_rsp*); -extern bool_t xdr_gfs3_entrylk_req (XDR *, gfs3_entrylk_req*); -extern bool_t xdr_gfs3_fentrylk_req (XDR *, gfs3_fentrylk_req*); -extern bool_t xdr_gfs3_setattr_req (XDR *, gfs3_setattr_req*); -extern bool_t xdr_gfs3_setattr_rsp (XDR *, gfs3_setattr_rsp*); -extern bool_t xdr_gfs3_fsetattr_req (XDR *, gfs3_fsetattr_req*); -extern bool_t xdr_gfs3_fsetattr_rsp (XDR *, gfs3_fsetattr_rsp*); -extern bool_t xdr_gfs3_fallocate_req (XDR *, gfs3_fallocate_req*); -extern bool_t xdr_gfs3_fallocate_rsp (XDR *, gfs3_fallocate_rsp*); -extern bool_t xdr_gfs3_discard_req (XDR *, gfs3_discard_req*); -extern bool_t xdr_gfs3_discard_rsp (XDR *, gfs3_discard_rsp*); -extern bool_t xdr_gfs3_zerofill_req (XDR *, gfs3_zerofill_req*); -extern bool_t xdr_gfs3_zerofill_rsp (XDR *, gfs3_zerofill_rsp*); -extern bool_t xdr_gfs3_rchecksum_req (XDR *, gfs3_rchecksum_req*); -extern bool_t xdr_gfs3_rchecksum_rsp (XDR *, gfs3_rchecksum_rsp*); -extern bool_t xdr_gf_setvolume_req (XDR *, gf_setvolume_req*); -extern bool_t xdr_gf_setvolume_rsp (XDR *, gf_setvolume_rsp*); -extern bool_t xdr_gf_getspec_req (XDR *, gf_getspec_req*); -extern bool_t xdr_gf_getspec_rsp (XDR *, gf_getspec_rsp*); -extern bool_t xdr_gf_mgmt_hndsk_req (XDR *, gf_mgmt_hndsk_req*); -extern bool_t xdr_gf_mgmt_hndsk_rsp (XDR *, gf_mgmt_hndsk_rsp*); -extern bool_t xdr_gf_log_req (XDR *, gf_log_req*); -extern bool_t xdr_gf_notify_req (XDR *, gf_notify_req*); -extern bool_t xdr_gf_notify_rsp (XDR *, gf_notify_rsp*); -extern bool_t xdr_gfs3_releasedir_req (XDR *, gfs3_releasedir_req*); -extern bool_t xdr_gfs3_release_req (XDR *, gfs3_release_req*); -extern bool_t xdr_gf_common_rsp (XDR *, gf_common_rsp*); -extern bool_t xdr_gfs3_dirlist (XDR *, gfs3_dirlist*); -extern bool_t xdr_gfs3_readdir_rsp (XDR *, gfs3_readdir_rsp*); -extern bool_t xdr_gfs3_dirplist (XDR *, gfs3_dirplist*); -extern bool_t xdr_gfs3_readdirp_rsp (XDR *, gfs3_readdirp_rsp*); -extern bool_t xdr_gf_set_lk_ver_rsp (XDR *, gf_set_lk_ver_rsp*); -extern bool_t xdr_gf_set_lk_ver_req (XDR *, gf_set_lk_ver_req*); -extern bool_t xdr_gf_event_notify_req (XDR *, gf_event_notify_req*); -extern bool_t xdr_gf_event_notify_rsp (XDR *, gf_event_notify_rsp*); - -#else /* K&R C */ -extern bool_t xdr_gf_statfs (); -extern bool_t xdr_gf_proto_flock (); -extern bool_t xdr_gf_iatt (); -extern bool_t xdr_gfs3_stat_req (); -extern bool_t xdr_gfs3_stat_rsp (); -extern bool_t xdr_gfs3_readlink_req (); -extern bool_t xdr_gfs3_readlink_rsp (); -extern bool_t xdr_gfs3_mknod_req (); -extern bool_t xdr_gfs3_mknod_rsp (); -extern bool_t xdr_gfs3_mkdir_req (); -extern bool_t xdr_gfs3_mkdir_rsp (); -extern bool_t xdr_gfs3_unlink_req (); -extern bool_t xdr_gfs3_unlink_rsp (); -extern bool_t xdr_gfs3_rmdir_req (); -extern bool_t xdr_gfs3_rmdir_rsp (); -extern bool_t xdr_gfs3_symlink_req (); -extern bool_t xdr_gfs3_symlink_rsp (); -extern bool_t xdr_gfs3_rename_req (); -extern bool_t xdr_gfs3_rename_rsp (); -extern bool_t xdr_gfs3_link_req (); -extern bool_t xdr_gfs3_link_rsp (); -extern bool_t xdr_gfs3_truncate_req (); -extern bool_t xdr_gfs3_truncate_rsp (); -extern bool_t xdr_gfs3_open_req (); -extern bool_t xdr_gfs3_open_rsp (); -extern bool_t xdr_gfs3_read_req (); -extern bool_t xdr_gfs3_read_rsp (); -extern bool_t xdr_gfs3_lookup_req (); -extern bool_t xdr_gfs3_lookup_rsp (); -extern bool_t xdr_gfs3_write_req (); -extern bool_t xdr_gfs3_write_rsp (); -extern bool_t xdr_gfs3_statfs_req (); -extern bool_t xdr_gfs3_statfs_rsp (); -extern bool_t xdr_gfs3_lk_req (); -extern bool_t xdr_gfs3_lk_rsp (); -extern bool_t xdr_gfs3_inodelk_req (); -extern bool_t xdr_gfs3_finodelk_req (); -extern bool_t xdr_gfs3_flush_req (); -extern bool_t xdr_gfs3_fsync_req (); -extern bool_t xdr_gfs3_fsync_rsp (); -extern bool_t xdr_gfs3_setxattr_req (); -extern bool_t xdr_gfs3_fsetxattr_req (); -extern bool_t xdr_gfs3_xattrop_req (); -extern bool_t xdr_gfs3_xattrop_rsp (); -extern bool_t xdr_gfs3_fxattrop_req (); -extern bool_t xdr_gfs3_fxattrop_rsp (); -extern bool_t xdr_gfs3_getxattr_req (); -extern bool_t xdr_gfs3_getxattr_rsp (); -extern bool_t xdr_gfs3_fgetxattr_req (); -extern bool_t xdr_gfs3_fgetxattr_rsp (); -extern bool_t xdr_gfs3_removexattr_req (); -extern bool_t xdr_gfs3_fremovexattr_req (); -extern bool_t xdr_gfs3_opendir_req (); -extern bool_t xdr_gfs3_opendir_rsp (); -extern bool_t xdr_gfs3_fsyncdir_req (); -extern bool_t xdr_gfs3_readdir_req (); -extern bool_t xdr_gfs3_readdirp_req (); -extern bool_t xdr_gfs3_access_req (); -extern bool_t xdr_gfs3_create_req (); -extern bool_t xdr_gfs3_create_rsp (); -extern bool_t xdr_gfs3_ftruncate_req (); -extern bool_t xdr_gfs3_ftruncate_rsp (); -extern bool_t xdr_gfs3_fstat_req (); -extern bool_t xdr_gfs3_fstat_rsp (); -extern bool_t xdr_gfs3_entrylk_req (); -extern bool_t xdr_gfs3_fentrylk_req (); -extern bool_t xdr_gfs3_setattr_req (); -extern bool_t xdr_gfs3_setattr_rsp (); -extern bool_t xdr_gfs3_fsetattr_req (); -extern bool_t xdr_gfs3_fsetattr_rsp (); -extern bool_t xdr_gfs3_fallocate_req (); -extern bool_t xdr_gfs3_fallocate_rsp (); -extern bool_t xdr_gfs3_discard_req (); -extern bool_t xdr_gfs3_discard_rsp (); -extern bool_t xdr_gfs3_zerofill_req (); -extern bool_t xdr_gfs3_zerofill_rsp (); -extern bool_t xdr_gfs3_rchecksum_req (); -extern bool_t xdr_gfs3_rchecksum_rsp (); -extern bool_t xdr_gf_setvolume_req (); -extern bool_t xdr_gf_setvolume_rsp (); -extern bool_t xdr_gf_getspec_req (); -extern bool_t xdr_gf_getspec_rsp (); -extern bool_t xdr_gf_mgmt_hndsk_req (); -extern bool_t xdr_gf_mgmt_hndsk_rsp (); -extern bool_t xdr_gf_log_req (); -extern bool_t xdr_gf_notify_req (); -extern bool_t xdr_gf_notify_rsp (); -extern bool_t xdr_gfs3_releasedir_req (); -extern bool_t xdr_gfs3_release_req (); -extern bool_t xdr_gf_common_rsp (); -extern bool_t xdr_gfs3_dirlist (); -extern bool_t xdr_gfs3_readdir_rsp (); -extern bool_t xdr_gfs3_dirplist (); -extern bool_t xdr_gfs3_readdirp_rsp (); -extern bool_t xdr_gf_set_lk_ver_rsp (); -extern bool_t xdr_gf_set_lk_ver_req (); -extern bool_t xdr_gf_event_notify_req (); -extern bool_t xdr_gf_event_notify_rsp (); - -#endif /* K&R C */ - -#ifdef __cplusplus -} -#endif - -#endif /* !_GLUSTERFS3_XDR_H_RPCGEN */ diff --git a/rpc/xdr/src/nlm4-xdr.c b/rpc/xdr/src/nlm4-xdr.c deleted file mode 100644 index caba05f58..000000000 --- a/rpc/xdr/src/nlm4-xdr.c +++ /dev/null @@ -1,245 +0,0 @@ -/* - Copyright (c) 2007-2012 Red Hat, Inc. - This file is part of GlusterFS. - - This file is licensed to you under your choice of the GNU Lesser - General Public License, version 3 or any later version (LGPLv3 or - later), or the GNU General Public License, version 2 (GPLv2), in all - cases as published by the Free Software Foundation. -*/ - -/* - * Please do not edit this file. - * It was generated using rpcgen. - */ - -#include "nlm4-xdr.h" - -bool_t -xdr_netobj (XDR *xdrs, netobj *objp) -{ - if (!xdr_bytes (xdrs, (char **)&objp->n_bytes, (u_int *) &objp->n_len, MAXNETOBJ_SZ)) - return FALSE; - return TRUE; -} - -bool_t -xdr_fsh_mode (XDR *xdrs, fsh_mode *objp) -{ - if (!xdr_enum (xdrs, (enum_t *) objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_fsh_access (XDR *xdrs, fsh_access *objp) -{ - if (!xdr_enum (xdrs, (enum_t *) objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_nlm4_stats (XDR *xdrs, nlm4_stats *objp) -{ - if (!xdr_enum (xdrs, (enum_t *) objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_nlm4_stat (XDR *xdrs, nlm4_stat *objp) -{ - if (!xdr_nlm4_stats (xdrs, &objp->stat)) - return FALSE; - return TRUE; -} - -bool_t -xdr_nlm4_holder (XDR *xdrs, nlm4_holder *objp) -{ - if (!xdr_bool (xdrs, &objp->exclusive)) - return FALSE; - if (!xdr_uint32_t (xdrs, &objp->svid)) - return FALSE; - if (!xdr_netobj (xdrs, &objp->oh)) - return FALSE; - if (!xdr_uint64_t (xdrs, &objp->l_offset)) - return FALSE; - if (!xdr_uint64_t (xdrs, &objp->l_len)) - return FALSE; - return TRUE; -} - -bool_t -xdr_nlm4_lock (XDR *xdrs, nlm4_lock *objp) -{ - if (!xdr_string (xdrs, &objp->caller_name, MAXNAMELEN)) - return FALSE; - if (!xdr_netobj (xdrs, &objp->fh)) - return FALSE; - if (!xdr_netobj (xdrs, &objp->oh)) - return FALSE; - if (!xdr_uint32_t (xdrs, &objp->svid)) - return FALSE; - if (!xdr_uint64_t (xdrs, &objp->l_offset)) - return FALSE; - if (!xdr_uint64_t (xdrs, &objp->l_len)) - return FALSE; - return TRUE; -} - -bool_t -xdr_nlm4_share (XDR *xdrs, nlm4_share *objp) -{ - if (!xdr_string (xdrs, &objp->caller_name, MAXNAMELEN)) - return FALSE; - if (!xdr_netobj (xdrs, &objp->fh)) - return FALSE; - if (!xdr_netobj (xdrs, &objp->oh)) - return FALSE; - if (!xdr_fsh_mode (xdrs, &objp->mode)) - return FALSE; - if (!xdr_fsh_access (xdrs, &objp->access)) - return FALSE; - return TRUE; -} - -bool_t -xdr_nlm4_testrply (XDR *xdrs, nlm4_testrply *objp) -{ - if (!xdr_nlm4_stats (xdrs, &objp->stat)) - return FALSE; - switch (objp->stat) { - case nlm4_denied: - if (!xdr_nlm4_holder (xdrs, &objp->nlm4_testrply_u.holder)) - return FALSE; - break; - default: - break; - } - return TRUE; -} - -bool_t -xdr_nlm4_testres (XDR *xdrs, nlm4_testres *objp) -{ - if (!xdr_netobj (xdrs, &objp->cookie)) - return FALSE; - if (!xdr_nlm4_testrply (xdrs, &objp->stat)) - return FALSE; - return TRUE; -} - -bool_t -xdr_nlm4_testargs (XDR *xdrs, nlm4_testargs *objp) -{ - if (!xdr_netobj (xdrs, &objp->cookie)) - return FALSE; - if (!xdr_bool (xdrs, &objp->exclusive)) - return FALSE; - if (!xdr_nlm4_lock (xdrs, &objp->alock)) - return FALSE; - return TRUE; -} - -bool_t -xdr_nlm4_res (XDR *xdrs, nlm4_res *objp) -{ - if (!xdr_netobj (xdrs, &objp->cookie)) - return FALSE; - if (!xdr_nlm4_stat (xdrs, &objp->stat)) - return FALSE; - return TRUE; -} - -bool_t -xdr_nlm4_lockargs (XDR *xdrs, nlm4_lockargs *objp) -{ - if (!xdr_netobj (xdrs, &objp->cookie)) - return FALSE; - if (!xdr_bool (xdrs, &objp->block)) - return FALSE; - if (!xdr_bool (xdrs, &objp->exclusive)) - return FALSE; - if (!xdr_nlm4_lock (xdrs, &objp->alock)) - return FALSE; - if (!xdr_bool (xdrs, &objp->reclaim)) - return FALSE; - if (!xdr_int (xdrs, &objp->state)) - return FALSE; - return TRUE; -} - -bool_t -xdr_nlm4_cancargs (XDR *xdrs, nlm4_cancargs *objp) -{ - if (!xdr_netobj (xdrs, &objp->cookie)) - return FALSE; - if (!xdr_bool (xdrs, &objp->block)) - return FALSE; - if (!xdr_bool (xdrs, &objp->exclusive)) - return FALSE; - if (!xdr_nlm4_lock (xdrs, &objp->alock)) - return FALSE; - return TRUE; -} - -bool_t -xdr_nlm4_unlockargs (XDR *xdrs, nlm4_unlockargs *objp) -{ - if (!xdr_netobj (xdrs, &objp->cookie)) - return FALSE; - if (!xdr_nlm4_lock (xdrs, &objp->alock)) - return FALSE; - return TRUE; -} - -bool_t -xdr_nlm4_shareargs (XDR *xdrs, nlm4_shareargs *objp) -{ - if (!xdr_netobj (xdrs, &objp->cookie)) - return FALSE; - if (!xdr_nlm4_share (xdrs, &objp->share)) - return FALSE; - if (!xdr_bool (xdrs, &objp->reclaim)) - return FALSE; - return TRUE; -} - -bool_t -xdr_nlm4_shareres (XDR *xdrs, nlm4_shareres *objp) -{ - if (!xdr_netobj (xdrs, &objp->cookie)) - return FALSE; - if (!xdr_nlm4_stats (xdrs, &objp->stat)) - return FALSE; - if (!xdr_int (xdrs, &objp->sequence)) - return FALSE; - return TRUE; -} - -bool_t -xdr_nlm4_freeallargs (XDR *xdrs, nlm4_freeallargs *objp) -{ - if (!xdr_string (xdrs, &objp->name, LM_MAXSTRLEN)) - return FALSE; - if (!xdr_uint32_t (xdrs, &objp->state)) - return FALSE; - return TRUE; -} - - -/* -bool_t -xdr_nlm_sm_status (XDR *xdrs, nlm_sm_status *objp) -{ - if (!xdr_string (xdrs, &objp->mon_name, LM_MAXSTRLEN)) - return FALSE; - if (!xdr_int (xdrs, &objp->state)) - return FALSE; - if (!xdr_opaque (xdrs, objp->priv, 16)) - return FALSE; - return TRUE; -} -*/ diff --git a/rpc/xdr/src/nlm4-xdr.h b/rpc/xdr/src/nlm4-xdr.h deleted file mode 100644 index 8545694a6..000000000 --- a/rpc/xdr/src/nlm4-xdr.h +++ /dev/null @@ -1,260 +0,0 @@ -/* - Copyright (c) 2007-2012 Red Hat, Inc. - This file is part of GlusterFS. - - This file is licensed to you under your choice of the GNU Lesser - General Public License, version 3 or any later version (LGPLv3 or - later), or the GNU General Public License, version 2 (GPLv2), in all - cases as published by the Free Software Foundation. -*/ - -/* - * Please do not edit this file. - * It was generated using rpcgen. - */ - -#ifndef _NLM_H_RPCGEN -#define _NLM_H_RPCGEN - -#include -#include "xdr-common.h" - -#ifdef __cplusplus -extern "C" { -#endif - -#define MAXNETOBJ_SZ 1024 -#define LM_MAXSTRLEN 1024 -#define MAXNAMELEN 1025 - -#if defined(GF_DARWIN_HOST_OS) -#define xdr_u_quad_t xdr_u_int64_t -#define xdr_quad_t xdr_int64_t -#define xdr_uint32_t xdr_u_int32_t -#define xdr_uint64_t xdr_u_int64_t -#define uint64_t u_int64_t -#endif - -#if defined(__NetBSD__) -#define xdr_u_quad_t xdr_u_int64_t -#define xdr_quad_t xdr_int64_t -#define xdr_uint32_t xdr_u_int32_t -#define xdr_uint64_t xdr_u_int64_t -#endif - -/* - * The following enums are actually bit encoded for efficient - * boolean algebra.... DON'T change them..... - */ - -enum fsh_mode { - fsm_DN = 0, - fsm_DR = 1, - fsm_DW = 2, - fsm_DRW = 3, -}; -typedef enum fsh_mode fsh_mode; - -enum fsh_access { - fsa_NONE = 0, - fsa_R = 1, - fsa_W = 2, - fsa_RW = 3, -}; -typedef enum fsh_access fsh_access; -/* definitions for NLM version 4 */ - -enum nlm4_stats { - nlm4_granted = 0, - nlm4_denied = 1, - nlm4_denied_nolock = 2, - nlm4_blocked = 3, - nlm4_denied_grace_period = 4, - nlm4_deadlck = 5, - nlm4_rofs = 6, - nlm4_stale_fh = 7, - nlm4_fbig = 8, - nlm4_failed = 9, -}; -typedef enum nlm4_stats nlm4_stats; - -struct nlm4_stat { - nlm4_stats stat; -}; -typedef struct nlm4_stat nlm4_stat; - -struct nlm4_holder { - bool_t exclusive; - u_int32_t svid; - netobj oh; - u_int64_t l_offset; - u_int64_t l_len; -}; -typedef struct nlm4_holder nlm4_holder; - -struct nlm4_lock { - char *caller_name; - netobj fh; - netobj oh; - u_int32_t svid; - u_int64_t l_offset; - u_int64_t l_len; -}; -typedef struct nlm4_lock nlm4_lock; - -struct nlm4_share { - char *caller_name; - netobj fh; - netobj oh; - fsh_mode mode; - fsh_access access; -}; -typedef struct nlm4_share nlm4_share; - -struct nlm4_testrply { - nlm4_stats stat; - union { - struct nlm4_holder holder; - } nlm4_testrply_u; -}; -typedef struct nlm4_testrply nlm4_testrply; - -struct nlm4_testres { - netobj cookie; - nlm4_testrply stat; -}; -typedef struct nlm4_testres nlm4_testres; - -struct nlm4_testargs { - netobj cookie; - bool_t exclusive; - struct nlm4_lock alock; -}; -typedef struct nlm4_testargs nlm4_testargs; - -struct nlm4_res { - netobj cookie; - nlm4_stat stat; -}; -typedef struct nlm4_res nlm4_res; - -struct nlm4_lockargs { - netobj cookie; - bool_t block; - bool_t exclusive; - struct nlm4_lock alock; - bool_t reclaim; - int state; -}; -typedef struct nlm4_lockargs nlm4_lockargs; - -struct nlm4_cancargs { - netobj cookie; - bool_t block; - bool_t exclusive; - struct nlm4_lock alock; -}; -typedef struct nlm4_cancargs nlm4_cancargs; - -struct nlm4_unlockargs { - netobj cookie; - struct nlm4_lock alock; -}; -typedef struct nlm4_unlockargs nlm4_unlockargs; - -struct nlm4_shareargs { - netobj cookie; - nlm4_share share; - bool_t reclaim; -}; -typedef struct nlm4_shareargs nlm4_shareargs; - -struct nlm4_shareres { - netobj cookie; - nlm4_stats stat; - int sequence; -}; -typedef struct nlm4_shareres nlm4_shareres; - -struct nlm4_freeallargs { - char *name; - u_int32_t state; -}; -typedef struct nlm4_freeallargs nlm4_freeallargs; - - -#define NLM4_NULL 0 -#define NLM4_TEST 1 -#define NLM4_LOCK 2 -#define NLM4_CANCEL 3 -#define NLM4_UNLOCK 4 -#define NLM4_GRANTED 5 -#define NLM4_TEST_MSG 6 -#define NLM4_LOCK_MSG 7 -#define NLM4_CANCEL_MSG 8 -#define NLM4_UNLOCK_MSG 9 -#define NLM4_GRANTED_MSG 10 -#define NLM4_TEST_RES 11 -#define NLM4_LOCK_RES 12 -#define NLM4_CANCEL_RES 13 -#define NLM4_UNLOCK_RES 14 -#define NLM4_GRANTED_RES 15 -#define NLM4_SM_NOTIFY 16 -#define NLM4_SEVENTEEN 17 -#define NLM4_EIGHTEEN 18 -#define NLM4_NINETEEN 19 -#define NLM4_SHARE 20 -#define NLM4_UNSHARE 21 -#define NLM4_NM_LOCK 22 -#define NLM4_FREE_ALL 23 -#define NLM4_PROC_COUNT 24 - -/* the xdr functions */ - -#if defined(__STDC__) || defined(__cplusplus) -extern bool_t xdr_netobj (XDR *, netobj*); -extern bool_t xdr_fsh_mode (XDR *, fsh_mode*); -extern bool_t xdr_fsh_access (XDR *, fsh_access*); -extern bool_t xdr_nlm4_stats (XDR *, nlm4_stats*); -extern bool_t xdr_nlm4_stat (XDR *, nlm4_stat*); -extern bool_t xdr_nlm4_holder (XDR *, nlm4_holder*); -extern bool_t xdr_nlm4_lock (XDR *, nlm4_lock*); -extern bool_t xdr_nlm4_share (XDR *, nlm4_share*); -extern bool_t xdr_nlm4_testrply (XDR *, nlm4_testrply*); -extern bool_t xdr_nlm4_testres (XDR *, nlm4_testres*); -extern bool_t xdr_nlm4_testargs (XDR *, nlm4_testargs*); -extern bool_t xdr_nlm4_res (XDR *, nlm4_res*); -extern bool_t xdr_nlm4_lockargs (XDR *, nlm4_lockargs*); -extern bool_t xdr_nlm4_cancargs (XDR *, nlm4_cancargs*); -extern bool_t xdr_nlm4_unlockargs (XDR *, nlm4_unlockargs*); -extern bool_t xdr_nlm4_shareargs (XDR *, nlm4_shareargs*); -extern bool_t xdr_nlm4_shareres (XDR *, nlm4_shareres*); -extern bool_t xdr_nlm4_freeallargs (XDR *, nlm4_freeallargs*); - -#else /* K&R C */ -extern bool_t xdr_netobj (); -extern bool_t xdr_fsh_mode (); -extern bool_t xdr_fsh_access (); -extern bool_t xdr_nlm4_stats (); -extern bool_t xdr_nlm4_stat (); -extern bool_t xdr_nlm4_holder (); -extern bool_t xdr_nlm4_lock (); -extern bool_t xdr_nlm4_share (); -extern bool_t xdr_nlm4_testrply (); -extern bool_t xdr_nlm4_testres (); -extern bool_t xdr_nlm4_testargs (); -extern bool_t xdr_nlm4_res (); -extern bool_t xdr_nlm4_lockargs (); -extern bool_t xdr_nlm4_cancargs (); -extern bool_t xdr_nlm4_unlockargs (); -extern bool_t xdr_nlm4_shareargs (); -extern bool_t xdr_nlm4_shareres (); -extern bool_t xdr_nlm4_freeallargs (); - -#endif /* K&R C */ - -#ifdef __cplusplus -} -#endif - -#endif /* !_NLM_H_RPCGEN */ diff --git a/rpc/xdr/src/nlm4-xdr.x b/rpc/xdr/src/nlm4-xdr.x new file mode 100644 index 000000000..e2be3b7f0 --- /dev/null +++ b/rpc/xdr/src/nlm4-xdr.x @@ -0,0 +1,160 @@ +/* + Copyright (c) 2007-2012 Red Hat, Inc. + This file is part of GlusterFS. + + This file is licensed to you under your choice of the GNU Lesser + General Public License, version 3 or any later version (LGPLv3 or + later), or the GNU General Public License, version 2 (GPLv2), in all + cases as published by the Free Software Foundation. +*/ + +/* .x file defined as according to the RFC */ + +const MAXNETOBJ_SZ = 1024; +const LM_MAXSTRLEN = 1024; +const MAXNAMELEN = 1025; + +typedef opaque nlm4_netobj; + +#ifdef RPC_HDR +%/* +% * The following enums are actually bit encoded for efficient +% * boolean algebra.... DON'T change them..... +% */ +#endif +enum fsh_mode { + fsm_DN = 0, /* deny none */ + fsm_DR = 1, /* deny read */ + fsm_DW = 2, /* deny write */ + fsm_DRW = 3 /* deny read/write */ +}; + +enum fsh_access { + fsa_NONE = 0, /* for completeness */ + fsa_R = 1, /* read only */ + fsa_W = 2, /* write only */ + fsa_RW = 3 /* read/write */ +}; + +#ifdef RPC_HDR +%/* definitions for NLM version 4 */ +#endif +enum nlm4_stats { + nlm4_granted = 0, + nlm4_denied = 1, + nlm4_denied_nolock = 2, + nlm4_blocked = 3, + nlm4_denied_grace_period = 4, + nlm4_deadlck = 5, + nlm4_rofs = 6, + nlm4_stale_fh = 7, + nlm4_fbig = 8, + nlm4_failed = 9 +}; + +struct nlm4_stat { + nlm4_stats stat; +}; + +struct nlm4_holder { + bool exclusive; + u_int32_t svid; + nlm4_netobj oh; + u_int64_t l_offset; + u_int64_t l_len; +}; + +struct nlm4_lock { + string caller_name; + nlm4_netobj fh; + nlm4_netobj oh; + u_int32_t svid; + u_int64_t l_offset; + u_int64_t l_len; +}; + +struct nlm4_share { + string caller_name; + nlm4_netobj fh; + nlm4_netobj oh; + fsh_mode mode; + fsh_access access; +}; + +union nlm4_testrply switch (nlm4_stats stat) { + case nlm4_denied: + struct nlm4_holder holder; + default: + void; +}; + +struct nlm4_testres { + nlm4_netobj cookie; + nlm4_testrply stat; +}; + +struct nlm4_testargs { + nlm4_netobj cookie; + bool exclusive; + struct nlm4_lock alock; +}; + +struct nlm4_res { + nlm4_netobj cookie; + nlm4_stat stat; +}; + +struct nlm4_lockargs { + nlm4_netobj cookie; + bool block; + bool exclusive; + struct nlm4_lock alock; + bool reclaim; /* used for recovering locks */ + int32_t state; /* specify local status monitor state */ +}; + +struct nlm4_cancargs { + nlm4_netobj cookie; + bool block; + bool exclusive; + struct nlm4_lock alock; +}; + +struct nlm4_unlockargs { + nlm4_netobj cookie; + struct nlm4_lock alock; +}; + +struct nlm4_shareargs { + nlm4_netobj cookie; + nlm4_share share; + bool reclaim; +}; + +struct nlm4_shareres { + nlm4_netobj cookie; + nlm4_stats stat; + int32_t sequence; +}; + +struct nlm4_freeallargs { + string name; /* client hostname */ + uint32_t state; /* unused */ +}; + +/* + * argument for the procedure called by rpc.statd when a monitored host + * status change. + * XXX assumes LM_MAXSTRLEN == SM_MAXSTRLEN + */ +struct nlm_sm_status { + string mon_name; /* name of host */ + int state; /* new state */ + opaque priv[16]; /* private data */ +}; + +program NLMCBK_PROGRAM { + version NLMCBK_V1 { + void NLMCBK_SM_NOTIFY(struct nlm_sm_status) = 16; + } = 1; +} = 100021; diff --git a/rpc/xdr/src/nlm4.x b/rpc/xdr/src/nlm4.x deleted file mode 100644 index e22ac99f2..000000000 --- a/rpc/xdr/src/nlm4.x +++ /dev/null @@ -1,154 +0,0 @@ -/* - Copyright (c) 2007-2012 Red Hat, Inc. - This file is part of GlusterFS. - - This file is licensed to you under your choice of the GNU Lesser - General Public License, version 3 or any later version (LGPLv3 or - later), or the GNU General Public License, version 2 (GPLv2), in all - cases as published by the Free Software Foundation. -*/ - -/* .x file defined as according to the RFC */ - -const MAXNETOBJ_SZ = 1024; -const LM_MAXSTRLEN = 1024; -const MAXNAMELEN = 1025; - -typedef opaque netobj; - -#ifdef RPC_HDR -%/* -% * The following enums are actually bit encoded for efficient -% * boolean algebra.... DON'T change them..... -% */ -#endif -enum fsh_mode { - fsm_DN = 0, /* deny none */ - fsm_DR = 1, /* deny read */ - fsm_DW = 2, /* deny write */ - fsm_DRW = 3 /* deny read/write */ -}; - -enum fsh_access { - fsa_NONE = 0, /* for completeness */ - fsa_R = 1, /* read only */ - fsa_W = 2, /* write only */ - fsa_RW = 3 /* read/write */ -}; - -#ifdef RPC_HDR -%/* definitions for NLM version 4 */ -#endif -enum nlm4_stats { - nlm4_granted = 0, - nlm4_denied = 1, - nlm4_denied_nolock = 2, - nlm4_blocked = 3, - nlm4_denied_grace_period = 4, - nlm4_deadlck = 5, - nlm4_rofs = 6, - nlm4_stale_fh = 7, - nlm4_fbig = 8, - nlm4_failed = 9 -}; - -struct nlm4_stat { - nlm4_stats stat; -}; - -struct nlm4_holder { - bool exclusive; - u_int32_t svid; - netobj oh; - u_int64_t l_offset; - u_int64_t l_len; -}; - -struct nlm4_lock { - string caller_name; - netobj fh; - netobj oh; - u_int32_t svid; - u_int64_t l_offset; - u_int64_t l_len; -}; - -struct nlm4_share { - string caller_name; - netobj fh; - netobj oh; - fsh_mode mode; - fsh_access access; -}; - -union nlm4_testrply switch (nlm4_stats stat) { - case nlm_denied: - struct nlm4_holder holder; - default: - void; -}; - -struct nlm4_testres { - netobj cookie; - nlm4_testrply stat; -}; - -struct nlm4_testargs { - netobj cookie; - bool exclusive; - struct nlm4_lock alock; -}; - -struct nlm4_res { - netobj cookie; - nlm4_stat stat; -}; - -struct nlm4_lockargs { - netobj cookie; - bool block; - bool exclusive; - struct nlm4_lock alock; - bool reclaim; /* used for recovering locks */ - int state; /* specify local status monitor state */ -}; - -struct nlm4_cancargs { - netobj cookie; - bool block; - bool exclusive; - struct nlm4_lock alock; -}; - -struct nlm4_unlockargs { - netobj cookie; - struct nlm4_lock alock; -}; - -struct nlm4_shareargs { - netobj cookie; - nlm4_share share; - bool reclaim; -}; - -struct nlm4_shareres { - netobj cookie; - nlm4_stats stat; - int sequence; -}; - -struct nlm4_freeallargs { - string name; /* client hostname */ - uint32 state; /* unused */ -}; - -/* - * argument for the procedure called by rpc.statd when a monitored host - * status change. - * XXX assumes LM_MAXSTRLEN == SM_MAXSTRLEN - */ -struct nlm_sm_status { - string mon_name; /* name of host */ - int state; /* new state */ - opaque priv[16]; /* private data */ -}; diff --git a/rpc/xdr/src/nlmcbk-xdr.c b/rpc/xdr/src/nlmcbk-xdr.c deleted file mode 100644 index 3d75acc55..000000000 --- a/rpc/xdr/src/nlmcbk-xdr.c +++ /dev/null @@ -1,28 +0,0 @@ -/* - Copyright (c) 2007-2012 Red Hat, Inc. - This file is part of GlusterFS. - - This file is licensed to you under your choice of the GNU Lesser - General Public License, version 3 or any later version (LGPLv3 or - later), or the GNU General Public License, version 2 (GPLv2), in all - cases as published by the Free Software Foundation. -*/ - -/* - * Please do not edit this file. - * It was generated using rpcgen. - */ - -#include "nlmcbk-xdr.h" - -bool_t -xdr_nlm_sm_status (XDR *xdrs, nlm_sm_status *objp) -{ - if (!xdr_string (xdrs, &objp->mon_name, LM_MAXSTRLEN)) - return FALSE; - if (!xdr_int (xdrs, &objp->state)) - return FALSE; - if (!xdr_opaque (xdrs, objp->priv, 16)) - return FALSE; - return TRUE; -} diff --git a/rpc/xdr/src/nlmcbk-xdr.h b/rpc/xdr/src/nlmcbk-xdr.h deleted file mode 100644 index ad8421857..000000000 --- a/rpc/xdr/src/nlmcbk-xdr.h +++ /dev/null @@ -1,65 +0,0 @@ -/* - Copyright (c) 2007-2012 Red Hat, Inc. - This file is part of GlusterFS. - - This file is licensed to you under your choice of the GNU Lesser - General Public License, version 3 or any later version (LGPLv3 or - later), or the GNU General Public License, version 2 (GPLv2), in all - cases as published by the Free Software Foundation. -*/ - -/* - * Please do not edit this file. - * It was generated using rpcgen. - */ - -#ifndef _NLMCBK_H_RPCGEN -#define _NLMCBK_H_RPCGEN - -#include - - -#ifdef __cplusplus -extern "C" { -#endif - -#define LM_MAXSTRLEN 1024 - -struct nlm_sm_status { - char *mon_name; - int state; - char priv[16]; -}; -typedef struct nlm_sm_status nlm_sm_status; - -#define NLMCBK_PROGRAM 100021 -#define NLMCBK_V1 1 - -#if defined(__STDC__) || defined(__cplusplus) -#define NLMCBK_SM_NOTIFY 16 -extern void * nlmcbk_sm_notify_0(struct nlm_sm_status *, CLIENT *); -extern void * nlmcbk_sm_notify_0_svc(struct nlm_sm_status *, struct svc_req *); -extern int nlmcbk_program_0_freeresult (SVCXPRT *, xdrproc_t, caddr_t); - -#else /* K&R C */ -#define NLMCBK_SM_NOTIFY 16 -extern void * nlmcbk_sm_notify_0(); -extern void * nlmcbk_sm_notify_0_svc(); -extern int nlmcbk_program_0_freeresult (); -#endif /* K&R C */ - -/* the xdr functions */ - -#if defined(__STDC__) || defined(__cplusplus) -extern bool_t xdr_nlm_sm_status (XDR *, nlm_sm_status*); - -#else /* K&R C */ -extern bool_t xdr_nlm_sm_status (); - -#endif /* K&R C */ - -#ifdef __cplusplus -} -#endif - -#endif /* !_NLMCBK_H_RPCGEN */ diff --git a/rpc/xdr/src/nlmcbk.x b/rpc/xdr/src/nlmcbk.x deleted file mode 100644 index 1d3746c9a..000000000 --- a/rpc/xdr/src/nlmcbk.x +++ /dev/null @@ -1,24 +0,0 @@ -/* - Copyright (c) 2007-2012 Red Hat, Inc. - This file is part of GlusterFS. - - This file is licensed to you under your choice of the GNU Lesser - General Public License, version 3 or any later version (LGPLv3 or - later), or the GNU General Public License, version 2 (GPLv2), in all - cases as published by the Free Software Foundation. -*/ - -const LM_MAXSTRLEN = 1024; - -struct nlm_sm_status { - string mon_name; /* name of host */ - int state; /* new state */ - opaque priv[16]; /* private data */ -}; - -program NLMCBK_PROGRAM { - version NLMCBK_V0 { - void NLMCBK_SM_NOTIFY(struct nlm_sm_status) = 1; - } = 0; -} = 1238477; - diff --git a/rpc/xdr/src/nsm-xdr.c b/rpc/xdr/src/nsm-xdr.c deleted file mode 100644 index 58712737b..000000000 --- a/rpc/xdr/src/nsm-xdr.c +++ /dev/null @@ -1,96 +0,0 @@ -/* - Copyright (c) 2007-2012 Red Hat, Inc. - This file is part of GlusterFS. - - This file is licensed to you under your choice of the GNU Lesser - General Public License, version 3 or any later version (LGPLv3 or - later), or the GNU General Public License, version 2 (GPLv2), in all - cases as published by the Free Software Foundation. -*/ - -/* - * Please do not edit this file. - * It was generated using rpcgen. - */ - -#include "nsm-xdr.h" - -bool_t -xdr_sm_name (XDR *xdrs, sm_name *objp) -{ - if (!xdr_string (xdrs, &objp->mon_name, SM_MAXSTRLEN)) - return FALSE; - return TRUE; -} - -bool_t -xdr_res (XDR *xdrs, res *objp) -{ - if (!xdr_enum (xdrs, (enum_t *) objp)) - return FALSE; - return TRUE; -} - -bool_t -xdr_sm_stat_res (XDR *xdrs, sm_stat_res *objp) -{ - if (!xdr_res (xdrs, &objp->res_stat)) - return FALSE; - if (!xdr_int (xdrs, &objp->state)) - return FALSE; - return TRUE; -} - -bool_t -xdr_sm_stat (XDR *xdrs, sm_stat *objp) -{ - if (!xdr_int (xdrs, &objp->state)) - return FALSE; - return TRUE; -} - -bool_t -xdr_my_id (XDR *xdrs, my_id *objp) -{ - if (!xdr_string (xdrs, &objp->my_name, SM_MAXSTRLEN)) - return FALSE; - if (!xdr_int (xdrs, &objp->my_prog)) - return FALSE; - if (!xdr_int (xdrs, &objp->my_vers)) - return FALSE; - if (!xdr_int (xdrs, &objp->my_proc)) - return FALSE; - return TRUE; -} - -bool_t -xdr_mon_id (XDR *xdrs, mon_id *objp) -{ - if (!xdr_string (xdrs, &objp->mon_name, SM_MAXSTRLEN)) - return FALSE; - if (!xdr_my_id (xdrs, &objp->my_id)) - return FALSE; - return TRUE; -} - -bool_t -xdr_mon (XDR *xdrs, mon *objp) -{ - if (!xdr_mon_id (xdrs, &objp->mon_id)) - return FALSE; - if (!xdr_opaque (xdrs, objp->priv, 16)) - return FALSE; - return TRUE; -} - -bool_t -xdr_nsm_callback_status (XDR *xdrs, nsm_callback_status *objp) -{ - if (!xdr_string (xdrs, &objp->mon_name, SM_MAXSTRLEN)) - return FALSE; - if (!xdr_int (xdrs, &objp->state)) - return FALSE; - if (!xdr_opaque (xdrs, objp->priv, 16)) - return FALSE; - return TRUE; -} diff --git a/rpc/xdr/src/nsm-xdr.h b/rpc/xdr/src/nsm-xdr.h deleted file mode 100644 index 9de642c15..000000000 --- a/rpc/xdr/src/nsm-xdr.h +++ /dev/null @@ -1,95 +0,0 @@ -/* - * Please do not edit this file. - * It was generated using rpcgen. - */ - -#ifndef _NSM_H_RPCGEN -#define _NSM_H_RPCGEN - -#include - - -#ifdef __cplusplus -extern "C" { -#endif - -#define SM_MAXSTRLEN 1024 - -struct sm_name { - char *mon_name; -}; -typedef struct sm_name sm_name; - -enum res { - STAT_SUCC = 0, - STAT_FAIL = 1, -}; -typedef enum res res; - -struct sm_stat_res { - res res_stat; - int state; -}; -typedef struct sm_stat_res sm_stat_res; - -struct sm_stat { - int state; -}; -typedef struct sm_stat sm_stat; - -struct my_id { - char *my_name; - int my_prog; - int my_vers; - int my_proc; -}; -typedef struct my_id my_id; - -struct mon_id { - char *mon_name; - struct my_id my_id; -}; -typedef struct mon_id mon_id; - -struct mon { - struct mon_id mon_id; - char priv[16]; -}; -typedef struct mon mon; - -struct nsm_callback_status { - char *mon_name; - int state; - char priv[16]; -}; -typedef struct nsm_callback_status nsm_callback_status; - -/* the xdr functions */ - -#if defined(__STDC__) || defined(__cplusplus) -extern bool_t xdr_sm_name (XDR *, sm_name*); -extern bool_t xdr_res (XDR *, res*); -extern bool_t xdr_sm_stat_res (XDR *, sm_stat_res*); -extern bool_t xdr_sm_stat (XDR *, sm_stat*); -extern bool_t xdr_my_id (XDR *, my_id*); -extern bool_t xdr_mon_id (XDR *, mon_id*); -extern bool_t xdr_mon (XDR *, mon*); -extern bool_t xdr_nsm_callback_status (XDR *, nsm_callback_status*); - -#else /* K&R C */ -extern bool_t xdr_sm_name (); -extern bool_t xdr_res (); -extern bool_t xdr_sm_stat_res (); -extern bool_t xdr_sm_stat (); -extern bool_t xdr_my_id (); -extern bool_t xdr_mon_id (); -extern bool_t xdr_mon (); -extern bool_t xdr_nsm_callback_status (); - -#endif /* K&R C */ - -#ifdef __cplusplus -} -#endif - -#endif /* !_NSM_H_RPCGEN */ diff --git a/rpc/xdr/src/nsm-xdr.x b/rpc/xdr/src/nsm-xdr.x new file mode 100644 index 000000000..8f97b1aaa --- /dev/null +++ b/rpc/xdr/src/nsm-xdr.x @@ -0,0 +1,47 @@ +/* + * This defines the maximum length of the string + * identifying the caller. + */ +const SM_MAXSTRLEN = 1024; + +struct sm_name { + string mon_name; +}; + +enum res { + STAT_SUCC = 0, /* NSM agrees to monitor. */ + STAT_FAIL = 1 /* NSM cannot monitor. */ +}; + +struct sm_stat_res { + res res_stat; + int state; +}; + +struct sm_stat { + int state; /* state number of NSM */ +}; + +struct my_id { + string my_name; /* hostname */ + int my_prog; /* RPC program number */ + int my_vers; /* program version number */ + int my_proc; /* procedure number */ +}; + +struct mon_id { + string mon_name; /* name of the host to be monitored */ + struct my_id my_id; +}; + +struct mon { + struct mon_id mon_id; + opaque priv[16]; /* private information */ +}; + +struct nsm_callback_status { + string mon_name; + int state; + opaque priv[16]; /* for private information */ +}; + diff --git a/rpc/xdr/src/nsm.x b/rpc/xdr/src/nsm.x deleted file mode 100644 index 8f97b1aaa..000000000 --- a/rpc/xdr/src/nsm.x +++ /dev/null @@ -1,47 +0,0 @@ -/* - * This defines the maximum length of the string - * identifying the caller. - */ -const SM_MAXSTRLEN = 1024; - -struct sm_name { - string mon_name; -}; - -enum res { - STAT_SUCC = 0, /* NSM agrees to monitor. */ - STAT_FAIL = 1 /* NSM cannot monitor. */ -}; - -struct sm_stat_res { - res res_stat; - int state; -}; - -struct sm_stat { - int state; /* state number of NSM */ -}; - -struct my_id { - string my_name; /* hostname */ - int my_prog; /* RPC program number */ - int my_vers; /* program version number */ - int my_proc; /* procedure number */ -}; - -struct mon_id { - string mon_name; /* name of the host to be monitored */ - struct my_id my_id; -}; - -struct mon { - struct mon_id mon_id; - opaque priv[16]; /* private information */ -}; - -struct nsm_callback_status { - string mon_name; - int state; - opaque priv[16]; /* for private information */ -}; - diff --git a/rpc/xdr/src/portmap-xdr.c b/rpc/xdr/src/portmap-xdr.c deleted file mode 100644 index 4766122e6..000000000 --- a/rpc/xdr/src/portmap-xdr.c +++ /dev/null @@ -1,237 +0,0 @@ -/* - Copyright (c) 2007-2012 Red Hat, Inc. - This file is part of GlusterFS. - - This file is licensed to you under your choice of the GNU Lesser - General Public License, version 3 or any later version (LGPLv3 or - later), or the GNU General Public License, version 2 (GPLv2), in all - cases as published by the Free Software Foundation. -*/ - -#include "xdr-common.h" -#include "compat.h" - -#if defined(__GNUC__) -#if __GNUC__ >= 4 -#pragma GCC diagnostic ignored "-Wunused-but-set-variable" -#endif -#endif - -/* - * Please do not edit this file. - * It was generated using rpcgen. - */ - -#include "portmap-xdr.h" - -bool_t -xdr_pmap_port_by_brick_req (XDR *xdrs, pmap_port_by_brick_req *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_string (xdrs, &objp->brick, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_pmap_port_by_brick_rsp (XDR *xdrs, pmap_port_by_brick_rsp *objp) -{ - register int32_t *buf; - buf = NULL; - - - if (xdrs->x_op == XDR_ENCODE) { - buf = XDR_INLINE (xdrs, 4 * BYTES_PER_XDR_UNIT); - if (buf == NULL) { - if (!xdr_int (xdrs, &objp->op_ret)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_errno)) - return FALSE; - if (!xdr_int (xdrs, &objp->status)) - return FALSE; - if (!xdr_int (xdrs, &objp->port)) - return FALSE; - } else { - IXDR_PUT_LONG(buf, objp->op_ret); - IXDR_PUT_LONG(buf, objp->op_errno); - IXDR_PUT_LONG(buf, objp->status); - IXDR_PUT_LONG(buf, objp->port); - } - return TRUE; - } else if (xdrs->x_op == XDR_DECODE) { - buf = XDR_INLINE (xdrs, 4 * BYTES_PER_XDR_UNIT); - if (buf == NULL) { - if (!xdr_int (xdrs, &objp->op_ret)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_errno)) - return FALSE; - if (!xdr_int (xdrs, &objp->status)) - return FALSE; - if (!xdr_int (xdrs, &objp->port)) - return FALSE; - } else { - objp->op_ret = IXDR_GET_LONG(buf); - objp->op_errno = IXDR_GET_LONG(buf); - objp->status = IXDR_GET_LONG(buf); - objp->port = IXDR_GET_LONG(buf); - } - return TRUE; - } - - if (!xdr_int (xdrs, &objp->op_ret)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_errno)) - return FALSE; - if (!xdr_int (xdrs, &objp->status)) - return FALSE; - if (!xdr_int (xdrs, &objp->port)) - return FALSE; - return TRUE; -} - -bool_t -xdr_pmap_brick_by_port_req (XDR *xdrs, pmap_brick_by_port_req *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_int (xdrs, &objp->port)) - return FALSE; - return TRUE; -} - -bool_t -xdr_pmap_brick_by_port_rsp (XDR *xdrs, pmap_brick_by_port_rsp *objp) -{ - register int32_t *buf; - buf = NULL; - - - if (xdrs->x_op == XDR_ENCODE) { - buf = XDR_INLINE (xdrs, 3 * BYTES_PER_XDR_UNIT); - if (buf == NULL) { - if (!xdr_int (xdrs, &objp->op_ret)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_errno)) - return FALSE; - if (!xdr_int (xdrs, &objp->status)) - return FALSE; - - } else { - IXDR_PUT_LONG(buf, objp->op_ret); - IXDR_PUT_LONG(buf, objp->op_errno); - IXDR_PUT_LONG(buf, objp->status); - } - if (!xdr_string (xdrs, &objp->brick, ~0)) - return FALSE; - return TRUE; - } else if (xdrs->x_op == XDR_DECODE) { - buf = XDR_INLINE (xdrs, 3 * BYTES_PER_XDR_UNIT); - if (buf == NULL) { - if (!xdr_int (xdrs, &objp->op_ret)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_errno)) - return FALSE; - if (!xdr_int (xdrs, &objp->status)) - return FALSE; - - } else { - objp->op_ret = IXDR_GET_LONG(buf); - objp->op_errno = IXDR_GET_LONG(buf); - objp->status = IXDR_GET_LONG(buf); - } - if (!xdr_string (xdrs, &objp->brick, ~0)) - return FALSE; - return TRUE; - } - - if (!xdr_int (xdrs, &objp->op_ret)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_errno)) - return FALSE; - if (!xdr_int (xdrs, &objp->status)) - return FALSE; - if (!xdr_string (xdrs, &objp->brick, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_pmap_signup_req (XDR *xdrs, pmap_signup_req *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_string (xdrs, &objp->brick, ~0)) - return FALSE; - if (!xdr_int (xdrs, &objp->port)) - return FALSE; - return TRUE; -} - -bool_t -xdr_pmap_signup_rsp (XDR *xdrs, pmap_signup_rsp *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_int (xdrs, &objp->op_ret)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_errno)) - return FALSE; - return TRUE; -} - -bool_t -xdr_pmap_signin_req (XDR *xdrs, pmap_signin_req *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_string (xdrs, &objp->brick, ~0)) - return FALSE; - if (!xdr_int (xdrs, &objp->port)) - return FALSE; - return TRUE; -} - -bool_t -xdr_pmap_signin_rsp (XDR *xdrs, pmap_signin_rsp *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_int (xdrs, &objp->op_ret)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_errno)) - return FALSE; - return TRUE; -} - -bool_t -xdr_pmap_signout_req (XDR *xdrs, pmap_signout_req *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_string (xdrs, &objp->brick, ~0)) - return FALSE; - if (!xdr_int (xdrs, &objp->port)) - return FALSE; - return TRUE; -} - -bool_t -xdr_pmap_signout_rsp (XDR *xdrs, pmap_signout_rsp *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_int (xdrs, &objp->op_ret)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_errno)) - return FALSE; - return TRUE; -} diff --git a/rpc/xdr/src/portmap-xdr.h b/rpc/xdr/src/portmap-xdr.h deleted file mode 100644 index 8e4ff4f45..000000000 --- a/rpc/xdr/src/portmap-xdr.h +++ /dev/null @@ -1,130 +0,0 @@ -/* - Copyright (c) 2007-2012 Red Hat, Inc. - This file is part of GlusterFS. - - This file is licensed to you under your choice of the GNU Lesser - General Public License, version 3 or any later version (LGPLv3 or - later), or the GNU General Public License, version 2 (GPLv2), in all - cases as published by the Free Software Foundation. -*/ - -#include "xdr-common.h" -#include "compat.h" - -#if defined(__GNUC__) -#if __GNUC__ >= 4 -#pragma GCC diagnostic ignored "-Wunused-but-set-variable" -#endif -#endif - -/* - * Please do not edit this file. - * It was generated using rpcgen. - */ - -#ifndef _PORTMAP_XDR_H_RPCGEN -#define _PORTMAP_XDR_H_RPCGEN - -#include - - -#ifdef __cplusplus -extern "C" { -#endif - - -struct pmap_port_by_brick_req { - char *brick; -}; -typedef struct pmap_port_by_brick_req pmap_port_by_brick_req; - -struct pmap_port_by_brick_rsp { - int op_ret; - int op_errno; - int status; - int port; -}; -typedef struct pmap_port_by_brick_rsp pmap_port_by_brick_rsp; - -struct pmap_brick_by_port_req { - int port; -}; -typedef struct pmap_brick_by_port_req pmap_brick_by_port_req; - -struct pmap_brick_by_port_rsp { - int op_ret; - int op_errno; - int status; - char *brick; -}; -typedef struct pmap_brick_by_port_rsp pmap_brick_by_port_rsp; - -struct pmap_signup_req { - char *brick; - int port; -}; -typedef struct pmap_signup_req pmap_signup_req; - -struct pmap_signup_rsp { - int op_ret; - int op_errno; -}; -typedef struct pmap_signup_rsp pmap_signup_rsp; - -struct pmap_signin_req { - char *brick; - int port; -}; -typedef struct pmap_signin_req pmap_signin_req; - -struct pmap_signin_rsp { - int op_ret; - int op_errno; -}; -typedef struct pmap_signin_rsp pmap_signin_rsp; - -struct pmap_signout_req { - char *brick; - int port; -}; -typedef struct pmap_signout_req pmap_signout_req; - -struct pmap_signout_rsp { - int op_ret; - int op_errno; -}; -typedef struct pmap_signout_rsp pmap_signout_rsp; - -/* the xdr functions */ - -#if defined(__STDC__) || defined(__cplusplus) -extern bool_t xdr_pmap_port_by_brick_req (XDR *, pmap_port_by_brick_req*); -extern bool_t xdr_pmap_port_by_brick_rsp (XDR *, pmap_port_by_brick_rsp*); -extern bool_t xdr_pmap_brick_by_port_req (XDR *, pmap_brick_by_port_req*); -extern bool_t xdr_pmap_brick_by_port_rsp (XDR *, pmap_brick_by_port_rsp*); -extern bool_t xdr_pmap_signup_req (XDR *, pmap_signup_req*); -extern bool_t xdr_pmap_signup_rsp (XDR *, pmap_signup_rsp*); -extern bool_t xdr_pmap_signin_req (XDR *, pmap_signin_req*); -extern bool_t xdr_pmap_signin_rsp (XDR *, pmap_signin_rsp*); -extern bool_t xdr_pmap_signout_req (XDR *, pmap_signout_req*); -extern bool_t xdr_pmap_signout_rsp (XDR *, pmap_signout_rsp*); - -#else /* K&R C */ -extern bool_t xdr_pmap_port_by_brick_req (); -extern bool_t xdr_pmap_port_by_brick_rsp (); -extern bool_t xdr_pmap_brick_by_port_req (); -extern bool_t xdr_pmap_brick_by_port_rsp (); -extern bool_t xdr_pmap_signup_req (); -extern bool_t xdr_pmap_signup_rsp (); -extern bool_t xdr_pmap_signin_req (); -extern bool_t xdr_pmap_signin_rsp (); -extern bool_t xdr_pmap_signout_req (); -extern bool_t xdr_pmap_signout_rsp (); - -#endif /* K&R C */ - -#ifdef __cplusplus -} -#endif - -#endif /* !_PORTMAP_XDR_H_RPCGEN */ diff --git a/rpc/xdr/src/rpc-common-xdr.c b/rpc/xdr/src/rpc-common-xdr.c deleted file mode 100644 index 6cb48a923..000000000 --- a/rpc/xdr/src/rpc-common-xdr.c +++ /dev/null @@ -1,223 +0,0 @@ -/* - Copyright (c) 2007-2012 Red Hat, Inc. - This file is part of GlusterFS. - - This file is licensed to you under your choice of the GNU Lesser - General Public License, version 3 or any later version (LGPLv3 or - later), or the GNU General Public License, version 2 (GPLv2), in all - cases as published by the Free Software Foundation. -*/ - -#include "xdr-common.h" -#include "compat.h" - -#if defined(__GNUC__) -#if __GNUC__ >= 4 -#pragma GCC diagnostic ignored "-Wunused-but-set-variable" -#endif -#endif - -/* - * Please do not edit this file. - * It was generated using rpcgen. - */ - -#include "rpc-common-xdr.h" - -bool_t -xdr_auth_glusterfs_parms_v2 (XDR *xdrs, auth_glusterfs_parms_v2 *objp) -{ - register int32_t *buf; - buf = NULL; - - - if (xdrs->x_op == XDR_ENCODE) { - buf = XDR_INLINE (xdrs, 3 * BYTES_PER_XDR_UNIT); - if (buf == NULL) { - if (!xdr_int (xdrs, &objp->pid)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->uid)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->gid)) - return FALSE; - - } else { - IXDR_PUT_LONG(buf, objp->pid); - IXDR_PUT_U_LONG(buf, objp->uid); - IXDR_PUT_U_LONG(buf, objp->gid); - } - if (!xdr_array (xdrs, (char **)&objp->groups.groups_val, (u_int *) &objp->groups.groups_len, ~0, - sizeof (u_int), (xdrproc_t) xdr_u_int)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->lk_owner.lk_owner_val, (u_int *) &objp->lk_owner.lk_owner_len, ~0)) - return FALSE; - return TRUE; - } else if (xdrs->x_op == XDR_DECODE) { - buf = XDR_INLINE (xdrs, 3 * BYTES_PER_XDR_UNIT); - if (buf == NULL) { - if (!xdr_int (xdrs, &objp->pid)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->uid)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->gid)) - return FALSE; - - } else { - objp->pid = IXDR_GET_LONG(buf); - objp->uid = IXDR_GET_U_LONG(buf); - objp->gid = IXDR_GET_U_LONG(buf); - } - if (!xdr_array (xdrs, (char **)&objp->groups.groups_val, (u_int *) &objp->groups.groups_len, ~0, - sizeof (u_int), (xdrproc_t) xdr_u_int)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->lk_owner.lk_owner_val, (u_int *) &objp->lk_owner.lk_owner_len, ~0)) - return FALSE; - return TRUE; - } - - if (!xdr_int (xdrs, &objp->pid)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->uid)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->gid)) - return FALSE; - if (!xdr_array (xdrs, (char **)&objp->groups.groups_val, (u_int *) &objp->groups.groups_len, ~0, - sizeof (u_int), (xdrproc_t) xdr_u_int)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->lk_owner.lk_owner_val, (u_int *) &objp->lk_owner.lk_owner_len, ~0)) - return FALSE; - return TRUE; -} - -bool_t -xdr_auth_glusterfs_parms (XDR *xdrs, auth_glusterfs_parms *objp) -{ - register int32_t *buf; - int i; - buf = NULL; - - - if (xdrs->x_op == XDR_ENCODE) { - if (!xdr_u_quad_t (xdrs, &objp->lk_owner)) - return FALSE; - buf = XDR_INLINE (xdrs, (4 + 16 )* BYTES_PER_XDR_UNIT); - if (buf == NULL) { - if (!xdr_u_int (xdrs, &objp->pid)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->uid)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->gid)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->ngrps)) - return FALSE; - if (!xdr_vector (xdrs, (char *)objp->groups, 16, - sizeof (u_int), (xdrproc_t) xdr_u_int)) - return FALSE; - } else { - IXDR_PUT_U_LONG(buf, objp->pid); - IXDR_PUT_U_LONG(buf, objp->uid); - IXDR_PUT_U_LONG(buf, objp->gid); - IXDR_PUT_U_LONG(buf, objp->ngrps); - { - register u_int *genp; - - for (i = 0, genp = objp->groups; - i < 16; ++i) { - IXDR_PUT_U_LONG(buf, *genp++); - } - } - } - return TRUE; - } else if (xdrs->x_op == XDR_DECODE) { - if (!xdr_u_quad_t (xdrs, &objp->lk_owner)) - return FALSE; - buf = XDR_INLINE (xdrs, (4 + 16 )* BYTES_PER_XDR_UNIT); - if (buf == NULL) { - if (!xdr_u_int (xdrs, &objp->pid)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->uid)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->gid)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->ngrps)) - return FALSE; - if (!xdr_vector (xdrs, (char *)objp->groups, 16, - sizeof (u_int), (xdrproc_t) xdr_u_int)) - return FALSE; - } else { - objp->pid = IXDR_GET_U_LONG(buf); - objp->uid = IXDR_GET_U_LONG(buf); - objp->gid = IXDR_GET_U_LONG(buf); - objp->ngrps = IXDR_GET_U_LONG(buf); - { - register u_int *genp; - - for (i = 0, genp = objp->groups; - i < 16; ++i) { - *genp++ = IXDR_GET_U_LONG(buf); - } - } - } - return TRUE; - } - - if (!xdr_u_quad_t (xdrs, &objp->lk_owner)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->pid)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->uid)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->gid)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->ngrps)) - return FALSE; - if (!xdr_vector (xdrs, (char *)objp->groups, 16, - sizeof (u_int), (xdrproc_t) xdr_u_int)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gf_dump_req (XDR *xdrs, gf_dump_req *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_u_quad_t (xdrs, &objp->gfs_id)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gf_prog_detail (XDR *xdrs, gf_prog_detail *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_string (xdrs, &objp->progname, ~0)) - return FALSE; - if (!xdr_u_quad_t (xdrs, &objp->prognum)) - return FALSE; - if (!xdr_u_quad_t (xdrs, &objp->progver)) - return FALSE; - if (!xdr_pointer (xdrs, (char **)&objp->next, sizeof (gf_prog_detail), (xdrproc_t) xdr_gf_prog_detail)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gf_dump_rsp (XDR *xdrs, gf_dump_rsp *objp) -{ - register int32_t *buf; - buf = NULL; - - if (!xdr_u_quad_t (xdrs, &objp->gfs_id)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_ret)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_errno)) - return FALSE; - if (!xdr_pointer (xdrs, (char **)&objp->prog, sizeof (gf_prog_detail), (xdrproc_t) xdr_gf_prog_detail)) - return FALSE; - return TRUE; -} diff --git a/rpc/xdr/src/rpc-common-xdr.h b/rpc/xdr/src/rpc-common-xdr.h deleted file mode 100644 index c43eab315..000000000 --- a/rpc/xdr/src/rpc-common-xdr.h +++ /dev/null @@ -1,104 +0,0 @@ -/* - Copyright (c) 2007-2012 Red Hat, Inc. - This file is part of GlusterFS. - - This file is licensed to you under your choice of the GNU Lesser - General Public License, version 3 or any later version (LGPLv3 or - later), or the GNU General Public License, version 2 (GPLv2), in all - cases as published by the Free Software Foundation. -*/ - -#include "xdr-common.h" -#include "compat.h" - -#if defined(__GNUC__) -#if __GNUC__ >= 4 -#pragma GCC diagnostic ignored "-Wunused-but-set-variable" -#endif -#endif - -/* - * Please do not edit this file. - * It was generated using rpcgen. - */ - -#ifndef _RPC_COMMON_XDR_H_RPCGEN -#define _RPC_COMMON_XDR_H_RPCGEN - -#include - - -#ifdef __cplusplus -extern "C" { -#endif - - -struct auth_glusterfs_parms_v2 { - int pid; - u_int uid; - u_int gid; - struct { - u_int groups_len; - u_int *groups_val; - } groups; - struct { - u_int lk_owner_len; - char *lk_owner_val; - } lk_owner; -}; -typedef struct auth_glusterfs_parms_v2 auth_glusterfs_parms_v2; - -struct auth_glusterfs_parms { - u_quad_t lk_owner; - u_int pid; - u_int uid; - u_int gid; - u_int ngrps; - u_int groups[16]; -}; -typedef struct auth_glusterfs_parms auth_glusterfs_parms; - -struct gf_dump_req { - u_quad_t gfs_id; -}; -typedef struct gf_dump_req gf_dump_req; - -struct gf_prog_detail { - char *progname; - u_quad_t prognum; - u_quad_t progver; - struct gf_prog_detail *next; -}; -typedef struct gf_prog_detail gf_prog_detail; - -struct gf_dump_rsp { - u_quad_t gfs_id; - int op_ret; - int op_errno; - struct gf_prog_detail *prog; -}; -typedef struct gf_dump_rsp gf_dump_rsp; - -/* the xdr functions */ - -#if defined(__STDC__) || defined(__cplusplus) -extern bool_t xdr_auth_glusterfs_parms_v2 (XDR *, auth_glusterfs_parms_v2*); -extern bool_t xdr_auth_glusterfs_parms (XDR *, auth_glusterfs_parms*); -extern bool_t xdr_gf_dump_req (XDR *, gf_dump_req*); -extern bool_t xdr_gf_prog_detail (XDR *, gf_prog_detail*); -extern bool_t xdr_gf_dump_rsp (XDR *, gf_dump_rsp*); - -#else /* K&R C */ -extern bool_t xdr_auth_glusterfs_parms_v2 (); -extern bool_t xdr_auth_glusterfs_parms (); -extern bool_t xdr_gf_dump_req (); -extern bool_t xdr_gf_prog_detail (); -extern bool_t xdr_gf_dump_rsp (); - -#endif /* K&R C */ - -#ifdef __cplusplus -} -#endif - -#endif /* !_RPC_COMMON_XDR_H_RPCGEN */ diff --git a/rpc/xdr/src/xdr-generic.h b/rpc/xdr/src/xdr-generic.h index bb3759bbe..2547d7e54 100644 --- a/rpc/xdr/src/xdr-generic.h +++ b/rpc/xdr/src/xdr-generic.h @@ -12,7 +12,6 @@ #define _XDR_GENERIC_H #include -//#include #include #include diff --git a/rpc/xdr/src/xdr-nfs3.c b/rpc/xdr/src/xdr-nfs3.c index a497e9f54..2be83924a 100644 --- a/rpc/xdr/src/xdr-nfs3.c +++ b/rpc/xdr/src/xdr-nfs3.c @@ -12,13 +12,6 @@ #include "mem-pool.h" #include "xdr-common.h" -#if GF_DARWIN_HOST_OS -#define xdr_u_quad_t xdr_u_int64_t -#define xdr_quad_t xdr_int64_t -#define xdr_uint32_t xdr_u_int32_t -#define xdr_uint64_t xdr_u_int64_t -#endif - bool_t xdr_uint64 (XDR *xdrs, uint64 *objp) { @@ -1884,5 +1877,3 @@ xdr_free_write3args_nocopy (write3args *wa) FREE (wa->file.data.data_val); } - - diff --git a/xlators/nfs/server/src/acl3.h b/xlators/nfs/server/src/acl3.h index 03d626f3e..220bc9e78 100644 --- a/xlators/nfs/server/src/acl3.h +++ b/xlators/nfs/server/src/acl3.h @@ -13,6 +13,11 @@ #include "glusterfs-acl.h" +#define ACL3_NULL 0 +#define ACL3_GETACL 1 +#define ACL3_SETACL 2 +#define ACL3_PROC_COUNT 3 + #define GF_ACL3_PORT 38469 #define GF_ACL GF_NFS"-ACL" diff --git a/xlators/nfs/server/src/nlm4.c b/xlators/nfs/server/src/nlm4.c index d0caa97c2..042cfeba1 100644 --- a/xlators/nfs/server/src/nlm4.c +++ b/xlators/nfs/server/src/nlm4.c @@ -33,7 +33,6 @@ #include "nfs-generics.h" #include "rpc-clnt.h" #include "nsm-xdr.h" -#include "nlmcbk-xdr.h" #include "run.h" #include #include @@ -157,9 +156,9 @@ nlm4_prep_nlm4_testargs (nlm4_testargs *args, struct nfs3_fh *fh, nlm4_lkowner_t *oh, char *cookiebytes) { memset (args, 0, sizeof (*args)); - args->alock.fh.n_bytes = (void *)fh; - args->alock.oh.n_bytes = (void *)oh; - args->cookie.n_bytes = (void *)cookiebytes; + args->alock.fh.nlm4_netobj_val = (void *)fh; + args->alock.oh.nlm4_netobj_val = (void *)oh; + args->cookie.nlm4_netobj_val = (void *)cookiebytes; } void @@ -167,9 +166,9 @@ nlm4_prep_nlm4_lockargs (nlm4_lockargs *args, struct nfs3_fh *fh, nlm4_lkowner_t *oh, char *cookiebytes) { memset (args, 0, sizeof (*args)); - args->alock.fh.n_bytes = (void *)fh; - args->alock.oh.n_bytes = (void *)oh; - args->cookie.n_bytes = (void *)cookiebytes; + args->alock.fh.nlm4_netobj_val = (void *)fh; + args->alock.oh.nlm4_netobj_val = (void *)oh; + args->cookie.nlm4_netobj_val = (void *)cookiebytes; } void @@ -177,9 +176,9 @@ nlm4_prep_nlm4_cancargs (nlm4_cancargs *args, struct nfs3_fh *fh, nlm4_lkowner_t *oh, char *cookiebytes) { memset (args, 0, sizeof (*args)); - args->alock.fh.n_bytes = (void *)fh; - args->alock.oh.n_bytes = (void *)oh; - args->cookie.n_bytes = (void *)cookiebytes; + args->alock.fh.nlm4_netobj_val = (void *)fh; + args->alock.oh.nlm4_netobj_val = (void *)oh; + args->cookie.nlm4_netobj_val = (void *)cookiebytes; } void @@ -187,9 +186,9 @@ nlm4_prep_nlm4_unlockargs (nlm4_unlockargs *args, struct nfs3_fh *fh, nlm4_lkowner_t *oh, char *cookiebytes) { memset (args, 0, sizeof (*args)); - args->alock.fh.n_bytes = (void *)fh; - args->alock.oh.n_bytes = (void *)oh; - args->cookie.n_bytes = (void *)cookiebytes; + args->alock.fh.nlm4_netobj_val = (void *)fh; + args->alock.oh.nlm4_netobj_val = (void *)oh; + args->cookie.nlm4_netobj_val = (void *)cookiebytes; } void @@ -197,9 +196,9 @@ nlm4_prep_shareargs (nlm4_shareargs *args, struct nfs3_fh *fh, nlm4_lkowner_t *oh, char *cookiebytes) { memset (args, 0, sizeof (*args)); - args->share.fh.n_bytes = (void *)fh; - args->share.oh.n_bytes = (void *)oh; - args->cookie.n_bytes = (void *)cookiebytes; + args->share.fh.nlm4_netobj_val = (void *)fh; + args->share.oh.nlm4_netobj_val = (void *)oh; + args->cookie.nlm4_netobj_val = (void *)cookiebytes; } void @@ -210,22 +209,22 @@ nlm4_prep_freeallargs (nlm4_freeallargs *args, nlm4_lkowner_t *oh) } void -nlm_copy_lkowner (gf_lkowner_t *dst, netobj *src) +nlm_copy_lkowner (gf_lkowner_t *dst, nlm4_netobj *src) { - dst->len = src->n_len; - memcpy (dst->data, src->n_bytes, dst->len); + dst->len = src->nlm4_netobj_len; + memcpy (dst->data, src->nlm4_netobj_val, dst->len); } int -nlm_is_oh_same_lkowner (gf_lkowner_t *a, netobj *b) +nlm_is_oh_same_lkowner (gf_lkowner_t *a, nlm4_netobj *b) { if (!a || !b) { gf_log (GF_NLM, GF_LOG_ERROR, "invalid args"); return -1; } - return (a->len == b->n_len && - !memcmp (a->data, b->n_bytes, a->len)); + return (a->len == b->nlm4_netobj_len && + !memcmp (a->data, b->nlm4_netobj_val, a->len)); } nlm4_stats @@ -653,7 +652,7 @@ err: } int -nlm4_generic_reply (rpcsvc_request_t *req, netobj cookie, nlm4_stats stat) +nlm4_generic_reply (rpcsvc_request_t *req, nlm4_netobj cookie, nlm4_stats stat) { nlm4_res res; diff --git a/xlators/nfs/server/src/nlm4.h b/xlators/nfs/server/src/nlm4.h index 5b6296110..e234b6944 100644 --- a/xlators/nfs/server/src/nlm4.h +++ b/xlators/nfs/server/src/nlm4.h @@ -31,6 +31,32 @@ #include "nlm4-xdr.h" #include "lkowner.h" +#define NLM4_NULL 0 +#define NLM4_TEST 1 +#define NLM4_LOCK 2 +#define NLM4_CANCEL 3 +#define NLM4_UNLOCK 4 +#define NLM4_GRANTED 5 +#define NLM4_TEST_MSG 6 +#define NLM4_LOCK_MSG 7 +#define NLM4_CANCEL_MSG 8 +#define NLM4_UNLOCK_MSG 9 +#define NLM4_GRANTED_MSG 10 +#define NLM4_TEST_RES 11 +#define NLM4_LOCK_RES 12 +#define NLM4_CANCEL_RES 13 +#define NLM4_UNLOCK_RES 14 +#define NLM4_GRANTED_RES 15 +#define NLM4_SM_NOTIFY 16 +#define NLM4_SEVENTEEN 17 +#define NLM4_EIGHTEEN 18 +#define NLM4_NINETEEN 19 +#define NLM4_SHARE 20 +#define NLM4_UNSHARE 21 +#define NLM4_NM_LOCK 22 +#define NLM4_FREE_ALL 23 +#define NLM4_PROC_COUNT 24 + /* Registered with portmap */ #define GF_NLM4_PORT 38468 #define GF_NLM GF_NFS"-NLM" diff --git a/xlators/nfs/server/src/nlmcbk_svc.c b/xlators/nfs/server/src/nlmcbk_svc.c index e1b588765..20d3728d0 100644 --- a/xlators/nfs/server/src/nlmcbk_svc.c +++ b/xlators/nfs/server/src/nlmcbk_svc.c @@ -13,7 +13,6 @@ * It was generated using rpcgen. */ -#include "nlmcbk-xdr.h" #include "nlm4.h" #include "logging.h" #include -- cgit From 8647ea41d42c35d1e74232c37b898708dee315c4 Mon Sep 17 00:00:00 2001 From: "Bala.FA" Date: Fri, 25 Apr 2014 11:16:02 +0530 Subject: build: fix RHEL 7 build issue Glusterfs build on RHEL 7 fails with "Installed (but unpackaged) file(s) found". This patch fixes it. BUG: 1058188 Change-Id: I8f37935b75ba02d085e75a66cdbc4017d82faa2e Signed-off-by: Bala.FA Reviewed-on: http://review.gluster.org/7557 Reviewed-by: Niels de Vos Tested-by: Niels de Vos Tested-by: Gluster Build System --- glusterfs.spec.in | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/glusterfs.spec.in b/glusterfs.spec.in index fbaabea41..21913a095 100644 --- a/glusterfs.spec.in +++ b/glusterfs.spec.in @@ -573,6 +573,9 @@ EOM rm -rf %{buildroot}/benchmarking rm -f %{buildroot}/glusterfs-mode.el rm -f %{buildroot}/glusterfs.vim +rm -fr %{buildroot}/%{_docdir}/glusterfs/benchmarking +rm -f %{buildroot}/%{_docdir}/glusterfs/glusterfs-mode.el +rm -f %{buildroot}/%{_docdir}/glusterfs/glusterfs.vim # Create working directory mkdir -p %{buildroot}%{_sharedstatedir}/glusterd @@ -984,6 +987,9 @@ fi %ghost %attr(0600,-,-) %{_sharedstatedir}/glusterd/nfs/run/nfs.pid %changelog +* Fri Apr 25 2014 Arumugam Balamurugan +- fix RHEL 7 build failure "Installed (but unpackaged) file(s) found" (#1058188) + * Wed Apr 02 2014 Arumugam Balamurugan - cleanup to rearrange spec file elements -- cgit From 447f4dec70a8103fc188024ea76447425cf14c60 Mon Sep 17 00:00:00 2001 From: Harshavardhana Date: Fri, 25 Apr 2014 16:08:09 -0700 Subject: rpcgen: 'hyper' is 64bit undefined on Darwin use quad_t "9819fcedf10f1430d4969c86e6df4dfe975b7dcf" After the commit i observed that we never used "hyper" as defined in .x previously in the .[c,h] files. Change-Id: I26152141bca6e789c4a3b3158fffe0a65e4b0878 BUG: 1090807 Signed-off-by: Harshavardhana Reviewed-on: http://review.gluster.org/7566 Tested-by: Gluster Build System Reviewed-by: Anand Avati --- build-aux/xdrgen | 2 +- rpc/xdr/src/.gitignore | 1 + rpc/xdr/src/glusterfs3-xdr.x | 128 +++++++++++++++++++++---------------------- rpc/xdr/src/rpc-common-xdr.x | 10 ++-- 4 files changed, 71 insertions(+), 70 deletions(-) diff --git a/build-aux/xdrgen b/build-aux/xdrgen index dd5571baa..b5f33d372 100755 --- a/build-aux/xdrgen +++ b/build-aux/xdrgen @@ -1,4 +1,4 @@ -#!/bin/sh +#!/bin/bash _init () { diff --git a/rpc/xdr/src/.gitignore b/rpc/xdr/src/.gitignore index 407f135c5..4fb7f9582 100644 --- a/rpc/xdr/src/.gitignore +++ b/rpc/xdr/src/.gitignore @@ -16,3 +16,4 @@ portmap-xdr.c portmap-xdr.h rpc-common-xdr.c rpc-common-xdr.h +*-e diff --git a/rpc/xdr/src/glusterfs3-xdr.x b/rpc/xdr/src/glusterfs3-xdr.x index 1edbda3ad..feef7e264 100644 --- a/rpc/xdr/src/glusterfs3-xdr.x +++ b/rpc/xdr/src/glusterfs3-xdr.x @@ -1,23 +1,23 @@ #define GF_REQUEST_MAXGROUPS 16 struct gf_statfs { - unsigned hyper bsize; - unsigned hyper frsize; - unsigned hyper blocks; - unsigned hyper bfree; - unsigned hyper bavail; - unsigned hyper files; - unsigned hyper ffree; - unsigned hyper favail; - unsigned hyper fsid; - unsigned hyper flag; - unsigned hyper namemax; + u_quad_t bsize; + u_quad_t frsize; + u_quad_t blocks; + u_quad_t bfree; + u_quad_t bavail; + u_quad_t files; + u_quad_t ffree; + u_quad_t favail; + u_quad_t fsid; + u_quad_t flag; + u_quad_t namemax; }; struct gf_proto_flock { unsigned int type; unsigned int whence; - unsigned hyper start; - unsigned hyper len; + u_quad_t start; + u_quad_t len; unsigned int pid; opaque lk_owner<>; } ; @@ -25,16 +25,16 @@ struct gf_proto_flock { struct gf_iatt { opaque ia_gfid[16]; - unsigned hyper ia_ino; /* inode number */ - unsigned hyper ia_dev; /* backing device ID */ + u_quad_t ia_ino; /* inode number */ + u_quad_t ia_dev; /* backing device ID */ unsigned int mode; /* mode (type + protection )*/ unsigned int ia_nlink; /* Link count */ unsigned int ia_uid; /* user ID of owner */ unsigned int ia_gid; /* group ID of owner */ - unsigned hyper ia_rdev; /* device ID (if special file) */ - unsigned hyper ia_size; /* file size in bytes */ + u_quad_t ia_rdev; /* device ID (if special file) */ + u_quad_t ia_size; /* file size in bytes */ unsigned int ia_blksize; /* blocksize for filesystem I/O */ - unsigned hyper ia_blocks; /* number of 512B blocks allocated */ + u_quad_t ia_blocks; /* number of 512B blocks allocated */ unsigned int ia_atime; /* last access time */ unsigned int ia_atime_nsec; unsigned int ia_mtime; /* last modification time */ @@ -71,7 +71,7 @@ struct gfs3_readlink_req { struct gfs3_mknod_req { opaque pargfid[16]; - unsigned hyper dev; + u_quad_t dev; unsigned int mode; unsigned int umask; string bname<>; /* NULL terminated */ @@ -187,7 +187,7 @@ struct gfs3_readlink_req { struct gfs3_truncate_req { opaque gfid[16]; - unsigned hyper offset; + u_quad_t offset; opaque xdata<>; /* Extra data */ }; struct gfs3_truncate_rsp { @@ -207,15 +207,15 @@ struct gfs3_readlink_req { struct gfs3_open_rsp { int op_ret; int op_errno; - hyper fd; + quad_t fd; opaque xdata<>; /* Extra data */ }; struct gfs3_read_req { opaque gfid[16]; - hyper fd; - unsigned hyper offset; + quad_t fd; + u_quad_t offset; unsigned int size; unsigned int flag; opaque xdata<>; /* Extra data */ @@ -247,8 +247,8 @@ struct gfs3_lookup_req { struct gfs3_write_req { opaque gfid[16]; - hyper fd; - unsigned hyper offset; + quad_t fd; + u_quad_t offset; unsigned int size; unsigned int flag; opaque xdata<>; /* Extra data */ @@ -275,7 +275,7 @@ struct gfs3_lookup_req { struct gfs3_lk_req { opaque gfid[16]; - hyper fd; + int64_t fd; unsigned int cmd; unsigned int type; struct gf_proto_flock flock; @@ -299,7 +299,7 @@ struct gfs3_lookup_req { struct gfs3_finodelk_req { opaque gfid[16]; - hyper fd; + quad_t fd; unsigned int cmd; unsigned int type; struct gf_proto_flock flock; @@ -310,14 +310,14 @@ struct gfs3_finodelk_req { struct gfs3_flush_req { opaque gfid[16]; - hyper fd; + quad_t fd; opaque xdata<>; /* Extra data */ } ; struct gfs3_fsync_req { opaque gfid[16]; - hyper fd; + quad_t fd; unsigned int data; opaque xdata<>; /* Extra data */ } ; @@ -341,7 +341,7 @@ struct gfs3_finodelk_req { struct gfs3_fsetxattr_req { opaque gfid[16]; - hyper fd; + int64_t fd; unsigned int flags; opaque dict<>; opaque xdata<>; /* Extra data */ @@ -366,7 +366,7 @@ struct gfs3_finodelk_req { struct gfs3_fxattrop_req { opaque gfid[16]; - hyper fd; + quad_t fd; unsigned int flags; opaque dict<>; opaque xdata<>; /* Extra data */ @@ -396,7 +396,7 @@ struct gfs3_finodelk_req { struct gfs3_fgetxattr_req { opaque gfid[16]; - hyper fd; + quad_t fd; unsigned int namelen; string name<>; opaque xdata<>; /* Extra data */ @@ -417,7 +417,7 @@ struct gfs3_finodelk_req { struct gfs3_fremovexattr_req { opaque gfid[16]; - hyper fd; + quad_t fd; string name<>; opaque xdata<>; /* Extra data */ } ; @@ -431,30 +431,30 @@ struct gfs3_finodelk_req { struct gfs3_opendir_rsp { int op_ret; int op_errno; - hyper fd; + quad_t fd; opaque xdata<>; /* Extra data */ } ; struct gfs3_fsyncdir_req { opaque gfid[16]; - hyper fd; + quad_t fd; int data; opaque xdata<>; /* Extra data */ } ; struct gfs3_readdir_req { opaque gfid[16]; - hyper fd; - unsigned hyper offset; + quad_t fd; + u_quad_t offset; unsigned int size; opaque xdata<>; /* Extra data */ }; struct gfs3_readdirp_req { opaque gfid[16]; - hyper fd; - unsigned hyper offset; + quad_t fd; + u_quad_t offset; unsigned int size; opaque dict<>; } ; @@ -479,7 +479,7 @@ struct gfs3_create_rsp { int op_ret; int op_errno; struct gf_iatt stat; - unsigned hyper fd; + u_quad_t fd; struct gf_iatt preparent; struct gf_iatt postparent; opaque xdata<>; /* Extra data */ @@ -489,8 +489,8 @@ struct gfs3_create_rsp { struct gfs3_ftruncate_req { opaque gfid[16]; - hyper fd; - unsigned hyper offset; + quad_t fd; + u_quad_t offset; opaque xdata<>; /* Extra data */ } ; struct gfs3_ftruncate_rsp { @@ -504,7 +504,7 @@ struct gfs3_ftruncate_rsp { struct gfs3_fstat_req { opaque gfid[16]; - hyper fd; + quad_t fd; opaque xdata<>; /* Extra data */ } ; struct gfs3_fstat_rsp { @@ -520,7 +520,7 @@ struct gfs3_fstat_req { opaque gfid[16]; unsigned int cmd; unsigned int type; - unsigned hyper namelen; + u_quad_t namelen; string name<>; string volume<>; opaque xdata<>; /* Extra data */ @@ -528,10 +528,10 @@ struct gfs3_fstat_req { struct gfs3_fentrylk_req { opaque gfid[16]; - hyper fd; + quad_t fd; unsigned int cmd; unsigned int type; - unsigned hyper namelen; + u_quad_t namelen; string name<>; string volume<>; opaque xdata<>; /* Extra data */ @@ -553,7 +553,7 @@ struct gfs3_fstat_req { } ; struct gfs3_fsetattr_req { - hyper fd; + quad_t fd; struct gf_iatt stbuf; int valid; opaque xdata<>; /* Extra data */ @@ -568,10 +568,10 @@ struct gfs3_fstat_req { struct gfs3_fallocate_req { opaque gfid[16]; - hyper fd; + quad_t fd; unsigned int flags; - unsigned hyper offset; - unsigned hyper size; + u_quad_t offset; + u_quad_t size; opaque xdata<>; /* Extra data */ } ; @@ -585,9 +585,9 @@ struct gfs3_fstat_req { struct gfs3_discard_req { opaque gfid[16]; - hyper fd; - unsigned hyper offset; - unsigned hyper size; + quad_t fd; + u_quad_t offset; + u_quad_t size; opaque xdata<>; /* Extra data */ } ; @@ -601,9 +601,9 @@ struct gfs3_fstat_req { struct gfs3_zerofill_req { opaque gfid[16]; - hyper fd; - unsigned hyper offset; - unsigned hyper size; + quad_t fd; + u_quad_t offset; + u_quad_t size; opaque xdata<>; } ; @@ -617,8 +617,8 @@ struct gfs3_fstat_req { struct gfs3_rchecksum_req { - hyper fd; - unsigned hyper offset; + quad_t fd; + u_quad_t offset; unsigned int len; opaque xdata<>; /* Extra data */ } ; @@ -682,13 +682,13 @@ struct gfs3_fstat_req { struct gfs3_releasedir_req { opaque gfid[16]; - hyper fd; + quad_t fd; opaque xdata<>; /* Extra data */ } ; struct gfs3_release_req { opaque gfid[16]; - hyper fd; + quad_t fd; opaque xdata<>; /* Extra data */ } ; @@ -699,8 +699,8 @@ struct gf_common_rsp { } ; struct gfs3_dirlist { - unsigned hyper d_ino; - unsigned hyper d_off; + u_quad_t d_ino; + u_quad_t d_off; unsigned int d_len; unsigned int d_type; string name<>; @@ -716,8 +716,8 @@ struct gfs3_readdir_rsp { }; struct gfs3_dirplist { - unsigned hyper d_ino; - unsigned hyper d_off; + u_quad_t d_ino; + u_quad_t d_off; unsigned int d_len; unsigned int d_type; string name<>; diff --git a/rpc/xdr/src/rpc-common-xdr.x b/rpc/xdr/src/rpc-common-xdr.x index ca28f38b5..ee66500e0 100644 --- a/rpc/xdr/src/rpc-common-xdr.x +++ b/rpc/xdr/src/rpc-common-xdr.x @@ -10,7 +10,7 @@ struct auth_glusterfs_parms_v2 { }; struct auth_glusterfs_parms { - unsigned hyper lk_owner; + u_quad_t lk_owner; unsigned int pid; unsigned int uid; unsigned int gid; @@ -19,20 +19,20 @@ struct auth_glusterfs_parms { }; struct gf_dump_req { - unsigned hyper gfs_id; + u_quad_t gfs_id; }; struct gf_prog_detail { string progname<>; - unsigned hyper prognum; - unsigned hyper progver; + u_quad_t prognum; + u_quad_t progver; struct gf_prog_detail *next; }; struct gf_dump_rsp { - unsigned hyper gfs_id; + u_quad_t gfs_id; int op_ret; int op_errno; struct gf_prog_detail *prog; -- cgit From 0af287791f0d50b5d2975cb2e2c902c797b05860 Mon Sep 17 00:00:00 2001 From: Avra Sengupta Date: Wed, 2 Apr 2014 05:39:22 +0000 Subject: glusterd/snapshot-handshake: Perform handshake of missed_snaps_list. In a handshake, create a union of the missed_snap_lists of the two peers. If an entry is present, its no op. If an entry is pendng, and the peer entry is done, mark own entry as done. If an entry is done, and the peer ertry is pending, its a no-op. If its a new entry, add it. Change-Id: Idbfa49cc34871631ba8c7c56d915666311024887 BUG: 1061685 Signed-off-by: Avra Sengupta Reviewed-on: http://review.gluster.org/7453 Tested-by: Gluster Build System Reviewed-by: Rajesh Joseph Reviewed-by: Vijay Bellur --- rpc/rpc-lib/src/protocol-common.h | 3 +- xlators/mgmt/glusterd/src/glusterd-handler.c | 6 ++ xlators/mgmt/glusterd/src/glusterd-rpc-ops.c | 10 +++ xlators/mgmt/glusterd/src/glusterd-sm.c | 22 +++++++ xlators/mgmt/glusterd/src/glusterd-utils.c | 96 ++++++++++++++++++++++++++++ xlators/mgmt/glusterd/src/glusterd-utils.h | 6 ++ xlators/mgmt/glusterd/src/glusterd.c | 11 ++++ 7 files changed, 153 insertions(+), 1 deletion(-) diff --git a/rpc/rpc-lib/src/protocol-common.h b/rpc/rpc-lib/src/protocol-common.h index 97d47c433..8129b8131 100644 --- a/rpc/rpc-lib/src/protocol-common.h +++ b/rpc/rpc-lib/src/protocol-common.h @@ -107,7 +107,8 @@ enum gf_probe_resp { GF_PROBE_SAME_UUID, GF_PROBE_UNKNOWN_PEER, GF_PROBE_ADD_FAILED, - GF_PROBE_QUORUM_NOT_MET + GF_PROBE_QUORUM_NOT_MET, + GF_PROBE_MISSED_SNAP_CONFLICT, }; enum gf_deprobe_resp { diff --git a/xlators/mgmt/glusterd/src/glusterd-handler.c b/xlators/mgmt/glusterd/src/glusterd-handler.c index 53c402136..5869a88d4 100644 --- a/xlators/mgmt/glusterd/src/glusterd-handler.c +++ b/xlators/mgmt/glusterd/src/glusterd-handler.c @@ -3403,6 +3403,12 @@ set_probe_error_str (int op_ret, int op_errno, char *op_errstr, char *errstr, "in this state"); break; + case GF_PROBE_MISSED_SNAP_CONFLICT: + snprintf (errstr, len, "Failed to update " + "list of missed snapshots from " + "peer %s", hostname); + break; + default: snprintf (errstr, len, "Probe returned with " "unknown errno %d", op_errno); diff --git a/xlators/mgmt/glusterd/src/glusterd-rpc-ops.c b/xlators/mgmt/glusterd/src/glusterd-rpc-ops.c index 27910d132..cf1ae279a 100644 --- a/xlators/mgmt/glusterd/src/glusterd-rpc-ops.c +++ b/xlators/mgmt/glusterd/src/glusterd-rpc-ops.c @@ -1266,6 +1266,16 @@ glusterd_rpc_friend_add (call_frame_t *frame, xlator_t *this, if (ret) goto out; + if (priv->op_version >= GD_OP_VERSION_4) { + ret = glusterd_add_missed_snaps_to_export_dict (vols); + if (ret) { + gf_log (this->name, GF_LOG_ERROR, + "Unable to add list of missed snapshots " + "in the vols dict for handshake"); + goto out; + } + } + uuid_copy (req.uuid, MY_UUID); req.hostname = peerinfo->hostname; req.port = peerinfo->port; diff --git a/xlators/mgmt/glusterd/src/glusterd-sm.c b/xlators/mgmt/glusterd/src/glusterd-sm.c index fd56e5abf..3f0add220 100644 --- a/xlators/mgmt/glusterd/src/glusterd-sm.c +++ b/xlators/mgmt/glusterd/src/glusterd-sm.c @@ -648,10 +648,14 @@ glusterd_ac_handle_friend_add_req (glusterd_friend_sm_event_t *event, void *ctx) glusterd_friend_update_ctx_t *new_ev_ctx = NULL; glusterd_friend_sm_event_t *new_event = NULL; glusterd_friend_sm_event_type_t event_type = GD_FRIEND_EVENT_NONE; + glusterd_conf_t *conf = NULL; int status = 0; int32_t op_ret = -1; int32_t op_errno = 0; + xlator_t *this = NULL; + this = THIS; + GF_ASSERT (this); GF_ASSERT (ctx); ev_ctx = ctx; uuid_copy (uuid, ev_ctx->uuid); @@ -659,6 +663,9 @@ glusterd_ac_handle_friend_add_req (glusterd_friend_sm_event_t *event, void *ctx) GF_ASSERT (peerinfo); uuid_copy (peerinfo->uuid, ev_ctx->uuid); + conf = this->private; + GF_ASSERT (conf); + //Build comparison logic here. ret = glusterd_compare_friend_data (ev_ctx->vols, &status, peerinfo->hostname); @@ -674,6 +681,21 @@ glusterd_ac_handle_friend_add_req (glusterd_friend_sm_event_t *event, void *ctx) op_ret = -1; } + /* Compare missed_snapshot list with the peer * + * if volume comparison is successful */ + if ((op_ret == 0) && + (conf->op_version >= GD_OP_VERSION_4)) { + ret = glusterd_import_friend_missed_snap_list (ev_ctx->vols); + if (ret) { + gf_log (this->name, GF_LOG_ERROR, + "Failed to import peer's " + "missed_snaps_list."); + event_type = GD_FRIEND_EVENT_LOCAL_RJT; + op_errno = GF_PROBE_MISSED_SNAP_CONFLICT; + op_ret = -1; + } + } + ret = glusterd_friend_sm_new_event (event_type, &new_event); if (ret) { diff --git a/xlators/mgmt/glusterd/src/glusterd-utils.c b/xlators/mgmt/glusterd/src/glusterd-utils.c index be2022da4..74317eb44 100644 --- a/xlators/mgmt/glusterd/src/glusterd-utils.c +++ b/xlators/mgmt/glusterd/src/glusterd-utils.c @@ -2666,6 +2666,64 @@ out: return ret; } +int32_t +glusterd_add_missed_snaps_to_export_dict (dict_t *vols) +{ + char name_buf[PATH_MAX] = ""; + char value[PATH_MAX] = ""; + int32_t missed_snap_count = 0; + int32_t ret = -1; + glusterd_conf_t *priv = NULL; + glusterd_missed_snap_info *missed_snapinfo = NULL; + glusterd_snap_op_t *snap_opinfo = NULL; + xlator_t *this = NULL; + + this = THIS; + GF_ASSERT (this); + GF_ASSERT (vols); + + priv = this->private; + GF_ASSERT (priv); + + /* Add the missed_entries in the dict */ + list_for_each_entry (missed_snapinfo, &priv->missed_snaps_list, + missed_snaps) { + list_for_each_entry (snap_opinfo, + &missed_snapinfo->snap_ops, + snap_ops_list) { + snprintf (name_buf, sizeof(name_buf), + "missed_snaps_%d", missed_snap_count); + snprintf (value, sizeof(value), "%s=%d:%s:%d:%d", + missed_snapinfo->node_snap_info, + snap_opinfo->brick_num, + snap_opinfo->brick_path, + snap_opinfo->op, + snap_opinfo->status); + + ret = dict_set_dynstr_with_alloc (vols, name_buf, + value); + if (ret) { + gf_log (this->name, GF_LOG_ERROR, + "Unable to set %s", + name_buf); + goto out; + } + missed_snap_count++; + } + } + + ret = dict_set_int32 (vols, "missed_snap_count", missed_snap_count); + if (ret) { + gf_log (this->name, GF_LOG_ERROR, + "Unable to set missed_snap_count"); + goto out; + } + +out: + gf_log (this->name, GF_LOG_TRACE, "Returning %d", ret); + return ret; +} + int32_t glusterd_build_volume_dict (dict_t **vols) { @@ -4156,6 +4214,44 @@ out: return ret; } +/* Import friend volumes missed_snap_list and update * + * missed_snap_list if need be */ +int32_t +glusterd_import_friend_missed_snap_list (dict_t *vols) +{ + int32_t missed_snap_count = -1; + int32_t ret = -1; + glusterd_conf_t *priv = NULL; + xlator_t *this = NULL; + + this = THIS; + GF_ASSERT (this); + GF_ASSERT (vols); + + priv = this->private; + GF_ASSERT (priv); + + /* Add the friends missed_snaps entries to the in-memory list */ + ret = dict_get_int32 (vols, "missed_snap_count", &missed_snap_count); + if (ret) { + gf_log (this->name, GF_LOG_INFO, + "No missed snaps"); + ret = 0; + goto out; + } + + ret = glusterd_store_update_missed_snaps (vols, missed_snap_count); + if (ret) { + gf_log (this->name, GF_LOG_ERROR, + "Failed to update missed_snaps_list"); + goto out; + } + +out: + gf_log (this->name, GF_LOG_TRACE, "Returning %d", ret); + return ret; +} + int32_t glusterd_compare_friend_data (dict_t *vols, int32_t *status, char *hostname) { diff --git a/xlators/mgmt/glusterd/src/glusterd-utils.h b/xlators/mgmt/glusterd/src/glusterd-utils.h index d2121778a..0f1c52372 100644 --- a/xlators/mgmt/glusterd/src/glusterd-utils.h +++ b/xlators/mgmt/glusterd/src/glusterd-utils.h @@ -719,4 +719,10 @@ glusterd_add_missed_snaps_to_dict (dict_t *rsp_dict, char *snap_uuid, glusterd_brickinfo_t *brickinfo, int32_t brick_number, int32_t op); +int32_t +glusterd_add_missed_snaps_to_export_dict (dict_t *vols); + +int32_t +glusterd_import_friend_missed_snap_list (dict_t *vols); + #endif diff --git a/xlators/mgmt/glusterd/src/glusterd.c b/xlators/mgmt/glusterd/src/glusterd.c index abef538d8..1a6aa81d3 100644 --- a/xlators/mgmt/glusterd/src/glusterd.c +++ b/xlators/mgmt/glusterd/src/glusterd.c @@ -1256,6 +1256,17 @@ init (xlator_t *this) exit (1); } + snprintf (storedir, PATH_MAX, "%s/snaps", workdir); + + ret = mkdir (storedir, 0777); + + if ((-1 == ret) && (errno != EEXIST)) { + gf_log (this->name, GF_LOG_CRITICAL, + "Unable to create snaps directory %s" + " ,errno = %d", storedir, errno); + exit (1); + } + snprintf (storedir, PATH_MAX, "%s/peers", workdir); ret = mkdir (storedir, 0777); -- cgit From 6a188c6b2c95d16c1bb6391c9fcb8ef808c2141b Mon Sep 17 00:00:00 2001 From: Krutika Dhananjay Date: Thu, 24 Apr 2014 16:37:05 +0530 Subject: features/locks: Remove stale entrylk objects from 'blocked_locks' list * In the event of a DISCONNECT from a client, as part of cleanup, entrylk objects are not removed from the blocked_locks list before being unref'd and freed, causing the brick process to crash at some point when the (now) stale object is accessed again in the list. * Also during cleanup, it is pointless to try and grant lock to a previously blocked entrylk (say L1) as part of releasing another conflicting lock (L2), (which is a side-effect of L1 not being deleted from blocked_locks list before grant_blocked_entry_locks() in cleanup) if L1 is also associated with the DISCONNECTing client. This patch fixes the problem. Change-Id: I3d684c6bafc7e6db89ba68f0a2ed1dcb333791c6 BUG: 1089470 Signed-off-by: Krutika Dhananjay Reviewed-on: http://review.gluster.org/7560 Reviewed-by: Pranith Kumar Karampuri Tested-by: Gluster Build System Reviewed-by: Anand Avati --- xlators/features/locks/src/entrylk.c | 50 +++++++++++++++++++++++++++++++++--- xlators/features/locks/src/inodelk.c | 2 +- 2 files changed, 48 insertions(+), 4 deletions(-) diff --git a/xlators/features/locks/src/entrylk.c b/xlators/features/locks/src/entrylk.c index 4f5d8aca2..8496d9d8d 100644 --- a/xlators/features/locks/src/entrylk.c +++ b/xlators/features/locks/src/entrylk.c @@ -715,15 +715,16 @@ pl_entrylk_client_cleanup (xlator_t *this, pl_ctx_t *ctx) pl_inode_t *pinode = NULL; struct list_head released; + struct list_head unwind; INIT_LIST_HEAD (&released); + INIT_LIST_HEAD (&unwind); pthread_mutex_lock (&ctx->lock); { list_for_each_entry_safe (l, tmp, &ctx->entrylk_lockers, client_list) { list_del_init (&l->client_list); - list_add_tail (&l->client_list, &released); pl_entrylk_log_cleanup (l); @@ -731,19 +732,62 @@ pl_entrylk_client_cleanup (xlator_t *this, pl_ctx_t *ctx) pthread_mutex_lock (&pinode->mutex); { - list_del_init (&l->domain_list); + /* If the entrylk object is part of granted list but not + * blocked list, then perform the following actions: + * i. delete the object from granted list; + * ii. grant other locks (from other clients) that may + * have been blocked on this entrylk; and + * iii. unref the object. + * + * If the entrylk object (L1) is part of both granted + * and blocked lists, then this means that a parallel + * unlock on another entrylk (L2 say) may have 'granted' + * L1 and added it to 'granted' list in + * __grant_blocked_entry_locks() (although using the + * 'blocked_locks' member). In that case, the cleanup + * codepath must try and grant other overlapping + * blocked entrylks from other clients, now that L1 is + * out of their way and then unref L1 in the end, and + * leave it to the other thread (the one executing + * unlock codepath) to unwind L1's frame, delete it from + * blocked_locks list, and perform the last unref on L1. + * + * If the entrylk object (L1) is part of blocked list + * only, the cleanup code path must: + * i. delete it from the blocked_locks list inside + * this critical section, + * ii. unwind its frame with EAGAIN, + * iii. try and grant blocked entry locks from other + * clients that were otherwise grantable, but were + * blocked to avoid leaving L1 to starve forever. + * iv. unref the object. + */ + if (!list_empty (&l->domain_list)) { + list_del_init (&l->domain_list); + list_add_tail (&l->client_list, + &released); + } else { + list_del_init (&l->blocked_locks); + list_add_tail (&l->client_list, + &unwind); + } } pthread_mutex_unlock (&pinode->mutex); } } pthread_mutex_unlock (&ctx->lock); - list_for_each_entry_safe (l, tmp, &released, client_list) { + list_for_each_entry_safe (l, tmp, &unwind, client_list) { list_del_init (&l->client_list); if (l->frame) STACK_UNWIND_STRICT (entrylk, l->frame, -1, EAGAIN, NULL); + list_add_tail (&l->client_list, &released); + } + + list_for_each_entry_safe (l, tmp, &released, client_list) { + list_del_init (&l->client_list); pinode = l->pinode; diff --git a/xlators/features/locks/src/inodelk.c b/xlators/features/locks/src/inodelk.c index d105e14f2..c76cb7f91 100644 --- a/xlators/features/locks/src/inodelk.c +++ b/xlators/features/locks/src/inodelk.c @@ -26,7 +26,7 @@ inline void __delete_inode_lock (pl_inode_lock_t *lock) { - list_del (&lock->list); + list_del_init (&lock->list); } static inline void -- cgit From 3b40a553f466aa3d671efc2ae892215bebaa4c7b Mon Sep 17 00:00:00 2001 From: Santosh Kumar Pradhan Date: Thu, 24 Apr 2014 12:55:05 +0530 Subject: gNFS: Log properly for pmap_getport() fail in NLM In NLM callback path, if pmap_getport() FAILs, it just log the error message saying "Is firewall running on the client". It may happen that RPC services are not running e.g. "rpcbind" is not running or nlockmgr (NLM) is not registered with portmapper which all can be checked using "rpcinfo -p" command. FIX: Modify the log message to include the later case mentioned above. Change-Id: If422275b2ab59d1e974a6caa37132f31e9a34329 BUG: 1090782 Signed-off-by: Santosh Kumar Pradhan Reviewed-on: http://review.gluster.org/7544 Reviewed-by: Niels de Vos Tested-by: Gluster Build System Reviewed-by: Rajesh Joseph --- xlators/nfs/server/src/nlm4.c | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/xlators/nfs/server/src/nlm4.c b/xlators/nfs/server/src/nlm4.c index 042cfeba1..4d0083fe2 100644 --- a/xlators/nfs/server/src/nlm4.c +++ b/xlators/nfs/server/src/nlm4.c @@ -974,8 +974,10 @@ nlm4_establish_callback (void *csarg) NLM_V4, IPPROTO_TCP); if (port == 0) { - gf_log (GF_NLM, GF_LOG_ERROR, "Unable to get NLM port of the " - "client. Is the firewall running on client?"); + gf_log (GF_NLM, GF_LOG_ERROR, + "Unable to get NLM port of the client." + " Is the firewall running on client?" + " OR Are RPC services running (rpcinfo -p)?"); goto err; } -- cgit From fbef3a51c501c67ce6814dd16efb87758d855d48 Mon Sep 17 00:00:00 2001 From: Pranith Kumar K Date: Sun, 27 Apr 2014 07:00:34 +0530 Subject: libglusterfs: Define macro GF_PRI_USEC for Linux as well Change-Id: I073f1f4ead4391d497fbb7603f9ee0257271493b BUG: 1089172 Signed-off-by: Pranith Kumar K Reviewed-on: http://review.gluster.org/7571 Reviewed-by: Harshavardhana Tested-by: Harshavardhana Reviewed-by: Anand Avati --- libglusterfs/src/logging.h | 1 + 1 file changed, 1 insertion(+) diff --git a/libglusterfs/src/logging.h b/libglusterfs/src/logging.h index 3c83ebbc0..0c5c3b4c4 100644 --- a/libglusterfs/src/logging.h +++ b/libglusterfs/src/logging.h @@ -36,6 +36,7 @@ #define GF_PRI_NLINK PRIu32 #define GF_PRI_SECOND "lu" #define GF_PRI_SUSECONDS "06ld" +#define GF_PRI_USEC "ld" #endif #define GF_PRI_BLKSIZE PRId32 #define GF_PRI_SIZET "zu" -- cgit From f77e5b6ebe5d702065844db141ebd38ff7802168 Mon Sep 17 00:00:00 2001 From: Harshavardhana Date: Sat, 26 Apr 2014 20:19:38 -0700 Subject: rpcgen: After recent changes parallel builds failed Parallel builds failed due to make file would overrun xdrgen (internally xdrgen uses tempfiles to add License header). Seperate out header and source generation and add explicit dependency to fix it. Change-Id: Id20f548493540b0f17a2300f0775646f9f20789c BUG: 1090807 Signed-off-by: Harshavardhana Reviewed-on: http://review.gluster.org/7572 Tested-by: Gluster Build System Reviewed-by: Anand Avati --- build-aux/xdrgen | 90 +++++++++++++++++++++-------------------- rpc/xdr/src/.gitignore | 2 + rpc/xdr/src/Makefile.am | 105 +++++++++++++++++++++++++++++++++++++++++++----- 3 files changed, 145 insertions(+), 52 deletions(-) diff --git a/build-aux/xdrgen b/build-aux/xdrgen index b5f33d372..e826111b9 100755 --- a/build-aux/xdrgen +++ b/build-aux/xdrgen @@ -1,23 +1,9 @@ #!/bin/bash -_init () -{ - xfile="$1"; - - cfile="${1%.x}.c"; - hfile="${1%.x}.h"; - - tmp_cfile="$1.c"; - - tmp1_hfile="$1.h.tmp"; - tmp1_cfile="$1.c.tmp"; - -} - append_licence_header () { - src_file=$1; - dst_file=$2; + local src_file=$1; + local dst_file=$2; cat >$dst_file <.x" - exit 1; - fi + local xfile="$1"; + + local cfile="${1%.x}.c"; + local hfile="${1%.x}.h"; + local tmp_cfile="$1.c.tmp"; + local tmp_hfile="$1.h.tmp"; - echo -n "writing the XDR routine file ($tmp_cfile) ... "; + rm -f $cfile; + rpcgen -c -o $cfile $xfile; + append_licence_header $cfile $tmp_cfile; + mv $tmp_cfile $cfile; + # remove unwanted temporary files (if any) rm -f $tmp_cfile; - rpcgen -c -o $tmp_cfile $xfile; + echo "Generated $cfile" + return +} + +gen_headers () +{ + local xfile="$1"; + + local cfile="${1%.x}.c"; + local hfile="${1%.x}.h"; - echo "OK"; + local tmp_cfile="$1.c.tmp"; + local tmp_hfile="$1.h.tmp"; # no need for a temporary file here as there are no changes from glusterfs - echo -n "writing the XDR header file ($hfile) ... "; rm -f $hfile; rpcgen -h -o $hfile $xfile; - # the '#ifdef' part of file should be fixed sed -i -e 's/-/_/g' $hfile; - - echo "OK"; - - echo -n "writing licence header to the generated files ... "; - # Write header to temp file and append generated file - append_licence_header $hfile $tmp1_hfile; - append_licence_header $tmp_cfile $tmp1_cfile; - echo "OK" - + # Gen header to temp file and append generated file + append_licence_header $hfile $tmp_hfile; # now move the destination file to actual original file - echo -n "updating existing files ... "; - mv $tmp1_hfile $hfile; - mv $tmp1_cfile $cfile; + mv $tmp_hfile $hfile; + rm -f $tmp_hfile; + echo "Generated $hfile"; + return +} - # remove unwanted temporary files (if any) - rm -f $tmp_cfile $tmp1_cfile $tmp1_hfile +main () +{ + if [ $# -ne 2 ]; then + echo "wrong number of arguments given" + echo " $0 [header|source] .x" + exit 1; + fi - echo "OK" + if [ $1 == "header" ]; then + gen_headers $2 + fi + if [ $1 == "source" ]; then + gen_sources $2 + fi } -_init "$@" && main "$@"; +main "$@"; diff --git a/rpc/xdr/src/.gitignore b/rpc/xdr/src/.gitignore index 4fb7f9582..f9eab1680 100644 --- a/rpc/xdr/src/.gitignore +++ b/rpc/xdr/src/.gitignore @@ -16,4 +16,6 @@ portmap-xdr.c portmap-xdr.h rpc-common-xdr.c rpc-common-xdr.h +mount3udp.c +mount3udp.h *-e diff --git a/rpc/xdr/src/Makefile.am b/rpc/xdr/src/Makefile.am index e39c677a9..1c70dc9db 100644 --- a/rpc/xdr/src/Makefile.am +++ b/rpc/xdr/src/Makefile.am @@ -1,3 +1,8 @@ +XDRSOURCES = glusterfs3-xdr.c cli1-xdr.c nlm4-xdr.c nsm-xdr.c \ + rpc-common-xdr.c glusterd1-xdr.c acl3-xdr.c portmap-xdr.c mount3udp.c +XDRHEADERS = $(XDRSOURCES:.c=.h) +XDRGENFILES = $(XDRSOURCES:.c=.x) + lib_LTLIBRARIES = libgfxdr.la libgfxdr_la_CFLAGS = -Wall $(GF_CFLAGS) $(GF_DARWIN_LIBGLUSTERFS_CFLAGS) @@ -13,14 +18,96 @@ libgfxdr_la_SOURCES = $(XDRSOURCES) xdr-generic.c xdr-nfs3.c msg-nfs3.c noinst_HEADERS = $(XDRHEADERS) xdr-generic.h xdr-nfs3.h msg-nfs3.h glusterfs3.h -XDRSOURCES = glusterfs3-xdr.c cli1-xdr.c nlm4-xdr.c nsm-xdr.c \ - rpc-common-xdr.c glusterd1-xdr.c acl3-xdr.c portmap-xdr.c -XDRHEADERS = glusterfs3-xdr.h cli1-xdr.h nlm4-xdr.h nsm-xdr.h \ - rpc-common-xdr.h glusterd1-xdr.h acl3-xdr.h portmap-xdr.h +CLEANFILES = $(XDRSOURCES) $(XDRHEADERS) -%.h:%.x - $(top_srcdir)/build-aux/xdrgen $(top_srcdir)/rpc/xdr/src/$*.x -%.c:%.x - $(top_srcdir)/build-aux/xdrgen $(top_srcdir)/rpc/xdr/src/$*.x +EXTRA_DIST = $(XDRGENFILES) -CLEANFILES = $(XDRSOURCES) $(XDRHEADERS) +glusterfs3-xdr.c: glusterfs3-xdr.x glusterfs3-xdr.h + @if test -f $<; then \ + $(top_srcdir)/build-aux/xdrgen source $< ; \ + fi + +glusterfs3-xdr.h: glusterfs3-xdr.x + @if test -f $< ; then \ + $(top_srcdir)/build-aux/xdrgen header $< ; \ + fi + +cli1-xdr.c: cli1-xdr.x cli1-xdr.h + @if test -f $< ; then \ + $(top_srcdir)/build-aux/xdrgen source $< ; \ + fi + +cli1-xdr.h: cli1-xdr.x + @if test -f $< ; then \ + $(top_srcdir)/build-aux/xdrgen header $< ; \ + fi + +nlm4-xdr.c: nlm4-xdr.x nlm4-xdr.h + @if test -f $< ; then \ + $(top_srcdir)/build-aux/xdrgen source $< ; \ + fi + +nlm4-xdr.h: nlm4-xdr.x + @if test -f $< ; then \ + $(top_srcdir)/build-aux/xdrgen header $< ; \ + fi + +nsm-xdr.c: nsm-xdr.x nsm-xdr.h + @if test -f $< ; then \ + $(top_srcdir)/build-aux/xdrgen source $< ; \ + fi + +nsm-xdr.h: nsm-xdr.x + @if test -f $< ; then \ + $(top_srcdir)/build-aux/xdrgen header $< ; \ + fi + +rpc-common-xdr.c: rpc-common-xdr.x rpc-common-xdr.h + @if test -f $< ; then \ + $(top_srcdir)/build-aux/xdrgen source $< ; \ + fi + +rpc-common-xdr.h: rpc-common-xdr.x + @if test -f $< ; then \ + $(top_srcdir)/build-aux/xdrgen header $< ; \ + fi + +glusterd1-xdr.c: glusterd1-xdr.x glusterd1-xdr.h + @if test -f $< ; then \ + $(top_srcdir)/build-aux/xdrgen source $< ; \ + fi + +glusterd1-xdr.h: glusterd1-xdr.x + @if test -f $< ; then \ + $(top_srcdir)/build-aux/xdrgen header $< ; \ + fi + +acl3-xdr.c: acl3-xdr.x acl3-xdr.h + @if test -f $< ; then \ + $(top_srcdir)/build-aux/xdrgen source $< ; \ + fi + +acl3-xdr.h: acl3-xdr.x + @if test -f $< ; then \ + $(top_srcdir)/build-aux/xdrgen header $< ; \ + fi + +portmap-xdr.c: portmap-xdr.x portmap-xdr.h + @if test -f $< ; then \ + $(top_srcdir)/build-aux/xdrgen source $< ; \ + fi + +portmap-xdr.h: portmap-xdr.x + @if test -f $< ; then \ + $(top_srcdir)/build-aux/xdrgen header $< ; \ + fi + +mount3udp.c: mount3udp.x mount3udp.h + @if test -f $< ; then \ + $(top_srcdir)/build-aux/xdrgen source $< ; \ + fi + +mount3udp.h: mount3udp.x + @if test -f $< ; then \ + $(top_srcdir)/build-aux/xdrgen header $< ; \ + fi -- cgit From 76ab97169f63da78c9e83daf040d7b09766497cf Mon Sep 17 00:00:00 2001 From: Niels de Vos Date: Thu, 24 Apr 2014 13:38:31 +0200 Subject: fuse: minor improvements for readdir(plus) Instead of using 'int' for the sizes, use a 'size_t' as it is more correct. Save the size of a fuse_dirent in a temporary variable so that strlen() on the filename is called fewer times. Also correcting some typos in comments. Change-Id: Ic62d9d729a86a1a6a53ed1354fce153bac01d860 BUG: 1074023 Reported-by: Kaleb S. KEITHLEY Signed-off-by: Niels de Vos Reviewed-on: http://review.gluster.org/7547 Tested-by: Gluster Build System Reviewed-by: Anand Avati --- xlators/mount/fuse/src/fuse-bridge.c | 33 ++++++++++++++++----------------- 1 file changed, 16 insertions(+), 17 deletions(-) diff --git a/xlators/mount/fuse/src/fuse-bridge.c b/xlators/mount/fuse/src/fuse-bridge.c index 745617a71..d5ca4d146 100644 --- a/xlators/mount/fuse/src/fuse-bridge.c +++ b/xlators/mount/fuse/src/fuse-bridge.c @@ -2553,8 +2553,8 @@ fuse_readdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this, { fuse_state_t *state = NULL; fuse_in_header_t *finh = NULL; - int size = 0; - int max_size = 0; + size_t size = 0; + size_t max_size = 0; char *buf = NULL; gf_dirent_t *entry = NULL; struct fuse_dirent *fde = NULL; @@ -2580,18 +2580,18 @@ fuse_readdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this, frame->root->unique, op_ret, state->size, state->off); list_for_each_entry (entry, &entries->list, list) { - max_size += FUSE_DIRENT_ALIGN (FUSE_NAME_OFFSET + - strlen (entry->d_name)); + size_t fde_size = FUSE_DIRENT_ALIGN (FUSE_NAME_OFFSET + + strlen (entry->d_name)); + max_size += fde_size; if (max_size > state->size) { - /* we received to many entries to fit in the request */ - max_size -= FUSE_DIRENT_ALIGN (FUSE_NAME_OFFSET + - strlen (entry->d_name)); + /* we received too many entries to fit in the reply */ + max_size -= fde_size; break; } } - if (max_size <= 0) { + if (max_size == 0) { send_fuse_data (this, finh, 0, 0); goto out; } @@ -2666,8 +2666,8 @@ fuse_readdirp_cbk (call_frame_t *frame, void *cookie, xlator_t *this, { fuse_state_t *state = NULL; fuse_in_header_t *finh = NULL; - int max_size = 0; - int size = 0; + size_t max_size = 0; + size_t size = 0; char *buf = NULL; gf_dirent_t *entry = NULL; struct fuse_direntplus *fde = NULL; @@ -2692,19 +2692,18 @@ fuse_readdirp_cbk (call_frame_t *frame, void *cookie, xlator_t *this, frame->root->unique, op_ret, state->size, state->off); list_for_each_entry (entry, &entries->list, list) { - max_size += FUSE_DIRENT_ALIGN (FUSE_NAME_OFFSET_DIRENTPLUS + - strlen (entry->d_name)); + size_t fdes = FUSE_DIRENT_ALIGN (FUSE_NAME_OFFSET_DIRENTPLUS + + strlen (entry->d_name)); + max_size += fdes; if (max_size > state->size) { - /* we received to many entries to fit in the reply */ - max_size -= FUSE_DIRENT_ALIGN ( - FUSE_NAME_OFFSET_DIRENTPLUS + - strlen (entry->d_name)); + /* we received too many entries to fit in the reply */ + max_size -= fdes; break; } } - if (max_size <= 0) { + if (max_size == 0) { send_fuse_data (this, finh, 0, 0); goto out; } -- cgit From 03813a6ec08405c815b993551d16f07075efd467 Mon Sep 17 00:00:00 2001 From: Kasturi Narra Date: Wed, 23 Apr 2014 14:04:59 +0530 Subject: doc: Adding user documentation for WORM feature Change-Id: Ic31c8305254dd00eae986fbb322cac3761b5d330 BUG: 1086760 Signed-off-by: Kasturi Narra Reviewed-on: http://review.gluster.org/7530 Reviewed-by: Humble Devassy Chirammal Reviewed-by: Niels de Vos Reviewed-by: Lalatendu Mohanty Tested-by: Gluster Build System --- doc/features/worm.md | 75 ++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 75 insertions(+) create mode 100644 doc/features/worm.md diff --git a/doc/features/worm.md b/doc/features/worm.md new file mode 100644 index 000000000..dba99777d --- /dev/null +++ b/doc/features/worm.md @@ -0,0 +1,75 @@ +#WORM (Write Once Read Many) +This features enables you to create a `WORM volume` using gluster CLI. +##Description +WORM (write once,read many) is a desired feature for users who want to store data such as `log files` and where data is not allowed to get modified. + +GlusterFS provides a new key `features.worm` which takes boolean values(enable/disable) for volume set. + +Internally, the volume set command with 'feature.worm' key will add 'features/worm' translator in the brick's volume file. + +`This change would be reflected on a subsequent restart of the volume`, i.e gluster volume stop, followed by a gluster volume start. + +With a volume converted to WORM, the changes are as follows: + +* Reads are handled normally +* Only files with O_APPEND flag will be supported. +* Truncation,deletion wont be supported. + +##Volume Options +Use the volume set command on a volume and see if the volume is actually turned into WORM type. + + # features.worm enable +##Fully loaded Example +WORM feature is being supported from glusterfs version 3.4 +start glusterd by using the command + + # service glusterd start +Now create a volume by using the command + + # gluster volume create +start the volume created by running the command below. + + # gluster vol start +Run the command below to make sure that volume is created. + + # gluster volume info +Now turn on the WORM feature on the volume by using the command + + # gluster vol set worm enable +Verify that the option is set by using the command + + # gluster volume info +User should be able to see another option in the volume info + + # features.worm: enable +Now restart the volume for the changes to reflect, by performing volume stop and start. + + # gluster volume stop + # gluster volume start +Now mount the volume using fuse mount + + # mount -t glusterfs +create a file inside the mount point by running the command below + + # touch +Verify that user is able to create a file by running the command below + + # ls + +##How To Test +Now try deleting the above file which is been created + + # rm +Since WORM is enabled on the volume, it gives the following error message `rm: cannot remove '//': Read-only file system` + +put some content into the file which is created above. + + # echo "at the end of the file" >> +Now try editing the file by running the commnad below and verify that the following error message is displayed `rm: cannot remove '//': Read-only file system` + + # sed -i "1iAt the beginning of the file" +Now read the contents of the file and verify that file can be read. + + cat + +`Note: If WORM option is set on the volume before it is started, then volume need not be restarted for the changes to get reflected`. -- cgit From d2cdc392accdd35995370ee5b52aee5e5af7dee4 Mon Sep 17 00:00:00 2001 From: Niels de Vos Date: Sun, 27 Apr 2014 15:03:58 +0200 Subject: Update references to the maillinglist to gluster-devel@gluster.org gluster-devel@nongnu.org has moved to gluster-devel@gluster.org. All occurrences in the current (non legacy) documentation and code have been adjusted. Change-Id: I053162e633f7ea14fd3eed239ded017df165147c BUG: 1091705 Signed-off-by: Niels de Vos Reviewed-on: http://review.gluster.org/7573 Reviewed-by: Justin Clift Reviewed-by: Anand Avati Tested-by: Anand Avati --- MAINTAINERS | 2 +- api/examples/setup.py.in | 2 +- extras/test/ld-preload-test/README | 4 ++-- tests/README.md | 4 ++-- xlators/features/glupy/src/setup.py.in | 2 +- xlators/protocol/client/src/client-lk.c | 2 +- xlators/storage/posix/src/posix.c | 2 +- 7 files changed, 9 insertions(+), 9 deletions(-) diff --git a/MAINTAINERS b/MAINTAINERS index 49c7c3431..ba01c3503 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -7,7 +7,7 @@ have a question about a particular subset and also to provide a set of names to be CC'd when submitting a patch to obtain appropriate review. In general, if you have a question about inclusion of a patch, you should -consult gluster-devel@nongnu.org and not any specific individual privately. +consult gluster-devel@gluster.org and not any specific individual privately. Descriptions of section entries: diff --git a/api/examples/setup.py.in b/api/examples/setup.py.in index f22fa1f30..908ccda84 100644 --- a/api/examples/setup.py.in +++ b/api/examples/setup.py.in @@ -16,7 +16,7 @@ setup( description='Python client library for the GlusterFS libgfapi', long_description=DESC, author='Gluster Community', - author_email='gluster-devel@nongnu.org', + author_email='gluster-devel@gluster.org', license='LGPLv3', url='http://gluster.org/', package_dir={'gluster':''}, diff --git a/extras/test/ld-preload-test/README b/extras/test/ld-preload-test/README index 725b94023..df8000384 100644 --- a/extras/test/ld-preload-test/README +++ b/extras/test/ld-preload-test/README @@ -32,9 +32,9 @@ Instructions $ make (We've tested the tool on Debian and CentOS. If there are build errors or -warnings, please do report them to glusterfs-devel@nongnu.org.) +warnings, please do report them to gluster-devel@gluster.org.) 2. Run the test. $ ./test-preload.sh > preload.log -3. Mail the log to glusterfs-devel@nongnu.org. +3. Mail the log to gluster-devel@gluster.org. diff --git a/tests/README.md b/tests/README.md index 2b5ed8dcd..3a1406f6f 100644 --- a/tests/README.md +++ b/tests/README.md @@ -21,7 +21,7 @@ Regression tests framework for GlusterFS - Execute `/usr/share/glusterfs/run-tests.sh` as root. - If some test cases fail, report to GlusterFS community at - `gluster-devel@nongnu.org`. + `gluster-devel@gluster.org`. ## Reminder -- BE WARNED THAT THE TEST CASES DELETE /var/lib/glusterd/* !!! \ No newline at end of file +- BE WARNED THAT THE TEST CASES DELETE /var/lib/glusterd/* !!! diff --git a/xlators/features/glupy/src/setup.py.in b/xlators/features/glupy/src/setup.py.in index 1aea9875f..b9ee02c2b 100644 --- a/xlators/features/glupy/src/setup.py.in +++ b/xlators/features/glupy/src/setup.py.in @@ -16,7 +16,7 @@ setup( description='Glupy is the Python translator interface for GlusterFS', long_description=DESC, author='Gluster Community', - author_email='gluster-devel@nongnu.org', + author_email='gluster-devel@gluster.org', license='LGPLv3', url='http://gluster.org/', package_dir={'gluster':''}, diff --git a/xlators/protocol/client/src/client-lk.c b/xlators/protocol/client/src/client-lk.c index 1fd8f0d50..b3c36a420 100644 --- a/xlators/protocol/client/src/client-lk.c +++ b/xlators/protocol/client/src/client-lk.c @@ -227,7 +227,7 @@ subtract_locks (client_posix_lock_t *big, client_posix_lock_t *small) /* LOG-TODO : decide what more info is required here*/ gf_log ("client-protocol", GF_LOG_CRITICAL, "Unexpected case in subtract_locks. Please send " - "a bug report to gluster-devel@nongnu.org"); + "a bug report to gluster-devel@gluster.org"); } return v; diff --git a/xlators/storage/posix/src/posix.c b/xlators/storage/posix/src/posix.c index d33b5027e..c6a3aa3c4 100644 --- a/xlators/storage/posix/src/posix.c +++ b/xlators/storage/posix/src/posix.c @@ -4319,7 +4319,7 @@ _posix_handle_xattr_keyvalue_pair (dict_t *d, char *k, data_t *v, default: gf_log (this->name, GF_LOG_ERROR, "Unknown xattrop type (%d) on %s. Please send " - "a bug report to gluster-devel@nongnu.org", + "a bug report to gluster-devel@gluster.org", optype, filler->real_path); op_ret = -1; op_errno = EINVAL; -- cgit From d7b3e068290c41b13ecd664771814202d7d26881 Mon Sep 17 00:00:00 2001 From: Avra Sengupta Date: Mon, 7 Apr 2014 05:25:28 +0000 Subject: glusterd/snapshot: Adding snap_vol_id and snap_uuid to missed_snap_list Persisting missing snapshot info on disk as well as in memory in the following format: -------------NODE-UUID--------------:--------------SNAP-UUID-------------=---------SNAP-VOL-ID------------:BRICKNUM:-------BRICKPATH--------:OPERATION:STATUS 927cb5fe-63da-48f5-82f6-e6a09ddc81c4:8258b18f-d408-483d-8239-204039dc6397=a17b4fe42c5a45f7a916438643edaa13: 3 :/brick/brick-dirs/brick3: 1 : 1 927cb5fe-63da-48f5-82f6-e6a09ddc81c4:8258b18f-d408-483d-8239-204039dc6397=a17b4fe42c5a45f7a916438643edaa13: 3 :/brick/brick-dirs/brick3: 3 : 1 927cb5fe-63da-48f5-82f6-e6a09ddc81c4:8258b18f-d408-483d-8239-204039dc6397=83a3cc05453b46b2a7eda4c9a9208638: 3 :/brick/brick-dirs/brick3: 1 : 1 This data will be stored on disk at /var/lib/glusterd/snaps/missed_snaps_list In memory we maintain the data as a list of glusterd_missed_snap_info in conf, the key for this list are the first two fields, i.e NODE-UUID:SNAP-UUID. For every NODE-UUID:SNAP-UUID, there can be multiple operations missed on multiple bricks. So we maintain a list of glusterd_snap_op_t for every node of glusterd_missed_snap_info This list is maintained or updated during snapshot create, delete, and restore operations which are the only operations that if missed, are recorded in this list. During snapshot create, if a node is down, or a brick is down, we don't receive their mount point infos. snap_status of such bricks is marked as -1, and their brick details are added to this list. During snapshot delete, we check from originator node, if any other nodes, holding bricks of the said snap are down. Those are also added to the list. Also if the node is up, but the snapshot was pending for a snap brick, and its snap_status is -1, we add that to the list too. When a subsequent delete entry is processed for an already existing create entry, we just mark the create entries status as done (2), and don't add the delete entry to the list. During snapshot restore, we check from originator node, if any other nodes, holding bricks of the said snap are down. Those are also added to the list. Also if the node is up, but the snapshot was pending for a snap brick, and its snap_status is -1, we add that to the list too. Like delete when a subsequent restore entry is processed for an already existing create entry, we just mark the create entries status as done (2), and don't add the restore entry to the list. Change-Id: I54f63e28d3c40555d0f84528f38227103171f594 BUG: 1061685 Signed-off-by: Avra Sengupta Reviewed-on: http://review.gluster.org/7454 Tested-by: Gluster Build System Reviewed-by: Rajesh Joseph Reviewed-by: Vijay Bellur --- xlators/mgmt/glusterd/src/glusterd-handler.c | 91 ++++++++- xlators/mgmt/glusterd/src/glusterd-snapshot.c | 284 ++++++++++++++++---------- xlators/mgmt/glusterd/src/glusterd-store.c | 45 ++-- xlators/mgmt/glusterd/src/glusterd-store.h | 3 +- xlators/mgmt/glusterd/src/glusterd-utils.c | 25 ++- xlators/mgmt/glusterd/src/glusterd-utils.h | 3 +- xlators/mgmt/glusterd/src/glusterd.h | 10 +- 7 files changed, 305 insertions(+), 156 deletions(-) diff --git a/xlators/mgmt/glusterd/src/glusterd-handler.c b/xlators/mgmt/glusterd/src/glusterd-handler.c index 5869a88d4..ed756f15b 100644 --- a/xlators/mgmt/glusterd/src/glusterd-handler.c +++ b/xlators/mgmt/glusterd/src/glusterd-handler.c @@ -3895,6 +3895,52 @@ glusterd_handle_cli_clearlocks_volume (rpcsvc_request_t *req) __glusterd_handle_cli_clearlocks_volume); } +static int +get_volinfo_from_brickid (char *brickid, glusterd_volinfo_t **volinfo) +{ + int ret = -1; + char *volid_str = NULL; + char *brick = NULL; + char *brickid_dup = NULL; + uuid_t volid = {0}; + xlator_t *this = NULL; + + this = THIS; + GF_ASSERT (this); + GF_ASSERT (brickid); + + brickid_dup = gf_strdup (brickid); + if (!brickid_dup) + goto out; + + volid_str = brickid_dup; + brick = strchr (brickid_dup, ':'); + if (!brick) { + gf_log (this->name, GF_LOG_ERROR, + "Invalid brickid"); + goto out; + } + + *brick = '\0'; + brick++; + uuid_parse (volid_str, volid); + ret = glusterd_volinfo_find_by_volume_id (volid, volinfo); + if (ret) { + /* Check if it is a snapshot volume */ + ret = glusterd_snap_volinfo_find_by_volume_id (volid, volinfo); + if (ret) { + gf_log (this->name, GF_LOG_WARNING, + "Failed to find volinfo"); + goto out; + } + } + + ret = 0; +out: + GF_FREE (brickid_dup); + return ret; +} + static int get_brickinfo_from_brickid (char *brickid, glusterd_brickinfo_t **brickinfo) { @@ -3938,13 +3984,14 @@ out: int __glusterd_brick_rpc_notify (struct rpc_clnt *rpc, void *mydata, - rpc_clnt_event_t event, void *data) + rpc_clnt_event_t event, void *data) { - xlator_t *this = NULL; - glusterd_conf_t *conf = NULL; - int ret = 0; - char *brickid = NULL; - glusterd_brickinfo_t *brickinfo = NULL; + char *brickid = NULL; + int ret = 0; + glusterd_conf_t *conf = NULL; + glusterd_brickinfo_t *brickinfo = NULL; + glusterd_volinfo_t *volinfo = NULL; + xlator_t *this = NULL; brickid = mydata; if (!brickid) @@ -3961,6 +4008,37 @@ __glusterd_brick_rpc_notify (struct rpc_clnt *rpc, void *mydata, switch (event) { case RPC_CLNT_CONNECT: + /* If a node on coming back up, already starts a brick + * before the handshake, and the notification comes after + * the handshake is done, then we need to check if this + * is a restored brick with a snapshot pending. If so, we + * need to stop the brick + */ + if (brickinfo->snap_status == -1) { + gf_log (this->name, GF_LOG_INFO, + "Snapshot is pending on %s:%s. " + "Hence not starting the brick", + brickinfo->hostname, + brickinfo->path); + ret = get_volinfo_from_brickid (brickid, &volinfo); + if (ret) { + gf_log (this->name, GF_LOG_ERROR, + "Failed to get volinfo from " + "brickid(%s)", brickid); + goto out; + } + + ret = glusterd_brick_stop (volinfo, brickinfo, + _gf_false); + if (ret) { + gf_log (THIS->name, GF_LOG_ERROR, + "Unable to stop %s:%s", + brickinfo->hostname, brickinfo->path); + goto out; + } + + break; + } gf_log (this->name, GF_LOG_DEBUG, "Connected to %s:%s", brickinfo->hostname, brickinfo->path); glusterd_set_brick_status (brickinfo, GF_BRICK_STARTED); @@ -3986,6 +4064,7 @@ __glusterd_brick_rpc_notify (struct rpc_clnt *rpc, void *mydata, break; } +out: return ret; } diff --git a/xlators/mgmt/glusterd/src/glusterd-snapshot.c b/xlators/mgmt/glusterd/src/glusterd-snapshot.c index b294d1bc6..b99f2ac89 100644 --- a/xlators/mgmt/glusterd/src/glusterd-snapshot.c +++ b/xlators/mgmt/glusterd/src/glusterd-snapshot.c @@ -52,10 +52,66 @@ char snap_mount_folder[PATH_MAX]; +/* Look for disconnected peers, for missed snap creates or deletes */ static int32_t glusterd_find_missed_snap (dict_t *rsp_dict, glusterd_volinfo_t *vol, - char *snap_uuid, struct list_head *peers, - int32_t op); + struct list_head *peers, int32_t op) +{ + int32_t brick_count = -1; + int32_t ret = -1; + xlator_t *this = NULL; + glusterd_peerinfo_t *peerinfo = NULL; + glusterd_brickinfo_t *brickinfo = NULL; + + this = THIS; + GF_ASSERT (this); + GF_ASSERT (rsp_dict); + GF_ASSERT (peers); + GF_ASSERT (vol); + + brick_count = 0; + list_for_each_entry (brickinfo, &vol->bricks, brick_list) { + if (!uuid_compare (brickinfo->uuid, MY_UUID)) { + /* If the brick belongs to the same node */ + brick_count++; + continue; + } + + list_for_each_entry (peerinfo, peers, uuid_list) { + if (uuid_compare (peerinfo->uuid, brickinfo->uuid)) { + /* If the brick doesnt belong to this peer */ + continue; + } + + /* Found peer who owns the brick, * + * if peer is not connected or not * + * friend add it to missed snap list */ + if (!(peerinfo->connected) || + (peerinfo->state.state != + GD_FRIEND_STATE_BEFRIENDED)) { + ret = glusterd_add_missed_snaps_to_dict + (rsp_dict, + vol, brickinfo, + brick_count + 1, + op); + if (ret) { + gf_log (this->name, GF_LOG_ERROR, + "Failed to add missed snapshot " + "info for %s:%s in the " + "rsp_dict", brickinfo->hostname, + brickinfo->path); + goto out; + } + } + } + brick_count++; + } + + ret = 0; +out: + gf_log (this->name, GF_LOG_TRACE, "Returning %d", ret); + return ret; +} /* This function will restore a snapshot volumes * @@ -105,6 +161,7 @@ glusterd_snapshot_restore (dict_t *dict, char **op_errstr, dict_t *rsp_dict) goto out; } + /* TODO : As of now there is only volume in snapshot. * Change this when multiple volume snapshot is introduced */ @@ -122,7 +179,6 @@ glusterd_snapshot_restore (dict_t *dict, char **op_errstr, dict_t *rsp_dict) /* From origin glusterd check if * * any peers with snap bricks is down */ ret = glusterd_find_missed_snap (rsp_dict, snap_volinfo, - snap_volinfo->volname, &priv->peers, GF_SNAP_OPTION_TYPE_RESTORE); if (ret) { @@ -1060,7 +1116,7 @@ glusterd_lvm_snapshot_remove (dict_t *rsp_dict, glusterd_volinfo_t *snap_vol) /* Adding missed delete to the dict */ ret = glusterd_add_missed_snaps_to_dict (rsp_dict, - snap_vol->volname, + snap_vol, brickinfo, brick_count + 1, GF_SNAP_OPTION_TYPE_DELETE); @@ -2556,11 +2612,12 @@ out: /* Added missed_snap_entry to rsp_dict */ int32_t -glusterd_add_missed_snaps_to_dict (dict_t *rsp_dict, char *snap_uuid, +glusterd_add_missed_snaps_to_dict (dict_t *rsp_dict, + glusterd_volinfo_t *snap_vol, glusterd_brickinfo_t *brickinfo, int32_t brick_number, int32_t op) { - char *buf = NULL; + char *snap_uuid = NULL; char missed_snap_entry[PATH_MAX] = ""; char name_buf[PATH_MAX] = ""; int32_t missed_snap_count = -1; @@ -2570,20 +2627,20 @@ glusterd_add_missed_snaps_to_dict (dict_t *rsp_dict, char *snap_uuid, this = THIS; GF_ASSERT (this); GF_ASSERT (rsp_dict); - GF_ASSERT (snap_uuid); + GF_ASSERT (snap_vol); GF_ASSERT (brickinfo); - snprintf (missed_snap_entry, sizeof(missed_snap_entry), - "%s:%s=%d:%s:%d:%d", uuid_utoa(brickinfo->uuid), - snap_uuid, brick_number, brickinfo->path, op, - GD_MISSED_SNAP_PENDING); - - buf = gf_strdup (missed_snap_entry); - if (!buf) { + snap_uuid = gf_strdup (uuid_utoa (snap_vol->snapshot->snap_id)); + if (!snap_uuid) { ret = -1; goto out; } + snprintf (missed_snap_entry, sizeof(missed_snap_entry), + "%s:%s=%s:%d:%s:%d:%d", uuid_utoa(brickinfo->uuid), + snap_uuid, snap_vol->volname, brick_number, brickinfo->path, + op, GD_MISSED_SNAP_PENDING); + /* Fetch the missed_snap_count from the dict */ ret = dict_get_int32 (rsp_dict, "missed_snap_count", &missed_snap_count); @@ -2595,12 +2652,12 @@ glusterd_add_missed_snaps_to_dict (dict_t *rsp_dict, char *snap_uuid, /* Setting the missed_snap_entry in the rsp_dict */ snprintf (name_buf, sizeof(name_buf), "missed_snaps_%d", missed_snap_count); - ret = dict_set_dynstr (rsp_dict, name_buf, buf); + ret = dict_set_dynstr_with_alloc (rsp_dict, name_buf, + missed_snap_entry); if (ret) { gf_log (this->name, GF_LOG_ERROR, "Failed to set missed_snap_entry (%s) " - "in the rsp_dict.", buf); - GF_FREE (buf); + "in the rsp_dict.", missed_snap_entry); goto out; } missed_snap_count++; @@ -2616,6 +2673,9 @@ glusterd_add_missed_snaps_to_dict (dict_t *rsp_dict, char *snap_uuid, } out: + if (snap_uuid) + GF_FREE (snap_uuid); + gf_log (this->name, GF_LOG_TRACE, "Returning %d", ret); return ret; } @@ -2948,7 +3008,7 @@ glusterd_add_bricks_to_snap_volume (dict_t *dict, dict_t *rsp_dict, if (add_missed_snap) { ret = glusterd_add_missed_snaps_to_dict (rsp_dict, - snap_vol->volname, + snap_vol, original_brickinfo, brick_count + 1, GF_SNAP_OPTION_TYPE_CREATE); @@ -3048,70 +3108,6 @@ out: return ret; } -/* Look for disconnected peers, for missed snap creates or deletes */ -static int32_t -glusterd_find_missed_snap (dict_t *rsp_dict, glusterd_volinfo_t *vol, - char *snap_uuid, struct list_head *peers, - int32_t op) -{ - int32_t brick_count = -1; - int32_t ret = -1; - xlator_t *this = NULL; - glusterd_peerinfo_t *peerinfo = NULL; - glusterd_brickinfo_t *brickinfo = NULL; - - this = THIS; - GF_ASSERT (this); - GF_ASSERT (rsp_dict); - GF_ASSERT (peers); - GF_ASSERT (vol); - GF_ASSERT (snap_uuid); - - brick_count = 0; - list_for_each_entry (brickinfo, &vol->bricks, brick_list) { - if (!uuid_compare (brickinfo->uuid, MY_UUID)) { - /* If the brick belongs to the same node */ - brick_count++; - continue; - } - - list_for_each_entry (peerinfo, peers, uuid_list) { - if (uuid_compare (peerinfo->uuid, brickinfo->uuid)) { - /* If the brick doesnt belong to this peer */ - continue; - } - - /* Found peer who owns the brick, * - * if peer is not connected or not * - * friend add it to missed snap list */ - if (!(peerinfo->connected) || - (peerinfo->state.state != - GD_FRIEND_STATE_BEFRIENDED)) { - ret = glusterd_add_missed_snaps_to_dict - (rsp_dict, - snap_uuid, - brickinfo, - brick_count + 1, - op); - if (ret) { - gf_log (this->name, GF_LOG_ERROR, - "Failed to add missed snapshot " - "info for %s:%s in the " - "rsp_dict", brickinfo->hostname, - brickinfo->path); - goto out; - } - } - } - brick_count++; - } - - ret = 0; -out: - gf_log (this->name, GF_LOG_TRACE, "Returning %d", ret); - return ret; -} - glusterd_volinfo_t * glusterd_do_snap_vol (glusterd_volinfo_t *origin_vol, glusterd_snap_t *snap, dict_t *dict, dict_t *rsp_dict, int64_t volcount) @@ -3592,7 +3588,6 @@ glusterd_snapshot_remove_commit (dict_t *dict, char **op_errstr, /* From origin glusterd check if * * any peers with snap bricks is down */ ret = glusterd_find_missed_snap (rsp_dict, snap_volinfo, - snap_volinfo->volname, &priv->peers, GF_SNAP_OPTION_TYPE_DELETE); if (ret) { @@ -3707,7 +3702,14 @@ glusterd_snapshot_update_snaps_post_validate (dict_t *dict, char **op_errstr, goto out; } - ret = glusterd_store_update_missed_snaps (dict, missed_snap_count); + ret = glusterd_add_missed_snaps_to_list (dict, missed_snap_count); + if (ret) { + gf_log (this->name, GF_LOG_ERROR, + "Failed to add missed snaps to list"); + goto out; + } + + ret = glusterd_store_update_missed_snaps (); if (ret) { gf_log (this->name, GF_LOG_ERROR, "Failed to update missed_snaps_list"); @@ -5330,6 +5332,30 @@ glusterd_free_snap_op (glusterd_snap_op_t *snap_op) } } +static inline void +glusterd_free_missed_snapinfo (glusterd_missed_snap_info *missed_snapinfo) +{ + glusterd_snap_op_t *snap_opinfo = NULL; + glusterd_snap_op_t *tmp = NULL; + + if (missed_snapinfo) { + list_for_each_entry_safe (snap_opinfo, tmp, + &missed_snapinfo->snap_ops, + snap_ops_list) { + glusterd_free_snap_op (snap_opinfo); + snap_opinfo = NULL; + } + + if (missed_snapinfo->node_uuid) + GF_FREE (missed_snapinfo->node_uuid); + + if (missed_snapinfo->snap_uuid) + GF_FREE (missed_snapinfo->snap_uuid); + + GF_FREE (missed_snapinfo); + } +} + /* Look for duplicates and accordingly update the list */ int32_t glusterd_update_missed_snap_entry (glusterd_missed_snap_info *missed_snapinfo, @@ -5347,6 +5373,13 @@ glusterd_update_missed_snap_entry (glusterd_missed_snap_info *missed_snapinfo, list_for_each_entry (snap_opinfo, &missed_snapinfo->snap_ops, snap_ops_list) { + /* If the entry is not for the same snap_vol_id + * then continue + */ + if (strcmp (snap_opinfo->snap_vol_id, + missed_snap_op->snap_vol_id)) + continue; + if ((!strcmp (snap_opinfo->brick_path, missed_snap_op->brick_path)) && (snap_opinfo->op == missed_snap_op->op)) { @@ -5358,8 +5391,10 @@ glusterd_update_missed_snap_entry (glusterd_missed_snap_info *missed_snapinfo, snap_opinfo->status = GD_MISSED_SNAP_DONE; gf_log (this->name, GF_LOG_INFO, "Updating missed snap status " - "for %s:%d:%s:%d as DONE", - missed_snapinfo->node_snap_info, + "for %s:%s=%s:%d:%s:%d as DONE", + missed_snapinfo->node_uuid, + missed_snapinfo->snap_uuid, + snap_opinfo->snap_vol_id, snap_opinfo->brick_num, snap_opinfo->brick_path, snap_opinfo->op); @@ -5372,15 +5407,19 @@ glusterd_update_missed_snap_entry (glusterd_missed_snap_info *missed_snapinfo, } else if ((snap_opinfo->brick_num == missed_snap_op->brick_num) && (snap_opinfo->op == GF_SNAP_OPTION_TYPE_CREATE) && - (missed_snap_op->op == - GF_SNAP_OPTION_TYPE_DELETE)) { + ((missed_snap_op->op == + GF_SNAP_OPTION_TYPE_DELETE) || + (missed_snap_op->op == + GF_SNAP_OPTION_TYPE_RESTORE))) { /* Optimizing create and delete entries for the same * brick and same node */ gf_log (this->name, GF_LOG_INFO, "Updating missed snap status " - "for %s:%d:%s:%d as DONE", - missed_snapinfo->node_snap_info, + "for %s:%s=%s:%d:%s:%d as DONE", + missed_snapinfo->node_uuid, + missed_snapinfo->snap_uuid, + snap_opinfo->snap_vol_id, snap_opinfo->brick_num, snap_opinfo->brick_path, snap_opinfo->op); @@ -5408,10 +5447,13 @@ out: /* Add new missed snap entry to the missed_snaps list. */ int32_t -glusterd_store_missed_snaps_list (char *missed_info, int32_t brick_num, - char *brick_path, int32_t snap_op, - int32_t snap_status) +glusterd_add_new_entry_to_list (char *missed_info, char *snap_vol_id, + int32_t brick_num, char *brick_path, + int32_t snap_op, int32_t snap_status) { + char *buf = NULL; + char *save_ptr = NULL; + char node_snap_info[PATH_MAX] = ""; int32_t ret = -1; glusterd_missed_snap_info *missed_snapinfo = NULL; glusterd_snap_op_t *missed_snap_op = NULL; @@ -5423,6 +5465,7 @@ glusterd_store_missed_snaps_list (char *missed_info, int32_t brick_num, this = THIS; GF_ASSERT(this); GF_ASSERT(missed_info); + GF_ASSERT(snap_vol_id); GF_ASSERT(brick_path); priv = this->private; @@ -5438,6 +5481,11 @@ glusterd_store_missed_snaps_list (char *missed_info, int32_t brick_num, goto out; } + missed_snap_op->snap_vol_id = gf_strdup(snap_vol_id); + if (!missed_snap_op->snap_vol_id) { + ret = -1; + goto out; + } missed_snap_op->brick_path = gf_strdup(brick_path); if (!missed_snap_op->brick_path) { ret = -1; @@ -5450,8 +5498,10 @@ glusterd_store_missed_snaps_list (char *missed_info, int32_t brick_num, /* Look for other entries for the same node and same snap */ list_for_each_entry (missed_snapinfo, &priv->missed_snaps_list, missed_snaps) { - if (!strcmp (missed_snapinfo->node_snap_info, - missed_info)) { + snprintf (node_snap_info, sizeof(node_snap_info), + "%s:%s", missed_snapinfo->node_uuid, + missed_snapinfo->snap_uuid); + if (!strcmp (node_snap_info, missed_info)) { /* Found missed snapshot info for * * the same node and same snap */ match = _gf_true; @@ -5468,8 +5518,24 @@ glusterd_store_missed_snaps_list (char *missed_info, int32_t brick_num, goto out; } free_missed_snap_info = _gf_true; - missed_snapinfo->node_snap_info = gf_strdup(missed_info); - if (!missed_snapinfo->node_snap_info) { + buf = strtok_r (missed_info, ":", &save_ptr); + if (!buf) { + ret = -1; + goto out; + } + missed_snapinfo->node_uuid = gf_strdup(buf); + if (!missed_snapinfo->node_uuid) { + ret = -1; + goto out; + } + + buf = strtok_r (NULL, ":", &save_ptr); + if (!buf) { + ret = -1; + goto out; + } + missed_snapinfo->snap_uuid = gf_strdup(buf); + if (!missed_snapinfo->snap_uuid) { ret = -1; goto out; } @@ -5496,12 +5562,8 @@ out: glusterd_free_snap_op (missed_snap_op); if (missed_snapinfo && - (free_missed_snap_info == _gf_true)) { - if (missed_snapinfo->node_snap_info) - GF_FREE (missed_snapinfo->node_snap_info); - - GF_FREE (missed_snapinfo); - } + (free_missed_snap_info == _gf_true)) + glusterd_free_missed_snapinfo (missed_snapinfo); } gf_log (this->name, GF_LOG_TRACE, "Returning %d", ret); @@ -5517,6 +5579,7 @@ glusterd_add_missed_snaps_to_list (dict_t *dict, int32_t missed_snap_count) char *save_ptr = NULL; char *nodeid = NULL; char *snap_uuid = NULL; + char *snap_vol_id = NULL; char *brick_path = NULL; char missed_info[PATH_MAX] = ""; char name_buf[PATH_MAX] = ""; @@ -5563,13 +5626,14 @@ glusterd_add_missed_snaps_to_list (dict_t *dict, int32_t missed_snap_count) */ nodeid = strtok_r (tmp, ":", &save_ptr); snap_uuid = strtok_r (NULL, "=", &save_ptr); + snap_vol_id = strtok_r (NULL, ":", &save_ptr); brick_num = atoi(strtok_r (NULL, ":", &save_ptr)); brick_path = strtok_r (NULL, ":", &save_ptr); snap_op = atoi(strtok_r (NULL, ":", &save_ptr)); snap_status = atoi(strtok_r (NULL, ":", &save_ptr)); if (!nodeid || !snap_uuid || !brick_path || - brick_num < 1 || snap_op < 1 || + !snap_vol_id || brick_num < 1 || snap_op < 1 || snap_status < 1) { gf_log (this->name, GF_LOG_ERROR, "Invalid missed_snap_entry"); @@ -5580,11 +5644,12 @@ glusterd_add_missed_snaps_to_list (dict_t *dict, int32_t missed_snap_count) snprintf (missed_info, sizeof(missed_info), "%s:%s", nodeid, snap_uuid); - ret = glusterd_store_missed_snaps_list (missed_info, - brick_num, - brick_path, - snap_op, - snap_status); + ret = glusterd_add_new_entry_to_list (missed_info, + snap_vol_id, + brick_num, + brick_path, + snap_op, + snap_status); if (ret) { gf_log (this->name, GF_LOG_ERROR, "Failed to store missed snaps_list"); @@ -5595,6 +5660,7 @@ glusterd_add_missed_snaps_to_list (dict_t *dict, int32_t missed_snap_count) tmp = NULL; } + ret = 0; out: if (tmp) GF_FREE (tmp); diff --git a/xlators/mgmt/glusterd/src/glusterd-store.c b/xlators/mgmt/glusterd/src/glusterd-store.c index b803ba282..9c04aab50 100644 --- a/xlators/mgmt/glusterd/src/glusterd-store.c +++ b/xlators/mgmt/glusterd/src/glusterd-store.c @@ -2994,6 +2994,7 @@ glusterd_store_retrieve_missed_snaps_list (xlator_t *this) { char buf[PATH_MAX] = ""; char path[PATH_MAX] = ""; + char *snap_vol_id = NULL; char *missed_node_info = NULL; char *brick_path = NULL; char *value = NULL; @@ -3048,12 +3049,13 @@ glusterd_store_retrieve_missed_snaps_list (xlator_t *this) } /* Fetch the brick_num, brick_path, snap_op and snap status */ - brick_num = atoi(strtok_r (value, ":", &save_ptr)); + snap_vol_id = strtok_r (value, ":", &save_ptr); + brick_num = atoi(strtok_r (NULL, ":", &save_ptr)); brick_path = strtok_r (NULL, ":", &save_ptr); snap_op = atoi(strtok_r (NULL, ":", &save_ptr)); snap_status = atoi(strtok_r (NULL, ":", &save_ptr)); - if (!missed_node_info || !brick_path || + if (!missed_node_info || !brick_path || !snap_vol_id || brick_num < 1 || snap_op < 1 || snap_status < 1) { gf_log (this->name, GF_LOG_ERROR, @@ -3062,11 +3064,12 @@ glusterd_store_retrieve_missed_snaps_list (xlator_t *this) goto out; } - ret = glusterd_store_missed_snaps_list (missed_node_info, - brick_num, - brick_path, - snap_op, - snap_status); + ret = glusterd_add_new_entry_to_list (missed_node_info, + snap_vol_id, + brick_num, + brick_path, + snap_op, + snap_status); if (ret) { gf_log (this->name, GF_LOG_ERROR, "Failed to store missed snaps_list"); @@ -3145,6 +3148,7 @@ out: int32_t glusterd_store_write_missed_snapinfo (int32_t fd) { + char key[PATH_MAX] = ""; char value[PATH_MAX] = ""; int32_t ret = -1; glusterd_conf_t *priv = NULL; @@ -3164,14 +3168,15 @@ glusterd_store_write_missed_snapinfo (int32_t fd) list_for_each_entry (snap_opinfo, &missed_snapinfo->snap_ops, snap_ops_list) { - snprintf (value, sizeof(value), "%d:%s:%d:%d", + snprintf (key, sizeof(key), "%s:%s", + missed_snapinfo->node_uuid, + missed_snapinfo->snap_uuid); + snprintf (value, sizeof(value), "%s:%d:%s:%d:%d", + snap_opinfo->snap_vol_id, snap_opinfo->brick_num, snap_opinfo->brick_path, snap_opinfo->op, snap_opinfo->status); - ret = gf_store_save_value - (fd, - missed_snapinfo->node_snap_info, - value); + ret = gf_store_save_value (fd, key, value); if (ret) { gf_log (this->name, GF_LOG_ERROR, "Failed to write missed snapinfo"); @@ -3189,7 +3194,7 @@ out: /* Adds the missed snap entries to the in-memory conf->missed_snap_list * * and writes them to disk */ int32_t -glusterd_store_update_missed_snaps (dict_t *dict, int32_t missed_snap_count) +glusterd_store_update_missed_snaps () { int32_t fd = -1; int32_t ret = -1; @@ -3198,17 +3203,10 @@ glusterd_store_update_missed_snaps (dict_t *dict, int32_t missed_snap_count) this = THIS; GF_ASSERT(this); - GF_ASSERT(dict); priv = this->private; GF_ASSERT (priv); - if (missed_snap_count < 1) { - gf_log (this->name, GF_LOG_DEBUG, "No missed snaps"); - ret = 0; - goto out; - } - ret = glusterd_store_create_missed_snaps_list_shandle_on_absence (); if (ret) { gf_log (this->name, GF_LOG_ERROR, "Unable to obtain " @@ -3224,13 +3222,6 @@ glusterd_store_update_missed_snaps (dict_t *dict, int32_t missed_snap_count) goto out; } - ret = glusterd_add_missed_snaps_to_list (dict, missed_snap_count); - if (ret) { - gf_log (this->name, GF_LOG_ERROR, - "Failed to add missed snaps to list"); - goto out; - } - ret = glusterd_store_write_missed_snapinfo (fd); if (ret) { gf_log (this->name, GF_LOG_ERROR, diff --git a/xlators/mgmt/glusterd/src/glusterd-store.h b/xlators/mgmt/glusterd/src/glusterd-store.h index 64c073a8a..19123f005 100644 --- a/xlators/mgmt/glusterd/src/glusterd-store.h +++ b/xlators/mgmt/glusterd/src/glusterd-store.h @@ -168,7 +168,6 @@ int32_t glusterd_store_snap (glusterd_snap_t *snap); int32_t -glusterd_store_update_missed_snaps (dict_t *dict, - int32_t missed_snap_count); +glusterd_store_update_missed_snaps (); #endif diff --git a/xlators/mgmt/glusterd/src/glusterd-utils.c b/xlators/mgmt/glusterd/src/glusterd-utils.c index 74317eb44..b4644432d 100644 --- a/xlators/mgmt/glusterd/src/glusterd-utils.c +++ b/xlators/mgmt/glusterd/src/glusterd-utils.c @@ -709,7 +709,7 @@ glusterd_snap_volinfo_restore (dict_t *rsp_dict, /* Adding missed delete to the dict */ ret = glusterd_add_missed_snaps_to_dict (rsp_dict, - snap_volinfo->volname, + snap_volinfo, brickinfo, brick_count + 1, GF_SNAP_OPTION_TYPE_RESTORE); @@ -2693,8 +2693,10 @@ glusterd_add_missed_snaps_to_export_dict (dict_t *vols) snap_ops_list) { snprintf (name_buf, sizeof(name_buf), "missed_snaps_%d", missed_snap_count); - snprintf (value, sizeof(value), "%s=%d:%s:%d:%d", - missed_snapinfo->node_snap_info, + snprintf (value, sizeof(value), "%s:%s=%s:%d:%s:%d:%d", + missed_snapinfo->node_uuid, + missed_snapinfo->snap_uuid, + snap_opinfo->snap_vol_id, snap_opinfo->brick_num, snap_opinfo->brick_path, snap_opinfo->op, @@ -3937,7 +3939,11 @@ glusterd_volinfo_stop_stale_bricks (glusterd_volinfo_t *new_volinfo, old_brickinfo->hostname, old_brickinfo->path, new_volinfo, &new_brickinfo); - if (ret) { + /* If the brick is stale, i.e it's not a part of the new volume + * or if it's part of the new volume and is pending a snap, + * then stop the brick process + */ + if (ret || (new_brickinfo->snap_status == -1)) { /*TODO: may need to switch to 'atomic' flavour of * brick_stop, once we make peer rpc program also * synctask enabled*/ @@ -4240,7 +4246,14 @@ glusterd_import_friend_missed_snap_list (dict_t *vols) goto out; } - ret = glusterd_store_update_missed_snaps (vols, missed_snap_count); + ret = glusterd_add_missed_snaps_to_list (vols, missed_snap_count); + if (ret) { + gf_log (this->name, GF_LOG_ERROR, + "Failed to add missed snaps to list"); + goto out; + } + + ret = glusterd_store_update_missed_snaps (); if (ret) { gf_log (this->name, GF_LOG_ERROR, "Failed to update missed_snaps_list"); @@ -10086,7 +10099,6 @@ glusterd_missed_snapinfo_new (glusterd_missed_snap_info **missed_snapinfo) if (!new_missed_snapinfo) goto out; - new_missed_snapinfo->node_snap_info = NULL; INIT_LIST_HEAD (&new_missed_snapinfo->missed_snaps); INIT_LIST_HEAD (&new_missed_snapinfo->snap_ops); @@ -10116,7 +10128,6 @@ glusterd_missed_snap_op_new (glusterd_snap_op_t **snap_op) if (!new_snap_op) goto out; - new_snap_op->brick_path = NULL; new_snap_op->brick_num = -1; new_snap_op->op = -1; new_snap_op->status = -1; diff --git a/xlators/mgmt/glusterd/src/glusterd-utils.h b/xlators/mgmt/glusterd/src/glusterd-utils.h index 0f1c52372..ec65357f9 100644 --- a/xlators/mgmt/glusterd/src/glusterd-utils.h +++ b/xlators/mgmt/glusterd/src/glusterd-utils.h @@ -715,7 +715,8 @@ int32_t glusterd_missed_snap_op_new (glusterd_snap_op_t **snap_op); int32_t -glusterd_add_missed_snaps_to_dict (dict_t *rsp_dict, char *snap_uuid, +glusterd_add_missed_snaps_to_dict (dict_t *rsp_dict, + glusterd_volinfo_t *snap_vol, glusterd_brickinfo_t *brickinfo, int32_t brick_number, int32_t op); diff --git a/xlators/mgmt/glusterd/src/glusterd.h b/xlators/mgmt/glusterd/src/glusterd.h index 7568a2e9a..d50fa03d2 100644 --- a/xlators/mgmt/glusterd/src/glusterd.h +++ b/xlators/mgmt/glusterd/src/glusterd.h @@ -393,6 +393,7 @@ struct glusterd_snap_ { }; typedef struct glusterd_snap_op_ { + char *snap_vol_id; int32_t brick_num; char *brick_path; int32_t op; @@ -401,7 +402,8 @@ typedef struct glusterd_snap_op_ { } glusterd_snap_op_t; typedef struct glusterd_missed_snap_ { - char *node_snap_info; + char *node_uuid; + char *snap_uuid; struct list_head missed_snaps; struct list_head snap_ops; } glusterd_missed_snap_info; @@ -989,8 +991,8 @@ int32_t glusterd_add_missed_snaps_to_list (dict_t *dict, int32_t missed_snap_count); int32_t -glusterd_store_missed_snaps_list (char *missed_info, int32_t brick_num, - char *brick_path, int32_t snap_op, - int32_t snap_status); +glusterd_add_new_entry_to_list (char *missed_info, char *snap_vol_id, + int32_t brick_num, char *brick_path, + int32_t snap_op, int32_t snap_status); #endif -- cgit From 22f47322d246c94d0bec8e893e4837a67d39f544 Mon Sep 17 00:00:00 2001 From: Atin Mukherjee Date: Mon, 3 Mar 2014 18:00:59 +0530 Subject: Barrier: Barrier translator options configuration barrier enable/disable, barrier-timeout configuration in barrier translator. Change-Id: I7cbf9cd4f5e55d42dcc6b7cd6827234566c7b6f3 BUG: 1060002 Signed-off-by: Atin Mukherjee Reviewed-on: http://review.gluster.org/7177 Reviewed-by: Kaushal M Tested-by: Gluster Build System --- xlators/features/barrier/src/barrier.c | 6 +++--- xlators/mgmt/glusterd/src/glusterd-volgen.c | 4 ++++ xlators/mgmt/glusterd/src/glusterd-volume-set.c | 10 ++++++++++ 3 files changed, 17 insertions(+), 3 deletions(-) diff --git a/xlators/features/barrier/src/barrier.c b/xlators/features/barrier/src/barrier.c index 9937698ed..5edb9cdd3 100644 --- a/xlators/features/barrier/src/barrier.c +++ b/xlators/features/barrier/src/barrier.c @@ -415,7 +415,7 @@ reconfigure (xlator_t *this, dict_t *options) GF_ASSERT (priv); GF_OPTION_RECONF ("barrier", barrier_enabled, options, bool, out); - GF_OPTION_RECONF ("timeout", timeout, options, time, out); + GF_OPTION_RECONF ("barrier-timeout", timeout, options, time, out); INIT_LIST_HEAD (&queue); @@ -490,7 +490,7 @@ init (xlator_t *this) LOCK_INIT (&priv->lock); GF_OPTION_INIT ("barrier", priv->barrier_enabled, bool, out); - GF_OPTION_INIT ("timeout", timeout, time, out); + GF_OPTION_INIT ("barrier-timeout", timeout, time, out); priv->timeout.tv_sec = timeout; INIT_LIST_HEAD (&priv->queue); @@ -646,7 +646,7 @@ struct volume_options options[] = { "write (with O_SYNC), fsync. It is turned \"off\" by " "default." }, - { .key = {"timeout"}, + { .key = {"barrier-timeout"}, .type = GF_OPTION_TYPE_TIME, .default_value = "120", .description = "After 'timeout' seconds since the time 'barrier' " diff --git a/xlators/mgmt/glusterd/src/glusterd-volgen.c b/xlators/mgmt/glusterd/src/glusterd-volgen.c index 316b70f77..797370a87 100644 --- a/xlators/mgmt/glusterd/src/glusterd-volgen.c +++ b/xlators/mgmt/glusterd/src/glusterd-volgen.c @@ -1589,6 +1589,10 @@ server_graph_builder (volgen_graph_t *graph, glusterd_volinfo_t *volinfo, if (ret) return -1; + xl = volgen_graph_add (graph, "features/barrier", volname); + if (!xl) + return -1; + ret = dict_get_int32 (volinfo->dict, "enable-pump", &pump); if (ret == -ENOENT) ret = pump = 0; diff --git a/xlators/mgmt/glusterd/src/glusterd-volume-set.c b/xlators/mgmt/glusterd/src/glusterd-volume-set.c index 1c5d359d9..e3af4e7f5 100644 --- a/xlators/mgmt/glusterd/src/glusterd-volume-set.c +++ b/xlators/mgmt/glusterd/src/glusterd-volume-set.c @@ -1524,6 +1524,16 @@ struct volopt_map_entry glusterd_volopt_map[] = { .type = NO_DOC, .op_version = 3 }, + { .key = "features.barrier", + .voltype = "features/barrier", + .value = "disable", + .op_version = 4 + }, + { .key = "features.barrier-timeout", + .voltype = "features/barrier", + .value = "120", + .op_version = 4 + }, { .key = NULL } }; -- cgit From 49733d307f010bfeb3d2440402ff51a5366262f5 Mon Sep 17 00:00:00 2001 From: Yuan Ding Date: Mon, 21 Apr 2014 22:10:13 +0800 Subject: gNFS: gNFS drc cache failed to detecte duplicates. After the drc cache get full, message "DRC failed to detect duplicates" keep printed in the log. The root cause is drc_compare_reqs use the wrong compare type. This function should use type drc_cache_op_t as its input type. Since all rbtree related code (except function rpcsvc_drc_lookup) in drc cache pass drc_cache_op_t as compare type. Only rpcsvc_drc_lookup use type rpcsvc_request_t. It has been modified too. Change-Id: I925c097debe6b82f267986961fd4e7755f3de9af BUG: 1089676 Signed-off-by: Yuan Ding Reviewed-on: http://review.gluster.org/7519 Reviewed-by: Niels de Vos Reviewed-by: Santosh Pradhan Tested-by: Gluster Build System Reviewed-by: Anand Avati --- rpc/rpc-lib/src/rpc-drc.c | 14 ++++++++++---- 1 file changed, 10 insertions(+), 4 deletions(-) diff --git a/rpc/rpc-lib/src/rpc-drc.c b/rpc/rpc-lib/src/rpc-drc.c index 0babb9bc4..bc37324d3 100644 --- a/rpc/rpc-lib/src/rpc-drc.c +++ b/rpc/rpc-lib/src/rpc-drc.c @@ -127,14 +127,14 @@ int drc_compare_reqs (const void *item, const void *rb_node_data, void *param) { int ret = -1; - rpcsvc_request_t *req = NULL; + drc_cached_op_t *req = NULL; drc_cached_op_t *reply = NULL; GF_ASSERT (item); GF_ASSERT (rb_node_data); GF_ASSERT (param); - req = (rpcsvc_request_t *)item; + req = (drc_cached_op_t *)item; reply = (drc_cached_op_t *)rb_node_data; ret = req->xid - reply->xid; @@ -143,7 +143,7 @@ drc_compare_reqs (const void *item, const void *rb_node_data, void *param) if (req->prognum == reply->prognum && req->procnum == reply->procnum && - req->progver == reply->progversion) + req->progversion == reply->progversion) return 0; return 1; @@ -331,6 +331,12 @@ rpcsvc_drc_lookup (rpcsvc_request_t *req) { drc_client_t *client = NULL; drc_cached_op_t *reply = NULL; + drc_cached_op_t new = { + .xid = req->xid, + .prognum = req->prognum, + .progversion = req->progver, + .procnum = req->procnum, + }; GF_ASSERT (req); @@ -347,7 +353,7 @@ rpcsvc_drc_lookup (rpcsvc_request_t *req) if (client->op_count == 0) goto out; - reply = rb_find (client->rbtree, req); + reply = rb_find (client->rbtree, &new); out: if (client) -- cgit From 5d9172e0b3e14795db7aba321cfcac428a201399 Mon Sep 17 00:00:00 2001 From: Avra Sengupta Date: Mon, 7 Apr 2014 06:02:10 +0000 Subject: glusterd/snapshot: Perform missed snap deletes and restores. Replacing is_volume_restored(gf_boolean_t) with restored_from_snap(uuid_t) in glusterd_volinfo_ Also removed gd_restore_snap_volume from glusterd-volgen.c to glusterd-snapshot.c Change-Id: Ic615a1658cfaffa98d4590506ac82f20bf709ad6 BUG: 1089906 Signed-off-by: Avra Sengupta Reviewed-on: http://review.gluster.org/7455 Tested-by: Gluster Build System Reviewed-by: Krishnan Parthasarathi Reviewed-by: Rajesh Joseph Reviewed-by: Vijay Bellur --- xlators/mgmt/glusterd/src/glusterd-snapshot.c | 159 +++++++++++++++++-- xlators/mgmt/glusterd/src/glusterd-store.c | 32 ++-- xlators/mgmt/glusterd/src/glusterd-store.h | 2 +- xlators/mgmt/glusterd/src/glusterd-utils.c | 217 ++++++++++++++++++++++++-- xlators/mgmt/glusterd/src/glusterd-utils.h | 5 + xlators/mgmt/glusterd/src/glusterd-volgen.c | 125 --------------- xlators/mgmt/glusterd/src/glusterd-volgen.h | 3 - xlators/mgmt/glusterd/src/glusterd.h | 2 +- 8 files changed, 374 insertions(+), 171 deletions(-) diff --git a/xlators/mgmt/glusterd/src/glusterd-snapshot.c b/xlators/mgmt/glusterd/src/glusterd-snapshot.c index b99f2ac89..c1967a29c 100644 --- a/xlators/mgmt/glusterd/src/glusterd-snapshot.c +++ b/xlators/mgmt/glusterd/src/glusterd-snapshot.c @@ -124,7 +124,6 @@ int glusterd_snapshot_restore (dict_t *dict, char **op_errstr, dict_t *rsp_dict) { int ret = -1; - char *volname = NULL; char *snapname = NULL; xlator_t *this = NULL; glusterd_volinfo_t *snap_volinfo = NULL; @@ -152,7 +151,7 @@ glusterd_snapshot_restore (dict_t *dict, char **op_errstr, dict_t *rsp_dict) snap = glusterd_find_snap_by_name (snapname); if (NULL == snap) { ret = gf_asprintf (op_errstr, "Snap (%s) not found", - snapname); + snapname); if (ret < 0) { goto out; } @@ -195,7 +194,7 @@ glusterd_snapshot_restore (dict_t *dict, char **op_errstr, dict_t *rsp_dict) * failure. */ gf_log (this->name, GF_LOG_ERROR, "Failed to restore " - "snap for %s volume", volname); + "snap for %s", snapname); goto out; } @@ -218,7 +217,7 @@ out: * @param rsp_dict response dictionary * @return Negative value on Failure and 0 in success */ -int +int32_t glusterd_snapshot_restore_prevalidate (dict_t *dict, char **op_errstr, dict_t *rsp_dict) { @@ -1092,11 +1091,13 @@ glusterd_lvm_snapshot_remove (dict_t *rsp_dict, glusterd_volinfo_t *snap_vol) this = THIS; GF_ASSERT (this); - GF_ASSERT (rsp_dict); GF_ASSERT (snap_vol); - if (!snap_vol) { - gf_log (this->name, GF_LOG_ERROR, "snap volinfo is NULL"); + if ((snap_vol->is_snap_volume == _gf_false) && + (uuid_is_null (snap_vol->restored_from_snap))) { + gf_log (this->name, GF_LOG_DEBUG, + "Not a snap volume, or a restored snap volume."); + ret = 0; goto out; } @@ -1113,20 +1114,23 @@ glusterd_lvm_snapshot_remove (dict_t *rsp_dict, glusterd_volinfo_t *snap_vol) brickinfo->hostname, brickinfo->path, snap_vol->snapshot->snapname); - /* Adding missed delete to the dict */ - ret = glusterd_add_missed_snaps_to_dict + if (rsp_dict && + (snap_vol->is_snap_volume == _gf_true)) { + /* Adding missed delete to the dict */ + ret = glusterd_add_missed_snaps_to_dict (rsp_dict, snap_vol, brickinfo, brick_count + 1, GF_SNAP_OPTION_TYPE_DELETE); - if (ret) { - gf_log (this->name, GF_LOG_ERROR, - "Failed to add missed snapshot info " - "for %s:%s in the rsp_dict", - brickinfo->hostname, - brickinfo->path); - goto out; + if (ret) { + gf_log (this->name, GF_LOG_ERROR, + "Failed to add missed snapshot " + "info for %s:%s in the " + "rsp_dict", brickinfo->hostname, + brickinfo->path); + goto out; + } } continue; @@ -5668,3 +5672,126 @@ out: gf_log (this->name, GF_LOG_TRACE, "Returning %d", ret); return ret; } + +/* This function will restore origin volume to it's snap. + * The restore operation will simply replace the Gluster origin + * volume with the snap volume. + * TODO: Multi-volume delete to be done. + * Cleanup in case of restore failure is pending. + * + * @param orig_vol volinfo of origin volume + * @param snap_vol volinfo of snapshot volume + * + * @return 0 on success and negative value on error + */ +int +gd_restore_snap_volume (dict_t *rsp_dict, + glusterd_volinfo_t *orig_vol, + glusterd_volinfo_t *snap_vol) +{ + int ret = -1; + glusterd_volinfo_t *new_volinfo = NULL; + glusterd_snap_t *snap = NULL; + xlator_t *this = NULL; + glusterd_conf_t *conf = NULL; + glusterd_volinfo_t *temp_volinfo = NULL; + glusterd_volinfo_t *voliter = NULL; + + this = THIS; + GF_ASSERT (this); + GF_ASSERT (rsp_dict); + conf = this->private; + GF_ASSERT (conf); + + GF_VALIDATE_OR_GOTO (this->name, orig_vol, out); + GF_VALIDATE_OR_GOTO (this->name, snap_vol, out); + snap = snap_vol->snapshot; + GF_VALIDATE_OR_GOTO (this->name, snap, out); + + /* Snap volume must be stoped before performing the + * restore operation. + */ + ret = glusterd_stop_volume (snap_vol); + if (ret) { + gf_log (this->name, GF_LOG_ERROR, "Failed to stop " + "snap volume"); + goto out; + } + + /* Create a new volinfo for the restored volume */ + ret = glusterd_volinfo_dup (snap_vol, &new_volinfo, _gf_true); + if (ret) { + gf_log (this->name, GF_LOG_ERROR, "Failed to create volinfo"); + goto out; + } + + /* Following entries need to be derived from origin volume. */ + strcpy (new_volinfo->volname, orig_vol->volname); + uuid_copy (new_volinfo->volume_id, orig_vol->volume_id); + new_volinfo->snap_count = orig_vol->snap_count; + new_volinfo->snap_max_hard_limit = orig_vol->snap_max_hard_limit; + uuid_copy (new_volinfo->restored_from_snap, + snap_vol->snapshot->snap_id); + + /* Bump the version of the restored volume, so that nodes * + * which are done can sync during handshake */ + new_volinfo->version = orig_vol->version; + + list_for_each_entry_safe (voliter, temp_volinfo, + &orig_vol->snap_volumes, snapvol_list) { + list_add_tail (&voliter->snapvol_list, + &new_volinfo->snap_volumes); + } + /* Copy the snap vol info to the new_volinfo.*/ + ret = glusterd_snap_volinfo_restore (rsp_dict, new_volinfo, snap_vol); + if (ret) { + gf_log (this->name, GF_LOG_ERROR, "Failed to restore snap"); + (void)glusterd_volinfo_delete (new_volinfo); + goto out; + } + + ret = glusterd_lvm_snapshot_remove (rsp_dict, orig_vol); + if (ret) { + gf_log (this->name, GF_LOG_ERROR, "Failed to remove " + "LVM backend"); + (void)glusterd_volinfo_delete (new_volinfo); + goto out; + } + + /* New volinfo always shows the status as created. Therefore + * set the status to the original volume's status. */ + glusterd_set_volume_status (new_volinfo, orig_vol->status); + + /* Once the new_volinfo is completely constructed then delete + * the orinal volinfo + */ + ret = glusterd_volinfo_delete (orig_vol); + if (ret) { + gf_log (this->name, GF_LOG_ERROR, "Failed to delete volinfo"); + (void)glusterd_volinfo_delete (new_volinfo); + goto out; + } + + list_add_tail (&new_volinfo->vol_list, &conf->volumes); + + /* Now delete the snap entry. As a first step delete the snap + * volume information stored in store. */ + ret = glusterd_snap_remove (rsp_dict, snap, _gf_false, _gf_true); + if (ret) { + gf_log (this->name, GF_LOG_WARNING, "Failed to delete " + "snap %s", snap->snapname); + goto out; + } + + ret = glusterd_store_volinfo (new_volinfo, + GLUSTERD_VOLINFO_VER_AC_INCREMENT); + if (ret) { + gf_log (this->name, GF_LOG_ERROR, "Failed to store volinfo"); + goto out; + } + + ret = 0; +out: + + return ret; +} diff --git a/xlators/mgmt/glusterd/src/glusterd-store.c b/xlators/mgmt/glusterd/src/glusterd-store.c index 9c04aab50..1e39fb27e 100644 --- a/xlators/mgmt/glusterd/src/glusterd-store.c +++ b/xlators/mgmt/glusterd/src/glusterd-store.c @@ -525,10 +525,13 @@ int _storeopts (dict_t *this, char *key, data_t *value, void *data) int32_t glusterd_volume_exclude_options_write (int fd, glusterd_volinfo_t *volinfo) { - char *str = NULL; - char buf[PATH_MAX] = {0,}; - int32_t ret = -1; + char *str = NULL; + char buf[PATH_MAX] = ""; + int32_t ret = -1; + xlator_t *this = NULL; + this = THIS; + GF_ASSERT (this); GF_ASSERT (fd > 0); GF_ASSERT (volinfo); @@ -576,7 +579,7 @@ glusterd_volume_exclude_options_write (int fd, glusterd_volinfo_t *volinfo) snprintf (buf, sizeof (buf), "%s", volinfo->parent_volname); ret = gf_store_save_value (fd, GLUSTERD_STORE_KEY_PARENT_VOLNAME, buf); if (ret) { - gf_log (THIS->name, GF_LOG_ERROR, "Failed to store " + gf_log (this->name, GF_LOG_ERROR, "Failed to store " GLUSTERD_STORE_KEY_PARENT_VOLNAME); goto out; } @@ -620,11 +623,11 @@ glusterd_volume_exclude_options_write (int fd, glusterd_volinfo_t *volinfo) goto out; } - snprintf (buf, sizeof (buf), "%d", volinfo->is_volume_restored); - ret = gf_store_save_value (fd, GLUSTERD_STORE_KEY_VOL_IS_RESTORED, buf); + ret = gf_store_save_value (fd, GLUSTERD_STORE_KEY_VOL_RESTORED_SNAP, + uuid_utoa (volinfo->restored_from_snap)); if (ret) { - gf_log (THIS->name, GF_LOG_ERROR, - "Unable to write is_volume_restored"); + gf_log (this->name, GF_LOG_ERROR, + "Unable to write restored_from_snap"); goto out; } @@ -632,14 +635,14 @@ glusterd_volume_exclude_options_write (int fd, glusterd_volinfo_t *volinfo) ret = gf_store_save_value (fd, GLUSTERD_STORE_KEY_SNAP_MAX_HARD_LIMIT, buf); if (ret) { - gf_log (THIS->name, GF_LOG_ERROR, + gf_log (this->name, GF_LOG_ERROR, "Unable to write snap-max-hard-limit"); goto out; } out: if (ret) - gf_log (THIS->name, GF_LOG_ERROR, "Unable to write volume " + gf_log (this->name, GF_LOG_ERROR, "Unable to write volume " "values for %s", volinfo->volname); return ret; } @@ -2417,9 +2420,12 @@ glusterd_store_update_volinfo (glusterd_volinfo_t *volinfo) } else if (!strncmp (key, GLUSTERD_STORE_KEY_SNAP_MAX_HARD_LIMIT, strlen (GLUSTERD_STORE_KEY_SNAP_MAX_HARD_LIMIT))) { volinfo->snap_max_hard_limit = (uint64_t) atoll (value); - } else if (!strncmp (key, GLUSTERD_STORE_KEY_VOL_IS_RESTORED, - strlen (GLUSTERD_STORE_KEY_VOL_IS_RESTORED))) { - volinfo->is_volume_restored = atoi (value); + } else if (!strncmp (key, GLUSTERD_STORE_KEY_VOL_RESTORED_SNAP, + strlen (GLUSTERD_STORE_KEY_VOL_RESTORED_SNAP))) { + ret = uuid_parse (value, volinfo->restored_from_snap); + if (ret) + gf_log ("", GF_LOG_WARNING, + "failed to parse restored snap's uuid"); } else if (!strncmp (key, GLUSTERD_STORE_KEY_PARENT_VOLNAME, strlen (GLUSTERD_STORE_KEY_PARENT_VOLNAME))) { strncpy (volinfo->parent_volname, value, sizeof(volinfo->parent_volname) - 1); diff --git a/xlators/mgmt/glusterd/src/glusterd-store.h b/xlators/mgmt/glusterd/src/glusterd-store.h index 19123f005..63d510cbf 100644 --- a/xlators/mgmt/glusterd/src/glusterd-store.h +++ b/xlators/mgmt/glusterd/src/glusterd-store.h @@ -48,7 +48,7 @@ typedef enum glusterd_store_ver_ac_{ #define GLUSTERD_STORE_KEY_VOL_VERSION "version" #define GLUSTERD_STORE_KEY_VOL_TRANSPORT "transport-type" #define GLUSTERD_STORE_KEY_VOL_ID "volume-id" -#define GLUSTERD_STORE_KEY_VOL_IS_RESTORED "is-volume-restored" +#define GLUSTERD_STORE_KEY_VOL_RESTORED_SNAP "restored_from_snap" #define GLUSTERD_STORE_KEY_RB_STATUS "rb_status" #define GLUSTERD_STORE_KEY_RB_SRC_BRICK "rb_src" #define GLUSTERD_STORE_KEY_RB_DST_BRICK "rb_dst" diff --git a/xlators/mgmt/glusterd/src/glusterd-utils.c b/xlators/mgmt/glusterd/src/glusterd-utils.c index b4644432d..0dda39103 100644 --- a/xlators/mgmt/glusterd/src/glusterd-utils.c +++ b/xlators/mgmt/glusterd/src/glusterd-utils.c @@ -2273,14 +2273,12 @@ glusterd_add_volume_to_dict (glusterd_volinfo_t *volinfo, if (ret) goto out; - snprintf (key, sizeof (key), "volume%d.is_volume_restored", count); - ret = dict_set_int32 (dict, key, volinfo->is_volume_restored); - if (ret) { - gf_log (THIS->name, GF_LOG_ERROR, "Failed to set " - "is_volume_restored option for %s volume", - volinfo->volname); + snprintf (key, sizeof (key), "volume%d.restored_from_snap", count); + ret = dict_set_dynstr_with_alloc + (dict, key, + uuid_utoa (volinfo->restored_from_snap)); + if (ret) goto out; - } memset (key, 0, sizeof (key)); snprintf (key, sizeof (key), "volume%d.brick_count", count); @@ -3548,6 +3546,7 @@ glusterd_import_volinfo (dict_t *vols, int count, char *volname = NULL; glusterd_volinfo_t *new_volinfo = NULL; char *volume_id_str = NULL; + char *restored_snap = NULL; char msg[2048] = {0}; char *src_brick = NULL; char *dst_brick = NULL; @@ -3713,15 +3712,16 @@ glusterd_import_volinfo (dict_t *vols, int count, new_volinfo->is_snap_volume = is_snap_volume; - snprintf (key, sizeof (key), "volume%d.is_volume_restored", count); - ret = dict_get_uint32 (vols, key, &new_volinfo->is_volume_restored); + snprintf (key, sizeof (key), "volume%d.restored_from_snap", count); + ret = dict_get_str (vols, key, &restored_snap); if (ret) { - gf_log (THIS->name, GF_LOG_ERROR, "Failed to get " - "is_volume_restored option for %s", - volname); + snprintf (msg, sizeof (msg), "%s missing in payload for %s", + key, volname); goto out; } + uuid_parse (restored_snap, new_volinfo->restored_from_snap); + snprintf (key, sizeof (key), "volume%d.snap-max-hard-limit", count); ret = dict_get_uint64 (vols, key, &new_volinfo->snap_max_hard_limit); if (ret) { @@ -3965,9 +3965,34 @@ int32_t glusterd_delete_stale_volume (glusterd_volinfo_t *stale_volinfo, glusterd_volinfo_t *valid_volinfo) { + int32_t ret = -1; + glusterd_volinfo_t *temp_volinfo = NULL; + glusterd_volinfo_t *voliter = NULL; + xlator_t *this = NULL; + GF_ASSERT (stale_volinfo); GF_ASSERT (valid_volinfo); + /* Copy snap_volumes list from stale_volinfo to valid_volinfo */ + valid_volinfo->snap_count = 0; + list_for_each_entry_safe (voliter, temp_volinfo, + &stale_volinfo->snap_volumes, snapvol_list) { + list_add_tail (&voliter->snapvol_list, + &valid_volinfo->snap_volumes); + valid_volinfo->snap_count++; + } + + if ((!uuid_is_null (stale_volinfo->restored_from_snap)) && + (uuid_compare (stale_volinfo->restored_from_snap, + valid_volinfo->restored_from_snap))) { + ret = glusterd_lvm_snapshot_remove (NULL, stale_volinfo); + if (ret) { + gf_log(this->name, GF_LOG_WARNING, + "Failed to remove lvm snapshot for " + "restored volume %s", stale_volinfo->volname); + } + } + /* If stale volume is in started state, copy the port numbers of the * local bricks if they exist in the valid volume information. * stop stale bricks. Stale volume information is going to be deleted. @@ -4220,6 +4245,164 @@ out: return ret; } +int32_t +glusterd_perform_missed_op (glusterd_snap_t *snap, int32_t op) +{ + dict_t *dict = NULL; + int32_t ret = -1; + glusterd_conf_t *priv = NULL; + glusterd_volinfo_t *snap_volinfo = NULL; + glusterd_volinfo_t *volinfo = NULL; + xlator_t *this = NULL; + uuid_t null_uuid = {0}; + + this = THIS; + GF_ASSERT (this); + + priv = this->private; + GF_ASSERT (priv); + GF_ASSERT (snap); + + dict = dict_new(); + if (!dict) { + gf_log (this->name, GF_LOG_ERROR, "Unable to create dict"); + ret = -1; + goto out; + } + + switch (op) { + case GF_SNAP_OPTION_TYPE_DELETE: + ret = glusterd_snap_remove (dict, snap, _gf_true, _gf_false); + if (ret) { + gf_log (this->name, GF_LOG_ERROR, + "Failed to remove snap"); + goto out; + } + + break; + case GF_SNAP_OPTION_TYPE_RESTORE: + /* TODO : As of now there is only volume in snapshot. + * Change this when multiple volume snapshot is introduced + */ + snap_volinfo = list_entry (snap->volumes.next, + glusterd_volinfo_t, vol_list); + + /* Find the parent volinfo */ + ret = glusterd_volinfo_find (snap_volinfo->parent_volname, + &volinfo); + if (ret) { + gf_log (this->name, GF_LOG_ERROR, + "Could not get volinfo of %s", + snap_volinfo->parent_volname); + goto out; + } + + /* Bump down the original volinfo's version, coz it would have + * incremented already due to volume handshake + */ + volinfo->version--; + uuid_copy (volinfo->restored_from_snap, null_uuid); + + /* Perform the restore */ + ret = gd_restore_snap_volume (dict, volinfo, snap_volinfo); + if (ret) { + gf_log (this->name, GF_LOG_ERROR, "Failed to restore " + "snap for %s", snap->snapname); + volinfo->version++; + goto out; + } + + break; + default: + /* The entry must be a create, delete, or + * restore entry + */ + gf_log (this->name, GF_LOG_ERROR, "Invalid missed snap entry"); + ret = -1; + goto out; + } + +out: + dict_unref (dict); + gf_log (this->name, GF_LOG_TRACE, "Returning %d", ret); + return ret; +} + +/* Perform missed deletes and restores on this node */ +int32_t +glusterd_perform_missed_snap_ops () +{ + int32_t ret = -1; + int32_t op_status = -1; + glusterd_conf_t *priv = NULL; + glusterd_missed_snap_info *missed_snapinfo = NULL; + glusterd_snap_op_t *snap_opinfo = NULL; + glusterd_snap_t *snap = NULL; + uuid_t snap_uuid = {0,}; + xlator_t *this = NULL; + + this = THIS; + GF_ASSERT (this); + + priv = this->private; + GF_ASSERT (priv); + + list_for_each_entry (missed_snapinfo, &priv->missed_snaps_list, + missed_snaps) { + /* If the pending snap_op is not for this node then continue */ + if (strcmp (missed_snapinfo->node_uuid, uuid_utoa (MY_UUID))) + continue; + + /* Find the snap id */ + uuid_parse (missed_snapinfo->snap_uuid, snap_uuid); + snap = NULL; + snap = glusterd_find_snap_by_id (snap_uuid); + if (!snap) { + /* If the snap is not found, then a delete or a + * restore can't be pending on that snap_uuid. + */ + gf_log (this->name, GF_LOG_DEBUG, + "Not a pending delete or restore op"); + continue; + } + + op_status = GD_MISSED_SNAP_PENDING; + list_for_each_entry (snap_opinfo, &missed_snapinfo->snap_ops, + snap_ops_list) { + /* If the snap_op is create or its status is + * GD_MISSED_SNAP_DONE then continue + */ + if ((snap_opinfo->status == GD_MISSED_SNAP_DONE) || + (snap_opinfo->op == GF_SNAP_OPTION_TYPE_CREATE)) + continue; + + /* Perform the actual op for the first time for + * this snap, and mark the snap_status as + * GD_MISSED_SNAP_DONE. For other entries for the same + * snap, just mark the entry as done. + */ + if (op_status == GD_MISSED_SNAP_PENDING) { + ret = glusterd_perform_missed_op + (snap, + snap_opinfo->op); + if (ret) { + gf_log (this->name, GF_LOG_ERROR, + "Failed to perform missed snap op"); + goto out; + } + op_status = GD_MISSED_SNAP_DONE; + } + + snap_opinfo->status = GD_MISSED_SNAP_DONE; + } + } + + ret = 0; +out: + gf_log (this->name, GF_LOG_TRACE, "Returning %d", ret); + return ret; +} + /* Import friend volumes missed_snap_list and update * * missed_snap_list if need be */ int32_t @@ -4253,6 +4436,16 @@ glusterd_import_friend_missed_snap_list (dict_t *vols) goto out; } + ret = glusterd_perform_missed_snap_ops (); + if (ret) { + gf_log (this->name, GF_LOG_ERROR, + "Failed to perform snap operations"); + /* Not going to out at this point coz some * + * missed ops might have been performed. We * + * need to persist the current list * + */ + } + ret = glusterd_store_update_missed_snaps (); if (ret) { gf_log (this->name, GF_LOG_ERROR, diff --git a/xlators/mgmt/glusterd/src/glusterd-utils.h b/xlators/mgmt/glusterd/src/glusterd-utils.h index ec65357f9..1a4490ab9 100644 --- a/xlators/mgmt/glusterd/src/glusterd-utils.h +++ b/xlators/mgmt/glusterd/src/glusterd-utils.h @@ -726,4 +726,9 @@ glusterd_add_missed_snaps_to_export_dict (dict_t *vols); int32_t glusterd_import_friend_missed_snap_list (dict_t *vols); +int32_t +gd_restore_snap_volume (dict_t *rsp_dict, + glusterd_volinfo_t *orig_vol, + glusterd_volinfo_t *snap_vol); + #endif diff --git a/xlators/mgmt/glusterd/src/glusterd-volgen.c b/xlators/mgmt/glusterd/src/glusterd-volgen.c index 797370a87..ae095bf7c 100644 --- a/xlators/mgmt/glusterd/src/glusterd-volgen.c +++ b/xlators/mgmt/glusterd/src/glusterd-volgen.c @@ -4266,128 +4266,3 @@ gd_is_boolean_option (char *key) return _gf_false; } - -/* This function will restore origin volume to it's snap. - * The restore operation will simply replace the Gluster origin - * volume with the snap volume. - * TODO: Multi-volume delete to be done. - * Cleanup in case of restore failure is pending. - * - * @param orig_vol volinfo of origin volume - * @param snap_vol volinfo of snapshot volume - * - * @return 0 on success and negative value on error - */ -int -gd_restore_snap_volume (dict_t *rsp_dict, - glusterd_volinfo_t *orig_vol, - glusterd_volinfo_t *snap_vol) -{ - int ret = -1; - glusterd_volinfo_t *new_volinfo = NULL; - glusterd_snap_t *snap = NULL; - xlator_t *this = NULL; - glusterd_conf_t *conf = NULL; - glusterd_volinfo_t *temp_volinfo = NULL; - glusterd_volinfo_t *voliter = NULL; - - this = THIS; - GF_ASSERT (this); - GF_ASSERT (rsp_dict); - conf = this->private; - GF_ASSERT (conf); - - GF_VALIDATE_OR_GOTO (this->name, orig_vol, out); - GF_VALIDATE_OR_GOTO (this->name, snap_vol, out); - snap = snap_vol->snapshot; - GF_VALIDATE_OR_GOTO (this->name, snap, out); - - /* Snap volume must be stoped before performing the - * restore operation. - */ - ret = glusterd_stop_volume (snap_vol); - if (ret) { - gf_log (this->name, GF_LOG_ERROR, "Failed to stop " - "snap volume(%s)", snap_vol->volname); - goto out; - } - - /* Create a new volinfo for the restored volume */ - ret = glusterd_volinfo_dup (snap_vol, &new_volinfo, _gf_true); - if (ret) { - gf_log (this->name, GF_LOG_ERROR, "Failed to create volinfo"); - goto out; - } - - /* Following entries need to be derived from origin volume. */ - strcpy (new_volinfo->volname, orig_vol->volname); - uuid_copy (new_volinfo->volume_id, orig_vol->volume_id); - new_volinfo->snap_count = orig_vol->snap_count; - new_volinfo->snap_max_hard_limit = orig_vol->snap_max_hard_limit; - new_volinfo->is_volume_restored = _gf_true; - - /* Bump the version of the restored volume, so that nodes * - * which are done can sync during handshake */ - new_volinfo->version = orig_vol->version; - - list_for_each_entry_safe (voliter, temp_volinfo, - &orig_vol->snap_volumes, snapvol_list) { - list_add_tail (&voliter->snapvol_list, - &new_volinfo->snap_volumes); - } - /* Copy the snap vol info to the new_volinfo.*/ - ret = glusterd_snap_volinfo_restore (rsp_dict, new_volinfo, snap_vol); - if (ret) { - gf_log (this->name, GF_LOG_ERROR, "Failed to restore snap"); - (void)glusterd_volinfo_delete (new_volinfo); - goto out; - } - - /* If the orig_vol is already restored then we should delete - * the backend LVMs */ - if (orig_vol->is_volume_restored) { - ret = glusterd_lvm_snapshot_remove (rsp_dict, orig_vol); - if (ret) { - gf_log (this->name, GF_LOG_ERROR, "Failed to remove " - "LVM backend"); - (void)glusterd_volinfo_delete (new_volinfo); - goto out; - } - } - - /* Once the new_volinfo is completely constructed then delete - * the orinal volinfo - */ - ret = glusterd_volinfo_delete (orig_vol); - if (ret) { - gf_log (this->name, GF_LOG_ERROR, "Failed to delete volinfo"); - (void)glusterd_volinfo_delete (new_volinfo); - goto out; - } - /* New volinfo always shows the status as created. Therefore - * set the status to stop. */ - glusterd_set_volume_status (new_volinfo, GLUSTERD_STATUS_STOPPED); - - list_add_tail (&new_volinfo->vol_list, &conf->volumes); - - /* Now delete the snap entry. As a first step delete the snap - * volume information stored in store. */ - ret = glusterd_snap_remove (rsp_dict, snap, _gf_false, _gf_true); - if (ret) { - gf_log (this->name, GF_LOG_WARNING, "Failed to delete " - "snap %s", snap->snapname); - goto out; - } - - ret = glusterd_store_volinfo (new_volinfo, - GLUSTERD_VOLINFO_VER_AC_INCREMENT); - if (ret) { - gf_log (this->name, GF_LOG_ERROR, "Failed to store volinfo"); - goto out; - } - - ret = 0; -out: - - return ret; -} diff --git a/xlators/mgmt/glusterd/src/glusterd-volgen.h b/xlators/mgmt/glusterd/src/glusterd-volgen.h index 1f9416106..ef92087fc 100644 --- a/xlators/mgmt/glusterd/src/glusterd-volgen.h +++ b/xlators/mgmt/glusterd/src/glusterd-volgen.h @@ -172,7 +172,4 @@ gd_is_xlator_option (char *key); gf_boolean_t gd_is_boolean_option (char *key); -int gd_restore_snap_volume (dict_t *rsp_dict, - glusterd_volinfo_t *orig_vol, - glusterd_volinfo_t *snap_vol); #endif diff --git a/xlators/mgmt/glusterd/src/glusterd.h b/xlators/mgmt/glusterd/src/glusterd.h index d50fa03d2..b53d8e412 100644 --- a/xlators/mgmt/glusterd/src/glusterd.h +++ b/xlators/mgmt/glusterd/src/glusterd.h @@ -298,7 +298,7 @@ struct glusterd_volinfo_ { char volname[GLUSTERD_MAX_VOLUME_NAME]; gf_boolean_t is_snap_volume; glusterd_snap_t *snapshot; - gf_boolean_t is_volume_restored; + uuid_t restored_from_snap; char parent_volname[GLUSTERD_MAX_VOLUME_NAME]; /* In case of a snap volume i.e (is_snap_volume == TRUE) this -- cgit From b46d0ba04901ebca81d0f477e3e9ac6ba8607946 Mon Sep 17 00:00:00 2001 From: Avra Sengupta Date: Thu, 3 Apr 2014 03:36:28 +0000 Subject: glusterd/snapshot: Recreate the mount dirs and mount the lvm snapshots on node reboot. The lvm snapshots of the bricks are mounted at /var/run/gluster/snaps/ or /run/gluster/snaps. These paths being on a tempfs, on reboot are removed. So when glusterd starts, we need to recreate these paths, activate the respective logical volumes (lvm snapshots of the bricks), and mount these logical volumes at their respective paths. Change-Id: Ic5ef61e79a25d9830df717c592391965fe09db62 BUG: 1061685 Signed-off-by: Avra Sengupta Reviewed-on: http://review.gluster.org/7452 Tested-by: Gluster Build System Reviewed-by: Rajesh Joseph Reviewed-by: Vijay Bellur --- xlators/mgmt/glusterd/src/glusterd-snapshot.c | 30 +- xlators/mgmt/glusterd/src/glusterd-store.c | 417 +++++++++++++++++++++++--- xlators/mgmt/glusterd/src/glusterd-utils.c | 35 +++ xlators/mgmt/glusterd/src/glusterd-utils.h | 3 + 4 files changed, 415 insertions(+), 70 deletions(-) diff --git a/xlators/mgmt/glusterd/src/glusterd-snapshot.c b/xlators/mgmt/glusterd/src/glusterd-snapshot.c index c1967a29c..0e824a022 100644 --- a/xlators/mgmt/glusterd/src/glusterd-snapshot.c +++ b/xlators/mgmt/glusterd/src/glusterd-snapshot.c @@ -1104,8 +1104,12 @@ glusterd_lvm_snapshot_remove (dict_t *rsp_dict, glusterd_volinfo_t *snap_vol) brick_count = -1; list_for_each_entry (brickinfo, &snap_vol->bricks, brick_list) { brick_count++; - if (uuid_compare (brickinfo->uuid, MY_UUID)) + if (uuid_compare (brickinfo->uuid, MY_UUID)) { + gf_log (this->name, GF_LOG_DEBUG, + "%s:%s belongs to a different node", + brickinfo->hostname, brickinfo->path); continue; + } if (brickinfo->snap_status == -1) { gf_log (this->name, GF_LOG_INFO, @@ -1170,6 +1174,7 @@ glusterd_lvm_snapshot_remove (dict_t *rsp_dict, glusterd_volinfo_t *snap_vol) ret = 0; out: + gf_log (this->name, GF_LOG_TRACE, "Returning %d", ret); return ret; } @@ -2855,9 +2860,7 @@ glusterd_snap_brick_create (char *device, glusterd_volinfo_t *snap_volinfo, glusterd_conf_t *priv = NULL; char snap_brick_mount_path[PATH_MAX] = ""; char snap_brick_path[PATH_MAX] = ""; - char msg[1024] = ""; struct stat statbuf = {0, }; - runner_t runner = {0, }; this = THIS; priv = this->private; @@ -2888,25 +2891,12 @@ glusterd_snap_brick_create (char *device, glusterd_volinfo_t *snap_volinfo, MS_MGC_VAL, "nouuid"); But for now, mounting using runner apis. */ - runinit (&runner); - snprintf (msg, sizeof (msg), "mounting snapshot of the brick %s:%s", - original_brickinfo->hostname, original_brickinfo->path); - runner_add_args (&runner, "mount", "-o", "nouuid", device, - snap_brick_mount_path, NULL); - runner_log (&runner, "", GF_LOG_DEBUG, msg); - - /* let glusterd get blocked till snapshot is over */ - synclock_unlock (&priv->big_lock); - ret = runner_run (&runner); - synclock_lock (&priv->big_lock); + ret = glusterd_mount_lvm_snapshot (device, snap_brick_mount_path); if (ret) { - gf_log (this->name, GF_LOG_ERROR, "mounting the snapshot " - "logical device %s failed (error: %s)", device, - strerror (errno)); + gf_log (this->name, GF_LOG_ERROR, + "Failed to mount lvm snapshot."); goto out; - } else - gf_log (this->name, GF_LOG_DEBUG, "mounting the snapshot " - "logical device %s successful", device); + } ret = stat (snap_brick_path, &statbuf); if (ret) { diff --git a/xlators/mgmt/glusterd/src/glusterd-store.c b/xlators/mgmt/glusterd/src/glusterd-store.c index 1e39fb27e..d9d2a3e50 100644 --- a/xlators/mgmt/glusterd/src/glusterd-store.c +++ b/xlators/mgmt/glusterd/src/glusterd-store.c @@ -44,6 +44,7 @@ #include #include #include +#include void glusterd_replace_slash_with_hyphen (char *str) @@ -2424,7 +2425,7 @@ glusterd_store_update_volinfo (glusterd_volinfo_t *volinfo) strlen (GLUSTERD_STORE_KEY_VOL_RESTORED_SNAP))) { ret = uuid_parse (value, volinfo->restored_from_snap); if (ret) - gf_log ("", GF_LOG_WARNING, + gf_log (this->name, GF_LOG_WARNING, "failed to parse restored snap's uuid"); } else if (!strncmp (key, GLUSTERD_STORE_KEY_PARENT_VOLNAME, strlen (GLUSTERD_STORE_KEY_PARENT_VOLNAME))) { @@ -2792,6 +2793,209 @@ out: return ret; } +/* Figure out the brick mount path, from the brick path */ +int32_t +glusterd_find_brick_mount_path (char *brick_path, int32_t brick_count, + char **brick_mount_path) +{ + char brick_num[PATH_MAX] = ""; + char *ptr = NULL; + int32_t ret = -1; + xlator_t *this = NULL; + + this = THIS; + GF_ASSERT (this); + GF_ASSERT (brick_path); + GF_ASSERT (brick_mount_path); + + *brick_mount_path = gf_strdup (brick_path); + if (!*brick_mount_path) { + ret = -1; + goto out; + } + + snprintf (brick_num, sizeof(brick_num), "brick%d", brick_count); + + /* Finding the pointer to the end of + * /var/run/gluster/snaps/ + */ + ptr = strstr (*brick_mount_path, brick_num); + if (!ptr) { + /* Snapshot bricks must have brick num as part + * of the brickpath + */ + gf_log (this->name, GF_LOG_ERROR, + "Invalid brick path(%s)", brick_path); + ret = -1; + goto out; + } + + /* Moving the pointer to the end of + * /var/run/gluster/snaps// + * and assigning '\0' to it. + */ + ptr += strlen(brick_num); + *ptr = '\0'; + + ret = 0; +out: + if (ret && *brick_mount_path) { + GF_FREE (*brick_mount_path); + *brick_mount_path = NULL; + } + gf_log (this->name, GF_LOG_TRACE, "Returning with %d", ret); + return ret; +} + +/* Check if brick_mount_path is already mounted. If not, mount the device_path + * at the brick_mount_path + */ +int32_t +glusterd_mount_brick_paths (char *brick_mount_path, char *device_path) +{ + FILE *mtab = NULL; + int32_t ret = -1; + runner_t runner = {0, }; + struct mntent *entry = NULL; + xlator_t *this = NULL; + glusterd_conf_t *priv = NULL; + + this = THIS; + GF_ASSERT (this); + GF_ASSERT (brick_mount_path); + GF_ASSERT (device_path); + + priv = this->private; + GF_ASSERT (priv); + + /* Check if the brick_mount_path is already mounted */ + entry = glusterd_get_mnt_entry_info (brick_mount_path, mtab); + if (entry) { + gf_log (this->name, GF_LOG_INFO, + "brick_mount_path (%s) already mounted.", + brick_mount_path); + ret = 0; + goto out; + } + + /* TODO RHEL 6.5 has the logical volumes inactive by default + * on reboot. Hence activating the logical vol. Check behaviour + * on other systems + */ + /* Activate the snapshot */ + runinit (&runner); + runner_add_args (&runner, "lvchange", "-ay", device_path, + NULL); + ret = runner_run (&runner); + if (ret) { + gf_log (this->name, GF_LOG_ERROR, + "Failed to activate %s. Error: %s", + device_path, strerror(errno)); + goto out; + } else + gf_log (this->name, GF_LOG_DEBUG, + "Activating %s successful", device_path); + + /* Mount the snapshot */ + ret = glusterd_mount_lvm_snapshot (device_path, brick_mount_path); + if (ret) { + gf_log (this->name, GF_LOG_ERROR, + "Failed to mount lvm snapshot."); + goto out; + } + +out: + if (mtab) + endmntent (mtab); + gf_log (this->name, GF_LOG_TRACE, "Returning with %d", ret); + return ret; +} + +static int32_t +glusterd_store_recreate_brick_mounts (glusterd_volinfo_t *volinfo) +{ + char *brick_mount_path = NULL; + glusterd_brickinfo_t *brickinfo = NULL; + int32_t ret = -1; + int32_t brick_count = -1; + struct stat st_buf = {0, }; + xlator_t *this = NULL; + + this = THIS; + GF_ASSERT (this); + GF_ASSERT (volinfo); + + brick_count = 0; + list_for_each_entry (brickinfo, &volinfo->bricks, brick_list) { + brick_count++; + /* If the brick is not of this node, or its + * snapshot is pending, or the brick is not + * a snapshotted brick, we continue + */ + if ((uuid_compare (brickinfo->uuid, MY_UUID)) || + (brickinfo->snap_status == -1) || + (strlen(brickinfo->device_path) == 0)) + continue; + + /* Fetch the brick mount path from the brickinfo->path */ + ret = glusterd_find_brick_mount_path (brickinfo->path, + brick_count, + &brick_mount_path); + if (ret) { + gf_log (this->name, GF_LOG_ERROR, + "Failed to find brick_mount_path for %s", + brickinfo->path); + goto out; + } + + /* Check if the brickinfo path is present. + * If not create the brick_mount_path */ + ret = lstat (brickinfo->path, &st_buf); + if (ret) { + if (errno == ENOENT) { + ret = mkdir_p (brick_mount_path, 0777, + _gf_true); + if (ret) { + gf_log (this->name, GF_LOG_ERROR, + "Failed to create %s. " + "Error: %s", brick_mount_path, + strerror (errno)); + goto out; + } + } else { + gf_log (this->name, GF_LOG_ERROR, + "Brick Path(%s) not valid. " + "Error: %s", brickinfo->path, + strerror(errno)); + goto out; + } + } + + /* Check if brick_mount_path is already mounted. + * If not, mount the device_path at the brick_mount_path */ + ret = glusterd_mount_brick_paths (brick_mount_path, + brickinfo->device_path); + if (ret) { + gf_log (this->name, GF_LOG_ERROR, + "Failed to mount brick_mount_path"); + goto out; + } + + if (brick_mount_path) { + GF_FREE (brick_mount_path); + brick_mount_path = NULL; + } + } + + ret = 0; +out: + if (ret && brick_mount_path) + GF_FREE (brick_mount_path); + + gf_log (this->name, GF_LOG_TRACE, "Returning with %d", ret); + return ret; +} + int32_t glusterd_resolve_snap_bricks (xlator_t *this, glusterd_snap_t *snap) { @@ -2911,25 +3115,16 @@ out: int32_t glusterd_store_retrieve_snap (char *snapname) { - int32_t ret = -1; - dict_t *dict = NULL; - glusterd_snap_t *snap = NULL; - glusterd_conf_t *priv = NULL; - xlator_t *this = NULL; + int32_t ret = -1; + glusterd_snap_t *snap = NULL; + glusterd_conf_t *priv = NULL; + xlator_t *this = NULL; this = THIS; priv = this->private; GF_ASSERT (priv); GF_ASSERT (snapname); - dict = dict_new(); - if (!dict) { - gf_log (this->name, GF_LOG_ERROR, - "Failed to create dict"); - ret = -1; - goto out; - } - snap = glusterd_new_snap_object (); if (!snap) { gf_log (this->name, GF_LOG_ERROR, "Failed to create " @@ -2952,34 +3147,6 @@ glusterd_store_retrieve_snap (char *snapname) goto out; } - /* Unlike bricks of normal volumes which are resolved at the end of - the glusterd restore, the bricks belonging to the snap volumes of - each snap should be resolved as part of snapshot restore itself. - Because if the snapshot has to be removed, then resolving bricks - helps glusterd in understanding what all bricks have its own uuid - and killing those bricks. - */ - ret = glusterd_resolve_snap_bricks (this, snap); - if (ret) - gf_log (this->name, GF_LOG_WARNING, "resolving the snap bricks" - " failed (snap: %s)", snap?snap->snapname:""); - - /* When the snapshot command from cli is received, the on disk and - in memory structures for the snapshot are created (with the status) - being marked as GD_SNAP_STATUS_INIT. Once the backend snapshot is - taken, the status is changed to GD_SNAP_STATUS_IN_USE. If glusterd - dies after taking the backend snapshot, but before updating the - status, then when glusterd comes up, it should treat that snapshot - as a failed snapshot and clean it up. - */ - if (snap->snap_status != GD_SNAP_STATUS_IN_USE) { - ret = glusterd_snap_remove (dict, snap, _gf_true, _gf_true); - if (ret) - gf_log (this->name, GF_LOG_WARNING, "failed to remove" - " the snapshot %s", snap->snapname); - goto out; - } - /* TODO: list_add_order can do 'N-square' comparisions and is not efficient. Find a better solution to store the snap in order */ @@ -2987,9 +3154,6 @@ glusterd_store_retrieve_snap (char *snapname) glusterd_compare_snap_time); out: - if (dict) - dict_unref (dict); - gf_log (this->name, GF_LOG_TRACE, "Returning with %d", ret); return ret; } @@ -3616,19 +3780,147 @@ out: return ret; } +static int32_t +glusterd_recreate_vol_brick_mounts (xlator_t *this, + glusterd_volinfo_t *volinfo) +{ + int32_t ret = 0; + glusterd_conf_t *priv = NULL; + glusterd_brickinfo_t *brickinfo = NULL; + + GF_ASSERT (this); + priv = this->private; + GF_ASSERT (priv); + + list_for_each_entry (brickinfo, &volinfo->bricks, brick_list) { + ret = glusterd_store_recreate_brick_mounts (volinfo); + if (ret) { + gf_log (this->name, GF_LOG_ERROR, + "Failed to recreate brick mounts " + "for %s", volinfo->volname); + goto out; + } + } + +out: + gf_log (this->name, GF_LOG_TRACE, "Returning with %d", ret); + return ret; +} + +/* Bricks for snap volumes are hosted at /var/run/gluster/snaps + * When a volume is restored, it points to the bricks of the snap + * volume it was restored from. Hence on a node restart these + * paths need to be recreated and re-mounted + */ +int32_t +glusterd_recreate_all_snap_brick_mounts (xlator_t *this) +{ + int32_t ret = 0; + glusterd_conf_t *priv = NULL; + glusterd_volinfo_t *volinfo = NULL; + glusterd_snap_t *snap = NULL; + + GF_ASSERT (this); + priv = this->private; + GF_ASSERT (priv); + + /* Recreate bricks of volumes restored from snaps */ + list_for_each_entry (volinfo, &priv->volumes, vol_list) { + /* If the volume is not a restored volume then continue */ + if (uuid_is_null (volinfo->restored_from_snap)) + continue; + + ret = glusterd_recreate_vol_brick_mounts (this, volinfo); + if (ret) { + gf_log (this->name, GF_LOG_ERROR, + "Failed to recreate brick mounts " + "for %s", volinfo->volname); + goto out; + } + } + + /* Recreate bricks of snapshot volumes */ + list_for_each_entry (snap, &priv->snapshots, snap_list) { + list_for_each_entry (volinfo, &snap->volumes, vol_list) { + ret = glusterd_recreate_vol_brick_mounts (this, + volinfo); + if (ret) { + gf_log (this->name, GF_LOG_ERROR, + "Failed to recreate brick mounts " + "for %s", snap->snapname); + goto out; + } + } + } + +out: + gf_log (this->name, GF_LOG_TRACE, "Returning with %d", ret); + return ret; +} + +/* When the snapshot command from cli is received, the on disk and + * in memory structures for the snapshot are created (with the status) + * being marked as GD_SNAP_STATUS_INIT. Once the backend snapshot is + * taken, the status is changed to GD_SNAP_STATUS_IN_USE. If glusterd + * dies after taking the backend snapshot, but before updating the + * status, then when glusterd comes up, it should treat that snapshot + * as a failed snapshot and clean it up. + */ +int32_t +glusterd_snap_cleanup (xlator_t *this) +{ + dict_t *dict = NULL; + int32_t ret = 0; + glusterd_conf_t *priv = NULL; + glusterd_snap_t *snap = NULL; + + GF_ASSERT (this); + priv = this->private; + GF_ASSERT (priv); + + dict = dict_new(); + if (!dict) { + gf_log (this->name, GF_LOG_ERROR, + "Failed to create dict"); + ret = -1; + goto out; + } + + list_for_each_entry (snap, &priv->snapshots, snap_list) { + if (snap->snap_status != GD_SNAP_STATUS_IN_USE) { + ret = glusterd_snap_remove (dict, snap, + _gf_true, _gf_true); + if (ret) { + gf_log (this->name, GF_LOG_ERROR, + "Failed to remove the snapshot %s", + snap->snapname); + goto out; + } + } + } +out: + if (dict) + dict_unref (dict); + + gf_log (this->name, GF_LOG_TRACE, "Returning with %d", ret); + return ret; +} + int32_t glusterd_resolve_all_bricks (xlator_t *this) { - int32_t ret = 0; - glusterd_conf_t *priv = NULL; - glusterd_volinfo_t *volinfo = NULL; + int32_t ret = 0; + glusterd_conf_t *priv = NULL; + glusterd_volinfo_t *volinfo = NULL; glusterd_brickinfo_t *brickinfo = NULL; + glusterd_snap_t *snap = NULL; GF_ASSERT (this); priv = this->private; GF_ASSERT (priv); + /* Resolve bricks of volumes */ list_for_each_entry (volinfo, &priv->volumes, vol_list) { list_for_each_entry (brickinfo, &volinfo->bricks, brick_list) { ret = glusterd_resolve_brick (brickinfo); @@ -3640,9 +3932,20 @@ glusterd_resolve_all_bricks (xlator_t *this) } } -out: - gf_log ("", GF_LOG_DEBUG, "Returning with %d", ret); + /* Resolve bricks of snapshot volumes */ + list_for_each_entry (snap, &priv->snapshots, snap_list) { + ret = glusterd_resolve_snap_bricks (this, snap); + if (ret) { + gf_log (this->name, GF_LOG_ERROR, + "resolving the snap bricks" + " failed for snap: %s", + snap->snapname); + goto out; + } + } +out: + gf_log (this->name, GF_LOG_TRACE, "Returning with %d", ret); return ret; } @@ -3677,6 +3980,20 @@ glusterd_restore () if (ret) goto out; + ret = glusterd_snap_cleanup (this); + if (ret) { + gf_log (this->name, GF_LOG_ERROR, "Failed to perform " + "a cleanup of the snapshots"); + goto out; + } + + ret = glusterd_recreate_all_snap_brick_mounts (this); + if (ret) { + gf_log (this->name, GF_LOG_ERROR, "Failed to recreate " + "all snap brick mounts"); + goto out; + } + out: gf_log ("", GF_LOG_DEBUG, "Returning %d", ret); return ret; diff --git a/xlators/mgmt/glusterd/src/glusterd-utils.c b/xlators/mgmt/glusterd/src/glusterd-utils.c index 0dda39103..7bd9348ae 100644 --- a/xlators/mgmt/glusterd/src/glusterd-utils.c +++ b/xlators/mgmt/glusterd/src/glusterd-utils.c @@ -10673,3 +10673,38 @@ glusterd_compare_volume_name(struct list_head *list1, struct list_head *list2) volinfo2 = list_entry(list2, glusterd_volinfo_t, vol_list); return strcmp(volinfo1->volname, volinfo2->volname); } + +int32_t +glusterd_mount_lvm_snapshot (char *device_path, char *brick_mount_path) +{ + char msg[NAME_MAX] = ""; + int32_t ret = -1; + runner_t runner = {0, }; + xlator_t *this = NULL; + + this = THIS; + GF_ASSERT (this); + GF_ASSERT (brick_mount_path); + GF_ASSERT (device_path); + + + runinit (&runner); + snprintf (msg, sizeof (msg), "mount -o nouuid %s %s", + device_path, brick_mount_path); + runner_add_args (&runner, "mount", "-o", "nouuid", device_path, + brick_mount_path, NULL); + runner_log (&runner, this->name, GF_LOG_DEBUG, msg); + ret = runner_run (&runner); + if (ret) { + gf_log (this->name, GF_LOG_ERROR, "mounting the snapshot " + "logical device %s failed (error: %s)", device_path, + strerror (errno)); + goto out; + } else + gf_log (this->name, GF_LOG_DEBUG, "mounting the snapshot " + "logical device %s successful", device_path); + +out: + gf_log (this->name, GF_LOG_TRACE, "Returning with %d", ret); + return ret; +} diff --git a/xlators/mgmt/glusterd/src/glusterd-utils.h b/xlators/mgmt/glusterd/src/glusterd-utils.h index 1a4490ab9..76198428c 100644 --- a/xlators/mgmt/glusterd/src/glusterd-utils.h +++ b/xlators/mgmt/glusterd/src/glusterd-utils.h @@ -731,4 +731,7 @@ gd_restore_snap_volume (dict_t *rsp_dict, glusterd_volinfo_t *orig_vol, glusterd_volinfo_t *snap_vol); +int32_t +glusterd_mount_lvm_snapshot (char *device_path, char *brick_mount_path); + #endif -- cgit From a7c8d514c0487019d218c327deb52f7d09645875 Mon Sep 17 00:00:00 2001 From: Avra Sengupta Date: Mon, 21 Apr 2014 03:32:00 +0000 Subject: glusterd: Rename the export dictionary as peer_data During a glusterd handshake, a dictionary is passed among the peers which contains, info of volumes, global opts, and now also info of snaps and list of missed snaps As it now contains more than just volume specific data, renaming the dict in the code-base from "vols" to "peer_data" Change-Id: Ib457172789ddd0d8978b08bceab0988c48e9eea7 BUG: 1061685 Signed-off-by: Avra Sengupta Reviewed-on: http://review.gluster.org/7524 Tested-by: Gluster Build System Reviewed-by: Rajesh Joseph Reviewed-by: Atin Mukherjee Reviewed-by: Vijay Bellur --- xlators/mgmt/glusterd/src/glusterd-rpc-ops.c | 30 ++-- xlators/mgmt/glusterd/src/glusterd-utils.c | 224 +++++++++++++++------------ xlators/mgmt/glusterd/src/glusterd-utils.h | 11 +- 3 files changed, 144 insertions(+), 121 deletions(-) diff --git a/xlators/mgmt/glusterd/src/glusterd-rpc-ops.c b/xlators/mgmt/glusterd/src/glusterd-rpc-ops.c index cf1ae279a..09def1915 100644 --- a/xlators/mgmt/glusterd/src/glusterd-rpc-ops.c +++ b/xlators/mgmt/glusterd/src/glusterd-rpc-ops.c @@ -1242,12 +1242,12 @@ int32_t glusterd_rpc_friend_add (call_frame_t *frame, xlator_t *this, void *data) { - gd1_mgmt_friend_req req = {{0},}; - int ret = 0; - glusterd_peerinfo_t *peerinfo = NULL; - glusterd_conf_t *priv = NULL; - glusterd_friend_sm_event_t *event = NULL; - dict_t *vols = NULL; + gd1_mgmt_friend_req req = {{0},}; + int ret = 0; + glusterd_peerinfo_t *peerinfo = NULL; + glusterd_conf_t *priv = NULL; + glusterd_friend_sm_event_t *event = NULL; + dict_t *peer_data = NULL; if (!frame || !this || !data) { @@ -1262,16 +1262,20 @@ glusterd_rpc_friend_add (call_frame_t *frame, xlator_t *this, peerinfo = event->peerinfo; - ret = glusterd_build_volume_dict (&vols); - if (ret) + ret = glusterd_add_volumes_to_export_dict (&peer_data); + if (ret) { + gf_log (this->name, GF_LOG_ERROR, + "Unable to add list of volumes " + "in the peer_data dict for handshake"); goto out; + } if (priv->op_version >= GD_OP_VERSION_4) { - ret = glusterd_add_missed_snaps_to_export_dict (vols); + ret = glusterd_add_missed_snaps_to_export_dict (peer_data); if (ret) { gf_log (this->name, GF_LOG_ERROR, "Unable to add list of missed snapshots " - "in the vols dict for handshake"); + "in the peer_data dict for handshake"); goto out; } } @@ -1280,7 +1284,7 @@ glusterd_rpc_friend_add (call_frame_t *frame, xlator_t *this, req.hostname = peerinfo->hostname; req.port = peerinfo->port; - ret = dict_allocate_and_serialize (vols, &req.vols.vols_val, + ret = dict_allocate_and_serialize (peer_data, &req.vols.vols_val, &req.vols.vols_len); if (ret) goto out; @@ -1294,8 +1298,8 @@ glusterd_rpc_friend_add (call_frame_t *frame, xlator_t *this, out: GF_FREE (req.vols.vols_val); - if (vols) - dict_unref (vols); + if (peer_data) + dict_unref (peer_data); gf_log ("glusterd", GF_LOG_DEBUG, "Returning %d", ret); return ret; diff --git a/xlators/mgmt/glusterd/src/glusterd-utils.c b/xlators/mgmt/glusterd/src/glusterd-utils.c index 7bd9348ae..20a3d0862 100644 --- a/xlators/mgmt/glusterd/src/glusterd-utils.c +++ b/xlators/mgmt/glusterd/src/glusterd-utils.c @@ -2665,7 +2665,7 @@ out: } int32_t -glusterd_add_missed_snaps_to_export_dict (dict_t *vols) +glusterd_add_missed_snaps_to_export_dict (dict_t *peer_data) { char name_buf[PATH_MAX] = ""; char value[PATH_MAX] = ""; @@ -2678,7 +2678,7 @@ glusterd_add_missed_snaps_to_export_dict (dict_t *vols) this = THIS; GF_ASSERT (this); - GF_ASSERT (vols); + GF_ASSERT (peer_data); priv = this->private; GF_ASSERT (priv); @@ -2700,7 +2700,7 @@ glusterd_add_missed_snaps_to_export_dict (dict_t *vols) snap_opinfo->op, snap_opinfo->status); - ret = dict_set_dynstr_with_alloc (vols, name_buf, + ret = dict_set_dynstr_with_alloc (peer_data, name_buf, value); if (ret) { gf_log (this->name, GF_LOG_ERROR, @@ -2712,7 +2712,8 @@ glusterd_add_missed_snaps_to_export_dict (dict_t *vols) } } - ret = dict_set_int32 (vols, "missed_snap_count", missed_snap_count); + ret = dict_set_int32 (peer_data, "missed_snap_count", + missed_snap_count); if (ret) { gf_log (this->name, GF_LOG_ERROR, "Unable to set missed_snap_count"); @@ -2725,7 +2726,7 @@ out: } int32_t -glusterd_build_volume_dict (dict_t **vols) +glusterd_add_volumes_to_export_dict (dict_t **peer_data) { int32_t ret = -1; dict_t *dict = NULL; @@ -2733,11 +2734,14 @@ glusterd_build_volume_dict (dict_t **vols) glusterd_volinfo_t *volinfo = NULL; int32_t count = 0; glusterd_dict_ctx_t ctx = {0}; + xlator_t *this = NULL; - priv = THIS->private; + this = THIS; + GF_ASSERT (this); + priv = this->private; + GF_ASSERT (priv); dict = dict_new (); - if (!dict) goto out; @@ -2753,7 +2757,6 @@ glusterd_build_volume_dict (dict_t **vols) goto out; } - ret = dict_set_int32 (dict, "count", count); if (ret) goto out; @@ -2769,18 +2772,18 @@ glusterd_build_volume_dict (dict_t **vols) if (ret) goto out; - *vols = dict; + *peer_data = dict; out: - gf_log ("", GF_LOG_DEBUG, "Returning with %d", ret); if (ret) dict_unref (dict); + gf_log (this->name, GF_LOG_TRACE, "Returning %d", ret); return ret; } int32_t -glusterd_compare_friend_volume (dict_t *vols, int32_t count, int32_t *status, - char *hostname) +glusterd_compare_friend_volume (dict_t *peer_data, int32_t count, + int32_t *status, char *hostname) { int32_t ret = -1; @@ -2793,14 +2796,14 @@ glusterd_compare_friend_volume (dict_t *vols, int32_t count, int32_t *status, int32_t version = 0; xlator_t *this = NULL; - GF_ASSERT (vols); + GF_ASSERT (peer_data); GF_ASSERT (status); this = THIS; GF_ASSERT (this); snprintf (key, sizeof (key), "volume%d.name", count); - ret = dict_get_str (vols, key, &volname); + ret = dict_get_str (peer_data, key, &volname); if (ret) goto out; @@ -2814,7 +2817,7 @@ glusterd_compare_friend_volume (dict_t *vols, int32_t count, int32_t *status, memset (key, 0, sizeof (key)); snprintf (key, sizeof (key), "volume%d.version", count); - ret = dict_get_int32 (vols, key, &version); + ret = dict_get_int32 (peer_data, key, &version); if (ret) goto out; @@ -2835,7 +2838,7 @@ glusterd_compare_friend_volume (dict_t *vols, int32_t count, int32_t *status, // memset (key, 0, sizeof (key)); snprintf (key, sizeof (key), "volume%d.ckusm", count); - ret = dict_get_uint32 (vols, key, &cksum); + ret = dict_get_uint32 (peer_data, key, &cksum); if (ret) goto out; @@ -2850,7 +2853,7 @@ glusterd_compare_friend_volume (dict_t *vols, int32_t count, int32_t *status, memset (key, 0, sizeof (key)); snprintf (key, sizeof (key), "volume%d.quota-version", count); - ret = dict_get_uint32 (vols, key, "a_version); + ret = dict_get_uint32 (peer_data, key, "a_version); if (ret) { gf_log (this->name, GF_LOG_DEBUG, "quota-version key absent for" " volume %s in peer %s's response", volinfo->volname, @@ -2878,7 +2881,7 @@ glusterd_compare_friend_volume (dict_t *vols, int32_t count, int32_t *status, // memset (key, 0, sizeof (key)); snprintf (key, sizeof (key), "volume%d.quota-cksum", count); - ret = dict_get_uint32 (vols, key, "a_cksum); + ret = dict_get_uint32 (peer_data, key, "a_cksum); if (ret) { gf_log (this->name, GF_LOG_DEBUG, "quota checksum absent for " "volume %s in peer %s's response", volinfo->volname, @@ -2906,7 +2909,7 @@ out: } static int32_t -import_prdict_dict (dict_t *vols, dict_t *dst_dict, char *key_prefix, +import_prdict_dict (dict_t *peer_data, dict_t *dst_dict, char *key_prefix, char *value_prefix, int opt_count, char *prefix) { char key[512] = {0,}; @@ -2921,7 +2924,7 @@ import_prdict_dict (dict_t *vols, dict_t *dst_dict, char *key_prefix, memset (key, 0, sizeof (key)); snprintf (key, sizeof (key), "%s.%s%d", prefix, key_prefix, i); - ret = dict_get_str (vols, key, &opt_key); + ret = dict_get_str (peer_data, key, &opt_key); if (ret) { snprintf (msg, sizeof (msg), "Volume dict key not " "specified"); @@ -2931,7 +2934,7 @@ import_prdict_dict (dict_t *vols, dict_t *dst_dict, char *key_prefix, memset (key, 0, sizeof (key)); snprintf (key, sizeof (key), "%s.%s%d", prefix, value_prefix, i); - ret = dict_get_str (vols, key, &opt_val); + ret = dict_get_str (peer_data, key, &opt_val); if (ret) { snprintf (msg, sizeof (msg), "Volume dict value not " "specified"); @@ -3219,7 +3222,7 @@ out: } int32_t -glusterd_import_friend_volume_opts (dict_t *vols, int count, +glusterd_import_friend_volume_opts (dict_t *peer_data, int count, glusterd_volinfo_t *volinfo) { char key[512] = {0,}; @@ -3228,9 +3231,12 @@ glusterd_import_friend_volume_opts (dict_t *vols, int count, char msg[2048] = {0}; char volume_prefix[1024] = {0}; + GF_ASSERT (peer_data); + GF_ASSERT (volinfo); + memset (key, 0, sizeof (key)); snprintf (key, sizeof (key), "volume%d.opt-count", count); - ret = dict_get_int32 (vols, key, &opt_count); + ret = dict_get_int32 (peer_data, key, &opt_count); if (ret) { snprintf (msg, sizeof (msg), "Volume option count not " "specified for %s", volinfo->volname); @@ -3238,7 +3244,7 @@ glusterd_import_friend_volume_opts (dict_t *vols, int count, } snprintf (volume_prefix, sizeof (volume_prefix), "volume%d", count); - ret = import_prdict_dict (vols, volinfo->dict, "key", "value", + ret = import_prdict_dict (peer_data, volinfo->dict, "key", "value", opt_count, volume_prefix); if (ret) { snprintf (msg, sizeof (msg), "Unable to import options dict " @@ -3248,14 +3254,14 @@ glusterd_import_friend_volume_opts (dict_t *vols, int count, memset (key, 0, sizeof (key)); snprintf (key, sizeof (key), "volume%d.gsync-count", count); - ret = dict_get_int32 (vols, key, &opt_count); + ret = dict_get_int32 (peer_data, key, &opt_count); if (ret) { snprintf (msg, sizeof (msg), "Gsync count not " "specified for %s", volinfo->volname); goto out; } - ret = import_prdict_dict (vols, volinfo->gsync_slaves, "slave-num", + ret = import_prdict_dict (peer_data, volinfo->gsync_slaves, "slave-num", "slave-val", opt_count, volume_prefix); if (ret) { snprintf (msg, sizeof (msg), "Unable to import gsync sessions " @@ -3271,7 +3277,7 @@ out: } int32_t -glusterd_import_new_brick (dict_t *vols, int32_t vol_count, +glusterd_import_new_brick (dict_t *peer_data, int32_t vol_count, int32_t brick_count, glusterd_brickinfo_t **brickinfo) { @@ -3286,14 +3292,14 @@ glusterd_import_new_brick (dict_t *vols, int32_t vol_count, glusterd_brickinfo_t *new_brickinfo = NULL; char msg[2048] = {0}; - GF_ASSERT (vols); + GF_ASSERT (peer_data); GF_ASSERT (vol_count >= 0); GF_ASSERT (brickinfo); memset (key, 0, sizeof (key)); snprintf (key, sizeof (key), "volume%d.brick%d.hostname", vol_count, brick_count); - ret = dict_get_str (vols, key, &hostname); + ret = dict_get_str (peer_data, key, &hostname); if (ret) { snprintf (msg, sizeof (msg), "%s missing in payload", key); goto out; @@ -3302,7 +3308,7 @@ glusterd_import_new_brick (dict_t *vols, int32_t vol_count, memset (key, 0, sizeof (key)); snprintf (key, sizeof (key), "volume%d.brick%d.path", vol_count, brick_count); - ret = dict_get_str (vols, key, &path); + ret = dict_get_str (peer_data, key, &path); if (ret) { snprintf (msg, sizeof (msg), "%s missing in payload", key); goto out; @@ -3311,12 +3317,12 @@ glusterd_import_new_brick (dict_t *vols, int32_t vol_count, memset (key, 0, sizeof (key)); snprintf (key, sizeof (key), "volume%d.brick%d.brick_id", vol_count, brick_count); - ret = dict_get_str (vols, key, &brick_id); + ret = dict_get_str (peer_data, key, &brick_id); memset (key, 0, sizeof (key)); snprintf (key, sizeof (key), "volume%d.brick%d.decommissioned", vol_count, brick_count); - ret = dict_get_int32 (vols, key, &decommissioned); + ret = dict_get_int32 (peer_data, key, &decommissioned); if (ret) { /* For backward compatibility */ ret = 0; @@ -3324,7 +3330,7 @@ glusterd_import_new_brick (dict_t *vols, int32_t vol_count, snprintf (key, sizeof (key), "volume%d.brick%d.snap_status", vol_count, brick_count); - ret = dict_get_int32 (vols, key, &snap_status); + ret = dict_get_int32 (peer_data, key, &snap_status); if (ret) { snprintf (msg, sizeof (msg), "%s missing in payload", key); goto out; @@ -3332,7 +3338,7 @@ glusterd_import_new_brick (dict_t *vols, int32_t vol_count, snprintf (key, sizeof (key), "volume%d.brick%d.device_path", vol_count, brick_count); - ret = dict_get_str (vols, key, &snap_device); + ret = dict_get_str (peer_data, key, &snap_device); if (ret) { snprintf (msg, sizeof (msg), "%s missing in payload", key); goto out; @@ -3361,7 +3367,7 @@ out: } int32_t -glusterd_import_bricks (dict_t *vols, int32_t vol_count, +glusterd_import_bricks (dict_t *peer_data, int32_t vol_count, glusterd_volinfo_t *new_volinfo) { int ret = -1; @@ -3369,12 +3375,13 @@ glusterd_import_bricks (dict_t *vols, int32_t vol_count, int brickid = 0; glusterd_brickinfo_t *new_brickinfo = NULL; - GF_ASSERT (vols); + GF_ASSERT (peer_data); GF_ASSERT (vol_count >= 0); GF_ASSERT (new_volinfo); while (brick_count <= new_volinfo->brick_count) { - ret = glusterd_import_new_brick (vols, vol_count, brick_count, + ret = glusterd_import_new_brick (peer_data, vol_count, + brick_count, &new_brickinfo); if (ret) goto out; @@ -3394,7 +3401,7 @@ out: } static int -glusterd_import_quota_conf (dict_t *vols, int vol_idx, +glusterd_import_quota_conf (dict_t *peer_data, int vol_idx, glusterd_volinfo_t *new_volinfo) { int gfid_idx = 0; @@ -3408,6 +3415,7 @@ glusterd_import_quota_conf (dict_t *vols, int vol_idx, this = THIS; GF_ASSERT (this); + GF_ASSERT (peer_data); if (!glusterd_is_volume_quota_enabled (new_volinfo)) { (void) glusterd_clean_up_quota_store (new_volinfo); @@ -3426,20 +3434,21 @@ glusterd_import_quota_conf (dict_t *vols, int vol_idx, snprintf (key, sizeof (key)-1, "volume%d.quota-cksum", vol_idx); key[sizeof(key)-1] = '\0'; - ret = dict_get_uint32 (vols, key, &new_volinfo->quota_conf_cksum); + ret = dict_get_uint32 (peer_data, key, &new_volinfo->quota_conf_cksum); if (ret) gf_log (this->name, GF_LOG_DEBUG, "Failed to get quota cksum"); snprintf (key, sizeof (key)-1, "volume%d.quota-version", vol_idx); key[sizeof(key)-1] = '\0'; - ret = dict_get_uint32 (vols, key, &new_volinfo->quota_conf_version); + ret = dict_get_uint32 (peer_data, key, + &new_volinfo->quota_conf_version); if (ret) gf_log (this->name, GF_LOG_DEBUG, "Failed to get quota " "version"); snprintf (key, sizeof (key)-1, "volume%d.gfid-count", vol_idx); key[sizeof(key)-1] = '\0'; - ret = dict_get_int32 (vols, key, &gfid_count); + ret = dict_get_int32 (peer_data, key, &gfid_count); if (ret) goto out; @@ -3456,7 +3465,7 @@ glusterd_import_quota_conf (dict_t *vols, int vol_idx, snprintf (key, sizeof (key)-1, "volume%d.gfid%d", vol_idx, gfid_idx); key[sizeof(key)-1] = '\0'; - ret = dict_get_str (vols, key, &gfid_str); + ret = dict_get_str (peer_data, key, &gfid_str); if (ret) goto out; @@ -3538,7 +3547,7 @@ out: } int32_t -glusterd_import_volinfo (dict_t *vols, int count, +glusterd_import_volinfo (dict_t *peer_data, int count, glusterd_volinfo_t **volinfo) { int ret = -1; @@ -3558,11 +3567,11 @@ glusterd_import_volinfo (dict_t *vols, int count, int client_op_version = 0; uint32_t is_snap_volume = 0; - GF_ASSERT (vols); + GF_ASSERT (peer_data); GF_ASSERT (volinfo); snprintf (key, sizeof (key), "volume%d.name", count); - ret = dict_get_str (vols, key, &volname); + ret = dict_get_str (peer_data, key, &volname); if (ret) { snprintf (msg, sizeof (msg), "%s missing in payload", key); goto out; @@ -3570,7 +3579,7 @@ glusterd_import_volinfo (dict_t *vols, int count, memset (key, 0, sizeof (key)); snprintf (key, sizeof (key), "volume%d.is_snap_volume", count); - ret = dict_get_uint32 (vols, key, &is_snap_volume); + ret = dict_get_uint32 (peer_data, key, &is_snap_volume); if (ret) { snprintf (msg, sizeof (msg), "%s missing in payload for %s", key, volname); @@ -3592,7 +3601,7 @@ glusterd_import_volinfo (dict_t *vols, int count, memset (key, 0, sizeof (key)); snprintf (key, sizeof (key), "volume%d.type", count); - ret = dict_get_int32 (vols, key, &new_volinfo->type); + ret = dict_get_int32 (peer_data, key, &new_volinfo->type); if (ret) { snprintf (msg, sizeof (msg), "%s missing in payload for %s", key, volname); @@ -3601,7 +3610,7 @@ glusterd_import_volinfo (dict_t *vols, int count, memset (key, 0, sizeof (key)); snprintf (key, sizeof (key), "volume%d.brick_count", count); - ret = dict_get_int32 (vols, key, &new_volinfo->brick_count); + ret = dict_get_int32 (peer_data, key, &new_volinfo->brick_count); if (ret) { snprintf (msg, sizeof (msg), "%s missing in payload for %s", key, volname); @@ -3610,7 +3619,7 @@ glusterd_import_volinfo (dict_t *vols, int count, memset (key, 0, sizeof (key)); snprintf (key, sizeof (key), "volume%d.version", count); - ret = dict_get_int32 (vols, key, &new_volinfo->version); + ret = dict_get_int32 (peer_data, key, &new_volinfo->version); if (ret) { snprintf (msg, sizeof (msg), "%s missing in payload for %s", key, volname); @@ -3619,7 +3628,7 @@ glusterd_import_volinfo (dict_t *vols, int count, memset (key, 0, sizeof (key)); snprintf (key, sizeof (key), "volume%d.status", count); - ret = dict_get_int32 (vols, key, (int32_t *)&new_volinfo->status); + ret = dict_get_int32 (peer_data, key, (int32_t *)&new_volinfo->status); if (ret) { snprintf (msg, sizeof (msg), "%s missing in payload for %s", key, volname); @@ -3628,7 +3637,7 @@ glusterd_import_volinfo (dict_t *vols, int count, memset (key, 0, sizeof (key)); snprintf (key, sizeof (key), "volume%d.sub_count", count); - ret = dict_get_int32 (vols, key, &new_volinfo->sub_count); + ret = dict_get_int32 (peer_data, key, &new_volinfo->sub_count); if (ret) { snprintf (msg, sizeof (msg), "%s missing in payload for %s", key, volname); @@ -3639,7 +3648,7 @@ glusterd_import_volinfo (dict_t *vols, int count, (as peer may be of old version) */ memset (key, 0, sizeof (key)); snprintf (key, sizeof (key), "volume%d.stripe_count", count); - ret = dict_get_int32 (vols, key, &new_volinfo->stripe_count); + ret = dict_get_int32 (peer_data, key, &new_volinfo->stripe_count); if (ret) gf_log (THIS->name, GF_LOG_INFO, "peer is possibly old version"); @@ -3648,7 +3657,7 @@ glusterd_import_volinfo (dict_t *vols, int count, (as peer may be of old version) */ memset (key, 0, sizeof (key)); snprintf (key, sizeof (key), "volume%d.replica_count", count); - ret = dict_get_int32 (vols, key, &new_volinfo->replica_count); + ret = dict_get_int32 (peer_data, key, &new_volinfo->replica_count); if (ret) gf_log (THIS->name, GF_LOG_INFO, "peer is possibly old version"); @@ -3657,7 +3666,7 @@ glusterd_import_volinfo (dict_t *vols, int count, (as peer may be of old version) */ memset (key, 0, sizeof (key)); snprintf (key, sizeof (key), "volume%d.dist_count", count); - ret = dict_get_int32 (vols, key, &new_volinfo->dist_leaf_count); + ret = dict_get_int32 (peer_data, key, &new_volinfo->dist_leaf_count); if (ret) gf_log (THIS->name, GF_LOG_INFO, "peer is possibly old version"); @@ -3665,7 +3674,7 @@ glusterd_import_volinfo (dict_t *vols, int count, glusterd_get_dist_leaf_count (new_volinfo); memset (key, 0, sizeof (key)); snprintf (key, sizeof (key), "volume%d.ckusm", count); - ret = dict_get_uint32 (vols, key, &new_volinfo->cksum); + ret = dict_get_uint32 (peer_data, key, &new_volinfo->cksum); if (ret) { snprintf (msg, sizeof (msg), "%s missing in payload for %s", key, volname); @@ -3674,7 +3683,7 @@ glusterd_import_volinfo (dict_t *vols, int count, memset (key, 0, sizeof (key)); snprintf (key, sizeof (key), "volume%d.volume_id", count); - ret = dict_get_str (vols, key, &volume_id_str); + ret = dict_get_str (peer_data, key, &volume_id_str); if (ret) { snprintf (msg, sizeof (msg), "%s missing in payload for %s", key, volname); @@ -3685,7 +3694,7 @@ glusterd_import_volinfo (dict_t *vols, int count, memset (key, 0, sizeof (key)); snprintf (key, sizeof (key), "volume%d.username", count); - ret = dict_get_str (vols, key, &str); + ret = dict_get_str (peer_data, key, &str); if (!ret) { ret = glusterd_auth_set_username (new_volinfo, str); if (ret) @@ -3694,7 +3703,7 @@ glusterd_import_volinfo (dict_t *vols, int count, memset (key, 0, sizeof (key)); snprintf (key, sizeof (key), "volume%d.password", count); - ret = dict_get_str (vols, key, &str); + ret = dict_get_str (peer_data, key, &str); if (!ret) { ret = glusterd_auth_set_password (new_volinfo, str); if (ret) @@ -3703,7 +3712,7 @@ glusterd_import_volinfo (dict_t *vols, int count, memset (key, 0, sizeof (key)); snprintf (key, sizeof (key), "volume%d.transport_type", count); - ret = dict_get_uint32 (vols, key, &new_volinfo->transport_type); + ret = dict_get_uint32 (peer_data, key, &new_volinfo->transport_type); if (ret) { snprintf (msg, sizeof (msg), "%s missing in payload for %s", key, volname); @@ -3713,7 +3722,7 @@ glusterd_import_volinfo (dict_t *vols, int count, new_volinfo->is_snap_volume = is_snap_volume; snprintf (key, sizeof (key), "volume%d.restored_from_snap", count); - ret = dict_get_str (vols, key, &restored_snap); + ret = dict_get_str (peer_data, key, &restored_snap); if (ret) { snprintf (msg, sizeof (msg), "%s missing in payload for %s", key, volname); @@ -3723,7 +3732,8 @@ glusterd_import_volinfo (dict_t *vols, int count, uuid_parse (restored_snap, new_volinfo->restored_from_snap); snprintf (key, sizeof (key), "volume%d.snap-max-hard-limit", count); - ret = dict_get_uint64 (vols, key, &new_volinfo->snap_max_hard_limit); + ret = dict_get_uint64 (peer_data, key, + &new_volinfo->snap_max_hard_limit); if (ret) { snprintf (msg, sizeof (msg), "%s missing in payload for %s", key, volname); @@ -3732,7 +3742,7 @@ glusterd_import_volinfo (dict_t *vols, int count, memset (key, 0, sizeof (key)); snprintf (key, sizeof (key), "volume%d.rebalance", count); - ret = dict_get_uint32 (vols, key, &new_volinfo->rebal.defrag_cmd); + ret = dict_get_uint32 (peer_data, key, &new_volinfo->rebal.defrag_cmd); if (ret) { snprintf (msg, sizeof (msg), "%s missing in payload for %s", key, volname); @@ -3741,7 +3751,7 @@ glusterd_import_volinfo (dict_t *vols, int count, memset (key, 0, sizeof (key)); snprintf (key, sizeof (key), "volume%d.rebalance-id", count); - ret = dict_get_str (vols, key, &rebalance_id_str); + ret = dict_get_str (peer_data, key, &rebalance_id_str); if (ret) { /* This is not present in older glusterfs versions, * so don't error out @@ -3753,14 +3763,16 @@ glusterd_import_volinfo (dict_t *vols, int count, memset (key, 0, sizeof (key)); snprintf (key, sizeof (key), "volume%d.rebalance-op", count); - ret = dict_get_uint32 (vols, key,(uint32_t *) &new_volinfo->rebal.op); + ret = dict_get_uint32 (peer_data, key, + (uint32_t *) &new_volinfo->rebal.op); if (ret) { /* This is not present in older glusterfs versions, * so don't error out */ ret = 0; } - ret = gd_import_friend_volume_rebal_dict (vols, count, new_volinfo); + ret = gd_import_friend_volume_rebal_dict (peer_data, count, + new_volinfo); if (ret) { snprintf (msg, sizeof (msg), "Failed to import rebalance dict " "for volume."); @@ -3769,7 +3781,7 @@ glusterd_import_volinfo (dict_t *vols, int count, memset (key, 0, sizeof (key)); snprintf (key, 256, "volume%d."GLUSTERD_STORE_KEY_RB_STATUS, count); - ret = dict_get_int32 (vols, key, &rb_status); + ret = dict_get_int32 (peer_data, key, &rb_status); if (ret) goto out; new_volinfo->rep_brick.rb_status = rb_status; @@ -3779,7 +3791,7 @@ glusterd_import_volinfo (dict_t *vols, int count, memset (key, 0, sizeof (key)); snprintf (key, 256, "volume%d."GLUSTERD_STORE_KEY_RB_SRC_BRICK, count); - ret = dict_get_str (vols, key, &src_brick); + ret = dict_get_str (peer_data, key, &src_brick); if (ret) goto out; @@ -3794,7 +3806,7 @@ glusterd_import_volinfo (dict_t *vols, int count, memset (key, 0, sizeof (key)); snprintf (key, 256, "volume%d."GLUSTERD_STORE_KEY_RB_DST_BRICK, count); - ret = dict_get_str (vols, key, &dst_brick); + ret = dict_get_str (peer_data, key, &dst_brick); if (ret) goto out; @@ -3808,7 +3820,7 @@ glusterd_import_volinfo (dict_t *vols, int count, memset (key, 0, sizeof (key)); snprintf (key, sizeof (key), "volume%d.rb_id", count); - ret = dict_get_str (vols, key, &rb_id_str); + ret = dict_get_str (peer_data, key, &rb_id_str); if (ret) { /* This is not present in older glusterfs versions, * so don't error out @@ -3820,7 +3832,8 @@ glusterd_import_volinfo (dict_t *vols, int count, } - ret = glusterd_import_friend_volume_opts (vols, count, new_volinfo); + ret = glusterd_import_friend_volume_opts (peer_data, count, + new_volinfo); if (ret) goto out; @@ -3834,12 +3847,12 @@ glusterd_import_volinfo (dict_t *vols, int count, */ memset (key, 0, sizeof (key)); snprintf (key, sizeof (key), "volume%d.op-version", count); - ret = dict_get_int32 (vols, key, &op_version); + ret = dict_get_int32 (peer_data, key, &op_version); if (ret) ret = 0; memset (key, 0, sizeof (key)); snprintf (key, sizeof (key), "volume%d.client-op-version", count); - ret = dict_get_int32 (vols, key, &client_op_version); + ret = dict_get_int32 (peer_data, key, &client_op_version); if (ret) ret = 0; @@ -3860,9 +3873,9 @@ glusterd_import_volinfo (dict_t *vols, int count, memset (key, 0 ,sizeof (key)); snprintf (key, sizeof (key), "volume%d.caps", count); /*This is not present in older glusterfs versions, so ignore ret value*/ - ret = dict_get_int32 (vols, key, &new_volinfo->caps); + ret = dict_get_int32 (peer_data, key, &new_volinfo->caps); - ret = glusterd_import_bricks (vols, count, new_volinfo); + ret = glusterd_import_bricks (peer_data, count, new_volinfo); if (ret) goto out; @@ -4079,7 +4092,7 @@ out: } int32_t -glusterd_import_friend_volume (dict_t *vols, size_t count) +glusterd_import_friend_volume (dict_t *peer_data, size_t count) { int32_t ret = -1; @@ -4088,13 +4101,13 @@ glusterd_import_friend_volume (dict_t *vols, size_t count) glusterd_volinfo_t *old_volinfo = NULL; glusterd_volinfo_t *new_volinfo = NULL; - GF_ASSERT (vols); + GF_ASSERT (peer_data); this = THIS; GF_ASSERT (this); priv = this->private; GF_ASSERT (priv); - ret = glusterd_import_volinfo (vols, count, &new_volinfo); + ret = glusterd_import_volinfo (peer_data, count, &new_volinfo); if (ret) goto out; @@ -4120,7 +4133,7 @@ glusterd_import_friend_volume (dict_t *vols, size_t count) if (ret) goto out; - ret = glusterd_import_quota_conf (vols, count, new_volinfo); + ret = glusterd_import_quota_conf (peer_data, count, new_volinfo); if (ret) goto out; @@ -4132,20 +4145,20 @@ out: } int32_t -glusterd_import_friend_volumes (dict_t *vols) +glusterd_import_friend_volumes (dict_t *peer_data) { int32_t ret = -1; int32_t count = 0; int i = 1; - GF_ASSERT (vols); + GF_ASSERT (peer_data); - ret = dict_get_int32 (vols, "count", &count); + ret = dict_get_int32 (peer_data, "count", &count); if (ret) goto out; while (i <= count) { - ret = glusterd_import_friend_volume (vols, i); + ret = glusterd_import_friend_volume (peer_data, i); if (ret) goto out; i++; @@ -4406,7 +4419,7 @@ out: /* Import friend volumes missed_snap_list and update * * missed_snap_list if need be */ int32_t -glusterd_import_friend_missed_snap_list (dict_t *vols) +glusterd_import_friend_missed_snap_list (dict_t *peer_data) { int32_t missed_snap_count = -1; int32_t ret = -1; @@ -4415,13 +4428,14 @@ glusterd_import_friend_missed_snap_list (dict_t *vols) this = THIS; GF_ASSERT (this); - GF_ASSERT (vols); + GF_ASSERT (peer_data); priv = this->private; GF_ASSERT (priv); /* Add the friends missed_snaps entries to the in-memory list */ - ret = dict_get_int32 (vols, "missed_snap_count", &missed_snap_count); + ret = dict_get_int32 (peer_data, "missed_snap_count", + &missed_snap_count); if (ret) { gf_log (this->name, GF_LOG_INFO, "No missed snaps"); @@ -4429,7 +4443,8 @@ glusterd_import_friend_missed_snap_list (dict_t *vols) goto out; } - ret = glusterd_add_missed_snaps_to_list (vols, missed_snap_count); + ret = glusterd_add_missed_snaps_to_list (peer_data, + missed_snap_count); if (ret) { gf_log (this->name, GF_LOG_ERROR, "Failed to add missed snaps to list"); @@ -4459,25 +4474,29 @@ out: } int32_t -glusterd_compare_friend_data (dict_t *vols, int32_t *status, char *hostname) -{ - int32_t ret = -1; - int32_t count = 0; - int i = 1; - gf_boolean_t update = _gf_false; - gf_boolean_t stale_nfs = _gf_false; - gf_boolean_t stale_shd = _gf_false; - gf_boolean_t stale_qd = _gf_false; +glusterd_compare_friend_data (dict_t *peer_data, int32_t *status, + char *hostname) +{ + int32_t ret = -1; + int32_t count = 0; + int i = 1; + gf_boolean_t update = _gf_false; + gf_boolean_t stale_nfs = _gf_false; + gf_boolean_t stale_shd = _gf_false; + gf_boolean_t stale_qd = _gf_false; + xlator_t *this = NULL; - GF_ASSERT (vols); + this = THIS; + GF_ASSERT (this); + GF_ASSERT (peer_data); GF_ASSERT (status); - ret = dict_get_int32 (vols, "count", &count); + ret = dict_get_int32 (peer_data, "count", &count); if (ret) goto out; while (i <= count) { - ret = glusterd_compare_friend_volume (vols, i, status, + ret = glusterd_compare_friend_volume (peer_data, i, status, hostname); if (ret) goto out; @@ -4499,10 +4518,10 @@ glusterd_compare_friend_data (dict_t *vols, int32_t *status, char *hostname) stale_shd = _gf_true; if (glusterd_is_nodesvc_running ("quotad")) stale_qd = _gf_true; - ret = glusterd_import_global_opts (vols); + ret = glusterd_import_global_opts (peer_data); if (ret) goto out; - ret = glusterd_import_friend_volumes (vols); + ret = glusterd_import_friend_volumes (peer_data); if (ret) goto out; if (_gf_false == glusterd_are_all_volumes_stopped ()) { @@ -4518,9 +4537,8 @@ glusterd_compare_friend_data (dict_t *vols, int32_t *status, char *hostname) } out: - gf_log ("", GF_LOG_DEBUG, "Returning with ret: %d, status: %d", - ret, *status); - + gf_log (this->name, GF_LOG_DEBUG, + "Returning with ret: %d, status: %d", ret, *status); return ret; } diff --git a/xlators/mgmt/glusterd/src/glusterd-utils.h b/xlators/mgmt/glusterd/src/glusterd-utils.h index 76198428c..5d7c76b84 100644 --- a/xlators/mgmt/glusterd/src/glusterd-utils.h +++ b/xlators/mgmt/glusterd/src/glusterd-utils.h @@ -182,10 +182,11 @@ glusterd_volume_brickinfo_get_by_brick (char *brick, glusterd_brickinfo_t **brickinfo); int32_t -glusterd_build_volume_dict (dict_t **vols); +glusterd_add_volumes_to_export_dict (dict_t **peer_data); int32_t -glusterd_compare_friend_data (dict_t *vols, int32_t *status, char *hostname); +glusterd_compare_friend_data (dict_t *peer_data, int32_t *status, + char *hostname); int glusterd_compute_cksum (glusterd_volinfo_t *volinfo, @@ -251,7 +252,7 @@ int glusterd_remote_hostname_get (rpcsvc_request_t *req, char *remote_host, int len); int32_t -glusterd_import_friend_volumes (dict_t *vols); +glusterd_import_friend_volumes (dict_t *peer_data); void glusterd_set_volume_status (glusterd_volinfo_t *volinfo, glusterd_volume_status status); @@ -721,10 +722,10 @@ glusterd_add_missed_snaps_to_dict (dict_t *rsp_dict, int32_t brick_number, int32_t op); int32_t -glusterd_add_missed_snaps_to_export_dict (dict_t *vols); +glusterd_add_missed_snaps_to_export_dict (dict_t *peer_data); int32_t -glusterd_import_friend_missed_snap_list (dict_t *vols); +glusterd_import_friend_missed_snap_list (dict_t *peer_data); int32_t gd_restore_snap_volume (dict_t *rsp_dict, -- cgit From 54a5a42848870ee17b923c6c37d65fdfe4a5fec9 Mon Sep 17 00:00:00 2001 From: Avra Sengupta Date: Tue, 22 Apr 2014 00:52:57 +0000 Subject: glusterd/snapshot: Compare and update snapshots during peer handshake During a peer-handshake, after the volumes have synced, and the list of missed snapshots have synced, the node will perform the pending deletes and restores on this list. At this point, the current snapshot list in the node will be updated, and hence in case of conflicts arising during snapshot handshake, the peer hosting the bricks will be given precedence Likewise, if there will be a conflict, and both peers will be in the same state, i.e either both would be hosting bricks or both would not be hosting bricks, then a decision can't be taken and a peer-reject will happen. glusterd_compare_and_update_snap() implements the following algorithm to perform the above task: Step 1: Start. Step 2: Check if the peer is missing a delete on the said snap. If yes, goto step 6. Step 3: Check if there is a conflict between the peer's data and the local snap. If no, goto step 5. Step 4: As there is a conflict, check if both the peer and the local nodes are hosting bricks. Based on the results perform the following: Peer Hosts Bricks Local Node Hosts Bricks Action Yes Yes Goto Step 7 No No Goto Step 7 Yes No Goto Step 8 No Yes Goto Step 6 Step 5: Check if the local node is missing the peer's data. If yes, goto step 9. Step 6: It's a no-op. Goto step 10 Step 7: Peer Reject. Goto step 10 Step 8: Delete local node's data. Step 9: Accept Peer Data. Step 10: Stop Change-Id: I79be0f0f5f2a4f5c72277a4e77c2be732af432e1 BUG: 1061685 Signed-off-by: Avra Sengupta Reviewed-on: http://review.gluster.org/7525 Tested-by: Gluster Build System Reviewed-by: Krishnan Parthasarathi Reviewed-by: Rajesh Joseph Reviewed-by: Atin Mukherjee Reviewed-by: Vijay Bellur --- rpc/rpc-lib/src/protocol-common.h | 1 + xlators/mgmt/glusterd/src/glusterd-handler.c | 6 + xlators/mgmt/glusterd/src/glusterd-op-sm.c | 6 +- xlators/mgmt/glusterd/src/glusterd-rpc-ops.c | 8 + xlators/mgmt/glusterd/src/glusterd-sm.c | 10 + xlators/mgmt/glusterd/src/glusterd-store.c | 2 +- xlators/mgmt/glusterd/src/glusterd-utils.c | 1056 +++++++++++++++++++++++--- xlators/mgmt/glusterd/src/glusterd-utils.h | 22 +- 8 files changed, 985 insertions(+), 126 deletions(-) diff --git a/rpc/rpc-lib/src/protocol-common.h b/rpc/rpc-lib/src/protocol-common.h index 8129b8131..e4f7fbf3a 100644 --- a/rpc/rpc-lib/src/protocol-common.h +++ b/rpc/rpc-lib/src/protocol-common.h @@ -109,6 +109,7 @@ enum gf_probe_resp { GF_PROBE_ADD_FAILED, GF_PROBE_QUORUM_NOT_MET, GF_PROBE_MISSED_SNAP_CONFLICT, + GF_PROBE_SNAP_CONFLICT, }; enum gf_deprobe_resp { diff --git a/xlators/mgmt/glusterd/src/glusterd-handler.c b/xlators/mgmt/glusterd/src/glusterd-handler.c index ed756f15b..b8202b233 100644 --- a/xlators/mgmt/glusterd/src/glusterd-handler.c +++ b/xlators/mgmt/glusterd/src/glusterd-handler.c @@ -3409,6 +3409,12 @@ set_probe_error_str (int op_ret, int op_errno, char *op_errstr, char *errstr, "peer %s", hostname); break; + case GF_PROBE_SNAP_CONFLICT: + snprintf (errstr, len, "Conflict in comparing " + "list of snapshots from " + "peer %s", hostname); + break; + default: snprintf (errstr, len, "Probe returned with " "unknown errno %d", op_errno); diff --git a/xlators/mgmt/glusterd/src/glusterd-op-sm.c b/xlators/mgmt/glusterd/src/glusterd-op-sm.c index c22c2ea63..9b130b4c6 100644 --- a/xlators/mgmt/glusterd/src/glusterd-op-sm.c +++ b/xlators/mgmt/glusterd/src/glusterd-op-sm.c @@ -2082,12 +2082,12 @@ glusterd_op_sync_volume (dict_t *dict, char **op_errstr, if (volname) { ret = glusterd_add_volume_to_dict (volinfo, rsp_dict, - 1); + 1, "volume"); vol_count = 1; } else { list_for_each_entry (volinfo, &priv->volumes, vol_list) { - ret = glusterd_add_volume_to_dict (volinfo, - rsp_dict, count); + ret = glusterd_add_volume_to_dict (volinfo, rsp_dict, + count, "volume"); if (ret) goto out; diff --git a/xlators/mgmt/glusterd/src/glusterd-rpc-ops.c b/xlators/mgmt/glusterd/src/glusterd-rpc-ops.c index 09def1915..babd5a3be 100644 --- a/xlators/mgmt/glusterd/src/glusterd-rpc-ops.c +++ b/xlators/mgmt/glusterd/src/glusterd-rpc-ops.c @@ -1278,6 +1278,14 @@ glusterd_rpc_friend_add (call_frame_t *frame, xlator_t *this, "in the peer_data dict for handshake"); goto out; } + + ret = glusterd_add_snapshots_to_export_dict (peer_data); + if (ret) { + gf_log (this->name, GF_LOG_ERROR, + "Unable to add list of snapshots " + "in the peer_data dict for handshake"); + goto out; + } } uuid_copy (req.uuid, MY_UUID); diff --git a/xlators/mgmt/glusterd/src/glusterd-sm.c b/xlators/mgmt/glusterd/src/glusterd-sm.c index 3f0add220..e6ad34335 100644 --- a/xlators/mgmt/glusterd/src/glusterd-sm.c +++ b/xlators/mgmt/glusterd/src/glusterd-sm.c @@ -694,6 +694,16 @@ glusterd_ac_handle_friend_add_req (glusterd_friend_sm_event_t *event, void *ctx) op_errno = GF_PROBE_MISSED_SNAP_CONFLICT; op_ret = -1; } + + ret = glusterd_compare_friend_snapshots (ev_ctx->vols, + peerinfo); + if (ret) { + gf_log (this->name, GF_LOG_ERROR, + "Conflict in comparing peer's snapshots"); + event_type = GD_FRIEND_EVENT_LOCAL_RJT; + op_errno = GF_PROBE_SNAP_CONFLICT; + op_ret = -1; + } } ret = glusterd_friend_sm_new_event (event_type, &new_event); diff --git a/xlators/mgmt/glusterd/src/glusterd-store.c b/xlators/mgmt/glusterd/src/glusterd-store.c index d9d2a3e50..afbc8ff35 100644 --- a/xlators/mgmt/glusterd/src/glusterd-store.c +++ b/xlators/mgmt/glusterd/src/glusterd-store.c @@ -677,7 +677,7 @@ glusterd_store_create_volume_dir (glusterd_volinfo_t *volinfo) return ret; } -static int32_t +int32_t glusterd_store_create_snap_dir (glusterd_snap_t *snap) { int32_t ret = -1; diff --git a/xlators/mgmt/glusterd/src/glusterd-utils.c b/xlators/mgmt/glusterd/src/glusterd-utils.c index 20a3d0862..896827244 100644 --- a/xlators/mgmt/glusterd/src/glusterd-utils.c +++ b/xlators/mgmt/glusterd/src/glusterd-utils.c @@ -2239,12 +2239,17 @@ out: return ret; } +/* The prefix represents the type of volume to be added. + * It will be "volume" for normal volumes, and snap# like + * snap1, snap2, for snapshot volumes + */ int32_t glusterd_add_volume_to_dict (glusterd_volinfo_t *volinfo, - dict_t *dict, int32_t count) + dict_t *dict, int32_t count, + char *prefix) { int32_t ret = -1; - char prefix[512] = {0,}; + char pfx[512] = {0,}; char key[512] = {0,}; glusterd_brickinfo_t *brickinfo = NULL; int32_t i = 1; @@ -2261,14 +2266,15 @@ glusterd_add_volume_to_dict (glusterd_volinfo_t *volinfo, GF_ASSERT (this); GF_ASSERT (dict); GF_ASSERT (volinfo); + GF_ASSERT (prefix); - snprintf (key, sizeof (key), "volume%d.name", count); + snprintf (key, sizeof (key), "%s%d.name", prefix, count); ret = dict_set_str (dict, key, volinfo->volname); if (ret) goto out; memset (key, 0, sizeof (key)); - snprintf (key, sizeof (key), "volume%d.type", count); + snprintf (key, sizeof (key), "%s%d.type", prefix, count); ret = dict_set_int32 (dict, key, volinfo->type); if (ret) goto out; @@ -2280,68 +2286,81 @@ glusterd_add_volume_to_dict (glusterd_volinfo_t *volinfo, if (ret) goto out; + if (strlen (volinfo->parent_volname) > 0) { + snprintf (key, sizeof (key), "%s%d.parent_volname", + prefix, count); + ret = dict_set_dynstr_with_alloc (dict, key, + volinfo->parent_volname); + if (ret) { + gf_log (this->name, GF_LOG_ERROR, + "Failed to set parent_volname for %s", + volinfo->volname); + goto out; + } + } + memset (key, 0, sizeof (key)); - snprintf (key, sizeof (key), "volume%d.brick_count", count); + snprintf (key, sizeof (key), "%s%d.brick_count", prefix, count); ret = dict_set_int32 (dict, key, volinfo->brick_count); if (ret) goto out; memset (key, 0, sizeof (key)); - snprintf (key, sizeof (key), "volume%d.version", count); + snprintf (key, sizeof (key), "%s%d.version", prefix, count); ret = dict_set_int32 (dict, key, volinfo->version); if (ret) goto out; memset (key, 0, sizeof (key)); - snprintf (key, sizeof (key), "volume%d.status", count); + snprintf (key, sizeof (key), "%s%d.status", prefix, count); ret = dict_set_int32 (dict, key, volinfo->status); if (ret) goto out; memset (key, 0, sizeof (key)); - snprintf (key, sizeof (key), "volume%d.sub_count", count); + snprintf (key, sizeof (key), "%s%d.sub_count", prefix, count); ret = dict_set_int32 (dict, key, volinfo->sub_count); if (ret) goto out; memset (key, 0, sizeof (key)); - snprintf (key, sizeof (key), "volume%d.stripe_count", count); + snprintf (key, sizeof (key), "%s%d.stripe_count", prefix, count); ret = dict_set_int32 (dict, key, volinfo->stripe_count); if (ret) goto out; memset (key, 0, sizeof (key)); - snprintf (key, sizeof (key), "volume%d.replica_count", count); + snprintf (key, sizeof (key), "%s%d.replica_count", prefix, count); ret = dict_set_int32 (dict, key, volinfo->replica_count); if (ret) goto out; memset (key, 0, sizeof (key)); - snprintf (key, sizeof (key), "volume%d.dist_count", count); + snprintf (key, sizeof (key), "%s%d.dist_count", prefix, count); ret = dict_set_int32 (dict, key, volinfo->dist_leaf_count); if (ret) goto out; memset (key, 0, sizeof (key)); - snprintf (key, sizeof (key), "volume%d.ckusm", count); + snprintf (key, sizeof (key), "%s%d.ckusm", prefix, count); ret = dict_set_int64 (dict, key, volinfo->cksum); if (ret) goto out; memset (key, 0, sizeof (key)); - snprintf (key, sizeof (key), "volume%d.transport_type", count); + snprintf (key, sizeof (key), "%s%d.transport_type", prefix, count); ret = dict_set_uint32 (dict, key, volinfo->transport_type); if (ret) goto out; - snprintf (key, sizeof (key), "volume%d.is_snap_volume", count); + snprintf (key, sizeof (key), "%s%d.is_snap_volume", prefix, count); ret = dict_set_uint32 (dict, key, volinfo->is_snap_volume); if (ret) { gf_log (THIS->name, GF_LOG_ERROR, "Unable to set %s", key); goto out; } - snprintf (key, sizeof (key), "volume%d.snap-max-hard-limit", count); + snprintf (key, sizeof (key), "%s%d.snap-max-hard-limit", prefix, count); ret = dict_set_uint64 (dict, key, volinfo->snap_max_hard_limit); if (ret) { gf_log (THIS->name, GF_LOG_ERROR, "Unable to set %s", key); @@ -2354,14 +2373,14 @@ glusterd_add_volume_to_dict (glusterd_volinfo_t *volinfo, goto out; } memset (key, 0, sizeof (key)); - snprintf (key, sizeof (key), "volume%d.volume_id", count); + snprintf (key, sizeof (key), "%s%d.volume_id", prefix, count); ret = dict_set_dynstr (dict, key, volume_id_str); if (ret) goto out; volume_id_str = NULL; memset (key, 0, sizeof (key)); - snprintf (key, sizeof (key), "volume%d.username", count); + snprintf (key, sizeof (key), "%s%d.username", prefix, count); str = glusterd_auth_get_username (volinfo); if (str) { ret = dict_set_dynstr (dict, key, gf_strdup (str)); @@ -2370,7 +2389,7 @@ glusterd_add_volume_to_dict (glusterd_volinfo_t *volinfo, } memset (key, 0, sizeof (key)); - snprintf (key, sizeof (key), "volume%d.password", count); + snprintf (key, sizeof (key), "%s%d.password", prefix, count); str = glusterd_auth_get_password (volinfo); if (str) { ret = dict_set_dynstr (dict, key, gf_strdup (str)); @@ -2379,7 +2398,7 @@ glusterd_add_volume_to_dict (glusterd_volinfo_t *volinfo, } memset (key, 0, sizeof (key)); - snprintf (key, 256, "volume%d.rebalance", count); + snprintf (key, 256, "%s%d.rebalance", prefix, count); ret = dict_set_int32 (dict, key, volinfo->rebal.defrag_cmd); if (ret) goto out; @@ -2391,22 +2410,22 @@ glusterd_add_volume_to_dict (glusterd_volinfo_t *volinfo, goto out; } memset (key, 0, sizeof (key)); - snprintf (key, 256, "volume%d.rebalance-id", count); + snprintf (key, 256, "%s%d.rebalance-id", prefix, count); ret = dict_set_dynstr (dict, key, rebalance_id_str); if (ret) goto out; rebalance_id_str = NULL; memset (key, 0, sizeof (key)); - snprintf (key, sizeof (key), "volume%d.rebalance-op", count); + snprintf (key, sizeof (key), "%s%d.rebalance-op", prefix, count); ret = dict_set_uint32 (dict, key, volinfo->rebal.op); if (ret) goto out; if (volinfo->rebal.dict) { - snprintf (prefix, sizeof (prefix), "volume%d", count); + snprintf (pfx, sizeof (pfx), "%s%d", prefix, count); ctx.dict = dict; - ctx.prefix = prefix; + ctx.prefix = pfx; ctx.opt_count = 1; ctx.key_name = "rebal-dict-key"; ctx.val_name = "rebal-dict-value"; @@ -2421,7 +2440,7 @@ glusterd_add_volume_to_dict (glusterd_volinfo_t *volinfo, } memset (key, 0, sizeof (key)); - snprintf (key, 256, "volume%d."GLUSTERD_STORE_KEY_RB_STATUS, count); + snprintf (key, 256, "%s%d."GLUSTERD_STORE_KEY_RB_STATUS, prefix, count); ret = dict_set_int32 (dict, key, volinfo->rep_brick.rb_status); if (ret) goto out; @@ -2429,8 +2448,8 @@ glusterd_add_volume_to_dict (glusterd_volinfo_t *volinfo, if (volinfo->rep_brick.rb_status > GF_RB_STATUS_NONE) { memset (key, 0, sizeof (key)); - snprintf (key, 256, "volume%d."GLUSTERD_STORE_KEY_RB_SRC_BRICK, - count); + snprintf (key, 256, "%s%d."GLUSTERD_STORE_KEY_RB_SRC_BRICK, + prefix, count); gf_asprintf (&src_brick, "%s:%s", volinfo->rep_brick.src_brick->hostname, volinfo->rep_brick.src_brick->path); @@ -2439,8 +2458,8 @@ glusterd_add_volume_to_dict (glusterd_volinfo_t *volinfo, goto out; memset (key, 0, sizeof (key)); - snprintf (key, 256, "volume%d."GLUSTERD_STORE_KEY_RB_DST_BRICK, - count); + snprintf (key, 256, "%s%d."GLUSTERD_STORE_KEY_RB_DST_BRICK, + prefix, count); gf_asprintf (&dst_brick, "%s:%s", volinfo->rep_brick.dst_brick->hostname, volinfo->rep_brick.dst_brick->path); @@ -2455,16 +2474,16 @@ glusterd_add_volume_to_dict (glusterd_volinfo_t *volinfo, } memset (key, 0, sizeof (key)); - snprintf (key, sizeof (key), "volume%d.rb_id", count); + snprintf (key, sizeof (key), "%s%d.rb_id", prefix, count); ret = dict_set_dynstr (dict, key, rb_id_str); if (ret) goto out; rb_id_str = NULL; } - snprintf (prefix, sizeof (prefix), "volume%d", count); + snprintf (pfx, sizeof (pfx), "%s%d", prefix, count); ctx.dict = dict; - ctx.prefix = prefix; + ctx.prefix = pfx; ctx.opt_count = 1; ctx.key_name = "key"; ctx.val_name = "value"; @@ -2473,13 +2492,13 @@ glusterd_add_volume_to_dict (glusterd_volinfo_t *volinfo, dict_foreach (volinfo->dict, _add_dict_to_prdict, &ctx); ctx.opt_count--; memset (key, 0, sizeof (key)); - snprintf (key, sizeof (key), "volume%d.opt-count", count); + snprintf (key, sizeof (key), "%s%d.opt-count", prefix, count); ret = dict_set_int32 (dict, key, ctx.opt_count); if (ret) goto out; ctx.dict = dict; - ctx.prefix = prefix; + ctx.prefix = pfx; ctx.opt_count = 1; ctx.key_name = "slave-num"; ctx.val_name = "slave-val"; @@ -2489,42 +2508,42 @@ glusterd_add_volume_to_dict (glusterd_volinfo_t *volinfo, ctx.opt_count--; memset (key, 0, sizeof (key)); - snprintf (key, sizeof (key), "volume%d.gsync-count", count); + snprintf (key, sizeof (key), "%s%d.gsync-count", prefix, count); ret = dict_set_int32 (dict, key, ctx.opt_count); if (ret) goto out; list_for_each_entry (brickinfo, &volinfo->bricks, brick_list) { memset (key, 0, sizeof (key)); - snprintf (key, sizeof (key), "volume%d.brick%d.hostname", - count, i); + snprintf (key, sizeof (key), "%s%d.brick%d.hostname", + prefix, count, i); ret = dict_set_str (dict, key, brickinfo->hostname); if (ret) goto out; memset (key, 0, sizeof (key)); - snprintf (key, sizeof (key), "volume%d.brick%d.path", - count, i); + snprintf (key, sizeof (key), "%s%d.brick%d.path", + prefix, count, i); ret = dict_set_str (dict, key, brickinfo->path); if (ret) goto out; memset (key, 0, sizeof (key)); - snprintf (key, sizeof (key), "volume%d.brick%d.decommissioned", - count, i); + snprintf (key, sizeof (key), "%s%d.brick%d.decommissioned", + prefix, count, i); ret = dict_set_int32 (dict, key, brickinfo->decommissioned); if (ret) goto out; memset (key, 0, sizeof (key)); - snprintf (key, sizeof (key), "volume%d.brick%d.brick_id", - count, i); + snprintf (key, sizeof (key), "%s%d.brick%d.brick_id", + prefix, count, i); ret = dict_set_str (dict, key, brickinfo->brick_id); if (ret) goto out; - snprintf (key, sizeof (key), "volume%d.brick%d.snap_status", - count, i); + snprintf (key, sizeof (key), "%s%d.brick%d.snap_status", + prefix, count, i); ret = dict_set_int32 (dict, key, brickinfo->snap_status); if (ret) { gf_log (this->name, GF_LOG_ERROR, @@ -2534,8 +2553,8 @@ glusterd_add_volume_to_dict (glusterd_volinfo_t *volinfo, goto out; } - snprintf (key, sizeof (key), "volume%d.brick%d.device_path", - count, i); + snprintf (key, sizeof (key), "%s%d.brick%d.device_path", + prefix, count, i); ret = dict_set_str (dict, key, brickinfo->device_path); if (ret) { gf_log (this->name, GF_LOG_ERROR, @@ -2552,19 +2571,19 @@ glusterd_add_volume_to_dict (glusterd_volinfo_t *volinfo, * in the cluster */ memset (key, 0, sizeof (key)); - snprintf (key, sizeof (key), "volume%d.op-version", count); + snprintf (key, sizeof (key), "%s%d.op-version", prefix, count); ret = dict_set_int32 (dict, key, volinfo->op_version); if (ret) goto out; memset (key, 0, sizeof (key)); - snprintf (key, sizeof (key), "volume%d.client-op-version", count); + snprintf (key, sizeof (key), "%s%d.client-op-version", prefix, count); ret = dict_set_int32 (dict, key, volinfo->client_op_version); if (ret) goto out; /*Add volume Capability (BD Xlator) to dict*/ memset (key, 0 ,sizeof (key)); - snprintf (key, sizeof (key), "volume%d.caps", count); + snprintf (key, sizeof (key), "%s%d.caps", prefix, count); ret = dict_set_int32 (dict, key, volinfo->caps); out: @@ -2572,14 +2591,17 @@ out: GF_FREE (rebalance_id_str); GF_FREE (rb_id_str); - gf_log ("", GF_LOG_DEBUG, "Returning with %d", ret); - + gf_log (this->name, GF_LOG_DEBUG, "Returning with %d", ret); return ret; } +/* The prefix represents the type of volume to be added. + * It will be "volume" for normal volumes, and snap# like + * snap1, snap2, for snapshot volumes + */ int glusterd_vol_add_quota_conf_to_dict (glusterd_volinfo_t *volinfo, dict_t* load, - int vol_idx) + int vol_idx, char *prefix) { int fd = -1; char *gfid_str = NULL; @@ -2591,6 +2613,7 @@ glusterd_vol_add_quota_conf_to_dict (glusterd_volinfo_t *volinfo, dict_t* load, this = THIS; GF_ASSERT (this); + GF_ASSERT (prefix); ret = glusterd_store_create_quota_conf_sh_on_absence (volinfo); if (ret) @@ -2627,8 +2650,8 @@ glusterd_vol_add_quota_conf_to_dict (glusterd_volinfo_t *volinfo, dict_t* load, goto out; } - snprintf (key, sizeof(key)-1, "volume%d.gfid%d", vol_idx, - gfid_idx); + snprintf (key, sizeof(key)-1, "%s%d.gfid%d", prefix, + vol_idx, gfid_idx); key[sizeof(key)-1] = '\0'; ret = dict_set_dynstr (load, key, gfid_str); if (ret) { @@ -2638,19 +2661,19 @@ glusterd_vol_add_quota_conf_to_dict (glusterd_volinfo_t *volinfo, dict_t* load, gfid_str = NULL; } - snprintf (key, sizeof(key)-1, "volume%d.gfid-count", vol_idx); + snprintf (key, sizeof(key)-1, "%s%d.gfid-count", prefix, vol_idx); key[sizeof(key)-1] = '\0'; ret = dict_set_int32 (load, key, gfid_idx); if (ret) goto out; - snprintf (key, sizeof(key)-1, "volume%d.quota-cksum", vol_idx); + snprintf (key, sizeof(key)-1, "%s%d.quota-cksum", prefix, vol_idx); key[sizeof(key)-1] = '\0'; ret = dict_set_uint32 (load, key, volinfo->quota_conf_cksum); if (ret) goto out; - snprintf (key, sizeof(key)-1, "volume%d.quota-version", vol_idx); + snprintf (key, sizeof(key)-1, "%s%d.quota-version", prefix, vol_idx); key[sizeof(key)-1] = '\0'; ret = dict_set_uint32 (load, key, volinfo->quota_conf_version); if (ret) @@ -2725,6 +2748,175 @@ out: return ret; } +int32_t +glusterd_add_snap_to_dict (glusterd_snap_t *snap, dict_t *peer_data, + int32_t snap_count) +{ + char buf[NAME_MAX] = ""; + char prefix[NAME_MAX] = ""; + int32_t ret = -1; + int32_t volcount = 0; + glusterd_volinfo_t *volinfo = NULL; + glusterd_brickinfo_t *brickinfo = NULL; + gf_boolean_t host_bricks = _gf_false; + xlator_t *this = NULL; + + this = THIS; + GF_ASSERT (this); + GF_ASSERT (snap); + GF_ASSERT (peer_data); + + snprintf (prefix, sizeof(prefix), "snap%d", snap_count); + + list_for_each_entry (volinfo, &snap->volumes, vol_list) { + volcount++; + ret = glusterd_add_volume_to_dict (volinfo, peer_data, + volcount, prefix); + if (ret) { + gf_log (this->name, GF_LOG_ERROR, + "Failed to add snap:%s volume:%s " + "to peer_data dict for handshake", + snap->snapname, volinfo->volname); + goto out; + } + + ret = glusterd_vol_add_quota_conf_to_dict (volinfo, peer_data, + volcount, prefix); + if (ret) { + gf_log (this->name, GF_LOG_ERROR, + "Failed to add quota conf for " + "snap:%s volume:%s to peer_data " + "dict for handshake", snap->snapname, + volinfo->volname); + goto out; + } + + list_for_each_entry (brickinfo, &volinfo->bricks, brick_list) { + if (!uuid_compare (brickinfo->uuid, MY_UUID)) { + host_bricks = _gf_true; + break; + } + } + } + + snprintf (buf, sizeof(buf), "%s.host_bricks", prefix); + ret = dict_set_int8 (peer_data, buf, (int8_t) host_bricks); + if (ret) { + gf_log (this->name, GF_LOG_ERROR, + "Unable to set host_bricks for snap %s", + snap->snapname); + goto out; + } + + snprintf (buf, sizeof(buf), "%s.volcount", prefix); + ret = dict_set_int32 (peer_data, buf, volcount); + if (ret) { + gf_log (this->name, GF_LOG_ERROR, + "Unable to set volcount for snap %s", + snap->snapname); + goto out; + } + + snprintf (buf, sizeof(buf), "%s.snapname", prefix); + ret = dict_set_dynstr_with_alloc (peer_data, buf, snap->snapname); + if (ret) { + gf_log (this->name, GF_LOG_ERROR, + "Unable to set snapname for snap %s", + snap->snapname); + goto out; + } + + snprintf (buf, sizeof(buf), "%s.snap_id", prefix); + ret = dict_set_dynstr_with_alloc (peer_data, buf, + uuid_utoa (snap->snap_id)); + if (ret) { + gf_log (this->name, GF_LOG_ERROR, + "Unable to set snap_id for snap %s", + snap->snapname); + goto out; + } + + if (snap->description) { + snprintf (buf, sizeof(buf), "%s.snapid", prefix); + ret = dict_set_dynstr_with_alloc (peer_data, buf, + snap->description); + if (ret) { + gf_log (this->name, GF_LOG_ERROR, + "Unable to set description for snap %s", + snap->snapname); + goto out; + } + } + + snprintf (buf, sizeof(buf), "%s.time_stamp", prefix); + ret = dict_set_int64 (peer_data, buf, (int64_t)snap->time_stamp); + if (ret) { + gf_log (this->name, GF_LOG_ERROR, + "Unable to set time_stamp for snap %s", + snap->snapname); + goto out; + } + + snprintf (buf, sizeof(buf), "%s.snap_restored", prefix); + ret = dict_set_int8 (peer_data, buf, snap->snap_restored); + if (ret) { + gf_log (this->name, GF_LOG_ERROR, + "Unable to set snap_restored for snap %s", + snap->snapname); + goto out; + } + + snprintf (buf, sizeof(buf), "%s.snap_status", prefix); + ret = dict_set_int32 (peer_data, buf, snap->snap_status); + if (ret) { + gf_log (this->name, GF_LOG_ERROR, + "Unable to set snap_status for snap %s", + snap->snapname); + goto out; + } +out: + gf_log (this->name, GF_LOG_TRACE, "Returning %d", ret); + return ret; +} + +int32_t +glusterd_add_snapshots_to_export_dict (dict_t *peer_data) +{ + int32_t snap_count = 0; + int32_t ret = -1; + glusterd_conf_t *priv = NULL; + glusterd_snap_t *snap = NULL; + xlator_t *this = NULL; + + this = THIS; + GF_ASSERT (this); + priv = this->private; + GF_ASSERT (priv); + GF_ASSERT (peer_data); + + list_for_each_entry (snap, &priv->snapshots, snap_list) { + snap_count++; + ret = glusterd_add_snap_to_dict (snap, peer_data, snap_count); + if (ret) { + gf_log (this->name, GF_LOG_ERROR, + "Failed to add snap(%s) to the " + " peer_data dict for handshake", + snap->snapname); + goto out; + } + } + + ret = dict_set_int32 (peer_data, "snap_count", snap_count); + if (ret) { + gf_log (this->name, GF_LOG_ERROR, "Failed to set snap_count"); + goto out; + } + +out: + gf_log (this->name, GF_LOG_TRACE, "Returning %d", ret); + return ret; +} + int32_t glusterd_add_volumes_to_export_dict (dict_t **peer_data) { @@ -2747,12 +2939,14 @@ glusterd_add_volumes_to_export_dict (dict_t **peer_data) list_for_each_entry (volinfo, &priv->volumes, vol_list) { count++; - ret = glusterd_add_volume_to_dict (volinfo, dict, count); + ret = glusterd_add_volume_to_dict (volinfo, dict, count, + "volume"); if (ret) goto out; if (!glusterd_is_volume_quota_enabled (volinfo)) continue; - ret = glusterd_vol_add_quota_conf_to_dict (volinfo, dict, count); + ret = glusterd_vol_add_quota_conf_to_dict (volinfo, dict, + count, "volume"); if (ret) goto out; } @@ -3276,10 +3470,15 @@ out: return ret; } +/* The prefix represents the type of volume to be added. + * It will be "volume" for normal volumes, and snap# like + * snap1, snap2, for snapshot volumes + */ int32_t glusterd_import_new_brick (dict_t *peer_data, int32_t vol_count, int32_t brick_count, - glusterd_brickinfo_t **brickinfo) + glusterd_brickinfo_t **brickinfo, + char *prefix) { char key[512] = {0,}; int ret = -1; @@ -3295,10 +3494,11 @@ glusterd_import_new_brick (dict_t *peer_data, int32_t vol_count, GF_ASSERT (peer_data); GF_ASSERT (vol_count >= 0); GF_ASSERT (brickinfo); + GF_ASSERT (prefix); memset (key, 0, sizeof (key)); - snprintf (key, sizeof (key), "volume%d.brick%d.hostname", - vol_count, brick_count); + snprintf (key, sizeof (key), "%s%d.brick%d.hostname", + prefix, vol_count, brick_count); ret = dict_get_str (peer_data, key, &hostname); if (ret) { snprintf (msg, sizeof (msg), "%s missing in payload", key); @@ -3306,8 +3506,8 @@ glusterd_import_new_brick (dict_t *peer_data, int32_t vol_count, } memset (key, 0, sizeof (key)); - snprintf (key, sizeof (key), "volume%d.brick%d.path", - vol_count, brick_count); + snprintf (key, sizeof (key), "%s%d.brick%d.path", + prefix, vol_count, brick_count); ret = dict_get_str (peer_data, key, &path); if (ret) { snprintf (msg, sizeof (msg), "%s missing in payload", key); @@ -3315,29 +3515,29 @@ glusterd_import_new_brick (dict_t *peer_data, int32_t vol_count, } memset (key, 0, sizeof (key)); - snprintf (key, sizeof (key), "volume%d.brick%d.brick_id", - vol_count, brick_count); + snprintf (key, sizeof (key), "%s%d.brick%d.brick_id", + prefix, vol_count, brick_count); ret = dict_get_str (peer_data, key, &brick_id); memset (key, 0, sizeof (key)); - snprintf (key, sizeof (key), "volume%d.brick%d.decommissioned", - vol_count, brick_count); + snprintf (key, sizeof (key), "%s%d.brick%d.decommissioned", + prefix, vol_count, brick_count); ret = dict_get_int32 (peer_data, key, &decommissioned); if (ret) { /* For backward compatibility */ ret = 0; } - snprintf (key, sizeof (key), "volume%d.brick%d.snap_status", - vol_count, brick_count); + snprintf (key, sizeof (key), "%s%d.brick%d.snap_status", + prefix, vol_count, brick_count); ret = dict_get_int32 (peer_data, key, &snap_status); if (ret) { snprintf (msg, sizeof (msg), "%s missing in payload", key); goto out; } - snprintf (key, sizeof (key), "volume%d.brick%d.device_path", - vol_count, brick_count); + snprintf (key, sizeof (key), "%s%d.brick%d.device_path", + prefix, vol_count, brick_count); ret = dict_get_str (peer_data, key, &snap_device); if (ret) { snprintf (msg, sizeof (msg), "%s missing in payload", key); @@ -3366,9 +3566,13 @@ out: return ret; } +/* The prefix represents the type of volume to be added. + * It will be "volume" for normal volumes, and snap# like + * snap1, snap2, for snapshot volumes + */ int32_t glusterd_import_bricks (dict_t *peer_data, int32_t vol_count, - glusterd_volinfo_t *new_volinfo) + glusterd_volinfo_t *new_volinfo, char *prefix) { int ret = -1; int brick_count = 1; @@ -3378,11 +3582,12 @@ glusterd_import_bricks (dict_t *peer_data, int32_t vol_count, GF_ASSERT (peer_data); GF_ASSERT (vol_count >= 0); GF_ASSERT (new_volinfo); + GF_ASSERT (prefix); while (brick_count <= new_volinfo->brick_count) { ret = glusterd_import_new_brick (peer_data, vol_count, brick_count, - &new_brickinfo); + &new_brickinfo, prefix); if (ret) goto out; if (new_brickinfo->brick_id[0] == '\0') @@ -3400,9 +3605,14 @@ out: return ret; } +/* The prefix represents the type of volume to be added. + * It will be "volume" for normal volumes, and snap# like + * snap1, snap2, for snapshot volumes + */ static int glusterd_import_quota_conf (dict_t *peer_data, int vol_idx, - glusterd_volinfo_t *new_volinfo) + glusterd_volinfo_t *new_volinfo, + char *prefix) { int gfid_idx = 0; int gfid_count = 0; @@ -3416,6 +3626,7 @@ glusterd_import_quota_conf (dict_t *peer_data, int vol_idx, this = THIS; GF_ASSERT (this); GF_ASSERT (peer_data); + GF_ASSERT (prefix); if (!glusterd_is_volume_quota_enabled (new_volinfo)) { (void) glusterd_clean_up_quota_store (new_volinfo); @@ -3432,13 +3643,13 @@ glusterd_import_quota_conf (dict_t *peer_data, int vol_idx, goto out; } - snprintf (key, sizeof (key)-1, "volume%d.quota-cksum", vol_idx); + snprintf (key, sizeof (key)-1, "%s%d.quota-cksum", prefix, vol_idx); key[sizeof(key)-1] = '\0'; ret = dict_get_uint32 (peer_data, key, &new_volinfo->quota_conf_cksum); if (ret) gf_log (this->name, GF_LOG_DEBUG, "Failed to get quota cksum"); - snprintf (key, sizeof (key)-1, "volume%d.quota-version", vol_idx); + snprintf (key, sizeof (key)-1, "%s%d.quota-version", prefix, vol_idx); key[sizeof(key)-1] = '\0'; ret = dict_get_uint32 (peer_data, key, &new_volinfo->quota_conf_version); @@ -3446,7 +3657,7 @@ glusterd_import_quota_conf (dict_t *peer_data, int vol_idx, gf_log (this->name, GF_LOG_DEBUG, "Failed to get quota " "version"); - snprintf (key, sizeof (key)-1, "volume%d.gfid-count", vol_idx); + snprintf (key, sizeof (key)-1, "%s%d.gfid-count", prefix, vol_idx); key[sizeof(key)-1] = '\0'; ret = dict_get_int32 (peer_data, key, &gfid_count); if (ret) @@ -3462,8 +3673,8 @@ glusterd_import_quota_conf (dict_t *peer_data, int vol_idx, gfid_idx = 0; for (gfid_idx = 0; gfid_idx < gfid_count; gfid_idx++) { - snprintf (key, sizeof (key)-1, "volume%d.gfid%d", - vol_idx, gfid_idx); + snprintf (key, sizeof (key)-1, "%s%d.gfid%d", + prefix, vol_idx, gfid_idx); key[sizeof(key)-1] = '\0'; ret = dict_get_str (peer_data, key, &gfid_str); if (ret) @@ -3546,12 +3757,18 @@ out: return ret; } +/* The prefix represents the type of volume to be added. + * It will be "volume" for normal volumes, and snap# like + * snap1, snap2, for snapshot volumes + */ int32_t glusterd_import_volinfo (dict_t *peer_data, int count, - glusterd_volinfo_t **volinfo) + glusterd_volinfo_t **volinfo, + char *prefix) { int ret = -1; char key[256] = {0}; + char *parent_volname = NULL; char *volname = NULL; glusterd_volinfo_t *new_volinfo = NULL; char *volume_id_str = NULL; @@ -3569,8 +3786,9 @@ glusterd_import_volinfo (dict_t *peer_data, int count, GF_ASSERT (peer_data); GF_ASSERT (volinfo); + GF_ASSERT (prefix); - snprintf (key, sizeof (key), "volume%d.name", count); + snprintf (key, sizeof (key), "%s%d.name", prefix, count); ret = dict_get_str (peer_data, key, &volname); if (ret) { snprintf (msg, sizeof (msg), "%s missing in payload", key); @@ -3578,7 +3796,7 @@ glusterd_import_volinfo (dict_t *peer_data, int count, } memset (key, 0, sizeof (key)); - snprintf (key, sizeof (key), "volume%d.is_snap_volume", count); + snprintf (key, sizeof (key), "%s%d.is_snap_volume", prefix, count); ret = dict_get_uint32 (peer_data, key, &is_snap_volume); if (ret) { snprintf (msg, sizeof (msg), "%s missing in payload for %s", @@ -3586,21 +3804,13 @@ glusterd_import_volinfo (dict_t *peer_data, int count, goto out; } - if (is_snap_volume == _gf_true) { - gf_log (THIS->name, GF_LOG_DEBUG, - "Not syncing snap volume %s", volname); - ret = 0; - goto out; - } - ret = glusterd_volinfo_new (&new_volinfo); if (ret) goto out; strncpy (new_volinfo->volname, volname, sizeof (new_volinfo->volname)); - memset (key, 0, sizeof (key)); - snprintf (key, sizeof (key), "volume%d.type", count); + snprintf (key, sizeof (key), "%s%d.type", prefix, count); ret = dict_get_int32 (peer_data, key, &new_volinfo->type); if (ret) { snprintf (msg, sizeof (msg), "%s missing in payload for %s", @@ -3608,8 +3818,14 @@ glusterd_import_volinfo (dict_t *peer_data, int count, goto out; } + snprintf (key, sizeof (key), "%s%d.parent_volname", prefix, count); + ret = dict_get_str (peer_data, key, &parent_volname); + if (!ret) + strncpy (new_volinfo->parent_volname, parent_volname, + sizeof(new_volinfo->parent_volname)); + memset (key, 0, sizeof (key)); - snprintf (key, sizeof (key), "volume%d.brick_count", count); + snprintf (key, sizeof (key), "%s%d.brick_count", prefix, count); ret = dict_get_int32 (peer_data, key, &new_volinfo->brick_count); if (ret) { snprintf (msg, sizeof (msg), "%s missing in payload for %s", @@ -3618,7 +3834,7 @@ glusterd_import_volinfo (dict_t *peer_data, int count, } memset (key, 0, sizeof (key)); - snprintf (key, sizeof (key), "volume%d.version", count); + snprintf (key, sizeof (key), "%s%d.version", prefix, count); ret = dict_get_int32 (peer_data, key, &new_volinfo->version); if (ret) { snprintf (msg, sizeof (msg), "%s missing in payload for %s", @@ -3627,7 +3843,7 @@ glusterd_import_volinfo (dict_t *peer_data, int count, } memset (key, 0, sizeof (key)); - snprintf (key, sizeof (key), "volume%d.status", count); + snprintf (key, sizeof (key), "%s%d.status", prefix, count); ret = dict_get_int32 (peer_data, key, (int32_t *)&new_volinfo->status); if (ret) { snprintf (msg, sizeof (msg), "%s missing in payload for %s", @@ -3636,7 +3852,7 @@ glusterd_import_volinfo (dict_t *peer_data, int count, } memset (key, 0, sizeof (key)); - snprintf (key, sizeof (key), "volume%d.sub_count", count); + snprintf (key, sizeof (key), "%s%d.sub_count", prefix, count); ret = dict_get_int32 (peer_data, key, &new_volinfo->sub_count); if (ret) { snprintf (msg, sizeof (msg), "%s missing in payload for %s", @@ -3647,7 +3863,7 @@ glusterd_import_volinfo (dict_t *peer_data, int count, /* not having a 'stripe_count' key is not a error (as peer may be of old version) */ memset (key, 0, sizeof (key)); - snprintf (key, sizeof (key), "volume%d.stripe_count", count); + snprintf (key, sizeof (key), "%s%d.stripe_count", prefix, count); ret = dict_get_int32 (peer_data, key, &new_volinfo->stripe_count); if (ret) gf_log (THIS->name, GF_LOG_INFO, @@ -3656,7 +3872,7 @@ glusterd_import_volinfo (dict_t *peer_data, int count, /* not having a 'replica_count' key is not a error (as peer may be of old version) */ memset (key, 0, sizeof (key)); - snprintf (key, sizeof (key), "volume%d.replica_count", count); + snprintf (key, sizeof (key), "%s%d.replica_count", prefix, count); ret = dict_get_int32 (peer_data, key, &new_volinfo->replica_count); if (ret) gf_log (THIS->name, GF_LOG_INFO, @@ -3665,7 +3881,7 @@ glusterd_import_volinfo (dict_t *peer_data, int count, /* not having a 'dist_count' key is not a error (as peer may be of old version) */ memset (key, 0, sizeof (key)); - snprintf (key, sizeof (key), "volume%d.dist_count", count); + snprintf (key, sizeof (key), "%s%d.dist_count", prefix, count); ret = dict_get_int32 (peer_data, key, &new_volinfo->dist_leaf_count); if (ret) gf_log (THIS->name, GF_LOG_INFO, @@ -3673,7 +3889,7 @@ glusterd_import_volinfo (dict_t *peer_data, int count, new_volinfo->subvol_count = new_volinfo->brick_count/ glusterd_get_dist_leaf_count (new_volinfo); memset (key, 0, sizeof (key)); - snprintf (key, sizeof (key), "volume%d.ckusm", count); + snprintf (key, sizeof (key), "%s%d.ckusm", prefix, count); ret = dict_get_uint32 (peer_data, key, &new_volinfo->cksum); if (ret) { snprintf (msg, sizeof (msg), "%s missing in payload for %s", @@ -3682,7 +3898,7 @@ glusterd_import_volinfo (dict_t *peer_data, int count, } memset (key, 0, sizeof (key)); - snprintf (key, sizeof (key), "volume%d.volume_id", count); + snprintf (key, sizeof (key), "%s%d.volume_id", prefix, count); ret = dict_get_str (peer_data, key, &volume_id_str); if (ret) { snprintf (msg, sizeof (msg), "%s missing in payload for %s", @@ -3693,7 +3909,7 @@ glusterd_import_volinfo (dict_t *peer_data, int count, uuid_parse (volume_id_str, new_volinfo->volume_id); memset (key, 0, sizeof (key)); - snprintf (key, sizeof (key), "volume%d.username", count); + snprintf (key, sizeof (key), "%s%d.username", prefix, count); ret = dict_get_str (peer_data, key, &str); if (!ret) { ret = glusterd_auth_set_username (new_volinfo, str); @@ -3702,7 +3918,7 @@ glusterd_import_volinfo (dict_t *peer_data, int count, } memset (key, 0, sizeof (key)); - snprintf (key, sizeof (key), "volume%d.password", count); + snprintf (key, sizeof (key), "%s%d.password", prefix, count); ret = dict_get_str (peer_data, key, &str); if (!ret) { ret = glusterd_auth_set_password (new_volinfo, str); @@ -3711,7 +3927,7 @@ glusterd_import_volinfo (dict_t *peer_data, int count, } memset (key, 0, sizeof (key)); - snprintf (key, sizeof (key), "volume%d.transport_type", count); + snprintf (key, sizeof (key), "%s%d.transport_type", prefix, count); ret = dict_get_uint32 (peer_data, key, &new_volinfo->transport_type); if (ret) { snprintf (msg, sizeof (msg), "%s missing in payload for %s", @@ -3721,7 +3937,7 @@ glusterd_import_volinfo (dict_t *peer_data, int count, new_volinfo->is_snap_volume = is_snap_volume; - snprintf (key, sizeof (key), "volume%d.restored_from_snap", count); + snprintf (key, sizeof (key), "%s%d.restored_from_snap", prefix, count); ret = dict_get_str (peer_data, key, &restored_snap); if (ret) { snprintf (msg, sizeof (msg), "%s missing in payload for %s", @@ -3731,7 +3947,7 @@ glusterd_import_volinfo (dict_t *peer_data, int count, uuid_parse (restored_snap, new_volinfo->restored_from_snap); - snprintf (key, sizeof (key), "volume%d.snap-max-hard-limit", count); + snprintf (key, sizeof (key), "%s%d.snap-max-hard-limit", prefix, count); ret = dict_get_uint64 (peer_data, key, &new_volinfo->snap_max_hard_limit); if (ret) { @@ -3741,7 +3957,7 @@ glusterd_import_volinfo (dict_t *peer_data, int count, } memset (key, 0, sizeof (key)); - snprintf (key, sizeof (key), "volume%d.rebalance", count); + snprintf (key, sizeof (key), "%s%d.rebalance", prefix, count); ret = dict_get_uint32 (peer_data, key, &new_volinfo->rebal.defrag_cmd); if (ret) { snprintf (msg, sizeof (msg), "%s missing in payload for %s", @@ -3750,7 +3966,7 @@ glusterd_import_volinfo (dict_t *peer_data, int count, } memset (key, 0, sizeof (key)); - snprintf (key, sizeof (key), "volume%d.rebalance-id", count); + snprintf (key, sizeof (key), "%s%d.rebalance-id", prefix, count); ret = dict_get_str (peer_data, key, &rebalance_id_str); if (ret) { /* This is not present in older glusterfs versions, @@ -3762,7 +3978,7 @@ glusterd_import_volinfo (dict_t *peer_data, int count, } memset (key, 0, sizeof (key)); - snprintf (key, sizeof (key), "volume%d.rebalance-op", count); + snprintf (key, sizeof (key), "%s%d.rebalance-op", prefix, count); ret = dict_get_uint32 (peer_data, key, (uint32_t *) &new_volinfo->rebal.op); if (ret) { @@ -3780,7 +3996,7 @@ glusterd_import_volinfo (dict_t *peer_data, int count, } memset (key, 0, sizeof (key)); - snprintf (key, 256, "volume%d."GLUSTERD_STORE_KEY_RB_STATUS, count); + snprintf (key, 256, "%s%d."GLUSTERD_STORE_KEY_RB_STATUS, prefix, count); ret = dict_get_int32 (peer_data, key, &rb_status); if (ret) goto out; @@ -3789,8 +4005,8 @@ glusterd_import_volinfo (dict_t *peer_data, int count, if (new_volinfo->rep_brick.rb_status > GF_RB_STATUS_NONE) { memset (key, 0, sizeof (key)); - snprintf (key, 256, "volume%d."GLUSTERD_STORE_KEY_RB_SRC_BRICK, - count); + snprintf (key, 256, "%s%d."GLUSTERD_STORE_KEY_RB_SRC_BRICK, + prefix, count); ret = dict_get_str (peer_data, key, &src_brick); if (ret) goto out; @@ -3804,8 +4020,8 @@ glusterd_import_volinfo (dict_t *peer_data, int count, } memset (key, 0, sizeof (key)); - snprintf (key, 256, "volume%d."GLUSTERD_STORE_KEY_RB_DST_BRICK, - count); + snprintf (key, 256, "%s%d."GLUSTERD_STORE_KEY_RB_DST_BRICK, + prefix, count); ret = dict_get_str (peer_data, key, &dst_brick); if (ret) goto out; @@ -3819,7 +4035,7 @@ glusterd_import_volinfo (dict_t *peer_data, int count, } memset (key, 0, sizeof (key)); - snprintf (key, sizeof (key), "volume%d.rb_id", count); + snprintf (key, sizeof (key), "%s%d.rb_id", prefix, count); ret = dict_get_str (peer_data, key, &rb_id_str); if (ret) { /* This is not present in older glusterfs versions, @@ -3846,12 +4062,12 @@ glusterd_import_volinfo (dict_t *peer_data, int count, * present. Only one being present is a failure */ memset (key, 0, sizeof (key)); - snprintf (key, sizeof (key), "volume%d.op-version", count); + snprintf (key, sizeof (key), "%s%d.op-version", prefix, count); ret = dict_get_int32 (peer_data, key, &op_version); if (ret) ret = 0; memset (key, 0, sizeof (key)); - snprintf (key, sizeof (key), "volume%d.client-op-version", count); + snprintf (key, sizeof (key), "%s%d.client-op-version", prefix, count); ret = dict_get_int32 (peer_data, key, &client_op_version); if (ret) ret = 0; @@ -3871,11 +4087,11 @@ glusterd_import_volinfo (dict_t *peer_data, int count, } memset (key, 0 ,sizeof (key)); - snprintf (key, sizeof (key), "volume%d.caps", count); + snprintf (key, sizeof (key), "%s%d.caps", prefix, count); /*This is not present in older glusterfs versions, so ignore ret value*/ ret = dict_get_int32 (peer_data, key, &new_volinfo->caps); - ret = glusterd_import_bricks (peer_data, count, new_volinfo); + ret = glusterd_import_bricks (peer_data, count, new_volinfo, prefix); if (ret) goto out; @@ -4107,7 +4323,8 @@ glusterd_import_friend_volume (dict_t *peer_data, size_t count) GF_ASSERT (this); priv = this->private; GF_ASSERT (priv); - ret = glusterd_import_volinfo (peer_data, count, &new_volinfo); + ret = glusterd_import_volinfo (peer_data, count, + &new_volinfo, "volume"); if (ret) goto out; @@ -4133,7 +4350,8 @@ glusterd_import_friend_volume (dict_t *peer_data, size_t count) if (ret) goto out; - ret = glusterd_import_quota_conf (peer_data, count, new_volinfo); + ret = glusterd_import_quota_conf (peer_data, count, + new_volinfo, "volume"); if (ret) goto out; @@ -4473,6 +4691,602 @@ out: return ret; } +/* Check for the peer_snap_name in the list of existing snapshots. + * If a snap exists with the same name and a different snap_id, then + * there is a conflict. Set conflict as _gf_true, and snap to the + * conflicting snap object. If a snap exists with the same name, and the + * same snap_id, then there is no conflict. Set conflict as _gf_false + * and snap to the existing snap object. If no snap exists with the + * peer_snap_name, then there is no conflict. Set conflict as _gf_false + * and snap to NULL. + */ +void +glusterd_is_peer_snap_conflicting (char *peer_snap_name, char *peer_snap_id, + gf_boolean_t *conflict, + glusterd_snap_t **snap, char *hostname) +{ + uuid_t peer_snap_uuid = {0,}; + xlator_t *this = NULL; + + this = THIS; + GF_ASSERT (this); + GF_ASSERT (peer_snap_name); + GF_ASSERT (peer_snap_id); + GF_ASSERT (conflict); + GF_ASSERT (snap); + GF_ASSERT (hostname); + + *snap = glusterd_find_snap_by_name (peer_snap_name); + if (*snap) { + uuid_parse (peer_snap_id, peer_snap_uuid); + if (!uuid_compare (peer_snap_uuid, (*snap)->snap_id)) { + /* Current node contains the same snap having + * the same snapname and snap_id + */ + gf_log (this->name, GF_LOG_DEBUG, + "Snapshot %s from peer %s present in " + "localhost", peer_snap_name, hostname); + *conflict = _gf_false; + } else { + /* Current node contains the same snap having + * the same snapname but different snap_id + */ + gf_log (this->name, GF_LOG_DEBUG, + "Snapshot %s from peer %s conflicts with " + "snapshot in localhost", peer_snap_name, + hostname); + *conflict = _gf_true; + } + } else { + /* Peer contains snapshots missing on the current node */ + gf_log (this->name, GF_LOG_INFO, + "Snapshot %s from peer %s missing on localhost", + peer_snap_name, hostname); + *conflict = _gf_false; + } +} + +/* Check if the local node is hosting any bricks for the given snapshot */ +gf_boolean_t +glusterd_are_snap_bricks_local (glusterd_snap_t *snap) +{ + gf_boolean_t is_local = _gf_false; + glusterd_volinfo_t *volinfo = NULL; + glusterd_brickinfo_t *brickinfo = NULL; + xlator_t *this = NULL; + + this = THIS; + GF_ASSERT (this); + GF_ASSERT (snap); + + list_for_each_entry (volinfo, &snap->volumes, vol_list) { + list_for_each_entry (brickinfo, &volinfo->bricks, brick_list) { + if (!uuid_compare (brickinfo->uuid, MY_UUID)) { + is_local = _gf_true; + goto out; + } + } + } + +out: + gf_log (this->name, GF_LOG_TRACE, "Returning %d", is_local); + return is_local; +} + +/* Check if the peer has missed any snap delete for the given snap_id */ +gf_boolean_t +glusterd_peer_has_missed_snap_delete (glusterd_peerinfo_t *peerinfo, + char *peer_snap_id) +{ + char *peer_uuid = NULL; + gf_boolean_t missed_delete = _gf_false; + glusterd_conf_t *priv = NULL; + glusterd_missed_snap_info *missed_snapinfo = NULL; + glusterd_snap_op_t *snap_opinfo = NULL; + xlator_t *this = NULL; + + this = THIS; + GF_ASSERT (this); + priv = this->private; + GF_ASSERT (priv); + GF_ASSERT (peerinfo); + GF_ASSERT (peer_snap_id); + + peer_uuid = uuid_utoa (peerinfo->uuid); + + list_for_each_entry (missed_snapinfo, &priv->missed_snaps_list, + missed_snaps) { + /* Look for missed snap for the same peer, and + * the same snap_id + */ + if ((!strcmp (peer_uuid, missed_snapinfo->node_uuid)) && + (!strcmp (peer_snap_id, missed_snapinfo->snap_uuid))) { + /* Check if the missed snap's op is delete and the + * status is pending + */ + list_for_each_entry (snap_opinfo, + &missed_snapinfo->snap_ops, + snap_ops_list) { + if ((snap_opinfo->op == + GF_SNAP_OPTION_TYPE_DELETE) && + (snap_opinfo->status == + GD_MISSED_SNAP_PENDING)) { + missed_delete = _gf_true; + goto out; + } + } + } + } + +out: + gf_log (this->name, GF_LOG_TRACE, "Returning %d", missed_delete); + return missed_delete; +} + +/* Genrate and store snap volfiles for imported snap object */ +int32_t +glusterd_gen_snap_volfiles (glusterd_volinfo_t *snap_vol, char *peer_snap_name) +{ + int32_t ret = -1; + xlator_t *this = NULL; + glusterd_volinfo_t *parent_volinfo = NULL; + glusterd_brickinfo_t *brickinfo = NULL; + + this = THIS; + GF_ASSERT (this); + GF_ASSERT (snap_vol); + GF_ASSERT (peer_snap_name); + + ret = glusterd_store_volinfo (snap_vol, GLUSTERD_VOLINFO_VER_AC_NONE); + if (ret) { + gf_log (this->name, GF_LOG_ERROR, "Failed to store snapshot " + "volinfo (%s) for snap %s", snap_vol->volname, + peer_snap_name); + goto out; + } + + ret = generate_brick_volfiles (snap_vol); + if (ret) { + gf_log (this->name, GF_LOG_ERROR, + "generating the brick volfiles for the " + "snap %s failed", peer_snap_name); + goto out; + } + + ret = generate_client_volfiles (snap_vol, GF_CLIENT_TRUSTED); + if (ret) { + gf_log (this->name, GF_LOG_ERROR, + "generating the trusted client volfiles for " + "the snap %s failed", peer_snap_name); + goto out; + } + + ret = generate_client_volfiles (snap_vol, GF_CLIENT_OTHER); + if (ret) { + gf_log (this->name, GF_LOG_ERROR, + "generating the client volfiles for the " + "snap %s failed", peer_snap_name); + goto out; + } + + ret = glusterd_volinfo_find (snap_vol->parent_volname, + &parent_volinfo); + if (ret) { + gf_log (this->name, GF_LOG_ERROR, "Parent volinfo " + "not found for %s volume of snap %s", + snap_vol->volname, peer_snap_name); + goto out; + } + + glusterd_list_add_snapvol (parent_volinfo, snap_vol); + + list_for_each_entry (brickinfo, &snap_vol->bricks, brick_list) { + if (uuid_compare (brickinfo->uuid, MY_UUID)) + continue; + + if (brickinfo->snap_status == -1) { + gf_log (this->name, GF_LOG_INFO, + "not starting snap brick %s:%s for " + "for the snap %s (volume: %s)", + brickinfo->hostname, brickinfo->path, + peer_snap_name, parent_volinfo->volname); + continue; + } + + ret = glusterd_brick_start (snap_vol, brickinfo, _gf_true); + if (ret) { + gf_log (this->name, GF_LOG_WARNING, "starting the " + "brick %s:%s for the snap %s (volume: %s) " + "failed", brickinfo->hostname, brickinfo->path, + peer_snap_name, parent_volinfo->volname); + goto out; + } + } + + snap_vol->status = GLUSTERD_STATUS_STARTED; + + ret = glusterd_store_volinfo (snap_vol, GLUSTERD_VOLINFO_VER_AC_NONE); + if (ret) { + gf_log (this->name, GF_LOG_ERROR, + "Failed to store snap volinfo"); + goto out; + } +out: + gf_log (this->name, GF_LOG_TRACE, "Returning %d", ret); + return ret; +} + +/* Import snapshot info from peer_data and add it to priv */ +int32_t +glusterd_import_friend_snap (dict_t *peer_data, int32_t snap_count, + char *peer_snap_name, char *peer_snap_id) +{ + char buf[NAME_MAX] = ""; + char prefix[NAME_MAX] = ""; + dict_t *dict = NULL; + glusterd_snap_t *snap = NULL; + glusterd_volinfo_t *snap_vol = NULL; + glusterd_conf_t *priv = NULL; + int32_t ret = -1; + int32_t volcount = -1; + int32_t i = -1; + xlator_t *this = NULL; + + this = THIS; + GF_ASSERT (this); + priv = this->private; + GF_ASSERT (priv); + GF_ASSERT (peer_data); + GF_ASSERT (peer_snap_name); + GF_ASSERT (peer_snap_id); + + snprintf (prefix, sizeof(prefix), "snap%d", snap_count); + + snap = glusterd_new_snap_object (); + if (!snap) { + gf_log (this->name, GF_LOG_ERROR, "Could not create " + "the snap object for snap %s", peer_snap_name); + goto out; + } + + strcpy (snap->snapname, peer_snap_name); + uuid_parse (peer_snap_id, snap->snap_id); + + snprintf (buf, sizeof(buf), "%s.snapid", prefix); + ret = dict_get_str (peer_data, buf, &snap->description); + + snprintf (buf, sizeof(buf), "%s.time_stamp", prefix); + ret = dict_get_int64 (peer_data, buf, &snap->time_stamp); + if (ret) { + gf_log (this->name, GF_LOG_ERROR, + "Unable to get time_stamp for snap %s", + peer_snap_name); + goto out; + } + + snprintf (buf, sizeof(buf), "%s.snap_restored", prefix); + ret = dict_get_int8 (peer_data, buf, (int8_t *) &snap->snap_restored); + if (ret) { + gf_log (this->name, GF_LOG_ERROR, + "Unable to get snap_restored for snap %s", + peer_snap_name); + goto out; + } + + snprintf (buf, sizeof(buf), "%s.snap_status", prefix); + ret = dict_get_int32 (peer_data, buf, (int32_t *) &snap->snap_status); + if (ret) { + gf_log (this->name, GF_LOG_ERROR, + "Unable to get snap_status for snap %s", + peer_snap_name); + goto out; + } + + snprintf (buf, sizeof(buf), "%s.volcount", prefix); + ret = dict_get_int32 (peer_data, buf, &volcount); + if (ret) { + gf_log (this->name, GF_LOG_ERROR, + "Unable to get volcount for snap %s", + peer_snap_name); + goto out; + } + + ret = glusterd_store_create_snap_dir (snap); + if (ret) { + gf_log (THIS->name, GF_LOG_ERROR, "Failed to create snap dir"); + goto out; + } + + list_add_order (&snap->snap_list, &priv->snapshots, + glusterd_compare_snap_time); + + for (i = 1; i <= volcount; i++) { + ret = glusterd_import_volinfo (peer_data, i, + &snap_vol, prefix); + if (ret) { + gf_log (this->name, GF_LOG_ERROR, + "Failed to import snap volinfo for " + "snap %s", peer_snap_name); + goto out; + } + + snap_vol->snapshot = snap; + + ret = glusterd_gen_snap_volfiles (snap_vol, peer_snap_name); + if (ret) { + gf_log (this->name, GF_LOG_ERROR, + "Failed to generate snap vol files " + "for snap %s", peer_snap_name); + goto out; + } + + ret = glusterd_import_quota_conf (peer_data, i, + snap_vol, prefix); + if (ret) { + gf_log (this->name, GF_LOG_ERROR, + "Failed to import quota conf " + "for snap %s", peer_snap_name); + goto out; + } + + snap_vol = NULL; + } + + ret = glusterd_store_snap (snap); + if (ret) { + gf_log (this->name, GF_LOG_WARNING, "Could not store snap" + "object %s", peer_snap_name); + goto out; + } + +out: + if (ret) + glusterd_snap_remove (dict, snap, + _gf_true, _gf_true); + + if (dict) + dict_unref (dict); + + gf_log (this->name, GF_LOG_TRACE, "Returning %d", ret); + return ret; +} + +/* During a peer-handshake, after the volumes have synced, and the list of + * missed snapshots have synced, the node will perform the pending deletes + * and restores on this list. At this point, the current snapshot list in + * the node will be updated, and hence in case of conflicts arising during + * snapshot handshake, the peer hosting the bricks will be given precedence + * Likewise, if there will be a conflict, and both peers will be in the same + * state, i.e either both would be hosting bricks or both would not be hosting + * bricks, then a decision can't be taken and a peer-reject will happen. + * + * glusterd_compare_and_update_snap() implements the following algorithm to + * perform the above task: + * Step 1: Start. + * Step 2: Check if the peer is missing a delete on the said snap. + * If yes, goto step 6. + * Step 3: Check if there is a conflict between the peer's data and the + * local snap. If no, goto step 5. + * Step 4: As there is a conflict, check if both the peer and the local nodes + * are hosting bricks. Based on the results perform the following: + * Peer Hosts Bricks Local Node Hosts Bricks Action + * Yes Yes Goto Step 7 + * No No Goto Step 7 + * Yes No Goto Step 8 + * No Yes Goto Step 6 + * Step 5: Check if the local node is missing the peer's data. + * If yes, goto step 9. + * Step 6: It's a no-op. Goto step 10 + * Step 7: Peer Reject. Goto step 10 + * Step 8: Delete local node's data. + * Step 9: Accept Peer Data. + * Step 10: Stop + * + */ +int32_t +glusterd_compare_and_update_snap (dict_t *peer_data, int32_t snap_count, + glusterd_peerinfo_t *peerinfo) +{ + char buf[NAME_MAX] = ""; + char prefix[NAME_MAX] = ""; + char *peer_snap_name = NULL; + char *peer_snap_id = NULL; + dict_t *dict = NULL; + glusterd_snap_t *snap = NULL; + gf_boolean_t conflict = _gf_false; + gf_boolean_t is_local = _gf_false; + gf_boolean_t is_hosted = _gf_false; + gf_boolean_t missed_delete = _gf_false; + int32_t ret = -1; + xlator_t *this = NULL; + + this = THIS; + GF_ASSERT (this); + GF_ASSERT (peer_data); + GF_ASSERT (peerinfo); + + snprintf (prefix, sizeof(prefix), "snap%d", snap_count); + + /* Fetch the peer's snapname */ + snprintf (buf, sizeof(buf), "%s.snapname", prefix); + ret = dict_get_str (peer_data, buf, &peer_snap_name); + if (ret) { + gf_log (this->name, GF_LOG_ERROR, + "Unable to fetch snapname from peer: %s", + peerinfo->hostname); + goto out; + } + + /* Fetch the peer's snap_id */ + snprintf (buf, sizeof(buf), "%s.snap_id", prefix); + ret = dict_get_str (peer_data, buf, &peer_snap_id); + if (ret) { + gf_log (this->name, GF_LOG_ERROR, + "Unable to fetch snap_id from peer: %s", + peerinfo->hostname); + goto out; + } + + /* Check if the peer has missed a snap delete for the + * snap in question + */ + missed_delete = glusterd_peer_has_missed_snap_delete (peerinfo, + peer_snap_id); + if (missed_delete == _gf_true) { + /* Peer has missed delete on the missing/conflicting snap_id */ + gf_log (this->name, GF_LOG_INFO, "Peer %s has missed a delete " + "on snap %s", peerinfo->hostname, peer_snap_name); + ret = 0; + goto out; + } + + /* Check if there is a conflict, and if the + * peer data is already present + */ + glusterd_is_peer_snap_conflicting (peer_snap_name, peer_snap_id, + &conflict, &snap, + peerinfo->hostname); + if (conflict == _gf_false) { + if (snap) { + /* Peer has snap with the same snapname + * and snap_id. No need to accept peer data + */ + ret = 0; + goto out; + } else { + /* Peer has snap with the same snapname + * and snap_id, which local node doesn't have. + */ + goto accept_peer_data; + } + } + + /* There is a conflict. Check if the current node is + * hosting bricks for the conflicted snap. + */ + is_local = glusterd_are_snap_bricks_local (snap); + + /* Check if the peer is hosting any bricks for the + * conflicting snap + */ + snprintf (buf, sizeof(buf), "%s.host_bricks", prefix); + ret = dict_get_int8 (peer_data, buf, (int8_t *) &is_hosted); + if (ret) { + gf_log (this->name, GF_LOG_ERROR, + "Unable to fetch host_bricks from peer: %s " + "for %s", peerinfo->hostname, peer_snap_name); + goto out; + } + + /* As there is a conflict at this point of time, the data of the + * node that hosts a brick takes precedence. If both the local + * node and the peer are in the same state, i.e if both of them + * are either hosting or not hosting the bricks, for the snap, + * then it's a peer reject + */ + if (is_hosted == is_local) { + gf_log (this->name, GF_LOG_ERROR, + "Conflict in snapshot %s with peer %s", + peer_snap_name, peerinfo->hostname); + ret = -1; + goto out; + } + + if (is_hosted == _gf_false) { + /* If there was a conflict, and the peer is not hosting + * any brick, then don't accept peer data + */ + gf_log (this->name, GF_LOG_DEBUG, + "Peer doesn't hosts bricks for conflicting " + "snap(%s). Not accepting peer data.", + peer_snap_name); + ret = 0; + goto out; + } + + /* The peer is hosting a brick in case of conflict + * And local node isn't. Hence remove local node's + * data and accept peer data + */ + + gf_log (this->name, GF_LOG_DEBUG, "Peer hosts bricks for conflicting " + "snap(%s). Removing local data. Accepting peer data.", + peer_snap_name); + + dict = dict_new(); + if (!dict) { + gf_log (this->name, GF_LOG_ERROR, + "Unable to create dict"); + ret = -1; + goto out; + } + + ret = glusterd_snap_remove (dict, snap, _gf_true, _gf_false); + if (ret) { + gf_log (this->name, GF_LOG_ERROR, + "Failed to remove snap %s", snap->snapname); + goto out; + } + +accept_peer_data: + + /* Accept Peer Data */ + ret = glusterd_import_friend_snap (peer_data, snap_count, + peer_snap_name, peer_snap_id); + if (ret) { + gf_log (this->name, GF_LOG_ERROR, + "Failed to import snap %s from peer %s", + peer_snap_name, peerinfo->hostname); + goto out; + } + +out: + if (dict) + dict_unref (dict); + + gf_log (this->name, GF_LOG_TRACE, "Returning %d", ret); + return ret; +} + +/* Compare snapshots present in peer_data, with the snapshots in + * the current node + */ +int32_t +glusterd_compare_friend_snapshots (dict_t *peer_data, + glusterd_peerinfo_t *peerinfo) +{ + int32_t ret = -1; + int32_t snap_count = 0; + int i = 1; + xlator_t *this = NULL; + + this = THIS; + GF_ASSERT (this); + GF_ASSERT (peer_data); + GF_ASSERT (peerinfo); + + ret = dict_get_int32 (peer_data, "snap_count", &snap_count); + if (ret) { + gf_log (this->name, GF_LOG_ERROR, "Failed to fetch snap_count"); + goto out; + } + + for (i = 1; i <= snap_count; i++) { + /* Compare one snapshot from peer_data at a time */ + ret = glusterd_compare_and_update_snap (peer_data, i, peerinfo); + if (ret) { + gf_log (this->name, GF_LOG_ERROR, + "Failed to compare snapshots with peer %s", + peerinfo->hostname); + goto out; + } + } + +out: + gf_log (this->name, GF_LOG_TRACE, "Returning %d", ret); + return ret; +} + int32_t glusterd_compare_friend_data (dict_t *peer_data, int32_t *status, char *hostname) diff --git a/xlators/mgmt/glusterd/src/glusterd-utils.h b/xlators/mgmt/glusterd/src/glusterd-utils.h index 5d7c76b84..84fa89b0e 100644 --- a/xlators/mgmt/glusterd/src/glusterd-utils.h +++ b/xlators/mgmt/glusterd/src/glusterd-utils.h @@ -281,7 +281,8 @@ int32_t glusterd_volume_count_get (void); int32_t glusterd_add_volume_to_dict (glusterd_volinfo_t *volinfo, - dict_t *dict, int32_t count); + dict_t *dict, int32_t count, + char *prefix); int glusterd_get_brickinfo (xlator_t *this, const char *brickname, int port, gf_boolean_t localhost, @@ -735,4 +736,23 @@ gd_restore_snap_volume (dict_t *rsp_dict, int32_t glusterd_mount_lvm_snapshot (char *device_path, char *brick_mount_path); +int32_t +glusterd_add_snapshots_to_export_dict (dict_t *peer_data); + +int32_t +glusterd_compare_friend_snapshots (dict_t *peer_data, + glusterd_peerinfo_t *peerinfo); + +int32_t +glusterd_snapobject_delete (glusterd_snap_t *snap); + +int32_t +glusterd_snap_volume_remove (dict_t *rsp_dict, + glusterd_volinfo_t *snap_vol, + gf_boolean_t remove_lvm, + gf_boolean_t force); + +int32_t +glusterd_store_create_snap_dir (glusterd_snap_t *snap); + #endif -- cgit From f2bac9f9d5b9956969ddd25a54bc636b82f6923e Mon Sep 17 00:00:00 2001 From: Kotresh H R Date: Thu, 13 Feb 2014 23:53:27 +0530 Subject: features/libgfchangelog: APIs to process history changelogs. 1. Create directories in following fashion for history API's usage when consumer is registered with libgfchangelog shared library through gf_changelog_register. scratch_dir/.history scratch_dir/.history/.current scratch_dir/.history/.processed scratch_dir/.history/.processing 2. Added new file 'gf-history-changelog.c' and following APIs are provided for consumers to process history changelogs. 1. gf_history_changelog_scan: Move processed history changelog file from .processing to .processed 2. gf_history_changelog_next_change: Return the next history changelog file entry. Zero means all history chanelogs are consumed. 3. gf_history_changelog_done: Scan .processing directory and generate a list of change entries. 4. gf_history_changelog_start_fresh: For a set of changelogs, start from the begining. NOTE: Though this patch provides above funcationalities. It is considered functionally full with the patch (http://review.gluster.org/#/c/6930/). Change-Id: I200780c7278e0a6c008910d93faad5858a4b3e76 Original-author: Kotresh H R Signed-off-by: Kotresh H R Signed-off-by: Ajeet Jha Reviewed-on: http://review.gluster.org/6998 Tested-by: Gluster Build System Reviewed-by: Venky Shankar Tested-by: Venky Shankar --- xlators/features/changelog/lib/src/Makefile.am | 3 +- .../changelog/lib/src/gf-changelog-helpers.h | 4 + xlators/features/changelog/lib/src/gf-changelog.c | 57 ++++- .../changelog/lib/src/gf-history-changelog.c | 274 +++++++++++++++++++++ 4 files changed, 336 insertions(+), 2 deletions(-) create mode 100644 xlators/features/changelog/lib/src/gf-history-changelog.c diff --git a/xlators/features/changelog/lib/src/Makefile.am b/xlators/features/changelog/lib/src/Makefile.am index 775f026cf..28d5a70aa 100644 --- a/xlators/features/changelog/lib/src/Makefile.am +++ b/xlators/features/changelog/lib/src/Makefile.am @@ -17,7 +17,8 @@ lib_LTLIBRARIES = libgfchangelog.la CONTRIB_BUILDDIR = $(top_builddir)/contrib libgfchangelog_la_SOURCES = gf-changelog.c gf-changelog-process.c \ - gf-changelog-helpers.c $(CONTRIBDIR)/uuid/clear.c \ + gf-changelog-helpers.c gf-history-changelog.c \ + $(CONTRIBDIR)/uuid/clear.c \ $(CONTRIBDIR)/uuid/copy.c $(CONTRIBDIR)/uuid/gen_uuid.c \ $(CONTRIBDIR)/uuid/pack.c $(CONTRIBDIR)/uuid/parse.c \ $(CONTRIBDIR)/uuid/unparse.c $(CONTRIBDIR)/uuid/uuid_time.c \ diff --git a/xlators/features/changelog/lib/src/gf-changelog-helpers.h b/xlators/features/changelog/lib/src/gf-changelog-helpers.h index 7e13d9376..2d545da9e 100644 --- a/xlators/features/changelog/lib/src/gf-changelog-helpers.h +++ b/xlators/features/changelog/lib/src/gf-changelog-helpers.h @@ -23,6 +23,7 @@ #define GF_CHANGELOG_CURRENT_DIR ".current" #define GF_CHANGELOG_PROCESSED_DIR ".processed" #define GF_CHANGELOG_PROCESSING_DIR ".processing" +#define GF_CHANGELOG_HISTORY_DIR ".history" #ifndef MAXLINE #define MAXLINE 4096 @@ -68,6 +69,9 @@ typedef struct gf_changelog { char gfc_processing_dir[PATH_MAX]; pthread_t gfc_changelog_processor; + + /* Holds gfc for History API */ + struct gf_changelog *hist_gfc; } gf_changelog_t; int diff --git a/xlators/features/changelog/lib/src/gf-changelog.c b/xlators/features/changelog/lib/src/gf-changelog.c index 4b2b25ad5..0827f2cac 100644 --- a/xlators/features/changelog/lib/src/gf-changelog.c +++ b/xlators/features/changelog/lib/src/gf-changelog.c @@ -82,6 +82,10 @@ __attribute__ ((destructor)) gf_changelog_dtor (void) gfc = this->private; if (gfc) { + if (gfc->hist_gfc) { + gf_changelog_cleanup(gfc->hist_gfc); + GF_FREE (gfc->hist_gfc); + } gf_changelog_cleanup (gfc); GF_FREE (gfc); } @@ -437,6 +441,7 @@ gf_changelog_register (char *brick_path, char *scratch_dir, int errn = 0; xlator_t *this = NULL; gf_changelog_t *gfc = NULL; + char hist_scratch_dir[PATH_MAX] = {0,}; this = THIS; if (!this->ctx) @@ -460,6 +465,52 @@ gf_changelog_register (char *brick_path, char *scratch_dir, goto cleanup; } + /* Begin: Changes for History API */ + gfc->hist_gfc = NULL; + + gfc->hist_gfc = GF_CALLOC (1, sizeof (*gfc), + gf_changelog_mt_libgfchangelog_t); + if (!gfc->hist_gfc) + goto cleanup; + + gfc->hist_gfc->gfc_dir = NULL; + gfc->hist_gfc->gfc_fd = gfc->hist_gfc->gfc_sockfd = -1; + gfc->hist_gfc->this = NULL; + + (void) strncpy (hist_scratch_dir, scratch_dir, PATH_MAX); + (void) snprintf (hist_scratch_dir, PATH_MAX, + "%s/"GF_CHANGELOG_HISTORY_DIR"/", + gfc->gfc_working_dir); + + ret = mkdir_p (hist_scratch_dir, 0600, _gf_false); + if (ret) { + errn = errno; + goto cleanup; + } + + gfc->hist_gfc->gfc_working_dir = realpath (hist_scratch_dir, NULL); + if (!gfc->hist_gfc->gfc_working_dir) { + errn = errno; + goto cleanup; + } + + ret = gf_changelog_open_dirs (gfc->hist_gfc); + if (ret) { + errn = errno; + gf_log (this->name, GF_LOG_ERROR, + "could not create entries in history scratch dir"); + goto cleanup; + } + + (void) strncpy (gfc->hist_gfc->gfc_brickpath, brick_path, PATH_MAX); + + for (i=0; i < 256; i++) { + gfc->hist_gfc->rfc3986[i] = + (isalnum(i) || i == '~' || + i == '-' || i == '.' || i == '_') ? i : 0; + } + /* End: Changes for History API*/ + ret = gf_changelog_open_dirs (gfc); if (ret) { errn = errno; @@ -494,7 +545,7 @@ gf_changelog_register (char *brick_path, char *scratch_dir, goto cleanup; } - for (; i < 256; i++) { + for (i=0; i < 256; i++) { gfc->rfc3986[i] = (isalnum(i) || i == '~' || i == '-' || i == '.' || i == '_') ? i : 0; @@ -506,6 +557,10 @@ gf_changelog_register (char *brick_path, char *scratch_dir, goto out; cleanup: + if (gfc->hist_gfc) { + gf_changelog_cleanup (gfc->hist_gfc); + GF_FREE (gfc->hist_gfc); + } gf_changelog_cleanup (gfc); GF_FREE (gfc); this->private = NULL; diff --git a/xlators/features/changelog/lib/src/gf-history-changelog.c b/xlators/features/changelog/lib/src/gf-history-changelog.c new file mode 100644 index 000000000..bfc4cd37d --- /dev/null +++ b/xlators/features/changelog/lib/src/gf-history-changelog.c @@ -0,0 +1,274 @@ +#include +#include +#include +#include + +#ifndef _GNU_SOURCE +#define _GNU_SOURCE +#endif +#include + +#include "globals.h" +#include "glusterfs.h" +#include "logging.h" + +#include "gf-changelog-helpers.h" + +/* from the changelog translator */ +#include "changelog-misc.h" +#include "changelog-mem-types.h" + +/*@API + * gf_history_changelog_done: + * Move processed history changelog file from .processing + * to .processed + * + * ARGUMENTS: + * file(IN): path to processed history changelog file in + * .processing directory. + * + * RETURN VALUE: + * 0: On success. + * -1: On error. + */ +int +gf_history_changelog_done (char *file) +{ + int ret = -1; + char *buffer = NULL; + xlator_t *this = NULL; + gf_changelog_t *gfc = NULL; + gf_changelog_t *hist_gfc = NULL; + char to_path[PATH_MAX] = {0,}; + + errno = EINVAL; + + this = THIS; + if (!this) + goto out; + + gfc = (gf_changelog_t *) this->private; + if (!gfc) + goto out; + + hist_gfc = gfc->hist_gfc; + if (!hist_gfc) + goto out; + + if (!file || !strlen (file)) + goto out; + + /* make sure 'file' is inside ->gfc_working_dir */ + buffer = realpath (file, NULL); + if (!buffer) + goto out; + + if (strncmp (hist_gfc->gfc_working_dir, + buffer, strlen (hist_gfc->gfc_working_dir))) + goto out; + + (void) snprintf (to_path, PATH_MAX, "%s%s", + hist_gfc->gfc_processed_dir, basename (buffer)); + gf_log (this->name, GF_LOG_DEBUG, + "moving %s to processed directory", file); + ret = rename (buffer, to_path); + if (ret) { + gf_log (this->name, GF_LOG_ERROR, + "cannot move %s to %s (reason: %s)", + file, to_path, strerror (errno)); + goto out; + } + + ret = 0; + + out: + if (buffer) + free (buffer); /* allocated by realpath() */ + return ret; +} +/** + * @API + * gf_history_changelog_start_fresh: + * For a set of changelogs, start from the begining. + * It will truncates the history tracker fd. + * + * RETURN VALUES: + * 0: On success. + * -1: On error. + */ +int +gf_history_changelog_start_fresh () +{ + xlator_t *this = NULL; + gf_changelog_t *gfc = NULL; + gf_changelog_t *hist_gfc = NULL; + + this = THIS; + if (!this) + goto out; + + errno = EINVAL; + + gfc = (gf_changelog_t *) this->private; + if (!gfc) + goto out; + + hist_gfc = gfc->hist_gfc; + if (!hist_gfc) + goto out; + + if (gf_ftruncate (hist_gfc->gfc_fd, 0)) + goto out; + + return 0; + + out: + return -1; +} + +/* + * @API + * gf_history_changelog_next_change: + * Return the next history changelog file entry. Zero means all + * history chanelogs are consumed. + * + * ARGUMENTS: + * bufptr(OUT): Path to unprocessed history changelog file + * from tracker file. + * maxlen(IN): Usually PATH_MAX. + * + * RETURN VALUES: + * size: On success. + * -1 : On error. + */ +ssize_t +gf_history_changelog_next_change (char *bufptr, size_t maxlen) +{ + ssize_t size = 0; + int tracker_fd = 0; + xlator_t *this = NULL; + gf_changelog_t *gfc = NULL; + gf_changelog_t *hist_gfc = NULL; + char buffer[PATH_MAX] = {0,}; + + errno = EINVAL; + + this = THIS; + if (!this) + goto out; + + gfc = (gf_changelog_t *) this->private; + if (!gfc) + goto out; + + hist_gfc = gfc->hist_gfc; + if (!hist_gfc) + goto out; + + tracker_fd = hist_gfc->gfc_fd; + + size = gf_readline (tracker_fd, buffer, maxlen); + if (size < 0) + goto out; + if (size == 0) + return 0; + + memcpy (bufptr, buffer, size - 1); + *(buffer + size) = '\0'; + + return size; + + out: + return -1; +} + +/* + * @API + * gf_history_changelog_scan: + * Scan and generate a list of change entries. + * Calling this api multiple times (without calling gf_changlog_done()) + * would result new changelogs(s) being refreshed in the tracker file. + * This call also acts as a cancellation point for the consumer. + * + * RETURN VALUES: + * nr_entries: On success. + * -1 : On error. + */ +ssize_t +gf_history_changelog_scan () +{ + int ret = 0; + int tracker_fd = 0; + size_t len = 0; + size_t off = 0; + xlator_t *this = NULL; + size_t nr_entries = 0; + gf_changelog_t *gfc = NULL; + gf_changelog_t *hist_gfc = NULL; + struct dirent *entryp = NULL; + struct dirent *result = NULL; + char buffer[PATH_MAX] = {0,}; + + this = THIS; + if (!this) + goto out; + + gfc = (gf_changelog_t *) this->private; + if (!gfc) + goto out; + + hist_gfc = gfc->hist_gfc; + if (!hist_gfc) + goto out; + + errno = EINVAL; + + tracker_fd = hist_gfc->gfc_fd; + + if (gf_ftruncate (tracker_fd, 0)) + goto out; + + len = offsetof(struct dirent, d_name) + + pathconf(hist_gfc->gfc_processing_dir, _PC_NAME_MAX) + 1; + entryp = GF_CALLOC (1, len, + gf_changelog_mt_libgfchangelog_dirent_t); + if (!entryp) + goto out; + + rewinddir (hist_gfc->gfc_dir); + while (1) { + ret = readdir_r (hist_gfc->gfc_dir, entryp, &result); + if (ret || !result) + break; + + if ( !strcmp (basename (entryp->d_name), ".") + || !strcmp (basename (entryp->d_name), "..") ) + continue; + + nr_entries++; + + GF_CHANGELOG_FILL_BUFFER (hist_gfc->gfc_processing_dir, + buffer, off, + strlen (hist_gfc->gfc_processing_dir)); + GF_CHANGELOG_FILL_BUFFER (entryp->d_name, buffer, + off, strlen (entryp->d_name)); + GF_CHANGELOG_FILL_BUFFER ("\n", buffer, off, 1); + + if (gf_changelog_write (tracker_fd, buffer, off) != off) { + gf_log (this->name, GF_LOG_ERROR, + "error writing changelog filename" + " to tracker file"); + break; + } + off = 0; + } + + GF_FREE (entryp); + + if (!result) { + if (gf_lseek (tracker_fd, 0, SEEK_SET) != -1) + return nr_entries; + } + out: + return -1; +} -- cgit