diff options
Diffstat (limited to 'xlators/protocol/server/src')
| -rw-r--r-- | xlators/protocol/server/src/authenticate.c | 327 | ||||
| -rw-r--r-- | xlators/protocol/server/src/server-common.c | 1166 | ||||
| -rw-r--r-- | xlators/protocol/server/src/server-handshake.c | 1730 | ||||
| -rw-r--r-- | xlators/protocol/server/src/server-helpers.c | 9811 | ||||
| -rw-r--r-- | xlators/protocol/server/src/server-resolve.c | 955 | ||||
| -rw-r--r-- | xlators/protocol/server/src/server-rpc-fops.c | 8890 | ||||
| -rw-r--r-- | xlators/protocol/server/src/server-rpc-fops_v2.c | 8434 | ||||
| -rw-r--r-- | xlators/protocol/server/src/server.c | 3086 |
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, ¶ms); - 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, ¶ms); + 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, }; |