andy/glusterfs
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

protocol/server: White space cleanup and NULL check validations.

Browse Source 
Signed-off-by: Junaid <junaid@gluster.com>
Signed-off-by: Amar Tumballi <amar@gluster.com>
Signed-off-by: Vijay Bellur <vijay@dev.gluster.com>

BUG: 2346 (Log message enhancements in GlusterFS - phase 1)
URL: http://bugs.gluster.com/cgi-bin/bugzilla3/show_bug.cgi?id=2346
This commit is contained in:
Mohammed Junaid Ahmed 2011-03-16 09:43:21 +00:00 committed by Vijay Bellur
parent 0d7628c6c2
commit d3e9a97b6e
10 changed files with 499 additions and 422 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

304
xlators/protocol/server/src/authenticate.c
View File

@ -32,218 +32,210 @@
#include "authenticate.h"
static void
init (dict_t *this,
char *key,
data_t *value,
void *data)
init (dict_t *this, char *key, data_t *value, void *data)
{
void *handle = NULL;
char *auth_file = NULL;
auth_handle_t *auth_handle = NULL;
auth_fn_t authenticate = NULL;
int *error = NULL;
void *handle = NULL;
char *auth_file = NULL;
auth_handle_t *auth_handle = NULL;
auth_fn_t authenticate = NULL;
int *error = NULL;
int ret = 0;
/* It gets over written */
error = data;
/* It gets over written */
error = data;
if (!strncasecmp (key, "ip", strlen ("ip"))) {
gf_log ("authenticate", GF_LOG_ERROR,
"AUTHENTICATION MODULE \"IP\" HAS BEEN REPLACED "
"BY \"ADDR\"");
dict_set (this, key, data_from_dynptr (NULL, 0));
/* TODO: 1.3.x backword compatibility */
// *error = -1;
// return;
key = "addr";
}
if (!strncasecmp (key, "ip", strlen ("ip"))) {
gf_log ("authenticate", GF_LOG_ERROR,
"AUTHENTICATION MODULE \"IP\" HAS BEEN REPLACED "
"BY \"ADDR\"");
dict_set (this, key, data_from_dynptr (NULL, 0));
/* TODO: 1.3.x backword compatibility */
// *error = -1;
// return;
key = "addr";
}
ret = gf_asprintf (&auth_file, "%s/%s.so", LIBDIR, key);
ret = gf_asprintf (&auth_file, "%s/%s.so", LIBDIR, key);
if (-1 == ret) {
gf_log ("authenticate", GF_LOG_ERROR, "asprintf failed");
dict_set (this, key, data_from_dynptr (NULL, 0));
*error = -1;
return;
}
handle = dlopen (auth_file, RTLD_LAZY);
if (!handle) {
gf_log ("authenticate", GF_LOG_ERROR, "dlopen(%s): %s\n",
auth_file, dlerror ());
dict_set (this, key, data_from_dynptr (NULL, 0));
GF_FREE (auth_file);
*error = -1;
return;
}
GF_FREE (auth_file);
handle = dlopen (auth_file, RTLD_LAZY);
if (!handle) {
gf_log ("authenticate", GF_LOG_ERROR, "dlopen(%s): %s\n",
auth_file, dlerror ());
dict_set (this, key, data_from_dynptr (NULL, 0));
GF_FREE (auth_file);
*error = -1;
return;
}
GF_FREE (auth_file);
authenticate = dlsym (handle, "gf_auth");
if (!authenticate) {
gf_log ("authenticate", GF_LOG_ERROR,
"dlsym(gf_auth) on %s\n", dlerror ());
dict_set (this, key, data_from_dynptr (NULL, 0));
*error = -1;
return;
}
authenticate = dlsym (handle, "gf_auth");
if (!authenticate) {
gf_log ("authenticate", GF_LOG_ERROR,
"dlsym(gf_auth) on %s\n", dlerror ());
dict_set (this, key, data_from_dynptr (NULL, 0));
*error = -1;
return;
}
auth_handle = GF_CALLOC (1, sizeof (*auth_handle),
auth_handle = GF_CALLOC (1, sizeof (*auth_handle),
gf_common_mt_auth_handle_t);
if (!auth_handle) {
gf_log ("authenticate", GF_LOG_ERROR, "Out of memory");
dict_set (this, key, data_from_dynptr (NULL, 0));
*error = -1;
return;
}
auth_handle->vol_opt = GF_CALLOC (1, sizeof (volume_opt_list_t),
gf_common_mt_volume_opt_list_t);
auth_handle->vol_opt->given_opt = dlsym (handle, "options");
if (auth_handle->vol_opt->given_opt == NULL) {
gf_log ("authenticate", GF_LOG_DEBUG,
"volume option validation not specified");
}
if (!auth_handle) {
dict_set (this, key, data_from_dynptr (NULL, 0));
*error = -1;
return;
}
auth_handle->vol_opt = GF_CALLOC (1, sizeof (volume_opt_list_t),
gf_common_mt_volume_opt_list_t);
auth_handle->vol_opt->given_opt = dlsym (handle, "options");
if (auth_handle->vol_opt->given_opt == NULL) {
gf_log ("authenticate", GF_LOG_DEBUG,
"volume option validation not specified");
}
auth_handle->authenticate = authenticate;
auth_handle->handle = handle;
auth_handle->authenticate = authenticate;
auth_handle->handle = handle;
dict_set (this, key,
data_from_dynptr (auth_handle, sizeof (*auth_handle)));
dict_set (this, key,
data_from_dynptr (auth_handle, sizeof (*auth_handle)));
}
static void
fini (dict_t *this,
char *key,
data_t *value,
void *data)
fini (dict_t *this, char *key, data_t *value, void *data)
{
auth_handle_t *handle = data_to_ptr (value);
if (handle) {
dlclose (handle->handle);
}
auth_handle_t *handle = data_to_ptr (value);
if (handle) {
dlclose (handle->handle);
}
}
int32_t
gf_auth_init (xlator_t *xl, dict_t *auth_modules)
{
int ret = 0;
auth_handle_t *handle = NULL;
data_pair_t *pair = NULL;
dict_foreach (auth_modules, init, &ret);
if (!ret) {
pair = auth_modules->members_list;
while (pair) {
handle = data_to_ptr (pair->value);
if (handle) {
list_add_tail (&(handle->vol_opt->list),
&(xl->volume_options));
if (-1 ==
validate_xlator_volume_options (xl,
handle->vol_opt->given_opt)) {
gf_log ("authenticate", GF_LOG_ERROR,
"volume option validation "
"failed");
ret = -1;
}
}
pair = pair->next;
}
}
if (ret) {
gf_log (xl->name, GF_LOG_ERROR, "authentication init failed");
dict_foreach (auth_modules, fini, &ret);
ret = -1;
}
return ret;
int ret = 0;
auth_handle_t *handle = NULL;
data_pair_t *pair = NULL;
dict_foreach (auth_modules, init, &ret);
if (ret)
goto out;
pair = auth_modules->members_list;
while (pair) {
handle = data_to_ptr (pair->value);
if (!handle) {
pair = pair->next;
continue;
}
list_add_tail (&(handle->vol_opt->list),
&(xl->volume_options));
ret = validate_xlator_volume_options (xl,
handle->vol_opt->given_opt);
if (ret)
gf_log ("authenticate", GF_LOG_ERROR,
"volume option validation failed");
pair = pair->next;
}
out:
if (ret) {
gf_log (xl->name, GF_LOG_ERROR, "authentication init failed");
dict_foreach (auth_modules, fini, &ret);
ret = -1;
}
return ret;
}
static dict_t *__input_params;
static dict_t *__config_params;
void
map (dict_t *this,
char *key,
data_t *value,
void *data)
map (dict_t *this, char *key, data_t *value, void *data)
{
dict_t *res = data;
auth_fn_t authenticate;
auth_handle_t *handle = NULL;
dict_t *res = data;
auth_fn_t authenticate;
auth_handle_t *handle = NULL;
if (value && (handle = data_to_ptr (value)) &&
(authenticate = handle->authenticate)) {
dict_set (res, key,
int_to_data (authenticate (__input_params,
__config_params)));
} else {
dict_set (res, key, int_to_data (AUTH_DONT_CARE));
}
if (value && (handle = data_to_ptr (value)) &&
(authenticate = handle->authenticate)) {
dict_set (res, key,
int_to_data (authenticate (__input_params,
__config_params)));
} else {
dict_set (res, key, int_to_data (AUTH_DONT_CARE));
}
}
void
reduce (dict_t *this,
char *key,
data_t *value,
void *data)
reduce (dict_t *this, char *key, data_t *value, void *data)
{
int64_t val = 0;
int64_t *res = data;
if (!data)
return;
int64_t val = 0;
int64_t *res = data;
if (!data)
return;
val = data_to_int64 (value);
switch (val)
{
case AUTH_ACCEPT:
if (AUTH_DONT_CARE == *res)
*res = AUTH_ACCEPT;
break;
val = data_to_int64 (value);
switch (val)
{
case AUTH_ACCEPT:
if (AUTH_DONT_CARE == *res)
*res = AUTH_ACCEPT;
break;
case AUTH_REJECT:
*res = AUTH_REJECT;
break;
case AUTH_REJECT:
*res = AUTH_REJECT;
break;
case AUTH_DONT_CARE:
break;
}
case AUTH_DONT_CARE:
break;
}
}
auth_result_t
gf_authenticate (dict_t *input_params,
dict_t *config_params,
dict_t *auth_modules)
dict_t *config_params,
dict_t *auth_modules)
{
dict_t *results = NULL;
int64_t result = AUTH_DONT_CARE;
char *name = NULL;
dict_t *results = NULL;
int64_t result = AUTH_DONT_CARE;
data_t *peerinfo_data = NULL;
results = get_new_dict ();
__input_params = input_params;
__config_params = config_params;
results = get_new_dict ();
__input_params = input_params;
__config_params = config_params;
dict_foreach (auth_modules, map, results);
dict_foreach (auth_modules, map, results);
dict_foreach (results, reduce, &result);
if (AUTH_DONT_CARE == result) {
data_t *peerinfo_data = dict_get (input_params, "peer-info-name");
char *name = NULL;
dict_foreach (results, reduce, &result);
if (AUTH_DONT_CARE == result) {
peerinfo_data = dict_get (input_params, "peer-info-name");
if (peerinfo_data) {
name = peerinfo_data->data;
}
if (peerinfo_data) {
name = peerinfo_data->data;
}
gf_log ("auth", GF_LOG_ERROR,
"no authentication module is interested in "
"accepting remote-client %s", name);
result = AUTH_REJECT;
}
gf_log ("auth", GF_LOG_ERROR,
"no authentication module is interested in "
"accepting remote-client %s", name);
result = AUTH_REJECT;
}
dict_destroy (results);
return result;
dict_destroy (results);
return result;
}
void
gf_auth_fini (dict_t *auth_modules)
{
int32_t dummy;
int32_t dummy;
dict_foreach (auth_modules, fini, &dummy);
dict_foreach (auth_modules, fini, &dummy);
}

