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

protocol: Implement put fop

Browse Source 
Updates #353
Change-Id: I755b9208690be76935d763688fa414521eba3a40
Signed-off-by: Poornima G <pgurusid@redhat.com>
This commit is contained in:
Poornima G 2018-01-16 14:14:39 +05:30 committed by Amar Tumballi
parent bb34b07fd2
commit 542af5714d
9 changed files with 356 additions and 1 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
rpc/rpc-lib/src/protocol-common.h
View File

@ -67,6 +67,7 @@ enum gf_fop_procnum {
GFS3_OP_SETACTIVELK,
GFS3_OP_ICREATE,
GFS3_OP_NAMELINK,
GFS3_OP_PUT,
GFS3_OP_MAXVALUE,
};

12
rpc/xdr/src/glusterfs4-xdr.x
View File

@ -153,6 +153,18 @@ struct gfx_icreate_req {
gfx_dict xdata;
};
struct gfx_put_req {
opaque pargfid[16];
string bname<>;
unsigned int mode;
unsigned int umask;
unsigned int flag;
u_quad_t offset;
unsigned int size;
gfx_dict xattr;
gfx_dict xdata;
};
struct gfx_namelink_req {
opaque pargfid[16];
string bname<>;

1
rpc/xdr/src/libgfxdr.sym
View File

@ -339,6 +339,7 @@ xdr_gfx_getsnap_name_uuid_rsp
xdr_gfx_getactivelk_rsp
xdr_gfx_getactivelk_req
xdr_gfx_setactivelk_req
xdr_gfx_put_req
xdr_compound_req_v2
xdr_gfx_compound_req
xdr_compound_rsp_v2

35
xlators/protocol/client/src/client-common.c
View File

@ -3522,6 +3522,41 @@ out:
return -op_errno;
}
int
client_pre_put_v2 (xlator_t *this, gfx_put_req *req, loc_t *loc, mode_t mode,
mode_t umask, int32_t flags, size_t size, off_t offset,
dict_t *xattr, dict_t *xdata)
{
int op_errno = ESTALE;
if (!(loc && loc->parent))
goto out;
if (!gf_uuid_is_null (loc->parent->gfid))
memcpy (req->pargfid, loc->parent->gfid, 16);
else
memcpy (req->pargfid, loc->pargfid, 16);
GF_ASSERT_AND_GOTO_WITH_ERROR (this->name,
!gf_uuid_is_null (*((uuid_t *)req->pargfid)),
out, op_errno, EINVAL);
req->bname = (char *)loc->name;
req->mode = mode;
req->umask = umask;
req->flag = gf_flags_from_flags (flags);
req->size = size;
req->offset = offset;
if (xattr)
dict_to_xdr (xattr, &req->xattr);
dict_to_xdr (xdata, &req->xdata);
return 0;
out:
return -op_errno;
}
int
client_post_create_v2 (xlator_t *this, gfx_create_rsp *rsp,
struct iatt *stbuf, struct iatt *preparent,

5
xlators/protocol/client/src/client-common.h
View File

@ -609,6 +609,11 @@ int
client_pre_lease_v2 (xlator_t *this, gfx_lease_req *req, loc_t *loc,
struct gf_lease *lease, dict_t *xdata);
int
client_pre_put_v2 (xlator_t *this, gfx_put_req *req, loc_t *loc, mode_t mode,
mode_t umask, int32_t flags, size_t size, off_t offset,
dict_t *xattr, dict_t *xdata);
int
client_post_readv_v2 (xlator_t *this, gfx_read_rsp *rsp, struct iobref **iobref,
struct iobref *rsp_iobref, struct iatt *stat,

121
xlators/protocol/client/src/client-rpc-fops_v2.c
View File

@ -5479,6 +5479,68 @@ client4_icreate_cbk (struct rpc_req *req,
dict_unref (xdata);
return 0;
}
int
client4_0_put_cbk (struct rpc_req *req, struct iovec *iov, int count,
void *myframe)
{
gfx_common_3iatt_rsp rsp = {0,};
call_frame_t *frame = NULL;
int ret = 0;
xlator_t *this = NULL;
dict_t *xdata = NULL;
clnt_local_t *local = NULL;
struct iatt stbuf = {0, };
struct iatt preparent = {0, };
struct iatt postparent = {0, };
inode_t *inode = NULL;
this = THIS;
frame = myframe;
local = frame->local;
inode = local->loc.inode;
if (-1 == req->rpc_status) {
rsp.op_ret = -1;
rsp.op_errno = ENOTCONN;
goto out;
}
ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gfx_common_3iatt_rsp);
if (ret < 0) {
gf_msg (this->name, GF_LOG_ERROR, EINVAL,
PC_MSG_XDR_DECODING_FAILED, "XDR decoding failed");
rsp.op_ret = -1;
rsp.op_errno = EINVAL;
goto out;
}
if (-1 != rsp.op_ret) {
ret = client_post_common_3iatt (this, &rsp, &stbuf, &preparent,
&postparent, &xdata);
if (ret < 0)
goto out;
}
out:
if (rsp.op_ret == -1) {
gf_msg (this->name, GF_LOG_WARNING,
gf_error_to_errno (rsp.op_errno),
PC_MSG_REMOTE_OP_FAILED,
"remote operation failed");
}
CLIENT_STACK_UNWIND (put, frame, rsp.op_ret,
gf_error_to_errno (rsp.op_errno), inode, &stbuf,
&preparent, &postparent, xdata);
if (xdata)
dict_unref (xdata);
return 0;
}
int32_t
client4_namelink (call_frame_t *frame, xlator_t *this, void *data)
{
@ -5574,6 +5636,65 @@ client4_icreate (call_frame_t *frame, xlator_t *this, void *data)
return 0;
}
int32_t
client4_0_put (call_frame_t *frame, xlator_t *this, void *data)
{
clnt_args_t *args = NULL;
clnt_conf_t *conf = NULL;
gfx_put_req req = {{0,},};
int op_errno = ESTALE;
int ret = 0;
clnt_local_t *local = NULL;
if (!frame || !this || !data)
goto unwind;
args = data;
conf = this->private;
local = mem_get0 (this->local_pool);
if (!local) {
op_errno = ENOMEM;
goto unwind;
}
frame->local = local;
loc_copy (&local->loc, args->loc);
loc_path (&local->loc, NULL);
ret = client_pre_put_v2 (this, &req, args->loc, args->mode, args->umask,
args->flags, args->size, args->offset,
args->xattr, args->xdata);
if (ret) {
op_errno = -ret;
goto unwind;
}
ret = client_submit_vec_request (this, &req, frame, conf->fops,
GFS3_OP_PUT, client4_0_put_cbk,
args->vector, args->count,
args->iobref,
(xdrproc_t)xdr_gfx_put_req);
if (ret) {
/*
* If the lower layers fail to submit a request, they'll also
* do the unwind for us (see rpc_clnt_submit), so don't unwind
* here in such cases.
*/
gf_msg (this->name, GF_LOG_WARNING, 0, PC_MSG_FOP_SEND_FAILED,
"failed to send the fop");
}
return 0;
unwind:
CLIENT_STACK_UNWIND (put, frame, -1, op_errno, NULL, NULL, NULL, NULL,
NULL);
return 0;
}
int32_t
client4_0_fsetattr (call_frame_t *frame, xlator_t *this, void *data)
{

40
xlators/protocol/client/src/client.c
View File

@ -2134,6 +2134,45 @@ client_icreate (call_frame_t *frame,
return 0;
}
int32_t
client_put (call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode,
mode_t umask, uint32_t flags, struct iovec *vector, int32_t count,
off_t off, struct iobref *iobref, dict_t *xattr, dict_t *xdata)
{
int ret = -1;
clnt_conf_t *conf = NULL;
rpc_clnt_procedure_t *proc = NULL;
clnt_args_t args = {0,};
conf = this->private;
if (!conf || !conf->fops)
goto out;
args.loc = loc;
args.mode = mode;
args.umask = umask;
args.flags = flags;
args.vector = vector;
args.count = count;
args.offset = off;
args.size = iov_length (vector, count);
args.iobref = iobref;
args.xattr = xattr;
args.xdata = xdata;
client_filter_o_direct (conf, &args.flags);
proc = &conf->fops->proctable[GF_FOP_PUT];
if (proc->fn)
ret = proc->fn (frame, this, &args);
out:
if (ret)
STACK_UNWIND_STRICT (put, frame, -1, ENOTCONN, NULL, NULL,
NULL, NULL, NULL);
return 0;
}
int
client_mark_fd_bad (xlator_t *this)
{
@ -2854,6 +2893,7 @@ struct xlator_fops fops = {
.setactivelk = client_setactivelk,
.icreate = client_icreate,
.namelink = client_namelink,
.put = client_put,
};

3
xlators/protocol/server/src/server-messages.h
View File

@ -115,7 +115,8 @@ GLFS_MSGID(PS,
PS_MSG_SEEK_INFO,
PS_MSG_COMPOUND_INFO,
PS_MSG_CLIENT_OPVERSION_GET_FAILED,
PS_MSG_CHILD_STATUS_FAILED
PS_MSG_CHILD_STATUS_FAILED,
PS_MSG_PUT_INFO
);
#endif /* !_PS_MESSAGES_H__ */

139
xlators/protocol/server/src/server-rpc-fops_v2.c
View File

@ -2131,6 +2131,50 @@ out:
return 0;
}
int
server4_put_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
int32_t op_ret, int32_t op_errno, inode_t *inode,
struct iatt *stbuf, struct iatt *preparent,
struct iatt *postparent, dict_t *xdata)
{
server_state_t *state = NULL;
rpcsvc_request_t *req = NULL;
gfx_common_3iatt_rsp rsp = {0,};
dict_to_xdr (xdata, &rsp.xdata);
state = CALL_STATE (frame);
if (op_ret < 0) {
gf_msg (this->name, GF_LOG_INFO, op_errno, PS_MSG_PUT_INFO,
"%"PRId64": PUT %s (%s/%s), client: %s, "
"error-xlator: %s", frame->root->unique,
state->loc.path, uuid_utoa (state->resolve.pargfid),
state->resolve.bname, STACK_CLIENT_NAME (frame->root),
STACK_ERR_XL_NAME (frame->root));
goto out;
}
gf_msg_trace (frame->root->client->bound_xl->name, 0, "%"PRId64": "
"PUT %s (%s)", frame->root->unique, state->loc.name,
uuid_utoa (stbuf->ia_gfid));
server4_post_common_3iatt (state, &rsp, inode, stbuf, preparent,
postparent);
out:
rsp.op_ret = op_ret;
rsp.op_errno = gf_errno_to_error (op_errno);
req = frame->local;
server_submit_reply (frame, req, &rsp, NULL, 0, NULL,
(xdrproc_t)xdr_gfx_common_3iatt_rsp);
GF_FREE (rsp.xdata.pairs.pairs_val);
return 0;
}
/* Resume function section */
int
@ -2182,6 +2226,32 @@ err:
return 0;
}
int
server4_put_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;
state->loc.inode = inode_new (state->itable);
STACK_WIND (frame, server4_put_cbk,
bound_xl, bound_xl->fops->put,
&(state->loc), state->mode, state->umask, state->flags,
state->payload_vector, state->payload_count, state->offset,
state->iobref, state->dict, state->xdata);
return 0;
err:
server4_put_cbk (frame, NULL, frame->this, state->resolve.op_ret,
state->resolve.op_errno, NULL, NULL, NULL,
NULL, NULL);
return 0;
}
int
server4_lk_resume (call_frame_t *frame, xlator_t *bound_xl)
{
@ -5677,6 +5747,75 @@ out:
return ret;
}
int
server4_0_put (rpcsvc_request_t *req)
{
server_state_t *state = NULL;
call_frame_t *frame = NULL;
gfx_put_req args = {{0,},};
int ret = -1;
int op_errno = 0;
ssize_t len = 0;
int i = 0;
if (!req)
return ret;
args.bname = alloca (req->msg[0].iov_len);
ret = rpc_receive_common (req, &frame, &state, &len, &args,
xdr_gfx_put_req, GF_FOP_PUT);
if (ret != 0) {
goto out;
}
state->resolve.bname = gf_strdup (args.bname);
state->mode = args.mode;
state->umask = args.umask;
state->flags = gf_flags_to_flags (args.flag);
state->offset = args.offset;
state->size = args.size;
state->iobref = iobref_ref (req->iobref);
if (len < req->msg[0].iov_len) {
state->payload_vector[0].iov_base
= (req->msg[0].iov_base + len);
state->payload_vector[0].iov_len
= req->msg[0].iov_len - len;
state->payload_count = 1;
}
for (i = 1; i < req->count; i++) {
state->payload_vector[state->payload_count++]
= req->msg[i];
}
len = iov_length (state->payload_vector, state->payload_count);
GF_ASSERT (state->size == len);
set_resolve_gfid (frame->root->client, state->resolve.pargfid,
args.pargfid);
if (state->flags & O_EXCL) {
state->resolve.type = RESOLVE_NOT;
} else {
state->resolve.type = RESOLVE_DONTCARE;
}
xdr_to_dict (&args.xattr, &state->dict);
xdr_to_dict (&args.xdata, &state->xdata);
ret = 0;
resolve_and_resume (frame, server4_put_resume);
out:
if (op_errno)
SERVER_REQ_SET_ERROR (req, ret);
return ret;
}
int
server4_compound_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
int32_t op_ret, int32_t op_errno, void *data,