summaryrefslogtreecommitdiffstats
path: root/xlators/protocol/server
diff options
context:
space:
mode:
Diffstat (limited to 'xlators/protocol/server')
-rw-r--r--xlators/protocol/server/src/Makefile.am6
-rw-r--r--xlators/protocol/server/src/server-handshake.c101
-rw-r--r--xlators/protocol/server/src/server-helpers.c1134
-rw-r--r--xlators/protocol/server/src/server-helpers.h55
-rw-r--r--xlators/protocol/server/src/server-resolve.c33
-rw-r--r--xlators/protocol/server/src/server-rpc-fops.c1713
-rw-r--r--xlators/protocol/server/src/server.c595
-rw-r--r--xlators/protocol/server/src/server.h108
8 files changed, 1767 insertions, 1978 deletions
diff --git a/xlators/protocol/server/src/Makefile.am b/xlators/protocol/server/src/Makefile.am
index 25d6706cc..6a18bf025 100644
--- a/xlators/protocol/server/src/Makefile.am
+++ b/xlators/protocol/server/src/Makefile.am
@@ -16,9 +16,9 @@ AM_CPPFLAGS = $(GF_CPPFLAGS) \
-I$(top_srcdir)/libglusterfs/src \
-DCONFDIR=\"$(sysconfdir)/glusterfs\" \
-DLIBDIR=\"$(libdir)/glusterfs/$(PACKAGE_VERSION)/auth\" \
- -I$(top_srcdir)/xlators/protocol/lib/src \
- -I$(top_srcdir)/rpc/rpc-lib/src/ \
- -I$(top_srcdir)/rpc/xdr/src/
+ -I$(top_srcdir)/xlators/protocol/lib/src \
+ -I$(top_srcdir)/rpc/rpc-lib/src \
+ -I$(top_srcdir)/rpc/xdr/src
AM_CFLAGS = -Wall $(GF_CFLAGS) \
-DDATADIR=\"$(localstatedir)\"
diff --git a/xlators/protocol/server/src/server-handshake.c b/xlators/protocol/server/src/server-handshake.c
index 8886221aa..d4941011d 100644
--- a/xlators/protocol/server/src/server-handshake.c
+++ b/xlators/protocol/server/src/server-handshake.c
@@ -94,9 +94,9 @@ _volfile_update_checksum (xlator_t *this, char *key, uint32_t checksum)
if (temp_volfile->checksum != checksum) {
gf_log (this->name, GF_LOG_INFO,
- "the volume file got modified between earlier access "
- "and now, this may lead to inconsistency between "
- "clients, advised to remount client");
+ "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;
}
@@ -109,10 +109,10 @@ static size_t
getspec_build_volfile_path (xlator_t *this, const char *key, char *path,
size_t path_len)
{
- int ret = -1;
+ char *filename = NULL;
+ server_conf_t *conf = NULL;
+ int ret = -1;
int free_filename = 0;
- char *filename = NULL;
- server_conf_t *conf = NULL;
char data_key[256] = {0,};
conf = this->private;
@@ -329,14 +329,15 @@ server_setvolume (rpcsvc_request_t *req)
{
gf_setvolume_req args = {{0,},};
gf_setvolume_rsp rsp = {0,};
- server_connection_t *conn = 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 *process_uuid = NULL;
+ char *client_uid = NULL;
char *clnt_version = NULL;
xlator_t *xl = NULL;
char *msg = NULL;
@@ -393,7 +394,7 @@ server_setvolume (rpcsvc_request_t *req)
params->extra_free = buf;
buf = NULL;
- ret = dict_get_str (params, "process-uuid", &process_uuid);
+ ret = dict_get_str (params, "process-uuid", &client_uid);
if (ret < 0) {
ret = dict_set_str (reply, "ERROR",
"UUID not specified");
@@ -420,25 +421,32 @@ server_setvolume (rpcsvc_request_t *req)
goto fail;
}
- conn = server_connection_get (this, process_uuid);
- if (!conn) {
+ client = gf_client_get (this, &req->cred, client_uid);
+ if (client == NULL) {
op_ret = -1;
op_errno = ENOMEM;
goto fail;
}
- gf_log (this->name, GF_LOG_DEBUG, "Connected to %s", conn->id);
- cancelled = server_cancel_conn_timer (this, conn);
- if (cancelled)//Do connection_put on behalf of grace-timer-handler.
- server_connection_put (this, conn, NULL);
- if (conn->lk_version != 0 &&
- conn->lk_version != lk_version) {
- (void) server_connection_cleanup (this, conn,
+ gf_log (this->name, GF_LOG_DEBUG, "Connected to %s", client->client_uid);
+ cancelled = server_cancel_grace_timer (this, client);
+ if (cancelled)//Do gf_client_put on behalf of grace-timer-handler.
+ gf_client_put (client, NULL);
+
+ serv_ctx = server_ctx_get (client, client->this);
+ if (serv_ctx == NULL) {
+ gf_log (this->name, GF_LOG_INFO, "server_ctx_get() failed");
+ goto fail;
+ }
+
+ if (serv_ctx->lk_version != 0 &&
+ serv_ctx->lk_version != lk_version) {
+ (void) server_connection_cleanup (this, client,
INTERNAL_LOCKS | POSIX_LOCKS);
}
- if (req->trans->xl_private != conn)
- req->trans->xl_private = conn;
+ if (req->trans->xl_private != client)
+ req->trans->xl_private = client;
ret = dict_get_int32 (params, "fops-version", &fop_version);
if (ret < 0) {
@@ -563,10 +571,10 @@ server_setvolume (rpcsvc_request_t *req)
gf_log (this->name, GF_LOG_INFO,
"accepted client from %s (version: %s)",
- conn->id,
+ client->client_uid,
(clnt_version) ? clnt_version : "old");
op_ret = 0;
- conn->bound_xl = xl;
+ client->bound_xl = xl;
ret = dict_set_str (reply, "ERROR", "Success");
if (ret < 0)
gf_log (this->name, GF_LOG_DEBUG,
@@ -574,7 +582,7 @@ server_setvolume (rpcsvc_request_t *req)
} else {
gf_log (this->name, GF_LOG_ERROR,
"Cannot authenticate client from %s %s",
- conn->id,
+ client->client_uid,
(clnt_version) ? clnt_version : "old");
op_ret = -1;
@@ -586,7 +594,7 @@ server_setvolume (rpcsvc_request_t *req)
goto fail;
}
- if (conn->bound_xl == NULL) {
+ if (client->bound_xl == NULL) {
ret = dict_set_str (reply, "ERROR",
"Check volfile and handshake "
"options in protocol/client");
@@ -599,20 +607,21 @@ server_setvolume (rpcsvc_request_t *req)
goto fail;
}
- if ((conn->bound_xl != NULL) &&
+ if ((client->bound_xl != NULL) &&
(ret >= 0) &&
- (conn->bound_xl->itable == NULL)) {
+ (client->bound_xl->itable == NULL)) {
/* create inode table for this bound_xl, if one doesn't
already exist */
gf_log (this->name, GF_LOG_TRACE,
"creating inode table with lru_limit=%"PRId32", "
"xlator=%s", conf->inode_lru_limit,
- conn->bound_xl->name);
+ client->bound_xl->name);
/* TODO: what is this ? */
- conn->bound_xl->itable = inode_table_new (conf->inode_lru_limit,
- conn->bound_xl);
+ client->bound_xl->itable =
+ inode_table_new (conf->inode_lru_limit,
+ client->bound_xl);
}
ret = dict_set_str (reply, "process-uuid",
@@ -621,8 +630,7 @@ server_setvolume (rpcsvc_request_t *req)
gf_log (this->name, GF_LOG_DEBUG,
"failed to set 'process-uuid'");
- ret = dict_set_uint32 (reply, "clnt-lk-version",
- conn->lk_version);
+ ret = dict_set_uint32 (reply, "clnt-lk-version", serv_ctx->lk_version);
if (ret)
gf_log (this->name, GF_LOG_WARNING,
"failed to set 'clnt-lk-version'");
@@ -664,15 +672,15 @@ fail:
* list of connections the server is maintaining and might segfault
* during statedump when bound_xl of the connection is accessed.
*/
- if (op_ret && conn && !xl) {
+ if (op_ret && !xl) {
/* 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.
*/
- if (server_connection_put (this, conn, NULL) == NULL)
- req->trans->xl_private = NULL;
+ gf_client_put (client, NULL);
+ req->trans->xl_private = NULL;
}
server_submit_reply (NULL, req, &rsp, NULL, 0, NULL,
(xdrproc_t)xdr_gf_setvolume_rsp);
@@ -709,12 +717,13 @@ server_ping (rpcsvc_request_t *req)
int
server_set_lk_version (rpcsvc_request_t *req)
{
- int op_ret = -1;
- int op_errno = EINVAL;
- gf_set_lk_ver_req args = {0, };
- gf_set_lk_ver_rsp rsp = {0,};
- server_connection_t *conn = NULL;
- xlator_t *this = NULL;
+ int op_ret = -1;
+ int op_errno = EINVAL;
+ gf_set_lk_ver_req args = {0,};
+ gf_set_lk_ver_rsp rsp = {0,};
+ client_t *client = NULL;
+ server_ctx_t *serv_ctx = NULL;
+ xlator_t *this = NULL;
this = req->svc->mydata;
//TODO: Decide on an appropriate errno for the error-path
@@ -730,9 +739,15 @@ server_set_lk_version (rpcsvc_request_t *req)
goto fail;
}
- conn = server_connection_get (this, args.uid);
- conn->lk_version = args.lk_ver;
- server_connection_put (this, conn, NULL);
+ client = gf_client_get (this, &req->cred, args.uid);
+ serv_ctx = server_ctx_get (client, client->this);
+ if (serv_ctx == NULL) {
+ gf_log (this->name, GF_LOG_INFO, "server_ctx_get() failed");
+ goto fail;
+ }
+
+ serv_ctx->lk_version = args.lk_ver;
+ gf_client_put (client, NULL);
rsp.lk_ver = args.lk_ver;
diff --git a/xlators/protocol/server/src/server-helpers.c b/xlators/protocol/server/src/server-helpers.c
index c8d425056..f0b040c74 100644
--- a/xlators/protocol/server/src/server-helpers.c
+++ b/xlators/protocol/server/src/server-helpers.c
@@ -26,6 +26,9 @@ server_decode_groups (call_frame_t *frame, rpcsvc_request_t *req)
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;
+
frame->root->ngrps = req->auxgidcount;
if (frame->root->ngrps == 0)
return 0;
@@ -39,6 +42,7 @@ out:
return 0;
}
+
void
server_loc_wipe (loc_t *loc)
{
@@ -70,11 +74,6 @@ server_resolve_wipe (server_resolve_t *resolve)
void
free_state (server_state_t *state)
{
- if (state->conn) {
- //xprt_svc_unref (state->conn);
- state->conn = NULL;
- }
-
if (state->xprt) {
rpc_transport_unref (state->xprt);
state->xprt = NULL;
@@ -123,280 +122,26 @@ free_state (server_state_t *state)
}
-int
-gf_add_locker (server_connection_t *conn, const char *volume,
- loc_t *loc, fd_t *fd, pid_t pid, gf_lkowner_t *owner,
- glusterfs_fop_t type)
-{
- int32_t ret = -1;
- struct _locker *new = NULL;
- struct _lock_table *table = NULL;
-
- GF_VALIDATE_OR_GOTO ("server", volume, out);
-
- new = GF_CALLOC (1, sizeof (struct _locker), gf_server_mt_locker_t);
- if (new == NULL) {
- goto out;
- }
- INIT_LIST_HEAD (&new->lockers);
-
- new->volume = gf_strdup (volume);
-
- if (fd == NULL) {
- loc_copy (&new->loc, loc);
- } else {
- new->fd = fd_ref (fd);
- }
-
- new->pid = pid;
- new->owner = *owner;
-
- pthread_mutex_lock (&conn->lock);
- {
- table = conn->ltable;
- if (type == GF_FOP_ENTRYLK)
- list_add_tail (&new->lockers, &table->entrylk_lockers);
- else
- list_add_tail (&new->lockers, &table->inodelk_lockers);
- }
- pthread_mutex_unlock (&conn->lock);
-out:
- return ret;
-}
-
-
-int
-gf_del_locker (server_connection_t *conn, const char *volume,
- loc_t *loc, fd_t *fd, gf_lkowner_t *owner,
- glusterfs_fop_t type)
-{
- struct _locker *locker = NULL;
- struct _locker *tmp = NULL;
- int32_t ret = -1;
- struct list_head *head = NULL;
- struct _lock_table *table = NULL;
- int found = 0;
-
- GF_VALIDATE_OR_GOTO ("server", volume, out);
-
- pthread_mutex_lock (&conn->lock);
- {
- table = conn->ltable;
- if (type == GF_FOP_ENTRYLK) {
- head = &table->entrylk_lockers;
- } else {
- head = &table->inodelk_lockers;
- }
-
- list_for_each_entry_safe (locker, tmp, head, lockers) {
- if (!is_same_lkowner (&locker->owner, owner) ||
- strcmp (locker->volume, volume))
- continue;
-
- if (locker->fd && fd && (locker->fd == fd))
- found = 1;
- else if (locker->loc.inode && loc &&
- (locker->loc.inode == loc->inode))
- found = 1;
- if (found) {
- list_del_init (&locker->lockers);
- break;
- }
- }
- if (!found)
- locker = NULL;
- }
- pthread_mutex_unlock (&conn->lock);
-
- if (locker) {
- if (locker->fd)
- fd_unref (locker->fd);
- else
- loc_wipe (&locker->loc);
-
- GF_FREE (locker->volume);
- GF_FREE (locker);
- }
-
- ret = 0;
-out:
- return ret;
-}
-
-static struct _lock_table *
-gf_lock_table_new (void)
-{
- struct _lock_table *new = NULL;
-
- new = GF_CALLOC (1, sizeof (struct _lock_table), gf_server_mt_lock_table_t);
- if (new == NULL) {
- goto out;
- }
- INIT_LIST_HEAD (&new->entrylk_lockers);
- INIT_LIST_HEAD (&new->inodelk_lockers);
-out:
- return new;
-}
-
-static int
-server_nop_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
- int32_t op_ret, int32_t op_errno, dict_t *xdata)
-{
- int ret = -1;
- server_state_t *state = NULL;
-
- GF_VALIDATE_OR_GOTO ("server", frame, out);
- GF_VALIDATE_OR_GOTO ("server", cookie, out);
- GF_VALIDATE_OR_GOTO ("server", this, out);
-
- if (frame->root->trans)
- server_conn_unref (frame->root->trans);
- state = CALL_STATE(frame);
-
- if (state)
- free_state (state);
- STACK_DESTROY (frame->root);
-
- ret = 0;
-out:
- return ret;
-}
-
-int
-do_lock_table_cleanup (xlator_t *this, server_connection_t *conn,
- call_frame_t *frame, struct _lock_table *ltable)
-{
- struct list_head inodelk_lockers, entrylk_lockers;
- call_frame_t *tmp_frame = NULL;
- struct gf_flock flock = {0, };
- xlator_t *bound_xl = NULL;
- struct _locker *locker = NULL, *tmp = NULL;
- int ret = -1;
-
- GF_VALIDATE_OR_GOTO ("server", this, out);
- GF_VALIDATE_OR_GOTO ("server", conn, out);
- GF_VALIDATE_OR_GOTO ("server", frame, out);
- GF_VALIDATE_OR_GOTO ("server", ltable, out);
-
- bound_xl = conn->bound_xl;
- INIT_LIST_HEAD (&inodelk_lockers);
- INIT_LIST_HEAD (&entrylk_lockers);
-
- list_splice_init (&ltable->inodelk_lockers,
- &inodelk_lockers);
-
- list_splice_init (&ltable->entrylk_lockers, &entrylk_lockers);
- GF_FREE (ltable);
-
- flock.l_type = F_UNLCK;
- flock.l_start = 0;
- flock.l_len = 0;
- list_for_each_entry_safe (locker,
- tmp, &inodelk_lockers, lockers) {
- tmp_frame = copy_frame (frame);
- if (tmp_frame == NULL) {
- goto out;
- }
- /*
- lock owner = 0 is a special case that tells posix-locks
- to release all locks from this transport
- */
- tmp_frame->root->pid = 0;
- tmp_frame->root->trans = server_conn_ref (conn);
- memset (&tmp_frame->root->lk_owner, 0, sizeof (gf_lkowner_t));
-
- if (locker->fd) {
- gf_log (this->name, GF_LOG_DEBUG, "finodelk "
- "released on inode with gfid %s",
- uuid_utoa (locker->fd->inode->gfid));
-
- STACK_WIND (tmp_frame, server_nop_cbk, bound_xl,
- bound_xl->fops->finodelk,
- locker->volume,
- locker->fd, F_SETLK, &flock, NULL);
- fd_unref (locker->fd);
- } else {
- gf_log (this->name, GF_LOG_DEBUG, "inodelk released "
- "on %s", locker->loc.path);
-
- STACK_WIND (tmp_frame, server_nop_cbk, bound_xl,
- bound_xl->fops->inodelk,
- locker->volume,
- &(locker->loc), F_SETLK, &flock, NULL);
- loc_wipe (&locker->loc);
- }
-
- GF_FREE (locker->volume);
-
- list_del_init (&locker->lockers);
- GF_FREE (locker);
- }
-
- tmp = NULL;
- locker = NULL;
- list_for_each_entry_safe (locker, tmp, &entrylk_lockers, lockers) {
- tmp_frame = copy_frame (frame);
-
- tmp_frame->root->pid = 0;
- tmp_frame->root->trans = server_conn_ref (conn);
- memset (&tmp_frame->root->lk_owner, 0, sizeof (gf_lkowner_t));
-
- if (locker->fd) {
- GF_ASSERT (locker->fd->inode);
-
- gf_log (this->name, GF_LOG_DEBUG, "fentrylk "
- "released on inode with gfid %s",
- uuid_utoa (locker->fd->inode->gfid));
-
- STACK_WIND (tmp_frame, server_nop_cbk, bound_xl,
- bound_xl->fops->fentrylk,
- locker->volume,
- locker->fd, NULL,
- ENTRYLK_UNLOCK, ENTRYLK_WRLCK, NULL);
- fd_unref (locker->fd);
- } else {
- gf_log (this->name, GF_LOG_DEBUG, "entrylk released "
- "on %s", locker->loc.path);
-
- STACK_WIND (tmp_frame, server_nop_cbk, bound_xl,
- bound_xl->fops->entrylk,
- locker->volume,
- &(locker->loc), NULL,
- ENTRYLK_UNLOCK, ENTRYLK_WRLCK, NULL);
- loc_wipe (&locker->loc);
- }
-
- GF_FREE (locker->volume);
-
- list_del_init (&locker->lockers);
- GF_FREE (locker);
- }
- ret = 0;
-
-out:
- return ret;
-}
-
-
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)
{
- int32_t ret = -1;
- fd_t *fd = 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", cookie, out);
GF_VALIDATE_OR_GOTO ("server", frame, out);
fd = frame->local;
+ client = frame->root->client;
fd_unref (fd);
frame->local = NULL;
- if (frame->root->trans)
- server_conn_unref (frame->root->trans);
+ gf_client_unref (client);
STACK_DESTROY (frame->root);
ret = 0;
@@ -405,9 +150,8 @@ out:
}
-int
-do_fd_cleanup (xlator_t *this, server_connection_t *conn, call_frame_t *frame,
- fdentry_t *fdentries, int fd_count)
+static int
+do_fd_cleanup (xlator_t *this, client_t* client, fdentry_t *fdentries, int fd_count)
{
fd_t *fd = NULL;
int i = 0, ret = -1;
@@ -416,16 +160,14 @@ do_fd_cleanup (xlator_t *this, server_connection_t *conn, call_frame_t *frame,
char *path = NULL;
GF_VALIDATE_OR_GOTO ("server", this, out);
- GF_VALIDATE_OR_GOTO ("server", conn, out);
- GF_VALIDATE_OR_GOTO ("server", frame, out);
GF_VALIDATE_OR_GOTO ("server", fdentries, out);
- bound_xl = conn->bound_xl;
+ bound_xl = client->bound_xl;
for (i = 0;i < fd_count; i++) {
fd = fdentries[i].fd;
if (fd != NULL) {
- tmp_frame = copy_frame (frame);
+ tmp_frame = create_frame (this, this->ctx->pool);
if (tmp_frame == NULL) {
goto out;
}
@@ -435,20 +177,20 @@ do_fd_cleanup (xlator_t *this, server_connection_t *conn, call_frame_t *frame,
ret = inode_path (fd->inode, NULL, &path);
if (ret > 0) {
- gf_log (this->name, GF_LOG_INFO, "fd cleanup on "
- "%s", path);
+ gf_log (this->name, GF_LOG_INFO,
+ "fd cleanup on %s", path);
GF_FREE (path);
} else {
- gf_log (this->name, GF_LOG_INFO, "fd cleanup on"
- " inode with gfid %s",
+ gf_log (this->name, GF_LOG_INFO,
+ "fd cleanup on inode with gfid %s",
uuid_utoa (fd->inode->gfid));
}
tmp_frame->local = fd;
tmp_frame->root->pid = 0;
- tmp_frame->root->trans = server_conn_ref (conn);
+ gf_client_ref (client);
memset (&tmp_frame->root->lk_owner, 0,
sizeof (gf_lkowner_t));
@@ -465,312 +207,72 @@ out:
return ret;
}
-int
-do_connection_cleanup (xlator_t *this, server_connection_t *conn,
- struct _lock_table *ltable, fdentry_t *fdentries, int fd_count)
-{
- int ret = 0;
- int saved_ret = 0;
- call_frame_t *frame = NULL;
- server_state_t *state = NULL;
-
- GF_VALIDATE_OR_GOTO ("server", this, out);
- GF_VALIDATE_OR_GOTO ("server", conn, out);
-
- if (!ltable && !fdentries)
- goto out;
-
- frame = create_frame (this, this->ctx->pool);
- if (frame == NULL) {
- goto out;
- }
-
- if (ltable)
- saved_ret = do_lock_table_cleanup (this, conn, frame, ltable);
-
- if (fdentries != NULL) {
- ret = do_fd_cleanup (this, conn, frame, fdentries, fd_count);
- }
-
- state = CALL_STATE (frame);
- GF_FREE (state);
-
- STACK_DESTROY (frame->root);
-
- if (saved_ret || ret) {
- ret = -1;
- }
-
-out:
- return ret;
-}
int
-server_connection_cleanup (xlator_t *this, server_connection_t *conn,
+server_connection_cleanup (xlator_t *this, client_t *client,
int32_t flags)
{
- struct _lock_table *ltable = NULL;
- fdentry_t *fdentries = NULL;
- uint32_t fd_count = 0;
- int ret = 0;
+ 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 (this->name, this, out);
- GF_VALIDATE_OR_GOTO (this->name, conn, out);
+ GF_VALIDATE_OR_GOTO (this->name, client, out);
GF_VALIDATE_OR_GOTO (this->name, flags, out);
- pthread_mutex_lock (&conn->lock);
- {
- if (conn->ltable && (flags & INTERNAL_LOCKS)) {
- ltable = conn->ltable;
- conn->ltable = gf_lock_table_new ();
- }
-
- if (conn->fdtable && (flags & POSIX_LOCKS))
- fdentries = gf_fd_fdtable_get_all_fds (conn->fdtable,
- &fd_count);
- }
- pthread_mutex_unlock (&conn->lock);
-
- if (conn->bound_xl)
- ret = do_connection_cleanup (this, conn, ltable,
- fdentries, fd_count);
+ serv_ctx = server_ctx_get (client, client->this);
-out:
- return ret;
-}
-
-void
-server_log_conn_destroy (server_connection_t *conn)
-{
- int i = 0;
- char *rsp_failures_msg = NULL;
- char *free_ptr = NULL;
- char *msg = NULL;
- char *failed_to_rsp = "";
- char *sep1 = " - ";
- char *sep2 = ", ";
- int msg_len = 0;
-
- for (i = GF_FOP_NULL + 1; i < GF_FOP_MAXVALUE; i++) {
- msg_len += strlen (gf_fop_list[i]);
- msg_len += 20; //Max len of uint64_t is 20
- //Separators for fop-string, count
- msg_len += strlen (sep1) + strlen (sep2);
- }
-
- rsp_failures_msg = GF_CALLOC (msg_len + 1, 1, gf_common_mt_char);
- if (rsp_failures_msg == NULL) {
- rsp_failures_msg = "";
+ if (serv_ctx == NULL) {
+ gf_log (this->name, GF_LOG_INFO, "server_ctx_get() failed");
goto out;
- } else {
- free_ptr = rsp_failures_msg;
- }
-
- msg = rsp_failures_msg;
- for (i = GF_FOP_NULL + 1; i < GF_FOP_MAXVALUE; i++) {
- if (!conn->rsp_failure_fops[i])
- continue;
- //Note: Please make sure the size is calculated appropriately
- //if you plan to change the format string.
- msg += sprintf (msg, "%s%s%"PRIu64"%s", gf_fop_list[i], sep1,
- conn->rsp_failure_fops[i], sep2);
- }
- if (rsp_failures_msg[0]) {
- failed_to_rsp = " - Failed to respond to following operations:";
- //Remove last comma
- rsp_failures_msg[strlen (rsp_failures_msg) - 2] = '\0';
- }
-out:
- gf_log (conn->this->name, GF_LOG_INFO, "destroyed connection of "
- "%s %s %s", conn->id, failed_to_rsp, rsp_failures_msg);
- GF_FREE (free_ptr);
-}
-
-int
-server_connection_destroy (xlator_t *this, server_connection_t *conn)
-{
- xlator_t *bound_xl = NULL;
- int32_t ret = -1;
- struct list_head inodelk_lockers;
- struct list_head entrylk_lockers;
- struct _lock_table *ltable = NULL;
- fdtable_t *fdtable = NULL;
-
- GF_VALIDATE_OR_GOTO ("server", this, out);
- GF_VALIDATE_OR_GOTO ("server", conn, out);
-
- bound_xl = (xlator_t *) (conn->bound_xl);
-
- if (bound_xl) {
- pthread_mutex_lock (&(conn->lock));
- {
- if (conn->ltable) {
- ltable = conn->ltable;
- conn->ltable = NULL;
- }
- if (conn->fdtable) {
- fdtable = conn->fdtable;
- conn->fdtable = NULL;
- }
- }
- pthread_mutex_unlock (&conn->lock);
-
- INIT_LIST_HEAD (&inodelk_lockers);
- INIT_LIST_HEAD (&entrylk_lockers);
-
- if (ltable) {
- list_splice_init (&ltable->inodelk_lockers,
- &inodelk_lockers);
-
- list_splice_init (&ltable->entrylk_lockers,
- &entrylk_lockers);
- GF_FREE (ltable);
- }
-
- GF_ASSERT (list_empty (&inodelk_lockers));
- GF_ASSERT (list_empty (&entrylk_lockers));
-
- if (fdtable)
- gf_fd_fdtable_destroy (fdtable);
}
- server_log_conn_destroy (conn);
-
- pthread_mutex_destroy (&conn->lock);
- GF_FREE (conn->id);
- GF_FREE (conn);
- ret = 0;
-out:
- return ret;
-}
-
-server_connection_t*
-server_conn_unref (server_connection_t *conn)
-{
- server_connection_t *todel = NULL;
- xlator_t *this = NULL;
-
- pthread_mutex_lock (&conn->lock);
+ LOCK (&serv_ctx->fdtable_lock);
{
- conn->ref--;
-
- if (!conn->ref) {
- todel = conn;
- }
+ if (serv_ctx->fdtable && (flags & POSIX_LOCKS))
+ fdentries = gf_fd_fdtable_get_all_fds (serv_ctx->fdtable,
+ &fd_count);
}
- pthread_mutex_unlock (&conn->lock);
+ UNLOCK (&serv_ctx->fdtable_lock);
- if (todel) {
- this = THIS;
- server_connection_destroy (this, todel);
- conn = NULL;
- }
- return conn;
-}
+ if (client->bound_xl == NULL)
+ goto out;
-server_connection_t*
-server_conn_ref (server_connection_t *conn)
-{
- pthread_mutex_lock (&conn->lock);
- {
- conn->ref++;
+ if (flags & INTERNAL_LOCKS) {
+ cd_ret = gf_client_disconnect (client);
}
- pthread_mutex_unlock (&conn->lock);
- return conn;
-}
+ if (fdentries != NULL)
+ ret = do_fd_cleanup (this, client, fdentries, fd_count);
+ else
+ gf_log (this->name, GF_LOG_INFO, "no fdentries to clean");
-server_connection_t *
-server_connection_get (xlator_t *this, const char *id)
-{
- server_connection_t *conn = NULL;
- server_connection_t *trav = NULL;
- server_conf_t *conf = NULL;
-
- GF_VALIDATE_OR_GOTO ("server", this, out);
- GF_VALIDATE_OR_GOTO ("server", id, out);
-
- conf = this->private;
-
- pthread_mutex_lock (&conf->mutex);
- {
- list_for_each_entry (trav, &conf->conns, list) {
- if (!strcmp (trav->id, id)) {
- conn = trav;
- conn->bind_ref++;
- goto unlock;
- }
- }
-
- conn = (void *) GF_CALLOC (1, sizeof (*conn),
- gf_server_mt_conn_t);
- if (!conn)
- goto unlock;
-
- conn->id = gf_strdup (id);
- /*'0' denotes uninitialised lock state*/
- conn->lk_version = 0;
- conn->fdtable = gf_fd_fdtable_alloc ();
- conn->ltable = gf_lock_table_new ();
- conn->this = this;
- conn->bind_ref = 1;
- conn->ref = 1;//when bind_ref becomes 0 it calls conn_unref
- pthread_mutex_init (&conn->lock, NULL);
- list_add (&conn->list, &conf->conns);
+ if (cd_ret || ret)
+ ret = -1;
- }
-unlock:
- pthread_mutex_unlock (&conf->mutex);
out:
- return conn;
+ return ret;
}
-server_connection_t*
-server_connection_put (xlator_t *this, server_connection_t *conn,
- gf_boolean_t *detached)
-{
- server_conf_t *conf = NULL;
- gf_boolean_t unref = _gf_false;
-
- if (detached)
- *detached = _gf_false;
- conf = this->private;
- pthread_mutex_lock (&conf->mutex);
- {
- conn->bind_ref--;
- if (!conn->bind_ref) {
- list_del_init (&conn->list);
- unref = _gf_true;
- }
- }
- pthread_mutex_unlock (&conf->mutex);
- if (unref) {
- gf_log (this->name, GF_LOG_INFO, "Shutting down connection %s",
- conn->id);
- if (detached)
- *detached = _gf_true;
- server_conn_unref (conn);
- conn = NULL;
- }
- return conn;
-}
static call_frame_t *
server_alloc_frame (rpcsvc_request_t *req)
{
- call_frame_t *frame = NULL;
- server_state_t *state = NULL;
- server_connection_t *conn = 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);
- conn = (server_connection_t *)req->trans->xl_private;
- GF_VALIDATE_OR_GOTO ("server", conn, out);
+ client = req->trans->xl_private;
+ GF_VALIDATE_OR_GOTO ("server", client, out);
- frame = create_frame (conn->this, req->svc->ctx->pool);
+ frame = create_frame (client->this, req->svc->ctx->pool);
if (!frame)
goto out;
@@ -778,32 +280,33 @@ server_alloc_frame (rpcsvc_request_t *req)
if (!state)
goto out;
- if (conn->bound_xl)
- state->itable = conn->bound_xl->itable;
+ if (client->bound_xl)
+ state->itable = client->bound_xl->itable;
state->xprt = rpc_transport_ref (req->trans);
- state->conn = conn;
-
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->this = conn->this;
+ frame->this = client->this;
out:
return frame;
}
-
call_frame_t *
get_frame_from_request (rpcsvc_request_t *req)
{
- call_frame_t *frame = NULL;
+ call_frame_t *frame = NULL;
+ client_t *client = NULL;
GF_VALIDATE_OR_GOTO ("server", req, out);
+ client = req->trans->xl_private;
+
frame = server_alloc_frame (req);
if (!frame)
goto out;
@@ -815,7 +318,8 @@ get_frame_from_request (rpcsvc_request_t *req)
frame->root->uid = req->uid;
frame->root->gid = req->gid;
frame->root->pid = req->pid;
- frame->root->trans = server_conn_ref (req->trans->xl_private);
+ gf_client_ref (client);
+ frame->root->client = client;
frame->root->lk_owner = req->lk_owner;
server_decode_groups (frame, req);
@@ -900,84 +404,6 @@ out:
return ret;
}
-void
-put_server_conn_state (xlator_t *this, rpc_transport_t *xprt)
-{
- GF_VALIDATE_OR_GOTO ("server", this, out);
- GF_VALIDATE_OR_GOTO ("server", xprt, out);
-
- xprt->xl_private = NULL;
-out:
- return;
-}
-
-server_connection_t *
-get_server_conn_state (xlator_t *this, rpc_transport_t *xprt)
-{
- GF_VALIDATE_OR_GOTO ("server", this, out);
- GF_VALIDATE_OR_GOTO ("server", xprt, out);
-
- return (server_connection_t *)xprt->xl_private;
-out:
- return NULL;
-}
-
-server_connection_t *
-create_server_conn_state (xlator_t *this, rpc_transport_t *xprt)
-{
- server_connection_t *conn = NULL;
- int ret = -1;
-
- GF_VALIDATE_OR_GOTO ("server", this, out);
- GF_VALIDATE_OR_GOTO ("server", xprt, out);
-
- conn = GF_CALLOC (1, sizeof (*conn), gf_server_mt_conn_t);
- if (!conn)
- goto out;
-
- pthread_mutex_init (&conn->lock, NULL);
-
- conn->fdtable = gf_fd_fdtable_alloc ();
- if (!conn->fdtable)
- goto out;
-
- conn->ltable = gf_lock_table_new ();
- if (!conn->ltable)
- goto out;
-
- conn->this = this;
-
- xprt->xl_private = conn;
-
- ret = 0;
-out:
- if (ret)
- destroy_server_conn_state (conn);
-
- return conn;
-}
-
-void
-destroy_server_conn_state (server_connection_t *conn)
-{
- GF_VALIDATE_OR_GOTO ("server", conn, out);
-
- if (conn->ltable) {
- /* TODO */
- //FREE (conn->ltable);
- ;
- }
-
- if (conn->fdtable)
- gf_fd_fdtable_destroy (conn->fdtable);
-
- pthread_mutex_destroy (&conn->lock);
-
- GF_FREE (conn);
-out:
- return;
-}
-
void
print_caller (char *str, int size, call_frame_t *frame)
@@ -1104,12 +530,15 @@ server_print_params (char *str, int size, server_state_t *state)
filled += snprintf (str + filled, size - filled,
"volume=%s,", state->volume);
+/* FIXME
snprintf (str + filled, size - filled,
- "bound_xl=%s}", state->conn->bound_xl->name);
+ "bound_xl=%s}", state->client->bound_xl->name);
+*/
out:
return;
}
+
int
server_resolve_is_empty (server_resolve_t *resolve)
{
@@ -1125,6 +554,7 @@ server_resolve_is_empty (server_resolve_t *resolve)
return 1;
}
+
void
server_print_reply (call_frame_t *frame, int op_ret, int op_errno)
{
@@ -1170,16 +600,16 @@ out:
void
server_print_request (call_frame_t *frame)
{
- server_conf_t *conf = NULL;
- xlator_t *this = NULL;
+ 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];
- char *op = "UNKNOWN";
GF_VALIDATE_OR_GOTO ("server", frame, out);
@@ -1230,13 +660,14 @@ out:
return;
}
+
int
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;
+ gfs3_dirplist *trav = NULL;
+ gfs3_dirplist *prev = NULL;
+ int ret = -1;
GF_VALIDATE_OR_GOTO ("server", entries, out);
GF_VALIDATE_OR_GOTO ("server", rsp, out);
@@ -1304,10 +735,10 @@ out:
int
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_dirent_t *entry = NULL;
+ gfs3_dirlist *trav = NULL;
+ gfs3_dirlist *prev = NULL;
+ int ret = -1;
GF_VALIDATE_OR_GOTO ("server", entries, out);
GF_VALIDATE_OR_GOTO ("server", rsp, out);
@@ -1334,11 +765,12 @@ out:
return ret;
}
+
int
readdir_rsp_cleanup (gfs3_readdir_rsp *rsp)
{
- gfs3_dirlist *prev = NULL;
- gfs3_dirlist *trav = NULL;
+ gfs3_dirlist *prev = NULL;
+ gfs3_dirlist *trav = NULL;
trav = rsp->reply;
prev = trav;
@@ -1351,6 +783,7 @@ readdir_rsp_cleanup (gfs3_readdir_rsp *rsp)
return 0;
}
+
int
readdirp_rsp_cleanup (gfs3_readdirp_rsp *rsp)
{
@@ -1369,6 +802,7 @@ readdirp_rsp_cleanup (gfs3_readdirp_rsp *rsp)
return 0;
}
+
int
gf_server_check_getxattr_cmd (call_frame_t *frame, const char *key)
{
@@ -1397,13 +831,14 @@ gf_server_check_getxattr_cmd (call_frame_t *frame, const char *key)
return 0;
}
+
int
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;
+ server_conf_t *conf = NULL;
+ rpc_transport_t *xprt = NULL;
+ uint64_t total_read = 0;
uint64_t total_write = 0;
conf = frame->this->private;
@@ -1424,32 +859,403 @@ gf_server_check_setxattr_cmd (call_frame_t *frame, dict_t *dict)
return 0;
}
+
gf_boolean_t
-server_cancel_conn_timer (xlator_t *this, server_connection_t *conn)
+server_cancel_grace_timer (xlator_t *this, client_t *client)
{
- gf_timer_t *timer = NULL;
- gf_boolean_t cancelled = _gf_false;
+ server_ctx_t *serv_ctx = NULL;
+ gf_timer_t *timer = NULL;
+ gf_boolean_t cancelled = _gf_false;
- if (!this || !conn) {
- gf_log (THIS->name, GF_LOG_ERROR, "Invalid arguments to "
- "cancel connection timer");
+ if (!this || !client) {
+ gf_log (THIS->name, GF_LOG_ERROR,
+ "Invalid arguments to cancel connection timer");
return cancelled;
}
- pthread_mutex_lock (&conn->lock);
- {
- if (!conn->timer)
- goto unlock;
+ serv_ctx = server_ctx_get (client, client->this);
- timer = conn->timer;
- conn->timer = NULL;
+ if (serv_ctx == NULL) {
+ gf_log (this->name, GF_LOG_INFO, "server_ctx_get() failed");
+ goto out;
}
-unlock:
- pthread_mutex_unlock (&conn->lock);
+
+ LOCK (&serv_ctx->fdtable_lock);
+ {
+ if (serv_ctx->grace_timer) {
+ timer = serv_ctx->grace_timer;
+ serv_ctx->grace_timer = NULL;
+ }
+ }
+ UNLOCK (&serv_ctx->fdtable_lock);
if (timer) {
gf_timer_call_cancel (this->ctx, timer);
cancelled = _gf_true;
}
+out:
return cancelled;
}
+
+server_ctx_t*
+server_ctx_get (client_t *client, xlator_t *xlator)
+{
+ void *tmp = NULL;
+ server_ctx_t *ctx = NULL;
+
+ client_ctx_get (client, xlator, &tmp);
+
+ ctx = tmp;
+
+ if (ctx != NULL)
+ goto out;
+
+ ctx = GF_CALLOC (1, sizeof (server_ctx_t), gf_server_mt_server_conf_t);
+
+ if (ctx == NULL)
+ goto out;
+
+ /* ctx->lk_version = 0; redundant */
+ ctx->fdtable = gf_fd_fdtable_alloc ();
+
+ if (ctx->fdtable == NULL) {
+ GF_FREE (ctx);
+ ctx = NULL;
+ goto out;
+ }
+
+ LOCK_INIT (&ctx->fdtable_lock);
+
+ if (client_ctx_set (client, xlator, ctx) != 0) {
+ LOCK_DESTROY (&ctx->fdtable_lock);
+ GF_FREE (ctx);
+ ctx = NULL;
+ }
+
+out:
+ return ctx;
+}
+
+int32_t
+gf_barrier_transmit (server_conf_t *conf, gf_barrier_payload_t *payload)
+{
+ gf_barrier_t *barrier = NULL;
+ int32_t ret = -1;
+ client_t *client = NULL;
+ gf_boolean_t lk_heal = _gf_false;
+ call_frame_t *frame = NULL;
+ server_state_t *state = NULL;
+
+ GF_VALIDATE_OR_GOTO ("barrier", conf, out);
+ GF_VALIDATE_OR_GOTO ("barrier", conf->barrier, out);
+ GF_VALIDATE_OR_GOTO ("barrier", payload, out);
+
+ barrier = conf->barrier;
+
+ frame = payload->frame;
+ if (frame) {
+ state = CALL_STATE (frame);
+ frame->local = NULL;
+ client = frame->root->client;
+ }
+ /* currently lk fops are not barrier'ed. This is reflecting code in
+ * server_submit_reply */
+ if (client)
+ lk_heal = ((server_conf_t *) client->this->private)->lk_heal;
+
+ ret = rpcsvc_submit_generic (payload->req, &payload->rsp, 1,
+ payload->payload, payload->payload_count,
+ payload->iobref);
+ iobuf_unref (payload->iob);
+ if (ret == -1) {
+ gf_log_callingfn ("", GF_LOG_ERROR, "Reply submission failed");
+ if (frame && client && !lk_heal) {
+ server_connection_cleanup (frame->this, client,
+ INTERNAL_LOCKS | POSIX_LOCKS);
+ } else {
+ /* TODO: Failure of open(dir), create, inodelk, entrylk
+ or lk fops send failure must be handled specially. */
+ }
+ goto ret;
+ }
+
+ ret = 0;
+ret:
+ if (state) {
+ free_state (state);
+ }
+
+ if (frame) {
+ gf_client_unref (client);
+ STACK_DESTROY (frame->root);
+ }
+
+ if (payload->free_iobref) {
+ iobref_unref (payload->iobref);
+ }
+out:
+ return ret;
+}
+
+gf_barrier_payload_t *
+gf_barrier_dequeue (gf_barrier_t *barrier)
+{
+ gf_barrier_payload_t *payload = NULL;
+
+ if (!barrier || list_empty (&barrier->queue))
+ return NULL;
+
+ payload = list_entry (barrier->queue.next,
+ gf_barrier_payload_t, list);
+ if (payload) {
+ list_del_init (&payload->list);
+ barrier->cur_size--;
+ }
+
+ return payload;
+}
+
+
+void*
+gf_barrier_dequeue_start (void *data)
+{
+ server_conf_t *conf = NULL;
+ gf_barrier_t *barrier = NULL;
+ gf_barrier_payload_t *payload = NULL;
+
+ conf = (server_conf_t *)data;
+ if (!conf || !conf->barrier)
+ return NULL;
+ barrier = conf->barrier;
+
+ LOCK (&barrier->lock);
+ {
+ while (barrier->cur_size) {
+ payload = gf_barrier_dequeue (barrier);
+ if (payload) {
+ if (gf_barrier_transmit (conf, payload)) {
+ gf_log ("server", GF_LOG_WARNING,
+ "Failed to transmit");
+ }
+ GF_FREE (payload);
+ }
+ }
+ }
+ UNLOCK (&barrier->lock);
+ return NULL;
+}
+
+void
+gf_barrier_timeout (void *data)
+{
+ server_conf_t *conf = NULL;
+ gf_barrier_t *barrier = NULL;
+ gf_boolean_t need_dequeue = _gf_false;
+
+ conf = (server_conf_t *)data;
+ if (!conf || !conf->barrier)
+ goto out;
+ barrier = conf->barrier;
+
+ gf_log ("", GF_LOG_INFO, "barrier timed-out");
+ LOCK (&barrier->lock);
+ {
+ need_dequeue = barrier->on;
+ barrier->on = _gf_false;
+ }
+ UNLOCK (&barrier->lock);
+
+ if (need_dequeue == _gf_true)
+ gf_barrier_dequeue_start (data);
+out:
+ return;
+}
+
+
+int32_t
+gf_barrier_start (xlator_t *this)
+{
+ server_conf_t *conf = NULL;
+ gf_barrier_t *barrier = NULL;
+ int32_t ret = -1;
+ struct timespec time = {0,};
+
+ conf = this->private;
+
+ GF_VALIDATE_OR_GOTO ("server", this, out);
+ GF_VALIDATE_OR_GOTO (this->name, conf, out);
+ GF_VALIDATE_OR_GOTO (this->name, conf->barrier, out);
+
+ barrier = conf->barrier;
+
+ gf_log (this->name, GF_LOG_INFO, "barrier start called");
+ LOCK (&barrier->lock);
+ {
+ /* if barrier is on, reset timer */
+ if (barrier->on == _gf_true) {
+ ret = gf_timer_call_cancel (this->ctx, barrier->timer);
+ if (ret) {
+ gf_log (this->name, GF_LOG_ERROR, "Failed to "
+ "unset timer, failing barrier start");
+ goto unlock;
+ }
+ }
+
+ barrier->on = _gf_true;
+ time.tv_sec = barrier->time_out;
+ time.tv_nsec = 0;
+
+ barrier->timer = gf_timer_call_after (this->ctx, time,
+ gf_barrier_timeout,
+ (void *)conf);
+ if (!barrier->timer) {
+ gf_log (this->name, GF_LOG_ERROR, "Failed to set "
+ "timer, failing barrier start");
+ barrier->on = _gf_false;
+ }
+ }
+unlock:
+ UNLOCK (&barrier->lock);
+
+ ret = 0;
+out:
+ return ret;
+}
+
+int32_t
+gf_barrier_stop (xlator_t *this)
+{
+ server_conf_t *conf = NULL;
+ gf_barrier_t *barrier = NULL;
+ int32_t ret = -1;
+ gf_boolean_t need_dequeue = _gf_false;
+
+ conf = this->private;
+
+ GF_VALIDATE_OR_GOTO ("server", this, out);
+ GF_VALIDATE_OR_GOTO (this->name, conf, out);
+ GF_VALIDATE_OR_GOTO (this->name, conf->barrier, out);
+
+ barrier = conf->barrier;
+
+ gf_log (this->name, GF_LOG_INFO, "barrier stop called");
+ LOCK (&barrier->lock);
+ {
+ need_dequeue = barrier->on;
+ barrier->on = _gf_false;
+ }
+ UNLOCK (&barrier->lock);
+
+ if (need_dequeue == _gf_true) {
+ gf_timer_call_cancel (this->ctx, barrier->timer);
+ ret = gf_thread_create (&conf->barrier_th, NULL,
+ gf_barrier_dequeue_start,
+ conf);
+ if (ret) {
+ gf_log (this->name, GF_LOG_CRITICAL,
+ "Failed to start un-barriering");
+ goto out;
+ }
+ }
+ ret = 0;
+out:
+ return ret;
+}
+
+int32_t
+gf_barrier_fops_configure (xlator_t *this, gf_barrier_t *barrier, char *str)
+{
+ int32_t ret = -1;
+ char *dup_str = NULL;
+ char *str_tok = NULL;
+ char *save_ptr = NULL;
+ uint64_t fops = 0;
+
+ /* by defaul fsync & flush needs to be barriered */
+
+ fops |= 1 << GFS3_OP_FSYNC;
+ fops |= 1 << GFS3_OP_FLUSH;
+
+ if (!str)
+ goto done;
+
+ dup_str = gf_strdup (str);
+ if (!dup_str)
+ goto done;
+
+ str_tok = strtok_r (dup_str, ",", &save_ptr);
+ if (!str_tok)
+ goto done;
+
+ fops = 0;
+ while (str_tok) {
+ if (!strcmp(str_tok, "writev")) {
+ fops |= ((uint64_t)1 << GFS3_OP_WRITE);
+ } else if (!strcmp(str_tok, "fsync")) {
+ fops |= ((uint64_t)1 << GFS3_OP_FSYNC);
+ } else if (!strcmp(str_tok, "read")) {
+ fops |= ((uint64_t)1 << GFS3_OP_READ);
+ } else if (!strcmp(str_tok, "rename")) {
+ fops |= ((uint64_t)1 << GFS3_OP_RENAME);
+ } else if (!strcmp(str_tok, "flush")) {
+ fops |= ((uint64_t)1 << GFS3_OP_FLUSH);
+ } else if (!strcmp(str_tok, "ftruncate")) {
+ fops |= ((uint64_t)1 << GFS3_OP_FTRUNCATE);
+ } else if (!strcmp(str_tok, "fallocate")) {
+ fops |= ((uint64_t)1 << GFS3_OP_FALLOCATE);
+ } else if (!strcmp(str_tok, "rmdir")) {
+ fops |= ((uint64_t)1 << GFS3_OP_RMDIR);
+ } else {
+ gf_log ("barrier", GF_LOG_ERROR,
+ "Invalid barrier fop %s", str_tok);
+ }
+
+ str_tok = strtok_r (NULL, ",", &save_ptr);
+ }
+done:
+ LOCK (&barrier->lock);
+ {
+ barrier->fops = fops;
+ }
+ UNLOCK (&barrier->lock);
+ ret = 0;
+
+ GF_FREE (dup_str);
+ return ret;
+}
+
+void
+gf_barrier_enqueue (gf_barrier_t *barrier, gf_barrier_payload_t *payload)
+{
+ list_add_tail (&payload->list, &barrier->queue);
+ barrier->cur_size++;
+}
+
+gf_barrier_payload_t *
+gf_barrier_payload (rpcsvc_request_t *req, struct iovec *rsp,
+ call_frame_t *frame, struct iovec *payload_orig,
+ int payloadcount, struct iobref *iobref,
+ struct iobuf *iob, gf_boolean_t free_iobref)
+{
+ gf_barrier_payload_t *payload = NULL;
+
+ if (!rsp)
+ return NULL;
+
+ payload = GF_CALLOC (1, sizeof (*payload),1);
+ if (!payload)
+ return NULL;
+
+ INIT_LIST_HEAD (&payload->list);
+
+ payload->req = req;
+ memcpy (&payload->rsp, rsp, sizeof (struct iovec));
+ payload->frame = frame;
+ payload->payload = payload_orig;
+ payload->payload_count = payloadcount;
+ payload->iobref = iobref;
+ payload->iob = iob;
+ payload->free_iobref = free_iobref;
+
+ return payload;
+}
diff --git a/xlators/protocol/server/src/server-helpers.h b/xlators/protocol/server/src/server-helpers.h
index 0b7424bab..b455aa6df 100644
--- a/xlators/protocol/server/src/server-helpers.h
+++ b/xlators/protocol/server/src/server-helpers.h
@@ -15,13 +15,8 @@
#define CALL_STATE(frame) ((server_state_t *)frame->root->state)
-#define BOUND_XL(frame) ((xlator_t *) CALL_STATE(frame)->conn->bound_xl)
-
#define XPRT_FROM_FRAME(frame) ((rpc_transport_t *) CALL_STATE(frame)->xprt)
-#define SERVER_CONNECTION(frame) \
- ((server_connection_t *) CALL_STATE(frame)->conn)
-
#define SERVER_CONF(frame) \
((server_conf_t *)XPRT_FROM_FRAME(frame)->this->private)
@@ -34,45 +29,26 @@
#define IS_NOT_ROOT(pathlen) ((pathlen > 2)? 1 : 0)
+#define is_fop_barriered(fops, procnum) (fops & ((uint64_t)1 << procnum))
+
+#define barrier_add_to_queue(barrier) (barrier->on || barrier->cur_size)
+
void free_state (server_state_t *state);
void server_loc_wipe (loc_t *loc);
-int32_t
-gf_add_locker (server_connection_t *conn, const char *volume,
- loc_t *loc,
- fd_t *fd,
- pid_t pid,
- gf_lkowner_t *owner,
- glusterfs_fop_t type);
-
-int32_t
-gf_del_locker (server_connection_t *conn, const char *volume,
- loc_t *loc,
- fd_t *fd,
- gf_lkowner_t *owner,
- glusterfs_fop_t type);
-
void
server_print_request (call_frame_t *frame);
call_frame_t *
get_frame_from_request (rpcsvc_request_t *req);
-gf_boolean_t
-server_cancel_conn_timer (xlator_t *this, server_connection_t *conn);
-
-void
-put_server_conn_state (xlator_t *this, rpc_transport_t *xprt);
-
-server_connection_t *
-get_server_conn_state (xlator_t *this, rpc_transport_t *xptr);
-
-server_connection_t *
-create_server_conn_state (xlator_t *this, rpc_transport_t *xptr);
+int
+server_connection_cleanup (xlator_t *this, struct _client_t *client,
+ int32_t flags);
-void
-destroy_server_conn_state (server_connection_t *conn);
+gf_boolean_t
+server_cancel_grace_timer (xlator_t *this, struct _client_t *client);
int
server_build_config (xlator_t *this, server_conf_t *conf);
@@ -82,4 +58,17 @@ int serialize_rsp_direntp (gf_dirent_t *entries, gfs3_readdirp_rsp *rsp);
int readdirp_rsp_cleanup (gfs3_readdirp_rsp *rsp);
int readdir_rsp_cleanup (gfs3_readdir_rsp *rsp);
+server_ctx_t *server_ctx_get (client_t *client, xlator_t *xlator);
+
+int32_t gf_barrier_start (xlator_t *this);
+int32_t gf_barrier_stop (xlator_t *this);
+int32_t gf_barrier_fops_configure (xlator_t *this, gf_barrier_t *barrier,
+ char *str);
+void gf_barrier_enqueue (gf_barrier_t *barrier, gf_barrier_payload_t *stub);
+gf_barrier_payload_t *
+gf_barrier_payload (rpcsvc_request_t *req, struct iovec *rsp,
+ call_frame_t *frame, struct iovec *payload,
+ int payloadcount, struct iobref *iobref,
+ struct iobuf *iob, gf_boolean_t free_iobref);
+
#endif /* !_SERVER_HELPERS_H */
diff --git a/xlators/protocol/server/src/server-resolve.c b/xlators/protocol/server/src/server-resolve.c
index 4a91a4104..cc4686a03 100644
--- a/xlators/protocol/server/src/server-resolve.c
+++ b/xlators/protocol/server/src/server-resolve.c
@@ -147,7 +147,8 @@ resolve_gfid_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
(char **) &resolve_loc->path);
STACK_WIND (frame, resolve_gfid_entry_cbk,
- BOUND_XL (frame), BOUND_XL (frame)->fops->lookup,
+ frame->root->client->bound_xl,
+ frame->root->client->bound_xl->fops->lookup,
&resolve->resolve_loc, NULL);
return 0;
out:
@@ -179,7 +180,8 @@ resolve_gfid (call_frame_t *frame)
ret = loc_path (resolve_loc, NULL);
STACK_WIND (frame, resolve_gfid_cbk,
- BOUND_XL (frame), BOUND_XL (frame)->fops->lookup,
+ frame->root->client->bound_xl,
+ frame->root->client->bound_xl->fops->lookup,
&resolve->resolve_loc, NULL);
return 0;
}
@@ -449,14 +451,14 @@ server_resolve_anonfd (call_frame_t *frame)
int
server_resolve_fd (call_frame_t *frame)
{
- server_state_t *state = NULL;
- server_resolve_t *resolve = NULL;
- server_connection_t *conn = 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;
- conn = SERVER_CONNECTION (frame);
fd_no = resolve->fd_no;
@@ -465,7 +467,18 @@ server_resolve_fd (call_frame_t *frame)
return 0;
}
- state->fd = gf_fd_fdptr_get (conn->fdtable, fd_no);
+ client = frame->root->client;
+
+ serv_ctx = server_ctx_get (client, client->this);
+
+ if (serv_ctx == NULL) {
+ gf_log ("", GF_LOG_INFO, "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);
if (!state->fd) {
gf_log ("", GF_LOG_INFO, "fd not found in context");
@@ -520,14 +533,12 @@ int
server_resolve_done (call_frame_t *frame)
{
server_state_t *state = NULL;
- xlator_t *bound_xl = NULL;
state = CALL_STATE (frame);
- bound_xl = BOUND_XL (frame);
server_print_request (frame);
- state->resume_fn (frame, bound_xl);
+ state->resume_fn (frame, frame->root->client->bound_xl);
return 0;
}
diff --git a/xlators/protocol/server/src/server-rpc-fops.c b/xlators/protocol/server/src/server-rpc-fops.c
index 9e326af4b..138e601ce 100644
--- a/xlators/protocol/server/src/server-rpc-fops.c
+++ b/xlators/protocol/server/src/server-rpc-fops.c
@@ -24,6 +24,11 @@
#include "xdr-nfs3.h"
+#define SERVER_REQ_SET_ERROR(req, ret) \
+ do { \
+ rpcsvc_request_seterr (req, GARBAGE_ARGS); \
+ ret = RPCSVC_ACTOR_ERROR; \
+ } while (0)
/* Callback function section */
int
@@ -31,20 +36,14 @@ 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;
- server_connection_t *conn = NULL;
-
- req = frame->local;
-
- conn = SERVER_CONNECTION (frame);
+ gfs3_statfs_rsp rsp = {0,};
+ rpcsvc_request_t *req = NULL;
- GF_PROTOCOL_DICT_SERIALIZE (this, xdata, (&rsp.xdata.xdata_val),
+ GF_PROTOCOL_DICT_SERIALIZE (this, xdata, &rsp.xdata.xdata_val,
rsp.xdata.xdata_len, op_errno, out);
if (op_ret < 0) {
- gf_log (this->name, GF_LOG_WARNING,
- "(conn:%s) %"PRId64": STATFS (%s)", conn->id,
+ gf_log (this->name, GF_LOG_WARNING, "%"PRId64": STATFS (%s)",
frame->root->unique, strerror (op_errno));
goto out;
}
@@ -55,7 +54,7 @@ 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_gfs3_statfs_rsp);
@@ -77,11 +76,8 @@ server_lookup_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
loc_t fresh_loc = {0,};
gfs3_lookup_rsp rsp = {0,};
uuid_t rootgfid = {0,};
- server_connection_t *conn = NULL;
- req = frame->local;
- state = CALL_STATE(frame);
- conn = SERVER_CONNECTION (frame);
+ state = CALL_STATE (frame);
if (state->is_revalidate == 1 && op_ret == -1) {
state->is_revalidate = 2;
@@ -89,8 +85,9 @@ server_lookup_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
inode_unref (fresh_loc.inode);
fresh_loc.inode = inode_new (state->itable);
- STACK_WIND (frame, server_lookup_cbk, BOUND_XL (frame),
- BOUND_XL (frame)->fops->lookup,
+ 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);
@@ -99,7 +96,7 @@ server_lookup_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
gf_stat_from_iatt (&rsp.postparent, postparent);
- GF_PROTOCOL_DICT_SERIALIZE (this, xdata, (&rsp.xdata.xdata_val),
+ GF_PROTOCOL_DICT_SERIALIZE (this, xdata, &rsp.xdata.xdata_val,
rsp.xdata.xdata_len, op_errno, out);
if (op_ret) {
@@ -113,7 +110,7 @@ server_lookup_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
goto out;
}
- root_inode = BOUND_XL(frame)->itable->root;
+ root_inode = frame->root->client->bound_xl->itable->root;
if (inode == root_inode) {
/* we just looked up root ("/") */
stbuf->ia_ino = 1;
@@ -142,8 +139,8 @@ out:
if (state->resolve.bname) {
gf_log (this->name, ((op_errno == ENOENT) ?
GF_LOG_TRACE : GF_LOG_INFO),
- "(conn:%s) %"PRId64": LOOKUP %s (%s/%s) ==> "
- "(%s)",conn->id, frame->root->unique,
+ "%"PRId64": LOOKUP %s (%s/%s) ==> "
+ "(%s)", frame->root->unique,
state->loc.path,
uuid_utoa (state->resolve.pargfid),
state->resolve.bname,
@@ -151,13 +148,14 @@ out:
} else {
gf_log (this->name, ((op_errno == ENOENT) ?
GF_LOG_TRACE : GF_LOG_INFO),
- "(conn:%s) %"PRId64": LOOKUP %s (%s) ==> (%s)",
- conn->id, frame->root->unique, state->loc.path,
+ "%"PRId64": LOOKUP %s (%s) ==> (%s)",
+ frame->root->unique, state->loc.path,
uuid_utoa (state->resolve.gfid),
strerror (op_errno));
}
}
+ req = frame->local;
server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
(xdrproc_t)xdr_gfs3_lookup_rsp);
@@ -175,21 +173,16 @@ server_lk_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
gfs3_lk_rsp rsp = {0,};
rpcsvc_request_t *req = NULL;
server_state_t *state = NULL;
- server_connection_t *conn = NULL;
- req = frame->local;
- state = CALL_STATE(frame);
-
- conn = SERVER_CONNECTION (frame);
-
- GF_PROTOCOL_DICT_SERIALIZE (this, xdata, (&rsp.xdata.xdata_val),
+ GF_PROTOCOL_DICT_SERIALIZE (this, xdata, &rsp.xdata.xdata_val,
rsp.xdata.xdata_len, op_errno, out);
if (op_ret) {
if ((op_errno != ENOSYS) && (op_errno != EAGAIN)) {
+ state = CALL_STATE (frame);
gf_log (this->name, GF_LOG_INFO,
- "(conn: %s) %"PRId64": LK %"PRId64" (%s) ==> "
- "(%s)", conn->id, frame->root->unique,
+ "%"PRId64": LK %"PRId64" (%s) ==> "
+ "(%s)", frame->root->unique,
state->resolve.fd_no,
uuid_utoa (state->resolve.gfid),
strerror (op_errno));
@@ -219,6 +212,7 @@ 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_gfs3_lk_rsp);
@@ -232,43 +226,32 @@ int
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_connection_t *conn = NULL;
- 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;
- conn = SERVER_CONNECTION(frame);
- state = CALL_STATE(frame);
-
- GF_PROTOCOL_DICT_SERIALIZE (this, xdata, (&rsp.xdata.xdata_val),
+ 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) {
if ((op_errno != ENOSYS) && (op_errno != EAGAIN)) {
- gf_log (this->name, GF_LOG_INFO,
- "(conn:%s) %"PRId64": INODELK %s (%s) ==> (%s)",
- conn->id, frame->root->unique, state->loc.path,
+ gf_log (this->name, (op_errno == ENOENT)?
+ GF_LOG_DEBUG:GF_LOG_ERROR,
+ "%"PRId64": INODELK %s (%s) ==> (%s)",
+ frame->root->unique, state->loc.path,
uuid_utoa (state->resolve.gfid),
strerror (op_errno));
}
goto out;
}
- if (state->flock.l_type == F_UNLCK)
- gf_del_locker (conn, state->volume,
- &state->loc, NULL, &frame->root->lk_owner,
- GF_FOP_INODELK);
- else
- gf_add_locker (conn, state->volume,
- &state->loc, NULL, frame->root->pid,
- &frame->root->lk_owner,
- GF_FOP_INODELK);
-
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_gf_common_rsp);
@@ -282,23 +265,20 @@ int
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;
- server_connection_t *conn = NULL;
- rpcsvc_request_t *req = NULL;
-
- req = frame->local;
- conn = SERVER_CONNECTION(frame);
- state = CALL_STATE(frame);
+ 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),
+ 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) {
if ((op_errno != ENOSYS) && (op_errno != EAGAIN)) {
gf_log (this->name, GF_LOG_INFO,
- "(conn:%s) %"PRId64": FINODELK %"PRId64" (%s) "
- "==> (%s)", conn->id, frame->root->unique,
+ "%"PRId64": FINODELK %"PRId64" (%s) "
+ "==> (%s)", frame->root->unique,
state->resolve.fd_no,
uuid_utoa (state->resolve.gfid),
strerror (op_errno));
@@ -306,20 +286,11 @@ server_finodelk_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
goto out;
}
- if (state->flock.l_type == F_UNLCK)
- gf_del_locker (conn, state->volume,
- NULL, state->fd,
- &frame->root->lk_owner, GF_FOP_INODELK);
- else
- gf_add_locker (conn, state->volume,
- NULL, state->fd,
- frame->root->pid,
- &frame->root->lk_owner, GF_FOP_INODELK);
-
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_gf_common_rsp);
@@ -332,43 +303,31 @@ 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_connection_t *conn = NULL;
- server_state_t *state = NULL;
- rpcsvc_request_t *req = NULL;
- gf_common_rsp rsp = {0,};
+ gf_common_rsp rsp = {0,};
+ server_state_t *state = NULL;
+ rpcsvc_request_t *req = NULL;
- req = frame->local;
- conn = SERVER_CONNECTION(frame);
- state = CALL_STATE(frame);
-
- GF_PROTOCOL_DICT_SERIALIZE (this, xdata, (&rsp.xdata.xdata_val),
+ 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) {
if ((op_errno != ENOSYS) && (op_errno != EAGAIN)) {
gf_log (this->name, GF_LOG_INFO,
- "(conn:%s) %"PRId64": ENTRYLK %s (%s) ==> (%s)",
- conn->id, frame->root->unique, state->loc.path,
+ "%"PRId64": ENTRYLK %s (%s) ==> (%s)",
+ frame->root->unique, state->loc.path,
uuid_utoa (state->resolve.gfid),
strerror (op_errno));
}
goto out;
}
- if (state->cmd == ENTRYLK_UNLOCK)
- gf_del_locker (conn, state->volume,
- &state->loc, NULL, &frame->root->lk_owner,
- GF_FOP_ENTRYLK);
- else
- gf_add_locker (conn, state->volume,
- &state->loc, NULL, frame->root->pid,
- &frame->root->lk_owner,
- GF_FOP_ENTRYLK);
-
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_gf_common_rsp);
@@ -382,23 +341,19 @@ int
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_connection_t *conn = NULL;
- 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;
- conn = SERVER_CONNECTION(frame);
- state = CALL_STATE(frame);
-
- GF_PROTOCOL_DICT_SERIALIZE (this, xdata, (&rsp.xdata.xdata_val),
+ 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) {
if ((op_errno != ENOSYS) && (op_errno != EAGAIN)) {
gf_log (this->name, GF_LOG_INFO,
- "(conn:%s) %"PRId64": FENTRYLK %"PRId64" (%s) "
- "==>(%s)", conn->id,
+ "%"PRId64": FENTRYLK %"PRId64" (%s) ==>(%s)",
frame->root->unique, state->resolve.fd_no,
uuid_utoa (state->resolve.gfid),
strerror (op_errno));
@@ -406,19 +361,11 @@ server_fentrylk_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
goto out;
}
- if (state->cmd == ENTRYLK_UNLOCK)
- gf_del_locker (conn, state->volume,
- NULL, state->fd, &frame->root->lk_owner,
- GF_FOP_ENTRYLK);
- else
- gf_add_locker (conn, state->volume,
- NULL, state->fd, frame->root->pid,
- &frame->root->lk_owner, GF_FOP_ENTRYLK);
-
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_gf_common_rsp);
@@ -435,19 +382,15 @@ server_access_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
gf_common_rsp rsp = {0,};
rpcsvc_request_t *req = NULL;
server_state_t *state = NULL;
- server_connection_t *conn = NULL;
- req = frame->local;
- state = CALL_STATE(frame);
- conn = SERVER_CONNECTION (frame);
-
- GF_PROTOCOL_DICT_SERIALIZE (this, xdata, (&rsp.xdata.xdata_val),
+ 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_log (this->name, GF_LOG_INFO,
- "(conn:%s) %"PRId64": ACCESS %s (%s) ==> (%s)",
- conn->id, frame->root->unique, state->loc.path,
+ "%"PRId64": ACCESS %s (%s) ==> (%s)",
+ frame->root->unique, state->loc.path,
uuid_utoa (state->resolve.gfid),
strerror (op_errno));
goto out;
@@ -457,6 +400,7 @@ 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_gf_common_rsp);
@@ -474,19 +418,16 @@ server_rmdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
server_state_t *state = NULL;
inode_t *parent = NULL;
rpcsvc_request_t *req = NULL;
- server_connection_t *conn = NULL;
-
- req = frame->local;
- state = CALL_STATE(frame);
- conn = SERVER_CONNECTION (frame);
- GF_PROTOCOL_DICT_SERIALIZE (this, xdata, (&rsp.xdata.xdata_val),
+ 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_log (this->name, GF_LOG_INFO,
- "(conn:%s) %"PRId64": RMDIR %s (%s/%s) ==> (%s)",
- conn->id, frame->root->unique, state->loc.path,
+ "%"PRId64": RMDIR %s (%s/%s) ==> (%s)",
+ frame->root->unique, state->loc.path,
uuid_utoa (state->resolve.pargfid),
state->resolve.bname, strerror (op_errno));
goto out;
@@ -511,6 +452,7 @@ 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_gfs3_rmdir_rsp);
@@ -529,19 +471,16 @@ server_mkdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
server_state_t *state = NULL;
inode_t *link_inode = NULL;
rpcsvc_request_t *req = NULL;
- server_connection_t *conn = NULL;
-
- req = frame->local;
- state = CALL_STATE(frame);
- conn = SERVER_CONNECTION (frame);
- GF_PROTOCOL_DICT_SERIALIZE (this, xdata, (&rsp.xdata.xdata_val),
+ 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_log (this->name, GF_LOG_INFO,
- "(conn:%s) %"PRId64": MKDIR %s (%s/%s) ==> (%s)",
- conn->id, frame->root->unique, state->loc.path,
+ "%"PRId64": MKDIR %s (%s/%s) ==> (%s)",
+ frame->root->unique, state->loc.path,
uuid_utoa (state->resolve.pargfid),
state->resolve.bname, strerror (op_errno));
goto out;
@@ -560,6 +499,7 @@ 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_gfs3_mkdir_rsp);
@@ -578,19 +518,16 @@ server_mknod_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
server_state_t *state = NULL;
inode_t *link_inode = NULL;
rpcsvc_request_t *req = NULL;
- server_connection_t *conn = NULL;
- req = frame->local;
- state = CALL_STATE(frame);
- conn = SERVER_CONNECTION (frame);
-
- GF_PROTOCOL_DICT_SERIALIZE (this, xdata, (&rsp.xdata.xdata_val),
+ 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_log (this->name, GF_LOG_INFO,
- "(conn:%s) %"PRId64": MKNOD %s (%s/%s) ==> (%s)",
- conn->id, frame->root->unique, state->loc.path,
+ "%"PRId64": MKNOD %s (%s/%s) ==> (%s)",
+ frame->root->unique, state->loc.path,
uuid_utoa (state->resolve.pargfid),
state->resolve.bname, strerror (op_errno));
goto out;
@@ -609,6 +546,7 @@ 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_gfs3_mknod_rsp);
@@ -624,19 +562,15 @@ server_fsyncdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
gf_common_rsp rsp = {0,};
server_state_t *state = NULL;
rpcsvc_request_t *req = NULL;
- server_connection_t *conn = NULL;
-
- req = frame->local;
- state = CALL_STATE(frame);
- conn = SERVER_CONNECTION (frame);
- GF_PROTOCOL_DICT_SERIALIZE (this, xdata, (&rsp.xdata.xdata_val),
+ 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_log (this->name, GF_LOG_INFO,
- "(conn:%s) %"PRId64": FSYNCDIR %"PRId64" (%s) ==> (%s)",
- conn->id, frame->root->unique, state->resolve.fd_no,
+ "%"PRId64": FSYNCDIR %"PRId64" (%s) ==> (%s)",
+ frame->root->unique, state->resolve.fd_no,
uuid_utoa (state->resolve.gfid),
strerror (op_errno));
goto out;
@@ -646,6 +580,7 @@ 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_gf_common_rsp);
@@ -663,19 +598,15 @@ server_readdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
server_state_t *state = NULL;
rpcsvc_request_t *req = NULL;
int ret = 0;
- server_connection_t *conn = NULL;
-
- req = frame->local;
- state = CALL_STATE(frame);
- conn = SERVER_CONNECTION (frame);
- GF_PROTOCOL_DICT_SERIALIZE (this, xdata, (&rsp.xdata.xdata_val),
+ 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_log (this->name, GF_LOG_INFO,
- "(conn:%s) %"PRId64": READDIR %"PRId64" (%s) ==> (%s)",
- conn->id, frame->root->unique, state->resolve.fd_no,
+ "%"PRId64": READDIR %"PRId64" (%s) ==> (%s)",
+ frame->root->unique, state->resolve.fd_no,
uuid_utoa (state->resolve.gfid),
strerror (op_errno));
goto out;
@@ -695,6 +626,7 @@ 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_gfs3_readdir_rsp);
@@ -709,29 +641,33 @@ 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_connection_t *conn = NULL;
- server_state_t *state = NULL;
- rpcsvc_request_t *req = NULL;
- gfs3_opendir_rsp rsp = {0,};
- uint64_t fd_no = 0;
-
- req = frame->local;
- conn = SERVER_CONNECTION (frame);
- state = CALL_STATE (frame);
+ server_state_t *state = NULL;
+ server_ctx_t *serv_ctx = 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),
+ GF_PROTOCOL_DICT_SERIALIZE (this, xdata, &rsp.xdata.xdata_val,
rsp.xdata.xdata_len, op_errno, out);
if (op_ret < 0) {
- gf_log (this->name, GF_LOG_INFO,
- "(conn:%s) %"PRId64": OPENDIR %s (%s) ==> (%s)",
- conn->id, frame->root->unique, state->loc.path,
+ state = CALL_STATE (frame);
+ gf_log (this->name, (op_errno == ENOENT)?
+ GF_LOG_DEBUG:GF_LOG_ERROR,
+ "%"PRId64": OPENDIR %s (%s) ==> (%s)",
+ frame->root->unique, state->loc.path,
uuid_utoa (state->resolve.gfid), strerror (op_errno));
goto out;
}
+ serv_ctx = server_ctx_get (frame->root->client, this);
+ if (serv_ctx == NULL) {
+ gf_log (this->name, GF_LOG_INFO, "server_ctx_get() failed");
+ goto out;
+ }
+
fd_bind (fd);
- fd_no = gf_fd_unused_get (conn->fdtable, fd);
+ fd_no = gf_fd_unused_get (serv_ctx->fdtable, fd);
fd_ref (fd); // on behalf of the client
out:
@@ -739,6 +675,7 @@ 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_gfs3_opendir_rsp);
@@ -754,19 +691,14 @@ server_removexattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
gf_common_rsp rsp = {0,};
rpcsvc_request_t *req = NULL;
server_state_t *state = NULL;
- server_connection_t *conn = NULL;
- req = frame->local;
- state = CALL_STATE(frame);
- conn = SERVER_CONNECTION (frame);
-
- GF_PROTOCOL_DICT_SERIALIZE (this, xdata, (&rsp.xdata.xdata_val),
+ 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_log (this->name, GF_LOG_INFO,
- "(conn:%s) %"PRId64": REMOVEXATTR %s (%s) of key %s "
- "==> (%s)", conn->id,
+ "%"PRId64": REMOVEXATTR %s (%s) of key %s ==> (%s)",
frame->root->unique, state->loc.path,
uuid_utoa (state->resolve.gfid),
state->name, strerror (op_errno));
@@ -777,6 +709,7 @@ 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_gf_common_rsp);
@@ -792,19 +725,14 @@ server_fremovexattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
gf_common_rsp rsp = {0,};
rpcsvc_request_t *req = NULL;
server_state_t *state = NULL;
- server_connection_t *conn = NULL;
- req = frame->local;
- state = CALL_STATE(frame);
- conn = SERVER_CONNECTION (frame);
-
- GF_PROTOCOL_DICT_SERIALIZE (this, xdata, (&rsp.xdata.xdata_val),
+ 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_log (this->name, GF_LOG_INFO,
- "(conn:%s) %"PRId64": FREMOVEXATTR %"PRId64" (%s) (%s) "
- "==> (%s)", conn->id,
+ "%"PRId64": FREMOVEXATTR %"PRId64" (%s) (%s) ==> (%s)",
frame->root->unique, state->resolve.fd_no,
uuid_utoa (state->resolve.gfid), state->name,
strerror (op_errno));
@@ -815,6 +743,7 @@ 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_gf_common_rsp);
@@ -831,34 +760,31 @@ server_getxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
gfs3_getxattr_rsp rsp = {0,};
rpcsvc_request_t *req = NULL;
server_state_t *state = NULL;
- server_connection_t *conn = NULL;
-
- req = frame->local;
- state = CALL_STATE (frame);
- conn = SERVER_CONNECTION (frame);
- GF_PROTOCOL_DICT_SERIALIZE (this, xdata, (&rsp.xdata.xdata_val),
+ 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_log (this->name, (((op_errno == ENOTSUP) ||
(op_errno == ENODATA) ||
(op_errno == ENOENT)) ?
GF_LOG_DEBUG : GF_LOG_INFO),
- "(conn:%s) %"PRId64": GETXATTR %s (%s) (%s) ==> (%s)",
- conn->id, frame->root->unique, state->loc.path,
+ "%"PRId64": GETXATTR %s (%s) (%s) ==> (%s)",
+ frame->root->unique, state->loc.path,
uuid_utoa (state->resolve.gfid),
state->name, strerror (op_errno));
goto out;
}
- GF_PROTOCOL_DICT_SERIALIZE (this, dict, (&rsp.dict.dict_val),
+ 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);
+ req = frame->local;
server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
(xdrproc_t)xdr_gfs3_getxattr_rsp);
@@ -878,27 +804,22 @@ server_fgetxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
gfs3_fgetxattr_rsp rsp = {0,};
server_state_t *state = NULL;
rpcsvc_request_t *req = NULL;
- server_connection_t *conn = NULL;
-
- req = frame->local;
- state = CALL_STATE (frame);
- conn = SERVER_CONNECTION (frame);
- GF_PROTOCOL_DICT_SERIALIZE (this, xdata, (&rsp.xdata.xdata_val),
+ 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_log (this->name, ((op_errno == ENOTSUP) ?
GF_LOG_DEBUG : GF_LOG_INFO),
- "(conn:%s) %"PRId64": FGETXATTR %"PRId64" (%s) (%s) "
- "==> (%s)", conn->id,
+ "%"PRId64": FGETXATTR %"PRId64" (%s) (%s) ==> (%s)",
frame->root->unique, state->resolve.fd_no,
uuid_utoa (state->resolve.gfid),
state->name, strerror (op_errno));
goto out;
}
- GF_PROTOCOL_DICT_SERIALIZE (this, dict, (&rsp.dict.dict_val),
+ GF_PROTOCOL_DICT_SERIALIZE (this, dict, &rsp.dict.dict_val,
rsp.dict.dict_len, op_errno, out);
out:
@@ -906,6 +827,7 @@ 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_gfs3_fgetxattr_rsp);
@@ -923,15 +845,13 @@ _gf_server_log_setxattr_failure (dict_t *d, char *k, data_t *v,
{
server_state_t *state = NULL;
call_frame_t *frame = NULL;
- server_connection_t *conn = NULL;
frame = tmp;
- conn = SERVER_CONNECTION (frame);
- state = CALL_STATE(frame);
+ state = CALL_STATE (frame);
gf_log (THIS->name, GF_LOG_INFO,
- "(conn:%s) %"PRId64": SETXATTR %s (%s) ==> %s",
- conn->id, frame->root->unique, state->loc.path,
+ "%"PRId64": SETXATTR %s (%s) ==> %s",
+ frame->root->unique, state->loc.path,
uuid_utoa (state->resolve.gfid), k);
return 0;
}
@@ -944,13 +864,11 @@ server_setxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
rpcsvc_request_t *req = NULL;
server_state_t *state = NULL;
- req = frame->local;
- state = CALL_STATE(frame);
-
- GF_PROTOCOL_DICT_SERIALIZE (this, xdata, (&rsp.xdata.xdata_val),
+ 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,
@@ -966,6 +884,7 @@ 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_gf_common_rsp);
@@ -981,15 +900,13 @@ _gf_server_log_fsetxattr_failure (dict_t *d, char *k, data_t *v,
{
call_frame_t *frame = NULL;
server_state_t *state = NULL;
- server_connection_t *conn = NULL;
frame = tmp;
- state = CALL_STATE(frame);
- conn = SERVER_CONNECTION (frame);
+ state = CALL_STATE (frame);
gf_log (THIS->name, GF_LOG_INFO,
- "(conn:%s) %"PRId64": FSETXATTR %"PRId64" (%s) ==> %s",
- conn->id, frame->root->unique, state->resolve.fd_no,
+ "%"PRId64": FSETXATTR %"PRId64" (%s) ==> %s",
+ frame->root->unique, state->resolve.fd_no,
uuid_utoa (state->resolve.gfid), k);
return 0;
@@ -1003,13 +920,11 @@ server_fsetxattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
rpcsvc_request_t *req = NULL;
server_state_t *state = NULL;
- req = frame->local;
- state = CALL_STATE(frame);
-
- GF_PROTOCOL_DICT_SERIALIZE (this, xdata, (&rsp.xdata.xdata_val),
+ 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,
@@ -1025,6 +940,7 @@ 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_gf_common_rsp);
@@ -1047,21 +963,17 @@ server_rename_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
inode_t *tmp_parent = NULL;
char oldpar_str[50] = {0,};
char newpar_str[50] = {0,};
- server_connection_t *conn = NULL;
-
- req = frame->local;
- state = CALL_STATE(frame);
- conn = SERVER_CONNECTION (frame);
- GF_PROTOCOL_DICT_SERIALIZE (this, xdata, (&rsp.xdata.xdata_val),
+ 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.gfid, oldpar_str);
uuid_utoa_r (state->resolve2.gfid, newpar_str);
gf_log (this->name, GF_LOG_INFO,
- "(conn:%s) %"PRId64": RENAME %s (%s/%s) -> %s (%s/%s) "
- "==> (%s)", conn->id,
+ "%"PRId64": RENAME %s (%s/%s) -> %s (%s/%s) ==> (%s)",
frame->root->unique, state->loc.path,
oldpar_str, state->resolve.bname, state->loc2.path,
newpar_str, state->resolve2.bname, strerror (op_errno));
@@ -1071,8 +983,8 @@ server_rename_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
stbuf->ia_type = state->loc.inode->ia_type;
/* TODO: log gfid of the inodes */
- gf_log (state->conn->bound_xl->name, GF_LOG_TRACE,
- "(conn:%s) %"PRId64": RENAME_CBK %s ==> %s", conn->id,
+ gf_log (frame->root->client->bound_xl->name, GF_LOG_TRACE,
+ "%"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
@@ -1113,6 +1025,7 @@ 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_gfs3_rename_rsp);
@@ -1130,28 +1043,25 @@ server_unlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
server_state_t *state = NULL;
inode_t *parent = NULL;
rpcsvc_request_t *req = NULL;
- server_connection_t *conn = NULL;
-
- req = frame->local;
- state = CALL_STATE(frame);
- conn = SERVER_CONNECTION (frame);
- GF_PROTOCOL_DICT_SERIALIZE (this, xdata, (&rsp.xdata.xdata_val),
+ 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_log (this->name, (op_errno == ENOENT)?
GF_LOG_DEBUG:GF_LOG_ERROR,
- "(conn:%s) %"PRId64": UNLINK %s (%s/%s) ==> (%s)",
- conn->id, frame->root->unique, state->loc.path,
+ "%"PRId64": UNLINK %s (%s/%s) ==> (%s)",
+ frame->root->unique, state->loc.path,
uuid_utoa (state->resolve.pargfid),
state->resolve.bname, strerror (op_errno));
goto out;
}
/* TODO: log gfid of the inodes */
- gf_log (state->conn->bound_xl->name, GF_LOG_TRACE,
- "(conn:%s) %"PRId64": UNLINK_CBK %s", conn->id,
+ gf_log (frame->root->client->bound_xl->name, GF_LOG_TRACE,
+ "%"PRId64": UNLINK_CBK %s",
frame->root->unique, state->loc.name);
inode_unlink (state->loc.inode, state->loc.parent,
@@ -1170,6 +1080,7 @@ 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_gfs3_unlink_rsp);
@@ -1188,19 +1099,16 @@ server_symlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
server_state_t *state = NULL;
inode_t *link_inode = NULL;
rpcsvc_request_t *req = NULL;
- server_connection_t *conn = NULL;
- req = frame->local;
- state = CALL_STATE(frame);
- conn = SERVER_CONNECTION (frame);
-
- GF_PROTOCOL_DICT_SERIALIZE (this, xdata, (&rsp.xdata.xdata_val),
+ 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_log (this->name, GF_LOG_INFO,
- "(conn:%s) %"PRId64": SYMLINK %s (%s/%s) ==> (%s)",
- conn->id, frame->root->unique, state->loc.path,
+ "%"PRId64": SYMLINK %s (%s/%s) ==> (%s)",
+ frame->root->unique, state->loc.path,
uuid_utoa (state->resolve.pargfid),
state->resolve.bname, strerror (op_errno));
goto out;
@@ -1219,6 +1127,7 @@ 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_gfs3_symlink_rsp);
@@ -1240,22 +1149,19 @@ server_link_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
rpcsvc_request_t *req = NULL;
char gfid_str[50] = {0,};
char newpar_str[50] = {0,};
- server_connection_t *conn = NULL;
- req = frame->local;
- state = CALL_STATE(frame);
- conn = SERVER_CONNECTION (frame);
-
- GF_PROTOCOL_DICT_SERIALIZE (this, xdata, (&rsp.xdata.xdata_val),
+ GF_PROTOCOL_DICT_SERIALIZE (this, xdata, &rsp.xdata.xdata_val,
rsp.xdata.xdata_len, op_errno, out);
+ state = CALL_STATE (frame);
+
if (op_ret) {
uuid_utoa_r (state->resolve.gfid, gfid_str);
uuid_utoa_r (state->resolve2.pargfid, newpar_str);
gf_log (this->name, GF_LOG_INFO,
- "(conn:%s) %"PRId64": LINK %s (%s) -> %s/%s ==> (%s)",
- conn->id, frame->root->unique, state->loc.path,
+ "%"PRId64": LINK %s (%s) -> %s/%s ==> (%s)",
+ frame->root->unique, state->loc.path,
gfid_str, newpar_str, state->resolve2.bname,
strerror (op_errno));
goto out;
@@ -1273,6 +1179,7 @@ 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_gfs3_link_rsp);
@@ -1289,19 +1196,15 @@ server_truncate_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
gfs3_truncate_rsp rsp = {0,};
server_state_t *state = NULL;
rpcsvc_request_t *req = NULL;
- server_connection_t *conn = NULL;
- req = frame->local;
- state = CALL_STATE (frame);
- conn = SERVER_CONNECTION (frame);
-
- GF_PROTOCOL_DICT_SERIALIZE (this, xdata, (&rsp.xdata.xdata_val),
+ 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_log (this->name, GF_LOG_INFO,
- "(conn:%s) %"PRId64": TRUNCATE %s (%s) ==> (%s)",
- conn->id, frame->root->unique, state->loc.path,
+ "%"PRId64": TRUNCATE %s (%s) ==> (%s)",
+ frame->root->unique, state->loc.path,
uuid_utoa (state->resolve.gfid), strerror (op_errno));
goto out;
}
@@ -1313,6 +1216,7 @@ 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_gfs3_truncate_rsp);
@@ -1329,19 +1233,15 @@ server_fstat_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
gfs3_fstat_rsp rsp = {0,};
server_state_t *state = NULL;
rpcsvc_request_t *req = NULL;
- server_connection_t *conn = NULL;
- req = frame->local;
- state = CALL_STATE(frame);
- conn = SERVER_CONNECTION (frame);
-
- GF_PROTOCOL_DICT_SERIALIZE (this, xdata, (&rsp.xdata.xdata_val),
+ 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_log (this->name, GF_LOG_INFO,
- "(conn:%s) %"PRId64": FSTAT %"PRId64" (%s) ==> (%s)",
- conn->id, frame->root->unique, state->resolve.fd_no,
+ "%"PRId64": FSTAT %"PRId64" (%s) ==> (%s)",
+ frame->root->unique, state->resolve.fd_no,
uuid_utoa (state->resolve.gfid), strerror (op_errno));
goto out;
}
@@ -1352,6 +1252,7 @@ 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_gfs3_fstat_rsp);
@@ -1368,19 +1269,15 @@ server_ftruncate_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
gfs3_ftruncate_rsp rsp = {0};
server_state_t *state = NULL;
rpcsvc_request_t *req = NULL;
- server_connection_t *conn = NULL;
- req = frame->local;
- state = CALL_STATE (frame);
- conn = SERVER_CONNECTION (frame);
-
- GF_PROTOCOL_DICT_SERIALIZE (this, xdata, (&rsp.xdata.xdata_val),
+ 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_log (this->name, GF_LOG_INFO,
- "(conn:%s) %"PRId64": FTRUNCATE %"PRId64" (%s)==> (%s)",
- conn->id, frame->root->unique, state->resolve.fd_no,
+ "%"PRId64": FTRUNCATE %"PRId64" (%s)==> (%s)",
+ frame->root->unique, state->resolve.fd_no,
uuid_utoa (state->resolve.gfid), strerror (op_errno));
goto out;
}
@@ -1392,6 +1289,7 @@ 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_gfs3_ftruncate_rsp);
@@ -1407,20 +1305,17 @@ server_flush_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
gf_common_rsp rsp = {0,};
server_state_t *state = NULL;
rpcsvc_request_t *req = NULL;
- server_connection_t *conn = NULL;
- req = frame->local;
- state = CALL_STATE(frame);
- conn = SERVER_CONNECTION (frame);
-
- GF_PROTOCOL_DICT_SERIALIZE (this, xdata, (&rsp.xdata.xdata_val),
+ GF_PROTOCOL_DICT_SERIALIZE (this, xdata, &rsp.xdata.xdata_val,
rsp.xdata.xdata_len, op_errno, out);
if (op_ret < 0) {
- gf_log (this->name, GF_LOG_INFO,
- "(conn:%s) %"PRId64": FLUSH %"PRId64" (%s) ==> (%s)",
- conn->id, frame->root->unique, state->resolve.fd_no,
- uuid_utoa (state->resolve.gfid), strerror (op_errno));
+ state = CALL_STATE (frame);
+ gf_log (this->name, (op_errno == ENOENT)?
+ GF_LOG_DEBUG:GF_LOG_ERROR,
+ "%"PRId64": FLUSH %"PRId64" (%s) ==> (%s)",
+ frame->root->unique, state->resolve.fd_no,
+ uuid_utoa (state->resolve.gfid), strerror (op_errno));
goto out;
}
@@ -1428,6 +1323,7 @@ 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_gf_common_rsp);
@@ -1444,19 +1340,15 @@ server_fsync_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
gfs3_fsync_rsp rsp = {0,};
server_state_t *state = NULL;
rpcsvc_request_t *req = NULL;
- server_connection_t *conn = NULL;
- req = frame->local;
- state = CALL_STATE(frame);
- conn = SERVER_CONNECTION (frame);
-
- GF_PROTOCOL_DICT_SERIALIZE (this, xdata, (&rsp.xdata.xdata_val),
+ 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_log (this->name, GF_LOG_INFO,
- "(conn:%s) %"PRId64": FSYNC %"PRId64" (%s) ==> (%s)",
- conn->id, frame->root->unique, state->resolve.fd_no,
+ "%"PRId64": FSYNC %"PRId64" (%s) ==> (%s)",
+ frame->root->unique, state->resolve.fd_no,
uuid_utoa (state->resolve.gfid), strerror (op_errno));
goto out;
}
@@ -1468,6 +1360,7 @@ 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_gfs3_fsync_rsp);
@@ -1484,19 +1377,15 @@ server_writev_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
gfs3_write_rsp rsp = {0,};
server_state_t *state = NULL;
rpcsvc_request_t *req = NULL;
- server_connection_t *conn = NULL;
- req = frame->local;
- state = CALL_STATE(frame);
- conn = SERVER_CONNECTION (frame);
-
- GF_PROTOCOL_DICT_SERIALIZE (this, xdata, (&rsp.xdata.xdata_val),
+ 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_log (this->name, GF_LOG_INFO,
- "(conn:%s) %"PRId64": WRITEV %"PRId64" (%s) ==> (%s)",
- conn->id, frame->root->unique, state->resolve.fd_no,
+ "%"PRId64": WRITEV %"PRId64" (%s) ==> (%s)",
+ frame->root->unique, state->resolve.fd_no,
uuid_utoa (state->resolve.gfid), strerror (op_errno));
goto out;
}
@@ -1508,6 +1397,7 @@ 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_gfs3_write_rsp);
@@ -1526,11 +1416,6 @@ server_readv_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
gfs3_read_rsp rsp = {0,};
server_state_t *state = NULL;
rpcsvc_request_t *req = NULL;
- server_connection_t *conn = NULL;
-
- req = frame->local;
- state = CALL_STATE(frame);
- conn = SERVER_CONNECTION (frame);
#ifdef GF_TESTING_IO_XDATA
{
@@ -1542,13 +1427,14 @@ server_readv_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
"testing-xdata-value");
}
#endif
- GF_PROTOCOL_DICT_SERIALIZE (this, xdata, (&rsp.xdata.xdata_val),
+ 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_log (this->name, GF_LOG_INFO,
- "(conn:%s) %"PRId64": READV %"PRId64" (%s) ==> (%s)",
- conn->id, frame->root->unique, state->resolve.fd_no,
+ "%"PRId64": READV %"PRId64" (%s) ==> (%s)",
+ frame->root->unique, state->resolve.fd_no,
uuid_utoa (state->resolve.gfid), strerror (op_errno));
goto out;
}
@@ -1560,6 +1446,7 @@ out:
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);
@@ -1577,19 +1464,15 @@ server_rchecksum_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
gfs3_rchecksum_rsp rsp = {0,};
rpcsvc_request_t *req = NULL;
server_state_t *state = NULL;
- server_connection_t *conn = NULL;
-
- req = frame->local;
- state = CALL_STATE(frame);
- conn = SERVER_CONNECTION (frame);
- GF_PROTOCOL_DICT_SERIALIZE (this, xdata, (&rsp.xdata.xdata_val),
+ 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_log (this->name, GF_LOG_INFO,
- "(conn:%s) %"PRId64": RCHECKSUM %"PRId64" (%s)==> (%s)",
- conn->id, frame->root->unique, state->resolve.fd_no,
+ "%"PRId64": RCHECKSUM %"PRId64" (%s)==> (%s)",
+ frame->root->unique, state->resolve.fd_no,
uuid_utoa (state->resolve.gfid), strerror (op_errno));
goto out;
}
@@ -1603,6 +1486,7 @@ 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_gfs3_rchecksum_rsp);
@@ -1616,30 +1500,34 @@ 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_connection_t *conn = NULL;
- server_state_t *state = NULL;
- rpcsvc_request_t *req = NULL;
- uint64_t fd_no = 0;
- gfs3_open_rsp rsp = {0,};
-
- req = frame->local;
- conn = SERVER_CONNECTION (frame);
- state = CALL_STATE (frame);
+ server_state_t *state = NULL;
+ server_ctx_t *serv_ctx = NULL;
+ rpcsvc_request_t *req = NULL;
+ uint64_t fd_no = 0;
+ gfs3_open_rsp rsp = {0,};
- GF_PROTOCOL_DICT_SERIALIZE (this, xdata, (&rsp.xdata.xdata_val),
+ GF_PROTOCOL_DICT_SERIALIZE (this, xdata, &rsp.xdata.xdata_val,
rsp.xdata.xdata_len, op_errno, out);
if (op_ret < 0) {
- gf_log (this->name, GF_LOG_INFO,
- "(conn:%s) %"PRId64": OPEN %s (%s) ==> (%s)",
- conn->id, frame->root->unique, state->loc.path,
+ state = CALL_STATE (frame);
+ gf_log (this->name, (op_errno == ENOENT)?
+ GF_LOG_DEBUG:GF_LOG_ERROR,
+ "%"PRId64": OPEN %s (%s) ==> (%s)",
+ frame->root->unique, state->loc.path,
uuid_utoa (state->resolve.gfid),
strerror (op_errno));
goto out;
}
+ serv_ctx = server_ctx_get (frame->root->client, this);
+ if (serv_ctx == NULL) {
+ gf_log (this->name, GF_LOG_INFO, "server_ctx_get() failed");
+ goto out;
+ }
+
fd_bind (fd);
- fd_no = gf_fd_unused_get (conn->fdtable, fd);
+ fd_no = gf_fd_unused_get (serv_ctx->fdtable, fd);
fd_ref (fd);
rsp.fd = fd_no;
@@ -1647,6 +1535,7 @@ 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_gfs3_open_rsp);
GF_FREE (rsp.xdata.xdata_val);
@@ -1661,33 +1550,31 @@ server_create_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
struct iatt *stbuf, struct iatt *preparent,
struct iatt *postparent, dict_t *xdata)
{
- server_connection_t *conn = NULL;
server_state_t *state = NULL;
+ server_ctx_t *serv_ctx = NULL;
inode_t *link_inode = NULL;
rpcsvc_request_t *req = NULL;
uint64_t fd_no = 0;
gfs3_create_rsp rsp = {0,};
- req = frame->local;
- conn = SERVER_CONNECTION (frame);
- state = CALL_STATE (frame);
-
- GF_PROTOCOL_DICT_SERIALIZE (this, xdata, (&rsp.xdata.xdata_val),
+ 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_log (this->name, GF_LOG_INFO,
- "(conn:%s) %"PRId64": CREATE %s (%s/%s) ==> (%s)",
- conn->id, frame->root->unique, state->loc.path,
+ "%"PRId64": CREATE %s (%s/%s) ==> (%s)",
+ frame->root->unique, state->loc.path,
uuid_utoa (state->resolve.pargfid),
state->resolve.bname, strerror (op_errno));
goto out;
}
/* TODO: log gfid too */
- gf_log (state->conn->bound_xl->name, GF_LOG_TRACE,
- "(conn:%s) %"PRId64": CREATE %s (%s)",
- conn->id, frame->root->unique, state->loc.name,
+ gf_log (frame->root->client->bound_xl->name, GF_LOG_TRACE,
+ "%"PRId64": CREATE %s (%s)",
+ frame->root->unique, state->loc.name,
uuid_utoa (stbuf->ia_gfid));
link_inode = inode_link (inode, state->loc.parent,
@@ -1712,9 +1599,14 @@ server_create_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
inode_lookup (link_inode);
inode_unref (link_inode);
- fd_bind (fd);
+ serv_ctx = server_ctx_get (frame->root->client, this);
+ if (serv_ctx == NULL) {
+ gf_log (this->name, GF_LOG_INFO, "server_ctx_get() failed");
+ goto out;
+ }
- fd_no = gf_fd_unused_get (conn->fdtable, fd);
+ fd_bind (fd);
+ fd_no = gf_fd_unused_get (serv_ctx->fdtable, fd);
fd_ref (fd);
if ((fd_no < 0) || (fd == 0)) {
@@ -1731,6 +1623,7 @@ 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_gfs3_create_rsp);
@@ -1747,19 +1640,15 @@ server_readlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
gfs3_readlink_rsp rsp = {0,};
server_state_t *state = NULL;
rpcsvc_request_t *req = NULL;
- server_connection_t *conn = NULL;
- req = frame->local;
- state = CALL_STATE(frame);
- conn = SERVER_CONNECTION (frame);
-
- GF_PROTOCOL_DICT_SERIALIZE (this, xdata, (&rsp.xdata.xdata_val),
+ 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_log (this->name, GF_LOG_INFO,
- "(conn:%s) %"PRId64": READLINK %s (%s) ==> (%s)",
- conn->id, frame->root->unique, state->loc.path,
+ "%"PRId64": READLINK %s (%s) ==> (%s)",
+ frame->root->unique, state->loc.path,
uuid_utoa (state->resolve.gfid),
strerror (op_errno));
goto out;
@@ -1775,6 +1664,7 @@ out:
if (!rsp.path)
rsp.path = "";
+ req = frame->local;
server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
(xdrproc_t)xdr_gfs3_readlink_rsp);
@@ -1791,19 +1681,16 @@ server_stat_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
gfs3_stat_rsp rsp = {0,};
server_state_t *state = NULL;
rpcsvc_request_t *req = NULL;
- server_connection_t *conn = NULL;
-
- req = frame->local;
- state = CALL_STATE (frame);
- conn = SERVER_CONNECTION (frame);
- GF_PROTOCOL_DICT_SERIALIZE (this, xdata, (&rsp.xdata.xdata_val),
+ GF_PROTOCOL_DICT_SERIALIZE (this, xdata, &rsp.xdata.xdata_val,
rsp.xdata.xdata_len, op_errno, out);
if (op_ret) {
- gf_log (this->name, GF_LOG_INFO,
- "(conn:%s) %"PRId64": STAT %s (%s) ==> (%s)",
- conn->id, frame->root->unique, state->loc.path,
+ state = CALL_STATE (frame);
+ gf_log (this->name, (op_errno == ENOENT)?
+ GF_LOG_DEBUG:GF_LOG_ERROR,
+ "%"PRId64": STAT %s (%s) ==> (%s)",
+ frame->root->unique, state->loc.path,
uuid_utoa (state->resolve.gfid),
strerror (op_errno));
goto out;
@@ -1815,6 +1702,7 @@ 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_gfs3_stat_rsp);
@@ -1832,19 +1720,15 @@ server_setattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
gfs3_setattr_rsp rsp = {0,};
server_state_t *state = NULL;
rpcsvc_request_t *req = NULL;
- server_connection_t *conn = NULL;
-
- req = frame->local;
- state = CALL_STATE (frame);
- conn = SERVER_CONNECTION (frame);
- GF_PROTOCOL_DICT_SERIALIZE (this, xdata, (&rsp.xdata.xdata_val),
+ 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_log (this->name, GF_LOG_INFO,
- "(conn:%s) %"PRId64": SETATTR %s (%s) ==> (%s)",
- conn->id, frame->root->unique, state->loc.path,
+ "%"PRId64": SETATTR %s (%s) ==> (%s)",
+ frame->root->unique, state->loc.path,
uuid_utoa (state->resolve.gfid),
strerror (op_errno));
goto out;
@@ -1857,6 +1741,7 @@ 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_gfs3_setattr_rsp);
@@ -1873,19 +1758,15 @@ server_fsetattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
gfs3_fsetattr_rsp rsp = {0,};
server_state_t *state = NULL;
rpcsvc_request_t *req = NULL;
- server_connection_t *conn = NULL;
- req = frame->local;
- state = CALL_STATE (frame);
- conn = SERVER_CONNECTION (frame);
-
- GF_PROTOCOL_DICT_SERIALIZE (this, xdata, (&rsp.xdata.xdata_val),
+ 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_log (this->name, GF_LOG_INFO,
- "(conn:%s) %"PRId64": FSETATTR %"PRId64" (%s) ==> (%s)",
- conn->id, frame->root->unique, state->resolve.fd_no,
+ "%"PRId64": FSETATTR %"PRId64" (%s) ==> (%s)",
+ frame->root->unique, state->resolve.fd_no,
uuid_utoa (state->resolve.gfid),
strerror (op_errno));
goto out;
@@ -1898,6 +1779,7 @@ 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_gfs3_fsetattr_rsp);
@@ -1915,31 +1797,28 @@ server_xattrop_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
gfs3_xattrop_rsp rsp = {0,};
server_state_t *state = NULL;
rpcsvc_request_t *req = NULL;
- server_connection_t *conn = NULL;
-
- req = frame->local;
- state = CALL_STATE (frame);
- conn = SERVER_CONNECTION (frame);
- GF_PROTOCOL_DICT_SERIALIZE (this, xdata, (&rsp.xdata.xdata_val),
+ 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_log (this->name, GF_LOG_INFO,
- "(conn:%s) %"PRId64": XATTROP %s (%s) ==> (%s)",
- conn->id, frame->root->unique, state->loc.path,
+ "%"PRId64": XATTROP %s (%s) ==> (%s)",
+ frame->root->unique, state->loc.path,
uuid_utoa (state->resolve.gfid),
strerror (op_errno));
goto out;
}
- GF_PROTOCOL_DICT_SERIALIZE (this, dict, (&rsp.dict.dict_val),
+ 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);
+ req = frame->local;
server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
(xdrproc_t)xdr_gfs3_xattrop_rsp);
@@ -1959,31 +1838,28 @@ server_fxattrop_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
gfs3_xattrop_rsp rsp = {0,};
server_state_t *state = NULL;
rpcsvc_request_t *req = NULL;
- server_connection_t *conn = NULL;
- req = frame->local;
- state = CALL_STATE(frame);
- conn = SERVER_CONNECTION (frame);
-
- GF_PROTOCOL_DICT_SERIALIZE (this, xdata, (&rsp.xdata.xdata_val),
+ 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_log (this->name, GF_LOG_INFO,
- "(conn:%s) %"PRId64": FXATTROP %"PRId64" (%s) ==> (%s)",
- conn->id, frame->root->unique, state->resolve.fd_no,
+ "%"PRId64": FXATTROP %"PRId64" (%s) ==> (%s)",
+ frame->root->unique, state->resolve.fd_no,
uuid_utoa (state->resolve.gfid),
strerror (op_errno));
goto out;
}
- GF_PROTOCOL_DICT_SERIALIZE (this, dict, (&rsp.dict.dict_val),
+ 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);
+ req = frame->local;
server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
(xdrproc_t)xdr_gfs3_fxattrop_rsp);
@@ -2004,19 +1880,15 @@ server_readdirp_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
server_state_t *state = NULL;
rpcsvc_request_t *req = NULL;
int ret = 0;
- server_connection_t *conn = NULL;
- req = frame->local;
- state = CALL_STATE(frame);
- conn = SERVER_CONNECTION (frame);
-
- GF_PROTOCOL_DICT_SERIALIZE (this, xdata, (&rsp.xdata.xdata_val),
+ 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_log (this->name, GF_LOG_INFO,
- "(conn:%s) %"PRId64": READDIRP %"PRId64" (%s) ==> (%s)",
- conn->id, frame->root->unique, state->resolve.fd_no,
+ "%"PRId64": READDIRP %"PRId64" (%s) ==> (%s)",
+ frame->root->unique, state->resolve.fd_no,
uuid_utoa (state->resolve.gfid),
strerror (op_errno));
goto out;
@@ -2039,6 +1911,7 @@ 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_gfs3_readdirp_rsp);
@@ -2058,13 +1931,11 @@ server_fallocate_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
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),
+ 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_log (this->name, GF_LOG_INFO,
"%"PRId64": FALLOCATE %"PRId64" (%s) ==> (%s)",
frame->root->unique, state->resolve.fd_no,
@@ -2080,6 +1951,7 @@ 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_gfs3_fallocate_rsp);
@@ -2093,10 +1965,48 @@ 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,};
+ 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_log (this->name, GF_LOG_INFO,
+ "%"PRId64": DISCARD %"PRId64" (%s) ==> (%s)",
+ frame->root->unique, state->resolve.fd_no,
+ uuid_utoa (state->resolve.gfid),
+ strerror (op_errno));
+ goto out;
+ }
+
+ gf_stat_from_iatt (&rsp.statpre, statpre);
+ gf_stat_from_iatt (&rsp.statpost, statpost);
+
+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_gfs3_discard_rsp);
+
+ GF_FREE (rsp.xdata.xdata_val);
+
+ 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);
@@ -2105,7 +2015,7 @@ server_discard_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
if (op_ret) {
gf_log (this->name, GF_LOG_INFO,
- "%"PRId64": DISCARD %"PRId64" (%s) ==> (%s)",
+ "%"PRId64": ZEROFILL%"PRId64" (%s) ==> (%s)",
frame->root->unique, state->resolve.fd_no,
uuid_utoa (state->resolve.gfid),
strerror (op_errno));
@@ -2120,13 +2030,14 @@ out:
rsp.op_errno = gf_errno_to_error (op_errno);
server_submit_reply(frame, req, &rsp, NULL, 0, NULL,
- (xdrproc_t) xdr_gfs3_discard_rsp);
+ (xdrproc_t) xdr_gfs3_zerofill_rsp);
GF_FREE (rsp.xdata.xdata_val);
return 0;
}
+
/* Resume function section */
int
@@ -2290,6 +2201,7 @@ err:
int
server_fentrylk_resume (call_frame_t *frame, xlator_t *bound_xl)
{
+ GF_UNUSED int ret = -1;
server_state_t *state = NULL;
state = CALL_STATE (frame);
@@ -2297,6 +2209,13 @@ server_fentrylk_resume (call_frame_t *frame, xlator_t *bound_xl)
if (state->resolve.op_ret != 0)
goto err;
+ if (!state->xdata)
+ state->xdata = dict_new ();
+
+ 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,
@@ -2313,6 +2232,7 @@ err:
int
server_entrylk_resume (call_frame_t *frame, xlator_t *bound_xl)
{
+ GF_UNUSED int ret = -1;
server_state_t *state = NULL;
state = CALL_STATE (frame);
@@ -2320,6 +2240,13 @@ server_entrylk_resume (call_frame_t *frame, xlator_t *bound_xl)
if (state->resolve.op_ret != 0)
goto err;
+ if (!state->xdata)
+ state->xdata = dict_new ();
+
+ 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,
@@ -2335,13 +2262,24 @@ err:
int
server_finodelk_resume (call_frame_t *frame, xlator_t *bound_xl)
{
+ GF_UNUSED int ret = -1;
server_state_t *state = NULL;
+ gf_log (bound_xl->name, GF_LOG_WARNING, "frame %p, xlator %p",
+ frame, bound_xl);
+
state = CALL_STATE (frame);
if (state->resolve.op_ret != 0)
goto err;
+ if (!state->xdata)
+ state->xdata = dict_new ();
+
+ 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);
@@ -2357,13 +2295,24 @@ err:
int
server_inodelk_resume (call_frame_t *frame, xlator_t *bound_xl)
{
+ GF_UNUSED int ret = -1;
server_state_t *state = NULL;
+ gf_log (bound_xl->name, GF_LOG_WARNING, "frame %p, xlator %p",
+ frame, bound_xl);
+
state = CALL_STATE (frame);
if (state->resolve.op_ret != 0)
goto err;
+ if (!state->xdata)
+ state->xdata = dict_new ();
+
+ 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);
@@ -3085,11 +3034,11 @@ server_fallocate_resume (call_frame_t *frame, xlator_t *bound_xl)
STACK_WIND (frame, server_fallocate_cbk,
bound_xl, bound_xl->fops->fallocate,
state->fd, state->flags, state->offset, state->size,
- state->xdata);
+ state->xdata);
return 0;
err:
server_fallocate_cbk(frame, NULL, frame->this, state->resolve.op_ret,
- state->resolve.op_errno, NULL, NULL, NULL);
+ state->resolve.op_errno, NULL, NULL, NULL);
return 0;
}
@@ -3110,12 +3059,34 @@ server_discard_resume (call_frame_t *frame, xlator_t *bound_xl)
return 0;
err:
server_discard_cbk(frame, NULL, frame->this, state->resolve.op_ret,
- state->resolve.op_errno, NULL, NULL, NULL);
+ state->resolve.op_errno, NULL, NULL, NULL);
+
+ return 0;
+}
+
+int
+server_zerofill_resume (call_frame_t *frame, xlator_t *bound_xl)
+{
+ server_state_t *state = NULL;
+
+ state = CALL_STATE (frame);
+
+ 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;
+err:
+ server_zerofill_cbk(frame, NULL, frame->this, state->resolve.op_ret,
+ state->resolve.op_errno, NULL, NULL, NULL);
return 0;
}
+
/* Fop section */
int
@@ -3135,31 +3106,31 @@ server3_3_stat (rpcsvc_request_t *req)
ret = xdr_to_generic (req->msg[0], &args, (xdrproc_t)xdr_gfs3_stat_req);
if (ret < 0) {
//failed to decode msg;
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
frame = get_frame_from_request (req);
if (!frame) {
- // something wrong, mostly insufficient memory
- req->rpc_err = GARBAGE_ARGS; /* TODO */
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
frame->root->op = GF_FOP_STAT;
state = CALL_STATE (frame);
- if (!state->conn->bound_xl) {
+ if (!frame->root->client->bound_xl) {
/* auth failure, request on subvolume without setvolume */
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
state->resolve.type = RESOLVE_MUST;
memcpy (state->resolve.gfid, args.gfid, 16);
- GF_PROTOCOL_DICT_UNSERIALIZE (state->conn->bound_xl, state->xdata,
- (args.xdata.xdata_val),
- (args.xdata.xdata_len), ret,
+ GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
+ state->xdata,
+ args.xdata.xdata_val,
+ args.xdata.xdata_len, ret,
op_errno, out);
@@ -3170,7 +3141,7 @@ out:
free (args.xdata.xdata_val);
if (op_errno)
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
return ret;
}
@@ -3192,22 +3163,22 @@ server3_3_setattr (rpcsvc_request_t *req)
(xdrproc_t)xdr_gfs3_setattr_req);
if (ret < 0) {
//failed to decode msg;
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
frame = get_frame_from_request (req);
if (!frame) {
// something wrong, mostly insufficient memory
- req->rpc_err = GARBAGE_ARGS; /* TODO */
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
frame->root->op = GF_FOP_SETATTR;
state = CALL_STATE (frame);
- if (!state->conn->bound_xl) {
+ if (!frame->root->client->bound_xl) {
/* auth failure, request on subvolume without setvolume */
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
@@ -3217,9 +3188,10 @@ server3_3_setattr (rpcsvc_request_t *req)
gf_stat_to_iatt (&args.stbuf, &state->stbuf);
state->valid = args.valid;
- GF_PROTOCOL_DICT_UNSERIALIZE (state->conn->bound_xl, state->xdata,
- (args.xdata.xdata_val),
- (args.xdata.xdata_len), ret,
+ 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;
@@ -3227,7 +3199,7 @@ server3_3_setattr (rpcsvc_request_t *req)
out:
if (op_errno)
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
free (args.xdata.xdata_val);
@@ -3251,22 +3223,21 @@ server3_3_fsetattr (rpcsvc_request_t *req)
(xdrproc_t)xdr_gfs3_fsetattr_req);
if (ret < 0) {
//failed to decode msg;
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
frame = get_frame_from_request (req);
if (!frame) {
- // something wrong, mostly insufficient memory
- req->rpc_err = GARBAGE_ARGS; /* TODO */
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
frame->root->op = GF_FOP_FSETATTR;
state = CALL_STATE (frame);
- if (!state->conn->bound_xl) {
+ if (!frame->root->client->bound_xl) {
/* auth failure, request on subvolume without setvolume */
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
@@ -3276,9 +3247,10 @@ server3_3_fsetattr (rpcsvc_request_t *req)
gf_stat_to_iatt (&args.stbuf, &state->stbuf);
state->valid = args.valid;
- GF_PROTOCOL_DICT_UNSERIALIZE (state->conn->bound_xl, state->xdata,
- (args.xdata.xdata_val),
- (args.xdata.xdata_len), ret,
+ 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;
@@ -3288,7 +3260,7 @@ out:
free (args.xdata.xdata_val);
if (op_errno)
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
return ret;
}
@@ -3309,36 +3281,37 @@ server3_3_fallocate(rpcsvc_request_t *req)
(xdrproc_t)xdr_gfs3_fallocate_req);
if (ret < 0) {
//failed to decode msg;
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
frame = get_frame_from_request (req);
if (!frame) {
// something wrong, mostly insufficient memory
- req->rpc_err = GARBAGE_ARGS; /* TODO */
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
frame->root->op = GF_FOP_FALLOCATE;
state = CALL_STATE (frame);
- if (!state->conn->bound_xl) {
+ if (!frame->root->client->bound_xl) {
/* auth failure, request on subvolume without setvolume */
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
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 (state->conn->bound_xl, state->xdata,
- (args.xdata.xdata_val),
- (args.xdata.xdata_len), ret,
+ 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;
@@ -3348,7 +3321,7 @@ out:
free (args.xdata.xdata_val);
if (op_errno)
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
return ret;
}
@@ -3359,7 +3332,7 @@ server3_3_discard(rpcsvc_request_t *req)
{
server_state_t *state = NULL;
call_frame_t *frame = NULL;
- gfs3_discard_req args = {{0},};
+ gfs3_discard_req args = {{0},};
int ret = -1;
int op_errno = 0;
@@ -3370,20 +3343,81 @@ server3_3_discard(rpcsvc_request_t *req)
(xdrproc_t)xdr_gfs3_discard_req);
if (ret < 0) {
//failed to decode msg;
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
frame = get_frame_from_request (req);
if (!frame) {
// something wrong, mostly insufficient memory
- req->rpc_err = GARBAGE_ARGS; /* TODO */
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
frame->root->op = GF_FOP_DISCARD;
state = CALL_STATE (frame);
- if (!state->conn->bound_xl) {
+ if (!frame->root->client->bound_xl) {
+ /* auth failure, request on subvolume without setvolume */
+ SERVER_REQ_SET_ERROR (req, ret);
+ goto out;
+ }
+
+ 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);
+
+ 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);
+
+out:
+ free (args.xdata.xdata_val);
+
+ if (op_errno)
+ SERVER_REQ_SET_ERROR (req, 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;
+
+ if (!req)
+ return ret;
+
+ ret = xdr_to_generic (req->msg[0], &args,
+ (xdrproc_t)xdr_gfs3_zerofill_req);
+ if (ret < 0) {
+ /*failed to decode msg*/;
+ req->rpc_err = GARBAGE_ARGS;
+ goto out;
+ }
+
+ frame = get_frame_from_request (req);
+ if (!frame) {
+ /* something wrong, mostly insufficient memory*/
+ req->rpc_err = GARBAGE_ARGS; /* TODO */
+ goto out;
+ }
+ frame->root->op = GF_FOP_ZEROFILL;
+
+ state = CALL_STATE (frame);
+ if (!frame->root->client->bound_xl) {
/* auth failure, request on subvolume without setvolume */
req->rpc_err = GARBAGE_ARGS;
goto out;
@@ -3392,17 +3426,17 @@ server3_3_discard(rpcsvc_request_t *req)
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 (state->conn->bound_xl, state->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_discard_resume);
+ resolve_and_resume (frame, server_zerofill_resume);
out:
free (args.xdata.xdata_val);
@@ -3413,7 +3447,6 @@ out:
return ret;
}
-
int
server3_3_readlink (rpcsvc_request_t *req)
{
@@ -3430,22 +3463,22 @@ server3_3_readlink (rpcsvc_request_t *req)
(xdrproc_t)xdr_gfs3_readlink_req);
if (ret < 0) {
//failed to decode msg;
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
frame = get_frame_from_request (req);
if (!frame) {
// something wrong, mostly insufficient memory
- req->rpc_err = GARBAGE_ARGS; /* TODO */
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
frame->root->op = GF_FOP_READLINK;
state = CALL_STATE (frame);
- if (!state->conn->bound_xl) {
+ if (!frame->root->client->bound_xl) {
/* auth failure, request on subvolume without setvolume */
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
@@ -3454,9 +3487,10 @@ server3_3_readlink (rpcsvc_request_t *req)
state->size = args.size;
- GF_PROTOCOL_DICT_UNSERIALIZE (state->conn->bound_xl, state->xdata,
- (args.xdata.xdata_val),
- (args.xdata.xdata_len), ret,
+ 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;
@@ -3466,7 +3500,7 @@ out:
free (args.xdata.xdata_val);
if (op_errno)
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
return ret;
}
@@ -3490,22 +3524,22 @@ server3_3_create (rpcsvc_request_t *req)
(xdrproc_t)xdr_gfs3_create_req);
if (ret < 0) {
//failed to decode msg;
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
frame = get_frame_from_request (req);
if (!frame) {
// something wrong, mostly insufficient memory
- req->rpc_err = GARBAGE_ARGS; /* TODO */
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
frame->root->op = GF_FOP_CREATE;
state = CALL_STATE (frame);
- if (!state->conn->bound_xl) {
+ if (!frame->root->client->bound_xl) {
/* auth failure, request on subvolume without setvolume */
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
@@ -3523,9 +3557,10 @@ server3_3_create (rpcsvc_request_t *req)
}
/* TODO: can do alloca for xdata field instead of stdalloc */
- GF_PROTOCOL_DICT_UNSERIALIZE (state->conn->bound_xl, state->xdata,
- (args.xdata.xdata_val),
- (args.xdata.xdata_len), ret,
+ 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;
@@ -3536,7 +3571,7 @@ out:
free (args.xdata.xdata_val);
if (op_errno)
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
return ret;
}
@@ -3557,22 +3592,22 @@ server3_3_open (rpcsvc_request_t *req)
ret = xdr_to_generic (req->msg[0], &args, (xdrproc_t)xdr_gfs3_open_req);
if (ret < 0) {
//failed to decode msg;
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
frame = get_frame_from_request (req);
if (!frame) {
// something wrong, mostly insufficient memory
- req->rpc_err = GARBAGE_ARGS; /* TODO */
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
frame->root->op = GF_FOP_OPEN;
state = CALL_STATE (frame);
- if (!state->conn->bound_xl) {
+ if (!frame->root->client->bound_xl) {
/* auth failure, request on subvolume without setvolume */
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
@@ -3581,16 +3616,17 @@ server3_3_open (rpcsvc_request_t *req)
state->flags = gf_flags_to_flags (args.flags);
- GF_PROTOCOL_DICT_UNSERIALIZE (state->conn->bound_xl, state->xdata,
- (args.xdata.xdata_val),
- (args.xdata.xdata_len), ret,
+ 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);
out:
if (op_errno)
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
free (args.xdata.xdata_val);
@@ -3613,22 +3649,22 @@ server3_3_readv (rpcsvc_request_t *req)
ret = xdr_to_generic (req->msg[0], &args, (xdrproc_t)xdr_gfs3_read_req);
if (ret < 0) {
//failed to decode msg;
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
frame = get_frame_from_request (req);
if (!frame) {
// something wrong, mostly insufficient memory
- req->rpc_err = GARBAGE_ARGS; /* TODO */
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
frame->root->op = GF_FOP_READ;
state = CALL_STATE (frame);
- if (!state->conn->bound_xl) {
+ if (!frame->root->client->bound_xl) {
/* auth failure, request on subvolume without setvolume */
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
@@ -3640,9 +3676,10 @@ server3_3_readv (rpcsvc_request_t *req)
memcpy (state->resolve.gfid, args.gfid, 16);
- GF_PROTOCOL_DICT_UNSERIALIZE (state->conn->bound_xl, state->xdata,
- (args.xdata.xdata_val),
- (args.xdata.xdata_len), ret,
+ 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;
@@ -3652,7 +3689,7 @@ out:
free (args.xdata.xdata_val);
if (op_errno)
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
return ret;
}
@@ -3676,22 +3713,22 @@ server3_3_writev (rpcsvc_request_t *req)
(xdrproc_t)xdr_gfs3_write_req);
if (len < 0) {
//failed to decode msg;
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
frame = get_frame_from_request (req);
if (!frame) {
// something wrong, mostly insufficient memory
- req->rpc_err = GARBAGE_ARGS; /* TODO */
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
frame->root->op = GF_FOP_WRITE;
state = CALL_STATE (frame);
- if (!state->conn->bound_xl) {
+ if (!frame->root->client->bound_xl) {
/* auth failure, request on subvolume without setvolume */
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
@@ -3719,9 +3756,10 @@ server3_3_writev (rpcsvc_request_t *req)
state->size += state->payload_vector[i].iov_len;
}
- GF_PROTOCOL_DICT_UNSERIALIZE (state->conn->bound_xl, state->xdata,
- (args.xdata.xdata_val),
- (args.xdata.xdata_len), ret,
+ 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
@@ -3734,7 +3772,7 @@ out:
free (args.xdata.xdata_val);
if (op_errno)
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
return ret;
}
@@ -3800,26 +3838,36 @@ server3_3_writev_vecsizer (int state, ssize_t *readsize, char *base_addr,
int
server3_3_release (rpcsvc_request_t *req)
{
- server_connection_t *conn = NULL;
- gfs3_release_req args = {{0,},};
- gf_common_rsp rsp = {0,};
- int ret = -1;
+ 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;
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
- conn = req->trans->xl_private;
- if (!conn) {
+ client = req->trans->xl_private;
+ if (!client) {
/* Handshake is not complete yet. */
req->rpc_err = SYSTEM_ERR;
goto out;
}
- gf_fd_put (conn->fdtable, args.fd);
+
+ serv_ctx = server_ctx_get (client, client->this);
+ if (serv_ctx == NULL) {
+ gf_log (req->trans->name, GF_LOG_INFO,
+ "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);
@@ -3832,26 +3880,35 @@ out:
int
server3_3_releasedir (rpcsvc_request_t *req)
{
- server_connection_t *conn = NULL;
- gfs3_releasedir_req args = {{0,},};
- gf_common_rsp rsp = {0,};
- int ret = -1;
+ 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;
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
- conn = req->trans->xl_private;
- if (!conn) {
- req->rpc_err = GARBAGE_ARGS;
+ client = req->trans->xl_private;
+ if (!client) {
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
- gf_fd_put (conn->fdtable, args.fd);
+ serv_ctx = server_ctx_get (client, client->this);
+ if (serv_ctx == NULL) {
+ gf_log (req->trans->name, GF_LOG_INFO,
+ "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);
@@ -3878,22 +3935,22 @@ server3_3_fsync (rpcsvc_request_t *req)
(xdrproc_t)xdr_gfs3_fsync_req);
if (ret < 0) {
//failed to decode msg;
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
frame = get_frame_from_request (req);
if (!frame) {
// something wrong, mostly insufficient memory
- req->rpc_err = GARBAGE_ARGS; /* TODO */
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
frame->root->op = GF_FOP_FSYNC;
state = CALL_STATE (frame);
- if (!state->conn->bound_xl) {
+ if (!frame->root->client->bound_xl) {
/* auth failure, request on subvolume without setvolume */
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
@@ -3902,9 +3959,10 @@ server3_3_fsync (rpcsvc_request_t *req)
state->flags = args.data;
memcpy (state->resolve.gfid, args.gfid, 16);
- GF_PROTOCOL_DICT_UNSERIALIZE (state->conn->bound_xl, state->xdata,
- (args.xdata.xdata_val),
- (args.xdata.xdata_len), ret,
+ 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;
@@ -3913,7 +3971,7 @@ out:
free (args.xdata.xdata_val);
if (op_errno)
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
return ret;
}
@@ -3936,22 +3994,22 @@ server3_3_flush (rpcsvc_request_t *req)
(xdrproc_t)xdr_gfs3_flush_req);
if (ret < 0) {
//failed to decode msg;
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
frame = get_frame_from_request (req);
if (!frame) {
// something wrong, mostly insufficient memory
- req->rpc_err = GARBAGE_ARGS; /* TODO */
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
frame->root->op = GF_FOP_FLUSH;
state = CALL_STATE (frame);
- if (!state->conn->bound_xl) {
+ if (!frame->root->client->bound_xl) {
/* auth failure, request on subvolume without setvolume */
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
@@ -3959,9 +4017,10 @@ server3_3_flush (rpcsvc_request_t *req)
state->resolve.fd_no = args.fd;
memcpy (state->resolve.gfid, args.gfid, 16);
- GF_PROTOCOL_DICT_UNSERIALIZE (state->conn->bound_xl, state->xdata,
- (args.xdata.xdata_val),
- (args.xdata.xdata_len), ret,
+ 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;
@@ -3970,7 +4029,7 @@ out:
free (args.xdata.xdata_val);
if (op_errno)
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
return ret;
}
@@ -3993,22 +4052,22 @@ server3_3_ftruncate (rpcsvc_request_t *req)
(xdrproc_t)xdr_gfs3_ftruncate_req);
if (ret < 0) {
//failed to decode msg;
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
frame = get_frame_from_request (req);
if (!frame) {
// something wrong, mostly insufficient memory
- req->rpc_err = GARBAGE_ARGS; /* TODO */
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
frame->root->op = GF_FOP_FTRUNCATE;
state = CALL_STATE (frame);
- if (!state->conn->bound_xl) {
+ if (!frame->root->client->bound_xl) {
/* auth failure, request on subvolume without setvolume */
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
@@ -4017,9 +4076,10 @@ server3_3_ftruncate (rpcsvc_request_t *req)
state->offset = args.offset;
memcpy (state->resolve.gfid, args.gfid, 16);
- GF_PROTOCOL_DICT_UNSERIALIZE (state->conn->bound_xl, state->xdata,
- (args.xdata.xdata_val),
- (args.xdata.xdata_len), ret,
+ 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;
@@ -4028,7 +4088,7 @@ out:
free (args.xdata.xdata_val);
if (op_errno)
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
return ret;
}
@@ -4050,22 +4110,22 @@ server3_3_fstat (rpcsvc_request_t *req)
(xdrproc_t)xdr_gfs3_fstat_req);
if (ret < 0) {
//failed to decode msg;
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
frame = get_frame_from_request (req);
if (!frame) {
// something wrong, mostly insufficient memory
- req->rpc_err = GARBAGE_ARGS; /* TODO */
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
frame->root->op = GF_FOP_FSTAT;
state = CALL_STATE (frame);
- if (!state->conn->bound_xl) {
+ if (!frame->root->client->bound_xl) {
/* auth failure, request on subvolume without setvolume */
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
@@ -4073,9 +4133,10 @@ server3_3_fstat (rpcsvc_request_t *req)
state->resolve.fd_no = args.fd;
memcpy (state->resolve.gfid, args.gfid, 16);
- GF_PROTOCOL_DICT_UNSERIALIZE (state->conn->bound_xl, state->xdata,
- (args.xdata.xdata_val),
- (args.xdata.xdata_len), ret,
+ 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;
@@ -4084,7 +4145,7 @@ out:
free (args.xdata.xdata_val);
if (op_errno)
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
return ret;
}
@@ -4106,22 +4167,22 @@ server3_3_truncate (rpcsvc_request_t *req)
(xdrproc_t)xdr_gfs3_truncate_req);
if (ret < 0) {
//failed to decode msg;
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
frame = get_frame_from_request (req);
if (!frame) {
// something wrong, mostly insufficient memory
- req->rpc_err = GARBAGE_ARGS; /* TODO */
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
frame->root->op = GF_FOP_TRUNCATE;
state = CALL_STATE (frame);
- if (!state->conn->bound_xl) {
+ if (!frame->root->client->bound_xl) {
/* auth failure, request on subvolume without setvolume */
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
@@ -4129,9 +4190,10 @@ server3_3_truncate (rpcsvc_request_t *req)
memcpy (state->resolve.gfid, args.gfid, 16);
state->offset = args.offset;
- GF_PROTOCOL_DICT_UNSERIALIZE (state->conn->bound_xl, state->xdata,
- (args.xdata.xdata_val),
- (args.xdata.xdata_len), ret,
+ 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;
@@ -4140,7 +4202,7 @@ out:
free (args.xdata.xdata_val);
if (op_errno)
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
return ret;
}
@@ -4165,22 +4227,22 @@ server3_3_unlink (rpcsvc_request_t *req)
(xdrproc_t)xdr_gfs3_unlink_req);
if (ret < 0) {
//failed to decode msg;
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
frame = get_frame_from_request (req);
if (!frame) {
// something wrong, mostly insufficient memory
- req->rpc_err = GARBAGE_ARGS; /* TODO */
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
frame->root->op = GF_FOP_UNLINK;
state = CALL_STATE (frame);
- if (!state->conn->bound_xl) {
+ if (!frame->root->client->bound_xl) {
/* auth failure, request on subvolume without setvolume */
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
@@ -4190,9 +4252,10 @@ server3_3_unlink (rpcsvc_request_t *req)
state->flags = args.xflags;
- GF_PROTOCOL_DICT_UNSERIALIZE (state->conn->bound_xl, state->xdata,
- (args.xdata.xdata_val),
- (args.xdata.xdata_len), ret,
+ 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;
@@ -4201,7 +4264,7 @@ out:
free (args.xdata.xdata_val);
if (op_errno)
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
return ret;
}
@@ -4226,22 +4289,22 @@ server3_3_setxattr (rpcsvc_request_t *req)
(xdrproc_t)xdr_gfs3_setxattr_req);
if (ret < 0) {
//failed to decode msg;
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
frame = get_frame_from_request (req);
if (!frame) {
// something wrong, mostly insufficient memory
- req->rpc_err = GARBAGE_ARGS; /* TODO */
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
frame->root->op = GF_FOP_SETXATTR;
state = CALL_STATE (frame);
- if (!state->conn->bound_xl) {
+ if (!frame->root->client->bound_xl) {
/* auth failure, request on subvolume without setvolume */
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
@@ -4249,7 +4312,8 @@ server3_3_setxattr (rpcsvc_request_t *req)
state->flags = args.flags;
memcpy (state->resolve.gfid, args.gfid, 16);
- GF_PROTOCOL_DICT_UNSERIALIZE (state->conn->bound_xl, dict,
+ GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
+ dict,
(args.dict.dict_val),
(args.dict.dict_len), ret,
op_errno, out);
@@ -4259,9 +4323,10 @@ server3_3_setxattr (rpcsvc_request_t *req)
/* There can be some commands hidden in key, check and proceed */
gf_server_check_setxattr_cmd (frame, dict);
- GF_PROTOCOL_DICT_UNSERIALIZE (state->conn->bound_xl, state->xdata,
- (args.xdata.xdata_val),
- (args.xdata.xdata_len), ret,
+ 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;
@@ -4272,7 +4337,7 @@ out:
free (args.xdata.xdata_val);
if (op_errno)
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
if (dict)
dict_unref (dict);
@@ -4300,22 +4365,22 @@ server3_3_fsetxattr (rpcsvc_request_t *req)
(xdrproc_t)xdr_gfs3_fsetxattr_req);
if (ret < 0) {
//failed to decode msg;
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
frame = get_frame_from_request (req);
if (!frame) {
// something wrong, mostly insufficient memory
- req->rpc_err = GARBAGE_ARGS; /* TODO */
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
frame->root->op = GF_FOP_FSETXATTR;
state = CALL_STATE (frame);
- if (!state->conn->bound_xl) {
+ if (!frame->root->client->bound_xl) {
/* auth failure, request on subvolume without setvolume */
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
@@ -4324,16 +4389,18 @@ server3_3_fsetxattr (rpcsvc_request_t *req)
state->flags = args.flags;
memcpy (state->resolve.gfid, args.gfid, 16);
- GF_PROTOCOL_DICT_UNSERIALIZE (state->conn->bound_xl, dict,
+ 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;
- GF_PROTOCOL_DICT_UNSERIALIZE (state->conn->bound_xl, state->xdata,
- (args.xdata.xdata_val),
- (args.xdata.xdata_len), ret,
+ 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;
@@ -4344,7 +4411,7 @@ out:
free (args.xdata.xdata_val);
if (op_errno)
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
if (dict)
dict_unref (dict);
@@ -4372,22 +4439,22 @@ server3_3_fxattrop (rpcsvc_request_t *req)
(xdrproc_t)xdr_gfs3_fxattrop_req);
if (ret < 0) {
//failed to decode msg;
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
frame = get_frame_from_request (req);
if (!frame) {
// something wrong, mostly insufficient memory
- req->rpc_err = GARBAGE_ARGS; /* TODO */
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
frame->root->op = GF_FOP_FXATTROP;
- state = CALL_STATE(frame);
- if (!state->conn->bound_xl) {
+ state = CALL_STATE (frame);
+ if (!frame->root->client->bound_xl) {
/* auth failure, request on subvolume without setvolume */
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
@@ -4396,16 +4463,18 @@ server3_3_fxattrop (rpcsvc_request_t *req)
state->flags = args.flags;
memcpy (state->resolve.gfid, args.gfid, 16);
- GF_PROTOCOL_DICT_UNSERIALIZE (state->conn->bound_xl, dict,
+ 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;
- GF_PROTOCOL_DICT_UNSERIALIZE (state->conn->bound_xl, state->xdata,
- (args.xdata.xdata_val),
- (args.xdata.xdata_len), ret,
+ 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;
@@ -4417,7 +4486,7 @@ out:
free (args.xdata.xdata_val);
if (op_errno)
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
if (dict)
dict_unref (dict);
@@ -4446,22 +4515,22 @@ server3_3_xattrop (rpcsvc_request_t *req)
(xdrproc_t)xdr_gfs3_xattrop_req);
if (ret < 0) {
//failed to decode msg;
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
frame = get_frame_from_request (req);
if (!frame) {
// something wrong, mostly insufficient memory
- req->rpc_err = GARBAGE_ARGS; /* TODO */
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
frame->root->op = GF_FOP_XATTROP;
- state = CALL_STATE(frame);
- if (!state->conn->bound_xl) {
+ state = CALL_STATE (frame);
+ if (!frame->root->client->bound_xl) {
/* auth failure, request on subvolume without setvolume */
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
@@ -4469,16 +4538,18 @@ server3_3_xattrop (rpcsvc_request_t *req)
state->flags = args.flags;
memcpy (state->resolve.gfid, args.gfid, 16);
- GF_PROTOCOL_DICT_UNSERIALIZE (state->conn->bound_xl, dict,
+ 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;
- GF_PROTOCOL_DICT_UNSERIALIZE (state->conn->bound_xl, state->xdata,
- (args.xdata.xdata_val),
- (args.xdata.xdata_len), ret,
+ 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;
@@ -4489,7 +4560,7 @@ out:
free (args.xdata.xdata_val);
if (op_errno)
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
if (dict)
dict_unref (dict);
@@ -4516,22 +4587,22 @@ server3_3_getxattr (rpcsvc_request_t *req)
(xdrproc_t)xdr_gfs3_getxattr_req);
if (ret < 0) {
//failed to decode msg;
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
frame = get_frame_from_request (req);
if (!frame) {
// something wrong, mostly insufficient memory
- req->rpc_err = GARBAGE_ARGS; /* TODO */
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
frame->root->op = GF_FOP_GETXATTR;
state = CALL_STATE (frame);
- if (!state->conn->bound_xl) {
+ if (!frame->root->client->bound_xl) {
/* auth failure, request on subvolume without setvolume */
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
@@ -4544,9 +4615,10 @@ server3_3_getxattr (rpcsvc_request_t *req)
gf_server_check_getxattr_cmd (frame, state->name);
}
- GF_PROTOCOL_DICT_UNSERIALIZE (state->conn->bound_xl, state->xdata,
- (args.xdata.xdata_val),
- (args.xdata.xdata_len), ret,
+ 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;
@@ -4555,7 +4627,7 @@ out:
free (args.xdata.xdata_val);
if (op_errno)
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
return ret;
}
@@ -4578,22 +4650,22 @@ server3_3_fgetxattr (rpcsvc_request_t *req)
(xdrproc_t)xdr_gfs3_fgetxattr_req);
if (ret < 0) {
//failed to decode msg;
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
frame = get_frame_from_request (req);
if (!frame) {
// something wrong, mostly insufficient memory
- req->rpc_err = GARBAGE_ARGS; /* TODO */
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
frame->root->op = GF_FOP_FGETXATTR;
state = CALL_STATE (frame);
- if (!state->conn->bound_xl) {
+ if (!frame->root->client->bound_xl) {
/* auth failure, request on subvolume without setvolume */
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
@@ -4604,9 +4676,10 @@ server3_3_fgetxattr (rpcsvc_request_t *req)
if (args.namelen)
state->name = gf_strdup (args.name);
- GF_PROTOCOL_DICT_UNSERIALIZE (state->conn->bound_xl, state->xdata,
- (args.xdata.xdata_val),
- (args.xdata.xdata_len), ret,
+ 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;
@@ -4615,7 +4688,7 @@ out:
free (args.xdata.xdata_val);
if (op_errno)
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
return ret;
}
@@ -4640,22 +4713,22 @@ server3_3_removexattr (rpcsvc_request_t *req)
(xdrproc_t)xdr_gfs3_removexattr_req);
if (ret < 0) {
//failed to decode msg;
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
frame = get_frame_from_request (req);
if (!frame) {
// something wrong, mostly insufficient memory
- req->rpc_err = GARBAGE_ARGS; /* TODO */
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
frame->root->op = GF_FOP_REMOVEXATTR;
state = CALL_STATE (frame);
- if (!state->conn->bound_xl) {
+ if (!frame->root->client->bound_xl) {
/* auth failure, request on subvolume without setvolume */
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
@@ -4663,9 +4736,10 @@ server3_3_removexattr (rpcsvc_request_t *req)
memcpy (state->resolve.gfid, args.gfid, 16);
state->name = gf_strdup (args.name);
- GF_PROTOCOL_DICT_UNSERIALIZE (state->conn->bound_xl, state->xdata,
- (args.xdata.xdata_val),
- (args.xdata.xdata_len), ret,
+ 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;
@@ -4674,7 +4748,7 @@ out:
free (args.xdata.xdata_val);
if (op_errno)
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
return ret;
}
@@ -4697,22 +4771,22 @@ server3_3_fremovexattr (rpcsvc_request_t *req)
(xdrproc_t)xdr_gfs3_fremovexattr_req);
if (ret < 0) {
//failed to decode msg;
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
frame = get_frame_from_request (req);
if (!frame) {
// something wrong, mostly insufficient memory
- req->rpc_err = GARBAGE_ARGS; /* TODO */
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
frame->root->op = GF_FOP_FREMOVEXATTR;
state = CALL_STATE (frame);
- if (!state->conn->bound_xl) {
+ if (!frame->root->client->bound_xl) {
/* auth failure, request on subvolume without setvolume */
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
@@ -4721,9 +4795,10 @@ server3_3_fremovexattr (rpcsvc_request_t *req)
memcpy (state->resolve.gfid, args.gfid, 16);
state->name = gf_strdup (args.name);
- GF_PROTOCOL_DICT_UNSERIALIZE (state->conn->bound_xl, state->xdata,
- (args.xdata.xdata_val),
- (args.xdata.xdata_len), ret,
+ 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;
@@ -4732,7 +4807,7 @@ out:
free (args.xdata.xdata_val);
if (op_errno)
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
return ret;
}
@@ -4756,31 +4831,32 @@ server3_3_opendir (rpcsvc_request_t *req)
(xdrproc_t)xdr_gfs3_opendir_req);
if (ret < 0) {
//failed to decode msg;
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
frame = get_frame_from_request (req);
if (!frame) {
// something wrong, mostly insufficient memory
- req->rpc_err = GARBAGE_ARGS; /* TODO */
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
frame->root->op = GF_FOP_OPENDIR;
state = CALL_STATE (frame);
- if (!state->conn->bound_xl) {
+ if (!frame->root->client->bound_xl) {
/* auth failure, request on subvolume without setvolume */
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
state->resolve.type = RESOLVE_MUST;
memcpy (state->resolve.gfid, args.gfid, 16);
- GF_PROTOCOL_DICT_UNSERIALIZE (state->conn->bound_xl, state->xdata,
- (args.xdata.xdata_val),
- (args.xdata.xdata_len), ret,
+ 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;
@@ -4789,7 +4865,7 @@ out:
free (args.xdata.xdata_val);
if (op_errno)
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
return ret;
}
@@ -4812,22 +4888,22 @@ server3_3_readdirp (rpcsvc_request_t *req)
(xdrproc_t)xdr_gfs3_readdirp_req);
if (ret < 0) {
//failed to decode msg;
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
frame = get_frame_from_request (req);
if (!frame) {
// something wrong, mostly insufficient memory
- req->rpc_err = GARBAGE_ARGS; /* TODO */
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
frame->root->op = GF_FOP_READDIRP;
- state = CALL_STATE(frame);
- if (!state->conn->bound_xl) {
+ state = CALL_STATE (frame);
+ if (!frame->root->client->bound_xl) {
/* auth failure, request on subvolume without setvolume */
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
@@ -4848,7 +4924,8 @@ server3_3_readdirp (rpcsvc_request_t *req)
memcpy (state->resolve.gfid, args.gfid, 16);
/* here, dict itself works as xdata */
- GF_PROTOCOL_DICT_UNSERIALIZE (state->conn->bound_xl, state->dict,
+ GF_PROTOCOL_DICT_UNSERIALIZE (frame->root->client->bound_xl,
+ state->dict,
(args.dict.dict_val),
(args.dict.dict_len), ret,
op_errno, out);
@@ -4858,7 +4935,7 @@ server3_3_readdirp (rpcsvc_request_t *req)
resolve_and_resume (frame, server_readdirp_resume);
out:
if (op_errno)
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
free (args.dict.dict_val);
@@ -4882,22 +4959,22 @@ server3_3_readdir (rpcsvc_request_t *req)
(xdrproc_t)xdr_gfs3_readdir_req);
if (ret < 0) {
//failed to decode msg;
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
frame = get_frame_from_request (req);
if (!frame) {
// something wrong, mostly insufficient memory
- req->rpc_err = GARBAGE_ARGS; /* TODO */
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
frame->root->op = GF_FOP_READDIR;
- state = CALL_STATE(frame);
- if (!state->conn->bound_xl) {
+ state = CALL_STATE (frame);
+ if (!frame->root->client->bound_xl) {
/* auth failure, request on subvolume without setvolume */
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
@@ -4917,9 +4994,10 @@ server3_3_readdir (rpcsvc_request_t *req)
state->offset = args.offset;
memcpy (state->resolve.gfid, args.gfid, 16);
- GF_PROTOCOL_DICT_UNSERIALIZE (state->conn->bound_xl, state->xdata,
- (args.xdata.xdata_val),
- (args.xdata.xdata_len), ret,
+ 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;
@@ -4928,7 +5006,7 @@ out:
free (args.xdata.xdata_val);
if (op_errno)
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
return ret;
}
@@ -4949,22 +5027,22 @@ server3_3_fsyncdir (rpcsvc_request_t *req)
(xdrproc_t)xdr_gfs3_fsyncdir_req);
if (ret < 0) {
//failed to decode msg;
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
frame = get_frame_from_request (req);
if (!frame) {
// something wrong, mostly insufficient memory
- req->rpc_err = GARBAGE_ARGS; /* TODO */
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
frame->root->op = GF_FOP_FSYNCDIR;
- state = CALL_STATE(frame);
- if (!state->conn->bound_xl) {
+ state = CALL_STATE (frame);
+ if (!frame->root->client->bound_xl) {
/* auth failure, request on subvolume without setvolume */
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
@@ -4973,9 +5051,10 @@ server3_3_fsyncdir (rpcsvc_request_t *req)
state->flags = args.data;
memcpy (state->resolve.gfid, args.gfid, 16);
- GF_PROTOCOL_DICT_UNSERIALIZE (state->conn->bound_xl, state->xdata,
- (args.xdata.xdata_val),
- (args.xdata.xdata_len), ret,
+ 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;
@@ -4984,7 +5063,7 @@ out:
free (args.xdata.xdata_val);
if (op_errno)
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
return ret;
}
@@ -5009,22 +5088,22 @@ server3_3_mknod (rpcsvc_request_t *req)
(xdrproc_t)xdr_gfs3_mknod_req);
if (ret < 0) {
//failed to decode msg;
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
frame = get_frame_from_request (req);
if (!frame) {
// something wrong, mostly insufficient memory
- req->rpc_err = GARBAGE_ARGS; /* TODO */
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
frame->root->op = GF_FOP_MKNOD;
state = CALL_STATE (frame);
- if (!state->conn->bound_xl) {
+ if (!frame->root->client->bound_xl) {
/* auth failure, request on subvolume without setvolume */
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
@@ -5036,9 +5115,10 @@ server3_3_mknod (rpcsvc_request_t *req)
state->dev = args.dev;
state->umask = args.umask;
- GF_PROTOCOL_DICT_UNSERIALIZE (state->conn->bound_xl, state->xdata,
- (args.xdata.xdata_val),
- (args.xdata.xdata_len), ret,
+ 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;
@@ -5046,7 +5126,7 @@ server3_3_mknod (rpcsvc_request_t *req)
out:
if (op_errno)
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
/* memory allocated by libc, don't use GF_FREE */
free (args.xdata.xdata_val);
@@ -5074,22 +5154,22 @@ server3_3_mkdir (rpcsvc_request_t *req)
(xdrproc_t)xdr_gfs3_mkdir_req);
if (ret < 0) {
//failed to decode msg;
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
frame = get_frame_from_request (req);
if (!frame) {
// something wrong, mostly insufficient memory
- req->rpc_err = GARBAGE_ARGS; /* TODO */
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
frame->root->op = GF_FOP_MKDIR;
state = CALL_STATE (frame);
- if (!state->conn->bound_xl) {
+ if (!frame->root->client->bound_xl) {
/* auth failure, request on subvolume without setvolume */
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
@@ -5101,9 +5181,10 @@ server3_3_mkdir (rpcsvc_request_t *req)
state->umask = args.umask;
/* TODO: can do alloca for xdata field instead of stdalloc */
- GF_PROTOCOL_DICT_UNSERIALIZE (state->conn->bound_xl, state->xdata,
- (args.xdata.xdata_val),
- (args.xdata.xdata_len), ret,
+ 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;
@@ -5111,7 +5192,7 @@ server3_3_mkdir (rpcsvc_request_t *req)
out:
if (op_errno)
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
free (args.xdata.xdata_val);
@@ -5137,22 +5218,22 @@ server3_3_rmdir (rpcsvc_request_t *req)
(xdrproc_t)xdr_gfs3_rmdir_req);
if (ret < 0) {
//failed to decode msg;
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
frame = get_frame_from_request (req);
if (!frame) {
// something wrong, mostly insufficient memory
- req->rpc_err = GARBAGE_ARGS; /* TODO */
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
frame->root->op = GF_FOP_RMDIR;
state = CALL_STATE (frame);
- if (!state->conn->bound_xl) {
+ if (!frame->root->client->bound_xl) {
/* auth failure, request on subvolume without setvolume */
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
@@ -5162,9 +5243,10 @@ server3_3_rmdir (rpcsvc_request_t *req)
state->flags = args.xflags;
- GF_PROTOCOL_DICT_UNSERIALIZE (state->conn->bound_xl, state->xdata,
- (args.xdata.xdata_val),
- (args.xdata.xdata_len), ret,
+ 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;
@@ -5173,7 +5255,7 @@ out:
free (args.xdata.xdata_val);
if (op_errno)
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
return ret;
}
@@ -5199,22 +5281,22 @@ server3_3_inodelk (rpcsvc_request_t *req)
(xdrproc_t)xdr_gfs3_inodelk_req);
if (ret < 0) {
//failed to decode msg;
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
frame = get_frame_from_request (req);
if (!frame) {
// something wrong, mostly insufficient memory
- req->rpc_err = GARBAGE_ARGS; /* TODO */
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
frame->root->op = GF_FOP_INODELK;
state = CALL_STATE (frame);
- if (!state->conn->bound_xl) {
+ if (!frame->root->client->bound_xl) {
/* auth failure, request on subvolume without setvolume */
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
@@ -5251,9 +5333,10 @@ server3_3_inodelk (rpcsvc_request_t *req)
break;
}
- GF_PROTOCOL_DICT_UNSERIALIZE (state->conn->bound_xl, state->xdata,
- (args.xdata.xdata_val),
- (args.xdata.xdata_len), ret,
+ 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;
@@ -5264,7 +5347,7 @@ out:
free (args.flock.lk_owner.lk_owner_val);
if (op_errno)
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
return ret;
}
@@ -5286,22 +5369,22 @@ server3_3_finodelk (rpcsvc_request_t *req)
(xdrproc_t)xdr_gfs3_finodelk_req);
if (ret < 0) {
//failed to decode msg;
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
frame = get_frame_from_request (req);
if (!frame) {
// something wrong, mostly insufficient memory
- req->rpc_err = GARBAGE_ARGS; /* TODO */
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
frame->root->op = GF_FOP_FINODELK;
- state = CALL_STATE(frame);
- if (!state->conn->bound_xl) {
+ state = CALL_STATE (frame);
+ if (!frame->root->client->bound_xl) {
/* auth failure, request on subvolume without setvolume */
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
@@ -5339,9 +5422,10 @@ server3_3_finodelk (rpcsvc_request_t *req)
break;
}
- GF_PROTOCOL_DICT_UNSERIALIZE (state->conn->bound_xl, state->xdata,
- (args.xdata.xdata_val),
- (args.xdata.xdata_len), ret,
+ 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;
@@ -5352,7 +5436,7 @@ out:
free (args.flock.lk_owner.lk_owner_val);
if (op_errno)
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
return ret;
}
@@ -5377,22 +5461,22 @@ server3_3_entrylk (rpcsvc_request_t *req)
(xdrproc_t)xdr_gfs3_entrylk_req);
if (ret < 0) {
//failed to decode msg;
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
frame = get_frame_from_request (req);
if (!frame) {
// something wrong, mostly insufficient memory
- req->rpc_err = GARBAGE_ARGS; /* TODO */
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
frame->root->op = GF_FOP_ENTRYLK;
state = CALL_STATE (frame);
- if (!state->conn->bound_xl) {
+ if (!frame->root->client->bound_xl) {
/* auth failure, request on subvolume without setvolume */
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
@@ -5406,9 +5490,10 @@ server3_3_entrylk (rpcsvc_request_t *req)
state->cmd = args.cmd;
state->type = args.type;
- GF_PROTOCOL_DICT_UNSERIALIZE (state->conn->bound_xl, state->xdata,
- (args.xdata.xdata_val),
- (args.xdata.xdata_len), ret,
+ 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;
@@ -5417,7 +5502,7 @@ out:
free (args.xdata.xdata_val);
if (op_errno)
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
return ret;
}
@@ -5441,22 +5526,22 @@ server3_3_fentrylk (rpcsvc_request_t *req)
(xdrproc_t)xdr_gfs3_fentrylk_req);
if (ret < 0) {
//failed to decode msg;
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
frame = get_frame_from_request (req);
if (!frame) {
// something wrong, mostly insufficient memory
- req->rpc_err = GARBAGE_ARGS; /* TODO */
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
frame->root->op = GF_FOP_FENTRYLK;
- state = CALL_STATE(frame);
- if (!state->conn->bound_xl) {
+ state = CALL_STATE (frame);
+ if (!frame->root->client->bound_xl) {
/* auth failure, request on subvolume without setvolume */
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
@@ -5470,9 +5555,10 @@ server3_3_fentrylk (rpcsvc_request_t *req)
state->name = gf_strdup (args.name);
state->volume = gf_strdup (args.volume);
- GF_PROTOCOL_DICT_UNSERIALIZE (state->conn->bound_xl, state->xdata,
- (args.xdata.xdata_val),
- (args.xdata.xdata_len), ret,
+ 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;
@@ -5481,7 +5567,7 @@ out:
free (args.xdata.xdata_val);
if (op_errno)
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
return ret;
}
@@ -5502,22 +5588,22 @@ server3_3_access (rpcsvc_request_t *req)
(xdrproc_t)xdr_gfs3_access_req);
if (ret < 0) {
//failed to decode msg;
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
frame = get_frame_from_request (req);
if (!frame) {
// something wrong, mostly insufficient memory
- req->rpc_err = GARBAGE_ARGS; /* TODO */
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
frame->root->op = GF_FOP_ACCESS;
state = CALL_STATE (frame);
- if (!state->conn->bound_xl) {
+ if (!frame->root->client->bound_xl) {
/* auth failure, request on subvolume without setvolume */
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
@@ -5525,9 +5611,10 @@ server3_3_access (rpcsvc_request_t *req)
memcpy (state->resolve.gfid, args.gfid, 16);
state->mask = args.mask;
- GF_PROTOCOL_DICT_UNSERIALIZE (state->conn->bound_xl, state->xdata,
- (args.xdata.xdata_val),
- (args.xdata.xdata_len), ret,
+ 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;
@@ -5536,7 +5623,7 @@ out:
free (args.xdata.xdata_val);
if (op_errno)
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
return ret;
}
@@ -5562,22 +5649,22 @@ server3_3_symlink (rpcsvc_request_t *req)
(xdrproc_t)xdr_gfs3_symlink_req);
if (ret < 0) {
//failed to decode msg;
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
frame = get_frame_from_request (req);
if (!frame) {
// something wrong, mostly insufficient memory
- req->rpc_err = GARBAGE_ARGS; /* TODO */
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
frame->root->op = GF_FOP_SYMLINK;
state = CALL_STATE (frame);
- if (!state->conn->bound_xl) {
+ if (!frame->root->client->bound_xl) {
/* auth failure, request on subvolume without setvolume */
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
@@ -5587,9 +5674,10 @@ server3_3_symlink (rpcsvc_request_t *req)
state->name = gf_strdup (args.linkname);
state->umask = args.umask;
- GF_PROTOCOL_DICT_UNSERIALIZE (state->conn->bound_xl, state->xdata,
- (args.xdata.xdata_val),
- (args.xdata.xdata_len), ret,
+ 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;
@@ -5597,7 +5685,7 @@ server3_3_symlink (rpcsvc_request_t *req)
out:
if (op_errno)
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
/* memory allocated by libc, don't use GF_FREE */
free (args.xdata.xdata_val);
@@ -5624,22 +5712,22 @@ server3_3_link (rpcsvc_request_t *req)
ret = xdr_to_generic (req->msg[0], &args, (xdrproc_t)xdr_gfs3_link_req);
if (ret < 0) {
//failed to decode msg;
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
frame = get_frame_from_request (req);
if (!frame) {
// something wrong, mostly insufficient memory
- req->rpc_err = GARBAGE_ARGS; /* TODO */
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
frame->root->op = GF_FOP_LINK;
state = CALL_STATE (frame);
- if (!state->conn->bound_xl) {
+ if (!frame->root->client->bound_xl) {
/* auth failure, request on subvolume without setvolume */
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
@@ -5650,9 +5738,10 @@ server3_3_link (rpcsvc_request_t *req)
state->resolve2.bname = gf_strdup (args.newbname);
memcpy (state->resolve2.pargfid, args.newgfid, 16);
- GF_PROTOCOL_DICT_UNSERIALIZE (state->conn->bound_xl, state->xdata,
- (args.xdata.xdata_val),
- (args.xdata.xdata_len), ret,
+ 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;
@@ -5661,7 +5750,7 @@ out:
free (args.xdata.xdata_val);
if (op_errno)
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
return ret;
}
@@ -5686,22 +5775,22 @@ server3_3_rename (rpcsvc_request_t *req)
(xdrproc_t)xdr_gfs3_rename_req);
if (ret < 0) {
//failed to decode msg;
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
frame = get_frame_from_request (req);
if (!frame) {
// something wrong, mostly insufficient memory
- req->rpc_err = GARBAGE_ARGS; /* TODO */
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
frame->root->op = GF_FOP_RENAME;
state = CALL_STATE (frame);
- if (!state->conn->bound_xl) {
+ if (!frame->root->client->bound_xl) {
/* auth failure, request on subvolume without setvolume */
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
@@ -5713,9 +5802,10 @@ server3_3_rename (rpcsvc_request_t *req)
state->resolve2.bname = gf_strdup (args.newbname);
memcpy (state->resolve2.pargfid, args.newgfid, 16);
- GF_PROTOCOL_DICT_UNSERIALIZE (state->conn->bound_xl, state->xdata,
- (args.xdata.xdata_val),
- (args.xdata.xdata_len), ret,
+ 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;
@@ -5724,7 +5814,7 @@ out:
free (args.xdata.xdata_val);
if (op_errno)
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
return ret;
}
@@ -5744,22 +5834,22 @@ server3_3_lk (rpcsvc_request_t *req)
ret = xdr_to_generic (req->msg[0], &args, (xdrproc_t)xdr_gfs3_lk_req);
if (ret < 0) {
//failed to decode msg;
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
frame = get_frame_from_request (req);
if (!frame) {
// something wrong, mostly insufficient memory
- req->rpc_err = GARBAGE_ARGS; /* TODO */
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
frame->root->op = GF_FOP_LK;
state = CALL_STATE (frame);
- if (!state->conn->bound_xl) {
+ if (!frame->root->client->bound_xl) {
/* auth failure, request on subvolume without setvolume */
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
@@ -5807,7 +5897,7 @@ server3_3_lk (rpcsvc_request_t *req)
state->flock.l_type = F_UNLCK;
break;
default:
- gf_log (state->conn->bound_xl->name, GF_LOG_ERROR,
+ gf_log (frame->root->client->bound_xl->name, GF_LOG_ERROR,
"fd - %"PRId64" (%s): Unknown lock type: %"PRId32"!",
state->resolve.fd_no,
uuid_utoa (state->fd->inode->gfid), state->type);
@@ -5815,9 +5905,10 @@ server3_3_lk (rpcsvc_request_t *req)
}
- GF_PROTOCOL_DICT_UNSERIALIZE (state->conn->bound_xl, state->xdata,
- (args.xdata.xdata_val),
- (args.xdata.xdata_len), ret,
+ 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;
@@ -5828,7 +5919,7 @@ out:
free (args.flock.lk_owner.lk_owner_val);
if (op_errno)
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
return ret;
}
@@ -5850,22 +5941,22 @@ server3_3_rchecksum (rpcsvc_request_t *req)
(xdrproc_t)xdr_gfs3_rchecksum_req);
if (ret < 0) {
//failed to decode msg;
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
frame = get_frame_from_request (req);
if (!frame) {
// something wrong, mostly insufficient memory
- req->rpc_err = GARBAGE_ARGS; /* TODO */
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
frame->root->op = GF_FOP_RCHECKSUM;
- state = CALL_STATE(frame);
- if (!state->conn->bound_xl) {
+ state = CALL_STATE (frame);
+ if (!frame->root->client->bound_xl) {
/* auth failure, request on subvolume without setvolume */
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
@@ -5874,9 +5965,10 @@ server3_3_rchecksum (rpcsvc_request_t *req)
state->offset = args.offset;
state->size = args.len;
- GF_PROTOCOL_DICT_UNSERIALIZE (state->conn->bound_xl, state->xdata,
- (args.xdata.xdata_val),
- (args.xdata.xdata_len), ret,
+ 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;
@@ -5885,7 +5977,7 @@ out:
free (args.xdata.xdata_val);
if (op_errno)
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
return ret;
}
@@ -5922,14 +6014,14 @@ server3_3_lookup (rpcsvc_request_t *req)
(xdrproc_t)xdr_gfs3_lookup_req);
if (ret < 0) {
//failed to decode msg;
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
goto err;
}
frame = get_frame_from_request (req);
if (!frame) {
// something wrong, mostly insufficient memory
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
goto err;
}
frame->root->op = GF_FOP_LOOKUP;
@@ -5939,9 +6031,9 @@ server3_3_lookup (rpcsvc_request_t *req)
*/
state = CALL_STATE (frame);
- if (!state->conn->bound_xl) {
+ if (!frame->root->client->bound_xl) {
/* auth failure, request on subvolume without setvolume */
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
@@ -5954,9 +6046,10 @@ server3_3_lookup (rpcsvc_request_t *req)
memcpy (state->resolve.gfid, args.gfid, 16);
}
- GF_PROTOCOL_DICT_UNSERIALIZE (state->conn->bound_xl, state->xdata,
- (args.xdata.xdata_val),
- (args.xdata.xdata_len), ret,
+ 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;
@@ -5988,38 +6081,39 @@ server3_3_statfs (rpcsvc_request_t *req)
(xdrproc_t)xdr_gfs3_statfs_req);
if (ret < 0) {
//failed to decode msg;
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
frame = get_frame_from_request (req);
if (!frame) {
// something wrong, mostly insufficient memory
- req->rpc_err = GARBAGE_ARGS; /* TODO */
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
frame->root->op = GF_FOP_STATFS;
state = CALL_STATE (frame);
- if (!state->conn->bound_xl) {
+ if (!frame->root->client->bound_xl) {
/* auth failure, request on subvolume without setvolume */
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
goto out;
}
state->resolve.type = RESOLVE_MUST;
memcpy (state->resolve.gfid, args.gfid, 16);
- GF_PROTOCOL_DICT_UNSERIALIZE (state->conn->bound_xl, state->xdata,
- (args.xdata.xdata_val),
- (args.xdata.xdata_len), ret,
+ 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);
out:
if (op_errno)
- req->rpc_err = GARBAGE_ARGS;
+ SERVER_REQ_SET_ERROR (req, ret);
return ret;
}
@@ -6070,8 +6164,9 @@ rpcsvc_actor_t glusterfs3_3_fop_actors[] = {
[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_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},
};
diff --git a/xlators/protocol/server/src/server.c b/xlators/protocol/server/src/server.c
index 63e3ce918..589bd7b36 100644
--- a/xlators/protocol/server/src/server.c
+++ b/xlators/protocol/server/src/server.c
@@ -25,33 +25,56 @@
#include "statedump.h"
#include "defaults.h"
#include "authenticate.h"
-#include "rpcsvc.h"
void
grace_time_handler (void *data)
{
- server_connection_t *conn = NULL;
- xlator_t *this = NULL;
- gf_boolean_t cancelled = _gf_false;
- gf_boolean_t detached = _gf_false;
+ client_t *client = NULL;
+ xlator_t *this = NULL;
+ gf_timer_t *timer = NULL;
+ server_ctx_t *serv_ctx = NULL;
+ gf_boolean_t cancelled = _gf_false;
+ gf_boolean_t detached = _gf_false;
- conn = data;
- this = conn->this;
+ client = data;
+ this = client->this;
- GF_VALIDATE_OR_GOTO (THIS->name, conn, out);
GF_VALIDATE_OR_GOTO (THIS->name, this, out);
- gf_log (this->name, GF_LOG_INFO, "grace timer expired for %s", conn->id);
+ gf_log (this->name, GF_LOG_INFO, "grace timer expired for %s",
+ client->client_uid);
- cancelled = server_cancel_conn_timer (this, conn);
+ serv_ctx = server_ctx_get (client, this);
+
+ if (serv_ctx == NULL) {
+ gf_log (this->name, GF_LOG_INFO, "server_ctx_get() failed");
+ goto out;
+ }
+
+ LOCK (&serv_ctx->fdtable_lock);
+ {
+ if (serv_ctx->grace_timer) {
+ timer = serv_ctx->grace_timer;
+ serv_ctx->grace_timer = NULL;
+ }
+ }
+ UNLOCK (&serv_ctx->fdtable_lock);
+ if (timer) {
+ gf_timer_call_cancel (this->ctx, timer);
+ cancelled = _gf_true;
+ }
if (cancelled) {
- //conn should not be destroyed in conn_put, so take a ref.
- server_conn_ref (conn);
- server_connection_put (this, conn, &detached);
+
+ /*
+ * client must not be destroyed in gf_client_put(),
+ * so take a ref.
+ */
+ gf_client_ref (client);
+ gf_client_put (client, &detached);
if (detached)//reconnection did not happen :-(
- server_connection_cleanup (this, conn,
- INTERNAL_LOCKS | POSIX_LOCKS);
- server_conn_unref (conn);
+ server_connection_cleanup (this, client,
+ INTERNAL_LOCKS | POSIX_LOCKS);
+ gf_client_unref (client);
}
out:
return;
@@ -107,8 +130,6 @@ ret:
return iob;
}
-
-
int
server_submit_reply (call_frame_t *frame, rpcsvc_request_t *req, void *arg,
struct iovec *payload, int payloadcount,
@@ -119,20 +140,24 @@ server_submit_reply (call_frame_t *frame, rpcsvc_request_t *req, void *arg,
struct iovec rsp = {0,};
server_state_t *state = NULL;
char new_iobref = 0;
- server_connection_t *conn = NULL;
+ client_t *client = NULL;
gf_boolean_t lk_heal = _gf_false;
- glusterfs_fop_t fop = GF_FOP_NULL;
+ server_conf_t *conf = NULL;
+ gf_barrier_t *barrier = NULL;
+ gf_barrier_payload_t *stub = NULL;
+ gf_boolean_t barriered = _gf_false;
GF_VALIDATE_OR_GOTO ("server", req, ret);
if (frame) {
state = CALL_STATE (frame);
frame->local = NULL;
- conn = SERVER_CONNECTION(frame);
+ client = frame->root->client;
+ conf = (server_conf_t *) client->this->private;
}
- if (conn)
- lk_heal = ((server_conf_t *) conn->this->private)->lk_heal;
+ if (client)
+ lk_heal = ((server_conf_t *) client->this->private)->lk_heal;
if (!iobref) {
iobref = iobref_new ();
@@ -151,6 +176,32 @@ server_submit_reply (call_frame_t *frame, rpcsvc_request_t *req, void *arg,
iobref_add (iobref, iob);
+ if (conf)
+ barrier = conf->barrier;
+ if (barrier) {
+ /* todo: write's with fd flags set to O_SYNC and O_DIRECT */
+ LOCK (&barrier->lock);
+ {
+ if (is_fop_barriered (barrier->fops, req->procnum) &&
+ (barrier_add_to_queue (barrier))) {
+ stub = gf_barrier_payload (req, &rsp, frame,
+ payload,
+ payloadcount, iobref,
+ iob, new_iobref);
+ if (stub) {
+ gf_barrier_enqueue (barrier, stub);
+ barriered = _gf_true;
+ } else {
+ gf_log ("", GF_LOG_ERROR, "Failed to "
+ " barrier fop %"PRIu64,
+ ((uint64_t)1 << req->procnum));
+ }
+ }
+ }
+ UNLOCK (&barrier->lock);
+ if (barriered == _gf_true)
+ goto out;
+ }
/* Then, submit the message for transmission. */
ret = rpcsvc_submit_generic (req, &rsp, 1, payload, payloadcount,
iobref);
@@ -165,17 +216,9 @@ server_submit_reply (call_frame_t *frame, rpcsvc_request_t *req, void *arg,
*/
iobuf_unref (iob);
if (ret == -1) {
- if (frame && conn && !lk_heal) {
- fop = frame->root->op;
- if ((GF_FOP_NULL < fop) &&
- (fop < GF_FOP_MAXVALUE)) {
- pthread_mutex_lock (&conn->lock);
- {
- conn->rsp_failure_fops[fop]++;
- }
- pthread_mutex_unlock (&conn->lock);
- }
- server_connection_cleanup (frame->this, conn,
+ gf_log_callingfn ("", GF_LOG_ERROR, "Reply submission failed");
+ if (frame && client && !lk_heal) {
+ server_connection_cleanup (frame->this, client,
INTERNAL_LOCKS | POSIX_LOCKS);
} else {
gf_log_callingfn ("", GF_LOG_ERROR,
@@ -193,185 +236,17 @@ ret:
}
if (frame) {
- if (frame->root->trans)
- server_conn_unref (frame->root->trans);
+ gf_client_unref (client);
STACK_DESTROY (frame->root);
}
if (new_iobref) {
iobref_unref (iobref);
}
-
- return ret;
-}
-
-/* */
-int
-server_fd_to_dict (xlator_t *this, dict_t *dict)
-{
- server_conf_t *conf = NULL;
- server_connection_t *trav = NULL;
- char key[GF_DUMP_MAX_BUF_LEN] = {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 -1;
-
- ret = pthread_mutex_trylock (&conf->mutex);
- if (ret)
- return -1;
-
- list_for_each_entry (trav, &conf->conns, list) {
- memset (key, 0, sizeof (key));
- snprintf (key, sizeof (key), "conn%d", count++);
- fdtable_dump_to_dict (trav->fdtable, key, dict);
- }
- pthread_mutex_unlock (&conf->mutex);
-
- ret = dict_set_int32 (dict, "conncount", count);
-out:
- return ret;
-}
-
-int
-server_fd (xlator_t *this)
-{
- server_conf_t *conf = NULL;
- server_connection_t *trav = NULL;
- char key[GF_DUMP_MAX_BUF_LEN];
- int i = 1;
- int ret = -1;
- gf_boolean_t section_added = _gf_false;
-
- GF_VALIDATE_OR_GOTO ("server", this, out);
-
- conf = this->private;
- if (!conf) {
- gf_log (this->name, GF_LOG_WARNING,
- "conf null in xlator");
- return -1;
- }
-
- gf_proc_dump_add_section("xlator.protocol.server.conn");
- section_added = _gf_true;
-
- ret = pthread_mutex_trylock (&conf->mutex);
- if (ret)
- goto out;
-
- list_for_each_entry (trav, &conf->conns, list) {
- if (trav->id) {
- gf_proc_dump_build_key(key,
- "conn","%d.id", i);
- gf_proc_dump_write(key, "%s", trav->id);
- }
-
- gf_proc_dump_build_key(key,"conn","%d.ref",i)
- gf_proc_dump_write(key, "%d", trav->ref);
- if (trav->bound_xl) {
- gf_proc_dump_build_key(key,
- "conn","%d.bound_xl", i);
- gf_proc_dump_write(key, "%s", trav->bound_xl->name);
- }
-
- gf_proc_dump_build_key(key,
- "conn","%d.id", i);
- fdtable_dump(trav->fdtable,key);
- i++;
- }
- pthread_mutex_unlock (&conf->mutex);
-
- ret = 0;
out:
- if (ret) {
- if (section_added == _gf_false)
- gf_proc_dump_add_section("xlator.protocol.server.conn");
- gf_proc_dump_write ("Unable to dump the list of connections",
- "(Lock acquisition failed) %s",
- this?this->name:"server");
- }
return ret;
}
-void
-ltable_dump (server_connection_t *trav)
-{
- char key[GF_DUMP_MAX_BUF_LEN] = {0,};
- struct _locker *locker = NULL;
- char locker_data[GF_MAX_LOCK_OWNER_LEN] = {0,};
- int count = 0;
-
- gf_proc_dump_build_key(key,
- "conn","bound_xl.ltable.inodelk.%s",
- trav->bound_xl?trav->bound_xl->name:"");
- gf_proc_dump_add_section(key);
-
- list_for_each_entry (locker, &trav->ltable->inodelk_lockers, lockers) {
- count++;
- gf_proc_dump_write("volume", "%s", locker->volume);
- if (locker->fd) {
- gf_proc_dump_write("fd", "%p", locker->fd);
- gf_proc_dump_write("gfid", "%s",
- uuid_utoa (locker->fd->inode->gfid));
- } else {
- gf_proc_dump_write("fd", "%s", locker->loc.path);
- gf_proc_dump_write("gfid", "%s",
- uuid_utoa (locker->loc.inode->gfid));
- }
- gf_proc_dump_write("pid", "%d", locker->pid);
- gf_proc_dump_write("lock length", "%d", locker->owner.len);
- lkowner_unparse (&locker->owner, locker_data,
- locker->owner.len);
- gf_proc_dump_write("lock owner", "%s", locker_data);
- memset (locker_data, 0, sizeof (locker_data));
-
- gf_proc_dump_build_key (key, "inode", "%d", count);
- gf_proc_dump_add_section (key);
- if (locker->fd)
- inode_dump (locker->fd->inode, key);
- else
- inode_dump (locker->loc.inode, key);
- }
-
- count = 0;
- locker = NULL;
- gf_proc_dump_build_key(key,
- "conn","bound_xl.ltable.entrylk.%s",
- trav->bound_xl?trav->bound_xl->name:"");
- gf_proc_dump_add_section(key);
-
- list_for_each_entry (locker, &trav->ltable->entrylk_lockers,
- lockers) {
- count++;
- gf_proc_dump_write("volume", "%s", locker->volume);
- if (locker->fd) {
- gf_proc_dump_write("fd", "%p", locker->fd);
- gf_proc_dump_write("gfid", "%s",
- uuid_utoa (locker->fd->inode->gfid));
- } else {
- gf_proc_dump_write("fd", "%s", locker->loc.path);
- gf_proc_dump_write("gfid", "%s",
- uuid_utoa (locker->loc.inode->gfid));
- }
- gf_proc_dump_write("pid", "%d", locker->pid);
- gf_proc_dump_write("lock length", "%d", locker->owner.len);
- lkowner_unparse (&locker->owner, locker_data, locker->owner.len);
- gf_proc_dump_write("lock data", "%s", locker_data);
- memset (locker_data, 0, sizeof (locker_data));
-
- gf_proc_dump_build_key (key, "inode", "%d", count);
- gf_proc_dump_add_section (key);
- if (locker->fd)
- inode_dump (locker->fd->inode, key);
- else
- inode_dump (locker->loc.inode, key);
- }
-}
int
server_priv_to_dict (xlator_t *this, dict_t *dict)
@@ -478,104 +353,6 @@ out:
return ret;
}
-int
-server_inode_to_dict (xlator_t *this, dict_t *dict)
-{
- server_conf_t *conf = NULL;
- server_connection_t *trav = NULL;
- char key[32] = {0,};
- int count = 0;
- int ret = -1;
- xlator_t *prev_bound_xl = NULL;
-
- GF_VALIDATE_OR_GOTO (THIS->name, this, out);
- GF_VALIDATE_OR_GOTO (this->name, dict, out);
-
- conf = this->private;
- if (!conf)
- return -1;
-
- ret = pthread_mutex_trylock (&conf->mutex);
- if (ret)
- return -1;
-
- list_for_each_entry (trav, &conf->conns, list) {
- if (trav->bound_xl && trav->bound_xl->itable) {
- /* Presently every brick contains only one
- * bound_xl for all connections. This will lead
- * to duplicating of the inode lists, if listing
- * is done for every connection. This simple check
- * prevents duplication in the present case. If
- * need arises the check can be improved.
- */
- if (trav->bound_xl == prev_bound_xl)
- continue;
- prev_bound_xl = trav->bound_xl;
-
- memset (key, 0, sizeof (key));
- snprintf (key, sizeof (key), "conn%d", count);
- inode_table_dump_to_dict (trav->bound_xl->itable,
- key, dict);
- count++;
- }
- }
- pthread_mutex_unlock (&conf->mutex);
-
- ret = dict_set_int32 (dict, "conncount", count);
-
-out:
- if (prev_bound_xl)
- prev_bound_xl = NULL;
- return ret;
-}
-
-int
-server_inode (xlator_t *this)
-{
- server_conf_t *conf = NULL;
- server_connection_t *trav = NULL;
- char key[GF_DUMP_MAX_BUF_LEN];
- int i = 1;
- int ret = -1;
-
- GF_VALIDATE_OR_GOTO ("server", this, out);
-
- conf = this->private;
- if (!conf) {
- gf_log (this->name, GF_LOG_WARNING,
- "conf null in xlator");
- return -1;
- }
-
- ret = pthread_mutex_trylock (&conf->mutex);
- if (ret)
- goto out;
-
- list_for_each_entry (trav, &conf->conns, list) {
- ret = pthread_mutex_trylock (&trav->lock);
- if (!ret)
- {
- gf_proc_dump_build_key(key,
- "conn","%d.ltable", i);
- gf_proc_dump_add_section(key);
- ltable_dump (trav);
- i++;
- pthread_mutex_unlock (&trav->lock);
- }else
- continue;
- }
- pthread_mutex_unlock (&conf->mutex);
-
- ret = 0;
-out:
- if (ret)
- gf_proc_dump_write ("Unable to dump the lock table",
- "(Lock acquisition failed) %s",
- this?this->name:"server");
-
- return ret;
-}
-
static int
get_auth_types (dict_t *this, char *key, data_t *value, void *data)
@@ -718,9 +495,10 @@ server_rpc_notify (rpcsvc_t *rpc, void *xl, rpcsvc_event_t event,
{
gf_boolean_t detached = _gf_false;
xlator_t *this = NULL;
- rpc_transport_t *xprt = NULL;
- server_connection_t *conn = NULL;
+ rpc_transport_t *trans = NULL;
server_conf_t *conf = NULL;
+ client_t *client = NULL;
+ server_ctx_t *serv_ctx = NULL;
if (!xl || !data) {
gf_log_callingfn ("server", GF_LOG_WARNING,
@@ -729,7 +507,7 @@ server_rpc_notify (rpcsvc_t *rpc, void *xl, rpcsvc_event_t event,
}
this = xl;
- xprt = data;
+ trans = data;
conf = this->private;
switch (event) {
@@ -737,17 +515,17 @@ server_rpc_notify (rpcsvc_t *rpc, void *xl, rpcsvc_event_t event,
{
/* Have a structure per new connection */
/* TODO: Should we create anything here at all ? * /
- conn = create_server_conn_state (this, xprt);
- if (!conn)
+ client->conn = create_server_conn_state (this, trans);
+ if (!client->conn)
goto out;
- xprt->protocol_private = conn;
+ trans->protocol_private = client->conn;
*/
- INIT_LIST_HEAD (&xprt->list);
+ INIT_LIST_HEAD (&trans->list);
pthread_mutex_lock (&conf->mutex);
{
- list_add_tail (&xprt->list, &conf->xprt_list);
+ list_add_tail (&trans->list, &conf->xprt_list);
}
pthread_mutex_unlock (&conf->mutex);
@@ -760,51 +538,58 @@ server_rpc_notify (rpcsvc_t *rpc, void *xl, rpcsvc_event_t event,
*/
pthread_mutex_lock (&conf->mutex);
{
- list_del_init (&xprt->list);
+ list_del_init (&trans->list);
}
pthread_mutex_unlock (&conf->mutex);
- conn = get_server_conn_state (this, xprt);
- if (!conn)
+ client = trans->xl_private;
+ if (!client)
break;
gf_log (this->name, GF_LOG_INFO, "disconnecting connection"
- " from %s, Number of pending operations: %"PRIu64,
- conn->id, conn->ref);
+ "from %s", client->client_uid);
/* If lock self heal is off, then destroy the
conn object, else register a grace timer event */
if (!conf->lk_heal) {
- server_conn_ref (conn);
- server_connection_put (this, conn, &detached);
+ gf_client_ref (client);
+ gf_client_put (client, &detached);
if (detached)
- server_connection_cleanup (this, conn,
- INTERNAL_LOCKS |
- POSIX_LOCKS);
- server_conn_unref (conn);
- } else {
- put_server_conn_state (this, xprt);
- server_connection_cleanup (this, conn, INTERNAL_LOCKS);
+ server_connection_cleanup (this, client,
+ INTERNAL_LOCKS | POSIX_LOCKS);
+ gf_client_unref (client);
+ break;
+ }
+ trans->xl_private = NULL;
+ server_connection_cleanup (this, client, INTERNAL_LOCKS);
- pthread_mutex_lock (&conn->lock);
- {
- if (conn->timer)
- goto unlock;
+ serv_ctx = server_ctx_get (client, this);
- gf_log (this->name, GF_LOG_INFO, "starting a grace "
- "timer for %s", conn->id);
+ if (serv_ctx == NULL) {
+ gf_log (this->name, GF_LOG_INFO,
+ "server_ctx_get() failed");
+ goto out;
+ }
+
+ LOCK (&serv_ctx->fdtable_lock);
+ {
+ if (!serv_ctx->grace_timer) {
+
+ gf_log (this->name, GF_LOG_INFO,
+ "starting a grace timer for %s",
+ client->client_uid);
- conn->timer = gf_timer_call_after (this->ctx,
- conf->grace_tv,
- grace_time_handler,
- conn);
+ serv_ctx->grace_timer =
+ gf_timer_call_after (this->ctx,
+ conf->grace_ts,
+ grace_time_handler,
+ client);
}
- unlock:
- pthread_mutex_unlock (&conn->lock);
}
+ UNLOCK (&serv_ctx->fdtable_lock);
break;
case RPCSVC_EVENT_TRANSPORT_DESTROY:
- /*- conn obj has been disassociated from xprt on first
+ /*- conn obj has been disassociated from trans on first
* disconnect.
* conn cleanup and destruction is handed over to
* grace_time_handler or the subsequent handler that 'owns'
@@ -898,14 +683,14 @@ server_init_grace_timer (xlator_t *this, dict_t *options,
ret = dict_get_int32 (options, "grace-timeout", &grace_timeout);
if (!ret)
- conf->grace_tv.tv_sec = grace_timeout;
+ conf->grace_ts.tv_sec = grace_timeout;
else
- conf->grace_tv.tv_sec = 10;
+ conf->grace_ts.tv_sec = 10;
gf_log (this->name, GF_LOG_DEBUG, "Server grace timeout "
- "value = %"PRIu64, conf->grace_tv.tv_sec);
+ "value = %"PRIu64, conf->grace_ts.tv_sec);
- conf->grace_tv.tv_usec = 0;
+ conf->grace_ts.tv_nsec = 0;
ret = 0;
out:
@@ -952,12 +737,6 @@ reconfigure (xlator_t *this, dict_t *options)
}
- /*ret = dict_get_str (options, "statedump-path", &statedump_path);
- if (!ret) {
- gf_path_strip_trailing_slashes (statedump_path);
- GF_FREE (this->ctx->statedump_path);
- this->ctx->statedump_path = gf_strdup (statedump_path);
- }*/
GF_OPTION_RECONF ("statedump-path", statedump_path,
options, path, out);
if (!statedump_path) {
@@ -996,6 +775,7 @@ reconfigure (xlator_t *this, dict_t *options)
(void) rpcsvc_set_allow_insecure (rpc_conf, options);
(void) rpcsvc_set_root_squash (rpc_conf, options);
+ (void) rpcsvc_set_outstanding_rpc_limit (rpc_conf, options);
list_for_each_entry (listeners, &(rpc_conf->listeners), list) {
if (listeners->trans != NULL) {
if (listeners->trans->reconfigure )
@@ -1012,6 +792,26 @@ out:
return ret;
}
+static int32_t
+client_destroy_cbk (xlator_t *this, client_t *client)
+{
+ void *tmp = NULL;
+ server_ctx_t *ctx = NULL;
+
+ client_ctx_del (client, this, &tmp);
+
+ ctx = tmp;
+
+ if (ctx == NULL)
+ return 0;
+
+ gf_fd_fdtable_destroy (ctx->fdtable);
+ LOCK_DESTROY (&ctx->fdtable_lock);
+ GF_FREE (ctx);
+
+ return 0;
+}
+
int
init (xlator_t *this)
{
@@ -1019,6 +819,8 @@ init (xlator_t *this)
server_conf_t *conf = NULL;
rpcsvc_listener_t *listener = NULL;
char *statedump_path = NULL;
+ gf_barrier_t *barrier = NULL;
+ char *str = NULL;
GF_VALIDATE_OR_GOTO ("init", this, out);
if (this->children == NULL) {
@@ -1038,7 +840,6 @@ init (xlator_t *this)
GF_VALIDATE_OR_GOTO(this->name, conf, out);
- INIT_LIST_HEAD (&conf->conns);
INIT_LIST_HEAD (&conf->xprt_list);
pthread_mutex_init (&conf->mutex, NULL);
@@ -1160,6 +961,37 @@ init (xlator_t *this)
}
}
#endif
+ /* barrier related */
+ barrier = GF_CALLOC (1, sizeof (*barrier),1);
+ if (!barrier) {
+ gf_log (this->name, GF_LOG_WARNING,
+ "WARNING: Failed to allocate barrier");
+ ret = -1;
+ goto out;
+ }
+
+ LOCK_INIT (&barrier->lock);
+ INIT_LIST_HEAD (&barrier->queue);
+ barrier->on = _gf_false;
+
+ GF_OPTION_INIT ("barrier-queue-length", barrier->max_size,
+ int64, out);
+ GF_OPTION_INIT ("barrier-timeout", barrier->time_out,
+ uint64, out);
+
+ ret = dict_get_str (this->options, "barrier-fops", &str);
+ if (ret) {
+ gf_log (this->name, GF_LOG_DEBUG,
+ "setting barrier fops to default value");
+ }
+ ret = gf_barrier_fops_configure (this, barrier, str);
+ if (ret) {
+ gf_log (this->name, GF_LOG_ERROR,
+ "invalid barrier fops specified");
+ goto out;
+ }
+
+ conf->barrier = barrier;
this->private = conf;
ret = 0;
@@ -1213,27 +1045,65 @@ int
notify (xlator_t *this, int32_t event, void *data, ...)
{
int ret = 0;
+ int32_t val = 0;
+ dict_t *dict = NULL;
+ dict_t *output = NULL;
+ va_list ap;
+
+ dict = data;
+ va_start (ap, data);
+ output = va_arg (ap, dict_t*);
+ va_end (ap);
+
switch (event) {
+ case GF_EVENT_VOLUME_BARRIER_OP:
+ ret = dict_get_int32 (dict, "barrier", &val);
+ if (ret) {
+ gf_log (this->name, GF_LOG_ERROR,
+ "Wrong BARRIER event");
+ goto out;
+ }
+ /* !val un-barrier, if val, barrier */
+ if (val) {
+ ret = gf_barrier_start (this);
+ if (ret)
+ gf_log (this->name, GF_LOG_ERROR,
+ "Barrier start failed");
+ } else {
+ ret = gf_barrier_stop (this);
+ if (ret)
+ gf_log (this->name, GF_LOG_ERROR,
+ "Barrier stop failed");
+ }
+ ret = dict_set_int32 (output, "barrier-status", ret);
+ if (ret)
+ gf_log (this->name, GF_LOG_ERROR,
+ "Failed to set barrier-status in dict");
+ break;
+
+ /* todo: call default_notify to make other xlators handle it.*/
default:
default_notify (this, event, data);
break;
}
-
+out:
return ret;
}
struct xlator_fops fops;
-struct xlator_cbks cbks;
+struct xlator_cbks cbks = {
+ .client_destroy = client_destroy_cbk,
+};
struct xlator_dumpops dumpops = {
.priv = server_priv,
- .fd = server_fd,
- .inode = server_inode,
+ .fd = gf_client_dump_fdtables,
+ .inode = gf_client_dump_inodes,
.priv_to_dict = server_priv_to_dict,
- .fd_to_dict = server_fd_to_dict,
- .inode_to_dict = server_inode_to_dict,
+ .fd_to_dict = gf_client_dump_fdtables_to_dict,
+ .inode_to_dict = gf_client_dump_inodes_to_dict,
};
@@ -1322,6 +1192,23 @@ struct volume_options options[] = {
"hostnames to connect to the server. By default, all"
" connections are allowed."
},
-
+ {.key = {"barrier-timeout"},
+ .type = GF_OPTION_TYPE_INT,
+ .default_value = "60",
+ .min = 0,
+ .max = 360,
+ .description = "Barrier timeout in seconds",
+ },
+ {.key = {"barrier-queue-length"},
+ .type = GF_OPTION_TYPE_INT,
+ .default_value = "4096",
+ .min = 0,
+ .max = 16384,
+ .description = "Barrier queue length",
+ },
+ {.key = {"barrier-fops"},
+ .type = GF_OPTION_TYPE_STR,
+ .description = "Allow a comma seperated fop lists",
+ },
{ .key = {NULL} },
};
diff --git a/xlators/protocol/server/src/server.h b/xlators/protocol/server/src/server.h
index 1da574934..782327d77 100644
--- a/xlators/protocol/server/src/server.h
+++ b/xlators/protocol/server/src/server.h
@@ -13,6 +13,7 @@
#include <pthread.h>
+#include "fd.h"
#include "rpcsvc.h"
#include "fd.h"
@@ -20,70 +21,47 @@
#include "server-mem-types.h"
#include "glusterfs3.h"
#include "timer.h"
+#include "client_t.h"
#define DEFAULT_BLOCK_SIZE 4194304 /* 4MB */
#define DEFAULT_VOLUME_FILE_PATH CONFDIR "/glusterfs.vol"
#define GF_MAX_SOCKET_WINDOW_SIZE (1 * GF_UNIT_MB)
#define GF_MIN_SOCKET_WINDOW_SIZE (0)
-typedef enum {
- INTERNAL_LOCKS = 1,
- POSIX_LOCKS = 2,
-} server_lock_flags_t;
-
-typedef struct _server_state server_state_t;
-
-struct _locker {
- struct list_head lockers;
- char *volume;
- loc_t loc;
- fd_t *fd;
- gf_lkowner_t owner;
- pid_t pid;
+struct _gf_barrier_payload {
+ rpcsvc_request_t *req;
+ struct iovec rsp;
+ call_frame_t *frame;
+ struct iovec *payload;
+ struct iobref *iobref;
+ struct iobuf *iob;
+ int payload_count;
+ gf_boolean_t free_iobref;
+ struct list_head list;
};
-struct _lock_table {
- struct list_head inodelk_lockers;
- struct list_head entrylk_lockers;
+typedef struct _gf_barrier_payload gf_barrier_payload_t;
+
+struct _gf_barrier {
+ gf_lock_t lock;
+ gf_boolean_t on;
+ gf_boolean_t force;
+ size_t cur_size;
+ int64_t max_size;
+ uint64_t fops;
+ gf_timer_t *timer;
+ uint64_t time_out;
+ struct list_head queue;
};
-/* private structure per connection (transport object)
- * used as transport_t->xl_private
- */
-struct _server_connection {
- struct list_head list;
- char *id;
- uint64_t ref;
- int bind_ref;
- pthread_mutex_t lock;
- fdtable_t *fdtable;
- struct _lock_table *ltable;
- gf_timer_t *timer;
- xlator_t *bound_xl;
- xlator_t *this;
- uint32_t lk_version;
- uint64_t rsp_failure_fops[GF_FOP_MAXVALUE];
-};
-
-typedef struct _server_connection server_connection_t;
-
-
-server_connection_t *
-server_connection_get (xlator_t *this, const char *id);
+typedef struct _gf_barrier gf_barrier_t;
-server_connection_t *
-server_connection_put (xlator_t *this, server_connection_t *conn,
- gf_boolean_t *detached);
-
-server_connection_t*
-server_conn_unref (server_connection_t *conn);
-
-server_connection_t*
-server_conn_ref (server_connection_t *conn);
+typedef enum {
+ INTERNAL_LOCKS = 1,
+ POSIX_LOCKS = 2,
+} server_lock_flags_t;
-int
-server_connection_cleanup (xlator_t *this, server_connection_t *conn,
- int32_t flags);
+typedef struct _server_state server_state_t;
int server_null (rpcsvc_request_t *req);
@@ -103,11 +81,12 @@ struct server_conf {
heal is on else off. */
char *conf_dir;
struct _volfile_ctx *volfile;
- struct timeval grace_tv;
+ struct timespec grace_ts;
dict_t *auth_modules;
pthread_mutex_t mutex;
- struct list_head conns;
+ gf_barrier_t *barrier;
struct list_head xprt_list;
+ pthread_t barrier_th;
};
typedef struct server_conf server_conf_t;
@@ -145,11 +124,10 @@ int
resolve_and_resume (call_frame_t *frame, server_resume_fn_t fn);
struct _server_state {
- server_connection_t *conn;
- rpc_transport_t *xprt;
- inode_table_t *itable;
+ rpc_transport_t *xprt;
+ inode_table_t *itable;
- server_resume_fn_t resume_fn;
+ server_resume_fn_t resume_fn;
loc_t loc;
loc_t loc2;
@@ -185,7 +163,7 @@ struct _server_state {
int mask;
char is_revalidate;
dict_t *dict;
- struct gf_flock flock;
+ struct gf_flock flock;
const char *volume;
dir_entry_t *entry;
@@ -193,10 +171,20 @@ struct _server_state {
mode_t umask;
};
+
extern struct rpcsvc_program gluster_handshake_prog;
extern struct rpcsvc_program glusterfs3_3_fop_prog;
extern struct rpcsvc_program gluster_ping_prog;
+
+typedef struct _server_ctx {
+ gf_lock_t fdtable_lock;
+ fdtable_t *fdtable;
+ struct _gf_timer *grace_timer;
+ uint32_t lk_version;
+} server_ctx_t;
+
+
int
server_submit_reply (call_frame_t *frame, rpcsvc_request_t *req, void *arg,
struct iovec *payload, int payloadcount,
@@ -205,6 +193,4 @@ server_submit_reply (call_frame_t *frame, rpcsvc_request_t *req, void *arg,
int gf_server_check_setxattr_cmd (call_frame_t *frame, dict_t *dict);
int gf_server_check_getxattr_cmd (call_frame_t *frame, const char *name);
-void ltable_dump (server_connection_t *conn);
-
#endif /* !_SERVER_H */
generated by cgit (git 2.34.1) at 2026-01-11 18:04:23 +0000