18
xlators/protocol/server/src/authenticate.h
View File

@ -37,23 +37,23 @@
#include "xlator.h"
typedef enum {
AUTH_ACCEPT,
AUTH_REJECT,
AUTH_DONT_CARE
AUTH_ACCEPT,
AUTH_REJECT,
AUTH_DONT_CARE
} auth_result_t;
typedef auth_result_t (*auth_fn_t) (dict_t *input_params,
dict_t *config_params);
dict_t *config_params);
typedef struct {
void *handle;
auth_fn_t authenticate;
volume_opt_list_t *vol_opt;
void *handle;
auth_fn_t authenticate;
volume_opt_list_t *vol_opt;
} auth_handle_t;
auth_result_t gf_authenticate (dict_t *input_params,
dict_t *config_params,
dict_t *auth_modules);
dict_t *config_params,
dict_t *auth_modules);
int32_t gf_auth_init (xlator_t *xl, dict_t *auth_modules);
void gf_auth_fini (dict_t *auth_modules);

10
xlators/protocol/server/src/server-handshake.c
View File

@ -109,14 +109,14 @@ _volfile_update_checksum (xlator_t *this, char *key, uint32_t checksum)
temp_volfile->checksum = checksum;
}
out:
out:
return 0;
}
static size_t
getspec_build_volfile_path (xlator_t *this, const char *key, char *path,
size_t path_len)
size_t path_len)
{
int ret = -1;
int free_filename = 0;
@ -205,7 +205,7 @@ _validate_volfile_checksum (xlator_t *this, char *key,
if (!temp_volfile) {
ret = getspec_build_volfile_path (this, key, filename,
sizeof (filename));
sizeof (filename));
if (ret <= 0)
goto out;
fd = open (filename, O_RDONLY);
@ -438,7 +438,7 @@ server_setvolume (rpcsvc_request_t *req)
ret = gf_asprintf (&msg, "version mismatch: client(%d)"
" - client-mgmt(%d)",
fop_version, mgmt_version);
/* get_supported_version (req)); */
/* get_supported_version (req)); */
if (-1 == ret) {
gf_log (this->name, GF_LOG_ERROR,
"asprintf failed while setting up error msg");
@ -470,7 +470,7 @@ server_setvolume (rpcsvc_request_t *req)
xl = get_xlator_by_name (this, name);
if (xl == NULL) {
ret = gf_asprintf (&msg, "remote-subvolume \"%s\" is not found",
name);
name);
if (-1 == ret) {
gf_log (this->name, GF_LOG_ERROR,
"asprintf failed while setting error msg");

204
xlators/protocol/server/src/server-helpers.c
View File

@ -32,8 +32,8 @@ server_decode_groups (call_frame_t *frame, rpcsvc_request_t *req)
{
int i = 0;
if ((!frame) || (!req))
return 0;
GF_VALIDATE_OR_GOTO ("server", frame, out);
GF_VALIDATE_OR_GOTO ("server", req, out);
frame->root->ngrps = req->auxgidcount;
if (frame->root->ngrps == 0)
@ -44,7 +44,7 @@ server_decode_groups (call_frame_t *frame, rpcsvc_request_t *req)
for (; i < frame->root->ngrps; ++i)
frame->root->groups[i] = req->auxgids[i];
out:
return 0;
}
@ -155,6 +155,11 @@ gf_add_locker (struct _lock_table *table, const char *volume,
int32_t ret = -1;
struct _locker *new = NULL;
GF_VALIDATE_OR_GOTO ("server", table, out);
GF_VALIDATE_OR_GOTO ("server", volume, out);
GF_VALIDATE_OR_GOTO ("server", loc, out);
GF_VALIDATE_OR_GOTO ("server", fd, out);
new = GF_CALLOC (1, sizeof (struct _locker), gf_server_mt_locker_t);
if (new == NULL) {
gf_log ("server", GF_LOG_ERROR,
@ -193,10 +198,15 @@ gf_del_locker (struct _lock_table *table, const char *volume,
{
struct _locker *locker = NULL;
struct _locker *tmp = NULL;
int32_t ret = 0;
int32_t ret = -1;
struct list_head *head = NULL;
struct list_head del;
GF_VALIDATE_OR_GOTO ("server", table, out);
GF_VALIDATE_OR_GOTO ("server", volume, out);
GF_VALIDATE_OR_GOTO ("server", loc, out);
GF_VALIDATE_OR_GOTO ("server", fd, out);
INIT_LIST_HEAD (&del);
LOCK (&table->lock);
@ -237,6 +247,8 @@ gf_del_locker (struct _lock_table *table, const char *volume,
GF_FREE (locker);
}
ret = 0;
out:
return ret;
}
@ -262,14 +274,22 @@ static int
server_nop_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
int32_t op_ret, int32_t op_errno)
{
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);
state = CALL_STATE(frame);
if (state)
free_state (state);
STACK_DESTROY (frame->root);
return 0;
ret = 0;
out:
return ret;
}
int
@ -284,6 +304,11 @@ do_lock_table_cleanup (xlator_t *this, server_connection_t *conn,
int ret = -1;
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", ltable, out);
bound_xl = conn->bound_xl;
INIT_LIST_HEAD (&inodelk_lockers);
INIT_LIST_HEAD (&entrylk_lockers);
@ -311,8 +336,8 @@ do_lock_table_cleanup (xlator_t *this, server_connection_t *conn,
goto out;
}
/*
lock owner = 0 is a special case that tells posix-locks
to release all locks from this transport
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->lk_owner = 0;
@ -416,15 +441,23 @@ server_connection_cleanup_flush_cbk (call_frame_t *frame, void *cookie,
xlator_t *this, int32_t op_ret,
int32_t op_errno)
{
int32_t ret = -1;
fd_t *fd = 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;
fd_unref (fd);
frame->local = NULL;
STACK_DESTROY (frame->root);
return 0;
ret = 0;
out:
return ret;
}
@ -438,6 +471,11 @@ do_fd_cleanup (xlator_t *this, server_connection_t *conn, call_frame_t *frame,
xlator_t *bound_xl = NULL;
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;
for (i = 0;i < fd_count; i++) {
fd = fdentries[i].fd;
@ -493,6 +531,11 @@ do_connection_cleanup (xlator_t *this, server_connection_t *conn,
call_frame_t *frame = NULL;
server_state_t *state = NULL;
GF_VALIDATE_OR_GOTO ("server", this, out);
GF_VALIDATE_OR_GOTO ("server", conn, out);
GF_VALIDATE_OR_GOTO ("server", fdentries, out);
GF_VALIDATE_OR_GOTO ("server", ltable, out);
frame = create_frame (this, this->ctx->pool);
if (frame == NULL) {
gf_log (this->name, GF_LOG_ERROR, "out of memory");
@ -529,9 +572,8 @@ server_connection_cleanup (xlator_t *this, server_connection_t *conn)
uint32_t fd_count = 0;
int ret = 0;
if (conn == NULL) {
goto out;
}
GF_VALIDATE_OR_GOTO ("server", this, out);
GF_VALIDATE_OR_GOTO ("server", conn, out);
pthread_mutex_lock (&conn->lock);
{
@ -577,10 +619,8 @@ server_connection_destroy (xlator_t *this, server_connection_t *conn)
uint32_t fd_count = 0;
char *path = NULL;
if (conn == NULL) {
ret = 0;
goto out;
}
GF_VALIDATE_OR_GOTO ("server", this, out);
GF_VALIDATE_OR_GOTO ("server", conn, out);
bound_xl = (xlator_t *) (conn->bound_xl);
@ -621,8 +661,8 @@ server_connection_destroy (xlator_t *this, server_connection_t *conn)
tmp, &inodelk_lockers, lockers) {
tmp_frame = copy_frame (frame);
/*
lock_owner = 0 is a special case that tells posix-locks
to release all locks from this transport
lock_owner = 0 is a special case that tells posix-locks
to release all locks from this transport
*/
tmp_frame->root->lk_owner = 0;
tmp_frame->root->trans = conn;
@ -766,9 +806,12 @@ out:
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;
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;
@ -793,15 +836,15 @@ server_connection_get (xlator_t *this, const char *id)
conn->this = this;
pthread_mutex_init (&conn->lock, NULL);
list_add (&conn->list, &conf->conns);
}
list_add (&conn->list, &conf->conns);
}
conn->ref++;
conn->active_transports++;
}
}
unlock:
pthread_mutex_unlock (&conf->mutex);
pthread_mutex_unlock (&conf->mutex);
out:
return conn;
}
@ -812,15 +855,11 @@ server_connection_put (xlator_t *this, server_connection_t *conn)
server_conf_t *conf = NULL;
server_connection_t *todel = NULL;
if (conn == NULL) {
goto out;
}
GF_VALIDATE_OR_GOTO ("server", this, out);
GF_VALIDATE_OR_GOTO ("server", conn, out);
conf = this->private;
if (conf == NULL) {
goto out;
}
GF_VALIDATE_OR_GOTO ("server", conf, out);
pthread_mutex_lock (&conf->mutex);
{
@ -848,20 +887,19 @@ server_alloc_frame (rpcsvc_request_t *req)
server_state_t *state = NULL;
server_connection_t *conn = NULL;
GF_VALIDATE_OR_GOTO("server", req, out);
GF_VALIDATE_OR_GOTO("server", req->trans, out);
GF_VALIDATE_OR_GOTO("server", req->svc, out);
GF_VALIDATE_OR_GOTO("server", req->svc->ctx, out);
GF_VALIDATE_OR_GOTO ("server", req, out);
GF_VALIDATE_OR_GOTO ("server", req->trans, out);
GF_VALIDATE_OR_GOTO ("server", req->svc, out);
GF_VALIDATE_OR_GOTO ("server", req->svc->ctx, out);
conn = (server_connection_t *)req->trans->xl_private;
if (!conn)
goto out;
GF_VALIDATE_OR_GOTO ("server", conn, out);
frame = create_frame (conn->this, req->svc->ctx->pool);
GF_VALIDATE_OR_GOTO("server", frame, out);
GF_VALIDATE_OR_GOTO ("server", frame, out);
state = GF_CALLOC (1, sizeof (*state), gf_server_mt_state_t);
GF_VALIDATE_OR_GOTO("server", state, out);
GF_VALIDATE_OR_GOTO ("server", state, out);
if (conn->bound_xl)
state->itable = conn->bound_xl->itable;
@ -887,9 +925,10 @@ get_frame_from_request (rpcsvc_request_t *req)
{
call_frame_t *frame = NULL;
GF_VALIDATE_OR_GOTO ("server", req, out);
frame = server_alloc_frame (req);
if (!frame)
goto out;
GF_VALIDATE_OR_GOTO ("server", frame, out);
frame->root->op = req->procnum;
frame->root->type = req->type;
@ -917,6 +956,9 @@ server_build_config (xlator_t *this, server_conf_t *conf)
int ret = -1;
struct stat buf = {0,};
GF_VALIDATE_OR_GOTO ("server", this, out);
GF_VALIDATE_OR_GOTO ("server", conf, out);
ret = dict_get_int32 (this->options, "inode-lru-limit",
&conf->inode_lru_limit);
if (ret < 0) {
@ -935,14 +977,14 @@ server_build_config (xlator_t *this, server_conf_t *conf)
}
data = dict_get (this->options, "trace");
if (data) {
if (data) {
ret = gf_string2boolean (data->data, &conf->trace);
if (ret != 0) {
gf_log (this->name, GF_LOG_WARNING,
"'trace' takes on only boolean values. "
gf_log (this->name, GF_LOG_WARNING,
"'trace' takes on only boolean values. "
"Neglecting option");
}
}
}
}
/* TODO: build_rpc_config (); */
ret = dict_get_int32 (this->options, "limits.transaction-size",
@ -984,7 +1026,12 @@ out:
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 *
@ -993,6 +1040,9 @@ 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;
@ -1022,9 +1072,7 @@ out:
void
destroy_server_conn_state (server_connection_t *conn)
{
if (!conn) {
return;
}
GF_VALIDATE_OR_GOTO ("server", conn, out);
if (conn->ltable) {
/* TODO */
@ -1038,7 +1086,7 @@ destroy_server_conn_state (server_connection_t *conn)
pthread_mutex_destroy (&conn->lock);
GF_FREE (conn);
out:
return;
}
@ -1048,6 +1096,9 @@ print_caller (char *str, int size, call_frame_t *frame)
{
server_state_t *state = NULL;
GF_VALIDATE_OR_GOTO ("server", str, out);
GF_VALIDATE_OR_GOTO ("server", frame, out);
state = CALL_STATE (frame);
snprintf (str, size,
@ -1055,6 +1106,7 @@ print_caller (char *str, int size, call_frame_t *frame)
frame->root->unique,
state->xprt->peerinfo.identifier);
out:
return;
}
@ -1064,6 +1116,8 @@ server_print_resolve (char *str, int size, server_resolve_t *resolve)
{
int filled = 0;
GF_VALIDATE_OR_GOTO ("server", str, out);
if (!resolve) {
snprintf (str, size, "<nul>");
return;
@ -1091,6 +1145,8 @@ server_print_resolve (char *str, int size, server_resolve_t *resolve)
"path=%s", resolve->path);
snprintf (str + filled, size - filled, "}");
out:
return;
}
@ -1099,6 +1155,8 @@ server_print_loc (char *str, int size, loc_t *loc)
{
int filled = 0;
GF_VALIDATE_OR_GOTO ("server", str, out);
if (!loc) {
snprintf (str, size, "<nul>");
return;
@ -1118,6 +1176,8 @@ server_print_loc (char *str, int size, loc_t *loc)
"parent=%p", loc->parent);
snprintf (str + filled, size - filled, "}");
out:
return;
}
@ -1126,6 +1186,8 @@ server_print_params (char *str, int size, server_state_t *state)
{
int filled = 0;
GF_VALIDATE_OR_GOTO ("server", str, out);
filled += snprintf (str + filled, size - filled,
" Params={");
@ -1165,6 +1227,8 @@ server_print_params (char *str, int size, server_state_t *state)
snprintf (str + filled, size - filled,
"bound_xl=%s}", state->conn->bound_xl->name);
out:
return;
}
int
@ -1201,11 +1265,13 @@ server_print_reply (call_frame_t *frame, int op_ret, int op_errno)
char fdstr[32];
char *op = "UNKNOWN";
GF_VALIDATE_OR_GOTO ("server", frame, out);
this = frame->this;
conf = this->private;
if (!conf || !conf->trace)
return;
GF_VALIDATE_OR_GOTO ("server", conf, out);
GF_VALIDATE_OR_GOTO ("server", conf->trace, out);
state = CALL_STATE (frame);
@ -1229,6 +1295,8 @@ server_print_reply (call_frame_t *frame, int op_ret, int op_errno)
gf_log (this->name, GF_LOG_NORMAL,
"%s%s => (%d, %d)%s",
op, caller, op_ret, op_errno, fdstr);
out:
return;
}
@ -1246,11 +1314,13 @@ server_print_request (call_frame_t *frame)
char caller[512];
char *op = "UNKNOWN";
GF_VALIDATE_OR_GOTO ("server", frame, out);
this = frame->this;
conf = this->private;
if (!conf || !conf->trace)
return;
GF_VALIDATE_OR_GOTO ("server", conf, out);
GF_VALIDATE_OR_GOTO ("server", conf->trace, out);
state = CALL_STATE (frame);
@ -1290,17 +1360,22 @@ server_print_request (call_frame_t *frame)
"%s%s%s%s%s%s%s",
op, caller,
resolve_vars, loc_vars, resolve2_vars, loc2_vars, other_vars);
out:
return;
}
int
serialize_rsp_direntp (gf_dirent_t *entries, gfs3_readdirp_rsp *rsp)
{
gf_dirent_t *entry = NULL;
gf_dirent_t *entry = NULL;
gfs3_dirplist *trav = NULL;
gfs3_dirplist *prev = NULL;
int ret = -1;
int ret = -1;
list_for_each_entry (entry, &entries->list, list) {
GF_VALIDATE_OR_GOTO ("server", entries, out);
GF_VALIDATE_OR_GOTO ("server", rsp, out);
list_for_each_entry (entry, &entries->list, list) {
trav = GF_CALLOC (1, sizeof (*trav), gf_server_mt_dirent_rsp_t);
if (!trav)
goto out;
@ -1320,7 +1395,7 @@ serialize_rsp_direntp (gf_dirent_t *entries, gfs3_readdirp_rsp *rsp)
rsp->reply = trav;
prev = trav;
}
}
ret = 0;
out:
@ -1331,12 +1406,15 @@ out:
int
serialize_rsp_dirent (gf_dirent_t *entries, gfs3_readdir_rsp *rsp)
{
gf_dirent_t *entry = NULL;
gf_dirent_t *entry = NULL;
gfs3_dirlist *trav = NULL;
gfs3_dirlist *prev = NULL;
int ret = -1;
int ret = -1;
list_for_each_entry (entry, &entries->list, list) {
GF_VALIDATE_OR_GOTO ("server", entries, out);
GF_VALIDATE_OR_GOTO ("server", rsp, out);
list_for_each_entry (entry, &entries->list, list) {
trav = GF_CALLOC (1, sizeof (*trav), gf_server_mt_dirent_rsp_t);
if (!trav)
goto out;
@ -1351,7 +1429,7 @@ serialize_rsp_dirent (gf_dirent_t *entries, gfs3_readdir_rsp *rsp)
rsp->reply = trav;
prev = trav;
}
}
ret = 0;
out:

24
xlators/protocol/server/src/server-helpers.h
View File

@ -28,16 +28,16 @@
#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_CONNECTION(frame) \
((server_connection_t *) CALL_STATE(frame)->conn)
#define SERVER_CONF(frame) \
((server_conf_t *)XPRT_FROM_FRAME(frame)->this->private)
#define SERVER_CONF(frame) \
((server_conf_t *)XPRT_FROM_FRAME(frame)->this->private)
#define XPRT_FROM_XLATOR(this) ((((server_conf_t *)this->private))->listen)
#define INODE_LRU_LIMIT(this) \
(((server_conf_t *)(this->private))->config.inode_lru_limit)
#define INODE_LRU_LIMIT(this) \
(((server_conf_t *)(this->private))->config.inode_lru_limit)
#define IS_ROOT_INODE(inode) (inode == inode->table->root)
@ -49,17 +49,17 @@ void server_loc_wipe (loc_t *loc);
int32_t
gf_add_locker (struct _lock_table *table, const char *volume,
loc_t *loc,
fd_t *fd,
pid_t pid,
loc_t *loc,
fd_t *fd,
pid_t pid,
uint64_t owner,
glusterfs_fop_t type);
int32_t
gf_del_locker (struct _lock_table *table, const char *volume,
loc_t *loc,
fd_t *fd,
uint64_t owner,
loc_t *loc,
fd_t *fd,
uint64_t owner,
glusterfs_fop_t type);
void

26
xlators/protocol/server/src/server-mem-types.h
View File

@ -1,20 +1,20 @@
/*
Copyright (c) 2010 Gluster, Inc. <http://www.gluster.com>
This file is part of GlusterFS.
Copyright (c) 2010 Gluster, Inc. <http://www.gluster.com>
This file is part of GlusterFS.
GlusterFS is free software; you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License as published
by the Free Software Foundation; either version 3 of the License,
or (at your option) any later version.
GlusterFS is free software; you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License as published
by the Free Software Foundation; either version 3 of the License,
or (at your option) any later version.
GlusterFS is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Affero General Public License for more details.
GlusterFS is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Affero General Public License for more details.
You should have received a copy of the GNU Affero General Public License
along with this program. If not, see
<http://www.gnu.org/licenses/>.
You should have received a copy of the GNU Affero General Public License
along with this program. If not, see
<http://www.gnu.org/licenses/>.
*/

5
xlators/protocol/server/src/server-resolve.c
View File

@ -61,7 +61,6 @@ prepare_components (call_frame_t *frame)
int i = 0;
char *trav = NULL;
state = CALL_STATE (frame);
resolve = state->resolve_now;
@ -71,8 +70,8 @@ prepare_components (call_frame_t *frame)
count = component_count (resolve->path);
components = GF_CALLOC (sizeof (*components), count,
gf_server_mt_resolv_comp_t);
if (!components)
goto out;
GF_VALIDATE_OR_GOTO ("server", components, out);
resolve->components = components;
components[0].basename = "";

231
xlators/protocol/server/src/server.c
View File

@ -43,6 +43,8 @@ gfs_serialize_reply (rpcsvc_request_t *req, void *arg, gfs_serialize_t sfunc,
struct iobuf *iob = NULL;
ssize_t retlen = -1;
GF_VALIDATE_OR_GOTO ("server", req, ret);
/* First, get the io buffer into which the reply in arg will
* be serialized.
*/
@ -93,9 +95,7 @@ server_submit_reply (call_frame_t *frame, rpcsvc_request_t *req, void *arg,
server_state_t *state = NULL;
char new_iobref = 0;
if (!req) {
goto ret;
}
GF_VALIDATE_OR_GOTO ("server", req, ret);
if (frame) {
state = CALL_STATE (frame);
@ -126,7 +126,7 @@ server_submit_reply (call_frame_t *frame, rpcsvc_request_t *req, void *arg,
/* TODO: this is demo purpose only */
/* ret = rpcsvc_callback_submit (req->svc, req->trans, req->prog,
GF_CBK_NULL, &rsp, 1);
GF_CBK_NULL, &rsp, 1);
*/
/* Now that we've done our job of handing the message to the RPC layer
* we can safely unref the iob in the hope that RPC layer must have
@ -161,74 +161,73 @@ xdr_to_glusterfs_req (rpcsvc_request_t *req, void *arg, gfs_serialize_t sfunc)
{
int ret = -1;
if (!req)
return -1;
GF_VALIDATE_OR_GOTO ("server", req, out);
ret = sfunc (req->msg[0], arg);
if (ret > 0)
ret = 0;
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;
server_conf_t *conf = NULL;
server_connection_t *trav = NULL;
char key[GF_DUMP_MAX_BUF_LEN];
int i = 1;
int ret = -1;
if (!this)
return -1;
GF_VALIDATE_OR_GOTO ("server", this, out);
conf = this->private;
if (!conf) {
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");
gf_proc_dump_add_section("xlator.protocol.server.conn");
ret = pthread_mutex_trylock (&conf->mutex);
if (ret) {
ret = pthread_mutex_trylock (&conf->mutex);
if (ret) {
gf_log("", GF_LOG_WARNING, "Unable to dump fdtable"
" errno: %d", errno);
" errno: %d", errno);
return -1;
}
list_for_each_entry (trav, &conf->conns, list) {
if (trav->id) {
gf_proc_dump_build_key(key,
"xlator.protocol.server.conn",
"%d.id", i);
gf_proc_dump_write(key, "%s", trav->id);
}
list_for_each_entry (trav, &conf->conns, list) {
if (trav->id) {
gf_proc_dump_build_key(key,
"xlator.protocol.server.conn",
"%d.id", i);
gf_proc_dump_write(key, "%s", trav->id);
}
gf_proc_dump_build_key(key,"xlator.protocol.server.conn",
"%d.ref",i)
gf_proc_dump_write(key, "%d", trav->ref);
if (trav->bound_xl) {
gf_proc_dump_build_key(key,
"xlator.protocol.server.conn",
"%d.bound_xl", i);
gf_proc_dump_write(key, "%s", trav->bound_xl->name);
}
gf_proc_dump_build_key(key,"xlator.protocol.server.conn",
"%d.ref",i)
gf_proc_dump_write(key, "%d", trav->ref);
if (trav->bound_xl) {
gf_proc_dump_build_key(key,
"xlator.protocol.server.conn",
"%d.bound_xl", i);
gf_proc_dump_write(key, "%s", trav->bound_xl->name);
}
gf_proc_dump_build_key(key,
"xlator.protocol.server.conn",
"%d.id", i);
fdtable_dump(trav->fdtable,key);
i++;
}
gf_proc_dump_build_key(key,
"xlator.protocol.server.conn",
"%d.id", i);
fdtable_dump(trav->fdtable,key);
i++;
}
pthread_mutex_unlock (&conf->mutex);
return 0;
}
ret = 0;
out:
return ret;
}
int
server_priv (xlator_t *this)
@ -238,6 +237,9 @@ server_priv (xlator_t *this)
char key[GF_DUMP_MAX_BUF_LEN] = {0,};
uint64_t total_read = 0;
uint64_t total_write = 0;
int32_t ret = -1;
GF_VALIDATE_OR_GOTO ("server", this, out);
conf = this->private;
if (!conf)
@ -254,49 +256,51 @@ server_priv (xlator_t *this)
gf_proc_dump_build_key(key, "server", "total-bytes-write");
gf_proc_dump_write(key, "%"PRIu64, total_write);
return 0;
ret = 0;
out:
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;
server_conf_t *conf = NULL;
server_connection_t *trav = NULL;
char key[GF_DUMP_MAX_BUF_LEN];
int i = 1;
int ret = -1;
if (!this)
return -1;
GF_VALIDATE_OR_GOTO ("server", this, out);
conf = this->private;
if (!conf) {
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) {
ret = pthread_mutex_trylock (&conf->mutex);
if (ret) {
gf_log("", GF_LOG_WARNING, "Unable to dump itable"
" errno: %d", errno);
" errno: %d", errno);
return -1;
}
list_for_each_entry (trav, &conf->conns, list) {
if (trav->bound_xl && trav->bound_xl->itable) {
gf_proc_dump_build_key(key,
"xlator.protocol.server.conn",
"%d.bound_xl.%s",
i, trav->bound_xl->name);
inode_table_dump(trav->bound_xl->itable,key);
i++;
}
if (trav->bound_xl && trav->bound_xl->itable) {
gf_proc_dump_build_key(key,
"xlator.protocol.server.conn",
"%d.bound_xl.%s",
i, trav->bound_xl->name);
inode_table_dump(trav->bound_xl->itable,key);
i++;
}
}
pthread_mutex_unlock (&conf->mutex);
return 0;
ret = 0;
out:
return ret;
}
@ -309,6 +313,10 @@ get_auth_types (dict_t *this, char *key, data_t *value, void *data)
char *key_cpy = NULL;
int32_t ret = -1;
GF_VALIDATE_OR_GOTO ("server", this, out);
GF_VALIDATE_OR_GOTO ("server", key, out);
GF_VALIDATE_OR_GOTO ("server", data, out);
auth_dict = data;
key_cpy = gf_strdup (key);
GF_VALIDATE_OR_GOTO("server", key_cpy, out);
@ -340,11 +348,14 @@ out:
int
validate_auth_options (xlator_t *this, dict_t *dict)
{
int error = 0;
int error = -1;
xlator_list_t *trav = NULL;
data_pair_t *pair = NULL;
char *tail = NULL;
GF_VALIDATE_OR_GOTO ("server", this, out);
GF_VALIDATE_OR_GOTO ("server", dict, out);
trav = this->children;
while (trav) {
error = -1;
@ -376,7 +387,7 @@ validate_auth_options (xlator_t *this, dict_t *dict)
}
trav = trav->next;
}
out:
return error;
}
@ -406,11 +417,11 @@ 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)
goto out;
conn = create_server_conn_state (this, xprt);
if (!conn)
goto out;
xprt->protocol_private = conn;
xprt->protocol_private = conn;
*/
INIT_LIST_HEAD (&xprt->list);
@ -448,17 +459,16 @@ mem_acct_init (xlator_t *this)
{
int ret = -1;
if (!this)
return ret;
GF_VALIDATE_OR_GOTO ("server", this, out);
ret = xlator_mem_acct_init (this, gf_server_mt_end + 1);
if (ret != 0) {
gf_log (this->name, GF_LOG_ERROR, "Memory accounting init"
"failed");
"failed");
return ret;
}
out:
return ret;
}
@ -478,14 +488,14 @@ validate_options (xlator_t *this, dict_t *options, char **op_errstr)
if (!(inode_lru_limit < (1 * GF_UNIT_MB) &&
inode_lru_limit >1 )) {
gf_log (this->name, GF_LOG_DEBUG, "Validate inode-lru"
"-limit %d, was WRONG", inode_lru_limit);
"-limit %d, was WRONG", inode_lru_limit);
snprintf (errstr,1024, "Error, Greater than max value %d "
,inode_lru_limit);
,inode_lru_limit);
*op_errstr = gf_strdup (errstr);
ret = -1;
goto out;
}
}
}
data = dict_get (options, "trace");
@ -494,9 +504,9 @@ validate_options (xlator_t *this, dict_t *options, char **op_errstr)
if (ret != 0) {
gf_log (this->name, GF_LOG_WARNING,
"'trace' takes on only boolean values. "
"Neglecting option");
"Neglecting option");
snprintf (errstr,1024, "Error, trace takes only boolean"
"values");
"values");
*op_errstr = gf_strdup (errstr);
ret = -1;
goto out;
@ -566,32 +576,32 @@ int
reconfigure (xlator_t *this, dict_t *options)
{
server_conf_t *conf =NULL;
server_conf_t *conf =NULL;
rpcsvc_t *rpc_conf;
rpcsvc_listener_t *listeners;
int inode_lru_limit;
gf_boolean_t trace;
data_t *data;
int ret = 0;
int inode_lru_limit;
gf_boolean_t trace;
data_t *data;
int ret = 0;
conf = this->private;
conf = this->private;
if (!conf) {
gf_log (this->name, GF_LOG_DEBUG, "conf == null!!!");
goto out;
}
if (dict_get_int32 ( options, "inode-lru-limit", &inode_lru_limit) == 0){
conf->inode_lru_limit = inode_lru_limit;
gf_log (this->name, GF_LOG_TRACE, "Reconfigured inode-lru-limit"
" to %d", conf->inode_lru_limit);
}
if (dict_get_int32 ( options, "inode-lru-limit", &inode_lru_limit) == 0){
conf->inode_lru_limit = inode_lru_limit;
gf_log (this->name, GF_LOG_TRACE, "Reconfigured inode-lru-limit"
" to %d", conf->inode_lru_limit);
}
data = dict_get (options, "trace");
if (data) {
data = dict_get (options, "trace");
if (data) {
ret = gf_string2boolean (data->data, &trace);
if (ret != 0) {
gf_log (this->name, GF_LOG_WARNING,
"'trace' takes on only boolean values. "
gf_log (this->name, GF_LOG_WARNING,
"'trace' takes on only boolean values. "
"Neglecting option");
ret = -1;
goto out;
@ -630,13 +640,11 @@ reconfigure (xlator_t *this, dict_t *options)
if (listeners->trans->reconfigure )
listeners->trans->reconfigure (listeners->trans, options);
else
gf_log (this->name, GF_LOG_ERROR,
"Reconfigure not found for transport" );
gf_log (this->name, GF_LOG_ERROR,
"Reconfigure not found for transport" );
}
}
out:
gf_log ("", GF_LOG_DEBUG, "returning %d", ret);
return ret;
@ -649,8 +657,7 @@ init (xlator_t *this)
server_conf_t *conf = NULL;
rpcsvc_listener_t *listener = NULL;
if (!this)
goto out;
GF_VALIDATE_OR_GOTO ("init", this, out);
if (this->children == NULL) {
gf_log (this->name, GF_LOG_ERROR,
@ -664,7 +671,9 @@ init (xlator_t *this)
goto out;
}
conf = GF_CALLOC (1, sizeof (server_conf_t), gf_server_mt_server_conf_t);
conf = GF_CALLOC (1, sizeof (server_conf_t),
gf_server_mt_server_conf_t);
GF_VALIDATE_OR_GOTO(this->name, conf, out);
INIT_LIST_HEAD (&conf->conns);
@ -798,10 +807,10 @@ fini (xlator_t *this)
if (conf->rpc) {
/* TODO: memory leak here, have to free RPC */
/*
if (conf->rpc->conn) {
rpcsvc_conn_destroy (conf->rpc->conn);
}
rpcsvc_fini (conf->rpc);
if (conf->rpc->conn) {
rpcsvc_conn_destroy (conf->rpc->conn);
}
rpcsvc_fini (conf->rpc);
*/
;
}

74
xlators/protocol/server/src/server.h
View File

@ -35,34 +35,34 @@
typedef struct _server_state server_state_t;
struct _locker {
struct list_head lockers;
struct list_head lockers;
char *volume;
loc_t loc;
fd_t *fd;
loc_t loc;
fd_t *fd;
uint64_t owner;
pid_t pid;
pid_t pid;
};
struct _lock_table {
struct list_head inodelk_lockers;
struct list_head entrylk_lockers;
gf_lock_t lock;
size_t count;
struct list_head inodelk_lockers;
struct list_head entrylk_lockers;
gf_lock_t lock;
size_t count;
};
/* private structure per connection (transport object)
* used as transport_t->xl_private
*/
struct _server_connection {
struct list_head list;
char *id;
int ref;
struct list_head list;
char *id;
int ref;
int active_transports;
pthread_mutex_t lock;
char disconnected;
fdtable_t *fdtable;
struct _lock_table *ltable;
xlator_t *bound_xl;
pthread_mutex_t lock;
char disconnected;
fdtable_t *fdtable;
struct _lock_table *ltable;
xlator_t *bound_xl;
xlator_t *this;
};
@ -95,9 +95,9 @@ struct server_conf {
char *conf_dir;
struct _volfile_ctx *volfile;
dict_t *auth_modules;
pthread_mutex_t mutex;
struct list_head conns;
dict_t *auth_modules;
pthread_mutex_t mutex;
struct list_head conns;
struct list_head xprt_list;
};
typedef struct server_conf server_conf_t;
@ -129,7 +129,7 @@ typedef struct {
u_char pargfid[16];
char *path;
char *bname;
char *resolved;
char *resolved;
int op_ret;
int op_errno;
loc_t deep_loc;
@ -150,8 +150,8 @@ struct _server_state {
server_resume_fn_t resume_fn;
loc_t loc;
loc_t loc2;
loc_t loc;
loc_t loc2;
server_resolve_t resolve;
server_resolve_t resolve2;
@ -162,29 +162,29 @@ struct _server_state {
struct iatt stbuf;
int valid;
fd_t *fd;
fd_t *fd;
dict_t *params;
int flags;
int flags;
int wbflags;
struct iovec payload_vector[MAX_IOVEC];
int payload_count;
struct iobuf *iobuf;
struct iobref *iobref;
size_t size;
off_t offset;
mode_t mode;
dev_t dev;
size_t nr_count;
int cmd;
int type;
char *name;
int name_len;
size_t size;
off_t offset;
mode_t mode;
dev_t dev;
size_t nr_count;
int cmd;
int type;
char *name;
int name_len;
int mask;
char is_revalidate;
dict_t *dict;
struct gf_flock flock;
int mask;
char is_revalidate;
dict_t *dict;
struct gf_flock flock;
const char *volume;
dir_entry_t *entry;
};

15
xlators/protocol/server/src/server3_1-fops.c
View File

@ -1328,8 +1328,8 @@ server_create_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
if (link_inode != inode) {
/*
VERY racy code (if used anywhere else)
-- don't do this without understanding
VERY racy code (if used anywhere else)
-- don't do this without understanding
*/
inode_unref (fd->inode);
@ -2025,7 +2025,7 @@ err:
int
server_readdir_resume (call_frame_t *frame, xlator_t *bound_xl)
server_readdir_resume (call_frame_t *frame, xlator_t *bound_xl)
{
server_state_t *state = NULL;
@ -4835,7 +4835,7 @@ server_lk (rpcsvc_request_t *req)
case GF_LK_SETLKW:
state->cmd = F_SETLKW;
break;
case GF_LK_RESLK_LCK:
case GF_LK_RESLK_LCK:
state->cmd = F_RESLK_LCK;
break;
case GF_LK_RESLK_LCKW:
@ -4946,8 +4946,7 @@ server_lookup (rpcsvc_request_t *req)
gfs3_lookup_req args = {{0,},};
int ret = -1;
if (!req)
return ret;
GF_VALIDATE_OR_GOTO ("server", req, err);
conn = req->trans->xl_private;
@ -5113,8 +5112,8 @@ rpcsvc_actor_t glusterfs3_1_fop_actors[] = {
[GFS3_OP_READDIR] = { "READDIR", GFS3_OP_READDIR, server_readdir, NULL, NULL },
[GFS3_OP_INODELK] = { "INODELK", GFS3_OP_INODELK, server_inodelk, NULL, NULL },
[GFS3_OP_FINODELK] = { "FINODELK", GFS3_OP_FINODELK, server_finodelk, NULL, NULL },
[GFS3_OP_ENTRYLK] = { "ENTRYLK", GFS3_OP_ENTRYLK, server_entrylk, NULL, NULL },
[GFS3_OP_FENTRYLK] = { "FENTRYLK", GFS3_OP_FENTRYLK, server_fentrylk, NULL, NULL },
[GFS3_OP_ENTRYLK] = { "ENTRYLK", GFS3_OP_ENTRYLK, server_entrylk, NULL, NULL },
[GFS3_OP_FENTRYLK] = { "FENTRYLK", GFS3_OP_FENTRYLK, server_fentrylk, NULL, NULL },
[GFS3_OP_XATTROP] = { "XATTROP", GFS3_OP_XATTROP, server_xattrop, NULL, NULL },
[GFS3_OP_FXATTROP] = { "FXATTROP", GFS3_OP_FXATTROP, server_fxattrop, NULL, NULL },
[GFS3_OP_FGETXATTR] = { "FGETXATTR", GFS3_OP_FGETXATTR, server_fgetxattr, NULL, NULL },