summaryrefslogtreecommitdiffstats
path: root/xlators/protocol/server/src
diff options
context:
space:
mode:
Diffstat (limited to 'xlators/protocol/server/src')
-rw-r--r--xlators/protocol/server/src/authenticate.c327
-rw-r--r--xlators/protocol/server/src/server-common.c1166
-rw-r--r--xlators/protocol/server/src/server-handshake.c1730
-rw-r--r--xlators/protocol/server/src/server-helpers.c9811
-rw-r--r--xlators/protocol/server/src/server-resolve.c955
-rw-r--r--xlators/protocol/server/src/server-rpc-fops.c8890
-rw-r--r--xlators/protocol/server/src/server-rpc-fops_v2.c8434
-rw-r--r--xlators/protocol/server/src/server.c3086
8 files changed, 17000 insertions, 17399 deletions
diff --git a/xlators/protocol/server/src/authenticate.c b/xlators/protocol/server/src/authenticate.c
index 0d95b9a7ac9..c1229f9ebf3 100644
--- a/xlators/protocol/server/src/authenticate.c
+++ b/xlators/protocol/server/src/authenticate.c
@@ -8,8 +8,6 @@
cases as published by the Free Software Foundation.
*/
-
-
#ifndef _GNU_SOURCE
#define _GNU_SOURCE
#endif
@@ -21,217 +19,214 @@
#include "server-messages.h"
static int
-init (dict_t *this, char *key, data_t *value, void *data)
+init(dict_t *this, char *key, data_t *value, void *data)
{
- void *handle = NULL;
- char *auth_file = NULL;
- auth_handle_t *auth_handle = NULL;
- auth_fn_t authenticate = NULL;
- int *error = NULL;
- int ret = 0;
-
- /* It gets over written */
- error = data;
-
- if (!strncasecmp (key, "ip", SLEN ("ip"))) {
- gf_msg ("authenticate", GF_LOG_ERROR, 0,
- PS_MSG_AUTHENTICATE_ERROR, "AUTHENTICATION MODULE "
- "\"IP\" HAS BEEN REPLACED BY \"ADDR\"");
- dict_set (this, key, data_from_dynptr (NULL, 0));
- /* TODO: 1.3.x backward compatibility */
- // *error = -1;
- // return;
- key = "addr";
- }
-
- ret = gf_asprintf (&auth_file, "%s/%s.so", LIBDIR, key);
- if (-1 == ret) {
- dict_set (this, key, data_from_dynptr (NULL, 0));
- *error = -1;
- return -1;
- }
-
- handle = dlopen (auth_file, RTLD_LAZY);
- if (!handle) {
- gf_msg ("authenticate", GF_LOG_ERROR, 0,
- PS_MSG_AUTHENTICATE_ERROR, "dlopen(%s): %s\n",
- auth_file, dlerror ());
- dict_set (this, key, data_from_dynptr (NULL, 0));
- GF_FREE (auth_file);
- *error = -1;
- return -1;
- }
- GF_FREE (auth_file);
-
- authenticate = dlsym (handle, "gf_auth");
- if (!authenticate) {
- gf_msg ("authenticate", GF_LOG_ERROR, 0,
- PS_MSG_AUTHENTICATE_ERROR, "dlsym(gf_auth) on %s\n",
- dlerror ());
- dict_set (this, key, data_from_dynptr (NULL, 0));
- dlclose (handle);
- *error = -1;
- return -1;
- }
-
- auth_handle = GF_CALLOC (1, sizeof (*auth_handle),
- gf_common_mt_auth_handle_t);
- if (!auth_handle) {
- dict_set (this, key, data_from_dynptr (NULL, 0));
- *error = -1;
- dlclose (handle);
- return -1;
- }
- auth_handle->vol_opt = GF_CALLOC (1, sizeof (volume_opt_list_t),
- gf_common_mt_volume_opt_list_t);
- if (!auth_handle->vol_opt) {
- dict_set (this, key, data_from_dynptr (NULL, 0));
- *error = -1;
- GF_FREE (auth_handle);
- dlclose (handle);
- return -1;
- }
- auth_handle->vol_opt->given_opt = dlsym (handle, "options");
- if (auth_handle->vol_opt->given_opt == NULL) {
- gf_msg_debug ("authenticate", 0, "volume option validation "
- "not specified");
- }
-
- auth_handle->authenticate = authenticate;
- auth_handle->handle = handle;
-
- dict_set (this, key,
- data_from_dynptr (auth_handle, sizeof (*auth_handle)));
- return 0;
+ void *handle = NULL;
+ char *auth_file = NULL;
+ auth_handle_t *auth_handle = NULL;
+ auth_fn_t authenticate = NULL;
+ int *error = NULL;
+ int ret = 0;
+
+ /* It gets over written */
+ error = data;
+
+ if (!strncasecmp(key, "ip", SLEN("ip"))) {
+ gf_msg("authenticate", GF_LOG_ERROR, 0, PS_MSG_AUTHENTICATE_ERROR,
+ "AUTHENTICATION MODULE "
+ "\"IP\" HAS BEEN REPLACED BY \"ADDR\"");
+ dict_set(this, key, data_from_dynptr(NULL, 0));
+ /* TODO: 1.3.x backward compatibility */
+ // *error = -1;
+ // return;
+ key = "addr";
+ }
+
+ ret = gf_asprintf(&auth_file, "%s/%s.so", LIBDIR, key);
+ if (-1 == ret) {
+ dict_set(this, key, data_from_dynptr(NULL, 0));
+ *error = -1;
+ return -1;
+ }
+
+ handle = dlopen(auth_file, RTLD_LAZY);
+ if (!handle) {
+ gf_msg("authenticate", GF_LOG_ERROR, 0, PS_MSG_AUTHENTICATE_ERROR,
+ "dlopen(%s): %s\n", auth_file, dlerror());
+ dict_set(this, key, data_from_dynptr(NULL, 0));
+ GF_FREE(auth_file);
+ *error = -1;
+ return -1;
+ }
+ GF_FREE(auth_file);
+
+ authenticate = dlsym(handle, "gf_auth");
+ if (!authenticate) {
+ gf_msg("authenticate", GF_LOG_ERROR, 0, PS_MSG_AUTHENTICATE_ERROR,
+ "dlsym(gf_auth) on %s\n", dlerror());
+ dict_set(this, key, data_from_dynptr(NULL, 0));
+ dlclose(handle);
+ *error = -1;
+ return -1;
+ }
+
+ auth_handle = GF_CALLOC(1, sizeof(*auth_handle),
+ gf_common_mt_auth_handle_t);
+ if (!auth_handle) {
+ dict_set(this, key, data_from_dynptr(NULL, 0));
+ *error = -1;
+ dlclose(handle);
+ return -1;
+ }
+ auth_handle->vol_opt = GF_CALLOC(1, sizeof(volume_opt_list_t),
+ gf_common_mt_volume_opt_list_t);
+ if (!auth_handle->vol_opt) {
+ dict_set(this, key, data_from_dynptr(NULL, 0));
+ *error = -1;
+ GF_FREE(auth_handle);
+ dlclose(handle);
+ return -1;
+ }
+ auth_handle->vol_opt->given_opt = dlsym(handle, "options");
+ if (auth_handle->vol_opt->given_opt == NULL) {
+ gf_msg_debug("authenticate", 0,
+ "volume option validation "
+ "not specified");
+ }
+
+ auth_handle->authenticate = authenticate;
+ auth_handle->handle = handle;
+
+ dict_set(this, key, data_from_dynptr(auth_handle, sizeof(*auth_handle)));
+ return 0;
}
static int
-fini (dict_t *this, char *key, data_t *value, void *data)
+fini(dict_t *this, char *key, data_t *value, void *data)
{
- auth_handle_t *handle = data_to_ptr (value);
- if (handle) {
- dlclose (handle->handle);
- }
- return 0;
+ auth_handle_t *handle = data_to_ptr(value);
+ if (handle) {
+ dlclose(handle->handle);
+ }
+ return 0;
}
static int
-_gf_auth_option_validate (dict_t *d, char *k, data_t *v, void *tmp)
+_gf_auth_option_validate(dict_t *d, char *k, data_t *v, void *tmp)
{
- auth_handle_t *handle = NULL;
- xlator_t *xl = NULL;
- int ret = 0;
+ auth_handle_t *handle = NULL;
+ xlator_t *xl = NULL;
+ int ret = 0;
- xl = tmp;
+ xl = tmp;
- handle = data_to_ptr (v);
- if (!handle)
- return 0;
+ handle = data_to_ptr(v);
+ if (!handle)
+ return 0;
- list_add_tail (&(handle->vol_opt->list), &(xl->volume_options));
+ list_add_tail(&(handle->vol_opt->list), &(xl->volume_options));
- ret = xlator_options_validate_list (xl, xl->options,
- handle->vol_opt, NULL);
- if (ret) {
- gf_msg ("authenticate", GF_LOG_ERROR, 0,
- PS_MSG_VOL_VALIDATE_FAILED, "volume option validation "
- "failed");
- return -1;
- }
- return 0;
+ ret = xlator_options_validate_list(xl, xl->options, handle->vol_opt, NULL);
+ if (ret) {
+ gf_msg("authenticate", GF_LOG_ERROR, 0, PS_MSG_VOL_VALIDATE_FAILED,
+ "volume option validation "
+ "failed");
+ return -1;
+ }
+ return 0;
}
int32_t
-gf_auth_init (xlator_t *xl, dict_t *auth_modules)
+gf_auth_init(xlator_t *xl, dict_t *auth_modules)
{
- int ret = 0;
+ int ret = 0;
- dict_foreach (auth_modules, init, &ret);
- if (ret)
- goto out;
+ dict_foreach(auth_modules, init, &ret);
+ if (ret)
+ goto out;
- ret = dict_foreach (auth_modules, _gf_auth_option_validate, xl);
+ ret = dict_foreach(auth_modules, _gf_auth_option_validate, xl);
out:
- if (ret) {
- gf_msg (xl->name, GF_LOG_ERROR, 0, PS_MSG_AUTH_INIT_FAILED,
- "authentication init failed");
- dict_foreach (auth_modules, fini, &ret);
- ret = -1;
- }
- return ret;
+ if (ret) {
+ gf_msg(xl->name, GF_LOG_ERROR, 0, PS_MSG_AUTH_INIT_FAILED,
+ "authentication init failed");
+ dict_foreach(auth_modules, fini, &ret);
+ ret = -1;
+ }
+ return ret;
}
typedef struct {
- dict_t *iparams;
- dict_t *cparams;
- int64_t result;
+ dict_t *iparams;
+ dict_t *cparams;
+ int64_t result;
} gf_auth_args_t;
static int
-gf_auth_one_method (dict_t *this, char *key, data_t *value, void *data)
+gf_auth_one_method(dict_t *this, char *key, data_t *value, void *data)
{
- gf_auth_args_t *args = data;
- auth_handle_t *handle = NULL;
+ gf_auth_args_t *args = data;
+ auth_handle_t *handle = NULL;
- if (!value) {
- return 0;
- }
+ if (!value) {
+ return 0;
+ }
- handle = data_to_ptr (value);
- if (!handle || !handle->authenticate) {
- return 0;
- }
+ handle = data_to_ptr(value);
+ if (!handle || !handle->authenticate) {
+ return 0;
+ }
- switch (handle->authenticate (args->iparams, args->cparams)) {
+ switch (handle->authenticate(args->iparams, args->cparams)) {
case AUTH_ACCEPT:
- if (args->result != AUTH_REJECT) {
- args->result = AUTH_ACCEPT;
- }
- /* FALLTHROUGH */
+ if (args->result != AUTH_REJECT) {
+ args->result = AUTH_ACCEPT;
+ }
+ /* FALLTHROUGH */
default:
- return 0;
+ return 0;
case AUTH_REJECT:
- args->result = AUTH_REJECT;
- return -1;
- }
+ args->result = AUTH_REJECT;
+ return -1;
+ }
}
auth_result_t
-gf_authenticate (dict_t *input_params,
- dict_t *config_params,
- dict_t *auth_modules)
+gf_authenticate(dict_t *input_params, dict_t *config_params,
+ dict_t *auth_modules)
{
- char *name = NULL;
- data_t *peerinfo_data = NULL;
- gf_auth_args_t args;
-
- args.iparams = input_params;
- args.cparams = config_params;
- args.result = AUTH_DONT_CARE;
+ char *name = NULL;
+ data_t *peerinfo_data = NULL;
+ gf_auth_args_t args;
- dict_foreach (auth_modules, gf_auth_one_method, &args);
+ args.iparams = input_params;
+ args.cparams = config_params;
+ args.result = AUTH_DONT_CARE;
- if (AUTH_DONT_CARE == args.result) {
- peerinfo_data = dict_get (input_params, "peer-info-name");
+ dict_foreach(auth_modules, gf_auth_one_method, &args);
- if (peerinfo_data) {
- name = peerinfo_data->data;
- }
+ if (AUTH_DONT_CARE == args.result) {
+ peerinfo_data = dict_get(input_params, "peer-info-name");
- gf_msg ("auth", GF_LOG_ERROR, 0, PS_MSG_REMOTE_CLIENT_REFUSED,
- "no authentication module is interested in "
- "accepting remote-client %s", name);
- args.result = AUTH_REJECT;
+ if (peerinfo_data) {
+ name = peerinfo_data->data;
}
- return args.result;
+ gf_msg("auth", GF_LOG_ERROR, 0, PS_MSG_REMOTE_CLIENT_REFUSED,
+ "no authentication module is interested in "
+ "accepting remote-client %s",
+ name);
+ args.result = AUTH_REJECT;
+ }
+
+ return args.result;
}
void
-gf_auth_fini (dict_t *auth_modules)
+gf_auth_fini(dict_t *auth_modules)
{
- int32_t dummy;
+ int32_t dummy;
- dict_foreach (auth_modules, fini, &dummy);
+ dict_foreach(auth_modules, fini, &dummy);
}
diff --git a/xlators/protocol/server/src/server-common.c b/xlators/protocol/server/src/server-common.c
index 071a1cf2714..b5d61edccfb 100644
--- a/xlators/protocol/server/src/server-common.c
+++ b/xlators/protocol/server/src/server-common.c
@@ -11,871 +11,839 @@
#include "xdr-nfs3.h"
void
-server_post_stat (server_state_t *state, gfs3_stat_rsp *rsp, struct iatt *stbuf)
-{
- if (state->client->subdir_mount &&
- !gf_uuid_compare (stbuf->ia_gfid,
- state->client->subdir_gfid)) {
- /* This is very important as when we send iatt of
- root-inode, fuse/client expect the gfid to be 1,
- along with inode number. As for subdirectory mount,
- we use inode table which is shared by everyone, but
- make sure we send fops only from subdir and below,
- we have to alter inode gfid and send it to client */
- uuid_t gfid = {0,};
-
- gfid[15] = 1;
- stbuf->ia_ino = 1;
- gf_uuid_copy (stbuf->ia_gfid, gfid);
- }
+server_post_stat(server_state_t *state, gfs3_stat_rsp *rsp, struct iatt *stbuf)
+{
+ if (state->client->subdir_mount &&
+ !gf_uuid_compare(stbuf->ia_gfid, state->client->subdir_gfid)) {
+ /* This is very important as when we send iatt of
+ root-inode, fuse/client expect the gfid to be 1,
+ along with inode number. As for subdirectory mount,
+ we use inode table which is shared by everyone, but
+ make sure we send fops only from subdir and below,
+ we have to alter inode gfid and send it to client */
+ uuid_t gfid = {
+ 0,
+ };
+
+ gfid[15] = 1;
+ stbuf->ia_ino = 1;
+ gf_uuid_copy(stbuf->ia_gfid, gfid);
+ }
- gf_stat_from_iatt (&rsp->stat, stbuf);
+ gf_stat_from_iatt(&rsp->stat, stbuf);
}
void
-server_post_readlink (gfs3_readlink_rsp *rsp, struct iatt *stbuf,
- const char *buf)
+server_post_readlink(gfs3_readlink_rsp *rsp, struct iatt *stbuf,
+ const char *buf)
{
- gf_stat_from_iatt (&rsp->buf, stbuf);
- rsp->path = (char *)buf;
+ gf_stat_from_iatt(&rsp->buf, stbuf);
+ rsp->path = (char *)buf;
}
void
-server_post_mknod (server_state_t *state, gfs3_mknod_rsp *rsp,
- struct iatt *stbuf, struct iatt *preparent,
- struct iatt *postparent, inode_t *inode)
+server_post_mknod(server_state_t *state, gfs3_mknod_rsp *rsp,
+ struct iatt *stbuf, struct iatt *preparent,
+ struct iatt *postparent, inode_t *inode)
{
- inode_t *link_inode = NULL;
+ inode_t *link_inode = NULL;
- gf_stat_from_iatt (&rsp->stat, stbuf);
- gf_stat_from_iatt (&rsp->preparent, preparent);
- gf_stat_from_iatt (&rsp->postparent, postparent);
+ gf_stat_from_iatt(&rsp->stat, stbuf);
+ gf_stat_from_iatt(&rsp->preparent, preparent);
+ gf_stat_from_iatt(&rsp->postparent, postparent);
- link_inode = inode_link (inode, state->loc.parent,
- state->loc.name, stbuf);
- inode_lookup (link_inode);
- inode_unref (link_inode);
+ link_inode = inode_link(inode, state->loc.parent, state->loc.name, stbuf);
+ inode_lookup(link_inode);
+ inode_unref(link_inode);
}
void
-server_post_mkdir (server_state_t *state, gfs3_mkdir_rsp *rsp,
- inode_t *inode,
- struct iatt *stbuf, struct iatt *preparent,
- struct iatt *postparent, dict_t *xdata)
+server_post_mkdir(server_state_t *state, gfs3_mkdir_rsp *rsp, inode_t *inode,
+ struct iatt *stbuf, struct iatt *preparent,
+ struct iatt *postparent, dict_t *xdata)
{
- inode_t *link_inode = NULL;
-
- gf_stat_from_iatt (&rsp->stat, stbuf);
- gf_stat_from_iatt (&rsp->preparent, preparent);
- gf_stat_from_iatt (&rsp->postparent, postparent);
+ inode_t *link_inode = NULL;
- link_inode = inode_link (inode, state->loc.parent,
- state->loc.name, stbuf);
- inode_lookup (link_inode);
- inode_unref (link_inode);
+ gf_stat_from_iatt(&rsp->stat, stbuf);
+ gf_stat_from_iatt(&rsp->preparent, preparent);
+ gf_stat_from_iatt(&rsp->postparent, postparent);
+ link_inode = inode_link(inode, state->loc.parent, state->loc.name, stbuf);
+ inode_lookup(link_inode);
+ inode_unref(link_inode);
}
void
-server_post_unlink (server_state_t *state, gfs3_unlink_rsp *rsp,
- struct iatt *preparent, struct iatt *postparent)
+server_post_unlink(server_state_t *state, gfs3_unlink_rsp *rsp,
+ struct iatt *preparent, struct iatt *postparent)
{
- inode_unlink (state->loc.inode, state->loc.parent,
- state->loc.name);
+ inode_unlink(state->loc.inode, state->loc.parent, state->loc.name);
- forget_inode_if_no_dentry (state->loc.inode);
-
- gf_stat_from_iatt (&rsp->preparent, preparent);
- gf_stat_from_iatt (&rsp->postparent, postparent);
+ forget_inode_if_no_dentry(state->loc.inode);
+ gf_stat_from_iatt(&rsp->preparent, preparent);
+ gf_stat_from_iatt(&rsp->postparent, postparent);
}
void
-server_post_rmdir (server_state_t *state, gfs3_rmdir_rsp *rsp,
- struct iatt *preparent, struct iatt *postparent)
+server_post_rmdir(server_state_t *state, gfs3_rmdir_rsp *rsp,
+ struct iatt *preparent, struct iatt *postparent)
{
- inode_unlink (state->loc.inode, state->loc.parent,
- state->loc.name);
- /* parent should not be found for directories after
- * inode_unlink, since directories cannot have
- * hardlinks.
- */
- forget_inode_if_no_dentry (state->loc.inode);
+ inode_unlink(state->loc.inode, state->loc.parent, state->loc.name);
+ /* parent should not be found for directories after
+ * inode_unlink, since directories cannot have
+ * hardlinks.
+ */
+ forget_inode_if_no_dentry(state->loc.inode);
- gf_stat_from_iatt (&rsp->preparent, preparent);
- gf_stat_from_iatt (&rsp->postparent, postparent);
+ gf_stat_from_iatt(&rsp->preparent, preparent);
+ gf_stat_from_iatt(&rsp->postparent, postparent);
}
void
-server_post_symlink (server_state_t *state, gfs3_symlink_rsp *rsp,
- inode_t *inode,
- struct iatt *stbuf, struct iatt *preparent,
- struct iatt *postparent, dict_t *xdata)
+server_post_symlink(server_state_t *state, gfs3_symlink_rsp *rsp,
+ inode_t *inode, struct iatt *stbuf, struct iatt *preparent,
+ struct iatt *postparent, dict_t *xdata)
{
- inode_t *link_inode = NULL;
-
- gf_stat_from_iatt (&rsp->stat, stbuf);
- gf_stat_from_iatt (&rsp->preparent, preparent);
- gf_stat_from_iatt (&rsp->postparent, postparent);
+ inode_t *link_inode = NULL;
- link_inode = inode_link (inode, state->loc.parent,
- state->loc.name, stbuf);
- inode_lookup (link_inode);
- inode_unref (link_inode);
+ gf_stat_from_iatt(&rsp->stat, stbuf);
+ gf_stat_from_iatt(&rsp->preparent, preparent);
+ gf_stat_from_iatt(&rsp->postparent, postparent);
+ link_inode = inode_link(inode, state->loc.parent, state->loc.name, stbuf);
+ inode_lookup(link_inode);
+ inode_unref(link_inode);
}
void
-server_post_link (server_state_t *state, gfs3_link_rsp *rsp,
- inode_t *inode,
- struct iatt *stbuf, struct iatt *preparent,
- struct iatt *postparent, dict_t *xdata)
+server_post_link(server_state_t *state, gfs3_link_rsp *rsp, inode_t *inode,
+ struct iatt *stbuf, struct iatt *preparent,
+ struct iatt *postparent, dict_t *xdata)
{
- inode_t *link_inode = NULL;
-
- gf_stat_from_iatt (&rsp->stat, stbuf);
- gf_stat_from_iatt (&rsp->preparent, preparent);
- gf_stat_from_iatt (&rsp->postparent, postparent);
+ inode_t *link_inode = NULL;
- link_inode = inode_link (inode, state->loc2.parent,
- state->loc2.name, stbuf);
- inode_lookup (link_inode);
- inode_unref (link_inode);
+ gf_stat_from_iatt(&rsp->stat, stbuf);
+ gf_stat_from_iatt(&rsp->preparent, preparent);
+ gf_stat_from_iatt(&rsp->postparent, postparent);
+ link_inode = inode_link(inode, state->loc2.parent, state->loc2.name, stbuf);
+ inode_lookup(link_inode);
+ inode_unref(link_inode);
}
void
-server_post_truncate (gfs3_truncate_rsp *rsp, struct iatt *prebuf,
- struct iatt *postbuf)
+server_post_truncate(gfs3_truncate_rsp *rsp, struct iatt *prebuf,
+ struct iatt *postbuf)
{
- gf_stat_from_iatt (&rsp->prestat, prebuf);
- gf_stat_from_iatt (&rsp->poststat, postbuf);
+ gf_stat_from_iatt(&rsp->prestat, prebuf);
+ gf_stat_from_iatt(&rsp->poststat, postbuf);
}
void
-server_post_writev (gfs3_write_rsp *rsp, struct iatt *prebuf,
- struct iatt *postbuf)
+server_post_writev(gfs3_write_rsp *rsp, struct iatt *prebuf,
+ struct iatt *postbuf)
{
- gf_stat_from_iatt (&rsp->prestat, prebuf);
- gf_stat_from_iatt (&rsp->poststat, postbuf);
+ gf_stat_from_iatt(&rsp->prestat, prebuf);
+ gf_stat_from_iatt(&rsp->poststat, postbuf);
}
void
-server_post_statfs (gfs3_statfs_rsp *rsp, struct statvfs *stbuf)
+server_post_statfs(gfs3_statfs_rsp *rsp, struct statvfs *stbuf)
{
- gf_statfs_from_statfs (&rsp->statfs, stbuf);
+ gf_statfs_from_statfs(&rsp->statfs, stbuf);
}
void
-server_post_fsync (gfs3_fsync_rsp *rsp, struct iatt *prebuf,
- struct iatt *postbuf)
+server_post_fsync(gfs3_fsync_rsp *rsp, struct iatt *prebuf,
+ struct iatt *postbuf)
{
- gf_stat_from_iatt (&rsp->prestat, prebuf);
- gf_stat_from_iatt (&rsp->poststat, postbuf);
+ gf_stat_from_iatt(&rsp->prestat, prebuf);
+ gf_stat_from_iatt(&rsp->poststat, postbuf);
}
void
-server_post_ftruncate (gfs3_ftruncate_rsp *rsp, struct iatt *prebuf,
+server_post_ftruncate(gfs3_ftruncate_rsp *rsp, struct iatt *prebuf,
struct iatt *postbuf)
{
- gf_stat_from_iatt (&rsp->prestat, prebuf);
- gf_stat_from_iatt (&rsp->poststat, postbuf);
+ gf_stat_from_iatt(&rsp->prestat, prebuf);
+ gf_stat_from_iatt(&rsp->poststat, postbuf);
}
void
-server_post_fstat (server_state_t *state, gfs3_fstat_rsp *rsp,
- struct iatt *stbuf)
+server_post_fstat(server_state_t *state, gfs3_fstat_rsp *rsp,
+ struct iatt *stbuf)
{
- if (state->client->subdir_mount &&
- !gf_uuid_compare (stbuf->ia_gfid,
- state->client->subdir_gfid)) {
- /* This is very important as when we send iatt of
- root-inode, fuse/client expect the gfid to be 1,
- along with inode number. As for subdirectory mount,
- we use inode table which is shared by everyone, but
- make sure we send fops only from subdir and below,
- we have to alter inode gfid and send it to client */
- uuid_t gfid = {0,};
+ if (state->client->subdir_mount &&
+ !gf_uuid_compare(stbuf->ia_gfid, state->client->subdir_gfid)) {
+ /* This is very important as when we send iatt of
+ root-inode, fuse/client expect the gfid to be 1,
+ along with inode number. As for subdirectory mount,
+ we use inode table which is shared by everyone, but
+ make sure we send fops only from subdir and below,
+ we have to alter inode gfid and send it to client */
+ uuid_t gfid = {
+ 0,
+ };
- gfid[15] = 1;
- stbuf->ia_ino = 1;
- gf_uuid_copy (stbuf->ia_gfid, gfid);
- }
+ gfid[15] = 1;
+ stbuf->ia_ino = 1;
+ gf_uuid_copy(stbuf->ia_gfid, gfid);
+ }
- gf_stat_from_iatt (&rsp->stat, stbuf);
+ gf_stat_from_iatt(&rsp->stat, stbuf);
}
void
-server_post_lk (xlator_t *this, gfs3_lk_rsp *rsp, struct gf_flock *lock)
+server_post_lk(xlator_t *this, gfs3_lk_rsp *rsp, struct gf_flock *lock)
{
- switch (lock->l_type) {
+ switch (lock->l_type) {
case F_RDLCK:
- lock->l_type = GF_LK_F_RDLCK;
- break;
+ lock->l_type = GF_LK_F_RDLCK;
+ break;
case F_WRLCK:
- lock->l_type = GF_LK_F_WRLCK;
- break;
+ lock->l_type = GF_LK_F_WRLCK;
+ break;
case F_UNLCK:
- lock->l_type = GF_LK_F_UNLCK;
- break;
+ lock->l_type = GF_LK_F_UNLCK;
+ break;
default:
- gf_msg (this->name, GF_LOG_ERROR, 0, PS_MSG_LOCK_ERROR,
- "Unknown lock type: %"PRId32"!", lock->l_type);
- break;
- }
+ gf_msg(this->name, GF_LOG_ERROR, 0, PS_MSG_LOCK_ERROR,
+ "Unknown lock type: %" PRId32 "!", lock->l_type);
+ break;
+ }
- gf_proto_flock_from_flock (&rsp->flock, lock);
+ gf_proto_flock_from_flock(&rsp->flock, lock);
}
int
-server_post_readdir (gfs3_readdir_rsp *rsp, gf_dirent_t *entries)
+server_post_readdir(gfs3_readdir_rsp *rsp, gf_dirent_t *entries)
{
- int ret = 0;
+ int ret = 0;
- ret = serialize_rsp_dirent (entries, rsp);
+ ret = serialize_rsp_dirent(entries, rsp);
- return ret;
+ return ret;
}
void
-server_post_zerofill (gfs3_zerofill_rsp *rsp, struct iatt *statpre,
- struct iatt *statpost)
+server_post_zerofill(gfs3_zerofill_rsp *rsp, struct iatt *statpre,
+ struct iatt *statpost)
{
- gf_stat_from_iatt (&rsp->statpre, statpre);
- gf_stat_from_iatt (&rsp->statpost, statpost);
+ gf_stat_from_iatt(&rsp->statpre, statpre);
+ gf_stat_from_iatt(&rsp->statpost, statpost);
}
void
-server_post_discard (gfs3_discard_rsp *rsp, struct iatt *statpre,
- struct iatt *statpost)
+server_post_discard(gfs3_discard_rsp *rsp, struct iatt *statpre,
+ struct iatt *statpost)
{
- gf_stat_from_iatt (&rsp->statpre, statpre);
- gf_stat_from_iatt (&rsp->statpost, statpost);
+ gf_stat_from_iatt(&rsp->statpre, statpre);
+ gf_stat_from_iatt(&rsp->statpost, statpost);
}
void
-server_post_fallocate (gfs3_fallocate_rsp *rsp, struct iatt *statpre,
- struct iatt *statpost)
+server_post_fallocate(gfs3_fallocate_rsp *rsp, struct iatt *statpre,
+ struct iatt *statpost)
{
- gf_stat_from_iatt (&rsp->statpre, statpre);
- gf_stat_from_iatt (&rsp->statpost, statpost);
+ gf_stat_from_iatt(&rsp->statpre, statpre);
+ gf_stat_from_iatt(&rsp->statpost, statpost);
}
void
-server_post_seek (gfs3_seek_rsp *rsp, off_t offset)
+server_post_seek(gfs3_seek_rsp *rsp, off_t offset)
{
- rsp->offset = offset;
+ rsp->offset = offset;
}
int
-server_post_readdirp (gfs3_readdirp_rsp *rsp, gf_dirent_t *entries)
+server_post_readdirp(gfs3_readdirp_rsp *rsp, gf_dirent_t *entries)
{
- int ret = 0;
+ int ret = 0;
- ret = serialize_rsp_direntp (entries, rsp);
+ ret = serialize_rsp_direntp(entries, rsp);
- return ret;
+ return ret;
}
void
-server_post_fsetattr (gfs3_fsetattr_rsp *rsp, struct iatt *statpre,
- struct iatt *statpost)
+server_post_fsetattr(gfs3_fsetattr_rsp *rsp, struct iatt *statpre,
+ struct iatt *statpost)
{
- gf_stat_from_iatt (&rsp->statpre, statpre);
- gf_stat_from_iatt (&rsp->statpost, statpost);
+ gf_stat_from_iatt(&rsp->statpre, statpre);
+ gf_stat_from_iatt(&rsp->statpost, statpost);
}
void
-server_post_setattr (gfs3_setattr_rsp *rsp, struct iatt *statpre,
- struct iatt *statpost)
+server_post_setattr(gfs3_setattr_rsp *rsp, struct iatt *statpre,
+ struct iatt *statpost)
{
- gf_stat_from_iatt (&rsp->statpre, statpre);
- gf_stat_from_iatt (&rsp->statpost, statpost);
+ gf_stat_from_iatt(&rsp->statpre, statpre);
+ gf_stat_from_iatt(&rsp->statpost, statpost);
}
void
-server_post_rchecksum (gfs3_rchecksum_rsp *rsp, uint32_t weak_checksum,
- uint8_t *strong_checksum)
+server_post_rchecksum(gfs3_rchecksum_rsp *rsp, uint32_t weak_checksum,
+ uint8_t *strong_checksum)
{
- rsp->weak_checksum = weak_checksum;
-
- rsp->strong_checksum.strong_checksum_val = (char *)strong_checksum;
- rsp->strong_checksum.strong_checksum_len = MD5_DIGEST_LENGTH;
+ rsp->weak_checksum = weak_checksum;
+ rsp->strong_checksum.strong_checksum_val = (char *)strong_checksum;
+ rsp->strong_checksum.strong_checksum_len = MD5_DIGEST_LENGTH;
}
void
-server_post_rename (call_frame_t *frame,
- server_state_t *state, gfs3_rename_rsp *rsp,
- struct iatt *stbuf,
- struct iatt *preoldparent,
- struct iatt *postoldparent,
- struct iatt *prenewparent,
- struct iatt *postnewparent)
+server_post_rename(call_frame_t *frame, server_state_t *state,
+ gfs3_rename_rsp *rsp, struct iatt *stbuf,
+ struct iatt *preoldparent, struct iatt *postoldparent,
+ struct iatt *prenewparent, struct iatt *postnewparent)
{
- inode_t *tmp_inode = NULL;
+ inode_t *tmp_inode = NULL;
- stbuf->ia_type = state->loc.inode->ia_type;
+ stbuf->ia_type = state->loc.inode->ia_type;
- /* TODO: log gfid of the inodes */
- gf_msg_trace (frame->root->client->bound_xl->name, 0, "%"PRId64": "
- "RENAME_CBK %s ==> %s", frame->root->unique,
- state->loc.name, state->loc2.name);
-
- /* Before renaming the inode, we have to get the inode for the
- * destination entry (i.e. inode with state->loc2.parent as
- * parent and state->loc2.name as name). If it exists, then
- * unlink that inode, and send forget on that inode if the
- * unlinked entry is the last entry. In case of fuse client
- * the fuse kernel module itself sends the forget on the
- * unlinked inode.
- */
- tmp_inode = inode_grep (state->loc.inode->table,
- state->loc2.parent, state->loc2.name);
- if (tmp_inode) {
- inode_unlink (tmp_inode, state->loc2.parent,
- state->loc2.name);
- forget_inode_if_no_dentry (tmp_inode);
- inode_unref (tmp_inode);
- }
+ /* TODO: log gfid of the inodes */
+ gf_msg_trace(frame->root->client->bound_xl->name, 0,
+ "%" PRId64
+ ": "
+ "RENAME_CBK %s ==> %s",
+ frame->root->unique, state->loc.name, state->loc2.name);
- inode_rename (state->itable,
- state->loc.parent, state->loc.name,
- state->loc2.parent, state->loc2.name,
- state->loc.inode, stbuf);
- gf_stat_from_iatt (&rsp->stat, stbuf);
+ /* Before renaming the inode, we have to get the inode for the
+ * destination entry (i.e. inode with state->loc2.parent as
+ * parent and state->loc2.name as name). If it exists, then
+ * unlink that inode, and send forget on that inode if the
+ * unlinked entry is the last entry. In case of fuse client
+ * the fuse kernel module itself sends the forget on the
+ * unlinked inode.
+ */
+ tmp_inode = inode_grep(state->loc.inode->table, state->loc2.parent,
+ state->loc2.name);
+ if (tmp_inode) {
+ inode_unlink(tmp_inode, state->loc2.parent, state->loc2.name);
+ forget_inode_if_no_dentry(tmp_inode);
+ inode_unref(tmp_inode);
+ }
- gf_stat_from_iatt (&rsp->preoldparent, preoldparent);
- gf_stat_from_iatt (&rsp->postoldparent, postoldparent);
+ inode_rename(state->itable, state->loc.parent, state->loc.name,
+ state->loc2.parent, state->loc2.name, state->loc.inode, stbuf);
+ gf_stat_from_iatt(&rsp->stat, stbuf);
- gf_stat_from_iatt (&rsp->prenewparent, prenewparent);
- gf_stat_from_iatt (&rsp->postnewparent, postnewparent);
+ gf_stat_from_iatt(&rsp->preoldparent, preoldparent);
+ gf_stat_from_iatt(&rsp->postoldparent, postoldparent);
+ gf_stat_from_iatt(&rsp->prenewparent, prenewparent);
+ gf_stat_from_iatt(&rsp->postnewparent, postnewparent);
}
int
-server_post_open (call_frame_t *frame, xlator_t *this,
- gfs3_open_rsp *rsp, fd_t *fd)
-{
- server_ctx_t *serv_ctx = NULL;
- uint64_t fd_no = 0;
-
- serv_ctx = server_ctx_get (frame->root->client, this);
- if (serv_ctx == NULL) {
- gf_msg (this->name, GF_LOG_INFO, 0,
- PS_MSG_SERVER_CTX_GET_FAILED, "server_ctx_get() "
- "failed");
- return -1;
- }
+server_post_open(call_frame_t *frame, xlator_t *this, gfs3_open_rsp *rsp,
+ fd_t *fd)
+{
+ server_ctx_t *serv_ctx = NULL;
+ uint64_t fd_no = 0;
+
+ serv_ctx = server_ctx_get(frame->root->client, this);
+ if (serv_ctx == NULL) {
+ gf_msg(this->name, GF_LOG_INFO, 0, PS_MSG_SERVER_CTX_GET_FAILED,
+ "server_ctx_get() "
+ "failed");
+ return -1;
+ }
- fd_bind (fd);
- fd_ref (fd);
- fd_no = gf_fd_unused_get (serv_ctx->fdtable, fd);
- rsp->fd = fd_no;
+ fd_bind(fd);
+ fd_ref(fd);
+ fd_no = gf_fd_unused_get(serv_ctx->fdtable, fd);
+ rsp->fd = fd_no;
- return 0;
+ return 0;
}
void
-server_post_readv (gfs3_read_rsp *rsp, struct iatt *stbuf, int op_ret)
+server_post_readv(gfs3_read_rsp *rsp, struct iatt *stbuf, int op_ret)
{
- gf_stat_from_iatt (&rsp->stat, stbuf);
- rsp->size = op_ret;
+ gf_stat_from_iatt(&rsp->stat, stbuf);
+ rsp->size = op_ret;
}
int
-server_post_opendir (call_frame_t *frame, xlator_t *this,
- gfs3_opendir_rsp *rsp, fd_t *fd)
-{
- server_ctx_t *serv_ctx = NULL;
- uint64_t fd_no = 0;
-
- serv_ctx = server_ctx_get (frame->root->client, this);
- if (serv_ctx == NULL) {
- gf_msg (this->name, GF_LOG_INFO, 0,
- PS_MSG_SERVER_CTX_GET_FAILED, "server_ctx_get() "
- "failed");
- return -1;
- }
-
- fd_bind (fd);
- fd_ref (fd);
- fd_no = gf_fd_unused_get (serv_ctx->fdtable, fd);
- rsp->fd = fd_no;
-
- return 0;
-}
-
-int
-server_post_create (call_frame_t *frame, gfs3_create_rsp *rsp,
- server_state_t *state,
- xlator_t *this, fd_t *fd, inode_t *inode,
- struct iatt *stbuf, struct iatt *preparent,
- struct iatt *postparent)
+server_post_opendir(call_frame_t *frame, xlator_t *this, gfs3_opendir_rsp *rsp,
+ fd_t *fd)
{
- server_ctx_t *serv_ctx = NULL;
- inode_t *link_inode = NULL;
- uint64_t fd_no = 0;
- int op_errno = 0;
+ server_ctx_t *serv_ctx = NULL;
+ uint64_t fd_no = 0;
- link_inode = inode_link (inode, state->loc.parent,
- state->loc.name, stbuf);
+ serv_ctx = server_ctx_get(frame->root->client, this);
+ if (serv_ctx == NULL) {
+ gf_msg(this->name, GF_LOG_INFO, 0, PS_MSG_SERVER_CTX_GET_FAILED,
+ "server_ctx_get() "
+ "failed");
+ return -1;
+ }
- if (!link_inode) {
- op_errno = ENOENT;
- goto out;
- }
-
- if (link_inode != inode) {
- /*
- VERY racy code (if used anywhere else)
- -- don't do this without understanding
- */
-
- inode_ctx_merge (fd, fd->inode, link_inode);
- inode_unref (fd->inode);
- fd->inode = inode_ref (link_inode);
- }
+ fd_bind(fd);
+ fd_ref(fd);
+ fd_no = gf_fd_unused_get(serv_ctx->fdtable, fd);
+ rsp->fd = fd_no;
- inode_lookup (link_inode);
- inode_unref (link_inode);
-
- serv_ctx = server_ctx_get (frame->root->client, this);
- if (serv_ctx == NULL) {
- gf_msg (this->name, GF_LOG_INFO, 0,
- PS_MSG_SERVER_CTX_GET_FAILED, "server_ctx_get() "
- "failed");
- goto out;
- }
-
- fd_bind (fd);
- fd_ref (fd);
- fd_no = gf_fd_unused_get (serv_ctx->fdtable, fd);
-
- if ((fd_no > UINT64_MAX) || (fd == 0)) {
- op_errno = errno;
- }
-
- rsp->fd = fd_no;
- gf_stat_from_iatt (&rsp->stat, stbuf);
- gf_stat_from_iatt (&rsp->preparent, preparent);
- gf_stat_from_iatt (&rsp->postparent, postparent);
+ return 0;
+}
- return 0;
+int
+server_post_create(call_frame_t *frame, gfs3_create_rsp *rsp,
+ server_state_t *state, xlator_t *this, fd_t *fd,
+ inode_t *inode, struct iatt *stbuf, struct iatt *preparent,
+ struct iatt *postparent)
+{
+ server_ctx_t *serv_ctx = NULL;
+ inode_t *link_inode = NULL;
+ uint64_t fd_no = 0;
+ int op_errno = 0;
+
+ link_inode = inode_link(inode, state->loc.parent, state->loc.name, stbuf);
+
+ if (!link_inode) {
+ op_errno = ENOENT;
+ goto out;
+ }
+
+ if (link_inode != inode) {
+ /*
+ VERY racy code (if used anywhere else)
+ -- don't do this without understanding
+ */
+
+ inode_ctx_merge(fd, fd->inode, link_inode);
+ inode_unref(fd->inode);
+ fd->inode = inode_ref(link_inode);
+ }
+
+ inode_lookup(link_inode);
+ inode_unref(link_inode);
+
+ serv_ctx = server_ctx_get(frame->root->client, this);
+ if (serv_ctx == NULL) {
+ gf_msg(this->name, GF_LOG_INFO, 0, PS_MSG_SERVER_CTX_GET_FAILED,
+ "server_ctx_get() "
+ "failed");
+ goto out;
+ }
+
+ fd_bind(fd);
+ fd_ref(fd);
+ fd_no = gf_fd_unused_get(serv_ctx->fdtable, fd);
+
+ if ((fd_no > UINT64_MAX) || (fd == 0)) {
+ op_errno = errno;
+ }
+
+ rsp->fd = fd_no;
+ gf_stat_from_iatt(&rsp->stat, stbuf);
+ gf_stat_from_iatt(&rsp->preparent, preparent);
+ gf_stat_from_iatt(&rsp->postparent, postparent);
+
+ return 0;
out:
- return -op_errno;
+ return -op_errno;
}
/*TODO: Handle revalidate path */
void
-server_post_lookup (gfs3_lookup_rsp *rsp, call_frame_t *frame,
- server_state_t *state,
- inode_t *inode, struct iatt *stbuf,
- struct iatt *postparent)
+server_post_lookup(gfs3_lookup_rsp *rsp, call_frame_t *frame,
+ server_state_t *state, inode_t *inode, struct iatt *stbuf,
+ struct iatt *postparent)
{
- inode_t *root_inode = NULL;
- inode_t *link_inode = NULL;
- uuid_t rootgfid = {0,};
+ inode_t *root_inode = NULL;
+ inode_t *link_inode = NULL;
+ uuid_t rootgfid = {
+ 0,
+ };
- root_inode = frame->root->client->bound_xl->itable->root;
+ root_inode = frame->root->client->bound_xl->itable->root;
- if (!__is_root_gfid (inode->gfid)) {
- link_inode = inode_link (inode, state->loc.parent,
- state->loc.name, stbuf);
- if (link_inode) {
- inode_lookup (link_inode);
- inode_unref (link_inode);
- }
+ if (!__is_root_gfid(inode->gfid)) {
+ link_inode = inode_link(inode, state->loc.parent, state->loc.name,
+ stbuf);
+ if (link_inode) {
+ inode_lookup(link_inode);
+ inode_unref(link_inode);
}
+ }
- if ((inode == root_inode) ||
- (state->client->subdir_mount &&
- (inode == state->client->subdir_inode))) {
- /* we just looked up root ("/") OR
- subdir mount directory, which is root ('/') in client */
- /* This is very important as when we send iatt of
- root-inode, fuse/client expect the gfid to be 1,
- along with inode number. As for subdirectory mount,
- we use inode table which is shared by everyone, but
- make sure we send fops only from subdir and below,
- we have to alter inode gfid and send it to client */
- stbuf->ia_ino = 1;
- rootgfid[15] = 1;
- gf_uuid_copy (stbuf->ia_gfid, rootgfid);
- if (inode->ia_type == 0)
- inode->ia_type = stbuf->ia_type;
- }
+ if ((inode == root_inode) || (state->client->subdir_mount &&
+ (inode == state->client->subdir_inode))) {
+ /* we just looked up root ("/") OR
+ subdir mount directory, which is root ('/') in client */
+ /* This is very important as when we send iatt of
+ root-inode, fuse/client expect the gfid to be 1,
+ along with inode number. As for subdirectory mount,
+ we use inode table which is shared by everyone, but
+ make sure we send fops only from subdir and below,
+ we have to alter inode gfid and send it to client */
+ stbuf->ia_ino = 1;
+ rootgfid[15] = 1;
+ gf_uuid_copy(stbuf->ia_gfid, rootgfid);
+ if (inode->ia_type == 0)
+ inode->ia_type = stbuf->ia_type;
+ }
- gf_stat_from_iatt (&rsp->stat, stbuf);
+ gf_stat_from_iatt(&rsp->stat, stbuf);
}
void
-server_post_lease (gfs3_lease_rsp *rsp, struct gf_lease *lease)
+server_post_lease(gfs3_lease_rsp *rsp, struct gf_lease *lease)
{
- gf_proto_lease_from_lease (&rsp->lease, lease);
+ gf_proto_lease_from_lease(&rsp->lease, lease);
}
-
/* Version 4 helpers */
void
-server4_post_readlink (gfx_readlink_rsp *rsp, struct iatt *stbuf,
+server4_post_readlink(gfx_readlink_rsp *rsp, struct iatt *stbuf,
const char *buf)
{
- gfx_stat_from_iattx (&rsp->buf, stbuf);
- rsp->path = (char *)buf;
+ gfx_stat_from_iattx(&rsp->buf, stbuf);
+ rsp->path = (char *)buf;
}
void
-server4_post_common_3iatt (server_state_t *state, gfx_common_3iatt_rsp *rsp,
- inode_t *inode, struct iatt *stbuf,
- struct iatt *preparent, struct iatt *postparent)
+server4_post_common_3iatt(server_state_t *state, gfx_common_3iatt_rsp *rsp,
+ inode_t *inode, struct iatt *stbuf,
+ struct iatt *preparent, struct iatt *postparent)
{
- inode_t *link_inode = NULL;
+ inode_t *link_inode = NULL;
- gfx_stat_from_iattx (&rsp->stat, stbuf);
- if (state->client->subdir_mount &&
- !gf_uuid_compare (preparent->ia_gfid,
- state->client->subdir_gfid)) {
- /* This is very important as when we send iatt of
- root-inode, fuse/client expect the gfid to be 1,
- along with inode number. As for subdirectory mount,
- we use inode table which is shared by everyone, but
- make sure we send fops only from subdir and below,
- we have to alter inode gfid and send it to client */
- uuid_t gfid = {0,};
+ gfx_stat_from_iattx(&rsp->stat, stbuf);
+ if (state->client->subdir_mount &&
+ !gf_uuid_compare(preparent->ia_gfid, state->client->subdir_gfid)) {
+ /* This is very important as when we send iatt of
+ root-inode, fuse/client expect the gfid to be 1,
+ along with inode number. As for subdirectory mount,
+ we use inode table which is shared by everyone, but
+ make sure we send fops only from subdir and below,
+ we have to alter inode gfid and send it to client */
+ uuid_t gfid = {
+ 0,
+ };
- gfid[15] = 1;
- preparent->ia_ino = 1;
- postparent->ia_ino = 1;
- gf_uuid_copy (preparent->ia_gfid, gfid);
- gf_uuid_copy (postparent->ia_gfid, gfid);
- }
+ gfid[15] = 1;
+ preparent->ia_ino = 1;
+ postparent->ia_ino = 1;
+ gf_uuid_copy(preparent->ia_gfid, gfid);
+ gf_uuid_copy(postparent->ia_gfid, gfid);
+ }
- gfx_stat_from_iattx (&rsp->preparent, preparent);
- gfx_stat_from_iattx (&rsp->postparent, postparent);
+ gfx_stat_from_iattx(&rsp->preparent, preparent);
+ gfx_stat_from_iattx(&rsp->postparent, postparent);
- link_inode = inode_link (inode, state->loc.parent,
- state->loc.name, stbuf);
- inode_lookup (link_inode);
- inode_unref (link_inode);
+ link_inode = inode_link(inode, state->loc.parent, state->loc.name, stbuf);
+ inode_lookup(link_inode);
+ inode_unref(link_inode);
}
void
-server4_post_common_2iatt (gfx_common_2iatt_rsp *rsp, struct iatt *prebuf,
- struct iatt *postbuf)
+server4_post_common_2iatt(gfx_common_2iatt_rsp *rsp, struct iatt *prebuf,
+ struct iatt *postbuf)
{
- gfx_stat_from_iattx (&rsp->prestat, prebuf);
- gfx_stat_from_iattx (&rsp->poststat, postbuf);
+ gfx_stat_from_iattx(&rsp->prestat, prebuf);
+ gfx_stat_from_iattx(&rsp->poststat, postbuf);
}
void
-server4_post_entry_remove (server_state_t *state, gfx_common_2iatt_rsp *rsp,
- struct iatt *prebuf, struct iatt *postbuf)
+server4_post_entry_remove(server_state_t *state, gfx_common_2iatt_rsp *rsp,
+ struct iatt *prebuf, struct iatt *postbuf)
{
- inode_unlink (state->loc.inode, state->loc.parent,
- state->loc.name);
- /* parent should not be found for directories after
- * inode_unlink, since directories cannot have
- * hardlinks.
- */
- forget_inode_if_no_dentry (state->loc.inode);
+ inode_unlink(state->loc.inode, state->loc.parent, state->loc.name);
+ /* parent should not be found for directories after
+ * inode_unlink, since directories cannot have
+ * hardlinks.
+ */
+ forget_inode_if_no_dentry(state->loc.inode);
- gfx_stat_from_iattx (&rsp->prestat, prebuf);
- gfx_stat_from_iattx (&rsp->poststat, postbuf);
+ gfx_stat_from_iattx(&rsp->prestat, prebuf);
+ gfx_stat_from_iattx(&rsp->poststat, postbuf);
}
-
void
-server4_post_statfs (gfx_statfs_rsp *rsp, struct statvfs *stbuf)
+server4_post_statfs(gfx_statfs_rsp *rsp, struct statvfs *stbuf)
{
- gf_statfs_from_statfs (&rsp->statfs, stbuf);
+ gf_statfs_from_statfs(&rsp->statfs, stbuf);
}
void
-server4_post_common_iatt (server_state_t *state, gfx_common_iatt_rsp *rsp,
- struct iatt *stbuf)
+server4_post_common_iatt(server_state_t *state, gfx_common_iatt_rsp *rsp,
+ struct iatt *stbuf)
{
- if (state->client->subdir_mount &&
- !gf_uuid_compare (stbuf->ia_gfid,
- state->client->subdir_gfid)) {
- /* This is very important as when we send iatt of
- root-inode, fuse/client expect the gfid to be 1,
- along with inode number. As for subdirectory mount,
- we use inode table which is shared by everyone, but
- make sure we send fops only from subdir and below,
- we have to alter inode gfid and send it to client */
- uuid_t gfid = {0,};
+ if (state->client->subdir_mount &&
+ !gf_uuid_compare(stbuf->ia_gfid, state->client->subdir_gfid)) {
+ /* This is very important as when we send iatt of
+ root-inode, fuse/client expect the gfid to be 1,
+ along with inode number. As for subdirectory mount,
+ we use inode table which is shared by everyone, but
+ make sure we send fops only from subdir and below,
+ we have to alter inode gfid and send it to client */
+ uuid_t gfid = {
+ 0,
+ };
- gfid[15] = 1;
- stbuf->ia_ino = 1;
- gf_uuid_copy (stbuf->ia_gfid, gfid);
- }
+ gfid[15] = 1;
+ stbuf->ia_ino = 1;
+ gf_uuid_copy(stbuf->ia_gfid, gfid);
+ }
- gfx_stat_from_iattx (&rsp->stat, stbuf);
+ gfx_stat_from_iattx(&rsp->stat, stbuf);
}
void
-server4_post_lk (xlator_t *this, gfx_lk_rsp *rsp, struct gf_flock *lock)
+server4_post_lk(xlator_t *this, gfx_lk_rsp *rsp, struct gf_flock *lock)
{
- switch (lock->l_type) {
+ switch (lock->l_type) {
case F_RDLCK:
- lock->l_type = GF_LK_F_RDLCK;
- break;
+ lock->l_type = GF_LK_F_RDLCK;
+ break;
case F_WRLCK:
- lock->l_type = GF_LK_F_WRLCK;
- break;
+ lock->l_type = GF_LK_F_WRLCK;
+ break;
case F_UNLCK:
- lock->l_type = GF_LK_F_UNLCK;
- break;
+ lock->l_type = GF_LK_F_UNLCK;
+ break;
default:
- gf_msg (this->name, GF_LOG_ERROR, 0, PS_MSG_LOCK_ERROR,
- "Unknown lock type: %"PRId32"!", lock->l_type);
- break;
- }
+ gf_msg(this->name, GF_LOG_ERROR, 0, PS_MSG_LOCK_ERROR,
+ "Unknown lock type: %" PRId32 "!", lock->l_type);
+ break;
+ }
- gf_proto_flock_from_flock (&rsp->flock, lock);
+ gf_proto_flock_from_flock(&rsp->flock, lock);
}
int
-server4_post_readdir (gfx_readdir_rsp *rsp, gf_dirent_t *entries)
+server4_post_readdir(gfx_readdir_rsp *rsp, gf_dirent_t *entries)
{
- int ret = 0;
+ int ret = 0;
- ret = serialize_rsp_dirent_v2 (entries, rsp);
+ ret = serialize_rsp_dirent_v2(entries, rsp);
- return ret;
+ return ret;
}
void
-server4_post_seek (gfx_seek_rsp *rsp, off_t offset)
+server4_post_seek(gfx_seek_rsp *rsp, off_t offset)
{
- rsp->offset = offset;
+ rsp->offset = offset;
}
int
-server4_post_readdirp (gfx_readdirp_rsp *rsp, gf_dirent_t *entries)
+server4_post_readdirp(gfx_readdirp_rsp *rsp, gf_dirent_t *entries)
{
- int ret = 0;
+ int ret = 0;
- ret = serialize_rsp_direntp_v2 (entries, rsp);
+ ret = serialize_rsp_direntp_v2(entries, rsp);
- return ret;
+ return ret;
}
void
-server4_post_rchecksum (gfx_rchecksum_rsp *rsp, uint32_t weak_checksum,
+server4_post_rchecksum(gfx_rchecksum_rsp *rsp, uint32_t weak_checksum,
uint8_t *strong_checksum)
{
- rsp->weak_checksum = weak_checksum;
-
- rsp->strong_checksum.strong_checksum_val = (char *)strong_checksum;
- rsp->strong_checksum.strong_checksum_len = SHA256_DIGEST_LENGTH;
- rsp->flags = 1; /* Indicates SHA256 TYPE */
+ rsp->weak_checksum = weak_checksum;
+ rsp->strong_checksum.strong_checksum_val = (char *)strong_checksum;
+ rsp->strong_checksum.strong_checksum_len = SHA256_DIGEST_LENGTH;
+ rsp->flags = 1; /* Indicates SHA256 TYPE */
}
void
-server4_post_rename (call_frame_t *frame,
- server_state_t *state, gfx_rename_rsp *rsp,
- struct iatt *stbuf,
- struct iatt *preoldparent,
- struct iatt *postoldparent,
- struct iatt *prenewparent,
- struct iatt *postnewparent)
+server4_post_rename(call_frame_t *frame, server_state_t *state,
+ gfx_rename_rsp *rsp, struct iatt *stbuf,
+ struct iatt *preoldparent, struct iatt *postoldparent,
+ struct iatt *prenewparent, struct iatt *postnewparent)
{
- inode_t *tmp_inode = NULL;
-
- stbuf->ia_type = state->loc.inode->ia_type;
+ inode_t *tmp_inode = NULL;
- /* TODO: log gfid of the inodes */
- gf_msg_trace (frame->root->client->bound_xl->name, 0, "%"PRId64": "
- "RENAME_CBK %s ==> %s", frame->root->unique,
- state->loc.name, state->loc2.name);
+ stbuf->ia_type = state->loc.inode->ia_type;
- /* Before renaming the inode, we have to get the inode for the
- * destination entry (i.e. inode with state->loc2.parent as
- * parent and state->loc2.name as name). If it exists, then
- * unlink that inode, and send forget on that inode if the
- * unlinked entry is the last entry. In case of fuse client
- * the fuse kernel module itself sends the forget on the
- * unlinked inode.
- */
- tmp_inode = inode_grep (state->loc.inode->table,
- state->loc2.parent, state->loc2.name);
- if (tmp_inode) {
- inode_unlink (tmp_inode, state->loc2.parent,
- state->loc2.name);
- forget_inode_if_no_dentry (tmp_inode);
- inode_unref (tmp_inode);
- }
+ /* TODO: log gfid of the inodes */
+ gf_msg_trace(frame->root->client->bound_xl->name, 0,
+ "%" PRId64
+ ": "
+ "RENAME_CBK %s ==> %s",
+ frame->root->unique, state->loc.name, state->loc2.name);
- inode_rename (state->itable,
- state->loc.parent, state->loc.name,
- state->loc2.parent, state->loc2.name,
- state->loc.inode, stbuf);
- gfx_stat_from_iattx (&rsp->stat, stbuf);
+ /* Before renaming the inode, we have to get the inode for the
+ * destination entry (i.e. inode with state->loc2.parent as
+ * parent and state->loc2.name as name). If it exists, then
+ * unlink that inode, and send forget on that inode if the
+ * unlinked entry is the last entry. In case of fuse client
+ * the fuse kernel module itself sends the forget on the
+ * unlinked inode.
+ */
+ tmp_inode = inode_grep(state->loc.inode->table, state->loc2.parent,
+ state->loc2.name);
+ if (tmp_inode) {
+ inode_unlink(tmp_inode, state->loc2.parent, state->loc2.name);
+ forget_inode_if_no_dentry(tmp_inode);
+ inode_unref(tmp_inode);
+ }
- gfx_stat_from_iattx (&rsp->preoldparent, preoldparent);
- gfx_stat_from_iattx (&rsp->postoldparent, postoldparent);
+ inode_rename(state->itable, state->loc.parent, state->loc.name,
+ state->loc2.parent, state->loc2.name, state->loc.inode, stbuf);
+ gfx_stat_from_iattx(&rsp->stat, stbuf);
- gfx_stat_from_iattx (&rsp->prenewparent, prenewparent);
- gfx_stat_from_iattx (&rsp->postnewparent, postnewparent);
+ gfx_stat_from_iattx(&rsp->preoldparent, preoldparent);
+ gfx_stat_from_iattx(&rsp->postoldparent, postoldparent);
+ gfx_stat_from_iattx(&rsp->prenewparent, prenewparent);
+ gfx_stat_from_iattx(&rsp->postnewparent, postnewparent);
}
int
-server4_post_open (call_frame_t *frame, xlator_t *this,
- gfx_open_rsp *rsp, fd_t *fd)
-{
- server_ctx_t *serv_ctx = NULL;
- uint64_t fd_no = 0;
-
- serv_ctx = server_ctx_get (frame->root->client, this);
- if (serv_ctx == NULL) {
- gf_msg (this->name, GF_LOG_INFO, 0,
- PS_MSG_SERVER_CTX_GET_FAILED, "server_ctx_get() "
- "failed");
- return -1;
- }
+server4_post_open(call_frame_t *frame, xlator_t *this, gfx_open_rsp *rsp,
+ fd_t *fd)
+{
+ server_ctx_t *serv_ctx = NULL;
+ uint64_t fd_no = 0;
+
+ serv_ctx = server_ctx_get(frame->root->client, this);
+ if (serv_ctx == NULL) {
+ gf_msg(this->name, GF_LOG_INFO, 0, PS_MSG_SERVER_CTX_GET_FAILED,
+ "server_ctx_get() "
+ "failed");
+ return -1;
+ }
- fd_bind (fd);
- fd_ref (fd);
- fd_no = gf_fd_unused_get (serv_ctx->fdtable, fd);
- rsp->fd = fd_no;
+ fd_bind(fd);
+ fd_ref(fd);
+ fd_no = gf_fd_unused_get(serv_ctx->fdtable, fd);
+ rsp->fd = fd_no;
- return 0;
+ return 0;
}
void
-server4_post_readv (gfx_read_rsp *rsp, struct iatt *stbuf, int op_ret)
+server4_post_readv(gfx_read_rsp *rsp, struct iatt *stbuf, int op_ret)
{
- gfx_stat_from_iattx (&rsp->stat, stbuf);
- rsp->size = op_ret;
+ gfx_stat_from_iattx(&rsp->stat, stbuf);
+ rsp->size = op_ret;
}
int
-server4_post_create (call_frame_t *frame, gfx_create_rsp *rsp,
- server_state_t *state,
- xlator_t *this, fd_t *fd, inode_t *inode,
- struct iatt *stbuf, struct iatt *preparent,
+server4_post_create(call_frame_t *frame, gfx_create_rsp *rsp,
+ server_state_t *state, xlator_t *this, fd_t *fd,
+ inode_t *inode, struct iatt *stbuf, struct iatt *preparent,
struct iatt *postparent)
{
- server_ctx_t *serv_ctx = NULL;
- inode_t *link_inode = NULL;
- uint64_t fd_no = 0;
- int op_errno = 0;
-
- link_inode = inode_link (inode, state->loc.parent,
- state->loc.name, stbuf);
-
- if (!link_inode) {
- op_errno = ENOENT;
- goto out;
- }
-
- if (link_inode != inode) {
- /*
- VERY racy code (if used anywhere else)
- -- don't do this without understanding
- */
-
- inode_ctx_merge (fd, fd->inode, link_inode);
- inode_unref (fd->inode);
- fd->inode = inode_ref (link_inode);
- }
-
- inode_lookup (link_inode);
- inode_unref (link_inode);
-
- serv_ctx = server_ctx_get (frame->root->client, this);
- if (serv_ctx == NULL) {
- gf_msg (this->name, GF_LOG_INFO, 0,
- PS_MSG_SERVER_CTX_GET_FAILED, "server_ctx_get() "
- "failed");
- goto out;
- }
-
- fd_bind (fd);
- fd_ref (fd);
- fd_no = gf_fd_unused_get (serv_ctx->fdtable, fd);
-
- if ((fd_no > UINT64_MAX) || (fd == 0)) {
- op_errno = errno;
- }
-
- rsp->fd = fd_no;
- gfx_stat_from_iattx (&rsp->stat, stbuf);
- gfx_stat_from_iattx (&rsp->preparent, preparent);
- gfx_stat_from_iattx (&rsp->postparent, postparent);
-
- return 0;
+ server_ctx_t *serv_ctx = NULL;
+ inode_t *link_inode = NULL;
+ uint64_t fd_no = 0;
+ int op_errno = 0;
+
+ link_inode = inode_link(inode, state->loc.parent, state->loc.name, stbuf);
+
+ if (!link_inode) {
+ op_errno = ENOENT;
+ goto out;
+ }
+
+ if (link_inode != inode) {
+ /*
+ VERY racy code (if used anywhere else)
+ -- don't do this without understanding
+ */
+
+ inode_ctx_merge(fd, fd->inode, link_inode);
+ inode_unref(fd->inode);
+ fd->inode = inode_ref(link_inode);
+ }
+
+ inode_lookup(link_inode);
+ inode_unref(link_inode);
+
+ serv_ctx = server_ctx_get(frame->root->client, this);
+ if (serv_ctx == NULL) {
+ gf_msg(this->name, GF_LOG_INFO, 0, PS_MSG_SERVER_CTX_GET_FAILED,
+ "server_ctx_get() "
+ "failed");
+ goto out;
+ }
+
+ fd_bind(fd);
+ fd_ref(fd);
+ fd_no = gf_fd_unused_get(serv_ctx->fdtable, fd);
+
+ if ((fd_no > UINT64_MAX) || (fd == 0)) {
+ op_errno = errno;
+ }
+
+ rsp->fd = fd_no;
+ gfx_stat_from_iattx(&rsp->stat, stbuf);
+ gfx_stat_from_iattx(&rsp->preparent, preparent);
+ gfx_stat_from_iattx(&rsp->postparent, postparent);
+
+ return 0;
out:
- return -op_errno;
+ return -op_errno;
}
/*TODO: Handle revalidate path */
void
-server4_post_lookup (gfx_common_2iatt_rsp *rsp, call_frame_t *frame,
- server_state_t *state,
- inode_t *inode, struct iatt *stbuf)
+server4_post_lookup(gfx_common_2iatt_rsp *rsp, call_frame_t *frame,
+ server_state_t *state, inode_t *inode, struct iatt *stbuf)
{
- inode_t *root_inode = NULL;
- inode_t *link_inode = NULL;
- uuid_t rootgfid = {0,};
+ inode_t *root_inode = NULL;
+ inode_t *link_inode = NULL;
+ uuid_t rootgfid = {
+ 0,
+ };
- root_inode = frame->root->client->bound_xl->itable->root;
+ root_inode = frame->root->client->bound_xl->itable->root;
- if (!__is_root_gfid (inode->gfid)) {
- link_inode = inode_link (inode, state->loc.parent,
- state->loc.name, stbuf);
- if (link_inode) {
- inode_lookup (link_inode);
- inode_unref (link_inode);
- }
+ if (!__is_root_gfid(inode->gfid)) {
+ link_inode = inode_link(inode, state->loc.parent, state->loc.name,
+ stbuf);
+ if (link_inode) {
+ inode_lookup(link_inode);
+ inode_unref(link_inode);
}
+ }
- if ((inode == root_inode) ||
- (state->client->subdir_mount &&
- (inode == state->client->subdir_inode))) {
- /* we just looked up root ("/") OR
- subdir mount directory, which is root ('/') in client */
- /* This is very important as when we send iatt of
- root-inode, fuse/client expect the gfid to be 1,
- along with inode number. As for subdirectory mount,
- we use inode table which is shared by everyone, but
- make sure we send fops only from subdir and below,
- we have to alter inode gfid and send it to client */
- stbuf->ia_ino = 1;
- rootgfid[15] = 1;
- gf_uuid_copy (stbuf->ia_gfid, rootgfid);
- if (inode->ia_type == 0)
- inode->ia_type = stbuf->ia_type;
- }
+ if ((inode == root_inode) || (state->client->subdir_mount &&
+ (inode == state->client->subdir_inode))) {
+ /* we just looked up root ("/") OR
+ subdir mount directory, which is root ('/') in client */
+ /* This is very important as when we send iatt of
+ root-inode, fuse/client expect the gfid to be 1,
+ along with inode number. As for subdirectory mount,
+ we use inode table which is shared by everyone, but
+ make sure we send fops only from subdir and below,
+ we have to alter inode gfid and send it to client */
+ stbuf->ia_ino = 1;
+ rootgfid[15] = 1;
+ gf_uuid_copy(stbuf->ia_gfid, rootgfid);
+ if (inode->ia_type == 0)
+ inode->ia_type = stbuf->ia_type;
+ }
- gfx_stat_from_iattx (&rsp->prestat, stbuf);
+ gfx_stat_from_iattx(&rsp->prestat, stbuf);
}
void
-server4_post_lease (gfx_lease_rsp *rsp, struct gf_lease *lease)
+server4_post_lease(gfx_lease_rsp *rsp, struct gf_lease *lease)
{
- gf_proto_lease_from_lease (&rsp->lease, lease);
+ gf_proto_lease_from_lease(&rsp->lease, lease);
}
void
-server4_post_link (server_state_t *state, gfx_common_3iatt_rsp *rsp,
- inode_t *inode,
- struct iatt *stbuf, struct iatt *preparent,
- struct iatt *postparent, dict_t *xdata)
+server4_post_link(server_state_t *state, gfx_common_3iatt_rsp *rsp,
+ inode_t *inode, struct iatt *stbuf, struct iatt *preparent,
+ struct iatt *postparent, dict_t *xdata)
{
- inode_t *link_inode = NULL;
-
- gfx_stat_from_iattx (&rsp->stat, stbuf);
- gfx_stat_from_iattx (&rsp->preparent, preparent);
- gfx_stat_from_iattx (&rsp->postparent, postparent);
+ inode_t *link_inode = NULL;
- link_inode = inode_link (inode, state->loc2.parent,
- state->loc2.name, stbuf);
- inode_lookup (link_inode);
- inode_unref (link_inode);
+ gfx_stat_from_iattx(&rsp->stat, stbuf);
+ gfx_stat_from_iattx(&rsp->preparent, preparent);
+ gfx_stat_from_iattx(&rsp->postparent, postparent);
+ link_inode = inode_link(inode, state->loc2.parent, state->loc2.name, stbuf);
+ inode_lookup(link_inode);
+ inode_unref(link_inode);
}
diff --git a/xlators/protocol/server/src/server-handshake.c b/xlators/protocol/server/src/server-handshake.c
index c0b03510191..30e7e4b0478 100644
--- a/xlators/protocol/server/src/server-handshake.c
+++ b/xlators/protocol/server/src/server-handshake.c
@@ -8,7 +8,6 @@
cases as published by the Free Software Foundation.
*/
-
#include "server.h"
#include "server-helpers.h"
#include "rpc-common-xdr.h"
@@ -22,989 +21,1012 @@
#include "syncop.h"
struct __get_xl_struct {
- const char *name;
- xlator_t *reply;
+ const char *name;
+ xlator_t *reply;
};
int
-gf_compare_client_version (rpcsvc_request_t *req, int fop_prognum,
- int mgmt_prognum)
+gf_compare_client_version(rpcsvc_request_t *req, int fop_prognum,
+ int mgmt_prognum)
{
- int ret = -1;
- /* TODO: think.. */
- if (glusterfs3_3_fop_prog.prognum == fop_prognum)
- ret = 0;
+ int ret = -1;
+ /* TODO: think.. */
+ if (glusterfs3_3_fop_prog.prognum == fop_prognum)
+ ret = 0;
- return ret;
+ return ret;
}
int
-_volfile_update_checksum (xlator_t *this, char *key, uint32_t checksum)
+_volfile_update_checksum(xlator_t *this, char *key, uint32_t checksum)
{
- server_conf_t *conf = NULL;
- struct _volfile_ctx *temp_volfile = NULL;
-
- conf = this->private;
- temp_volfile = conf->volfile;
-
- while (temp_volfile) {
- if ((NULL == key) && (NULL == temp_volfile->key))
- break;
- if ((NULL == key) || (NULL == temp_volfile->key)) {
- temp_volfile = temp_volfile->next;
- continue;
- }
- if (strcmp (temp_volfile->key, key) == 0)
- break;
- temp_volfile = temp_volfile->next;
+ server_conf_t *conf = NULL;
+ struct _volfile_ctx *temp_volfile = NULL;
+
+ conf = this->private;
+ temp_volfile = conf->volfile;
+
+ while (temp_volfile) {
+ if ((NULL == key) && (NULL == temp_volfile->key))
+ break;
+ if ((NULL == key) || (NULL == temp_volfile->key)) {
+ temp_volfile = temp_volfile->next;
+ continue;
}
+ if (strcmp(temp_volfile->key, key) == 0)
+ break;
+ temp_volfile = temp_volfile->next;
+ }
+
+ if (!temp_volfile) {
+ temp_volfile = GF_CALLOC(1, sizeof(struct _volfile_ctx),
+ gf_server_mt_volfile_ctx_t);
+ if (!temp_volfile)
+ goto out;
+ temp_volfile->next = conf->volfile;
+ temp_volfile->key = (key) ? gf_strdup(key) : NULL;
+ temp_volfile->checksum = checksum;
- if (!temp_volfile) {
- temp_volfile = GF_CALLOC (1, sizeof (struct _volfile_ctx),
- gf_server_mt_volfile_ctx_t);
- if (!temp_volfile)
- goto out;
- temp_volfile->next = conf->volfile;
- temp_volfile->key = (key)? gf_strdup (key): NULL;
- temp_volfile->checksum = checksum;
-
- conf->volfile = temp_volfile;
- goto out;
- }
+ conf->volfile = temp_volfile;
+ goto out;
+ }
- if (temp_volfile->checksum != checksum) {
- gf_msg (this->name, GF_LOG_INFO, 0, PS_MSG_REMOUNT_CLIENT_REQD,
- "the volume file was modified between a prior access "
- "and now. This may lead to inconsistency between "
- "clients, you are advised to remount client");
- temp_volfile->checksum = checksum;
- }
+ if (temp_volfile->checksum != checksum) {
+ gf_msg(this->name, GF_LOG_INFO, 0, PS_MSG_REMOUNT_CLIENT_REQD,
+ "the volume file was modified between a prior access "
+ "and now. This may lead to inconsistency between "
+ "clients, you are advised to remount client");
+ temp_volfile->checksum = checksum;
+ }
out:
- return 0;
+ return 0;
}
-
static size_t
-getspec_build_volfile_path (xlator_t *this, const char *key, char *path,
- size_t path_len)
+getspec_build_volfile_path(xlator_t *this, const char *key, char *path,
+ size_t path_len)
{
- char *filename = NULL;
- server_conf_t *conf = NULL;
- int ret = -1;
- int free_filename = 0;
- char data_key[256] = {0,};
-
- conf = this->private;
-
- /* Inform users that this option is changed now */
- ret = dict_get_str (this->options, "client-volume-filename",
- &filename);
- if (ret == 0) {
- gf_msg (this->name, GF_LOG_WARNING, 0, PS_MSG_DEFAULTING_FILE,
- "option 'client-volume-filename' is changed to "
- "'volume-filename.<key>' which now takes 'key' as an "
- "option to choose/fetch different files from server. "
- "Refer documentation or contact developers for more "
- "info. Currently defaulting to given file '%s'",
- filename);
- }
-
- if (key && !filename) {
- sprintf (data_key, "volume-filename.%s", key);
- ret = dict_get_str (this->options, data_key, &filename);
- if (ret < 0) {
- /* Make sure that key doesn't contain "../" in path */
- if ((gf_strstr (key, "/", "..")) == -1) {
- gf_msg (this->name, GF_LOG_ERROR, EINVAL,
- PS_MSG_INVALID_ENTRY, "%s: invalid "
- "key", key);
- goto out;
- }
- }
+ char *filename = NULL;
+ server_conf_t *conf = NULL;
+ int ret = -1;
+ int free_filename = 0;
+ char data_key[256] = {
+ 0,
+ };
+
+ conf = this->private;
+
+ /* Inform users that this option is changed now */
+ ret = dict_get_str(this->options, "client-volume-filename", &filename);
+ if (ret == 0) {
+ gf_msg(this->name, GF_LOG_WARNING, 0, PS_MSG_DEFAULTING_FILE,
+ "option 'client-volume-filename' is changed to "
+ "'volume-filename.<key>' which now takes 'key' as an "
+ "option to choose/fetch different files from server. "
+ "Refer documentation or contact developers for more "
+ "info. Currently defaulting to given file '%s'",
+ filename);
+ }
+
+ if (key && !filename) {
+ sprintf(data_key, "volume-filename.%s", key);
+ ret = dict_get_str(this->options, data_key, &filename);
+ if (ret < 0) {
+ /* Make sure that key doesn't contain "../" in path */
+ if ((gf_strstr(key, "/", "..")) == -1) {
+ gf_msg(this->name, GF_LOG_ERROR, EINVAL, PS_MSG_INVALID_ENTRY,
+ "%s: invalid "
+ "key",
+ key);
+ goto out;
+ }
}
+ }
- if (!filename) {
- ret = dict_get_str (this->options,
- "volume-filename.default", &filename);
- if (ret < 0) {
- gf_msg_debug (this->name, 0, "no default volume "
- "filename given, defaulting to %s",
- DEFAULT_VOLUME_FILE_PATH);
- }
+ if (!filename) {
+ ret = dict_get_str(this->options, "volume-filename.default", &filename);
+ if (ret < 0) {
+ gf_msg_debug(this->name, 0,
+ "no default volume "
+ "filename given, defaulting to %s",
+ DEFAULT_VOLUME_FILE_PATH);
}
+ }
- if (!filename && key) {
- ret = gf_asprintf (&filename, "%s/%s.vol", conf->conf_dir, key);
- if (-1 == ret)
- goto out;
+ if (!filename && key) {
+ ret = gf_asprintf(&filename, "%s/%s.vol", conf->conf_dir, key);
+ if (-1 == ret)
+ goto out;
- free_filename = 1;
- }
- if (!filename)
- filename = DEFAULT_VOLUME_FILE_PATH;
+ free_filename = 1;
+ }
+ if (!filename)
+ filename = DEFAULT_VOLUME_FILE_PATH;
- ret = -1;
+ ret = -1;
- if ((filename) && (path_len > strlen (filename))) {
- strcpy (path, filename);
- ret = strlen (filename);
- }
+ if ((filename) && (path_len > strlen(filename))) {
+ strcpy(path, filename);
+ ret = strlen(filename);
+ }
out:
- if (free_filename)
- GF_FREE (filename);
+ if (free_filename)
+ GF_FREE(filename);
- return ret;
+ return ret;
}
int
-_validate_volfile_checksum (xlator_t *this, char *key,
- uint32_t checksum)
+_validate_volfile_checksum(xlator_t *this, char *key, uint32_t checksum)
{
- char filename[PATH_MAX] = {0,};
- server_conf_t *conf = NULL;
- struct _volfile_ctx *temp_volfile = NULL;
- int ret = 0;
- int fd = 0;
- uint32_t local_checksum = 0;
-
- conf = this->private;
- temp_volfile = conf->volfile;
-
- if (!checksum)
- goto out;
+ char filename[PATH_MAX] = {
+ 0,
+ };
+ server_conf_t *conf = NULL;
+ struct _volfile_ctx *temp_volfile = NULL;
+ int ret = 0;
+ int fd = 0;
+ uint32_t local_checksum = 0;
+
+ conf = this->private;
+ temp_volfile = conf->volfile;
+
+ if (!checksum)
+ goto out;
- if (!temp_volfile) {
- ret = getspec_build_volfile_path (this, key, filename,
- sizeof (filename));
- if (ret <= 0)
- goto out;
- fd = open (filename, O_RDONLY);
- if (-1 == fd) {
- ret = 0;
- gf_msg (this->name, GF_LOG_INFO, errno,
- PS_MSG_VOL_FILE_OPEN_FAILED,
- "failed to open volume file (%s) : %s",
- filename, strerror (errno));
- goto out;
- }
- get_checksum_for_file (fd, &local_checksum);
- _volfile_update_checksum (this, key, local_checksum);
- sys_close (fd);
+ if (!temp_volfile) {
+ ret = getspec_build_volfile_path(this, key, filename, sizeof(filename));
+ if (ret <= 0)
+ goto out;
+ fd = open(filename, O_RDONLY);
+ if (-1 == fd) {
+ ret = 0;
+ gf_msg(this->name, GF_LOG_INFO, errno, PS_MSG_VOL_FILE_OPEN_FAILED,
+ "failed to open volume file (%s) : %s", filename,
+ strerror(errno));
+ goto out;
}
-
- temp_volfile = conf->volfile;
- while (temp_volfile) {
- if ((NULL == key) && (NULL == temp_volfile->key))
- break;
- if ((NULL == key) || (NULL == temp_volfile->key)) {
- temp_volfile = temp_volfile->next;
- continue;
- }
- if (strcmp (temp_volfile->key, key) == 0)
- break;
- temp_volfile = temp_volfile->next;
+ get_checksum_for_file(fd, &local_checksum);
+ _volfile_update_checksum(this, key, local_checksum);
+ sys_close(fd);
+ }
+
+ temp_volfile = conf->volfile;
+ while (temp_volfile) {
+ if ((NULL == key) && (NULL == temp_volfile->key))
+ break;
+ if ((NULL == key) || (NULL == temp_volfile->key)) {
+ temp_volfile = temp_volfile->next;
+ continue;
}
+ if (strcmp(temp_volfile->key, key) == 0)
+ break;
+ temp_volfile = temp_volfile->next;
+ }
- if (!temp_volfile)
- goto out;
+ if (!temp_volfile)
+ goto out;
- if ((temp_volfile->checksum) &&
- (checksum != temp_volfile->checksum))
- ret = -1;
+ if ((temp_volfile->checksum) && (checksum != temp_volfile->checksum))
+ ret = -1;
out:
- return ret;
+ return ret;
}
-
int
-server_getspec (rpcsvc_request_t *req)
+server_getspec(rpcsvc_request_t *req)
{
- int32_t ret = -1;
- int32_t op_errno = ENOENT;
- int32_t spec_fd = -1;
- size_t file_len = 0;
- char filename[PATH_MAX] = {0,};
- struct stat stbuf = {0,};
- uint32_t checksum = 0;
- char *key = NULL;
- server_conf_t *conf = NULL;
- xlator_t *this = NULL;
- gf_getspec_req args = {0,};
- gf_getspec_rsp rsp = {0,};
-
- this = req->svc->xl;
- conf = this->private;
- ret = xdr_to_generic (req->msg[0], &args,
- (xdrproc_t)xdr_gf_getspec_req);
+ int32_t ret = -1;
+ int32_t op_errno = ENOENT;
+ int32_t spec_fd = -1;
+ size_t file_len = 0;
+ char filename[PATH_MAX] = {
+ 0,
+ };
+ struct stat stbuf = {
+ 0,
+ };
+ uint32_t checksum = 0;
+ char *key = NULL;
+ server_conf_t *conf = NULL;
+ xlator_t *this = NULL;
+ gf_getspec_req args = {
+ 0,
+ };
+ gf_getspec_rsp rsp = {
+ 0,
+ };
+
+ this = req->svc->xl;
+ conf = this->private;
+ ret = xdr_to_generic(req->msg[0], &args, (xdrproc_t)xdr_gf_getspec_req);
+ if (ret < 0) {
+ // failed to decode msg;
+ req->rpc_err = GARBAGE_ARGS;
+ op_errno = EINVAL;
+ goto fail;
+ }
+
+ ret = getspec_build_volfile_path(this, args.key, filename,
+ sizeof(filename));
+ if (ret > 0) {
+ /* to allocate the proper buffer to hold the file data */
+ ret = sys_stat(filename, &stbuf);
if (ret < 0) {
- //failed to decode msg;
- req->rpc_err = GARBAGE_ARGS;
- op_errno = EINVAL;
- goto fail;
+ gf_msg(this->name, GF_LOG_ERROR, errno, PS_MSG_STAT_ERROR,
+ "Unable to stat %s (%s)", filename, strerror(errno));
+ op_errno = errno;
+ goto fail;
}
- ret = getspec_build_volfile_path (this, args.key,
- filename, sizeof (filename));
- if (ret > 0) {
- /* to allocate the proper buffer to hold the file data */
- ret = sys_stat (filename, &stbuf);
- if (ret < 0){
- gf_msg (this->name, GF_LOG_ERROR, errno,
- PS_MSG_STAT_ERROR, "Unable to stat %s (%s)",
- filename, strerror (errno));
- op_errno = errno;
- goto fail;
- }
-
- spec_fd = open (filename, O_RDONLY);
- if (spec_fd < 0) {
- gf_msg (this->name, GF_LOG_ERROR, errno,
- PS_MSG_FILE_OP_FAILED, "Unable to open %s "
- "(%s)", filename, strerror (errno));
- op_errno = errno;
- goto fail;
- }
- ret = file_len = stbuf.st_size;
-
- if (conf->verify_volfile) {
- get_checksum_for_file (spec_fd, &checksum);
- _volfile_update_checksum (this, key, checksum);
- }
+ spec_fd = open(filename, O_RDONLY);
+ if (spec_fd < 0) {
+ gf_msg(this->name, GF_LOG_ERROR, errno, PS_MSG_FILE_OP_FAILED,
+ "Unable to open %s "
+ "(%s)",
+ filename, strerror(errno));
+ op_errno = errno;
+ goto fail;
}
+ ret = file_len = stbuf.st_size;
- if (file_len) {
- rsp.spec = GF_CALLOC (file_len, sizeof (char),
- gf_server_mt_rsp_buf_t);
- if (!rsp.spec) {
- ret = -1;
- op_errno = ENOMEM;
- goto fail;
- }
- ret = sys_read (spec_fd, rsp.spec, file_len);
+ if (conf->verify_volfile) {
+ get_checksum_for_file(spec_fd, &checksum);
+ _volfile_update_checksum(this, key, checksum);
}
+ }
+
+ if (file_len) {
+ rsp.spec = GF_CALLOC(file_len, sizeof(char), gf_server_mt_rsp_buf_t);
+ if (!rsp.spec) {
+ ret = -1;
+ op_errno = ENOMEM;
+ goto fail;
+ }
+ ret = sys_read(spec_fd, rsp.spec, file_len);
+ }
- /* convert to XDR */
- op_errno = errno;
+ /* convert to XDR */
+ op_errno = errno;
fail:
- if (!rsp.spec)
- rsp.spec = "";
- rsp.op_errno = gf_errno_to_error (op_errno);
- rsp.op_ret = ret;
+ if (!rsp.spec)
+ rsp.spec = "";
+ rsp.op_errno = gf_errno_to_error(op_errno);
+ rsp.op_ret = ret;
- if (spec_fd != -1)
- sys_close (spec_fd);
+ if (spec_fd != -1)
+ sys_close(spec_fd);
- server_submit_reply (NULL, req, &rsp, NULL, 0, NULL,
- (xdrproc_t)xdr_gf_getspec_rsp);
+ server_submit_reply(NULL, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gf_getspec_rsp);
- return 0;
+ return 0;
}
static void
-server_first_lookup_done (rpcsvc_request_t *req, gf_setvolume_rsp *rsp) {
-
- server_submit_reply (NULL, req, rsp, NULL, 0, NULL,
- (xdrproc_t)xdr_gf_setvolume_rsp);
+server_first_lookup_done(rpcsvc_request_t *req, gf_setvolume_rsp *rsp)
+{
+ server_submit_reply(NULL, req, rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gf_setvolume_rsp);
- GF_FREE (rsp->dict.dict_val);
- GF_FREE (rsp);
+ GF_FREE(rsp->dict.dict_val);
+ GF_FREE(rsp);
}
static inode_t *
-do_path_lookup (xlator_t *xl, dict_t *dict, inode_t *parinode, char *basename)
+do_path_lookup(xlator_t *xl, dict_t *dict, inode_t *parinode, char *basename)
{
- int ret = 0;
- loc_t loc = {0,};
- uuid_t gfid = {0,};
- struct iatt iatt = {0,};
- inode_t *inode = NULL;
-
- loc.parent = parinode;
- loc_touchup (&loc, basename);
- loc.inode = inode_new (xl->itable);
-
- gf_uuid_generate (gfid);
- ret = dict_set_gfuuid (dict, "gfid-req", gfid, true);
- if (ret) {
- gf_log (xl->name, GF_LOG_ERROR,
- "failed to set 'gfid-req' for subdir");
- goto out;
- }
-
- ret = syncop_lookup (xl, &loc, &iatt, NULL, dict, NULL);
- if (ret < 0) {
- gf_log (xl->name, GF_LOG_ERROR,
- "first lookup on subdir (%s) failed: %s",
- basename, strerror (errno));
- }
+ int ret = 0;
+ loc_t loc = {
+ 0,
+ };
+ uuid_t gfid = {
+ 0,
+ };
+ struct iatt iatt = {
+ 0,
+ };
+ inode_t *inode = NULL;
+
+ loc.parent = parinode;
+ loc_touchup(&loc, basename);
+ loc.inode = inode_new(xl->itable);
+
+ gf_uuid_generate(gfid);
+ ret = dict_set_gfuuid(dict, "gfid-req", gfid, true);
+ if (ret) {
+ gf_log(xl->name, GF_LOG_ERROR, "failed to set 'gfid-req' for subdir");
+ goto out;
+ }
+ ret = syncop_lookup(xl, &loc, &iatt, NULL, dict, NULL);
+ if (ret < 0) {
+ gf_log(xl->name, GF_LOG_ERROR, "first lookup on subdir (%s) failed: %s",
+ basename, strerror(errno));
+ }
- /* Inode linking is required so that the
- resolution happens all fine for future fops */
- inode = inode_link (loc.inode, loc.parent, loc.name, &iatt);
+ /* Inode linking is required so that the
+ resolution happens all fine for future fops */
+ inode = inode_link(loc.inode, loc.parent, loc.name, &iatt);
- /* Extra ref so the pointer is valid till client is valid */
- /* FIXME: not a priority, but this can lead to some inode
- leaks if subdir is more than 1 level depth. Leak is only
- per subdir entry, and not dependent on number of
- connections, so it should be fine for now */
- inode_ref (inode);
+ /* Extra ref so the pointer is valid till client is valid */
+ /* FIXME: not a priority, but this can lead to some inode
+ leaks if subdir is more than 1 level depth. Leak is only
+ per subdir entry, and not dependent on number of
+ connections, so it should be fine for now */
+ inode_ref(inode);
out:
- return inode;
+ return inode;
}
int
-server_first_lookup (xlator_t *this, client_t *client, dict_t *reply)
+server_first_lookup(xlator_t *this, client_t *client, dict_t *reply)
{
- loc_t loc = {0, };
- struct iatt iatt = {0,};
- dict_t *dict = NULL;
- int ret = 0;
- xlator_t *xl = client->bound_xl;
- char *msg = NULL;
- inode_t *inode = NULL;
- char *bname = NULL;
- char *str = NULL;
- char *tmp = NULL;
- char *saveptr = NULL;
-
- loc.path = "/";
- loc.name = "";
- loc.inode = xl->itable->root;
- loc.parent = NULL;
- gf_uuid_copy (loc.gfid, loc.inode->gfid);
-
- ret = syncop_lookup (xl, &loc, &iatt, NULL, NULL, NULL);
- if (ret < 0)
- gf_log (xl->name, GF_LOG_ERROR, "lookup on root failed: %s",
- strerror (errno));
- /* Ignore error from lookup, don't set
- * failure in rsp->op_ret. lookup on a snapview-server
- * can fail with ESTALE
- */
- /* TODO-SUBDIR-MOUNT: validate above comment with respect to subdir lookup */
-
- if (client->subdir_mount) {
- str = tmp = gf_strdup (client->subdir_mount);
- dict = dict_new ();
- inode = xl->itable->root;
- bname = strtok_r (str, "/", &saveptr);
- while (bname != NULL) {
- inode = do_path_lookup (xl, dict, inode, bname);
- if (inode == NULL) {
- gf_log (this->name, GF_LOG_ERROR,
- "first lookup on subdir (%s) failed: %s",
- client->subdir_mount, strerror (errno));
- ret = -1;
- goto fail;
- }
- bname = strtok_r (NULL, "/", &saveptr);
- }
-
- /* Can be used in server_resolve() */
- gf_uuid_copy (client->subdir_gfid, inode->gfid);
- client->subdir_inode = inode;
+ loc_t loc = {
+ 0,
+ };
+ struct iatt iatt = {
+ 0,
+ };
+ dict_t *dict = NULL;
+ int ret = 0;
+ xlator_t *xl = client->bound_xl;
+ char *msg = NULL;
+ inode_t *inode = NULL;
+ char *bname = NULL;
+ char *str = NULL;
+ char *tmp = NULL;
+ char *saveptr = NULL;
+
+ loc.path = "/";
+ loc.name = "";
+ loc.inode = xl->itable->root;
+ loc.parent = NULL;
+ gf_uuid_copy(loc.gfid, loc.inode->gfid);
+
+ ret = syncop_lookup(xl, &loc, &iatt, NULL, NULL, NULL);
+ if (ret < 0)
+ gf_log(xl->name, GF_LOG_ERROR, "lookup on root failed: %s",
+ strerror(errno));
+ /* Ignore error from lookup, don't set
+ * failure in rsp->op_ret. lookup on a snapview-server
+ * can fail with ESTALE
+ */
+ /* TODO-SUBDIR-MOUNT: validate above comment with respect to subdir lookup
+ */
+
+ if (client->subdir_mount) {
+ str = tmp = gf_strdup(client->subdir_mount);
+ dict = dict_new();
+ inode = xl->itable->root;
+ bname = strtok_r(str, "/", &saveptr);
+ while (bname != NULL) {
+ inode = do_path_lookup(xl, dict, inode, bname);
+ if (inode == NULL) {
+ gf_log(this->name, GF_LOG_ERROR,
+ "first lookup on subdir (%s) failed: %s",
+ client->subdir_mount, strerror(errno));
+ ret = -1;
+ goto fail;
+ }
+ bname = strtok_r(NULL, "/", &saveptr);
}
- ret = 0;
- goto out;
+ /* Can be used in server_resolve() */
+ gf_uuid_copy(client->subdir_gfid, inode->gfid);
+ client->subdir_inode = inode;
+ }
-fail:
- /* we should say to client, it is not possible
- to connect */
- ret = gf_asprintf (&msg, "subdirectory for mount \"%s\" is not found",
- client->subdir_mount);
- if (-1 == ret) {
- gf_msg (this->name, GF_LOG_ERROR, 0,
- PS_MSG_ASPRINTF_FAILED,
- "asprintf failed while setting error msg");
- }
- ret = dict_set_dynstr (reply, "ERROR", msg);
- if (ret < 0)
- gf_msg_debug (this->name, 0, "failed to set error "
- "msg");
+ ret = 0;
+ goto out;
- ret = -1;
+fail:
+ /* we should say to client, it is not possible
+ to connect */
+ ret = gf_asprintf(&msg, "subdirectory for mount \"%s\" is not found",
+ client->subdir_mount);
+ if (-1 == ret) {
+ gf_msg(this->name, GF_LOG_ERROR, 0, PS_MSG_ASPRINTF_FAILED,
+ "asprintf failed while setting error msg");
+ }
+ ret = dict_set_dynstr(reply, "ERROR", msg);
+ if (ret < 0)
+ gf_msg_debug(this->name, 0,
+ "failed to set error "
+ "msg");
+
+ ret = -1;
out:
- if (dict)
- dict_unref (dict);
+ if (dict)
+ dict_unref(dict);
- inode_unref (loc.inode);
+ inode_unref(loc.inode);
- if (tmp)
- GF_FREE (tmp);
+ if (tmp)
+ GF_FREE(tmp);
- return ret;
+ return ret;
}
int
-server_setvolume (rpcsvc_request_t *req)
+server_setvolume(rpcsvc_request_t *req)
{
- gf_setvolume_req args = {{0,},};
- gf_setvolume_rsp *rsp = NULL;
- client_t *client = NULL;
- server_ctx_t *serv_ctx = NULL;
- server_conf_t *conf = NULL;
- peer_info_t *peerinfo = NULL;
- dict_t *reply = NULL;
- dict_t *config_params = NULL;
- dict_t *params = NULL;
- char *name = NULL;
- char *client_uid = NULL;
- char *clnt_version = NULL;
- xlator_t *xl = NULL;
- char *msg = NULL;
- char *volfile_key = NULL;
- xlator_t *this = NULL;
- uint32_t checksum = 0;
- int32_t ret = -1;
- int32_t op_ret = -1;
- int32_t op_errno = EINVAL;
- char *buf = NULL;
- uint32_t opversion = 0;
- rpc_transport_t *xprt = NULL;
- int32_t fop_version = 0;
- int32_t mgmt_version = 0;
- glusterfs_ctx_t *ctx = NULL;
- struct _child_status *tmp = NULL;
- char *subdir_mount = NULL;
- char *client_name = NULL;
- gf_boolean_t cleanup_starting = _gf_false;
-
- params = dict_new ();
- reply = dict_new ();
- ret = xdr_to_generic (req->msg[0], &args,
- (xdrproc_t)xdr_gf_setvolume_req);
- if (ret < 0) {
- //failed to decode msg;
- req->rpc_err = GARBAGE_ARGS;
- goto fail;
- }
- ctx = THIS->ctx;
-
- this = req->svc->xl;
- /* this is to ensure config_params is populated with the first brick
- * details at first place if brick multiplexing is enabled
- */
- config_params = dict_copy_with_ref (this->options, NULL);
-
- buf = memdup (args.dict.dict_val, args.dict.dict_len);
- if (buf == NULL) {
- op_ret = -1;
- op_errno = ENOMEM;
- goto fail;
- }
-
- ret = dict_unserialize (buf, args.dict.dict_len, &params);
- if (ret < 0) {
- ret = dict_set_str (reply, "ERROR",
- "Internal error: failed to unserialize "
- "request dictionary");
- if (ret < 0)
- gf_msg_debug (this->name, 0, "failed to set error "
- "msg \"%s\"", "Internal error: failed "
- "to unserialize request dictionary");
-
- op_ret = -1;
- op_errno = EINVAL;
- goto fail;
- }
-
- params->extra_free = buf;
- buf = NULL;
-
- ret = dict_get_str (params, "remote-subvolume", &name);
- if (ret < 0) {
- ret = dict_set_str (reply, "ERROR",
- "No remote-subvolume option specified");
- if (ret < 0)
- gf_msg_debug (this->name, 0, "failed to set error "
- "msg");
-
- op_ret = -1;
- op_errno = EINVAL;
- goto fail;
- }
-
- LOCK (&ctx->volfile_lock);
+ gf_setvolume_req args = {
{
- xl = get_xlator_by_name (this, name);
- if (!xl)
- xl = this;
- }
- UNLOCK (&ctx->volfile_lock);
- if (xl == NULL) {
- ret = gf_asprintf (&msg, "remote-subvolume \"%s\" is not found",
- name);
- if (-1 == ret) {
- gf_msg (this->name, GF_LOG_ERROR, 0,
- PS_MSG_ASPRINTF_FAILED,
- "asprintf failed while setting error msg");
- goto fail;
- }
- ret = dict_set_dynstr (reply, "ERROR", msg);
- if (ret < 0)
- gf_msg_debug (this->name, 0, "failed to set error "
- "msg");
-
- op_ret = -1;
- op_errno = ENOENT;
- goto fail;
- }
-
- config_params = dict_copy_with_ref (xl->options, config_params);
- conf = this->private;
-
- if (conf->parent_up == _gf_false) {
- /* PARENT_UP indicates that all xlators in graph are inited
- * successfully
- */
- op_ret = -1;
- op_errno = EAGAIN;
-
- ret = dict_set_str (reply, "ERROR",
- "xlator graph in server is not initialised "
- "yet. Try again later");
- if (ret < 0)
- gf_msg_debug (this->name, 0, "failed to set error: "
- "xlator graph in server is not "
- "initialised yet. Try again later");
- goto fail;
- }
-
- list_for_each_entry (tmp, &conf->child_status->status_list,
- status_list) {
- if (strcmp (tmp->name, name) == 0)
- break;
- }
-
- if (!tmp->name) {
- gf_msg (this->name, GF_LOG_ERROR, 0,
- PS_MSG_CHILD_STATUS_FAILED,
- "No xlator %s is found in "
- "child status list", name);
- } else {
- ret = dict_set_int32 (reply, "child_up", tmp->child_up);
- if (ret < 0)
- gf_msg (this->name, GF_LOG_ERROR, 0,
- PS_MSG_DICT_GET_FAILED,
- "Failed to set 'child_up' for xlator %s "
- "in the reply dict", tmp->name);
- }
-
- ret = dict_get_str (params, "process-uuid", &client_uid);
- if (ret < 0) {
- ret = dict_set_str (reply, "ERROR",
- "UUID not specified");
- if (ret < 0)
- gf_msg_debug (this->name, 0, "failed to set error "
- "msg");
-
- op_ret = -1;
- op_errno = EINVAL;
- goto fail;
- }
-
- ret = dict_get_str (params, "subdir-mount", &subdir_mount);
- if (ret < 0) {
- /* Not a problem at all as the key is optional */
- }
- ret = dict_get_str (params, "process-name", &client_name);
- if (ret < 0) {
- client_name = "unknown";
- }
-
- client = gf_client_get (this, &req->cred, client_uid, subdir_mount);
- if (client == NULL) {
- op_ret = -1;
- op_errno = ENOMEM;
- goto fail;
- }
-
- client->client_name = gf_strdup(client_name);
-
- gf_msg_debug (this->name, 0, "Connected to %s", client->client_uid);
-
- serv_ctx = server_ctx_get (client, client->this);
- if (serv_ctx == NULL) {
- gf_msg (this->name, GF_LOG_INFO, 0,
- PS_MSG_SERVER_CTX_GET_FAILED, "server_ctx_get() "
- "failed");
- goto fail;
+ 0,
+ },
+ };
+ gf_setvolume_rsp *rsp = NULL;
+ client_t *client = NULL;
+ server_ctx_t *serv_ctx = NULL;
+ server_conf_t *conf = NULL;
+ peer_info_t *peerinfo = NULL;
+ dict_t *reply = NULL;
+ dict_t *config_params = NULL;
+ dict_t *params = NULL;
+ char *name = NULL;
+ char *client_uid = NULL;
+ char *clnt_version = NULL;
+ xlator_t *xl = NULL;
+ char *msg = NULL;
+ char *volfile_key = NULL;
+ xlator_t *this = NULL;
+ uint32_t checksum = 0;
+ int32_t ret = -1;
+ int32_t op_ret = -1;
+ int32_t op_errno = EINVAL;
+ char *buf = NULL;
+ uint32_t opversion = 0;
+ rpc_transport_t *xprt = NULL;
+ int32_t fop_version = 0;
+ int32_t mgmt_version = 0;
+ glusterfs_ctx_t *ctx = NULL;
+ struct _child_status *tmp = NULL;
+ char *subdir_mount = NULL;
+ char *client_name = NULL;
+ gf_boolean_t cleanup_starting = _gf_false;
+
+ params = dict_new();
+ reply = dict_new();
+ ret = xdr_to_generic(req->msg[0], &args, (xdrproc_t)xdr_gf_setvolume_req);
+ if (ret < 0) {
+ // failed to decode msg;
+ req->rpc_err = GARBAGE_ARGS;
+ goto fail;
+ }
+ ctx = THIS->ctx;
+
+ this = req->svc->xl;
+ /* this is to ensure config_params is populated with the first brick
+ * details at first place if brick multiplexing is enabled
+ */
+ config_params = dict_copy_with_ref(this->options, NULL);
+
+ buf = memdup(args.dict.dict_val, args.dict.dict_len);
+ if (buf == NULL) {
+ op_ret = -1;
+ op_errno = ENOMEM;
+ goto fail;
+ }
+
+ ret = dict_unserialize(buf, args.dict.dict_len, &params);
+ if (ret < 0) {
+ ret = dict_set_str(reply, "ERROR",
+ "Internal error: failed to unserialize "
+ "request dictionary");
+ if (ret < 0)
+ gf_msg_debug(this->name, 0,
+ "failed to set error "
+ "msg \"%s\"",
+ "Internal error: failed "
+ "to unserialize request dictionary");
+
+ op_ret = -1;
+ op_errno = EINVAL;
+ goto fail;
+ }
+
+ params->extra_free = buf;
+ buf = NULL;
+
+ ret = dict_get_str(params, "remote-subvolume", &name);
+ if (ret < 0) {
+ ret = dict_set_str(reply, "ERROR",
+ "No remote-subvolume option specified");
+ if (ret < 0)
+ gf_msg_debug(this->name, 0,
+ "failed to set error "
+ "msg");
+
+ op_ret = -1;
+ op_errno = EINVAL;
+ goto fail;
+ }
+
+ LOCK(&ctx->volfile_lock);
+ {
+ xl = get_xlator_by_name(this, name);
+ if (!xl)
+ xl = this;
+ }
+ UNLOCK(&ctx->volfile_lock);
+ if (xl == NULL) {
+ ret = gf_asprintf(&msg, "remote-subvolume \"%s\" is not found", name);
+ if (-1 == ret) {
+ gf_msg(this->name, GF_LOG_ERROR, 0, PS_MSG_ASPRINTF_FAILED,
+ "asprintf failed while setting error msg");
+ goto fail;
}
+ ret = dict_set_dynstr(reply, "ERROR", msg);
+ if (ret < 0)
+ gf_msg_debug(this->name, 0,
+ "failed to set error "
+ "msg");
- pthread_mutex_lock (&conf->mutex);
- if (xl->cleanup_starting) {
- cleanup_starting = _gf_true;
- } else if (req->trans->xl_private != client) {
- req->trans->xl_private = client;
- }
- pthread_mutex_unlock (&conf->mutex);
+ op_ret = -1;
+ op_errno = ENOENT;
+ goto fail;
+ }
- if (cleanup_starting) {
- op_ret = -1;
- op_errno = EAGAIN;
+ config_params = dict_copy_with_ref(xl->options, config_params);
+ conf = this->private;
- ret = dict_set_str (reply, "ERROR",
- "cleanup flag is set for xlator. "
- " Try again later");
- if (ret < 0)
- gf_msg_debug (this->name, 0, "failed to set error: "
- "cleanup flag is set for xlator. "
- "Try again later");
- goto fail;
- }
+ if (conf->parent_up == _gf_false) {
+ /* PARENT_UP indicates that all xlators in graph are inited
+ * successfully
+ */
+ op_ret = -1;
+ op_errno = EAGAIN;
- auth_set_username_passwd (params, config_params, client);
- if (req->trans->ssl_name) {
- if (dict_set_str(params,"ssl-name",req->trans->ssl_name) != 0) {
- gf_msg (this->name, GF_LOG_WARNING, 0,
- PS_MSG_SSL_NAME_SET_FAILED, "failed to set "
- "ssl_name %s", req->trans->ssl_name);
- /* Not fatal, auth will just fail. */
- }
+ ret = dict_set_str(reply, "ERROR",
+ "xlator graph in server is not initialised "
+ "yet. Try again later");
+ if (ret < 0)
+ gf_msg_debug(this->name, 0,
+ "failed to set error: "
+ "xlator graph in server is not "
+ "initialised yet. Try again later");
+ goto fail;
+ }
+
+ list_for_each_entry(tmp, &conf->child_status->status_list, status_list)
+ {
+ if (strcmp(tmp->name, name) == 0)
+ break;
+ }
+
+ if (!tmp->name) {
+ gf_msg(this->name, GF_LOG_ERROR, 0, PS_MSG_CHILD_STATUS_FAILED,
+ "No xlator %s is found in "
+ "child status list",
+ name);
+ } else {
+ ret = dict_set_int32(reply, "child_up", tmp->child_up);
+ if (ret < 0)
+ gf_msg(this->name, GF_LOG_ERROR, 0, PS_MSG_DICT_GET_FAILED,
+ "Failed to set 'child_up' for xlator %s "
+ "in the reply dict",
+ tmp->name);
+ }
+
+ ret = dict_get_str(params, "process-uuid", &client_uid);
+ if (ret < 0) {
+ ret = dict_set_str(reply, "ERROR", "UUID not specified");
+ if (ret < 0)
+ gf_msg_debug(this->name, 0,
+ "failed to set error "
+ "msg");
+
+ op_ret = -1;
+ op_errno = EINVAL;
+ goto fail;
+ }
+
+ ret = dict_get_str(params, "subdir-mount", &subdir_mount);
+ if (ret < 0) {
+ /* Not a problem at all as the key is optional */
+ }
+ ret = dict_get_str(params, "process-name", &client_name);
+ if (ret < 0) {
+ client_name = "unknown";
+ }
+
+ client = gf_client_get(this, &req->cred, client_uid, subdir_mount);
+ if (client == NULL) {
+ op_ret = -1;
+ op_errno = ENOMEM;
+ goto fail;
+ }
+
+ client->client_name = gf_strdup(client_name);
+
+ gf_msg_debug(this->name, 0, "Connected to %s", client->client_uid);
+
+ serv_ctx = server_ctx_get(client, client->this);
+ if (serv_ctx == NULL) {
+ gf_msg(this->name, GF_LOG_INFO, 0, PS_MSG_SERVER_CTX_GET_FAILED,
+ "server_ctx_get() "
+ "failed");
+ goto fail;
+ }
+
+ pthread_mutex_lock(&conf->mutex);
+ if (xl->cleanup_starting) {
+ cleanup_starting = _gf_true;
+ } else if (req->trans->xl_private != client) {
+ req->trans->xl_private = client;
+ }
+ pthread_mutex_unlock(&conf->mutex);
+
+ if (cleanup_starting) {
+ op_ret = -1;
+ op_errno = EAGAIN;
+
+ ret = dict_set_str(reply, "ERROR",
+ "cleanup flag is set for xlator. "
+ " Try again later");
+ if (ret < 0)
+ gf_msg_debug(this->name, 0,
+ "failed to set error: "
+ "cleanup flag is set for xlator. "
+ "Try again later");
+ goto fail;
+ }
+
+ auth_set_username_passwd(params, config_params, client);
+ if (req->trans->ssl_name) {
+ if (dict_set_str(params, "ssl-name", req->trans->ssl_name) != 0) {
+ gf_msg(this->name, GF_LOG_WARNING, 0, PS_MSG_SSL_NAME_SET_FAILED,
+ "failed to set "
+ "ssl_name %s",
+ req->trans->ssl_name);
+ /* Not fatal, auth will just fail. */
}
+ }
- ret = dict_get_int32 (params, "fops-version", &fop_version);
- if (ret < 0) {
- ret = dict_set_str (reply, "ERROR",
- "No FOP version number specified");
- if (ret < 0)
- gf_msg_debug (this->name, 0, "failed to set error "
- "msg");
+ ret = dict_get_int32(params, "fops-version", &fop_version);
+ if (ret < 0) {
+ ret = dict_set_str(reply, "ERROR", "No FOP version number specified");
+ if (ret < 0)
+ gf_msg_debug(this->name, 0,
+ "failed to set error "
+ "msg");
+ }
+
+ ret = dict_get_int32(params, "mgmt-version", &mgmt_version);
+ if (ret < 0) {
+ ret = dict_set_str(reply, "ERROR", "No MGMT version number specified");
+ if (ret < 0)
+ gf_msg_debug(this->name, 0,
+ "failed to set error "
+ "msg");
+ }
+
+ ret = gf_compare_client_version(req, fop_version, mgmt_version);
+ if (ret != 0) {
+ ret = gf_asprintf(&msg,
+ "version mismatch: client(%d)"
+ " - client-mgmt(%d)",
+ fop_version, mgmt_version);
+ /* get_supported_version (req)); */
+ if (-1 == ret) {
+ gf_msg(this->name, GF_LOG_ERROR, 0, PS_MSG_ASPRINTF_FAILED,
+ "asprintf failed while"
+ "setting up error msg");
+ goto fail;
}
+ ret = dict_set_dynstr(reply, "ERROR", msg);
+ if (ret < 0)
+ gf_msg_debug(this->name, 0,
+ "failed to set error "
+ "msg");
- ret = dict_get_int32 (params, "mgmt-version", &mgmt_version);
- if (ret < 0) {
- ret = dict_set_str (reply, "ERROR",
- "No MGMT version number specified");
- if (ret < 0)
- gf_msg_debug (this->name, 0, "failed to set error "
- "msg");
- }
+ op_ret = -1;
+ op_errno = EINVAL;
+ goto fail;
+ }
- ret = gf_compare_client_version (req, fop_version, mgmt_version);
- if (ret != 0) {
- ret = gf_asprintf (&msg, "version mismatch: client(%d)"
- " - client-mgmt(%d)",
- fop_version, mgmt_version);
- /* get_supported_version (req)); */
- if (-1 == ret) {
- gf_msg (this->name, GF_LOG_ERROR, 0,
- PS_MSG_ASPRINTF_FAILED, "asprintf failed while"
- "setting up error msg");
- goto fail;
- }
- ret = dict_set_dynstr (reply, "ERROR", msg);
+ if (conf->verify_volfile) {
+ ret = dict_get_uint32(params, "volfile-checksum", &checksum);
+ if (ret == 0) {
+ ret = dict_get_str(params, "volfile-key", &volfile_key);
+ if (ret)
+ gf_msg_debug(this->name, 0,
+ "failed to get "
+ "'volfile-key'");
+
+ ret = _validate_volfile_checksum(this, volfile_key, checksum);
+ if (-1 == ret) {
+ ret = dict_set_str(reply, "ERROR",
+ "volume-file checksum "
+ "varies from earlier "
+ "access");
if (ret < 0)
- gf_msg_debug (this->name, 0, "failed to set error "
- "msg");
+ gf_msg_debug(this->name, 0,
+ "failed "
+ "to set error msg");
op_ret = -1;
- op_errno = EINVAL;
+ op_errno = ESTALE;
goto fail;
+ }
}
+ }
- if (conf->verify_volfile) {
- ret = dict_get_uint32 (params, "volfile-checksum", &checksum);
- if (ret == 0) {
- ret = dict_get_str (params, "volfile-key",
- &volfile_key);
- if (ret)
- gf_msg_debug (this->name, 0, "failed to get "
- "'volfile-key'");
-
- ret = _validate_volfile_checksum (this, volfile_key,
- checksum);
- if (-1 == ret) {
- ret = dict_set_str (reply, "ERROR",
- "volume-file checksum "
- "varies from earlier "
- "access");
- if (ret < 0)
- gf_msg_debug (this->name, 0, "failed "
- "to set error msg");
-
- op_ret = -1;
- op_errno = ESTALE;
- goto fail;
- }
- }
- }
-
-
- peerinfo = &req->trans->peerinfo;
- if (peerinfo) {
- ret = dict_set_static_ptr (params, "peer-info", peerinfo);
- if (ret < 0)
- gf_msg_debug (this->name, 0, "failed to set "
- "peer-info");
- }
-
- ret = dict_get_uint32 (params, "opversion", &opversion);
- if (ret) {
- gf_msg (this->name, GF_LOG_INFO, 0,
- PS_MSG_CLIENT_OPVERSION_GET_FAILED,
- "Failed to get client opversion");
- }
- client->opversion = opversion;
- /* Assign op-version value to the client */
- pthread_mutex_lock (&conf->mutex);
- list_for_each_entry (xprt, &conf->xprt_list, list) {
- if (strcmp (peerinfo->identifier, xprt->peerinfo.identifier))
- continue;
- xprt->peerinfo.max_op_version = opversion;
- }
- pthread_mutex_unlock (&conf->mutex);
-
- if (conf->auth_modules == NULL) {
- gf_msg (this->name, GF_LOG_ERROR, 0, PS_MSG_AUTH_INIT_FAILED,
- "Authentication module not initialized");
+ peerinfo = &req->trans->peerinfo;
+ if (peerinfo) {
+ ret = dict_set_static_ptr(params, "peer-info", peerinfo);
+ if (ret < 0)
+ gf_msg_debug(this->name, 0,
+ "failed to set "
+ "peer-info");
+ }
+
+ ret = dict_get_uint32(params, "opversion", &opversion);
+ if (ret) {
+ gf_msg(this->name, GF_LOG_INFO, 0, PS_MSG_CLIENT_OPVERSION_GET_FAILED,
+ "Failed to get client opversion");
+ }
+ client->opversion = opversion;
+ /* Assign op-version value to the client */
+ pthread_mutex_lock(&conf->mutex);
+ list_for_each_entry(xprt, &conf->xprt_list, list)
+ {
+ if (strcmp(peerinfo->identifier, xprt->peerinfo.identifier))
+ continue;
+ xprt->peerinfo.max_op_version = opversion;
+ }
+ pthread_mutex_unlock(&conf->mutex);
+
+ if (conf->auth_modules == NULL) {
+ gf_msg(this->name, GF_LOG_ERROR, 0, PS_MSG_AUTH_INIT_FAILED,
+ "Authentication module not initialized");
+ }
+
+ ret = dict_get_str(params, "client-version", &clnt_version);
+ if (ret)
+ gf_msg(this->name, GF_LOG_INFO, 0, PS_MSG_CLIENT_VERSION_NOT_SET,
+ "client-version not set, may be of older version");
+
+ ret = gf_authenticate(params, config_params, conf->auth_modules);
+
+ if (ret == AUTH_ACCEPT) {
+ /* Store options received from client side */
+ req->trans->clnt_options = dict_ref(params);
+
+ gf_msg(this->name, GF_LOG_INFO, 0, PS_MSG_CLIENT_ACCEPTED,
+ "accepted client from %s (version: %s)", client->client_uid,
+ (clnt_version) ? clnt_version : "old");
+
+ gf_event(EVENT_CLIENT_CONNECT,
+ "client_uid=%s;"
+ "client_identifier=%s;server_identifier=%s;"
+ "brick_path=%s;subdir_mount=%s",
+ client->client_uid, req->trans->peerinfo.identifier,
+ req->trans->myinfo.identifier, name, subdir_mount);
+
+ op_ret = 0;
+ client->bound_xl = xl;
+
+ /* Don't be confused by the below line (like how ERROR can
+ be Success), key checked on client is 'ERROR' and hence
+ we send 'Success' in this key */
+ ret = dict_set_str(reply, "ERROR", "Success");
+ if (ret < 0)
+ gf_msg_debug(this->name, 0,
+ "failed to set error "
+ "msg");
+ } else {
+ gf_event(EVENT_CLIENT_AUTH_REJECT,
+ "client_uid=%s;"
+ "client_identifier=%s;server_identifier=%s;"
+ "brick_path=%s",
+ client->client_uid, req->trans->peerinfo.identifier,
+ req->trans->myinfo.identifier, name);
+ gf_msg(this->name, GF_LOG_ERROR, EACCES, PS_MSG_AUTHENTICATE_ERROR,
+ "Cannot authenticate client"
+ " from %s %s",
+ client->client_uid, (clnt_version) ? clnt_version : "old");
+
+ op_ret = -1;
+ op_errno = EACCES;
+ ret = dict_set_str(reply, "ERROR", "Authentication failed");
+ if (ret < 0)
+ gf_msg_debug(this->name, 0,
+ "failed to set error "
+ "msg");
+ goto fail;
+ }
+
+ if (client->bound_xl == NULL) {
+ ret = dict_set_str(reply, "ERROR",
+ "Check volfile and handshake "
+ "options in protocol/client");
+ if (ret < 0)
+ gf_msg_debug(this->name, 0,
+ "failed to set error "
+ "msg");
+
+ op_ret = -1;
+ op_errno = EACCES;
+ goto fail;
+ }
+
+ LOCK(&conf->itable_lock);
+ {
+ if (client->bound_xl->itable == NULL) {
+ /* create inode table for this bound_xl, if one doesn't
+ already exist */
+
+ gf_msg_trace(this->name, 0,
+ "creating inode table with"
+ " lru_limit=%" PRId32 ", xlator=%s",
+ conf->inode_lru_limit, client->bound_xl->name);
+
+ /* TODO: what is this ? */
+ client->bound_xl->itable = inode_table_new(conf->inode_lru_limit,
+ client->bound_xl);
}
+ }
+ UNLOCK(&conf->itable_lock);
+
+ ret = dict_set_str(reply, "process-uuid", this->ctx->process_uuid);
+ if (ret)
+ gf_msg_debug(this->name, 0, "failed to set 'process-uuid'");
+
+ /* Insert a dummy key value pair to avoid failure at client side for
+ * clnt-lk-version with older clients.
+ */
+ ret = dict_set_uint32(reply, "clnt-lk-version", 0);
+ if (ret) {
+ gf_msg(this->name, GF_LOG_WARNING, 0, PS_MSG_CLIENT_LK_VERSION_ERROR,
+ "failed to set "
+ "'clnt-lk-version'");
+ }
+
+ ret = dict_set_uint64(reply, "transport-ptr", ((uint64_t)(long)req->trans));
+ if (ret)
+ gf_msg_debug(this->name, 0, "failed to set 'transport-ptr'");
- ret = dict_get_str (params, "client-version", &clnt_version);
- if (ret)
- gf_msg (this->name, GF_LOG_INFO, 0,
- PS_MSG_CLIENT_VERSION_NOT_SET,
- "client-version not set, may be of older version");
-
- ret = gf_authenticate (params, config_params,
- conf->auth_modules);
-
- if (ret == AUTH_ACCEPT) {
- /* Store options received from client side */
- req->trans->clnt_options = dict_ref(params);
-
- gf_msg (this->name, GF_LOG_INFO, 0, PS_MSG_CLIENT_ACCEPTED,
- "accepted client from %s (version: %s)",
- client->client_uid,
- (clnt_version) ? clnt_version : "old");
-
- gf_event (EVENT_CLIENT_CONNECT, "client_uid=%s;"
- "client_identifier=%s;server_identifier=%s;"
- "brick_path=%s;subdir_mount=%s",
- client->client_uid,
- req->trans->peerinfo.identifier,
- req->trans->myinfo.identifier,
- name, subdir_mount);
-
- op_ret = 0;
- client->bound_xl = xl;
-
- /* Don't be confused by the below line (like how ERROR can
- be Success), key checked on client is 'ERROR' and hence
- we send 'Success' in this key */
- ret = dict_set_str (reply, "ERROR", "Success");
- if (ret < 0)
- gf_msg_debug (this->name, 0, "failed to set error "
- "msg");
+fail:
+ /* It is important to validate the lookup on '/' as part of handshake,
+ because if lookup itself can't succeed, we should communicate this
+ to client. Very important in case of subdirectory mounts, where if
+ client is trying to mount a non-existing directory */
+ if (op_ret >= 0 && client->bound_xl->itable) {
+ if (client->bound_xl->cleanup_starting) {
+ op_ret = -1;
+ op_errno = EAGAIN;
+ ret = dict_set_str(reply, "ERROR",
+ "cleanup flag is set for xlator "
+ "before call first_lookup Try again later");
} else {
- gf_event (EVENT_CLIENT_AUTH_REJECT, "client_uid=%s;"
- "client_identifier=%s;server_identifier=%s;"
- "brick_path=%s",
- client->client_uid,
- req->trans->peerinfo.identifier,
- req->trans->myinfo.identifier,
- name);
- gf_msg (this->name, GF_LOG_ERROR, EACCES,
- PS_MSG_AUTHENTICATE_ERROR, "Cannot authenticate client"
- " from %s %s", client->client_uid,
- (clnt_version) ? clnt_version : "old");
-
- op_ret = -1;
- op_errno = EACCES;
- ret = dict_set_str (reply, "ERROR", "Authentication failed");
- if (ret < 0)
- gf_msg_debug (this->name, 0, "failed to set error "
- "msg");
- goto fail;
+ op_ret = server_first_lookup(this, client, reply);
+ if (op_ret == -1)
+ op_errno = ENOENT;
}
-
- if (client->bound_xl == NULL) {
- ret = dict_set_str (reply, "ERROR",
- "Check volfile and handshake "
- "options in protocol/client");
- if (ret < 0)
- gf_msg_debug (this->name, 0, "failed to set error "
- "msg");
-
+ }
+
+ rsp = GF_CALLOC(1, sizeof(gf_setvolume_rsp), gf_server_mt_setvolume_rsp_t);
+ GF_ASSERT(rsp);
+
+ rsp->op_ret = 0;
+ rsp->dict.dict_len = dict_serialized_length(reply);
+ if (rsp->dict.dict_len) {
+ rsp->dict.dict_val = GF_CALLOC(1, rsp->dict.dict_len,
+ gf_server_mt_rsp_buf_t);
+ if (rsp->dict.dict_val) {
+ ret = dict_serialize(reply, rsp->dict.dict_val);
+ if (ret < 0) {
+ gf_msg_debug("server-handshake", 0,
+ "failed "
+ "to serialize reply dict");
op_ret = -1;
- op_errno = EACCES;
- goto fail;
- }
-
- LOCK (&conf->itable_lock);
- {
- if (client->bound_xl->itable == NULL) {
- /* create inode table for this bound_xl, if one doesn't
- already exist */
-
- gf_msg_trace (this->name, 0, "creating inode table with"
- " lru_limit=%"PRId32", xlator=%s",
- conf->inode_lru_limit,
- client->bound_xl->name);
-
- /* TODO: what is this ? */
- client->bound_xl->itable =
- inode_table_new (conf->inode_lru_limit,
- client->bound_xl);
- }
+ op_errno = -ret;
+ }
}
- UNLOCK (&conf->itable_lock);
-
- ret = dict_set_str (reply, "process-uuid",
- this->ctx->process_uuid);
- if (ret)
- gf_msg_debug (this->name, 0, "failed to set 'process-uuid'");
-
- /* Insert a dummy key value pair to avoid failure at client side for
- * clnt-lk-version with older clients.
+ }
+ rsp->op_ret = op_ret;
+ rsp->op_errno = gf_errno_to_error(op_errno);
+
+ /* if bound_xl is NULL or something fails, then put the connection
+ * back. Otherwise the connection would have been added to the
+ * list of connections the server is maintaining and might segfault
+ * during statedump when bound_xl of the connection is accessed.
+ */
+ if (op_ret && !xl && (client != NULL)) {
+ /* We would have set the xl_private of the transport to the
+ * @conn. But if we have put the connection i.e shutting down
+ * the connection, then we should set xl_private to NULL as it
+ * would be pointing to a freed memory and would segfault when
+ * accessed upon getting DISCONNECT.
*/
- ret = dict_set_uint32 (reply, "clnt-lk-version", 0);
- if (ret) {
- gf_msg (this->name, GF_LOG_WARNING, 0,
- PS_MSG_CLIENT_LK_VERSION_ERROR, "failed to set "
- "'clnt-lk-version'");
- }
-
- ret = dict_set_uint64 (reply, "transport-ptr",
- ((uint64_t) (long) req->trans));
- if (ret)
- gf_msg_debug (this->name, 0, "failed to set 'transport-ptr'");
+ gf_client_put(client, NULL);
+ req->trans->xl_private = NULL;
+ }
-fail:
- /* It is important to validate the lookup on '/' as part of handshake,
- because if lookup itself can't succeed, we should communicate this
- to client. Very important in case of subdirectory mounts, where if
- client is trying to mount a non-existing directory */
- if (op_ret >= 0 && client->bound_xl->itable) {
- if (client->bound_xl->cleanup_starting) {
- op_ret = -1;
- op_errno = EAGAIN;
- ret = dict_set_str (reply, "ERROR",
- "cleanup flag is set for xlator "
- "before call first_lookup Try again later");
- } else {
- op_ret = server_first_lookup (this, client, reply);
- if (op_ret == -1)
- op_errno = ENOENT;
- }
- }
+ /* Send the response properly */
+ server_first_lookup_done(req, rsp);
- rsp = GF_CALLOC (1, sizeof (gf_setvolume_rsp),
- gf_server_mt_setvolume_rsp_t);
- GF_ASSERT (rsp);
-
- rsp->op_ret = 0;
- rsp->dict.dict_len = dict_serialized_length (reply);
- if (rsp->dict.dict_len) {
- rsp->dict.dict_val = GF_CALLOC (1, rsp->dict.dict_len,
- gf_server_mt_rsp_buf_t);
- if (rsp->dict.dict_val) {
- ret = dict_serialize (reply, rsp->dict.dict_val);
- if (ret < 0) {
- gf_msg_debug ("server-handshake", 0, "failed "
- "to serialize reply dict");
- op_ret = -1;
- op_errno = -ret;
- }
- }
- }
- rsp->op_ret = op_ret;
- rsp->op_errno = gf_errno_to_error (op_errno);
+ free(args.dict.dict_val);
- /* if bound_xl is NULL or something fails, then put the connection
- * back. Otherwise the connection would have been added to the
- * list of connections the server is maintaining and might segfault
- * during statedump when bound_xl of the connection is accessed.
+ dict_unref(params);
+ dict_unref(reply);
+ if (config_params) {
+ /*
+ * This might be null if we couldn't even find the translator
+ * (brick) to copy it from.
*/
- if (op_ret && !xl && (client != NULL)) {
- /* We would have set the xl_private of the transport to the
- * @conn. But if we have put the connection i.e shutting down
- * the connection, then we should set xl_private to NULL as it
- * would be pointing to a freed memory and would segfault when
- * accessed upon getting DISCONNECT.
- */
- gf_client_put (client, NULL);
- req->trans->xl_private = NULL;
- }
+ dict_unref(config_params);
+ }
- /* Send the response properly */
- server_first_lookup_done (req, rsp);
+ GF_FREE(buf);
- free (args.dict.dict_val);
-
- dict_unref (params);
- dict_unref (reply);
- if (config_params) {
- /*
- * This might be null if we couldn't even find the translator
- * (brick) to copy it from.
- */
- dict_unref (config_params);
- }
-
- GF_FREE (buf);
-
- return 0;
+ return 0;
}
-
int
-server_ping (rpcsvc_request_t *req)
+server_ping(rpcsvc_request_t *req)
{
- gf_common_rsp rsp = {0,};
+ gf_common_rsp rsp = {
+ 0,
+ };
- /* Accepted */
- rsp.op_ret = 0;
+ /* Accepted */
+ rsp.op_ret = 0;
- server_submit_reply (NULL, req, &rsp, NULL, 0, NULL,
- (xdrproc_t)xdr_gf_common_rsp);
+ server_submit_reply(NULL, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gf_common_rsp);
- return 0;
+ return 0;
}
int
-server_set_lk_version (rpcsvc_request_t *req)
+server_set_lk_version(rpcsvc_request_t *req)
{
- int ret = -1;
- gf_set_lk_ver_req args = {0,};
- gf_set_lk_ver_rsp rsp = {0,};
-
- ret = xdr_to_generic (req->msg[0], &args,
- (xdrproc_t)xdr_gf_set_lk_ver_req);
- if (ret < 0) {
- /* failed to decode msg */
- req->rpc_err = GARBAGE_ARGS;
- goto fail;
- }
-
- rsp.lk_ver = args.lk_ver;
+ int ret = -1;
+ gf_set_lk_ver_req args = {
+ 0,
+ };
+ gf_set_lk_ver_rsp rsp = {
+ 0,
+ };
+
+ ret = xdr_to_generic(req->msg[0], &args, (xdrproc_t)xdr_gf_set_lk_ver_req);
+ if (ret < 0) {
+ /* failed to decode msg */
+ req->rpc_err = GARBAGE_ARGS;
+ goto fail;
+ }
+
+ rsp.lk_ver = args.lk_ver;
fail:
- server_submit_reply (NULL, req, &rsp, NULL, 0, NULL,
- (xdrproc_t)xdr_gf_set_lk_ver_rsp);
+ server_submit_reply(NULL, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gf_set_lk_ver_rsp);
- free (args.uid);
+ free(args.uid);
- return 0;
+ return 0;
}
rpcsvc_actor_t gluster_handshake_actors[GF_HNDSK_MAXVALUE] = {
- [GF_HNDSK_NULL] = {"NULL", GF_HNDSK_NULL, server_null, NULL, 0, DRC_NA},
- [GF_HNDSK_SETVOLUME] = {"SETVOLUME", GF_HNDSK_SETVOLUME, server_setvolume, NULL, 0, DRC_NA},
- [GF_HNDSK_GETSPEC] = {"GETSPEC", GF_HNDSK_GETSPEC, server_getspec, NULL, 0, DRC_NA},
- [GF_HNDSK_PING] = {"PING", GF_HNDSK_PING, server_ping, NULL, 0, DRC_NA},
- [GF_HNDSK_SET_LK_VER] = {"SET_LK_VER", GF_HNDSK_SET_LK_VER, server_set_lk_version, NULL, 0, DRC_NA},
+ [GF_HNDSK_NULL] = {"NULL", GF_HNDSK_NULL, server_null, NULL, 0, DRC_NA},
+ [GF_HNDSK_SETVOLUME] = {"SETVOLUME", GF_HNDSK_SETVOLUME, server_setvolume,
+ NULL, 0, DRC_NA},
+ [GF_HNDSK_GETSPEC] = {"GETSPEC", GF_HNDSK_GETSPEC, server_getspec, NULL, 0,
+ DRC_NA},
+ [GF_HNDSK_PING] = {"PING", GF_HNDSK_PING, server_ping, NULL, 0, DRC_NA},
+ [GF_HNDSK_SET_LK_VER] = {"SET_LK_VER", GF_HNDSK_SET_LK_VER,
+ server_set_lk_version, NULL, 0, DRC_NA},
};
-
struct rpcsvc_program gluster_handshake_prog = {
- .progname = "GlusterFS Handshake",
- .prognum = GLUSTER_HNDSK_PROGRAM,
- .progver = GLUSTER_HNDSK_VERSION,
- .actors = gluster_handshake_actors,
- .numactors = GF_HNDSK_MAXVALUE,
+ .progname = "GlusterFS Handshake",
+ .prognum = GLUSTER_HNDSK_PROGRAM,
+ .progver = GLUSTER_HNDSK_VERSION,
+ .actors = gluster_handshake_actors,
+ .numactors = GF_HNDSK_MAXVALUE,
};
diff --git a/xlators/protocol/server/src/server-helpers.c b/xlators/protocol/server/src/server-helpers.c
index ce2097765b1..cb2a73c7168 100644
--- a/xlators/protocol/server/src/server-helpers.c
+++ b/xlators/protocol/server/src/server-helpers.c
@@ -23,5289 +23,4830 @@
/* based on nfs_fix_aux_groups() */
int
-gid_resolve (server_conf_t *conf, call_stack_t *root)
+gid_resolve(server_conf_t *conf, call_stack_t *root)
{
- int ret = 0;
- struct passwd mypw;
- char mystrs[1024];
- struct passwd *result;
- gid_t *mygroups = NULL;
- gid_list_t gl;
- int ngroups;
- const gid_list_t *agl;
-
- agl = gid_cache_lookup (&conf->gid_cache, root->uid, 0, 0);
- if (agl) {
- root->ngrps = agl->gl_count;
-
- if (root->ngrps > 0) {
- ret = call_stack_alloc_groups (root, agl->gl_count);
- if (ret == 0) {
- memcpy (root->groups, agl->gl_list,
- sizeof (gid_t) * agl->gl_count);
- }
- }
-
- gid_cache_release (&conf->gid_cache, agl);
+ int ret = 0;
+ struct passwd mypw;
+ char mystrs[1024];
+ struct passwd *result;
+ gid_t *mygroups = NULL;
+ gid_list_t gl;
+ int ngroups;
+ const gid_list_t *agl;
+
+ agl = gid_cache_lookup(&conf->gid_cache, root->uid, 0, 0);
+ if (agl) {
+ root->ngrps = agl->gl_count;
- return ret;
+ if (root->ngrps > 0) {
+ ret = call_stack_alloc_groups(root, agl->gl_count);
+ if (ret == 0) {
+ memcpy(root->groups, agl->gl_list,
+ sizeof(gid_t) * agl->gl_count);
+ }
}
- ret = getpwuid_r (root->uid, &mypw, mystrs, sizeof(mystrs), &result);
- if (ret != 0) {
- gf_msg ("gid-cache", GF_LOG_ERROR, errno,
- PS_MSG_GET_UID_FAILED, "getpwuid_r(%u) failed",
- root->uid);
- return -1;
- }
+ gid_cache_release(&conf->gid_cache, agl);
- if (!result) {
- gf_msg ("gid-cache", GF_LOG_ERROR, 0, PS_MSG_UID_NOT_FOUND,
- "getpwuid_r(%u) found nothing", root->uid);
- return -1;
- }
+ return ret;
+ }
- gf_msg_trace ("gid-cache", 0, "mapped %u => %s", root->uid,
- result->pw_name);
+ ret = getpwuid_r(root->uid, &mypw, mystrs, sizeof(mystrs), &result);
+ if (ret != 0) {
+ gf_msg("gid-cache", GF_LOG_ERROR, errno, PS_MSG_GET_UID_FAILED,
+ "getpwuid_r(%u) failed", root->uid);
+ return -1;
+ }
- ngroups = gf_getgrouplist (result->pw_name, root->gid, &mygroups);
- if (ngroups == -1) {
- gf_msg ("gid-cache", GF_LOG_ERROR, 0, PS_MSG_MAPPING_ERROR,
- "could not map %s to group list (%d gids)",
- result->pw_name, root->ngrps);
- return -1;
- }
- root->ngrps = (uint16_t) ngroups;
+ if (!result) {
+ gf_msg("gid-cache", GF_LOG_ERROR, 0, PS_MSG_UID_NOT_FOUND,
+ "getpwuid_r(%u) found nothing", root->uid);
+ return -1;
+ }
- /* setup a full gid_list_t to add it to the gid_cache */
- gl.gl_id = root->uid;
- gl.gl_uid = root->uid;
- gl.gl_gid = root->gid;
- gl.gl_count = root->ngrps;
+ gf_msg_trace("gid-cache", 0, "mapped %u => %s", root->uid, result->pw_name);
- gl.gl_list = GF_MALLOC (root->ngrps * sizeof(gid_t),
- gf_common_mt_groups_t);
- if (gl.gl_list)
- memcpy (gl.gl_list, mygroups,
- sizeof(gid_t) * root->ngrps);
- else {
- GF_FREE (mygroups);
- return -1;
- }
+ ngroups = gf_getgrouplist(result->pw_name, root->gid, &mygroups);
+ if (ngroups == -1) {
+ gf_msg("gid-cache", GF_LOG_ERROR, 0, PS_MSG_MAPPING_ERROR,
+ "could not map %s to group list (%d gids)", result->pw_name,
+ root->ngrps);
+ return -1;
+ }
+ root->ngrps = (uint16_t)ngroups;
+
+ /* setup a full gid_list_t to add it to the gid_cache */
+ gl.gl_id = root->uid;
+ gl.gl_uid = root->uid;
+ gl.gl_gid = root->gid;
+ gl.gl_count = root->ngrps;
+
+ gl.gl_list = GF_MALLOC(root->ngrps * sizeof(gid_t), gf_common_mt_groups_t);
+ if (gl.gl_list)
+ memcpy(gl.gl_list, mygroups, sizeof(gid_t) * root->ngrps);
+ else {
+ GF_FREE(mygroups);
+ return -1;
+ }
- if (root->ngrps > 0) {
- call_stack_set_groups (root, root->ngrps, &mygroups);
- }
+ if (root->ngrps > 0) {
+ call_stack_set_groups(root, root->ngrps, &mygroups);
+ }
- if (gid_cache_add (&conf->gid_cache, &gl) != 1)
- GF_FREE (gl.gl_list);
+ if (gid_cache_add(&conf->gid_cache, &gl) != 1)
+ GF_FREE(gl.gl_list);
- return ret;
+ return ret;
}
int
-server_resolve_groups (call_frame_t *frame, rpcsvc_request_t *req)
+server_resolve_groups(call_frame_t *frame, rpcsvc_request_t *req)
{
- xlator_t *this = NULL;
- server_conf_t *conf = NULL;
+ xlator_t *this = NULL;
+ server_conf_t *conf = NULL;
- GF_VALIDATE_OR_GOTO ("server", frame, out);
- GF_VALIDATE_OR_GOTO ("server", req, out);
+ GF_VALIDATE_OR_GOTO("server", frame, out);
+ GF_VALIDATE_OR_GOTO("server", req, out);
- this = req->trans->xl;
- conf = this->private;
+ this = req->trans->xl;
+ conf = this->private;
- return gid_resolve (conf, frame->root);
+ return gid_resolve(conf, frame->root);
out:
- return -1;
+ return -1;
}
int
-server_decode_groups (call_frame_t *frame, rpcsvc_request_t *req)
+server_decode_groups(call_frame_t *frame, rpcsvc_request_t *req)
{
- int i = 0;
+ int i = 0;
- GF_VALIDATE_OR_GOTO ("server", frame, out);
- GF_VALIDATE_OR_GOTO ("server", req, out);
+ GF_VALIDATE_OR_GOTO("server", frame, out);
+ GF_VALIDATE_OR_GOTO("server", req, out);
- if (call_stack_alloc_groups (frame->root, req->auxgidcount) != 0)
- return -1;
+ if (call_stack_alloc_groups(frame->root, req->auxgidcount) != 0)
+ return -1;
- frame->root->ngrps = req->auxgidcount;
- if (frame->root->ngrps == 0)
- return 0;
+ frame->root->ngrps = req->auxgidcount;
+ 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;
+ /* ngrps cannot be bigger than USHRT_MAX(65535) */
+ if (frame->root->ngrps > GF_MAX_AUX_GROUPS)
+ return -1;
- for (; i < frame->root->ngrps; ++i)
- frame->root->groups[i] = req->auxgids[i];
+ for (; i < frame->root->ngrps; ++i)
+ frame->root->groups[i] = req->auxgids[i];
out:
- return 0;
+ return 0;
}
-
void
-server_loc_wipe (loc_t *loc)
+server_loc_wipe(loc_t *loc)
{
- if (loc->parent) {
- inode_unref (loc->parent);
- loc->parent = NULL;
- }
+ if (loc->parent) {
+ inode_unref(loc->parent);
+ loc->parent = NULL;
+ }
- if (loc->inode) {
- inode_unref (loc->inode);
- loc->inode = NULL;
- }
+ if (loc->inode) {
+ inode_unref(loc->inode);
+ loc->inode = NULL;
+ }
- GF_FREE ((void *)loc->path);
+ GF_FREE((void *)loc->path);
}
-
void
-server_resolve_wipe (server_resolve_t *resolve)
+server_resolve_wipe(server_resolve_t *resolve)
{
- GF_FREE ((void *)resolve->path);
+ GF_FREE((void *)resolve->path);
- GF_FREE ((void *)resolve->bname);
+ GF_FREE((void *)resolve->bname);
- loc_wipe (&resolve->resolve_loc);
+ loc_wipe(&resolve->resolve_loc);
}
-
void
-free_state (server_state_t *state)
+free_state(server_state_t *state)
{
- if (state->fd) {
- fd_unref (state->fd);
- state->fd = NULL;
- }
-
- if (state->params) {
- dict_unref (state->params);
- state->params = NULL;
- }
-
- if (state->iobref) {
- iobref_unref (state->iobref);
- state->iobref = NULL;
- }
-
- if (state->iobuf) {
- iobuf_unref (state->iobuf);
- state->iobuf = NULL;
- }
-
- if (state->dict) {
- dict_unref (state->dict);
- state->dict = NULL;
- }
-
- if (state->xdata) {
- dict_unref (state->xdata);
- state->xdata = NULL;
- }
-
- GF_FREE ((void *)state->volume);
-
- GF_FREE ((void *)state->name);
-
- server_loc_wipe (&state->loc);
- server_loc_wipe (&state->loc2);
-
- server_resolve_wipe (&state->resolve);
- server_resolve_wipe (&state->resolve2);
-
- compound_args_cleanup (state->args);
-
- /* Call rpc_trnasport_unref to avoid crashes at last after free
- all resources because of server_rpc_notify (for transport destroy)
- call's xlator_mem_cleanup if all xprt are destroyed that internally
- call's inode_table_destroy.
- */
- if (state->xprt) {
- rpc_transport_unref (state->xprt);
- state->xprt = NULL;
- }
-
-
- GF_FREE (state);
+ if (state->fd) {
+ fd_unref(state->fd);
+ state->fd = NULL;
+ }
+
+ if (state->params) {
+ dict_unref(state->params);
+ state->params = NULL;
+ }
+
+ if (state->iobref) {
+ iobref_unref(state->iobref);
+ state->iobref = NULL;
+ }
+
+ if (state->iobuf) {
+ iobuf_unref(state->iobuf);
+ state->iobuf = NULL;
+ }
+
+ if (state->dict) {
+ dict_unref(state->dict);
+ state->dict = NULL;
+ }
+
+ if (state->xdata) {
+ dict_unref(state->xdata);
+ state->xdata = NULL;
+ }
+
+ GF_FREE((void *)state->volume);
+
+ GF_FREE((void *)state->name);
+
+ server_loc_wipe(&state->loc);
+ server_loc_wipe(&state->loc2);
+
+ server_resolve_wipe(&state->resolve);
+ server_resolve_wipe(&state->resolve2);
+
+ compound_args_cleanup(state->args);
+
+ /* Call rpc_trnasport_unref to avoid crashes at last after free
+ all resources because of server_rpc_notify (for transport destroy)
+ call's xlator_mem_cleanup if all xprt are destroyed that internally
+ call's inode_table_destroy.
+ */
+ if (state->xprt) {
+ rpc_transport_unref(state->xprt);
+ state->xprt = NULL;
+ }
+
+ GF_FREE(state);
}
-
static int
-server_connection_cleanup_flush_cbk (call_frame_t *frame, void *cookie,
- xlator_t *this, int32_t op_ret,
- int32_t op_errno, dict_t *xdata)
+server_connection_cleanup_flush_cbk(call_frame_t *frame, void *cookie,
+ xlator_t *this, int32_t op_ret,
+ int32_t op_errno, dict_t *xdata)
{
- int32_t ret = -1;
- fd_t *fd = NULL;
- client_t *client = NULL;
+ int32_t ret = -1;
+ fd_t *fd = NULL;
+ client_t *client = NULL;
- GF_VALIDATE_OR_GOTO ("server", this, out);
- GF_VALIDATE_OR_GOTO ("server", frame, out);
+ GF_VALIDATE_OR_GOTO("server", this, out);
+ GF_VALIDATE_OR_GOTO("server", frame, out);
- fd = frame->local;
- client = frame->root->client;
+ fd = frame->local;
+ client = frame->root->client;
- fd_unref (fd);
- frame->local = NULL;
+ fd_unref(fd);
+ frame->local = NULL;
- gf_client_unref (client);
- STACK_DESTROY (frame->root);
+ gf_client_unref(client);
+ STACK_DESTROY(frame->root);
- ret = 0;
+ ret = 0;
out:
- return ret;
+ return ret;
}
-
static int
-do_fd_cleanup (xlator_t *this, client_t* client, fdentry_t *fdentries, int fd_count)
+do_fd_cleanup(xlator_t *this, client_t *client, fdentry_t *fdentries,
+ int fd_count)
{
- fd_t *fd = NULL;
- int i = 0, ret = -1;
- call_frame_t *tmp_frame = NULL;
- xlator_t *bound_xl = NULL;
- char *path = NULL;
-
- GF_VALIDATE_OR_GOTO ("server", this, out);
- GF_VALIDATE_OR_GOTO ("server", fdentries, out);
-
- bound_xl = client->bound_xl;
- for (i = 0;i < fd_count; i++) {
- fd = fdentries[i].fd;
-
- if (fd != NULL) {
- tmp_frame = create_frame (this, this->ctx->pool);
- if (tmp_frame == NULL) {
- goto out;
- }
-
- GF_ASSERT (fd->inode);
-
- ret = inode_path (fd->inode, NULL, &path);
-
- if (ret > 0) {
- gf_msg (this->name, GF_LOG_INFO, 0,
- PS_MSG_FD_CLEANUP,
- "fd cleanup on %s", path);
- GF_FREE (path);
- } else {
-
- gf_msg (this->name, GF_LOG_INFO, 0,
- PS_MSG_FD_CLEANUP,
- "fd cleanup on inode with gfid %s",
- uuid_utoa (fd->inode->gfid));
- }
-
- tmp_frame->local = fd;
- tmp_frame->root->pid = 0;
- gf_client_ref (client);
- tmp_frame->root->client = client;
- memset (&tmp_frame->root->lk_owner, 0,
- sizeof (gf_lkowner_t));
-
- STACK_WIND (tmp_frame,
- server_connection_cleanup_flush_cbk,
- bound_xl, bound_xl->fops->flush, fd, NULL);
- }
- }
+ fd_t *fd = NULL;
+ int i = 0, ret = -1;
+ call_frame_t *tmp_frame = NULL;
+ xlator_t *bound_xl = NULL;
+ char *path = NULL;
+
+ GF_VALIDATE_OR_GOTO("server", this, out);
+ GF_VALIDATE_OR_GOTO("server", fdentries, out);
+
+ bound_xl = client->bound_xl;
+ for (i = 0; i < fd_count; i++) {
+ fd = fdentries[i].fd;
+
+ if (fd != NULL) {
+ tmp_frame = create_frame(this, this->ctx->pool);
+ if (tmp_frame == NULL) {
+ goto out;
+ }
- GF_FREE (fdentries);
- ret = 0;
+ GF_ASSERT(fd->inode);
-out:
- return ret;
-}
+ ret = inode_path(fd->inode, NULL, &path);
+ if (ret > 0) {
+ gf_msg(this->name, GF_LOG_INFO, 0, PS_MSG_FD_CLEANUP,
+ "fd cleanup on %s", path);
+ GF_FREE(path);
+ } else {
+ gf_msg(this->name, GF_LOG_INFO, 0, PS_MSG_FD_CLEANUP,
+ "fd cleanup on inode with gfid %s",
+ uuid_utoa(fd->inode->gfid));
+ }
-int
-server_connection_cleanup (xlator_t *this, client_t *client,
- int32_t flags)
-{
- server_ctx_t *serv_ctx = NULL;
- fdentry_t *fdentries = NULL;
- uint32_t fd_count = 0;
- int cd_ret = 0;
- int ret = 0;
-
- GF_VALIDATE_OR_GOTO ("server", this, out);
- GF_VALIDATE_OR_GOTO (this->name, client, out);
- GF_VALIDATE_OR_GOTO (this->name, flags, out);
-
- serv_ctx = server_ctx_get (client, client->this);
-
- if (serv_ctx == NULL) {
- gf_msg (this->name, GF_LOG_INFO, 0,
- PS_MSG_SERVER_CTX_GET_FAILED, "server_ctx_get() "
- "failed");
- goto out;
- }
+ tmp_frame->local = fd;
+ tmp_frame->root->pid = 0;
+ gf_client_ref(client);
+ tmp_frame->root->client = client;
+ memset(&tmp_frame->root->lk_owner, 0, sizeof(gf_lkowner_t));
- LOCK (&serv_ctx->fdtable_lock);
- {
- if (serv_ctx->fdtable && (flags & POSIX_LOCKS))
- fdentries = gf_fd_fdtable_get_all_fds (serv_ctx->fdtable,
- &fd_count);
+ STACK_WIND(tmp_frame, server_connection_cleanup_flush_cbk, bound_xl,
+ bound_xl->fops->flush, fd, NULL);
}
- UNLOCK (&serv_ctx->fdtable_lock);
+ }
- if (client->bound_xl == NULL)
- goto out;
+ GF_FREE(fdentries);
+ ret = 0;
- if (flags & INTERNAL_LOCKS) {
- cd_ret = gf_client_disconnect (client);
- }
-
- if (fdentries != NULL) {
- gf_msg_debug (this->name, 0, "Performing cleanup on %d "
- "fdentries", fd_count);
- ret = do_fd_cleanup (this, client, fdentries, fd_count);
- }
- else
- gf_msg (this->name, GF_LOG_INFO, 0, PS_MSG_FDENTRY_NULL,
- "no fdentries to clean");
+out:
+ return ret;
+}
- if (cd_ret || ret)
- ret = -1;
+int
+server_connection_cleanup(xlator_t *this, client_t *client, int32_t flags)
+{
+ server_ctx_t *serv_ctx = NULL;
+ fdentry_t *fdentries = NULL;
+ uint32_t fd_count = 0;
+ int cd_ret = 0;
+ int ret = 0;
+
+ GF_VALIDATE_OR_GOTO("server", this, out);
+ GF_VALIDATE_OR_GOTO(this->name, client, out);
+ GF_VALIDATE_OR_GOTO(this->name, flags, out);
+
+ serv_ctx = server_ctx_get(client, client->this);
+
+ if (serv_ctx == NULL) {
+ gf_msg(this->name, GF_LOG_INFO, 0, PS_MSG_SERVER_CTX_GET_FAILED,
+ "server_ctx_get() "
+ "failed");
+ goto out;
+ }
+
+ LOCK(&serv_ctx->fdtable_lock);
+ {
+ if (serv_ctx->fdtable && (flags & POSIX_LOCKS))
+ fdentries = gf_fd_fdtable_get_all_fds(serv_ctx->fdtable, &fd_count);
+ }
+ UNLOCK(&serv_ctx->fdtable_lock);
+
+ if (client->bound_xl == NULL)
+ goto out;
+
+ if (flags & INTERNAL_LOCKS) {
+ cd_ret = gf_client_disconnect(client);
+ }
+
+ if (fdentries != NULL) {
+ gf_msg_debug(this->name, 0,
+ "Performing cleanup on %d "
+ "fdentries",
+ fd_count);
+ ret = do_fd_cleanup(this, client, fdentries, fd_count);
+ } else
+ gf_msg(this->name, GF_LOG_INFO, 0, PS_MSG_FDENTRY_NULL,
+ "no fdentries to clean");
+
+ if (cd_ret || ret)
+ ret = -1;
out:
- return ret;
+ return ret;
}
-
static call_frame_t *
-server_alloc_frame (rpcsvc_request_t *req)
+server_alloc_frame(rpcsvc_request_t *req)
{
- call_frame_t *frame = NULL;
- server_state_t *state = NULL;
- client_t *client = NULL;
+ call_frame_t *frame = NULL;
+ server_state_t *state = NULL;
+ client_t *client = NULL;
- GF_VALIDATE_OR_GOTO ("server", req, out);
- GF_VALIDATE_OR_GOTO ("server", req->trans, out);
- GF_VALIDATE_OR_GOTO ("server", req->svc, out);
- GF_VALIDATE_OR_GOTO ("server", req->svc->ctx, out);
+ GF_VALIDATE_OR_GOTO("server", req, out);
+ GF_VALIDATE_OR_GOTO("server", req->trans, out);
+ GF_VALIDATE_OR_GOTO("server", req->svc, out);
+ GF_VALIDATE_OR_GOTO("server", req->svc->ctx, out);
- client = req->trans->xl_private;
- GF_VALIDATE_OR_GOTO ("server", client, out);
+ client = req->trans->xl_private;
+ GF_VALIDATE_OR_GOTO("server", client, out);
- frame = create_frame (client->this, req->svc->ctx->pool);
- if (!frame)
- goto out;
+ frame = create_frame(client->this, req->svc->ctx->pool);
+ if (!frame)
+ goto out;
- state = GF_CALLOC (1, sizeof (*state), gf_server_mt_state_t);
- if (!state)
- goto out;
+ state = GF_CALLOC(1, sizeof(*state), gf_server_mt_state_t);
+ if (!state)
+ goto out;
- if (client->bound_xl)
- state->itable = client->bound_xl->itable;
+ if (client->bound_xl)
+ state->itable = client->bound_xl->itable;
- state->xprt = rpc_transport_ref (req->trans);
- state->resolve.fd_no = -1;
- state->resolve2.fd_no = -1;
+ state->xprt = rpc_transport_ref(req->trans);
+ state->resolve.fd_no = -1;
+ state->resolve2.fd_no = -1;
- frame->root->client = client;
- frame->root->state = state; /* which socket */
- frame->root->unique = 0; /* which call */
+ frame->root->client = client;
+ frame->root->state = state; /* which socket */
+ frame->root->unique = 0; /* which call */
- frame->this = client->this;
+ frame->this = client->this;
out:
- return frame;
+ return frame;
}
-
call_frame_t *
-get_frame_from_request (rpcsvc_request_t *req)
+get_frame_from_request(rpcsvc_request_t *req)
{
- call_frame_t *frame = NULL;
- client_t *client = NULL;
- client_t *tmp_client = NULL;
- xlator_t *this = NULL;
- server_conf_t *priv = NULL;
- clienttable_t *clienttable = NULL;
- unsigned int i = 0;
- rpc_transport_t *trans = NULL;
- server_state_t *state = NULL;
-
- GF_VALIDATE_OR_GOTO ("server", req, out);
-
- client = req->trans->xl_private;
-
- frame = server_alloc_frame (req);
- if (!frame)
- goto out;
-
- frame->root->op = req->procnum;
-
- frame->root->unique = req->xid;
-
- client = req->trans->xl_private;
- this = req->trans->xl;
- priv = this->private;
- clienttable = this->ctx->clienttable;
-
- for (i = 0; i < clienttable->max_clients; i++) {
- tmp_client = clienttable->cliententries[i].client;
- if (client == tmp_client) {
- /* for non trusted clients username and password
- would not have been set. So for non trusted clients
- (i.e clients not from the same machine as the brick,
- and clients from outside the storage pool)
- do the root-squashing.
- TODO: If any client within the storage pool (i.e
- mounting within a machine from the pool but using
- other machine's ip/hostname from the same pool)
- is present treat it as a trusted client
- */
- if (!client->auth.username && req->pid != NFS_PID)
- RPC_AUTH_ROOT_SQUASH (req);
-
- /* Problem: If we just check whether the client is
- trusted client and do not do root squashing for
- them, then for smb clients and UFO clients root
- squashing will never happen as they use the fuse
- mounts done within the trusted pool (i.e they are
- trusted clients).
- Solution: To fix it, do root squashing for trusted
- clients also. If one wants to have a client within
- the storage pool for which root-squashing does not
- happen, then the client has to be mounted with
- --no-root-squash option. But for defrag client and
- gsyncd client do not do root-squashing.
- */
- if (client->auth.username &&
- req->pid != GF_CLIENT_PID_NO_ROOT_SQUASH &&
- req->pid != GF_CLIENT_PID_GSYNCD &&
- req->pid != GF_CLIENT_PID_DEFRAG &&
- req->pid != GF_CLIENT_PID_SELF_HEALD &&
- req->pid != GF_CLIENT_PID_QUOTA_MOUNT)
- RPC_AUTH_ROOT_SQUASH (req);
-
- /* For nfs clients the server processes will be running
- within the trusted storage pool machines. So if we
- do not do root-squashing for nfs servers, thinking
- that its a trusted client, then root-squashing won't
- work for nfs clients.
- */
- if (req->pid == NFS_PID)
- RPC_AUTH_ROOT_SQUASH (req);
- }
- }
-
- /* Add a ref for this fop */
- if (client)
- gf_client_ref (client);
-
- frame->root->uid = req->uid;
- frame->root->gid = req->gid;
- frame->root->pid = req->pid;
- frame->root->client = client;
- frame->root->lk_owner = req->lk_owner;
-
- if (priv->server_manage_gids)
- server_resolve_groups (frame, req);
- else
- server_decode_groups (frame, req);
- trans = req->trans;
- if (trans) {
- memcpy (&frame->root->identifier, trans->peerinfo.identifier,
- sizeof (trans->peerinfo.identifier));
- }
-
- /* more fields, for the clients which are 3.x series this will be 0 */
- frame->root->flags = req->flags;
- frame->root->ctime = req->ctime;
-
- frame->local = req;
-
- state = CALL_STATE (frame);
- state->client = client;
+ call_frame_t *frame = NULL;
+ client_t *client = NULL;
+ client_t *tmp_client = NULL;
+ xlator_t *this = NULL;
+ server_conf_t *priv = NULL;
+ clienttable_t *clienttable = NULL;
+ unsigned int i = 0;
+ rpc_transport_t *trans = NULL;
+ server_state_t *state = NULL;
+
+ GF_VALIDATE_OR_GOTO("server", req, out);
+
+ client = req->trans->xl_private;
+
+ frame = server_alloc_frame(req);
+ if (!frame)
+ goto out;
+
+ frame->root->op = req->procnum;
+
+ frame->root->unique = req->xid;
+
+ client = req->trans->xl_private;
+ this = req->trans->xl;
+ priv = this->private;
+ clienttable = this->ctx->clienttable;
+
+ for (i = 0; i < clienttable->max_clients; i++) {
+ tmp_client = clienttable->cliententries[i].client;
+ if (client == tmp_client) {
+ /* for non trusted clients username and password
+ would not have been set. So for non trusted clients
+ (i.e clients not from the same machine as the brick,
+ and clients from outside the storage pool)
+ do the root-squashing.
+ TODO: If any client within the storage pool (i.e
+ mounting within a machine from the pool but using
+ other machine's ip/hostname from the same pool)
+ is present treat it as a trusted client
+ */
+ if (!client->auth.username && req->pid != NFS_PID)
+ RPC_AUTH_ROOT_SQUASH(req);
+
+ /* Problem: If we just check whether the client is
+ trusted client and do not do root squashing for
+ them, then for smb clients and UFO clients root
+ squashing will never happen as they use the fuse
+ mounts done within the trusted pool (i.e they are
+ trusted clients).
+ Solution: To fix it, do root squashing for trusted
+ clients also. If one wants to have a client within
+ the storage pool for which root-squashing does not
+ happen, then the client has to be mounted with
+ --no-root-squash option. But for defrag client and
+ gsyncd client do not do root-squashing.
+ */
+ if (client->auth.username &&
+ req->pid != GF_CLIENT_PID_NO_ROOT_SQUASH &&
+ req->pid != GF_CLIENT_PID_GSYNCD &&
+ req->pid != GF_CLIENT_PID_DEFRAG &&
+ req->pid != GF_CLIENT_PID_SELF_HEALD &&
+ req->pid != GF_CLIENT_PID_QUOTA_MOUNT)
+ RPC_AUTH_ROOT_SQUASH(req);
+
+ /* For nfs clients the server processes will be running
+ within the trusted storage pool machines. So if we
+ do not do root-squashing for nfs servers, thinking
+ that its a trusted client, then root-squashing won't
+ work for nfs clients.
+ */
+ if (req->pid == NFS_PID)
+ RPC_AUTH_ROOT_SQUASH(req);
+ }
+ }
+
+ /* Add a ref for this fop */
+ if (client)
+ gf_client_ref(client);
+
+ frame->root->uid = req->uid;
+ frame->root->gid = req->gid;
+ frame->root->pid = req->pid;
+ frame->root->client = client;
+ frame->root->lk_owner = req->lk_owner;
+
+ if (priv->server_manage_gids)
+ server_resolve_groups(frame, req);
+ else
+ server_decode_groups(frame, req);
+ trans = req->trans;
+ if (trans) {
+ memcpy(&frame->root->identifier, trans->peerinfo.identifier,
+ sizeof(trans->peerinfo.identifier));
+ }
+
+ /* more fields, for the clients which are 3.x series this will be 0 */
+ frame->root->flags = req->flags;
+ frame->root->ctime = req->ctime;
+
+ frame->local = req;
+
+ state = CALL_STATE(frame);
+ state->client = client;
out:
- return frame;
+ return frame;
}
-
int
-server_build_config (xlator_t *this, server_conf_t *conf)
+server_build_config(xlator_t *this, server_conf_t *conf)
{
- data_t *data = NULL;
- int ret = -1;
- struct stat buf = {0,};
-
- GF_VALIDATE_OR_GOTO ("server", this, out);
- GF_VALIDATE_OR_GOTO ("server", conf, out);
-
- ret = dict_get_int32 (this->options, "inode-lru-limit",
- &conf->inode_lru_limit);
- if (ret < 0) {
- conf->inode_lru_limit = 16384;
- }
-
- conf->verify_volfile = 1;
- data = dict_get (this->options, "verify-volfile-checksum");
- if (data) {
- ret = gf_string2boolean(data->data, &conf->verify_volfile);
- if (ret != 0) {
- gf_msg (this->name, GF_LOG_WARNING, EINVAL,
- PS_MSG_INVALID_ENTRY, "wrong value for '"
- "verify-volfile-checksum', Neglecting option");
- }
- }
-
- data = dict_get (this->options, "trace");
- if (data) {
- ret = gf_string2boolean (data->data, &conf->trace);
- if (ret != 0) {
- gf_msg (this->name, GF_LOG_WARNING, EINVAL,
- PS_MSG_INVALID_ENTRY, "'trace' takes on only "
- "boolean values. Neglecting option");
- }
+ data_t *data = NULL;
+ int ret = -1;
+ struct stat buf = {
+ 0,
+ };
+
+ GF_VALIDATE_OR_GOTO("server", this, out);
+ GF_VALIDATE_OR_GOTO("server", conf, out);
+
+ ret = dict_get_int32(this->options, "inode-lru-limit",
+ &conf->inode_lru_limit);
+ if (ret < 0) {
+ conf->inode_lru_limit = 16384;
+ }
+
+ conf->verify_volfile = 1;
+ data = dict_get(this->options, "verify-volfile-checksum");
+ if (data) {
+ ret = gf_string2boolean(data->data, &conf->verify_volfile);
+ if (ret != 0) {
+ gf_msg(this->name, GF_LOG_WARNING, EINVAL, PS_MSG_INVALID_ENTRY,
+ "wrong value for '"
+ "verify-volfile-checksum', Neglecting option");
}
+ }
- /* TODO: build_rpc_config (); */
- ret = dict_get_int32 (this->options, "limits.transaction-size",
- &conf->rpc_conf.max_block_size);
- if (ret < 0) {
- gf_msg_trace (this->name, 0, "defaulting limits.transaction-"
- "size to %d", DEFAULT_BLOCK_SIZE);
- conf->rpc_conf.max_block_size = DEFAULT_BLOCK_SIZE;
- }
-
- data = dict_get (this->options, "config-directory");
- if (data) {
- /* Check whether the specified directory exists,
- or directory specified is non standard */
- ret = sys_stat (data->data, &buf);
- if ((ret != 0) || !S_ISDIR (buf.st_mode)) {
- gf_msg (this->name, GF_LOG_ERROR, 0,
- PS_MSG_DIR_NOT_FOUND, "Directory '%s' doesn't "
- "exist, exiting.", data->data);
- ret = -1;
- goto out;
- }
- /* Make sure that conf-dir doesn't contain ".." in path */
- if ((gf_strstr (data->data, "/", "..")) == -1) {
- ret = -1;
- gf_msg (this->name, GF_LOG_ERROR, 0,
- PS_MSG_CONF_DIR_INVALID,
- "%s: invalid conf_dir", data->data);
- goto out;
- }
-
- conf->conf_dir = gf_strdup (data->data);
- }
- ret = 0;
+ data = dict_get(this->options, "trace");
+ if (data) {
+ ret = gf_string2boolean(data->data, &conf->trace);
+ if (ret != 0) {
+ gf_msg(this->name, GF_LOG_WARNING, EINVAL, PS_MSG_INVALID_ENTRY,
+ "'trace' takes on only "
+ "boolean values. Neglecting option");
+ }
+ }
+
+ /* TODO: build_rpc_config (); */
+ ret = dict_get_int32(this->options, "limits.transaction-size",
+ &conf->rpc_conf.max_block_size);
+ if (ret < 0) {
+ gf_msg_trace(this->name, 0,
+ "defaulting limits.transaction-"
+ "size to %d",
+ DEFAULT_BLOCK_SIZE);
+ conf->rpc_conf.max_block_size = DEFAULT_BLOCK_SIZE;
+ }
+
+ data = dict_get(this->options, "config-directory");
+ if (data) {
+ /* Check whether the specified directory exists,
+ or directory specified is non standard */
+ ret = sys_stat(data->data, &buf);
+ if ((ret != 0) || !S_ISDIR(buf.st_mode)) {
+ gf_msg(this->name, GF_LOG_ERROR, 0, PS_MSG_DIR_NOT_FOUND,
+ "Directory '%s' doesn't "
+ "exist, exiting.",
+ data->data);
+ ret = -1;
+ goto out;
+ }
+ /* Make sure that conf-dir doesn't contain ".." in path */
+ if ((gf_strstr(data->data, "/", "..")) == -1) {
+ ret = -1;
+ gf_msg(this->name, GF_LOG_ERROR, 0, PS_MSG_CONF_DIR_INVALID,
+ "%s: invalid conf_dir", data->data);
+ goto out;
+ }
+
+ conf->conf_dir = gf_strdup(data->data);
+ }
+ ret = 0;
out:
- return ret;
+ return ret;
}
-
void
-print_caller (char *str, int size, call_frame_t *frame)
+print_caller(char *str, int size, call_frame_t *frame)
{
- server_state_t *state = NULL;
+ server_state_t *state = NULL;
- GF_VALIDATE_OR_GOTO ("server", str, out);
- GF_VALIDATE_OR_GOTO ("server", frame, out);
+ GF_VALIDATE_OR_GOTO("server", str, out);
+ GF_VALIDATE_OR_GOTO("server", frame, out);
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- snprintf (str, size,
- " Callid=%"PRId64", Client=%s",
- frame->root->unique,
- state->xprt->peerinfo.identifier);
+ snprintf(str, size, " Callid=%" PRId64 ", Client=%s", frame->root->unique,
+ state->xprt->peerinfo.identifier);
out:
- return;
+ return;
}
-
void
-server_print_resolve (char *str, int size, server_resolve_t *resolve)
+server_print_resolve(char *str, int size, server_resolve_t *resolve)
{
- int filled = 0;
+ int filled = 0;
- GF_VALIDATE_OR_GOTO ("server", str, out);
+ GF_VALIDATE_OR_GOTO("server", str, out);
- if (!resolve) {
- snprintf (str, size, "<nul>");
- return;
- }
-
- filled += snprintf (str + filled, size - filled,
- " Resolve={");
- if (resolve->fd_no != -1)
- filled += snprintf (str + filled, size - filled,
- "fd=%"PRId64",", (uint64_t) resolve->fd_no);
- if (resolve->bname)
- filled += snprintf (str + filled, size - filled,
- "bname=%s,", resolve->bname);
- if (resolve->path)
- filled += snprintf (str + filled, size - filled,
- "path=%s", resolve->path);
-
- snprintf (str + filled, size - filled, "}");
-out:
+ if (!resolve) {
+ snprintf(str, size, "<nul>");
return;
+ }
+
+ filled += snprintf(str + filled, size - filled, " Resolve={");
+ if (resolve->fd_no != -1)
+ filled += snprintf(str + filled, size - filled, "fd=%" PRId64 ",",
+ (uint64_t)resolve->fd_no);
+ if (resolve->bname)
+ filled += snprintf(str + filled, size - filled, "bname=%s,",
+ resolve->bname);
+ if (resolve->path)
+ filled += snprintf(str + filled, size - filled, "path=%s",
+ resolve->path);
+
+ snprintf(str + filled, size - filled, "}");
+out:
+ return;
}
-
void
-server_print_loc (char *str, int size, loc_t *loc)
+server_print_loc(char *str, int size, loc_t *loc)
{
- int filled = 0;
+ int filled = 0;
- GF_VALIDATE_OR_GOTO ("server", str, out);
+ GF_VALIDATE_OR_GOTO("server", str, out);
- if (!loc) {
- snprintf (str, size, "<nul>");
- return;
- }
+ if (!loc) {
+ snprintf(str, size, "<nul>");
+ return;
+ }
- filled += snprintf (str + filled, size - filled,
- " Loc={");
+ filled += snprintf(str + filled, size - filled, " Loc={");
- if (loc->path)
- filled += snprintf (str + filled, size - filled,
- "path=%s,", loc->path);
- if (loc->inode)
- filled += snprintf (str + filled, size - filled,
- "inode=%p,", loc->inode);
- if (loc->parent)
- filled += snprintf (str + filled, size - filled,
- "parent=%p", loc->parent);
+ if (loc->path)
+ filled += snprintf(str + filled, size - filled, "path=%s,", loc->path);
+ if (loc->inode)
+ filled += snprintf(str + filled, size - filled, "inode=%p,",
+ loc->inode);
+ if (loc->parent)
+ filled += snprintf(str + filled, size - filled, "parent=%p",
+ loc->parent);
- snprintf (str + filled, size - filled, "}");
+ snprintf(str + filled, size - filled, "}");
out:
- return;
+ return;
}
-
void
-server_print_params (char *str, int size, server_state_t *state)
+server_print_params(char *str, int size, server_state_t *state)
{
- int filled = 0;
-
- GF_VALIDATE_OR_GOTO ("server", str, out);
-
- filled += snprintf (str + filled, size - filled,
- " Params={");
-
- if (state->fd)
- filled += snprintf (str + filled, size - filled,
- "fd=%p,", state->fd);
- if (state->valid)
- filled += snprintf (str + filled, size - filled,
- "valid=%d,", state->valid);
- if (state->flags)
- filled += snprintf (str + filled, size - filled,
- "flags=%d,", state->flags);
- if (state->wbflags)
- filled += snprintf (str + filled, size - filled,
- "wbflags=%d,", state->wbflags);
- if (state->size)
- filled += snprintf (str + filled, size - filled,
- "size=%zu,", state->size);
- if (state->offset)
- filled += snprintf (str + filled, size - filled,
- "offset=%"PRId64",", state->offset);
- if (state->cmd)
- filled += snprintf (str + filled, size - filled,
- "cmd=%d,", state->cmd);
- if (state->type)
- filled += snprintf (str + filled, size - filled,
- "type=%d,", state->type);
- if (state->name)
- filled += snprintf (str + filled, size - filled,
- "name=%s,", state->name);
- if (state->mask)
- filled += snprintf (str + filled, size - filled,
- "mask=%d,", state->mask);
- if (state->volume)
- filled += snprintf (str + filled, size - filled,
- "volume=%s,", state->volume);
+ int filled = 0;
+
+ GF_VALIDATE_OR_GOTO("server", str, out);
+
+ filled += snprintf(str + filled, size - filled, " Params={");
+
+ if (state->fd)
+ filled += snprintf(str + filled, size - filled, "fd=%p,", state->fd);
+ if (state->valid)
+ filled += snprintf(str + filled, size - filled, "valid=%d,",
+ state->valid);
+ if (state->flags)
+ filled += snprintf(str + filled, size - filled, "flags=%d,",
+ state->flags);
+ if (state->wbflags)
+ filled += snprintf(str + filled, size - filled, "wbflags=%d,",
+ state->wbflags);
+ if (state->size)
+ filled += snprintf(str + filled, size - filled, "size=%zu,",
+ state->size);
+ if (state->offset)
+ filled += snprintf(str + filled, size - filled, "offset=%" PRId64 ",",
+ state->offset);
+ if (state->cmd)
+ filled += snprintf(str + filled, size - filled, "cmd=%d,", state->cmd);
+ if (state->type)
+ filled += snprintf(str + filled, size - filled, "type=%d,",
+ state->type);
+ if (state->name)
+ filled += snprintf(str + filled, size - filled, "name=%s,",
+ state->name);
+ if (state->mask)
+ filled += snprintf(str + filled, size - filled, "mask=%d,",
+ state->mask);
+ if (state->volume)
+ filled += snprintf(str + filled, size - filled, "volume=%s,",
+ state->volume);
/* FIXME
snprintf (str + filled, size - filled,
"bound_xl=%s}", state->client->bound_xl->name);
*/
out:
- return;
+ return;
}
-
int
-server_resolve_is_empty (server_resolve_t *resolve)
+server_resolve_is_empty(server_resolve_t *resolve)
{
- if (resolve->fd_no != -1)
- return 0;
+ if (resolve->fd_no != -1)
+ return 0;
- if (resolve->path != 0)
- return 0;
+ if (resolve->path != 0)
+ return 0;
- if (resolve->bname != 0)
- return 0;
+ if (resolve->bname != 0)
+ return 0;
- return 1;
+ return 1;
}
-
void
-server_print_reply (call_frame_t *frame, int op_ret, int op_errno)
+server_print_reply(call_frame_t *frame, int op_ret, int op_errno)
{
- server_conf_t *conf = NULL;
- server_state_t *state = NULL;
- xlator_t *this = NULL;
- char caller[512];
- char fdstr[32];
- char *op = "UNKNOWN";
+ server_conf_t *conf = NULL;
+ server_state_t *state = NULL;
+ xlator_t *this = NULL;
+ char caller[512];
+ char fdstr[32];
+ char *op = "UNKNOWN";
- GF_VALIDATE_OR_GOTO ("server", frame, out);
+ GF_VALIDATE_OR_GOTO("server", frame, out);
- this = frame->this;
- conf = this->private;
+ this = frame->this;
+ conf = this->private;
- GF_VALIDATE_OR_GOTO ("server", conf, out);
- GF_VALIDATE_OR_GOTO ("server", conf->trace, out);
+ GF_VALIDATE_OR_GOTO("server", conf, out);
+ GF_VALIDATE_OR_GOTO("server", conf->trace, out);
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- print_caller (caller, 256, frame);
+ print_caller(caller, 256, frame);
- switch (frame->root->type) {
+ switch (frame->root->type) {
case GF_OP_TYPE_FOP:
- op = (char *)gf_fop_list[frame->root->op];
- break;
+ op = (char *)gf_fop_list[frame->root->op];
+ break;
default:
- op = "";
- }
+ op = "";
+ }
- fdstr[0] = '\0';
- if (state->fd)
- snprintf (fdstr, 32, " fd=%p", state->fd);
+ fdstr[0] = '\0';
+ if (state->fd)
+ snprintf(fdstr, 32, " fd=%p", state->fd);
- gf_msg (this->name, GF_LOG_INFO, op_errno, PS_MSG_SERVER_MSG,
- "%s%s => (%d, %d)%s", op, caller, op_ret, op_errno, fdstr);
+ gf_msg(this->name, GF_LOG_INFO, op_errno, PS_MSG_SERVER_MSG,
+ "%s%s => (%d, %d)%s", op, caller, op_ret, op_errno, fdstr);
out:
- return;
+ return;
}
-
void
-server_print_request (call_frame_t *frame)
+server_print_request(call_frame_t *frame)
{
- server_conf_t *conf = NULL;
- xlator_t *this = NULL;
- server_state_t *state = NULL;
- char *op = "UNKNOWN";
- char resolve_vars[256];
- char resolve2_vars[256];
- char loc_vars[256];
- char loc2_vars[256];
- char other_vars[512];
- char caller[512];
+ server_conf_t *conf = NULL;
+ xlator_t *this = NULL;
+ server_state_t *state = NULL;
+ char *op = "UNKNOWN";
+ char resolve_vars[256];
+ char resolve2_vars[256];
+ char loc_vars[256];
+ char loc2_vars[256];
+ char other_vars[512];
+ char caller[512];
- GF_VALIDATE_OR_GOTO ("server", frame, out);
+ GF_VALIDATE_OR_GOTO("server", frame, out);
- this = frame->this;
- conf = this->private;
+ this = frame->this;
+ conf = this->private;
- GF_VALIDATE_OR_GOTO ("server", conf, out);
+ GF_VALIDATE_OR_GOTO("server", conf, out);
- if (!conf->trace)
- goto out;
+ if (!conf->trace)
+ goto out;
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- memset (resolve_vars, '\0', 256);
- memset (resolve2_vars, '\0', 256);
- memset (loc_vars, '\0', 256);
- memset (loc2_vars, '\0', 256);
- memset (other_vars, '\0', 256);
+ memset(resolve_vars, '\0', 256);
+ memset(resolve2_vars, '\0', 256);
+ memset(loc_vars, '\0', 256);
+ memset(loc2_vars, '\0', 256);
+ memset(other_vars, '\0', 256);
- print_caller (caller, 256, frame);
+ print_caller(caller, 256, frame);
- if (!server_resolve_is_empty (&state->resolve)) {
- server_print_resolve (resolve_vars, 256, &state->resolve);
- server_print_loc (loc_vars, 256, &state->loc);
- }
+ if (!server_resolve_is_empty(&state->resolve)) {
+ server_print_resolve(resolve_vars, 256, &state->resolve);
+ server_print_loc(loc_vars, 256, &state->loc);
+ }
- if (!server_resolve_is_empty (&state->resolve2)) {
- server_print_resolve (resolve2_vars, 256, &state->resolve2);
- server_print_loc (loc2_vars, 256, &state->loc2);
- }
+ if (!server_resolve_is_empty(&state->resolve2)) {
+ server_print_resolve(resolve2_vars, 256, &state->resolve2);
+ server_print_loc(loc2_vars, 256, &state->loc2);
+ }
- server_print_params (other_vars, 512, state);
+ server_print_params(other_vars, 512, state);
- switch (frame->root->type) {
+ switch (frame->root->type) {
case GF_OP_TYPE_FOP:
- op = (char *)gf_fop_list[frame->root->op];
- break;
+ op = (char *)gf_fop_list[frame->root->op];
+ break;
default:
- op = "";
- break;
- }
+ op = "";
+ break;
+ }
- gf_msg (this->name, GF_LOG_INFO, 0, PS_MSG_SERVER_MSG,
- "%s%s%s%s%s%s%s", op, caller,
- resolve_vars, loc_vars, resolve2_vars, loc2_vars, other_vars);
+ gf_msg(this->name, GF_LOG_INFO, 0, PS_MSG_SERVER_MSG, "%s%s%s%s%s%s%s", op,
+ caller, resolve_vars, loc_vars, resolve2_vars, loc2_vars,
+ other_vars);
out:
- return;
+ return;
}
-
int
-serialize_rsp_direntp (gf_dirent_t *entries, gfs3_readdirp_rsp *rsp)
+serialize_rsp_direntp(gf_dirent_t *entries, gfs3_readdirp_rsp *rsp)
{
- gf_dirent_t *entry = NULL;
- gfs3_dirplist *trav = NULL;
- gfs3_dirplist *prev = NULL;
- int ret = -1;
- int temp = 0;
-
- GF_VALIDATE_OR_GOTO ("server", entries, out);
- GF_VALIDATE_OR_GOTO ("server", rsp, out);
-
- list_for_each_entry (entry, &entries->list, list) {
- trav = GF_CALLOC (1, sizeof (*trav), gf_server_mt_dirent_rsp_t);
- if (!trav)
- goto out;
-
- trav->d_ino = entry->d_ino;
- trav->d_off = entry->d_off;
- trav->d_len = entry->d_len;
- trav->d_type = entry->d_type;
- trav->name = entry->d_name;
-
- gf_stat_from_iatt (&trav->stat, &entry->d_stat);
-
- /* if 'dict' is present, pack it */
- if (entry->dict) {
- temp = dict_serialized_length (entry->dict);
-
- if (temp < 0) {
- gf_msg (THIS->name, GF_LOG_ERROR, EINVAL,
- PS_MSG_INVALID_ENTRY, "failed to get "
- "serialized length of reply dict");
- errno = EINVAL;
- trav->dict.dict_len = 0;
- goto out;
- }
- trav->dict.dict_len = temp;
-
- trav->dict.dict_val = GF_CALLOC (1, trav->dict.dict_len,
- gf_server_mt_rsp_buf_t);
- if (!trav->dict.dict_val) {
- errno = ENOMEM;
- trav->dict.dict_len = 0;
- goto out;
- }
-
- ret = dict_serialize (entry->dict, trav->dict.dict_val);
- if (ret < 0) {
- gf_msg (THIS->name, GF_LOG_ERROR, 0,
- PS_MSG_DICT_SERIALIZE_FAIL,
- "failed to serialize reply dict");
- errno = -ret;
- trav->dict.dict_len = 0;
- goto out;
- }
- }
+ gf_dirent_t *entry = NULL;
+ gfs3_dirplist *trav = NULL;
+ gfs3_dirplist *prev = NULL;
+ int ret = -1;
+ int temp = 0;
+
+ GF_VALIDATE_OR_GOTO("server", entries, out);
+ GF_VALIDATE_OR_GOTO("server", rsp, out);
+
+ list_for_each_entry(entry, &entries->list, list)
+ {
+ trav = GF_CALLOC(1, sizeof(*trav), gf_server_mt_dirent_rsp_t);
+ if (!trav)
+ goto out;
+
+ trav->d_ino = entry->d_ino;
+ trav->d_off = entry->d_off;
+ trav->d_len = entry->d_len;
+ trav->d_type = entry->d_type;
+ trav->name = entry->d_name;
+
+ gf_stat_from_iatt(&trav->stat, &entry->d_stat);
+
+ /* if 'dict' is present, pack it */
+ if (entry->dict) {
+ temp = dict_serialized_length(entry->dict);
+
+ if (temp < 0) {
+ gf_msg(THIS->name, GF_LOG_ERROR, EINVAL, PS_MSG_INVALID_ENTRY,
+ "failed to get "
+ "serialized length of reply dict");
+ errno = EINVAL;
+ trav->dict.dict_len = 0;
+ goto out;
+ }
+ trav->dict.dict_len = temp;
+
+ trav->dict.dict_val = GF_CALLOC(1, trav->dict.dict_len,
+ gf_server_mt_rsp_buf_t);
+ if (!trav->dict.dict_val) {
+ errno = ENOMEM;
+ trav->dict.dict_len = 0;
+ goto out;
+ }
+
+ ret = dict_serialize(entry->dict, trav->dict.dict_val);
+ if (ret < 0) {
+ gf_msg(THIS->name, GF_LOG_ERROR, 0, PS_MSG_DICT_SERIALIZE_FAIL,
+ "failed to serialize reply dict");
+ errno = -ret;
+ trav->dict.dict_len = 0;
+ goto out;
+ }
+ }
- if (prev)
- prev->nextentry = trav;
- else
- rsp->reply = trav;
+ if (prev)
+ prev->nextentry = trav;
+ else
+ rsp->reply = trav;
- prev = trav;
- trav = NULL;
- }
+ prev = trav;
+ trav = NULL;
+ }
- ret = 0;
+ ret = 0;
out:
- GF_FREE (trav);
+ GF_FREE(trav);
- return ret;
+ return ret;
}
-
int
-serialize_rsp_direntp_v2 (gf_dirent_t *entries, gfx_readdirp_rsp *rsp)
+serialize_rsp_direntp_v2(gf_dirent_t *entries, gfx_readdirp_rsp *rsp)
{
- gf_dirent_t *entry = NULL;
- gfx_dirplist *trav = NULL;
- gfx_dirplist *prev = NULL;
- int ret = -1;
-
- GF_VALIDATE_OR_GOTO ("server", entries, out);
- GF_VALIDATE_OR_GOTO ("server", rsp, out);
-
- list_for_each_entry (entry, &entries->list, list) {
- trav = GF_CALLOC (1, sizeof (*trav), gf_server_mt_dirent_rsp_t);
- if (!trav)
- goto out;
-
- trav->d_ino = entry->d_ino;
- trav->d_off = entry->d_off;
- trav->d_len = entry->d_len;
- trav->d_type = entry->d_type;
- trav->name = entry->d_name;
-
- gfx_stat_from_iattx (&trav->stat, &entry->d_stat);
- dict_to_xdr (entry->dict, &trav->dict);
-
- if (prev)
- prev->nextentry = trav;
- else
- rsp->reply = trav;
+ gf_dirent_t *entry = NULL;
+ gfx_dirplist *trav = NULL;
+ gfx_dirplist *prev = NULL;
+ int ret = -1;
+
+ GF_VALIDATE_OR_GOTO("server", entries, out);
+ GF_VALIDATE_OR_GOTO("server", rsp, out);
+
+ list_for_each_entry(entry, &entries->list, list)
+ {
+ trav = GF_CALLOC(1, sizeof(*trav), gf_server_mt_dirent_rsp_t);
+ if (!trav)
+ goto out;
+
+ trav->d_ino = entry->d_ino;
+ trav->d_off = entry->d_off;
+ trav->d_len = entry->d_len;
+ trav->d_type = entry->d_type;
+ trav->name = entry->d_name;
+
+ gfx_stat_from_iattx(&trav->stat, &entry->d_stat);
+ dict_to_xdr(entry->dict, &trav->dict);
+
+ if (prev)
+ prev->nextentry = trav;
+ else
+ rsp->reply = trav;
- prev = trav;
- trav = NULL;
- }
+ prev = trav;
+ trav = NULL;
+ }
- ret = 0;
+ ret = 0;
out:
- GF_FREE (trav);
+ GF_FREE(trav);
- return ret;
+ return ret;
}
-
int
-serialize_rsp_dirent (gf_dirent_t *entries, gfs3_readdir_rsp *rsp)
+serialize_rsp_dirent(gf_dirent_t *entries, gfs3_readdir_rsp *rsp)
{
- gf_dirent_t *entry = NULL;
- gfs3_dirlist *trav = NULL;
- gfs3_dirlist *prev = NULL;
- int ret = -1;
-
- GF_VALIDATE_OR_GOTO ("server", rsp, out);
- GF_VALIDATE_OR_GOTO ("server", entries, out);
-
- list_for_each_entry (entry, &entries->list, list) {
- trav = GF_CALLOC (1, sizeof (*trav), gf_server_mt_dirent_rsp_t);
- if (!trav)
- goto out;
- trav->d_ino = entry->d_ino;
- trav->d_off = entry->d_off;
- trav->d_len = entry->d_len;
- trav->d_type = entry->d_type;
- trav->name = entry->d_name;
- if (prev)
- prev->nextentry = trav;
- else
- rsp->reply = trav;
-
- prev = trav;
- }
+ gf_dirent_t *entry = NULL;
+ gfs3_dirlist *trav = NULL;
+ gfs3_dirlist *prev = NULL;
+ int ret = -1;
+
+ GF_VALIDATE_OR_GOTO("server", rsp, out);
+ GF_VALIDATE_OR_GOTO("server", entries, out);
+
+ list_for_each_entry(entry, &entries->list, list)
+ {
+ trav = GF_CALLOC(1, sizeof(*trav), gf_server_mt_dirent_rsp_t);
+ if (!trav)
+ goto out;
+ trav->d_ino = entry->d_ino;
+ trav->d_off = entry->d_off;
+ trav->d_len = entry->d_len;
+ trav->d_type = entry->d_type;
+ trav->name = entry->d_name;
+ if (prev)
+ prev->nextentry = trav;
+ else
+ rsp->reply = trav;
- ret = 0;
+ prev = trav;
+ }
+
+ ret = 0;
out:
- return ret;
+ return ret;
}
int
-serialize_rsp_dirent_v2 (gf_dirent_t *entries, gfx_readdir_rsp *rsp)
+serialize_rsp_dirent_v2(gf_dirent_t *entries, gfx_readdir_rsp *rsp)
{
- gf_dirent_t *entry = NULL;
- gfx_dirlist *trav = NULL;
- gfx_dirlist *prev = NULL;
- int ret = -1;
-
- GF_VALIDATE_OR_GOTO ("server", rsp, out);
- GF_VALIDATE_OR_GOTO ("server", entries, out);
-
- list_for_each_entry (entry, &entries->list, list) {
- trav = GF_CALLOC (1, sizeof (*trav), gf_server_mt_dirent_rsp_t);
- if (!trav)
- goto out;
- trav->d_ino = entry->d_ino;
- trav->d_off = entry->d_off;
- trav->d_len = entry->d_len;
- trav->d_type = entry->d_type;
- trav->name = entry->d_name;
- if (prev)
- prev->nextentry = trav;
- else
- rsp->reply = trav;
-
- prev = trav;
- }
+ gf_dirent_t *entry = NULL;
+ gfx_dirlist *trav = NULL;
+ gfx_dirlist *prev = NULL;
+ int ret = -1;
+
+ GF_VALIDATE_OR_GOTO("server", rsp, out);
+ GF_VALIDATE_OR_GOTO("server", entries, out);
+
+ list_for_each_entry(entry, &entries->list, list)
+ {
+ trav = GF_CALLOC(1, sizeof(*trav), gf_server_mt_dirent_rsp_t);
+ if (!trav)
+ goto out;
+ trav->d_ino = entry->d_ino;
+ trav->d_off = entry->d_off;
+ trav->d_len = entry->d_len;
+ trav->d_type = entry->d_type;
+ trav->name = entry->d_name;
+ if (prev)
+ prev->nextentry = trav;
+ else
+ rsp->reply = trav;
- ret = 0;
+ prev = trav;
+ }
+
+ ret = 0;
out:
- return ret;
+ return ret;
}
-
-
int
-readdir_rsp_cleanup (gfs3_readdir_rsp *rsp)
+readdir_rsp_cleanup(gfs3_readdir_rsp *rsp)
{
- gfs3_dirlist *prev = NULL;
- gfs3_dirlist *trav = NULL;
-
- trav = rsp->reply;
+ gfs3_dirlist *prev = NULL;
+ gfs3_dirlist *trav = NULL;
+
+ trav = rsp->reply;
+ prev = trav;
+ while (trav) {
+ trav = trav->nextentry;
+ GF_FREE(prev);
prev = trav;
- while (trav) {
- trav = trav->nextentry;
- GF_FREE (prev);
- prev = trav;
- }
+ }
- return 0;
+ return 0;
}
-
int
-readdirp_rsp_cleanup (gfs3_readdirp_rsp *rsp)
+readdirp_rsp_cleanup(gfs3_readdirp_rsp *rsp)
{
- gfs3_dirplist *prev = NULL;
- gfs3_dirplist *trav = NULL;
-
- trav = rsp->reply;
+ gfs3_dirplist *prev = NULL;
+ gfs3_dirplist *trav = NULL;
+
+ trav = rsp->reply;
+ prev = trav;
+ while (trav) {
+ trav = trav->nextentry;
+ GF_FREE(prev->dict.dict_val);
+ GF_FREE(prev);
prev = trav;
- while (trav) {
- trav = trav->nextentry;
- GF_FREE (prev->dict.dict_val);
- GF_FREE (prev);
- prev = trav;
- }
+ }
- return 0;
+ return 0;
}
int
-readdir_rsp_cleanup_v2 (gfx_readdir_rsp *rsp)
+readdir_rsp_cleanup_v2(gfx_readdir_rsp *rsp)
{
- gfx_dirlist *prev = NULL;
- gfx_dirlist *trav = NULL;
-
- trav = rsp->reply;
+ gfx_dirlist *prev = NULL;
+ gfx_dirlist *trav = NULL;
+
+ trav = rsp->reply;
+ prev = trav;
+ while (trav) {
+ trav = trav->nextentry;
+ GF_FREE(prev);
prev = trav;
- while (trav) {
- trav = trav->nextentry;
- GF_FREE (prev);
- prev = trav;
- }
+ }
- return 0;
+ return 0;
}
-
int
-readdirp_rsp_cleanup_v2 (gfx_readdirp_rsp *rsp)
+readdirp_rsp_cleanup_v2(gfx_readdirp_rsp *rsp)
{
- gfx_dirplist *prev = NULL;
- gfx_dirplist *trav = NULL;
-
- trav = rsp->reply;
+ gfx_dirplist *prev = NULL;
+ gfx_dirplist *trav = NULL;
+
+ trav = rsp->reply;
+ prev = trav;
+ while (trav) {
+ trav = trav->nextentry;
+ GF_FREE(prev->dict.pairs.pairs_val);
+ GF_FREE(prev);
prev = trav;
- while (trav) {
- trav = trav->nextentry;
- GF_FREE (prev->dict.pairs.pairs_val);
- GF_FREE (prev);
- prev = trav;
- }
+ }
- return 0;
+ return 0;
}
-
static int
-common_rsp_locklist (lock_migration_info_t *locklist,
- gfs3_locklist **reply) {
- lock_migration_info_t *tmp = NULL;
- gfs3_locklist *trav = NULL;
- gfs3_locklist *prev = NULL;
- int ret = -1;
-
- GF_VALIDATE_OR_GOTO ("server", locklist, out);
-
- list_for_each_entry (tmp, &locklist->list, list) {
- trav = GF_CALLOC (1, sizeof (*trav), gf_server_mt_lock_mig_t);
- if (!trav)
- goto out;
-
- switch (tmp->flock.l_type) {
- case F_RDLCK:
- tmp->flock.l_type = GF_LK_F_RDLCK;
- break;
- case F_WRLCK:
- tmp->flock.l_type = GF_LK_F_WRLCK;
- break;
- case F_UNLCK:
- tmp->flock.l_type = GF_LK_F_UNLCK;
- break;
+common_rsp_locklist(lock_migration_info_t *locklist, gfs3_locklist **reply)
+{
+ lock_migration_info_t *tmp = NULL;
+ gfs3_locklist *trav = NULL;
+ gfs3_locklist *prev = NULL;
+ int ret = -1;
- default:
- gf_msg (THIS->name, GF_LOG_ERROR, 0, PS_MSG_LOCK_ERROR,
- "Unknown lock type: %"PRId32"!",
- tmp->flock.l_type);
- break;
- }
+ GF_VALIDATE_OR_GOTO("server", locklist, out);
+
+ list_for_each_entry(tmp, &locklist->list, list)
+ {
+ trav = GF_CALLOC(1, sizeof(*trav), gf_server_mt_lock_mig_t);
+ if (!trav)
+ goto out;
- gf_proto_flock_from_flock (&trav->flock, &tmp->flock);
+ switch (tmp->flock.l_type) {
+ case F_RDLCK:
+ tmp->flock.l_type = GF_LK_F_RDLCK;
+ break;
+ case F_WRLCK:
+ tmp->flock.l_type = GF_LK_F_WRLCK;
+ break;
+ case F_UNLCK:
+ tmp->flock.l_type = GF_LK_F_UNLCK;
+ break;
- trav->lk_flags = tmp->lk_flags;
+ default:
+ gf_msg(THIS->name, GF_LOG_ERROR, 0, PS_MSG_LOCK_ERROR,
+ "Unknown lock type: %" PRId32 "!", tmp->flock.l_type);
+ break;
+ }
- trav->client_uid = tmp->client_uid;
+ gf_proto_flock_from_flock(&trav->flock, &tmp->flock);
- if (prev)
- prev->nextentry = trav;
- else
- *reply = trav;
+ trav->lk_flags = tmp->lk_flags;
- prev = trav;
- trav = NULL;
- }
+ trav->client_uid = tmp->client_uid;
- ret = 0;
+ if (prev)
+ prev->nextentry = trav;
+ else
+ *reply = trav;
+
+ prev = trav;
+ trav = NULL;
+ }
+
+ ret = 0;
out:
- GF_FREE (trav);
- return ret;
+ GF_FREE(trav);
+ return ret;
}
int
-serialize_rsp_locklist (lock_migration_info_t *locklist,
- gfs3_getactivelk_rsp *rsp)
+serialize_rsp_locklist(lock_migration_info_t *locklist,
+ gfs3_getactivelk_rsp *rsp)
{
- int ret = 0;
+ int ret = 0;
- GF_VALIDATE_OR_GOTO ("server", rsp, out);
- ret = common_rsp_locklist (locklist, &rsp->reply);
+ GF_VALIDATE_OR_GOTO("server", rsp, out);
+ ret = common_rsp_locklist(locklist, &rsp->reply);
out:
- return ret;
+ return ret;
}
int
-serialize_rsp_locklist_v2 (lock_migration_info_t *locklist,
- gfx_getactivelk_rsp *rsp)
+serialize_rsp_locklist_v2(lock_migration_info_t *locklist,
+ gfx_getactivelk_rsp *rsp)
{
- int ret = 0;
+ int ret = 0;
- GF_VALIDATE_OR_GOTO ("server", rsp, out);
- ret = common_rsp_locklist (locklist, &rsp->reply);
+ GF_VALIDATE_OR_GOTO("server", rsp, out);
+ ret = common_rsp_locklist(locklist, &rsp->reply);
out:
- return ret;
+ return ret;
}
-
int
-getactivelkinfo_rsp_cleanup (gfs3_getactivelk_rsp *rsp)
+getactivelkinfo_rsp_cleanup(gfs3_getactivelk_rsp *rsp)
{
- gfs3_locklist *prev = NULL;
- gfs3_locklist *trav = NULL;
+ gfs3_locklist *prev = NULL;
+ gfs3_locklist *trav = NULL;
- trav = rsp->reply;
- prev = trav;
+ trav = rsp->reply;
+ prev = trav;
- while (trav) {
- trav = trav->nextentry;
- GF_FREE (prev);
- prev = trav;
- }
+ while (trav) {
+ trav = trav->nextentry;
+ GF_FREE(prev);
+ prev = trav;
+ }
- return 0;
+ return 0;
}
int
-getactivelkinfo_rsp_cleanup_v2 (gfx_getactivelk_rsp *rsp)
+getactivelkinfo_rsp_cleanup_v2(gfx_getactivelk_rsp *rsp)
{
- gfs3_locklist *prev = NULL;
- gfs3_locklist *trav = NULL;
+ gfs3_locklist *prev = NULL;
+ gfs3_locklist *trav = NULL;
- trav = rsp->reply;
- prev = trav;
+ trav = rsp->reply;
+ prev = trav;
- while (trav) {
- trav = trav->nextentry;
- GF_FREE (prev);
- prev = trav;
- }
+ while (trav) {
+ trav = trav->nextentry;
+ GF_FREE(prev);
+ prev = trav;
+ }
- return 0;
+ return 0;
}
int
-gf_server_check_getxattr_cmd (call_frame_t *frame, const char *key)
+gf_server_check_getxattr_cmd(call_frame_t *frame, const char *key)
{
+ server_conf_t *conf = NULL;
+ rpc_transport_t *xprt = NULL;
- server_conf_t *conf = NULL;
- rpc_transport_t *xprt = NULL;
-
- conf = frame->this->private;
- if (!conf)
- return 0;
+ conf = frame->this->private;
+ if (!conf)
+ return 0;
- if (fnmatch ("*list*mount*point*", key, 0) == 0) {
- /* list all the client protocol connecting to this process */
- pthread_mutex_lock (&conf->mutex);
- {
- list_for_each_entry (xprt, &conf->xprt_list, list) {
- gf_msg ("mount-point-list", GF_LOG_INFO, 0,
- PS_MSG_MOUNT_PT_FAIL,
- "%s", xprt->peerinfo.identifier);
- }
- }
- pthread_mutex_unlock (&conf->mutex);
+ if (fnmatch("*list*mount*point*", key, 0) == 0) {
+ /* list all the client protocol connecting to this process */
+ pthread_mutex_lock(&conf->mutex);
+ {
+ list_for_each_entry(xprt, &conf->xprt_list, list)
+ {
+ gf_msg("mount-point-list", GF_LOG_INFO, 0, PS_MSG_MOUNT_PT_FAIL,
+ "%s", xprt->peerinfo.identifier);
+ }
}
+ pthread_mutex_unlock(&conf->mutex);
+ }
- /* Add more options/keys here */
+ /* Add more options/keys here */
- return 0;
+ return 0;
}
-
int
-gf_server_check_setxattr_cmd (call_frame_t *frame, dict_t *dict)
+gf_server_check_setxattr_cmd(call_frame_t *frame, dict_t *dict)
{
+ server_conf_t *conf = NULL;
+ rpc_transport_t *xprt = NULL;
+ uint64_t total_read = 0;
+ uint64_t total_write = 0;
- server_conf_t *conf = NULL;
- rpc_transport_t *xprt = NULL;
- uint64_t total_read = 0;
- uint64_t total_write = 0;
-
- conf = frame->this->private;
- if (!conf || !dict)
- return 0;
+ conf = frame->this->private;
+ if (!conf || !dict)
+ return 0;
- if (dict_foreach_fnmatch (dict, "*io*stat*dump",
- dict_null_foreach_fn, NULL ) > 0) {
- list_for_each_entry (xprt, &conf->xprt_list, list) {
- total_read += xprt->total_bytes_read;
- total_write += xprt->total_bytes_write;
- }
- gf_msg ("stats", GF_LOG_INFO, 0, PS_MSG_RW_STAT,
- "total-read %"PRIu64", total-write %"PRIu64,
- total_read, total_write);
+ if (dict_foreach_fnmatch(dict, "*io*stat*dump", dict_null_foreach_fn,
+ NULL) > 0) {
+ list_for_each_entry(xprt, &conf->xprt_list, list)
+ {
+ total_read += xprt->total_bytes_read;
+ total_write += xprt->total_bytes_write;
}
+ gf_msg("stats", GF_LOG_INFO, 0, PS_MSG_RW_STAT,
+ "total-read %" PRIu64 ", total-write %" PRIu64, total_read,
+ total_write);
+ }
- return 0;
+ return 0;
}
-server_ctx_t*
-server_ctx_get (client_t *client, xlator_t *xlator)
+server_ctx_t *
+server_ctx_get(client_t *client, xlator_t *xlator)
{
- void *tmp = NULL;
- server_ctx_t *ctx = NULL;
- server_ctx_t *setted_ctx = NULL;
+ void *tmp = NULL;
+ server_ctx_t *ctx = NULL;
+ server_ctx_t *setted_ctx = NULL;
- client_ctx_get (client, xlator, &tmp);
+ client_ctx_get(client, xlator, &tmp);
- ctx = tmp;
+ ctx = tmp;
- if (ctx != NULL)
- goto out;
+ if (ctx != NULL)
+ goto out;
- ctx = GF_CALLOC (1, sizeof (server_ctx_t), gf_server_mt_server_conf_t);
+ ctx = GF_CALLOC(1, sizeof(server_ctx_t), gf_server_mt_server_conf_t);
- if (ctx == NULL)
- goto out;
+ if (ctx == NULL)
+ goto out;
- ctx->fdtable = gf_fd_fdtable_alloc ();
+ ctx->fdtable = gf_fd_fdtable_alloc();
- if (ctx->fdtable == NULL) {
- GF_FREE (ctx);
- ctx = NULL;
- goto out;
- }
+ if (ctx->fdtable == NULL) {
+ GF_FREE(ctx);
+ ctx = NULL;
+ goto out;
+ }
- LOCK_INIT (&ctx->fdtable_lock);
+ LOCK_INIT(&ctx->fdtable_lock);
- setted_ctx = client_ctx_set (client, xlator, ctx);
- if (ctx != setted_ctx) {
- LOCK_DESTROY (&ctx->fdtable_lock);
- GF_FREE (ctx->fdtable);
- GF_FREE (ctx);
- ctx = setted_ctx;
- }
+ setted_ctx = client_ctx_set(client, xlator, ctx);
+ if (ctx != setted_ctx) {
+ LOCK_DESTROY(&ctx->fdtable_lock);
+ GF_FREE(ctx->fdtable);
+ GF_FREE(ctx);
+ ctx = setted_ctx;
+ }
out:
- return ctx;
+ return ctx;
}
int
-auth_set_username_passwd (dict_t *input_params, dict_t *config_params,
- client_t *client)
+auth_set_username_passwd(dict_t *input_params, dict_t *config_params,
+ client_t *client)
{
- int ret = 0;
- data_t *allow_user = NULL;
- data_t *passwd_data = NULL;
- char *username = NULL;
- char *password = NULL;
- char *brick_name = NULL;
- char *searchstr = NULL;
- char *username_str = NULL;
- char *tmp = NULL;
- char *username_cpy = NULL;
-
- ret = dict_get_str (input_params, "username", &username);
- if (ret) {
- gf_msg_debug ("auth/login", 0, "username not found, returning "
- "DONT-CARE");
- /* For non trusted clients username and password
- will not be there. So don't reject the client.
- */
- ret = 0;
- goto out;
- }
-
- ret = dict_get_str (input_params, "password", &password);
- if (ret) {
- gf_msg ("auth/login", GF_LOG_WARNING, 0,
- PS_MSG_DICT_GET_FAILED,
- "password not found, returning DONT-CARE");
- goto out;
- }
-
- ret = dict_get_str (input_params, "remote-subvolume", &brick_name);
- if (ret) {
- gf_msg ("auth/login", GF_LOG_ERROR, 0, PS_MSG_DICT_GET_FAILED,
- "remote-subvolume not specified");
- ret = -1;
- goto out;
- }
-
- ret = gf_asprintf (&searchstr, "auth.login.%s.allow", brick_name);
- if (-1 == ret) {
- ret = 0;
- goto out;
- }
-
- allow_user = dict_get (config_params, searchstr);
- GF_FREE (searchstr);
-
- if (allow_user) {
- username_cpy = gf_strdup (allow_user->data);
- if (!username_cpy)
- goto out;
-
- username_str = strtok_r (username_cpy, " ,", &tmp);
-
- while (username_str) {
- if (!fnmatch (username_str, username, 0)) {
- ret = gf_asprintf (&searchstr,
- "auth.login.%s.password",
- username);
- if (-1 == ret)
- goto out;
-
- passwd_data = dict_get (config_params,
- searchstr);
- GF_FREE (searchstr);
-
- if (!passwd_data) {
- gf_msg ("auth/login", GF_LOG_ERROR, 0,
- PS_MSG_LOGIN_ERROR, "wrong "
- "username/password "
- "combination");
- ret = -1;
- goto out;
- }
-
- ret = strcmp (data_to_str (passwd_data),
- password);
- if (!ret) {
- client->auth.username =
- gf_strdup (username);
- client->auth.passwd =
- gf_strdup (password);
- } else {
- gf_msg ("auth/login", GF_LOG_ERROR, 0,
- PS_MSG_LOGIN_ERROR, "wrong "
- "password for user %s",
- username);
- }
- break;
- }
- username_str = strtok_r (NULL, " ,", &tmp);
+ int ret = 0;
+ data_t *allow_user = NULL;
+ data_t *passwd_data = NULL;
+ char *username = NULL;
+ char *password = NULL;
+ char *brick_name = NULL;
+ char *searchstr = NULL;
+ char *username_str = NULL;
+ char *tmp = NULL;
+ char *username_cpy = NULL;
+
+ ret = dict_get_str(input_params, "username", &username);
+ if (ret) {
+ gf_msg_debug("auth/login", 0,
+ "username not found, returning "
+ "DONT-CARE");
+ /* For non trusted clients username and password
+ will not be there. So don't reject the client.
+ */
+ ret = 0;
+ goto out;
+ }
+
+ ret = dict_get_str(input_params, "password", &password);
+ if (ret) {
+ gf_msg("auth/login", GF_LOG_WARNING, 0, PS_MSG_DICT_GET_FAILED,
+ "password not found, returning DONT-CARE");
+ goto out;
+ }
+
+ ret = dict_get_str(input_params, "remote-subvolume", &brick_name);
+ if (ret) {
+ gf_msg("auth/login", GF_LOG_ERROR, 0, PS_MSG_DICT_GET_FAILED,
+ "remote-subvolume not specified");
+ ret = -1;
+ goto out;
+ }
+
+ ret = gf_asprintf(&searchstr, "auth.login.%s.allow", brick_name);
+ if (-1 == ret) {
+ ret = 0;
+ goto out;
+ }
+
+ allow_user = dict_get(config_params, searchstr);
+ GF_FREE(searchstr);
+
+ if (allow_user) {
+ username_cpy = gf_strdup(allow_user->data);
+ if (!username_cpy)
+ goto out;
+
+ username_str = strtok_r(username_cpy, " ,", &tmp);
+
+ while (username_str) {
+ if (!fnmatch(username_str, username, 0)) {
+ ret = gf_asprintf(&searchstr, "auth.login.%s.password",
+ username);
+ if (-1 == ret)
+ goto out;
+
+ passwd_data = dict_get(config_params, searchstr);
+ GF_FREE(searchstr);
+
+ if (!passwd_data) {
+ gf_msg("auth/login", GF_LOG_ERROR, 0, PS_MSG_LOGIN_ERROR,
+ "wrong "
+ "username/password "
+ "combination");
+ ret = -1;
+ goto out;
+ }
+
+ ret = strcmp(data_to_str(passwd_data), password);
+ if (!ret) {
+ client->auth.username = gf_strdup(username);
+ client->auth.passwd = gf_strdup(password);
+ } else {
+ gf_msg("auth/login", GF_LOG_ERROR, 0, PS_MSG_LOGIN_ERROR,
+ "wrong "
+ "password for user %s",
+ username);
}
+ break;
+ }
+ username_str = strtok_r(NULL, " ,", &tmp);
}
+ }
out:
- GF_FREE (username_cpy);
+ GF_FREE(username_cpy);
- return ret;
+ return ret;
}
inode_t *
-server_inode_new (inode_table_t *itable, uuid_t gfid) {
- if (__is_root_gfid (gfid))
- return itable->root;
- else
- return inode_new (itable);
+server_inode_new(inode_table_t *itable, uuid_t gfid)
+{
+ if (__is_root_gfid(gfid))
+ return itable->root;
+ else
+ return inode_new(itable);
}
int
-unserialize_req_locklist (gfs3_setactivelk_req *req,
- lock_migration_info_t *lmi)
+unserialize_req_locklist(gfs3_setactivelk_req *req, lock_migration_info_t *lmi)
{
- struct gfs3_locklist *trav = NULL;
- lock_migration_info_t *temp = NULL;
- int ret = -1;
+ struct gfs3_locklist *trav = NULL;
+ lock_migration_info_t *temp = NULL;
+ int ret = -1;
- trav = req->request;
+ trav = req->request;
- INIT_LIST_HEAD (&lmi->list);
+ INIT_LIST_HEAD(&lmi->list);
- while (trav) {
- temp = GF_CALLOC (1, sizeof (*lmi), gf_common_mt_lock_mig);
- if (temp == NULL) {
- gf_msg (THIS->name, GF_LOG_ERROR, 0, 0, "No memory");
- goto out;
- }
+ while (trav) {
+ temp = GF_CALLOC(1, sizeof(*lmi), gf_common_mt_lock_mig);
+ if (temp == NULL) {
+ gf_msg(THIS->name, GF_LOG_ERROR, 0, 0, "No memory");
+ goto out;
+ }
- INIT_LIST_HEAD (&temp->list);
+ INIT_LIST_HEAD(&temp->list);
- gf_proto_flock_to_flock (&trav->flock, &temp->flock);
+ gf_proto_flock_to_flock(&trav->flock, &temp->flock);
- temp->lk_flags = trav->lk_flags;
+ temp->lk_flags = trav->lk_flags;
- temp->client_uid = gf_strdup (trav->client_uid);
+ temp->client_uid = gf_strdup(trav->client_uid);
- list_add_tail (&temp->list, &lmi->list);
+ list_add_tail(&temp->list, &lmi->list);
- trav = trav->nextentry;
- }
+ trav = trav->nextentry;
+ }
- ret = 0;
+ ret = 0;
out:
- return ret;
+ return ret;
}
int
-unserialize_req_locklist_v2 (gfx_setactivelk_req *req,
- lock_migration_info_t *lmi)
+unserialize_req_locklist_v2(gfx_setactivelk_req *req,
+ lock_migration_info_t *lmi)
{
- struct gfs3_locklist *trav = NULL;
- lock_migration_info_t *temp = NULL;
- int ret = -1;
+ struct gfs3_locklist *trav = NULL;
+ lock_migration_info_t *temp = NULL;
+ int ret = -1;
- trav = req->request;
+ trav = req->request;
- INIT_LIST_HEAD (&lmi->list);
+ INIT_LIST_HEAD(&lmi->list);
- while (trav) {
- temp = GF_CALLOC (1, sizeof (*lmi), gf_common_mt_lock_mig);
- if (temp == NULL) {
- gf_msg (THIS->name, GF_LOG_ERROR, 0, 0, "No memory");
- goto out;
- }
+ while (trav) {
+ temp = GF_CALLOC(1, sizeof(*lmi), gf_common_mt_lock_mig);
+ if (temp == NULL) {
+ gf_msg(THIS->name, GF_LOG_ERROR, 0, 0, "No memory");
+ goto out;
+ }
- INIT_LIST_HEAD (&temp->list);
+ INIT_LIST_HEAD(&temp->list);
- gf_proto_flock_to_flock (&trav->flock, &temp->flock);
+ gf_proto_flock_to_flock(&trav->flock, &temp->flock);
- temp->lk_flags = trav->lk_flags;
+ temp->lk_flags = trav->lk_flags;
- temp->client_uid = gf_strdup (trav->client_uid);
+ temp->client_uid = gf_strdup(trav->client_uid);
- list_add_tail (&temp->list, &lmi->list);
+ list_add_tail(&temp->list, &lmi->list);
- trav = trav->nextentry;
- }
+ trav = trav->nextentry;
+ }
- ret = 0;
+ ret = 0;
out:
- return ret;
+ return ret;
}
int
-server_populate_compound_request (gfs3_compound_req *req, call_frame_t *frame,
- default_args_t *this_args,
- int index)
+server_populate_compound_request(gfs3_compound_req *req, call_frame_t *frame,
+ default_args_t *this_args, int index)
{
- int op_errno = 0;
- int ret = -1;
- dict_t *xdata = NULL;
- dict_t *xattr = NULL;
- struct iovec req_iovec[MAX_IOVEC] = { {0,} };
- compound_req *this_req = NULL;
- server_state_t *state = CALL_STATE (frame);
-
- this_req = &req->compound_req_array.compound_req_array_val[index];
-
- switch (this_req->fop_enum) {
- case GF_FOP_STAT:
- {
- gfs3_stat_req *args = NULL;
+ int op_errno = 0;
+ int ret = -1;
+ dict_t *xdata = NULL;
+ dict_t *xattr = NULL;
+ struct iovec req_iovec[MAX_IOVEC] = {{
+ 0,
+ }};
+ compound_req *this_req = NULL;
+ server_state_t *state = CALL_STATE(frame);
- args = &this_req->compound_req_u.compound_stat_req;
+ this_req = &req->compound_req_array.compound_req_array_val[index];
- GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
- xdata, args->xdata.xdata_val,
- args->xdata.xdata_len, ret,
- op_errno, out);
- args_stat_store (this_args, &state->loc, xdata);
- break;
- }
- case GF_FOP_READLINK:
- {
- gfs3_readlink_req *args = NULL;
-
- args = &this_req->compound_req_u.compound_readlink_req;
-
- GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
- xdata, args->xdata.xdata_val,
- args->xdata.xdata_len, ret,
- op_errno, out);
- args_readlink_store (this_args, &state->loc, args->size, xdata);
- break;
- }
- case GF_FOP_MKNOD:
- {
- gfs3_mknod_req *args = NULL;
+ switch (this_req->fop_enum) {
+ case GF_FOP_STAT: {
+ gfs3_stat_req *args = NULL;
- args = &this_req->compound_req_u.compound_mknod_req;
+ args = &this_req->compound_req_u.compound_stat_req;
- GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
- xdata, args->xdata.xdata_val,
- args->xdata.xdata_len, ret,
- op_errno, out);
- args_mknod_store (this_args, &state->loc, args->mode, args->dev,
- args->umask, xdata);
- break;
+ GF_PROTOCOL_DICT_UNSERIALIZE(
+ frame->root->client->bound_xl, xdata, args->xdata.xdata_val,
+ args->xdata.xdata_len, ret, op_errno, out);
+ args_stat_store(this_args, &state->loc, xdata);
+ break;
}
- case GF_FOP_MKDIR:
- {
- gfs3_mkdir_req *args = NULL;
+ case GF_FOP_READLINK: {
+ gfs3_readlink_req *args = NULL;
- args = &this_req->compound_req_u.compound_mkdir_req;
+ args = &this_req->compound_req_u.compound_readlink_req;
- GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
- xdata, args->xdata.xdata_val,
- args->xdata.xdata_len, ret,
- op_errno, out);
- args_mkdir_store (this_args, &state->loc, args->mode,
- args->umask, xdata);
- break;
+ GF_PROTOCOL_DICT_UNSERIALIZE(
+ frame->root->client->bound_xl, xdata, args->xdata.xdata_val,
+ args->xdata.xdata_len, ret, op_errno, out);
+ args_readlink_store(this_args, &state->loc, args->size, xdata);
+ break;
}
- case GF_FOP_UNLINK:
- {
- gfs3_unlink_req *args = NULL;
+ case GF_FOP_MKNOD: {
+ gfs3_mknod_req *args = NULL;
- args = &this_req->compound_req_u.compound_unlink_req;
+ args = &this_req->compound_req_u.compound_mknod_req;
- GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
- xdata, args->xdata.xdata_val,
- args->xdata.xdata_len, ret,
- op_errno, out);
- args_unlink_store (this_args, &state->loc, args->xflags, xdata);
- break;
+ GF_PROTOCOL_DICT_UNSERIALIZE(
+ frame->root->client->bound_xl, xdata, args->xdata.xdata_val,
+ args->xdata.xdata_len, ret, op_errno, out);
+ args_mknod_store(this_args, &state->loc, args->mode, args->dev,
+ args->umask, xdata);
+ break;
}
- case GF_FOP_RMDIR:
- {
- gfs3_rmdir_req *args = NULL;
+ case GF_FOP_MKDIR: {
+ gfs3_mkdir_req *args = NULL;
- args = &this_req->compound_req_u.compound_rmdir_req;
+ args = &this_req->compound_req_u.compound_mkdir_req;
- GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
- xdata, args->xdata.xdata_val,
- args->xdata.xdata_len, ret,
- op_errno, out);
- args_rmdir_store (this_args, &state->loc, args->xflags, xdata);
- break;
+ GF_PROTOCOL_DICT_UNSERIALIZE(
+ frame->root->client->bound_xl, xdata, args->xdata.xdata_val,
+ args->xdata.xdata_len, ret, op_errno, out);
+ args_mkdir_store(this_args, &state->loc, args->mode, args->umask,
+ xdata);
+ break;
}
- case GF_FOP_SYMLINK:
- {
- gfs3_symlink_req *args = NULL;
+ case GF_FOP_UNLINK: {
+ gfs3_unlink_req *args = NULL;
- args = &this_req->compound_req_u.compound_symlink_req;
+ args = &this_req->compound_req_u.compound_unlink_req;
- GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
- xdata, args->xdata.xdata_val,
- args->xdata.xdata_len, ret,
- op_errno, out);
- args_symlink_store (this_args, args->linkname, &state->loc,
- args->umask, xdata);
-
- this_args->loc.inode = inode_new (state->itable);
-
- break;
+ GF_PROTOCOL_DICT_UNSERIALIZE(
+ frame->root->client->bound_xl, xdata, args->xdata.xdata_val,
+ args->xdata.xdata_len, ret, op_errno, out);
+ args_unlink_store(this_args, &state->loc, args->xflags, xdata);
+ break;
}
- case GF_FOP_RENAME:
- {
- gfs3_rename_req *args = NULL;
-
- args = &this_req->compound_req_u.compound_rename_req;
+ case GF_FOP_RMDIR: {
+ gfs3_rmdir_req *args = NULL;
- GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
- xdata, args->xdata.xdata_val,
- args->xdata.xdata_len, ret,
- op_errno, out);
+ args = &this_req->compound_req_u.compound_rmdir_req;
- args_rename_store (this_args, &state->loc, &state->loc2, xdata);
- break;
+ GF_PROTOCOL_DICT_UNSERIALIZE(
+ frame->root->client->bound_xl, xdata, args->xdata.xdata_val,
+ args->xdata.xdata_len, ret, op_errno, out);
+ args_rmdir_store(this_args, &state->loc, args->xflags, xdata);
+ break;
}
- case GF_FOP_LINK:
- {
- gfs3_link_req *args = NULL;
+ case GF_FOP_SYMLINK: {
+ gfs3_symlink_req *args = NULL;
- args = &this_req->compound_req_u.compound_link_req;
+ args = &this_req->compound_req_u.compound_symlink_req;
- GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
- xdata, args->xdata.xdata_val,
- args->xdata.xdata_len, ret,
- op_errno, out);
- args_link_store (this_args, &state->loc, &state->loc2, xdata);
+ GF_PROTOCOL_DICT_UNSERIALIZE(
+ frame->root->client->bound_xl, xdata, args->xdata.xdata_val,
+ args->xdata.xdata_len, ret, op_errno, out);
+ args_symlink_store(this_args, args->linkname, &state->loc,
+ args->umask, xdata);
- this_args->loc2.inode = inode_ref (this_args->loc.inode);
+ this_args->loc.inode = inode_new(state->itable);
- break;
+ break;
}
- case GF_FOP_TRUNCATE:
- {
- gfs3_truncate_req *args = NULL;
+ case GF_FOP_RENAME: {
+ gfs3_rename_req *args = NULL;
- args = &this_req->compound_req_u.compound_truncate_req;
+ args = &this_req->compound_req_u.compound_rename_req;
- GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
- xdata, args->xdata.xdata_val,
- args->xdata.xdata_len, ret,
- op_errno, out);
- args_truncate_store (this_args, &state->loc, args->offset,
- xdata);
- break;
+ GF_PROTOCOL_DICT_UNSERIALIZE(
+ frame->root->client->bound_xl, xdata, args->xdata.xdata_val,
+ args->xdata.xdata_len, ret, op_errno, out);
+
+ args_rename_store(this_args, &state->loc, &state->loc2, xdata);
+ break;
}
- case GF_FOP_OPEN:
- {
- gfs3_open_req *args = NULL;
+ case GF_FOP_LINK: {
+ gfs3_link_req *args = NULL;
- args = &this_req->compound_req_u.compound_open_req;
+ args = &this_req->compound_req_u.compound_link_req;
- GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
- xdata, args->xdata.xdata_val,
- args->xdata.xdata_len, ret,
- op_errno, out);
- args_open_store (this_args, &state->loc, args->flags, state->fd,
- xdata);
+ GF_PROTOCOL_DICT_UNSERIALIZE(
+ frame->root->client->bound_xl, xdata, args->xdata.xdata_val,
+ args->xdata.xdata_len, ret, op_errno, out);
+ args_link_store(this_args, &state->loc, &state->loc2, xdata);
- this_args->fd = fd_create (this_args->loc.inode,
- frame->root->pid);
- this_args->fd->flags = this_args->flags;
+ this_args->loc2.inode = inode_ref(this_args->loc.inode);
- break;
+ break;
}
- case GF_FOP_READ:
- {
- gfs3_read_req *args = NULL;
+ case GF_FOP_TRUNCATE: {
+ gfs3_truncate_req *args = NULL;
- args = &this_req->compound_req_u.compound_read_req;
+ args = &this_req->compound_req_u.compound_truncate_req;
- GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
- xdata, args->xdata.xdata_val,
- args->xdata.xdata_len, ret,
- op_errno, out);
- args_readv_store (this_args, state->fd, args->size,
- args->offset, args->flag, xdata);
- break;
+ GF_PROTOCOL_DICT_UNSERIALIZE(
+ frame->root->client->bound_xl, xdata, args->xdata.xdata_val,
+ args->xdata.xdata_len, ret, op_errno, out);
+ args_truncate_store(this_args, &state->loc, args->offset, xdata);
+ break;
}
- case GF_FOP_WRITE:
- {
- gfs3_write_req *args = NULL;
-
- args = &this_req->compound_req_u.compound_write_req;
-
- /*TODO : What happens when payload count is more than one? */
- req_iovec[0].iov_base = state->payload_vector[0].iov_base +
- state->write_length;
- req_iovec[0].iov_len = args->size;
-
- GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
- xdata, args->xdata.xdata_val,
- args->xdata.xdata_len, ret,
- op_errno, out);
- /* The way writev fop works :
- * xdr args of write along with other args contains
- * write length not count. But when the call is wound to posix,
- * this length is not used. It is taken from the request
- * write vector that is passed down. Posix needs the vector
- * count to determine the amount of write to be done.
- * This count for writes that come as part of compound fops
- * will be 1. The vectors are merged into one under
- * GF_FOP_WRITE section of client_handle_fop_requirements()
- * in protocol client.
- */
- args_writev_store (this_args, state->fd, req_iovec, 1,
- args->offset, args->flag, state->iobref,
- xdata);
- state->write_length += req_iovec[0].iov_len;
- break;
- }
- case GF_FOP_STATFS:
- {
- gfs3_statfs_req *args = NULL;
+ case GF_FOP_OPEN: {
+ gfs3_open_req *args = NULL;
- args = &this_req->compound_req_u.compound_statfs_req;
+ args = &this_req->compound_req_u.compound_open_req;
- GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
- xdata, args->xdata.xdata_val,
- args->xdata.xdata_len, ret,
- op_errno, out);
- args_statfs_store (this_args, &state->loc, xdata);
- break;
- }
- case GF_FOP_FLUSH:
- {
- gfs3_flush_req *args = NULL;
+ GF_PROTOCOL_DICT_UNSERIALIZE(
+ frame->root->client->bound_xl, xdata, args->xdata.xdata_val,
+ args->xdata.xdata_len, ret, op_errno, out);
+ args_open_store(this_args, &state->loc, args->flags, state->fd,
+ xdata);
- args = &this_req->compound_req_u.compound_flush_req;
+ this_args->fd = fd_create(this_args->loc.inode, frame->root->pid);
+ this_args->fd->flags = this_args->flags;
- GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
- xdata, args->xdata.xdata_val,
- args->xdata.xdata_len, ret,
- op_errno, out);
- args_flush_store (this_args, state->fd, xdata);
- break;
+ break;
}
- case GF_FOP_FSYNC:
- {
- gfs3_fsync_req *args = NULL;
+ case GF_FOP_READ: {
+ gfs3_read_req *args = NULL;
- args = &this_req->compound_req_u.compound_fsync_req;
+ args = &this_req->compound_req_u.compound_read_req;
- GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
- xdata, args->xdata.xdata_val,
- args->xdata.xdata_len, ret,
- op_errno, out);
- args_fsync_store (this_args, state->fd, args->data, xdata);
- break;
+ GF_PROTOCOL_DICT_UNSERIALIZE(
+ frame->root->client->bound_xl, xdata, args->xdata.xdata_val,
+ args->xdata.xdata_len, ret, op_errno, out);
+ args_readv_store(this_args, state->fd, args->size, args->offset,
+ args->flag, xdata);
+ break;
}
- case GF_FOP_SETXATTR:
- {
- gfs3_setxattr_req *args = NULL;
+ case GF_FOP_WRITE: {
+ gfs3_write_req *args = NULL;
- args = &this_req->compound_req_u.compound_setxattr_req;
+ args = &this_req->compound_req_u.compound_write_req;
- GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
- xdata, args->xdata.xdata_val,
- args->xdata.xdata_len, ret,
- op_errno, out);
- GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
- xattr, args->dict.dict_val,
- args->dict.dict_len, ret,
- op_errno, out);
- args_setxattr_store (this_args, &state->loc, xattr, args->flags,
- xdata);
- break;
- }
- case GF_FOP_GETXATTR:
- {
- gfs3_getxattr_req *args = NULL;
+ /*TODO : What happens when payload count is more than one? */
+ req_iovec[0].iov_base = state->payload_vector[0].iov_base +
+ state->write_length;
+ req_iovec[0].iov_len = args->size;
- args = &this_req->compound_req_u.compound_getxattr_req;
+ GF_PROTOCOL_DICT_UNSERIALIZE(
+ frame->root->client->bound_xl, xdata, args->xdata.xdata_val,
+ args->xdata.xdata_len, ret, op_errno, out);
+ /* The way writev fop works :
+ * xdr args of write along with other args contains
+ * write length not count. But when the call is wound to posix,
+ * this length is not used. It is taken from the request
+ * write vector that is passed down. Posix needs the vector
+ * count to determine the amount of write to be done.
+ * This count for writes that come as part of compound fops
+ * will be 1. The vectors are merged into one under
+ * GF_FOP_WRITE section of client_handle_fop_requirements()
+ * in protocol client.
+ */
+ args_writev_store(this_args, state->fd, req_iovec, 1, args->offset,
+ args->flag, state->iobref, xdata);
+ state->write_length += req_iovec[0].iov_len;
+ break;
+ }
+ case GF_FOP_STATFS: {
+ gfs3_statfs_req *args = NULL;
- GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
- xdata, args->xdata.xdata_val,
- args->xdata.xdata_len, ret,
- op_errno, out);
- gf_server_check_getxattr_cmd (frame, args->name);
+ args = &this_req->compound_req_u.compound_statfs_req;
- args_getxattr_store (this_args, &state->loc, args->name, xdata);
- break;
+ GF_PROTOCOL_DICT_UNSERIALIZE(
+ frame->root->client->bound_xl, xdata, args->xdata.xdata_val,
+ args->xdata.xdata_len, ret, op_errno, out);
+ args_statfs_store(this_args, &state->loc, xdata);
+ break;
}
- case GF_FOP_REMOVEXATTR:
- {
- gfs3_removexattr_req *args = NULL;
+ case GF_FOP_FLUSH: {
+ gfs3_flush_req *args = NULL;
- args = &this_req->compound_req_u.compound_removexattr_req;
+ args = &this_req->compound_req_u.compound_flush_req;
- GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
- xdata, args->xdata.xdata_val,
- args->xdata.xdata_len, ret,
- op_errno, out);
- args_removexattr_store (this_args, &state->loc, args->name,
- xdata);
- break;
+ GF_PROTOCOL_DICT_UNSERIALIZE(
+ frame->root->client->bound_xl, xdata, args->xdata.xdata_val,
+ args->xdata.xdata_len, ret, op_errno, out);
+ args_flush_store(this_args, state->fd, xdata);
+ break;
}
- case GF_FOP_OPENDIR:
- {
- gfs3_opendir_req *args = NULL;
+ case GF_FOP_FSYNC: {
+ gfs3_fsync_req *args = NULL;
- args = &this_req->compound_req_u.compound_opendir_req;
+ args = &this_req->compound_req_u.compound_fsync_req;
- this_args->fd = fd_create (this_args->loc.inode,
- frame->root->pid);
- if (!this_args->fd) {
- gf_msg ("server", GF_LOG_ERROR, 0,
- PS_MSG_FD_CREATE_FAILED,
- "could not create the fd");
- goto out;
- }
- GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
- xdata,
- args->xdata.xdata_val,
- args->xdata.xdata_len, ret,
- op_errno, out);
- args_opendir_store (this_args, &state->loc, state->fd, xdata);
- break;
+ GF_PROTOCOL_DICT_UNSERIALIZE(
+ frame->root->client->bound_xl, xdata, args->xdata.xdata_val,
+ args->xdata.xdata_len, ret, op_errno, out);
+ args_fsync_store(this_args, state->fd, args->data, xdata);
+ break;
+ }
+ case GF_FOP_SETXATTR: {
+ gfs3_setxattr_req *args = NULL;
+
+ args = &this_req->compound_req_u.compound_setxattr_req;
+
+ GF_PROTOCOL_DICT_UNSERIALIZE(
+ frame->root->client->bound_xl, xdata, args->xdata.xdata_val,
+ args->xdata.xdata_len, ret, op_errno, out);
+ GF_PROTOCOL_DICT_UNSERIALIZE(
+ frame->root->client->bound_xl, xattr, args->dict.dict_val,
+ args->dict.dict_len, ret, op_errno, out);
+ args_setxattr_store(this_args, &state->loc, xattr, args->flags,
+ xdata);
+ break;
+ }
+ case GF_FOP_GETXATTR: {
+ gfs3_getxattr_req *args = NULL;
+
+ args = &this_req->compound_req_u.compound_getxattr_req;
+
+ GF_PROTOCOL_DICT_UNSERIALIZE(
+ frame->root->client->bound_xl, xdata, args->xdata.xdata_val,
+ args->xdata.xdata_len, ret, op_errno, out);
+ gf_server_check_getxattr_cmd(frame, args->name);
+
+ args_getxattr_store(this_args, &state->loc, args->name, xdata);
+ break;
+ }
+ case GF_FOP_REMOVEXATTR: {
+ gfs3_removexattr_req *args = NULL;
+
+ args = &this_req->compound_req_u.compound_removexattr_req;
+
+ GF_PROTOCOL_DICT_UNSERIALIZE(
+ frame->root->client->bound_xl, xdata, args->xdata.xdata_val,
+ args->xdata.xdata_len, ret, op_errno, out);
+ args_removexattr_store(this_args, &state->loc, args->name, xdata);
+ break;
+ }
+ case GF_FOP_OPENDIR: {
+ gfs3_opendir_req *args = NULL;
+
+ args = &this_req->compound_req_u.compound_opendir_req;
+
+ this_args->fd = fd_create(this_args->loc.inode, frame->root->pid);
+ if (!this_args->fd) {
+ gf_msg("server", GF_LOG_ERROR, 0, PS_MSG_FD_CREATE_FAILED,
+ "could not create the fd");
+ goto out;
+ }
+ GF_PROTOCOL_DICT_UNSERIALIZE(
+ frame->root->client->bound_xl, xdata, args->xdata.xdata_val,
+ args->xdata.xdata_len, ret, op_errno, out);
+ args_opendir_store(this_args, &state->loc, state->fd, xdata);
+ break;
}
- case GF_FOP_FSYNCDIR:
- {
- gfs3_fsyncdir_req *args = NULL;
+ case GF_FOP_FSYNCDIR: {
+ gfs3_fsyncdir_req *args = NULL;
- args = &this_req->compound_req_u.compound_fsyncdir_req;
+ args = &this_req->compound_req_u.compound_fsyncdir_req;
- GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
- xdata, args->xdata.xdata_val,
- args->xdata.xdata_len, ret,
- op_errno, out);
- args_fsyncdir_store (this_args, state->fd, args->data, xdata);
- break;
+ GF_PROTOCOL_DICT_UNSERIALIZE(
+ frame->root->client->bound_xl, xdata, args->xdata.xdata_val,
+ args->xdata.xdata_len, ret, op_errno, out);
+ args_fsyncdir_store(this_args, state->fd, args->data, xdata);
+ break;
}
- case GF_FOP_ACCESS:
- {
- gfs3_access_req *args = NULL;
+ case GF_FOP_ACCESS: {
+ gfs3_access_req *args = NULL;
- args = &this_req->compound_req_u.compound_access_req;
+ args = &this_req->compound_req_u.compound_access_req;
- GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
- xdata, args->xdata.xdata_val,
- args->xdata.xdata_len, ret,
- op_errno, out);
- args_access_store (this_args, &state->loc, args->mask, xdata);
- break;
+ GF_PROTOCOL_DICT_UNSERIALIZE(
+ frame->root->client->bound_xl, xdata, args->xdata.xdata_val,
+ args->xdata.xdata_len, ret, op_errno, out);
+ args_access_store(this_args, &state->loc, args->mask, xdata);
+ break;
}
- case GF_FOP_CREATE:
- {
- gfs3_create_req *args = NULL;
+ case GF_FOP_CREATE: {
+ gfs3_create_req *args = NULL;
- args = &this_req->compound_req_u.compound_create_req;
+ args = &this_req->compound_req_u.compound_create_req;
- state->loc.inode = inode_new (state->itable);
+ state->loc.inode = inode_new(state->itable);
- state->fd = fd_create (state->loc.inode, frame->root->pid);
- if (!state->fd) {
- gf_msg ("server", GF_LOG_ERROR, 0,
- PS_MSG_FD_CREATE_FAILED,
- "fd creation for the inode %s failed",
- state->loc.inode ?
- uuid_utoa (state->loc.inode->gfid):NULL);
- goto out;
- }
- state->fd->flags = state->flags;
+ state->fd = fd_create(state->loc.inode, frame->root->pid);
+ if (!state->fd) {
+ gf_msg("server", GF_LOG_ERROR, 0, PS_MSG_FD_CREATE_FAILED,
+ "fd creation for the inode %s failed",
+ state->loc.inode ? uuid_utoa(state->loc.inode->gfid)
+ : NULL);
+ goto out;
+ }
+ state->fd->flags = state->flags;
- GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
- xdata, args->xdata.xdata_val,
- args->xdata.xdata_len, ret,
- op_errno, out);
- args_create_store (this_args, &state->loc, args->flags,
- args->mode, args->umask, state->fd, xdata);
- break;
+ GF_PROTOCOL_DICT_UNSERIALIZE(
+ frame->root->client->bound_xl, xdata, args->xdata.xdata_val,
+ args->xdata.xdata_len, ret, op_errno, out);
+ args_create_store(this_args, &state->loc, args->flags, args->mode,
+ args->umask, state->fd, xdata);
+ break;
}
- case GF_FOP_FTRUNCATE:
- {
- gfs3_ftruncate_req *args = NULL;
+ case GF_FOP_FTRUNCATE: {
+ gfs3_ftruncate_req *args = NULL;
- args = &this_req->compound_req_u.compound_ftruncate_req;
+ args = &this_req->compound_req_u.compound_ftruncate_req;
- GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
- xdata, args->xdata.xdata_val,
- args->xdata.xdata_len, ret,
- op_errno, out);
- args_ftruncate_store (this_args, state->fd, args->offset,
- xdata);
- break;
+ GF_PROTOCOL_DICT_UNSERIALIZE(
+ frame->root->client->bound_xl, xdata, args->xdata.xdata_val,
+ args->xdata.xdata_len, ret, op_errno, out);
+ args_ftruncate_store(this_args, state->fd, args->offset, xdata);
+ break;
}
- case GF_FOP_FSTAT:
- {
- gfs3_fstat_req *args = NULL;
+ case GF_FOP_FSTAT: {
+ gfs3_fstat_req *args = NULL;
- args = &this_req->compound_req_u.compound_fstat_req;
+ args = &this_req->compound_req_u.compound_fstat_req;
- GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
- xdata, args->xdata.xdata_val,
- args->xdata.xdata_len, ret,
- op_errno, out);
- args_fstat_store (this_args, state->fd, xdata);
- break;
+ GF_PROTOCOL_DICT_UNSERIALIZE(
+ frame->root->client->bound_xl, xdata, args->xdata.xdata_val,
+ args->xdata.xdata_len, ret, op_errno, out);
+ args_fstat_store(this_args, state->fd, xdata);
+ break;
}
- case GF_FOP_LK:
- {
- gfs3_lk_req *args = NULL;
+ case GF_FOP_LK: {
+ gfs3_lk_req *args = NULL;
- args = &this_req->compound_req_u.compound_lk_req;
+ args = &this_req->compound_req_u.compound_lk_req;
- GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
- xdata, args->xdata.xdata_val,
- args->xdata.xdata_len, ret,
- op_errno, out);
+ GF_PROTOCOL_DICT_UNSERIALIZE(
+ frame->root->client->bound_xl, xdata, args->xdata.xdata_val,
+ args->xdata.xdata_len, ret, op_errno, out);
- switch (args->cmd) {
+ switch (args->cmd) {
case GF_LK_GETLK:
- this_args->cmd = F_GETLK;
- break;
+ this_args->cmd = F_GETLK;
+ break;
case GF_LK_SETLK:
- this_args->cmd = F_SETLK;
- break;
+ this_args->cmd = F_SETLK;
+ break;
case GF_LK_SETLKW:
- this_args->cmd = F_SETLKW;
- break;
+ this_args->cmd = F_SETLKW;
+ break;
case GF_LK_RESLK_LCK:
- this_args->cmd = F_RESLK_LCK;
- break;
+ this_args->cmd = F_RESLK_LCK;
+ break;
case GF_LK_RESLK_LCKW:
- this_args->cmd = F_RESLK_LCKW;
- break;
+ this_args->cmd = F_RESLK_LCKW;
+ break;
case GF_LK_RESLK_UNLCK:
- this_args->cmd = F_RESLK_UNLCK;
- break;
+ this_args->cmd = F_RESLK_UNLCK;
+ break;
case GF_LK_GETLK_FD:
- this_args->cmd = F_GETLK_FD;
- break;
- }
+ this_args->cmd = F_GETLK_FD;
+ break;
+ }
- gf_proto_flock_to_flock (&args->flock, &this_args->lock);
+ gf_proto_flock_to_flock(&args->flock, &this_args->lock);
- switch (args->type) {
+ switch (args->type) {
case GF_LK_F_RDLCK:
- this_args->lock.l_type = F_RDLCK;
- break;
+ this_args->lock.l_type = F_RDLCK;
+ break;
case GF_LK_F_WRLCK:
- this_args->lock.l_type = F_WRLCK;
- break;
+ this_args->lock.l_type = F_WRLCK;
+ break;
case GF_LK_F_UNLCK:
- this_args->lock.l_type = F_UNLCK;
- break;
+ this_args->lock.l_type = F_UNLCK;
+ break;
default:
- gf_msg (frame->root->client->bound_xl->name,
- GF_LOG_ERROR,
- 0, PS_MSG_LOCK_ERROR, "fd - %"PRId64" (%s):"
- " Unknown "
- "lock type: %"PRId32"!", state->resolve.fd_no,
- uuid_utoa (state->fd->inode->gfid),
- args->type);
- break;
- }
- args_lk_store (this_args, state->fd, this_args->cmd,
- &this_args->lock, xdata);
- break;
- }
- case GF_FOP_LOOKUP:
- {
- gfs3_lookup_req *args = NULL;
-
- args = &this_req->compound_req_u.compound_lookup_req;
-
- if (this_args->loc.inode)
- this_args->loc.inode = server_inode_new (state->itable,
- state->loc.gfid);
- else
- state->is_revalidate = 1;
-
- GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
- xdata, args->xdata.xdata_val,
- args->xdata.xdata_len, ret,
- op_errno, out);
- args_lookup_store (this_args, &state->loc, xdata);
- break;
- }
- case GF_FOP_READDIR:
- {
- gfs3_readdir_req *args = NULL;
-
- args = &this_req->compound_req_u.compound_readdir_req;
-
- GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
- xdata, args->xdata.xdata_val,
- args->xdata.xdata_len, ret,
- op_errno, out);
- args_readdir_store (this_args, state->fd, args->size,
- args->offset, xdata);
- break;
- }
- case GF_FOP_INODELK:
- {
- gfs3_inodelk_req *args = NULL;
-
- args = &this_req->compound_req_u.compound_inodelk_req;
-
- switch (args->cmd) {
+ gf_msg(frame->root->client->bound_xl->name, GF_LOG_ERROR, 0,
+ PS_MSG_LOCK_ERROR,
+ "fd - %" PRId64
+ " (%s):"
+ " Unknown "
+ "lock type: %" PRId32 "!",
+ state->resolve.fd_no,
+ uuid_utoa(state->fd->inode->gfid), args->type);
+ break;
+ }
+ args_lk_store(this_args, state->fd, this_args->cmd,
+ &this_args->lock, xdata);
+ break;
+ }
+ case GF_FOP_LOOKUP: {
+ gfs3_lookup_req *args = NULL;
+
+ args = &this_req->compound_req_u.compound_lookup_req;
+
+ if (this_args->loc.inode)
+ this_args->loc.inode = server_inode_new(state->itable,
+ state->loc.gfid);
+ else
+ state->is_revalidate = 1;
+
+ GF_PROTOCOL_DICT_UNSERIALIZE(
+ frame->root->client->bound_xl, xdata, args->xdata.xdata_val,
+ args->xdata.xdata_len, ret, op_errno, out);
+ args_lookup_store(this_args, &state->loc, xdata);
+ break;
+ }
+ case GF_FOP_READDIR: {
+ gfs3_readdir_req *args = NULL;
+
+ args = &this_req->compound_req_u.compound_readdir_req;
+
+ GF_PROTOCOL_DICT_UNSERIALIZE(
+ frame->root->client->bound_xl, xdata, args->xdata.xdata_val,
+ args->xdata.xdata_len, ret, op_errno, out);
+ args_readdir_store(this_args, state->fd, args->size, args->offset,
+ xdata);
+ break;
+ }
+ case GF_FOP_INODELK: {
+ gfs3_inodelk_req *args = NULL;
+
+ args = &this_req->compound_req_u.compound_inodelk_req;
+
+ switch (args->cmd) {
case GF_LK_GETLK:
- this_args->cmd = F_GETLK;
- break;
+ this_args->cmd = F_GETLK;
+ break;
case GF_LK_SETLK:
- this_args->cmd = F_SETLK;
- break;
+ this_args->cmd = F_SETLK;
+ break;
case GF_LK_SETLKW:
- this_args->cmd = F_SETLKW;
- break;
- }
+ this_args->cmd = F_SETLKW;
+ break;
+ }
- gf_proto_flock_to_flock (&args->flock, &this_args->lock);
+ gf_proto_flock_to_flock(&args->flock, &this_args->lock);
- switch (args->type) {
+ switch (args->type) {
case GF_LK_F_RDLCK:
- this_args->lock.l_type = F_RDLCK;
- break;
+ this_args->lock.l_type = F_RDLCK;
+ break;
case GF_LK_F_WRLCK:
- this_args->lock.l_type = F_WRLCK;
- break;
+ this_args->lock.l_type = F_WRLCK;
+ break;
case GF_LK_F_UNLCK:
- this_args->lock.l_type = F_UNLCK;
- break;
- }
+ this_args->lock.l_type = F_UNLCK;
+ break;
+ }
- GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
- xdata, args->xdata.xdata_val,
- args->xdata.xdata_len, ret,
- op_errno, out);
- args_inodelk_store (this_args, args->volume, &state->loc,
- this_args->cmd, &this_args->lock, xdata);
- break;
+ GF_PROTOCOL_DICT_UNSERIALIZE(
+ frame->root->client->bound_xl, xdata, args->xdata.xdata_val,
+ args->xdata.xdata_len, ret, op_errno, out);
+ args_inodelk_store(this_args, args->volume, &state->loc,
+ this_args->cmd, &this_args->lock, xdata);
+ break;
}
- case GF_FOP_FINODELK:
- {
- gfs3_finodelk_req *args = NULL;
+ case GF_FOP_FINODELK: {
+ gfs3_finodelk_req *args = NULL;
- args = &this_req->compound_req_u.compound_finodelk_req;
+ args = &this_req->compound_req_u.compound_finodelk_req;
- GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
- xdata, args->xdata.xdata_val,
- args->xdata.xdata_len, ret,
- op_errno, out);
+ GF_PROTOCOL_DICT_UNSERIALIZE(
+ frame->root->client->bound_xl, xdata, args->xdata.xdata_val,
+ args->xdata.xdata_len, ret, op_errno, out);
- switch (args->cmd) {
+ switch (args->cmd) {
case GF_LK_GETLK:
- this_args->cmd = F_GETLK;
- break;
+ this_args->cmd = F_GETLK;
+ break;
case GF_LK_SETLK:
- this_args->cmd = F_SETLK;
- break;
+ this_args->cmd = F_SETLK;
+ break;
case GF_LK_SETLKW:
- this_args->cmd = F_SETLKW;
- break;
- }
+ this_args->cmd = F_SETLKW;
+ break;
+ }
- gf_proto_flock_to_flock (&args->flock, &this_args->lock);
+ gf_proto_flock_to_flock(&args->flock, &this_args->lock);
- switch (args->type) {
+ switch (args->type) {
case GF_LK_F_RDLCK:
- this_args->lock.l_type = F_RDLCK;
- break;
+ this_args->lock.l_type = F_RDLCK;
+ break;
case GF_LK_F_WRLCK:
- this_args->lock.l_type = F_WRLCK;
- break;
+ this_args->lock.l_type = F_WRLCK;
+ break;
case GF_LK_F_UNLCK:
- this_args->lock.l_type = F_UNLCK;
- break;
- }
- args_finodelk_store (this_args, args->volume, state->fd,
- this_args->cmd, &this_args->lock, xdata);
- break;
+ this_args->lock.l_type = F_UNLCK;
+ break;
+ }
+ args_finodelk_store(this_args, args->volume, state->fd,
+ this_args->cmd, &this_args->lock, xdata);
+ break;
}
- case GF_FOP_ENTRYLK:
- {
- gfs3_entrylk_req *args = NULL;
+ case GF_FOP_ENTRYLK: {
+ gfs3_entrylk_req *args = NULL;
- args = &this_req->compound_req_u.compound_entrylk_req;
+ args = &this_req->compound_req_u.compound_entrylk_req;
- GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
- xdata, args->xdata.xdata_val,
- args->xdata.xdata_len, ret,
- op_errno, out);
- args_entrylk_store (this_args, args->volume, &state->loc,
- args->name, args->cmd, args->type, xdata);
- break;
+ GF_PROTOCOL_DICT_UNSERIALIZE(
+ frame->root->client->bound_xl, xdata, args->xdata.xdata_val,
+ args->xdata.xdata_len, ret, op_errno, out);
+ args_entrylk_store(this_args, args->volume, &state->loc, args->name,
+ args->cmd, args->type, xdata);
+ break;
}
- case GF_FOP_FENTRYLK:
- {
- gfs3_fentrylk_req *args = NULL;
+ case GF_FOP_FENTRYLK: {
+ gfs3_fentrylk_req *args = NULL;
- args = &this_req->compound_req_u.compound_fentrylk_req;
+ args = &this_req->compound_req_u.compound_fentrylk_req;
- GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
- xdata, args->xdata.xdata_val,
- args->xdata.xdata_len, ret,
- op_errno, out);
- args_fentrylk_store (this_args, args->volume, state->fd,
- args->name, args->cmd, args->type, xdata);
- break;
+ GF_PROTOCOL_DICT_UNSERIALIZE(
+ frame->root->client->bound_xl, xdata, args->xdata.xdata_val,
+ args->xdata.xdata_len, ret, op_errno, out);
+ args_fentrylk_store(this_args, args->volume, state->fd, args->name,
+ args->cmd, args->type, xdata);
+ break;
}
- case GF_FOP_XATTROP:
- {
- gfs3_xattrop_req *args = NULL;
+ case GF_FOP_XATTROP: {
+ gfs3_xattrop_req *args = NULL;
- args = &this_req->compound_req_u.compound_xattrop_req;
+ args = &this_req->compound_req_u.compound_xattrop_req;
- GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
- xdata, args->xdata.xdata_val,
- args->xdata.xdata_len, ret,
- op_errno, out);
+ GF_PROTOCOL_DICT_UNSERIALIZE(
+ frame->root->client->bound_xl, xdata, args->xdata.xdata_val,
+ args->xdata.xdata_len, ret, op_errno, out);
- GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
- xattr, (args->dict.dict_val),
- (args->dict.dict_len), ret,
- op_errno, out);
- args_xattrop_store (this_args, &state->loc, args->flags,
- xattr, xdata);
- break;
+ GF_PROTOCOL_DICT_UNSERIALIZE(
+ frame->root->client->bound_xl, xattr, (args->dict.dict_val),
+ (args->dict.dict_len), ret, op_errno, out);
+ args_xattrop_store(this_args, &state->loc, args->flags, xattr,
+ xdata);
+ break;
}
- case GF_FOP_FXATTROP:
- {
- gfs3_fxattrop_req *args = NULL;
+ case GF_FOP_FXATTROP: {
+ gfs3_fxattrop_req *args = NULL;
- args = &this_req->compound_req_u.compound_fxattrop_req;
+ args = &this_req->compound_req_u.compound_fxattrop_req;
- GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
- xattr, (args->dict.dict_val),
- (args->dict.dict_len), ret,
- op_errno, out);
+ GF_PROTOCOL_DICT_UNSERIALIZE(
+ frame->root->client->bound_xl, xattr, (args->dict.dict_val),
+ (args->dict.dict_len), ret, op_errno, out);
- GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
- xdata, args->xdata.xdata_val,
- args->xdata.xdata_len, ret,
- op_errno, out);
+ GF_PROTOCOL_DICT_UNSERIALIZE(
+ frame->root->client->bound_xl, xdata, args->xdata.xdata_val,
+ args->xdata.xdata_len, ret, op_errno, out);
- args_fxattrop_store (this_args, state->fd, args->flags, xattr,
- xdata);
- break;
+ args_fxattrop_store(this_args, state->fd, args->flags, xattr,
+ xdata);
+ break;
}
- case GF_FOP_FGETXATTR:
- {
- gfs3_fgetxattr_req *args = NULL;
+ case GF_FOP_FGETXATTR: {
+ gfs3_fgetxattr_req *args = NULL;
- args = &this_req->compound_req_u.compound_fgetxattr_req;
+ args = &this_req->compound_req_u.compound_fgetxattr_req;
- GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
- xdata, args->xdata.xdata_val,
- args->xdata.xdata_len, ret,
- op_errno, out);
+ GF_PROTOCOL_DICT_UNSERIALIZE(
+ frame->root->client->bound_xl, xdata, args->xdata.xdata_val,
+ args->xdata.xdata_len, ret, op_errno, out);
- args_fgetxattr_store (this_args, state->fd, args->name, xdata);
- break;
+ args_fgetxattr_store(this_args, state->fd, args->name, xdata);
+ break;
}
- case GF_FOP_FSETXATTR:
- {
- gfs3_fsetxattr_req *args = NULL;
+ case GF_FOP_FSETXATTR: {
+ gfs3_fsetxattr_req *args = NULL;
- args = &this_req->compound_req_u.compound_fsetxattr_req;
+ args = &this_req->compound_req_u.compound_fsetxattr_req;
- GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
- xattr, (args->dict.dict_val),
- (args->dict.dict_len), ret,
- op_errno, out);
+ GF_PROTOCOL_DICT_UNSERIALIZE(
+ frame->root->client->bound_xl, xattr, (args->dict.dict_val),
+ (args->dict.dict_len), ret, op_errno, out);
- GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
- xdata, args->xdata.xdata_val,
- args->xdata.xdata_len, ret,
- op_errno, out);
+ GF_PROTOCOL_DICT_UNSERIALIZE(
+ frame->root->client->bound_xl, xdata, args->xdata.xdata_val,
+ args->xdata.xdata_len, ret, op_errno, out);
- args_fsetxattr_store (this_args, state->fd, xattr, args->flags,
- xdata);
- break;
+ args_fsetxattr_store(this_args, state->fd, xattr, args->flags,
+ xdata);
+ break;
}
- case GF_FOP_RCHECKSUM:
- {
- gfs3_rchecksum_req *args = NULL;
+ case GF_FOP_RCHECKSUM: {
+ gfs3_rchecksum_req *args = NULL;
- args = &this_req->compound_req_u.compound_rchecksum_req;
+ args = &this_req->compound_req_u.compound_rchecksum_req;
- GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
- xdata, args->xdata.xdata_val,
- args->xdata.xdata_len, ret,
- op_errno, out);
+ GF_PROTOCOL_DICT_UNSERIALIZE(
+ frame->root->client->bound_xl, xdata, args->xdata.xdata_val,
+ args->xdata.xdata_len, ret, op_errno, out);
- args_rchecksum_store (this_args, state->fd, args->offset,
- args->len, xdata);
- break;
+ args_rchecksum_store(this_args, state->fd, args->offset, args->len,
+ xdata);
+ break;
}
- case GF_FOP_SETATTR:
- {
- gfs3_setattr_req *args = NULL;
+ case GF_FOP_SETATTR: {
+ gfs3_setattr_req *args = NULL;
- args = &this_req->compound_req_u.compound_setattr_req;
+ args = &this_req->compound_req_u.compound_setattr_req;
- GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
- xdata, args->xdata.xdata_val,
- args->xdata.xdata_len, ret,
- op_errno, out);
+ GF_PROTOCOL_DICT_UNSERIALIZE(
+ frame->root->client->bound_xl, xdata, args->xdata.xdata_val,
+ args->xdata.xdata_len, ret, op_errno, out);
- gf_stat_to_iatt (&args->stbuf, &this_args->stat);
+ gf_stat_to_iatt(&args->stbuf, &this_args->stat);
- args_setattr_store (this_args, &state->loc, &this_args->stat,
- args->valid, xdata);
- break;
+ args_setattr_store(this_args, &state->loc, &this_args->stat,
+ args->valid, xdata);
+ break;
}
- case GF_FOP_FSETATTR:
- {
- gfs3_fsetattr_req *args = NULL;
+ case GF_FOP_FSETATTR: {
+ gfs3_fsetattr_req *args = NULL;
- args = &this_req->compound_req_u.compound_fsetattr_req;
+ args = &this_req->compound_req_u.compound_fsetattr_req;
- GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
- xdata, args->xdata.xdata_val,
- args->xdata.xdata_len, ret,
- op_errno, out);
+ GF_PROTOCOL_DICT_UNSERIALIZE(
+ frame->root->client->bound_xl, xdata, args->xdata.xdata_val,
+ args->xdata.xdata_len, ret, op_errno, out);
- gf_stat_to_iatt (&args->stbuf, &this_args->stat);
+ gf_stat_to_iatt(&args->stbuf, &this_args->stat);
- args_fsetattr_store (this_args, state->fd, &this_args->stat,
- args->valid, xdata);
- break;
+ args_fsetattr_store(this_args, state->fd, &this_args->stat,
+ args->valid, xdata);
+ break;
}
- case GF_FOP_READDIRP:
- {
- gfs3_readdirp_req *args = NULL;
+ case GF_FOP_READDIRP: {
+ gfs3_readdirp_req *args = NULL;
- args = &this_req->compound_req_u.compound_readdirp_req;
+ args = &this_req->compound_req_u.compound_readdirp_req;
- GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
- xattr, (args->dict.dict_val),
- (args->dict.dict_len), ret,
- op_errno, out);
+ GF_PROTOCOL_DICT_UNSERIALIZE(
+ frame->root->client->bound_xl, xattr, (args->dict.dict_val),
+ (args->dict.dict_len), ret, op_errno, out);
- args_readdirp_store (this_args, state->fd, args->size,
- args->offset, xattr);
- break;
+ args_readdirp_store(this_args, state->fd, args->size, args->offset,
+ xattr);
+ break;
}
- case GF_FOP_FREMOVEXATTR:
- {
- gfs3_fremovexattr_req *args = NULL;
+ case GF_FOP_FREMOVEXATTR: {
+ gfs3_fremovexattr_req *args = NULL;
- args = &this_req->compound_req_u.compound_fremovexattr_req;
+ args = &this_req->compound_req_u.compound_fremovexattr_req;
- GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
- xdata, args->xdata.xdata_val,
- args->xdata.xdata_len, ret,
- op_errno, out);
+ GF_PROTOCOL_DICT_UNSERIALIZE(
+ frame->root->client->bound_xl, xdata, args->xdata.xdata_val,
+ args->xdata.xdata_len, ret, op_errno, out);
- args_fremovexattr_store (this_args, state->fd, args->name,
- xdata);
- break;
+ args_fremovexattr_store(this_args, state->fd, args->name, xdata);
+ break;
}
- case GF_FOP_FALLOCATE:
- {
- gfs3_fallocate_req *args = NULL;
+ case GF_FOP_FALLOCATE: {
+ gfs3_fallocate_req *args = NULL;
- args = &this_req->compound_req_u.compound_fallocate_req;
+ args = &this_req->compound_req_u.compound_fallocate_req;
- GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
- xdata, args->xdata.xdata_val,
- args->xdata.xdata_len, ret,
- op_errno, out);
- args_fallocate_store (this_args, state->fd, args->flags,
- args->offset, args->size, xdata);
- break;
+ GF_PROTOCOL_DICT_UNSERIALIZE(
+ frame->root->client->bound_xl, xdata, args->xdata.xdata_val,
+ args->xdata.xdata_len, ret, op_errno, out);
+ args_fallocate_store(this_args, state->fd, args->flags,
+ args->offset, args->size, xdata);
+ break;
}
- case GF_FOP_DISCARD:
- {
- gfs3_discard_req *args = NULL;
+ case GF_FOP_DISCARD: {
+ gfs3_discard_req *args = NULL;
- args = &this_req->compound_req_u.compound_discard_req;
+ args = &this_req->compound_req_u.compound_discard_req;
- GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
- xdata, args->xdata.xdata_val,
- args->xdata.xdata_len, ret,
- op_errno, out);
+ GF_PROTOCOL_DICT_UNSERIALIZE(
+ frame->root->client->bound_xl, xdata, args->xdata.xdata_val,
+ args->xdata.xdata_len, ret, op_errno, out);
- args_discard_store (this_args, state->fd, args->offset,
- args->size, xdata);
- break;
+ args_discard_store(this_args, state->fd, args->offset, args->size,
+ xdata);
+ break;
}
- case GF_FOP_ZEROFILL:
- {
- gfs3_zerofill_req *args = NULL;
+ case GF_FOP_ZEROFILL: {
+ gfs3_zerofill_req *args = NULL;
- args = &this_req->compound_req_u.compound_zerofill_req;
+ args = &this_req->compound_req_u.compound_zerofill_req;
- GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
- xdata, args->xdata.xdata_val,
- args->xdata.xdata_len, ret,
- op_errno, out);
- args_zerofill_store (this_args, state->fd, args->offset,
- args->size, xdata);
- break;
+ GF_PROTOCOL_DICT_UNSERIALIZE(
+ frame->root->client->bound_xl, xdata, args->xdata.xdata_val,
+ args->xdata.xdata_len, ret, op_errno, out);
+ args_zerofill_store(this_args, state->fd, args->offset, args->size,
+ xdata);
+ break;
}
- case GF_FOP_SEEK:
- {
- gfs3_seek_req *args = NULL;
+ case GF_FOP_SEEK: {
+ gfs3_seek_req *args = NULL;
- args = &this_req->compound_req_u.compound_seek_req;
+ args = &this_req->compound_req_u.compound_seek_req;
- GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
- xdata, args->xdata.xdata_val,
- args->xdata.xdata_len, ret,
- op_errno, out);
- args_seek_store (this_args, state->fd, args->offset, args->what,
- xdata);
- break;
+ GF_PROTOCOL_DICT_UNSERIALIZE(
+ frame->root->client->bound_xl, xdata, args->xdata.xdata_val,
+ args->xdata.xdata_len, ret, op_errno, out);
+ args_seek_store(this_args, state->fd, args->offset, args->what,
+ xdata);
+ break;
}
- case GF_FOP_LEASE:
- {
- gfs3_lease_req *args = NULL;
+ case GF_FOP_LEASE: {
+ gfs3_lease_req *args = NULL;
- args = &this_req->compound_req_u.compound_lease_req;
+ args = &this_req->compound_req_u.compound_lease_req;
- GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
- xdata, args->xdata.xdata_val,
- args->xdata.xdata_len, ret,
- op_errno, out);
+ GF_PROTOCOL_DICT_UNSERIALIZE(
+ frame->root->client->bound_xl, xdata, args->xdata.xdata_val,
+ args->xdata.xdata_len, ret, op_errno, out);
- gf_proto_lease_to_lease (&args->lease, &state->lease);
+ gf_proto_lease_to_lease(&args->lease, &state->lease);
- args_lease_store (this_args, &state->loc, &state->lease, xdata);
- break;
+ args_lease_store(this_args, &state->loc, &state->lease, xdata);
+ break;
}
default:
- return ENOTSUP;
- }
+ return ENOTSUP;
+ }
out:
- if (xattr)
- dict_unref (xattr);
- if (xdata)
- dict_unref (xdata);
- return op_errno;
+ if (xattr)
+ dict_unref(xattr);
+ if (xdata)
+ dict_unref(xdata);
+ return op_errno;
}
int
-server_populate_compound_response (xlator_t *this, gfs3_compound_rsp *rsp,
- call_frame_t *frame,
- compound_args_cbk_t *args_cbk, int index)
+server_populate_compound_response(xlator_t *this, gfs3_compound_rsp *rsp,
+ call_frame_t *frame,
+ compound_args_cbk_t *args_cbk, int index)
{
- int op_errno = EINVAL;
- default_args_cbk_t *this_args_cbk = NULL;
- compound_rsp *this_rsp = NULL;
- server_state_t *state = NULL;
- int ret = 0;
-
- state = CALL_STATE (frame);
- this_rsp = &rsp->compound_rsp_array.compound_rsp_array_val[index];
+ int op_errno = EINVAL;
+ default_args_cbk_t *this_args_cbk = NULL;
+ compound_rsp *this_rsp = NULL;
+ server_state_t *state = NULL;
+ int ret = 0;
+
+ state = CALL_STATE(frame);
+ this_rsp = &rsp->compound_rsp_array.compound_rsp_array_val[index];
+
+ this_args_cbk = &args_cbk->rsp_list[index];
+ this_rsp->fop_enum = args_cbk->enum_list[index];
+
+ switch (this_rsp->fop_enum) {
+ case GF_FOP_STAT: {
+ gfs3_stat_rsp *rsp_args = NULL;
+
+ rsp_args = &this_rsp->compound_rsp_u.compound_stat_rsp;
+
+ GF_PROTOCOL_DICT_SERIALIZE(
+ this, this_args_cbk->xdata, &rsp_args->xdata.xdata_val,
+ rsp_args->xdata.xdata_len, rsp_args->op_errno, out);
+ if (!this_args_cbk->op_ret) {
+ server_post_stat(state, rsp_args, &this_args_cbk->stat);
+ }
+ rsp_args->op_ret = this_args_cbk->op_ret;
+ rsp_args->op_errno = gf_errno_to_error(this_args_cbk->op_errno);
+ break;
+ }
+ case GF_FOP_READLINK: {
+ gfs3_readlink_rsp *rsp_args = NULL;
+
+ rsp_args = &this_rsp->compound_rsp_u.compound_readlink_rsp;
+
+ GF_PROTOCOL_DICT_SERIALIZE(
+ this, this_args_cbk->xdata, &rsp_args->xdata.xdata_val,
+ rsp_args->xdata.xdata_len, rsp_args->op_errno, out);
+ if (this_args_cbk->op_ret >= 0) {
+ server_post_readlink(rsp_args, &this_args_cbk->stat,
+ this_args_cbk->buf);
+ }
+ rsp_args->op_ret = this_args_cbk->op_ret;
+ rsp_args->op_errno = gf_errno_to_error(this_args_cbk->op_errno);
+ if (!rsp_args->path)
+ rsp_args->path = "";
+ break;
+ }
+ case GF_FOP_MKNOD: {
+ gfs3_mknod_rsp *rsp_args = NULL;
+
+ rsp_args = &this_rsp->compound_rsp_u.compound_mknod_rsp;
+
+ GF_PROTOCOL_DICT_SERIALIZE(
+ this, this_args_cbk->xdata, &rsp_args->xdata.xdata_val,
+ rsp_args->xdata.xdata_len, rsp_args->op_errno, out);
+ if (!this_args_cbk->op_ret) {
+ server_post_mknod(state, rsp_args, &this_args_cbk->stat,
+ &this_args_cbk->preparent,
+ &this_args_cbk->postparent,
+ this_args_cbk->inode);
+ }
+ rsp_args->op_ret = this_args_cbk->op_ret;
+ rsp_args->op_errno = gf_errno_to_error(this_args_cbk->op_errno);
+ break;
+ }
+ case GF_FOP_MKDIR: {
+ gfs3_mkdir_rsp *rsp_args = NULL;
+
+ rsp_args = &this_rsp->compound_rsp_u.compound_mkdir_rsp;
+
+ GF_PROTOCOL_DICT_SERIALIZE(
+ this, this_args_cbk->xdata, &rsp_args->xdata.xdata_val,
+ rsp_args->xdata.xdata_len, rsp_args->op_errno, out);
+
+ if (!this_args_cbk->op_ret) {
+ server_post_mkdir(
+ state, rsp_args, this_args_cbk->inode, &this_args_cbk->stat,
+ &this_args_cbk->preparent, &this_args_cbk->postparent,
+ this_args_cbk->xdata);
+ }
+ rsp_args->op_ret = this_args_cbk->op_ret;
+ rsp_args->op_errno = gf_errno_to_error(this_args_cbk->op_errno);
+ break;
+ }
+ case GF_FOP_UNLINK: {
+ gfs3_unlink_rsp *rsp_args = NULL;
+
+ rsp_args = &this_rsp->compound_rsp_u.compound_unlink_rsp;
+
+ if (gf_replace_old_iatt_in_dict(this_args_cbk->xdata)) {
+ rsp_args->op_errno = errno;
+ rsp_args->op_ret = -1;
+ goto out;
+ }
+
+ GF_PROTOCOL_DICT_SERIALIZE(
+ this, this_args_cbk->xdata, &rsp_args->xdata.xdata_val,
+ rsp_args->xdata.xdata_len, rsp_args->op_errno, out);
+ if (!this_args_cbk->op_ret) {
+ server_post_unlink(state, rsp_args, &this_args_cbk->preparent,
+ &this_args_cbk->postparent);
+ }
+ rsp_args->op_ret = this_args_cbk->op_ret;
+ rsp_args->op_errno = gf_errno_to_error(this_args_cbk->op_errno);
+ break;
+ }
+ case GF_FOP_RMDIR: {
+ gfs3_rmdir_rsp *rsp_args = NULL;
+
+ rsp_args = &this_rsp->compound_rsp_u.compound_rmdir_rsp;
+
+ GF_PROTOCOL_DICT_SERIALIZE(
+ this, this_args_cbk->xdata, &rsp_args->xdata.xdata_val,
+ rsp_args->xdata.xdata_len, rsp_args->op_errno, out);
+ if (!this_args_cbk->op_ret) {
+ server_post_rmdir(state, rsp_args, &this_args_cbk->preparent,
+ &this_args_cbk->postparent);
+ }
+ rsp_args->op_ret = this_args_cbk->op_ret;
+ rsp_args->op_errno = gf_errno_to_error(this_args_cbk->op_errno);
+ break;
+ }
+ case GF_FOP_SYMLINK: {
+ gfs3_symlink_rsp *rsp_args = NULL;
+
+ rsp_args = &this_rsp->compound_rsp_u.compound_symlink_rsp;
+
+ GF_PROTOCOL_DICT_SERIALIZE(
+ this, this_args_cbk->xdata, &rsp_args->xdata.xdata_val,
+ rsp_args->xdata.xdata_len, rsp_args->op_errno, out);
+
+ if (!this_args_cbk->op_ret) {
+ server_post_symlink(
+ state, rsp_args, this_args_cbk->inode, &this_args_cbk->stat,
+ &this_args_cbk->preparent, &this_args_cbk->postparent,
+ this_args_cbk->xdata);
+ }
+ rsp_args->op_ret = this_args_cbk->op_ret;
+ rsp_args->op_errno = gf_errno_to_error(this_args_cbk->op_errno);
+ break;
+ }
+ case GF_FOP_RENAME: {
+ gfs3_rename_rsp *rsp_args = NULL;
+
+ rsp_args = &this_rsp->compound_rsp_u.compound_rename_rsp;
+
+ GF_PROTOCOL_DICT_SERIALIZE(
+ this, this_args_cbk->xdata, &rsp_args->xdata.xdata_val,
+ rsp_args->xdata.xdata_len, rsp_args->op_errno, out);
+
+ if (!this_args_cbk->op_ret) {
+ server_post_rename(
+ frame, state, rsp_args, &this_args_cbk->stat,
+ &this_args_cbk->preparent, &this_args_cbk->postparent,
+ &this_args_cbk->preparent2, &this_args_cbk->postparent2);
+ }
+ rsp_args->op_ret = this_args_cbk->op_ret;
+ rsp_args->op_errno = gf_errno_to_error(this_args_cbk->op_errno);
+ break;
+ }
+ case GF_FOP_LINK: {
+ gfs3_link_rsp *rsp_args = NULL;
+
+ rsp_args = &this_rsp->compound_rsp_u.compound_link_rsp;
+
+ GF_PROTOCOL_DICT_SERIALIZE(
+ this, this_args_cbk->xdata, &rsp_args->xdata.xdata_val,
+ rsp_args->xdata.xdata_len, rsp_args->op_errno, out);
+
+ if (!this_args_cbk->op_ret) {
+ server_post_link(
+ state, rsp_args, this_args_cbk->inode, &this_args_cbk->stat,
+ &this_args_cbk->preparent, &this_args_cbk->postparent,
+ this_args_cbk->xdata);
+ }
+ rsp_args->op_ret = this_args_cbk->op_ret;
+ rsp_args->op_errno = gf_errno_to_error(this_args_cbk->op_errno);
+ break;
+ }
+ case GF_FOP_TRUNCATE: {
+ gfs3_truncate_rsp *rsp_args = NULL;
+
+ rsp_args = &this_rsp->compound_rsp_u.compound_truncate_rsp;
+
+ GF_PROTOCOL_DICT_SERIALIZE(
+ this, this_args_cbk->xdata, &rsp_args->xdata.xdata_val,
+ rsp_args->xdata.xdata_len, rsp_args->op_errno, out);
+
+ if (!this_args_cbk->op_ret) {
+ server_post_truncate(rsp_args, &this_args_cbk->prestat,
+ &this_args_cbk->poststat);
+ }
+ rsp_args->op_ret = this_args_cbk->op_ret;
+ rsp_args->op_errno = gf_errno_to_error(this_args_cbk->op_errno);
+ break;
+ }
+ case GF_FOP_OPEN: {
+ gfs3_open_rsp *rsp_args = NULL;
+
+ rsp_args = &this_rsp->compound_rsp_u.compound_open_rsp;
+
+ GF_PROTOCOL_DICT_SERIALIZE(
+ this, this_args_cbk->xdata, &rsp_args->xdata.xdata_val,
+ rsp_args->xdata.xdata_len, rsp_args->op_errno, out);
+
+ if (!this_args_cbk->op_ret) {
+ server_post_open(frame, this, rsp_args, this_args_cbk->fd);
+ }
+ rsp_args->op_ret = this_args_cbk->op_ret;
+ rsp_args->op_errno = gf_errno_to_error(this_args_cbk->op_errno);
+ break;
+ }
+ case GF_FOP_READ: {
+ gfs3_read_rsp *rsp_args = NULL;
+
+ rsp_args = &this_rsp->compound_rsp_u.compound_read_rsp;
+
+ GF_PROTOCOL_DICT_SERIALIZE(
+ this, this_args_cbk->xdata, &rsp_args->xdata.xdata_val,
+ rsp_args->xdata.xdata_len, rsp_args->op_errno, out);
+
+ if (this_args_cbk->op_ret >= 0) {
+ server_post_readv(rsp_args, &this_args_cbk->stat,
+ this_args_cbk->op_ret);
+
+ if (!state->rsp_iobref) {
+ state->rsp_iobref = this_args_cbk->iobref;
+ state->rsp_count = 0;
+ }
+ iobref_merge(state->rsp_iobref, this_args_cbk->iobref);
+ memcpy(&state->rsp_vector[state->rsp_count],
+ this_args_cbk->vector,
+ (this_args_cbk->count * sizeof(state->rsp_vector[0])));
+ state->rsp_count += this_args_cbk->count;
+ }
+ rsp_args->op_ret = this_args_cbk->op_ret;
+ rsp_args->op_errno = gf_errno_to_error(this_args_cbk->op_errno);
+ break;
+ }
+ case GF_FOP_WRITE: {
+ gfs3_write_rsp *rsp_args = NULL;
+
+ rsp_args = &this_rsp->compound_rsp_u.compound_write_rsp;
+
+ GF_PROTOCOL_DICT_SERIALIZE(
+ this, this_args_cbk->xdata, &rsp_args->xdata.xdata_val,
+ rsp_args->xdata.xdata_len, rsp_args->op_errno, out);
+
+ if (this_args_cbk->op_ret >= 0) {
+ server_post_writev(rsp_args, &this_args_cbk->prestat,
+ &this_args_cbk->poststat);
+ }
+ rsp_args->op_ret = this_args_cbk->op_ret;
+ rsp_args->op_errno = gf_errno_to_error(this_args_cbk->op_errno);
+ break;
+ }
+ case GF_FOP_STATFS: {
+ gfs3_statfs_rsp *rsp_args = NULL;
+
+ rsp_args = &this_rsp->compound_rsp_u.compound_statfs_rsp;
+
+ GF_PROTOCOL_DICT_SERIALIZE(
+ this, this_args_cbk->xdata, &rsp_args->xdata.xdata_val,
+ rsp_args->xdata.xdata_len, rsp_args->op_errno, out);
+ if (!this_args_cbk->op_ret) {
+ server_post_statfs(rsp_args, &this_args_cbk->statvfs);
+ }
+ rsp_args->op_ret = this_args_cbk->op_ret;
+ rsp_args->op_errno = gf_errno_to_error(this_args_cbk->op_errno);
+ break;
+ }
+ case GF_FOP_FLUSH: {
+ gf_common_rsp *rsp_args = NULL;
+
+ rsp_args = &this_rsp->compound_rsp_u.compound_flush_rsp;
+
+ GF_PROTOCOL_DICT_SERIALIZE(
+ this, this_args_cbk->xdata, &rsp_args->xdata.xdata_val,
+ rsp_args->xdata.xdata_len, rsp_args->op_errno, out);
+ rsp_args->op_ret = this_args_cbk->op_ret;
+ rsp_args->op_errno = gf_errno_to_error(this_args_cbk->op_errno);
+ break;
+ }
+ case GF_FOP_FSYNC: {
+ gfs3_fsync_rsp *rsp_args = NULL;
+
+ rsp_args = &this_rsp->compound_rsp_u.compound_fsync_rsp;
+
+ GF_PROTOCOL_DICT_SERIALIZE(
+ this, this_args_cbk->xdata, &rsp_args->xdata.xdata_val,
+ rsp_args->xdata.xdata_len, rsp_args->op_errno, out);
+
+ if (!this_args_cbk->op_ret) {
+ server_post_fsync(rsp_args, &this_args_cbk->prestat,
+ &this_args_cbk->poststat);
+ }
+ rsp_args->op_ret = this_args_cbk->op_ret;
+ rsp_args->op_errno = gf_errno_to_error(this_args_cbk->op_errno);
+ break;
+ }
+ case GF_FOP_SETXATTR: {
+ gf_common_rsp *rsp_args = NULL;
+
+ rsp_args = &this_rsp->compound_rsp_u.compound_setxattr_rsp;
+
+ if (gf_replace_old_iatt_in_dict(this_args_cbk->xdata)) {
+ rsp_args->op_errno = errno;
+ rsp_args->op_ret = -1;
+ goto out;
+ }
- this_args_cbk = &args_cbk->rsp_list[index];
- this_rsp->fop_enum = args_cbk->enum_list[index];
+ GF_PROTOCOL_DICT_SERIALIZE(
+ this, this_args_cbk->xdata, &rsp_args->xdata.xdata_val,
+ rsp_args->xdata.xdata_len, rsp_args->op_errno, out);
+ rsp_args->op_ret = this_args_cbk->op_ret;
+ rsp_args->op_errno = gf_errno_to_error(this_args_cbk->op_errno);
+ break;
+ }
+ case GF_FOP_GETXATTR: {
+ gfs3_getxattr_rsp *rsp_args = NULL;
- switch (this_rsp->fop_enum) {
- case GF_FOP_STAT:
- {
- gfs3_stat_rsp *rsp_args = NULL;
+ rsp_args = &this_rsp->compound_rsp_u.compound_getxattr_rsp;
- rsp_args = &this_rsp->compound_rsp_u.compound_stat_rsp;
+ GF_PROTOCOL_DICT_SERIALIZE(
+ this, this_args_cbk->xdata, &rsp_args->xdata.xdata_val,
+ rsp_args->xdata.xdata_len, rsp_args->op_errno, out);
- GF_PROTOCOL_DICT_SERIALIZE (this, this_args_cbk->xdata,
- &rsp_args->xdata.xdata_val,
- rsp_args->xdata.xdata_len,
- rsp_args->op_errno, out);
- if (!this_args_cbk->op_ret) {
- server_post_stat (state, rsp_args,
- &this_args_cbk->stat);
- }
- rsp_args->op_ret = this_args_cbk->op_ret;
- rsp_args->op_errno = gf_errno_to_error
- (this_args_cbk->op_errno);
- break;
+ if (-1 != this_args_cbk->op_ret) {
+ GF_PROTOCOL_DICT_SERIALIZE(
+ this, this_args_cbk->xattr, &rsp_args->dict.dict_val,
+ rsp_args->dict.dict_len, rsp_args->op_errno, out);
+ }
+ rsp_args->op_ret = this_args_cbk->op_ret;
+ rsp_args->op_errno = gf_errno_to_error(this_args_cbk->op_errno);
+ break;
}
- case GF_FOP_READLINK:
- {
- gfs3_readlink_rsp *rsp_args = NULL;
-
- rsp_args = &this_rsp->compound_rsp_u.compound_readlink_rsp;
+ case GF_FOP_REMOVEXATTR: {
+ gf_common_rsp *rsp_args = NULL;
- GF_PROTOCOL_DICT_SERIALIZE (this, this_args_cbk->xdata,
- &rsp_args->xdata.xdata_val,
- rsp_args->xdata.xdata_len,
- rsp_args->op_errno, out);
- if (this_args_cbk->op_ret >= 0) {
- server_post_readlink (rsp_args, &this_args_cbk->stat,
- this_args_cbk->buf);
- }
- rsp_args->op_ret = this_args_cbk->op_ret;
- rsp_args->op_errno = gf_errno_to_error
- (this_args_cbk->op_errno);
- if (!rsp_args->path)
- rsp_args->path = "";
- break;
- }
- case GF_FOP_MKNOD:
- {
- gfs3_mknod_rsp *rsp_args = NULL;
-
- rsp_args = &this_rsp->compound_rsp_u.compound_mknod_rsp;
-
- GF_PROTOCOL_DICT_SERIALIZE (this, this_args_cbk->xdata,
- &rsp_args->xdata.xdata_val,
- rsp_args->xdata.xdata_len,
- rsp_args->op_errno, out);
- if (!this_args_cbk->op_ret) {
- server_post_mknod (state, rsp_args,
- &this_args_cbk->stat,
- &this_args_cbk->preparent,
- &this_args_cbk->postparent,
- this_args_cbk->inode);
- }
- rsp_args->op_ret = this_args_cbk->op_ret;
- rsp_args->op_errno = gf_errno_to_error
- (this_args_cbk->op_errno);
- break;
- }
- case GF_FOP_MKDIR:
- {
- gfs3_mkdir_rsp *rsp_args = NULL;
-
- rsp_args = &this_rsp->compound_rsp_u.compound_mkdir_rsp;
-
- GF_PROTOCOL_DICT_SERIALIZE (this, this_args_cbk->xdata,
- &rsp_args->xdata.xdata_val,
- rsp_args->xdata.xdata_len,
- rsp_args->op_errno, out);
-
- if (!this_args_cbk->op_ret) {
- server_post_mkdir (state, rsp_args,
- this_args_cbk->inode,
- &this_args_cbk->stat,
- &this_args_cbk->preparent,
- &this_args_cbk->postparent,
- this_args_cbk->xdata);
- }
- rsp_args->op_ret = this_args_cbk->op_ret;
- rsp_args->op_errno = gf_errno_to_error
- (this_args_cbk->op_errno);
- break;
- }
- case GF_FOP_UNLINK:
- {
- gfs3_unlink_rsp *rsp_args = NULL;
+ rsp_args = &this_rsp->compound_rsp_u.compound_removexattr_rsp;
- rsp_args = &this_rsp->compound_rsp_u.compound_unlink_rsp;
+ if (gf_replace_old_iatt_in_dict(this_args_cbk->xdata)) {
+ rsp_args->op_errno = errno;
+ rsp_args->op_ret = -1;
+ goto out;
+ }
+
+ GF_PROTOCOL_DICT_SERIALIZE(
+ this, this_args_cbk->xdata, &rsp_args->xdata.xdata_val,
+ rsp_args->xdata.xdata_len, rsp_args->op_errno, out);
+ rsp_args->op_ret = this_args_cbk->op_ret;
+ rsp_args->op_errno = gf_errno_to_error(this_args_cbk->op_errno);
+ break;
+ }
+ case GF_FOP_OPENDIR: {
+ gfs3_opendir_rsp *rsp_args = NULL;
+
+ rsp_args = &this_rsp->compound_rsp_u.compound_opendir_rsp;
- if (gf_replace_old_iatt_in_dict (this_args_cbk->xdata)) {
- rsp_args->op_errno = errno;
- rsp_args->op_ret = -1;
- goto out;
- }
+ GF_PROTOCOL_DICT_SERIALIZE(
+ this, this_args_cbk->xdata, &rsp_args->xdata.xdata_val,
+ rsp_args->xdata.xdata_len, rsp_args->op_errno, out);
- GF_PROTOCOL_DICT_SERIALIZE (this, this_args_cbk->xdata,
- &rsp_args->xdata.xdata_val,
- rsp_args->xdata.xdata_len,
- rsp_args->op_errno, out);
- if (!this_args_cbk->op_ret) {
- server_post_unlink (state, rsp_args,
- &this_args_cbk->preparent,
- &this_args_cbk->postparent);
- }
- rsp_args->op_ret = this_args_cbk->op_ret;
- rsp_args->op_errno = gf_errno_to_error
- (this_args_cbk->op_errno);
- break;
+ if (!this_args_cbk->op_ret) {
+ server_post_opendir(frame, this, rsp_args, this_args_cbk->fd);
+ }
+ rsp_args->op_ret = this_args_cbk->op_ret;
+ rsp_args->op_errno = gf_errno_to_error(this_args_cbk->op_errno);
+ break;
}
- case GF_FOP_RMDIR:
- {
- gfs3_rmdir_rsp *rsp_args = NULL;
-
- rsp_args = &this_rsp->compound_rsp_u.compound_rmdir_rsp;
-
- GF_PROTOCOL_DICT_SERIALIZE (this, this_args_cbk->xdata,
- &rsp_args->xdata.xdata_val,
- rsp_args->xdata.xdata_len,
- rsp_args->op_errno, out);
- if (!this_args_cbk->op_ret) {
- server_post_rmdir (state, rsp_args,
- &this_args_cbk->preparent,
- &this_args_cbk->postparent);
- }
- rsp_args->op_ret = this_args_cbk->op_ret;
- rsp_args->op_errno = gf_errno_to_error
- (this_args_cbk->op_errno);
- break;
- }
- case GF_FOP_SYMLINK:
- {
- gfs3_symlink_rsp *rsp_args = NULL;
-
- rsp_args = &this_rsp->compound_rsp_u.compound_symlink_rsp;
-
- GF_PROTOCOL_DICT_SERIALIZE (this, this_args_cbk->xdata,
- &rsp_args->xdata.xdata_val,
- rsp_args->xdata.xdata_len,
- rsp_args->op_errno, out);
-
- if (!this_args_cbk->op_ret) {
- server_post_symlink (state, rsp_args,
- this_args_cbk->inode,
- &this_args_cbk->stat,
- &this_args_cbk->preparent,
- &this_args_cbk->postparent,
- this_args_cbk->xdata);
- }
- rsp_args->op_ret = this_args_cbk->op_ret;
- rsp_args->op_errno = gf_errno_to_error
- (this_args_cbk->op_errno);
- break;
- }
- case GF_FOP_RENAME:
- {
- gfs3_rename_rsp *rsp_args = NULL;
-
- rsp_args = &this_rsp->compound_rsp_u.compound_rename_rsp;
-
- GF_PROTOCOL_DICT_SERIALIZE (this, this_args_cbk->xdata,
- &rsp_args->xdata.xdata_val,
- rsp_args->xdata.xdata_len,
- rsp_args->op_errno, out);
-
- if (!this_args_cbk->op_ret) {
- server_post_rename (frame, state, rsp_args,
- &this_args_cbk->stat,
- &this_args_cbk->preparent,
- &this_args_cbk->postparent,
- &this_args_cbk->preparent2,
- &this_args_cbk->postparent2);
- }
- rsp_args->op_ret = this_args_cbk->op_ret;
- rsp_args->op_errno = gf_errno_to_error
- (this_args_cbk->op_errno);
- break;
- }
- case GF_FOP_LINK:
- {
- gfs3_link_rsp *rsp_args = NULL;
+ case GF_FOP_FSYNCDIR: {
+ gf_common_rsp *rsp_args = NULL;
- rsp_args = &this_rsp->compound_rsp_u.compound_link_rsp;
+ rsp_args = &this_rsp->compound_rsp_u.compound_fsyncdir_rsp;
- GF_PROTOCOL_DICT_SERIALIZE (this, this_args_cbk->xdata,
- &rsp_args->xdata.xdata_val,
- rsp_args->xdata.xdata_len,
- rsp_args->op_errno, out);
-
- if (!this_args_cbk->op_ret) {
- server_post_link (state, rsp_args,
- this_args_cbk->inode,
- &this_args_cbk->stat,
- &this_args_cbk->preparent,
- &this_args_cbk->postparent,
- this_args_cbk->xdata);
- }
- rsp_args->op_ret = this_args_cbk->op_ret;
- rsp_args->op_errno = gf_errno_to_error
- (this_args_cbk->op_errno);
- break;
+ GF_PROTOCOL_DICT_SERIALIZE(
+ this, this_args_cbk->xdata, &rsp_args->xdata.xdata_val,
+ rsp_args->xdata.xdata_len, rsp_args->op_errno, out);
+ rsp_args->op_ret = this_args_cbk->op_ret;
+ rsp_args->op_errno = gf_errno_to_error(this_args_cbk->op_errno);
+ break;
+ }
+ case GF_FOP_ACCESS: {
+ gf_common_rsp *rsp_args = NULL;
+
+ rsp_args = &this_rsp->compound_rsp_u.compound_access_rsp;
+
+ GF_PROTOCOL_DICT_SERIALIZE(
+ this, this_args_cbk->xdata, &rsp_args->xdata.xdata_val,
+ rsp_args->xdata.xdata_len, rsp_args->op_errno, out);
+ rsp_args->op_ret = this_args_cbk->op_ret;
+ rsp_args->op_errno = gf_errno_to_error(this_args_cbk->op_errno);
+ break;
}
- case GF_FOP_TRUNCATE:
- {
- gfs3_truncate_rsp *rsp_args = NULL;
+ case GF_FOP_CREATE: {
+ gfs3_create_rsp *rsp_args = NULL;
+
+ rsp_args = &this_rsp->compound_rsp_u.compound_create_rsp;
- rsp_args = &this_rsp->compound_rsp_u.compound_truncate_rsp;
+ GF_PROTOCOL_DICT_SERIALIZE(
+ this, this_args_cbk->xdata, &rsp_args->xdata.xdata_val,
+ rsp_args->xdata.xdata_len, rsp_args->op_errno, out);
- GF_PROTOCOL_DICT_SERIALIZE (this, this_args_cbk->xdata,
- &rsp_args->xdata.xdata_val,
- rsp_args->xdata.xdata_len,
- rsp_args->op_errno, out);
+ rsp_args->op_ret = this_args_cbk->op_ret;
+ rsp_args->op_errno = gf_errno_to_error(this_args_cbk->op_errno);
- if (!this_args_cbk->op_ret) {
- server_post_truncate (rsp_args,
- &this_args_cbk->prestat,
- &this_args_cbk->poststat);
+ if (!this_args_cbk->op_ret) {
+ rsp_args->op_ret = server_post_create(
+ frame, rsp_args, state, this, this_args_cbk->fd,
+ this_args_cbk->inode, &this_args_cbk->stat,
+ &this_args_cbk->preparent, &this_args_cbk->postparent);
+ if (rsp_args->op_ret) {
+ rsp_args->op_errno = -rsp_args->op_ret;
+ rsp_args->op_ret = -1;
}
- rsp_args->op_ret = this_args_cbk->op_ret;
- rsp_args->op_errno = gf_errno_to_error
- (this_args_cbk->op_errno);
- break;
+ }
+ break;
}
- case GF_FOP_OPEN:
- {
- gfs3_open_rsp *rsp_args = NULL;
-
- rsp_args = &this_rsp->compound_rsp_u.compound_open_rsp;
+ case GF_FOP_FTRUNCATE: {
+ gfs3_ftruncate_rsp *rsp_args = NULL;
- GF_PROTOCOL_DICT_SERIALIZE (this, this_args_cbk->xdata,
- &rsp_args->xdata.xdata_val,
- rsp_args->xdata.xdata_len,
- rsp_args->op_errno, out);
+ rsp_args = &this_rsp->compound_rsp_u.compound_ftruncate_rsp;
- if (!this_args_cbk->op_ret) {
- server_post_open (frame, this, rsp_args,
- this_args_cbk->fd);
+ GF_PROTOCOL_DICT_SERIALIZE(
+ this, this_args_cbk->xdata, &rsp_args->xdata.xdata_val,
+ rsp_args->xdata.xdata_len, rsp_args->op_errno, out);
- }
- rsp_args->op_ret = this_args_cbk->op_ret;
- rsp_args->op_errno = gf_errno_to_error
- (this_args_cbk->op_errno);
- break;
+ if (!this_args_cbk->op_ret) {
+ server_post_ftruncate(rsp_args, &this_args_cbk->prestat,
+ &this_args_cbk->poststat);
+ }
+ rsp_args->op_ret = this_args_cbk->op_ret;
+ rsp_args->op_errno = gf_errno_to_error(this_args_cbk->op_errno);
+ break;
}
- case GF_FOP_READ:
- {
- gfs3_read_rsp *rsp_args = NULL;
-
- rsp_args = &this_rsp->compound_rsp_u.compound_read_rsp;
-
- GF_PROTOCOL_DICT_SERIALIZE (this, this_args_cbk->xdata,
- &rsp_args->xdata.xdata_val,
- rsp_args->xdata.xdata_len,
- rsp_args->op_errno, out);
-
- if (this_args_cbk->op_ret >= 0) {
- server_post_readv (rsp_args, &this_args_cbk->stat,
- this_args_cbk->op_ret);
-
- if (!state->rsp_iobref) {
- state->rsp_iobref = this_args_cbk->iobref;
- state->rsp_count = 0;
- }
- iobref_merge (state->rsp_iobref,
- this_args_cbk->iobref);
- memcpy (&state->rsp_vector[state->rsp_count],
- this_args_cbk->vector,
- (this_args_cbk->count *
- sizeof(state->rsp_vector[0])));
- state->rsp_count += this_args_cbk->count;
- }
- rsp_args->op_ret = this_args_cbk->op_ret;
- rsp_args->op_errno = gf_errno_to_error
- (this_args_cbk->op_errno);
- break;
- }
- case GF_FOP_WRITE:
- {
- gfs3_write_rsp *rsp_args = NULL;
+ case GF_FOP_FSTAT: {
+ gfs3_fstat_rsp *rsp_args = NULL;
- rsp_args = &this_rsp->compound_rsp_u.compound_write_rsp;
+ rsp_args = &this_rsp->compound_rsp_u.compound_fstat_rsp;
- GF_PROTOCOL_DICT_SERIALIZE (this, this_args_cbk->xdata,
- &rsp_args->xdata.xdata_val,
- rsp_args->xdata.xdata_len,
- rsp_args->op_errno, out);
-
- if (this_args_cbk->op_ret >= 0) {
- server_post_writev (rsp_args,
- &this_args_cbk->prestat,
- &this_args_cbk->poststat);
- }
- rsp_args->op_ret = this_args_cbk->op_ret;
- rsp_args->op_errno = gf_errno_to_error
- (this_args_cbk->op_errno);
- break;
+ GF_PROTOCOL_DICT_SERIALIZE(
+ this, this_args_cbk->xdata, &rsp_args->xdata.xdata_val,
+ rsp_args->xdata.xdata_len, rsp_args->op_errno, out);
+ if (!this_args_cbk->op_ret) {
+ server_post_fstat(state, rsp_args, &this_args_cbk->stat);
+ }
+ rsp_args->op_ret = this_args_cbk->op_ret;
+ rsp_args->op_errno = gf_errno_to_error(this_args_cbk->op_errno);
+ break;
}
- case GF_FOP_STATFS:
- {
- gfs3_statfs_rsp *rsp_args = NULL;
+ case GF_FOP_LK: {
+ gfs3_lk_rsp *rsp_args = NULL;
- rsp_args = &this_rsp->compound_rsp_u.compound_statfs_rsp;
+ rsp_args = &this_rsp->compound_rsp_u.compound_lk_rsp;
- GF_PROTOCOL_DICT_SERIALIZE (this, this_args_cbk->xdata,
- &rsp_args->xdata.xdata_val,
- rsp_args->xdata.xdata_len,
- rsp_args->op_errno, out);
- if (!this_args_cbk->op_ret) {
- server_post_statfs (rsp_args,
- &this_args_cbk->statvfs);
- }
- rsp_args->op_ret = this_args_cbk->op_ret;
- rsp_args->op_errno = gf_errno_to_error
- (this_args_cbk->op_errno);
- break;
- }
- case GF_FOP_FLUSH:
- {
- gf_common_rsp *rsp_args = NULL;
+ GF_PROTOCOL_DICT_SERIALIZE(
+ this, this_args_cbk->xdata, &rsp_args->xdata.xdata_val,
+ rsp_args->xdata.xdata_len, rsp_args->op_errno, out);
- rsp_args = &this_rsp->compound_rsp_u.compound_flush_rsp;
+ if (!this_args_cbk->op_ret) {
+ server_post_lk(this, rsp_args, &this_args_cbk->lock);
+ }
- GF_PROTOCOL_DICT_SERIALIZE (this, this_args_cbk->xdata,
- &rsp_args->xdata.xdata_val,
- rsp_args->xdata.xdata_len,
- rsp_args->op_errno, out);
- rsp_args->op_ret = this_args_cbk->op_ret;
- rsp_args->op_errno = gf_errno_to_error
- (this_args_cbk->op_errno);
- break;
+ rsp_args->op_ret = this_args_cbk->op_ret;
+ rsp_args->op_errno = gf_errno_to_error(this_args_cbk->op_errno);
+ break;
}
- case GF_FOP_FSYNC:
- {
- gfs3_fsync_rsp *rsp_args = NULL;
+ case GF_FOP_LOOKUP: {
+ gfs3_lookup_rsp *rsp_args = NULL;
- rsp_args = &this_rsp->compound_rsp_u.compound_fsync_rsp;
+ rsp_args = &this_rsp->compound_rsp_u.compound_lookup_rsp;
- GF_PROTOCOL_DICT_SERIALIZE (this, this_args_cbk->xdata,
- &rsp_args->xdata.xdata_val,
- rsp_args->xdata.xdata_len,
- rsp_args->op_errno, out);
-
- if (!this_args_cbk->op_ret) {
- server_post_fsync (rsp_args,
- &this_args_cbk->prestat,
- &this_args_cbk->poststat);
- }
- rsp_args->op_ret = this_args_cbk->op_ret;
- rsp_args->op_errno = gf_errno_to_error
- (this_args_cbk->op_errno);
- break;
+ GF_PROTOCOL_DICT_SERIALIZE(
+ this, this_args_cbk->xdata, &rsp_args->xdata.xdata_val,
+ rsp_args->xdata.xdata_len, rsp_args->op_errno, out);
+
+ if (!this_args_cbk->op_ret) {
+ server_post_lookup(rsp_args, frame, state, this_args_cbk->inode,
+ &this_args_cbk->stat,
+ &this_args_cbk->postparent);
+ }
+ rsp_args->op_ret = this_args_cbk->op_ret;
+ rsp_args->op_errno = gf_errno_to_error(this_args_cbk->op_errno);
+ break;
}
- case GF_FOP_SETXATTR:
- {
- gf_common_rsp *rsp_args = NULL;
+ case GF_FOP_READDIR: {
+ gfs3_readdir_rsp *rsp_args = NULL;
+
+ rsp_args = &this_rsp->compound_rsp_u.compound_readdir_rsp;
+
+ GF_PROTOCOL_DICT_SERIALIZE(
+ this, this_args_cbk->xdata, &rsp_args->xdata.xdata_val,
+ rsp_args->xdata.xdata_len, rsp_args->op_errno, out);
- rsp_args = &this_rsp->compound_rsp_u.compound_setxattr_rsp;
+ rsp_args->op_ret = this_args_cbk->op_ret;
+ rsp_args->op_errno = gf_errno_to_error(this_args_cbk->op_errno);
- if (gf_replace_old_iatt_in_dict (this_args_cbk->xdata)) {
- rsp_args->op_errno = errno;
- rsp_args->op_ret = -1;
- goto out;
- }
-
- GF_PROTOCOL_DICT_SERIALIZE (this, this_args_cbk->xdata,
- &rsp_args->xdata.xdata_val,
- rsp_args->xdata.xdata_len,
- rsp_args->op_errno, out);
- rsp_args->op_ret = this_args_cbk->op_ret;
- rsp_args->op_errno = gf_errno_to_error
- (this_args_cbk->op_errno);
- break;
+ if (this_args_cbk->op_ret > 0) {
+ ret = server_post_readdir(rsp_args, &this_args_cbk->entries);
+ if (ret < 0) {
+ rsp_args->op_ret = ret;
+ rsp_args->op_errno = ENOMEM;
+ }
+ }
+ break;
+ }
+ case GF_FOP_INODELK: {
+ gf_common_rsp *rsp_args = NULL;
+
+ rsp_args = &this_rsp->compound_rsp_u.compound_inodelk_rsp;
+
+ GF_PROTOCOL_DICT_SERIALIZE(
+ this, this_args_cbk->xdata, &rsp_args->xdata.xdata_val,
+ rsp_args->xdata.xdata_len, rsp_args->op_errno, out);
+ rsp_args->op_ret = this_args_cbk->op_ret;
+ rsp_args->op_errno = gf_errno_to_error(this_args_cbk->op_errno);
+ break;
}
- case GF_FOP_GETXATTR:
- {
- gfs3_getxattr_rsp *rsp_args = NULL;
-
- rsp_args = &this_rsp->compound_rsp_u.compound_getxattr_rsp;
+ case GF_FOP_FINODELK: {
+ gf_common_rsp *rsp_args = NULL;
+
+ rsp_args = &this_rsp->compound_rsp_u.compound_finodelk_rsp;
+
+ GF_PROTOCOL_DICT_SERIALIZE(
+ this, this_args_cbk->xdata, &rsp_args->xdata.xdata_val,
+ rsp_args->xdata.xdata_len, rsp_args->op_errno, out);
+ rsp_args->op_ret = this_args_cbk->op_ret;
+ rsp_args->op_errno = gf_errno_to_error(this_args_cbk->op_errno);
+ break;
+ }
+ case GF_FOP_ENTRYLK: {
+ gf_common_rsp *rsp_args = NULL;
+
+ rsp_args = &this_rsp->compound_rsp_u.compound_entrylk_rsp;
- GF_PROTOCOL_DICT_SERIALIZE (this, this_args_cbk->xdata,
- &rsp_args->xdata.xdata_val,
- rsp_args->xdata.xdata_len,
- rsp_args->op_errno, out);
+ GF_PROTOCOL_DICT_SERIALIZE(
+ this, this_args_cbk->xdata, &rsp_args->xdata.xdata_val,
+ rsp_args->xdata.xdata_len, rsp_args->op_errno, out);
+ rsp_args->op_ret = this_args_cbk->op_ret;
+ rsp_args->op_errno = gf_errno_to_error(this_args_cbk->op_errno);
+ break;
+ }
+ case GF_FOP_FENTRYLK: {
+ gf_common_rsp *rsp_args = NULL;
+
+ rsp_args = &this_rsp->compound_rsp_u.compound_fentrylk_rsp;
- if (-1 != this_args_cbk->op_ret) {
- GF_PROTOCOL_DICT_SERIALIZE (this,
- this_args_cbk->xattr,
- &rsp_args->dict.dict_val,
- rsp_args->dict.dict_len,
- rsp_args->op_errno, out);
- }
- rsp_args->op_ret = this_args_cbk->op_ret;
- rsp_args->op_errno = gf_errno_to_error
- (this_args_cbk->op_errno);
- break;
+ GF_PROTOCOL_DICT_SERIALIZE(
+ this, this_args_cbk->xdata, &rsp_args->xdata.xdata_val,
+ rsp_args->xdata.xdata_len, rsp_args->op_errno, out);
+ rsp_args->op_ret = this_args_cbk->op_ret;
+ rsp_args->op_errno = gf_errno_to_error(this_args_cbk->op_errno);
+ break;
}
- case GF_FOP_REMOVEXATTR:
- {
- gf_common_rsp *rsp_args = NULL;
-
- rsp_args = &this_rsp->compound_rsp_u.compound_removexattr_rsp;
+ case GF_FOP_XATTROP: {
+ gfs3_xattrop_rsp *rsp_args = NULL;
+
+ rsp_args = &this_rsp->compound_rsp_u.compound_xattrop_rsp;
- if (gf_replace_old_iatt_in_dict (this_args_cbk->xdata)) {
- rsp_args->op_errno = errno;
- rsp_args->op_ret = -1;
- goto out;
- }
+ GF_PROTOCOL_DICT_SERIALIZE(
+ this, this_args_cbk->xdata, &rsp_args->xdata.xdata_val,
+ rsp_args->xdata.xdata_len, rsp_args->op_errno, out);
- GF_PROTOCOL_DICT_SERIALIZE (this, this_args_cbk->xdata,
- &rsp_args->xdata.xdata_val,
- rsp_args->xdata.xdata_len,
- rsp_args->op_errno, out);
- rsp_args->op_ret = this_args_cbk->op_ret;
- rsp_args->op_errno = gf_errno_to_error
- (this_args_cbk->op_errno);
- break;
+ if (!this_args_cbk->op_ret) {
+ GF_PROTOCOL_DICT_SERIALIZE(
+ this, this_args_cbk->xattr, &rsp_args->dict.dict_val,
+ rsp_args->dict.dict_len, rsp_args->op_errno, out);
+ }
+ rsp_args->op_ret = this_args_cbk->op_ret;
+ rsp_args->op_errno = gf_errno_to_error(this_args_cbk->op_errno);
+ break;
+ }
+ case GF_FOP_FXATTROP: {
+ gfs3_fxattrop_rsp *rsp_args = NULL;
+
+ rsp_args = &this_rsp->compound_rsp_u.compound_fxattrop_rsp;
+
+ GF_PROTOCOL_DICT_SERIALIZE(
+ this, this_args_cbk->xdata, &rsp_args->xdata.xdata_val,
+ rsp_args->xdata.xdata_len, rsp_args->op_errno, out);
+
+ if (!this_args_cbk->op_ret) {
+ GF_PROTOCOL_DICT_SERIALIZE(
+ this, this_args_cbk->xattr, &rsp_args->dict.dict_val,
+ rsp_args->dict.dict_len, rsp_args->op_errno, out);
+ }
+ rsp_args->op_ret = this_args_cbk->op_ret;
+ rsp_args->op_errno = gf_errno_to_error(this_args_cbk->op_errno);
+ break;
}
- case GF_FOP_OPENDIR:
- {
- gfs3_opendir_rsp *rsp_args = NULL;
+ case GF_FOP_FGETXATTR: {
+ gfs3_fgetxattr_rsp *rsp_args = NULL;
+
+ rsp_args = &this_rsp->compound_rsp_u.compound_fgetxattr_rsp;
+
+ GF_PROTOCOL_DICT_SERIALIZE(
+ this, this_args_cbk->xdata, &rsp_args->xdata.xdata_val,
+ rsp_args->xdata.xdata_len, rsp_args->op_errno, out);
+
+ if (-1 != this_args_cbk->op_ret) {
+ GF_PROTOCOL_DICT_SERIALIZE(
+ this, this_args_cbk->xattr, &rsp_args->dict.dict_val,
+ rsp_args->dict.dict_len, rsp_args->op_errno, out);
+ }
+ rsp_args->op_ret = this_args_cbk->op_ret;
+ rsp_args->op_errno = gf_errno_to_error(this_args_cbk->op_errno);
+ break;
+ }
+ case GF_FOP_FSETXATTR: {
+ gf_common_rsp *rsp_args = NULL;
+
+ rsp_args = &this_rsp->compound_rsp_u.compound_setxattr_rsp;
+
+ if (gf_replace_old_iatt_in_dict(this_args_cbk->xdata)) {
+ rsp_args->op_errno = errno;
+ rsp_args->op_ret = -1;
+ goto out;
+ }
+
+ GF_PROTOCOL_DICT_SERIALIZE(
+ this, this_args_cbk->xdata, &rsp_args->xdata.xdata_val,
+ rsp_args->xdata.xdata_len, rsp_args->op_errno, out);
+ rsp_args->op_ret = this_args_cbk->op_ret;
+ rsp_args->op_errno = gf_errno_to_error(this_args_cbk->op_errno);
+ break;
+ }
+ case GF_FOP_RCHECKSUM: {
+ gfs3_rchecksum_rsp *rsp_args = NULL;
+
+ rsp_args = &this_rsp->compound_rsp_u.compound_rchecksum_rsp;
+
+ GF_PROTOCOL_DICT_SERIALIZE(
+ this, this_args_cbk->xdata, &rsp_args->xdata.xdata_val,
+ rsp_args->xdata.xdata_len, rsp_args->op_errno, out);
+
+ if (!this_args_cbk->op_ret) {
+ server_post_rchecksum(rsp_args, this_args_cbk->weak_checksum,
+ this_args_cbk->strong_checksum);
+ }
+ rsp_args->op_ret = this_args_cbk->op_ret;
+ rsp_args->op_errno = gf_errno_to_error(this_args_cbk->op_errno);
+ break;
+ }
+ case GF_FOP_SETATTR: {
+ gfs3_setattr_rsp *rsp_args = NULL;
+
+ rsp_args = &this_rsp->compound_rsp_u.compound_setattr_rsp;
+
+ GF_PROTOCOL_DICT_SERIALIZE(
+ this, this_args_cbk->xdata, &rsp_args->xdata.xdata_val,
+ rsp_args->xdata.xdata_len, rsp_args->op_errno, out);
+
+ if (!this_args_cbk->op_ret) {
+ server_post_setattr(rsp_args, &this_args_cbk->prestat,
+ &this_args_cbk->poststat);
+ }
+ rsp_args->op_ret = this_args_cbk->op_ret;
+ rsp_args->op_errno = gf_errno_to_error(this_args_cbk->op_errno);
+ break;
+ }
+ case GF_FOP_FSETATTR: {
+ gfs3_fsetattr_rsp *rsp_args = NULL;
+
+ rsp_args = &this_rsp->compound_rsp_u.compound_fsetattr_rsp;
+
+ GF_PROTOCOL_DICT_SERIALIZE(
+ this, this_args_cbk->xdata, &rsp_args->xdata.xdata_val,
+ rsp_args->xdata.xdata_len, rsp_args->op_errno, out);
+
+ if (!this_args_cbk->op_ret) {
+ server_post_fsetattr(rsp_args, &this_args_cbk->prestat,
+ &this_args_cbk->poststat);
+ }
+ rsp_args->op_ret = this_args_cbk->op_ret;
+ rsp_args->op_errno = gf_errno_to_error(this_args_cbk->op_errno);
+ break;
+ }
+ case GF_FOP_READDIRP: {
+ gfs3_readdirp_rsp *rsp_args = NULL;
+
+ rsp_args = &this_rsp->compound_rsp_u.compound_readdirp_rsp;
+
+ GF_PROTOCOL_DICT_SERIALIZE(
+ this, this_args_cbk->xdata, &rsp_args->xdata.xdata_val,
+ rsp_args->xdata.xdata_len, rsp_args->op_errno, out);
+
+ if (this_args_cbk->op_ret > 0) {
+ ret = server_post_readdirp(rsp_args, &this_args_cbk->entries);
+ if (ret < 0) {
+ rsp_args->op_ret = ret;
+ rsp_args->op_errno = ENOMEM;
+ goto out;
+ }
+ gf_link_inodes_from_dirent(this, state->fd->inode,
+ &this_args_cbk->entries);
+ }
+ rsp_args->op_ret = this_args_cbk->op_ret;
+ rsp_args->op_errno = gf_errno_to_error(this_args_cbk->op_errno);
+ break;
+ }
+ case GF_FOP_FREMOVEXATTR: {
+ gf_common_rsp *rsp_args = NULL;
+
+ rsp_args = &this_rsp->compound_rsp_u.compound_fremovexattr_rsp;
+
+ if (gf_replace_old_iatt_in_dict(this_args_cbk->xdata)) {
+ rsp_args->op_errno = errno;
+ rsp_args->op_ret = -1;
+ goto out;
+ }
- rsp_args = &this_rsp->compound_rsp_u.compound_opendir_rsp;
+ GF_PROTOCOL_DICT_SERIALIZE(
+ this, this_args_cbk->xdata, &rsp_args->xdata.xdata_val,
+ rsp_args->xdata.xdata_len, rsp_args->op_errno, out);
+ rsp_args->op_ret = this_args_cbk->op_ret;
+ rsp_args->op_errno = gf_errno_to_error(this_args_cbk->op_errno);
+ break;
+ }
+ case GF_FOP_FALLOCATE: {
+ gfs3_fallocate_rsp *rsp_args = NULL;
- GF_PROTOCOL_DICT_SERIALIZE (this, this_args_cbk->xdata,
- &rsp_args->xdata.xdata_val,
- rsp_args->xdata.xdata_len,
- rsp_args->op_errno, out);
+ rsp_args = &this_rsp->compound_rsp_u.compound_fallocate_rsp;
- if (!this_args_cbk->op_ret) {
- server_post_opendir (frame, this, rsp_args,
- this_args_cbk->fd);
+ GF_PROTOCOL_DICT_SERIALIZE(
+ this, this_args_cbk->xdata, &rsp_args->xdata.xdata_val,
+ rsp_args->xdata.xdata_len, rsp_args->op_errno, out);
- }
- rsp_args->op_ret = this_args_cbk->op_ret;
- rsp_args->op_errno = gf_errno_to_error
- (this_args_cbk->op_errno);
- break;
+ if (!this_args_cbk->op_ret) {
+ server_post_fallocate(rsp_args, &this_args_cbk->prestat,
+ &this_args_cbk->poststat);
+ }
+ rsp_args->op_ret = this_args_cbk->op_ret;
+ rsp_args->op_errno = gf_errno_to_error(this_args_cbk->op_errno);
+ break;
}
- case GF_FOP_FSYNCDIR:
- {
- gf_common_rsp *rsp_args = NULL;
-
- rsp_args = &this_rsp->compound_rsp_u.compound_fsyncdir_rsp;
+ case GF_FOP_DISCARD: {
+ gfs3_discard_rsp *rsp_args = NULL;
- GF_PROTOCOL_DICT_SERIALIZE (this, this_args_cbk->xdata,
- &rsp_args->xdata.xdata_val,
- rsp_args->xdata.xdata_len,
- rsp_args->op_errno, out);
- rsp_args->op_ret = this_args_cbk->op_ret;
- rsp_args->op_errno = gf_errno_to_error
- (this_args_cbk->op_errno);
- break;
- }
- case GF_FOP_ACCESS:
- {
- gf_common_rsp *rsp_args = NULL;
+ rsp_args = &this_rsp->compound_rsp_u.compound_discard_rsp;
- rsp_args = &this_rsp->compound_rsp_u.compound_access_rsp;
+ GF_PROTOCOL_DICT_SERIALIZE(
+ this, this_args_cbk->xdata, &rsp_args->xdata.xdata_val,
+ rsp_args->xdata.xdata_len, rsp_args->op_errno, out);
- GF_PROTOCOL_DICT_SERIALIZE (this, this_args_cbk->xdata,
- &rsp_args->xdata.xdata_val,
- rsp_args->xdata.xdata_len,
- rsp_args->op_errno, out);
- rsp_args->op_ret = this_args_cbk->op_ret;
- rsp_args->op_errno = gf_errno_to_error
- (this_args_cbk->op_errno);
- break;
+ if (!this_args_cbk->op_ret) {
+ server_post_discard(rsp_args, &this_args_cbk->prestat,
+ &this_args_cbk->poststat);
+ }
+ rsp_args->op_ret = this_args_cbk->op_ret;
+ rsp_args->op_errno = gf_errno_to_error(this_args_cbk->op_errno);
+ break;
}
- case GF_FOP_CREATE:
- {
- gfs3_create_rsp *rsp_args = NULL;
-
- rsp_args = &this_rsp->compound_rsp_u.compound_create_rsp;
-
- GF_PROTOCOL_DICT_SERIALIZE (this, this_args_cbk->xdata,
- &rsp_args->xdata.xdata_val,
- rsp_args->xdata.xdata_len,
- rsp_args->op_errno, out);
-
- rsp_args->op_ret = this_args_cbk->op_ret;
- rsp_args->op_errno = gf_errno_to_error
- (this_args_cbk->op_errno);
-
- if (!this_args_cbk->op_ret) {
- rsp_args->op_ret = server_post_create (frame,
- rsp_args, state, this,
- this_args_cbk->fd,
- this_args_cbk->inode,
- &this_args_cbk->stat,
- &this_args_cbk->preparent,
- &this_args_cbk->postparent);
- if (rsp_args->op_ret) {
- rsp_args->op_errno = -rsp_args->op_ret;
- rsp_args->op_ret = -1;
- }
- }
- break;
- }
- case GF_FOP_FTRUNCATE:
- {
- gfs3_ftruncate_rsp *rsp_args = NULL;
+ case GF_FOP_ZEROFILL: {
+ gfs3_zerofill_rsp *rsp_args = NULL;
- rsp_args = &this_rsp->compound_rsp_u.compound_ftruncate_rsp;
+ rsp_args = &this_rsp->compound_rsp_u.compound_zerofill_rsp;
- GF_PROTOCOL_DICT_SERIALIZE (this, this_args_cbk->xdata,
- &rsp_args->xdata.xdata_val,
- rsp_args->xdata.xdata_len,
- rsp_args->op_errno, out);
+ GF_PROTOCOL_DICT_SERIALIZE(
+ this, this_args_cbk->xdata, &rsp_args->xdata.xdata_val,
+ rsp_args->xdata.xdata_len, rsp_args->op_errno, out);
- if (!this_args_cbk->op_ret) {
- server_post_ftruncate (rsp_args,
- &this_args_cbk->prestat,
- &this_args_cbk->poststat);
- }
- rsp_args->op_ret = this_args_cbk->op_ret;
- rsp_args->op_errno = gf_errno_to_error
- (this_args_cbk->op_errno);
- break;
+ if (!this_args_cbk->op_ret) {
+ server_post_zerofill(rsp_args, &this_args_cbk->prestat,
+ &this_args_cbk->poststat);
+ }
+ rsp_args->op_ret = this_args_cbk->op_ret;
+ rsp_args->op_errno = gf_errno_to_error(this_args_cbk->op_errno);
+ break;
}
- case GF_FOP_FSTAT:
- {
- gfs3_fstat_rsp *rsp_args = NULL;
+ case GF_FOP_SEEK: {
+ gfs3_seek_rsp *rsp_args = NULL;
- rsp_args = &this_rsp->compound_rsp_u.compound_fstat_rsp;
+ rsp_args = &this_rsp->compound_rsp_u.compound_seek_rsp;
- GF_PROTOCOL_DICT_SERIALIZE (this, this_args_cbk->xdata,
- &rsp_args->xdata.xdata_val,
- rsp_args->xdata.xdata_len,
- rsp_args->op_errno, out);
- if (!this_args_cbk->op_ret) {
- server_post_fstat (state, rsp_args,
- &this_args_cbk->stat);
- }
- rsp_args->op_ret = this_args_cbk->op_ret;
- rsp_args->op_errno = gf_errno_to_error
- (this_args_cbk->op_errno);
- break;
+ GF_PROTOCOL_DICT_SERIALIZE(
+ this, this_args_cbk->xdata, &rsp_args->xdata.xdata_val,
+ rsp_args->xdata.xdata_len, rsp_args->op_errno, out);
+ rsp_args->op_ret = this_args_cbk->op_ret;
+ rsp_args->op_errno = gf_errno_to_error(this_args_cbk->op_errno);
+ break;
}
- case GF_FOP_LK:
- {
- gfs3_lk_rsp *rsp_args = NULL;
+ case GF_FOP_LEASE: {
+ gfs3_lease_rsp *rsp_args = NULL;
- rsp_args = &this_rsp->compound_rsp_u.compound_lk_rsp;
+ rsp_args = &this_rsp->compound_rsp_u.compound_lease_rsp;
- GF_PROTOCOL_DICT_SERIALIZE (this, this_args_cbk->xdata,
- &rsp_args->xdata.xdata_val,
- rsp_args->xdata.xdata_len,
- rsp_args->op_errno, out);
+ GF_PROTOCOL_DICT_SERIALIZE(
+ this, this_args_cbk->xdata, &rsp_args->xdata.xdata_val,
+ rsp_args->xdata.xdata_len, rsp_args->op_errno, out);
- if (!this_args_cbk->op_ret) {
- server_post_lk (this, rsp_args, &this_args_cbk->lock);
- }
+ if (!this_args_cbk->op_ret) {
+ server_post_lease(rsp_args, &this_args_cbk->lease);
+ }
- rsp_args->op_ret = this_args_cbk->op_ret;
- rsp_args->op_errno = gf_errno_to_error
- (this_args_cbk->op_errno);
- break;
+ rsp_args->op_ret = this_args_cbk->op_ret;
+ rsp_args->op_errno = gf_errno_to_error(this_args_cbk->op_errno);
+ break;
}
- case GF_FOP_LOOKUP:
- {
- gfs3_lookup_rsp *rsp_args = NULL;
+ default:
+ return ENOTSUP;
+ }
+ op_errno = 0;
+out:
+ return op_errno;
+}
+/* This works only when the compound fop acts on one loc/inode/gfid.
+ * If compound fops on more than one inode is required, multiple
+ * resolve and resumes will have to be done. This will have to change.
+ * Right now, multiple unlinks, rmdirs etc is are not supported.
+ * This can be added for future enhancements.
+ */
+int
+server_get_compound_resolve(server_state_t *state, gfs3_compound_req *req)
+{
+ int i = 0;
+ compound_req *array = &req->compound_req_array.compound_req_array_val[i];
- rsp_args = &this_rsp->compound_rsp_u.compound_lookup_rsp;
+ switch (array->fop_enum) {
+ case GF_FOP_STAT: {
+ gfs3_stat_req this_req = {{
+ 0,
+ }};
- GF_PROTOCOL_DICT_SERIALIZE (this, this_args_cbk->xdata,
- &rsp_args->xdata.xdata_val,
- rsp_args->xdata.xdata_len,
- rsp_args->op_errno, out);
+ this_req = array[i].compound_req_u.compound_stat_req;
- if (!this_args_cbk->op_ret) {
- server_post_lookup (rsp_args, frame, state,
- this_args_cbk->inode,
- &this_args_cbk->stat,
- &this_args_cbk->postparent);
- }
- rsp_args->op_ret = this_args_cbk->op_ret;
- rsp_args->op_errno = gf_errno_to_error
- (this_args_cbk->op_errno);
- break;
- }
- case GF_FOP_READDIR:
- {
- gfs3_readdir_rsp *rsp_args = NULL;
-
- rsp_args = &this_rsp->compound_rsp_u.compound_readdir_rsp;
-
- GF_PROTOCOL_DICT_SERIALIZE (this, this_args_cbk->xdata,
- &rsp_args->xdata.xdata_val,
- rsp_args->xdata.xdata_len,
- rsp_args->op_errno, out);
-
- rsp_args->op_ret = this_args_cbk->op_ret;
- rsp_args->op_errno = gf_errno_to_error
- (this_args_cbk->op_errno);
-
- if (this_args_cbk->op_ret > 0) {
- ret = server_post_readdir (rsp_args,
- &this_args_cbk->entries);
- if (ret < 0) {
- rsp_args->op_ret = ret;
- rsp_args->op_errno = ENOMEM;
- }
- }
- break;
+ state->resolve.type = RESOLVE_MUST;
+ memcpy(state->resolve.gfid, this_req.gfid, 16);
+ break;
}
- case GF_FOP_INODELK:
- {
- gf_common_rsp *rsp_args = NULL;
+ case GF_FOP_READLINK: {
+ gfs3_readlink_req this_req = {{
+ 0,
+ }};
- rsp_args = &this_rsp->compound_rsp_u.compound_inodelk_rsp;
+ this_req = array[i].compound_req_u.compound_readlink_req;
- GF_PROTOCOL_DICT_SERIALIZE (this, this_args_cbk->xdata,
- &rsp_args->xdata.xdata_val,
- rsp_args->xdata.xdata_len,
- rsp_args->op_errno, out);
- rsp_args->op_ret = this_args_cbk->op_ret;
- rsp_args->op_errno = gf_errno_to_error
- (this_args_cbk->op_errno);
- break;
+ state->resolve.type = RESOLVE_MUST;
+ memcpy(state->resolve.gfid, this_req.gfid, 16);
+ break;
}
- case GF_FOP_FINODELK:
- {
- gf_common_rsp *rsp_args = NULL;
+ case GF_FOP_MKNOD: {
+ gfs3_mknod_req this_req = {{
+ 0,
+ }};
- rsp_args = &this_rsp->compound_rsp_u.compound_finodelk_rsp;
+ this_req = array[i].compound_req_u.compound_mknod_req;
- GF_PROTOCOL_DICT_SERIALIZE (this, this_args_cbk->xdata,
- &rsp_args->xdata.xdata_val,
- rsp_args->xdata.xdata_len,
- rsp_args->op_errno, out);
- rsp_args->op_ret = this_args_cbk->op_ret;
- rsp_args->op_errno = gf_errno_to_error
- (this_args_cbk->op_errno);
- break;
+ state->resolve.type = RESOLVE_NOT;
+ memcpy(state->resolve.pargfid, this_req.pargfid, 16);
+ state->resolve.bname = gf_strdup(this_req.bname);
+ break;
}
- case GF_FOP_ENTRYLK:
- {
- gf_common_rsp *rsp_args = NULL;
+ case GF_FOP_MKDIR: {
+ gfs3_mkdir_req this_req = {{
+ 0,
+ }};
- rsp_args = &this_rsp->compound_rsp_u.compound_entrylk_rsp;
+ this_req = array[i].compound_req_u.compound_mkdir_req;
- GF_PROTOCOL_DICT_SERIALIZE (this, this_args_cbk->xdata,
- &rsp_args->xdata.xdata_val,
- rsp_args->xdata.xdata_len,
- rsp_args->op_errno, out);
- rsp_args->op_ret = this_args_cbk->op_ret;
- rsp_args->op_errno = gf_errno_to_error
- (this_args_cbk->op_errno);
- break;
+ state->resolve.type = RESOLVE_NOT;
+ memcpy(state->resolve.pargfid, this_req.pargfid, 16);
+ state->resolve.bname = gf_strdup(this_req.bname);
+ break;
}
- case GF_FOP_FENTRYLK:
- {
- gf_common_rsp *rsp_args = NULL;
+ case GF_FOP_UNLINK: {
+ gfs3_unlink_req this_req = {{
+ 0,
+ }};
- rsp_args = &this_rsp->compound_rsp_u.compound_fentrylk_rsp;
+ this_req = array[i].compound_req_u.compound_unlink_req;
- GF_PROTOCOL_DICT_SERIALIZE (this, this_args_cbk->xdata,
- &rsp_args->xdata.xdata_val,
- rsp_args->xdata.xdata_len,
- rsp_args->op_errno, out);
- rsp_args->op_ret = this_args_cbk->op_ret;
- rsp_args->op_errno = gf_errno_to_error
- (this_args_cbk->op_errno);
- break;
+ state->resolve.type = RESOLVE_MUST;
+ memcpy(state->resolve.pargfid, this_req.pargfid, 16);
+ state->resolve.bname = gf_strdup(this_req.bname);
+ break;
}
- case GF_FOP_XATTROP:
- {
- gfs3_xattrop_rsp *rsp_args = NULL;
-
- rsp_args = &this_rsp->compound_rsp_u.compound_xattrop_rsp;
+ case GF_FOP_RMDIR: {
+ gfs3_rmdir_req this_req = {{
+ 0,
+ }};
- GF_PROTOCOL_DICT_SERIALIZE (this, this_args_cbk->xdata,
- &rsp_args->xdata.xdata_val,
- rsp_args->xdata.xdata_len,
- rsp_args->op_errno, out);
+ this_req = array[i].compound_req_u.compound_rmdir_req;
- if (!this_args_cbk->op_ret) {
- GF_PROTOCOL_DICT_SERIALIZE (this,
- this_args_cbk->xattr,
- &rsp_args->dict.dict_val,
- rsp_args->dict.dict_len,
- rsp_args->op_errno, out);
- }
- rsp_args->op_ret = this_args_cbk->op_ret;
- rsp_args->op_errno = gf_errno_to_error
- (this_args_cbk->op_errno);
- break;
+ state->resolve.type = RESOLVE_MUST;
+ memcpy(state->resolve.pargfid, this_req.pargfid, 16);
+ state->resolve.bname = gf_strdup(this_req.bname);
+ break;
}
- case GF_FOP_FXATTROP:
- {
- gfs3_fxattrop_rsp *rsp_args = NULL;
+ case GF_FOP_SYMLINK: {
+ gfs3_symlink_req this_req = {{
+ 0,
+ }};
- rsp_args = &this_rsp->compound_rsp_u.compound_fxattrop_rsp;
+ this_req = array[i].compound_req_u.compound_symlink_req;
- GF_PROTOCOL_DICT_SERIALIZE (this, this_args_cbk->xdata,
- &rsp_args->xdata.xdata_val,
- rsp_args->xdata.xdata_len,
- rsp_args->op_errno, out);
-
- if (!this_args_cbk->op_ret) {
- GF_PROTOCOL_DICT_SERIALIZE (this,
- this_args_cbk->xattr,
- &rsp_args->dict.dict_val,
- rsp_args->dict.dict_len,
- rsp_args->op_errno, out);
- }
- rsp_args->op_ret = this_args_cbk->op_ret;
- rsp_args->op_errno = gf_errno_to_error
- (this_args_cbk->op_errno);
- break;
+ state->resolve.type = RESOLVE_NOT;
+ memcpy(state->resolve.pargfid, this_req.pargfid, 16);
+ state->resolve.bname = gf_strdup(this_req.bname);
+ break;
}
- case GF_FOP_FGETXATTR:
- {
- gfs3_fgetxattr_rsp *rsp_args = NULL;
+ case GF_FOP_RENAME: {
+ gfs3_rename_req this_req = {{
+ 0,
+ }};
- rsp_args = &this_rsp->compound_rsp_u.compound_fgetxattr_rsp;
+ this_req = array[i].compound_req_u.compound_rename_req;
- GF_PROTOCOL_DICT_SERIALIZE (this, this_args_cbk->xdata,
- &rsp_args->xdata.xdata_val,
- rsp_args->xdata.xdata_len,
- rsp_args->op_errno, out);
+ state->resolve.type = RESOLVE_MUST;
+ state->resolve.bname = gf_strdup(this_req.oldbname);
+ memcpy(state->resolve.pargfid, this_req.oldgfid, 16);
- if (-1 != this_args_cbk->op_ret) {
- GF_PROTOCOL_DICT_SERIALIZE (this, this_args_cbk->xattr,
- &rsp_args->dict.dict_val,
- rsp_args->dict.dict_len,
- rsp_args->op_errno, out);
- }
- rsp_args->op_ret = this_args_cbk->op_ret;
- rsp_args->op_errno = gf_errno_to_error
- (this_args_cbk->op_errno);
- break;
+ state->resolve2.type = RESOLVE_MAY;
+ state->resolve2.bname = gf_strdup(this_req.newbname);
+ memcpy(state->resolve2.pargfid, this_req.newgfid, 16);
+ break;
}
- case GF_FOP_FSETXATTR:
- {
- gf_common_rsp *rsp_args = NULL;
+ case GF_FOP_LINK: {
+ gfs3_link_req this_req = {{
+ 0,
+ }};
- rsp_args = &this_rsp->compound_rsp_u.compound_setxattr_rsp;
+ this_req = array[i].compound_req_u.compound_link_req;
- if (gf_replace_old_iatt_in_dict (this_args_cbk->xdata)) {
- rsp_args->op_errno = errno;
- rsp_args->op_ret = -1;
- goto out;
- }
+ state->resolve.type = RESOLVE_MUST;
+ memcpy(state->resolve.gfid, this_req.oldgfid, 16);
- GF_PROTOCOL_DICT_SERIALIZE (this, this_args_cbk->xdata,
- &rsp_args->xdata.xdata_val,
- rsp_args->xdata.xdata_len,
- rsp_args->op_errno, out);
- rsp_args->op_ret = this_args_cbk->op_ret;
- rsp_args->op_errno = gf_errno_to_error
- (this_args_cbk->op_errno);
- break;
+ state->resolve2.type = RESOLVE_NOT;
+ state->resolve2.bname = gf_strdup(this_req.newbname);
+ memcpy(state->resolve2.pargfid, this_req.newgfid, 16);
+ break;
}
- case GF_FOP_RCHECKSUM:
- {
- gfs3_rchecksum_rsp *rsp_args = NULL;
-
- rsp_args = &this_rsp->compound_rsp_u.compound_rchecksum_rsp;
+ case GF_FOP_TRUNCATE: {
+ gfs3_truncate_req this_req = {{
+ 0,
+ }};
- GF_PROTOCOL_DICT_SERIALIZE (this, this_args_cbk->xdata,
- &rsp_args->xdata.xdata_val,
- rsp_args->xdata.xdata_len,
- rsp_args->op_errno, out);
+ this_req = array[i].compound_req_u.compound_truncate_req;
- if (!this_args_cbk->op_ret) {
- server_post_rchecksum (rsp_args,
- this_args_cbk->weak_checksum,
- this_args_cbk->strong_checksum);
- }
- rsp_args->op_ret = this_args_cbk->op_ret;
- rsp_args->op_errno = gf_errno_to_error
- (this_args_cbk->op_errno);
- break;
+ state->resolve.type = RESOLVE_MUST;
+ memcpy(state->resolve.gfid, this_req.gfid, 16);
+ break;
}
- case GF_FOP_SETATTR:
- {
- gfs3_setattr_rsp *rsp_args = NULL;
+ case GF_FOP_OPEN: {
+ gfs3_open_req this_req = {{
+ 0,
+ }};
- rsp_args = &this_rsp->compound_rsp_u.compound_setattr_rsp;
+ this_req = array[i].compound_req_u.compound_open_req;
- GF_PROTOCOL_DICT_SERIALIZE (this, this_args_cbk->xdata,
- &rsp_args->xdata.xdata_val,
- rsp_args->xdata.xdata_len,
- rsp_args->op_errno, out);
-
- if (!this_args_cbk->op_ret) {
- server_post_setattr (rsp_args,
- &this_args_cbk->prestat,
- &this_args_cbk->poststat);
- }
- rsp_args->op_ret = this_args_cbk->op_ret;
- rsp_args->op_errno = gf_errno_to_error
- (this_args_cbk->op_errno);
- break;
+ state->resolve.type = RESOLVE_MUST;
+ memcpy(state->resolve.gfid, this_req.gfid, 16);
+ break;
}
- case GF_FOP_FSETATTR:
- {
- gfs3_fsetattr_rsp *rsp_args = NULL;
+ case GF_FOP_READ: {
+ gfs3_read_req this_req = {{
+ 0,
+ }};
- rsp_args = &this_rsp->compound_rsp_u.compound_fsetattr_rsp;
+ this_req = array[i].compound_req_u.compound_read_req;
- GF_PROTOCOL_DICT_SERIALIZE (this, this_args_cbk->xdata,
- &rsp_args->xdata.xdata_val,
- rsp_args->xdata.xdata_len,
- rsp_args->op_errno, out);
-
- if (!this_args_cbk->op_ret) {
- server_post_fsetattr (rsp_args, &this_args_cbk->prestat,
- &this_args_cbk->poststat);
- }
- rsp_args->op_ret = this_args_cbk->op_ret;
- rsp_args->op_errno = gf_errno_to_error
- (this_args_cbk->op_errno);
- break;
+ state->resolve.type = RESOLVE_MUST;
+ memcpy(state->resolve.gfid, this_req.gfid, 16);
+ break;
}
- case GF_FOP_READDIRP:
- {
- gfs3_readdirp_rsp *rsp_args = NULL;
-
- rsp_args = &this_rsp->compound_rsp_u.compound_readdirp_rsp;
-
- GF_PROTOCOL_DICT_SERIALIZE (this, this_args_cbk->xdata,
- &rsp_args->xdata.xdata_val,
- rsp_args->xdata.xdata_len,
- rsp_args->op_errno, out);
-
- if (this_args_cbk->op_ret > 0) {
- ret = server_post_readdirp (rsp_args,
- &this_args_cbk->entries);
- if (ret < 0) {
- rsp_args->op_ret = ret;
- rsp_args->op_errno = ENOMEM;
- goto out;
- }
- gf_link_inodes_from_dirent (this, state->fd->inode,
- &this_args_cbk->entries);
- }
- rsp_args->op_ret = this_args_cbk->op_ret;
- rsp_args->op_errno = gf_errno_to_error
- (this_args_cbk->op_errno);
- break;
- }
- case GF_FOP_FREMOVEXATTR:
- {
- gf_common_rsp *rsp_args = NULL;
+ case GF_FOP_WRITE: {
+ gfs3_write_req this_req = {{
+ 0,
+ }};
- rsp_args = &this_rsp->compound_rsp_u.compound_fremovexattr_rsp;
-
- if (gf_replace_old_iatt_in_dict (this_args_cbk->xdata)) {
- rsp_args->op_errno = errno;
- rsp_args->op_ret = -1;
- goto out;
- }
+ this_req = array[i].compound_req_u.compound_write_req;
- GF_PROTOCOL_DICT_SERIALIZE (this, this_args_cbk->xdata,
- &rsp_args->xdata.xdata_val,
- rsp_args->xdata.xdata_len,
- rsp_args->op_errno, out);
- rsp_args->op_ret = this_args_cbk->op_ret;
- rsp_args->op_errno = gf_errno_to_error
- (this_args_cbk->op_errno);
- break;
+ state->resolve.type = RESOLVE_MUST;
+ memcpy(state->resolve.gfid, this_req.gfid, 16);
+ break;
}
- case GF_FOP_FALLOCATE:
- {
- gfs3_fallocate_rsp *rsp_args = NULL;
-
- rsp_args = &this_rsp->compound_rsp_u.compound_fallocate_rsp;
+ case GF_FOP_STATFS: {
+ gfs3_statfs_req this_req = {{
+ 0,
+ }};
- GF_PROTOCOL_DICT_SERIALIZE (this, this_args_cbk->xdata,
- &rsp_args->xdata.xdata_val,
- rsp_args->xdata.xdata_len,
- rsp_args->op_errno, out);
+ this_req = array[i].compound_req_u.compound_statfs_req;
- if (!this_args_cbk->op_ret) {
- server_post_fallocate (rsp_args,
- &this_args_cbk->prestat,
- &this_args_cbk->poststat);
- }
- rsp_args->op_ret = this_args_cbk->op_ret;
- rsp_args->op_errno = gf_errno_to_error
- (this_args_cbk->op_errno);
- break;
+ state->resolve.type = RESOLVE_MUST;
+ memcpy(state->resolve.gfid, this_req.gfid, 16);
+ break;
}
- case GF_FOP_DISCARD:
- {
- gfs3_discard_rsp *rsp_args = NULL;
+ case GF_FOP_FLUSH: {
+ gfs3_flush_req this_req = {{
+ 0,
+ }};
- rsp_args = &this_rsp->compound_rsp_u.compound_discard_rsp;
+ this_req = array[i].compound_req_u.compound_flush_req;
- GF_PROTOCOL_DICT_SERIALIZE (this, this_args_cbk->xdata,
- &rsp_args->xdata.xdata_val,
- rsp_args->xdata.xdata_len,
- rsp_args->op_errno, out);
-
- if (!this_args_cbk->op_ret) {
- server_post_discard (rsp_args,
- &this_args_cbk->prestat,
- &this_args_cbk->poststat);
- }
- rsp_args->op_ret = this_args_cbk->op_ret;
- rsp_args->op_errno = gf_errno_to_error
- (this_args_cbk->op_errno);
- break;
+ state->resolve.type = RESOLVE_MUST;
+ memcpy(state->resolve.gfid, this_req.gfid, 16);
+ state->resolve.fd_no = this_req.fd;
+ break;
}
- case GF_FOP_ZEROFILL:
- {
- gfs3_zerofill_rsp *rsp_args = NULL;
+ case GF_FOP_FSYNC: {
+ gfs3_fsync_req this_req = {{
+ 0,
+ }};
- rsp_args = &this_rsp->compound_rsp_u.compound_zerofill_rsp;
+ this_req = array[i].compound_req_u.compound_fsync_req;
- GF_PROTOCOL_DICT_SERIALIZE (this, this_args_cbk->xdata,
- &rsp_args->xdata.xdata_val,
- rsp_args->xdata.xdata_len,
- rsp_args->op_errno, out);
-
- if (!this_args_cbk->op_ret) {
- server_post_zerofill (rsp_args,
- &this_args_cbk->prestat,
- &this_args_cbk->poststat);
- }
- rsp_args->op_ret = this_args_cbk->op_ret;
- rsp_args->op_errno = gf_errno_to_error
- (this_args_cbk->op_errno);
- break;
+ state->resolve.type = RESOLVE_MUST;
+ memcpy(state->resolve.gfid, this_req.gfid, 16);
+ state->resolve.fd_no = this_req.fd;
+ break;
}
- case GF_FOP_SEEK:
- {
- gfs3_seek_rsp *rsp_args = NULL;
+ case GF_FOP_SETXATTR: {
+ gfs3_setxattr_req this_req = {{
+ 0,
+ }};
- rsp_args = &this_rsp->compound_rsp_u.compound_seek_rsp;
+ this_req = array[i].compound_req_u.compound_setxattr_req;
- GF_PROTOCOL_DICT_SERIALIZE (this, this_args_cbk->xdata,
- &rsp_args->xdata.xdata_val,
- rsp_args->xdata.xdata_len,
- rsp_args->op_errno, out);
- rsp_args->op_ret = this_args_cbk->op_ret;
- rsp_args->op_errno = gf_errno_to_error
- (this_args_cbk->op_errno);
- break;
+ state->resolve.type = RESOLVE_MUST;
+ memcpy(state->resolve.gfid, this_req.gfid, 16);
+ break;
}
- case GF_FOP_LEASE:
- {
- gfs3_lease_rsp *rsp_args = NULL;
+ case GF_FOP_GETXATTR: {
+ gfs3_getxattr_req this_req = {{
+ 0,
+ }};
- rsp_args = &this_rsp->compound_rsp_u.compound_lease_rsp;
+ this_req = array[i].compound_req_u.compound_getxattr_req;
- GF_PROTOCOL_DICT_SERIALIZE (this, this_args_cbk->xdata,
- &rsp_args->xdata.xdata_val,
- rsp_args->xdata.xdata_len,
- rsp_args->op_errno, out);
-
- if (!this_args_cbk->op_ret) {
- server_post_lease (rsp_args, &this_args_cbk->lease);
- }
-
- rsp_args->op_ret = this_args_cbk->op_ret;
- rsp_args->op_errno = gf_errno_to_error
- (this_args_cbk->op_errno);
- break;
- }
- default:
- return ENOTSUP;
+ state->resolve.type = RESOLVE_MUST;
+ memcpy(state->resolve.gfid, this_req.gfid, 16);
+ break;
}
- op_errno = 0;
-out:
- return op_errno;
-}
-/* This works only when the compound fop acts on one loc/inode/gfid.
- * If compound fops on more than one inode is required, multiple
- * resolve and resumes will have to be done. This will have to change.
- * Right now, multiple unlinks, rmdirs etc is are not supported.
- * This can be added for future enhancements.
- */
-int
-server_get_compound_resolve (server_state_t *state, gfs3_compound_req *req)
-{
- int i = 0;
- compound_req *array = &req->compound_req_array.compound_req_array_val[i];
+ case GF_FOP_REMOVEXATTR: {
+ gfs3_removexattr_req this_req = {{
+ 0,
+ }};
- switch (array->fop_enum) {
- case GF_FOP_STAT:
- {
- gfs3_stat_req this_req = { {0,} };
-
- this_req = array[i].compound_req_u.compound_stat_req;
+ this_req = array[i].compound_req_u.compound_removexattr_req;
- state->resolve.type = RESOLVE_MUST;
- memcpy (state->resolve.gfid,
- this_req.gfid, 16);
- break;
+ state->resolve.type = RESOLVE_MUST;
+ memcpy(state->resolve.gfid, this_req.gfid, 16);
+ break;
}
- case GF_FOP_READLINK:
- {
- gfs3_readlink_req this_req = { {0,} };
+ case GF_FOP_OPENDIR: {
+ gfs3_opendir_req this_req = {{
+ 0,
+ }};
- this_req = array[i].compound_req_u.compound_readlink_req;
+ this_req = array[i].compound_req_u.compound_opendir_req;
- state->resolve.type = RESOLVE_MUST;
- memcpy (state->resolve.gfid,
- this_req.gfid, 16);
- break;
+ state->resolve.type = RESOLVE_MUST;
+ memcpy(state->resolve.gfid, this_req.gfid, 16);
+ break;
}
- case GF_FOP_MKNOD:
- {
- gfs3_mknod_req this_req = { {0,} };
+ case GF_FOP_FSYNCDIR: {
+ gfs3_fsyncdir_req this_req = {{
+ 0,
+ }};
- this_req = array[i].compound_req_u.compound_mknod_req;
+ this_req = array[i].compound_req_u.compound_fsyncdir_req;
- state->resolve.type = RESOLVE_NOT;
- memcpy (state->resolve.pargfid, this_req.pargfid, 16);
- state->resolve.bname = gf_strdup
- (this_req.bname);
- break;
+ state->resolve.type = RESOLVE_MUST;
+ memcpy(state->resolve.gfid, this_req.gfid, 16);
+ state->resolve.fd_no = this_req.fd;
+ break;
}
- case GF_FOP_MKDIR:
- {
- gfs3_mkdir_req this_req = { {0,} };
+ case GF_FOP_ACCESS: {
+ gfs3_access_req this_req = {{
+ 0,
+ }};
- this_req = array[i].compound_req_u.compound_mkdir_req;
+ this_req = array[i].compound_req_u.compound_access_req;
- state->resolve.type = RESOLVE_NOT;
- memcpy (state->resolve.pargfid, this_req.pargfid, 16);
- state->resolve.bname = gf_strdup
- (this_req.bname);
- break;
+ state->resolve.type = RESOLVE_MUST;
+ memcpy(state->resolve.gfid, this_req.gfid, 16);
+ break;
}
- case GF_FOP_UNLINK:
- {
- gfs3_unlink_req this_req = { {0,} };
-
- this_req = array[i].compound_req_u.compound_unlink_req;
+ case GF_FOP_CREATE: {
+ gfs3_create_req this_req = {{
+ 0,
+ }};
- state->resolve.type = RESOLVE_MUST;
- memcpy (state->resolve.pargfid, this_req.pargfid, 16);
- state->resolve.bname = gf_strdup
- (this_req.bname);
- break;
- }
- case GF_FOP_RMDIR:
- {
- gfs3_rmdir_req this_req = { {0,} };
+ this_req = array[i].compound_req_u.compound_create_req;
- this_req = array[i].compound_req_u.compound_rmdir_req;
+ state->flags = gf_flags_to_flags(this_req.flags);
+ if (state->flags & O_EXCL) {
+ state->resolve.type = RESOLVE_NOT;
+ } else {
+ state->resolve.type = RESOLVE_DONTCARE;
+ }
- state->resolve.type = RESOLVE_MUST;
- memcpy (state->resolve.pargfid, this_req.pargfid, 16);
- state->resolve.bname = gf_strdup
- (this_req.bname);
- break;
+ memcpy(state->resolve.pargfid, this_req.pargfid, 16);
+ state->resolve.bname = gf_strdup(this_req.bname);
+ break;
}
- case GF_FOP_SYMLINK:
- {
- gfs3_symlink_req this_req = { {0,} };
+ case GF_FOP_FTRUNCATE: {
+ gfs3_ftruncate_req this_req = {{
+ 0,
+ }};
- this_req = array[i].compound_req_u.compound_symlink_req;
+ this_req = array[i].compound_req_u.compound_ftruncate_req;
- state->resolve.type = RESOLVE_NOT;
- memcpy (state->resolve.pargfid, this_req.pargfid, 16);
- state->resolve.bname = gf_strdup
- (this_req.bname);
- break;
+ state->resolve.type = RESOLVE_MUST;
+ memcpy(state->resolve.gfid, this_req.gfid, 16);
+ state->resolve.fd_no = this_req.fd;
+ break;
}
- case GF_FOP_RENAME:
- {
- gfs3_rename_req this_req = { {0,} };
+ case GF_FOP_FSTAT: {
+ gfs3_fstat_req this_req = {{
+ 0,
+ }};
- this_req = array[i].compound_req_u.compound_rename_req;
+ this_req = array[i].compound_req_u.compound_fstat_req;
- state->resolve.type = RESOLVE_MUST;
- state->resolve.bname = gf_strdup
- (this_req.oldbname);
- memcpy (state->resolve.pargfid, this_req.oldgfid, 16);
-
- state->resolve2.type = RESOLVE_MAY;
- state->resolve2.bname = gf_strdup
- (this_req.newbname);
- memcpy (state->resolve2.pargfid, this_req.newgfid, 16);
- break;
+ state->resolve.type = RESOLVE_MUST;
+ memcpy(state->resolve.gfid, this_req.gfid, 16);
+ state->resolve.fd_no = this_req.fd;
+ break;
}
- case GF_FOP_LINK:
- {
- gfs3_link_req this_req = { {0,} };
+ case GF_FOP_LK: {
+ gfs3_lk_req this_req = {{
+ 0,
+ }};
- this_req = array[i].compound_req_u.compound_link_req;
+ this_req = array[i].compound_req_u.compound_lk_req;
- state->resolve.type = RESOLVE_MUST;
- memcpy (state->resolve.gfid, this_req.oldgfid, 16);
-
- state->resolve2.type = RESOLVE_NOT;
- state->resolve2.bname = gf_strdup
- (this_req.newbname);
- memcpy (state->resolve2.pargfid, this_req.newgfid, 16);
- break;
+ memcpy(state->resolve.gfid, this_req.gfid, 16);
+ state->resolve.fd_no = this_req.fd;
+ break;
}
- case GF_FOP_TRUNCATE:
- {
- gfs3_truncate_req this_req = { {0,} };
+ case GF_FOP_LOOKUP: {
+ gfs3_lookup_req this_req = {{
+ 0,
+ }};
- this_req = array[i].compound_req_u.compound_truncate_req;
+ this_req = array[i].compound_req_u.compound_lookup_req;
+ state->resolve.type = RESOLVE_DONTCARE;
- state->resolve.type = RESOLVE_MUST;
- memcpy (state->resolve.gfid,
- this_req.gfid, 16);
- break;
+ if (this_req.bname && strcmp(this_req.bname, "")) {
+ memcpy(state->resolve.pargfid, this_req.pargfid, 16);
+ state->resolve.bname = gf_strdup(this_req.bname);
+ } else {
+ memcpy(state->resolve.gfid, this_req.gfid, 16);
+ }
+ break;
}
- case GF_FOP_OPEN:
- {
- gfs3_open_req this_req = { {0,} };
+ case GF_FOP_READDIR: {
+ gfs3_readdir_req this_req = {{
+ 0,
+ }};
- this_req = array[i].compound_req_u.compound_open_req;
+ this_req = array[i].compound_req_u.compound_readdir_req;
- state->resolve.type = RESOLVE_MUST;
- memcpy (state->resolve.gfid,
- this_req.gfid, 16);
- break;
+ state->resolve.type = RESOLVE_MUST;
+ memcpy(state->resolve.gfid, this_req.gfid, 16);
+ state->resolve.fd_no = this_req.fd;
+ break;
}
- case GF_FOP_READ:
- {
- gfs3_read_req this_req = { {0,} };
+ case GF_FOP_INODELK: {
+ gfs3_inodelk_req this_req = {{
+ 0,
+ }};
- this_req = array[i].compound_req_u.compound_read_req;
+ this_req = array[i].compound_req_u.compound_inodelk_req;
- state->resolve.type = RESOLVE_MUST;
- memcpy (state->resolve.gfid,
- this_req.gfid, 16);
- break;
+ state->resolve.type = RESOLVE_EXACT;
+ memcpy(state->resolve.gfid, this_req.gfid, 16);
+ break;
}
- case GF_FOP_WRITE:
- {
- gfs3_write_req this_req = { {0,} };
+ case GF_FOP_FINODELK: {
+ gfs3_finodelk_req this_req = {{
+ 0,
+ }};
- this_req = array[i].compound_req_u.compound_write_req;
+ this_req = array[i].compound_req_u.compound_finodelk_req;
- state->resolve.type = RESOLVE_MUST;
- memcpy (state->resolve.gfid,
- this_req.gfid, 16);
- break;
+ state->resolve.type = RESOLVE_EXACT;
+ memcpy(state->resolve.gfid, this_req.gfid, 16);
+ state->resolve.fd_no = this_req.fd;
+ break;
}
- case GF_FOP_STATFS:
- {
- gfs3_statfs_req this_req = { {0,} };
+ case GF_FOP_ENTRYLK: {
+ gfs3_entrylk_req this_req = {{
+ 0,
+ }};
- this_req = array[i].compound_req_u.compound_statfs_req;
+ this_req = array[i].compound_req_u.compound_entrylk_req;
- state->resolve.type = RESOLVE_MUST;
- memcpy (state->resolve.gfid,
- this_req.gfid, 16);
- break;
+ state->resolve.type = RESOLVE_EXACT;
+ memcpy(state->resolve.gfid, this_req.gfid, 16);
+ break;
}
- case GF_FOP_FLUSH:
- {
- gfs3_flush_req this_req = { {0,} };
+ case GF_FOP_FENTRYLK: {
+ gfs3_fentrylk_req this_req = {{
+ 0,
+ }};
- this_req = array[i].compound_req_u.compound_flush_req;
+ this_req = array[i].compound_req_u.compound_fentrylk_req;
- state->resolve.type = RESOLVE_MUST;
- memcpy (state->resolve.gfid,
- this_req.gfid, 16);
- state->resolve.fd_no = this_req.fd;
- break;
+ state->resolve.type = RESOLVE_EXACT;
+ memcpy(state->resolve.gfid, this_req.gfid, 16);
+ state->resolve.fd_no = this_req.fd;
+ break;
}
- case GF_FOP_FSYNC:
- {
- gfs3_fsync_req this_req = { {0,} };
+ case GF_FOP_XATTROP: {
+ gfs3_xattrop_req this_req = {{
+ 0,
+ }};
- this_req = array[i].compound_req_u.compound_fsync_req;
+ this_req = array[i].compound_req_u.compound_xattrop_req;
- state->resolve.type = RESOLVE_MUST;
- memcpy (state->resolve.gfid,
- this_req.gfid, 16);
- state->resolve.fd_no = this_req.fd;
- break;
+ state->resolve.type = RESOLVE_MUST;
+ memcpy(state->resolve.gfid, this_req.gfid, 16);
+ break;
}
- case GF_FOP_SETXATTR:
- {
- gfs3_setxattr_req this_req = { {0,} };
+ case GF_FOP_FXATTROP: {
+ gfs3_fxattrop_req this_req = {{
+ 0,
+ }};
- this_req = array[i].compound_req_u.compound_setxattr_req;
+ this_req = array[i].compound_req_u.compound_fxattrop_req;
- state->resolve.type = RESOLVE_MUST;
- memcpy (state->resolve.gfid,
- this_req.gfid, 16);
- break;
+ state->resolve.type = RESOLVE_MUST;
+ memcpy(state->resolve.gfid, this_req.gfid, 16);
+ state->resolve.fd_no = this_req.fd;
+ break;
}
- case GF_FOP_GETXATTR:
- {
- gfs3_getxattr_req this_req = { {0,} };
+ case GF_FOP_FGETXATTR: {
+ gfs3_fgetxattr_req this_req = {{
+ 0,
+ }};
- this_req = array[i].compound_req_u.compound_getxattr_req;
+ this_req = array[i].compound_req_u.compound_fgetxattr_req;
- state->resolve.type = RESOLVE_MUST;
- memcpy (state->resolve.gfid,
- this_req.gfid, 16);
- break;
+ state->resolve.type = RESOLVE_MUST;
+ memcpy(state->resolve.gfid, this_req.gfid, 16);
+ state->resolve.fd_no = this_req.fd;
+ break;
}
- case GF_FOP_REMOVEXATTR:
- {
- gfs3_removexattr_req this_req = { {0,} };
+ case GF_FOP_FSETXATTR: {
+ gfs3_fsetxattr_req this_req = {{
+ 0,
+ }};
- this_req = array[i].compound_req_u.compound_removexattr_req;
+ this_req = array[i].compound_req_u.compound_fsetxattr_req;
- state->resolve.type = RESOLVE_MUST;
- memcpy (state->resolve.gfid,
- this_req.gfid, 16);
- break;
+ state->resolve.type = RESOLVE_MUST;
+ memcpy(state->resolve.gfid, this_req.gfid, 16);
+ state->resolve.fd_no = this_req.fd;
+ break;
}
- case GF_FOP_OPENDIR:
- {
- gfs3_opendir_req this_req = { {0,} };
+ case GF_FOP_RCHECKSUM: {
+ gfs3_rchecksum_req this_req = {
+ 0,
+ };
- this_req = array[i].compound_req_u.compound_opendir_req;
+ this_req = array[i].compound_req_u.compound_rchecksum_req;
- state->resolve.type = RESOLVE_MUST;
- memcpy (state->resolve.gfid,
- this_req.gfid, 16);
- break;
+ state->resolve.type = RESOLVE_MAY;
+ state->resolve.fd_no = this_req.fd;
+ break;
}
- case GF_FOP_FSYNCDIR:
- {
- gfs3_fsyncdir_req this_req = { {0,} };
+ case GF_FOP_SETATTR: {
+ gfs3_setattr_req this_req = {{
+ 0,
+ }};
- this_req = array[i].compound_req_u.compound_fsyncdir_req;
+ this_req = array[i].compound_req_u.compound_setattr_req;
- state->resolve.type = RESOLVE_MUST;
- memcpy (state->resolve.gfid,
- this_req.gfid, 16);
- state->resolve.fd_no = this_req.fd;
- break;
+ state->resolve.type = RESOLVE_MUST;
+ memcpy(state->resolve.gfid, this_req.gfid, 16);
+ break;
}
- case GF_FOP_ACCESS:
- {
- gfs3_access_req this_req = { {0,} };
+ case GF_FOP_FSETATTR: {
+ gfs3_fsetattr_req this_req = {
+ 0,
+ };
- this_req = array[i].compound_req_u.compound_access_req;
+ this_req = array[i].compound_req_u.compound_fsetattr_req;
- state->resolve.type = RESOLVE_MUST;
- memcpy (state->resolve.gfid,
- this_req.gfid, 16);
- break;
+ state->resolve.type = RESOLVE_MUST;
+ state->resolve.fd_no = this_req.fd;
+ break;
}
- case GF_FOP_CREATE:
- {
- gfs3_create_req this_req = { {0,} };
-
- this_req = array[i].compound_req_u.compound_create_req;
+ case GF_FOP_READDIRP: {
+ gfs3_readdirp_req this_req = {{
+ 0,
+ }};
- state->flags = gf_flags_to_flags (this_req.flags);
- if (state->flags & O_EXCL) {
- state->resolve.type = RESOLVE_NOT;
- } else {
- state->resolve.type = RESOLVE_DONTCARE;
- }
+ this_req = array[i].compound_req_u.compound_readdirp_req;
- memcpy (state->resolve.pargfid, this_req.pargfid, 16);
- state->resolve.bname = gf_strdup
- (this_req.bname);
- break;
+ state->resolve.type = RESOLVE_MUST;
+ memcpy(state->resolve.gfid, this_req.gfid, 16);
+ state->resolve.fd_no = this_req.fd;
+ break;
}
- case GF_FOP_FTRUNCATE:
- {
- gfs3_ftruncate_req this_req = { {0,} };
+ case GF_FOP_FREMOVEXATTR: {
+ gfs3_fremovexattr_req this_req = {{
+ 0,
+ }};
- this_req = array[i].compound_req_u.compound_ftruncate_req;
+ this_req = array[i].compound_req_u.compound_fremovexattr_req;
- state->resolve.type = RESOLVE_MUST;
- memcpy (state->resolve.gfid,
- this_req.gfid, 16);
- state->resolve.fd_no = this_req.fd;
- break;
+ state->resolve.type = RESOLVE_MUST;
+ memcpy(state->resolve.gfid, this_req.gfid, 16);
+ state->resolve.fd_no = this_req.fd;
+ break;
}
- case GF_FOP_FSTAT:
- {
- gfs3_fstat_req this_req = { {0,} };
+ case GF_FOP_FALLOCATE: {
+ gfs3_fallocate_req this_req = {{
+ 0,
+ }};
- this_req = array[i].compound_req_u.compound_fstat_req;
+ this_req = array[i].compound_req_u.compound_fallocate_req;
- state->resolve.type = RESOLVE_MUST;
- memcpy (state->resolve.gfid,
- this_req.gfid, 16);
- state->resolve.fd_no = this_req.fd;
- break;
+ state->resolve.type = RESOLVE_MUST;
+ memcpy(state->resolve.gfid, this_req.gfid, 16);
+ state->resolve.fd_no = this_req.fd;
+ break;
}
- case GF_FOP_LK:
- {
- gfs3_lk_req this_req = { {0,} };
+ case GF_FOP_DISCARD: {
+ gfs3_discard_req this_req = {{
+ 0,
+ }};
- this_req = array[i].compound_req_u.compound_lk_req;
+ this_req = array[i].compound_req_u.compound_discard_req;
- memcpy (state->resolve.gfid,
- this_req.gfid, 16);
- state->resolve.fd_no = this_req.fd;
- break;
+ state->resolve.type = RESOLVE_MUST;
+ memcpy(state->resolve.gfid, this_req.gfid, 16);
+ state->resolve.fd_no = this_req.fd;
+ break;
}
- case GF_FOP_LOOKUP:
- {
- gfs3_lookup_req this_req = { {0,} };
+ case GF_FOP_ZEROFILL: {
+ gfs3_zerofill_req this_req = {{
+ 0,
+ }};
- this_req = array[i].compound_req_u.compound_lookup_req;
- state->resolve.type = RESOLVE_DONTCARE;
+ this_req = array[i].compound_req_u.compound_zerofill_req;
- if (this_req.bname && strcmp (this_req.bname, "")) {
- memcpy (state->resolve.pargfid, this_req.pargfid, 16);
- state->resolve.bname = gf_strdup
- (this_req.bname);
- } else {
- memcpy (state->resolve.gfid, this_req.gfid, 16);
- }
- break;
+ state->resolve.type = RESOLVE_MUST;
+ memcpy(state->resolve.gfid, this_req.gfid, 16);
+ state->resolve.fd_no = this_req.fd;
+ break;
}
- case GF_FOP_READDIR:
- {
- gfs3_readdir_req this_req = { {0,} };
+ case GF_FOP_SEEK: {
+ gfs3_seek_req this_req = {{
+ 0,
+ }};
- this_req = array[i].compound_req_u.compound_readdir_req;
+ this_req = array[i].compound_req_u.compound_seek_req;
- state->resolve.type = RESOLVE_MUST;
- memcpy (state->resolve.gfid,
- this_req.gfid, 16);
- state->resolve.fd_no = this_req.fd;
- break;
+ state->resolve.type = RESOLVE_MUST;
+ memcpy(state->resolve.gfid, this_req.gfid, 16);
+ state->resolve.fd_no = this_req.fd;
+ break;
}
- case GF_FOP_INODELK:
- {
- gfs3_inodelk_req this_req = { {0,} };
+ case GF_FOP_LEASE: {
+ gfs3_lease_req this_req = {{
+ 0,
+ }};
- this_req = array[i].compound_req_u.compound_inodelk_req;
+ this_req = array[i].compound_req_u.compound_lease_req;
- state->resolve.type = RESOLVE_EXACT;
- memcpy (state->resolve.gfid,
- this_req.gfid, 16);
- break;
+ state->resolve.type = RESOLVE_MUST;
+ memcpy(state->resolve.gfid, this_req.gfid, 16);
+ break;
}
- case GF_FOP_FINODELK:
- {
- gfs3_finodelk_req this_req = { {0,} };
+ default:
+ return ENOTSUP;
+ }
+ return 0;
+}
- this_req = array[i].compound_req_u.compound_finodelk_req;
+void
+server_compound_rsp_cleanup(gfs3_compound_rsp *rsp, compound_args_cbk_t *args)
+{
+ int i, len = 0;
+ compound_rsp *this_rsp = NULL;
- state->resolve.type = RESOLVE_EXACT;
- memcpy (state->resolve.gfid,
- this_req.gfid, 16);
- state->resolve.fd_no = this_req.fd;
- break;
- }
- case GF_FOP_ENTRYLK:
- {
- gfs3_entrylk_req this_req = { {0,} };
+ if (!rsp->compound_rsp_array.compound_rsp_array_val)
+ return;
- this_req = array[i].compound_req_u.compound_entrylk_req;
+ len = rsp->compound_rsp_array.compound_rsp_array_len;
- state->resolve.type = RESOLVE_EXACT;
- memcpy (state->resolve.gfid,
- this_req.gfid, 16);
+ for (i = 0; i < len; i++) {
+ this_rsp = &rsp->compound_rsp_array.compound_rsp_array_val[i];
+ switch (args->enum_list[i]) {
+ case GF_FOP_STAT:
+ SERVER_FOP_RSP_CLEANUP(rsp, stat, i);
break;
- }
- case GF_FOP_FENTRYLK:
- {
- gfs3_fentrylk_req this_req = { {0,} };
-
- this_req = array[i].compound_req_u.compound_fentrylk_req;
-
- state->resolve.type = RESOLVE_EXACT;
- memcpy (state->resolve.gfid,
- this_req.gfid, 16);
- state->resolve.fd_no = this_req.fd;
+ case GF_FOP_MKNOD:
+ SERVER_FOP_RSP_CLEANUP(rsp, mknod, i);
break;
- }
- case GF_FOP_XATTROP:
- {
- gfs3_xattrop_req this_req = { {0,} };
-
- this_req = array[i].compound_req_u.compound_xattrop_req;
-
- state->resolve.type = RESOLVE_MUST;
- memcpy (state->resolve.gfid,
- this_req.gfid, 16);
+ case GF_FOP_MKDIR:
+ SERVER_FOP_RSP_CLEANUP(rsp, mkdir, i);
break;
- }
- case GF_FOP_FXATTROP:
- {
- gfs3_fxattrop_req this_req = { {0,} };
-
- this_req = array[i].compound_req_u.compound_fxattrop_req;
-
- state->resolve.type = RESOLVE_MUST;
- memcpy (state->resolve.gfid,
- this_req.gfid, 16);
- state->resolve.fd_no = this_req.fd;
+ case GF_FOP_UNLINK:
+ SERVER_FOP_RSP_CLEANUP(rsp, unlink, i);
break;
- }
- case GF_FOP_FGETXATTR:
- {
- gfs3_fgetxattr_req this_req = { {0,} };
-
- this_req = array[i].compound_req_u.compound_fgetxattr_req;
-
- state->resolve.type = RESOLVE_MUST;
- memcpy (state->resolve.gfid,
- this_req.gfid, 16);
- state->resolve.fd_no = this_req.fd;
+ case GF_FOP_RMDIR:
+ SERVER_FOP_RSP_CLEANUP(rsp, rmdir, i);
break;
- }
- case GF_FOP_FSETXATTR:
- {
- gfs3_fsetxattr_req this_req = { {0,} };
-
- this_req = array[i].compound_req_u.compound_fsetxattr_req;
-
- state->resolve.type = RESOLVE_MUST;
- memcpy (state->resolve.gfid,
- this_req.gfid, 16);
- state->resolve.fd_no = this_req.fd;
+ case GF_FOP_SYMLINK:
+ SERVER_FOP_RSP_CLEANUP(rsp, symlink, i);
break;
- }
- case GF_FOP_RCHECKSUM:
- {
- gfs3_rchecksum_req this_req = {0,};
-
- this_req = array[i].compound_req_u.compound_rchecksum_req;
-
- state->resolve.type = RESOLVE_MAY;
- state->resolve.fd_no = this_req.fd;
+ case GF_FOP_RENAME:
+ SERVER_FOP_RSP_CLEANUP(rsp, rename, i);
break;
- }
- case GF_FOP_SETATTR:
- {
- gfs3_setattr_req this_req = { {0,} };
-
- this_req = array[i].compound_req_u.compound_setattr_req;
-
- state->resolve.type = RESOLVE_MUST;
- memcpy (state->resolve.gfid,
- this_req.gfid, 16);
+ case GF_FOP_LINK:
+ SERVER_FOP_RSP_CLEANUP(rsp, link, i);
break;
- }
- case GF_FOP_FSETATTR:
- {
- gfs3_fsetattr_req this_req = {0,};
-
- this_req = array[i].compound_req_u.compound_fsetattr_req;
-
- state->resolve.type = RESOLVE_MUST;
- state->resolve.fd_no = this_req.fd;
+ case GF_FOP_TRUNCATE:
+ SERVER_FOP_RSP_CLEANUP(rsp, truncate, i);
break;
- }
- case GF_FOP_READDIRP:
- {
- gfs3_readdirp_req this_req = { {0,} };
-
- this_req = array[i].compound_req_u.compound_readdirp_req;
-
- state->resolve.type = RESOLVE_MUST;
- memcpy (state->resolve.gfid,
- this_req.gfid, 16);
- state->resolve.fd_no = this_req.fd;
+ case GF_FOP_OPEN:
+ SERVER_FOP_RSP_CLEANUP(rsp, open, i);
break;
- }
- case GF_FOP_FREMOVEXATTR:
- {
- gfs3_fremovexattr_req this_req = { {0,} };
-
- this_req = array[i].compound_req_u.compound_fremovexattr_req;
-
- state->resolve.type = RESOLVE_MUST;
- memcpy (state->resolve.gfid,
- this_req.gfid, 16);
- state->resolve.fd_no = this_req.fd;
+ case GF_FOP_READ:
+ SERVER_FOP_RSP_CLEANUP(rsp, read, i);
break;
- }
- case GF_FOP_FALLOCATE:
- {
- gfs3_fallocate_req this_req = { {0,} };
-
- this_req = array[i].compound_req_u.compound_fallocate_req;
-
- state->resolve.type = RESOLVE_MUST;
- memcpy (state->resolve.gfid,
- this_req.gfid, 16);
- state->resolve.fd_no = this_req.fd;
+ case GF_FOP_WRITE:
+ SERVER_FOP_RSP_CLEANUP(rsp, write, i);
break;
- }
- case GF_FOP_DISCARD:
- {
- gfs3_discard_req this_req = { {0,} };
-
- this_req = array[i].compound_req_u.compound_discard_req;
-
- state->resolve.type = RESOLVE_MUST;
- memcpy (state->resolve.gfid,
- this_req.gfid, 16);
- state->resolve.fd_no = this_req.fd;
+ case GF_FOP_STATFS:
+ SERVER_FOP_RSP_CLEANUP(rsp, statfs, i);
break;
- }
- case GF_FOP_ZEROFILL:
- {
- gfs3_zerofill_req this_req = { {0,} };
-
- this_req = array[i].compound_req_u.compound_zerofill_req;
-
- state->resolve.type = RESOLVE_MUST;
- memcpy (state->resolve.gfid,
- this_req.gfid, 16);
- state->resolve.fd_no = this_req.fd;
+ case GF_FOP_FSYNC:
+ SERVER_FOP_RSP_CLEANUP(rsp, fsync, i);
break;
- }
- case GF_FOP_SEEK:
- {
- gfs3_seek_req this_req = { {0,} };
-
- this_req = array[i].compound_req_u.compound_seek_req;
-
- state->resolve.type = RESOLVE_MUST;
- memcpy (state->resolve.gfid,
- this_req.gfid, 16);
- state->resolve.fd_no = this_req.fd;
+ case GF_FOP_OPENDIR:
+ SERVER_FOP_RSP_CLEANUP(rsp, opendir, i);
break;
- }
- case GF_FOP_LEASE:
- {
- gfs3_lease_req this_req = { {0,} };
-
- this_req = array[i].compound_req_u.compound_lease_req;
-
- state->resolve.type = RESOLVE_MUST;
- memcpy (state->resolve.gfid, this_req.gfid, 16);
+ case GF_FOP_CREATE:
+ SERVER_FOP_RSP_CLEANUP(rsp, create, i);
+ break;
+ case GF_FOP_FTRUNCATE:
+ SERVER_FOP_RSP_CLEANUP(rsp, ftruncate, i);
+ break;
+ case GF_FOP_FSTAT:
+ SERVER_FOP_RSP_CLEANUP(rsp, fstat, i);
+ break;
+ case GF_FOP_LK:
+ SERVER_FOP_RSP_CLEANUP(rsp, lk, i);
+ break;
+ case GF_FOP_LOOKUP:
+ SERVER_FOP_RSP_CLEANUP(rsp, lookup, i);
+ break;
+ case GF_FOP_SETATTR:
+ SERVER_FOP_RSP_CLEANUP(rsp, setattr, i);
+ break;
+ case GF_FOP_FSETATTR:
+ SERVER_FOP_RSP_CLEANUP(rsp, fsetattr, i);
+ break;
+ case GF_FOP_FALLOCATE:
+ SERVER_FOP_RSP_CLEANUP(rsp, fallocate, i);
+ break;
+ case GF_FOP_DISCARD:
+ SERVER_FOP_RSP_CLEANUP(rsp, discard, i);
+ break;
+ case GF_FOP_ZEROFILL:
+ SERVER_FOP_RSP_CLEANUP(rsp, zerofill, i);
+ break;
+ case GF_FOP_IPC:
+ SERVER_FOP_RSP_CLEANUP(rsp, ipc, i);
+ break;
+ case GF_FOP_SEEK:
+ SERVER_FOP_RSP_CLEANUP(rsp, seek, i);
+ break;
+ case GF_FOP_LEASE:
+ SERVER_FOP_RSP_CLEANUP(rsp, lease, i);
+ break;
+ /* fops that use gf_common_rsp */
+ case GF_FOP_FLUSH:
+ SERVER_COMMON_RSP_CLEANUP(rsp, flush, i);
+ break;
+ case GF_FOP_SETXATTR:
+ SERVER_COMMON_RSP_CLEANUP(rsp, setxattr, i);
+ break;
+ case GF_FOP_REMOVEXATTR:
+ SERVER_COMMON_RSP_CLEANUP(rsp, removexattr, i);
+ break;
+ case GF_FOP_FSETXATTR:
+ SERVER_COMMON_RSP_CLEANUP(rsp, fsetxattr, i);
+ break;
+ case GF_FOP_FREMOVEXATTR:
+ SERVER_COMMON_RSP_CLEANUP(rsp, fremovexattr, i);
+ break;
+ case GF_FOP_FSYNCDIR:
+ SERVER_COMMON_RSP_CLEANUP(rsp, fsyncdir, i);
+ break;
+ case GF_FOP_ACCESS:
+ SERVER_COMMON_RSP_CLEANUP(rsp, access, i);
+ break;
+ case GF_FOP_INODELK:
+ SERVER_COMMON_RSP_CLEANUP(rsp, inodelk, i);
+ break;
+ case GF_FOP_FINODELK:
+ SERVER_COMMON_RSP_CLEANUP(rsp, finodelk, i);
+ break;
+ case GF_FOP_ENTRYLK:
+ SERVER_COMMON_RSP_CLEANUP(rsp, entrylk, i);
+ break;
+ case GF_FOP_FENTRYLK:
+ SERVER_COMMON_RSP_CLEANUP(rsp, fentrylk, i);
+ break;
+ case GF_FOP_READLINK:
+ SERVER_FOP_RSP_CLEANUP(rsp, readlink, i);
+ break;
+ case GF_FOP_RCHECKSUM:
+ SERVER_FOP_RSP_CLEANUP(rsp, rchecksum, i);
+ break;
+ /* fops that need extra cleanup */
+ case GF_FOP_XATTROP: {
+ gfs3_xattrop_rsp *tmp_rsp = &CPD_RSP_FIELD(this_rsp, xattrop);
+ SERVER_FOP_RSP_CLEANUP(rsp, xattrop, i);
+ GF_FREE(tmp_rsp->dict.dict_val);
+ break;
+ }
+ case GF_FOP_FXATTROP: {
+ gfs3_fxattrop_rsp *tmp_rsp = &CPD_RSP_FIELD(this_rsp, fxattrop);
+ SERVER_FOP_RSP_CLEANUP(rsp, fxattrop, i);
+ GF_FREE(tmp_rsp->dict.dict_val);
+ break;
+ }
+ case GF_FOP_READDIR: {
+ gfs3_readdir_rsp *tmp_rsp = &CPD_RSP_FIELD(this_rsp, readdir);
+ SERVER_FOP_RSP_CLEANUP(rsp, readdir, i);
+ readdir_rsp_cleanup(tmp_rsp);
+ break;
+ }
+ case GF_FOP_READDIRP: {
+ gfs3_readdirp_rsp *tmp_rsp = &CPD_RSP_FIELD(this_rsp, readdirp);
+ SERVER_FOP_RSP_CLEANUP(rsp, readdir, i);
+ readdirp_rsp_cleanup(tmp_rsp);
+ break;
+ }
+ case GF_FOP_GETXATTR: {
+ gfs3_getxattr_rsp *tmp_rsp = &CPD_RSP_FIELD(this_rsp, getxattr);
+ SERVER_FOP_RSP_CLEANUP(rsp, getxattr, i);
+ GF_FREE(tmp_rsp->dict.dict_val);
+ break;
+ }
+ case GF_FOP_FGETXATTR: {
+ gfs3_fgetxattr_rsp *tmp_rsp = &CPD_RSP_FIELD(this_rsp,
+ fgetxattr);
+ SERVER_FOP_RSP_CLEANUP(rsp, fgetxattr, i);
+ GF_FREE(tmp_rsp->dict.dict_val);
+ break;
+ }
+ default:
break;
}
- default:
- return ENOTSUP;
- }
- return 0;
+ }
+ GF_FREE(rsp->compound_rsp_array.compound_rsp_array_val);
+ return;
}
void
-server_compound_rsp_cleanup (gfs3_compound_rsp *rsp, compound_args_cbk_t *args)
+server_compound_req_cleanup(gfs3_compound_req *req, int len)
{
- int i, len = 0;
- compound_rsp *this_rsp = NULL;
-
- if (!rsp->compound_rsp_array.compound_rsp_array_val)
- return;
-
- len = rsp->compound_rsp_array.compound_rsp_array_len;
-
- for (i = 0; i < len; i++) {
- this_rsp = &rsp->compound_rsp_array.compound_rsp_array_val[i];
- switch (args->enum_list[i]) {
- case GF_FOP_STAT:
- SERVER_FOP_RSP_CLEANUP (rsp, stat, i);
- break;
- case GF_FOP_MKNOD:
- SERVER_FOP_RSP_CLEANUP (rsp, mknod, i);
- break;
- case GF_FOP_MKDIR:
- SERVER_FOP_RSP_CLEANUP (rsp, mkdir, i);
- break;
- case GF_FOP_UNLINK:
- SERVER_FOP_RSP_CLEANUP (rsp, unlink, i);
- break;
- case GF_FOP_RMDIR:
- SERVER_FOP_RSP_CLEANUP (rsp, rmdir, i);
- break;
- case GF_FOP_SYMLINK:
- SERVER_FOP_RSP_CLEANUP (rsp, symlink, i);
- break;
- case GF_FOP_RENAME:
- SERVER_FOP_RSP_CLEANUP (rsp, rename, i);
- break;
- case GF_FOP_LINK:
- SERVER_FOP_RSP_CLEANUP (rsp, link, i);
- break;
- case GF_FOP_TRUNCATE:
- SERVER_FOP_RSP_CLEANUP (rsp, truncate, i);
- break;
- case GF_FOP_OPEN:
- SERVER_FOP_RSP_CLEANUP (rsp, open, i);
- break;
- case GF_FOP_READ:
- SERVER_FOP_RSP_CLEANUP (rsp, read, i);
- break;
- case GF_FOP_WRITE:
- SERVER_FOP_RSP_CLEANUP (rsp, write, i);
- break;
- case GF_FOP_STATFS:
- SERVER_FOP_RSP_CLEANUP (rsp, statfs, i);
- break;
- case GF_FOP_FSYNC:
- SERVER_FOP_RSP_CLEANUP (rsp, fsync, i);
- break;
- case GF_FOP_OPENDIR:
- SERVER_FOP_RSP_CLEANUP (rsp, opendir, i);
- break;
- case GF_FOP_CREATE:
- SERVER_FOP_RSP_CLEANUP (rsp, create, i);
- break;
- case GF_FOP_FTRUNCATE:
- SERVER_FOP_RSP_CLEANUP (rsp, ftruncate, i);
- break;
- case GF_FOP_FSTAT:
- SERVER_FOP_RSP_CLEANUP (rsp, fstat, i);
- break;
- case GF_FOP_LK:
- SERVER_FOP_RSP_CLEANUP (rsp, lk, i);
- break;
- case GF_FOP_LOOKUP:
- SERVER_FOP_RSP_CLEANUP (rsp, lookup, i);
- break;
- case GF_FOP_SETATTR:
- SERVER_FOP_RSP_CLEANUP (rsp, setattr, i);
- break;
- case GF_FOP_FSETATTR:
- SERVER_FOP_RSP_CLEANUP (rsp, fsetattr, i);
- break;
- case GF_FOP_FALLOCATE:
- SERVER_FOP_RSP_CLEANUP (rsp, fallocate, i);
- break;
- case GF_FOP_DISCARD:
- SERVER_FOP_RSP_CLEANUP (rsp, discard, i);
- break;
- case GF_FOP_ZEROFILL:
- SERVER_FOP_RSP_CLEANUP (rsp, zerofill, i);
- break;
- case GF_FOP_IPC:
- SERVER_FOP_RSP_CLEANUP (rsp, ipc, i);
- break;
- case GF_FOP_SEEK:
- SERVER_FOP_RSP_CLEANUP (rsp, seek, i);
- break;
- case GF_FOP_LEASE:
- SERVER_FOP_RSP_CLEANUP (rsp, lease, i);
- break;
- /* fops that use gf_common_rsp */
- case GF_FOP_FLUSH:
- SERVER_COMMON_RSP_CLEANUP (rsp, flush, i);
- break;
- case GF_FOP_SETXATTR:
- SERVER_COMMON_RSP_CLEANUP (rsp, setxattr, i);
- break;
- case GF_FOP_REMOVEXATTR:
- SERVER_COMMON_RSP_CLEANUP (rsp, removexattr, i);
- break;
- case GF_FOP_FSETXATTR:
- SERVER_COMMON_RSP_CLEANUP (rsp, fsetxattr, i);
- break;
- case GF_FOP_FREMOVEXATTR:
- SERVER_COMMON_RSP_CLEANUP (rsp, fremovexattr, i);
- break;
- case GF_FOP_FSYNCDIR:
- SERVER_COMMON_RSP_CLEANUP (rsp, fsyncdir, i);
- break;
- case GF_FOP_ACCESS:
- SERVER_COMMON_RSP_CLEANUP (rsp, access, i);
- break;
- case GF_FOP_INODELK:
- SERVER_COMMON_RSP_CLEANUP (rsp, inodelk, i);
- break;
- case GF_FOP_FINODELK:
- SERVER_COMMON_RSP_CLEANUP (rsp, finodelk, i);
- break;
- case GF_FOP_ENTRYLK:
- SERVER_COMMON_RSP_CLEANUP (rsp, entrylk, i);
- break;
- case GF_FOP_FENTRYLK:
- SERVER_COMMON_RSP_CLEANUP (rsp, fentrylk, i);
- break;
- case GF_FOP_READLINK:
- SERVER_FOP_RSP_CLEANUP (rsp, readlink, i);
- break;
- case GF_FOP_RCHECKSUM:
- SERVER_FOP_RSP_CLEANUP (rsp, rchecksum, i);
- break;
- /* fops that need extra cleanup */
- case GF_FOP_XATTROP:
- {
- gfs3_xattrop_rsp *tmp_rsp = &CPD_RSP_FIELD(this_rsp,
- xattrop);
- SERVER_FOP_RSP_CLEANUP (rsp, xattrop, i);
- GF_FREE (tmp_rsp->dict.dict_val);
- break;
- }
- case GF_FOP_FXATTROP:
- {
- gfs3_fxattrop_rsp *tmp_rsp = &CPD_RSP_FIELD(this_rsp,
- fxattrop);
- SERVER_FOP_RSP_CLEANUP (rsp, fxattrop, i);
- GF_FREE (tmp_rsp->dict.dict_val);
- break;
- }
- case GF_FOP_READDIR:
- {
- gfs3_readdir_rsp *tmp_rsp = &CPD_RSP_FIELD(this_rsp,
- readdir);
- SERVER_FOP_RSP_CLEANUP (rsp, readdir, i);
- readdir_rsp_cleanup (tmp_rsp);
- break;
- }
- case GF_FOP_READDIRP:
- {
- gfs3_readdirp_rsp *tmp_rsp = &CPD_RSP_FIELD(this_rsp,
- readdirp);
- SERVER_FOP_RSP_CLEANUP (rsp, readdir, i);
- readdirp_rsp_cleanup (tmp_rsp);
- break;
- }
- case GF_FOP_GETXATTR:
- {
- gfs3_getxattr_rsp *tmp_rsp = &CPD_RSP_FIELD(this_rsp,
- getxattr);
- SERVER_FOP_RSP_CLEANUP (rsp, getxattr, i);
- GF_FREE (tmp_rsp->dict.dict_val);
- break;
- }
- case GF_FOP_FGETXATTR:
- {
- gfs3_fgetxattr_rsp *tmp_rsp = &CPD_RSP_FIELD(this_rsp,
- fgetxattr);
- SERVER_FOP_RSP_CLEANUP (rsp, fgetxattr, i);
- GF_FREE (tmp_rsp->dict.dict_val);
- break;
- }
- default:
- break;
- }
- }
- GF_FREE (rsp->compound_rsp_array.compound_rsp_array_val);
+ int i = 0;
+ compound_req *curr_req = NULL;
+
+ if (!req->compound_req_array.compound_req_array_val)
return;
-}
-void
-server_compound_req_cleanup (gfs3_compound_req *req, int len)
-{
- int i = 0;
- compound_req *curr_req = NULL;
-
-
- if (!req->compound_req_array.compound_req_array_val)
- return;
-
- for (i = 0; i < len; i++) {
- curr_req = &req->compound_req_array.compound_req_array_val[i];
-
- switch (curr_req->fop_enum) {
- case GF_FOP_STAT:
- SERVER_COMPOUND_FOP_CLEANUP (curr_req, stat);
- break;
- case GF_FOP_READLINK:
- SERVER_COMPOUND_FOP_CLEANUP (curr_req, readlink);
- break;
- case GF_FOP_MKNOD:
- SERVER_COMPOUND_FOP_CLEANUP (curr_req, mknod);
- break;
- case GF_FOP_MKDIR:
- {
- gfs3_mkdir_req *args = &CPD_REQ_FIELD (curr_req, mkdir);
+ for (i = 0; i < len; i++) {
+ curr_req = &req->compound_req_array.compound_req_array_val[i];
- SERVER_COMPOUND_FOP_CLEANUP (curr_req, mkdir);
- free (args->bname);
- break;
- }
- case GF_FOP_UNLINK:
- {
- gfs3_unlink_req *args = &CPD_REQ_FIELD (curr_req,
- unlink);
+ switch (curr_req->fop_enum) {
+ case GF_FOP_STAT:
+ SERVER_COMPOUND_FOP_CLEANUP(curr_req, stat);
+ break;
+ case GF_FOP_READLINK:
+ SERVER_COMPOUND_FOP_CLEANUP(curr_req, readlink);
+ break;
+ case GF_FOP_MKNOD:
+ SERVER_COMPOUND_FOP_CLEANUP(curr_req, mknod);
+ break;
+ case GF_FOP_MKDIR: {
+ gfs3_mkdir_req *args = &CPD_REQ_FIELD(curr_req, mkdir);
- SERVER_COMPOUND_FOP_CLEANUP (curr_req, unlink);
- free (args->bname);
- break;
- }
- case GF_FOP_RMDIR:
- {
- gfs3_rmdir_req *args = &CPD_REQ_FIELD (curr_req,
- rmdir);
+ SERVER_COMPOUND_FOP_CLEANUP(curr_req, mkdir);
+ free(args->bname);
+ break;
+ }
+ case GF_FOP_UNLINK: {
+ gfs3_unlink_req *args = &CPD_REQ_FIELD(curr_req, unlink);
- SERVER_COMPOUND_FOP_CLEANUP (curr_req, rmdir);
- free (args->bname);
- break;
- }
- case GF_FOP_SYMLINK:
- {
- gfs3_symlink_req *args = &CPD_REQ_FIELD (curr_req,
- symlink);
+ SERVER_COMPOUND_FOP_CLEANUP(curr_req, unlink);
+ free(args->bname);
+ break;
+ }
+ case GF_FOP_RMDIR: {
+ gfs3_rmdir_req *args = &CPD_REQ_FIELD(curr_req, rmdir);
- SERVER_COMPOUND_FOP_CLEANUP (curr_req, symlink);
- free (args->bname);
- free (args->linkname);
- break;
- }
- case GF_FOP_RENAME:
- {
- gfs3_rename_req *args = &CPD_REQ_FIELD (curr_req,
- rename);
+ SERVER_COMPOUND_FOP_CLEANUP(curr_req, rmdir);
+ free(args->bname);
+ break;
+ }
+ case GF_FOP_SYMLINK: {
+ gfs3_symlink_req *args = &CPD_REQ_FIELD(curr_req, symlink);
- SERVER_COMPOUND_FOP_CLEANUP (curr_req, rename);
- free (args->oldbname);
- free (args->newbname);
- break;
- }
- case GF_FOP_LINK:
- {
- gfs3_link_req *args = &CPD_REQ_FIELD (curr_req,
- link);
+ SERVER_COMPOUND_FOP_CLEANUP(curr_req, symlink);
+ free(args->bname);
+ free(args->linkname);
+ break;
+ }
+ case GF_FOP_RENAME: {
+ gfs3_rename_req *args = &CPD_REQ_FIELD(curr_req, rename);
- SERVER_COMPOUND_FOP_CLEANUP (curr_req, link);
- free (args->newbname);
- break;
- }
- case GF_FOP_TRUNCATE:
- SERVER_COMPOUND_FOP_CLEANUP (curr_req, truncate);
- break;
- case GF_FOP_OPEN:
- SERVER_COMPOUND_FOP_CLEANUP (curr_req, open);
- break;
- case GF_FOP_READ:
- SERVER_COMPOUND_FOP_CLEANUP (curr_req, read);
- break;
- case GF_FOP_WRITE:
- SERVER_COMPOUND_FOP_CLEANUP (curr_req, write);
- break;
- case GF_FOP_STATFS:
- SERVER_COMPOUND_FOP_CLEANUP (curr_req, statfs);
- break;
- case GF_FOP_FLUSH:
- SERVER_COMPOUND_FOP_CLEANUP (curr_req, flush);
- break;
- case GF_FOP_FSYNC:
- SERVER_COMPOUND_FOP_CLEANUP (curr_req, fsync);
- break;
- case GF_FOP_SETXATTR:
- {
- gfs3_setxattr_req *args = &CPD_REQ_FIELD (curr_req,
- setxattr);
+ SERVER_COMPOUND_FOP_CLEANUP(curr_req, rename);
+ free(args->oldbname);
+ free(args->newbname);
+ break;
+ }
+ case GF_FOP_LINK: {
+ gfs3_link_req *args = &CPD_REQ_FIELD(curr_req, link);
- free (args->dict.dict_val);
- SERVER_COMPOUND_FOP_CLEANUP (curr_req, setxattr);
- break;
- }
- case GF_FOP_GETXATTR:
- {
- gfs3_getxattr_req *args = &CPD_REQ_FIELD (curr_req,
- getxattr);
+ SERVER_COMPOUND_FOP_CLEANUP(curr_req, link);
+ free(args->newbname);
+ break;
+ }
+ case GF_FOP_TRUNCATE:
+ SERVER_COMPOUND_FOP_CLEANUP(curr_req, truncate);
+ break;
+ case GF_FOP_OPEN:
+ SERVER_COMPOUND_FOP_CLEANUP(curr_req, open);
+ break;
+ case GF_FOP_READ:
+ SERVER_COMPOUND_FOP_CLEANUP(curr_req, read);
+ break;
+ case GF_FOP_WRITE:
+ SERVER_COMPOUND_FOP_CLEANUP(curr_req, write);
+ break;
+ case GF_FOP_STATFS:
+ SERVER_COMPOUND_FOP_CLEANUP(curr_req, statfs);
+ break;
+ case GF_FOP_FLUSH:
+ SERVER_COMPOUND_FOP_CLEANUP(curr_req, flush);
+ break;
+ case GF_FOP_FSYNC:
+ SERVER_COMPOUND_FOP_CLEANUP(curr_req, fsync);
+ break;
+ case GF_FOP_SETXATTR: {
+ gfs3_setxattr_req *args = &CPD_REQ_FIELD(curr_req, setxattr);
- SERVER_COMPOUND_FOP_CLEANUP (curr_req, getxattr);
- free (args->name);
- break;
- }
- case GF_FOP_REMOVEXATTR:
- {
- gfs3_removexattr_req *args = &CPD_REQ_FIELD (curr_req,
- removexattr);
+ free(args->dict.dict_val);
+ SERVER_COMPOUND_FOP_CLEANUP(curr_req, setxattr);
+ break;
+ }
+ case GF_FOP_GETXATTR: {
+ gfs3_getxattr_req *args = &CPD_REQ_FIELD(curr_req, getxattr);
- SERVER_COMPOUND_FOP_CLEANUP (curr_req, removexattr);
- free (args->name);
- break;
- }
- case GF_FOP_OPENDIR:
- SERVER_COMPOUND_FOP_CLEANUP (curr_req, opendir);
- break;
- case GF_FOP_FSYNCDIR:
- SERVER_COMPOUND_FOP_CLEANUP (curr_req, fsyncdir);
- break;
- case GF_FOP_ACCESS:
- SERVER_COMPOUND_FOP_CLEANUP (curr_req, access);
- break;
- case GF_FOP_CREATE:
- {
- gfs3_create_req *args = &CPD_REQ_FIELD (curr_req,
- create);
+ SERVER_COMPOUND_FOP_CLEANUP(curr_req, getxattr);
+ free(args->name);
+ break;
+ }
+ case GF_FOP_REMOVEXATTR: {
+ gfs3_removexattr_req *args = &CPD_REQ_FIELD(curr_req,
+ removexattr);
- SERVER_COMPOUND_FOP_CLEANUP (curr_req, create);
- free (args->bname);
- break;
- }
- case GF_FOP_FTRUNCATE:
- SERVER_COMPOUND_FOP_CLEANUP (curr_req, ftruncate);
- break;
- case GF_FOP_FSTAT:
- SERVER_COMPOUND_FOP_CLEANUP (curr_req, fstat);
- break;
- case GF_FOP_LK:
- {
- gfs3_lk_req *args = &CPD_REQ_FIELD (curr_req, lk);
+ SERVER_COMPOUND_FOP_CLEANUP(curr_req, removexattr);
+ free(args->name);
+ break;
+ }
+ case GF_FOP_OPENDIR:
+ SERVER_COMPOUND_FOP_CLEANUP(curr_req, opendir);
+ break;
+ case GF_FOP_FSYNCDIR:
+ SERVER_COMPOUND_FOP_CLEANUP(curr_req, fsyncdir);
+ break;
+ case GF_FOP_ACCESS:
+ SERVER_COMPOUND_FOP_CLEANUP(curr_req, access);
+ break;
+ case GF_FOP_CREATE: {
+ gfs3_create_req *args = &CPD_REQ_FIELD(curr_req, create);
- SERVER_COMPOUND_FOP_CLEANUP (curr_req, lk);
- free (args->flock.lk_owner.lk_owner_val);
- break;
- }
- case GF_FOP_LOOKUP:
- {
- gfs3_lookup_req *args = &CPD_REQ_FIELD (curr_req,
- lookup);
+ SERVER_COMPOUND_FOP_CLEANUP(curr_req, create);
+ free(args->bname);
+ break;
+ }
+ case GF_FOP_FTRUNCATE:
+ SERVER_COMPOUND_FOP_CLEANUP(curr_req, ftruncate);
+ break;
+ case GF_FOP_FSTAT:
+ SERVER_COMPOUND_FOP_CLEANUP(curr_req, fstat);
+ break;
+ case GF_FOP_LK: {
+ gfs3_lk_req *args = &CPD_REQ_FIELD(curr_req, lk);
- SERVER_COMPOUND_FOP_CLEANUP (curr_req, lookup);
- free (args->bname);
- break;
- }
- case GF_FOP_READDIR:
- SERVER_COMPOUND_FOP_CLEANUP (curr_req, readdir);
- break;
- case GF_FOP_INODELK:
- {
- gfs3_inodelk_req *args = &CPD_REQ_FIELD (curr_req,
- inodelk);
+ SERVER_COMPOUND_FOP_CLEANUP(curr_req, lk);
+ free(args->flock.lk_owner.lk_owner_val);
+ break;
+ }
+ case GF_FOP_LOOKUP: {
+ gfs3_lookup_req *args = &CPD_REQ_FIELD(curr_req, lookup);
- SERVER_COMPOUND_FOP_CLEANUP (curr_req, inodelk);
- free (args->volume);
- free (args->flock.lk_owner.lk_owner_val);
- break;
- }
- case GF_FOP_FINODELK:
- {
- gfs3_finodelk_req *args = &CPD_REQ_FIELD (curr_req,
- finodelk);
+ SERVER_COMPOUND_FOP_CLEANUP(curr_req, lookup);
+ free(args->bname);
+ break;
+ }
+ case GF_FOP_READDIR:
+ SERVER_COMPOUND_FOP_CLEANUP(curr_req, readdir);
+ break;
+ case GF_FOP_INODELK: {
+ gfs3_inodelk_req *args = &CPD_REQ_FIELD(curr_req, inodelk);
- SERVER_COMPOUND_FOP_CLEANUP (curr_req, finodelk);
- free (args->volume);
- free (args->flock.lk_owner.lk_owner_val);
- break;
- }
- case GF_FOP_ENTRYLK:
- {
- gfs3_entrylk_req *args = &CPD_REQ_FIELD (curr_req,
- entrylk);
+ SERVER_COMPOUND_FOP_CLEANUP(curr_req, inodelk);
+ free(args->volume);
+ free(args->flock.lk_owner.lk_owner_val);
+ break;
+ }
+ case GF_FOP_FINODELK: {
+ gfs3_finodelk_req *args = &CPD_REQ_FIELD(curr_req, finodelk);
- SERVER_COMPOUND_FOP_CLEANUP (curr_req, entrylk);
- free (args->volume);
- free (args->name);
- break;
- }
- case GF_FOP_FENTRYLK:
- {
- gfs3_fentrylk_req *args = &CPD_REQ_FIELD (curr_req,
- fentrylk);
+ SERVER_COMPOUND_FOP_CLEANUP(curr_req, finodelk);
+ free(args->volume);
+ free(args->flock.lk_owner.lk_owner_val);
+ break;
+ }
+ case GF_FOP_ENTRYLK: {
+ gfs3_entrylk_req *args = &CPD_REQ_FIELD(curr_req, entrylk);
- SERVER_COMPOUND_FOP_CLEANUP (curr_req, fentrylk);
- free (args->volume);
- free (args->name);
- break;
- }
- case GF_FOP_XATTROP:
- {
- gfs3_xattrop_req *args = &CPD_REQ_FIELD (curr_req,
- xattrop);
+ SERVER_COMPOUND_FOP_CLEANUP(curr_req, entrylk);
+ free(args->volume);
+ free(args->name);
+ break;
+ }
+ case GF_FOP_FENTRYLK: {
+ gfs3_fentrylk_req *args = &CPD_REQ_FIELD(curr_req, fentrylk);
- free (args->dict.dict_val);
- SERVER_COMPOUND_FOP_CLEANUP (curr_req, xattrop);
- break;
- }
- case GF_FOP_FXATTROP:
- {
- gfs3_fxattrop_req *args = &CPD_REQ_FIELD (curr_req,
- fxattrop);
+ SERVER_COMPOUND_FOP_CLEANUP(curr_req, fentrylk);
+ free(args->volume);
+ free(args->name);
+ break;
+ }
+ case GF_FOP_XATTROP: {
+ gfs3_xattrop_req *args = &CPD_REQ_FIELD(curr_req, xattrop);
- free (args->dict.dict_val);
- SERVER_COMPOUND_FOP_CLEANUP (curr_req, fxattrop);
- break;
- }
- case GF_FOP_FGETXATTR:
- {
- gfs3_fgetxattr_req *args = &CPD_REQ_FIELD (curr_req,
- fgetxattr);
+ free(args->dict.dict_val);
+ SERVER_COMPOUND_FOP_CLEANUP(curr_req, xattrop);
+ break;
+ }
+ case GF_FOP_FXATTROP: {
+ gfs3_fxattrop_req *args = &CPD_REQ_FIELD(curr_req, fxattrop);
- SERVER_COMPOUND_FOP_CLEANUP (curr_req, fgetxattr);
- free (args->name);
- break;
- }
- case GF_FOP_FSETXATTR:
- {
- gfs3_fsetxattr_req *args = &CPD_REQ_FIELD(curr_req,
- fsetxattr);
+ free(args->dict.dict_val);
+ SERVER_COMPOUND_FOP_CLEANUP(curr_req, fxattrop);
+ break;
+ }
+ case GF_FOP_FGETXATTR: {
+ gfs3_fgetxattr_req *args = &CPD_REQ_FIELD(curr_req, fgetxattr);
- free (args->dict.dict_val);
- SERVER_COMPOUND_FOP_CLEANUP (curr_req, fsetxattr);
- break;
- }
- case GF_FOP_RCHECKSUM:
- SERVER_COMPOUND_FOP_CLEANUP (curr_req, rchecksum);
- break;
- case GF_FOP_SETATTR:
- SERVER_COMPOUND_FOP_CLEANUP (curr_req, setattr);
- break;
- case GF_FOP_FSETATTR:
- SERVER_COMPOUND_FOP_CLEANUP (curr_req, fsetattr);
- break;
- case GF_FOP_READDIRP:
- {
- gfs3_readdirp_req *args = &CPD_REQ_FIELD (curr_req,
- readdirp);
+ SERVER_COMPOUND_FOP_CLEANUP(curr_req, fgetxattr);
+ free(args->name);
+ break;
+ }
+ case GF_FOP_FSETXATTR: {
+ gfs3_fsetxattr_req *args = &CPD_REQ_FIELD(curr_req, fsetxattr);
- SERVER_COMPOUND_FOP_CLEANUP (curr_req, fremovexattr);
- free (args->dict.dict_val);
- break;
- }
- case GF_FOP_FREMOVEXATTR:
- {
- gfs3_fremovexattr_req *args = &CPD_REQ_FIELD(curr_req,
- fremovexattr);
+ free(args->dict.dict_val);
+ SERVER_COMPOUND_FOP_CLEANUP(curr_req, fsetxattr);
+ break;
+ }
+ case GF_FOP_RCHECKSUM:
+ SERVER_COMPOUND_FOP_CLEANUP(curr_req, rchecksum);
+ break;
+ case GF_FOP_SETATTR:
+ SERVER_COMPOUND_FOP_CLEANUP(curr_req, setattr);
+ break;
+ case GF_FOP_FSETATTR:
+ SERVER_COMPOUND_FOP_CLEANUP(curr_req, fsetattr);
+ break;
+ case GF_FOP_READDIRP: {
+ gfs3_readdirp_req *args = &CPD_REQ_FIELD(curr_req, readdirp);
- SERVER_COMPOUND_FOP_CLEANUP (curr_req, fremovexattr);
- free (args->name);
- break;
- }
- case GF_FOP_FALLOCATE:
- SERVER_COMPOUND_FOP_CLEANUP (curr_req, fallocate);
- break;
- case GF_FOP_DISCARD:
- SERVER_COMPOUND_FOP_CLEANUP (curr_req, discard);
- break;
- case GF_FOP_ZEROFILL:
- SERVER_COMPOUND_FOP_CLEANUP (curr_req, zerofill);
- break;
- case GF_FOP_IPC:
- SERVER_COMPOUND_FOP_CLEANUP (curr_req, ipc);
- break;
- case GF_FOP_SEEK:
- SERVER_COMPOUND_FOP_CLEANUP (curr_req, seek);
- break;
- default:
- break;
- }
+ SERVER_COMPOUND_FOP_CLEANUP(curr_req, fremovexattr);
+ free(args->dict.dict_val);
+ break;
+ }
+ case GF_FOP_FREMOVEXATTR: {
+ gfs3_fremovexattr_req *args = &CPD_REQ_FIELD(curr_req,
+ fremovexattr);
+
+ SERVER_COMPOUND_FOP_CLEANUP(curr_req, fremovexattr);
+ free(args->name);
+ break;
+ }
+ case GF_FOP_FALLOCATE:
+ SERVER_COMPOUND_FOP_CLEANUP(curr_req, fallocate);
+ break;
+ case GF_FOP_DISCARD:
+ SERVER_COMPOUND_FOP_CLEANUP(curr_req, discard);
+ break;
+ case GF_FOP_ZEROFILL:
+ SERVER_COMPOUND_FOP_CLEANUP(curr_req, zerofill);
+ break;
+ case GF_FOP_IPC:
+ SERVER_COMPOUND_FOP_CLEANUP(curr_req, ipc);
+ break;
+ case GF_FOP_SEEK:
+ SERVER_COMPOUND_FOP_CLEANUP(curr_req, seek);
+ break;
+ default:
+ break;
}
+ }
- return;
+ return;
}
/* compound v2 */
int
-server_populate_compound_request_v2 (gfx_compound_req *req, call_frame_t *frame,
- default_args_t *this_args,
- int index)
+server_populate_compound_request_v2(gfx_compound_req *req, call_frame_t *frame,
+ default_args_t *this_args, int index)
{
- int op_errno = 0;
- dict_t *xdata = NULL;
- dict_t *xattr = NULL;
- struct iovec req_iovec[MAX_IOVEC] = { {0,} };
- compound_req_v2 *this_req = NULL;
- server_state_t *state = CALL_STATE (frame);
+ int op_errno = 0;
+ dict_t *xdata = NULL;
+ dict_t *xattr = NULL;
+ struct iovec req_iovec[MAX_IOVEC] = {{
+ 0,
+ }};
+ compound_req_v2 *this_req = NULL;
+ server_state_t *state = CALL_STATE(frame);
- this_req = &req->compound_req_array.compound_req_array_val[index];
+ this_req = &req->compound_req_array.compound_req_array_val[index];
- switch (this_req->fop_enum) {
- case GF_FOP_STAT:
- {
- gfx_stat_req *args = NULL;
+ switch (this_req->fop_enum) {
+ case GF_FOP_STAT: {
+ gfx_stat_req *args = NULL;
- args = &this_req->compound_req_v2_u.compound_stat_req;
+ args = &this_req->compound_req_v2_u.compound_stat_req;
- xdr_to_dict (&args->xdata, &xdata);
- args_stat_store (this_args, &state->loc, xdata);
- break;
+ xdr_to_dict(&args->xdata, &xdata);
+ args_stat_store(this_args, &state->loc, xdata);
+ break;
}
- case GF_FOP_READLINK:
- {
- gfx_readlink_req *args = NULL;
+ case GF_FOP_READLINK: {
+ gfx_readlink_req *args = NULL;
- args = &this_req->compound_req_v2_u.compound_readlink_req;
+ args = &this_req->compound_req_v2_u.compound_readlink_req;
- xdr_to_dict (&args->xdata, &xdata);
- args_readlink_store (this_args, &state->loc, args->size, xdata);
- break;
+ xdr_to_dict(&args->xdata, &xdata);
+ args_readlink_store(this_args, &state->loc, args->size, xdata);
+ break;
}
- case GF_FOP_MKNOD:
- {
- gfx_mknod_req *args = NULL;
+ case GF_FOP_MKNOD: {
+ gfx_mknod_req *args = NULL;
- args = &this_req->compound_req_v2_u.compound_mknod_req;
+ args = &this_req->compound_req_v2_u.compound_mknod_req;
- xdr_to_dict (&args->xdata, &xdata);
- args_mknod_store (this_args, &state->loc, args->mode, args->dev,
- args->umask, xdata);
- break;
+ xdr_to_dict(&args->xdata, &xdata);
+ args_mknod_store(this_args, &state->loc, args->mode, args->dev,
+ args->umask, xdata);
+ break;
}
- case GF_FOP_MKDIR:
- {
- gfx_mkdir_req *args = NULL;
+ case GF_FOP_MKDIR: {
+ gfx_mkdir_req *args = NULL;
- args = &this_req->compound_req_v2_u.compound_mkdir_req;
+ args = &this_req->compound_req_v2_u.compound_mkdir_req;
- xdr_to_dict (&args->xdata, &xdata);
- args_mkdir_store (this_args, &state->loc, args->mode,
- args->umask, xdata);
- break;
+ xdr_to_dict(&args->xdata, &xdata);
+ args_mkdir_store(this_args, &state->loc, args->mode, args->umask,
+ xdata);
+ break;
}
- case GF_FOP_UNLINK:
- {
- gfx_unlink_req *args = NULL;
+ case GF_FOP_UNLINK: {
+ gfx_unlink_req *args = NULL;
- args = &this_req->compound_req_v2_u.compound_unlink_req;
+ args = &this_req->compound_req_v2_u.compound_unlink_req;
- xdr_to_dict (&args->xdata, &xdata);
- args_unlink_store (this_args, &state->loc, args->xflags, xdata);
- break;
+ xdr_to_dict(&args->xdata, &xdata);
+ args_unlink_store(this_args, &state->loc, args->xflags, xdata);
+ break;
}
- case GF_FOP_RMDIR:
- {
- gfx_rmdir_req *args = NULL;
+ case GF_FOP_RMDIR: {
+ gfx_rmdir_req *args = NULL;
- args = &this_req->compound_req_v2_u.compound_rmdir_req;
+ args = &this_req->compound_req_v2_u.compound_rmdir_req;
- xdr_to_dict (&args->xdata, &xdata);
- args_rmdir_store (this_args, &state->loc, args->xflags, xdata);
- break;
+ xdr_to_dict(&args->xdata, &xdata);
+ args_rmdir_store(this_args, &state->loc, args->xflags, xdata);
+ break;
}
- case GF_FOP_SYMLINK:
- {
- gfx_symlink_req *args = NULL;
+ case GF_FOP_SYMLINK: {
+ gfx_symlink_req *args = NULL;
- args = &this_req->compound_req_v2_u.compound_symlink_req;
+ args = &this_req->compound_req_v2_u.compound_symlink_req;
- xdr_to_dict (&args->xdata, &xdata);
- args_symlink_store (this_args, args->linkname, &state->loc,
- args->umask, xdata);
+ xdr_to_dict(&args->xdata, &xdata);
+ args_symlink_store(this_args, args->linkname, &state->loc,
+ args->umask, xdata);
- this_args->loc.inode = inode_new (state->itable);
+ this_args->loc.inode = inode_new(state->itable);
- break;
+ break;
}
- case GF_FOP_RENAME:
- {
- gfx_rename_req *args = NULL;
+ case GF_FOP_RENAME: {
+ gfx_rename_req *args = NULL;
- args = &this_req->compound_req_v2_u.compound_rename_req;
+ args = &this_req->compound_req_v2_u.compound_rename_req;
- xdr_to_dict (&args->xdata, &xdata);
+ xdr_to_dict(&args->xdata, &xdata);
- args_rename_store (this_args, &state->loc, &state->loc2, xdata);
- break;
+ args_rename_store(this_args, &state->loc, &state->loc2, xdata);
+ break;
}
- case GF_FOP_LINK:
- {
- gfx_link_req *args = NULL;
+ case GF_FOP_LINK: {
+ gfx_link_req *args = NULL;
- args = &this_req->compound_req_v2_u.compound_link_req;
+ args = &this_req->compound_req_v2_u.compound_link_req;
- xdr_to_dict (&args->xdata, &xdata);
- args_link_store (this_args, &state->loc, &state->loc2, xdata);
+ xdr_to_dict(&args->xdata, &xdata);
+ args_link_store(this_args, &state->loc, &state->loc2, xdata);
- this_args->loc2.inode = inode_ref (this_args->loc.inode);
+ this_args->loc2.inode = inode_ref(this_args->loc.inode);
- break;
+ break;
}
- case GF_FOP_TRUNCATE:
- {
- gfx_truncate_req *args = NULL;
+ case GF_FOP_TRUNCATE: {
+ gfx_truncate_req *args = NULL;
- args = &this_req->compound_req_v2_u.compound_truncate_req;
+ args = &this_req->compound_req_v2_u.compound_truncate_req;
- xdr_to_dict (&args->xdata, &xdata);
- args_truncate_store (this_args, &state->loc, args->offset,
- xdata);
- break;
+ xdr_to_dict(&args->xdata, &xdata);
+ args_truncate_store(this_args, &state->loc, args->offset, xdata);
+ break;
}
- case GF_FOP_OPEN:
- {
- gfx_open_req *args = NULL;
+ case GF_FOP_OPEN: {
+ gfx_open_req *args = NULL;
- args = &this_req->compound_req_v2_u.compound_open_req;
+ args = &this_req->compound_req_v2_u.compound_open_req;
- xdr_to_dict (&args->xdata, &xdata);
- args_open_store (this_args, &state->loc, args->flags, state->fd,
- xdata);
+ xdr_to_dict(&args->xdata, &xdata);
+ args_open_store(this_args, &state->loc, args->flags, state->fd,
+ xdata);
- this_args->fd = fd_create (this_args->loc.inode,
- frame->root->pid);
- this_args->fd->flags = this_args->flags;
+ this_args->fd = fd_create(this_args->loc.inode, frame->root->pid);
+ this_args->fd->flags = this_args->flags;
- break;
+ break;
}
- case GF_FOP_READ:
- {
- gfx_read_req *args = NULL;
+ case GF_FOP_READ: {
+ gfx_read_req *args = NULL;
- args = &this_req->compound_req_v2_u.compound_read_req;
+ args = &this_req->compound_req_v2_u.compound_read_req;
- xdr_to_dict (&args->xdata, &xdata);
- args_readv_store (this_args, state->fd, args->size,
- args->offset, args->flag, xdata);
- break;
+ xdr_to_dict(&args->xdata, &xdata);
+ args_readv_store(this_args, state->fd, args->size, args->offset,
+ args->flag, xdata);
+ break;
}
- case GF_FOP_WRITE:
- {
- gfx_write_req *args = NULL;
-
- args = &this_req->compound_req_v2_u.compound_write_req;
-
- /*TODO : What happens when payload count is more than one? */
- req_iovec[0].iov_base = state->payload_vector[0].iov_base +
- state->write_length;
- req_iovec[0].iov_len = args->size;
-
- xdr_to_dict (&args->xdata, &xdata);
- /* The way writev fop works :
- * xdr args of write along with other args contains
- * write length not count. But when the call is wound to posix,
- * this length is not used. It is taken from the request
- * write vector that is passed down. Posix needs the vector
- * count to determine the amount of write to be done.
- * This count for writes that come as part of compound fops
- * will be 1. The vectors are merged into one under
- * GF_FOP_WRITE section of client_handle_fop_requirements()
- * in protocol client.
- */
- args_writev_store (this_args, state->fd, req_iovec, 1,
- args->offset, args->flag, state->iobref,
- xdata);
- state->write_length += req_iovec[0].iov_len;
- break;
- }
- case GF_FOP_STATFS:
- {
- gfx_statfs_req *args = NULL;
+ case GF_FOP_WRITE: {
+ gfx_write_req *args = NULL;
- args = &this_req->compound_req_v2_u.compound_statfs_req;
+ args = &this_req->compound_req_v2_u.compound_write_req;
- xdr_to_dict (&args->xdata, &xdata);
- args_statfs_store (this_args, &state->loc, xdata);
- break;
+ /*TODO : What happens when payload count is more than one? */
+ req_iovec[0].iov_base = state->payload_vector[0].iov_base +
+ state->write_length;
+ req_iovec[0].iov_len = args->size;
+
+ xdr_to_dict(&args->xdata, &xdata);
+ /* The way writev fop works :
+ * xdr args of write along with other args contains
+ * write length not count. But when the call is wound to posix,
+ * this length is not used. It is taken from the request
+ * write vector that is passed down. Posix needs the vector
+ * count to determine the amount of write to be done.
+ * This count for writes that come as part of compound fops
+ * will be 1. The vectors are merged into one under
+ * GF_FOP_WRITE section of client_handle_fop_requirements()
+ * in protocol client.
+ */
+ args_writev_store(this_args, state->fd, req_iovec, 1, args->offset,
+ args->flag, state->iobref, xdata);
+ state->write_length += req_iovec[0].iov_len;
+ break;
}
- case GF_FOP_FLUSH:
- {
- gfx_flush_req *args = NULL;
+ case GF_FOP_STATFS: {
+ gfx_statfs_req *args = NULL;
- args = &this_req->compound_req_v2_u.compound_flush_req;
+ args = &this_req->compound_req_v2_u.compound_statfs_req;
- xdr_to_dict (&args->xdata, &xdata);
- args_flush_store (this_args, state->fd, xdata);
- break;
+ xdr_to_dict(&args->xdata, &xdata);
+ args_statfs_store(this_args, &state->loc, xdata);
+ break;
}
- case GF_FOP_FSYNC:
- {
- gfx_fsync_req *args = NULL;
+ case GF_FOP_FLUSH: {
+ gfx_flush_req *args = NULL;
- args = &this_req->compound_req_v2_u.compound_fsync_req;
+ args = &this_req->compound_req_v2_u.compound_flush_req;
- xdr_to_dict (&args->xdata, &xdata);
- args_fsync_store (this_args, state->fd, args->data, xdata);
- break;
+ xdr_to_dict(&args->xdata, &xdata);
+ args_flush_store(this_args, state->fd, xdata);
+ break;
}
- case GF_FOP_SETXATTR:
- {
- gfx_setxattr_req *args = NULL;
+ case GF_FOP_FSYNC: {
+ gfx_fsync_req *args = NULL;
- args = &this_req->compound_req_v2_u.compound_setxattr_req;
+ args = &this_req->compound_req_v2_u.compound_fsync_req;
- xdr_to_dict (&args->dict, &xattr);
- xdr_to_dict (&args->xdata, &xdata);
- args_setxattr_store (this_args, &state->loc, xattr, args->flags,
- xdata);
- break;
+ xdr_to_dict(&args->xdata, &xdata);
+ args_fsync_store(this_args, state->fd, args->data, xdata);
+ break;
}
- case GF_FOP_GETXATTR:
- {
- gfx_getxattr_req *args = NULL;
+ case GF_FOP_SETXATTR: {
+ gfx_setxattr_req *args = NULL;
- args = &this_req->compound_req_v2_u.compound_getxattr_req;
+ args = &this_req->compound_req_v2_u.compound_setxattr_req;
- xdr_to_dict (&args->xdata, &xdata);
- gf_server_check_getxattr_cmd (frame, args->name);
+ xdr_to_dict(&args->dict, &xattr);
+ xdr_to_dict(&args->xdata, &xdata);
+ args_setxattr_store(this_args, &state->loc, xattr, args->flags,
+ xdata);
+ break;
+ }
+ case GF_FOP_GETXATTR: {
+ gfx_getxattr_req *args = NULL;
- args_getxattr_store (this_args, &state->loc, args->name, xdata);
- break;
+ args = &this_req->compound_req_v2_u.compound_getxattr_req;
+
+ xdr_to_dict(&args->xdata, &xdata);
+ gf_server_check_getxattr_cmd(frame, args->name);
+
+ args_getxattr_store(this_args, &state->loc, args->name, xdata);
+ break;
}
- case GF_FOP_REMOVEXATTR:
- {
- gfx_removexattr_req *args = NULL;
+ case GF_FOP_REMOVEXATTR: {
+ gfx_removexattr_req *args = NULL;
- args = &this_req->compound_req_v2_u.compound_removexattr_req;
+ args = &this_req->compound_req_v2_u.compound_removexattr_req;
- xdr_to_dict (&args->xdata, &xdata);
- args_removexattr_store (this_args, &state->loc, args->name,
- xdata);
- break;
+ xdr_to_dict(&args->xdata, &xdata);
+ args_removexattr_store(this_args, &state->loc, args->name, xdata);
+ break;
}
- case GF_FOP_OPENDIR:
- {
- gfx_opendir_req *args = NULL;
+ case GF_FOP_OPENDIR: {
+ gfx_opendir_req *args = NULL;
- args = &this_req->compound_req_v2_u.compound_opendir_req;
+ args = &this_req->compound_req_v2_u.compound_opendir_req;
- this_args->fd = fd_create (this_args->loc.inode,
- frame->root->pid);
- if (!this_args->fd) {
- gf_msg ("server", GF_LOG_ERROR, 0,
- PS_MSG_FD_CREATE_FAILED,
- "could not create the fd");
- goto out;
- }
- xdr_to_dict (&args->xdata, &xdata);
+ this_args->fd = fd_create(this_args->loc.inode, frame->root->pid);
+ if (!this_args->fd) {
+ gf_msg("server", GF_LOG_ERROR, 0, PS_MSG_FD_CREATE_FAILED,
+ "could not create the fd");
+ goto out;
+ }
+ xdr_to_dict(&args->xdata, &xdata);
- args_opendir_store (this_args, &state->loc, state->fd, xdata);
- break;
+ args_opendir_store(this_args, &state->loc, state->fd, xdata);
+ break;
}
- case GF_FOP_FSYNCDIR:
- {
- gfx_fsyncdir_req *args = NULL;
+ case GF_FOP_FSYNCDIR: {
+ gfx_fsyncdir_req *args = NULL;
- args = &this_req->compound_req_v2_u.compound_fsyncdir_req;
+ args = &this_req->compound_req_v2_u.compound_fsyncdir_req;
- xdr_to_dict (&args->xdata, &xdata);
- args_fsyncdir_store (this_args, state->fd, args->data, xdata);
- break;
+ xdr_to_dict(&args->xdata, &xdata);
+ args_fsyncdir_store(this_args, state->fd, args->data, xdata);
+ break;
}
- case GF_FOP_ACCESS:
- {
- gfx_access_req *args = NULL;
+ case GF_FOP_ACCESS: {
+ gfx_access_req *args = NULL;
- args = &this_req->compound_req_v2_u.compound_access_req;
+ args = &this_req->compound_req_v2_u.compound_access_req;
- xdr_to_dict (&args->xdata, &xdata);
- args_access_store (this_args, &state->loc, args->mask, xdata);
- break;
+ xdr_to_dict(&args->xdata, &xdata);
+ args_access_store(this_args, &state->loc, args->mask, xdata);
+ break;
}
- case GF_FOP_CREATE:
- {
- gfx_create_req *args = NULL;
+ case GF_FOP_CREATE: {
+ gfx_create_req *args = NULL;
- args = &this_req->compound_req_v2_u.compound_create_req;
+ args = &this_req->compound_req_v2_u.compound_create_req;
- state->loc.inode = inode_new (state->itable);
+ state->loc.inode = inode_new(state->itable);
- state->fd = fd_create (state->loc.inode, frame->root->pid);
- if (!state->fd) {
- gf_msg ("server", GF_LOG_ERROR, 0,
- PS_MSG_FD_CREATE_FAILED,
- "fd creation for the inode %s failed",
- state->loc.inode ?
- uuid_utoa (state->loc.inode->gfid):NULL);
- goto out;
- }
- state->fd->flags = state->flags;
+ state->fd = fd_create(state->loc.inode, frame->root->pid);
+ if (!state->fd) {
+ gf_msg("server", GF_LOG_ERROR, 0, PS_MSG_FD_CREATE_FAILED,
+ "fd creation for the inode %s failed",
+ state->loc.inode ? uuid_utoa(state->loc.inode->gfid)
+ : NULL);
+ goto out;
+ }
+ state->fd->flags = state->flags;
- xdr_to_dict (&args->xdata, &xdata);
- args_create_store (this_args, &state->loc, args->flags,
- args->mode, args->umask, state->fd, xdata);
- break;
+ xdr_to_dict(&args->xdata, &xdata);
+ args_create_store(this_args, &state->loc, args->flags, args->mode,
+ args->umask, state->fd, xdata);
+ break;
}
- case GF_FOP_FTRUNCATE:
- {
- gfx_ftruncate_req *args = NULL;
+ case GF_FOP_FTRUNCATE: {
+ gfx_ftruncate_req *args = NULL;
- args = &this_req->compound_req_v2_u.compound_ftruncate_req;
+ args = &this_req->compound_req_v2_u.compound_ftruncate_req;
- xdr_to_dict (&args->xdata, &xdata);
- args_ftruncate_store (this_args, state->fd, args->offset,
- xdata);
- break;
+ xdr_to_dict(&args->xdata, &xdata);
+ args_ftruncate_store(this_args, state->fd, args->offset, xdata);
+ break;
}
- case GF_FOP_FSTAT:
- {
- gfx_fstat_req *args = NULL;
+ case GF_FOP_FSTAT: {
+ gfx_fstat_req *args = NULL;
- args = &this_req->compound_req_v2_u.compound_fstat_req;
+ args = &this_req->compound_req_v2_u.compound_fstat_req;
- xdr_to_dict (&args->xdata, &xdata);
- args_fstat_store (this_args, state->fd, xdata);
- break;
+ xdr_to_dict(&args->xdata, &xdata);
+ args_fstat_store(this_args, state->fd, xdata);
+ break;
}
- case GF_FOP_LK:
- {
- gfx_lk_req *args = NULL;
+ case GF_FOP_LK: {
+ gfx_lk_req *args = NULL;
- args = &this_req->compound_req_v2_u.compound_lk_req;
+ args = &this_req->compound_req_v2_u.compound_lk_req;
- xdr_to_dict (&args->xdata, &xdata);
+ xdr_to_dict(&args->xdata, &xdata);
- switch (args->cmd) {
+ switch (args->cmd) {
case GF_LK_GETLK:
- this_args->cmd = F_GETLK;
- break;
+ this_args->cmd = F_GETLK;
+ break;
case GF_LK_SETLK:
- this_args->cmd = F_SETLK;
- break;
+ this_args->cmd = F_SETLK;
+ break;
case GF_LK_SETLKW:
- this_args->cmd = F_SETLKW;
- break;
+ this_args->cmd = F_SETLKW;
+ break;
case GF_LK_RESLK_LCK:
- this_args->cmd = F_RESLK_LCK;
- break;
+ this_args->cmd = F_RESLK_LCK;
+ break;
case GF_LK_RESLK_LCKW:
- this_args->cmd = F_RESLK_LCKW;
- break;
+ this_args->cmd = F_RESLK_LCKW;
+ break;
case GF_LK_RESLK_UNLCK:
- this_args->cmd = F_RESLK_UNLCK;
- break;
+ this_args->cmd = F_RESLK_UNLCK;
+ break;
case GF_LK_GETLK_FD:
- this_args->cmd = F_GETLK_FD;
- break;
- }
+ this_args->cmd = F_GETLK_FD;
+ break;
+ }
- gf_proto_flock_to_flock (&args->flock, &this_args->lock);
+ gf_proto_flock_to_flock(&args->flock, &this_args->lock);
- switch (args->type) {
+ switch (args->type) {
case GF_LK_F_RDLCK:
- this_args->lock.l_type = F_RDLCK;
- break;
+ this_args->lock.l_type = F_RDLCK;
+ break;
case GF_LK_F_WRLCK:
- this_args->lock.l_type = F_WRLCK;
- break;
+ this_args->lock.l_type = F_WRLCK;
+ break;
case GF_LK_F_UNLCK:
- this_args->lock.l_type = F_UNLCK;
- break;
+ this_args->lock.l_type = F_UNLCK;
+ break;
default:
- gf_msg (frame->root->client->bound_xl->name,
- GF_LOG_ERROR,
- 0, PS_MSG_LOCK_ERROR, "fd - %"PRId64" (%s):"
- " Unknown "
- "lock type: %"PRId32"!", state->resolve.fd_no,
- uuid_utoa (state->fd->inode->gfid),
- args->type);
- break;
- }
- args_lk_store (this_args, state->fd, this_args->cmd,
- &this_args->lock, xdata);
- break;
- }
- case GF_FOP_LOOKUP:
- {
- gfx_lookup_req *args = NULL;
-
- args = &this_req->compound_req_v2_u.compound_lookup_req;
-
- if (this_args->loc.inode)
- this_args->loc.inode = server_inode_new (state->itable,
- state->loc.gfid);
- else
- state->is_revalidate = 1;
-
- xdr_to_dict (&args->xdata, &xdata);
- args_lookup_store (this_args, &state->loc, xdata);
- break;
- }
- case GF_FOP_READDIR:
- {
- gfx_readdir_req *args = NULL;
-
- args = &this_req->compound_req_v2_u.compound_readdir_req;
-
- xdr_to_dict (&args->xdata, &xdata);
- args_readdir_store (this_args, state->fd, args->size,
- args->offset, xdata);
- break;
- }
- case GF_FOP_INODELK:
- {
- gfx_inodelk_req *args = NULL;
-
- args = &this_req->compound_req_v2_u.compound_inodelk_req;
-
- switch (args->cmd) {
+ gf_msg(frame->root->client->bound_xl->name, GF_LOG_ERROR, 0,
+ PS_MSG_LOCK_ERROR,
+ "fd - %" PRId64
+ " (%s):"
+ " Unknown "
+ "lock type: %" PRId32 "!",
+ state->resolve.fd_no,
+ uuid_utoa(state->fd->inode->gfid), args->type);
+ break;
+ }
+ args_lk_store(this_args, state->fd, this_args->cmd,
+ &this_args->lock, xdata);
+ break;
+ }
+ case GF_FOP_LOOKUP: {
+ gfx_lookup_req *args = NULL;
+
+ args = &this_req->compound_req_v2_u.compound_lookup_req;
+
+ if (this_args->loc.inode)
+ this_args->loc.inode = server_inode_new(state->itable,
+ state->loc.gfid);
+ else
+ state->is_revalidate = 1;
+
+ xdr_to_dict(&args->xdata, &xdata);
+ args_lookup_store(this_args, &state->loc, xdata);
+ break;
+ }
+ case GF_FOP_READDIR: {
+ gfx_readdir_req *args = NULL;
+
+ args = &this_req->compound_req_v2_u.compound_readdir_req;
+
+ xdr_to_dict(&args->xdata, &xdata);
+ args_readdir_store(this_args, state->fd, args->size, args->offset,
+ xdata);
+ break;
+ }
+ case GF_FOP_INODELK: {
+ gfx_inodelk_req *args = NULL;
+
+ args = &this_req->compound_req_v2_u.compound_inodelk_req;
+
+ switch (args->cmd) {
case GF_LK_GETLK:
- this_args->cmd = F_GETLK;
- break;
+ this_args->cmd = F_GETLK;
+ break;
case GF_LK_SETLK:
- this_args->cmd = F_SETLK;
- break;
+ this_args->cmd = F_SETLK;
+ break;
case GF_LK_SETLKW:
- this_args->cmd = F_SETLKW;
- break;
- }
+ this_args->cmd = F_SETLKW;
+ break;
+ }
- gf_proto_flock_to_flock (&args->flock, &this_args->lock);
+ gf_proto_flock_to_flock(&args->flock, &this_args->lock);
- switch (args->type) {
+ switch (args->type) {
case GF_LK_F_RDLCK:
- this_args->lock.l_type = F_RDLCK;
- break;
+ this_args->lock.l_type = F_RDLCK;
+ break;
case GF_LK_F_WRLCK:
- this_args->lock.l_type = F_WRLCK;
- break;
+ this_args->lock.l_type = F_WRLCK;
+ break;
case GF_LK_F_UNLCK:
- this_args->lock.l_type = F_UNLCK;
- break;
- }
+ this_args->lock.l_type = F_UNLCK;
+ break;
+ }
- xdr_to_dict (&args->xdata, &xdata);
- args_inodelk_store (this_args, args->volume, &state->loc,
- this_args->cmd, &this_args->lock, xdata);
- break;
+ xdr_to_dict(&args->xdata, &xdata);
+ args_inodelk_store(this_args, args->volume, &state->loc,
+ this_args->cmd, &this_args->lock, xdata);
+ break;
}
- case GF_FOP_FINODELK:
- {
- gfx_finodelk_req *args = NULL;
+ case GF_FOP_FINODELK: {
+ gfx_finodelk_req *args = NULL;
- args = &this_req->compound_req_v2_u.compound_finodelk_req;
+ args = &this_req->compound_req_v2_u.compound_finodelk_req;
- xdr_to_dict (&args->xdata, &xdata);
+ xdr_to_dict(&args->xdata, &xdata);
- switch (args->cmd) {
+ switch (args->cmd) {
case GF_LK_GETLK:
- this_args->cmd = F_GETLK;
- break;
+ this_args->cmd = F_GETLK;
+ break;
case GF_LK_SETLK:
- this_args->cmd = F_SETLK;
- break;
+ this_args->cmd = F_SETLK;
+ break;
case GF_LK_SETLKW:
- this_args->cmd = F_SETLKW;
- break;
- }
+ this_args->cmd = F_SETLKW;
+ break;
+ }
- gf_proto_flock_to_flock (&args->flock, &this_args->lock);
+ gf_proto_flock_to_flock(&args->flock, &this_args->lock);
- switch (args->type) {
+ switch (args->type) {
case GF_LK_F_RDLCK:
- this_args->lock.l_type = F_RDLCK;
- break;
+ this_args->lock.l_type = F_RDLCK;
+ break;
case GF_LK_F_WRLCK:
- this_args->lock.l_type = F_WRLCK;
- break;
+ this_args->lock.l_type = F_WRLCK;
+ break;
case GF_LK_F_UNLCK:
- this_args->lock.l_type = F_UNLCK;
- break;
- }
- args_finodelk_store (this_args, args->volume, state->fd,
- this_args->cmd, &this_args->lock, xdata);
- break;
+ this_args->lock.l_type = F_UNLCK;
+ break;
+ }
+ args_finodelk_store(this_args, args->volume, state->fd,
+ this_args->cmd, &this_args->lock, xdata);
+ break;
}
- case GF_FOP_ENTRYLK:
- {
- gfx_entrylk_req *args = NULL;
+ case GF_FOP_ENTRYLK: {
+ gfx_entrylk_req *args = NULL;
- args = &this_req->compound_req_v2_u.compound_entrylk_req;
+ args = &this_req->compound_req_v2_u.compound_entrylk_req;
- xdr_to_dict (&args->xdata, &xdata);
- args_entrylk_store (this_args, args->volume, &state->loc,
- args->name, args->cmd, args->type, xdata);
- break;
+ xdr_to_dict(&args->xdata, &xdata);
+ args_entrylk_store(this_args, args->volume, &state->loc, args->name,
+ args->cmd, args->type, xdata);
+ break;
}
- case GF_FOP_FENTRYLK:
- {
- gfx_fentrylk_req *args = NULL;
+ case GF_FOP_FENTRYLK: {
+ gfx_fentrylk_req *args = NULL;
- args = &this_req->compound_req_v2_u.compound_fentrylk_req;
+ args = &this_req->compound_req_v2_u.compound_fentrylk_req;
- xdr_to_dict (&args->xdata, &xdata);
- args_fentrylk_store (this_args, args->volume, state->fd,
- args->name, args->cmd, args->type, xdata);
- break;
+ xdr_to_dict(&args->xdata, &xdata);
+ args_fentrylk_store(this_args, args->volume, state->fd, args->name,
+ args->cmd, args->type, xdata);
+ break;
}
- case GF_FOP_XATTROP:
- {
- gfx_xattrop_req *args = NULL;
+ case GF_FOP_XATTROP: {
+ gfx_xattrop_req *args = NULL;
- args = &this_req->compound_req_v2_u.compound_xattrop_req;
+ args = &this_req->compound_req_v2_u.compound_xattrop_req;
- xdr_to_dict (&args->dict, &xattr);
+ xdr_to_dict(&args->dict, &xattr);
- xdr_to_dict (&args->xdata, &xdata);
- args_xattrop_store (this_args, &state->loc, args->flags,
- xattr, xdata);
- break;
+ xdr_to_dict(&args->xdata, &xdata);
+ args_xattrop_store(this_args, &state->loc, args->flags, xattr,
+ xdata);
+ break;
}
- case GF_FOP_FXATTROP:
- {
- gfx_fxattrop_req *args = NULL;
+ case GF_FOP_FXATTROP: {
+ gfx_fxattrop_req *args = NULL;
- args = &this_req->compound_req_v2_u.compound_fxattrop_req;
+ args = &this_req->compound_req_v2_u.compound_fxattrop_req;
- xdr_to_dict (&args->dict, &xattr);
+ xdr_to_dict(&args->dict, &xattr);
- xdr_to_dict (&args->xdata, &xdata);
+ xdr_to_dict(&args->xdata, &xdata);
- args_fxattrop_store (this_args, state->fd, args->flags, xattr,
- xdata);
- break;
+ args_fxattrop_store(this_args, state->fd, args->flags, xattr,
+ xdata);
+ break;
}
- case GF_FOP_FGETXATTR:
- {
- gfx_fgetxattr_req *args = NULL;
+ case GF_FOP_FGETXATTR: {
+ gfx_fgetxattr_req *args = NULL;
- args = &this_req->compound_req_v2_u.compound_fgetxattr_req;
+ args = &this_req->compound_req_v2_u.compound_fgetxattr_req;
- xdr_to_dict (&args->xdata, &xdata);
+ xdr_to_dict(&args->xdata, &xdata);
- args_fgetxattr_store (this_args, state->fd, args->name, xdata);
- break;
+ args_fgetxattr_store(this_args, state->fd, args->name, xdata);
+ break;
}
- case GF_FOP_FSETXATTR:
- {
- gfx_fsetxattr_req *args = NULL;
+ case GF_FOP_FSETXATTR: {
+ gfx_fsetxattr_req *args = NULL;
- args = &this_req->compound_req_v2_u.compound_fsetxattr_req;
+ args = &this_req->compound_req_v2_u.compound_fsetxattr_req;
- xdr_to_dict (&args->dict, &xattr);
+ xdr_to_dict(&args->dict, &xattr);
- xdr_to_dict (&args->xdata, &xdata);
+ xdr_to_dict(&args->xdata, &xdata);
- args_fsetxattr_store (this_args, state->fd, xattr, args->flags,
- xdata);
- break;
+ args_fsetxattr_store(this_args, state->fd, xattr, args->flags,
+ xdata);
+ break;
}
- case GF_FOP_RCHECKSUM:
- {
- gfx_rchecksum_req *args = NULL;
+ case GF_FOP_RCHECKSUM: {
+ gfx_rchecksum_req *args = NULL;
- args = &this_req->compound_req_v2_u.compound_rchecksum_req;
+ args = &this_req->compound_req_v2_u.compound_rchecksum_req;
- xdr_to_dict (&args->xdata, &xdata);
+ xdr_to_dict(&args->xdata, &xdata);
- args_rchecksum_store (this_args, state->fd, args->offset,
- args->len, xdata);
- break;
+ args_rchecksum_store(this_args, state->fd, args->offset, args->len,
+ xdata);
+ break;
}
- case GF_FOP_SETATTR:
- {
- gfx_setattr_req *args = NULL;
+ case GF_FOP_SETATTR: {
+ gfx_setattr_req *args = NULL;
- args = &this_req->compound_req_v2_u.compound_setattr_req;
+ args = &this_req->compound_req_v2_u.compound_setattr_req;
- xdr_to_dict (&args->xdata, &xdata);
+ xdr_to_dict(&args->xdata, &xdata);
- gfx_stat_to_iattx (&args->stbuf, &this_args->stat);
+ gfx_stat_to_iattx(&args->stbuf, &this_args->stat);
- args_setattr_store (this_args, &state->loc, &this_args->stat,
- args->valid, xdata);
- break;
+ args_setattr_store(this_args, &state->loc, &this_args->stat,
+ args->valid, xdata);
+ break;
}
- case GF_FOP_FSETATTR:
- {
- gfx_fsetattr_req *args = NULL;
+ case GF_FOP_FSETATTR: {
+ gfx_fsetattr_req *args = NULL;
- args = &this_req->compound_req_v2_u.compound_fsetattr_req;
+ args = &this_req->compound_req_v2_u.compound_fsetattr_req;
- xdr_to_dict (&args->xdata, &xdata);
+ xdr_to_dict(&args->xdata, &xdata);
- gfx_stat_to_iattx (&args->stbuf, &this_args->stat);
+ gfx_stat_to_iattx(&args->stbuf, &this_args->stat);
- args_fsetattr_store (this_args, state->fd, &this_args->stat,
- args->valid, xdata);
- break;
+ args_fsetattr_store(this_args, state->fd, &this_args->stat,
+ args->valid, xdata);
+ break;
}
- case GF_FOP_READDIRP:
- {
- gfx_readdirp_req *args = NULL;
+ case GF_FOP_READDIRP: {
+ gfx_readdirp_req *args = NULL;
- args = &this_req->compound_req_v2_u.compound_readdirp_req;
+ args = &this_req->compound_req_v2_u.compound_readdirp_req;
- xdr_to_dict (&args->xdata, &xdata);
+ xdr_to_dict(&args->xdata, &xdata);
- args_readdirp_store (this_args, state->fd, args->size,
- args->offset, xattr);
- break;
+ args_readdirp_store(this_args, state->fd, args->size, args->offset,
+ xattr);
+ break;
}
- case GF_FOP_FREMOVEXATTR:
- {
- gfx_fremovexattr_req *args = NULL;
+ case GF_FOP_FREMOVEXATTR: {
+ gfx_fremovexattr_req *args = NULL;
- args = &this_req->compound_req_v2_u.compound_fremovexattr_req;
+ args = &this_req->compound_req_v2_u.compound_fremovexattr_req;
- xdr_to_dict (&args->xdata, &xdata);
+ xdr_to_dict(&args->xdata, &xdata);
- args_fremovexattr_store (this_args, state->fd, args->name,
- xdata);
- break;
+ args_fremovexattr_store(this_args, state->fd, args->name, xdata);
+ break;
}
- case GF_FOP_FALLOCATE:
- {
- gfx_fallocate_req *args = NULL;
+ case GF_FOP_FALLOCATE: {
+ gfx_fallocate_req *args = NULL;
- args = &this_req->compound_req_v2_u.compound_fallocate_req;
+ args = &this_req->compound_req_v2_u.compound_fallocate_req;
- xdr_to_dict (&args->xdata, &xdata);
- args_fallocate_store (this_args, state->fd, args->flags,
- args->offset, args->size, xdata);
- break;
+ xdr_to_dict(&args->xdata, &xdata);
+ args_fallocate_store(this_args, state->fd, args->flags,
+ args->offset, args->size, xdata);
+ break;
}
- case GF_FOP_DISCARD:
- {
- gfx_discard_req *args = NULL;
+ case GF_FOP_DISCARD: {
+ gfx_discard_req *args = NULL;
- args = &this_req->compound_req_v2_u.compound_discard_req;
+ args = &this_req->compound_req_v2_u.compound_discard_req;
- xdr_to_dict (&args->xdata, &xdata);
+ xdr_to_dict(&args->xdata, &xdata);
- args_discard_store (this_args, state->fd, args->offset,
- args->size, xdata);
- break;
+ args_discard_store(this_args, state->fd, args->offset, args->size,
+ xdata);
+ break;
}
- case GF_FOP_ZEROFILL:
- {
- gfx_zerofill_req *args = NULL;
+ case GF_FOP_ZEROFILL: {
+ gfx_zerofill_req *args = NULL;
- args = &this_req->compound_req_v2_u.compound_zerofill_req;
+ args = &this_req->compound_req_v2_u.compound_zerofill_req;
- xdr_to_dict (&args->xdata, &xdata);
- args_zerofill_store (this_args, state->fd, args->offset,
- args->size, xdata);
- break;
+ xdr_to_dict(&args->xdata, &xdata);
+ args_zerofill_store(this_args, state->fd, args->offset, args->size,
+ xdata);
+ break;
}
- case GF_FOP_SEEK:
- {
- gfx_seek_req *args = NULL;
+ case GF_FOP_SEEK: {
+ gfx_seek_req *args = NULL;
- args = &this_req->compound_req_v2_u.compound_seek_req;
+ args = &this_req->compound_req_v2_u.compound_seek_req;
- xdr_to_dict (&args->xdata, &xdata);
- args_seek_store (this_args, state->fd, args->offset, args->what,
- xdata);
- break;
+ xdr_to_dict(&args->xdata, &xdata);
+ args_seek_store(this_args, state->fd, args->offset, args->what,
+ xdata);
+ break;
}
- case GF_FOP_LEASE:
- {
- gfx_lease_req *args = NULL;
+ case GF_FOP_LEASE: {
+ gfx_lease_req *args = NULL;
- args = &this_req->compound_req_v2_u.compound_lease_req;
+ args = &this_req->compound_req_v2_u.compound_lease_req;
- xdr_to_dict (&args->xdata, &xdata);
+ xdr_to_dict(&args->xdata, &xdata);
- gf_proto_lease_to_lease (&args->lease, &state->lease);
+ gf_proto_lease_to_lease(&args->lease, &state->lease);
- args_lease_store (this_args, &state->loc, &state->lease, xdata);
- break;
+ args_lease_store(this_args, &state->loc, &state->lease, xdata);
+ break;
}
default:
- return ENOTSUP;
- }
+ return ENOTSUP;
+ }
out:
- if (xattr)
- dict_unref (xattr);
- if (xdata)
- dict_unref (xdata);
- return op_errno;
+ if (xattr)
+ dict_unref(xattr);
+ if (xdata)
+ dict_unref(xdata);
+ return op_errno;
}
int
-server_populate_compound_response_v2 (xlator_t *this, gfx_compound_rsp *rsp,
- call_frame_t *frame,
- compound_args_cbk_t *args_cbk, int index)
+server_populate_compound_response_v2(xlator_t *this, gfx_compound_rsp *rsp,
+ call_frame_t *frame,
+ compound_args_cbk_t *args_cbk, int index)
{
- int op_errno = EINVAL;
- default_args_cbk_t *this_args_cbk = NULL;
- compound_rsp_v2 *this_rsp = NULL;
- server_state_t *state = NULL;
- int ret = 0;
+ int op_errno = EINVAL;
+ default_args_cbk_t *this_args_cbk = NULL;
+ compound_rsp_v2 *this_rsp = NULL;
+ server_state_t *state = NULL;
+ int ret = 0;
- state = CALL_STATE (frame);
- this_rsp = &rsp->compound_rsp_array.compound_rsp_array_val[index];
+ state = CALL_STATE(frame);
+ this_rsp = &rsp->compound_rsp_array.compound_rsp_array_val[index];
- this_args_cbk = &args_cbk->rsp_list[index];
- this_rsp->fop_enum = args_cbk->enum_list[index];
+ this_args_cbk = &args_cbk->rsp_list[index];
+ this_rsp->fop_enum = args_cbk->enum_list[index];
- switch (this_rsp->fop_enum) {
+ switch (this_rsp->fop_enum) {
case GF_FOP_FSTAT:
- case GF_FOP_STAT:
- {
- gfx_common_iatt_rsp *rsp_args = NULL;
-
- rsp_args = &this_rsp->compound_rsp_v2_u.compound_stat_rsp;
-
- dict_to_xdr (this_args_cbk->xdata, &rsp_args->xdata);
- if (!this_args_cbk->op_ret) {
- server4_post_common_iatt (state, rsp_args,
- &this_args_cbk->stat);
- }
- rsp_args->op_ret = this_args_cbk->op_ret;
- rsp_args->op_errno = gf_errno_to_error
- (this_args_cbk->op_errno);
- break;
- }
- case GF_FOP_READLINK:
- {
- gfx_readlink_rsp *rsp_args = NULL;
-
- rsp_args = &this_rsp->compound_rsp_v2_u.compound_readlink_rsp;
-
- dict_to_xdr (this_args_cbk->xdata, &rsp_args->xdata);
- if (this_args_cbk->op_ret >= 0) {
- server4_post_readlink (rsp_args, &this_args_cbk->stat,
- this_args_cbk->buf);
- }
- rsp_args->op_ret = this_args_cbk->op_ret;
- rsp_args->op_errno = gf_errno_to_error
- (this_args_cbk->op_errno);
- if (!rsp_args->path)
- rsp_args->path = "";
- break;
+ case GF_FOP_STAT: {
+ gfx_common_iatt_rsp *rsp_args = NULL;
+
+ rsp_args = &this_rsp->compound_rsp_v2_u.compound_stat_rsp;
+
+ dict_to_xdr(this_args_cbk->xdata, &rsp_args->xdata);
+ if (!this_args_cbk->op_ret) {
+ server4_post_common_iatt(state, rsp_args, &this_args_cbk->stat);
+ }
+ rsp_args->op_ret = this_args_cbk->op_ret;
+ rsp_args->op_errno = gf_errno_to_error(this_args_cbk->op_errno);
+ break;
+ }
+ case GF_FOP_READLINK: {
+ gfx_readlink_rsp *rsp_args = NULL;
+
+ rsp_args = &this_rsp->compound_rsp_v2_u.compound_readlink_rsp;
+
+ dict_to_xdr(this_args_cbk->xdata, &rsp_args->xdata);
+ if (this_args_cbk->op_ret >= 0) {
+ server4_post_readlink(rsp_args, &this_args_cbk->stat,
+ this_args_cbk->buf);
+ }
+ rsp_args->op_ret = this_args_cbk->op_ret;
+ rsp_args->op_errno = gf_errno_to_error(this_args_cbk->op_errno);
+ if (!rsp_args->path)
+ rsp_args->path = "";
+ break;
}
case GF_FOP_MKNOD:
case GF_FOP_MKDIR:
case GF_FOP_SYMLINK:
- case GF_FOP_LINK:
- {
- gfx_common_3iatt_rsp *rsp_args = NULL;
+ case GF_FOP_LINK: {
+ gfx_common_3iatt_rsp *rsp_args = NULL;
- rsp_args = &this_rsp->compound_rsp_v2_u.compound_mknod_rsp;
+ rsp_args = &this_rsp->compound_rsp_v2_u.compound_mknod_rsp;
- dict_to_xdr (this_args_cbk->xdata, &rsp_args->xdata);
- if (!this_args_cbk->op_ret) {
- server4_post_common_3iatt (state, rsp_args,
- this_args_cbk->inode,
- &this_args_cbk->stat,
- &this_args_cbk->preparent,
- &this_args_cbk->postparent);
- }
- rsp_args->op_ret = this_args_cbk->op_ret;
- rsp_args->op_errno = gf_errno_to_error
- (this_args_cbk->op_errno);
- break;
+ dict_to_xdr(this_args_cbk->xdata, &rsp_args->xdata);
+ if (!this_args_cbk->op_ret) {
+ server4_post_common_3iatt(
+ state, rsp_args, this_args_cbk->inode, &this_args_cbk->stat,
+ &this_args_cbk->preparent, &this_args_cbk->postparent);
+ }
+ rsp_args->op_ret = this_args_cbk->op_ret;
+ rsp_args->op_errno = gf_errno_to_error(this_args_cbk->op_errno);
+ break;
}
case GF_FOP_UNLINK:
- case GF_FOP_RMDIR:
- {
- gfx_common_2iatt_rsp *rsp_args = NULL;
+ case GF_FOP_RMDIR: {
+ gfx_common_2iatt_rsp *rsp_args = NULL;
- rsp_args = &this_rsp->compound_rsp_v2_u.compound_unlink_rsp;
+ rsp_args = &this_rsp->compound_rsp_v2_u.compound_unlink_rsp;
- dict_to_xdr (this_args_cbk->xdata, &rsp_args->xdata);
- if (!this_args_cbk->op_ret) {
- server4_post_entry_remove (state, rsp_args,
- &this_args_cbk->preparent,
- &this_args_cbk->postparent);
- }
- rsp_args->op_ret = this_args_cbk->op_ret;
- rsp_args->op_errno = gf_errno_to_error
- (this_args_cbk->op_errno);
- break;
+ dict_to_xdr(this_args_cbk->xdata, &rsp_args->xdata);
+ if (!this_args_cbk->op_ret) {
+ server4_post_entry_remove(state, rsp_args,
+ &this_args_cbk->preparent,
+ &this_args_cbk->postparent);
+ }
+ rsp_args->op_ret = this_args_cbk->op_ret;
+ rsp_args->op_errno = gf_errno_to_error(this_args_cbk->op_errno);
+ break;
}
- case GF_FOP_RENAME:
- {
- gfx_rename_rsp *rsp_args = NULL;
+ case GF_FOP_RENAME: {
+ gfx_rename_rsp *rsp_args = NULL;
- rsp_args = &this_rsp->compound_rsp_v2_u.compound_rename_rsp;
+ rsp_args = &this_rsp->compound_rsp_v2_u.compound_rename_rsp;
- dict_to_xdr (this_args_cbk->xdata, &rsp_args->xdata);
+ dict_to_xdr(this_args_cbk->xdata, &rsp_args->xdata);
- if (!this_args_cbk->op_ret) {
- server4_post_rename (frame, state, rsp_args,
- &this_args_cbk->stat,
- &this_args_cbk->preparent,
- &this_args_cbk->postparent,
- &this_args_cbk->preparent2,
- &this_args_cbk->postparent2);
- }
- rsp_args->op_ret = this_args_cbk->op_ret;
- rsp_args->op_errno = gf_errno_to_error
- (this_args_cbk->op_errno);
- break;
+ if (!this_args_cbk->op_ret) {
+ server4_post_rename(
+ frame, state, rsp_args, &this_args_cbk->stat,
+ &this_args_cbk->preparent, &this_args_cbk->postparent,
+ &this_args_cbk->preparent2, &this_args_cbk->postparent2);
+ }
+ rsp_args->op_ret = this_args_cbk->op_ret;
+ rsp_args->op_errno = gf_errno_to_error(this_args_cbk->op_errno);
+ break;
}
- case GF_FOP_FALLOCATE:
- case GF_FOP_ZEROFILL:
- case GF_FOP_DISCARD:
+ case GF_FOP_FALLOCATE:
+ case GF_FOP_ZEROFILL:
+ case GF_FOP_DISCARD:
case GF_FOP_SETATTR:
case GF_FOP_FSETATTR:
case GF_FOP_FTRUNCATE:
case GF_FOP_TRUNCATE:
case GF_FOP_WRITE:
- case GF_FOP_FSYNC:
- {
- gfx_common_2iatt_rsp *rsp_args = NULL;
+ case GF_FOP_FSYNC: {
+ gfx_common_2iatt_rsp *rsp_args = NULL;
- rsp_args = &this_rsp->compound_rsp_v2_u.compound_truncate_rsp;
+ rsp_args = &this_rsp->compound_rsp_v2_u.compound_truncate_rsp;
- dict_to_xdr (this_args_cbk->xdata, &rsp_args->xdata);
+ dict_to_xdr(this_args_cbk->xdata, &rsp_args->xdata);
- if (!this_args_cbk->op_ret) {
- server4_post_common_2iatt (rsp_args,
- &this_args_cbk->prestat,
- &this_args_cbk->poststat);
- }
- rsp_args->op_ret = this_args_cbk->op_ret;
- rsp_args->op_errno = gf_errno_to_error
- (this_args_cbk->op_errno);
- break;
+ if (!this_args_cbk->op_ret) {
+ server4_post_common_2iatt(rsp_args, &this_args_cbk->prestat,
+ &this_args_cbk->poststat);
+ }
+ rsp_args->op_ret = this_args_cbk->op_ret;
+ rsp_args->op_errno = gf_errno_to_error(this_args_cbk->op_errno);
+ break;
}
case GF_FOP_OPEN:
- case GF_FOP_OPENDIR:
- {
- gfx_open_rsp *rsp_args = NULL;
+ case GF_FOP_OPENDIR: {
+ gfx_open_rsp *rsp_args = NULL;
- rsp_args = &this_rsp->compound_rsp_v2_u.compound_open_rsp;
+ rsp_args = &this_rsp->compound_rsp_v2_u.compound_open_rsp;
- dict_to_xdr (this_args_cbk->xdata, &rsp_args->xdata);
+ dict_to_xdr(this_args_cbk->xdata, &rsp_args->xdata);
- if (!this_args_cbk->op_ret) {
- server4_post_open (frame, this, rsp_args,
- this_args_cbk->fd);
-
- }
- rsp_args->op_ret = this_args_cbk->op_ret;
- rsp_args->op_errno = gf_errno_to_error
- (this_args_cbk->op_errno);
- break;
+ if (!this_args_cbk->op_ret) {
+ server4_post_open(frame, this, rsp_args, this_args_cbk->fd);
+ }
+ rsp_args->op_ret = this_args_cbk->op_ret;
+ rsp_args->op_errno = gf_errno_to_error(this_args_cbk->op_errno);
+ break;
}
- case GF_FOP_READ:
- {
- gfx_read_rsp *rsp_args = NULL;
-
- rsp_args = &this_rsp->compound_rsp_v2_u.compound_read_rsp;
-
- dict_to_xdr (this_args_cbk->xdata, &rsp_args->xdata);
-
- if (this_args_cbk->op_ret >= 0) {
- server4_post_readv (rsp_args, &this_args_cbk->stat,
- this_args_cbk->op_ret);
-
- if (!state->rsp_iobref) {
- state->rsp_iobref = this_args_cbk->iobref;
- state->rsp_count = 0;
- }
- iobref_merge (state->rsp_iobref,
- this_args_cbk->iobref);
- memcpy (&state->rsp_vector[state->rsp_count],
- this_args_cbk->vector,
- (this_args_cbk->count *
- sizeof(state->rsp_vector[0])));
- state->rsp_count += this_args_cbk->count;
+ case GF_FOP_READ: {
+ gfx_read_rsp *rsp_args = NULL;
+
+ rsp_args = &this_rsp->compound_rsp_v2_u.compound_read_rsp;
+
+ dict_to_xdr(this_args_cbk->xdata, &rsp_args->xdata);
+
+ if (this_args_cbk->op_ret >= 0) {
+ server4_post_readv(rsp_args, &this_args_cbk->stat,
+ this_args_cbk->op_ret);
+
+ if (!state->rsp_iobref) {
+ state->rsp_iobref = this_args_cbk->iobref;
+ state->rsp_count = 0;
}
- rsp_args->op_ret = this_args_cbk->op_ret;
- rsp_args->op_errno = gf_errno_to_error
- (this_args_cbk->op_errno);
- break;
+ iobref_merge(state->rsp_iobref, this_args_cbk->iobref);
+ memcpy(&state->rsp_vector[state->rsp_count],
+ this_args_cbk->vector,
+ (this_args_cbk->count * sizeof(state->rsp_vector[0])));
+ state->rsp_count += this_args_cbk->count;
+ }
+ rsp_args->op_ret = this_args_cbk->op_ret;
+ rsp_args->op_errno = gf_errno_to_error(this_args_cbk->op_errno);
+ break;
}
- case GF_FOP_STATFS:
- {
- gfx_statfs_rsp *rsp_args = NULL;
+ case GF_FOP_STATFS: {
+ gfx_statfs_rsp *rsp_args = NULL;
- rsp_args = &this_rsp->compound_rsp_v2_u.compound_statfs_rsp;
+ rsp_args = &this_rsp->compound_rsp_v2_u.compound_statfs_rsp;
- dict_to_xdr (this_args_cbk->xdata, &rsp_args->xdata);
- if (!this_args_cbk->op_ret) {
- server4_post_statfs (rsp_args,
- &this_args_cbk->statvfs);
- }
- rsp_args->op_ret = this_args_cbk->op_ret;
- rsp_args->op_errno = gf_errno_to_error
- (this_args_cbk->op_errno);
- break;
+ dict_to_xdr(this_args_cbk->xdata, &rsp_args->xdata);
+ if (!this_args_cbk->op_ret) {
+ server4_post_statfs(rsp_args, &this_args_cbk->statvfs);
+ }
+ rsp_args->op_ret = this_args_cbk->op_ret;
+ rsp_args->op_errno = gf_errno_to_error(this_args_cbk->op_errno);
+ break;
}
case GF_FOP_FLUSH:
case GF_FOP_SETXATTR:
@@ -5317,200 +4858,173 @@ server_populate_compound_response_v2 (xlator_t *this, gfx_compound_rsp *rsp,
case GF_FOP_INODELK:
case GF_FOP_FINODELK:
case GF_FOP_ENTRYLK:
- case GF_FOP_FENTRYLK:
- {
- gfx_common_rsp *rsp_args = NULL;
+ case GF_FOP_FENTRYLK: {
+ gfx_common_rsp *rsp_args = NULL;
- rsp_args = &this_rsp->compound_rsp_v2_u.compound_flush_rsp;
+ rsp_args = &this_rsp->compound_rsp_v2_u.compound_flush_rsp;
- dict_to_xdr (this_args_cbk->xdata, &rsp_args->xdata);
- rsp_args->op_ret = this_args_cbk->op_ret;
- rsp_args->op_errno = gf_errno_to_error
- (this_args_cbk->op_errno);
- break;
+ dict_to_xdr(this_args_cbk->xdata, &rsp_args->xdata);
+ rsp_args->op_ret = this_args_cbk->op_ret;
+ rsp_args->op_errno = gf_errno_to_error(this_args_cbk->op_errno);
+ break;
}
case GF_FOP_FGETXATTR:
case GF_FOP_GETXATTR:
case GF_FOP_XATTROP:
- case GF_FOP_FXATTROP:
- {
- gfx_common_dict_rsp *rsp_args = NULL;
+ case GF_FOP_FXATTROP: {
+ gfx_common_dict_rsp *rsp_args = NULL;
- rsp_args = &this_rsp->compound_rsp_v2_u.compound_getxattr_rsp;
+ rsp_args = &this_rsp->compound_rsp_v2_u.compound_getxattr_rsp;
- dict_to_xdr (this_args_cbk->xdata, &rsp_args->xdata);
+ dict_to_xdr(this_args_cbk->xdata, &rsp_args->xdata);
- if (-1 != this_args_cbk->op_ret) {
- dict_to_xdr (this_args_cbk->xattr, &rsp_args->dict);
- }
- rsp_args->op_ret = this_args_cbk->op_ret;
- rsp_args->op_errno = gf_errno_to_error
- (this_args_cbk->op_errno);
- break;
+ if (-1 != this_args_cbk->op_ret) {
+ dict_to_xdr(this_args_cbk->xattr, &rsp_args->dict);
+ }
+ rsp_args->op_ret = this_args_cbk->op_ret;
+ rsp_args->op_errno = gf_errno_to_error(this_args_cbk->op_errno);
+ break;
}
- case GF_FOP_CREATE:
- {
- gfx_create_rsp *rsp_args = NULL;
-
- rsp_args = &this_rsp->compound_rsp_v2_u.compound_create_rsp;
-
- dict_to_xdr (this_args_cbk->xdata, &rsp_args->xdata);
-
- rsp_args->op_ret = this_args_cbk->op_ret;
- rsp_args->op_errno = gf_errno_to_error
- (this_args_cbk->op_errno);
-
- if (!this_args_cbk->op_ret) {
- rsp_args->op_ret = server4_post_create (frame,
- rsp_args, state, this,
- this_args_cbk->fd,
- this_args_cbk->inode,
- &this_args_cbk->stat,
- &this_args_cbk->preparent,
- &this_args_cbk->postparent);
- if (rsp_args->op_ret) {
- rsp_args->op_errno = -rsp_args->op_ret;
- rsp_args->op_ret = -1;
- }
+ case GF_FOP_CREATE: {
+ gfx_create_rsp *rsp_args = NULL;
+
+ rsp_args = &this_rsp->compound_rsp_v2_u.compound_create_rsp;
+
+ dict_to_xdr(this_args_cbk->xdata, &rsp_args->xdata);
+
+ rsp_args->op_ret = this_args_cbk->op_ret;
+ rsp_args->op_errno = gf_errno_to_error(this_args_cbk->op_errno);
+
+ if (!this_args_cbk->op_ret) {
+ rsp_args->op_ret = server4_post_create(
+ frame, rsp_args, state, this, this_args_cbk->fd,
+ this_args_cbk->inode, &this_args_cbk->stat,
+ &this_args_cbk->preparent, &this_args_cbk->postparent);
+ if (rsp_args->op_ret) {
+ rsp_args->op_errno = -rsp_args->op_ret;
+ rsp_args->op_ret = -1;
}
- break;
+ }
+ break;
}
- case GF_FOP_LK:
- {
- gfx_lk_rsp *rsp_args = NULL;
+ case GF_FOP_LK: {
+ gfx_lk_rsp *rsp_args = NULL;
- rsp_args = &this_rsp->compound_rsp_v2_u.compound_lk_rsp;
+ rsp_args = &this_rsp->compound_rsp_v2_u.compound_lk_rsp;
- dict_to_xdr (this_args_cbk->xdata, &rsp_args->xdata);
+ dict_to_xdr(this_args_cbk->xdata, &rsp_args->xdata);
- if (!this_args_cbk->op_ret) {
- server4_post_lk (this, rsp_args, &this_args_cbk->lock);
- }
+ if (!this_args_cbk->op_ret) {
+ server4_post_lk(this, rsp_args, &this_args_cbk->lock);
+ }
- rsp_args->op_ret = this_args_cbk->op_ret;
- rsp_args->op_errno = gf_errno_to_error
- (this_args_cbk->op_errno);
- break;
+ rsp_args->op_ret = this_args_cbk->op_ret;
+ rsp_args->op_errno = gf_errno_to_error(this_args_cbk->op_errno);
+ break;
}
- case GF_FOP_LOOKUP:
- {
- gfx_common_2iatt_rsp *rsp_args = NULL;
+ case GF_FOP_LOOKUP: {
+ gfx_common_2iatt_rsp *rsp_args = NULL;
- rsp_args = &this_rsp->compound_rsp_v2_u.compound_lookup_rsp;
+ rsp_args = &this_rsp->compound_rsp_v2_u.compound_lookup_rsp;
- dict_to_xdr (this_args_cbk->xdata, &rsp_args->xdata);
- gfx_stat_from_iattx (&rsp_args->poststat,
- &this_args_cbk->postparent);
+ dict_to_xdr(this_args_cbk->xdata, &rsp_args->xdata);
+ gfx_stat_from_iattx(&rsp_args->poststat,
+ &this_args_cbk->postparent);
- if (!this_args_cbk->op_ret) {
- server4_post_lookup (rsp_args, frame, state,
- this_args_cbk->inode,
- &this_args_cbk->stat);
- }
- rsp_args->op_ret = this_args_cbk->op_ret;
- rsp_args->op_errno = gf_errno_to_error
- (this_args_cbk->op_errno);
- break;
+ if (!this_args_cbk->op_ret) {
+ server4_post_lookup(rsp_args, frame, state,
+ this_args_cbk->inode, &this_args_cbk->stat);
+ }
+ rsp_args->op_ret = this_args_cbk->op_ret;
+ rsp_args->op_errno = gf_errno_to_error(this_args_cbk->op_errno);
+ break;
}
- case GF_FOP_READDIR:
- {
- gfx_readdir_rsp *rsp_args = NULL;
+ case GF_FOP_READDIR: {
+ gfx_readdir_rsp *rsp_args = NULL;
- rsp_args = &this_rsp->compound_rsp_v2_u.compound_readdir_rsp;
+ rsp_args = &this_rsp->compound_rsp_v2_u.compound_readdir_rsp;
- dict_to_xdr (this_args_cbk->xdata, &rsp_args->xdata);
+ dict_to_xdr(this_args_cbk->xdata, &rsp_args->xdata);
- rsp_args->op_ret = this_args_cbk->op_ret;
- rsp_args->op_errno = gf_errno_to_error
- (this_args_cbk->op_errno);
+ rsp_args->op_ret = this_args_cbk->op_ret;
+ rsp_args->op_errno = gf_errno_to_error(this_args_cbk->op_errno);
- if (this_args_cbk->op_ret > 0) {
- ret = server4_post_readdir (rsp_args,
- &this_args_cbk->entries);
- if (ret < 0) {
- rsp_args->op_ret = ret;
- rsp_args->op_errno = ENOMEM;
- }
+ if (this_args_cbk->op_ret > 0) {
+ ret = server4_post_readdir(rsp_args, &this_args_cbk->entries);
+ if (ret < 0) {
+ rsp_args->op_ret = ret;
+ rsp_args->op_errno = ENOMEM;
}
- break;
+ }
+ break;
}
- case GF_FOP_RCHECKSUM:
- {
- gfx_rchecksum_rsp *rsp_args = NULL;
+ case GF_FOP_RCHECKSUM: {
+ gfx_rchecksum_rsp *rsp_args = NULL;
- rsp_args = &this_rsp->compound_rsp_v2_u.compound_rchecksum_rsp;
+ rsp_args = &this_rsp->compound_rsp_v2_u.compound_rchecksum_rsp;
- dict_to_xdr (this_args_cbk->xdata, &rsp_args->xdata);
+ dict_to_xdr(this_args_cbk->xdata, &rsp_args->xdata);
- if (!this_args_cbk->op_ret) {
- server4_post_rchecksum (rsp_args,
- this_args_cbk->weak_checksum,
- this_args_cbk->strong_checksum);
- }
- rsp_args->op_ret = this_args_cbk->op_ret;
- rsp_args->op_errno = gf_errno_to_error
- (this_args_cbk->op_errno);
- break;
+ if (!this_args_cbk->op_ret) {
+ server4_post_rchecksum(rsp_args, this_args_cbk->weak_checksum,
+ this_args_cbk->strong_checksum);
+ }
+ rsp_args->op_ret = this_args_cbk->op_ret;
+ rsp_args->op_errno = gf_errno_to_error(this_args_cbk->op_errno);
+ break;
}
- case GF_FOP_READDIRP:
- {
- gfx_readdirp_rsp *rsp_args = NULL;
-
- rsp_args = &this_rsp->compound_rsp_v2_u.compound_readdirp_rsp;
-
- dict_to_xdr (this_args_cbk->xdata, &rsp_args->xdata);
-
- if (this_args_cbk->op_ret > 0) {
- ret = server4_post_readdirp (rsp_args,
- &this_args_cbk->entries);
- if (ret < 0) {
- rsp_args->op_ret = ret;
- rsp_args->op_errno = ENOMEM;
- goto out;
- }
- gf_link_inodes_from_dirent (this, state->fd->inode,
- &this_args_cbk->entries);
+ case GF_FOP_READDIRP: {
+ gfx_readdirp_rsp *rsp_args = NULL;
+
+ rsp_args = &this_rsp->compound_rsp_v2_u.compound_readdirp_rsp;
+
+ dict_to_xdr(this_args_cbk->xdata, &rsp_args->xdata);
+
+ if (this_args_cbk->op_ret > 0) {
+ ret = server4_post_readdirp(rsp_args, &this_args_cbk->entries);
+ if (ret < 0) {
+ rsp_args->op_ret = ret;
+ rsp_args->op_errno = ENOMEM;
+ goto out;
}
- rsp_args->op_ret = this_args_cbk->op_ret;
- rsp_args->op_errno = gf_errno_to_error
- (this_args_cbk->op_errno);
- break;
+ gf_link_inodes_from_dirent(this, state->fd->inode,
+ &this_args_cbk->entries);
+ }
+ rsp_args->op_ret = this_args_cbk->op_ret;
+ rsp_args->op_errno = gf_errno_to_error(this_args_cbk->op_errno);
+ break;
}
- case GF_FOP_SEEK:
- {
- gfx_seek_rsp *rsp_args = NULL;
+ case GF_FOP_SEEK: {
+ gfx_seek_rsp *rsp_args = NULL;
- rsp_args = &this_rsp->compound_rsp_v2_u.compound_seek_rsp;
+ rsp_args = &this_rsp->compound_rsp_v2_u.compound_seek_rsp;
- dict_to_xdr (this_args_cbk->xdata, &rsp_args->xdata);
- rsp_args->op_ret = this_args_cbk->op_ret;
- rsp_args->op_errno = gf_errno_to_error
- (this_args_cbk->op_errno);
- break;
+ dict_to_xdr(this_args_cbk->xdata, &rsp_args->xdata);
+ rsp_args->op_ret = this_args_cbk->op_ret;
+ rsp_args->op_errno = gf_errno_to_error(this_args_cbk->op_errno);
+ break;
}
- case GF_FOP_LEASE:
- {
- gfx_lease_rsp *rsp_args = NULL;
+ case GF_FOP_LEASE: {
+ gfx_lease_rsp *rsp_args = NULL;
- rsp_args = &this_rsp->compound_rsp_v2_u.compound_lease_rsp;
+ rsp_args = &this_rsp->compound_rsp_v2_u.compound_lease_rsp;
- dict_to_xdr (this_args_cbk->xdata, &rsp_args->xdata);
+ dict_to_xdr(this_args_cbk->xdata, &rsp_args->xdata);
- if (!this_args_cbk->op_ret) {
- server4_post_lease (rsp_args, &this_args_cbk->lease);
- }
+ if (!this_args_cbk->op_ret) {
+ server4_post_lease(rsp_args, &this_args_cbk->lease);
+ }
- rsp_args->op_ret = this_args_cbk->op_ret;
- rsp_args->op_errno = gf_errno_to_error
- (this_args_cbk->op_errno);
- break;
+ rsp_args->op_ret = this_args_cbk->op_ret;
+ rsp_args->op_errno = gf_errno_to_error(this_args_cbk->op_errno);
+ break;
}
default:
- return ENOTSUP;
- }
- op_errno = 0;
+ return ENOTSUP;
+ }
+ op_errno = 0;
out:
- return op_errno;
+ return op_errno;
}
/* This works only when the compound fop acts on one loc/inode/gfid.
* If compound fops on more than one inode is required, multiple
@@ -5519,912 +5033,877 @@ out:
* This can be added for future enhancements.
*/
int
-server_get_compound_resolve_v2 (server_state_t *state, gfx_compound_req *req)
+server_get_compound_resolve_v2(server_state_t *state, gfx_compound_req *req)
{
- int i = 0;
- compound_req_v2 *array = NULL;
+ int i = 0;
+ compound_req_v2 *array = NULL;
- array = &req->compound_req_array.compound_req_array_val[i];
+ array = &req->compound_req_array.compound_req_array_val[i];
- switch (array->fop_enum) {
- case GF_FOP_STAT:
- {
- gfx_stat_req this_req = { {0,} };
+ switch (array->fop_enum) {
+ case GF_FOP_STAT: {
+ gfx_stat_req this_req = {{
+ 0,
+ }};
- this_req = array[i].compound_req_v2_u.compound_stat_req;
+ this_req = array[i].compound_req_v2_u.compound_stat_req;
- state->resolve.type = RESOLVE_MUST;
- memcpy (state->resolve.gfid,
- this_req.gfid, 16);
- break;
+ state->resolve.type = RESOLVE_MUST;
+ memcpy(state->resolve.gfid, this_req.gfid, 16);
+ break;
}
- case GF_FOP_READLINK:
- {
- gfx_readlink_req this_req = { {0,} };
+ case GF_FOP_READLINK: {
+ gfx_readlink_req this_req = {{
+ 0,
+ }};
- this_req = array[i].compound_req_v2_u.compound_readlink_req;
+ this_req = array[i].compound_req_v2_u.compound_readlink_req;
- state->resolve.type = RESOLVE_MUST;
- memcpy (state->resolve.gfid,
- this_req.gfid, 16);
- break;
+ state->resolve.type = RESOLVE_MUST;
+ memcpy(state->resolve.gfid, this_req.gfid, 16);
+ break;
}
- case GF_FOP_MKNOD:
- {
- gfx_mknod_req this_req = { {0,} };
+ case GF_FOP_MKNOD: {
+ gfx_mknod_req this_req = {{
+ 0,
+ }};
- this_req = array[i].compound_req_v2_u.compound_mknod_req;
+ this_req = array[i].compound_req_v2_u.compound_mknod_req;
- state->resolve.type = RESOLVE_NOT;
- memcpy (state->resolve.pargfid, this_req.pargfid, 16);
- state->resolve.bname = gf_strdup
- (this_req.bname);
- break;
+ state->resolve.type = RESOLVE_NOT;
+ memcpy(state->resolve.pargfid, this_req.pargfid, 16);
+ state->resolve.bname = gf_strdup(this_req.bname);
+ break;
}
- case GF_FOP_MKDIR:
- {
- gfx_mkdir_req this_req = { {0,} };
+ case GF_FOP_MKDIR: {
+ gfx_mkdir_req this_req = {{
+ 0,
+ }};
- this_req = array[i].compound_req_v2_u.compound_mkdir_req;
+ this_req = array[i].compound_req_v2_u.compound_mkdir_req;
- state->resolve.type = RESOLVE_NOT;
- memcpy (state->resolve.pargfid, this_req.pargfid, 16);
- state->resolve.bname = gf_strdup
- (this_req.bname);
- break;
+ state->resolve.type = RESOLVE_NOT;
+ memcpy(state->resolve.pargfid, this_req.pargfid, 16);
+ state->resolve.bname = gf_strdup(this_req.bname);
+ break;
}
- case GF_FOP_UNLINK:
- {
- gfx_unlink_req this_req = { {0,} };
+ case GF_FOP_UNLINK: {
+ gfx_unlink_req this_req = {{
+ 0,
+ }};
- this_req = array[i].compound_req_v2_u.compound_unlink_req;
+ this_req = array[i].compound_req_v2_u.compound_unlink_req;
- state->resolve.type = RESOLVE_MUST;
- memcpy (state->resolve.pargfid, this_req.pargfid, 16);
- state->resolve.bname = gf_strdup
- (this_req.bname);
- break;
+ state->resolve.type = RESOLVE_MUST;
+ memcpy(state->resolve.pargfid, this_req.pargfid, 16);
+ state->resolve.bname = gf_strdup(this_req.bname);
+ break;
}
- case GF_FOP_RMDIR:
- {
- gfx_rmdir_req this_req = { {0,} };
+ case GF_FOP_RMDIR: {
+ gfx_rmdir_req this_req = {{
+ 0,
+ }};
- this_req = array[i].compound_req_v2_u.compound_rmdir_req;
+ this_req = array[i].compound_req_v2_u.compound_rmdir_req;
- state->resolve.type = RESOLVE_MUST;
- memcpy (state->resolve.pargfid, this_req.pargfid, 16);
- state->resolve.bname = gf_strdup
- (this_req.bname);
- break;
+ state->resolve.type = RESOLVE_MUST;
+ memcpy(state->resolve.pargfid, this_req.pargfid, 16);
+ state->resolve.bname = gf_strdup(this_req.bname);
+ break;
}
- case GF_FOP_SYMLINK:
- {
- gfx_symlink_req this_req = { {0,} };
+ case GF_FOP_SYMLINK: {
+ gfx_symlink_req this_req = {{
+ 0,
+ }};
- this_req = array[i].compound_req_v2_u.compound_symlink_req;
+ this_req = array[i].compound_req_v2_u.compound_symlink_req;
- state->resolve.type = RESOLVE_NOT;
- memcpy (state->resolve.pargfid, this_req.pargfid, 16);
- state->resolve.bname = gf_strdup
- (this_req.bname);
- break;
+ state->resolve.type = RESOLVE_NOT;
+ memcpy(state->resolve.pargfid, this_req.pargfid, 16);
+ state->resolve.bname = gf_strdup(this_req.bname);
+ break;
}
- case GF_FOP_RENAME:
- {
- gfx_rename_req this_req = { {0,} };
+ case GF_FOP_RENAME: {
+ gfx_rename_req this_req = {{
+ 0,
+ }};
- this_req = array[i].compound_req_v2_u.compound_rename_req;
+ this_req = array[i].compound_req_v2_u.compound_rename_req;
- state->resolve.type = RESOLVE_MUST;
- state->resolve.bname = gf_strdup
- (this_req.oldbname);
- memcpy (state->resolve.pargfid, this_req.oldgfid, 16);
+ state->resolve.type = RESOLVE_MUST;
+ state->resolve.bname = gf_strdup(this_req.oldbname);
+ memcpy(state->resolve.pargfid, this_req.oldgfid, 16);
- state->resolve2.type = RESOLVE_MAY;
- state->resolve2.bname = gf_strdup
- (this_req.newbname);
- memcpy (state->resolve2.pargfid, this_req.newgfid, 16);
- break;
+ state->resolve2.type = RESOLVE_MAY;
+ state->resolve2.bname = gf_strdup(this_req.newbname);
+ memcpy(state->resolve2.pargfid, this_req.newgfid, 16);
+ break;
}
- case GF_FOP_LINK:
- {
- gfx_link_req this_req = { {0,} };
+ case GF_FOP_LINK: {
+ gfx_link_req this_req = {{
+ 0,
+ }};
- this_req = array[i].compound_req_v2_u.compound_link_req;
+ this_req = array[i].compound_req_v2_u.compound_link_req;
- state->resolve.type = RESOLVE_MUST;
- memcpy (state->resolve.gfid, this_req.oldgfid, 16);
+ state->resolve.type = RESOLVE_MUST;
+ memcpy(state->resolve.gfid, this_req.oldgfid, 16);
- state->resolve2.type = RESOLVE_NOT;
- state->resolve2.bname = gf_strdup
- (this_req.newbname);
- memcpy (state->resolve2.pargfid, this_req.newgfid, 16);
- break;
+ state->resolve2.type = RESOLVE_NOT;
+ state->resolve2.bname = gf_strdup(this_req.newbname);
+ memcpy(state->resolve2.pargfid, this_req.newgfid, 16);
+ break;
}
- case GF_FOP_TRUNCATE:
- {
- gfx_truncate_req this_req = { {0,} };
+ case GF_FOP_TRUNCATE: {
+ gfx_truncate_req this_req = {{
+ 0,
+ }};
- this_req = array[i].compound_req_v2_u.compound_truncate_req;
+ this_req = array[i].compound_req_v2_u.compound_truncate_req;
- state->resolve.type = RESOLVE_MUST;
- memcpy (state->resolve.gfid,
- this_req.gfid, 16);
- break;
+ state->resolve.type = RESOLVE_MUST;
+ memcpy(state->resolve.gfid, this_req.gfid, 16);
+ break;
}
- case GF_FOP_OPEN:
- {
- gfx_open_req this_req = { {0,} };
+ case GF_FOP_OPEN: {
+ gfx_open_req this_req = {{
+ 0,
+ }};
- this_req = array[i].compound_req_v2_u.compound_open_req;
+ this_req = array[i].compound_req_v2_u.compound_open_req;
- state->resolve.type = RESOLVE_MUST;
- memcpy (state->resolve.gfid,
- this_req.gfid, 16);
- break;
+ state->resolve.type = RESOLVE_MUST;
+ memcpy(state->resolve.gfid, this_req.gfid, 16);
+ break;
}
- case GF_FOP_READ:
- {
- gfx_read_req this_req = { {0,} };
+ case GF_FOP_READ: {
+ gfx_read_req this_req = {{
+ 0,
+ }};
- this_req = array[i].compound_req_v2_u.compound_read_req;
+ this_req = array[i].compound_req_v2_u.compound_read_req;
- state->resolve.type = RESOLVE_MUST;
- memcpy (state->resolve.gfid,
- this_req.gfid, 16);
- break;
+ state->resolve.type = RESOLVE_MUST;
+ memcpy(state->resolve.gfid, this_req.gfid, 16);
+ break;
}
- case GF_FOP_WRITE:
- {
- gfx_write_req this_req = { {0,} };
+ case GF_FOP_WRITE: {
+ gfx_write_req this_req = {{
+ 0,
+ }};
- this_req = array[i].compound_req_v2_u.compound_write_req;
+ this_req = array[i].compound_req_v2_u.compound_write_req;
- state->resolve.type = RESOLVE_MUST;
- memcpy (state->resolve.gfid,
- this_req.gfid, 16);
- break;
+ state->resolve.type = RESOLVE_MUST;
+ memcpy(state->resolve.gfid, this_req.gfid, 16);
+ break;
}
- case GF_FOP_STATFS:
- {
- gfx_statfs_req this_req = { {0,} };
+ case GF_FOP_STATFS: {
+ gfx_statfs_req this_req = {{
+ 0,
+ }};
- this_req = array[i].compound_req_v2_u.compound_statfs_req;
+ this_req = array[i].compound_req_v2_u.compound_statfs_req;
- state->resolve.type = RESOLVE_MUST;
- memcpy (state->resolve.gfid,
- this_req.gfid, 16);
- break;
+ state->resolve.type = RESOLVE_MUST;
+ memcpy(state->resolve.gfid, this_req.gfid, 16);
+ break;
}
- case GF_FOP_FLUSH:
- {
- gfx_flush_req this_req = { {0,} };
+ case GF_FOP_FLUSH: {
+ gfx_flush_req this_req = {{
+ 0,
+ }};
- this_req = array[i].compound_req_v2_u.compound_flush_req;
+ this_req = array[i].compound_req_v2_u.compound_flush_req;
- state->resolve.type = RESOLVE_MUST;
- memcpy (state->resolve.gfid,
- this_req.gfid, 16);
- state->resolve.fd_no = this_req.fd;
- break;
+ state->resolve.type = RESOLVE_MUST;
+ memcpy(state->resolve.gfid, this_req.gfid, 16);
+ state->resolve.fd_no = this_req.fd;
+ break;
}
- case GF_FOP_FSYNC:
- {
- gfx_fsync_req this_req = { {0,} };
+ case GF_FOP_FSYNC: {
+ gfx_fsync_req this_req = {{
+ 0,
+ }};
- this_req = array[i].compound_req_v2_u.compound_fsync_req;
+ this_req = array[i].compound_req_v2_u.compound_fsync_req;
- state->resolve.type = RESOLVE_MUST;
- memcpy (state->resolve.gfid,
- this_req.gfid, 16);
- state->resolve.fd_no = this_req.fd;
- break;
+ state->resolve.type = RESOLVE_MUST;
+ memcpy(state->resolve.gfid, this_req.gfid, 16);
+ state->resolve.fd_no = this_req.fd;
+ break;
}
- case GF_FOP_SETXATTR:
- {
- gfx_setxattr_req this_req = { {0,} };
+ case GF_FOP_SETXATTR: {
+ gfx_setxattr_req this_req = {{
+ 0,
+ }};
- this_req = array[i].compound_req_v2_u.compound_setxattr_req;
+ this_req = array[i].compound_req_v2_u.compound_setxattr_req;
- state->resolve.type = RESOLVE_MUST;
- memcpy (state->resolve.gfid,
- this_req.gfid, 16);
- break;
+ state->resolve.type = RESOLVE_MUST;
+ memcpy(state->resolve.gfid, this_req.gfid, 16);
+ break;
}
- case GF_FOP_GETXATTR:
- {
- gfx_getxattr_req this_req = { {0,} };
+ case GF_FOP_GETXATTR: {
+ gfx_getxattr_req this_req = {{
+ 0,
+ }};
- this_req = array[i].compound_req_v2_u.compound_getxattr_req;
+ this_req = array[i].compound_req_v2_u.compound_getxattr_req;
- state->resolve.type = RESOLVE_MUST;
- memcpy (state->resolve.gfid,
- this_req.gfid, 16);
- break;
+ state->resolve.type = RESOLVE_MUST;
+ memcpy(state->resolve.gfid, this_req.gfid, 16);
+ break;
}
- case GF_FOP_REMOVEXATTR:
- {
- gfx_removexattr_req this_req = { {0,} };
+ case GF_FOP_REMOVEXATTR: {
+ gfx_removexattr_req this_req = {{
+ 0,
+ }};
- this_req = array[i].compound_req_v2_u.compound_removexattr_req;
+ this_req = array[i].compound_req_v2_u.compound_removexattr_req;
- state->resolve.type = RESOLVE_MUST;
- memcpy (state->resolve.gfid,
- this_req.gfid, 16);
- break;
+ state->resolve.type = RESOLVE_MUST;
+ memcpy(state->resolve.gfid, this_req.gfid, 16);
+ break;
}
- case GF_FOP_OPENDIR:
- {
- gfx_opendir_req this_req = { {0,} };
+ case GF_FOP_OPENDIR: {
+ gfx_opendir_req this_req = {{
+ 0,
+ }};
- this_req = array[i].compound_req_v2_u.compound_opendir_req;
+ this_req = array[i].compound_req_v2_u.compound_opendir_req;
- state->resolve.type = RESOLVE_MUST;
- memcpy (state->resolve.gfid,
- this_req.gfid, 16);
- break;
+ state->resolve.type = RESOLVE_MUST;
+ memcpy(state->resolve.gfid, this_req.gfid, 16);
+ break;
}
- case GF_FOP_FSYNCDIR:
- {
- gfx_fsyncdir_req this_req = { {0,} };
+ case GF_FOP_FSYNCDIR: {
+ gfx_fsyncdir_req this_req = {{
+ 0,
+ }};
- this_req = array[i].compound_req_v2_u.compound_fsyncdir_req;
+ this_req = array[i].compound_req_v2_u.compound_fsyncdir_req;
- state->resolve.type = RESOLVE_MUST;
- memcpy (state->resolve.gfid,
- this_req.gfid, 16);
- state->resolve.fd_no = this_req.fd;
- break;
+ state->resolve.type = RESOLVE_MUST;
+ memcpy(state->resolve.gfid, this_req.gfid, 16);
+ state->resolve.fd_no = this_req.fd;
+ break;
}
- case GF_FOP_ACCESS:
- {
- gfx_access_req this_req = { {0,} };
+ case GF_FOP_ACCESS: {
+ gfx_access_req this_req = {{
+ 0,
+ }};
- this_req = array[i].compound_req_v2_u.compound_access_req;
+ this_req = array[i].compound_req_v2_u.compound_access_req;
- state->resolve.type = RESOLVE_MUST;
- memcpy (state->resolve.gfid,
- this_req.gfid, 16);
- break;
+ state->resolve.type = RESOLVE_MUST;
+ memcpy(state->resolve.gfid, this_req.gfid, 16);
+ break;
}
- case GF_FOP_CREATE:
- {
- gfx_create_req this_req = { {0,} };
+ case GF_FOP_CREATE: {
+ gfx_create_req this_req = {{
+ 0,
+ }};
- this_req = array[i].compound_req_v2_u.compound_create_req;
+ this_req = array[i].compound_req_v2_u.compound_create_req;
- state->flags = gf_flags_to_flags (this_req.flags);
- if (state->flags & O_EXCL) {
- state->resolve.type = RESOLVE_NOT;
- } else {
- state->resolve.type = RESOLVE_DONTCARE;
- }
+ state->flags = gf_flags_to_flags(this_req.flags);
+ if (state->flags & O_EXCL) {
+ state->resolve.type = RESOLVE_NOT;
+ } else {
+ state->resolve.type = RESOLVE_DONTCARE;
+ }
- memcpy (state->resolve.pargfid, this_req.pargfid, 16);
- state->resolve.bname = gf_strdup
- (this_req.bname);
- break;
+ memcpy(state->resolve.pargfid, this_req.pargfid, 16);
+ state->resolve.bname = gf_strdup(this_req.bname);
+ break;
}
- case GF_FOP_FTRUNCATE:
- {
- gfx_ftruncate_req this_req = { {0,} };
+ case GF_FOP_FTRUNCATE: {
+ gfx_ftruncate_req this_req = {{
+ 0,
+ }};
- this_req = array[i].compound_req_v2_u.compound_ftruncate_req;
+ this_req = array[i].compound_req_v2_u.compound_ftruncate_req;
- state->resolve.type = RESOLVE_MUST;
- memcpy (state->resolve.gfid,
- this_req.gfid, 16);
- state->resolve.fd_no = this_req.fd;
- break;
+ state->resolve.type = RESOLVE_MUST;
+ memcpy(state->resolve.gfid, this_req.gfid, 16);
+ state->resolve.fd_no = this_req.fd;
+ break;
}
- case GF_FOP_FSTAT:
- {
- gfx_fstat_req this_req = { {0,} };
+ case GF_FOP_FSTAT: {
+ gfx_fstat_req this_req = {{
+ 0,
+ }};
- this_req = array[i].compound_req_v2_u.compound_fstat_req;
+ this_req = array[i].compound_req_v2_u.compound_fstat_req;
- state->resolve.type = RESOLVE_MUST;
- memcpy (state->resolve.gfid,
- this_req.gfid, 16);
- state->resolve.fd_no = this_req.fd;
- break;
+ state->resolve.type = RESOLVE_MUST;
+ memcpy(state->resolve.gfid, this_req.gfid, 16);
+ state->resolve.fd_no = this_req.fd;
+ break;
}
- case GF_FOP_LK:
- {
- gfx_lk_req this_req = { {0,} };
+ case GF_FOP_LK: {
+ gfx_lk_req this_req = {{
+ 0,
+ }};
- this_req = array[i].compound_req_v2_u.compound_lk_req;
+ this_req = array[i].compound_req_v2_u.compound_lk_req;
- memcpy (state->resolve.gfid,
- this_req.gfid, 16);
- state->resolve.fd_no = this_req.fd;
- break;
+ memcpy(state->resolve.gfid, this_req.gfid, 16);
+ state->resolve.fd_no = this_req.fd;
+ break;
}
- case GF_FOP_LOOKUP:
- {
- gfx_lookup_req this_req = { {0,} };
+ case GF_FOP_LOOKUP: {
+ gfx_lookup_req this_req = {{
+ 0,
+ }};
- this_req = array[i].compound_req_v2_u.compound_lookup_req;
- state->resolve.type = RESOLVE_DONTCARE;
+ this_req = array[i].compound_req_v2_u.compound_lookup_req;
+ state->resolve.type = RESOLVE_DONTCARE;
- if (this_req.bname && strcmp (this_req.bname, "")) {
- memcpy (state->resolve.pargfid, this_req.pargfid, 16);
- state->resolve.bname = gf_strdup
- (this_req.bname);
- } else {
- memcpy (state->resolve.gfid, this_req.gfid, 16);
- }
- break;
+ if (this_req.bname && strcmp(this_req.bname, "")) {
+ memcpy(state->resolve.pargfid, this_req.pargfid, 16);
+ state->resolve.bname = gf_strdup(this_req.bname);
+ } else {
+ memcpy(state->resolve.gfid, this_req.gfid, 16);
+ }
+ break;
}
- case GF_FOP_READDIR:
- {
- gfx_readdir_req this_req = { {0,} };
+ case GF_FOP_READDIR: {
+ gfx_readdir_req this_req = {{
+ 0,
+ }};
- this_req = array[i].compound_req_v2_u.compound_readdir_req;
+ this_req = array[i].compound_req_v2_u.compound_readdir_req;
- state->resolve.type = RESOLVE_MUST;
- memcpy (state->resolve.gfid,
- this_req.gfid, 16);
- state->resolve.fd_no = this_req.fd;
- break;
+ state->resolve.type = RESOLVE_MUST;
+ memcpy(state->resolve.gfid, this_req.gfid, 16);
+ state->resolve.fd_no = this_req.fd;
+ break;
}
- case GF_FOP_INODELK:
- {
- gfx_inodelk_req this_req = { {0,} };
+ case GF_FOP_INODELK: {
+ gfx_inodelk_req this_req = {{
+ 0,
+ }};
- this_req = array[i].compound_req_v2_u.compound_inodelk_req;
+ this_req = array[i].compound_req_v2_u.compound_inodelk_req;
- state->resolve.type = RESOLVE_EXACT;
- memcpy (state->resolve.gfid,
- this_req.gfid, 16);
- break;
+ state->resolve.type = RESOLVE_EXACT;
+ memcpy(state->resolve.gfid, this_req.gfid, 16);
+ break;
}
- case GF_FOP_FINODELK:
- {
- gfx_finodelk_req this_req = { {0,} };
-
- this_req = array[i].compound_req_v2_u.compound_finodelk_req;
+ case GF_FOP_FINODELK: {
+ gfx_finodelk_req this_req = {{
+ 0,
+ }};
+
+ this_req = array[i].compound_req_v2_u.compound_finodelk_req;
- state->resolve.type = RESOLVE_EXACT;
- memcpy (state->resolve.gfid,
- this_req.gfid, 16);
- state->resolve.fd_no = this_req.fd;
- break;
+ state->resolve.type = RESOLVE_EXACT;
+ memcpy(state->resolve.gfid, this_req.gfid, 16);
+ state->resolve.fd_no = this_req.fd;
+ break;
}
- case GF_FOP_ENTRYLK:
- {
- gfx_entrylk_req this_req = { {0,} };
-
- this_req = array[i].compound_req_v2_u.compound_entrylk_req;
+ case GF_FOP_ENTRYLK: {
+ gfx_entrylk_req this_req = {{
+ 0,
+ }};
+
+ this_req = array[i].compound_req_v2_u.compound_entrylk_req;
- state->resolve.type = RESOLVE_EXACT;
- memcpy (state->resolve.gfid,
- this_req.gfid, 16);
- break;
+ state->resolve.type = RESOLVE_EXACT;
+ memcpy(state->resolve.gfid, this_req.gfid, 16);
+ break;
}
- case GF_FOP_FENTRYLK:
- {
- gfx_fentrylk_req this_req = { {0,} };
+ case GF_FOP_FENTRYLK: {
+ gfx_fentrylk_req this_req = {{
+ 0,
+ }};
- this_req = array[i].compound_req_v2_u.compound_fentrylk_req;
+ this_req = array[i].compound_req_v2_u.compound_fentrylk_req;
- state->resolve.type = RESOLVE_EXACT;
- memcpy (state->resolve.gfid,
- this_req.gfid, 16);
- state->resolve.fd_no = this_req.fd;
- break;
+ state->resolve.type = RESOLVE_EXACT;
+ memcpy(state->resolve.gfid, this_req.gfid, 16);
+ state->resolve.fd_no = this_req.fd;
+ break;
}
- case GF_FOP_XATTROP:
- {
- gfx_xattrop_req this_req = { {0,} };
+ case GF_FOP_XATTROP: {
+ gfx_xattrop_req this_req = {{
+ 0,
+ }};
- this_req = array[i].compound_req_v2_u.compound_xattrop_req;
+ this_req = array[i].compound_req_v2_u.compound_xattrop_req;
- state->resolve.type = RESOLVE_MUST;
- memcpy (state->resolve.gfid,
- this_req.gfid, 16);
- break;
+ state->resolve.type = RESOLVE_MUST;
+ memcpy(state->resolve.gfid, this_req.gfid, 16);
+ break;
}
- case GF_FOP_FXATTROP:
- {
- gfx_fxattrop_req this_req = { {0,} };
+ case GF_FOP_FXATTROP: {
+ gfx_fxattrop_req this_req = {{
+ 0,
+ }};
- this_req = array[i].compound_req_v2_u.compound_fxattrop_req;
+ this_req = array[i].compound_req_v2_u.compound_fxattrop_req;
- state->resolve.type = RESOLVE_MUST;
- memcpy (state->resolve.gfid,
- this_req.gfid, 16);
- state->resolve.fd_no = this_req.fd;
- break;
+ state->resolve.type = RESOLVE_MUST;
+ memcpy(state->resolve.gfid, this_req.gfid, 16);
+ state->resolve.fd_no = this_req.fd;
+ break;
}
- case GF_FOP_FGETXATTR:
- {
- gfx_fgetxattr_req this_req = { {0,} };
+ case GF_FOP_FGETXATTR: {
+ gfx_fgetxattr_req this_req = {{
+ 0,
+ }};
- this_req = array[i].compound_req_v2_u.compound_fgetxattr_req;
+ this_req = array[i].compound_req_v2_u.compound_fgetxattr_req;
- state->resolve.type = RESOLVE_MUST;
- memcpy (state->resolve.gfid,
- this_req.gfid, 16);
- state->resolve.fd_no = this_req.fd;
- break;
+ state->resolve.type = RESOLVE_MUST;
+ memcpy(state->resolve.gfid, this_req.gfid, 16);
+ state->resolve.fd_no = this_req.fd;
+ break;
}
- case GF_FOP_FSETXATTR:
- {
- gfx_fsetxattr_req this_req = { {0,} };
+ case GF_FOP_FSETXATTR: {
+ gfx_fsetxattr_req this_req = {{
+ 0,
+ }};
- this_req = array[i].compound_req_v2_u.compound_fsetxattr_req;
+ this_req = array[i].compound_req_v2_u.compound_fsetxattr_req;
- state->resolve.type = RESOLVE_MUST;
- memcpy (state->resolve.gfid,
- this_req.gfid, 16);
- state->resolve.fd_no = this_req.fd;
- break;
+ state->resolve.type = RESOLVE_MUST;
+ memcpy(state->resolve.gfid, this_req.gfid, 16);
+ state->resolve.fd_no = this_req.fd;
+ break;
}
- case GF_FOP_RCHECKSUM:
- {
- gfx_rchecksum_req this_req = { {0,},};
+ case GF_FOP_RCHECKSUM: {
+ gfx_rchecksum_req this_req = {
+ {
+ 0,
+ },
+ };
- this_req = array[i].compound_req_v2_u.compound_rchecksum_req;
+ this_req = array[i].compound_req_v2_u.compound_rchecksum_req;
- state->resolve.type = RESOLVE_MAY;
- state->resolve.fd_no = this_req.fd;
- break;
+ state->resolve.type = RESOLVE_MAY;
+ state->resolve.fd_no = this_req.fd;
+ break;
}
- case GF_FOP_SETATTR:
- {
- gfx_setattr_req this_req = { {0,} };
+ case GF_FOP_SETATTR: {
+ gfx_setattr_req this_req = {{
+ 0,
+ }};
- this_req = array[i].compound_req_v2_u.compound_setattr_req;
+ this_req = array[i].compound_req_v2_u.compound_setattr_req;
- state->resolve.type = RESOLVE_MUST;
- memcpy (state->resolve.gfid,
- this_req.gfid, 16);
- break;
+ state->resolve.type = RESOLVE_MUST;
+ memcpy(state->resolve.gfid, this_req.gfid, 16);
+ break;
}
- case GF_FOP_FSETATTR:
- {
- gfx_fsetattr_req this_req = { {0,} };
+ case GF_FOP_FSETATTR: {
+ gfx_fsetattr_req this_req = {{
+ 0,
+ }};
- this_req = array[i].compound_req_v2_u.compound_fsetattr_req;
+ this_req = array[i].compound_req_v2_u.compound_fsetattr_req;
- state->resolve.type = RESOLVE_MUST;
- state->resolve.fd_no = this_req.fd;
- break;
+ state->resolve.type = RESOLVE_MUST;
+ state->resolve.fd_no = this_req.fd;
+ break;
}
- case GF_FOP_READDIRP:
- {
- gfx_readdirp_req this_req = { {0,} };
+ case GF_FOP_READDIRP: {
+ gfx_readdirp_req this_req = {{
+ 0,
+ }};
- this_req = array[i].compound_req_v2_u.compound_readdirp_req;
+ this_req = array[i].compound_req_v2_u.compound_readdirp_req;
- state->resolve.type = RESOLVE_MUST;
- memcpy (state->resolve.gfid,
- this_req.gfid, 16);
- state->resolve.fd_no = this_req.fd;
- break;
+ state->resolve.type = RESOLVE_MUST;
+ memcpy(state->resolve.gfid, this_req.gfid, 16);
+ state->resolve.fd_no = this_req.fd;
+ break;
}
- case GF_FOP_FREMOVEXATTR:
- {
- gfx_fremovexattr_req this_req = { {0,} };
+ case GF_FOP_FREMOVEXATTR: {
+ gfx_fremovexattr_req this_req = {{
+ 0,
+ }};
- this_req = array[i].compound_req_v2_u.compound_fremovexattr_req;
+ this_req = array[i].compound_req_v2_u.compound_fremovexattr_req;
- state->resolve.type = RESOLVE_MUST;
- memcpy (state->resolve.gfid,
- this_req.gfid, 16);
- state->resolve.fd_no = this_req.fd;
- break;
+ state->resolve.type = RESOLVE_MUST;
+ memcpy(state->resolve.gfid, this_req.gfid, 16);
+ state->resolve.fd_no = this_req.fd;
+ break;
}
- case GF_FOP_FALLOCATE:
- {
- gfx_fallocate_req this_req = { {0,} };
+ case GF_FOP_FALLOCATE: {
+ gfx_fallocate_req this_req = {{
+ 0,
+ }};
- this_req = array[i].compound_req_v2_u.compound_fallocate_req;
+ this_req = array[i].compound_req_v2_u.compound_fallocate_req;
- state->resolve.type = RESOLVE_MUST;
- memcpy (state->resolve.gfid,
- this_req.gfid, 16);
- state->resolve.fd_no = this_req.fd;
- break;
+ state->resolve.type = RESOLVE_MUST;
+ memcpy(state->resolve.gfid, this_req.gfid, 16);
+ state->resolve.fd_no = this_req.fd;
+ break;
}
- case GF_FOP_DISCARD:
- {
- gfx_discard_req this_req = { {0,} };
+ case GF_FOP_DISCARD: {
+ gfx_discard_req this_req = {{
+ 0,
+ }};
- this_req = array[i].compound_req_v2_u.compound_discard_req;
+ this_req = array[i].compound_req_v2_u.compound_discard_req;
- state->resolve.type = RESOLVE_MUST;
- memcpy (state->resolve.gfid,
- this_req.gfid, 16);
- state->resolve.fd_no = this_req.fd;
- break;
+ state->resolve.type = RESOLVE_MUST;
+ memcpy(state->resolve.gfid, this_req.gfid, 16);
+ state->resolve.fd_no = this_req.fd;
+ break;
}
- case GF_FOP_ZEROFILL:
- {
- gfx_zerofill_req this_req = { {0,} };
+ case GF_FOP_ZEROFILL: {
+ gfx_zerofill_req this_req = {{
+ 0,
+ }};
- this_req = array[i].compound_req_v2_u.compound_zerofill_req;
+ this_req = array[i].compound_req_v2_u.compound_zerofill_req;
- state->resolve.type = RESOLVE_MUST;
- memcpy (state->resolve.gfid,
- this_req.gfid, 16);
- state->resolve.fd_no = this_req.fd;
- break;
+ state->resolve.type = RESOLVE_MUST;
+ memcpy(state->resolve.gfid, this_req.gfid, 16);
+ state->resolve.fd_no = this_req.fd;
+ break;
}
- case GF_FOP_SEEK:
- {
- gfx_seek_req this_req = { {0,} };
+ case GF_FOP_SEEK: {
+ gfx_seek_req this_req = {{
+ 0,
+ }};
- this_req = array[i].compound_req_v2_u.compound_seek_req;
+ this_req = array[i].compound_req_v2_u.compound_seek_req;
- state->resolve.type = RESOLVE_MUST;
- memcpy (state->resolve.gfid,
- this_req.gfid, 16);
- state->resolve.fd_no = this_req.fd;
- break;
+ state->resolve.type = RESOLVE_MUST;
+ memcpy(state->resolve.gfid, this_req.gfid, 16);
+ state->resolve.fd_no = this_req.fd;
+ break;
}
- case GF_FOP_LEASE:
- {
- gfx_lease_req this_req = { {0,} };
+ case GF_FOP_LEASE: {
+ gfx_lease_req this_req = {{
+ 0,
+ }};
- this_req = array[i].compound_req_v2_u.compound_lease_req;
+ this_req = array[i].compound_req_v2_u.compound_lease_req;
- state->resolve.type = RESOLVE_MUST;
- memcpy (state->resolve.gfid, this_req.gfid, 16);
- break;
+ state->resolve.type = RESOLVE_MUST;
+ memcpy(state->resolve.gfid, this_req.gfid, 16);
+ break;
}
default:
- return ENOTSUP;
- }
- return 0;
+ return ENOTSUP;
+ }
+ return 0;
}
void
-server_compound_rsp_cleanup_v2 (gfx_compound_rsp *rsp, compound_args_cbk_t *args)
+server_compound_rsp_cleanup_v2(gfx_compound_rsp *rsp, compound_args_cbk_t *args)
{
- int i, len = 0;
- compound_rsp_v2 *this_rsp = NULL;
-
- if (!rsp->compound_rsp_array.compound_rsp_array_val)
- return;
-
- len = rsp->compound_rsp_array.compound_rsp_array_len;
-
- for (i = 0; i < len; i++) {
- this_rsp = &rsp->compound_rsp_array.compound_rsp_array_val[i];
- switch (args->enum_list[i]) {
- case GF_FOP_STAT:
- SERVER4_FOP_RSP_CLEANUP (rsp, stat, i, common_iatt);
- break;
- case GF_FOP_MKNOD:
- SERVER4_FOP_RSP_CLEANUP (rsp, mknod, i, common_3iatt);
- break;
- case GF_FOP_MKDIR:
- SERVER4_FOP_RSP_CLEANUP (rsp, mkdir, i, common_3iatt);
- break;
- case GF_FOP_UNLINK:
- SERVER4_FOP_RSP_CLEANUP (rsp, unlink, i, common_2iatt);
- break;
- case GF_FOP_RMDIR:
- SERVER4_FOP_RSP_CLEANUP (rsp, rmdir, i, common_2iatt);
- break;
- case GF_FOP_SYMLINK:
- SERVER4_FOP_RSP_CLEANUP (rsp, symlink, i, common_3iatt);
- break;
- case GF_FOP_RENAME:
- SERVER4_FOP_RSP_CLEANUP (rsp, rename, i, rename);
- break;
- case GF_FOP_LINK:
- SERVER4_FOP_RSP_CLEANUP (rsp, link, i, common_3iatt);
- break;
- case GF_FOP_TRUNCATE:
- SERVER4_FOP_RSP_CLEANUP (rsp, truncate, i, common_2iatt);
- break;
- case GF_FOP_OPEN:
- SERVER4_FOP_RSP_CLEANUP (rsp, open, i, open);
- break;
- case GF_FOP_READ:
- SERVER4_FOP_RSP_CLEANUP (rsp, read, i, read);
- break;
- case GF_FOP_WRITE:
- SERVER4_FOP_RSP_CLEANUP (rsp, write, i, common_2iatt);
- break;
- case GF_FOP_STATFS:
- SERVER4_FOP_RSP_CLEANUP (rsp, statfs, i, statfs);
- break;
- case GF_FOP_FSYNC:
- SERVER4_FOP_RSP_CLEANUP (rsp, fsync, i, common_2iatt);
- break;
- case GF_FOP_OPENDIR:
- SERVER4_FOP_RSP_CLEANUP (rsp, opendir, i, open);
- break;
- case GF_FOP_CREATE:
- SERVER4_FOP_RSP_CLEANUP (rsp, create, i, create);
- break;
- case GF_FOP_FTRUNCATE:
- SERVER4_FOP_RSP_CLEANUP (rsp, ftruncate, i, common_2iatt);
- break;
- case GF_FOP_FSTAT:
- SERVER4_FOP_RSP_CLEANUP (rsp, fstat, i, common_iatt);
- break;
- case GF_FOP_LK:
- SERVER4_FOP_RSP_CLEANUP (rsp, lk, i, lk);
- break;
- case GF_FOP_LOOKUP:
- SERVER4_FOP_RSP_CLEANUP (rsp, lookup, i, common_2iatt);
- break;
- case GF_FOP_SETATTR:
- SERVER4_FOP_RSP_CLEANUP (rsp, setattr, i, common_2iatt);
- break;
- case GF_FOP_FSETATTR:
- SERVER4_FOP_RSP_CLEANUP (rsp, fsetattr, i, common_2iatt);
- break;
- case GF_FOP_FALLOCATE:
- SERVER4_FOP_RSP_CLEANUP (rsp, fallocate, i, common_2iatt);
- break;
- case GF_FOP_DISCARD:
- SERVER4_FOP_RSP_CLEANUP (rsp, discard, i, common_2iatt);
- break;
- case GF_FOP_ZEROFILL:
- SERVER4_FOP_RSP_CLEANUP (rsp, zerofill, i, common_2iatt);
- break;
- case GF_FOP_SEEK:
- SERVER4_FOP_RSP_CLEANUP (rsp, seek, i, seek);
- break;
- case GF_FOP_LEASE:
- SERVER4_FOP_RSP_CLEANUP (rsp, lease, i, lease);
- break;
- case GF_FOP_READLINK:
- SERVER4_FOP_RSP_CLEANUP (rsp, readlink, i, readlink);
- break;
- case GF_FOP_RCHECKSUM:
- SERVER4_FOP_RSP_CLEANUP (rsp, rchecksum, i, rchecksum);
- break;
- /* fops that use gfx_common_rsp */
- case GF_FOP_IPC:
- SERVER4_COMMON_RSP_CLEANUP (rsp, ipc, i);
- break;
- case GF_FOP_FLUSH:
- SERVER4_COMMON_RSP_CLEANUP (rsp, flush, i);
- break;
- case GF_FOP_SETXATTR:
- SERVER4_COMMON_RSP_CLEANUP (rsp, setxattr, i);
- break;
- case GF_FOP_REMOVEXATTR:
- SERVER4_COMMON_RSP_CLEANUP (rsp, removexattr, i);
- break;
- case GF_FOP_FSETXATTR:
- SERVER4_COMMON_RSP_CLEANUP (rsp, fsetxattr, i);
- break;
- case GF_FOP_FREMOVEXATTR:
- SERVER4_COMMON_RSP_CLEANUP (rsp, fremovexattr, i);
- break;
- case GF_FOP_FSYNCDIR:
- SERVER4_COMMON_RSP_CLEANUP (rsp, fsyncdir, i);
- break;
- case GF_FOP_ACCESS:
- SERVER4_COMMON_RSP_CLEANUP (rsp, access, i);
- break;
- case GF_FOP_INODELK:
- SERVER4_COMMON_RSP_CLEANUP (rsp, inodelk, i);
- break;
- case GF_FOP_FINODELK:
- SERVER4_COMMON_RSP_CLEANUP (rsp, finodelk, i);
- break;
- case GF_FOP_ENTRYLK:
- SERVER4_COMMON_RSP_CLEANUP (rsp, entrylk, i);
- break;
- case GF_FOP_FENTRYLK:
- SERVER4_COMMON_RSP_CLEANUP (rsp, fentrylk, i);
- break;
- /* fops that need extra cleanup */
- case GF_FOP_XATTROP:
- {
- gfx_common_dict_rsp *tmp_rsp = &CPD4_RSP_FIELD(this_rsp,
- xattrop);
- SERVER4_FOP_RSP_CLEANUP (rsp, xattrop, i, common_dict);
- GF_FREE (tmp_rsp->dict.pairs.pairs_val);
- break;
- }
- case GF_FOP_FXATTROP:
- {
- gfx_common_dict_rsp *tmp_rsp = &CPD4_RSP_FIELD(this_rsp,
- fxattrop);
- SERVER4_FOP_RSP_CLEANUP (rsp, fxattrop, i, common_dict);
- GF_FREE (tmp_rsp->dict.pairs.pairs_val);
- break;
- }
- case GF_FOP_READDIR:
- {
- gfx_readdir_rsp *tmp_rsp = &CPD4_RSP_FIELD(this_rsp,
- readdir);
- SERVER4_FOP_RSP_CLEANUP (rsp, readdir, i, readdir);
- readdir_rsp_cleanup_v2 (tmp_rsp);
- break;
- }
- case GF_FOP_READDIRP:
- {
- gfx_readdirp_rsp *tmp_rsp = &CPD4_RSP_FIELD(this_rsp,
- readdirp);
- SERVER4_FOP_RSP_CLEANUP (rsp, readdirp, i, readdirp);
- readdirp_rsp_cleanup_v2 (tmp_rsp);
- break;
- }
- case GF_FOP_GETXATTR:
- {
- gfx_common_dict_rsp *tmp_rsp = &CPD4_RSP_FIELD(this_rsp,
- getxattr);
- SERVER4_FOP_RSP_CLEANUP (rsp, getxattr, i, common_dict);
- GF_FREE (tmp_rsp->dict.pairs.pairs_val);
- break;
- }
- case GF_FOP_FGETXATTR:
- {
- gfx_common_dict_rsp *tmp_rsp = &CPD4_RSP_FIELD(this_rsp,
- fgetxattr);
- SERVER4_FOP_RSP_CLEANUP (rsp, fgetxattr, i, common_dict);
- GF_FREE (tmp_rsp->dict.pairs.pairs_val);
- break;
- }
- default:
- break;
- }
- }
- GF_FREE (rsp->compound_rsp_array.compound_rsp_array_val);
+ int i, len = 0;
+ compound_rsp_v2 *this_rsp = NULL;
+
+ if (!rsp->compound_rsp_array.compound_rsp_array_val)
return;
+
+ len = rsp->compound_rsp_array.compound_rsp_array_len;
+
+ for (i = 0; i < len; i++) {
+ this_rsp = &rsp->compound_rsp_array.compound_rsp_array_val[i];
+ switch (args->enum_list[i]) {
+ case GF_FOP_STAT:
+ SERVER4_FOP_RSP_CLEANUP(rsp, stat, i, common_iatt);
+ break;
+ case GF_FOP_MKNOD:
+ SERVER4_FOP_RSP_CLEANUP(rsp, mknod, i, common_3iatt);
+ break;
+ case GF_FOP_MKDIR:
+ SERVER4_FOP_RSP_CLEANUP(rsp, mkdir, i, common_3iatt);
+ break;
+ case GF_FOP_UNLINK:
+ SERVER4_FOP_RSP_CLEANUP(rsp, unlink, i, common_2iatt);
+ break;
+ case GF_FOP_RMDIR:
+ SERVER4_FOP_RSP_CLEANUP(rsp, rmdir, i, common_2iatt);
+ break;
+ case GF_FOP_SYMLINK:
+ SERVER4_FOP_RSP_CLEANUP(rsp, symlink, i, common_3iatt);
+ break;
+ case GF_FOP_RENAME:
+ SERVER4_FOP_RSP_CLEANUP(rsp, rename, i, rename);
+ break;
+ case GF_FOP_LINK:
+ SERVER4_FOP_RSP_CLEANUP(rsp, link, i, common_3iatt);
+ break;
+ case GF_FOP_TRUNCATE:
+ SERVER4_FOP_RSP_CLEANUP(rsp, truncate, i, common_2iatt);
+ break;
+ case GF_FOP_OPEN:
+ SERVER4_FOP_RSP_CLEANUP(rsp, open, i, open);
+ break;
+ case GF_FOP_READ:
+ SERVER4_FOP_RSP_CLEANUP(rsp, read, i, read);
+ break;
+ case GF_FOP_WRITE:
+ SERVER4_FOP_RSP_CLEANUP(rsp, write, i, common_2iatt);
+ break;
+ case GF_FOP_STATFS:
+ SERVER4_FOP_RSP_CLEANUP(rsp, statfs, i, statfs);
+ break;
+ case GF_FOP_FSYNC:
+ SERVER4_FOP_RSP_CLEANUP(rsp, fsync, i, common_2iatt);
+ break;
+ case GF_FOP_OPENDIR:
+ SERVER4_FOP_RSP_CLEANUP(rsp, opendir, i, open);
+ break;
+ case GF_FOP_CREATE:
+ SERVER4_FOP_RSP_CLEANUP(rsp, create, i, create);
+ break;
+ case GF_FOP_FTRUNCATE:
+ SERVER4_FOP_RSP_CLEANUP(rsp, ftruncate, i, common_2iatt);
+ break;
+ case GF_FOP_FSTAT:
+ SERVER4_FOP_RSP_CLEANUP(rsp, fstat, i, common_iatt);
+ break;
+ case GF_FOP_LK:
+ SERVER4_FOP_RSP_CLEANUP(rsp, lk, i, lk);
+ break;
+ case GF_FOP_LOOKUP:
+ SERVER4_FOP_RSP_CLEANUP(rsp, lookup, i, common_2iatt);
+ break;
+ case GF_FOP_SETATTR:
+ SERVER4_FOP_RSP_CLEANUP(rsp, setattr, i, common_2iatt);
+ break;
+ case GF_FOP_FSETATTR:
+ SERVER4_FOP_RSP_CLEANUP(rsp, fsetattr, i, common_2iatt);
+ break;
+ case GF_FOP_FALLOCATE:
+ SERVER4_FOP_RSP_CLEANUP(rsp, fallocate, i, common_2iatt);
+ break;
+ case GF_FOP_DISCARD:
+ SERVER4_FOP_RSP_CLEANUP(rsp, discard, i, common_2iatt);
+ break;
+ case GF_FOP_ZEROFILL:
+ SERVER4_FOP_RSP_CLEANUP(rsp, zerofill, i, common_2iatt);
+ break;
+ case GF_FOP_SEEK:
+ SERVER4_FOP_RSP_CLEANUP(rsp, seek, i, seek);
+ break;
+ case GF_FOP_LEASE:
+ SERVER4_FOP_RSP_CLEANUP(rsp, lease, i, lease);
+ break;
+ case GF_FOP_READLINK:
+ SERVER4_FOP_RSP_CLEANUP(rsp, readlink, i, readlink);
+ break;
+ case GF_FOP_RCHECKSUM:
+ SERVER4_FOP_RSP_CLEANUP(rsp, rchecksum, i, rchecksum);
+ break;
+ /* fops that use gfx_common_rsp */
+ case GF_FOP_IPC:
+ SERVER4_COMMON_RSP_CLEANUP(rsp, ipc, i);
+ break;
+ case GF_FOP_FLUSH:
+ SERVER4_COMMON_RSP_CLEANUP(rsp, flush, i);
+ break;
+ case GF_FOP_SETXATTR:
+ SERVER4_COMMON_RSP_CLEANUP(rsp, setxattr, i);
+ break;
+ case GF_FOP_REMOVEXATTR:
+ SERVER4_COMMON_RSP_CLEANUP(rsp, removexattr, i);
+ break;
+ case GF_FOP_FSETXATTR:
+ SERVER4_COMMON_RSP_CLEANUP(rsp, fsetxattr, i);
+ break;
+ case GF_FOP_FREMOVEXATTR:
+ SERVER4_COMMON_RSP_CLEANUP(rsp, fremovexattr, i);
+ break;
+ case GF_FOP_FSYNCDIR:
+ SERVER4_COMMON_RSP_CLEANUP(rsp, fsyncdir, i);
+ break;
+ case GF_FOP_ACCESS:
+ SERVER4_COMMON_RSP_CLEANUP(rsp, access, i);
+ break;
+ case GF_FOP_INODELK:
+ SERVER4_COMMON_RSP_CLEANUP(rsp, inodelk, i);
+ break;
+ case GF_FOP_FINODELK:
+ SERVER4_COMMON_RSP_CLEANUP(rsp, finodelk, i);
+ break;
+ case GF_FOP_ENTRYLK:
+ SERVER4_COMMON_RSP_CLEANUP(rsp, entrylk, i);
+ break;
+ case GF_FOP_FENTRYLK:
+ SERVER4_COMMON_RSP_CLEANUP(rsp, fentrylk, i);
+ break;
+ /* fops that need extra cleanup */
+ case GF_FOP_XATTROP: {
+ gfx_common_dict_rsp *tmp_rsp = &CPD4_RSP_FIELD(this_rsp,
+ xattrop);
+ SERVER4_FOP_RSP_CLEANUP(rsp, xattrop, i, common_dict);
+ GF_FREE(tmp_rsp->dict.pairs.pairs_val);
+ break;
+ }
+ case GF_FOP_FXATTROP: {
+ gfx_common_dict_rsp *tmp_rsp = &CPD4_RSP_FIELD(this_rsp,
+ fxattrop);
+ SERVER4_FOP_RSP_CLEANUP(rsp, fxattrop, i, common_dict);
+ GF_FREE(tmp_rsp->dict.pairs.pairs_val);
+ break;
+ }
+ case GF_FOP_READDIR: {
+ gfx_readdir_rsp *tmp_rsp = &CPD4_RSP_FIELD(this_rsp, readdir);
+ SERVER4_FOP_RSP_CLEANUP(rsp, readdir, i, readdir);
+ readdir_rsp_cleanup_v2(tmp_rsp);
+ break;
+ }
+ case GF_FOP_READDIRP: {
+ gfx_readdirp_rsp *tmp_rsp = &CPD4_RSP_FIELD(this_rsp, readdirp);
+ SERVER4_FOP_RSP_CLEANUP(rsp, readdirp, i, readdirp);
+ readdirp_rsp_cleanup_v2(tmp_rsp);
+ break;
+ }
+ case GF_FOP_GETXATTR: {
+ gfx_common_dict_rsp *tmp_rsp = &CPD4_RSP_FIELD(this_rsp,
+ getxattr);
+ SERVER4_FOP_RSP_CLEANUP(rsp, getxattr, i, common_dict);
+ GF_FREE(tmp_rsp->dict.pairs.pairs_val);
+ break;
+ }
+ case GF_FOP_FGETXATTR: {
+ gfx_common_dict_rsp *tmp_rsp = &CPD4_RSP_FIELD(this_rsp,
+ fgetxattr);
+ SERVER4_FOP_RSP_CLEANUP(rsp, fgetxattr, i, common_dict);
+ GF_FREE(tmp_rsp->dict.pairs.pairs_val);
+ break;
+ }
+ default:
+ break;
+ }
+ }
+ GF_FREE(rsp->compound_rsp_array.compound_rsp_array_val);
+ return;
}
void
-server_compound_req_cleanup_v2 (gfx_compound_req *req, int len)
+server_compound_req_cleanup_v2(gfx_compound_req *req, int len)
{
- int i = 0;
- compound_req_v2 *curr_req = NULL;
+ int i = 0;
+ compound_req_v2 *curr_req = NULL;
+ if (!req->compound_req_array.compound_req_array_val)
+ return;
- if (!req->compound_req_array.compound_req_array_val)
- return;
-
- for (i = 0; i < len; i++) {
- curr_req = &req->compound_req_array.compound_req_array_val[i];
+ for (i = 0; i < len; i++) {
+ curr_req = &req->compound_req_array.compound_req_array_val[i];
- switch (curr_req->fop_enum) {
- case GF_FOP_MKDIR:
- {
- gfx_mkdir_req *args = &CPD4_REQ_FIELD (curr_req, mkdir);
+ switch (curr_req->fop_enum) {
+ case GF_FOP_MKDIR: {
+ gfx_mkdir_req *args = &CPD4_REQ_FIELD(curr_req, mkdir);
- free (args->bname);
- break;
- }
- case GF_FOP_UNLINK:
- {
- gfx_unlink_req *args = &CPD4_REQ_FIELD (curr_req,
- unlink);
- free (args->bname);
- break;
- }
- case GF_FOP_RMDIR:
- {
- gfx_rmdir_req *args = &CPD4_REQ_FIELD (curr_req,
- rmdir);
- free (args->bname);
- break;
- }
- case GF_FOP_SYMLINK:
- {
- gfx_symlink_req *args = &CPD4_REQ_FIELD (curr_req,
- symlink);
- free (args->bname);
- free (args->linkname);
- break;
- }
- case GF_FOP_RENAME:
- {
- gfx_rename_req *args = &CPD4_REQ_FIELD (curr_req,
- rename);
- free (args->oldbname);
- free (args->newbname);
- break;
- }
- case GF_FOP_LINK:
- {
- gfx_link_req *args = &CPD4_REQ_FIELD (curr_req,
- link);
- free (args->newbname);
- break;
- }
- case GF_FOP_GETXATTR:
- {
- gfx_getxattr_req *args = &CPD4_REQ_FIELD (curr_req,
- getxattr);
+ free(args->bname);
+ break;
+ }
+ case GF_FOP_UNLINK: {
+ gfx_unlink_req *args = &CPD4_REQ_FIELD(curr_req, unlink);
+ free(args->bname);
+ break;
+ }
+ case GF_FOP_RMDIR: {
+ gfx_rmdir_req *args = &CPD4_REQ_FIELD(curr_req, rmdir);
+ free(args->bname);
+ break;
+ }
+ case GF_FOP_SYMLINK: {
+ gfx_symlink_req *args = &CPD4_REQ_FIELD(curr_req, symlink);
+ free(args->bname);
+ free(args->linkname);
+ break;
+ }
+ case GF_FOP_RENAME: {
+ gfx_rename_req *args = &CPD4_REQ_FIELD(curr_req, rename);
+ free(args->oldbname);
+ free(args->newbname);
+ break;
+ }
+ case GF_FOP_LINK: {
+ gfx_link_req *args = &CPD4_REQ_FIELD(curr_req, link);
+ free(args->newbname);
+ break;
+ }
+ case GF_FOP_GETXATTR: {
+ gfx_getxattr_req *args = &CPD4_REQ_FIELD(curr_req, getxattr);
- free (args->name);
- break;
- }
- case GF_FOP_REMOVEXATTR:
- {
- gfx_removexattr_req *args = &CPD4_REQ_FIELD (curr_req,
- removexattr);
+ free(args->name);
+ break;
+ }
+ case GF_FOP_REMOVEXATTR: {
+ gfx_removexattr_req *args = &CPD4_REQ_FIELD(curr_req,
+ removexattr);
- free (args->name);
- break;
- }
- case GF_FOP_CREATE:
- {
- gfx_create_req *args = &CPD4_REQ_FIELD (curr_req,
- create);
+ free(args->name);
+ break;
+ }
+ case GF_FOP_CREATE: {
+ gfx_create_req *args = &CPD4_REQ_FIELD(curr_req, create);
- free (args->bname);
- break;
- }
- case GF_FOP_LK:
- {
- gfx_lk_req *args = &CPD4_REQ_FIELD (curr_req, lk);
- free (args->flock.lk_owner.lk_owner_val);
- break;
- }
- case GF_FOP_LOOKUP:
- {
- gfx_lookup_req *args = &CPD4_REQ_FIELD (curr_req,
- lookup);
- free (args->bname);
- break;
- }
- case GF_FOP_INODELK:
- {
- gfx_inodelk_req *args = &CPD4_REQ_FIELD (curr_req,
- inodelk);
+ free(args->bname);
+ break;
+ }
+ case GF_FOP_LK: {
+ gfx_lk_req *args = &CPD4_REQ_FIELD(curr_req, lk);
+ free(args->flock.lk_owner.lk_owner_val);
+ break;
+ }
+ case GF_FOP_LOOKUP: {
+ gfx_lookup_req *args = &CPD4_REQ_FIELD(curr_req, lookup);
+ free(args->bname);
+ break;
+ }
+ case GF_FOP_INODELK: {
+ gfx_inodelk_req *args = &CPD4_REQ_FIELD(curr_req, inodelk);
- free (args->volume);
- free (args->flock.lk_owner.lk_owner_val);
- break;
- }
- case GF_FOP_FINODELK:
- {
- gfx_finodelk_req *args = &CPD4_REQ_FIELD (curr_req,
- finodelk);
+ free(args->volume);
+ free(args->flock.lk_owner.lk_owner_val);
+ break;
+ }
+ case GF_FOP_FINODELK: {
+ gfx_finodelk_req *args = &CPD4_REQ_FIELD(curr_req, finodelk);
- free (args->volume);
- free (args->flock.lk_owner.lk_owner_val);
- break;
- }
- case GF_FOP_ENTRYLK:
- {
- gfx_entrylk_req *args = &CPD4_REQ_FIELD (curr_req,
- entrylk);
+ free(args->volume);
+ free(args->flock.lk_owner.lk_owner_val);
+ break;
+ }
+ case GF_FOP_ENTRYLK: {
+ gfx_entrylk_req *args = &CPD4_REQ_FIELD(curr_req, entrylk);
- free (args->volume);
- free (args->name);
- break;
- }
- case GF_FOP_FENTRYLK:
- {
- gfx_fentrylk_req *args = &CPD4_REQ_FIELD (curr_req,
- fentrylk);
+ free(args->volume);
+ free(args->name);
+ break;
+ }
+ case GF_FOP_FENTRYLK: {
+ gfx_fentrylk_req *args = &CPD4_REQ_FIELD(curr_req, fentrylk);
- free (args->volume);
- free (args->name);
- break;
- }
- case GF_FOP_FGETXATTR:
- {
- gfx_fgetxattr_req *args = &CPD4_REQ_FIELD (curr_req,
- fgetxattr);
+ free(args->volume);
+ free(args->name);
+ break;
+ }
+ case GF_FOP_FGETXATTR: {
+ gfx_fgetxattr_req *args = &CPD4_REQ_FIELD(curr_req, fgetxattr);
- free (args->name);
- break;
- }
- case GF_FOP_FREMOVEXATTR:
- {
- gfx_fremovexattr_req *args = &CPD4_REQ_FIELD(curr_req,
- fremovexattr);
- free (args->name);
- break;
- }
- default:
- break;
- }
+ free(args->name);
+ break;
+ }
+ case GF_FOP_FREMOVEXATTR: {
+ gfx_fremovexattr_req *args = &CPD4_REQ_FIELD(curr_req,
+ fremovexattr);
+ free(args->name);
+ break;
+ }
+ default:
+ break;
}
+ }
- return;
+ return;
}
diff --git a/xlators/protocol/server/src/server-resolve.c b/xlators/protocol/server/src/server-resolve.c
index b3eda0e4c9e..ba4d2f16a93 100644
--- a/xlators/protocol/server/src/server-resolve.c
+++ b/xlators/protocol/server/src/server-resolve.c
@@ -12,271 +12,257 @@
#include "server-helpers.h"
#include "server-messages.h"
-
int
-server_resolve_all (call_frame_t *frame);
+server_resolve_all(call_frame_t *frame);
int
-resolve_entry_simple (call_frame_t *frame);
+resolve_entry_simple(call_frame_t *frame);
int
-resolve_inode_simple (call_frame_t *frame);
+resolve_inode_simple(call_frame_t *frame);
int
-resolve_continue (call_frame_t *frame);
+resolve_continue(call_frame_t *frame);
int
-resolve_anonfd_simple (call_frame_t *frame);
+resolve_anonfd_simple(call_frame_t *frame);
int
-resolve_loc_touchup (call_frame_t *frame)
+resolve_loc_touchup(call_frame_t *frame)
{
- server_state_t *state = NULL;
- server_resolve_t *resolve = NULL;
- loc_t *loc = NULL;
+ server_state_t *state = NULL;
+ server_resolve_t *resolve = NULL;
+ loc_t *loc = NULL;
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- resolve = state->resolve_now;
- loc = state->loc_now;
+ resolve = state->resolve_now;
+ loc = state->loc_now;
- loc_touchup (loc, resolve->bname);
- return 0;
+ loc_touchup(loc, resolve->bname);
+ return 0;
}
-
int
-resolve_gfid_entry_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
- int op_ret, int op_errno, inode_t *inode,
- struct iatt *buf, dict_t *xdata,
- struct iatt *postparent)
+resolve_gfid_entry_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+ int op_ret, int op_errno, inode_t *inode,
+ struct iatt *buf, dict_t *xdata, struct iatt *postparent)
{
- server_state_t *state = NULL;
- server_resolve_t *resolve = NULL;
- inode_t *link_inode = NULL;
- loc_t *resolve_loc = NULL;
-
- state = CALL_STATE (frame);
- resolve = state->resolve_now;
- resolve_loc = &resolve->resolve_loc;
-
- if (op_ret == -1) {
- if (op_errno == ENOENT) {
- gf_msg_debug (this->name, 0,
- "%s/%s: failed to resolve (%s)",
- uuid_utoa (resolve_loc->pargfid),
- resolve_loc->name, strerror (op_errno));
- if (resolve->type == RESOLVE_NOT) {
- do {
- inode = inode_grep (state->itable,
- resolve_loc->parent,
- resolve->bname);
-
- if (inode) {
- gf_msg_debug (this->name, 0, "%s/%s: "
- "removing stale dentry",
- uuid_utoa (resolve_loc->pargfid),
- resolve->bname);
- inode_unlink (inode,
- resolve_loc->parent,
- resolve->bname);
- }
- } while (inode);
- }
- } else {
- gf_msg (this->name, GF_LOG_WARNING, op_errno,
- PS_MSG_GFID_RESOLVE_FAILED, "%s/%s: failed to "
- "resolve (%s)",
- uuid_utoa (resolve_loc->pargfid),
- resolve_loc->name, strerror (op_errno));
- }
- goto out;
+ server_state_t *state = NULL;
+ server_resolve_t *resolve = NULL;
+ inode_t *link_inode = NULL;
+ loc_t *resolve_loc = NULL;
+
+ state = CALL_STATE(frame);
+ resolve = state->resolve_now;
+ resolve_loc = &resolve->resolve_loc;
+
+ if (op_ret == -1) {
+ if (op_errno == ENOENT) {
+ gf_msg_debug(this->name, 0, "%s/%s: failed to resolve (%s)",
+ uuid_utoa(resolve_loc->pargfid), resolve_loc->name,
+ strerror(op_errno));
+ if (resolve->type == RESOLVE_NOT) {
+ do {
+ inode = inode_grep(state->itable, resolve_loc->parent,
+ resolve->bname);
+
+ if (inode) {
+ gf_msg_debug(this->name, 0,
+ "%s/%s: "
+ "removing stale dentry",
+ uuid_utoa(resolve_loc->pargfid),
+ resolve->bname);
+ inode_unlink(inode, resolve_loc->parent,
+ resolve->bname);
+ }
+ } while (inode);
+ }
+ } else {
+ gf_msg(this->name, GF_LOG_WARNING, op_errno,
+ PS_MSG_GFID_RESOLVE_FAILED,
+ "%s/%s: failed to "
+ "resolve (%s)",
+ uuid_utoa(resolve_loc->pargfid), resolve_loc->name,
+ strerror(op_errno));
}
+ goto out;
+ }
- link_inode = inode_link (inode, resolve_loc->parent,
- resolve_loc->name, buf);
+ link_inode = inode_link(inode, resolve_loc->parent, resolve_loc->name, buf);
- if (!link_inode)
- goto out;
+ if (!link_inode)
+ goto out;
- inode_lookup (link_inode);
+ inode_lookup(link_inode);
- inode_unref (link_inode);
+ inode_unref(link_inode);
out:
- loc_wipe (resolve_loc);
+ loc_wipe(resolve_loc);
- resolve_continue (frame);
- return 0;
+ resolve_continue(frame);
+ return 0;
}
-
int
-resolve_gfid_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
- int op_ret, int op_errno, inode_t *inode, struct iatt *buf,
- dict_t *xdata, struct iatt *postparent)
+resolve_gfid_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int op_ret,
+ int op_errno, inode_t *inode, struct iatt *buf, dict_t *xdata,
+ struct iatt *postparent)
{
- server_state_t *state = NULL;
- server_resolve_t *resolve = NULL;
- inode_t *link_inode = NULL;
- loc_t *resolve_loc = NULL;
- dict_t *dict = NULL;
-
- state = CALL_STATE (frame);
- resolve = state->resolve_now;
- resolve_loc = &resolve->resolve_loc;
-
- if (op_ret == -1) {
- if (op_errno == ENOENT) {
- gf_msg_debug (this->name, GF_LOG_DEBUG,
- "%s: failed to resolve (%s)",
- uuid_utoa (resolve_loc->gfid),
- strerror (op_errno));
- } else {
- gf_msg (this->name, GF_LOG_WARNING, op_errno,
- PS_MSG_GFID_RESOLVE_FAILED,
- "%s: failed to resolve (%s)",
- uuid_utoa (resolve_loc->gfid),
- strerror (op_errno));
- }
- loc_wipe (&resolve->resolve_loc);
- goto out;
- }
-
- link_inode = inode_link (inode, NULL, NULL, buf);
-
- if (!link_inode) {
- loc_wipe (resolve_loc);
- goto out;
- }
-
- inode_lookup (link_inode);
-
- /* wipe the loc only after the inode has been linked to the inode
- table. Otherwise before inode gets linked to the inode table,
- inode would have been unrefed (this might have been destroyed
- if refcount becomes 0, and put back to mempool). So once the
- inode gets destroyed, inode_link is a redundant operation. But
- without knowing that the destroyed inode's pointer is saved in
- the resolved_loc as parent (while constructing loc for resolving
- the entry) and the inode_new call for resolving the entry will
- return the same pointer to the inode as the parent (because in
- reality the inode is a free inode present in cold list of the
- inode mem-pool).
- */
- loc_wipe (resolve_loc);
-
- if (gf_uuid_is_null (resolve->pargfid)) {
- inode_unref (link_inode);
- goto out;
- }
-
- resolve_loc->parent = link_inode;
- gf_uuid_copy (resolve_loc->pargfid, resolve_loc->parent->gfid);
-
- resolve_loc->name = resolve->bname;
-
- resolve_loc->inode = server_inode_new (state->itable,
- resolve_loc->gfid);
-
- inode_path (resolve_loc->parent, resolve_loc->name,
- (char **) &resolve_loc->path);
-
- if (state->xdata) {
- dict = dict_copy_with_ref (state->xdata, NULL);
- if (!dict)
- gf_msg (this->name, GF_LOG_ERROR, ENOMEM, PS_MSG_NO_MEMORY,
- "BUG: dict allocation failed (pargfid: %s, name: %s), "
- "still continuing", uuid_utoa (resolve_loc->gfid),
- resolve_loc->name);
+ server_state_t *state = NULL;
+ server_resolve_t *resolve = NULL;
+ inode_t *link_inode = NULL;
+ loc_t *resolve_loc = NULL;
+ dict_t *dict = NULL;
+
+ state = CALL_STATE(frame);
+ resolve = state->resolve_now;
+ resolve_loc = &resolve->resolve_loc;
+
+ if (op_ret == -1) {
+ if (op_errno == ENOENT) {
+ gf_msg_debug(this->name, GF_LOG_DEBUG, "%s: failed to resolve (%s)",
+ uuid_utoa(resolve_loc->gfid), strerror(op_errno));
+ } else {
+ gf_msg(this->name, GF_LOG_WARNING, op_errno,
+ PS_MSG_GFID_RESOLVE_FAILED, "%s: failed to resolve (%s)",
+ uuid_utoa(resolve_loc->gfid), strerror(op_errno));
}
-
- STACK_WIND (frame, resolve_gfid_entry_cbk,
- frame->root->client->bound_xl,
- frame->root->client->bound_xl->fops->lookup,
- &resolve->resolve_loc, dict);
- if (dict)
- dict_unref (dict);
- return 0;
+ loc_wipe(&resolve->resolve_loc);
+ goto out;
+ }
+
+ link_inode = inode_link(inode, NULL, NULL, buf);
+
+ if (!link_inode) {
+ loc_wipe(resolve_loc);
+ goto out;
+ }
+
+ inode_lookup(link_inode);
+
+ /* wipe the loc only after the inode has been linked to the inode
+ table. Otherwise before inode gets linked to the inode table,
+ inode would have been unrefed (this might have been destroyed
+ if refcount becomes 0, and put back to mempool). So once the
+ inode gets destroyed, inode_link is a redundant operation. But
+ without knowing that the destroyed inode's pointer is saved in
+ the resolved_loc as parent (while constructing loc for resolving
+ the entry) and the inode_new call for resolving the entry will
+ return the same pointer to the inode as the parent (because in
+ reality the inode is a free inode present in cold list of the
+ inode mem-pool).
+ */
+ loc_wipe(resolve_loc);
+
+ if (gf_uuid_is_null(resolve->pargfid)) {
+ inode_unref(link_inode);
+ goto out;
+ }
+
+ resolve_loc->parent = link_inode;
+ gf_uuid_copy(resolve_loc->pargfid, resolve_loc->parent->gfid);
+
+ resolve_loc->name = resolve->bname;
+
+ resolve_loc->inode = server_inode_new(state->itable, resolve_loc->gfid);
+
+ inode_path(resolve_loc->parent, resolve_loc->name,
+ (char **)&resolve_loc->path);
+
+ if (state->xdata) {
+ dict = dict_copy_with_ref(state->xdata, NULL);
+ if (!dict)
+ gf_msg(this->name, GF_LOG_ERROR, ENOMEM, PS_MSG_NO_MEMORY,
+ "BUG: dict allocation failed (pargfid: %s, name: %s), "
+ "still continuing",
+ uuid_utoa(resolve_loc->gfid), resolve_loc->name);
+ }
+
+ STACK_WIND(frame, resolve_gfid_entry_cbk, frame->root->client->bound_xl,
+ frame->root->client->bound_xl->fops->lookup,
+ &resolve->resolve_loc, dict);
+ if (dict)
+ dict_unref(dict);
+ return 0;
out:
- resolve_continue (frame);
- return 0;
+ resolve_continue(frame);
+ return 0;
}
-
int
-resolve_gfid (call_frame_t *frame)
+resolve_gfid(call_frame_t *frame)
{
- server_state_t *state = NULL;
- xlator_t *this = NULL;
- server_resolve_t *resolve = NULL;
- loc_t *resolve_loc = NULL;
- dict_t *xdata = NULL;
-
- state = CALL_STATE (frame);
- this = frame->this;
- resolve = state->resolve_now;
- resolve_loc = &resolve->resolve_loc;
-
- if (!gf_uuid_is_null (resolve->pargfid))
- gf_uuid_copy (resolve_loc->gfid, resolve->pargfid);
- else if (!gf_uuid_is_null (resolve->gfid))
- gf_uuid_copy (resolve_loc->gfid, resolve->gfid);
-
- resolve_loc->inode = server_inode_new (state->itable,
- resolve_loc->gfid);
- (void) loc_path (resolve_loc, NULL);
-
- if (state->xdata) {
- xdata = dict_copy_with_ref (state->xdata, NULL);
- if (!xdata)
- gf_msg (this->name, GF_LOG_ERROR, ENOMEM, PS_MSG_NO_MEMORY,
- "BUG: dict allocation failed (gfid: %s), "
- "still continuing",
- uuid_utoa (resolve_loc->gfid));
- }
-
- STACK_WIND (frame, resolve_gfid_cbk,
- frame->root->client->bound_xl,
- frame->root->client->bound_xl->fops->lookup,
- &resolve->resolve_loc, xdata);
-
- if (xdata)
- dict_unref (xdata);
-
- return 0;
+ server_state_t *state = NULL;
+ xlator_t *this = NULL;
+ server_resolve_t *resolve = NULL;
+ loc_t *resolve_loc = NULL;
+ dict_t *xdata = NULL;
+
+ state = CALL_STATE(frame);
+ this = frame->this;
+ resolve = state->resolve_now;
+ resolve_loc = &resolve->resolve_loc;
+
+ if (!gf_uuid_is_null(resolve->pargfid))
+ gf_uuid_copy(resolve_loc->gfid, resolve->pargfid);
+ else if (!gf_uuid_is_null(resolve->gfid))
+ gf_uuid_copy(resolve_loc->gfid, resolve->gfid);
+
+ resolve_loc->inode = server_inode_new(state->itable, resolve_loc->gfid);
+ (void)loc_path(resolve_loc, NULL);
+
+ if (state->xdata) {
+ xdata = dict_copy_with_ref(state->xdata, NULL);
+ if (!xdata)
+ gf_msg(this->name, GF_LOG_ERROR, ENOMEM, PS_MSG_NO_MEMORY,
+ "BUG: dict allocation failed (gfid: %s), "
+ "still continuing",
+ uuid_utoa(resolve_loc->gfid));
+ }
+
+ STACK_WIND(frame, resolve_gfid_cbk, frame->root->client->bound_xl,
+ frame->root->client->bound_xl->fops->lookup,
+ &resolve->resolve_loc, xdata);
+
+ if (xdata)
+ dict_unref(xdata);
+
+ return 0;
}
int
-resolve_continue (call_frame_t *frame)
+resolve_continue(call_frame_t *frame)
{
- server_state_t *state = NULL;
- xlator_t *this = NULL;
- server_resolve_t *resolve = NULL;
- int ret = 0;
-
- state = CALL_STATE (frame);
- this = frame->this;
- resolve = state->resolve_now;
-
- resolve->op_ret = 0;
- resolve->op_errno = 0;
-
- if (resolve->fd_no != -1) {
- ret = resolve_anonfd_simple (frame);
- goto out;
- } else if (!gf_uuid_is_null (resolve->pargfid))
- ret = resolve_entry_simple (frame);
- else if (!gf_uuid_is_null (resolve->gfid))
- ret = resolve_inode_simple (frame);
- if (ret)
- gf_msg_debug (this->name, 0, "return value of resolve_*_"
- "simple %d", ret);
-
- resolve_loc_touchup (frame);
+ server_state_t *state = NULL;
+ xlator_t *this = NULL;
+ server_resolve_t *resolve = NULL;
+ int ret = 0;
+
+ state = CALL_STATE(frame);
+ this = frame->this;
+ resolve = state->resolve_now;
+
+ resolve->op_ret = 0;
+ resolve->op_errno = 0;
+
+ if (resolve->fd_no != -1) {
+ ret = resolve_anonfd_simple(frame);
+ goto out;
+ } else if (!gf_uuid_is_null(resolve->pargfid))
+ ret = resolve_entry_simple(frame);
+ else if (!gf_uuid_is_null(resolve->gfid))
+ ret = resolve_inode_simple(frame);
+ if (ret)
+ gf_msg_debug(this->name, 0,
+ "return value of resolve_*_"
+ "simple %d",
+ ret);
+
+ resolve_loc_touchup(frame);
out:
- server_resolve_all (frame);
+ server_resolve_all(frame);
- return 0;
+ return 0;
}
-
/*
Check if the requirements are fulfilled by entries in the inode cache itself
Return value:
@@ -285,392 +271,375 @@ out:
*/
int
-resolve_entry_simple (call_frame_t *frame)
+resolve_entry_simple(call_frame_t *frame)
{
- server_state_t *state = NULL;
- xlator_t *this = NULL;
- server_resolve_t *resolve = NULL;
- inode_t *parent = NULL;
- inode_t *inode = NULL;
- int ret = 0;
-
- state = CALL_STATE (frame);
- this = frame->this;
- resolve = state->resolve_now;
-
- parent = inode_find (state->itable, resolve->pargfid);
- if (!parent) {
- /* simple resolution is indecisive. need to perform
- deep resolution */
- resolve->op_ret = -1;
- resolve->op_errno = ESTALE;
+ server_state_t *state = NULL;
+ xlator_t *this = NULL;
+ server_resolve_t *resolve = NULL;
+ inode_t *parent = NULL;
+ inode_t *inode = NULL;
+ int ret = 0;
+
+ state = CALL_STATE(frame);
+ this = frame->this;
+ resolve = state->resolve_now;
+
+ parent = inode_find(state->itable, resolve->pargfid);
+ if (!parent) {
+ /* simple resolution is indecisive. need to perform
+ deep resolution */
+ resolve->op_ret = -1;
+ resolve->op_errno = ESTALE;
+ ret = 1;
+ goto out;
+ }
+
+ /* expected @parent was found from the inode cache */
+ gf_uuid_copy(state->loc_now->pargfid, resolve->pargfid);
+ state->loc_now->parent = inode_ref(parent);
+
+ if (strstr(resolve->bname, "../")) {
+ /* Resolving outside the parent's tree is not allowed */
+ gf_msg(this->name, GF_LOG_ERROR, EPERM, PS_MSG_GFID_RESOLVE_FAILED,
+ "%s: path sent by client not allowed", resolve->bname);
+ resolve->op_ret = -1;
+ resolve->op_errno = EPERM;
+ ret = 1;
+ goto out;
+ }
+ state->loc_now->name = resolve->bname;
+
+ inode = inode_grep(state->itable, parent, resolve->bname);
+ if (!inode) {
+ switch (resolve->type) {
+ case RESOLVE_DONTCARE:
+ case RESOLVE_NOT:
+ ret = 0;
+ break;
+ case RESOLVE_MAY:
ret = 1;
- goto out;
- }
-
- /* expected @parent was found from the inode cache */
- gf_uuid_copy (state->loc_now->pargfid, resolve->pargfid);
- state->loc_now->parent = inode_ref (parent);
-
- if (strstr (resolve->bname, "../")) {
- /* Resolving outside the parent's tree is not allowed */
- gf_msg (this->name, GF_LOG_ERROR, EPERM,
- PS_MSG_GFID_RESOLVE_FAILED,
- "%s: path sent by client not allowed",
- resolve->bname);
- resolve->op_ret = -1;
- resolve->op_errno = EPERM;
+ break;
+ default:
+ resolve->op_ret = -1;
+ resolve->op_errno = ENOENT;
ret = 1;
- goto out;
- }
- state->loc_now->name = resolve->bname;
-
- inode = inode_grep (state->itable, parent, resolve->bname);
- if (!inode) {
- switch (resolve->type) {
- case RESOLVE_DONTCARE:
- case RESOLVE_NOT:
- ret = 0;
- break;
- case RESOLVE_MAY:
- ret = 1;
- break;
- default:
- resolve->op_ret = -1;
- resolve->op_errno = ENOENT;
- ret = 1;
- break;
- }
-
- goto out;
+ break;
}
- if (resolve->type == RESOLVE_NOT) {
- gf_msg_debug (this->name, 0, "inode (pointer: %p gfid:%s found"
- " for path (%s) while type is RESOLVE_NOT. "
- "Performing lookup on backend to rule out any "
- "possible stale dentries in inode table",
- inode, uuid_utoa (inode->gfid), resolve->path);
- resolve->op_ret = -1;
- resolve->op_errno = EEXIST;
- ret = 1;
- goto out;
- }
+ goto out;
+ }
+
+ if (resolve->type == RESOLVE_NOT) {
+ gf_msg_debug(this->name, 0,
+ "inode (pointer: %p gfid:%s found"
+ " for path (%s) while type is RESOLVE_NOT. "
+ "Performing lookup on backend to rule out any "
+ "possible stale dentries in inode table",
+ inode, uuid_utoa(inode->gfid), resolve->path);
+ resolve->op_ret = -1;
+ resolve->op_errno = EEXIST;
+ ret = 1;
+ goto out;
+ }
- ret = 0;
+ ret = 0;
- state->loc_now->inode = inode_ref (inode);
+ state->loc_now->inode = inode_ref(inode);
out:
- if (parent)
- inode_unref (parent);
+ if (parent)
+ inode_unref(parent);
- if (inode)
- inode_unref (inode);
+ if (inode)
+ inode_unref(inode);
- return ret;
+ return ret;
}
-
int
-server_resolve_entry (call_frame_t *frame)
+server_resolve_entry(call_frame_t *frame)
{
- server_state_t *state = NULL;
- int ret = 0;
- loc_t *loc = NULL;
+ server_state_t *state = NULL;
+ int ret = 0;
+ loc_t *loc = NULL;
- state = CALL_STATE (frame);
- loc = state->loc_now;
+ state = CALL_STATE(frame);
+ loc = state->loc_now;
- ret = resolve_entry_simple (frame);
+ ret = resolve_entry_simple(frame);
- if (ret > 0) {
- loc_wipe (loc);
- resolve_gfid (frame);
- return 0;
- }
+ if (ret > 0) {
+ loc_wipe(loc);
+ resolve_gfid(frame);
+ return 0;
+ }
- if (ret == 0)
- resolve_loc_touchup (frame);
+ if (ret == 0)
+ resolve_loc_touchup(frame);
- server_resolve_all (frame);
+ server_resolve_all(frame);
- return 0;
+ return 0;
}
-
int
-resolve_inode_simple (call_frame_t *frame)
+resolve_inode_simple(call_frame_t *frame)
{
- server_state_t *state = NULL;
- server_resolve_t *resolve = NULL;
- inode_t *inode = NULL;
- int ret = 0;
+ server_state_t *state = NULL;
+ server_resolve_t *resolve = NULL;
+ inode_t *inode = NULL;
+ int ret = 0;
- state = CALL_STATE (frame);
- resolve = state->resolve_now;
+ state = CALL_STATE(frame);
+ resolve = state->resolve_now;
- inode = inode_find (state->itable, resolve->gfid);
+ inode = inode_find(state->itable, resolve->gfid);
- if (!inode) {
- resolve->op_ret = -1;
- resolve->op_errno = ESTALE;
- ret = 1;
- goto out;
- }
+ if (!inode) {
+ resolve->op_ret = -1;
+ resolve->op_errno = ESTALE;
+ ret = 1;
+ goto out;
+ }
- ret = 0;
+ ret = 0;
- state->loc_now->inode = inode_ref (inode);
- gf_uuid_copy (state->loc_now->gfid, resolve->gfid);
+ state->loc_now->inode = inode_ref(inode);
+ gf_uuid_copy(state->loc_now->gfid, resolve->gfid);
out:
- if (inode)
- inode_unref (inode);
+ if (inode)
+ inode_unref(inode);
- return ret;
+ return ret;
}
-
int
-server_resolve_inode (call_frame_t *frame)
+server_resolve_inode(call_frame_t *frame)
{
- server_state_t *state = NULL;
- int ret = 0;
- loc_t *loc = NULL;
+ server_state_t *state = NULL;
+ int ret = 0;
+ loc_t *loc = NULL;
- state = CALL_STATE (frame);
- loc = state->loc_now;
+ state = CALL_STATE(frame);
+ loc = state->loc_now;
- ret = resolve_inode_simple (frame);
+ ret = resolve_inode_simple(frame);
- if (ret > 0) {
- loc_wipe (loc);
- resolve_gfid (frame);
- return 0;
- }
+ if (ret > 0) {
+ loc_wipe(loc);
+ resolve_gfid(frame);
+ return 0;
+ }
- if (ret == 0)
- resolve_loc_touchup (frame);
+ if (ret == 0)
+ resolve_loc_touchup(frame);
- server_resolve_all (frame);
+ server_resolve_all(frame);
- return 0;
+ return 0;
}
-
int
-resolve_anonfd_simple (call_frame_t *frame)
+resolve_anonfd_simple(call_frame_t *frame)
{
- server_state_t *state = NULL;
- server_resolve_t *resolve = NULL;
- inode_t *inode = NULL;
- int ret = 0;
+ server_state_t *state = NULL;
+ server_resolve_t *resolve = NULL;
+ inode_t *inode = NULL;
+ int ret = 0;
- state = CALL_STATE (frame);
- resolve = state->resolve_now;
+ state = CALL_STATE(frame);
+ resolve = state->resolve_now;
- inode = inode_find (state->itable, resolve->gfid);
+ inode = inode_find(state->itable, resolve->gfid);
- if (!inode) {
- resolve->op_ret = -1;
- resolve->op_errno = ENOENT;
- ret = 1;
- goto out;
- }
+ if (!inode) {
+ resolve->op_ret = -1;
+ resolve->op_errno = ENOENT;
+ ret = 1;
+ goto out;
+ }
- ret = 0;
+ ret = 0;
- if (frame->root->op == GF_FOP_READ || frame->root->op == GF_FOP_WRITE)
- state->fd = fd_anonymous_with_flags (inode, state->flags);
- else
- state->fd = fd_anonymous (inode);
+ if (frame->root->op == GF_FOP_READ || frame->root->op == GF_FOP_WRITE)
+ state->fd = fd_anonymous_with_flags(inode, state->flags);
+ else
+ state->fd = fd_anonymous(inode);
out:
- if (inode)
- inode_unref (inode);
-
- if (ret != 0)
- gf_msg_debug ("server", 0, "inode for the gfid"
- "(%s) is not found. anonymous fd creation failed",
- uuid_utoa (resolve->gfid));
- return ret;
+ if (inode)
+ inode_unref(inode);
+
+ if (ret != 0)
+ gf_msg_debug("server", 0,
+ "inode for the gfid"
+ "(%s) is not found. anonymous fd creation failed",
+ uuid_utoa(resolve->gfid));
+ return ret;
}
-
int
-server_resolve_anonfd (call_frame_t *frame)
+server_resolve_anonfd(call_frame_t *frame)
{
- server_state_t *state = NULL;
- int ret = 0;
- loc_t *loc = NULL;
+ server_state_t *state = NULL;
+ int ret = 0;
+ loc_t *loc = NULL;
- state = CALL_STATE (frame);
- loc = state->loc_now;
+ state = CALL_STATE(frame);
+ loc = state->loc_now;
- ret = resolve_anonfd_simple (frame);
-
- if (ret > 0) {
- loc_wipe (loc);
- resolve_gfid (frame);
- return 0;
- }
-
- server_resolve_all (frame);
+ ret = resolve_anonfd_simple(frame);
+ if (ret > 0) {
+ loc_wipe(loc);
+ resolve_gfid(frame);
return 0;
+ }
-}
+ server_resolve_all(frame);
+ return 0;
+}
int
-server_resolve_fd (call_frame_t *frame)
+server_resolve_fd(call_frame_t *frame)
{
- server_ctx_t *serv_ctx = NULL;
- server_state_t *state = NULL;
- client_t *client = NULL;
- server_resolve_t *resolve = NULL;
- uint64_t fd_no = -1;
+ server_ctx_t *serv_ctx = NULL;
+ server_state_t *state = NULL;
+ client_t *client = NULL;
+ server_resolve_t *resolve = NULL;
+ uint64_t fd_no = -1;
- state = CALL_STATE (frame);
- resolve = state->resolve_now;
+ state = CALL_STATE(frame);
+ resolve = state->resolve_now;
- fd_no = resolve->fd_no;
+ fd_no = resolve->fd_no;
- if (fd_no == GF_ANON_FD_NO) {
- server_resolve_anonfd (frame);
- return 0;
- }
+ if (fd_no == GF_ANON_FD_NO) {
+ server_resolve_anonfd(frame);
+ return 0;
+ }
- client = frame->root->client;
+ client = frame->root->client;
- serv_ctx = server_ctx_get (client, client->this);
+ serv_ctx = server_ctx_get(client, client->this);
- if (serv_ctx == NULL) {
- gf_msg ("", GF_LOG_INFO, ENOMEM, PS_MSG_NO_MEMORY,
- "server_ctx_get() failed");
- resolve->op_ret = -1;
- resolve->op_errno = ENOMEM;
- return 0;
- }
+ if (serv_ctx == NULL) {
+ gf_msg("", GF_LOG_INFO, ENOMEM, PS_MSG_NO_MEMORY,
+ "server_ctx_get() failed");
+ resolve->op_ret = -1;
+ resolve->op_errno = ENOMEM;
+ return 0;
+ }
- state->fd = gf_fd_fdptr_get (serv_ctx->fdtable, fd_no);
+ state->fd = gf_fd_fdptr_get(serv_ctx->fdtable, fd_no);
- if (!state->fd) {
- gf_msg ("", GF_LOG_INFO, EBADF, PS_MSG_FD_NOT_FOUND, "fd not "
- "found in context");
- resolve->op_ret = -1;
- resolve->op_errno = EBADF;
- }
+ if (!state->fd) {
+ gf_msg("", GF_LOG_INFO, EBADF, PS_MSG_FD_NOT_FOUND,
+ "fd not "
+ "found in context");
+ resolve->op_ret = -1;
+ resolve->op_errno = EBADF;
+ }
- server_resolve_all (frame);
+ server_resolve_all(frame);
- return 0;
+ return 0;
}
-
int
-server_resolve (call_frame_t *frame)
+server_resolve(call_frame_t *frame)
{
- server_state_t *state = NULL;
- server_resolve_t *resolve = NULL;
-
- state = CALL_STATE (frame);
- resolve = state->resolve_now;
-
- if (resolve->fd_no != -1) {
-
- server_resolve_fd (frame);
+ server_state_t *state = NULL;
+ server_resolve_t *resolve = NULL;
- } else if (!gf_uuid_is_null (resolve->pargfid)) {
+ state = CALL_STATE(frame);
+ resolve = state->resolve_now;
- server_resolve_entry (frame);
+ if (resolve->fd_no != -1) {
+ server_resolve_fd(frame);
- } else if (!gf_uuid_is_null (resolve->gfid)) {
+ } else if (!gf_uuid_is_null(resolve->pargfid)) {
+ server_resolve_entry(frame);
- server_resolve_inode (frame);
+ } else if (!gf_uuid_is_null(resolve->gfid)) {
+ server_resolve_inode(frame);
- } else {
- if (resolve == &state->resolve)
- gf_msg (frame->this->name, GF_LOG_WARNING, 0,
- PS_MSG_INVALID_ENTRY,
- "no resolution type for %s (%s)",
- resolve->path, gf_fop_list[frame->root->op]);
+ } else {
+ if (resolve == &state->resolve)
+ gf_msg(frame->this->name, GF_LOG_WARNING, 0, PS_MSG_INVALID_ENTRY,
+ "no resolution type for %s (%s)", resolve->path,
+ gf_fop_list[frame->root->op]);
- resolve->op_ret = -1;
- resolve->op_errno = EINVAL;
+ resolve->op_ret = -1;
+ resolve->op_errno = EINVAL;
- server_resolve_all (frame);
- }
+ server_resolve_all(frame);
+ }
- return 0;
+ return 0;
}
-
int
-server_resolve_done (call_frame_t *frame)
+server_resolve_done(call_frame_t *frame)
{
- server_state_t *state = NULL;
+ server_state_t *state = NULL;
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- server_print_request (frame);
+ server_print_request(frame);
- state->resume_fn (frame, frame->root->client->bound_xl);
+ state->resume_fn(frame, frame->root->client->bound_xl);
- return 0;
+ return 0;
}
-
/*
* This function is called multiple times, once per resolving one location/fd.
* state->resolve_now is used to decide which location/fd is to be resolved now
*/
int
-server_resolve_all (call_frame_t *frame)
+server_resolve_all(call_frame_t *frame)
{
- server_state_t *state = NULL;
- xlator_t *this = NULL;
-
- this = frame->this;
- state = CALL_STATE (frame);
-
- if (state->resolve_now == NULL) {
-
- state->resolve_now = &state->resolve;
- state->loc_now = &state->loc;
+ server_state_t *state = NULL;
+ xlator_t *this = NULL;
- server_resolve (frame);
+ this = frame->this;
+ state = CALL_STATE(frame);
- } else if (state->resolve_now == &state->resolve) {
+ if (state->resolve_now == NULL) {
+ state->resolve_now = &state->resolve;
+ state->loc_now = &state->loc;
- state->resolve_now = &state->resolve2;
- state->loc_now = &state->loc2;
+ server_resolve(frame);
- server_resolve (frame);
+ } else if (state->resolve_now == &state->resolve) {
+ state->resolve_now = &state->resolve2;
+ state->loc_now = &state->loc2;
- } else if (state->resolve_now == &state->resolve2) {
+ server_resolve(frame);
- server_resolve_done (frame);
+ } else if (state->resolve_now == &state->resolve2) {
+ server_resolve_done(frame);
- } else {
- gf_msg (this->name, GF_LOG_ERROR, EINVAL,
- PS_MSG_INVALID_ENTRY, "Invalid pointer for "
- "state->resolve_now");
- }
+ } else {
+ gf_msg(this->name, GF_LOG_ERROR, EINVAL, PS_MSG_INVALID_ENTRY,
+ "Invalid pointer for "
+ "state->resolve_now");
+ }
- return 0;
+ return 0;
}
-
int
-resolve_and_resume (call_frame_t *frame, server_resume_fn_t fn)
+resolve_and_resume(call_frame_t *frame, server_resume_fn_t fn)
{
- server_state_t *state = NULL;
+ server_state_t *state = NULL;
- state = CALL_STATE (frame);
- state->resume_fn = fn;
+ state = CALL_STATE(frame);
+ state->resume_fn = fn;
- server_resolve_all (frame);
+ server_resolve_all(frame);
- return 0;
+ return 0;
}
diff --git a/xlators/protocol/server/src/server-rpc-fops.c b/xlators/protocol/server/src/server-rpc-fops.c
index 8efbb8dcb9e..c621743fa06 100644
--- a/xlators/protocol/server/src/server-rpc-fops.c
+++ b/xlators/protocol/server/src/server-rpc-fops.c
@@ -8,7 +8,6 @@
cases as published by the Free Software Foundation.
*/
-
#include <openssl/md5.h>
#include "server.h"
@@ -26,6160 +25,6235 @@
#include "xdr-nfs3.h"
-#define SERVER_REQ_SET_ERROR(req, ret) \
- do { \
- rpcsvc_request_seterr (req, GARBAGE_ARGS); \
- ret = RPCSVC_ACTOR_ERROR; \
- } while (0)
-
+#define SERVER_REQ_SET_ERROR(req, ret) \
+ do { \
+ rpcsvc_request_seterr(req, GARBAGE_ARGS); \
+ ret = RPCSVC_ACTOR_ERROR; \
+ } while (0)
void
-forget_inode_if_no_dentry (inode_t *inode)
+forget_inode_if_no_dentry(inode_t *inode)
{
- if (!inode) {
- return;
- }
+ if (!inode) {
+ return;
+ }
- if (!inode_has_dentry (inode))
- inode_forget (inode, 0);
+ if (!inode_has_dentry(inode))
+ inode_forget(inode, 0);
- return;
+ return;
}
void
-set_resolve_gfid (client_t *client, uuid_t resolve_gfid,
- char *on_wire_gfid)
+set_resolve_gfid(client_t *client, uuid_t resolve_gfid, char *on_wire_gfid)
{
- if (client->subdir_mount &&
- __is_root_gfid ((unsigned char *)on_wire_gfid)) {
- /* set the subdir_mount's gfid for proper resolution */
- gf_uuid_copy (resolve_gfid, client->subdir_gfid);
- } else {
- memcpy (resolve_gfid, on_wire_gfid, 16);
- }
+ if (client->subdir_mount && __is_root_gfid((unsigned char *)on_wire_gfid)) {
+ /* set the subdir_mount's gfid for proper resolution */
+ gf_uuid_copy(resolve_gfid, client->subdir_gfid);
+ } else {
+ memcpy(resolve_gfid, on_wire_gfid, 16);
+ }
}
/* Callback function section */
int
-server_statfs_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
- int32_t op_ret, int32_t op_errno, struct statvfs *buf,
- dict_t *xdata)
+server_statfs_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+ int32_t op_ret, int32_t op_errno, struct statvfs *buf,
+ dict_t *xdata)
{
- gfs3_statfs_rsp rsp = {0,};
- rpcsvc_request_t *req = NULL;
+ gfs3_statfs_rsp rsp = {
+ 0,
+ };
+ rpcsvc_request_t *req = NULL;
- GF_PROTOCOL_DICT_SERIALIZE (this, xdata, &rsp.xdata.xdata_val,
- rsp.xdata.xdata_len, op_errno, out);
+ GF_PROTOCOL_DICT_SERIALIZE(this, xdata, &rsp.xdata.xdata_val,
+ rsp.xdata.xdata_len, op_errno, out);
- if (op_ret < 0) {
- gf_msg (this->name, GF_LOG_WARNING, op_errno, PS_MSG_STATFS,
- "%"PRId64": STATFS, client: %s, error-xlator: %s",
- frame->root->unique, STACK_CLIENT_NAME (frame->root),
- STACK_ERR_XL_NAME (frame->root));
- goto out;
- }
+ if (op_ret < 0) {
+ gf_msg(this->name, GF_LOG_WARNING, op_errno, PS_MSG_STATFS,
+ "%" PRId64 ": STATFS, client: %s, error-xlator: %s",
+ frame->root->unique, STACK_CLIENT_NAME(frame->root),
+ STACK_ERR_XL_NAME(frame->root));
+ goto out;
+ }
- server_post_statfs (&rsp, buf);
+ server_post_statfs(&rsp, buf);
out:
- rsp.op_ret = op_ret;
- rsp.op_errno = gf_errno_to_error (op_errno);
+ rsp.op_ret = op_ret;
+ rsp.op_errno = gf_errno_to_error(op_errno);
- req = frame->local;
- server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
- (xdrproc_t)xdr_gfs3_statfs_rsp);
+ req = frame->local;
+ server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gfs3_statfs_rsp);
- GF_FREE (rsp.xdata.xdata_val);
+ GF_FREE(rsp.xdata.xdata_val);
- return 0;
+ return 0;
}
int
-server_lookup_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
- int32_t op_ret, int32_t op_errno,
- inode_t *inode, struct iatt *stbuf, dict_t *xdata,
- struct iatt *postparent)
-{
- rpcsvc_request_t *req = NULL;
- server_state_t *state = NULL;
- loc_t fresh_loc = {0,};
- gfs3_lookup_rsp rsp = {0,};
-
- state = CALL_STATE (frame);
-
- if (state->is_revalidate == 1 && op_ret == -1) {
- state->is_revalidate = 2;
- loc_copy (&fresh_loc, &state->loc);
- inode_unref (fresh_loc.inode);
- fresh_loc.inode = server_inode_new (state->itable,
- fresh_loc.gfid);
-
- STACK_WIND (frame, server_lookup_cbk,
- frame->root->client->bound_xl,
- frame->root->client->bound_xl->fops->lookup,
- &fresh_loc, state->xdata);
-
- loc_wipe (&fresh_loc);
- return 0;
- }
-
- gf_stat_from_iatt (&rsp.postparent, postparent);
-
- GF_PROTOCOL_DICT_SERIALIZE (this, xdata, &rsp.xdata.xdata_val,
- rsp.xdata.xdata_len, op_errno, out);
-
- if (op_ret) {
- if (state->is_revalidate && op_errno == ENOENT) {
- if (!__is_root_gfid (state->resolve.gfid)) {
- inode_unlink (state->loc.inode,
- state->loc.parent,
- state->loc.name);
- /**
- * If the entry is not present, then just
- * unlinking the associated dentry is not
- * suffecient. This condition should be
- * treated as unlink of the entry. So along
- * with deleting the entry, its also important
- * to forget the inode for it (if the dentry
- * being considered was the last dentry).
- * Otherwise it might lead to inode leak.
- * It also might lead to wrong decisions being
- * taken if the future lookups on this inode are
- * successful since they are able to find the
- * inode in the inode table (at least gfid based
- * lookups will be successful, if the lookup
- * is a soft lookup)
- */
- forget_inode_if_no_dentry (state->loc.inode);
- }
- }
- goto out;
- }
-
- server_post_lookup (&rsp, frame, state, inode, stbuf, postparent);
+server_lookup_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+ int32_t op_ret, int32_t op_errno, inode_t *inode,
+ struct iatt *stbuf, dict_t *xdata, struct iatt *postparent)
+{
+ rpcsvc_request_t *req = NULL;
+ server_state_t *state = NULL;
+ loc_t fresh_loc = {
+ 0,
+ };
+ gfs3_lookup_rsp rsp = {
+ 0,
+ };
+
+ state = CALL_STATE(frame);
+
+ if (state->is_revalidate == 1 && op_ret == -1) {
+ state->is_revalidate = 2;
+ loc_copy(&fresh_loc, &state->loc);
+ inode_unref(fresh_loc.inode);
+ fresh_loc.inode = server_inode_new(state->itable, fresh_loc.gfid);
+
+ STACK_WIND(frame, server_lookup_cbk, frame->root->client->bound_xl,
+ frame->root->client->bound_xl->fops->lookup, &fresh_loc,
+ state->xdata);
+
+ loc_wipe(&fresh_loc);
+ return 0;
+ }
+
+ gf_stat_from_iatt(&rsp.postparent, postparent);
+
+ GF_PROTOCOL_DICT_SERIALIZE(this, xdata, &rsp.xdata.xdata_val,
+ rsp.xdata.xdata_len, op_errno, out);
+
+ if (op_ret) {
+ if (state->is_revalidate && op_errno == ENOENT) {
+ if (!__is_root_gfid(state->resolve.gfid)) {
+ inode_unlink(state->loc.inode, state->loc.parent,
+ state->loc.name);
+ /**
+ * If the entry is not present, then just
+ * unlinking the associated dentry is not
+ * suffecient. This condition should be
+ * treated as unlink of the entry. So along
+ * with deleting the entry, its also important
+ * to forget the inode for it (if the dentry
+ * being considered was the last dentry).
+ * Otherwise it might lead to inode leak.
+ * It also might lead to wrong decisions being
+ * taken if the future lookups on this inode are
+ * successful since they are able to find the
+ * inode in the inode table (at least gfid based
+ * lookups will be successful, if the lookup
+ * is a soft lookup)
+ */
+ forget_inode_if_no_dentry(state->loc.inode);
+ }
+ }
+ goto out;
+ }
+
+ server_post_lookup(&rsp, frame, state, inode, stbuf, postparent);
out:
- rsp.op_ret = op_ret;
- rsp.op_errno = gf_errno_to_error (op_errno);
-
- if (op_ret) {
- if (state->resolve.bname) {
- gf_msg (this->name,
- fop_log_level (GF_FOP_LOOKUP, op_errno),
- op_errno, PS_MSG_LOOKUP_INFO,
- "%"PRId64": LOOKUP %s (%s/%s), client: %s, "
- "error-xlator: %s", frame->root->unique,
- state->loc.path,
- uuid_utoa (state->resolve.pargfid),
- state->resolve.bname,
- STACK_CLIENT_NAME (frame->root),
- STACK_ERR_XL_NAME (frame->root));
- } else {
- gf_msg (this->name,
- fop_log_level (GF_FOP_LOOKUP, op_errno),
- op_errno, PS_MSG_LOOKUP_INFO,
- "%"PRId64": LOOKUP %s (%s), client: %s, "
- "error-xlator: %s",
- frame->root->unique, state->loc.path,
- uuid_utoa (state->resolve.gfid),
- STACK_CLIENT_NAME (frame->root),
- STACK_ERR_XL_NAME (frame->root));
- }
+ rsp.op_ret = op_ret;
+ rsp.op_errno = gf_errno_to_error(op_errno);
+
+ if (op_ret) {
+ if (state->resolve.bname) {
+ gf_msg(this->name, fop_log_level(GF_FOP_LOOKUP, op_errno), op_errno,
+ PS_MSG_LOOKUP_INFO,
+ "%" PRId64
+ ": LOOKUP %s (%s/%s), client: %s, "
+ "error-xlator: %s",
+ frame->root->unique, state->loc.path,
+ uuid_utoa(state->resolve.pargfid), state->resolve.bname,
+ STACK_CLIENT_NAME(frame->root),
+ STACK_ERR_XL_NAME(frame->root));
+ } else {
+ gf_msg(this->name, fop_log_level(GF_FOP_LOOKUP, op_errno), op_errno,
+ PS_MSG_LOOKUP_INFO,
+ "%" PRId64
+ ": LOOKUP %s (%s), client: %s, "
+ "error-xlator: %s",
+ frame->root->unique, state->loc.path,
+ uuid_utoa(state->resolve.gfid),
+ STACK_CLIENT_NAME(frame->root),
+ STACK_ERR_XL_NAME(frame->root));
}
+ }
- req = frame->local;
- server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
- (xdrproc_t)xdr_gfs3_lookup_rsp);
+ req = frame->local;
+ server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gfs3_lookup_rsp);
- GF_FREE (rsp.xdata.xdata_val);
+ GF_FREE(rsp.xdata.xdata_val);
- return 0;
+ return 0;
}
int
-server_lease_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
- int32_t op_ret, int32_t op_errno, struct gf_lease *lease,
- dict_t *xdata)
+server_lease_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+ int32_t op_ret, int32_t op_errno, struct gf_lease *lease,
+ dict_t *xdata)
{
- gfs3_lease_rsp rsp = {0,};
- rpcsvc_request_t *req = NULL;
- server_state_t *state = NULL;
-
- GF_PROTOCOL_DICT_SERIALIZE (this, xdata, &rsp.xdata.xdata_val,
- rsp.xdata.xdata_len, op_errno, out);
-
- if (op_ret) {
- state = CALL_STATE (frame);
- gf_msg (this->name, fop_log_level (GF_FOP_LEASE, op_errno),
- op_errno, PS_MSG_LK_INFO,
- "%"PRId64": LEASE %s (%s), client: %s, error-xlator: %s",
- frame->root->unique, state->loc.path,
- uuid_utoa (state->resolve.gfid),
- STACK_CLIENT_NAME (frame->root),
- STACK_ERR_XL_NAME (frame->root));
- goto out;
- }
- server_post_lease (&rsp, lease);
+ gfs3_lease_rsp rsp = {
+ 0,
+ };
+ rpcsvc_request_t *req = NULL;
+ server_state_t *state = NULL;
+
+ GF_PROTOCOL_DICT_SERIALIZE(this, xdata, &rsp.xdata.xdata_val,
+ rsp.xdata.xdata_len, op_errno, out);
+
+ if (op_ret) {
+ state = CALL_STATE(frame);
+ gf_msg(this->name, fop_log_level(GF_FOP_LEASE, op_errno), op_errno,
+ PS_MSG_LK_INFO,
+ "%" PRId64 ": LEASE %s (%s), client: %s, error-xlator: %s",
+ frame->root->unique, state->loc.path,
+ uuid_utoa(state->resolve.gfid), STACK_CLIENT_NAME(frame->root),
+ STACK_ERR_XL_NAME(frame->root));
+ goto out;
+ }
+ server_post_lease(&rsp, lease);
out:
- rsp.op_ret = op_ret;
- rsp.op_errno = gf_errno_to_error (op_errno);
+ rsp.op_ret = op_ret;
+ rsp.op_errno = gf_errno_to_error(op_errno);
- req = frame->local;
- server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
- (xdrproc_t)xdr_gfs3_lease_rsp);
+ req = frame->local;
+ server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gfs3_lease_rsp);
- GF_FREE (rsp.xdata.xdata_val);
+ GF_FREE(rsp.xdata.xdata_val);
- return 0;
+ return 0;
}
int
-server_lk_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
- int32_t op_ret, int32_t op_errno, struct gf_flock *lock,
- dict_t *xdata)
+server_lk_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret,
+ int32_t op_errno, struct gf_flock *lock, dict_t *xdata)
{
- gfs3_lk_rsp rsp = {0,};
- rpcsvc_request_t *req = NULL;
- server_state_t *state = NULL;
+ gfs3_lk_rsp rsp = {
+ 0,
+ };
+ rpcsvc_request_t *req = NULL;
+ server_state_t *state = NULL;
- GF_PROTOCOL_DICT_SERIALIZE (this, xdata, &rsp.xdata.xdata_val,
- rsp.xdata.xdata_len, op_errno, out);
+ GF_PROTOCOL_DICT_SERIALIZE(this, xdata, &rsp.xdata.xdata_val,
+ rsp.xdata.xdata_len, op_errno, out);
- if (op_ret) {
- state = CALL_STATE (frame);
- gf_msg (this->name, fop_log_level (GF_FOP_LK, op_errno),
- op_errno, PS_MSG_LK_INFO,
- "%"PRId64": LK %"PRId64" (%s), client: %s, "
- "error-xlator: %s", frame->root->unique,
- state->resolve.fd_no, uuid_utoa (state->resolve.gfid),
- STACK_CLIENT_NAME (frame->root),
- STACK_ERR_XL_NAME (frame->root));
- goto out;
- }
+ if (op_ret) {
+ state = CALL_STATE(frame);
+ gf_msg(this->name, fop_log_level(GF_FOP_LK, op_errno), op_errno,
+ PS_MSG_LK_INFO,
+ "%" PRId64 ": LK %" PRId64
+ " (%s), client: %s, "
+ "error-xlator: %s",
+ frame->root->unique, state->resolve.fd_no,
+ uuid_utoa(state->resolve.gfid), STACK_CLIENT_NAME(frame->root),
+ STACK_ERR_XL_NAME(frame->root));
+ goto out;
+ }
- server_post_lk (this, &rsp, lock);
+ server_post_lk(this, &rsp, lock);
out:
- rsp.op_ret = op_ret;
- rsp.op_errno = gf_errno_to_error (op_errno);
+ rsp.op_ret = op_ret;
+ rsp.op_errno = gf_errno_to_error(op_errno);
- req = frame->local;
- server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
- (xdrproc_t)xdr_gfs3_lk_rsp);
+ req = frame->local;
+ server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gfs3_lk_rsp);
- GF_FREE (rsp.xdata.xdata_val);
+ GF_FREE(rsp.xdata.xdata_val);
- return 0;
+ return 0;
}
-
int
-server_inodelk_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
- int32_t op_ret, int32_t op_errno, dict_t *xdata)
+server_inodelk_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+ int32_t op_ret, int32_t op_errno, dict_t *xdata)
{
- gf_common_rsp rsp = {0,};
- server_state_t *state = NULL;
- rpcsvc_request_t *req = NULL;
-
- GF_PROTOCOL_DICT_SERIALIZE (this, xdata, &rsp.xdata.xdata_val,
- rsp.xdata.xdata_len, op_errno, out);
-
- state = CALL_STATE (frame);
-
- if (op_ret < 0) {
- gf_msg (this->name, fop_log_level (GF_FOP_INODELK, op_errno),
- op_errno, PS_MSG_INODELK_INFO,
- "%"PRId64": INODELK %s (%s), client: %s, "
- "error-xlator: %s", frame->root->unique,
- state->loc.path, uuid_utoa (state->resolve.gfid),
- STACK_CLIENT_NAME (frame->root),
- STACK_ERR_XL_NAME (frame->root));
- goto out;
- }
+ gf_common_rsp rsp = {
+ 0,
+ };
+ server_state_t *state = NULL;
+ rpcsvc_request_t *req = NULL;
+
+ GF_PROTOCOL_DICT_SERIALIZE(this, xdata, &rsp.xdata.xdata_val,
+ rsp.xdata.xdata_len, op_errno, out);
+
+ state = CALL_STATE(frame);
+
+ if (op_ret < 0) {
+ gf_msg(this->name, fop_log_level(GF_FOP_INODELK, op_errno), op_errno,
+ PS_MSG_INODELK_INFO,
+ "%" PRId64
+ ": INODELK %s (%s), client: %s, "
+ "error-xlator: %s",
+ frame->root->unique, state->loc.path,
+ uuid_utoa(state->resolve.gfid), STACK_CLIENT_NAME(frame->root),
+ STACK_ERR_XL_NAME(frame->root));
+ goto out;
+ }
out:
- rsp.op_ret = op_ret;
- rsp.op_errno = gf_errno_to_error (op_errno);
+ rsp.op_ret = op_ret;
+ rsp.op_errno = gf_errno_to_error(op_errno);
- req = frame->local;
- server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
- (xdrproc_t)xdr_gf_common_rsp);
+ req = frame->local;
+ server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gf_common_rsp);
- GF_FREE (rsp.xdata.xdata_val);
+ GF_FREE(rsp.xdata.xdata_val);
- return 0;
+ return 0;
}
-
int
-server_finodelk_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
- int32_t op_ret, int32_t op_errno, dict_t *xdata)
+server_finodelk_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+ int32_t op_ret, int32_t op_errno, dict_t *xdata)
{
- gf_common_rsp rsp = {0,};
- server_state_t *state = NULL;
- rpcsvc_request_t *req = NULL;
-
- GF_PROTOCOL_DICT_SERIALIZE (this, xdata, &rsp.xdata.xdata_val,
- rsp.xdata.xdata_len, op_errno, out);
-
- state = CALL_STATE (frame);
-
- if (op_ret < 0) {
- gf_msg (this->name, fop_log_level (GF_FOP_FINODELK, op_errno),
- op_errno, PS_MSG_INODELK_INFO,
- "%"PRId64": FINODELK %"PRId64" (%s), client: %s, "
- "error-xlator: %s", frame->root->unique,
- state->resolve.fd_no, uuid_utoa (state->resolve.gfid),
- STACK_CLIENT_NAME (frame->root),
- STACK_ERR_XL_NAME (frame->root));
- goto out;
- }
+ gf_common_rsp rsp = {
+ 0,
+ };
+ server_state_t *state = NULL;
+ rpcsvc_request_t *req = NULL;
+
+ GF_PROTOCOL_DICT_SERIALIZE(this, xdata, &rsp.xdata.xdata_val,
+ rsp.xdata.xdata_len, op_errno, out);
+
+ state = CALL_STATE(frame);
+
+ if (op_ret < 0) {
+ gf_msg(this->name, fop_log_level(GF_FOP_FINODELK, op_errno), op_errno,
+ PS_MSG_INODELK_INFO,
+ "%" PRId64 ": FINODELK %" PRId64
+ " (%s), client: %s, "
+ "error-xlator: %s",
+ frame->root->unique, state->resolve.fd_no,
+ uuid_utoa(state->resolve.gfid), STACK_CLIENT_NAME(frame->root),
+ STACK_ERR_XL_NAME(frame->root));
+ goto out;
+ }
out:
- rsp.op_ret = op_ret;
- rsp.op_errno = gf_errno_to_error (op_errno);
+ rsp.op_ret = op_ret;
+ rsp.op_errno = gf_errno_to_error(op_errno);
- req = frame->local;
- server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
- (xdrproc_t)xdr_gf_common_rsp);
+ req = frame->local;
+ server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gf_common_rsp);
- GF_FREE (rsp.xdata.xdata_val);
+ GF_FREE(rsp.xdata.xdata_val);
- return 0;
+ return 0;
}
int
-server_entrylk_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
- int32_t op_ret, int32_t op_errno, dict_t *xdata)
+server_entrylk_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+ int32_t op_ret, int32_t op_errno, dict_t *xdata)
{
- gf_common_rsp rsp = {0,};
- server_state_t *state = NULL;
- rpcsvc_request_t *req = NULL;
-
- GF_PROTOCOL_DICT_SERIALIZE (this, xdata, &rsp.xdata.xdata_val,
- rsp.xdata.xdata_len, op_errno, out);
-
- state = CALL_STATE (frame);
-
- if (op_ret < 0) {
- gf_msg (this->name, fop_log_level (GF_FOP_ENTRYLK, op_errno),
- op_errno, PS_MSG_ENTRYLK_INFO,
- "%"PRId64": ENTRYLK %s (%s), client: %s, "
- "error-xlator: %s", frame->root->unique,
- state->loc.path, uuid_utoa (state->resolve.gfid),
- STACK_CLIENT_NAME (frame->root),
- STACK_ERR_XL_NAME (frame->root));
- goto out;
- }
+ gf_common_rsp rsp = {
+ 0,
+ };
+ server_state_t *state = NULL;
+ rpcsvc_request_t *req = NULL;
+
+ GF_PROTOCOL_DICT_SERIALIZE(this, xdata, &rsp.xdata.xdata_val,
+ rsp.xdata.xdata_len, op_errno, out);
+
+ state = CALL_STATE(frame);
+
+ if (op_ret < 0) {
+ gf_msg(this->name, fop_log_level(GF_FOP_ENTRYLK, op_errno), op_errno,
+ PS_MSG_ENTRYLK_INFO,
+ "%" PRId64
+ ": ENTRYLK %s (%s), client: %s, "
+ "error-xlator: %s",
+ frame->root->unique, state->loc.path,
+ uuid_utoa(state->resolve.gfid), STACK_CLIENT_NAME(frame->root),
+ STACK_ERR_XL_NAME(frame->root));
+ goto out;
+ }
out:
- rsp.op_ret = op_ret;
- rsp.op_errno = gf_errno_to_error (op_errno);
+ rsp.op_ret = op_ret;
+ rsp.op_errno = gf_errno_to_error(op_errno);
- req = frame->local;
- server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
- (xdrproc_t)xdr_gf_common_rsp);
+ req = frame->local;
+ server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gf_common_rsp);
- GF_FREE (rsp.xdata.xdata_val);
+ GF_FREE(rsp.xdata.xdata_val);
- return 0;
+ return 0;
}
-
int
-server_fentrylk_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
- int32_t op_ret, int32_t op_errno, dict_t *xdata)
+server_fentrylk_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+ int32_t op_ret, int32_t op_errno, dict_t *xdata)
{
- gf_common_rsp rsp = {0,};
- server_state_t *state = NULL;
- rpcsvc_request_t *req = NULL;
-
- GF_PROTOCOL_DICT_SERIALIZE (this, xdata, &rsp.xdata.xdata_val,
- rsp.xdata.xdata_len, op_errno, out);
-
- state = CALL_STATE (frame);
-
- if (op_ret < 0) {
- gf_msg (this->name, fop_log_level (GF_FOP_FENTRYLK, op_errno),
- op_errno, PS_MSG_ENTRYLK_INFO,
- "%"PRId64": FENTRYLK %"PRId64" (%s), client: %s, "
- "error-xlator: %s", frame->root->unique,
- state->resolve.fd_no, uuid_utoa (state->resolve.gfid),
- STACK_CLIENT_NAME (frame->root),
- STACK_ERR_XL_NAME (frame->root));
- goto out;
- }
+ gf_common_rsp rsp = {
+ 0,
+ };
+ server_state_t *state = NULL;
+ rpcsvc_request_t *req = NULL;
+
+ GF_PROTOCOL_DICT_SERIALIZE(this, xdata, &rsp.xdata.xdata_val,
+ rsp.xdata.xdata_len, op_errno, out);
+
+ state = CALL_STATE(frame);
+
+ if (op_ret < 0) {
+ gf_msg(this->name, fop_log_level(GF_FOP_FENTRYLK, op_errno), op_errno,
+ PS_MSG_ENTRYLK_INFO,
+ "%" PRId64 ": FENTRYLK %" PRId64
+ " (%s), client: %s, "
+ "error-xlator: %s",
+ frame->root->unique, state->resolve.fd_no,
+ uuid_utoa(state->resolve.gfid), STACK_CLIENT_NAME(frame->root),
+ STACK_ERR_XL_NAME(frame->root));
+ goto out;
+ }
out:
- rsp.op_ret = op_ret;
- rsp.op_errno = gf_errno_to_error (op_errno);
+ rsp.op_ret = op_ret;
+ rsp.op_errno = gf_errno_to_error(op_errno);
- req = frame->local;
- server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
- (xdrproc_t)xdr_gf_common_rsp);
+ req = frame->local;
+ server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gf_common_rsp);
- GF_FREE (rsp.xdata.xdata_val);
+ GF_FREE(rsp.xdata.xdata_val);
- return 0;
+ return 0;
}
-
int
-server_access_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
- int32_t op_ret, int32_t op_errno, dict_t *xdata)
+server_access_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+ int32_t op_ret, int32_t op_errno, dict_t *xdata)
{
- gf_common_rsp rsp = {0,};
- rpcsvc_request_t *req = NULL;
- server_state_t *state = NULL;
-
- GF_PROTOCOL_DICT_SERIALIZE (this, xdata, &rsp.xdata.xdata_val,
- rsp.xdata.xdata_len, op_errno, out);
-
- if (op_ret) {
- state = CALL_STATE (frame);
- gf_msg (this->name, GF_LOG_INFO,
- op_errno, PS_MSG_ACCESS_INFO,
- "%"PRId64": ACCESS %s (%s), client: %s, "
- "error-xlator: %s", frame->root->unique,
- (state->loc.path) ? state->loc.path : "",
- uuid_utoa (state->resolve.gfid),
- STACK_CLIENT_NAME (frame->root),
- STACK_ERR_XL_NAME (frame->root));
- goto out;
- }
+ gf_common_rsp rsp = {
+ 0,
+ };
+ rpcsvc_request_t *req = NULL;
+ server_state_t *state = NULL;
+
+ GF_PROTOCOL_DICT_SERIALIZE(this, xdata, &rsp.xdata.xdata_val,
+ rsp.xdata.xdata_len, op_errno, out);
+
+ if (op_ret) {
+ state = CALL_STATE(frame);
+ gf_msg(this->name, GF_LOG_INFO, op_errno, PS_MSG_ACCESS_INFO,
+ "%" PRId64
+ ": ACCESS %s (%s), client: %s, "
+ "error-xlator: %s",
+ frame->root->unique, (state->loc.path) ? state->loc.path : "",
+ uuid_utoa(state->resolve.gfid), STACK_CLIENT_NAME(frame->root),
+ STACK_ERR_XL_NAME(frame->root));
+ goto out;
+ }
out:
- rsp.op_ret = op_ret;
- rsp.op_errno = gf_errno_to_error (op_errno);
+ rsp.op_ret = op_ret;
+ rsp.op_errno = gf_errno_to_error(op_errno);
- req = frame->local;
- server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
- (xdrproc_t)xdr_gf_common_rsp);
+ req = frame->local;
+ server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gf_common_rsp);
- GF_FREE (rsp.xdata.xdata_val);
+ GF_FREE(rsp.xdata.xdata_val);
- return 0;
+ return 0;
}
int
-server_rmdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
- int32_t op_ret, int32_t op_errno, struct iatt *preparent,
- struct iatt *postparent, dict_t *xdata)
+server_rmdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+ int32_t op_ret, int32_t op_errno, struct iatt *preparent,
+ struct iatt *postparent, dict_t *xdata)
{
- gfs3_rmdir_rsp rsp = {0,};
- server_state_t *state = NULL;
- rpcsvc_request_t *req = NULL;
+ gfs3_rmdir_rsp rsp = {
+ 0,
+ };
+ server_state_t *state = NULL;
+ rpcsvc_request_t *req = NULL;
- GF_PROTOCOL_DICT_SERIALIZE (this, xdata, &rsp.xdata.xdata_val,
- rsp.xdata.xdata_len, op_errno, out);
+ GF_PROTOCOL_DICT_SERIALIZE(this, xdata, &rsp.xdata.xdata_val,
+ rsp.xdata.xdata_len, op_errno, out);
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (op_ret) {
- gf_msg (this->name, GF_LOG_INFO,
- op_errno, PS_MSG_DIR_INFO,
- "%"PRId64": RMDIR %s (%s/%s), client: %s, "
- "error-xlator: %s", frame->root->unique,
- (state->loc.path) ? state->loc.path : "",
- uuid_utoa (state->resolve.pargfid),
- state->resolve.bname, STACK_CLIENT_NAME (frame->root),
- STACK_ERR_XL_NAME (frame->root));
- goto out;
- }
+ if (op_ret) {
+ gf_msg(this->name, GF_LOG_INFO, op_errno, PS_MSG_DIR_INFO,
+ "%" PRId64
+ ": RMDIR %s (%s/%s), client: %s, "
+ "error-xlator: %s",
+ frame->root->unique, (state->loc.path) ? state->loc.path : "",
+ uuid_utoa(state->resolve.pargfid), state->resolve.bname,
+ STACK_CLIENT_NAME(frame->root), STACK_ERR_XL_NAME(frame->root));
+ goto out;
+ }
- server_post_rmdir (state, &rsp, preparent, postparent);
+ server_post_rmdir(state, &rsp, preparent, postparent);
out:
- rsp.op_ret = op_ret;
- rsp.op_errno = gf_errno_to_error (op_errno);
+ rsp.op_ret = op_ret;
+ rsp.op_errno = gf_errno_to_error(op_errno);
- req = frame->local;
- server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
- (xdrproc_t)xdr_gfs3_rmdir_rsp);
+ req = frame->local;
+ server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gfs3_rmdir_rsp);
- GF_FREE (rsp.xdata.xdata_val);
+ GF_FREE(rsp.xdata.xdata_val);
- return 0;
+ return 0;
}
int
-server_mkdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
- int32_t op_ret, int32_t op_errno, inode_t *inode,
- struct iatt *stbuf, struct iatt *preparent,
- struct iatt *postparent, dict_t *xdata)
+server_mkdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+ int32_t op_ret, int32_t op_errno, inode_t *inode,
+ struct iatt *stbuf, struct iatt *preparent,
+ struct iatt *postparent, dict_t *xdata)
{
- gfs3_mkdir_rsp rsp = {0,};
- server_state_t *state = NULL;
- rpcsvc_request_t *req = NULL;
-
- GF_PROTOCOL_DICT_SERIALIZE (this, xdata, &rsp.xdata.xdata_val,
- rsp.xdata.xdata_len, op_errno, out);
-
- state = CALL_STATE (frame);
-
- if (op_ret < 0) {
- gf_msg (this->name, fop_log_level (GF_FOP_MKDIR, op_errno),
- op_errno, PS_MSG_DIR_INFO,
- "%"PRId64": MKDIR %s (%s/%s) client: %s, "
- "error-xlator: %s", frame->root->unique,
- (state->loc.path) ? state->loc.path : "",
- uuid_utoa (state->resolve.pargfid),
- state->resolve.bname,
- STACK_CLIENT_NAME (frame->root),
- STACK_ERR_XL_NAME (frame->root));
- goto out;
- }
-
- server_post_mkdir (state, &rsp, inode, stbuf, preparent,
- postparent, xdata);
+ gfs3_mkdir_rsp rsp = {
+ 0,
+ };
+ server_state_t *state = NULL;
+ rpcsvc_request_t *req = NULL;
+
+ GF_PROTOCOL_DICT_SERIALIZE(this, xdata, &rsp.xdata.xdata_val,
+ rsp.xdata.xdata_len, op_errno, out);
+
+ state = CALL_STATE(frame);
+
+ if (op_ret < 0) {
+ gf_msg(this->name, fop_log_level(GF_FOP_MKDIR, op_errno), op_errno,
+ PS_MSG_DIR_INFO,
+ "%" PRId64
+ ": MKDIR %s (%s/%s) client: %s, "
+ "error-xlator: %s",
+ frame->root->unique, (state->loc.path) ? state->loc.path : "",
+ uuid_utoa(state->resolve.pargfid), state->resolve.bname,
+ STACK_CLIENT_NAME(frame->root), STACK_ERR_XL_NAME(frame->root));
+ goto out;
+ }
+
+ server_post_mkdir(state, &rsp, inode, stbuf, preparent, postparent, xdata);
out:
- rsp.op_ret = op_ret;
- rsp.op_errno = gf_errno_to_error (op_errno);
+ rsp.op_ret = op_ret;
+ rsp.op_errno = gf_errno_to_error(op_errno);
- req = frame->local;
- server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
- (xdrproc_t)xdr_gfs3_mkdir_rsp);
+ req = frame->local;
+ server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gfs3_mkdir_rsp);
- GF_FREE (rsp.xdata.xdata_val);
+ GF_FREE(rsp.xdata.xdata_val);
- return 0;
+ return 0;
}
int
-server_mknod_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
- int32_t op_ret, int32_t op_errno,
- inode_t *inode, struct iatt *stbuf, struct iatt *preparent,
- struct iatt *postparent, dict_t *xdata)
+server_mknod_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+ int32_t op_ret, int32_t op_errno, inode_t *inode,
+ struct iatt *stbuf, struct iatt *preparent,
+ struct iatt *postparent, dict_t *xdata)
{
- gfs3_mknod_rsp rsp = {0,};
- server_state_t *state = NULL;
- rpcsvc_request_t *req = NULL;
-
- GF_PROTOCOL_DICT_SERIALIZE (this, xdata, &rsp.xdata.xdata_val,
- rsp.xdata.xdata_len, op_errno, out);
-
- state = CALL_STATE (frame);
-
- if (op_ret < 0) {
- gf_msg (this->name, fop_log_level (GF_FOP_MKNOD, op_errno),
- op_errno, PS_MSG_MKNOD_INFO,
- "%"PRId64": MKNOD %s (%s/%s), client: %s, "
- "error-xlator: %s", frame->root->unique,
- state->loc.path, uuid_utoa (state->resolve.pargfid),
- state->resolve.bname, STACK_CLIENT_NAME (frame->root),
- STACK_ERR_XL_NAME (frame->root));
- goto out;
- }
-
- server_post_mknod (state, &rsp, stbuf, preparent, postparent,
- inode);
+ gfs3_mknod_rsp rsp = {
+ 0,
+ };
+ server_state_t *state = NULL;
+ rpcsvc_request_t *req = NULL;
+
+ GF_PROTOCOL_DICT_SERIALIZE(this, xdata, &rsp.xdata.xdata_val,
+ rsp.xdata.xdata_len, op_errno, out);
+
+ state = CALL_STATE(frame);
+
+ if (op_ret < 0) {
+ gf_msg(this->name, fop_log_level(GF_FOP_MKNOD, op_errno), op_errno,
+ PS_MSG_MKNOD_INFO,
+ "%" PRId64
+ ": MKNOD %s (%s/%s), client: %s, "
+ "error-xlator: %s",
+ frame->root->unique, state->loc.path,
+ uuid_utoa(state->resolve.pargfid), state->resolve.bname,
+ STACK_CLIENT_NAME(frame->root), STACK_ERR_XL_NAME(frame->root));
+ goto out;
+ }
+
+ server_post_mknod(state, &rsp, stbuf, preparent, postparent, inode);
out:
- rsp.op_ret = op_ret;
- rsp.op_errno = gf_errno_to_error (op_errno);
+ rsp.op_ret = op_ret;
+ rsp.op_errno = gf_errno_to_error(op_errno);
- req = frame->local;
- server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
- (xdrproc_t)xdr_gfs3_mknod_rsp);
+ req = frame->local;
+ server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gfs3_mknod_rsp);
- GF_FREE (rsp.xdata.xdata_val);
+ GF_FREE(rsp.xdata.xdata_val);
- return 0;
+ return 0;
}
int
-server_fsyncdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
- int32_t op_ret, int32_t op_errno, dict_t *xdata)
+server_fsyncdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+ int32_t op_ret, int32_t op_errno, dict_t *xdata)
{
- gf_common_rsp rsp = {0,};
- server_state_t *state = NULL;
- rpcsvc_request_t *req = NULL;
-
- GF_PROTOCOL_DICT_SERIALIZE (this, xdata, &rsp.xdata.xdata_val,
- rsp.xdata.xdata_len, op_errno, out);
-
- if (op_ret < 0) {
- state = CALL_STATE (frame);
- gf_msg (this->name, fop_log_level (GF_FOP_FSYNCDIR, op_errno),
- op_errno, PS_MSG_DIR_INFO,
- "%"PRId64": FSYNCDIR %"PRId64" (%s), client: %s, "
- "error-xlator: %s", frame->root->unique,
- state->resolve.fd_no, uuid_utoa (state->resolve.gfid),
- STACK_CLIENT_NAME (frame->root),
- STACK_ERR_XL_NAME (frame->root));
- goto out;
- }
+ gf_common_rsp rsp = {
+ 0,
+ };
+ server_state_t *state = NULL;
+ rpcsvc_request_t *req = NULL;
+
+ GF_PROTOCOL_DICT_SERIALIZE(this, xdata, &rsp.xdata.xdata_val,
+ rsp.xdata.xdata_len, op_errno, out);
+
+ if (op_ret < 0) {
+ state = CALL_STATE(frame);
+ gf_msg(this->name, fop_log_level(GF_FOP_FSYNCDIR, op_errno), op_errno,
+ PS_MSG_DIR_INFO,
+ "%" PRId64 ": FSYNCDIR %" PRId64
+ " (%s), client: %s, "
+ "error-xlator: %s",
+ frame->root->unique, state->resolve.fd_no,
+ uuid_utoa(state->resolve.gfid), STACK_CLIENT_NAME(frame->root),
+ STACK_ERR_XL_NAME(frame->root));
+ goto out;
+ }
out:
- rsp.op_ret = op_ret;
- rsp.op_errno = gf_errno_to_error (op_errno);
+ rsp.op_ret = op_ret;
+ rsp.op_errno = gf_errno_to_error(op_errno);
- req = frame->local;
- server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
- (xdrproc_t)xdr_gf_common_rsp);
+ req = frame->local;
+ server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gf_common_rsp);
- GF_FREE (rsp.xdata.xdata_val);
+ GF_FREE(rsp.xdata.xdata_val);
- return 0;
+ return 0;
}
int
-server_readdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
- int32_t op_ret, int32_t op_errno, gf_dirent_t *entries,
- dict_t *xdata)
+server_readdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+ int32_t op_ret, int32_t op_errno, gf_dirent_t *entries,
+ dict_t *xdata)
{
- gfs3_readdir_rsp rsp = {0,};
- server_state_t *state = NULL;
- rpcsvc_request_t *req = NULL;
- int ret = 0;
-
- GF_PROTOCOL_DICT_SERIALIZE (this, xdata, &rsp.xdata.xdata_val,
- rsp.xdata.xdata_len, op_errno, out);
-
- if (op_ret < 0) {
- state = CALL_STATE (frame);
- gf_msg (this->name, fop_log_level (GF_FOP_READDIR, op_errno),
- op_errno, PS_MSG_DIR_INFO,
- "%"PRId64": READDIR %"PRId64" (%s), client: %s, "
- "error-xlator: %s", frame->root->unique,
- state->resolve.fd_no, uuid_utoa (state->resolve.gfid),
- STACK_CLIENT_NAME (frame->root),
- STACK_ERR_XL_NAME (frame->root));
- goto out;
- }
-
- /* (op_ret == 0) is valid, and means EOF */
- if (op_ret) {
- ret = server_post_readdir (&rsp, entries);
- if (ret == -1) {
- op_ret = -1;
- op_errno = ENOMEM;
- goto out;
- }
- }
+ gfs3_readdir_rsp rsp = {
+ 0,
+ };
+ server_state_t *state = NULL;
+ rpcsvc_request_t *req = NULL;
+ int ret = 0;
+
+ GF_PROTOCOL_DICT_SERIALIZE(this, xdata, &rsp.xdata.xdata_val,
+ rsp.xdata.xdata_len, op_errno, out);
+
+ if (op_ret < 0) {
+ state = CALL_STATE(frame);
+ gf_msg(this->name, fop_log_level(GF_FOP_READDIR, op_errno), op_errno,
+ PS_MSG_DIR_INFO,
+ "%" PRId64 ": READDIR %" PRId64
+ " (%s), client: %s, "
+ "error-xlator: %s",
+ frame->root->unique, state->resolve.fd_no,
+ uuid_utoa(state->resolve.gfid), STACK_CLIENT_NAME(frame->root),
+ STACK_ERR_XL_NAME(frame->root));
+ goto out;
+ }
+
+ /* (op_ret == 0) is valid, and means EOF */
+ if (op_ret) {
+ ret = server_post_readdir(&rsp, entries);
+ if (ret == -1) {
+ op_ret = -1;
+ op_errno = ENOMEM;
+ goto out;
+ }
+ }
out:
- rsp.op_ret = op_ret;
- rsp.op_errno = gf_errno_to_error (op_errno);
+ rsp.op_ret = op_ret;
+ rsp.op_errno = gf_errno_to_error(op_errno);
- req = frame->local;
- server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
- (xdrproc_t)xdr_gfs3_readdir_rsp);
+ req = frame->local;
+ server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gfs3_readdir_rsp);
- GF_FREE (rsp.xdata.xdata_val);
+ GF_FREE(rsp.xdata.xdata_val);
- readdir_rsp_cleanup (&rsp);
+ readdir_rsp_cleanup(&rsp);
- return 0;
+ return 0;
}
int
-server_opendir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
- int32_t op_ret, int32_t op_errno, fd_t *fd, dict_t *xdata)
+server_opendir_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+ int32_t op_ret, int32_t op_errno, fd_t *fd, dict_t *xdata)
{
- server_state_t *state = NULL;
- rpcsvc_request_t *req = NULL;
- gfs3_opendir_rsp rsp = {0,};
- uint64_t fd_no = 0;
-
- GF_PROTOCOL_DICT_SERIALIZE (this, xdata, &rsp.xdata.xdata_val,
- rsp.xdata.xdata_len, op_errno, out);
+ server_state_t *state = NULL;
+ rpcsvc_request_t *req = NULL;
+ gfs3_opendir_rsp rsp = {
+ 0,
+ };
+ uint64_t fd_no = 0;
- if (op_ret < 0) {
- state = CALL_STATE (frame);
- gf_msg (this->name, fop_log_level (GF_FOP_OPENDIR, op_errno),
- op_errno, PS_MSG_DIR_INFO,
- "%"PRId64": OPENDIR %s (%s), client: %s, "
- "error-xlator: %s", frame->root->unique,
- (state->loc.path) ? state->loc.path : "",
- uuid_utoa (state->resolve.gfid),
- STACK_CLIENT_NAME (frame->root),
- STACK_ERR_XL_NAME (frame->root));
- goto out;
- }
+ GF_PROTOCOL_DICT_SERIALIZE(this, xdata, &rsp.xdata.xdata_val,
+ rsp.xdata.xdata_len, op_errno, out);
+ if (op_ret < 0) {
+ state = CALL_STATE(frame);
+ gf_msg(this->name, fop_log_level(GF_FOP_OPENDIR, op_errno), op_errno,
+ PS_MSG_DIR_INFO,
+ "%" PRId64
+ ": OPENDIR %s (%s), client: %s, "
+ "error-xlator: %s",
+ frame->root->unique, (state->loc.path) ? state->loc.path : "",
+ uuid_utoa(state->resolve.gfid), STACK_CLIENT_NAME(frame->root),
+ STACK_ERR_XL_NAME(frame->root));
+ goto out;
+ }
- op_ret = server_post_opendir (frame, this, &rsp, fd);
- if (op_ret)
- goto out;
+ op_ret = server_post_opendir(frame, this, &rsp, fd);
+ if (op_ret)
+ goto out;
out:
- if (op_ret)
- rsp.fd = fd_no;
- rsp.op_ret = op_ret;
- rsp.op_errno = gf_errno_to_error (op_errno);
+ if (op_ret)
+ rsp.fd = fd_no;
+ rsp.op_ret = op_ret;
+ rsp.op_errno = gf_errno_to_error(op_errno);
- req = frame->local;
- server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
- (xdrproc_t)xdr_gfs3_opendir_rsp);
+ req = frame->local;
+ server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gfs3_opendir_rsp);
- GF_FREE (rsp.xdata.xdata_val);
+ GF_FREE(rsp.xdata.xdata_val);
- return 0;
+ return 0;
}
int
-server_removexattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
- int32_t op_ret, int32_t op_errno, dict_t *xdata)
+server_removexattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+ int32_t op_ret, int32_t op_errno, dict_t *xdata)
{
- gf_common_rsp rsp = {0,};
- rpcsvc_request_t *req = NULL;
- server_state_t *state = NULL;
- gf_loglevel_t loglevel = GF_LOG_NONE;
+ gf_common_rsp rsp = {
+ 0,
+ };
+ rpcsvc_request_t *req = NULL;
+ server_state_t *state = NULL;
+ gf_loglevel_t loglevel = GF_LOG_NONE;
- if (gf_replace_old_iatt_in_dict (xdata)) {
- op_errno = errno;
- op_ret = -1;
- goto out;
- }
+ if (gf_replace_old_iatt_in_dict(xdata)) {
+ op_errno = errno;
+ op_ret = -1;
+ goto out;
+ }
- GF_PROTOCOL_DICT_SERIALIZE (this, xdata, &rsp.xdata.xdata_val,
- rsp.xdata.xdata_len, op_errno, out);
-
- if (op_ret == -1) {
- state = CALL_STATE (frame);
- if (ENODATA == op_errno || ENOATTR == op_errno)
- loglevel = GF_LOG_DEBUG;
- else
- loglevel = GF_LOG_INFO;
-
- gf_msg (this->name, loglevel, op_errno,
- PS_MSG_REMOVEXATTR_INFO,
- "%"PRId64": REMOVEXATTR %s (%s) of key %s, client: %s, "
- "error-xlator: %s",
- frame->root->unique, state->loc.path,
- uuid_utoa (state->resolve.gfid),
- state->name, STACK_CLIENT_NAME (frame->root),
- STACK_ERR_XL_NAME (frame->root));
- goto out;
- }
+ GF_PROTOCOL_DICT_SERIALIZE(this, xdata, &rsp.xdata.xdata_val,
+ rsp.xdata.xdata_len, op_errno, out);
+
+ if (op_ret == -1) {
+ state = CALL_STATE(frame);
+ if (ENODATA == op_errno || ENOATTR == op_errno)
+ loglevel = GF_LOG_DEBUG;
+ else
+ loglevel = GF_LOG_INFO;
+
+ gf_msg(this->name, loglevel, op_errno, PS_MSG_REMOVEXATTR_INFO,
+ "%" PRId64
+ ": REMOVEXATTR %s (%s) of key %s, client: %s, "
+ "error-xlator: %s",
+ frame->root->unique, state->loc.path,
+ uuid_utoa(state->resolve.gfid), state->name,
+ STACK_CLIENT_NAME(frame->root), STACK_ERR_XL_NAME(frame->root));
+ goto out;
+ }
out:
- rsp.op_ret = op_ret;
- rsp.op_errno = gf_errno_to_error (op_errno);
+ rsp.op_ret = op_ret;
+ rsp.op_errno = gf_errno_to_error(op_errno);
- req = frame->local;
- server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
- (xdrproc_t)xdr_gf_common_rsp);
+ req = frame->local;
+ server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gf_common_rsp);
- GF_FREE (rsp.xdata.xdata_val);
+ GF_FREE(rsp.xdata.xdata_val);
- return 0;
+ return 0;
}
int
-server_fremovexattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
- int32_t op_ret, int32_t op_errno, dict_t *xdata)
+server_fremovexattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+ int32_t op_ret, int32_t op_errno, dict_t *xdata)
{
- gf_common_rsp rsp = {0,};
- rpcsvc_request_t *req = NULL;
- server_state_t *state = NULL;
-
- if (gf_replace_old_iatt_in_dict (xdata)) {
- op_errno = errno;
- op_ret = -1;
- goto out;
- }
-
- GF_PROTOCOL_DICT_SERIALIZE (this, xdata, &rsp.xdata.xdata_val,
- rsp.xdata.xdata_len, op_errno, out);
-
- if (op_ret == -1) {
- state = CALL_STATE (frame);
- gf_msg (this->name,
- fop_log_level (GF_FOP_FREMOVEXATTR, op_errno), op_errno,
- PS_MSG_REMOVEXATTR_INFO,
- "%"PRId64": FREMOVEXATTR %"PRId64" (%s) (%s), "
- "client: %s, error-xlator: %s", frame->root->unique,
- state->resolve.fd_no, uuid_utoa (state->resolve.gfid),
- state->name, STACK_CLIENT_NAME (frame->root),
- STACK_ERR_XL_NAME (frame->root));
- goto out;
- }
+ gf_common_rsp rsp = {
+ 0,
+ };
+ rpcsvc_request_t *req = NULL;
+ server_state_t *state = NULL;
+
+ if (gf_replace_old_iatt_in_dict(xdata)) {
+ op_errno = errno;
+ op_ret = -1;
+ goto out;
+ }
+
+ GF_PROTOCOL_DICT_SERIALIZE(this, xdata, &rsp.xdata.xdata_val,
+ rsp.xdata.xdata_len, op_errno, out);
+
+ if (op_ret == -1) {
+ state = CALL_STATE(frame);
+ gf_msg(this->name, fop_log_level(GF_FOP_FREMOVEXATTR, op_errno),
+ op_errno, PS_MSG_REMOVEXATTR_INFO,
+ "%" PRId64 ": FREMOVEXATTR %" PRId64
+ " (%s) (%s), "
+ "client: %s, error-xlator: %s",
+ frame->root->unique, state->resolve.fd_no,
+ uuid_utoa(state->resolve.gfid), state->name,
+ STACK_CLIENT_NAME(frame->root), STACK_ERR_XL_NAME(frame->root));
+ goto out;
+ }
out:
- rsp.op_ret = op_ret;
- rsp.op_errno = gf_errno_to_error (op_errno);
+ rsp.op_ret = op_ret;
+ rsp.op_errno = gf_errno_to_error(op_errno);
- req = frame->local;
- server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
- (xdrproc_t)xdr_gf_common_rsp);
+ req = frame->local;
+ server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gf_common_rsp);
- GF_FREE (rsp.xdata.xdata_val);
+ GF_FREE(rsp.xdata.xdata_val);
- return 0;
+ return 0;
}
int
-server_getxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
- int32_t op_ret, int32_t op_errno, dict_t *dict,
- dict_t *xdata)
+server_getxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+ int32_t op_ret, int32_t op_errno, dict_t *dict,
+ dict_t *xdata)
{
- gfs3_getxattr_rsp rsp = {0,};
- rpcsvc_request_t *req = NULL;
- server_state_t *state = NULL;
-
- GF_PROTOCOL_DICT_SERIALIZE (this, xdata, &rsp.xdata.xdata_val,
- rsp.xdata.xdata_len, op_errno, out);
-
- if (op_ret == -1) {
- state = CALL_STATE (frame);
- gf_msg (this->name, fop_log_level (GF_FOP_GETXATTR, op_errno),
- op_errno, PS_MSG_GETXATTR_INFO,
- "%"PRId64": GETXATTR %s (%s) (%s), client: %s, "
- "error-xlator: %s", frame->root->unique,
- state->loc.path, uuid_utoa (state->resolve.gfid),
- state->name, STACK_CLIENT_NAME (frame->root),
- STACK_ERR_XL_NAME (frame->root));
- goto out;
- }
-
- GF_PROTOCOL_DICT_SERIALIZE (this, dict, &rsp.dict.dict_val,
- rsp.dict.dict_len, op_errno, out);
+ gfs3_getxattr_rsp rsp = {
+ 0,
+ };
+ rpcsvc_request_t *req = NULL;
+ server_state_t *state = NULL;
+
+ GF_PROTOCOL_DICT_SERIALIZE(this, xdata, &rsp.xdata.xdata_val,
+ rsp.xdata.xdata_len, op_errno, out);
+
+ if (op_ret == -1) {
+ state = CALL_STATE(frame);
+ gf_msg(this->name, fop_log_level(GF_FOP_GETXATTR, op_errno), op_errno,
+ PS_MSG_GETXATTR_INFO,
+ "%" PRId64
+ ": GETXATTR %s (%s) (%s), client: %s, "
+ "error-xlator: %s",
+ frame->root->unique, state->loc.path,
+ uuid_utoa(state->resolve.gfid), state->name,
+ STACK_CLIENT_NAME(frame->root), STACK_ERR_XL_NAME(frame->root));
+ goto out;
+ }
+
+ GF_PROTOCOL_DICT_SERIALIZE(this, dict, &rsp.dict.dict_val,
+ rsp.dict.dict_len, op_errno, out);
out:
- rsp.op_ret = op_ret;
- rsp.op_errno = gf_errno_to_error (op_errno);
+ rsp.op_ret = op_ret;
+ rsp.op_errno = gf_errno_to_error(op_errno);
- req = frame->local;
- server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
- (xdrproc_t)xdr_gfs3_getxattr_rsp);
+ req = frame->local;
+ server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gfs3_getxattr_rsp);
- GF_FREE (rsp.dict.dict_val);
+ GF_FREE(rsp.dict.dict_val);
- GF_FREE (rsp.xdata.xdata_val);
+ GF_FREE(rsp.xdata.xdata_val);
- return 0;
+ return 0;
}
-
int
-server_fgetxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
- int32_t op_ret, int32_t op_errno, dict_t *dict,
- dict_t *xdata)
+server_fgetxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+ int32_t op_ret, int32_t op_errno, dict_t *dict,
+ dict_t *xdata)
{
- gfs3_fgetxattr_rsp rsp = {0,};
- server_state_t *state = NULL;
- rpcsvc_request_t *req = NULL;
-
- GF_PROTOCOL_DICT_SERIALIZE (this, xdata, &rsp.xdata.xdata_val,
- rsp.xdata.xdata_len, op_errno, out);
-
- if (op_ret == -1) {
- state = CALL_STATE (frame);
- gf_msg (this->name, fop_log_level (GF_FOP_FGETXATTR, op_errno),
- op_errno, PS_MSG_GETXATTR_INFO,
- "%"PRId64": FGETXATTR %"PRId64" (%s) (%s), "
- "client: %s, error-xlator: %s", frame->root->unique,
- state->resolve.fd_no, uuid_utoa (state->resolve.gfid),
- state->name, STACK_CLIENT_NAME (frame->root),
- STACK_ERR_XL_NAME (frame->root));
- goto out;
- }
-
- GF_PROTOCOL_DICT_SERIALIZE (this, dict, &rsp.dict.dict_val,
- rsp.dict.dict_len, op_errno, out);
+ gfs3_fgetxattr_rsp rsp = {
+ 0,
+ };
+ server_state_t *state = NULL;
+ rpcsvc_request_t *req = NULL;
+
+ GF_PROTOCOL_DICT_SERIALIZE(this, xdata, &rsp.xdata.xdata_val,
+ rsp.xdata.xdata_len, op_errno, out);
+
+ if (op_ret == -1) {
+ state = CALL_STATE(frame);
+ gf_msg(this->name, fop_log_level(GF_FOP_FGETXATTR, op_errno), op_errno,
+ PS_MSG_GETXATTR_INFO,
+ "%" PRId64 ": FGETXATTR %" PRId64
+ " (%s) (%s), "
+ "client: %s, error-xlator: %s",
+ frame->root->unique, state->resolve.fd_no,
+ uuid_utoa(state->resolve.gfid), state->name,
+ STACK_CLIENT_NAME(frame->root), STACK_ERR_XL_NAME(frame->root));
+ goto out;
+ }
+
+ GF_PROTOCOL_DICT_SERIALIZE(this, dict, &rsp.dict.dict_val,
+ rsp.dict.dict_len, op_errno, out);
out:
- rsp.op_ret = op_ret;
- rsp.op_errno = gf_errno_to_error (op_errno);
+ rsp.op_ret = op_ret;
+ rsp.op_errno = gf_errno_to_error(op_errno);
- req = frame->local;
- server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
- (xdrproc_t)xdr_gfs3_fgetxattr_rsp);
+ req = frame->local;
+ server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gfs3_fgetxattr_rsp);
- GF_FREE (rsp.dict.dict_val);
+ GF_FREE(rsp.dict.dict_val);
- GF_FREE (rsp.xdata.xdata_val);
+ GF_FREE(rsp.xdata.xdata_val);
- return 0;
+ return 0;
}
/* print every key */
int
-_gf_server_log_setxattr_failure (dict_t *d, char *k, data_t *v,
- void *tmp)
+_gf_server_log_setxattr_failure(dict_t *d, char *k, data_t *v, void *tmp)
{
- server_state_t *state = NULL;
- call_frame_t *frame = NULL;
+ server_state_t *state = NULL;
+ call_frame_t *frame = NULL;
- frame = tmp;
- state = CALL_STATE (frame);
+ frame = tmp;
+ state = CALL_STATE(frame);
- gf_msg (THIS->name, GF_LOG_INFO, 0, PS_MSG_SETXATTR_INFO,
- "%"PRId64": SETXATTR %s (%s) ==> %s, client: %s, "
- "error-xlator: %s", frame->root->unique, state->loc.path,
- uuid_utoa (state->resolve.gfid), k,
- STACK_CLIENT_NAME (frame->root),
- STACK_ERR_XL_NAME (frame->root));
- return 0;
+ gf_msg(THIS->name, GF_LOG_INFO, 0, PS_MSG_SETXATTR_INFO,
+ "%" PRId64
+ ": SETXATTR %s (%s) ==> %s, client: %s, "
+ "error-xlator: %s",
+ frame->root->unique, state->loc.path, uuid_utoa(state->resolve.gfid),
+ k, STACK_CLIENT_NAME(frame->root), STACK_ERR_XL_NAME(frame->root));
+ return 0;
}
int
-server_setxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
- int32_t op_ret, int32_t op_errno, dict_t *xdata)
+server_setxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+ int32_t op_ret, int32_t op_errno, dict_t *xdata)
{
- gf_common_rsp rsp = {0,};
- rpcsvc_request_t *req = NULL;
- server_state_t *state = NULL;
+ gf_common_rsp rsp = {
+ 0,
+ };
+ rpcsvc_request_t *req = NULL;
+ server_state_t *state = NULL;
- if (gf_replace_old_iatt_in_dict (xdata)) {
- op_errno = errno;
- op_ret = -1;
- goto out;
- }
+ if (gf_replace_old_iatt_in_dict(xdata)) {
+ op_errno = errno;
+ op_ret = -1;
+ goto out;
+ }
- GF_PROTOCOL_DICT_SERIALIZE (this, xdata, &rsp.xdata.xdata_val,
- rsp.xdata.xdata_len, op_errno, out);
-
- if (op_ret == -1) {
- state = CALL_STATE (frame);
- if (op_errno != ENOTSUP)
- dict_foreach (state->dict,
- _gf_server_log_setxattr_failure,
- frame);
-
- if (op_errno == ENOTSUP) {
- gf_msg_debug (THIS->name, 0, "%s",
- strerror (op_errno));
- } else {
- gf_msg (THIS->name, GF_LOG_INFO, op_errno,
- PS_MSG_SETXATTR_INFO, "client: %s, "
- "error-xlator: %s",
- STACK_CLIENT_NAME (frame->root),
- STACK_ERR_XL_NAME (frame->root));
- }
- goto out;
+ GF_PROTOCOL_DICT_SERIALIZE(this, xdata, &rsp.xdata.xdata_val,
+ rsp.xdata.xdata_len, op_errno, out);
+
+ if (op_ret == -1) {
+ state = CALL_STATE(frame);
+ if (op_errno != ENOTSUP)
+ dict_foreach(state->dict, _gf_server_log_setxattr_failure, frame);
+
+ if (op_errno == ENOTSUP) {
+ gf_msg_debug(THIS->name, 0, "%s", strerror(op_errno));
+ } else {
+ gf_msg(THIS->name, GF_LOG_INFO, op_errno, PS_MSG_SETXATTR_INFO,
+ "client: %s, "
+ "error-xlator: %s",
+ STACK_CLIENT_NAME(frame->root),
+ STACK_ERR_XL_NAME(frame->root));
}
+ goto out;
+ }
out:
- rsp.op_ret = op_ret;
- rsp.op_errno = gf_errno_to_error (op_errno);
+ rsp.op_ret = op_ret;
+ rsp.op_errno = gf_errno_to_error(op_errno);
- req = frame->local;
- server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
- (xdrproc_t)xdr_gf_common_rsp);
+ req = frame->local;
+ server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gf_common_rsp);
- GF_FREE (rsp.xdata.xdata_val);
+ GF_FREE(rsp.xdata.xdata_val);
- return 0;
+ return 0;
}
/* print every key here */
static int
-_gf_server_log_fsetxattr_failure (dict_t *d, char *k, data_t *v,
- void *tmp)
+_gf_server_log_fsetxattr_failure(dict_t *d, char *k, data_t *v, void *tmp)
{
- call_frame_t *frame = NULL;
- server_state_t *state = NULL;
+ call_frame_t *frame = NULL;
+ server_state_t *state = NULL;
- frame = tmp;
- state = CALL_STATE (frame);
+ frame = tmp;
+ state = CALL_STATE(frame);
- gf_msg (THIS->name, GF_LOG_INFO, 0, PS_MSG_SETXATTR_INFO,
- "%"PRId64": FSETXATTR %"PRId64" (%s) ==> %s, client: %s, "
- "error-xlator: %s", frame->root->unique, state->resolve.fd_no,
- uuid_utoa (state->resolve.gfid), k,
- STACK_CLIENT_NAME (frame->root),
- STACK_ERR_XL_NAME (frame->root));
+ gf_msg(THIS->name, GF_LOG_INFO, 0, PS_MSG_SETXATTR_INFO,
+ "%" PRId64 ": FSETXATTR %" PRId64
+ " (%s) ==> %s, client: %s, "
+ "error-xlator: %s",
+ frame->root->unique, state->resolve.fd_no,
+ uuid_utoa(state->resolve.gfid), k, STACK_CLIENT_NAME(frame->root),
+ STACK_ERR_XL_NAME(frame->root));
- return 0;
+ return 0;
}
int
-server_fsetxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
- int32_t op_ret, int32_t op_errno, dict_t *xdata)
+server_fsetxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+ int32_t op_ret, int32_t op_errno, dict_t *xdata)
{
- gf_common_rsp rsp = {0,};
- rpcsvc_request_t *req = NULL;
- server_state_t *state = NULL;
+ gf_common_rsp rsp = {
+ 0,
+ };
+ rpcsvc_request_t *req = NULL;
+ server_state_t *state = NULL;
- if (gf_replace_old_iatt_in_dict (xdata)) {
- op_errno = errno;
- op_ret = -1;
- goto out;
- }
+ if (gf_replace_old_iatt_in_dict(xdata)) {
+ op_errno = errno;
+ op_ret = -1;
+ goto out;
+ }
+
+ GF_PROTOCOL_DICT_SERIALIZE(this, xdata, &rsp.xdata.xdata_val,
+ rsp.xdata.xdata_len, op_errno, out);
- GF_PROTOCOL_DICT_SERIALIZE (this, xdata, &rsp.xdata.xdata_val,
- rsp.xdata.xdata_len, op_errno, out);
-
- if (op_ret == -1) {
- state = CALL_STATE (frame);
- if (op_errno != ENOTSUP) {
- dict_foreach (state->dict,
- _gf_server_log_fsetxattr_failure,
- frame);
- }
- if (op_errno == ENOTSUP) {
- gf_msg_debug (THIS->name, 0, "%s",
- strerror (op_errno));
- } else {
- gf_msg (THIS->name, GF_LOG_INFO, op_errno,
- PS_MSG_SETXATTR_INFO, "client: %s, "
- "error-xlator: %s",
- STACK_CLIENT_NAME (frame->root),
- STACK_ERR_XL_NAME (frame->root));
- }
- goto out;
+ if (op_ret == -1) {
+ state = CALL_STATE(frame);
+ if (op_errno != ENOTSUP) {
+ dict_foreach(state->dict, _gf_server_log_fsetxattr_failure, frame);
+ }
+ if (op_errno == ENOTSUP) {
+ gf_msg_debug(THIS->name, 0, "%s", strerror(op_errno));
+ } else {
+ gf_msg(THIS->name, GF_LOG_INFO, op_errno, PS_MSG_SETXATTR_INFO,
+ "client: %s, "
+ "error-xlator: %s",
+ STACK_CLIENT_NAME(frame->root),
+ STACK_ERR_XL_NAME(frame->root));
}
+ goto out;
+ }
out:
- rsp.op_ret = op_ret;
- rsp.op_errno = gf_errno_to_error (op_errno);
+ rsp.op_ret = op_ret;
+ rsp.op_errno = gf_errno_to_error(op_errno);
- req = frame->local;
- server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
- (xdrproc_t)xdr_gf_common_rsp);
+ req = frame->local;
+ server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gf_common_rsp);
- GF_FREE (rsp.xdata.xdata_val);
+ GF_FREE(rsp.xdata.xdata_val);
- return 0;
+ return 0;
}
int
-server_rename_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
- int32_t op_ret, int32_t op_errno, struct iatt *stbuf,
- struct iatt *preoldparent, struct iatt *postoldparent,
- struct iatt *prenewparent, struct iatt *postnewparent,
- dict_t *xdata)
+server_rename_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+ int32_t op_ret, int32_t op_errno, struct iatt *stbuf,
+ struct iatt *preoldparent, struct iatt *postoldparent,
+ struct iatt *prenewparent, struct iatt *postnewparent,
+ dict_t *xdata)
{
- gfs3_rename_rsp rsp = {0,};
- server_state_t *state = NULL;
- rpcsvc_request_t *req = NULL;
- char oldpar_str[50] = {0,};
- char newpar_str[50] = {0,};
-
- GF_PROTOCOL_DICT_SERIALIZE (this, xdata, &rsp.xdata.xdata_val,
- rsp.xdata.xdata_len, op_errno, out);
-
- state = CALL_STATE (frame);
-
- if (op_ret == -1) {
- uuid_utoa_r (state->resolve.pargfid, oldpar_str);
- uuid_utoa_r (state->resolve2.pargfid, newpar_str);
- gf_msg (this->name, GF_LOG_INFO, op_errno, PS_MSG_RENAME_INFO,
- "%"PRId64": RENAME %s (%s/%s) -> %s (%s/%s), "
- "client: %s, error-xlator: %s", frame->root->unique,
- state->loc.path, oldpar_str, state->resolve.bname,
- state->loc2.path, newpar_str, state->resolve2.bname,
- STACK_CLIENT_NAME (frame->root),
- STACK_ERR_XL_NAME (frame->root));
- goto out;
- }
-
- server_post_rename (frame, state, &rsp, stbuf,
- preoldparent, postoldparent,
- prenewparent, postnewparent);
+ gfs3_rename_rsp rsp = {
+ 0,
+ };
+ server_state_t *state = NULL;
+ rpcsvc_request_t *req = NULL;
+ char oldpar_str[50] = {
+ 0,
+ };
+ char newpar_str[50] = {
+ 0,
+ };
+
+ GF_PROTOCOL_DICT_SERIALIZE(this, xdata, &rsp.xdata.xdata_val,
+ rsp.xdata.xdata_len, op_errno, out);
+
+ state = CALL_STATE(frame);
+
+ if (op_ret == -1) {
+ uuid_utoa_r(state->resolve.pargfid, oldpar_str);
+ uuid_utoa_r(state->resolve2.pargfid, newpar_str);
+ gf_msg(this->name, GF_LOG_INFO, op_errno, PS_MSG_RENAME_INFO,
+ "%" PRId64
+ ": RENAME %s (%s/%s) -> %s (%s/%s), "
+ "client: %s, error-xlator: %s",
+ frame->root->unique, state->loc.path, oldpar_str,
+ state->resolve.bname, state->loc2.path, newpar_str,
+ state->resolve2.bname, STACK_CLIENT_NAME(frame->root),
+ STACK_ERR_XL_NAME(frame->root));
+ goto out;
+ }
+
+ server_post_rename(frame, state, &rsp, stbuf, preoldparent, postoldparent,
+ prenewparent, postnewparent);
out:
- rsp.op_ret = op_ret;
- rsp.op_errno = gf_errno_to_error (op_errno);
+ rsp.op_ret = op_ret;
+ rsp.op_errno = gf_errno_to_error(op_errno);
- req = frame->local;
- server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
- (xdrproc_t)xdr_gfs3_rename_rsp);
+ req = frame->local;
+ server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gfs3_rename_rsp);
- GF_FREE (rsp.xdata.xdata_val);
+ GF_FREE(rsp.xdata.xdata_val);
- return 0;
+ return 0;
}
int
-server_unlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
- int32_t op_ret, int32_t op_errno, struct iatt *preparent,
- struct iatt *postparent, dict_t *xdata)
+server_unlink_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+ int32_t op_ret, int32_t op_errno, struct iatt *preparent,
+ struct iatt *postparent, dict_t *xdata)
{
- gfs3_unlink_rsp rsp = {0,};
- server_state_t *state = NULL;
- rpcsvc_request_t *req = NULL;
-
- if (gf_replace_old_iatt_in_dict (xdata)) {
- op_errno = errno;
- op_ret = -1;
- goto out;
- }
-
- GF_PROTOCOL_DICT_SERIALIZE (this, xdata, &rsp.xdata.xdata_val,
- rsp.xdata.xdata_len, op_errno, out);
-
- state = CALL_STATE (frame);
-
- if (op_ret) {
- gf_msg (this->name, fop_log_level (GF_FOP_UNLINK, op_errno),
- op_errno, PS_MSG_LINK_INFO,
- "%"PRId64": UNLINK %s (%s/%s), client: %s, "
- "error-xlator: %s", frame->root->unique,
- state->loc.path, uuid_utoa (state->resolve.pargfid),
- state->resolve.bname,
- STACK_CLIENT_NAME (frame->root),
- STACK_ERR_XL_NAME (frame->root));
- goto out;
- }
-
- /* TODO: log gfid of the inodes */
- gf_msg_trace (frame->root->client->bound_xl->name, 0, "%"PRId64": "
- "UNLINK_CBK %s", frame->root->unique, state->loc.name);
-
- server_post_unlink (state, &rsp, preparent, postparent);
+ gfs3_unlink_rsp rsp = {
+ 0,
+ };
+ server_state_t *state = NULL;
+ rpcsvc_request_t *req = NULL;
+
+ if (gf_replace_old_iatt_in_dict(xdata)) {
+ op_errno = errno;
+ op_ret = -1;
+ goto out;
+ }
+
+ GF_PROTOCOL_DICT_SERIALIZE(this, xdata, &rsp.xdata.xdata_val,
+ rsp.xdata.xdata_len, op_errno, out);
+
+ state = CALL_STATE(frame);
+
+ if (op_ret) {
+ gf_msg(this->name, fop_log_level(GF_FOP_UNLINK, op_errno), op_errno,
+ PS_MSG_LINK_INFO,
+ "%" PRId64
+ ": UNLINK %s (%s/%s), client: %s, "
+ "error-xlator: %s",
+ frame->root->unique, state->loc.path,
+ uuid_utoa(state->resolve.pargfid), state->resolve.bname,
+ STACK_CLIENT_NAME(frame->root), STACK_ERR_XL_NAME(frame->root));
+ goto out;
+ }
+
+ /* TODO: log gfid of the inodes */
+ gf_msg_trace(frame->root->client->bound_xl->name, 0,
+ "%" PRId64
+ ": "
+ "UNLINK_CBK %s",
+ frame->root->unique, state->loc.name);
+
+ server_post_unlink(state, &rsp, preparent, postparent);
out:
- rsp.op_ret = op_ret;
- rsp.op_errno = gf_errno_to_error (op_errno);
+ rsp.op_ret = op_ret;
+ rsp.op_errno = gf_errno_to_error(op_errno);
- req = frame->local;
- server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
- (xdrproc_t)xdr_gfs3_unlink_rsp);
+ req = frame->local;
+ server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gfs3_unlink_rsp);
- GF_FREE (rsp.xdata.xdata_val);
+ GF_FREE(rsp.xdata.xdata_val);
- return 0;
+ return 0;
}
int
-server_symlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
- int32_t op_ret, int32_t op_errno, inode_t *inode,
- struct iatt *stbuf, struct iatt *preparent,
- struct iatt *postparent, dict_t *xdata)
+server_symlink_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+ int32_t op_ret, int32_t op_errno, inode_t *inode,
+ struct iatt *stbuf, struct iatt *preparent,
+ struct iatt *postparent, dict_t *xdata)
{
- gfs3_symlink_rsp rsp = {0,};
- server_state_t *state = NULL;
- rpcsvc_request_t *req = NULL;
+ gfs3_symlink_rsp rsp = {
+ 0,
+ };
+ server_state_t *state = NULL;
+ rpcsvc_request_t *req = NULL;
- GF_PROTOCOL_DICT_SERIALIZE (this, xdata, &rsp.xdata.xdata_val,
- rsp.xdata.xdata_len, op_errno, out);
+ GF_PROTOCOL_DICT_SERIALIZE(this, xdata, &rsp.xdata.xdata_val,
+ rsp.xdata.xdata_len, op_errno, out);
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (op_ret < 0) {
- gf_msg (this->name, GF_LOG_INFO, op_errno, PS_MSG_LINK_INFO,
- "%"PRId64": SYMLINK %s (%s/%s), client: %s, "
- "error-xlator:%s", frame->root->unique,
- (state->loc.path) ? state->loc.path : "",
- uuid_utoa (state->resolve.pargfid),
- state->resolve.bname,
- STACK_CLIENT_NAME (frame->root),
- STACK_ERR_XL_NAME (frame->root));
- goto out;
- }
+ if (op_ret < 0) {
+ gf_msg(this->name, GF_LOG_INFO, op_errno, PS_MSG_LINK_INFO,
+ "%" PRId64
+ ": SYMLINK %s (%s/%s), client: %s, "
+ "error-xlator:%s",
+ frame->root->unique, (state->loc.path) ? state->loc.path : "",
+ uuid_utoa(state->resolve.pargfid), state->resolve.bname,
+ STACK_CLIENT_NAME(frame->root), STACK_ERR_XL_NAME(frame->root));
+ goto out;
+ }
- server_post_symlink (state, &rsp, inode, stbuf, preparent,
- postparent, xdata);
+ server_post_symlink(state, &rsp, inode, stbuf, preparent, postparent,
+ xdata);
out:
- rsp.op_ret = op_ret;
- rsp.op_errno = gf_errno_to_error (op_errno);
+ rsp.op_ret = op_ret;
+ rsp.op_errno = gf_errno_to_error(op_errno);
- req = frame->local;
- server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
- (xdrproc_t)xdr_gfs3_symlink_rsp);
+ req = frame->local;
+ server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gfs3_symlink_rsp);
- GF_FREE (rsp.xdata.xdata_val);
+ GF_FREE(rsp.xdata.xdata_val);
- return 0;
+ return 0;
}
-
int
-server_link_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
- int32_t op_ret, int32_t op_errno, inode_t *inode,
- struct iatt *stbuf, struct iatt *preparent,
- struct iatt *postparent, dict_t *xdata)
+server_link_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+ int32_t op_ret, int32_t op_errno, inode_t *inode,
+ struct iatt *stbuf, struct iatt *preparent,
+ struct iatt *postparent, dict_t *xdata)
{
- gfs3_link_rsp rsp = {0,};
- server_state_t *state = NULL;
- rpcsvc_request_t *req = NULL;
- char gfid_str[50] = {0,};
- char newpar_str[50] = {0,};
+ gfs3_link_rsp rsp = {
+ 0,
+ };
+ server_state_t *state = NULL;
+ rpcsvc_request_t *req = NULL;
+ char gfid_str[50] = {
+ 0,
+ };
+ char newpar_str[50] = {
+ 0,
+ };
- GF_PROTOCOL_DICT_SERIALIZE (this, xdata, &rsp.xdata.xdata_val,
- rsp.xdata.xdata_len, op_errno, out);
+ GF_PROTOCOL_DICT_SERIALIZE(this, xdata, &rsp.xdata.xdata_val,
+ rsp.xdata.xdata_len, op_errno, out);
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (op_ret) {
- uuid_utoa_r (state->resolve.gfid, gfid_str);
- uuid_utoa_r (state->resolve2.pargfid, newpar_str);
-
- gf_msg (this->name, GF_LOG_INFO, op_errno, PS_MSG_LINK_INFO,
- "%"PRId64": LINK %s (%s) -> %s/%s, client: %s, "
- "error-xlator: %s", frame->root->unique,
- state->loc.path, gfid_str, newpar_str,
- state->resolve2.bname, STACK_CLIENT_NAME (frame->root),
- STACK_ERR_XL_NAME (frame->root));
- goto out;
- }
+ if (op_ret) {
+ uuid_utoa_r(state->resolve.gfid, gfid_str);
+ uuid_utoa_r(state->resolve2.pargfid, newpar_str);
+
+ gf_msg(this->name, GF_LOG_INFO, op_errno, PS_MSG_LINK_INFO,
+ "%" PRId64
+ ": LINK %s (%s) -> %s/%s, client: %s, "
+ "error-xlator: %s",
+ frame->root->unique, state->loc.path, gfid_str, newpar_str,
+ state->resolve2.bname, STACK_CLIENT_NAME(frame->root),
+ STACK_ERR_XL_NAME(frame->root));
+ goto out;
+ }
- server_post_link (state, &rsp, inode, stbuf, preparent,
- postparent, xdata);
+ server_post_link(state, &rsp, inode, stbuf, preparent, postparent, xdata);
out:
- rsp.op_ret = op_ret;
- rsp.op_errno = gf_errno_to_error (op_errno);
+ rsp.op_ret = op_ret;
+ rsp.op_errno = gf_errno_to_error(op_errno);
- req = frame->local;
- server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
- (xdrproc_t)xdr_gfs3_link_rsp);
+ req = frame->local;
+ server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gfs3_link_rsp);
- GF_FREE (rsp.xdata.xdata_val);
+ GF_FREE(rsp.xdata.xdata_val);
- return 0;
+ return 0;
}
int
-server_truncate_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
- int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
- struct iatt *postbuf, dict_t *xdata)
+server_truncate_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+ int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
+ struct iatt *postbuf, dict_t *xdata)
{
- gfs3_truncate_rsp rsp = {0,};
- server_state_t *state = NULL;
- rpcsvc_request_t *req = NULL;
+ gfs3_truncate_rsp rsp = {
+ 0,
+ };
+ server_state_t *state = NULL;
+ rpcsvc_request_t *req = NULL;
- GF_PROTOCOL_DICT_SERIALIZE (this, xdata, &rsp.xdata.xdata_val,
- rsp.xdata.xdata_len, op_errno, out);
+ GF_PROTOCOL_DICT_SERIALIZE(this, xdata, &rsp.xdata.xdata_val,
+ rsp.xdata.xdata_len, op_errno, out);
- if (op_ret) {
- state = CALL_STATE (frame);
- gf_msg (this->name, GF_LOG_INFO, op_errno,
- PS_MSG_TRUNCATE_INFO,
- "%"PRId64": TRUNCATE %s (%s), client: %s, "
- "error-xlator: %s", frame->root->unique,
- state->loc.path, uuid_utoa (state->resolve.gfid),
- STACK_CLIENT_NAME (frame->root),
- STACK_ERR_XL_NAME (frame->root));
- goto out;
- }
+ if (op_ret) {
+ state = CALL_STATE(frame);
+ gf_msg(this->name, GF_LOG_INFO, op_errno, PS_MSG_TRUNCATE_INFO,
+ "%" PRId64
+ ": TRUNCATE %s (%s), client: %s, "
+ "error-xlator: %s",
+ frame->root->unique, state->loc.path,
+ uuid_utoa(state->resolve.gfid), STACK_CLIENT_NAME(frame->root),
+ STACK_ERR_XL_NAME(frame->root));
+ goto out;
+ }
- server_post_truncate (&rsp, prebuf, postbuf);
+ server_post_truncate(&rsp, prebuf, postbuf);
out:
- rsp.op_ret = op_ret;
- rsp.op_errno = gf_errno_to_error (op_errno);
+ rsp.op_ret = op_ret;
+ rsp.op_errno = gf_errno_to_error(op_errno);
- req = frame->local;
- server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
- (xdrproc_t)xdr_gfs3_truncate_rsp);
+ req = frame->local;
+ server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gfs3_truncate_rsp);
- GF_FREE (rsp.xdata.xdata_val);
+ GF_FREE(rsp.xdata.xdata_val);
- return 0;
+ return 0;
}
int
-server_fstat_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
- int32_t op_ret, int32_t op_errno, struct iatt *stbuf,
- dict_t *xdata)
+server_fstat_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+ int32_t op_ret, int32_t op_errno, struct iatt *stbuf,
+ dict_t *xdata)
{
- gfs3_fstat_rsp rsp = {0,};
- server_state_t *state = NULL;
- rpcsvc_request_t *req = NULL;
-
- GF_PROTOCOL_DICT_SERIALIZE (this, xdata, &rsp.xdata.xdata_val,
- rsp.xdata.xdata_len, op_errno, out);
-
- state = CALL_STATE (frame);
- if (op_ret) {
- gf_msg (this->name, fop_log_level (GF_FOP_FSTAT, op_errno),
- op_errno, PS_MSG_STAT_INFO,
- "%"PRId64": FSTAT %"PRId64" (%s), client: %s, "
- "error-xlator: %s", frame->root->unique,
- state->resolve.fd_no, uuid_utoa (state->resolve.gfid),
- STACK_CLIENT_NAME (frame->root),
- STACK_ERR_XL_NAME (frame->root));
- goto out;
- }
-
- server_post_fstat (state, &rsp, stbuf);
+ gfs3_fstat_rsp rsp = {
+ 0,
+ };
+ server_state_t *state = NULL;
+ rpcsvc_request_t *req = NULL;
+
+ GF_PROTOCOL_DICT_SERIALIZE(this, xdata, &rsp.xdata.xdata_val,
+ rsp.xdata.xdata_len, op_errno, out);
+
+ state = CALL_STATE(frame);
+ if (op_ret) {
+ gf_msg(this->name, fop_log_level(GF_FOP_FSTAT, op_errno), op_errno,
+ PS_MSG_STAT_INFO,
+ "%" PRId64 ": FSTAT %" PRId64
+ " (%s), client: %s, "
+ "error-xlator: %s",
+ frame->root->unique, state->resolve.fd_no,
+ uuid_utoa(state->resolve.gfid), STACK_CLIENT_NAME(frame->root),
+ STACK_ERR_XL_NAME(frame->root));
+ goto out;
+ }
+
+ server_post_fstat(state, &rsp, stbuf);
out:
- rsp.op_ret = op_ret;
- rsp.op_errno = gf_errno_to_error (op_errno);
+ rsp.op_ret = op_ret;
+ rsp.op_errno = gf_errno_to_error(op_errno);
- req = frame->local;
- server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
- (xdrproc_t)xdr_gfs3_fstat_rsp);
+ req = frame->local;
+ server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gfs3_fstat_rsp);
- GF_FREE (rsp.xdata.xdata_val);
+ GF_FREE(rsp.xdata.xdata_val);
- return 0;
+ return 0;
}
int
-server_ftruncate_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
- int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
- struct iatt *postbuf, dict_t *xdata)
+server_ftruncate_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+ int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
+ struct iatt *postbuf, dict_t *xdata)
{
- gfs3_ftruncate_rsp rsp = {0};
- server_state_t *state = NULL;
- rpcsvc_request_t *req = NULL;
+ gfs3_ftruncate_rsp rsp = {0};
+ server_state_t *state = NULL;
+ rpcsvc_request_t *req = NULL;
- GF_PROTOCOL_DICT_SERIALIZE (this, xdata, &rsp.xdata.xdata_val,
- rsp.xdata.xdata_len, op_errno, out);
+ GF_PROTOCOL_DICT_SERIALIZE(this, xdata, &rsp.xdata.xdata_val,
+ rsp.xdata.xdata_len, op_errno, out);
- if (op_ret) {
- state = CALL_STATE (frame);
- gf_msg (this->name, fop_log_level (GF_FOP_FTRUNCATE, op_errno),
- op_errno, PS_MSG_TRUNCATE_INFO,
- "%"PRId64": FTRUNCATE %"PRId64" (%s), client: %s, "
- "error-xlator: %s", frame->root->unique,
- state->resolve.fd_no, uuid_utoa (state->resolve.gfid),
- STACK_CLIENT_NAME (frame->root),
- STACK_ERR_XL_NAME (frame->root));
- goto out;
- }
+ if (op_ret) {
+ state = CALL_STATE(frame);
+ gf_msg(this->name, fop_log_level(GF_FOP_FTRUNCATE, op_errno), op_errno,
+ PS_MSG_TRUNCATE_INFO,
+ "%" PRId64 ": FTRUNCATE %" PRId64
+ " (%s), client: %s, "
+ "error-xlator: %s",
+ frame->root->unique, state->resolve.fd_no,
+ uuid_utoa(state->resolve.gfid), STACK_CLIENT_NAME(frame->root),
+ STACK_ERR_XL_NAME(frame->root));
+ goto out;
+ }
- server_post_ftruncate (&rsp, prebuf, postbuf);
+ server_post_ftruncate(&rsp, prebuf, postbuf);
out:
- rsp.op_ret = op_ret;
- rsp.op_errno = gf_errno_to_error (op_errno);
+ rsp.op_ret = op_ret;
+ rsp.op_errno = gf_errno_to_error(op_errno);
- req = frame->local;
- server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
- (xdrproc_t)xdr_gfs3_ftruncate_rsp);
+ req = frame->local;
+ server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gfs3_ftruncate_rsp);
- GF_FREE (rsp.xdata.xdata_val);
+ GF_FREE(rsp.xdata.xdata_val);
- return 0;
+ return 0;
}
int
-server_flush_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
- int32_t op_ret, int32_t op_errno, dict_t *xdata)
+server_flush_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+ int32_t op_ret, int32_t op_errno, dict_t *xdata)
{
- gf_common_rsp rsp = {0,};
- server_state_t *state = NULL;
- rpcsvc_request_t *req = NULL;
-
- GF_PROTOCOL_DICT_SERIALIZE (this, xdata, &rsp.xdata.xdata_val,
- rsp.xdata.xdata_len, op_errno, out);
-
- if (op_ret < 0) {
- state = CALL_STATE (frame);
- gf_msg (this->name, fop_log_level (GF_FOP_FLUSH, op_errno),
- op_errno, PS_MSG_FLUSH_INFO,
- "%"PRId64": FLUSH %"PRId64" (%s), client: %s, "
- "error-xlator: %s",
- frame->root->unique, state->resolve.fd_no,
- uuid_utoa (state->resolve.gfid),
- STACK_CLIENT_NAME (frame->root),
- STACK_ERR_XL_NAME (frame->root));
- goto out;
- }
+ gf_common_rsp rsp = {
+ 0,
+ };
+ server_state_t *state = NULL;
+ rpcsvc_request_t *req = NULL;
+
+ GF_PROTOCOL_DICT_SERIALIZE(this, xdata, &rsp.xdata.xdata_val,
+ rsp.xdata.xdata_len, op_errno, out);
+
+ if (op_ret < 0) {
+ state = CALL_STATE(frame);
+ gf_msg(this->name, fop_log_level(GF_FOP_FLUSH, op_errno), op_errno,
+ PS_MSG_FLUSH_INFO,
+ "%" PRId64 ": FLUSH %" PRId64
+ " (%s), client: %s, "
+ "error-xlator: %s",
+ frame->root->unique, state->resolve.fd_no,
+ uuid_utoa(state->resolve.gfid), STACK_CLIENT_NAME(frame->root),
+ STACK_ERR_XL_NAME(frame->root));
+ goto out;
+ }
out:
- rsp.op_ret = op_ret;
- rsp.op_errno = gf_errno_to_error (op_errno);
+ rsp.op_ret = op_ret;
+ rsp.op_errno = gf_errno_to_error(op_errno);
- req = frame->local;
- server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
- (xdrproc_t)xdr_gf_common_rsp);
+ req = frame->local;
+ server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gf_common_rsp);
- GF_FREE (rsp.xdata.xdata_val);
+ GF_FREE(rsp.xdata.xdata_val);
- return 0;
+ return 0;
}
int
-server_fsync_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
- int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
- struct iatt *postbuf, dict_t *xdata)
+server_fsync_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+ int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
+ struct iatt *postbuf, dict_t *xdata)
{
- gfs3_fsync_rsp rsp = {0,};
- server_state_t *state = NULL;
- rpcsvc_request_t *req = NULL;
-
- GF_PROTOCOL_DICT_SERIALIZE (this, xdata, &rsp.xdata.xdata_val,
- rsp.xdata.xdata_len, op_errno, out);
-
- if (op_ret < 0) {
- state = CALL_STATE (frame);
- gf_msg (this->name, fop_log_level (GF_FOP_FSYNC, op_errno),
- op_errno, PS_MSG_SYNC_INFO,
- "%"PRId64": FSYNC %"PRId64" (%s), client: %s, "
- "error-xlator: %s", frame->root->unique,
- state->resolve.fd_no, uuid_utoa (state->resolve.gfid),
- STACK_CLIENT_NAME (frame->root),
- STACK_ERR_XL_NAME (frame->root));
- goto out;
- }
+ gfs3_fsync_rsp rsp = {
+ 0,
+ };
+ server_state_t *state = NULL;
+ rpcsvc_request_t *req = NULL;
+
+ GF_PROTOCOL_DICT_SERIALIZE(this, xdata, &rsp.xdata.xdata_val,
+ rsp.xdata.xdata_len, op_errno, out);
- server_post_fsync (&rsp, prebuf, postbuf);
+ if (op_ret < 0) {
+ state = CALL_STATE(frame);
+ gf_msg(this->name, fop_log_level(GF_FOP_FSYNC, op_errno), op_errno,
+ PS_MSG_SYNC_INFO,
+ "%" PRId64 ": FSYNC %" PRId64
+ " (%s), client: %s, "
+ "error-xlator: %s",
+ frame->root->unique, state->resolve.fd_no,
+ uuid_utoa(state->resolve.gfid), STACK_CLIENT_NAME(frame->root),
+ STACK_ERR_XL_NAME(frame->root));
+ goto out;
+ }
+
+ server_post_fsync(&rsp, prebuf, postbuf);
out:
- rsp.op_ret = op_ret;
- rsp.op_errno = gf_errno_to_error (op_errno);
+ rsp.op_ret = op_ret;
+ rsp.op_errno = gf_errno_to_error(op_errno);
- req = frame->local;
- server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
- (xdrproc_t)xdr_gfs3_fsync_rsp);
+ req = frame->local;
+ server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gfs3_fsync_rsp);
- GF_FREE (rsp.xdata.xdata_val);
+ GF_FREE(rsp.xdata.xdata_val);
- return 0;
+ return 0;
}
int
-server_writev_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
- int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
- struct iatt *postbuf, dict_t *xdata)
+server_writev_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+ int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
+ struct iatt *postbuf, dict_t *xdata)
{
- gfs3_write_rsp rsp = {0,};
- server_state_t *state = NULL;
- rpcsvc_request_t *req = NULL;
-
- GF_PROTOCOL_DICT_SERIALIZE (this, xdata, &rsp.xdata.xdata_val,
- rsp.xdata.xdata_len, op_errno, out);
-
- if (op_ret < 0) {
- state = CALL_STATE (frame);
- gf_msg (this->name, fop_log_level (GF_FOP_WRITE, op_errno),
- op_errno, PS_MSG_WRITE_INFO,
- "%"PRId64": WRITEV %"PRId64" (%s), client: %s, "
- "error-xlator: %s", frame->root->unique,
- state->resolve.fd_no, uuid_utoa (state->resolve.gfid),
- STACK_CLIENT_NAME (frame->root),
- STACK_ERR_XL_NAME (frame->root));
- goto out;
- }
-
- server_post_writev (&rsp, prebuf, postbuf);
+ gfs3_write_rsp rsp = {
+ 0,
+ };
+ server_state_t *state = NULL;
+ rpcsvc_request_t *req = NULL;
+
+ GF_PROTOCOL_DICT_SERIALIZE(this, xdata, &rsp.xdata.xdata_val,
+ rsp.xdata.xdata_len, op_errno, out);
+
+ if (op_ret < 0) {
+ state = CALL_STATE(frame);
+ gf_msg(this->name, fop_log_level(GF_FOP_WRITE, op_errno), op_errno,
+ PS_MSG_WRITE_INFO,
+ "%" PRId64 ": WRITEV %" PRId64
+ " (%s), client: %s, "
+ "error-xlator: %s",
+ frame->root->unique, state->resolve.fd_no,
+ uuid_utoa(state->resolve.gfid), STACK_CLIENT_NAME(frame->root),
+ STACK_ERR_XL_NAME(frame->root));
+ goto out;
+ }
+
+ server_post_writev(&rsp, prebuf, postbuf);
out:
- rsp.op_ret = op_ret;
- rsp.op_errno = gf_errno_to_error (op_errno);
+ rsp.op_ret = op_ret;
+ rsp.op_errno = gf_errno_to_error(op_errno);
- req = frame->local;
- server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
- (xdrproc_t)xdr_gfs3_write_rsp);
+ req = frame->local;
+ server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gfs3_write_rsp);
- GF_FREE (rsp.xdata.xdata_val);
+ GF_FREE(rsp.xdata.xdata_val);
- return 0;
+ return 0;
}
-
int
-server_readv_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
- int32_t op_ret, int32_t op_errno,
- struct iovec *vector, int32_t count,
- struct iatt *stbuf, struct iobref *iobref, dict_t *xdata)
+server_readv_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+ int32_t op_ret, int32_t op_errno, struct iovec *vector,
+ int32_t count, struct iatt *stbuf, struct iobref *iobref,
+ dict_t *xdata)
{
- gfs3_read_rsp rsp = {0,};
- server_state_t *state = NULL;
- rpcsvc_request_t *req = NULL;
+ gfs3_read_rsp rsp = {
+ 0,
+ };
+ server_state_t *state = NULL;
+ rpcsvc_request_t *req = NULL;
#ifdef GF_TESTING_IO_XDATA
- {
- int ret = 0;
- if (!xdata)
- xdata = dict_new ();
-
- ret = dict_set_str (xdata, "testing-the-xdata-key",
- "testing-xdata-value");
- }
+ {
+ int ret = 0;
+ if (!xdata)
+ xdata = dict_new();
+
+ ret = dict_set_str(xdata, "testing-the-xdata-key",
+ "testing-xdata-value");
+ }
#endif
- GF_PROTOCOL_DICT_SERIALIZE (this, xdata, &rsp.xdata.xdata_val,
- rsp.xdata.xdata_len, op_errno, out);
-
- if (op_ret < 0) {
- state = CALL_STATE (frame);
- gf_msg (this->name, fop_log_level (GF_FOP_READ, op_errno),
- op_errno, PS_MSG_READ_INFO,
- "%"PRId64": READV %"PRId64" (%s), client: %s, "
- "error-xlator: %s", frame->root->unique,
- state->resolve.fd_no, uuid_utoa (state->resolve.gfid),
- STACK_CLIENT_NAME (frame->root),
- STACK_ERR_XL_NAME (frame->root));
- goto out;
- }
-
- server_post_readv (&rsp, stbuf, op_ret);
+ GF_PROTOCOL_DICT_SERIALIZE(this, xdata, &rsp.xdata.xdata_val,
+ rsp.xdata.xdata_len, op_errno, out);
+
+ if (op_ret < 0) {
+ state = CALL_STATE(frame);
+ gf_msg(this->name, fop_log_level(GF_FOP_READ, op_errno), op_errno,
+ PS_MSG_READ_INFO,
+ "%" PRId64 ": READV %" PRId64
+ " (%s), client: %s, "
+ "error-xlator: %s",
+ frame->root->unique, state->resolve.fd_no,
+ uuid_utoa(state->resolve.gfid), STACK_CLIENT_NAME(frame->root),
+ STACK_ERR_XL_NAME(frame->root));
+ goto out;
+ }
+
+ server_post_readv(&rsp, stbuf, op_ret);
out:
- rsp.op_ret = op_ret;
- rsp.op_errno = gf_errno_to_error (op_errno);
+ rsp.op_ret = op_ret;
+ rsp.op_errno = gf_errno_to_error(op_errno);
- req = frame->local;
- server_submit_reply (frame, req, &rsp, vector, count, iobref,
- (xdrproc_t)xdr_gfs3_read_rsp);
+ req = frame->local;
+ server_submit_reply(frame, req, &rsp, vector, count, iobref,
+ (xdrproc_t)xdr_gfs3_read_rsp);
- GF_FREE (rsp.xdata.xdata_val);
+ GF_FREE(rsp.xdata.xdata_val);
- return 0;
+ return 0;
}
int
-server_rchecksum_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
- int32_t op_ret, int32_t op_errno,
- uint32_t weak_checksum, uint8_t *strong_checksum,
- dict_t *xdata)
+server_rchecksum_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+ int32_t op_ret, int32_t op_errno, uint32_t weak_checksum,
+ uint8_t *strong_checksum, dict_t *xdata)
{
- gfs3_rchecksum_rsp rsp = {0,};
- rpcsvc_request_t *req = NULL;
- server_state_t *state = NULL;
+ gfs3_rchecksum_rsp rsp = {
+ 0,
+ };
+ rpcsvc_request_t *req = NULL;
+ server_state_t *state = NULL;
- GF_PROTOCOL_DICT_SERIALIZE (this, xdata, &rsp.xdata.xdata_val,
- rsp.xdata.xdata_len, op_errno, out);
+ GF_PROTOCOL_DICT_SERIALIZE(this, xdata, &rsp.xdata.xdata_val,
+ rsp.xdata.xdata_len, op_errno, out);
- if (op_ret < 0) {
- state = CALL_STATE (frame);
- gf_msg (this->name, fop_log_level (GF_FOP_RCHECKSUM, op_errno),
- op_errno, PS_MSG_CHKSUM_INFO,
- "%"PRId64": RCHECKSUM %"PRId64" (%s), client: %s, "
- "error-xlator: %s", frame->root->unique,
- state->resolve.fd_no, uuid_utoa (state->resolve.gfid),
- STACK_CLIENT_NAME (frame->root),
- STACK_ERR_XL_NAME (frame->root));
- goto out;
- }
+ if (op_ret < 0) {
+ state = CALL_STATE(frame);
+ gf_msg(this->name, fop_log_level(GF_FOP_RCHECKSUM, op_errno), op_errno,
+ PS_MSG_CHKSUM_INFO,
+ "%" PRId64 ": RCHECKSUM %" PRId64
+ " (%s), client: %s, "
+ "error-xlator: %s",
+ frame->root->unique, state->resolve.fd_no,
+ uuid_utoa(state->resolve.gfid), STACK_CLIENT_NAME(frame->root),
+ STACK_ERR_XL_NAME(frame->root));
+ goto out;
+ }
- server_post_rchecksum (&rsp, weak_checksum, strong_checksum);
+ server_post_rchecksum(&rsp, weak_checksum, strong_checksum);
out:
- rsp.op_ret = op_ret;
- rsp.op_errno = gf_errno_to_error (op_errno);
+ rsp.op_ret = op_ret;
+ rsp.op_errno = gf_errno_to_error(op_errno);
- req = frame->local;
- server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
- (xdrproc_t)xdr_gfs3_rchecksum_rsp);
+ req = frame->local;
+ server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gfs3_rchecksum_rsp);
- GF_FREE (rsp.xdata.xdata_val);
+ GF_FREE(rsp.xdata.xdata_val);
- return 0;
+ return 0;
}
-
int
-server_open_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
- int32_t op_ret, int32_t op_errno, fd_t *fd, dict_t *xdata)
+server_open_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+ int32_t op_ret, int32_t op_errno, fd_t *fd, dict_t *xdata)
{
- server_state_t *state = NULL;
- rpcsvc_request_t *req = NULL;
- gfs3_open_rsp rsp = {0,};
+ server_state_t *state = NULL;
+ rpcsvc_request_t *req = NULL;
+ gfs3_open_rsp rsp = {
+ 0,
+ };
- GF_PROTOCOL_DICT_SERIALIZE (this, xdata, &rsp.xdata.xdata_val,
- rsp.xdata.xdata_len, op_errno, out);
+ GF_PROTOCOL_DICT_SERIALIZE(this, xdata, &rsp.xdata.xdata_val,
+ rsp.xdata.xdata_len, op_errno, out);
- if (op_ret < 0) {
- state = CALL_STATE (frame);
- gf_msg (this->name, fop_log_level (GF_FOP_OPEN, op_errno),
- op_errno, PS_MSG_OPEN_INFO,
- "%"PRId64": OPEN %s (%s), client: %s, error-xlator: %s",
- frame->root->unique, state->loc.path,
- uuid_utoa (state->resolve.gfid),
- STACK_CLIENT_NAME (frame->root),
- STACK_ERR_XL_NAME (frame->root));
- goto out;
- }
+ if (op_ret < 0) {
+ state = CALL_STATE(frame);
+ gf_msg(this->name, fop_log_level(GF_FOP_OPEN, op_errno), op_errno,
+ PS_MSG_OPEN_INFO,
+ "%" PRId64 ": OPEN %s (%s), client: %s, error-xlator: %s",
+ frame->root->unique, state->loc.path,
+ uuid_utoa(state->resolve.gfid), STACK_CLIENT_NAME(frame->root),
+ STACK_ERR_XL_NAME(frame->root));
+ goto out;
+ }
- op_ret = server_post_open (frame, this, &rsp, fd);
- if (op_ret)
- goto out;
+ op_ret = server_post_open(frame, this, &rsp, fd);
+ if (op_ret)
+ goto out;
out:
- rsp.op_ret = op_ret;
- rsp.op_errno = gf_errno_to_error (op_errno);
+ rsp.op_ret = op_ret;
+ rsp.op_errno = gf_errno_to_error(op_errno);
- req = frame->local;
- server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
- (xdrproc_t)xdr_gfs3_open_rsp);
- GF_FREE (rsp.xdata.xdata_val);
+ req = frame->local;
+ server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gfs3_open_rsp);
+ GF_FREE(rsp.xdata.xdata_val);
- return 0;
+ return 0;
}
-
int
-server_create_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
- int32_t op_ret, int32_t op_errno, fd_t *fd, inode_t *inode,
- struct iatt *stbuf, struct iatt *preparent,
- struct iatt *postparent, dict_t *xdata)
+server_create_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+ int32_t op_ret, int32_t op_errno, fd_t *fd, inode_t *inode,
+ struct iatt *stbuf, struct iatt *preparent,
+ struct iatt *postparent, dict_t *xdata)
{
- server_state_t *state = NULL;
- rpcsvc_request_t *req = NULL;
- uint64_t fd_no = 0;
- gfs3_create_rsp rsp = {0,};
-
- GF_PROTOCOL_DICT_SERIALIZE (this, xdata, &rsp.xdata.xdata_val,
- rsp.xdata.xdata_len, op_errno, out);
-
- state = CALL_STATE (frame);
-
- if (op_ret < 0) {
- gf_msg (this->name, GF_LOG_INFO, op_errno, PS_MSG_CREATE_INFO,
- "%"PRId64": CREATE %s (%s/%s), client: %s, "
- "error-xlator: %s", frame->root->unique,
- state->loc.path, uuid_utoa (state->resolve.pargfid),
- state->resolve.bname, STACK_CLIENT_NAME (frame->root),
- STACK_ERR_XL_NAME (frame->root));
- goto out;
- }
-
- /* TODO: log gfid too */
- gf_msg_trace (frame->root->client->bound_xl->name, 0, "%"PRId64": "
- "CREATE %s (%s)", frame->root->unique, state->loc.name,
- uuid_utoa (stbuf->ia_gfid));
-
- op_ret = server_post_create (frame, &rsp, state, this, fd, inode,
- stbuf,
- preparent, postparent);
- if (op_ret) {
- op_errno = -op_ret;
- op_ret = -1;
- goto out;
- }
+ server_state_t *state = NULL;
+ rpcsvc_request_t *req = NULL;
+ uint64_t fd_no = 0;
+ gfs3_create_rsp rsp = {
+ 0,
+ };
+
+ GF_PROTOCOL_DICT_SERIALIZE(this, xdata, &rsp.xdata.xdata_val,
+ rsp.xdata.xdata_len, op_errno, out);
+
+ state = CALL_STATE(frame);
+
+ if (op_ret < 0) {
+ gf_msg(this->name, GF_LOG_INFO, op_errno, PS_MSG_CREATE_INFO,
+ "%" PRId64
+ ": CREATE %s (%s/%s), client: %s, "
+ "error-xlator: %s",
+ frame->root->unique, state->loc.path,
+ uuid_utoa(state->resolve.pargfid), state->resolve.bname,
+ STACK_CLIENT_NAME(frame->root), STACK_ERR_XL_NAME(frame->root));
+ goto out;
+ }
+
+ /* TODO: log gfid too */
+ gf_msg_trace(frame->root->client->bound_xl->name, 0,
+ "%" PRId64
+ ": "
+ "CREATE %s (%s)",
+ frame->root->unique, state->loc.name,
+ uuid_utoa(stbuf->ia_gfid));
+
+ op_ret = server_post_create(frame, &rsp, state, this, fd, inode, stbuf,
+ preparent, postparent);
+ if (op_ret) {
+ op_errno = -op_ret;
+ op_ret = -1;
+ goto out;
+ }
out:
- if (op_ret)
- rsp.fd = fd_no;
- rsp.op_ret = op_ret;
- rsp.op_errno = gf_errno_to_error (op_errno);
+ if (op_ret)
+ rsp.fd = fd_no;
+ rsp.op_ret = op_ret;
+ rsp.op_errno = gf_errno_to_error(op_errno);
- req = frame->local;
- server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
- (xdrproc_t)xdr_gfs3_create_rsp);
+ req = frame->local;
+ server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gfs3_create_rsp);
- GF_FREE (rsp.xdata.xdata_val);
+ GF_FREE(rsp.xdata.xdata_val);
- return 0;
+ return 0;
}
int
-server_readlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
- int32_t op_ret, int32_t op_errno, const char *buf,
- struct iatt *stbuf, dict_t *xdata)
+server_readlink_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+ int32_t op_ret, int32_t op_errno, const char *buf,
+ struct iatt *stbuf, dict_t *xdata)
{
- gfs3_readlink_rsp rsp = {0,};
- server_state_t *state = NULL;
- rpcsvc_request_t *req = NULL;
+ gfs3_readlink_rsp rsp = {
+ 0,
+ };
+ server_state_t *state = NULL;
+ rpcsvc_request_t *req = NULL;
- GF_PROTOCOL_DICT_SERIALIZE (this, xdata, &rsp.xdata.xdata_val,
- rsp.xdata.xdata_len, op_errno, out);
+ GF_PROTOCOL_DICT_SERIALIZE(this, xdata, &rsp.xdata.xdata_val,
+ rsp.xdata.xdata_len, op_errno, out);
- if (op_ret < 0) {
- state = CALL_STATE (frame);
- gf_msg (this->name, GF_LOG_INFO, op_errno, PS_MSG_LINK_INFO,
- "%"PRId64": READLINK %s (%s), client: %s, "
- "error-xlator: %s", frame->root->unique,
- state->loc.path, uuid_utoa (state->resolve.gfid),
- STACK_CLIENT_NAME (frame->root),
- STACK_ERR_XL_NAME (frame->root));
- goto out;
- }
+ if (op_ret < 0) {
+ state = CALL_STATE(frame);
+ gf_msg(this->name, GF_LOG_INFO, op_errno, PS_MSG_LINK_INFO,
+ "%" PRId64
+ ": READLINK %s (%s), client: %s, "
+ "error-xlator: %s",
+ frame->root->unique, state->loc.path,
+ uuid_utoa(state->resolve.gfid), STACK_CLIENT_NAME(frame->root),
+ STACK_ERR_XL_NAME(frame->root));
+ goto out;
+ }
- server_post_readlink (&rsp, stbuf, buf);
+ server_post_readlink(&rsp, stbuf, buf);
out:
- rsp.op_ret = op_ret;
- rsp.op_errno = gf_errno_to_error (op_errno);
- if (!rsp.path)
- rsp.path = "";
+ rsp.op_ret = op_ret;
+ rsp.op_errno = gf_errno_to_error(op_errno);
+ if (!rsp.path)
+ rsp.path = "";
- req = frame->local;
- server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
- (xdrproc_t)xdr_gfs3_readlink_rsp);
+ req = frame->local;
+ server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gfs3_readlink_rsp);
- GF_FREE (rsp.xdata.xdata_val);
+ GF_FREE(rsp.xdata.xdata_val);
- return 0;
+ return 0;
}
int
-server_stat_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
- int32_t op_ret, int32_t op_errno, struct iatt *stbuf,
- dict_t *xdata)
+server_stat_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+ int32_t op_ret, int32_t op_errno, struct iatt *stbuf,
+ dict_t *xdata)
{
- gfs3_stat_rsp rsp = {0,};
- server_state_t *state = NULL;
- rpcsvc_request_t *req = NULL;
+ gfs3_stat_rsp rsp = {
+ 0,
+ };
+ server_state_t *state = NULL;
+ rpcsvc_request_t *req = NULL;
- GF_PROTOCOL_DICT_SERIALIZE (this, xdata, &rsp.xdata.xdata_val,
- rsp.xdata.xdata_len, op_errno, out);
+ GF_PROTOCOL_DICT_SERIALIZE(this, xdata, &rsp.xdata.xdata_val,
+ rsp.xdata.xdata_len, op_errno, out);
- state = CALL_STATE (frame);
- if (op_ret) {
- gf_msg (this->name, fop_log_level (GF_FOP_STAT, op_errno),
- op_errno, PS_MSG_STAT_INFO,
- "%"PRId64": STAT %s (%s), client: %s, error-xlator: %s",
- frame->root->unique,
- (state->loc.path) ? state->loc.path : "",
- uuid_utoa (state->resolve.gfid),
- STACK_CLIENT_NAME (frame->root),
- STACK_ERR_XL_NAME (frame->root));
- goto out;
- }
+ state = CALL_STATE(frame);
+ if (op_ret) {
+ gf_msg(this->name, fop_log_level(GF_FOP_STAT, op_errno), op_errno,
+ PS_MSG_STAT_INFO,
+ "%" PRId64 ": STAT %s (%s), client: %s, error-xlator: %s",
+ frame->root->unique, (state->loc.path) ? state->loc.path : "",
+ uuid_utoa(state->resolve.gfid), STACK_CLIENT_NAME(frame->root),
+ STACK_ERR_XL_NAME(frame->root));
+ goto out;
+ }
- server_post_stat (state, &rsp, stbuf);
+ server_post_stat(state, &rsp, stbuf);
out:
- rsp.op_ret = op_ret;
- rsp.op_errno = gf_errno_to_error (op_errno);
+ rsp.op_ret = op_ret;
+ rsp.op_errno = gf_errno_to_error(op_errno);
- req = frame->local;
- server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
- (xdrproc_t)xdr_gfs3_stat_rsp);
+ req = frame->local;
+ server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gfs3_stat_rsp);
- GF_FREE (rsp.xdata.xdata_val);
+ GF_FREE(rsp.xdata.xdata_val);
- return 0;
+ return 0;
}
-
int
-server_setattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
- int32_t op_ret, int32_t op_errno,
- struct iatt *statpre, struct iatt *statpost, dict_t *xdata)
+server_setattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+ int32_t op_ret, int32_t op_errno, struct iatt *statpre,
+ struct iatt *statpost, dict_t *xdata)
{
- gfs3_setattr_rsp rsp = {0,};
- server_state_t *state = NULL;
- rpcsvc_request_t *req = NULL;
+ gfs3_setattr_rsp rsp = {
+ 0,
+ };
+ server_state_t *state = NULL;
+ rpcsvc_request_t *req = NULL;
- GF_PROTOCOL_DICT_SERIALIZE (this, xdata, &rsp.xdata.xdata_val,
- rsp.xdata.xdata_len, op_errno, out);
+ GF_PROTOCOL_DICT_SERIALIZE(this, xdata, &rsp.xdata.xdata_val,
+ rsp.xdata.xdata_len, op_errno, out);
- if (op_ret) {
- state = CALL_STATE (frame);
- gf_msg (this->name, GF_LOG_INFO, op_errno, PS_MSG_SETATTR_INFO,
- "%"PRId64": SETATTR %s (%s), client: %s, "
- "error-xlator: %s", frame->root->unique,
- (state->loc.path) ? state->loc.path : "",
- uuid_utoa (state->resolve.gfid),
- STACK_CLIENT_NAME (frame->root),
- STACK_ERR_XL_NAME (frame->root));
- goto out;
- }
+ if (op_ret) {
+ state = CALL_STATE(frame);
+ gf_msg(this->name, GF_LOG_INFO, op_errno, PS_MSG_SETATTR_INFO,
+ "%" PRId64
+ ": SETATTR %s (%s), client: %s, "
+ "error-xlator: %s",
+ frame->root->unique, (state->loc.path) ? state->loc.path : "",
+ uuid_utoa(state->resolve.gfid), STACK_CLIENT_NAME(frame->root),
+ STACK_ERR_XL_NAME(frame->root));
+ goto out;
+ }
- server_post_setattr (&rsp, statpre, statpost);
+ server_post_setattr(&rsp, statpre, statpost);
out:
- rsp.op_ret = op_ret;
- rsp.op_errno = gf_errno_to_error (op_errno);
+ rsp.op_ret = op_ret;
+ rsp.op_errno = gf_errno_to_error(op_errno);
- req = frame->local;
- server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
- (xdrproc_t)xdr_gfs3_setattr_rsp);
+ req = frame->local;
+ server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gfs3_setattr_rsp);
- GF_FREE (rsp.xdata.xdata_val);
+ GF_FREE(rsp.xdata.xdata_val);
- return 0;
+ return 0;
}
int
-server_fsetattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
- int32_t op_ret, int32_t op_errno,
- struct iatt *statpre, struct iatt *statpost, dict_t *xdata)
+server_fsetattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+ int32_t op_ret, int32_t op_errno, struct iatt *statpre,
+ struct iatt *statpost, dict_t *xdata)
{
- gfs3_fsetattr_rsp rsp = {0,};
- server_state_t *state = NULL;
- rpcsvc_request_t *req = NULL;
+ gfs3_fsetattr_rsp rsp = {
+ 0,
+ };
+ server_state_t *state = NULL;
+ rpcsvc_request_t *req = NULL;
- GF_PROTOCOL_DICT_SERIALIZE (this, xdata, &rsp.xdata.xdata_val,
- rsp.xdata.xdata_len, op_errno, out);
+ GF_PROTOCOL_DICT_SERIALIZE(this, xdata, &rsp.xdata.xdata_val,
+ rsp.xdata.xdata_len, op_errno, out);
- if (op_ret) {
- state = CALL_STATE (frame);
- gf_msg (this->name, fop_log_level (GF_FOP_FSETATTR, op_errno),
- op_errno, PS_MSG_SETATTR_INFO,
- "%"PRId64": FSETATTR %"PRId64" (%s), client: %s, "
- "error-xlator: %s", frame->root->unique,
- state->resolve.fd_no, uuid_utoa (state->resolve.gfid),
- STACK_CLIENT_NAME (frame->root),
- STACK_ERR_XL_NAME (frame->root));
- goto out;
- }
+ if (op_ret) {
+ state = CALL_STATE(frame);
+ gf_msg(this->name, fop_log_level(GF_FOP_FSETATTR, op_errno), op_errno,
+ PS_MSG_SETATTR_INFO,
+ "%" PRId64 ": FSETATTR %" PRId64
+ " (%s), client: %s, "
+ "error-xlator: %s",
+ frame->root->unique, state->resolve.fd_no,
+ uuid_utoa(state->resolve.gfid), STACK_CLIENT_NAME(frame->root),
+ STACK_ERR_XL_NAME(frame->root));
+ goto out;
+ }
- server_post_fsetattr (&rsp, statpre, statpost);
+ server_post_fsetattr(&rsp, statpre, statpost);
out:
- rsp.op_ret = op_ret;
- rsp.op_errno = gf_errno_to_error (op_errno);
+ rsp.op_ret = op_ret;
+ rsp.op_errno = gf_errno_to_error(op_errno);
- req = frame->local;
- server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
- (xdrproc_t)xdr_gfs3_fsetattr_rsp);
+ req = frame->local;
+ server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gfs3_fsetattr_rsp);
- GF_FREE (rsp.xdata.xdata_val);
+ GF_FREE(rsp.xdata.xdata_val);
- return 0;
+ return 0;
}
-
int
-server_xattrop_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
- int32_t op_ret, int32_t op_errno, dict_t *dict,
- dict_t *xdata)
+server_xattrop_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+ int32_t op_ret, int32_t op_errno, dict_t *dict,
+ dict_t *xdata)
{
- gfs3_xattrop_rsp rsp = {0,};
- server_state_t *state = NULL;
- rpcsvc_request_t *req = NULL;
-
- GF_PROTOCOL_DICT_SERIALIZE (this, xdata, &rsp.xdata.xdata_val,
- rsp.xdata.xdata_len, op_errno, out);
-
- if (op_ret < 0) {
- state = CALL_STATE (frame);
- gf_msg (this->name, fop_log_level (GF_FOP_XATTROP, op_errno),
- op_errno, PS_MSG_XATTROP_INFO,
- "%"PRId64": XATTROP %s (%s), client: %s, "
- "error-xlator: %s", frame->root->unique,
- state->loc.path, uuid_utoa (state->resolve.gfid),
- STACK_CLIENT_NAME (frame->root),
- STACK_ERR_XL_NAME (frame->root));
- goto out;
- }
-
- GF_PROTOCOL_DICT_SERIALIZE (this, dict, &rsp.dict.dict_val,
- rsp.dict.dict_len, op_errno, out);
+ gfs3_xattrop_rsp rsp = {
+ 0,
+ };
+ server_state_t *state = NULL;
+ rpcsvc_request_t *req = NULL;
+
+ GF_PROTOCOL_DICT_SERIALIZE(this, xdata, &rsp.xdata.xdata_val,
+ rsp.xdata.xdata_len, op_errno, out);
+
+ if (op_ret < 0) {
+ state = CALL_STATE(frame);
+ gf_msg(this->name, fop_log_level(GF_FOP_XATTROP, op_errno), op_errno,
+ PS_MSG_XATTROP_INFO,
+ "%" PRId64
+ ": XATTROP %s (%s), client: %s, "
+ "error-xlator: %s",
+ frame->root->unique, state->loc.path,
+ uuid_utoa(state->resolve.gfid), STACK_CLIENT_NAME(frame->root),
+ STACK_ERR_XL_NAME(frame->root));
+ goto out;
+ }
+
+ GF_PROTOCOL_DICT_SERIALIZE(this, dict, &rsp.dict.dict_val,
+ rsp.dict.dict_len, op_errno, out);
out:
- rsp.op_ret = op_ret;
- rsp.op_errno = gf_errno_to_error (op_errno);
+ rsp.op_ret = op_ret;
+ rsp.op_errno = gf_errno_to_error(op_errno);
- req = frame->local;
- server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
- (xdrproc_t)xdr_gfs3_xattrop_rsp);
+ req = frame->local;
+ server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gfs3_xattrop_rsp);
- GF_FREE (rsp.dict.dict_val);
+ GF_FREE(rsp.dict.dict_val);
- GF_FREE (rsp.xdata.xdata_val);
+ GF_FREE(rsp.xdata.xdata_val);
- return 0;
+ return 0;
}
-
int
-server_fxattrop_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
- int32_t op_ret, int32_t op_errno, dict_t *dict,
- dict_t *xdata)
+server_fxattrop_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+ int32_t op_ret, int32_t op_errno, dict_t *dict,
+ dict_t *xdata)
{
- gfs3_xattrop_rsp rsp = {0,};
- server_state_t *state = NULL;
- rpcsvc_request_t *req = NULL;
-
- GF_PROTOCOL_DICT_SERIALIZE (this, xdata, &rsp.xdata.xdata_val,
- rsp.xdata.xdata_len, op_errno, out);
-
- if (op_ret < 0) {
- state = CALL_STATE (frame);
- gf_msg (this->name, fop_log_level (GF_FOP_FXATTROP, op_errno),
- op_errno, PS_MSG_XATTROP_INFO,
- "%"PRId64": FXATTROP %"PRId64" (%s), client: %s, "
- "error-xlator: %s", frame->root->unique,
- state->resolve.fd_no, uuid_utoa (state->resolve.gfid),
- STACK_CLIENT_NAME (frame->root),
- STACK_ERR_XL_NAME (frame->root));
- goto out;
- }
-
- GF_PROTOCOL_DICT_SERIALIZE (this, dict, &rsp.dict.dict_val,
- rsp.dict.dict_len, op_errno, out);
+ gfs3_xattrop_rsp rsp = {
+ 0,
+ };
+ server_state_t *state = NULL;
+ rpcsvc_request_t *req = NULL;
+
+ GF_PROTOCOL_DICT_SERIALIZE(this, xdata, &rsp.xdata.xdata_val,
+ rsp.xdata.xdata_len, op_errno, out);
+
+ if (op_ret < 0) {
+ state = CALL_STATE(frame);
+ gf_msg(this->name, fop_log_level(GF_FOP_FXATTROP, op_errno), op_errno,
+ PS_MSG_XATTROP_INFO,
+ "%" PRId64 ": FXATTROP %" PRId64
+ " (%s), client: %s, "
+ "error-xlator: %s",
+ frame->root->unique, state->resolve.fd_no,
+ uuid_utoa(state->resolve.gfid), STACK_CLIENT_NAME(frame->root),
+ STACK_ERR_XL_NAME(frame->root));
+ goto out;
+ }
+
+ GF_PROTOCOL_DICT_SERIALIZE(this, dict, &rsp.dict.dict_val,
+ rsp.dict.dict_len, op_errno, out);
out:
- rsp.op_ret = op_ret;
- rsp.op_errno = gf_errno_to_error (op_errno);
+ rsp.op_ret = op_ret;
+ rsp.op_errno = gf_errno_to_error(op_errno);
- req = frame->local;
- server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
- (xdrproc_t)xdr_gfs3_fxattrop_rsp);
+ req = frame->local;
+ server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gfs3_fxattrop_rsp);
- GF_FREE (rsp.dict.dict_val);
+ GF_FREE(rsp.dict.dict_val);
- GF_FREE (rsp.xdata.xdata_val);
+ GF_FREE(rsp.xdata.xdata_val);
- return 0;
+ return 0;
}
-
int
-server_readdirp_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
- int32_t op_ret, int32_t op_errno, gf_dirent_t *entries,
- dict_t *xdata)
+server_readdirp_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+ int32_t op_ret, int32_t op_errno, gf_dirent_t *entries,
+ dict_t *xdata)
{
- gfs3_readdirp_rsp rsp = {0,};
- server_state_t *state = NULL;
- rpcsvc_request_t *req = NULL;
- int ret = 0;
-
- state = CALL_STATE (frame);
-
- GF_PROTOCOL_DICT_SERIALIZE (this, xdata, &rsp.xdata.xdata_val,
- rsp.xdata.xdata_len, op_errno, out);
-
- if (op_ret < 0) {
- state = CALL_STATE (frame);
- gf_msg (this->name, fop_log_level (GF_FOP_READDIRP, op_errno),
- op_errno, PS_MSG_DIR_INFO,
- "%"PRId64": READDIRP %"PRId64" (%s), client: %s, "
- "error-xlator: %s", frame->root->unique,
- state->resolve.fd_no, uuid_utoa (state->resolve.gfid),
- STACK_CLIENT_NAME (frame->root),
- STACK_ERR_XL_NAME (frame->root));
- goto out;
- }
-
- /* (op_ret == 0) is valid, and means EOF */
- if (op_ret) {
- ret = server_post_readdirp (&rsp, entries);
- if (ret == -1) {
- op_ret = -1;
- op_errno = ENOMEM;
- goto out;
- }
- }
-
- gf_link_inodes_from_dirent (this, state->fd->inode, entries);
+ gfs3_readdirp_rsp rsp = {
+ 0,
+ };
+ server_state_t *state = NULL;
+ rpcsvc_request_t *req = NULL;
+ int ret = 0;
+
+ state = CALL_STATE(frame);
+
+ GF_PROTOCOL_DICT_SERIALIZE(this, xdata, &rsp.xdata.xdata_val,
+ rsp.xdata.xdata_len, op_errno, out);
+
+ if (op_ret < 0) {
+ state = CALL_STATE(frame);
+ gf_msg(this->name, fop_log_level(GF_FOP_READDIRP, op_errno), op_errno,
+ PS_MSG_DIR_INFO,
+ "%" PRId64 ": READDIRP %" PRId64
+ " (%s), client: %s, "
+ "error-xlator: %s",
+ frame->root->unique, state->resolve.fd_no,
+ uuid_utoa(state->resolve.gfid), STACK_CLIENT_NAME(frame->root),
+ STACK_ERR_XL_NAME(frame->root));
+ goto out;
+ }
+
+ /* (op_ret == 0) is valid, and means EOF */
+ if (op_ret) {
+ ret = server_post_readdirp(&rsp, entries);
+ if (ret == -1) {
+ op_ret = -1;
+ op_errno = ENOMEM;
+ goto out;
+ }
+ }
+
+ gf_link_inodes_from_dirent(this, state->fd->inode, entries);
out:
- rsp.op_ret = op_ret;
- rsp.op_errno = gf_errno_to_error (op_errno);
+ rsp.op_ret = op_ret;
+ rsp.op_errno = gf_errno_to_error(op_errno);
- req = frame->local;
- server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
- (xdrproc_t)xdr_gfs3_readdirp_rsp);
+ req = frame->local;
+ server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gfs3_readdirp_rsp);
- GF_FREE (rsp.xdata.xdata_val);
+ GF_FREE(rsp.xdata.xdata_val);
- readdirp_rsp_cleanup (&rsp);
+ readdirp_rsp_cleanup(&rsp);
- return 0;
+ return 0;
}
int
server_fallocate_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
- int32_t op_ret, int32_t op_errno,
- struct iatt *statpre, struct iatt *statpost, dict_t *xdata)
-{
- gfs3_fallocate_rsp rsp = {0,};
- server_state_t *state = NULL;
- rpcsvc_request_t *req = NULL;
-
- GF_PROTOCOL_DICT_SERIALIZE (this, xdata, &rsp.xdata.xdata_val,
- rsp.xdata.xdata_len, op_errno, out);
-
- if (op_ret) {
- state = CALL_STATE (frame);
- gf_msg (this->name, fop_log_level (GF_FOP_FALLOCATE, op_errno),
- op_errno, PS_MSG_ALLOC_INFO,
- "%"PRId64": FALLOCATE %"PRId64" (%s), client: %s, "
- "error-xlator: %s", frame->root->unique,
- state->resolve.fd_no, uuid_utoa (state->resolve.gfid),
- STACK_CLIENT_NAME (frame->root),
- STACK_ERR_XL_NAME (frame->root));
- goto out;
- }
-
- server_post_fallocate (&rsp, statpre, statpost);
+ int32_t op_ret, int32_t op_errno, struct iatt *statpre,
+ struct iatt *statpost, dict_t *xdata)
+{
+ gfs3_fallocate_rsp rsp = {
+ 0,
+ };
+ server_state_t *state = NULL;
+ rpcsvc_request_t *req = NULL;
+
+ GF_PROTOCOL_DICT_SERIALIZE(this, xdata, &rsp.xdata.xdata_val,
+ rsp.xdata.xdata_len, op_errno, out);
+
+ if (op_ret) {
+ state = CALL_STATE(frame);
+ gf_msg(this->name, fop_log_level(GF_FOP_FALLOCATE, op_errno), op_errno,
+ PS_MSG_ALLOC_INFO,
+ "%" PRId64 ": FALLOCATE %" PRId64
+ " (%s), client: %s, "
+ "error-xlator: %s",
+ frame->root->unique, state->resolve.fd_no,
+ uuid_utoa(state->resolve.gfid), STACK_CLIENT_NAME(frame->root),
+ STACK_ERR_XL_NAME(frame->root));
+ goto out;
+ }
+
+ server_post_fallocate(&rsp, statpre, statpost);
out:
- rsp.op_ret = op_ret;
- rsp.op_errno = gf_errno_to_error (op_errno);
+ rsp.op_ret = op_ret;
+ rsp.op_errno = gf_errno_to_error(op_errno);
- req = frame->local;
- server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
- (xdrproc_t) xdr_gfs3_fallocate_rsp);
+ req = frame->local;
+ server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gfs3_fallocate_rsp);
- GF_FREE (rsp.xdata.xdata_val);
+ GF_FREE(rsp.xdata.xdata_val);
- return 0;
+ return 0;
}
int
server_discard_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
- int32_t op_ret, int32_t op_errno,
- struct iatt *statpre, struct iatt *statpost, dict_t *xdata)
-{
- gfs3_discard_rsp rsp = {0,};
- server_state_t *state = NULL;
- rpcsvc_request_t *req = NULL;
-
- GF_PROTOCOL_DICT_SERIALIZE (this, xdata, &rsp.xdata.xdata_val,
- rsp.xdata.xdata_len, op_errno, out);
-
- if (op_ret) {
- state = CALL_STATE (frame);
- gf_msg (this->name, fop_log_level (GF_FOP_DISCARD, op_errno),
- op_errno, PS_MSG_DISCARD_INFO,
- "%"PRId64": DISCARD %"PRId64" (%s), client: %s, "
- "error-xlator: %s", frame->root->unique,
- state->resolve.fd_no, uuid_utoa (state->resolve.gfid),
- STACK_CLIENT_NAME (frame->root),
- STACK_ERR_XL_NAME (frame->root));
- goto out;
- }
-
- server_post_discard (&rsp, statpre, statpost);
+ int32_t op_ret, int32_t op_errno, struct iatt *statpre,
+ struct iatt *statpost, dict_t *xdata)
+{
+ gfs3_discard_rsp rsp = {
+ 0,
+ };
+ server_state_t *state = NULL;
+ rpcsvc_request_t *req = NULL;
+
+ GF_PROTOCOL_DICT_SERIALIZE(this, xdata, &rsp.xdata.xdata_val,
+ rsp.xdata.xdata_len, op_errno, out);
+
+ if (op_ret) {
+ state = CALL_STATE(frame);
+ gf_msg(this->name, fop_log_level(GF_FOP_DISCARD, op_errno), op_errno,
+ PS_MSG_DISCARD_INFO,
+ "%" PRId64 ": DISCARD %" PRId64
+ " (%s), client: %s, "
+ "error-xlator: %s",
+ frame->root->unique, state->resolve.fd_no,
+ uuid_utoa(state->resolve.gfid), STACK_CLIENT_NAME(frame->root),
+ STACK_ERR_XL_NAME(frame->root));
+ goto out;
+ }
+
+ server_post_discard(&rsp, statpre, statpost);
out:
- rsp.op_ret = op_ret;
- rsp.op_errno = gf_errno_to_error (op_errno);
+ rsp.op_ret = op_ret;
+ rsp.op_errno = gf_errno_to_error(op_errno);
- req = frame->local;
- server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
- (xdrproc_t) xdr_gfs3_discard_rsp);
+ req = frame->local;
+ server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gfs3_discard_rsp);
- GF_FREE (rsp.xdata.xdata_val);
+ GF_FREE(rsp.xdata.xdata_val);
- return 0;
+ return 0;
}
int
server_zerofill_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
- int32_t op_ret, int32_t op_errno,
- struct iatt *statpre, struct iatt *statpost, dict_t *xdata)
-{
- gfs3_zerofill_rsp rsp = {0,};
- server_state_t *state = NULL;
- rpcsvc_request_t *req = NULL;
-
- req = frame->local;
- state = CALL_STATE (frame);
-
- GF_PROTOCOL_DICT_SERIALIZE (this, xdata, (&rsp.xdata.xdata_val),
- rsp.xdata.xdata_len, op_errno, out);
-
- if (op_ret) {
- gf_msg (this->name, fop_log_level (GF_FOP_ZEROFILL, op_errno),
- op_errno, PS_MSG_ZEROFILL_INFO,
- "%"PRId64": ZEROFILL%"PRId64" (%s), client: %s, "
- "error-xlator: %s",
- frame->root->unique, state->resolve.fd_no,
- uuid_utoa (state->resolve.gfid),
- STACK_CLIENT_NAME (frame->root),
- STACK_ERR_XL_NAME (frame->root));
- goto out;
- }
-
- server_post_zerofill (&rsp, statpre, statpost);
+ int32_t op_ret, int32_t op_errno, struct iatt *statpre,
+ struct iatt *statpost, dict_t *xdata)
+{
+ gfs3_zerofill_rsp rsp = {
+ 0,
+ };
+ server_state_t *state = NULL;
+ rpcsvc_request_t *req = NULL;
+
+ req = frame->local;
+ state = CALL_STATE(frame);
+
+ GF_PROTOCOL_DICT_SERIALIZE(this, xdata, (&rsp.xdata.xdata_val),
+ rsp.xdata.xdata_len, op_errno, out);
+
+ if (op_ret) {
+ gf_msg(this->name, fop_log_level(GF_FOP_ZEROFILL, op_errno), op_errno,
+ PS_MSG_ZEROFILL_INFO,
+ "%" PRId64 ": ZEROFILL%" PRId64
+ " (%s), client: %s, "
+ "error-xlator: %s",
+ frame->root->unique, state->resolve.fd_no,
+ uuid_utoa(state->resolve.gfid), STACK_CLIENT_NAME(frame->root),
+ STACK_ERR_XL_NAME(frame->root));
+ goto out;
+ }
+
+ server_post_zerofill(&rsp, statpre, statpost);
out:
- rsp.op_ret = op_ret;
- rsp.op_errno = gf_errno_to_error (op_errno);
+ rsp.op_ret = op_ret;
+ rsp.op_errno = gf_errno_to_error(op_errno);
- server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
- (xdrproc_t) xdr_gfs3_zerofill_rsp);
+ server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gfs3_zerofill_rsp);
- GF_FREE (rsp.xdata.xdata_val);
+ GF_FREE(rsp.xdata.xdata_val);
- return 0;
+ return 0;
}
-
int
-server_ipc_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
- int32_t op_ret, int32_t op_errno, dict_t *xdata)
+server_ipc_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+ int32_t op_ret, int32_t op_errno, dict_t *xdata)
{
- gf_common_rsp rsp = {0,};
- server_state_t *state = NULL;
- rpcsvc_request_t *req = NULL;
+ gf_common_rsp rsp = {
+ 0,
+ };
+ server_state_t *state = NULL;
+ rpcsvc_request_t *req = NULL;
- req = frame->local;
- state = CALL_STATE (frame);
+ req = frame->local;
+ state = CALL_STATE(frame);
- GF_PROTOCOL_DICT_SERIALIZE (this, xdata, (&rsp.xdata.xdata_val),
- rsp.xdata.xdata_len, op_errno, out);
+ GF_PROTOCOL_DICT_SERIALIZE(this, xdata, (&rsp.xdata.xdata_val),
+ rsp.xdata.xdata_len, op_errno, out);
- if (op_ret) {
- gf_msg (this->name, GF_LOG_INFO, op_errno,
- PS_MSG_SERVER_IPC_INFO,
- "%"PRId64": IPC%"PRId64" (%s), client: %s, "
- "error-xlator: %s",
- frame->root->unique, state->resolve.fd_no,
- uuid_utoa (state->resolve.gfid),
- STACK_CLIENT_NAME (frame->root),
- STACK_ERR_XL_NAME (frame->root));
- goto out;
- }
+ if (op_ret) {
+ gf_msg(this->name, GF_LOG_INFO, op_errno, PS_MSG_SERVER_IPC_INFO,
+ "%" PRId64 ": IPC%" PRId64
+ " (%s), client: %s, "
+ "error-xlator: %s",
+ frame->root->unique, state->resolve.fd_no,
+ uuid_utoa(state->resolve.gfid), STACK_CLIENT_NAME(frame->root),
+ STACK_ERR_XL_NAME(frame->root));
+ goto out;
+ }
out:
- rsp.op_ret = op_ret;
- rsp.op_errno = gf_errno_to_error (op_errno);
+ rsp.op_ret = op_ret;
+ rsp.op_errno = gf_errno_to_error(op_errno);
- server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
- (xdrproc_t) xdr_gf_common_rsp);
+ server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gf_common_rsp);
- GF_FREE (rsp.xdata.xdata_val);
+ GF_FREE(rsp.xdata.xdata_val);
- return 0;
+ return 0;
}
-
int
-server_seek_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
- int32_t op_ret, int32_t op_errno, off_t offset, dict_t *xdata)
+server_seek_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+ int32_t op_ret, int32_t op_errno, off_t offset, dict_t *xdata)
{
- struct gfs3_seek_rsp rsp = {0, };
- server_state_t *state = NULL;
- rpcsvc_request_t *req = NULL;
+ struct gfs3_seek_rsp rsp = {
+ 0,
+ };
+ server_state_t *state = NULL;
+ rpcsvc_request_t *req = NULL;
- req = frame->local;
- state = CALL_STATE (frame);
+ req = frame->local;
+ state = CALL_STATE(frame);
- GF_PROTOCOL_DICT_SERIALIZE (this, xdata, (&rsp.xdata.xdata_val),
- rsp.xdata.xdata_len, op_errno, out);
+ GF_PROTOCOL_DICT_SERIALIZE(this, xdata, (&rsp.xdata.xdata_val),
+ rsp.xdata.xdata_len, op_errno, out);
- if (op_ret) {
- gf_msg (this->name, fop_log_level (GF_FOP_SEEK, op_errno),
- op_errno, PS_MSG_SEEK_INFO,
- "%"PRId64": SEEK%"PRId64" (%s), client: %s, "
- "error-xlator: %s",
- frame->root->unique, state->resolve.fd_no,
- uuid_utoa (state->resolve.gfid),
- STACK_CLIENT_NAME (frame->root),
- STACK_ERR_XL_NAME (frame->root));
- goto out;
- }
+ if (op_ret) {
+ gf_msg(this->name, fop_log_level(GF_FOP_SEEK, op_errno), op_errno,
+ PS_MSG_SEEK_INFO,
+ "%" PRId64 ": SEEK%" PRId64
+ " (%s), client: %s, "
+ "error-xlator: %s",
+ frame->root->unique, state->resolve.fd_no,
+ uuid_utoa(state->resolve.gfid), STACK_CLIENT_NAME(frame->root),
+ STACK_ERR_XL_NAME(frame->root));
+ goto out;
+ }
- server_post_seek (&rsp, offset);
+ server_post_seek(&rsp, offset);
out:
- rsp.op_ret = op_ret;
- rsp.op_errno = gf_errno_to_error (op_errno);
+ rsp.op_ret = op_ret;
+ rsp.op_errno = gf_errno_to_error(op_errno);
- server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
- (xdrproc_t) xdr_gfs3_seek_rsp);
+ server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gfs3_seek_rsp);
- GF_FREE (rsp.xdata.xdata_val);
+ GF_FREE(rsp.xdata.xdata_val);
- return 0;
+ return 0;
}
static int
-server_setactivelk_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
- int32_t op_ret, int32_t op_errno, dict_t *xdata)
-{
- gfs3_setactivelk_rsp rsp = {0,};
- server_state_t *state = NULL;
- rpcsvc_request_t *req = NULL;
-
- state = CALL_STATE (frame);
-
- GF_PROTOCOL_DICT_SERIALIZE (this, xdata, &rsp.xdata.xdata_val,
- rsp.xdata.xdata_len, op_errno, out);
-
- if (op_ret < 0) {
- state = CALL_STATE (frame);
- gf_msg (this->name, GF_LOG_INFO,
- op_errno, 0,
- "%"PRId64": SETACTIVELK %s (%s), client: %s, "
- "error-xlator: %s", frame->root->unique,
- state->loc.path, uuid_utoa (state->resolve.gfid),
- STACK_CLIENT_NAME (frame->root),
- STACK_ERR_XL_NAME (frame->root));
- goto out;
- }
+server_setactivelk_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+ int32_t op_ret, int32_t op_errno, dict_t *xdata)
+{
+ gfs3_setactivelk_rsp rsp = {
+ 0,
+ };
+ server_state_t *state = NULL;
+ rpcsvc_request_t *req = NULL;
+
+ state = CALL_STATE(frame);
+
+ GF_PROTOCOL_DICT_SERIALIZE(this, xdata, &rsp.xdata.xdata_val,
+ rsp.xdata.xdata_len, op_errno, out);
+
+ if (op_ret < 0) {
+ state = CALL_STATE(frame);
+ gf_msg(this->name, GF_LOG_INFO, op_errno, 0,
+ "%" PRId64
+ ": SETACTIVELK %s (%s), client: %s, "
+ "error-xlator: %s",
+ frame->root->unique, state->loc.path,
+ uuid_utoa(state->resolve.gfid), STACK_CLIENT_NAME(frame->root),
+ STACK_ERR_XL_NAME(frame->root));
+ goto out;
+ }
out:
- rsp.op_ret = op_ret;
- rsp.op_errno = gf_errno_to_error (op_errno);
+ rsp.op_ret = op_ret;
+ rsp.op_errno = gf_errno_to_error(op_errno);
- req = frame->local;
+ req = frame->local;
- server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
- (xdrproc_t)xdr_gfs3_setactivelk_rsp);
+ server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gfs3_setactivelk_rsp);
- GF_FREE (rsp.xdata.xdata_val);
+ GF_FREE(rsp.xdata.xdata_val);
- return 0;
+ return 0;
}
int
-server_compound_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
- int32_t op_ret, int32_t op_errno, void *data,
- dict_t *xdata)
+server_compound_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+ int32_t op_ret, int32_t op_errno, void *data, dict_t *xdata)
{
- struct gfs3_compound_rsp rsp = {0,};
- server_state_t *state = NULL;
- rpcsvc_request_t *req = NULL;
- compound_args_cbk_t *args_cbk = data;
- int i = 0;
+ struct gfs3_compound_rsp rsp = {
+ 0,
+ };
+ server_state_t *state = NULL;
+ rpcsvc_request_t *req = NULL;
+ compound_args_cbk_t *args_cbk = data;
+ int i = 0;
- req = frame->local;
- state = CALL_STATE (frame);
+ req = frame->local;
+ state = CALL_STATE(frame);
- GF_PROTOCOL_DICT_SERIALIZE (this, xdata, (&rsp.xdata.xdata_val),
- rsp.xdata.xdata_len, op_errno, out);
+ GF_PROTOCOL_DICT_SERIALIZE(this, xdata, (&rsp.xdata.xdata_val),
+ rsp.xdata.xdata_len, op_errno, out);
- if (op_ret) {
- gf_msg (this->name, fop_log_level (GF_FOP_COMPOUND, op_errno),
- op_errno, PS_MSG_COMPOUND_INFO,
- "%"PRId64": COMPOUND%"PRId64" (%s), client: %s, "
- "error-xlator: %s", frame->root->unique,
- state->resolve.fd_no, uuid_utoa (state->resolve.gfid),
- STACK_CLIENT_NAME (frame->root),
- STACK_ERR_XL_NAME (frame->root));
- }
+ if (op_ret) {
+ gf_msg(this->name, fop_log_level(GF_FOP_COMPOUND, op_errno), op_errno,
+ PS_MSG_COMPOUND_INFO,
+ "%" PRId64 ": COMPOUND%" PRId64
+ " (%s), client: %s, "
+ "error-xlator: %s",
+ frame->root->unique, state->resolve.fd_no,
+ uuid_utoa(state->resolve.gfid), STACK_CLIENT_NAME(frame->root),
+ STACK_ERR_XL_NAME(frame->root));
+ }
- /* TODO: I assume a single 10MB payload is large, if not, we need to
- agree to valid payload */
- if ((args_cbk->fop_length <= 0) ||
- ((args_cbk->fop_length > (10 * 1024 * 1024)))) {
- op_ret = -1;
- op_errno = EINVAL;
- goto out;
- }
+ /* TODO: I assume a single 10MB payload is large, if not, we need to
+ agree to valid payload */
+ if ((args_cbk->fop_length <= 0) ||
+ ((args_cbk->fop_length > (10 * 1024 * 1024)))) {
+ op_ret = -1;
+ op_errno = EINVAL;
+ goto out;
+ }
- rsp.compound_rsp_array.compound_rsp_array_val = GF_CALLOC
- (args_cbk->fop_length,
- sizeof (compound_rsp),
- gf_server_mt_compound_rsp_t);
+ rsp.compound_rsp_array.compound_rsp_array_val = GF_CALLOC(
+ args_cbk->fop_length, sizeof(compound_rsp),
+ gf_server_mt_compound_rsp_t);
- if (!rsp.compound_rsp_array.compound_rsp_array_val) {
- op_ret = -1;
- op_errno = ENOMEM;
- goto out;
- }
- rsp.compound_rsp_array.compound_rsp_array_len = args_cbk->fop_length;
-
- for (i = 0; i < args_cbk->fop_length; i++) {
- op_ret = server_populate_compound_response (this, &rsp,
- frame,
- args_cbk, i);
-
- if (op_ret) {
- op_errno = op_ret;
- op_ret = -1;
- goto out;
- }
+ if (!rsp.compound_rsp_array.compound_rsp_array_val) {
+ op_ret = -1;
+ op_errno = ENOMEM;
+ goto out;
+ }
+ rsp.compound_rsp_array.compound_rsp_array_len = args_cbk->fop_length;
+
+ for (i = 0; i < args_cbk->fop_length; i++) {
+ op_ret = server_populate_compound_response(this, &rsp, frame, args_cbk,
+ i);
+
+ if (op_ret) {
+ op_errno = op_ret;
+ op_ret = -1;
+ goto out;
}
+ }
out:
- rsp.op_ret = op_ret;
- rsp.op_errno = gf_errno_to_error (op_errno);
+ rsp.op_ret = op_ret;
+ rsp.op_errno = gf_errno_to_error(op_errno);
- server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
- (xdrproc_t) xdr_gfs3_compound_rsp);
+ server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gfs3_compound_rsp);
- server_compound_rsp_cleanup (&rsp, args_cbk);
- GF_FREE (rsp.xdata.xdata_val);
+ server_compound_rsp_cleanup(&rsp, args_cbk);
+ GF_FREE(rsp.xdata.xdata_val);
- return 0;
+ return 0;
}
/* Resume function section */
int
-server_rchecksum_resume (call_frame_t *frame, xlator_t *bound_xl)
+server_rchecksum_resume(call_frame_t *frame, xlator_t *bound_xl)
{
- server_state_t *state = NULL;
- int op_ret = 0;
- int op_errno = EINVAL;
+ server_state_t *state = NULL;
+ int op_ret = 0;
+ int op_errno = EINVAL;
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (state->resolve.op_ret != 0) {
- op_ret = state->resolve.op_ret;
- op_errno = state->resolve.op_errno;
- goto err;
- }
+ if (state->resolve.op_ret != 0) {
+ op_ret = state->resolve.op_ret;
+ op_errno = state->resolve.op_errno;
+ goto err;
+ }
- STACK_WIND (frame, server_rchecksum_cbk, bound_xl,
- bound_xl->fops->rchecksum, state->fd,
- state->offset, state->size, state->xdata);
+ STACK_WIND(frame, server_rchecksum_cbk, bound_xl, bound_xl->fops->rchecksum,
+ state->fd, state->offset, state->size, state->xdata);
- return 0;
+ return 0;
err:
- server_rchecksum_cbk (frame, NULL, frame->this, op_ret, op_errno, 0,
- NULL, NULL);
-
- return 0;
+ server_rchecksum_cbk(frame, NULL, frame->this, op_ret, op_errno, 0, NULL,
+ NULL);
+ return 0;
}
int
-server_lease_resume (call_frame_t *frame, xlator_t *bound_xl)
+server_lease_resume(call_frame_t *frame, xlator_t *bound_xl)
{
- server_state_t *state = NULL;
+ server_state_t *state = NULL;
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (state->resolve.op_ret != 0)
- goto err;
+ if (state->resolve.op_ret != 0)
+ goto err;
- STACK_WIND (frame, server_lease_cbk, bound_xl, bound_xl->fops->lease,
- &state->loc, &state->lease, state->xdata);
+ STACK_WIND(frame, server_lease_cbk, bound_xl, bound_xl->fops->lease,
+ &state->loc, &state->lease, state->xdata);
- return 0;
+ return 0;
err:
- server_lease_cbk (frame, NULL, frame->this, state->resolve.op_ret,
- state->resolve.op_errno, NULL, NULL);
- return 0;
+ server_lease_cbk(frame, NULL, frame->this, state->resolve.op_ret,
+ state->resolve.op_errno, NULL, NULL);
+ return 0;
}
int
-server_lk_resume (call_frame_t *frame, xlator_t *bound_xl)
+server_lk_resume(call_frame_t *frame, xlator_t *bound_xl)
{
- server_state_t *state = NULL;
+ server_state_t *state = NULL;
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (state->resolve.op_ret != 0)
- goto err;
+ if (state->resolve.op_ret != 0)
+ goto err;
- STACK_WIND (frame, server_lk_cbk, bound_xl, bound_xl->fops->lk,
- state->fd, state->cmd, &state->flock, state->xdata);
+ STACK_WIND(frame, server_lk_cbk, bound_xl, bound_xl->fops->lk, state->fd,
+ state->cmd, &state->flock, state->xdata);
- return 0;
+ return 0;
err:
- server_lk_cbk (frame, NULL, frame->this, state->resolve.op_ret,
- state->resolve.op_errno, NULL, NULL);
- return 0;
+ server_lk_cbk(frame, NULL, frame->this, state->resolve.op_ret,
+ state->resolve.op_errno, NULL, NULL);
+ return 0;
}
int
-server_rename_resume (call_frame_t *frame, xlator_t *bound_xl)
+server_rename_resume(call_frame_t *frame, xlator_t *bound_xl)
{
- server_state_t *state = NULL;
- int op_ret = 0;
- int op_errno = 0;
+ server_state_t *state = NULL;
+ int op_ret = 0;
+ int op_errno = 0;
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (state->resolve.op_ret != 0) {
- op_ret = state->resolve.op_ret;
- op_errno = state->resolve.op_errno;
- goto err;
- }
+ if (state->resolve.op_ret != 0) {
+ op_ret = state->resolve.op_ret;
+ op_errno = state->resolve.op_errno;
+ goto err;
+ }
- if (state->resolve2.op_ret != 0) {
- op_ret = state->resolve2.op_ret;
- op_errno = state->resolve2.op_errno;
- goto err;
- }
+ if (state->resolve2.op_ret != 0) {
+ op_ret = state->resolve2.op_ret;
+ op_errno = state->resolve2.op_errno;
+ goto err;
+ }
- STACK_WIND (frame, server_rename_cbk,
- bound_xl, bound_xl->fops->rename,
- &state->loc, &state->loc2, state->xdata);
- return 0;
+ STACK_WIND(frame, server_rename_cbk, bound_xl, bound_xl->fops->rename,
+ &state->loc, &state->loc2, state->xdata);
+ return 0;
err:
- server_rename_cbk (frame, NULL, frame->this, op_ret, op_errno,
- NULL, NULL, NULL, NULL, NULL, NULL);
- return 0;
+ server_rename_cbk(frame, NULL, frame->this, op_ret, op_errno, NULL, NULL,
+ NULL, NULL, NULL, NULL);
+ return 0;
}
-
int
-server_link_resume (call_frame_t *frame, xlator_t *bound_xl)
+server_link_resume(call_frame_t *frame, xlator_t *bound_xl)
{
- server_state_t *state = NULL;
- int op_ret = 0;
- int op_errno = 0;
+ server_state_t *state = NULL;
+ int op_ret = 0;
+ int op_errno = 0;
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (state->resolve.op_ret != 0) {
- op_ret = state->resolve.op_ret;
- op_errno = state->resolve.op_errno;
- goto err;
- }
+ if (state->resolve.op_ret != 0) {
+ op_ret = state->resolve.op_ret;
+ op_errno = state->resolve.op_errno;
+ goto err;
+ }
- if (state->resolve2.op_ret != 0) {
- op_ret = state->resolve2.op_ret;
- op_errno = state->resolve2.op_errno;
- goto err;
- }
+ if (state->resolve2.op_ret != 0) {
+ op_ret = state->resolve2.op_ret;
+ op_errno = state->resolve2.op_errno;
+ goto err;
+ }
- state->loc2.inode = inode_ref (state->loc.inode);
+ state->loc2.inode = inode_ref(state->loc.inode);
- STACK_WIND (frame, server_link_cbk, bound_xl, bound_xl->fops->link,
- &state->loc, &state->loc2, state->xdata);
+ STACK_WIND(frame, server_link_cbk, bound_xl, bound_xl->fops->link,
+ &state->loc, &state->loc2, state->xdata);
- return 0;
+ return 0;
err:
- server_link_cbk (frame, NULL, frame->this, op_ret, op_errno,
- NULL, NULL, NULL, NULL, NULL);
- return 0;
+ server_link_cbk(frame, NULL, frame->this, op_ret, op_errno, NULL, NULL,
+ NULL, NULL, NULL);
+ return 0;
}
int
-server_symlink_resume (call_frame_t *frame, xlator_t *bound_xl)
+server_symlink_resume(call_frame_t *frame, xlator_t *bound_xl)
{
- server_state_t *state = NULL;
+ server_state_t *state = NULL;
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (state->resolve.op_ret != 0)
- goto err;
+ if (state->resolve.op_ret != 0)
+ goto err;
- state->loc.inode = inode_new (state->itable);
+ state->loc.inode = inode_new(state->itable);
- STACK_WIND (frame, server_symlink_cbk,
- bound_xl, bound_xl->fops->symlink,
- state->name, &state->loc, state->umask, state->xdata);
+ STACK_WIND(frame, server_symlink_cbk, bound_xl, bound_xl->fops->symlink,
+ state->name, &state->loc, state->umask, state->xdata);
- return 0;
+ return 0;
err:
- server_symlink_cbk (frame, NULL, frame->this, state->resolve.op_ret,
- state->resolve.op_errno, NULL, NULL, NULL, NULL, NULL);
- return 0;
+ server_symlink_cbk(frame, NULL, frame->this, state->resolve.op_ret,
+ state->resolve.op_errno, NULL, NULL, NULL, NULL, NULL);
+ return 0;
}
-
int
-server_access_resume (call_frame_t *frame, xlator_t *bound_xl)
+server_access_resume(call_frame_t *frame, xlator_t *bound_xl)
{
- server_state_t *state = NULL;
+ server_state_t *state = NULL;
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (state->resolve.op_ret != 0)
- goto err;
+ if (state->resolve.op_ret != 0)
+ goto err;
- STACK_WIND (frame, server_access_cbk,
- bound_xl, bound_xl->fops->access,
- &state->loc, state->mask, state->xdata);
- return 0;
+ STACK_WIND(frame, server_access_cbk, bound_xl, bound_xl->fops->access,
+ &state->loc, state->mask, state->xdata);
+ return 0;
err:
- server_access_cbk (frame, NULL, frame->this, state->resolve.op_ret,
- state->resolve.op_errno, NULL);
- return 0;
+ server_access_cbk(frame, NULL, frame->this, state->resolve.op_ret,
+ state->resolve.op_errno, NULL);
+ return 0;
}
int
-server_fentrylk_resume (call_frame_t *frame, xlator_t *bound_xl)
+server_fentrylk_resume(call_frame_t *frame, xlator_t *bound_xl)
{
- GF_UNUSED int ret = -1;
- server_state_t *state = NULL;
+ GF_UNUSED int ret = -1;
+ server_state_t *state = NULL;
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (state->resolve.op_ret != 0)
- goto err;
+ if (state->resolve.op_ret != 0)
+ goto err;
- if (!state->xdata)
- state->xdata = dict_new ();
+ if (!state->xdata)
+ state->xdata = dict_new();
- if (state->xdata)
- ret = dict_set_str (state->xdata, "connection-id",
- frame->root->client->client_uid);
+ if (state->xdata)
+ ret = dict_set_str(state->xdata, "connection-id",
+ frame->root->client->client_uid);
- STACK_WIND (frame, server_fentrylk_cbk, bound_xl,
- bound_xl->fops->fentrylk,
- state->volume, state->fd, state->name,
- state->cmd, state->type, state->xdata);
+ STACK_WIND(frame, server_fentrylk_cbk, bound_xl, bound_xl->fops->fentrylk,
+ state->volume, state->fd, state->name, state->cmd, state->type,
+ state->xdata);
- return 0;
+ return 0;
err:
- server_fentrylk_cbk (frame, NULL, frame->this, state->resolve.op_ret,
- state->resolve.op_errno, NULL);
- return 0;
+ server_fentrylk_cbk(frame, NULL, frame->this, state->resolve.op_ret,
+ state->resolve.op_errno, NULL);
+ return 0;
}
-
int
-server_entrylk_resume (call_frame_t *frame, xlator_t *bound_xl)
+server_entrylk_resume(call_frame_t *frame, xlator_t *bound_xl)
{
- GF_UNUSED int ret = -1;
- server_state_t *state = NULL;
+ GF_UNUSED int ret = -1;
+ server_state_t *state = NULL;
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (state->resolve.op_ret != 0)
- goto err;
+ if (state->resolve.op_ret != 0)
+ goto err;
- if (!state->xdata)
- state->xdata = dict_new ();
+ if (!state->xdata)
+ state->xdata = dict_new();
- if (state->xdata)
- ret = dict_set_str (state->xdata, "connection-id",
- frame->root->client->client_uid);
+ if (state->xdata)
+ ret = dict_set_str(state->xdata, "connection-id",
+ frame->root->client->client_uid);
- STACK_WIND (frame, server_entrylk_cbk,
- bound_xl, bound_xl->fops->entrylk,
- state->volume, &state->loc, state->name,
- state->cmd, state->type, state->xdata);
- return 0;
+ STACK_WIND(frame, server_entrylk_cbk, bound_xl, bound_xl->fops->entrylk,
+ state->volume, &state->loc, state->name, state->cmd, state->type,
+ state->xdata);
+ return 0;
err:
- server_entrylk_cbk (frame, NULL, frame->this, state->resolve.op_ret,
- state->resolve.op_errno, NULL);
- return 0;
+ server_entrylk_cbk(frame, NULL, frame->this, state->resolve.op_ret,
+ state->resolve.op_errno, NULL);
+ return 0;
}
-
int
-server_finodelk_resume (call_frame_t *frame, xlator_t *bound_xl)
+server_finodelk_resume(call_frame_t *frame, xlator_t *bound_xl)
{
- GF_UNUSED int ret = -1;
- server_state_t *state = NULL;
+ GF_UNUSED int ret = -1;
+ server_state_t *state = NULL;
- gf_msg_debug (bound_xl->name, 0, "frame %p, xlator %p", frame,
- bound_xl);
+ gf_msg_debug(bound_xl->name, 0, "frame %p, xlator %p", frame, bound_xl);
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (state->resolve.op_ret != 0)
- goto err;
+ if (state->resolve.op_ret != 0)
+ goto err;
- if (!state->xdata)
- state->xdata = dict_new ();
+ if (!state->xdata)
+ state->xdata = dict_new();
- if (state->xdata)
- ret = dict_set_str (state->xdata, "connection-id",
- frame->root->client->client_uid);
+ if (state->xdata)
+ ret = dict_set_str(state->xdata, "connection-id",
+ frame->root->client->client_uid);
- STACK_WIND (frame, server_finodelk_cbk, bound_xl,
- bound_xl->fops->finodelk, state->volume, state->fd,
- state->cmd, &state->flock, state->xdata);
+ STACK_WIND(frame, server_finodelk_cbk, bound_xl, bound_xl->fops->finodelk,
+ state->volume, state->fd, state->cmd, &state->flock,
+ state->xdata);
- return 0;
+ return 0;
err:
- server_finodelk_cbk (frame, NULL, frame->this, state->resolve.op_ret,
- state->resolve.op_errno, NULL);
+ server_finodelk_cbk(frame, NULL, frame->this, state->resolve.op_ret,
+ state->resolve.op_errno, NULL);
- return 0;
+ return 0;
}
int
-server_inodelk_resume (call_frame_t *frame, xlator_t *bound_xl)
+server_inodelk_resume(call_frame_t *frame, xlator_t *bound_xl)
{
- GF_UNUSED int ret = -1;
- server_state_t *state = NULL;
+ GF_UNUSED int ret = -1;
+ server_state_t *state = NULL;
- gf_msg_debug (bound_xl->name, 0, "frame %p, xlator %p", frame,
- bound_xl);
+ gf_msg_debug(bound_xl->name, 0, "frame %p, xlator %p", frame, bound_xl);
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (state->resolve.op_ret != 0)
- goto err;
+ if (state->resolve.op_ret != 0)
+ goto err;
- if (!state->xdata)
- state->xdata = dict_new ();
+ if (!state->xdata)
+ state->xdata = dict_new();
- if (state->xdata)
- ret = dict_set_str (state->xdata, "connection-id",
- frame->root->client->client_uid);
+ if (state->xdata)
+ ret = dict_set_str(state->xdata, "connection-id",
+ frame->root->client->client_uid);
- STACK_WIND (frame, server_inodelk_cbk, bound_xl,
- bound_xl->fops->inodelk, state->volume, &state->loc,
- state->cmd, &state->flock, state->xdata);
- return 0;
+ STACK_WIND(frame, server_inodelk_cbk, bound_xl, bound_xl->fops->inodelk,
+ state->volume, &state->loc, state->cmd, &state->flock,
+ state->xdata);
+ return 0;
err:
- server_inodelk_cbk (frame, NULL, frame->this, state->resolve.op_ret,
- state->resolve.op_errno, NULL);
- return 0;
+ server_inodelk_cbk(frame, NULL, frame->this, state->resolve.op_ret,
+ state->resolve.op_errno, NULL);
+ return 0;
}
int
-server_rmdir_resume (call_frame_t *frame, xlator_t *bound_xl)
+server_rmdir_resume(call_frame_t *frame, xlator_t *bound_xl)
{
- server_state_t *state = NULL;
+ server_state_t *state = NULL;
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (state->resolve.op_ret != 0)
- goto err;
+ if (state->resolve.op_ret != 0)
+ goto err;
- STACK_WIND (frame, server_rmdir_cbk, bound_xl, bound_xl->fops->rmdir,
- &state->loc, state->flags, state->xdata);
- return 0;
+ STACK_WIND(frame, server_rmdir_cbk, bound_xl, bound_xl->fops->rmdir,
+ &state->loc, state->flags, state->xdata);
+ return 0;
err:
- server_rmdir_cbk (frame, NULL, frame->this, state->resolve.op_ret,
- state->resolve.op_errno, NULL, NULL, NULL);
- return 0;
+ server_rmdir_cbk(frame, NULL, frame->this, state->resolve.op_ret,
+ state->resolve.op_errno, NULL, NULL, NULL);
+ return 0;
}
int
-server_mkdir_resume (call_frame_t *frame, xlator_t *bound_xl)
+server_mkdir_resume(call_frame_t *frame, xlator_t *bound_xl)
{
- server_state_t *state = NULL;
+ server_state_t *state = NULL;
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (state->resolve.op_ret != 0)
- goto err;
+ if (state->resolve.op_ret != 0)
+ goto err;
- state->loc.inode = inode_new (state->itable);
+ state->loc.inode = inode_new(state->itable);
- STACK_WIND (frame, server_mkdir_cbk,
- bound_xl, bound_xl->fops->mkdir,
- &(state->loc), state->mode, state->umask, state->xdata);
+ STACK_WIND(frame, server_mkdir_cbk, bound_xl, bound_xl->fops->mkdir,
+ &(state->loc), state->mode, state->umask, state->xdata);
- return 0;
+ return 0;
err:
- server_mkdir_cbk (frame, NULL, frame->this, state->resolve.op_ret,
- state->resolve.op_errno, NULL, NULL, NULL, NULL, NULL);
- return 0;
+ server_mkdir_cbk(frame, NULL, frame->this, state->resolve.op_ret,
+ state->resolve.op_errno, NULL, NULL, NULL, NULL, NULL);
+ return 0;
}
-
int
-server_mknod_resume (call_frame_t *frame, xlator_t *bound_xl)
+server_mknod_resume(call_frame_t *frame, xlator_t *bound_xl)
{
- server_state_t *state = NULL;
+ server_state_t *state = NULL;
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (state->resolve.op_ret != 0)
- goto err;
+ if (state->resolve.op_ret != 0)
+ goto err;
- state->loc.inode = inode_new (state->itable);
+ state->loc.inode = inode_new(state->itable);
- STACK_WIND (frame, server_mknod_cbk,
- bound_xl, bound_xl->fops->mknod,
- &(state->loc), state->mode, state->dev,
- state->umask, state->xdata);
+ STACK_WIND(frame, server_mknod_cbk, bound_xl, bound_xl->fops->mknod,
+ &(state->loc), state->mode, state->dev, state->umask,
+ state->xdata);
- return 0;
+ return 0;
err:
- server_mknod_cbk (frame, NULL, frame->this, state->resolve.op_ret,
- state->resolve.op_errno, NULL, NULL, NULL, NULL, NULL);
- return 0;
+ server_mknod_cbk(frame, NULL, frame->this, state->resolve.op_ret,
+ state->resolve.op_errno, NULL, NULL, NULL, NULL, NULL);
+ return 0;
}
-
int
-server_fsyncdir_resume (call_frame_t *frame, xlator_t *bound_xl)
+server_fsyncdir_resume(call_frame_t *frame, xlator_t *bound_xl)
{
- server_state_t *state = NULL;
+ server_state_t *state = NULL;
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (state->resolve.op_ret != 0)
- goto err;
+ if (state->resolve.op_ret != 0)
+ goto err;
- STACK_WIND (frame, server_fsyncdir_cbk,
- bound_xl,
- bound_xl->fops->fsyncdir,
- state->fd, state->flags, state->xdata);
- return 0;
+ STACK_WIND(frame, server_fsyncdir_cbk, bound_xl, bound_xl->fops->fsyncdir,
+ state->fd, state->flags, state->xdata);
+ return 0;
err:
- server_fsyncdir_cbk (frame, NULL, frame->this,
- state->resolve.op_ret,
- state->resolve.op_errno, NULL);
- return 0;
+ server_fsyncdir_cbk(frame, NULL, frame->this, state->resolve.op_ret,
+ state->resolve.op_errno, NULL);
+ return 0;
}
-
int
-server_readdir_resume (call_frame_t *frame, xlator_t *bound_xl)
+server_readdir_resume(call_frame_t *frame, xlator_t *bound_xl)
{
- server_state_t *state = NULL;
+ server_state_t *state = NULL;
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (state->resolve.op_ret != 0)
- goto err;
+ if (state->resolve.op_ret != 0)
+ goto err;
- GF_ASSERT (state->fd);
+ GF_ASSERT(state->fd);
- STACK_WIND (frame, server_readdir_cbk,
- bound_xl,
- bound_xl->fops->readdir,
- state->fd, state->size, state->offset, state->xdata);
+ STACK_WIND(frame, server_readdir_cbk, bound_xl, bound_xl->fops->readdir,
+ state->fd, state->size, state->offset, state->xdata);
- return 0;
+ return 0;
err:
- server_readdir_cbk (frame, NULL, frame->this, state->resolve.op_ret,
- state->resolve.op_errno, NULL, NULL);
- return 0;
+ server_readdir_cbk(frame, NULL, frame->this, state->resolve.op_ret,
+ state->resolve.op_errno, NULL, NULL);
+ return 0;
}
int
-server_readdirp_resume (call_frame_t *frame, xlator_t *bound_xl)
+server_readdirp_resume(call_frame_t *frame, xlator_t *bound_xl)
{
- server_state_t *state = NULL;
+ server_state_t *state = NULL;
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (state->resolve.op_ret != 0)
- goto err;
+ if (state->resolve.op_ret != 0)
+ goto err;
- STACK_WIND (frame, server_readdirp_cbk, bound_xl,
- bound_xl->fops->readdirp, state->fd, state->size,
- state->offset, state->dict);
+ STACK_WIND(frame, server_readdirp_cbk, bound_xl, bound_xl->fops->readdirp,
+ state->fd, state->size, state->offset, state->dict);
- return 0;
+ return 0;
err:
- server_readdirp_cbk (frame, NULL, frame->this, state->resolve.op_ret,
- state->resolve.op_errno, NULL, NULL);
- return 0;
+ server_readdirp_cbk(frame, NULL, frame->this, state->resolve.op_ret,
+ state->resolve.op_errno, NULL, NULL);
+ return 0;
}
-
int
-server_opendir_resume (call_frame_t *frame, xlator_t *bound_xl)
+server_opendir_resume(call_frame_t *frame, xlator_t *bound_xl)
{
- server_state_t *state = NULL;
+ server_state_t *state = NULL;
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (state->resolve.op_ret != 0)
- goto err;
+ if (state->resolve.op_ret != 0)
+ goto err;
- state->fd = fd_create (state->loc.inode, frame->root->pid);
- if (!state->fd) {
- gf_msg ("server", GF_LOG_ERROR, 0, PS_MSG_FD_CREATE_FAILED,
- "could not create the fd");
- goto err;
- }
+ state->fd = fd_create(state->loc.inode, frame->root->pid);
+ if (!state->fd) {
+ gf_msg("server", GF_LOG_ERROR, 0, PS_MSG_FD_CREATE_FAILED,
+ "could not create the fd");
+ goto err;
+ }
- STACK_WIND (frame, server_opendir_cbk,
- bound_xl, bound_xl->fops->opendir,
- &state->loc, state->fd, state->xdata);
- return 0;
+ STACK_WIND(frame, server_opendir_cbk, bound_xl, bound_xl->fops->opendir,
+ &state->loc, state->fd, state->xdata);
+ return 0;
err:
- server_opendir_cbk (frame, NULL, frame->this, state->resolve.op_ret,
- state->resolve.op_errno, NULL, NULL);
- return 0;
+ server_opendir_cbk(frame, NULL, frame->this, state->resolve.op_ret,
+ state->resolve.op_errno, NULL, NULL);
+ return 0;
}
-
int
-server_statfs_resume (call_frame_t *frame, xlator_t *bound_xl)
+server_statfs_resume(call_frame_t *frame, xlator_t *bound_xl)
{
- server_state_t *state = NULL;
+ server_state_t *state = NULL;
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (state->resolve.op_ret !=0)
- goto err;
+ if (state->resolve.op_ret != 0)
+ goto err;
- STACK_WIND (frame, server_statfs_cbk,
- bound_xl, bound_xl->fops->statfs,
- &state->loc, state->xdata);
- return 0;
+ STACK_WIND(frame, server_statfs_cbk, bound_xl, bound_xl->fops->statfs,
+ &state->loc, state->xdata);
+ return 0;
err:
- server_statfs_cbk (frame, NULL, frame->this, state->resolve.op_ret,
- state->resolve.op_errno, NULL, NULL);
- return 0;
+ server_statfs_cbk(frame, NULL, frame->this, state->resolve.op_ret,
+ state->resolve.op_errno, NULL, NULL);
+ return 0;
}
-
int
-server_removexattr_resume (call_frame_t *frame, xlator_t *bound_xl)
+server_removexattr_resume(call_frame_t *frame, xlator_t *bound_xl)
{
- server_state_t *state = NULL;
+ server_state_t *state = NULL;
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (state->resolve.op_ret != 0)
- goto err;
+ if (state->resolve.op_ret != 0)
+ goto err;
- STACK_WIND (frame, server_removexattr_cbk,
- bound_xl, bound_xl->fops->removexattr,
- &state->loc, state->name, state->xdata);
- return 0;
+ STACK_WIND(frame, server_removexattr_cbk, bound_xl,
+ bound_xl->fops->removexattr, &state->loc, state->name,
+ state->xdata);
+ return 0;
err:
- server_removexattr_cbk (frame, NULL, frame->this, state->resolve.op_ret,
- state->resolve.op_errno, NULL);
- return 0;
+ server_removexattr_cbk(frame, NULL, frame->this, state->resolve.op_ret,
+ state->resolve.op_errno, NULL);
+ return 0;
}
int
-server_fremovexattr_resume (call_frame_t *frame, xlator_t *bound_xl)
+server_fremovexattr_resume(call_frame_t *frame, xlator_t *bound_xl)
{
- server_state_t *state = NULL;
+ server_state_t *state = NULL;
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (state->resolve.op_ret != 0)
- goto err;
+ if (state->resolve.op_ret != 0)
+ goto err;
- STACK_WIND (frame, server_fremovexattr_cbk,
- bound_xl, bound_xl->fops->fremovexattr,
- state->fd, state->name, state->xdata);
- return 0;
+ STACK_WIND(frame, server_fremovexattr_cbk, bound_xl,
+ bound_xl->fops->fremovexattr, state->fd, state->name,
+ state->xdata);
+ return 0;
err:
- server_fremovexattr_cbk (frame, NULL, frame->this, state->resolve.op_ret,
- state->resolve.op_errno, NULL);
- return 0;
+ server_fremovexattr_cbk(frame, NULL, frame->this, state->resolve.op_ret,
+ state->resolve.op_errno, NULL);
+ return 0;
}
int
-server_fgetxattr_resume (call_frame_t *frame, xlator_t *bound_xl)
+server_fgetxattr_resume(call_frame_t *frame, xlator_t *bound_xl)
{
- server_state_t *state = NULL;
+ server_state_t *state = NULL;
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (state->resolve.op_ret != 0)
- goto err;
+ if (state->resolve.op_ret != 0)
+ goto err;
- STACK_WIND (frame, server_fgetxattr_cbk,
- bound_xl, bound_xl->fops->fgetxattr,
- state->fd, state->name, state->xdata);
- return 0;
+ STACK_WIND(frame, server_fgetxattr_cbk, bound_xl, bound_xl->fops->fgetxattr,
+ state->fd, state->name, state->xdata);
+ return 0;
err:
- server_fgetxattr_cbk (frame, NULL, frame->this, state->resolve.op_ret,
- state->resolve.op_errno, NULL, NULL);
- return 0;
+ server_fgetxattr_cbk(frame, NULL, frame->this, state->resolve.op_ret,
+ state->resolve.op_errno, NULL, NULL);
+ return 0;
}
-
int
-server_xattrop_resume (call_frame_t *frame, xlator_t *bound_xl)
+server_xattrop_resume(call_frame_t *frame, xlator_t *bound_xl)
{
- server_state_t *state = NULL;
+ server_state_t *state = NULL;
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (state->resolve.op_ret != 0)
- goto err;
+ if (state->resolve.op_ret != 0)
+ goto err;
- STACK_WIND (frame, server_xattrop_cbk,
- bound_xl, bound_xl->fops->xattrop,
- &state->loc, state->flags, state->dict, state->xdata);
- return 0;
+ STACK_WIND(frame, server_xattrop_cbk, bound_xl, bound_xl->fops->xattrop,
+ &state->loc, state->flags, state->dict, state->xdata);
+ return 0;
err:
- server_xattrop_cbk (frame, NULL, frame->this, state->resolve.op_ret,
- state->resolve.op_errno, NULL, NULL);
- return 0;
+ server_xattrop_cbk(frame, NULL, frame->this, state->resolve.op_ret,
+ state->resolve.op_errno, NULL, NULL);
+ return 0;
}
int
-server_fxattrop_resume (call_frame_t *frame, xlator_t *bound_xl)
+server_fxattrop_resume(call_frame_t *frame, xlator_t *bound_xl)
{
- server_state_t *state = NULL;
+ server_state_t *state = NULL;
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (state->resolve.op_ret != 0)
- goto err;
+ if (state->resolve.op_ret != 0)
+ goto err;
- STACK_WIND (frame, server_fxattrop_cbk,
- bound_xl, bound_xl->fops->fxattrop,
- state->fd, state->flags, state->dict, state->xdata);
- return 0;
+ STACK_WIND(frame, server_fxattrop_cbk, bound_xl, bound_xl->fops->fxattrop,
+ state->fd, state->flags, state->dict, state->xdata);
+ return 0;
err:
- server_fxattrop_cbk (frame, NULL, frame->this, state->resolve.op_ret,
- state->resolve.op_errno, NULL, NULL);
- return 0;
+ server_fxattrop_cbk(frame, NULL, frame->this, state->resolve.op_ret,
+ state->resolve.op_errno, NULL, NULL);
+ return 0;
}
int
-server_fsetxattr_resume (call_frame_t *frame, xlator_t *bound_xl)
+server_fsetxattr_resume(call_frame_t *frame, xlator_t *bound_xl)
{
- server_state_t *state = NULL;
+ server_state_t *state = NULL;
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (state->resolve.op_ret != 0)
- goto err;
+ if (state->resolve.op_ret != 0)
+ goto err;
- STACK_WIND (frame, server_setxattr_cbk,
- bound_xl, bound_xl->fops->fsetxattr,
- state->fd, state->dict, state->flags, state->xdata);
- return 0;
+ STACK_WIND(frame, server_setxattr_cbk, bound_xl, bound_xl->fops->fsetxattr,
+ state->fd, state->dict, state->flags, state->xdata);
+ return 0;
err:
- server_fsetxattr_cbk (frame, NULL, frame->this, state->resolve.op_ret,
- state->resolve.op_errno, NULL);
+ server_fsetxattr_cbk(frame, NULL, frame->this, state->resolve.op_ret,
+ state->resolve.op_errno, NULL);
- return 0;
+ return 0;
}
int
-server_unlink_resume (call_frame_t *frame, xlator_t *bound_xl)
+server_unlink_resume(call_frame_t *frame, xlator_t *bound_xl)
{
- server_state_t *state = NULL;
+ server_state_t *state = NULL;
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (state->resolve.op_ret != 0)
- goto err;
+ if (state->resolve.op_ret != 0)
+ goto err;
- STACK_WIND (frame, server_unlink_cbk,
- bound_xl, bound_xl->fops->unlink,
- &state->loc, state->flags, state->xdata);
- return 0;
+ STACK_WIND(frame, server_unlink_cbk, bound_xl, bound_xl->fops->unlink,
+ &state->loc, state->flags, state->xdata);
+ return 0;
err:
- server_unlink_cbk (frame, NULL, frame->this, state->resolve.op_ret,
- state->resolve.op_errno, NULL, NULL, NULL);
- return 0;
+ server_unlink_cbk(frame, NULL, frame->this, state->resolve.op_ret,
+ state->resolve.op_errno, NULL, NULL, NULL);
+ return 0;
}
int
-server_truncate_resume (call_frame_t *frame, xlator_t *bound_xl)
+server_truncate_resume(call_frame_t *frame, xlator_t *bound_xl)
{
- server_state_t *state = NULL;
+ server_state_t *state = NULL;
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (state->resolve.op_ret != 0)
- goto err;
+ if (state->resolve.op_ret != 0)
+ goto err;
- STACK_WIND (frame, server_truncate_cbk,
- bound_xl, bound_xl->fops->truncate,
- &state->loc, state->offset, state->xdata);
- return 0;
+ STACK_WIND(frame, server_truncate_cbk, bound_xl, bound_xl->fops->truncate,
+ &state->loc, state->offset, state->xdata);
+ return 0;
err:
- server_truncate_cbk (frame, NULL, frame->this, state->resolve.op_ret,
- state->resolve.op_errno, NULL, NULL, NULL);
- return 0;
+ server_truncate_cbk(frame, NULL, frame->this, state->resolve.op_ret,
+ state->resolve.op_errno, NULL, NULL, NULL);
+ return 0;
}
-
-
int
-server_fstat_resume (call_frame_t *frame, xlator_t *bound_xl)
+server_fstat_resume(call_frame_t *frame, xlator_t *bound_xl)
{
- server_state_t *state = NULL;
+ server_state_t *state = NULL;
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (state->resolve.op_ret != 0)
- goto err;
+ if (state->resolve.op_ret != 0)
+ goto err;
- STACK_WIND (frame, server_fstat_cbk,
- bound_xl, bound_xl->fops->fstat,
- state->fd, state->xdata);
- return 0;
+ STACK_WIND(frame, server_fstat_cbk, bound_xl, bound_xl->fops->fstat,
+ state->fd, state->xdata);
+ return 0;
err:
- server_fstat_cbk (frame, NULL, frame->this, state->resolve.op_ret,
- state->resolve.op_errno, NULL, NULL);
- return 0;
+ server_fstat_cbk(frame, NULL, frame->this, state->resolve.op_ret,
+ state->resolve.op_errno, NULL, NULL);
+ return 0;
}
-
int
-server_setxattr_resume (call_frame_t *frame, xlator_t *bound_xl)
+server_setxattr_resume(call_frame_t *frame, xlator_t *bound_xl)
{
- server_state_t *state = NULL;
+ server_state_t *state = NULL;
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (state->resolve.op_ret != 0)
- goto err;
+ if (state->resolve.op_ret != 0)
+ goto err;
- STACK_WIND (frame, server_setxattr_cbk,
- bound_xl, bound_xl->fops->setxattr,
- &state->loc, state->dict, state->flags, state->xdata);
- return 0;
+ STACK_WIND(frame, server_setxattr_cbk, bound_xl, bound_xl->fops->setxattr,
+ &state->loc, state->dict, state->flags, state->xdata);
+ return 0;
err:
- server_setxattr_cbk (frame, NULL, frame->this, state->resolve.op_ret,
- state->resolve.op_errno, NULL);
+ server_setxattr_cbk(frame, NULL, frame->this, state->resolve.op_ret,
+ state->resolve.op_errno, NULL);
- return 0;
+ return 0;
}
-
int
-server_getxattr_resume (call_frame_t *frame, xlator_t *bound_xl)
+server_getxattr_resume(call_frame_t *frame, xlator_t *bound_xl)
{
- server_state_t *state = NULL;
+ server_state_t *state = NULL;
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (state->resolve.op_ret != 0)
- goto err;
+ if (state->resolve.op_ret != 0)
+ goto err;
- STACK_WIND (frame, server_getxattr_cbk,
- bound_xl, bound_xl->fops->getxattr,
- &state->loc, state->name, state->xdata);
- return 0;
+ STACK_WIND(frame, server_getxattr_cbk, bound_xl, bound_xl->fops->getxattr,
+ &state->loc, state->name, state->xdata);
+ return 0;
err:
- server_getxattr_cbk (frame, NULL, frame->this, state->resolve.op_ret,
- state->resolve.op_errno, NULL, NULL);
- return 0;
+ server_getxattr_cbk(frame, NULL, frame->this, state->resolve.op_ret,
+ state->resolve.op_errno, NULL, NULL);
+ return 0;
}
-
int
-server_ftruncate_resume (call_frame_t *frame, xlator_t *bound_xl)
+server_ftruncate_resume(call_frame_t *frame, xlator_t *bound_xl)
{
- server_state_t *state = NULL;
+ server_state_t *state = NULL;
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (state->resolve.op_ret != 0)
- goto err;
+ if (state->resolve.op_ret != 0)
+ goto err;
- STACK_WIND (frame, server_ftruncate_cbk,
- bound_xl, bound_xl->fops->ftruncate,
- state->fd, state->offset, state->xdata);
- return 0;
+ STACK_WIND(frame, server_ftruncate_cbk, bound_xl, bound_xl->fops->ftruncate,
+ state->fd, state->offset, state->xdata);
+ return 0;
err:
- server_ftruncate_cbk (frame, NULL, frame->this, state->resolve.op_ret,
- state->resolve.op_errno, NULL, NULL, NULL);
+ server_ftruncate_cbk(frame, NULL, frame->this, state->resolve.op_ret,
+ state->resolve.op_errno, NULL, NULL, NULL);
- return 0;
+ return 0;
}
-
int
-server_flush_resume (call_frame_t *frame, xlator_t *bound_xl)
+server_flush_resume(call_frame_t *frame, xlator_t *bound_xl)
{
- server_state_t *state = NULL;
+ server_state_t *state = NULL;
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (state->resolve.op_ret != 0)
- goto err;
+ if (state->resolve.op_ret != 0)
+ goto err;
- STACK_WIND (frame, server_flush_cbk,
- bound_xl, bound_xl->fops->flush, state->fd, state->xdata);
- return 0;
+ STACK_WIND(frame, server_flush_cbk, bound_xl, bound_xl->fops->flush,
+ state->fd, state->xdata);
+ return 0;
err:
- server_flush_cbk (frame, NULL, frame->this, state->resolve.op_ret,
- state->resolve.op_errno, NULL);
+ server_flush_cbk(frame, NULL, frame->this, state->resolve.op_ret,
+ state->resolve.op_errno, NULL);
- return 0;
+ return 0;
}
-
int
-server_fsync_resume (call_frame_t *frame, xlator_t *bound_xl)
+server_fsync_resume(call_frame_t *frame, xlator_t *bound_xl)
{
- server_state_t *state = NULL;
+ server_state_t *state = NULL;
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (state->resolve.op_ret != 0)
- goto err;
+ if (state->resolve.op_ret != 0)
+ goto err;
- STACK_WIND (frame, server_fsync_cbk,
- bound_xl, bound_xl->fops->fsync,
- state->fd, state->flags, state->xdata);
- return 0;
+ STACK_WIND(frame, server_fsync_cbk, bound_xl, bound_xl->fops->fsync,
+ state->fd, state->flags, state->xdata);
+ return 0;
err:
- server_fsync_cbk (frame, NULL, frame->this, state->resolve.op_ret,
- state->resolve.op_errno, NULL, NULL, NULL);
+ server_fsync_cbk(frame, NULL, frame->this, state->resolve.op_ret,
+ state->resolve.op_errno, NULL, NULL, NULL);
- return 0;
+ return 0;
}
int
-server_writev_resume (call_frame_t *frame, xlator_t *bound_xl)
+server_writev_resume(call_frame_t *frame, xlator_t *bound_xl)
{
- server_state_t *state = NULL;
+ server_state_t *state = NULL;
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (state->resolve.op_ret != 0)
- goto err;
+ if (state->resolve.op_ret != 0)
+ goto err;
- STACK_WIND (frame, server_writev_cbk,
- bound_xl, bound_xl->fops->writev,
- state->fd, state->payload_vector, state->payload_count,
- state->offset, state->flags, state->iobref, state->xdata);
+ STACK_WIND(frame, server_writev_cbk, bound_xl, bound_xl->fops->writev,
+ state->fd, state->payload_vector, state->payload_count,
+ state->offset, state->flags, state->iobref, state->xdata);
- return 0;
+ return 0;
err:
- server_writev_cbk (frame, NULL, frame->this, state->resolve.op_ret,
- state->resolve.op_errno, NULL, NULL, NULL);
- return 0;
+ server_writev_cbk(frame, NULL, frame->this, state->resolve.op_ret,
+ state->resolve.op_errno, NULL, NULL, NULL);
+ return 0;
}
-
int
-server_readv_resume (call_frame_t *frame, xlator_t *bound_xl)
+server_readv_resume(call_frame_t *frame, xlator_t *bound_xl)
{
- server_state_t *state = NULL;
+ server_state_t *state = NULL;
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (state->resolve.op_ret != 0)
- goto err;
+ if (state->resolve.op_ret != 0)
+ goto err;
- STACK_WIND (frame, server_readv_cbk,
- bound_xl, bound_xl->fops->readv,
- state->fd, state->size, state->offset, state->flags, state->xdata);
+ STACK_WIND(frame, server_readv_cbk, bound_xl, bound_xl->fops->readv,
+ state->fd, state->size, state->offset, state->flags,
+ state->xdata);
- return 0;
+ return 0;
err:
- server_readv_cbk (frame, NULL, frame->this, state->resolve.op_ret,
- state->resolve.op_errno, NULL, 0, NULL, NULL, NULL);
- return 0;
+ server_readv_cbk(frame, NULL, frame->this, state->resolve.op_ret,
+ state->resolve.op_errno, NULL, 0, NULL, NULL, NULL);
+ return 0;
}
-
int
-server_create_resume (call_frame_t *frame, xlator_t *bound_xl)
+server_create_resume(call_frame_t *frame, xlator_t *bound_xl)
{
- server_state_t *state = NULL;
+ server_state_t *state = NULL;
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (state->resolve.op_ret != 0)
- goto err;
+ if (state->resolve.op_ret != 0)
+ goto err;
- state->loc.inode = inode_new (state->itable);
+ state->loc.inode = inode_new(state->itable);
- state->fd = fd_create (state->loc.inode, frame->root->pid);
- if (!state->fd) {
- gf_msg ("server", GF_LOG_ERROR, 0, PS_MSG_FD_CREATE_FAILED,
- "fd creation for the inode %s failed",
- state->loc.inode ?
- uuid_utoa (state->loc.inode->gfid):NULL);
- state->resolve.op_ret = -1;
- state->resolve.op_errno = ENOMEM;
- goto err;
- }
- state->fd->flags = state->flags;
+ state->fd = fd_create(state->loc.inode, frame->root->pid);
+ if (!state->fd) {
+ gf_msg("server", GF_LOG_ERROR, 0, PS_MSG_FD_CREATE_FAILED,
+ "fd creation for the inode %s failed",
+ state->loc.inode ? uuid_utoa(state->loc.inode->gfid) : NULL);
+ state->resolve.op_ret = -1;
+ state->resolve.op_errno = ENOMEM;
+ goto err;
+ }
+ state->fd->flags = state->flags;
- STACK_WIND (frame, server_create_cbk,
- bound_xl, bound_xl->fops->create,
- &(state->loc), state->flags, state->mode,
- state->umask, state->fd, state->xdata);
+ STACK_WIND(frame, server_create_cbk, bound_xl, bound_xl->fops->create,
+ &(state->loc), state->flags, state->mode, state->umask,
+ state->fd, state->xdata);
- return 0;
+ return 0;
err:
- server_create_cbk (frame, NULL, frame->this, state->resolve.op_ret,
- state->resolve.op_errno, NULL, NULL, NULL,
- NULL, NULL, NULL);
- return 0;
+ server_create_cbk(frame, NULL, frame->this, state->resolve.op_ret,
+ state->resolve.op_errno, NULL, NULL, NULL, NULL, NULL,
+ NULL);
+ return 0;
}
-
int
-server_open_resume (call_frame_t *frame, xlator_t *bound_xl)
+server_open_resume(call_frame_t *frame, xlator_t *bound_xl)
{
- server_state_t *state = NULL;
+ server_state_t *state = NULL;
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (state->resolve.op_ret != 0)
- goto err;
+ if (state->resolve.op_ret != 0)
+ goto err;
- state->fd = fd_create (state->loc.inode, frame->root->pid);
- state->fd->flags = state->flags;
+ state->fd = fd_create(state->loc.inode, frame->root->pid);
+ state->fd->flags = state->flags;
- STACK_WIND (frame, server_open_cbk,
- bound_xl, bound_xl->fops->open,
- &state->loc, state->flags, state->fd, state->xdata);
+ STACK_WIND(frame, server_open_cbk, bound_xl, bound_xl->fops->open,
+ &state->loc, state->flags, state->fd, state->xdata);
- return 0;
+ return 0;
err:
- server_open_cbk (frame, NULL, frame->this, state->resolve.op_ret,
- state->resolve.op_errno, NULL, NULL);
- return 0;
+ server_open_cbk(frame, NULL, frame->this, state->resolve.op_ret,
+ state->resolve.op_errno, NULL, NULL);
+ return 0;
}
-
int
-server_readlink_resume (call_frame_t *frame, xlator_t *bound_xl)
+server_readlink_resume(call_frame_t *frame, xlator_t *bound_xl)
{
- server_state_t *state = NULL;
+ server_state_t *state = NULL;
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (state->resolve.op_ret != 0)
- goto err;
+ if (state->resolve.op_ret != 0)
+ goto err;
- STACK_WIND (frame, server_readlink_cbk,
- bound_xl, bound_xl->fops->readlink,
- &state->loc, state->size, state->xdata);
- return 0;
+ STACK_WIND(frame, server_readlink_cbk, bound_xl, bound_xl->fops->readlink,
+ &state->loc, state->size, state->xdata);
+ return 0;
err:
- server_readlink_cbk (frame, NULL, frame->this, state->resolve.op_ret,
- state->resolve.op_errno, NULL, NULL, NULL);
- return 0;
+ server_readlink_cbk(frame, NULL, frame->this, state->resolve.op_ret,
+ state->resolve.op_errno, NULL, NULL, NULL);
+ return 0;
}
-
int
-server_fsetattr_resume (call_frame_t *frame, xlator_t *bound_xl)
+server_fsetattr_resume(call_frame_t *frame, xlator_t *bound_xl)
{
- server_state_t *state = NULL;
+ server_state_t *state = NULL;
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (state->resolve.op_ret != 0)
- goto err;
+ if (state->resolve.op_ret != 0)
+ goto err;
- STACK_WIND (frame, server_fsetattr_cbk,
- bound_xl, bound_xl->fops->fsetattr,
- state->fd, &state->stbuf, state->valid, state->xdata);
- return 0;
+ STACK_WIND(frame, server_fsetattr_cbk, bound_xl, bound_xl->fops->fsetattr,
+ state->fd, &state->stbuf, state->valid, state->xdata);
+ return 0;
err:
- server_fsetattr_cbk (frame, NULL, frame->this, state->resolve.op_ret,
- state->resolve.op_errno, NULL, NULL, NULL);
+ server_fsetattr_cbk(frame, NULL, frame->this, state->resolve.op_ret,
+ state->resolve.op_errno, NULL, NULL, NULL);
- return 0;
+ return 0;
}
-
int
-server_setattr_resume (call_frame_t *frame, xlator_t *bound_xl)
+server_setattr_resume(call_frame_t *frame, xlator_t *bound_xl)
{
- server_state_t *state = NULL;
+ server_state_t *state = NULL;
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (state->resolve.op_ret != 0)
- goto err;
+ if (state->resolve.op_ret != 0)
+ goto err;
- STACK_WIND (frame, server_setattr_cbk,
- bound_xl, bound_xl->fops->setattr,
- &state->loc, &state->stbuf, state->valid, state->xdata);
- return 0;
+ STACK_WIND(frame, server_setattr_cbk, bound_xl, bound_xl->fops->setattr,
+ &state->loc, &state->stbuf, state->valid, state->xdata);
+ return 0;
err:
- server_setattr_cbk (frame, NULL, frame->this, state->resolve.op_ret,
- state->resolve.op_errno, NULL, NULL, NULL);
+ server_setattr_cbk(frame, NULL, frame->this, state->resolve.op_ret,
+ state->resolve.op_errno, NULL, NULL, NULL);
- return 0;
+ return 0;
}
-
int
-server_stat_resume (call_frame_t *frame, xlator_t *bound_xl)
+server_stat_resume(call_frame_t *frame, xlator_t *bound_xl)
{
- server_state_t *state = NULL;
+ server_state_t *state = NULL;
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (state->resolve.op_ret != 0)
- goto err;
+ if (state->resolve.op_ret != 0)
+ goto err;
- STACK_WIND (frame, server_stat_cbk,
- bound_xl, bound_xl->fops->stat, &state->loc, state->xdata);
- return 0;
+ STACK_WIND(frame, server_stat_cbk, bound_xl, bound_xl->fops->stat,
+ &state->loc, state->xdata);
+ return 0;
err:
- server_stat_cbk (frame, NULL, frame->this, state->resolve.op_ret,
- state->resolve.op_errno, NULL, NULL);
- return 0;
+ server_stat_cbk(frame, NULL, frame->this, state->resolve.op_ret,
+ state->resolve.op_errno, NULL, NULL);
+ return 0;
}
int
-server_lookup_resume (call_frame_t *frame, xlator_t *bound_xl)
+server_lookup_resume(call_frame_t *frame, xlator_t *bound_xl)
{
- server_state_t *state = NULL;
+ server_state_t *state = NULL;
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (state->resolve.op_ret != 0)
- goto err;
+ if (state->resolve.op_ret != 0)
+ goto err;
- if (!state->loc.inode)
- state->loc.inode = server_inode_new (state->itable,
- state->loc.gfid);
- else
- state->is_revalidate = 1;
+ if (!state->loc.inode)
+ state->loc.inode = server_inode_new(state->itable, state->loc.gfid);
+ else
+ state->is_revalidate = 1;
- STACK_WIND (frame, server_lookup_cbk,
- bound_xl, bound_xl->fops->lookup,
- &state->loc, state->xdata);
+ STACK_WIND(frame, server_lookup_cbk, bound_xl, bound_xl->fops->lookup,
+ &state->loc, state->xdata);
- return 0;
+ return 0;
err:
- server_lookup_cbk (frame, NULL, frame->this, state->resolve.op_ret,
- state->resolve.op_errno, NULL, NULL, NULL, NULL);
+ server_lookup_cbk(frame, NULL, frame->this, state->resolve.op_ret,
+ state->resolve.op_errno, NULL, NULL, NULL, NULL);
- return 0;
+ return 0;
}
int
-server_fallocate_resume (call_frame_t *frame, xlator_t *bound_xl)
+server_fallocate_resume(call_frame_t *frame, xlator_t *bound_xl)
{
- server_state_t *state = NULL;
+ server_state_t *state = NULL;
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (state->resolve.op_ret != 0)
- goto err;
+ if (state->resolve.op_ret != 0)
+ goto err;
- STACK_WIND (frame, server_fallocate_cbk,
- bound_xl, bound_xl->fops->fallocate,
- state->fd, state->flags, state->offset, state->size,
- state->xdata);
- return 0;
+ STACK_WIND(frame, server_fallocate_cbk, bound_xl, bound_xl->fops->fallocate,
+ state->fd, state->flags, state->offset, state->size,
+ state->xdata);
+ return 0;
err:
- server_fallocate_cbk(frame, NULL, frame->this, state->resolve.op_ret,
- state->resolve.op_errno, NULL, NULL, NULL);
+ server_fallocate_cbk(frame, NULL, frame->this, state->resolve.op_ret,
+ state->resolve.op_errno, NULL, NULL, NULL);
- return 0;
+ return 0;
}
int
-server_discard_resume (call_frame_t *frame, xlator_t *bound_xl)
+server_discard_resume(call_frame_t *frame, xlator_t *bound_xl)
{
- server_state_t *state = NULL;
+ server_state_t *state = NULL;
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (state->resolve.op_ret != 0)
- goto err;
+ if (state->resolve.op_ret != 0)
+ goto err;
- STACK_WIND (frame, server_discard_cbk,
- bound_xl, bound_xl->fops->discard,
- state->fd, state->offset, state->size, state->xdata);
- return 0;
+ STACK_WIND(frame, server_discard_cbk, bound_xl, bound_xl->fops->discard,
+ state->fd, state->offset, state->size, state->xdata);
+ return 0;
err:
- server_discard_cbk(frame, NULL, frame->this, state->resolve.op_ret,
- state->resolve.op_errno, NULL, NULL, NULL);
+ server_discard_cbk(frame, NULL, frame->this, state->resolve.op_ret,
+ state->resolve.op_errno, NULL, NULL, NULL);
- return 0;
+ return 0;
}
int
-server_zerofill_resume (call_frame_t *frame, xlator_t *bound_xl)
+server_zerofill_resume(call_frame_t *frame, xlator_t *bound_xl)
{
- server_state_t *state = NULL;
+ server_state_t *state = NULL;
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (state->resolve.op_ret != 0)
- goto err;
+ if (state->resolve.op_ret != 0)
+ goto err;
- STACK_WIND (frame, server_zerofill_cbk,
- bound_xl, bound_xl->fops->zerofill,
- state->fd, state->offset, state->size, state->xdata);
- return 0;
+ STACK_WIND(frame, server_zerofill_cbk, bound_xl, bound_xl->fops->zerofill,
+ state->fd, state->offset, state->size, state->xdata);
+ return 0;
err:
- server_zerofill_cbk(frame, NULL, frame->this, state->resolve.op_ret,
- state->resolve.op_errno, NULL, NULL, NULL);
+ server_zerofill_cbk(frame, NULL, frame->this, state->resolve.op_ret,
+ state->resolve.op_errno, NULL, NULL, NULL);
- return 0;
+ return 0;
}
int
-server_seek_resume (call_frame_t *frame, xlator_t *bound_xl)
+server_seek_resume(call_frame_t *frame, xlator_t *bound_xl)
{
- server_state_t *state = NULL;
+ server_state_t *state = NULL;
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (state->resolve.op_ret != 0)
- goto err;
+ if (state->resolve.op_ret != 0)
+ goto err;
- STACK_WIND (frame, server_seek_cbk, bound_xl, bound_xl->fops->seek,
- state->fd, state->offset, state->what, state->xdata);
- return 0;
+ STACK_WIND(frame, server_seek_cbk, bound_xl, bound_xl->fops->seek,
+ state->fd, state->offset, state->what, state->xdata);
+ return 0;
err:
- server_seek_cbk (frame, NULL, frame->this, state->resolve.op_ret,
- state->resolve.op_errno, 0, NULL);
+ server_seek_cbk(frame, NULL, frame->this, state->resolve.op_ret,
+ state->resolve.op_errno, 0, NULL);
- return 0;
+ return 0;
}
static int
-server_getactivelk_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
- int32_t op_ret, int32_t op_errno,
- lock_migration_info_t *locklist, dict_t *xdata)
-{
- gfs3_getactivelk_rsp rsp = {0,};
- server_state_t *state = NULL;
- rpcsvc_request_t *req = NULL;
- int ret = 0;
-
- state = CALL_STATE (frame);
-
- GF_PROTOCOL_DICT_SERIALIZE (this, xdata, &rsp.xdata.xdata_val,
- rsp.xdata.xdata_len, op_errno, out);
-
- if (op_ret < 0) {
- state = CALL_STATE (frame);
-
- gf_msg (this->name, GF_LOG_INFO,
- op_errno, 0,
- "%"PRId64": GETACTIVELK %s (%s), client: %s, "
- "error-xlator: %s", frame->root->unique,
- state->loc.path, uuid_utoa (state->resolve.gfid),
- STACK_CLIENT_NAME (frame->root),
- STACK_ERR_XL_NAME (frame->root));
-
- goto out;
- }
-
- /* (op_ret == 0) means there are no locks on the file*/
- if (op_ret > 0) {
- ret = serialize_rsp_locklist (locklist, &rsp);
- if (ret == -1) {
- op_ret = -1;
- op_errno = ENOMEM;
- goto out;
- }
- }
+server_getactivelk_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+ int32_t op_ret, int32_t op_errno,
+ lock_migration_info_t *locklist, dict_t *xdata)
+{
+ gfs3_getactivelk_rsp rsp = {
+ 0,
+ };
+ server_state_t *state = NULL;
+ rpcsvc_request_t *req = NULL;
+ int ret = 0;
+
+ state = CALL_STATE(frame);
+
+ GF_PROTOCOL_DICT_SERIALIZE(this, xdata, &rsp.xdata.xdata_val,
+ rsp.xdata.xdata_len, op_errno, out);
+
+ if (op_ret < 0) {
+ state = CALL_STATE(frame);
+
+ gf_msg(this->name, GF_LOG_INFO, op_errno, 0,
+ "%" PRId64
+ ": GETACTIVELK %s (%s), client: %s, "
+ "error-xlator: %s",
+ frame->root->unique, state->loc.path,
+ uuid_utoa(state->resolve.gfid), STACK_CLIENT_NAME(frame->root),
+ STACK_ERR_XL_NAME(frame->root));
+
+ goto out;
+ }
+
+ /* (op_ret == 0) means there are no locks on the file*/
+ if (op_ret > 0) {
+ ret = serialize_rsp_locklist(locklist, &rsp);
+ if (ret == -1) {
+ op_ret = -1;
+ op_errno = ENOMEM;
+ goto out;
+ }
+ }
out:
- rsp.op_ret = op_ret;
- rsp.op_errno = gf_errno_to_error (op_errno);
+ rsp.op_ret = op_ret;
+ rsp.op_errno = gf_errno_to_error(op_errno);
- req = frame->local;
+ req = frame->local;
- server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
- (xdrproc_t)xdr_gfs3_getactivelk_rsp);
+ server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gfs3_getactivelk_rsp);
- GF_FREE (rsp.xdata.xdata_val);
+ GF_FREE(rsp.xdata.xdata_val);
- getactivelkinfo_rsp_cleanup (&rsp);
+ getactivelkinfo_rsp_cleanup(&rsp);
- return 0;
+ return 0;
}
int
-server_getactivelk_resume (call_frame_t *frame, xlator_t *bound_xl)
+server_getactivelk_resume(call_frame_t *frame, xlator_t *bound_xl)
{
- server_state_t *state = NULL;
+ server_state_t *state = NULL;
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (state->resolve.op_ret != 0)
- goto err;
+ if (state->resolve.op_ret != 0)
+ goto err;
- STACK_WIND (frame, server_getactivelk_cbk, bound_xl,
- bound_xl->fops->getactivelk, &state->loc, state->xdata);
- return 0;
+ STACK_WIND(frame, server_getactivelk_cbk, bound_xl,
+ bound_xl->fops->getactivelk, &state->loc, state->xdata);
+ return 0;
err:
- server_getactivelk_cbk (frame, NULL, frame->this, state->resolve.op_ret,
- state->resolve.op_errno, NULL, NULL);
- return 0;
-
+ server_getactivelk_cbk(frame, NULL, frame->this, state->resolve.op_ret,
+ state->resolve.op_errno, NULL, NULL);
+ return 0;
}
int
-server_setactivelk_resume (call_frame_t *frame, xlator_t *bound_xl)
+server_setactivelk_resume(call_frame_t *frame, xlator_t *bound_xl)
{
- server_state_t *state = NULL;
+ server_state_t *state = NULL;
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (state->resolve.op_ret != 0)
- goto err;
+ if (state->resolve.op_ret != 0)
+ goto err;
- STACK_WIND (frame, server_setactivelk_cbk,
- bound_xl, bound_xl->fops->setactivelk, &state->loc,
- &state->locklist, state->xdata);
- return 0;
+ STACK_WIND(frame, server_setactivelk_cbk, bound_xl,
+ bound_xl->fops->setactivelk, &state->loc, &state->locklist,
+ state->xdata);
+ return 0;
err:
- server_setactivelk_cbk (frame, NULL, frame->this,
- state->resolve.op_ret,
- state->resolve.op_errno, NULL);
- return 0;
-
+ server_setactivelk_cbk(frame, NULL, frame->this, state->resolve.op_ret,
+ state->resolve.op_errno, NULL);
+ return 0;
}
int
-server_compound_resume (call_frame_t *frame, xlator_t *bound_xl)
+server_compound_resume(call_frame_t *frame, xlator_t *bound_xl)
{
- server_state_t *state = NULL;
- gfs3_compound_req *req = NULL;
- compound_args_t *args = NULL;
- int i = 0;
- int ret = -1;
- int length = 0;
- int op_errno = ENOMEM;
- compound_req *c_req = NULL;
+ server_state_t *state = NULL;
+ gfs3_compound_req *req = NULL;
+ compound_args_t *args = NULL;
+ int i = 0;
+ int ret = -1;
+ int length = 0;
+ int op_errno = ENOMEM;
+ compound_req *c_req = NULL;
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (state->resolve.op_ret != 0) {
- ret = state->resolve.op_ret;
- op_errno = state->resolve.op_errno;
- goto err;
- }
+ if (state->resolve.op_ret != 0) {
+ ret = state->resolve.op_ret;
+ op_errno = state->resolve.op_errno;
+ goto err;
+ }
- req = &state->req;
+ req = &state->req;
- length = req->compound_req_array.compound_req_array_len;
- state->args = compound_fop_alloc (length, req->compound_fop_enum,
- state->xdata);
- args = state->args;
+ length = req->compound_req_array.compound_req_array_len;
+ state->args = compound_fop_alloc(length, req->compound_fop_enum,
+ state->xdata);
+ args = state->args;
- if (!args)
- goto err;
+ if (!args)
+ goto err;
- for (i = 0; i < length; i++) {
- c_req = &req->compound_req_array.compound_req_array_val[i];
- args->enum_list[i] = c_req->fop_enum;
+ for (i = 0; i < length; i++) {
+ c_req = &req->compound_req_array.compound_req_array_val[i];
+ args->enum_list[i] = c_req->fop_enum;
- ret = server_populate_compound_request (req, frame,
- &args->req_list[i],
- i);
+ ret = server_populate_compound_request(req, frame, &args->req_list[i],
+ i);
- if (ret) {
- op_errno = ret;
- ret = -1;
- goto err;
- }
+ if (ret) {
+ op_errno = ret;
+ ret = -1;
+ goto err;
}
+ }
- STACK_WIND (frame, server_compound_cbk,
- bound_xl, bound_xl->fops->compound,
- args, state->xdata);
+ STACK_WIND(frame, server_compound_cbk, bound_xl, bound_xl->fops->compound,
+ args, state->xdata);
- return 0;
+ return 0;
err:
- server_compound_cbk (frame, NULL, frame->this, ret, op_errno,
- NULL, NULL);
+ server_compound_cbk(frame, NULL, frame->this, ret, op_errno, NULL, NULL);
- return ret;
+ return ret;
}
/* Fop section */
int
-rpc_receive_common (rpcsvc_request_t *req, call_frame_t **fr,
- server_state_t **st, ssize_t *xdrlen, void *args,
- void *xdrfn, glusterfs_fop_t fop)
-{
- int ret = -1;
- ssize_t len = 0;
-
- len = xdr_to_generic (req->msg[0], args, (xdrproc_t)xdrfn);
- if (len < 0) {
- /* failed to decode msg; */
- SERVER_REQ_SET_ERROR (req, ret);
- goto out;
- }
-
- /* Few fops use the xdr size to get the vector sizes */
- if (xdrlen)
- *xdrlen = len;
-
- *fr = get_frame_from_request (req);
- if (!(*fr)) {
- /* something wrong, mostly no memory */
- SERVER_REQ_SET_ERROR (req, ret);
- goto out;
- }
- (*fr)->root->op = fop;
-
- *st = CALL_STATE ((*fr));
- if (!(*fr)->root->client->bound_xl) {
- /* auth failure, mostly setvolume is not successful */
- SERVER_REQ_SET_ERROR (req, ret);
- goto out;
- }
-
- if (!(*fr)->root->client->bound_xl->itable) {
- /* inode_table is not allocated successful in server_setvolume */
- SERVER_REQ_SET_ERROR (req, ret);
- goto out;
- }
-
- ret = 0;
+rpc_receive_common(rpcsvc_request_t *req, call_frame_t **fr,
+ server_state_t **st, ssize_t *xdrlen, void *args,
+ void *xdrfn, glusterfs_fop_t fop)
+{
+ int ret = -1;
+ ssize_t len = 0;
+
+ len = xdr_to_generic(req->msg[0], args, (xdrproc_t)xdrfn);
+ if (len < 0) {
+ /* failed to decode msg; */
+ SERVER_REQ_SET_ERROR(req, ret);
+ goto out;
+ }
+
+ /* Few fops use the xdr size to get the vector sizes */
+ if (xdrlen)
+ *xdrlen = len;
+
+ *fr = get_frame_from_request(req);
+ if (!(*fr)) {
+ /* something wrong, mostly no memory */
+ SERVER_REQ_SET_ERROR(req, ret);
+ goto out;
+ }
+ (*fr)->root->op = fop;
+
+ *st = CALL_STATE((*fr));
+ if (!(*fr)->root->client->bound_xl) {
+ /* auth failure, mostly setvolume is not successful */
+ SERVER_REQ_SET_ERROR(req, ret);
+ goto out;
+ }
+
+ if (!(*fr)->root->client->bound_xl->itable) {
+ /* inode_table is not allocated successful in server_setvolume */
+ SERVER_REQ_SET_ERROR(req, ret);
+ goto out;
+ }
+
+ ret = 0;
out:
- return ret;
+ return ret;
}
-
int
-server3_3_stat (rpcsvc_request_t *req)
+server3_3_stat(rpcsvc_request_t *req)
{
- server_state_t *state = NULL;
- call_frame_t *frame = NULL;
- gfs3_stat_req args = {{0,},};
- int ret = -1;
- int op_errno = 0;
-
- if (!req)
- return 0;
+ server_state_t *state = NULL;
+ call_frame_t *frame = NULL;
+ gfs3_stat_req args = {
+ {
+ 0,
+ },
+ };
+ int ret = -1;
+ int op_errno = 0;
- /* Initialize args first, then decode */
- ret = rpc_receive_common (req, &frame, &state, NULL, &args,
- xdr_gfs3_stat_req, GF_FOP_STAT);
- if (ret != 0) {
- goto out;
- }
+ if (!req)
+ return 0;
- state->resolve.type = RESOLVE_MUST;
- set_resolve_gfid (frame->root->client, state->resolve.gfid, args.gfid);
+ /* Initialize args first, then decode */
+ ret = rpc_receive_common(req, &frame, &state, NULL, &args,
+ xdr_gfs3_stat_req, GF_FOP_STAT);
+ if (ret != 0) {
+ goto out;
+ }
- GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
- state->xdata,
- args.xdata.xdata_val,
- args.xdata.xdata_len, ret,
- op_errno, out);
+ state->resolve.type = RESOLVE_MUST;
+ set_resolve_gfid(frame->root->client, state->resolve.gfid, args.gfid);
+ GF_PROTOCOL_DICT_UNSERIALIZE(frame->root->client->bound_xl, state->xdata,
+ args.xdata.xdata_val, args.xdata.xdata_len,
+ ret, op_errno, out);
- ret = 0;
- resolve_and_resume (frame, server_stat_resume);
+ ret = 0;
+ resolve_and_resume(frame, server_stat_resume);
out:
- free (args.xdata.xdata_val);
+ free(args.xdata.xdata_val);
- if (op_errno)
- SERVER_REQ_SET_ERROR (req, ret);
+ if (op_errno)
+ SERVER_REQ_SET_ERROR(req, ret);
- return ret;
+ return ret;
}
-
int
-server3_3_setattr (rpcsvc_request_t *req)
+server3_3_setattr(rpcsvc_request_t *req)
{
- server_state_t *state = NULL;
- call_frame_t *frame = NULL;
- gfs3_setattr_req args = {{0,},};
- int ret = -1;
- int op_errno = 0;
+ server_state_t *state = NULL;
+ call_frame_t *frame = NULL;
+ gfs3_setattr_req args = {
+ {
+ 0,
+ },
+ };
+ int ret = -1;
+ int op_errno = 0;
- if (!req)
- return 0;
+ if (!req)
+ return 0;
- ret = rpc_receive_common (req, &frame, &state, NULL, &args,
- xdr_gfs3_setattr_req, GF_FOP_SETATTR);
- if (ret != 0) {
- goto out;
- }
+ ret = rpc_receive_common(req, &frame, &state, NULL, &args,
+ xdr_gfs3_setattr_req, GF_FOP_SETATTR);
+ if (ret != 0) {
+ goto out;
+ }
- state->resolve.type = RESOLVE_MUST;
- set_resolve_gfid (frame->root->client, state->resolve.gfid, args.gfid);
+ state->resolve.type = RESOLVE_MUST;
+ set_resolve_gfid(frame->root->client, state->resolve.gfid, args.gfid);
- gf_stat_to_iatt (&args.stbuf, &state->stbuf);
- state->valid = args.valid;
+ gf_stat_to_iatt(&args.stbuf, &state->stbuf);
+ state->valid = args.valid;
- GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
- state->xdata,
- args.xdata.xdata_val,
- args.xdata.xdata_len, ret,
- op_errno, out);
+ GF_PROTOCOL_DICT_UNSERIALIZE(frame->root->client->bound_xl, state->xdata,
+ args.xdata.xdata_val, args.xdata.xdata_len,
+ ret, op_errno, out);
- ret = 0;
- resolve_and_resume (frame, server_setattr_resume);
+ ret = 0;
+ resolve_and_resume(frame, server_setattr_resume);
out:
- if (op_errno)
- SERVER_REQ_SET_ERROR (req, ret);
+ if (op_errno)
+ SERVER_REQ_SET_ERROR(req, ret);
- free (args.xdata.xdata_val);
+ free(args.xdata.xdata_val);
- return ret;
+ return ret;
}
-
int
-server3_3_fsetattr (rpcsvc_request_t *req)
+server3_3_fsetattr(rpcsvc_request_t *req)
{
- server_state_t *state = NULL;
- call_frame_t *frame = NULL;
- gfs3_fsetattr_req args = {0,};
- int ret = -1;
- int op_errno = 0;
+ server_state_t *state = NULL;
+ call_frame_t *frame = NULL;
+ gfs3_fsetattr_req args = {
+ 0,
+ };
+ int ret = -1;
+ int op_errno = 0;
- if (!req)
- return ret;
+ if (!req)
+ return ret;
- ret = rpc_receive_common (req, &frame, &state, NULL, &args,
- xdr_gfs3_fsetattr_req, GF_FOP_FSETATTR);
- if (ret != 0) {
- goto out;
- }
+ ret = rpc_receive_common(req, &frame, &state, NULL, &args,
+ xdr_gfs3_fsetattr_req, GF_FOP_FSETATTR);
+ if (ret != 0) {
+ goto out;
+ }
- state->resolve.type = RESOLVE_MUST;
- state->resolve.fd_no = args.fd;
+ state->resolve.type = RESOLVE_MUST;
+ state->resolve.fd_no = args.fd;
- gf_stat_to_iatt (&args.stbuf, &state->stbuf);
- state->valid = args.valid;
+ gf_stat_to_iatt(&args.stbuf, &state->stbuf);
+ state->valid = args.valid;
- GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
- state->xdata,
- args.xdata.xdata_val,
- args.xdata.xdata_len, ret,
- op_errno, out);
+ GF_PROTOCOL_DICT_UNSERIALIZE(frame->root->client->bound_xl, state->xdata,
+ args.xdata.xdata_val, args.xdata.xdata_len,
+ ret, op_errno, out);
- ret = 0;
- resolve_and_resume (frame, server_fsetattr_resume);
+ ret = 0;
+ resolve_and_resume(frame, server_fsetattr_resume);
out:
- free (args.xdata.xdata_val);
+ free(args.xdata.xdata_val);
- if (op_errno)
- SERVER_REQ_SET_ERROR (req, ret);
+ if (op_errno)
+ SERVER_REQ_SET_ERROR(req, ret);
- return ret;
+ return ret;
}
int
server3_3_fallocate(rpcsvc_request_t *req)
{
- server_state_t *state = NULL;
- call_frame_t *frame = NULL;
- gfs3_fallocate_req args = {{0},};
- int ret = -1;
- int op_errno = 0;
+ server_state_t *state = NULL;
+ call_frame_t *frame = NULL;
+ gfs3_fallocate_req args = {
+ {0},
+ };
+ int ret = -1;
+ int op_errno = 0;
- if (!req)
- return ret;
+ if (!req)
+ return ret;
- ret = rpc_receive_common (req, &frame, &state, NULL, &args,
- xdr_gfs3_fallocate_req, GF_FOP_FALLOCATE);
- if (ret != 0) {
- goto out;
- }
+ ret = rpc_receive_common(req, &frame, &state, NULL, &args,
+ xdr_gfs3_fallocate_req, GF_FOP_FALLOCATE);
+ if (ret != 0) {
+ goto out;
+ }
- state->resolve.type = RESOLVE_MUST;
- state->resolve.fd_no = args.fd;
+ state->resolve.type = RESOLVE_MUST;
+ state->resolve.fd_no = args.fd;
- state->flags = args.flags;
- state->offset = args.offset;
- state->size = args.size;
- memcpy(state->resolve.gfid, args.gfid, 16);
+ state->flags = args.flags;
+ state->offset = args.offset;
+ state->size = args.size;
+ memcpy(state->resolve.gfid, args.gfid, 16);
- GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
- state->xdata,
- args.xdata.xdata_val,
- args.xdata.xdata_len, ret,
- op_errno, out);
+ GF_PROTOCOL_DICT_UNSERIALIZE(frame->root->client->bound_xl, state->xdata,
+ args.xdata.xdata_val, args.xdata.xdata_len,
+ ret, op_errno, out);
- ret = 0;
- resolve_and_resume (frame, server_fallocate_resume);
+ ret = 0;
+ resolve_and_resume(frame, server_fallocate_resume);
out:
- free (args.xdata.xdata_val);
+ free(args.xdata.xdata_val);
- if (op_errno)
- SERVER_REQ_SET_ERROR (req, ret);
+ if (op_errno)
+ SERVER_REQ_SET_ERROR(req, ret);
- return ret;
+ return ret;
}
-
int
server3_3_discard(rpcsvc_request_t *req)
{
- server_state_t *state = NULL;
- call_frame_t *frame = NULL;
- gfs3_discard_req args = {{0},};
- int ret = -1;
- int op_errno = 0;
+ server_state_t *state = NULL;
+ call_frame_t *frame = NULL;
+ gfs3_discard_req args = {
+ {0},
+ };
+ int ret = -1;
+ int op_errno = 0;
- if (!req)
- return ret;
+ if (!req)
+ return ret;
- ret = rpc_receive_common (req, &frame, &state, NULL, &args,
- xdr_gfs3_discard_req, GF_FOP_DISCARD);
- if (ret != 0) {
- goto out;
- }
+ ret = rpc_receive_common(req, &frame, &state, NULL, &args,
+ xdr_gfs3_discard_req, GF_FOP_DISCARD);
+ if (ret != 0) {
+ goto out;
+ }
- state->resolve.type = RESOLVE_MUST;
- state->resolve.fd_no = args.fd;
+ state->resolve.type = RESOLVE_MUST;
+ state->resolve.fd_no = args.fd;
- state->offset = args.offset;
- state->size = args.size;
- memcpy(state->resolve.gfid, args.gfid, 16);
+ state->offset = args.offset;
+ state->size = args.size;
+ memcpy(state->resolve.gfid, args.gfid, 16);
- GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
- state->xdata,
- args.xdata.xdata_val,
- args.xdata.xdata_len, ret,
- op_errno, out);
+ GF_PROTOCOL_DICT_UNSERIALIZE(frame->root->client->bound_xl, state->xdata,
+ args.xdata.xdata_val, args.xdata.xdata_len,
+ ret, op_errno, out);
- ret = 0;
- resolve_and_resume (frame, server_discard_resume);
+ ret = 0;
+ resolve_and_resume(frame, server_discard_resume);
out:
- free (args.xdata.xdata_val);
+ free(args.xdata.xdata_val);
- if (op_errno)
- SERVER_REQ_SET_ERROR (req, ret);
+ if (op_errno)
+ SERVER_REQ_SET_ERROR(req, ret);
- return ret;
+ return ret;
}
-
int
server3_3_zerofill(rpcsvc_request_t *req)
{
- server_state_t *state = NULL;
- call_frame_t *frame = NULL;
- gfs3_zerofill_req args = {{0},};
- int ret = -1;
- int op_errno = 0;
+ server_state_t *state = NULL;
+ call_frame_t *frame = NULL;
+ gfs3_zerofill_req args = {
+ {0},
+ };
+ int ret = -1;
+ int op_errno = 0;
- if (!req)
- return ret;
+ if (!req)
+ return ret;
- ret = rpc_receive_common (req, &frame, &state, NULL, &args,
- xdr_gfs3_zerofill_req, GF_FOP_ZEROFILL);
- if (ret != 0) {
- goto out;
- }
+ ret = rpc_receive_common(req, &frame, &state, NULL, &args,
+ xdr_gfs3_zerofill_req, GF_FOP_ZEROFILL);
+ if (ret != 0) {
+ goto out;
+ }
- state->resolve.type = RESOLVE_MUST;
- state->resolve.fd_no = args.fd;
+ state->resolve.type = RESOLVE_MUST;
+ state->resolve.fd_no = args.fd;
- state->offset = args.offset;
- state->size = args.size;
- memcpy(state->resolve.gfid, args.gfid, 16);
+ state->offset = args.offset;
+ state->size = args.size;
+ memcpy(state->resolve.gfid, args.gfid, 16);
- GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl, state->xdata,
- (args.xdata.xdata_val),
- (args.xdata.xdata_len), ret,
- op_errno, out);
+ GF_PROTOCOL_DICT_UNSERIALIZE(frame->root->client->bound_xl, state->xdata,
+ (args.xdata.xdata_val), (args.xdata.xdata_len),
+ ret, op_errno, out);
- ret = 0;
- resolve_and_resume (frame, server_zerofill_resume);
+ ret = 0;
+ resolve_and_resume(frame, server_zerofill_resume);
out:
- free (args.xdata.xdata_val);
+ free(args.xdata.xdata_val);
- if (op_errno)
- req->rpc_err = GARBAGE_ARGS;
+ if (op_errno)
+ req->rpc_err = GARBAGE_ARGS;
- return ret;
+ return ret;
}
int
-server3_3_ipc (rpcsvc_request_t *req)
+server3_3_ipc(rpcsvc_request_t *req)
{
- server_state_t *state = NULL;
- call_frame_t *frame = NULL;
- gfs3_ipc_req args = {0,};
- int ret = -1;
- int op_errno = 0;
- xlator_t *bound_xl = NULL;
+ server_state_t *state = NULL;
+ call_frame_t *frame = NULL;
+ gfs3_ipc_req args = {
+ 0,
+ };
+ int ret = -1;
+ int op_errno = 0;
+ xlator_t *bound_xl = NULL;
- if (!req)
- return ret;
+ if (!req)
+ return ret;
- ret = rpc_receive_common (req, &frame, &state, NULL, &args,
- xdr_gfs3_ipc_req, GF_FOP_IPC);
- if (ret != 0) {
- goto out;
- }
+ ret = rpc_receive_common(req, &frame, &state, NULL, &args, xdr_gfs3_ipc_req,
+ GF_FOP_IPC);
+ if (ret != 0) {
+ goto out;
+ }
- bound_xl = frame->root->client->bound_xl;
- GF_PROTOCOL_DICT_UNSERIALIZE (bound_xl, state->xdata,
- args.xdata.xdata_val,
- args.xdata.xdata_len,
- ret, op_errno, out);
+ bound_xl = frame->root->client->bound_xl;
+ GF_PROTOCOL_DICT_UNSERIALIZE(bound_xl, state->xdata, args.xdata.xdata_val,
+ args.xdata.xdata_len, ret, op_errno, out);
- ret = 0;
- STACK_WIND (frame, server_ipc_cbk, bound_xl, bound_xl->fops->ipc,
- args.op, state->xdata);
+ ret = 0;
+ STACK_WIND(frame, server_ipc_cbk, bound_xl, bound_xl->fops->ipc, args.op,
+ state->xdata);
out:
- free (args.xdata.xdata_val);
+ free(args.xdata.xdata_val);
- if (op_errno)
- req->rpc_err = GARBAGE_ARGS;
+ if (op_errno)
+ req->rpc_err = GARBAGE_ARGS;
- return ret;
+ return ret;
}
int
-server3_3_seek (rpcsvc_request_t *req)
+server3_3_seek(rpcsvc_request_t *req)
{
- server_state_t *state = NULL;
- call_frame_t *frame = NULL;
- gfs3_seek_req args = {{0,},};
- int ret = -1;
- int op_errno = 0;
- xlator_t *bound_xl = NULL;
-
- if (!req)
- return ret;
+ server_state_t *state = NULL;
+ call_frame_t *frame = NULL;
+ gfs3_seek_req args = {
+ {
+ 0,
+ },
+ };
+ int ret = -1;
+ int op_errno = 0;
+ xlator_t *bound_xl = NULL;
+
+ if (!req)
+ return ret;
- ret = rpc_receive_common (req, &frame, &state, NULL, &args,
- xdr_gfs3_seek_req, GF_FOP_SEEK);
- if (ret != 0) {
- goto out;
- }
+ ret = rpc_receive_common(req, &frame, &state, NULL, &args,
+ xdr_gfs3_seek_req, GF_FOP_SEEK);
+ if (ret != 0) {
+ goto out;
+ }
- state->resolve.type = RESOLVE_MUST;
- state->resolve.fd_no = args.fd;
+ state->resolve.type = RESOLVE_MUST;
+ state->resolve.fd_no = args.fd;
- state->offset = args.offset;
- state->what = args.what;
- memcpy(state->resolve.gfid, args.gfid, 16);
+ state->offset = args.offset;
+ state->what = args.what;
+ memcpy(state->resolve.gfid, args.gfid, 16);
- bound_xl = frame->root->client->bound_xl;
- GF_PROTOCOL_DICT_UNSERIALIZE (bound_xl, state->xdata,
- args.xdata.xdata_val,
- args.xdata.xdata_len,
- ret, op_errno, out);
+ bound_xl = frame->root->client->bound_xl;
+ GF_PROTOCOL_DICT_UNSERIALIZE(bound_xl, state->xdata, args.xdata.xdata_val,
+ args.xdata.xdata_len, ret, op_errno, out);
- ret = 0;
- resolve_and_resume (frame, server_seek_resume);
+ ret = 0;
+ resolve_and_resume(frame, server_seek_resume);
out:
- free (args.xdata.xdata_val);
+ free(args.xdata.xdata_val);
- if (op_errno)
- SERVER_REQ_SET_ERROR (req, ret);
+ if (op_errno)
+ SERVER_REQ_SET_ERROR(req, ret);
- return ret;
+ return ret;
}
int
-server3_3_readlink (rpcsvc_request_t *req)
+server3_3_readlink(rpcsvc_request_t *req)
{
- server_state_t *state = NULL;
- call_frame_t *frame = NULL;
- gfs3_readlink_req args = {{0,},};
- int ret = -1;
- int op_errno = 0;
+ server_state_t *state = NULL;
+ call_frame_t *frame = NULL;
+ gfs3_readlink_req args = {
+ {
+ 0,
+ },
+ };
+ int ret = -1;
+ int op_errno = 0;
- if (!req)
- return ret;
+ if (!req)
+ return ret;
- ret = rpc_receive_common (req, &frame, &state, NULL, &args,
- xdr_gfs3_readlink_req, GF_FOP_READLINK);
- if (ret != 0) {
- goto out;
- }
+ ret = rpc_receive_common(req, &frame, &state, NULL, &args,
+ xdr_gfs3_readlink_req, GF_FOP_READLINK);
+ if (ret != 0) {
+ goto out;
+ }
- state->resolve.type = RESOLVE_MUST;
- memcpy (state->resolve.gfid, args.gfid, 16);
+ state->resolve.type = RESOLVE_MUST;
+ memcpy(state->resolve.gfid, args.gfid, 16);
- state->size = args.size;
+ state->size = args.size;
- GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
- state->xdata,
- args.xdata.xdata_val,
- args.xdata.xdata_len, ret,
- op_errno, out);
+ GF_PROTOCOL_DICT_UNSERIALIZE(frame->root->client->bound_xl, state->xdata,
+ args.xdata.xdata_val, args.xdata.xdata_len,
+ ret, op_errno, out);
- ret = 0;
- resolve_and_resume (frame, server_readlink_resume);
+ ret = 0;
+ resolve_and_resume(frame, server_readlink_resume);
out:
- free (args.xdata.xdata_val);
+ free(args.xdata.xdata_val);
- if (op_errno)
- SERVER_REQ_SET_ERROR (req, ret);
+ if (op_errno)
+ SERVER_REQ_SET_ERROR(req, ret);
- return ret;
+ return ret;
}
-
int
-server3_3_create (rpcsvc_request_t *req)
+server3_3_create(rpcsvc_request_t *req)
{
- server_state_t *state = NULL;
- call_frame_t *frame = NULL;
- gfs3_create_req args = {{0,},};
- int ret = -1;
- int op_errno = 0;
+ server_state_t *state = NULL;
+ call_frame_t *frame = NULL;
+ gfs3_create_req args = {
+ {
+ 0,
+ },
+ };
+ int ret = -1;
+ int op_errno = 0;
- if (!req)
- return ret;
+ if (!req)
+ return ret;
- ret = rpc_receive_common (req, &frame, &state, NULL, &args,
- xdr_gfs3_create_req, GF_FOP_CREATE);
- if (ret != 0) {
- goto out;
- }
+ ret = rpc_receive_common(req, &frame, &state, NULL, &args,
+ xdr_gfs3_create_req, GF_FOP_CREATE);
+ if (ret != 0) {
+ goto out;
+ }
- state->resolve.bname = gf_strdup (args.bname);
- state->mode = args.mode;
- state->umask = args.umask;
- state->flags = gf_flags_to_flags (args.flags);
+ state->resolve.bname = gf_strdup(args.bname);
+ state->mode = args.mode;
+ state->umask = args.umask;
+ state->flags = gf_flags_to_flags(args.flags);
- set_resolve_gfid (frame->root->client, state->resolve.pargfid,
- args.pargfid);
+ set_resolve_gfid(frame->root->client, state->resolve.pargfid, args.pargfid);
- if (state->flags & O_EXCL) {
- state->resolve.type = RESOLVE_NOT;
- } else {
- state->resolve.type = RESOLVE_DONTCARE;
- }
+ if (state->flags & O_EXCL) {
+ state->resolve.type = RESOLVE_NOT;
+ } else {
+ state->resolve.type = RESOLVE_DONTCARE;
+ }
- /* TODO: can do alloca for xdata field instead of stdalloc */
- GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
- state->xdata,
- args.xdata.xdata_val,
- args.xdata.xdata_len, ret,
- op_errno, out);
+ /* TODO: can do alloca for xdata field instead of stdalloc */
+ GF_PROTOCOL_DICT_UNSERIALIZE(frame->root->client->bound_xl, state->xdata,
+ args.xdata.xdata_val, args.xdata.xdata_len,
+ ret, op_errno, out);
- ret = 0;
- resolve_and_resume (frame, server_create_resume);
+ ret = 0;
+ resolve_and_resume(frame, server_create_resume);
out:
- /* memory allocated by libc, don't use GF_FREE */
- free (args.xdata.xdata_val);
- free (args.bname);
+ /* memory allocated by libc, don't use GF_FREE */
+ free(args.xdata.xdata_val);
+ free(args.bname);
- if (op_errno)
- SERVER_REQ_SET_ERROR (req, ret);
+ if (op_errno)
+ SERVER_REQ_SET_ERROR(req, ret);
- return ret;
+ return ret;
}
-
int
-server3_3_open (rpcsvc_request_t *req)
+server3_3_open(rpcsvc_request_t *req)
{
- server_state_t *state = NULL;
- call_frame_t *frame = NULL;
- gfs3_open_req args = {{0,},};
- int ret = -1;
- int op_errno = 0;
+ server_state_t *state = NULL;
+ call_frame_t *frame = NULL;
+ gfs3_open_req args = {
+ {
+ 0,
+ },
+ };
+ int ret = -1;
+ int op_errno = 0;
- if (!req)
- return ret;
+ if (!req)
+ return ret;
- ret = rpc_receive_common (req, &frame, &state, NULL, &args,
- xdr_gfs3_open_req, GF_FOP_OPEN);
- if (ret != 0) {
- goto out;
- }
+ ret = rpc_receive_common(req, &frame, &state, NULL, &args,
+ xdr_gfs3_open_req, GF_FOP_OPEN);
+ if (ret != 0) {
+ goto out;
+ }
- state->resolve.type = RESOLVE_MUST;
- memcpy (state->resolve.gfid, args.gfid, 16);
+ state->resolve.type = RESOLVE_MUST;
+ memcpy(state->resolve.gfid, args.gfid, 16);
- state->flags = gf_flags_to_flags (args.flags);
+ state->flags = gf_flags_to_flags(args.flags);
- GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
- state->xdata,
- args.xdata.xdata_val,
- args.xdata.xdata_len, ret,
- op_errno, out);
+ GF_PROTOCOL_DICT_UNSERIALIZE(frame->root->client->bound_xl, state->xdata,
+ args.xdata.xdata_val, args.xdata.xdata_len,
+ ret, op_errno, out);
- ret = 0;
- resolve_and_resume (frame, server_open_resume);
+ ret = 0;
+ resolve_and_resume(frame, server_open_resume);
out:
- if (op_errno)
- SERVER_REQ_SET_ERROR (req, ret);
+ if (op_errno)
+ SERVER_REQ_SET_ERROR(req, ret);
- free (args.xdata.xdata_val);
+ free(args.xdata.xdata_val);
- return ret;
+ return ret;
}
-
int
-server3_3_readv (rpcsvc_request_t *req)
+server3_3_readv(rpcsvc_request_t *req)
{
- server_state_t *state = NULL;
- call_frame_t *frame = NULL;
- gfs3_read_req args = {{0,},};
- int ret = -1;
- int op_errno = 0;
-
- if (!req)
- goto out;
-
- ret = rpc_receive_common (req, &frame, &state, NULL, &args,
- xdr_gfs3_read_req, GF_FOP_READ);
- if (ret != 0) {
- goto out;
- }
-
- state->resolve.type = RESOLVE_MUST;
- state->resolve.fd_no = args.fd;
- state->size = args.size;
- state->offset = args.offset;
- state->flags = args.flag;
-
- memcpy (state->resolve.gfid, args.gfid, 16);
-
- GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
- state->xdata,
- args.xdata.xdata_val,
- args.xdata.xdata_len, ret,
- op_errno, out);
-
- ret = 0;
- resolve_and_resume (frame, server_readv_resume);
+ server_state_t *state = NULL;
+ call_frame_t *frame = NULL;
+ gfs3_read_req args = {
+ {
+ 0,
+ },
+ };
+ int ret = -1;
+ int op_errno = 0;
+
+ if (!req)
+ goto out;
+
+ ret = rpc_receive_common(req, &frame, &state, NULL, &args,
+ xdr_gfs3_read_req, GF_FOP_READ);
+ if (ret != 0) {
+ goto out;
+ }
+
+ state->resolve.type = RESOLVE_MUST;
+ state->resolve.fd_no = args.fd;
+ state->size = args.size;
+ state->offset = args.offset;
+ state->flags = args.flag;
+
+ memcpy(state->resolve.gfid, args.gfid, 16);
+
+ GF_PROTOCOL_DICT_UNSERIALIZE(frame->root->client->bound_xl, state->xdata,
+ args.xdata.xdata_val, args.xdata.xdata_len,
+ ret, op_errno, out);
+
+ ret = 0;
+ resolve_and_resume(frame, server_readv_resume);
out:
- /* memory allocated by libc, don't use GF_FREE */
- free (args.xdata.xdata_val);
+ /* memory allocated by libc, don't use GF_FREE */
+ free(args.xdata.xdata_val);
- if (op_errno)
- SERVER_REQ_SET_ERROR (req, ret);
+ if (op_errno)
+ SERVER_REQ_SET_ERROR(req, ret);
- return ret;
+ return ret;
}
-
int
-server3_3_writev (rpcsvc_request_t *req)
+server3_3_writev(rpcsvc_request_t *req)
{
- server_state_t *state = NULL;
- call_frame_t *frame = NULL;
- gfs3_write_req args = {{0,},};
- ssize_t len = 0;
- int i = 0;
- int ret = -1;
- int op_errno = 0;
+ server_state_t *state = NULL;
+ call_frame_t *frame = NULL;
+ gfs3_write_req args = {
+ {
+ 0,
+ },
+ };
+ ssize_t len = 0;
+ int i = 0;
+ int ret = -1;
+ int op_errno = 0;
+
+ if (!req)
+ return ret;
- if (!req)
- return ret;
+ ret = rpc_receive_common(req, &frame, &state, &len, &args,
+ xdr_gfs3_write_req, GF_FOP_WRITE);
+ if (ret != 0) {
+ goto out;
+ }
- ret = rpc_receive_common (req, &frame, &state, &len, &args,
- xdr_gfs3_write_req, GF_FOP_WRITE);
- if (ret != 0) {
- goto out;
- }
+ state->resolve.type = RESOLVE_MUST;
+ state->resolve.fd_no = args.fd;
+ state->offset = args.offset;
+ state->size = args.size;
+ state->flags = args.flag;
+ state->iobref = iobref_ref(req->iobref);
+ memcpy(state->resolve.gfid, args.gfid, 16);
- state->resolve.type = RESOLVE_MUST;
- state->resolve.fd_no = args.fd;
- state->offset = args.offset;
- state->size = args.size;
- state->flags = args.flag;
- state->iobref = iobref_ref (req->iobref);
- memcpy (state->resolve.gfid, args.gfid, 16);
-
- if (len < req->msg[0].iov_len) {
- state->payload_vector[0].iov_base
- = (req->msg[0].iov_base + len);
- state->payload_vector[0].iov_len
- = req->msg[0].iov_len - len;
- state->payload_count = 1;
- }
+ if (len < req->msg[0].iov_len) {
+ state->payload_vector[0].iov_base = (req->msg[0].iov_base + len);
+ state->payload_vector[0].iov_len = req->msg[0].iov_len - len;
+ state->payload_count = 1;
+ }
- for (i = 1; i < req->count; i++) {
- state->payload_vector[state->payload_count++]
- = req->msg[i];
- }
+ for (i = 1; i < req->count; i++) {
+ state->payload_vector[state->payload_count++] = req->msg[i];
+ }
- len = iov_length (state->payload_vector, state->payload_count);
+ len = iov_length(state->payload_vector, state->payload_count);
- GF_ASSERT (state->size == len);
+ GF_ASSERT(state->size == len);
- GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
- state->xdata,
- args.xdata.xdata_val,
- args.xdata.xdata_len, ret,
- op_errno, out);
+ GF_PROTOCOL_DICT_UNSERIALIZE(frame->root->client->bound_xl, state->xdata,
+ args.xdata.xdata_val, args.xdata.xdata_len,
+ ret, op_errno, out);
#ifdef GF_TESTING_IO_XDATA
- dict_dump_to_log (state->xdata);
+ dict_dump_to_log(state->xdata);
#endif
- ret = 0;
- resolve_and_resume (frame, server_writev_resume);
+ ret = 0;
+ resolve_and_resume(frame, server_writev_resume);
out:
- free (args.xdata.xdata_val);
+ free(args.xdata.xdata_val);
- if (op_errno)
- SERVER_REQ_SET_ERROR (req, ret);
+ if (op_errno)
+ SERVER_REQ_SET_ERROR(req, ret);
- return ret;
+ return ret;
}
-
#define SERVER3_3_VECWRITE_START 0
#define SERVER3_3_VECWRITE_READING_HDR 1
#define SERVER3_3_VECWRITE_READING_OPAQUE 2
int
-server3_3_writev_vecsizer (int state, ssize_t *readsize, char *base_addr,
- char *curr_addr)
+server3_3_writev_vecsizer(int state, ssize_t *readsize, char *base_addr,
+ char *curr_addr)
{
- ssize_t size = 0;
- int nextstate = 0;
- gfs3_write_req write_req = {{0,},};
- XDR xdr;
+ ssize_t size = 0;
+ int nextstate = 0;
+ gfs3_write_req write_req = {
+ {
+ 0,
+ },
+ };
+ XDR xdr;
- switch (state) {
+ switch (state) {
case SERVER3_3_VECWRITE_START:
- size = xdr_sizeof ((xdrproc_t) xdr_gfs3_write_req,
- &write_req);
- *readsize = size;
- nextstate = SERVER3_3_VECWRITE_READING_HDR;
- break;
+ size = xdr_sizeof((xdrproc_t)xdr_gfs3_write_req, &write_req);
+ *readsize = size;
+ nextstate = SERVER3_3_VECWRITE_READING_HDR;
+ break;
case SERVER3_3_VECWRITE_READING_HDR:
- size = xdr_sizeof ((xdrproc_t) xdr_gfs3_write_req,
- &write_req);
+ size = xdr_sizeof((xdrproc_t)xdr_gfs3_write_req, &write_req);
- xdrmem_create (&xdr, base_addr, size, XDR_DECODE);
+ xdrmem_create(&xdr, base_addr, size, XDR_DECODE);
- /* This will fail if there is xdata sent from client, if not,
- well and good */
- xdr_gfs3_write_req (&xdr, &write_req);
+ /* This will fail if there is xdata sent from client, if not,
+ well and good */
+ xdr_gfs3_write_req(&xdr, &write_req);
- /* need to round off to proper roof (%4), as XDR packing pads
- the end of opaque object with '0' */
- size = roof (write_req.xdata.xdata_len, 4);
+ /* need to round off to proper roof (%4), as XDR packing pads
+ the end of opaque object with '0' */
+ size = roof(write_req.xdata.xdata_len, 4);
- *readsize = size;
+ *readsize = size;
- if (!size)
- nextstate = SERVER3_3_VECWRITE_START;
- else
- nextstate = SERVER3_3_VECWRITE_READING_OPAQUE;
+ if (!size)
+ nextstate = SERVER3_3_VECWRITE_START;
+ else
+ nextstate = SERVER3_3_VECWRITE_READING_OPAQUE;
- free (write_req.xdata.xdata_val);
+ free(write_req.xdata.xdata_val);
- break;
+ break;
case SERVER3_3_VECWRITE_READING_OPAQUE:
- *readsize = 0;
- nextstate = SERVER3_3_VECWRITE_START;
- break;
+ *readsize = 0;
+ nextstate = SERVER3_3_VECWRITE_START;
+ break;
default:
- gf_msg ("server", GF_LOG_ERROR, 0, PS_MSG_WRONG_STATE,
- "wrong state: %d", state);
- }
+ gf_msg("server", GF_LOG_ERROR, 0, PS_MSG_WRONG_STATE,
+ "wrong state: %d", state);
+ }
- return nextstate;
+ return nextstate;
}
-
int
-server3_3_release (rpcsvc_request_t *req)
+server3_3_release(rpcsvc_request_t *req)
{
- client_t *client = NULL;
- server_ctx_t *serv_ctx = NULL;
- gfs3_release_req args = {{0,},};
- gf_common_rsp rsp = {0,};
- int ret = -1;
-
- ret = xdr_to_generic (req->msg[0], &args,
- (xdrproc_t)xdr_gfs3_release_req);
- if (ret < 0) {
- //failed to decode msg;
- SERVER_REQ_SET_ERROR (req, ret);
- goto out;
- }
-
- client = req->trans->xl_private;
- if (!client) {
- /* Handshake is not complete yet. */
- req->rpc_err = SYSTEM_ERR;
- goto out;
- }
-
- serv_ctx = server_ctx_get (client, client->this);
- if (serv_ctx == NULL) {
- gf_msg (req->trans->name, GF_LOG_INFO, 0,
- PS_MSG_SERVER_CTX_GET_FAILED, "server_ctx_get() "
- "failed");
- req->rpc_err = SYSTEM_ERR;
- goto out;
- }
-
- gf_fd_put (serv_ctx->fdtable, args.fd);
-
- server_submit_reply (NULL, req, &rsp, NULL, 0, NULL,
- (xdrproc_t)xdr_gf_common_rsp);
-
- ret = 0;
+ client_t *client = NULL;
+ server_ctx_t *serv_ctx = NULL;
+ gfs3_release_req args = {
+ {
+ 0,
+ },
+ };
+ gf_common_rsp rsp = {
+ 0,
+ };
+ int ret = -1;
+
+ ret = xdr_to_generic(req->msg[0], &args, (xdrproc_t)xdr_gfs3_release_req);
+ if (ret < 0) {
+ // failed to decode msg;
+ SERVER_REQ_SET_ERROR(req, ret);
+ goto out;
+ }
+
+ client = req->trans->xl_private;
+ if (!client) {
+ /* Handshake is not complete yet. */
+ req->rpc_err = SYSTEM_ERR;
+ goto out;
+ }
+
+ serv_ctx = server_ctx_get(client, client->this);
+ if (serv_ctx == NULL) {
+ gf_msg(req->trans->name, GF_LOG_INFO, 0, PS_MSG_SERVER_CTX_GET_FAILED,
+ "server_ctx_get() "
+ "failed");
+ req->rpc_err = SYSTEM_ERR;
+ goto out;
+ }
+
+ gf_fd_put(serv_ctx->fdtable, args.fd);
+
+ server_submit_reply(NULL, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gf_common_rsp);
+
+ ret = 0;
out:
- return ret;
+ return ret;
}
int
-server3_3_releasedir (rpcsvc_request_t *req)
+server3_3_releasedir(rpcsvc_request_t *req)
{
- client_t *client = NULL;
- server_ctx_t *serv_ctx = NULL;
- gfs3_releasedir_req args = {{0,},};
- gf_common_rsp rsp = {0,};
- int ret = -1;
-
- ret = xdr_to_generic (req->msg[0], &args,
- (xdrproc_t)xdr_gfs3_release_req);
- if (ret < 0) {
- //failed to decode msg;
- SERVER_REQ_SET_ERROR (req, ret);
- goto out;
- }
-
- client = req->trans->xl_private;
- if (!client) {
- SERVER_REQ_SET_ERROR (req, ret);
- goto out;
- }
-
- serv_ctx = server_ctx_get (client, client->this);
- if (serv_ctx == NULL) {
- gf_msg (req->trans->name, GF_LOG_INFO, 0,
- PS_MSG_SERVER_CTX_GET_FAILED, "server_ctx_get() "
- "failed");
- req->rpc_err = SYSTEM_ERR;
- goto out;
- }
-
- gf_fd_put (serv_ctx->fdtable, args.fd);
-
- server_submit_reply (NULL, req, &rsp, NULL, 0, NULL,
- (xdrproc_t)xdr_gf_common_rsp);
-
- ret = 0;
+ client_t *client = NULL;
+ server_ctx_t *serv_ctx = NULL;
+ gfs3_releasedir_req args = {
+ {
+ 0,
+ },
+ };
+ gf_common_rsp rsp = {
+ 0,
+ };
+ int ret = -1;
+
+ ret = xdr_to_generic(req->msg[0], &args, (xdrproc_t)xdr_gfs3_release_req);
+ if (ret < 0) {
+ // failed to decode msg;
+ SERVER_REQ_SET_ERROR(req, ret);
+ goto out;
+ }
+
+ client = req->trans->xl_private;
+ if (!client) {
+ SERVER_REQ_SET_ERROR(req, ret);
+ goto out;
+ }
+
+ serv_ctx = server_ctx_get(client, client->this);
+ if (serv_ctx == NULL) {
+ gf_msg(req->trans->name, GF_LOG_INFO, 0, PS_MSG_SERVER_CTX_GET_FAILED,
+ "server_ctx_get() "
+ "failed");
+ req->rpc_err = SYSTEM_ERR;
+ goto out;
+ }
+
+ gf_fd_put(serv_ctx->fdtable, args.fd);
+
+ server_submit_reply(NULL, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gf_common_rsp);
+
+ ret = 0;
out:
- return ret;
+ return ret;
}
-
int
-server3_3_fsync (rpcsvc_request_t *req)
+server3_3_fsync(rpcsvc_request_t *req)
{
- server_state_t *state = NULL;
- call_frame_t *frame = NULL;
- gfs3_fsync_req args = {{0,},};
- int ret = -1;
- int op_errno = 0;
+ server_state_t *state = NULL;
+ call_frame_t *frame = NULL;
+ gfs3_fsync_req args = {
+ {
+ 0,
+ },
+ };
+ int ret = -1;
+ int op_errno = 0;
- if (!req)
- return ret;
+ if (!req)
+ return ret;
- ret = rpc_receive_common (req, &frame, &state, NULL, &args,
- xdr_gfs3_fsync_req, GF_FOP_FSYNC);
- if (ret != 0) {
- goto out;
- }
+ ret = rpc_receive_common(req, &frame, &state, NULL, &args,
+ xdr_gfs3_fsync_req, GF_FOP_FSYNC);
+ if (ret != 0) {
+ goto out;
+ }
- state->resolve.type = RESOLVE_MUST;
- state->resolve.fd_no = args.fd;
- state->flags = args.data;
- memcpy (state->resolve.gfid, args.gfid, 16);
+ state->resolve.type = RESOLVE_MUST;
+ state->resolve.fd_no = args.fd;
+ state->flags = args.data;
+ memcpy(state->resolve.gfid, args.gfid, 16);
- GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
- state->xdata,
- args.xdata.xdata_val,
- args.xdata.xdata_len, ret,
- op_errno, out);
+ GF_PROTOCOL_DICT_UNSERIALIZE(frame->root->client->bound_xl, state->xdata,
+ args.xdata.xdata_val, args.xdata.xdata_len,
+ ret, op_errno, out);
- ret = 0;
- resolve_and_resume (frame, server_fsync_resume);
+ ret = 0;
+ resolve_and_resume(frame, server_fsync_resume);
out:
- free (args.xdata.xdata_val);
+ free(args.xdata.xdata_val);
- if (op_errno)
- SERVER_REQ_SET_ERROR (req, ret);
+ if (op_errno)
+ SERVER_REQ_SET_ERROR(req, ret);
- return ret;
+ return ret;
}
-
-
int
-server3_3_flush (rpcsvc_request_t *req)
+server3_3_flush(rpcsvc_request_t *req)
{
- server_state_t *state = NULL;
- call_frame_t *frame = NULL;
- gfs3_flush_req args = {{0,},};
- int ret = -1;
- int op_errno = 0;
+ server_state_t *state = NULL;
+ call_frame_t *frame = NULL;
+ gfs3_flush_req args = {
+ {
+ 0,
+ },
+ };
+ int ret = -1;
+ int op_errno = 0;
- if (!req)
- return ret;
+ if (!req)
+ return ret;
- ret = rpc_receive_common (req, &frame, &state, NULL, &args,
- xdr_gfs3_flush_req, GF_FOP_FLUSH);
- if (ret != 0) {
- goto out;
- }
+ ret = rpc_receive_common(req, &frame, &state, NULL, &args,
+ xdr_gfs3_flush_req, GF_FOP_FLUSH);
+ if (ret != 0) {
+ goto out;
+ }
- state->resolve.type = RESOLVE_MUST;
- state->resolve.fd_no = args.fd;
- memcpy (state->resolve.gfid, args.gfid, 16);
+ state->resolve.type = RESOLVE_MUST;
+ state->resolve.fd_no = args.fd;
+ memcpy(state->resolve.gfid, args.gfid, 16);
- GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
- state->xdata,
- args.xdata.xdata_val,
- args.xdata.xdata_len, ret,
- op_errno, out);
+ GF_PROTOCOL_DICT_UNSERIALIZE(frame->root->client->bound_xl, state->xdata,
+ args.xdata.xdata_val, args.xdata.xdata_len,
+ ret, op_errno, out);
- ret = 0;
- resolve_and_resume (frame, server_flush_resume);
+ ret = 0;
+ resolve_and_resume(frame, server_flush_resume);
out:
- free (args.xdata.xdata_val);
+ free(args.xdata.xdata_val);
- if (op_errno)
- SERVER_REQ_SET_ERROR (req, ret);
+ if (op_errno)
+ SERVER_REQ_SET_ERROR(req, ret);
- return ret;
+ return ret;
}
-
-
int
-server3_3_ftruncate (rpcsvc_request_t *req)
+server3_3_ftruncate(rpcsvc_request_t *req)
{
- server_state_t *state = NULL;
- call_frame_t *frame = NULL;
- gfs3_ftruncate_req args = {{0,},};
- int ret = -1;
- int op_errno = 0;
+ server_state_t *state = NULL;
+ call_frame_t *frame = NULL;
+ gfs3_ftruncate_req args = {
+ {
+ 0,
+ },
+ };
+ int ret = -1;
+ int op_errno = 0;
- if (!req)
- return ret;
+ if (!req)
+ return ret;
- ret = rpc_receive_common (req, &frame, &state, NULL, &args,
- xdr_gfs3_ftruncate_req, GF_FOP_FTRUNCATE);
- if (ret != 0) {
- goto out;
- }
+ ret = rpc_receive_common(req, &frame, &state, NULL, &args,
+ xdr_gfs3_ftruncate_req, GF_FOP_FTRUNCATE);
+ if (ret != 0) {
+ goto out;
+ }
- state->resolve.type = RESOLVE_MUST;
- state->resolve.fd_no = args.fd;
- state->offset = args.offset;
- memcpy (state->resolve.gfid, args.gfid, 16);
+ state->resolve.type = RESOLVE_MUST;
+ state->resolve.fd_no = args.fd;
+ state->offset = args.offset;
+ memcpy(state->resolve.gfid, args.gfid, 16);
- GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
- state->xdata,
- args.xdata.xdata_val,
- args.xdata.xdata_len, ret,
- op_errno, out);
+ GF_PROTOCOL_DICT_UNSERIALIZE(frame->root->client->bound_xl, state->xdata,
+ args.xdata.xdata_val, args.xdata.xdata_len,
+ ret, op_errno, out);
- ret = 0;
- resolve_and_resume (frame, server_ftruncate_resume);
+ ret = 0;
+ resolve_and_resume(frame, server_ftruncate_resume);
out:
- free (args.xdata.xdata_val);
+ free(args.xdata.xdata_val);
- if (op_errno)
- SERVER_REQ_SET_ERROR (req, ret);
+ if (op_errno)
+ SERVER_REQ_SET_ERROR(req, ret);
- return ret;
+ return ret;
}
-
int
-server3_3_fstat (rpcsvc_request_t *req)
+server3_3_fstat(rpcsvc_request_t *req)
{
- server_state_t *state = NULL;
- call_frame_t *frame = NULL;
- gfs3_fstat_req args = {{0,},};
- int ret = -1;
- int op_errno = 0;
+ server_state_t *state = NULL;
+ call_frame_t *frame = NULL;
+ gfs3_fstat_req args = {
+ {
+ 0,
+ },
+ };
+ int ret = -1;
+ int op_errno = 0;
- if (!req)
- return ret;
+ if (!req)
+ return ret;
- ret = rpc_receive_common (req, &frame, &state, NULL, &args,
- xdr_gfs3_fstat_req, GF_FOP_FSTAT);
- if (ret != 0) {
- goto out;
- }
+ ret = rpc_receive_common(req, &frame, &state, NULL, &args,
+ xdr_gfs3_fstat_req, GF_FOP_FSTAT);
+ if (ret != 0) {
+ goto out;
+ }
- state->resolve.type = RESOLVE_MUST;
- state->resolve.fd_no = args.fd;
- set_resolve_gfid (frame->root->client, state->resolve.gfid, args.gfid);
+ state->resolve.type = RESOLVE_MUST;
+ state->resolve.fd_no = args.fd;
+ set_resolve_gfid(frame->root->client, state->resolve.gfid, args.gfid);
- GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
- state->xdata,
- args.xdata.xdata_val,
- args.xdata.xdata_len, ret,
- op_errno, out);
+ GF_PROTOCOL_DICT_UNSERIALIZE(frame->root->client->bound_xl, state->xdata,
+ args.xdata.xdata_val, args.xdata.xdata_len,
+ ret, op_errno, out);
- ret = 0;
- resolve_and_resume (frame, server_fstat_resume);
+ ret = 0;
+ resolve_and_resume(frame, server_fstat_resume);
out:
- free (args.xdata.xdata_val);
+ free(args.xdata.xdata_val);
- if (op_errno)
- SERVER_REQ_SET_ERROR (req, ret);
+ if (op_errno)
+ SERVER_REQ_SET_ERROR(req, ret);
- return ret;
+ return ret;
}
-
int
-server3_3_truncate (rpcsvc_request_t *req)
+server3_3_truncate(rpcsvc_request_t *req)
{
- server_state_t *state = NULL;
- call_frame_t *frame = NULL;
- gfs3_truncate_req args = {{0,},};
- int ret = -1;
- int op_errno = 0;
+ server_state_t *state = NULL;
+ call_frame_t *frame = NULL;
+ gfs3_truncate_req args = {
+ {
+ 0,
+ },
+ };
+ int ret = -1;
+ int op_errno = 0;
- if (!req)
- return ret;
+ if (!req)
+ return ret;
- ret = rpc_receive_common (req, &frame, &state, NULL, &args,
- xdr_gfs3_truncate_req, GF_FOP_TRUNCATE);
- if (ret != 0) {
- goto out;
- }
+ ret = rpc_receive_common(req, &frame, &state, NULL, &args,
+ xdr_gfs3_truncate_req, GF_FOP_TRUNCATE);
+ if (ret != 0) {
+ goto out;
+ }
- state->resolve.type = RESOLVE_MUST;
- memcpy (state->resolve.gfid, args.gfid, 16);
- state->offset = args.offset;
+ state->resolve.type = RESOLVE_MUST;
+ memcpy(state->resolve.gfid, args.gfid, 16);
+ state->offset = args.offset;
- GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
- state->xdata,
- args.xdata.xdata_val,
- args.xdata.xdata_len, ret,
- op_errno, out);
+ GF_PROTOCOL_DICT_UNSERIALIZE(frame->root->client->bound_xl, state->xdata,
+ args.xdata.xdata_val, args.xdata.xdata_len,
+ ret, op_errno, out);
- ret = 0;
- resolve_and_resume (frame, server_truncate_resume);
+ ret = 0;
+ resolve_and_resume(frame, server_truncate_resume);
out:
- free (args.xdata.xdata_val);
+ free(args.xdata.xdata_val);
- if (op_errno)
- SERVER_REQ_SET_ERROR (req, ret);
+ if (op_errno)
+ SERVER_REQ_SET_ERROR(req, ret);
- return ret;
+ return ret;
}
-
-
int
-server3_3_unlink (rpcsvc_request_t *req)
+server3_3_unlink(rpcsvc_request_t *req)
{
- server_state_t *state = NULL;
- call_frame_t *frame = NULL;
- gfs3_unlink_req args = {{0,},};
- int ret = -1;
- int op_errno = 0;
+ server_state_t *state = NULL;
+ call_frame_t *frame = NULL;
+ gfs3_unlink_req args = {
+ {
+ 0,
+ },
+ };
+ int ret = -1;
+ int op_errno = 0;
- if (!req)
- return ret;
+ if (!req)
+ return ret;
- ret = rpc_receive_common (req, &frame, &state, NULL, &args,
- xdr_gfs3_unlink_req, GF_FOP_UNLINK);
- if (ret != 0) {
- goto out;
- }
+ ret = rpc_receive_common(req, &frame, &state, NULL, &args,
+ xdr_gfs3_unlink_req, GF_FOP_UNLINK);
+ if (ret != 0) {
+ goto out;
+ }
- state->resolve.type = RESOLVE_MUST;
- state->resolve.bname = gf_strdup (args.bname);
+ state->resolve.type = RESOLVE_MUST;
+ state->resolve.bname = gf_strdup(args.bname);
- set_resolve_gfid (frame->root->client, state->resolve.pargfid,
- args.pargfid);
+ set_resolve_gfid(frame->root->client, state->resolve.pargfid, args.pargfid);
- state->flags = args.xflags;
+ state->flags = args.xflags;
- GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
- state->xdata,
- args.xdata.xdata_val,
- args.xdata.xdata_len, ret,
- op_errno, out);
+ GF_PROTOCOL_DICT_UNSERIALIZE(frame->root->client->bound_xl, state->xdata,
+ args.xdata.xdata_val, args.xdata.xdata_len,
+ ret, op_errno, out);
- ret = 0;
- resolve_and_resume (frame, server_unlink_resume);
+ ret = 0;
+ resolve_and_resume(frame, server_unlink_resume);
out:
- free (args.xdata.xdata_val);
- free (args.bname);
+ free(args.xdata.xdata_val);
+ free(args.bname);
- if (op_errno)
- SERVER_REQ_SET_ERROR (req, ret);
+ if (op_errno)
+ SERVER_REQ_SET_ERROR(req, ret);
- return ret;
+ return ret;
}
-
int
-server3_3_setxattr (rpcsvc_request_t *req)
+server3_3_setxattr(rpcsvc_request_t *req)
{
- server_state_t *state = NULL;
- dict_t *dict = NULL;
- call_frame_t *frame = NULL;
- gfs3_setxattr_req args = {{0,},};
- int32_t ret = -1;
- int32_t op_errno = 0;
+ server_state_t *state = NULL;
+ dict_t *dict = NULL;
+ call_frame_t *frame = NULL;
+ gfs3_setxattr_req args = {
+ {
+ 0,
+ },
+ };
+ int32_t ret = -1;
+ int32_t op_errno = 0;
- if (!req)
- return ret;
+ if (!req)
+ return ret;
- ret = rpc_receive_common (req, &frame, &state, NULL, &args,
- xdr_gfs3_setxattr_req, GF_FOP_SETXATTR);
- if (ret != 0) {
- goto out;
- }
+ ret = rpc_receive_common(req, &frame, &state, NULL, &args,
+ xdr_gfs3_setxattr_req, GF_FOP_SETXATTR);
+ if (ret != 0) {
+ goto out;
+ }
- state->resolve.type = RESOLVE_MUST;
- state->flags = args.flags;
- set_resolve_gfid (frame->root->client, state->resolve.gfid, args.gfid);
+ state->resolve.type = RESOLVE_MUST;
+ state->flags = args.flags;
+ set_resolve_gfid(frame->root->client, state->resolve.gfid, args.gfid);
- GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
- dict,
- (args.dict.dict_val),
- (args.dict.dict_len), ret,
- op_errno, out);
+ GF_PROTOCOL_DICT_UNSERIALIZE(frame->root->client->bound_xl, dict,
+ (args.dict.dict_val), (args.dict.dict_len),
+ ret, op_errno, out);
- state->dict = dict;
+ state->dict = dict;
- /* There can be some commands hidden in key, check and proceed */
- gf_server_check_setxattr_cmd (frame, dict);
+ /* There can be some commands hidden in key, check and proceed */
+ gf_server_check_setxattr_cmd(frame, dict);
- GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
- state->xdata,
- args.xdata.xdata_val,
- args.xdata.xdata_len, ret,
- op_errno, out);
+ GF_PROTOCOL_DICT_UNSERIALIZE(frame->root->client->bound_xl, state->xdata,
+ args.xdata.xdata_val, args.xdata.xdata_len,
+ ret, op_errno, out);
- ret = 0;
- resolve_and_resume (frame, server_setxattr_resume);
+ ret = 0;
+ resolve_and_resume(frame, server_setxattr_resume);
- /* 'dict' will be destroyed later when 'state' is not needed anymore */
- dict = NULL;
+ /* 'dict' will be destroyed later when 'state' is not needed anymore */
+ dict = NULL;
out:
- free (args.xdata.xdata_val);
- free (args.dict.dict_val);
+ free(args.xdata.xdata_val);
+ free(args.dict.dict_val);
- if (op_errno)
- SERVER_REQ_SET_ERROR (req, ret);
+ if (op_errno)
+ SERVER_REQ_SET_ERROR(req, ret);
- if (dict)
- dict_unref (dict);
+ if (dict)
+ dict_unref(dict);
- return ret;
+ return ret;
}
-
-
int
-server3_3_fsetxattr (rpcsvc_request_t *req)
+server3_3_fsetxattr(rpcsvc_request_t *req)
{
- server_state_t *state = NULL;
- dict_t *dict = NULL;
- call_frame_t *frame = NULL;
- gfs3_fsetxattr_req args = {{0,},};
- int32_t ret = -1;
- int32_t op_errno = 0;
+ server_state_t *state = NULL;
+ dict_t *dict = NULL;
+ call_frame_t *frame = NULL;
+ gfs3_fsetxattr_req args = {
+ {
+ 0,
+ },
+ };
+ int32_t ret = -1;
+ int32_t op_errno = 0;
- if (!req)
- return ret;
+ if (!req)
+ return ret;
- ret = rpc_receive_common (req, &frame, &state, NULL, &args,
- xdr_gfs3_fsetxattr_req, GF_FOP_FSETXATTR);
- if (ret != 0) {
- goto out;
- }
+ ret = rpc_receive_common(req, &frame, &state, NULL, &args,
+ xdr_gfs3_fsetxattr_req, GF_FOP_FSETXATTR);
+ if (ret != 0) {
+ goto out;
+ }
- state->resolve.type = RESOLVE_MUST;
- state->resolve.fd_no = args.fd;
- state->flags = args.flags;
- set_resolve_gfid (frame->root->client, state->resolve.gfid, args.gfid);
+ state->resolve.type = RESOLVE_MUST;
+ state->resolve.fd_no = args.fd;
+ state->flags = args.flags;
+ set_resolve_gfid(frame->root->client, state->resolve.gfid, args.gfid);
- GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
- dict,
- (args.dict.dict_val),
- (args.dict.dict_len), ret,
- op_errno, out);
+ GF_PROTOCOL_DICT_UNSERIALIZE(frame->root->client->bound_xl, dict,
+ (args.dict.dict_val), (args.dict.dict_len),
+ ret, op_errno, out);
- state->dict = dict;
+ state->dict = dict;
- GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
- state->xdata,
- args.xdata.xdata_val,
- args.xdata.xdata_len, ret,
- op_errno, out);
+ GF_PROTOCOL_DICT_UNSERIALIZE(frame->root->client->bound_xl, state->xdata,
+ args.xdata.xdata_val, args.xdata.xdata_len,
+ ret, op_errno, out);
- ret = 0;
- resolve_and_resume (frame, server_fsetxattr_resume);
+ ret = 0;
+ resolve_and_resume(frame, server_fsetxattr_resume);
- /* 'dict' will be destroyed later when 'state' is not needed anymore */
- dict = NULL;
+ /* 'dict' will be destroyed later when 'state' is not needed anymore */
+ dict = NULL;
out:
- free (args.xdata.xdata_val);
- free (args.dict.dict_val);
+ free(args.xdata.xdata_val);
+ free(args.dict.dict_val);
- if (op_errno)
- SERVER_REQ_SET_ERROR (req, ret);
+ if (op_errno)
+ SERVER_REQ_SET_ERROR(req, ret);
- if (dict)
- dict_unref (dict);
+ if (dict)
+ dict_unref(dict);
- return ret;
+ return ret;
}
-
-
int
-server3_3_fxattrop (rpcsvc_request_t *req)
+server3_3_fxattrop(rpcsvc_request_t *req)
{
- dict_t *dict = NULL;
- server_state_t *state = NULL;
- call_frame_t *frame = NULL;
- gfs3_fxattrop_req args = {{0,},};
- int32_t ret = -1;
- int32_t op_errno = 0;
+ dict_t *dict = NULL;
+ server_state_t *state = NULL;
+ call_frame_t *frame = NULL;
+ gfs3_fxattrop_req args = {
+ {
+ 0,
+ },
+ };
+ int32_t ret = -1;
+ int32_t op_errno = 0;
- if (!req)
- return ret;
+ if (!req)
+ return ret;
- ret = rpc_receive_common (req, &frame, &state, NULL, &args,
- xdr_gfs3_fxattrop_req, GF_FOP_FXATTROP);
- if (ret != 0) {
- goto out;
- }
+ ret = rpc_receive_common(req, &frame, &state, NULL, &args,
+ xdr_gfs3_fxattrop_req, GF_FOP_FXATTROP);
+ if (ret != 0) {
+ goto out;
+ }
- state->resolve.type = RESOLVE_MUST;
- state->resolve.fd_no = args.fd;
- state->flags = args.flags;
- set_resolve_gfid (frame->root->client, state->resolve.gfid, args.gfid);
+ state->resolve.type = RESOLVE_MUST;
+ state->resolve.fd_no = args.fd;
+ state->flags = args.flags;
+ set_resolve_gfid(frame->root->client, state->resolve.gfid, args.gfid);
- GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
- dict,
- (args.dict.dict_val),
- (args.dict.dict_len), ret,
- op_errno, out);
+ GF_PROTOCOL_DICT_UNSERIALIZE(frame->root->client->bound_xl, dict,
+ (args.dict.dict_val), (args.dict.dict_len),
+ ret, op_errno, out);
- state->dict = dict;
+ state->dict = dict;
- GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
- state->xdata,
- args.xdata.xdata_val,
- args.xdata.xdata_len, ret,
- op_errno, out);
+ GF_PROTOCOL_DICT_UNSERIALIZE(frame->root->client->bound_xl, state->xdata,
+ args.xdata.xdata_val, args.xdata.xdata_len,
+ ret, op_errno, out);
- ret = 0;
- resolve_and_resume (frame, server_fxattrop_resume);
+ ret = 0;
+ resolve_and_resume(frame, server_fxattrop_resume);
- /* 'dict' will be destroyed later when 'state' is not needed anymore */
- dict = NULL;
+ /* 'dict' will be destroyed later when 'state' is not needed anymore */
+ dict = NULL;
out:
- free (args.xdata.xdata_val);
- free (args.dict.dict_val);
+ free(args.xdata.xdata_val);
+ free(args.dict.dict_val);
- if (op_errno)
- SERVER_REQ_SET_ERROR (req, ret);
+ if (op_errno)
+ SERVER_REQ_SET_ERROR(req, ret);
- if (dict)
- dict_unref (dict);
+ if (dict)
+ dict_unref(dict);
- return ret;
+ return ret;
}
-
-
int
-server3_3_xattrop (rpcsvc_request_t *req)
+server3_3_xattrop(rpcsvc_request_t *req)
{
- dict_t *dict = NULL;
- server_state_t *state = NULL;
- call_frame_t *frame = NULL;
- gfs3_xattrop_req args = {{0,},};
- int32_t ret = -1;
- int32_t op_errno = 0;
+ dict_t *dict = NULL;
+ server_state_t *state = NULL;
+ call_frame_t *frame = NULL;
+ gfs3_xattrop_req args = {
+ {
+ 0,
+ },
+ };
+ int32_t ret = -1;
+ int32_t op_errno = 0;
- if (!req)
- return ret;
+ if (!req)
+ return ret;
- ret = rpc_receive_common (req, &frame, &state, NULL, &args,
- xdr_gfs3_xattrop_req, GF_FOP_XATTROP);
- if (ret != 0) {
- goto out;
- }
+ ret = rpc_receive_common(req, &frame, &state, NULL, &args,
+ xdr_gfs3_xattrop_req, GF_FOP_XATTROP);
+ if (ret != 0) {
+ goto out;
+ }
- state->resolve.type = RESOLVE_MUST;
- state->flags = args.flags;
- set_resolve_gfid (frame->root->client, state->resolve.gfid, args.gfid);
+ state->resolve.type = RESOLVE_MUST;
+ state->flags = args.flags;
+ set_resolve_gfid(frame->root->client, state->resolve.gfid, args.gfid);
- GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
- dict,
- (args.dict.dict_val),
- (args.dict.dict_len), ret,
- op_errno, out);
+ GF_PROTOCOL_DICT_UNSERIALIZE(frame->root->client->bound_xl, dict,
+ (args.dict.dict_val), (args.dict.dict_len),
+ ret, op_errno, out);
- state->dict = dict;
+ state->dict = dict;
- GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
- state->xdata,
- args.xdata.xdata_val,
- args.xdata.xdata_len, ret,
- op_errno, out);
+ GF_PROTOCOL_DICT_UNSERIALIZE(frame->root->client->bound_xl, state->xdata,
+ args.xdata.xdata_val, args.xdata.xdata_len,
+ ret, op_errno, out);
- ret = 0;
- resolve_and_resume (frame, server_xattrop_resume);
+ ret = 0;
+ resolve_and_resume(frame, server_xattrop_resume);
- /* 'dict' will be destroyed later when 'state' is not needed anymore */
- dict = NULL;
+ /* 'dict' will be destroyed later when 'state' is not needed anymore */
+ dict = NULL;
out:
- free (args.xdata.xdata_val);
- free (args.dict.dict_val);
+ free(args.xdata.xdata_val);
+ free(args.dict.dict_val);
- if (op_errno)
- SERVER_REQ_SET_ERROR (req, ret);
+ if (op_errno)
+ SERVER_REQ_SET_ERROR(req, ret);
- if (dict)
- dict_unref (dict);
+ if (dict)
+ dict_unref(dict);
- return ret;
+ return ret;
}
-
int
-server3_3_getxattr (rpcsvc_request_t *req)
+server3_3_getxattr(rpcsvc_request_t *req)
{
- server_state_t *state = NULL;
- call_frame_t *frame = NULL;
- gfs3_getxattr_req args = {{0,},};
- int ret = -1;
- int op_errno = 0;
+ server_state_t *state = NULL;
+ call_frame_t *frame = NULL;
+ gfs3_getxattr_req args = {
+ {
+ 0,
+ },
+ };
+ int ret = -1;
+ int op_errno = 0;
- if (!req)
- return ret;
+ if (!req)
+ return ret;
- ret = rpc_receive_common (req, &frame, &state, NULL, &args,
- xdr_gfs3_getxattr_req, GF_FOP_GETXATTR);
- if (ret != 0) {
- goto out;
- }
+ ret = rpc_receive_common(req, &frame, &state, NULL, &args,
+ xdr_gfs3_getxattr_req, GF_FOP_GETXATTR);
+ if (ret != 0) {
+ goto out;
+ }
- state->resolve.type = RESOLVE_MUST;
- set_resolve_gfid (frame->root->client, state->resolve.gfid, args.gfid);
+ state->resolve.type = RESOLVE_MUST;
+ set_resolve_gfid(frame->root->client, state->resolve.gfid, args.gfid);
- if (args.namelen) {
- state->name = gf_strdup (args.name);
- /* There can be some commands hidden in key, check and proceed */
- gf_server_check_getxattr_cmd (frame, state->name);
- }
+ if (args.namelen) {
+ state->name = gf_strdup(args.name);
+ /* There can be some commands hidden in key, check and proceed */
+ gf_server_check_getxattr_cmd(frame, state->name);
+ }
- GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
- state->xdata,
- args.xdata.xdata_val,
- args.xdata.xdata_len, ret,
- op_errno, out);
+ GF_PROTOCOL_DICT_UNSERIALIZE(frame->root->client->bound_xl, state->xdata,
+ args.xdata.xdata_val, args.xdata.xdata_len,
+ ret, op_errno, out);
- ret = 0;
- resolve_and_resume (frame, server_getxattr_resume);
+ ret = 0;
+ resolve_and_resume(frame, server_getxattr_resume);
out:
- free (args.xdata.xdata_val);
- free (args.name);
+ free(args.xdata.xdata_val);
+ free(args.name);
- if (op_errno)
- SERVER_REQ_SET_ERROR (req, ret);
+ if (op_errno)
+ SERVER_REQ_SET_ERROR(req, ret);
- return ret;
+ return ret;
}
-
int
-server3_3_fgetxattr (rpcsvc_request_t *req)
+server3_3_fgetxattr(rpcsvc_request_t *req)
{
- server_state_t *state = NULL;
- call_frame_t *frame = NULL;
- gfs3_fgetxattr_req args = {{0,},};
- int ret = -1;
- int op_errno = 0;
+ server_state_t *state = NULL;
+ call_frame_t *frame = NULL;
+ gfs3_fgetxattr_req args = {
+ {
+ 0,
+ },
+ };
+ int ret = -1;
+ int op_errno = 0;
- if (!req)
- return ret;
+ if (!req)
+ return ret;
- ret = rpc_receive_common (req, &frame, &state, NULL, &args,
- xdr_gfs3_fgetxattr_req, GF_FOP_FGETXATTR);
- if (ret != 0) {
- goto out;
- }
+ ret = rpc_receive_common(req, &frame, &state, NULL, &args,
+ xdr_gfs3_fgetxattr_req, GF_FOP_FGETXATTR);
+ if (ret != 0) {
+ goto out;
+ }
- state->resolve.type = RESOLVE_MUST;
- state->resolve.fd_no = args.fd;
- set_resolve_gfid (frame->root->client, state->resolve.gfid, args.gfid);
- if (args.namelen)
- state->name = gf_strdup (args.name);
+ state->resolve.type = RESOLVE_MUST;
+ state->resolve.fd_no = args.fd;
+ set_resolve_gfid(frame->root->client, state->resolve.gfid, args.gfid);
+ if (args.namelen)
+ state->name = gf_strdup(args.name);
- GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
- state->xdata,
- args.xdata.xdata_val,
- args.xdata.xdata_len, ret,
- op_errno, out);
+ GF_PROTOCOL_DICT_UNSERIALIZE(frame->root->client->bound_xl, state->xdata,
+ args.xdata.xdata_val, args.xdata.xdata_len,
+ ret, op_errno, out);
- ret = 0;
- resolve_and_resume (frame, server_fgetxattr_resume);
+ ret = 0;
+ resolve_and_resume(frame, server_fgetxattr_resume);
out:
- free (args.xdata.xdata_val);
- free (args.name);
+ free(args.xdata.xdata_val);
+ free(args.name);
- if (op_errno)
- SERVER_REQ_SET_ERROR (req, ret);
+ if (op_errno)
+ SERVER_REQ_SET_ERROR(req, ret);
- return ret;
+ return ret;
}
-
-
int
-server3_3_removexattr (rpcsvc_request_t *req)
+server3_3_removexattr(rpcsvc_request_t *req)
{
- server_state_t *state = NULL;
- call_frame_t *frame = NULL;
- gfs3_removexattr_req args = {{0,},};
- int ret = -1;
- int op_errno = 0;
+ server_state_t *state = NULL;
+ call_frame_t *frame = NULL;
+ gfs3_removexattr_req args = {
+ {
+ 0,
+ },
+ };
+ int ret = -1;
+ int op_errno = 0;
- if (!req)
- return ret;
+ if (!req)
+ return ret;
- ret = rpc_receive_common (req, &frame, &state, NULL, &args,
- xdr_gfs3_removexattr_req,
- GF_FOP_REMOVEXATTR);
- if (ret != 0) {
- goto out;
- }
+ ret = rpc_receive_common(req, &frame, &state, NULL, &args,
+ xdr_gfs3_removexattr_req, GF_FOP_REMOVEXATTR);
+ if (ret != 0) {
+ goto out;
+ }
- state->resolve.type = RESOLVE_MUST;
- set_resolve_gfid (frame->root->client, state->resolve.gfid, args.gfid);
- state->name = gf_strdup (args.name);
+ state->resolve.type = RESOLVE_MUST;
+ set_resolve_gfid(frame->root->client, state->resolve.gfid, args.gfid);
+ state->name = gf_strdup(args.name);
- GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
- state->xdata,
- args.xdata.xdata_val,
- args.xdata.xdata_len, ret,
- op_errno, out);
+ GF_PROTOCOL_DICT_UNSERIALIZE(frame->root->client->bound_xl, state->xdata,
+ args.xdata.xdata_val, args.xdata.xdata_len,
+ ret, op_errno, out);
- ret = 0;
- resolve_and_resume (frame, server_removexattr_resume);
+ ret = 0;
+ resolve_and_resume(frame, server_removexattr_resume);
out:
- free (args.xdata.xdata_val);
- free (args.name);
+ free(args.xdata.xdata_val);
+ free(args.name);
- if (op_errno)
- SERVER_REQ_SET_ERROR (req, ret);
+ if (op_errno)
+ SERVER_REQ_SET_ERROR(req, ret);
- return ret;
+ return ret;
}
int
-server3_3_fremovexattr (rpcsvc_request_t *req)
+server3_3_fremovexattr(rpcsvc_request_t *req)
{
- server_state_t *state = NULL;
- call_frame_t *frame = NULL;
- gfs3_fremovexattr_req args = {{0,},};
- int ret = -1;
- int op_errno = 0;
+ server_state_t *state = NULL;
+ call_frame_t *frame = NULL;
+ gfs3_fremovexattr_req args = {
+ {
+ 0,
+ },
+ };
+ int ret = -1;
+ int op_errno = 0;
- if (!req)
- return ret;
+ if (!req)
+ return ret;
- ret = rpc_receive_common (req, &frame, &state, NULL, &args,
- xdr_gfs3_fremovexattr_req,
- GF_FOP_FREMOVEXATTR);
- if (ret != 0) {
- goto out;
- }
+ ret = rpc_receive_common(req, &frame, &state, NULL, &args,
+ xdr_gfs3_fremovexattr_req, GF_FOP_FREMOVEXATTR);
+ if (ret != 0) {
+ goto out;
+ }
- state->resolve.type = RESOLVE_MUST;
- state->resolve.fd_no = args.fd;
- set_resolve_gfid (frame->root->client, state->resolve.gfid, args.gfid);
- state->name = gf_strdup (args.name);
+ state->resolve.type = RESOLVE_MUST;
+ state->resolve.fd_no = args.fd;
+ set_resolve_gfid(frame->root->client, state->resolve.gfid, args.gfid);
+ state->name = gf_strdup(args.name);
- GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
- state->xdata,
- args.xdata.xdata_val,
- args.xdata.xdata_len, ret,
- op_errno, out);
+ GF_PROTOCOL_DICT_UNSERIALIZE(frame->root->client->bound_xl, state->xdata,
+ args.xdata.xdata_val, args.xdata.xdata_len,
+ ret, op_errno, out);
- ret = 0;
- resolve_and_resume (frame, server_fremovexattr_resume);
+ ret = 0;
+ resolve_and_resume(frame, server_fremovexattr_resume);
out:
- free (args.xdata.xdata_val);
- free (args.name);
+ free(args.xdata.xdata_val);
+ free(args.name);
- if (op_errno)
- SERVER_REQ_SET_ERROR (req, ret);
+ if (op_errno)
+ SERVER_REQ_SET_ERROR(req, ret);
- return ret;
+ return ret;
}
-
-
-
int
-server3_3_opendir (rpcsvc_request_t *req)
+server3_3_opendir(rpcsvc_request_t *req)
{
- server_state_t *state = NULL;
- call_frame_t *frame = NULL;
- gfs3_opendir_req args = {{0,},};
- int ret = -1;
- int op_errno = 0;
+ server_state_t *state = NULL;
+ call_frame_t *frame = NULL;
+ gfs3_opendir_req args = {
+ {
+ 0,
+ },
+ };
+ int ret = -1;
+ int op_errno = 0;
- if (!req)
- return ret;
+ if (!req)
+ return ret;
- ret = rpc_receive_common (req, &frame, &state, NULL, &args,
- xdr_gfs3_opendir_req, GF_FOP_OPENDIR);
- if (ret != 0) {
- goto out;
- }
+ ret = rpc_receive_common(req, &frame, &state, NULL, &args,
+ xdr_gfs3_opendir_req, GF_FOP_OPENDIR);
+ if (ret != 0) {
+ goto out;
+ }
- state->resolve.type = RESOLVE_MUST;
- set_resolve_gfid (frame->root->client, state->resolve.gfid, args.gfid);
+ state->resolve.type = RESOLVE_MUST;
+ set_resolve_gfid(frame->root->client, state->resolve.gfid, args.gfid);
- GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
- state->xdata,
- args.xdata.xdata_val,
- args.xdata.xdata_len, ret,
- op_errno, out);
+ GF_PROTOCOL_DICT_UNSERIALIZE(frame->root->client->bound_xl, state->xdata,
+ args.xdata.xdata_val, args.xdata.xdata_len,
+ ret, op_errno, out);
- ret = 0;
- resolve_and_resume (frame, server_opendir_resume);
+ ret = 0;
+ resolve_and_resume(frame, server_opendir_resume);
out:
- free (args.xdata.xdata_val);
+ free(args.xdata.xdata_val);
- if (op_errno)
- SERVER_REQ_SET_ERROR (req, ret);
+ if (op_errno)
+ SERVER_REQ_SET_ERROR(req, ret);
- return ret;
+ return ret;
}
-
int
-server3_3_readdirp (rpcsvc_request_t *req)
+server3_3_readdirp(rpcsvc_request_t *req)
{
- server_state_t *state = NULL;
- call_frame_t *frame = NULL;
- gfs3_readdirp_req args = {{0,},};
- size_t headers_size = 0;
- int ret = -1;
- int op_errno = 0;
-
- if (!req)
- return ret;
-
- ret = rpc_receive_common (req, &frame, &state, NULL, &args,
- xdr_gfs3_readdirp_req,
- GF_FOP_READDIRP);
- if (ret != 0) {
- goto out;
- }
-
- /* FIXME: this should go away when variable sized iobufs are introduced
- * and transport layer can send msgs bigger than current page-size.
- */
- headers_size = sizeof (struct rpc_msg) + sizeof (gfs3_readdir_rsp);
- if ((frame->this->ctx->page_size < args.size)
- || ((frame->this->ctx->page_size - args.size) < headers_size)) {
- state->size = frame->this->ctx->page_size - headers_size;
- } else {
- state->size = args.size;
- }
+ server_state_t *state = NULL;
+ call_frame_t *frame = NULL;
+ gfs3_readdirp_req args = {
+ {
+ 0,
+ },
+ };
+ size_t headers_size = 0;
+ int ret = -1;
+ int op_errno = 0;
+
+ if (!req)
+ return ret;
- state->resolve.type = RESOLVE_MUST;
- state->resolve.fd_no = args.fd;
- state->offset = args.offset;
- set_resolve_gfid (frame->root->client, state->resolve.gfid, args.gfid);
+ ret = rpc_receive_common(req, &frame, &state, NULL, &args,
+ xdr_gfs3_readdirp_req, GF_FOP_READDIRP);
+ if (ret != 0) {
+ goto out;
+ }
+
+ /* FIXME: this should go away when variable sized iobufs are introduced
+ * and transport layer can send msgs bigger than current page-size.
+ */
+ headers_size = sizeof(struct rpc_msg) + sizeof(gfs3_readdir_rsp);
+ if ((frame->this->ctx->page_size < args.size) ||
+ ((frame->this->ctx->page_size - args.size) < headers_size)) {
+ state->size = frame->this->ctx->page_size - headers_size;
+ } else {
+ state->size = args.size;
+ }
- /* here, dict itself works as xdata */
- GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
- state->dict,
- (args.dict.dict_val),
- (args.dict.dict_len), ret,
- op_errno, out);
+ state->resolve.type = RESOLVE_MUST;
+ state->resolve.fd_no = args.fd;
+ state->offset = args.offset;
+ set_resolve_gfid(frame->root->client, state->resolve.gfid, args.gfid);
+ /* here, dict itself works as xdata */
+ GF_PROTOCOL_DICT_UNSERIALIZE(frame->root->client->bound_xl, state->dict,
+ (args.dict.dict_val), (args.dict.dict_len),
+ ret, op_errno, out);
- ret = 0;
- resolve_and_resume (frame, server_readdirp_resume);
+ ret = 0;
+ resolve_and_resume(frame, server_readdirp_resume);
out:
- if (op_errno)
- SERVER_REQ_SET_ERROR (req, ret);
+ if (op_errno)
+ SERVER_REQ_SET_ERROR(req, ret);
- free (args.dict.dict_val);
+ free(args.dict.dict_val);
- return ret;
+ return ret;
}
int
-server3_3_readdir (rpcsvc_request_t *req)
+server3_3_readdir(rpcsvc_request_t *req)
{
- server_state_t *state = NULL;
- call_frame_t *frame = NULL;
- gfs3_readdir_req args = {{0,},};
- size_t headers_size = 0;
- int ret = -1;
- int op_errno = 0;
-
- if (!req)
- return ret;
-
- ret = rpc_receive_common (req, &frame, &state, NULL, &args,
- xdr_gfs3_readdir_req, GF_FOP_READDIR);
- if (ret != 0) {
- goto out;
- }
+ server_state_t *state = NULL;
+ call_frame_t *frame = NULL;
+ gfs3_readdir_req args = {
+ {
+ 0,
+ },
+ };
+ size_t headers_size = 0;
+ int ret = -1;
+ int op_errno = 0;
+
+ if (!req)
+ return ret;
- /* FIXME: this should go away when variable sized iobufs are introduced
- * and transport layer can send msgs bigger than current page-size.
- */
- headers_size = sizeof (struct rpc_msg) + sizeof (gfs3_readdir_rsp);
- if ((frame->this->ctx->page_size < args.size)
- || ((frame->this->ctx->page_size - args.size) < headers_size)) {
- state->size = frame->this->ctx->page_size - headers_size;
- } else {
- state->size = args.size;
- }
+ ret = rpc_receive_common(req, &frame, &state, NULL, &args,
+ xdr_gfs3_readdir_req, GF_FOP_READDIR);
+ if (ret != 0) {
+ goto out;
+ }
+
+ /* FIXME: this should go away when variable sized iobufs are introduced
+ * and transport layer can send msgs bigger than current page-size.
+ */
+ headers_size = sizeof(struct rpc_msg) + sizeof(gfs3_readdir_rsp);
+ if ((frame->this->ctx->page_size < args.size) ||
+ ((frame->this->ctx->page_size - args.size) < headers_size)) {
+ state->size = frame->this->ctx->page_size - headers_size;
+ } else {
+ state->size = args.size;
+ }
- state->resolve.type = RESOLVE_MUST;
- state->resolve.fd_no = args.fd;
- state->offset = args.offset;
- set_resolve_gfid (frame->root->client, state->resolve.gfid, args.gfid);
+ state->resolve.type = RESOLVE_MUST;
+ state->resolve.fd_no = args.fd;
+ state->offset = args.offset;
+ set_resolve_gfid(frame->root->client, state->resolve.gfid, args.gfid);
- GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
- state->xdata,
- args.xdata.xdata_val,
- args.xdata.xdata_len, ret,
- op_errno, out);
+ GF_PROTOCOL_DICT_UNSERIALIZE(frame->root->client->bound_xl, state->xdata,
+ args.xdata.xdata_val, args.xdata.xdata_len,
+ ret, op_errno, out);
- ret = 0;
- resolve_and_resume (frame, server_readdir_resume);
+ ret = 0;
+ resolve_and_resume(frame, server_readdir_resume);
out:
- free (args.xdata.xdata_val);
+ free(args.xdata.xdata_val);
- if (op_errno)
- SERVER_REQ_SET_ERROR (req, ret);
+ if (op_errno)
+ SERVER_REQ_SET_ERROR(req, ret);
- return ret;
+ return ret;
}
int
-server3_3_fsyncdir (rpcsvc_request_t *req)
+server3_3_fsyncdir(rpcsvc_request_t *req)
{
- server_state_t *state = NULL;
- call_frame_t *frame = NULL;
- gfs3_fsyncdir_req args = {{0,},};
- int ret = -1;
- int op_errno = 0;
+ server_state_t *state = NULL;
+ call_frame_t *frame = NULL;
+ gfs3_fsyncdir_req args = {
+ {
+ 0,
+ },
+ };
+ int ret = -1;
+ int op_errno = 0;
- if (!req)
- return ret;
+ if (!req)
+ return ret;
- ret = rpc_receive_common (req, &frame, &state, NULL, &args,
- xdr_gfs3_fsyncdir_req, GF_FOP_FSYNCDIR);
- if (ret != 0) {
- goto out;
- }
+ ret = rpc_receive_common(req, &frame, &state, NULL, &args,
+ xdr_gfs3_fsyncdir_req, GF_FOP_FSYNCDIR);
+ if (ret != 0) {
+ goto out;
+ }
- state->resolve.type = RESOLVE_MUST;
- state->resolve.fd_no = args.fd;
- state->flags = args.data;
- set_resolve_gfid (frame->root->client, state->resolve.gfid, args.gfid);
+ state->resolve.type = RESOLVE_MUST;
+ state->resolve.fd_no = args.fd;
+ state->flags = args.data;
+ set_resolve_gfid(frame->root->client, state->resolve.gfid, args.gfid);
- GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
- state->xdata,
- args.xdata.xdata_val,
- args.xdata.xdata_len, ret,
- op_errno, out);
+ GF_PROTOCOL_DICT_UNSERIALIZE(frame->root->client->bound_xl, state->xdata,
+ args.xdata.xdata_val, args.xdata.xdata_len,
+ ret, op_errno, out);
- ret = 0;
- resolve_and_resume (frame, server_fsyncdir_resume);
+ ret = 0;
+ resolve_and_resume(frame, server_fsyncdir_resume);
out:
- free (args.xdata.xdata_val);
+ free(args.xdata.xdata_val);
- if (op_errno)
- SERVER_REQ_SET_ERROR (req, ret);
+ if (op_errno)
+ SERVER_REQ_SET_ERROR(req, ret);
- return ret;
+ return ret;
}
-
-
int
-server3_3_mknod (rpcsvc_request_t *req)
+server3_3_mknod(rpcsvc_request_t *req)
{
- server_state_t *state = NULL;
- call_frame_t *frame = NULL;
- gfs3_mknod_req args = {{0,},};
- int ret = -1;
- int op_errno = 0;
+ server_state_t *state = NULL;
+ call_frame_t *frame = NULL;
+ gfs3_mknod_req args = {
+ {
+ 0,
+ },
+ };
+ int ret = -1;
+ int op_errno = 0;
- if (!req)
- return ret;
+ if (!req)
+ return ret;
- ret = rpc_receive_common (req, &frame, &state, NULL, &args,
- xdr_gfs3_mknod_req, GF_FOP_MKNOD);
- if (ret != 0) {
- goto out;
- }
+ ret = rpc_receive_common(req, &frame, &state, NULL, &args,
+ xdr_gfs3_mknod_req, GF_FOP_MKNOD);
+ if (ret != 0) {
+ goto out;
+ }
- state->resolve.type = RESOLVE_NOT;
- set_resolve_gfid (frame->root->client, state->resolve.pargfid,
- args.pargfid);
+ state->resolve.type = RESOLVE_NOT;
+ set_resolve_gfid(frame->root->client, state->resolve.pargfid, args.pargfid);
- state->resolve.bname = gf_strdup (args.bname);
+ state->resolve.bname = gf_strdup(args.bname);
- state->mode = args.mode;
- state->dev = args.dev;
- state->umask = args.umask;
+ state->mode = args.mode;
+ state->dev = args.dev;
+ state->umask = args.umask;
- GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
- state->xdata,
- args.xdata.xdata_val,
- args.xdata.xdata_len, ret,
- op_errno, out);
+ GF_PROTOCOL_DICT_UNSERIALIZE(frame->root->client->bound_xl, state->xdata,
+ args.xdata.xdata_val, args.xdata.xdata_len,
+ ret, op_errno, out);
- ret = 0;
- resolve_and_resume (frame, server_mknod_resume);
+ ret = 0;
+ resolve_and_resume(frame, server_mknod_resume);
out:
- if (op_errno)
- SERVER_REQ_SET_ERROR (req, ret);
+ if (op_errno)
+ SERVER_REQ_SET_ERROR(req, ret);
- /* memory allocated by libc, don't use GF_FREE */
- free (args.xdata.xdata_val);
- free (args.bname);
-
- return ret;
+ /* memory allocated by libc, don't use GF_FREE */
+ free(args.xdata.xdata_val);
+ free(args.bname);
+ return ret;
}
-
int
-server3_3_mkdir (rpcsvc_request_t *req)
+server3_3_mkdir(rpcsvc_request_t *req)
{
- server_state_t *state = NULL;
- call_frame_t *frame = NULL;
- gfs3_mkdir_req args = {{0,},};
- int ret = -1;
- int op_errno = 0;
+ server_state_t *state = NULL;
+ call_frame_t *frame = NULL;
+ gfs3_mkdir_req args = {
+ {
+ 0,
+ },
+ };
+ int ret = -1;
+ int op_errno = 0;
- if (!req)
- return ret;
+ if (!req)
+ return ret;
- ret = rpc_receive_common (req, &frame, &state, NULL, &args,
- xdr_gfs3_mkdir_req, GF_FOP_MKDIR);
- if (ret != 0) {
- goto out;
- }
+ ret = rpc_receive_common(req, &frame, &state, NULL, &args,
+ xdr_gfs3_mkdir_req, GF_FOP_MKDIR);
+ if (ret != 0) {
+ goto out;
+ }
- state->resolve.type = RESOLVE_NOT;
- set_resolve_gfid (frame->root->client, state->resolve.pargfid,
- args.pargfid);
- state->resolve.bname = gf_strdup (args.bname);
+ state->resolve.type = RESOLVE_NOT;
+ set_resolve_gfid(frame->root->client, state->resolve.pargfid, args.pargfid);
+ state->resolve.bname = gf_strdup(args.bname);
- state->mode = args.mode;
- state->umask = args.umask;
+ state->mode = args.mode;
+ state->umask = args.umask;
- /* TODO: can do alloca for xdata field instead of stdalloc */
- GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
- state->xdata,
- args.xdata.xdata_val,
- args.xdata.xdata_len, ret,
- op_errno, out);
+ /* TODO: can do alloca for xdata field instead of stdalloc */
+ GF_PROTOCOL_DICT_UNSERIALIZE(frame->root->client->bound_xl, state->xdata,
+ args.xdata.xdata_val, args.xdata.xdata_len,
+ ret, op_errno, out);
- ret = 0;
- resolve_and_resume (frame, server_mkdir_resume);
+ ret = 0;
+ resolve_and_resume(frame, server_mkdir_resume);
out:
- if (op_errno)
- SERVER_REQ_SET_ERROR (req, ret);
+ if (op_errno)
+ SERVER_REQ_SET_ERROR(req, ret);
- free (args.xdata.xdata_val);
- free (args.bname);
+ free(args.xdata.xdata_val);
+ free(args.bname);
- return ret;
+ return ret;
}
-
int
-server3_3_rmdir (rpcsvc_request_t *req)
+server3_3_rmdir(rpcsvc_request_t *req)
{
- server_state_t *state = NULL;
- call_frame_t *frame = NULL;
- gfs3_rmdir_req args = {{0,},};
- int ret = -1;
- int op_errno = 0;
+ server_state_t *state = NULL;
+ call_frame_t *frame = NULL;
+ gfs3_rmdir_req args = {
+ {
+ 0,
+ },
+ };
+ int ret = -1;
+ int op_errno = 0;
- if (!req)
- return ret;
+ if (!req)
+ return ret;
- ret = rpc_receive_common (req, &frame, &state, NULL, &args,
- xdr_gfs3_rmdir_req, GF_FOP_RMDIR);
- if (ret != 0) {
- goto out;
- }
+ ret = rpc_receive_common(req, &frame, &state, NULL, &args,
+ xdr_gfs3_rmdir_req, GF_FOP_RMDIR);
+ if (ret != 0) {
+ goto out;
+ }
- state->resolve.type = RESOLVE_MUST;
- set_resolve_gfid (frame->root->client, state->resolve.pargfid,
- args.pargfid);
- state->resolve.bname = gf_strdup (args.bname);
+ state->resolve.type = RESOLVE_MUST;
+ set_resolve_gfid(frame->root->client, state->resolve.pargfid, args.pargfid);
+ state->resolve.bname = gf_strdup(args.bname);
- state->flags = args.xflags;
+ state->flags = args.xflags;
- GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
- state->xdata,
- args.xdata.xdata_val,
- args.xdata.xdata_len, ret,
- op_errno, out);
+ GF_PROTOCOL_DICT_UNSERIALIZE(frame->root->client->bound_xl, state->xdata,
+ args.xdata.xdata_val, args.xdata.xdata_len,
+ ret, op_errno, out);
- ret = 0;
- resolve_and_resume (frame, server_rmdir_resume);
+ ret = 0;
+ resolve_and_resume(frame, server_rmdir_resume);
out:
- free (args.xdata.xdata_val);
- free (args.bname);
+ free(args.xdata.xdata_val);
+ free(args.bname);
- if (op_errno)
- SERVER_REQ_SET_ERROR (req, ret);
+ if (op_errno)
+ SERVER_REQ_SET_ERROR(req, ret);
- return ret;
+ return ret;
}
-
-
int
-server3_3_inodelk (rpcsvc_request_t *req)
+server3_3_inodelk(rpcsvc_request_t *req)
{
- server_state_t *state = NULL;
- call_frame_t *frame = NULL;
- gfs3_inodelk_req args = {{0,},};
- int cmd = 0;
- int ret = -1;
- int op_errno = 0;
-
- if (!req)
- return ret;
+ server_state_t *state = NULL;
+ call_frame_t *frame = NULL;
+ gfs3_inodelk_req args = {
+ {
+ 0,
+ },
+ };
+ int cmd = 0;
+ int ret = -1;
+ int op_errno = 0;
+
+ if (!req)
+ return ret;
- ret = rpc_receive_common (req, &frame, &state, NULL, &args,
- xdr_gfs3_inodelk_req, GF_FOP_INODELK);
- if (ret != 0) {
- goto out;
- }
+ ret = rpc_receive_common(req, &frame, &state, NULL, &args,
+ xdr_gfs3_inodelk_req, GF_FOP_INODELK);
+ if (ret != 0) {
+ goto out;
+ }
- state->resolve.type = RESOLVE_EXACT;
- set_resolve_gfid (frame->root->client, state->resolve.gfid, args.gfid);
+ state->resolve.type = RESOLVE_EXACT;
+ set_resolve_gfid(frame->root->client, state->resolve.gfid, args.gfid);
- cmd = args.cmd;
- switch (cmd) {
+ cmd = args.cmd;
+ switch (cmd) {
case GF_LK_GETLK:
- state->cmd = F_GETLK;
- break;
+ state->cmd = F_GETLK;
+ break;
case GF_LK_SETLK:
- state->cmd = F_SETLK;
- break;
+ state->cmd = F_SETLK;
+ break;
case GF_LK_SETLKW:
- state->cmd = F_SETLKW;
- break;
- }
+ state->cmd = F_SETLKW;
+ break;
+ }
- state->type = args.type;
- state->volume = gf_strdup (args.volume);
+ state->type = args.type;
+ state->volume = gf_strdup(args.volume);
- gf_proto_flock_to_flock (&args.flock, &state->flock);
+ gf_proto_flock_to_flock(&args.flock, &state->flock);
- switch (state->type) {
+ switch (state->type) {
case GF_LK_F_RDLCK:
- state->flock.l_type = F_RDLCK;
- break;
+ state->flock.l_type = F_RDLCK;
+ break;
case GF_LK_F_WRLCK:
- state->flock.l_type = F_WRLCK;
- break;
+ state->flock.l_type = F_WRLCK;
+ break;
case GF_LK_F_UNLCK:
- state->flock.l_type = F_UNLCK;
- break;
- }
+ state->flock.l_type = F_UNLCK;
+ break;
+ }
- GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
- state->xdata,
- args.xdata.xdata_val,
- args.xdata.xdata_len, ret,
- op_errno, out);
+ GF_PROTOCOL_DICT_UNSERIALIZE(frame->root->client->bound_xl, state->xdata,
+ args.xdata.xdata_val, args.xdata.xdata_len,
+ ret, op_errno, out);
- ret = 0;
- resolve_and_resume (frame, server_inodelk_resume);
+ ret = 0;
+ resolve_and_resume(frame, server_inodelk_resume);
out:
- free (args.xdata.xdata_val);
- free (args.volume);
+ free(args.xdata.xdata_val);
+ free(args.volume);
- free (args.flock.lk_owner.lk_owner_val);
+ free(args.flock.lk_owner.lk_owner_val);
- if (op_errno)
- SERVER_REQ_SET_ERROR (req, ret);
+ if (op_errno)
+ SERVER_REQ_SET_ERROR(req, ret);
- return ret;
+ return ret;
}
int
-server3_3_finodelk (rpcsvc_request_t *req)
+server3_3_finodelk(rpcsvc_request_t *req)
{
- server_state_t *state = NULL;
- call_frame_t *frame = NULL;
- gfs3_finodelk_req args = {{0,},};
- int ret = -1;
- int op_errno = 0;
+ server_state_t *state = NULL;
+ call_frame_t *frame = NULL;
+ gfs3_finodelk_req args = {
+ {
+ 0,
+ },
+ };
+ int ret = -1;
+ int op_errno = 0;
- if (!req)
- return ret;
+ if (!req)
+ return ret;
- ret = rpc_receive_common (req, &frame, &state, NULL, &args,
- xdr_gfs3_finodelk_req,
- GF_FOP_FINODELK);
- if (ret != 0) {
- goto out;
- }
+ ret = rpc_receive_common(req, &frame, &state, NULL, &args,
+ xdr_gfs3_finodelk_req, GF_FOP_FINODELK);
+ if (ret != 0) {
+ goto out;
+ }
- state->resolve.type = RESOLVE_EXACT;
- state->volume = gf_strdup (args.volume);
- state->resolve.fd_no = args.fd;
- state->cmd = args.cmd;
- set_resolve_gfid (frame->root->client, state->resolve.gfid, args.gfid);
+ state->resolve.type = RESOLVE_EXACT;
+ state->volume = gf_strdup(args.volume);
+ state->resolve.fd_no = args.fd;
+ state->cmd = args.cmd;
+ set_resolve_gfid(frame->root->client, state->resolve.gfid, args.gfid);
- switch (state->cmd) {
+ switch (state->cmd) {
case GF_LK_GETLK:
- state->cmd = F_GETLK;
- break;
+ state->cmd = F_GETLK;
+ break;
case GF_LK_SETLK:
- state->cmd = F_SETLK;
- break;
+ state->cmd = F_SETLK;
+ break;
case GF_LK_SETLKW:
- state->cmd = F_SETLKW;
- break;
- }
+ state->cmd = F_SETLKW;
+ break;
+ }
- state->type = args.type;
+ state->type = args.type;
- gf_proto_flock_to_flock (&args.flock, &state->flock);
+ gf_proto_flock_to_flock(&args.flock, &state->flock);
- switch (state->type) {
+ switch (state->type) {
case GF_LK_F_RDLCK:
- state->flock.l_type = F_RDLCK;
- break;
+ state->flock.l_type = F_RDLCK;
+ break;
case GF_LK_F_WRLCK:
- state->flock.l_type = F_WRLCK;
- break;
+ state->flock.l_type = F_WRLCK;
+ break;
case GF_LK_F_UNLCK:
- state->flock.l_type = F_UNLCK;
- break;
- }
+ state->flock.l_type = F_UNLCK;
+ break;
+ }
- GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
- state->xdata,
- args.xdata.xdata_val,
- args.xdata.xdata_len, ret,
- op_errno, out);
+ GF_PROTOCOL_DICT_UNSERIALIZE(frame->root->client->bound_xl, state->xdata,
+ args.xdata.xdata_val, args.xdata.xdata_len,
+ ret, op_errno, out);
- ret = 0;
- resolve_and_resume (frame, server_finodelk_resume);
+ ret = 0;
+ resolve_and_resume(frame, server_finodelk_resume);
out:
- free (args.xdata.xdata_val);
- free (args.volume);
+ free(args.xdata.xdata_val);
+ free(args.volume);
- free (args.flock.lk_owner.lk_owner_val);
+ free(args.flock.lk_owner.lk_owner_val);
- if (op_errno)
- SERVER_REQ_SET_ERROR (req, ret);
+ if (op_errno)
+ SERVER_REQ_SET_ERROR(req, ret);
- return ret;
+ return ret;
}
-
int
-server3_3_entrylk (rpcsvc_request_t *req)
+server3_3_entrylk(rpcsvc_request_t *req)
{
- server_state_t *state = NULL;
- call_frame_t *frame = NULL;
- gfs3_entrylk_req args = {{0,},};
- int ret = -1;
- int op_errno = 0;
+ server_state_t *state = NULL;
+ call_frame_t *frame = NULL;
+ gfs3_entrylk_req args = {
+ {
+ 0,
+ },
+ };
+ int ret = -1;
+ int op_errno = 0;
- if (!req)
- return ret;
+ if (!req)
+ return ret;
- ret = rpc_receive_common (req, &frame, &state, NULL, &args,
- xdr_gfs3_entrylk_req,
- GF_FOP_ENTRYLK);
- if (ret != 0) {
- goto out;
- }
+ ret = rpc_receive_common(req, &frame, &state, NULL, &args,
+ xdr_gfs3_entrylk_req, GF_FOP_ENTRYLK);
+ if (ret != 0) {
+ goto out;
+ }
- state->resolve.type = RESOLVE_EXACT;
- set_resolve_gfid (frame->root->client, state->resolve.gfid, args.gfid);
+ state->resolve.type = RESOLVE_EXACT;
+ set_resolve_gfid(frame->root->client, state->resolve.gfid, args.gfid);
- if (args.namelen)
- state->name = gf_strdup (args.name);
- state->volume = gf_strdup (args.volume);
+ if (args.namelen)
+ state->name = gf_strdup(args.name);
+ state->volume = gf_strdup(args.volume);
- state->cmd = args.cmd;
- state->type = args.type;
+ state->cmd = args.cmd;
+ state->type = args.type;
- GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
- state->xdata,
- args.xdata.xdata_val,
- args.xdata.xdata_len, ret,
- op_errno, out);
+ GF_PROTOCOL_DICT_UNSERIALIZE(frame->root->client->bound_xl, state->xdata,
+ args.xdata.xdata_val, args.xdata.xdata_len,
+ ret, op_errno, out);
- ret = 0;
- resolve_and_resume (frame, server_entrylk_resume);
+ ret = 0;
+ resolve_and_resume(frame, server_entrylk_resume);
out:
- free (args.xdata.xdata_val);
- free (args.volume);
- free (args.name);
+ free(args.xdata.xdata_val);
+ free(args.volume);
+ free(args.name);
- if (op_errno)
- SERVER_REQ_SET_ERROR (req, ret);
+ if (op_errno)
+ SERVER_REQ_SET_ERROR(req, ret);
- return ret;
+ return ret;
}
int
-server3_3_fentrylk (rpcsvc_request_t *req)
+server3_3_fentrylk(rpcsvc_request_t *req)
{
- server_state_t *state = NULL;
- call_frame_t *frame = NULL;
- gfs3_fentrylk_req args = {{0,},};
- int ret = -1;
- int op_errno = 0;
+ server_state_t *state = NULL;
+ call_frame_t *frame = NULL;
+ gfs3_fentrylk_req args = {
+ {
+ 0,
+ },
+ };
+ int ret = -1;
+ int op_errno = 0;
- if (!req)
- return ret;
+ if (!req)
+ return ret;
- ret = rpc_receive_common (req, &frame, &state, NULL, &args,
- xdr_gfs3_fentrylk_req,
- GF_FOP_FENTRYLK);
- if (ret != 0) {
- goto out;
- }
+ ret = rpc_receive_common(req, &frame, &state, NULL, &args,
+ xdr_gfs3_fentrylk_req, GF_FOP_FENTRYLK);
+ if (ret != 0) {
+ goto out;
+ }
- state->resolve.type = RESOLVE_EXACT;
- state->resolve.fd_no = args.fd;
- state->cmd = args.cmd;
- state->type = args.type;
- set_resolve_gfid (frame->root->client, state->resolve.gfid, args.gfid);
+ state->resolve.type = RESOLVE_EXACT;
+ state->resolve.fd_no = args.fd;
+ state->cmd = args.cmd;
+ state->type = args.type;
+ set_resolve_gfid(frame->root->client, state->resolve.gfid, args.gfid);
- if (args.namelen)
- state->name = gf_strdup (args.name);
- state->volume = gf_strdup (args.volume);
+ if (args.namelen)
+ state->name = gf_strdup(args.name);
+ state->volume = gf_strdup(args.volume);
- GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
- state->xdata,
- args.xdata.xdata_val,
- args.xdata.xdata_len, ret,
- op_errno, out);
+ GF_PROTOCOL_DICT_UNSERIALIZE(frame->root->client->bound_xl, state->xdata,
+ args.xdata.xdata_val, args.xdata.xdata_len,
+ ret, op_errno, out);
- ret = 0;
- resolve_and_resume (frame, server_fentrylk_resume);
+ ret = 0;
+ resolve_and_resume(frame, server_fentrylk_resume);
out:
- free (args.xdata.xdata_val);
- free (args.volume);
- free (args.name);
+ free(args.xdata.xdata_val);
+ free(args.volume);
+ free(args.name);
- if (op_errno)
- SERVER_REQ_SET_ERROR (req, ret);
+ if (op_errno)
+ SERVER_REQ_SET_ERROR(req, ret);
- return ret;
+ return ret;
}
int
-server3_3_access (rpcsvc_request_t *req)
+server3_3_access(rpcsvc_request_t *req)
{
- server_state_t *state = NULL;
- call_frame_t *frame = NULL;
- gfs3_access_req args = {{0,},};
- int ret = -1;
- int op_errno = 0;
+ server_state_t *state = NULL;
+ call_frame_t *frame = NULL;
+ gfs3_access_req args = {
+ {
+ 0,
+ },
+ };
+ int ret = -1;
+ int op_errno = 0;
- if (!req)
- return ret;
+ if (!req)
+ return ret;
- ret = rpc_receive_common (req, &frame, &state, NULL, &args,
- xdr_gfs3_access_req, GF_FOP_ACCESS);
- if (ret != 0) {
- goto out;
- }
+ ret = rpc_receive_common(req, &frame, &state, NULL, &args,
+ xdr_gfs3_access_req, GF_FOP_ACCESS);
+ if (ret != 0) {
+ goto out;
+ }
- state->resolve.type = RESOLVE_MUST;
- set_resolve_gfid (frame->root->client, state->resolve.gfid, args.gfid);
- state->mask = args.mask;
+ state->resolve.type = RESOLVE_MUST;
+ set_resolve_gfid(frame->root->client, state->resolve.gfid, args.gfid);
+ state->mask = args.mask;
- GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
- state->xdata,
- args.xdata.xdata_val,
- args.xdata.xdata_len, ret,
- op_errno, out);
+ GF_PROTOCOL_DICT_UNSERIALIZE(frame->root->client->bound_xl, state->xdata,
+ args.xdata.xdata_val, args.xdata.xdata_len,
+ ret, op_errno, out);
- ret = 0;
- resolve_and_resume (frame, server_access_resume);
+ ret = 0;
+ resolve_and_resume(frame, server_access_resume);
out:
- free (args.xdata.xdata_val);
+ free(args.xdata.xdata_val);
- if (op_errno)
- SERVER_REQ_SET_ERROR (req, ret);
+ if (op_errno)
+ SERVER_REQ_SET_ERROR(req, ret);
- return ret;
+ return ret;
}
-
-
int
-server3_3_symlink (rpcsvc_request_t *req)
+server3_3_symlink(rpcsvc_request_t *req)
{
- server_state_t *state = NULL;
- call_frame_t *frame = NULL;
- gfs3_symlink_req args = {{0,},};
- int ret = -1;
- int op_errno = 0;
+ server_state_t *state = NULL;
+ call_frame_t *frame = NULL;
+ gfs3_symlink_req args = {
+ {
+ 0,
+ },
+ };
+ int ret = -1;
+ int op_errno = 0;
- if (!req)
- return ret;
+ if (!req)
+ return ret;
- ret = rpc_receive_common (req, &frame, &state, NULL, &args,
- xdr_gfs3_symlink_req, GF_FOP_SYMLINK);
- if (ret != 0) {
- goto out;
- }
+ ret = rpc_receive_common(req, &frame, &state, NULL, &args,
+ xdr_gfs3_symlink_req, GF_FOP_SYMLINK);
+ if (ret != 0) {
+ goto out;
+ }
- state->resolve.type = RESOLVE_NOT;
- set_resolve_gfid (frame->root->client, state->resolve.pargfid,
- args.pargfid);
- state->resolve.bname = gf_strdup (args.bname);
- state->name = gf_strdup (args.linkname);
- state->umask = args.umask;
+ state->resolve.type = RESOLVE_NOT;
+ set_resolve_gfid(frame->root->client, state->resolve.pargfid, args.pargfid);
+ state->resolve.bname = gf_strdup(args.bname);
+ state->name = gf_strdup(args.linkname);
+ state->umask = args.umask;
- GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
- state->xdata,
- args.xdata.xdata_val,
- args.xdata.xdata_len, ret,
- op_errno, out);
+ GF_PROTOCOL_DICT_UNSERIALIZE(frame->root->client->bound_xl, state->xdata,
+ args.xdata.xdata_val, args.xdata.xdata_len,
+ ret, op_errno, out);
- ret = 0;
- resolve_and_resume (frame, server_symlink_resume);
+ ret = 0;
+ resolve_and_resume(frame, server_symlink_resume);
out:
- if (op_errno)
- SERVER_REQ_SET_ERROR (req, ret);
+ if (op_errno)
+ SERVER_REQ_SET_ERROR(req, ret);
- /* memory allocated by libc, don't use GF_FREE */
- free (args.xdata.xdata_val);
- free (args.linkname);
- free (args.bname);
+ /* memory allocated by libc, don't use GF_FREE */
+ free(args.xdata.xdata_val);
+ free(args.linkname);
+ free(args.bname);
- return ret;
+ return ret;
}
-
-
int
-server3_3_link (rpcsvc_request_t *req)
+server3_3_link(rpcsvc_request_t *req)
{
- server_state_t *state = NULL;
- call_frame_t *frame = NULL;
- gfs3_link_req args = {{0,},};
- int ret = -1;
- int op_errno = 0;
+ server_state_t *state = NULL;
+ call_frame_t *frame = NULL;
+ gfs3_link_req args = {
+ {
+ 0,
+ },
+ };
+ int ret = -1;
+ int op_errno = 0;
- if (!req)
- return ret;
+ if (!req)
+ return ret;
- ret = rpc_receive_common (req, &frame, &state, NULL, &args,
- xdr_gfs3_link_req, GF_FOP_LINK);
- if (ret != 0) {
- goto out;
- }
+ ret = rpc_receive_common(req, &frame, &state, NULL, &args,
+ xdr_gfs3_link_req, GF_FOP_LINK);
+ if (ret != 0) {
+ goto out;
+ }
- state->resolve.type = RESOLVE_MUST;
- memcpy (state->resolve.gfid, args.oldgfid, 16);
+ state->resolve.type = RESOLVE_MUST;
+ memcpy(state->resolve.gfid, args.oldgfid, 16);
- state->resolve2.type = RESOLVE_NOT;
- state->resolve2.bname = gf_strdup (args.newbname);
- set_resolve_gfid (frame->root->client, state->resolve2.pargfid,
- args.newgfid);
+ state->resolve2.type = RESOLVE_NOT;
+ state->resolve2.bname = gf_strdup(args.newbname);
+ set_resolve_gfid(frame->root->client, state->resolve2.pargfid,
+ args.newgfid);
- GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
- state->xdata,
- args.xdata.xdata_val,
- args.xdata.xdata_len, ret,
- op_errno, out);
+ GF_PROTOCOL_DICT_UNSERIALIZE(frame->root->client->bound_xl, state->xdata,
+ args.xdata.xdata_val, args.xdata.xdata_len,
+ ret, op_errno, out);
- ret = 0;
- resolve_and_resume (frame, server_link_resume);
+ ret = 0;
+ resolve_and_resume(frame, server_link_resume);
out:
- free (args.xdata.xdata_val);
- free (args.newbname);
+ free(args.xdata.xdata_val);
+ free(args.newbname);
- if (op_errno)
- SERVER_REQ_SET_ERROR (req, ret);
+ if (op_errno)
+ SERVER_REQ_SET_ERROR(req, ret);
- return ret;
+ return ret;
}
-
int
-server3_3_rename (rpcsvc_request_t *req)
+server3_3_rename(rpcsvc_request_t *req)
{
- server_state_t *state = NULL;
- call_frame_t *frame = NULL;
- gfs3_rename_req args = {{0,},};
- int ret = -1;
- int op_errno = 0;
+ server_state_t *state = NULL;
+ call_frame_t *frame = NULL;
+ gfs3_rename_req args = {
+ {
+ 0,
+ },
+ };
+ int ret = -1;
+ int op_errno = 0;
- if (!req)
- return ret;
+ if (!req)
+ return ret;
- ret = rpc_receive_common (req, &frame, &state, NULL, &args,
- xdr_gfs3_rename_req, GF_FOP_RENAME);
- if (ret != 0) {
- goto out;
- }
+ ret = rpc_receive_common(req, &frame, &state, NULL, &args,
+ xdr_gfs3_rename_req, GF_FOP_RENAME);
+ if (ret != 0) {
+ goto out;
+ }
- state->resolve.type = RESOLVE_MUST;
- state->resolve.bname = gf_strdup (args.oldbname);
- set_resolve_gfid (frame->root->client, state->resolve.pargfid,
- args.oldgfid);
+ state->resolve.type = RESOLVE_MUST;
+ state->resolve.bname = gf_strdup(args.oldbname);
+ set_resolve_gfid(frame->root->client, state->resolve.pargfid, args.oldgfid);
- state->resolve2.type = RESOLVE_MAY;
- state->resolve2.bname = gf_strdup (args.newbname);
- set_resolve_gfid (frame->root->client, state->resolve2.pargfid,
- args.newgfid);
+ state->resolve2.type = RESOLVE_MAY;
+ state->resolve2.bname = gf_strdup(args.newbname);
+ set_resolve_gfid(frame->root->client, state->resolve2.pargfid,
+ args.newgfid);
- GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
- state->xdata,
- args.xdata.xdata_val,
- args.xdata.xdata_len, ret,
- op_errno, out);
+ GF_PROTOCOL_DICT_UNSERIALIZE(frame->root->client->bound_xl, state->xdata,
+ args.xdata.xdata_val, args.xdata.xdata_len,
+ ret, op_errno, out);
- ret = 0;
- resolve_and_resume (frame, server_rename_resume);
+ ret = 0;
+ resolve_and_resume(frame, server_rename_resume);
out:
- free (args.xdata.xdata_val);
- free (args.newbname);
- free (args.oldbname);
+ free(args.xdata.xdata_val);
+ free(args.newbname);
+ free(args.oldbname);
- if (op_errno)
- SERVER_REQ_SET_ERROR (req, ret);
+ if (op_errno)
+ SERVER_REQ_SET_ERROR(req, ret);
- return ret;
+ return ret;
}
int
-server3_3_lease (rpcsvc_request_t *req)
+server3_3_lease(rpcsvc_request_t *req)
{
- server_state_t *state = NULL;
- call_frame_t *frame = NULL;
- gfs3_lease_req args = {{0,},};
- int ret = -1;
- int op_errno = 0;
+ server_state_t *state = NULL;
+ call_frame_t *frame = NULL;
+ gfs3_lease_req args = {
+ {
+ 0,
+ },
+ };
+ int ret = -1;
+ int op_errno = 0;
- if (!req)
- return ret;
+ if (!req)
+ return ret;
- ret = rpc_receive_common (req, &frame, &state, NULL, &args,
- xdr_gfs3_lease_req, GF_FOP_LEASE);
- if (ret != 0) {
- goto out;
- }
+ ret = rpc_receive_common(req, &frame, &state, NULL, &args,
+ xdr_gfs3_lease_req, GF_FOP_LEASE);
+ if (ret != 0) {
+ goto out;
+ }
- state->resolve.type = RESOLVE_MUST;
- set_resolve_gfid (frame->root->client, state->resolve.gfid, args.gfid);
- gf_proto_lease_to_lease (&args.lease, &state->lease);
+ state->resolve.type = RESOLVE_MUST;
+ set_resolve_gfid(frame->root->client, state->resolve.gfid, args.gfid);
+ gf_proto_lease_to_lease(&args.lease, &state->lease);
- GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
- state->xdata,
- args.xdata.xdata_val,
- args.xdata.xdata_len, ret,
- op_errno, out);
+ GF_PROTOCOL_DICT_UNSERIALIZE(frame->root->client->bound_xl, state->xdata,
+ args.xdata.xdata_val, args.xdata.xdata_len,
+ ret, op_errno, out);
- ret = 0;
- resolve_and_resume (frame, server_lease_resume);
+ ret = 0;
+ resolve_and_resume(frame, server_lease_resume);
out:
- free (args.xdata.xdata_val);
+ free(args.xdata.xdata_val);
- if (op_errno)
- SERVER_REQ_SET_ERROR (req, ret);
+ if (op_errno)
+ SERVER_REQ_SET_ERROR(req, ret);
- return ret;
+ return ret;
}
int
-server3_3_lk (rpcsvc_request_t *req)
+server3_3_lk(rpcsvc_request_t *req)
{
- server_state_t *state = NULL;
- call_frame_t *frame = NULL;
- gfs3_lk_req args = {{0,},};
- int ret = -1;
- int op_errno = 0;
+ server_state_t *state = NULL;
+ call_frame_t *frame = NULL;
+ gfs3_lk_req args = {
+ {
+ 0,
+ },
+ };
+ int ret = -1;
+ int op_errno = 0;
- if (!req)
- return ret;
+ if (!req)
+ return ret;
- ret = rpc_receive_common (req, &frame, &state, NULL, &args,
- xdr_gfs3_lk_req, GF_FOP_LK);
- if (ret != 0) {
- goto out;
- }
+ ret = rpc_receive_common(req, &frame, &state, NULL, &args, xdr_gfs3_lk_req,
+ GF_FOP_LK);
+ if (ret != 0) {
+ goto out;
+ }
- state->resolve.fd_no = args.fd;
- state->cmd = args.cmd;
- state->type = args.type;
- set_resolve_gfid (frame->root->client, state->resolve.gfid, args.gfid);
+ state->resolve.fd_no = args.fd;
+ state->cmd = args.cmd;
+ state->type = args.type;
+ set_resolve_gfid(frame->root->client, state->resolve.gfid, args.gfid);
- switch (state->cmd) {
+ switch (state->cmd) {
case GF_LK_GETLK:
- state->cmd = F_GETLK;
- break;
+ state->cmd = F_GETLK;
+ break;
case GF_LK_SETLK:
- state->cmd = F_SETLK;
- break;
+ state->cmd = F_SETLK;
+ break;
case GF_LK_SETLKW:
- state->cmd = F_SETLKW;
- break;
+ state->cmd = F_SETLKW;
+ break;
case GF_LK_RESLK_LCK:
- state->cmd = F_RESLK_LCK;
- break;
+ state->cmd = F_RESLK_LCK;
+ break;
case GF_LK_RESLK_LCKW:
- state->cmd = F_RESLK_LCKW;
- break;
+ state->cmd = F_RESLK_LCKW;
+ break;
case GF_LK_RESLK_UNLCK:
- state->cmd = F_RESLK_UNLCK;
- break;
+ state->cmd = F_RESLK_UNLCK;
+ break;
case GF_LK_GETLK_FD:
- state->cmd = F_GETLK_FD;
- break;
-
- }
+ state->cmd = F_GETLK_FD;
+ break;
+ }
+ gf_proto_flock_to_flock(&args.flock, &state->flock);
- gf_proto_flock_to_flock (&args.flock, &state->flock);
-
- switch (state->type) {
+ switch (state->type) {
case GF_LK_F_RDLCK:
- state->flock.l_type = F_RDLCK;
- break;
+ state->flock.l_type = F_RDLCK;
+ break;
case GF_LK_F_WRLCK:
- state->flock.l_type = F_WRLCK;
- break;
+ state->flock.l_type = F_WRLCK;
+ break;
case GF_LK_F_UNLCK:
- state->flock.l_type = F_UNLCK;
- break;
+ state->flock.l_type = F_UNLCK;
+ break;
default:
- gf_msg (frame->root->client->bound_xl->name, GF_LOG_ERROR,
- 0, PS_MSG_LOCK_ERROR, "fd - %"PRId64" (%s): Unknown "
- "lock type: %"PRId32"!", state->resolve.fd_no,
- uuid_utoa (state->fd->inode->gfid), state->type);
- break;
- }
-
-
- GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
- state->xdata,
- args.xdata.xdata_val,
- args.xdata.xdata_len, ret,
- op_errno, out);
-
- ret = 0;
- resolve_and_resume (frame, server_lk_resume);
+ gf_msg(frame->root->client->bound_xl->name, GF_LOG_ERROR, 0,
+ PS_MSG_LOCK_ERROR,
+ "fd - %" PRId64
+ " (%s): Unknown "
+ "lock type: %" PRId32 "!",
+ state->resolve.fd_no, uuid_utoa(state->fd->inode->gfid),
+ state->type);
+ break;
+ }
+
+ GF_PROTOCOL_DICT_UNSERIALIZE(frame->root->client->bound_xl, state->xdata,
+ args.xdata.xdata_val, args.xdata.xdata_len,
+ ret, op_errno, out);
+
+ ret = 0;
+ resolve_and_resume(frame, server_lk_resume);
out:
- free (args.xdata.xdata_val);
+ free(args.xdata.xdata_val);
- free (args.flock.lk_owner.lk_owner_val);
+ free(args.flock.lk_owner.lk_owner_val);
- if (op_errno)
- SERVER_REQ_SET_ERROR (req, ret);
+ if (op_errno)
+ SERVER_REQ_SET_ERROR(req, ret);
- return ret;
+ return ret;
}
-
int
-server3_3_rchecksum (rpcsvc_request_t *req)
+server3_3_rchecksum(rpcsvc_request_t *req)
{
- server_state_t *state = NULL;
- call_frame_t *frame = NULL;
- gfs3_rchecksum_req args = {0,};
- int ret = -1;
- int op_errno = 0;
+ server_state_t *state = NULL;
+ call_frame_t *frame = NULL;
+ gfs3_rchecksum_req args = {
+ 0,
+ };
+ int ret = -1;
+ int op_errno = 0;
- if (!req)
- return ret;
+ if (!req)
+ return ret;
- ret = rpc_receive_common (req, &frame, &state, NULL, &args,
- xdr_gfs3_rchecksum_req,
- GF_FOP_RCHECKSUM);
- if (ret != 0) {
- goto out;
- }
+ ret = rpc_receive_common(req, &frame, &state, NULL, &args,
+ xdr_gfs3_rchecksum_req, GF_FOP_RCHECKSUM);
+ if (ret != 0) {
+ goto out;
+ }
- state->resolve.type = RESOLVE_MAY;
- state->resolve.fd_no = args.fd;
- state->offset = args.offset;
- state->size = args.len;
+ state->resolve.type = RESOLVE_MAY;
+ state->resolve.fd_no = args.fd;
+ state->offset = args.offset;
+ state->size = args.len;
- GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
- state->xdata,
- args.xdata.xdata_val,
- args.xdata.xdata_len, ret,
- op_errno, out);
+ GF_PROTOCOL_DICT_UNSERIALIZE(frame->root->client->bound_xl, state->xdata,
+ args.xdata.xdata_val, args.xdata.xdata_len,
+ ret, op_errno, out);
- ret = 0;
- resolve_and_resume (frame, server_rchecksum_resume);
+ ret = 0;
+ resolve_and_resume(frame, server_rchecksum_resume);
out:
- free (args.xdata.xdata_val);
+ free(args.xdata.xdata_val);
- if (op_errno)
- SERVER_REQ_SET_ERROR (req, ret);
+ if (op_errno)
+ SERVER_REQ_SET_ERROR(req, ret);
- return ret;
+ return ret;
}
-
int
-server_null (rpcsvc_request_t *req)
+server_null(rpcsvc_request_t *req)
{
- gf_common_rsp rsp = {0,};
+ gf_common_rsp rsp = {
+ 0,
+ };
- /* Accepted */
- rsp.op_ret = 0;
+ /* Accepted */
+ rsp.op_ret = 0;
- server_submit_reply (NULL, req, &rsp, NULL, 0, NULL,
- (xdrproc_t)xdr_gf_common_rsp);
+ server_submit_reply(NULL, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gf_common_rsp);
- return 0;
+ return 0;
}
int
-server3_3_lookup (rpcsvc_request_t *req)
+server3_3_lookup(rpcsvc_request_t *req)
{
- call_frame_t *frame = NULL;
- server_state_t *state = NULL;
- gfs3_lookup_req args = {{0,},};
- int ret = -1;
+ call_frame_t *frame = NULL;
+ server_state_t *state = NULL;
+ gfs3_lookup_req args = {
+ {
+ 0,
+ },
+ };
+ int ret = -1;
- GF_VALIDATE_OR_GOTO ("server", req, err);
+ GF_VALIDATE_OR_GOTO("server", req, err);
- ret = rpc_receive_common (req, &frame, &state, NULL, &args,
- xdr_gfs3_lookup_req, GF_FOP_LOOKUP);
- if (ret != 0) {
- goto err;
- }
+ ret = rpc_receive_common(req, &frame, &state, NULL, &args,
+ xdr_gfs3_lookup_req, GF_FOP_LOOKUP);
+ if (ret != 0) {
+ goto err;
+ }
- state->resolve.type = RESOLVE_DONTCARE;
+ state->resolve.type = RESOLVE_DONTCARE;
- if (args.bname && strcmp (args.bname, "")) {
- set_resolve_gfid (frame->root->client, state->resolve.pargfid,
- args.pargfid);
- state->resolve.bname = gf_strdup (args.bname);
- } else {
- set_resolve_gfid (frame->root->client,
- state->resolve.gfid, args.gfid);
- }
+ if (args.bname && strcmp(args.bname, "")) {
+ set_resolve_gfid(frame->root->client, state->resolve.pargfid,
+ args.pargfid);
+ state->resolve.bname = gf_strdup(args.bname);
+ } else {
+ set_resolve_gfid(frame->root->client, state->resolve.gfid, args.gfid);
+ }
- GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
- state->xdata,
- args.xdata.xdata_val,
- args.xdata.xdata_len, ret,
- ret, out);
+ GF_PROTOCOL_DICT_UNSERIALIZE(frame->root->client->bound_xl, state->xdata,
+ args.xdata.xdata_val, args.xdata.xdata_len,
+ ret, ret, out);
- ret = 0;
- resolve_and_resume (frame, server_lookup_resume);
+ ret = 0;
+ resolve_and_resume(frame, server_lookup_resume);
- free (args.bname);
- free (args.xdata.xdata_val);
+ free(args.bname);
+ free(args.xdata.xdata_val);
- return ret;
+ return ret;
out:
- free (args.bname);
- free (args.xdata.xdata_val);
+ free(args.bname);
+ free(args.xdata.xdata_val);
- server_lookup_cbk (frame, NULL, frame->this, -1, EINVAL, NULL, NULL,
- NULL, NULL);
- ret = 0;
+ server_lookup_cbk(frame, NULL, frame->this, -1, EINVAL, NULL, NULL, NULL,
+ NULL);
+ ret = 0;
err:
- return ret;
+ return ret;
}
int
-server3_3_statfs (rpcsvc_request_t *req)
+server3_3_statfs(rpcsvc_request_t *req)
{
- server_state_t *state = NULL;
- call_frame_t *frame = NULL;
- gfs3_statfs_req args = {{0,},};
- int ret = -1;
- int op_errno = 0;
+ server_state_t *state = NULL;
+ call_frame_t *frame = NULL;
+ gfs3_statfs_req args = {
+ {
+ 0,
+ },
+ };
+ int ret = -1;
+ int op_errno = 0;
- if (!req)
- return ret;
+ if (!req)
+ return ret;
- ret = rpc_receive_common (req, &frame, &state, NULL, &args,
- xdr_gfs3_statfs_req, GF_FOP_STATFS);
- if (ret != 0) {
- goto out;
- }
+ ret = rpc_receive_common(req, &frame, &state, NULL, &args,
+ xdr_gfs3_statfs_req, GF_FOP_STATFS);
+ if (ret != 0) {
+ goto out;
+ }
- state->resolve.type = RESOLVE_MUST;
- set_resolve_gfid (frame->root->client, state->resolve.gfid, args.gfid);
+ state->resolve.type = RESOLVE_MUST;
+ set_resolve_gfid(frame->root->client, state->resolve.gfid, args.gfid);
- GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
- state->xdata,
- args.xdata.xdata_val,
- args.xdata.xdata_len, ret,
- op_errno, out);
+ GF_PROTOCOL_DICT_UNSERIALIZE(frame->root->client->bound_xl, state->xdata,
+ args.xdata.xdata_val, args.xdata.xdata_len,
+ ret, op_errno, out);
- ret = 0;
- resolve_and_resume (frame, server_statfs_resume);
+ ret = 0;
+ resolve_and_resume(frame, server_statfs_resume);
out:
- free (args.xdata.xdata_val);
+ free(args.xdata.xdata_val);
- if (op_errno)
- SERVER_REQ_SET_ERROR (req, ret);
+ if (op_errno)
+ SERVER_REQ_SET_ERROR(req, ret);
- return ret;
+ return ret;
}
static int
-server3_3_getactivelk (rpcsvc_request_t *req)
-{
- server_state_t *state = NULL;
- call_frame_t *frame = NULL;
- gfs3_getactivelk_req args = {{0,},};
- int ret = -1;
- int op_errno = 0;
-
- if (!req)
- return ret;
-
- ret = rpc_receive_common (req, &frame, &state, NULL, &args,
- xdr_gfs3_getactivelk_req,
- GF_FOP_GETACTIVELK);
- if (ret != 0) {
- goto out;
- }
+server3_3_getactivelk(rpcsvc_request_t *req)
+{
+ server_state_t *state = NULL;
+ call_frame_t *frame = NULL;
+ gfs3_getactivelk_req args = {
+ {
+ 0,
+ },
+ };
+ int ret = -1;
+ int op_errno = 0;
- state->resolve.type = RESOLVE_MUST;
- set_resolve_gfid (frame->root->client, state->resolve.gfid, args.gfid);
+ if (!req)
+ return ret;
- /* here, dict itself works as xdata */
- GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
- state->xdata,
- (args.xdata.xdata_val),
- (args.xdata.xdata_len), ret,
- op_errno, out);
+ ret = rpc_receive_common(req, &frame, &state, NULL, &args,
+ xdr_gfs3_getactivelk_req, GF_FOP_GETACTIVELK);
+ if (ret != 0) {
+ goto out;
+ }
+ state->resolve.type = RESOLVE_MUST;
+ set_resolve_gfid(frame->root->client, state->resolve.gfid, args.gfid);
- ret = 0;
- resolve_and_resume (frame, server_getactivelk_resume);
+ /* here, dict itself works as xdata */
+ GF_PROTOCOL_DICT_UNSERIALIZE(frame->root->client->bound_xl, state->xdata,
+ (args.xdata.xdata_val), (args.xdata.xdata_len),
+ ret, op_errno, out);
+
+ ret = 0;
+ resolve_and_resume(frame, server_getactivelk_resume);
out:
- free (args.xdata.xdata_val);
+ free(args.xdata.xdata_val);
- if (op_errno)
- SERVER_REQ_SET_ERROR (req, ret);
+ if (op_errno)
+ SERVER_REQ_SET_ERROR(req, ret);
- return ret;
+ return ret;
}
-
static int
-server3_3_setactivelk (rpcsvc_request_t *req)
-{
- server_state_t *state = NULL;
- call_frame_t *frame = NULL;
- gfs3_setactivelk_req args = {{0,},};
- int ret = -1;
- int op_errno = 0;
-
- if (!req)
- return ret;
-
- ret = rpc_receive_common (req, &frame, &state, NULL, &args,
- xdr_gfs3_setactivelk_req,
- GF_FOP_SETACTIVELK);
- if (ret != 0) {
- goto out;
- }
+server3_3_setactivelk(rpcsvc_request_t *req)
+{
+ server_state_t *state = NULL;
+ call_frame_t *frame = NULL;
+ gfs3_setactivelk_req args = {
+ {
+ 0,
+ },
+ };
+ int ret = -1;
+ int op_errno = 0;
- state->resolve.type = RESOLVE_MUST;
- set_resolve_gfid (frame->root->client, state->resolve.gfid, args.gfid);
+ if (!req)
+ return ret;
+
+ ret = rpc_receive_common(req, &frame, &state, NULL, &args,
+ xdr_gfs3_setactivelk_req, GF_FOP_SETACTIVELK);
+ if (ret != 0) {
+ goto out;
+ }
- /* here, dict itself works as xdata */
- GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
- state->xdata,
- (args.xdata.xdata_val),
- (args.xdata.xdata_len), ret,
- op_errno, out);
+ state->resolve.type = RESOLVE_MUST;
+ set_resolve_gfid(frame->root->client, state->resolve.gfid, args.gfid);
- ret = unserialize_req_locklist (&args, &state->locklist);
- if (ret)
- goto out;
+ /* here, dict itself works as xdata */
+ GF_PROTOCOL_DICT_UNSERIALIZE(frame->root->client->bound_xl, state->xdata,
+ (args.xdata.xdata_val), (args.xdata.xdata_len),
+ ret, op_errno, out);
- ret = 0;
+ ret = unserialize_req_locklist(&args, &state->locklist);
+ if (ret)
+ goto out;
- resolve_and_resume (frame, server_setactivelk_resume);
+ ret = 0;
+
+ resolve_and_resume(frame, server_setactivelk_resume);
out:
- free (args.xdata.xdata_val);
+ free(args.xdata.xdata_val);
- if (op_errno)
- SERVER_REQ_SET_ERROR (req, ret);
+ if (op_errno)
+ SERVER_REQ_SET_ERROR(req, ret);
- return ret;
+ return ret;
}
int
-server3_3_compound (rpcsvc_request_t *req)
+server3_3_compound(rpcsvc_request_t *req)
{
- server_state_t *state = NULL;
- call_frame_t *frame = NULL;
- gfs3_compound_req args = {0,};
- ssize_t len = 0;
- int length = 0;
- int i = 0;
- int ret = -1;
- int op_errno = 0;
+ server_state_t *state = NULL;
+ call_frame_t *frame = NULL;
+ gfs3_compound_req args = {
+ 0,
+ };
+ ssize_t len = 0;
+ int length = 0;
+ int i = 0;
+ int ret = -1;
+ int op_errno = 0;
- if (!req)
- return ret;
+ if (!req)
+ return ret;
- ret = rpc_receive_common (req, &frame, &state, &len, &args,
- xdr_gfs3_compound_req,
- GF_FOP_COMPOUND);
- if (ret != 0) {
- goto out;
- }
+ ret = rpc_receive_common(req, &frame, &state, &len, &args,
+ xdr_gfs3_compound_req, GF_FOP_COMPOUND);
+ if (ret != 0) {
+ goto out;
+ }
- state->req = args;
- state->iobref = iobref_ref (req->iobref);
+ state->req = args;
+ state->iobref = iobref_ref(req->iobref);
- if (len < req->msg[0].iov_len) {
- state->payload_vector[0].iov_base
- = (req->msg[0].iov_base + len);
- state->payload_vector[0].iov_len
- = req->msg[0].iov_len - len;
- state->payload_count = 1;
- }
+ if (len < req->msg[0].iov_len) {
+ state->payload_vector[0].iov_base = (req->msg[0].iov_base + len);
+ state->payload_vector[0].iov_len = req->msg[0].iov_len - len;
+ state->payload_count = 1;
+ }
- for (i = 1; i < req->count; i++) {
- state->payload_vector[state->payload_count++]
- = req->msg[i];
- }
+ for (i = 1; i < req->count; i++) {
+ state->payload_vector[state->payload_count++] = req->msg[i];
+ }
- state->size = iov_length (state->payload_vector, state->payload_count);
+ state->size = iov_length(state->payload_vector, state->payload_count);
- ret = server_get_compound_resolve (state, &args);
+ ret = server_get_compound_resolve(state, &args);
- if (ret) {
- SERVER_REQ_SET_ERROR (req, ret);
- goto out;
- }
+ if (ret) {
+ SERVER_REQ_SET_ERROR(req, ret);
+ goto out;
+ }
- GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
- state->xdata,
- args.xdata.xdata_val,
- args.xdata.xdata_len, ret,
- op_errno, out);
+ GF_PROTOCOL_DICT_UNSERIALIZE(frame->root->client->bound_xl, state->xdata,
+ args.xdata.xdata_val, args.xdata.xdata_len,
+ ret, op_errno, out);
- ret = 0;
- resolve_and_resume (frame, server_compound_resume);
+ ret = 0;
+ resolve_and_resume(frame, server_compound_resume);
out:
- free (args.xdata.xdata_val);
+ free(args.xdata.xdata_val);
- length = args.compound_req_array.compound_req_array_len;
- server_compound_req_cleanup (&args, length);
- free (args.compound_req_array.compound_req_array_val);
+ length = args.compound_req_array.compound_req_array_len;
+ server_compound_req_cleanup(&args, length);
+ free(args.compound_req_array.compound_req_array_val);
- if (op_errno)
- SERVER_REQ_SET_ERROR (req, ret);
+ if (op_errno)
+ SERVER_REQ_SET_ERROR(req, ret);
- return ret;
+ return ret;
}
-
rpcsvc_actor_t glusterfs3_3_fop_actors[GLUSTER_FOP_PROCCNT] = {
- [GFS3_OP_NULL] = {"NULL", GFS3_OP_NULL, server_null, NULL, 0, DRC_NA},
- [GFS3_OP_STAT] = {"STAT", GFS3_OP_STAT, server3_3_stat, NULL, 0, DRC_NA},
- [GFS3_OP_READLINK] = {"READLINK", GFS3_OP_READLINK, server3_3_readlink, NULL, 0, DRC_NA},
- [GFS3_OP_MKNOD] = {"MKNOD", GFS3_OP_MKNOD, server3_3_mknod, NULL, 0, DRC_NA},
- [GFS3_OP_MKDIR] = {"MKDIR", GFS3_OP_MKDIR, server3_3_mkdir, NULL, 0, DRC_NA},
- [GFS3_OP_UNLINK] = {"UNLINK", GFS3_OP_UNLINK, server3_3_unlink, NULL, 0, DRC_NA},
- [GFS3_OP_RMDIR] = {"RMDIR", GFS3_OP_RMDIR, server3_3_rmdir, NULL, 0, DRC_NA},
- [GFS3_OP_SYMLINK] = {"SYMLINK", GFS3_OP_SYMLINK, server3_3_symlink, NULL, 0, DRC_NA},
- [GFS3_OP_RENAME] = {"RENAME", GFS3_OP_RENAME, server3_3_rename, NULL, 0, DRC_NA},
- [GFS3_OP_LINK] = {"LINK", GFS3_OP_LINK, server3_3_link, NULL, 0, DRC_NA},
- [GFS3_OP_TRUNCATE] = {"TRUNCATE", GFS3_OP_TRUNCATE, server3_3_truncate, NULL, 0, DRC_NA},
- [GFS3_OP_OPEN] = {"OPEN", GFS3_OP_OPEN, server3_3_open, NULL, 0, DRC_NA},
- [GFS3_OP_READ] = {"READ", GFS3_OP_READ, server3_3_readv, NULL, 0, DRC_NA},
- [GFS3_OP_WRITE] = {"WRITE", GFS3_OP_WRITE, server3_3_writev, server3_3_writev_vecsizer, 0, DRC_NA},
- [GFS3_OP_STATFS] = {"STATFS", GFS3_OP_STATFS, server3_3_statfs, NULL, 0, DRC_NA},
- [GFS3_OP_FLUSH] = {"FLUSH", GFS3_OP_FLUSH, server3_3_flush, NULL, 0, DRC_NA},
- [GFS3_OP_FSYNC] = {"FSYNC", GFS3_OP_FSYNC, server3_3_fsync, NULL, 0, DRC_NA},
- [GFS3_OP_SETXATTR] = {"SETXATTR", GFS3_OP_SETXATTR, server3_3_setxattr, NULL, 0, DRC_NA},
- [GFS3_OP_GETXATTR] = {"GETXATTR", GFS3_OP_GETXATTR, server3_3_getxattr, NULL, 0, DRC_NA},
- [GFS3_OP_REMOVEXATTR] = {"REMOVEXATTR", GFS3_OP_REMOVEXATTR, server3_3_removexattr, NULL, 0, DRC_NA},
- [GFS3_OP_OPENDIR] = {"OPENDIR", GFS3_OP_OPENDIR, server3_3_opendir, NULL, 0, DRC_NA},
- [GFS3_OP_FSYNCDIR] = {"FSYNCDIR", GFS3_OP_FSYNCDIR, server3_3_fsyncdir, NULL, 0, DRC_NA},
- [GFS3_OP_ACCESS] = {"ACCESS", GFS3_OP_ACCESS, server3_3_access, NULL, 0, DRC_NA},
- [GFS3_OP_CREATE] = {"CREATE", GFS3_OP_CREATE, server3_3_create, NULL, 0, DRC_NA},
- [GFS3_OP_FTRUNCATE] = {"FTRUNCATE", GFS3_OP_FTRUNCATE, server3_3_ftruncate, NULL, 0, DRC_NA},
- [GFS3_OP_FSTAT] = {"FSTAT", GFS3_OP_FSTAT, server3_3_fstat, NULL, 0, DRC_NA},
- [GFS3_OP_LK] = {"LK", GFS3_OP_LK, server3_3_lk, NULL, 0, DRC_NA},
- [GFS3_OP_LOOKUP] = {"LOOKUP", GFS3_OP_LOOKUP, server3_3_lookup, NULL, 0, DRC_NA},
- [GFS3_OP_READDIR] = {"READDIR", GFS3_OP_READDIR, server3_3_readdir, NULL, 0, DRC_NA},
- [GFS3_OP_INODELK] = {"INODELK", GFS3_OP_INODELK, server3_3_inodelk, NULL, 0, DRC_NA},
- [GFS3_OP_FINODELK] = {"FINODELK", GFS3_OP_FINODELK, server3_3_finodelk, NULL, 0, DRC_NA},
- [GFS3_OP_ENTRYLK] = {"ENTRYLK", GFS3_OP_ENTRYLK, server3_3_entrylk, NULL, 0, DRC_NA},
- [GFS3_OP_FENTRYLK] = {"FENTRYLK", GFS3_OP_FENTRYLK, server3_3_fentrylk, NULL, 0, DRC_NA},
- [GFS3_OP_XATTROP] = {"XATTROP", GFS3_OP_XATTROP, server3_3_xattrop, NULL, 0, DRC_NA},
- [GFS3_OP_FXATTROP] = {"FXATTROP", GFS3_OP_FXATTROP, server3_3_fxattrop, NULL, 0, DRC_NA},
- [GFS3_OP_FGETXATTR] = {"FGETXATTR", GFS3_OP_FGETXATTR, server3_3_fgetxattr, NULL, 0, DRC_NA},
- [GFS3_OP_FSETXATTR] = {"FSETXATTR", GFS3_OP_FSETXATTR, server3_3_fsetxattr, NULL, 0, DRC_NA},
- [GFS3_OP_RCHECKSUM] = {"RCHECKSUM", GFS3_OP_RCHECKSUM, server3_3_rchecksum, NULL, 0, DRC_NA},
- [GFS3_OP_SETATTR] = {"SETATTR", GFS3_OP_SETATTR, server3_3_setattr, NULL, 0, DRC_NA},
- [GFS3_OP_FSETATTR] = {"FSETATTR", GFS3_OP_FSETATTR, server3_3_fsetattr, NULL, 0, DRC_NA},
- [GFS3_OP_READDIRP] = {"READDIRP", GFS3_OP_READDIRP, server3_3_readdirp, NULL, 0, DRC_NA},
- [GFS3_OP_RELEASE] = {"RELEASE", GFS3_OP_RELEASE, server3_3_release, NULL, 0, DRC_NA},
- [GFS3_OP_RELEASEDIR] = {"RELEASEDIR", GFS3_OP_RELEASEDIR, server3_3_releasedir, NULL, 0, DRC_NA},
- [GFS3_OP_FREMOVEXATTR] = {"FREMOVEXATTR", GFS3_OP_FREMOVEXATTR, server3_3_fremovexattr, NULL, 0, DRC_NA},
- [GFS3_OP_FALLOCATE] = {"FALLOCATE", GFS3_OP_FALLOCATE, server3_3_fallocate, NULL, 0, DRC_NA},
- [GFS3_OP_DISCARD] = {"DISCARD", GFS3_OP_DISCARD, server3_3_discard, NULL, 0, DRC_NA},
- [GFS3_OP_ZEROFILL] = {"ZEROFILL", GFS3_OP_ZEROFILL, server3_3_zerofill, NULL, 0, DRC_NA},
- [GFS3_OP_IPC] = {"IPC", GFS3_OP_IPC, server3_3_ipc, NULL, 0, DRC_NA},
- [GFS3_OP_SEEK] = {"SEEK", GFS3_OP_SEEK, server3_3_seek, NULL, 0, DRC_NA},
- [GFS3_OP_LEASE] = {"LEASE", GFS3_OP_LEASE, server3_3_lease, NULL, 0, DRC_NA},
- [GFS3_OP_GETACTIVELK] = {"GETACTIVELK", GFS3_OP_GETACTIVELK, server3_3_getactivelk, NULL, 0, DRC_NA},
- [GFS3_OP_SETACTIVELK] = {"SETACTIVELK", GFS3_OP_SETACTIVELK, server3_3_setactivelk, NULL, 0, DRC_NA},
- [GFS3_OP_COMPOUND] = {"COMPOUND", GFS3_OP_COMPOUND, server3_3_compound, NULL, 0, DRC_NA},
+ [GFS3_OP_NULL] = {"NULL", GFS3_OP_NULL, server_null, NULL, 0, DRC_NA},
+ [GFS3_OP_STAT] = {"STAT", GFS3_OP_STAT, server3_3_stat, NULL, 0, DRC_NA},
+ [GFS3_OP_READLINK] = {"READLINK", GFS3_OP_READLINK, server3_3_readlink,
+ NULL, 0, DRC_NA},
+ [GFS3_OP_MKNOD] = {"MKNOD", GFS3_OP_MKNOD, server3_3_mknod, NULL, 0,
+ DRC_NA},
+ [GFS3_OP_MKDIR] = {"MKDIR", GFS3_OP_MKDIR, server3_3_mkdir, NULL, 0,
+ DRC_NA},
+ [GFS3_OP_UNLINK] = {"UNLINK", GFS3_OP_UNLINK, server3_3_unlink, NULL, 0,
+ DRC_NA},
+ [GFS3_OP_RMDIR] = {"RMDIR", GFS3_OP_RMDIR, server3_3_rmdir, NULL, 0,
+ DRC_NA},
+ [GFS3_OP_SYMLINK] = {"SYMLINK", GFS3_OP_SYMLINK, server3_3_symlink, NULL, 0,
+ DRC_NA},
+ [GFS3_OP_RENAME] = {"RENAME", GFS3_OP_RENAME, server3_3_rename, NULL, 0,
+ DRC_NA},
+ [GFS3_OP_LINK] = {"LINK", GFS3_OP_LINK, server3_3_link, NULL, 0, DRC_NA},
+ [GFS3_OP_TRUNCATE] = {"TRUNCATE", GFS3_OP_TRUNCATE, server3_3_truncate,
+ NULL, 0, DRC_NA},
+ [GFS3_OP_OPEN] = {"OPEN", GFS3_OP_OPEN, server3_3_open, NULL, 0, DRC_NA},
+ [GFS3_OP_READ] = {"READ", GFS3_OP_READ, server3_3_readv, NULL, 0, DRC_NA},
+ [GFS3_OP_WRITE] = {"WRITE", GFS3_OP_WRITE, server3_3_writev,
+ server3_3_writev_vecsizer, 0, DRC_NA},
+ [GFS3_OP_STATFS] = {"STATFS", GFS3_OP_STATFS, server3_3_statfs, NULL, 0,
+ DRC_NA},
+ [GFS3_OP_FLUSH] = {"FLUSH", GFS3_OP_FLUSH, server3_3_flush, NULL, 0,
+ DRC_NA},
+ [GFS3_OP_FSYNC] = {"FSYNC", GFS3_OP_FSYNC, server3_3_fsync, NULL, 0,
+ DRC_NA},
+ [GFS3_OP_SETXATTR] = {"SETXATTR", GFS3_OP_SETXATTR, server3_3_setxattr,
+ NULL, 0, DRC_NA},
+ [GFS3_OP_GETXATTR] = {"GETXATTR", GFS3_OP_GETXATTR, server3_3_getxattr,
+ NULL, 0, DRC_NA},
+ [GFS3_OP_REMOVEXATTR] = {"REMOVEXATTR", GFS3_OP_REMOVEXATTR,
+ server3_3_removexattr, NULL, 0, DRC_NA},
+ [GFS3_OP_OPENDIR] = {"OPENDIR", GFS3_OP_OPENDIR, server3_3_opendir, NULL, 0,
+ DRC_NA},
+ [GFS3_OP_FSYNCDIR] = {"FSYNCDIR", GFS3_OP_FSYNCDIR, server3_3_fsyncdir,
+ NULL, 0, DRC_NA},
+ [GFS3_OP_ACCESS] = {"ACCESS", GFS3_OP_ACCESS, server3_3_access, NULL, 0,
+ DRC_NA},
+ [GFS3_OP_CREATE] = {"CREATE", GFS3_OP_CREATE, server3_3_create, NULL, 0,
+ DRC_NA},
+ [GFS3_OP_FTRUNCATE] = {"FTRUNCATE", GFS3_OP_FTRUNCATE, server3_3_ftruncate,
+ NULL, 0, DRC_NA},
+ [GFS3_OP_FSTAT] = {"FSTAT", GFS3_OP_FSTAT, server3_3_fstat, NULL, 0,
+ DRC_NA},
+ [GFS3_OP_LK] = {"LK", GFS3_OP_LK, server3_3_lk, NULL, 0, DRC_NA},
+ [GFS3_OP_LOOKUP] = {"LOOKUP", GFS3_OP_LOOKUP, server3_3_lookup, NULL, 0,
+ DRC_NA},
+ [GFS3_OP_READDIR] = {"READDIR", GFS3_OP_READDIR, server3_3_readdir, NULL, 0,
+ DRC_NA},
+ [GFS3_OP_INODELK] = {"INODELK", GFS3_OP_INODELK, server3_3_inodelk, NULL, 0,
+ DRC_NA},
+ [GFS3_OP_FINODELK] = {"FINODELK", GFS3_OP_FINODELK, server3_3_finodelk,
+ NULL, 0, DRC_NA},
+ [GFS3_OP_ENTRYLK] = {"ENTRYLK", GFS3_OP_ENTRYLK, server3_3_entrylk, NULL, 0,
+ DRC_NA},
+ [GFS3_OP_FENTRYLK] = {"FENTRYLK", GFS3_OP_FENTRYLK, server3_3_fentrylk,
+ NULL, 0, DRC_NA},
+ [GFS3_OP_XATTROP] = {"XATTROP", GFS3_OP_XATTROP, server3_3_xattrop, NULL, 0,
+ DRC_NA},
+ [GFS3_OP_FXATTROP] = {"FXATTROP", GFS3_OP_FXATTROP, server3_3_fxattrop,
+ NULL, 0, DRC_NA},
+ [GFS3_OP_FGETXATTR] = {"FGETXATTR", GFS3_OP_FGETXATTR, server3_3_fgetxattr,
+ NULL, 0, DRC_NA},
+ [GFS3_OP_FSETXATTR] = {"FSETXATTR", GFS3_OP_FSETXATTR, server3_3_fsetxattr,
+ NULL, 0, DRC_NA},
+ [GFS3_OP_RCHECKSUM] = {"RCHECKSUM", GFS3_OP_RCHECKSUM, server3_3_rchecksum,
+ NULL, 0, DRC_NA},
+ [GFS3_OP_SETATTR] = {"SETATTR", GFS3_OP_SETATTR, server3_3_setattr, NULL, 0,
+ DRC_NA},
+ [GFS3_OP_FSETATTR] = {"FSETATTR", GFS3_OP_FSETATTR, server3_3_fsetattr,
+ NULL, 0, DRC_NA},
+ [GFS3_OP_READDIRP] = {"READDIRP", GFS3_OP_READDIRP, server3_3_readdirp,
+ NULL, 0, DRC_NA},
+ [GFS3_OP_RELEASE] = {"RELEASE", GFS3_OP_RELEASE, server3_3_release, NULL, 0,
+ DRC_NA},
+ [GFS3_OP_RELEASEDIR] = {"RELEASEDIR", GFS3_OP_RELEASEDIR,
+ server3_3_releasedir, NULL, 0, DRC_NA},
+ [GFS3_OP_FREMOVEXATTR] = {"FREMOVEXATTR", GFS3_OP_FREMOVEXATTR,
+ server3_3_fremovexattr, NULL, 0, DRC_NA},
+ [GFS3_OP_FALLOCATE] = {"FALLOCATE", GFS3_OP_FALLOCATE, server3_3_fallocate,
+ NULL, 0, DRC_NA},
+ [GFS3_OP_DISCARD] = {"DISCARD", GFS3_OP_DISCARD, server3_3_discard, NULL, 0,
+ DRC_NA},
+ [GFS3_OP_ZEROFILL] = {"ZEROFILL", GFS3_OP_ZEROFILL, server3_3_zerofill,
+ NULL, 0, DRC_NA},
+ [GFS3_OP_IPC] = {"IPC", GFS3_OP_IPC, server3_3_ipc, NULL, 0, DRC_NA},
+ [GFS3_OP_SEEK] = {"SEEK", GFS3_OP_SEEK, server3_3_seek, NULL, 0, DRC_NA},
+ [GFS3_OP_LEASE] = {"LEASE", GFS3_OP_LEASE, server3_3_lease, NULL, 0,
+ DRC_NA},
+ [GFS3_OP_GETACTIVELK] = {"GETACTIVELK", GFS3_OP_GETACTIVELK,
+ server3_3_getactivelk, NULL, 0, DRC_NA},
+ [GFS3_OP_SETACTIVELK] = {"SETACTIVELK", GFS3_OP_SETACTIVELK,
+ server3_3_setactivelk, NULL, 0, DRC_NA},
+ [GFS3_OP_COMPOUND] = {"COMPOUND", GFS3_OP_COMPOUND, server3_3_compound,
+ NULL, 0, DRC_NA},
};
-
struct rpcsvc_program glusterfs3_3_fop_prog = {
- .progname = "GlusterFS 3.3",
- .prognum = GLUSTER_FOP_PROGRAM,
- .progver = GLUSTER_FOP_VERSION,
- .numactors = GLUSTER_FOP_PROCCNT,
- .actors = glusterfs3_3_fop_actors,
- .ownthread = _gf_true,
+ .progname = "GlusterFS 3.3",
+ .prognum = GLUSTER_FOP_PROGRAM,
+ .progver = GLUSTER_FOP_VERSION,
+ .numactors = GLUSTER_FOP_PROCCNT,
+ .actors = glusterfs3_3_fop_actors,
+ .ownthread = _gf_true,
};
diff --git a/xlators/protocol/server/src/server-rpc-fops_v2.c b/xlators/protocol/server/src/server-rpc-fops_v2.c
index 92abaa1b5d1..21df9021c66 100644
--- a/xlators/protocol/server/src/server-rpc-fops_v2.c
+++ b/xlators/protocol/server/src/server-rpc-fops_v2.c
@@ -25,6012 +25,6178 @@
#include "xdr-nfs3.h"
-#define SERVER_REQ_SET_ERROR(req, ret) \
- do { \
- rpcsvc_request_seterr (req, GARBAGE_ARGS); \
- ret = RPCSVC_ACTOR_ERROR; \
- } while (0)
+#define SERVER_REQ_SET_ERROR(req, ret) \
+ do { \
+ rpcsvc_request_seterr(req, GARBAGE_ARGS); \
+ ret = RPCSVC_ACTOR_ERROR; \
+ } while (0)
extern int
-server3_3_getxattr (rpcsvc_request_t *req);
+server3_3_getxattr(rpcsvc_request_t *req);
extern void
-set_resolve_gfid (client_t *client, uuid_t resolve_gfid,
- char *on_wire_gfid);
+set_resolve_gfid(client_t *client, uuid_t resolve_gfid, char *on_wire_gfid);
extern int
-_gf_server_log_setxattr_failure (dict_t *d, char *k, data_t *v,
- void *tmp);
+_gf_server_log_setxattr_failure(dict_t *d, char *k, data_t *v, void *tmp);
extern int
-rpc_receive_common (rpcsvc_request_t *req, call_frame_t **fr,
- server_state_t **st, ssize_t *xdrlen, void *args,
- void *xdrfn, glusterfs_fop_t fop);
-
+rpc_receive_common(rpcsvc_request_t *req, call_frame_t **fr,
+ server_state_t **st, ssize_t *xdrlen, void *args,
+ void *xdrfn, glusterfs_fop_t fop);
/* Callback function section */
int
-server4_statfs_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
+server4_statfs_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
int32_t op_ret, int32_t op_errno, struct statvfs *buf,
dict_t *xdata)
{
- gfx_statfs_rsp rsp = {0,};
- rpcsvc_request_t *req = NULL;
+ gfx_statfs_rsp rsp = {
+ 0,
+ };
+ rpcsvc_request_t *req = NULL;
- dict_to_xdr (xdata, &rsp.xdata);
+ dict_to_xdr(xdata, &rsp.xdata);
- if (op_ret < 0) {
- gf_msg (this->name, GF_LOG_WARNING, op_errno, PS_MSG_STATFS,
- "%"PRId64": STATFS, client: %s, error-xlator: %s",
- frame->root->unique, STACK_CLIENT_NAME (frame->root),
- STACK_ERR_XL_NAME (frame->root));
- goto out;
- }
+ if (op_ret < 0) {
+ gf_msg(this->name, GF_LOG_WARNING, op_errno, PS_MSG_STATFS,
+ "%" PRId64 ": STATFS, client: %s, error-xlator: %s",
+ frame->root->unique, STACK_CLIENT_NAME(frame->root),
+ STACK_ERR_XL_NAME(frame->root));
+ goto out;
+ }
- server4_post_statfs (&rsp, buf);
+ server4_post_statfs(&rsp, buf);
out:
- rsp.op_ret = op_ret;
- rsp.op_errno = gf_errno_to_error (op_errno);
-
- req = frame->local;
- server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
- (xdrproc_t)xdr_gfx_statfs_rsp);
-
- GF_FREE (rsp.xdata.pairs.pairs_val);
-
- return 0;
-}
-
-int
-server4_lookup_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
- int32_t op_ret, int32_t op_errno,
- inode_t *inode, struct iatt *stbuf, dict_t *xdata,
- struct iatt *postparent)
-{
- rpcsvc_request_t *req = NULL;
- server_state_t *state = NULL;
- loc_t fresh_loc = {0,};
- gfx_common_2iatt_rsp rsp = {0,};
-
- state = CALL_STATE (frame);
-
- if (state->is_revalidate == 1 && op_ret == -1) {
- state->is_revalidate = 2;
- loc_copy (&fresh_loc, &state->loc);
- inode_unref (fresh_loc.inode);
- fresh_loc.inode = server_inode_new (state->itable,
- fresh_loc.gfid);
-
- STACK_WIND (frame, server4_lookup_cbk,
- frame->root->client->bound_xl,
- frame->root->client->bound_xl->fops->lookup,
- &fresh_loc, state->xdata);
-
- loc_wipe (&fresh_loc);
- return 0;
- }
-
- gfx_stat_from_iattx (&rsp.poststat, postparent);
-
- dict_to_xdr (xdata, &rsp.xdata);
-
- if (op_ret) {
- if (state->is_revalidate && op_errno == ENOENT) {
- if (!__is_root_gfid (state->resolve.gfid)) {
- inode_unlink (state->loc.inode,
- state->loc.parent,
- state->loc.name);
- /**
- * If the entry is not present, then just
- * unlinking the associated dentry is not
- * suffecient. This condition should be
- * treated as unlink of the entry. So along
- * with deleting the entry, its also important
- * to forget the inode for it (if the dentry
- * being considered was the last dentry).
- * Otherwise it might lead to inode leak.
- * It also might lead to wrong decisions being
- * taken if the future lookups on this inode are
- * successful since they are able to find the
- * inode in the inode table (at least gfid based
- * lookups will be successful, if the lookup
- * is a soft lookup)
- */
- forget_inode_if_no_dentry (state->loc.inode);
- }
- }
- goto out;
- }
-
- server4_post_lookup (&rsp, frame, state, inode, stbuf);
+ rsp.op_ret = op_ret;
+ rsp.op_errno = gf_errno_to_error(op_errno);
+
+ req = frame->local;
+ server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gfx_statfs_rsp);
+
+ GF_FREE(rsp.xdata.pairs.pairs_val);
+
+ return 0;
+}
+
+int
+server4_lookup_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+ int32_t op_ret, int32_t op_errno, inode_t *inode,
+ struct iatt *stbuf, dict_t *xdata, struct iatt *postparent)
+{
+ rpcsvc_request_t *req = NULL;
+ server_state_t *state = NULL;
+ loc_t fresh_loc = {
+ 0,
+ };
+ gfx_common_2iatt_rsp rsp = {
+ 0,
+ };
+
+ state = CALL_STATE(frame);
+
+ if (state->is_revalidate == 1 && op_ret == -1) {
+ state->is_revalidate = 2;
+ loc_copy(&fresh_loc, &state->loc);
+ inode_unref(fresh_loc.inode);
+ fresh_loc.inode = server_inode_new(state->itable, fresh_loc.gfid);
+
+ STACK_WIND(frame, server4_lookup_cbk, frame->root->client->bound_xl,
+ frame->root->client->bound_xl->fops->lookup, &fresh_loc,
+ state->xdata);
+
+ loc_wipe(&fresh_loc);
+ return 0;
+ }
+
+ gfx_stat_from_iattx(&rsp.poststat, postparent);
+
+ dict_to_xdr(xdata, &rsp.xdata);
+
+ if (op_ret) {
+ if (state->is_revalidate && op_errno == ENOENT) {
+ if (!__is_root_gfid(state->resolve.gfid)) {
+ inode_unlink(state->loc.inode, state->loc.parent,
+ state->loc.name);
+ /**
+ * If the entry is not present, then just
+ * unlinking the associated dentry is not
+ * suffecient. This condition should be
+ * treated as unlink of the entry. So along
+ * with deleting the entry, its also important
+ * to forget the inode for it (if the dentry
+ * being considered was the last dentry).
+ * Otherwise it might lead to inode leak.
+ * It also might lead to wrong decisions being
+ * taken if the future lookups on this inode are
+ * successful since they are able to find the
+ * inode in the inode table (at least gfid based
+ * lookups will be successful, if the lookup
+ * is a soft lookup)
+ */
+ forget_inode_if_no_dentry(state->loc.inode);
+ }
+ }
+ goto out;
+ }
+
+ server4_post_lookup(&rsp, frame, state, inode, stbuf);
out:
- rsp.op_ret = op_ret;
- rsp.op_errno = gf_errno_to_error (op_errno);
-
- if (op_ret) {
- if (state->resolve.bname) {
- gf_msg (this->name,
- fop_log_level (GF_FOP_LOOKUP, op_errno),
- op_errno, PS_MSG_LOOKUP_INFO,
- "%"PRId64": LOOKUP %s (%s/%s), client: %s, "
- "error-xlator: %s", frame->root->unique,
- state->loc.path,
- uuid_utoa (state->resolve.pargfid),
- state->resolve.bname,
- STACK_CLIENT_NAME (frame->root),
- STACK_ERR_XL_NAME (frame->root));
- } else {
- gf_msg (this->name,
- fop_log_level (GF_FOP_LOOKUP, op_errno),
- op_errno, PS_MSG_LOOKUP_INFO,
- "%"PRId64": LOOKUP %s (%s), client: %s, "
- "error-xlator: %s",
- frame->root->unique, state->loc.path,
- uuid_utoa (state->resolve.gfid),
- STACK_CLIENT_NAME (frame->root),
- STACK_ERR_XL_NAME (frame->root));
- }
+ rsp.op_ret = op_ret;
+ rsp.op_errno = gf_errno_to_error(op_errno);
+
+ if (op_ret) {
+ if (state->resolve.bname) {
+ gf_msg(this->name, fop_log_level(GF_FOP_LOOKUP, op_errno), op_errno,
+ PS_MSG_LOOKUP_INFO,
+ "%" PRId64
+ ": LOOKUP %s (%s/%s), client: %s, "
+ "error-xlator: %s",
+ frame->root->unique, state->loc.path,
+ uuid_utoa(state->resolve.pargfid), state->resolve.bname,
+ STACK_CLIENT_NAME(frame->root),
+ STACK_ERR_XL_NAME(frame->root));
+ } else {
+ gf_msg(this->name, fop_log_level(GF_FOP_LOOKUP, op_errno), op_errno,
+ PS_MSG_LOOKUP_INFO,
+ "%" PRId64
+ ": LOOKUP %s (%s), client: %s, "
+ "error-xlator: %s",
+ frame->root->unique, state->loc.path,
+ uuid_utoa(state->resolve.gfid),
+ STACK_CLIENT_NAME(frame->root),
+ STACK_ERR_XL_NAME(frame->root));
}
+ }
- req = frame->local;
- server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
- (xdrproc_t)xdr_gfx_common_2iatt_rsp);
+ req = frame->local;
+ server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gfx_common_2iatt_rsp);
- GF_FREE (rsp.xdata.pairs.pairs_val);
+ GF_FREE(rsp.xdata.pairs.pairs_val);
- return 0;
+ return 0;
}
int
-server4_lease_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
+server4_lease_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
int32_t op_ret, int32_t op_errno, struct gf_lease *lease,
dict_t *xdata)
{
- gfx_lease_rsp rsp = {0,};
- rpcsvc_request_t *req = NULL;
- server_state_t *state = NULL;
+ gfx_lease_rsp rsp = {
+ 0,
+ };
+ rpcsvc_request_t *req = NULL;
+ server_state_t *state = NULL;
- dict_to_xdr (xdata, &rsp.xdata);
+ dict_to_xdr(xdata, &rsp.xdata);
- if (op_ret) {
- state = CALL_STATE (frame);
- gf_msg (this->name, fop_log_level (GF_FOP_LEASE, op_errno),
- op_errno, PS_MSG_LK_INFO,
- "%"PRId64": LEASE %s (%s), client: %s, error-xlator: %s",
- frame->root->unique, state->loc.path,
- uuid_utoa (state->resolve.gfid),
- STACK_CLIENT_NAME (frame->root),
- STACK_ERR_XL_NAME (frame->root));
- }
- server4_post_lease (&rsp, lease);
+ if (op_ret) {
+ state = CALL_STATE(frame);
+ gf_msg(this->name, fop_log_level(GF_FOP_LEASE, op_errno), op_errno,
+ PS_MSG_LK_INFO,
+ "%" PRId64 ": LEASE %s (%s), client: %s, error-xlator: %s",
+ frame->root->unique, state->loc.path,
+ uuid_utoa(state->resolve.gfid), STACK_CLIENT_NAME(frame->root),
+ STACK_ERR_XL_NAME(frame->root));
+ }
+ server4_post_lease(&rsp, lease);
- rsp.op_ret = op_ret;
- rsp.op_errno = gf_errno_to_error (op_errno);
+ rsp.op_ret = op_ret;
+ rsp.op_errno = gf_errno_to_error(op_errno);
- req = frame->local;
- server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
- (xdrproc_t)xdr_gfx_lease_rsp);
+ req = frame->local;
+ server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gfx_lease_rsp);
- GF_FREE (rsp.xdata.pairs.pairs_val);
+ GF_FREE(rsp.xdata.pairs.pairs_val);
- return 0;
+ return 0;
}
int
-server4_lk_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
+server4_lk_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
int32_t op_ret, int32_t op_errno, struct gf_flock *lock,
dict_t *xdata)
{
- gfx_lk_rsp rsp = {0,};
- rpcsvc_request_t *req = NULL;
- server_state_t *state = NULL;
-
- dict_to_xdr (xdata, &rsp.xdata);
-
- if (op_ret) {
- state = CALL_STATE (frame);
- gf_msg (this->name, fop_log_level (GF_FOP_LK, op_errno),
- op_errno, PS_MSG_LK_INFO,
- "%"PRId64": LK %"PRId64" (%s), client: %s, "
- "error-xlator: %s", frame->root->unique,
- state->resolve.fd_no, uuid_utoa (state->resolve.gfid),
- STACK_CLIENT_NAME (frame->root),
- STACK_ERR_XL_NAME (frame->root));
- goto out;
- }
-
- server4_post_lk (this, &rsp, lock);
+ gfx_lk_rsp rsp = {
+ 0,
+ };
+ rpcsvc_request_t *req = NULL;
+ server_state_t *state = NULL;
+
+ dict_to_xdr(xdata, &rsp.xdata);
+
+ if (op_ret) {
+ state = CALL_STATE(frame);
+ gf_msg(this->name, fop_log_level(GF_FOP_LK, op_errno), op_errno,
+ PS_MSG_LK_INFO,
+ "%" PRId64 ": LK %" PRId64
+ " (%s), client: %s, "
+ "error-xlator: %s",
+ frame->root->unique, state->resolve.fd_no,
+ uuid_utoa(state->resolve.gfid), STACK_CLIENT_NAME(frame->root),
+ STACK_ERR_XL_NAME(frame->root));
+ goto out;
+ }
+
+ server4_post_lk(this, &rsp, lock);
out:
- rsp.op_ret = op_ret;
- rsp.op_errno = gf_errno_to_error (op_errno);
+ rsp.op_ret = op_ret;
+ rsp.op_errno = gf_errno_to_error(op_errno);
- req = frame->local;
- server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
- (xdrproc_t)xdr_gfx_lk_rsp);
+ req = frame->local;
+ server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gfx_lk_rsp);
- GF_FREE (rsp.xdata.pairs.pairs_val);
+ GF_FREE(rsp.xdata.pairs.pairs_val);
- return 0;
+ return 0;
}
-
int
-server4_inodelk_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
+server4_inodelk_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
int32_t op_ret, int32_t op_errno, dict_t *xdata)
{
- gfx_common_rsp rsp = {0,};
- server_state_t *state = NULL;
- rpcsvc_request_t *req = NULL;
+ gfx_common_rsp rsp = {
+ 0,
+ };
+ server_state_t *state = NULL;
+ rpcsvc_request_t *req = NULL;
- dict_to_xdr (xdata, &rsp.xdata);
+ dict_to_xdr(xdata, &rsp.xdata);
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (op_ret < 0) {
- gf_msg (this->name, fop_log_level (GF_FOP_INODELK, op_errno),
- op_errno, PS_MSG_INODELK_INFO,
- "%"PRId64": INODELK %s (%s), client: %s, "
- "error-xlator: %s", frame->root->unique,
- state->loc.path, uuid_utoa (state->resolve.gfid),
- STACK_CLIENT_NAME (frame->root),
- STACK_ERR_XL_NAME (frame->root));
- goto out;
- }
+ if (op_ret < 0) {
+ gf_msg(this->name, fop_log_level(GF_FOP_INODELK, op_errno), op_errno,
+ PS_MSG_INODELK_INFO,
+ "%" PRId64
+ ": INODELK %s (%s), client: %s, "
+ "error-xlator: %s",
+ frame->root->unique, state->loc.path,
+ uuid_utoa(state->resolve.gfid), STACK_CLIENT_NAME(frame->root),
+ STACK_ERR_XL_NAME(frame->root));
+ goto out;
+ }
out:
- rsp.op_ret = op_ret;
- rsp.op_errno = gf_errno_to_error (op_errno);
+ rsp.op_ret = op_ret;
+ rsp.op_errno = gf_errno_to_error(op_errno);
- req = frame->local;
- server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
- (xdrproc_t)xdr_gfx_common_rsp);
+ req = frame->local;
+ server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gfx_common_rsp);
- GF_FREE (rsp.xdata.pairs.pairs_val);
+ GF_FREE(rsp.xdata.pairs.pairs_val);
- return 0;
+ return 0;
}
-
int
-server4_finodelk_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
+server4_finodelk_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
int32_t op_ret, int32_t op_errno, dict_t *xdata)
{
- gfx_common_rsp rsp = {0,};
- server_state_t *state = NULL;
- rpcsvc_request_t *req = NULL;
+ gfx_common_rsp rsp = {
+ 0,
+ };
+ server_state_t *state = NULL;
+ rpcsvc_request_t *req = NULL;
- dict_to_xdr (xdata, &rsp.xdata);
+ dict_to_xdr(xdata, &rsp.xdata);
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (op_ret < 0) {
- gf_msg (this->name, fop_log_level (GF_FOP_FINODELK, op_errno),
- op_errno, PS_MSG_INODELK_INFO,
- "%"PRId64": FINODELK %"PRId64" (%s), client: %s, "
- "error-xlator: %s", frame->root->unique,
- state->resolve.fd_no, uuid_utoa (state->resolve.gfid),
- STACK_CLIENT_NAME (frame->root),
- STACK_ERR_XL_NAME (frame->root));
- goto out;
- }
+ if (op_ret < 0) {
+ gf_msg(this->name, fop_log_level(GF_FOP_FINODELK, op_errno), op_errno,
+ PS_MSG_INODELK_INFO,
+ "%" PRId64 ": FINODELK %" PRId64
+ " (%s), client: %s, "
+ "error-xlator: %s",
+ frame->root->unique, state->resolve.fd_no,
+ uuid_utoa(state->resolve.gfid), STACK_CLIENT_NAME(frame->root),
+ STACK_ERR_XL_NAME(frame->root));
+ goto out;
+ }
out:
- rsp.op_ret = op_ret;
- rsp.op_errno = gf_errno_to_error (op_errno);
+ rsp.op_ret = op_ret;
+ rsp.op_errno = gf_errno_to_error(op_errno);
- req = frame->local;
- server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
- (xdrproc_t)xdr_gfx_common_rsp);
+ req = frame->local;
+ server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gfx_common_rsp);
- GF_FREE (rsp.xdata.pairs.pairs_val);
+ GF_FREE(rsp.xdata.pairs.pairs_val);
- return 0;
+ return 0;
}
int
-server4_entrylk_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
+server4_entrylk_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
int32_t op_ret, int32_t op_errno, dict_t *xdata)
{
- gfx_common_rsp rsp = {0,};
- server_state_t *state = NULL;
- rpcsvc_request_t *req = NULL;
+ gfx_common_rsp rsp = {
+ 0,
+ };
+ server_state_t *state = NULL;
+ rpcsvc_request_t *req = NULL;
- dict_to_xdr (xdata, &rsp.xdata);
+ dict_to_xdr(xdata, &rsp.xdata);
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (op_ret < 0) {
- gf_msg (this->name, fop_log_level (GF_FOP_ENTRYLK, op_errno),
- op_errno, PS_MSG_ENTRYLK_INFO,
- "%"PRId64": ENTRYLK %s (%s), client: %s, "
- "error-xlator: %s", frame->root->unique,
- state->loc.path, uuid_utoa (state->resolve.gfid),
- STACK_CLIENT_NAME (frame->root),
- STACK_ERR_XL_NAME (frame->root));
- goto out;
- }
+ if (op_ret < 0) {
+ gf_msg(this->name, fop_log_level(GF_FOP_ENTRYLK, op_errno), op_errno,
+ PS_MSG_ENTRYLK_INFO,
+ "%" PRId64
+ ": ENTRYLK %s (%s), client: %s, "
+ "error-xlator: %s",
+ frame->root->unique, state->loc.path,
+ uuid_utoa(state->resolve.gfid), STACK_CLIENT_NAME(frame->root),
+ STACK_ERR_XL_NAME(frame->root));
+ goto out;
+ }
out:
- rsp.op_ret = op_ret;
- rsp.op_errno = gf_errno_to_error (op_errno);
+ rsp.op_ret = op_ret;
+ rsp.op_errno = gf_errno_to_error(op_errno);
- req = frame->local;
- server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
- (xdrproc_t)xdr_gfx_common_rsp);
+ req = frame->local;
+ server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gfx_common_rsp);
- GF_FREE (rsp.xdata.pairs.pairs_val);
+ GF_FREE(rsp.xdata.pairs.pairs_val);
- return 0;
+ return 0;
}
-
int
-server4_fentrylk_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
+server4_fentrylk_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
int32_t op_ret, int32_t op_errno, dict_t *xdata)
{
- gfx_common_rsp rsp = {0,};
- server_state_t *state = NULL;
- rpcsvc_request_t *req = NULL;
+ gfx_common_rsp rsp = {
+ 0,
+ };
+ server_state_t *state = NULL;
+ rpcsvc_request_t *req = NULL;
- dict_to_xdr (xdata, &rsp.xdata);
+ dict_to_xdr(xdata, &rsp.xdata);
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (op_ret < 0) {
- gf_msg (this->name, fop_log_level (GF_FOP_FENTRYLK, op_errno),
- op_errno, PS_MSG_ENTRYLK_INFO,
- "%"PRId64": FENTRYLK %"PRId64" (%s), client: %s, "
- "error-xlator: %s", frame->root->unique,
- state->resolve.fd_no, uuid_utoa (state->resolve.gfid),
- STACK_CLIENT_NAME (frame->root),
- STACK_ERR_XL_NAME (frame->root));
- goto out;
- }
+ if (op_ret < 0) {
+ gf_msg(this->name, fop_log_level(GF_FOP_FENTRYLK, op_errno), op_errno,
+ PS_MSG_ENTRYLK_INFO,
+ "%" PRId64 ": FENTRYLK %" PRId64
+ " (%s), client: %s, "
+ "error-xlator: %s",
+ frame->root->unique, state->resolve.fd_no,
+ uuid_utoa(state->resolve.gfid), STACK_CLIENT_NAME(frame->root),
+ STACK_ERR_XL_NAME(frame->root));
+ goto out;
+ }
out:
- rsp.op_ret = op_ret;
- rsp.op_errno = gf_errno_to_error (op_errno);
+ rsp.op_ret = op_ret;
+ rsp.op_errno = gf_errno_to_error(op_errno);
- req = frame->local;
- server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
- (xdrproc_t)xdr_gfx_common_rsp);
+ req = frame->local;
+ server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gfx_common_rsp);
- GF_FREE (rsp.xdata.pairs.pairs_val);
+ GF_FREE(rsp.xdata.pairs.pairs_val);
- return 0;
+ return 0;
}
-
int
-server4_access_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
+server4_access_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
int32_t op_ret, int32_t op_errno, dict_t *xdata)
{
- gfx_common_rsp rsp = {0,};
- rpcsvc_request_t *req = NULL;
- server_state_t *state = NULL;
-
- dict_to_xdr (xdata, &rsp.xdata);
-
- if (op_ret) {
- state = CALL_STATE (frame);
- gf_msg (this->name, GF_LOG_INFO,
- op_errno, PS_MSG_ACCESS_INFO,
- "%"PRId64": ACCESS %s (%s), client: %s, "
- "error-xlator: %s", frame->root->unique,
- (state->loc.path) ? state->loc.path : "",
- uuid_utoa (state->resolve.gfid),
- STACK_CLIENT_NAME (frame->root),
- STACK_ERR_XL_NAME (frame->root));
- goto out;
- }
+ gfx_common_rsp rsp = {
+ 0,
+ };
+ rpcsvc_request_t *req = NULL;
+ server_state_t *state = NULL;
+
+ dict_to_xdr(xdata, &rsp.xdata);
+
+ if (op_ret) {
+ state = CALL_STATE(frame);
+ gf_msg(this->name, GF_LOG_INFO, op_errno, PS_MSG_ACCESS_INFO,
+ "%" PRId64
+ ": ACCESS %s (%s), client: %s, "
+ "error-xlator: %s",
+ frame->root->unique, (state->loc.path) ? state->loc.path : "",
+ uuid_utoa(state->resolve.gfid), STACK_CLIENT_NAME(frame->root),
+ STACK_ERR_XL_NAME(frame->root));
+ goto out;
+ }
out:
- rsp.op_ret = op_ret;
- rsp.op_errno = gf_errno_to_error (op_errno);
+ rsp.op_ret = op_ret;
+ rsp.op_errno = gf_errno_to_error(op_errno);
- req = frame->local;
- server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
- (xdrproc_t)xdr_gfx_common_rsp);
+ req = frame->local;
+ server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gfx_common_rsp);
- GF_FREE (rsp.xdata.pairs.pairs_val);
+ GF_FREE(rsp.xdata.pairs.pairs_val);
- return 0;
+ return 0;
}
int
-server4_rmdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
+server4_rmdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
int32_t op_ret, int32_t op_errno, struct iatt *preparent,
struct iatt *postparent, dict_t *xdata)
{
- gfx_common_2iatt_rsp rsp = {0,};
- server_state_t *state = NULL;
- rpcsvc_request_t *req = NULL;
+ gfx_common_2iatt_rsp rsp = {
+ 0,
+ };
+ server_state_t *state = NULL;
+ rpcsvc_request_t *req = NULL;
- dict_to_xdr (xdata, &rsp.xdata);
+ dict_to_xdr(xdata, &rsp.xdata);
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (op_ret) {
- gf_msg (this->name, GF_LOG_INFO,
- op_errno, PS_MSG_DIR_INFO,
- "%"PRId64": RMDIR %s (%s/%s), client: %s, "
- "error-xlator: %s", frame->root->unique,
- (state->loc.path) ? state->loc.path : "",
- uuid_utoa (state->resolve.pargfid),
- state->resolve.bname, STACK_CLIENT_NAME (frame->root),
- STACK_ERR_XL_NAME (frame->root));
- goto out;
- }
+ if (op_ret) {
+ gf_msg(this->name, GF_LOG_INFO, op_errno, PS_MSG_DIR_INFO,
+ "%" PRId64
+ ": RMDIR %s (%s/%s), client: %s, "
+ "error-xlator: %s",
+ frame->root->unique, (state->loc.path) ? state->loc.path : "",
+ uuid_utoa(state->resolve.pargfid), state->resolve.bname,
+ STACK_CLIENT_NAME(frame->root), STACK_ERR_XL_NAME(frame->root));
+ goto out;
+ }
- server4_post_entry_remove (state, &rsp, preparent, postparent);
+ server4_post_entry_remove(state, &rsp, preparent, postparent);
out:
- rsp.op_ret = op_ret;
- rsp.op_errno = gf_errno_to_error (op_errno);
+ rsp.op_ret = op_ret;
+ rsp.op_errno = gf_errno_to_error(op_errno);
- req = frame->local;
- server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
- (xdrproc_t)xdr_gfx_common_2iatt_rsp);
+ req = frame->local;
+ server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gfx_common_2iatt_rsp);
- GF_FREE (rsp.xdata.pairs.pairs_val);
+ GF_FREE(rsp.xdata.pairs.pairs_val);
- return 0;
+ return 0;
}
int
-server4_mkdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
+server4_mkdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
int32_t op_ret, int32_t op_errno, inode_t *inode,
struct iatt *stbuf, struct iatt *preparent,
struct iatt *postparent, dict_t *xdata)
{
- gfx_common_3iatt_rsp rsp = {0,};
- server_state_t *state = NULL;
- rpcsvc_request_t *req = NULL;
-
- dict_to_xdr (xdata, &rsp.xdata);
-
- state = CALL_STATE (frame);
-
- if (op_ret < 0) {
- gf_msg (this->name, fop_log_level (GF_FOP_MKDIR, op_errno),
- op_errno, PS_MSG_DIR_INFO,
- "%"PRId64": MKDIR %s (%s/%s) client: %s, "
- "error-xlator: %s", frame->root->unique,
- (state->loc.path) ? state->loc.path : "",
- uuid_utoa (state->resolve.pargfid),
- state->resolve.bname,
- STACK_CLIENT_NAME (frame->root),
- STACK_ERR_XL_NAME (frame->root));
- goto out;
- }
-
- server4_post_common_3iatt (state, &rsp, inode, stbuf, preparent,
- postparent);
+ gfx_common_3iatt_rsp rsp = {
+ 0,
+ };
+ server_state_t *state = NULL;
+ rpcsvc_request_t *req = NULL;
+
+ dict_to_xdr(xdata, &rsp.xdata);
+
+ state = CALL_STATE(frame);
+
+ if (op_ret < 0) {
+ gf_msg(this->name, fop_log_level(GF_FOP_MKDIR, op_errno), op_errno,
+ PS_MSG_DIR_INFO,
+ "%" PRId64
+ ": MKDIR %s (%s/%s) client: %s, "
+ "error-xlator: %s",
+ frame->root->unique, (state->loc.path) ? state->loc.path : "",
+ uuid_utoa(state->resolve.pargfid), state->resolve.bname,
+ STACK_CLIENT_NAME(frame->root), STACK_ERR_XL_NAME(frame->root));
+ goto out;
+ }
+
+ server4_post_common_3iatt(state, &rsp, inode, stbuf, preparent, postparent);
out:
- rsp.op_ret = op_ret;
- rsp.op_errno = gf_errno_to_error (op_errno);
+ rsp.op_ret = op_ret;
+ rsp.op_errno = gf_errno_to_error(op_errno);
- req = frame->local;
- server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
- (xdrproc_t)xdr_gfx_common_3iatt_rsp);
+ req = frame->local;
+ server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gfx_common_3iatt_rsp);
- GF_FREE (rsp.xdata.pairs.pairs_val);
+ GF_FREE(rsp.xdata.pairs.pairs_val);
- return 0;
+ return 0;
}
int
-server4_mknod_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
- int32_t op_ret, int32_t op_errno,
- inode_t *inode, struct iatt *stbuf, struct iatt *preparent,
+server4_mknod_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+ int32_t op_ret, int32_t op_errno, inode_t *inode,
+ struct iatt *stbuf, struct iatt *preparent,
struct iatt *postparent, dict_t *xdata)
{
- gfx_common_3iatt_rsp rsp = {0,};
- server_state_t *state = NULL;
- rpcsvc_request_t *req = NULL;
-
- dict_to_xdr (xdata, &rsp.xdata);
-
- state = CALL_STATE (frame);
-
- if (op_ret < 0) {
- gf_msg (this->name, fop_log_level (GF_FOP_MKNOD, op_errno),
- op_errno, PS_MSG_MKNOD_INFO,
- "%"PRId64": MKNOD %s (%s/%s), client: %s, "
- "error-xlator: %s", frame->root->unique,
- state->loc.path, uuid_utoa (state->resolve.pargfid),
- state->resolve.bname, STACK_CLIENT_NAME (frame->root),
- STACK_ERR_XL_NAME (frame->root));
- goto out;
- }
-
- server4_post_common_3iatt (state, &rsp, inode, stbuf, preparent,
- postparent);
+ gfx_common_3iatt_rsp rsp = {
+ 0,
+ };
+ server_state_t *state = NULL;
+ rpcsvc_request_t *req = NULL;
+
+ dict_to_xdr(xdata, &rsp.xdata);
+
+ state = CALL_STATE(frame);
+
+ if (op_ret < 0) {
+ gf_msg(this->name, fop_log_level(GF_FOP_MKNOD, op_errno), op_errno,
+ PS_MSG_MKNOD_INFO,
+ "%" PRId64
+ ": MKNOD %s (%s/%s), client: %s, "
+ "error-xlator: %s",
+ frame->root->unique, state->loc.path,
+ uuid_utoa(state->resolve.pargfid), state->resolve.bname,
+ STACK_CLIENT_NAME(frame->root), STACK_ERR_XL_NAME(frame->root));
+ goto out;
+ }
+
+ server4_post_common_3iatt(state, &rsp, inode, stbuf, preparent, postparent);
out:
- rsp.op_ret = op_ret;
- rsp.op_errno = gf_errno_to_error (op_errno);
+ rsp.op_ret = op_ret;
+ rsp.op_errno = gf_errno_to_error(op_errno);
- req = frame->local;
- server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
- (xdrproc_t)xdr_gfx_common_3iatt_rsp);
+ req = frame->local;
+ server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gfx_common_3iatt_rsp);
- GF_FREE (rsp.xdata.pairs.pairs_val);
+ GF_FREE(rsp.xdata.pairs.pairs_val);
- return 0;
+ return 0;
}
int
-server4_fsyncdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
+server4_fsyncdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
int32_t op_ret, int32_t op_errno, dict_t *xdata)
{
- gfx_common_rsp rsp = {0,};
- server_state_t *state = NULL;
- rpcsvc_request_t *req = NULL;
-
- dict_to_xdr (xdata, &rsp.xdata);
-
- if (op_ret < 0) {
- state = CALL_STATE (frame);
- gf_msg (this->name, fop_log_level (GF_FOP_FSYNCDIR, op_errno),
- op_errno, PS_MSG_DIR_INFO,
- "%"PRId64": FSYNCDIR %"PRId64" (%s), client: %s, "
- "error-xlator: %s", frame->root->unique,
- state->resolve.fd_no, uuid_utoa (state->resolve.gfid),
- STACK_CLIENT_NAME (frame->root),
- STACK_ERR_XL_NAME (frame->root));
- goto out;
- }
+ gfx_common_rsp rsp = {
+ 0,
+ };
+ server_state_t *state = NULL;
+ rpcsvc_request_t *req = NULL;
+
+ dict_to_xdr(xdata, &rsp.xdata);
+
+ if (op_ret < 0) {
+ state = CALL_STATE(frame);
+ gf_msg(this->name, fop_log_level(GF_FOP_FSYNCDIR, op_errno), op_errno,
+ PS_MSG_DIR_INFO,
+ "%" PRId64 ": FSYNCDIR %" PRId64
+ " (%s), client: %s, "
+ "error-xlator: %s",
+ frame->root->unique, state->resolve.fd_no,
+ uuid_utoa(state->resolve.gfid), STACK_CLIENT_NAME(frame->root),
+ STACK_ERR_XL_NAME(frame->root));
+ goto out;
+ }
out:
- rsp.op_ret = op_ret;
- rsp.op_errno = gf_errno_to_error (op_errno);
+ rsp.op_ret = op_ret;
+ rsp.op_errno = gf_errno_to_error(op_errno);
- req = frame->local;
- server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
- (xdrproc_t)xdr_gfx_common_rsp);
+ req = frame->local;
+ server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gfx_common_rsp);
- GF_FREE (rsp.xdata.pairs.pairs_val);
+ GF_FREE(rsp.xdata.pairs.pairs_val);
- return 0;
+ return 0;
}
int
-server4_readdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
+server4_readdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
int32_t op_ret, int32_t op_errno, gf_dirent_t *entries,
dict_t *xdata)
{
- gfx_readdir_rsp rsp = {0,};
- server_state_t *state = NULL;
- rpcsvc_request_t *req = NULL;
- int ret = 0;
-
- dict_to_xdr (xdata, &rsp.xdata);
-
- if (op_ret < 0) {
- state = CALL_STATE (frame);
- gf_msg (this->name, fop_log_level (GF_FOP_READDIR, op_errno),
- op_errno, PS_MSG_DIR_INFO,
- "%"PRId64": READDIR %"PRId64" (%s), client: %s, "
- "error-xlator: %s", frame->root->unique,
- state->resolve.fd_no, uuid_utoa (state->resolve.gfid),
- STACK_CLIENT_NAME (frame->root),
- STACK_ERR_XL_NAME (frame->root));
- goto out;
- }
-
- /* (op_ret == 0) is valid, and means EOF */
- if (op_ret) {
- ret = server4_post_readdir (&rsp, entries);
- if (ret == -1) {
- op_ret = -1;
- op_errno = ENOMEM;
- goto out;
- }
- }
+ gfx_readdir_rsp rsp = {
+ 0,
+ };
+ server_state_t *state = NULL;
+ rpcsvc_request_t *req = NULL;
+ int ret = 0;
+
+ dict_to_xdr(xdata, &rsp.xdata);
+
+ if (op_ret < 0) {
+ state = CALL_STATE(frame);
+ gf_msg(this->name, fop_log_level(GF_FOP_READDIR, op_errno), op_errno,
+ PS_MSG_DIR_INFO,
+ "%" PRId64 ": READDIR %" PRId64
+ " (%s), client: %s, "
+ "error-xlator: %s",
+ frame->root->unique, state->resolve.fd_no,
+ uuid_utoa(state->resolve.gfid), STACK_CLIENT_NAME(frame->root),
+ STACK_ERR_XL_NAME(frame->root));
+ goto out;
+ }
+
+ /* (op_ret == 0) is valid, and means EOF */
+ if (op_ret) {
+ ret = server4_post_readdir(&rsp, entries);
+ if (ret == -1) {
+ op_ret = -1;
+ op_errno = ENOMEM;
+ goto out;
+ }
+ }
out:
- rsp.op_ret = op_ret;
- rsp.op_errno = gf_errno_to_error (op_errno);
+ rsp.op_ret = op_ret;
+ rsp.op_errno = gf_errno_to_error(op_errno);
- req = frame->local;
- server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
- (xdrproc_t)xdr_gfx_readdir_rsp);
+ req = frame->local;
+ server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gfx_readdir_rsp);
- GF_FREE (rsp.xdata.pairs.pairs_val);
+ GF_FREE(rsp.xdata.pairs.pairs_val);
- readdir_rsp_cleanup_v2 (&rsp);
+ readdir_rsp_cleanup_v2(&rsp);
- return 0;
+ return 0;
}
int
-server4_opendir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
+server4_opendir_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
int32_t op_ret, int32_t op_errno, fd_t *fd, dict_t *xdata)
{
- server_state_t *state = NULL;
- rpcsvc_request_t *req = NULL;
- gfx_open_rsp rsp = {0,};
- uint64_t fd_no = 0;
-
- dict_to_xdr (xdata, &rsp.xdata);
-
- if (op_ret < 0) {
- state = CALL_STATE (frame);
- gf_msg (this->name, fop_log_level (GF_FOP_OPENDIR, op_errno),
- op_errno, PS_MSG_DIR_INFO,
- "%"PRId64": OPENDIR %s (%s), client: %s, "
- "error-xlator: %s", frame->root->unique,
- (state->loc.path) ? state->loc.path : "",
- uuid_utoa (state->resolve.gfid),
- STACK_CLIENT_NAME (frame->root),
- STACK_ERR_XL_NAME (frame->root));
- goto out;
- }
-
-
- op_ret = server4_post_open (frame, this, &rsp, fd);
- if (op_ret)
- goto out;
+ server_state_t *state = NULL;
+ rpcsvc_request_t *req = NULL;
+ gfx_open_rsp rsp = {
+ 0,
+ };
+ uint64_t fd_no = 0;
+
+ dict_to_xdr(xdata, &rsp.xdata);
+
+ if (op_ret < 0) {
+ state = CALL_STATE(frame);
+ gf_msg(this->name, fop_log_level(GF_FOP_OPENDIR, op_errno), op_errno,
+ PS_MSG_DIR_INFO,
+ "%" PRId64
+ ": OPENDIR %s (%s), client: %s, "
+ "error-xlator: %s",
+ frame->root->unique, (state->loc.path) ? state->loc.path : "",
+ uuid_utoa(state->resolve.gfid), STACK_CLIENT_NAME(frame->root),
+ STACK_ERR_XL_NAME(frame->root));
+ goto out;
+ }
+
+ op_ret = server4_post_open(frame, this, &rsp, fd);
+ if (op_ret)
+ goto out;
out:
- if (op_ret)
- rsp.fd = fd_no;
- rsp.op_ret = op_ret;
- rsp.op_errno = gf_errno_to_error (op_errno);
+ if (op_ret)
+ rsp.fd = fd_no;
+ rsp.op_ret = op_ret;
+ rsp.op_errno = gf_errno_to_error(op_errno);
- req = frame->local;
- server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
- (xdrproc_t)xdr_gfx_open_rsp);
+ req = frame->local;
+ server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gfx_open_rsp);
- GF_FREE (rsp.xdata.pairs.pairs_val);
+ GF_FREE(rsp.xdata.pairs.pairs_val);
- return 0;
+ return 0;
}
int
-server4_removexattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
+server4_removexattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
int32_t op_ret, int32_t op_errno, dict_t *xdata)
{
- gfx_common_rsp rsp = {0,};
- rpcsvc_request_t *req = NULL;
- server_state_t *state = NULL;
- gf_loglevel_t loglevel = GF_LOG_NONE;
-
- dict_to_xdr (xdata, &rsp.xdata);
-
- if (op_ret == -1) {
- state = CALL_STATE (frame);
- if (ENODATA == op_errno || ENOATTR == op_errno)
- loglevel = GF_LOG_DEBUG;
- else
- loglevel = GF_LOG_INFO;
-
- gf_msg (this->name, loglevel, op_errno,
- PS_MSG_REMOVEXATTR_INFO,
- "%"PRId64": REMOVEXATTR %s (%s) of key %s, client: %s, "
- "error-xlator: %s",
- frame->root->unique, state->loc.path,
- uuid_utoa (state->resolve.gfid),
- state->name, STACK_CLIENT_NAME (frame->root),
- STACK_ERR_XL_NAME (frame->root));
- goto out;
- }
+ gfx_common_rsp rsp = {
+ 0,
+ };
+ rpcsvc_request_t *req = NULL;
+ server_state_t *state = NULL;
+ gf_loglevel_t loglevel = GF_LOG_NONE;
+
+ dict_to_xdr(xdata, &rsp.xdata);
+
+ if (op_ret == -1) {
+ state = CALL_STATE(frame);
+ if (ENODATA == op_errno || ENOATTR == op_errno)
+ loglevel = GF_LOG_DEBUG;
+ else
+ loglevel = GF_LOG_INFO;
+
+ gf_msg(this->name, loglevel, op_errno, PS_MSG_REMOVEXATTR_INFO,
+ "%" PRId64
+ ": REMOVEXATTR %s (%s) of key %s, client: %s, "
+ "error-xlator: %s",
+ frame->root->unique, state->loc.path,
+ uuid_utoa(state->resolve.gfid), state->name,
+ STACK_CLIENT_NAME(frame->root), STACK_ERR_XL_NAME(frame->root));
+ goto out;
+ }
out:
- rsp.op_ret = op_ret;
- rsp.op_errno = gf_errno_to_error (op_errno);
+ rsp.op_ret = op_ret;
+ rsp.op_errno = gf_errno_to_error(op_errno);
- req = frame->local;
- server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
- (xdrproc_t)xdr_gfx_common_rsp);
+ req = frame->local;
+ server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gfx_common_rsp);
- GF_FREE (rsp.xdata.pairs.pairs_val);
+ GF_FREE(rsp.xdata.pairs.pairs_val);
- return 0;
+ return 0;
}
int
-server4_fremovexattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
+server4_fremovexattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
int32_t op_ret, int32_t op_errno, dict_t *xdata)
{
- gfx_common_rsp rsp = {0,};
- rpcsvc_request_t *req = NULL;
- server_state_t *state = NULL;
-
- dict_to_xdr (xdata, &rsp.xdata);
-
- if (op_ret == -1) {
- state = CALL_STATE (frame);
- gf_msg (this->name,
- fop_log_level (GF_FOP_FREMOVEXATTR, op_errno), op_errno,
- PS_MSG_REMOVEXATTR_INFO,
- "%"PRId64": FREMOVEXATTR %"PRId64" (%s) (%s), "
- "client: %s, error-xlator: %s", frame->root->unique,
- state->resolve.fd_no, uuid_utoa (state->resolve.gfid),
- state->name, STACK_CLIENT_NAME (frame->root),
- STACK_ERR_XL_NAME (frame->root));
- goto out;
- }
+ gfx_common_rsp rsp = {
+ 0,
+ };
+ rpcsvc_request_t *req = NULL;
+ server_state_t *state = NULL;
+
+ dict_to_xdr(xdata, &rsp.xdata);
+
+ if (op_ret == -1) {
+ state = CALL_STATE(frame);
+ gf_msg(this->name, fop_log_level(GF_FOP_FREMOVEXATTR, op_errno),
+ op_errno, PS_MSG_REMOVEXATTR_INFO,
+ "%" PRId64 ": FREMOVEXATTR %" PRId64
+ " (%s) (%s), "
+ "client: %s, error-xlator: %s",
+ frame->root->unique, state->resolve.fd_no,
+ uuid_utoa(state->resolve.gfid), state->name,
+ STACK_CLIENT_NAME(frame->root), STACK_ERR_XL_NAME(frame->root));
+ goto out;
+ }
out:
- rsp.op_ret = op_ret;
- rsp.op_errno = gf_errno_to_error (op_errno);
+ rsp.op_ret = op_ret;
+ rsp.op_errno = gf_errno_to_error(op_errno);
- req = frame->local;
- server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
- (xdrproc_t)xdr_gfx_common_rsp);
+ req = frame->local;
+ server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gfx_common_rsp);
- GF_FREE (rsp.xdata.pairs.pairs_val);
+ GF_FREE(rsp.xdata.pairs.pairs_val);
- return 0;
+ return 0;
}
int
-server4_getxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
+server4_getxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
int32_t op_ret, int32_t op_errno, dict_t *dict,
dict_t *xdata)
{
- gfx_common_dict_rsp rsp = {0,};
- rpcsvc_request_t *req = NULL;
- server_state_t *state = NULL;
-
- dict_to_xdr (xdata, &rsp.xdata);
-
- if (op_ret == -1) {
- state = CALL_STATE (frame);
- gf_msg (this->name, fop_log_level (GF_FOP_GETXATTR, op_errno),
- op_errno, PS_MSG_GETXATTR_INFO,
- "%"PRId64": GETXATTR %s (%s) (%s), client: %s, "
- "error-xlator: %s", frame->root->unique,
- state->loc.path, uuid_utoa (state->resolve.gfid),
- state->name, STACK_CLIENT_NAME (frame->root),
- STACK_ERR_XL_NAME (frame->root));
- goto out;
- }
-
- dict_to_xdr (dict, &rsp.dict);
+ gfx_common_dict_rsp rsp = {
+ 0,
+ };
+ rpcsvc_request_t *req = NULL;
+ server_state_t *state = NULL;
+
+ dict_to_xdr(xdata, &rsp.xdata);
+
+ if (op_ret == -1) {
+ state = CALL_STATE(frame);
+ gf_msg(this->name, fop_log_level(GF_FOP_GETXATTR, op_errno), op_errno,
+ PS_MSG_GETXATTR_INFO,
+ "%" PRId64
+ ": GETXATTR %s (%s) (%s), client: %s, "
+ "error-xlator: %s",
+ frame->root->unique, state->loc.path,
+ uuid_utoa(state->resolve.gfid), state->name,
+ STACK_CLIENT_NAME(frame->root), STACK_ERR_XL_NAME(frame->root));
+ goto out;
+ }
+
+ dict_to_xdr(dict, &rsp.dict);
out:
- rsp.op_ret = op_ret;
- rsp.op_errno = gf_errno_to_error (op_errno);
+ rsp.op_ret = op_ret;
+ rsp.op_errno = gf_errno_to_error(op_errno);
- req = frame->local;
- server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
- (xdrproc_t)xdr_gfx_common_dict_rsp);
+ req = frame->local;
+ server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gfx_common_dict_rsp);
- GF_FREE (rsp.dict.pairs.pairs_val);
+ GF_FREE(rsp.dict.pairs.pairs_val);
- GF_FREE (rsp.xdata.pairs.pairs_val);
+ GF_FREE(rsp.xdata.pairs.pairs_val);
- return 0;
+ return 0;
}
-
int
-server4_fgetxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
+server4_fgetxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
int32_t op_ret, int32_t op_errno, dict_t *dict,
dict_t *xdata)
{
- gfx_common_dict_rsp rsp = {0,};
- server_state_t *state = NULL;
- rpcsvc_request_t *req = NULL;
-
- dict_to_xdr (xdata, &rsp.xdata);
-
- if (op_ret == -1) {
- state = CALL_STATE (frame);
- gf_msg (this->name, fop_log_level (GF_FOP_FGETXATTR, op_errno),
- op_errno, PS_MSG_GETXATTR_INFO,
- "%"PRId64": FGETXATTR %"PRId64" (%s) (%s), "
- "client: %s, error-xlator: %s", frame->root->unique,
- state->resolve.fd_no, uuid_utoa (state->resolve.gfid),
- state->name, STACK_CLIENT_NAME (frame->root),
- STACK_ERR_XL_NAME (frame->root));
- goto out;
- }
-
- dict_to_xdr (dict, &rsp.dict);
+ gfx_common_dict_rsp rsp = {
+ 0,
+ };
+ server_state_t *state = NULL;
+ rpcsvc_request_t *req = NULL;
+
+ dict_to_xdr(xdata, &rsp.xdata);
+
+ if (op_ret == -1) {
+ state = CALL_STATE(frame);
+ gf_msg(this->name, fop_log_level(GF_FOP_FGETXATTR, op_errno), op_errno,
+ PS_MSG_GETXATTR_INFO,
+ "%" PRId64 ": FGETXATTR %" PRId64
+ " (%s) (%s), "
+ "client: %s, error-xlator: %s",
+ frame->root->unique, state->resolve.fd_no,
+ uuid_utoa(state->resolve.gfid), state->name,
+ STACK_CLIENT_NAME(frame->root), STACK_ERR_XL_NAME(frame->root));
+ goto out;
+ }
+
+ dict_to_xdr(dict, &rsp.dict);
out:
- rsp.op_ret = op_ret;
- rsp.op_errno = gf_errno_to_error (op_errno);
+ rsp.op_ret = op_ret;
+ rsp.op_errno = gf_errno_to_error(op_errno);
- req = frame->local;
- server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
- (xdrproc_t)xdr_gfx_common_dict_rsp);
+ req = frame->local;
+ server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gfx_common_dict_rsp);
- GF_FREE (rsp.dict.pairs.pairs_val);
+ GF_FREE(rsp.dict.pairs.pairs_val);
- GF_FREE (rsp.xdata.pairs.pairs_val);
+ GF_FREE(rsp.xdata.pairs.pairs_val);
- return 0;
+ return 0;
}
int
-server4_setxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
+server4_setxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
int32_t op_ret, int32_t op_errno, dict_t *xdata)
{
- gfx_common_rsp rsp = {0,};
- rpcsvc_request_t *req = NULL;
- server_state_t *state = NULL;
-
- dict_to_xdr (xdata, &rsp.xdata);
-
- if (op_ret == -1) {
- state = CALL_STATE (frame);
- if (op_errno != ENOTSUP)
- dict_foreach (state->dict,
- _gf_server_log_setxattr_failure,
- frame);
-
- if (op_errno == ENOTSUP) {
- gf_msg_debug (THIS->name, 0, "%s",
- strerror (op_errno));
- } else {
- gf_msg (THIS->name, GF_LOG_INFO, op_errno,
- PS_MSG_SETXATTR_INFO, "client: %s, "
- "error-xlator: %s",
- STACK_CLIENT_NAME (frame->root),
- STACK_ERR_XL_NAME (frame->root));
- }
- goto out;
+ gfx_common_rsp rsp = {
+ 0,
+ };
+ rpcsvc_request_t *req = NULL;
+ server_state_t *state = NULL;
+
+ dict_to_xdr(xdata, &rsp.xdata);
+
+ if (op_ret == -1) {
+ state = CALL_STATE(frame);
+ if (op_errno != ENOTSUP)
+ dict_foreach(state->dict, _gf_server_log_setxattr_failure, frame);
+
+ if (op_errno == ENOTSUP) {
+ gf_msg_debug(THIS->name, 0, "%s", strerror(op_errno));
+ } else {
+ gf_msg(THIS->name, GF_LOG_INFO, op_errno, PS_MSG_SETXATTR_INFO,
+ "client: %s, "
+ "error-xlator: %s",
+ STACK_CLIENT_NAME(frame->root),
+ STACK_ERR_XL_NAME(frame->root));
}
+ goto out;
+ }
out:
- rsp.op_ret = op_ret;
- rsp.op_errno = gf_errno_to_error (op_errno);
+ rsp.op_ret = op_ret;
+ rsp.op_errno = gf_errno_to_error(op_errno);
- req = frame->local;
- server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
- (xdrproc_t)xdr_gfx_common_rsp);
+ req = frame->local;
+ server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gfx_common_rsp);
- GF_FREE (rsp.xdata.pairs.pairs_val);
+ GF_FREE(rsp.xdata.pairs.pairs_val);
- return 0;
+ return 0;
}
int
-server4_fsetxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
+server4_fsetxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
int32_t op_ret, int32_t op_errno, dict_t *xdata)
{
- gfx_common_rsp rsp = {0,};
- rpcsvc_request_t *req = NULL;
- server_state_t *state = NULL;
-
- dict_to_xdr (xdata, &rsp.xdata);
-
- if (op_ret == -1) {
- state = CALL_STATE (frame);
- if (op_errno != ENOTSUP) {
- dict_foreach (state->dict,
- _gf_server_log_setxattr_failure,
- frame);
- }
- if (op_errno == ENOTSUP) {
- gf_msg_debug (THIS->name, 0, "%s",
- strerror (op_errno));
- } else {
- gf_msg (THIS->name, GF_LOG_INFO, op_errno,
- PS_MSG_SETXATTR_INFO, "client: %s, "
- "error-xlator: %s",
- STACK_CLIENT_NAME (frame->root),
- STACK_ERR_XL_NAME (frame->root));
- }
- goto out;
+ gfx_common_rsp rsp = {
+ 0,
+ };
+ rpcsvc_request_t *req = NULL;
+ server_state_t *state = NULL;
+
+ dict_to_xdr(xdata, &rsp.xdata);
+
+ if (op_ret == -1) {
+ state = CALL_STATE(frame);
+ if (op_errno != ENOTSUP) {
+ dict_foreach(state->dict, _gf_server_log_setxattr_failure, frame);
}
+ if (op_errno == ENOTSUP) {
+ gf_msg_debug(THIS->name, 0, "%s", strerror(op_errno));
+ } else {
+ gf_msg(THIS->name, GF_LOG_INFO, op_errno, PS_MSG_SETXATTR_INFO,
+ "client: %s, "
+ "error-xlator: %s",
+ STACK_CLIENT_NAME(frame->root),
+ STACK_ERR_XL_NAME(frame->root));
+ }
+ goto out;
+ }
out:
- rsp.op_ret = op_ret;
- rsp.op_errno = gf_errno_to_error (op_errno);
+ rsp.op_ret = op_ret;
+ rsp.op_errno = gf_errno_to_error(op_errno);
- req = frame->local;
- server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
- (xdrproc_t)xdr_gfx_common_rsp);
+ req = frame->local;
+ server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gfx_common_rsp);
- GF_FREE (rsp.xdata.pairs.pairs_val);
+ GF_FREE(rsp.xdata.pairs.pairs_val);
- return 0;
+ return 0;
}
int
-server4_rename_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
+server4_rename_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
int32_t op_ret, int32_t op_errno, struct iatt *stbuf,
struct iatt *preoldparent, struct iatt *postoldparent,
struct iatt *prenewparent, struct iatt *postnewparent,
dict_t *xdata)
{
- gfx_rename_rsp rsp = {0,};
- server_state_t *state = NULL;
- rpcsvc_request_t *req = NULL;
- char oldpar_str[50] = {0,};
- char newpar_str[50] = {0,};
-
- dict_to_xdr (xdata, &rsp.xdata);
-
- state = CALL_STATE (frame);
-
- if (op_ret == -1) {
- uuid_utoa_r (state->resolve.pargfid, oldpar_str);
- uuid_utoa_r (state->resolve2.pargfid, newpar_str);
- gf_msg (this->name, GF_LOG_INFO, op_errno, PS_MSG_RENAME_INFO,
- "%"PRId64": RENAME %s (%s/%s) -> %s (%s/%s), "
- "client: %s, error-xlator: %s", frame->root->unique,
- state->loc.path, oldpar_str, state->resolve.bname,
- state->loc2.path, newpar_str, state->resolve2.bname,
- STACK_CLIENT_NAME (frame->root),
- STACK_ERR_XL_NAME (frame->root));
- goto out;
- }
-
- server4_post_rename (frame, state, &rsp, stbuf,
- preoldparent, postoldparent,
- prenewparent, postnewparent);
+ gfx_rename_rsp rsp = {
+ 0,
+ };
+ server_state_t *state = NULL;
+ rpcsvc_request_t *req = NULL;
+ char oldpar_str[50] = {
+ 0,
+ };
+ char newpar_str[50] = {
+ 0,
+ };
+
+ dict_to_xdr(xdata, &rsp.xdata);
+
+ state = CALL_STATE(frame);
+
+ if (op_ret == -1) {
+ uuid_utoa_r(state->resolve.pargfid, oldpar_str);
+ uuid_utoa_r(state->resolve2.pargfid, newpar_str);
+ gf_msg(this->name, GF_LOG_INFO, op_errno, PS_MSG_RENAME_INFO,
+ "%" PRId64
+ ": RENAME %s (%s/%s) -> %s (%s/%s), "
+ "client: %s, error-xlator: %s",
+ frame->root->unique, state->loc.path, oldpar_str,
+ state->resolve.bname, state->loc2.path, newpar_str,
+ state->resolve2.bname, STACK_CLIENT_NAME(frame->root),
+ STACK_ERR_XL_NAME(frame->root));
+ goto out;
+ }
+
+ server4_post_rename(frame, state, &rsp, stbuf, preoldparent, postoldparent,
+ prenewparent, postnewparent);
out:
- rsp.op_ret = op_ret;
- rsp.op_errno = gf_errno_to_error (op_errno);
+ rsp.op_ret = op_ret;
+ rsp.op_errno = gf_errno_to_error(op_errno);
- req = frame->local;
- server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
- (xdrproc_t)xdr_gfx_rename_rsp);
+ req = frame->local;
+ server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gfx_rename_rsp);
- GF_FREE (rsp.xdata.pairs.pairs_val);
+ GF_FREE(rsp.xdata.pairs.pairs_val);
- return 0;
+ return 0;
}
int
-server4_unlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
+server4_unlink_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
int32_t op_ret, int32_t op_errno, struct iatt *preparent,
struct iatt *postparent, dict_t *xdata)
{
- gfx_common_2iatt_rsp rsp = {0,};
- server_state_t *state = NULL;
- rpcsvc_request_t *req = NULL;
-
- dict_to_xdr (xdata, &rsp.xdata);
-
- state = CALL_STATE (frame);
-
- if (op_ret) {
- gf_msg (this->name, fop_log_level (GF_FOP_UNLINK, op_errno),
- op_errno, PS_MSG_LINK_INFO,
- "%"PRId64": UNLINK %s (%s/%s), client: %s, "
- "error-xlator: %s", frame->root->unique,
- state->loc.path, uuid_utoa (state->resolve.pargfid),
- state->resolve.bname,
- STACK_CLIENT_NAME (frame->root),
- STACK_ERR_XL_NAME (frame->root));
- goto out;
- }
-
- /* TODO: log gfid of the inodes */
- gf_msg_trace (frame->root->client->bound_xl->name, 0, "%"PRId64": "
- "UNLINK_CBK %s", frame->root->unique, state->loc.name);
-
- server4_post_entry_remove (state, &rsp, preparent, postparent);
+ gfx_common_2iatt_rsp rsp = {
+ 0,
+ };
+ server_state_t *state = NULL;
+ rpcsvc_request_t *req = NULL;
+
+ dict_to_xdr(xdata, &rsp.xdata);
+
+ state = CALL_STATE(frame);
+
+ if (op_ret) {
+ gf_msg(this->name, fop_log_level(GF_FOP_UNLINK, op_errno), op_errno,
+ PS_MSG_LINK_INFO,
+ "%" PRId64
+ ": UNLINK %s (%s/%s), client: %s, "
+ "error-xlator: %s",
+ frame->root->unique, state->loc.path,
+ uuid_utoa(state->resolve.pargfid), state->resolve.bname,
+ STACK_CLIENT_NAME(frame->root), STACK_ERR_XL_NAME(frame->root));
+ goto out;
+ }
+
+ /* TODO: log gfid of the inodes */
+ gf_msg_trace(frame->root->client->bound_xl->name, 0,
+ "%" PRId64
+ ": "
+ "UNLINK_CBK %s",
+ frame->root->unique, state->loc.name);
+
+ server4_post_entry_remove(state, &rsp, preparent, postparent);
out:
- rsp.op_ret = op_ret;
- rsp.op_errno = gf_errno_to_error (op_errno);
+ rsp.op_ret = op_ret;
+ rsp.op_errno = gf_errno_to_error(op_errno);
- req = frame->local;
- server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
- (xdrproc_t)xdr_gfx_common_2iatt_rsp);
+ req = frame->local;
+ server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gfx_common_2iatt_rsp);
- GF_FREE (rsp.xdata.pairs.pairs_val);
+ GF_FREE(rsp.xdata.pairs.pairs_val);
- return 0;
+ return 0;
}
int
-server4_symlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
+server4_symlink_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
int32_t op_ret, int32_t op_errno, inode_t *inode,
struct iatt *stbuf, struct iatt *preparent,
struct iatt *postparent, dict_t *xdata)
{
- gfx_common_3iatt_rsp rsp = {0,};
- server_state_t *state = NULL;
- rpcsvc_request_t *req = NULL;
+ gfx_common_3iatt_rsp rsp = {
+ 0,
+ };
+ server_state_t *state = NULL;
+ rpcsvc_request_t *req = NULL;
- dict_to_xdr (xdata, &rsp.xdata);
+ dict_to_xdr(xdata, &rsp.xdata);
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (op_ret < 0) {
- gf_msg (this->name, GF_LOG_INFO, op_errno, PS_MSG_LINK_INFO,
- "%"PRId64": SYMLINK %s (%s/%s), client: %s, "
- "error-xlator:%s", frame->root->unique,
- (state->loc.path) ? state->loc.path : "",
- uuid_utoa (state->resolve.pargfid),
- state->resolve.bname,
- STACK_CLIENT_NAME (frame->root),
- STACK_ERR_XL_NAME (frame->root));
- goto out;
- }
+ if (op_ret < 0) {
+ gf_msg(this->name, GF_LOG_INFO, op_errno, PS_MSG_LINK_INFO,
+ "%" PRId64
+ ": SYMLINK %s (%s/%s), client: %s, "
+ "error-xlator:%s",
+ frame->root->unique, (state->loc.path) ? state->loc.path : "",
+ uuid_utoa(state->resolve.pargfid), state->resolve.bname,
+ STACK_CLIENT_NAME(frame->root), STACK_ERR_XL_NAME(frame->root));
+ goto out;
+ }
- server4_post_common_3iatt (state, &rsp, inode, stbuf, preparent,
- postparent);
+ server4_post_common_3iatt(state, &rsp, inode, stbuf, preparent, postparent);
out:
- rsp.op_ret = op_ret;
- rsp.op_errno = gf_errno_to_error (op_errno);
+ rsp.op_ret = op_ret;
+ rsp.op_errno = gf_errno_to_error(op_errno);
- req = frame->local;
- server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
- (xdrproc_t)xdr_gfx_common_3iatt_rsp);
+ req = frame->local;
+ server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gfx_common_3iatt_rsp);
- GF_FREE (rsp.xdata.pairs.pairs_val);
+ GF_FREE(rsp.xdata.pairs.pairs_val);
- return 0;
+ return 0;
}
-
int
-server4_link_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
+server4_link_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
int32_t op_ret, int32_t op_errno, inode_t *inode,
struct iatt *stbuf, struct iatt *preparent,
struct iatt *postparent, dict_t *xdata)
{
- gfx_common_3iatt_rsp rsp = {0,};
- server_state_t *state = NULL;
- rpcsvc_request_t *req = NULL;
- char gfid_str[50] = {0,};
- char newpar_str[50] = {0,};
-
- dict_to_xdr (xdata, &rsp.xdata);
-
- state = CALL_STATE (frame);
-
- if (op_ret) {
- uuid_utoa_r (state->resolve.gfid, gfid_str);
- uuid_utoa_r (state->resolve2.pargfid, newpar_str);
-
- gf_msg (this->name, GF_LOG_INFO, op_errno, PS_MSG_LINK_INFO,
- "%"PRId64": LINK %s (%s) -> %s/%s, client: %s, "
- "error-xlator: %s", frame->root->unique,
- state->loc.path, gfid_str, newpar_str,
- state->resolve2.bname, STACK_CLIENT_NAME (frame->root),
- STACK_ERR_XL_NAME (frame->root));
- goto out;
- }
-
- server4_post_link (state, &rsp, inode, stbuf, preparent,
- postparent);
+ gfx_common_3iatt_rsp rsp = {
+ 0,
+ };
+ server_state_t *state = NULL;
+ rpcsvc_request_t *req = NULL;
+ char gfid_str[50] = {
+ 0,
+ };
+ char newpar_str[50] = {
+ 0,
+ };
+
+ dict_to_xdr(xdata, &rsp.xdata);
+
+ state = CALL_STATE(frame);
+
+ if (op_ret) {
+ uuid_utoa_r(state->resolve.gfid, gfid_str);
+ uuid_utoa_r(state->resolve2.pargfid, newpar_str);
+
+ gf_msg(this->name, GF_LOG_INFO, op_errno, PS_MSG_LINK_INFO,
+ "%" PRId64
+ ": LINK %s (%s) -> %s/%s, client: %s, "
+ "error-xlator: %s",
+ frame->root->unique, state->loc.path, gfid_str, newpar_str,
+ state->resolve2.bname, STACK_CLIENT_NAME(frame->root),
+ STACK_ERR_XL_NAME(frame->root));
+ goto out;
+ }
+
+ server4_post_link(state, &rsp, inode, stbuf, preparent, postparent);
out:
- rsp.op_ret = op_ret;
- rsp.op_errno = gf_errno_to_error (op_errno);
+ rsp.op_ret = op_ret;
+ rsp.op_errno = gf_errno_to_error(op_errno);
- req = frame->local;
- server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
- (xdrproc_t)xdr_gfx_common_3iatt_rsp);
+ req = frame->local;
+ server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gfx_common_3iatt_rsp);
- GF_FREE (rsp.xdata.pairs.pairs_val);
+ GF_FREE(rsp.xdata.pairs.pairs_val);
- return 0;
+ return 0;
}
int
-server4_truncate_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
+server4_truncate_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
struct iatt *postbuf, dict_t *xdata)
{
- gfx_common_2iatt_rsp rsp = {0,};
- server_state_t *state = NULL;
- rpcsvc_request_t *req = NULL;
+ gfx_common_2iatt_rsp rsp = {
+ 0,
+ };
+ server_state_t *state = NULL;
+ rpcsvc_request_t *req = NULL;
- dict_to_xdr (xdata, &rsp.xdata);
+ dict_to_xdr(xdata, &rsp.xdata);
- if (op_ret) {
- state = CALL_STATE (frame);
- gf_msg (this->name, GF_LOG_INFO, op_errno,
- PS_MSG_TRUNCATE_INFO,
- "%"PRId64": TRUNCATE %s (%s), client: %s, "
- "error-xlator: %s", frame->root->unique,
- state->loc.path, uuid_utoa (state->resolve.gfid),
- STACK_CLIENT_NAME (frame->root),
- STACK_ERR_XL_NAME (frame->root));
- goto out;
- }
+ if (op_ret) {
+ state = CALL_STATE(frame);
+ gf_msg(this->name, GF_LOG_INFO, op_errno, PS_MSG_TRUNCATE_INFO,
+ "%" PRId64
+ ": TRUNCATE %s (%s), client: %s, "
+ "error-xlator: %s",
+ frame->root->unique, state->loc.path,
+ uuid_utoa(state->resolve.gfid), STACK_CLIENT_NAME(frame->root),
+ STACK_ERR_XL_NAME(frame->root));
+ goto out;
+ }
- server4_post_common_2iatt (&rsp, prebuf, postbuf);
+ server4_post_common_2iatt(&rsp, prebuf, postbuf);
out:
- rsp.op_ret = op_ret;
- rsp.op_errno = gf_errno_to_error (op_errno);
+ rsp.op_ret = op_ret;
+ rsp.op_errno = gf_errno_to_error(op_errno);
- req = frame->local;
- server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
- (xdrproc_t)xdr_gfx_common_2iatt_rsp);
+ req = frame->local;
+ server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gfx_common_2iatt_rsp);
- GF_FREE (rsp.xdata.pairs.pairs_val);
+ GF_FREE(rsp.xdata.pairs.pairs_val);
- return 0;
+ return 0;
}
int
-server4_fstat_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
+server4_fstat_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
int32_t op_ret, int32_t op_errno, struct iatt *stbuf,
dict_t *xdata)
{
- gfx_common_iatt_rsp rsp = {0,};
- server_state_t *state = NULL;
- rpcsvc_request_t *req = NULL;
-
- dict_to_xdr (xdata, &rsp.xdata);
-
- state = CALL_STATE (frame);
- if (op_ret) {
- gf_msg (this->name, fop_log_level (GF_FOP_FSTAT, op_errno),
- op_errno, PS_MSG_STAT_INFO,
- "%"PRId64": FSTAT %"PRId64" (%s), client: %s, "
- "error-xlator: %s", frame->root->unique,
- state->resolve.fd_no, uuid_utoa (state->resolve.gfid),
- STACK_CLIENT_NAME (frame->root),
- STACK_ERR_XL_NAME (frame->root));
- goto out;
- }
-
- server4_post_common_iatt (state, &rsp, stbuf);
+ gfx_common_iatt_rsp rsp = {
+ 0,
+ };
+ server_state_t *state = NULL;
+ rpcsvc_request_t *req = NULL;
+
+ dict_to_xdr(xdata, &rsp.xdata);
+
+ state = CALL_STATE(frame);
+ if (op_ret) {
+ gf_msg(this->name, fop_log_level(GF_FOP_FSTAT, op_errno), op_errno,
+ PS_MSG_STAT_INFO,
+ "%" PRId64 ": FSTAT %" PRId64
+ " (%s), client: %s, "
+ "error-xlator: %s",
+ frame->root->unique, state->resolve.fd_no,
+ uuid_utoa(state->resolve.gfid), STACK_CLIENT_NAME(frame->root),
+ STACK_ERR_XL_NAME(frame->root));
+ goto out;
+ }
+
+ server4_post_common_iatt(state, &rsp, stbuf);
out:
- rsp.op_ret = op_ret;
- rsp.op_errno = gf_errno_to_error (op_errno);
+ rsp.op_ret = op_ret;
+ rsp.op_errno = gf_errno_to_error(op_errno);
- req = frame->local;
- server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
- (xdrproc_t)xdr_gfx_common_iatt_rsp);
+ req = frame->local;
+ server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gfx_common_iatt_rsp);
- GF_FREE (rsp.xdata.pairs.pairs_val);
+ GF_FREE(rsp.xdata.pairs.pairs_val);
- return 0;
+ return 0;
}
int
-server4_ftruncate_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
+server4_ftruncate_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
struct iatt *postbuf, dict_t *xdata)
{
- gfx_common_2iatt_rsp rsp = {0};
- server_state_t *state = NULL;
- rpcsvc_request_t *req = NULL;
+ gfx_common_2iatt_rsp rsp = {0};
+ server_state_t *state = NULL;
+ rpcsvc_request_t *req = NULL;
- dict_to_xdr (xdata, &rsp.xdata);
+ dict_to_xdr(xdata, &rsp.xdata);
- if (op_ret) {
- state = CALL_STATE (frame);
- gf_msg (this->name, fop_log_level (GF_FOP_FTRUNCATE, op_errno),
- op_errno, PS_MSG_TRUNCATE_INFO,
- "%"PRId64": FTRUNCATE %"PRId64" (%s), client: %s, "
- "error-xlator: %s", frame->root->unique,
- state->resolve.fd_no, uuid_utoa (state->resolve.gfid),
- STACK_CLIENT_NAME (frame->root),
- STACK_ERR_XL_NAME (frame->root));
- goto out;
- }
+ if (op_ret) {
+ state = CALL_STATE(frame);
+ gf_msg(this->name, fop_log_level(GF_FOP_FTRUNCATE, op_errno), op_errno,
+ PS_MSG_TRUNCATE_INFO,
+ "%" PRId64 ": FTRUNCATE %" PRId64
+ " (%s), client: %s, "
+ "error-xlator: %s",
+ frame->root->unique, state->resolve.fd_no,
+ uuid_utoa(state->resolve.gfid), STACK_CLIENT_NAME(frame->root),
+ STACK_ERR_XL_NAME(frame->root));
+ goto out;
+ }
- server4_post_common_2iatt (&rsp, prebuf, postbuf);
+ server4_post_common_2iatt(&rsp, prebuf, postbuf);
out:
- rsp.op_ret = op_ret;
- rsp.op_errno = gf_errno_to_error (op_errno);
+ rsp.op_ret = op_ret;
+ rsp.op_errno = gf_errno_to_error(op_errno);
- req = frame->local;
- server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
- (xdrproc_t)xdr_gfx_common_2iatt_rsp);
+ req = frame->local;
+ server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gfx_common_2iatt_rsp);
- GF_FREE (rsp.xdata.pairs.pairs_val);
+ GF_FREE(rsp.xdata.pairs.pairs_val);
- return 0;
+ return 0;
}
int
-server4_flush_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
+server4_flush_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
int32_t op_ret, int32_t op_errno, dict_t *xdata)
{
- gfx_common_rsp rsp = {0,};
- server_state_t *state = NULL;
- rpcsvc_request_t *req = NULL;
-
- dict_to_xdr (xdata, &rsp.xdata);
-
- if (op_ret < 0) {
- state = CALL_STATE (frame);
- gf_msg (this->name, fop_log_level (GF_FOP_FLUSH, op_errno),
- op_errno, PS_MSG_FLUSH_INFO,
- "%"PRId64": FLUSH %"PRId64" (%s), client: %s, "
- "error-xlator: %s",
- frame->root->unique, state->resolve.fd_no,
- uuid_utoa (state->resolve.gfid),
- STACK_CLIENT_NAME (frame->root),
- STACK_ERR_XL_NAME (frame->root));
- goto out;
- }
+ gfx_common_rsp rsp = {
+ 0,
+ };
+ server_state_t *state = NULL;
+ rpcsvc_request_t *req = NULL;
+
+ dict_to_xdr(xdata, &rsp.xdata);
+
+ if (op_ret < 0) {
+ state = CALL_STATE(frame);
+ gf_msg(this->name, fop_log_level(GF_FOP_FLUSH, op_errno), op_errno,
+ PS_MSG_FLUSH_INFO,
+ "%" PRId64 ": FLUSH %" PRId64
+ " (%s), client: %s, "
+ "error-xlator: %s",
+ frame->root->unique, state->resolve.fd_no,
+ uuid_utoa(state->resolve.gfid), STACK_CLIENT_NAME(frame->root),
+ STACK_ERR_XL_NAME(frame->root));
+ goto out;
+ }
out:
- rsp.op_ret = op_ret;
- rsp.op_errno = gf_errno_to_error (op_errno);
+ rsp.op_ret = op_ret;
+ rsp.op_errno = gf_errno_to_error(op_errno);
- req = frame->local;
- server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
- (xdrproc_t)xdr_gfx_common_rsp);
+ req = frame->local;
+ server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gfx_common_rsp);
- GF_FREE (rsp.xdata.pairs.pairs_val);
+ GF_FREE(rsp.xdata.pairs.pairs_val);
- return 0;
+ return 0;
}
int
-server4_fsync_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
+server4_fsync_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
struct iatt *postbuf, dict_t *xdata)
{
- gfx_common_2iatt_rsp rsp = {0,};
- server_state_t *state = NULL;
- rpcsvc_request_t *req = NULL;
-
- dict_to_xdr (xdata, &rsp.xdata);
-
- if (op_ret < 0) {
- state = CALL_STATE (frame);
- gf_msg (this->name, fop_log_level (GF_FOP_FSYNC, op_errno),
- op_errno, PS_MSG_SYNC_INFO,
- "%"PRId64": FSYNC %"PRId64" (%s), client: %s, "
- "error-xlator: %s", frame->root->unique,
- state->resolve.fd_no, uuid_utoa (state->resolve.gfid),
- STACK_CLIENT_NAME (frame->root),
- STACK_ERR_XL_NAME (frame->root));
- goto out;
- }
-
- server4_post_common_2iatt (&rsp, prebuf, postbuf);
+ gfx_common_2iatt_rsp rsp = {
+ 0,
+ };
+ server_state_t *state = NULL;
+ rpcsvc_request_t *req = NULL;
+
+ dict_to_xdr(xdata, &rsp.xdata);
+
+ if (op_ret < 0) {
+ state = CALL_STATE(frame);
+ gf_msg(this->name, fop_log_level(GF_FOP_FSYNC, op_errno), op_errno,
+ PS_MSG_SYNC_INFO,
+ "%" PRId64 ": FSYNC %" PRId64
+ " (%s), client: %s, "
+ "error-xlator: %s",
+ frame->root->unique, state->resolve.fd_no,
+ uuid_utoa(state->resolve.gfid), STACK_CLIENT_NAME(frame->root),
+ STACK_ERR_XL_NAME(frame->root));
+ goto out;
+ }
+
+ server4_post_common_2iatt(&rsp, prebuf, postbuf);
out:
- rsp.op_ret = op_ret;
- rsp.op_errno = gf_errno_to_error (op_errno);
+ rsp.op_ret = op_ret;
+ rsp.op_errno = gf_errno_to_error(op_errno);
- req = frame->local;
- server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
- (xdrproc_t)xdr_gfx_common_2iatt_rsp);
+ req = frame->local;
+ server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gfx_common_2iatt_rsp);
- GF_FREE (rsp.xdata.pairs.pairs_val);
+ GF_FREE(rsp.xdata.pairs.pairs_val);
- return 0;
+ return 0;
}
int
-server4_writev_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
+server4_writev_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
struct iatt *postbuf, dict_t *xdata)
{
- gfx_common_2iatt_rsp rsp = {0,};
- server_state_t *state = NULL;
- rpcsvc_request_t *req = NULL;
-
- dict_to_xdr (xdata, &rsp.xdata);
-
- if (op_ret < 0) {
- state = CALL_STATE (frame);
- gf_msg (this->name, fop_log_level (GF_FOP_WRITE, op_errno),
- op_errno, PS_MSG_WRITE_INFO,
- "%"PRId64": WRITEV %"PRId64" (%s), client: %s, "
- "error-xlator: %s", frame->root->unique,
- state->resolve.fd_no, uuid_utoa (state->resolve.gfid),
- STACK_CLIENT_NAME (frame->root),
- STACK_ERR_XL_NAME (frame->root));
- goto out;
- }
-
- server4_post_common_2iatt (&rsp, prebuf, postbuf);
+ gfx_common_2iatt_rsp rsp = {
+ 0,
+ };
+ server_state_t *state = NULL;
+ rpcsvc_request_t *req = NULL;
+
+ dict_to_xdr(xdata, &rsp.xdata);
+
+ if (op_ret < 0) {
+ state = CALL_STATE(frame);
+ gf_msg(this->name, fop_log_level(GF_FOP_WRITE, op_errno), op_errno,
+ PS_MSG_WRITE_INFO,
+ "%" PRId64 ": WRITEV %" PRId64
+ " (%s), client: %s, "
+ "error-xlator: %s",
+ frame->root->unique, state->resolve.fd_no,
+ uuid_utoa(state->resolve.gfid), STACK_CLIENT_NAME(frame->root),
+ STACK_ERR_XL_NAME(frame->root));
+ goto out;
+ }
+
+ server4_post_common_2iatt(&rsp, prebuf, postbuf);
out:
- rsp.op_ret = op_ret;
- rsp.op_errno = gf_errno_to_error (op_errno);
+ rsp.op_ret = op_ret;
+ rsp.op_errno = gf_errno_to_error(op_errno);
- req = frame->local;
- server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
- (xdrproc_t)xdr_gfx_common_2iatt_rsp);
+ req = frame->local;
+ server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gfx_common_2iatt_rsp);
- GF_FREE (rsp.xdata.pairs.pairs_val);
+ GF_FREE(rsp.xdata.pairs.pairs_val);
- return 0;
+ return 0;
}
-
int
-server4_readv_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
- int32_t op_ret, int32_t op_errno,
- struct iovec *vector, int32_t count,
- struct iatt *stbuf, struct iobref *iobref, dict_t *xdata)
+server4_readv_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+ int32_t op_ret, int32_t op_errno, struct iovec *vector,
+ int32_t count, struct iatt *stbuf, struct iobref *iobref,
+ dict_t *xdata)
{
- gfx_read_rsp rsp = {0,};
- server_state_t *state = NULL;
- rpcsvc_request_t *req = NULL;
+ gfx_read_rsp rsp = {
+ 0,
+ };
+ server_state_t *state = NULL;
+ rpcsvc_request_t *req = NULL;
#ifdef GF_TESTING_IO_XDATA
- {
- int ret = 0;
- if (!xdata)
- xdata = dict_new ();
-
- ret = dict_set_str (xdata, "testing-the-xdata-key",
- "testing-xdata-value");
- }
+ {
+ int ret = 0;
+ if (!xdata)
+ xdata = dict_new();
+
+ ret = dict_set_str(xdata, "testing-the-xdata-key",
+ "testing-xdata-value");
+ }
#endif
- dict_to_xdr (xdata, &rsp.xdata);
-
- if (op_ret < 0) {
- state = CALL_STATE (frame);
- gf_msg (this->name, fop_log_level (GF_FOP_READ, op_errno),
- op_errno, PS_MSG_READ_INFO,
- "%"PRId64": READV %"PRId64" (%s), client: %s, "
- "error-xlator: %s", frame->root->unique,
- state->resolve.fd_no, uuid_utoa (state->resolve.gfid),
- STACK_CLIENT_NAME (frame->root),
- STACK_ERR_XL_NAME (frame->root));
- goto out;
- }
-
- server4_post_readv (&rsp, stbuf, op_ret);
+ dict_to_xdr(xdata, &rsp.xdata);
+
+ if (op_ret < 0) {
+ state = CALL_STATE(frame);
+ gf_msg(this->name, fop_log_level(GF_FOP_READ, op_errno), op_errno,
+ PS_MSG_READ_INFO,
+ "%" PRId64 ": READV %" PRId64
+ " (%s), client: %s, "
+ "error-xlator: %s",
+ frame->root->unique, state->resolve.fd_no,
+ uuid_utoa(state->resolve.gfid), STACK_CLIENT_NAME(frame->root),
+ STACK_ERR_XL_NAME(frame->root));
+ goto out;
+ }
+
+ server4_post_readv(&rsp, stbuf, op_ret);
out:
- rsp.op_ret = op_ret;
- rsp.op_errno = gf_errno_to_error (op_errno);
+ rsp.op_ret = op_ret;
+ rsp.op_errno = gf_errno_to_error(op_errno);
- req = frame->local;
- server_submit_reply (frame, req, &rsp, vector, count, iobref,
- (xdrproc_t)xdr_gfx_read_rsp);
+ req = frame->local;
+ server_submit_reply(frame, req, &rsp, vector, count, iobref,
+ (xdrproc_t)xdr_gfx_read_rsp);
- GF_FREE (rsp.xdata.pairs.pairs_val);
+ GF_FREE(rsp.xdata.pairs.pairs_val);
- return 0;
+ return 0;
}
int
-server4_rchecksum_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
- int32_t op_ret, int32_t op_errno,
- uint32_t weak_checksum, uint8_t *strong_checksum,
- dict_t *xdata)
+server4_rchecksum_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+ int32_t op_ret, int32_t op_errno, uint32_t weak_checksum,
+ uint8_t *strong_checksum, dict_t *xdata)
{
- gfx_rchecksum_rsp rsp = {0,};
- rpcsvc_request_t *req = NULL;
- server_state_t *state = NULL;
-
- dict_to_xdr (xdata, &rsp.xdata);
-
- if (op_ret < 0) {
- state = CALL_STATE (frame);
- gf_msg (this->name, fop_log_level (GF_FOP_RCHECKSUM, op_errno),
- op_errno, PS_MSG_CHKSUM_INFO,
- "%"PRId64": RCHECKSUM %"PRId64" (%s), client: %s, "
- "error-xlator: %s", frame->root->unique,
- state->resolve.fd_no, uuid_utoa (state->resolve.gfid),
- STACK_CLIENT_NAME (frame->root),
- STACK_ERR_XL_NAME (frame->root));
- goto out;
- }
+ gfx_rchecksum_rsp rsp = {
+ 0,
+ };
+ rpcsvc_request_t *req = NULL;
+ server_state_t *state = NULL;
+
+ dict_to_xdr(xdata, &rsp.xdata);
- server4_post_rchecksum (&rsp, weak_checksum, strong_checksum);
+ if (op_ret < 0) {
+ state = CALL_STATE(frame);
+ gf_msg(this->name, fop_log_level(GF_FOP_RCHECKSUM, op_errno), op_errno,
+ PS_MSG_CHKSUM_INFO,
+ "%" PRId64 ": RCHECKSUM %" PRId64
+ " (%s), client: %s, "
+ "error-xlator: %s",
+ frame->root->unique, state->resolve.fd_no,
+ uuid_utoa(state->resolve.gfid), STACK_CLIENT_NAME(frame->root),
+ STACK_ERR_XL_NAME(frame->root));
+ goto out;
+ }
+
+ server4_post_rchecksum(&rsp, weak_checksum, strong_checksum);
out:
- rsp.op_ret = op_ret;
- rsp.op_errno = gf_errno_to_error (op_errno);
+ rsp.op_ret = op_ret;
+ rsp.op_errno = gf_errno_to_error(op_errno);
- req = frame->local;
- server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
- (xdrproc_t)xdr_gfx_rchecksum_rsp);
+ req = frame->local;
+ server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gfx_rchecksum_rsp);
- GF_FREE (rsp.xdata.pairs.pairs_val);
+ GF_FREE(rsp.xdata.pairs.pairs_val);
- return 0;
+ return 0;
}
-
int
-server4_open_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
+server4_open_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
int32_t op_ret, int32_t op_errno, fd_t *fd, dict_t *xdata)
{
- server_state_t *state = NULL;
- rpcsvc_request_t *req = NULL;
- gfx_open_rsp rsp = {0,};
-
- dict_to_xdr (xdata, &rsp.xdata);
-
- if (op_ret < 0) {
- state = CALL_STATE (frame);
- gf_msg (this->name, fop_log_level (GF_FOP_OPEN, op_errno),
- op_errno, PS_MSG_OPEN_INFO,
- "%"PRId64": OPEN %s (%s), client: %s, error-xlator: %s",
- frame->root->unique, state->loc.path,
- uuid_utoa (state->resolve.gfid),
- STACK_CLIENT_NAME (frame->root),
- STACK_ERR_XL_NAME (frame->root));
- goto out;
- }
-
- op_ret = server4_post_open (frame, this, &rsp, fd);
- if (op_ret)
- goto out;
+ server_state_t *state = NULL;
+ rpcsvc_request_t *req = NULL;
+ gfx_open_rsp rsp = {
+ 0,
+ };
+
+ dict_to_xdr(xdata, &rsp.xdata);
+
+ if (op_ret < 0) {
+ state = CALL_STATE(frame);
+ gf_msg(this->name, fop_log_level(GF_FOP_OPEN, op_errno), op_errno,
+ PS_MSG_OPEN_INFO,
+ "%" PRId64 ": OPEN %s (%s), client: %s, error-xlator: %s",
+ frame->root->unique, state->loc.path,
+ uuid_utoa(state->resolve.gfid), STACK_CLIENT_NAME(frame->root),
+ STACK_ERR_XL_NAME(frame->root));
+ goto out;
+ }
+
+ op_ret = server4_post_open(frame, this, &rsp, fd);
+ if (op_ret)
+ goto out;
out:
- rsp.op_ret = op_ret;
- rsp.op_errno = gf_errno_to_error (op_errno);
+ rsp.op_ret = op_ret;
+ rsp.op_errno = gf_errno_to_error(op_errno);
- req = frame->local;
- server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
- (xdrproc_t)xdr_gfx_open_rsp);
- GF_FREE (rsp.xdata.pairs.pairs_val);
+ req = frame->local;
+ server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gfx_open_rsp);
+ GF_FREE(rsp.xdata.pairs.pairs_val);
- return 0;
+ return 0;
}
-
int
-server4_create_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
+server4_create_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
int32_t op_ret, int32_t op_errno, fd_t *fd, inode_t *inode,
struct iatt *stbuf, struct iatt *preparent,
struct iatt *postparent, dict_t *xdata)
{
- server_state_t *state = NULL;
- rpcsvc_request_t *req = NULL;
- uint64_t fd_no = 0;
- gfx_create_rsp rsp = {0,};
-
- dict_to_xdr (xdata, &rsp.xdata);
-
- state = CALL_STATE (frame);
-
- if (op_ret < 0) {
- gf_msg (this->name, GF_LOG_INFO, op_errno, PS_MSG_CREATE_INFO,
- "%"PRId64": CREATE %s (%s/%s), client: %s, "
- "error-xlator: %s", frame->root->unique,
- state->loc.path, uuid_utoa (state->resolve.pargfid),
- state->resolve.bname, STACK_CLIENT_NAME (frame->root),
- STACK_ERR_XL_NAME (frame->root));
- goto out;
- }
-
- /* TODO: log gfid too */
- gf_msg_trace (frame->root->client->bound_xl->name, 0, "%"PRId64": "
- "CREATE %s (%s)", frame->root->unique, state->loc.name,
- uuid_utoa (stbuf->ia_gfid));
-
- op_ret = server4_post_create (frame, &rsp, state, this, fd, inode,
- stbuf,
- preparent, postparent);
- if (op_ret) {
- op_errno = -op_ret;
- op_ret = -1;
- goto out;
- }
+ server_state_t *state = NULL;
+ rpcsvc_request_t *req = NULL;
+ uint64_t fd_no = 0;
+ gfx_create_rsp rsp = {
+ 0,
+ };
+
+ dict_to_xdr(xdata, &rsp.xdata);
+
+ state = CALL_STATE(frame);
+
+ if (op_ret < 0) {
+ gf_msg(this->name, GF_LOG_INFO, op_errno, PS_MSG_CREATE_INFO,
+ "%" PRId64
+ ": CREATE %s (%s/%s), client: %s, "
+ "error-xlator: %s",
+ frame->root->unique, state->loc.path,
+ uuid_utoa(state->resolve.pargfid), state->resolve.bname,
+ STACK_CLIENT_NAME(frame->root), STACK_ERR_XL_NAME(frame->root));
+ goto out;
+ }
+
+ /* TODO: log gfid too */
+ gf_msg_trace(frame->root->client->bound_xl->name, 0,
+ "%" PRId64
+ ": "
+ "CREATE %s (%s)",
+ frame->root->unique, state->loc.name,
+ uuid_utoa(stbuf->ia_gfid));
+
+ op_ret = server4_post_create(frame, &rsp, state, this, fd, inode, stbuf,
+ preparent, postparent);
+ if (op_ret) {
+ op_errno = -op_ret;
+ op_ret = -1;
+ goto out;
+ }
out:
- if (op_ret)
- rsp.fd = fd_no;
- rsp.op_ret = op_ret;
- rsp.op_errno = gf_errno_to_error (op_errno);
+ if (op_ret)
+ rsp.fd = fd_no;
+ rsp.op_ret = op_ret;
+ rsp.op_errno = gf_errno_to_error(op_errno);
- req = frame->local;
- server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
- (xdrproc_t)xdr_gfx_create_rsp);
+ req = frame->local;
+ server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gfx_create_rsp);
- GF_FREE (rsp.xdata.pairs.pairs_val);
+ GF_FREE(rsp.xdata.pairs.pairs_val);
- return 0;
+ return 0;
}
int
-server4_readlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
+server4_readlink_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
int32_t op_ret, int32_t op_errno, const char *buf,
struct iatt *stbuf, dict_t *xdata)
{
- gfx_readlink_rsp rsp = {0,};
- server_state_t *state = NULL;
- rpcsvc_request_t *req = NULL;
-
- dict_to_xdr (xdata, &rsp.xdata);
-
- if (op_ret < 0) {
- state = CALL_STATE (frame);
- gf_msg (this->name, GF_LOG_INFO, op_errno, PS_MSG_LINK_INFO,
- "%"PRId64": READLINK %s (%s), client: %s, "
- "error-xlator: %s", frame->root->unique,
- state->loc.path, uuid_utoa (state->resolve.gfid),
- STACK_CLIENT_NAME (frame->root),
- STACK_ERR_XL_NAME (frame->root));
- goto out;
- }
-
- server4_post_readlink (&rsp, stbuf, buf);
+ gfx_readlink_rsp rsp = {
+ 0,
+ };
+ server_state_t *state = NULL;
+ rpcsvc_request_t *req = NULL;
+
+ dict_to_xdr(xdata, &rsp.xdata);
+
+ if (op_ret < 0) {
+ state = CALL_STATE(frame);
+ gf_msg(this->name, GF_LOG_INFO, op_errno, PS_MSG_LINK_INFO,
+ "%" PRId64
+ ": READLINK %s (%s), client: %s, "
+ "error-xlator: %s",
+ frame->root->unique, state->loc.path,
+ uuid_utoa(state->resolve.gfid), STACK_CLIENT_NAME(frame->root),
+ STACK_ERR_XL_NAME(frame->root));
+ goto out;
+ }
+
+ server4_post_readlink(&rsp, stbuf, buf);
out:
- rsp.op_ret = op_ret;
- rsp.op_errno = gf_errno_to_error (op_errno);
- if (!rsp.path)
- rsp.path = "";
+ rsp.op_ret = op_ret;
+ rsp.op_errno = gf_errno_to_error(op_errno);
+ if (!rsp.path)
+ rsp.path = "";
- req = frame->local;
- server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
- (xdrproc_t)xdr_gfx_readlink_rsp);
+ req = frame->local;
+ server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gfx_readlink_rsp);
- GF_FREE (rsp.xdata.pairs.pairs_val);
+ GF_FREE(rsp.xdata.pairs.pairs_val);
- return 0;
+ return 0;
}
int
-server4_stat_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
+server4_stat_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
int32_t op_ret, int32_t op_errno, struct iatt *stbuf,
dict_t *xdata)
{
- gfx_common_iatt_rsp rsp = {0,};
- server_state_t *state = NULL;
- rpcsvc_request_t *req = NULL;
-
- dict_to_xdr (xdata, &rsp.xdata);
-
- state = CALL_STATE (frame);
- if (op_ret) {
- gf_msg (this->name, fop_log_level (GF_FOP_STAT, op_errno),
- op_errno, PS_MSG_STAT_INFO,
- "%"PRId64": STAT %s (%s), client: %s, error-xlator: %s",
- frame->root->unique,
- (state->loc.path) ? state->loc.path : "",
- uuid_utoa (state->resolve.gfid),
- STACK_CLIENT_NAME (frame->root),
- STACK_ERR_XL_NAME (frame->root));
- goto out;
- }
-
- server4_post_common_iatt (state, &rsp, stbuf);
+ gfx_common_iatt_rsp rsp = {
+ 0,
+ };
+ server_state_t *state = NULL;
+ rpcsvc_request_t *req = NULL;
+
+ dict_to_xdr(xdata, &rsp.xdata);
+
+ state = CALL_STATE(frame);
+ if (op_ret) {
+ gf_msg(this->name, fop_log_level(GF_FOP_STAT, op_errno), op_errno,
+ PS_MSG_STAT_INFO,
+ "%" PRId64 ": STAT %s (%s), client: %s, error-xlator: %s",
+ frame->root->unique, (state->loc.path) ? state->loc.path : "",
+ uuid_utoa(state->resolve.gfid), STACK_CLIENT_NAME(frame->root),
+ STACK_ERR_XL_NAME(frame->root));
+ goto out;
+ }
+
+ server4_post_common_iatt(state, &rsp, stbuf);
out:
- rsp.op_ret = op_ret;
- rsp.op_errno = gf_errno_to_error (op_errno);
+ rsp.op_ret = op_ret;
+ rsp.op_errno = gf_errno_to_error(op_errno);
- req = frame->local;
- server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
- (xdrproc_t)xdr_gfx_common_iatt_rsp);
+ req = frame->local;
+ server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gfx_common_iatt_rsp);
- GF_FREE (rsp.xdata.pairs.pairs_val);
+ GF_FREE(rsp.xdata.pairs.pairs_val);
- return 0;
+ return 0;
}
-
int
-server4_setattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
- int32_t op_ret, int32_t op_errno,
- struct iatt *statpre, struct iatt *statpost, dict_t *xdata)
+server4_setattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+ int32_t op_ret, int32_t op_errno, struct iatt *statpre,
+ struct iatt *statpost, dict_t *xdata)
{
- gfx_common_2iatt_rsp rsp = {0,};
- server_state_t *state = NULL;
- rpcsvc_request_t *req = NULL;
+ gfx_common_2iatt_rsp rsp = {
+ 0,
+ };
+ server_state_t *state = NULL;
+ rpcsvc_request_t *req = NULL;
- dict_to_xdr (xdata, &rsp.xdata);
+ dict_to_xdr(xdata, &rsp.xdata);
- if (op_ret) {
- state = CALL_STATE (frame);
- gf_msg (this->name, GF_LOG_INFO, op_errno, PS_MSG_SETATTR_INFO,
- "%"PRId64": SETATTR %s (%s), client: %s, "
- "error-xlator: %s", frame->root->unique,
- (state->loc.path) ? state->loc.path : "",
- uuid_utoa (state->resolve.gfid),
- STACK_CLIENT_NAME (frame->root),
- STACK_ERR_XL_NAME (frame->root));
- goto out;
- }
+ if (op_ret) {
+ state = CALL_STATE(frame);
+ gf_msg(this->name, GF_LOG_INFO, op_errno, PS_MSG_SETATTR_INFO,
+ "%" PRId64
+ ": SETATTR %s (%s), client: %s, "
+ "error-xlator: %s",
+ frame->root->unique, (state->loc.path) ? state->loc.path : "",
+ uuid_utoa(state->resolve.gfid), STACK_CLIENT_NAME(frame->root),
+ STACK_ERR_XL_NAME(frame->root));
+ goto out;
+ }
- server4_post_common_2iatt (&rsp, statpre, statpost);
+ server4_post_common_2iatt(&rsp, statpre, statpost);
out:
- rsp.op_ret = op_ret;
- rsp.op_errno = gf_errno_to_error (op_errno);
+ rsp.op_ret = op_ret;
+ rsp.op_errno = gf_errno_to_error(op_errno);
- req = frame->local;
- server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
- (xdrproc_t)xdr_gfx_common_2iatt_rsp);
+ req = frame->local;
+ server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gfx_common_2iatt_rsp);
- GF_FREE (rsp.xdata.pairs.pairs_val);
+ GF_FREE(rsp.xdata.pairs.pairs_val);
- return 0;
+ return 0;
}
int
-server4_fsetattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
- int32_t op_ret, int32_t op_errno,
- struct iatt *statpre, struct iatt *statpost, dict_t *xdata)
+server4_fsetattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+ int32_t op_ret, int32_t op_errno, struct iatt *statpre,
+ struct iatt *statpost, dict_t *xdata)
{
- gfx_common_2iatt_rsp rsp = {0,};
- server_state_t *state = NULL;
- rpcsvc_request_t *req = NULL;
+ gfx_common_2iatt_rsp rsp = {
+ 0,
+ };
+ server_state_t *state = NULL;
+ rpcsvc_request_t *req = NULL;
- dict_to_xdr (xdata, &rsp.xdata);
+ dict_to_xdr(xdata, &rsp.xdata);
- if (op_ret) {
- state = CALL_STATE (frame);
- gf_msg (this->name, fop_log_level (GF_FOP_FSETATTR, op_errno),
- op_errno, PS_MSG_SETATTR_INFO,
- "%"PRId64": FSETATTR %"PRId64" (%s), client: %s, "
- "error-xlator: %s", frame->root->unique,
- state->resolve.fd_no, uuid_utoa (state->resolve.gfid),
- STACK_CLIENT_NAME (frame->root),
- STACK_ERR_XL_NAME (frame->root));
- goto out;
- }
+ if (op_ret) {
+ state = CALL_STATE(frame);
+ gf_msg(this->name, fop_log_level(GF_FOP_FSETATTR, op_errno), op_errno,
+ PS_MSG_SETATTR_INFO,
+ "%" PRId64 ": FSETATTR %" PRId64
+ " (%s), client: %s, "
+ "error-xlator: %s",
+ frame->root->unique, state->resolve.fd_no,
+ uuid_utoa(state->resolve.gfid), STACK_CLIENT_NAME(frame->root),
+ STACK_ERR_XL_NAME(frame->root));
+ goto out;
+ }
- server4_post_common_2iatt (&rsp, statpre, statpost);
+ server4_post_common_2iatt(&rsp, statpre, statpost);
out:
- rsp.op_ret = op_ret;
- rsp.op_errno = gf_errno_to_error (op_errno);
+ rsp.op_ret = op_ret;
+ rsp.op_errno = gf_errno_to_error(op_errno);
- req = frame->local;
- server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
- (xdrproc_t)xdr_gfx_common_2iatt_rsp);
+ req = frame->local;
+ server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gfx_common_2iatt_rsp);
- GF_FREE (rsp.xdata.pairs.pairs_val);
+ GF_FREE(rsp.xdata.pairs.pairs_val);
- return 0;
+ return 0;
}
-
int
-server4_xattrop_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
+server4_xattrop_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
int32_t op_ret, int32_t op_errno, dict_t *dict,
dict_t *xdata)
{
- gfx_common_dict_rsp rsp = {0,};
- server_state_t *state = NULL;
- rpcsvc_request_t *req = NULL;
-
- dict_to_xdr (xdata, &rsp.xdata);
-
- if (op_ret < 0) {
- state = CALL_STATE (frame);
- gf_msg (this->name, fop_log_level (GF_FOP_XATTROP, op_errno),
- op_errno, PS_MSG_XATTROP_INFO,
- "%"PRId64": XATTROP %s (%s), client: %s, "
- "error-xlator: %s", frame->root->unique,
- state->loc.path, uuid_utoa (state->resolve.gfid),
- STACK_CLIENT_NAME (frame->root),
- STACK_ERR_XL_NAME (frame->root));
- goto out;
- }
-
- dict_to_xdr (dict, &rsp.dict);
+ gfx_common_dict_rsp rsp = {
+ 0,
+ };
+ server_state_t *state = NULL;
+ rpcsvc_request_t *req = NULL;
+
+ dict_to_xdr(xdata, &rsp.xdata);
+
+ if (op_ret < 0) {
+ state = CALL_STATE(frame);
+ gf_msg(this->name, fop_log_level(GF_FOP_XATTROP, op_errno), op_errno,
+ PS_MSG_XATTROP_INFO,
+ "%" PRId64
+ ": XATTROP %s (%s), client: %s, "
+ "error-xlator: %s",
+ frame->root->unique, state->loc.path,
+ uuid_utoa(state->resolve.gfid), STACK_CLIENT_NAME(frame->root),
+ STACK_ERR_XL_NAME(frame->root));
+ goto out;
+ }
+
+ dict_to_xdr(dict, &rsp.dict);
out:
- rsp.op_ret = op_ret;
- rsp.op_errno = gf_errno_to_error (op_errno);
+ rsp.op_ret = op_ret;
+ rsp.op_errno = gf_errno_to_error(op_errno);
- req = frame->local;
- server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
- (xdrproc_t)xdr_gfx_common_dict_rsp);
+ req = frame->local;
+ server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gfx_common_dict_rsp);
- GF_FREE (rsp.dict.pairs.pairs_val);
+ GF_FREE(rsp.dict.pairs.pairs_val);
- GF_FREE (rsp.xdata.pairs.pairs_val);
+ GF_FREE(rsp.xdata.pairs.pairs_val);
- return 0;
+ return 0;
}
-
int
-server4_fxattrop_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
+server4_fxattrop_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
int32_t op_ret, int32_t op_errno, dict_t *dict,
dict_t *xdata)
{
- gfx_common_dict_rsp rsp = {0,};
- server_state_t *state = NULL;
- rpcsvc_request_t *req = NULL;
-
- dict_to_xdr (xdata, &rsp.xdata);
-
- if (op_ret < 0) {
- state = CALL_STATE (frame);
- gf_msg (this->name, fop_log_level (GF_FOP_FXATTROP, op_errno),
- op_errno, PS_MSG_XATTROP_INFO,
- "%"PRId64": FXATTROP %"PRId64" (%s), client: %s, "
- "error-xlator: %s", frame->root->unique,
- state->resolve.fd_no, uuid_utoa (state->resolve.gfid),
- STACK_CLIENT_NAME (frame->root),
- STACK_ERR_XL_NAME (frame->root));
- goto out;
- }
-
- dict_to_xdr (dict, &rsp.dict);
+ gfx_common_dict_rsp rsp = {
+ 0,
+ };
+ server_state_t *state = NULL;
+ rpcsvc_request_t *req = NULL;
+
+ dict_to_xdr(xdata, &rsp.xdata);
+
+ if (op_ret < 0) {
+ state = CALL_STATE(frame);
+ gf_msg(this->name, fop_log_level(GF_FOP_FXATTROP, op_errno), op_errno,
+ PS_MSG_XATTROP_INFO,
+ "%" PRId64 ": FXATTROP %" PRId64
+ " (%s), client: %s, "
+ "error-xlator: %s",
+ frame->root->unique, state->resolve.fd_no,
+ uuid_utoa(state->resolve.gfid), STACK_CLIENT_NAME(frame->root),
+ STACK_ERR_XL_NAME(frame->root));
+ goto out;
+ }
+
+ dict_to_xdr(dict, &rsp.dict);
out:
- rsp.op_ret = op_ret;
- rsp.op_errno = gf_errno_to_error (op_errno);
+ rsp.op_ret = op_ret;
+ rsp.op_errno = gf_errno_to_error(op_errno);
- req = frame->local;
- server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
- (xdrproc_t)xdr_gfx_common_dict_rsp);
+ req = frame->local;
+ server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gfx_common_dict_rsp);
- GF_FREE (rsp.dict.pairs.pairs_val);
+ GF_FREE(rsp.dict.pairs.pairs_val);
- GF_FREE (rsp.xdata.pairs.pairs_val);
+ GF_FREE(rsp.xdata.pairs.pairs_val);
- return 0;
+ return 0;
}
-
int
-server4_readdirp_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
+server4_readdirp_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
int32_t op_ret, int32_t op_errno, gf_dirent_t *entries,
dict_t *xdata)
{
- gfx_readdirp_rsp rsp = {0,};
- server_state_t *state = NULL;
- rpcsvc_request_t *req = NULL;
- int ret = 0;
-
- state = CALL_STATE (frame);
-
- dict_to_xdr (xdata, &rsp.xdata);
-
- if (op_ret < 0) {
- state = CALL_STATE (frame);
- gf_msg (this->name, fop_log_level (GF_FOP_READDIRP, op_errno),
- op_errno, PS_MSG_DIR_INFO,
- "%"PRId64": READDIRP %"PRId64" (%s), client: %s, "
- "error-xlator: %s", frame->root->unique,
- state->resolve.fd_no, uuid_utoa (state->resolve.gfid),
- STACK_CLIENT_NAME (frame->root),
- STACK_ERR_XL_NAME (frame->root));
- goto out;
- }
-
- /* (op_ret == 0) is valid, and means EOF */
- if (op_ret) {
- ret = server4_post_readdirp (&rsp, entries);
- if (ret == -1) {
- op_ret = -1;
- op_errno = ENOMEM;
- goto out;
- }
- }
-
- gf_link_inodes_from_dirent (this, state->fd->inode, entries);
+ gfx_readdirp_rsp rsp = {
+ 0,
+ };
+ server_state_t *state = NULL;
+ rpcsvc_request_t *req = NULL;
+ int ret = 0;
+
+ state = CALL_STATE(frame);
+
+ dict_to_xdr(xdata, &rsp.xdata);
+
+ if (op_ret < 0) {
+ state = CALL_STATE(frame);
+ gf_msg(this->name, fop_log_level(GF_FOP_READDIRP, op_errno), op_errno,
+ PS_MSG_DIR_INFO,
+ "%" PRId64 ": READDIRP %" PRId64
+ " (%s), client: %s, "
+ "error-xlator: %s",
+ frame->root->unique, state->resolve.fd_no,
+ uuid_utoa(state->resolve.gfid), STACK_CLIENT_NAME(frame->root),
+ STACK_ERR_XL_NAME(frame->root));
+ goto out;
+ }
+
+ /* (op_ret == 0) is valid, and means EOF */
+ if (op_ret) {
+ ret = server4_post_readdirp(&rsp, entries);
+ if (ret == -1) {
+ op_ret = -1;
+ op_errno = ENOMEM;
+ goto out;
+ }
+ }
+
+ gf_link_inodes_from_dirent(this, state->fd->inode, entries);
out:
- rsp.op_ret = op_ret;
- rsp.op_errno = gf_errno_to_error (op_errno);
+ rsp.op_ret = op_ret;
+ rsp.op_errno = gf_errno_to_error(op_errno);
- req = frame->local;
- server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
- (xdrproc_t)xdr_gfx_readdirp_rsp);
+ req = frame->local;
+ server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gfx_readdirp_rsp);
- GF_FREE (rsp.xdata.pairs.pairs_val);
+ GF_FREE(rsp.xdata.pairs.pairs_val);
- readdirp_rsp_cleanup_v2 (&rsp);
+ readdirp_rsp_cleanup_v2(&rsp);
- return 0;
+ return 0;
}
int
server4_fallocate_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
- int32_t op_ret, int32_t op_errno,
- struct iatt *statpre, struct iatt *statpost, dict_t *xdata)
-{
- gfx_common_2iatt_rsp rsp = {0,};
- server_state_t *state = NULL;
- rpcsvc_request_t *req = NULL;
-
- dict_to_xdr (xdata, &rsp.xdata);
-
- if (op_ret) {
- state = CALL_STATE (frame);
- gf_msg (this->name, fop_log_level (GF_FOP_FALLOCATE, op_errno),
- op_errno, PS_MSG_ALLOC_INFO,
- "%"PRId64": FALLOCATE %"PRId64" (%s), client: %s, "
- "error-xlator: %s", frame->root->unique,
- state->resolve.fd_no, uuid_utoa (state->resolve.gfid),
- STACK_CLIENT_NAME (frame->root),
- STACK_ERR_XL_NAME (frame->root));
- goto out;
- }
-
- server4_post_common_2iatt (&rsp, statpre, statpost);
+ int32_t op_ret, int32_t op_errno, struct iatt *statpre,
+ struct iatt *statpost, dict_t *xdata)
+{
+ gfx_common_2iatt_rsp rsp = {
+ 0,
+ };
+ server_state_t *state = NULL;
+ rpcsvc_request_t *req = NULL;
+
+ dict_to_xdr(xdata, &rsp.xdata);
+
+ if (op_ret) {
+ state = CALL_STATE(frame);
+ gf_msg(this->name, fop_log_level(GF_FOP_FALLOCATE, op_errno), op_errno,
+ PS_MSG_ALLOC_INFO,
+ "%" PRId64 ": FALLOCATE %" PRId64
+ " (%s), client: %s, "
+ "error-xlator: %s",
+ frame->root->unique, state->resolve.fd_no,
+ uuid_utoa(state->resolve.gfid), STACK_CLIENT_NAME(frame->root),
+ STACK_ERR_XL_NAME(frame->root));
+ goto out;
+ }
+
+ server4_post_common_2iatt(&rsp, statpre, statpost);
out:
- rsp.op_ret = op_ret;
- rsp.op_errno = gf_errno_to_error (op_errno);
+ rsp.op_ret = op_ret;
+ rsp.op_errno = gf_errno_to_error(op_errno);
- req = frame->local;
- server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
- (xdrproc_t) xdr_gfx_common_2iatt_rsp);
+ req = frame->local;
+ server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gfx_common_2iatt_rsp);
- GF_FREE (rsp.xdata.pairs.pairs_val);
+ GF_FREE(rsp.xdata.pairs.pairs_val);
- return 0;
+ return 0;
}
int
server4_discard_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
- int32_t op_ret, int32_t op_errno,
- struct iatt *statpre, struct iatt *statpost, dict_t *xdata)
-{
- gfx_common_2iatt_rsp rsp = {0,};
- server_state_t *state = NULL;
- rpcsvc_request_t *req = NULL;
-
- dict_to_xdr (xdata, &rsp.xdata);
-
- if (op_ret) {
- state = CALL_STATE (frame);
- gf_msg (this->name, fop_log_level (GF_FOP_DISCARD, op_errno),
- op_errno, PS_MSG_DISCARD_INFO,
- "%"PRId64": DISCARD %"PRId64" (%s), client: %s, "
- "error-xlator: %s", frame->root->unique,
- state->resolve.fd_no, uuid_utoa (state->resolve.gfid),
- STACK_CLIENT_NAME (frame->root),
- STACK_ERR_XL_NAME (frame->root));
- goto out;
- }
-
- server4_post_common_2iatt (&rsp, statpre, statpost);
+ int32_t op_ret, int32_t op_errno, struct iatt *statpre,
+ struct iatt *statpost, dict_t *xdata)
+{
+ gfx_common_2iatt_rsp rsp = {
+ 0,
+ };
+ server_state_t *state = NULL;
+ rpcsvc_request_t *req = NULL;
+
+ dict_to_xdr(xdata, &rsp.xdata);
+
+ if (op_ret) {
+ state = CALL_STATE(frame);
+ gf_msg(this->name, fop_log_level(GF_FOP_DISCARD, op_errno), op_errno,
+ PS_MSG_DISCARD_INFO,
+ "%" PRId64 ": DISCARD %" PRId64
+ " (%s), client: %s, "
+ "error-xlator: %s",
+ frame->root->unique, state->resolve.fd_no,
+ uuid_utoa(state->resolve.gfid), STACK_CLIENT_NAME(frame->root),
+ STACK_ERR_XL_NAME(frame->root));
+ goto out;
+ }
+
+ server4_post_common_2iatt(&rsp, statpre, statpost);
out:
- rsp.op_ret = op_ret;
- rsp.op_errno = gf_errno_to_error (op_errno);
+ rsp.op_ret = op_ret;
+ rsp.op_errno = gf_errno_to_error(op_errno);
- req = frame->local;
- server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
- (xdrproc_t) xdr_gfx_common_2iatt_rsp);
+ req = frame->local;
+ server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gfx_common_2iatt_rsp);
- GF_FREE (rsp.xdata.pairs.pairs_val);
+ GF_FREE(rsp.xdata.pairs.pairs_val);
- return 0;
+ return 0;
}
int
server4_zerofill_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
- int32_t op_ret, int32_t op_errno,
- struct iatt *statpre, struct iatt *statpost, dict_t *xdata)
-{
- gfx_common_2iatt_rsp rsp = {0,};
- server_state_t *state = NULL;
- rpcsvc_request_t *req = NULL;
-
- req = frame->local;
- state = CALL_STATE (frame);
-
- dict_to_xdr (xdata, &rsp.xdata);
-
- if (op_ret) {
- gf_msg (this->name, fop_log_level (GF_FOP_ZEROFILL, op_errno),
- op_errno, PS_MSG_ZEROFILL_INFO,
- "%"PRId64": ZEROFILL%"PRId64" (%s), client: %s, "
- "error-xlator: %s",
- frame->root->unique, state->resolve.fd_no,
- uuid_utoa (state->resolve.gfid),
- STACK_CLIENT_NAME (frame->root),
- STACK_ERR_XL_NAME (frame->root));
- goto out;
- }
-
- server4_post_common_2iatt (&rsp, statpre, statpost);
+ int32_t op_ret, int32_t op_errno, struct iatt *statpre,
+ struct iatt *statpost, dict_t *xdata)
+{
+ gfx_common_2iatt_rsp rsp = {
+ 0,
+ };
+ server_state_t *state = NULL;
+ rpcsvc_request_t *req = NULL;
+
+ req = frame->local;
+ state = CALL_STATE(frame);
+
+ dict_to_xdr(xdata, &rsp.xdata);
+
+ if (op_ret) {
+ gf_msg(this->name, fop_log_level(GF_FOP_ZEROFILL, op_errno), op_errno,
+ PS_MSG_ZEROFILL_INFO,
+ "%" PRId64 ": ZEROFILL%" PRId64
+ " (%s), client: %s, "
+ "error-xlator: %s",
+ frame->root->unique, state->resolve.fd_no,
+ uuid_utoa(state->resolve.gfid), STACK_CLIENT_NAME(frame->root),
+ STACK_ERR_XL_NAME(frame->root));
+ goto out;
+ }
+
+ server4_post_common_2iatt(&rsp, statpre, statpost);
out:
- rsp.op_ret = op_ret;
- rsp.op_errno = gf_errno_to_error (op_errno);
+ rsp.op_ret = op_ret;
+ rsp.op_errno = gf_errno_to_error(op_errno);
- server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
- (xdrproc_t) xdr_gfx_common_2iatt_rsp);
+ server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gfx_common_2iatt_rsp);
- GF_FREE (rsp.xdata.pairs.pairs_val);
+ GF_FREE(rsp.xdata.pairs.pairs_val);
- return 0;
+ return 0;
}
-
int
-server4_ipc_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
+server4_ipc_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
int32_t op_ret, int32_t op_errno, dict_t *xdata)
{
- gfx_common_rsp rsp = {0,};
- server_state_t *state = NULL;
- rpcsvc_request_t *req = NULL;
+ gfx_common_rsp rsp = {
+ 0,
+ };
+ server_state_t *state = NULL;
+ rpcsvc_request_t *req = NULL;
- req = frame->local;
- state = CALL_STATE (frame);
+ req = frame->local;
+ state = CALL_STATE(frame);
- dict_to_xdr (xdata, &rsp.xdata);
+ dict_to_xdr(xdata, &rsp.xdata);
- if (op_ret) {
- gf_msg (this->name, GF_LOG_INFO, op_errno,
- PS_MSG_SERVER_IPC_INFO,
- "%"PRId64": IPC%"PRId64" (%s), client: %s, "
- "error-xlator: %s",
- frame->root->unique, state->resolve.fd_no,
- uuid_utoa (state->resolve.gfid),
- STACK_CLIENT_NAME (frame->root),
- STACK_ERR_XL_NAME (frame->root));
- goto out;
- }
+ if (op_ret) {
+ gf_msg(this->name, GF_LOG_INFO, op_errno, PS_MSG_SERVER_IPC_INFO,
+ "%" PRId64 ": IPC%" PRId64
+ " (%s), client: %s, "
+ "error-xlator: %s",
+ frame->root->unique, state->resolve.fd_no,
+ uuid_utoa(state->resolve.gfid), STACK_CLIENT_NAME(frame->root),
+ STACK_ERR_XL_NAME(frame->root));
+ goto out;
+ }
out:
- rsp.op_ret = op_ret;
- rsp.op_errno = gf_errno_to_error (op_errno);
+ rsp.op_ret = op_ret;
+ rsp.op_errno = gf_errno_to_error(op_errno);
- server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
- (xdrproc_t) xdr_gfx_common_rsp);
+ server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gfx_common_rsp);
- GF_FREE (rsp.xdata.pairs.pairs_val);
+ GF_FREE(rsp.xdata.pairs.pairs_val);
- return 0;
+ return 0;
}
-
int
-server4_seek_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
+server4_seek_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
int32_t op_ret, int32_t op_errno, off_t offset, dict_t *xdata)
{
- struct gfx_seek_rsp rsp = {0, };
- server_state_t *state = NULL;
- rpcsvc_request_t *req = NULL;
-
- req = frame->local;
- state = CALL_STATE (frame);
-
- dict_to_xdr (xdata, &rsp.xdata);
-
- if (op_ret) {
- gf_msg (this->name, fop_log_level (GF_FOP_SEEK, op_errno),
- op_errno, PS_MSG_SEEK_INFO,
- "%"PRId64": SEEK%"PRId64" (%s), client: %s, "
- "error-xlator: %s",
- frame->root->unique, state->resolve.fd_no,
- uuid_utoa (state->resolve.gfid),
- STACK_CLIENT_NAME (frame->root),
- STACK_ERR_XL_NAME (frame->root));
- goto out;
- }
-
- server4_post_seek (&rsp, offset);
+ struct gfx_seek_rsp rsp = {
+ 0,
+ };
+ server_state_t *state = NULL;
+ rpcsvc_request_t *req = NULL;
+
+ req = frame->local;
+ state = CALL_STATE(frame);
+
+ dict_to_xdr(xdata, &rsp.xdata);
+
+ if (op_ret) {
+ gf_msg(this->name, fop_log_level(GF_FOP_SEEK, op_errno), op_errno,
+ PS_MSG_SEEK_INFO,
+ "%" PRId64 ": SEEK%" PRId64
+ " (%s), client: %s, "
+ "error-xlator: %s",
+ frame->root->unique, state->resolve.fd_no,
+ uuid_utoa(state->resolve.gfid), STACK_CLIENT_NAME(frame->root),
+ STACK_ERR_XL_NAME(frame->root));
+ goto out;
+ }
+
+ server4_post_seek(&rsp, offset);
out:
- rsp.op_ret = op_ret;
- rsp.op_errno = gf_errno_to_error (op_errno);
+ rsp.op_ret = op_ret;
+ rsp.op_errno = gf_errno_to_error(op_errno);
- server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
- (xdrproc_t) xdr_gfx_seek_rsp);
+ server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gfx_seek_rsp);
- GF_FREE (rsp.xdata.pairs.pairs_val);
+ GF_FREE(rsp.xdata.pairs.pairs_val);
- return 0;
+ return 0;
}
static int
-server4_setactivelk_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
+server4_setactivelk_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
int32_t op_ret, int32_t op_errno, dict_t *xdata)
{
- gfx_common_rsp rsp = {0,};
- server_state_t *state = NULL;
- rpcsvc_request_t *req = NULL;
+ gfx_common_rsp rsp = {
+ 0,
+ };
+ server_state_t *state = NULL;
+ rpcsvc_request_t *req = NULL;
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- dict_to_xdr (xdata, &rsp.xdata);
+ dict_to_xdr(xdata, &rsp.xdata);
- if (op_ret < 0) {
- state = CALL_STATE (frame);
- gf_msg (this->name, GF_LOG_INFO,
- op_errno, 0,
- "%"PRId64": SETACTIVELK %s (%s), client: %s, "
- "error-xlator: %s", frame->root->unique,
- state->loc.path, uuid_utoa (state->resolve.gfid),
- STACK_CLIENT_NAME (frame->root),
- STACK_ERR_XL_NAME (frame->root));
- goto out;
- }
+ if (op_ret < 0) {
+ state = CALL_STATE(frame);
+ gf_msg(this->name, GF_LOG_INFO, op_errno, 0,
+ "%" PRId64
+ ": SETACTIVELK %s (%s), client: %s, "
+ "error-xlator: %s",
+ frame->root->unique, state->loc.path,
+ uuid_utoa(state->resolve.gfid), STACK_CLIENT_NAME(frame->root),
+ STACK_ERR_XL_NAME(frame->root));
+ goto out;
+ }
out:
- rsp.op_ret = op_ret;
- rsp.op_errno = gf_errno_to_error (op_errno);
+ rsp.op_ret = op_ret;
+ rsp.op_errno = gf_errno_to_error(op_errno);
- req = frame->local;
+ req = frame->local;
- server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
- (xdrproc_t)xdr_gfx_common_rsp);
+ server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gfx_common_rsp);
- GF_FREE (rsp.xdata.pairs.pairs_val);
+ GF_FREE(rsp.xdata.pairs.pairs_val);
- return 0;
+ return 0;
}
int
-server4_namelink_cbk (call_frame_t *frame,
- void *cookie, xlator_t *this,
- int32_t op_ret, int32_t op_errno,
- struct iatt *prebuf, struct iatt *postbuf, dict_t *xdata)
+server4_namelink_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+ int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
+ struct iatt *postbuf, dict_t *xdata)
{
- gfx_common_2iatt_rsp rsp = {0,};
- rpcsvc_request_t *req = NULL;
+ gfx_common_2iatt_rsp rsp = {
+ 0,
+ };
+ rpcsvc_request_t *req = NULL;
- dict_to_xdr (xdata, &rsp.xdata);
- if (op_ret < 0)
- goto out;
+ dict_to_xdr(xdata, &rsp.xdata);
+ if (op_ret < 0)
+ goto out;
- gfx_stat_from_iattx (&rsp.prestat, prebuf);
- gfx_stat_from_iattx (&rsp.poststat, postbuf);
+ gfx_stat_from_iattx(&rsp.prestat, prebuf);
+ gfx_stat_from_iattx(&rsp.poststat, postbuf);
- /**
- * no point in linking inode here -- there's no stbuf anyway and a
- * lookup() for this name entry would be a negative lookup.
- */
+ /**
+ * no point in linking inode here -- there's no stbuf anyway and a
+ * lookup() for this name entry would be a negative lookup.
+ */
out:
- rsp.op_ret = op_ret;
- rsp.op_errno = gf_errno_to_error (op_errno);
+ rsp.op_ret = op_ret;
+ rsp.op_errno = gf_errno_to_error(op_errno);
- req = frame->local;
- server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
- (xdrproc_t)xdr_gfx_common_2iatt_rsp);
+ req = frame->local;
+ server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gfx_common_2iatt_rsp);
- GF_FREE (rsp.xdata.pairs.pairs_val);
+ GF_FREE(rsp.xdata.pairs.pairs_val);
- return 0;
+ return 0;
}
int
-server4_icreate_cbk (call_frame_t *frame,
- void *cookie, xlator_t *this,
- int32_t op_ret, int32_t op_errno,
- inode_t *inode, struct iatt *stbuf, dict_t *xdata)
+server4_icreate_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
+ int32_t op_ret, int32_t op_errno, inode_t *inode,
+ struct iatt *stbuf, dict_t *xdata)
{
- server_state_t *state = NULL;
- inode_t *link_inode = NULL;
- rpcsvc_request_t *req = NULL;
- gfx_common_iatt_rsp rsp = {0,};
+ server_state_t *state = NULL;
+ inode_t *link_inode = NULL;
+ rpcsvc_request_t *req = NULL;
+ gfx_common_iatt_rsp rsp = {
+ 0,
+ };
- dict_to_xdr (xdata, &rsp.xdata);
- state = CALL_STATE (frame);
+ dict_to_xdr(xdata, &rsp.xdata);
+ state = CALL_STATE(frame);
- if (op_ret < 0) {
- gf_msg (this->name, GF_LOG_INFO, op_errno, PS_MSG_CREATE_INFO,
- "%"PRId64": ICREATE [%s] ==> (%s)",
- frame->root->unique, uuid_utoa (state->resolve.gfid),
- strerror (op_errno));
- goto out;
- }
+ if (op_ret < 0) {
+ gf_msg(this->name, GF_LOG_INFO, op_errno, PS_MSG_CREATE_INFO,
+ "%" PRId64 ": ICREATE [%s] ==> (%s)", frame->root->unique,
+ uuid_utoa(state->resolve.gfid), strerror(op_errno));
+ goto out;
+ }
- gf_msg_trace (frame->root->client->bound_xl->name, 0, "%"PRId64": "
- "ICREATE [%s]", frame->root->unique,
- uuid_utoa (stbuf->ia_gfid));
+ gf_msg_trace(frame->root->client->bound_xl->name, 0,
+ "%" PRId64
+ ": "
+ "ICREATE [%s]",
+ frame->root->unique, uuid_utoa(stbuf->ia_gfid));
- link_inode = inode_link (inode,
- state->loc.parent, state->loc.name, stbuf);
+ link_inode = inode_link(inode, state->loc.parent, state->loc.name, stbuf);
- if (!link_inode) {
- op_ret = -1;
- op_errno = ENOENT;
- goto out;
- }
+ if (!link_inode) {
+ op_ret = -1;
+ op_errno = ENOENT;
+ goto out;
+ }
- inode_lookup (link_inode);
- inode_unref (link_inode);
+ inode_lookup(link_inode);
+ inode_unref(link_inode);
- gfx_stat_from_iattx (&rsp.stat, stbuf);
+ gfx_stat_from_iattx(&rsp.stat, stbuf);
out:
- rsp.op_ret = op_ret;
- rsp.op_errno = gf_errno_to_error (op_errno);
+ rsp.op_ret = op_ret;
+ rsp.op_errno = gf_errno_to_error(op_errno);
- req = frame->local;
- server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
- (xdrproc_t)xdr_gfx_common_iatt_rsp);
+ req = frame->local;
+ server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gfx_common_iatt_rsp);
- GF_FREE (rsp.xdata.pairs.pairs_val);
+ GF_FREE(rsp.xdata.pairs.pairs_val);
- return 0;
+ return 0;
}
int
-server4_put_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
+server4_put_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
int32_t op_ret, int32_t op_errno, inode_t *inode,
struct iatt *stbuf, struct iatt *preparent,
struct iatt *postparent, dict_t *xdata)
{
- server_state_t *state = NULL;
- rpcsvc_request_t *req = NULL;
- gfx_common_3iatt_rsp rsp = {0,};
+ server_state_t *state = NULL;
+ rpcsvc_request_t *req = NULL;
+ gfx_common_3iatt_rsp rsp = {
+ 0,
+ };
- dict_to_xdr (xdata, &rsp.xdata);
+ dict_to_xdr(xdata, &rsp.xdata);
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (op_ret < 0) {
- gf_msg (this->name, GF_LOG_INFO, op_errno, PS_MSG_PUT_INFO,
- "%"PRId64": PUT %s (%s/%s), client: %s, "
- "error-xlator: %s", frame->root->unique,
- state->loc.path, uuid_utoa (state->resolve.pargfid),
- state->resolve.bname, STACK_CLIENT_NAME (frame->root),
- STACK_ERR_XL_NAME (frame->root));
- goto out;
- }
+ if (op_ret < 0) {
+ gf_msg(this->name, GF_LOG_INFO, op_errno, PS_MSG_PUT_INFO,
+ "%" PRId64
+ ": PUT %s (%s/%s), client: %s, "
+ "error-xlator: %s",
+ frame->root->unique, state->loc.path,
+ uuid_utoa(state->resolve.pargfid), state->resolve.bname,
+ STACK_CLIENT_NAME(frame->root), STACK_ERR_XL_NAME(frame->root));
+ goto out;
+ }
- gf_msg_trace (frame->root->client->bound_xl->name, 0, "%"PRId64": "
- "PUT %s (%s)", frame->root->unique, state->loc.name,
- uuid_utoa (stbuf->ia_gfid));
+ gf_msg_trace(frame->root->client->bound_xl->name, 0,
+ "%" PRId64
+ ": "
+ "PUT %s (%s)",
+ frame->root->unique, state->loc.name,
+ uuid_utoa(stbuf->ia_gfid));
- server4_post_common_3iatt (state, &rsp, inode, stbuf, preparent,
- postparent);
+ server4_post_common_3iatt(state, &rsp, inode, stbuf, preparent, postparent);
out:
- rsp.op_ret = op_ret;
- rsp.op_errno = gf_errno_to_error (op_errno);
+ rsp.op_ret = op_ret;
+ rsp.op_errno = gf_errno_to_error(op_errno);
- req = frame->local;
- server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
- (xdrproc_t)xdr_gfx_common_3iatt_rsp);
+ req = frame->local;
+ server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gfx_common_3iatt_rsp);
- GF_FREE (rsp.xdata.pairs.pairs_val);
+ GF_FREE(rsp.xdata.pairs.pairs_val);
- return 0;
+ return 0;
}
/* Resume function section */
int
-server4_rchecksum_resume (call_frame_t *frame, xlator_t *bound_xl)
+server4_rchecksum_resume(call_frame_t *frame, xlator_t *bound_xl)
{
- server_state_t *state = NULL;
- int op_ret = 0;
- int op_errno = EINVAL;
+ server_state_t *state = NULL;
+ int op_ret = 0;
+ int op_errno = EINVAL;
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (state->resolve.op_ret != 0) {
- op_ret = state->resolve.op_ret;
- op_errno = state->resolve.op_errno;
- goto err;
- }
+ if (state->resolve.op_ret != 0) {
+ op_ret = state->resolve.op_ret;
+ op_errno = state->resolve.op_errno;
+ goto err;
+ }
- STACK_WIND (frame, server4_rchecksum_cbk, bound_xl,
- bound_xl->fops->rchecksum, state->fd,
- state->offset, state->size, state->xdata);
+ STACK_WIND(frame, server4_rchecksum_cbk, bound_xl,
+ bound_xl->fops->rchecksum, state->fd, state->offset, state->size,
+ state->xdata);
- return 0;
+ return 0;
err:
- server4_rchecksum_cbk (frame, NULL, frame->this, op_ret, op_errno, 0,
- NULL, NULL);
-
- return 0;
+ server4_rchecksum_cbk(frame, NULL, frame->this, op_ret, op_errno, 0, NULL,
+ NULL);
+ return 0;
}
int
-server4_lease_resume (call_frame_t *frame, xlator_t *bound_xl)
+server4_lease_resume(call_frame_t *frame, xlator_t *bound_xl)
{
- server_state_t *state = NULL;
+ server_state_t *state = NULL;
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (state->resolve.op_ret != 0)
- goto err;
+ if (state->resolve.op_ret != 0)
+ goto err;
- STACK_WIND (frame, server4_lease_cbk, bound_xl, bound_xl->fops->lease,
- &state->loc, &state->lease, state->xdata);
+ STACK_WIND(frame, server4_lease_cbk, bound_xl, bound_xl->fops->lease,
+ &state->loc, &state->lease, state->xdata);
- return 0;
+ return 0;
err:
- server4_lease_cbk (frame, NULL, frame->this, state->resolve.op_ret,
- state->resolve.op_errno, NULL, NULL);
- return 0;
+ server4_lease_cbk(frame, NULL, frame->this, state->resolve.op_ret,
+ state->resolve.op_errno, NULL, NULL);
+ return 0;
}
int
-server4_put_resume (call_frame_t *frame, xlator_t *bound_xl)
+server4_put_resume(call_frame_t *frame, xlator_t *bound_xl)
{
- server_state_t *state = NULL;
+ server_state_t *state = NULL;
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (state->resolve.op_ret != 0)
- goto err;
+ if (state->resolve.op_ret != 0)
+ goto err;
- state->loc.inode = inode_new (state->itable);
+ state->loc.inode = inode_new(state->itable);
- STACK_WIND (frame, server4_put_cbk,
- bound_xl, bound_xl->fops->put,
- &(state->loc), state->mode, state->umask, state->flags,
- state->payload_vector, state->payload_count, state->offset,
- state->iobref, state->dict, state->xdata);
+ STACK_WIND(frame, server4_put_cbk, bound_xl, bound_xl->fops->put,
+ &(state->loc), state->mode, state->umask, state->flags,
+ state->payload_vector, state->payload_count, state->offset,
+ state->iobref, state->dict, state->xdata);
- return 0;
+ return 0;
err:
- server4_put_cbk (frame, NULL, frame->this, state->resolve.op_ret,
- state->resolve.op_errno, NULL, NULL, NULL,
- NULL, NULL);
- return 0;
+ server4_put_cbk(frame, NULL, frame->this, state->resolve.op_ret,
+ state->resolve.op_errno, NULL, NULL, NULL, NULL, NULL);
+ return 0;
}
int
-server4_lk_resume (call_frame_t *frame, xlator_t *bound_xl)
+server4_lk_resume(call_frame_t *frame, xlator_t *bound_xl)
{
- server_state_t *state = NULL;
+ server_state_t *state = NULL;
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (state->resolve.op_ret != 0)
- goto err;
+ if (state->resolve.op_ret != 0)
+ goto err;
- STACK_WIND (frame, server4_lk_cbk, bound_xl, bound_xl->fops->lk,
- state->fd, state->cmd, &state->flock, state->xdata);
+ STACK_WIND(frame, server4_lk_cbk, bound_xl, bound_xl->fops->lk, state->fd,
+ state->cmd, &state->flock, state->xdata);
- return 0;
+ return 0;
err:
- server4_lk_cbk (frame, NULL, frame->this, state->resolve.op_ret,
- state->resolve.op_errno, NULL, NULL);
- return 0;
+ server4_lk_cbk(frame, NULL, frame->this, state->resolve.op_ret,
+ state->resolve.op_errno, NULL, NULL);
+ return 0;
}
int
-server4_rename_resume (call_frame_t *frame, xlator_t *bound_xl)
+server4_rename_resume(call_frame_t *frame, xlator_t *bound_xl)
{
- server_state_t *state = NULL;
- int op_ret = 0;
- int op_errno = 0;
+ server_state_t *state = NULL;
+ int op_ret = 0;
+ int op_errno = 0;
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (state->resolve.op_ret != 0) {
- op_ret = state->resolve.op_ret;
- op_errno = state->resolve.op_errno;
- goto err;
- }
+ if (state->resolve.op_ret != 0) {
+ op_ret = state->resolve.op_ret;
+ op_errno = state->resolve.op_errno;
+ goto err;
+ }
- if (state->resolve2.op_ret != 0) {
- op_ret = state->resolve2.op_ret;
- op_errno = state->resolve2.op_errno;
- goto err;
- }
+ if (state->resolve2.op_ret != 0) {
+ op_ret = state->resolve2.op_ret;
+ op_errno = state->resolve2.op_errno;
+ goto err;
+ }
- STACK_WIND (frame, server4_rename_cbk,
- bound_xl, bound_xl->fops->rename,
- &state->loc, &state->loc2, state->xdata);
- return 0;
+ STACK_WIND(frame, server4_rename_cbk, bound_xl, bound_xl->fops->rename,
+ &state->loc, &state->loc2, state->xdata);
+ return 0;
err:
- server4_rename_cbk (frame, NULL, frame->this, op_ret, op_errno,
- NULL, NULL, NULL, NULL, NULL, NULL);
- return 0;
+ server4_rename_cbk(frame, NULL, frame->this, op_ret, op_errno, NULL, NULL,
+ NULL, NULL, NULL, NULL);
+ return 0;
}
-
int
-server4_link_resume (call_frame_t *frame, xlator_t *bound_xl)
+server4_link_resume(call_frame_t *frame, xlator_t *bound_xl)
{
- server_state_t *state = NULL;
- int op_ret = 0;
- int op_errno = 0;
+ server_state_t *state = NULL;
+ int op_ret = 0;
+ int op_errno = 0;
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (state->resolve.op_ret != 0) {
- op_ret = state->resolve.op_ret;
- op_errno = state->resolve.op_errno;
- goto err;
- }
+ if (state->resolve.op_ret != 0) {
+ op_ret = state->resolve.op_ret;
+ op_errno = state->resolve.op_errno;
+ goto err;
+ }
- if (state->resolve2.op_ret != 0) {
- op_ret = state->resolve2.op_ret;
- op_errno = state->resolve2.op_errno;
- goto err;
- }
+ if (state->resolve2.op_ret != 0) {
+ op_ret = state->resolve2.op_ret;
+ op_errno = state->resolve2.op_errno;
+ goto err;
+ }
- state->loc2.inode = inode_ref (state->loc.inode);
+ state->loc2.inode = inode_ref(state->loc.inode);
- STACK_WIND (frame, server4_link_cbk, bound_xl, bound_xl->fops->link,
- &state->loc, &state->loc2, state->xdata);
+ STACK_WIND(frame, server4_link_cbk, bound_xl, bound_xl->fops->link,
+ &state->loc, &state->loc2, state->xdata);
- return 0;
+ return 0;
err:
- server4_link_cbk (frame, NULL, frame->this, op_ret, op_errno,
- NULL, NULL, NULL, NULL, NULL);
- return 0;
+ server4_link_cbk(frame, NULL, frame->this, op_ret, op_errno, NULL, NULL,
+ NULL, NULL, NULL);
+ return 0;
}
int
-server4_symlink_resume (call_frame_t *frame, xlator_t *bound_xl)
+server4_symlink_resume(call_frame_t *frame, xlator_t *bound_xl)
{
- server_state_t *state = NULL;
+ server_state_t *state = NULL;
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (state->resolve.op_ret != 0)
- goto err;
+ if (state->resolve.op_ret != 0)
+ goto err;
- state->loc.inode = inode_new (state->itable);
+ state->loc.inode = inode_new(state->itable);
- STACK_WIND (frame, server4_symlink_cbk,
- bound_xl, bound_xl->fops->symlink,
- state->name, &state->loc, state->umask, state->xdata);
+ STACK_WIND(frame, server4_symlink_cbk, bound_xl, bound_xl->fops->symlink,
+ state->name, &state->loc, state->umask, state->xdata);
- return 0;
+ return 0;
err:
- server4_symlink_cbk (frame, NULL, frame->this, state->resolve.op_ret,
- state->resolve.op_errno, NULL, NULL, NULL, NULL, NULL);
- return 0;
+ server4_symlink_cbk(frame, NULL, frame->this, state->resolve.op_ret,
+ state->resolve.op_errno, NULL, NULL, NULL, NULL, NULL);
+ return 0;
}
-
int
-server4_access_resume (call_frame_t *frame, xlator_t *bound_xl)
+server4_access_resume(call_frame_t *frame, xlator_t *bound_xl)
{
- server_state_t *state = NULL;
+ server_state_t *state = NULL;
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (state->resolve.op_ret != 0)
- goto err;
+ if (state->resolve.op_ret != 0)
+ goto err;
- STACK_WIND (frame, server4_access_cbk,
- bound_xl, bound_xl->fops->access,
- &state->loc, state->mask, state->xdata);
- return 0;
+ STACK_WIND(frame, server4_access_cbk, bound_xl, bound_xl->fops->access,
+ &state->loc, state->mask, state->xdata);
+ return 0;
err:
- server4_access_cbk (frame, NULL, frame->this, state->resolve.op_ret,
- state->resolve.op_errno, NULL);
- return 0;
+ server4_access_cbk(frame, NULL, frame->this, state->resolve.op_ret,
+ state->resolve.op_errno, NULL);
+ return 0;
}
int
-server4_fentrylk_resume (call_frame_t *frame, xlator_t *bound_xl)
+server4_fentrylk_resume(call_frame_t *frame, xlator_t *bound_xl)
{
- GF_UNUSED int ret = -1;
- server_state_t *state = NULL;
+ GF_UNUSED int ret = -1;
+ server_state_t *state = NULL;
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (state->resolve.op_ret != 0)
- goto err;
+ if (state->resolve.op_ret != 0)
+ goto err;
- if (!state->xdata)
- state->xdata = dict_new ();
+ if (!state->xdata)
+ state->xdata = dict_new();
- if (state->xdata)
- ret = dict_set_str (state->xdata, "connection-id",
- frame->root->client->client_uid);
+ if (state->xdata)
+ ret = dict_set_str(state->xdata, "connection-id",
+ frame->root->client->client_uid);
- STACK_WIND (frame, server4_fentrylk_cbk, bound_xl,
- bound_xl->fops->fentrylk,
- state->volume, state->fd, state->name,
- state->cmd, state->type, state->xdata);
+ STACK_WIND(frame, server4_fentrylk_cbk, bound_xl, bound_xl->fops->fentrylk,
+ state->volume, state->fd, state->name, state->cmd, state->type,
+ state->xdata);
- return 0;
+ return 0;
err:
- server4_fentrylk_cbk (frame, NULL, frame->this, state->resolve.op_ret,
- state->resolve.op_errno, NULL);
- return 0;
+ server4_fentrylk_cbk(frame, NULL, frame->this, state->resolve.op_ret,
+ state->resolve.op_errno, NULL);
+ return 0;
}
-
int
-server4_entrylk_resume (call_frame_t *frame, xlator_t *bound_xl)
+server4_entrylk_resume(call_frame_t *frame, xlator_t *bound_xl)
{
- GF_UNUSED int ret = -1;
- server_state_t *state = NULL;
+ GF_UNUSED int ret = -1;
+ server_state_t *state = NULL;
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (state->resolve.op_ret != 0)
- goto err;
+ if (state->resolve.op_ret != 0)
+ goto err;
- if (!state->xdata)
- state->xdata = dict_new ();
+ if (!state->xdata)
+ state->xdata = dict_new();
- if (state->xdata)
- ret = dict_set_str (state->xdata, "connection-id",
- frame->root->client->client_uid);
+ if (state->xdata)
+ ret = dict_set_str(state->xdata, "connection-id",
+ frame->root->client->client_uid);
- STACK_WIND (frame, server4_entrylk_cbk,
- bound_xl, bound_xl->fops->entrylk,
- state->volume, &state->loc, state->name,
- state->cmd, state->type, state->xdata);
- return 0;
+ STACK_WIND(frame, server4_entrylk_cbk, bound_xl, bound_xl->fops->entrylk,
+ state->volume, &state->loc, state->name, state->cmd, state->type,
+ state->xdata);
+ return 0;
err:
- server4_entrylk_cbk (frame, NULL, frame->this, state->resolve.op_ret,
- state->resolve.op_errno, NULL);
- return 0;
+ server4_entrylk_cbk(frame, NULL, frame->this, state->resolve.op_ret,
+ state->resolve.op_errno, NULL);
+ return 0;
}
-
int
-server4_finodelk_resume (call_frame_t *frame, xlator_t *bound_xl)
+server4_finodelk_resume(call_frame_t *frame, xlator_t *bound_xl)
{
- GF_UNUSED int ret = -1;
- server_state_t *state = NULL;
+ GF_UNUSED int ret = -1;
+ server_state_t *state = NULL;
- gf_msg_debug (bound_xl->name, 0, "frame %p, xlator %p", frame,
- bound_xl);
+ gf_msg_debug(bound_xl->name, 0, "frame %p, xlator %p", frame, bound_xl);
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (state->resolve.op_ret != 0)
- goto err;
+ if (state->resolve.op_ret != 0)
+ goto err;
- if (!state->xdata)
- state->xdata = dict_new ();
+ if (!state->xdata)
+ state->xdata = dict_new();
- if (state->xdata)
- ret = dict_set_str (state->xdata, "connection-id",
- frame->root->client->client_uid);
+ if (state->xdata)
+ ret = dict_set_str(state->xdata, "connection-id",
+ frame->root->client->client_uid);
- STACK_WIND (frame, server4_finodelk_cbk, bound_xl,
- bound_xl->fops->finodelk, state->volume, state->fd,
- state->cmd, &state->flock, state->xdata);
+ STACK_WIND(frame, server4_finodelk_cbk, bound_xl, bound_xl->fops->finodelk,
+ state->volume, state->fd, state->cmd, &state->flock,
+ state->xdata);
- return 0;
+ return 0;
err:
- server4_finodelk_cbk (frame, NULL, frame->this, state->resolve.op_ret,
- state->resolve.op_errno, NULL);
+ server4_finodelk_cbk(frame, NULL, frame->this, state->resolve.op_ret,
+ state->resolve.op_errno, NULL);
- return 0;
+ return 0;
}
int
-server4_inodelk_resume (call_frame_t *frame, xlator_t *bound_xl)
+server4_inodelk_resume(call_frame_t *frame, xlator_t *bound_xl)
{
- GF_UNUSED int ret = -1;
- server_state_t *state = NULL;
+ GF_UNUSED int ret = -1;
+ server_state_t *state = NULL;
- gf_msg_debug (bound_xl->name, 0, "frame %p, xlator %p", frame,
- bound_xl);
+ gf_msg_debug(bound_xl->name, 0, "frame %p, xlator %p", frame, bound_xl);
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (state->resolve.op_ret != 0)
- goto err;
+ if (state->resolve.op_ret != 0)
+ goto err;
- if (!state->xdata)
- state->xdata = dict_new ();
+ if (!state->xdata)
+ state->xdata = dict_new();
- if (state->xdata)
- ret = dict_set_str (state->xdata, "connection-id",
- frame->root->client->client_uid);
+ if (state->xdata)
+ ret = dict_set_str(state->xdata, "connection-id",
+ frame->root->client->client_uid);
- STACK_WIND (frame, server4_inodelk_cbk, bound_xl,
- bound_xl->fops->inodelk, state->volume, &state->loc,
- state->cmd, &state->flock, state->xdata);
- return 0;
+ STACK_WIND(frame, server4_inodelk_cbk, bound_xl, bound_xl->fops->inodelk,
+ state->volume, &state->loc, state->cmd, &state->flock,
+ state->xdata);
+ return 0;
err:
- server4_inodelk_cbk (frame, NULL, frame->this, state->resolve.op_ret,
- state->resolve.op_errno, NULL);
- return 0;
+ server4_inodelk_cbk(frame, NULL, frame->this, state->resolve.op_ret,
+ state->resolve.op_errno, NULL);
+ return 0;
}
int
-server4_rmdir_resume (call_frame_t *frame, xlator_t *bound_xl)
+server4_rmdir_resume(call_frame_t *frame, xlator_t *bound_xl)
{
- server_state_t *state = NULL;
+ server_state_t *state = NULL;
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (state->resolve.op_ret != 0)
- goto err;
+ if (state->resolve.op_ret != 0)
+ goto err;
- STACK_WIND (frame, server4_rmdir_cbk, bound_xl, bound_xl->fops->rmdir,
- &state->loc, state->flags, state->xdata);
- return 0;
+ STACK_WIND(frame, server4_rmdir_cbk, bound_xl, bound_xl->fops->rmdir,
+ &state->loc, state->flags, state->xdata);
+ return 0;
err:
- server4_rmdir_cbk (frame, NULL, frame->this, state->resolve.op_ret,
- state->resolve.op_errno, NULL, NULL, NULL);
- return 0;
+ server4_rmdir_cbk(frame, NULL, frame->this, state->resolve.op_ret,
+ state->resolve.op_errno, NULL, NULL, NULL);
+ return 0;
}
int
-server4_mkdir_resume (call_frame_t *frame, xlator_t *bound_xl)
+server4_mkdir_resume(call_frame_t *frame, xlator_t *bound_xl)
{
- server_state_t *state = NULL;
+ server_state_t *state = NULL;
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (state->resolve.op_ret != 0)
- goto err;
+ if (state->resolve.op_ret != 0)
+ goto err;
- state->loc.inode = inode_new (state->itable);
+ state->loc.inode = inode_new(state->itable);
- STACK_WIND (frame, server4_mkdir_cbk,
- bound_xl, bound_xl->fops->mkdir,
- &(state->loc), state->mode, state->umask, state->xdata);
+ STACK_WIND(frame, server4_mkdir_cbk, bound_xl, bound_xl->fops->mkdir,
+ &(state->loc), state->mode, state->umask, state->xdata);
- return 0;
+ return 0;
err:
- server4_mkdir_cbk (frame, NULL, frame->this, state->resolve.op_ret,
- state->resolve.op_errno, NULL, NULL, NULL, NULL, NULL);
- return 0;
+ server4_mkdir_cbk(frame, NULL, frame->this, state->resolve.op_ret,
+ state->resolve.op_errno, NULL, NULL, NULL, NULL, NULL);
+ return 0;
}
-
int
-server4_mknod_resume (call_frame_t *frame, xlator_t *bound_xl)
+server4_mknod_resume(call_frame_t *frame, xlator_t *bound_xl)
{
- server_state_t *state = NULL;
+ server_state_t *state = NULL;
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (state->resolve.op_ret != 0)
- goto err;
+ if (state->resolve.op_ret != 0)
+ goto err;
- state->loc.inode = inode_new (state->itable);
+ state->loc.inode = inode_new(state->itable);
- STACK_WIND (frame, server4_mknod_cbk,
- bound_xl, bound_xl->fops->mknod,
- &(state->loc), state->mode, state->dev,
- state->umask, state->xdata);
+ STACK_WIND(frame, server4_mknod_cbk, bound_xl, bound_xl->fops->mknod,
+ &(state->loc), state->mode, state->dev, state->umask,
+ state->xdata);
- return 0;
+ return 0;
err:
- server4_mknod_cbk (frame, NULL, frame->this, state->resolve.op_ret,
- state->resolve.op_errno, NULL, NULL, NULL, NULL, NULL);
- return 0;
+ server4_mknod_cbk(frame, NULL, frame->this, state->resolve.op_ret,
+ state->resolve.op_errno, NULL, NULL, NULL, NULL, NULL);
+ return 0;
}
-
int
-server4_fsyncdir_resume (call_frame_t *frame, xlator_t *bound_xl)
+server4_fsyncdir_resume(call_frame_t *frame, xlator_t *bound_xl)
{
- server_state_t *state = NULL;
+ server_state_t *state = NULL;
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (state->resolve.op_ret != 0)
- goto err;
+ if (state->resolve.op_ret != 0)
+ goto err;
- STACK_WIND (frame, server4_fsyncdir_cbk,
- bound_xl,
- bound_xl->fops->fsyncdir,
- state->fd, state->flags, state->xdata);
- return 0;
+ STACK_WIND(frame, server4_fsyncdir_cbk, bound_xl, bound_xl->fops->fsyncdir,
+ state->fd, state->flags, state->xdata);
+ return 0;
err:
- server4_fsyncdir_cbk (frame, NULL, frame->this,
- state->resolve.op_ret,
- state->resolve.op_errno, NULL);
- return 0;
+ server4_fsyncdir_cbk(frame, NULL, frame->this, state->resolve.op_ret,
+ state->resolve.op_errno, NULL);
+ return 0;
}
-
int
-server4_readdir_resume (call_frame_t *frame, xlator_t *bound_xl)
+server4_readdir_resume(call_frame_t *frame, xlator_t *bound_xl)
{
- server_state_t *state = NULL;
+ server_state_t *state = NULL;
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (state->resolve.op_ret != 0)
- goto err;
+ if (state->resolve.op_ret != 0)
+ goto err;
- GF_ASSERT (state->fd);
+ GF_ASSERT(state->fd);
- STACK_WIND (frame, server4_readdir_cbk,
- bound_xl,
- bound_xl->fops->readdir,
- state->fd, state->size, state->offset, state->xdata);
+ STACK_WIND(frame, server4_readdir_cbk, bound_xl, bound_xl->fops->readdir,
+ state->fd, state->size, state->offset, state->xdata);
- return 0;
+ return 0;
err:
- server4_readdir_cbk (frame, NULL, frame->this, state->resolve.op_ret,
- state->resolve.op_errno, NULL, NULL);
- return 0;
+ server4_readdir_cbk(frame, NULL, frame->this, state->resolve.op_ret,
+ state->resolve.op_errno, NULL, NULL);
+ return 0;
}
int
-server4_readdirp_resume (call_frame_t *frame, xlator_t *bound_xl)
+server4_readdirp_resume(call_frame_t *frame, xlator_t *bound_xl)
{
- server_state_t *state = NULL;
+ server_state_t *state = NULL;
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (state->resolve.op_ret != 0)
- goto err;
+ if (state->resolve.op_ret != 0)
+ goto err;
- STACK_WIND (frame, server4_readdirp_cbk, bound_xl,
- bound_xl->fops->readdirp, state->fd, state->size,
- state->offset, state->xdata);
+ STACK_WIND(frame, server4_readdirp_cbk, bound_xl, bound_xl->fops->readdirp,
+ state->fd, state->size, state->offset, state->xdata);
- return 0;
+ return 0;
err:
- server4_readdirp_cbk (frame, NULL, frame->this, state->resolve.op_ret,
- state->resolve.op_errno, NULL, NULL);
- return 0;
+ server4_readdirp_cbk(frame, NULL, frame->this, state->resolve.op_ret,
+ state->resolve.op_errno, NULL, NULL);
+ return 0;
}
-
int
-server4_opendir_resume (call_frame_t *frame, xlator_t *bound_xl)
+server4_opendir_resume(call_frame_t *frame, xlator_t *bound_xl)
{
- server_state_t *state = NULL;
+ server_state_t *state = NULL;
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (state->resolve.op_ret != 0)
- goto err;
+ if (state->resolve.op_ret != 0)
+ goto err;
- state->fd = fd_create (state->loc.inode, frame->root->pid);
- if (!state->fd) {
- gf_msg ("server", GF_LOG_ERROR, 0, PS_MSG_FD_CREATE_FAILED,
- "could not create the fd");
- goto err;
- }
+ state->fd = fd_create(state->loc.inode, frame->root->pid);
+ if (!state->fd) {
+ gf_msg("server", GF_LOG_ERROR, 0, PS_MSG_FD_CREATE_FAILED,
+ "could not create the fd");
+ goto err;
+ }
- STACK_WIND (frame, server4_opendir_cbk,
- bound_xl, bound_xl->fops->opendir,
- &state->loc, state->fd, state->xdata);
- return 0;
+ STACK_WIND(frame, server4_opendir_cbk, bound_xl, bound_xl->fops->opendir,
+ &state->loc, state->fd, state->xdata);
+ return 0;
err:
- server4_opendir_cbk (frame, NULL, frame->this, state->resolve.op_ret,
- state->resolve.op_errno, NULL, NULL);
- return 0;
+ server4_opendir_cbk(frame, NULL, frame->this, state->resolve.op_ret,
+ state->resolve.op_errno, NULL, NULL);
+ return 0;
}
-
int
-server4_statfs_resume (call_frame_t *frame, xlator_t *bound_xl)
+server4_statfs_resume(call_frame_t *frame, xlator_t *bound_xl)
{
- server_state_t *state = NULL;
+ server_state_t *state = NULL;
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (state->resolve.op_ret != 0)
- goto err;
+ if (state->resolve.op_ret != 0)
+ goto err;
- STACK_WIND (frame, server4_statfs_cbk,
- bound_xl, bound_xl->fops->statfs,
- &state->loc, state->xdata);
- return 0;
+ STACK_WIND(frame, server4_statfs_cbk, bound_xl, bound_xl->fops->statfs,
+ &state->loc, state->xdata);
+ return 0;
err:
- server4_statfs_cbk (frame, NULL, frame->this, state->resolve.op_ret,
- state->resolve.op_errno, NULL, NULL);
- return 0;
+ server4_statfs_cbk(frame, NULL, frame->this, state->resolve.op_ret,
+ state->resolve.op_errno, NULL, NULL);
+ return 0;
}
-
int
-server4_removexattr_resume (call_frame_t *frame, xlator_t *bound_xl)
+server4_removexattr_resume(call_frame_t *frame, xlator_t *bound_xl)
{
- server_state_t *state = NULL;
+ server_state_t *state = NULL;
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (state->resolve.op_ret != 0)
- goto err;
+ if (state->resolve.op_ret != 0)
+ goto err;
- STACK_WIND (frame, server4_removexattr_cbk,
- bound_xl, bound_xl->fops->removexattr,
- &state->loc, state->name, state->xdata);
- return 0;
+ STACK_WIND(frame, server4_removexattr_cbk, bound_xl,
+ bound_xl->fops->removexattr, &state->loc, state->name,
+ state->xdata);
+ return 0;
err:
- server4_removexattr_cbk (frame, NULL, frame->this, state->resolve.op_ret,
- state->resolve.op_errno, NULL);
- return 0;
+ server4_removexattr_cbk(frame, NULL, frame->this, state->resolve.op_ret,
+ state->resolve.op_errno, NULL);
+ return 0;
}
int
-server4_fremovexattr_resume (call_frame_t *frame, xlator_t *bound_xl)
+server4_fremovexattr_resume(call_frame_t *frame, xlator_t *bound_xl)
{
- server_state_t *state = NULL;
+ server_state_t *state = NULL;
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (state->resolve.op_ret != 0)
- goto err;
+ if (state->resolve.op_ret != 0)
+ goto err;
- STACK_WIND (frame, server4_fremovexattr_cbk,
- bound_xl, bound_xl->fops->fremovexattr,
- state->fd, state->name, state->xdata);
- return 0;
+ STACK_WIND(frame, server4_fremovexattr_cbk, bound_xl,
+ bound_xl->fops->fremovexattr, state->fd, state->name,
+ state->xdata);
+ return 0;
err:
- server4_fremovexattr_cbk (frame, NULL, frame->this, state->resolve.op_ret,
- state->resolve.op_errno, NULL);
- return 0;
+ server4_fremovexattr_cbk(frame, NULL, frame->this, state->resolve.op_ret,
+ state->resolve.op_errno, NULL);
+ return 0;
}
int
-server4_fgetxattr_resume (call_frame_t *frame, xlator_t *bound_xl)
+server4_fgetxattr_resume(call_frame_t *frame, xlator_t *bound_xl)
{
- server_state_t *state = NULL;
+ server_state_t *state = NULL;
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (state->resolve.op_ret != 0)
- goto err;
+ if (state->resolve.op_ret != 0)
+ goto err;
- STACK_WIND (frame, server4_fgetxattr_cbk,
- bound_xl, bound_xl->fops->fgetxattr,
- state->fd, state->name, state->xdata);
- return 0;
+ STACK_WIND(frame, server4_fgetxattr_cbk, bound_xl,
+ bound_xl->fops->fgetxattr, state->fd, state->name, state->xdata);
+ return 0;
err:
- server4_fgetxattr_cbk (frame, NULL, frame->this, state->resolve.op_ret,
- state->resolve.op_errno, NULL, NULL);
- return 0;
+ server4_fgetxattr_cbk(frame, NULL, frame->this, state->resolve.op_ret,
+ state->resolve.op_errno, NULL, NULL);
+ return 0;
}
-
int
-server4_xattrop_resume (call_frame_t *frame, xlator_t *bound_xl)
+server4_xattrop_resume(call_frame_t *frame, xlator_t *bound_xl)
{
- server_state_t *state = NULL;
+ server_state_t *state = NULL;
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (state->resolve.op_ret != 0)
- goto err;
+ if (state->resolve.op_ret != 0)
+ goto err;
- STACK_WIND (frame, server4_xattrop_cbk,
- bound_xl, bound_xl->fops->xattrop,
- &state->loc, state->flags, state->dict, state->xdata);
- return 0;
+ STACK_WIND(frame, server4_xattrop_cbk, bound_xl, bound_xl->fops->xattrop,
+ &state->loc, state->flags, state->dict, state->xdata);
+ return 0;
err:
- server4_xattrop_cbk (frame, NULL, frame->this, state->resolve.op_ret,
- state->resolve.op_errno, NULL, NULL);
- return 0;
+ server4_xattrop_cbk(frame, NULL, frame->this, state->resolve.op_ret,
+ state->resolve.op_errno, NULL, NULL);
+ return 0;
}
int
-server4_fxattrop_resume (call_frame_t *frame, xlator_t *bound_xl)
+server4_fxattrop_resume(call_frame_t *frame, xlator_t *bound_xl)
{
- server_state_t *state = NULL;
+ server_state_t *state = NULL;
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (state->resolve.op_ret != 0)
- goto err;
+ if (state->resolve.op_ret != 0)
+ goto err;
- STACK_WIND (frame, server4_fxattrop_cbk,
- bound_xl, bound_xl->fops->fxattrop,
- state->fd, state->flags, state->dict, state->xdata);
- return 0;
+ STACK_WIND(frame, server4_fxattrop_cbk, bound_xl, bound_xl->fops->fxattrop,
+ state->fd, state->flags, state->dict, state->xdata);
+ return 0;
err:
- server4_fxattrop_cbk (frame, NULL, frame->this, state->resolve.op_ret,
- state->resolve.op_errno, NULL, NULL);
- return 0;
+ server4_fxattrop_cbk(frame, NULL, frame->this, state->resolve.op_ret,
+ state->resolve.op_errno, NULL, NULL);
+ return 0;
}
int
-server4_fsetxattr_resume (call_frame_t *frame, xlator_t *bound_xl)
+server4_fsetxattr_resume(call_frame_t *frame, xlator_t *bound_xl)
{
- server_state_t *state = NULL;
+ server_state_t *state = NULL;
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (state->resolve.op_ret != 0)
- goto err;
+ if (state->resolve.op_ret != 0)
+ goto err;
- STACK_WIND (frame, server4_setxattr_cbk,
- bound_xl, bound_xl->fops->fsetxattr,
- state->fd, state->dict, state->flags, state->xdata);
- return 0;
+ STACK_WIND(frame, server4_setxattr_cbk, bound_xl, bound_xl->fops->fsetxattr,
+ state->fd, state->dict, state->flags, state->xdata);
+ return 0;
err:
- server4_fsetxattr_cbk (frame, NULL, frame->this, state->resolve.op_ret,
- state->resolve.op_errno, NULL);
+ server4_fsetxattr_cbk(frame, NULL, frame->this, state->resolve.op_ret,
+ state->resolve.op_errno, NULL);
- return 0;
+ return 0;
}
int
-server4_unlink_resume (call_frame_t *frame, xlator_t *bound_xl)
+server4_unlink_resume(call_frame_t *frame, xlator_t *bound_xl)
{
- server_state_t *state = NULL;
+ server_state_t *state = NULL;
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (state->resolve.op_ret != 0)
- goto err;
+ if (state->resolve.op_ret != 0)
+ goto err;
- STACK_WIND (frame, server4_unlink_cbk,
- bound_xl, bound_xl->fops->unlink,
- &state->loc, state->flags, state->xdata);
- return 0;
+ STACK_WIND(frame, server4_unlink_cbk, bound_xl, bound_xl->fops->unlink,
+ &state->loc, state->flags, state->xdata);
+ return 0;
err:
- server4_unlink_cbk (frame, NULL, frame->this, state->resolve.op_ret,
- state->resolve.op_errno, NULL, NULL, NULL);
- return 0;
+ server4_unlink_cbk(frame, NULL, frame->this, state->resolve.op_ret,
+ state->resolve.op_errno, NULL, NULL, NULL);
+ return 0;
}
int
-server4_truncate_resume (call_frame_t *frame, xlator_t *bound_xl)
+server4_truncate_resume(call_frame_t *frame, xlator_t *bound_xl)
{
- server_state_t *state = NULL;
+ server_state_t *state = NULL;
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (state->resolve.op_ret != 0)
- goto err;
+ if (state->resolve.op_ret != 0)
+ goto err;
- STACK_WIND (frame, server4_truncate_cbk,
- bound_xl, bound_xl->fops->truncate,
- &state->loc, state->offset, state->xdata);
- return 0;
+ STACK_WIND(frame, server4_truncate_cbk, bound_xl, bound_xl->fops->truncate,
+ &state->loc, state->offset, state->xdata);
+ return 0;
err:
- server4_truncate_cbk (frame, NULL, frame->this, state->resolve.op_ret,
- state->resolve.op_errno, NULL, NULL, NULL);
- return 0;
+ server4_truncate_cbk(frame, NULL, frame->this, state->resolve.op_ret,
+ state->resolve.op_errno, NULL, NULL, NULL);
+ return 0;
}
-
-
int
-server4_fstat_resume (call_frame_t *frame, xlator_t *bound_xl)
+server4_fstat_resume(call_frame_t *frame, xlator_t *bound_xl)
{
- server_state_t *state = NULL;
+ server_state_t *state = NULL;
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (state->resolve.op_ret != 0)
- goto err;
+ if (state->resolve.op_ret != 0)
+ goto err;
- STACK_WIND (frame, server4_fstat_cbk,
- bound_xl, bound_xl->fops->fstat,
- state->fd, state->xdata);
- return 0;
+ STACK_WIND(frame, server4_fstat_cbk, bound_xl, bound_xl->fops->fstat,
+ state->fd, state->xdata);
+ return 0;
err:
- server4_fstat_cbk (frame, NULL, frame->this, state->resolve.op_ret,
- state->resolve.op_errno, NULL, NULL);
- return 0;
+ server4_fstat_cbk(frame, NULL, frame->this, state->resolve.op_ret,
+ state->resolve.op_errno, NULL, NULL);
+ return 0;
}
-
int
-server4_setxattr_resume (call_frame_t *frame, xlator_t *bound_xl)
+server4_setxattr_resume(call_frame_t *frame, xlator_t *bound_xl)
{
- server_state_t *state = NULL;
+ server_state_t *state = NULL;
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (state->resolve.op_ret != 0)
- goto err;
+ if (state->resolve.op_ret != 0)
+ goto err;
- STACK_WIND (frame, server4_setxattr_cbk,
- bound_xl, bound_xl->fops->setxattr,
- &state->loc, state->dict, state->flags, state->xdata);
- return 0;
+ STACK_WIND(frame, server4_setxattr_cbk, bound_xl, bound_xl->fops->setxattr,
+ &state->loc, state->dict, state->flags, state->xdata);
+ return 0;
err:
- server4_setxattr_cbk (frame, NULL, frame->this, state->resolve.op_ret,
- state->resolve.op_errno, NULL);
+ server4_setxattr_cbk(frame, NULL, frame->this, state->resolve.op_ret,
+ state->resolve.op_errno, NULL);
- return 0;
+ return 0;
}
-
int
-server4_getxattr_resume (call_frame_t *frame, xlator_t *bound_xl)
+server4_getxattr_resume(call_frame_t *frame, xlator_t *bound_xl)
{
- server_state_t *state = NULL;
+ server_state_t *state = NULL;
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (state->resolve.op_ret != 0)
- goto err;
+ if (state->resolve.op_ret != 0)
+ goto err;
- STACK_WIND (frame, server4_getxattr_cbk,
- bound_xl, bound_xl->fops->getxattr,
- &state->loc, state->name, state->xdata);
- return 0;
+ STACK_WIND(frame, server4_getxattr_cbk, bound_xl, bound_xl->fops->getxattr,
+ &state->loc, state->name, state->xdata);
+ return 0;
err:
- server4_getxattr_cbk (frame, NULL, frame->this, state->resolve.op_ret,
- state->resolve.op_errno, NULL, NULL);
- return 0;
+ server4_getxattr_cbk(frame, NULL, frame->this, state->resolve.op_ret,
+ state->resolve.op_errno, NULL, NULL);
+ return 0;
}
-
int
-server4_ftruncate_resume (call_frame_t *frame, xlator_t *bound_xl)
+server4_ftruncate_resume(call_frame_t *frame, xlator_t *bound_xl)
{
- server_state_t *state = NULL;
+ server_state_t *state = NULL;
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (state->resolve.op_ret != 0)
- goto err;
+ if (state->resolve.op_ret != 0)
+ goto err;
- STACK_WIND (frame, server4_ftruncate_cbk,
- bound_xl, bound_xl->fops->ftruncate,
- state->fd, state->offset, state->xdata);
- return 0;
+ STACK_WIND(frame, server4_ftruncate_cbk, bound_xl,
+ bound_xl->fops->ftruncate, state->fd, state->offset,
+ state->xdata);
+ return 0;
err:
- server4_ftruncate_cbk (frame, NULL, frame->this, state->resolve.op_ret,
- state->resolve.op_errno, NULL, NULL, NULL);
+ server4_ftruncate_cbk(frame, NULL, frame->this, state->resolve.op_ret,
+ state->resolve.op_errno, NULL, NULL, NULL);
- return 0;
+ return 0;
}
-
int
-server4_flush_resume (call_frame_t *frame, xlator_t *bound_xl)
+server4_flush_resume(call_frame_t *frame, xlator_t *bound_xl)
{
- server_state_t *state = NULL;
+ server_state_t *state = NULL;
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (state->resolve.op_ret != 0)
- goto err;
+ if (state->resolve.op_ret != 0)
+ goto err;
- STACK_WIND (frame, server4_flush_cbk,
- bound_xl, bound_xl->fops->flush, state->fd, state->xdata);
- return 0;
+ STACK_WIND(frame, server4_flush_cbk, bound_xl, bound_xl->fops->flush,
+ state->fd, state->xdata);
+ return 0;
err:
- server4_flush_cbk (frame, NULL, frame->this, state->resolve.op_ret,
- state->resolve.op_errno, NULL);
+ server4_flush_cbk(frame, NULL, frame->this, state->resolve.op_ret,
+ state->resolve.op_errno, NULL);
- return 0;
+ return 0;
}
-
int
-server4_fsync_resume (call_frame_t *frame, xlator_t *bound_xl)
+server4_fsync_resume(call_frame_t *frame, xlator_t *bound_xl)
{
- server_state_t *state = NULL;
+ server_state_t *state = NULL;
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (state->resolve.op_ret != 0)
- goto err;
+ if (state->resolve.op_ret != 0)
+ goto err;
- STACK_WIND (frame, server4_fsync_cbk,
- bound_xl, bound_xl->fops->fsync,
- state->fd, state->flags, state->xdata);
- return 0;
+ STACK_WIND(frame, server4_fsync_cbk, bound_xl, bound_xl->fops->fsync,
+ state->fd, state->flags, state->xdata);
+ return 0;
err:
- server4_fsync_cbk (frame, NULL, frame->this, state->resolve.op_ret,
- state->resolve.op_errno, NULL, NULL, NULL);
+ server4_fsync_cbk(frame, NULL, frame->this, state->resolve.op_ret,
+ state->resolve.op_errno, NULL, NULL, NULL);
- return 0;
+ return 0;
}
int
-server4_writev_resume (call_frame_t *frame, xlator_t *bound_xl)
+server4_writev_resume(call_frame_t *frame, xlator_t *bound_xl)
{
- server_state_t *state = NULL;
+ server_state_t *state = NULL;
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (state->resolve.op_ret != 0)
- goto err;
+ if (state->resolve.op_ret != 0)
+ goto err;
- STACK_WIND (frame, server4_writev_cbk,
- bound_xl, bound_xl->fops->writev,
- state->fd, state->payload_vector, state->payload_count,
- state->offset, state->flags, state->iobref, state->xdata);
+ STACK_WIND(frame, server4_writev_cbk, bound_xl, bound_xl->fops->writev,
+ state->fd, state->payload_vector, state->payload_count,
+ state->offset, state->flags, state->iobref, state->xdata);
- return 0;
+ return 0;
err:
- server4_writev_cbk (frame, NULL, frame->this, state->resolve.op_ret,
- state->resolve.op_errno, NULL, NULL, NULL);
- return 0;
+ server4_writev_cbk(frame, NULL, frame->this, state->resolve.op_ret,
+ state->resolve.op_errno, NULL, NULL, NULL);
+ return 0;
}
-
int
-server4_readv_resume (call_frame_t *frame, xlator_t *bound_xl)
+server4_readv_resume(call_frame_t *frame, xlator_t *bound_xl)
{
- server_state_t *state = NULL;
+ server_state_t *state = NULL;
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (state->resolve.op_ret != 0)
- goto err;
+ if (state->resolve.op_ret != 0)
+ goto err;
- STACK_WIND (frame, server4_readv_cbk,
- bound_xl, bound_xl->fops->readv,
- state->fd, state->size, state->offset, state->flags, state->xdata);
+ STACK_WIND(frame, server4_readv_cbk, bound_xl, bound_xl->fops->readv,
+ state->fd, state->size, state->offset, state->flags,
+ state->xdata);
- return 0;
+ return 0;
err:
- server4_readv_cbk (frame, NULL, frame->this, state->resolve.op_ret,
- state->resolve.op_errno, NULL, 0, NULL, NULL, NULL);
- return 0;
+ server4_readv_cbk(frame, NULL, frame->this, state->resolve.op_ret,
+ state->resolve.op_errno, NULL, 0, NULL, NULL, NULL);
+ return 0;
}
-
int
-server4_create_resume (call_frame_t *frame, xlator_t *bound_xl)
+server4_create_resume(call_frame_t *frame, xlator_t *bound_xl)
{
- server_state_t *state = NULL;
+ server_state_t *state = NULL;
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (state->resolve.op_ret != 0)
- goto err;
+ if (state->resolve.op_ret != 0)
+ goto err;
- state->loc.inode = inode_new (state->itable);
+ state->loc.inode = inode_new(state->itable);
- state->fd = fd_create (state->loc.inode, frame->root->pid);
- if (!state->fd) {
- gf_msg ("server", GF_LOG_ERROR, 0, PS_MSG_FD_CREATE_FAILED,
- "fd creation for the inode %s failed",
- state->loc.inode ?
- uuid_utoa (state->loc.inode->gfid):NULL);
- state->resolve.op_ret = -1;
- state->resolve.op_errno = ENOMEM;
- goto err;
- }
- state->fd->flags = state->flags;
+ state->fd = fd_create(state->loc.inode, frame->root->pid);
+ if (!state->fd) {
+ gf_msg("server", GF_LOG_ERROR, 0, PS_MSG_FD_CREATE_FAILED,
+ "fd creation for the inode %s failed",
+ state->loc.inode ? uuid_utoa(state->loc.inode->gfid) : NULL);
+ state->resolve.op_ret = -1;
+ state->resolve.op_errno = ENOMEM;
+ goto err;
+ }
+ state->fd->flags = state->flags;
- STACK_WIND (frame, server4_create_cbk,
- bound_xl, bound_xl->fops->create,
- &(state->loc), state->flags, state->mode,
- state->umask, state->fd, state->xdata);
+ STACK_WIND(frame, server4_create_cbk, bound_xl, bound_xl->fops->create,
+ &(state->loc), state->flags, state->mode, state->umask,
+ state->fd, state->xdata);
- return 0;
+ return 0;
err:
- server4_create_cbk (frame, NULL, frame->this, state->resolve.op_ret,
- state->resolve.op_errno, NULL, NULL, NULL,
- NULL, NULL, NULL);
- return 0;
+ server4_create_cbk(frame, NULL, frame->this, state->resolve.op_ret,
+ state->resolve.op_errno, NULL, NULL, NULL, NULL, NULL,
+ NULL);
+ return 0;
}
-
int
-server4_open_resume (call_frame_t *frame, xlator_t *bound_xl)
+server4_open_resume(call_frame_t *frame, xlator_t *bound_xl)
{
- server_state_t *state = NULL;
+ server_state_t *state = NULL;
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (state->resolve.op_ret != 0)
- goto err;
+ if (state->resolve.op_ret != 0)
+ goto err;
- state->fd = fd_create (state->loc.inode, frame->root->pid);
- state->fd->flags = state->flags;
+ state->fd = fd_create(state->loc.inode, frame->root->pid);
+ state->fd->flags = state->flags;
- STACK_WIND (frame, server4_open_cbk,
- bound_xl, bound_xl->fops->open,
- &state->loc, state->flags, state->fd, state->xdata);
+ STACK_WIND(frame, server4_open_cbk, bound_xl, bound_xl->fops->open,
+ &state->loc, state->flags, state->fd, state->xdata);
- return 0;
+ return 0;
err:
- server4_open_cbk (frame, NULL, frame->this, state->resolve.op_ret,
- state->resolve.op_errno, NULL, NULL);
- return 0;
+ server4_open_cbk(frame, NULL, frame->this, state->resolve.op_ret,
+ state->resolve.op_errno, NULL, NULL);
+ return 0;
}
-
int
-server4_readlink_resume (call_frame_t *frame, xlator_t *bound_xl)
+server4_readlink_resume(call_frame_t *frame, xlator_t *bound_xl)
{
- server_state_t *state = NULL;
+ server_state_t *state = NULL;
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (state->resolve.op_ret != 0)
- goto err;
+ if (state->resolve.op_ret != 0)
+ goto err;
- STACK_WIND (frame, server4_readlink_cbk,
- bound_xl, bound_xl->fops->readlink,
- &state->loc, state->size, state->xdata);
- return 0;
+ STACK_WIND(frame, server4_readlink_cbk, bound_xl, bound_xl->fops->readlink,
+ &state->loc, state->size, state->xdata);
+ return 0;
err:
- server4_readlink_cbk (frame, NULL, frame->this, state->resolve.op_ret,
- state->resolve.op_errno, NULL, NULL, NULL);
- return 0;
+ server4_readlink_cbk(frame, NULL, frame->this, state->resolve.op_ret,
+ state->resolve.op_errno, NULL, NULL, NULL);
+ return 0;
}
-
int
-server4_fsetattr_resume (call_frame_t *frame, xlator_t *bound_xl)
+server4_fsetattr_resume(call_frame_t *frame, xlator_t *bound_xl)
{
- server_state_t *state = NULL;
+ server_state_t *state = NULL;
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (state->resolve.op_ret != 0)
- goto err;
+ if (state->resolve.op_ret != 0)
+ goto err;
- STACK_WIND (frame, server4_fsetattr_cbk,
- bound_xl, bound_xl->fops->fsetattr,
- state->fd, &state->stbuf, state->valid, state->xdata);
- return 0;
+ STACK_WIND(frame, server4_fsetattr_cbk, bound_xl, bound_xl->fops->fsetattr,
+ state->fd, &state->stbuf, state->valid, state->xdata);
+ return 0;
err:
- server4_fsetattr_cbk (frame, NULL, frame->this, state->resolve.op_ret,
- state->resolve.op_errno, NULL, NULL, NULL);
+ server4_fsetattr_cbk(frame, NULL, frame->this, state->resolve.op_ret,
+ state->resolve.op_errno, NULL, NULL, NULL);
- return 0;
+ return 0;
}
-
int
-server4_setattr_resume (call_frame_t *frame, xlator_t *bound_xl)
+server4_setattr_resume(call_frame_t *frame, xlator_t *bound_xl)
{
- server_state_t *state = NULL;
+ server_state_t *state = NULL;
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (state->resolve.op_ret != 0)
- goto err;
+ if (state->resolve.op_ret != 0)
+ goto err;
- STACK_WIND (frame, server4_setattr_cbk,
- bound_xl, bound_xl->fops->setattr,
- &state->loc, &state->stbuf, state->valid, state->xdata);
- return 0;
+ STACK_WIND(frame, server4_setattr_cbk, bound_xl, bound_xl->fops->setattr,
+ &state->loc, &state->stbuf, state->valid, state->xdata);
+ return 0;
err:
- server4_setattr_cbk (frame, NULL, frame->this, state->resolve.op_ret,
- state->resolve.op_errno, NULL, NULL, NULL);
+ server4_setattr_cbk(frame, NULL, frame->this, state->resolve.op_ret,
+ state->resolve.op_errno, NULL, NULL, NULL);
- return 0;
+ return 0;
}
-
int
-server4_stat_resume (call_frame_t *frame, xlator_t *bound_xl)
+server4_stat_resume(call_frame_t *frame, xlator_t *bound_xl)
{
- server_state_t *state = NULL;
+ server_state_t *state = NULL;
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (state->resolve.op_ret != 0)
- goto err;
+ if (state->resolve.op_ret != 0)
+ goto err;
- STACK_WIND (frame, server4_stat_cbk,
- bound_xl, bound_xl->fops->stat, &state->loc, state->xdata);
- return 0;
+ STACK_WIND(frame, server4_stat_cbk, bound_xl, bound_xl->fops->stat,
+ &state->loc, state->xdata);
+ return 0;
err:
- server4_stat_cbk (frame, NULL, frame->this, state->resolve.op_ret,
- state->resolve.op_errno, NULL, NULL);
- return 0;
+ server4_stat_cbk(frame, NULL, frame->this, state->resolve.op_ret,
+ state->resolve.op_errno, NULL, NULL);
+ return 0;
}
int
-server4_lookup_resume (call_frame_t *frame, xlator_t *bound_xl)
+server4_lookup_resume(call_frame_t *frame, xlator_t *bound_xl)
{
- server_state_t *state = NULL;
+ server_state_t *state = NULL;
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (state->resolve.op_ret != 0)
- goto err;
+ if (state->resolve.op_ret != 0)
+ goto err;
- if (!state->loc.inode)
- state->loc.inode = server_inode_new (state->itable,
- state->loc.gfid);
- else
- state->is_revalidate = 1;
+ if (!state->loc.inode)
+ state->loc.inode = server_inode_new(state->itable, state->loc.gfid);
+ else
+ state->is_revalidate = 1;
- STACK_WIND (frame, server4_lookup_cbk,
- bound_xl, bound_xl->fops->lookup,
- &state->loc, state->xdata);
+ STACK_WIND(frame, server4_lookup_cbk, bound_xl, bound_xl->fops->lookup,
+ &state->loc, state->xdata);
- return 0;
+ return 0;
err:
- server4_lookup_cbk (frame, NULL, frame->this, state->resolve.op_ret,
- state->resolve.op_errno, NULL, NULL, NULL, NULL);
+ server4_lookup_cbk(frame, NULL, frame->this, state->resolve.op_ret,
+ state->resolve.op_errno, NULL, NULL, NULL, NULL);
- return 0;
+ return 0;
}
int
-server4_fallocate_resume (call_frame_t *frame, xlator_t *bound_xl)
+server4_fallocate_resume(call_frame_t *frame, xlator_t *bound_xl)
{
- server_state_t *state = NULL;
+ server_state_t *state = NULL;
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (state->resolve.op_ret != 0)
- goto err;
+ if (state->resolve.op_ret != 0)
+ goto err;
- STACK_WIND (frame, server4_fallocate_cbk,
- bound_xl, bound_xl->fops->fallocate,
- state->fd, state->flags, state->offset, state->size,
- state->xdata);
- return 0;
+ STACK_WIND(frame, server4_fallocate_cbk, bound_xl,
+ bound_xl->fops->fallocate, state->fd, state->flags,
+ state->offset, state->size, state->xdata);
+ return 0;
err:
- server4_fallocate_cbk(frame, NULL, frame->this, state->resolve.op_ret,
- state->resolve.op_errno, NULL, NULL, NULL);
+ server4_fallocate_cbk(frame, NULL, frame->this, state->resolve.op_ret,
+ state->resolve.op_errno, NULL, NULL, NULL);
- return 0;
+ return 0;
}
int
-server4_discard_resume (call_frame_t *frame, xlator_t *bound_xl)
+server4_discard_resume(call_frame_t *frame, xlator_t *bound_xl)
{
- server_state_t *state = NULL;
+ server_state_t *state = NULL;
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (state->resolve.op_ret != 0)
- goto err;
+ if (state->resolve.op_ret != 0)
+ goto err;
- STACK_WIND (frame, server4_discard_cbk,
- bound_xl, bound_xl->fops->discard,
- state->fd, state->offset, state->size, state->xdata);
- return 0;
+ STACK_WIND(frame, server4_discard_cbk, bound_xl, bound_xl->fops->discard,
+ state->fd, state->offset, state->size, state->xdata);
+ return 0;
err:
- server4_discard_cbk(frame, NULL, frame->this, state->resolve.op_ret,
- state->resolve.op_errno, NULL, NULL, NULL);
+ server4_discard_cbk(frame, NULL, frame->this, state->resolve.op_ret,
+ state->resolve.op_errno, NULL, NULL, NULL);
- return 0;
+ return 0;
}
int
-server4_zerofill_resume (call_frame_t *frame, xlator_t *bound_xl)
+server4_zerofill_resume(call_frame_t *frame, xlator_t *bound_xl)
{
- server_state_t *state = NULL;
+ server_state_t *state = NULL;
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (state->resolve.op_ret != 0)
- goto err;
+ if (state->resolve.op_ret != 0)
+ goto err;
- STACK_WIND (frame, server4_zerofill_cbk,
- bound_xl, bound_xl->fops->zerofill,
- state->fd, state->offset, state->size, state->xdata);
- return 0;
+ STACK_WIND(frame, server4_zerofill_cbk, bound_xl, bound_xl->fops->zerofill,
+ state->fd, state->offset, state->size, state->xdata);
+ return 0;
err:
- server4_zerofill_cbk(frame, NULL, frame->this, state->resolve.op_ret,
- state->resolve.op_errno, NULL, NULL, NULL);
+ server4_zerofill_cbk(frame, NULL, frame->this, state->resolve.op_ret,
+ state->resolve.op_errno, NULL, NULL, NULL);
- return 0;
+ return 0;
}
int
-server4_seek_resume (call_frame_t *frame, xlator_t *bound_xl)
+server4_seek_resume(call_frame_t *frame, xlator_t *bound_xl)
{
- server_state_t *state = NULL;
+ server_state_t *state = NULL;
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (state->resolve.op_ret != 0)
- goto err;
+ if (state->resolve.op_ret != 0)
+ goto err;
- STACK_WIND (frame, server4_seek_cbk, bound_xl, bound_xl->fops->seek,
- state->fd, state->offset, state->what, state->xdata);
- return 0;
+ STACK_WIND(frame, server4_seek_cbk, bound_xl, bound_xl->fops->seek,
+ state->fd, state->offset, state->what, state->xdata);
+ return 0;
err:
- server4_seek_cbk (frame, NULL, frame->this, state->resolve.op_ret,
- state->resolve.op_errno, 0, NULL);
+ server4_seek_cbk(frame, NULL, frame->this, state->resolve.op_ret,
+ state->resolve.op_errno, 0, NULL);
- return 0;
+ return 0;
}
static int
-server4_getactivelk_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
+server4_getactivelk_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
int32_t op_ret, int32_t op_errno,
lock_migration_info_t *locklist, dict_t *xdata)
{
- gfx_getactivelk_rsp rsp = {0,};
- server_state_t *state = NULL;
- rpcsvc_request_t *req = NULL;
- int ret = 0;
+ gfx_getactivelk_rsp rsp = {
+ 0,
+ };
+ server_state_t *state = NULL;
+ rpcsvc_request_t *req = NULL;
+ int ret = 0;
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- dict_to_xdr (xdata, &rsp.xdata);
+ dict_to_xdr(xdata, &rsp.xdata);
- if (op_ret < 0) {
- state = CALL_STATE (frame);
+ if (op_ret < 0) {
+ state = CALL_STATE(frame);
- gf_msg (this->name, GF_LOG_INFO,
- op_errno, 0,
- "%"PRId64": GETACTIVELK %s (%s), client: %s, "
- "error-xlator: %s", frame->root->unique,
- state->loc.path, uuid_utoa (state->resolve.gfid),
- STACK_CLIENT_NAME (frame->root),
- STACK_ERR_XL_NAME (frame->root));
+ gf_msg(this->name, GF_LOG_INFO, op_errno, 0,
+ "%" PRId64
+ ": GETACTIVELK %s (%s), client: %s, "
+ "error-xlator: %s",
+ frame->root->unique, state->loc.path,
+ uuid_utoa(state->resolve.gfid), STACK_CLIENT_NAME(frame->root),
+ STACK_ERR_XL_NAME(frame->root));
- goto out;
- }
+ goto out;
+ }
- /* (op_ret == 0) means there are no locks on the file*/
- if (op_ret > 0) {
- ret = serialize_rsp_locklist_v2 (locklist, &rsp);
- if (ret == -1) {
- op_ret = -1;
- op_errno = ENOMEM;
- goto out;
- }
+ /* (op_ret == 0) means there are no locks on the file*/
+ if (op_ret > 0) {
+ ret = serialize_rsp_locklist_v2(locklist, &rsp);
+ if (ret == -1) {
+ op_ret = -1;
+ op_errno = ENOMEM;
+ goto out;
}
+ }
out:
- rsp.op_ret = op_ret;
- rsp.op_errno = gf_errno_to_error (op_errno);
+ rsp.op_ret = op_ret;
+ rsp.op_errno = gf_errno_to_error(op_errno);
- req = frame->local;
+ req = frame->local;
- server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
- (xdrproc_t)xdr_gfx_getactivelk_rsp);
+ server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gfx_getactivelk_rsp);
- GF_FREE (rsp.xdata.pairs.pairs_val);
+ GF_FREE(rsp.xdata.pairs.pairs_val);
- getactivelkinfo_rsp_cleanup_v2 (&rsp);
+ getactivelkinfo_rsp_cleanup_v2(&rsp);
- return 0;
+ return 0;
}
int
-server4_getactivelk_resume (call_frame_t *frame, xlator_t *bound_xl)
+server4_getactivelk_resume(call_frame_t *frame, xlator_t *bound_xl)
{
- server_state_t *state = NULL;
+ server_state_t *state = NULL;
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (state->resolve.op_ret != 0)
- goto err;
+ if (state->resolve.op_ret != 0)
+ goto err;
- STACK_WIND (frame, server4_getactivelk_cbk, bound_xl,
- bound_xl->fops->getactivelk, &state->loc, state->xdata);
- return 0;
+ STACK_WIND(frame, server4_getactivelk_cbk, bound_xl,
+ bound_xl->fops->getactivelk, &state->loc, state->xdata);
+ return 0;
err:
- server4_getactivelk_cbk (frame, NULL, frame->this, state->resolve.op_ret,
- state->resolve.op_errno, NULL, NULL);
- return 0;
-
+ server4_getactivelk_cbk(frame, NULL, frame->this, state->resolve.op_ret,
+ state->resolve.op_errno, NULL, NULL);
+ return 0;
}
int
-server4_setactivelk_resume (call_frame_t *frame, xlator_t *bound_xl)
+server4_setactivelk_resume(call_frame_t *frame, xlator_t *bound_xl)
{
- server_state_t *state = NULL;
+ server_state_t *state = NULL;
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (state->resolve.op_ret != 0)
- goto err;
+ if (state->resolve.op_ret != 0)
+ goto err;
- STACK_WIND (frame, server4_setactivelk_cbk,
- bound_xl, bound_xl->fops->setactivelk, &state->loc,
- &state->locklist, state->xdata);
- return 0;
+ STACK_WIND(frame, server4_setactivelk_cbk, bound_xl,
+ bound_xl->fops->setactivelk, &state->loc, &state->locklist,
+ state->xdata);
+ return 0;
err:
- server4_setactivelk_cbk (frame, NULL, frame->this,
- state->resolve.op_ret,
- state->resolve.op_errno, NULL);
- return 0;
-
+ server4_setactivelk_cbk(frame, NULL, frame->this, state->resolve.op_ret,
+ state->resolve.op_errno, NULL);
+ return 0;
}
int
-server4_namelink_resume (call_frame_t *frame, xlator_t *bound_xl)
+server4_namelink_resume(call_frame_t *frame, xlator_t *bound_xl)
{
- server_state_t *state = NULL;
+ server_state_t *state = NULL;
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (state->resolve.op_ret != 0)
- goto err;
+ if (state->resolve.op_ret != 0)
+ goto err;
- state->loc.inode = inode_new (state->itable);
+ state->loc.inode = inode_new(state->itable);
- STACK_WIND (frame, server4_namelink_cbk,
- bound_xl, bound_xl->fops->namelink,
- &(state->loc), state->xdata);
- return 0;
+ STACK_WIND(frame, server4_namelink_cbk, bound_xl, bound_xl->fops->namelink,
+ &(state->loc), state->xdata);
+ return 0;
- err:
- server4_namelink_cbk (frame, NULL,
- frame->this,
- state->resolve.op_ret,
- state->resolve.op_errno, NULL, NULL, NULL);
- return 0;
+err:
+ server4_namelink_cbk(frame, NULL, frame->this, state->resolve.op_ret,
+ state->resolve.op_errno, NULL, NULL, NULL);
+ return 0;
}
int
-server4_icreate_resume (call_frame_t *frame, xlator_t *bound_xl)
+server4_icreate_resume(call_frame_t *frame, xlator_t *bound_xl)
{
- server_state_t *state = NULL;
+ server_state_t *state = NULL;
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (state->resolve.op_ret != 0)
- goto err;
+ if (state->resolve.op_ret != 0)
+ goto err;
- state->loc.inode = inode_new (state->itable);
+ state->loc.inode = inode_new(state->itable);
- STACK_WIND (frame, server4_icreate_cbk,
- bound_xl, bound_xl->fops->icreate,
- &(state->loc), state->mode, state->xdata);
+ STACK_WIND(frame, server4_icreate_cbk, bound_xl, bound_xl->fops->icreate,
+ &(state->loc), state->mode, state->xdata);
- return 0;
+ return 0;
err:
- server4_icreate_cbk (frame, NULL, frame->this, state->resolve.op_ret,
- state->resolve.op_errno, NULL, NULL, NULL);
- return 0;
+ server4_icreate_cbk(frame, NULL, frame->this, state->resolve.op_ret,
+ state->resolve.op_errno, NULL, NULL, NULL);
+ return 0;
}
-
int
-server4_0_stat (rpcsvc_request_t *req)
+server4_0_stat(rpcsvc_request_t *req)
{
- server_state_t *state = NULL;
- call_frame_t *frame = NULL;
- gfx_stat_req args = {{0,},};
- int ret = -1;
- int op_errno = 0;
+ server_state_t *state = NULL;
+ call_frame_t *frame = NULL;
+ gfx_stat_req args = {
+ {
+ 0,
+ },
+ };
+ int ret = -1;
+ int op_errno = 0;
- if (!req)
- return 0;
+ if (!req)
+ return 0;
- /* Initialize args first, then decode */
- ret = rpc_receive_common (req, &frame, &state, NULL, &args,
- xdr_gfx_stat_req, GF_FOP_STAT);
- if (ret != 0) {
- goto out;
- }
+ /* Initialize args first, then decode */
+ ret = rpc_receive_common(req, &frame, &state, NULL, &args, xdr_gfx_stat_req,
+ GF_FOP_STAT);
+ if (ret != 0) {
+ goto out;
+ }
- state->resolve.type = RESOLVE_MUST;
- set_resolve_gfid (frame->root->client, state->resolve.gfid, args.gfid);
+ state->resolve.type = RESOLVE_MUST;
+ set_resolve_gfid(frame->root->client, state->resolve.gfid, args.gfid);
- xdr_to_dict (&args.xdata, &state->xdata);
+ xdr_to_dict(&args.xdata, &state->xdata);
- ret = 0;
- resolve_and_resume (frame, server4_stat_resume);
+ ret = 0;
+ resolve_and_resume(frame, server4_stat_resume);
out:
+ if (op_errno)
+ SERVER_REQ_SET_ERROR(req, ret);
- if (op_errno)
- SERVER_REQ_SET_ERROR (req, ret);
-
- return ret;
+ return ret;
}
-
int
-server4_0_setattr (rpcsvc_request_t *req)
+server4_0_setattr(rpcsvc_request_t *req)
{
- server_state_t *state = NULL;
- call_frame_t *frame = NULL;
- gfx_setattr_req args = {{0,},};
- int ret = -1;
- int op_errno = 0;
+ server_state_t *state = NULL;
+ call_frame_t *frame = NULL;
+ gfx_setattr_req args = {
+ {
+ 0,
+ },
+ };
+ int ret = -1;
+ int op_errno = 0;
- if (!req)
- return 0;
+ if (!req)
+ return 0;
- ret = rpc_receive_common (req, &frame, &state, NULL, &args,
- xdr_gfx_setattr_req, GF_FOP_SETATTR);
- if (ret != 0) {
- goto out;
- }
+ ret = rpc_receive_common(req, &frame, &state, NULL, &args,
+ xdr_gfx_setattr_req, GF_FOP_SETATTR);
+ if (ret != 0) {
+ goto out;
+ }
- state->resolve.type = RESOLVE_MUST;
- set_resolve_gfid (frame->root->client, state->resolve.gfid, args.gfid);
+ state->resolve.type = RESOLVE_MUST;
+ set_resolve_gfid(frame->root->client, state->resolve.gfid, args.gfid);
- gfx_stat_to_iattx (&args.stbuf, &state->stbuf);
- state->valid = args.valid;
+ gfx_stat_to_iattx(&args.stbuf, &state->stbuf);
+ state->valid = args.valid;
- xdr_to_dict (&args.xdata, &state->xdata);
+ xdr_to_dict(&args.xdata, &state->xdata);
- ret = 0;
- resolve_and_resume (frame, server4_setattr_resume);
+ ret = 0;
+ resolve_and_resume(frame, server4_setattr_resume);
out:
- if (op_errno)
- SERVER_REQ_SET_ERROR (req, ret);
+ if (op_errno)
+ SERVER_REQ_SET_ERROR(req, ret);
-
-
- return ret;
+ return ret;
}
-
int
server4_0_fallocate(rpcsvc_request_t *req)
{
- server_state_t *state = NULL;
- call_frame_t *frame = NULL;
- gfx_fallocate_req args = {{0},};
- int ret = -1;
- int op_errno = 0;
+ server_state_t *state = NULL;
+ call_frame_t *frame = NULL;
+ gfx_fallocate_req args = {
+ {0},
+ };
+ int ret = -1;
+ int op_errno = 0;
- if (!req)
- return ret;
+ if (!req)
+ return ret;
- ret = rpc_receive_common (req, &frame, &state, NULL, &args,
- xdr_gfx_fallocate_req, GF_FOP_FALLOCATE);
- if (ret != 0) {
- goto out;
- }
+ ret = rpc_receive_common(req, &frame, &state, NULL, &args,
+ xdr_gfx_fallocate_req, GF_FOP_FALLOCATE);
+ if (ret != 0) {
+ goto out;
+ }
- state->resolve.type = RESOLVE_MUST;
- state->resolve.fd_no = args.fd;
+ state->resolve.type = RESOLVE_MUST;
+ state->resolve.fd_no = args.fd;
- state->flags = args.flags;
- state->offset = args.offset;
- state->size = args.size;
- memcpy(state->resolve.gfid, args.gfid, 16);
+ state->flags = args.flags;
+ state->offset = args.offset;
+ state->size = args.size;
+ memcpy(state->resolve.gfid, args.gfid, 16);
- xdr_to_dict (&args.xdata, &state->xdata);
+ xdr_to_dict(&args.xdata, &state->xdata);
- ret = 0;
- resolve_and_resume (frame, server4_fallocate_resume);
+ ret = 0;
+ resolve_and_resume(frame, server4_fallocate_resume);
out:
+ if (op_errno)
+ SERVER_REQ_SET_ERROR(req, ret);
- if (op_errno)
- SERVER_REQ_SET_ERROR (req, ret);
-
- return ret;
+ return ret;
}
-
int
server4_0_discard(rpcsvc_request_t *req)
{
- server_state_t *state = NULL;
- call_frame_t *frame = NULL;
- gfx_discard_req args = {{0},};
- int ret = -1;
- int op_errno = 0;
+ server_state_t *state = NULL;
+ call_frame_t *frame = NULL;
+ gfx_discard_req args = {
+ {0},
+ };
+ int ret = -1;
+ int op_errno = 0;
- if (!req)
- return ret;
+ if (!req)
+ return ret;
- ret = rpc_receive_common (req, &frame, &state, NULL, &args,
- xdr_gfx_discard_req, GF_FOP_DISCARD);
- if (ret != 0) {
- goto out;
- }
+ ret = rpc_receive_common(req, &frame, &state, NULL, &args,
+ xdr_gfx_discard_req, GF_FOP_DISCARD);
+ if (ret != 0) {
+ goto out;
+ }
- state->resolve.type = RESOLVE_MUST;
- state->resolve.fd_no = args.fd;
+ state->resolve.type = RESOLVE_MUST;
+ state->resolve.fd_no = args.fd;
- state->offset = args.offset;
- state->size = args.size;
- memcpy(state->resolve.gfid, args.gfid, 16);
+ state->offset = args.offset;
+ state->size = args.size;
+ memcpy(state->resolve.gfid, args.gfid, 16);
- xdr_to_dict (&args.xdata, &state->xdata);
+ xdr_to_dict(&args.xdata, &state->xdata);
- ret = 0;
- resolve_and_resume (frame, server4_discard_resume);
+ ret = 0;
+ resolve_and_resume(frame, server4_discard_resume);
out:
+ if (op_errno)
+ SERVER_REQ_SET_ERROR(req, ret);
- if (op_errno)
- SERVER_REQ_SET_ERROR (req, ret);
-
- return ret;
+ return ret;
}
-
int
server4_0_zerofill(rpcsvc_request_t *req)
{
- server_state_t *state = NULL;
- call_frame_t *frame = NULL;
- gfx_zerofill_req args = {{0},};
- int ret = -1;
- int op_errno = 0;
+ server_state_t *state = NULL;
+ call_frame_t *frame = NULL;
+ gfx_zerofill_req args = {
+ {0},
+ };
+ int ret = -1;
+ int op_errno = 0;
- if (!req)
- return ret;
+ if (!req)
+ return ret;
- ret = rpc_receive_common (req, &frame, &state, NULL, &args,
- xdr_gfx_zerofill_req, GF_FOP_ZEROFILL);
- if (ret != 0) {
- op_errno = -1;
- goto out;
- }
+ ret = rpc_receive_common(req, &frame, &state, NULL, &args,
+ xdr_gfx_zerofill_req, GF_FOP_ZEROFILL);
+ if (ret != 0) {
+ op_errno = -1;
+ goto out;
+ }
- state->resolve.type = RESOLVE_MUST;
- state->resolve.fd_no = args.fd;
+ state->resolve.type = RESOLVE_MUST;
+ state->resolve.fd_no = args.fd;
- state->offset = args.offset;
- state->size = args.size;
- memcpy(state->resolve.gfid, args.gfid, 16);
+ state->offset = args.offset;
+ state->size = args.size;
+ memcpy(state->resolve.gfid, args.gfid, 16);
- xdr_to_dict (&args.xdata, &state->xdata);
- ret = 0;
- resolve_and_resume (frame, server4_zerofill_resume);
+ xdr_to_dict(&args.xdata, &state->xdata);
+ ret = 0;
+ resolve_and_resume(frame, server4_zerofill_resume);
out:
- if (op_errno)
- req->rpc_err = GARBAGE_ARGS;
+ if (op_errno)
+ req->rpc_err = GARBAGE_ARGS;
- return ret;
+ return ret;
}
int
-server4_0_ipc (rpcsvc_request_t *req)
+server4_0_ipc(rpcsvc_request_t *req)
{
- server_state_t *state = NULL;
- call_frame_t *frame = NULL;
- gfx_ipc_req args = {0,};
- int ret = -1;
- int op_errno = 0;
- xlator_t *bound_xl = NULL;
+ server_state_t *state = NULL;
+ call_frame_t *frame = NULL;
+ gfx_ipc_req args = {
+ 0,
+ };
+ int ret = -1;
+ int op_errno = 0;
+ xlator_t *bound_xl = NULL;
- if (!req)
- return ret;
+ if (!req)
+ return ret;
- ret = rpc_receive_common (req, &frame, &state, NULL, &args,
- xdr_gfx_ipc_req, GF_FOP_IPC);
- if (ret != 0) {
- op_errno = -1;
- goto out;
- }
+ ret = rpc_receive_common(req, &frame, &state, NULL, &args, xdr_gfx_ipc_req,
+ GF_FOP_IPC);
+ if (ret != 0) {
+ op_errno = -1;
+ goto out;
+ }
- bound_xl = frame->root->client->bound_xl;
- xdr_to_dict (&args.xdata, &state->xdata);
- ret = 0;
- STACK_WIND (frame, server4_ipc_cbk, bound_xl, bound_xl->fops->ipc,
- args.op, state->xdata);
+ bound_xl = frame->root->client->bound_xl;
+ xdr_to_dict(&args.xdata, &state->xdata);
+ ret = 0;
+ STACK_WIND(frame, server4_ipc_cbk, bound_xl, bound_xl->fops->ipc, args.op,
+ state->xdata);
out:
+ if (op_errno)
+ req->rpc_err = GARBAGE_ARGS;
- if (op_errno)
- req->rpc_err = GARBAGE_ARGS;
-
- return ret;
+ return ret;
}
int
-server4_0_seek (rpcsvc_request_t *req)
+server4_0_seek(rpcsvc_request_t *req)
{
- server_state_t *state = NULL;
- call_frame_t *frame = NULL;
- gfx_seek_req args = {{0,},};
- int ret = -1;
- int op_errno = 0;
+ server_state_t *state = NULL;
+ call_frame_t *frame = NULL;
+ gfx_seek_req args = {
+ {
+ 0,
+ },
+ };
+ int ret = -1;
+ int op_errno = 0;
- if (!req)
- return ret;
+ if (!req)
+ return ret;
- ret = rpc_receive_common (req, &frame, &state, NULL, &args,
- xdr_gfx_seek_req, GF_FOP_SEEK);
- if (ret != 0) {
- goto out;
- }
+ ret = rpc_receive_common(req, &frame, &state, NULL, &args, xdr_gfx_seek_req,
+ GF_FOP_SEEK);
+ if (ret != 0) {
+ goto out;
+ }
- state->resolve.type = RESOLVE_MUST;
- state->resolve.fd_no = args.fd;
+ state->resolve.type = RESOLVE_MUST;
+ state->resolve.fd_no = args.fd;
- state->offset = args.offset;
- state->what = args.what;
- memcpy(state->resolve.gfid, args.gfid, 16);
+ state->offset = args.offset;
+ state->what = args.what;
+ memcpy(state->resolve.gfid, args.gfid, 16);
- xdr_to_dict (&args.xdata, &state->xdata);
+ xdr_to_dict(&args.xdata, &state->xdata);
- ret = 0;
- resolve_and_resume (frame, server4_seek_resume);
+ ret = 0;
+ resolve_and_resume(frame, server4_seek_resume);
out:
- if (op_errno)
- SERVER_REQ_SET_ERROR (req, ret);
+ if (op_errno)
+ SERVER_REQ_SET_ERROR(req, ret);
- return ret;
+ return ret;
}
int
-server4_0_readlink (rpcsvc_request_t *req)
+server4_0_readlink(rpcsvc_request_t *req)
{
- server_state_t *state = NULL;
- call_frame_t *frame = NULL;
- gfx_readlink_req args = {{0,},};
- int ret = -1;
- int op_errno = 0;
+ server_state_t *state = NULL;
+ call_frame_t *frame = NULL;
+ gfx_readlink_req args = {
+ {
+ 0,
+ },
+ };
+ int ret = -1;
+ int op_errno = 0;
- if (!req)
- return ret;
+ if (!req)
+ return ret;
- ret = rpc_receive_common (req, &frame, &state, NULL, &args,
- xdr_gfx_readlink_req, GF_FOP_READLINK);
- if (ret != 0) {
- goto out;
- }
+ ret = rpc_receive_common(req, &frame, &state, NULL, &args,
+ xdr_gfx_readlink_req, GF_FOP_READLINK);
+ if (ret != 0) {
+ goto out;
+ }
- state->resolve.type = RESOLVE_MUST;
- memcpy (state->resolve.gfid, args.gfid, 16);
+ state->resolve.type = RESOLVE_MUST;
+ memcpy(state->resolve.gfid, args.gfid, 16);
- state->size = args.size;
+ state->size = args.size;
- xdr_to_dict (&args.xdata, &state->xdata);
+ xdr_to_dict(&args.xdata, &state->xdata);
- ret = 0;
- resolve_and_resume (frame, server4_readlink_resume);
+ ret = 0;
+ resolve_and_resume(frame, server4_readlink_resume);
out:
+ if (op_errno)
+ SERVER_REQ_SET_ERROR(req, ret);
- if (op_errno)
- SERVER_REQ_SET_ERROR (req, ret);
-
- return ret;
+ return ret;
}
-
int
-server4_0_create (rpcsvc_request_t *req)
+server4_0_create(rpcsvc_request_t *req)
{
- server_state_t *state = NULL;
- call_frame_t *frame = NULL;
- gfx_create_req args = {{0,},};
- int ret = -1;
- int op_errno = 0;
+ server_state_t *state = NULL;
+ call_frame_t *frame = NULL;
+ gfx_create_req args = {
+ {
+ 0,
+ },
+ };
+ int ret = -1;
+ int op_errno = 0;
- if (!req)
- return ret;
+ if (!req)
+ return ret;
- ret = rpc_receive_common (req, &frame, &state, NULL, &args,
- xdr_gfx_create_req, GF_FOP_CREATE);
- if (ret != 0) {
- goto out;
- }
+ ret = rpc_receive_common(req, &frame, &state, NULL, &args,
+ xdr_gfx_create_req, GF_FOP_CREATE);
+ if (ret != 0) {
+ goto out;
+ }
- state->resolve.bname = gf_strdup (args.bname);
- state->mode = args.mode;
- state->umask = args.umask;
- state->flags = gf_flags_to_flags (args.flags);
+ state->resolve.bname = gf_strdup(args.bname);
+ state->mode = args.mode;
+ state->umask = args.umask;
+ state->flags = gf_flags_to_flags(args.flags);
- set_resolve_gfid (frame->root->client, state->resolve.pargfid,
- args.pargfid);
+ set_resolve_gfid(frame->root->client, state->resolve.pargfid, args.pargfid);
- if (state->flags & O_EXCL) {
- state->resolve.type = RESOLVE_NOT;
- } else {
- state->resolve.type = RESOLVE_DONTCARE;
- }
+ if (state->flags & O_EXCL) {
+ state->resolve.type = RESOLVE_NOT;
+ } else {
+ state->resolve.type = RESOLVE_DONTCARE;
+ }
- xdr_to_dict (&args.xdata, &state->xdata);
+ xdr_to_dict(&args.xdata, &state->xdata);
- ret = 0;
- resolve_and_resume (frame, server4_create_resume);
+ ret = 0;
+ resolve_and_resume(frame, server4_create_resume);
out:
- free (args.bname);
+ free(args.bname);
- if (op_errno)
- SERVER_REQ_SET_ERROR (req, ret);
+ if (op_errno)
+ SERVER_REQ_SET_ERROR(req, ret);
- return ret;
+ return ret;
}
-
int
-server4_0_open (rpcsvc_request_t *req)
+server4_0_open(rpcsvc_request_t *req)
{
- server_state_t *state = NULL;
- call_frame_t *frame = NULL;
- gfx_open_req args = {{0,},};
- int ret = -1;
- int op_errno = 0;
+ server_state_t *state = NULL;
+ call_frame_t *frame = NULL;
+ gfx_open_req args = {
+ {
+ 0,
+ },
+ };
+ int ret = -1;
+ int op_errno = 0;
- if (!req)
- return ret;
+ if (!req)
+ return ret;
- ret = rpc_receive_common (req, &frame, &state, NULL, &args,
- xdr_gfx_open_req, GF_FOP_OPEN);
- if (ret != 0) {
- goto out;
- }
+ ret = rpc_receive_common(req, &frame, &state, NULL, &args, xdr_gfx_open_req,
+ GF_FOP_OPEN);
+ if (ret != 0) {
+ goto out;
+ }
- state->resolve.type = RESOLVE_MUST;
- memcpy (state->resolve.gfid, args.gfid, 16);
+ state->resolve.type = RESOLVE_MUST;
+ memcpy(state->resolve.gfid, args.gfid, 16);
- state->flags = gf_flags_to_flags (args.flags);
+ state->flags = gf_flags_to_flags(args.flags);
- xdr_to_dict (&args.xdata, &state->xdata);
+ xdr_to_dict(&args.xdata, &state->xdata);
- ret = 0;
- resolve_and_resume (frame, server4_open_resume);
+ ret = 0;
+ resolve_and_resume(frame, server4_open_resume);
out:
- if (op_errno)
- SERVER_REQ_SET_ERROR (req, ret);
+ if (op_errno)
+ SERVER_REQ_SET_ERROR(req, ret);
-
-
- return ret;
+ return ret;
}
-
int
-server4_0_readv (rpcsvc_request_t *req)
+server4_0_readv(rpcsvc_request_t *req)
{
- server_state_t *state = NULL;
- call_frame_t *frame = NULL;
- gfx_read_req args = {{0,},};
- int ret = -1;
- int op_errno = 0;
+ server_state_t *state = NULL;
+ call_frame_t *frame = NULL;
+ gfx_read_req args = {
+ {
+ 0,
+ },
+ };
+ int ret = -1;
+ int op_errno = 0;
- if (!req)
- goto out;
+ if (!req)
+ goto out;
- ret = rpc_receive_common (req, &frame, &state, NULL, &args,
- xdr_gfx_read_req, GF_FOP_READ);
- if (ret != 0) {
- goto out;
- }
+ ret = rpc_receive_common(req, &frame, &state, NULL, &args, xdr_gfx_read_req,
+ GF_FOP_READ);
+ if (ret != 0) {
+ goto out;
+ }
- state->resolve.type = RESOLVE_MUST;
- state->resolve.fd_no = args.fd;
- state->size = args.size;
- state->offset = args.offset;
- state->flags = args.flag;
+ state->resolve.type = RESOLVE_MUST;
+ state->resolve.fd_no = args.fd;
+ state->size = args.size;
+ state->offset = args.offset;
+ state->flags = args.flag;
- memcpy (state->resolve.gfid, args.gfid, 16);
+ memcpy(state->resolve.gfid, args.gfid, 16);
- xdr_to_dict (&args.xdata, &state->xdata);
+ xdr_to_dict(&args.xdata, &state->xdata);
- ret = 0;
- resolve_and_resume (frame, server4_readv_resume);
+ ret = 0;
+ resolve_and_resume(frame, server4_readv_resume);
out:
- if (op_errno)
- SERVER_REQ_SET_ERROR (req, ret);
+ if (op_errno)
+ SERVER_REQ_SET_ERROR(req, ret);
- return ret;
+ return ret;
}
-
int
-server4_0_writev (rpcsvc_request_t *req)
+server4_0_writev(rpcsvc_request_t *req)
{
- server_state_t *state = NULL;
- call_frame_t *frame = NULL;
- gfx_write_req args = {{0,},};
- ssize_t len = 0;
- int i = 0;
- int ret = -1;
- int op_errno = 0;
+ server_state_t *state = NULL;
+ call_frame_t *frame = NULL;
+ gfx_write_req args = {
+ {
+ 0,
+ },
+ };
+ ssize_t len = 0;
+ int i = 0;
+ int ret = -1;
+ int op_errno = 0;
+
+ if (!req)
+ return ret;
- if (!req)
- return ret;
+ ret = rpc_receive_common(req, &frame, &state, &len, &args,
+ xdr_gfx_write_req, GF_FOP_WRITE);
+ if (ret != 0) {
+ goto out;
+ }
- ret = rpc_receive_common (req, &frame, &state, &len, &args,
- xdr_gfx_write_req, GF_FOP_WRITE);
- if (ret != 0) {
- goto out;
- }
+ state->resolve.type = RESOLVE_MUST;
+ state->resolve.fd_no = args.fd;
+ state->offset = args.offset;
+ state->size = args.size;
+ state->flags = args.flag;
+ state->iobref = iobref_ref(req->iobref);
+ memcpy(state->resolve.gfid, args.gfid, 16);
- state->resolve.type = RESOLVE_MUST;
- state->resolve.fd_no = args.fd;
- state->offset = args.offset;
- state->size = args.size;
- state->flags = args.flag;
- state->iobref = iobref_ref (req->iobref);
- memcpy (state->resolve.gfid, args.gfid, 16);
-
- if (len < req->msg[0].iov_len) {
- state->payload_vector[0].iov_base
- = (req->msg[0].iov_base + len);
- state->payload_vector[0].iov_len
- = req->msg[0].iov_len - len;
- state->payload_count = 1;
- }
+ if (len < req->msg[0].iov_len) {
+ state->payload_vector[0].iov_base = (req->msg[0].iov_base + len);
+ state->payload_vector[0].iov_len = req->msg[0].iov_len - len;
+ state->payload_count = 1;
+ }
- for (i = 1; i < req->count; i++) {
- state->payload_vector[state->payload_count++]
- = req->msg[i];
- }
+ for (i = 1; i < req->count; i++) {
+ state->payload_vector[state->payload_count++] = req->msg[i];
+ }
- len = iov_length (state->payload_vector, state->payload_count);
+ len = iov_length(state->payload_vector, state->payload_count);
- GF_ASSERT (state->size == len);
+ GF_ASSERT(state->size == len);
- xdr_to_dict (&args.xdata, &state->xdata);
+ xdr_to_dict(&args.xdata, &state->xdata);
#ifdef GF_TESTING_IO_XDATA
- dict_dump_to_log (state->xdata);
+ dict_dump_to_log(state->xdata);
#endif
- ret = 0;
- resolve_and_resume (frame, server4_writev_resume);
+ ret = 0;
+ resolve_and_resume(frame, server4_writev_resume);
out:
+ if (op_errno)
+ SERVER_REQ_SET_ERROR(req, ret);
- if (op_errno)
- SERVER_REQ_SET_ERROR (req, ret);
-
- return ret;
+ return ret;
}
-
#define SERVER4_0_VECWRITE_START 0
#define SERVER4_0_VECWRITE_READING_HDR 1
#define SERVER4_0_VECWRITE_READING_OPAQUE 2
int
-server4_0_writev_vecsizer (int state, ssize_t *readsize, char *base_addr,
- char *curr_addr)
+server4_0_writev_vecsizer(int state, ssize_t *readsize, char *base_addr,
+ char *curr_addr)
{
- ssize_t size = 0;
- int nextstate = 0;
- gfx_write_req write_req = {{0,},};
- XDR xdr;
+ ssize_t size = 0;
+ int nextstate = 0;
+ gfx_write_req write_req = {
+ {
+ 0,
+ },
+ };
+ XDR xdr;
- switch (state) {
+ switch (state) {
case SERVER4_0_VECWRITE_START:
- size = xdr_sizeof ((xdrproc_t) xdr_gfx_write_req,
- &write_req);
- *readsize = size;
+ size = xdr_sizeof((xdrproc_t)xdr_gfx_write_req, &write_req);
+ *readsize = size;
- nextstate = SERVER4_0_VECWRITE_READING_HDR;
- break;
+ nextstate = SERVER4_0_VECWRITE_READING_HDR;
+ break;
case SERVER4_0_VECWRITE_READING_HDR:
- size = xdr_sizeof ((xdrproc_t) xdr_gfx_write_req,
- &write_req);
+ size = xdr_sizeof((xdrproc_t)xdr_gfx_write_req, &write_req);
- xdrmem_create (&xdr, base_addr, size, XDR_DECODE);
+ xdrmem_create(&xdr, base_addr, size, XDR_DECODE);
- /* This will fail if there is xdata sent from client, if not,
- well and good */
- xdr_gfx_write_req (&xdr, &write_req);
+ /* This will fail if there is xdata sent from client, if not,
+ well and good */
+ xdr_gfx_write_req(&xdr, &write_req);
- /* need to round off to proper roof (%4), as XDR packing pads
- the end of opaque object with '0' */
- size = roof (write_req.xdata.xdr_size, 4);
+ /* need to round off to proper roof (%4), as XDR packing pads
+ the end of opaque object with '0' */
+ size = roof(write_req.xdata.xdr_size, 4);
- *readsize = size;
+ *readsize = size;
- if (!size)
- nextstate = SERVER4_0_VECWRITE_START;
- else
- nextstate = SERVER4_0_VECWRITE_READING_OPAQUE;
+ if (!size)
+ nextstate = SERVER4_0_VECWRITE_START;
+ else
+ nextstate = SERVER4_0_VECWRITE_READING_OPAQUE;
- free (write_req.xdata.pairs.pairs_val);
+ free(write_req.xdata.pairs.pairs_val);
- break;
+ break;
case SERVER4_0_VECWRITE_READING_OPAQUE:
- *readsize = 0;
- nextstate = SERVER4_0_VECWRITE_START;
- break;
- }
+ *readsize = 0;
+ nextstate = SERVER4_0_VECWRITE_START;
+ break;
+ }
- return nextstate;
+ return nextstate;
}
-
int
-server4_0_release (rpcsvc_request_t *req)
+server4_0_release(rpcsvc_request_t *req)
{
- client_t *client = NULL;
- server_ctx_t *serv_ctx = NULL;
- gfx_release_req args = {{0,},};
- gfx_common_rsp rsp = {0,};
- int ret = -1;
-
- ret = xdr_to_generic (req->msg[0], &args,
- (xdrproc_t)xdr_gfx_release_req);
- if (ret < 0) {
- SERVER_REQ_SET_ERROR (req, ret);
- goto out;
- }
-
- client = req->trans->xl_private;
- if (!client) {
- /* Handshake is not complete yet. */
- req->rpc_err = SYSTEM_ERR;
- goto out;
- }
-
- serv_ctx = server_ctx_get (client, client->this);
- if (serv_ctx == NULL) {
- gf_msg (req->trans->name, GF_LOG_INFO, 0,
- PS_MSG_SERVER_CTX_GET_FAILED, "server_ctx_get() "
- "failed");
- req->rpc_err = SYSTEM_ERR;
- goto out;
- }
-
- gf_fd_put (serv_ctx->fdtable, args.fd);
-
- server_submit_reply (NULL, req, &rsp, NULL, 0, NULL,
- (xdrproc_t)xdr_gfx_common_rsp);
-
- ret = 0;
+ client_t *client = NULL;
+ server_ctx_t *serv_ctx = NULL;
+ gfx_release_req args = {
+ {
+ 0,
+ },
+ };
+ gfx_common_rsp rsp = {
+ 0,
+ };
+ int ret = -1;
+
+ ret = xdr_to_generic(req->msg[0], &args, (xdrproc_t)xdr_gfx_release_req);
+ if (ret < 0) {
+ SERVER_REQ_SET_ERROR(req, ret);
+ goto out;
+ }
+
+ client = req->trans->xl_private;
+ if (!client) {
+ /* Handshake is not complete yet. */
+ req->rpc_err = SYSTEM_ERR;
+ goto out;
+ }
+
+ serv_ctx = server_ctx_get(client, client->this);
+ if (serv_ctx == NULL) {
+ gf_msg(req->trans->name, GF_LOG_INFO, 0, PS_MSG_SERVER_CTX_GET_FAILED,
+ "server_ctx_get() "
+ "failed");
+ req->rpc_err = SYSTEM_ERR;
+ goto out;
+ }
+
+ gf_fd_put(serv_ctx->fdtable, args.fd);
+
+ server_submit_reply(NULL, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gfx_common_rsp);
+
+ ret = 0;
out:
- return ret;
+ return ret;
}
int
-server4_0_releasedir (rpcsvc_request_t *req)
+server4_0_releasedir(rpcsvc_request_t *req)
{
- client_t *client = NULL;
- server_ctx_t *serv_ctx = NULL;
- gfx_releasedir_req args = {{0,},};
- gfx_common_rsp rsp = {0,};
- int ret = -1;
-
- ret = xdr_to_generic (req->msg[0], &args,
- (xdrproc_t)xdr_gfx_release_req);
- if (ret < 0) {
- SERVER_REQ_SET_ERROR (req, ret);
- goto out;
- }
-
- client = req->trans->xl_private;
- if (!client) {
- SERVER_REQ_SET_ERROR (req, ret);
- goto out;
- }
-
- serv_ctx = server_ctx_get (client, client->this);
- if (serv_ctx == NULL) {
- gf_msg (req->trans->name, GF_LOG_INFO, 0,
- PS_MSG_SERVER_CTX_GET_FAILED, "server_ctx_get() "
- "failed");
- req->rpc_err = SYSTEM_ERR;
- goto out;
- }
-
- gf_fd_put (serv_ctx->fdtable, args.fd);
-
- server_submit_reply (NULL, req, &rsp, NULL, 0, NULL,
- (xdrproc_t)xdr_gfx_common_rsp);
-
- ret = 0;
+ client_t *client = NULL;
+ server_ctx_t *serv_ctx = NULL;
+ gfx_releasedir_req args = {
+ {
+ 0,
+ },
+ };
+ gfx_common_rsp rsp = {
+ 0,
+ };
+ int ret = -1;
+
+ ret = xdr_to_generic(req->msg[0], &args, (xdrproc_t)xdr_gfx_release_req);
+ if (ret < 0) {
+ SERVER_REQ_SET_ERROR(req, ret);
+ goto out;
+ }
+
+ client = req->trans->xl_private;
+ if (!client) {
+ SERVER_REQ_SET_ERROR(req, ret);
+ goto out;
+ }
+
+ serv_ctx = server_ctx_get(client, client->this);
+ if (serv_ctx == NULL) {
+ gf_msg(req->trans->name, GF_LOG_INFO, 0, PS_MSG_SERVER_CTX_GET_FAILED,
+ "server_ctx_get() "
+ "failed");
+ req->rpc_err = SYSTEM_ERR;
+ goto out;
+ }
+
+ gf_fd_put(serv_ctx->fdtable, args.fd);
+
+ server_submit_reply(NULL, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gfx_common_rsp);
+
+ ret = 0;
out:
- return ret;
+ return ret;
}
-
int
-server4_0_fsync (rpcsvc_request_t *req)
+server4_0_fsync(rpcsvc_request_t *req)
{
- server_state_t *state = NULL;
- call_frame_t *frame = NULL;
- gfx_fsync_req args = {{0,},};
- int ret = -1;
- int op_errno = 0;
+ server_state_t *state = NULL;
+ call_frame_t *frame = NULL;
+ gfx_fsync_req args = {
+ {
+ 0,
+ },
+ };
+ int ret = -1;
+ int op_errno = 0;
- if (!req)
- return ret;
+ if (!req)
+ return ret;
- ret = rpc_receive_common (req, &frame, &state, NULL, &args,
- xdr_gfx_fsync_req, GF_FOP_FSYNC);
- if (ret != 0) {
- goto out;
- }
+ ret = rpc_receive_common(req, &frame, &state, NULL, &args,
+ xdr_gfx_fsync_req, GF_FOP_FSYNC);
+ if (ret != 0) {
+ goto out;
+ }
- state->resolve.type = RESOLVE_MUST;
- state->resolve.fd_no = args.fd;
- state->flags = args.data;
- memcpy (state->resolve.gfid, args.gfid, 16);
+ state->resolve.type = RESOLVE_MUST;
+ state->resolve.fd_no = args.fd;
+ state->flags = args.data;
+ memcpy(state->resolve.gfid, args.gfid, 16);
- xdr_to_dict (&args.xdata, &state->xdata);
+ xdr_to_dict(&args.xdata, &state->xdata);
- ret = 0;
- resolve_and_resume (frame, server4_fsync_resume);
+ ret = 0;
+ resolve_and_resume(frame, server4_fsync_resume);
out:
+ if (op_errno)
+ SERVER_REQ_SET_ERROR(req, ret);
- if (op_errno)
- SERVER_REQ_SET_ERROR (req, ret);
-
- return ret;
+ return ret;
}
-
-
int
-server4_0_flush (rpcsvc_request_t *req)
+server4_0_flush(rpcsvc_request_t *req)
{
- server_state_t *state = NULL;
- call_frame_t *frame = NULL;
- gfx_flush_req args = {{0,},};
- int ret = -1;
- int op_errno = 0;
+ server_state_t *state = NULL;
+ call_frame_t *frame = NULL;
+ gfx_flush_req args = {
+ {
+ 0,
+ },
+ };
+ int ret = -1;
+ int op_errno = 0;
- if (!req)
- return ret;
+ if (!req)
+ return ret;
- ret = rpc_receive_common (req, &frame, &state, NULL, &args,
- xdr_gfx_flush_req, GF_FOP_FLUSH);
- if (ret != 0) {
- goto out;
- }
+ ret = rpc_receive_common(req, &frame, &state, NULL, &args,
+ xdr_gfx_flush_req, GF_FOP_FLUSH);
+ if (ret != 0) {
+ goto out;
+ }
- state->resolve.type = RESOLVE_MUST;
- state->resolve.fd_no = args.fd;
- memcpy (state->resolve.gfid, args.gfid, 16);
+ state->resolve.type = RESOLVE_MUST;
+ state->resolve.fd_no = args.fd;
+ memcpy(state->resolve.gfid, args.gfid, 16);
- xdr_to_dict (&args.xdata, &state->xdata);
+ xdr_to_dict(&args.xdata, &state->xdata);
- ret = 0;
- resolve_and_resume (frame, server4_flush_resume);
+ ret = 0;
+ resolve_and_resume(frame, server4_flush_resume);
out:
+ if (op_errno)
+ SERVER_REQ_SET_ERROR(req, ret);
- if (op_errno)
- SERVER_REQ_SET_ERROR (req, ret);
-
- return ret;
+ return ret;
}
-
-
int
-server4_0_ftruncate (rpcsvc_request_t *req)
+server4_0_ftruncate(rpcsvc_request_t *req)
{
- server_state_t *state = NULL;
- call_frame_t *frame = NULL;
- gfx_ftruncate_req args = {{0,},};
- int ret = -1;
- int op_errno = 0;
+ server_state_t *state = NULL;
+ call_frame_t *frame = NULL;
+ gfx_ftruncate_req args = {
+ {
+ 0,
+ },
+ };
+ int ret = -1;
+ int op_errno = 0;
- if (!req)
- return ret;
+ if (!req)
+ return ret;
- ret = rpc_receive_common (req, &frame, &state, NULL, &args,
- xdr_gfx_ftruncate_req, GF_FOP_FTRUNCATE);
- if (ret != 0) {
- goto out;
- }
+ ret = rpc_receive_common(req, &frame, &state, NULL, &args,
+ xdr_gfx_ftruncate_req, GF_FOP_FTRUNCATE);
+ if (ret != 0) {
+ goto out;
+ }
- state->resolve.type = RESOLVE_MUST;
- state->resolve.fd_no = args.fd;
- state->offset = args.offset;
- memcpy (state->resolve.gfid, args.gfid, 16);
+ state->resolve.type = RESOLVE_MUST;
+ state->resolve.fd_no = args.fd;
+ state->offset = args.offset;
+ memcpy(state->resolve.gfid, args.gfid, 16);
- xdr_to_dict (&args.xdata, &state->xdata);
+ xdr_to_dict(&args.xdata, &state->xdata);
- ret = 0;
- resolve_and_resume (frame, server4_ftruncate_resume);
+ ret = 0;
+ resolve_and_resume(frame, server4_ftruncate_resume);
out:
- if (op_errno)
- SERVER_REQ_SET_ERROR (req, ret);
+ if (op_errno)
+ SERVER_REQ_SET_ERROR(req, ret);
- return ret;
+ return ret;
}
-
int
-server4_0_fstat (rpcsvc_request_t *req)
+server4_0_fstat(rpcsvc_request_t *req)
{
- server_state_t *state = NULL;
- call_frame_t *frame = NULL;
- gfx_fstat_req args = {{0,},};
- int ret = -1;
- int op_errno = 0;
+ server_state_t *state = NULL;
+ call_frame_t *frame = NULL;
+ gfx_fstat_req args = {
+ {
+ 0,
+ },
+ };
+ int ret = -1;
+ int op_errno = 0;
- if (!req)
- return ret;
+ if (!req)
+ return ret;
- ret = rpc_receive_common (req, &frame, &state, NULL, &args,
- xdr_gfx_fstat_req, GF_FOP_FSTAT);
- if (ret != 0) {
- goto out;
- }
+ ret = rpc_receive_common(req, &frame, &state, NULL, &args,
+ xdr_gfx_fstat_req, GF_FOP_FSTAT);
+ if (ret != 0) {
+ goto out;
+ }
- state->resolve.type = RESOLVE_MUST;
- state->resolve.fd_no = args.fd;
- set_resolve_gfid (frame->root->client, state->resolve.gfid, args.gfid);
+ state->resolve.type = RESOLVE_MUST;
+ state->resolve.fd_no = args.fd;
+ set_resolve_gfid(frame->root->client, state->resolve.gfid, args.gfid);
- xdr_to_dict (&args.xdata, &state->xdata);
+ xdr_to_dict(&args.xdata, &state->xdata);
- ret = 0;
- resolve_and_resume (frame, server4_fstat_resume);
+ ret = 0;
+ resolve_and_resume(frame, server4_fstat_resume);
out:
- if (op_errno)
- SERVER_REQ_SET_ERROR (req, ret);
+ if (op_errno)
+ SERVER_REQ_SET_ERROR(req, ret);
- return ret;
+ return ret;
}
-
int
-server4_0_truncate (rpcsvc_request_t *req)
+server4_0_truncate(rpcsvc_request_t *req)
{
- server_state_t *state = NULL;
- call_frame_t *frame = NULL;
- gfx_truncate_req args = {{0,},};
- int ret = -1;
- int op_errno = 0;
+ server_state_t *state = NULL;
+ call_frame_t *frame = NULL;
+ gfx_truncate_req args = {
+ {
+ 0,
+ },
+ };
+ int ret = -1;
+ int op_errno = 0;
- if (!req)
- return ret;
+ if (!req)
+ return ret;
- ret = rpc_receive_common (req, &frame, &state, NULL, &args,
- xdr_gfx_truncate_req, GF_FOP_TRUNCATE);
- if (ret != 0) {
- goto out;
- }
+ ret = rpc_receive_common(req, &frame, &state, NULL, &args,
+ xdr_gfx_truncate_req, GF_FOP_TRUNCATE);
+ if (ret != 0) {
+ goto out;
+ }
- state->resolve.type = RESOLVE_MUST;
- memcpy (state->resolve.gfid, args.gfid, 16);
- state->offset = args.offset;
+ state->resolve.type = RESOLVE_MUST;
+ memcpy(state->resolve.gfid, args.gfid, 16);
+ state->offset = args.offset;
- xdr_to_dict (&args.xdata, &state->xdata);
+ xdr_to_dict(&args.xdata, &state->xdata);
- ret = 0;
- resolve_and_resume (frame, server4_truncate_resume);
+ ret = 0;
+ resolve_and_resume(frame, server4_truncate_resume);
out:
- if (op_errno)
- SERVER_REQ_SET_ERROR (req, ret);
+ if (op_errno)
+ SERVER_REQ_SET_ERROR(req, ret);
- return ret;
+ return ret;
}
-
-
int
-server4_0_unlink (rpcsvc_request_t *req)
+server4_0_unlink(rpcsvc_request_t *req)
{
- server_state_t *state = NULL;
- call_frame_t *frame = NULL;
- gfx_unlink_req args = {{0,},};
- int ret = -1;
- int op_errno = 0;
+ server_state_t *state = NULL;
+ call_frame_t *frame = NULL;
+ gfx_unlink_req args = {
+ {
+ 0,
+ },
+ };
+ int ret = -1;
+ int op_errno = 0;
- if (!req)
- return ret;
+ if (!req)
+ return ret;
- ret = rpc_receive_common (req, &frame, &state, NULL, &args,
- xdr_gfx_unlink_req, GF_FOP_UNLINK);
- if (ret != 0) {
- goto out;
- }
+ ret = rpc_receive_common(req, &frame, &state, NULL, &args,
+ xdr_gfx_unlink_req, GF_FOP_UNLINK);
+ if (ret != 0) {
+ goto out;
+ }
- state->resolve.type = RESOLVE_MUST;
- state->resolve.bname = gf_strdup (args.bname);
+ state->resolve.type = RESOLVE_MUST;
+ state->resolve.bname = gf_strdup(args.bname);
- set_resolve_gfid (frame->root->client, state->resolve.pargfid,
- args.pargfid);
+ set_resolve_gfid(frame->root->client, state->resolve.pargfid, args.pargfid);
- state->flags = args.xflags;
+ state->flags = args.xflags;
- xdr_to_dict (&args.xdata, &state->xdata);
+ xdr_to_dict(&args.xdata, &state->xdata);
- ret = 0;
- resolve_and_resume (frame, server4_unlink_resume);
+ ret = 0;
+ resolve_and_resume(frame, server4_unlink_resume);
out:
- free (args.bname);
+ free(args.bname);
- if (op_errno)
- SERVER_REQ_SET_ERROR (req, ret);
+ if (op_errno)
+ SERVER_REQ_SET_ERROR(req, ret);
- return ret;
+ return ret;
}
-
int
-server4_0_setxattr (rpcsvc_request_t *req)
+server4_0_setxattr(rpcsvc_request_t *req)
{
- server_state_t *state = NULL;
- call_frame_t *frame = NULL;
- gfx_setxattr_req args = {{0,},};
- int32_t ret = -1;
- int32_t op_errno = 0;
+ server_state_t *state = NULL;
+ call_frame_t *frame = NULL;
+ gfx_setxattr_req args = {
+ {
+ 0,
+ },
+ };
+ int32_t ret = -1;
+ int32_t op_errno = 0;
- if (!req)
- return ret;
+ if (!req)
+ return ret;
- ret = rpc_receive_common (req, &frame, &state, NULL, &args,
- xdr_gfx_setxattr_req, GF_FOP_SETXATTR);
- if (ret != 0) {
- goto out;
- }
+ ret = rpc_receive_common(req, &frame, &state, NULL, &args,
+ xdr_gfx_setxattr_req, GF_FOP_SETXATTR);
+ if (ret != 0) {
+ goto out;
+ }
- state->resolve.type = RESOLVE_MUST;
- state->flags = args.flags;
- set_resolve_gfid (frame->root->client, state->resolve.gfid, args.gfid);
+ state->resolve.type = RESOLVE_MUST;
+ state->flags = args.flags;
+ set_resolve_gfid(frame->root->client, state->resolve.gfid, args.gfid);
- ret = xdr_to_dict (&args.dict, &state->dict);
- if (ret)
- gf_msg_debug (THIS->name, EINVAL,
- "dictionary not received");
+ ret = xdr_to_dict(&args.dict, &state->dict);
+ if (ret)
+ gf_msg_debug(THIS->name, EINVAL, "dictionary not received");
- /* There can be some commands hidden in key, check and proceed */
- gf_server_check_setxattr_cmd (frame, state->dict);
+ /* There can be some commands hidden in key, check and proceed */
+ gf_server_check_setxattr_cmd(frame, state->dict);
- xdr_to_dict (&args.xdata, &state->xdata);
+ xdr_to_dict(&args.xdata, &state->xdata);
- ret = 0;
- resolve_and_resume (frame, server4_setxattr_resume);
+ ret = 0;
+ resolve_and_resume(frame, server4_setxattr_resume);
out:
- if (op_errno)
- SERVER_REQ_SET_ERROR (req, ret);
+ if (op_errno)
+ SERVER_REQ_SET_ERROR(req, ret);
- return ret;
+ return ret;
}
-
-
int
-server4_0_fsetxattr (rpcsvc_request_t *req)
+server4_0_fsetxattr(rpcsvc_request_t *req)
{
- server_state_t *state = NULL;
- call_frame_t *frame = NULL;
- gfx_fsetxattr_req args = {{0,},};
- int32_t ret = -1;
- int32_t op_errno = 0;
+ server_state_t *state = NULL;
+ call_frame_t *frame = NULL;
+ gfx_fsetxattr_req args = {
+ {
+ 0,
+ },
+ };
+ int32_t ret = -1;
+ int32_t op_errno = 0;
- if (!req)
- return ret;
+ if (!req)
+ return ret;
- ret = rpc_receive_common (req, &frame, &state, NULL, &args,
- xdr_gfx_fsetxattr_req, GF_FOP_FSETXATTR);
- if (ret != 0) {
- goto out;
- }
+ ret = rpc_receive_common(req, &frame, &state, NULL, &args,
+ xdr_gfx_fsetxattr_req, GF_FOP_FSETXATTR);
+ if (ret != 0) {
+ goto out;
+ }
- state->resolve.type = RESOLVE_MUST;
- state->resolve.fd_no = args.fd;
- state->flags = args.flags;
- set_resolve_gfid (frame->root->client, state->resolve.gfid, args.gfid);
+ state->resolve.type = RESOLVE_MUST;
+ state->resolve.fd_no = args.fd;
+ state->flags = args.flags;
+ set_resolve_gfid(frame->root->client, state->resolve.gfid, args.gfid);
- ret = xdr_to_dict (&args.dict, &state->dict);
- if (ret)
- gf_msg_debug (THIS->name, EINVAL,
- "dictionary not received");
+ ret = xdr_to_dict(&args.dict, &state->dict);
+ if (ret)
+ gf_msg_debug(THIS->name, EINVAL, "dictionary not received");
- xdr_to_dict (&args.xdata, &state->xdata);
+ xdr_to_dict(&args.xdata, &state->xdata);
- ret = 0;
- resolve_and_resume (frame, server4_fsetxattr_resume);
+ ret = 0;
+ resolve_and_resume(frame, server4_fsetxattr_resume);
out:
- if (op_errno)
- SERVER_REQ_SET_ERROR (req, ret);
+ if (op_errno)
+ SERVER_REQ_SET_ERROR(req, ret);
- return ret;
+ return ret;
}
-
-
int
-server4_0_fxattrop (rpcsvc_request_t *req)
+server4_0_fxattrop(rpcsvc_request_t *req)
{
- server_state_t *state = NULL;
- call_frame_t *frame = NULL;
- gfx_fxattrop_req args = {{0,},};
- int32_t ret = -1;
- int32_t op_errno = 0;
+ server_state_t *state = NULL;
+ call_frame_t *frame = NULL;
+ gfx_fxattrop_req args = {
+ {
+ 0,
+ },
+ };
+ int32_t ret = -1;
+ int32_t op_errno = 0;
- if (!req)
- return ret;
+ if (!req)
+ return ret;
- ret = rpc_receive_common (req, &frame, &state, NULL, &args,
- xdr_gfx_fxattrop_req, GF_FOP_FXATTROP);
- if (ret != 0) {
- goto out;
- }
+ ret = rpc_receive_common(req, &frame, &state, NULL, &args,
+ xdr_gfx_fxattrop_req, GF_FOP_FXATTROP);
+ if (ret != 0) {
+ goto out;
+ }
- state->resolve.type = RESOLVE_MUST;
- state->resolve.fd_no = args.fd;
- state->flags = args.flags;
- set_resolve_gfid (frame->root->client, state->resolve.gfid, args.gfid);
+ state->resolve.type = RESOLVE_MUST;
+ state->resolve.fd_no = args.fd;
+ state->flags = args.flags;
+ set_resolve_gfid(frame->root->client, state->resolve.gfid, args.gfid);
- ret = xdr_to_dict (&args.dict, &state->dict);
- if (ret)
- gf_msg_debug (THIS->name, EINVAL,
- "dictionary not received");
+ ret = xdr_to_dict(&args.dict, &state->dict);
+ if (ret)
+ gf_msg_debug(THIS->name, EINVAL, "dictionary not received");
- xdr_to_dict (&args.xdata, &state->xdata);
+ xdr_to_dict(&args.xdata, &state->xdata);
- ret = 0;
- resolve_and_resume (frame, server4_fxattrop_resume);
+ ret = 0;
+ resolve_and_resume(frame, server4_fxattrop_resume);
out:
- if (op_errno)
- SERVER_REQ_SET_ERROR (req, ret);
+ if (op_errno)
+ SERVER_REQ_SET_ERROR(req, ret);
- return ret;
+ return ret;
}
int
-server4_0_xattrop (rpcsvc_request_t *req)
+server4_0_xattrop(rpcsvc_request_t *req)
{
- server_state_t *state = NULL;
- call_frame_t *frame = NULL;
- gfx_xattrop_req args = {{0,},};
- int32_t ret = -1;
- int32_t op_errno = 0;
+ server_state_t *state = NULL;
+ call_frame_t *frame = NULL;
+ gfx_xattrop_req args = {
+ {
+ 0,
+ },
+ };
+ int32_t ret = -1;
+ int32_t op_errno = 0;
- if (!req)
- return ret;
+ if (!req)
+ return ret;
- ret = rpc_receive_common (req, &frame, &state, NULL, &args,
- xdr_gfx_xattrop_req, GF_FOP_XATTROP);
- if (ret != 0) {
- goto out;
- }
+ ret = rpc_receive_common(req, &frame, &state, NULL, &args,
+ xdr_gfx_xattrop_req, GF_FOP_XATTROP);
+ if (ret != 0) {
+ goto out;
+ }
- state->resolve.type = RESOLVE_MUST;
- state->flags = args.flags;
- set_resolve_gfid (frame->root->client, state->resolve.gfid, args.gfid);
+ state->resolve.type = RESOLVE_MUST;
+ state->flags = args.flags;
+ set_resolve_gfid(frame->root->client, state->resolve.gfid, args.gfid);
- ret = xdr_to_dict (&args.dict, &state->dict);
- if (ret)
- gf_msg_debug (THIS->name, EINVAL,
- "dictionary not received");
+ ret = xdr_to_dict(&args.dict, &state->dict);
+ if (ret)
+ gf_msg_debug(THIS->name, EINVAL, "dictionary not received");
- xdr_to_dict (&args.xdata, &state->xdata);
+ xdr_to_dict(&args.xdata, &state->xdata);
- ret = 0;
- resolve_and_resume (frame, server4_xattrop_resume);
+ ret = 0;
+ resolve_and_resume(frame, server4_xattrop_resume);
out:
- if (op_errno)
- SERVER_REQ_SET_ERROR (req, ret);
+ if (op_errno)
+ SERVER_REQ_SET_ERROR(req, ret);
- return ret;
+ return ret;
}
-
int
-server4_0_getxattr (rpcsvc_request_t *req)
+server4_0_getxattr(rpcsvc_request_t *req)
{
- server_state_t *state = NULL;
- call_frame_t *frame = NULL;
- gfx_getxattr_req args = {{0,},};
- int ret = -1;
- int op_errno = 0;
+ server_state_t *state = NULL;
+ call_frame_t *frame = NULL;
+ gfx_getxattr_req args = {
+ {
+ 0,
+ },
+ };
+ int ret = -1;
+ int op_errno = 0;
- if (!req)
- return ret;
+ if (!req)
+ return ret;
- ret = rpc_receive_common (req, &frame, &state, NULL, &args,
- xdr_gfx_getxattr_req, GF_FOP_GETXATTR);
- if (ret != 0) {
- goto out;
- }
+ ret = rpc_receive_common(req, &frame, &state, NULL, &args,
+ xdr_gfx_getxattr_req, GF_FOP_GETXATTR);
+ if (ret != 0) {
+ goto out;
+ }
- state->resolve.type = RESOLVE_MUST;
- set_resolve_gfid (frame->root->client, state->resolve.gfid, args.gfid);
+ state->resolve.type = RESOLVE_MUST;
+ set_resolve_gfid(frame->root->client, state->resolve.gfid, args.gfid);
- if (args.namelen) {
- state->name = gf_strdup (args.name);
- /* There can be some commands hidden in key, check and proceed */
- gf_server_check_getxattr_cmd (frame, state->name);
- }
+ if (args.namelen) {
+ state->name = gf_strdup(args.name);
+ /* There can be some commands hidden in key, check and proceed */
+ gf_server_check_getxattr_cmd(frame, state->name);
+ }
- xdr_to_dict (&args.xdata, &state->xdata);
+ xdr_to_dict(&args.xdata, &state->xdata);
- ret = 0;
- resolve_and_resume (frame, server4_getxattr_resume);
+ ret = 0;
+ resolve_and_resume(frame, server4_getxattr_resume);
out:
- free (args.name);
+ free(args.name);
- if (op_errno)
- SERVER_REQ_SET_ERROR (req, ret);
+ if (op_errno)
+ SERVER_REQ_SET_ERROR(req, ret);
- return ret;
+ return ret;
}
-
int
-server4_0_fgetxattr (rpcsvc_request_t *req)
+server4_0_fgetxattr(rpcsvc_request_t *req)
{
- server_state_t *state = NULL;
- call_frame_t *frame = NULL;
- gfx_fgetxattr_req args = {{0,},};
- int ret = -1;
- int op_errno = 0;
+ server_state_t *state = NULL;
+ call_frame_t *frame = NULL;
+ gfx_fgetxattr_req args = {
+ {
+ 0,
+ },
+ };
+ int ret = -1;
+ int op_errno = 0;
- if (!req)
- return ret;
+ if (!req)
+ return ret;
- ret = rpc_receive_common (req, &frame, &state, NULL, &args,
- xdr_gfx_fgetxattr_req, GF_FOP_FGETXATTR);
- if (ret != 0) {
- goto out;
- }
+ ret = rpc_receive_common(req, &frame, &state, NULL, &args,
+ xdr_gfx_fgetxattr_req, GF_FOP_FGETXATTR);
+ if (ret != 0) {
+ goto out;
+ }
- state->resolve.type = RESOLVE_MUST;
- state->resolve.fd_no = args.fd;
- set_resolve_gfid (frame->root->client, state->resolve.gfid, args.gfid);
- if (args.namelen)
- state->name = gf_strdup (args.name);
+ state->resolve.type = RESOLVE_MUST;
+ state->resolve.fd_no = args.fd;
+ set_resolve_gfid(frame->root->client, state->resolve.gfid, args.gfid);
+ if (args.namelen)
+ state->name = gf_strdup(args.name);
- xdr_to_dict (&args.xdata, &state->xdata);
+ xdr_to_dict(&args.xdata, &state->xdata);
- ret = 0;
- resolve_and_resume (frame, server4_fgetxattr_resume);
+ ret = 0;
+ resolve_and_resume(frame, server4_fgetxattr_resume);
out:
- free (args.name);
+ free(args.name);
- if (op_errno)
- SERVER_REQ_SET_ERROR (req, ret);
+ if (op_errno)
+ SERVER_REQ_SET_ERROR(req, ret);
- return ret;
+ return ret;
}
-
-
int
-server4_0_removexattr (rpcsvc_request_t *req)
+server4_0_removexattr(rpcsvc_request_t *req)
{
- server_state_t *state = NULL;
- call_frame_t *frame = NULL;
- gfx_removexattr_req args = {{0,},};
- int ret = -1;
- int op_errno = 0;
+ server_state_t *state = NULL;
+ call_frame_t *frame = NULL;
+ gfx_removexattr_req args = {
+ {
+ 0,
+ },
+ };
+ int ret = -1;
+ int op_errno = 0;
- if (!req)
- return ret;
+ if (!req)
+ return ret;
- ret = rpc_receive_common (req, &frame, &state, NULL, &args,
- xdr_gfx_removexattr_req,
- GF_FOP_REMOVEXATTR);
- if (ret != 0) {
- goto out;
- }
+ ret = rpc_receive_common(req, &frame, &state, NULL, &args,
+ xdr_gfx_removexattr_req, GF_FOP_REMOVEXATTR);
+ if (ret != 0) {
+ goto out;
+ }
- state->resolve.type = RESOLVE_MUST;
- set_resolve_gfid (frame->root->client, state->resolve.gfid, args.gfid);
- state->name = gf_strdup (args.name);
+ state->resolve.type = RESOLVE_MUST;
+ set_resolve_gfid(frame->root->client, state->resolve.gfid, args.gfid);
+ state->name = gf_strdup(args.name);
- xdr_to_dict (&args.xdata, &state->xdata);
+ xdr_to_dict(&args.xdata, &state->xdata);
- ret = 0;
- resolve_and_resume (frame, server4_removexattr_resume);
+ ret = 0;
+ resolve_and_resume(frame, server4_removexattr_resume);
out:
- free (args.name);
+ free(args.name);
- if (op_errno)
- SERVER_REQ_SET_ERROR (req, ret);
+ if (op_errno)
+ SERVER_REQ_SET_ERROR(req, ret);
- return ret;
+ return ret;
}
int
-server4_0_fremovexattr (rpcsvc_request_t *req)
+server4_0_fremovexattr(rpcsvc_request_t *req)
{
- server_state_t *state = NULL;
- call_frame_t *frame = NULL;
- gfx_fremovexattr_req args = {{0,},};
- int ret = -1;
- int op_errno = 0;
+ server_state_t *state = NULL;
+ call_frame_t *frame = NULL;
+ gfx_fremovexattr_req args = {
+ {
+ 0,
+ },
+ };
+ int ret = -1;
+ int op_errno = 0;
- if (!req)
- return ret;
+ if (!req)
+ return ret;
- ret = rpc_receive_common (req, &frame, &state, NULL, &args,
- xdr_gfx_fremovexattr_req,
- GF_FOP_FREMOVEXATTR);
- if (ret != 0) {
- goto out;
- }
+ ret = rpc_receive_common(req, &frame, &state, NULL, &args,
+ xdr_gfx_fremovexattr_req, GF_FOP_FREMOVEXATTR);
+ if (ret != 0) {
+ goto out;
+ }
- state->resolve.type = RESOLVE_MUST;
- state->resolve.fd_no = args.fd;
- set_resolve_gfid (frame->root->client, state->resolve.gfid, args.gfid);
- state->name = gf_strdup (args.name);
+ state->resolve.type = RESOLVE_MUST;
+ state->resolve.fd_no = args.fd;
+ set_resolve_gfid(frame->root->client, state->resolve.gfid, args.gfid);
+ state->name = gf_strdup(args.name);
- xdr_to_dict (&args.xdata, &state->xdata);
+ xdr_to_dict(&args.xdata, &state->xdata);
- ret = 0;
- resolve_and_resume (frame, server4_fremovexattr_resume);
+ ret = 0;
+ resolve_and_resume(frame, server4_fremovexattr_resume);
out:
- free (args.name);
+ free(args.name);
- if (op_errno)
- SERVER_REQ_SET_ERROR (req, ret);
+ if (op_errno)
+ SERVER_REQ_SET_ERROR(req, ret);
- return ret;
+ return ret;
}
-
-
-
int
-server4_0_opendir (rpcsvc_request_t *req)
+server4_0_opendir(rpcsvc_request_t *req)
{
- server_state_t *state = NULL;
- call_frame_t *frame = NULL;
- gfx_opendir_req args = {{0,},};
- int ret = -1;
- int op_errno = 0;
+ server_state_t *state = NULL;
+ call_frame_t *frame = NULL;
+ gfx_opendir_req args = {
+ {
+ 0,
+ },
+ };
+ int ret = -1;
+ int op_errno = 0;
- if (!req)
- return ret;
+ if (!req)
+ return ret;
- ret = rpc_receive_common (req, &frame, &state, NULL, &args,
- xdr_gfx_opendir_req, GF_FOP_OPENDIR);
- if (ret != 0) {
- goto out;
- }
+ ret = rpc_receive_common(req, &frame, &state, NULL, &args,
+ xdr_gfx_opendir_req, GF_FOP_OPENDIR);
+ if (ret != 0) {
+ goto out;
+ }
- state->resolve.type = RESOLVE_MUST;
- set_resolve_gfid (frame->root->client, state->resolve.gfid, args.gfid);
+ state->resolve.type = RESOLVE_MUST;
+ set_resolve_gfid(frame->root->client, state->resolve.gfid, args.gfid);
- xdr_to_dict (&args.xdata, &state->xdata);
+ xdr_to_dict(&args.xdata, &state->xdata);
- ret = 0;
- resolve_and_resume (frame, server4_opendir_resume);
+ ret = 0;
+ resolve_and_resume(frame, server4_opendir_resume);
out:
+ if (op_errno)
+ SERVER_REQ_SET_ERROR(req, ret);
- if (op_errno)
- SERVER_REQ_SET_ERROR (req, ret);
-
- return ret;
+ return ret;
}
-
int
-server4_0_readdirp (rpcsvc_request_t *req)
+server4_0_readdirp(rpcsvc_request_t *req)
{
- server_state_t *state = NULL;
- call_frame_t *frame = NULL;
- gfx_readdirp_req args = {{0,},};
- size_t headers_size = 0;
- int ret = -1;
- int op_errno = 0;
-
- if (!req)
- return ret;
-
- ret = rpc_receive_common (req, &frame, &state, NULL, &args,
- xdr_gfx_readdirp_req,
- GF_FOP_READDIRP);
- if (ret != 0) {
- goto out;
- }
+ server_state_t *state = NULL;
+ call_frame_t *frame = NULL;
+ gfx_readdirp_req args = {
+ {
+ 0,
+ },
+ };
+ size_t headers_size = 0;
+ int ret = -1;
+ int op_errno = 0;
+
+ if (!req)
+ return ret;
- /* FIXME: this should go away when variable sized iobufs are introduced
- * and transport layer can send msgs bigger than current page-size.
- */
- headers_size = sizeof (struct rpc_msg) + sizeof (gfx_readdir_rsp);
- if ((frame->this->ctx->page_size < args.size)
- || ((frame->this->ctx->page_size - args.size) < headers_size)) {
- state->size = frame->this->ctx->page_size - headers_size;
- } else {
- state->size = args.size;
- }
+ ret = rpc_receive_common(req, &frame, &state, NULL, &args,
+ xdr_gfx_readdirp_req, GF_FOP_READDIRP);
+ if (ret != 0) {
+ goto out;
+ }
+
+ /* FIXME: this should go away when variable sized iobufs are introduced
+ * and transport layer can send msgs bigger than current page-size.
+ */
+ headers_size = sizeof(struct rpc_msg) + sizeof(gfx_readdir_rsp);
+ if ((frame->this->ctx->page_size < args.size) ||
+ ((frame->this->ctx->page_size - args.size) < headers_size)) {
+ state->size = frame->this->ctx->page_size - headers_size;
+ } else {
+ state->size = args.size;
+ }
- state->resolve.type = RESOLVE_MUST;
- state->resolve.fd_no = args.fd;
- state->offset = args.offset;
- set_resolve_gfid (frame->root->client, state->resolve.gfid, args.gfid);
+ state->resolve.type = RESOLVE_MUST;
+ state->resolve.fd_no = args.fd;
+ state->offset = args.offset;
+ set_resolve_gfid(frame->root->client, state->resolve.gfid, args.gfid);
- /* here, dict itself works as xdata */
- xdr_to_dict (&args.xdata, &state->xdata);
+ /* here, dict itself works as xdata */
+ xdr_to_dict(&args.xdata, &state->xdata);
- ret = 0;
- resolve_and_resume (frame, server4_readdirp_resume);
+ ret = 0;
+ resolve_and_resume(frame, server4_readdirp_resume);
out:
- if (op_errno)
- SERVER_REQ_SET_ERROR (req, ret);
+ if (op_errno)
+ SERVER_REQ_SET_ERROR(req, ret);
- return ret;
+ return ret;
}
int
-server4_0_readdir (rpcsvc_request_t *req)
+server4_0_readdir(rpcsvc_request_t *req)
{
- server_state_t *state = NULL;
- call_frame_t *frame = NULL;
- gfx_readdir_req args = {{0,},};
- size_t headers_size = 0;
- int ret = -1;
- int op_errno = 0;
-
- if (!req)
- return ret;
-
- ret = rpc_receive_common (req, &frame, &state, NULL, &args,
- xdr_gfx_readdir_req, GF_FOP_READDIR);
- if (ret != 0) {
- goto out;
- }
+ server_state_t *state = NULL;
+ call_frame_t *frame = NULL;
+ gfx_readdir_req args = {
+ {
+ 0,
+ },
+ };
+ size_t headers_size = 0;
+ int ret = -1;
+ int op_errno = 0;
+
+ if (!req)
+ return ret;
- /* FIXME: this should go away when variable sized iobufs are introduced
- * and transport layer can send msgs bigger than current page-size.
- */
- headers_size = sizeof (struct rpc_msg) + sizeof (gfx_readdir_rsp);
- if ((frame->this->ctx->page_size < args.size)
- || ((frame->this->ctx->page_size - args.size) < headers_size)) {
- state->size = frame->this->ctx->page_size - headers_size;
- } else {
- state->size = args.size;
- }
+ ret = rpc_receive_common(req, &frame, &state, NULL, &args,
+ xdr_gfx_readdir_req, GF_FOP_READDIR);
+ if (ret != 0) {
+ goto out;
+ }
+
+ /* FIXME: this should go away when variable sized iobufs are introduced
+ * and transport layer can send msgs bigger than current page-size.
+ */
+ headers_size = sizeof(struct rpc_msg) + sizeof(gfx_readdir_rsp);
+ if ((frame->this->ctx->page_size < args.size) ||
+ ((frame->this->ctx->page_size - args.size) < headers_size)) {
+ state->size = frame->this->ctx->page_size - headers_size;
+ } else {
+ state->size = args.size;
+ }
- state->resolve.type = RESOLVE_MUST;
- state->resolve.fd_no = args.fd;
- state->offset = args.offset;
- set_resolve_gfid (frame->root->client, state->resolve.gfid, args.gfid);
+ state->resolve.type = RESOLVE_MUST;
+ state->resolve.fd_no = args.fd;
+ state->offset = args.offset;
+ set_resolve_gfid(frame->root->client, state->resolve.gfid, args.gfid);
- xdr_to_dict (&args.xdata, &state->xdata);
+ xdr_to_dict(&args.xdata, &state->xdata);
- ret = 0;
- resolve_and_resume (frame, server4_readdir_resume);
+ ret = 0;
+ resolve_and_resume(frame, server4_readdir_resume);
out:
+ if (op_errno)
+ SERVER_REQ_SET_ERROR(req, ret);
- if (op_errno)
- SERVER_REQ_SET_ERROR (req, ret);
-
- return ret;
+ return ret;
}
int
-server4_0_fsyncdir (rpcsvc_request_t *req)
+server4_0_fsyncdir(rpcsvc_request_t *req)
{
- server_state_t *state = NULL;
- call_frame_t *frame = NULL;
- gfx_fsyncdir_req args = {{0,},};
- int ret = -1;
- int op_errno = 0;
+ server_state_t *state = NULL;
+ call_frame_t *frame = NULL;
+ gfx_fsyncdir_req args = {
+ {
+ 0,
+ },
+ };
+ int ret = -1;
+ int op_errno = 0;
- if (!req)
- return ret;
+ if (!req)
+ return ret;
- ret = rpc_receive_common (req, &frame, &state, NULL, &args,
- xdr_gfx_fsyncdir_req, GF_FOP_FSYNCDIR);
- if (ret != 0) {
- goto out;
- }
+ ret = rpc_receive_common(req, &frame, &state, NULL, &args,
+ xdr_gfx_fsyncdir_req, GF_FOP_FSYNCDIR);
+ if (ret != 0) {
+ goto out;
+ }
- state->resolve.type = RESOLVE_MUST;
- state->resolve.fd_no = args.fd;
- state->flags = args.data;
- set_resolve_gfid (frame->root->client, state->resolve.gfid, args.gfid);
+ state->resolve.type = RESOLVE_MUST;
+ state->resolve.fd_no = args.fd;
+ state->flags = args.data;
+ set_resolve_gfid(frame->root->client, state->resolve.gfid, args.gfid);
- xdr_to_dict (&args.xdata, &state->xdata);
+ xdr_to_dict(&args.xdata, &state->xdata);
- ret = 0;
- resolve_and_resume (frame, server4_fsyncdir_resume);
+ ret = 0;
+ resolve_and_resume(frame, server4_fsyncdir_resume);
out:
+ if (op_errno)
+ SERVER_REQ_SET_ERROR(req, ret);
- if (op_errno)
- SERVER_REQ_SET_ERROR (req, ret);
-
- return ret;
+ return ret;
}
-
-
int
-server4_0_mknod (rpcsvc_request_t *req)
+server4_0_mknod(rpcsvc_request_t *req)
{
- server_state_t *state = NULL;
- call_frame_t *frame = NULL;
- gfx_mknod_req args = {{0,},};
- int ret = -1;
- int op_errno = 0;
+ server_state_t *state = NULL;
+ call_frame_t *frame = NULL;
+ gfx_mknod_req args = {
+ {
+ 0,
+ },
+ };
+ int ret = -1;
+ int op_errno = 0;
- if (!req)
- return ret;
+ if (!req)
+ return ret;
- ret = rpc_receive_common (req, &frame, &state, NULL, &args,
- xdr_gfx_mknod_req, GF_FOP_MKNOD);
- if (ret != 0) {
- goto out;
- }
+ ret = rpc_receive_common(req, &frame, &state, NULL, &args,
+ xdr_gfx_mknod_req, GF_FOP_MKNOD);
+ if (ret != 0) {
+ goto out;
+ }
- state->resolve.type = RESOLVE_NOT;
- set_resolve_gfid (frame->root->client, state->resolve.pargfid,
- args.pargfid);
+ state->resolve.type = RESOLVE_NOT;
+ set_resolve_gfid(frame->root->client, state->resolve.pargfid, args.pargfid);
- state->resolve.bname = gf_strdup (args.bname);
+ state->resolve.bname = gf_strdup(args.bname);
- state->mode = args.mode;
- state->dev = args.dev;
- state->umask = args.umask;
+ state->mode = args.mode;
+ state->dev = args.dev;
+ state->umask = args.umask;
- xdr_to_dict (&args.xdata, &state->xdata);
+ xdr_to_dict(&args.xdata, &state->xdata);
- ret = 0;
- resolve_and_resume (frame, server4_mknod_resume);
+ ret = 0;
+ resolve_and_resume(frame, server4_mknod_resume);
out:
- free (args.bname);
+ free(args.bname);
- if (op_errno)
- SERVER_REQ_SET_ERROR (req, ret);
-
- return ret;
+ if (op_errno)
+ SERVER_REQ_SET_ERROR(req, ret);
+ return ret;
}
-
int
-server4_0_mkdir (rpcsvc_request_t *req)
+server4_0_mkdir(rpcsvc_request_t *req)
{
- server_state_t *state = NULL;
- call_frame_t *frame = NULL;
- gfx_mkdir_req args = {{0,},};
- int ret = -1;
- int op_errno = 0;
+ server_state_t *state = NULL;
+ call_frame_t *frame = NULL;
+ gfx_mkdir_req args = {
+ {
+ 0,
+ },
+ };
+ int ret = -1;
+ int op_errno = 0;
- if (!req)
- return ret;
+ if (!req)
+ return ret;
- ret = rpc_receive_common (req, &frame, &state, NULL, &args,
- xdr_gfx_mkdir_req, GF_FOP_MKDIR);
- if (ret != 0) {
- goto out;
- }
+ ret = rpc_receive_common(req, &frame, &state, NULL, &args,
+ xdr_gfx_mkdir_req, GF_FOP_MKDIR);
+ if (ret != 0) {
+ goto out;
+ }
- state->resolve.type = RESOLVE_NOT;
- set_resolve_gfid (frame->root->client, state->resolve.pargfid,
- args.pargfid);
- state->resolve.bname = gf_strdup (args.bname);
+ state->resolve.type = RESOLVE_NOT;
+ set_resolve_gfid(frame->root->client, state->resolve.pargfid, args.pargfid);
+ state->resolve.bname = gf_strdup(args.bname);
- state->mode = args.mode;
- state->umask = args.umask;
+ state->mode = args.mode;
+ state->umask = args.umask;
- xdr_to_dict (&args.xdata, &state->xdata);
+ xdr_to_dict(&args.xdata, &state->xdata);
- ret = 0;
- resolve_and_resume (frame, server4_mkdir_resume);
+ ret = 0;
+ resolve_and_resume(frame, server4_mkdir_resume);
out:
- free (args.bname);
-
- if (op_errno)
- SERVER_REQ_SET_ERROR (req, ret);
+ free(args.bname);
+ if (op_errno)
+ SERVER_REQ_SET_ERROR(req, ret);
-
- return ret;
+ return ret;
}
-
int
-server4_0_rmdir (rpcsvc_request_t *req)
+server4_0_rmdir(rpcsvc_request_t *req)
{
- server_state_t *state = NULL;
- call_frame_t *frame = NULL;
- gfx_rmdir_req args = {{0,},};
- int ret = -1;
- int op_errno = 0;
+ server_state_t *state = NULL;
+ call_frame_t *frame = NULL;
+ gfx_rmdir_req args = {
+ {
+ 0,
+ },
+ };
+ int ret = -1;
+ int op_errno = 0;
- if (!req)
- return ret;
+ if (!req)
+ return ret;
- ret = rpc_receive_common (req, &frame, &state, NULL, &args,
- xdr_gfx_rmdir_req, GF_FOP_RMDIR);
- if (ret != 0) {
- goto out;
- }
+ ret = rpc_receive_common(req, &frame, &state, NULL, &args,
+ xdr_gfx_rmdir_req, GF_FOP_RMDIR);
+ if (ret != 0) {
+ goto out;
+ }
- state->resolve.type = RESOLVE_MUST;
- set_resolve_gfid (frame->root->client, state->resolve.pargfid,
- args.pargfid);
- state->resolve.bname = gf_strdup (args.bname);
+ state->resolve.type = RESOLVE_MUST;
+ set_resolve_gfid(frame->root->client, state->resolve.pargfid, args.pargfid);
+ state->resolve.bname = gf_strdup(args.bname);
- state->flags = args.xflags;
+ state->flags = args.xflags;
- xdr_to_dict (&args.xdata, &state->xdata);
+ xdr_to_dict(&args.xdata, &state->xdata);
- ret = 0;
- resolve_and_resume (frame, server4_rmdir_resume);
+ ret = 0;
+ resolve_and_resume(frame, server4_rmdir_resume);
out:
- free (args.bname);
+ free(args.bname);
- if (op_errno)
- SERVER_REQ_SET_ERROR (req, ret);
+ if (op_errno)
+ SERVER_REQ_SET_ERROR(req, ret);
- return ret;
+ return ret;
}
-
-
int
-server4_0_inodelk (rpcsvc_request_t *req)
+server4_0_inodelk(rpcsvc_request_t *req)
{
- server_state_t *state = NULL;
- call_frame_t *frame = NULL;
- gfx_inodelk_req args = {{0,},};
- int cmd = 0;
- int ret = -1;
- int op_errno = 0;
-
- if (!req)
- return ret;
+ server_state_t *state = NULL;
+ call_frame_t *frame = NULL;
+ gfx_inodelk_req args = {
+ {
+ 0,
+ },
+ };
+ int cmd = 0;
+ int ret = -1;
+ int op_errno = 0;
+
+ if (!req)
+ return ret;
- ret = rpc_receive_common (req, &frame, &state, NULL, &args,
- xdr_gfx_inodelk_req, GF_FOP_INODELK);
- if (ret != 0) {
- goto out;
- }
+ ret = rpc_receive_common(req, &frame, &state, NULL, &args,
+ xdr_gfx_inodelk_req, GF_FOP_INODELK);
+ if (ret != 0) {
+ goto out;
+ }
- state->resolve.type = RESOLVE_EXACT;
- set_resolve_gfid (frame->root->client, state->resolve.gfid, args.gfid);
+ state->resolve.type = RESOLVE_EXACT;
+ set_resolve_gfid(frame->root->client, state->resolve.gfid, args.gfid);
- cmd = args.cmd;
- switch (cmd) {
+ cmd = args.cmd;
+ switch (cmd) {
case GF_LK_GETLK:
- state->cmd = F_GETLK;
- break;
+ state->cmd = F_GETLK;
+ break;
case GF_LK_SETLK:
- state->cmd = F_SETLK;
- break;
+ state->cmd = F_SETLK;
+ break;
case GF_LK_SETLKW:
- state->cmd = F_SETLKW;
- break;
- }
+ state->cmd = F_SETLKW;
+ break;
+ }
- state->type = args.type;
- state->volume = gf_strdup (args.volume);
+ state->type = args.type;
+ state->volume = gf_strdup(args.volume);
- gf_proto_flock_to_flock (&args.flock, &state->flock);
+ gf_proto_flock_to_flock(&args.flock, &state->flock);
- switch (state->type) {
+ switch (state->type) {
case GF_LK_F_RDLCK:
- state->flock.l_type = F_RDLCK;
- break;
+ state->flock.l_type = F_RDLCK;
+ break;
case GF_LK_F_WRLCK:
- state->flock.l_type = F_WRLCK;
- break;
+ state->flock.l_type = F_WRLCK;
+ break;
case GF_LK_F_UNLCK:
- state->flock.l_type = F_UNLCK;
- break;
- }
+ state->flock.l_type = F_UNLCK;
+ break;
+ }
- xdr_to_dict (&args.xdata, &state->xdata);
+ xdr_to_dict(&args.xdata, &state->xdata);
- ret = 0;
- resolve_and_resume (frame, server4_inodelk_resume);
+ ret = 0;
+ resolve_and_resume(frame, server4_inodelk_resume);
out:
- free (args.volume);
+ free(args.volume);
- free (args.flock.lk_owner.lk_owner_val);
+ free(args.flock.lk_owner.lk_owner_val);
- if (op_errno)
- SERVER_REQ_SET_ERROR (req, ret);
+ if (op_errno)
+ SERVER_REQ_SET_ERROR(req, ret);
- return ret;
+ return ret;
}
int
-server4_0_finodelk (rpcsvc_request_t *req)
+server4_0_finodelk(rpcsvc_request_t *req)
{
- server_state_t *state = NULL;
- call_frame_t *frame = NULL;
- gfx_finodelk_req args = {{0,},};
- int ret = -1;
- int op_errno = 0;
+ server_state_t *state = NULL;
+ call_frame_t *frame = NULL;
+ gfx_finodelk_req args = {
+ {
+ 0,
+ },
+ };
+ int ret = -1;
+ int op_errno = 0;
- if (!req)
- return ret;
+ if (!req)
+ return ret;
- ret = rpc_receive_common (req, &frame, &state, NULL, &args,
- xdr_gfx_finodelk_req,
- GF_FOP_FINODELK);
- if (ret != 0) {
- goto out;
- }
+ ret = rpc_receive_common(req, &frame, &state, NULL, &args,
+ xdr_gfx_finodelk_req, GF_FOP_FINODELK);
+ if (ret != 0) {
+ goto out;
+ }
- state->resolve.type = RESOLVE_EXACT;
- state->volume = gf_strdup (args.volume);
- state->resolve.fd_no = args.fd;
- state->cmd = args.cmd;
- set_resolve_gfid (frame->root->client, state->resolve.gfid, args.gfid);
+ state->resolve.type = RESOLVE_EXACT;
+ state->volume = gf_strdup(args.volume);
+ state->resolve.fd_no = args.fd;
+ state->cmd = args.cmd;
+ set_resolve_gfid(frame->root->client, state->resolve.gfid, args.gfid);
- switch (state->cmd) {
+ switch (state->cmd) {
case GF_LK_GETLK:
- state->cmd = F_GETLK;
- break;
+ state->cmd = F_GETLK;
+ break;
case GF_LK_SETLK:
- state->cmd = F_SETLK;
- break;
+ state->cmd = F_SETLK;
+ break;
case GF_LK_SETLKW:
- state->cmd = F_SETLKW;
- break;
- }
+ state->cmd = F_SETLKW;
+ break;
+ }
- state->type = args.type;
+ state->type = args.type;
- gf_proto_flock_to_flock (&args.flock, &state->flock);
+ gf_proto_flock_to_flock(&args.flock, &state->flock);
- switch (state->type) {
+ switch (state->type) {
case GF_LK_F_RDLCK:
- state->flock.l_type = F_RDLCK;
- break;
+ state->flock.l_type = F_RDLCK;
+ break;
case GF_LK_F_WRLCK:
- state->flock.l_type = F_WRLCK;
- break;
+ state->flock.l_type = F_WRLCK;
+ break;
case GF_LK_F_UNLCK:
- state->flock.l_type = F_UNLCK;
- break;
- }
+ state->flock.l_type = F_UNLCK;
+ break;
+ }
- xdr_to_dict (&args.xdata, &state->xdata);
+ xdr_to_dict(&args.xdata, &state->xdata);
- ret = 0;
- resolve_and_resume (frame, server4_finodelk_resume);
+ ret = 0;
+ resolve_and_resume(frame, server4_finodelk_resume);
out:
- free (args.volume);
+ free(args.volume);
- free (args.flock.lk_owner.lk_owner_val);
+ free(args.flock.lk_owner.lk_owner_val);
- if (op_errno)
- SERVER_REQ_SET_ERROR (req, ret);
+ if (op_errno)
+ SERVER_REQ_SET_ERROR(req, ret);
- return ret;
+ return ret;
}
-
int
-server4_0_entrylk (rpcsvc_request_t *req)
+server4_0_entrylk(rpcsvc_request_t *req)
{
- server_state_t *state = NULL;
- call_frame_t *frame = NULL;
- gfx_entrylk_req args = {{0,},};
- int ret = -1;
- int op_errno = 0;
+ server_state_t *state = NULL;
+ call_frame_t *frame = NULL;
+ gfx_entrylk_req args = {
+ {
+ 0,
+ },
+ };
+ int ret = -1;
+ int op_errno = 0;
- if (!req)
- return ret;
+ if (!req)
+ return ret;
- ret = rpc_receive_common (req, &frame, &state, NULL, &args,
- xdr_gfx_entrylk_req,
- GF_FOP_ENTRYLK);
- if (ret != 0) {
- goto out;
- }
+ ret = rpc_receive_common(req, &frame, &state, NULL, &args,
+ xdr_gfx_entrylk_req, GF_FOP_ENTRYLK);
+ if (ret != 0) {
+ goto out;
+ }
- state->resolve.type = RESOLVE_EXACT;
- set_resolve_gfid (frame->root->client, state->resolve.gfid, args.gfid);
+ state->resolve.type = RESOLVE_EXACT;
+ set_resolve_gfid(frame->root->client, state->resolve.gfid, args.gfid);
- if (args.namelen)
- state->name = gf_strdup (args.name);
- state->volume = gf_strdup (args.volume);
+ if (args.namelen)
+ state->name = gf_strdup(args.name);
+ state->volume = gf_strdup(args.volume);
- state->cmd = args.cmd;
- state->type = args.type;
+ state->cmd = args.cmd;
+ state->type = args.type;
- xdr_to_dict (&args.xdata, &state->xdata);
+ xdr_to_dict(&args.xdata, &state->xdata);
- ret = 0;
- resolve_and_resume (frame, server4_entrylk_resume);
+ ret = 0;
+ resolve_and_resume(frame, server4_entrylk_resume);
out:
- free (args.volume);
- free (args.name);
+ free(args.volume);
+ free(args.name);
- if (op_errno)
- SERVER_REQ_SET_ERROR (req, ret);
+ if (op_errno)
+ SERVER_REQ_SET_ERROR(req, ret);
- return ret;
+ return ret;
}
int
-server4_0_fentrylk (rpcsvc_request_t *req)
+server4_0_fentrylk(rpcsvc_request_t *req)
{
- server_state_t *state = NULL;
- call_frame_t *frame = NULL;
- gfx_fentrylk_req args = {{0,},};
- int ret = -1;
- int op_errno = 0;
+ server_state_t *state = NULL;
+ call_frame_t *frame = NULL;
+ gfx_fentrylk_req args = {
+ {
+ 0,
+ },
+ };
+ int ret = -1;
+ int op_errno = 0;
- if (!req)
- return ret;
+ if (!req)
+ return ret;
- ret = rpc_receive_common (req, &frame, &state, NULL, &args,
- xdr_gfx_fentrylk_req,
- GF_FOP_FENTRYLK);
- if (ret != 0) {
- goto out;
- }
+ ret = rpc_receive_common(req, &frame, &state, NULL, &args,
+ xdr_gfx_fentrylk_req, GF_FOP_FENTRYLK);
+ if (ret != 0) {
+ goto out;
+ }
- state->resolve.type = RESOLVE_EXACT;
- state->resolve.fd_no = args.fd;
- state->cmd = args.cmd;
- state->type = args.type;
- set_resolve_gfid (frame->root->client, state->resolve.gfid, args.gfid);
+ state->resolve.type = RESOLVE_EXACT;
+ state->resolve.fd_no = args.fd;
+ state->cmd = args.cmd;
+ state->type = args.type;
+ set_resolve_gfid(frame->root->client, state->resolve.gfid, args.gfid);
- if (args.namelen)
- state->name = gf_strdup (args.name);
- state->volume = gf_strdup (args.volume);
+ if (args.namelen)
+ state->name = gf_strdup(args.name);
+ state->volume = gf_strdup(args.volume);
- xdr_to_dict (&args.xdata, &state->xdata);
+ xdr_to_dict(&args.xdata, &state->xdata);
- ret = 0;
- resolve_and_resume (frame, server4_fentrylk_resume);
+ ret = 0;
+ resolve_and_resume(frame, server4_fentrylk_resume);
out:
- free (args.volume);
- free (args.name);
+ free(args.volume);
+ free(args.name);
- if (op_errno)
- SERVER_REQ_SET_ERROR (req, ret);
+ if (op_errno)
+ SERVER_REQ_SET_ERROR(req, ret);
- return ret;
+ return ret;
}
int
-server4_0_access (rpcsvc_request_t *req)
+server4_0_access(rpcsvc_request_t *req)
{
- server_state_t *state = NULL;
- call_frame_t *frame = NULL;
- gfx_access_req args = {{0,},};
- int ret = -1;
- int op_errno = 0;
+ server_state_t *state = NULL;
+ call_frame_t *frame = NULL;
+ gfx_access_req args = {
+ {
+ 0,
+ },
+ };
+ int ret = -1;
+ int op_errno = 0;
- if (!req)
- return ret;
+ if (!req)
+ return ret;
- ret = rpc_receive_common (req, &frame, &state, NULL, &args,
- xdr_gfx_access_req, GF_FOP_ACCESS);
- if (ret != 0) {
- goto out;
- }
+ ret = rpc_receive_common(req, &frame, &state, NULL, &args,
+ xdr_gfx_access_req, GF_FOP_ACCESS);
+ if (ret != 0) {
+ goto out;
+ }
- state->resolve.type = RESOLVE_MUST;
- set_resolve_gfid (frame->root->client, state->resolve.gfid, args.gfid);
- state->mask = args.mask;
+ state->resolve.type = RESOLVE_MUST;
+ set_resolve_gfid(frame->root->client, state->resolve.gfid, args.gfid);
+ state->mask = args.mask;
- xdr_to_dict (&args.xdata, &state->xdata);
+ xdr_to_dict(&args.xdata, &state->xdata);
- ret = 0;
- resolve_and_resume (frame, server4_access_resume);
+ ret = 0;
+ resolve_and_resume(frame, server4_access_resume);
out:
+ if (op_errno)
+ SERVER_REQ_SET_ERROR(req, ret);
- if (op_errno)
- SERVER_REQ_SET_ERROR (req, ret);
-
- return ret;
+ return ret;
}
-
-
int
-server4_0_symlink (rpcsvc_request_t *req)
+server4_0_symlink(rpcsvc_request_t *req)
{
- server_state_t *state = NULL;
- call_frame_t *frame = NULL;
- gfx_symlink_req args = {{0,},};
- int ret = -1;
- int op_errno = 0;
+ server_state_t *state = NULL;
+ call_frame_t *frame = NULL;
+ gfx_symlink_req args = {
+ {
+ 0,
+ },
+ };
+ int ret = -1;
+ int op_errno = 0;
- if (!req)
- return ret;
+ if (!req)
+ return ret;
- ret = rpc_receive_common (req, &frame, &state, NULL, &args,
- xdr_gfx_symlink_req, GF_FOP_SYMLINK);
- if (ret != 0) {
- goto out;
- }
+ ret = rpc_receive_common(req, &frame, &state, NULL, &args,
+ xdr_gfx_symlink_req, GF_FOP_SYMLINK);
+ if (ret != 0) {
+ goto out;
+ }
- state->resolve.type = RESOLVE_NOT;
- set_resolve_gfid (frame->root->client, state->resolve.pargfid,
- args.pargfid);
- state->resolve.bname = gf_strdup (args.bname);
- state->name = gf_strdup (args.linkname);
- state->umask = args.umask;
+ state->resolve.type = RESOLVE_NOT;
+ set_resolve_gfid(frame->root->client, state->resolve.pargfid, args.pargfid);
+ state->resolve.bname = gf_strdup(args.bname);
+ state->name = gf_strdup(args.linkname);
+ state->umask = args.umask;
- xdr_to_dict (&args.xdata, &state->xdata);
+ xdr_to_dict(&args.xdata, &state->xdata);
- ret = 0;
- resolve_and_resume (frame, server4_symlink_resume);
+ ret = 0;
+ resolve_and_resume(frame, server4_symlink_resume);
out:
- free (args.bname);
- free (args.linkname);
+ free(args.bname);
+ free(args.linkname);
- if (op_errno)
- SERVER_REQ_SET_ERROR (req, ret);
+ if (op_errno)
+ SERVER_REQ_SET_ERROR(req, ret);
- return ret;
+ return ret;
}
-
int
-server4_0_link (rpcsvc_request_t *req)
+server4_0_link(rpcsvc_request_t *req)
{
- server_state_t *state = NULL;
- call_frame_t *frame = NULL;
- gfx_link_req args = {{0,},};
- int ret = -1;
- int op_errno = 0;
+ server_state_t *state = NULL;
+ call_frame_t *frame = NULL;
+ gfx_link_req args = {
+ {
+ 0,
+ },
+ };
+ int ret = -1;
+ int op_errno = 0;
- if (!req)
- return ret;
+ if (!req)
+ return ret;
- ret = rpc_receive_common (req, &frame, &state, NULL, &args,
- xdr_gfx_link_req, GF_FOP_LINK);
- if (ret != 0) {
- goto out;
- }
+ ret = rpc_receive_common(req, &frame, &state, NULL, &args, xdr_gfx_link_req,
+ GF_FOP_LINK);
+ if (ret != 0) {
+ goto out;
+ }
- state->resolve.type = RESOLVE_MUST;
- memcpy (state->resolve.gfid, args.oldgfid, 16);
+ state->resolve.type = RESOLVE_MUST;
+ memcpy(state->resolve.gfid, args.oldgfid, 16);
- state->resolve2.type = RESOLVE_NOT;
- state->resolve2.bname = gf_strdup (args.newbname);
- set_resolve_gfid (frame->root->client, state->resolve2.pargfid,
- args.newgfid);
+ state->resolve2.type = RESOLVE_NOT;
+ state->resolve2.bname = gf_strdup(args.newbname);
+ set_resolve_gfid(frame->root->client, state->resolve2.pargfid,
+ args.newgfid);
- xdr_to_dict (&args.xdata, &state->xdata);
+ xdr_to_dict(&args.xdata, &state->xdata);
- ret = 0;
- resolve_and_resume (frame, server4_link_resume);
+ ret = 0;
+ resolve_and_resume(frame, server4_link_resume);
out:
- free (args.newbname);
+ free(args.newbname);
- if (op_errno)
- SERVER_REQ_SET_ERROR (req, ret);
+ if (op_errno)
+ SERVER_REQ_SET_ERROR(req, ret);
- return ret;
+ return ret;
}
-
int
-server4_0_rename (rpcsvc_request_t *req)
+server4_0_rename(rpcsvc_request_t *req)
{
- server_state_t *state = NULL;
- call_frame_t *frame = NULL;
- gfx_rename_req args = {{0,},};
- int ret = -1;
- int op_errno = 0;
+ server_state_t *state = NULL;
+ call_frame_t *frame = NULL;
+ gfx_rename_req args = {
+ {
+ 0,
+ },
+ };
+ int ret = -1;
+ int op_errno = 0;
- if (!req)
- return ret;
+ if (!req)
+ return ret;
- ret = rpc_receive_common (req, &frame, &state, NULL, &args,
- xdr_gfx_rename_req, GF_FOP_RENAME);
- if (ret != 0) {
- goto out;
- }
+ ret = rpc_receive_common(req, &frame, &state, NULL, &args,
+ xdr_gfx_rename_req, GF_FOP_RENAME);
+ if (ret != 0) {
+ goto out;
+ }
- state->resolve.type = RESOLVE_MUST;
- state->resolve.bname = gf_strdup (args.oldbname);
- set_resolve_gfid (frame->root->client, state->resolve.pargfid,
- args.oldgfid);
+ state->resolve.type = RESOLVE_MUST;
+ state->resolve.bname = gf_strdup(args.oldbname);
+ set_resolve_gfid(frame->root->client, state->resolve.pargfid, args.oldgfid);
- state->resolve2.type = RESOLVE_MAY;
- state->resolve2.bname = gf_strdup (args.newbname);
- set_resolve_gfid (frame->root->client, state->resolve2.pargfid,
- args.newgfid);
+ state->resolve2.type = RESOLVE_MAY;
+ state->resolve2.bname = gf_strdup(args.newbname);
+ set_resolve_gfid(frame->root->client, state->resolve2.pargfid,
+ args.newgfid);
- xdr_to_dict (&args.xdata, &state->xdata);
+ xdr_to_dict(&args.xdata, &state->xdata);
- ret = 0;
- resolve_and_resume (frame, server4_rename_resume);
+ ret = 0;
+ resolve_and_resume(frame, server4_rename_resume);
out:
- free (args.oldbname);
- free (args.newbname);
+ free(args.oldbname);
+ free(args.newbname);
- if (op_errno)
- SERVER_REQ_SET_ERROR (req, ret);
+ if (op_errno)
+ SERVER_REQ_SET_ERROR(req, ret);
- return ret;
+ return ret;
}
int
-server4_0_lease (rpcsvc_request_t *req)
+server4_0_lease(rpcsvc_request_t *req)
{
- server_state_t *state = NULL;
- call_frame_t *frame = NULL;
- gfx_lease_req args = {{0,},};
- int ret = -1;
- int op_errno = 0;
+ server_state_t *state = NULL;
+ call_frame_t *frame = NULL;
+ gfx_lease_req args = {
+ {
+ 0,
+ },
+ };
+ int ret = -1;
+ int op_errno = 0;
- if (!req)
- return ret;
+ if (!req)
+ return ret;
- ret = rpc_receive_common (req, &frame, &state, NULL, &args,
- xdr_gfx_lease_req, GF_FOP_LEASE);
- if (ret != 0) {
- goto out;
- }
+ ret = rpc_receive_common(req, &frame, &state, NULL, &args,
+ xdr_gfx_lease_req, GF_FOP_LEASE);
+ if (ret != 0) {
+ goto out;
+ }
- state->resolve.type = RESOLVE_MUST;
- set_resolve_gfid (frame->root->client, state->resolve.gfid, args.gfid);
- gf_proto_lease_to_lease (&args.lease, &state->lease);
+ state->resolve.type = RESOLVE_MUST;
+ set_resolve_gfid(frame->root->client, state->resolve.gfid, args.gfid);
+ gf_proto_lease_to_lease(&args.lease, &state->lease);
- xdr_to_dict (&args.xdata, &state->xdata);
+ xdr_to_dict(&args.xdata, &state->xdata);
- ret = 0;
- resolve_and_resume (frame, server4_lease_resume);
+ ret = 0;
+ resolve_and_resume(frame, server4_lease_resume);
out:
+ if (op_errno)
+ SERVER_REQ_SET_ERROR(req, ret);
- if (op_errno)
- SERVER_REQ_SET_ERROR (req, ret);
-
- return ret;
+ return ret;
}
int
-server4_0_lk (rpcsvc_request_t *req)
+server4_0_lk(rpcsvc_request_t *req)
{
- server_state_t *state = NULL;
- call_frame_t *frame = NULL;
- gfx_lk_req args = {{0,},};
- int ret = -1;
- int op_errno = 0;
+ server_state_t *state = NULL;
+ call_frame_t *frame = NULL;
+ gfx_lk_req args = {
+ {
+ 0,
+ },
+ };
+ int ret = -1;
+ int op_errno = 0;
- if (!req)
- return ret;
+ if (!req)
+ return ret;
- ret = rpc_receive_common (req, &frame, &state, NULL, &args,
- xdr_gfx_lk_req, GF_FOP_LK);
- if (ret != 0) {
- goto out;
- }
+ ret = rpc_receive_common(req, &frame, &state, NULL, &args, xdr_gfx_lk_req,
+ GF_FOP_LK);
+ if (ret != 0) {
+ goto out;
+ }
- state->resolve.fd_no = args.fd;
- state->cmd = args.cmd;
- state->type = args.type;
- set_resolve_gfid (frame->root->client, state->resolve.gfid, args.gfid);
+ state->resolve.fd_no = args.fd;
+ state->cmd = args.cmd;
+ state->type = args.type;
+ set_resolve_gfid(frame->root->client, state->resolve.gfid, args.gfid);
- switch (state->cmd) {
+ switch (state->cmd) {
case GF_LK_GETLK:
- state->cmd = F_GETLK;
- break;
+ state->cmd = F_GETLK;
+ break;
case GF_LK_SETLK:
- state->cmd = F_SETLK;
- break;
+ state->cmd = F_SETLK;
+ break;
case GF_LK_SETLKW:
- state->cmd = F_SETLKW;
- break;
+ state->cmd = F_SETLKW;
+ break;
case GF_LK_RESLK_LCK:
- state->cmd = F_RESLK_LCK;
- break;
+ state->cmd = F_RESLK_LCK;
+ break;
case GF_LK_RESLK_LCKW:
- state->cmd = F_RESLK_LCKW;
- break;
+ state->cmd = F_RESLK_LCKW;
+ break;
case GF_LK_RESLK_UNLCK:
- state->cmd = F_RESLK_UNLCK;
- break;
+ state->cmd = F_RESLK_UNLCK;
+ break;
case GF_LK_GETLK_FD:
- state->cmd = F_GETLK_FD;
- break;
+ state->cmd = F_GETLK_FD;
+ break;
+ }
- }
-
-
- gf_proto_flock_to_flock (&args.flock, &state->flock);
+ gf_proto_flock_to_flock(&args.flock, &state->flock);
- switch (state->type) {
+ switch (state->type) {
case GF_LK_F_RDLCK:
- state->flock.l_type = F_RDLCK;
- break;
+ state->flock.l_type = F_RDLCK;
+ break;
case GF_LK_F_WRLCK:
- state->flock.l_type = F_WRLCK;
- break;
+ state->flock.l_type = F_WRLCK;
+ break;
case GF_LK_F_UNLCK:
- state->flock.l_type = F_UNLCK;
- break;
+ state->flock.l_type = F_UNLCK;
+ break;
default:
- gf_msg (frame->root->client->bound_xl->name, GF_LOG_ERROR,
- 0, PS_MSG_LOCK_ERROR, "fd - %"PRId64" (%s): Unknown "
- "lock type: %"PRId32"!", state->resolve.fd_no,
- uuid_utoa (state->fd->inode->gfid), state->type);
- break;
- }
-
-
- xdr_to_dict (&args.xdata, &state->xdata);
-
- ret = 0;
- resolve_and_resume (frame, server4_lk_resume);
+ gf_msg(frame->root->client->bound_xl->name, GF_LOG_ERROR, 0,
+ PS_MSG_LOCK_ERROR,
+ "fd - %" PRId64
+ " (%s): Unknown "
+ "lock type: %" PRId32 "!",
+ state->resolve.fd_no, uuid_utoa(state->fd->inode->gfid),
+ state->type);
+ break;
+ }
+
+ xdr_to_dict(&args.xdata, &state->xdata);
+
+ ret = 0;
+ resolve_and_resume(frame, server4_lk_resume);
out:
+ free(args.flock.lk_owner.lk_owner_val);
- free (args.flock.lk_owner.lk_owner_val);
-
- if (op_errno)
- SERVER_REQ_SET_ERROR (req, ret);
+ if (op_errno)
+ SERVER_REQ_SET_ERROR(req, ret);
- return ret;
+ return ret;
}
-
int
-server4_0_null (rpcsvc_request_t *req)
+server4_0_null(rpcsvc_request_t *req)
{
- gfx_common_rsp rsp = {0,};
+ gfx_common_rsp rsp = {
+ 0,
+ };
- /* Accepted */
- rsp.op_ret = 0;
+ /* Accepted */
+ rsp.op_ret = 0;
- server_submit_reply (NULL, req, &rsp, NULL, 0, NULL,
- (xdrproc_t)xdr_gfx_common_rsp);
+ server_submit_reply(NULL, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gfx_common_rsp);
- return 0;
+ return 0;
}
int
-server4_0_lookup (rpcsvc_request_t *req)
+server4_0_lookup(rpcsvc_request_t *req)
{
- call_frame_t *frame = NULL;
- server_state_t *state = NULL;
- gfx_lookup_req args = {{0,},};
- int ret = -1;
+ call_frame_t *frame = NULL;
+ server_state_t *state = NULL;
+ gfx_lookup_req args = {
+ {
+ 0,
+ },
+ };
+ int ret = -1;
- GF_VALIDATE_OR_GOTO ("server", req, err);
+ GF_VALIDATE_OR_GOTO("server", req, err);
- ret = rpc_receive_common (req, &frame, &state, NULL, &args,
- xdr_gfx_lookup_req, GF_FOP_LOOKUP);
- if (ret != 0) {
- goto err;
- }
+ ret = rpc_receive_common(req, &frame, &state, NULL, &args,
+ xdr_gfx_lookup_req, GF_FOP_LOOKUP);
+ if (ret != 0) {
+ goto err;
+ }
- state->resolve.type = RESOLVE_DONTCARE;
+ state->resolve.type = RESOLVE_DONTCARE;
- if (args.bname && strcmp (args.bname, "")) {
- set_resolve_gfid (frame->root->client, state->resolve.pargfid,
- args.pargfid);
- state->resolve.bname = gf_strdup (args.bname);
- } else {
- set_resolve_gfid (frame->root->client,
- state->resolve.gfid, args.gfid);
- }
+ if (args.bname && strcmp(args.bname, "")) {
+ set_resolve_gfid(frame->root->client, state->resolve.pargfid,
+ args.pargfid);
+ state->resolve.bname = gf_strdup(args.bname);
+ } else {
+ set_resolve_gfid(frame->root->client, state->resolve.gfid, args.gfid);
+ }
- xdr_to_dict (&args.xdata, &state->xdata);
+ xdr_to_dict(&args.xdata, &state->xdata);
- ret = 0;
- resolve_and_resume (frame, server4_lookup_resume);
+ ret = 0;
+ resolve_and_resume(frame, server4_lookup_resume);
err:
- free (args.bname);
+ free(args.bname);
- return ret;
+ return ret;
}
int
-server4_0_statfs (rpcsvc_request_t *req)
+server4_0_statfs(rpcsvc_request_t *req)
{
- server_state_t *state = NULL;
- call_frame_t *frame = NULL;
- gfx_statfs_req args = {{0,},};
- int ret = -1;
- int op_errno = 0;
+ server_state_t *state = NULL;
+ call_frame_t *frame = NULL;
+ gfx_statfs_req args = {
+ {
+ 0,
+ },
+ };
+ int ret = -1;
+ int op_errno = 0;
- if (!req)
- return ret;
+ if (!req)
+ return ret;
- ret = rpc_receive_common (req, &frame, &state, NULL, &args,
- xdr_gfx_statfs_req, GF_FOP_STATFS);
- if (ret != 0) {
- goto out;
- }
+ ret = rpc_receive_common(req, &frame, &state, NULL, &args,
+ xdr_gfx_statfs_req, GF_FOP_STATFS);
+ if (ret != 0) {
+ goto out;
+ }
- state->resolve.type = RESOLVE_MUST;
- set_resolve_gfid (frame->root->client, state->resolve.gfid, args.gfid);
+ state->resolve.type = RESOLVE_MUST;
+ set_resolve_gfid(frame->root->client, state->resolve.gfid, args.gfid);
- xdr_to_dict (&args.xdata, &state->xdata);
+ xdr_to_dict(&args.xdata, &state->xdata);
- ret = 0;
- resolve_and_resume (frame, server4_statfs_resume);
+ ret = 0;
+ resolve_and_resume(frame, server4_statfs_resume);
out:
- if (op_errno)
- SERVER_REQ_SET_ERROR (req, ret);
+ if (op_errno)
+ SERVER_REQ_SET_ERROR(req, ret);
- return ret;
+ return ret;
}
int
-server4_0_getactivelk (rpcsvc_request_t *req)
+server4_0_getactivelk(rpcsvc_request_t *req)
{
- server_state_t *state = NULL;
- call_frame_t *frame = NULL;
- gfx_getactivelk_req args = {{0,},};
- int ret = -1;
- int op_errno = 0;
-
- if (!req)
- return ret;
+ server_state_t *state = NULL;
+ call_frame_t *frame = NULL;
+ gfx_getactivelk_req args = {
+ {
+ 0,
+ },
+ };
+ int ret = -1;
+ int op_errno = 0;
- ret = rpc_receive_common (req, &frame, &state, NULL, &args,
- xdr_gfx_getactivelk_req,
- GF_FOP_GETACTIVELK);
- if (ret != 0) {
- goto out;
- }
+ if (!req)
+ return ret;
- state->resolve.type = RESOLVE_MUST;
- set_resolve_gfid (frame->root->client, state->resolve.gfid, args.gfid);
+ ret = rpc_receive_common(req, &frame, &state, NULL, &args,
+ xdr_gfx_getactivelk_req, GF_FOP_GETACTIVELK);
+ if (ret != 0) {
+ goto out;
+ }
- /* here, dict itself works as xdata */
- xdr_to_dict (&args.xdata, &state->xdata);
+ state->resolve.type = RESOLVE_MUST;
+ set_resolve_gfid(frame->root->client, state->resolve.gfid, args.gfid);
+ /* here, dict itself works as xdata */
+ xdr_to_dict(&args.xdata, &state->xdata);
- ret = 0;
- resolve_and_resume (frame, server4_getactivelk_resume);
+ ret = 0;
+ resolve_and_resume(frame, server4_getactivelk_resume);
out:
+ if (op_errno)
+ SERVER_REQ_SET_ERROR(req, ret);
- if (op_errno)
- SERVER_REQ_SET_ERROR (req, ret);
-
- return ret;
+ return ret;
}
-
int
-server4_0_setactivelk (rpcsvc_request_t *req)
+server4_0_setactivelk(rpcsvc_request_t *req)
{
- server_state_t *state = NULL;
- call_frame_t *frame = NULL;
- gfx_setactivelk_req args = {{0,},};
- int ret = -1;
- int op_errno = 0;
+ server_state_t *state = NULL;
+ call_frame_t *frame = NULL;
+ gfx_setactivelk_req args = {
+ {
+ 0,
+ },
+ };
+ int ret = -1;
+ int op_errno = 0;
- if (!req)
- return ret;
+ if (!req)
+ return ret;
- ret = rpc_receive_common (req, &frame, &state, NULL, &args,
- xdr_gfx_setactivelk_req,
- GF_FOP_SETACTIVELK);
- if (ret != 0) {
- goto out;
- }
+ ret = rpc_receive_common(req, &frame, &state, NULL, &args,
+ xdr_gfx_setactivelk_req, GF_FOP_SETACTIVELK);
+ if (ret != 0) {
+ goto out;
+ }
- state->resolve.type = RESOLVE_MUST;
- set_resolve_gfid (frame->root->client, state->resolve.gfid, args.gfid);
+ state->resolve.type = RESOLVE_MUST;
+ set_resolve_gfid(frame->root->client, state->resolve.gfid, args.gfid);
- /* here, dict itself works as xdata */
- xdr_to_dict (&args.xdata, &state->xdata);
+ /* here, dict itself works as xdata */
+ xdr_to_dict(&args.xdata, &state->xdata);
- ret = unserialize_req_locklist_v2 (&args, &state->locklist);
- if (ret)
- goto out;
+ ret = unserialize_req_locklist_v2(&args, &state->locklist);
+ if (ret)
+ goto out;
- ret = 0;
+ ret = 0;
- resolve_and_resume (frame, server4_setactivelk_resume);
+ resolve_and_resume(frame, server4_setactivelk_resume);
out:
- if (op_errno)
- SERVER_REQ_SET_ERROR (req, ret);
+ if (op_errno)
+ SERVER_REQ_SET_ERROR(req, ret);
- return ret;
+ return ret;
}
int
-server4_0_namelink (rpcsvc_request_t *req)
+server4_0_namelink(rpcsvc_request_t *req)
{
- server_state_t *state = NULL;
- call_frame_t *frame = NULL;
- gfx_namelink_req args = {{0,},};
- int ret = -1;
- int op_errno = 0;
+ server_state_t *state = NULL;
+ call_frame_t *frame = NULL;
+ gfx_namelink_req args = {
+ {
+ 0,
+ },
+ };
+ int ret = -1;
+ int op_errno = 0;
- if (!req)
- return ret;
+ if (!req)
+ return ret;
- ret = rpc_receive_common (req, &frame, &state, NULL, &args,
- xdr_gfx_namelink_req, GF_FOP_NAMELINK);
+ ret = rpc_receive_common(req, &frame, &state, NULL, &args,
+ xdr_gfx_namelink_req, GF_FOP_NAMELINK);
- if (ret != 0)
- goto out;
+ if (ret != 0)
+ goto out;
- state->resolve.bname = gf_strdup (args.bname);
- memcpy (state->resolve.pargfid, args.pargfid, sizeof (uuid_t));
+ state->resolve.bname = gf_strdup(args.bname);
+ memcpy(state->resolve.pargfid, args.pargfid, sizeof(uuid_t));
- state->resolve.type = RESOLVE_NOT;
+ state->resolve.type = RESOLVE_NOT;
- xdr_to_dict (&args.xdata, &state->xdata);
- ret = 0;
- resolve_and_resume (frame, server4_namelink_resume);
+ xdr_to_dict(&args.xdata, &state->xdata);
+ ret = 0;
+ resolve_and_resume(frame, server4_namelink_resume);
out:
- if (op_errno)
- SERVER_REQ_SET_ERROR (req, ret);
-
- return ret;
+ if (op_errno)
+ SERVER_REQ_SET_ERROR(req, ret);
+ return ret;
}
int
-server4_0_icreate (rpcsvc_request_t *req)
+server4_0_icreate(rpcsvc_request_t *req)
{
- server_state_t *state = NULL;
- call_frame_t *frame = NULL;
- gfx_icreate_req args = {{0,},};
- int ret = -1;
- int op_errno = 0;
- uuid_t gfid = {0,};
-
- if (!req)
- return ret;
+ server_state_t *state = NULL;
+ call_frame_t *frame = NULL;
+ gfx_icreate_req args = {
+ {
+ 0,
+ },
+ };
+ int ret = -1;
+ int op_errno = 0;
+ uuid_t gfid = {
+ 0,
+ };
+
+ if (!req)
+ return ret;
- ret = rpc_receive_common (req, &frame, &state, NULL, &args,
- xdr_gfx_icreate_req, GF_FOP_ICREATE);
+ ret = rpc_receive_common(req, &frame, &state, NULL, &args,
+ xdr_gfx_icreate_req, GF_FOP_ICREATE);
- if (ret != 0)
- goto out;
+ if (ret != 0)
+ goto out;
- memcpy (gfid, args.gfid, sizeof (uuid_t));
+ memcpy(gfid, args.gfid, sizeof(uuid_t));
- state->mode = args.mode;
- gf_asprintf (&state->resolve.bname, INODE_PATH_FMT, uuid_utoa (gfid));
+ state->mode = args.mode;
+ gf_asprintf(&state->resolve.bname, INODE_PATH_FMT, uuid_utoa(gfid));
- /* parent is an auxiliary inode number */
- memset (state->resolve.pargfid, 0, sizeof (uuid_t));
- state->resolve.pargfid[15] = GF_AUXILLARY_PARGFID;
+ /* parent is an auxiliary inode number */
+ memset(state->resolve.pargfid, 0, sizeof(uuid_t));
+ state->resolve.pargfid[15] = GF_AUXILLARY_PARGFID;
- state->resolve.type = RESOLVE_NOT;
+ state->resolve.type = RESOLVE_NOT;
- xdr_to_dict (&args.xdata, &state->xdata);
- ret = 0;
- resolve_and_resume (frame, server4_icreate_resume);
+ xdr_to_dict(&args.xdata, &state->xdata);
+ ret = 0;
+ resolve_and_resume(frame, server4_icreate_resume);
out:
- if (op_errno)
- SERVER_REQ_SET_ERROR (req, ret);
+ if (op_errno)
+ SERVER_REQ_SET_ERROR(req, ret);
- return ret;
+ return ret;
}
int
-server4_0_fsetattr (rpcsvc_request_t *req)
+server4_0_fsetattr(rpcsvc_request_t *req)
{
- server_state_t *state = NULL;
- call_frame_t *frame = NULL;
- gfx_fsetattr_req args = {{0},};
- int ret = -1;
- int op_errno = 0;
+ server_state_t *state = NULL;
+ call_frame_t *frame = NULL;
+ gfx_fsetattr_req args = {
+ {0},
+ };
+ int ret = -1;
+ int op_errno = 0;
- if (!req)
- return ret;
+ if (!req)
+ return ret;
- ret = rpc_receive_common (req, &frame, &state, NULL, &args,
- xdr_gfx_fsetattr_req,
- GF_FOP_FSETATTR);
- if (ret != 0) {
- goto out;
- }
+ ret = rpc_receive_common(req, &frame, &state, NULL, &args,
+ xdr_gfx_fsetattr_req, GF_FOP_FSETATTR);
+ if (ret != 0) {
+ goto out;
+ }
- state->resolve.type = RESOLVE_MUST;
- state->resolve.fd_no = args.fd;
- memcpy (state->resolve.gfid, args.gfid, 16);
+ state->resolve.type = RESOLVE_MUST;
+ state->resolve.fd_no = args.fd;
+ memcpy(state->resolve.gfid, args.gfid, 16);
- gfx_stat_to_iattx (&args.stbuf, &state->stbuf);
- state->valid = args.valid;
+ gfx_stat_to_iattx(&args.stbuf, &state->stbuf);
+ state->valid = args.valid;
- xdr_to_dict (&args.xdata, &state->xdata);
- ret = 0;
- resolve_and_resume (frame, server4_fsetattr_resume);
+ xdr_to_dict(&args.xdata, &state->xdata);
+ ret = 0;
+ resolve_and_resume(frame, server4_fsetattr_resume);
out:
- if (op_errno)
- SERVER_REQ_SET_ERROR (req, ret);
+ if (op_errno)
+ SERVER_REQ_SET_ERROR(req, ret);
- return ret;
+ return ret;
}
int
-server4_0_rchecksum (rpcsvc_request_t *req)
+server4_0_rchecksum(rpcsvc_request_t *req)
{
- server_state_t *state = NULL;
- call_frame_t *frame = NULL;
- gfx_rchecksum_req args = {{0},};
- int ret = -1;
- int op_errno = 0;
+ server_state_t *state = NULL;
+ call_frame_t *frame = NULL;
+ gfx_rchecksum_req args = {
+ {0},
+ };
+ int ret = -1;
+ int op_errno = 0;
- if (!req)
- return ret;
+ if (!req)
+ return ret;
- ret = rpc_receive_common (req, &frame, &state, NULL, &args,
- xdr_gfx_rchecksum_req,
- GF_FOP_RCHECKSUM);
- if (ret != 0) {
- goto out;
- }
+ ret = rpc_receive_common(req, &frame, &state, NULL, &args,
+ xdr_gfx_rchecksum_req, GF_FOP_RCHECKSUM);
+ if (ret != 0) {
+ goto out;
+ }
- state->resolve.type = RESOLVE_MAY;
- state->resolve.fd_no = args.fd;
- state->offset = args.offset;
- state->size = args.len;
+ state->resolve.type = RESOLVE_MAY;
+ state->resolve.fd_no = args.fd;
+ state->offset = args.offset;
+ state->size = args.len;
- memcpy (state->resolve.gfid, args.gfid, 16);
+ memcpy(state->resolve.gfid, args.gfid, 16);
- xdr_to_dict (&args.xdata, &state->xdata);
- ret = 0;
- resolve_and_resume (frame, server4_rchecksum_resume);
+ xdr_to_dict(&args.xdata, &state->xdata);
+ ret = 0;
+ resolve_and_resume(frame, server4_rchecksum_resume);
out:
- if (op_errno)
- SERVER_REQ_SET_ERROR (req, ret);
+ if (op_errno)
+ SERVER_REQ_SET_ERROR(req, ret);
- return ret;
+ return ret;
}
int
-server4_0_put (rpcsvc_request_t *req)
+server4_0_put(rpcsvc_request_t *req)
{
- server_state_t *state = NULL;
- call_frame_t *frame = NULL;
- gfx_put_req args = {{0,},};
- int ret = -1;
- int op_errno = 0;
- ssize_t len = 0;
- int i = 0;
+ server_state_t *state = NULL;
+ call_frame_t *frame = NULL;
+ gfx_put_req args = {
+ {
+ 0,
+ },
+ };
+ int ret = -1;
+ int op_errno = 0;
+ ssize_t len = 0;
+ int i = 0;
+
+ if (!req)
+ return ret;
- if (!req)
- return ret;
+ ret = rpc_receive_common(req, &frame, &state, &len, &args, xdr_gfx_put_req,
+ GF_FOP_PUT);
+ if (ret != 0) {
+ goto out;
+ }
- ret = rpc_receive_common (req, &frame, &state, &len, &args,
- xdr_gfx_put_req, GF_FOP_PUT);
- if (ret != 0) {
- goto out;
- }
+ state->resolve.bname = gf_strdup(args.bname);
+ state->mode = args.mode;
+ state->umask = args.umask;
+ state->flags = gf_flags_to_flags(args.flag);
+ state->offset = args.offset;
+ state->size = args.size;
+ state->iobref = iobref_ref(req->iobref);
- state->resolve.bname = gf_strdup (args.bname);
- state->mode = args.mode;
- state->umask = args.umask;
- state->flags = gf_flags_to_flags (args.flag);
- state->offset = args.offset;
- state->size = args.size;
- state->iobref = iobref_ref (req->iobref);
-
- if (len < req->msg[0].iov_len) {
- state->payload_vector[0].iov_base
- = (req->msg[0].iov_base + len);
- state->payload_vector[0].iov_len
- = req->msg[0].iov_len - len;
- state->payload_count = 1;
- }
+ if (len < req->msg[0].iov_len) {
+ state->payload_vector[0].iov_base = (req->msg[0].iov_base + len);
+ state->payload_vector[0].iov_len = req->msg[0].iov_len - len;
+ state->payload_count = 1;
+ }
- for (i = 1; i < req->count; i++) {
- state->payload_vector[state->payload_count++]
- = req->msg[i];
- }
+ for (i = 1; i < req->count; i++) {
+ state->payload_vector[state->payload_count++] = req->msg[i];
+ }
- len = iov_length (state->payload_vector, state->payload_count);
+ len = iov_length(state->payload_vector, state->payload_count);
- GF_ASSERT (state->size == len);
+ GF_ASSERT(state->size == len);
- set_resolve_gfid (frame->root->client, state->resolve.pargfid,
- args.pargfid);
+ set_resolve_gfid(frame->root->client, state->resolve.pargfid, args.pargfid);
- if (state->flags & O_EXCL) {
- state->resolve.type = RESOLVE_NOT;
- } else {
- state->resolve.type = RESOLVE_DONTCARE;
- }
+ if (state->flags & O_EXCL) {
+ state->resolve.type = RESOLVE_NOT;
+ } else {
+ state->resolve.type = RESOLVE_DONTCARE;
+ }
- xdr_to_dict (&args.xattr, &state->dict);
- xdr_to_dict (&args.xdata, &state->xdata);
+ xdr_to_dict(&args.xattr, &state->dict);
+ xdr_to_dict(&args.xdata, &state->xdata);
- ret = 0;
- resolve_and_resume (frame, server4_put_resume);
+ ret = 0;
+ resolve_and_resume(frame, server4_put_resume);
out:
- free (args.bname);
+ free(args.bname);
- if (op_errno)
- SERVER_REQ_SET_ERROR (req, ret);
+ if (op_errno)
+ SERVER_REQ_SET_ERROR(req, ret);
- return ret;
+ return ret;
}
int
-server4_compound_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
+server4_compound_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
int32_t op_ret, int32_t op_errno, void *data,
dict_t *xdata)
{
- struct gfx_compound_rsp rsp = {0,};
- server_state_t *state = NULL;
- rpcsvc_request_t *req = NULL;
- compound_args_cbk_t *args_cbk = data;
- int i = 0;
-
- req = frame->local;
- state = CALL_STATE (frame);
-
- dict_to_xdr (xdata, &rsp.xdata);
+ struct gfx_compound_rsp rsp = {
+ 0,
+ };
+ server_state_t *state = NULL;
+ rpcsvc_request_t *req = NULL;
+ compound_args_cbk_t *args_cbk = data;
+ int i = 0;
+
+ req = frame->local;
+ state = CALL_STATE(frame);
+
+ dict_to_xdr(xdata, &rsp.xdata);
+
+ if (op_ret) {
+ gf_msg(this->name, fop_log_level(GF_FOP_COMPOUND, op_errno), op_errno,
+ PS_MSG_COMPOUND_INFO,
+ "%" PRId64 ": COMPOUND%" PRId64
+ " (%s), client: %s, "
+ "error-xlator: %s",
+ frame->root->unique, state->resolve.fd_no,
+ uuid_utoa(state->resolve.gfid), STACK_CLIENT_NAME(frame->root),
+ STACK_ERR_XL_NAME(frame->root));
+ }
+
+ /* TODO: I assume a single 10MB payload is large, if not, we need to
+ agree to valid payload */
+ if ((args_cbk->fop_length <= 0) ||
+ ((args_cbk->fop_length > (10 * 1024 * 1024)))) {
+ op_ret = -1;
+ op_errno = EINVAL;
+ goto out;
+ }
+
+ rsp.compound_rsp_array.compound_rsp_array_val = GF_CALLOC(
+ args_cbk->fop_length, sizeof(compound_rsp_v2),
+ gf_server_mt_compound_rsp_t);
+
+ if (!rsp.compound_rsp_array.compound_rsp_array_val) {
+ op_ret = -1;
+ op_errno = ENOMEM;
+ goto out;
+ }
+ rsp.compound_rsp_array.compound_rsp_array_len = args_cbk->fop_length;
+
+ for (i = 0; i < args_cbk->fop_length; i++) {
+ op_ret = server_populate_compound_response_v2(this, &rsp, frame,
+ args_cbk, i);
if (op_ret) {
- gf_msg (this->name, fop_log_level (GF_FOP_COMPOUND, op_errno),
- op_errno, PS_MSG_COMPOUND_INFO,
- "%"PRId64": COMPOUND%"PRId64" (%s), client: %s, "
- "error-xlator: %s", frame->root->unique,
- state->resolve.fd_no, uuid_utoa (state->resolve.gfid),
- STACK_CLIENT_NAME (frame->root),
- STACK_ERR_XL_NAME (frame->root));
- }
-
- /* TODO: I assume a single 10MB payload is large, if not, we need to
- agree to valid payload */
- if ((args_cbk->fop_length <= 0) ||
- ((args_cbk->fop_length > (10 * 1024 * 1024)))) {
- op_ret = -1;
- op_errno = EINVAL;
- goto out;
- }
-
- rsp.compound_rsp_array.compound_rsp_array_val = GF_CALLOC
- (args_cbk->fop_length,
- sizeof (compound_rsp_v2),
- gf_server_mt_compound_rsp_t);
-
- if (!rsp.compound_rsp_array.compound_rsp_array_val) {
- op_ret = -1;
- op_errno = ENOMEM;
- goto out;
- }
- rsp.compound_rsp_array.compound_rsp_array_len = args_cbk->fop_length;
-
- for (i = 0; i < args_cbk->fop_length; i++) {
- op_ret = server_populate_compound_response_v2 (this, &rsp,
- frame,
- args_cbk, i);
-
- if (op_ret) {
- op_errno = op_ret;
- op_ret = -1;
- goto out;
- }
+ op_errno = op_ret;
+ op_ret = -1;
+ goto out;
}
+ }
out:
- rsp.op_ret = op_ret;
- rsp.op_errno = gf_errno_to_error (op_errno);
+ rsp.op_ret = op_ret;
+ rsp.op_errno = gf_errno_to_error(op_errno);
- server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
- (xdrproc_t) xdr_gfx_compound_rsp);
+ server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
+ (xdrproc_t)xdr_gfx_compound_rsp);
- server_compound_rsp_cleanup_v2 (&rsp, args_cbk);
- GF_FREE (rsp.xdata.pairs.pairs_val);
+ server_compound_rsp_cleanup_v2(&rsp, args_cbk);
+ GF_FREE(rsp.xdata.pairs.pairs_val);
- return 0;
+ return 0;
}
int
-server4_compound_resume (call_frame_t *frame, xlator_t *bound_xl)
+server4_compound_resume(call_frame_t *frame, xlator_t *bound_xl)
{
- server_state_t *state = NULL;
- gfx_compound_req *req = NULL;
- compound_args_t *args = NULL;
- int i = 0;
- int ret = -1;
- int length = 0;
- int op_errno = ENOMEM;
- compound_req_v2 *c_req = NULL;
+ server_state_t *state = NULL;
+ gfx_compound_req *req = NULL;
+ compound_args_t *args = NULL;
+ int i = 0;
+ int ret = -1;
+ int length = 0;
+ int op_errno = ENOMEM;
+ compound_req_v2 *c_req = NULL;
- state = CALL_STATE (frame);
+ state = CALL_STATE(frame);
- if (state->resolve.op_ret != 0) {
- ret = state->resolve.op_ret;
- op_errno = state->resolve.op_errno;
- goto err;
- }
+ if (state->resolve.op_ret != 0) {
+ ret = state->resolve.op_ret;
+ op_errno = state->resolve.op_errno;
+ goto err;
+ }
- req = &state->req_v2;
+ req = &state->req_v2;
- length = req->compound_req_array.compound_req_array_len;
- state->args = compound_fop_alloc (length, req->compound_fop_enum,
- state->xdata);
- args = state->args;
+ length = req->compound_req_array.compound_req_array_len;
+ state->args = compound_fop_alloc(length, req->compound_fop_enum,
+ state->xdata);
+ args = state->args;
- if (!args)
- goto err;
+ if (!args)
+ goto err;
- for (i = 0; i < length; i++) {
- c_req = &req->compound_req_array.compound_req_array_val[i];
- args->enum_list[i] = c_req->fop_enum;
+ for (i = 0; i < length; i++) {
+ c_req = &req->compound_req_array.compound_req_array_val[i];
+ args->enum_list[i] = c_req->fop_enum;
- ret = server_populate_compound_request_v2 (req, frame,
- &args->req_list[i],
- i);
+ ret = server_populate_compound_request_v2(req, frame,
+ &args->req_list[i], i);
- if (ret) {
- op_errno = ret;
- ret = -1;
- goto err;
- }
+ if (ret) {
+ op_errno = ret;
+ ret = -1;
+ goto err;
}
+ }
- STACK_WIND (frame, server4_compound_cbk,
- bound_xl, bound_xl->fops->compound,
- args, state->xdata);
+ STACK_WIND(frame, server4_compound_cbk, bound_xl, bound_xl->fops->compound,
+ args, state->xdata);
- return 0;
+ return 0;
err:
- server4_compound_cbk (frame, NULL, frame->this, ret, op_errno,
- NULL, NULL);
+ server4_compound_cbk(frame, NULL, frame->this, ret, op_errno, NULL, NULL);
- return ret;
+ return ret;
}
int
-server4_0_compound (rpcsvc_request_t *req)
+server4_0_compound(rpcsvc_request_t *req)
{
- server_state_t *state = NULL;
- call_frame_t *frame = NULL;
- gfx_compound_req args = {0,};
- ssize_t len = 0;
- int length = 0;
- int i = 0;
- int ret = -1;
- int op_errno = 0;
+ server_state_t *state = NULL;
+ call_frame_t *frame = NULL;
+ gfx_compound_req args = {
+ 0,
+ };
+ ssize_t len = 0;
+ int length = 0;
+ int i = 0;
+ int ret = -1;
+ int op_errno = 0;
- if (!req)
- return ret;
+ if (!req)
+ return ret;
- ret = rpc_receive_common (req, &frame, &state, &len, &args,
- xdr_gfx_compound_req,
- GF_FOP_COMPOUND);
- if (ret != 0) {
- goto out;
- }
+ ret = rpc_receive_common(req, &frame, &state, &len, &args,
+ xdr_gfx_compound_req, GF_FOP_COMPOUND);
+ if (ret != 0) {
+ goto out;
+ }
- state->req_v2 = args;
- state->iobref = iobref_ref (req->iobref);
+ state->req_v2 = args;
+ state->iobref = iobref_ref(req->iobref);
- if (len < req->msg[0].iov_len) {
- state->payload_vector[0].iov_base
- = (req->msg[0].iov_base + len);
- state->payload_vector[0].iov_len
- = req->msg[0].iov_len - len;
- state->payload_count = 1;
- }
+ if (len < req->msg[0].iov_len) {
+ state->payload_vector[0].iov_base = (req->msg[0].iov_base + len);
+ state->payload_vector[0].iov_len = req->msg[0].iov_len - len;
+ state->payload_count = 1;
+ }
- for (i = 1; i < req->count; i++) {
- state->payload_vector[state->payload_count++]
- = req->msg[i];
- }
+ for (i = 1; i < req->count; i++) {
+ state->payload_vector[state->payload_count++] = req->msg[i];
+ }
- state->size = iov_length (state->payload_vector, state->payload_count);
+ state->size = iov_length(state->payload_vector, state->payload_count);
- ret = server_get_compound_resolve_v2 (state, &args);
+ ret = server_get_compound_resolve_v2(state, &args);
- if (ret) {
- SERVER_REQ_SET_ERROR (req, ret);
- goto out;
- }
+ if (ret) {
+ SERVER_REQ_SET_ERROR(req, ret);
+ goto out;
+ }
- xdr_to_dict (&args.xdata, &state->xdata);
+ xdr_to_dict(&args.xdata, &state->xdata);
- ret = 0;
- resolve_and_resume (frame, server4_compound_resume);
+ ret = 0;
+ resolve_and_resume(frame, server4_compound_resume);
out:
- length = args.compound_req_array.compound_req_array_len;
- server_compound_req_cleanup_v2 (&args, length);
- free (args.compound_req_array.compound_req_array_val);
+ length = args.compound_req_array.compound_req_array_len;
+ server_compound_req_cleanup_v2(&args, length);
+ free(args.compound_req_array.compound_req_array_val);
- if (op_errno)
- SERVER_REQ_SET_ERROR (req, ret);
+ if (op_errno)
+ SERVER_REQ_SET_ERROR(req, ret);
- return ret;
+ return ret;
}
-
rpcsvc_actor_t glusterfs4_0_fop_actors[] = {
- [GFS3_OP_NULL] = { "NULL", GFS3_OP_NULL, server_null, NULL, 0},
- [GFS3_OP_STAT] = { "STAT", GFS3_OP_STAT, server4_0_stat, NULL, 0},
- [GFS3_OP_READLINK] = { "READLINK", GFS3_OP_READLINK, server4_0_readlink, NULL, 0},
- [GFS3_OP_MKNOD] = { "MKNOD", GFS3_OP_MKNOD, server4_0_mknod, NULL, 0},
- [GFS3_OP_MKDIR] = { "MKDIR", GFS3_OP_MKDIR, server4_0_mkdir, NULL, 0},
- [GFS3_OP_UNLINK] = { "UNLINK", GFS3_OP_UNLINK, server4_0_unlink, NULL, 0},
- [GFS3_OP_RMDIR] = { "RMDIR", GFS3_OP_RMDIR, server4_0_rmdir, NULL, 0},
- [GFS3_OP_SYMLINK] = { "SYMLINK", GFS3_OP_SYMLINK, server4_0_symlink, NULL, 0},
- [GFS3_OP_RENAME] = { "RENAME", GFS3_OP_RENAME, server4_0_rename, NULL, 0},
- [GFS3_OP_LINK] = { "LINK", GFS3_OP_LINK, server4_0_link, NULL, 0},
- [GFS3_OP_TRUNCATE] = { "TRUNCATE", GFS3_OP_TRUNCATE, server4_0_truncate, NULL, 0},
- [GFS3_OP_OPEN] = { "OPEN", GFS3_OP_OPEN, server4_0_open, NULL, 0},
- [GFS3_OP_READ] = { "READ", GFS3_OP_READ, server4_0_readv, NULL, 0},
- [GFS3_OP_WRITE] = { "WRITE", GFS3_OP_WRITE, server4_0_writev, server4_0_writev_vecsizer, 0},
- [GFS3_OP_STATFS] = { "STATFS", GFS3_OP_STATFS, server4_0_statfs, NULL, 0},
- [GFS3_OP_FLUSH] = { "FLUSH", GFS3_OP_FLUSH, server4_0_flush, NULL, 0},
- [GFS3_OP_FSYNC] = { "FSYNC", GFS3_OP_FSYNC, server4_0_fsync, NULL, 0},
- [GFS3_OP_GETXATTR] = { "GETXATTR", GFS3_OP_GETXATTR, server4_0_getxattr, NULL, 0},
- [GFS3_OP_SETXATTR] = { "SETXATTR", GFS3_OP_SETXATTR, server4_0_setxattr, NULL, 0},
- [GFS3_OP_REMOVEXATTR] = { "REMOVEXATTR", GFS3_OP_REMOVEXATTR, server4_0_removexattr, NULL, 0},
- [GFS3_OP_OPENDIR] = { "OPENDIR", GFS3_OP_OPENDIR, server4_0_opendir, NULL, 0},
- [GFS3_OP_FSYNCDIR] = { "FSYNCDIR", GFS3_OP_FSYNCDIR, server4_0_fsyncdir, NULL, 0},
- [GFS3_OP_ACCESS] = { "ACCESS", GFS3_OP_ACCESS, server4_0_access, NULL, 0},
- [GFS3_OP_CREATE] = { "CREATE", GFS3_OP_CREATE, server4_0_create, NULL, 0},
- [GFS3_OP_FTRUNCATE] = { "FTRUNCATE", GFS3_OP_FTRUNCATE, server4_0_ftruncate, NULL, 0},
- [GFS3_OP_FSTAT] = { "FSTAT", GFS3_OP_FSTAT, server4_0_fstat, NULL, 0},
- [GFS3_OP_LK] = { "LK", GFS3_OP_LK, server4_0_lk, NULL, 0},
- [GFS3_OP_LOOKUP] = { "LOOKUP", GFS3_OP_LOOKUP, server4_0_lookup, NULL, 0},
- [GFS3_OP_READDIR] = { "READDIR", GFS3_OP_READDIR, server4_0_readdir, NULL, 0},
- [GFS3_OP_INODELK] = { "INODELK", GFS3_OP_INODELK, server4_0_inodelk, NULL, 0},
- [GFS3_OP_FINODELK] = { "FINODELK", GFS3_OP_FINODELK, server4_0_finodelk, NULL, 0},
- [GFS3_OP_ENTRYLK] = { "ENTRYLK", GFS3_OP_ENTRYLK, server4_0_entrylk, NULL, 0},
- [GFS3_OP_FENTRYLK] = { "FENTRYLK", GFS3_OP_FENTRYLK, server4_0_fentrylk, NULL, 0},
- [GFS3_OP_XATTROP] = { "XATTROP", GFS3_OP_XATTROP, server4_0_xattrop, NULL, 0},
- [GFS3_OP_FXATTROP] = { "FXATTROP", GFS3_OP_FXATTROP, server4_0_fxattrop, NULL, 0},
- [GFS3_OP_FGETXATTR] = { "FGETXATTR", GFS3_OP_FGETXATTR, server4_0_fgetxattr, NULL, 0},
- [GFS3_OP_FSETXATTR] = { "FSETXATTR", GFS3_OP_FSETXATTR, server4_0_fsetxattr, NULL, 0},
- [GFS3_OP_RCHECKSUM] = { "RCHECKSUM", GFS3_OP_RCHECKSUM, server4_0_rchecksum, NULL, 0},
- [GFS3_OP_SETATTR] = { "SETATTR", GFS3_OP_SETATTR, server4_0_setattr, NULL, 0},
- [GFS3_OP_FSETATTR] = { "FSETATTR", GFS3_OP_FSETATTR, server4_0_fsetattr, NULL, 0},
- [GFS3_OP_READDIRP] = { "READDIRP", GFS3_OP_READDIRP, server4_0_readdirp, NULL, 0},
- [GFS3_OP_RELEASE] = { "RELEASE", GFS3_OP_RELEASE, server4_0_release, NULL, 0},
- [GFS3_OP_RELEASEDIR] = { "RELEASEDIR", GFS3_OP_RELEASEDIR, server4_0_releasedir, NULL, 0},
- [GFS3_OP_FREMOVEXATTR] = { "FREMOVEXATTR", GFS3_OP_FREMOVEXATTR, server4_0_fremovexattr, NULL, 0},
- [GFS3_OP_FALLOCATE] = {"FALLOCATE", GFS3_OP_FALLOCATE, server4_0_fallocate, NULL, 0, DRC_NA},
- [GFS3_OP_DISCARD] = {"DISCARD", GFS3_OP_DISCARD, server4_0_discard, NULL, 0, DRC_NA},
- [GFS3_OP_ZEROFILL] = {"ZEROFILL", GFS3_OP_ZEROFILL, server4_0_zerofill, NULL, 0, DRC_NA},
- [GFS3_OP_IPC] = {"IPC", GFS3_OP_IPC, server4_0_ipc, NULL, 0, DRC_NA},
- [GFS3_OP_SEEK] = {"SEEK", GFS3_OP_SEEK, server4_0_seek, NULL, 0, DRC_NA},
- [GFS3_OP_LEASE] = {"LEASE", GFS3_OP_LEASE, server4_0_lease, NULL, 0, DRC_NA},
- [GFS3_OP_GETACTIVELK] = {"GETACTIVELK", GFS3_OP_GETACTIVELK, server4_0_getactivelk, NULL, 0, DRC_NA},
- [GFS3_OP_SETACTIVELK] = {"SETACTIVELK", GFS3_OP_SETACTIVELK, server4_0_setactivelk, NULL, 0, DRC_NA},
- [GFS3_OP_COMPOUND] = {"COMPOUND", GFS3_OP_COMPOUND, server4_0_compound, NULL, 0, DRC_NA},
- [GFS3_OP_ICREATE] = {"ICREATE", GFS3_OP_ICREATE, server4_0_icreate, NULL, 0, DRC_NA},
- [GFS3_OP_NAMELINK] = {"NAMELINK", GFS3_OP_NAMELINK, server4_0_namelink, NULL, 0, DRC_NA},
+ [GFS3_OP_NULL] = {"NULL", GFS3_OP_NULL, server_null, NULL, 0},
+ [GFS3_OP_STAT] = {"STAT", GFS3_OP_STAT, server4_0_stat, NULL, 0},
+ [GFS3_OP_READLINK] = {"READLINK", GFS3_OP_READLINK, server4_0_readlink,
+ NULL, 0},
+ [GFS3_OP_MKNOD] = {"MKNOD", GFS3_OP_MKNOD, server4_0_mknod, NULL, 0},
+ [GFS3_OP_MKDIR] = {"MKDIR", GFS3_OP_MKDIR, server4_0_mkdir, NULL, 0},
+ [GFS3_OP_UNLINK] = {"UNLINK", GFS3_OP_UNLINK, server4_0_unlink, NULL, 0},
+ [GFS3_OP_RMDIR] = {"RMDIR", GFS3_OP_RMDIR, server4_0_rmdir, NULL, 0},
+ [GFS3_OP_SYMLINK] = {"SYMLINK", GFS3_OP_SYMLINK, server4_0_symlink, NULL,
+ 0},
+ [GFS3_OP_RENAME] = {"RENAME", GFS3_OP_RENAME, server4_0_rename, NULL, 0},
+ [GFS3_OP_LINK] = {"LINK", GFS3_OP_LINK, server4_0_link, NULL, 0},
+ [GFS3_OP_TRUNCATE] = {"TRUNCATE", GFS3_OP_TRUNCATE, server4_0_truncate,
+ NULL, 0},
+ [GFS3_OP_OPEN] = {"OPEN", GFS3_OP_OPEN, server4_0_open, NULL, 0},
+ [GFS3_OP_READ] = {"READ", GFS3_OP_READ, server4_0_readv, NULL, 0},
+ [GFS3_OP_WRITE] = {"WRITE", GFS3_OP_WRITE, server4_0_writev,
+ server4_0_writev_vecsizer, 0},
+ [GFS3_OP_STATFS] = {"STATFS", GFS3_OP_STATFS, server4_0_statfs, NULL, 0},
+ [GFS3_OP_FLUSH] = {"FLUSH", GFS3_OP_FLUSH, server4_0_flush, NULL, 0},
+ [GFS3_OP_FSYNC] = {"FSYNC", GFS3_OP_FSYNC, server4_0_fsync, NULL, 0},
+ [GFS3_OP_GETXATTR] = {"GETXATTR", GFS3_OP_GETXATTR, server4_0_getxattr,
+ NULL, 0},
+ [GFS3_OP_SETXATTR] = {"SETXATTR", GFS3_OP_SETXATTR, server4_0_setxattr,
+ NULL, 0},
+ [GFS3_OP_REMOVEXATTR] = {"REMOVEXATTR", GFS3_OP_REMOVEXATTR,
+ server4_0_removexattr, NULL, 0},
+ [GFS3_OP_OPENDIR] = {"OPENDIR", GFS3_OP_OPENDIR, server4_0_opendir, NULL,
+ 0},
+ [GFS3_OP_FSYNCDIR] = {"FSYNCDIR", GFS3_OP_FSYNCDIR, server4_0_fsyncdir,
+ NULL, 0},
+ [GFS3_OP_ACCESS] = {"ACCESS", GFS3_OP_ACCESS, server4_0_access, NULL, 0},
+ [GFS3_OP_CREATE] = {"CREATE", GFS3_OP_CREATE, server4_0_create, NULL, 0},
+ [GFS3_OP_FTRUNCATE] = {"FTRUNCATE", GFS3_OP_FTRUNCATE, server4_0_ftruncate,
+ NULL, 0},
+ [GFS3_OP_FSTAT] = {"FSTAT", GFS3_OP_FSTAT, server4_0_fstat, NULL, 0},
+ [GFS3_OP_LK] = {"LK", GFS3_OP_LK, server4_0_lk, NULL, 0},
+ [GFS3_OP_LOOKUP] = {"LOOKUP", GFS3_OP_LOOKUP, server4_0_lookup, NULL, 0},
+ [GFS3_OP_READDIR] = {"READDIR", GFS3_OP_READDIR, server4_0_readdir, NULL,
+ 0},
+ [GFS3_OP_INODELK] = {"INODELK", GFS3_OP_INODELK, server4_0_inodelk, NULL,
+ 0},
+ [GFS3_OP_FINODELK] = {"FINODELK", GFS3_OP_FINODELK, server4_0_finodelk,
+ NULL, 0},
+ [GFS3_OP_ENTRYLK] = {"ENTRYLK", GFS3_OP_ENTRYLK, server4_0_entrylk, NULL,
+ 0},
+ [GFS3_OP_FENTRYLK] = {"FENTRYLK", GFS3_OP_FENTRYLK, server4_0_fentrylk,
+ NULL, 0},
+ [GFS3_OP_XATTROP] = {"XATTROP", GFS3_OP_XATTROP, server4_0_xattrop, NULL,
+ 0},
+ [GFS3_OP_FXATTROP] = {"FXATTROP", GFS3_OP_FXATTROP, server4_0_fxattrop,
+ NULL, 0},
+ [GFS3_OP_FGETXATTR] = {"FGETXATTR", GFS3_OP_FGETXATTR, server4_0_fgetxattr,
+ NULL, 0},
+ [GFS3_OP_FSETXATTR] = {"FSETXATTR", GFS3_OP_FSETXATTR, server4_0_fsetxattr,
+ NULL, 0},
+ [GFS3_OP_RCHECKSUM] = {"RCHECKSUM", GFS3_OP_RCHECKSUM, server4_0_rchecksum,
+ NULL, 0},
+ [GFS3_OP_SETATTR] = {"SETATTR", GFS3_OP_SETATTR, server4_0_setattr, NULL,
+ 0},
+ [GFS3_OP_FSETATTR] = {"FSETATTR", GFS3_OP_FSETATTR, server4_0_fsetattr,
+ NULL, 0},
+ [GFS3_OP_READDIRP] = {"READDIRP", GFS3_OP_READDIRP, server4_0_readdirp,
+ NULL, 0},
+ [GFS3_OP_RELEASE] = {"RELEASE", GFS3_OP_RELEASE, server4_0_release, NULL,
+ 0},
+ [GFS3_OP_RELEASEDIR] = {"RELEASEDIR", GFS3_OP_RELEASEDIR,
+ server4_0_releasedir, NULL, 0},
+ [GFS3_OP_FREMOVEXATTR] = {"FREMOVEXATTR", GFS3_OP_FREMOVEXATTR,
+ server4_0_fremovexattr, NULL, 0},
+ [GFS3_OP_FALLOCATE] = {"FALLOCATE", GFS3_OP_FALLOCATE, server4_0_fallocate,
+ NULL, 0, DRC_NA},
+ [GFS3_OP_DISCARD] = {"DISCARD", GFS3_OP_DISCARD, server4_0_discard, NULL, 0,
+ DRC_NA},
+ [GFS3_OP_ZEROFILL] = {"ZEROFILL", GFS3_OP_ZEROFILL, server4_0_zerofill,
+ NULL, 0, DRC_NA},
+ [GFS3_OP_IPC] = {"IPC", GFS3_OP_IPC, server4_0_ipc, NULL, 0, DRC_NA},
+ [GFS3_OP_SEEK] = {"SEEK", GFS3_OP_SEEK, server4_0_seek, NULL, 0, DRC_NA},
+ [GFS3_OP_LEASE] = {"LEASE", GFS3_OP_LEASE, server4_0_lease, NULL, 0,
+ DRC_NA},
+ [GFS3_OP_GETACTIVELK] = {"GETACTIVELK", GFS3_OP_GETACTIVELK,
+ server4_0_getactivelk, NULL, 0, DRC_NA},
+ [GFS3_OP_SETACTIVELK] = {"SETACTIVELK", GFS3_OP_SETACTIVELK,
+ server4_0_setactivelk, NULL, 0, DRC_NA},
+ [GFS3_OP_COMPOUND] = {"COMPOUND", GFS3_OP_COMPOUND, server4_0_compound,
+ NULL, 0, DRC_NA},
+ [GFS3_OP_ICREATE] = {"ICREATE", GFS3_OP_ICREATE, server4_0_icreate, NULL, 0,
+ DRC_NA},
+ [GFS3_OP_NAMELINK] = {"NAMELINK", GFS3_OP_NAMELINK, server4_0_namelink,
+ NULL, 0, DRC_NA},
};
-
struct rpcsvc_program glusterfs4_0_fop_prog = {
- .progname = "GlusterFS 4.x v1",
- .prognum = GLUSTER_FOP_PROGRAM,
- .progver = GLUSTER_FOP_VERSION_v2,
- .numactors = GLUSTER_FOP_PROCCNT,
- .actors = glusterfs4_0_fop_actors,
- .ownthread = _gf_true,
+ .progname = "GlusterFS 4.x v1",
+ .prognum = GLUSTER_FOP_PROGRAM,
+ .progver = GLUSTER_FOP_VERSION_v2,
+ .numactors = GLUSTER_FOP_PROCCNT,
+ .actors = glusterfs4_0_fop_actors,
+ .ownthread = _gf_true,
};
diff --git a/xlators/protocol/server/src/server.c b/xlators/protocol/server/src/server.c
index 02096b65e2c..b9879cdf148 100644
--- a/xlators/protocol/server/src/server.c
+++ b/xlators/protocol/server/src/server.c
@@ -8,11 +8,9 @@
cases as published by the Free Software Foundation.
*/
-
#include <sys/time.h>
#include <sys/resource.h>
-
#include "server.h"
#include "server-helpers.h"
#include "glusterfs3-xdr.h"
@@ -27,1222 +25,1176 @@
#include "glusterfsd.h"
rpcsvc_cbk_program_t server_cbk_prog = {
- .progname = "Gluster Callback",
- .prognum = GLUSTER_CBK_PROGRAM,
- .progver = GLUSTER_CBK_VERSION,
+ .progname = "Gluster Callback",
+ .prognum = GLUSTER_CBK_PROGRAM,
+ .progver = GLUSTER_CBK_VERSION,
};
struct iobuf *
-gfs_serialize_reply (rpcsvc_request_t *req, void *arg, struct iovec *outmsg,
- xdrproc_t xdrproc)
+gfs_serialize_reply(rpcsvc_request_t *req, void *arg, struct iovec *outmsg,
+ xdrproc_t xdrproc)
{
- struct iobuf *iob = NULL;
- ssize_t retlen = 0;
- ssize_t xdr_size = 0;
-
- GF_VALIDATE_OR_GOTO ("server", req, ret);
-
- /* First, get the io buffer into which the reply in arg will
- * be serialized.
+ struct iobuf *iob = NULL;
+ ssize_t retlen = 0;
+ ssize_t xdr_size = 0;
+
+ GF_VALIDATE_OR_GOTO("server", req, ret);
+
+ /* First, get the io buffer into which the reply in arg will
+ * be serialized.
+ */
+ if (arg && xdrproc) {
+ xdr_size = xdr_sizeof(xdrproc, arg);
+ iob = iobuf_get2(req->svc->ctx->iobuf_pool, xdr_size);
+ if (!iob) {
+ gf_msg_callingfn(THIS->name, GF_LOG_ERROR, ENOMEM, PS_MSG_NO_MEMORY,
+ "Failed to get iobuf");
+ goto ret;
+ };
+
+ iobuf_to_iovec(iob, outmsg);
+ /* Use the given serializer to translate the give C structure in arg
+ * to XDR format which will be written into the buffer in outmsg.
+ */
+ /* retlen is used to received the error since size_t is unsigned and we
+ * need -1 for error notification during encoding.
*/
- if (arg && xdrproc) {
- xdr_size = xdr_sizeof (xdrproc, arg);
- iob = iobuf_get2 (req->svc->ctx->iobuf_pool, xdr_size);
- if (!iob) {
- gf_msg_callingfn (THIS->name, GF_LOG_ERROR, ENOMEM,
- PS_MSG_NO_MEMORY,
- "Failed to get iobuf");
- goto ret;
- };
-
- iobuf_to_iovec (iob, outmsg);
- /* Use the given serializer to translate the give C structure in arg
- * to XDR format which will be written into the buffer in outmsg.
- */
- /* retlen is used to received the error since size_t is unsigned and we
- * need -1 for error notification during encoding.
- */
- retlen = xdr_serialize_generic (*outmsg, arg, xdrproc);
- if (retlen == -1) {
- /* Failed to Encode 'GlusterFS' msg in RPC is not exactly
- failure of RPC return values.. client should get
- notified about this, so there are no missing frames */
- gf_msg_callingfn ("", GF_LOG_ERROR, 0,
- PS_MSG_ENCODE_MSG_FAILED,
- "Failed to encode message");
- req->rpc_err = GARBAGE_ARGS;
- retlen = 0;
- }
+ retlen = xdr_serialize_generic(*outmsg, arg, xdrproc);
+ if (retlen == -1) {
+ /* Failed to Encode 'GlusterFS' msg in RPC is not exactly
+ failure of RPC return values.. client should get
+ notified about this, so there are no missing frames */
+ gf_msg_callingfn("", GF_LOG_ERROR, 0, PS_MSG_ENCODE_MSG_FAILED,
+ "Failed to encode message");
+ req->rpc_err = GARBAGE_ARGS;
+ retlen = 0;
}
- outmsg->iov_len = retlen;
+ }
+ outmsg->iov_len = retlen;
ret:
- return iob;
+ return iob;
}
int
-server_submit_reply (call_frame_t *frame, rpcsvc_request_t *req, void *arg,
- struct iovec *payload, int payloadcount,
- struct iobref *iobref, xdrproc_t xdrproc)
+server_submit_reply(call_frame_t *frame, rpcsvc_request_t *req, void *arg,
+ struct iovec *payload, int payloadcount,
+ struct iobref *iobref, xdrproc_t xdrproc)
{
- struct iobuf *iob = NULL;
- int ret = -1;
- struct iovec rsp = {0,};
- server_state_t *state = NULL;
- char new_iobref = 0;
- client_t *client = NULL;
-
- GF_VALIDATE_OR_GOTO ("server", req, ret);
-
- if (frame) {
- state = CALL_STATE (frame);
- frame->local = NULL;
- client = frame->root->client;
- }
-
+ struct iobuf *iob = NULL;
+ int ret = -1;
+ struct iovec rsp = {
+ 0,
+ };
+ server_state_t *state = NULL;
+ char new_iobref = 0;
+ client_t *client = NULL;
+
+ GF_VALIDATE_OR_GOTO("server", req, ret);
+
+ if (frame) {
+ state = CALL_STATE(frame);
+ frame->local = NULL;
+ client = frame->root->client;
+ }
+
+ if (!iobref) {
+ iobref = iobref_new();
if (!iobref) {
- iobref = iobref_new ();
- if (!iobref) {
- goto ret;
- }
-
- new_iobref = 1;
- }
-
- iob = gfs_serialize_reply (req, arg, &rsp, xdrproc);
- if (!iob) {
- gf_msg ("", GF_LOG_ERROR, 0, PS_MSG_SERIALIZE_REPLY_FAILED,
- "Failed to serialize reply");
- goto ret;
+ goto ret;
}
- iobref_add (iobref, iob);
-
- /* Then, submit the message for transmission. */
- ret = rpcsvc_submit_generic (req, &rsp, 1, payload, payloadcount,
- iobref);
-
- /* TODO: this is demo purpose only */
- /* ret = rpcsvc_callback_submit (req->svc, req->trans, req->prog,
- GF_CBK_NULL, &rsp, 1);
- */
- /* Now that we've done our job of handing the message to the RPC layer
- * we can safely unref the iob in the hope that RPC layer must have
- * ref'ed the iob on receiving into the txlist.
- */
- iobuf_unref (iob);
- if (ret == -1) {
- gf_msg_callingfn ("", GF_LOG_ERROR, 0,
- PS_MSG_REPLY_SUBMIT_FAILED,
- "Reply submission failed");
- if (frame && client) {
- server_connection_cleanup (frame->this, client,
- INTERNAL_LOCKS | POSIX_LOCKS);
- } else {
- gf_msg_callingfn ("", GF_LOG_ERROR, 0,
- PS_MSG_REPLY_SUBMIT_FAILED,
- "Reply submission failed");
- /* TODO: Failure of open(dir), create, inodelk, entrylk
- or lk fops send failure must be handled specially. */
- }
- goto ret;
+ new_iobref = 1;
+ }
+
+ iob = gfs_serialize_reply(req, arg, &rsp, xdrproc);
+ if (!iob) {
+ gf_msg("", GF_LOG_ERROR, 0, PS_MSG_SERIALIZE_REPLY_FAILED,
+ "Failed to serialize reply");
+ goto ret;
+ }
+
+ iobref_add(iobref, iob);
+
+ /* Then, submit the message for transmission. */
+ ret = rpcsvc_submit_generic(req, &rsp, 1, payload, payloadcount, iobref);
+
+ /* TODO: this is demo purpose only */
+ /* ret = rpcsvc_callback_submit (req->svc, req->trans, req->prog,
+ GF_CBK_NULL, &rsp, 1);
+ */
+ /* Now that we've done our job of handing the message to the RPC layer
+ * we can safely unref the iob in the hope that RPC layer must have
+ * ref'ed the iob on receiving into the txlist.
+ */
+ iobuf_unref(iob);
+ if (ret == -1) {
+ gf_msg_callingfn("", GF_LOG_ERROR, 0, PS_MSG_REPLY_SUBMIT_FAILED,
+ "Reply submission failed");
+ if (frame && client) {
+ server_connection_cleanup(frame->this, client,
+ INTERNAL_LOCKS | POSIX_LOCKS);
+ } else {
+ gf_msg_callingfn("", GF_LOG_ERROR, 0, PS_MSG_REPLY_SUBMIT_FAILED,
+ "Reply submission failed");
+ /* TODO: Failure of open(dir), create, inodelk, entrylk
+ or lk fops send failure must be handled specially. */
}
+ goto ret;
+ }
- ret = 0;
+ ret = 0;
ret:
- if (client)
- gf_client_unref (client);
+ if (client)
+ gf_client_unref(client);
- if (frame)
- STACK_DESTROY (frame->root);
+ if (frame)
+ STACK_DESTROY(frame->root);
- if (new_iobref)
- iobref_unref (iobref);
+ if (new_iobref)
+ iobref_unref(iobref);
- if (state)
- free_state (state);
+ if (state)
+ free_state(state);
- return ret;
+ return ret;
}
-
int
-server_priv_to_dict (xlator_t *this, dict_t *dict, char *brickname)
+server_priv_to_dict(xlator_t *this, dict_t *dict, char *brickname)
{
- server_conf_t *conf = NULL;
- rpc_transport_t *xprt = NULL;
- peer_info_t *peerinfo = NULL;
- char key[32] = {0,};
- int count = 0;
- int ret = -1;
+ server_conf_t *conf = NULL;
+ rpc_transport_t *xprt = NULL;
+ peer_info_t *peerinfo = NULL;
+ char key[32] = {
+ 0,
+ };
+ int count = 0;
+ int ret = -1;
+
+ GF_VALIDATE_OR_GOTO(THIS->name, this, out);
+ GF_VALIDATE_OR_GOTO(THIS->name, dict, out);
+
+ conf = this->private;
+ if (!conf)
+ return 0;
+ // TODO: Dump only specific info to dict
- GF_VALIDATE_OR_GOTO (THIS->name, this, out);
- GF_VALIDATE_OR_GOTO (THIS->name, dict, out);
+ pthread_mutex_lock(&conf->mutex);
+ {
+ list_for_each_entry(xprt, &conf->xprt_list, list)
+ {
+ if ((xprt->xl_private) && (xprt->xl_private->bound_xl) &&
+ (xprt->xl_private->bound_xl->name) && (brickname) &&
+ (!strcmp(brickname, xprt->xl_private->bound_xl->name))) {
+ peerinfo = &xprt->peerinfo;
+ snprintf(key, sizeof(key), "client%d.hostname", count);
+ ret = dict_set_str(dict, key, peerinfo->identifier);
+ if (ret)
+ goto unlock;
- conf = this->private;
- if (!conf)
- return 0;
- //TODO: Dump only specific info to dict
+ snprintf(key, sizeof(key), "client%d.bytesread", count);
+ ret = dict_set_uint64(dict, key, xprt->total_bytes_read);
+ if (ret)
+ goto unlock;
- pthread_mutex_lock (&conf->mutex);
- {
- list_for_each_entry (xprt, &conf->xprt_list, list) {
- if ((xprt->xl_private) &&
- (xprt->xl_private->bound_xl) &&
- (xprt->xl_private->bound_xl->name) && (brickname) &&
- (!strcmp (brickname,
- xprt->xl_private->bound_xl->name))) {
- peerinfo = &xprt->peerinfo;
- snprintf (key, sizeof (key),
- "client%d.hostname",
- count);
- ret = dict_set_str (dict, key,
- peerinfo->identifier);
- if (ret)
- goto unlock;
-
- snprintf (key, sizeof (key),
- "client%d.bytesread",
- count);
- ret = dict_set_uint64 (dict, key,
- xprt->total_bytes_read);
- if (ret)
- goto unlock;
-
- snprintf (key, sizeof (key),
- "client%d.byteswrite",
- count);
- ret = dict_set_uint64 (dict, key,
- xprt->total_bytes_write);
- if (ret)
- goto unlock;
-
- snprintf (key, sizeof (key),
- "client%d.opversion",
- count);
- ret = dict_set_uint32 (dict, key,
- peerinfo->max_op_version);
- if (ret)
- goto unlock;
-
- snprintf (key, sizeof (key), "client%d.name",
- count);
- ret = dict_set_str (dict, key,
- xprt->xl_private->client_name);
- if (ret)
- goto unlock;
-
- count++;
- }
- }
+ snprintf(key, sizeof(key), "client%d.byteswrite", count);
+ ret = dict_set_uint64(dict, key, xprt->total_bytes_write);
+ if (ret)
+ goto unlock;
+
+ snprintf(key, sizeof(key), "client%d.opversion", count);
+ ret = dict_set_uint32(dict, key, peerinfo->max_op_version);
+ if (ret)
+ goto unlock;
+
+ snprintf(key, sizeof(key), "client%d.name", count);
+ ret = dict_set_str(dict, key, xprt->xl_private->client_name);
+ if (ret)
+ goto unlock;
+
+ count++;
+ }
}
+ }
unlock:
- pthread_mutex_unlock (&conf->mutex);
- if (ret)
- goto out;
+ pthread_mutex_unlock(&conf->mutex);
+ if (ret)
+ goto out;
- ret = dict_set_int32 (dict, "clientcount", count);
+ ret = dict_set_int32(dict, "clientcount", count);
out:
- return ret;
+ return ret;
}
int
-server_priv (xlator_t *this)
+server_priv(xlator_t *this)
{
- server_conf_t *conf = NULL;
- rpc_transport_t *xprt = NULL;
- char key[GF_DUMP_MAX_BUF_LEN] = {0,};
- uint64_t total_read = 0;
- uint64_t total_write = 0;
- int32_t ret = -1;
-
- GF_VALIDATE_OR_GOTO ("server", this, out);
-
- conf = this->private;
- if (!conf)
- return 0;
+ server_conf_t *conf = NULL;
+ rpc_transport_t *xprt = NULL;
+ char key[GF_DUMP_MAX_BUF_LEN] = {
+ 0,
+ };
+ uint64_t total_read = 0;
+ uint64_t total_write = 0;
+ int32_t ret = -1;
+
+ GF_VALIDATE_OR_GOTO("server", this, out);
+
+ conf = this->private;
+ if (!conf)
+ return 0;
- gf_proc_dump_build_key (key, "xlator.protocol.server", "priv");
- gf_proc_dump_add_section (key);
+ gf_proc_dump_build_key(key, "xlator.protocol.server", "priv");
+ gf_proc_dump_add_section(key);
- ret = pthread_mutex_trylock (&conf->mutex);
- if (ret != 0)
- goto out;
+ ret = pthread_mutex_trylock(&conf->mutex);
+ if (ret != 0)
+ goto out;
+ {
+ list_for_each_entry(xprt, &conf->xprt_list, list)
{
- list_for_each_entry (xprt, &conf->xprt_list, list) {
- total_read += xprt->total_bytes_read;
- total_write += xprt->total_bytes_write;
- }
+ total_read += xprt->total_bytes_read;
+ total_write += xprt->total_bytes_write;
}
- pthread_mutex_unlock (&conf->mutex);
+ }
+ pthread_mutex_unlock(&conf->mutex);
- gf_proc_dump_build_key(key, "server", "total-bytes-read");
- gf_proc_dump_write(key, "%"PRIu64, total_read);
+ gf_proc_dump_build_key(key, "server", "total-bytes-read");
+ gf_proc_dump_write(key, "%" PRIu64, total_read);
- gf_proc_dump_build_key(key, "server", "total-bytes-write");
- gf_proc_dump_write(key, "%"PRIu64, total_write);
+ gf_proc_dump_build_key(key, "server", "total-bytes-write");
+ gf_proc_dump_write(key, "%" PRIu64, total_write);
- ret = 0;
+ ret = 0;
out:
- if (ret)
- gf_proc_dump_write ("Unable to print priv",
- "(Lock acquisition failed) %s",
- this?this->name:"server");
+ if (ret)
+ gf_proc_dump_write("Unable to print priv",
+ "(Lock acquisition failed) %s",
+ this ? this->name : "server");
- return ret;
+ return ret;
}
-
static int
-get_auth_types (dict_t *this, char *key, data_t *value, void *data)
+get_auth_types(dict_t *this, char *key, data_t *value, void *data)
{
- dict_t *auth_dict = NULL;
- char *saveptr = NULL;
- char *tmp = NULL;
- char *key_cpy = NULL;
- int32_t ret = -1;
-
- GF_VALIDATE_OR_GOTO ("server", this, out);
- GF_VALIDATE_OR_GOTO ("server", key, out);
- GF_VALIDATE_OR_GOTO ("server", data, out);
-
- auth_dict = data;
- key_cpy = gf_strdup (key);
- GF_VALIDATE_OR_GOTO("server", key_cpy, out);
-
- tmp = strtok_r (key_cpy, ".", &saveptr);
- ret = strcmp (tmp, "auth");
- if (ret == 0) {
- tmp = strtok_r (NULL, ".", &saveptr);
- if (strcmp (tmp, "ip") == 0) {
- /* TODO: backward compatibility, remove when
- newer versions are available */
- tmp = "addr";
- gf_msg ("server", GF_LOG_WARNING, 0,
- PS_MSG_AUTH_IP_ERROR,
- "assuming 'auth.ip' to be 'auth.addr'");
- }
- ret = dict_set_dynptr (auth_dict, tmp, NULL, 0);
- if (ret < 0) {
- gf_msg_debug ("server", 0, "failed to "
- "dict_set_dynptr");
- }
+ dict_t *auth_dict = NULL;
+ char *saveptr = NULL;
+ char *tmp = NULL;
+ char *key_cpy = NULL;
+ int32_t ret = -1;
+
+ GF_VALIDATE_OR_GOTO("server", this, out);
+ GF_VALIDATE_OR_GOTO("server", key, out);
+ GF_VALIDATE_OR_GOTO("server", data, out);
+
+ auth_dict = data;
+ key_cpy = gf_strdup(key);
+ GF_VALIDATE_OR_GOTO("server", key_cpy, out);
+
+ tmp = strtok_r(key_cpy, ".", &saveptr);
+ ret = strcmp(tmp, "auth");
+ if (ret == 0) {
+ tmp = strtok_r(NULL, ".", &saveptr);
+ if (strcmp(tmp, "ip") == 0) {
+ /* TODO: backward compatibility, remove when
+ newer versions are available */
+ tmp = "addr";
+ gf_msg("server", GF_LOG_WARNING, 0, PS_MSG_AUTH_IP_ERROR,
+ "assuming 'auth.ip' to be 'auth.addr'");
}
+ ret = dict_set_dynptr(auth_dict, tmp, NULL, 0);
+ if (ret < 0) {
+ gf_msg_debug("server", 0,
+ "failed to "
+ "dict_set_dynptr");
+ }
+ }
- GF_FREE (key_cpy);
+ GF_FREE(key_cpy);
out:
- return 0;
+ return 0;
}
int
-_check_for_auth_option (dict_t *d, char *k, data_t *v,
- void *tmp)
+_check_for_auth_option(dict_t *d, char *k, data_t *v, void *tmp)
{
- int ret = 0;
- xlator_t *xl = NULL;
- char *tail = NULL;
-
- xl = tmp;
-
- tail = strtail (k, "auth.");
- if (!tail)
- goto out;
-
- if (strncmp(tail, "addr.", 5) != 0) {
- gf_msg (xl->name, GF_LOG_TRACE, 0, PS_MSG_SKIP_FORMAT_CHK,
- "skip format check for non-addr auth option %s", k);
- goto out;
- }
-
- /* fast fwd through module type */
- tail = strchr (tail, '.');
- if (!tail)
- goto out;
- tail++;
-
- tail = strtail (tail, xl->name);
- if (!tail)
- goto out;
-
- if (*tail == '.') {
- /* when we are here, the key is checked for
- * valid auth.allow.<xlator>
- * Now we verify the ip address
- */
- ret = xlator_option_validate_addr_list (xl, "auth-*", v->data,
- NULL, NULL);
- if (ret)
- gf_msg (xl->name, GF_LOG_ERROR, 0,
- PS_MSG_INTERNET_ADDR_ERROR,
- "internet address '%s' does not conform "
- "to standards.", v->data);
- }
+ int ret = 0;
+ xlator_t *xl = NULL;
+ char *tail = NULL;
+
+ xl = tmp;
+
+ tail = strtail(k, "auth.");
+ if (!tail)
+ goto out;
+
+ if (strncmp(tail, "addr.", 5) != 0) {
+ gf_msg(xl->name, GF_LOG_TRACE, 0, PS_MSG_SKIP_FORMAT_CHK,
+ "skip format check for non-addr auth option %s", k);
+ goto out;
+ }
+
+ /* fast fwd through module type */
+ tail = strchr(tail, '.');
+ if (!tail)
+ goto out;
+ tail++;
+
+ tail = strtail(tail, xl->name);
+ if (!tail)
+ goto out;
+
+ if (*tail == '.') {
+ /* when we are here, the key is checked for
+ * valid auth.allow.<xlator>
+ * Now we verify the ip address
+ */
+ ret = xlator_option_validate_addr_list(xl, "auth-*", v->data, NULL,
+ NULL);
+ if (ret)
+ gf_msg(xl->name, GF_LOG_ERROR, 0, PS_MSG_INTERNET_ADDR_ERROR,
+ "internet address '%s' does not conform "
+ "to standards.",
+ v->data);
+ }
out:
- return ret;
+ return ret;
}
int
-validate_auth_options (xlator_t *this, dict_t *dict)
+validate_auth_options(xlator_t *this, dict_t *dict)
{
- int error = -1;
- xlator_list_t *trav = NULL;
-
- GF_VALIDATE_OR_GOTO ("server", this, out);
- GF_VALIDATE_OR_GOTO ("server", dict, out);
-
- trav = this->children;
- while (trav) {
- error = dict_foreach (dict, _check_for_auth_option,
- trav->xlator);
-
- if (-1 == error) {
- gf_msg (this->name, GF_LOG_ERROR, 0,
- PS_MSG_AUTHENTICATE_ERROR, "volume '%s' "
- "defined as subvolume, but no authentication "
- "defined for the same", trav->xlator->name);
- break;
- }
- trav = trav->next;
+ int error = -1;
+ xlator_list_t *trav = NULL;
+
+ GF_VALIDATE_OR_GOTO("server", this, out);
+ GF_VALIDATE_OR_GOTO("server", dict, out);
+
+ trav = this->children;
+ while (trav) {
+ error = dict_foreach(dict, _check_for_auth_option, trav->xlator);
+
+ if (-1 == error) {
+ gf_msg(this->name, GF_LOG_ERROR, 0, PS_MSG_AUTHENTICATE_ERROR,
+ "volume '%s' "
+ "defined as subvolume, but no authentication "
+ "defined for the same",
+ trav->xlator->name);
+ break;
}
+ trav = trav->next;
+ }
out:
- return error;
+ return error;
}
-
int
-server_rpc_notify (rpcsvc_t *rpc, void *xl, rpcsvc_event_t event,
- void *data)
+server_rpc_notify(rpcsvc_t *rpc, void *xl, rpcsvc_event_t event, void *data)
{
- gf_boolean_t detached = _gf_false;
- xlator_t *this = NULL;
- rpc_transport_t *trans = NULL;
- server_conf_t *conf = NULL;
- client_t *client = NULL;
- char *auth_path = NULL;
- int ret = -1;
- gf_boolean_t victim_found = _gf_false;
- char *xlator_name = NULL;
- glusterfs_ctx_t *ctx = NULL;
- xlator_t *top = NULL;
- xlator_list_t **trav_p = NULL;
- xlator_t *travxl = NULL;
- uint64_t xprtrefcount = 0;
- struct _child_status *tmp = NULL;
-
-
- if (!xl || !data) {
- gf_msg_callingfn ("server", GF_LOG_WARNING, 0,
- PS_MSG_RPC_NOTIFY_ERROR,
- "Calling rpc_notify without initializing");
- goto out;
- }
-
- this = xl;
- trans = data;
- conf = this->private;
- ctx = this->ctx;
-
- switch (event) {
- case RPCSVC_EVENT_ACCEPT:
- {
- /* Have a structure per new connection */
- /* TODO: Should we create anything here at all ? * /
- client->conn = create_server_conn_state (this, trans);
- if (!client->conn)
- goto out;
-
- trans->protocol_private = client->conn;
- */
-
- pthread_mutex_lock (&conf->mutex);
- rpc_transport_ref (trans);
- list_add_tail (&trans->list, &conf->xprt_list);
- pthread_mutex_unlock (&conf->mutex);
-
- break;
+ gf_boolean_t detached = _gf_false;
+ xlator_t *this = NULL;
+ rpc_transport_t *trans = NULL;
+ server_conf_t *conf = NULL;
+ client_t *client = NULL;
+ char *auth_path = NULL;
+ int ret = -1;
+ gf_boolean_t victim_found = _gf_false;
+ char *xlator_name = NULL;
+ glusterfs_ctx_t *ctx = NULL;
+ xlator_t *top = NULL;
+ xlator_list_t **trav_p = NULL;
+ xlator_t *travxl = NULL;
+ uint64_t xprtrefcount = 0;
+ struct _child_status *tmp = NULL;
+
+ if (!xl || !data) {
+ gf_msg_callingfn("server", GF_LOG_WARNING, 0, PS_MSG_RPC_NOTIFY_ERROR,
+ "Calling rpc_notify without initializing");
+ goto out;
+ }
+
+ this = xl;
+ trans = data;
+ conf = this->private;
+ ctx = this->ctx;
+
+ switch (event) {
+ case RPCSVC_EVENT_ACCEPT: {
+ /* Have a structure per new connection */
+ /* TODO: Should we create anything here at all ? * /
+ client->conn = create_server_conn_state (this, trans);
+ if (!client->conn)
+ goto out;
+
+ trans->protocol_private = client->conn;
+ */
+
+ pthread_mutex_lock(&conf->mutex);
+ rpc_transport_ref(trans);
+ list_add_tail(&trans->list, &conf->xprt_list);
+ pthread_mutex_unlock(&conf->mutex);
+
+ break;
}
case RPCSVC_EVENT_DISCONNECT:
- /* A DISCONNECT event could come without an ACCEPT event
- * happening for this transport. This happens when the server is
- * expecting encrypted connections by the client tries to
- * connect unecnrypted
- */
- if (list_empty (&trans->list)) {
- break;
- }
-
- /* transport has to be removed from the list upon disconnect
- * irrespective of whether lock self heal is off or on, since
- * new transport will be created upon reconnect.
- */
- pthread_mutex_lock (&conf->mutex);
- client = trans->xl_private;
- list_del_init (&trans->list);
- pthread_mutex_unlock (&conf->mutex);
-
- if (!client)
- goto unref_transport;
-
- gf_msg (this->name, GF_LOG_INFO, 0,
- PS_MSG_CLIENT_DISCONNECTING, "disconnecting connection"
- " from %s", client->client_uid);
-
- ret = dict_get_str (this->options, "auth-path", &auth_path);
- if (ret) {
- gf_msg (this->name, GF_LOG_WARNING, 0,
- PS_MSG_DICT_GET_FAILED,
- "failed to get auth-path");
- auth_path = NULL;
- }
-
- gf_client_ref (client);
- gf_client_put (client, &detached);
- if (detached) {
- server_connection_cleanup (this, client,
- INTERNAL_LOCKS | POSIX_LOCKS);
- gf_event (EVENT_CLIENT_DISCONNECT, "client_uid=%s;"
- "client_identifier=%s;server_identifier=%s;"
- "brick_path=%s",
- client->client_uid,
- trans->peerinfo.identifier,
- trans->myinfo.identifier,
- auth_path);
- }
-
- /*
- * gf_client_unref will be done while handling
- * RPC_EVENT_TRANSPORT_DESTROY
- */
-
-unref_transport:
- /* rpc_transport_unref() causes a RPCSVC_EVENT_TRANSPORT_DESTROY
- * to be called in blocking manner
- * So no code should ideally be after this unref
- */
- rpc_transport_unref (trans);
+ /* A DISCONNECT event could come without an ACCEPT event
+ * happening for this transport. This happens when the server is
+ * expecting encrypted connections by the client tries to
+ * connect unecnrypted
+ */
+ if (list_empty(&trans->list)) {
break;
+ }
+
+ /* transport has to be removed from the list upon disconnect
+ * irrespective of whether lock self heal is off or on, since
+ * new transport will be created upon reconnect.
+ */
+ pthread_mutex_lock(&conf->mutex);
+ client = trans->xl_private;
+ list_del_init(&trans->list);
+ pthread_mutex_unlock(&conf->mutex);
+
+ if (!client)
+ goto unref_transport;
+
+ gf_msg(this->name, GF_LOG_INFO, 0, PS_MSG_CLIENT_DISCONNECTING,
+ "disconnecting connection"
+ " from %s",
+ client->client_uid);
+
+ ret = dict_get_str(this->options, "auth-path", &auth_path);
+ if (ret) {
+ gf_msg(this->name, GF_LOG_WARNING, 0, PS_MSG_DICT_GET_FAILED,
+ "failed to get auth-path");
+ auth_path = NULL;
+ }
+
+ gf_client_ref(client);
+ gf_client_put(client, &detached);
+ if (detached) {
+ server_connection_cleanup(this, client,
+ INTERNAL_LOCKS | POSIX_LOCKS);
+ gf_event(EVENT_CLIENT_DISCONNECT,
+ "client_uid=%s;"
+ "client_identifier=%s;server_identifier=%s;"
+ "brick_path=%s",
+ client->client_uid, trans->peerinfo.identifier,
+ trans->myinfo.identifier, auth_path);
+ }
+
+ /*
+ * gf_client_unref will be done while handling
+ * RPC_EVENT_TRANSPORT_DESTROY
+ */
+
+ unref_transport:
+ /* rpc_transport_unref() causes a RPCSVC_EVENT_TRANSPORT_DESTROY
+ * to be called in blocking manner
+ * So no code should ideally be after this unref
+ */
+ rpc_transport_unref(trans);
+ break;
case RPCSVC_EVENT_TRANSPORT_DESTROY:
- client = trans->xl_private;
- if (!client)
- break;
- pthread_mutex_lock (&conf->mutex);
- list_for_each_entry (tmp, &conf->child_status->status_list,
- status_list) {
- if (tmp->name && client->bound_xl &&
- client->bound_xl->cleanup_starting &&
- !strcmp (tmp->name, client->bound_xl->name)) {
- xprtrefcount = GF_ATOMIC_GET (tmp->xprtrefcnt);
- if (xprtrefcount > 0) {
- xprtrefcount = GF_ATOMIC_DEC (tmp->xprtrefcnt);
- if (xprtrefcount == 0)
- xlator_name = gf_strdup(client->bound_xl->name);
- }
- break;
- }
+ client = trans->xl_private;
+ if (!client)
+ break;
+ pthread_mutex_lock(&conf->mutex);
+ list_for_each_entry(tmp, &conf->child_status->status_list,
+ status_list)
+ {
+ if (tmp->name && client->bound_xl &&
+ client->bound_xl->cleanup_starting &&
+ !strcmp(tmp->name, client->bound_xl->name)) {
+ xprtrefcount = GF_ATOMIC_GET(tmp->xprtrefcnt);
+ if (xprtrefcount > 0) {
+ xprtrefcount = GF_ATOMIC_DEC(tmp->xprtrefcnt);
+ if (xprtrefcount == 0)
+ xlator_name = gf_strdup(client->bound_xl->name);
+ }
+ break;
}
- pthread_mutex_unlock (&conf->mutex);
-
- gf_client_unref (client);
-
- if (xlator_name) {
- if (this->ctx->active) {
- top = this->ctx->active->first;
- LOCK (&ctx->volfile_lock);
- for (trav_p = &top->children; *trav_p;
- trav_p = &(*trav_p)->next) {
- travxl = (*trav_p)->xlator;
- if (!travxl->call_cleanup &&
- strcmp (travxl->name, xlator_name) == 0) {
- victim_found = _gf_true;
- break;
- }
- }
- UNLOCK (&ctx->volfile_lock);
- if (victim_found) {
- xlator_mem_cleanup (travxl);
- rpcsvc_autoscale_threads (ctx, conf->rpc, -1);
- }
+ }
+ pthread_mutex_unlock(&conf->mutex);
+
+ gf_client_unref(client);
+
+ if (xlator_name) {
+ if (this->ctx->active) {
+ top = this->ctx->active->first;
+ LOCK(&ctx->volfile_lock);
+ for (trav_p = &top->children; *trav_p;
+ trav_p = &(*trav_p)->next) {
+ travxl = (*trav_p)->xlator;
+ if (!travxl->call_cleanup &&
+ strcmp(travxl->name, xlator_name) == 0) {
+ victim_found = _gf_true;
+ break;
}
- GF_FREE (xlator_name);
+ }
+ UNLOCK(&ctx->volfile_lock);
+ if (victim_found) {
+ xlator_mem_cleanup(travxl);
+ rpcsvc_autoscale_threads(ctx, conf->rpc, -1);
+ }
}
+ GF_FREE(xlator_name);
+ }
- trans->xl_private = NULL;
- break;
+ trans->xl_private = NULL;
+ break;
default:
- break;
- }
+ break;
+ }
out:
- return 0;
+ return 0;
}
int32_t
-server_mem_acct_init (xlator_t *this)
+server_mem_acct_init(xlator_t *this)
{
- int ret = -1;
+ int ret = -1;
- GF_VALIDATE_OR_GOTO ("server", this, out);
+ GF_VALIDATE_OR_GOTO("server", this, out);
- ret = xlator_mem_acct_init (this, gf_server_mt_end + 1);
+ ret = xlator_mem_acct_init(this, gf_server_mt_end + 1);
- if (ret != 0) {
- gf_msg (this->name, GF_LOG_ERROR, ENOMEM, PS_MSG_NO_MEMORY,
- "Memory accounting init failed");
- return ret;
- }
-out:
+ if (ret != 0) {
+ gf_msg(this->name, GF_LOG_ERROR, ENOMEM, PS_MSG_NO_MEMORY,
+ "Memory accounting init failed");
return ret;
+ }
+out:
+ return ret;
}
-
static int
-_delete_auth_opt (dict_t *this, char *key, data_t *value, void *data)
+_delete_auth_opt(dict_t *this, char *key, data_t *value, void *data)
{
- char *auth_option_pattern[] = { "auth.addr.*.allow",
- "auth.addr.*.reject",
- "auth.login.*.allow",
- "auth.login.*.password",
- "auth.login.*.ssl-allow",
- NULL};
- int i = 0;
-
- for (i = 0; auth_option_pattern[i]; i++) {
- if (fnmatch (auth_option_pattern[i], key, 0) == 0) {
- dict_del (this, key);
- break;
- }
+ char *auth_option_pattern[] = {
+ "auth.addr.*.allow", "auth.addr.*.reject", "auth.login.*.allow",
+ "auth.login.*.password", "auth.login.*.ssl-allow", NULL};
+ int i = 0;
+
+ for (i = 0; auth_option_pattern[i]; i++) {
+ if (fnmatch(auth_option_pattern[i], key, 0) == 0) {
+ dict_del(this, key);
+ break;
}
+ }
- return 0;
+ return 0;
}
-
static int
-_copy_auth_opt (dict_t *unused, char *key, data_t *value, void *xl_dict)
+_copy_auth_opt(dict_t *unused, char *key, data_t *value, void *xl_dict)
{
- char *auth_option_pattern[] = { "auth.addr.*.allow",
- "auth.addr.*.reject",
- "auth.login.*.allow",
- "auth.login.*.password",
- "auth.login.*.ssl-allow",
- NULL};
- int i = 0;
-
- for (i = 0; auth_option_pattern [i]; i++) {
- if (fnmatch (auth_option_pattern[i], key, 0) == 0) {
- dict_set ((dict_t *)xl_dict, key, value);
- break;
- }
+ char *auth_option_pattern[] = {
+ "auth.addr.*.allow", "auth.addr.*.reject", "auth.login.*.allow",
+ "auth.login.*.password", "auth.login.*.ssl-allow", NULL};
+ int i = 0;
+
+ for (i = 0; auth_option_pattern[i]; i++) {
+ if (fnmatch(auth_option_pattern[i], key, 0) == 0) {
+ dict_set((dict_t *)xl_dict, key, value);
+ break;
}
+ }
- return 0;
+ return 0;
}
int
-server_check_event_threads (xlator_t *this, server_conf_t *conf, int32_t new)
+server_check_event_threads(xlator_t *this, server_conf_t *conf, int32_t new)
{
- struct event_pool *pool = this->ctx->event_pool;
- int target;
+ struct event_pool *pool = this->ctx->event_pool;
+ int target;
- target = new + pool->auto_thread_count;
- conf->event_threads = new;
+ target = new + pool->auto_thread_count;
+ conf->event_threads = new;
- if (target == pool->eventthreadcount) {
- return 0;
- }
+ if (target == pool->eventthreadcount) {
+ return 0;
+ }
- return event_reconfigure_threads (pool, target);
+ return event_reconfigure_threads(pool, target);
}
int
-server_reconfigure (xlator_t *this, dict_t *options)
+server_reconfigure(xlator_t *this, dict_t *options)
{
+ server_conf_t *conf = NULL;
+ rpcsvc_t *rpc_conf;
+ rpcsvc_listener_t *listeners;
+ rpc_transport_t *xprt = NULL;
+ rpc_transport_t *xp_next = NULL;
+ int inode_lru_limit;
+ gf_boolean_t trace;
+ data_t *data;
+ int ret = 0;
+ char *statedump_path = NULL;
+ int32_t new_nthread = 0;
+ char *auth_path = NULL;
+ char *xprt_path = NULL;
+ xlator_t *oldTHIS;
+ xlator_t *kid;
+
+ /*
+ * Since we're not a fop, we can't really count on THIS being set
+ * correctly, and it needs to be or else GF_OPTION_RECONF won't work
+ * (because it won't find our options list). This is another thing
+ * that "just happened" to work before multiplexing, but now we need to
+ * handle it more explicitly.
+ */
+ oldTHIS = THIS;
+ THIS = this;
+
+ conf = this->private;
+
+ if (!conf) {
+ gf_msg_callingfn(this->name, GF_LOG_DEBUG, EINVAL, PS_MSG_INVALID_ENTRY,
+ "conf == null!!!");
+ goto out;
+ }
+
+ /*
+ * For some of the auth/rpc stuff, we need to operate on the correct
+ * child, but for other stuff we need to operate on the server
+ * translator itself.
+ */
+ kid = NULL;
+ if (dict_get_str(options, "auth-path", &auth_path) == 0) {
+ kid = get_xlator_by_name(this, auth_path);
+ }
+ if (!kid) {
+ kid = this;
+ }
+
+ if (dict_get_int32(options, "inode-lru-limit", &inode_lru_limit) == 0) {
+ conf->inode_lru_limit = inode_lru_limit;
+ gf_msg_trace(this->name, 0,
+ "Reconfigured inode-lru-limit to "
+ "%d",
+ conf->inode_lru_limit);
+
+ /* traverse through the xlator graph. For each xlator in the
+ graph check whether it is a bound_xl or not (bound_xl means
+ the xlator will have its itable pointer set). If so, then
+ set the lru limit for the itable.
+ */
+ xlator_foreach(this, xlator_set_inode_lru_limit, &inode_lru_limit);
+ }
- server_conf_t *conf =NULL;
- rpcsvc_t *rpc_conf;
- rpcsvc_listener_t *listeners;
- rpc_transport_t *xprt = NULL;
- rpc_transport_t *xp_next = NULL;
- int inode_lru_limit;
- gf_boolean_t trace;
- data_t *data;
- int ret = 0;
- char *statedump_path = NULL;
- int32_t new_nthread = 0;
- char *auth_path = NULL;
- char *xprt_path = NULL;
- xlator_t *oldTHIS;
- xlator_t *kid;
-
- /*
- * Since we're not a fop, we can't really count on THIS being set
- * correctly, and it needs to be or else GF_OPTION_RECONF won't work
- * (because it won't find our options list). This is another thing
- * that "just happened" to work before multiplexing, but now we need to
- * handle it more explicitly.
- */
- oldTHIS = THIS;
- THIS = this;
-
- conf = this->private;
-
- if (!conf) {
- gf_msg_callingfn (this->name, GF_LOG_DEBUG, EINVAL,
- PS_MSG_INVALID_ENTRY, "conf == null!!!");
- goto out;
- }
-
- /*
- * For some of the auth/rpc stuff, we need to operate on the correct
- * child, but for other stuff we need to operate on the server
- * translator itself.
- */
- kid = NULL;
- if (dict_get_str (options, "auth-path", &auth_path) == 0) {
- kid = get_xlator_by_name (this, auth_path);
- }
- if (!kid) {
- kid = this;
- }
-
- if (dict_get_int32 ( options, "inode-lru-limit", &inode_lru_limit) == 0){
- conf->inode_lru_limit = inode_lru_limit;
- gf_msg_trace (this->name, 0, "Reconfigured inode-lru-limit to "
- "%d", conf->inode_lru_limit);
-
- /* traverse through the xlator graph. For each xlator in the
- graph check whether it is a bound_xl or not (bound_xl means
- the xlator will have its itable pointer set). If so, then
- set the lru limit for the itable.
- */
- xlator_foreach (this, xlator_set_inode_lru_limit,
- &inode_lru_limit);
- }
-
- data = dict_get (options, "trace");
- if (data) {
- ret = gf_string2boolean (data->data, &trace);
- if (ret != 0) {
- gf_msg (this->name, GF_LOG_WARNING, EINVAL,
- PS_MSG_INVALID_ENTRY, "'trace' takes on only "
- "boolean values. Neglecting option");
- ret = -1;
- goto out;
- }
- conf->trace = trace;
- gf_msg_trace (this->name, 0, "Reconfigured trace to %d",
- conf->trace);
-
- }
-
- GF_OPTION_RECONF ("statedump-path", statedump_path,
- options, path, do_auth);
- if (!statedump_path) {
- gf_msg (this->name, GF_LOG_ERROR, 0,
- PS_MSG_STATEDUMP_PATH_ERROR,
- "Error while reconfiguring statedump path");
- goto do_auth;
+ data = dict_get(options, "trace");
+ if (data) {
+ ret = gf_string2boolean(data->data, &trace);
+ if (ret != 0) {
+ gf_msg(this->name, GF_LOG_WARNING, EINVAL, PS_MSG_INVALID_ENTRY,
+ "'trace' takes on only "
+ "boolean values. Neglecting option");
+ ret = -1;
+ goto out;
}
- gf_path_strip_trailing_slashes (statedump_path);
- GF_FREE (this->ctx->statedump_path);
- this->ctx->statedump_path = gf_strdup (statedump_path);
+ conf->trace = trace;
+ gf_msg_trace(this->name, 0, "Reconfigured trace to %d", conf->trace);
+ }
+
+ GF_OPTION_RECONF("statedump-path", statedump_path, options, path, do_auth);
+ if (!statedump_path) {
+ gf_msg(this->name, GF_LOG_ERROR, 0, PS_MSG_STATEDUMP_PATH_ERROR,
+ "Error while reconfiguring statedump path");
+ goto do_auth;
+ }
+ gf_path_strip_trailing_slashes(statedump_path);
+ GF_FREE(this->ctx->statedump_path);
+ this->ctx->statedump_path = gf_strdup(statedump_path);
do_auth:
- if (!conf->auth_modules)
- conf->auth_modules = dict_new ();
-
- dict_foreach (options, get_auth_types, conf->auth_modules);
- ret = validate_auth_options (kid, options);
- if (ret == -1) {
- /* logging already done in validate_auth_options function. */
- goto out;
- }
-
- dict_foreach (kid->options, _delete_auth_opt, NULL);
- dict_foreach (options, _copy_auth_opt, kid->options);
-
- ret = gf_auth_init (kid, conf->auth_modules);
- if (ret) {
- dict_unref (conf->auth_modules);
- goto out;
- }
-
- GF_OPTION_RECONF ("manage-gids", conf->server_manage_gids, options,
- bool, do_rpc);
-
- GF_OPTION_RECONF ("gid-timeout", conf->gid_cache_timeout, options,
- int32, do_rpc);
- if (gid_cache_reconf (&conf->gid_cache, conf->gid_cache_timeout) < 0) {
- gf_msg (this->name, GF_LOG_ERROR, 0, PS_MSG_GRP_CACHE_ERROR,
- "Failed to reconfigure group cache.");
- goto do_rpc;
- }
+ if (!conf->auth_modules)
+ conf->auth_modules = dict_new();
+
+ dict_foreach(options, get_auth_types, conf->auth_modules);
+ ret = validate_auth_options(kid, options);
+ if (ret == -1) {
+ /* logging already done in validate_auth_options function. */
+ goto out;
+ }
+
+ dict_foreach(kid->options, _delete_auth_opt, NULL);
+ dict_foreach(options, _copy_auth_opt, kid->options);
+
+ ret = gf_auth_init(kid, conf->auth_modules);
+ if (ret) {
+ dict_unref(conf->auth_modules);
+ goto out;
+ }
+
+ GF_OPTION_RECONF("manage-gids", conf->server_manage_gids, options, bool,
+ do_rpc);
+
+ GF_OPTION_RECONF("gid-timeout", conf->gid_cache_timeout, options, int32,
+ do_rpc);
+ if (gid_cache_reconf(&conf->gid_cache, conf->gid_cache_timeout) < 0) {
+ gf_msg(this->name, GF_LOG_ERROR, 0, PS_MSG_GRP_CACHE_ERROR,
+ "Failed to reconfigure group cache.");
+ goto do_rpc;
+ }
do_rpc:
- rpc_conf = conf->rpc;
- if (!rpc_conf) {
- gf_msg (this->name, GF_LOG_ERROR, 0, PS_MSG_RPC_CONF_ERROR,
- "No rpc_conf !!!!");
- goto out;
- }
-
- ret = rpcsvc_auth_reconf (rpc_conf, options);
- if (ret == -1) {
- gf_log (GF_RPCSVC, GF_LOG_ERROR,
- "Failed to reconfigure authentication");
- goto out;
- }
-
- GF_OPTION_RECONF ("strict-auth-accept", conf->strict_auth_enabled,
- options, bool, out);
-
-
- GF_OPTION_RECONF ("dynamic-auth", conf->dync_auth, options,
- bool, out);
-
- if (conf->dync_auth) {
- pthread_mutex_lock (&conf->mutex);
- {
- /*
- * Disconnecting will (usually) drop the last ref,
- * which will cause the transport to be unlinked and
- * freed while we're still traversing, which will cause
- * us to crash unless we use list_for_each_entry_safe.
- */
- list_for_each_entry_safe (xprt, xp_next,
- &conf->xprt_list, list) {
- /* check for client authorization */
- if (!xprt->clnt_options) {
- /* If clnt_options dictionary is null,
- * which means for this transport
- * server_setvolume was not called.
- *
- * So here we can skip authentication
- * because server_setvolume will do
- * gf_authenticate.
- *
- */
- continue;
- }
- /*
- * Make sure we're only operating on
- * connections that are relevant to the brick
- * we're reconfiguring.
- */
- if (dict_get_str (xprt->clnt_options,
- "remote-subvolume",
- &xprt_path) != 0) {
- continue;
- }
- if (strcmp (xprt_path, auth_path) != 0) {
- continue;
- }
- ret = gf_authenticate (xprt->clnt_options,
- options,
- conf->auth_modules);
- if (ret == AUTH_ACCEPT) {
- gf_msg (kid->name, GF_LOG_TRACE, 0,
- PS_MSG_CLIENT_ACCEPTED,
- "authorized client, hence we "
- "continue with this connection");
- } else {
- gf_event (EVENT_CLIENT_AUTH_REJECT,
- "client_uid=%s;"
- "client_identifier=%s;"
- "server_identifier=%s;"
- "brick_path=%s",
- xprt->xl_private->client_uid,
- xprt->peerinfo.identifier,
- xprt->myinfo.identifier,
- auth_path);
- gf_msg (this->name, GF_LOG_INFO,
- EACCES,
- PS_MSG_AUTHENTICATE_ERROR,
- "unauthorized client, hence "
- "terminating the connection %s",
- xprt->peerinfo.identifier);
- rpc_transport_disconnect(xprt,
- _gf_false);
- }
- }
+ rpc_conf = conf->rpc;
+ if (!rpc_conf) {
+ gf_msg(this->name, GF_LOG_ERROR, 0, PS_MSG_RPC_CONF_ERROR,
+ "No rpc_conf !!!!");
+ goto out;
+ }
+
+ ret = rpcsvc_auth_reconf(rpc_conf, options);
+ if (ret == -1) {
+ gf_log(GF_RPCSVC, GF_LOG_ERROR, "Failed to reconfigure authentication");
+ goto out;
+ }
+
+ GF_OPTION_RECONF("strict-auth-accept", conf->strict_auth_enabled, options,
+ bool, out);
+
+ GF_OPTION_RECONF("dynamic-auth", conf->dync_auth, options, bool, out);
+
+ if (conf->dync_auth) {
+ pthread_mutex_lock(&conf->mutex);
+ {
+ /*
+ * Disconnecting will (usually) drop the last ref,
+ * which will cause the transport to be unlinked and
+ * freed while we're still traversing, which will cause
+ * us to crash unless we use list_for_each_entry_safe.
+ */
+ list_for_each_entry_safe(xprt, xp_next, &conf->xprt_list, list)
+ {
+ /* check for client authorization */
+ if (!xprt->clnt_options) {
+ /* If clnt_options dictionary is null,
+ * which means for this transport
+ * server_setvolume was not called.
+ *
+ * So here we can skip authentication
+ * because server_setvolume will do
+ * gf_authenticate.
+ *
+ */
+ continue;
}
- pthread_mutex_unlock (&conf->mutex);
- }
-
- ret = rpcsvc_set_outstanding_rpc_limit (rpc_conf, options,
- RPCSVC_DEFAULT_OUTSTANDING_RPC_LIMIT);
- if (ret < 0) {
- gf_msg (this->name, GF_LOG_ERROR, 0, PS_MSG_RPC_CONF_ERROR,
- "Failed to reconfigure outstanding-rpc-limit");
- goto out;
- }
-
- list_for_each_entry (listeners, &(rpc_conf->listeners), list) {
- if (listeners->trans != NULL) {
- if (listeners->trans->reconfigure )
- listeners->trans->reconfigure (listeners->trans, options);
- else
- gf_msg (this->name, GF_LOG_ERROR, 0,
- PS_MSG_TRANSPORT_ERROR, "Reconfigure "
- "not found for transport");
+ /*
+ * Make sure we're only operating on
+ * connections that are relevant to the brick
+ * we're reconfiguring.
+ */
+ if (dict_get_str(xprt->clnt_options, "remote-subvolume",
+ &xprt_path) != 0) {
+ continue;
+ }
+ if (strcmp(xprt_path, auth_path) != 0) {
+ continue;
+ }
+ ret = gf_authenticate(xprt->clnt_options, options,
+ conf->auth_modules);
+ if (ret == AUTH_ACCEPT) {
+ gf_msg(kid->name, GF_LOG_TRACE, 0, PS_MSG_CLIENT_ACCEPTED,
+ "authorized client, hence we "
+ "continue with this connection");
+ } else {
+ gf_event(EVENT_CLIENT_AUTH_REJECT,
+ "client_uid=%s;"
+ "client_identifier=%s;"
+ "server_identifier=%s;"
+ "brick_path=%s",
+ xprt->xl_private->client_uid,
+ xprt->peerinfo.identifier, xprt->myinfo.identifier,
+ auth_path);
+ gf_msg(this->name, GF_LOG_INFO, EACCES,
+ PS_MSG_AUTHENTICATE_ERROR,
+ "unauthorized client, hence "
+ "terminating the connection %s",
+ xprt->peerinfo.identifier);
+ rpc_transport_disconnect(xprt, _gf_false);
}
+ }
}
-
- /*
- * Update:
- * We don't need to reset auto_thread_count since it has been derived
- * out of the total bricks attached. We can reconfigure event threads
- * but not auto threads.
- */
-
- GF_OPTION_RECONF ("event-threads", new_nthread, options, int32, out);
- ret = server_check_event_threads (this, conf, new_nthread);
- if (ret)
- goto out;
-
- /* rpcsvc thread reconfigure should be after events thread
- * reconfigure
- */
- new_nthread =
- ((struct event_pool *)(this->ctx->event_pool))->eventthreadcount;
- ret = rpcsvc_ownthread_reconf (rpc_conf, new_nthread);
+ pthread_mutex_unlock(&conf->mutex);
+ }
+
+ ret = rpcsvc_set_outstanding_rpc_limit(
+ rpc_conf, options, RPCSVC_DEFAULT_OUTSTANDING_RPC_LIMIT);
+ if (ret < 0) {
+ gf_msg(this->name, GF_LOG_ERROR, 0, PS_MSG_RPC_CONF_ERROR,
+ "Failed to reconfigure outstanding-rpc-limit");
+ goto out;
+ }
+
+ list_for_each_entry(listeners, &(rpc_conf->listeners), list)
+ {
+ if (listeners->trans != NULL) {
+ if (listeners->trans->reconfigure)
+ listeners->trans->reconfigure(listeners->trans, options);
+ else
+ gf_msg(this->name, GF_LOG_ERROR, 0, PS_MSG_TRANSPORT_ERROR,
+ "Reconfigure "
+ "not found for transport");
+ }
+ }
+
+ /*
+ * Update:
+ * We don't need to reset auto_thread_count since it has been derived
+ * out of the total bricks attached. We can reconfigure event threads
+ * but not auto threads.
+ */
+
+ GF_OPTION_RECONF("event-threads", new_nthread, options, int32, out);
+ ret = server_check_event_threads(this, conf, new_nthread);
+ if (ret)
+ goto out;
+
+ /* rpcsvc thread reconfigure should be after events thread
+ * reconfigure
+ */
+ new_nthread = ((struct event_pool *)(this->ctx->event_pool))
+ ->eventthreadcount;
+ ret = rpcsvc_ownthread_reconf(rpc_conf, new_nthread);
out:
- THIS = oldTHIS;
- gf_msg_debug ("", 0, "returning %d", ret);
- return ret;
+ THIS = oldTHIS;
+ gf_msg_debug("", 0, "returning %d", ret);
+ return ret;
}
static int32_t
-client_destroy_cbk (xlator_t *this, client_t *client)
+client_destroy_cbk(xlator_t *this, client_t *client)
{
- void *tmp = NULL;
- server_ctx_t *ctx = NULL;
+ void *tmp = NULL;
+ server_ctx_t *ctx = NULL;
- client_ctx_del (client, this, &tmp);
+ client_ctx_del(client, this, &tmp);
- ctx = tmp;
+ ctx = tmp;
- if (ctx == NULL)
- return 0;
+ if (ctx == NULL)
+ return 0;
- gf_fd_fdtable_destroy (ctx->fdtable);
- LOCK_DESTROY (&ctx->fdtable_lock);
- GF_FREE (ctx);
+ gf_fd_fdtable_destroy(ctx->fdtable);
+ LOCK_DESTROY(&ctx->fdtable_lock);
+ GF_FREE(ctx);
- return 0;
+ return 0;
}
int32_t
-server_dump_metrics (xlator_t *this, int fd)
+server_dump_metrics(xlator_t *this, int fd)
{
- rpc_transport_t *xprt = NULL;
- server_conf_t *conf = NULL;
- client_t *client = NULL;
+ rpc_transport_t *xprt = NULL;
+ server_conf_t *conf = NULL;
+ client_t *client = NULL;
- conf = this->private;
+ conf = this->private;
- pthread_mutex_lock (&conf->mutex);
+ pthread_mutex_lock(&conf->mutex);
- list_for_each_entry (xprt, &conf->xprt_list, list) {
- client = xprt->xl_private;
+ list_for_each_entry(xprt, &conf->xprt_list, list)
+ {
+ client = xprt->xl_private;
- if (!client)
- continue;
+ if (!client)
+ continue;
- dprintf (fd, "%s.total.rpc.%s.bytes_read %lu\n", this->name,
- client->client_uid, xprt->total_bytes_read);
- dprintf (fd, "%s.total.rpc.%s.bytes_write %lu\n", this->name,
- client->client_uid, xprt->total_bytes_write);
- dprintf (fd, "%s.total.rpc.%s.outstanding %d\n", this->name,
- client->client_uid, xprt->outstanding_rpc_count);
- }
+ dprintf(fd, "%s.total.rpc.%s.bytes_read %lu\n", this->name,
+ client->client_uid, xprt->total_bytes_read);
+ dprintf(fd, "%s.total.rpc.%s.bytes_write %lu\n", this->name,
+ client->client_uid, xprt->total_bytes_write);
+ dprintf(fd, "%s.total.rpc.%s.outstanding %d\n", this->name,
+ client->client_uid, xprt->outstanding_rpc_count);
+ }
- pthread_mutex_unlock (&conf->mutex);
+ pthread_mutex_unlock(&conf->mutex);
- return 0;
+ return 0;
}
int
-server_init (xlator_t *this)
+server_init(xlator_t *this)
{
- int32_t ret = -1;
- server_conf_t *conf = NULL;
- char *transport_type = NULL;
- char *statedump_path = NULL;
- int total_transport = 0;
-
- GF_VALIDATE_OR_GOTO ("init", this, out);
-
- if (this->children == NULL) {
- gf_msg (this->name, GF_LOG_ERROR, 0, PS_MSG_SUBVOL_NULL,
- "protocol/server should have subvolume");
- goto out;
- }
-
- if (this->parents != NULL) {
- gf_msg (this->name, GF_LOG_ERROR, 0, PS_MSG_PARENT_VOL_ERROR,
- "protocol/server should not have parent volumes");
- goto out;
- }
-
- conf = GF_CALLOC (1, sizeof (server_conf_t),
- gf_server_mt_server_conf_t);
-
- GF_VALIDATE_OR_GOTO(this->name, conf, out);
-
- INIT_LIST_HEAD (&conf->xprt_list);
- pthread_mutex_init (&conf->mutex, NULL);
-
- LOCK_INIT (&conf->itable_lock);
-
- /* Set event threads to the configured default */
- GF_OPTION_INIT("event-threads", conf->event_threads, int32, out);
- ret = server_check_event_threads (this, conf, conf->event_threads);
- if (ret)
- goto out;
-
- ret = server_build_config (this, conf);
- if (ret)
- goto out;
-
- ret = dict_get_str (this->options, "config-directory", &conf->conf_dir);
- if (ret)
- conf->conf_dir = CONFDIR;
-
- conf->child_status = GF_CALLOC (1, sizeof (struct _child_status),
- gf_server_mt_child_status);
- INIT_LIST_HEAD (&conf->child_status->status_list);
- GF_ATOMIC_INIT (conf->child_status->xprtrefcnt, 0);
-
- /*ret = dict_get_str (this->options, "statedump-path", &statedump_path);
- if (!ret) {
- gf_path_strip_trailing_slashes (statedump_path);
- this->ctx->statedump_path = statedump_path;
- }*/
- GF_OPTION_INIT ("statedump-path", statedump_path, path, out);
- if (statedump_path) {
- gf_path_strip_trailing_slashes (statedump_path);
- this->ctx->statedump_path = gf_strdup (statedump_path);
- } else {
- gf_msg (this->name, GF_LOG_ERROR, 0,
- PS_MSG_STATEDUMP_PATH_ERROR,
- "Error setting statedump path");
- ret = -1;
- goto out;
- }
-
- /* Authentication modules */
- conf->auth_modules = dict_new ();
- GF_VALIDATE_OR_GOTO(this->name, conf->auth_modules, out);
-
- dict_foreach (this->options, get_auth_types, conf->auth_modules);
- ret = validate_auth_options (this, this->options);
- if (ret == -1) {
- /* logging already done in validate_auth_options function. */
- goto out;
- }
-
- ret = gf_auth_init (this, conf->auth_modules);
- if (ret) {
- dict_unref (conf->auth_modules);
- goto out;
- }
-
- ret = dict_get_str_boolean (this->options, "manage-gids", _gf_false);
- if (ret == -1)
- conf->server_manage_gids = _gf_false;
- else
- conf->server_manage_gids = ret;
-
- GF_OPTION_INIT("gid-timeout", conf->gid_cache_timeout, int32, out);
- if (gid_cache_init (&conf->gid_cache, conf->gid_cache_timeout) < 0) {
- gf_msg (this->name, GF_LOG_ERROR, 0, PS_MSG_GRP_CACHE_ERROR,
- "Failed to initialize group cache.");
- goto out;
- }
-
- ret = dict_get_str_boolean (this->options, "strict-auth-accept",
- _gf_false);
- if (ret == -1)
- conf->strict_auth_enabled = _gf_false;
- else
- conf->strict_auth_enabled = ret;
-
- ret = dict_get_str_boolean (this->options, "dynamic-auth",
- _gf_true);
- if (ret == -1)
- conf->dync_auth = _gf_true;
- else
- conf->dync_auth = ret;
-
- /* RPC related */
- conf->rpc = rpcsvc_init (this, this->ctx, this->options, 0);
- if (conf->rpc == NULL) {
- gf_msg (this->name, GF_LOG_ERROR, 0,
- PS_MSG_RPCSVC_CREATE_FAILED, "creation of rpcsvc "
- "failed");
- ret = -1;
- goto out;
- }
-
- ret = rpcsvc_set_outstanding_rpc_limit (conf->rpc, this->options,
- RPCSVC_DEFAULT_OUTSTANDING_RPC_LIMIT);
- if (ret < 0) {
- gf_msg (this->name, GF_LOG_ERROR, 0, PS_MSG_RPC_CONF_ERROR,
- "Failed to configure outstanding-rpc-limit");
- goto out;
- }
-
- /*
- * This is the only place where we want secure_srvr to reflect
- * the data-plane setting.
- */
- this->ctx->secure_srvr = MGMT_SSL_COPY_IO;
-
- ret = dict_get_str (this->options, "transport-type", &transport_type);
- if (ret) {
- gf_msg (this->name, GF_LOG_ERROR, 0, PS_MSG_TRANSPORT_ERROR,
- "option transport-type not set");
- ret = -1;
- goto out;
- }
- total_transport = rpc_transport_count (transport_type);
- if (total_transport <= 0) {
- gf_msg (this->name, GF_LOG_ERROR, 0, PS_MSG_TRANSPORT_ERROR,
- "failed to get total number of available tranpsorts");
- ret = -1;
- goto out;
- }
- ret = rpcsvc_create_listeners (conf->rpc, this->options,
- this->name);
- if (ret < 1) {
- gf_msg (this->name, GF_LOG_WARNING, 0,
- PS_MSG_RPCSVC_LISTENER_CREATE_FAILED,
- "creation of listener failed");
- if (ret != -EADDRINUSE)
- ret = -1;
- goto out;
- } else if (ret < total_transport) {
- gf_msg (this->name, GF_LOG_ERROR, 0,
- PS_MSG_RPCSVC_LISTENER_CREATE_FAILED,
- "creation of %d listeners failed, continuing with "
- "succeeded transport", (total_transport - ret));
- }
-
- ret = rpcsvc_register_notify (conf->rpc, server_rpc_notify, this);
- if (ret) {
- gf_msg (this->name, GF_LOG_WARNING, 0, PS_MSG_RPCSVC_NOTIFY,
- "registration of notify with rpcsvc failed");
- goto out;
- }
-
- glusterfs3_3_fop_prog.options = this->options;
- /* make sure we register the fop program at the head to optimize
- * lookup
- */
- ret = rpcsvc_program_register (conf->rpc, &glusterfs3_3_fop_prog,
- _gf_true);
- if (ret) {
- gf_msg (this->name, GF_LOG_WARNING, 0, PS_MSG_PGM_REG_FAILED,
- "registration of program (name:%s, prognum:%d, "
- "progver:%d) failed", glusterfs3_3_fop_prog.progname,
- glusterfs3_3_fop_prog.prognum,
- glusterfs3_3_fop_prog.progver);
- goto out;
- }
-
- glusterfs4_0_fop_prog.options = this->options;
- ret = rpcsvc_program_register (conf->rpc, &glusterfs4_0_fop_prog,
- _gf_true);
- if (ret) {
- gf_log (this->name, GF_LOG_WARNING,
- "registration of program (name:%s, prognum:%d, "
- "progver:%d) failed", glusterfs4_0_fop_prog.progname,
- glusterfs4_0_fop_prog.prognum,
- glusterfs4_0_fop_prog.progver);
- rpcsvc_program_unregister (conf->rpc, &glusterfs3_3_fop_prog);
- goto out;
- }
-
- gluster_handshake_prog.options = this->options;
- ret = rpcsvc_program_register (conf->rpc, &gluster_handshake_prog,
- _gf_false);
- if (ret) {
- gf_msg (this->name, GF_LOG_WARNING, 0, PS_MSG_PGM_REG_FAILED,
- "registration of program (name:%s, prognum:%d, "
- "progver:%d) failed", gluster_handshake_prog.progname,
- gluster_handshake_prog.prognum,
- gluster_handshake_prog.progver);
- rpcsvc_program_unregister (conf->rpc, &glusterfs3_3_fop_prog);
- rpcsvc_program_unregister (conf->rpc, &glusterfs4_0_fop_prog);
- goto out;
- }
+ int32_t ret = -1;
+ server_conf_t *conf = NULL;
+ char *transport_type = NULL;
+ char *statedump_path = NULL;
+ int total_transport = 0;
+
+ GF_VALIDATE_OR_GOTO("init", this, out);
+
+ if (this->children == NULL) {
+ gf_msg(this->name, GF_LOG_ERROR, 0, PS_MSG_SUBVOL_NULL,
+ "protocol/server should have subvolume");
+ goto out;
+ }
+
+ if (this->parents != NULL) {
+ gf_msg(this->name, GF_LOG_ERROR, 0, PS_MSG_PARENT_VOL_ERROR,
+ "protocol/server should not have parent volumes");
+ goto out;
+ }
+
+ conf = GF_CALLOC(1, sizeof(server_conf_t), gf_server_mt_server_conf_t);
+
+ GF_VALIDATE_OR_GOTO(this->name, conf, out);
+
+ INIT_LIST_HEAD(&conf->xprt_list);
+ pthread_mutex_init(&conf->mutex, NULL);
+
+ LOCK_INIT(&conf->itable_lock);
+
+ /* Set event threads to the configured default */
+ GF_OPTION_INIT("event-threads", conf->event_threads, int32, out);
+ ret = server_check_event_threads(this, conf, conf->event_threads);
+ if (ret)
+ goto out;
+
+ ret = server_build_config(this, conf);
+ if (ret)
+ goto out;
+
+ ret = dict_get_str(this->options, "config-directory", &conf->conf_dir);
+ if (ret)
+ conf->conf_dir = CONFDIR;
+
+ conf->child_status = GF_CALLOC(1, sizeof(struct _child_status),
+ gf_server_mt_child_status);
+ INIT_LIST_HEAD(&conf->child_status->status_list);
+ GF_ATOMIC_INIT(conf->child_status->xprtrefcnt, 0);
+
+ /*ret = dict_get_str (this->options, "statedump-path", &statedump_path);
+ if (!ret) {
+ gf_path_strip_trailing_slashes (statedump_path);
+ this->ctx->statedump_path = statedump_path;
+ }*/
+ GF_OPTION_INIT("statedump-path", statedump_path, path, out);
+ if (statedump_path) {
+ gf_path_strip_trailing_slashes(statedump_path);
+ this->ctx->statedump_path = gf_strdup(statedump_path);
+ } else {
+ gf_msg(this->name, GF_LOG_ERROR, 0, PS_MSG_STATEDUMP_PATH_ERROR,
+ "Error setting statedump path");
+ ret = -1;
+ goto out;
+ }
+
+ /* Authentication modules */
+ conf->auth_modules = dict_new();
+ GF_VALIDATE_OR_GOTO(this->name, conf->auth_modules, out);
+
+ dict_foreach(this->options, get_auth_types, conf->auth_modules);
+ ret = validate_auth_options(this, this->options);
+ if (ret == -1) {
+ /* logging already done in validate_auth_options function. */
+ goto out;
+ }
+
+ ret = gf_auth_init(this, conf->auth_modules);
+ if (ret) {
+ dict_unref(conf->auth_modules);
+ goto out;
+ }
+
+ ret = dict_get_str_boolean(this->options, "manage-gids", _gf_false);
+ if (ret == -1)
+ conf->server_manage_gids = _gf_false;
+ else
+ conf->server_manage_gids = ret;
+
+ GF_OPTION_INIT("gid-timeout", conf->gid_cache_timeout, int32, out);
+ if (gid_cache_init(&conf->gid_cache, conf->gid_cache_timeout) < 0) {
+ gf_msg(this->name, GF_LOG_ERROR, 0, PS_MSG_GRP_CACHE_ERROR,
+ "Failed to initialize group cache.");
+ goto out;
+ }
+
+ ret = dict_get_str_boolean(this->options, "strict-auth-accept", _gf_false);
+ if (ret == -1)
+ conf->strict_auth_enabled = _gf_false;
+ else
+ conf->strict_auth_enabled = ret;
+
+ ret = dict_get_str_boolean(this->options, "dynamic-auth", _gf_true);
+ if (ret == -1)
+ conf->dync_auth = _gf_true;
+ else
+ conf->dync_auth = ret;
+
+ /* RPC related */
+ conf->rpc = rpcsvc_init(this, this->ctx, this->options, 0);
+ if (conf->rpc == NULL) {
+ gf_msg(this->name, GF_LOG_ERROR, 0, PS_MSG_RPCSVC_CREATE_FAILED,
+ "creation of rpcsvc "
+ "failed");
+ ret = -1;
+ goto out;
+ }
+
+ ret = rpcsvc_set_outstanding_rpc_limit(
+ conf->rpc, this->options, RPCSVC_DEFAULT_OUTSTANDING_RPC_LIMIT);
+ if (ret < 0) {
+ gf_msg(this->name, GF_LOG_ERROR, 0, PS_MSG_RPC_CONF_ERROR,
+ "Failed to configure outstanding-rpc-limit");
+ goto out;
+ }
+
+ /*
+ * This is the only place where we want secure_srvr to reflect
+ * the data-plane setting.
+ */
+ this->ctx->secure_srvr = MGMT_SSL_COPY_IO;
+
+ ret = dict_get_str(this->options, "transport-type", &transport_type);
+ if (ret) {
+ gf_msg(this->name, GF_LOG_ERROR, 0, PS_MSG_TRANSPORT_ERROR,
+ "option transport-type not set");
+ ret = -1;
+ goto out;
+ }
+ total_transport = rpc_transport_count(transport_type);
+ if (total_transport <= 0) {
+ gf_msg(this->name, GF_LOG_ERROR, 0, PS_MSG_TRANSPORT_ERROR,
+ "failed to get total number of available tranpsorts");
+ ret = -1;
+ goto out;
+ }
+ ret = rpcsvc_create_listeners(conf->rpc, this->options, this->name);
+ if (ret < 1) {
+ gf_msg(this->name, GF_LOG_WARNING, 0,
+ PS_MSG_RPCSVC_LISTENER_CREATE_FAILED,
+ "creation of listener failed");
+ if (ret != -EADDRINUSE)
+ ret = -1;
+ goto out;
+ } else if (ret < total_transport) {
+ gf_msg(this->name, GF_LOG_ERROR, 0,
+ PS_MSG_RPCSVC_LISTENER_CREATE_FAILED,
+ "creation of %d listeners failed, continuing with "
+ "succeeded transport",
+ (total_transport - ret));
+ }
+
+ ret = rpcsvc_register_notify(conf->rpc, server_rpc_notify, this);
+ if (ret) {
+ gf_msg(this->name, GF_LOG_WARNING, 0, PS_MSG_RPCSVC_NOTIFY,
+ "registration of notify with rpcsvc failed");
+ goto out;
+ }
+
+ glusterfs3_3_fop_prog.options = this->options;
+ /* make sure we register the fop program at the head to optimize
+ * lookup
+ */
+ ret = rpcsvc_program_register(conf->rpc, &glusterfs3_3_fop_prog, _gf_true);
+ if (ret) {
+ gf_msg(this->name, GF_LOG_WARNING, 0, PS_MSG_PGM_REG_FAILED,
+ "registration of program (name:%s, prognum:%d, "
+ "progver:%d) failed",
+ glusterfs3_3_fop_prog.progname, glusterfs3_3_fop_prog.prognum,
+ glusterfs3_3_fop_prog.progver);
+ goto out;
+ }
+
+ glusterfs4_0_fop_prog.options = this->options;
+ ret = rpcsvc_program_register(conf->rpc, &glusterfs4_0_fop_prog, _gf_true);
+ if (ret) {
+ gf_log(this->name, GF_LOG_WARNING,
+ "registration of program (name:%s, prognum:%d, "
+ "progver:%d) failed",
+ glusterfs4_0_fop_prog.progname, glusterfs4_0_fop_prog.prognum,
+ glusterfs4_0_fop_prog.progver);
+ rpcsvc_program_unregister(conf->rpc, &glusterfs3_3_fop_prog);
+ goto out;
+ }
+
+ gluster_handshake_prog.options = this->options;
+ ret = rpcsvc_program_register(conf->rpc, &gluster_handshake_prog,
+ _gf_false);
+ if (ret) {
+ gf_msg(this->name, GF_LOG_WARNING, 0, PS_MSG_PGM_REG_FAILED,
+ "registration of program (name:%s, prognum:%d, "
+ "progver:%d) failed",
+ gluster_handshake_prog.progname, gluster_handshake_prog.prognum,
+ gluster_handshake_prog.progver);
+ rpcsvc_program_unregister(conf->rpc, &glusterfs3_3_fop_prog);
+ rpcsvc_program_unregister(conf->rpc, &glusterfs4_0_fop_prog);
+ goto out;
+ }
#ifndef GF_DARWIN_HOST_OS
- {
- struct rlimit lim;
-
- lim.rlim_cur = 1048576;
- lim.rlim_max = 1048576;
-
- if (setrlimit (RLIMIT_NOFILE, &lim) == -1) {
- gf_msg (this->name, GF_LOG_WARNING, errno,
- PS_MSG_ULIMIT_SET_FAILED, "WARNING: Failed to "
- "set 'ulimit -n 1M': %s", strerror(errno));
- lim.rlim_cur = 65536;
- lim.rlim_max = 65536;
-
- if (setrlimit (RLIMIT_NOFILE, &lim) == -1) {
- gf_msg (this->name, GF_LOG_WARNING, errno,
- PS_MSG_FD_NOT_FOUND, "Failed to set "
- "max open fd to 64k: %s",
- strerror(errno));
- } else {
- gf_msg_trace (this->name, 0, "max open fd set "
- "to 64k");
- }
- }
+ {
+ struct rlimit lim;
+
+ lim.rlim_cur = 1048576;
+ lim.rlim_max = 1048576;
+
+ if (setrlimit(RLIMIT_NOFILE, &lim) == -1) {
+ gf_msg(this->name, GF_LOG_WARNING, errno, PS_MSG_ULIMIT_SET_FAILED,
+ "WARNING: Failed to "
+ "set 'ulimit -n 1M': %s",
+ strerror(errno));
+ lim.rlim_cur = 65536;
+ lim.rlim_max = 65536;
+
+ if (setrlimit(RLIMIT_NOFILE, &lim) == -1) {
+ gf_msg(this->name, GF_LOG_WARNING, errno, PS_MSG_FD_NOT_FOUND,
+ "Failed to set "
+ "max open fd to 64k: %s",
+ strerror(errno));
+ } else {
+ gf_msg_trace(this->name, 0,
+ "max open fd set "
+ "to 64k");
+ }
}
+ }
#endif
- if (!this->ctx->cmd_args.volfile_id) {
- /* In some use cases this is a valid case, but
- document this to be annoying log in that case */
- gf_msg (this->name, GF_LOG_WARNING, EINVAL,
- PS_MSG_VOL_FILE_OPEN_FAILED,
- "volfile-id argument not given. "
- "This is mandatory argument, defaulting to 'gluster'");
- this->ctx->cmd_args.volfile_id = gf_strdup ("gluster");
- }
- FIRST_CHILD(this)->volfile_id
- = gf_strdup (this->ctx->cmd_args.volfile_id);
-
- this->private = conf;
- ret = 0;
+ if (!this->ctx->cmd_args.volfile_id) {
+ /* In some use cases this is a valid case, but
+ document this to be annoying log in that case */
+ gf_msg(this->name, GF_LOG_WARNING, EINVAL, PS_MSG_VOL_FILE_OPEN_FAILED,
+ "volfile-id argument not given. "
+ "This is mandatory argument, defaulting to 'gluster'");
+ this->ctx->cmd_args.volfile_id = gf_strdup("gluster");
+ }
+ FIRST_CHILD(this)->volfile_id = gf_strdup(this->ctx->cmd_args.volfile_id);
+
+ this->private = conf;
+ ret = 0;
out:
- if (ret) {
- if (this != NULL) {
- this->fini (this);
- }
+ if (ret) {
+ if (this != NULL) {
+ this->fini(this);
+ }
- if (conf && conf->rpc) {
- rpcsvc_listener_t *listener, *next;
- list_for_each_entry_safe (listener, next,
- &conf->rpc->listeners, list) {
- rpcsvc_listener_destroy (listener);
- }
- }
+ if (conf && conf->rpc) {
+ rpcsvc_listener_t *listener, *next;
+ list_for_each_entry_safe(listener, next, &conf->rpc->listeners,
+ list)
+ {
+ rpcsvc_listener_destroy(listener);
+ }
}
+ }
- return ret;
+ return ret;
}
-
void
-server_fini (xlator_t *this)
+server_fini(xlator_t *this)
{
#if 0
server_conf_t *conf = NULL;
@@ -1269,585 +1221,561 @@ server_fini (xlator_t *this)
this->private = NULL;
#endif
- return;
+ return;
}
int
-server_process_event_upcall (xlator_t *this, void *data)
+server_process_event_upcall(xlator_t *this, void *data)
{
- int ret = -1;
- server_conf_t *conf = NULL;
- client_t *client = NULL;
- char *client_uid = NULL;
- struct gf_upcall *upcall_data = NULL;
- void *up_req = NULL;
- rpc_transport_t *xprt = NULL;
- enum gf_cbk_procnum cbk_procnum = GF_CBK_NULL;
- gfs3_cbk_cache_invalidation_req gf_c_req = {0,};
- gfs3_recall_lease_req gf_recall_lease = {{0,},};
- gfs4_inodelk_contention_req gf_inodelk_contention = {{0},};
- gfs4_entrylk_contention_req gf_entrylk_contention = {{0},};
- xdrproc_t xdrproc;
-
- GF_VALIDATE_OR_GOTO(this->name, data, out);
-
- conf = this->private;
- GF_VALIDATE_OR_GOTO(this->name, conf, out);
-
- upcall_data = (struct gf_upcall *)data;
- client_uid = upcall_data->client_uid;
- /* client_uid could be NULL if the upcall was intended for a server's
- * child xlator (so no client_uid available) but it hasn't handled
- * the notification. For this reason we silently ignore any upcall
- * request with a NULL client_uid, but -1 will be returned.
- */
- if (client_uid == NULL) {
- gf_msg_debug(this->name, 0,
- "NULL client_uid for an upcall request");
+ int ret = -1;
+ server_conf_t *conf = NULL;
+ client_t *client = NULL;
+ char *client_uid = NULL;
+ struct gf_upcall *upcall_data = NULL;
+ void *up_req = NULL;
+ rpc_transport_t *xprt = NULL;
+ enum gf_cbk_procnum cbk_procnum = GF_CBK_NULL;
+ gfs3_cbk_cache_invalidation_req gf_c_req = {
+ 0,
+ };
+ gfs3_recall_lease_req gf_recall_lease = {
+ {
+ 0,
+ },
+ };
+ gfs4_inodelk_contention_req gf_inodelk_contention = {
+ {0},
+ };
+ gfs4_entrylk_contention_req gf_entrylk_contention = {
+ {0},
+ };
+ xdrproc_t xdrproc;
+
+ GF_VALIDATE_OR_GOTO(this->name, data, out);
+
+ conf = this->private;
+ GF_VALIDATE_OR_GOTO(this->name, conf, out);
+
+ upcall_data = (struct gf_upcall *)data;
+ client_uid = upcall_data->client_uid;
+ /* client_uid could be NULL if the upcall was intended for a server's
+ * child xlator (so no client_uid available) but it hasn't handled
+ * the notification. For this reason we silently ignore any upcall
+ * request with a NULL client_uid, but -1 will be returned.
+ */
+ if (client_uid == NULL) {
+ gf_msg_debug(this->name, 0, "NULL client_uid for an upcall request");
+ goto out;
+ }
+
+ switch (upcall_data->event_type) {
+ case GF_UPCALL_CACHE_INVALIDATION:
+ ret = gf_proto_cache_invalidation_from_upcall(this, &gf_c_req,
+ upcall_data);
+ if (ret < 0)
goto out;
- }
- switch (upcall_data->event_type) {
- case GF_UPCALL_CACHE_INVALIDATION:
- ret = gf_proto_cache_invalidation_from_upcall (this, &gf_c_req,
- upcall_data);
- if (ret < 0)
- goto out;
-
- up_req = &gf_c_req;
- cbk_procnum = GF_CBK_CACHE_INVALIDATION;
- xdrproc = (xdrproc_t)xdr_gfs3_cbk_cache_invalidation_req;
- break;
+ up_req = &gf_c_req;
+ cbk_procnum = GF_CBK_CACHE_INVALIDATION;
+ xdrproc = (xdrproc_t)xdr_gfs3_cbk_cache_invalidation_req;
+ break;
case GF_UPCALL_RECALL_LEASE:
- ret = gf_proto_recall_lease_from_upcall (this, &gf_recall_lease,
- upcall_data);
- if (ret < 0)
- goto out;
-
- up_req = &gf_recall_lease;
- cbk_procnum = GF_CBK_RECALL_LEASE;
- xdrproc = (xdrproc_t)xdr_gfs3_recall_lease_req;
- break;
+ ret = gf_proto_recall_lease_from_upcall(this, &gf_recall_lease,
+ upcall_data);
+ if (ret < 0)
+ goto out;
+
+ up_req = &gf_recall_lease;
+ cbk_procnum = GF_CBK_RECALL_LEASE;
+ xdrproc = (xdrproc_t)xdr_gfs3_recall_lease_req;
+ break;
case GF_UPCALL_INODELK_CONTENTION:
- ret = gf_proto_inodelk_contention_from_upcall (this,
- &gf_inodelk_contention,
- upcall_data);
- if (ret < 0)
- goto out;
-
- up_req = &gf_inodelk_contention;
- cbk_procnum = GF_CBK_INODELK_CONTENTION;
- xdrproc = (xdrproc_t)xdr_gfs4_inodelk_contention_req;
- break;
+ ret = gf_proto_inodelk_contention_from_upcall(
+ this, &gf_inodelk_contention, upcall_data);
+ if (ret < 0)
+ goto out;
+
+ up_req = &gf_inodelk_contention;
+ cbk_procnum = GF_CBK_INODELK_CONTENTION;
+ xdrproc = (xdrproc_t)xdr_gfs4_inodelk_contention_req;
+ break;
case GF_UPCALL_ENTRYLK_CONTENTION:
- ret = gf_proto_entrylk_contention_from_upcall (this,
- &gf_entrylk_contention,
- upcall_data);
- if (ret < 0)
- goto out;
-
- up_req = &gf_entrylk_contention;
- cbk_procnum = GF_CBK_ENTRYLK_CONTENTION;
- xdrproc = (xdrproc_t)xdr_gfs4_entrylk_contention_req;
- break;
- default:
- gf_msg (this->name, GF_LOG_WARNING, EINVAL,
- PS_MSG_INVALID_ENTRY,
- "Received invalid upcall event(%d)",
- upcall_data->event_type);
+ ret = gf_proto_entrylk_contention_from_upcall(
+ this, &gf_entrylk_contention, upcall_data);
+ if (ret < 0)
goto out;
- }
- pthread_mutex_lock (&conf->mutex);
+ up_req = &gf_entrylk_contention;
+ cbk_procnum = GF_CBK_ENTRYLK_CONTENTION;
+ xdrproc = (xdrproc_t)xdr_gfs4_entrylk_contention_req;
+ break;
+ default:
+ gf_msg(this->name, GF_LOG_WARNING, EINVAL, PS_MSG_INVALID_ENTRY,
+ "Received invalid upcall event(%d)",
+ upcall_data->event_type);
+ goto out;
+ }
+
+ pthread_mutex_lock(&conf->mutex);
+ {
+ list_for_each_entry(xprt, &conf->xprt_list, list)
{
- list_for_each_entry (xprt, &conf->xprt_list, list) {
- client = xprt->xl_private;
-
- /* 'client' is not atomically added during xprt entry
- * addition to the list. */
- if (!client || strcmp(client->client_uid, client_uid))
- continue;
-
- ret = rpcsvc_request_submit (conf->rpc, xprt,
- &server_cbk_prog,
- cbk_procnum,
- up_req,
- this->ctx,
- xdrproc);
- if (ret < 0) {
- gf_msg_debug (this->name, 0, "Failed to send "
- "upcall to client:%s upcall "
- "event:%d", client_uid,
- upcall_data->event_type);
- }
- break;
- }
+ client = xprt->xl_private;
+
+ /* 'client' is not atomically added during xprt entry
+ * addition to the list. */
+ if (!client || strcmp(client->client_uid, client_uid))
+ continue;
+
+ ret = rpcsvc_request_submit(conf->rpc, xprt, &server_cbk_prog,
+ cbk_procnum, up_req, this->ctx,
+ xdrproc);
+ if (ret < 0) {
+ gf_msg_debug(this->name, 0,
+ "Failed to send "
+ "upcall to client:%s upcall "
+ "event:%d",
+ client_uid, upcall_data->event_type);
+ }
+ break;
}
- pthread_mutex_unlock (&conf->mutex);
- ret = 0;
+ }
+ pthread_mutex_unlock(&conf->mutex);
+ ret = 0;
out:
- GF_FREE ((gf_c_req.xdata).xdata_val);
- GF_FREE ((gf_recall_lease.xdata).xdata_val);
- GF_FREE ((gf_inodelk_contention.xdata).xdata_val);
- GF_FREE ((gf_entrylk_contention.xdata).xdata_val);
+ GF_FREE((gf_c_req.xdata).xdata_val);
+ GF_FREE((gf_recall_lease.xdata).xdata_val);
+ GF_FREE((gf_inodelk_contention.xdata).xdata_val);
+ GF_FREE((gf_entrylk_contention.xdata).xdata_val);
- return ret;
+ return ret;
}
int
-server_process_child_event (xlator_t *this, int32_t event, void *data,
- enum gf_cbk_procnum cbk_procnum)
+server_process_child_event(xlator_t *this, int32_t event, void *data,
+ enum gf_cbk_procnum cbk_procnum)
{
- int ret = -1;
- server_conf_t *conf = NULL;
- rpc_transport_t *xprt = NULL;
- xlator_t *victim = NULL;
- struct _child_status *tmp = NULL;
-
- GF_VALIDATE_OR_GOTO(this->name, data, out);
-
- conf = this->private;
- GF_VALIDATE_OR_GOTO(this->name, conf, out);
+ int ret = -1;
+ server_conf_t *conf = NULL;
+ rpc_transport_t *xprt = NULL;
+ xlator_t *victim = NULL;
+ struct _child_status *tmp = NULL;
+
+ GF_VALIDATE_OR_GOTO(this->name, data, out);
+
+ conf = this->private;
+ GF_VALIDATE_OR_GOTO(this->name, conf, out);
+
+ victim = data;
+ pthread_mutex_lock(&conf->mutex);
+ {
+ if (cbk_procnum == GF_CBK_CHILD_UP) {
+ list_for_each_entry(tmp, &conf->child_status->status_list,
+ status_list)
+ {
+ if (tmp->name == NULL)
+ break;
+ if (strcmp(tmp->name, victim->name) == 0)
+ break;
+ }
+ if (tmp->name) {
+ tmp->child_up = _gf_true;
+ } else {
+ tmp = GF_CALLOC(1, sizeof(struct _child_status),
+ gf_server_mt_child_status);
+ INIT_LIST_HEAD(&tmp->status_list);
+ tmp->name = gf_strdup(victim->name);
+ tmp->child_up = _gf_true;
+ list_add_tail(&tmp->status_list,
+ &conf->child_status->status_list);
+ }
+ }
- victim = data;
- pthread_mutex_lock (&conf->mutex);
- {
- if (cbk_procnum == GF_CBK_CHILD_UP) {
- list_for_each_entry (tmp, &conf->child_status->status_list,
- status_list) {
- if (tmp->name == NULL)
- break;
- if (strcmp (tmp->name, victim->name) == 0)
- break;
- }
- if (tmp->name) {
- tmp->child_up = _gf_true;
- } else {
- tmp = GF_CALLOC (1, sizeof (struct _child_status),
- gf_server_mt_child_status);
- INIT_LIST_HEAD (&tmp->status_list);
- tmp->name = gf_strdup (victim->name);
- tmp->child_up = _gf_true;
- list_add_tail (&tmp->status_list,
- &conf->child_status->status_list);
- }
+ if (cbk_procnum == GF_CBK_CHILD_DOWN) {
+ list_for_each_entry(tmp, &conf->child_status->status_list,
+ status_list)
+ {
+ if (strcmp(tmp->name, victim->name) == 0) {
+ tmp->child_up = _gf_false;
+ break;
}
+ }
- if (cbk_procnum == GF_CBK_CHILD_DOWN) {
- list_for_each_entry (tmp, &conf->child_status->status_list,
- status_list) {
- if (strcmp (tmp->name, victim->name) == 0) {
- tmp->child_up = _gf_false;
- break;
- }
- }
-
- if (!tmp->name)
- gf_msg (this->name, GF_LOG_ERROR, 0,
- PS_MSG_CHILD_STATUS_FAILED,
- "No xlator %s is found in "
- "child status list", victim->name);
- }
- list_for_each_entry (xprt, &conf->xprt_list, list) {
- if (!xprt->xl_private) {
- continue;
- }
- if (xprt->xl_private->bound_xl == data) {
- rpcsvc_callback_submit (conf->rpc, xprt,
- &server_cbk_prog,
- cbk_procnum,
- NULL, 0, NULL);
- }
- }
+ if (!tmp->name)
+ gf_msg(this->name, GF_LOG_ERROR, 0, PS_MSG_CHILD_STATUS_FAILED,
+ "No xlator %s is found in "
+ "child status list",
+ victim->name);
+ }
+ list_for_each_entry(xprt, &conf->xprt_list, list)
+ {
+ if (!xprt->xl_private) {
+ continue;
+ }
+ if (xprt->xl_private->bound_xl == data) {
+ rpcsvc_callback_submit(conf->rpc, xprt, &server_cbk_prog,
+ cbk_procnum, NULL, 0, NULL);
+ }
}
- pthread_mutex_unlock (&conf->mutex);
- ret = 0;
+ }
+ pthread_mutex_unlock(&conf->mutex);
+ ret = 0;
out:
- return ret;
+ return ret;
}
-
int
-server_notify (xlator_t *this, int32_t event, void *data, ...)
+server_notify(xlator_t *this, int32_t event, void *data, ...)
{
- int ret = -1;
- server_conf_t *conf = NULL;
- rpc_transport_t *xprt = NULL;
- rpc_transport_t *xp_next = NULL;
- xlator_t *victim = NULL;
- xlator_t *top = NULL;
- xlator_t *travxl = NULL;
- xlator_list_t **trav_p = NULL;
- struct _child_status *tmp = NULL;
- gf_boolean_t victim_found = _gf_false;
- glusterfs_ctx_t *ctx = NULL;
- gf_boolean_t xprt_found = _gf_false;
- uint64_t totxprt = 0;
-
- GF_VALIDATE_OR_GOTO (THIS->name, this, out);
- conf = this->private;
- GF_VALIDATE_OR_GOTO (this->name, conf, out);
- victim = data;
- ctx = THIS->ctx;
-
- switch (event) {
- case GF_EVENT_UPCALL:
- {
- GF_VALIDATE_OR_GOTO(this->name, data, out);
-
- ret = server_process_event_upcall (this, data);
- if (ret) {
- gf_msg (this->name, GF_LOG_ERROR, 0,
- PS_MSG_SERVER_EVENT_UPCALL_FAILED,
- "server_process_event_upcall failed");
- goto out;
- }
- break;
+ int ret = -1;
+ server_conf_t *conf = NULL;
+ rpc_transport_t *xprt = NULL;
+ rpc_transport_t *xp_next = NULL;
+ xlator_t *victim = NULL;
+ xlator_t *top = NULL;
+ xlator_t *travxl = NULL;
+ xlator_list_t **trav_p = NULL;
+ struct _child_status *tmp = NULL;
+ gf_boolean_t victim_found = _gf_false;
+ glusterfs_ctx_t *ctx = NULL;
+ gf_boolean_t xprt_found = _gf_false;
+ uint64_t totxprt = 0;
+
+ GF_VALIDATE_OR_GOTO(THIS->name, this, out);
+ conf = this->private;
+ GF_VALIDATE_OR_GOTO(this->name, conf, out);
+ victim = data;
+ ctx = THIS->ctx;
+
+ switch (event) {
+ case GF_EVENT_UPCALL: {
+ GF_VALIDATE_OR_GOTO(this->name, data, out);
+
+ ret = server_process_event_upcall(this, data);
+ if (ret) {
+ gf_msg(this->name, GF_LOG_ERROR, 0,
+ PS_MSG_SERVER_EVENT_UPCALL_FAILED,
+ "server_process_event_upcall failed");
+ goto out;
+ }
+ break;
}
- case GF_EVENT_PARENT_UP:
- {
- conf = this->private;
+ case GF_EVENT_PARENT_UP: {
+ conf = this->private;
- conf->parent_up = _gf_true;
+ conf->parent_up = _gf_true;
- default_notify (this, event, data);
- break;
+ default_notify(this, event, data);
+ break;
}
- case GF_EVENT_CHILD_UP:
- {
- ret = server_process_child_event (this, event, data,
- GF_CBK_CHILD_UP);
- if (ret) {
- gf_msg (this->name, GF_LOG_ERROR, 0,
- PS_MSG_SERVER_EVENT_UPCALL_FAILED,
- "server_process_child_event failed");
- goto out;
- }
- default_notify (this, event, data);
- break;
+ case GF_EVENT_CHILD_UP: {
+ ret = server_process_child_event(this, event, data,
+ GF_CBK_CHILD_UP);
+ if (ret) {
+ gf_msg(this->name, GF_LOG_ERROR, 0,
+ PS_MSG_SERVER_EVENT_UPCALL_FAILED,
+ "server_process_child_event failed");
+ goto out;
+ }
+ default_notify(this, event, data);
+ break;
}
- case GF_EVENT_CHILD_DOWN:
- {
- ret = server_process_child_event (this, event, data,
- GF_CBK_CHILD_DOWN);
- if (ret) {
- gf_msg (this->name, GF_LOG_ERROR, 0,
- PS_MSG_SERVER_EVENT_UPCALL_FAILED,
- "server_process_child_event failed");
- goto out;
- }
- default_notify (this, event, data);
- break;
-
+ case GF_EVENT_CHILD_DOWN: {
+ ret = server_process_child_event(this, event, data,
+ GF_CBK_CHILD_DOWN);
+ if (ret) {
+ gf_msg(this->name, GF_LOG_ERROR, 0,
+ PS_MSG_SERVER_EVENT_UPCALL_FAILED,
+ "server_process_child_event failed");
+ goto out;
+ }
+ default_notify(this, event, data);
+ break;
}
case GF_EVENT_CLEANUP:
- conf = this->private;
- pthread_mutex_lock (&conf->mutex);
- /* Calculate total no. of xprt available in list for this
- brick xlator
- */
- list_for_each_entry_safe (xprt, xp_next,
- &conf->xprt_list, list) {
- if (!xprt->xl_private) {
- continue;
- }
- if (xprt->xl_private->bound_xl == data) {
- totxprt++;
- }
+ conf = this->private;
+ pthread_mutex_lock(&conf->mutex);
+ /* Calculate total no. of xprt available in list for this
+ brick xlator
+ */
+ list_for_each_entry_safe(xprt, xp_next, &conf->xprt_list, list)
+ {
+ if (!xprt->xl_private) {
+ continue;
}
-
- list_for_each_entry (tmp, &conf->child_status->status_list,
- status_list) {
- if (strcmp (tmp->name, victim->name) == 0) {
- tmp->child_up = _gf_false;
- GF_ATOMIC_INIT (tmp->xprtrefcnt, totxprt);
- break;
- }
+ if (xprt->xl_private->bound_xl == data) {
+ totxprt++;
}
-
- /*
- * Disconnecting will (usually) drop the last ref, which will
- * cause the transport to be unlinked and freed while we're
- * still traversing, which will cause us to crash unless we use
- * list_for_each_entry_safe.
- */
- list_for_each_entry_safe (xprt, xp_next,
- &conf->xprt_list, list) {
- if (!xprt->xl_private) {
- continue;
- }
- if (xprt->xl_private->bound_xl == data) {
- gf_log (this->name, GF_LOG_INFO,
- "disconnecting %s",
- xprt->peerinfo.identifier);
- xprt_found = _gf_true;
- rpc_transport_disconnect (xprt, _gf_false);
- }
+ }
+
+ list_for_each_entry(tmp, &conf->child_status->status_list,
+ status_list)
+ {
+ if (strcmp(tmp->name, victim->name) == 0) {
+ tmp->child_up = _gf_false;
+ GF_ATOMIC_INIT(tmp->xprtrefcnt, totxprt);
+ break;
}
+ }
+
+ /*
+ * Disconnecting will (usually) drop the last ref, which will
+ * cause the transport to be unlinked and freed while we're
+ * still traversing, which will cause us to crash unless we use
+ * list_for_each_entry_safe.
+ */
+ list_for_each_entry_safe(xprt, xp_next, &conf->xprt_list, list)
+ {
+ if (!xprt->xl_private) {
+ continue;
+ }
+ if (xprt->xl_private->bound_xl == data) {
+ gf_log(this->name, GF_LOG_INFO, "disconnecting %s",
+ xprt->peerinfo.identifier);
+ xprt_found = _gf_true;
+ rpc_transport_disconnect(xprt, _gf_false);
+ }
+ }
+
+ pthread_mutex_unlock(&conf->mutex);
+ if (this->ctx->active) {
+ top = this->ctx->active->first;
+ LOCK(&ctx->volfile_lock);
+ for (trav_p = &top->children; *trav_p;
+ trav_p = &(*trav_p)->next) {
+ travxl = (*trav_p)->xlator;
+ if (!travxl->call_cleanup &&
+ strcmp(travxl->name, victim->name) == 0) {
+ victim_found = _gf_true;
+ break;
+ }
+ }
+ if (victim_found)
+ glusterfs_delete_volfile_checksum(ctx, victim->volfile_id);
+ UNLOCK(&ctx->volfile_lock);
- pthread_mutex_unlock (&conf->mutex);
- if (this->ctx->active) {
- top = this->ctx->active->first;
- LOCK (&ctx->volfile_lock);
- for (trav_p = &top->children; *trav_p;
- trav_p = &(*trav_p)->next) {
- travxl = (*trav_p)->xlator;
- if (!travxl->call_cleanup &&
- strcmp (travxl->name, victim->name) == 0) {
- victim_found = _gf_true;
- break;
- }
- }
- if (victim_found)
- glusterfs_delete_volfile_checksum (ctx,
- victim->volfile_id);
- UNLOCK (&ctx->volfile_lock);
-
- rpc_clnt_mgmt_pmap_signout (ctx, victim->name);
-
- if (!xprt_found && victim_found) {
- xlator_mem_cleanup (victim);
- rpcsvc_autoscale_threads (ctx, conf->rpc, -1);
- }
+ rpc_clnt_mgmt_pmap_signout(ctx, victim->name);
+
+ if (!xprt_found && victim_found) {
+ xlator_mem_cleanup(victim);
+ rpcsvc_autoscale_threads(ctx, conf->rpc, -1);
}
- break;
+ }
+ break;
default:
- default_notify (this, event, data);
- break;
- }
- ret = 0;
+ default_notify(this, event, data);
+ break;
+ }
+ ret = 0;
out:
- return ret;
+ return ret;
}
-
struct xlator_fops server_fops;
struct xlator_cbks server_cbks = {
- .client_destroy = client_destroy_cbk,
+ .client_destroy = client_destroy_cbk,
};
struct xlator_dumpops server_dumpops = {
- .priv = server_priv,
- .fd = gf_client_dump_fdtables,
- .inode = gf_client_dump_inodes,
- .priv_to_dict = server_priv_to_dict,
- .fd_to_dict = gf_client_dump_fdtables_to_dict,
- .inode_to_dict = gf_client_dump_inodes_to_dict,
+ .priv = server_priv,
+ .fd = gf_client_dump_fdtables,
+ .inode = gf_client_dump_inodes,
+ .priv_to_dict = server_priv_to_dict,
+ .fd_to_dict = gf_client_dump_fdtables_to_dict,
+ .inode_to_dict = gf_client_dump_inodes_to_dict,
};
-
struct volume_options server_options[] = {
- { .key = {"transport-type"},
- .value = {"rpc", "rpc-over-rdma", "tcp", "socket", "ib-verbs",
- "unix", "ib-sdp", "tcp/server", "ib-verbs/server", "rdma",
- "rdma*([ \t]),*([ \t])socket",
- "rdma*([ \t]),*([ \t])tcp",
- "tcp*([ \t]),*([ \t])rdma",
- "socket*([ \t]),*([ \t])rdma"},
- .type = GF_OPTION_TYPE_STR,
- .default_value = "{{ volume.transport }}"
- },
- { .key = {"transport.listen-backlog"},
- .type = GF_OPTION_TYPE_INT,
- .default_value = "10",
- },
- { .key = {"volume-filename.*"},
- .type = GF_OPTION_TYPE_PATH,
- },
- { .key = {"transport.tcp-user-timeout"},
- .type = GF_OPTION_TYPE_TIME,
- .min = 0,
- .max = 1013,
- .default_value = "42", /* default like network.ping-timeout */
- },
- { .key = {"transport.*"},
- .type = GF_OPTION_TYPE_ANY,
- },
- { .key = {"inode-lru-limit"},
- .type = GF_OPTION_TYPE_INT,
- .min = 0,
- .max = 1048576,
- .default_value = "16384",
- .description = "Specifies the limit on the number of inodes "
- "in the lru list of the inode cache.",
- .op_version = {1},
- .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC
- },
- { .key = {"verify-volfile-checksum"},
- .type = GF_OPTION_TYPE_BOOL
- },
- { .key = {"trace"},
- .type = GF_OPTION_TYPE_BOOL
- },
- { .key = {"config-directory",
- "conf-dir"},
- .type = GF_OPTION_TYPE_PATH,
- },
- { .key = {"rpc-auth-allow-insecure", "allow-insecure"},
- .type = GF_OPTION_TYPE_BOOL,
- .default_value = "on",
- .op_version = {1},
- .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC
- },
- { .key = {"root-squash"},
- .type = GF_OPTION_TYPE_BOOL,
- .default_value = "off",
- .description = "Map requests from uid/gid 0 to the anonymous "
- "uid/gid. Note that this does not apply to any other "
- "uids or gids that might be equally sensitive, such "
- "as user bin or group staff.",
- .op_version = {2},
- .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC
- },
- { .key = {"anonuid"},
- .type = GF_OPTION_TYPE_INT,
- .default_value = "65534", /* RPC_NOBODY_UID */
- .min = 0,
- .max = (uint32_t) -1,
- .description = "value of the uid used for the anonymous "
- "user/nfsnobody when root-squash is enabled.",
- .op_version = {3},
- .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC
- },
- { .key = {"anongid"},
- .type = GF_OPTION_TYPE_INT,
- .default_value = "65534", /* RPC_NOBODY_GID */
- .min = 0,
- .max = (uint32_t) -1,
- .description = "value of the gid used for the anonymous "
- "user/nfsnobody when root-squash is enabled.",
- .op_version = {3},
- .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC
- },
- { .key = {"statedump-path"},
- .type = GF_OPTION_TYPE_PATH,
- .default_value = DEFAULT_VAR_RUN_DIRECTORY,
- .description = "Specifies directory in which gluster should save its"
- " statedumps.",
- .op_version = {1},
- .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC
- },
- {.key = {"tcp-window-size"},
- .type = GF_OPTION_TYPE_SIZET,
- .min = GF_MIN_SOCKET_WINDOW_SIZE,
- .max = GF_MAX_SOCKET_WINDOW_SIZE,
- .description = "Specifies the window size for tcp socket.",
- .op_version = {1},
- .flags = OPT_FLAG_SETTABLE
- },
-
- /* The following two options are defined in addr.c, redifined here *
- * for the sake of validation during volume set from cli */
-
- { .key = {"auth.addr.*.allow", "auth.allow"},
- .setkey = "auth.addr.{{ brick.path }}.allow",
- .default_value = "*",
- .type = GF_OPTION_TYPE_INTERNET_ADDRESS_LIST,
- .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
- .description = "Allow a comma separated list of addresses and/or "
- "hostnames to connect to the server. Option "
- "auth.reject overrides this option. By default, all "
- "connections are allowed."
- },
- { .key = {"auth.addr.*.reject", "auth.reject"},
- .setkey = "auth.addr.{{ brick.path }}.reject",
- .type = GF_OPTION_TYPE_INTERNET_ADDRESS_LIST,
- .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
- .description = "Reject a comma separated list of addresses and/or "
- "hostnames to connect to the server. This option "
- "overrides the auth.allow option. By default, all"
- " connections are allowed."
- },
- { .key = {"ssl-allow"},
- .setkey = "auth.login.{{ brick.path }}.ssl-allow",
- .default_value = "*",
- .type = GF_OPTION_TYPE_INTERNET_ADDRESS_LIST,
- .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
- .description = "Allow a comma separated list of common names (CN) of"
- "the clients that are allowed to access the server."
- "By default, all TLS authenticated clients are"
- "allowed to access the server."
- },
- /* This is not a valid path w.r.t daemons, hence it's string */
- { .key = {"auth-path"},
- .type = GF_OPTION_TYPE_STR,
- .default_value = "{{ brick.path }}"
- },
- { .key = {"rpc.outstanding-rpc-limit"},
- .type = GF_OPTION_TYPE_INT,
- .min = RPCSVC_MIN_OUTSTANDING_RPC_LIMIT,
- .max = RPCSVC_MAX_OUTSTANDING_RPC_LIMIT,
- .default_value = TOSTRING(RPCSVC_DEFAULT_OUTSTANDING_RPC_LIMIT),
- .description = "Parameter to throttle the number of incoming RPC "
- "requests from a client. 0 means no limit (can "
- "potentially run out of memory)",
- .op_version = {1},
- .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC | OPT_FLAG_GLOBAL
- },
- { .key = {"manage-gids"},
- .type = GF_OPTION_TYPE_BOOL,
- .default_value = "off",
- .description = "Resolve groups on the server-side.",
- .op_version = {GD_OP_VERSION_3_6_0},
- .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC
- },
- { .key = {"gid-timeout"},
- .type = GF_OPTION_TYPE_INT,
- .default_value = "300",
- .description = "Timeout in seconds for the cached groups to expire.",
- .op_version = {GD_OP_VERSION_3_6_0},
- .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC
- },
- { .key = {"event-threads"},
- .type = GF_OPTION_TYPE_INT,
- .min = 1,
- .max = 1024,
- .default_value = "1",
- .description = "Specifies the number of event threads to execute "
- "in parallel. Larger values would help process"
- " responses faster, depending on available processing"
- " power.",
- .op_version = {GD_OP_VERSION_3_7_0},
- .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC
- },
- { .key = {"dynamic-auth"},
- .type = GF_OPTION_TYPE_BOOL,
- .default_value = "on",
- .description = "When 'on' perform dynamic authentication of volume "
- "options in order to allow/terminate client "
- "transport connection immediately in response to "
- "*.allow | *.reject volume set options.",
- .op_version = {GD_OP_VERSION_3_7_5},
- .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC
- },
- { .key = {"strict-auth-accept"},
- .type = GF_OPTION_TYPE_BOOL,
- .default_value = "off",
- .description = "strict-auth-accept reject connection with out"
- "a valid username and password."
- },
- { .key = {NULL} },
+ {.key = {"transport-type"},
+ .value = {"rpc", "rpc-over-rdma", "tcp", "socket", "ib-verbs", "unix",
+ "ib-sdp", "tcp/server", "ib-verbs/server", "rdma",
+ "rdma*([ \t]),*([ \t])socket", "rdma*([ \t]),*([ \t])tcp",
+ "tcp*([ \t]),*([ \t])rdma", "socket*([ \t]),*([ \t])rdma"},
+ .type = GF_OPTION_TYPE_STR,
+ .default_value = "{{ volume.transport }}"},
+ {
+ .key = {"transport.listen-backlog"},
+ .type = GF_OPTION_TYPE_INT,
+ .default_value = "10",
+ },
+ {
+ .key = {"volume-filename.*"},
+ .type = GF_OPTION_TYPE_PATH,
+ },
+ {
+ .key = {"transport.tcp-user-timeout"},
+ .type = GF_OPTION_TYPE_TIME,
+ .min = 0,
+ .max = 1013,
+ .default_value = "42", /* default like network.ping-timeout */
+ },
+ {
+ .key = {"transport.*"},
+ .type = GF_OPTION_TYPE_ANY,
+ },
+ {.key = {"inode-lru-limit"},
+ .type = GF_OPTION_TYPE_INT,
+ .min = 0,
+ .max = 1048576,
+ .default_value = "16384",
+ .description = "Specifies the limit on the number of inodes "
+ "in the lru list of the inode cache.",
+ .op_version = {1},
+ .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC},
+ {.key = {"verify-volfile-checksum"}, .type = GF_OPTION_TYPE_BOOL},
+ {.key = {"trace"}, .type = GF_OPTION_TYPE_BOOL},
+ {
+ .key = {"config-directory", "conf-dir"},
+ .type = GF_OPTION_TYPE_PATH,
+ },
+ {.key = {"rpc-auth-allow-insecure", "allow-insecure"},
+ .type = GF_OPTION_TYPE_BOOL,
+ .default_value = "on",
+ .op_version = {1},
+ .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC},
+ {.key = {"root-squash"},
+ .type = GF_OPTION_TYPE_BOOL,
+ .default_value = "off",
+ .description = "Map requests from uid/gid 0 to the anonymous "
+ "uid/gid. Note that this does not apply to any other "
+ "uids or gids that might be equally sensitive, such "
+ "as user bin or group staff.",
+ .op_version = {2},
+ .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC},
+ {.key = {"anonuid"},
+ .type = GF_OPTION_TYPE_INT,
+ .default_value = "65534", /* RPC_NOBODY_UID */
+ .min = 0,
+ .max = (uint32_t)-1,
+ .description = "value of the uid used for the anonymous "
+ "user/nfsnobody when root-squash is enabled.",
+ .op_version = {3},
+ .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC},
+ {.key = {"anongid"},
+ .type = GF_OPTION_TYPE_INT,
+ .default_value = "65534", /* RPC_NOBODY_GID */
+ .min = 0,
+ .max = (uint32_t)-1,
+ .description = "value of the gid used for the anonymous "
+ "user/nfsnobody when root-squash is enabled.",
+ .op_version = {3},
+ .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC},
+ {.key = {"statedump-path"},
+ .type = GF_OPTION_TYPE_PATH,
+ .default_value = DEFAULT_VAR_RUN_DIRECTORY,
+ .description = "Specifies directory in which gluster should save its"
+ " statedumps.",
+ .op_version = {1},
+ .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC},
+ {.key = {"tcp-window-size"},
+ .type = GF_OPTION_TYPE_SIZET,
+ .min = GF_MIN_SOCKET_WINDOW_SIZE,
+ .max = GF_MAX_SOCKET_WINDOW_SIZE,
+ .description = "Specifies the window size for tcp socket.",
+ .op_version = {1},
+ .flags = OPT_FLAG_SETTABLE},
+
+ /* The following two options are defined in addr.c, redifined here *
+ * for the sake of validation during volume set from cli */
+
+ {.key = {"auth.addr.*.allow", "auth.allow"},
+ .setkey = "auth.addr.{{ brick.path }}.allow",
+ .default_value = "*",
+ .type = GF_OPTION_TYPE_INTERNET_ADDRESS_LIST,
+ .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
+ .description = "Allow a comma separated list of addresses and/or "
+ "hostnames to connect to the server. Option "
+ "auth.reject overrides this option. By default, all "
+ "connections are allowed."},
+ {.key = {"auth.addr.*.reject", "auth.reject"},
+ .setkey = "auth.addr.{{ brick.path }}.reject",
+ .type = GF_OPTION_TYPE_INTERNET_ADDRESS_LIST,
+ .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
+ .description = "Reject a comma separated list of addresses and/or "
+ "hostnames to connect to the server. This option "
+ "overrides the auth.allow option. By default, all"
+ " connections are allowed."},
+ {.key = {"ssl-allow"},
+ .setkey = "auth.login.{{ brick.path }}.ssl-allow",
+ .default_value = "*",
+ .type = GF_OPTION_TYPE_INTERNET_ADDRESS_LIST,
+ .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC,
+ .description = "Allow a comma separated list of common names (CN) of"
+ "the clients that are allowed to access the server."
+ "By default, all TLS authenticated clients are"
+ "allowed to access the server."},
+ /* This is not a valid path w.r.t daemons, hence it's string */
+ {.key = {"auth-path"},
+ .type = GF_OPTION_TYPE_STR,
+ .default_value = "{{ brick.path }}"},
+ {.key = {"rpc.outstanding-rpc-limit"},
+ .type = GF_OPTION_TYPE_INT,
+ .min = RPCSVC_MIN_OUTSTANDING_RPC_LIMIT,
+ .max = RPCSVC_MAX_OUTSTANDING_RPC_LIMIT,
+ .default_value = TOSTRING(RPCSVC_DEFAULT_OUTSTANDING_RPC_LIMIT),
+ .description = "Parameter to throttle the number of incoming RPC "
+ "requests from a client. 0 means no limit (can "
+ "potentially run out of memory)",
+ .op_version = {1},
+ .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC | OPT_FLAG_GLOBAL},
+ {.key = {"manage-gids"},
+ .type = GF_OPTION_TYPE_BOOL,
+ .default_value = "off",
+ .description = "Resolve groups on the server-side.",
+ .op_version = {GD_OP_VERSION_3_6_0},
+ .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC},
+ {.key = {"gid-timeout"},
+ .type = GF_OPTION_TYPE_INT,
+ .default_value = "300",
+ .description = "Timeout in seconds for the cached groups to expire.",
+ .op_version = {GD_OP_VERSION_3_6_0},
+ .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC},
+ {.key = {"event-threads"},
+ .type = GF_OPTION_TYPE_INT,
+ .min = 1,
+ .max = 1024,
+ .default_value = "1",
+ .description = "Specifies the number of event threads to execute "
+ "in parallel. Larger values would help process"
+ " responses faster, depending on available processing"
+ " power.",
+ .op_version = {GD_OP_VERSION_3_7_0},
+ .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC},
+ {.key = {"dynamic-auth"},
+ .type = GF_OPTION_TYPE_BOOL,
+ .default_value = "on",
+ .description = "When 'on' perform dynamic authentication of volume "
+ "options in order to allow/terminate client "
+ "transport connection immediately in response to "
+ "*.allow | *.reject volume set options.",
+ .op_version = {GD_OP_VERSION_3_7_5},
+ .flags = OPT_FLAG_SETTABLE | OPT_FLAG_DOC},
+ {.key = {"strict-auth-accept"},
+ .type = GF_OPTION_TYPE_BOOL,
+ .default_value = "off",
+ .description = "strict-auth-accept reject connection with out"
+ "a valid username and password."},
+ {.key = {NULL}},
};
-
xlator_api_t xlator_api = {
- .init = server_init,
- .fini = server_fini,
- .notify = server_notify,
- .reconfigure = server_reconfigure,
- .mem_acct_init = server_mem_acct_init,
- .dump_metrics = server_dump_metrics,
- .op_version = {1}, /* Present from the initial version */
- .dumpops = &server_dumpops,
- .fops = &server_fops,
- .cbks = &server_cbks,
- .options = server_options,
- .identifier = "server",
- .category = GF_MAINTAINED,
+ .init = server_init,
+ .fini = server_fini,
+ .notify = server_notify,
+ .reconfigure = server_reconfigure,
+ .mem_acct_init = server_mem_acct_init,
+ .dump_metrics = server_dump_metrics,
+ .op_version = {1}, /* Present from the initial version */
+ .dumpops = &server_dumpops,
+ .fops = &server_fops,
+ .cbks = &server_cbks,
+ .options = server_options,
+ .identifier = "server",
+ .category = GF_MAINTAINED,
};