diff options
Diffstat (limited to 'rpc')
| -rw-r--r-- | rpc/rpc-lib/src/auth-glusterfs.c | 615 | ||||
| -rw-r--r-- | rpc/rpc-lib/src/auth-null.c | 36 | ||||
| -rw-r--r-- | rpc/rpc-lib/src/auth-unix.c | 75 | ||||
| -rw-r--r-- | rpc/rpc-lib/src/autoscale-threads.c | 12 | ||||
| -rw-r--r-- | rpc/rpc-lib/src/mgmt-pmap.c | 212 | ||||
| -rw-r--r-- | rpc/rpc-lib/src/rpc-clnt-ping.c | 569 | ||||
| -rw-r--r-- | rpc/rpc-lib/src/rpc-clnt.c | 3376 | ||||
| -rw-r--r-- | rpc/rpc-lib/src/rpc-drc.c | 1100 | ||||
| -rw-r--r-- | rpc/rpc-lib/src/rpc-transport.c | 1000 | ||||
| -rw-r--r-- | rpc/rpc-lib/src/rpcsvc-auth.c | 790 | ||||
| -rw-r--r-- | rpc/rpc-lib/src/rpcsvc.c | 4525 | ||||
| -rw-r--r-- | rpc/rpc-lib/src/xdr-rpc.c | 259 | ||||
| -rw-r--r-- | rpc/rpc-lib/src/xdr-rpcclnt.c | 108 | ||||
| -rw-r--r-- | rpc/rpc-transport/rdma/src/name.c | 1002 | ||||
| -rw-r--r-- | rpc/rpc-transport/rdma/src/rdma.c | 8091 | ||||
| -rw-r--r-- | rpc/rpc-transport/socket/src/name.c | 1151 | ||||
| -rw-r--r-- | rpc/rpc-transport/socket/src/socket.c | 7444 | ||||
| -rw-r--r-- | rpc/xdr/src/msg-nfs3.c | 442 | ||||
| -rw-r--r-- | rpc/xdr/src/xdr-generic.c | 129 | ||||
| -rw-r--r-- | rpc/xdr/src/xdr-nfs3.c | 2572 |
20 files changed, 16413 insertions, 17095 deletions
diff --git a/rpc/rpc-lib/src/auth-glusterfs.c b/rpc/rpc-lib/src/auth-glusterfs.c index 78f283557b0..d569a0403f8 100644 --- a/rpc/rpc-lib/src/auth-glusterfs.c +++ b/rpc/rpc-lib/src/auth-glusterfs.c @@ -8,8 +8,6 @@ cases as published by the Free Software Foundation. */ - - #include "rpcsvc.h" #include "list.h" #include "dict.h" @@ -21,386 +19,369 @@ /* V1 */ ssize_t -xdr_to_glusterfs_auth (char *buf, struct auth_glusterfs_parms *req) +xdr_to_glusterfs_auth(char *buf, struct auth_glusterfs_parms *req) { - XDR xdr; - ssize_t ret = -1; - - if ((!buf) || (!req)) - return -1; - - xdrmem_create (&xdr, buf, sizeof (struct auth_glusterfs_parms), - XDR_DECODE); - if (!xdr_auth_glusterfs_parms (&xdr, req)) { - gf_log ("", GF_LOG_WARNING, - "failed to decode glusterfs parameters"); - ret = -1; - goto ret; - } - - ret = (((size_t)(&xdr)->x_private) - ((size_t)(&xdr)->x_base)); -ret: - return ret; + XDR xdr; + ssize_t ret = -1; + if ((!buf) || (!req)) + return -1; + + xdrmem_create(&xdr, buf, sizeof(struct auth_glusterfs_parms), XDR_DECODE); + if (!xdr_auth_glusterfs_parms(&xdr, req)) { + gf_log("", GF_LOG_WARNING, "failed to decode glusterfs parameters"); + ret = -1; + goto ret; + } + + ret = (((size_t)(&xdr)->x_private) - ((size_t)(&xdr)->x_base)); +ret: + return ret; } int -auth_glusterfs_request_init (rpcsvc_request_t *req, void *priv) +auth_glusterfs_request_init(rpcsvc_request_t *req, void *priv) { - return 0; + return 0; } -int auth_glusterfs_authenticate (rpcsvc_request_t *req, void *priv) +int +auth_glusterfs_authenticate(rpcsvc_request_t *req, void *priv) { - struct auth_glusterfs_parms au = {0,}; - - int ret = RPCSVC_AUTH_REJECT; - int j = 0; - int i = 0; - int gidcount = 0; - - if (!req) - return ret; - - ret = xdr_to_glusterfs_auth (req->cred.authdata, &au); - if (ret == -1) { - gf_log ("", GF_LOG_WARNING, - "failed to decode glusterfs credentials"); - ret = RPCSVC_AUTH_REJECT; - goto err; - } - - req->pid = au.pid; - req->uid = au.uid; - req->gid = au.gid; - req->lk_owner.len = 8; - { - for (i = 0; i < req->lk_owner.len; i++, j += 8) - req->lk_owner.data[i] = (char)((au.lk_owner >> j) & 0xff); - } - req->auxgidcount = au.ngrps; - - if (req->auxgidcount > 16) { - gf_log ("", GF_LOG_WARNING, - "more than 16 aux gids found, failing authentication"); - ret = RPCSVC_AUTH_REJECT; - goto err; - } - - if (req->auxgidcount > SMALL_GROUP_COUNT) { - req->auxgidlarge = GF_CALLOC(req->auxgidcount, - sizeof(req->auxgids[0]), - gf_common_mt_auxgids); - req->auxgids = req->auxgidlarge; - } else { - req->auxgids = req->auxgidsmall; - } - - if (!req->auxgids) { - gf_log ("auth-glusterfs", GF_LOG_WARNING, - "cannot allocate gid list"); - ret = RPCSVC_AUTH_REJECT; - goto err; - } - - for (gidcount = 0; gidcount < au.ngrps; ++gidcount) - req->auxgids[gidcount] = au.groups[gidcount]; - - - gf_log (GF_RPCSVC, GF_LOG_TRACE, "Auth Info: pid: %u, uid: %d" - ", gid: %d, owner: %s", - req->pid, req->uid, req->gid, lkowner_utoa (&req->lk_owner)); - ret = RPCSVC_AUTH_ACCEPT; -err: + struct auth_glusterfs_parms au = { + 0, + }; + + int ret = RPCSVC_AUTH_REJECT; + int j = 0; + int i = 0; + int gidcount = 0; + + if (!req) return ret; + + ret = xdr_to_glusterfs_auth(req->cred.authdata, &au); + if (ret == -1) { + gf_log("", GF_LOG_WARNING, "failed to decode glusterfs credentials"); + ret = RPCSVC_AUTH_REJECT; + goto err; + } + + req->pid = au.pid; + req->uid = au.uid; + req->gid = au.gid; + req->lk_owner.len = 8; + { + for (i = 0; i < req->lk_owner.len; i++, j += 8) + req->lk_owner.data[i] = (char)((au.lk_owner >> j) & 0xff); + } + req->auxgidcount = au.ngrps; + + if (req->auxgidcount > 16) { + gf_log("", GF_LOG_WARNING, + "more than 16 aux gids found, failing authentication"); + ret = RPCSVC_AUTH_REJECT; + goto err; + } + + if (req->auxgidcount > SMALL_GROUP_COUNT) { + req->auxgidlarge = GF_CALLOC(req->auxgidcount, sizeof(req->auxgids[0]), + gf_common_mt_auxgids); + req->auxgids = req->auxgidlarge; + } else { + req->auxgids = req->auxgidsmall; + } + + if (!req->auxgids) { + gf_log("auth-glusterfs", GF_LOG_WARNING, "cannot allocate gid list"); + ret = RPCSVC_AUTH_REJECT; + goto err; + } + + for (gidcount = 0; gidcount < au.ngrps; ++gidcount) + req->auxgids[gidcount] = au.groups[gidcount]; + + gf_log(GF_RPCSVC, GF_LOG_TRACE, + "Auth Info: pid: %u, uid: %d" + ", gid: %d, owner: %s", + req->pid, req->uid, req->gid, lkowner_utoa(&req->lk_owner)); + ret = RPCSVC_AUTH_ACCEPT; +err: + return ret; } rpcsvc_auth_ops_t auth_glusterfs_ops = { - .transport_init = NULL, - .request_init = auth_glusterfs_request_init, - .authenticate = auth_glusterfs_authenticate -}; - -rpcsvc_auth_t rpcsvc_auth_glusterfs = { - .authname = "AUTH_GLUSTERFS", - .authnum = AUTH_GLUSTERFS, - .authops = &auth_glusterfs_ops, - .authprivate = NULL -}; + .transport_init = NULL, + .request_init = auth_glusterfs_request_init, + .authenticate = auth_glusterfs_authenticate}; +rpcsvc_auth_t rpcsvc_auth_glusterfs = {.authname = "AUTH_GLUSTERFS", + .authnum = AUTH_GLUSTERFS, + .authops = &auth_glusterfs_ops, + .authprivate = NULL}; rpcsvc_auth_t * -rpcsvc_auth_glusterfs_init (rpcsvc_t *svc, dict_t *options) +rpcsvc_auth_glusterfs_init(rpcsvc_t *svc, dict_t *options) { - return &rpcsvc_auth_glusterfs; + return &rpcsvc_auth_glusterfs; } /* V2 */ ssize_t -xdr_to_glusterfs_auth_v2 (char *buf, struct auth_glusterfs_parms_v2 *req) +xdr_to_glusterfs_auth_v2(char *buf, struct auth_glusterfs_parms_v2 *req) { - XDR xdr; - ssize_t ret = -1; + XDR xdr; + ssize_t ret = -1; - if ((!buf) || (!req)) - return -1; + if ((!buf) || (!req)) + return -1; - xdrmem_create (&xdr, buf, GF_MAX_AUTH_BYTES, XDR_DECODE); - if (!xdr_auth_glusterfs_parms_v2 (&xdr, req)) { - gf_log ("", GF_LOG_WARNING, - "failed to decode glusterfs v2 parameters"); - ret = -1; - goto ret; - } + xdrmem_create(&xdr, buf, GF_MAX_AUTH_BYTES, XDR_DECODE); + if (!xdr_auth_glusterfs_parms_v2(&xdr, req)) { + gf_log("", GF_LOG_WARNING, "failed to decode glusterfs v2 parameters"); + ret = -1; + goto ret; + } - ret = (((size_t)(&xdr)->x_private) - ((size_t)(&xdr)->x_base)); + ret = (((size_t)(&xdr)->x_private) - ((size_t)(&xdr)->x_base)); ret: - return ret; - + return ret; } int -auth_glusterfs_v2_request_init (rpcsvc_request_t *req, void *priv) +auth_glusterfs_v2_request_init(rpcsvc_request_t *req, void *priv) { - return 0; + return 0; } -int auth_glusterfs_v2_authenticate (rpcsvc_request_t *req, void *priv) +int +auth_glusterfs_v2_authenticate(rpcsvc_request_t *req, void *priv) { - struct auth_glusterfs_parms_v2 au = {0,}; - int ret = RPCSVC_AUTH_REJECT; - int i = 0; - int max_groups = 0; - int max_lk_owner_len = 0; - - if (!req) - return ret; - - ret = xdr_to_glusterfs_auth_v2 (req->cred.authdata, &au); - if (ret == -1) { - gf_log ("", GF_LOG_WARNING, - "failed to decode glusterfs credentials"); - ret = RPCSVC_AUTH_REJECT; - goto err; - } - - req->pid = au.pid; - req->uid = au.uid; - req->gid = au.gid; - req->lk_owner.len = au.lk_owner.lk_owner_len; - req->auxgidcount = au.groups.groups_len; - - /* the number of groups and size of lk_owner depend on each other */ - max_groups = GF_AUTH_GLUSTERFS_MAX_GROUPS (req->lk_owner.len, - AUTH_GLUSTERFS_v2); - max_lk_owner_len = GF_AUTH_GLUSTERFS_MAX_LKOWNER (req->auxgidcount, - AUTH_GLUSTERFS_v2); - - if (req->auxgidcount > max_groups) { - gf_log ("", GF_LOG_WARNING, - "more than max aux gids found (%d) , truncating it " - "to %d and continuing", au.groups.groups_len, - max_groups); - req->auxgidcount = max_groups; - } - - if (req->lk_owner.len > max_lk_owner_len) { - gf_log ("", GF_LOG_WARNING, - "lkowner field to big (%d), depends on the number of " - "groups (%d), failing authentication", - req->lk_owner.len, req->auxgidcount); - ret = RPCSVC_AUTH_REJECT; - goto err; - } - - if (req->auxgidcount > SMALL_GROUP_COUNT) { - req->auxgidlarge = GF_CALLOC(req->auxgidcount, - sizeof(req->auxgids[0]), - gf_common_mt_auxgids); - req->auxgids = req->auxgidlarge; - } else { - req->auxgids = req->auxgidsmall; - } - - if (!req->auxgids) { - gf_log ("auth-glusterfs-v2", GF_LOG_WARNING, - "cannot allocate gid list"); - ret = RPCSVC_AUTH_REJECT; - goto err; - } - - for (i = 0; i < req->auxgidcount; ++i) - req->auxgids[i] = au.groups.groups_val[i]; - - for (i = 0; i < au.lk_owner.lk_owner_len; ++i) - req->lk_owner.data[i] = au.lk_owner.lk_owner_val[i]; - - - gf_log (GF_RPCSVC, GF_LOG_TRACE, "Auth Info: pid: %u, uid: %d" - ", gid: %d, owner: %s", - req->pid, req->uid, req->gid, lkowner_utoa (&req->lk_owner)); - ret = RPCSVC_AUTH_ACCEPT; + struct auth_glusterfs_parms_v2 au = { + 0, + }; + int ret = RPCSVC_AUTH_REJECT; + int i = 0; + int max_groups = 0; + int max_lk_owner_len = 0; + + if (!req) + return ret; + + ret = xdr_to_glusterfs_auth_v2(req->cred.authdata, &au); + if (ret == -1) { + gf_log("", GF_LOG_WARNING, "failed to decode glusterfs credentials"); + ret = RPCSVC_AUTH_REJECT; + goto err; + } + + req->pid = au.pid; + req->uid = au.uid; + req->gid = au.gid; + req->lk_owner.len = au.lk_owner.lk_owner_len; + req->auxgidcount = au.groups.groups_len; + + /* the number of groups and size of lk_owner depend on each other */ + max_groups = GF_AUTH_GLUSTERFS_MAX_GROUPS(req->lk_owner.len, + AUTH_GLUSTERFS_v2); + max_lk_owner_len = GF_AUTH_GLUSTERFS_MAX_LKOWNER(req->auxgidcount, + AUTH_GLUSTERFS_v2); + + if (req->auxgidcount > max_groups) { + gf_log("", GF_LOG_WARNING, + "more than max aux gids found (%d) , truncating it " + "to %d and continuing", + au.groups.groups_len, max_groups); + req->auxgidcount = max_groups; + } + + if (req->lk_owner.len > max_lk_owner_len) { + gf_log("", GF_LOG_WARNING, + "lkowner field to big (%d), depends on the number of " + "groups (%d), failing authentication", + req->lk_owner.len, req->auxgidcount); + ret = RPCSVC_AUTH_REJECT; + goto err; + } + + if (req->auxgidcount > SMALL_GROUP_COUNT) { + req->auxgidlarge = GF_CALLOC(req->auxgidcount, sizeof(req->auxgids[0]), + gf_common_mt_auxgids); + req->auxgids = req->auxgidlarge; + } else { + req->auxgids = req->auxgidsmall; + } + + if (!req->auxgids) { + gf_log("auth-glusterfs-v2", GF_LOG_WARNING, "cannot allocate gid list"); + ret = RPCSVC_AUTH_REJECT; + goto err; + } + + for (i = 0; i < req->auxgidcount; ++i) + req->auxgids[i] = au.groups.groups_val[i]; + + for (i = 0; i < au.lk_owner.lk_owner_len; ++i) + req->lk_owner.data[i] = au.lk_owner.lk_owner_val[i]; + + gf_log(GF_RPCSVC, GF_LOG_TRACE, + "Auth Info: pid: %u, uid: %d" + ", gid: %d, owner: %s", + req->pid, req->uid, req->gid, lkowner_utoa(&req->lk_owner)); + ret = RPCSVC_AUTH_ACCEPT; err: - /* TODO: instead use alloca() for these variables */ - free (au.groups.groups_val); - free (au.lk_owner.lk_owner_val); + /* TODO: instead use alloca() for these variables */ + free(au.groups.groups_val); + free(au.lk_owner.lk_owner_val); - return ret; + return ret; } rpcsvc_auth_ops_t auth_glusterfs_ops_v2 = { - .transport_init = NULL, - .request_init = auth_glusterfs_v2_request_init, - .authenticate = auth_glusterfs_v2_authenticate -}; - -rpcsvc_auth_t rpcsvc_auth_glusterfs_v2 = { - .authname = "AUTH_GLUSTERFS-v2", - .authnum = AUTH_GLUSTERFS_v2, - .authops = &auth_glusterfs_ops_v2, - .authprivate = NULL -}; + .transport_init = NULL, + .request_init = auth_glusterfs_v2_request_init, + .authenticate = auth_glusterfs_v2_authenticate}; +rpcsvc_auth_t rpcsvc_auth_glusterfs_v2 = {.authname = "AUTH_GLUSTERFS-v2", + .authnum = AUTH_GLUSTERFS_v2, + .authops = &auth_glusterfs_ops_v2, + .authprivate = NULL}; rpcsvc_auth_t * -rpcsvc_auth_glusterfs_v2_init (rpcsvc_t *svc, dict_t *options) +rpcsvc_auth_glusterfs_v2_init(rpcsvc_t *svc, dict_t *options) { - return &rpcsvc_auth_glusterfs_v2; + return &rpcsvc_auth_glusterfs_v2; } /* V3 */ ssize_t -xdr_to_glusterfs_auth_v3 (char *buf, struct auth_glusterfs_params_v3 *req) +xdr_to_glusterfs_auth_v3(char *buf, struct auth_glusterfs_params_v3 *req) { - XDR xdr; - ssize_t ret = -1; + XDR xdr; + ssize_t ret = -1; - if ((!buf) || (!req)) - return -1; + if ((!buf) || (!req)) + return -1; - xdrmem_create (&xdr, buf, GF_MAX_AUTH_BYTES, XDR_DECODE); - if (!xdr_auth_glusterfs_params_v3 (&xdr, req)) { - gf_log ("", GF_LOG_WARNING, - "failed to decode glusterfs v3 parameters"); - ret = -1; - goto ret; - } + xdrmem_create(&xdr, buf, GF_MAX_AUTH_BYTES, XDR_DECODE); + if (!xdr_auth_glusterfs_params_v3(&xdr, req)) { + gf_log("", GF_LOG_WARNING, "failed to decode glusterfs v3 parameters"); + ret = -1; + goto ret; + } - ret = (((size_t)(&xdr)->x_private) - ((size_t)(&xdr)->x_base)); + ret = (((size_t)(&xdr)->x_private) - ((size_t)(&xdr)->x_base)); ret: - return ret; + return ret; } int -auth_glusterfs_v3_request_init (rpcsvc_request_t *req, void *priv) +auth_glusterfs_v3_request_init(rpcsvc_request_t *req, void *priv) { - return 0; + return 0; } -int auth_glusterfs_v3_authenticate (rpcsvc_request_t *req, void *priv) +int +auth_glusterfs_v3_authenticate(rpcsvc_request_t *req, void *priv) { - struct auth_glusterfs_params_v3 au = {0,}; - int ret = RPCSVC_AUTH_REJECT; - int i = 0; - int max_groups = 0; - int max_lk_owner_len = 0; - - if (!req) - return ret; - - ret = xdr_to_glusterfs_auth_v3 (req->cred.authdata, &au); - if (ret == -1) { - gf_log ("", GF_LOG_WARNING, - "failed to decode glusterfs credentials"); - ret = RPCSVC_AUTH_REJECT; - goto err; - } - - req->pid = au.pid; - req->uid = au.uid; - req->gid = au.gid; - req->lk_owner.len = au.lk_owner.lk_owner_len; - req->auxgidcount = au.groups.groups_len; - - /* the number of groups and size of lk_owner depend on each other */ - max_groups = GF_AUTH_GLUSTERFS_MAX_GROUPS (req->lk_owner.len, - AUTH_GLUSTERFS_v3); - max_lk_owner_len = GF_AUTH_GLUSTERFS_MAX_LKOWNER (req->auxgidcount, - AUTH_GLUSTERFS_v3); - - if (req->auxgidcount > max_groups) { - gf_log ("", GF_LOG_WARNING, - "more than max aux gids found (%d) , truncating it " - "to %d and continuing", au.groups.groups_len, - max_groups); - req->auxgidcount = max_groups; - } - - if (req->lk_owner.len > max_lk_owner_len) { - gf_log ("", GF_LOG_WARNING, - "lkowner field to big (%d), depends on the number of " - "groups (%d), failing authentication", - req->lk_owner.len, req->auxgidcount); - ret = RPCSVC_AUTH_REJECT; - goto err; - } - - if (req->auxgidcount > SMALL_GROUP_COUNT) { - req->auxgidlarge = GF_CALLOC(req->auxgidcount, - sizeof(req->auxgids[0]), - gf_common_mt_auxgids); - req->auxgids = req->auxgidlarge; - } else { - req->auxgids = req->auxgidsmall; - } - - if (!req->auxgids) { - gf_log ("auth-glusterfs-v2", GF_LOG_WARNING, - "cannot allocate gid list"); - ret = RPCSVC_AUTH_REJECT; - goto err; - } - - for (i = 0; i < req->auxgidcount; ++i) - req->auxgids[i] = au.groups.groups_val[i]; - - for (i = 0; i < au.lk_owner.lk_owner_len; ++i) - req->lk_owner.data[i] = au.lk_owner.lk_owner_val[i]; - - /* All new things, starting glusterfs-4.0.0 */ - req->flags = au.flags; - req->ctime.tv_sec = au.ctime_sec; - req->ctime.tv_nsec = au.ctime_nsec; - - gf_log (GF_RPCSVC, GF_LOG_TRACE, "Auth Info: pid: %u, uid: %d" - ", gid: %d, owner: %s, flags: %d", - req->pid, req->uid, req->gid, lkowner_utoa (&req->lk_owner), - req->flags); - ret = RPCSVC_AUTH_ACCEPT; + struct auth_glusterfs_params_v3 au = { + 0, + }; + int ret = RPCSVC_AUTH_REJECT; + int i = 0; + int max_groups = 0; + int max_lk_owner_len = 0; + + if (!req) + return ret; + + ret = xdr_to_glusterfs_auth_v3(req->cred.authdata, &au); + if (ret == -1) { + gf_log("", GF_LOG_WARNING, "failed to decode glusterfs credentials"); + ret = RPCSVC_AUTH_REJECT; + goto err; + } + + req->pid = au.pid; + req->uid = au.uid; + req->gid = au.gid; + req->lk_owner.len = au.lk_owner.lk_owner_len; + req->auxgidcount = au.groups.groups_len; + + /* the number of groups and size of lk_owner depend on each other */ + max_groups = GF_AUTH_GLUSTERFS_MAX_GROUPS(req->lk_owner.len, + AUTH_GLUSTERFS_v3); + max_lk_owner_len = GF_AUTH_GLUSTERFS_MAX_LKOWNER(req->auxgidcount, + AUTH_GLUSTERFS_v3); + + if (req->auxgidcount > max_groups) { + gf_log("", GF_LOG_WARNING, + "more than max aux gids found (%d) , truncating it " + "to %d and continuing", + au.groups.groups_len, max_groups); + req->auxgidcount = max_groups; + } + + if (req->lk_owner.len > max_lk_owner_len) { + gf_log("", GF_LOG_WARNING, + "lkowner field to big (%d), depends on the number of " + "groups (%d), failing authentication", + req->lk_owner.len, req->auxgidcount); + ret = RPCSVC_AUTH_REJECT; + goto err; + } + + if (req->auxgidcount > SMALL_GROUP_COUNT) { + req->auxgidlarge = GF_CALLOC(req->auxgidcount, sizeof(req->auxgids[0]), + gf_common_mt_auxgids); + req->auxgids = req->auxgidlarge; + } else { + req->auxgids = req->auxgidsmall; + } + + if (!req->auxgids) { + gf_log("auth-glusterfs-v2", GF_LOG_WARNING, "cannot allocate gid list"); + ret = RPCSVC_AUTH_REJECT; + goto err; + } + + for (i = 0; i < req->auxgidcount; ++i) + req->auxgids[i] = au.groups.groups_val[i]; + + for (i = 0; i < au.lk_owner.lk_owner_len; ++i) + req->lk_owner.data[i] = au.lk_owner.lk_owner_val[i]; + + /* All new things, starting glusterfs-4.0.0 */ + req->flags = au.flags; + req->ctime.tv_sec = au.ctime_sec; + req->ctime.tv_nsec = au.ctime_nsec; + + gf_log(GF_RPCSVC, GF_LOG_TRACE, + "Auth Info: pid: %u, uid: %d" + ", gid: %d, owner: %s, flags: %d", + req->pid, req->uid, req->gid, lkowner_utoa(&req->lk_owner), + req->flags); + ret = RPCSVC_AUTH_ACCEPT; err: - /* TODO: instead use alloca() for these variables */ - free (au.groups.groups_val); - free (au.lk_owner.lk_owner_val); + /* TODO: instead use alloca() for these variables */ + free(au.groups.groups_val); + free(au.lk_owner.lk_owner_val); - return ret; + return ret; } rpcsvc_auth_ops_t auth_glusterfs_ops_v3 = { - .transport_init = NULL, - .request_init = auth_glusterfs_v3_request_init, - .authenticate = auth_glusterfs_v3_authenticate -}; - -rpcsvc_auth_t rpcsvc_auth_glusterfs_v3 = { - .authname = "AUTH_GLUSTERFS-v3", - .authnum = AUTH_GLUSTERFS_v3, - .authops = &auth_glusterfs_ops_v3, - .authprivate = NULL -}; + .transport_init = NULL, + .request_init = auth_glusterfs_v3_request_init, + .authenticate = auth_glusterfs_v3_authenticate}; +rpcsvc_auth_t rpcsvc_auth_glusterfs_v3 = {.authname = "AUTH_GLUSTERFS-v3", + .authnum = AUTH_GLUSTERFS_v3, + .authops = &auth_glusterfs_ops_v3, + .authprivate = NULL}; rpcsvc_auth_t * -rpcsvc_auth_glusterfs_v3_init (rpcsvc_t *svc, dict_t *options) +rpcsvc_auth_glusterfs_v3_init(rpcsvc_t *svc, dict_t *options) { - return &rpcsvc_auth_glusterfs_v3; + return &rpcsvc_auth_glusterfs_v3; } diff --git a/rpc/rpc-lib/src/auth-null.c b/rpc/rpc-lib/src/auth-null.c index 774fdc8da3a..46046e8e440 100644 --- a/rpc/rpc-lib/src/auth-null.c +++ b/rpc/rpc-lib/src/auth-null.c @@ -8,40 +8,34 @@ cases as published by the Free Software Foundation. */ - #include "rpcsvc.h" #include "list.h" #include "dict.h" - int -auth_null_request_init (rpcsvc_request_t *req, void *priv) +auth_null_request_init(rpcsvc_request_t *req, void *priv) { - return 0; + return 0; } -int auth_null_authenticate (rpcsvc_request_t *req, void *priv) +int +auth_null_authenticate(rpcsvc_request_t *req, void *priv) { - /* Always succeed. */ - return RPCSVC_AUTH_ACCEPT; + /* Always succeed. */ + return RPCSVC_AUTH_ACCEPT; } -rpcsvc_auth_ops_t auth_null_ops = { - .transport_init = NULL, - .request_init = auth_null_request_init, - .authenticate = auth_null_authenticate -}; - -rpcsvc_auth_t rpcsvc_auth_null = { - .authname = "AUTH_NULL", - .authnum = AUTH_NULL, - .authops = &auth_null_ops, - .authprivate = NULL -}; +rpcsvc_auth_ops_t auth_null_ops = {.transport_init = NULL, + .request_init = auth_null_request_init, + .authenticate = auth_null_authenticate}; +rpcsvc_auth_t rpcsvc_auth_null = {.authname = "AUTH_NULL", + .authnum = AUTH_NULL, + .authops = &auth_null_ops, + .authprivate = NULL}; rpcsvc_auth_t * -rpcsvc_auth_null_init (rpcsvc_t *svc, dict_t *options) +rpcsvc_auth_null_init(rpcsvc_t *svc, dict_t *options) { - return &rpcsvc_auth_null; + return &rpcsvc_auth_null; } diff --git a/rpc/rpc-lib/src/auth-unix.c b/rpc/rpc-lib/src/auth-unix.c index 74ebfe0d1ff..c53870fcf94 100644 --- a/rpc/rpc-lib/src/auth-unix.c +++ b/rpc/rpc-lib/src/auth-unix.c @@ -8,65 +8,60 @@ cases as published by the Free Software Foundation. */ - - #include "rpcsvc.h" #include "list.h" #include "dict.h" #include "xdr-rpc.h" - int -auth_unix_request_init (rpcsvc_request_t *req, void *priv) +auth_unix_request_init(rpcsvc_request_t *req, void *priv) { - return 0; + return 0; } -int auth_unix_authenticate (rpcsvc_request_t *req, void *priv) +int +auth_unix_authenticate(rpcsvc_request_t *req, void *priv) { - int ret = RPCSVC_AUTH_REJECT; - struct authunix_parms aup; - char machname[MAX_MACHINE_NAME]; + int ret = RPCSVC_AUTH_REJECT; + struct authunix_parms aup; + char machname[MAX_MACHINE_NAME]; - if (!req) - return ret; + if (!req) + return ret; - req->auxgids = req->auxgidsmall; - ret = xdr_to_auth_unix_cred (req->cred.authdata, req->cred.datalen, - &aup, machname, req->auxgids); - if (ret == -1) { - gf_log ("", GF_LOG_WARNING, "failed to decode unix credentials"); - ret = RPCSVC_AUTH_REJECT; - goto err; - } + req->auxgids = req->auxgidsmall; + ret = xdr_to_auth_unix_cred(req->cred.authdata, req->cred.datalen, &aup, + machname, req->auxgids); + if (ret == -1) { + gf_log("", GF_LOG_WARNING, "failed to decode unix credentials"); + ret = RPCSVC_AUTH_REJECT; + goto err; + } - req->uid = aup.aup_uid; - req->gid = aup.aup_gid; - req->auxgidcount = aup.aup_len; + req->uid = aup.aup_uid; + req->gid = aup.aup_gid; + req->auxgidcount = aup.aup_len; - gf_log (GF_RPCSVC, GF_LOG_TRACE, "Auth Info: machine name: %s, uid: %d" - ", gid: %d", machname, req->uid, req->gid); - ret = RPCSVC_AUTH_ACCEPT; + gf_log(GF_RPCSVC, GF_LOG_TRACE, + "Auth Info: machine name: %s, uid: %d" + ", gid: %d", + machname, req->uid, req->gid); + ret = RPCSVC_AUTH_ACCEPT; err: - return ret; + return ret; } -rpcsvc_auth_ops_t auth_unix_ops = { - .transport_init = NULL, - .request_init = auth_unix_request_init, - .authenticate = auth_unix_authenticate -}; - -rpcsvc_auth_t rpcsvc_auth_unix = { - .authname = "AUTH_UNIX", - .authnum = AUTH_UNIX, - .authops = &auth_unix_ops, - .authprivate = NULL -}; +rpcsvc_auth_ops_t auth_unix_ops = {.transport_init = NULL, + .request_init = auth_unix_request_init, + .authenticate = auth_unix_authenticate}; +rpcsvc_auth_t rpcsvc_auth_unix = {.authname = "AUTH_UNIX", + .authnum = AUTH_UNIX, + .authops = &auth_unix_ops, + .authprivate = NULL}; rpcsvc_auth_t * -rpcsvc_auth_unix_init (rpcsvc_t *svc, dict_t *options) +rpcsvc_auth_unix_init(rpcsvc_t *svc, dict_t *options) { - return &rpcsvc_auth_unix; + return &rpcsvc_auth_unix; } diff --git a/rpc/rpc-lib/src/autoscale-threads.c b/rpc/rpc-lib/src/autoscale-threads.c index 4840fd4e971..337f002df10 100644 --- a/rpc/rpc-lib/src/autoscale-threads.c +++ b/rpc/rpc-lib/src/autoscale-threads.c @@ -12,12 +12,12 @@ #include "rpcsvc.h" void -rpcsvc_autoscale_threads (glusterfs_ctx_t *ctx, rpcsvc_t *rpc, int incr) +rpcsvc_autoscale_threads(glusterfs_ctx_t *ctx, rpcsvc_t *rpc, int incr) { - struct event_pool *pool = ctx->event_pool; - int thread_count = pool->eventthreadcount; + struct event_pool *pool = ctx->event_pool; + int thread_count = pool->eventthreadcount; - pool->auto_thread_count += incr; - (void) event_reconfigure_threads (pool, thread_count+incr); - rpcsvc_ownthread_reconf (rpc, pool->eventthreadcount); + pool->auto_thread_count += incr; + (void)event_reconfigure_threads(pool, thread_count + incr); + rpcsvc_ownthread_reconf(rpc, pool->eventthreadcount); } diff --git a/rpc/rpc-lib/src/mgmt-pmap.c b/rpc/rpc-lib/src/mgmt-pmap.c index fbcc78a7a7e..344ec56bbf7 100644 --- a/rpc/rpc-lib/src/mgmt-pmap.c +++ b/rpc/rpc-lib/src/mgmt-pmap.c @@ -17,122 +17,126 @@ /* Defining a minimal RPC client program for portmap signout */ char *clnt_pmap_signout_procs[GF_PMAP_MAXVALUE] = { - [GF_PMAP_SIGNOUT] = "SIGNOUT", + [GF_PMAP_SIGNOUT] = "SIGNOUT", }; - rpc_clnt_prog_t clnt_pmap_signout_prog = { - .progname = "Gluster Portmap", - .prognum = GLUSTER_PMAP_PROGRAM, - .progver = GLUSTER_PMAP_VERSION, - .procnames = clnt_pmap_signout_procs, + .progname = "Gluster Portmap", + .prognum = GLUSTER_PMAP_PROGRAM, + .progver = GLUSTER_PMAP_VERSION, + .procnames = clnt_pmap_signout_procs, }; static int -mgmt_pmap_signout_cbk (struct rpc_req *req, struct iovec *iov, int count, - void *myframe) +mgmt_pmap_signout_cbk(struct rpc_req *req, struct iovec *iov, int count, + void *myframe) { - pmap_signout_rsp rsp = {0,}; - int ret = 0; - - if (-1 == req->rpc_status) { - rsp.op_ret = -1; - rsp.op_errno = EINVAL; - goto out; - } - - ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_pmap_signout_rsp); - if (ret < 0) { - gf_log (THIS->name, GF_LOG_ERROR, "XDR decoding failed"); - rsp.op_ret = -1; - rsp.op_errno = EINVAL; - goto out; - } - - if (-1 == rsp.op_ret) { - gf_log (THIS->name, GF_LOG_ERROR, - "failed to register the port with glusterd"); - goto out; - } + pmap_signout_rsp rsp = { + 0, + }; + int ret = 0; + + if (-1 == req->rpc_status) { + rsp.op_ret = -1; + rsp.op_errno = EINVAL; + goto out; + } + + ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_pmap_signout_rsp); + if (ret < 0) { + gf_log(THIS->name, GF_LOG_ERROR, "XDR decoding failed"); + rsp.op_ret = -1; + rsp.op_errno = EINVAL; + goto out; + } + + if (-1 == rsp.op_ret) { + gf_log(THIS->name, GF_LOG_ERROR, + "failed to register the port with glusterd"); + goto out; + } out: - return 0; + return 0; } int -rpc_clnt_mgmt_pmap_signout (glusterfs_ctx_t *ctx, char *brickname) +rpc_clnt_mgmt_pmap_signout(glusterfs_ctx_t *ctx, char *brickname) { - int ret = 0; - pmap_signout_req req = {0, }; - call_frame_t *frame = NULL; - cmd_args_t *cmd_args = NULL; - char brick_name[PATH_MAX] = {0,}; - struct iovec iov = {0, }; - struct iobuf *iobuf = NULL; - struct iobref *iobref = NULL; - ssize_t xdr_size = 0; - - frame = create_frame (THIS, ctx->pool); - cmd_args = &ctx->cmd_args; - - if (!cmd_args->brick_port && (!cmd_args->brick_name || !brickname)) { - gf_log ("fsd-mgmt", GF_LOG_DEBUG, - "portmapper signout arguments not given"); - goto out; - } - - if (cmd_args->volfile_server_transport && - !strcmp(cmd_args->volfile_server_transport, "rdma")) { - snprintf (brick_name, sizeof(brick_name), "%s.rdma", - cmd_args->brick_name); - req.brick = brick_name; - } else { - if (brickname) - req.brick = brickname; - else - req.brick = cmd_args->brick_name; - } - - req.port = cmd_args->brick_port; - req.rdma_port = cmd_args->brick_port2; - - /* mgmt_submit_request is not available in libglusterfs. - * Need to serialize and submit manually. - */ - iobref = iobref_new (); - if (!iobref) { - goto out; - } - - xdr_size = xdr_sizeof ((xdrproc_t)xdr_pmap_signout_req, &req); - iobuf = iobuf_get2 (ctx->iobuf_pool, xdr_size); - if (!iobuf) { - goto out; - }; - - iobref_add (iobref, iobuf); - - iov.iov_base = iobuf->ptr; - iov.iov_len = iobuf_pagesize (iobuf); - - /* Create the xdr payload */ - ret = xdr_serialize_generic (iov, &req, - (xdrproc_t)xdr_pmap_signout_req); - if (ret == -1) { - gf_log (THIS->name, GF_LOG_WARNING, - "failed to create XDR payload"); - goto out; - } - iov.iov_len = ret; - - ret = rpc_clnt_submit (ctx->mgmt, &clnt_pmap_signout_prog, - GF_PMAP_SIGNOUT, mgmt_pmap_signout_cbk, - &iov, 1, - NULL, 0, iobref, frame, NULL, 0, NULL, 0, NULL); + int ret = 0; + pmap_signout_req req = { + 0, + }; + call_frame_t *frame = NULL; + cmd_args_t *cmd_args = NULL; + char brick_name[PATH_MAX] = { + 0, + }; + struct iovec iov = { + 0, + }; + struct iobuf *iobuf = NULL; + struct iobref *iobref = NULL; + ssize_t xdr_size = 0; + + frame = create_frame(THIS, ctx->pool); + cmd_args = &ctx->cmd_args; + + if (!cmd_args->brick_port && (!cmd_args->brick_name || !brickname)) { + gf_log("fsd-mgmt", GF_LOG_DEBUG, + "portmapper signout arguments not given"); + goto out; + } + + if (cmd_args->volfile_server_transport && + !strcmp(cmd_args->volfile_server_transport, "rdma")) { + snprintf(brick_name, sizeof(brick_name), "%s.rdma", + cmd_args->brick_name); + req.brick = brick_name; + } else { + if (brickname) + req.brick = brickname; + else + req.brick = cmd_args->brick_name; + } + + req.port = cmd_args->brick_port; + req.rdma_port = cmd_args->brick_port2; + + /* mgmt_submit_request is not available in libglusterfs. + * Need to serialize and submit manually. + */ + iobref = iobref_new(); + if (!iobref) { + goto out; + } + + xdr_size = xdr_sizeof((xdrproc_t)xdr_pmap_signout_req, &req); + iobuf = iobuf_get2(ctx->iobuf_pool, xdr_size); + if (!iobuf) { + goto out; + }; + + iobref_add(iobref, iobuf); + + iov.iov_base = iobuf->ptr; + iov.iov_len = iobuf_pagesize(iobuf); + + /* Create the xdr payload */ + ret = xdr_serialize_generic(iov, &req, (xdrproc_t)xdr_pmap_signout_req); + if (ret == -1) { + gf_log(THIS->name, GF_LOG_WARNING, "failed to create XDR payload"); + goto out; + } + iov.iov_len = ret; + + ret = rpc_clnt_submit(ctx->mgmt, &clnt_pmap_signout_prog, GF_PMAP_SIGNOUT, + mgmt_pmap_signout_cbk, &iov, 1, NULL, 0, iobref, + frame, NULL, 0, NULL, 0, NULL); out: - if (iobref) - iobref_unref (iobref); + if (iobref) + iobref_unref(iobref); - if (iobuf) - iobuf_unref (iobuf); - return ret; + if (iobuf) + iobuf_unref(iobuf); + return ret; } diff --git a/rpc/rpc-lib/src/rpc-clnt-ping.c b/rpc/rpc-lib/src/rpc-clnt-ping.c index 25629891379..a98a83dd8c8 100644 --- a/rpc/rpc-lib/src/rpc-clnt-ping.c +++ b/rpc/rpc-lib/src/rpc-clnt-ping.c @@ -8,7 +8,6 @@ cases as published by the Free Software Foundation. */ - #include "rpc-clnt.h" #include "rpc-clnt-ping.h" #include "byte-order.h" @@ -20,15 +19,14 @@ #include "rpc-common-xdr.h" #include "timespec.h" - char *clnt_ping_procs[GF_DUMP_MAXVALUE] = { - [GF_DUMP_PING] = "NULL", + [GF_DUMP_PING] = "NULL", }; struct rpc_clnt_program clnt_ping_prog = { - .progname = "GF-DUMP", - .prognum = GLUSTER_DUMP_PROGRAM, - .progver = GLUSTER_DUMP_VERSION, - .procnames = clnt_ping_procs, + .progname = "GF-DUMP", + .prognum = GLUSTER_DUMP_PROGRAM, + .progver = GLUSTER_DUMP_VERSION, + .procnames = clnt_ping_procs, }; struct ping_local { @@ -38,341 +36,326 @@ struct ping_local { /* Must be called under conn->lock */ static int -__rpc_clnt_rearm_ping_timer (struct rpc_clnt *rpc, gf_timer_cbk_t cbk) +__rpc_clnt_rearm_ping_timer(struct rpc_clnt *rpc, gf_timer_cbk_t cbk) { - rpc_clnt_connection_t *conn = &rpc->conn; - rpc_transport_t *trans = conn->trans; - struct timespec timeout = {0, }; - gf_timer_t *timer = NULL; - - if (conn->ping_timer) { - gf_log_callingfn ("", GF_LOG_CRITICAL, - "%s: ping timer event already scheduled", - conn->trans->peerinfo.identifier); - return -1; - } - - timeout.tv_sec = conn->ping_timeout; - timeout.tv_nsec = 0; - - rpc_clnt_ref (rpc); - timer = gf_timer_call_after (rpc->ctx, timeout, - cbk, - (void *) rpc); - if (timer == NULL) { - gf_log (trans->name, GF_LOG_WARNING, - "unable to setup ping timer"); - - /* This unref can't be the last. We just took a ref few lines - * above. So this can be performed under conn->lock. */ - rpc_clnt_unref (rpc); - conn->ping_started = 0; - return -1; - } - - conn->ping_timer = timer; - conn->ping_started = 1; - return 0; + rpc_clnt_connection_t *conn = &rpc->conn; + rpc_transport_t *trans = conn->trans; + struct timespec timeout = { + 0, + }; + gf_timer_t *timer = NULL; + + if (conn->ping_timer) { + gf_log_callingfn("", GF_LOG_CRITICAL, + "%s: ping timer event already scheduled", + conn->trans->peerinfo.identifier); + return -1; + } + + timeout.tv_sec = conn->ping_timeout; + timeout.tv_nsec = 0; + + rpc_clnt_ref(rpc); + timer = gf_timer_call_after(rpc->ctx, timeout, cbk, (void *)rpc); + if (timer == NULL) { + gf_log(trans->name, GF_LOG_WARNING, "unable to setup ping timer"); + + /* This unref can't be the last. We just took a ref few lines + * above. So this can be performed under conn->lock. */ + rpc_clnt_unref(rpc); + conn->ping_started = 0; + return -1; + } + + conn->ping_timer = timer; + conn->ping_started = 1; + return 0; } /* Must be called under conn->lock */ int -rpc_clnt_remove_ping_timer_locked (struct rpc_clnt *rpc) +rpc_clnt_remove_ping_timer_locked(struct rpc_clnt *rpc) { - rpc_clnt_connection_t *conn = &rpc->conn; - gf_timer_t *timer = NULL; - - if (conn->ping_timer) { - timer = conn->ping_timer; - conn->ping_timer = NULL; - gf_timer_call_cancel (rpc->ctx, timer); - conn->ping_started = 0; - return 1; - - } - - /* This is to account for rpc_clnt_disable that might have set - * conn->trans to NULL. */ - if (conn->trans) - gf_log_callingfn ("", GF_LOG_DEBUG, "%s: ping timer event " - "already removed", - conn->trans->peerinfo.identifier); - - return 0; + rpc_clnt_connection_t *conn = &rpc->conn; + gf_timer_t *timer = NULL; + + if (conn->ping_timer) { + timer = conn->ping_timer; + conn->ping_timer = NULL; + gf_timer_call_cancel(rpc->ctx, timer); + conn->ping_started = 0; + return 1; + } + + /* This is to account for rpc_clnt_disable that might have set + * conn->trans to NULL. */ + if (conn->trans) + gf_log_callingfn("", GF_LOG_DEBUG, + "%s: ping timer event " + "already removed", + conn->trans->peerinfo.identifier); + + return 0; } static void -rpc_clnt_start_ping (void *rpc_ptr); +rpc_clnt_start_ping(void *rpc_ptr); void -rpc_clnt_ping_timer_expired (void *rpc_ptr) +rpc_clnt_ping_timer_expired(void *rpc_ptr) { - struct rpc_clnt *rpc = NULL; - rpc_transport_t *trans = NULL; - rpc_clnt_connection_t *conn = NULL; - int disconnect = 0; - int transport_activity = 0; - struct timespec current = {0, }; - int unref = 0; - - rpc = (struct rpc_clnt*) rpc_ptr; - conn = &rpc->conn; - trans = conn->trans; - - if (!trans) { - gf_log ("ping-timer", GF_LOG_WARNING, - "transport not initialized"); - goto out; + struct rpc_clnt *rpc = NULL; + rpc_transport_t *trans = NULL; + rpc_clnt_connection_t *conn = NULL; + int disconnect = 0; + int transport_activity = 0; + struct timespec current = { + 0, + }; + int unref = 0; + + rpc = (struct rpc_clnt *)rpc_ptr; + conn = &rpc->conn; + trans = conn->trans; + + if (!trans) { + gf_log("ping-timer", GF_LOG_WARNING, "transport not initialized"); + goto out; + } + + pthread_mutex_lock(&conn->lock); + { + unref = rpc_clnt_remove_ping_timer_locked(rpc); + + clock_gettime(CLOCK_REALTIME, ¤t); + if (((current.tv_sec - conn->last_received.tv_sec) < + conn->ping_timeout) || + ((current.tv_sec - conn->last_sent.tv_sec) < conn->ping_timeout)) { + transport_activity = 1; } - pthread_mutex_lock (&conn->lock); - { - unref = rpc_clnt_remove_ping_timer_locked (rpc); - - clock_gettime (CLOCK_REALTIME, ¤t); - if (((current.tv_sec - conn->last_received.tv_sec) < - conn->ping_timeout) - || ((current.tv_sec - conn->last_sent.tv_sec) < - conn->ping_timeout)) { - transport_activity = 1; - } - - if (transport_activity) { - gf_log (trans->name, GF_LOG_TRACE, - "ping timer expired but transport activity " - "detected - not bailing transport"); - - if (__rpc_clnt_rearm_ping_timer (rpc, - rpc_clnt_ping_timer_expired) == -1) { - gf_log (trans->name, GF_LOG_WARNING, - "unable to setup ping timer"); - } - - } else { - conn->ping_started = 0; - disconnect = 1; - } + if (transport_activity) { + gf_log(trans->name, GF_LOG_TRACE, + "ping timer expired but transport activity " + "detected - not bailing transport"); + + if (__rpc_clnt_rearm_ping_timer(rpc, rpc_clnt_ping_timer_expired) == + -1) { + gf_log(trans->name, GF_LOG_WARNING, + "unable to setup ping timer"); + } + + } else { + conn->ping_started = 0; + disconnect = 1; } - pthread_mutex_unlock (&conn->lock); + } + pthread_mutex_unlock(&conn->lock); - if (unref) - rpc_clnt_unref (rpc); + if (unref) + rpc_clnt_unref(rpc); - if (disconnect) { - gf_log (trans->name, GF_LOG_CRITICAL, - "server %s has not responded in the last %d " - "seconds, disconnecting.", - trans->peerinfo.identifier, - conn->ping_timeout); + if (disconnect) { + gf_log(trans->name, GF_LOG_CRITICAL, + "server %s has not responded in the last %d " + "seconds, disconnecting.", + trans->peerinfo.identifier, conn->ping_timeout); - rpc_transport_disconnect (conn->trans, _gf_false); - } + rpc_transport_disconnect(conn->trans, _gf_false); + } out: - return; + return; } int -rpc_clnt_ping_cbk (struct rpc_req *req, struct iovec *iov, int count, - void *myframe) +rpc_clnt_ping_cbk(struct rpc_req *req, struct iovec *iov, int count, + void *myframe) { - struct ping_local *local = NULL; - xlator_t *this = NULL; - rpc_clnt_connection_t *conn = NULL; - call_frame_t *frame = NULL; - int unref = 0; - gf_boolean_t call_notify = _gf_false; - - struct timespec now; - struct timespec delta; - int64_t latency_msec = 0; - int ret = 0; - - if (!myframe) { - gf_log (THIS->name, GF_LOG_WARNING, - "frame with the request is NULL"); - goto out; + struct ping_local *local = NULL; + xlator_t *this = NULL; + rpc_clnt_connection_t *conn = NULL; + call_frame_t *frame = NULL; + int unref = 0; + gf_boolean_t call_notify = _gf_false; + + struct timespec now; + struct timespec delta; + int64_t latency_msec = 0; + int ret = 0; + + if (!myframe) { + gf_log(THIS->name, GF_LOG_WARNING, "frame with the request is NULL"); + goto out; + } + + frame = myframe; + this = frame->this; + local = frame->local; + conn = &local->rpc->conn; + + timespec_now(&now); + timespec_sub(&local->submit_time, &now, &delta); + latency_msec = delta.tv_sec * 1000 + delta.tv_nsec / 1000000; + + pthread_mutex_lock(&conn->lock); + { + gf_log(THIS->name, GF_LOG_DEBUG, "Ping latency is %" PRIu64 "ms", + latency_msec); + + call_notify = _gf_true; + if (req->rpc_status == -1) { + unref = rpc_clnt_remove_ping_timer_locked(local->rpc); + if (unref) { + gf_log(this->name, GF_LOG_WARNING, + "socket or ib related error"); + + } else { + /* timer expired and transport bailed out */ + gf_log(this->name, GF_LOG_WARNING, "socket disconnected"); + } + conn->ping_started = 0; + goto unlock; } - frame = myframe; - this = frame->this; - local = frame->local; - conn = &local->rpc->conn; - - timespec_now (&now); - timespec_sub (&local->submit_time, &now, &delta); - latency_msec = delta.tv_sec * 1000 + delta.tv_nsec / 1000000; - - pthread_mutex_lock (&conn->lock); - { - gf_log (THIS->name, GF_LOG_DEBUG, - "Ping latency is %" PRIu64 "ms", - latency_msec); - - call_notify = _gf_true; - if (req->rpc_status == -1) { - unref = rpc_clnt_remove_ping_timer_locked (local->rpc); - if (unref) { - gf_log (this->name, GF_LOG_WARNING, - "socket or ib related error"); - - } else { - /* timer expired and transport bailed out */ - gf_log (this->name, GF_LOG_WARNING, - "socket disconnected"); - - } - conn->ping_started = 0; - goto unlock; - } - - unref = rpc_clnt_remove_ping_timer_locked (local->rpc); - if (__rpc_clnt_rearm_ping_timer (local->rpc, - rpc_clnt_start_ping) == -1) { - gf_log (this->name, GF_LOG_WARNING, - "failed to set the ping timer"); - } - + unref = rpc_clnt_remove_ping_timer_locked(local->rpc); + if (__rpc_clnt_rearm_ping_timer(local->rpc, rpc_clnt_start_ping) == + -1) { + gf_log(this->name, GF_LOG_WARNING, "failed to set the ping timer"); } + } unlock: - pthread_mutex_unlock (&conn->lock); - - if (call_notify) { - ret = local->rpc->notifyfn (local->rpc, this, RPC_CLNT_PING, - (void *)(uintptr_t)latency_msec); - if (ret) { - gf_log (this->name, GF_LOG_WARNING, - "RPC_CLNT_PING notify failed"); - } - } -out: - if (unref) - rpc_clnt_unref (local->rpc); + pthread_mutex_unlock(&conn->lock); - if (frame) { - GF_FREE (frame->local); - frame->local = NULL; - STACK_DESTROY (frame->root); + if (call_notify) { + ret = local->rpc->notifyfn(local->rpc, this, RPC_CLNT_PING, + (void *)(uintptr_t)latency_msec); + if (ret) { + gf_log(this->name, GF_LOG_WARNING, "RPC_CLNT_PING notify failed"); } - return 0; + } +out: + if (unref) + rpc_clnt_unref(local->rpc); + + if (frame) { + GF_FREE(frame->local); + frame->local = NULL; + STACK_DESTROY(frame->root); + } + return 0; } int -rpc_clnt_ping (struct rpc_clnt *rpc) +rpc_clnt_ping(struct rpc_clnt *rpc) { - call_frame_t *frame = NULL; - int32_t ret = -1; - rpc_clnt_connection_t *conn = NULL; - struct ping_local *local = NULL; - - conn = &rpc->conn; - local = GF_MALLOC (sizeof(struct ping_local), - gf_common_ping_local_t); - if (!local) - return ret; - frame = create_frame (THIS, THIS->ctx->pool); - if (!frame) { - GF_FREE (local); - return ret; - } - - local->rpc = rpc; - timespec_now (&local->submit_time); - frame->local = local; - - ret = rpc_clnt_submit (rpc, &clnt_ping_prog, - GF_DUMP_PING, rpc_clnt_ping_cbk, NULL, 0, - NULL, 0, NULL, frame, NULL, 0, NULL, 0, NULL); - if (ret) { - /* FIXME: should we free the frame here? Methinks so! */ - gf_log (THIS->name, GF_LOG_ERROR, - "failed to start ping timer"); - } - else { - /* ping successfully queued in list of saved frames - * for the connection*/ - pthread_mutex_lock (&conn->lock); - conn->pingcnt++; - pthread_mutex_unlock (&conn->lock); - } - + call_frame_t *frame = NULL; + int32_t ret = -1; + rpc_clnt_connection_t *conn = NULL; + struct ping_local *local = NULL; + + conn = &rpc->conn; + local = GF_MALLOC(sizeof(struct ping_local), gf_common_ping_local_t); + if (!local) return ret; - + frame = create_frame(THIS, THIS->ctx->pool); + if (!frame) { + GF_FREE(local); + return ret; + } + + local->rpc = rpc; + timespec_now(&local->submit_time); + frame->local = local; + + ret = rpc_clnt_submit(rpc, &clnt_ping_prog, GF_DUMP_PING, rpc_clnt_ping_cbk, + NULL, 0, NULL, 0, NULL, frame, NULL, 0, NULL, 0, + NULL); + if (ret) { + /* FIXME: should we free the frame here? Methinks so! */ + gf_log(THIS->name, GF_LOG_ERROR, "failed to start ping timer"); + } else { + /* ping successfully queued in list of saved frames + * for the connection*/ + pthread_mutex_lock(&conn->lock); + conn->pingcnt++; + pthread_mutex_unlock(&conn->lock); + } + + return ret; } static void -rpc_clnt_start_ping (void *rpc_ptr) +rpc_clnt_start_ping(void *rpc_ptr) { - struct rpc_clnt *rpc = NULL; - rpc_clnt_connection_t *conn = NULL; - int frame_count = 0; - int unref = 0; - - rpc = (struct rpc_clnt*) rpc_ptr; - conn = &rpc->conn; - - if (conn->ping_timeout == 0) { - gf_log (THIS->name, GF_LOG_DEBUG, "ping timeout is 0," - " returning"); - return; + struct rpc_clnt *rpc = NULL; + rpc_clnt_connection_t *conn = NULL; + int frame_count = 0; + int unref = 0; + + rpc = (struct rpc_clnt *)rpc_ptr; + conn = &rpc->conn; + + if (conn->ping_timeout == 0) { + gf_log(THIS->name, GF_LOG_DEBUG, + "ping timeout is 0," + " returning"); + return; + } + + pthread_mutex_lock(&conn->lock); + { + unref = rpc_clnt_remove_ping_timer_locked(rpc); + + if (conn->saved_frames) { + GF_ASSERT(conn->saved_frames->count >= 0); + /* treat the case where conn->saved_frames is NULL + as no pending frames */ + frame_count = conn->saved_frames->count; } - pthread_mutex_lock (&conn->lock); - { - unref = rpc_clnt_remove_ping_timer_locked (rpc); - - if (conn->saved_frames) { - GF_ASSERT (conn->saved_frames->count >= 0); - /* treat the case where conn->saved_frames is NULL - as no pending frames */ - frame_count = conn->saved_frames->count; - } - - if ((frame_count == 0) || !conn->connected) { - gf_log (THIS->name, GF_LOG_DEBUG, - "returning as transport is already disconnected" - " OR there are no frames (%d || %d)", - !conn->connected, frame_count); - - pthread_mutex_unlock (&conn->lock); - if (unref) - rpc_clnt_unref (rpc); - return; - } - - if (__rpc_clnt_rearm_ping_timer (rpc, - rpc_clnt_ping_timer_expired) == -1) { - gf_log (THIS->name, GF_LOG_WARNING, - "unable to setup ping timer"); - pthread_mutex_unlock (&conn->lock); - if (unref) - rpc_clnt_unref (rpc); - return; - - } + if ((frame_count == 0) || !conn->connected) { + gf_log(THIS->name, GF_LOG_DEBUG, + "returning as transport is already disconnected" + " OR there are no frames (%d || %d)", + !conn->connected, frame_count); + pthread_mutex_unlock(&conn->lock); + if (unref) + rpc_clnt_unref(rpc); + return; } - pthread_mutex_unlock (&conn->lock); - if (unref) - rpc_clnt_unref (rpc); - rpc_clnt_ping(rpc); + if (__rpc_clnt_rearm_ping_timer(rpc, rpc_clnt_ping_timer_expired) == + -1) { + gf_log(THIS->name, GF_LOG_WARNING, "unable to setup ping timer"); + pthread_mutex_unlock(&conn->lock); + if (unref) + rpc_clnt_unref(rpc); + return; + } + } + pthread_mutex_unlock(&conn->lock); + if (unref) + rpc_clnt_unref(rpc); + + rpc_clnt_ping(rpc); } void -rpc_clnt_check_and_start_ping (struct rpc_clnt *rpc) +rpc_clnt_check_and_start_ping(struct rpc_clnt *rpc) { - char start_ping = 0; + char start_ping = 0; - pthread_mutex_lock (&rpc->conn.lock); - { - if (!rpc->conn.ping_started) - start_ping = 1; - } - pthread_mutex_unlock (&rpc->conn.lock); + pthread_mutex_lock(&rpc->conn.lock); + { + if (!rpc->conn.ping_started) + start_ping = 1; + } + pthread_mutex_unlock(&rpc->conn.lock); - if (start_ping) - rpc_clnt_start_ping ((void *)rpc); + if (start_ping) + rpc_clnt_start_ping((void *)rpc); - return; + return; } diff --git a/rpc/rpc-lib/src/rpc-clnt.c b/rpc/rpc-lib/src/rpc-clnt.c index 9ee9161c904..c5236251549 100644 --- a/rpc/rpc-lib/src/rpc-clnt.c +++ b/rpc/rpc-lib/src/rpc-clnt.c @@ -8,7 +8,6 @@ cases as published by the Free Software Foundation. */ - #define RPC_CLNT_DEFAULT_REQUEST_COUNT 512 #include "rpc-clnt.h" @@ -22,479 +21,465 @@ #include "rpc-common-xdr.h" void -rpc_clnt_reply_deinit (struct rpc_req *req, struct mem_pool *pool); +rpc_clnt_reply_deinit(struct rpc_req *req, struct mem_pool *pool); struct saved_frame * -__saved_frames_get_timedout (struct saved_frames *frames, uint32_t timeout, - struct timeval *current) +__saved_frames_get_timedout(struct saved_frames *frames, uint32_t timeout, + struct timeval *current) { - struct saved_frame *bailout_frame = NULL, *tmp = NULL; - - if (!list_empty(&frames->sf.list)) { - tmp = list_entry (frames->sf.list.next, typeof (*tmp), list); - if ((tmp->saved_at.tv_sec + timeout) <= current->tv_sec) { - bailout_frame = tmp; - list_del_init (&bailout_frame->list); - frames->count--; - } - } - - return bailout_frame; + struct saved_frame *bailout_frame = NULL, *tmp = NULL; + + if (!list_empty(&frames->sf.list)) { + tmp = list_entry(frames->sf.list.next, typeof(*tmp), list); + if ((tmp->saved_at.tv_sec + timeout) <= current->tv_sec) { + bailout_frame = tmp; + list_del_init(&bailout_frame->list); + frames->count--; + } + } + + return bailout_frame; } static int -_is_lock_fop (struct saved_frame *sframe) +_is_lock_fop(struct saved_frame *sframe) { - int fop = 0; + int fop = 0; - if (SFRAME_GET_PROGNUM (sframe) == GLUSTER_FOP_PROGRAM && - SFRAME_GET_PROGVER (sframe) == GLUSTER_FOP_VERSION) - fop = SFRAME_GET_PROCNUM (sframe); + if (SFRAME_GET_PROGNUM(sframe) == GLUSTER_FOP_PROGRAM && + SFRAME_GET_PROGVER(sframe) == GLUSTER_FOP_VERSION) + fop = SFRAME_GET_PROCNUM(sframe); - return ((fop == GFS3_OP_LK) || - (fop == GFS3_OP_INODELK) || - (fop == GFS3_OP_FINODELK) || - (fop == GFS3_OP_ENTRYLK) || - (fop == GFS3_OP_FENTRYLK)); + return ((fop == GFS3_OP_LK) || (fop == GFS3_OP_INODELK) || + (fop == GFS3_OP_FINODELK) || (fop == GFS3_OP_ENTRYLK) || + (fop == GFS3_OP_FENTRYLK)); } struct saved_frame * -__saved_frames_put (struct saved_frames *frames, void *frame, - struct rpc_req *rpcreq) +__saved_frames_put(struct saved_frames *frames, void *frame, + struct rpc_req *rpcreq) { - struct saved_frame *saved_frame = NULL; + struct saved_frame *saved_frame = NULL; - saved_frame = mem_get (rpcreq->conn->rpc_clnt->saved_frames_pool); - if (!saved_frame) { - goto out; - } - /* THIS should be saved and set back */ + saved_frame = mem_get(rpcreq->conn->rpc_clnt->saved_frames_pool); + if (!saved_frame) { + goto out; + } + /* THIS should be saved and set back */ - memset (saved_frame, 0, sizeof (*saved_frame)); - INIT_LIST_HEAD (&saved_frame->list); + memset(saved_frame, 0, sizeof(*saved_frame)); + INIT_LIST_HEAD(&saved_frame->list); - saved_frame->capital_this = THIS; - saved_frame->frame = frame; - saved_frame->rpcreq = rpcreq; - gettimeofday (&saved_frame->saved_at, NULL); + saved_frame->capital_this = THIS; + saved_frame->frame = frame; + saved_frame->rpcreq = rpcreq; + gettimeofday(&saved_frame->saved_at, NULL); - if (_is_lock_fop (saved_frame)) - list_add_tail (&saved_frame->list, &frames->lk_sf.list); - else - list_add_tail (&saved_frame->list, &frames->sf.list); + if (_is_lock_fop(saved_frame)) + list_add_tail(&saved_frame->list, &frames->lk_sf.list); + else + list_add_tail(&saved_frame->list, &frames->sf.list); - frames->count++; + frames->count++; out: - return saved_frame; + return saved_frame; } - - static void -call_bail (void *data) +call_bail(void *data) { - rpc_transport_t *trans = NULL; - struct rpc_clnt *clnt = NULL; - rpc_clnt_connection_t *conn = NULL; - struct timeval current; - struct list_head list; - struct saved_frame *saved_frame = NULL; - struct saved_frame *trav = NULL; - struct saved_frame *tmp = NULL; - char frame_sent[256] = {0,}; - struct timespec timeout = {0,}; - char peerid[UNIX_PATH_MAX] = {0}; - gf_boolean_t need_unref = _gf_false; - int len; - - GF_VALIDATE_OR_GOTO ("client", data, out); - - clnt = data; - - conn = &clnt->conn; - pthread_mutex_lock (&conn->lock); - { - trans = conn->trans; - if (trans) { - strncpy (peerid, conn->trans->peerinfo.identifier, - sizeof (peerid)-1); - + rpc_transport_t *trans = NULL; + struct rpc_clnt *clnt = NULL; + rpc_clnt_connection_t *conn = NULL; + struct timeval current; + struct list_head list; + struct saved_frame *saved_frame = NULL; + struct saved_frame *trav = NULL; + struct saved_frame *tmp = NULL; + char frame_sent[256] = { + 0, + }; + struct timespec timeout = { + 0, + }; + char peerid[UNIX_PATH_MAX] = {0}; + gf_boolean_t need_unref = _gf_false; + int len; + + GF_VALIDATE_OR_GOTO("client", data, out); + + clnt = data; + + conn = &clnt->conn; + pthread_mutex_lock(&conn->lock); + { + trans = conn->trans; + if (trans) { + strncpy(peerid, conn->trans->peerinfo.identifier, + sizeof(peerid) - 1); + } + } + pthread_mutex_unlock(&conn->lock); + /*rpc_clnt_connection_cleanup will be unwinding all saved frames, + * bailed or otherwise*/ + if (!trans) + goto out; + + gettimeofday(¤t, NULL); + INIT_LIST_HEAD(&list); + + pthread_mutex_lock(&conn->lock); + { + /* Chaining to get call-always functionality from + call-once timer */ + if (conn->timer) { + timeout.tv_sec = 10; + timeout.tv_nsec = 0; + + /* Ref rpc as it's added to timer event queue */ + rpc_clnt_ref(clnt); + gf_timer_call_cancel(clnt->ctx, conn->timer); + conn->timer = gf_timer_call_after(clnt->ctx, timeout, call_bail, + (void *)clnt); + + if (conn->timer == NULL) { + gf_log(conn->name, GF_LOG_WARNING, + "Cannot create bailout timer for %s", peerid); + need_unref = _gf_true; } } - pthread_mutex_unlock (&conn->lock); - /*rpc_clnt_connection_cleanup will be unwinding all saved frames, - * bailed or otherwise*/ - if (!trans) - goto out; - - gettimeofday (¤t, NULL); - INIT_LIST_HEAD (&list); - pthread_mutex_lock (&conn->lock); - { - /* Chaining to get call-always functionality from - call-once timer */ - if (conn->timer) { - timeout.tv_sec = 10; - timeout.tv_nsec = 0; - - /* Ref rpc as it's added to timer event queue */ - rpc_clnt_ref (clnt); - gf_timer_call_cancel (clnt->ctx, conn->timer); - conn->timer = gf_timer_call_after (clnt->ctx, - timeout, - call_bail, - (void *) clnt); - - if (conn->timer == NULL) { - gf_log (conn->name, GF_LOG_WARNING, - "Cannot create bailout timer for %s", - peerid); - need_unref = _gf_true; - } - } - - do { - saved_frame = - __saved_frames_get_timedout (conn->saved_frames, - conn->frame_timeout, - ¤t); - if (saved_frame) - list_add (&saved_frame->list, &list); - - } while (saved_frame); - } - pthread_mutex_unlock (&conn->lock); - - list_for_each_entry_safe (trav, tmp, &list, list) { - gf_time_fmt (frame_sent, sizeof frame_sent, - trav->saved_at.tv_sec, gf_timefmt_FT); - len = strlen (frame_sent); - snprintf (frame_sent + len, sizeof (frame_sent) - len, - ".%"GF_PRI_SUSECONDS, trav->saved_at.tv_usec); - - gf_log (conn->name, GF_LOG_ERROR, - "bailing out frame type(%s), op(%s(%d)), xid = 0x%x, " - "unique = %"PRIu64", sent = %s, timeout = %d for %s", - trav->rpcreq->prog->progname, - (trav->rpcreq->prog->procnames) ? - trav->rpcreq->prog->procnames[trav->rpcreq->procnum] : - "--", - trav->rpcreq->procnum, trav->rpcreq->xid, - ((call_frame_t *)(trav->frame))->root->unique, - frame_sent, conn->frame_timeout, peerid); - - clnt = rpc_clnt_ref (clnt); - trav->rpcreq->rpc_status = -1; - trav->rpcreq->cbkfn (trav->rpcreq, NULL, 0, trav->frame); - - rpc_clnt_reply_deinit (trav->rpcreq, clnt->reqpool); - clnt = rpc_clnt_unref (clnt); - list_del_init (&trav->list); - mem_put (trav); - } + do { + saved_frame = __saved_frames_get_timedout( + conn->saved_frames, conn->frame_timeout, ¤t); + if (saved_frame) + list_add(&saved_frame->list, &list); + + } while (saved_frame); + } + pthread_mutex_unlock(&conn->lock); + + list_for_each_entry_safe(trav, tmp, &list, list) + { + gf_time_fmt(frame_sent, sizeof frame_sent, trav->saved_at.tv_sec, + gf_timefmt_FT); + len = strlen(frame_sent); + snprintf(frame_sent + len, sizeof(frame_sent) - len, + ".%" GF_PRI_SUSECONDS, trav->saved_at.tv_usec); + + gf_log(conn->name, GF_LOG_ERROR, + "bailing out frame type(%s), op(%s(%d)), xid = 0x%x, " + "unique = %" PRIu64 ", sent = %s, timeout = %d for %s", + trav->rpcreq->prog->progname, + (trav->rpcreq->prog->procnames) + ? trav->rpcreq->prog->procnames[trav->rpcreq->procnum] + : "--", + trav->rpcreq->procnum, trav->rpcreq->xid, + ((call_frame_t *)(trav->frame))->root->unique, frame_sent, + conn->frame_timeout, peerid); + + clnt = rpc_clnt_ref(clnt); + trav->rpcreq->rpc_status = -1; + trav->rpcreq->cbkfn(trav->rpcreq, NULL, 0, trav->frame); + + rpc_clnt_reply_deinit(trav->rpcreq, clnt->reqpool); + clnt = rpc_clnt_unref(clnt); + list_del_init(&trav->list); + mem_put(trav); + } out: - rpc_clnt_unref (clnt); - if (need_unref) - rpc_clnt_unref (clnt); - return; + rpc_clnt_unref(clnt); + if (need_unref) + rpc_clnt_unref(clnt); + return; } - /* to be called with conn->lock held */ struct saved_frame * -__save_frame (struct rpc_clnt *rpc_clnt, call_frame_t *frame, - struct rpc_req *rpcreq) +__save_frame(struct rpc_clnt *rpc_clnt, call_frame_t *frame, + struct rpc_req *rpcreq) { - rpc_clnt_connection_t *conn = NULL; - struct timespec timeout = {0, }; - struct saved_frame *saved_frame = NULL; + rpc_clnt_connection_t *conn = NULL; + struct timespec timeout = { + 0, + }; + struct saved_frame *saved_frame = NULL; - conn = &rpc_clnt->conn; + conn = &rpc_clnt->conn; - saved_frame = __saved_frames_put (conn->saved_frames, frame, rpcreq); + saved_frame = __saved_frames_put(conn->saved_frames, frame, rpcreq); - if (saved_frame == NULL) { - goto out; - } + if (saved_frame == NULL) { + goto out; + } - /* TODO: make timeout configurable */ - if (conn->timer == NULL) { - timeout.tv_sec = 10; - timeout.tv_nsec = 0; - rpc_clnt_ref (rpc_clnt); - conn->timer = gf_timer_call_after (rpc_clnt->ctx, - timeout, - call_bail, - (void *) rpc_clnt); - } + /* TODO: make timeout configurable */ + if (conn->timer == NULL) { + timeout.tv_sec = 10; + timeout.tv_nsec = 0; + rpc_clnt_ref(rpc_clnt); + conn->timer = gf_timer_call_after(rpc_clnt->ctx, timeout, call_bail, + (void *)rpc_clnt); + } out: - return saved_frame; + return saved_frame; } - struct saved_frames * -saved_frames_new (void) +saved_frames_new(void) { - struct saved_frames *saved_frames = NULL; + struct saved_frames *saved_frames = NULL; - saved_frames = GF_CALLOC (1, sizeof (*saved_frames), - gf_common_mt_rpcclnt_savedframe_t); - if (!saved_frames) { - return NULL; - } + saved_frames = GF_CALLOC(1, sizeof(*saved_frames), + gf_common_mt_rpcclnt_savedframe_t); + if (!saved_frames) { + return NULL; + } - INIT_LIST_HEAD (&saved_frames->sf.list); - INIT_LIST_HEAD (&saved_frames->lk_sf.list); + INIT_LIST_HEAD(&saved_frames->sf.list); + INIT_LIST_HEAD(&saved_frames->lk_sf.list); - return saved_frames; + return saved_frames; } - int -__saved_frame_copy (struct saved_frames *frames, int64_t callid, - struct saved_frame *saved_frame) +__saved_frame_copy(struct saved_frames *frames, int64_t callid, + struct saved_frame *saved_frame) { - struct saved_frame *tmp = NULL; - int ret = -1; + struct saved_frame *tmp = NULL; + int ret = -1; - if (!saved_frame) { - ret = 0; - goto out; + if (!saved_frame) { + ret = 0; + goto out; + } + + list_for_each_entry(tmp, &frames->sf.list, list) + { + if (tmp->rpcreq->xid == callid) { + *saved_frame = *tmp; + ret = 0; + goto out; } + } - list_for_each_entry (tmp, &frames->sf.list, list) { - if (tmp->rpcreq->xid == callid) { - *saved_frame = *tmp; - ret = 0; - goto out; - } - } - - list_for_each_entry (tmp, &frames->lk_sf.list, list) { - if (tmp->rpcreq->xid == callid) { - *saved_frame = *tmp; - ret = 0; - goto out; - } - } + list_for_each_entry(tmp, &frames->lk_sf.list, list) + { + if (tmp->rpcreq->xid == callid) { + *saved_frame = *tmp; + ret = 0; + goto out; + } + } out: - return ret; + return ret; } - struct saved_frame * -__saved_frame_get (struct saved_frames *frames, int64_t callid) +__saved_frame_get(struct saved_frames *frames, int64_t callid) { - struct saved_frame *saved_frame = NULL; - struct saved_frame *tmp = NULL; - - list_for_each_entry (tmp, &frames->sf.list, list) { - if (tmp->rpcreq->xid == callid) { - list_del_init (&tmp->list); - frames->count--; - saved_frame = tmp; - goto out; - } - } - - list_for_each_entry (tmp, &frames->lk_sf.list, list) { - if (tmp->rpcreq->xid == callid) { - list_del_init (&tmp->list); - frames->count--; - saved_frame = tmp; - goto out; - } - } + struct saved_frame *saved_frame = NULL; + struct saved_frame *tmp = NULL; -out: - if (saved_frame) { - THIS = saved_frame->capital_this; + list_for_each_entry(tmp, &frames->sf.list, list) + { + if (tmp->rpcreq->xid == callid) { + list_del_init(&tmp->list); + frames->count--; + saved_frame = tmp; + goto out; } + } - return saved_frame; -} + list_for_each_entry(tmp, &frames->lk_sf.list, list) + { + if (tmp->rpcreq->xid == callid) { + list_del_init(&tmp->list); + frames->count--; + saved_frame = tmp; + goto out; + } + } + +out: + if (saved_frame) { + THIS = saved_frame->capital_this; + } + return saved_frame; +} void -saved_frames_unwind (struct saved_frames *saved_frames) +saved_frames_unwind(struct saved_frames *saved_frames) { - struct saved_frame *trav = NULL; - struct saved_frame *tmp = NULL; - char timestr[1024] = {0,}; - int len; - - list_splice_init (&saved_frames->lk_sf.list, &saved_frames->sf.list); - - list_for_each_entry_safe (trav, tmp, &saved_frames->sf.list, list) { - gf_time_fmt (timestr, sizeof timestr, - trav->saved_at.tv_sec, gf_timefmt_FT); - len = strlen (timestr); - snprintf (timestr + len, sizeof(timestr) - len, - ".%"GF_PRI_SUSECONDS, trav->saved_at.tv_usec); - - if (!trav->rpcreq || !trav->rpcreq->prog) - continue; - - gf_log_callingfn (trav->rpcreq->conn->name, - GF_LOG_ERROR, - "forced unwinding frame type(%s) op(%s(%d)) " - "called at %s (xid=0x%x)", - trav->rpcreq->prog->progname, - ((trav->rpcreq->prog->procnames) ? - trav->rpcreq->prog->procnames[trav->rpcreq->procnum] - : "--"), - trav->rpcreq->procnum, timestr, - trav->rpcreq->xid); - saved_frames->count--; - - trav->rpcreq->rpc_status = -1; - trav->rpcreq->cbkfn (trav->rpcreq, NULL, 0, trav->frame); - - rpc_clnt_reply_deinit (trav->rpcreq, - trav->rpcreq->conn->rpc_clnt->reqpool); - - list_del_init (&trav->list); - mem_put (trav); - } + struct saved_frame *trav = NULL; + struct saved_frame *tmp = NULL; + char timestr[1024] = { + 0, + }; + int len; + + list_splice_init(&saved_frames->lk_sf.list, &saved_frames->sf.list); + + list_for_each_entry_safe(trav, tmp, &saved_frames->sf.list, list) + { + gf_time_fmt(timestr, sizeof timestr, trav->saved_at.tv_sec, + gf_timefmt_FT); + len = strlen(timestr); + snprintf(timestr + len, sizeof(timestr) - len, ".%" GF_PRI_SUSECONDS, + trav->saved_at.tv_usec); + + if (!trav->rpcreq || !trav->rpcreq->prog) + continue; + + gf_log_callingfn( + trav->rpcreq->conn->name, GF_LOG_ERROR, + "forced unwinding frame type(%s) op(%s(%d)) " + "called at %s (xid=0x%x)", + trav->rpcreq->prog->progname, + ((trav->rpcreq->prog->procnames) + ? trav->rpcreq->prog->procnames[trav->rpcreq->procnum] + : "--"), + trav->rpcreq->procnum, timestr, trav->rpcreq->xid); + saved_frames->count--; + + trav->rpcreq->rpc_status = -1; + trav->rpcreq->cbkfn(trav->rpcreq, NULL, 0, trav->frame); + + rpc_clnt_reply_deinit(trav->rpcreq, + trav->rpcreq->conn->rpc_clnt->reqpool); + + list_del_init(&trav->list); + mem_put(trav); + } } - void -saved_frames_destroy (struct saved_frames *frames) +saved_frames_destroy(struct saved_frames *frames) { - if (!frames) - return; + if (!frames) + return; - saved_frames_unwind (frames); + saved_frames_unwind(frames); - GF_FREE (frames); + GF_FREE(frames); } - void -rpc_clnt_reconnect (void *conn_ptr) +rpc_clnt_reconnect(void *conn_ptr) { - rpc_transport_t *trans = NULL; - rpc_clnt_connection_t *conn = NULL; - struct timespec ts = {0, 0}; - struct rpc_clnt *clnt = NULL; - gf_boolean_t need_unref = _gf_false; + rpc_transport_t *trans = NULL; + rpc_clnt_connection_t *conn = NULL; + struct timespec ts = {0, 0}; + struct rpc_clnt *clnt = NULL; + gf_boolean_t need_unref = _gf_false; - conn = conn_ptr; - clnt = conn->rpc_clnt; + conn = conn_ptr; + clnt = conn->rpc_clnt; - pthread_mutex_lock (&conn->lock); - { - trans = conn->trans; - if (!trans) { - pthread_mutex_unlock (&conn->lock); - return; - } - if (conn->reconnect) - gf_timer_call_cancel (clnt->ctx, - conn->reconnect); - conn->reconnect = 0; - - if ((conn->connected == 0) && !clnt->disabled) { - ts.tv_sec = 3; - ts.tv_nsec = 0; - - gf_log (conn->name, GF_LOG_TRACE, - "attempting reconnect"); - (void) rpc_transport_connect (trans, - conn->config.remote_port); - rpc_clnt_ref (clnt); - conn->reconnect = - gf_timer_call_after (clnt->ctx, ts, - rpc_clnt_reconnect, - conn); - if (!conn->reconnect) { - need_unref = _gf_true; - gf_log (conn->name, GF_LOG_ERROR, - "Error adding to timer event queue"); - } - } else { - gf_log (conn->name, GF_LOG_TRACE, - "breaking reconnect chain"); - } + pthread_mutex_lock(&conn->lock); + { + trans = conn->trans; + if (!trans) { + pthread_mutex_unlock(&conn->lock); + return; + } + if (conn->reconnect) + gf_timer_call_cancel(clnt->ctx, conn->reconnect); + conn->reconnect = 0; + + if ((conn->connected == 0) && !clnt->disabled) { + ts.tv_sec = 3; + ts.tv_nsec = 0; + + gf_log(conn->name, GF_LOG_TRACE, "attempting reconnect"); + (void)rpc_transport_connect(trans, conn->config.remote_port); + rpc_clnt_ref(clnt); + conn->reconnect = gf_timer_call_after(clnt->ctx, ts, + rpc_clnt_reconnect, conn); + if (!conn->reconnect) { + need_unref = _gf_true; + gf_log(conn->name, GF_LOG_ERROR, + "Error adding to timer event queue"); + } + } else { + gf_log(conn->name, GF_LOG_TRACE, "breaking reconnect chain"); } - pthread_mutex_unlock (&conn->lock); + } + pthread_mutex_unlock(&conn->lock); - rpc_clnt_unref (clnt); - if (need_unref) - rpc_clnt_unref (clnt); - return; + rpc_clnt_unref(clnt); + if (need_unref) + rpc_clnt_unref(clnt); + return; } - int -rpc_clnt_fill_request_info (struct rpc_clnt *clnt, rpc_request_info_t *info) +rpc_clnt_fill_request_info(struct rpc_clnt *clnt, rpc_request_info_t *info) { - struct saved_frame saved_frame; - int ret = -1; - - pthread_mutex_lock (&clnt->conn.lock); - { - ret = __saved_frame_copy (clnt->conn.saved_frames, info->xid, - &saved_frame); - } - pthread_mutex_unlock (&clnt->conn.lock); - - if (ret == -1) { - gf_log (clnt->conn.name, GF_LOG_CRITICAL, - "cannot lookup the saved " - "frame corresponding to xid (%d)", info->xid); - goto out; - } - - info->prognum = saved_frame.rpcreq->prog->prognum; - info->procnum = saved_frame.rpcreq->procnum; - info->progver = saved_frame.rpcreq->prog->progver; - info->rpc_req = saved_frame.rpcreq; - info->rsp = saved_frame.rsp; - - ret = 0; + struct saved_frame saved_frame; + int ret = -1; + + pthread_mutex_lock(&clnt->conn.lock); + { + ret = __saved_frame_copy(clnt->conn.saved_frames, info->xid, + &saved_frame); + } + pthread_mutex_unlock(&clnt->conn.lock); + + if (ret == -1) { + gf_log(clnt->conn.name, GF_LOG_CRITICAL, + "cannot lookup the saved " + "frame corresponding to xid (%d)", + info->xid); + goto out; + } + + info->prognum = saved_frame.rpcreq->prog->prognum; + info->procnum = saved_frame.rpcreq->procnum; + info->progver = saved_frame.rpcreq->prog->progver; + info->rpc_req = saved_frame.rpcreq; + info->rsp = saved_frame.rsp; + + ret = 0; out: - return ret; + return ret; } int -rpc_clnt_reconnect_cleanup (rpc_clnt_connection_t *conn) +rpc_clnt_reconnect_cleanup(rpc_clnt_connection_t *conn) { - struct rpc_clnt *clnt = NULL; - int ret = 0; - gf_boolean_t reconnect_unref = _gf_false; - - if (!conn) { - goto out; - } - - clnt = conn->rpc_clnt; - - pthread_mutex_lock (&conn->lock); - { - - if (conn->reconnect) { - ret = gf_timer_call_cancel (clnt->ctx, conn->reconnect); - if (!ret) { - reconnect_unref = _gf_true; - conn->cleanup_gen++; - } - conn->reconnect = NULL; - } - + struct rpc_clnt *clnt = NULL; + int ret = 0; + gf_boolean_t reconnect_unref = _gf_false; + + if (!conn) { + goto out; + } + + clnt = conn->rpc_clnt; + + pthread_mutex_lock(&conn->lock); + { + if (conn->reconnect) { + ret = gf_timer_call_cancel(clnt->ctx, conn->reconnect); + if (!ret) { + reconnect_unref = _gf_true; + conn->cleanup_gen++; + } + conn->reconnect = NULL; } - pthread_mutex_unlock (&conn->lock); + } + pthread_mutex_unlock(&conn->lock); - if (reconnect_unref) - rpc_clnt_unref (clnt); + if (reconnect_unref) + rpc_clnt_unref(clnt); out: - return 0; + return 0; } /* @@ -503,54 +488,53 @@ out: * */ int -rpc_clnt_connection_cleanup (rpc_clnt_connection_t *conn) +rpc_clnt_connection_cleanup(rpc_clnt_connection_t *conn) { - struct saved_frames *saved_frames = NULL; - struct rpc_clnt *clnt = NULL; - int unref = 0; - int ret = 0; - gf_boolean_t timer_unref = _gf_false; - - if (!conn) { - goto out; - } + struct saved_frames *saved_frames = NULL; + struct rpc_clnt *clnt = NULL; + int unref = 0; + int ret = 0; + gf_boolean_t timer_unref = _gf_false; - clnt = conn->rpc_clnt; + if (!conn) { + goto out; + } - pthread_mutex_lock (&conn->lock); - { + clnt = conn->rpc_clnt; - saved_frames = conn->saved_frames; - conn->saved_frames = saved_frames_new (); + pthread_mutex_lock(&conn->lock); + { + saved_frames = conn->saved_frames; + conn->saved_frames = saved_frames_new(); - /* bailout logic cleanup */ - if (conn->timer) { - ret = gf_timer_call_cancel (clnt->ctx, conn->timer); - if (!ret) - timer_unref = _gf_true; - conn->timer = NULL; - } + /* bailout logic cleanup */ + if (conn->timer) { + ret = gf_timer_call_cancel(clnt->ctx, conn->timer); + if (!ret) + timer_unref = _gf_true; + conn->timer = NULL; + } - conn->connected = 0; - conn->disconnected = 1; + conn->connected = 0; + conn->disconnected = 1; - unref = rpc_clnt_remove_ping_timer_locked (clnt); - /*reset rpc msgs stats*/ - conn->pingcnt = 0; - conn->msgcnt = 0; - conn->cleanup_gen++; - } - pthread_mutex_unlock (&conn->lock); + unref = rpc_clnt_remove_ping_timer_locked(clnt); + /*reset rpc msgs stats*/ + conn->pingcnt = 0; + conn->msgcnt = 0; + conn->cleanup_gen++; + } + pthread_mutex_unlock(&conn->lock); - saved_frames_destroy (saved_frames); - if (unref) - rpc_clnt_unref (clnt); + saved_frames_destroy(saved_frames); + if (unref) + rpc_clnt_unref(clnt); - if (timer_unref) - rpc_clnt_unref (clnt); + if (timer_unref) + rpc_clnt_unref(clnt); out: - return 0; + return 0; } /* @@ -562,1554 +546,1516 @@ out: */ static struct saved_frame * -lookup_frame (rpc_clnt_connection_t *conn, int64_t callid) +lookup_frame(rpc_clnt_connection_t *conn, int64_t callid) { - struct saved_frame *frame = NULL; + struct saved_frame *frame = NULL; - pthread_mutex_lock (&conn->lock); - { - frame = __saved_frame_get (conn->saved_frames, callid); - } - pthread_mutex_unlock (&conn->lock); + pthread_mutex_lock(&conn->lock); + { + frame = __saved_frame_get(conn->saved_frames, callid); + } + pthread_mutex_unlock(&conn->lock); - return frame; + return frame; } - int -rpc_clnt_reply_fill (rpc_transport_pollin_t *msg, - rpc_clnt_connection_t *conn, - struct rpc_msg *replymsg, struct iovec progmsg, - struct rpc_req *req, - struct saved_frame *saved_frame) +rpc_clnt_reply_fill(rpc_transport_pollin_t *msg, rpc_clnt_connection_t *conn, + struct rpc_msg *replymsg, struct iovec progmsg, + struct rpc_req *req, struct saved_frame *saved_frame) { - int ret = -1; - - if ((!conn) || (!replymsg)|| (!req) || (!saved_frame) || (!msg)) { - goto out; - } - - req->rpc_status = 0; - if ((rpc_reply_status (replymsg) == MSG_DENIED) - || (rpc_accepted_reply_status (replymsg) != SUCCESS)) { - req->rpc_status = -1; - } - - req->rsp[0] = progmsg; - req->rsp_iobref = iobref_ref (msg->iobref); - - if (msg->vectored) { - req->rsp[1] = msg->vector[1]; - req->rspcnt = 2; - } else { - req->rspcnt = 1; - } - - /* By this time, the data bytes for the auth scheme would have already - * been copied into the required sections of the req structure, - * we just need to fill in the meta-data about it now. + int ret = -1; + + if ((!conn) || (!replymsg) || (!req) || (!saved_frame) || (!msg)) { + goto out; + } + + req->rpc_status = 0; + if ((rpc_reply_status(replymsg) == MSG_DENIED) || + (rpc_accepted_reply_status(replymsg) != SUCCESS)) { + req->rpc_status = -1; + } + + req->rsp[0] = progmsg; + req->rsp_iobref = iobref_ref(msg->iobref); + + if (msg->vectored) { + req->rsp[1] = msg->vector[1]; + req->rspcnt = 2; + } else { + req->rspcnt = 1; + } + + /* By this time, the data bytes for the auth scheme would have already + * been copied into the required sections of the req structure, + * we just need to fill in the meta-data about it now. + */ + if (req->rpc_status == 0) { + /* + * req->verf.flavour = rpc_reply_verf_flavour (replymsg); + * req->verf.datalen = rpc_reply_verf_len (replymsg); */ - if (req->rpc_status == 0) { - /* - * req->verf.flavour = rpc_reply_verf_flavour (replymsg); - * req->verf.datalen = rpc_reply_verf_len (replymsg); - */ - } + } - ret = 0; + ret = 0; out: - return ret; + return ret; } - void -rpc_clnt_reply_deinit (struct rpc_req *req, struct mem_pool *pool) +rpc_clnt_reply_deinit(struct rpc_req *req, struct mem_pool *pool) { - if (!req) { - goto out; - } + if (!req) { + goto out; + } - if (req->rsp_iobref) { - iobref_unref (req->rsp_iobref); - } + if (req->rsp_iobref) { + iobref_unref(req->rsp_iobref); + } - mem_put (req); + mem_put(req); out: - return; + return; } - /* TODO: use mem-pool for allocating requests */ int -rpc_clnt_reply_init (rpc_clnt_connection_t *conn, rpc_transport_pollin_t *msg, - struct rpc_req *req, struct saved_frame *saved_frame) +rpc_clnt_reply_init(rpc_clnt_connection_t *conn, rpc_transport_pollin_t *msg, + struct rpc_req *req, struct saved_frame *saved_frame) { - char *msgbuf = NULL; - struct rpc_msg rpcmsg; - struct iovec progmsg; /* RPC Program payload */ - size_t msglen = 0; - int ret = -1; - - msgbuf = msg->vector[0].iov_base; - msglen = msg->vector[0].iov_len; - - ret = xdr_to_rpc_reply (msgbuf, msglen, &rpcmsg, &progmsg, - req->verf.authdata); - if (ret != 0) { - gf_log (conn->name, GF_LOG_WARNING, - "RPC reply decoding failed"); - goto out; - } - - ret = rpc_clnt_reply_fill (msg, conn, &rpcmsg, progmsg, req, - saved_frame); - if (ret != 0) { - goto out; - } - - gf_log (conn->name, GF_LOG_TRACE, - "received rpc message (RPC XID: 0x%x" - " Program: %s, ProgVers: %d, Proc: %d) from rpc-transport (%s)", - saved_frame->rpcreq->xid, - saved_frame->rpcreq->prog->progname, - saved_frame->rpcreq->prog->progver, - saved_frame->rpcreq->procnum, conn->name); + char *msgbuf = NULL; + struct rpc_msg rpcmsg; + struct iovec progmsg; /* RPC Program payload */ + size_t msglen = 0; + int ret = -1; + + msgbuf = msg->vector[0].iov_base; + msglen = msg->vector[0].iov_len; + + ret = xdr_to_rpc_reply(msgbuf, msglen, &rpcmsg, &progmsg, + req->verf.authdata); + if (ret != 0) { + gf_log(conn->name, GF_LOG_WARNING, "RPC reply decoding failed"); + goto out; + } + + ret = rpc_clnt_reply_fill(msg, conn, &rpcmsg, progmsg, req, saved_frame); + if (ret != 0) { + goto out; + } + + gf_log(conn->name, GF_LOG_TRACE, + "received rpc message (RPC XID: 0x%x" + " Program: %s, ProgVers: %d, Proc: %d) from rpc-transport (%s)", + saved_frame->rpcreq->xid, saved_frame->rpcreq->prog->progname, + saved_frame->rpcreq->prog->progver, saved_frame->rpcreq->procnum, + conn->name); out: - if (ret != 0) { - req->rpc_status = -1; - } + if (ret != 0) { + req->rpc_status = -1; + } - return ret; + return ret; } int -rpc_clnt_handle_cbk (struct rpc_clnt *clnt, rpc_transport_pollin_t *msg) +rpc_clnt_handle_cbk(struct rpc_clnt *clnt, rpc_transport_pollin_t *msg) { - char *msgbuf = NULL; - rpcclnt_cb_program_t *program = NULL; - struct rpc_msg rpcmsg; - struct iovec progmsg; /* RPC Program payload */ - size_t msglen = 0; - int found = 0; - int ret = -1; - int procnum = 0; - - msgbuf = msg->vector[0].iov_base; - msglen = msg->vector[0].iov_len; - - clnt = rpc_clnt_ref (clnt); - ret = xdr_to_rpc_call (msgbuf, msglen, &rpcmsg, &progmsg, NULL,NULL); - if (ret == -1) { - gf_log (clnt->conn.name, GF_LOG_WARNING, - "RPC call decoding failed"); - goto out; - } - - gf_log (clnt->conn.name, GF_LOG_TRACE, - "receivd rpc message (XID: 0x%" GF_PRI_RPC_XID ", " - "Ver: %" GF_PRI_RPC_VERSION ", Program: %" GF_PRI_RPC_PROG_ID ", " - "ProgVers: %" GF_PRI_RPC_PROG_VERS ", Proc: %" GF_PRI_RPC_PROC ") " - "from rpc-transport (%s)", rpc_call_xid (&rpcmsg), - rpc_call_rpcvers (&rpcmsg), rpc_call_program (&rpcmsg), - rpc_call_progver (&rpcmsg), rpc_call_progproc (&rpcmsg), - clnt->conn.name); - - procnum = rpc_call_progproc (&rpcmsg); - - pthread_mutex_lock (&clnt->lock); + char *msgbuf = NULL; + rpcclnt_cb_program_t *program = NULL; + struct rpc_msg rpcmsg; + struct iovec progmsg; /* RPC Program payload */ + size_t msglen = 0; + int found = 0; + int ret = -1; + int procnum = 0; + + msgbuf = msg->vector[0].iov_base; + msglen = msg->vector[0].iov_len; + + clnt = rpc_clnt_ref(clnt); + ret = xdr_to_rpc_call(msgbuf, msglen, &rpcmsg, &progmsg, NULL, NULL); + if (ret == -1) { + gf_log(clnt->conn.name, GF_LOG_WARNING, "RPC call decoding failed"); + goto out; + } + + gf_log(clnt->conn.name, GF_LOG_TRACE, + "receivd rpc message (XID: 0x%" GF_PRI_RPC_XID + ", " + "Ver: %" GF_PRI_RPC_VERSION ", Program: %" GF_PRI_RPC_PROG_ID + ", " + "ProgVers: %" GF_PRI_RPC_PROG_VERS ", Proc: %" GF_PRI_RPC_PROC + ") " + "from rpc-transport (%s)", + rpc_call_xid(&rpcmsg), rpc_call_rpcvers(&rpcmsg), + rpc_call_program(&rpcmsg), rpc_call_progver(&rpcmsg), + rpc_call_progproc(&rpcmsg), clnt->conn.name); + + procnum = rpc_call_progproc(&rpcmsg); + + pthread_mutex_lock(&clnt->lock); + { + list_for_each_entry(program, &clnt->programs, program) { - list_for_each_entry (program, &clnt->programs, program) { - if ((program->prognum == rpc_call_program (&rpcmsg)) - && (program->progver - == rpc_call_progver (&rpcmsg))) { - found = 1; - break; - } - } + if ((program->prognum == rpc_call_program(&rpcmsg)) && + (program->progver == rpc_call_progver(&rpcmsg))) { + found = 1; + break; + } } - pthread_mutex_unlock (&clnt->lock); + } + pthread_mutex_unlock(&clnt->lock); - if (found && (procnum < program->numactors) && - (program->actors[procnum].actor)) { - program->actors[procnum].actor (clnt, program->mydata, - &progmsg); - } + if (found && (procnum < program->numactors) && + (program->actors[procnum].actor)) { + program->actors[procnum].actor(clnt, program->mydata, &progmsg); + } out: - rpc_clnt_unref (clnt); - return ret; + rpc_clnt_unref(clnt); + return ret; } int -rpc_clnt_handle_reply (struct rpc_clnt *clnt, rpc_transport_pollin_t *pollin) +rpc_clnt_handle_reply(struct rpc_clnt *clnt, rpc_transport_pollin_t *pollin) { - rpc_clnt_connection_t *conn = NULL; - struct saved_frame *saved_frame = NULL; - int ret = -1; - struct rpc_req *req = NULL; - uint32_t xid = 0; - - clnt = rpc_clnt_ref (clnt); - conn = &clnt->conn; - - xid = ntoh32 (*((uint32_t *)pollin->vector[0].iov_base)); - saved_frame = lookup_frame (conn, xid); - if (saved_frame == NULL) { - gf_log (conn->name, GF_LOG_ERROR, - "cannot lookup the saved frame for reply with xid (%u)", - xid); - goto out; - } - - req = saved_frame->rpcreq; - if (req == NULL) { - gf_log (conn->name, GF_LOG_ERROR, - "no request with frame for xid (%u)", xid); - goto out; - } - - ret = rpc_clnt_reply_init (conn, pollin, req, saved_frame); - if (ret != 0) { - req->rpc_status = -1; - gf_log (conn->name, GF_LOG_WARNING, - "initialising rpc reply failed"); - } - - req->cbkfn (req, req->rsp, req->rspcnt, saved_frame->frame); - - if (req) { - rpc_clnt_reply_deinit (req, conn->rpc_clnt->reqpool); - } + rpc_clnt_connection_t *conn = NULL; + struct saved_frame *saved_frame = NULL; + int ret = -1; + struct rpc_req *req = NULL; + uint32_t xid = 0; + + clnt = rpc_clnt_ref(clnt); + conn = &clnt->conn; + + xid = ntoh32(*((uint32_t *)pollin->vector[0].iov_base)); + saved_frame = lookup_frame(conn, xid); + if (saved_frame == NULL) { + gf_log(conn->name, GF_LOG_ERROR, + "cannot lookup the saved frame for reply with xid (%u)", xid); + goto out; + } + + req = saved_frame->rpcreq; + if (req == NULL) { + gf_log(conn->name, GF_LOG_ERROR, "no request with frame for xid (%u)", + xid); + goto out; + } + + ret = rpc_clnt_reply_init(conn, pollin, req, saved_frame); + if (ret != 0) { + req->rpc_status = -1; + gf_log(conn->name, GF_LOG_WARNING, "initialising rpc reply failed"); + } + + req->cbkfn(req, req->rsp, req->rspcnt, saved_frame->frame); + + if (req) { + rpc_clnt_reply_deinit(req, conn->rpc_clnt->reqpool); + } out: - if (saved_frame) { - mem_put (saved_frame); - } + if (saved_frame) { + mem_put(saved_frame); + } - rpc_clnt_unref (clnt); - return ret; + rpc_clnt_unref(clnt); + return ret; } gf_boolean_t -is_rpc_clnt_disconnected (rpc_clnt_connection_t *conn) +is_rpc_clnt_disconnected(rpc_clnt_connection_t *conn) { - gf_boolean_t disconnected = _gf_true; + gf_boolean_t disconnected = _gf_true; - if (!conn) - return disconnected; + if (!conn) + return disconnected; - pthread_mutex_lock (&conn->lock); - { - if (conn->disconnected == _gf_false) - disconnected = _gf_false; - } - pthread_mutex_unlock (&conn->lock); + pthread_mutex_lock(&conn->lock); + { + if (conn->disconnected == _gf_false) + disconnected = _gf_false; + } + pthread_mutex_unlock(&conn->lock); - return disconnected; + return disconnected; } static void -rpc_clnt_destroy (struct rpc_clnt *rpc); +rpc_clnt_destroy(struct rpc_clnt *rpc); -#define RPC_THIS_SAVE(xl) do { \ - old_THIS = THIS ; \ - if (!old_THIS) \ - gf_log_callingfn ("rpc", GF_LOG_CRITICAL, \ - "THIS is not initialised."); \ - THIS = xl; \ -} while (0) +#define RPC_THIS_SAVE(xl) \ + do { \ + old_THIS = THIS; \ + if (!old_THIS) \ + gf_log_callingfn("rpc", GF_LOG_CRITICAL, \ + "THIS is not initialised."); \ + THIS = xl; \ + } while (0) -#define RPC_THIS_RESTORE (THIS = old_THIS) +#define RPC_THIS_RESTORE (THIS = old_THIS) static int -rpc_clnt_handle_disconnect (struct rpc_clnt *clnt, rpc_clnt_connection_t *conn) +rpc_clnt_handle_disconnect(struct rpc_clnt *clnt, rpc_clnt_connection_t *conn) { - struct timespec ts = {0, }; - gf_boolean_t unref_clnt = _gf_false; - uint64_t pre_notify_gen = 0, post_notify_gen = 0; - - pthread_mutex_lock (&conn->lock); - { - pre_notify_gen = conn->cleanup_gen; - } - pthread_mutex_unlock (&conn->lock); - - if (clnt->notifyfn) - clnt->notifyfn (clnt, clnt->mydata, RPC_CLNT_DISCONNECT, NULL); - - pthread_mutex_lock (&conn->lock); - { - post_notify_gen = conn->cleanup_gen; - } - pthread_mutex_unlock (&conn->lock); - - if (pre_notify_gen == post_notify_gen) { - /* program didn't invoke cleanup, so rpc has to do it */ - rpc_clnt_connection_cleanup (conn); - } - - pthread_mutex_lock (&conn->lock); - { - if (!conn->rpc_clnt->disabled && (conn->reconnect == NULL)) { - ts.tv_sec = 10; - ts.tv_nsec = 0; - - rpc_clnt_ref (clnt); - conn->reconnect = gf_timer_call_after (clnt->ctx, ts, - rpc_clnt_reconnect, conn); - if (conn->reconnect == NULL) { - gf_log (conn->name, GF_LOG_WARNING, - "Cannot create rpc_clnt_reconnect timer"); - unref_clnt = _gf_true; - } - } + struct timespec ts = { + 0, + }; + gf_boolean_t unref_clnt = _gf_false; + uint64_t pre_notify_gen = 0, post_notify_gen = 0; + + pthread_mutex_lock(&conn->lock); + { + pre_notify_gen = conn->cleanup_gen; + } + pthread_mutex_unlock(&conn->lock); + + if (clnt->notifyfn) + clnt->notifyfn(clnt, clnt->mydata, RPC_CLNT_DISCONNECT, NULL); + + pthread_mutex_lock(&conn->lock); + { + post_notify_gen = conn->cleanup_gen; + } + pthread_mutex_unlock(&conn->lock); + + if (pre_notify_gen == post_notify_gen) { + /* program didn't invoke cleanup, so rpc has to do it */ + rpc_clnt_connection_cleanup(conn); + } + + pthread_mutex_lock(&conn->lock); + { + if (!conn->rpc_clnt->disabled && (conn->reconnect == NULL)) { + ts.tv_sec = 10; + ts.tv_nsec = 0; + + rpc_clnt_ref(clnt); + conn->reconnect = gf_timer_call_after(clnt->ctx, ts, + rpc_clnt_reconnect, conn); + if (conn->reconnect == NULL) { + gf_log(conn->name, GF_LOG_WARNING, + "Cannot create rpc_clnt_reconnect timer"); + unref_clnt = _gf_true; + } } - pthread_mutex_unlock (&conn->lock); - + } + pthread_mutex_unlock(&conn->lock); - if (unref_clnt) - rpc_clnt_unref (clnt); + if (unref_clnt) + rpc_clnt_unref(clnt); - return 0; + return 0; } int -rpc_clnt_notify (rpc_transport_t *trans, void *mydata, - rpc_transport_event_t event, void *data, ...) +rpc_clnt_notify(rpc_transport_t *trans, void *mydata, + rpc_transport_event_t event, void *data, ...) { - rpc_clnt_connection_t *conn = NULL; - struct rpc_clnt *clnt = NULL; - int ret = -1; - rpc_request_info_t *req_info = NULL; - rpc_transport_pollin_t *pollin = NULL; - void *clnt_mydata = NULL; - DECLARE_OLD_THIS; - - conn = mydata; - if (conn == NULL) { - goto out; - } - clnt = conn->rpc_clnt; - if (!clnt) - goto out; - - RPC_THIS_SAVE (clnt->owner); - - switch (event) { - case RPC_TRANSPORT_DISCONNECT: - { - rpc_clnt_handle_disconnect (clnt, conn); - /* The auth_value was being reset to AUTH_GLUSTERFS_v2. - * if (clnt->auth_value) - * clnt->auth_value = AUTH_GLUSTERFS_v2; - * It should not be reset here. The disconnect during - * portmap request can race with handshake. If handshake - * happens first and disconnect later, auth_value would set - * to default value and it never sets back to actual auth_value - * supported by server. But it's important to set to lower - * version supported in the case where the server downgrades. - * So moving this code to RPC_TRANSPORT_CONNECT. Note that - * CONNECT cannot race with handshake as by nature it is - * serialized with handhake. An handshake can happen only - * on a connected transport and hence its strictly serialized. - */ - break; + rpc_clnt_connection_t *conn = NULL; + struct rpc_clnt *clnt = NULL; + int ret = -1; + rpc_request_info_t *req_info = NULL; + rpc_transport_pollin_t *pollin = NULL; + void *clnt_mydata = NULL; + DECLARE_OLD_THIS; + + conn = mydata; + if (conn == NULL) { + goto out; + } + clnt = conn->rpc_clnt; + if (!clnt) + goto out; + + RPC_THIS_SAVE(clnt->owner); + + switch (event) { + case RPC_TRANSPORT_DISCONNECT: { + rpc_clnt_handle_disconnect(clnt, conn); + /* The auth_value was being reset to AUTH_GLUSTERFS_v2. + * if (clnt->auth_value) + * clnt->auth_value = AUTH_GLUSTERFS_v2; + * It should not be reset here. The disconnect during + * portmap request can race with handshake. If handshake + * happens first and disconnect later, auth_value would set + * to default value and it never sets back to actual auth_value + * supported by server. But it's important to set to lower + * version supported in the case where the server downgrades. + * So moving this code to RPC_TRANSPORT_CONNECT. Note that + * CONNECT cannot race with handshake as by nature it is + * serialized with handhake. An handshake can happen only + * on a connected transport and hence its strictly serialized. + */ + break; } case RPC_TRANSPORT_CLEANUP: - if (clnt->notifyfn) { - clnt_mydata = clnt->mydata; - clnt->mydata = NULL; - ret = clnt->notifyfn (clnt, clnt_mydata, - RPC_CLNT_DESTROY, NULL); - if (ret < 0) { - gf_log (trans->name, GF_LOG_WARNING, - "client notify handler returned error " - "while handling RPC_CLNT_DESTROY"); - } + if (clnt->notifyfn) { + clnt_mydata = clnt->mydata; + clnt->mydata = NULL; + ret = clnt->notifyfn(clnt, clnt_mydata, RPC_CLNT_DESTROY, NULL); + if (ret < 0) { + gf_log(trans->name, GF_LOG_WARNING, + "client notify handler returned error " + "while handling RPC_CLNT_DESTROY"); } - rpc_clnt_destroy (clnt); - ret = 0; - break; - - case RPC_TRANSPORT_MAP_XID_REQUEST: - { - req_info = data; - ret = rpc_clnt_fill_request_info (clnt, req_info); - break; - } - - case RPC_TRANSPORT_MSG_RECEIVED: - { - clock_gettime (CLOCK_REALTIME, &conn->last_received); - - pollin = data; - if (pollin->is_reply) - ret = rpc_clnt_handle_reply (clnt, pollin); - else - ret = rpc_clnt_handle_cbk (clnt, pollin); - /* ret = clnt->notifyfn (clnt, clnt->mydata, RPC_CLNT_MSG, - * data); - */ - break; - } + } + rpc_clnt_destroy(clnt); + ret = 0; + break; + + case RPC_TRANSPORT_MAP_XID_REQUEST: { + req_info = data; + ret = rpc_clnt_fill_request_info(clnt, req_info); + break; + } + + case RPC_TRANSPORT_MSG_RECEIVED: { + clock_gettime(CLOCK_REALTIME, &conn->last_received); + + pollin = data; + if (pollin->is_reply) + ret = rpc_clnt_handle_reply(clnt, pollin); + else + ret = rpc_clnt_handle_cbk(clnt, pollin); + /* ret = clnt->notifyfn (clnt, clnt->mydata, RPC_CLNT_MSG, + * data); + */ + break; + } + + case RPC_TRANSPORT_MSG_SENT: { + clock_gettime(CLOCK_REALTIME, &conn->last_sent); + + ret = 0; + break; + } + + case RPC_TRANSPORT_CONNECT: { + pthread_mutex_lock(&conn->lock); + { + /* Every time there is a disconnection, processes + * should try to connect to 'glusterd' (ie, default + * port) or whichever port given as 'option remote-port' + * in volume file. */ + /* Below code makes sure the (re-)configured port lasts + * for just one successful attempt */ + conn->config.remote_port = 0; + conn->connected = 1; + conn->disconnected = 0; + } + pthread_mutex_unlock(&conn->lock); - case RPC_TRANSPORT_MSG_SENT: - { - clock_gettime (CLOCK_REALTIME, &conn->last_sent); + /* auth value should be set to lower version available + * and will be set to appropriate version supported by + * server after the handshake. + */ + if (clnt->auth_value) + clnt->auth_value = AUTH_GLUSTERFS_v2; + if (clnt->notifyfn) + ret = clnt->notifyfn(clnt, clnt->mydata, RPC_CLNT_CONNECT, + NULL); - ret = 0; - break; - } - - case RPC_TRANSPORT_CONNECT: - { - pthread_mutex_lock (&conn->lock); - { - /* Every time there is a disconnection, processes - * should try to connect to 'glusterd' (ie, default - * port) or whichever port given as 'option remote-port' - * in volume file. */ - /* Below code makes sure the (re-)configured port lasts - * for just one successful attempt */ - conn->config.remote_port = 0; - conn->connected = 1; - conn->disconnected = 0; - } - pthread_mutex_unlock (&conn->lock); - - /* auth value should be set to lower version available - * and will be set to appropriate version supported by - * server after the handshake. - */ - if (clnt->auth_value) - clnt->auth_value = AUTH_GLUSTERFS_v2; - if (clnt->notifyfn) - ret = clnt->notifyfn (clnt, clnt->mydata, - RPC_CLNT_CONNECT, NULL); - - break; + break; } case RPC_TRANSPORT_ACCEPT: - /* only meaningful on a server, no need of handling this event - * in a client. - */ - ret = 0; - break; - } + /* only meaningful on a server, no need of handling this event + * in a client. + */ + ret = 0; + break; + } out: - RPC_THIS_RESTORE; - return ret; + RPC_THIS_RESTORE; + return ret; } static int -rpc_clnt_connection_init (struct rpc_clnt *clnt, glusterfs_ctx_t *ctx, - dict_t *options, char *name) +rpc_clnt_connection_init(struct rpc_clnt *clnt, glusterfs_ctx_t *ctx, + dict_t *options, char *name) { - int ret = -1; - rpc_clnt_connection_t *conn = NULL; - rpc_transport_t *trans = NULL; - - conn = &clnt->conn; - pthread_mutex_init (&clnt->conn.lock, NULL); - - conn->name = gf_strdup (name); - if (!conn->name) { - ret = -1; - goto out; - } - - ret = dict_get_int32 (options, "frame-timeout", - &conn->frame_timeout); - if (ret >= 0) { - gf_log (name, GF_LOG_INFO, - "setting frame-timeout to %d", conn->frame_timeout); - } else { - gf_log (name, GF_LOG_DEBUG, - "defaulting frame-timeout to 30mins"); - conn->frame_timeout = 1800; - } - conn->rpc_clnt = clnt; + int ret = -1; + rpc_clnt_connection_t *conn = NULL; + rpc_transport_t *trans = NULL; - ret = dict_get_int32 (options, "ping-timeout", - &conn->ping_timeout); - if (ret >= 0) { - gf_log (name, GF_LOG_DEBUG, - "setting ping-timeout to %d", conn->ping_timeout); - } else { - /*TODO: Once the epoll thread model is fixed, - change the default ping-timeout to 30sec */ - gf_log (name, GF_LOG_DEBUG, - "disable ping-timeout"); - conn->ping_timeout = 0; - } - - trans = rpc_transport_load (ctx, options, name); - if (!trans) { - gf_log (name, GF_LOG_WARNING, "loading of new rpc-transport" - " failed"); - ret = -1; - goto out; - } - rpc_transport_ref (trans); - - pthread_mutex_lock (&conn->lock); - { - conn->trans = trans; - trans = NULL; - } - pthread_mutex_unlock (&conn->lock); - - ret = rpc_transport_register_notify (conn->trans, rpc_clnt_notify, - conn); - if (ret == -1) { - gf_log (name, GF_LOG_WARNING, "registering notify failed"); - goto out; - } + conn = &clnt->conn; + pthread_mutex_init(&clnt->conn.lock, NULL); - conn->saved_frames = saved_frames_new (); - if (!conn->saved_frames) { - gf_log (name, GF_LOG_WARNING, "creation of saved_frames " - "failed"); - ret = -1; - goto out; - } + conn->name = gf_strdup(name); + if (!conn->name) { + ret = -1; + goto out; + } + + ret = dict_get_int32(options, "frame-timeout", &conn->frame_timeout); + if (ret >= 0) { + gf_log(name, GF_LOG_INFO, "setting frame-timeout to %d", + conn->frame_timeout); + } else { + gf_log(name, GF_LOG_DEBUG, "defaulting frame-timeout to 30mins"); + conn->frame_timeout = 1800; + } + conn->rpc_clnt = clnt; + + ret = dict_get_int32(options, "ping-timeout", &conn->ping_timeout); + if (ret >= 0) { + gf_log(name, GF_LOG_DEBUG, "setting ping-timeout to %d", + conn->ping_timeout); + } else { + /*TODO: Once the epoll thread model is fixed, + change the default ping-timeout to 30sec */ + gf_log(name, GF_LOG_DEBUG, "disable ping-timeout"); + conn->ping_timeout = 0; + } + + trans = rpc_transport_load(ctx, options, name); + if (!trans) { + gf_log(name, GF_LOG_WARNING, + "loading of new rpc-transport" + " failed"); + ret = -1; + goto out; + } + rpc_transport_ref(trans); + + pthread_mutex_lock(&conn->lock); + { + conn->trans = trans; + trans = NULL; + } + pthread_mutex_unlock(&conn->lock); + + ret = rpc_transport_register_notify(conn->trans, rpc_clnt_notify, conn); + if (ret == -1) { + gf_log(name, GF_LOG_WARNING, "registering notify failed"); + goto out; + } + + conn->saved_frames = saved_frames_new(); + if (!conn->saved_frames) { + gf_log(name, GF_LOG_WARNING, + "creation of saved_frames " + "failed"); + ret = -1; + goto out; + } - ret = 0; + ret = 0; out: - if (ret) { - pthread_mutex_lock (&conn->lock); - { - trans = conn->trans; - conn->trans = NULL; - } - pthread_mutex_unlock (&conn->lock); - if (trans) - rpc_transport_unref (trans); - //conn cleanup needs to be done since we might have failed to - // register notification. - rpc_clnt_connection_cleanup (conn); - } - return ret; + if (ret) { + pthread_mutex_lock(&conn->lock); + { + trans = conn->trans; + conn->trans = NULL; + } + pthread_mutex_unlock(&conn->lock); + if (trans) + rpc_transport_unref(trans); + // conn cleanup needs to be done since we might have failed to + // register notification. + rpc_clnt_connection_cleanup(conn); + } + return ret; } struct rpc_clnt * -rpc_clnt_new (dict_t *options, xlator_t *owner, char *name, - uint32_t reqpool_size) +rpc_clnt_new(dict_t *options, xlator_t *owner, char *name, + uint32_t reqpool_size) { - int ret = -1; - struct rpc_clnt *rpc = NULL; - glusterfs_ctx_t *ctx = owner->ctx; - - - rpc = GF_CALLOC (1, sizeof (*rpc), gf_common_mt_rpcclnt_t); - if (!rpc) { - goto out; - } - - pthread_mutex_init (&rpc->lock, NULL); - rpc->ctx = ctx; - rpc->owner = owner; - GF_ATOMIC_INIT (rpc->xid, 1); - - if (!reqpool_size) - reqpool_size = RPC_CLNT_DEFAULT_REQUEST_COUNT; - - rpc->reqpool = mem_pool_new (struct rpc_req, reqpool_size); - if (rpc->reqpool == NULL) { - pthread_mutex_destroy (&rpc->lock); - GF_FREE (rpc); - rpc = NULL; - goto out; - } - - rpc->saved_frames_pool = mem_pool_new (struct saved_frame, - reqpool_size); - if (rpc->saved_frames_pool == NULL) { - pthread_mutex_destroy (&rpc->lock); - mem_pool_destroy (rpc->reqpool); - GF_FREE (rpc); - rpc = NULL; - goto out; - } - - ret = rpc_clnt_connection_init (rpc, ctx, options, name); - if (ret == -1) { - pthread_mutex_destroy (&rpc->lock); - mem_pool_destroy (rpc->reqpool); - mem_pool_destroy (rpc->saved_frames_pool); - GF_FREE (rpc); - rpc = NULL; - if (options) - dict_unref (options); - goto out; - } - - /* This is handled to make sure we have modularity in getting the - auth data changed */ - gf_boolean_t auth_null = dict_get_str_boolean(options, "auth-null", 0); - - rpc->auth_value = (auth_null) ? 0 : AUTH_GLUSTERFS_v2; - - rpc = rpc_clnt_ref (rpc); - INIT_LIST_HEAD (&rpc->programs); + int ret = -1; + struct rpc_clnt *rpc = NULL; + glusterfs_ctx_t *ctx = owner->ctx; + + rpc = GF_CALLOC(1, sizeof(*rpc), gf_common_mt_rpcclnt_t); + if (!rpc) { + goto out; + } + + pthread_mutex_init(&rpc->lock, NULL); + rpc->ctx = ctx; + rpc->owner = owner; + GF_ATOMIC_INIT(rpc->xid, 1); + + if (!reqpool_size) + reqpool_size = RPC_CLNT_DEFAULT_REQUEST_COUNT; + + rpc->reqpool = mem_pool_new(struct rpc_req, reqpool_size); + if (rpc->reqpool == NULL) { + pthread_mutex_destroy(&rpc->lock); + GF_FREE(rpc); + rpc = NULL; + goto out; + } + + rpc->saved_frames_pool = mem_pool_new(struct saved_frame, reqpool_size); + if (rpc->saved_frames_pool == NULL) { + pthread_mutex_destroy(&rpc->lock); + mem_pool_destroy(rpc->reqpool); + GF_FREE(rpc); + rpc = NULL; + goto out; + } + + ret = rpc_clnt_connection_init(rpc, ctx, options, name); + if (ret == -1) { + pthread_mutex_destroy(&rpc->lock); + mem_pool_destroy(rpc->reqpool); + mem_pool_destroy(rpc->saved_frames_pool); + GF_FREE(rpc); + rpc = NULL; + if (options) + dict_unref(options); + goto out; + } + + /* This is handled to make sure we have modularity in getting the + auth data changed */ + gf_boolean_t auth_null = dict_get_str_boolean(options, "auth-null", 0); + + rpc->auth_value = (auth_null) ? 0 : AUTH_GLUSTERFS_v2; + + rpc = rpc_clnt_ref(rpc); + INIT_LIST_HEAD(&rpc->programs); out: - return rpc; + return rpc; } - int -rpc_clnt_start (struct rpc_clnt *rpc) +rpc_clnt_start(struct rpc_clnt *rpc) { - struct rpc_clnt_connection *conn = NULL; + struct rpc_clnt_connection *conn = NULL; - if (!rpc) - return -1; + if (!rpc) + return -1; - conn = &rpc->conn; + conn = &rpc->conn; - pthread_mutex_lock (&conn->lock); - { - rpc->disabled = 0; - } - pthread_mutex_unlock (&conn->lock); - /* Corresponding unref will be either on successful timer cancel or last - * rpc_clnt_reconnect fire event. - */ - rpc_clnt_ref (rpc); - rpc_clnt_reconnect (conn); + pthread_mutex_lock(&conn->lock); + { + rpc->disabled = 0; + } + pthread_mutex_unlock(&conn->lock); + /* Corresponding unref will be either on successful timer cancel or last + * rpc_clnt_reconnect fire event. + */ + rpc_clnt_ref(rpc); + rpc_clnt_reconnect(conn); - return 0; + return 0; } - int -rpc_clnt_cleanup_and_start (struct rpc_clnt *rpc) +rpc_clnt_cleanup_and_start(struct rpc_clnt *rpc) { - struct rpc_clnt_connection *conn = NULL; + struct rpc_clnt_connection *conn = NULL; - if (!rpc) - return -1; + if (!rpc) + return -1; - conn = &rpc->conn; + conn = &rpc->conn; - rpc_clnt_connection_cleanup (conn); + rpc_clnt_connection_cleanup(conn); - pthread_mutex_lock (&conn->lock); - { - rpc->disabled = 0; - } - pthread_mutex_unlock (&conn->lock); - /* Corresponding unref will be either on successful timer cancel or last - * rpc_clnt_reconnect fire event. - */ - rpc_clnt_ref (rpc); - rpc_clnt_reconnect (conn); + pthread_mutex_lock(&conn->lock); + { + rpc->disabled = 0; + } + pthread_mutex_unlock(&conn->lock); + /* Corresponding unref will be either on successful timer cancel or last + * rpc_clnt_reconnect fire event. + */ + rpc_clnt_ref(rpc); + rpc_clnt_reconnect(conn); - return 0; + return 0; } - int -rpc_clnt_register_notify (struct rpc_clnt *rpc, rpc_clnt_notify_t fn, - void *mydata) +rpc_clnt_register_notify(struct rpc_clnt *rpc, rpc_clnt_notify_t fn, + void *mydata) { - rpc->mydata = mydata; - rpc->notifyfn = fn; + rpc->mydata = mydata; + rpc->notifyfn = fn; - return 0; + return 0; } /* used for GF_LOG_OCCASIONALLY() */ static int gf_auth_max_groups_log = 0; static inline int -setup_glusterfs_auth_param_v3 (call_frame_t *frame, - auth_glusterfs_params_v3 *au, - int lk_owner_len, char *owner_data) +setup_glusterfs_auth_param_v3(call_frame_t *frame, auth_glusterfs_params_v3 *au, + int lk_owner_len, char *owner_data) { - int ret = -1; - unsigned int max_groups = 0; - int max_lkowner_len = 0; - - au->pid = frame->root->pid; - au->uid = frame->root->uid; - au->gid = frame->root->gid; - - au->flags = frame->root->flags; - au->ctime_sec = frame->root->ctime.tv_sec; - au->ctime_nsec = frame->root->ctime.tv_nsec; - - au->lk_owner.lk_owner_val = owner_data; - au->lk_owner.lk_owner_len = lk_owner_len; - au->groups.groups_val = frame->root->groups; - au->groups.groups_len = frame->root->ngrps; - - /* The number of groups and the size of lk_owner depend on oneother. - * We can truncate the groups, but should not touch the lk_owner. */ - max_groups = GF_AUTH_GLUSTERFS_MAX_GROUPS (lk_owner_len, AUTH_GLUSTERFS_v3); - if (au->groups.groups_len > max_groups) { - GF_LOG_OCCASIONALLY (gf_auth_max_groups_log, "rpc-auth", - GF_LOG_WARNING, "truncating grouplist " - "from %d to %d", au->groups.groups_len, - max_groups); - - au->groups.groups_len = max_groups; - } - - max_lkowner_len = GF_AUTH_GLUSTERFS_MAX_LKOWNER (au->groups.groups_len, - AUTH_GLUSTERFS_v3); - if (lk_owner_len > max_lkowner_len) { - gf_log ("rpc-clnt", GF_LOG_ERROR, "lkowner field is too " - "big (%d), it does not fit in the rpc-header", - au->lk_owner.lk_owner_len); - errno = E2BIG; - goto out; - } - - ret = 0; + int ret = -1; + unsigned int max_groups = 0; + int max_lkowner_len = 0; + + au->pid = frame->root->pid; + au->uid = frame->root->uid; + au->gid = frame->root->gid; + + au->flags = frame->root->flags; + au->ctime_sec = frame->root->ctime.tv_sec; + au->ctime_nsec = frame->root->ctime.tv_nsec; + + au->lk_owner.lk_owner_val = owner_data; + au->lk_owner.lk_owner_len = lk_owner_len; + au->groups.groups_val = frame->root->groups; + au->groups.groups_len = frame->root->ngrps; + + /* The number of groups and the size of lk_owner depend on oneother. + * We can truncate the groups, but should not touch the lk_owner. */ + max_groups = GF_AUTH_GLUSTERFS_MAX_GROUPS(lk_owner_len, AUTH_GLUSTERFS_v3); + if (au->groups.groups_len > max_groups) { + GF_LOG_OCCASIONALLY(gf_auth_max_groups_log, "rpc-auth", GF_LOG_WARNING, + "truncating grouplist " + "from %d to %d", + au->groups.groups_len, max_groups); + + au->groups.groups_len = max_groups; + } + + max_lkowner_len = GF_AUTH_GLUSTERFS_MAX_LKOWNER(au->groups.groups_len, + AUTH_GLUSTERFS_v3); + if (lk_owner_len > max_lkowner_len) { + gf_log("rpc-clnt", GF_LOG_ERROR, + "lkowner field is too " + "big (%d), it does not fit in the rpc-header", + au->lk_owner.lk_owner_len); + errno = E2BIG; + goto out; + } + + ret = 0; out: - return ret; + return ret; } static inline int -setup_glusterfs_auth_param_v2 (call_frame_t *frame, - auth_glusterfs_parms_v2 *au, - int lk_owner_len, char *owner_data) +setup_glusterfs_auth_param_v2(call_frame_t *frame, auth_glusterfs_parms_v2 *au, + int lk_owner_len, char *owner_data) { - unsigned int max_groups = 0; - int max_lkowner_len = 0; - int ret = -1; - - au->pid = frame->root->pid; - au->uid = frame->root->uid; - au->gid = frame->root->gid; - - au->lk_owner.lk_owner_val = owner_data; - au->lk_owner.lk_owner_len = lk_owner_len; - au->groups.groups_val = frame->root->groups; - au->groups.groups_len = frame->root->ngrps; - - /* The number of groups and the size of lk_owner depend on oneother. - * We can truncate the groups, but should not touch the lk_owner. */ - max_groups = GF_AUTH_GLUSTERFS_MAX_GROUPS (lk_owner_len, AUTH_GLUSTERFS_v2); - if (au->groups.groups_len > max_groups) { - GF_LOG_OCCASIONALLY (gf_auth_max_groups_log, "rpc-auth", - GF_LOG_WARNING, "truncating grouplist " - "from %d to %d", au->groups.groups_len, - max_groups); - - au->groups.groups_len = max_groups; - } - - max_lkowner_len = GF_AUTH_GLUSTERFS_MAX_LKOWNER (au->groups.groups_len, - AUTH_GLUSTERFS_v2); - if (lk_owner_len > max_lkowner_len) { - gf_log ("rpc-auth", GF_LOG_ERROR, "lkowner field is too " - "big (%d), it does not fit in the rpc-header", - au->lk_owner.lk_owner_len); - errno = E2BIG; - goto out; - } - - ret = 0; + unsigned int max_groups = 0; + int max_lkowner_len = 0; + int ret = -1; + + au->pid = frame->root->pid; + au->uid = frame->root->uid; + au->gid = frame->root->gid; + + au->lk_owner.lk_owner_val = owner_data; + au->lk_owner.lk_owner_len = lk_owner_len; + au->groups.groups_val = frame->root->groups; + au->groups.groups_len = frame->root->ngrps; + + /* The number of groups and the size of lk_owner depend on oneother. + * We can truncate the groups, but should not touch the lk_owner. */ + max_groups = GF_AUTH_GLUSTERFS_MAX_GROUPS(lk_owner_len, AUTH_GLUSTERFS_v2); + if (au->groups.groups_len > max_groups) { + GF_LOG_OCCASIONALLY(gf_auth_max_groups_log, "rpc-auth", GF_LOG_WARNING, + "truncating grouplist " + "from %d to %d", + au->groups.groups_len, max_groups); + + au->groups.groups_len = max_groups; + } + + max_lkowner_len = GF_AUTH_GLUSTERFS_MAX_LKOWNER(au->groups.groups_len, + AUTH_GLUSTERFS_v2); + if (lk_owner_len > max_lkowner_len) { + gf_log("rpc-auth", GF_LOG_ERROR, + "lkowner field is too " + "big (%d), it does not fit in the rpc-header", + au->lk_owner.lk_owner_len); + errno = E2BIG; + goto out; + } + + ret = 0; out: - return ret; + return ret; } - static ssize_t -xdr_serialize_glusterfs_auth (struct rpc_clnt *clnt, call_frame_t *frame, - char *dest) +xdr_serialize_glusterfs_auth(struct rpc_clnt *clnt, call_frame_t *frame, + char *dest) { - ssize_t ret = -1; - XDR xdr; - char owner[4] = {0,}; - int32_t pid = 0; - char *lk_owner_data = NULL; - int lk_owner_len = 0; - - if ((!dest)) - return -1; - - xdrmem_create (&xdr, dest, GF_MAX_AUTH_BYTES, XDR_ENCODE); - - if (frame->root->lk_owner.len) { - lk_owner_data = frame->root->lk_owner.data; - lk_owner_len = frame->root->lk_owner.len; - } else { - pid = frame->root->pid; - owner[0] = (char)(pid & 0xff); - owner[1] = (char)((pid >> 8) & 0xff); - owner[2] = (char)((pid >> 16) & 0xff); - owner[3] = (char)((pid >> 24) & 0xff); - - lk_owner_data = owner; - lk_owner_len = 4; - } - - if (clnt->auth_value == AUTH_GLUSTERFS_v2) { - auth_glusterfs_parms_v2 au_v2 = {0,}; - - ret = setup_glusterfs_auth_param_v2 (frame, &au_v2, - lk_owner_len, - lk_owner_data); - if (ret) - goto out; - if (!xdr_auth_glusterfs_parms_v2 (&xdr, &au_v2)) { - gf_log (THIS->name, GF_LOG_WARNING, - "failed to encode auth glusterfs elements"); - ret = -1; - goto out; - } - } else if (clnt->auth_value == AUTH_GLUSTERFS_v3) { - auth_glusterfs_params_v3 au_v3 = {0,}; - - ret = setup_glusterfs_auth_param_v3 (frame, &au_v3, - lk_owner_len, - lk_owner_data); - if (ret) - goto out; - - if (!xdr_auth_glusterfs_params_v3 (&xdr, &au_v3)) { - gf_log (THIS->name, GF_LOG_WARNING, - "failed to encode auth glusterfs elements"); - ret = -1; - goto out; - } - } else { - gf_log (THIS->name, GF_LOG_WARNING, - "failed to encode auth glusterfs elements"); - ret = -1; - goto out; - } + ssize_t ret = -1; + XDR xdr; + char owner[4] = { + 0, + }; + int32_t pid = 0; + char *lk_owner_data = NULL; + int lk_owner_len = 0; + + if ((!dest)) + return -1; + + xdrmem_create(&xdr, dest, GF_MAX_AUTH_BYTES, XDR_ENCODE); + + if (frame->root->lk_owner.len) { + lk_owner_data = frame->root->lk_owner.data; + lk_owner_len = frame->root->lk_owner.len; + } else { + pid = frame->root->pid; + owner[0] = (char)(pid & 0xff); + owner[1] = (char)((pid >> 8) & 0xff); + owner[2] = (char)((pid >> 16) & 0xff); + owner[3] = (char)((pid >> 24) & 0xff); + + lk_owner_data = owner; + lk_owner_len = 4; + } + + if (clnt->auth_value == AUTH_GLUSTERFS_v2) { + auth_glusterfs_parms_v2 au_v2 = { + 0, + }; + + ret = setup_glusterfs_auth_param_v2(frame, &au_v2, lk_owner_len, + lk_owner_data); + if (ret) + goto out; + if (!xdr_auth_glusterfs_parms_v2(&xdr, &au_v2)) { + gf_log(THIS->name, GF_LOG_WARNING, + "failed to encode auth glusterfs elements"); + ret = -1; + goto out; + } + } else if (clnt->auth_value == AUTH_GLUSTERFS_v3) { + auth_glusterfs_params_v3 au_v3 = { + 0, + }; + + ret = setup_glusterfs_auth_param_v3(frame, &au_v3, lk_owner_len, + lk_owner_data); + if (ret) + goto out; + + if (!xdr_auth_glusterfs_params_v3(&xdr, &au_v3)) { + gf_log(THIS->name, GF_LOG_WARNING, + "failed to encode auth glusterfs elements"); + ret = -1; + goto out; + } + } else { + gf_log(THIS->name, GF_LOG_WARNING, + "failed to encode auth glusterfs elements"); + ret = -1; + goto out; + } - ret = (((size_t)(&xdr)->x_private) - ((size_t)(&xdr)->x_base)); + ret = (((size_t)(&xdr)->x_private) - ((size_t)(&xdr)->x_base)); out: - return ret; + return ret; } - int -rpc_clnt_fill_request (struct rpc_clnt *clnt, int prognum, int progver, - int procnum, uint64_t xid, call_frame_t *fr, - struct rpc_msg *request, char *auth_data) +rpc_clnt_fill_request(struct rpc_clnt *clnt, int prognum, int progver, + int procnum, uint64_t xid, call_frame_t *fr, + struct rpc_msg *request, char *auth_data) { - int ret = -1; + int ret = -1; - if (!request) { - goto out; - } + if (!request) { + goto out; + } - memset (request, 0, sizeof (*request)); + memset(request, 0, sizeof(*request)); - request->rm_xid = xid; - request->rm_direction = CALL; + request->rm_xid = xid; + request->rm_direction = CALL; - request->rm_call.cb_rpcvers = 2; - request->rm_call.cb_prog = prognum; - request->rm_call.cb_vers = progver; - request->rm_call.cb_proc = procnum; + request->rm_call.cb_rpcvers = 2; + request->rm_call.cb_prog = prognum; + request->rm_call.cb_vers = progver; + request->rm_call.cb_proc = procnum; - if (!clnt->auth_value) { - request->rm_call.cb_cred.oa_flavor = AUTH_NULL; - request->rm_call.cb_cred.oa_base = NULL; - request->rm_call.cb_cred.oa_length = 0; - } else { - ret = xdr_serialize_glusterfs_auth (clnt, fr, auth_data); - if (ret == -1) { - gf_log ("rpc-clnt", GF_LOG_WARNING, - "cannot encode auth credentials"); - goto out; - } - - request->rm_call.cb_cred.oa_flavor = clnt->auth_value; - request->rm_call.cb_cred.oa_base = auth_data; - request->rm_call.cb_cred.oa_length = ret; + if (!clnt->auth_value) { + request->rm_call.cb_cred.oa_flavor = AUTH_NULL; + request->rm_call.cb_cred.oa_base = NULL; + request->rm_call.cb_cred.oa_length = 0; + } else { + ret = xdr_serialize_glusterfs_auth(clnt, fr, auth_data); + if (ret == -1) { + gf_log("rpc-clnt", GF_LOG_WARNING, + "cannot encode auth credentials"); + goto out; } - request->rm_call.cb_verf.oa_flavor = AUTH_NONE; - request->rm_call.cb_verf.oa_base = NULL; - request->rm_call.cb_verf.oa_length = 0; - ret = 0; + request->rm_call.cb_cred.oa_flavor = clnt->auth_value; + request->rm_call.cb_cred.oa_base = auth_data; + request->rm_call.cb_cred.oa_length = ret; + } + request->rm_call.cb_verf.oa_flavor = AUTH_NONE; + request->rm_call.cb_verf.oa_base = NULL; + request->rm_call.cb_verf.oa_length = 0; + + ret = 0; out: - return ret; + return ret; } - struct iovec -rpc_clnt_record_build_header (char *recordstart, size_t rlen, - struct rpc_msg *request, size_t payload) +rpc_clnt_record_build_header(char *recordstart, size_t rlen, + struct rpc_msg *request, size_t payload) { - struct iovec requesthdr = {0, }; - struct iovec txrecord = {0, 0}; - int ret = -1; - size_t fraglen = 0; - - ret = rpc_request_to_xdr (request, recordstart, rlen, &requesthdr); - if (ret == -1) { - gf_log ("rpc-clnt", GF_LOG_DEBUG, - "Failed to create RPC request"); - goto out; - } - - fraglen = payload + requesthdr.iov_len; - gf_log ("rpc-clnt", GF_LOG_TRACE, "Request fraglen %zu, payload: %zu, " - "rpc hdr: %zu", fraglen, payload, requesthdr.iov_len); - - - txrecord.iov_base = recordstart; - - /* Remember, this is only the vec for the RPC header and does not - * include the payload above. We needed the payload only to calculate - * the size of the full fragment. This size is sent in the fragment - * header. - */ - txrecord.iov_len = requesthdr.iov_len; + struct iovec requesthdr = { + 0, + }; + struct iovec txrecord = {0, 0}; + int ret = -1; + size_t fraglen = 0; + + ret = rpc_request_to_xdr(request, recordstart, rlen, &requesthdr); + if (ret == -1) { + gf_log("rpc-clnt", GF_LOG_DEBUG, "Failed to create RPC request"); + goto out; + } + + fraglen = payload + requesthdr.iov_len; + gf_log("rpc-clnt", GF_LOG_TRACE, + "Request fraglen %zu, payload: %zu, " + "rpc hdr: %zu", + fraglen, payload, requesthdr.iov_len); + + txrecord.iov_base = recordstart; + + /* Remember, this is only the vec for the RPC header and does not + * include the payload above. We needed the payload only to calculate + * the size of the full fragment. This size is sent in the fragment + * header. + */ + txrecord.iov_len = requesthdr.iov_len; out: - return txrecord; + return txrecord; } - struct iobuf * -rpc_clnt_record_build_record (struct rpc_clnt *clnt, call_frame_t *fr, - int prognum, int progver, - int procnum, size_t hdrsize, uint64_t xid, - struct iovec *recbuf) +rpc_clnt_record_build_record(struct rpc_clnt *clnt, call_frame_t *fr, + int prognum, int progver, int procnum, + size_t hdrsize, uint64_t xid, struct iovec *recbuf) { - struct rpc_msg request = {0, }; - struct iobuf *request_iob = NULL; - char *record = NULL; - struct iovec recordhdr = {0, }; - size_t pagesize = 0; - int ret = -1; - size_t xdr_size = 0; - char auth_data[GF_MAX_AUTH_BYTES] = {0, }; - - if ((!clnt) || (!recbuf)) { - goto out; - } - - /* Fill the rpc structure and XDR it into the buffer got above. */ - ret = rpc_clnt_fill_request (clnt, prognum, progver, procnum, - xid, fr, &request, auth_data); - - if (ret == -1) { - gf_log (clnt->conn.name, GF_LOG_WARNING, - "cannot build a rpc-request xid (%"PRIu64")", xid); - goto out; - } - - xdr_size = xdr_sizeof ((xdrproc_t)xdr_callmsg, &request); - - /* First, try to get a pointer into the buffer which the RPC - * layer can use. - */ - request_iob = iobuf_get2 (clnt->ctx->iobuf_pool, (xdr_size + hdrsize)); - if (!request_iob) { - goto out; - } - - pagesize = iobuf_pagesize (request_iob); - - record = iobuf_ptr (request_iob); /* Now we have it. */ - - recordhdr = rpc_clnt_record_build_header (record, pagesize, &request, - hdrsize); - - if (!recordhdr.iov_base) { - gf_log (clnt->conn.name, GF_LOG_ERROR, - "Failed to build record header"); - iobuf_unref (request_iob); - request_iob = NULL; - recbuf->iov_base = NULL; - goto out; - } - - recbuf->iov_base = recordhdr.iov_base; - recbuf->iov_len = recordhdr.iov_len; + struct rpc_msg request = { + 0, + }; + struct iobuf *request_iob = NULL; + char *record = NULL; + struct iovec recordhdr = { + 0, + }; + size_t pagesize = 0; + int ret = -1; + size_t xdr_size = 0; + char auth_data[GF_MAX_AUTH_BYTES] = { + 0, + }; + + if ((!clnt) || (!recbuf)) { + goto out; + } + + /* Fill the rpc structure and XDR it into the buffer got above. */ + ret = rpc_clnt_fill_request(clnt, prognum, progver, procnum, xid, fr, + &request, auth_data); + + if (ret == -1) { + gf_log(clnt->conn.name, GF_LOG_WARNING, + "cannot build a rpc-request xid (%" PRIu64 ")", xid); + goto out; + } + + xdr_size = xdr_sizeof((xdrproc_t)xdr_callmsg, &request); + + /* First, try to get a pointer into the buffer which the RPC + * layer can use. + */ + request_iob = iobuf_get2(clnt->ctx->iobuf_pool, (xdr_size + hdrsize)); + if (!request_iob) { + goto out; + } + + pagesize = iobuf_pagesize(request_iob); + + record = iobuf_ptr(request_iob); /* Now we have it. */ + + recordhdr = rpc_clnt_record_build_header(record, pagesize, &request, + hdrsize); + + if (!recordhdr.iov_base) { + gf_log(clnt->conn.name, GF_LOG_ERROR, "Failed to build record header"); + iobuf_unref(request_iob); + request_iob = NULL; + recbuf->iov_base = NULL; + goto out; + } + + recbuf->iov_base = recordhdr.iov_base; + recbuf->iov_len = recordhdr.iov_len; out: - return request_iob; + return request_iob; } - static inline struct iobuf * -rpc_clnt_record (struct rpc_clnt *clnt, call_frame_t *call_frame, - rpc_clnt_prog_t *prog, int procnum, size_t hdrlen, - struct iovec *rpchdr, uint64_t callid) +rpc_clnt_record(struct rpc_clnt *clnt, call_frame_t *call_frame, + rpc_clnt_prog_t *prog, int procnum, size_t hdrlen, + struct iovec *rpchdr, uint64_t callid) { + if (!prog || !rpchdr || !call_frame) { + return NULL; + } - if (!prog || !rpchdr || !call_frame) { - return NULL; - } - - return rpc_clnt_record_build_record (clnt, call_frame, - prog->prognum, - prog->progver, - procnum, hdrlen, - callid, rpchdr); + return rpc_clnt_record_build_record(clnt, call_frame, prog->prognum, + prog->progver, procnum, hdrlen, callid, + rpchdr); } int -rpcclnt_cbk_program_register (struct rpc_clnt *clnt, - rpcclnt_cb_program_t *program, void *mydata) +rpcclnt_cbk_program_register(struct rpc_clnt *clnt, + rpcclnt_cb_program_t *program, void *mydata) { - int ret = -1; - char already_registered = 0; - rpcclnt_cb_program_t *tmp = NULL; + int ret = -1; + char already_registered = 0; + rpcclnt_cb_program_t *tmp = NULL; - if (!clnt) - goto out; + if (!clnt) + goto out; - if (program->actors == NULL) - goto out; + if (program->actors == NULL) + goto out; - pthread_mutex_lock (&clnt->lock); + pthread_mutex_lock(&clnt->lock); + { + list_for_each_entry(tmp, &clnt->programs, program) { - list_for_each_entry (tmp, &clnt->programs, program) { - if ((program->prognum == tmp->prognum) - && (program->progver == tmp->progver)) { - already_registered = 1; - break; - } - } + if ((program->prognum == tmp->prognum) && + (program->progver == tmp->progver)) { + already_registered = 1; + break; + } } - pthread_mutex_unlock (&clnt->lock); + } + pthread_mutex_unlock(&clnt->lock); - if (already_registered) { - gf_log_callingfn (clnt->conn.name, GF_LOG_DEBUG, - "already registered"); - ret = 0; - goto out; - } + if (already_registered) { + gf_log_callingfn(clnt->conn.name, GF_LOG_DEBUG, "already registered"); + ret = 0; + goto out; + } - tmp = GF_MALLOC (sizeof (*tmp), - gf_common_mt_rpcclnt_cb_program_t); - if (tmp == NULL) { - goto out; - } + tmp = GF_MALLOC(sizeof(*tmp), gf_common_mt_rpcclnt_cb_program_t); + if (tmp == NULL) { + goto out; + } - memcpy (tmp, program, sizeof (*tmp)); - INIT_LIST_HEAD (&tmp->program); + memcpy(tmp, program, sizeof(*tmp)); + INIT_LIST_HEAD(&tmp->program); - tmp->mydata = mydata; + tmp->mydata = mydata; - pthread_mutex_lock (&clnt->lock); - { - list_add_tail (&tmp->program, &clnt->programs); - } - pthread_mutex_unlock (&clnt->lock); + pthread_mutex_lock(&clnt->lock); + { + list_add_tail(&tmp->program, &clnt->programs); + } + pthread_mutex_unlock(&clnt->lock); - ret = 0; - gf_log (clnt->conn.name, GF_LOG_DEBUG, - "New program registered: %s, Num: %d, Ver: %d", - program->progname, program->prognum, - program->progver); + ret = 0; + gf_log(clnt->conn.name, GF_LOG_DEBUG, + "New program registered: %s, Num: %d, Ver: %d", program->progname, + program->prognum, program->progver); out: - if (ret == -1 && clnt) { - gf_log (clnt->conn.name, GF_LOG_ERROR, - "Program registration failed:" - " %s, Num: %d, Ver: %d", - program->progname, - program->prognum, program->progver); - } - - return ret; + if (ret == -1 && clnt) { + gf_log(clnt->conn.name, GF_LOG_ERROR, + "Program registration failed:" + " %s, Num: %d, Ver: %d", + program->progname, program->prognum, program->progver); + } + + return ret; } - int -rpc_clnt_submit (struct rpc_clnt *rpc, rpc_clnt_prog_t *prog, - int procnum, fop_cbk_fn_t cbkfn, - struct iovec *proghdr, int proghdrcount, - struct iovec *progpayload, int progpayloadcount, - struct iobref *iobref, void *frame, struct iovec *rsphdr, - int rsphdr_count, struct iovec *rsp_payload, - int rsp_payload_count, struct iobref *rsp_iobref) +rpc_clnt_submit(struct rpc_clnt *rpc, rpc_clnt_prog_t *prog, int procnum, + fop_cbk_fn_t cbkfn, struct iovec *proghdr, int proghdrcount, + struct iovec *progpayload, int progpayloadcount, + struct iobref *iobref, void *frame, struct iovec *rsphdr, + int rsphdr_count, struct iovec *rsp_payload, + int rsp_payload_count, struct iobref *rsp_iobref) { - rpc_clnt_connection_t *conn = NULL; - struct iobuf *request_iob = NULL; - struct iovec rpchdr = {0,}; - struct rpc_req *rpcreq = NULL; - rpc_transport_req_t req; - int ret = -1; - int proglen = 0; - char new_iobref = 0; - uint64_t callid = 0; - gf_boolean_t need_unref = _gf_false; - call_frame_t *cframe = frame; - - if (!rpc || !prog || !frame) { - goto out; - } - - conn = &rpc->conn; - - rpcreq = mem_get (rpc->reqpool); - if (rpcreq == NULL) { - goto out; - } - - memset (rpcreq, 0, sizeof (*rpcreq)); - memset (&req, 0, sizeof (req)); - + rpc_clnt_connection_t *conn = NULL; + struct iobuf *request_iob = NULL; + struct iovec rpchdr = { + 0, + }; + struct rpc_req *rpcreq = NULL; + rpc_transport_req_t req; + int ret = -1; + int proglen = 0; + char new_iobref = 0; + uint64_t callid = 0; + gf_boolean_t need_unref = _gf_false; + call_frame_t *cframe = frame; + + if (!rpc || !prog || !frame) { + goto out; + } + + conn = &rpc->conn; + + rpcreq = mem_get(rpc->reqpool); + if (rpcreq == NULL) { + goto out; + } + + memset(rpcreq, 0, sizeof(*rpcreq)); + memset(&req, 0, sizeof(req)); + + if (!iobref) { + iobref = iobref_new(); if (!iobref) { - iobref = iobref_new (); - if (!iobref) { - goto out; - } - - new_iobref = 1; - } - - callid = GF_ATOMIC_INC (rpc->xid); - - rpcreq->prog = prog; - rpcreq->procnum = procnum; - rpcreq->conn = conn; - rpcreq->xid = callid; - rpcreq->cbkfn = cbkfn; - - ret = -1; - - if (proghdr) { - proglen += iov_length (proghdr, proghdrcount); + goto out; + } + + new_iobref = 1; + } + + callid = GF_ATOMIC_INC(rpc->xid); + + rpcreq->prog = prog; + rpcreq->procnum = procnum; + rpcreq->conn = conn; + rpcreq->xid = callid; + rpcreq->cbkfn = cbkfn; + + ret = -1; + + if (proghdr) { + proglen += iov_length(proghdr, proghdrcount); + } + + request_iob = rpc_clnt_record(rpc, frame, prog, procnum, proglen, &rpchdr, + callid); + if (!request_iob) { + gf_log(conn->name, GF_LOG_WARNING, "cannot build rpc-record"); + goto out; + } + + iobref_add(iobref, request_iob); + + req.msg.rpchdr = &rpchdr; + req.msg.rpchdrcount = 1; + req.msg.proghdr = proghdr; + req.msg.proghdrcount = proghdrcount; + req.msg.progpayload = progpayload; + req.msg.progpayloadcount = progpayloadcount; + req.msg.iobref = iobref; + + req.rsp.rsphdr = rsphdr; + req.rsp.rsphdr_count = rsphdr_count; + req.rsp.rsp_payload = rsp_payload; + req.rsp.rsp_payload_count = rsp_payload_count; + req.rsp.rsp_iobref = rsp_iobref; + req.rpc_req = rpcreq; + + pthread_mutex_lock(&conn->lock); + { + if (conn->connected == 0 && !rpc->disabled) { + ret = rpc_transport_connect(conn->trans, conn->config.remote_port); + if (ret < 0) { + gf_log(conn->name, GF_LOG_WARNING, + "error returned while attempting to " + "connect to host:%s, port:%d", + conn->config.remote_host, conn->config.remote_port); + } } - request_iob = rpc_clnt_record (rpc, frame, prog, - procnum, proglen, - &rpchdr, callid); - if (!request_iob) { - gf_log (conn->name, GF_LOG_WARNING, - "cannot build rpc-record"); - goto out; + ret = rpc_transport_submit_request(conn->trans, &req); + if (ret == -1) { + gf_log(conn->name, GF_LOG_WARNING, + "failed to submit rpc-request " + "(unique: %" PRIu64 + ", XID: 0x%x Program: %s, " + "ProgVers: %d, Proc: %d) to rpc-transport (%s)", + cframe->root->unique, rpcreq->xid, rpcreq->prog->progname, + rpcreq->prog->progver, rpcreq->procnum, conn->name); } - iobref_add (iobref, request_iob); - - req.msg.rpchdr = &rpchdr; - req.msg.rpchdrcount = 1; - req.msg.proghdr = proghdr; - req.msg.proghdrcount = proghdrcount; - req.msg.progpayload = progpayload; - req.msg.progpayloadcount = progpayloadcount; - req.msg.iobref = iobref; + if ((ret >= 0) && frame) { + /* Save the frame in queue */ + __save_frame(rpc, frame, rpcreq); - req.rsp.rsphdr = rsphdr; - req.rsp.rsphdr_count = rsphdr_count; - req.rsp.rsp_payload = rsp_payload; - req.rsp.rsp_payload_count = rsp_payload_count; - req.rsp.rsp_iobref = rsp_iobref; - req.rpc_req = rpcreq; - - pthread_mutex_lock (&conn->lock); - { - if (conn->connected == 0 && !rpc->disabled) { - ret = rpc_transport_connect (conn->trans, - conn->config.remote_port); - if (ret < 0) { - gf_log (conn->name, GF_LOG_WARNING, - "error returned while attempting to " - "connect to host:%s, port:%d", - conn->config.remote_host, - conn->config.remote_port); - } - } + /* A ref on rpc-clnt object is taken while registering + * call_bail to timer in __save_frame. If it fails to + * register, it needs an unref and should happen outside + * conn->lock which otherwise leads to deadlocks */ + if (conn->timer == NULL) + need_unref = _gf_true; - ret = rpc_transport_submit_request (conn->trans, &req); - if (ret == -1) { - gf_log (conn->name, GF_LOG_WARNING, - "failed to submit rpc-request " - "(unique: %"PRIu64", XID: 0x%x Program: %s, " - "ProgVers: %d, Proc: %d) to rpc-transport (%s)", - cframe->root->unique, rpcreq->xid, - rpcreq->prog->progname, rpcreq->prog->progver, - rpcreq->procnum, conn->name); - } + conn->msgcnt++; - if ((ret >= 0) && frame) { - /* Save the frame in queue */ - __save_frame (rpc, frame, rpcreq); - - /* A ref on rpc-clnt object is taken while registering - * call_bail to timer in __save_frame. If it fails to - * register, it needs an unref and should happen outside - * conn->lock which otherwise leads to deadlocks */ - if (conn->timer == NULL) - need_unref = _gf_true; - - conn->msgcnt++; - - gf_log ("rpc-clnt", GF_LOG_TRACE, "submitted request " - "(unique: %"PRIu64", XID: 0x%x, Program: %s, " - "ProgVers: %d, Proc: %d) to rpc-transport (%s)", - cframe->root->unique, rpcreq->xid, - rpcreq->prog->progname, rpcreq->prog->progver, - rpcreq->procnum, conn->name); - } + gf_log("rpc-clnt", GF_LOG_TRACE, + "submitted request " + "(unique: %" PRIu64 + ", XID: 0x%x, Program: %s, " + "ProgVers: %d, Proc: %d) to rpc-transport (%s)", + cframe->root->unique, rpcreq->xid, rpcreq->prog->progname, + rpcreq->prog->progver, rpcreq->procnum, conn->name); } - pthread_mutex_unlock (&conn->lock); + } + pthread_mutex_unlock(&conn->lock); - if (need_unref) - rpc_clnt_unref (rpc); + if (need_unref) + rpc_clnt_unref(rpc); - if (ret == -1) { - goto out; - } + if (ret == -1) { + goto out; + } - rpc_clnt_check_and_start_ping (rpc); - ret = 0; + rpc_clnt_check_and_start_ping(rpc); + ret = 0; out: - if (request_iob) { - iobuf_unref (request_iob); - } - - if (new_iobref && iobref) { - iobref_unref (iobref); - } - - if (frame && (ret == -1)) { - if (rpcreq) { - rpcreq->rpc_status = -1; - cbkfn (rpcreq, NULL, 0, frame); - mem_put (rpcreq); - } - } - return ret; + if (request_iob) { + iobuf_unref(request_iob); + } + + if (new_iobref && iobref) { + iobref_unref(iobref); + } + + if (frame && (ret == -1)) { + if (rpcreq) { + rpcreq->rpc_status = -1; + cbkfn(rpcreq, NULL, 0, frame); + mem_put(rpcreq); + } + } + return ret; } - struct rpc_clnt * -rpc_clnt_ref (struct rpc_clnt *rpc) +rpc_clnt_ref(struct rpc_clnt *rpc) { - if (!rpc) - return NULL; + if (!rpc) + return NULL; - GF_ATOMIC_INC (rpc->refcount); - return rpc; + GF_ATOMIC_INC(rpc->refcount); + return rpc; } - static void -rpc_clnt_trigger_destroy (struct rpc_clnt *rpc) +rpc_clnt_trigger_destroy(struct rpc_clnt *rpc) { - rpc_clnt_connection_t *conn = NULL; - rpc_transport_t *trans = NULL; - - if (!rpc) - return; + rpc_clnt_connection_t *conn = NULL; + rpc_transport_t *trans = NULL; - /* reading conn->trans outside conn->lock is OK, since this is the last - * ref*/ - conn = &rpc->conn; - trans = conn->trans; - rpc_clnt_disconnect (rpc); + if (!rpc) + return; - /* This is to account for rpc_clnt_disable that might have been called - * before rpc_clnt_unref */ - if (trans) { - /* set conn->trans to NULL before rpc_transport_unref - * as rpc_transport_unref can potentially free conn - */ - conn->trans = NULL; - rpc_transport_unref (trans); - } + /* reading conn->trans outside conn->lock is OK, since this is the last + * ref*/ + conn = &rpc->conn; + trans = conn->trans; + rpc_clnt_disconnect(rpc); + + /* This is to account for rpc_clnt_disable that might have been called + * before rpc_clnt_unref */ + if (trans) { + /* set conn->trans to NULL before rpc_transport_unref + * as rpc_transport_unref can potentially free conn + */ + conn->trans = NULL; + rpc_transport_unref(trans); + } } static void -rpc_clnt_destroy (struct rpc_clnt *rpc) +rpc_clnt_destroy(struct rpc_clnt *rpc) { - rpcclnt_cb_program_t *program = NULL; - rpcclnt_cb_program_t *tmp = NULL; - struct saved_frames *saved_frames = NULL; - rpc_clnt_connection_t *conn = NULL; - - if (!rpc) - return; - - conn = &rpc->conn; - GF_FREE (rpc->conn.name); - /* Access saved_frames in critical-section to avoid - crash in rpc_clnt_connection_cleanup at the time - of destroying saved frames - */ - pthread_mutex_lock (&conn->lock); - { - saved_frames = conn->saved_frames; - conn->saved_frames = NULL; - } - pthread_mutex_unlock (&conn->lock); + rpcclnt_cb_program_t *program = NULL; + rpcclnt_cb_program_t *tmp = NULL; + struct saved_frames *saved_frames = NULL; + rpc_clnt_connection_t *conn = NULL; - saved_frames_destroy (saved_frames); - pthread_mutex_destroy (&rpc->lock); - pthread_mutex_destroy (&rpc->conn.lock); - - /* mem-pool should be destroyed, otherwise, - it will cause huge memory leaks */ - mem_pool_destroy (rpc->reqpool); - mem_pool_destroy (rpc->saved_frames_pool); - - list_for_each_entry_safe (program, tmp, &rpc->programs, program) { - GF_FREE (program); - } - - GF_FREE (rpc); + if (!rpc) return; + + conn = &rpc->conn; + GF_FREE(rpc->conn.name); + /* Access saved_frames in critical-section to avoid + crash in rpc_clnt_connection_cleanup at the time + of destroying saved frames + */ + pthread_mutex_lock(&conn->lock); + { + saved_frames = conn->saved_frames; + conn->saved_frames = NULL; + } + pthread_mutex_unlock(&conn->lock); + + saved_frames_destroy(saved_frames); + pthread_mutex_destroy(&rpc->lock); + pthread_mutex_destroy(&rpc->conn.lock); + + /* mem-pool should be destroyed, otherwise, + it will cause huge memory leaks */ + mem_pool_destroy(rpc->reqpool); + mem_pool_destroy(rpc->saved_frames_pool); + + list_for_each_entry_safe(program, tmp, &rpc->programs, program) + { + GF_FREE(program); + } + + GF_FREE(rpc); + return; } struct rpc_clnt * -rpc_clnt_unref (struct rpc_clnt *rpc) +rpc_clnt_unref(struct rpc_clnt *rpc) { - int count = 0; + int count = 0; - if (!rpc) - return NULL; + if (!rpc) + return NULL; - count = GF_ATOMIC_DEC (rpc->refcount); + count = GF_ATOMIC_DEC(rpc->refcount); - if (!count) { - rpc_clnt_trigger_destroy (rpc); - return NULL; - } - return rpc; + if (!count) { + rpc_clnt_trigger_destroy(rpc); + return NULL; + } + return rpc; } - char -rpc_clnt_is_disabled (struct rpc_clnt *rpc) +rpc_clnt_is_disabled(struct rpc_clnt *rpc) { + rpc_clnt_connection_t *conn = NULL; + char disabled = 0; - rpc_clnt_connection_t *conn = NULL; - char disabled = 0; + if (!rpc) { + goto out; + } - if (!rpc) { - goto out; - } + conn = &rpc->conn; - conn = &rpc->conn; - - pthread_mutex_lock (&conn->lock); - { - disabled = rpc->disabled; - } - pthread_mutex_unlock (&conn->lock); + pthread_mutex_lock(&conn->lock); + { + disabled = rpc->disabled; + } + pthread_mutex_unlock(&conn->lock); out: - return disabled; + return disabled; } void -rpc_clnt_disable (struct rpc_clnt *rpc) +rpc_clnt_disable(struct rpc_clnt *rpc) { - rpc_clnt_connection_t *conn = NULL; - rpc_transport_t *trans = NULL; - int unref = 0; - int ret = 0; - gf_boolean_t timer_unref = _gf_false; - gf_boolean_t reconnect_unref = _gf_false; - - if (!rpc) { - goto out; - } - - conn = &rpc->conn; - - pthread_mutex_lock (&conn->lock); - { - rpc->disabled = 1; - - if (conn->timer) { - ret = gf_timer_call_cancel (rpc->ctx, conn->timer); - /* If the event is not fired and it actually cancelled - * the timer, do the unref else registered call back - * function will take care of it. - */ - if (!ret) - timer_unref = _gf_true; - conn->timer = NULL; - } - - if (conn->reconnect) { - ret = gf_timer_call_cancel (rpc->ctx, conn->reconnect); - if (!ret) - reconnect_unref = _gf_true; - conn->reconnect = NULL; - } - conn->connected = 0; - - unref = rpc_clnt_remove_ping_timer_locked (rpc); - trans = conn->trans; - - } - pthread_mutex_unlock (&conn->lock); - - if (trans) { - rpc_transport_disconnect (trans, _gf_true); - /* The auth_value was being reset to AUTH_GLUSTERFS_v2. - * if (clnt->auth_value) - * clnt->auth_value = AUTH_GLUSTERFS_v2; - * It should not be reset here. The disconnect during - * portmap request can race with handshake. If handshake - * happens first and disconnect later, auth_value would set - * to default value and it never sets back to actual auth_value - * supported by server. But it's important to set to lower - * version supported in the case where the server downgrades. - * So moving this code to RPC_TRANSPORT_CONNECT. Note that - * CONNECT cannot race with handshake as by nature it is - * serialized with handhake. An handshake can happen only - * on a connected transport and hence its strictly serialized. - */ - } + rpc_clnt_connection_t *conn = NULL; + rpc_transport_t *trans = NULL; + int unref = 0; + int ret = 0; + gf_boolean_t timer_unref = _gf_false; + gf_boolean_t reconnect_unref = _gf_false; + + if (!rpc) { + goto out; + } + + conn = &rpc->conn; + + pthread_mutex_lock(&conn->lock); + { + rpc->disabled = 1; + + if (conn->timer) { + ret = gf_timer_call_cancel(rpc->ctx, conn->timer); + /* If the event is not fired and it actually cancelled + * the timer, do the unref else registered call back + * function will take care of it. + */ + if (!ret) + timer_unref = _gf_true; + conn->timer = NULL; + } + + if (conn->reconnect) { + ret = gf_timer_call_cancel(rpc->ctx, conn->reconnect); + if (!ret) + reconnect_unref = _gf_true; + conn->reconnect = NULL; + } + conn->connected = 0; + + unref = rpc_clnt_remove_ping_timer_locked(rpc); + trans = conn->trans; + } + pthread_mutex_unlock(&conn->lock); + + if (trans) { + rpc_transport_disconnect(trans, _gf_true); + /* The auth_value was being reset to AUTH_GLUSTERFS_v2. + * if (clnt->auth_value) + * clnt->auth_value = AUTH_GLUSTERFS_v2; + * It should not be reset here. The disconnect during + * portmap request can race with handshake. If handshake + * happens first and disconnect later, auth_value would set + * to default value and it never sets back to actual auth_value + * supported by server. But it's important to set to lower + * version supported in the case where the server downgrades. + * So moving this code to RPC_TRANSPORT_CONNECT. Note that + * CONNECT cannot race with handshake as by nature it is + * serialized with handhake. An handshake can happen only + * on a connected transport and hence its strictly serialized. + */ + } - if (unref) - rpc_clnt_unref (rpc); + if (unref) + rpc_clnt_unref(rpc); - if (timer_unref) - rpc_clnt_unref (rpc); + if (timer_unref) + rpc_clnt_unref(rpc); - if (reconnect_unref) - rpc_clnt_unref (rpc); + if (reconnect_unref) + rpc_clnt_unref(rpc); out: - return; + return; } void -rpc_clnt_disconnect (struct rpc_clnt *rpc) +rpc_clnt_disconnect(struct rpc_clnt *rpc) { - rpc_clnt_connection_t *conn = NULL; - rpc_transport_t *trans = NULL; - int unref = 0; - int ret = 0; - gf_boolean_t timer_unref = _gf_false; - gf_boolean_t reconnect_unref = _gf_false; - - if (!rpc) - goto out; - - conn = &rpc->conn; - - pthread_mutex_lock (&conn->lock); - { - rpc->disabled = 1; - if (conn->timer) { - ret = gf_timer_call_cancel (rpc->ctx, conn->timer); - /* If the event is not fired and it actually cancelled - * the timer, do the unref else registered call back - * function will take care of unref. - */ - if (!ret) - timer_unref = _gf_true; - conn->timer = NULL; - } - - if (conn->reconnect) { - ret = gf_timer_call_cancel (rpc->ctx, conn->reconnect); - if (!ret) - reconnect_unref = _gf_true; - conn->reconnect = NULL; - } - conn->connected = 0; - - unref = rpc_clnt_remove_ping_timer_locked (rpc); - trans = conn->trans; - } - pthread_mutex_unlock (&conn->lock); - - if (trans) { - rpc_transport_disconnect (trans, _gf_true); - /* The auth_value was being reset to AUTH_GLUSTERFS_v2. - * if (clnt->auth_value) - * clnt->auth_value = AUTH_GLUSTERFS_v2; - * It should not be reset here. The disconnect during - * portmap request can race with handshake. If handshake - * happens first and disconnect later, auth_value would set - * to default value and it never sets back to actual auth_value - * supported by server. But it's important to set to lower - * version supported in the case where the server downgrades. - * So moving this code to RPC_TRANSPORT_CONNECT. Note that - * CONNECT cannot race with handshake as by nature it is - * serialized with handhake. An handshake can happen only - * on a connected transport and hence its strictly serialized. - */ - } - if (unref) - rpc_clnt_unref (rpc); + rpc_clnt_connection_t *conn = NULL; + rpc_transport_t *trans = NULL; + int unref = 0; + int ret = 0; + gf_boolean_t timer_unref = _gf_false; + gf_boolean_t reconnect_unref = _gf_false; + + if (!rpc) + goto out; + + conn = &rpc->conn; + + pthread_mutex_lock(&conn->lock); + { + rpc->disabled = 1; + if (conn->timer) { + ret = gf_timer_call_cancel(rpc->ctx, conn->timer); + /* If the event is not fired and it actually cancelled + * the timer, do the unref else registered call back + * function will take care of unref. + */ + if (!ret) + timer_unref = _gf_true; + conn->timer = NULL; + } + + if (conn->reconnect) { + ret = gf_timer_call_cancel(rpc->ctx, conn->reconnect); + if (!ret) + reconnect_unref = _gf_true; + conn->reconnect = NULL; + } + conn->connected = 0; + + unref = rpc_clnt_remove_ping_timer_locked(rpc); + trans = conn->trans; + } + pthread_mutex_unlock(&conn->lock); + + if (trans) { + rpc_transport_disconnect(trans, _gf_true); + /* The auth_value was being reset to AUTH_GLUSTERFS_v2. + * if (clnt->auth_value) + * clnt->auth_value = AUTH_GLUSTERFS_v2; + * It should not be reset here. The disconnect during + * portmap request can race with handshake. If handshake + * happens first and disconnect later, auth_value would set + * to default value and it never sets back to actual auth_value + * supported by server. But it's important to set to lower + * version supported in the case where the server downgrades. + * So moving this code to RPC_TRANSPORT_CONNECT. Note that + * CONNECT cannot race with handshake as by nature it is + * serialized with handhake. An handshake can happen only + * on a connected transport and hence its strictly serialized. + */ + } + if (unref) + rpc_clnt_unref(rpc); - if (timer_unref) - rpc_clnt_unref (rpc); + if (timer_unref) + rpc_clnt_unref(rpc); - if (reconnect_unref) - rpc_clnt_unref (rpc); + if (reconnect_unref) + rpc_clnt_unref(rpc); out: - return; + return; } - void -rpc_clnt_reconfig (struct rpc_clnt *rpc, struct rpc_clnt_config *config) +rpc_clnt_reconfig(struct rpc_clnt *rpc, struct rpc_clnt_config *config) { - if (config->ping_timeout) { - if (config->ping_timeout != rpc->conn.ping_timeout) - gf_log (rpc->conn.name, GF_LOG_INFO, - "changing ping timeout to %d (from %d)", - config->ping_timeout, - rpc->conn.ping_timeout); - - pthread_mutex_lock (&rpc->conn.lock); - { - rpc->conn.ping_timeout = config->ping_timeout; - } - pthread_mutex_unlock (&rpc->conn.lock); - - } - - if (config->rpc_timeout) { - if (config->rpc_timeout != rpc->conn.config.rpc_timeout) - gf_log (rpc->conn.name, GF_LOG_INFO, - "changing timeout to %d (from %d)", - config->rpc_timeout, - rpc->conn.config.rpc_timeout); - rpc->conn.config.rpc_timeout = config->rpc_timeout; - } - - if (config->remote_port) { - if (config->remote_port != rpc->conn.config.remote_port) - gf_log (rpc->conn.name, GF_LOG_INFO, - "changing port to %d (from %d)", - config->remote_port, - rpc->conn.config.remote_port); + if (config->ping_timeout) { + if (config->ping_timeout != rpc->conn.ping_timeout) + gf_log(rpc->conn.name, GF_LOG_INFO, + "changing ping timeout to %d (from %d)", + config->ping_timeout, rpc->conn.ping_timeout); - rpc->conn.config.remote_port = config->remote_port; + pthread_mutex_lock(&rpc->conn.lock); + { + rpc->conn.ping_timeout = config->ping_timeout; + } + pthread_mutex_unlock(&rpc->conn.lock); + } + + if (config->rpc_timeout) { + if (config->rpc_timeout != rpc->conn.config.rpc_timeout) + gf_log(rpc->conn.name, GF_LOG_INFO, + "changing timeout to %d (from %d)", config->rpc_timeout, + rpc->conn.config.rpc_timeout); + rpc->conn.config.rpc_timeout = config->rpc_timeout; + } + + if (config->remote_port) { + if (config->remote_port != rpc->conn.config.remote_port) + gf_log(rpc->conn.name, GF_LOG_INFO, "changing port to %d (from %d)", + config->remote_port, rpc->conn.config.remote_port); + + rpc->conn.config.remote_port = config->remote_port; + } + + if (config->remote_host) { + if (rpc->conn.config.remote_host) { + if (strcmp(rpc->conn.config.remote_host, config->remote_host)) + gf_log(rpc->conn.name, GF_LOG_INFO, + "changing hostname to %s (from %s)", config->remote_host, + rpc->conn.config.remote_host); + GF_FREE(rpc->conn.config.remote_host); + } else { + gf_log(rpc->conn.name, GF_LOG_INFO, "setting hostname to %s", + config->remote_host); } - if (config->remote_host) { - if (rpc->conn.config.remote_host) { - if (strcmp (rpc->conn.config.remote_host, - config->remote_host)) - gf_log (rpc->conn.name, GF_LOG_INFO, - "changing hostname to %s (from %s)", - config->remote_host, - rpc->conn.config.remote_host); - GF_FREE (rpc->conn.config.remote_host); - } else { - gf_log (rpc->conn.name, GF_LOG_INFO, - "setting hostname to %s", - config->remote_host); - } - - rpc->conn.config.remote_host = gf_strdup (config->remote_host); - } + rpc->conn.config.remote_host = gf_strdup(config->remote_host); + } } diff --git a/rpc/rpc-lib/src/rpc-drc.c b/rpc/rpc-lib/src/rpc-drc.c index fb7d2f13605..ff983b23fb4 100644 --- a/rpc/rpc-lib/src/rpc-drc.c +++ b/rpc/rpc-lib/src/rpc-drc.c @@ -29,29 +29,29 @@ * @return NULL if reply is destroyed, reply otherwise */ static drc_cached_op_t * -rpcsvc_drc_op_destroy (rpcsvc_drc_globals_t *drc, drc_cached_op_t *reply) +rpcsvc_drc_op_destroy(rpcsvc_drc_globals_t *drc, drc_cached_op_t *reply) { - GF_ASSERT (drc); - GF_ASSERT (reply); - - if (reply->state == DRC_OP_IN_TRANSIT) - return reply; - - iobref_unref (reply->msg.iobref); - if (reply->msg.rpchdr) - GF_FREE (reply->msg.rpchdr); - if (reply->msg.proghdr) - GF_FREE (reply->msg.proghdr); - if (reply->msg.progpayload) - GF_FREE (reply->msg.progpayload); - - list_del (&reply->global_list); - reply->client->op_count--; - drc->op_count--; - mem_put (reply); - reply = NULL; + GF_ASSERT(drc); + GF_ASSERT(reply); + if (reply->state == DRC_OP_IN_TRANSIT) return reply; + + iobref_unref(reply->msg.iobref); + if (reply->msg.rpchdr) + GF_FREE(reply->msg.rpchdr); + if (reply->msg.proghdr) + GF_FREE(reply->msg.proghdr); + if (reply->msg.progpayload) + GF_FREE(reply->msg.progpayload); + + list_del(&reply->global_list); + reply->client->op_count--; + drc->op_count--; + mem_put(reply); + reply = NULL; + + return reply; } /** @@ -62,9 +62,9 @@ rpcsvc_drc_op_destroy (rpcsvc_drc_globals_t *drc, drc_cached_op_t *reply) * @return void */ static void -rpcsvc_drc_rb_op_destroy (void *reply, void *drc) +rpcsvc_drc_rb_op_destroy(void *reply, void *drc) { - rpcsvc_drc_op_destroy (drc, (drc_cached_op_t *)reply); + rpcsvc_drc_op_destroy(drc, (drc_cached_op_t *)reply); } /** @@ -74,11 +74,11 @@ rpcsvc_drc_rb_op_destroy (void *reply, void *drc) * @return void */ static void -rpcsvc_remove_drc_client (drc_client_t *client) +rpcsvc_remove_drc_client(drc_client_t *client) { - rb_destroy (client->rbtree, rpcsvc_drc_rb_op_destroy); - list_del (&client->client_list); - GF_FREE (client); + rb_destroy(client->rbtree, rpcsvc_drc_rb_op_destroy); + list_del(&client->client_list); + GF_FREE(client); } /** @@ -89,24 +89,25 @@ rpcsvc_remove_drc_client (drc_client_t *client) * @return drc client if it exists, NULL otherwise */ static drc_client_t * -rpcsvc_client_lookup (rpcsvc_drc_globals_t *drc, - struct sockaddr_storage *sockaddr) +rpcsvc_client_lookup(rpcsvc_drc_globals_t *drc, + struct sockaddr_storage *sockaddr) { - drc_client_t *client = NULL; + drc_client_t *client = NULL; - GF_ASSERT (drc); - GF_ASSERT (sockaddr); + GF_ASSERT(drc); + GF_ASSERT(sockaddr); - if (list_empty (&drc->clients_head)) - return NULL; + if (list_empty(&drc->clients_head)) + return NULL; - list_for_each_entry (client, &drc->clients_head, client_list) { - if (gf_sock_union_equal_addr (&client->sock_union, - (union gf_sock_union *)sockaddr)) - return client; - } + list_for_each_entry(client, &drc->clients_head, client_list) + { + if (gf_sock_union_equal_addr(&client->sock_union, + (union gf_sock_union *)sockaddr)) + return client; + } - return NULL; + return NULL; } /** @@ -119,29 +120,28 @@ rpcsvc_client_lookup (rpcsvc_drc_globals_t *drc, * @return 0 if req matches reply, else (req->xid - reply->xid) */ int -drc_compare_reqs (const void *item, const void *rb_node_data, void *param) +drc_compare_reqs(const void *item, const void *rb_node_data, void *param) { - int ret = -1; - drc_cached_op_t *req = NULL; - drc_cached_op_t *reply = NULL; + int ret = -1; + drc_cached_op_t *req = NULL; + drc_cached_op_t *reply = NULL; - GF_ASSERT (item); - GF_ASSERT (rb_node_data); - GF_ASSERT (param); + GF_ASSERT(item); + GF_ASSERT(rb_node_data); + GF_ASSERT(param); - req = (drc_cached_op_t *)item; - reply = (drc_cached_op_t *)rb_node_data; + req = (drc_cached_op_t *)item; + reply = (drc_cached_op_t *)rb_node_data; - ret = req->xid - reply->xid; - if (ret != 0) - return ret; + ret = req->xid - reply->xid; + if (ret != 0) + return ret; - if (req->prognum == reply->prognum && - req->procnum == reply->procnum && - req->progversion == reply->progversion) - return 0; + if (req->prognum == reply->prognum && req->procnum == reply->procnum && + req->progversion == reply->progversion) + return 0; - return 1; + return 1; } /** @@ -152,18 +152,18 @@ drc_compare_reqs (const void *item, const void *rb_node_data, void *param) * @return 0 on success, -1 on failure */ static int -drc_init_client_cache (rpcsvc_drc_globals_t *drc, drc_client_t *client) +drc_init_client_cache(rpcsvc_drc_globals_t *drc, drc_client_t *client) { - GF_ASSERT (drc); - GF_ASSERT (client); + GF_ASSERT(drc); + GF_ASSERT(client); - client->rbtree = rb_create (drc_compare_reqs, drc, NULL); - if (!client->rbtree) { - gf_log (GF_RPCSVC, GF_LOG_DEBUG, "rb tree creation failed"); - return -1; - } + client->rbtree = rb_create(drc_compare_reqs, drc, NULL); + if (!client->rbtree) { + gf_log(GF_RPCSVC, GF_LOG_DEBUG, "rb tree creation failed"); + return -1; + } - return 0; + return 0; } /** @@ -175,42 +175,40 @@ drc_init_client_cache (rpcsvc_drc_globals_t *drc, drc_client_t *client) * @return drc client on success, NULL on failure */ static drc_client_t * -rpcsvc_get_drc_client (rpcsvc_drc_globals_t *drc, - struct sockaddr_storage *sockaddr) +rpcsvc_get_drc_client(rpcsvc_drc_globals_t *drc, + struct sockaddr_storage *sockaddr) { - drc_client_t *client = NULL; + drc_client_t *client = NULL; - GF_ASSERT (drc); - GF_ASSERT (sockaddr); + GF_ASSERT(drc); + GF_ASSERT(sockaddr); - client = rpcsvc_client_lookup (drc, sockaddr); - if (client) - goto out; + client = rpcsvc_client_lookup(drc, sockaddr); + if (client) + goto out; - /* if lookup fails, allocate cache for the new client */ - client = GF_CALLOC (1, sizeof (drc_client_t), - gf_common_mt_drc_client_t); - if (!client) - goto out; - - client->ref = 0; - client->sock_union = (union gf_sock_union)*sockaddr; - client->op_count = 0; - INIT_LIST_HEAD (&client->client_list); - - if (drc_init_client_cache (drc, client)) { - gf_log (GF_RPCSVC, GF_LOG_DEBUG, - "initialization of drc client failed"); - GF_FREE (client); - client = NULL; - goto out; - } - drc->client_count++; + /* if lookup fails, allocate cache for the new client */ + client = GF_CALLOC(1, sizeof(drc_client_t), gf_common_mt_drc_client_t); + if (!client) + goto out; + + client->ref = 0; + client->sock_union = (union gf_sock_union) * sockaddr; + client->op_count = 0; + INIT_LIST_HEAD(&client->client_list); + + if (drc_init_client_cache(drc, client)) { + gf_log(GF_RPCSVC, GF_LOG_DEBUG, "initialization of drc client failed"); + GF_FREE(client); + client = NULL; + goto out; + } + drc->client_count++; - list_add (&client->client_list, &drc->clients_head); + list_add(&client->client_list, &drc->clients_head); - out: - return client; +out: + return client; } /** @@ -220,25 +218,24 @@ rpcsvc_get_drc_client (rpcsvc_drc_globals_t *drc, * @return 1 if DRC is needed for req, 0 otherwise */ int -rpcsvc_need_drc (rpcsvc_request_t *req) +rpcsvc_need_drc(rpcsvc_request_t *req) { - rpcsvc_actor_t *actor = NULL; - rpcsvc_drc_globals_t *drc = NULL; + rpcsvc_actor_t *actor = NULL; + rpcsvc_drc_globals_t *drc = NULL; - GF_ASSERT (req); - GF_ASSERT (req->svc); + GF_ASSERT(req); + GF_ASSERT(req->svc); - drc = req->svc->drc; + drc = req->svc->drc; - if (!drc || drc->status == DRC_UNINITIATED) - return 0; + if (!drc || drc->status == DRC_UNINITIATED) + return 0; - actor = rpcsvc_program_actor (req); - if (!actor) - return 0; + actor = rpcsvc_program_actor(req); + if (!actor) + return 0; - return (actor->op_type == DRC_NON_IDEMPOTENT - && drc->type != DRC_TYPE_NONE); + return (actor->op_type == DRC_NON_IDEMPOTENT && drc->type != DRC_TYPE_NONE); } /** @@ -248,11 +245,11 @@ rpcsvc_need_drc (rpcsvc_request_t *req) * @return client */ static drc_client_t * -rpcsvc_drc_client_ref (drc_client_t *client) +rpcsvc_drc_client_ref(drc_client_t *client) { - GF_ASSERT (client); - client->ref++; - return client; + GF_ASSERT(client); + client->ref++; + return client; } /** @@ -264,19 +261,19 @@ rpcsvc_drc_client_ref (drc_client_t *client) * @return NULL if it is the last unref, client otherwise */ static drc_client_t * -rpcsvc_drc_client_unref (rpcsvc_drc_globals_t *drc, drc_client_t *client) +rpcsvc_drc_client_unref(rpcsvc_drc_globals_t *drc, drc_client_t *client) { - GF_ASSERT (drc); - GF_ASSERT (client->ref); - - client->ref--; - if (!client->ref) { - drc->client_count--; - rpcsvc_remove_drc_client (client); - client = NULL; - } + GF_ASSERT(drc); + GF_ASSERT(client->ref); - return client; + client->ref--; + if (!client->ref) { + drc->client_count--; + rpcsvc_remove_drc_client(client); + client = NULL; + } + + return client; } /** @@ -286,38 +283,37 @@ rpcsvc_drc_client_unref (rpcsvc_drc_globals_t *drc, drc_client_t *client) * @return cached reply of req if found, NULL otherwise */ drc_cached_op_t * -rpcsvc_drc_lookup (rpcsvc_request_t *req) +rpcsvc_drc_lookup(rpcsvc_request_t *req) { - drc_client_t *client = NULL; - drc_cached_op_t *reply = NULL; - drc_cached_op_t new = { - .xid = req->xid, - .prognum = req->prognum, - .progversion = req->progver, - .procnum = req->procnum, - }; - - GF_ASSERT (req); - - if (!req->trans->drc_client) { - client = rpcsvc_get_drc_client (req->svc->drc, - &req->trans->peerinfo.sockaddr); - if (!client) - goto out; - - req->trans->drc_client - = rpcsvc_drc_client_ref (client); - } + drc_client_t *client = NULL; + drc_cached_op_t *reply = NULL; + drc_cached_op_t new = { + .xid = req->xid, + .prognum = req->prognum, + .progversion = req->progver, + .procnum = req->procnum, + }; + + GF_ASSERT(req); + + if (!req->trans->drc_client) { + client = rpcsvc_get_drc_client(req->svc->drc, + &req->trans->peerinfo.sockaddr); + if (!client) + goto out; - client = req->trans->drc_client; + req->trans->drc_client = rpcsvc_drc_client_ref(client); + } - if (client->op_count == 0) - goto out; + client = req->trans->drc_client; - reply = rb_find (client->rbtree, &new); + if (client->op_count == 0) + goto out; - out: - return reply; + reply = rb_find(client->rbtree, &new); + +out: + return reply; } /** @@ -325,28 +321,30 @@ rpcsvc_drc_lookup (rpcsvc_request_t *req) * * @param req - incoming request (which is a duplicate in this case) * @param reply - the cached reply for req - * @return 0 on successful reply submission, -1 or other non-zero value otherwise + * @return 0 on successful reply submission, -1 or other non-zero value + * otherwise */ int -rpcsvc_send_cached_reply (rpcsvc_request_t *req, drc_cached_op_t *reply) +rpcsvc_send_cached_reply(rpcsvc_request_t *req, drc_cached_op_t *reply) { - int ret = 0; + int ret = 0; - GF_ASSERT (req); - GF_ASSERT (reply); + GF_ASSERT(req); + GF_ASSERT(reply); - gf_log (GF_RPCSVC, GF_LOG_DEBUG, "sending cached reply: xid: %d, " - "client: %s", req->xid, req->trans->peerinfo.identifier); + gf_log(GF_RPCSVC, GF_LOG_DEBUG, + "sending cached reply: xid: %d, " + "client: %s", + req->xid, req->trans->peerinfo.identifier); - rpcsvc_drc_client_ref (reply->client); - ret = rpcsvc_transport_submit (req->trans, - reply->msg.rpchdr, reply->msg.rpchdrcount, - reply->msg.proghdr, reply->msg.proghdrcount, - reply->msg.progpayload, reply->msg.progpayloadcount, - reply->msg.iobref, req->trans_private); - rpcsvc_drc_client_unref (req->svc->drc, reply->client); + rpcsvc_drc_client_ref(reply->client); + ret = rpcsvc_transport_submit( + req->trans, reply->msg.rpchdr, reply->msg.rpchdrcount, + reply->msg.proghdr, reply->msg.proghdrcount, reply->msg.progpayload, + reply->msg.progpayloadcount, reply->msg.iobref, req->trans_private); + rpcsvc_drc_client_unref(req->svc->drc, reply->client); - return ret; + return ret; } /** @@ -363,38 +361,37 @@ rpcsvc_send_cached_reply (rpcsvc_request_t *req, drc_cached_op_t *reply) * @return 0 on success, -1 on failure */ int -rpcsvc_cache_reply (rpcsvc_request_t *req, struct iobref *iobref, - struct iovec *rpchdr, int rpchdrcount, - struct iovec *proghdr, int proghdrcount, - struct iovec *payload, int payloadcount) +rpcsvc_cache_reply(rpcsvc_request_t *req, struct iobref *iobref, + struct iovec *rpchdr, int rpchdrcount, struct iovec *proghdr, + int proghdrcount, struct iovec *payload, int payloadcount) { - int ret = -1; - drc_cached_op_t *reply = NULL; + int ret = -1; + drc_cached_op_t *reply = NULL; - GF_ASSERT (req); - GF_ASSERT (req->reply); + GF_ASSERT(req); + GF_ASSERT(req->reply); - reply = req->reply; + reply = req->reply; - reply->state = DRC_OP_CACHED; + reply->state = DRC_OP_CACHED; - reply->msg.iobref = iobref_ref (iobref); + reply->msg.iobref = iobref_ref(iobref); - reply->msg.rpchdrcount = rpchdrcount; - reply->msg.rpchdr = iov_dup (rpchdr, rpchdrcount); + reply->msg.rpchdrcount = rpchdrcount; + reply->msg.rpchdr = iov_dup(rpchdr, rpchdrcount); - reply->msg.proghdrcount = proghdrcount; - reply->msg.proghdr = iov_dup (proghdr, proghdrcount); + reply->msg.proghdrcount = proghdrcount; + reply->msg.proghdr = iov_dup(proghdr, proghdrcount); - reply->msg.progpayloadcount = payloadcount; - if (payloadcount) - reply->msg.progpayload = iov_dup (payload, payloadcount); + reply->msg.progpayloadcount = payloadcount; + if (payloadcount) + reply->msg.progpayload = iov_dup(payload, payloadcount); - // rpcsvc_drc_client_unref (req->svc->drc, req->trans->drc_client); - // rpcsvc_drc_op_unref (req->svc->drc, reply); - ret = 0; + // rpcsvc_drc_client_unref (req->svc->drc, req->trans->drc_client); + // rpcsvc_drc_op_unref (req->svc->drc, reply); + ret = 0; - return ret; + return ret; } /** @@ -405,73 +402,74 @@ rpcsvc_cache_reply (rpcsvc_request_t *req, struct iobref *iobref, * @return void */ static void -rpcsvc_vacate_drc_entries (rpcsvc_drc_globals_t *drc) +rpcsvc_vacate_drc_entries(rpcsvc_drc_globals_t *drc) { - uint32_t i = 0; - uint32_t n = 0; - drc_cached_op_t *reply = NULL; - drc_cached_op_t *tmp = NULL; - drc_client_t *client = NULL; + uint32_t i = 0; + uint32_t n = 0; + drc_cached_op_t *reply = NULL; + drc_cached_op_t *tmp = NULL; + drc_client_t *client = NULL; - GF_ASSERT (drc); + GF_ASSERT(drc); - n = drc->global_cache_size / drc->lru_factor; + n = drc->global_cache_size / drc->lru_factor; - list_for_each_entry_safe_reverse (reply, tmp, &drc->cache_head, global_list) { - /* Don't delete ops that are in transit */ - if (reply->state == DRC_OP_IN_TRANSIT) - continue; + list_for_each_entry_safe_reverse(reply, tmp, &drc->cache_head, global_list) + { + /* Don't delete ops that are in transit */ + if (reply->state == DRC_OP_IN_TRANSIT) + continue; - client = reply->client; + client = reply->client; - rb_delete (client->rbtree, reply); + rb_delete(client->rbtree, reply); - rpcsvc_drc_op_destroy (drc, reply); - rpcsvc_drc_client_unref (drc, client); - i++; - if (i >= n) - break; - } + rpcsvc_drc_op_destroy(drc, reply); + rpcsvc_drc_client_unref(drc, client); + i++; + if (i >= n) + break; + } } /** - * rpcsvc_add_op_to_cache - insert the cached op into the client rbtree and drc list + * rpcsvc_add_op_to_cache - insert the cached op into the client rbtree and drc + * list * * @param drc - the main drc structure * @param reply - the op to be inserted * @return 0 on success, -1 on failure */ static int -rpcsvc_add_op_to_cache (rpcsvc_drc_globals_t *drc, drc_cached_op_t *reply) +rpcsvc_add_op_to_cache(rpcsvc_drc_globals_t *drc, drc_cached_op_t *reply) { - drc_client_t *client = NULL; - drc_cached_op_t **tmp_reply = NULL; + drc_client_t *client = NULL; + drc_cached_op_t **tmp_reply = NULL; - GF_ASSERT (drc); - GF_ASSERT (reply); + GF_ASSERT(drc); + GF_ASSERT(reply); - client = reply->client; + client = reply->client; - /* cache is full, free up some space */ - if (drc->op_count >= drc->global_cache_size) - rpcsvc_vacate_drc_entries (drc); - - tmp_reply = (drc_cached_op_t **)rb_probe (client->rbtree, reply); - if (!tmp_reply) { - /* mem alloc failed */ - return -1; - } else if (*tmp_reply != reply) { - /* should never happen */ - gf_log (GF_RPCSVC, GF_LOG_ERROR, - "DRC failed to detect duplicates"); - return -1; - } + /* cache is full, free up some space */ + if (drc->op_count >= drc->global_cache_size) + rpcsvc_vacate_drc_entries(drc); - client->op_count++; - list_add (&reply->global_list, &drc->cache_head); - drc->op_count++; + tmp_reply = (drc_cached_op_t **)rb_probe(client->rbtree, reply); + if (!tmp_reply) { + /* mem alloc failed */ + return -1; + } else if (*tmp_reply != reply) { + /* should never happen */ + gf_log(GF_RPCSVC, GF_LOG_ERROR, "DRC failed to detect duplicates"); + return -1; + } - return 0; + client->op_count++; + list_add(&reply->global_list, &drc->cache_head); + drc->op_count++; + + return 0; } /** @@ -481,46 +479,46 @@ rpcsvc_add_op_to_cache (rpcsvc_drc_globals_t *drc, drc_cached_op_t *reply) * @return 0 on success, -1 on failure */ int -rpcsvc_cache_request (rpcsvc_request_t *req) +rpcsvc_cache_request(rpcsvc_request_t *req) { - int ret = -1; - drc_client_t *client = NULL; - drc_cached_op_t *reply = NULL; - rpcsvc_drc_globals_t *drc = NULL; - - GF_ASSERT (req); - - drc = req->svc->drc; - - client = req->trans->drc_client; - if (!client) { - gf_log (GF_RPCSVC, GF_LOG_DEBUG, "drc client is NULL"); - goto out; - } - - reply = mem_get0 (drc->mempool); - if (!reply) - goto out; - - reply->client = rpcsvc_drc_client_ref (client); - reply->xid = req->xid; - reply->prognum = req->prognum; - reply->progversion = req->progver; - reply->procnum = req->procnum; - reply->state = DRC_OP_IN_TRANSIT; - req->reply = reply; - INIT_LIST_HEAD (&reply->global_list); - - ret = rpcsvc_add_op_to_cache (drc, reply); - if (ret) { - req->reply = NULL; - rpcsvc_drc_op_destroy (drc, reply); - rpcsvc_drc_client_unref (drc, client); - gf_log (GF_RPCSVC, GF_LOG_DEBUG, "Failed to add op to drc cache"); - } - - out: - return ret; + int ret = -1; + drc_client_t *client = NULL; + drc_cached_op_t *reply = NULL; + rpcsvc_drc_globals_t *drc = NULL; + + GF_ASSERT(req); + + drc = req->svc->drc; + + client = req->trans->drc_client; + if (!client) { + gf_log(GF_RPCSVC, GF_LOG_DEBUG, "drc client is NULL"); + goto out; + } + + reply = mem_get0(drc->mempool); + if (!reply) + goto out; + + reply->client = rpcsvc_drc_client_ref(client); + reply->xid = req->xid; + reply->prognum = req->prognum; + reply->progversion = req->progver; + reply->procnum = req->procnum; + reply->state = DRC_OP_IN_TRANSIT; + req->reply = reply; + INIT_LIST_HEAD(&reply->global_list); + + ret = rpcsvc_add_op_to_cache(drc, reply); + if (ret) { + req->reply = NULL; + rpcsvc_drc_op_destroy(drc, reply); + rpcsvc_drc_client_unref(drc, client); + gf_log(GF_RPCSVC, GF_LOG_DEBUG, "Failed to add op to drc cache"); + } + +out: + return ret; } /** @@ -531,72 +529,76 @@ rpcsvc_cache_request (rpcsvc_request_t *req) * @return 0 on success, -1 on failure */ int32_t -rpcsvc_drc_priv (rpcsvc_drc_globals_t *drc) +rpcsvc_drc_priv(rpcsvc_drc_globals_t *drc) { - int i = 0; - char key[GF_DUMP_MAX_BUF_LEN] = {0}; - drc_client_t *client = NULL; - char ip[INET6_ADDRSTRLEN] = {0}; - - if (!drc || drc->status == DRC_UNINITIATED) { - gf_log (GF_RPCSVC, GF_LOG_DEBUG, "DRC is " - "uninitialized, not dumping its state"); - return 0; + int i = 0; + char key[GF_DUMP_MAX_BUF_LEN] = {0}; + drc_client_t *client = NULL; + char ip[INET6_ADDRSTRLEN] = {0}; + + if (!drc || drc->status == DRC_UNINITIATED) { + gf_log(GF_RPCSVC, GF_LOG_DEBUG, + "DRC is " + "uninitialized, not dumping its state"); + return 0; + } + + gf_proc_dump_add_section("rpc.drc"); + + if (TRY_LOCK(&drc->lock)) + return -1; + + gf_proc_dump_build_key(key, "drc", "type"); + gf_proc_dump_write(key, "%d", drc->type); + + gf_proc_dump_build_key(key, "drc", "client_count"); + gf_proc_dump_write(key, "%d", drc->client_count); + + gf_proc_dump_build_key(key, "drc", "current_cache_size"); + gf_proc_dump_write(key, "%d", drc->op_count); + + gf_proc_dump_build_key(key, "drc", "max_cache_size"); + gf_proc_dump_write(key, "%d", drc->global_cache_size); + + gf_proc_dump_build_key(key, "drc", "lru_factor"); + gf_proc_dump_write(key, "%d", drc->lru_factor); + + gf_proc_dump_build_key(key, "drc", "duplicate_request_count"); + gf_proc_dump_write(key, "%d", drc->cache_hits); + + gf_proc_dump_build_key(key, "drc", "in_transit_duplicate_requests"); + gf_proc_dump_write(key, "%d", drc->intransit_hits); + + list_for_each_entry(client, &drc->clients_head, client_list) + { + gf_proc_dump_build_key(key, "client", "%d.ip-address", i); + memset(ip, 0, INET6_ADDRSTRLEN); + switch (client->sock_union.storage.ss_family) { + case AF_INET: + gf_proc_dump_write( + key, "%s", + inet_ntop(AF_INET, &client->sock_union.sin.sin_addr.s_addr, + ip, INET_ADDRSTRLEN)); + break; + case AF_INET6: + gf_proc_dump_write( + key, "%s", + inet_ntop(AF_INET6, &client->sock_union.sin6.sin6_addr, ip, + INET6_ADDRSTRLEN)); + break; + default: + gf_proc_dump_write(key, "%s", "N/A"); } - gf_proc_dump_add_section("rpc.drc"); - - if (TRY_LOCK (&drc->lock)) - return -1; - - gf_proc_dump_build_key (key, "drc", "type"); - gf_proc_dump_write (key, "%d", drc->type); - - gf_proc_dump_build_key (key, "drc", "client_count"); - gf_proc_dump_write (key, "%d", drc->client_count); - - gf_proc_dump_build_key (key, "drc", "current_cache_size"); - gf_proc_dump_write (key, "%d", drc->op_count); - - gf_proc_dump_build_key (key, "drc", "max_cache_size"); - gf_proc_dump_write (key, "%d", drc->global_cache_size); - - gf_proc_dump_build_key (key, "drc", "lru_factor"); - gf_proc_dump_write (key, "%d", drc->lru_factor); - - gf_proc_dump_build_key (key, "drc", "duplicate_request_count"); - gf_proc_dump_write (key, "%d", drc->cache_hits); - - gf_proc_dump_build_key (key, "drc", "in_transit_duplicate_requests"); - gf_proc_dump_write (key, "%d", drc->intransit_hits); - - list_for_each_entry (client, &drc->clients_head, client_list) { - gf_proc_dump_build_key (key, "client", "%d.ip-address", i); - memset (ip, 0, INET6_ADDRSTRLEN); - switch (client->sock_union.storage.ss_family) { - case AF_INET: - gf_proc_dump_write (key, "%s", inet_ntop (AF_INET, - &client->sock_union.sin.sin_addr.s_addr, - ip, INET_ADDRSTRLEN)); - break; - case AF_INET6: - gf_proc_dump_write (key, "%s", inet_ntop (AF_INET6, - &client->sock_union.sin6.sin6_addr, - ip, INET6_ADDRSTRLEN)); - break; - default: - gf_proc_dump_write (key, "%s", "N/A"); - } - - gf_proc_dump_build_key (key, "client", "%d.ref_count", i); - gf_proc_dump_write (key, "%d", client->ref); - gf_proc_dump_build_key (key, "client", "%d.op_count", i); - gf_proc_dump_write (key, "%d", client->op_count); - i++; - } + gf_proc_dump_build_key(key, "client", "%d.ref_count", i); + gf_proc_dump_write(key, "%d", client->ref); + gf_proc_dump_build_key(key, "client", "%d.op_count", i); + gf_proc_dump_write(key, "%d", client->op_count); + i++; + } - UNLOCK (&drc->lock); - return 0; + UNLOCK(&drc->lock); + return 0; } /** @@ -609,53 +611,51 @@ rpcsvc_drc_priv (rpcsvc_drc_globals_t *drc) * @return 0 on success, -1 on failure */ int -rpcsvc_drc_notify (rpcsvc_t *svc, void *xl, - rpcsvc_event_t event, void *data) +rpcsvc_drc_notify(rpcsvc_t *svc, void *xl, rpcsvc_event_t event, void *data) { - int ret = -1; - rpc_transport_t *trans = NULL; - drc_client_t *client = NULL; - rpcsvc_drc_globals_t *drc = NULL; - - GF_ASSERT (svc); - GF_ASSERT (svc->drc); - GF_ASSERT (data); - - drc = svc->drc; - - if (drc->status == DRC_UNINITIATED || - drc->type == DRC_TYPE_NONE) - return 0; - - LOCK (&drc->lock); - { - trans = (rpc_transport_t *)data; - client = rpcsvc_get_drc_client (drc, &trans->peerinfo.sockaddr); - if (!client) - goto unlock; - - switch (event) { - case RPCSVC_EVENT_ACCEPT: - trans->drc_client = rpcsvc_drc_client_ref (client); - ret = 0; - break; - - case RPCSVC_EVENT_DISCONNECT: - ret = 0; - if (list_empty (&drc->clients_head)) - break; - /* should be the last unref */ - trans->drc_client = NULL; - rpcsvc_drc_client_unref (drc, client); - break; - - default: - break; - } + int ret = -1; + rpc_transport_t *trans = NULL; + drc_client_t *client = NULL; + rpcsvc_drc_globals_t *drc = NULL; + + GF_ASSERT(svc); + GF_ASSERT(svc->drc); + GF_ASSERT(data); + + drc = svc->drc; + + if (drc->status == DRC_UNINITIATED || drc->type == DRC_TYPE_NONE) + return 0; + + LOCK(&drc->lock); + { + trans = (rpc_transport_t *)data; + client = rpcsvc_get_drc_client(drc, &trans->peerinfo.sockaddr); + if (!client) + goto unlock; + + switch (event) { + case RPCSVC_EVENT_ACCEPT: + trans->drc_client = rpcsvc_drc_client_ref(client); + ret = 0; + break; + + case RPCSVC_EVENT_DISCONNECT: + ret = 0; + if (list_empty(&drc->clients_head)) + break; + /* should be the last unref */ + trans->drc_client = NULL; + rpcsvc_drc_client_unref(drc, client); + break; + + default: + break; } + } unlock: - UNLOCK (&drc->lock); - return ret; + UNLOCK(&drc->lock); + return ret; } /** @@ -666,191 +666,195 @@ unlock: * @return 0 on success, non-zero integer on failure */ int -rpcsvc_drc_init (rpcsvc_t *svc, dict_t *options) +rpcsvc_drc_init(rpcsvc_t *svc, dict_t *options) { - int ret = 0; - uint32_t drc_type = 0; - uint32_t drc_size = 0; - uint32_t drc_factor = 0; - rpcsvc_drc_globals_t *drc = NULL; - - GF_ASSERT (svc); - GF_ASSERT (options); - - /* Toggle DRC on/off, when more drc types(persistent/cluster) - * are added, we shouldn't treat this as boolean. */ - ret = dict_get_str_boolean (options, "nfs.drc", _gf_false); - if (ret == -1) { - gf_log (GF_RPCSVC, GF_LOG_INFO, - "drc user options need second look"); - ret = _gf_false; - } - - gf_log (GF_RPCSVC, GF_LOG_INFO, "DRC is turned %s", (ret?"ON":"OFF")); - - /*DRC off, nothing to do */ - if (ret == _gf_false) - return (0); - - drc = GF_CALLOC (1, sizeof (rpcsvc_drc_globals_t), - gf_common_mt_drc_globals_t); - if (!drc) - return (-1); - - LOCK_INIT (&drc->lock); - svc->drc = drc; - - LOCK (&drc->lock); - - /* Specify type of DRC to be used */ - ret = dict_get_uint32 (options, "nfs.drc-type", &drc_type); - if (ret) { - gf_log (GF_RPCSVC, GF_LOG_DEBUG, "drc type not set." - " Continuing with default"); - drc_type = DRC_DEFAULT_TYPE; - } - - drc->type = drc_type; - - /* Set the global cache size (no. of ops to cache) */ - ret = dict_get_uint32 (options, "nfs.drc-size", &drc_size); - if (ret) { - gf_log (GF_RPCSVC, GF_LOG_DEBUG, "drc size not set." - " Continuing with default size"); - drc_size = DRC_DEFAULT_CACHE_SIZE; - } - - drc->global_cache_size = drc_size; - - /* Mempool for cached ops */ - drc->mempool = mem_pool_new (drc_cached_op_t, drc->global_cache_size); - if (!drc->mempool) { - gf_log (GF_RPCSVC, GF_LOG_ERROR, "Failed to get mempool for" - " DRC, drc-size: %d", drc->global_cache_size); - ret = -1; - goto out; - } - - /* What percent of cache to be evicted whenever it fills up */ - ret = dict_get_uint32 (options, "nfs.drc-lru-factor", &drc_factor); - if (ret) { - gf_log (GF_RPCSVC, GF_LOG_DEBUG, "drc lru factor not set." - " Continuing with policy default"); - drc_factor = DRC_DEFAULT_LRU_FACTOR; - } - - drc->lru_factor = (drc_lru_factor_t) drc_factor; - - INIT_LIST_HEAD (&drc->clients_head); - INIT_LIST_HEAD (&drc->cache_head); - - ret = rpcsvc_register_notify (svc, rpcsvc_drc_notify, THIS); - if (ret) { - gf_log (GF_RPCSVC, GF_LOG_ERROR, - "registration of drc_notify function failed"); - goto out; - } + int ret = 0; + uint32_t drc_type = 0; + uint32_t drc_size = 0; + uint32_t drc_factor = 0; + rpcsvc_drc_globals_t *drc = NULL; + + GF_ASSERT(svc); + GF_ASSERT(options); + + /* Toggle DRC on/off, when more drc types(persistent/cluster) + * are added, we shouldn't treat this as boolean. */ + ret = dict_get_str_boolean(options, "nfs.drc", _gf_false); + if (ret == -1) { + gf_log(GF_RPCSVC, GF_LOG_INFO, "drc user options need second look"); + ret = _gf_false; + } + + gf_log(GF_RPCSVC, GF_LOG_INFO, "DRC is turned %s", (ret ? "ON" : "OFF")); + + /*DRC off, nothing to do */ + if (ret == _gf_false) + return (0); - gf_log (GF_RPCSVC, GF_LOG_DEBUG, "drc init successful"); - drc->status = DRC_INITIATED; - out: - UNLOCK (&drc->lock); - if (ret == -1) { - if (drc->mempool) { - mem_pool_destroy (drc->mempool); - drc->mempool = NULL; - } - GF_FREE (drc); - svc->drc = NULL; + drc = GF_CALLOC(1, sizeof(rpcsvc_drc_globals_t), + gf_common_mt_drc_globals_t); + if (!drc) + return (-1); + + LOCK_INIT(&drc->lock); + svc->drc = drc; + + LOCK(&drc->lock); + + /* Specify type of DRC to be used */ + ret = dict_get_uint32(options, "nfs.drc-type", &drc_type); + if (ret) { + gf_log(GF_RPCSVC, GF_LOG_DEBUG, + "drc type not set." + " Continuing with default"); + drc_type = DRC_DEFAULT_TYPE; + } + + drc->type = drc_type; + + /* Set the global cache size (no. of ops to cache) */ + ret = dict_get_uint32(options, "nfs.drc-size", &drc_size); + if (ret) { + gf_log(GF_RPCSVC, GF_LOG_DEBUG, + "drc size not set." + " Continuing with default size"); + drc_size = DRC_DEFAULT_CACHE_SIZE; + } + + drc->global_cache_size = drc_size; + + /* Mempool for cached ops */ + drc->mempool = mem_pool_new(drc_cached_op_t, drc->global_cache_size); + if (!drc->mempool) { + gf_log(GF_RPCSVC, GF_LOG_ERROR, + "Failed to get mempool for" + " DRC, drc-size: %d", + drc->global_cache_size); + ret = -1; + goto out; + } + + /* What percent of cache to be evicted whenever it fills up */ + ret = dict_get_uint32(options, "nfs.drc-lru-factor", &drc_factor); + if (ret) { + gf_log(GF_RPCSVC, GF_LOG_DEBUG, + "drc lru factor not set." + " Continuing with policy default"); + drc_factor = DRC_DEFAULT_LRU_FACTOR; + } + + drc->lru_factor = (drc_lru_factor_t)drc_factor; + + INIT_LIST_HEAD(&drc->clients_head); + INIT_LIST_HEAD(&drc->cache_head); + + ret = rpcsvc_register_notify(svc, rpcsvc_drc_notify, THIS); + if (ret) { + gf_log(GF_RPCSVC, GF_LOG_ERROR, + "registration of drc_notify function failed"); + goto out; + } + + gf_log(GF_RPCSVC, GF_LOG_DEBUG, "drc init successful"); + drc->status = DRC_INITIATED; +out: + UNLOCK(&drc->lock); + if (ret == -1) { + if (drc->mempool) { + mem_pool_destroy(drc->mempool); + drc->mempool = NULL; } - return ret; + GF_FREE(drc); + svc->drc = NULL; + } + return ret; } int -rpcsvc_drc_deinit (rpcsvc_t *svc) +rpcsvc_drc_deinit(rpcsvc_t *svc) { - rpcsvc_drc_globals_t *drc = NULL; + rpcsvc_drc_globals_t *drc = NULL; - if (!svc) - return (-1); + if (!svc) + return (-1); - drc = svc->drc; - if (!drc) - return (0); + drc = svc->drc; + if (!drc) + return (0); - LOCK (&drc->lock); - (void) rpcsvc_unregister_notify (svc, rpcsvc_drc_notify, THIS); - if (drc->mempool) { - mem_pool_destroy (drc->mempool); - drc->mempool = NULL; - } - UNLOCK (&drc->lock); + LOCK(&drc->lock); + (void)rpcsvc_unregister_notify(svc, rpcsvc_drc_notify, THIS); + if (drc->mempool) { + mem_pool_destroy(drc->mempool); + drc->mempool = NULL; + } + UNLOCK(&drc->lock); - GF_FREE (drc); - svc->drc = NULL; + GF_FREE(drc); + svc->drc = NULL; - return (0); + return (0); } int -rpcsvc_drc_reconfigure (rpcsvc_t *svc, dict_t *options) +rpcsvc_drc_reconfigure(rpcsvc_t *svc, dict_t *options) { - int ret = -1; - gf_boolean_t enable_drc = _gf_false; - rpcsvc_drc_globals_t *drc = NULL; - uint32_t drc_size = 0; - - /* Input sanitization */ - if ((!svc) || (!options)) - return (-1); - - /* If DRC was not enabled before, Let rpcsvc_drc_init() to - * take care of DRC initialization part. - */ - drc = svc->drc; - if (!drc) { - return rpcsvc_drc_init(svc, options); - } - - /* DRC was already enabled before. Going to be reconfigured. Check - * if reconfigured options contain "nfs.drc" and "nfs.drc-size". - * - * NB: If DRC is "OFF", "drc-size" has no role to play. - * So, "drc-size" gets evaluated IFF DRC is "ON". - * - * If DRC is reconfigured, - * case 1: DRC is "ON" - * sub-case 1: drc-size remains same - * ACTION: Nothing to do. - * sub-case 2: drc-size just changed - * ACTION: rpcsvc_drc_deinit() followed by - * rpcsvc_drc_init(). - * - * case 2: DRC is "OFF" - * ACTION: rpcsvc_drc_deinit() - */ - ret = dict_get_str_boolean (options, "nfs.drc", _gf_false); - if (ret < 0) - ret = _gf_false; - - enable_drc = ret; - gf_log (GF_RPCSVC, GF_LOG_INFO, "DRC is turned %s", (ret?"ON":"OFF")); - - /* case 1: DRC is "ON"*/ - if (enable_drc) { - /* Fetch drc-size if reconfigured */ - if (dict_get_uint32 (options, "nfs.drc-size", &drc_size)) - drc_size = DRC_DEFAULT_CACHE_SIZE; - - /* case 1: sub-case 1*/ - if (drc->global_cache_size == drc_size) - return (0); - - /* case 1: sub-case 2*/ - (void) rpcsvc_drc_deinit (svc); - return rpcsvc_drc_init (svc, options); - } - - /* case 2: DRC is "OFF" */ - return rpcsvc_drc_deinit (svc); + int ret = -1; + gf_boolean_t enable_drc = _gf_false; + rpcsvc_drc_globals_t *drc = NULL; + uint32_t drc_size = 0; + + /* Input sanitization */ + if ((!svc) || (!options)) + return (-1); + + /* If DRC was not enabled before, Let rpcsvc_drc_init() to + * take care of DRC initialization part. + */ + drc = svc->drc; + if (!drc) { + return rpcsvc_drc_init(svc, options); + } + + /* DRC was already enabled before. Going to be reconfigured. Check + * if reconfigured options contain "nfs.drc" and "nfs.drc-size". + * + * NB: If DRC is "OFF", "drc-size" has no role to play. + * So, "drc-size" gets evaluated IFF DRC is "ON". + * + * If DRC is reconfigured, + * case 1: DRC is "ON" + * sub-case 1: drc-size remains same + * ACTION: Nothing to do. + * sub-case 2: drc-size just changed + * ACTION: rpcsvc_drc_deinit() followed by + * rpcsvc_drc_init(). + * + * case 2: DRC is "OFF" + * ACTION: rpcsvc_drc_deinit() + */ + ret = dict_get_str_boolean(options, "nfs.drc", _gf_false); + if (ret < 0) + ret = _gf_false; + + enable_drc = ret; + gf_log(GF_RPCSVC, GF_LOG_INFO, "DRC is turned %s", (ret ? "ON" : "OFF")); + + /* case 1: DRC is "ON"*/ + if (enable_drc) { + /* Fetch drc-size if reconfigured */ + if (dict_get_uint32(options, "nfs.drc-size", &drc_size)) + drc_size = DRC_DEFAULT_CACHE_SIZE; + + /* case 1: sub-case 1*/ + if (drc->global_cache_size == drc_size) + return (0); + + /* case 1: sub-case 2*/ + (void)rpcsvc_drc_deinit(svc); + return rpcsvc_drc_init(svc, options); + } + + /* case 2: DRC is "OFF" */ + return rpcsvc_drc_deinit(svc); } diff --git a/rpc/rpc-lib/src/rpc-transport.c b/rpc/rpc-lib/src/rpc-transport.c index 062d7905fe0..d70334476c7 100644 --- a/rpc/rpc-lib/src/rpc-transport.c +++ b/rpc/rpc-lib/src/rpc-transport.c @@ -29,696 +29,668 @@ #endif int32_t -rpc_transport_count (const char *transport_type) +rpc_transport_count(const char *transport_type) { - char *transport_dup = NULL; - char *saveptr = NULL; - char *ptr = NULL; - int count = 0; - - if (transport_type == NULL) - return -1; - - transport_dup = gf_strdup (transport_type); - if (transport_dup == NULL) { - return -1; - } - - ptr = strtok_r (transport_dup, ",", &saveptr); - while (ptr != NULL) { - count++; - ptr = strtok_r (NULL, ",", &saveptr); - } - - GF_FREE (transport_dup); - return count; + char *transport_dup = NULL; + char *saveptr = NULL; + char *ptr = NULL; + int count = 0; + + if (transport_type == NULL) + return -1; + + transport_dup = gf_strdup(transport_type); + if (transport_dup == NULL) { + return -1; + } + + ptr = strtok_r(transport_dup, ",", &saveptr); + while (ptr != NULL) { + count++; + ptr = strtok_r(NULL, ",", &saveptr); + } + + GF_FREE(transport_dup); + return count; } int -rpc_transport_get_myaddr (rpc_transport_t *this, char *peeraddr, int addrlen, - struct sockaddr_storage *sa, size_t salen) +rpc_transport_get_myaddr(rpc_transport_t *this, char *peeraddr, int addrlen, + struct sockaddr_storage *sa, size_t salen) { - int32_t ret = -1; - GF_VALIDATE_OR_GOTO ("rpc", this, out); + int32_t ret = -1; + GF_VALIDATE_OR_GOTO("rpc", this, out); - ret = this->ops->get_myaddr (this, peeraddr, addrlen, sa, salen); + ret = this->ops->get_myaddr(this, peeraddr, addrlen, sa, salen); out: - return ret; + return ret; } int32_t -rpc_transport_get_myname (rpc_transport_t *this, char *hostname, int hostlen) +rpc_transport_get_myname(rpc_transport_t *this, char *hostname, int hostlen) { - int32_t ret = -1; - GF_VALIDATE_OR_GOTO ("rpc", this, out); + int32_t ret = -1; + GF_VALIDATE_OR_GOTO("rpc", this, out); - ret = this->ops->get_myname (this, hostname, hostlen); + ret = this->ops->get_myname(this, hostname, hostlen); out: - return ret; + return ret; } int32_t -rpc_transport_get_peername (rpc_transport_t *this, char *hostname, int hostlen) +rpc_transport_get_peername(rpc_transport_t *this, char *hostname, int hostlen) { - int32_t ret = -1; - GF_VALIDATE_OR_GOTO ("rpc", this, out); + int32_t ret = -1; + GF_VALIDATE_OR_GOTO("rpc", this, out); - ret = this->ops->get_peername (this, hostname, hostlen); + ret = this->ops->get_peername(this, hostname, hostlen); out: - return ret; + return ret; } int -rpc_transport_throttle (rpc_transport_t *this, gf_boolean_t onoff) +rpc_transport_throttle(rpc_transport_t *this, gf_boolean_t onoff) { - int ret = 0; + int ret = 0; - if (!this->ops->throttle) - return -ENOSYS; + if (!this->ops->throttle) + return -ENOSYS; - ret = this->ops->throttle (this, onoff); + ret = this->ops->throttle(this, onoff); - return ret; + return ret; } int32_t -rpc_transport_get_peeraddr (rpc_transport_t *this, char *peeraddr, int addrlen, - struct sockaddr_storage *sa, size_t salen) +rpc_transport_get_peeraddr(rpc_transport_t *this, char *peeraddr, int addrlen, + struct sockaddr_storage *sa, size_t salen) { - int32_t ret = -1; - GF_VALIDATE_OR_GOTO ("rpc", this, out); + int32_t ret = -1; + GF_VALIDATE_OR_GOTO("rpc", this, out); - ret = this->ops->get_peeraddr (this, peeraddr, addrlen, sa, salen); + ret = this->ops->get_peeraddr(this, peeraddr, addrlen, sa, salen); out: - return ret; + return ret; } void -rpc_transport_pollin_destroy (rpc_transport_pollin_t *pollin) +rpc_transport_pollin_destroy(rpc_transport_pollin_t *pollin) { - GF_VALIDATE_OR_GOTO ("rpc", pollin, out); + GF_VALIDATE_OR_GOTO("rpc", pollin, out); - if (pollin->iobref) { - iobref_unref (pollin->iobref); - } + if (pollin->iobref) { + iobref_unref(pollin->iobref); + } - if (pollin->private) { - /* */ - GF_FREE (pollin->private); - } + if (pollin->private) { + /* */ + GF_FREE(pollin->private); + } - GF_FREE (pollin); + GF_FREE(pollin); out: - return; + return; } - rpc_transport_pollin_t * -rpc_transport_pollin_alloc (rpc_transport_t *this, struct iovec *vector, - int count, struct iobuf *hdr_iobuf, - struct iobref *iobref, void *private) +rpc_transport_pollin_alloc(rpc_transport_t *this, struct iovec *vector, + int count, struct iobuf *hdr_iobuf, + struct iobref *iobref, void *private) { - rpc_transport_pollin_t *msg = NULL; - msg = GF_CALLOC (1, sizeof (*msg), gf_common_mt_rpc_trans_pollin_t); - if (!msg) { - goto out; - } - - if (count > 1) { - msg->vectored = 1; - } - - memcpy (msg->vector, vector, count * sizeof (*vector)); - msg->count = count; - msg->iobref = iobref_ref (iobref); - msg->private = private; - if (hdr_iobuf) - iobref_add (iobref, hdr_iobuf); + rpc_transport_pollin_t *msg = NULL; + msg = GF_CALLOC(1, sizeof(*msg), gf_common_mt_rpc_trans_pollin_t); + if (!msg) { + goto out; + } + + if (count > 1) { + msg->vectored = 1; + } + + memcpy(msg->vector, vector, count * sizeof(*vector)); + msg->count = count; + msg->iobref = iobref_ref(iobref); + msg->private = private; + if (hdr_iobuf) + iobref_add(iobref, hdr_iobuf); out: - return msg; + return msg; } - - rpc_transport_t * -rpc_transport_load (glusterfs_ctx_t *ctx, dict_t *options, char *trans_name) +rpc_transport_load(glusterfs_ctx_t *ctx, dict_t *options, char *trans_name) { - struct rpc_transport *trans = NULL, *return_trans = NULL; - char *name = NULL; - void *handle = NULL; - char *type = NULL; - char str[] = "ERROR"; - int32_t ret = -1; - int is_tcp = 0, is_unix = 0, is_ibsdp = 0; - volume_opt_list_t *vol_opt = NULL; - gf_boolean_t bind_insecure = _gf_false; - xlator_t *this = NULL; - gf_boolean_t success = _gf_false; - - GF_VALIDATE_OR_GOTO("rpc-transport", options, fail); - GF_VALIDATE_OR_GOTO("rpc-transport", ctx, fail); - GF_VALIDATE_OR_GOTO("rpc-transport", trans_name, fail); - - trans = GF_CALLOC (1, sizeof (struct rpc_transport), gf_common_mt_rpc_trans_t); - if (!trans) - goto fail; - - trans->name = gf_strdup (trans_name); - if (!trans->name) - goto fail; - - trans->ctx = ctx; - type = str; - - /* Backward compatibility */ - ret = dict_get_str (options, "transport-type", &type); - if (ret < 0) { - ret = dict_set_str (options, "transport-type", "socket"); - if (ret < 0) - gf_log ("dict", GF_LOG_DEBUG, - "setting transport-type failed"); - else - gf_log ("rpc-transport", GF_LOG_DEBUG, - "missing 'option transport-type'. defaulting to " - "\"socket\""); - } else { - { - /* Backward compatibility to handle * /client, - * * /server. - */ - char *tmp = strchr (type, '/'); - if (tmp) - *tmp = '\0'; - } - - is_tcp = strcmp (type, "tcp"); - is_unix = strcmp (type, "unix"); - is_ibsdp = strcmp (type, "ib-sdp"); - if ((is_tcp == 0) || - (is_unix == 0) || - (is_ibsdp == 0)) { - if (is_unix == 0) - ret = dict_set_str (options, - "transport.address-family", - "unix"); - if (is_ibsdp == 0) - ret = dict_set_str (options, - "transport.address-family", - "inet-sdp"); - - if (ret < 0) - gf_log ("dict", GF_LOG_DEBUG, - "setting address-family failed"); - - ret = dict_set_str (options, - "transport-type", "socket"); - if (ret < 0) - gf_log ("dict", GF_LOG_DEBUG, - "setting transport-type failed"); - } - } - - /* client-bind-insecure is for clients protocol, and - * bind-insecure for glusterd. Both mutually exclusive - */ - ret = dict_get_str (options, "client-bind-insecure", &type); - if (ret) - ret = dict_get_str (options, "bind-insecure", &type); - if (ret == 0) { - ret = gf_string2boolean (type, &bind_insecure); - if (ret < 0) { - gf_log ("rcp-transport", GF_LOG_WARNING, - "bind-insecure option %s is not a" - " valid bool option", type); - goto fail; - } - if (_gf_true == bind_insecure) - trans->bind_insecure = 1; - else - trans->bind_insecure = 0; - } else { - /* By default allow bind insecure */ - trans->bind_insecure = 1; + struct rpc_transport *trans = NULL, *return_trans = NULL; + char *name = NULL; + void *handle = NULL; + char *type = NULL; + char str[] = "ERROR"; + int32_t ret = -1; + int is_tcp = 0, is_unix = 0, is_ibsdp = 0; + volume_opt_list_t *vol_opt = NULL; + gf_boolean_t bind_insecure = _gf_false; + xlator_t *this = NULL; + gf_boolean_t success = _gf_false; + + GF_VALIDATE_OR_GOTO("rpc-transport", options, fail); + GF_VALIDATE_OR_GOTO("rpc-transport", ctx, fail); + GF_VALIDATE_OR_GOTO("rpc-transport", trans_name, fail); + + trans = GF_CALLOC(1, sizeof(struct rpc_transport), + gf_common_mt_rpc_trans_t); + if (!trans) + goto fail; + + trans->name = gf_strdup(trans_name); + if (!trans->name) + goto fail; + + trans->ctx = ctx; + type = str; + + /* Backward compatibility */ + ret = dict_get_str(options, "transport-type", &type); + if (ret < 0) { + ret = dict_set_str(options, "transport-type", "socket"); + if (ret < 0) + gf_log("dict", GF_LOG_DEBUG, "setting transport-type failed"); + else + gf_log("rpc-transport", GF_LOG_DEBUG, + "missing 'option transport-type'. defaulting to " + "\"socket\""); + } else { + { + /* Backward compatibility to handle * /client, + * * /server. + */ + char *tmp = strchr(type, '/'); + if (tmp) + *tmp = '\0'; } - ret = dict_get_str (options, "transport-type", &type); - if (ret < 0) { - gf_log ("rpc-transport", GF_LOG_ERROR, - "'option transport-type <xx>' missing in volume '%s'", - trans_name); - goto fail; - } - - ret = gf_asprintf (&name, "%s/%s.so", RPC_TRANSPORTDIR, type); - if (-1 == ret) { - goto fail; + is_tcp = strcmp(type, "tcp"); + is_unix = strcmp(type, "unix"); + is_ibsdp = strcmp(type, "ib-sdp"); + if ((is_tcp == 0) || (is_unix == 0) || (is_ibsdp == 0)) { + if (is_unix == 0) + ret = dict_set_str(options, "transport.address-family", "unix"); + if (is_ibsdp == 0) + ret = dict_set_str(options, "transport.address-family", + "inet-sdp"); + + if (ret < 0) + gf_log("dict", GF_LOG_DEBUG, "setting address-family failed"); + + ret = dict_set_str(options, "transport-type", "socket"); + if (ret < 0) + gf_log("dict", GF_LOG_DEBUG, "setting transport-type failed"); } - - gf_log ("rpc-transport", GF_LOG_DEBUG, - "attempt to load file %s", name); - - handle = dlopen (name, RTLD_NOW); - if (handle == NULL) { - gf_log ("rpc-transport", GF_LOG_ERROR, "%s", dlerror ()); - gf_log ("rpc-transport", GF_LOG_WARNING, - "volume '%s': transport-type '%s' is not valid or " - "not found on this machine", - trans_name, type); - goto fail; - } - - trans->dl_handle = handle; - - trans->ops = dlsym (handle, "tops"); - if (trans->ops == NULL) { - gf_log ("rpc-transport", GF_LOG_ERROR, - "dlsym (rpc_transport_ops) on %s", dlerror ()); - goto fail; - } - - *VOID(&(trans->init)) = dlsym (handle, "init"); - if (trans->init == NULL) { - gf_log ("rpc-transport", GF_LOG_ERROR, - "dlsym (gf_rpc_transport_init) on %s", dlerror ()); - goto fail; - } - - *VOID(&(trans->fini)) = dlsym (handle, "fini"); - if (trans->fini == NULL) { - gf_log ("rpc-transport", GF_LOG_ERROR, - "dlsym (gf_rpc_transport_fini) on %s", dlerror ()); - goto fail; - } - - *VOID(&(trans->reconfigure)) = dlsym (handle, "reconfigure"); - if (trans->reconfigure == NULL) { - gf_log ("rpc-transport", GF_LOG_DEBUG, - "dlsym (gf_rpc_transport_reconfigure) on %s", dlerror()); + } + + /* client-bind-insecure is for clients protocol, and + * bind-insecure for glusterd. Both mutually exclusive + */ + ret = dict_get_str(options, "client-bind-insecure", &type); + if (ret) + ret = dict_get_str(options, "bind-insecure", &type); + if (ret == 0) { + ret = gf_string2boolean(type, &bind_insecure); + if (ret < 0) { + gf_log("rcp-transport", GF_LOG_WARNING, + "bind-insecure option %s is not a" + " valid bool option", + type); + goto fail; } - - vol_opt = GF_CALLOC (1, sizeof (volume_opt_list_t), - gf_common_mt_volume_opt_list_t); - if (!vol_opt) { - goto fail; + if (_gf_true == bind_insecure) + trans->bind_insecure = 1; + else + trans->bind_insecure = 0; + } else { + /* By default allow bind insecure */ + trans->bind_insecure = 1; + } + + ret = dict_get_str(options, "transport-type", &type); + if (ret < 0) { + gf_log("rpc-transport", GF_LOG_ERROR, + "'option transport-type <xx>' missing in volume '%s'", + trans_name); + goto fail; + } + + ret = gf_asprintf(&name, "%s/%s.so", RPC_TRANSPORTDIR, type); + if (-1 == ret) { + goto fail; + } + + gf_log("rpc-transport", GF_LOG_DEBUG, "attempt to load file %s", name); + + handle = dlopen(name, RTLD_NOW); + if (handle == NULL) { + gf_log("rpc-transport", GF_LOG_ERROR, "%s", dlerror()); + gf_log("rpc-transport", GF_LOG_WARNING, + "volume '%s': transport-type '%s' is not valid or " + "not found on this machine", + trans_name, type); + goto fail; + } + + trans->dl_handle = handle; + + trans->ops = dlsym(handle, "tops"); + if (trans->ops == NULL) { + gf_log("rpc-transport", GF_LOG_ERROR, "dlsym (rpc_transport_ops) on %s", + dlerror()); + goto fail; + } + + *VOID(&(trans->init)) = dlsym(handle, "init"); + if (trans->init == NULL) { + gf_log("rpc-transport", GF_LOG_ERROR, + "dlsym (gf_rpc_transport_init) on %s", dlerror()); + goto fail; + } + + *VOID(&(trans->fini)) = dlsym(handle, "fini"); + if (trans->fini == NULL) { + gf_log("rpc-transport", GF_LOG_ERROR, + "dlsym (gf_rpc_transport_fini) on %s", dlerror()); + goto fail; + } + + *VOID(&(trans->reconfigure)) = dlsym(handle, "reconfigure"); + if (trans->reconfigure == NULL) { + gf_log("rpc-transport", GF_LOG_DEBUG, + "dlsym (gf_rpc_transport_reconfigure) on %s", dlerror()); + } + + vol_opt = GF_CALLOC(1, sizeof(volume_opt_list_t), + gf_common_mt_volume_opt_list_t); + if (!vol_opt) { + goto fail; + } + + this = THIS; + vol_opt->given_opt = dlsym(handle, "options"); + if (vol_opt->given_opt == NULL) { + gf_log("rpc-transport", GF_LOG_DEBUG, + "volume option validation not specified"); + } else { + INIT_LIST_HEAD(&vol_opt->list); + list_add_tail(&vol_opt->list, &(this->volume_options)); + if (xlator_options_validate_list(this, options, vol_opt, NULL)) { + gf_log("rpc-transport", GF_LOG_ERROR, + "volume option validation failed"); + goto fail; } + } - this = THIS; - vol_opt->given_opt = dlsym (handle, "options"); - if (vol_opt->given_opt == NULL) { - gf_log ("rpc-transport", GF_LOG_DEBUG, - "volume option validation not specified"); - } else { - INIT_LIST_HEAD (&vol_opt->list); - list_add_tail (&vol_opt->list, &(this->volume_options)); - if (xlator_options_validate_list (this, options, vol_opt, - NULL)) { - gf_log ("rpc-transport", GF_LOG_ERROR, - "volume option validation failed"); - goto fail; - } - } + trans->options = options; - trans->options = options; + pthread_mutex_init(&trans->lock, NULL); + trans->xl = this; - pthread_mutex_init (&trans->lock, NULL); - trans->xl = this; + ret = trans->init(trans); + if (ret != 0) { + gf_log("rpc-transport", GF_LOG_WARNING, "'%s' initialization failed", + type); + goto fail; + } - ret = trans->init (trans); - if (ret != 0) { - gf_log ("rpc-transport", GF_LOG_WARNING, - "'%s' initialization failed", type); - goto fail; - } + INIT_LIST_HEAD(&trans->list); - INIT_LIST_HEAD (&trans->list); + return_trans = trans; - return_trans = trans; + GF_FREE(name); - GF_FREE (name); - - success = _gf_true; + success = _gf_true; fail: - if (!success) { - if (trans) { - GF_FREE (trans->name); + if (!success) { + if (trans) { + GF_FREE(trans->name); - if (trans->dl_handle) - dlclose (trans->dl_handle); + if (trans->dl_handle) + dlclose(trans->dl_handle); - GF_FREE (trans); - } + GF_FREE(trans); + } - GF_FREE (name); + GF_FREE(name); - return_trans = NULL; - } + return_trans = NULL; + } - if (vol_opt) { - if (!list_empty (&vol_opt->list)) { - list_del_init (&vol_opt->list); - } - GF_FREE (vol_opt); + if (vol_opt) { + if (!list_empty(&vol_opt->list)) { + list_del_init(&vol_opt->list); } + GF_FREE(vol_opt); + } - return return_trans; + return return_trans; } - int32_t -rpc_transport_submit_request (rpc_transport_t *this, rpc_transport_req_t *req) +rpc_transport_submit_request(rpc_transport_t *this, rpc_transport_req_t *req) { - int32_t ret = -1; + int32_t ret = -1; - GF_VALIDATE_OR_GOTO("rpc_transport", this, fail); - GF_VALIDATE_OR_GOTO("rpc_transport", this->ops, fail); + GF_VALIDATE_OR_GOTO("rpc_transport", this, fail); + GF_VALIDATE_OR_GOTO("rpc_transport", this->ops, fail); - ret = this->ops->submit_request (this, req); + ret = this->ops->submit_request(this, req); fail: - return ret; + return ret; } - int32_t -rpc_transport_submit_reply (rpc_transport_t *this, rpc_transport_reply_t *reply) +rpc_transport_submit_reply(rpc_transport_t *this, rpc_transport_reply_t *reply) { - int32_t ret = -1; + int32_t ret = -1; - GF_VALIDATE_OR_GOTO("rpc_transport", this, fail); - GF_VALIDATE_OR_GOTO("rpc_transport", this->ops, fail); + GF_VALIDATE_OR_GOTO("rpc_transport", this, fail); + GF_VALIDATE_OR_GOTO("rpc_transport", this->ops, fail); - ret = this->ops->submit_reply (this, reply); + ret = this->ops->submit_reply(this, reply); fail: - return ret; + return ret; } - int32_t -rpc_transport_connect (rpc_transport_t *this, int port) +rpc_transport_connect(rpc_transport_t *this, int port) { - int ret = -1; + int ret = -1; - GF_VALIDATE_OR_GOTO("rpc_transport", this, fail); + GF_VALIDATE_OR_GOTO("rpc_transport", this, fail); - ret = this->ops->connect (this, port); + ret = this->ops->connect(this, port); fail: - return ret; + return ret; } - int32_t -rpc_transport_listen (rpc_transport_t *this) +rpc_transport_listen(rpc_transport_t *this) { - int ret = -1; + int ret = -1; - GF_VALIDATE_OR_GOTO("rpc_transport", this, fail); + GF_VALIDATE_OR_GOTO("rpc_transport", this, fail); - ret = this->ops->listen (this); + ret = this->ops->listen(this); fail: - return ret; + return ret; } - int32_t -rpc_transport_disconnect (rpc_transport_t *this, gf_boolean_t wait) +rpc_transport_disconnect(rpc_transport_t *this, gf_boolean_t wait) { - int32_t ret = -1; + int32_t ret = -1; - GF_VALIDATE_OR_GOTO("rpc_transport", this, fail); + GF_VALIDATE_OR_GOTO("rpc_transport", this, fail); - ret = this->ops->disconnect (this, wait); + ret = this->ops->disconnect(this, wait); fail: - return ret; + return ret; } - int32_t -rpc_transport_destroy (rpc_transport_t *this) +rpc_transport_destroy(rpc_transport_t *this) { - struct dnscache6 *cache = NULL; - int32_t ret = -1; + struct dnscache6 *cache = NULL; + int32_t ret = -1; - GF_VALIDATE_OR_GOTO("rpc_transport", this, fail); + GF_VALIDATE_OR_GOTO("rpc_transport", this, fail); - if (this->clnt_options) - dict_unref (this->clnt_options); - if (this->options) - dict_unref (this->options); - if (this->fini) - this->fini (this); + if (this->clnt_options) + dict_unref(this->clnt_options); + if (this->options) + dict_unref(this->options); + if (this->fini) + this->fini(this); - pthread_mutex_destroy (&this->lock); + pthread_mutex_destroy(&this->lock); - GF_FREE (this->name); + GF_FREE(this->name); - if (this->dl_handle) - dlclose (this->dl_handle); + if (this->dl_handle) + dlclose(this->dl_handle); - if (this->ssl_name) { - GF_FREE(this->ssl_name); - } + if (this->ssl_name) { + GF_FREE(this->ssl_name); + } - if (this->dnscache) { - cache = this->dnscache; - if (cache->first) - freeaddrinfo (cache->first); - GF_FREE (this->dnscache); - } + if (this->dnscache) { + cache = this->dnscache; + if (cache->first) + freeaddrinfo(cache->first); + GF_FREE(this->dnscache); + } - GF_FREE (this); + GF_FREE(this); - ret = 0; + ret = 0; fail: - return ret; + return ret; } - rpc_transport_t * -rpc_transport_ref (rpc_transport_t *this) +rpc_transport_ref(rpc_transport_t *this) { - rpc_transport_t *return_this = NULL; + rpc_transport_t *return_this = NULL; - GF_VALIDATE_OR_GOTO("rpc_transport", this, fail); + GF_VALIDATE_OR_GOTO("rpc_transport", this, fail); - GF_ATOMIC_INC (this->refcount); + GF_ATOMIC_INC(this->refcount); - return_this = this; + return_this = this; fail: - return return_this; + return return_this; } - int32_t -rpc_transport_unref (rpc_transport_t *this) +rpc_transport_unref(rpc_transport_t *this) { - int32_t refcount = 0; - int32_t ret = -1; + int32_t refcount = 0; + int32_t ret = -1; - GF_VALIDATE_OR_GOTO("rpc_transport", this, fail); + GF_VALIDATE_OR_GOTO("rpc_transport", this, fail); - refcount = GF_ATOMIC_DEC (this->refcount); + refcount = GF_ATOMIC_DEC(this->refcount); - if (refcount == 0) { - if (this->mydata) - this->notify (this, this->mydata, RPC_TRANSPORT_CLEANUP, - NULL); - this->mydata = NULL; - this->notify = NULL; - rpc_transport_destroy (this); - } + if (refcount == 0) { + if (this->mydata) + this->notify(this, this->mydata, RPC_TRANSPORT_CLEANUP, NULL); + this->mydata = NULL; + this->notify = NULL; + rpc_transport_destroy(this); + } - ret = 0; + ret = 0; fail: - return ret; + return ret; } - int32_t -rpc_transport_notify (rpc_transport_t *this, rpc_transport_event_t event, - void *data, ...) +rpc_transport_notify(rpc_transport_t *this, rpc_transport_event_t event, + void *data, ...) { - int32_t ret = -1; - GF_VALIDATE_OR_GOTO ("rpc", this, out); + int32_t ret = -1; + GF_VALIDATE_OR_GOTO("rpc", this, out); - if (this->notify != NULL) { - ret = this->notify (this, this->mydata, event, data); - } else { - ret = 0; - } + if (this->notify != NULL) { + ret = this->notify(this, this->mydata, event, data); + } else { + ret = 0; + } out: - return ret; + return ret; } - - int -rpc_transport_register_notify (rpc_transport_t *trans, - rpc_transport_notify_t notify, void *mydata) +rpc_transport_register_notify(rpc_transport_t *trans, + rpc_transport_notify_t notify, void *mydata) { - int32_t ret = -1; - GF_VALIDATE_OR_GOTO ("rpc", trans, out); + int32_t ret = -1; + GF_VALIDATE_OR_GOTO("rpc", trans, out); - trans->notify = notify; - trans->mydata = mydata; + trans->notify = notify; + trans->mydata = mydata; - ret = 0; + ret = 0; out: - return ret; + return ret; } - - -//give negative values to skip setting that value -//this function asserts if both the values are negative. -//why call it if you don't set it. +// give negative values to skip setting that value +// this function asserts if both the values are negative. +// why call it if you don't set it. int -rpc_transport_keepalive_options_set (dict_t *options, int32_t interval, - int32_t time, int32_t timeout) +rpc_transport_keepalive_options_set(dict_t *options, int32_t interval, + int32_t time, int32_t timeout) { - int ret = -1; + int ret = -1; - GF_ASSERT (options); - GF_ASSERT ((interval > 0) || (time > 0)); + GF_ASSERT(options); + GF_ASSERT((interval > 0) || (time > 0)); - ret = dict_set_int32 (options, - "transport.socket.keepalive-interval", interval); - if (ret) - goto out; + ret = dict_set_int32(options, "transport.socket.keepalive-interval", + interval); + if (ret) + goto out; - ret = dict_set_int32 (options, - "transport.socket.keepalive-time", time); - if (ret) - goto out; + ret = dict_set_int32(options, "transport.socket.keepalive-time", time); + if (ret) + goto out; - ret = dict_set_int32 (options, - "transport.tcp-user-timeout", timeout); - if (ret) - goto out; + ret = dict_set_int32(options, "transport.tcp-user-timeout", timeout); + if (ret) + goto out; out: - return ret; + return ret; } int -rpc_transport_unix_options_build (dict_t **options, char *filepath, - int frame_timeout) +rpc_transport_unix_options_build(dict_t **options, char *filepath, + int frame_timeout) { - dict_t *dict = NULL; - char *fpath = NULL; - int ret = -1; - - GF_ASSERT (filepath); - GF_ASSERT (options); - - dict = dict_new (); - if (!dict) - goto out; - - fpath = gf_strdup (filepath); - if (!fpath) { - ret = -1; - goto out; - } - - ret = dict_set_dynstr (dict, "transport.socket.connect-path", fpath); - if (ret) { - GF_FREE (fpath); - goto out; - } - - ret = dict_set_str (dict, "transport.address-family", "unix"); + dict_t *dict = NULL; + char *fpath = NULL; + int ret = -1; + + GF_ASSERT(filepath); + GF_ASSERT(options); + + dict = dict_new(); + if (!dict) + goto out; + + fpath = gf_strdup(filepath); + if (!fpath) { + ret = -1; + goto out; + } + + ret = dict_set_dynstr(dict, "transport.socket.connect-path", fpath); + if (ret) { + GF_FREE(fpath); + goto out; + } + + ret = dict_set_str(dict, "transport.address-family", "unix"); + if (ret) + goto out; + + ret = dict_set_str(dict, "transport.socket.nodelay", "off"); + if (ret) + goto out; + + ret = dict_set_str(dict, "transport-type", "socket"); + if (ret) + goto out; + + ret = dict_set_str(dict, "transport.socket.keepalive", "off"); + if (ret) + goto out; + + if (frame_timeout > 0) { + ret = dict_set_int32(dict, "frame-timeout", frame_timeout); if (ret) - goto out; + goto out; + } - ret = dict_set_str (dict, "transport.socket.nodelay", "off"); - if (ret) - goto out; - - ret = dict_set_str (dict, "transport-type", "socket"); - if (ret) - goto out; - - ret = dict_set_str (dict, "transport.socket.keepalive", "off"); - if (ret) - goto out; - - if (frame_timeout > 0) { - ret = dict_set_int32 (dict, "frame-timeout", frame_timeout); - if (ret) - goto out; - } - - *options = dict; + *options = dict; out: - if (ret && dict) { - dict_unref (dict); - } - return ret; + if (ret && dict) { + dict_unref(dict); + } + return ret; } int -rpc_transport_inet_options_build (dict_t **options, const char *hostname, - int port) +rpc_transport_inet_options_build(dict_t **options, const char *hostname, + int port) { - dict_t *dict = NULL; - char *host = NULL; - int ret = -1; + dict_t *dict = NULL; + char *host = NULL; + int ret = -1; #ifdef IPV6_DEFAULT - char *addr_family = "inet6"; + char *addr_family = "inet6"; #else - char *addr_family = "inet"; + char *addr_family = "inet"; #endif - GF_ASSERT (options); - GF_ASSERT (hostname); - GF_ASSERT (port >= 1024); - - dict = dict_new (); - if (!dict) - goto out; - - host = gf_strdup ((char*)hostname); - if (!host) { - ret = -1; - goto out; - } - - ret = dict_set_dynstr (dict, "remote-host", host); - if (ret) { - gf_log (THIS->name, GF_LOG_WARNING, - "failed to set remote-host with %s", host); - GF_FREE (host); - goto out; - } - - ret = dict_set_int32 (dict, "remote-port", port); - if (ret) { - gf_log (THIS->name, GF_LOG_WARNING, - "failed to set remote-port with %d", port); - goto out; - } - - ret = dict_set_str (dict, "address-family", addr_family); - if (ret) { - gf_log (THIS->name, GF_LOG_WARNING, - "failed to set address-family to %s", addr_family); - goto out; - } - - ret = dict_set_str (dict, "transport-type", "socket"); - if (ret) { - gf_log (THIS->name, GF_LOG_WARNING, - "failed to set trans-type with socket"); - goto out; - } - - *options = dict; + GF_ASSERT(options); + GF_ASSERT(hostname); + GF_ASSERT(port >= 1024); + + dict = dict_new(); + if (!dict) + goto out; + + host = gf_strdup((char *)hostname); + if (!host) { + ret = -1; + goto out; + } + + ret = dict_set_dynstr(dict, "remote-host", host); + if (ret) { + gf_log(THIS->name, GF_LOG_WARNING, "failed to set remote-host with %s", + host); + GF_FREE(host); + goto out; + } + + ret = dict_set_int32(dict, "remote-port", port); + if (ret) { + gf_log(THIS->name, GF_LOG_WARNING, "failed to set remote-port with %d", + port); + goto out; + } + + ret = dict_set_str(dict, "address-family", addr_family); + if (ret) { + gf_log(THIS->name, GF_LOG_WARNING, "failed to set address-family to %s", + addr_family); + goto out; + } + + ret = dict_set_str(dict, "transport-type", "socket"); + if (ret) { + gf_log(THIS->name, GF_LOG_WARNING, + "failed to set trans-type with socket"); + goto out; + } + + *options = dict; out: - if (ret && dict) { - dict_unref (dict); - } + if (ret && dict) { + dict_unref(dict); + } - return ret; + return ret; } diff --git a/rpc/rpc-lib/src/rpcsvc-auth.c b/rpc/rpc-lib/src/rpcsvc-auth.c index ef9b35f56ad..da260ade0c0 100644 --- a/rpc/rpc-lib/src/rpcsvc-auth.c +++ b/rpc/rpc-lib/src/rpcsvc-auth.c @@ -13,521 +13,507 @@ #include "dict.h" extern rpcsvc_auth_t * -rpcsvc_auth_null_init (rpcsvc_t *svc, dict_t *options); +rpcsvc_auth_null_init(rpcsvc_t *svc, dict_t *options); extern rpcsvc_auth_t * -rpcsvc_auth_unix_init (rpcsvc_t *svc, dict_t *options); +rpcsvc_auth_unix_init(rpcsvc_t *svc, dict_t *options); extern rpcsvc_auth_t * -rpcsvc_auth_glusterfs_init (rpcsvc_t *svc, dict_t *options); +rpcsvc_auth_glusterfs_init(rpcsvc_t *svc, dict_t *options); extern rpcsvc_auth_t * -rpcsvc_auth_glusterfs_v2_init (rpcsvc_t *svc, dict_t *options); +rpcsvc_auth_glusterfs_v2_init(rpcsvc_t *svc, dict_t *options); extern rpcsvc_auth_t * -rpcsvc_auth_glusterfs_v3_init (rpcsvc_t *svc, dict_t *options); +rpcsvc_auth_glusterfs_v3_init(rpcsvc_t *svc, dict_t *options); int -rpcsvc_auth_add_initer (struct list_head *list, char *idfier, - rpcsvc_auth_initer_t init) +rpcsvc_auth_add_initer(struct list_head *list, char *idfier, + rpcsvc_auth_initer_t init) { - struct rpcsvc_auth_list *new = NULL; + struct rpcsvc_auth_list *new = NULL; - if ((!list) || (!init) || (!idfier)) - return -1; + if ((!list) || (!init) || (!idfier)) + return -1; - new = GF_CALLOC (1, sizeof (*new), gf_common_mt_rpcsvc_auth_list); - if (!new) { - return -1; - } + new = GF_CALLOC(1, sizeof(*new), gf_common_mt_rpcsvc_auth_list); + if (!new) { + return -1; + } - new->init = init; - strncpy (new->name, idfier, sizeof (new->name) - 1); - INIT_LIST_HEAD (&new->authlist); - list_add_tail (&new->authlist, list); - return 0; + new->init = init; + strncpy(new->name, idfier, sizeof(new->name) - 1); + INIT_LIST_HEAD(&new->authlist); + list_add_tail(&new->authlist, list); + return 0; } - - int -rpcsvc_auth_add_initers (rpcsvc_t *svc) +rpcsvc_auth_add_initers(rpcsvc_t *svc) { - int ret = -1; - - ret = rpcsvc_auth_add_initer (&svc->authschemes, "auth-glusterfs", - (rpcsvc_auth_initer_t) - rpcsvc_auth_glusterfs_init); - if (ret == -1) { - gf_log (GF_RPCSVC, GF_LOG_ERROR, "Failed to add AUTH_GLUSTERFS"); - goto err; - } - - - ret = rpcsvc_auth_add_initer (&svc->authschemes, "auth-glusterfs-v2", - (rpcsvc_auth_initer_t) - rpcsvc_auth_glusterfs_v2_init); - if (ret == -1) { - gf_log (GF_RPCSVC, GF_LOG_ERROR, - "Failed to add AUTH_GLUSTERFS-v2"); - goto err; - } - - ret = rpcsvc_auth_add_initer (&svc->authschemes, "auth-glusterfs-v3", - (rpcsvc_auth_initer_t) - rpcsvc_auth_glusterfs_v3_init); - if (ret == -1) { - gf_log (GF_RPCSVC, GF_LOG_ERROR, - "Failed to add AUTH_GLUSTERFS-v3"); - goto err; - } - - ret = rpcsvc_auth_add_initer (&svc->authschemes, "auth-unix", - (rpcsvc_auth_initer_t) - rpcsvc_auth_unix_init); - if (ret == -1) { - gf_log (GF_RPCSVC, GF_LOG_ERROR, "Failed to add AUTH_UNIX"); - goto err; - } - - ret = rpcsvc_auth_add_initer (&svc->authschemes, "auth-null", - (rpcsvc_auth_initer_t) - rpcsvc_auth_null_init); - if (ret == -1) { - gf_log (GF_RPCSVC, GF_LOG_ERROR, "Failed to add AUTH_NULL"); - goto err; - } - - ret = 0; + int ret = -1; + + ret = rpcsvc_auth_add_initer( + &svc->authschemes, "auth-glusterfs", + (rpcsvc_auth_initer_t)rpcsvc_auth_glusterfs_init); + if (ret == -1) { + gf_log(GF_RPCSVC, GF_LOG_ERROR, "Failed to add AUTH_GLUSTERFS"); + goto err; + } + + ret = rpcsvc_auth_add_initer( + &svc->authschemes, "auth-glusterfs-v2", + (rpcsvc_auth_initer_t)rpcsvc_auth_glusterfs_v2_init); + if (ret == -1) { + gf_log(GF_RPCSVC, GF_LOG_ERROR, "Failed to add AUTH_GLUSTERFS-v2"); + goto err; + } + + ret = rpcsvc_auth_add_initer( + &svc->authschemes, "auth-glusterfs-v3", + (rpcsvc_auth_initer_t)rpcsvc_auth_glusterfs_v3_init); + if (ret == -1) { + gf_log(GF_RPCSVC, GF_LOG_ERROR, "Failed to add AUTH_GLUSTERFS-v3"); + goto err; + } + + ret = rpcsvc_auth_add_initer(&svc->authschemes, "auth-unix", + (rpcsvc_auth_initer_t)rpcsvc_auth_unix_init); + if (ret == -1) { + gf_log(GF_RPCSVC, GF_LOG_ERROR, "Failed to add AUTH_UNIX"); + goto err; + } + + ret = rpcsvc_auth_add_initer(&svc->authschemes, "auth-null", + (rpcsvc_auth_initer_t)rpcsvc_auth_null_init); + if (ret == -1) { + gf_log(GF_RPCSVC, GF_LOG_ERROR, "Failed to add AUTH_NULL"); + goto err; + } + + ret = 0; err: - return ret; + return ret; } - int -rpcsvc_auth_init_auth (rpcsvc_t *svc, dict_t *options, - struct rpcsvc_auth_list *authitem) +rpcsvc_auth_init_auth(rpcsvc_t *svc, dict_t *options, + struct rpcsvc_auth_list *authitem) { - int ret = -1; - - if ((!svc) || (!options) || (!authitem)) - return -1; - - if (!authitem->init) { - gf_log (GF_RPCSVC, GF_LOG_ERROR, "No init function defined"); - ret = -1; - goto err; - } - - authitem->auth = authitem->init (svc, options); - if (!authitem->auth) { - gf_log (GF_RPCSVC, GF_LOG_ERROR, "Registration of auth failed:" - " %s", authitem->name); - ret = -1; - goto err; - } - - authitem->enable = 1; - gf_log (GF_RPCSVC, GF_LOG_TRACE, "Authentication enabled: %s", - authitem->auth->authname); - - ret = 0; + int ret = -1; + + if ((!svc) || (!options) || (!authitem)) + return -1; + + if (!authitem->init) { + gf_log(GF_RPCSVC, GF_LOG_ERROR, "No init function defined"); + ret = -1; + goto err; + } + + authitem->auth = authitem->init(svc, options); + if (!authitem->auth) { + gf_log(GF_RPCSVC, GF_LOG_ERROR, + "Registration of auth failed:" + " %s", + authitem->name); + ret = -1; + goto err; + } + + authitem->enable = 1; + gf_log(GF_RPCSVC, GF_LOG_TRACE, "Authentication enabled: %s", + authitem->auth->authname); + + ret = 0; err: - return ret; + return ret; } - int -rpcsvc_auth_init_auths (rpcsvc_t *svc, dict_t *options) +rpcsvc_auth_init_auths(rpcsvc_t *svc, dict_t *options) { - int ret = -1; - struct rpcsvc_auth_list *auth = NULL; - struct rpcsvc_auth_list *tmp = NULL; - - if (!svc) - return -1; + int ret = -1; + struct rpcsvc_auth_list *auth = NULL; + struct rpcsvc_auth_list *tmp = NULL; - if (list_empty (&svc->authschemes)) { - gf_log (GF_RPCSVC, GF_LOG_WARNING, "No authentication!"); - ret = 0; - goto err; - } + if (!svc) + return -1; - /* If auth null and sys are not disabled by the user, we must enable - * it by default. This is a globally default rule, the user is still - * allowed to disable the two for particular subvolumes. - */ - if (!dict_get (options, "rpc-auth.auth-null")) { - ret = dict_set_str (options, "rpc-auth.auth-null", "on"); - if (ret) - gf_log ("rpc-auth", GF_LOG_DEBUG, - "dict_set failed for 'auth-nill'"); - } + if (list_empty(&svc->authschemes)) { + gf_log(GF_RPCSVC, GF_LOG_WARNING, "No authentication!"); + ret = 0; + goto err; + } + + /* If auth null and sys are not disabled by the user, we must enable + * it by default. This is a globally default rule, the user is still + * allowed to disable the two for particular subvolumes. + */ + if (!dict_get(options, "rpc-auth.auth-null")) { + ret = dict_set_str(options, "rpc-auth.auth-null", "on"); + if (ret) + gf_log("rpc-auth", GF_LOG_DEBUG, "dict_set failed for 'auth-nill'"); + } - if (!dict_get (options, "rpc-auth.auth-unix")) { - ret = dict_set_str (options, "rpc-auth.auth-unix", "on"); - if (ret) - gf_log ("rpc-auth", GF_LOG_DEBUG, - "dict_set failed for 'auth-unix'"); - } + if (!dict_get(options, "rpc-auth.auth-unix")) { + ret = dict_set_str(options, "rpc-auth.auth-unix", "on"); + if (ret) + gf_log("rpc-auth", GF_LOG_DEBUG, "dict_set failed for 'auth-unix'"); + } - if (!dict_get (options, "rpc-auth.auth-glusterfs")) { - ret = dict_set_str (options, "rpc-auth.auth-glusterfs", "on"); - if (ret) - gf_log ("rpc-auth", GF_LOG_DEBUG, - "dict_set failed for 'auth-unix'"); - } + if (!dict_get(options, "rpc-auth.auth-glusterfs")) { + ret = dict_set_str(options, "rpc-auth.auth-glusterfs", "on"); + if (ret) + gf_log("rpc-auth", GF_LOG_DEBUG, "dict_set failed for 'auth-unix'"); + } - list_for_each_entry_safe (auth, tmp, &svc->authschemes, authlist) { - ret = rpcsvc_auth_init_auth (svc, options, auth); - if (ret == -1) - goto err; - } + list_for_each_entry_safe(auth, tmp, &svc->authschemes, authlist) + { + ret = rpcsvc_auth_init_auth(svc, options, auth); + if (ret == -1) + goto err; + } - ret = 0; + ret = 0; err: - return ret; - + return ret; } int -rpcsvc_set_addr_namelookup (rpcsvc_t *svc, dict_t *options) +rpcsvc_set_addr_namelookup(rpcsvc_t *svc, dict_t *options) { - int ret; - static char *addrlookup_key = "rpc-auth.addr.namelookup"; - - if (!svc || !options) - return (-1); - - /* By default it's disabled */ - ret = dict_get_str_boolean (options, addrlookup_key, _gf_false); - if (ret < 0) { - svc->addr_namelookup = _gf_false; - } else { - svc->addr_namelookup = ret; - } + int ret; + static char *addrlookup_key = "rpc-auth.addr.namelookup"; + + if (!svc || !options) + return (-1); - if (svc->addr_namelookup) - gf_log (GF_RPCSVC, GF_LOG_DEBUG, "Addr-Name lookup enabled"); + /* By default it's disabled */ + ret = dict_get_str_boolean(options, addrlookup_key, _gf_false); + if (ret < 0) { + svc->addr_namelookup = _gf_false; + } else { + svc->addr_namelookup = ret; + } - return (0); + if (svc->addr_namelookup) + gf_log(GF_RPCSVC, GF_LOG_DEBUG, "Addr-Name lookup enabled"); + + return (0); } int -rpcsvc_set_allow_insecure (rpcsvc_t *svc, dict_t *options) +rpcsvc_set_allow_insecure(rpcsvc_t *svc, dict_t *options) { - int ret = -1; - char *allow_insecure_str = NULL; - gf_boolean_t is_allow_insecure = _gf_false; + int ret = -1; + char *allow_insecure_str = NULL; + gf_boolean_t is_allow_insecure = _gf_false; - GF_ASSERT (svc); - GF_ASSERT (options); + GF_ASSERT(svc); + GF_ASSERT(options); - ret = dict_get_str (options, "rpc-auth-allow-insecure", - &allow_insecure_str); + ret = dict_get_str(options, "rpc-auth-allow-insecure", &allow_insecure_str); + if (0 == ret) { + ret = gf_string2boolean(allow_insecure_str, &is_allow_insecure); if (0 == ret) { - ret = gf_string2boolean (allow_insecure_str, - &is_allow_insecure); - if (0 == ret) { - if (_gf_true == is_allow_insecure) - svc->allow_insecure = 1; - else - svc->allow_insecure = 0; - } - } else { - /* By default set allow-insecure to true */ + if (_gf_true == is_allow_insecure) svc->allow_insecure = 1; - - /* setting in options for the sake of functions that look - * configuration params for allow insecure, eg: gf_auth - */ - ret = dict_set_str (options, "rpc-auth-allow-insecure", "on"); - if (ret < 0) - gf_log ("rpc-auth", GF_LOG_DEBUG, - "dict_set failed for 'allow-insecure'"); + else + svc->allow_insecure = 0; } + } else { + /* By default set allow-insecure to true */ + svc->allow_insecure = 1; - return ret; + /* setting in options for the sake of functions that look + * configuration params for allow insecure, eg: gf_auth + */ + ret = dict_set_str(options, "rpc-auth-allow-insecure", "on"); + if (ret < 0) + gf_log("rpc-auth", GF_LOG_DEBUG, + "dict_set failed for 'allow-insecure'"); + } + + return ret; } int -rpcsvc_set_root_squash (rpcsvc_t *svc, dict_t *options) +rpcsvc_set_root_squash(rpcsvc_t *svc, dict_t *options) { - int ret = -1; - uid_t anonuid = -1; - gid_t anongid = -1; - - GF_ASSERT (svc); - GF_ASSERT (options); - - ret = dict_get_str_boolean (options, "root-squash", 0); - if (ret != -1) - svc->root_squash = ret; - else - svc->root_squash = _gf_false; - - ret = dict_get_uint32 (options, "anonuid", &anonuid); - if (!ret) - svc->anonuid = anonuid; - else - svc->anonuid = RPC_NOBODY_UID; - - ret = dict_get_uint32 (options, "anongid", &anongid); - if (!ret) - svc->anongid = anongid; - else - svc->anongid = RPC_NOBODY_GID; - - if (svc->root_squash) - gf_log (GF_RPCSVC, GF_LOG_DEBUG, "root squashing enabled " - "(uid=%d, gid=%d)", svc->anonuid, svc->anongid); - - return 0; + int ret = -1; + uid_t anonuid = -1; + gid_t anongid = -1; + + GF_ASSERT(svc); + GF_ASSERT(options); + + ret = dict_get_str_boolean(options, "root-squash", 0); + if (ret != -1) + svc->root_squash = ret; + else + svc->root_squash = _gf_false; + + ret = dict_get_uint32(options, "anonuid", &anonuid); + if (!ret) + svc->anonuid = anonuid; + else + svc->anonuid = RPC_NOBODY_UID; + + ret = dict_get_uint32(options, "anongid", &anongid); + if (!ret) + svc->anongid = anongid; + else + svc->anongid = RPC_NOBODY_GID; + + if (svc->root_squash) + gf_log(GF_RPCSVC, GF_LOG_DEBUG, + "root squashing enabled " + "(uid=%d, gid=%d)", + svc->anonuid, svc->anongid); + + return 0; } int -rpcsvc_auth_init (rpcsvc_t *svc, dict_t *options) +rpcsvc_auth_init(rpcsvc_t *svc, dict_t *options) { - int ret = -1; - - if ((!svc) || (!options)) - return -1; - - (void) rpcsvc_set_allow_insecure (svc, options); - (void) rpcsvc_set_root_squash (svc, options); - (void) rpcsvc_set_addr_namelookup (svc, options); - ret = rpcsvc_auth_add_initers (svc); - if (ret == -1) { - gf_log (GF_RPCSVC, GF_LOG_ERROR, "Failed to add initers"); - goto out; - } - - ret = rpcsvc_auth_init_auths (svc, options); - if (ret == -1) { - gf_log (GF_RPCSVC, GF_LOG_ERROR, "Failed to init auth schemes"); - goto out; - } + int ret = -1; + + if ((!svc) || (!options)) + return -1; + + (void)rpcsvc_set_allow_insecure(svc, options); + (void)rpcsvc_set_root_squash(svc, options); + (void)rpcsvc_set_addr_namelookup(svc, options); + ret = rpcsvc_auth_add_initers(svc); + if (ret == -1) { + gf_log(GF_RPCSVC, GF_LOG_ERROR, "Failed to add initers"); + goto out; + } + + ret = rpcsvc_auth_init_auths(svc, options); + if (ret == -1) { + gf_log(GF_RPCSVC, GF_LOG_ERROR, "Failed to init auth schemes"); + goto out; + } out: - return ret; + return ret; } int -rpcsvc_auth_reconf (rpcsvc_t *svc, dict_t *options) +rpcsvc_auth_reconf(rpcsvc_t *svc, dict_t *options) { - int ret = 0; + int ret = 0; - if ((!svc) || (!options)) - return (-1); + if ((!svc) || (!options)) + return (-1); - ret = rpcsvc_set_allow_insecure (svc, options); - if (ret) - return (-1); + ret = rpcsvc_set_allow_insecure(svc, options); + if (ret) + return (-1); - ret = rpcsvc_set_root_squash (svc, options); - if (ret) - return (-1); + ret = rpcsvc_set_root_squash(svc, options); + if (ret) + return (-1); - return rpcsvc_set_addr_namelookup (svc, options); + return rpcsvc_set_addr_namelookup(svc, options); } - rpcsvc_auth_t * -__rpcsvc_auth_get_handler (rpcsvc_request_t *req) +__rpcsvc_auth_get_handler(rpcsvc_request_t *req) { - struct rpcsvc_auth_list *auth = NULL; - struct rpcsvc_auth_list *tmp = NULL; - rpcsvc_t *svc = NULL; - - if (!req) - return NULL; - - svc = req->svc; - if (!svc) { - gf_log (GF_RPCSVC, GF_LOG_ERROR, "!svc"); - goto err; - } - - if (list_empty (&svc->authschemes)) { - gf_log (GF_RPCSVC, GF_LOG_WARNING, "No authentication!"); - goto err; - } - - list_for_each_entry_safe (auth, tmp, &svc->authschemes, authlist) { - if (!auth->enable) - continue; - if (auth->auth->authnum == req->cred.flavour) - goto err; - - } - - auth = NULL; + struct rpcsvc_auth_list *auth = NULL; + struct rpcsvc_auth_list *tmp = NULL; + rpcsvc_t *svc = NULL; + + if (!req) + return NULL; + + svc = req->svc; + if (!svc) { + gf_log(GF_RPCSVC, GF_LOG_ERROR, "!svc"); + goto err; + } + + if (list_empty(&svc->authschemes)) { + gf_log(GF_RPCSVC, GF_LOG_WARNING, "No authentication!"); + goto err; + } + + list_for_each_entry_safe(auth, tmp, &svc->authschemes, authlist) + { + if (!auth->enable) + continue; + if (auth->auth->authnum == req->cred.flavour) + goto err; + } + + auth = NULL; err: - if (auth) - return auth->auth; - else - return NULL; + if (auth) + return auth->auth; + else + return NULL; } rpcsvc_auth_t * -rpcsvc_auth_get_handler (rpcsvc_request_t *req) +rpcsvc_auth_get_handler(rpcsvc_request_t *req) { - rpcsvc_auth_t *auth = NULL; + rpcsvc_auth_t *auth = NULL; - auth = __rpcsvc_auth_get_handler (req); - if (auth) - goto ret; + auth = __rpcsvc_auth_get_handler(req); + if (auth) + goto ret; - gf_log (GF_RPCSVC, GF_LOG_TRACE, "No auth handler: %d", - req->cred.flavour); + gf_log(GF_RPCSVC, GF_LOG_TRACE, "No auth handler: %d", req->cred.flavour); - /* The requested scheme was not available so fall back the to one - * scheme that will always be present. - */ - req->cred.flavour = AUTH_NULL; - req->verf.flavour = AUTH_NULL; - auth = __rpcsvc_auth_get_handler (req); + /* The requested scheme was not available so fall back the to one + * scheme that will always be present. + */ + req->cred.flavour = AUTH_NULL; + req->verf.flavour = AUTH_NULL; + auth = __rpcsvc_auth_get_handler(req); ret: - return auth; + return auth; } - int -rpcsvc_auth_request_init (rpcsvc_request_t *req, struct rpc_msg *callmsg) +rpcsvc_auth_request_init(rpcsvc_request_t *req, struct rpc_msg *callmsg) { - int32_t ret = 0; - rpcsvc_auth_t *auth = NULL; - - if (!req || !callmsg) { - ret = -1; - goto err; - } - - req->cred.flavour = rpc_call_cred_flavour (callmsg); - req->cred.datalen = rpc_call_cred_len (callmsg); - req->verf.flavour = rpc_call_verf_flavour (callmsg); - req->verf.datalen = rpc_call_verf_len (callmsg); - - auth = rpcsvc_auth_get_handler (req); - if (!auth) { - ret = -1; - goto err; - } - - gf_log (GF_RPCSVC, GF_LOG_TRACE, "Auth handler: %s", auth->authname); - - if (auth->authops->request_init) - ret = auth->authops->request_init (req, auth->authprivate); - - /* reset to auxgidlarge during - unsersialize if necessary */ - req->auxgids = req->auxgidsmall; - req->auxgidlarge = NULL; + int32_t ret = 0; + rpcsvc_auth_t *auth = NULL; + + if (!req || !callmsg) { + ret = -1; + goto err; + } + + req->cred.flavour = rpc_call_cred_flavour(callmsg); + req->cred.datalen = rpc_call_cred_len(callmsg); + req->verf.flavour = rpc_call_verf_flavour(callmsg); + req->verf.datalen = rpc_call_verf_len(callmsg); + + auth = rpcsvc_auth_get_handler(req); + if (!auth) { + ret = -1; + goto err; + } + + gf_log(GF_RPCSVC, GF_LOG_TRACE, "Auth handler: %s", auth->authname); + + if (auth->authops->request_init) + ret = auth->authops->request_init(req, auth->authprivate); + + /* reset to auxgidlarge during + unsersialize if necessary */ + req->auxgids = req->auxgidsmall; + req->auxgidlarge = NULL; err: - return ret; + return ret; } - int -rpcsvc_authenticate (rpcsvc_request_t *req) +rpcsvc_authenticate(rpcsvc_request_t *req) { - int ret = RPCSVC_AUTH_REJECT; - rpcsvc_auth_t *auth = NULL; - int minauth = 0; - - if (!req) - return ret; - - /* FIXME use rpcsvc_request_prog_minauth() */ - minauth = 0; - if (minauth > rpcsvc_request_cred_flavour (req)) { - gf_log (GF_RPCSVC, GF_LOG_WARNING, "Auth too weak"); - rpcsvc_request_set_autherr (req, AUTH_TOOWEAK); - goto err; - } + int ret = RPCSVC_AUTH_REJECT; + rpcsvc_auth_t *auth = NULL; + int minauth = 0; - auth = rpcsvc_auth_get_handler (req); - if (!auth) { - gf_log (GF_RPCSVC, GF_LOG_WARNING, "No auth handler found"); - goto err; - } + if (!req) + return ret; + + /* FIXME use rpcsvc_request_prog_minauth() */ + minauth = 0; + if (minauth > rpcsvc_request_cred_flavour(req)) { + gf_log(GF_RPCSVC, GF_LOG_WARNING, "Auth too weak"); + rpcsvc_request_set_autherr(req, AUTH_TOOWEAK); + goto err; + } + + auth = rpcsvc_auth_get_handler(req); + if (!auth) { + gf_log(GF_RPCSVC, GF_LOG_WARNING, "No auth handler found"); + goto err; + } - if (auth->authops->authenticate) - ret = auth->authops->authenticate (req, auth->authprivate); + if (auth->authops->authenticate) + ret = auth->authops->authenticate(req, auth->authprivate); err: - return ret; + return ret; } int -rpcsvc_auth_array (rpcsvc_t *svc, char *volname, int *autharr, int arrlen) +rpcsvc_auth_array(rpcsvc_t *svc, char *volname, int *autharr, int arrlen) { - int count = 0; - int result = RPCSVC_AUTH_REJECT; - char *srchstr = NULL; - int ret = 0; - - struct rpcsvc_auth_list *auth = NULL; - struct rpcsvc_auth_list *tmp = NULL; + int count = 0; + int result = RPCSVC_AUTH_REJECT; + char *srchstr = NULL; + int ret = 0; + + struct rpcsvc_auth_list *auth = NULL; + struct rpcsvc_auth_list *tmp = NULL; + + if ((!svc) || (!autharr) || (!volname)) + return -1; + + memset(autharr, 0, arrlen * sizeof(int)); + if (list_empty(&svc->authschemes)) { + gf_log(GF_RPCSVC, GF_LOG_ERROR, "No authentication!"); + goto err; + } + + list_for_each_entry_safe(auth, tmp, &svc->authschemes, authlist) + { + if (count >= arrlen) + break; + + result = gf_asprintf(&srchstr, "rpc-auth.%s.%s", auth->name, volname); + if (result == -1) { + count = -1; + goto err; + } - if ((!svc) || (!autharr) || (!volname)) - return -1; + ret = dict_get_str_boolean(svc->options, srchstr, 0xC00FFEE); + GF_FREE(srchstr); - memset (autharr, 0, arrlen * sizeof(int)); - if (list_empty (&svc->authschemes)) { - gf_log (GF_RPCSVC, GF_LOG_ERROR, "No authentication!"); - goto err; - } + switch (ret) { + case _gf_true: + autharr[count] = auth->auth->authnum; + ++count; + break; - list_for_each_entry_safe (auth, tmp, &svc->authschemes, authlist) { - if (count >= arrlen) - break; - - result = gf_asprintf (&srchstr, "rpc-auth.%s.%s", - auth->name, volname); - if (result == -1) { - count = -1; - goto err; - } - - ret = dict_get_str_boolean (svc->options, srchstr, 0xC00FFEE); - GF_FREE (srchstr); - - switch (ret) { - case _gf_true: - autharr[count] = auth->auth->authnum; - ++count; - break; - - default: - /* nothing to do */ - break; - } + default: + /* nothing to do */ + break; } + } err: - return count; + return count; } gid_t * -rpcsvc_auth_unix_auxgids (rpcsvc_request_t *req, int *arrlen) +rpcsvc_auth_unix_auxgids(rpcsvc_request_t *req, int *arrlen) { - if ((!req) || (!arrlen)) - return NULL; + if ((!req) || (!arrlen)) + return NULL; - /* In case of AUTH_NULL auxgids are not used */ - switch (req->cred.flavour) { + /* In case of AUTH_NULL auxgids are not used */ + switch (req->cred.flavour) { case AUTH_UNIX: case AUTH_GLUSTERFS: case AUTH_GLUSTERFS_v2: case AUTH_GLUSTERFS_v3: - break; + break; default: - gf_log ("rpc", GF_LOG_DEBUG, "auth type not unix or glusterfs"); - return NULL; - } + gf_log("rpc", GF_LOG_DEBUG, "auth type not unix or glusterfs"); + return NULL; + } - *arrlen = req->auxgidcount; - if (*arrlen == 0) - return NULL; + *arrlen = req->auxgidcount; + if (*arrlen == 0) + return NULL; - return &req->auxgids[0]; + return &req->auxgids[0]; } diff --git a/rpc/rpc-lib/src/rpcsvc.c b/rpc/rpc-lib/src/rpcsvc.c index c8aaf4c7fa9..c6545193a11 100644 --- a/rpc/rpc-lib/src/rpcsvc.c +++ b/rpc/rpc-lib/src/rpcsvc.c @@ -46,1175 +46,1176 @@ struct rpcsvc_program gluster_dump_prog; -#define rpcsvc_alloc_request(svc, request) \ - do { \ - request = (rpcsvc_request_t *)mem_get ((svc)->rxpool); \ - if (request) { \ - memset (request, 0, sizeof (rpcsvc_request_t)); \ - } else { \ - gf_log ("rpcsvc", GF_LOG_ERROR, \ - "error getting memory for rpc request"); \ - } \ - } while (0) +#define rpcsvc_alloc_request(svc, request) \ + do { \ + request = (rpcsvc_request_t *)mem_get((svc)->rxpool); \ + if (request) { \ + memset(request, 0, sizeof(rpcsvc_request_t)); \ + } else { \ + gf_log("rpcsvc", GF_LOG_ERROR, \ + "error getting memory for rpc request"); \ + } \ + } while (0) rpcsvc_listener_t * -rpcsvc_get_listener (rpcsvc_t *svc, uint16_t port, rpc_transport_t *trans); +rpcsvc_get_listener(rpcsvc_t *svc, uint16_t port, rpc_transport_t *trans); int -rpcsvc_notify (rpc_transport_t *trans, void *mydata, - rpc_transport_event_t event, void *data, ...); +rpcsvc_notify(rpc_transport_t *trans, void *mydata, rpc_transport_event_t event, + void *data, ...); static int -rpcsvc_match_subnet_v4 (const char *addrtok, const char *ipaddr); +rpcsvc_match_subnet_v4(const char *addrtok, const char *ipaddr); rpcsvc_notify_wrapper_t * -rpcsvc_notify_wrapper_alloc (void) +rpcsvc_notify_wrapper_alloc(void) { - rpcsvc_notify_wrapper_t *wrapper = NULL; + rpcsvc_notify_wrapper_t *wrapper = NULL; - wrapper = GF_CALLOC (1, sizeof (*wrapper), gf_common_mt_rpcsvc_wrapper_t); - if (!wrapper) { - goto out; - } + wrapper = GF_CALLOC(1, sizeof(*wrapper), gf_common_mt_rpcsvc_wrapper_t); + if (!wrapper) { + goto out; + } - INIT_LIST_HEAD (&wrapper->list); + INIT_LIST_HEAD(&wrapper->list); out: - return wrapper; + return wrapper; } - void -rpcsvc_listener_destroy (rpcsvc_listener_t *listener) +rpcsvc_listener_destroy(rpcsvc_listener_t *listener) { - rpcsvc_t *svc = NULL; + rpcsvc_t *svc = NULL; - if (!listener) { - goto out; - } + if (!listener) { + goto out; + } - svc = listener->svc; - if (!svc) { - goto listener_free; - } + svc = listener->svc; + if (!svc) { + goto listener_free; + } - pthread_rwlock_wrlock (&svc->rpclock); - { - list_del_init (&listener->list); - } - pthread_rwlock_unlock (&svc->rpclock); + pthread_rwlock_wrlock(&svc->rpclock); + { + list_del_init(&listener->list); + } + pthread_rwlock_unlock(&svc->rpclock); listener_free: - GF_FREE (listener); + GF_FREE(listener); out: - return; + return; } rpcsvc_vector_sizer -rpcsvc_get_program_vector_sizer (rpcsvc_t *svc, uint32_t prognum, - uint32_t progver, int procnum) +rpcsvc_get_program_vector_sizer(rpcsvc_t *svc, uint32_t prognum, + uint32_t progver, int procnum) { - rpcsvc_program_t *program = NULL; - char found = 0; + rpcsvc_program_t *program = NULL; + char found = 0; - if (!svc) - return NULL; + if (!svc) + return NULL; - pthread_rwlock_rdlock (&svc->rpclock); + pthread_rwlock_rdlock(&svc->rpclock); + { + /* Find the matching RPC program from registered list */ + list_for_each_entry(program, &svc->programs, program) { - /* Find the matching RPC program from registered list */ - list_for_each_entry (program, &svc->programs, program) { - if ((program->prognum == prognum) - && (program->progver == progver)) { - found = 1; - break; - } - } + if ((program->prognum == prognum) && + (program->progver == progver)) { + found = 1; + break; + } } - pthread_rwlock_unlock (&svc->rpclock); - - if (found) { - /* Make sure the requested procnum is supported by RPC prog */ - if ((procnum < 0) || (procnum >= program->numactors)) { - gf_log (GF_RPCSVC, GF_LOG_ERROR, - "RPC procedure %d not available for Program %s", - procnum, program->progname); - return NULL; - } + } + pthread_rwlock_unlock(&svc->rpclock); - /* SUCCESS: Supported procedure */ - return program->actors[procnum].vector_sizer; + if (found) { + /* Make sure the requested procnum is supported by RPC prog */ + if ((procnum < 0) || (procnum >= program->numactors)) { + gf_log(GF_RPCSVC, GF_LOG_ERROR, + "RPC procedure %d not available for Program %s", procnum, + program->progname); + return NULL; } - return NULL; /* FAIL */ + /* SUCCESS: Supported procedure */ + return program->actors[procnum].vector_sizer; + } + + return NULL; /* FAIL */ } gf_boolean_t -rpcsvc_can_outstanding_req_be_ignored (rpcsvc_request_t *req) -{ - /* - * If outstanding_rpc_limit is reached because of blocked locks and - * throttling is attempted then no unlock requests will be received. So - * the outstanding request count will never change i.e. it will always - * be equal to the limit. This also leads to ping timer expiry on - * client. - */ - - /* - * This is a hack and a necessity until grantedlock == fop completion. - * Ideally if we get a blocking lock request which cannot be granted - * right now, we should unwind the fop saying “request registered, will - * notify you when granted”, which is very hard to implement at the - * moment. Until we bring in such mechanism, we will need to live with - * not rate-limiting INODELK/ENTRYLK/LK fops - */ - - if ((req->prognum == GLUSTER_FOP_PROGRAM) && - (req->progver == GLUSTER_FOP_VERSION)) { - if ((req->procnum == GFS3_OP_INODELK) || - (req->procnum == GFS3_OP_FINODELK) || - (req->procnum == GFS3_OP_ENTRYLK) || - (req->procnum == GFS3_OP_FENTRYLK) || - (req->procnum == GFS3_OP_LK)) - return _gf_true; - } - return _gf_false; +rpcsvc_can_outstanding_req_be_ignored(rpcsvc_request_t *req) +{ + /* + * If outstanding_rpc_limit is reached because of blocked locks and + * throttling is attempted then no unlock requests will be received. So + * the outstanding request count will never change i.e. it will always + * be equal to the limit. This also leads to ping timer expiry on + * client. + */ + + /* + * This is a hack and a necessity until grantedlock == fop completion. + * Ideally if we get a blocking lock request which cannot be granted + * right now, we should unwind the fop saying “request registered, will + * notify you when granted”, which is very hard to implement at the + * moment. Until we bring in such mechanism, we will need to live with + * not rate-limiting INODELK/ENTRYLK/LK fops + */ + + if ((req->prognum == GLUSTER_FOP_PROGRAM) && + (req->progver == GLUSTER_FOP_VERSION)) { + if ((req->procnum == GFS3_OP_INODELK) || + (req->procnum == GFS3_OP_FINODELK) || + (req->procnum == GFS3_OP_ENTRYLK) || + (req->procnum == GFS3_OP_FENTRYLK) || (req->procnum == GFS3_OP_LK)) + return _gf_true; + } + return _gf_false; } int -rpcsvc_request_outstanding (rpcsvc_request_t *req, int delta) +rpcsvc_request_outstanding(rpcsvc_request_t *req, int delta) { - int ret = -1; - int old_count = 0; - int new_count = 0; - int limit = 0; - gf_boolean_t throttle = _gf_false; + int ret = -1; + int old_count = 0; + int new_count = 0; + int limit = 0; + gf_boolean_t throttle = _gf_false; - if (!req) - goto out; + if (!req) + goto out; - throttle = rpcsvc_get_throttle (req->svc); - if (!throttle) { - ret = 0; - goto out; - } + throttle = rpcsvc_get_throttle(req->svc); + if (!throttle) { + ret = 0; + goto out; + } - if (rpcsvc_can_outstanding_req_be_ignored (req)) { - ret = 0; - goto out; - } + if (rpcsvc_can_outstanding_req_be_ignored(req)) { + ret = 0; + goto out; + } - pthread_mutex_lock (&req->trans->lock); - { - limit = req->svc->outstanding_rpc_limit; - if (!limit) - goto unlock; + pthread_mutex_lock(&req->trans->lock); + { + limit = req->svc->outstanding_rpc_limit; + if (!limit) + goto unlock; - old_count = req->trans->outstanding_rpc_count; - req->trans->outstanding_rpc_count += delta; - new_count = req->trans->outstanding_rpc_count; + old_count = req->trans->outstanding_rpc_count; + req->trans->outstanding_rpc_count += delta; + new_count = req->trans->outstanding_rpc_count; - if (old_count <= limit && new_count > limit) - ret = rpc_transport_throttle (req->trans, _gf_true); + if (old_count <= limit && new_count > limit) + ret = rpc_transport_throttle(req->trans, _gf_true); - if (old_count > limit && new_count <= limit) - ret = rpc_transport_throttle (req->trans, _gf_false); - } + if (old_count > limit && new_count <= limit) + ret = rpc_transport_throttle(req->trans, _gf_false); + } unlock: - pthread_mutex_unlock (&req->trans->lock); + pthread_mutex_unlock(&req->trans->lock); out: - return ret; + return ret; } - /* This needs to change to returning errors, since * we need to return RPC specific error messages when some * of the pointers below are NULL. */ rpcsvc_actor_t * -rpcsvc_program_actor (rpcsvc_request_t *req) -{ - rpcsvc_program_t *program = NULL; - int err = SYSTEM_ERR; - rpcsvc_actor_t *actor = NULL; - rpcsvc_t *svc = NULL; - char found = 0; - char *peername = NULL; - - if (!req) - goto err; - - svc = req->svc; - peername = req->trans->peerinfo.identifier; - pthread_rwlock_rdlock (&svc->rpclock); +rpcsvc_program_actor(rpcsvc_request_t *req) +{ + rpcsvc_program_t *program = NULL; + int err = SYSTEM_ERR; + rpcsvc_actor_t *actor = NULL; + rpcsvc_t *svc = NULL; + char found = 0; + char *peername = NULL; + + if (!req) + goto err; + + svc = req->svc; + peername = req->trans->peerinfo.identifier; + pthread_rwlock_rdlock(&svc->rpclock); + { + list_for_each_entry(program, &svc->programs, program) { - list_for_each_entry (program, &svc->programs, program) { - if (program->prognum == req->prognum) { - err = PROG_MISMATCH; - } - - if ((program->prognum == req->prognum) - && (program->progver == req->progver)) { - found = 1; - break; - } - } - } - pthread_rwlock_unlock (&svc->rpclock); - - if (!found) { - if (err != PROG_MISMATCH) { - /* log in DEBUG when nfs clients try to see if - * ACL requests are accepted by nfs server - */ - gf_log (GF_RPCSVC, (req->prognum == ACL_PROGRAM) ? - GF_LOG_DEBUG : GF_LOG_WARNING, - "RPC program not available (req %u %u) for %s", - req->prognum, req->progver, - peername); - err = PROG_UNAVAIL; - goto err; - } + if (program->prognum == req->prognum) { + err = PROG_MISMATCH; + } - gf_log (GF_RPCSVC, GF_LOG_WARNING, - "RPC program version not available (req %u %u) for %s", - req->prognum, req->progver, - peername); - goto err; - } - req->prog = program; - if (!program->actors) { - gf_log (GF_RPCSVC, GF_LOG_WARNING, - "RPC Actor not found for program %s %d for %s", - program->progname, program->prognum, - peername); - err = SYSTEM_ERR; - goto err; - } - - if ((req->procnum < 0) || (req->procnum >= program->numactors)) { - gf_log (GF_RPCSVC, GF_LOG_ERROR, "RPC Program procedure not" - " available for procedure %d in %s for %s", - req->procnum, program->progname, - peername); - err = PROC_UNAVAIL; - goto err; - } - - actor = &program->actors[req->procnum]; - if (!actor->actor) { - gf_log (GF_RPCSVC, GF_LOG_ERROR, "RPC Program procedure not" - " available for procedure %d in %s for %s", - req->procnum, program->progname, - peername); - err = PROC_UNAVAIL; - actor = NULL; - goto err; - } - - req->ownthread = program->ownthread; - req->synctask = program->synctask; - - err = SUCCESS; - gf_log (GF_RPCSVC, GF_LOG_TRACE, "Actor found: %s - %s for %s", - program->progname, actor->procname, - peername); + if ((program->prognum == req->prognum) && + (program->progver == req->progver)) { + found = 1; + break; + } + } + } + pthread_rwlock_unlock(&svc->rpclock); + + if (!found) { + if (err != PROG_MISMATCH) { + /* log in DEBUG when nfs clients try to see if + * ACL requests are accepted by nfs server + */ + gf_log( + GF_RPCSVC, + (req->prognum == ACL_PROGRAM) ? GF_LOG_DEBUG : GF_LOG_WARNING, + "RPC program not available (req %u %u) for %s", req->prognum, + req->progver, peername); + err = PROG_UNAVAIL; + goto err; + } + + gf_log(GF_RPCSVC, GF_LOG_WARNING, + "RPC program version not available (req %u %u) for %s", + req->prognum, req->progver, peername); + goto err; + } + req->prog = program; + if (!program->actors) { + gf_log(GF_RPCSVC, GF_LOG_WARNING, + "RPC Actor not found for program %s %d for %s", + program->progname, program->prognum, peername); + err = SYSTEM_ERR; + goto err; + } + + if ((req->procnum < 0) || (req->procnum >= program->numactors)) { + gf_log(GF_RPCSVC, GF_LOG_ERROR, + "RPC Program procedure not" + " available for procedure %d in %s for %s", + req->procnum, program->progname, peername); + err = PROC_UNAVAIL; + goto err; + } + + actor = &program->actors[req->procnum]; + if (!actor->actor) { + gf_log(GF_RPCSVC, GF_LOG_ERROR, + "RPC Program procedure not" + " available for procedure %d in %s for %s", + req->procnum, program->progname, peername); + err = PROC_UNAVAIL; + actor = NULL; + goto err; + } + + req->ownthread = program->ownthread; + req->synctask = program->synctask; + + err = SUCCESS; + gf_log(GF_RPCSVC, GF_LOG_TRACE, "Actor found: %s - %s for %s", + program->progname, actor->procname, peername); err: - if (req) - req->rpc_err = err; + if (req) + req->rpc_err = err; - return actor; + return actor; } - /* this procedure can only pass 4 arguments to registered notifyfn. To send more * arguments call wrapper->notify directly. */ static void -rpcsvc_program_notify (rpcsvc_listener_t *listener, rpcsvc_event_t event, - void *data) +rpcsvc_program_notify(rpcsvc_listener_t *listener, rpcsvc_event_t event, + void *data) { - rpcsvc_notify_wrapper_t *wrapper = NULL; + rpcsvc_notify_wrapper_t *wrapper = NULL; - if (!listener) { - goto out; - } + if (!listener) { + goto out; + } - list_for_each_entry (wrapper, &listener->svc->notify, list) { - if (wrapper->notify) { - wrapper->notify (listener->svc, - wrapper->data, - event, data); - } + list_for_each_entry(wrapper, &listener->svc->notify, list) + { + if (wrapper->notify) { + wrapper->notify(listener->svc, wrapper->data, event, data); } + } out: - return; + return; } - static int -rpcsvc_accept (rpcsvc_t *svc, rpc_transport_t *listen_trans, - rpc_transport_t *new_trans) +rpcsvc_accept(rpcsvc_t *svc, rpc_transport_t *listen_trans, + rpc_transport_t *new_trans) { - rpcsvc_listener_t *listener = NULL; - int32_t ret = -1; + rpcsvc_listener_t *listener = NULL; + int32_t ret = -1; - listener = rpcsvc_get_listener (svc, -1, listen_trans); - if (listener == NULL) { - goto out; - } + listener = rpcsvc_get_listener(svc, -1, listen_trans); + if (listener == NULL) { + goto out; + } - rpcsvc_program_notify (listener, RPCSVC_EVENT_ACCEPT, new_trans); - ret = 0; + rpcsvc_program_notify(listener, RPCSVC_EVENT_ACCEPT, new_trans); + ret = 0; out: - return ret; + return ret; } - void -rpcsvc_request_destroy (rpcsvc_request_t *req) +rpcsvc_request_destroy(rpcsvc_request_t *req) { - if (!req) { - goto out; - } + if (!req) { + goto out; + } - if (req->iobref) { - iobref_unref (req->iobref); - } + if (req->iobref) { + iobref_unref(req->iobref); + } - /* This marks the "end" of an RPC request. Reply is - completely written to the socket and is on the way - to the client. It is time to decrement the - outstanding request counter by 1. - */ - if (req->prognum) //Only for initialized requests - rpcsvc_request_outstanding (req, -1); + /* This marks the "end" of an RPC request. Reply is + completely written to the socket and is on the way + to the client. It is time to decrement the + outstanding request counter by 1. + */ + if (req->prognum) // Only for initialized requests + rpcsvc_request_outstanding(req, -1); - rpc_transport_unref (req->trans); + rpc_transport_unref(req->trans); - GF_FREE (req->auxgidlarge); + GF_FREE(req->auxgidlarge); - mem_put (req); + mem_put(req); out: - return; + return; } - rpcsvc_request_t * -rpcsvc_request_init (rpcsvc_t *svc, rpc_transport_t *trans, - struct rpc_msg *callmsg, - struct iovec progmsg, rpc_transport_pollin_t *msg, - rpcsvc_request_t *req) +rpcsvc_request_init(rpcsvc_t *svc, rpc_transport_t *trans, + struct rpc_msg *callmsg, struct iovec progmsg, + rpc_transport_pollin_t *msg, rpcsvc_request_t *req) { - int i = 0; - - if ((!trans) || (!callmsg)|| (!req) || (!msg)) - return NULL; + int i = 0; - /* We start a RPC request as always denied. */ - req->rpc_status = MSG_DENIED; - req->xid = rpc_call_xid (callmsg); - req->prognum = rpc_call_program (callmsg); - req->progver = rpc_call_progver (callmsg); - req->procnum = rpc_call_progproc (callmsg); - req->trans = rpc_transport_ref (trans); - req->count = msg->count; - req->msg[0] = progmsg; - req->iobref = iobref_ref (msg->iobref); - if (msg->vectored) { - /* msg->vector[MAX_IOVEC] is defined in structure. prevent a - out of bound access */ - for (i = 1; i < min (msg->count, MAX_IOVEC); i++) { - req->msg[i] = msg->vector[i]; - } - } - - req->svc = svc; - req->trans_private = msg->private; - - INIT_LIST_HEAD (&req->txlist); - INIT_LIST_HEAD (&req->request_list); - req->payloadsize = 0; + if ((!trans) || (!callmsg) || (!req) || (!msg)) + return NULL; - /* By this time, the data bytes for the auth scheme would have already - * been copied into the required sections of the req structure, - * we just need to fill in the meta-data about it now. - */ - rpcsvc_auth_request_init (req, callmsg); - return req; + /* We start a RPC request as always denied. */ + req->rpc_status = MSG_DENIED; + req->xid = rpc_call_xid(callmsg); + req->prognum = rpc_call_program(callmsg); + req->progver = rpc_call_progver(callmsg); + req->procnum = rpc_call_progproc(callmsg); + req->trans = rpc_transport_ref(trans); + req->count = msg->count; + req->msg[0] = progmsg; + req->iobref = iobref_ref(msg->iobref); + if (msg->vectored) { + /* msg->vector[MAX_IOVEC] is defined in structure. prevent a + out of bound access */ + for (i = 1; i < min(msg->count, MAX_IOVEC); i++) { + req->msg[i] = msg->vector[i]; + } + } + + req->svc = svc; + req->trans_private = msg->private; + + INIT_LIST_HEAD(&req->txlist); + INIT_LIST_HEAD(&req->request_list); + req->payloadsize = 0; + + /* By this time, the data bytes for the auth scheme would have already + * been copied into the required sections of the req structure, + * we just need to fill in the meta-data about it now. + */ + rpcsvc_auth_request_init(req, callmsg); + return req; } - rpcsvc_request_t * -rpcsvc_request_create (rpcsvc_t *svc, rpc_transport_t *trans, - rpc_transport_pollin_t *msg) +rpcsvc_request_create(rpcsvc_t *svc, rpc_transport_t *trans, + rpc_transport_pollin_t *msg) { - char *msgbuf = NULL; - struct rpc_msg rpcmsg; - struct iovec progmsg; /* RPC Program payload */ - rpcsvc_request_t *req = NULL; - size_t msglen = 0; - int ret = -1; - - if (!svc || !trans || !svc->rxpool) - return NULL; - - /* We need to allocate the request before actually calling - * rpcsvc_request_init on the request so that we, can fill the auth - * data directly into the request structure from the message iobuf. - * This avoids a need to keep a temp buffer into which the auth data - * would've been copied otherwise. - */ - rpcsvc_alloc_request (svc, req); - if (!req) { - goto err; - } - - msgbuf = msg->vector[0].iov_base; - msglen = msg->vector[0].iov_len; - - ret = xdr_to_rpc_call (msgbuf, msglen, &rpcmsg, &progmsg, - req->cred.authdata,req->verf.authdata); - - if (ret == -1) { - gf_log (GF_RPCSVC, GF_LOG_WARNING, "RPC call decoding failed"); - rpcsvc_request_seterr (req, GARBAGE_ARGS); - req->trans = rpc_transport_ref (trans); - req->svc = svc; - goto err; - } - - ret = -1; - rpcsvc_request_init (svc, trans, &rpcmsg, progmsg, msg, req); - - gf_log (GF_RPCSVC, GF_LOG_TRACE, "received rpc-message " - "(XID: 0x%" GF_PRI_RPC_XID ", Ver: %" GF_PRI_RPC_VERSION ", Program: %" GF_PRI_RPC_PROG_ID ", " - "ProgVers: %" GF_PRI_RPC_PROG_VERS ", Proc: %" GF_PRI_RPC_PROC ") " - "from rpc-transport (%s)", rpc_call_xid (&rpcmsg), - rpc_call_rpcvers (&rpcmsg), rpc_call_program (&rpcmsg), - rpc_call_progver (&rpcmsg), rpc_call_progproc (&rpcmsg), - trans->name); - - /* We just received a new request from the wire. Account for - it in the outsanding request counter to make sure we don't - ingest too many concurrent requests from the same client. - */ - if (req->prognum) //Only for initialized requests - ret = rpcsvc_request_outstanding (req, +1); - - if (rpc_call_rpcvers (&rpcmsg) != 2) { - /* LOG- TODO: print rpc version, also print the peerinfo - from transport */ - gf_log (GF_RPCSVC, GF_LOG_ERROR, "RPC version not supported " - "(XID: 0x%" GF_PRI_RPC_XID ", Ver: %" GF_PRI_RPC_VERSION ", Program: %" GF_PRI_RPC_PROG_ID ", " - "ProgVers: %" GF_PRI_RPC_PROG_VERS ", Proc: %" GF_PRI_RPC_PROC ") " - "from trans (%s)", rpc_call_xid (&rpcmsg), - rpc_call_rpcvers (&rpcmsg), rpc_call_program (&rpcmsg), - rpc_call_progver (&rpcmsg), rpc_call_progproc (&rpcmsg), - trans->name); - rpcsvc_request_seterr (req, RPC_MISMATCH); - goto err; - } - - ret = rpcsvc_authenticate (req); - if (ret == RPCSVC_AUTH_REJECT) { - /* No need to set auth_err, that is the responsibility of - * the authentication handler since only that know what exact - * error happened. - */ - rpcsvc_request_seterr (req, AUTH_ERROR); - gf_log (GF_RPCSVC, GF_LOG_ERROR, "auth failed on request. " - "(XID: 0x%" GF_PRI_RPC_XID ", Ver: %" GF_PRI_RPC_VERSION ", Program: %" GF_PRI_RPC_PROG_ID ", " - "ProgVers: %" GF_PRI_RPC_PROG_VERS ", Proc: %" GF_PRI_RPC_PROC ") " - "from trans (%s)", rpc_call_xid (&rpcmsg), - rpc_call_rpcvers (&rpcmsg), rpc_call_program (&rpcmsg), - rpc_call_progver (&rpcmsg), rpc_call_progproc (&rpcmsg), - trans->name); - ret = -1; - goto err; - } + char *msgbuf = NULL; + struct rpc_msg rpcmsg; + struct iovec progmsg; /* RPC Program payload */ + rpcsvc_request_t *req = NULL; + size_t msglen = 0; + int ret = -1; + if (!svc || !trans || !svc->rxpool) + return NULL; - /* If the error is not RPC_MISMATCH, we consider the call as accepted - * since we are not handling authentication failures for now. + /* We need to allocate the request before actually calling + * rpcsvc_request_init on the request so that we, can fill the auth + * data directly into the request structure from the message iobuf. + * This avoids a need to keep a temp buffer into which the auth data + * would've been copied otherwise. + */ + rpcsvc_alloc_request(svc, req); + if (!req) { + goto err; + } + + msgbuf = msg->vector[0].iov_base; + msglen = msg->vector[0].iov_len; + + ret = xdr_to_rpc_call(msgbuf, msglen, &rpcmsg, &progmsg, req->cred.authdata, + req->verf.authdata); + + if (ret == -1) { + gf_log(GF_RPCSVC, GF_LOG_WARNING, "RPC call decoding failed"); + rpcsvc_request_seterr(req, GARBAGE_ARGS); + req->trans = rpc_transport_ref(trans); + req->svc = svc; + goto err; + } + + ret = -1; + rpcsvc_request_init(svc, trans, &rpcmsg, progmsg, msg, req); + + gf_log(GF_RPCSVC, GF_LOG_TRACE, + "received rpc-message " + "(XID: 0x%" GF_PRI_RPC_XID ", Ver: %" GF_PRI_RPC_VERSION + ", Program: %" GF_PRI_RPC_PROG_ID + ", " + "ProgVers: %" GF_PRI_RPC_PROG_VERS ", Proc: %" GF_PRI_RPC_PROC + ") " + "from rpc-transport (%s)", + rpc_call_xid(&rpcmsg), rpc_call_rpcvers(&rpcmsg), + rpc_call_program(&rpcmsg), rpc_call_progver(&rpcmsg), + rpc_call_progproc(&rpcmsg), trans->name); + + /* We just received a new request from the wire. Account for + it in the outsanding request counter to make sure we don't + ingest too many concurrent requests from the same client. + */ + if (req->prognum) // Only for initialized requests + ret = rpcsvc_request_outstanding(req, +1); + + if (rpc_call_rpcvers(&rpcmsg) != 2) { + /* LOG- TODO: print rpc version, also print the peerinfo + from transport */ + gf_log(GF_RPCSVC, GF_LOG_ERROR, + "RPC version not supported " + "(XID: 0x%" GF_PRI_RPC_XID ", Ver: %" GF_PRI_RPC_VERSION + ", Program: %" GF_PRI_RPC_PROG_ID + ", " + "ProgVers: %" GF_PRI_RPC_PROG_VERS ", Proc: %" GF_PRI_RPC_PROC + ") " + "from trans (%s)", + rpc_call_xid(&rpcmsg), rpc_call_rpcvers(&rpcmsg), + rpc_call_program(&rpcmsg), rpc_call_progver(&rpcmsg), + rpc_call_progproc(&rpcmsg), trans->name); + rpcsvc_request_seterr(req, RPC_MISMATCH); + goto err; + } + + ret = rpcsvc_authenticate(req); + if (ret == RPCSVC_AUTH_REJECT) { + /* No need to set auth_err, that is the responsibility of + * the authentication handler since only that know what exact + * error happened. */ - req->rpc_status = MSG_ACCEPTED; - req->reply = NULL; - ret = 0; + rpcsvc_request_seterr(req, AUTH_ERROR); + gf_log(GF_RPCSVC, GF_LOG_ERROR, + "auth failed on request. " + "(XID: 0x%" GF_PRI_RPC_XID ", Ver: %" GF_PRI_RPC_VERSION + ", Program: %" GF_PRI_RPC_PROG_ID + ", " + "ProgVers: %" GF_PRI_RPC_PROG_VERS ", Proc: %" GF_PRI_RPC_PROC + ") " + "from trans (%s)", + rpc_call_xid(&rpcmsg), rpc_call_rpcvers(&rpcmsg), + rpc_call_program(&rpcmsg), rpc_call_progver(&rpcmsg), + rpc_call_progproc(&rpcmsg), trans->name); + ret = -1; + goto err; + } + + /* If the error is not RPC_MISMATCH, we consider the call as accepted + * since we are not handling authentication failures for now. + */ + req->rpc_status = MSG_ACCEPTED; + req->reply = NULL; + ret = 0; err: - if (ret == -1) { - ret = rpcsvc_error_reply (req); - if (ret) - gf_log ("rpcsvc", GF_LOG_WARNING, - "failed to queue error reply"); - req = NULL; - } + if (ret == -1) { + ret = rpcsvc_error_reply(req); + if (ret) + gf_log("rpcsvc", GF_LOG_WARNING, "failed to queue error reply"); + req = NULL; + } - return req; + return req; } - int -rpcsvc_check_and_reply_error (int ret, call_frame_t *frame, void *opaque) +rpcsvc_check_and_reply_error(int ret, call_frame_t *frame, void *opaque) { - rpcsvc_request_t *req = NULL; + rpcsvc_request_t *req = NULL; + + req = opaque; - req = opaque; + if (ret) + gf_log("rpcsvc", GF_LOG_ERROR, + "rpc actor (%d:%d:%d) failed to complete successfully", + req->prognum, req->progver, req->procnum); + if (ret == RPCSVC_ACTOR_ERROR) { + ret = rpcsvc_error_reply(req); if (ret) - gf_log ("rpcsvc", GF_LOG_ERROR, - "rpc actor (%d:%d:%d) failed to complete successfully", - req->prognum, req->progver, req->procnum); - - if (ret == RPCSVC_ACTOR_ERROR) { - ret = rpcsvc_error_reply (req); - if (ret) - gf_log ("rpcsvc", GF_LOG_WARNING, - "failed to queue error reply"); - } + gf_log("rpcsvc", GF_LOG_WARNING, "failed to queue error reply"); + } - return 0; + return 0; } int -rpcsvc_handle_rpc_call (rpcsvc_t *svc, rpc_transport_t *trans, - rpc_transport_pollin_t *msg) -{ - rpcsvc_actor_t *actor = NULL; - rpcsvc_actor actor_fn = NULL; - rpcsvc_request_t *req = NULL; - int ret = -1; - uint16_t port = 0; - gf_boolean_t is_unix = _gf_false, empty = _gf_false; - gf_boolean_t unprivileged = _gf_false; - drc_cached_op_t *reply = NULL; - rpcsvc_drc_globals_t *drc = NULL; - - if (!trans || !svc) - return -1; - - switch (trans->peerinfo.sockaddr.ss_family) { +rpcsvc_handle_rpc_call(rpcsvc_t *svc, rpc_transport_t *trans, + rpc_transport_pollin_t *msg) +{ + rpcsvc_actor_t *actor = NULL; + rpcsvc_actor actor_fn = NULL; + rpcsvc_request_t *req = NULL; + int ret = -1; + uint16_t port = 0; + gf_boolean_t is_unix = _gf_false, empty = _gf_false; + gf_boolean_t unprivileged = _gf_false; + drc_cached_op_t *reply = NULL; + rpcsvc_drc_globals_t *drc = NULL; + + if (!trans || !svc) + return -1; + + switch (trans->peerinfo.sockaddr.ss_family) { case AF_INET: - port = ((struct sockaddr_in *)&trans->peerinfo.sockaddr)->sin_port; - break; + port = ((struct sockaddr_in *)&trans->peerinfo.sockaddr)->sin_port; + break; case AF_INET6: - port = ((struct sockaddr_in6 *)&trans->peerinfo.sockaddr)->sin6_port; - break; + port = ((struct sockaddr_in6 *)&trans->peerinfo.sockaddr) + ->sin6_port; + break; case AF_UNIX: - is_unix = _gf_true; - break; + is_unix = _gf_true; + break; default: - gf_log (GF_RPCSVC, GF_LOG_ERROR, - "invalid address family (%d)", - trans->peerinfo.sockaddr.ss_family); - return -1; - } + gf_log(GF_RPCSVC, GF_LOG_ERROR, "invalid address family (%d)", + trans->peerinfo.sockaddr.ss_family); + return -1; + } + if (is_unix == _gf_false) { + port = ntohs(port); + gf_log("rpcsvc", GF_LOG_TRACE, "Client port: %d", (int)port); - if (is_unix == _gf_false) { - port = ntohs (port); + if (port >= 1024) + unprivileged = _gf_true; + } - gf_log ("rpcsvc", GF_LOG_TRACE, "Client port: %d", (int)port); + req = rpcsvc_request_create(svc, trans, msg); + if (!req) + goto out; - if (port >= 1024) - unprivileged = _gf_true; - } + if (!rpcsvc_request_accepted(req)) + goto err_reply; + + actor = rpcsvc_program_actor(req); + if (!actor) + goto err_reply; + + if (0 == svc->allow_insecure && unprivileged && !actor->unprivileged) { + /* Non-privileged user, fail request */ + gf_log(GF_RPCSVC, GF_LOG_ERROR, + "Request received from non-" + "privileged port. Failing request for %s.", + req->trans->peerinfo.identifier); + req->rpc_status = MSG_DENIED; + req->rpc_err = AUTH_ERROR; + req->auth_err = RPCSVC_AUTH_REJECT; + goto err_reply; + } - req = rpcsvc_request_create (svc, trans, msg); - if (!req) + /* DRC */ + if (rpcsvc_need_drc(req)) { + drc = req->svc->drc; + + LOCK(&drc->lock); + { + reply = rpcsvc_drc_lookup(req); + + /* retransmission of completed request, send cached reply */ + if (reply && reply->state == DRC_OP_CACHED) { + gf_log(GF_RPCSVC, GF_LOG_INFO, + "duplicate request:" + " XID: 0x%x", + req->xid); + ret = rpcsvc_send_cached_reply(req, reply); + drc->cache_hits++; + UNLOCK(&drc->lock); + goto out; + + } /* retransmitted request, original op in transit, drop it */ + else if (reply && reply->state == DRC_OP_IN_TRANSIT) { + gf_log(GF_RPCSVC, GF_LOG_INFO, + "op in transit," + " discarding. XID: 0x%x", + req->xid); + ret = 0; + drc->intransit_hits++; + rpcsvc_request_destroy(req); + UNLOCK(&drc->lock); goto out; - if (!rpcsvc_request_accepted (req)) - goto err_reply; - - actor = rpcsvc_program_actor (req); - if (!actor) - goto err_reply; - - if (0 == svc->allow_insecure && unprivileged && !actor->unprivileged) { - /* Non-privileged user, fail request */ - gf_log (GF_RPCSVC, GF_LOG_ERROR, - "Request received from non-" - "privileged port. Failing request for %s.", - req->trans->peerinfo.identifier); - req->rpc_status = MSG_DENIED; - req->rpc_err = AUTH_ERROR; - req->auth_err = RPCSVC_AUTH_REJECT; - goto err_reply; + } /* fresh request, cache it as in-transit and proceed */ + else { + ret = rpcsvc_cache_request(req); + } } + UNLOCK(&drc->lock); + } - /* DRC */ - if (rpcsvc_need_drc (req)) { - drc = req->svc->drc; - - LOCK (&drc->lock); - { - reply = rpcsvc_drc_lookup (req); - - /* retransmission of completed request, send cached reply */ - if (reply && reply->state == DRC_OP_CACHED) { - gf_log (GF_RPCSVC, GF_LOG_INFO, "duplicate request:" - " XID: 0x%x", req->xid); - ret = rpcsvc_send_cached_reply (req, reply); - drc->cache_hits++; - UNLOCK (&drc->lock); - goto out; - - } /* retransmitted request, original op in transit, drop it */ - else if (reply && reply->state == DRC_OP_IN_TRANSIT) { - gf_log (GF_RPCSVC, GF_LOG_INFO, "op in transit," - " discarding. XID: 0x%x", req->xid); - ret = 0; - drc->intransit_hits++; - rpcsvc_request_destroy (req); - UNLOCK (&drc->lock); - goto out; - - } /* fresh request, cache it as in-transit and proceed */ - else { - ret = rpcsvc_cache_request (req); - } - } - UNLOCK (&drc->lock); + if (req->rpc_err == SUCCESS) { + /* Before going to xlator code, set the THIS properly */ + THIS = svc->xl; + + actor_fn = actor->actor; + + if (!actor_fn) { + rpcsvc_request_seterr(req, PROC_UNAVAIL); + /* LOG TODO: print more info about procnum, + prognum etc, also print transport info */ + gf_log(GF_RPCSVC, GF_LOG_ERROR, "No vectored handler present"); + ret = RPCSVC_ACTOR_ERROR; + goto err_reply; } - if (req->rpc_err == SUCCESS) { - /* Before going to xlator code, set the THIS properly */ - THIS = svc->xl; + if (req->synctask) { + ret = synctask_new(THIS->ctx->env, (synctask_fn_t)actor_fn, + rpcsvc_check_and_reply_error, NULL, req); + } else if (req->ownthread) { + pthread_mutex_lock(&req->prog->queue_lock); + { + empty = list_empty(&req->prog->request_queue); - actor_fn = actor->actor; + list_add_tail(&req->request_list, &req->prog->request_queue); - if (!actor_fn) { - rpcsvc_request_seterr (req, PROC_UNAVAIL); - /* LOG TODO: print more info about procnum, - prognum etc, also print transport info */ - gf_log (GF_RPCSVC, GF_LOG_ERROR, - "No vectored handler present"); - ret = RPCSVC_ACTOR_ERROR; - goto err_reply; - } + if (empty) + pthread_cond_signal(&req->prog->queue_cond); + } + pthread_mutex_unlock(&req->prog->queue_lock); - if (req->synctask) { - ret = synctask_new (THIS->ctx->env, - (synctask_fn_t) actor_fn, - rpcsvc_check_and_reply_error, NULL, - req); - } else if (req->ownthread) { - pthread_mutex_lock (&req->prog->queue_lock); - { - empty = list_empty (&req->prog->request_queue); - - list_add_tail (&req->request_list, - &req->prog->request_queue); - - if (empty) - pthread_cond_signal (&req->prog->queue_cond); - } - pthread_mutex_unlock (&req->prog->queue_lock); - - ret = 0; - } else { - ret = actor_fn (req); - } + ret = 0; + } else { + ret = actor_fn(req); } + } err_reply: - ret = rpcsvc_check_and_reply_error (ret, NULL, req); - /* No need to propagate error beyond this function since the reply - * has now been queued. */ - ret = 0; + ret = rpcsvc_check_and_reply_error(ret, NULL, req); + /* No need to propagate error beyond this function since the reply + * has now been queued. */ + ret = 0; out: - return ret; + return ret; } - int -rpcsvc_handle_disconnect (rpcsvc_t *svc, rpc_transport_t *trans) +rpcsvc_handle_disconnect(rpcsvc_t *svc, rpc_transport_t *trans) { - rpcsvc_event_t event; - rpcsvc_notify_wrapper_t *wrappers = NULL, *wrapper; - int32_t ret = -1, i = 0, wrapper_count = 0; - rpcsvc_listener_t *listener = NULL; - - event = (trans->listener == NULL) ? RPCSVC_EVENT_LISTENER_DEAD - : RPCSVC_EVENT_DISCONNECT; + rpcsvc_event_t event; + rpcsvc_notify_wrapper_t *wrappers = NULL, *wrapper; + int32_t ret = -1, i = 0, wrapper_count = 0; + rpcsvc_listener_t *listener = NULL; - pthread_rwlock_rdlock (&svc->rpclock); - { - if (!svc->notify_count) - goto unlock; + event = (trans->listener == NULL) ? RPCSVC_EVENT_LISTENER_DEAD + : RPCSVC_EVENT_DISCONNECT; - wrappers = GF_CALLOC (svc->notify_count, sizeof (*wrapper), - gf_common_mt_rpcsvc_wrapper_t); - if (!wrappers) { - goto unlock; - } + pthread_rwlock_rdlock(&svc->rpclock); + { + if (!svc->notify_count) + goto unlock; - list_for_each_entry (wrapper, &svc->notify, list) { - if (wrapper->notify) { - wrappers[i++] = *wrapper; - } - } + wrappers = GF_CALLOC(svc->notify_count, sizeof(*wrapper), + gf_common_mt_rpcsvc_wrapper_t); + if (!wrappers) { + goto unlock; + } - wrapper_count = i; + list_for_each_entry(wrapper, &svc->notify, list) + { + if (wrapper->notify) { + wrappers[i++] = *wrapper; + } } -unlock: - pthread_rwlock_unlock (&svc->rpclock); - if (wrappers) { - for (i = 0; i < wrapper_count; i++) { - wrappers[i].notify (svc, wrappers[i].data, - event, trans); - } + wrapper_count = i; + } +unlock: + pthread_rwlock_unlock(&svc->rpclock); - GF_FREE (wrappers); + if (wrappers) { + for (i = 0; i < wrapper_count; i++) { + wrappers[i].notify(svc, wrappers[i].data, event, trans); } - if (event == RPCSVC_EVENT_LISTENER_DEAD) { - listener = rpcsvc_get_listener (svc, -1, trans->listener); - rpcsvc_listener_destroy (listener); - } + GF_FREE(wrappers); + } - return ret; -} + if (event == RPCSVC_EVENT_LISTENER_DEAD) { + listener = rpcsvc_get_listener(svc, -1, trans->listener); + rpcsvc_listener_destroy(listener); + } + return ret; +} int -rpcsvc_notify (rpc_transport_t *trans, void *mydata, - rpc_transport_event_t event, void *data, ...) +rpcsvc_notify(rpc_transport_t *trans, void *mydata, rpc_transport_event_t event, + void *data, ...) { - int ret = -1; - rpc_transport_pollin_t *msg = NULL; - rpc_transport_t *new_trans = NULL; - rpcsvc_t *svc = NULL; - rpcsvc_listener_t *listener = NULL; + int ret = -1; + rpc_transport_pollin_t *msg = NULL; + rpc_transport_t *new_trans = NULL; + rpcsvc_t *svc = NULL; + rpcsvc_listener_t *listener = NULL; - svc = mydata; - if (svc == NULL) { - goto out; - } + svc = mydata; + if (svc == NULL) { + goto out; + } - switch (event) { + switch (event) { case RPC_TRANSPORT_ACCEPT: - new_trans = data; - ret = rpcsvc_accept (svc, trans, new_trans); - break; + new_trans = data; + ret = rpcsvc_accept(svc, trans, new_trans); + break; case RPC_TRANSPORT_DISCONNECT: - ret = rpcsvc_handle_disconnect (svc, trans); - break; + ret = rpcsvc_handle_disconnect(svc, trans); + break; case RPC_TRANSPORT_MSG_RECEIVED: - msg = data; - ret = rpcsvc_handle_rpc_call (svc, trans, msg); - break; + msg = data; + ret = rpcsvc_handle_rpc_call(svc, trans, msg); + break; case RPC_TRANSPORT_MSG_SENT: - ret = 0; - break; + ret = 0; + break; case RPC_TRANSPORT_CONNECT: - /* do nothing, no need for rpcsvc to handle this, client should - * handle this event - */ - /* print info about transport too : LOG TODO */ - gf_log ("rpcsvc", GF_LOG_CRITICAL, - "got CONNECT event, which should have not come"); - ret = 0; - break; + /* do nothing, no need for rpcsvc to handle this, client should + * handle this event + */ + /* print info about transport too : LOG TODO */ + gf_log("rpcsvc", GF_LOG_CRITICAL, + "got CONNECT event, which should have not come"); + ret = 0; + break; case RPC_TRANSPORT_CLEANUP: - listener = rpcsvc_get_listener (svc, -1, trans->listener); - if (listener == NULL) { - goto out; - } + listener = rpcsvc_get_listener(svc, -1, trans->listener); + if (listener == NULL) { + goto out; + } - rpcsvc_program_notify (listener, RPCSVC_EVENT_TRANSPORT_DESTROY, - trans); - ret = 0; - break; + rpcsvc_program_notify(listener, RPCSVC_EVENT_TRANSPORT_DESTROY, + trans); + ret = 0; + break; case RPC_TRANSPORT_MAP_XID_REQUEST: - /* FIXME: think about this later */ - gf_log ("rpcsvc", GF_LOG_CRITICAL, - "got MAP_XID event, which should have not come"); - ret = 0; - break; - } + /* FIXME: think about this later */ + gf_log("rpcsvc", GF_LOG_CRITICAL, + "got MAP_XID event, which should have not come"); + ret = 0; + break; + } out: - return ret; + return ret; } - /* Given the RPC reply structure and the payload handed by the RPC program, * encode the RPC record header into the buffer pointed by recordstart. */ struct iovec -rpcsvc_record_build_header (char *recordstart, size_t rlen, - struct rpc_msg reply, size_t payload) -{ - struct iovec replyhdr; - struct iovec txrecord = {0, 0}; - size_t fraglen = 0; - int ret = -1; - - /* After leaving aside the 4 bytes for the fragment header, lets - * encode the RPC reply structure into the buffer given to us. - */ - ret = rpc_reply_to_xdr (&reply, recordstart, rlen, &replyhdr); - if (ret == -1) { - gf_log (GF_RPCSVC, GF_LOG_WARNING, "Failed to create RPC reply"); - goto err; - } - - fraglen = payload + replyhdr.iov_len; - gf_log (GF_RPCSVC, GF_LOG_TRACE, "Reply fraglen %zu, payload: %zu, " - "rpc hdr: %zu", fraglen, payload, replyhdr.iov_len); - - txrecord.iov_base = recordstart; - - /* Remember, this is only the vec for the RPC header and does not - * include the payload above. We needed the payload only to calculate - * the size of the full fragment. This size is sent in the fragment - * header. - */ - txrecord.iov_len = replyhdr.iov_len; +rpcsvc_record_build_header(char *recordstart, size_t rlen, struct rpc_msg reply, + size_t payload) +{ + struct iovec replyhdr; + struct iovec txrecord = {0, 0}; + size_t fraglen = 0; + int ret = -1; + + /* After leaving aside the 4 bytes for the fragment header, lets + * encode the RPC reply structure into the buffer given to us. + */ + ret = rpc_reply_to_xdr(&reply, recordstart, rlen, &replyhdr); + if (ret == -1) { + gf_log(GF_RPCSVC, GF_LOG_WARNING, "Failed to create RPC reply"); + goto err; + } + + fraglen = payload + replyhdr.iov_len; + gf_log(GF_RPCSVC, GF_LOG_TRACE, + "Reply fraglen %zu, payload: %zu, " + "rpc hdr: %zu", + fraglen, payload, replyhdr.iov_len); + + txrecord.iov_base = recordstart; + + /* Remember, this is only the vec for the RPC header and does not + * include the payload above. We needed the payload only to calculate + * the size of the full fragment. This size is sent in the fragment + * header. + */ + txrecord.iov_len = replyhdr.iov_len; err: - return txrecord; + return txrecord; } static uint32_t -rpc_callback_new_callid (struct rpc_transport *trans) +rpc_callback_new_callid(struct rpc_transport *trans) { - uint32_t callid = 0; + uint32_t callid = 0; - pthread_mutex_lock (&trans->lock); - { - callid = ++trans->xid; - } - pthread_mutex_unlock (&trans->lock); + pthread_mutex_lock(&trans->lock); + { + callid = ++trans->xid; + } + pthread_mutex_unlock(&trans->lock); - return callid; + return callid; } int -rpcsvc_fill_callback (int prognum, int progver, int procnum, int payload, - uint32_t xid, struct rpc_msg *request) +rpcsvc_fill_callback(int prognum, int progver, int procnum, int payload, + uint32_t xid, struct rpc_msg *request) { - int ret = -1; + int ret = -1; - if (!request) { - goto out; - } + if (!request) { + goto out; + } - memset (request, 0, sizeof (*request)); + memset(request, 0, sizeof(*request)); - request->rm_xid = xid; - request->rm_direction = CALL; + request->rm_xid = xid; + request->rm_direction = CALL; - request->rm_call.cb_rpcvers = 2; - request->rm_call.cb_prog = prognum; - request->rm_call.cb_vers = progver; - request->rm_call.cb_proc = procnum; + request->rm_call.cb_rpcvers = 2; + request->rm_call.cb_prog = prognum; + request->rm_call.cb_vers = progver; + request->rm_call.cb_proc = procnum; - request->rm_call.cb_cred.oa_flavor = AUTH_NONE; - request->rm_call.cb_cred.oa_base = NULL; - request->rm_call.cb_cred.oa_length = 0; + request->rm_call.cb_cred.oa_flavor = AUTH_NONE; + request->rm_call.cb_cred.oa_base = NULL; + request->rm_call.cb_cred.oa_length = 0; - request->rm_call.cb_verf.oa_flavor = AUTH_NONE; - request->rm_call.cb_verf.oa_base = NULL; - request->rm_call.cb_verf.oa_length = 0; + request->rm_call.cb_verf.oa_flavor = AUTH_NONE; + request->rm_call.cb_verf.oa_base = NULL; + request->rm_call.cb_verf.oa_length = 0; - ret = 0; + ret = 0; out: - return ret; + return ret; } - struct iovec -rpcsvc_callback_build_header (char *recordstart, size_t rlen, +rpcsvc_callback_build_header(char *recordstart, size_t rlen, struct rpc_msg *request, size_t payload) { - struct iovec requesthdr = {0, }; - struct iovec txrecord = {0, 0}; - int ret = -1; - size_t fraglen = 0; - - ret = rpc_request_to_xdr (request, recordstart, rlen, &requesthdr); - if (ret == -1) { - gf_log ("rpcsvc", GF_LOG_WARNING, - "Failed to create RPC request"); - goto out; - } - - fraglen = payload + requesthdr.iov_len; - gf_log ("rpcsvc", GF_LOG_TRACE, "Request fraglen %zu, payload: %zu, " - "rpc hdr: %zu", fraglen, payload, requesthdr.iov_len); - - txrecord.iov_base = recordstart; - - /* Remember, this is only the vec for the RPC header and does not - * include the payload above. We needed the payload only to calculate - * the size of the full fragment. This size is sent in the fragment - * header. - */ - txrecord.iov_len = requesthdr.iov_len; + struct iovec requesthdr = { + 0, + }; + struct iovec txrecord = {0, 0}; + int ret = -1; + size_t fraglen = 0; + + ret = rpc_request_to_xdr(request, recordstart, rlen, &requesthdr); + if (ret == -1) { + gf_log("rpcsvc", GF_LOG_WARNING, "Failed to create RPC request"); + goto out; + } + + fraglen = payload + requesthdr.iov_len; + gf_log("rpcsvc", GF_LOG_TRACE, + "Request fraglen %zu, payload: %zu, " + "rpc hdr: %zu", + fraglen, payload, requesthdr.iov_len); + + txrecord.iov_base = recordstart; + + /* Remember, this is only the vec for the RPC header and does not + * include the payload above. We needed the payload only to calculate + * the size of the full fragment. This size is sent in the fragment + * header. + */ + txrecord.iov_len = requesthdr.iov_len; out: - return txrecord; + return txrecord; } static struct iobuf * -rpcsvc_callback_build_record (rpcsvc_t *rpc, int prognum, int progver, - int procnum, size_t payload, u_long xid, - struct iovec *recbuf) -{ - struct rpc_msg request = {0, }; - struct iobuf *request_iob = NULL; - char *record = NULL; - struct iovec recordhdr = {0, }; - size_t pagesize = 0; - size_t xdr_size = 0; - int ret = -1; - - if ((!rpc) || (!recbuf)) { - goto out; - } - - /* Fill the rpc structure and XDR it into the buffer got above. */ - ret = rpcsvc_fill_callback (prognum, progver, procnum, payload, xid, - &request); - if (ret == -1) { - gf_log ("rpcsvc", GF_LOG_WARNING, "cannot build a rpc-request " - "xid (%lu)", xid); - goto out; - } - - /* First, try to get a pointer into the buffer which the RPC - * layer can use. - */ - xdr_size = xdr_sizeof ((xdrproc_t)xdr_callmsg, &request); - - request_iob = iobuf_get2 (rpc->ctx->iobuf_pool, (xdr_size + payload)); - if (!request_iob) { - goto out; - } - - pagesize = iobuf_pagesize (request_iob); - - record = iobuf_ptr (request_iob); /* Now we have it. */ - - recordhdr = rpcsvc_callback_build_header (record, pagesize, &request, - payload); - - if (!recordhdr.iov_base) { - gf_log ("rpc-clnt", GF_LOG_ERROR, "Failed to build record " - " header"); - iobuf_unref (request_iob); - request_iob = NULL; - recbuf->iov_base = NULL; - goto out; - } - - recbuf->iov_base = recordhdr.iov_base; - recbuf->iov_len = recordhdr.iov_len; +rpcsvc_callback_build_record(rpcsvc_t *rpc, int prognum, int progver, + int procnum, size_t payload, u_long xid, + struct iovec *recbuf) +{ + struct rpc_msg request = { + 0, + }; + struct iobuf *request_iob = NULL; + char *record = NULL; + struct iovec recordhdr = { + 0, + }; + size_t pagesize = 0; + size_t xdr_size = 0; + int ret = -1; + + if ((!rpc) || (!recbuf)) { + goto out; + } + + /* Fill the rpc structure and XDR it into the buffer got above. */ + ret = rpcsvc_fill_callback(prognum, progver, procnum, payload, xid, + &request); + if (ret == -1) { + gf_log("rpcsvc", GF_LOG_WARNING, + "cannot build a rpc-request " + "xid (%lu)", + xid); + goto out; + } + + /* First, try to get a pointer into the buffer which the RPC + * layer can use. + */ + xdr_size = xdr_sizeof((xdrproc_t)xdr_callmsg, &request); + + request_iob = iobuf_get2(rpc->ctx->iobuf_pool, (xdr_size + payload)); + if (!request_iob) { + goto out; + } + + pagesize = iobuf_pagesize(request_iob); + + record = iobuf_ptr(request_iob); /* Now we have it. */ + + recordhdr = rpcsvc_callback_build_header(record, pagesize, &request, + payload); + + if (!recordhdr.iov_base) { + gf_log("rpc-clnt", GF_LOG_ERROR, + "Failed to build record " + " header"); + iobuf_unref(request_iob); + request_iob = NULL; + recbuf->iov_base = NULL; + goto out; + } + + recbuf->iov_base = recordhdr.iov_base; + recbuf->iov_len = recordhdr.iov_len; out: - return request_iob; + return request_iob; } -int rpcsvc_request_submit (rpcsvc_t *rpc, rpc_transport_t *trans, - rpcsvc_cbk_program_t *prog, int procnum, - void *req, glusterfs_ctx_t *ctx, - xdrproc_t xdrproc) -{ - int ret = -1; - int count = 0; - struct iovec iov = {0, }; - struct iobuf *iobuf = NULL; - ssize_t xdr_size = 0; - struct iobref *iobref = NULL; - - if (!req) - goto out; - - xdr_size = xdr_sizeof (xdrproc, req); - - iobuf = iobuf_get2 (ctx->iobuf_pool, xdr_size); - if (!iobuf) - goto out; - - iov.iov_base = iobuf->ptr; - iov.iov_len = iobuf_pagesize (iobuf); - - ret = xdr_serialize_generic (iov, req, xdrproc); - if (ret == -1) { - gf_log (THIS->name, GF_LOG_WARNING, - "failed to create XDR payload"); - goto out; - } - iov.iov_len = ret; - count = 1; - - iobref = iobref_new (); - if (!iobref) { - ret = -1; - gf_log ("rpcsvc", GF_LOG_WARNING, "Failed to create iobref"); - goto out; - } +int +rpcsvc_request_submit(rpcsvc_t *rpc, rpc_transport_t *trans, + rpcsvc_cbk_program_t *prog, int procnum, void *req, + glusterfs_ctx_t *ctx, xdrproc_t xdrproc) +{ + int ret = -1; + int count = 0; + struct iovec iov = { + 0, + }; + struct iobuf *iobuf = NULL; + ssize_t xdr_size = 0; + struct iobref *iobref = NULL; + + if (!req) + goto out; + + xdr_size = xdr_sizeof(xdrproc, req); + + iobuf = iobuf_get2(ctx->iobuf_pool, xdr_size); + if (!iobuf) + goto out; + + iov.iov_base = iobuf->ptr; + iov.iov_len = iobuf_pagesize(iobuf); + + ret = xdr_serialize_generic(iov, req, xdrproc); + if (ret == -1) { + gf_log(THIS->name, GF_LOG_WARNING, "failed to create XDR payload"); + goto out; + } + iov.iov_len = ret; + count = 1; + + iobref = iobref_new(); + if (!iobref) { + ret = -1; + gf_log("rpcsvc", GF_LOG_WARNING, "Failed to create iobref"); + goto out; + } - iobref_add (iobref, iobuf); + iobref_add(iobref, iobuf); - ret = rpcsvc_callback_submit (rpc, trans, prog, procnum, - &iov, count, iobref); + ret = rpcsvc_callback_submit(rpc, trans, prog, procnum, &iov, count, + iobref); out: - if (iobuf) - iobuf_unref (iobuf); + if (iobuf) + iobuf_unref(iobuf); - if (iobref) - iobref_unref (iobref); + if (iobref) + iobref_unref(iobref); - return ret; + return ret; } int -rpcsvc_callback_submit (rpcsvc_t *rpc, rpc_transport_t *trans, - rpcsvc_cbk_program_t *prog, int procnum, - struct iovec *proghdr, int proghdrcount, - struct iobref *iobref) -{ - struct iobuf *request_iob = NULL; - struct iovec rpchdr = {0,}; - rpc_transport_req_t req; - int ret = -1; - int proglen = 0; - uint32_t xid = 0; - gf_boolean_t new_iobref = _gf_false; - - if (!rpc) { - goto out; - } - - memset (&req, 0, sizeof (req)); - - if (proghdr) { - proglen += iov_length (proghdr, proghdrcount); - } - - xid = rpc_callback_new_callid (trans); - - request_iob = rpcsvc_callback_build_record (rpc, prog->prognum, - prog->progver, procnum, - proglen, xid, &rpchdr); - if (!request_iob) { - gf_log ("rpcsvc", GF_LOG_WARNING, - "cannot build rpc-record"); - goto out; - } +rpcsvc_callback_submit(rpcsvc_t *rpc, rpc_transport_t *trans, + rpcsvc_cbk_program_t *prog, int procnum, + struct iovec *proghdr, int proghdrcount, + struct iobref *iobref) +{ + struct iobuf *request_iob = NULL; + struct iovec rpchdr = { + 0, + }; + rpc_transport_req_t req; + int ret = -1; + int proglen = 0; + uint32_t xid = 0; + gf_boolean_t new_iobref = _gf_false; + + if (!rpc) { + goto out; + } + + memset(&req, 0, sizeof(req)); + + if (proghdr) { + proglen += iov_length(proghdr, proghdrcount); + } + + xid = rpc_callback_new_callid(trans); + + request_iob = rpcsvc_callback_build_record( + rpc, prog->prognum, prog->progver, procnum, proglen, xid, &rpchdr); + if (!request_iob) { + gf_log("rpcsvc", GF_LOG_WARNING, "cannot build rpc-record"); + goto out; + } + if (!iobref) { + iobref = iobref_new(); if (!iobref) { - iobref = iobref_new (); - if (!iobref) { - gf_log ("rpcsvc", GF_LOG_WARNING, "Failed to create iobref"); - goto out; - } - new_iobref = 1; + gf_log("rpcsvc", GF_LOG_WARNING, "Failed to create iobref"); + goto out; } + new_iobref = 1; + } - iobref_add (iobref, request_iob); + iobref_add(iobref, request_iob); - req.msg.rpchdr = &rpchdr; - req.msg.rpchdrcount = 1; - req.msg.proghdr = proghdr; - req.msg.proghdrcount = proghdrcount; - req.msg.iobref = iobref; + req.msg.rpchdr = &rpchdr; + req.msg.rpchdrcount = 1; + req.msg.proghdr = proghdr; + req.msg.proghdrcount = proghdrcount; + req.msg.iobref = iobref; - ret = rpc_transport_submit_request (trans, &req); - if (ret == -1) { - gf_log ("rpcsvc", GF_LOG_WARNING, - "transmission of rpc-request failed"); - goto out; - } + ret = rpc_transport_submit_request(trans, &req); + if (ret == -1) { + gf_log("rpcsvc", GF_LOG_WARNING, "transmission of rpc-request failed"); + goto out; + } - ret = 0; + ret = 0; out: - iobuf_unref (request_iob); + iobuf_unref(request_iob); - if (new_iobref) - iobref_unref (iobref); + if (new_iobref) + iobref_unref(iobref); - return ret; + return ret; } int -rpcsvc_transport_submit (rpc_transport_t *trans, struct iovec *rpchdr, - int rpchdrcount, struct iovec *proghdr, - int proghdrcount, struct iovec *progpayload, - int progpayloadcount, struct iobref *iobref, - void *priv) -{ - int ret = -1; - rpc_transport_reply_t reply = {{0, }}; - - if ((!trans) || (!rpchdr) || (!rpchdr->iov_base)) { - goto out; - } - - reply.msg.rpchdr = rpchdr; - reply.msg.rpchdrcount = rpchdrcount; - reply.msg.proghdr = proghdr; - reply.msg.proghdrcount = proghdrcount; - reply.msg.progpayload = progpayload; - reply.msg.progpayloadcount = progpayloadcount; - reply.msg.iobref = iobref; - reply.private = priv; - - ret = rpc_transport_submit_reply (trans, &reply); +rpcsvc_transport_submit(rpc_transport_t *trans, struct iovec *rpchdr, + int rpchdrcount, struct iovec *proghdr, + int proghdrcount, struct iovec *progpayload, + int progpayloadcount, struct iobref *iobref, void *priv) +{ + int ret = -1; + rpc_transport_reply_t reply = {{ + 0, + }}; + + if ((!trans) || (!rpchdr) || (!rpchdr->iov_base)) { + goto out; + } + + reply.msg.rpchdr = rpchdr; + reply.msg.rpchdrcount = rpchdrcount; + reply.msg.proghdr = proghdr; + reply.msg.proghdrcount = proghdrcount; + reply.msg.progpayload = progpayload; + reply.msg.progpayloadcount = progpayloadcount; + reply.msg.iobref = iobref; + reply.private = priv; + + ret = rpc_transport_submit_reply(trans, &reply); out: - return ret; + return ret; } - int -rpcsvc_fill_reply (rpcsvc_request_t *req, struct rpc_msg *reply) -{ - int ret = -1; - rpcsvc_program_t *prog = NULL; - if ((!req) || (!reply)) - goto out; - - ret = 0; - rpc_fill_empty_reply (reply, req->xid); - if (req->rpc_status == MSG_DENIED) { - rpc_fill_denied_reply (reply, req->rpc_err, req->auth_err); - goto out; - } - - prog = rpcsvc_request_program (req); - - if (req->rpc_status == MSG_ACCEPTED) - rpc_fill_accepted_reply (reply, req->rpc_err, - (prog) ? prog->proglowvers : 0, - (prog) ? prog->proghighvers: 0, - req->verf.flavour, req->verf.datalen, - req->verf.authdata); - else - gf_log (GF_RPCSVC, GF_LOG_ERROR, "Invalid rpc_status value"); +rpcsvc_fill_reply(rpcsvc_request_t *req, struct rpc_msg *reply) +{ + int ret = -1; + rpcsvc_program_t *prog = NULL; + if ((!req) || (!reply)) + goto out; + + ret = 0; + rpc_fill_empty_reply(reply, req->xid); + if (req->rpc_status == MSG_DENIED) { + rpc_fill_denied_reply(reply, req->rpc_err, req->auth_err); + goto out; + } + + prog = rpcsvc_request_program(req); + + if (req->rpc_status == MSG_ACCEPTED) + rpc_fill_accepted_reply( + reply, req->rpc_err, (prog) ? prog->proglowvers : 0, + (prog) ? prog->proghighvers : 0, req->verf.flavour, + req->verf.datalen, req->verf.authdata); + else + gf_log(GF_RPCSVC, GF_LOG_ERROR, "Invalid rpc_status value"); out: - return ret; + return ret; } - /* Given a request and the reply payload, build a reply and encodes the reply * into a record header. This record header is encoded into the vector pointed * to be recbuf. @@ -1224,59 +1225,60 @@ out: * we should account for the length of that buffer in the RPC fragment header. */ struct iobuf * -rpcsvc_record_build_record (rpcsvc_request_t *req, size_t payload, - size_t hdrlen, struct iovec *recbuf) -{ - struct rpc_msg reply; - struct iobuf *replyiob = NULL; - char *record = NULL; - struct iovec recordhdr = {0, }; - size_t pagesize = 0; - size_t xdr_size = 0; - rpcsvc_t *svc = NULL; - int ret = -1; +rpcsvc_record_build_record(rpcsvc_request_t *req, size_t payload, size_t hdrlen, + struct iovec *recbuf) +{ + struct rpc_msg reply; + struct iobuf *replyiob = NULL; + char *record = NULL; + struct iovec recordhdr = { + 0, + }; + size_t pagesize = 0; + size_t xdr_size = 0; + rpcsvc_t *svc = NULL; + int ret = -1; + + if ((!req) || (!req->trans) || (!req->svc) || (!recbuf)) + return NULL; - if ((!req) || (!req->trans) || (!req->svc) || (!recbuf)) - return NULL; + svc = req->svc; - svc = req->svc; + /* Fill the rpc structure and XDR it into the buffer got above. */ + ret = rpcsvc_fill_reply(req, &reply); + if (ret) + goto err_exit; - /* Fill the rpc structure and XDR it into the buffer got above. */ - ret = rpcsvc_fill_reply (req, &reply); - if (ret) - goto err_exit; + xdr_size = xdr_sizeof((xdrproc_t)xdr_replymsg, &reply); - xdr_size = xdr_sizeof ((xdrproc_t)xdr_replymsg, &reply); + /* Payload would include 'readv' size etc too, where as + that comes as another payload iobuf */ + replyiob = iobuf_get2(svc->ctx->iobuf_pool, (xdr_size + hdrlen)); + if (!replyiob) { + goto err_exit; + } - /* Payload would include 'readv' size etc too, where as - that comes as another payload iobuf */ - replyiob = iobuf_get2 (svc->ctx->iobuf_pool, (xdr_size + hdrlen)); - if (!replyiob) { - goto err_exit; - } - - pagesize = iobuf_pagesize (replyiob); + pagesize = iobuf_pagesize(replyiob); - record = iobuf_ptr (replyiob); /* Now we have it. */ + record = iobuf_ptr(replyiob); /* Now we have it. */ - recordhdr = rpcsvc_record_build_header (record, pagesize, reply, - payload); - if (!recordhdr.iov_base) { - gf_log (GF_RPCSVC, GF_LOG_ERROR, "Failed to build record " - " header"); - iobuf_unref (replyiob); - replyiob = NULL; - recbuf->iov_base = NULL; - goto err_exit; - } + recordhdr = rpcsvc_record_build_header(record, pagesize, reply, payload); + if (!recordhdr.iov_base) { + gf_log(GF_RPCSVC, GF_LOG_ERROR, + "Failed to build record " + " header"); + iobuf_unref(replyiob); + replyiob = NULL; + recbuf->iov_base = NULL; + goto err_exit; + } - recbuf->iov_base = recordhdr.iov_base; - recbuf->iov_len = recordhdr.iov_len; + recbuf->iov_base = recordhdr.iov_base; + recbuf->iov_len = recordhdr.iov_len; err_exit: - return replyiob; + return replyiob; } - /* * The function to submit a program message to the RPC service. * This message is added to the transmission queue of the @@ -1304,331 +1306,336 @@ err_exit: */ int -rpcsvc_submit_generic (rpcsvc_request_t *req, struct iovec *proghdr, - int hdrcount, struct iovec *payload, int payloadcount, - struct iobref *iobref) -{ - int ret = -1, i = 0; - struct iobuf *replyiob = NULL; - struct iovec recordhdr = {0, }; - rpc_transport_t *trans = NULL; - size_t msglen = 0; - size_t hdrlen = 0; - char new_iobref = 0; - rpcsvc_drc_globals_t *drc = NULL; - - if ((!req) || (!req->trans)) - return -1; - - trans = req->trans; - - for (i = 0; i < hdrcount; i++) { - msglen += proghdr[i].iov_len; - } - - for (i = 0; i < payloadcount; i++) { - msglen += payload[i].iov_len; - } - - gf_log (GF_RPCSVC, GF_LOG_TRACE, "Tx message: %zu", msglen); - - /* Build the buffer containing the encoded RPC reply. */ - replyiob = rpcsvc_record_build_record (req, msglen, hdrlen, &recordhdr); - if (!replyiob) { - gf_log (GF_RPCSVC, GF_LOG_ERROR,"Reply record creation failed"); - goto disconnect_exit; - } - +rpcsvc_submit_generic(rpcsvc_request_t *req, struct iovec *proghdr, + int hdrcount, struct iovec *payload, int payloadcount, + struct iobref *iobref) +{ + int ret = -1, i = 0; + struct iobuf *replyiob = NULL; + struct iovec recordhdr = { + 0, + }; + rpc_transport_t *trans = NULL; + size_t msglen = 0; + size_t hdrlen = 0; + char new_iobref = 0; + rpcsvc_drc_globals_t *drc = NULL; + + if ((!req) || (!req->trans)) + return -1; + + trans = req->trans; + + for (i = 0; i < hdrcount; i++) { + msglen += proghdr[i].iov_len; + } + + for (i = 0; i < payloadcount; i++) { + msglen += payload[i].iov_len; + } + + gf_log(GF_RPCSVC, GF_LOG_TRACE, "Tx message: %zu", msglen); + + /* Build the buffer containing the encoded RPC reply. */ + replyiob = rpcsvc_record_build_record(req, msglen, hdrlen, &recordhdr); + if (!replyiob) { + gf_log(GF_RPCSVC, GF_LOG_ERROR, "Reply record creation failed"); + goto disconnect_exit; + } + + if (!iobref) { + iobref = iobref_new(); if (!iobref) { - iobref = iobref_new (); - if (!iobref) { - goto disconnect_exit; - } - - new_iobref = 1; + goto disconnect_exit; } - iobref_add (iobref, replyiob); - - /* cache the request in the duplicate request cache for appropriate ops */ - if ((req->reply) && (rpcsvc_need_drc (req))) { - drc = req->svc->drc; + new_iobref = 1; + } - LOCK (&drc->lock); - ret = rpcsvc_cache_reply (req, iobref, &recordhdr, 1, - proghdr, hdrcount, - payload, payloadcount); - UNLOCK (&drc->lock); - if (ret < 0) { - gf_log (GF_RPCSVC, GF_LOG_ERROR, - "failed to cache reply"); - } - } + iobref_add(iobref, replyiob); - ret = rpcsvc_transport_submit (trans, &recordhdr, 1, proghdr, hdrcount, - payload, payloadcount, iobref, - req->trans_private); + /* cache the request in the duplicate request cache for appropriate ops */ + if ((req->reply) && (rpcsvc_need_drc(req))) { + drc = req->svc->drc; - if (ret == -1) { - gf_log (GF_RPCSVC, GF_LOG_ERROR, "failed to submit message " - "(XID: 0x%x, Program: %s, ProgVers: %d, Proc: %d) to " - "rpc-transport (%s)", req->xid, - req->prog ? req->prog->progname : "(not matched)", - req->prog ? req->prog->progver : 0, - req->procnum, trans ? trans->name : ""); - } else { - gf_log (GF_RPCSVC, GF_LOG_TRACE, - "submitted reply for rpc-message (XID: 0x%x, " - "Program: %s, ProgVers: %d, Proc: %d) to rpc-transport " - "(%s)", req->xid, req->prog ? req->prog->progname: "-", - req->prog ? req->prog->progver : 0, - req->procnum, trans ? trans->name : ""); - } + LOCK(&drc->lock); + ret = rpcsvc_cache_reply(req, iobref, &recordhdr, 1, proghdr, hdrcount, + payload, payloadcount); + UNLOCK(&drc->lock); + if (ret < 0) { + gf_log(GF_RPCSVC, GF_LOG_ERROR, "failed to cache reply"); + } + } + + ret = rpcsvc_transport_submit(trans, &recordhdr, 1, proghdr, hdrcount, + payload, payloadcount, iobref, + req->trans_private); + + if (ret == -1) { + gf_log(GF_RPCSVC, GF_LOG_ERROR, + "failed to submit message " + "(XID: 0x%x, Program: %s, ProgVers: %d, Proc: %d) to " + "rpc-transport (%s)", + req->xid, req->prog ? req->prog->progname : "(not matched)", + req->prog ? req->prog->progver : 0, req->procnum, + trans ? trans->name : ""); + } else { + gf_log(GF_RPCSVC, GF_LOG_TRACE, + "submitted reply for rpc-message (XID: 0x%x, " + "Program: %s, ProgVers: %d, Proc: %d) to rpc-transport " + "(%s)", + req->xid, req->prog ? req->prog->progname : "-", + req->prog ? req->prog->progver : 0, req->procnum, + trans ? trans->name : ""); + } disconnect_exit: - if (replyiob) { - iobuf_unref (replyiob); - } + if (replyiob) { + iobuf_unref(replyiob); + } - if (new_iobref) { - iobref_unref (iobref); - } + if (new_iobref) { + iobref_unref(iobref); + } - rpcsvc_request_destroy (req); + rpcsvc_request_destroy(req); - return ret; + return ret; } - int -rpcsvc_error_reply (rpcsvc_request_t *req) +rpcsvc_error_reply(rpcsvc_request_t *req) { - struct iovec dummyvec = {0, }; + struct iovec dummyvec = { + 0, + }; - if (!req) - return -1; + if (!req) + return -1; - gf_log_callingfn ("", GF_LOG_DEBUG, "sending a RPC error reply"); + gf_log_callingfn("", GF_LOG_DEBUG, "sending a RPC error reply"); - /* At this point the req should already have been filled with the - * appropriate RPC error numbers. - */ - return rpcsvc_submit_generic (req, &dummyvec, 0, NULL, 0, NULL); + /* At this point the req should already have been filled with the + * appropriate RPC error numbers. + */ + return rpcsvc_submit_generic(req, &dummyvec, 0, NULL, 0, NULL); } #ifdef IPV6_DEFAULT int -rpcsvc_program_register_rpcbind6 (rpcsvc_program_t *newprog, uint32_t port) -{ - const int IP_BUF_LEN = 64; - char addr_buf[IP_BUF_LEN]; - - int err = 0; - bool_t success = 0; - struct netconfig *nc; - struct netbuf *nb; - - if (!newprog) { - goto out; - } - - nc = getnetconfigent ("tcp6"); - if (!nc) { - err = -1; - goto out; - } - - - err = sprintf (addr_buf, "::.%d.%d", port >> 8 & 0xff, - port & 0xff); - if (err < 0) { - err = -1; - goto out; - } - - nb = uaddr2taddr (nc, addr_buf); - if (!nb) { - err = -1; - goto out; - } - - /* Force the unregistration of the program first. - * This call may fail if nothing has been registered, - * which is fine. - */ - rpcsvc_program_unregister_rpcbind6 (newprog); - - success = rpcb_set (newprog->prognum, newprog->progver, nc, nb); - if (!success) { - gf_log (GF_RPCSVC, GF_LOG_ERROR, "Could not register the IPv6" - " service with rpcbind"); - } - - err = 0; +rpcsvc_program_register_rpcbind6(rpcsvc_program_t *newprog, uint32_t port) +{ + const int IP_BUF_LEN = 64; + char addr_buf[IP_BUF_LEN]; + + int err = 0; + bool_t success = 0; + struct netconfig *nc; + struct netbuf *nb; + + if (!newprog) { + goto out; + } + + nc = getnetconfigent("tcp6"); + if (!nc) { + err = -1; + goto out; + } + + err = sprintf(addr_buf, "::.%d.%d", port >> 8 & 0xff, port & 0xff); + if (err < 0) { + err = -1; + goto out; + } + + nb = uaddr2taddr(nc, addr_buf); + if (!nb) { + err = -1; + goto out; + } + + /* Force the unregistration of the program first. + * This call may fail if nothing has been registered, + * which is fine. + */ + rpcsvc_program_unregister_rpcbind6(newprog); + + success = rpcb_set(newprog->prognum, newprog->progver, nc, nb); + if (!success) { + gf_log(GF_RPCSVC, GF_LOG_ERROR, + "Could not register the IPv6" + " service with rpcbind"); + } + + err = 0; out: - return err; + return err; } int -rpcsvc_program_unregister_rpcbind6 (rpcsvc_program_t *newprog) -{ - int err = 0; - bool_t success = 0; - struct netconfig *nc; - - if (!newprog) { - goto out; - } - - nc = getnetconfigent ("tcp6"); - if (!nc) { - err = -1; - goto out; - } - - success = rpcb_unset (newprog->prognum, newprog->progver, nc); - if (!success) { - gf_log (GF_RPCSVC, GF_LOG_ERROR, "Could not unregister the IPv6" - " service with rpcbind"); - } - - err = 0; +rpcsvc_program_unregister_rpcbind6(rpcsvc_program_t *newprog) +{ + int err = 0; + bool_t success = 0; + struct netconfig *nc; + + if (!newprog) { + goto out; + } + + nc = getnetconfigent("tcp6"); + if (!nc) { + err = -1; + goto out; + } + + success = rpcb_unset(newprog->prognum, newprog->progver, nc); + if (!success) { + gf_log(GF_RPCSVC, GF_LOG_ERROR, + "Could not unregister the IPv6" + " service with rpcbind"); + } + + err = 0; out: - return err; + return err; } #endif /* Register the program with the local portmapper service. */ int -rpcsvc_program_register_portmap (rpcsvc_program_t *newprog, uint32_t port) +rpcsvc_program_register_portmap(rpcsvc_program_t *newprog, uint32_t port) { - int ret = -1; /* FAIL */ + int ret = -1; /* FAIL */ - if (!newprog) { - goto out; - } + if (!newprog) { + goto out; + } - /* pmap_set() returns 0 for FAIL and 1 for SUCCESS */ - if (!(pmap_set (newprog->prognum, newprog->progver, IPPROTO_TCP, - port))) { - gf_log (GF_RPCSVC, GF_LOG_ERROR, "Could not register with" - " portmap %d %d %u", newprog->prognum, newprog->progver, port); - goto out; - } + /* pmap_set() returns 0 for FAIL and 1 for SUCCESS */ + if (!(pmap_set(newprog->prognum, newprog->progver, IPPROTO_TCP, port))) { + gf_log(GF_RPCSVC, GF_LOG_ERROR, + "Could not register with" + " portmap %d %d %u", + newprog->prognum, newprog->progver, port); + goto out; + } - ret = 0; /* SUCCESS */ + ret = 0; /* SUCCESS */ out: - return ret; + return ret; } - int -rpcsvc_program_unregister_portmap (rpcsvc_program_t *prog) +rpcsvc_program_unregister_portmap(rpcsvc_program_t *prog) { - int ret = -1; + int ret = -1; - if (!prog) - goto out; + if (!prog) + goto out; - if (!(pmap_unset(prog->prognum, prog->progver))) { - gf_log (GF_RPCSVC, GF_LOG_ERROR, "Could not unregister with" - " portmap"); - goto out; - } + if (!(pmap_unset(prog->prognum, prog->progver))) { + gf_log(GF_RPCSVC, GF_LOG_ERROR, + "Could not unregister with" + " portmap"); + goto out; + } - ret = 0; + ret = 0; out: - return ret; + return ret; } int -rpcsvc_register_portmap_enabled (rpcsvc_t *svc) +rpcsvc_register_portmap_enabled(rpcsvc_t *svc) { - return svc->register_portmap; + return svc->register_portmap; } int32_t -rpcsvc_get_listener_port (rpcsvc_listener_t *listener) +rpcsvc_get_listener_port(rpcsvc_listener_t *listener) { - int32_t listener_port = -1; + int32_t listener_port = -1; - if ((listener == NULL) || (listener->trans == NULL)) { - goto out; - } + if ((listener == NULL) || (listener->trans == NULL)) { + goto out; + } - switch (listener->trans->myinfo.sockaddr.ss_family) { + switch (listener->trans->myinfo.sockaddr.ss_family) { case AF_INET: - listener_port = ((struct sockaddr_in *)&listener->trans->myinfo.sockaddr)->sin_port; - break; + listener_port = ((struct sockaddr_in *)&listener->trans->myinfo + .sockaddr) + ->sin_port; + break; case AF_INET6: - listener_port = ((struct sockaddr_in6 *)&listener->trans->myinfo.sockaddr)->sin6_port; - break; + listener_port = ((struct sockaddr_in6 *)&listener->trans->myinfo + .sockaddr) + ->sin6_port; + break; default: - gf_log (GF_RPCSVC, GF_LOG_DEBUG, - "invalid address family (%d)", - listener->trans->myinfo.sockaddr.ss_family); - goto out; - } + gf_log(GF_RPCSVC, GF_LOG_DEBUG, "invalid address family (%d)", + listener->trans->myinfo.sockaddr.ss_family); + goto out; + } - listener_port = ntohs (listener_port); + listener_port = ntohs(listener_port); out: - return listener_port; + return listener_port; } - rpcsvc_listener_t * -rpcsvc_get_listener (rpcsvc_t *svc, uint16_t port, rpc_transport_t *trans) +rpcsvc_get_listener(rpcsvc_t *svc, uint16_t port, rpc_transport_t *trans) { - rpcsvc_listener_t *listener = NULL; - char found = 0; - rpcsvc_listener_t *next = NULL; - uint32_t listener_port = 0; + rpcsvc_listener_t *listener = NULL; + char found = 0; + rpcsvc_listener_t *next = NULL; + uint32_t listener_port = 0; - if (!svc) { - goto out; - } + if (!svc) { + goto out; + } - pthread_rwlock_rdlock (&svc->rpclock); + pthread_rwlock_rdlock(&svc->rpclock); + { + list_for_each_entry_safe(listener, next, &svc->listeners, list) { - list_for_each_entry_safe (listener, next, &svc->listeners, list) { - if (trans != NULL) { - if (listener->trans == trans) { - found = 1; - break; - } - - continue; - } - - listener_port = rpcsvc_get_listener_port (listener); - if (listener_port == -1) { - gf_log (GF_RPCSVC, GF_LOG_ERROR, - "invalid port for listener %s", - listener->trans->name); - continue; - } - - if (listener_port == port) { - found = 1; - break; - } + if (trans != NULL) { + if (listener->trans == trans) { + found = 1; + break; } - } - pthread_rwlock_unlock (&svc->rpclock); - if (!found) { - listener = NULL; + continue; + } + + listener_port = rpcsvc_get_listener_port(listener); + if (listener_port == -1) { + gf_log(GF_RPCSVC, GF_LOG_ERROR, "invalid port for listener %s", + listener->trans->name); + continue; + } + + if (listener_port == port) { + found = 1; + break; + } } + } + pthread_rwlock_unlock(&svc->rpclock); + + if (!found) { + listener = NULL; + } out: - return listener; + return listener; } - /* The only difference between the generic submit and this one is that the * generic submit is also used for submitting RPC error replies in where there * are no payloads so the msgvec and msgbuf can be NULL. @@ -1636,819 +1643,824 @@ out: * we must perform NULL checks before calling the generic submit. */ int -rpcsvc_submit_message (rpcsvc_request_t *req, struct iovec *proghdr, - int hdrcount, struct iovec *payload, int payloadcount, - struct iobref *iobref) +rpcsvc_submit_message(rpcsvc_request_t *req, struct iovec *proghdr, + int hdrcount, struct iovec *payload, int payloadcount, + struct iobref *iobref) { - if ((!req) || (!req->trans) || (!proghdr) || (!proghdr->iov_base)) - return -1; + if ((!req) || (!req->trans) || (!proghdr) || (!proghdr->iov_base)) + return -1; - return rpcsvc_submit_generic (req, proghdr, hdrcount, payload, - payloadcount, iobref); + return rpcsvc_submit_generic(req, proghdr, hdrcount, payload, payloadcount, + iobref); } - int -rpcsvc_program_unregister (rpcsvc_t *svc, rpcsvc_program_t *program) -{ - int ret = -1; - rpcsvc_program_t *prog = NULL; - if (!svc || !program) { - goto out; - } - - ret = rpcsvc_program_unregister_portmap (program); - if (ret == -1) { - gf_log (GF_RPCSVC, GF_LOG_ERROR, "portmap unregistration of" - " program failed"); - goto out; - } +rpcsvc_program_unregister(rpcsvc_t *svc, rpcsvc_program_t *program) +{ + int ret = -1; + rpcsvc_program_t *prog = NULL; + if (!svc || !program) { + goto out; + } + + ret = rpcsvc_program_unregister_portmap(program); + if (ret == -1) { + gf_log(GF_RPCSVC, GF_LOG_ERROR, + "portmap unregistration of" + " program failed"); + goto out; + } #ifdef IPV6_DEFAULT - ret = rpcsvc_program_unregister_rpcbind6 (program); - if (ret == -1) { - gf_log (GF_RPCSVC, GF_LOG_ERROR, "rpcbind (ipv6)" - " unregistration of program failed"); - goto out; - } + ret = rpcsvc_program_unregister_rpcbind6(program); + if (ret == -1) { + gf_log(GF_RPCSVC, GF_LOG_ERROR, + "rpcbind (ipv6)" + " unregistration of program failed"); + goto out; + } #endif - pthread_rwlock_rdlock (&svc->rpclock); + pthread_rwlock_rdlock(&svc->rpclock); + { + list_for_each_entry(prog, &svc->programs, program) { - list_for_each_entry (prog, &svc->programs, program) { - if ((prog->prognum == program->prognum) - && (prog->progver == program->progver)) { - break; - } - } + if ((prog->prognum == program->prognum) && + (prog->progver == program->progver)) { + break; + } } - pthread_rwlock_unlock (&svc->rpclock); + } + pthread_rwlock_unlock(&svc->rpclock); - gf_log (GF_RPCSVC, GF_LOG_DEBUG, "Program unregistered: %s, Num: %d," - " Ver: %d, Port: %d", prog->progname, prog->prognum, - prog->progver, prog->progport); + gf_log(GF_RPCSVC, GF_LOG_DEBUG, + "Program unregistered: %s, Num: %d," + " Ver: %d, Port: %d", + prog->progname, prog->prognum, prog->progver, prog->progport); - if (prog->ownthread) { - prog->alive = _gf_false; - ret = 0; - goto out; - } + if (prog->ownthread) { + prog->alive = _gf_false; + ret = 0; + goto out; + } - pthread_rwlock_wrlock (&svc->rpclock); - { - list_del_init (&prog->program); - } - pthread_rwlock_unlock (&svc->rpclock); + pthread_rwlock_wrlock(&svc->rpclock); + { + list_del_init(&prog->program); + } + pthread_rwlock_unlock(&svc->rpclock); - ret = 0; + ret = 0; out: - if (ret == -1) { - if (program) { - gf_log (GF_RPCSVC, GF_LOG_ERROR, "Program " - "unregistration failed" - ": %s, Num: %d, Ver: %d, Port: %d", - program->progname, program->prognum, - program->progver, program->progport); - } else { - gf_log (GF_RPCSVC, GF_LOG_ERROR, "Program not found"); - } + if (ret == -1) { + if (program) { + gf_log(GF_RPCSVC, GF_LOG_ERROR, + "Program " + "unregistration failed" + ": %s, Num: %d, Ver: %d, Port: %d", + program->progname, program->prognum, program->progver, + program->progport); + } else { + gf_log(GF_RPCSVC, GF_LOG_ERROR, "Program not found"); } + } - return ret; + return ret; } - int -rpcsvc_transport_peername (rpc_transport_t *trans, char *hostname, int hostlen) +rpcsvc_transport_peername(rpc_transport_t *trans, char *hostname, int hostlen) { - if (!trans) { - return -1; - } + if (!trans) { + return -1; + } - return rpc_transport_get_peername (trans, hostname, hostlen); + return rpc_transport_get_peername(trans, hostname, hostlen); } - int -rpcsvc_transport_peeraddr (rpc_transport_t *trans, char *addrstr, int addrlen, - struct sockaddr_storage *sa, socklen_t sasize) +rpcsvc_transport_peeraddr(rpc_transport_t *trans, char *addrstr, int addrlen, + struct sockaddr_storage *sa, socklen_t sasize) { - if (!trans) { - return -1; - } + if (!trans) { + return -1; + } - return rpc_transport_get_peeraddr(trans, addrstr, addrlen, sa, - sasize); + return rpc_transport_get_peeraddr(trans, addrstr, addrlen, sa, sasize); } rpcsvc_listener_t * -rpcsvc_listener_alloc (rpcsvc_t *svc, rpc_transport_t *trans) +rpcsvc_listener_alloc(rpcsvc_t *svc, rpc_transport_t *trans) { - rpcsvc_listener_t *listener = NULL; + rpcsvc_listener_t *listener = NULL; - listener = GF_CALLOC (1, sizeof (*listener), - gf_common_mt_rpcsvc_listener_t); - if (!listener) { - goto out; - } + listener = GF_CALLOC(1, sizeof(*listener), gf_common_mt_rpcsvc_listener_t); + if (!listener) { + goto out; + } - listener->trans = trans; - listener->svc = svc; + listener->trans = trans; + listener->svc = svc; - INIT_LIST_HEAD (&listener->list); + INIT_LIST_HEAD(&listener->list); - pthread_rwlock_wrlock (&svc->rpclock); - { - list_add_tail (&listener->list, &svc->listeners); - } - pthread_rwlock_unlock (&svc->rpclock); + pthread_rwlock_wrlock(&svc->rpclock); + { + list_add_tail(&listener->list, &svc->listeners); + } + pthread_rwlock_unlock(&svc->rpclock); out: - return listener; + return listener; } - int32_t -rpcsvc_create_listener (rpcsvc_t *svc, dict_t *options, char *name) -{ - rpc_transport_t *trans = NULL; - rpcsvc_listener_t *listener = NULL; - int32_t ret = -1; - - if (!svc || !options) { - goto out; - } - - trans = rpc_transport_load (svc->ctx, options, name); - if (!trans) { - gf_log (GF_RPCSVC, GF_LOG_WARNING, "cannot create listener, " - "initing the transport failed"); - goto out; - } - - ret = rpc_transport_listen (trans); - if (ret == -EADDRINUSE || ret == -1) { - gf_log (GF_RPCSVC, GF_LOG_WARNING, - "listening on transport failed"); - goto out; - } - - ret = rpc_transport_register_notify (trans, rpcsvc_notify, svc); - if (ret == -1) { - gf_log (GF_RPCSVC, GF_LOG_WARNING, "registering notify failed"); - goto out; - } - - listener = rpcsvc_listener_alloc (svc, trans); - if (listener == NULL) { - goto out; - } - - ret = 0; +rpcsvc_create_listener(rpcsvc_t *svc, dict_t *options, char *name) +{ + rpc_transport_t *trans = NULL; + rpcsvc_listener_t *listener = NULL; + int32_t ret = -1; + + if (!svc || !options) { + goto out; + } + + trans = rpc_transport_load(svc->ctx, options, name); + if (!trans) { + gf_log(GF_RPCSVC, GF_LOG_WARNING, + "cannot create listener, " + "initing the transport failed"); + goto out; + } + + ret = rpc_transport_listen(trans); + if (ret == -EADDRINUSE || ret == -1) { + gf_log(GF_RPCSVC, GF_LOG_WARNING, "listening on transport failed"); + goto out; + } + + ret = rpc_transport_register_notify(trans, rpcsvc_notify, svc); + if (ret == -1) { + gf_log(GF_RPCSVC, GF_LOG_WARNING, "registering notify failed"); + goto out; + } + + listener = rpcsvc_listener_alloc(svc, trans); + if (listener == NULL) { + goto out; + } + + ret = 0; out: - if (!listener && trans) { - rpc_transport_disconnect (trans, _gf_true); - } + if (!listener && trans) { + rpc_transport_disconnect(trans, _gf_true); + } - return ret; + return ret; } - int32_t -rpcsvc_create_listeners (rpcsvc_t *svc, dict_t *options, char *name) +rpcsvc_create_listeners(rpcsvc_t *svc, dict_t *options, char *name) { - int32_t ret = -1, count = 0; - data_t *data = NULL; - char *str = NULL, *ptr = NULL, *transport_name = NULL; - char *transport_type = NULL, *saveptr = NULL, *tmp = NULL; + int32_t ret = -1, count = 0; + data_t *data = NULL; + char *str = NULL, *ptr = NULL, *transport_name = NULL; + char *transport_type = NULL, *saveptr = NULL, *tmp = NULL; - if ((svc == NULL) || (options == NULL) || (name == NULL)) { - goto out; - } + if ((svc == NULL) || (options == NULL) || (name == NULL)) { + goto out; + } - data = dict_get (options, "transport-type"); - if (data == NULL) { - gf_log (GF_RPCSVC, GF_LOG_ERROR, - "option transport-type not set"); - goto out; - } + data = dict_get(options, "transport-type"); + if (data == NULL) { + gf_log(GF_RPCSVC, GF_LOG_ERROR, "option transport-type not set"); + goto out; + } - transport_type = data_to_str (data); - if (transport_type == NULL) { - gf_log (GF_RPCSVC, GF_LOG_ERROR, - "option transport-type not set"); - goto out; - } + transport_type = data_to_str(data); + if (transport_type == NULL) { + gf_log(GF_RPCSVC, GF_LOG_ERROR, "option transport-type not set"); + goto out; + } - /* duplicate transport_type, since following dict_set will free it */ - transport_type = gf_strdup (transport_type); - if (transport_type == NULL) { - goto out; - } + /* duplicate transport_type, since following dict_set will free it */ + transport_type = gf_strdup(transport_type); + if (transport_type == NULL) { + goto out; + } - str = gf_strdup (transport_type); - if (str == NULL) { - goto out; - } + str = gf_strdup(transport_type); + if (str == NULL) { + goto out; + } - ptr = strtok_r (str, ",", &saveptr); + ptr = strtok_r(str, ",", &saveptr); - while (ptr != NULL) { - tmp = gf_strdup (ptr); - if (tmp == NULL) { - goto out; - } - - ret = gf_asprintf (&transport_name, "%s.%s", tmp, name); - if (ret == -1) { - goto out; - } + while (ptr != NULL) { + tmp = gf_strdup(ptr); + if (tmp == NULL) { + goto out; + } - ret = dict_set_dynstr (options, "transport-type", tmp); - if (ret == -1) { - goto out; - } + ret = gf_asprintf(&transport_name, "%s.%s", tmp, name); + if (ret == -1) { + goto out; + } - tmp = NULL; - ptr = strtok_r (NULL, ",", &saveptr); + ret = dict_set_dynstr(options, "transport-type", tmp); + if (ret == -1) { + goto out; + } - ret = rpcsvc_create_listener (svc, options, transport_name); - if (ret != 0) { - goto out; - } + tmp = NULL; + ptr = strtok_r(NULL, ",", &saveptr); - GF_FREE (transport_name); - transport_name = NULL; - count++; + ret = rpcsvc_create_listener(svc, options, transport_name); + if (ret != 0) { + goto out; } - ret = dict_set_dynstr (options, "transport-type", transport_type); - if (ret == -1) { - goto out; - } + GF_FREE(transport_name); + transport_name = NULL; + count++; + } + + ret = dict_set_dynstr(options, "transport-type", transport_type); + if (ret == -1) { + goto out; + } - transport_type = NULL; + transport_type = NULL; out: - GF_FREE (str); + GF_FREE(str); - GF_FREE (transport_type); + GF_FREE(transport_type); - GF_FREE (tmp); + GF_FREE(tmp); - GF_FREE (transport_name); + GF_FREE(transport_name); - if (count > 0) { - return count; - } else { - return ret; - } + if (count > 0) { + return count; + } else { + return ret; + } } - int -rpcsvc_unregister_notify (rpcsvc_t *svc, rpcsvc_notify_t notify, void *mydata) +rpcsvc_unregister_notify(rpcsvc_t *svc, rpcsvc_notify_t notify, void *mydata) { - rpcsvc_notify_wrapper_t *wrapper = NULL, *tmp = NULL; - int ret = 0; + rpcsvc_notify_wrapper_t *wrapper = NULL, *tmp = NULL; + int ret = 0; - if (!svc || !notify) { - goto out; - } + if (!svc || !notify) { + goto out; + } - pthread_rwlock_wrlock (&svc->rpclock); + pthread_rwlock_wrlock(&svc->rpclock); + { + list_for_each_entry_safe(wrapper, tmp, &svc->notify, list) { - list_for_each_entry_safe (wrapper, tmp, &svc->notify, list) { - if ((wrapper->notify == notify) - && (mydata == wrapper->data)) { - list_del_init (&wrapper->list); - GF_FREE (wrapper); - ret++; - } - } + if ((wrapper->notify == notify) && (mydata == wrapper->data)) { + list_del_init(&wrapper->list); + GF_FREE(wrapper); + ret++; + } } - pthread_rwlock_unlock (&svc->rpclock); + } + pthread_rwlock_unlock(&svc->rpclock); out: - return ret; + return ret; } int -rpcsvc_register_notify (rpcsvc_t *svc, rpcsvc_notify_t notify, void *mydata) +rpcsvc_register_notify(rpcsvc_t *svc, rpcsvc_notify_t notify, void *mydata) +{ + rpcsvc_notify_wrapper_t *wrapper = NULL; + int ret = -1; + + wrapper = rpcsvc_notify_wrapper_alloc(); + if (!wrapper) { + goto out; + } + svc->mydata = mydata; + wrapper->data = mydata; + wrapper->notify = notify; + + pthread_rwlock_wrlock(&svc->rpclock); + { + list_add_tail(&wrapper->list, &svc->notify); + svc->notify_count++; + } + pthread_rwlock_unlock(&svc->rpclock); + + ret = 0; +out: + return ret; +} + +void * +rpcsvc_request_handler(void *arg) { - rpcsvc_notify_wrapper_t *wrapper = NULL; - int ret = -1; + rpcsvc_program_t *program = arg; + rpcsvc_request_t *req = NULL; + rpcsvc_actor_t *actor = NULL; + gf_boolean_t done = _gf_false; + int ret = 0; - wrapper = rpcsvc_notify_wrapper_alloc (); - if (!wrapper) { - goto out; - } - svc->mydata = mydata; - wrapper->data = mydata; - wrapper->notify = notify; + if (!program) + return NULL; - pthread_rwlock_wrlock (&svc->rpclock); + while (1) { + pthread_mutex_lock(&program->queue_lock); { - list_add_tail (&wrapper->list, &svc->notify); - svc->notify_count++; - } - pthread_rwlock_unlock (&svc->rpclock); + if (!program->alive && list_empty(&program->request_queue)) { + done = 1; + goto unlock; + } - ret = 0; -out: - return ret; -} + while (list_empty(&program->request_queue) && + (program->threadcount <= program->eventthreadcount)) { + pthread_cond_wait(&program->queue_cond, &program->queue_lock); + } -void * -rpcsvc_request_handler (void *arg) -{ - rpcsvc_program_t *program = arg; - rpcsvc_request_t *req = NULL; - rpcsvc_actor_t *actor = NULL; - gf_boolean_t done = _gf_false; - int ret = 0; - - if (!program) - return NULL; - - while (1) { - pthread_mutex_lock (&program->queue_lock); - { - if (!program->alive - && list_empty (&program->request_queue)) { - done = 1; - goto unlock; - } - - while (list_empty (&program->request_queue) && - (program->threadcount <= - program->eventthreadcount)) { - pthread_cond_wait (&program->queue_cond, - &program->queue_lock); - } - - if (program->threadcount > program->eventthreadcount) { - done = 1; - program->threadcount--; - - gf_log (GF_RPCSVC, GF_LOG_INFO, - "program '%s' thread terminated; " - "total count:%d", - program->progname, - program->threadcount); - } else if (!list_empty (&program->request_queue)) { - req = list_entry (program->request_queue.next, - typeof (*req), request_list); - - list_del_init (&req->request_list); - } - } - unlock: - pthread_mutex_unlock (&program->queue_lock); - - if (req) { - THIS = req->svc->xl; - actor = rpcsvc_program_actor (req); - ret = actor->actor (req); - - if (ret != 0) { - rpcsvc_check_and_reply_error (ret, NULL, req); - } - req = NULL; - } + if (program->threadcount > program->eventthreadcount) { + done = 1; + program->threadcount--; + + gf_log(GF_RPCSVC, GF_LOG_INFO, + "program '%s' thread terminated; " + "total count:%d", + program->progname, program->threadcount); + } else if (!list_empty(&program->request_queue)) { + req = list_entry(program->request_queue.next, typeof(*req), + request_list); - if (done) - break; + list_del_init(&req->request_list); + } } + unlock: + pthread_mutex_unlock(&program->queue_lock); - return NULL; + if (req) { + THIS = req->svc->xl; + actor = rpcsvc_program_actor(req); + ret = actor->actor(req); + + if (ret != 0) { + rpcsvc_check_and_reply_error(ret, NULL, req); + } + req = NULL; + } + + if (done) + break; + } + + return NULL; } int -rpcsvc_spawn_threads (rpcsvc_t *svc, rpcsvc_program_t *program) +rpcsvc_spawn_threads(rpcsvc_t *svc, rpcsvc_program_t *program) { - int ret = 0, delta = 0, creates = 0; + int ret = 0, delta = 0, creates = 0; - if (!program || !svc) - goto out; + if (!program || !svc) + goto out; - pthread_mutex_lock (&program->queue_lock); - { - delta = program->eventthreadcount - program->threadcount; - - if (delta >= 0) { - while (delta--) { - ret = gf_thread_create (&program->thread, NULL, - rpcsvc_request_handler, - program, "rpcrqhnd"); - if (!ret) { - program->threadcount++; - creates++; - } - } - - if (creates) { - gf_log (GF_RPCSVC, GF_LOG_INFO, - "spawned %d threads for program '%s'; " - "total count:%d", - creates, - program->progname, - program->threadcount); - } - } else { - gf_log (GF_RPCSVC, GF_LOG_INFO, - "terminating %d threads for program '%s'", - -delta, program->progname); - - /* this signal is to just wake up the threads so they - * test for the change in eventthreadcount and kill - * themselves until the program thread count becomes - * equal to the event thread count - */ - pthread_cond_broadcast (&program->queue_cond); + pthread_mutex_lock(&program->queue_lock); + { + delta = program->eventthreadcount - program->threadcount; + + if (delta >= 0) { + while (delta--) { + ret = gf_thread_create(&program->thread, NULL, + rpcsvc_request_handler, program, + "rpcrqhnd"); + if (!ret) { + program->threadcount++; + creates++; } + } + + if (creates) { + gf_log(GF_RPCSVC, GF_LOG_INFO, + "spawned %d threads for program '%s'; " + "total count:%d", + creates, program->progname, program->threadcount); + } + } else { + gf_log(GF_RPCSVC, GF_LOG_INFO, + "terminating %d threads for program '%s'", -delta, + program->progname); + + /* this signal is to just wake up the threads so they + * test for the change in eventthreadcount and kill + * themselves until the program thread count becomes + * equal to the event thread count + */ + pthread_cond_broadcast(&program->queue_cond); } - pthread_mutex_unlock (&program->queue_lock); + } + pthread_mutex_unlock(&program->queue_lock); out: - return creates; + return creates; } int -rpcsvc_program_register (rpcsvc_t *svc, rpcsvc_program_t *program, - gf_boolean_t add_to_head) +rpcsvc_program_register(rpcsvc_t *svc, rpcsvc_program_t *program, + gf_boolean_t add_to_head) { - int ret = -1; - int creates = -1; - rpcsvc_program_t *newprog = NULL; - char already_registered = 0; + int ret = -1; + int creates = -1; + rpcsvc_program_t *newprog = NULL; + char already_registered = 0; - if (!svc) { - goto out; - } + if (!svc) { + goto out; + } - if (program->actors == NULL) { - goto out; - } + if (program->actors == NULL) { + goto out; + } - pthread_rwlock_rdlock (&svc->rpclock); + pthread_rwlock_rdlock(&svc->rpclock); + { + list_for_each_entry(newprog, &svc->programs, program) { - list_for_each_entry (newprog, &svc->programs, program) { - if ((newprog->prognum == program->prognum) - && (newprog->progver == program->progver)) { - already_registered = 1; - break; - } - } + if ((newprog->prognum == program->prognum) && + (newprog->progver == program->progver)) { + already_registered = 1; + break; + } } - pthread_rwlock_unlock (&svc->rpclock); + } + pthread_rwlock_unlock(&svc->rpclock); - if (already_registered) { - ret = 0; - goto out; - } + if (already_registered) { + ret = 0; + goto out; + } - newprog = GF_CALLOC (1, sizeof(*newprog),gf_common_mt_rpcsvc_program_t); - if (newprog == NULL) { - goto out; - } + newprog = GF_CALLOC(1, sizeof(*newprog), gf_common_mt_rpcsvc_program_t); + if (newprog == NULL) { + goto out; + } - memcpy (newprog, program, sizeof (*program)); + memcpy(newprog, program, sizeof(*program)); - INIT_LIST_HEAD (&newprog->program); - INIT_LIST_HEAD (&newprog->request_queue); - pthread_mutex_init (&newprog->queue_lock, NULL); - pthread_cond_init (&newprog->queue_cond, NULL); + INIT_LIST_HEAD(&newprog->program); + INIT_LIST_HEAD(&newprog->request_queue); + pthread_mutex_init(&newprog->queue_lock, NULL); + pthread_cond_init(&newprog->queue_cond, NULL); - newprog->alive = _gf_true; + newprog->alive = _gf_true; - /* make sure synctask gets priority over ownthread */ - if (newprog->synctask) - newprog->ownthread = _gf_false; + /* make sure synctask gets priority over ownthread */ + if (newprog->synctask) + newprog->ownthread = _gf_false; - if (newprog->ownthread) { - newprog->eventthreadcount = 1; - creates = rpcsvc_spawn_threads (svc, newprog); + if (newprog->ownthread) { + newprog->eventthreadcount = 1; + creates = rpcsvc_spawn_threads(svc, newprog); - if (creates < 1) { - goto out; - } + if (creates < 1) { + goto out; } + } - pthread_rwlock_wrlock (&svc->rpclock); - { - if (add_to_head) - list_add (&newprog->program, &svc->programs); - else - list_add_tail (&newprog->program, &svc->programs); - } - pthread_rwlock_unlock (&svc->rpclock); + pthread_rwlock_wrlock(&svc->rpclock); + { + if (add_to_head) + list_add(&newprog->program, &svc->programs); + else + list_add_tail(&newprog->program, &svc->programs); + } + pthread_rwlock_unlock(&svc->rpclock); - ret = 0; - gf_log (GF_RPCSVC, GF_LOG_DEBUG, "New program registered: %s, Num: %d," - " Ver: %d, Port: %d", newprog->progname, newprog->prognum, - newprog->progver, newprog->progport); + ret = 0; + gf_log(GF_RPCSVC, GF_LOG_DEBUG, + "New program registered: %s, Num: %d," + " Ver: %d, Port: %d", + newprog->progname, newprog->prognum, newprog->progver, + newprog->progport); out: - if (ret == -1) { - gf_log (GF_RPCSVC, GF_LOG_ERROR, "Program registration failed:" - " %s, Num: %d, Ver: %d, Port: %d", program->progname, - program->prognum, program->progver, program->progport); - } + if (ret == -1) { + gf_log(GF_RPCSVC, GF_LOG_ERROR, + "Program registration failed:" + " %s, Num: %d, Ver: %d, Port: %d", + program->progname, program->prognum, program->progver, + program->progport); + } - return ret; + return ret; } static void -free_prog_details (gf_dump_rsp *rsp) +free_prog_details(gf_dump_rsp *rsp) { - gf_prog_detail *prev = NULL; - gf_prog_detail *trav = NULL; + gf_prog_detail *prev = NULL; + gf_prog_detail *trav = NULL; - trav = rsp->prog; - while (trav) { - prev = trav; - trav = trav->next; - GF_FREE (prev); - } + trav = rsp->prog; + while (trav) { + prev = trav; + trav = trav->next; + GF_FREE(prev); + } } static int -build_prog_details (rpcsvc_request_t *req, gf_dump_rsp *rsp) +build_prog_details(rpcsvc_request_t *req, gf_dump_rsp *rsp) { - int ret = -1; - rpcsvc_program_t *program = NULL; - gf_prog_detail *prog = NULL; - gf_prog_detail *prev = NULL; + int ret = -1; + rpcsvc_program_t *program = NULL; + gf_prog_detail *prog = NULL; + gf_prog_detail *prev = NULL; - if (!req || !req->trans || !req->svc) - goto out; + if (!req || !req->trans || !req->svc) + goto out; - pthread_rwlock_rdlock (&req->svc->rpclock); + pthread_rwlock_rdlock(&req->svc->rpclock); + { + list_for_each_entry(program, &req->svc->programs, program) { - list_for_each_entry (program, &req->svc->programs, program) { - prog = GF_CALLOC (1, sizeof (*prog), 0); - if (!prog) - goto unlock; - - prog->progname = program->progname; - prog->prognum = program->prognum; - prog->progver = program->progver; - - if (!rsp->prog) - rsp->prog = prog; - if (prev) - prev->next = prog; - prev = prog; - } - if (prev) - ret = 0; - } + prog = GF_CALLOC(1, sizeof(*prog), 0); + if (!prog) + goto unlock; + + prog->progname = program->progname; + prog->prognum = program->prognum; + prog->progver = program->progver; + + if (!rsp->prog) + rsp->prog = prog; + if (prev) + prev->next = prog; + prev = prog; + } + if (prev) + ret = 0; + } unlock: - pthread_rwlock_unlock (&req->svc->rpclock); + pthread_rwlock_unlock(&req->svc->rpclock); out: - return ret; + return ret; } static int -rpcsvc_ping (rpcsvc_request_t *req) +rpcsvc_ping(rpcsvc_request_t *req) { - char rsp_buf[8 * 1024] = {0,}; - gf_common_rsp rsp = {0,}; - struct iovec iov = {0,}; - int ret = -1; - uint32_t ping_rsp_len = 0; + char rsp_buf[8 * 1024] = { + 0, + }; + gf_common_rsp rsp = { + 0, + }; + struct iovec iov = { + 0, + }; + int ret = -1; + uint32_t ping_rsp_len = 0; - ping_rsp_len = xdr_sizeof ((xdrproc_t) xdr_gf_common_rsp, - &rsp); + ping_rsp_len = xdr_sizeof((xdrproc_t)xdr_gf_common_rsp, &rsp); - iov.iov_base = rsp_buf; - iov.iov_len = ping_rsp_len; + iov.iov_base = rsp_buf; + iov.iov_len = ping_rsp_len; - ret = xdr_serialize_generic (iov, &rsp, (xdrproc_t)xdr_gf_common_rsp); - if (ret < 0) { - ret = RPCSVC_ACTOR_ERROR; - } else { - rsp.op_ret = 0; - rpcsvc_submit_generic (req, &iov, 1, NULL, 0, NULL); - } + ret = xdr_serialize_generic(iov, &rsp, (xdrproc_t)xdr_gf_common_rsp); + if (ret < 0) { + ret = RPCSVC_ACTOR_ERROR; + } else { + rsp.op_ret = 0; + rpcsvc_submit_generic(req, &iov, 1, NULL, 0, NULL); + } - return 0; + return 0; } static int -rpcsvc_dump (rpcsvc_request_t *req) -{ - char rsp_buf[8 * 1024] = {0,}; - gf_dump_rsp rsp = {0,}; - struct iovec iov = {0,}; - int op_errno = EINVAL; - int ret = -1; - uint32_t dump_rsp_len = 0; - - if (!req) - goto sendrsp; - - ret = build_prog_details (req, &rsp); - if (ret < 0) { - op_errno = -ret; - goto sendrsp; - } - - op_errno = 0; +rpcsvc_dump(rpcsvc_request_t *req) +{ + char rsp_buf[8 * 1024] = { + 0, + }; + gf_dump_rsp rsp = { + 0, + }; + struct iovec iov = { + 0, + }; + int op_errno = EINVAL; + int ret = -1; + uint32_t dump_rsp_len = 0; + + if (!req) + goto sendrsp; + + ret = build_prog_details(req, &rsp); + if (ret < 0) { + op_errno = -ret; + goto sendrsp; + } + + op_errno = 0; sendrsp: - rsp.op_errno = gf_errno_to_error (op_errno); - rsp.op_ret = ret; + rsp.op_errno = gf_errno_to_error(op_errno); + rsp.op_ret = ret; - dump_rsp_len = xdr_sizeof ((xdrproc_t) xdr_gf_dump_rsp, - &rsp); + dump_rsp_len = xdr_sizeof((xdrproc_t)xdr_gf_dump_rsp, &rsp); - iov.iov_base = rsp_buf; - iov.iov_len = dump_rsp_len; + iov.iov_base = rsp_buf; + iov.iov_len = dump_rsp_len; - ret = xdr_serialize_generic (iov, &rsp, (xdrproc_t)xdr_gf_dump_rsp); - if (ret < 0) { - ret = RPCSVC_ACTOR_ERROR; - } else { - rpcsvc_submit_generic (req, &iov, 1, NULL, 0, NULL); - ret = 0; - } + ret = xdr_serialize_generic(iov, &rsp, (xdrproc_t)xdr_gf_dump_rsp); + if (ret < 0) { + ret = RPCSVC_ACTOR_ERROR; + } else { + rpcsvc_submit_generic(req, &iov, 1, NULL, 0, NULL); + ret = 0; + } - free_prog_details (&rsp); + free_prog_details(&rsp); - return ret; + return ret; } int -rpcsvc_init_options (rpcsvc_t *svc, dict_t *options) +rpcsvc_init_options(rpcsvc_t *svc, dict_t *options) { - char *optstr = NULL; - int ret = -1; + char *optstr = NULL; + int ret = -1; - if ((!svc) || (!options)) - return -1; + if ((!svc) || (!options)) + return -1; - svc->memfactor = RPCSVC_DEFAULT_MEMFACTOR; + svc->memfactor = RPCSVC_DEFAULT_MEMFACTOR; - svc->register_portmap = _gf_true; - if (dict_get (options, "rpc.register-with-portmap")) { - ret = dict_get_str (options, "rpc.register-with-portmap", - &optstr); - if (ret < 0) { - gf_log (GF_RPCSVC, GF_LOG_ERROR, "Failed to parse " - "dict"); - goto out; - } - - ret = gf_string2boolean (optstr, &svc->register_portmap); - if (ret < 0) { - gf_log (GF_RPCSVC, GF_LOG_ERROR, "Failed to parse bool " - "string"); - goto out; - } + svc->register_portmap = _gf_true; + if (dict_get(options, "rpc.register-with-portmap")) { + ret = dict_get_str(options, "rpc.register-with-portmap", &optstr); + if (ret < 0) { + gf_log(GF_RPCSVC, GF_LOG_ERROR, + "Failed to parse " + "dict"); + goto out; } - if (!svc->register_portmap) - gf_log (GF_RPCSVC, GF_LOG_DEBUG, "Portmap registration " - "disabled"); - ret = 0; + ret = gf_string2boolean(optstr, &svc->register_portmap); + if (ret < 0) { + gf_log(GF_RPCSVC, GF_LOG_ERROR, + "Failed to parse bool " + "string"); + goto out; + } + } + + if (!svc->register_portmap) + gf_log(GF_RPCSVC, GF_LOG_DEBUG, + "Portmap registration " + "disabled"); + ret = 0; out: - return ret; + return ret; } int -rpcsvc_reconfigure_options (rpcsvc_t *svc, dict_t *options) -{ - xlator_t *xlator = NULL; - xlator_list_t *volentry = NULL; - char *srchkey = NULL; - char *keyval = NULL; - int ret = -1; - - if ((!svc) || (!svc->options) || (!options)) - return (-1); - - /* Fetch the xlator from svc */ - xlator = svc->xl; - if (!xlator) +rpcsvc_reconfigure_options(rpcsvc_t *svc, dict_t *options) +{ + xlator_t *xlator = NULL; + xlator_list_t *volentry = NULL; + char *srchkey = NULL; + char *keyval = NULL; + int ret = -1; + + if ((!svc) || (!svc->options) || (!options)) + return (-1); + + /* Fetch the xlator from svc */ + xlator = svc->xl; + if (!xlator) + return (-1); + + /* Reconfigure the volume specific rpc-auth.addr allow part */ + volentry = xlator->children; + while (volentry) { + ret = gf_asprintf(&srchkey, "rpc-auth.addr.%s.allow", + volentry->xlator->name); + if (ret == -1) { + gf_log(GF_RPCSVC, GF_LOG_ERROR, "asprintf failed"); + return (-1); + } + + /* key-string: rpc-auth.addr.<volname>.allow + * + * IMP: Delete the OLD key/value pair from dict. + * And set the NEW key/value pair IFF the option is SET + * in reconfigured volfile. + * + * NB: If rpc-auth.addr.<volname>.allow is not SET explicitly, + * build_nfs_graph() sets it as "*" i.e. anonymous. + */ + dict_del(svc->options, srchkey); + if (!dict_get_str(options, srchkey, &keyval)) { + ret = dict_set_str(svc->options, srchkey, keyval); + if (ret < 0) { + gf_log(GF_RPCSVC, GF_LOG_ERROR, "dict_set_str error"); + GF_FREE(srchkey); return (-1); - - /* Reconfigure the volume specific rpc-auth.addr allow part */ - volentry = xlator->children; - while (volentry) { - ret = gf_asprintf (&srchkey, "rpc-auth.addr.%s.allow", - volentry->xlator->name); - if (ret == -1) { - gf_log (GF_RPCSVC, GF_LOG_ERROR, "asprintf failed"); - return (-1); - } - - /* key-string: rpc-auth.addr.<volname>.allow - * - * IMP: Delete the OLD key/value pair from dict. - * And set the NEW key/value pair IFF the option is SET - * in reconfigured volfile. - * - * NB: If rpc-auth.addr.<volname>.allow is not SET explicitly, - * build_nfs_graph() sets it as "*" i.e. anonymous. - */ - dict_del (svc->options, srchkey); - if (!dict_get_str (options, srchkey, &keyval)) { - ret = dict_set_str (svc->options, srchkey, keyval); - if (ret < 0) { - gf_log (GF_RPCSVC, GF_LOG_ERROR, - "dict_set_str error"); - GF_FREE (srchkey); - return (-1); - } - } - - GF_FREE (srchkey); - volentry = volentry->next; + } } - /* Reconfigure the volume specific rpc-auth.addr reject part */ - volentry = xlator->children; - while (volentry) { - ret = gf_asprintf (&srchkey, "rpc-auth.addr.%s.reject", - volentry->xlator->name); - if (ret == -1) { - gf_log (GF_RPCSVC, GF_LOG_ERROR, "asprintf failed"); - return (-1); - } - - /* key-string: rpc-auth.addr.<volname>.reject - * - * IMP: Delete the OLD key/value pair from dict. - * And set the NEW key/value pair IFF the option is SET - * in reconfigured volfile. - * - * NB: No default value for reject key. - */ - dict_del (svc->options, srchkey); - if (!dict_get_str (options, srchkey, &keyval)) { - ret = dict_set_str (svc->options, srchkey, keyval); - if (ret < 0) { - gf_log (GF_RPCSVC, GF_LOG_ERROR, - "dict_set_str error"); - GF_FREE (srchkey); - return (-1); - } - } + GF_FREE(srchkey); + volentry = volentry->next; + } - GF_FREE (srchkey); - volentry = volentry->next; + /* Reconfigure the volume specific rpc-auth.addr reject part */ + volentry = xlator->children; + while (volentry) { + ret = gf_asprintf(&srchkey, "rpc-auth.addr.%s.reject", + volentry->xlator->name); + if (ret == -1) { + gf_log(GF_RPCSVC, GF_LOG_ERROR, "asprintf failed"); + return (-1); } - ret = rpcsvc_init_options (svc, options); - if (ret) + /* key-string: rpc-auth.addr.<volname>.reject + * + * IMP: Delete the OLD key/value pair from dict. + * And set the NEW key/value pair IFF the option is SET + * in reconfigured volfile. + * + * NB: No default value for reject key. + */ + dict_del(svc->options, srchkey); + if (!dict_get_str(options, srchkey, &keyval)) { + ret = dict_set_str(svc->options, srchkey, keyval); + if (ret < 0) { + gf_log(GF_RPCSVC, GF_LOG_ERROR, "dict_set_str error"); + GF_FREE(srchkey); return (-1); + } + } - return rpcsvc_auth_reconf (svc, options); + GF_FREE(srchkey); + volentry = volentry->next; + } + + ret = rpcsvc_init_options(svc, options); + if (ret) + return (-1); + + return rpcsvc_auth_reconf(svc, options); } int -rpcsvc_transport_unix_options_build (dict_t **options, char *filepath) +rpcsvc_transport_unix_options_build(dict_t **options, char *filepath) { - dict_t *dict = NULL; - char *fpath = NULL; - int ret = -1; + dict_t *dict = NULL; + char *fpath = NULL; + int ret = -1; - GF_ASSERT (filepath); - GF_ASSERT (options); + GF_ASSERT(filepath); + GF_ASSERT(options); - dict = dict_new (); - if (!dict) - goto out; + dict = dict_new(); + if (!dict) + goto out; - fpath = gf_strdup (filepath); - if (!fpath) { - ret = -1; - goto out; - } + fpath = gf_strdup(filepath); + if (!fpath) { + ret = -1; + goto out; + } - ret = dict_set_dynstr (dict, "transport.socket.listen-path", fpath); - if (ret) - goto out; + ret = dict_set_dynstr(dict, "transport.socket.listen-path", fpath); + if (ret) + goto out; - ret = dict_set_str (dict, "transport.address-family", "unix"); - if (ret) - goto out; + ret = dict_set_str(dict, "transport.address-family", "unix"); + if (ret) + goto out; - ret = dict_set_str (dict, "transport.socket.nodelay", "off"); - if (ret) - goto out; + ret = dict_set_str(dict, "transport.socket.nodelay", "off"); + if (ret) + goto out; - ret = dict_set_str (dict, "transport-type", "socket"); - if (ret) - goto out; + ret = dict_set_str(dict, "transport-type", "socket"); + if (ret) + goto out; - *options = dict; + *options = dict; out: - if (ret) { - GF_FREE (fpath); - if (dict) - dict_unref (dict); - } - return ret; + if (ret) { + GF_FREE(fpath); + if (dict) + dict_unref(dict); + } + return ret; } /* @@ -2460,42 +2472,42 @@ out: * NB: defval or set-value "0" is special which means unlimited/65536. */ int -rpcsvc_set_outstanding_rpc_limit (rpcsvc_t *svc, dict_t *options, int defvalue) +rpcsvc_set_outstanding_rpc_limit(rpcsvc_t *svc, dict_t *options, int defvalue) { - int ret = -1; /* FAILURE */ - int rpclim = 0; - static char *rpclimkey = "rpc.outstanding-rpc-limit"; + int ret = -1; /* FAILURE */ + int rpclim = 0; + static char *rpclimkey = "rpc.outstanding-rpc-limit"; - if ((!svc) || (!options)) - return (-1); + if ((!svc) || (!options)) + return (-1); - if ((defvalue < RPCSVC_MIN_OUTSTANDING_RPC_LIMIT) || - (defvalue > RPCSVC_MAX_OUTSTANDING_RPC_LIMIT)) { - return (-1); - } + if ((defvalue < RPCSVC_MIN_OUTSTANDING_RPC_LIMIT) || + (defvalue > RPCSVC_MAX_OUTSTANDING_RPC_LIMIT)) { + return (-1); + } - /* Fetch the rpc.outstanding-rpc-limit from dict. */ - ret = dict_get_int32 (options, rpclimkey, &rpclim); - if (ret < 0) { - /* Fall back to default for FAILURE */ - rpclim = defvalue; - } + /* Fetch the rpc.outstanding-rpc-limit from dict. */ + ret = dict_get_int32(options, rpclimkey, &rpclim); + if (ret < 0) { + /* Fall back to default for FAILURE */ + rpclim = defvalue; + } - /* Round up to multiple-of-8. It must not exceed - * RPCSVC_MAX_OUTSTANDING_RPC_LIMIT. - */ - rpclim = ((rpclim + 8 - 1) >> 3) * 8; - if (rpclim > RPCSVC_MAX_OUTSTANDING_RPC_LIMIT) { - rpclim = RPCSVC_MAX_OUTSTANDING_RPC_LIMIT; - } + /* Round up to multiple-of-8. It must not exceed + * RPCSVC_MAX_OUTSTANDING_RPC_LIMIT. + */ + rpclim = ((rpclim + 8 - 1) >> 3) * 8; + if (rpclim > RPCSVC_MAX_OUTSTANDING_RPC_LIMIT) { + rpclim = RPCSVC_MAX_OUTSTANDING_RPC_LIMIT; + } - if (svc->outstanding_rpc_limit != rpclim) { - svc->outstanding_rpc_limit = rpclim; - gf_log (GF_RPCSVC, GF_LOG_INFO, - "Configured %s with value %d", rpclimkey, rpclim); - } + if (svc->outstanding_rpc_limit != rpclim) { + svc->outstanding_rpc_limit = rpclim; + gf_log(GF_RPCSVC, GF_LOG_INFO, "Configured %s with value %d", rpclimkey, + rpclim); + } - return (0); + return (0); } /* @@ -2503,15 +2515,14 @@ rpcsvc_set_outstanding_rpc_limit (rpcsvc_t *svc, dict_t *options, int defvalue) * Returns 0 on success, -1 otherwise. */ int -rpcsvc_set_throttle_on (rpcsvc_t *svc) +rpcsvc_set_throttle_on(rpcsvc_t *svc) { + if (!svc) + return -1; - if (!svc) - return -1; - - svc->throttle = _gf_true; + svc->throttle = _gf_true; - return 0; + return 0; } /* @@ -2519,15 +2530,14 @@ rpcsvc_set_throttle_on (rpcsvc_t *svc) * Returns 0 on success, -1 otherwise. */ int -rpcsvc_set_throttle_off (rpcsvc_t *svc) +rpcsvc_set_throttle_off(rpcsvc_t *svc) { + if (!svc) + return -1; - if (!svc) - return -1; + svc->throttle = _gf_false; - svc->throttle = _gf_false; - - return 0; + return 0; } /* @@ -2535,213 +2545,205 @@ rpcsvc_set_throttle_off (rpcsvc_t *svc) * Returns value of attribute throttle on success, _gf_false otherwise. */ gf_boolean_t -rpcsvc_get_throttle (rpcsvc_t *svc) +rpcsvc_get_throttle(rpcsvc_t *svc) { + if (!svc) + return _gf_false; - if (!svc) - return _gf_false; - - return svc->throttle; + return svc->throttle; } /* The global RPC service initializer. */ rpcsvc_t * -rpcsvc_init (xlator_t *xl, glusterfs_ctx_t *ctx, dict_t *options, - uint32_t poolcount) +rpcsvc_init(xlator_t *xl, glusterfs_ctx_t *ctx, dict_t *options, + uint32_t poolcount) { - rpcsvc_t *svc = NULL; - int ret = -1; - - if ((!xl) || (!ctx) || (!options)) - return NULL; - - svc = GF_CALLOC (1, sizeof (*svc), gf_common_mt_rpcsvc_t); - if (!svc) - return NULL; - - pthread_rwlock_init (&svc->rpclock, NULL); - INIT_LIST_HEAD (&svc->authschemes); - INIT_LIST_HEAD (&svc->notify); - INIT_LIST_HEAD (&svc->listeners); - INIT_LIST_HEAD (&svc->programs); + rpcsvc_t *svc = NULL; + int ret = -1; - ret = rpcsvc_init_options (svc, options); - if (ret == -1) { - gf_log (GF_RPCSVC, GF_LOG_ERROR, "Failed to init options"); - goto free_svc; - } - - if (!poolcount) - poolcount = RPCSVC_POOLCOUNT_MULT * svc->memfactor; - - gf_log (GF_RPCSVC, GF_LOG_TRACE, "rx pool: %d", poolcount); - svc->rxpool = mem_pool_new (rpcsvc_request_t, poolcount); - /* TODO: leak */ - if (!svc->rxpool) { - gf_log (GF_RPCSVC, GF_LOG_ERROR, "mem pool allocation failed"); - goto free_svc; - } - - ret = rpcsvc_auth_init (svc, options); - if (ret == -1) { - gf_log (GF_RPCSVC, GF_LOG_ERROR, "Failed to init " - "authentication"); - goto free_svc; - } - - ret = -1; - svc->options = options; - svc->ctx = ctx; - svc->xl = xl; - gf_log (GF_RPCSVC, GF_LOG_DEBUG, "RPC service inited."); - - gluster_dump_prog.options = options; + if ((!xl) || (!ctx) || (!options)) + return NULL; - ret = rpcsvc_program_register (svc, &gluster_dump_prog, _gf_false); - if (ret) { - gf_log (GF_RPCSVC, GF_LOG_ERROR, - "failed to register DUMP program"); - goto free_svc; - } + svc = GF_CALLOC(1, sizeof(*svc), gf_common_mt_rpcsvc_t); + if (!svc) + return NULL; - ret = 0; + pthread_rwlock_init(&svc->rpclock, NULL); + INIT_LIST_HEAD(&svc->authschemes); + INIT_LIST_HEAD(&svc->notify); + INIT_LIST_HEAD(&svc->listeners); + INIT_LIST_HEAD(&svc->programs); + + ret = rpcsvc_init_options(svc, options); + if (ret == -1) { + gf_log(GF_RPCSVC, GF_LOG_ERROR, "Failed to init options"); + goto free_svc; + } + + if (!poolcount) + poolcount = RPCSVC_POOLCOUNT_MULT * svc->memfactor; + + gf_log(GF_RPCSVC, GF_LOG_TRACE, "rx pool: %d", poolcount); + svc->rxpool = mem_pool_new(rpcsvc_request_t, poolcount); + /* TODO: leak */ + if (!svc->rxpool) { + gf_log(GF_RPCSVC, GF_LOG_ERROR, "mem pool allocation failed"); + goto free_svc; + } + + ret = rpcsvc_auth_init(svc, options); + if (ret == -1) { + gf_log(GF_RPCSVC, GF_LOG_ERROR, + "Failed to init " + "authentication"); + goto free_svc; + } + + ret = -1; + svc->options = options; + svc->ctx = ctx; + svc->xl = xl; + gf_log(GF_RPCSVC, GF_LOG_DEBUG, "RPC service inited."); + + gluster_dump_prog.options = options; + + ret = rpcsvc_program_register(svc, &gluster_dump_prog, _gf_false); + if (ret) { + gf_log(GF_RPCSVC, GF_LOG_ERROR, "failed to register DUMP program"); + goto free_svc; + } + + ret = 0; free_svc: - if (ret == -1) { - GF_FREE (svc); - svc = NULL; - } + if (ret == -1) { + GF_FREE(svc); + svc = NULL; + } - return svc; + return svc; } - int -rpcsvc_transport_peer_check_search (dict_t *options, char *pattern, - char *ip, char *hostname) +rpcsvc_transport_peer_check_search(dict_t *options, char *pattern, char *ip, + char *hostname) { - int ret = -1; - char *addrtok = NULL; - char *addrstr = NULL; - char *dup_addrstr = NULL; - char *svptr = NULL; + int ret = -1; + char *addrtok = NULL; + char *addrstr = NULL; + char *dup_addrstr = NULL; + char *svptr = NULL; - if ((!options) || (!ip)) - return -1; + if ((!options) || (!ip)) + return -1; - ret = dict_get_str (options, pattern, &addrstr); - if (ret < 0) { - ret = -1; - goto err; - } - - if (!addrstr) { - ret = -1; - goto err; - } + ret = dict_get_str(options, pattern, &addrstr); + if (ret < 0) { + ret = -1; + goto err; + } - dup_addrstr = gf_strdup (addrstr); - addrtok = strtok_r (dup_addrstr, ",", &svptr); - while (addrtok) { + if (!addrstr) { + ret = -1; + goto err; + } - /* CASEFOLD not present on Solaris */ + dup_addrstr = gf_strdup(addrstr); + addrtok = strtok_r(dup_addrstr, ",", &svptr); + while (addrtok) { + /* CASEFOLD not present on Solaris */ #ifdef FNM_CASEFOLD - ret = fnmatch (addrtok, ip, FNM_CASEFOLD); + ret = fnmatch(addrtok, ip, FNM_CASEFOLD); #else - ret = fnmatch (addrtok, ip, 0); + ret = fnmatch(addrtok, ip, 0); #endif - if (ret == 0) - goto err; + if (ret == 0) + goto err; - /* compare hostnames if applicable */ - if (hostname) { + /* compare hostnames if applicable */ + if (hostname) { #ifdef FNM_CASEFOLD - ret = fnmatch (addrtok, hostname, FNM_CASEFOLD); + ret = fnmatch(addrtok, hostname, FNM_CASEFOLD); #else - ret = fnmatch (addrtok, hostname, 0); + ret = fnmatch(addrtok, hostname, 0); #endif - if (ret == 0) - goto err; - } - - /* Compare IPv4 subnetwork, TODO: IPv6 subnet support */ - if (strchr (addrtok, '/')) { - ret = rpcsvc_match_subnet_v4 (addrtok, ip); - if (ret == 0) - goto err; - } + if (ret == 0) + goto err; + } - addrtok = strtok_r (NULL, ",", &svptr); + /* Compare IPv4 subnetwork, TODO: IPv6 subnet support */ + if (strchr(addrtok, '/')) { + ret = rpcsvc_match_subnet_v4(addrtok, ip); + if (ret == 0) + goto err; } - ret = -1; + addrtok = strtok_r(NULL, ",", &svptr); + } + + ret = -1; err: - GF_FREE (dup_addrstr); + GF_FREE(dup_addrstr); - return ret; + return ret; } - static int -rpcsvc_transport_peer_check_allow (dict_t *options, char *volname, - char *ip, char *hostname) +rpcsvc_transport_peer_check_allow(dict_t *options, char *volname, char *ip, + char *hostname) { - int ret = RPCSVC_AUTH_DONTCARE; - char *srchstr = NULL; + int ret = RPCSVC_AUTH_DONTCARE; + char *srchstr = NULL; - if ((!options) || (!ip) || (!volname)) - return ret; + if ((!options) || (!ip) || (!volname)) + return ret; - ret = gf_asprintf (&srchstr, "rpc-auth.addr.%s.allow", volname); - if (ret == -1) { - gf_log (GF_RPCSVC, GF_LOG_ERROR, "asprintf failed"); - ret = RPCSVC_AUTH_DONTCARE; - goto out; - } + ret = gf_asprintf(&srchstr, "rpc-auth.addr.%s.allow", volname); + if (ret == -1) { + gf_log(GF_RPCSVC, GF_LOG_ERROR, "asprintf failed"); + ret = RPCSVC_AUTH_DONTCARE; + goto out; + } - ret = rpcsvc_transport_peer_check_search (options, srchstr, - ip, hostname); - GF_FREE (srchstr); + ret = rpcsvc_transport_peer_check_search(options, srchstr, ip, hostname); + GF_FREE(srchstr); - if (ret == 0) - ret = RPCSVC_AUTH_ACCEPT; - else - ret = RPCSVC_AUTH_REJECT; + if (ret == 0) + ret = RPCSVC_AUTH_ACCEPT; + else + ret = RPCSVC_AUTH_REJECT; out: - return ret; + return ret; } static int -rpcsvc_transport_peer_check_reject (dict_t *options, char *volname, - char *ip, char *hostname) +rpcsvc_transport_peer_check_reject(dict_t *options, char *volname, char *ip, + char *hostname) { - int ret = RPCSVC_AUTH_DONTCARE; - char *srchstr = NULL; + int ret = RPCSVC_AUTH_DONTCARE; + char *srchstr = NULL; - if ((!options) || (!ip) || (!volname)) - return ret; + if ((!options) || (!ip) || (!volname)) + return ret; - ret = gf_asprintf (&srchstr, "rpc-auth.addr.%s.reject", - volname); - if (ret == -1) { - gf_log (GF_RPCSVC, GF_LOG_ERROR, "asprintf failed"); - ret = RPCSVC_AUTH_REJECT; - goto out; - } + ret = gf_asprintf(&srchstr, "rpc-auth.addr.%s.reject", volname); + if (ret == -1) { + gf_log(GF_RPCSVC, GF_LOG_ERROR, "asprintf failed"); + ret = RPCSVC_AUTH_REJECT; + goto out; + } - ret = rpcsvc_transport_peer_check_search (options, srchstr, - ip, hostname); - GF_FREE (srchstr); + ret = rpcsvc_transport_peer_check_search(options, srchstr, ip, hostname); + GF_FREE(srchstr); - if (ret == 0) - ret = RPCSVC_AUTH_REJECT; - else - ret = RPCSVC_AUTH_DONTCARE; + if (ret == 0) + ret = RPCSVC_AUTH_REJECT; + else + ret = RPCSVC_AUTH_DONTCARE; out: - return ret; + return ret; } - /* Combines rpc auth's allow and reject options. * Order of checks is important. * First, REJECT if either rejects. @@ -2749,188 +2751,188 @@ out: * If neither accepts, DONTCARE */ int -rpcsvc_combine_allow_reject_volume_check (int allow, int reject) +rpcsvc_combine_allow_reject_volume_check(int allow, int reject) { - if (allow == RPCSVC_AUTH_REJECT || - reject == RPCSVC_AUTH_REJECT) - return RPCSVC_AUTH_REJECT; + if (allow == RPCSVC_AUTH_REJECT || reject == RPCSVC_AUTH_REJECT) + return RPCSVC_AUTH_REJECT; - if (allow == RPCSVC_AUTH_ACCEPT || - reject == RPCSVC_AUTH_ACCEPT) - return RPCSVC_AUTH_ACCEPT; + if (allow == RPCSVC_AUTH_ACCEPT || reject == RPCSVC_AUTH_ACCEPT) + return RPCSVC_AUTH_ACCEPT; - return RPCSVC_AUTH_DONTCARE; + return RPCSVC_AUTH_DONTCARE; } int -rpcsvc_auth_check (rpcsvc_t *svc, char *volname, char *ipaddr) -{ - int ret = RPCSVC_AUTH_REJECT; - int accept = RPCSVC_AUTH_REJECT; - int reject = RPCSVC_AUTH_REJECT; - char *hostname = NULL; - char *allow_str = NULL; - char *reject_str = NULL; - char *srchstr = NULL; - dict_t *options = NULL; - - if (!svc || !volname || !ipaddr) - return ret; - - /* Fetch the options from svc struct and validate */ - options = svc->options; - if (!options) - return ret; - - /* Accept if its the default case: Allow all, Reject none - * The default volfile always contains a 'allow *' rule - * for each volume. If allow rule is missing (which implies - * there is some bad volfile generating code doing this), we - * assume no one is allowed mounts, and thus, we reject mounts. - */ - ret = gf_asprintf (&srchstr, "rpc-auth.addr.%s.allow", volname); - if (ret == -1) { - gf_log (GF_RPCSVC, GF_LOG_ERROR, "asprintf failed"); - return RPCSVC_AUTH_REJECT; - } - - ret = dict_get_str (options, srchstr, &allow_str); - GF_FREE (srchstr); - if (ret < 0) - return RPCSVC_AUTH_REJECT; - - ret = gf_asprintf (&srchstr, "rpc-auth.addr.%s.reject", volname); - if (ret == -1) { - gf_log (GF_RPCSVC, GF_LOG_ERROR, "asprintf failed"); - return RPCSVC_AUTH_REJECT; - } - - ret = dict_get_str (options, srchstr, &reject_str); - GF_FREE (srchstr); +rpcsvc_auth_check(rpcsvc_t *svc, char *volname, char *ipaddr) +{ + int ret = RPCSVC_AUTH_REJECT; + int accept = RPCSVC_AUTH_REJECT; + int reject = RPCSVC_AUTH_REJECT; + char *hostname = NULL; + char *allow_str = NULL; + char *reject_str = NULL; + char *srchstr = NULL; + dict_t *options = NULL; + + if (!svc || !volname || !ipaddr) + return ret; - /* - * If "reject_str" is being set as '*' (anonymous), then NFS-server - * would reject everything. If the "reject_str" is not set and - * "allow_str" is set as '*' (anonymous), then NFS-server would - * accept mount requests from all clients. - */ - if (reject_str != NULL) { - if (!strcmp ("*", reject_str)) - return RPCSVC_AUTH_REJECT; - } else { - if (!strcmp ("*", allow_str)) - return RPCSVC_AUTH_ACCEPT; - } + /* Fetch the options from svc struct and validate */ + options = svc->options; + if (!options) + return ret; - /* addr-namelookup check */ - if (svc->addr_namelookup == _gf_true) { - ret = gf_get_hostname_from_ip (ipaddr, &hostname); - if (ret) { - if (hostname) - GF_FREE (hostname); - /* failed to get hostname, but hostname auth - * is enabled, so authentication will not be - * 100% correct. reject mounts - */ - return RPCSVC_AUTH_REJECT; - } + /* Accept if its the default case: Allow all, Reject none + * The default volfile always contains a 'allow *' rule + * for each volume. If allow rule is missing (which implies + * there is some bad volfile generating code doing this), we + * assume no one is allowed mounts, and thus, we reject mounts. + */ + ret = gf_asprintf(&srchstr, "rpc-auth.addr.%s.allow", volname); + if (ret == -1) { + gf_log(GF_RPCSVC, GF_LOG_ERROR, "asprintf failed"); + return RPCSVC_AUTH_REJECT; + } + + ret = dict_get_str(options, srchstr, &allow_str); + GF_FREE(srchstr); + if (ret < 0) + return RPCSVC_AUTH_REJECT; + + ret = gf_asprintf(&srchstr, "rpc-auth.addr.%s.reject", volname); + if (ret == -1) { + gf_log(GF_RPCSVC, GF_LOG_ERROR, "asprintf failed"); + return RPCSVC_AUTH_REJECT; + } + + ret = dict_get_str(options, srchstr, &reject_str); + GF_FREE(srchstr); + + /* + * If "reject_str" is being set as '*' (anonymous), then NFS-server + * would reject everything. If the "reject_str" is not set and + * "allow_str" is set as '*' (anonymous), then NFS-server would + * accept mount requests from all clients. + */ + if (reject_str != NULL) { + if (!strcmp("*", reject_str)) + return RPCSVC_AUTH_REJECT; + } else { + if (!strcmp("*", allow_str)) + return RPCSVC_AUTH_ACCEPT; + } + + /* addr-namelookup check */ + if (svc->addr_namelookup == _gf_true) { + ret = gf_get_hostname_from_ip(ipaddr, &hostname); + if (ret) { + if (hostname) + GF_FREE(hostname); + /* failed to get hostname, but hostname auth + * is enabled, so authentication will not be + * 100% correct. reject mounts + */ + return RPCSVC_AUTH_REJECT; } + } - accept = rpcsvc_transport_peer_check_allow (options, volname, - ipaddr, hostname); + accept = rpcsvc_transport_peer_check_allow(options, volname, ipaddr, + hostname); - reject = rpcsvc_transport_peer_check_reject (options, volname, - ipaddr, hostname); + reject = rpcsvc_transport_peer_check_reject(options, volname, ipaddr, + hostname); - if (hostname) - GF_FREE (hostname); - return rpcsvc_combine_allow_reject_volume_check (accept, reject); + if (hostname) + GF_FREE(hostname); + return rpcsvc_combine_allow_reject_volume_check(accept, reject); } int -rpcsvc_transport_privport_check (rpcsvc_t *svc, char *volname, uint16_t port) +rpcsvc_transport_privport_check(rpcsvc_t *svc, char *volname, uint16_t port) { - int ret = RPCSVC_AUTH_REJECT; - char *srchstr = NULL; - char *valstr = NULL; - gf_boolean_t insecure = _gf_false; - - if ((!svc) || (!volname)) - return ret; - - gf_log (GF_RPCSVC, GF_LOG_TRACE, "Client port: %d", (int)port); - /* If the port is already a privileged one, don't bother with checking - * options. - */ - if (port <= 1024) { - ret = RPCSVC_AUTH_ACCEPT; - goto err; - } - - /* Disabled by default */ - ret = gf_asprintf (&srchstr, "rpc-auth.ports.%s.insecure", volname); - if (ret == -1) { - gf_log (GF_RPCSVC, GF_LOG_ERROR, "asprintf failed"); - ret = RPCSVC_AUTH_REJECT; - goto err; - } + int ret = RPCSVC_AUTH_REJECT; + char *srchstr = NULL; + char *valstr = NULL; + gf_boolean_t insecure = _gf_false; - ret = dict_get_str (svc->options, srchstr, &valstr); - if (ret) { - gf_log (GF_RPCSVC, GF_LOG_ERROR, "Failed to" - " read rpc-auth.ports.insecure value"); - goto err; - } - - ret = gf_string2boolean (valstr, &insecure); - if (ret) { - gf_log (GF_RPCSVC, GF_LOG_ERROR, "Failed to" - " convert rpc-auth.ports.insecure value"); - goto err; - } + if ((!svc) || (!volname)) + return ret; - ret = insecure ? RPCSVC_AUTH_ACCEPT : RPCSVC_AUTH_REJECT; - - if (ret == RPCSVC_AUTH_ACCEPT) - gf_log (GF_RPCSVC, GF_LOG_DEBUG, "Unprivileged port allowed"); - else - gf_log (GF_RPCSVC, GF_LOG_DEBUG, "Unprivileged port not" - " allowed"); + gf_log(GF_RPCSVC, GF_LOG_TRACE, "Client port: %d", (int)port); + /* If the port is already a privileged one, don't bother with checking + * options. + */ + if (port <= 1024) { + ret = RPCSVC_AUTH_ACCEPT; + goto err; + } + + /* Disabled by default */ + ret = gf_asprintf(&srchstr, "rpc-auth.ports.%s.insecure", volname); + if (ret == -1) { + gf_log(GF_RPCSVC, GF_LOG_ERROR, "asprintf failed"); + ret = RPCSVC_AUTH_REJECT; + goto err; + } + + ret = dict_get_str(svc->options, srchstr, &valstr); + if (ret) { + gf_log(GF_RPCSVC, GF_LOG_ERROR, + "Failed to" + " read rpc-auth.ports.insecure value"); + goto err; + } + + ret = gf_string2boolean(valstr, &insecure); + if (ret) { + gf_log(GF_RPCSVC, GF_LOG_ERROR, + "Failed to" + " convert rpc-auth.ports.insecure value"); + goto err; + } + + ret = insecure ? RPCSVC_AUTH_ACCEPT : RPCSVC_AUTH_REJECT; + + if (ret == RPCSVC_AUTH_ACCEPT) + gf_log(GF_RPCSVC, GF_LOG_DEBUG, "Unprivileged port allowed"); + else + gf_log(GF_RPCSVC, GF_LOG_DEBUG, + "Unprivileged port not" + " allowed"); err: - if (srchstr) - GF_FREE (srchstr); + if (srchstr) + GF_FREE(srchstr); - return ret; + return ret; } - char * -rpcsvc_volume_allowed (dict_t *options, char *volname) +rpcsvc_volume_allowed(dict_t *options, char *volname) { - char globalrule[] = "rpc-auth.addr.allow"; - char *srchstr = NULL; - char *addrstr = NULL; - int ret = -1; + char globalrule[] = "rpc-auth.addr.allow"; + char *srchstr = NULL; + char *addrstr = NULL; + int ret = -1; - if ((!options) || (!volname)) - return NULL; + if ((!options) || (!volname)) + return NULL; - ret = gf_asprintf (&srchstr, "rpc-auth.addr.%s.allow", volname); - if (ret == -1) { - gf_log (GF_RPCSVC, GF_LOG_ERROR, "asprintf failed"); - goto out; - } + ret = gf_asprintf(&srchstr, "rpc-auth.addr.%s.allow", volname); + if (ret == -1) { + gf_log(GF_RPCSVC, GF_LOG_ERROR, "asprintf failed"); + goto out; + } - if (!dict_get (options, srchstr)) - ret = dict_get_str (options, globalrule, &addrstr); - else - ret = dict_get_str (options, srchstr, &addrstr); + if (!dict_get(options, srchstr)) + ret = dict_get_str(options, globalrule, &addrstr); + else + ret = dict_get_str(options, srchstr, &addrstr); out: - GF_FREE (srchstr); + GF_FREE(srchstr); - return addrstr; + return addrstr; } /* @@ -2944,56 +2946,61 @@ out: * as it's already being done at the time of CLI SET. */ static int -rpcsvc_match_subnet_v4 (const char *addrtok, const char *ipaddr) -{ - char *slash = NULL; - char *netaddr = NULL; - int ret = -1; - uint32_t prefixlen = 0; - uint32_t shift = 0; - struct sockaddr_in sin1 = {0, }; - struct sockaddr_in sin2 = {0, }; - struct sockaddr_in mask = {0, }; - - /* Copy the input */ - netaddr = gf_strdup (addrtok); - if (netaddr == NULL) /* ENOMEM */ - goto out; - - /* Find the network socket addr of target */ - if (inet_pton (AF_INET, ipaddr, &sin1.sin_addr) == 0) - goto out; - - /* Find the network socket addr of subnet pattern */ - if (inet_pton (AF_INET, netaddr, &sin2.sin_addr) == 0) - goto out; - - slash = strchr (netaddr, '/'); - if (slash) { - *slash = '\0'; - /* - * Find the IPv4 network mask in network byte order. - * IMP: String slash+1 is already validated, it can't have value - * more than IPv4_ADDR_SIZE (32). - */ - prefixlen = (uint32_t) atoi (slash + 1); - if (prefixlen > 31) - goto out; - } else { - goto out; - } - - shift = IPv4_ADDR_SIZE - prefixlen; - mask.sin_addr.s_addr = htonl ((uint32_t)~0 << shift); - - if (mask_match (sin1.sin_addr.s_addr, - sin2.sin_addr.s_addr, - mask.sin_addr.s_addr)) { - ret = 0; /* SUCCESS */ - } +rpcsvc_match_subnet_v4(const char *addrtok, const char *ipaddr) +{ + char *slash = NULL; + char *netaddr = NULL; + int ret = -1; + uint32_t prefixlen = 0; + uint32_t shift = 0; + struct sockaddr_in sin1 = { + 0, + }; + struct sockaddr_in sin2 = { + 0, + }; + struct sockaddr_in mask = { + 0, + }; + + /* Copy the input */ + netaddr = gf_strdup(addrtok); + if (netaddr == NULL) /* ENOMEM */ + goto out; + + /* Find the network socket addr of target */ + if (inet_pton(AF_INET, ipaddr, &sin1.sin_addr) == 0) + goto out; + + /* Find the network socket addr of subnet pattern */ + if (inet_pton(AF_INET, netaddr, &sin2.sin_addr) == 0) + goto out; + + slash = strchr(netaddr, '/'); + if (slash) { + *slash = '\0'; + /* + * Find the IPv4 network mask in network byte order. + * IMP: String slash+1 is already validated, it can't have value + * more than IPv4_ADDR_SIZE (32). + */ + prefixlen = (uint32_t)atoi(slash + 1); + if (prefixlen > 31) + goto out; + } else { + goto out; + } + + shift = IPv4_ADDR_SIZE - prefixlen; + mask.sin_addr.s_addr = htonl((uint32_t)~0 << shift); + + if (mask_match(sin1.sin_addr.s_addr, sin2.sin_addr.s_addr, + mask.sin_addr.s_addr)) { + ret = 0; /* SUCCESS */ + } out: - GF_FREE (netaddr); - return ret; + GF_FREE(netaddr); + return ret; } /* During reconfigure, Make sure to call this function after event-threads are @@ -3001,45 +3008,43 @@ out: */ int -rpcsvc_ownthread_reconf (rpcsvc_t *svc, int new_eventthreadcount) +rpcsvc_ownthread_reconf(rpcsvc_t *svc, int new_eventthreadcount) { - int ret = -1; - rpcsvc_program_t *program = NULL; + int ret = -1; + rpcsvc_program_t *program = NULL; - if (!svc) { - ret = 0; - goto out; - } + if (!svc) { + ret = 0; + goto out; + } - pthread_rwlock_wrlock (&svc->rpclock); + pthread_rwlock_wrlock(&svc->rpclock); + { + list_for_each_entry(program, &svc->programs, program) { - list_for_each_entry (program, &svc->programs, program) { - if (program->ownthread) { - program->eventthreadcount = - new_eventthreadcount; - rpcsvc_spawn_threads (svc, program); - } - } + if (program->ownthread) { + program->eventthreadcount = new_eventthreadcount; + rpcsvc_spawn_threads(svc, program); + } } - pthread_rwlock_unlock (&svc->rpclock); + } + pthread_rwlock_unlock(&svc->rpclock); - ret = 0; + ret = 0; out: - return ret; + return ret; } - rpcsvc_actor_t gluster_dump_actors[GF_DUMP_MAXVALUE] = { - [GF_DUMP_NULL] = {"NULL", GF_DUMP_NULL, NULL, NULL, 0, DRC_NA}, - [GF_DUMP_DUMP] = {"DUMP", GF_DUMP_DUMP, rpcsvc_dump, NULL, 0, DRC_NA}, - [GF_DUMP_PING] = {"PING", GF_DUMP_PING, rpcsvc_ping, NULL, 0, DRC_NA}, + [GF_DUMP_NULL] = {"NULL", GF_DUMP_NULL, NULL, NULL, 0, DRC_NA}, + [GF_DUMP_DUMP] = {"DUMP", GF_DUMP_DUMP, rpcsvc_dump, NULL, 0, DRC_NA}, + [GF_DUMP_PING] = {"PING", GF_DUMP_PING, rpcsvc_ping, NULL, 0, DRC_NA}, }; - struct rpcsvc_program gluster_dump_prog = { - .progname = "GF-DUMP", - .prognum = GLUSTER_DUMP_PROGRAM, - .progver = GLUSTER_DUMP_VERSION, - .actors = gluster_dump_actors, - .numactors = GF_DUMP_MAXVALUE, + .progname = "GF-DUMP", + .prognum = GLUSTER_DUMP_PROGRAM, + .progver = GLUSTER_DUMP_VERSION, + .actors = gluster_dump_actors, + .numactors = GF_DUMP_MAXVALUE, }; diff --git a/rpc/rpc-lib/src/xdr-rpc.c b/rpc/rpc-lib/src/xdr-rpc.c index 88a7637b887..36fd9db1a97 100644 --- a/rpc/rpc-lib/src/xdr-rpc.c +++ b/rpc/rpc-lib/src/xdr-rpc.c @@ -25,183 +25,178 @@ * The remaining payload is returned into payload. */ int -xdr_to_rpc_call (char *msgbuf, size_t len, struct rpc_msg *call, - struct iovec *payload, char *credbytes, char *verfbytes) +xdr_to_rpc_call(char *msgbuf, size_t len, struct rpc_msg *call, + struct iovec *payload, char *credbytes, char *verfbytes) { - XDR xdr; - char opaquebytes[GF_MAX_AUTH_BYTES]; - struct opaque_auth *oa = NULL; - int ret = -1; - - GF_VALIDATE_OR_GOTO ("rpc", msgbuf, out); - GF_VALIDATE_OR_GOTO ("rpc", call, out); - - memset (call, 0, sizeof (*call)); - - oa = &call->rm_call.cb_cred; - if (!credbytes) - oa->oa_base = opaquebytes; - else - oa->oa_base = credbytes; - - oa = &call->rm_call.cb_verf; - if (!verfbytes) - oa->oa_base = opaquebytes; - else - oa->oa_base = verfbytes; - - xdrmem_create (&xdr, msgbuf, len, XDR_DECODE); - if (!xdr_callmsg (&xdr, call)) { - gf_log ("rpc", GF_LOG_WARNING, "failed to decode call msg"); - goto out; - } - - if (payload) { - payload->iov_base = xdr_decoded_remaining_addr (xdr); - payload->iov_len = xdr_decoded_remaining_len (xdr); - } - - ret = 0; + XDR xdr; + char opaquebytes[GF_MAX_AUTH_BYTES]; + struct opaque_auth *oa = NULL; + int ret = -1; + + GF_VALIDATE_OR_GOTO("rpc", msgbuf, out); + GF_VALIDATE_OR_GOTO("rpc", call, out); + + memset(call, 0, sizeof(*call)); + + oa = &call->rm_call.cb_cred; + if (!credbytes) + oa->oa_base = opaquebytes; + else + oa->oa_base = credbytes; + + oa = &call->rm_call.cb_verf; + if (!verfbytes) + oa->oa_base = opaquebytes; + else + oa->oa_base = verfbytes; + + xdrmem_create(&xdr, msgbuf, len, XDR_DECODE); + if (!xdr_callmsg(&xdr, call)) { + gf_log("rpc", GF_LOG_WARNING, "failed to decode call msg"); + goto out; + } + + if (payload) { + payload->iov_base = xdr_decoded_remaining_addr(xdr); + payload->iov_len = xdr_decoded_remaining_len(xdr); + } + + ret = 0; out: - return ret; + return ret; } - bool_t -true_func (XDR *s, caddr_t *a) +true_func(XDR *s, caddr_t *a) { - return TRUE; + return TRUE; } - int -rpc_fill_empty_reply (struct rpc_msg *reply, uint32_t xid) +rpc_fill_empty_reply(struct rpc_msg *reply, uint32_t xid) { - int ret = -1; + int ret = -1; - GF_VALIDATE_OR_GOTO ("rpc", reply, out); + GF_VALIDATE_OR_GOTO("rpc", reply, out); - /* Setting to 0 also results in reply verifier flavor to be - * set to AUTH_NULL which is what we want right now. - */ - memset (reply, 0, sizeof (*reply)); - reply->rm_xid = xid; - reply->rm_direction = REPLY; + /* Setting to 0 also results in reply verifier flavor to be + * set to AUTH_NULL which is what we want right now. + */ + memset(reply, 0, sizeof(*reply)); + reply->rm_xid = xid; + reply->rm_direction = REPLY; - ret = 0; + ret = 0; out: - return ret; + return ret; } int -rpc_fill_denied_reply (struct rpc_msg *reply, int rjstat, int auth_err) +rpc_fill_denied_reply(struct rpc_msg *reply, int rjstat, int auth_err) { - int ret = -1; - - GF_VALIDATE_OR_GOTO ("rpc", reply, out); - - reply->rm_reply.rp_stat = MSG_DENIED; - reply->rjcted_rply.rj_stat = rjstat; - if (rjstat == RPC_MISMATCH) { - /* No problem with hardcoding - * RPC version numbers. We only support - * v2 anyway. - */ - reply->rjcted_rply.rj_vers.low = 2; - reply->rjcted_rply.rj_vers.high = 2; - } else if (rjstat == AUTH_ERROR) - reply->rjcted_rply.rj_why = auth_err; - - ret = 0; + int ret = -1; + + GF_VALIDATE_OR_GOTO("rpc", reply, out); + + reply->rm_reply.rp_stat = MSG_DENIED; + reply->rjcted_rply.rj_stat = rjstat; + if (rjstat == RPC_MISMATCH) { + /* No problem with hardcoding + * RPC version numbers. We only support + * v2 anyway. + */ + reply->rjcted_rply.rj_vers.low = 2; + reply->rjcted_rply.rj_vers.high = 2; + } else if (rjstat == AUTH_ERROR) + reply->rjcted_rply.rj_why = auth_err; + + ret = 0; out: - return ret; + return ret; } - int -rpc_fill_accepted_reply (struct rpc_msg *reply, int arstat, int proglow, - int proghigh, int verf, int len, char *vdata) +rpc_fill_accepted_reply(struct rpc_msg *reply, int arstat, int proglow, + int proghigh, int verf, int len, char *vdata) { - int ret = -1; - - GF_VALIDATE_OR_GOTO ("rpc", reply, out); - - reply->rm_reply.rp_stat = MSG_ACCEPTED; - reply->acpted_rply.ar_stat = arstat; - - reply->acpted_rply.ar_verf.oa_flavor = verf; - reply->acpted_rply.ar_verf.oa_length = len; - reply->acpted_rply.ar_verf.oa_base = vdata; - if (arstat == PROG_MISMATCH) { - reply->acpted_rply.ar_vers.low = proglow; - reply->acpted_rply.ar_vers.high = proghigh; - } else if (arstat == SUCCESS) { - - /* This is a hack. I'd really like to build a custom - * XDR library because Sun RPC interface is not very flexible. - */ - reply->acpted_rply.ar_results.proc = (xdrproc_t)true_func; - reply->acpted_rply.ar_results.where = NULL; - } + int ret = -1; + + GF_VALIDATE_OR_GOTO("rpc", reply, out); + + reply->rm_reply.rp_stat = MSG_ACCEPTED; + reply->acpted_rply.ar_stat = arstat; + + reply->acpted_rply.ar_verf.oa_flavor = verf; + reply->acpted_rply.ar_verf.oa_length = len; + reply->acpted_rply.ar_verf.oa_base = vdata; + if (arstat == PROG_MISMATCH) { + reply->acpted_rply.ar_vers.low = proglow; + reply->acpted_rply.ar_vers.high = proghigh; + } else if (arstat == SUCCESS) { + /* This is a hack. I'd really like to build a custom + * XDR library because Sun RPC interface is not very flexible. + */ + reply->acpted_rply.ar_results.proc = (xdrproc_t)true_func; + reply->acpted_rply.ar_results.where = NULL; + } - ret = 0; + ret = 0; out: - return ret; + return ret; } int -rpc_reply_to_xdr (struct rpc_msg *reply, char *dest, size_t len, - struct iovec *dst) +rpc_reply_to_xdr(struct rpc_msg *reply, char *dest, size_t len, + struct iovec *dst) { - XDR xdr; - int ret = -1; + XDR xdr; + int ret = -1; - GF_VALIDATE_OR_GOTO ("rpc", reply, out); - GF_VALIDATE_OR_GOTO ("rpc", dest, out); - GF_VALIDATE_OR_GOTO ("rpc", dst, out); + GF_VALIDATE_OR_GOTO("rpc", reply, out); + GF_VALIDATE_OR_GOTO("rpc", dest, out); + GF_VALIDATE_OR_GOTO("rpc", dst, out); - xdrmem_create (&xdr, dest, len, XDR_ENCODE); - if (!xdr_replymsg(&xdr, reply)) { - gf_log ("rpc", GF_LOG_WARNING, "failed to encode reply msg"); - goto out; - } + xdrmem_create(&xdr, dest, len, XDR_ENCODE); + if (!xdr_replymsg(&xdr, reply)) { + gf_log("rpc", GF_LOG_WARNING, "failed to encode reply msg"); + goto out; + } - dst->iov_base = dest; - dst->iov_len = xdr_encoded_length (xdr); + dst->iov_base = dest; + dst->iov_len = xdr_encoded_length(xdr); - ret = 0; + ret = 0; out: - return ret; + return ret; } - int -xdr_to_auth_unix_cred (char *msgbuf, int msglen, struct authunix_parms *au, - char *machname, gid_t *gids) +xdr_to_auth_unix_cred(char *msgbuf, int msglen, struct authunix_parms *au, + char *machname, gid_t *gids) { - XDR xdr; - int ret = -1; + XDR xdr; + int ret = -1; - GF_VALIDATE_OR_GOTO ("rpc", msgbuf, out); - GF_VALIDATE_OR_GOTO ("rpc", machname, out); - GF_VALIDATE_OR_GOTO ("rpc", gids, out); - GF_VALIDATE_OR_GOTO ("rpc", au, out); + GF_VALIDATE_OR_GOTO("rpc", msgbuf, out); + GF_VALIDATE_OR_GOTO("rpc", machname, out); + GF_VALIDATE_OR_GOTO("rpc", gids, out); + GF_VALIDATE_OR_GOTO("rpc", au, out); - au->aup_machname = machname; + au->aup_machname = machname; #if defined(GF_DARWIN_HOST_OS) || defined(__FreeBSD__) - au->aup_gids = (int *)gids; + au->aup_gids = (int *)gids; #else - au->aup_gids = gids; + au->aup_gids = gids; #endif - xdrmem_create (&xdr, msgbuf, msglen, XDR_DECODE); + xdrmem_create(&xdr, msgbuf, msglen, XDR_DECODE); - if (!xdr_authunix_parms (&xdr, au)) { - gf_log ("rpc", GF_LOG_WARNING, "failed to decode auth unix parms"); - goto out; - } + if (!xdr_authunix_parms(&xdr, au)) { + gf_log("rpc", GF_LOG_WARNING, "failed to decode auth unix parms"); + goto out; + } - ret = 0; + ret = 0; out: - return ret; + return ret; } diff --git a/rpc/rpc-lib/src/xdr-rpcclnt.c b/rpc/rpc-lib/src/xdr-rpcclnt.c index 5b470442d71..9e60d19e7a2 100644 --- a/rpc/rpc-lib/src/xdr-rpcclnt.c +++ b/rpc/rpc-lib/src/xdr-rpcclnt.c @@ -26,86 +26,84 @@ * The remaining payload is returned into payload. */ int -xdr_to_rpc_reply (char *msgbuf, size_t len, struct rpc_msg *reply, - struct iovec *payload, char *verfbytes) +xdr_to_rpc_reply(char *msgbuf, size_t len, struct rpc_msg *reply, + struct iovec *payload, char *verfbytes) { - XDR xdr; - int ret = -EINVAL; + XDR xdr; + int ret = -EINVAL; - GF_VALIDATE_OR_GOTO ("rpc", msgbuf, out); - GF_VALIDATE_OR_GOTO ("rpc", reply, out); + GF_VALIDATE_OR_GOTO("rpc", msgbuf, out); + GF_VALIDATE_OR_GOTO("rpc", reply, out); - memset (reply, 0, sizeof (struct rpc_msg)); + memset(reply, 0, sizeof(struct rpc_msg)); - reply->acpted_rply.ar_verf = _null_auth; - reply->acpted_rply.ar_results.where = NULL; - reply->acpted_rply.ar_results.proc = (xdrproc_t)(xdr_void); + reply->acpted_rply.ar_verf = _null_auth; + reply->acpted_rply.ar_results.where = NULL; + reply->acpted_rply.ar_results.proc = (xdrproc_t)(xdr_void); - xdrmem_create (&xdr, msgbuf, len, XDR_DECODE); - if (!xdr_replymsg (&xdr, reply)) { - gf_log ("rpc", GF_LOG_WARNING, "failed to decode reply msg"); - goto out; - } - if (payload) { - payload->iov_base = xdr_decoded_remaining_addr (xdr); - payload->iov_len = xdr_decoded_remaining_len (xdr); - } + xdrmem_create(&xdr, msgbuf, len, XDR_DECODE); + if (!xdr_replymsg(&xdr, reply)) { + gf_log("rpc", GF_LOG_WARNING, "failed to decode reply msg"); + goto out; + } + if (payload) { + payload->iov_base = xdr_decoded_remaining_addr(xdr); + payload->iov_len = xdr_decoded_remaining_len(xdr); + } - ret = 0; + ret = 0; out: - return ret; + return ret; } - int -rpc_request_to_xdr (struct rpc_msg *request, char *dest, size_t len, - struct iovec *dst) +rpc_request_to_xdr(struct rpc_msg *request, char *dest, size_t len, + struct iovec *dst) { - XDR xdr; - int ret = -1; + XDR xdr; + int ret = -1; - GF_VALIDATE_OR_GOTO ("rpc", dest, out); - GF_VALIDATE_OR_GOTO ("rpc", request, out); - GF_VALIDATE_OR_GOTO ("rpc", dst, out); + GF_VALIDATE_OR_GOTO("rpc", dest, out); + GF_VALIDATE_OR_GOTO("rpc", request, out); + GF_VALIDATE_OR_GOTO("rpc", dst, out); - xdrmem_create (&xdr, dest, len, XDR_ENCODE); - if (!xdr_callmsg (&xdr, request)) { - gf_log ("rpc", GF_LOG_WARNING, "failed to encode call msg"); - goto out; - } + xdrmem_create(&xdr, dest, len, XDR_ENCODE); + if (!xdr_callmsg(&xdr, request)) { + gf_log("rpc", GF_LOG_WARNING, "failed to encode call msg"); + goto out; + } - dst->iov_base = dest; - dst->iov_len = xdr_encoded_length (xdr); + dst->iov_base = dest; + dst->iov_len = xdr_encoded_length(xdr); - ret = 0; + ret = 0; out: - return ret; + return ret; } - int -auth_unix_cred_to_xdr (struct authunix_parms *au, char *dest, size_t len, - struct iovec *iov) +auth_unix_cred_to_xdr(struct authunix_parms *au, char *dest, size_t len, + struct iovec *iov) { - XDR xdr; - int ret = -1; + XDR xdr; + int ret = -1; - GF_VALIDATE_OR_GOTO ("rpc", au, out); - GF_VALIDATE_OR_GOTO ("rpc", dest, out); - GF_VALIDATE_OR_GOTO ("rpc", iov, out); + GF_VALIDATE_OR_GOTO("rpc", au, out); + GF_VALIDATE_OR_GOTO("rpc", dest, out); + GF_VALIDATE_OR_GOTO("rpc", iov, out); - xdrmem_create (&xdr, dest, len, XDR_DECODE); + xdrmem_create(&xdr, dest, len, XDR_DECODE); - if (!xdr_authunix_parms (&xdr, au)) { - gf_log ("rpc", GF_LOG_WARNING, "failed to decode authunix parms"); - goto out; - } + if (!xdr_authunix_parms(&xdr, au)) { + gf_log("rpc", GF_LOG_WARNING, "failed to decode authunix parms"); + goto out; + } - iov->iov_base = dest; - iov->iov_len = xdr_encoded_length (xdr); + iov->iov_base = dest; + iov->iov_len = xdr_encoded_length(xdr); - ret = 0; + ret = 0; out: - return ret; + return ret; } diff --git a/rpc/rpc-transport/rdma/src/name.c b/rpc/rpc-transport/rdma/src/name.c index 2db1f08c751..ea960cba4eb 100644 --- a/rpc/rpc-transport/rdma/src/name.c +++ b/rpc/rpc-transport/rdma/src/name.c @@ -25,85 +25,82 @@ #include "rpc-lib-messages.h" #include "rpc-trans-rdma-messages.h" - int32_t -gf_resolve_ip6 (const char *hostname, - uint16_t port, - int family, - void **dnscache, - struct addrinfo **addr_info); - +gf_resolve_ip6(const char *hostname, uint16_t port, int family, void **dnscache, + struct addrinfo **addr_info); static void -_assign_port (struct sockaddr *sockaddr, uint16_t port) +_assign_port(struct sockaddr *sockaddr, uint16_t port) { - switch (sockaddr->sa_family) { + switch (sockaddr->sa_family) { case AF_INET6: - ((struct sockaddr_in6 *)sockaddr)->sin6_port = htons (port); - break; + ((struct sockaddr_in6 *)sockaddr)->sin6_port = htons(port); + break; case AF_INET_SDP: case AF_INET: - ((struct sockaddr_in *)sockaddr)->sin_port = htons (port); - break; - } + ((struct sockaddr_in *)sockaddr)->sin_port = htons(port); + break; + } } static int32_t -af_inet_bind_to_port_lt_ceiling (struct rdma_cm_id *cm_id, - struct sockaddr *sockaddr, - socklen_t sockaddr_len, uint32_t ceiling) +af_inet_bind_to_port_lt_ceiling(struct rdma_cm_id *cm_id, + struct sockaddr *sockaddr, + socklen_t sockaddr_len, uint32_t ceiling) { #if GF_DISABLE_PRIVPORT_TRACKING - _assign_port (sockaddr, 0); - return rdma_bind_addr (cm_id, sockaddr); + _assign_port(sockaddr, 0); + return rdma_bind_addr(cm_id, sockaddr); #else - int32_t ret = -1; - uint16_t port = ceiling - 1; - unsigned char ports[GF_PORT_ARRAY_SIZE] = {0,}; - int i = 0; + int32_t ret = -1; + uint16_t port = ceiling - 1; + unsigned char ports[GF_PORT_ARRAY_SIZE] = { + 0, + }; + int i = 0; loop: - ret = gf_process_reserved_ports (ports, ceiling); + ret = gf_process_reserved_ports(ports, ceiling); - while (port) { - if (port == GF_CLIENT_PORT_CEILING) { - ret = -1; - break; - } + while (port) { + if (port == GF_CLIENT_PORT_CEILING) { + ret = -1; + break; + } - /* ignore the reserved ports */ - if (BIT_VALUE (ports, port)) { - port--; - continue; - } + /* ignore the reserved ports */ + if (BIT_VALUE(ports, port)) { + port--; + continue; + } - _assign_port (sockaddr, port); + _assign_port(sockaddr, port); - ret = rdma_bind_addr (cm_id, sockaddr); + ret = rdma_bind_addr(cm_id, sockaddr); - if (ret == 0) - break; + if (ret == 0) + break; - if (ret == -1 && errno == EACCES) - break; + if (ret == -1 && errno == EACCES) + break; - port--; - } + port--; + } - /* In case if all the secure ports are exhausted, we are no more - * binding to secure ports, hence instead of getting a random - * port, lets define the range to restrict it from getting from - * ports reserved for bricks i.e from range of 49152 - 65535 - * which further may lead to port clash */ - if (!port) { - ceiling = port = GF_CLNT_INSECURE_PORT_CEILING; - for (i = 0; i <= ceiling; i++) - BIT_CLEAR (ports, i); - goto loop; - } + /* In case if all the secure ports are exhausted, we are no more + * binding to secure ports, hence instead of getting a random + * port, lets define the range to restrict it from getting from + * ports reserved for bricks i.e from range of 49152 - 65535 + * which further may lead to port clash */ + if (!port) { + ceiling = port = GF_CLNT_INSECURE_PORT_CEILING; + for (i = 0; i <= ceiling; i++) + BIT_CLEAR(ports, i); + goto loop; + } - return ret; + return ret; #endif /* GF_DISABLE_PRIVPORT_TRACKING */ } @@ -146,596 +143,573 @@ err: #endif static int32_t -client_fill_address_family (rpc_transport_t *this, struct sockaddr *sockaddr) +client_fill_address_family(rpc_transport_t *this, struct sockaddr *sockaddr) { - data_t *address_family_data = NULL; - - address_family_data = dict_get (this->options, - "transport.address-family"); - if (!address_family_data) { - data_t *remote_host_data = NULL, *connect_path_data = NULL; - remote_host_data = dict_get (this->options, "remote-host"); - connect_path_data = dict_get (this->options, - "transport.rdma.connect-path"); - - if (!(remote_host_data || connect_path_data) || - (remote_host_data && connect_path_data)) { - gf_msg (this->name, GF_LOG_ERROR, 0, - TRANS_MSG_ADDR_FAMILY_NOT_SPECIFIED, - "address-family not specified and not able to " - "determine the same from other options " - "(remote-host:%s and connect-path:%s)", - data_to_str (remote_host_data), - data_to_str (connect_path_data)); - return -1; - } + data_t *address_family_data = NULL; + + address_family_data = dict_get(this->options, "transport.address-family"); + if (!address_family_data) { + data_t *remote_host_data = NULL, *connect_path_data = NULL; + remote_host_data = dict_get(this->options, "remote-host"); + connect_path_data = dict_get(this->options, + "transport.rdma.connect-path"); + + if (!(remote_host_data || connect_path_data) || + (remote_host_data && connect_path_data)) { + gf_msg(this->name, GF_LOG_ERROR, 0, + TRANS_MSG_ADDR_FAMILY_NOT_SPECIFIED, + "address-family not specified and not able to " + "determine the same from other options " + "(remote-host:%s and connect-path:%s)", + data_to_str(remote_host_data), + data_to_str(connect_path_data)); + return -1; + } - if (remote_host_data) { - gf_msg_debug (this->name, 0, "address-family not " - "specified, guessing it to be " - "inet/inet6"); - sockaddr->sa_family = AF_UNSPEC; - } else { - gf_msg_debug (this->name, 0, "address-family not " - "specified, guessing it to be unix"); - sockaddr->sa_family = AF_UNIX; - } + if (remote_host_data) { + gf_msg_debug(this->name, 0, + "address-family not " + "specified, guessing it to be " + "inet/inet6"); + sockaddr->sa_family = AF_UNSPEC; + } else { + gf_msg_debug(this->name, 0, + "address-family not " + "specified, guessing it to be unix"); + sockaddr->sa_family = AF_UNIX; + } + } else { + char *address_family = data_to_str(address_family_data); + if (!strcasecmp(address_family, "unix")) { + sockaddr->sa_family = AF_UNIX; + } else if (!strcasecmp(address_family, "inet")) { + sockaddr->sa_family = AF_INET; + } else if (!strcasecmp(address_family, "inet6")) { + sockaddr->sa_family = AF_INET6; + } else if (!strcasecmp(address_family, "inet-sdp")) { + sockaddr->sa_family = AF_INET_SDP; } else { - char *address_family = data_to_str (address_family_data); - if (!strcasecmp (address_family, "unix")) { - sockaddr->sa_family = AF_UNIX; - } else if (!strcasecmp (address_family, "inet")) { - sockaddr->sa_family = AF_INET; - } else if (!strcasecmp (address_family, "inet6")) { - sockaddr->sa_family = AF_INET6; - } else if (!strcasecmp (address_family, "inet-sdp")) { - sockaddr->sa_family = AF_INET_SDP; - } else { - gf_msg (this->name, GF_LOG_ERROR, 0, - TRANS_MSG_UNKNOWN_ADDR_FAMILY, - "unknown address-family (%s) specified", - address_family); - sockaddr->sa_family = AF_UNSPEC; - return -1; - } + gf_msg(this->name, GF_LOG_ERROR, 0, TRANS_MSG_UNKNOWN_ADDR_FAMILY, + "unknown address-family (%s) specified", address_family); + sockaddr->sa_family = AF_UNSPEC; + return -1; } + } - return 0; + return 0; } static int32_t -af_inet_client_get_remote_sockaddr (rpc_transport_t *this, - struct sockaddr *sockaddr, - socklen_t *sockaddr_len, - int16_t remote_port) +af_inet_client_get_remote_sockaddr(rpc_transport_t *this, + struct sockaddr *sockaddr, + socklen_t *sockaddr_len, int16_t remote_port) { - dict_t *options = this->options; - data_t *remote_host_data = NULL; - data_t *remote_port_data = NULL; - char *remote_host = NULL; - struct addrinfo *addr_info = NULL; - int32_t ret = 0; - - remote_host_data = dict_get (options, "remote-host"); - if (remote_host_data == NULL) { - gf_msg (this->name, GF_LOG_ERROR, 0, - TRANS_MSG_REMOTE_HOST_ERROR, "option remote-host " - "missing in volume %s", this->name); - ret = -1; - goto err; - } - - remote_host = data_to_str (remote_host_data); - if (remote_host == NULL) { - gf_msg (this->name, GF_LOG_ERROR, 0, - TRANS_MSG_REMOTE_HOST_ERROR, "option remote-host " - "has data NULL in volume %s", this->name); - ret = -1; - goto err; - } - - if (remote_port == 0) { - remote_port_data = dict_get (options, "remote-port"); - if (remote_port_data == NULL) { - gf_msg_debug (this->name, 0, "option remote-port " - "missing in volume %s. Defaulting to %d", - this->name, GF_DEFAULT_RDMA_LISTEN_PORT); - - remote_port = GF_DEFAULT_RDMA_LISTEN_PORT; - } else { - remote_port = data_to_uint16 (remote_port_data); - } - } - - if (remote_port == -1) { - gf_msg (this->name, GF_LOG_ERROR, EINVAL, - RDMA_MSG_INVALID_ENTRY, "option remote-port has " - "invalid port in volume %s", this->name); - ret = -1; - goto err; - } - - /* TODO: gf_resolve is a blocking call. kick in some - non blocking dns techniques */ - ret = gf_resolve_ip6 (remote_host, remote_port, - sockaddr->sa_family, - &this->dnscache, &addr_info); - if (ret == -1) { - gf_msg (this->name, GF_LOG_ERROR, 0, TRANS_MSG_DNS_RESOL_FAILED, - "DNS resolution failed on host %s", remote_host); - goto err; + dict_t *options = this->options; + data_t *remote_host_data = NULL; + data_t *remote_port_data = NULL; + char *remote_host = NULL; + struct addrinfo *addr_info = NULL; + int32_t ret = 0; + + remote_host_data = dict_get(options, "remote-host"); + if (remote_host_data == NULL) { + gf_msg(this->name, GF_LOG_ERROR, 0, TRANS_MSG_REMOTE_HOST_ERROR, + "option remote-host " + "missing in volume %s", + this->name); + ret = -1; + goto err; + } + + remote_host = data_to_str(remote_host_data); + if (remote_host == NULL) { + gf_msg(this->name, GF_LOG_ERROR, 0, TRANS_MSG_REMOTE_HOST_ERROR, + "option remote-host " + "has data NULL in volume %s", + this->name); + ret = -1; + goto err; + } + + if (remote_port == 0) { + remote_port_data = dict_get(options, "remote-port"); + if (remote_port_data == NULL) { + gf_msg_debug(this->name, 0, + "option remote-port " + "missing in volume %s. Defaulting to %d", + this->name, GF_DEFAULT_RDMA_LISTEN_PORT); + + remote_port = GF_DEFAULT_RDMA_LISTEN_PORT; + } else { + remote_port = data_to_uint16(remote_port_data); } - - memcpy (sockaddr, addr_info->ai_addr, addr_info->ai_addrlen); - *sockaddr_len = addr_info->ai_addrlen; + } + + if (remote_port == -1) { + gf_msg(this->name, GF_LOG_ERROR, EINVAL, RDMA_MSG_INVALID_ENTRY, + "option remote-port has " + "invalid port in volume %s", + this->name); + ret = -1; + goto err; + } + + /* TODO: gf_resolve is a blocking call. kick in some + non blocking dns techniques */ + ret = gf_resolve_ip6(remote_host, remote_port, sockaddr->sa_family, + &this->dnscache, &addr_info); + if (ret == -1) { + gf_msg(this->name, GF_LOG_ERROR, 0, TRANS_MSG_DNS_RESOL_FAILED, + "DNS resolution failed on host %s", remote_host); + goto err; + } + + memcpy(sockaddr, addr_info->ai_addr, addr_info->ai_addrlen); + *sockaddr_len = addr_info->ai_addrlen; err: - return ret; + return ret; } static int32_t -af_unix_client_get_remote_sockaddr (rpc_transport_t *this, - struct sockaddr *sockaddr, - socklen_t *sockaddr_len) +af_unix_client_get_remote_sockaddr(rpc_transport_t *this, + struct sockaddr *sockaddr, + socklen_t *sockaddr_len) { - struct sockaddr_un *sockaddr_un = NULL; - char *connect_path = NULL; - data_t *connect_path_data = NULL; - int32_t ret = 0; - - connect_path_data = dict_get (this->options, - "transport.rdma.connect-path"); - if (!connect_path_data) { - gf_msg (this->name, GF_LOG_ERROR, 0, - TRANS_MSG_CONNECT_PATH_ERROR, "option " - "transport.rdma.connect-path not specified for " - "address-family unix"); - ret = -1; - goto err; - } - - connect_path = data_to_str (connect_path_data); - if (!connect_path) { - gf_msg (this->name, GF_LOG_ERROR, EINVAL, - RDMA_MSG_INVALID_ENTRY, "connect-path is null-string"); - ret = -1; - goto err; - } - - if (strlen (connect_path) > UNIX_PATH_MAX) { - gf_msg (this->name, GF_LOG_ERROR, 0, - TRANS_MSG_CONNECT_PATH_ERROR, - "connect-path value length %"GF_PRI_SIZET" > " - "%d octets", strlen (connect_path), UNIX_PATH_MAX); - ret = -1; - goto err; - } - - gf_msg_debug (this->name, 0, "using connect-path %s", connect_path); - sockaddr_un = (struct sockaddr_un *)sockaddr; - strcpy (sockaddr_un->sun_path, connect_path); - *sockaddr_len = sizeof (struct sockaddr_un); + struct sockaddr_un *sockaddr_un = NULL; + char *connect_path = NULL; + data_t *connect_path_data = NULL; + int32_t ret = 0; + + connect_path_data = dict_get(this->options, "transport.rdma.connect-path"); + if (!connect_path_data) { + gf_msg(this->name, GF_LOG_ERROR, 0, TRANS_MSG_CONNECT_PATH_ERROR, + "option " + "transport.rdma.connect-path not specified for " + "address-family unix"); + ret = -1; + goto err; + } + + connect_path = data_to_str(connect_path_data); + if (!connect_path) { + gf_msg(this->name, GF_LOG_ERROR, EINVAL, RDMA_MSG_INVALID_ENTRY, + "connect-path is null-string"); + ret = -1; + goto err; + } + + if (strlen(connect_path) > UNIX_PATH_MAX) { + gf_msg(this->name, GF_LOG_ERROR, 0, TRANS_MSG_CONNECT_PATH_ERROR, + "connect-path value length %" GF_PRI_SIZET + " > " + "%d octets", + strlen(connect_path), UNIX_PATH_MAX); + ret = -1; + goto err; + } + + gf_msg_debug(this->name, 0, "using connect-path %s", connect_path); + sockaddr_un = (struct sockaddr_un *)sockaddr; + strcpy(sockaddr_un->sun_path, connect_path); + *sockaddr_len = sizeof(struct sockaddr_un); err: - return ret; + return ret; } static int32_t -af_unix_server_get_local_sockaddr (rpc_transport_t *this, - struct sockaddr *addr, - socklen_t *addr_len) +af_unix_server_get_local_sockaddr(rpc_transport_t *this, struct sockaddr *addr, + socklen_t *addr_len) { - data_t *listen_path_data = NULL; - char *listen_path = NULL; - int32_t ret = 0; - struct sockaddr_un *sunaddr = (struct sockaddr_un *)addr; - - - listen_path_data = dict_get (this->options, - "transport.rdma.listen-path"); - if (!listen_path_data) { - gf_msg (this->name, GF_LOG_ERROR, 0, - TRANS_MSG_LISTEN_PATH_ERROR, - "missing option listen-path"); - ret = -1; - goto err; - } + data_t *listen_path_data = NULL; + char *listen_path = NULL; + int32_t ret = 0; + struct sockaddr_un *sunaddr = (struct sockaddr_un *)addr; + + listen_path_data = dict_get(this->options, "transport.rdma.listen-path"); + if (!listen_path_data) { + gf_msg(this->name, GF_LOG_ERROR, 0, TRANS_MSG_LISTEN_PATH_ERROR, + "missing option listen-path"); + ret = -1; + goto err; + } - listen_path = data_to_str (listen_path_data); + listen_path = data_to_str(listen_path_data); #ifndef UNIX_PATH_MAX #define UNIX_PATH_MAX 108 #endif - if (strlen (listen_path) > UNIX_PATH_MAX) { - gf_msg (this->name, GF_LOG_ERROR, 0, - TRANS_MSG_LISTEN_PATH_ERROR, "option listen-path has " - "value length %"GF_PRI_SIZET" > %d", - strlen (listen_path), UNIX_PATH_MAX); - ret = -1; - goto err; - } + if (strlen(listen_path) > UNIX_PATH_MAX) { + gf_msg(this->name, GF_LOG_ERROR, 0, TRANS_MSG_LISTEN_PATH_ERROR, + "option listen-path has " + "value length %" GF_PRI_SIZET " > %d", + strlen(listen_path), UNIX_PATH_MAX); + ret = -1; + goto err; + } - sunaddr->sun_family = AF_UNIX; - strcpy (sunaddr->sun_path, listen_path); - *addr_len = sizeof (struct sockaddr_un); + sunaddr->sun_family = AF_UNIX; + strcpy(sunaddr->sun_path, listen_path); + *addr_len = sizeof(struct sockaddr_un); err: - return ret; + return ret; } static int32_t -af_inet_server_get_local_sockaddr (rpc_transport_t *this, - struct sockaddr *addr, - socklen_t *addr_len) +af_inet_server_get_local_sockaddr(rpc_transport_t *this, struct sockaddr *addr, + socklen_t *addr_len) { - struct addrinfo hints, *res = 0; - data_t *listen_port_data = NULL, *listen_host_data = NULL; - uint16_t listen_port = -1; - char service[NI_MAXSERV], *listen_host = NULL; - dict_t *options = NULL; - int32_t ret = 0; - - options = this->options; - - listen_port_data = dict_get (options, "transport.rdma.listen-port"); - listen_host_data = dict_get (options, - "transport.rdma.bind-address"); - - if (listen_port_data) { - listen_port = data_to_uint16 (listen_port_data); - } else { - listen_port = GF_DEFAULT_RDMA_LISTEN_PORT; - - if (addr->sa_family == AF_INET6) { - struct sockaddr_in6 *in = (struct sockaddr_in6 *) addr; - in->sin6_addr = in6addr_any; - in->sin6_port = htons(listen_port); - *addr_len = sizeof(struct sockaddr_in6); - goto out; - } else if (addr->sa_family == AF_INET) { - struct sockaddr_in *in = (struct sockaddr_in *) addr; - in->sin_addr.s_addr = htonl(INADDR_ANY); - in->sin_port = htons(listen_port); - *addr_len = sizeof(struct sockaddr_in); - goto out; - } + struct addrinfo hints, *res = 0; + data_t *listen_port_data = NULL, *listen_host_data = NULL; + uint16_t listen_port = -1; + char service[NI_MAXSERV], *listen_host = NULL; + dict_t *options = NULL; + int32_t ret = 0; + + options = this->options; + + listen_port_data = dict_get(options, "transport.rdma.listen-port"); + listen_host_data = dict_get(options, "transport.rdma.bind-address"); + + if (listen_port_data) { + listen_port = data_to_uint16(listen_port_data); + } else { + listen_port = GF_DEFAULT_RDMA_LISTEN_PORT; + + if (addr->sa_family == AF_INET6) { + struct sockaddr_in6 *in = (struct sockaddr_in6 *)addr; + in->sin6_addr = in6addr_any; + in->sin6_port = htons(listen_port); + *addr_len = sizeof(struct sockaddr_in6); + goto out; + } else if (addr->sa_family == AF_INET) { + struct sockaddr_in *in = (struct sockaddr_in *)addr; + in->sin_addr.s_addr = htonl(INADDR_ANY); + in->sin_port = htons(listen_port); + *addr_len = sizeof(struct sockaddr_in); + goto out; } + } - if (listen_port == (uint16_t) -1) - listen_port = GF_DEFAULT_RDMA_LISTEN_PORT; + if (listen_port == (uint16_t)-1) + listen_port = GF_DEFAULT_RDMA_LISTEN_PORT; + if (listen_host_data) { + listen_host = data_to_str(listen_host_data); + } - if (listen_host_data) { - listen_host = data_to_str (listen_host_data); - } + sprintf(service, "%d", listen_port); - sprintf (service, "%d", listen_port); - - memset (&hints, 0, sizeof (hints)); - hints.ai_family = addr->sa_family; - hints.ai_socktype = SOCK_STREAM; - hints.ai_flags = AI_ADDRCONFIG | AI_PASSIVE; - - ret = getaddrinfo(listen_host, service, &hints, &res); - if (ret != 0) { - gf_msg (this->name, GF_LOG_ERROR, ret, - TRANS_MSG_GET_ADDR_INFO_FAILED, - "getaddrinfo failed for host %s, service %s", - listen_host, service); - ret = -1; - goto out; - } + memset(&hints, 0, sizeof(hints)); + hints.ai_family = addr->sa_family; + hints.ai_socktype = SOCK_STREAM; + hints.ai_flags = AI_ADDRCONFIG | AI_PASSIVE; + + ret = getaddrinfo(listen_host, service, &hints, &res); + if (ret != 0) { + gf_msg(this->name, GF_LOG_ERROR, ret, TRANS_MSG_GET_ADDR_INFO_FAILED, + "getaddrinfo failed for host %s, service %s", listen_host, + service); + ret = -1; + goto out; + } - memcpy (addr, res->ai_addr, res->ai_addrlen); - *addr_len = res->ai_addrlen; + memcpy(addr, res->ai_addr, res->ai_addrlen); + *addr_len = res->ai_addrlen; - freeaddrinfo (res); + freeaddrinfo(res); out: - return ret; + return ret; } int32_t -gf_rdma_client_bind (rpc_transport_t *this, struct sockaddr *sockaddr, - socklen_t *sockaddr_len, struct rdma_cm_id *cm_id) +gf_rdma_client_bind(rpc_transport_t *this, struct sockaddr *sockaddr, + socklen_t *sockaddr_len, struct rdma_cm_id *cm_id) { - int ret = 0; + int ret = 0; - *sockaddr_len = sizeof (struct sockaddr_in6); - switch (sockaddr->sa_family) { + *sockaddr_len = sizeof(struct sockaddr_in6); + switch (sockaddr->sa_family) { case AF_INET_SDP: case AF_INET: - *sockaddr_len = sizeof (struct sockaddr_in); + *sockaddr_len = sizeof(struct sockaddr_in); /* Fall through */ case AF_INET6: - if (!this->bind_insecure) { - ret = af_inet_bind_to_port_lt_ceiling (cm_id, sockaddr, - *sockaddr_len, - GF_CLIENT_PORT_CEILING); - if (ret == -1) { - gf_msg (this->name, GF_LOG_WARNING, errno, - RDMA_MSG_PORT_BIND_FAILED, - "cannot bind rdma_cm_id to port " - "less than %d", GF_CLIENT_PORT_CEILING); - } - } else { - ret = af_inet_bind_to_port_lt_ceiling (cm_id, sockaddr, - *sockaddr_len, - GF_IANA_PRIV_PORTS_START); - if (ret == -1) { - gf_msg (this->name, GF_LOG_WARNING, errno, - RDMA_MSG_PORT_BIND_FAILED, - "cannot bind rdma_cm_id to port " - "less than %d", - GF_IANA_PRIV_PORTS_START); - } + if (!this->bind_insecure) { + ret = af_inet_bind_to_port_lt_ceiling( + cm_id, sockaddr, *sockaddr_len, GF_CLIENT_PORT_CEILING); + if (ret == -1) { + gf_msg(this->name, GF_LOG_WARNING, errno, + RDMA_MSG_PORT_BIND_FAILED, + "cannot bind rdma_cm_id to port " + "less than %d", + GF_CLIENT_PORT_CEILING); + } + } else { + ret = af_inet_bind_to_port_lt_ceiling( + cm_id, sockaddr, *sockaddr_len, GF_IANA_PRIV_PORTS_START); + if (ret == -1) { + gf_msg(this->name, GF_LOG_WARNING, errno, + RDMA_MSG_PORT_BIND_FAILED, + "cannot bind rdma_cm_id to port " + "less than %d", + GF_IANA_PRIV_PORTS_START); } - break; + } + break; case AF_UNIX: - *sockaddr_len = sizeof (struct sockaddr_un); + *sockaddr_len = sizeof(struct sockaddr_un); #if 0 ret = af_unix_client_bind (this, (struct sockaddr *)sockaddr, *sockaddr_len, sock); #endif - break; + break; default: - gf_msg (this->name, GF_LOG_ERROR, 0, - TRANS_MSG_UNKNOWN_ADDR_FAMILY, - "unknown address family %d", sockaddr->sa_family); - ret = -1; - break; - } + gf_msg(this->name, GF_LOG_ERROR, 0, TRANS_MSG_UNKNOWN_ADDR_FAMILY, + "unknown address family %d", sockaddr->sa_family); + ret = -1; + break; + } - return ret; + return ret; } int32_t -gf_rdma_client_get_remote_sockaddr (rpc_transport_t *this, - struct sockaddr *sockaddr, - socklen_t *sockaddr_len, - int16_t remote_port) +gf_rdma_client_get_remote_sockaddr(rpc_transport_t *this, + struct sockaddr *sockaddr, + socklen_t *sockaddr_len, int16_t remote_port) { - int32_t ret = 0; - char is_inet_sdp = 0; + int32_t ret = 0; + char is_inet_sdp = 0; - ret = client_fill_address_family (this, sockaddr); - if (ret) { - ret = -1; - goto err; - } + ret = client_fill_address_family(this, sockaddr); + if (ret) { + ret = -1; + goto err; + } - switch (sockaddr->sa_family) { + switch (sockaddr->sa_family) { case AF_INET_SDP: - sockaddr->sa_family = AF_INET; - is_inet_sdp = 1; + sockaddr->sa_family = AF_INET; + is_inet_sdp = 1; /* Fall through */ case AF_INET: case AF_INET6: case AF_UNSPEC: - ret = af_inet_client_get_remote_sockaddr (this, - sockaddr, - sockaddr_len, - remote_port); + ret = af_inet_client_get_remote_sockaddr(this, sockaddr, + sockaddr_len, remote_port); - if (is_inet_sdp) { - sockaddr->sa_family = AF_INET_SDP; - } + if (is_inet_sdp) { + sockaddr->sa_family = AF_INET_SDP; + } - break; + break; case AF_UNIX: - ret = af_unix_client_get_remote_sockaddr (this, - sockaddr, - sockaddr_len); - break; + ret = af_unix_client_get_remote_sockaddr(this, sockaddr, + sockaddr_len); + break; default: - gf_msg (this->name, GF_LOG_ERROR, 0, - TRANS_MSG_UNKNOWN_ADDR_FAMILY, - "unknown address-family %d", sockaddr->sa_family); - ret = -1; - } + gf_msg(this->name, GF_LOG_ERROR, 0, TRANS_MSG_UNKNOWN_ADDR_FAMILY, + "unknown address-family %d", sockaddr->sa_family); + ret = -1; + } err: - return ret; + return ret; } int32_t -gf_rdma_server_get_local_sockaddr (rpc_transport_t *this, - struct sockaddr *addr, - socklen_t *addr_len) +gf_rdma_server_get_local_sockaddr(rpc_transport_t *this, struct sockaddr *addr, + socklen_t *addr_len) { - data_t *address_family_data = NULL; - int32_t ret = 0; - char is_inet_sdp = 0; - - address_family_data = dict_get (this->options, - "transport.address-family"); - if (address_family_data) { - char *address_family = NULL; - address_family = data_to_str (address_family_data); - - if (!strcasecmp (address_family, "inet")) { - addr->sa_family = AF_INET; - } else if (!strcasecmp (address_family, "inet6")) { - addr->sa_family = AF_INET6; - } else if (!strcasecmp (address_family, "inet-sdp")) { - addr->sa_family = AF_INET_SDP; - } else if (!strcasecmp (address_family, "unix")) { - addr->sa_family = AF_UNIX; - } else { - gf_msg (this->name, GF_LOG_ERROR, 0, - TRANS_MSG_UNKNOWN_ADDR_FAMILY, "unknown address" - " family (%s) specified", address_family); - addr->sa_family = AF_UNSPEC; - ret = -1; - goto err; - } + data_t *address_family_data = NULL; + int32_t ret = 0; + char is_inet_sdp = 0; + + address_family_data = dict_get(this->options, "transport.address-family"); + if (address_family_data) { + char *address_family = NULL; + address_family = data_to_str(address_family_data); + + if (!strcasecmp(address_family, "inet")) { + addr->sa_family = AF_INET; + } else if (!strcasecmp(address_family, "inet6")) { + addr->sa_family = AF_INET6; + } else if (!strcasecmp(address_family, "inet-sdp")) { + addr->sa_family = AF_INET_SDP; + } else if (!strcasecmp(address_family, "unix")) { + addr->sa_family = AF_UNIX; } else { - gf_msg_debug (this->name, 0, "option address-family not " - "specified, defaulting to inet"); - addr->sa_family = AF_INET; + gf_msg(this->name, GF_LOG_ERROR, 0, TRANS_MSG_UNKNOWN_ADDR_FAMILY, + "unknown address" + " family (%s) specified", + address_family); + addr->sa_family = AF_UNSPEC; + ret = -1; + goto err; } - - switch (addr->sa_family) { + } else { + gf_msg_debug(this->name, 0, + "option address-family not " + "specified, defaulting to inet"); + addr->sa_family = AF_INET; + } + + switch (addr->sa_family) { case AF_INET_SDP: - is_inet_sdp = 1; - addr->sa_family = AF_INET; - /* Fall through */ + is_inet_sdp = 1; + addr->sa_family = AF_INET; + /* Fall through */ case AF_INET: case AF_INET6: case AF_UNSPEC: - ret = af_inet_server_get_local_sockaddr (this, addr, addr_len); - if (is_inet_sdp && !ret) { - addr->sa_family = AF_INET_SDP; - } - break; + ret = af_inet_server_get_local_sockaddr(this, addr, addr_len); + if (is_inet_sdp && !ret) { + addr->sa_family = AF_INET_SDP; + } + break; case AF_UNIX: - ret = af_unix_server_get_local_sockaddr (this, addr, addr_len); - break; - } + ret = af_unix_server_get_local_sockaddr(this, addr, addr_len); + break; + } err: - return ret; + return ret; } int32_t -fill_inet6_inet_identifiers (rpc_transport_t *this, struct sockaddr_storage *addr, - int32_t addr_len, char *identifier) +fill_inet6_inet_identifiers(rpc_transport_t *this, + struct sockaddr_storage *addr, int32_t addr_len, + char *identifier) { - int32_t ret = 0, tmpaddr_len = 0; - char service[NI_MAXSERV], host[NI_MAXHOST]; - union gf_sock_union sock_union; + int32_t ret = 0, tmpaddr_len = 0; + char service[NI_MAXSERV], host[NI_MAXHOST]; + union gf_sock_union sock_union; - memset (&sock_union, 0, sizeof (sock_union)); - sock_union.storage = *addr; - tmpaddr_len = addr_len; + memset(&sock_union, 0, sizeof(sock_union)); + sock_union.storage = *addr; + tmpaddr_len = addr_len; - if (sock_union.sa.sa_family == AF_INET6) { - int32_t one_to_four, four_to_eight, twelve_to_sixteen; - int16_t eight_to_ten, ten_to_twelve; + if (sock_union.sa.sa_family == AF_INET6) { + int32_t one_to_four, four_to_eight, twelve_to_sixteen; + int16_t eight_to_ten, ten_to_twelve; - one_to_four = four_to_eight = twelve_to_sixteen = 0; - eight_to_ten = ten_to_twelve = 0; + one_to_four = four_to_eight = twelve_to_sixteen = 0; + eight_to_ten = ten_to_twelve = 0; - one_to_four = sock_union.sin6.sin6_addr.s6_addr32[0]; - four_to_eight = sock_union.sin6.sin6_addr.s6_addr32[1]; + one_to_four = sock_union.sin6.sin6_addr.s6_addr32[0]; + four_to_eight = sock_union.sin6.sin6_addr.s6_addr32[1]; #ifdef GF_SOLARIS_HOST_OS - eight_to_ten = S6_ADDR16(sock_union.sin6.sin6_addr)[4]; + eight_to_ten = S6_ADDR16(sock_union.sin6.sin6_addr)[4]; #else - eight_to_ten = sock_union.sin6.sin6_addr.s6_addr16[4]; + eight_to_ten = sock_union.sin6.sin6_addr.s6_addr16[4]; #endif #ifdef GF_SOLARIS_HOST_OS - ten_to_twelve = S6_ADDR16(sock_union.sin6.sin6_addr)[5]; + ten_to_twelve = S6_ADDR16(sock_union.sin6.sin6_addr)[5]; #else - ten_to_twelve = sock_union.sin6.sin6_addr.s6_addr16[5]; + ten_to_twelve = sock_union.sin6.sin6_addr.s6_addr16[5]; #endif - twelve_to_sixteen = sock_union.sin6.sin6_addr.s6_addr32[3]; - - /* ipv4 mapped ipv6 address has - bits 0-80: 0 - bits 80-96: 0xffff - bits 96-128: ipv4 address - */ - - if (one_to_four == 0 && - four_to_eight == 0 && - eight_to_ten == 0 && - ten_to_twelve == -1) { - struct sockaddr_in *in_ptr = &sock_union.sin; - memset (&sock_union, 0, sizeof (sock_union)); - - in_ptr->sin_family = AF_INET; - in_ptr->sin_port = ((struct sockaddr_in6 *)addr)->sin6_port; - in_ptr->sin_addr.s_addr = twelve_to_sixteen; - tmpaddr_len = sizeof (*in_ptr); - } + twelve_to_sixteen = sock_union.sin6.sin6_addr.s6_addr32[3]; + + /* ipv4 mapped ipv6 address has + bits 0-80: 0 + bits 80-96: 0xffff + bits 96-128: ipv4 address + */ + + if (one_to_four == 0 && four_to_eight == 0 && eight_to_ten == 0 && + ten_to_twelve == -1) { + struct sockaddr_in *in_ptr = &sock_union.sin; + memset(&sock_union, 0, sizeof(sock_union)); + + in_ptr->sin_family = AF_INET; + in_ptr->sin_port = ((struct sockaddr_in6 *)addr)->sin6_port; + in_ptr->sin_addr.s_addr = twelve_to_sixteen; + tmpaddr_len = sizeof(*in_ptr); } + } - ret = getnameinfo (&sock_union.sa, - tmpaddr_len, - host, sizeof (host), - service, sizeof (service), - NI_NUMERICHOST | NI_NUMERICSERV); - if (ret != 0) { - gf_msg (this->name, GF_LOG_ERROR, ret, - TRANS_MSG_GET_NAME_INFO_FAILED, - "getnameinfo failed"); - } + ret = getnameinfo(&sock_union.sa, tmpaddr_len, host, sizeof(host), service, + sizeof(service), NI_NUMERICHOST | NI_NUMERICSERV); + if (ret != 0) { + gf_msg(this->name, GF_LOG_ERROR, ret, TRANS_MSG_GET_NAME_INFO_FAILED, + "getnameinfo failed"); + } - sprintf (identifier, "%s:%s", host, service); + sprintf(identifier, "%s:%s", host, service); - return ret; + return ret; } int32_t -gf_rdma_get_transport_identifiers (rpc_transport_t *this) +gf_rdma_get_transport_identifiers(rpc_transport_t *this) { - int32_t ret = 0; - char is_inet_sdp = 0; + int32_t ret = 0; + char is_inet_sdp = 0; - switch (((struct sockaddr *) &this->myinfo.sockaddr)->sa_family) { + switch (((struct sockaddr *)&this->myinfo.sockaddr)->sa_family) { case AF_INET_SDP: - is_inet_sdp = 1; - ((struct sockaddr *) &this->peerinfo.sockaddr)->sa_family = ((struct sockaddr *) &this->myinfo.sockaddr)->sa_family = AF_INET; - /* Fall through */ + is_inet_sdp = 1; + ((struct sockaddr *)&this->peerinfo.sockaddr) + ->sa_family = ((struct sockaddr *)&this->myinfo.sockaddr) + ->sa_family = AF_INET; + /* Fall through */ case AF_INET: case AF_INET6: { - ret = fill_inet6_inet_identifiers (this, - &this->myinfo.sockaddr, - this->myinfo.sockaddr_len, - this->myinfo.identifier); - if (ret == -1) { - gf_msg (this->name, GF_LOG_ERROR, 0, - TRANS_MSG_INET_ERROR, - "can't fill inet/inet6 identifier for server"); - goto err; - } - - ret = fill_inet6_inet_identifiers (this, - &this->peerinfo.sockaddr, - this->peerinfo.sockaddr_len, - this->peerinfo.identifier); - if (ret == -1) { - gf_msg (this->name, GF_LOG_ERROR, 0, - TRANS_MSG_INET_ERROR, - "can't fill inet/inet6 identifier for client"); - goto err; - } + ret = fill_inet6_inet_identifiers(this, &this->myinfo.sockaddr, + this->myinfo.sockaddr_len, + this->myinfo.identifier); + if (ret == -1) { + gf_msg(this->name, GF_LOG_ERROR, 0, TRANS_MSG_INET_ERROR, + "can't fill inet/inet6 identifier for server"); + goto err; + } + + ret = fill_inet6_inet_identifiers(this, &this->peerinfo.sockaddr, + this->peerinfo.sockaddr_len, + this->peerinfo.identifier); + if (ret == -1) { + gf_msg(this->name, GF_LOG_ERROR, 0, TRANS_MSG_INET_ERROR, + "can't fill inet/inet6 identifier for client"); + goto err; + } - if (is_inet_sdp) { - ((struct sockaddr *) &this->peerinfo.sockaddr)->sa_family = ((struct sockaddr *) &this->myinfo.sockaddr)->sa_family = AF_INET_SDP; - } - } - break; + if (is_inet_sdp) { + ((struct sockaddr *)&this->peerinfo.sockaddr) + ->sa_family = ((struct sockaddr *)&this->myinfo.sockaddr) + ->sa_family = AF_INET_SDP; + } + } break; - case AF_UNIX: - { - struct sockaddr_un *sunaddr = NULL; + case AF_UNIX: { + struct sockaddr_un *sunaddr = NULL; - sunaddr = (struct sockaddr_un *) &this->myinfo.sockaddr; - strcpy (this->myinfo.identifier, sunaddr->sun_path); + sunaddr = (struct sockaddr_un *)&this->myinfo.sockaddr; + strcpy(this->myinfo.identifier, sunaddr->sun_path); - sunaddr = (struct sockaddr_un *) &this->peerinfo.sockaddr; - strcpy (this->peerinfo.identifier, sunaddr->sun_path); - } - break; + sunaddr = (struct sockaddr_un *)&this->peerinfo.sockaddr; + strcpy(this->peerinfo.identifier, sunaddr->sun_path); + } break; default: - gf_msg (this->name, GF_LOG_ERROR, 0, - TRANS_MSG_UNKNOWN_ADDR_FAMILY, - "unknown address family (%d)", - ((struct sockaddr *) &this->myinfo.sockaddr)->sa_family); - ret = -1; - break; - } + gf_msg(this->name, GF_LOG_ERROR, 0, TRANS_MSG_UNKNOWN_ADDR_FAMILY, + "unknown address family (%d)", + ((struct sockaddr *)&this->myinfo.sockaddr)->sa_family); + ret = -1; + break; + } err: - return ret; + return ret; } diff --git a/rpc/rpc-transport/rdma/src/rdma.c b/rpc/rpc-transport/rdma/src/rdma.c index f1859a73bdf..92c9ce95929 100644 --- a/rpc/rpc-transport/rdma/src/rdma.c +++ b/rpc/rpc-transport/rdma/src/rdma.c @@ -24,1363 +24,1322 @@ #define GF_RDMA_LOG_NAME "rpc-transport/rdma" static int32_t -__gf_rdma_ioq_churn (gf_rdma_peer_t *peer); +__gf_rdma_ioq_churn(gf_rdma_peer_t *peer); gf_rdma_post_t * -gf_rdma_post_ref (gf_rdma_post_t *post); +gf_rdma_post_ref(gf_rdma_post_t *post); int -gf_rdma_post_unref (gf_rdma_post_t *post); +gf_rdma_post_unref(gf_rdma_post_t *post); static void * -gf_rdma_send_completion_proc (void *data); +gf_rdma_send_completion_proc(void *data); static void * -gf_rdma_recv_completion_proc (void *data); +gf_rdma_recv_completion_proc(void *data); void * -gf_rdma_async_event_thread (void *context); +gf_rdma_async_event_thread(void *context); static int32_t -gf_rdma_create_qp (rpc_transport_t *this); +gf_rdma_create_qp(rpc_transport_t *this); static int32_t -__gf_rdma_teardown (rpc_transport_t *this); +__gf_rdma_teardown(rpc_transport_t *this); static int32_t -gf_rdma_teardown (rpc_transport_t *this); +gf_rdma_teardown(rpc_transport_t *this); static int32_t -gf_rdma_disconnect (rpc_transport_t *this, gf_boolean_t wait); +gf_rdma_disconnect(rpc_transport_t *this, gf_boolean_t wait); static void -gf_rdma_cm_handle_disconnect (rpc_transport_t *this); +gf_rdma_cm_handle_disconnect(rpc_transport_t *this); static int -gf_rdma_cm_handle_connect_init (struct rdma_cm_event *event); +gf_rdma_cm_handle_connect_init(struct rdma_cm_event *event); static void -gf_rdma_put_post (gf_rdma_queue_t *queue, gf_rdma_post_t *post) +gf_rdma_put_post(gf_rdma_queue_t *queue, gf_rdma_post_t *post) { - post->ctx.is_request = 0; + post->ctx.is_request = 0; - pthread_mutex_lock (&queue->lock); - { - if (post->prev) { - queue->active_count--; - post->prev->next = post->next; - } - - if (post->next) { - post->next->prev = post->prev; - } + pthread_mutex_lock(&queue->lock); + { + if (post->prev) { + queue->active_count--; + post->prev->next = post->next; + } - post->prev = &queue->passive_posts; - post->next = post->prev->next; - post->prev->next = post; - post->next->prev = post; - queue->passive_count++; + if (post->next) { + post->next->prev = post->prev; } - pthread_mutex_unlock (&queue->lock); -} + post->prev = &queue->passive_posts; + post->next = post->prev->next; + post->prev->next = post; + post->next->prev = post; + queue->passive_count++; + } + pthread_mutex_unlock(&queue->lock); +} static gf_rdma_post_t * -gf_rdma_new_post (rpc_transport_t *this, gf_rdma_device_t *device, int32_t len, - gf_rdma_post_type_t type) +gf_rdma_new_post(rpc_transport_t *this, gf_rdma_device_t *device, int32_t len, + gf_rdma_post_type_t type) { - gf_rdma_post_t *post = NULL; - int ret = -1; + gf_rdma_post_t *post = NULL; + int ret = -1; - post = (gf_rdma_post_t *) GF_CALLOC (1, sizeof (*post), - gf_common_mt_rdma_post_t); - if (post == NULL) { - goto out; - } + post = (gf_rdma_post_t *)GF_CALLOC(1, sizeof(*post), + gf_common_mt_rdma_post_t); + if (post == NULL) { + goto out; + } - pthread_mutex_init (&post->lock, NULL); + pthread_mutex_init(&post->lock, NULL); - post->buf_size = len; + post->buf_size = len; - post->buf = valloc (len); - if (!post->buf) { - gf_msg_nomem (GF_RDMA_LOG_NAME, GF_LOG_ERROR, len); - goto out; - } + post->buf = valloc(len); + if (!post->buf) { + gf_msg_nomem(GF_RDMA_LOG_NAME, GF_LOG_ERROR, len); + goto out; + } - post->mr = ibv_reg_mr (device->pd, - post->buf, - post->buf_size, - IBV_ACCESS_LOCAL_WRITE); - if (!post->mr) { - gf_msg (this->name, GF_LOG_WARNING, errno, - RDMA_MSG_MR_ALOC_FAILED, - "memory registration failed"); - goto out; - } + post->mr = ibv_reg_mr(device->pd, post->buf, post->buf_size, + IBV_ACCESS_LOCAL_WRITE); + if (!post->mr) { + gf_msg(this->name, GF_LOG_WARNING, errno, RDMA_MSG_MR_ALOC_FAILED, + "memory registration failed"); + goto out; + } - post->device = device; - post->type = type; + post->device = device; + post->type = type; - ret = 0; + ret = 0; out: - if (ret != 0 && post) { - free (post->buf); + if (ret != 0 && post) { + free(post->buf); - GF_FREE (post); - post = NULL; - } + GF_FREE(post); + post = NULL; + } - return post; + return post; } - static gf_rdma_post_t * -gf_rdma_get_post (gf_rdma_queue_t *queue) +gf_rdma_get_post(gf_rdma_queue_t *queue) { - gf_rdma_post_t *post = NULL; - - pthread_mutex_lock (&queue->lock); - { - post = queue->passive_posts.next; - if (post == &queue->passive_posts) - post = NULL; - - if (post) { - if (post->prev) - post->prev->next = post->next; - if (post->next) - post->next->prev = post->prev; - post->prev = &queue->active_posts; - post->next = post->prev->next; - post->prev->next = post; - post->next->prev = post; - post->reused++; - queue->active_count++; - } - } - pthread_mutex_unlock (&queue->lock); - - return post; + gf_rdma_post_t *post = NULL; + + pthread_mutex_lock(&queue->lock); + { + post = queue->passive_posts.next; + if (post == &queue->passive_posts) + post = NULL; + + if (post) { + if (post->prev) + post->prev->next = post->next; + if (post->next) + post->next->prev = post->prev; + post->prev = &queue->active_posts; + post->next = post->prev->next; + post->prev->next = post; + post->next->prev = post; + post->reused++; + queue->active_count++; + } + } + pthread_mutex_unlock(&queue->lock); + + return post; } void -gf_rdma_destroy_post (gf_rdma_post_t *post) +gf_rdma_destroy_post(gf_rdma_post_t *post) { - ibv_dereg_mr (post->mr); - free (post->buf); - GF_FREE (post); + ibv_dereg_mr(post->mr); + free(post->buf); + GF_FREE(post); } - static int32_t -__gf_rdma_quota_get (gf_rdma_peer_t *peer) +__gf_rdma_quota_get(gf_rdma_peer_t *peer) { - int32_t ret = -1; - gf_rdma_private_t *priv = NULL; + int32_t ret = -1; + gf_rdma_private_t *priv = NULL; - priv = peer->trans->private; + priv = peer->trans->private; - if (priv->connected && peer->quota > 0) { - ret = peer->quota--; - } + if (priv->connected && peer->quota > 0) { + ret = peer->quota--; + } - return ret; + return ret; } - static void -__gf_rdma_ioq_entry_free (gf_rdma_ioq_t *entry) +__gf_rdma_ioq_entry_free(gf_rdma_ioq_t *entry) { - list_del_init (&entry->list); + list_del_init(&entry->list); - if (entry->iobref) { - iobref_unref (entry->iobref); - entry->iobref = NULL; - } + if (entry->iobref) { + iobref_unref(entry->iobref); + entry->iobref = NULL; + } - if (entry->msg.request.rsp_iobref) { - iobref_unref (entry->msg.request.rsp_iobref); - entry->msg.request.rsp_iobref = NULL; - } + if (entry->msg.request.rsp_iobref) { + iobref_unref(entry->msg.request.rsp_iobref); + entry->msg.request.rsp_iobref = NULL; + } - mem_put (entry); + mem_put(entry); } - static void -__gf_rdma_ioq_flush (gf_rdma_peer_t *peer) +__gf_rdma_ioq_flush(gf_rdma_peer_t *peer) { - gf_rdma_ioq_t *entry = NULL, *dummy = NULL; + gf_rdma_ioq_t *entry = NULL, *dummy = NULL; - list_for_each_entry_safe (entry, dummy, &peer->ioq, list) { - __gf_rdma_ioq_entry_free (entry); - } + list_for_each_entry_safe(entry, dummy, &peer->ioq, list) + { + __gf_rdma_ioq_entry_free(entry); + } } - static int32_t -__gf_rdma_disconnect (rpc_transport_t *this) +__gf_rdma_disconnect(rpc_transport_t *this) { - gf_rdma_private_t *priv = NULL; + gf_rdma_private_t *priv = NULL; - priv = this->private; + priv = this->private; - if (priv->connected) { - rdma_disconnect (priv->peer.cm_id); - } + if (priv->connected) { + rdma_disconnect(priv->peer.cm_id); + } - return 0; + return 0; } - static void -gf_rdma_queue_init (gf_rdma_queue_t *queue) +gf_rdma_queue_init(gf_rdma_queue_t *queue) { - pthread_mutex_init (&queue->lock, NULL); + pthread_mutex_init(&queue->lock, NULL); - queue->active_posts.next = &queue->active_posts; - queue->active_posts.prev = &queue->active_posts; - queue->passive_posts.next = &queue->passive_posts; - queue->passive_posts.prev = &queue->passive_posts; + queue->active_posts.next = &queue->active_posts; + queue->active_posts.prev = &queue->active_posts; + queue->passive_posts.next = &queue->passive_posts; + queue->passive_posts.prev = &queue->passive_posts; } - static void -__gf_rdma_destroy_queue (gf_rdma_post_t *post) +__gf_rdma_destroy_queue(gf_rdma_post_t *post) { - gf_rdma_post_t *tmp = NULL; + gf_rdma_post_t *tmp = NULL; - while (post->next != post) { - tmp = post->next; + while (post->next != post) { + tmp = post->next; - post->next = post->next->next; - post->next->prev = post; + post->next = post->next->next; + post->next->prev = post; - gf_rdma_destroy_post (tmp); - } + gf_rdma_destroy_post(tmp); + } } - static void -gf_rdma_destroy_queue (gf_rdma_queue_t *queue) +gf_rdma_destroy_queue(gf_rdma_queue_t *queue) { - if (queue == NULL) { - goto out; - } + if (queue == NULL) { + goto out; + } - pthread_mutex_lock (&queue->lock); - { - if (queue->passive_count > 0) { - __gf_rdma_destroy_queue (&queue->passive_posts); - queue->passive_count = 0; - } + pthread_mutex_lock(&queue->lock); + { + if (queue->passive_count > 0) { + __gf_rdma_destroy_queue(&queue->passive_posts); + queue->passive_count = 0; + } - if (queue->active_count > 0) { - __gf_rdma_destroy_queue (&queue->active_posts); - queue->active_count = 0; - } + if (queue->active_count > 0) { + __gf_rdma_destroy_queue(&queue->active_posts); + queue->active_count = 0; } - pthread_mutex_unlock (&queue->lock); + } + pthread_mutex_unlock(&queue->lock); out: - return; + return; } - static void -gf_rdma_destroy_posts (rpc_transport_t *this) +gf_rdma_destroy_posts(rpc_transport_t *this) { - gf_rdma_device_t *device = NULL; - gf_rdma_private_t *priv = NULL; + gf_rdma_device_t *device = NULL; + gf_rdma_private_t *priv = NULL; - if (this == NULL) { - goto out; - } + if (this == NULL) { + goto out; + } - priv = this->private; - device = priv->device; + priv = this->private; + device = priv->device; - gf_rdma_destroy_queue (&device->sendq); - gf_rdma_destroy_queue (&device->recvq); + gf_rdma_destroy_queue(&device->sendq); + gf_rdma_destroy_queue(&device->recvq); out: - return; + return; } - static int32_t -__gf_rdma_create_posts (rpc_transport_t *this, int32_t count, int32_t size, - gf_rdma_queue_t *q, gf_rdma_post_type_t type) +__gf_rdma_create_posts(rpc_transport_t *this, int32_t count, int32_t size, + gf_rdma_queue_t *q, gf_rdma_post_type_t type) { - int32_t i = 0; - int32_t ret = 0; - gf_rdma_private_t *priv = NULL; - gf_rdma_device_t *device = NULL; - - priv = this->private; - device = priv->device; - - for (i = 0 ; i < count ; i++) { - gf_rdma_post_t *post = NULL; - - post = gf_rdma_new_post (this, device, size + 2048, type); - if (!post) { - gf_msg (this->name, GF_LOG_ERROR, 0, - RDMA_MSG_POST_CREATION_FAILED, - "post creation failed"); - ret = -1; - break; - } + int32_t i = 0; + int32_t ret = 0; + gf_rdma_private_t *priv = NULL; + gf_rdma_device_t *device = NULL; + + priv = this->private; + device = priv->device; - gf_rdma_put_post (q, post); + for (i = 0; i < count; i++) { + gf_rdma_post_t *post = NULL; + + post = gf_rdma_new_post(this, device, size + 2048, type); + if (!post) { + gf_msg(this->name, GF_LOG_ERROR, 0, RDMA_MSG_POST_CREATION_FAILED, + "post creation failed"); + ret = -1; + break; } - return ret; -} + gf_rdma_put_post(q, post); + } + return ret; +} static int32_t -gf_rdma_post_recv (struct ibv_srq *srq, - gf_rdma_post_t *post) +gf_rdma_post_recv(struct ibv_srq *srq, gf_rdma_post_t *post) { - struct ibv_sge list = { - .addr = (unsigned long) post->buf, - .length = post->buf_size, - .lkey = post->mr->lkey - }; + struct ibv_sge list = {.addr = (unsigned long)post->buf, + .length = post->buf_size, + .lkey = post->mr->lkey}; - struct ibv_recv_wr wr = { - .wr_id = (unsigned long) post, - .sg_list = &list, - .num_sge = 1, - }, *bad_wr; + struct ibv_recv_wr wr = + { + .wr_id = (unsigned long)post, + .sg_list = &list, + .num_sge = 1, + }, + *bad_wr; - gf_rdma_post_ref (post); + gf_rdma_post_ref(post); - return ibv_post_srq_recv (srq, &wr, &bad_wr); + return ibv_post_srq_recv(srq, &wr, &bad_wr); } static void -gf_rdma_deregister_iobuf_pool (gf_rdma_device_t *device) +gf_rdma_deregister_iobuf_pool(gf_rdma_device_t *device) { + gf_rdma_arena_mr *arena_mr = NULL; + gf_rdma_arena_mr *tmp = NULL; - gf_rdma_arena_mr *arena_mr = NULL; - gf_rdma_arena_mr *tmp = NULL; - - while (device) { - pthread_mutex_lock (&device->all_mr_lock); + while (device) { + pthread_mutex_lock(&device->all_mr_lock); + { + if (!list_empty(&device->all_mr)) { + list_for_each_entry_safe(arena_mr, tmp, &device->all_mr, list) { - if (!list_empty(&device->all_mr)) { - list_for_each_entry_safe (arena_mr, tmp, - &device->all_mr, list) { - if (ibv_dereg_mr(arena_mr->mr)) { - gf_msg ("rdma", GF_LOG_WARNING, 0, - RDMA_MSG_DEREGISTER_ARENA_FAILED, - "deallocation of memory region " - "failed"); - pthread_mutex_unlock (&device->all_mr_lock); - return; - } - list_del(&arena_mr->list); - GF_FREE(arena_mr); - } - } + if (ibv_dereg_mr(arena_mr->mr)) { + gf_msg("rdma", GF_LOG_WARNING, 0, + RDMA_MSG_DEREGISTER_ARENA_FAILED, + "deallocation of memory region " + "failed"); + pthread_mutex_unlock(&device->all_mr_lock); + return; + } + list_del(&arena_mr->list); + GF_FREE(arena_mr); } - pthread_mutex_unlock (&device->all_mr_lock); - - device = device->next; + } } + pthread_mutex_unlock(&device->all_mr_lock); + + device = device->next; + } } int -gf_rdma_deregister_arena (struct list_head **mr_list, - struct iobuf_arena *iobuf_arena) +gf_rdma_deregister_arena(struct list_head **mr_list, + struct iobuf_arena *iobuf_arena) { - gf_rdma_arena_mr *tmp = NULL; - gf_rdma_arena_mr *dummy = NULL; - gf_rdma_device_t *device = NULL; - int count = 0, i = 0; - - count = iobuf_arena->iobuf_pool->rdma_device_count; - for (i = 0; i < count; i++) { - device = iobuf_arena->iobuf_pool->device[i]; - pthread_mutex_lock (&device->all_mr_lock); - { - list_for_each_entry_safe (tmp, dummy, mr_list[i], list) { - if (tmp->iobuf_arena == iobuf_arena) { - if (ibv_dereg_mr(tmp->mr)) { - gf_msg ("rdma", GF_LOG_WARNING, 0, - RDMA_MSG_DEREGISTER_ARENA_FAILED, - "deallocation of memory region " - "failed"); - pthread_mutex_unlock (&device->all_mr_lock); - return -1; - } - list_del(&tmp->list); - GF_FREE(tmp); - break; - } - } + gf_rdma_arena_mr *tmp = NULL; + gf_rdma_arena_mr *dummy = NULL; + gf_rdma_device_t *device = NULL; + int count = 0, i = 0; + + count = iobuf_arena->iobuf_pool->rdma_device_count; + for (i = 0; i < count; i++) { + device = iobuf_arena->iobuf_pool->device[i]; + pthread_mutex_lock(&device->all_mr_lock); + { + list_for_each_entry_safe(tmp, dummy, mr_list[i], list) + { + if (tmp->iobuf_arena == iobuf_arena) { + if (ibv_dereg_mr(tmp->mr)) { + gf_msg("rdma", GF_LOG_WARNING, 0, + RDMA_MSG_DEREGISTER_ARENA_FAILED, + "deallocation of memory region " + "failed"); + pthread_mutex_unlock(&device->all_mr_lock); + return -1; + } + list_del(&tmp->list); + GF_FREE(tmp); + break; } - pthread_mutex_unlock (&device->all_mr_lock); + } } + pthread_mutex_unlock(&device->all_mr_lock); + } - return 0; + return 0; } - int -gf_rdma_register_arena (void **arg1, void *arg2) +gf_rdma_register_arena(void **arg1, void *arg2) { - struct ibv_mr *mr = NULL; - gf_rdma_arena_mr *new = NULL; - struct iobuf_pool *iobuf_pool = NULL; - gf_rdma_device_t **device = (gf_rdma_device_t **)arg1; - struct iobuf_arena *iobuf_arena = arg2; - int count = 0, i = 0; - - iobuf_pool = iobuf_arena->iobuf_pool; - count = iobuf_pool->rdma_device_count; - for (i = 0; i < count; i++) { - new = GF_CALLOC(1, sizeof(gf_rdma_arena_mr), - gf_common_mt_rdma_arena_mr); - if (new == NULL) { - gf_msg ("rdma", GF_LOG_INFO, ENOMEM, - RDMA_MSG_MR_ALOC_FAILED, "Out of " - "memory: registering pre allocated buffer " - "with rdma device failed."); - return -1; - } - INIT_LIST_HEAD (&new->list); - new->iobuf_arena = iobuf_arena; - - mr = ibv_reg_mr(device[i]->pd, iobuf_arena->mem_base, - iobuf_arena->arena_size, - IBV_ACCESS_REMOTE_READ | - IBV_ACCESS_LOCAL_WRITE | - IBV_ACCESS_REMOTE_WRITE - ); - if (!mr) - gf_msg ("rdma", GF_LOG_WARNING, 0, - RDMA_MSG_MR_ALOC_FAILED, "allocation of mr " - "failed"); - - new->mr = mr; - pthread_mutex_lock (&device[i]->all_mr_lock); - { - list_add (&new->list, &device[i]->all_mr); - } - pthread_mutex_unlock (&device[i]->all_mr_lock); - new = NULL; + struct ibv_mr *mr = NULL; + gf_rdma_arena_mr *new = NULL; + struct iobuf_pool *iobuf_pool = NULL; + gf_rdma_device_t **device = (gf_rdma_device_t **)arg1; + struct iobuf_arena *iobuf_arena = arg2; + int count = 0, i = 0; + + iobuf_pool = iobuf_arena->iobuf_pool; + count = iobuf_pool->rdma_device_count; + for (i = 0; i < count; i++) { + new = GF_CALLOC(1, sizeof(gf_rdma_arena_mr), + gf_common_mt_rdma_arena_mr); + if (new == NULL) { + gf_msg("rdma", GF_LOG_INFO, ENOMEM, RDMA_MSG_MR_ALOC_FAILED, + "Out of " + "memory: registering pre allocated buffer " + "with rdma device failed."); + return -1; + } + INIT_LIST_HEAD(&new->list); + new->iobuf_arena = iobuf_arena; + + mr = ibv_reg_mr(device[i]->pd, iobuf_arena->mem_base, + iobuf_arena->arena_size, + IBV_ACCESS_REMOTE_READ | IBV_ACCESS_LOCAL_WRITE | + IBV_ACCESS_REMOTE_WRITE); + if (!mr) + gf_msg("rdma", GF_LOG_WARNING, 0, RDMA_MSG_MR_ALOC_FAILED, + "allocation of mr " + "failed"); + + new->mr = mr; + pthread_mutex_lock(&device[i]->all_mr_lock); + { + list_add(&new->list, &device[i]->all_mr); } + pthread_mutex_unlock(&device[i]->all_mr_lock); + new = NULL; + } - return 0; - + return 0; } static void -gf_rdma_register_iobuf_pool (gf_rdma_device_t *device, - struct iobuf_pool *iobuf_pool) +gf_rdma_register_iobuf_pool(gf_rdma_device_t *device, + struct iobuf_pool *iobuf_pool) { - struct iobuf_arena *tmp = NULL; - struct iobuf_arena *dummy = NULL; - struct ibv_mr *mr = NULL; - gf_rdma_arena_mr *new = NULL; - - if (!list_empty(&iobuf_pool->all_arenas)) { - - list_for_each_entry_safe (tmp, dummy, &iobuf_pool->all_arenas, - all_list) { - new = GF_CALLOC(1, sizeof(gf_rdma_arena_mr), - gf_common_mt_rdma_arena_mr); - if (new == NULL) { - gf_msg ("rdma", GF_LOG_INFO, ENOMEM, - RDMA_MSG_MR_ALOC_FAILED, "Out of " - "memory: registering pre allocated " - "buffer with rdma device failed."); - return; - } - INIT_LIST_HEAD (&new->list); - new->iobuf_arena = tmp; - - mr = ibv_reg_mr(device->pd, tmp->mem_base, - tmp->arena_size, - IBV_ACCESS_REMOTE_READ | - IBV_ACCESS_LOCAL_WRITE | - IBV_ACCESS_REMOTE_WRITE); - if (!mr) { - gf_msg ("rdma", GF_LOG_WARNING, 0, - RDMA_MSG_MR_ALOC_FAILED, "failed" - " to pre register buffers with rdma " - "devices."); - - } - new->mr = mr; - pthread_mutex_lock (&device->all_mr_lock); - { - list_add (&new->list, &device->all_mr); - } - pthread_mutex_unlock (&device->all_mr_lock); + struct iobuf_arena *tmp = NULL; + struct iobuf_arena *dummy = NULL; + struct ibv_mr *mr = NULL; + gf_rdma_arena_mr *new = NULL; - new = NULL; - } - } - - return; + if (!list_empty(&iobuf_pool->all_arenas)) { + list_for_each_entry_safe(tmp, dummy, &iobuf_pool->all_arenas, all_list) + { + new = GF_CALLOC(1, sizeof(gf_rdma_arena_mr), + gf_common_mt_rdma_arena_mr); + if (new == NULL) { + gf_msg("rdma", GF_LOG_INFO, ENOMEM, RDMA_MSG_MR_ALOC_FAILED, + "Out of " + "memory: registering pre allocated " + "buffer with rdma device failed."); + return; + } + INIT_LIST_HEAD(&new->list); + new->iobuf_arena = tmp; + + mr = ibv_reg_mr(device->pd, tmp->mem_base, tmp->arena_size, + IBV_ACCESS_REMOTE_READ | IBV_ACCESS_LOCAL_WRITE | + IBV_ACCESS_REMOTE_WRITE); + if (!mr) { + gf_msg("rdma", GF_LOG_WARNING, 0, RDMA_MSG_MR_ALOC_FAILED, + "failed" + " to pre register buffers with rdma " + "devices."); + } + new->mr = mr; + pthread_mutex_lock(&device->all_mr_lock); + { + list_add(&new->list, &device->all_mr); + } + pthread_mutex_unlock(&device->all_mr_lock); + + new = NULL; + } + } + + return; } static void -gf_rdma_register_iobuf_pool_with_device (gf_rdma_device_t *device, - struct iobuf_pool *iobuf_pool) +gf_rdma_register_iobuf_pool_with_device(gf_rdma_device_t *device, + struct iobuf_pool *iobuf_pool) { - while (device) { - gf_rdma_register_iobuf_pool (device, iobuf_pool); - device = device->next; - } + while (device) { + gf_rdma_register_iobuf_pool(device, iobuf_pool); + device = device->next; + } } -static struct ibv_mr* +static struct ibv_mr * gf_rdma_get_pre_registred_mr(rpc_transport_t *this, void *ptr, int size) { - gf_rdma_arena_mr *tmp = NULL; - gf_rdma_arena_mr *dummy = NULL; - gf_rdma_private_t *priv = NULL; - gf_rdma_device_t *device = NULL; - - priv = this->private; - device = priv->device; - - pthread_mutex_lock (&device->all_mr_lock); - { - if (!list_empty(&device->all_mr)) { - list_for_each_entry_safe (tmp, dummy, &device->all_mr, list) { - if (tmp->iobuf_arena->mem_base <= ptr && - ptr < tmp->iobuf_arena->mem_base + - tmp->iobuf_arena->arena_size) { - pthread_mutex_unlock (&device->all_mr_lock); - return tmp->mr; - } - } + gf_rdma_arena_mr *tmp = NULL; + gf_rdma_arena_mr *dummy = NULL; + gf_rdma_private_t *priv = NULL; + gf_rdma_device_t *device = NULL; + + priv = this->private; + device = priv->device; + + pthread_mutex_lock(&device->all_mr_lock); + { + if (!list_empty(&device->all_mr)) { + list_for_each_entry_safe(tmp, dummy, &device->all_mr, list) + { + if (tmp->iobuf_arena->mem_base <= ptr && + ptr < tmp->iobuf_arena->mem_base + + tmp->iobuf_arena->arena_size) { + pthread_mutex_unlock(&device->all_mr_lock); + return tmp->mr; } + } } - pthread_mutex_unlock (&device->all_mr_lock); + } + pthread_mutex_unlock(&device->all_mr_lock); - return NULL; + return NULL; } static int32_t -gf_rdma_create_posts (rpc_transport_t *this) +gf_rdma_create_posts(rpc_transport_t *this) { - int32_t i = 0, ret = 0; - gf_rdma_post_t *post = NULL; - gf_rdma_private_t *priv = NULL; - gf_rdma_options_t *options = NULL; - gf_rdma_device_t *device = NULL; - - priv = this->private; - options = &priv->options; - device = priv->device; - - ret = __gf_rdma_create_posts (this, options->send_count, - options->send_size, - &device->sendq, GF_RDMA_SEND_POST); - if (!ret) - ret = __gf_rdma_create_posts (this, options->recv_count, - options->recv_size, - &device->recvq, - GF_RDMA_RECV_POST); - - if (!ret) { - for (i = 0 ; i < options->recv_count ; i++) { - post = gf_rdma_get_post (&device->recvq); - if (gf_rdma_post_recv (device->srq, post) != 0) { - ret = -1; - break; - } - } + int32_t i = 0, ret = 0; + gf_rdma_post_t *post = NULL; + gf_rdma_private_t *priv = NULL; + gf_rdma_options_t *options = NULL; + gf_rdma_device_t *device = NULL; + + priv = this->private; + options = &priv->options; + device = priv->device; + + ret = __gf_rdma_create_posts(this, options->send_count, options->send_size, + &device->sendq, GF_RDMA_SEND_POST); + if (!ret) + ret = __gf_rdma_create_posts(this, options->recv_count, + options->recv_size, &device->recvq, + GF_RDMA_RECV_POST); + + if (!ret) { + for (i = 0; i < options->recv_count; i++) { + post = gf_rdma_get_post(&device->recvq); + if (gf_rdma_post_recv(device->srq, post) != 0) { + ret = -1; + break; + } } + } - if (ret) - gf_rdma_destroy_posts (this); + if (ret) + gf_rdma_destroy_posts(this); - return ret; + return ret; } - static void -gf_rdma_destroy_cq (rpc_transport_t *this) +gf_rdma_destroy_cq(rpc_transport_t *this) { - gf_rdma_private_t *priv = NULL; - gf_rdma_device_t *device = NULL; + gf_rdma_private_t *priv = NULL; + gf_rdma_device_t *device = NULL; - priv = this->private; - device = priv->device; + priv = this->private; + device = priv->device; - if (device->recv_cq) - ibv_destroy_cq (device->recv_cq); - device->recv_cq = NULL; + if (device->recv_cq) + ibv_destroy_cq(device->recv_cq); + device->recv_cq = NULL; - if (device->send_cq) - ibv_destroy_cq (device->send_cq); - device->send_cq = NULL; + if (device->send_cq) + ibv_destroy_cq(device->send_cq); + device->send_cq = NULL; - return; + return; } - static int32_t -gf_rdma_create_cq (rpc_transport_t *this) +gf_rdma_create_cq(rpc_transport_t *this) { - gf_rdma_private_t *priv = NULL; - gf_rdma_options_t *options = NULL; - gf_rdma_device_t *device = NULL; - uint64_t send_cqe = 0; - int32_t ret = 0; - struct ibv_device_attr device_attr = {{0}, }; - - priv = this->private; - options = &priv->options; - device = priv->device; - - device->recv_cq = ibv_create_cq (priv->device->context, - options->recv_count * 2, - device, - device->recv_chan, - 0); - if (!device->recv_cq) { - gf_msg (this->name, GF_LOG_ERROR, 0, - RDMA_MSG_CQ_CREATION_FAILED, "creation of CQ for " - "device %s failed", device->device_name); - ret = -1; - goto out; - } else if (ibv_req_notify_cq (device->recv_cq, 0)) { - gf_msg (this->name, GF_LOG_ERROR, 0, - RDMA_MSG_REQ_NOTIFY_CQ_REVQ_FAILED, "ibv_req_notify_" - "cq on recv CQ of device %s failed", - device->device_name); - ret = -1; - goto out; - } - - do { - ret = ibv_query_device (priv->device->context, &device_attr); - if (ret != 0) { - gf_msg (this->name, GF_LOG_ERROR, 0, - RDMA_MSG_QUERY_DEVICE_FAILED, "ibv_query_" - "device on %s returned %d (%s)", - priv->device->device_name, ret, - (ret > 0) ? strerror (ret) : ""); - ret = -1; - goto out; - } - - send_cqe = (uint64_t)options->send_count * 128; - send_cqe = (send_cqe > device_attr.max_cqe) - ? device_attr.max_cqe : send_cqe; - - /* TODO: make send_cq size dynamically adaptive */ - device->send_cq = ibv_create_cq (priv->device->context, - send_cqe, device, - device->send_chan, 0); - if (!device->send_cq) { - gf_msg (this->name, GF_LOG_ERROR, 0, - RDMA_MSG_CQ_CREATION_FAILED, - "creation of send_cq " - "for device %s failed", device->device_name); - ret = -1; - goto out; - } - - if (ibv_req_notify_cq (device->send_cq, 0)) { - gf_msg (this->name, GF_LOG_ERROR, 0, - RDMA_MSG_REQ_NOTIFY_CQ_SENDQ_FAILED, - "ibv_req_notify_cq on send_cq for device %s" - " failed", device->device_name); - ret = -1; - goto out; - } - } while (0); + gf_rdma_private_t *priv = NULL; + gf_rdma_options_t *options = NULL; + gf_rdma_device_t *device = NULL; + uint64_t send_cqe = 0; + int32_t ret = 0; + struct ibv_device_attr device_attr = { + {0}, + }; + + priv = this->private; + options = &priv->options; + device = priv->device; + + device->recv_cq = ibv_create_cq(priv->device->context, + options->recv_count * 2, device, + device->recv_chan, 0); + if (!device->recv_cq) { + gf_msg(this->name, GF_LOG_ERROR, 0, RDMA_MSG_CQ_CREATION_FAILED, + "creation of CQ for " + "device %s failed", + device->device_name); + ret = -1; + goto out; + } else if (ibv_req_notify_cq(device->recv_cq, 0)) { + gf_msg(this->name, GF_LOG_ERROR, 0, RDMA_MSG_REQ_NOTIFY_CQ_REVQ_FAILED, + "ibv_req_notify_" + "cq on recv CQ of device %s failed", + device->device_name); + ret = -1; + goto out; + } + + do { + ret = ibv_query_device(priv->device->context, &device_attr); + if (ret != 0) { + gf_msg(this->name, GF_LOG_ERROR, 0, RDMA_MSG_QUERY_DEVICE_FAILED, + "ibv_query_" + "device on %s returned %d (%s)", + priv->device->device_name, ret, + (ret > 0) ? strerror(ret) : ""); + ret = -1; + goto out; + } + + send_cqe = (uint64_t)options->send_count * 128; + send_cqe = (send_cqe > device_attr.max_cqe) ? device_attr.max_cqe + : send_cqe; + + /* TODO: make send_cq size dynamically adaptive */ + device->send_cq = ibv_create_cq(priv->device->context, send_cqe, device, + device->send_chan, 0); + if (!device->send_cq) { + gf_msg(this->name, GF_LOG_ERROR, 0, RDMA_MSG_CQ_CREATION_FAILED, + "creation of send_cq " + "for device %s failed", + device->device_name); + ret = -1; + goto out; + } + + if (ibv_req_notify_cq(device->send_cq, 0)) { + gf_msg(this->name, GF_LOG_ERROR, 0, + RDMA_MSG_REQ_NOTIFY_CQ_SENDQ_FAILED, + "ibv_req_notify_cq on send_cq for device %s" + " failed", + device->device_name); + ret = -1; + goto out; + } + } while (0); out: - if (ret != 0) - gf_rdma_destroy_cq (this); + if (ret != 0) + gf_rdma_destroy_cq(this); - return ret; + return ret; } - static gf_rdma_device_t * -gf_rdma_get_device (rpc_transport_t *this, struct ibv_context *ibctx, - char *device_name) +gf_rdma_get_device(rpc_transport_t *this, struct ibv_context *ibctx, + char *device_name) { - glusterfs_ctx_t *ctx = NULL; - gf_rdma_private_t *priv = NULL; - gf_rdma_options_t *options = NULL; - int32_t ret = 0; - int32_t i = 0; - gf_rdma_device_t *trav = NULL, *device = NULL; - gf_rdma_ctx_t *rdma_ctx = NULL; - struct iobuf_pool *iobuf_pool = NULL; - - priv = this->private; - options = &priv->options; - ctx = this->ctx; - rdma_ctx = ctx->ib; - iobuf_pool = ctx->iobuf_pool; - - trav = rdma_ctx->device; - - while (trav) { - if (!strcmp (trav->device_name, device_name)) - break; - trav = trav->next; - } - - if (!trav) { - trav = GF_CALLOC (1, sizeof (*trav), - gf_common_mt_rdma_device_t); - if (trav == NULL) { - goto out; - } - priv->device = trav; - trav->context = ibctx; - - trav->next = rdma_ctx->device; - rdma_ctx->device = trav; - - iobuf_pool->device[iobuf_pool->rdma_device_count] = trav; - iobuf_pool->mr_list[iobuf_pool->rdma_device_count++] = &trav->all_mr; - trav->request_ctx_pool - = mem_pool_new (gf_rdma_request_context_t, - GF_RDMA_POOL_SIZE); - if (trav->request_ctx_pool == NULL) { - goto out; - } + glusterfs_ctx_t *ctx = NULL; + gf_rdma_private_t *priv = NULL; + gf_rdma_options_t *options = NULL; + int32_t ret = 0; + int32_t i = 0; + gf_rdma_device_t *trav = NULL, *device = NULL; + gf_rdma_ctx_t *rdma_ctx = NULL; + struct iobuf_pool *iobuf_pool = NULL; - trav->ioq_pool - = mem_pool_new (gf_rdma_ioq_t, GF_RDMA_POOL_SIZE); - if (trav->ioq_pool == NULL) { - goto out; - } - - trav->reply_info_pool = mem_pool_new (gf_rdma_reply_info_t, - GF_RDMA_POOL_SIZE); - if (trav->reply_info_pool == NULL) { - goto out; - } + priv = this->private; + options = &priv->options; + ctx = this->ctx; + rdma_ctx = ctx->ib; + iobuf_pool = ctx->iobuf_pool; - trav->device_name = gf_strdup (device_name); + trav = rdma_ctx->device; - trav->send_chan = ibv_create_comp_channel (trav->context); - if (!trav->send_chan) { - gf_msg (this->name, GF_LOG_ERROR, 0, - RDMA_MSG_SEND_COMP_CHAN_FAILED, "could not " - "create send completion channel for " - "device (%s)", device_name); - goto out; - } - - trav->recv_chan = ibv_create_comp_channel (trav->context); - if (!trav->recv_chan) { - gf_msg (this->name, GF_LOG_ERROR, 0, - RDMA_MSG_RECV_COMP_CHAN_FAILED, "could not " - "create recv completion channel for " - "device (%s)", device_name); - - /* TODO: cleanup current mess */ - goto out; - } - - if (gf_rdma_create_cq (this) < 0) { - gf_msg (this->name, GF_LOG_ERROR, 0, - RDMA_MSG_CQ_CREATION_FAILED, - "could not create CQ for device (%s)", - device_name); - goto out; - } - - /* protection domain */ - trav->pd = ibv_alloc_pd (trav->context); - - if (!trav->pd) { - gf_msg (this->name, GF_LOG_ERROR, 0, - RDMA_MSG_ALOC_PROT_DOM_FAILED, "could not " - "allocate protection domain for device (%s)", - device_name); - goto out; - } + while (trav) { + if (!strcmp(trav->device_name, device_name)) + break; + trav = trav->next; + } - struct ibv_srq_init_attr attr = { - .attr = { - .max_wr = options->recv_count, - .max_sge = 1, - .srq_limit = 10 - } - }; - trav->srq = ibv_create_srq (trav->pd, &attr); - - if (!trav->srq) { - gf_msg (this->name, GF_LOG_ERROR, 0, - RDMA_MSG_CRE_SRQ_FAILED, "could not create SRQ" - " for device (%s)", - device_name); - goto out; - } - - /* queue init */ - gf_rdma_queue_init (&trav->sendq); - gf_rdma_queue_init (&trav->recvq); - - INIT_LIST_HEAD (&trav->all_mr); - pthread_mutex_init (&trav->all_mr_lock, NULL); - gf_rdma_register_iobuf_pool(trav, iobuf_pool); - - if (gf_rdma_create_posts (this) < 0) { - gf_msg (this->name, GF_LOG_ERROR, 0, - RDMA_MSG_ALOC_POST_FAILED, "could not allocate" - "posts for device (%s)", device_name); - goto out; - } - - /* completion threads */ - ret = gf_thread_create (&trav->send_thread, NULL, - gf_rdma_send_completion_proc, - trav->send_chan, "rdmascom"); - if (ret) { - gf_msg (this->name, GF_LOG_ERROR, 0, - RDMA_MSG_SEND_COMP_THREAD_FAILED, - "could not create send completion thread for " - "device (%s)", device_name); - goto out; - } - - ret = gf_thread_create (&trav->recv_thread, NULL, - gf_rdma_recv_completion_proc, - trav->recv_chan, "rdmarcom"); - if (ret) { - gf_msg (this->name, GF_LOG_ERROR, 0, - RDMA_MSG_RECV_COMP_THREAD_FAILED, - "could not create recv completion thread " - "for device (%s)", device_name); - return NULL; - } - - ret = gf_thread_create (&trav->async_event_thread, NULL, - gf_rdma_async_event_thread, - ibctx, "rdmaAsyn"); - if (ret) { - gf_msg (this->name, GF_LOG_ERROR, 0, - RDMA_MSG_ASYNC_EVENT_THEAD_FAILED, - "could not create async_event_thread"); - return NULL; - } - - /* qpreg */ - pthread_mutex_init (&trav->qpreg.lock, NULL); - for (i = 0; i < 42; i++) { - trav->qpreg.ents[i].next = &trav->qpreg.ents[i]; - trav->qpreg.ents[i].prev = &trav->qpreg.ents[i]; - } + if (!trav) { + trav = GF_CALLOC(1, sizeof(*trav), gf_common_mt_rdma_device_t); + if (trav == NULL) { + goto out; } + priv->device = trav; + trav->context = ibctx; - device = trav; - trav = NULL; -out: + trav->next = rdma_ctx->device; + rdma_ctx->device = trav; - if (trav != NULL) { - rdma_ctx->device = trav->next; - gf_rdma_destroy_posts (this); - mem_pool_destroy (trav->ioq_pool); - mem_pool_destroy (trav->request_ctx_pool); - mem_pool_destroy (trav->reply_info_pool); - if (trav->pd != NULL) { - ibv_dealloc_pd (trav->pd); - } - gf_rdma_destroy_cq (this); - ibv_destroy_comp_channel (trav->recv_chan); - ibv_destroy_comp_channel (trav->send_chan); - GF_FREE ((char *)trav->device_name); - GF_FREE (trav); + iobuf_pool->device[iobuf_pool->rdma_device_count] = trav; + iobuf_pool->mr_list[iobuf_pool->rdma_device_count++] = &trav->all_mr; + trav->request_ctx_pool = mem_pool_new(gf_rdma_request_context_t, + GF_RDMA_POOL_SIZE); + if (trav->request_ctx_pool == NULL) { + goto out; } - return device; -} - - -static rpc_transport_t * -gf_rdma_transport_new (rpc_transport_t *listener, struct rdma_cm_id *cm_id) -{ - gf_rdma_private_t *listener_priv = NULL, *priv = NULL; - rpc_transport_t *this = NULL, *new = NULL; - gf_rdma_options_t *options = NULL; - char *device_name = NULL; - - listener_priv = listener->private; - - this = GF_CALLOC (1, sizeof (rpc_transport_t), - gf_common_mt_rpc_transport_t); - if (this == NULL) { - goto out; + trav->ioq_pool = mem_pool_new(gf_rdma_ioq_t, GF_RDMA_POOL_SIZE); + if (trav->ioq_pool == NULL) { + goto out; } - this->listener = listener; - - priv = GF_CALLOC (1, sizeof (gf_rdma_private_t), - gf_common_mt_rdma_private_t); - if (priv == NULL) { - goto out; + trav->reply_info_pool = mem_pool_new(gf_rdma_reply_info_t, + GF_RDMA_POOL_SIZE); + if (trav->reply_info_pool == NULL) { + goto out; } - this->private = priv; - priv->options = listener_priv->options; - - priv->listener = listener; - priv->entity = GF_RDMA_SERVER; - - options = &priv->options; + trav->device_name = gf_strdup(device_name); - this->ops = listener->ops; - this->init = listener->init; - this->fini = listener->fini; - this->ctx = listener->ctx; - this->name = gf_strdup (listener->name); - this->notify = listener->notify; - this->mydata = listener->mydata; - this->xl = listener->xl; - - this->myinfo.sockaddr_len = sizeof (cm_id->route.addr.src_addr); - memcpy (&this->myinfo.sockaddr, &cm_id->route.addr.src_addr, - this->myinfo.sockaddr_len); - - this->peerinfo.sockaddr_len = sizeof (cm_id->route.addr.dst_addr); - memcpy (&this->peerinfo.sockaddr, &cm_id->route.addr.dst_addr, - this->peerinfo.sockaddr_len); + trav->send_chan = ibv_create_comp_channel(trav->context); + if (!trav->send_chan) { + gf_msg(this->name, GF_LOG_ERROR, 0, RDMA_MSG_SEND_COMP_CHAN_FAILED, + "could not " + "create send completion channel for " + "device (%s)", + device_name); + goto out; + } - priv->peer.trans = this; - gf_rdma_get_transport_identifiers (this); + trav->recv_chan = ibv_create_comp_channel(trav->context); + if (!trav->recv_chan) { + gf_msg(this->name, GF_LOG_ERROR, 0, RDMA_MSG_RECV_COMP_CHAN_FAILED, + "could not " + "create recv completion channel for " + "device (%s)", + device_name); - device_name = (char *)ibv_get_device_name (cm_id->verbs->device); - if (device_name == NULL) { - gf_msg (listener->name, GF_LOG_WARNING, 0, - RDMA_MSG_GET_DEVICE_NAME_FAILED, "cannot get device " - "name (peer:%s me:%s)", this->peerinfo.identifier, - this->myinfo.identifier); - goto out; + /* TODO: cleanup current mess */ + goto out; } - priv->device = gf_rdma_get_device (this, cm_id->verbs, - device_name); - if (priv->device == NULL) { - gf_msg (listener->name, GF_LOG_WARNING, 0, - RDMA_MSG_GET_IB_DEVICE_FAILED, "cannot get infiniband" - " device %s (peer:%s me:%s)", device_name, - this->peerinfo.identifier, this->myinfo.identifier); - goto out; + if (gf_rdma_create_cq(this) < 0) { + gf_msg(this->name, GF_LOG_ERROR, 0, RDMA_MSG_CQ_CREATION_FAILED, + "could not create CQ for device (%s)", device_name); + goto out; } - priv->peer.send_count = options->send_count; - priv->peer.recv_count = options->recv_count; - priv->peer.send_size = options->send_size; - priv->peer.recv_size = options->recv_size; - priv->peer.cm_id = cm_id; - INIT_LIST_HEAD (&priv->peer.ioq); + /* protection domain */ + trav->pd = ibv_alloc_pd(trav->context); - pthread_mutex_init (&priv->write_mutex, NULL); - pthread_mutex_init (&priv->recv_mutex, NULL); - - cm_id->context = this; - - new = rpc_transport_ref (this); - this = NULL; -out: - if (this != NULL) { - if (this->private != NULL) { - GF_FREE (this->private); - } + if (!trav->pd) { + gf_msg(this->name, GF_LOG_ERROR, 0, RDMA_MSG_ALOC_PROT_DOM_FAILED, + "could not " + "allocate protection domain for device (%s)", + device_name); + goto out; + } - if (this->name != NULL) { - GF_FREE (this->name); - } + struct ibv_srq_init_attr attr = {.attr = {.max_wr = options->recv_count, + .max_sge = 1, + .srq_limit = 10}}; + trav->srq = ibv_create_srq(trav->pd, &attr); - GF_FREE (this); + if (!trav->srq) { + gf_msg(this->name, GF_LOG_ERROR, 0, RDMA_MSG_CRE_SRQ_FAILED, + "could not create SRQ" + " for device (%s)", + device_name); + goto out; } - return new; -} + /* queue init */ + gf_rdma_queue_init(&trav->sendq); + gf_rdma_queue_init(&trav->recvq); + INIT_LIST_HEAD(&trav->all_mr); + pthread_mutex_init(&trav->all_mr_lock, NULL); + gf_rdma_register_iobuf_pool(trav, iobuf_pool); -static int -gf_rdma_cm_handle_connect_request (struct rdma_cm_event *event) -{ - int ret = -1; - rpc_transport_t *this = NULL, *listener = NULL; - struct rdma_cm_id *child_cm_id = NULL, *listener_cm_id = NULL; - struct rdma_conn_param conn_param = {0, }; - gf_rdma_private_t *priv = NULL; - gf_rdma_options_t *options = NULL; - - child_cm_id = event->id; - listener_cm_id = event->listen_id; - - listener = listener_cm_id->context; - priv = listener->private; - options = &priv->options; - - this = gf_rdma_transport_new (listener, child_cm_id); - if (this == NULL) { - gf_msg (listener->name, GF_LOG_WARNING, 0, - RDMA_MSG_CREAT_INC_TRANS_FAILED, "could not create " - "a transport for incoming connection" - " (me.name:%s me.identifier:%s)", listener->name, - listener->myinfo.identifier); - rdma_destroy_id (child_cm_id); - goto out; + if (gf_rdma_create_posts(this) < 0) { + gf_msg(this->name, GF_LOG_ERROR, 0, RDMA_MSG_ALOC_POST_FAILED, + "could not allocate" + "posts for device (%s)", + device_name); + goto out; } - gf_msg_trace (listener->name, 0, "got a connect request (me:%s peer:" - "%s)", listener->myinfo.identifier, - this->peerinfo.identifier); + /* completion threads */ + ret = gf_thread_create(&trav->send_thread, NULL, + gf_rdma_send_completion_proc, trav->send_chan, + "rdmascom"); + if (ret) { + gf_msg(this->name, GF_LOG_ERROR, 0, + RDMA_MSG_SEND_COMP_THREAD_FAILED, + "could not create send completion thread for " + "device (%s)", + device_name); + goto out; + } - ret = gf_rdma_create_qp (this); - if (ret < 0) { - gf_msg (listener->name, GF_LOG_WARNING, 0, - RDMA_MSG_CREAT_QP_FAILED, "could not create QP " - "(peer:%s me:%s)", this->peerinfo.identifier, - this->myinfo.identifier); - gf_rdma_cm_handle_disconnect (this); - goto out; + ret = gf_thread_create(&trav->recv_thread, NULL, + gf_rdma_recv_completion_proc, trav->recv_chan, + "rdmarcom"); + if (ret) { + gf_msg(this->name, GF_LOG_ERROR, 0, + RDMA_MSG_RECV_COMP_THREAD_FAILED, + "could not create recv completion thread " + "for device (%s)", + device_name); + return NULL; } - conn_param.responder_resources = 1; - conn_param.initiator_depth = 1; - conn_param.retry_count = options->attr_retry_cnt; - conn_param.rnr_retry_count = options->attr_rnr_retry; + ret = gf_thread_create(&trav->async_event_thread, NULL, + gf_rdma_async_event_thread, ibctx, "rdmaAsyn"); + if (ret) { + gf_msg(this->name, GF_LOG_ERROR, 0, + RDMA_MSG_ASYNC_EVENT_THEAD_FAILED, + "could not create async_event_thread"); + return NULL; + } - ret = rdma_accept(child_cm_id, &conn_param); - if (ret < 0) { - gf_msg (listener->name, GF_LOG_WARNING, errno, - RDMA_MSG_ACCEPT_FAILED, "rdma_accept failed peer:%s " - "me:%s", this->peerinfo.identifier, - this->myinfo.identifier); - gf_rdma_cm_handle_disconnect (this); - goto out; + /* qpreg */ + pthread_mutex_init(&trav->qpreg.lock, NULL); + for (i = 0; i < 42; i++) { + trav->qpreg.ents[i].next = &trav->qpreg.ents[i]; + trav->qpreg.ents[i].prev = &trav->qpreg.ents[i]; } - gf_rdma_cm_handle_connect_init (event); - ret = 0; + } + device = trav; + trav = NULL; out: - return ret; -} + if (trav != NULL) { + rdma_ctx->device = trav->next; + gf_rdma_destroy_posts(this); + mem_pool_destroy(trav->ioq_pool); + mem_pool_destroy(trav->request_ctx_pool); + mem_pool_destroy(trav->reply_info_pool); + if (trav->pd != NULL) { + ibv_dealloc_pd(trav->pd); + } + gf_rdma_destroy_cq(this); + ibv_destroy_comp_channel(trav->recv_chan); + ibv_destroy_comp_channel(trav->send_chan); + GF_FREE((char *)trav->device_name); + GF_FREE(trav); + } + + return device; +} -static int -gf_rdma_cm_handle_route_resolved (struct rdma_cm_event *event) +static rpc_transport_t * +gf_rdma_transport_new(rpc_transport_t *listener, struct rdma_cm_id *cm_id) { - struct rdma_conn_param conn_param = {0, }; - int ret = 0; - rpc_transport_t *this = NULL; - gf_rdma_private_t *priv = NULL; - gf_rdma_peer_t *peer = NULL; - gf_rdma_options_t *options = NULL; - - if (event == NULL) { - goto out; + gf_rdma_private_t *listener_priv = NULL, *priv = NULL; + rpc_transport_t *this = NULL, *new = NULL; + gf_rdma_options_t *options = NULL; + char *device_name = NULL; + + listener_priv = listener->private; + + this = GF_CALLOC(1, sizeof(rpc_transport_t), gf_common_mt_rpc_transport_t); + if (this == NULL) { + goto out; + } + + this->listener = listener; + + priv = GF_CALLOC(1, sizeof(gf_rdma_private_t), gf_common_mt_rdma_private_t); + if (priv == NULL) { + goto out; + } + + this->private = priv; + priv->options = listener_priv->options; + + priv->listener = listener; + priv->entity = GF_RDMA_SERVER; + + options = &priv->options; + + this->ops = listener->ops; + this->init = listener->init; + this->fini = listener->fini; + this->ctx = listener->ctx; + this->name = gf_strdup(listener->name); + this->notify = listener->notify; + this->mydata = listener->mydata; + this->xl = listener->xl; + + this->myinfo.sockaddr_len = sizeof(cm_id->route.addr.src_addr); + memcpy(&this->myinfo.sockaddr, &cm_id->route.addr.src_addr, + this->myinfo.sockaddr_len); + + this->peerinfo.sockaddr_len = sizeof(cm_id->route.addr.dst_addr); + memcpy(&this->peerinfo.sockaddr, &cm_id->route.addr.dst_addr, + this->peerinfo.sockaddr_len); + + priv->peer.trans = this; + gf_rdma_get_transport_identifiers(this); + + device_name = (char *)ibv_get_device_name(cm_id->verbs->device); + if (device_name == NULL) { + gf_msg(listener->name, GF_LOG_WARNING, 0, + RDMA_MSG_GET_DEVICE_NAME_FAILED, + "cannot get device " + "name (peer:%s me:%s)", + this->peerinfo.identifier, this->myinfo.identifier); + goto out; + } + + priv->device = gf_rdma_get_device(this, cm_id->verbs, device_name); + if (priv->device == NULL) { + gf_msg(listener->name, GF_LOG_WARNING, 0, RDMA_MSG_GET_IB_DEVICE_FAILED, + "cannot get infiniband" + " device %s (peer:%s me:%s)", + device_name, this->peerinfo.identifier, this->myinfo.identifier); + goto out; + } + + priv->peer.send_count = options->send_count; + priv->peer.recv_count = options->recv_count; + priv->peer.send_size = options->send_size; + priv->peer.recv_size = options->recv_size; + priv->peer.cm_id = cm_id; + INIT_LIST_HEAD(&priv->peer.ioq); + + pthread_mutex_init(&priv->write_mutex, NULL); + pthread_mutex_init(&priv->recv_mutex, NULL); + + cm_id->context = this; + + new = rpc_transport_ref(this); + this = NULL; +out: + if (this != NULL) { + if (this->private != NULL) { + GF_FREE(this->private); } - this = event->id->context; - - priv = this->private; - peer = &priv->peer; - options = &priv->options; - - ret = gf_rdma_create_qp (this); - if (ret != 0) { - gf_msg (this->name, GF_LOG_WARNING, 0, - RDMA_MSG_CREAT_QP_FAILED, "could not create QP " - "(peer:%s me:%s)", this->peerinfo.identifier, - this->myinfo.identifier); - gf_rdma_cm_handle_disconnect (this); - goto out; + if (this->name != NULL) { + GF_FREE(this->name); } - memset(&conn_param, 0, sizeof conn_param); - conn_param.responder_resources = 1; - conn_param.initiator_depth = 1; - conn_param.retry_count = options->attr_retry_cnt; - conn_param.rnr_retry_count = options->attr_rnr_retry; + GF_FREE(this); + } - ret = rdma_connect(peer->cm_id, &conn_param); - if (ret != 0) { - gf_msg (this->name, GF_LOG_WARNING, errno, - RDMA_MSG_CONNECT_FAILED, - "rdma_connect failed"); - gf_rdma_cm_handle_disconnect (this); - goto out; - } + return new; +} - gf_msg_trace (this->name, 0, "route resolved (me:%s peer:%s)", - this->myinfo.identifier, this->peerinfo.identifier); +static int +gf_rdma_cm_handle_connect_request(struct rdma_cm_event *event) +{ + int ret = -1; + rpc_transport_t *this = NULL, *listener = NULL; + struct rdma_cm_id *child_cm_id = NULL, *listener_cm_id = NULL; + struct rdma_conn_param conn_param = { + 0, + }; + gf_rdma_private_t *priv = NULL; + gf_rdma_options_t *options = NULL; + + child_cm_id = event->id; + listener_cm_id = event->listen_id; + + listener = listener_cm_id->context; + priv = listener->private; + options = &priv->options; + + this = gf_rdma_transport_new(listener, child_cm_id); + if (this == NULL) { + gf_msg(listener->name, GF_LOG_WARNING, 0, + RDMA_MSG_CREAT_INC_TRANS_FAILED, + "could not create " + "a transport for incoming connection" + " (me.name:%s me.identifier:%s)", + listener->name, listener->myinfo.identifier); + rdma_destroy_id(child_cm_id); + goto out; + } + + gf_msg_trace(listener->name, 0, + "got a connect request (me:%s peer:" + "%s)", + listener->myinfo.identifier, this->peerinfo.identifier); + + ret = gf_rdma_create_qp(this); + if (ret < 0) { + gf_msg(listener->name, GF_LOG_WARNING, 0, RDMA_MSG_CREAT_QP_FAILED, + "could not create QP " + "(peer:%s me:%s)", + this->peerinfo.identifier, this->myinfo.identifier); + gf_rdma_cm_handle_disconnect(this); + goto out; + } + + conn_param.responder_resources = 1; + conn_param.initiator_depth = 1; + conn_param.retry_count = options->attr_retry_cnt; + conn_param.rnr_retry_count = options->attr_rnr_retry; + + ret = rdma_accept(child_cm_id, &conn_param); + if (ret < 0) { + gf_msg(listener->name, GF_LOG_WARNING, errno, RDMA_MSG_ACCEPT_FAILED, + "rdma_accept failed peer:%s " + "me:%s", + this->peerinfo.identifier, this->myinfo.identifier); + gf_rdma_cm_handle_disconnect(this); + goto out; + } + gf_rdma_cm_handle_connect_init(event); + ret = 0; - ret = 0; out: - return ret; + return ret; } +static int +gf_rdma_cm_handle_route_resolved(struct rdma_cm_event *event) +{ + struct rdma_conn_param conn_param = { + 0, + }; + int ret = 0; + rpc_transport_t *this = NULL; + gf_rdma_private_t *priv = NULL; + gf_rdma_peer_t *peer = NULL; + gf_rdma_options_t *options = NULL; + + if (event == NULL) { + goto out; + } + + this = event->id->context; + + priv = this->private; + peer = &priv->peer; + options = &priv->options; + + ret = gf_rdma_create_qp(this); + if (ret != 0) { + gf_msg(this->name, GF_LOG_WARNING, 0, RDMA_MSG_CREAT_QP_FAILED, + "could not create QP " + "(peer:%s me:%s)", + this->peerinfo.identifier, this->myinfo.identifier); + gf_rdma_cm_handle_disconnect(this); + goto out; + } + + memset(&conn_param, 0, sizeof conn_param); + conn_param.responder_resources = 1; + conn_param.initiator_depth = 1; + conn_param.retry_count = options->attr_retry_cnt; + conn_param.rnr_retry_count = options->attr_rnr_retry; + + ret = rdma_connect(peer->cm_id, &conn_param); + if (ret != 0) { + gf_msg(this->name, GF_LOG_WARNING, errno, RDMA_MSG_CONNECT_FAILED, + "rdma_connect failed"); + gf_rdma_cm_handle_disconnect(this); + goto out; + } + + gf_msg_trace(this->name, 0, "route resolved (me:%s peer:%s)", + this->myinfo.identifier, this->peerinfo.identifier); + + ret = 0; +out: + return ret; +} static int -gf_rdma_cm_handle_addr_resolved (struct rdma_cm_event *event) +gf_rdma_cm_handle_addr_resolved(struct rdma_cm_event *event) { - rpc_transport_t *this = NULL; - gf_rdma_peer_t *peer = NULL; - gf_rdma_private_t *priv = NULL; - int ret = 0; + rpc_transport_t *this = NULL; + gf_rdma_peer_t *peer = NULL; + gf_rdma_private_t *priv = NULL; + int ret = 0; - this = event->id->context; + this = event->id->context; - priv = this->private; - peer = &priv->peer; + priv = this->private; + peer = &priv->peer; - GF_ASSERT (peer->cm_id == event->id); + GF_ASSERT(peer->cm_id == event->id); - this->myinfo.sockaddr_len = sizeof (peer->cm_id->route.addr.src_addr); - memcpy (&this->myinfo.sockaddr, &peer->cm_id->route.addr.src_addr, - this->myinfo.sockaddr_len); + this->myinfo.sockaddr_len = sizeof(peer->cm_id->route.addr.src_addr); + memcpy(&this->myinfo.sockaddr, &peer->cm_id->route.addr.src_addr, + this->myinfo.sockaddr_len); - this->peerinfo.sockaddr_len = sizeof (peer->cm_id->route.addr.dst_addr); - memcpy (&this->peerinfo.sockaddr, &peer->cm_id->route.addr.dst_addr, - this->peerinfo.sockaddr_len); + this->peerinfo.sockaddr_len = sizeof(peer->cm_id->route.addr.dst_addr); + memcpy(&this->peerinfo.sockaddr, &peer->cm_id->route.addr.dst_addr, + this->peerinfo.sockaddr_len); - gf_rdma_get_transport_identifiers (this); + gf_rdma_get_transport_identifiers(this); - ret = rdma_resolve_route(peer->cm_id, 2000); - if (ret != 0) { - gf_msg (this->name, GF_LOG_WARNING, errno, - RDMA_MSG_ROUTE_RESOLVE_FAILED, "rdma_resolve_route " - "failed (me:%s peer:%s)", - this->myinfo.identifier, this->peerinfo.identifier); - gf_rdma_cm_handle_disconnect (this); - return ret; - } + ret = rdma_resolve_route(peer->cm_id, 2000); + if (ret != 0) { + gf_msg(this->name, GF_LOG_WARNING, errno, RDMA_MSG_ROUTE_RESOLVE_FAILED, + "rdma_resolve_route " + "failed (me:%s peer:%s)", + this->myinfo.identifier, this->peerinfo.identifier); + gf_rdma_cm_handle_disconnect(this); + return ret; + } - gf_msg_trace (this->name, 0, "Address resolved (me:%s peer:%s)", - this->myinfo.identifier, this->peerinfo.identifier); + gf_msg_trace(this->name, 0, "Address resolved (me:%s peer:%s)", + this->myinfo.identifier, this->peerinfo.identifier); - return ret; + return ret; } - static void -gf_rdma_cm_handle_disconnect (rpc_transport_t *this) +gf_rdma_cm_handle_disconnect(rpc_transport_t *this) { - gf_rdma_private_t *priv = NULL; - char need_unref = 0; + gf_rdma_private_t *priv = NULL; + char need_unref = 0; - priv = this->private; - gf_msg_debug (this->name, 0, "peer disconnected, cleaning up"); + priv = this->private; + gf_msg_debug(this->name, 0, "peer disconnected, cleaning up"); - pthread_mutex_lock (&priv->write_mutex); - { - if (priv->peer.cm_id != NULL) { - need_unref = 1; - priv->connected = 0; - } - - __gf_rdma_teardown (this); + pthread_mutex_lock(&priv->write_mutex); + { + if (priv->peer.cm_id != NULL) { + need_unref = 1; + priv->connected = 0; } - pthread_mutex_unlock (&priv->write_mutex); - rpc_transport_notify (this, RPC_TRANSPORT_DISCONNECT, this); + __gf_rdma_teardown(this); + } + pthread_mutex_unlock(&priv->write_mutex); - if (need_unref) - rpc_transport_unref (this); + rpc_transport_notify(this, RPC_TRANSPORT_DISCONNECT, this); + if (need_unref) + rpc_transport_unref(this); } - static int -gf_rdma_cm_handle_connect_init (struct rdma_cm_event *event) +gf_rdma_cm_handle_connect_init(struct rdma_cm_event *event) { - rpc_transport_t *this = NULL; - gf_rdma_private_t *priv = NULL; - struct rdma_cm_id *cm_id = NULL; - int ret = 0; - - cm_id = event->id; - this = cm_id->context; - priv = this->private; - - if (priv->connected == 1) { - gf_msg_trace (this->name, 0, "received event " - "RDMA_CM_EVENT_ESTABLISHED (me:%s peer:%s)", - this->myinfo.identifier, - this->peerinfo.identifier); - return ret; - } + rpc_transport_t *this = NULL; + gf_rdma_private_t *priv = NULL; + struct rdma_cm_id *cm_id = NULL; + int ret = 0; + + cm_id = event->id; + this = cm_id->context; + priv = this->private; + + if (priv->connected == 1) { + gf_msg_trace(this->name, 0, + "received event " + "RDMA_CM_EVENT_ESTABLISHED (me:%s peer:%s)", + this->myinfo.identifier, this->peerinfo.identifier); + return ret; + } - priv->connected = 1; + priv->connected = 1; - pthread_mutex_lock (&priv->write_mutex); - { - priv->peer.quota = 1; - priv->peer.quota_set = 0; - } - pthread_mutex_unlock (&priv->write_mutex); - - if (priv->entity == GF_RDMA_CLIENT) { - gf_msg_trace (this->name, 0, "received event " - "RDMA_CM_EVENT_ESTABLISHED (me:%s peer:%s)", - this->myinfo.identifier, - this->peerinfo.identifier); - ret = rpc_transport_notify (this, RPC_TRANSPORT_CONNECT, this); - - } else if (priv->entity == GF_RDMA_SERVER) { - ret = rpc_transport_notify (priv->listener, - RPC_TRANSPORT_ACCEPT, this); - } + pthread_mutex_lock(&priv->write_mutex); + { + priv->peer.quota = 1; + priv->peer.quota_set = 0; + } + pthread_mutex_unlock(&priv->write_mutex); - if (ret < 0) { - gf_rdma_disconnect (this, _gf_false); - } + if (priv->entity == GF_RDMA_CLIENT) { + gf_msg_trace(this->name, 0, + "received event " + "RDMA_CM_EVENT_ESTABLISHED (me:%s peer:%s)", + this->myinfo.identifier, this->peerinfo.identifier); + ret = rpc_transport_notify(this, RPC_TRANSPORT_CONNECT, this); - return ret; -} + } else if (priv->entity == GF_RDMA_SERVER) { + ret = rpc_transport_notify(priv->listener, RPC_TRANSPORT_ACCEPT, this); + } + + if (ret < 0) { + gf_rdma_disconnect(this, _gf_false); + } + return ret; +} static int -gf_rdma_cm_handle_event_error (rpc_transport_t *this) +gf_rdma_cm_handle_event_error(rpc_transport_t *this) { - gf_rdma_private_t *priv = NULL; + gf_rdma_private_t *priv = NULL; - priv = this->private; + priv = this->private; - if (priv->entity != GF_RDMA_SERVER_LISTENER) { - gf_rdma_cm_handle_disconnect (this); - } + if (priv->entity != GF_RDMA_SERVER_LISTENER) { + gf_rdma_cm_handle_disconnect(this); + } - return 0; + return 0; } - static int -gf_rdma_cm_handle_device_removal (struct rdma_cm_event *event) +gf_rdma_cm_handle_device_removal(struct rdma_cm_event *event) { - return 0; + return 0; } - static void * -gf_rdma_cm_event_handler (void *data) +gf_rdma_cm_event_handler(void *data) { - struct rdma_cm_event *event = NULL; - int ret = 0; - rpc_transport_t *this = NULL; - struct rdma_event_channel *event_channel = NULL; - - event_channel = data; - - while (1) { - ret = rdma_get_cm_event (event_channel, &event); - if (ret != 0) { - gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, errno, - RDMA_MSG_CM_EVENT_FAILED, - "rdma_cm_get_event failed"); - break; - } + struct rdma_cm_event *event = NULL; + int ret = 0; + rpc_transport_t *this = NULL; + struct rdma_event_channel *event_channel = NULL; - switch (event->event) { - case RDMA_CM_EVENT_ADDR_RESOLVED: - gf_rdma_cm_handle_addr_resolved (event); - break; + event_channel = data; - case RDMA_CM_EVENT_ROUTE_RESOLVED: - gf_rdma_cm_handle_route_resolved (event); - break; + while (1) { + ret = rdma_get_cm_event(event_channel, &event); + if (ret != 0) { + gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, errno, + RDMA_MSG_CM_EVENT_FAILED, "rdma_cm_get_event failed"); + break; + } - case RDMA_CM_EVENT_CONNECT_REQUEST: - gf_rdma_cm_handle_connect_request (event); - break; + switch (event->event) { + case RDMA_CM_EVENT_ADDR_RESOLVED: + gf_rdma_cm_handle_addr_resolved(event); + break; - case RDMA_CM_EVENT_ESTABLISHED: - gf_rdma_cm_handle_connect_init (event); - break; + case RDMA_CM_EVENT_ROUTE_RESOLVED: + gf_rdma_cm_handle_route_resolved(event); + break; - case RDMA_CM_EVENT_ADDR_ERROR: - case RDMA_CM_EVENT_ROUTE_ERROR: - case RDMA_CM_EVENT_CONNECT_ERROR: - case RDMA_CM_EVENT_UNREACHABLE: - case RDMA_CM_EVENT_REJECTED: - this = event->id->context; - - gf_msg (this->name, GF_LOG_WARNING, 0, - RDMA_MSG_CM_EVENT_FAILED, "cma event %s, " - "error %d (me:%s peer:%s)\n", - rdma_event_str(event->event), event->status, - this->myinfo.identifier, - this->peerinfo.identifier); - - rdma_ack_cm_event (event); - event = NULL; - - gf_rdma_cm_handle_event_error (this); - continue; - - case RDMA_CM_EVENT_DISCONNECTED: - this = event->id->context; - - gf_msg_debug (this->name, 0, "received disconnect " - "(me:%s peer:%s)\n", - this->myinfo.identifier, - this->peerinfo.identifier); - - rdma_ack_cm_event (event); - event = NULL; - - gf_rdma_cm_handle_disconnect (this); - continue; - - case RDMA_CM_EVENT_DEVICE_REMOVAL: - gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, - RDMA_MSG_CM_EVENT_FAILED, "device " - "removed"); - gf_rdma_cm_handle_device_removal (event); - break; + case RDMA_CM_EVENT_CONNECT_REQUEST: + gf_rdma_cm_handle_connect_request(event); + break; - default: - gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, - RDMA_MSG_CM_EVENT_FAILED, - "unhandled event: %s, ignoring", - rdma_event_str(event->event)); - break; - } + case RDMA_CM_EVENT_ESTABLISHED: + gf_rdma_cm_handle_connect_init(event); + break; - rdma_ack_cm_event (event); + case RDMA_CM_EVENT_ADDR_ERROR: + case RDMA_CM_EVENT_ROUTE_ERROR: + case RDMA_CM_EVENT_CONNECT_ERROR: + case RDMA_CM_EVENT_UNREACHABLE: + case RDMA_CM_EVENT_REJECTED: + this = event->id->context; + + gf_msg(this->name, GF_LOG_WARNING, 0, RDMA_MSG_CM_EVENT_FAILED, + "cma event %s, " + "error %d (me:%s peer:%s)\n", + rdma_event_str(event->event), event->status, + this->myinfo.identifier, this->peerinfo.identifier); + + rdma_ack_cm_event(event); + event = NULL; + + gf_rdma_cm_handle_event_error(this); + continue; + + case RDMA_CM_EVENT_DISCONNECTED: + this = event->id->context; + + gf_msg_debug(this->name, 0, + "received disconnect " + "(me:%s peer:%s)\n", + this->myinfo.identifier, + this->peerinfo.identifier); + + rdma_ack_cm_event(event); + event = NULL; + + gf_rdma_cm_handle_disconnect(this); + continue; + + case RDMA_CM_EVENT_DEVICE_REMOVAL: + gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, + RDMA_MSG_CM_EVENT_FAILED, + "device " + "removed"); + gf_rdma_cm_handle_device_removal(event); + break; + + default: + gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, + RDMA_MSG_CM_EVENT_FAILED, + "unhandled event: %s, ignoring", + rdma_event_str(event->event)); + break; } - return NULL; -} + rdma_ack_cm_event(event); + } + return NULL; +} static int32_t -gf_rdma_post_send (struct ibv_qp *qp, gf_rdma_post_t *post, int32_t len) +gf_rdma_post_send(struct ibv_qp *qp, gf_rdma_post_t *post, int32_t len) { - struct ibv_sge list = { - .addr = (unsigned long) post->buf, - .length = len, - .lkey = post->mr->lkey - }; - - struct ibv_send_wr wr = { - .wr_id = (unsigned long) post, - .sg_list = &list, - .num_sge = 1, - .opcode = IBV_WR_SEND, - .send_flags = IBV_SEND_SIGNALED, - }, *bad_wr; - - if (!qp) - return EINVAL; - - return ibv_post_send (qp, &wr, &bad_wr); + struct ibv_sge list = {.addr = (unsigned long)post->buf, + .length = len, + .lkey = post->mr->lkey}; + + struct ibv_send_wr wr = + { + .wr_id = (unsigned long)post, + .sg_list = &list, + .num_sge = 1, + .opcode = IBV_WR_SEND, + .send_flags = IBV_SEND_SIGNALED, + }, + *bad_wr; + + if (!qp) + return EINVAL; + + return ibv_post_send(qp, &wr, &bad_wr); } int @@ -1388,1945 +1347,1853 @@ __gf_rdma_encode_error(gf_rdma_peer_t *peer, gf_rdma_reply_info_t *reply_info, struct iovec *rpchdr, gf_rdma_header_t *hdr, gf_rdma_errcode_t err) { - struct rpc_msg *rpc_msg = NULL; - - if (reply_info != NULL) { - hdr->rm_xid = hton32(reply_info->rm_xid); - } else { - rpc_msg = rpchdr[0].iov_base; /* assume rpchdr contains - * only one vector. - * (which is true) - */ - hdr->rm_xid = rpc_msg->rm_xid; - } - - hdr->rm_vers = hton32(GF_RDMA_VERSION); - hdr->rm_credit = hton32(peer->send_count); - hdr->rm_type = hton32(GF_RDMA_ERROR); - hdr->rm_body.rm_error.rm_type = hton32(err); - if (err == ERR_VERS) { - hdr->rm_body.rm_error.rm_version.gf_rdma_vers_low - = hton32(GF_RDMA_VERSION); - hdr->rm_body.rm_error.rm_version.gf_rdma_vers_high - = hton32(GF_RDMA_VERSION); - } - - return sizeof (*hdr); + struct rpc_msg *rpc_msg = NULL; + + if (reply_info != NULL) { + hdr->rm_xid = hton32(reply_info->rm_xid); + } else { + rpc_msg = rpchdr[0].iov_base; /* assume rpchdr contains + * only one vector. + * (which is true) + */ + hdr->rm_xid = rpc_msg->rm_xid; + } + + hdr->rm_vers = hton32(GF_RDMA_VERSION); + hdr->rm_credit = hton32(peer->send_count); + hdr->rm_type = hton32(GF_RDMA_ERROR); + hdr->rm_body.rm_error.rm_type = hton32(err); + if (err == ERR_VERS) { + hdr->rm_body.rm_error.rm_version.gf_rdma_vers_low = hton32( + GF_RDMA_VERSION); + hdr->rm_body.rm_error.rm_version.gf_rdma_vers_high = hton32( + GF_RDMA_VERSION); + } + + return sizeof(*hdr); } - int32_t -__gf_rdma_send_error (gf_rdma_peer_t *peer, gf_rdma_ioq_t *entry, - gf_rdma_post_t *post, gf_rdma_reply_info_t *reply_info, - gf_rdma_errcode_t err) +__gf_rdma_send_error(gf_rdma_peer_t *peer, gf_rdma_ioq_t *entry, + gf_rdma_post_t *post, gf_rdma_reply_info_t *reply_info, + gf_rdma_errcode_t err) { - int32_t ret = -1, len = 0; - - len = __gf_rdma_encode_error (peer, reply_info, entry->rpchdr, - (gf_rdma_header_t *)post->buf, err); - if (len == -1) { - gf_msg (GF_RDMA_LOG_NAME, GF_LOG_ERROR, 0, - RDMA_MSG_ENCODE_ERROR, "encode error returned -1"); - goto out; - } - - gf_rdma_post_ref (post); - - ret = gf_rdma_post_send (peer->qp, post, len); - if (!ret) { - ret = len; - } else { - gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, - RDMA_MSG_POST_SEND_FAILED, - "gf_rdma_post_send (to %s) failed with ret = %d (%s)", - peer->trans->peerinfo.identifier, ret, - (ret > 0) ? strerror (ret) : ""); - gf_rdma_post_unref (post); - __gf_rdma_disconnect (peer->trans); - ret = -1; - } + int32_t ret = -1, len = 0; + + len = __gf_rdma_encode_error(peer, reply_info, entry->rpchdr, + (gf_rdma_header_t *)post->buf, err); + if (len == -1) { + gf_msg(GF_RDMA_LOG_NAME, GF_LOG_ERROR, 0, RDMA_MSG_ENCODE_ERROR, + "encode error returned -1"); + goto out; + } + + gf_rdma_post_ref(post); + + ret = gf_rdma_post_send(peer->qp, post, len); + if (!ret) { + ret = len; + } else { + gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, RDMA_MSG_POST_SEND_FAILED, + "gf_rdma_post_send (to %s) failed with ret = %d (%s)", + peer->trans->peerinfo.identifier, ret, + (ret > 0) ? strerror(ret) : ""); + gf_rdma_post_unref(post); + __gf_rdma_disconnect(peer->trans); + ret = -1; + } out: - return ret; + return ret; } - int32_t -__gf_rdma_create_read_chunks_from_vector (gf_rdma_peer_t *peer, - gf_rdma_read_chunk_t **readch_ptr, - int32_t *pos, struct iovec *vector, - int count, - gf_rdma_request_context_t *request_ctx) +__gf_rdma_create_read_chunks_from_vector(gf_rdma_peer_t *peer, + gf_rdma_read_chunk_t **readch_ptr, + int32_t *pos, struct iovec *vector, + int count, + gf_rdma_request_context_t *request_ctx) { - int i = 0; - gf_rdma_private_t *priv = NULL; - gf_rdma_device_t *device = NULL; - struct ibv_mr *mr = NULL; - gf_rdma_read_chunk_t *readch = NULL; - int32_t ret = -1; - - GF_VALIDATE_OR_GOTO (GF_RDMA_LOG_NAME, peer, out); - GF_VALIDATE_OR_GOTO (GF_RDMA_LOG_NAME, readch_ptr, out); - GF_VALIDATE_OR_GOTO (GF_RDMA_LOG_NAME, *readch_ptr, out); - GF_VALIDATE_OR_GOTO (GF_RDMA_LOG_NAME, request_ctx, out); - GF_VALIDATE_OR_GOTO (GF_RDMA_LOG_NAME, vector, out); - - priv = peer->trans->private; - device = priv->device; - readch = *readch_ptr; - - for (i = 0; i < count; i++) { - readch->rc_discrim = hton32 (1); - readch->rc_position = hton32 (*pos); - - mr = gf_rdma_get_pre_registred_mr(peer->trans, - (void *)vector[i].iov_base, vector[i].iov_len); - if (!mr) { - mr = ibv_reg_mr (device->pd, vector[i].iov_base, - vector[i].iov_len, - IBV_ACCESS_REMOTE_READ); - } - if (!mr) { - gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, errno, - RDMA_MSG_MR_ALOC_FAILED, - "memory registration failed (peer:%s)", - peer->trans->peerinfo.identifier); - goto out; - } - - request_ctx->mr[request_ctx->mr_count++] = mr; - - readch->rc_target.rs_handle = hton32 (mr->rkey); - readch->rc_target.rs_length - = hton32 (vector[i].iov_len); - readch->rc_target.rs_offset - = hton64 ((uint64_t)(unsigned long)vector[i].iov_base); - - *pos = *pos + vector[i].iov_len; - readch++; - } - - *readch_ptr = readch; - - ret = 0; + int i = 0; + gf_rdma_private_t *priv = NULL; + gf_rdma_device_t *device = NULL; + struct ibv_mr *mr = NULL; + gf_rdma_read_chunk_t *readch = NULL; + int32_t ret = -1; + + GF_VALIDATE_OR_GOTO(GF_RDMA_LOG_NAME, peer, out); + GF_VALIDATE_OR_GOTO(GF_RDMA_LOG_NAME, readch_ptr, out); + GF_VALIDATE_OR_GOTO(GF_RDMA_LOG_NAME, *readch_ptr, out); + GF_VALIDATE_OR_GOTO(GF_RDMA_LOG_NAME, request_ctx, out); + GF_VALIDATE_OR_GOTO(GF_RDMA_LOG_NAME, vector, out); + + priv = peer->trans->private; + device = priv->device; + readch = *readch_ptr; + + for (i = 0; i < count; i++) { + readch->rc_discrim = hton32(1); + readch->rc_position = hton32(*pos); + + mr = gf_rdma_get_pre_registred_mr( + peer->trans, (void *)vector[i].iov_base, vector[i].iov_len); + if (!mr) { + mr = ibv_reg_mr(device->pd, vector[i].iov_base, vector[i].iov_len, + IBV_ACCESS_REMOTE_READ); + } + if (!mr) { + gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, errno, + RDMA_MSG_MR_ALOC_FAILED, + "memory registration failed (peer:%s)", + peer->trans->peerinfo.identifier); + goto out; + } + + request_ctx->mr[request_ctx->mr_count++] = mr; + + readch->rc_target.rs_handle = hton32(mr->rkey); + readch->rc_target.rs_length = hton32(vector[i].iov_len); + readch->rc_target.rs_offset = hton64( + (uint64_t)(unsigned long)vector[i].iov_base); + + *pos = *pos + vector[i].iov_len; + readch++; + } + + *readch_ptr = readch; + + ret = 0; out: - return ret; + return ret; } - int32_t -__gf_rdma_create_read_chunks (gf_rdma_peer_t *peer, gf_rdma_ioq_t *entry, - gf_rdma_chunktype_t type, uint32_t **ptr, - gf_rdma_request_context_t *request_ctx) +__gf_rdma_create_read_chunks(gf_rdma_peer_t *peer, gf_rdma_ioq_t *entry, + gf_rdma_chunktype_t type, uint32_t **ptr, + gf_rdma_request_context_t *request_ctx) { - int32_t ret = -1; - int pos = 0; - - GF_VALIDATE_OR_GOTO (GF_RDMA_LOG_NAME, peer, out); - GF_VALIDATE_OR_GOTO (GF_RDMA_LOG_NAME, entry, out); - GF_VALIDATE_OR_GOTO (GF_RDMA_LOG_NAME, ptr, out); - GF_VALIDATE_OR_GOTO (GF_RDMA_LOG_NAME, *ptr, out); - GF_VALIDATE_OR_GOTO (GF_RDMA_LOG_NAME, request_ctx, out); - - request_ctx->iobref = iobref_ref (entry->iobref); - - if (type == gf_rdma_areadch) { - pos = 0; - ret = __gf_rdma_create_read_chunks_from_vector (peer, - (gf_rdma_read_chunk_t **)ptr, - &pos, - entry->rpchdr, - entry->rpchdr_count, - request_ctx); - if (ret == -1) { - gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, - RDMA_MSG_READ_CHUNK_VECTOR_FAILED, - "cannot create read chunks from vector " - "entry->rpchdr"); - goto out; - } + int32_t ret = -1; + int pos = 0; + + GF_VALIDATE_OR_GOTO(GF_RDMA_LOG_NAME, peer, out); + GF_VALIDATE_OR_GOTO(GF_RDMA_LOG_NAME, entry, out); + GF_VALIDATE_OR_GOTO(GF_RDMA_LOG_NAME, ptr, out); + GF_VALIDATE_OR_GOTO(GF_RDMA_LOG_NAME, *ptr, out); + GF_VALIDATE_OR_GOTO(GF_RDMA_LOG_NAME, request_ctx, out); + + request_ctx->iobref = iobref_ref(entry->iobref); + + if (type == gf_rdma_areadch) { + pos = 0; + ret = __gf_rdma_create_read_chunks_from_vector( + peer, (gf_rdma_read_chunk_t **)ptr, &pos, entry->rpchdr, + entry->rpchdr_count, request_ctx); + if (ret == -1) { + gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, + RDMA_MSG_READ_CHUNK_VECTOR_FAILED, + "cannot create read chunks from vector " + "entry->rpchdr"); + goto out; + } - ret = __gf_rdma_create_read_chunks_from_vector (peer, - (gf_rdma_read_chunk_t **)ptr, - &pos, - entry->proghdr, - entry->proghdr_count, - request_ctx); - if (ret == -1) { - gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, - RDMA_MSG_READ_CHUNK_VECTOR_FAILED, - "cannot create read chunks from vector " - "entry->proghdr"); - } + ret = __gf_rdma_create_read_chunks_from_vector( + peer, (gf_rdma_read_chunk_t **)ptr, &pos, entry->proghdr, + entry->proghdr_count, request_ctx); + if (ret == -1) { + gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, + RDMA_MSG_READ_CHUNK_VECTOR_FAILED, + "cannot create read chunks from vector " + "entry->proghdr"); + } - if (entry->prog_payload_count != 0) { - ret = __gf_rdma_create_read_chunks_from_vector (peer, - (gf_rdma_read_chunk_t **)ptr, - &pos, - entry->prog_payload, - entry->prog_payload_count, - request_ctx); - if (ret == -1) { - gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, - RDMA_MSG_READ_CHUNK_VECTOR_FAILED, - "cannot create read chunks from vector" - " entry->prog_payload"); - } - } - } else { - pos = iov_length (entry->rpchdr, entry->rpchdr_count); - ret = __gf_rdma_create_read_chunks_from_vector (peer, - (gf_rdma_read_chunk_t **)ptr, - &pos, - entry->prog_payload, - entry->prog_payload_count, - request_ctx); - if (ret == -1) { - gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, - RDMA_MSG_READ_CHUNK_VECTOR_FAILED, - "cannot create read chunks from vector " - "entry->prog_payload"); - } + if (entry->prog_payload_count != 0) { + ret = __gf_rdma_create_read_chunks_from_vector( + peer, (gf_rdma_read_chunk_t **)ptr, &pos, entry->prog_payload, + entry->prog_payload_count, request_ctx); + if (ret == -1) { + gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, + RDMA_MSG_READ_CHUNK_VECTOR_FAILED, + "cannot create read chunks from vector" + " entry->prog_payload"); + } + } + } else { + pos = iov_length(entry->rpchdr, entry->rpchdr_count); + ret = __gf_rdma_create_read_chunks_from_vector( + peer, (gf_rdma_read_chunk_t **)ptr, &pos, entry->prog_payload, + entry->prog_payload_count, request_ctx); + if (ret == -1) { + gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, + RDMA_MSG_READ_CHUNK_VECTOR_FAILED, + "cannot create read chunks from vector " + "entry->prog_payload"); } + } - /* terminate read-chunk list*/ - **ptr = 0; - *ptr = *ptr + 1; + /* terminate read-chunk list*/ + **ptr = 0; + *ptr = *ptr + 1; out: - return ret; + return ret; } - int32_t -__gf_rdma_create_write_chunks_from_vector (gf_rdma_peer_t *peer, - gf_rdma_write_chunk_t **writech_ptr, - struct iovec *vector, int count, - gf_rdma_request_context_t *request_ctx) +__gf_rdma_create_write_chunks_from_vector( + gf_rdma_peer_t *peer, gf_rdma_write_chunk_t **writech_ptr, + struct iovec *vector, int count, gf_rdma_request_context_t *request_ctx) { - int i = 0; - gf_rdma_private_t *priv = NULL; - gf_rdma_device_t *device = NULL; - struct ibv_mr *mr = NULL; - gf_rdma_write_chunk_t *writech = NULL; - int32_t ret = -1; + int i = 0; + gf_rdma_private_t *priv = NULL; + gf_rdma_device_t *device = NULL; + struct ibv_mr *mr = NULL; + gf_rdma_write_chunk_t *writech = NULL; + int32_t ret = -1; - GF_VALIDATE_OR_GOTO (GF_RDMA_LOG_NAME, peer, out); - GF_VALIDATE_OR_GOTO (GF_RDMA_LOG_NAME, writech_ptr, out); - GF_VALIDATE_OR_GOTO (GF_RDMA_LOG_NAME, *writech_ptr, out); - GF_VALIDATE_OR_GOTO (GF_RDMA_LOG_NAME, request_ctx, out); - GF_VALIDATE_OR_GOTO (GF_RDMA_LOG_NAME, vector, out); + GF_VALIDATE_OR_GOTO(GF_RDMA_LOG_NAME, peer, out); + GF_VALIDATE_OR_GOTO(GF_RDMA_LOG_NAME, writech_ptr, out); + GF_VALIDATE_OR_GOTO(GF_RDMA_LOG_NAME, *writech_ptr, out); + GF_VALIDATE_OR_GOTO(GF_RDMA_LOG_NAME, request_ctx, out); + GF_VALIDATE_OR_GOTO(GF_RDMA_LOG_NAME, vector, out); - writech = *writech_ptr; + writech = *writech_ptr; - priv = peer->trans->private; - device = priv->device; - - for (i = 0; i < count; i++) { + priv = peer->trans->private; + device = priv->device; - mr = gf_rdma_get_pre_registred_mr(peer->trans, - (void *)vector[i].iov_base, vector[i].iov_len); - if (!mr) { - mr = ibv_reg_mr (device->pd, vector[i].iov_base, - vector[i].iov_len, - IBV_ACCESS_REMOTE_WRITE - | IBV_ACCESS_LOCAL_WRITE); - } + for (i = 0; i < count; i++) { + mr = gf_rdma_get_pre_registred_mr( + peer->trans, (void *)vector[i].iov_base, vector[i].iov_len); + if (!mr) { + mr = ibv_reg_mr(device->pd, vector[i].iov_base, vector[i].iov_len, + IBV_ACCESS_REMOTE_WRITE | IBV_ACCESS_LOCAL_WRITE); + } - if (!mr) { - gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, errno, - RDMA_MSG_MR_ALOC_FAILED, "memory " - "registration failed (peer:%s)", - peer->trans->peerinfo.identifier); - goto out; - } + if (!mr) { + gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, errno, + RDMA_MSG_MR_ALOC_FAILED, + "memory " + "registration failed (peer:%s)", + peer->trans->peerinfo.identifier); + goto out; + } - request_ctx->mr[request_ctx->mr_count++] = mr; + request_ctx->mr[request_ctx->mr_count++] = mr; - writech->wc_target.rs_handle = hton32 (mr->rkey); - writech->wc_target.rs_length = hton32 (vector[i].iov_len); - writech->wc_target.rs_offset - = hton64 (((uint64_t)(unsigned long)vector[i].iov_base)); + writech->wc_target.rs_handle = hton32(mr->rkey); + writech->wc_target.rs_length = hton32(vector[i].iov_len); + writech->wc_target.rs_offset = hton64( + ((uint64_t)(unsigned long)vector[i].iov_base)); - writech++; - } + writech++; + } - *writech_ptr = writech; + *writech_ptr = writech; - ret = 0; + ret = 0; out: - return ret; + return ret; } - int32_t -__gf_rdma_create_write_chunks (gf_rdma_peer_t *peer, gf_rdma_ioq_t *entry, - gf_rdma_chunktype_t chunk_type, uint32_t **ptr, - gf_rdma_request_context_t *request_ctx) +__gf_rdma_create_write_chunks(gf_rdma_peer_t *peer, gf_rdma_ioq_t *entry, + gf_rdma_chunktype_t chunk_type, uint32_t **ptr, + gf_rdma_request_context_t *request_ctx) { - int32_t ret = -1; - gf_rdma_write_array_t *warray = NULL; - - GF_VALIDATE_OR_GOTO (GF_RDMA_LOG_NAME, peer, out); - GF_VALIDATE_OR_GOTO (GF_RDMA_LOG_NAME, ptr, out); - GF_VALIDATE_OR_GOTO (GF_RDMA_LOG_NAME, *ptr, out); - GF_VALIDATE_OR_GOTO (GF_RDMA_LOG_NAME, request_ctx, out); - GF_VALIDATE_OR_GOTO (GF_RDMA_LOG_NAME, entry, out); - - if ((chunk_type == gf_rdma_replych) - && ((entry->msg.request.rsphdr_count != 1) || - (entry->msg.request.rsphdr_vec[0].iov_base == NULL))) { - gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, - RDMA_MSG_BUFFER_ERROR, - (entry->msg.request.rsphdr_count == 1) - ? "chunktype specified as reply chunk but the vector " - "specifying the buffer to be used for holding reply" - " header is not correct" : - "chunktype specified as reply chunk, but more than one " - "buffer provided for holding reply"); - goto out; + int32_t ret = -1; + gf_rdma_write_array_t *warray = NULL; + + GF_VALIDATE_OR_GOTO(GF_RDMA_LOG_NAME, peer, out); + GF_VALIDATE_OR_GOTO(GF_RDMA_LOG_NAME, ptr, out); + GF_VALIDATE_OR_GOTO(GF_RDMA_LOG_NAME, *ptr, out); + GF_VALIDATE_OR_GOTO(GF_RDMA_LOG_NAME, request_ctx, out); + GF_VALIDATE_OR_GOTO(GF_RDMA_LOG_NAME, entry, out); + + if ((chunk_type == gf_rdma_replych) && + ((entry->msg.request.rsphdr_count != 1) || + (entry->msg.request.rsphdr_vec[0].iov_base == NULL))) { + gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, RDMA_MSG_BUFFER_ERROR, + (entry->msg.request.rsphdr_count == 1) + ? "chunktype specified as reply chunk but the vector " + "specifying the buffer to be used for holding reply" + " header is not correct" + : "chunktype specified as reply chunk, but more than one " + "buffer provided for holding reply"); + goto out; + } + + /* + if ((chunk_type == gf_rdma_writech) + && ((entry->msg.request.rsphdr_count == 0) + || (entry->msg.request.rsphdr_vec[0].iov_base == NULL))) { + gf_msg_debug (GF_RDMA_LOG_NAME, 0, + "vector specifying buffer to hold the program's reply " + "header should also be provided when buffers are " + "provided for holding the program's payload in reply"); + goto out; + } + */ + + if (chunk_type == gf_rdma_writech) { + warray = (gf_rdma_write_array_t *)*ptr; + warray->wc_discrim = hton32(1); + warray->wc_nchunks = hton32(entry->msg.request.rsp_payload_count); + + *ptr = (uint32_t *)&warray->wc_array[0]; + + ret = __gf_rdma_create_write_chunks_from_vector( + peer, (gf_rdma_write_chunk_t **)ptr, entry->msg.request.rsp_payload, + entry->msg.request.rsp_payload_count, request_ctx); + if (ret == -1) { + gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, + RDMA_MSG_WRITE_CHUNK_VECTOR_FAILED, + "cannot create write chunks from vector " + "entry->rpc_payload"); + goto out; } -/* - if ((chunk_type == gf_rdma_writech) - && ((entry->msg.request.rsphdr_count == 0) - || (entry->msg.request.rsphdr_vec[0].iov_base == NULL))) { - gf_msg_debug (GF_RDMA_LOG_NAME, 0, - "vector specifying buffer to hold the program's reply " - "header should also be provided when buffers are " - "provided for holding the program's payload in reply"); - goto out; - } -*/ - - if (chunk_type == gf_rdma_writech) { - warray = (gf_rdma_write_array_t *)*ptr; - warray->wc_discrim = hton32 (1); - warray->wc_nchunks - = hton32 (entry->msg.request.rsp_payload_count); - - *ptr = (uint32_t *)&warray->wc_array[0]; - - ret = __gf_rdma_create_write_chunks_from_vector (peer, - (gf_rdma_write_chunk_t **)ptr, - entry->msg.request.rsp_payload, - entry->msg.request.rsp_payload_count, - request_ctx); - if (ret == -1) { - gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, - RDMA_MSG_WRITE_CHUNK_VECTOR_FAILED, - "cannot create write chunks from vector " - "entry->rpc_payload"); - goto out; - } - - /* terminate write chunklist */ - **ptr = 0; - *ptr = *ptr + 1; - - /* no reply chunklist */ - **ptr = 0; - *ptr = *ptr + 1; - } else { - /* no write chunklist */ - **ptr = 0; - *ptr = *ptr + 1; + /* terminate write chunklist */ + **ptr = 0; + *ptr = *ptr + 1; - warray = (gf_rdma_write_array_t *)*ptr; - warray->wc_discrim = hton32 (1); - warray->wc_nchunks = hton32 (entry->msg.request.rsphdr_count); + /* no reply chunklist */ + **ptr = 0; + *ptr = *ptr + 1; + } else { + /* no write chunklist */ + **ptr = 0; + *ptr = *ptr + 1; - *ptr = (uint32_t *)&warray->wc_array[0]; + warray = (gf_rdma_write_array_t *)*ptr; + warray->wc_discrim = hton32(1); + warray->wc_nchunks = hton32(entry->msg.request.rsphdr_count); - ret = __gf_rdma_create_write_chunks_from_vector (peer, - (gf_rdma_write_chunk_t **)ptr, - entry->msg.request.rsphdr_vec, - entry->msg.request.rsphdr_count, - request_ctx); - if (ret == -1) { - gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, - RDMA_MSG_WRITE_CHUNK_VECTOR_FAILED, - "cannot create write chunks from vector " - "entry->rpchdr"); - goto out; - } + *ptr = (uint32_t *)&warray->wc_array[0]; - /* terminate reply chunklist */ - **ptr = 0; - *ptr = *ptr + 1; + ret = __gf_rdma_create_write_chunks_from_vector( + peer, (gf_rdma_write_chunk_t **)ptr, entry->msg.request.rsphdr_vec, + entry->msg.request.rsphdr_count, request_ctx); + if (ret == -1) { + gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, + RDMA_MSG_WRITE_CHUNK_VECTOR_FAILED, + "cannot create write chunks from vector " + "entry->rpchdr"); + goto out; } + /* terminate reply chunklist */ + **ptr = 0; + *ptr = *ptr + 1; + } + out: - return ret; + return ret; } - static void -__gf_rdma_deregister_mr (gf_rdma_device_t *device, - struct ibv_mr **mr, int count) +__gf_rdma_deregister_mr(gf_rdma_device_t *device, struct ibv_mr **mr, int count) { - gf_rdma_arena_mr *tmp = NULL; - gf_rdma_arena_mr *dummy = NULL; - int i = 0; - int found = 0; - - if (mr == NULL) { - goto out; - } - - for (i = 0; i < count; i++) { - found = 0; - pthread_mutex_lock (&device->all_mr_lock); - { - if (!list_empty(&device->all_mr)) { - list_for_each_entry_safe (tmp, dummy, &device->all_mr, list) { - if (tmp->mr == mr[i]) { - found = 1; - break; - } - } - } + gf_rdma_arena_mr *tmp = NULL; + gf_rdma_arena_mr *dummy = NULL; + int i = 0; + int found = 0; + + if (mr == NULL) { + goto out; + } + + for (i = 0; i < count; i++) { + found = 0; + pthread_mutex_lock(&device->all_mr_lock); + { + if (!list_empty(&device->all_mr)) { + list_for_each_entry_safe(tmp, dummy, &device->all_mr, list) + { + if (tmp->mr == mr[i]) { + found = 1; + break; + } } - pthread_mutex_unlock (&device->all_mr_lock); - if (!found) - ibv_dereg_mr (mr[i]); - + } } + pthread_mutex_unlock(&device->all_mr_lock); + if (!found) + ibv_dereg_mr(mr[i]); + } out: - return; + return; } - static int32_t -__gf_rdma_quota_put (gf_rdma_peer_t *peer) +__gf_rdma_quota_put(gf_rdma_peer_t *peer) { - int32_t ret = 0; + int32_t ret = 0; - peer->quota++; - ret = peer->quota; + peer->quota++; + ret = peer->quota; - if (!list_empty (&peer->ioq)) { - ret = __gf_rdma_ioq_churn (peer); - } + if (!list_empty(&peer->ioq)) { + ret = __gf_rdma_ioq_churn(peer); + } - return ret; + return ret; } - static int32_t -gf_rdma_quota_put (gf_rdma_peer_t *peer) +gf_rdma_quota_put(gf_rdma_peer_t *peer) { - int32_t ret = 0; - gf_rdma_private_t *priv = NULL; + int32_t ret = 0; + gf_rdma_private_t *priv = NULL; - priv = peer->trans->private; - pthread_mutex_lock (&priv->write_mutex); - { - ret = __gf_rdma_quota_put (peer); - } - pthread_mutex_unlock (&priv->write_mutex); + priv = peer->trans->private; + pthread_mutex_lock(&priv->write_mutex); + { + ret = __gf_rdma_quota_put(peer); + } + pthread_mutex_unlock(&priv->write_mutex); - return ret; + return ret; } - /* to be called with priv->mutex held */ void -__gf_rdma_request_context_destroy (gf_rdma_request_context_t *context) +__gf_rdma_request_context_destroy(gf_rdma_request_context_t *context) { - gf_rdma_peer_t *peer = NULL; - gf_rdma_private_t *priv = NULL; - gf_rdma_device_t *device = NULL; - int32_t ret = 0; + gf_rdma_peer_t *peer = NULL; + gf_rdma_private_t *priv = NULL; + gf_rdma_device_t *device = NULL; + int32_t ret = 0; - if (context == NULL) { - goto out; - } - - peer = context->peer; + if (context == NULL) { + goto out; + } - priv = peer->trans->private; - device = priv->device; - __gf_rdma_deregister_mr (device, context->mr, context->mr_count); + peer = context->peer; + priv = peer->trans->private; + device = priv->device; + __gf_rdma_deregister_mr(device, context->mr, context->mr_count); - if (priv->connected) { - ret = __gf_rdma_quota_put (peer); - if (ret < 0) { - gf_msg_debug ("rdma", 0, "failed to send message"); - mem_put (context); - __gf_rdma_disconnect (peer->trans); - goto out; - } + if (priv->connected) { + ret = __gf_rdma_quota_put(peer); + if (ret < 0) { + gf_msg_debug("rdma", 0, "failed to send message"); + mem_put(context); + __gf_rdma_disconnect(peer->trans); + goto out; } + } - if (context->iobref != NULL) { - iobref_unref (context->iobref); - context->iobref = NULL; - } + if (context->iobref != NULL) { + iobref_unref(context->iobref); + context->iobref = NULL; + } - if (context->rsp_iobref != NULL) { - iobref_unref (context->rsp_iobref); - context->rsp_iobref = NULL; - } + if (context->rsp_iobref != NULL) { + iobref_unref(context->rsp_iobref); + context->rsp_iobref = NULL; + } - mem_put (context); + mem_put(context); out: - return; + return; } - void -gf_rdma_post_context_destroy (gf_rdma_device_t *device, - gf_rdma_post_context_t *ctx) +gf_rdma_post_context_destroy(gf_rdma_device_t *device, + gf_rdma_post_context_t *ctx) { - if (ctx == NULL) { - goto out; - } + if (ctx == NULL) { + goto out; + } - __gf_rdma_deregister_mr (device, ctx->mr, ctx->mr_count); + __gf_rdma_deregister_mr(device, ctx->mr, ctx->mr_count); - if (ctx->iobref != NULL) { - iobref_unref (ctx->iobref); - } + if (ctx->iobref != NULL) { + iobref_unref(ctx->iobref); + } - if (ctx->hdr_iobuf != NULL) { - iobuf_unref (ctx->hdr_iobuf); - } + if (ctx->hdr_iobuf != NULL) { + iobuf_unref(ctx->hdr_iobuf); + } - memset (ctx, 0, sizeof (*ctx)); + memset(ctx, 0, sizeof(*ctx)); out: - return; + return; } - int -gf_rdma_post_unref (gf_rdma_post_t *post) +gf_rdma_post_unref(gf_rdma_post_t *post) { - int refcount = -1; - - if (post == NULL) { - goto out; - } - - pthread_mutex_lock (&post->lock); - { - refcount = --post->refcount; - } - pthread_mutex_unlock (&post->lock); - - if (refcount == 0) { - gf_rdma_post_context_destroy (post->device, &post->ctx); - if (post->type == GF_RDMA_SEND_POST) { - gf_rdma_put_post (&post->device->sendq, post); - } else { - gf_rdma_post_recv (post->device->srq, post); - } + int refcount = -1; + + if (post == NULL) { + goto out; + } + + pthread_mutex_lock(&post->lock); + { + refcount = --post->refcount; + } + pthread_mutex_unlock(&post->lock); + + if (refcount == 0) { + gf_rdma_post_context_destroy(post->device, &post->ctx); + if (post->type == GF_RDMA_SEND_POST) { + gf_rdma_put_post(&post->device->sendq, post); + } else { + gf_rdma_post_recv(post->device->srq, post); } + } out: - return refcount; + return refcount; } - int -gf_rdma_post_get_refcount (gf_rdma_post_t *post) +gf_rdma_post_get_refcount(gf_rdma_post_t *post) { - int refcount = -1; + int refcount = -1; - if (post == NULL) { - goto out; - } + if (post == NULL) { + goto out; + } - pthread_mutex_lock (&post->lock); - { - refcount = post->refcount; - } - pthread_mutex_unlock (&post->lock); + pthread_mutex_lock(&post->lock); + { + refcount = post->refcount; + } + pthread_mutex_unlock(&post->lock); out: - return refcount; + return refcount; } gf_rdma_post_t * -gf_rdma_post_ref (gf_rdma_post_t *post) +gf_rdma_post_ref(gf_rdma_post_t *post) { - if (post == NULL) { - goto out; - } + if (post == NULL) { + goto out; + } - pthread_mutex_lock (&post->lock); - { - post->refcount++; - } - pthread_mutex_unlock (&post->lock); + pthread_mutex_lock(&post->lock); + { + post->refcount++; + } + pthread_mutex_unlock(&post->lock); out: - return post; + return post; } - int32_t -__gf_rdma_ioq_churn_request (gf_rdma_peer_t *peer, gf_rdma_ioq_t *entry, - gf_rdma_post_t *post) +__gf_rdma_ioq_churn_request(gf_rdma_peer_t *peer, gf_rdma_ioq_t *entry, + gf_rdma_post_t *post) { - gf_rdma_chunktype_t rtype = gf_rdma_noch; - gf_rdma_chunktype_t wtype = gf_rdma_noch; - uint64_t send_size = 0; - gf_rdma_header_t *hdr = NULL; - struct rpc_msg *rpc_msg = NULL; - uint32_t *chunkptr = NULL; - char *buf = NULL; - int32_t ret = 0; - gf_rdma_private_t *priv = NULL; - gf_rdma_device_t *device = NULL; - int chunk_count = 0; - gf_rdma_request_context_t *request_ctx = NULL; - uint32_t prog_payload_length = 0, len = 0; - struct rpc_req *rpc_req = NULL; - - GF_VALIDATE_OR_GOTO (GF_RDMA_LOG_NAME, peer, out); - GF_VALIDATE_OR_GOTO (GF_RDMA_LOG_NAME, entry, out); - GF_VALIDATE_OR_GOTO (GF_RDMA_LOG_NAME, post, out); - - if ((entry->msg.request.rsphdr_count != 0) - && (entry->msg.request.rsp_payload_count != 0)) { - ret = -1; - gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, - RDMA_MSG_WRITE_REPLY_CHUNCK_CONFLICT, - "both write-chunklist and reply-chunk cannot be " - "present"); - goto out; - } - - post->ctx.is_request = 1; - priv = peer->trans->private; - device = priv->device; - - hdr = (gf_rdma_header_t *)post->buf; - - send_size = iov_length (entry->rpchdr, entry->rpchdr_count) - + iov_length (entry->proghdr, entry->proghdr_count) - + GLUSTERFS_RDMA_MAX_HEADER_SIZE; - - if (entry->prog_payload_count != 0) { - prog_payload_length - = iov_length (entry->prog_payload, - entry->prog_payload_count); - } - - if (send_size > GLUSTERFS_RDMA_INLINE_THRESHOLD) { - rtype = gf_rdma_areadch; - } else if ((send_size + prog_payload_length) - < GLUSTERFS_RDMA_INLINE_THRESHOLD) { - rtype = gf_rdma_noch; - } else if (entry->prog_payload_count != 0) { - rtype = gf_rdma_readch; - } - - if (entry->msg.request.rsphdr_count != 0) { - wtype = gf_rdma_replych; - } else if (entry->msg.request.rsp_payload_count != 0) { - wtype = gf_rdma_writech; - } - - if (rtype == gf_rdma_readch) { - chunk_count += entry->prog_payload_count; - } else if (rtype == gf_rdma_areadch) { - chunk_count += entry->rpchdr_count; - chunk_count += entry->proghdr_count; - } - - if (wtype == gf_rdma_writech) { - chunk_count += entry->msg.request.rsp_payload_count; - } else if (wtype == gf_rdma_replych) { - chunk_count += entry->msg.request.rsphdr_count; - } - - if (chunk_count > GF_RDMA_MAX_SEGMENTS) { - ret = -1; - gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, - RDMA_MSG_CHUNK_COUNT_GREAT_MAX_SEGMENTS, - "chunk count(%d) exceeding maximum allowed RDMA " - "segment count(%d)", chunk_count, GF_RDMA_MAX_SEGMENTS); - goto out; - } - - if ((wtype != gf_rdma_noch) || (rtype != gf_rdma_noch)) { - request_ctx = mem_get (device->request_ctx_pool); - if (request_ctx == NULL) { - ret = -1; - goto out; - } - - memset (request_ctx, 0, sizeof (*request_ctx)); - - request_ctx->pool = device->request_ctx_pool; - request_ctx->peer = peer; - - entry->msg.request.rpc_req->conn_private = request_ctx; - - if (entry->msg.request.rsp_iobref != NULL) { - request_ctx->rsp_iobref - = iobref_ref (entry->msg.request.rsp_iobref); - } - } - - rpc_msg = (struct rpc_msg *) entry->rpchdr[0].iov_base; - - hdr->rm_xid = rpc_msg->rm_xid; /* no need of hton32(rpc_msg->rm_xid), - * since rpc_msg->rm_xid is already - * hton32ed value of actual xid - */ - hdr->rm_vers = hton32 (GF_RDMA_VERSION); - hdr->rm_credit = hton32 (peer->send_count); - if (rtype == gf_rdma_areadch) { - hdr->rm_type = hton32 (GF_RDMA_NOMSG); - } else { - hdr->rm_type = hton32 (GF_RDMA_MSG); - } - - chunkptr = &hdr->rm_body.rm_chunks[0]; - if (rtype != gf_rdma_noch) { - ret = __gf_rdma_create_read_chunks (peer, entry, rtype, - &chunkptr, - request_ctx); - if (ret != 0) { - gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, - RDMA_MSG_CREATE_READ_CHUNK_FAILED, - "creation of read chunks failed"); - goto out; - } - } else { - *chunkptr++ = 0; /* no read chunks */ - } - - if (wtype != gf_rdma_noch) { - ret = __gf_rdma_create_write_chunks (peer, entry, wtype, - &chunkptr, - request_ctx); - if (ret != 0) { - gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, - RDMA_MSG_CREATE_WRITE_REPLAY_FAILED, - "creation of write/reply chunk failed"); - goto out; - } - } else { - *chunkptr++ = 0; /* no write chunks */ - *chunkptr++ = 0; /* no reply chunk */ + gf_rdma_chunktype_t rtype = gf_rdma_noch; + gf_rdma_chunktype_t wtype = gf_rdma_noch; + uint64_t send_size = 0; + gf_rdma_header_t *hdr = NULL; + struct rpc_msg *rpc_msg = NULL; + uint32_t *chunkptr = NULL; + char *buf = NULL; + int32_t ret = 0; + gf_rdma_private_t *priv = NULL; + gf_rdma_device_t *device = NULL; + int chunk_count = 0; + gf_rdma_request_context_t *request_ctx = NULL; + uint32_t prog_payload_length = 0, len = 0; + struct rpc_req *rpc_req = NULL; + + GF_VALIDATE_OR_GOTO(GF_RDMA_LOG_NAME, peer, out); + GF_VALIDATE_OR_GOTO(GF_RDMA_LOG_NAME, entry, out); + GF_VALIDATE_OR_GOTO(GF_RDMA_LOG_NAME, post, out); + + if ((entry->msg.request.rsphdr_count != 0) && + (entry->msg.request.rsp_payload_count != 0)) { + ret = -1; + gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, + RDMA_MSG_WRITE_REPLY_CHUNCK_CONFLICT, + "both write-chunklist and reply-chunk cannot be " + "present"); + goto out; + } + + post->ctx.is_request = 1; + priv = peer->trans->private; + device = priv->device; + + hdr = (gf_rdma_header_t *)post->buf; + + send_size = iov_length(entry->rpchdr, entry->rpchdr_count) + + iov_length(entry->proghdr, entry->proghdr_count) + + GLUSTERFS_RDMA_MAX_HEADER_SIZE; + + if (entry->prog_payload_count != 0) { + prog_payload_length = iov_length(entry->prog_payload, + entry->prog_payload_count); + } + + if (send_size > GLUSTERFS_RDMA_INLINE_THRESHOLD) { + rtype = gf_rdma_areadch; + } else if ((send_size + prog_payload_length) < + GLUSTERFS_RDMA_INLINE_THRESHOLD) { + rtype = gf_rdma_noch; + } else if (entry->prog_payload_count != 0) { + rtype = gf_rdma_readch; + } + + if (entry->msg.request.rsphdr_count != 0) { + wtype = gf_rdma_replych; + } else if (entry->msg.request.rsp_payload_count != 0) { + wtype = gf_rdma_writech; + } + + if (rtype == gf_rdma_readch) { + chunk_count += entry->prog_payload_count; + } else if (rtype == gf_rdma_areadch) { + chunk_count += entry->rpchdr_count; + chunk_count += entry->proghdr_count; + } + + if (wtype == gf_rdma_writech) { + chunk_count += entry->msg.request.rsp_payload_count; + } else if (wtype == gf_rdma_replych) { + chunk_count += entry->msg.request.rsphdr_count; + } + + if (chunk_count > GF_RDMA_MAX_SEGMENTS) { + ret = -1; + gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, + RDMA_MSG_CHUNK_COUNT_GREAT_MAX_SEGMENTS, + "chunk count(%d) exceeding maximum allowed RDMA " + "segment count(%d)", + chunk_count, GF_RDMA_MAX_SEGMENTS); + goto out; + } + + if ((wtype != gf_rdma_noch) || (rtype != gf_rdma_noch)) { + request_ctx = mem_get(device->request_ctx_pool); + if (request_ctx == NULL) { + ret = -1; + goto out; + } + + memset(request_ctx, 0, sizeof(*request_ctx)); + + request_ctx->pool = device->request_ctx_pool; + request_ctx->peer = peer; + + entry->msg.request.rpc_req->conn_private = request_ctx; + + if (entry->msg.request.rsp_iobref != NULL) { + request_ctx->rsp_iobref = iobref_ref(entry->msg.request.rsp_iobref); + } + } + + rpc_msg = (struct rpc_msg *)entry->rpchdr[0].iov_base; + + hdr->rm_xid = rpc_msg->rm_xid; /* no need of hton32(rpc_msg->rm_xid), + * since rpc_msg->rm_xid is already + * hton32ed value of actual xid + */ + hdr->rm_vers = hton32(GF_RDMA_VERSION); + hdr->rm_credit = hton32(peer->send_count); + if (rtype == gf_rdma_areadch) { + hdr->rm_type = hton32(GF_RDMA_NOMSG); + } else { + hdr->rm_type = hton32(GF_RDMA_MSG); + } + + chunkptr = &hdr->rm_body.rm_chunks[0]; + if (rtype != gf_rdma_noch) { + ret = __gf_rdma_create_read_chunks(peer, entry, rtype, &chunkptr, + request_ctx); + if (ret != 0) { + gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, + RDMA_MSG_CREATE_READ_CHUNK_FAILED, + "creation of read chunks failed"); + goto out; + } + } else { + *chunkptr++ = 0; /* no read chunks */ + } + + if (wtype != gf_rdma_noch) { + ret = __gf_rdma_create_write_chunks(peer, entry, wtype, &chunkptr, + request_ctx); + if (ret != 0) { + gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, + RDMA_MSG_CREATE_WRITE_REPLAY_FAILED, + "creation of write/reply chunk failed"); + goto out; } + } else { + *chunkptr++ = 0; /* no write chunks */ + *chunkptr++ = 0; /* no reply chunk */ + } - buf = (char *)chunkptr; + buf = (char *)chunkptr; - if (rtype != gf_rdma_areadch) { - iov_unload (buf, entry->rpchdr, entry->rpchdr_count); - buf += iov_length (entry->rpchdr, entry->rpchdr_count); + if (rtype != gf_rdma_areadch) { + iov_unload(buf, entry->rpchdr, entry->rpchdr_count); + buf += iov_length(entry->rpchdr, entry->rpchdr_count); - iov_unload (buf, entry->proghdr, entry->proghdr_count); - buf += iov_length (entry->proghdr, entry->proghdr_count); + iov_unload(buf, entry->proghdr, entry->proghdr_count); + buf += iov_length(entry->proghdr, entry->proghdr_count); - if (rtype != gf_rdma_readch) { - iov_unload (buf, entry->prog_payload, - entry->prog_payload_count); - buf += iov_length (entry->prog_payload, - entry->prog_payload_count); - } + if (rtype != gf_rdma_readch) { + iov_unload(buf, entry->prog_payload, entry->prog_payload_count); + buf += iov_length(entry->prog_payload, entry->prog_payload_count); } + } - len = buf - post->buf; + len = buf - post->buf; - gf_rdma_post_ref (post); + gf_rdma_post_ref(post); - ret = gf_rdma_post_send (peer->qp, post, len); - if (!ret) { - ret = len; - } else { - gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, - RDMA_MSG_POST_SEND_FAILED, - "gf_rdma_post_send (to %s) failed with ret = %d (%s)", - peer->trans->peerinfo.identifier, ret, - (ret > 0) ? strerror (ret) : ""); - gf_rdma_post_unref (post); - __gf_rdma_disconnect (peer->trans); - ret = -1; - } + ret = gf_rdma_post_send(peer->qp, post, len); + if (!ret) { + ret = len; + } else { + gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, RDMA_MSG_POST_SEND_FAILED, + "gf_rdma_post_send (to %s) failed with ret = %d (%s)", + peer->trans->peerinfo.identifier, ret, + (ret > 0) ? strerror(ret) : ""); + gf_rdma_post_unref(post); + __gf_rdma_disconnect(peer->trans); + ret = -1; + } out: - if (ret == -1) { - rpc_req = entry->msg.request.rpc_req; - - if (request_ctx != NULL) { - __gf_rdma_request_context_destroy (rpc_req->conn_private); - } + if (ret == -1) { + rpc_req = entry->msg.request.rpc_req; - rpc_req->conn_private = NULL; + if (request_ctx != NULL) { + __gf_rdma_request_context_destroy(rpc_req->conn_private); } - return ret; -} + rpc_req->conn_private = NULL; + } + return ret; +} static void -__gf_rdma_fill_reply_header (gf_rdma_header_t *header, struct iovec *rpchdr, - gf_rdma_reply_info_t *reply_info, int credits) +__gf_rdma_fill_reply_header(gf_rdma_header_t *header, struct iovec *rpchdr, + gf_rdma_reply_info_t *reply_info, int credits) { - struct rpc_msg *rpc_msg = NULL; - - if (reply_info != NULL) { - header->rm_xid = hton32 (reply_info->rm_xid); - } else { - rpc_msg = rpchdr[0].iov_base; /* assume rpchdr contains - * only one vector. - * (which is true) - */ - header->rm_xid = rpc_msg->rm_xid; - } - - header->rm_type = hton32 (GF_RDMA_MSG); - header->rm_vers = hton32 (GF_RDMA_VERSION); - header->rm_credit = hton32 (credits); - - header->rm_body.rm_chunks[0] = 0; /* no read chunks */ - header->rm_body.rm_chunks[1] = 0; /* no write chunks */ - header->rm_body.rm_chunks[2] = 0; /* no reply chunks */ - - return; + struct rpc_msg *rpc_msg = NULL; + + if (reply_info != NULL) { + header->rm_xid = hton32(reply_info->rm_xid); + } else { + rpc_msg = rpchdr[0].iov_base; /* assume rpchdr contains + * only one vector. + * (which is true) + */ + header->rm_xid = rpc_msg->rm_xid; + } + + header->rm_type = hton32(GF_RDMA_MSG); + header->rm_vers = hton32(GF_RDMA_VERSION); + header->rm_credit = hton32(credits); + + header->rm_body.rm_chunks[0] = 0; /* no read chunks */ + header->rm_body.rm_chunks[1] = 0; /* no write chunks */ + header->rm_body.rm_chunks[2] = 0; /* no reply chunks */ + + return; } - int32_t -__gf_rdma_send_reply_inline (gf_rdma_peer_t *peer, gf_rdma_ioq_t *entry, - gf_rdma_post_t *post, - gf_rdma_reply_info_t *reply_info) +__gf_rdma_send_reply_inline(gf_rdma_peer_t *peer, gf_rdma_ioq_t *entry, + gf_rdma_post_t *post, + gf_rdma_reply_info_t *reply_info) { - gf_rdma_header_t *header = NULL; - int32_t send_size = 0, ret = 0; - char *buf = NULL; - - send_size = iov_length (entry->rpchdr, entry->rpchdr_count) - + iov_length (entry->proghdr, entry->proghdr_count) - + iov_length (entry->prog_payload, entry->prog_payload_count) - + sizeof (gf_rdma_header_t); /* - * remember, no chunklists in the - * reply - */ - - if (send_size > GLUSTERFS_RDMA_INLINE_THRESHOLD) { - ret = __gf_rdma_send_error (peer, entry, post, reply_info, - ERR_CHUNK); - gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, - RDMA_MSG_SEND_SIZE_GREAT_INLINE_THRESHOLD, - "msg size (%d) is greater than maximum size " - "of msg that can be sent inlined (%d)", - send_size, GLUSTERFS_RDMA_INLINE_THRESHOLD); - goto out; - } - - header = (gf_rdma_header_t *)post->buf; - - __gf_rdma_fill_reply_header (header, entry->rpchdr, reply_info, - peer->send_count); - - buf = (char *)&header->rm_body.rm_chunks[3]; - - if (entry->rpchdr_count != 0) { - iov_unload (buf, entry->rpchdr, entry->rpchdr_count); - buf += iov_length (entry->rpchdr, entry->rpchdr_count); - } - - if (entry->proghdr_count != 0) { - iov_unload (buf, entry->proghdr, entry->proghdr_count); - buf += iov_length (entry->proghdr, entry->proghdr_count); - } - - if (entry->prog_payload_count != 0) { - iov_unload (buf, entry->prog_payload, - entry->prog_payload_count); - buf += iov_length (entry->prog_payload, - entry->prog_payload_count); - } - - gf_rdma_post_ref (post); + gf_rdma_header_t *header = NULL; + int32_t send_size = 0, ret = 0; + char *buf = NULL; + + send_size = iov_length(entry->rpchdr, entry->rpchdr_count) + + iov_length(entry->proghdr, entry->proghdr_count) + + iov_length(entry->prog_payload, entry->prog_payload_count) + + sizeof(gf_rdma_header_t); /* + * remember, no chunklists in the + * reply + */ - ret = gf_rdma_post_send (peer->qp, post, (buf - post->buf)); - if (!ret) { - ret = send_size; - } else { - gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, - RDMA_MSG_POST_SEND_FAILED, "posting send (to %s) " - "failed with ret = %d (%s)", - peer->trans->peerinfo.identifier, ret, - (ret > 0) ? strerror (ret) : ""); - gf_rdma_post_unref (post); - __gf_rdma_disconnect (peer->trans); - ret = -1; - } + if (send_size > GLUSTERFS_RDMA_INLINE_THRESHOLD) { + ret = __gf_rdma_send_error(peer, entry, post, reply_info, ERR_CHUNK); + gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, + RDMA_MSG_SEND_SIZE_GREAT_INLINE_THRESHOLD, + "msg size (%d) is greater than maximum size " + "of msg that can be sent inlined (%d)", + send_size, GLUSTERFS_RDMA_INLINE_THRESHOLD); + goto out; + } + + header = (gf_rdma_header_t *)post->buf; + + __gf_rdma_fill_reply_header(header, entry->rpchdr, reply_info, + peer->send_count); + + buf = (char *)&header->rm_body.rm_chunks[3]; + + if (entry->rpchdr_count != 0) { + iov_unload(buf, entry->rpchdr, entry->rpchdr_count); + buf += iov_length(entry->rpchdr, entry->rpchdr_count); + } + + if (entry->proghdr_count != 0) { + iov_unload(buf, entry->proghdr, entry->proghdr_count); + buf += iov_length(entry->proghdr, entry->proghdr_count); + } + + if (entry->prog_payload_count != 0) { + iov_unload(buf, entry->prog_payload, entry->prog_payload_count); + buf += iov_length(entry->prog_payload, entry->prog_payload_count); + } + + gf_rdma_post_ref(post); + + ret = gf_rdma_post_send(peer->qp, post, (buf - post->buf)); + if (!ret) { + ret = send_size; + } else { + gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, RDMA_MSG_POST_SEND_FAILED, + "posting send (to %s) " + "failed with ret = %d (%s)", + peer->trans->peerinfo.identifier, ret, + (ret > 0) ? strerror(ret) : ""); + gf_rdma_post_unref(post); + __gf_rdma_disconnect(peer->trans); + ret = -1; + } out: - return ret; + return ret; } - int32_t -__gf_rdma_reply_encode_write_chunks (gf_rdma_peer_t *peer, - uint32_t payload_size, - gf_rdma_post_t *post, - gf_rdma_reply_info_t *reply_info, - uint32_t **ptr) +__gf_rdma_reply_encode_write_chunks(gf_rdma_peer_t *peer, uint32_t payload_size, + gf_rdma_post_t *post, + gf_rdma_reply_info_t *reply_info, + uint32_t **ptr) { - uint32_t chunk_size = 0; - int32_t ret = -1; - gf_rdma_write_array_t *target_array = NULL; - int i = 0; - - target_array = (gf_rdma_write_array_t *)*ptr; - - for (i = 0; i < reply_info->wc_array->wc_nchunks; i++) { - chunk_size += - reply_info->wc_array->wc_array[i].wc_target.rs_length; - } - - if (chunk_size < payload_size) { - gf_msg_debug (GF_RDMA_LOG_NAME, 0, "length of payload (%d) is " - "exceeding the total write chunk length (%d)", - payload_size, chunk_size); - goto out; - } - - target_array->wc_discrim = hton32 (1); - for (i = 0; (i < reply_info->wc_array->wc_nchunks) - && (payload_size != 0); - i++) { - target_array->wc_array[i].wc_target.rs_offset - = hton64 (reply_info->wc_array->wc_array[i].wc_target.rs_offset); - - target_array->wc_array[i].wc_target.rs_length - = hton32 (min (payload_size, - reply_info->wc_array->wc_array[i].wc_target.rs_length)); - } - - target_array->wc_nchunks = hton32 (i); - target_array->wc_array[i].wc_target.rs_handle = 0; /* terminate - chunklist */ - - ret = 0; - - *ptr = &target_array->wc_array[i].wc_target.rs_length; + uint32_t chunk_size = 0; + int32_t ret = -1; + gf_rdma_write_array_t *target_array = NULL; + int i = 0; + + target_array = (gf_rdma_write_array_t *)*ptr; + + for (i = 0; i < reply_info->wc_array->wc_nchunks; i++) { + chunk_size += reply_info->wc_array->wc_array[i].wc_target.rs_length; + } + + if (chunk_size < payload_size) { + gf_msg_debug(GF_RDMA_LOG_NAME, 0, + "length of payload (%d) is " + "exceeding the total write chunk length (%d)", + payload_size, chunk_size); + goto out; + } + + target_array->wc_discrim = hton32(1); + for (i = 0; (i < reply_info->wc_array->wc_nchunks) && (payload_size != 0); + i++) { + target_array->wc_array[i].wc_target.rs_offset = hton64( + reply_info->wc_array->wc_array[i].wc_target.rs_offset); + + target_array->wc_array[i].wc_target.rs_length = hton32( + min(payload_size, + reply_info->wc_array->wc_array[i].wc_target.rs_length)); + } + + target_array->wc_nchunks = hton32(i); + target_array->wc_array[i].wc_target.rs_handle = 0; /* terminate + chunklist */ + + ret = 0; + + *ptr = &target_array->wc_array[i].wc_target.rs_length; out: - return ret; + return ret; } - static int32_t -__gf_rdma_register_local_mr_for_rdma (gf_rdma_peer_t *peer, - struct iovec *vector, int count, - gf_rdma_post_context_t *ctx) +__gf_rdma_register_local_mr_for_rdma(gf_rdma_peer_t *peer, struct iovec *vector, + int count, gf_rdma_post_context_t *ctx) { - int i = 0; - int32_t ret = -1; - gf_rdma_private_t *priv = NULL; - gf_rdma_device_t *device = NULL; - - GF_VALIDATE_OR_GOTO (GF_RDMA_LOG_NAME, ctx, out); - GF_VALIDATE_OR_GOTO (GF_RDMA_LOG_NAME, vector, out); - - priv = peer->trans->private; - device = priv->device; - - for (i = 0; i < count; i++) { - /* what if the memory is registered more than once? - * Assume that a single write buffer is passed to afr, which - * then passes it to its children. If more than one children - * happen to use rdma, then the buffer is registered more than - * once. - * Ib-verbs specification says that multiple registrations of - * same memory location is allowed. Refer to 10.6.3.8 of - * Infiniband Architecture Specification Volume 1 - * (Release 1.2.1) - */ - ctx->mr[ctx->mr_count] = gf_rdma_get_pre_registred_mr( - peer->trans, (void *)vector[i].iov_base, - vector[i].iov_len); - - if (!ctx->mr[ctx->mr_count]) { - ctx->mr[ctx->mr_count] = ibv_reg_mr (device->pd, - vector[i].iov_base, - vector[i].iov_len, - IBV_ACCESS_LOCAL_WRITE); - } - if (ctx->mr[ctx->mr_count] == NULL) { - gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, errno, - RDMA_MSG_MR_ALOC_FAILED, - "registering memory for IBV_ACCESS_LOCAL_WRITE" - " failed"); - goto out; - } + int i = 0; + int32_t ret = -1; + gf_rdma_private_t *priv = NULL; + gf_rdma_device_t *device = NULL; + + GF_VALIDATE_OR_GOTO(GF_RDMA_LOG_NAME, ctx, out); + GF_VALIDATE_OR_GOTO(GF_RDMA_LOG_NAME, vector, out); + + priv = peer->trans->private; + device = priv->device; + + for (i = 0; i < count; i++) { + /* what if the memory is registered more than once? + * Assume that a single write buffer is passed to afr, which + * then passes it to its children. If more than one children + * happen to use rdma, then the buffer is registered more than + * once. + * Ib-verbs specification says that multiple registrations of + * same memory location is allowed. Refer to 10.6.3.8 of + * Infiniband Architecture Specification Volume 1 + * (Release 1.2.1) + */ + ctx->mr[ctx->mr_count] = gf_rdma_get_pre_registred_mr( + peer->trans, (void *)vector[i].iov_base, vector[i].iov_len); - ctx->mr_count++; + if (!ctx->mr[ctx->mr_count]) { + ctx->mr[ctx->mr_count] = ibv_reg_mr(device->pd, vector[i].iov_base, + vector[i].iov_len, + IBV_ACCESS_LOCAL_WRITE); + } + if (ctx->mr[ctx->mr_count] == NULL) { + gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, errno, + RDMA_MSG_MR_ALOC_FAILED, + "registering memory for IBV_ACCESS_LOCAL_WRITE" + " failed"); + goto out; } - ret = 0; + ctx->mr_count++; + } + + ret = 0; out: - return ret; + return ret; } /* 1. assumes xfer_len of data is pointed by vector(s) starting from vec[*idx] * 2. modifies vec */ int32_t -__gf_rdma_write (gf_rdma_peer_t *peer, gf_rdma_post_t *post, struct iovec *vec, - uint32_t xfer_len, int *idx, gf_rdma_write_chunk_t *writech) +__gf_rdma_write(gf_rdma_peer_t *peer, gf_rdma_post_t *post, struct iovec *vec, + uint32_t xfer_len, int *idx, gf_rdma_write_chunk_t *writech) { - int size = 0, num_sge = 0, i = 0; - int32_t ret = -1; - struct ibv_sge *sg_list = NULL; - struct ibv_send_wr wr = { - .opcode = IBV_WR_RDMA_WRITE, - .send_flags = IBV_SEND_SIGNALED, - }, *bad_wr; - - if ((peer == NULL) || (writech == NULL) || (idx == NULL) - || (post == NULL) || (vec == NULL) || (xfer_len == 0)) { - goto out; - } - - for (i = *idx; size < xfer_len; i++) { - size += vec[i].iov_len; - } - - num_sge = i - *idx; - - sg_list = GF_CALLOC (num_sge, sizeof (struct ibv_sge), - gf_common_mt_sge); - if (sg_list == NULL) { - ret = -1; - goto out; - } - - for ((i = *idx), (num_sge = 0); (xfer_len != 0); i++, num_sge++) { - size = min (xfer_len, vec[i].iov_len); - - sg_list[num_sge].addr = (unsigned long)vec[i].iov_base; - sg_list[num_sge].length = size; - sg_list[num_sge].lkey = post->ctx.mr[i]->lkey; - - xfer_len -= size; - } - - *idx = i; - - if (size < vec[i - 1].iov_len) { - vec[i - 1].iov_base += size; - vec[i - 1].iov_len -= size; - *idx = i - 1; - } - - wr.sg_list = sg_list; - wr.num_sge = num_sge; - wr.wr_id = (unsigned long) gf_rdma_post_ref (post); - wr.wr.rdma.rkey = writech->wc_target.rs_handle; - wr.wr.rdma.remote_addr = writech->wc_target.rs_offset; - - ret = ibv_post_send(peer->qp, &wr, &bad_wr); - if (ret) { - gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, - RDMA_MSG_WRITE_CLIENT_ERROR, "rdma write to " - "client (%s) failed with ret = %d (%s)", - peer->trans->peerinfo.identifier, ret, - (ret > 0) ? strerror (ret) : ""); - ret = -1; - } - - GF_FREE (sg_list); + int size = 0, num_sge = 0, i = 0; + int32_t ret = -1; + struct ibv_sge *sg_list = NULL; + struct ibv_send_wr wr = + { + .opcode = IBV_WR_RDMA_WRITE, + .send_flags = IBV_SEND_SIGNALED, + }, + *bad_wr; + + if ((peer == NULL) || (writech == NULL) || (idx == NULL) || + (post == NULL) || (vec == NULL) || (xfer_len == 0)) { + goto out; + } + + for (i = *idx; size < xfer_len; i++) { + size += vec[i].iov_len; + } + + num_sge = i - *idx; + + sg_list = GF_CALLOC(num_sge, sizeof(struct ibv_sge), gf_common_mt_sge); + if (sg_list == NULL) { + ret = -1; + goto out; + } + + for ((i = *idx), (num_sge = 0); (xfer_len != 0); i++, num_sge++) { + size = min(xfer_len, vec[i].iov_len); + + sg_list[num_sge].addr = (unsigned long)vec[i].iov_base; + sg_list[num_sge].length = size; + sg_list[num_sge].lkey = post->ctx.mr[i]->lkey; + + xfer_len -= size; + } + + *idx = i; + + if (size < vec[i - 1].iov_len) { + vec[i - 1].iov_base += size; + vec[i - 1].iov_len -= size; + *idx = i - 1; + } + + wr.sg_list = sg_list; + wr.num_sge = num_sge; + wr.wr_id = (unsigned long)gf_rdma_post_ref(post); + wr.wr.rdma.rkey = writech->wc_target.rs_handle; + wr.wr.rdma.remote_addr = writech->wc_target.rs_offset; + + ret = ibv_post_send(peer->qp, &wr, &bad_wr); + if (ret) { + gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, RDMA_MSG_WRITE_CLIENT_ERROR, + "rdma write to " + "client (%s) failed with ret = %d (%s)", + peer->trans->peerinfo.identifier, ret, + (ret > 0) ? strerror(ret) : ""); + ret = -1; + } + + GF_FREE(sg_list); out: - return ret; + return ret; } - int32_t -__gf_rdma_do_gf_rdma_write (gf_rdma_peer_t *peer, gf_rdma_post_t *post, - struct iovec *vector, int count, - struct iobref *iobref, - gf_rdma_reply_info_t *reply_info) +__gf_rdma_do_gf_rdma_write(gf_rdma_peer_t *peer, gf_rdma_post_t *post, + struct iovec *vector, int count, + struct iobref *iobref, + gf_rdma_reply_info_t *reply_info) { - int i = 0, payload_idx = 0; - uint32_t payload_size = 0, xfer_len = 0; - int32_t ret = -1; + int i = 0, payload_idx = 0; + uint32_t payload_size = 0, xfer_len = 0; + int32_t ret = -1; - if (count != 0) { - payload_size = iov_length (vector, count); - } + if (count != 0) { + payload_size = iov_length(vector, count); + } - if (payload_size == 0) { - ret = 0; - goto out; - } + if (payload_size == 0) { + ret = 0; + goto out; + } - ret = __gf_rdma_register_local_mr_for_rdma (peer, vector, count, - &post->ctx); - if (ret == -1) { - gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, - RDMA_MSG_MR_ALOC_FAILED, - "registering memory region for rdma failed"); - goto out; - } + ret = __gf_rdma_register_local_mr_for_rdma(peer, vector, count, &post->ctx); + if (ret == -1) { + gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, RDMA_MSG_MR_ALOC_FAILED, + "registering memory region for rdma failed"); + goto out; + } - post->ctx.iobref = iobref_ref (iobref); + post->ctx.iobref = iobref_ref(iobref); - for (i = 0; (i < reply_info->wc_array->wc_nchunks) - && (payload_size != 0); - i++) { - xfer_len = min (payload_size, - reply_info->wc_array->wc_array[i].wc_target.rs_length); + for (i = 0; (i < reply_info->wc_array->wc_nchunks) && (payload_size != 0); + i++) { + xfer_len = min(payload_size, + reply_info->wc_array->wc_array[i].wc_target.rs_length); - ret = __gf_rdma_write (peer, post, vector, xfer_len, - &payload_idx, - &reply_info->wc_array->wc_array[i]); - if (ret == -1) { - gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, - RDMA_MSG_WRITE_CLIENT_ERROR, "rdma write to " - "client (%s) failed", - peer->trans->peerinfo.identifier); - goto out; - } - - payload_size -= xfer_len; + ret = __gf_rdma_write(peer, post, vector, xfer_len, &payload_idx, + &reply_info->wc_array->wc_array[i]); + if (ret == -1) { + gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, + RDMA_MSG_WRITE_CLIENT_ERROR, + "rdma write to " + "client (%s) failed", + peer->trans->peerinfo.identifier); + goto out; } - ret = 0; + payload_size -= xfer_len; + } + + ret = 0; out: - return ret; + return ret; } - int32_t -__gf_rdma_send_reply_type_nomsg (gf_rdma_peer_t *peer, gf_rdma_ioq_t *entry, - gf_rdma_post_t *post, - gf_rdma_reply_info_t *reply_info) +__gf_rdma_send_reply_type_nomsg(gf_rdma_peer_t *peer, gf_rdma_ioq_t *entry, + gf_rdma_post_t *post, + gf_rdma_reply_info_t *reply_info) { - gf_rdma_header_t *header = NULL; - char *buf = NULL; - uint32_t payload_size = 0; - int count = 0, i = 0; - int32_t ret = 0; - struct iovec vector[MAX_IOVEC]; - - header = (gf_rdma_header_t *)post->buf; - - __gf_rdma_fill_reply_header (header, entry->rpchdr, reply_info, - peer->send_count); - - header->rm_type = hton32 (GF_RDMA_NOMSG); - - payload_size = iov_length (entry->rpchdr, entry->rpchdr_count) + - iov_length (entry->proghdr, entry->proghdr_count); - - /* encode reply chunklist */ - buf = (char *)&header->rm_body.rm_chunks[2]; - ret = __gf_rdma_reply_encode_write_chunks (peer, payload_size, post, - reply_info, - (uint32_t **)&buf); - if (ret == -1) { - gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, - RDMA_MSG_ENCODE_ERROR, "encoding write chunks failed"); - ret = __gf_rdma_send_error (peer, entry, post, reply_info, - ERR_CHUNK); - goto out; - } - - gf_rdma_post_ref (post); - - for (i = 0; i < entry->rpchdr_count; i++) { - vector[count++] = entry->rpchdr[i]; - } - - for (i = 0; i < entry->proghdr_count; i++) { - vector[count++] = entry->proghdr[i]; - } - - ret = __gf_rdma_do_gf_rdma_write (peer, post, vector, count, - entry->iobref, reply_info); - if (ret == -1) { - gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, - RDMA_MSG_WRITE_PEER_FAILED, "rdma write to peer " - "(%s) failed", peer->trans->peerinfo.identifier); - gf_rdma_post_unref (post); - goto out; - } - - ret = gf_rdma_post_send (peer->qp, post, (buf - post->buf)); - if (ret) { - gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, - RDMA_MSG_POST_SEND_FAILED, "posting a send request " - "to client (%s) failed with ret = %d (%s)", - peer->trans->peerinfo.identifier, ret, - (ret > 0) ? strerror (ret) : ""); - ret = -1; - gf_rdma_post_unref (post); - } else { - ret = payload_size; - } + gf_rdma_header_t *header = NULL; + char *buf = NULL; + uint32_t payload_size = 0; + int count = 0, i = 0; + int32_t ret = 0; + struct iovec vector[MAX_IOVEC]; + + header = (gf_rdma_header_t *)post->buf; + + __gf_rdma_fill_reply_header(header, entry->rpchdr, reply_info, + peer->send_count); + + header->rm_type = hton32(GF_RDMA_NOMSG); + + payload_size = iov_length(entry->rpchdr, entry->rpchdr_count) + + iov_length(entry->proghdr, entry->proghdr_count); + + /* encode reply chunklist */ + buf = (char *)&header->rm_body.rm_chunks[2]; + ret = __gf_rdma_reply_encode_write_chunks(peer, payload_size, post, + reply_info, (uint32_t **)&buf); + if (ret == -1) { + gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, RDMA_MSG_ENCODE_ERROR, + "encoding write chunks failed"); + ret = __gf_rdma_send_error(peer, entry, post, reply_info, ERR_CHUNK); + goto out; + } + + gf_rdma_post_ref(post); + + for (i = 0; i < entry->rpchdr_count; i++) { + vector[count++] = entry->rpchdr[i]; + } + + for (i = 0; i < entry->proghdr_count; i++) { + vector[count++] = entry->proghdr[i]; + } + + ret = __gf_rdma_do_gf_rdma_write(peer, post, vector, count, entry->iobref, + reply_info); + if (ret == -1) { + gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, RDMA_MSG_WRITE_PEER_FAILED, + "rdma write to peer " + "(%s) failed", + peer->trans->peerinfo.identifier); + gf_rdma_post_unref(post); + goto out; + } + + ret = gf_rdma_post_send(peer->qp, post, (buf - post->buf)); + if (ret) { + gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, RDMA_MSG_POST_SEND_FAILED, + "posting a send request " + "to client (%s) failed with ret = %d (%s)", + peer->trans->peerinfo.identifier, ret, + (ret > 0) ? strerror(ret) : ""); + ret = -1; + gf_rdma_post_unref(post); + } else { + ret = payload_size; + } out: - return ret; + return ret; } - int32_t -__gf_rdma_send_reply_type_msg (gf_rdma_peer_t *peer, gf_rdma_ioq_t *entry, - gf_rdma_post_t *post, - gf_rdma_reply_info_t *reply_info) +__gf_rdma_send_reply_type_msg(gf_rdma_peer_t *peer, gf_rdma_ioq_t *entry, + gf_rdma_post_t *post, + gf_rdma_reply_info_t *reply_info) { - gf_rdma_header_t *header = NULL; - int32_t send_size = 0, ret = 0; - char *ptr = NULL; - uint32_t payload_size = 0; - - send_size = iov_length (entry->rpchdr, entry->rpchdr_count) - + iov_length (entry->proghdr, entry->proghdr_count) - + GLUSTERFS_RDMA_MAX_HEADER_SIZE; - - if (send_size > GLUSTERFS_RDMA_INLINE_THRESHOLD) { - gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, - RDMA_MSG_SEND_SIZE_GREAT_INLINE_THRESHOLD, - "client has provided only write chunks, but the " - "combined size of rpc and program header (%d) is " - "exceeding the size of msg that can be sent using " - "RDMA send (%d)", send_size, - GLUSTERFS_RDMA_INLINE_THRESHOLD); - - ret = __gf_rdma_send_error (peer, entry, post, reply_info, - ERR_CHUNK); - goto out; - } - - header = (gf_rdma_header_t *)post->buf; - - __gf_rdma_fill_reply_header (header, entry->rpchdr, reply_info, - peer->send_count); - - payload_size = iov_length (entry->prog_payload, - entry->prog_payload_count); - ptr = (char *)&header->rm_body.rm_chunks[1]; - - ret = __gf_rdma_reply_encode_write_chunks (peer, payload_size, post, - reply_info, - (uint32_t **)&ptr); - if (ret == -1) { - gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, - RDMA_MSG_ENCODE_ERROR, "encoding write chunks failed"); - ret = __gf_rdma_send_error (peer, entry, post, reply_info, - ERR_CHUNK); - goto out; - } - - *(uint32_t *)ptr = 0; /* terminate reply chunklist */ - ptr += sizeof (uint32_t); - - gf_rdma_post_ref (post); - - ret = __gf_rdma_do_gf_rdma_write (peer, post, entry->prog_payload, - entry->prog_payload_count, - entry->iobref, reply_info); - if (ret == -1) { - gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, - RDMA_MSG_WRITE_PEER_FAILED, "rdma write to peer " - "(%s) failed", peer->trans->peerinfo.identifier); - gf_rdma_post_unref (post); - goto out; - } - - iov_unload (ptr, entry->rpchdr, entry->rpchdr_count); - ptr += iov_length (entry->rpchdr, entry->rpchdr_count); - - iov_unload (ptr, entry->proghdr, entry->proghdr_count); - ptr += iov_length (entry->proghdr, entry->proghdr_count); - - ret = gf_rdma_post_send (peer->qp, post, (ptr - post->buf)); - if (ret) { - gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, - RDMA_MSG_SEND_CLIENT_ERROR, - "rdma send to client (%s) failed with ret = %d (%s)", - peer->trans->peerinfo.identifier, ret, - (ret > 0) ? strerror (ret) : ""); - gf_rdma_post_unref (post); - ret = -1; - } else { - ret = send_size + payload_size; - } + gf_rdma_header_t *header = NULL; + int32_t send_size = 0, ret = 0; + char *ptr = NULL; + uint32_t payload_size = 0; + + send_size = iov_length(entry->rpchdr, entry->rpchdr_count) + + iov_length(entry->proghdr, entry->proghdr_count) + + GLUSTERFS_RDMA_MAX_HEADER_SIZE; + + if (send_size > GLUSTERFS_RDMA_INLINE_THRESHOLD) { + gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, + RDMA_MSG_SEND_SIZE_GREAT_INLINE_THRESHOLD, + "client has provided only write chunks, but the " + "combined size of rpc and program header (%d) is " + "exceeding the size of msg that can be sent using " + "RDMA send (%d)", + send_size, GLUSTERFS_RDMA_INLINE_THRESHOLD); + + ret = __gf_rdma_send_error(peer, entry, post, reply_info, ERR_CHUNK); + goto out; + } + + header = (gf_rdma_header_t *)post->buf; + + __gf_rdma_fill_reply_header(header, entry->rpchdr, reply_info, + peer->send_count); + + payload_size = iov_length(entry->prog_payload, entry->prog_payload_count); + ptr = (char *)&header->rm_body.rm_chunks[1]; + + ret = __gf_rdma_reply_encode_write_chunks(peer, payload_size, post, + reply_info, (uint32_t **)&ptr); + if (ret == -1) { + gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, RDMA_MSG_ENCODE_ERROR, + "encoding write chunks failed"); + ret = __gf_rdma_send_error(peer, entry, post, reply_info, ERR_CHUNK); + goto out; + } + + *(uint32_t *)ptr = 0; /* terminate reply chunklist */ + ptr += sizeof(uint32_t); + + gf_rdma_post_ref(post); + + ret = __gf_rdma_do_gf_rdma_write(peer, post, entry->prog_payload, + entry->prog_payload_count, entry->iobref, + reply_info); + if (ret == -1) { + gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, RDMA_MSG_WRITE_PEER_FAILED, + "rdma write to peer " + "(%s) failed", + peer->trans->peerinfo.identifier); + gf_rdma_post_unref(post); + goto out; + } + + iov_unload(ptr, entry->rpchdr, entry->rpchdr_count); + ptr += iov_length(entry->rpchdr, entry->rpchdr_count); + + iov_unload(ptr, entry->proghdr, entry->proghdr_count); + ptr += iov_length(entry->proghdr, entry->proghdr_count); + + ret = gf_rdma_post_send(peer->qp, post, (ptr - post->buf)); + if (ret) { + gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, RDMA_MSG_SEND_CLIENT_ERROR, + "rdma send to client (%s) failed with ret = %d (%s)", + peer->trans->peerinfo.identifier, ret, + (ret > 0) ? strerror(ret) : ""); + gf_rdma_post_unref(post); + ret = -1; + } else { + ret = send_size + payload_size; + } out: - return ret; + return ret; } - void -gf_rdma_reply_info_destroy (gf_rdma_reply_info_t *reply_info) +gf_rdma_reply_info_destroy(gf_rdma_reply_info_t *reply_info) { - if (reply_info == NULL) { - goto out; - } + if (reply_info == NULL) { + goto out; + } - if (reply_info->wc_array != NULL) { - GF_FREE (reply_info->wc_array); - reply_info->wc_array = NULL; - } + if (reply_info->wc_array != NULL) { + GF_FREE(reply_info->wc_array); + reply_info->wc_array = NULL; + } - mem_put (reply_info); + mem_put(reply_info); out: - return; + return; } - gf_rdma_reply_info_t * -gf_rdma_reply_info_alloc (gf_rdma_peer_t *peer) +gf_rdma_reply_info_alloc(gf_rdma_peer_t *peer) { - gf_rdma_reply_info_t *reply_info = NULL; - gf_rdma_private_t *priv = NULL; + gf_rdma_reply_info_t *reply_info = NULL; + gf_rdma_private_t *priv = NULL; - priv = peer->trans->private; + priv = peer->trans->private; - reply_info = mem_get (priv->device->reply_info_pool); - if (reply_info == NULL) { - goto out; - } + reply_info = mem_get(priv->device->reply_info_pool); + if (reply_info == NULL) { + goto out; + } - memset (reply_info, 0, sizeof (*reply_info)); - reply_info->pool = priv->device->reply_info_pool; + memset(reply_info, 0, sizeof(*reply_info)); + reply_info->pool = priv->device->reply_info_pool; out: - return reply_info; + return reply_info; } - int32_t -__gf_rdma_ioq_churn_reply (gf_rdma_peer_t *peer, gf_rdma_ioq_t *entry, - gf_rdma_post_t *post) +__gf_rdma_ioq_churn_reply(gf_rdma_peer_t *peer, gf_rdma_ioq_t *entry, + gf_rdma_post_t *post) { - gf_rdma_reply_info_t *reply_info = NULL; - int32_t ret = -1; - gf_rdma_chunktype_t type = gf_rdma_noch; + gf_rdma_reply_info_t *reply_info = NULL; + int32_t ret = -1; + gf_rdma_chunktype_t type = gf_rdma_noch; - GF_VALIDATE_OR_GOTO (GF_RDMA_LOG_NAME, peer, out); - GF_VALIDATE_OR_GOTO (GF_RDMA_LOG_NAME, entry, out); - GF_VALIDATE_OR_GOTO (GF_RDMA_LOG_NAME, post, out); + GF_VALIDATE_OR_GOTO(GF_RDMA_LOG_NAME, peer, out); + GF_VALIDATE_OR_GOTO(GF_RDMA_LOG_NAME, entry, out); + GF_VALIDATE_OR_GOTO(GF_RDMA_LOG_NAME, post, out); - reply_info = entry->msg.reply_info; - if (reply_info != NULL) { - type = reply_info->type; - } + reply_info = entry->msg.reply_info; + if (reply_info != NULL) { + type = reply_info->type; + } - switch (type) { + switch (type) { case gf_rdma_noch: - ret = __gf_rdma_send_reply_inline (peer, entry, post, - reply_info); - if (ret < 0) { - gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, - RDMA_MSG_SEND_REPLY_FAILED, - "failed to send reply to peer (%s) as an " - "inlined rdma msg", - peer->trans->peerinfo.identifier); - } - break; + ret = __gf_rdma_send_reply_inline(peer, entry, post, reply_info); + if (ret < 0) { + gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, + RDMA_MSG_SEND_REPLY_FAILED, + "failed to send reply to peer (%s) as an " + "inlined rdma msg", + peer->trans->peerinfo.identifier); + } + break; case gf_rdma_replych: - ret = __gf_rdma_send_reply_type_nomsg (peer, entry, post, - reply_info); - if (ret < 0) { - gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, - RDMA_MSG_SEND_REPLY_FAILED, - "failed to send reply to peer (%s) as " - "RDMA_NOMSG", peer->trans->peerinfo.identifier); - } - break; + ret = __gf_rdma_send_reply_type_nomsg(peer, entry, post, + reply_info); + if (ret < 0) { + gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, + RDMA_MSG_SEND_REPLY_FAILED, + "failed to send reply to peer (%s) as " + "RDMA_NOMSG", + peer->trans->peerinfo.identifier); + } + break; case gf_rdma_writech: - ret = __gf_rdma_send_reply_type_msg (peer, entry, post, - reply_info); - if (ret < 0) { - gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, - RDMA_MSG_SEND_REPLY_FAILED, - "failed to send reply with write chunks " - "to peer (%s)", - peer->trans->peerinfo.identifier); - } - break; + ret = __gf_rdma_send_reply_type_msg(peer, entry, post, reply_info); + if (ret < 0) { + gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, + RDMA_MSG_SEND_REPLY_FAILED, + "failed to send reply with write chunks " + "to peer (%s)", + peer->trans->peerinfo.identifier); + } + break; default: - gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, - RDMA_MSG_INVALID_CHUNK_TYPE, - "invalid chunktype (%d) specified for sending reply " - " (peer:%s)", type, peer->trans->peerinfo.identifier); - break; - } - - if (reply_info != NULL) { - gf_rdma_reply_info_destroy (reply_info); - } + gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, + RDMA_MSG_INVALID_CHUNK_TYPE, + "invalid chunktype (%d) specified for sending reply " + " (peer:%s)", + type, peer->trans->peerinfo.identifier); + break; + } + + if (reply_info != NULL) { + gf_rdma_reply_info_destroy(reply_info); + } out: - return ret; + return ret; } - int32_t -__gf_rdma_ioq_churn_entry (gf_rdma_peer_t *peer, gf_rdma_ioq_t *entry) +__gf_rdma_ioq_churn_entry(gf_rdma_peer_t *peer, gf_rdma_ioq_t *entry) { - int32_t ret = 0, quota = 0; - gf_rdma_private_t *priv = NULL; - gf_rdma_device_t *device = NULL; - gf_rdma_options_t *options = NULL; - gf_rdma_post_t *post = NULL; - - priv = peer->trans->private; - options = &priv->options; - device = priv->device; - - quota = __gf_rdma_quota_get (peer); - if (quota > 0) { - post = gf_rdma_get_post (&device->sendq); - if (post == NULL) { - post = gf_rdma_new_post (peer->trans, device, - (options->send_size + 2048), - GF_RDMA_SEND_POST); - } - - if (post == NULL) { - ret = -1; - gf_msg_callingfn (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, - RDMA_MSG_POST_SEND_FAILED, - "not able to get a post to send msg"); - goto out; - } - - if (entry->is_request) { - ret = __gf_rdma_ioq_churn_request (peer, entry, post); - if (ret < 0) { - gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, - RDMA_MSG_PROC_IOQ_ENTRY_FAILED, - "failed to process request ioq entry " - "to peer(%s)", - peer->trans->peerinfo.identifier); - } - } else { - ret = __gf_rdma_ioq_churn_reply (peer, entry, post); - if (ret < 0) { - gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, - RDMA_MSG_PROC_IOQ_ENTRY_FAILED, - "failed to process reply ioq entry " - "to peer (%s)", - peer->trans->peerinfo.identifier); - } - } + int32_t ret = 0, quota = 0; + gf_rdma_private_t *priv = NULL; + gf_rdma_device_t *device = NULL; + gf_rdma_options_t *options = NULL; + gf_rdma_post_t *post = NULL; + + priv = peer->trans->private; + options = &priv->options; + device = priv->device; + + quota = __gf_rdma_quota_get(peer); + if (quota > 0) { + post = gf_rdma_get_post(&device->sendq); + if (post == NULL) { + post = gf_rdma_new_post(peer->trans, device, + (options->send_size + 2048), + GF_RDMA_SEND_POST); + } - if (ret != 0) { - __gf_rdma_ioq_entry_free (entry); - } + if (post == NULL) { + ret = -1; + gf_msg_callingfn(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, + RDMA_MSG_POST_SEND_FAILED, + "not able to get a post to send msg"); + goto out; + } + + if (entry->is_request) { + ret = __gf_rdma_ioq_churn_request(peer, entry, post); + if (ret < 0) { + gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, + RDMA_MSG_PROC_IOQ_ENTRY_FAILED, + "failed to process request ioq entry " + "to peer(%s)", + peer->trans->peerinfo.identifier); + } } else { - ret = 0; + ret = __gf_rdma_ioq_churn_reply(peer, entry, post); + if (ret < 0) { + gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, + RDMA_MSG_PROC_IOQ_ENTRY_FAILED, + "failed to process reply ioq entry " + "to peer (%s)", + peer->trans->peerinfo.identifier); + } + } + + if (ret != 0) { + __gf_rdma_ioq_entry_free(entry); } + } else { + ret = 0; + } out: - return ret; + return ret; } - static int32_t -__gf_rdma_ioq_churn (gf_rdma_peer_t *peer) +__gf_rdma_ioq_churn(gf_rdma_peer_t *peer) { - gf_rdma_ioq_t *entry = NULL; - int32_t ret = 0; + gf_rdma_ioq_t *entry = NULL; + int32_t ret = 0; - while (!list_empty (&peer->ioq)) { - /* pick next entry */ - entry = peer->ioq_next; + while (!list_empty(&peer->ioq)) { + /* pick next entry */ + entry = peer->ioq_next; - ret = __gf_rdma_ioq_churn_entry (peer, entry); + ret = __gf_rdma_ioq_churn_entry(peer, entry); - if (ret <= 0) - break; - } + if (ret <= 0) + break; + } - /* - list_for_each_entry_safe (entry, dummy, &peer->ioq, list) { - ret = __gf_rdma_ioq_churn_entry (peer, entry); - if (ret <= 0) { - break; - } - } - */ + /* + list_for_each_entry_safe (entry, dummy, &peer->ioq, list) { + ret = __gf_rdma_ioq_churn_entry (peer, entry); + if (ret <= 0) { + break; + } + } + */ - return ret; + return ret; } - static int32_t -gf_rdma_writev (rpc_transport_t *this, gf_rdma_ioq_t *entry) +gf_rdma_writev(rpc_transport_t *this, gf_rdma_ioq_t *entry) { - int32_t ret = 0, need_append = 1; - gf_rdma_private_t *priv = NULL; - gf_rdma_peer_t *peer = NULL; + int32_t ret = 0, need_append = 1; + gf_rdma_private_t *priv = NULL; + gf_rdma_peer_t *peer = NULL; - priv = this->private; - pthread_mutex_lock (&priv->write_mutex); - { - if (!priv->connected) { - gf_msg (this->name, GF_LOG_WARNING, 0, - RDMA_MSG_PEER_DISCONNECTED, - "rdma is not connected to peer (%s)", - this->peerinfo.identifier); - ret = -1; - goto unlock; - } + priv = this->private; + pthread_mutex_lock(&priv->write_mutex); + { + if (!priv->connected) { + gf_msg(this->name, GF_LOG_WARNING, 0, RDMA_MSG_PEER_DISCONNECTED, + "rdma is not connected to peer (%s)", + this->peerinfo.identifier); + ret = -1; + goto unlock; + } - peer = &priv->peer; - if (list_empty (&peer->ioq)) { - ret = __gf_rdma_ioq_churn_entry (peer, entry); - if (ret != 0) { - need_append = 0; - - if (ret < 0) { - gf_msg (this->name, GF_LOG_WARNING, 0, - RDMA_MSG_PROC_IOQ_ENTRY_FAILED, - "processing ioq entry destined" - " to (%s) failed", - this->peerinfo.identifier); - } - } - } + peer = &priv->peer; + if (list_empty(&peer->ioq)) { + ret = __gf_rdma_ioq_churn_entry(peer, entry); + if (ret != 0) { + need_append = 0; - if (need_append) { - list_add_tail (&entry->list, &peer->ioq); + if (ret < 0) { + gf_msg(this->name, GF_LOG_WARNING, 0, + RDMA_MSG_PROC_IOQ_ENTRY_FAILED, + "processing ioq entry destined" + " to (%s) failed", + this->peerinfo.identifier); } + } } + + if (need_append) { + list_add_tail(&entry->list, &peer->ioq); + } + } unlock: - pthread_mutex_unlock (&priv->write_mutex); - return ret; + pthread_mutex_unlock(&priv->write_mutex); + return ret; } - gf_rdma_ioq_t * -gf_rdma_ioq_new (rpc_transport_t *this, rpc_transport_data_t *data) +gf_rdma_ioq_new(rpc_transport_t *this, rpc_transport_data_t *data) { - gf_rdma_ioq_t *entry = NULL; - int count = 0, i = 0; - rpc_transport_msg_t *msg = NULL; - gf_rdma_private_t *priv = NULL; + gf_rdma_ioq_t *entry = NULL; + int count = 0, i = 0; + rpc_transport_msg_t *msg = NULL; + gf_rdma_private_t *priv = NULL; - if ((data == NULL) || (this == NULL)) { - goto out; - } + if ((data == NULL) || (this == NULL)) { + goto out; + } - priv = this->private; + priv = this->private; - entry = mem_get (priv->device->ioq_pool); - if (entry == NULL) { - goto out; - } - memset (entry, 0, sizeof (*entry)); - entry->pool = priv->device->ioq_pool; - - if (data->is_request) { - msg = &data->data.req.msg; - if (data->data.req.rsp.rsphdr_count != 0) { - for (i = 0; i < data->data.req.rsp.rsphdr_count; i++) { - entry->msg.request.rsphdr_vec[i] - = data->data.req.rsp.rsphdr[i]; - } + entry = mem_get(priv->device->ioq_pool); + if (entry == NULL) { + goto out; + } + memset(entry, 0, sizeof(*entry)); + entry->pool = priv->device->ioq_pool; - entry->msg.request.rsphdr_count = - data->data.req.rsp.rsphdr_count; - } + if (data->is_request) { + msg = &data->data.req.msg; + if (data->data.req.rsp.rsphdr_count != 0) { + for (i = 0; i < data->data.req.rsp.rsphdr_count; i++) { + entry->msg.request.rsphdr_vec[i] = data->data.req.rsp.rsphdr[i]; + } - if (data->data.req.rsp.rsp_payload_count != 0) { - for (i = 0; i < data->data.req.rsp.rsp_payload_count; - i++) { - entry->msg.request.rsp_payload[i] - = data->data.req.rsp.rsp_payload[i]; - } + entry->msg.request.rsphdr_count = data->data.req.rsp.rsphdr_count; + } - entry->msg.request.rsp_payload_count = - data->data.req.rsp.rsp_payload_count; - } + if (data->data.req.rsp.rsp_payload_count != 0) { + for (i = 0; i < data->data.req.rsp.rsp_payload_count; i++) { + entry->msg.request.rsp_payload[i] = data->data.req.rsp + .rsp_payload[i]; + } - entry->msg.request.rpc_req = data->data.req.rpc_req; + entry->msg.request.rsp_payload_count = data->data.req.rsp + .rsp_payload_count; + } - if (data->data.req.rsp.rsp_iobref != NULL) { - entry->msg.request.rsp_iobref - = iobref_ref (data->data.req.rsp.rsp_iobref); - } - } else { - msg = &data->data.reply.msg; - entry->msg.reply_info = data->data.reply.private; + entry->msg.request.rpc_req = data->data.req.rpc_req; + + if (data->data.req.rsp.rsp_iobref != NULL) { + entry->msg.request.rsp_iobref = iobref_ref( + data->data.req.rsp.rsp_iobref); } + } else { + msg = &data->data.reply.msg; + entry->msg.reply_info = data->data.reply.private; + } - entry->is_request = data->is_request; + entry->is_request = data->is_request; - count = msg->rpchdrcount + msg->proghdrcount + msg->progpayloadcount; + count = msg->rpchdrcount + msg->proghdrcount + msg->progpayloadcount; - GF_ASSERT (count <= MAX_IOVEC); + GF_ASSERT(count <= MAX_IOVEC); - if (msg->rpchdr != NULL) { - memcpy (&entry->rpchdr[0], msg->rpchdr, - sizeof (struct iovec) * msg->rpchdrcount); - entry->rpchdr_count = msg->rpchdrcount; - } + if (msg->rpchdr != NULL) { + memcpy(&entry->rpchdr[0], msg->rpchdr, + sizeof(struct iovec) * msg->rpchdrcount); + entry->rpchdr_count = msg->rpchdrcount; + } - if (msg->proghdr != NULL) { - memcpy (&entry->proghdr[0], msg->proghdr, - sizeof (struct iovec) * msg->proghdrcount); - entry->proghdr_count = msg->proghdrcount; - } + if (msg->proghdr != NULL) { + memcpy(&entry->proghdr[0], msg->proghdr, + sizeof(struct iovec) * msg->proghdrcount); + entry->proghdr_count = msg->proghdrcount; + } - if (msg->progpayload != NULL) { - memcpy (&entry->prog_payload[0], msg->progpayload, - sizeof (struct iovec) * msg->progpayloadcount); - entry->prog_payload_count = msg->progpayloadcount; - } + if (msg->progpayload != NULL) { + memcpy(&entry->prog_payload[0], msg->progpayload, + sizeof(struct iovec) * msg->progpayloadcount); + entry->prog_payload_count = msg->progpayloadcount; + } - if (msg->iobref != NULL) { - entry->iobref = iobref_ref (msg->iobref); - } + if (msg->iobref != NULL) { + entry->iobref = iobref_ref(msg->iobref); + } - INIT_LIST_HEAD (&entry->list); + INIT_LIST_HEAD(&entry->list); out: - return entry; + return entry; } - int32_t -gf_rdma_submit_request (rpc_transport_t *this, rpc_transport_req_t *req) +gf_rdma_submit_request(rpc_transport_t *this, rpc_transport_req_t *req) { - int32_t ret = 0; - gf_rdma_ioq_t *entry = NULL; - rpc_transport_data_t data = {0, }; - gf_rdma_private_t *priv = NULL; - gf_rdma_peer_t *peer = NULL; - - if (req == NULL) { - goto out; - } - - priv = this->private; - if (priv == NULL) { - ret = -1; - goto out; - } - - peer = &priv->peer; - data.is_request = 1; - data.data.req = *req; -/* - * when fist message is received on a transport, quota variable will - * initiaize and quota_set will set to one. In gluster code client - * process with respect to transport is the one who sends the first - * message. Before settng quota_set variable if a submit request is - * came on server, then the message should not send. - */ - - if (priv->entity == GF_RDMA_SERVER && peer->quota_set == 0) { - ret = 0; - goto out; - } + int32_t ret = 0; + gf_rdma_ioq_t *entry = NULL; + rpc_transport_data_t data = { + 0, + }; + gf_rdma_private_t *priv = NULL; + gf_rdma_peer_t *peer = NULL; + + if (req == NULL) { + goto out; + } + + priv = this->private; + if (priv == NULL) { + ret = -1; + goto out; + } + + peer = &priv->peer; + data.is_request = 1; + data.data.req = *req; + /* + * when fist message is received on a transport, quota variable will + * initiaize and quota_set will set to one. In gluster code client + * process with respect to transport is the one who sends the first + * message. Before settng quota_set variable if a submit request is + * came on server, then the message should not send. + */ + + if (priv->entity == GF_RDMA_SERVER && peer->quota_set == 0) { + ret = 0; + goto out; + } - entry = gf_rdma_ioq_new (this, &data); - if (entry == NULL) { - gf_msg (this->name, GF_LOG_WARNING, 0, - RDMA_MSG_NEW_IOQ_ENTRY_FAILED, - "getting a new ioq entry failed (peer:%s)", - this->peerinfo.identifier); - goto out; - } + entry = gf_rdma_ioq_new(this, &data); + if (entry == NULL) { + gf_msg(this->name, GF_LOG_WARNING, 0, RDMA_MSG_NEW_IOQ_ENTRY_FAILED, + "getting a new ioq entry failed (peer:%s)", + this->peerinfo.identifier); + goto out; + } - ret = gf_rdma_writev (this, entry); + ret = gf_rdma_writev(this, entry); - if (ret > 0) { - ret = 0; - } else if (ret < 0) { - gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, - RDMA_MSG_WRITE_PEER_FAILED, - "sending request to peer (%s) failed", - this->peerinfo.identifier); - rpc_transport_disconnect (this, _gf_false); - } + if (ret > 0) { + ret = 0; + } else if (ret < 0) { + gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, RDMA_MSG_WRITE_PEER_FAILED, + "sending request to peer (%s) failed", + this->peerinfo.identifier); + rpc_transport_disconnect(this, _gf_false); + } out: - return ret; + return ret; } int32_t -gf_rdma_submit_reply (rpc_transport_t *this, rpc_transport_reply_t *reply) +gf_rdma_submit_reply(rpc_transport_t *this, rpc_transport_reply_t *reply) { - int32_t ret = 0; - gf_rdma_ioq_t *entry = NULL; - rpc_transport_data_t data = {0, }; - - if (reply == NULL) { - goto out; - } - - data.data.reply = *reply; - - entry = gf_rdma_ioq_new (this, &data); - if (entry == NULL) { - gf_msg (this->name, GF_LOG_WARNING, 0, - RDMA_MSG_NEW_IOQ_ENTRY_FAILED, - "getting a new ioq entry failed (peer:%s)", - this->peerinfo.identifier); - goto out; - } - - ret = gf_rdma_writev (this, entry); - if (ret > 0) { - ret = 0; - } else if (ret < 0) { - gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, - RDMA_MSG_WRITE_PEER_FAILED, - "sending request to peer (%s) failed", - this->peerinfo.identifier); - rpc_transport_disconnect (this, _gf_false); - } + int32_t ret = 0; + gf_rdma_ioq_t *entry = NULL; + rpc_transport_data_t data = { + 0, + }; + + if (reply == NULL) { + goto out; + } + + data.data.reply = *reply; + + entry = gf_rdma_ioq_new(this, &data); + if (entry == NULL) { + gf_msg(this->name, GF_LOG_WARNING, 0, RDMA_MSG_NEW_IOQ_ENTRY_FAILED, + "getting a new ioq entry failed (peer:%s)", + this->peerinfo.identifier); + goto out; + } + + ret = gf_rdma_writev(this, entry); + if (ret > 0) { + ret = 0; + } else if (ret < 0) { + gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, RDMA_MSG_WRITE_PEER_FAILED, + "sending request to peer (%s) failed", + this->peerinfo.identifier); + rpc_transport_disconnect(this, _gf_false); + } out: - return ret; + return ret; } - static int -gf_rdma_register_peer (gf_rdma_device_t *device, int32_t qp_num, - gf_rdma_peer_t *peer) +gf_rdma_register_peer(gf_rdma_device_t *device, int32_t qp_num, + gf_rdma_peer_t *peer) { - struct _qpent *ent = NULL; - gf_rdma_qpreg_t *qpreg = NULL; - int32_t hash = 0; - int ret = -1; + struct _qpent *ent = NULL; + gf_rdma_qpreg_t *qpreg = NULL; + int32_t hash = 0; + int ret = -1; - qpreg = &device->qpreg; - hash = qp_num % 42; + qpreg = &device->qpreg; + hash = qp_num % 42; - pthread_mutex_lock (&qpreg->lock); - { - ent = qpreg->ents[hash].next; - while ((ent != &qpreg->ents[hash]) && (ent->qp_num != qp_num)) { - ent = ent->next; - } - - if (ent->qp_num == qp_num) { - ret = 0; - goto unlock; - } + pthread_mutex_lock(&qpreg->lock); + { + ent = qpreg->ents[hash].next; + while ((ent != &qpreg->ents[hash]) && (ent->qp_num != qp_num)) { + ent = ent->next; + } - ent = (struct _qpent *) GF_CALLOC (1, sizeof (*ent), - gf_common_mt_qpent); - if (ent == NULL) { - goto unlock; - } + if (ent->qp_num == qp_num) { + ret = 0; + goto unlock; + } - /* TODO: ref reg->peer */ - ent->peer = peer; - ent->next = &qpreg->ents[hash]; - ent->prev = ent->next->prev; - ent->next->prev = ent; - ent->prev->next = ent; - ent->qp_num = qp_num; - qpreg->count++; - ret = 0; + ent = (struct _qpent *)GF_CALLOC(1, sizeof(*ent), gf_common_mt_qpent); + if (ent == NULL) { + goto unlock; } + + /* TODO: ref reg->peer */ + ent->peer = peer; + ent->next = &qpreg->ents[hash]; + ent->prev = ent->next->prev; + ent->next->prev = ent; + ent->prev->next = ent; + ent->qp_num = qp_num; + qpreg->count++; + ret = 0; + } unlock: - pthread_mutex_unlock (&qpreg->lock); + pthread_mutex_unlock(&qpreg->lock); - return ret; + return ret; } - static void -gf_rdma_unregister_peer (gf_rdma_device_t *device, int32_t qp_num) +gf_rdma_unregister_peer(gf_rdma_device_t *device, int32_t qp_num) { - struct _qpent *ent = NULL; - gf_rdma_qpreg_t *qpreg = NULL; - int32_t hash = 0; + struct _qpent *ent = NULL; + gf_rdma_qpreg_t *qpreg = NULL; + int32_t hash = 0; - qpreg = &device->qpreg; - hash = qp_num % 42; + qpreg = &device->qpreg; + hash = qp_num % 42; - pthread_mutex_lock (&qpreg->lock); - { - ent = qpreg->ents[hash].next; - while ((ent != &qpreg->ents[hash]) && (ent->qp_num != qp_num)) - ent = ent->next; - if (ent->qp_num != qp_num) { - pthread_mutex_unlock (&qpreg->lock); - return; - } - ent->prev->next = ent->next; - ent->next->prev = ent->prev; - /* TODO: unref reg->peer */ - GF_FREE (ent); - qpreg->count--; - } - pthread_mutex_unlock (&qpreg->lock); + pthread_mutex_lock(&qpreg->lock); + { + ent = qpreg->ents[hash].next; + while ((ent != &qpreg->ents[hash]) && (ent->qp_num != qp_num)) + ent = ent->next; + if (ent->qp_num != qp_num) { + pthread_mutex_unlock(&qpreg->lock); + return; + } + ent->prev->next = ent->next; + ent->next->prev = ent->prev; + /* TODO: unref reg->peer */ + GF_FREE(ent); + qpreg->count--; + } + pthread_mutex_unlock(&qpreg->lock); } - static gf_rdma_peer_t * -__gf_rdma_lookup_peer (gf_rdma_device_t *device, int32_t qp_num) +__gf_rdma_lookup_peer(gf_rdma_device_t *device, int32_t qp_num) { - struct _qpent *ent = NULL; - gf_rdma_peer_t *peer = NULL; - gf_rdma_qpreg_t *qpreg = NULL; - int32_t hash = 0; - - qpreg = &device->qpreg; - hash = qp_num % 42; - ent = qpreg->ents[hash].next; - while ((ent != &qpreg->ents[hash]) && (ent->qp_num != qp_num)) - ent = ent->next; - - if (ent != &qpreg->ents[hash]) { - peer = ent->peer; - } - - return peer; + struct _qpent *ent = NULL; + gf_rdma_peer_t *peer = NULL; + gf_rdma_qpreg_t *qpreg = NULL; + int32_t hash = 0; + + qpreg = &device->qpreg; + hash = qp_num % 42; + ent = qpreg->ents[hash].next; + while ((ent != &qpreg->ents[hash]) && (ent->qp_num != qp_num)) + ent = ent->next; + + if (ent != &qpreg->ents[hash]) { + peer = ent->peer; + } + + return peer; } - static void -__gf_rdma_destroy_qp (rpc_transport_t *this) +__gf_rdma_destroy_qp(rpc_transport_t *this) { - gf_rdma_private_t *priv = NULL; + gf_rdma_private_t *priv = NULL; - priv = this->private; - if (priv->peer.qp) { - gf_rdma_unregister_peer (priv->device, priv->peer.qp->qp_num); - rdma_destroy_qp (priv->peer.cm_id); - } - priv->peer.qp = NULL; + priv = this->private; + if (priv->peer.qp) { + gf_rdma_unregister_peer(priv->device, priv->peer.qp->qp_num); + rdma_destroy_qp(priv->peer.cm_id); + } + priv->peer.qp = NULL; - return; + return; } - static int32_t -gf_rdma_create_qp (rpc_transport_t *this) +gf_rdma_create_qp(rpc_transport_t *this) { - gf_rdma_private_t *priv = NULL; - gf_rdma_device_t *device = NULL; - int32_t ret = 0; - gf_rdma_peer_t *peer = NULL; - char *device_name = NULL; - - priv = this->private; - - peer = &priv->peer; - - device_name = (char *)ibv_get_device_name (peer->cm_id->verbs->device); - if (device_name == NULL) { - ret = -1; - gf_msg (this->name, GF_LOG_WARNING, 0, - RDMA_MSG_GET_DEVICE_NAME_FAILED, "cannot get " - "device_name"); - goto out; - } - - device = gf_rdma_get_device (this, peer->cm_id->verbs, - device_name); - if (device == NULL) { - ret = -1; - gf_msg (this->name, GF_LOG_WARNING, 0, - RDMA_MSG_GET_DEVICE_FAILED, "cannot get device for " - "device %s", device_name); - goto out; - } - - if (priv->device == NULL) { - priv->device = device; - } - - struct ibv_qp_init_attr init_attr = { - .send_cq = device->send_cq, - .recv_cq = device->recv_cq, - .srq = device->srq, - .cap = { - .max_send_wr = peer->send_count, - .max_recv_wr = peer->recv_count, - .max_send_sge = 2, - .max_recv_sge = 1 - }, - .qp_type = IBV_QPT_RC - }; - - ret = rdma_create_qp(peer->cm_id, device->pd, &init_attr); - if (ret != 0) { - gf_msg (peer->trans->name, GF_LOG_CRITICAL, errno, - RDMA_MSG_CREAT_QP_FAILED, "%s: could not create QP", - this->name); - ret = -1; - goto out; - } - - peer->qp = peer->cm_id->qp; - - ret = gf_rdma_register_peer (device, peer->qp->qp_num, peer); + gf_rdma_private_t *priv = NULL; + gf_rdma_device_t *device = NULL; + int32_t ret = 0; + gf_rdma_peer_t *peer = NULL; + char *device_name = NULL; + + priv = this->private; + + peer = &priv->peer; + + device_name = (char *)ibv_get_device_name(peer->cm_id->verbs->device); + if (device_name == NULL) { + ret = -1; + gf_msg(this->name, GF_LOG_WARNING, 0, RDMA_MSG_GET_DEVICE_NAME_FAILED, + "cannot get " + "device_name"); + goto out; + } + + device = gf_rdma_get_device(this, peer->cm_id->verbs, device_name); + if (device == NULL) { + ret = -1; + gf_msg(this->name, GF_LOG_WARNING, 0, RDMA_MSG_GET_DEVICE_FAILED, + "cannot get device for " + "device %s", + device_name); + goto out; + } + + if (priv->device == NULL) { + priv->device = device; + } + + struct ibv_qp_init_attr init_attr = { + .send_cq = device->send_cq, + .recv_cq = device->recv_cq, + .srq = device->srq, + .cap = {.max_send_wr = peer->send_count, + .max_recv_wr = peer->recv_count, + .max_send_sge = 2, + .max_recv_sge = 1}, + .qp_type = IBV_QPT_RC}; + + ret = rdma_create_qp(peer->cm_id, device->pd, &init_attr); + if (ret != 0) { + gf_msg(peer->trans->name, GF_LOG_CRITICAL, errno, + RDMA_MSG_CREAT_QP_FAILED, "%s: could not create QP", this->name); + ret = -1; + goto out; + } + + peer->qp = peer->cm_id->qp; + + ret = gf_rdma_register_peer(device, peer->qp->qp_num, peer); out: - if (ret == -1) - __gf_rdma_destroy_qp (this); + if (ret == -1) + __gf_rdma_destroy_qp(this); - return ret; + return ret; } - static int32_t -__gf_rdma_teardown (rpc_transport_t *this) +__gf_rdma_teardown(rpc_transport_t *this) { - gf_rdma_private_t *priv = NULL; - gf_rdma_peer_t *peer = NULL; + gf_rdma_private_t *priv = NULL; + gf_rdma_peer_t *peer = NULL; - priv = this->private; - peer = &priv->peer; + priv = this->private; + peer = &priv->peer; - if (peer->cm_id && peer->cm_id->qp != NULL) { - __gf_rdma_destroy_qp (this); - } + if (peer->cm_id && peer->cm_id->qp != NULL) { + __gf_rdma_destroy_qp(this); + } - if (!list_empty (&priv->peer.ioq)) { - __gf_rdma_ioq_flush (peer); - } + if (!list_empty(&priv->peer.ioq)) { + __gf_rdma_ioq_flush(peer); + } - if (peer->cm_id != NULL) { - rdma_destroy_id (peer->cm_id); - peer->cm_id = NULL; - } + if (peer->cm_id != NULL) { + rdma_destroy_id(peer->cm_id); + peer->cm_id = NULL; + } - /* TODO: decrement cq size */ - return 0; + /* TODO: decrement cq size */ + return 0; } - static int32_t -gf_rdma_teardown (rpc_transport_t *this) +gf_rdma_teardown(rpc_transport_t *this) { - int32_t ret = 0; - gf_rdma_private_t *priv = NULL; + int32_t ret = 0; + gf_rdma_private_t *priv = NULL; - if (this == NULL) { - goto out; - } + if (this == NULL) { + goto out; + } - priv = this->private; + priv = this->private; - pthread_mutex_lock (&priv->write_mutex); - { - ret = __gf_rdma_teardown (this); - } - pthread_mutex_unlock (&priv->write_mutex); + pthread_mutex_lock(&priv->write_mutex); + { + ret = __gf_rdma_teardown(this); + } + pthread_mutex_unlock(&priv->write_mutex); out: - return ret; + return ret; } - /* * allocates new memory to hold write-chunklist. New memory is needed since * write-chunklist will be used while sending reply and the post holding initial @@ -3334,1756 +3201,1704 @@ out: * event is sent to upper layers. */ int32_t -gf_rdma_get_write_chunklist (char **ptr, gf_rdma_write_array_t **write_ary) +gf_rdma_get_write_chunklist(char **ptr, gf_rdma_write_array_t **write_ary) { - gf_rdma_write_array_t *from = NULL, *to = NULL; - int32_t ret = -1, size = 0, i = 0; - - from = (gf_rdma_write_array_t *) *ptr; - if (from->wc_discrim == 0) { - ret = 0; - goto out; - } - - from->wc_nchunks = ntoh32 (from->wc_nchunks); - - size = sizeof (*from) - + (sizeof (gf_rdma_write_chunk_t) * from->wc_nchunks); - - to = GF_CALLOC (1, size, gf_common_mt_char); - if (to == NULL) { - ret = -1; - goto out; - } - - to->wc_discrim = ntoh32 (from->wc_discrim); - to->wc_nchunks = from->wc_nchunks; + gf_rdma_write_array_t *from = NULL, *to = NULL; + int32_t ret = -1, size = 0, i = 0; - for (i = 0; i < to->wc_nchunks; i++) { - to->wc_array[i].wc_target.rs_handle - = ntoh32 (from->wc_array[i].wc_target.rs_handle); - to->wc_array[i].wc_target.rs_length - = ntoh32 (from->wc_array[i].wc_target.rs_length); - to->wc_array[i].wc_target.rs_offset - = ntoh64 (from->wc_array[i].wc_target.rs_offset); - } - - *write_ary = to; + from = (gf_rdma_write_array_t *)*ptr; + if (from->wc_discrim == 0) { ret = 0; - *ptr = (char *)&from->wc_array[i].wc_target.rs_handle; + goto out; + } + + from->wc_nchunks = ntoh32(from->wc_nchunks); + + size = sizeof(*from) + (sizeof(gf_rdma_write_chunk_t) * from->wc_nchunks); + + to = GF_CALLOC(1, size, gf_common_mt_char); + if (to == NULL) { + ret = -1; + goto out; + } + + to->wc_discrim = ntoh32(from->wc_discrim); + to->wc_nchunks = from->wc_nchunks; + + for (i = 0; i < to->wc_nchunks; i++) { + to->wc_array[i].wc_target.rs_handle = ntoh32( + from->wc_array[i].wc_target.rs_handle); + to->wc_array[i].wc_target.rs_length = ntoh32( + from->wc_array[i].wc_target.rs_length); + to->wc_array[i].wc_target.rs_offset = ntoh64( + from->wc_array[i].wc_target.rs_offset); + } + + *write_ary = to; + ret = 0; + *ptr = (char *)&from->wc_array[i].wc_target.rs_handle; out: - return ret; + return ret; } - /* * does not allocate new memory to hold read-chunklist. New memory is not * needed, since post is not put back to srq till we've completed all the * rdma-reads and hence readchunk-list can point to memory held by post. */ int32_t -gf_rdma_get_read_chunklist (char **ptr, gf_rdma_read_chunk_t **readch) +gf_rdma_get_read_chunklist(char **ptr, gf_rdma_read_chunk_t **readch) { - int32_t ret = -1; - gf_rdma_read_chunk_t *chunk = NULL; - int i = 0; - - chunk = (gf_rdma_read_chunk_t *)*ptr; - if (chunk[0].rc_discrim == 0) { - ret = 0; - goto out; - } + int32_t ret = -1; + gf_rdma_read_chunk_t *chunk = NULL; + int i = 0; - for (i = 0; chunk[i].rc_discrim != 0; i++) { - chunk[i].rc_discrim = ntoh32 (chunk[i].rc_discrim); - chunk[i].rc_position = ntoh32 (chunk[i].rc_position); - chunk[i].rc_target.rs_handle - = ntoh32 (chunk[i].rc_target.rs_handle); - chunk[i].rc_target.rs_length - = ntoh32 (chunk[i].rc_target.rs_length); - chunk[i].rc_target.rs_offset - = ntoh64 (chunk[i].rc_target.rs_offset); - } - - *readch = &chunk[0]; + chunk = (gf_rdma_read_chunk_t *)*ptr; + if (chunk[0].rc_discrim == 0) { ret = 0; - *ptr = (char *)&chunk[i].rc_discrim; + goto out; + } + + for (i = 0; chunk[i].rc_discrim != 0; i++) { + chunk[i].rc_discrim = ntoh32(chunk[i].rc_discrim); + chunk[i].rc_position = ntoh32(chunk[i].rc_position); + chunk[i].rc_target.rs_handle = ntoh32(chunk[i].rc_target.rs_handle); + chunk[i].rc_target.rs_length = ntoh32(chunk[i].rc_target.rs_length); + chunk[i].rc_target.rs_offset = ntoh64(chunk[i].rc_target.rs_offset); + } + + *readch = &chunk[0]; + ret = 0; + *ptr = (char *)&chunk[i].rc_discrim; out: - return ret; + return ret; } - static int32_t -gf_rdma_decode_error_msg (gf_rdma_peer_t *peer, gf_rdma_post_t *post, - size_t bytes_in_post) +gf_rdma_decode_error_msg(gf_rdma_peer_t *peer, gf_rdma_post_t *post, + size_t bytes_in_post) { - gf_rdma_header_t *header = NULL; - struct iobuf *iobuf = NULL; - struct iobref *iobref = NULL; - int32_t ret = -1; - struct rpc_msg rpc_msg = {0, }; - - header = (gf_rdma_header_t *)post->buf; - header->rm_body.rm_error.rm_type - = ntoh32 (header->rm_body.rm_error.rm_type); - if (header->rm_body.rm_error.rm_type == ERR_VERS) { - header->rm_body.rm_error.rm_version.gf_rdma_vers_low = - ntoh32 (header->rm_body.rm_error.rm_version.gf_rdma_vers_low); - header->rm_body.rm_error.rm_version.gf_rdma_vers_high = - ntoh32 (header->rm_body.rm_error.rm_version.gf_rdma_vers_high); - } - - rpc_msg.rm_xid = header->rm_xid; - rpc_msg.rm_direction = REPLY; - rpc_msg.rm_reply.rp_stat = MSG_DENIED; - - iobuf = iobuf_get2 (peer->trans->ctx->iobuf_pool, bytes_in_post); - if (iobuf == NULL) { - ret = -1; - goto out; - } - - post->ctx.iobref = iobref = iobref_new (); - if (iobref == NULL) { - ret = -1; - goto out; - } - - iobref_add (iobref, iobuf); - iobuf_unref (iobuf); - - ret = rpc_reply_to_xdr (&rpc_msg, iobuf_ptr (iobuf), - iobuf_pagesize (iobuf), &post->ctx.vector[0]); - if (ret == -1) { - gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, - RDMA_MSG_RPC_REPLY_CREATE_FAILED, "Failed to create " - "RPC reply"); - goto out; - } - - post->ctx.count = 1; - - iobuf = NULL; - iobref = NULL; + gf_rdma_header_t *header = NULL; + struct iobuf *iobuf = NULL; + struct iobref *iobref = NULL; + int32_t ret = -1; + struct rpc_msg rpc_msg = { + 0, + }; + + header = (gf_rdma_header_t *)post->buf; + header->rm_body.rm_error.rm_type = ntoh32(header->rm_body.rm_error.rm_type); + if (header->rm_body.rm_error.rm_type == ERR_VERS) { + header->rm_body.rm_error.rm_version.gf_rdma_vers_low = ntoh32( + header->rm_body.rm_error.rm_version.gf_rdma_vers_low); + header->rm_body.rm_error.rm_version.gf_rdma_vers_high = ntoh32( + header->rm_body.rm_error.rm_version.gf_rdma_vers_high); + } + + rpc_msg.rm_xid = header->rm_xid; + rpc_msg.rm_direction = REPLY; + rpc_msg.rm_reply.rp_stat = MSG_DENIED; + + iobuf = iobuf_get2(peer->trans->ctx->iobuf_pool, bytes_in_post); + if (iobuf == NULL) { + ret = -1; + goto out; + } + + post->ctx.iobref = iobref = iobref_new(); + if (iobref == NULL) { + ret = -1; + goto out; + } + + iobref_add(iobref, iobuf); + iobuf_unref(iobuf); + + ret = rpc_reply_to_xdr(&rpc_msg, iobuf_ptr(iobuf), iobuf_pagesize(iobuf), + &post->ctx.vector[0]); + if (ret == -1) { + gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, + RDMA_MSG_RPC_REPLY_CREATE_FAILED, + "Failed to create " + "RPC reply"); + goto out; + } + + post->ctx.count = 1; + + iobuf = NULL; + iobref = NULL; out: - if (ret == -1) { - if (iobuf != NULL) { - iobuf_unref (iobuf); - } + if (ret == -1) { + if (iobuf != NULL) { + iobuf_unref(iobuf); + } - if (iobref != NULL) { - iobref_unref (iobref); - } + if (iobref != NULL) { + iobref_unref(iobref); } + } - return 0; + return 0; } - int32_t -gf_rdma_decode_msg (gf_rdma_peer_t *peer, gf_rdma_post_t *post, - gf_rdma_read_chunk_t **readch, size_t bytes_in_post) +gf_rdma_decode_msg(gf_rdma_peer_t *peer, gf_rdma_post_t *post, + gf_rdma_read_chunk_t **readch, size_t bytes_in_post) { - int32_t ret = -1; - gf_rdma_header_t *header = NULL; - gf_rdma_reply_info_t *reply_info = NULL; - char *ptr = NULL; - gf_rdma_write_array_t *write_ary = NULL; - size_t header_len = 0; - - header = (gf_rdma_header_t *)post->buf; - - ptr = (char *)&header->rm_body.rm_chunks[0]; - - ret = gf_rdma_get_read_chunklist (&ptr, readch); - if (ret == -1) { - gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, - RDMA_MSG_GET_READ_CHUNK_FAILED, "cannot get read " - "chunklist from msg"); - goto out; + int32_t ret = -1; + gf_rdma_header_t *header = NULL; + gf_rdma_reply_info_t *reply_info = NULL; + char *ptr = NULL; + gf_rdma_write_array_t *write_ary = NULL; + size_t header_len = 0; + + header = (gf_rdma_header_t *)post->buf; + + ptr = (char *)&header->rm_body.rm_chunks[0]; + + ret = gf_rdma_get_read_chunklist(&ptr, readch); + if (ret == -1) { + gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, + RDMA_MSG_GET_READ_CHUNK_FAILED, + "cannot get read " + "chunklist from msg"); + goto out; + } + + /* skip terminator of read-chunklist */ + ptr = ptr + sizeof(uint32_t); + + ret = gf_rdma_get_write_chunklist(&ptr, &write_ary); + if (ret == -1) { + gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, + RDMA_MSG_GET_WRITE_CHUNK_FAILED, + "cannot get write " + "chunklist from msg"); + goto out; + } + + /* skip terminator of write-chunklist */ + ptr = ptr + sizeof(uint32_t); + + if (write_ary != NULL) { + reply_info = gf_rdma_reply_info_alloc(peer); + if (reply_info == NULL) { + gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, + RDMA_MSG_REPLY_INFO_ALLOC_FAILED, "reply_info_alloc failed"); + ret = -1; + goto out; } - /* skip terminator of read-chunklist */ - ptr = ptr + sizeof (uint32_t); - - ret = gf_rdma_get_write_chunklist (&ptr, &write_ary); + reply_info->type = gf_rdma_writech; + reply_info->wc_array = write_ary; + reply_info->rm_xid = header->rm_xid; + } else { + ret = gf_rdma_get_write_chunklist(&ptr, &write_ary); if (ret == -1) { - gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, - RDMA_MSG_GET_WRITE_CHUNK_FAILED, "cannot get write " - "chunklist from msg"); - goto out; + gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, + RDMA_MSG_CHUNKLIST_ERROR, + "cannot get reply " + "chunklist from msg"); + goto out; } - /* skip terminator of write-chunklist */ - ptr = ptr + sizeof (uint32_t); - if (write_ary != NULL) { - reply_info = gf_rdma_reply_info_alloc (peer); - if (reply_info == NULL) { - gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, - RDMA_MSG_REPLY_INFO_ALLOC_FAILED, - "reply_info_alloc failed"); - ret = -1; - goto out; - } - - reply_info->type = gf_rdma_writech; - reply_info->wc_array = write_ary; - reply_info->rm_xid = header->rm_xid; - } else { - ret = gf_rdma_get_write_chunklist (&ptr, &write_ary); - if (ret == -1) { - gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, - RDMA_MSG_CHUNKLIST_ERROR, "cannot get reply " - "chunklist from msg"); - goto out; - } - - if (write_ary != NULL) { - reply_info = gf_rdma_reply_info_alloc (peer); - if (reply_info == NULL) { - gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, - RDMA_MSG_REPLY_INFO_ALLOC_FAILED, - "reply_info_alloc_failed"); - ret = -1; - goto out; - } + reply_info = gf_rdma_reply_info_alloc(peer); + if (reply_info == NULL) { + gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, + RDMA_MSG_REPLY_INFO_ALLOC_FAILED, + "reply_info_alloc_failed"); + ret = -1; + goto out; + } - reply_info->type = gf_rdma_replych; - reply_info->wc_array = write_ary; - reply_info->rm_xid = header->rm_xid; - } + reply_info->type = gf_rdma_replych; + reply_info->wc_array = write_ary; + reply_info->rm_xid = header->rm_xid; } + } - /* skip terminator of reply chunk */ - ptr = ptr + sizeof (uint32_t); - if (header->rm_type != GF_RDMA_NOMSG) { - header_len = (long)ptr - (long)post->buf; - post->ctx.vector[0].iov_len = (bytes_in_post - header_len); - - post->ctx.hdr_iobuf = iobuf_get2 (peer->trans->ctx->iobuf_pool, - (bytes_in_post - header_len)); - if (post->ctx.hdr_iobuf == NULL) { - ret = -1; - goto out; - } + /* skip terminator of reply chunk */ + ptr = ptr + sizeof(uint32_t); + if (header->rm_type != GF_RDMA_NOMSG) { + header_len = (long)ptr - (long)post->buf; + post->ctx.vector[0].iov_len = (bytes_in_post - header_len); - post->ctx.vector[0].iov_base = iobuf_ptr (post->ctx.hdr_iobuf); - memcpy (post->ctx.vector[0].iov_base, ptr, - post->ctx.vector[0].iov_len); - post->ctx.count = 1; + post->ctx.hdr_iobuf = iobuf_get2(peer->trans->ctx->iobuf_pool, + (bytes_in_post - header_len)); + if (post->ctx.hdr_iobuf == NULL) { + ret = -1; + goto out; } - post->ctx.reply_info = reply_info; -out: - if (ret == -1) { - if (*readch != NULL) { - GF_FREE (*readch); - *readch = NULL; - } + post->ctx.vector[0].iov_base = iobuf_ptr(post->ctx.hdr_iobuf); + memcpy(post->ctx.vector[0].iov_base, ptr, post->ctx.vector[0].iov_len); + post->ctx.count = 1; + } - GF_FREE (write_ary); + post->ctx.reply_info = reply_info; +out: + if (ret == -1) { + if (*readch != NULL) { + GF_FREE(*readch); + *readch = NULL; } - return ret; -} + GF_FREE(write_ary); + } + return ret; +} /* Assumes only one of either write-chunklist or a reply chunk is present */ int32_t -gf_rdma_decode_header (gf_rdma_peer_t *peer, gf_rdma_post_t *post, - gf_rdma_read_chunk_t **readch, size_t bytes_in_post) +gf_rdma_decode_header(gf_rdma_peer_t *peer, gf_rdma_post_t *post, + gf_rdma_read_chunk_t **readch, size_t bytes_in_post) { - int32_t ret = -1; - gf_rdma_header_t *header = NULL; + int32_t ret = -1; + gf_rdma_header_t *header = NULL; - header = (gf_rdma_header_t *)post->buf; + header = (gf_rdma_header_t *)post->buf; - header->rm_xid = ntoh32 (header->rm_xid); - header->rm_vers = ntoh32 (header->rm_vers); - header->rm_credit = ntoh32 (header->rm_credit); - header->rm_type = ntoh32 (header->rm_type); + header->rm_xid = ntoh32(header->rm_xid); + header->rm_vers = ntoh32(header->rm_vers); + header->rm_credit = ntoh32(header->rm_credit); + header->rm_type = ntoh32(header->rm_type); - switch (header->rm_type) { + switch (header->rm_type) { case GF_RDMA_MSG: case GF_RDMA_NOMSG: - ret = gf_rdma_decode_msg (peer, post, readch, bytes_in_post); - if (ret < 0) { - gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, - RDMA_MSG_ENCODE_ERROR, "cannot decode msg of " - "type (%d)", header->rm_type); - } + ret = gf_rdma_decode_msg(peer, post, readch, bytes_in_post); + if (ret < 0) { + gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, + RDMA_MSG_ENCODE_ERROR, + "cannot decode msg of " + "type (%d)", + header->rm_type); + } - break; + break; case GF_RDMA_MSGP: - gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, - RDMA_MSG_INVALID_ENTRY, "rdma msg of msg-type " - "GF_RDMA_MSGP should not have been received"); - ret = -1; - break; + gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, RDMA_MSG_INVALID_ENTRY, + "rdma msg of msg-type " + "GF_RDMA_MSGP should not have been received"); + ret = -1; + break; case GF_RDMA_DONE: - gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, - RDMA_MSG_INVALID_ENTRY, "rdma msg of msg-type " - "GF_RDMA_DONE should not have been received"); - ret = -1; - break; + gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, RDMA_MSG_INVALID_ENTRY, + "rdma msg of msg-type " + "GF_RDMA_DONE should not have been received"); + ret = -1; + break; case GF_RDMA_ERROR: - gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, - RDMA_MSG_RDMA_ERROR_RECEIVED, "received a msg of type" - " RDMA_ERROR"); - ret = gf_rdma_decode_error_msg (peer, post, bytes_in_post); - break; + gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, + RDMA_MSG_RDMA_ERROR_RECEIVED, + "received a msg of type" + " RDMA_ERROR"); + ret = gf_rdma_decode_error_msg(peer, post, bytes_in_post); + break; default: - gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, - RDMA_MSG_INVALID_ENTRY, "unknown rdma msg-type (%d)", - header->rm_type); - } + gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, RDMA_MSG_INVALID_ENTRY, + "unknown rdma msg-type (%d)", header->rm_type); + } - return ret; + return ret; } - int32_t -gf_rdma_do_reads (gf_rdma_peer_t *peer, gf_rdma_post_t *post, - gf_rdma_read_chunk_t *readch) +gf_rdma_do_reads(gf_rdma_peer_t *peer, gf_rdma_post_t *post, + gf_rdma_read_chunk_t *readch) { - int32_t ret = -1, i = 0, count = 0; - size_t size = 0; - char *ptr = NULL; - struct iobuf *iobuf = NULL; - gf_rdma_private_t *priv = NULL; - struct ibv_sge *list = NULL; - struct ibv_send_wr *wr = NULL, *bad_wr = NULL; - int total_ref = 0; - priv = peer->trans->private; - - for (i = 0; readch[i].rc_discrim != 0; i++) { - size += readch[i].rc_target.rs_length; - } - - if (i == 0) { - gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, - RDMA_MSG_INVALID_CHUNK_TYPE, "message type specified " - "as rdma-read but there are no rdma read-chunks " - "present"); - goto out; - } - - post->ctx.gf_rdma_reads = i; - i = 0; - iobuf = iobuf_get2 (peer->trans->ctx->iobuf_pool, size); - if (iobuf == NULL) { - goto out; - } - + int32_t ret = -1, i = 0, count = 0; + size_t size = 0; + char *ptr = NULL; + struct iobuf *iobuf = NULL; + gf_rdma_private_t *priv = NULL; + struct ibv_sge *list = NULL; + struct ibv_send_wr *wr = NULL, *bad_wr = NULL; + int total_ref = 0; + priv = peer->trans->private; + + for (i = 0; readch[i].rc_discrim != 0; i++) { + size += readch[i].rc_target.rs_length; + } + + if (i == 0) { + gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, RDMA_MSG_INVALID_CHUNK_TYPE, + "message type specified " + "as rdma-read but there are no rdma read-chunks " + "present"); + goto out; + } + + post->ctx.gf_rdma_reads = i; + i = 0; + iobuf = iobuf_get2(peer->trans->ctx->iobuf_pool, size); + if (iobuf == NULL) { + goto out; + } + + if (post->ctx.iobref == NULL) { + post->ctx.iobref = iobref_new(); if (post->ctx.iobref == NULL) { - post->ctx.iobref = iobref_new (); - if (post->ctx.iobref == NULL) { - iobuf_unref (iobuf); - iobuf = NULL; - goto out; - } + iobuf_unref(iobuf); + iobuf = NULL; + goto out; } + } - iobref_add (post->ctx.iobref, iobuf); - iobuf_unref (iobuf); + iobref_add(post->ctx.iobref, iobuf); + iobuf_unref(iobuf); - ptr = iobuf_ptr (iobuf); - iobuf = NULL; + ptr = iobuf_ptr(iobuf); + iobuf = NULL; - pthread_mutex_lock (&priv->write_mutex); - { - if (!priv->connected) { - gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, - RDMA_MSG_PEER_DISCONNECTED, "transport not " - "connected to peer (%s), not doing rdma reads", - peer->trans->peerinfo.identifier); - goto unlock; - } + pthread_mutex_lock(&priv->write_mutex); + { + if (!priv->connected) { + gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, + RDMA_MSG_PEER_DISCONNECTED, + "transport not " + "connected to peer (%s), not doing rdma reads", + peer->trans->peerinfo.identifier); + goto unlock; + } - list = GF_CALLOC (post->ctx.gf_rdma_reads, - sizeof (struct ibv_sge), gf_common_mt_sge); + list = GF_CALLOC(post->ctx.gf_rdma_reads, sizeof(struct ibv_sge), + gf_common_mt_sge); - if (list == NULL) { - errno = ENOMEM; - ret = -1; - goto unlock; - } - wr = GF_CALLOC (post->ctx.gf_rdma_reads, - sizeof (struct ibv_send_wr), gf_common_mt_wr); - if (wr == NULL) { - errno = ENOMEM; - ret = -1; - goto unlock; - } - for (i = 0; readch[i].rc_discrim != 0; i++) { - count = post->ctx.count++; - post->ctx.vector[count].iov_base = ptr; - post->ctx.vector[count].iov_len - = readch[i].rc_target.rs_length; - - ret = __gf_rdma_register_local_mr_for_rdma (peer, - &post->ctx.vector[count], 1, &post->ctx); - if (ret == -1) { - gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, - RDMA_MSG_MR_ALOC_FAILED, - "registering local memory" - " for rdma read failed"); - goto unlock; - } - - list[i].addr = (unsigned long) - post->ctx.vector[count].iov_base; - list[i].length = post->ctx.vector[count].iov_len; - list[i].lkey = - post->ctx.mr[post->ctx.mr_count - 1]->lkey; - - wr[i].wr_id = - (unsigned long) gf_rdma_post_ref (post); - wr[i].sg_list = &list[i]; - wr[i].next = &wr[i+1]; - wr[i].num_sge = 1; - wr[i].opcode = IBV_WR_RDMA_READ; - wr[i].send_flags = IBV_SEND_SIGNALED; - wr[i].wr.rdma.remote_addr = - readch[i].rc_target.rs_offset; - wr[i].wr.rdma.rkey = readch[i].rc_target.rs_handle; - - ptr += readch[i].rc_target.rs_length; - total_ref++; - } - wr[i-1].next = NULL; - ret = ibv_post_send (peer->qp, wr, &bad_wr); - if (ret) { - gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, - RDMA_MSG_READ_CLIENT_ERROR, "rdma read from " - "client (%s) failed with ret = %d (%s)", - peer->trans->peerinfo.identifier, - ret, (ret > 0) ? strerror (ret) : ""); - - if (!bad_wr) { - ret = -1; - goto unlock; - } - - for (i = 0; i < post->ctx.gf_rdma_reads; i++) { - if (&wr[i] != bad_wr) - total_ref--; - else - break; - } + if (list == NULL) { + errno = ENOMEM; + ret = -1; + goto unlock; + } + wr = GF_CALLOC(post->ctx.gf_rdma_reads, sizeof(struct ibv_send_wr), + gf_common_mt_wr); + if (wr == NULL) { + errno = ENOMEM; + ret = -1; + goto unlock; + } + for (i = 0; readch[i].rc_discrim != 0; i++) { + count = post->ctx.count++; + post->ctx.vector[count].iov_base = ptr; + post->ctx.vector[count].iov_len = readch[i].rc_target.rs_length; + + ret = __gf_rdma_register_local_mr_for_rdma( + peer, &post->ctx.vector[count], 1, &post->ctx); + if (ret == -1) { + gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, + RDMA_MSG_MR_ALOC_FAILED, + "registering local memory" + " for rdma read failed"); + goto unlock; + } + + list[i].addr = (unsigned long)post->ctx.vector[count].iov_base; + list[i].length = post->ctx.vector[count].iov_len; + list[i].lkey = post->ctx.mr[post->ctx.mr_count - 1]->lkey; + + wr[i].wr_id = (unsigned long)gf_rdma_post_ref(post); + wr[i].sg_list = &list[i]; + wr[i].next = &wr[i + 1]; + wr[i].num_sge = 1; + wr[i].opcode = IBV_WR_RDMA_READ; + wr[i].send_flags = IBV_SEND_SIGNALED; + wr[i].wr.rdma.remote_addr = readch[i].rc_target.rs_offset; + wr[i].wr.rdma.rkey = readch[i].rc_target.rs_handle; + + ptr += readch[i].rc_target.rs_length; + total_ref++; + } + wr[i - 1].next = NULL; + ret = ibv_post_send(peer->qp, wr, &bad_wr); + if (ret) { + gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, + RDMA_MSG_READ_CLIENT_ERROR, + "rdma read from " + "client (%s) failed with ret = %d (%s)", + peer->trans->peerinfo.identifier, ret, + (ret > 0) ? strerror(ret) : ""); + + if (!bad_wr) { + ret = -1; + goto unlock; + } - ret = -1; - } + for (i = 0; i < post->ctx.gf_rdma_reads; i++) { + if (&wr[i] != bad_wr) + total_ref--; + else + break; + } + ret = -1; } + } unlock: - pthread_mutex_unlock (&priv->write_mutex); + pthread_mutex_unlock(&priv->write_mutex); out: - if (list) - GF_FREE (list); - if (wr) - GF_FREE (wr); + if (list) + GF_FREE(list); + if (wr) + GF_FREE(wr); - if (ret == -1) { - while (total_ref-- > 0) - gf_rdma_post_unref (post); + if (ret == -1) { + while (total_ref-- > 0) + gf_rdma_post_unref(post); + } - } - - return ret; + return ret; } - int32_t -gf_rdma_pollin_notify (gf_rdma_peer_t *peer, gf_rdma_post_t *post) +gf_rdma_pollin_notify(gf_rdma_peer_t *peer, gf_rdma_post_t *post) { - int32_t ret = -1; - enum msg_type msg_type = 0; - struct rpc_req *rpc_req = NULL; - gf_rdma_request_context_t *request_context = NULL; - rpc_request_info_t request_info = {0, }; - gf_rdma_private_t *priv = NULL; - uint32_t *ptr = NULL; - rpc_transport_pollin_t *pollin = NULL; - - if ((peer == NULL) || (post == NULL)) { - goto out; - } - + int32_t ret = -1; + enum msg_type msg_type = 0; + struct rpc_req *rpc_req = NULL; + gf_rdma_request_context_t *request_context = NULL; + rpc_request_info_t request_info = { + 0, + }; + gf_rdma_private_t *priv = NULL; + uint32_t *ptr = NULL; + rpc_transport_pollin_t *pollin = NULL; + + if ((peer == NULL) || (post == NULL)) { + goto out; + } + + if (post->ctx.iobref == NULL) { + post->ctx.iobref = iobref_new(); if (post->ctx.iobref == NULL) { - post->ctx.iobref = iobref_new (); - if (post->ctx.iobref == NULL) { - goto out; - } - - /* handling the case where both hdr and payload of - * GF_FOP_READ_CBK were received in a single iobuf - * because of server sending entire msg as inline without - * doing rdma writes. - */ - if (post->ctx.hdr_iobuf) - iobref_add (post->ctx.iobref, post->ctx.hdr_iobuf); + goto out; } - pollin = rpc_transport_pollin_alloc (peer->trans, - post->ctx.vector, - post->ctx.count, - post->ctx.hdr_iobuf, - post->ctx.iobref, - post->ctx.reply_info); - if (pollin == NULL) { - goto out; - } + /* handling the case where both hdr and payload of + * GF_FOP_READ_CBK were received in a single iobuf + * because of server sending entire msg as inline without + * doing rdma writes. + */ + if (post->ctx.hdr_iobuf) + iobref_add(post->ctx.iobref, post->ctx.hdr_iobuf); + } - ptr = (uint32_t *)pollin->vector[0].iov_base; + pollin = rpc_transport_pollin_alloc(peer->trans, post->ctx.vector, + post->ctx.count, post->ctx.hdr_iobuf, + post->ctx.iobref, post->ctx.reply_info); + if (pollin == NULL) { + goto out; + } - request_info.xid = ntoh32 (*ptr); - msg_type = ntoh32 (*(ptr + 1)); + ptr = (uint32_t *)pollin->vector[0].iov_base; - if (msg_type == REPLY) { - ret = rpc_transport_notify (peer->trans, - RPC_TRANSPORT_MAP_XID_REQUEST, - &request_info); - if (ret == -1) { - gf_msg_debug (GF_RDMA_LOG_NAME, 0, "cannot get request" - "information from rpc layer"); - goto out; - } + request_info.xid = ntoh32(*ptr); + msg_type = ntoh32(*(ptr + 1)); - rpc_req = request_info.rpc_req; - if (rpc_req == NULL) { - gf_msg_debug (GF_RDMA_LOG_NAME, 0, "rpc request " - "structure not found"); - ret = -1; - goto out; - } + if (msg_type == REPLY) { + ret = rpc_transport_notify(peer->trans, RPC_TRANSPORT_MAP_XID_REQUEST, + &request_info); + if (ret == -1) { + gf_msg_debug(GF_RDMA_LOG_NAME, 0, + "cannot get request" + "information from rpc layer"); + goto out; + } - request_context = rpc_req->conn_private; - rpc_req->conn_private = NULL; + rpc_req = request_info.rpc_req; + if (rpc_req == NULL) { + gf_msg_debug(GF_RDMA_LOG_NAME, 0, + "rpc request " + "structure not found"); + ret = -1; + goto out; + } - priv = peer->trans->private; - if (request_context != NULL) { - pthread_mutex_lock (&priv->write_mutex); - { - __gf_rdma_request_context_destroy (request_context); - } - pthread_mutex_unlock (&priv->write_mutex); - } else { - gf_rdma_quota_put (peer); - } + request_context = rpc_req->conn_private; + rpc_req->conn_private = NULL; - pollin->is_reply = 1; + priv = peer->trans->private; + if (request_context != NULL) { + pthread_mutex_lock(&priv->write_mutex); + { + __gf_rdma_request_context_destroy(request_context); + } + pthread_mutex_unlock(&priv->write_mutex); + } else { + gf_rdma_quota_put(peer); } - ret = rpc_transport_notify (peer->trans, RPC_TRANSPORT_MSG_RECEIVED, - pollin); - if (ret < 0) { - gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, - TRANS_MSG_TRANSPORT_ERROR, "transport_notify failed"); - } + pollin->is_reply = 1; + } + + ret = rpc_transport_notify(peer->trans, RPC_TRANSPORT_MSG_RECEIVED, pollin); + if (ret < 0) { + gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, TRANS_MSG_TRANSPORT_ERROR, + "transport_notify failed"); + } out: - if (pollin != NULL) { - pollin->private = NULL; - rpc_transport_pollin_destroy (pollin); - } + if (pollin != NULL) { + pollin->private = NULL; + rpc_transport_pollin_destroy(pollin); + } - return ret; + return ret; } - int32_t -gf_rdma_recv_reply (gf_rdma_peer_t *peer, gf_rdma_post_t *post) +gf_rdma_recv_reply(gf_rdma_peer_t *peer, gf_rdma_post_t *post) { - int32_t ret = -1; - gf_rdma_header_t *header = NULL; - gf_rdma_reply_info_t *reply_info = NULL; - gf_rdma_write_array_t *wc_array = NULL; - int i = 0; - uint32_t *ptr = NULL; - gf_rdma_request_context_t *ctx = NULL; - rpc_request_info_t request_info = {0, }; - struct rpc_req *rpc_req = NULL; - - header = (gf_rdma_header_t *)post->buf; - reply_info = post->ctx.reply_info; - - /* no write chunklist, just notify upper layers */ - if (reply_info == NULL) { - ret = 0; - goto out; - } - - wc_array = reply_info->wc_array; - - if (header->rm_type == GF_RDMA_NOMSG) { - post->ctx.vector[0].iov_base - = (void *)(long)wc_array->wc_array[0].wc_target.rs_offset; - post->ctx.vector[0].iov_len - = wc_array->wc_array[0].wc_target.rs_length; - - post->ctx.count = 1; - } else { - for (i = 0; i < wc_array->wc_nchunks; i++) { - post->ctx.vector[i + 1].iov_base - = (void *)(long)wc_array->wc_array[i].wc_target.rs_offset; - post->ctx.vector[i + 1].iov_len - = wc_array->wc_array[i].wc_target.rs_length; - } - - post->ctx.count += wc_array->wc_nchunks; - } - - ptr = (uint32_t *)post->ctx.vector[0].iov_base; - request_info.xid = ntoh32 (*ptr); - - ret = rpc_transport_notify (peer->trans, - RPC_TRANSPORT_MAP_XID_REQUEST, - &request_info); - if (ret == -1) { - gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, - TRANS_MSG_TRANSPORT_ERROR, "cannot get request " - "information (peer:%s) from rpc layer", - peer->trans->peerinfo.identifier); - goto out; - } + int32_t ret = -1; + gf_rdma_header_t *header = NULL; + gf_rdma_reply_info_t *reply_info = NULL; + gf_rdma_write_array_t *wc_array = NULL; + int i = 0; + uint32_t *ptr = NULL; + gf_rdma_request_context_t *ctx = NULL; + rpc_request_info_t request_info = { + 0, + }; + struct rpc_req *rpc_req = NULL; + + header = (gf_rdma_header_t *)post->buf; + reply_info = post->ctx.reply_info; + + /* no write chunklist, just notify upper layers */ + if (reply_info == NULL) { + ret = 0; + goto out; + } - rpc_req = request_info.rpc_req; - if (rpc_req == NULL) { - gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, - RDMA_MSG_RPC_ST_ERROR, "rpc request structure not " - "found"); - ret = -1; - goto out; - } + wc_array = reply_info->wc_array; - ctx = rpc_req->conn_private; - if ((post->ctx.iobref == NULL) && ctx->rsp_iobref) { - post->ctx.iobref = iobref_ref (ctx->rsp_iobref); - } + if (header->rm_type == GF_RDMA_NOMSG) { + post->ctx.vector[0].iov_base = (void *)(long)wc_array->wc_array[0] + .wc_target.rs_offset; + post->ctx.vector[0].iov_len = wc_array->wc_array[0].wc_target.rs_length; - ret = 0; - - gf_rdma_reply_info_destroy (reply_info); + post->ctx.count = 1; + } else { + for (i = 0; i < wc_array->wc_nchunks; i++) { + post->ctx.vector[i + 1].iov_base = + (void *)(long)wc_array->wc_array[i].wc_target.rs_offset; + post->ctx.vector[i + 1].iov_len = wc_array->wc_array[i] + .wc_target.rs_length; + } + + post->ctx.count += wc_array->wc_nchunks; + } + + ptr = (uint32_t *)post->ctx.vector[0].iov_base; + request_info.xid = ntoh32(*ptr); + + ret = rpc_transport_notify(peer->trans, RPC_TRANSPORT_MAP_XID_REQUEST, + &request_info); + if (ret == -1) { + gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, TRANS_MSG_TRANSPORT_ERROR, + "cannot get request " + "information (peer:%s) from rpc layer", + peer->trans->peerinfo.identifier); + goto out; + } + + rpc_req = request_info.rpc_req; + if (rpc_req == NULL) { + gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, RDMA_MSG_RPC_ST_ERROR, + "rpc request structure not " + "found"); + ret = -1; + goto out; + } + + ctx = rpc_req->conn_private; + if ((post->ctx.iobref == NULL) && ctx->rsp_iobref) { + post->ctx.iobref = iobref_ref(ctx->rsp_iobref); + } + + ret = 0; + + gf_rdma_reply_info_destroy(reply_info); out: - if (ret == 0) { - ret = gf_rdma_pollin_notify (peer, post); - if (ret < 0) { - gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, - RDMA_MSG_POLL_IN_NOTIFY_FAILED, - "pollin notify failed"); - } + if (ret == 0) { + ret = gf_rdma_pollin_notify(peer, post); + if (ret < 0) { + gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, + RDMA_MSG_POLL_IN_NOTIFY_FAILED, "pollin notify failed"); } + } - return ret; + return ret; } - static int32_t -gf_rdma_recv_request (gf_rdma_peer_t *peer, gf_rdma_post_t *post, - gf_rdma_read_chunk_t *readch) +gf_rdma_recv_request(gf_rdma_peer_t *peer, gf_rdma_post_t *post, + gf_rdma_read_chunk_t *readch) { - int32_t ret = -1; + int32_t ret = -1; - if (readch != NULL) { - ret = gf_rdma_do_reads (peer, post, readch); - if (ret < 0) { - gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, - RDMA_MSG_PEER_READ_FAILED, - "rdma read from peer (%s) failed", - peer->trans->peerinfo.identifier); - } - } else { - ret = gf_rdma_pollin_notify (peer, post); - if (ret == -1) { - gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, - RDMA_MSG_POLL_IN_NOTIFY_FAILED, - "pollin notification failed"); - } + if (readch != NULL) { + ret = gf_rdma_do_reads(peer, post, readch); + if (ret < 0) { + gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, + RDMA_MSG_PEER_READ_FAILED, "rdma read from peer (%s) failed", + peer->trans->peerinfo.identifier); } + } else { + ret = gf_rdma_pollin_notify(peer, post); + if (ret == -1) { + gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, + RDMA_MSG_POLL_IN_NOTIFY_FAILED, + "pollin notification failed"); + } + } - return ret; + return ret; } void -gf_rdma_process_recv (gf_rdma_peer_t *peer, struct ibv_wc *wc) +gf_rdma_process_recv(gf_rdma_peer_t *peer, struct ibv_wc *wc) { - gf_rdma_post_t *post = NULL; - gf_rdma_read_chunk_t *readch = NULL; - int ret = -1; - uint32_t *ptr = NULL; - enum msg_type msg_type = 0; - gf_rdma_header_t *header = NULL; - gf_rdma_private_t *priv = NULL; - - post = (gf_rdma_post_t *) (long) wc->wr_id; - if (post == NULL) { - gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, - RDMA_MSG_POST_MISSING, "no post found in successful " - "work completion element"); - goto out; - } - - ret = gf_rdma_decode_header (peer, post, &readch, wc->byte_len); - if (ret == -1) { - gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, - RDMA_MSG_HEADER_DECODE_FAILED, "decoding of header " - "failed"); - goto out; - } - - header = (gf_rdma_header_t *)post->buf; - - priv = peer->trans->private; - - pthread_mutex_lock (&priv->write_mutex); - { - if (!priv->peer.quota_set) { - priv->peer.quota_set = 1; - - /* Initially peer.quota is set to 1 as per RFC 5666. We - * have to account for the quota used while sending - * first msg (which may or may not be returned to pool - * at this point) while deriving peer.quota from - * header->rm_credit. Hence the arithmetic below, - * instead of directly setting it to header->rm_credit. - */ - priv->peer.quota = header->rm_credit - - (1 - priv->peer.quota); - } - } - pthread_mutex_unlock (&priv->write_mutex); - - switch (header->rm_type) { + gf_rdma_post_t *post = NULL; + gf_rdma_read_chunk_t *readch = NULL; + int ret = -1; + uint32_t *ptr = NULL; + enum msg_type msg_type = 0; + gf_rdma_header_t *header = NULL; + gf_rdma_private_t *priv = NULL; + + post = (gf_rdma_post_t *)(long)wc->wr_id; + if (post == NULL) { + gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, RDMA_MSG_POST_MISSING, + "no post found in successful " + "work completion element"); + goto out; + } + + ret = gf_rdma_decode_header(peer, post, &readch, wc->byte_len); + if (ret == -1) { + gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, + RDMA_MSG_HEADER_DECODE_FAILED, + "decoding of header " + "failed"); + goto out; + } + + header = (gf_rdma_header_t *)post->buf; + + priv = peer->trans->private; + + pthread_mutex_lock(&priv->write_mutex); + { + if (!priv->peer.quota_set) { + priv->peer.quota_set = 1; + + /* Initially peer.quota is set to 1 as per RFC 5666. We + * have to account for the quota used while sending + * first msg (which may or may not be returned to pool + * at this point) while deriving peer.quota from + * header->rm_credit. Hence the arithmetic below, + * instead of directly setting it to header->rm_credit. + */ + priv->peer.quota = header->rm_credit - (1 - priv->peer.quota); + } + } + pthread_mutex_unlock(&priv->write_mutex); + + switch (header->rm_type) { case GF_RDMA_MSG: - ptr = (uint32_t *)post->ctx.vector[0].iov_base; - msg_type = ntoh32 (*(ptr + 1)); - break; + ptr = (uint32_t *)post->ctx.vector[0].iov_base; + msg_type = ntoh32(*(ptr + 1)); + break; case GF_RDMA_NOMSG: - if (readch != NULL) { - msg_type = CALL; - } else { - msg_type = REPLY; - } - break; + if (readch != NULL) { + msg_type = CALL; + } else { + msg_type = REPLY; + } + break; case GF_RDMA_ERROR: - if (header->rm_body.rm_error.rm_type == ERR_CHUNK) { - gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, - RDMA_MSG_RDMA_ERROR_RECEIVED, - "peer (%s), couldn't encode or decode the msg " - "properly or write chunks were not provided " - "for replies that were bigger than " - "RDMA_INLINE_THRESHOLD (%d)", - peer->trans->peerinfo.identifier, - GLUSTERFS_RDMA_INLINE_THRESHOLD); - ret = gf_rdma_pollin_notify (peer, post); - if (ret == -1) { - gf_msg_debug (GF_RDMA_LOG_NAME, 0, "pollin " - "notification failed"); - } - goto out; - } else { - gf_msg (GF_RDMA_LOG_NAME, GF_LOG_ERROR, 0, - TRANS_MSG_TRANSPORT_ERROR, "an error has " - "happened while transmission of msg, " - "disconnecting the transport"); - ret = -1; - goto out; + if (header->rm_body.rm_error.rm_type == ERR_CHUNK) { + gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, + RDMA_MSG_RDMA_ERROR_RECEIVED, + "peer (%s), couldn't encode or decode the msg " + "properly or write chunks were not provided " + "for replies that were bigger than " + "RDMA_INLINE_THRESHOLD (%d)", + peer->trans->peerinfo.identifier, + GLUSTERFS_RDMA_INLINE_THRESHOLD); + ret = gf_rdma_pollin_notify(peer, post); + if (ret == -1) { + gf_msg_debug(GF_RDMA_LOG_NAME, 0, + "pollin " + "notification failed"); } + goto out; + } else { + gf_msg(GF_RDMA_LOG_NAME, GF_LOG_ERROR, 0, + TRANS_MSG_TRANSPORT_ERROR, + "an error has " + "happened while transmission of msg, " + "disconnecting the transport"); + ret = -1; + goto out; + } default: - gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, - RDMA_MSG_INVALID_ENTRY, "invalid rdma msg-type (%d)", - header->rm_type); - goto out; - } + gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, RDMA_MSG_INVALID_ENTRY, + "invalid rdma msg-type (%d)", header->rm_type); + goto out; + } - if (msg_type == CALL) { - ret = gf_rdma_recv_request (peer, post, readch); - if (ret < 0) { - gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, - RDMA_MSG_PEER_REQ_FAILED, "receiving a request" - " from peer (%s) failed", - peer->trans->peerinfo.identifier); - } - } else { - ret = gf_rdma_recv_reply (peer, post); - if (ret < 0) { - gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, - RDMA_MSG_PEER_REP_FAILED, "receiving a reply " - "from peer (%s) failed", - peer->trans->peerinfo.identifier); - } + if (msg_type == CALL) { + ret = gf_rdma_recv_request(peer, post, readch); + if (ret < 0) { + gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, + RDMA_MSG_PEER_REQ_FAILED, + "receiving a request" + " from peer (%s) failed", + peer->trans->peerinfo.identifier); + } + } else { + ret = gf_rdma_recv_reply(peer, post); + if (ret < 0) { + gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, + RDMA_MSG_PEER_REP_FAILED, + "receiving a reply " + "from peer (%s) failed", + peer->trans->peerinfo.identifier); } + } out: - if (ret == -1) { - rpc_transport_disconnect (peer->trans, _gf_false); - } + if (ret == -1) { + rpc_transport_disconnect(peer->trans, _gf_false); + } - return; + return; } void * -gf_rdma_async_event_thread (void *context) +gf_rdma_async_event_thread(void *context) { - struct ibv_async_event event; - int ret; - - while (1) { - do { - ret = ibv_get_async_event((struct ibv_context *)context, - &event); - - if (ret && errno != EINTR) { - gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, errno, - RDMA_MSG_EVENT_ERROR, "Error getting " - "event"); - } - } while (ret && errno == EINTR); + struct ibv_async_event event; + int ret; - switch (event.event_type) { - case IBV_EVENT_SRQ_LIMIT_REACHED: - gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, - RDMA_MSG_EVENT_SRQ_LIMIT_REACHED, "received " - "srq_limit reached"); - break; - - default: - gf_msg_debug (GF_RDMA_LOG_NAME, 0, "event (%d) " - "received", event.event_type); - break; - } + while (1) { + do { + ret = ibv_get_async_event((struct ibv_context *)context, &event); + + if (ret && errno != EINTR) { + gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, errno, + RDMA_MSG_EVENT_ERROR, + "Error getting " + "event"); + } + } while (ret && errno == EINTR); + + switch (event.event_type) { + case IBV_EVENT_SRQ_LIMIT_REACHED: + gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, + RDMA_MSG_EVENT_SRQ_LIMIT_REACHED, + "received " + "srq_limit reached"); + break; - ibv_ack_async_event(&event); + default: + gf_msg_debug(GF_RDMA_LOG_NAME, 0, + "event (%d) " + "received", + event.event_type); + break; } - return 0; -} + ibv_ack_async_event(&event); + } + return 0; +} static void * -gf_rdma_recv_completion_proc (void *data) +gf_rdma_recv_completion_proc(void *data) { - struct ibv_comp_channel *chan = NULL; - gf_rdma_device_t *device = NULL;; - gf_rdma_post_t *post = NULL; - gf_rdma_peer_t *peer = NULL; - struct ibv_cq *event_cq = NULL; - struct ibv_wc wc[10] = {{0},}; - void *event_ctx = NULL; - int32_t ret = 0; - int32_t num_wr = 0, index = 0; - uint8_t failed = 0; - - chan = data; - - while (1) { - failed = 0; - ret = ibv_get_cq_event (chan, &event_cq, &event_ctx); - if (ret) { - gf_msg (GF_RDMA_LOG_NAME, GF_LOG_ERROR, errno, - RDMA_MSG_IBV_GET_CQ_FAILED, - "ibv_get_cq_event failed, terminating recv " - "thread %d (%d)", ret, errno); - continue; - } + struct ibv_comp_channel *chan = NULL; + gf_rdma_device_t *device = NULL; + ; + gf_rdma_post_t *post = NULL; + gf_rdma_peer_t *peer = NULL; + struct ibv_cq *event_cq = NULL; + struct ibv_wc wc[10] = { + {0}, + }; + void *event_ctx = NULL; + int32_t ret = 0; + int32_t num_wr = 0, index = 0; + uint8_t failed = 0; + + chan = data; + + while (1) { + failed = 0; + ret = ibv_get_cq_event(chan, &event_cq, &event_ctx); + if (ret) { + gf_msg(GF_RDMA_LOG_NAME, GF_LOG_ERROR, errno, + RDMA_MSG_IBV_GET_CQ_FAILED, + "ibv_get_cq_event failed, terminating recv " + "thread %d (%d)", + ret, errno); + continue; + } - device = event_ctx; + device = event_ctx; - ret = ibv_req_notify_cq (event_cq, 0); - if (ret) { - gf_msg (GF_RDMA_LOG_NAME, GF_LOG_ERROR, errno, - RDMA_MSG_IBV_REQ_NOTIFY_CQ_FAILED, - "ibv_req_notify_cq on %s failed, terminating " - "recv thread: %d (%d)", - device->device_name, ret, errno); - continue; - } + ret = ibv_req_notify_cq(event_cq, 0); + if (ret) { + gf_msg(GF_RDMA_LOG_NAME, GF_LOG_ERROR, errno, + RDMA_MSG_IBV_REQ_NOTIFY_CQ_FAILED, + "ibv_req_notify_cq on %s failed, terminating " + "recv thread: %d (%d)", + device->device_name, ret, errno); + continue; + } - device = (gf_rdma_device_t *) event_ctx; - - while (!failed && - (num_wr = ibv_poll_cq (event_cq, 10, wc)) > 0) { - - for (index = 0; index < num_wr && !failed; index++) { - post = (gf_rdma_post_t *) (long) - wc[index].wr_id; - - pthread_mutex_lock (&device->qpreg.lock); - { - peer = __gf_rdma_lookup_peer (device, - wc[index].qp_num); - - /* - * keep a refcount on transport so that it - * does not get freed because of some error - * indicated by wc.status till we are done - * with usage of peer and thereby that of - * trans. - */ - if (peer != NULL) { - rpc_transport_ref (peer->trans); - } - } - pthread_mutex_unlock (&device->qpreg.lock); - - if (wc[index].status != IBV_WC_SUCCESS) { - gf_msg (GF_RDMA_LOG_NAME, - GF_LOG_ERROR, 0, - RDMA_MSG_RECV_ERROR, "recv work " - "request on `%s' returned error (%d)", - device->device_name, - wc[index].status); - failed = 1; - if (peer) { - ibv_ack_cq_events (event_cq, num_wr); - rpc_transport_disconnect (peer->trans, - _gf_false); - rpc_transport_unref (peer->trans); - } - - if (post) { - gf_rdma_post_unref (post); - } - - continue; - } - - if (peer) { - gf_rdma_process_recv (peer, - &wc[index]); - rpc_transport_unref (peer->trans); - } else { - gf_msg_debug (GF_RDMA_LOG_NAME, 0, - "could not lookup peer " - "for qp_num: %d", - wc[index].qp_num); - } - - gf_rdma_post_unref (post); - } + device = (gf_rdma_device_t *)event_ctx; + + while (!failed && (num_wr = ibv_poll_cq(event_cq, 10, wc)) > 0) { + for (index = 0; index < num_wr && !failed; index++) { + post = (gf_rdma_post_t *)(long)wc[index].wr_id; + + pthread_mutex_lock(&device->qpreg.lock); + { + peer = __gf_rdma_lookup_peer(device, wc[index].qp_num); + + /* + * keep a refcount on transport so that it + * does not get freed because of some error + * indicated by wc.status till we are done + * with usage of peer and thereby that of + * trans. + */ + if (peer != NULL) { + rpc_transport_ref(peer->trans); + } + } + pthread_mutex_unlock(&device->qpreg.lock); + + if (wc[index].status != IBV_WC_SUCCESS) { + gf_msg(GF_RDMA_LOG_NAME, GF_LOG_ERROR, 0, + RDMA_MSG_RECV_ERROR, + "recv work " + "request on `%s' returned error (%d)", + device->device_name, wc[index].status); + failed = 1; + if (peer) { + ibv_ack_cq_events(event_cq, num_wr); + rpc_transport_disconnect(peer->trans, _gf_false); + rpc_transport_unref(peer->trans); + } + + if (post) { + gf_rdma_post_unref(post); + } + + continue; } - if (ret < 0) { - gf_msg (GF_RDMA_LOG_NAME, GF_LOG_ERROR, errno, - RDMA_MSG_IBV_POLL_CQ_ERROR, - "ibv_poll_cq on `%s' returned error " - "(ret = %d, errno = %d)", - device->device_name, ret, errno); - continue; + if (peer) { + gf_rdma_process_recv(peer, &wc[index]); + rpc_transport_unref(peer->trans); + } else { + gf_msg_debug(GF_RDMA_LOG_NAME, 0, + "could not lookup peer " + "for qp_num: %d", + wc[index].qp_num); } - if (!failed) - ibv_ack_cq_events (event_cq, num_wr); + + gf_rdma_post_unref(post); + } } - return NULL; + if (ret < 0) { + gf_msg(GF_RDMA_LOG_NAME, GF_LOG_ERROR, errno, + RDMA_MSG_IBV_POLL_CQ_ERROR, + "ibv_poll_cq on `%s' returned error " + "(ret = %d, errno = %d)", + device->device_name, ret, errno); + continue; + } + if (!failed) + ibv_ack_cq_events(event_cq, num_wr); + } + + return NULL; } - void -gf_rdma_handle_failed_send_completion (gf_rdma_peer_t *peer, struct ibv_wc *wc) +gf_rdma_handle_failed_send_completion(gf_rdma_peer_t *peer, struct ibv_wc *wc) { - gf_rdma_post_t *post = NULL; - gf_rdma_device_t *device = NULL; - gf_rdma_private_t *priv = NULL; - - if (peer != NULL) { - priv = peer->trans->private; - if (priv != NULL) { - device = priv->device; - } - } - + gf_rdma_post_t *post = NULL; + gf_rdma_device_t *device = NULL; + gf_rdma_private_t *priv = NULL; - post = (gf_rdma_post_t *) (long) wc->wr_id; - - gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, - RDMA_MSG_RDMA_HANDLE_FAILED, - "send work request on `%s' returned error " - "wc.status = %d, wc.vendor_err = %d, post->buf = %p, " - "wc.byte_len = %d, post->reused = %d", - (device != NULL) ? device->device_name : NULL, wc->status, - wc->vendor_err, post->buf, wc->byte_len, post->reused); - - if (wc->status == IBV_WC_RETRY_EXC_ERR) { - gf_msg ("rdma", GF_LOG_ERROR, 0, TRANS_MSG_TIMEOUT_EXCEEDED, - "connection between client and server not working. " - "check by running 'ibv_srq_pingpong'. also make sure " - "subnet manager is running (eg: 'opensm'), or check " - "if rdma port is valid (or active) by running " - "'ibv_devinfo'. contact Gluster Support Team if the " - "problem persists."); - } - - if (peer) { - rpc_transport_disconnect (peer->trans, _gf_false); - } - - return; + if (peer != NULL) { + priv = peer->trans->private; + if (priv != NULL) { + device = priv->device; + } + } + + post = (gf_rdma_post_t *)(long)wc->wr_id; + + gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, RDMA_MSG_RDMA_HANDLE_FAILED, + "send work request on `%s' returned error " + "wc.status = %d, wc.vendor_err = %d, post->buf = %p, " + "wc.byte_len = %d, post->reused = %d", + (device != NULL) ? device->device_name : NULL, wc->status, + wc->vendor_err, post->buf, wc->byte_len, post->reused); + + if (wc->status == IBV_WC_RETRY_EXC_ERR) { + gf_msg("rdma", GF_LOG_ERROR, 0, TRANS_MSG_TIMEOUT_EXCEEDED, + "connection between client and server not working. " + "check by running 'ibv_srq_pingpong'. also make sure " + "subnet manager is running (eg: 'opensm'), or check " + "if rdma port is valid (or active) by running " + "'ibv_devinfo'. contact Gluster Support Team if the " + "problem persists."); + } + + if (peer) { + rpc_transport_disconnect(peer->trans, _gf_false); + } + + return; } - void -gf_rdma_handle_successful_send_completion (gf_rdma_peer_t *peer, - struct ibv_wc *wc) +gf_rdma_handle_successful_send_completion(gf_rdma_peer_t *peer, + struct ibv_wc *wc) { - gf_rdma_post_t *post = NULL; - int reads = 0, ret = 0; - gf_rdma_header_t *header = NULL; - - if (wc->opcode != IBV_WC_RDMA_READ) { - goto out; - } + gf_rdma_post_t *post = NULL; + int reads = 0, ret = 0; + gf_rdma_header_t *header = NULL; - post = (gf_rdma_post_t *)(long) wc->wr_id; + if (wc->opcode != IBV_WC_RDMA_READ) { + goto out; + } - pthread_mutex_lock (&post->lock); - { - reads = --post->ctx.gf_rdma_reads; - } - pthread_mutex_unlock (&post->lock); + post = (gf_rdma_post_t *)(long)wc->wr_id; - if (reads != 0) { - /* if it is not the last rdma read, we've got nothing to do */ - goto out; - } + pthread_mutex_lock(&post->lock); + { + reads = --post->ctx.gf_rdma_reads; + } + pthread_mutex_unlock(&post->lock); - header = (gf_rdma_header_t *)post->buf; + if (reads != 0) { + /* if it is not the last rdma read, we've got nothing to do */ + goto out; + } - if (header->rm_type == GF_RDMA_NOMSG) { - post->ctx.count = 1; - post->ctx.vector[0].iov_len += post->ctx.vector[1].iov_len; - } - /* - * if reads performed as vectored, then all the buffers are actually - * contiguous memory, so that we can use it as single vector, instead - * of multiple. - */ - while (post->ctx.count > 2) { - post->ctx.vector[1].iov_len += - post->ctx.vector[post->ctx.count-1].iov_len; - post->ctx.count--; - } + header = (gf_rdma_header_t *)post->buf; - ret = gf_rdma_pollin_notify (peer, post); - if ((ret == -1) && (peer != NULL)) { - rpc_transport_disconnect (peer->trans, _gf_false); - } + if (header->rm_type == GF_RDMA_NOMSG) { + post->ctx.count = 1; + post->ctx.vector[0].iov_len += post->ctx.vector[1].iov_len; + } + /* + * if reads performed as vectored, then all the buffers are actually + * contiguous memory, so that we can use it as single vector, instead + * of multiple. + */ + while (post->ctx.count > 2) { + post->ctx.vector[1].iov_len += post->ctx.vector[post->ctx.count - 1] + .iov_len; + post->ctx.count--; + } + + ret = gf_rdma_pollin_notify(peer, post); + if ((ret == -1) && (peer != NULL)) { + rpc_transport_disconnect(peer->trans, _gf_false); + } out: - return; + return; } - static void * -gf_rdma_send_completion_proc (void *data) +gf_rdma_send_completion_proc(void *data) { - struct ibv_comp_channel *chan = NULL; - gf_rdma_post_t *post = NULL; - gf_rdma_peer_t *peer = NULL; - struct ibv_cq *event_cq = NULL; - void *event_ctx = NULL; - gf_rdma_device_t *device = NULL; - struct ibv_wc wc[10] = {{0},}; - char is_request = 0; - int32_t ret = 0, quota_ret = 0, num_wr = 0; - int32_t index = 0, failed = 0; - chan = data; - while (1) { - failed = 0; - ret = ibv_get_cq_event (chan, &event_cq, &event_ctx); - if (ret) { - gf_msg (GF_RDMA_LOG_NAME, GF_LOG_ERROR, errno, - RDMA_MSG_IBV_GET_CQ_FAILED, - "ibv_get_cq_event on failed, terminating " - "send thread: %d (%d)", ret, errno); - continue; - } + struct ibv_comp_channel *chan = NULL; + gf_rdma_post_t *post = NULL; + gf_rdma_peer_t *peer = NULL; + struct ibv_cq *event_cq = NULL; + void *event_ctx = NULL; + gf_rdma_device_t *device = NULL; + struct ibv_wc wc[10] = { + {0}, + }; + char is_request = 0; + int32_t ret = 0, quota_ret = 0, num_wr = 0; + int32_t index = 0, failed = 0; + chan = data; + while (1) { + failed = 0; + ret = ibv_get_cq_event(chan, &event_cq, &event_ctx); + if (ret) { + gf_msg(GF_RDMA_LOG_NAME, GF_LOG_ERROR, errno, + RDMA_MSG_IBV_GET_CQ_FAILED, + "ibv_get_cq_event on failed, terminating " + "send thread: %d (%d)", + ret, errno); + continue; + } + + device = event_ctx; + + ret = ibv_req_notify_cq(event_cq, 0); + if (ret) { + gf_msg(GF_RDMA_LOG_NAME, GF_LOG_ERROR, errno, + RDMA_MSG_IBV_REQ_NOTIFY_CQ_FAILED, + "ibv_req_notify_cq on %s failed, terminating " + "send thread: %d (%d)", + device->device_name, ret, errno); + continue; + } - device = event_ctx; + while (!failed && (num_wr = ibv_poll_cq(event_cq, 10, wc)) > 0) { + for (index = 0; index < num_wr && !failed; index++) { + post = (gf_rdma_post_t *)(long)wc[index].wr_id; - ret = ibv_req_notify_cq (event_cq, 0); - if (ret) { - gf_msg (GF_RDMA_LOG_NAME, GF_LOG_ERROR, errno, - RDMA_MSG_IBV_REQ_NOTIFY_CQ_FAILED, - "ibv_req_notify_cq on %s failed, terminating " - "send thread: %d (%d)", - device->device_name, ret, errno); - continue; + pthread_mutex_lock(&device->qpreg.lock); + { + peer = __gf_rdma_lookup_peer(device, wc[index].qp_num); + + /* + * keep a refcount on transport so that it + * does not get freed because of some error + * indicated by wc.status, till we are done + * with usage of peer and thereby that of trans. + */ + if (peer != NULL) { + rpc_transport_ref(peer->trans); + } } + pthread_mutex_unlock(&device->qpreg.lock); - while (!failed && - (num_wr = ibv_poll_cq (event_cq, 10, wc)) > 0) { - for (index = 0; index < num_wr && !failed; index++) { - post = (gf_rdma_post_t *) (long) - wc[index].wr_id; - - pthread_mutex_lock (&device->qpreg.lock); - { - peer = __gf_rdma_lookup_peer (device, - wc[index].qp_num); - - /* - * keep a refcount on transport so that it - * does not get freed because of some error - * indicated by wc.status, till we are done - * with usage of peer and thereby that of trans. - */ - if (peer != NULL) { - rpc_transport_ref (peer->trans); - } - } - pthread_mutex_unlock (&device->qpreg.lock); - - if (wc[index].status != IBV_WC_SUCCESS) { - ibv_ack_cq_events (event_cq, num_wr); - failed = 1; - gf_rdma_handle_failed_send_completion - (peer, &wc[index]); - } else { - gf_rdma_handle_successful_send_completion - (peer, &wc[index]); - } - - if (post) { - is_request = post->ctx.is_request; - - ret = gf_rdma_post_unref (post); - if ((ret == 0) - && (wc[index].status == IBV_WC_SUCCESS) - && !is_request - && (post->type == GF_RDMA_SEND_POST) - && (peer != NULL)) { - /* An GF_RDMA_RECV_POST can end up in - * gf_rdma_send_completion_proc for - * rdma-reads, and we do not take - * quota for getting an GF_RDMA_RECV_POST. - */ - - /* - * if it is request, quota is returned - * after reply has come. - */ - quota_ret = gf_rdma_quota_put - (peer); - if (quota_ret < 0) { - gf_msg_debug ("rdma", - 0, "failed to send " - "message"); - } - } - } - - if (peer) { - rpc_transport_unref (peer->trans); - } else { - gf_msg_debug (GF_RDMA_LOG_NAME, 0, - "could not lookup peer for qp_num: %d", - wc[index].qp_num); - - } + if (wc[index].status != IBV_WC_SUCCESS) { + ibv_ack_cq_events(event_cq, num_wr); + failed = 1; + gf_rdma_handle_failed_send_completion(peer, &wc[index]); + } else { + gf_rdma_handle_successful_send_completion(peer, &wc[index]); + } + + if (post) { + is_request = post->ctx.is_request; + + ret = gf_rdma_post_unref(post); + if ((ret == 0) && (wc[index].status == IBV_WC_SUCCESS) && + !is_request && (post->type == GF_RDMA_SEND_POST) && + (peer != NULL)) { + /* An GF_RDMA_RECV_POST can end up in + * gf_rdma_send_completion_proc for + * rdma-reads, and we do not take + * quota for getting an GF_RDMA_RECV_POST. + */ + + /* + * if it is request, quota is returned + * after reply has come. + */ + quota_ret = gf_rdma_quota_put(peer); + if (quota_ret < 0) { + gf_msg_debug("rdma", 0, + "failed to send " + "message"); } + } } - if (ret < 0) { - gf_msg (GF_RDMA_LOG_NAME, GF_LOG_ERROR, errno, - RDMA_MSG_IBV_POLL_CQ_ERROR, - "ibv_poll_cq on `%s' returned error (ret = %d," - " errno = %d)", - device->device_name, ret, errno); - continue; - } - if (!failed) - ibv_ack_cq_events (event_cq, num_wr); + if (peer) { + rpc_transport_unref(peer->trans); + } else { + gf_msg_debug(GF_RDMA_LOG_NAME, 0, + "could not lookup peer for qp_num: %d", + wc[index].qp_num); + } + } } - return NULL; + if (ret < 0) { + gf_msg(GF_RDMA_LOG_NAME, GF_LOG_ERROR, errno, + RDMA_MSG_IBV_POLL_CQ_ERROR, + "ibv_poll_cq on `%s' returned error (ret = %d," + " errno = %d)", + device->device_name, ret, errno); + continue; + } + if (!failed) + ibv_ack_cq_events(event_cq, num_wr); + } + + return NULL; } - static void -gf_rdma_options_init (rpc_transport_t *this) +gf_rdma_options_init(rpc_transport_t *this) { - gf_rdma_private_t *priv = NULL; - gf_rdma_options_t *options = NULL; - int32_t mtu = 0; - data_t *temp = NULL; - - /* TODO: validate arguments from options below */ - - priv = this->private; - options = &priv->options; - options->send_size = GLUSTERFS_RDMA_INLINE_THRESHOLD;/*this->ctx->page_size * 4; 512 KB*/ - options->recv_size = GLUSTERFS_RDMA_INLINE_THRESHOLD;/*this->ctx->page_size * 4; 512 KB*/ - options->send_count = 4096; - options->recv_count = 4096; - options->attr_timeout = GF_RDMA_TIMEOUT; - options->attr_retry_cnt = GF_RDMA_RETRY_CNT; - options->attr_rnr_retry = GF_RDMA_RNR_RETRY; - - temp = dict_get (this->options, "transport.listen-backlog"); - if (temp) - options->backlog = data_to_uint32 (temp); - else - options->backlog = GLUSTERFS_SOCKET_LISTEN_BACKLOG; - - temp = dict_get (this->options, - "transport.rdma.work-request-send-count"); - if (temp) - options->send_count = data_to_int32 (temp); - - temp = dict_get (this->options, - "transport.rdma.work-request-recv-count"); - if (temp) - options->recv_count = data_to_int32 (temp); - - temp = dict_get (this->options, "transport.rdma.attr-timeout"); - - if (temp) - options->attr_timeout = data_to_uint8 (temp); - - temp = dict_get (this->options, "transport.rdma.attr-retry-cnt"); - - if (temp) - options->attr_retry_cnt = data_to_uint8 (temp); - - temp = dict_get (this->options, "transport.rdma.attr-rnr-retry"); - - if (temp) - options->attr_rnr_retry = data_to_uint8 (temp); - - options->port = 1; - temp = dict_get (this->options, - "transport.rdma.port"); - if (temp) - options->port = data_to_uint64 (temp); - - options->mtu = mtu = IBV_MTU_2048; - temp = dict_get (this->options, - "transport.rdma.mtu"); - if (temp) - mtu = data_to_int32 (temp); - switch (mtu) { - - case 256: options->mtu = IBV_MTU_256; - break; - - case 512: options->mtu = IBV_MTU_512; - break; - - case 1024: options->mtu = IBV_MTU_1024; - break; - - case 2048: options->mtu = IBV_MTU_2048; - break; - - case 4096: options->mtu = IBV_MTU_4096; - break; + gf_rdma_private_t *priv = NULL; + gf_rdma_options_t *options = NULL; + int32_t mtu = 0; + data_t *temp = NULL; + + /* TODO: validate arguments from options below */ + + priv = this->private; + options = &priv->options; + options->send_size = + GLUSTERFS_RDMA_INLINE_THRESHOLD; /*this->ctx->page_size * 4; 512 KB*/ + options->recv_size = + GLUSTERFS_RDMA_INLINE_THRESHOLD; /*this->ctx->page_size * 4; 512 KB*/ + options->send_count = 4096; + options->recv_count = 4096; + options->attr_timeout = GF_RDMA_TIMEOUT; + options->attr_retry_cnt = GF_RDMA_RETRY_CNT; + options->attr_rnr_retry = GF_RDMA_RNR_RETRY; + + temp = dict_get(this->options, "transport.listen-backlog"); + if (temp) + options->backlog = data_to_uint32(temp); + else + options->backlog = GLUSTERFS_SOCKET_LISTEN_BACKLOG; + + temp = dict_get(this->options, "transport.rdma.work-request-send-count"); + if (temp) + options->send_count = data_to_int32(temp); + + temp = dict_get(this->options, "transport.rdma.work-request-recv-count"); + if (temp) + options->recv_count = data_to_int32(temp); + + temp = dict_get(this->options, "transport.rdma.attr-timeout"); + + if (temp) + options->attr_timeout = data_to_uint8(temp); + + temp = dict_get(this->options, "transport.rdma.attr-retry-cnt"); + + if (temp) + options->attr_retry_cnt = data_to_uint8(temp); + + temp = dict_get(this->options, "transport.rdma.attr-rnr-retry"); + + if (temp) + options->attr_rnr_retry = data_to_uint8(temp); + + options->port = 1; + temp = dict_get(this->options, "transport.rdma.port"); + if (temp) + options->port = data_to_uint64(temp); + + options->mtu = mtu = IBV_MTU_2048; + temp = dict_get(this->options, "transport.rdma.mtu"); + if (temp) + mtu = data_to_int32(temp); + switch (mtu) { + case 256: + options->mtu = IBV_MTU_256; + break; + + case 512: + options->mtu = IBV_MTU_512; + break; + + case 1024: + options->mtu = IBV_MTU_1024; + break; + + case 2048: + options->mtu = IBV_MTU_2048; + break; + + case 4096: + options->mtu = IBV_MTU_4096; + break; default: - if (temp) - gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, - RDMA_MSG_UNRECG_MTU_VALUE, "%s: unrecognized " - "MTU value '%s', defaulting to '2048'", - this->name, data_to_str (temp)); - else - gf_msg_trace (GF_RDMA_LOG_NAME, 0, "%s: defaulting " - "MTU to '2048'", this->name); - options->mtu = IBV_MTU_2048; - break; - } - - temp = dict_get (this->options, - "transport.rdma.device-name"); - if (temp) - options->device_name = gf_strdup (temp->data); - - return; + if (temp) + gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, 0, + RDMA_MSG_UNRECG_MTU_VALUE, + "%s: unrecognized " + "MTU value '%s', defaulting to '2048'", + this->name, data_to_str(temp)); + else + gf_msg_trace(GF_RDMA_LOG_NAME, 0, + "%s: defaulting " + "MTU to '2048'", + this->name); + options->mtu = IBV_MTU_2048; + break; + } + + temp = dict_get(this->options, "transport.rdma.device-name"); + if (temp) + options->device_name = gf_strdup(temp->data); + + return; } - gf_rdma_ctx_t * -__gf_rdma_ctx_create (void) +__gf_rdma_ctx_create(void) { - gf_rdma_ctx_t *rdma_ctx = NULL; - int ret = -1; - - rdma_ctx = GF_CALLOC (1, sizeof (*rdma_ctx), gf_common_mt_char); - if (rdma_ctx == NULL) { - goto out; - } - pthread_mutex_init (&rdma_ctx->lock, NULL); - rdma_ctx->rdma_cm_event_channel = rdma_create_event_channel (); - if (rdma_ctx->rdma_cm_event_channel == NULL) { - gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, errno, - RDMA_MSG_CM_EVENT_FAILED, "rdma_cm event channel " - "creation failed"); - goto out; - } - - ret = gf_thread_create (&rdma_ctx->rdma_cm_thread, NULL, - gf_rdma_cm_event_handler, - rdma_ctx->rdma_cm_event_channel, "rdmaehan"); - if (ret != 0) { - gf_msg (GF_RDMA_LOG_NAME, GF_LOG_WARNING, ret, - RDMA_MSG_CM_EVENT_FAILED, "creation of thread to " - "handle rdma-cm events failed"); - goto out; - } + gf_rdma_ctx_t *rdma_ctx = NULL; + int ret = -1; + + rdma_ctx = GF_CALLOC(1, sizeof(*rdma_ctx), gf_common_mt_char); + if (rdma_ctx == NULL) { + goto out; + } + pthread_mutex_init(&rdma_ctx->lock, NULL); + rdma_ctx->rdma_cm_event_channel = rdma_create_event_channel(); + if (rdma_ctx->rdma_cm_event_channel == NULL) { + gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, errno, + RDMA_MSG_CM_EVENT_FAILED, + "rdma_cm event channel " + "creation failed"); + goto out; + } + + ret = gf_thread_create(&rdma_ctx->rdma_cm_thread, NULL, + gf_rdma_cm_event_handler, + rdma_ctx->rdma_cm_event_channel, "rdmaehan"); + if (ret != 0) { + gf_msg(GF_RDMA_LOG_NAME, GF_LOG_WARNING, ret, RDMA_MSG_CM_EVENT_FAILED, + "creation of thread to " + "handle rdma-cm events failed"); + goto out; + } out: - if (ret < 0 && rdma_ctx) { - if (rdma_ctx->rdma_cm_event_channel != NULL) { - rdma_destroy_event_channel (rdma_ctx->rdma_cm_event_channel); - } - - GF_FREE (rdma_ctx); - rdma_ctx = NULL; + if (ret < 0 && rdma_ctx) { + if (rdma_ctx->rdma_cm_event_channel != NULL) { + rdma_destroy_event_channel(rdma_ctx->rdma_cm_event_channel); } - return rdma_ctx; + GF_FREE(rdma_ctx); + rdma_ctx = NULL; + } + + return rdma_ctx; } static int32_t -gf_rdma_init (rpc_transport_t *this) +gf_rdma_init(rpc_transport_t *this) { - gf_rdma_private_t *priv = NULL; - int32_t ret = 0; - glusterfs_ctx_t *ctx = NULL; - gf_rdma_options_t *options = NULL; + gf_rdma_private_t *priv = NULL; + int32_t ret = 0; + glusterfs_ctx_t *ctx = NULL; + gf_rdma_options_t *options = NULL; - ctx = this->ctx; + ctx = this->ctx; - priv = this->private; + priv = this->private; - ibv_fork_init (); - gf_rdma_options_init (this); + ibv_fork_init(); + gf_rdma_options_init(this); - options = &priv->options; - priv->peer.send_count = options->send_count; - priv->peer.recv_count = options->recv_count; - priv->peer.send_size = options->send_size; - priv->peer.recv_size = options->recv_size; - priv->backlog = options->backlog; + options = &priv->options; + priv->peer.send_count = options->send_count; + priv->peer.recv_count = options->recv_count; + priv->peer.send_size = options->send_size; + priv->peer.recv_size = options->recv_size; + priv->backlog = options->backlog; - priv->peer.trans = this; - INIT_LIST_HEAD (&priv->peer.ioq); + priv->peer.trans = this; + INIT_LIST_HEAD(&priv->peer.ioq); - pthread_mutex_init (&priv->write_mutex, NULL); - pthread_mutex_init (&priv->recv_mutex, NULL); - pthread_cond_init (&priv->recv_cond, NULL); + pthread_mutex_init(&priv->write_mutex, NULL); + pthread_mutex_init(&priv->recv_mutex, NULL); + pthread_cond_init(&priv->recv_cond, NULL); - LOCK (&ctx->lock); - { - if (ctx->ib == NULL) { - ctx->ib = __gf_rdma_ctx_create (); - if (ctx->ib == NULL) { - ret = -1; - } - } + LOCK(&ctx->lock); + { + if (ctx->ib == NULL) { + ctx->ib = __gf_rdma_ctx_create(); + if (ctx->ib == NULL) { + ret = -1; + } } - UNLOCK (&ctx->lock); + } + UNLOCK(&ctx->lock); - return ret; + return ret; } - static int32_t -gf_rdma_disconnect (rpc_transport_t *this, gf_boolean_t wait) +gf_rdma_disconnect(rpc_transport_t *this, gf_boolean_t wait) { - gf_rdma_private_t *priv = NULL; - int32_t ret = 0; + gf_rdma_private_t *priv = NULL; + int32_t ret = 0; - priv = this->private; - gf_msg_callingfn (this->name, GF_LOG_DEBUG, 0, - RDMA_MSG_PEER_DISCONNECTED, - "disconnect called (peer:%s)", - this->peerinfo.identifier); + priv = this->private; + gf_msg_callingfn(this->name, GF_LOG_DEBUG, 0, RDMA_MSG_PEER_DISCONNECTED, + "disconnect called (peer:%s)", this->peerinfo.identifier); - pthread_mutex_lock (&priv->write_mutex); - { - ret = __gf_rdma_disconnect (this); - } - pthread_mutex_unlock (&priv->write_mutex); + pthread_mutex_lock(&priv->write_mutex); + { + ret = __gf_rdma_disconnect(this); + } + pthread_mutex_unlock(&priv->write_mutex); - return ret; + return ret; } - static int32_t -gf_rdma_connect (struct rpc_transport *this, int port) +gf_rdma_connect(struct rpc_transport *this, int port) { - gf_rdma_private_t *priv = NULL; - int32_t ret = 0; - union gf_sock_union sock_union = {{0, }, }; - socklen_t sockaddr_len = 0; - gf_rdma_peer_t *peer = NULL; - gf_rdma_ctx_t *rdma_ctx = NULL; - gf_boolean_t connected = _gf_false; - - priv = this->private; - - peer = &priv->peer; - - rpc_transport_ref (this); - - ret = gf_rdma_client_get_remote_sockaddr (this, - &sock_union.sa, - &sockaddr_len, port); - if (ret != 0) { - gf_msg_debug (this->name, 0, "cannot get remote address to " - "connect"); - goto out; - } - - rdma_ctx = this->ctx->ib; - - pthread_mutex_lock (&priv->write_mutex); + gf_rdma_private_t *priv = NULL; + int32_t ret = 0; + union gf_sock_union sock_union = { { - if (peer->cm_id != NULL) { - ret = -1; - errno = EINPROGRESS; - connected = _gf_true; - goto unlock; - } + 0, + }, + }; + socklen_t sockaddr_len = 0; + gf_rdma_peer_t *peer = NULL; + gf_rdma_ctx_t *rdma_ctx = NULL; + gf_boolean_t connected = _gf_false; - priv->entity = GF_RDMA_CLIENT; + priv = this->private; - ret = rdma_create_id (rdma_ctx->rdma_cm_event_channel, - &peer->cm_id, this, RDMA_PS_TCP); - if (ret != 0) { - gf_msg (this->name, GF_LOG_ERROR, errno, - RDMA_MSG_CM_EVENT_FAILED, "creation of " - "rdma_cm_id failed"); - ret = -errno; - goto unlock; - } + peer = &priv->peer; - memcpy (&this->peerinfo.sockaddr, &sock_union.storage, - sockaddr_len); - this->peerinfo.sockaddr_len = sockaddr_len; - - if (port > 0) - sock_union.sin.sin_port = htons (port); - - ((struct sockaddr *) &this->myinfo.sockaddr)->sa_family = - ((struct sockaddr *)&this->peerinfo.sockaddr)->sa_family; - - ret = gf_rdma_client_bind (this, - (struct sockaddr *)&this->myinfo.sockaddr, - &this->myinfo.sockaddr_len, - peer->cm_id); - if (ret != 0) { - gf_msg (this->name, GF_LOG_WARNING, errno, - RDMA_MSG_CLIENT_BIND_FAILED, - "client bind failed"); - goto unlock; - } - - ret = rdma_resolve_addr (peer->cm_id, NULL, &sock_union.sa, - 2000); - if (ret != 0) { - gf_msg (this->name, GF_LOG_WARNING, errno, - RDMA_MSG_RDMA_RESOLVE_ADDR_FAILED, - "rdma_resolve_addr failed"); - goto unlock; - } + rpc_transport_ref(this); - priv->connected = 0; - } -unlock: - pthread_mutex_unlock (&priv->write_mutex); + ret = gf_rdma_client_get_remote_sockaddr(this, &sock_union.sa, + &sockaddr_len, port); + if (ret != 0) { + gf_msg_debug(this->name, 0, + "cannot get remote address to " + "connect"); + goto out; + } -out: - if (ret != 0) { - if (!connected) { - gf_rdma_teardown (this); - } + rdma_ctx = this->ctx->ib; - rpc_transport_unref (this); + pthread_mutex_lock(&priv->write_mutex); + { + if (peer->cm_id != NULL) { + ret = -1; + errno = EINPROGRESS; + connected = _gf_true; + goto unlock; } - return ret; -} - + priv->entity = GF_RDMA_CLIENT; -static int32_t -gf_rdma_listen (rpc_transport_t *this) -{ - union gf_sock_union sock_union = {{0, }, }; - socklen_t sockaddr_len = 0; - gf_rdma_private_t *priv = NULL; - gf_rdma_peer_t *peer = NULL; - int ret = 0; - gf_rdma_ctx_t *rdma_ctx = NULL; - char service[NI_MAXSERV], host[NI_MAXHOST]; - int optval = 2; - - priv = this->private; - peer = &priv->peer; - - priv->entity = GF_RDMA_SERVER_LISTENER; - - rdma_ctx = this->ctx->ib; - - ret = gf_rdma_server_get_local_sockaddr (this, &sock_union.sa, - &sockaddr_len); + ret = rdma_create_id(rdma_ctx->rdma_cm_event_channel, &peer->cm_id, + this, RDMA_PS_TCP); if (ret != 0) { - gf_msg (this->name, GF_LOG_WARNING, 0, - RDMA_MSG_NW_ADDR_UNKNOWN, - "cannot find network address of server to bind to"); - goto err; + gf_msg(this->name, GF_LOG_ERROR, errno, RDMA_MSG_CM_EVENT_FAILED, + "creation of " + "rdma_cm_id failed"); + ret = -errno; + goto unlock; } - ret = rdma_create_id (rdma_ctx->rdma_cm_event_channel, - &peer->cm_id, this, RDMA_PS_TCP); - if (ret != 0) { - gf_msg (this->name, GF_LOG_WARNING, errno, - RDMA_MSG_CM_EVENT_FAILED, "creation of rdma_cm_id " - "failed"); - goto err; - } + memcpy(&this->peerinfo.sockaddr, &sock_union.storage, sockaddr_len); + this->peerinfo.sockaddr_len = sockaddr_len; - memcpy (&this->myinfo.sockaddr, &sock_union.storage, - sockaddr_len); - this->myinfo.sockaddr_len = sockaddr_len; + if (port > 0) + sock_union.sin.sin_port = htons(port); - ret = getnameinfo ((struct sockaddr *)&this->myinfo.sockaddr, - this->myinfo.sockaddr_len, host, sizeof (host), - service, sizeof (service), - NI_NUMERICHOST); - if (ret != 0) { - gf_msg (this->name, GF_LOG_ERROR, ret, - TRANS_MSG_GET_NAME_INFO_FAILED, - "getnameinfo failed"); - goto err; - } + ((struct sockaddr *)&this->myinfo.sockaddr)->sa_family = + ((struct sockaddr *)&this->peerinfo.sockaddr)->sa_family; - sprintf (this->myinfo.identifier, "%s:%s", host, service); - - ret = rdma_set_option(peer->cm_id, RDMA_OPTION_ID, - RDMA_OPTION_ID_REUSEADDR, - (void *)&optval, sizeof(optval)); + ret = gf_rdma_client_bind(this, + (struct sockaddr *)&this->myinfo.sockaddr, + &this->myinfo.sockaddr_len, peer->cm_id); if (ret != 0) { - gf_msg (this->name, GF_LOG_WARNING, errno, - RDMA_MSG_OPTION_SET_FAILED, "rdma option set failed"); - goto err; + gf_msg(this->name, GF_LOG_WARNING, errno, + RDMA_MSG_CLIENT_BIND_FAILED, "client bind failed"); + goto unlock; } - ret = rdma_bind_addr (peer->cm_id, &sock_union.sa); + ret = rdma_resolve_addr(peer->cm_id, NULL, &sock_union.sa, 2000); if (ret != 0) { - gf_msg (this->name, GF_LOG_WARNING, errno, - RDMA_MSG_RDMA_BIND_ADDR_FAILED, - "rdma_bind_addr failed"); - goto err; + gf_msg(this->name, GF_LOG_WARNING, errno, + RDMA_MSG_RDMA_RESOLVE_ADDR_FAILED, + "rdma_resolve_addr failed"); + goto unlock; } - ret = rdma_listen (peer->cm_id, priv->backlog); + priv->connected = 0; + } +unlock: + pthread_mutex_unlock(&priv->write_mutex); - if (ret != 0) { - gf_msg (this->name, GF_LOG_WARNING, errno, - RDMA_MSG_LISTEN_FAILED, - "rdma_listen failed"); - goto err; +out: + if (ret != 0) { + if (!connected) { + gf_rdma_teardown(this); } - rpc_transport_ref (this); + rpc_transport_unref(this); + } - ret = 0; + return ret; +} + +static int32_t +gf_rdma_listen(rpc_transport_t *this) +{ + union gf_sock_union sock_union = { + { + 0, + }, + }; + socklen_t sockaddr_len = 0; + gf_rdma_private_t *priv = NULL; + gf_rdma_peer_t *peer = NULL; + int ret = 0; + gf_rdma_ctx_t *rdma_ctx = NULL; + char service[NI_MAXSERV], host[NI_MAXHOST]; + int optval = 2; + + priv = this->private; + peer = &priv->peer; + + priv->entity = GF_RDMA_SERVER_LISTENER; + + rdma_ctx = this->ctx->ib; + + ret = gf_rdma_server_get_local_sockaddr(this, &sock_union.sa, + &sockaddr_len); + if (ret != 0) { + gf_msg(this->name, GF_LOG_WARNING, 0, RDMA_MSG_NW_ADDR_UNKNOWN, + "cannot find network address of server to bind to"); + goto err; + } + + ret = rdma_create_id(rdma_ctx->rdma_cm_event_channel, &peer->cm_id, this, + RDMA_PS_TCP); + if (ret != 0) { + gf_msg(this->name, GF_LOG_WARNING, errno, RDMA_MSG_CM_EVENT_FAILED, + "creation of rdma_cm_id " + "failed"); + goto err; + } + + memcpy(&this->myinfo.sockaddr, &sock_union.storage, sockaddr_len); + this->myinfo.sockaddr_len = sockaddr_len; + + ret = getnameinfo((struct sockaddr *)&this->myinfo.sockaddr, + this->myinfo.sockaddr_len, host, sizeof(host), service, + sizeof(service), NI_NUMERICHOST); + if (ret != 0) { + gf_msg(this->name, GF_LOG_ERROR, ret, TRANS_MSG_GET_NAME_INFO_FAILED, + "getnameinfo failed"); + goto err; + } + + sprintf(this->myinfo.identifier, "%s:%s", host, service); + + ret = rdma_set_option(peer->cm_id, RDMA_OPTION_ID, RDMA_OPTION_ID_REUSEADDR, + (void *)&optval, sizeof(optval)); + if (ret != 0) { + gf_msg(this->name, GF_LOG_WARNING, errno, RDMA_MSG_OPTION_SET_FAILED, + "rdma option set failed"); + goto err; + } + + ret = rdma_bind_addr(peer->cm_id, &sock_union.sa); + if (ret != 0) { + gf_msg(this->name, GF_LOG_WARNING, errno, + RDMA_MSG_RDMA_BIND_ADDR_FAILED, "rdma_bind_addr failed"); + goto err; + } + + ret = rdma_listen(peer->cm_id, priv->backlog); + + if (ret != 0) { + gf_msg(this->name, GF_LOG_WARNING, errno, RDMA_MSG_LISTEN_FAILED, + "rdma_listen failed"); + goto err; + } + + rpc_transport_ref(this); + + ret = 0; err: - if (ret < 0) { - if (peer->cm_id != NULL) { - rdma_destroy_id (peer->cm_id); - peer->cm_id = NULL; - } + if (ret < 0) { + if (peer->cm_id != NULL) { + rdma_destroy_id(peer->cm_id); + peer->cm_id = NULL; } + } - return ret; + return ret; } - struct rpc_transport_ops tops = { - .submit_request = gf_rdma_submit_request, - .submit_reply = gf_rdma_submit_reply, - .connect = gf_rdma_connect, - .disconnect = gf_rdma_disconnect, - .listen = gf_rdma_listen, + .submit_request = gf_rdma_submit_request, + .submit_reply = gf_rdma_submit_reply, + .connect = gf_rdma_connect, + .disconnect = gf_rdma_disconnect, + .listen = gf_rdma_listen, }; int32_t -init (rpc_transport_t *this) +init(rpc_transport_t *this) { - gf_rdma_private_t *priv = NULL; - gf_rdma_ctx_t *rdma_ctx = NULL; - struct iobuf_pool *iobuf_pool = NULL; - - priv = GF_CALLOC (1, sizeof (*priv), gf_common_mt_rdma_private_t); - if (!priv) - return -1; - - this->private = priv; - - if (gf_rdma_init (this)) { - gf_msg (this->name, GF_LOG_WARNING, 0, - RDMA_MSG_INIT_IB_DEVICE_FAILED, - "Failed to initialize IB Device"); - this->private = NULL; - GF_FREE (priv); - return -1; - } - rdma_ctx = this->ctx->ib; - if (!rdma_ctx) - return -1; + gf_rdma_private_t *priv = NULL; + gf_rdma_ctx_t *rdma_ctx = NULL; + struct iobuf_pool *iobuf_pool = NULL; - pthread_mutex_lock (&rdma_ctx->lock); - { - if (this->dl_handle && (++(rdma_ctx->dlcount)) == 1) { - iobuf_pool = this->ctx->iobuf_pool; - iobuf_pool->rdma_registration = gf_rdma_register_arena; - iobuf_pool->rdma_deregistration = - gf_rdma_deregister_arena; - gf_rdma_register_iobuf_pool_with_device - (rdma_ctx->device, iobuf_pool); - } - } - pthread_mutex_unlock (&rdma_ctx->lock); + priv = GF_CALLOC(1, sizeof(*priv), gf_common_mt_rdma_private_t); + if (!priv) + return -1; - return 0; + this->private = priv; + + if (gf_rdma_init(this)) { + gf_msg(this->name, GF_LOG_WARNING, 0, RDMA_MSG_INIT_IB_DEVICE_FAILED, + "Failed to initialize IB Device"); + this->private = NULL; + GF_FREE(priv); + return -1; + } + rdma_ctx = this->ctx->ib; + if (!rdma_ctx) + return -1; + + pthread_mutex_lock(&rdma_ctx->lock); + { + if (this->dl_handle && (++(rdma_ctx->dlcount)) == 1) { + iobuf_pool = this->ctx->iobuf_pool; + iobuf_pool->rdma_registration = gf_rdma_register_arena; + iobuf_pool->rdma_deregistration = gf_rdma_deregister_arena; + gf_rdma_register_iobuf_pool_with_device(rdma_ctx->device, + iobuf_pool); + } + } + pthread_mutex_unlock(&rdma_ctx->lock); + + return 0; } int -reconfigure (rpc_transport_t *this, dict_t *options) +reconfigure(rpc_transport_t *this, dict_t *options) { - gf_rdma_private_t *priv = NULL; - uint32_t backlog = 0; - int ret = -1; - - GF_VALIDATE_OR_GOTO ("rdma", this, out); - GF_VALIDATE_OR_GOTO ("rdma", this->private, out); - - priv = this->private; - - if (dict_get_uint32 (options, "transport.listen-backlog", - &backlog) == 0) { - priv->backlog = backlog; - gf_log (this->name, GF_LOG_DEBUG, "Reconfigued " - "transport.listen-backlog=%d", priv->backlog); - } - ret = 0; + gf_rdma_private_t *priv = NULL; + uint32_t backlog = 0; + int ret = -1; + + GF_VALIDATE_OR_GOTO("rdma", this, out); + GF_VALIDATE_OR_GOTO("rdma", this->private, out); + + priv = this->private; + + if (dict_get_uint32(options, "transport.listen-backlog", &backlog) == 0) { + priv->backlog = backlog; + gf_log(this->name, GF_LOG_DEBUG, + "Reconfigued " + "transport.listen-backlog=%d", + priv->backlog); + } + ret = 0; out: - return ret; + return ret; } void -fini (struct rpc_transport *this) +fini(struct rpc_transport *this) { - /* TODO: verify this function does graceful finish */ - gf_rdma_private_t *priv = NULL; - struct iobuf_pool *iobuf_pool = NULL; - gf_rdma_ctx_t *rdma_ctx = NULL; + /* TODO: verify this function does graceful finish */ + gf_rdma_private_t *priv = NULL; + struct iobuf_pool *iobuf_pool = NULL; + gf_rdma_ctx_t *rdma_ctx = NULL; - priv = this->private; + priv = this->private; - this->private = NULL; + this->private = NULL; - if (priv) { - pthread_mutex_destroy (&priv->recv_mutex); - pthread_mutex_destroy (&priv->write_mutex); + if (priv) { + pthread_mutex_destroy(&priv->recv_mutex); + pthread_mutex_destroy(&priv->write_mutex); - gf_msg_trace (this->name, 0, - "called fini on transport: %p", this); - GF_FREE (priv); - } + gf_msg_trace(this->name, 0, "called fini on transport: %p", this); + GF_FREE(priv); + } - rdma_ctx = this->ctx->ib; - if (!rdma_ctx) - return; + rdma_ctx = this->ctx->ib; + if (!rdma_ctx) + return; - pthread_mutex_lock (&rdma_ctx->lock); - { - if (this->dl_handle && (--(rdma_ctx->dlcount)) == 0) { - iobuf_pool = this->ctx->iobuf_pool; - gf_rdma_deregister_iobuf_pool (rdma_ctx->device); - iobuf_pool->rdma_registration = NULL; - iobuf_pool->rdma_deregistration = NULL; - } + pthread_mutex_lock(&rdma_ctx->lock); + { + if (this->dl_handle && (--(rdma_ctx->dlcount)) == 0) { + iobuf_pool = this->ctx->iobuf_pool; + gf_rdma_deregister_iobuf_pool(rdma_ctx->device); + iobuf_pool->rdma_registration = NULL; + iobuf_pool->rdma_deregistration = NULL; } - pthread_mutex_unlock (&rdma_ctx->lock); + } + pthread_mutex_unlock(&rdma_ctx->lock); - return; + return; } /* TODO: expand each option */ struct volume_options options[] = { - { .key = {"transport.rdma.port", - "rdma-port"}, - .type = GF_OPTION_TYPE_INT, - .min = 1, - .max = 4, - .description = "check the option by 'ibv_devinfo'" - }, - { .key = {"transport.rdma.mtu", - "rdma-mtu"}, - .type = GF_OPTION_TYPE_INT, - }, - { .key = {"transport.rdma.device-name", - "rdma-device-name"}, - .type = GF_OPTION_TYPE_ANY, - .description = "check by 'ibv_devinfo'" - }, - { .key = {"transport.rdma.work-request-send-count", - "rdma-work-request-send-count"}, - .type = GF_OPTION_TYPE_INT, - }, - { .key = {"transport.rdma.work-request-recv-count", - "rdma-work-request-recv-count"}, - .type = GF_OPTION_TYPE_INT, - }, - { .key = {"remote-port", - "transport.remote-port", - "transport.rdma.remote-port"}, - .type = GF_OPTION_TYPE_INT - }, - { .key = {"transport.rdma.attr-timeout", - "rdma-attr-timeout"}, - .type = GF_OPTION_TYPE_INT - }, - { .key = {"transport.rdma.attr-retry-cnt", - "rdma-attr-retry-cnt"}, - .type = GF_OPTION_TYPE_INT - }, - { .key = {"transport.rdma.attr-rnr-retry", - "rdma-attr-rnr-retry"}, - .type = GF_OPTION_TYPE_INT - }, - { .key = {"transport.rdma.listen-port", "listen-port"}, - .type = GF_OPTION_TYPE_INT - }, - { .key = {"transport.rdma.connect-path", "connect-path"}, - .type = GF_OPTION_TYPE_ANY - }, - { .key = {"transport.rdma.bind-path", "bind-path"}, - .type = GF_OPTION_TYPE_ANY - }, - { .key = {"transport.rdma.listen-path", "listen-path"}, - .type = GF_OPTION_TYPE_ANY - }, - { .key = {"transport.address-family", - "address-family"}, - .value = {"inet", "inet6", "inet/inet6", "inet6/inet", - "unix", "inet-sdp" }, - .type = GF_OPTION_TYPE_STR - }, - { .key = {"transport.socket.lowlat"}, - .type = GF_OPTION_TYPE_BOOL - }, - { .key = {NULL} } -}; + {.key = {"transport.rdma.port", "rdma-port"}, + .type = GF_OPTION_TYPE_INT, + .min = 1, + .max = 4, + .description = "check the option by 'ibv_devinfo'"}, + { + .key = {"transport.rdma.mtu", "rdma-mtu"}, + .type = GF_OPTION_TYPE_INT, + }, + {.key = {"transport.rdma.device-name", "rdma-device-name"}, + .type = GF_OPTION_TYPE_ANY, + .description = "check by 'ibv_devinfo'"}, + { + .key = {"transport.rdma.work-request-send-count", + "rdma-work-request-send-count"}, + .type = GF_OPTION_TYPE_INT, + }, + { + .key = {"transport.rdma.work-request-recv-count", + "rdma-work-request-recv-count"}, + .type = GF_OPTION_TYPE_INT, + }, + {.key = {"remote-port", "transport.remote-port", + "transport.rdma.remote-port"}, + .type = GF_OPTION_TYPE_INT}, + {.key = {"transport.rdma.attr-timeout", "rdma-attr-timeout"}, + .type = GF_OPTION_TYPE_INT}, + {.key = {"transport.rdma.attr-retry-cnt", "rdma-attr-retry-cnt"}, + .type = GF_OPTION_TYPE_INT}, + {.key = {"transport.rdma.attr-rnr-retry", "rdma-attr-rnr-retry"}, + .type = GF_OPTION_TYPE_INT}, + {.key = {"transport.rdma.listen-port", "listen-port"}, + .type = GF_OPTION_TYPE_INT}, + {.key = {"transport.rdma.connect-path", "connect-path"}, + .type = GF_OPTION_TYPE_ANY}, + {.key = {"transport.rdma.bind-path", "bind-path"}, + .type = GF_OPTION_TYPE_ANY}, + {.key = {"transport.rdma.listen-path", "listen-path"}, + .type = GF_OPTION_TYPE_ANY}, + {.key = {"transport.address-family", "address-family"}, + .value = {"inet", "inet6", "inet/inet6", "inet6/inet", "unix", "inet-sdp"}, + .type = GF_OPTION_TYPE_STR}, + {.key = {"transport.socket.lowlat"}, .type = GF_OPTION_TYPE_BOOL}, + {.key = {NULL}}}; diff --git a/rpc/rpc-transport/socket/src/name.c b/rpc/rpc-transport/socket/src/name.c index 34e6372a8f3..3194a7cf369 100644 --- a/rpc/rpc-transport/socket/src/name.c +++ b/rpc/rpc-transport/socket/src/name.c @@ -24,760 +24,729 @@ #include "common-utils.h" static void -_assign_port (struct sockaddr *sockaddr, uint16_t port) +_assign_port(struct sockaddr *sockaddr, uint16_t port) { - switch (sockaddr->sa_family) { + switch (sockaddr->sa_family) { case AF_INET6: - ((struct sockaddr_in6 *)sockaddr)->sin6_port = htons (port); - break; + ((struct sockaddr_in6 *)sockaddr)->sin6_port = htons(port); + break; case AF_INET_SDP: case AF_INET: - ((struct sockaddr_in *)sockaddr)->sin_port = htons (port); - break; - } + ((struct sockaddr_in *)sockaddr)->sin_port = htons(port); + break; + } } static int32_t -af_inet_bind_to_port_lt_ceiling (int fd, struct sockaddr *sockaddr, - socklen_t sockaddr_len, uint32_t ceiling) +af_inet_bind_to_port_lt_ceiling(int fd, struct sockaddr *sockaddr, + socklen_t sockaddr_len, uint32_t ceiling) { #if GF_DISABLE_PRIVPORT_TRACKING - _assign_port (sockaddr, 0); - return bind (fd, sockaddr, sockaddr_len); + _assign_port(sockaddr, 0); + return bind(fd, sockaddr, sockaddr_len); #else - int32_t ret = -1; - uint16_t port = ceiling - 1; - unsigned char ports[GF_PORT_ARRAY_SIZE] = {0,}; - int i = 0; + int32_t ret = -1; + uint16_t port = ceiling - 1; + unsigned char ports[GF_PORT_ARRAY_SIZE] = { + 0, + }; + int i = 0; loop: - ret = gf_process_reserved_ports (ports, ceiling); + ret = gf_process_reserved_ports(ports, ceiling); - while (port) { - if (port == GF_CLIENT_PORT_CEILING) { - ret = -1; - break; - } + while (port) { + if (port == GF_CLIENT_PORT_CEILING) { + ret = -1; + break; + } - /* ignore the reserved ports */ - if (BIT_VALUE (ports, port)) { - port--; - continue; - } + /* ignore the reserved ports */ + if (BIT_VALUE(ports, port)) { + port--; + continue; + } - _assign_port (sockaddr, port); + _assign_port(sockaddr, port); - ret = bind (fd, sockaddr, sockaddr_len); + ret = bind(fd, sockaddr, sockaddr_len); - if (ret == 0) - break; + if (ret == 0) + break; - if (ret == -1 && errno == EACCES) - break; + if (ret == -1 && errno == EACCES) + break; - port--; - } + port--; + } - /* In case if all the secure ports are exhausted, we are no more - * binding to secure ports, hence instead of getting a random - * port, lets define the range to restrict it from getting from - * ports reserved for bricks i.e from range of 49152 - 65535 - * which further may lead to port clash */ - if (!port) { - ceiling = port = GF_CLNT_INSECURE_PORT_CEILING; - for (i = 0; i <= ceiling; i++) - BIT_CLEAR (ports, i); - goto loop; - } + /* In case if all the secure ports are exhausted, we are no more + * binding to secure ports, hence instead of getting a random + * port, lets define the range to restrict it from getting from + * ports reserved for bricks i.e from range of 49152 - 65535 + * which further may lead to port clash */ + if (!port) { + ceiling = port = GF_CLNT_INSECURE_PORT_CEILING; + for (i = 0; i <= ceiling; i++) + BIT_CLEAR(ports, i); + goto loop; + } - return ret; + return ret; #endif /* GF_DISABLE_PRIVPORT_TRACKING */ } static int32_t -af_unix_client_bind (rpc_transport_t *this, - struct sockaddr *sockaddr, - socklen_t sockaddr_len, - int sock) +af_unix_client_bind(rpc_transport_t *this, struct sockaddr *sockaddr, + socklen_t sockaddr_len, int sock) { - data_t *path_data = NULL; - struct sockaddr_un *addr = NULL; - int32_t ret = 0; - - path_data = dict_get (this->options, "transport.socket.bind-path"); - if (path_data) { - char *path = data_to_str (path_data); - if (!path || strlen (path) > UNIX_PATH_MAX) { - gf_log (this->name, GF_LOG_TRACE, - "bind-path not specified for unix socket, " - "letting connect to assign default value"); - goto err; - } - - addr = (struct sockaddr_un *) sockaddr; - strcpy (addr->sun_path, path); - ret = bind (sock, (struct sockaddr *)addr, sockaddr_len); - if (ret == -1) { - gf_log (this->name, GF_LOG_ERROR, - "cannot bind to unix-domain socket %d (%s)", - sock, strerror (errno)); - goto err; - } - } else { - gf_log (this->name, GF_LOG_TRACE, - "bind-path not specified for unix socket, " - "letting connect to assign default value"); + data_t *path_data = NULL; + struct sockaddr_un *addr = NULL; + int32_t ret = 0; + + path_data = dict_get(this->options, "transport.socket.bind-path"); + if (path_data) { + char *path = data_to_str(path_data); + if (!path || strlen(path) > UNIX_PATH_MAX) { + gf_log(this->name, GF_LOG_TRACE, + "bind-path not specified for unix socket, " + "letting connect to assign default value"); + goto err; + } + + addr = (struct sockaddr_un *)sockaddr; + strcpy(addr->sun_path, path); + ret = bind(sock, (struct sockaddr *)addr, sockaddr_len); + if (ret == -1) { + gf_log(this->name, GF_LOG_ERROR, + "cannot bind to unix-domain socket %d (%s)", sock, + strerror(errno)); + goto err; } + } else { + gf_log(this->name, GF_LOG_TRACE, + "bind-path not specified for unix socket, " + "letting connect to assign default value"); + } err: - return ret; + return ret; } int32_t -client_fill_address_family (rpc_transport_t *this, sa_family_t *sa_family) +client_fill_address_family(rpc_transport_t *this, sa_family_t *sa_family) { - data_t *address_family_data = NULL; - int32_t ret = -1; - - if (sa_family == NULL) { - gf_log_callingfn ("", GF_LOG_WARNING, - "sa_family argument is NULL"); - goto out; - } - - address_family_data = dict_get (this->options, - "transport.address-family"); - if (!address_family_data) { - data_t *remote_host_data = NULL, *connect_path_data = NULL; - remote_host_data = dict_get (this->options, "remote-host"); - connect_path_data = dict_get (this->options, - "transport.socket.connect-path"); - - if (!(remote_host_data || connect_path_data) || - (remote_host_data && connect_path_data)) { - gf_log (this->name, GF_LOG_ERROR, - "transport.address-family not specified. " - "Could not guess default value from (remote-host:%s or " - "transport.unix.connect-path:%s) options", - data_to_str (remote_host_data), - data_to_str (connect_path_data)); - *sa_family = AF_UNSPEC; - goto out; - } - - if (remote_host_data) { - gf_log (this->name, GF_LOG_DEBUG, - "address-family not specified, marking it as unspec " - "for getaddrinfo to resolve from (remote-host: %s)", - data_to_str(remote_host_data)); - *sa_family = AF_UNSPEC; - } else { - gf_log (this->name, GF_LOG_DEBUG, - "address-family not specified, guessing it " - "to be unix from (transport.unix.connect-path: %s)", data_to_str (connect_path_data)); - *sa_family = AF_UNIX; - } - + data_t *address_family_data = NULL; + int32_t ret = -1; + + if (sa_family == NULL) { + gf_log_callingfn("", GF_LOG_WARNING, "sa_family argument is NULL"); + goto out; + } + + address_family_data = dict_get(this->options, "transport.address-family"); + if (!address_family_data) { + data_t *remote_host_data = NULL, *connect_path_data = NULL; + remote_host_data = dict_get(this->options, "remote-host"); + connect_path_data = dict_get(this->options, + "transport.socket.connect-path"); + + if (!(remote_host_data || connect_path_data) || + (remote_host_data && connect_path_data)) { + gf_log(this->name, GF_LOG_ERROR, + "transport.address-family not specified. " + "Could not guess default value from (remote-host:%s or " + "transport.unix.connect-path:%s) options", + data_to_str(remote_host_data), + data_to_str(connect_path_data)); + *sa_family = AF_UNSPEC; + goto out; + } + + if (remote_host_data) { + gf_log(this->name, GF_LOG_DEBUG, + "address-family not specified, marking it as unspec " + "for getaddrinfo to resolve from (remote-host: %s)", + data_to_str(remote_host_data)); + *sa_family = AF_UNSPEC; } else { - char *address_family = data_to_str (address_family_data); - if (!strcasecmp (address_family, "unix")) { - *sa_family = AF_UNIX; - } else if (!strcasecmp (address_family, "inet")) { - *sa_family = AF_INET; - } else if (!strcasecmp (address_family, "inet6")) { - *sa_family = AF_INET6; - } else if (!strcasecmp (address_family, "inet-sdp")) { - *sa_family = AF_INET_SDP; - } else { - gf_log (this->name, GF_LOG_ERROR, - "unknown address-family (%s) specified", - address_family); - *sa_family = AF_UNSPEC; - goto out; - } + gf_log(this->name, GF_LOG_DEBUG, + "address-family not specified, guessing it " + "to be unix from (transport.unix.connect-path: %s)", + data_to_str(connect_path_data)); + *sa_family = AF_UNIX; + } + + } else { + char *address_family = data_to_str(address_family_data); + if (!strcasecmp(address_family, "unix")) { + *sa_family = AF_UNIX; + } else if (!strcasecmp(address_family, "inet")) { + *sa_family = AF_INET; + } else if (!strcasecmp(address_family, "inet6")) { + *sa_family = AF_INET6; + } else if (!strcasecmp(address_family, "inet-sdp")) { + *sa_family = AF_INET_SDP; + } else { + gf_log(this->name, GF_LOG_ERROR, + "unknown address-family (%s) specified", address_family); + *sa_family = AF_UNSPEC; + goto out; } + } - ret = 0; + ret = 0; out: - return ret; + return ret; } static int32_t -af_inet_client_get_remote_sockaddr (rpc_transport_t *this, - struct sockaddr *sockaddr, - socklen_t *sockaddr_len) +af_inet_client_get_remote_sockaddr(rpc_transport_t *this, + struct sockaddr *sockaddr, + socklen_t *sockaddr_len) { - dict_t *options = this->options; - data_t *remote_host_data = NULL; - data_t *remote_port_data = NULL; - char *remote_host = NULL; - uint16_t remote_port = 0; - struct addrinfo *addr_info = NULL; - int32_t ret = 0; - - remote_host_data = dict_get (options, "remote-host"); - if (remote_host_data == NULL) - { - gf_log (this->name, GF_LOG_ERROR, - "option remote-host missing in volume %s", this->name); - ret = -1; - goto err; - } - - remote_host = data_to_str (remote_host_data); - if (remote_host == NULL) - { - gf_log (this->name, GF_LOG_ERROR, - "option remote-host has data NULL in volume %s", this->name); - ret = -1; - goto err; - } - - remote_port_data = dict_get (options, "remote-port"); - if (remote_port_data == NULL) - { - gf_log (this->name, GF_LOG_TRACE, - "option remote-port missing in volume %s. Defaulting to %d", - this->name, GF_DEFAULT_SOCKET_LISTEN_PORT); - - remote_port = GF_DEFAULT_SOCKET_LISTEN_PORT; - } - else - { - remote_port = data_to_uint16 (remote_port_data); - } - - if (remote_port == (uint16_t)-1) - { - gf_log (this->name, GF_LOG_ERROR, - "option remote-port has invalid port in volume %s", - this->name); - ret = -1; - goto err; - } - - /* TODO: gf_resolve is a blocking call. kick in some - non blocking dns techniques */ - ret = gf_resolve_ip6 (remote_host, remote_port, - sockaddr->sa_family, &this->dnscache, &addr_info); - if (ret == -1) { - gf_log (this->name, GF_LOG_ERROR, - "DNS resolution failed on host %s", remote_host); - goto err; - } - - memcpy (sockaddr, addr_info->ai_addr, addr_info->ai_addrlen); - *sockaddr_len = addr_info->ai_addrlen; + dict_t *options = this->options; + data_t *remote_host_data = NULL; + data_t *remote_port_data = NULL; + char *remote_host = NULL; + uint16_t remote_port = 0; + struct addrinfo *addr_info = NULL; + int32_t ret = 0; + + remote_host_data = dict_get(options, "remote-host"); + if (remote_host_data == NULL) { + gf_log(this->name, GF_LOG_ERROR, + "option remote-host missing in volume %s", this->name); + ret = -1; + goto err; + } + + remote_host = data_to_str(remote_host_data); + if (remote_host == NULL) { + gf_log(this->name, GF_LOG_ERROR, + "option remote-host has data NULL in volume %s", this->name); + ret = -1; + goto err; + } + + remote_port_data = dict_get(options, "remote-port"); + if (remote_port_data == NULL) { + gf_log(this->name, GF_LOG_TRACE, + "option remote-port missing in volume %s. Defaulting to %d", + this->name, GF_DEFAULT_SOCKET_LISTEN_PORT); + + remote_port = GF_DEFAULT_SOCKET_LISTEN_PORT; + } else { + remote_port = data_to_uint16(remote_port_data); + } + + if (remote_port == (uint16_t)-1) { + gf_log(this->name, GF_LOG_ERROR, + "option remote-port has invalid port in volume %s", this->name); + ret = -1; + goto err; + } + + /* TODO: gf_resolve is a blocking call. kick in some + non blocking dns techniques */ + ret = gf_resolve_ip6(remote_host, remote_port, sockaddr->sa_family, + &this->dnscache, &addr_info); + if (ret == -1) { + gf_log(this->name, GF_LOG_ERROR, "DNS resolution failed on host %s", + remote_host); + goto err; + } + + memcpy(sockaddr, addr_info->ai_addr, addr_info->ai_addrlen); + *sockaddr_len = addr_info->ai_addrlen; err: - return ret; + return ret; } static int32_t -af_unix_client_get_remote_sockaddr (rpc_transport_t *this, - struct sockaddr *sockaddr, - socklen_t *sockaddr_len) +af_unix_client_get_remote_sockaddr(rpc_transport_t *this, + struct sockaddr *sockaddr, + socklen_t *sockaddr_len) { - struct sockaddr_un *sockaddr_un = NULL; - char *connect_path = NULL; - data_t *connect_path_data = NULL; - int32_t ret = 0; - - connect_path_data = dict_get (this->options, - "transport.socket.connect-path"); - if (!connect_path_data) { - gf_log (this->name, GF_LOG_ERROR, - "option transport.unix.connect-path not specified for " - "address-family unix"); - ret = -1; - goto err; - } - - connect_path = data_to_str (connect_path_data); - if (!connect_path) { - gf_log (this->name, GF_LOG_ERROR, - "transport.unix.connect-path is null-string"); - ret = -1; - goto err; - } - - if ((strlen (connect_path) + 1) > UNIX_PATH_MAX) { - gf_log (this->name, GF_LOG_ERROR, - "connect-path value length %"GF_PRI_SIZET" > %d octets", - strlen (connect_path), UNIX_PATH_MAX); - ret = -1; - goto err; - } - - gf_log (this->name, GF_LOG_TRACE, - "using connect-path %s", connect_path); - sockaddr_un = (struct sockaddr_un *)sockaddr; - strcpy (sockaddr_un->sun_path, connect_path); - *sockaddr_len = sizeof (struct sockaddr_un); + struct sockaddr_un *sockaddr_un = NULL; + char *connect_path = NULL; + data_t *connect_path_data = NULL; + int32_t ret = 0; + + connect_path_data = dict_get(this->options, + "transport.socket.connect-path"); + if (!connect_path_data) { + gf_log(this->name, GF_LOG_ERROR, + "option transport.unix.connect-path not specified for " + "address-family unix"); + ret = -1; + goto err; + } + + connect_path = data_to_str(connect_path_data); + if (!connect_path) { + gf_log(this->name, GF_LOG_ERROR, + "transport.unix.connect-path is null-string"); + ret = -1; + goto err; + } + + if ((strlen(connect_path) + 1) > UNIX_PATH_MAX) { + gf_log(this->name, GF_LOG_ERROR, + "connect-path value length %" GF_PRI_SIZET " > %d octets", + strlen(connect_path), UNIX_PATH_MAX); + ret = -1; + goto err; + } + + gf_log(this->name, GF_LOG_TRACE, "using connect-path %s", connect_path); + sockaddr_un = (struct sockaddr_un *)sockaddr; + strcpy(sockaddr_un->sun_path, connect_path); + *sockaddr_len = sizeof(struct sockaddr_un); err: - return ret; + return ret; } static int32_t -af_unix_server_get_local_sockaddr (rpc_transport_t *this, - struct sockaddr *addr, - socklen_t *addr_len) +af_unix_server_get_local_sockaddr(rpc_transport_t *this, struct sockaddr *addr, + socklen_t *addr_len) { - data_t *listen_path_data = NULL; - char *listen_path = NULL; - int32_t ret = 0; - struct sockaddr_un *sunaddr = (struct sockaddr_un *)addr; - - - listen_path_data = dict_get (this->options, - "transport.socket.listen-path"); - if (!listen_path_data) { - gf_log (this->name, GF_LOG_ERROR, - "missing option transport.socket.listen-path"); - ret = -1; - goto err; - } + data_t *listen_path_data = NULL; + char *listen_path = NULL; + int32_t ret = 0; + struct sockaddr_un *sunaddr = (struct sockaddr_un *)addr; + + listen_path_data = dict_get(this->options, "transport.socket.listen-path"); + if (!listen_path_data) { + gf_log(this->name, GF_LOG_ERROR, + "missing option transport.socket.listen-path"); + ret = -1; + goto err; + } - listen_path = data_to_str (listen_path_data); + listen_path = data_to_str(listen_path_data); #ifndef UNIX_PATH_MAX #define UNIX_PATH_MAX 108 #endif - if ((strlen (listen_path) + 1) > UNIX_PATH_MAX) { - gf_log (this->name, GF_LOG_ERROR, - "option transport.unix.listen-path has value length " - "%"GF_PRI_SIZET" > %d", - strlen (listen_path), UNIX_PATH_MAX); - ret = -1; - goto err; - } + if ((strlen(listen_path) + 1) > UNIX_PATH_MAX) { + gf_log(this->name, GF_LOG_ERROR, + "option transport.unix.listen-path has value length " + "%" GF_PRI_SIZET " > %d", + strlen(listen_path), UNIX_PATH_MAX); + ret = -1; + goto err; + } - sunaddr->sun_family = AF_UNIX; - strcpy (sunaddr->sun_path, listen_path); - *addr_len = sizeof (struct sockaddr_un); + sunaddr->sun_family = AF_UNIX; + strcpy(sunaddr->sun_path, listen_path); + *addr_len = sizeof(struct sockaddr_un); err: - return ret; + return ret; } static int32_t -af_inet_server_get_local_sockaddr (rpc_transport_t *this, - struct sockaddr *addr, - socklen_t *addr_len) +af_inet_server_get_local_sockaddr(rpc_transport_t *this, struct sockaddr *addr, + socklen_t *addr_len) { - struct addrinfo hints, *res = 0, *rp = NULL; - data_t *listen_port_data = NULL, *listen_host_data = NULL; - uint16_t listen_port = -1; - char service[NI_MAXSERV], *listen_host = NULL; - dict_t *options = NULL; - int32_t ret = 0; - - options = this->options; - - listen_port_data = dict_get (options, "transport.socket.listen-port"); - listen_host_data = dict_get (options, "transport.socket.bind-address"); - - if (listen_port_data) - { - listen_port = data_to_uint16 (listen_port_data); - } - - if (listen_port == (uint16_t) -1) - listen_port = GF_DEFAULT_SOCKET_LISTEN_PORT; - - - if (listen_host_data) - { - listen_host = data_to_str (listen_host_data); - } else { - if (addr->sa_family == AF_INET6) { - struct sockaddr_in6 *in = (struct sockaddr_in6 *) addr; - in->sin6_addr = in6addr_any; - in->sin6_port = htons(listen_port); - *addr_len = sizeof(struct sockaddr_in6); - goto out; - } else if (addr->sa_family == AF_INET) { - struct sockaddr_in *in = (struct sockaddr_in *) addr; - in->sin_addr.s_addr = htonl(INADDR_ANY); - in->sin_port = htons(listen_port); - *addr_len = sizeof(struct sockaddr_in); - goto out; - } - } - - sprintf (service, "%d", listen_port); - - memset (&hints, 0, sizeof (hints)); - hints.ai_family = addr->sa_family; - hints.ai_socktype = SOCK_STREAM; - hints.ai_flags = AI_PASSIVE; - - ret = getaddrinfo(listen_host, service, &hints, &res); - if (ret != 0) { - gf_log (this->name, GF_LOG_ERROR, - "getaddrinfo failed for host %s, service %s (%s)", - listen_host, service, gai_strerror (ret)); - ret = -1; - goto out; - } - /* IPV6 server can handle both ipv4 and ipv6 clients */ - for (rp = res; rp != NULL; rp = rp->ai_next) { - if (rp->ai_addr == NULL) - continue; - if (rp->ai_family == AF_INET6) { - memcpy (addr, rp->ai_addr, rp->ai_addrlen); - *addr_len = rp->ai_addrlen; - } - } - - if (!(*addr_len)) { - memcpy (addr, res->ai_addr, res->ai_addrlen); - *addr_len = res->ai_addrlen; - } - - freeaddrinfo (res); + struct addrinfo hints, *res = 0, *rp = NULL; + data_t *listen_port_data = NULL, *listen_host_data = NULL; + uint16_t listen_port = -1; + char service[NI_MAXSERV], *listen_host = NULL; + dict_t *options = NULL; + int32_t ret = 0; + + options = this->options; + + listen_port_data = dict_get(options, "transport.socket.listen-port"); + listen_host_data = dict_get(options, "transport.socket.bind-address"); + + if (listen_port_data) { + listen_port = data_to_uint16(listen_port_data); + } + + if (listen_port == (uint16_t)-1) + listen_port = GF_DEFAULT_SOCKET_LISTEN_PORT; + + if (listen_host_data) { + listen_host = data_to_str(listen_host_data); + } else { + if (addr->sa_family == AF_INET6) { + struct sockaddr_in6 *in = (struct sockaddr_in6 *)addr; + in->sin6_addr = in6addr_any; + in->sin6_port = htons(listen_port); + *addr_len = sizeof(struct sockaddr_in6); + goto out; + } else if (addr->sa_family == AF_INET) { + struct sockaddr_in *in = (struct sockaddr_in *)addr; + in->sin_addr.s_addr = htonl(INADDR_ANY); + in->sin_port = htons(listen_port); + *addr_len = sizeof(struct sockaddr_in); + goto out; + } + } + + sprintf(service, "%d", listen_port); + + memset(&hints, 0, sizeof(hints)); + hints.ai_family = addr->sa_family; + hints.ai_socktype = SOCK_STREAM; + hints.ai_flags = AI_PASSIVE; + + ret = getaddrinfo(listen_host, service, &hints, &res); + if (ret != 0) { + gf_log(this->name, GF_LOG_ERROR, + "getaddrinfo failed for host %s, service %s (%s)", listen_host, + service, gai_strerror(ret)); + ret = -1; + goto out; + } + /* IPV6 server can handle both ipv4 and ipv6 clients */ + for (rp = res; rp != NULL; rp = rp->ai_next) { + if (rp->ai_addr == NULL) + continue; + if (rp->ai_family == AF_INET6) { + memcpy(addr, rp->ai_addr, rp->ai_addrlen); + *addr_len = rp->ai_addrlen; + } + } + + if (!(*addr_len)) { + memcpy(addr, res->ai_addr, res->ai_addrlen); + *addr_len = res->ai_addrlen; + } + + freeaddrinfo(res); out: - return ret; + return ret; } int32_t -client_bind (rpc_transport_t *this, - struct sockaddr *sockaddr, - socklen_t *sockaddr_len, - int sock) +client_bind(rpc_transport_t *this, struct sockaddr *sockaddr, + socklen_t *sockaddr_len, int sock) { - int ret = 0; + int ret = 0; - *sockaddr_len = sizeof (struct sockaddr_in6); - switch (sockaddr->sa_family) - { + *sockaddr_len = sizeof(struct sockaddr_in6); + switch (sockaddr->sa_family) { case AF_INET_SDP: case AF_INET: - *sockaddr_len = sizeof (struct sockaddr_in); + *sockaddr_len = sizeof(struct sockaddr_in); /* Fall through */ case AF_INET6: - if (!this->bind_insecure) { - ret = af_inet_bind_to_port_lt_ceiling (sock, sockaddr, - *sockaddr_len, - GF_CLIENT_PORT_CEILING); - if (ret == -1) { - gf_log (this->name, GF_LOG_DEBUG, - "cannot bind inet socket (%d) " - "to port less than %d (%s)", - sock, GF_CLIENT_PORT_CEILING, - strerror (errno)); - ret = 0; - } - } else { - ret = af_inet_bind_to_port_lt_ceiling (sock, sockaddr, - *sockaddr_len, - GF_IANA_PRIV_PORTS_START); - if (ret == -1) { - gf_log (this->name, GF_LOG_DEBUG, - "failed while binding to less than " - "%d (%s)", GF_IANA_PRIV_PORTS_START, - strerror (errno)); - ret = 0; - } + if (!this->bind_insecure) { + ret = af_inet_bind_to_port_lt_ceiling( + sock, sockaddr, *sockaddr_len, GF_CLIENT_PORT_CEILING); + if (ret == -1) { + gf_log(this->name, GF_LOG_DEBUG, + "cannot bind inet socket (%d) " + "to port less than %d (%s)", + sock, GF_CLIENT_PORT_CEILING, strerror(errno)); + ret = 0; + } + } else { + ret = af_inet_bind_to_port_lt_ceiling( + sock, sockaddr, *sockaddr_len, GF_IANA_PRIV_PORTS_START); + if (ret == -1) { + gf_log(this->name, GF_LOG_DEBUG, + "failed while binding to less than " + "%d (%s)", + GF_IANA_PRIV_PORTS_START, strerror(errno)); + ret = 0; } - break; + } + break; case AF_UNIX: - *sockaddr_len = sizeof (struct sockaddr_un); - ret = af_unix_client_bind (this, (struct sockaddr *)sockaddr, - *sockaddr_len, sock); - break; + *sockaddr_len = sizeof(struct sockaddr_un); + ret = af_unix_client_bind(this, (struct sockaddr *)sockaddr, + *sockaddr_len, sock); + break; default: - gf_log (this->name, GF_LOG_ERROR, - "unknown address family %d", sockaddr->sa_family); - ret = -1; - break; - } + gf_log(this->name, GF_LOG_ERROR, "unknown address family %d", + sockaddr->sa_family); + ret = -1; + break; + } - return ret; + return ret; } int32_t -socket_client_get_remote_sockaddr (rpc_transport_t *this, - struct sockaddr *sockaddr, - socklen_t *sockaddr_len, - sa_family_t *sa_family) +socket_client_get_remote_sockaddr(rpc_transport_t *this, + struct sockaddr *sockaddr, + socklen_t *sockaddr_len, + sa_family_t *sa_family) { - int32_t ret = 0; + int32_t ret = 0; - GF_VALIDATE_OR_GOTO ("socket", sockaddr, err); - GF_VALIDATE_OR_GOTO ("socket", sockaddr_len, err); - GF_VALIDATE_OR_GOTO ("socket", sa_family, err); + GF_VALIDATE_OR_GOTO("socket", sockaddr, err); + GF_VALIDATE_OR_GOTO("socket", sockaddr_len, err); + GF_VALIDATE_OR_GOTO("socket", sa_family, err); - ret = client_fill_address_family (this, &sockaddr->sa_family); - if (ret) { - ret = -1; - goto err; - } + ret = client_fill_address_family(this, &sockaddr->sa_family); + if (ret) { + ret = -1; + goto err; + } - *sa_family = sockaddr->sa_family; + *sa_family = sockaddr->sa_family; - switch (sockaddr->sa_family) - { + switch (sockaddr->sa_family) { case AF_INET_SDP: - sockaddr->sa_family = AF_INET; + sockaddr->sa_family = AF_INET; /* Fall through */ case AF_INET: case AF_INET6: case AF_UNSPEC: - ret = af_inet_client_get_remote_sockaddr (this, sockaddr, - sockaddr_len); - break; + ret = af_inet_client_get_remote_sockaddr(this, sockaddr, + sockaddr_len); + break; case AF_UNIX: - ret = af_unix_client_get_remote_sockaddr (this, sockaddr, - sockaddr_len); - break; + ret = af_unix_client_get_remote_sockaddr(this, sockaddr, + sockaddr_len); + break; default: - gf_log (this->name, GF_LOG_ERROR, - "unknown address-family %d", sockaddr->sa_family); - ret = -1; - } + gf_log(this->name, GF_LOG_ERROR, "unknown address-family %d", + sockaddr->sa_family); + ret = -1; + } - if (*sa_family == AF_UNSPEC) { - *sa_family = sockaddr->sa_family; - } + if (*sa_family == AF_UNSPEC) { + *sa_family = sockaddr->sa_family; + } err: - return ret; + return ret; } - int32_t -server_fill_address_family (rpc_transport_t *this, sa_family_t *sa_family) +server_fill_address_family(rpc_transport_t *this, sa_family_t *sa_family) { - data_t *address_family_data = NULL; - int32_t ret = -1; + data_t *address_family_data = NULL; + int32_t ret = -1; #ifdef IPV6_DEFAULT - char *addr_family = "inet6"; - sa_family_t default_family = AF_INET6; + char *addr_family = "inet6"; + sa_family_t default_family = AF_INET6; #else - char *addr_family = "inet"; - sa_family_t default_family = AF_INET; + char *addr_family = "inet"; + sa_family_t default_family = AF_INET; #endif - GF_VALIDATE_OR_GOTO ("socket", sa_family, out); - - address_family_data = dict_get (this->options, - "transport.address-family"); - if (address_family_data) { - char *address_family = NULL; - address_family = data_to_str (address_family_data); - - if (!strcasecmp (address_family, "inet")) { - *sa_family = AF_INET; - } else if (!strcasecmp (address_family, "inet6")) { - *sa_family = AF_INET6; - } else if (!strcasecmp (address_family, "inet-sdp")) { - *sa_family = AF_INET_SDP; - } else if (!strcasecmp (address_family, "unix")) { - *sa_family = AF_UNIX; - } else { - gf_log (this->name, GF_LOG_ERROR, - "unknown address family (%s) specified", address_family); - *sa_family = AF_UNSPEC; - goto out; - } + GF_VALIDATE_OR_GOTO("socket", sa_family, out); + + address_family_data = dict_get(this->options, "transport.address-family"); + if (address_family_data) { + char *address_family = NULL; + address_family = data_to_str(address_family_data); + + if (!strcasecmp(address_family, "inet")) { + *sa_family = AF_INET; + } else if (!strcasecmp(address_family, "inet6")) { + *sa_family = AF_INET6; + } else if (!strcasecmp(address_family, "inet-sdp")) { + *sa_family = AF_INET_SDP; + } else if (!strcasecmp(address_family, "unix")) { + *sa_family = AF_UNIX; } else { - gf_log (this->name, GF_LOG_DEBUG, - "option address-family not specified, " - "defaulting to %s", addr_family); - *sa_family = default_family; - } - - ret = 0; + gf_log(this->name, GF_LOG_ERROR, + "unknown address family (%s) specified", address_family); + *sa_family = AF_UNSPEC; + goto out; + } + } else { + gf_log(this->name, GF_LOG_DEBUG, + "option address-family not specified, " + "defaulting to %s", + addr_family); + *sa_family = default_family; + } + + ret = 0; out: - return ret; + return ret; } - int32_t -socket_server_get_local_sockaddr (rpc_transport_t *this, struct sockaddr *addr, - socklen_t *addr_len, sa_family_t *sa_family) +socket_server_get_local_sockaddr(rpc_transport_t *this, struct sockaddr *addr, + socklen_t *addr_len, sa_family_t *sa_family) { - int32_t ret = -1; + int32_t ret = -1; - GF_VALIDATE_OR_GOTO ("socket", sa_family, err); - GF_VALIDATE_OR_GOTO ("socket", addr, err); - GF_VALIDATE_OR_GOTO ("socket", addr_len, err); + GF_VALIDATE_OR_GOTO("socket", sa_family, err); + GF_VALIDATE_OR_GOTO("socket", addr, err); + GF_VALIDATE_OR_GOTO("socket", addr_len, err); - ret = server_fill_address_family (this, &addr->sa_family); - if (ret == -1) { - goto err; - } + ret = server_fill_address_family(this, &addr->sa_family); + if (ret == -1) { + goto err; + } - *sa_family = addr->sa_family; + *sa_family = addr->sa_family; - switch (addr->sa_family) - { + switch (addr->sa_family) { case AF_INET_SDP: - addr->sa_family = AF_INET; - /* Fall through */ + addr->sa_family = AF_INET; + /* Fall through */ case AF_INET: case AF_INET6: case AF_UNSPEC: - ret = af_inet_server_get_local_sockaddr (this, addr, addr_len); - break; + ret = af_inet_server_get_local_sockaddr(this, addr, addr_len); + break; case AF_UNIX: - ret = af_unix_server_get_local_sockaddr (this, addr, addr_len); - break; - } + ret = af_unix_server_get_local_sockaddr(this, addr, addr_len); + break; + } - if (*sa_family == AF_UNSPEC) { - *sa_family = addr->sa_family; - } + if (*sa_family == AF_UNSPEC) { + *sa_family = addr->sa_family; + } err: - return ret; + return ret; } int32_t -fill_inet6_inet_identifiers (rpc_transport_t *this, struct sockaddr_storage *addr, - int32_t addr_len, char *identifier) +fill_inet6_inet_identifiers(rpc_transport_t *this, + struct sockaddr_storage *addr, int32_t addr_len, + char *identifier) { - union gf_sock_union sock_union; - - char service[NI_MAXSERV] = {0,}; - char host[NI_MAXHOST] = {0,}; - int32_t ret = 0; - int32_t tmpaddr_len = 0; - int32_t one_to_four = 0; - int32_t four_to_eight = 0; - int32_t twelve_to_sixteen = 0; - int16_t eight_to_ten = 0; - int16_t ten_to_twelve = 0; - - memset (&sock_union, 0, sizeof (sock_union)); - sock_union.storage = *addr; - tmpaddr_len = addr_len; - - if (sock_union.sa.sa_family == AF_INET6) { - one_to_four = sock_union.sin6.sin6_addr.s6_addr32[0]; - four_to_eight = sock_union.sin6.sin6_addr.s6_addr32[1]; + union gf_sock_union sock_union; + + char service[NI_MAXSERV] = { + 0, + }; + char host[NI_MAXHOST] = { + 0, + }; + int32_t ret = 0; + int32_t tmpaddr_len = 0; + int32_t one_to_four = 0; + int32_t four_to_eight = 0; + int32_t twelve_to_sixteen = 0; + int16_t eight_to_ten = 0; + int16_t ten_to_twelve = 0; + + memset(&sock_union, 0, sizeof(sock_union)); + sock_union.storage = *addr; + tmpaddr_len = addr_len; + + if (sock_union.sa.sa_family == AF_INET6) { + one_to_four = sock_union.sin6.sin6_addr.s6_addr32[0]; + four_to_eight = sock_union.sin6.sin6_addr.s6_addr32[1]; #ifdef GF_SOLARIS_HOST_OS - eight_to_ten = S6_ADDR16(sock_union.sin6.sin6_addr)[4]; + eight_to_ten = S6_ADDR16(sock_union.sin6.sin6_addr)[4]; #else - eight_to_ten = sock_union.sin6.sin6_addr.s6_addr16[4]; + eight_to_ten = sock_union.sin6.sin6_addr.s6_addr16[4]; #endif #ifdef GF_SOLARIS_HOST_OS - ten_to_twelve = S6_ADDR16(sock_union.sin6.sin6_addr)[5]; + ten_to_twelve = S6_ADDR16(sock_union.sin6.sin6_addr)[5]; #else - ten_to_twelve = sock_union.sin6.sin6_addr.s6_addr16[5]; + ten_to_twelve = sock_union.sin6.sin6_addr.s6_addr16[5]; #endif - twelve_to_sixteen = sock_union.sin6.sin6_addr.s6_addr32[3]; - - /* ipv4 mapped ipv6 address has - bits 0-80: 0 - bits 80-96: 0xffff - bits 96-128: ipv4 address - */ - - if (one_to_four == 0 && - four_to_eight == 0 && - eight_to_ten == 0 && - ten_to_twelve == -1) { - struct sockaddr_in *in_ptr = &sock_union.sin; - memset (&sock_union, 0, sizeof (sock_union)); - - in_ptr->sin_family = AF_INET; - in_ptr->sin_port = ((struct sockaddr_in6 *)addr)->sin6_port; - in_ptr->sin_addr.s_addr = twelve_to_sixteen; - tmpaddr_len = sizeof (*in_ptr); - } - } + twelve_to_sixteen = sock_union.sin6.sin6_addr.s6_addr32[3]; + + /* ipv4 mapped ipv6 address has + bits 0-80: 0 + bits 80-96: 0xffff + bits 96-128: ipv4 address + */ + + if (one_to_four == 0 && four_to_eight == 0 && eight_to_ten == 0 && + ten_to_twelve == -1) { + struct sockaddr_in *in_ptr = &sock_union.sin; + memset(&sock_union, 0, sizeof(sock_union)); - ret = getnameinfo (&sock_union.sa, - tmpaddr_len, - host, sizeof (host), - service, sizeof (service), - NI_NUMERICHOST | NI_NUMERICSERV); - if (ret != 0) { - gf_log (this->name, GF_LOG_ERROR, - "getnameinfo failed (%s)", gai_strerror (ret)); + in_ptr->sin_family = AF_INET; + in_ptr->sin_port = ((struct sockaddr_in6 *)addr)->sin6_port; + in_ptr->sin_addr.s_addr = twelve_to_sixteen; + tmpaddr_len = sizeof(*in_ptr); } + } - sprintf (identifier, "%s:%s", host, service); + ret = getnameinfo(&sock_union.sa, tmpaddr_len, host, sizeof(host), service, + sizeof(service), NI_NUMERICHOST | NI_NUMERICSERV); + if (ret != 0) { + gf_log(this->name, GF_LOG_ERROR, "getnameinfo failed (%s)", + gai_strerror(ret)); + } - return ret; + sprintf(identifier, "%s:%s", host, service); + + return ret; } int32_t -get_transport_identifiers (rpc_transport_t *this) +get_transport_identifiers(rpc_transport_t *this) { - int32_t ret = 0; - char is_inet_sdp = 0; + int32_t ret = 0; + char is_inet_sdp = 0; - switch (((struct sockaddr *) &this->myinfo.sockaddr)->sa_family) - { + switch (((struct sockaddr *)&this->myinfo.sockaddr)->sa_family) { case AF_INET_SDP: - is_inet_sdp = 1; - ((struct sockaddr *) &this->peerinfo.sockaddr)->sa_family = ((struct sockaddr *) &this->myinfo.sockaddr)->sa_family = AF_INET; + is_inet_sdp = 1; + ((struct sockaddr *)&this->peerinfo.sockaddr) + ->sa_family = ((struct sockaddr *)&this->myinfo.sockaddr) + ->sa_family = AF_INET; /* Fall through */ case AF_INET: - case AF_INET6: - { - ret = fill_inet6_inet_identifiers (this, - &this->myinfo.sockaddr, - this->myinfo.sockaddr_len, - this->myinfo.identifier); - if (ret == -1) { - gf_log (this->name, GF_LOG_ERROR, - "cannot fill inet/inet6 identifier for server"); - goto err; - } - - ret = fill_inet6_inet_identifiers (this, - &this->peerinfo.sockaddr, - this->peerinfo.sockaddr_len, - this->peerinfo.identifier); - if (ret == -1) { - gf_log (this->name, GF_LOG_ERROR, - "cannot fill inet/inet6 identifier for client"); - goto err; - } + case AF_INET6: { + ret = fill_inet6_inet_identifiers(this, &this->myinfo.sockaddr, + this->myinfo.sockaddr_len, + this->myinfo.identifier); + if (ret == -1) { + gf_log(this->name, GF_LOG_ERROR, + "cannot fill inet/inet6 identifier for server"); + goto err; + } + + ret = fill_inet6_inet_identifiers(this, &this->peerinfo.sockaddr, + this->peerinfo.sockaddr_len, + this->peerinfo.identifier); + if (ret == -1) { + gf_log(this->name, GF_LOG_ERROR, + "cannot fill inet/inet6 identifier for client"); + goto err; + } - if (is_inet_sdp) { - ((struct sockaddr *) &this->peerinfo.sockaddr)->sa_family = ((struct sockaddr *) &this->myinfo.sockaddr)->sa_family = AF_INET_SDP; - } - } - break; + if (is_inet_sdp) { + ((struct sockaddr *)&this->peerinfo.sockaddr) + ->sa_family = ((struct sockaddr *)&this->myinfo.sockaddr) + ->sa_family = AF_INET_SDP; + } + } break; - case AF_UNIX: - { - struct sockaddr_un *sunaddr = NULL; + case AF_UNIX: { + struct sockaddr_un *sunaddr = NULL; - sunaddr = (struct sockaddr_un *) &this->myinfo.sockaddr; - strcpy (this->myinfo.identifier, sunaddr->sun_path); + sunaddr = (struct sockaddr_un *)&this->myinfo.sockaddr; + strcpy(this->myinfo.identifier, sunaddr->sun_path); - sunaddr = (struct sockaddr_un *) &this->peerinfo.sockaddr; - strcpy (this->peerinfo.identifier, sunaddr->sun_path); - } - break; + sunaddr = (struct sockaddr_un *)&this->peerinfo.sockaddr; + strcpy(this->peerinfo.identifier, sunaddr->sun_path); + } break; default: - gf_log (this->name, GF_LOG_ERROR, - "unknown address family (%d)", - ((struct sockaddr *) &this->myinfo.sockaddr)->sa_family); - ret = -1; - break; - } + gf_log(this->name, GF_LOG_ERROR, "unknown address family (%d)", + ((struct sockaddr *)&this->myinfo.sockaddr)->sa_family); + ret = -1; + break; + } err: - return ret; + return ret; } diff --git a/rpc/rpc-transport/socket/src/socket.c b/rpc/rpc-transport/socket/src/socket.c index 2c222ce8321..b3f8b7fc580 100644 --- a/rpc/rpc-transport/socket/src/socket.c +++ b/rpc/rpc-transport/socket/src/socket.c @@ -42,591 +42,583 @@ #define GF_LOG_ERRNO(errno) ((errno == ENOTCONN) ? GF_LOG_DEBUG : GF_LOG_ERROR) #define SA(ptr) ((struct sockaddr *)ptr) -#define SSL_ENABLED_OPT "transport.socket.ssl-enabled" -#define SSL_OWN_CERT_OPT "transport.socket.ssl-own-cert" +#define SSL_ENABLED_OPT "transport.socket.ssl-enabled" +#define SSL_OWN_CERT_OPT "transport.socket.ssl-own-cert" #define SSL_PRIVATE_KEY_OPT "transport.socket.ssl-private-key" -#define SSL_CA_LIST_OPT "transport.socket.ssl-ca-list" -#define SSL_CERT_DEPTH_OPT "transport.socket.ssl-cert-depth" +#define SSL_CA_LIST_OPT "transport.socket.ssl-ca-list" +#define SSL_CERT_DEPTH_OPT "transport.socket.ssl-cert-depth" #define SSL_CIPHER_LIST_OPT "transport.socket.ssl-cipher-list" -#define SSL_DH_PARAM_OPT "transport.socket.ssl-dh-param" -#define SSL_EC_CURVE_OPT "transport.socket.ssl-ec-curve" -#define SSL_CRL_PATH_OPT "transport.socket.ssl-crl-path" -#define OWN_THREAD_OPT "transport.socket.own-thread" +#define SSL_DH_PARAM_OPT "transport.socket.ssl-dh-param" +#define SSL_EC_CURVE_OPT "transport.socket.ssl-ec-curve" +#define SSL_CRL_PATH_OPT "transport.socket.ssl-crl-path" +#define OWN_THREAD_OPT "transport.socket.own-thread" /* TBD: do automake substitutions etc. (ick) to set these. */ #if !defined(DEFAULT_ETC_SSL) -# ifdef GF_LINUX_HOST_OS -# define DEFAULT_ETC_SSL "/etc/ssl" -# endif -# ifdef GF_BSD_HOST_OS -# define DEFAULT_ETC_SSL "/etc/openssl" -# endif -# ifdef GF_DARWIN_HOST_OS -# define DEFAULT_ETC_SSL "/usr/local/etc/openssl" -# endif -# if !defined(DEFAULT_ETC_SSL) -# define DEFAULT_ETC_SSL "/etc/ssl" -# endif +#ifdef GF_LINUX_HOST_OS +#define DEFAULT_ETC_SSL "/etc/ssl" +#endif +#ifdef GF_BSD_HOST_OS +#define DEFAULT_ETC_SSL "/etc/openssl" +#endif +#ifdef GF_DARWIN_HOST_OS +#define DEFAULT_ETC_SSL "/usr/local/etc/openssl" +#endif +#if !defined(DEFAULT_ETC_SSL) +#define DEFAULT_ETC_SSL "/etc/ssl" +#endif #endif #if !defined(DEFAULT_CERT_PATH) -#define DEFAULT_CERT_PATH DEFAULT_ETC_SSL "/glusterfs.pem" +#define DEFAULT_CERT_PATH DEFAULT_ETC_SSL "/glusterfs.pem" #endif #if !defined(DEFAULT_KEY_PATH) -#define DEFAULT_KEY_PATH DEFAULT_ETC_SSL "/glusterfs.key" +#define DEFAULT_KEY_PATH DEFAULT_ETC_SSL "/glusterfs.key" #endif #if !defined(DEFAULT_CA_PATH) -#define DEFAULT_CA_PATH DEFAULT_ETC_SSL "/glusterfs.ca" +#define DEFAULT_CA_PATH DEFAULT_ETC_SSL "/glusterfs.ca" #endif #if !defined(DEFAULT_VERIFY_DEPTH) #define DEFAULT_VERIFY_DEPTH 1 #endif #define DEFAULT_CIPHER_LIST "EECDH:EDH:HIGH:!3DES:!RC4:!DES:!MD5:!aNULL:!eNULL" -#define DEFAULT_DH_PARAM DEFAULT_ETC_SSL "/dhparam.pem" -#define DEFAULT_EC_CURVE "prime256v1" +#define DEFAULT_DH_PARAM DEFAULT_ETC_SSL "/dhparam.pem" +#define DEFAULT_EC_CURVE "prime256v1" -#define POLL_MASK_INPUT (POLLIN | POLLPRI) +#define POLL_MASK_INPUT (POLLIN | POLLPRI) #define POLL_MASK_OUTPUT (POLLOUT) -#define POLL_MASK_ERROR (POLLERR | POLLHUP | POLLNVAL) - -typedef int SSL_unary_func (SSL *); -typedef int SSL_trinary_func (SSL *, void *, int); -static int ssl_setup_connection_params(rpc_transport_t *this); - -#define __socket_proto_reset_pending(priv) do { \ - struct gf_sock_incoming_frag *frag; \ - frag = &priv->incoming.frag; \ - \ - memset (&frag->vector, 0, sizeof (frag->vector)); \ - frag->pending_vector = &frag->vector; \ - frag->pending_vector->iov_base = frag->fragcurrent; \ - priv->incoming.pending_vector = frag->pending_vector; \ - } while (0) - - -#define __socket_proto_update_pending(priv) \ - do { \ - uint32_t remaining; \ - struct gf_sock_incoming_frag *frag; \ - frag = &priv->incoming.frag; \ - if (frag->pending_vector->iov_len == 0) { \ - remaining = (RPC_FRAGSIZE (priv->incoming.fraghdr) \ - - frag->bytes_read); \ - \ - frag->pending_vector->iov_len = \ - (remaining > frag->remaining_size) \ - ? frag->remaining_size : remaining; \ - \ - frag->remaining_size -= \ - frag->pending_vector->iov_len; \ - } \ - } while (0) - -#define __socket_proto_update_priv_after_read(priv, ret, bytes_read) \ - { \ - struct gf_sock_incoming_frag *frag; \ - frag = &priv->incoming.frag; \ - \ - frag->fragcurrent += bytes_read; \ - frag->bytes_read += bytes_read; \ - \ - if ((ret > 0) || (frag->remaining_size != 0)) { \ - if (frag->remaining_size != 0 && ret == 0) { \ - __socket_proto_reset_pending (priv); \ - } \ - \ - gf_log (this->name, GF_LOG_TRACE, \ - "partial read on non-blocking socket"); \ - \ - break; \ - } \ - } - -#define __socket_proto_init_pending(priv,size) \ - do { \ - uint32_t remaining = 0; \ - struct gf_sock_incoming_frag *frag; \ - frag = &priv->incoming.frag; \ - \ - remaining = (RPC_FRAGSIZE (priv->incoming.fraghdr) \ - - frag->bytes_read); \ - \ - __socket_proto_reset_pending (priv); \ - \ - frag->pending_vector->iov_len = \ - (remaining > size) ? size : remaining; \ - \ - frag->remaining_size = (size - frag->pending_vector->iov_len); \ - \ - } while(0) +#define POLL_MASK_ERROR (POLLERR | POLLHUP | POLLNVAL) +typedef int +SSL_unary_func(SSL *); +typedef int +SSL_trinary_func(SSL *, void *, int); +static int +ssl_setup_connection_params(rpc_transport_t *this); + +#define __socket_proto_reset_pending(priv) \ + do { \ + struct gf_sock_incoming_frag *frag; \ + frag = &priv->incoming.frag; \ + \ + memset(&frag->vector, 0, sizeof(frag->vector)); \ + frag->pending_vector = &frag->vector; \ + frag->pending_vector->iov_base = frag->fragcurrent; \ + priv->incoming.pending_vector = frag->pending_vector; \ + } while (0) + +#define __socket_proto_update_pending(priv) \ + do { \ + uint32_t remaining; \ + struct gf_sock_incoming_frag *frag; \ + frag = &priv->incoming.frag; \ + if (frag->pending_vector->iov_len == 0) { \ + remaining = (RPC_FRAGSIZE(priv->incoming.fraghdr) - \ + frag->bytes_read); \ + \ + frag->pending_vector->iov_len = (remaining > frag->remaining_size) \ + ? frag->remaining_size \ + : remaining; \ + \ + frag->remaining_size -= frag->pending_vector->iov_len; \ + } \ + } while (0) + +#define __socket_proto_update_priv_after_read(priv, ret, bytes_read) \ + { \ + struct gf_sock_incoming_frag *frag; \ + frag = &priv->incoming.frag; \ + \ + frag->fragcurrent += bytes_read; \ + frag->bytes_read += bytes_read; \ + \ + if ((ret > 0) || (frag->remaining_size != 0)) { \ + if (frag->remaining_size != 0 && ret == 0) { \ + __socket_proto_reset_pending(priv); \ + } \ + \ + gf_log(this->name, GF_LOG_TRACE, \ + "partial read on non-blocking socket"); \ + \ + break; \ + } \ + } + +#define __socket_proto_init_pending(priv, size) \ + do { \ + uint32_t remaining = 0; \ + struct gf_sock_incoming_frag *frag; \ + frag = &priv->incoming.frag; \ + \ + remaining = (RPC_FRAGSIZE(priv->incoming.fraghdr) - frag->bytes_read); \ + \ + __socket_proto_reset_pending(priv); \ + \ + frag->pending_vector->iov_len = (remaining > size) ? size : remaining; \ + \ + frag->remaining_size = (size - frag->pending_vector->iov_len); \ + \ + } while (0) /* This will be used in a switch case and breaks from the switch case if all * the pending data is not read. */ -#define __socket_proto_read(priv, ret) \ - { \ - size_t bytes_read = 0; \ - struct gf_sock_incoming *in; \ - in = &priv->incoming; \ - \ - __socket_proto_update_pending (priv); \ - \ - ret = __socket_readv (this, \ - in->pending_vector, 1, \ - &in->pending_vector, \ - &in->pending_count, \ - &bytes_read); \ - if (ret == -1) \ - break; \ - __socket_proto_update_priv_after_read (priv, ret, bytes_read); \ - } +#define __socket_proto_read(priv, ret) \ + { \ + size_t bytes_read = 0; \ + struct gf_sock_incoming *in; \ + in = &priv->incoming; \ + \ + __socket_proto_update_pending(priv); \ + \ + ret = __socket_readv(this, in->pending_vector, 1, &in->pending_vector, \ + &in->pending_count, &bytes_read); \ + if (ret == -1) \ + break; \ + __socket_proto_update_priv_after_read(priv, ret, bytes_read); \ + } struct socket_connect_error_state_ { - xlator_t *this; - rpc_transport_t *trans; - gf_boolean_t refd; + xlator_t *this; + rpc_transport_t *trans; + gf_boolean_t refd; }; typedef struct socket_connect_error_state_ socket_connect_error_state_t; -static int socket_init (rpc_transport_t *this); -static int __socket_nonblock (int fd); +static int +socket_init(rpc_transport_t *this); +static int +__socket_nonblock(int fd); static void -socket_dump_info (struct sockaddr *sa, int is_server, int is_ssl, int sock, - char *log_domain, char *log_label) +socket_dump_info(struct sockaddr *sa, int is_server, int is_ssl, int sock, + char *log_domain, char *log_label) { - char addr_buf[INET6_ADDRSTRLEN+1] = {0, }; - char *addr = NULL; - char *peer_type = NULL; - int af = sa->sa_family; - int so_error = -1; - socklen_t slen = sizeof(so_error); - - if (af == AF_UNIX) { - addr = ((struct sockaddr_un *)(sa))->sun_path; + char addr_buf[INET6_ADDRSTRLEN + 1] = { + 0, + }; + char *addr = NULL; + char *peer_type = NULL; + int af = sa->sa_family; + int so_error = -1; + socklen_t slen = sizeof(so_error); + + if (af == AF_UNIX) { + addr = ((struct sockaddr_un *)(sa))->sun_path; + } else { + if (af == AF_INET6) { + struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)(sa); + + inet_ntop(af, &sin6->sin6_addr, addr_buf, sizeof(addr_buf)); + addr = addr_buf; } else { - if (af == AF_INET6) { - struct sockaddr_in6 *sin6 = - (struct sockaddr_in6 *)(sa); + struct sockaddr_in *sin = (struct sockaddr_in *)(sa); - inet_ntop (af, &sin6->sin6_addr, addr_buf, - sizeof (addr_buf)); - addr = addr_buf; - } else { - struct sockaddr_in *sin = - (struct sockaddr_in *)(sa); - - inet_ntop (af, &sin->sin_addr, addr_buf, - sizeof (addr_buf)); - addr = addr_buf; - } + inet_ntop(af, &sin->sin_addr, addr_buf, sizeof(addr_buf)); + addr = addr_buf; } - if (is_server) - peer_type = "server"; - else - peer_type = "client"; + } + if (is_server) + peer_type = "server"; + else + peer_type = "client"; - getsockopt (sock, SOL_SOCKET, SO_ERROR, &so_error, &slen); + getsockopt(sock, SOL_SOCKET, SO_ERROR, &so_error, &slen); - gf_log (log_domain, GF_LOG_TRACE, - "$$$ %s: %s (af:%d,sock:%d) %s %s (errno:%d:%s)", - peer_type, log_label, af, sock, addr, - (is_ssl ? "SSL" : "non-SSL"), - so_error, strerror (so_error)); + gf_log(log_domain, GF_LOG_TRACE, + "$$$ %s: %s (af:%d,sock:%d) %s %s (errno:%d:%s)", peer_type, + log_label, af, sock, addr, (is_ssl ? "SSL" : "non-SSL"), so_error, + strerror(so_error)); } static void -ssl_dump_error_stack (const char *caller) +ssl_dump_error_stack(const char *caller) { - unsigned long errnum = 0; - char errbuf[120] = {0, }; + unsigned long errnum = 0; + char errbuf[120] = { + 0, + }; - /* OpenSSL docs explicitly give 120 as the error-string length. */ + /* OpenSSL docs explicitly give 120 as the error-string length. */ - while ((errnum = ERR_get_error())) { - ERR_error_string(errnum, errbuf); - gf_log(caller, GF_LOG_ERROR, " %s", errbuf); - } + while ((errnum = ERR_get_error())) { + ERR_error_string(errnum, errbuf); + gf_log(caller, GF_LOG_ERROR, " %s", errbuf); + } } static int -ssl_do (rpc_transport_t *this, void *buf, size_t len, SSL_trinary_func *func) +ssl_do(rpc_transport_t *this, void *buf, size_t len, SSL_trinary_func *func) { - int r = (-1); - socket_private_t *priv = NULL; - - GF_VALIDATE_OR_GOTO(this->name, this->private, out); - priv = this->private; - - if (buf) { - if (priv->connected == -1) { - /* - * Fields in the SSL structure (especially - * the BIO pointers) are not valid at this - * point, so we'll segfault if we pass them - * to SSL_read/SSL_write. - */ - gf_log (this->name, GF_LOG_INFO, - "lost connection in %s", __func__); - return -1; - } - r = func (priv->ssl_ssl, buf, len); - } else { - /* - * We actually need these functions to get to - * priv->connected == 1. - */ - r = ((SSL_unary_func *)func)(priv->ssl_ssl); - } - switch (SSL_get_error (priv->ssl_ssl, r)) { + int r = (-1); + socket_private_t *priv = NULL; + + GF_VALIDATE_OR_GOTO(this->name, this->private, out); + priv = this->private; + + if (buf) { + if (priv->connected == -1) { + /* + * Fields in the SSL structure (especially + * the BIO pointers) are not valid at this + * point, so we'll segfault if we pass them + * to SSL_read/SSL_write. + */ + gf_log(this->name, GF_LOG_INFO, "lost connection in %s", __func__); + return -1; + } + r = func(priv->ssl_ssl, buf, len); + } else { + /* + * We actually need these functions to get to + * priv->connected == 1. + */ + r = ((SSL_unary_func *)func)(priv->ssl_ssl); + } + switch (SSL_get_error(priv->ssl_ssl, r)) { case SSL_ERROR_NONE: /* fall through */ case SSL_ERROR_WANT_READ: /* fall through */ case SSL_ERROR_WANT_WRITE: - errno = EAGAIN; - return r; + errno = EAGAIN; + return r; case SSL_ERROR_SYSCALL: - /* Sometimes SSL_ERROR_SYSCALL returns errno as - * EAGAIN. In such a case we should reattempt operation - * So, for now, just return the return value and the - * errno as is. - */ - gf_log (this->name, GF_LOG_DEBUG, - "syscall error (probably remote disconnect) " - "errno:%d:%s", errno, strerror(errno)); - return r; + /* Sometimes SSL_ERROR_SYSCALL returns errno as + * EAGAIN. In such a case we should reattempt operation + * So, for now, just return the return value and the + * errno as is. + */ + gf_log(this->name, GF_LOG_DEBUG, + "syscall error (probably remote disconnect) " + "errno:%d:%s", + errno, strerror(errno)); + return r; default: - errno = EIO; - goto out; /* "break" would just loop again */ - } + errno = EIO; + goto out; /* "break" would just loop again */ + } out: - return -1; + return -1; } -#define ssl_read_one(t, b, l) ssl_do((t), (b), (l), (SSL_trinary_func *)SSL_read) -#define ssl_write_one(t, b, l) ssl_do((t), (b), (l), (SSL_trinary_func *)SSL_write) - +#define ssl_read_one(t, b, l) \ + ssl_do((t), (b), (l), (SSL_trinary_func *)SSL_read) +#define ssl_write_one(t, b, l) \ + ssl_do((t), (b), (l), (SSL_trinary_func *)SSL_write) int -ssl_setup_connection_prefix (rpc_transport_t *this) +ssl_setup_connection_prefix(rpc_transport_t *this) { - int ret = -1; - socket_private_t *priv = NULL; - - GF_VALIDATE_OR_GOTO(this->name, this->private, done); + int ret = -1; + socket_private_t *priv = NULL; - priv = this->private; - - if (ssl_setup_connection_params (this) < 0) { - gf_log (this->name, GF_LOG_TRACE, - "+ ssl_setup_connection_params() failed!"); - goto done; - } else { - gf_log (this->name, GF_LOG_TRACE, - "+ ssl_setup_connection_params() done!"); - } + GF_VALIDATE_OR_GOTO(this->name, this->private, done); - priv->ssl_error_required = SSL_ERROR_NONE; - priv->ssl_connected = _gf_false; - priv->ssl_accepted = _gf_false; - priv->ssl_context_created = _gf_false; + priv = this->private; - priv->ssl_ssl = SSL_new(priv->ssl_ctx); - if (!priv->ssl_ssl) { - gf_log(this->name, GF_LOG_ERROR, "SSL_new failed"); - ssl_dump_error_stack(this->name); - goto done; - } + if (ssl_setup_connection_params(this) < 0) { + gf_log(this->name, GF_LOG_TRACE, + "+ ssl_setup_connection_params() failed!"); + goto done; + } else { + gf_log(this->name, GF_LOG_TRACE, + "+ ssl_setup_connection_params() done!"); + } + + priv->ssl_error_required = SSL_ERROR_NONE; + priv->ssl_connected = _gf_false; + priv->ssl_accepted = _gf_false; + priv->ssl_context_created = _gf_false; + + priv->ssl_ssl = SSL_new(priv->ssl_ctx); + if (!priv->ssl_ssl) { + gf_log(this->name, GF_LOG_ERROR, "SSL_new failed"); + ssl_dump_error_stack(this->name); + goto done; + } - priv->ssl_sbio = BIO_new_socket(priv->sock, BIO_NOCLOSE); - if (!priv->ssl_sbio) { - gf_log(this->name, GF_LOG_ERROR, "BIO_new_socket failed"); - ssl_dump_error_stack(this->name); - goto free_ssl; - } + priv->ssl_sbio = BIO_new_socket(priv->sock, BIO_NOCLOSE); + if (!priv->ssl_sbio) { + gf_log(this->name, GF_LOG_ERROR, "BIO_new_socket failed"); + ssl_dump_error_stack(this->name); + goto free_ssl; + } - SSL_set_bio (priv->ssl_ssl, priv->ssl_sbio, priv->ssl_sbio); - ret = 0; - goto done; + SSL_set_bio(priv->ssl_ssl, priv->ssl_sbio, priv->ssl_sbio); + ret = 0; + goto done; free_ssl: - SSL_free(priv->ssl_ssl); - priv->ssl_ssl = NULL; + SSL_free(priv->ssl_ssl); + priv->ssl_ssl = NULL; done: - return ret; + return ret; } static char * -ssl_setup_connection_postfix (rpc_transport_t *this) +ssl_setup_connection_postfix(rpc_transport_t *this) { - X509 *peer = NULL; - char peer_CN[256] = ""; - socket_private_t *priv = NULL; - - GF_VALIDATE_OR_GOTO(this->name, this->private, done); - priv = this->private; - - /* Make sure _SSL verification_ succeeded, yielding an identity. */ - if (SSL_get_verify_result(priv->ssl_ssl) != X509_V_OK) { - goto ssl_error; - } - peer = SSL_get_peer_certificate(priv->ssl_ssl); - if (!peer) { - goto ssl_error; - } - - SSL_set_mode(priv->ssl_ssl, SSL_MODE_ENABLE_PARTIAL_WRITE); - - /* Finally, everything seems OK. */ - X509_NAME_get_text_by_NID(X509_get_subject_name(peer), - NID_commonName, peer_CN, sizeof(peer_CN)-1); - peer_CN[sizeof(peer_CN)-1] = '\0'; - gf_log(this->name, GF_LOG_DEBUG, "peer CN = %s", peer_CN); - gf_log (this->name, GF_LOG_DEBUG, - "SSL verification succeeded (client: %s) (server: %s)", - this->peerinfo.identifier, this->myinfo.identifier); - return gf_strdup(peer_CN); - - /* Error paths. */ + X509 *peer = NULL; + char peer_CN[256] = ""; + socket_private_t *priv = NULL; + + GF_VALIDATE_OR_GOTO(this->name, this->private, done); + priv = this->private; + + /* Make sure _SSL verification_ succeeded, yielding an identity. */ + if (SSL_get_verify_result(priv->ssl_ssl) != X509_V_OK) { + goto ssl_error; + } + peer = SSL_get_peer_certificate(priv->ssl_ssl); + if (!peer) { + goto ssl_error; + } + + SSL_set_mode(priv->ssl_ssl, SSL_MODE_ENABLE_PARTIAL_WRITE); + + /* Finally, everything seems OK. */ + X509_NAME_get_text_by_NID(X509_get_subject_name(peer), NID_commonName, + peer_CN, sizeof(peer_CN) - 1); + peer_CN[sizeof(peer_CN) - 1] = '\0'; + gf_log(this->name, GF_LOG_DEBUG, "peer CN = %s", peer_CN); + gf_log(this->name, GF_LOG_DEBUG, + "SSL verification succeeded (client: %s) (server: %s)", + this->peerinfo.identifier, this->myinfo.identifier); + return gf_strdup(peer_CN); + + /* Error paths. */ ssl_error: - gf_log (this->name, GF_LOG_ERROR, - "SSL connect error (client: %s) (server: %s)", - this->peerinfo.identifier, this->myinfo.identifier); - ssl_dump_error_stack(this->name); + gf_log(this->name, GF_LOG_ERROR, + "SSL connect error (client: %s) (server: %s)", + this->peerinfo.identifier, this->myinfo.identifier); + ssl_dump_error_stack(this->name); - SSL_free(priv->ssl_ssl); - priv->ssl_ssl = NULL; + SSL_free(priv->ssl_ssl); + priv->ssl_ssl = NULL; done: - return NULL; + return NULL; } - int -ssl_complete_connection (rpc_transport_t *this) +ssl_complete_connection(rpc_transport_t *this) { - int ret = -1; /* 1 : implies go back to epoll_wait() - * 0 : implies successful ssl connection - * -1: implies continue processing current event - * as if EPOLLERR has been encountered - */ - char *cname = NULL; - int r = -1; - int ssl_error = -1; - socket_private_t *priv = NULL; - + int ret = -1; /* 1 : implies go back to epoll_wait() + * 0 : implies successful ssl connection + * -1: implies continue processing current event + * as if EPOLLERR has been encountered + */ + char *cname = NULL; + int r = -1; + int ssl_error = -1; + socket_private_t *priv = NULL; - priv = this->private; + priv = this->private; - if (priv->is_server) { - r = SSL_accept (priv->ssl_ssl); - } else { - r = SSL_connect (priv->ssl_ssl); - } + if (priv->is_server) { + r = SSL_accept(priv->ssl_ssl); + } else { + r = SSL_connect(priv->ssl_ssl); + } - ssl_error = SSL_get_error (priv->ssl_ssl, r); - priv->ssl_error_required = ssl_error; + ssl_error = SSL_get_error(priv->ssl_ssl, r); + priv->ssl_error_required = ssl_error; - switch (ssl_error) { + switch (ssl_error) { case SSL_ERROR_NONE: - cname = ssl_setup_connection_postfix (this); - if (!cname) { - /* we've failed to get the cname so - * we must close the connection - * - * treat this as EPOLLERR - */ - gf_log (this->name, GF_LOG_TRACE, - "error getting cname"); - errno = ECONNRESET; - ret = -1; + cname = ssl_setup_connection_postfix(this); + if (!cname) { + /* we've failed to get the cname so + * we must close the connection + * + * treat this as EPOLLERR + */ + gf_log(this->name, GF_LOG_TRACE, "error getting cname"); + errno = ECONNRESET; + ret = -1; + } else { + this->ssl_name = cname; + if (priv->is_server) { + priv->ssl_accepted = _gf_true; + gf_log(this->name, GF_LOG_TRACE, "ssl_accepted!"); } else { - this->ssl_name = cname; - if (priv->is_server) { - priv->ssl_accepted = _gf_true; - gf_log (this->name, GF_LOG_TRACE, - "ssl_accepted!"); - } else { - priv->ssl_connected = _gf_true; - gf_log (this->name, GF_LOG_TRACE, - "ssl_connected!"); - } - ret = 0; + priv->ssl_connected = _gf_true; + gf_log(this->name, GF_LOG_TRACE, "ssl_connected!"); } - break; + ret = 0; + } + break; case SSL_ERROR_WANT_READ: /* fall through */ case SSL_ERROR_WANT_WRITE: - errno = EAGAIN; - break; + errno = EAGAIN; + break; case SSL_ERROR_SYSCALL: - /* Sometimes SSL_ERROR_SYSCALL returns with errno as EAGAIN - * So, we should retry the operation. - * So, for now, we just return the return value and errno as is. - */ - break; + /* Sometimes SSL_ERROR_SYSCALL returns with errno as EAGAIN + * So, we should retry the operation. + * So, for now, we just return the return value and errno as is. + */ + break; case SSL_ERROR_SSL: - /* treat this as EPOLLERR */ - ret = -1; - break; + /* treat this as EPOLLERR */ + ret = -1; + break; default: - /* treat this as EPOLLERR */ - errno = EIO; - ret = -1; - break; - } - return ret; + /* treat this as EPOLLERR */ + errno = EIO; + ret = -1; + break; + } + return ret; } static void -ssl_teardown_connection (socket_private_t *priv) +ssl_teardown_connection(socket_private_t *priv) { - if (priv->ssl_ssl) { - SSL_shutdown(priv->ssl_ssl); - SSL_clear(priv->ssl_ssl); - SSL_free(priv->ssl_ssl); - SSL_CTX_free(priv->ssl_ctx); - priv->ssl_ssl = NULL; - priv->ssl_ctx = NULL; - if (priv->ssl_private_key) { - GF_FREE (priv->ssl_private_key); - priv->ssl_private_key = NULL; - } - if (priv->ssl_own_cert) { - GF_FREE (priv->ssl_own_cert); - priv->ssl_own_cert = NULL; - } - if (priv->ssl_ca_list) { - GF_FREE (priv->ssl_ca_list); - priv->ssl_ca_list = NULL; - } + if (priv->ssl_ssl) { + SSL_shutdown(priv->ssl_ssl); + SSL_clear(priv->ssl_ssl); + SSL_free(priv->ssl_ssl); + SSL_CTX_free(priv->ssl_ctx); + priv->ssl_ssl = NULL; + priv->ssl_ctx = NULL; + if (priv->ssl_private_key) { + GF_FREE(priv->ssl_private_key); + priv->ssl_private_key = NULL; } - priv->use_ssl = _gf_false; + if (priv->ssl_own_cert) { + GF_FREE(priv->ssl_own_cert); + priv->ssl_own_cert = NULL; + } + if (priv->ssl_ca_list) { + GF_FREE(priv->ssl_ca_list); + priv->ssl_ca_list = NULL; + } + } + priv->use_ssl = _gf_false; } - static ssize_t -__socket_ssl_readv (rpc_transport_t *this, struct iovec *opvector, int opcount) +__socket_ssl_readv(rpc_transport_t *this, struct iovec *opvector, int opcount) { - socket_private_t *priv = NULL; - int sock = -1; - int ret = -1; - - priv = this->private; - sock = priv->sock; - - if (priv->use_ssl) { - gf_log (this->name, GF_LOG_TRACE, "***** reading over SSL"); - ret = ssl_read_one (this, opvector->iov_base, opvector->iov_len); - } else { - gf_log (this->name, GF_LOG_TRACE, "***** reading over non-SSL"); - ret = sys_readv (sock, opvector, IOV_MIN(opcount)); - } - - return ret; + socket_private_t *priv = NULL; + int sock = -1; + int ret = -1; + + priv = this->private; + sock = priv->sock; + + if (priv->use_ssl) { + gf_log(this->name, GF_LOG_TRACE, "***** reading over SSL"); + ret = ssl_read_one(this, opvector->iov_base, opvector->iov_len); + } else { + gf_log(this->name, GF_LOG_TRACE, "***** reading over non-SSL"); + ret = sys_readv(sock, opvector, IOV_MIN(opcount)); + } + + return ret; } - static ssize_t -__socket_ssl_read (rpc_transport_t *this, void *buf, size_t count) +__socket_ssl_read(rpc_transport_t *this, void *buf, size_t count) { - struct iovec iov = {0, }; - int ret = -1; + struct iovec iov = { + 0, + }; + int ret = -1; - iov.iov_base = buf; - iov.iov_len = count; + iov.iov_base = buf; + iov.iov_len = count; - ret = __socket_ssl_readv (this, &iov, 1); + ret = __socket_ssl_readv(this, &iov, 1); - return ret; + return ret; } - static int -__socket_cached_read (rpc_transport_t *this, struct iovec *opvector, int opcount) +__socket_cached_read(rpc_transport_t *this, struct iovec *opvector, int opcount) { - socket_private_t *priv = NULL; - struct gf_sock_incoming *in = NULL; - int req_len = -1; - int ret = -1; - - priv = this->private; - in = &priv->incoming; - req_len = iov_length (opvector, opcount); - - if (in->record_state == SP_STATE_READING_FRAGHDR) { - in->ra_read = 0; - in->ra_served = 0; - in->ra_max = 0; - in->ra_buf = NULL; - goto uncached; - } - - if (!in->ra_max) { - /* first call after passing SP_STATE_READING_FRAGHDR */ - in->ra_max = min (RPC_FRAGSIZE (in->fraghdr), GF_SOCKET_RA_MAX); - /* Note that the in->iobuf is the primary iobuf into which - headers are read into, and in->frag.fragcurrent points to - some position in the buffer. By using this itself as our - read-ahead cache, we can avoid memory copies in iov_load - */ - in->ra_buf = in->frag.fragcurrent; - } - - /* fill read-ahead */ - if (in->ra_read < in->ra_max) { - ret = __socket_ssl_read (this, &in->ra_buf[in->ra_read], - (in->ra_max - in->ra_read)); - if (ret > 0) - in->ra_read += ret; - - /* we proceed to test if there is still cached data to - be served even if readahead could not progress */ - } - - /* serve cached */ - if (in->ra_served < in->ra_read) { - ret = iov_load (opvector, opcount, &in->ra_buf[in->ra_served], - min (req_len, (in->ra_read - in->ra_served))); - - in->ra_served += ret; - /* Do not read uncached and cached in the same call */ - goto out; - } - - if (in->ra_read < in->ra_max) - /* If there was no cached data to be served, (and we are - guaranteed to have already performed an attempt to progress - readahead above), and we have not yet read out the full - readahead capacity, then bail out for now without doing - the uncached read below (as that will overtake future cached - read) - */ - goto out; + socket_private_t *priv = NULL; + struct gf_sock_incoming *in = NULL; + int req_len = -1; + int ret = -1; + + priv = this->private; + in = &priv->incoming; + req_len = iov_length(opvector, opcount); + + if (in->record_state == SP_STATE_READING_FRAGHDR) { + in->ra_read = 0; + in->ra_served = 0; + in->ra_max = 0; + in->ra_buf = NULL; + goto uncached; + } + + if (!in->ra_max) { + /* first call after passing SP_STATE_READING_FRAGHDR */ + in->ra_max = min(RPC_FRAGSIZE(in->fraghdr), GF_SOCKET_RA_MAX); + /* Note that the in->iobuf is the primary iobuf into which + headers are read into, and in->frag.fragcurrent points to + some position in the buffer. By using this itself as our + read-ahead cache, we can avoid memory copies in iov_load + */ + in->ra_buf = in->frag.fragcurrent; + } + + /* fill read-ahead */ + if (in->ra_read < in->ra_max) { + ret = __socket_ssl_read(this, &in->ra_buf[in->ra_read], + (in->ra_max - in->ra_read)); + if (ret > 0) + in->ra_read += ret; + + /* we proceed to test if there is still cached data to + be served even if readahead could not progress */ + } + + /* serve cached */ + if (in->ra_served < in->ra_read) { + ret = iov_load(opvector, opcount, &in->ra_buf[in->ra_served], + min(req_len, (in->ra_read - in->ra_served))); + + in->ra_served += ret; + /* Do not read uncached and cached in the same call */ + goto out; + } + + if (in->ra_read < in->ra_max) + /* If there was no cached data to be served, (and we are + guaranteed to have already performed an attempt to progress + readahead above), and we have not yet read out the full + readahead capacity, then bail out for now without doing + the uncached read below (as that will overtake future cached + read) + */ + goto out; uncached: - ret = __socket_ssl_readv (this, opvector, opcount); + ret = __socket_ssl_readv(this, opvector, opcount); out: - return ret; + return ret; } static gf_boolean_t -__does_socket_rwv_error_need_logging (socket_private_t *priv, int write) +__does_socket_rwv_error_need_logging(socket_private_t *priv, int write) { - int read = !write; + int read = !write; - if (priv->connected == -1) /* Didn't even connect, of course it fails */ - return _gf_false; + if (priv->connected == -1) /* Didn't even connect, of course it fails */ + return _gf_false; - if (read && (priv->read_fail_log == _gf_false)) - return _gf_false; + if (read && (priv->read_fail_log == _gf_false)) + return _gf_false; - return _gf_true; + return _gf_true; } /* @@ -637,822 +629,786 @@ __does_socket_rwv_error_need_logging (socket_private_t *priv, int write) */ static int -__socket_rwv (rpc_transport_t *this, struct iovec *vector, int count, - struct iovec **pending_vector, int *pending_count, size_t *bytes, - int write) +__socket_rwv(rpc_transport_t *this, struct iovec *vector, int count, + struct iovec **pending_vector, int *pending_count, size_t *bytes, + int write) { - socket_private_t *priv = NULL; - int sock = -1; - int ret = -1; - struct iovec *opvector = NULL; - int opcount = 0; - int moved = 0; - - GF_VALIDATE_OR_GOTO ("socket", this, out); - GF_VALIDATE_OR_GOTO ("socket", this->private, out); - - priv = this->private; - sock = priv->sock; - - opvector = vector; - opcount = count; - - if (bytes != NULL) { - *bytes = 0; + socket_private_t *priv = NULL; + int sock = -1; + int ret = -1; + struct iovec *opvector = NULL; + int opcount = 0; + int moved = 0; + + GF_VALIDATE_OR_GOTO("socket", this, out); + GF_VALIDATE_OR_GOTO("socket", this->private, out); + + priv = this->private; + sock = priv->sock; + + opvector = vector; + opcount = count; + + if (bytes != NULL) { + *bytes = 0; + } + + while (opcount > 0) { + if (opvector->iov_len == 0) { + gf_log(this->name, GF_LOG_DEBUG, + "would have passed zero length to read/write"); + ++opvector; + --opcount; + continue; + } + if (priv->use_ssl && !priv->ssl_ssl) { + /* + * We could end up here with priv->ssl_ssl still NULL + * if (a) the connection failed and (b) some fool + * called other socket functions anyway. Demoting to + * non-SSL might be insecure, so just fail it outright. + */ + ret = -1; + gf_log(this->name, GF_LOG_TRACE, + "### no priv->ssl_ssl yet; ret = -1;"); + } else if (write) { + if (priv->use_ssl) { + ret = ssl_write_one(this, opvector->iov_base, + opvector->iov_len); + } else { + ret = sys_writev(sock, opvector, IOV_MIN(opcount)); + } + + if (ret == 0 || (ret == -1 && errno == EAGAIN)) { + /* done for now */ + break; + } + this->total_bytes_write += ret; + } else { + ret = __socket_cached_read(this, opvector, opcount); + if (ret == 0) { + gf_log(this->name, GF_LOG_DEBUG, "EOF on socket (errno:%d:%s)", + errno, strerror(errno)); + errno = ENODATA; + ret = -1; + } + if (ret == -1 && errno == EAGAIN) { + /* done for now */ + break; + } + this->total_bytes_read += ret; } - while (opcount > 0) { - if (opvector->iov_len == 0) { - gf_log(this->name, GF_LOG_DEBUG, - "would have passed zero length to read/write"); - ++opvector; - --opcount; - continue; - } - if (priv->use_ssl && !priv->ssl_ssl) { - /* - * We could end up here with priv->ssl_ssl still NULL - * if (a) the connection failed and (b) some fool - * called other socket functions anyway. Demoting to - * non-SSL might be insecure, so just fail it outright. - */ - ret = -1; - gf_log (this->name, GF_LOG_TRACE, - "### no priv->ssl_ssl yet; ret = -1;"); - } else if (write) { - if (priv->use_ssl) { - ret = ssl_write_one (this, opvector->iov_base, - opvector->iov_len); - } else { - ret = sys_writev (sock, opvector, IOV_MIN(opcount)); - } - - if (ret == 0 || (ret == -1 && errno == EAGAIN)) { - /* done for now */ - break; - } - this->total_bytes_write += ret; - } else { - ret = __socket_cached_read (this, opvector, opcount); - if (ret == 0) { - gf_log (this->name, GF_LOG_DEBUG, - "EOF on socket (errno:%d:%s)", - errno, strerror (errno)); - errno = ENODATA; - ret = -1; - } - if (ret == -1 && errno == EAGAIN) { - /* done for now */ - break; - } - this->total_bytes_read += ret; - } - - if (ret == 0) { - /* Mostly due to 'umount' in client */ - - gf_log (this->name, GF_LOG_DEBUG, - "EOF from peer %s", this->peerinfo.identifier); - opcount = -1; - errno = ENOTCONN; - break; - } - if (ret == -1) { - if (errno == EINTR) - continue; - - if (__does_socket_rwv_error_need_logging (priv, - write)) { - GF_LOG_OCCASIONALLY(priv->log_ctr, this->name, - GF_LOG_WARNING, - "%s on %s failed (%s)", - write ? "writev":"readv", - this->peerinfo.identifier, - strerror (errno)); - } - - if (priv->use_ssl && priv->ssl_ssl) { - ssl_dump_error_stack(this->name); - } - opcount = -1; - break; - } + if (ret == 0) { + /* Mostly due to 'umount' in client */ - if (bytes != NULL) { - *bytes += ret; - } + gf_log(this->name, GF_LOG_DEBUG, "EOF from peer %s", + this->peerinfo.identifier); + opcount = -1; + errno = ENOTCONN; + break; + } + if (ret == -1) { + if (errno == EINTR) + continue; - moved = 0; + if (__does_socket_rwv_error_need_logging(priv, write)) { + GF_LOG_OCCASIONALLY(priv->log_ctr, this->name, GF_LOG_WARNING, + "%s on %s failed (%s)", + write ? "writev" : "readv", + this->peerinfo.identifier, strerror(errno)); + } - while (moved < ret) { - if (!opcount) { - gf_log(this->name, GF_LOG_DEBUG, - "ran out of iov, moved %d/%d", - moved, ret); - goto ran_out; - } - if (!opvector[0].iov_len) { - opvector++; - opcount--; - continue; - } - if ((ret - moved) >= opvector[0].iov_len) { - moved += opvector[0].iov_len; - opvector++; - opcount--; - } else { - opvector[0].iov_len -= (ret - moved); - opvector[0].iov_base += (ret - moved); - moved += (ret - moved); - } - } + if (priv->use_ssl && priv->ssl_ssl) { + ssl_dump_error_stack(this->name); + } + opcount = -1; + break; } + if (bytes != NULL) { + *bytes += ret; + } + + moved = 0; + + while (moved < ret) { + if (!opcount) { + gf_log(this->name, GF_LOG_DEBUG, "ran out of iov, moved %d/%d", + moved, ret); + goto ran_out; + } + if (!opvector[0].iov_len) { + opvector++; + opcount--; + continue; + } + if ((ret - moved) >= opvector[0].iov_len) { + moved += opvector[0].iov_len; + opvector++; + opcount--; + } else { + opvector[0].iov_len -= (ret - moved); + opvector[0].iov_base += (ret - moved); + moved += (ret - moved); + } + } + } + ran_out: - if (pending_vector) - *pending_vector = opvector; + if (pending_vector) + *pending_vector = opvector; - if (pending_count) - *pending_count = opcount; + if (pending_count) + *pending_count = opcount; out: - return opcount; + return opcount; } - static int -__socket_readv (rpc_transport_t *this, struct iovec *vector, int count, - struct iovec **pending_vector, int *pending_count, - size_t *bytes) +__socket_readv(rpc_transport_t *this, struct iovec *vector, int count, + struct iovec **pending_vector, int *pending_count, size_t *bytes) { - int ret = -1; + int ret = -1; - ret = __socket_rwv (this, vector, count, - pending_vector, pending_count, bytes, 0); + ret = __socket_rwv(this, vector, count, pending_vector, pending_count, + bytes, 0); - return ret; + return ret; } - static int -__socket_writev (rpc_transport_t *this, struct iovec *vector, int count, - struct iovec **pending_vector, int *pending_count) +__socket_writev(rpc_transport_t *this, struct iovec *vector, int count, + struct iovec **pending_vector, int *pending_count) { - int ret = -1; + int ret = -1; - ret = __socket_rwv (this, vector, count, - pending_vector, pending_count, NULL, 1); + ret = __socket_rwv(this, vector, count, pending_vector, pending_count, NULL, + 1); - return ret; + return ret; } - static int -__socket_shutdown (rpc_transport_t *this) +__socket_shutdown(rpc_transport_t *this) { - int ret = -1; - socket_private_t *priv = this->private; - - priv->connected = -1; - ret = shutdown (priv->sock, SHUT_RDWR); - if (ret) { - /* its already disconnected.. no need to understand - why it failed to shutdown in normal cases */ - gf_log (this->name, GF_LOG_DEBUG, - "shutdown() returned %d. %s", - ret, strerror (errno)); - } - - return ret; + int ret = -1; + socket_private_t *priv = this->private; + + priv->connected = -1; + ret = shutdown(priv->sock, SHUT_RDWR); + if (ret) { + /* its already disconnected.. no need to understand + why it failed to shutdown in normal cases */ + gf_log(this->name, GF_LOG_DEBUG, "shutdown() returned %d. %s", ret, + strerror(errno)); + } + + return ret; } static int -__socket_teardown_connection (rpc_transport_t *this) +__socket_teardown_connection(rpc_transport_t *this) { - int ret = -1; - socket_private_t *priv = NULL; + int ret = -1; + socket_private_t *priv = NULL; - GF_VALIDATE_OR_GOTO ("socket", this, out); - GF_VALIDATE_OR_GOTO ("socket", this->private, out); + GF_VALIDATE_OR_GOTO("socket", this, out); + GF_VALIDATE_OR_GOTO("socket", this->private, out); - priv = this->private; + priv = this->private; - if (priv->use_ssl) - ssl_teardown_connection(priv); + if (priv->use_ssl) + ssl_teardown_connection(priv); - ret = __socket_shutdown(this); + ret = __socket_shutdown(this); out: - return ret; + return ret; } static int -__socket_disconnect (rpc_transport_t *this) +__socket_disconnect(rpc_transport_t *this) { - int ret = -1; - socket_private_t *priv = NULL; + int ret = -1; + socket_private_t *priv = NULL; - GF_VALIDATE_OR_GOTO ("socket", this, out); - GF_VALIDATE_OR_GOTO ("socket", this->private, out); + GF_VALIDATE_OR_GOTO("socket", this, out); + GF_VALIDATE_OR_GOTO("socket", this->private, out); - priv = this->private; + priv = this->private; - gf_log (this->name, GF_LOG_TRACE, "disconnecting %p, sock=%d", - this, priv->sock); + gf_log(this->name, GF_LOG_TRACE, "disconnecting %p, sock=%d", this, + priv->sock); - if (priv->sock != -1) { - gf_log_callingfn (this->name, GF_LOG_TRACE, - "tearing down socket connection"); - ret = __socket_teardown_connection (this); - if (ret) { - gf_log (this->name, GF_LOG_DEBUG, - "__socket_teardown_connection () failed: %s", - strerror (errno)); - } + if (priv->sock != -1) { + gf_log_callingfn(this->name, GF_LOG_TRACE, + "tearing down socket connection"); + ret = __socket_teardown_connection(this); + if (ret) { + gf_log(this->name, GF_LOG_DEBUG, + "__socket_teardown_connection () failed: %s", + strerror(errno)); } + } out: - return ret; + return ret; } - static int -__socket_server_bind (rpc_transport_t *this) +__socket_server_bind(rpc_transport_t *this) { - socket_private_t *priv = NULL; - int ret = -1; - int opt = 1; - int reuse_check_sock = -1; - struct sockaddr_storage unix_addr = {0}; + socket_private_t *priv = NULL; + int ret = -1; + int opt = 1; + int reuse_check_sock = -1; + struct sockaddr_storage unix_addr = {0}; - GF_VALIDATE_OR_GOTO ("socket", this, out); - GF_VALIDATE_OR_GOTO ("socket", this->private, out); + GF_VALIDATE_OR_GOTO("socket", this, out); + GF_VALIDATE_OR_GOTO("socket", this->private, out); - priv = this->private; + priv = this->private; - ret = setsockopt (priv->sock, SOL_SOCKET, SO_REUSEADDR, - &opt, sizeof (opt)); + ret = setsockopt(priv->sock, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt)); - if (ret == -1) { - gf_log (this->name, GF_LOG_ERROR, - "setsockopt() for SO_REUSEADDR failed (%s)", - strerror (errno)); - } + if (ret == -1) { + gf_log(this->name, GF_LOG_ERROR, + "setsockopt() for SO_REUSEADDR failed (%s)", strerror(errno)); + } - /* reuse-address doesn't work for unix type sockets */ - if (AF_UNIX == SA (&this->myinfo.sockaddr)->sa_family) { - memcpy (&unix_addr, SA (&this->myinfo.sockaddr), - this->myinfo.sockaddr_len); - reuse_check_sock = socket (AF_UNIX, SOCK_STREAM, 0); - if (reuse_check_sock >= 0) { - ret = connect (reuse_check_sock, SA (&unix_addr), - this->myinfo.sockaddr_len); - if ((ret == -1) && (ECONNREFUSED == errno)) { - sys_unlink (((struct sockaddr_un *)&unix_addr)->sun_path); - } - sys_close (reuse_check_sock); - } + /* reuse-address doesn't work for unix type sockets */ + if (AF_UNIX == SA(&this->myinfo.sockaddr)->sa_family) { + memcpy(&unix_addr, SA(&this->myinfo.sockaddr), + this->myinfo.sockaddr_len); + reuse_check_sock = socket(AF_UNIX, SOCK_STREAM, 0); + if (reuse_check_sock >= 0) { + ret = connect(reuse_check_sock, SA(&unix_addr), + this->myinfo.sockaddr_len); + if ((ret == -1) && (ECONNREFUSED == errno)) { + sys_unlink(((struct sockaddr_un *)&unix_addr)->sun_path); + } + sys_close(reuse_check_sock); } + } - ret = bind (priv->sock, (struct sockaddr *)&this->myinfo.sockaddr, - this->myinfo.sockaddr_len); + ret = bind(priv->sock, (struct sockaddr *)&this->myinfo.sockaddr, + this->myinfo.sockaddr_len); - if (ret == -1) { - gf_log (this->name, GF_LOG_ERROR, - "binding to %s failed: %s", - this->myinfo.identifier, strerror (errno)); - if (errno == EADDRINUSE) { - gf_log (this->name, GF_LOG_ERROR, - "Port is already in use"); - - ret = -EADDRINUSE; - } + if (ret == -1) { + gf_log(this->name, GF_LOG_ERROR, "binding to %s failed: %s", + this->myinfo.identifier, strerror(errno)); + if (errno == EADDRINUSE) { + gf_log(this->name, GF_LOG_ERROR, "Port is already in use"); + + ret = -EADDRINUSE; } + } out: - return ret; + return ret; } - static int -__socket_nonblock (int fd) +__socket_nonblock(int fd) { - int flags = 0; - int ret = -1; + int flags = 0; + int ret = -1; - flags = fcntl (fd, F_GETFL); + flags = fcntl(fd, F_GETFL); - if (flags != -1) - ret = fcntl (fd, F_SETFL, flags | O_NONBLOCK); + if (flags != -1) + ret = fcntl(fd, F_SETFL, flags | O_NONBLOCK); - return ret; + return ret; } static int -__socket_nodelay (int fd) +__socket_nodelay(int fd) { - int on = 1; - int ret = -1; + int on = 1; + int ret = -1; - ret = setsockopt (fd, IPPROTO_TCP, TCP_NODELAY, - &on, sizeof (on)); - if (!ret) - gf_log (THIS->name, GF_LOG_TRACE, - "NODELAY enabled for socket %d", fd); + ret = setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &on, sizeof(on)); + if (!ret) + gf_log(THIS->name, GF_LOG_TRACE, "NODELAY enabled for socket %d", fd); - return ret; + return ret; } - static int -__socket_keepalive (int fd, int family, int keepaliveintvl, - int keepaliveidle, int keepalivecnt, int timeout) +__socket_keepalive(int fd, int family, int keepaliveintvl, int keepaliveidle, + int keepalivecnt, int timeout) { - int on = 1; - int ret = -1; + int on = 1; + int ret = -1; #if defined(TCP_USER_TIMEOUT) - int timeout_ms = timeout * 1000; + int timeout_ms = timeout * 1000; #endif - ret = setsockopt (fd, SOL_SOCKET, SO_KEEPALIVE, &on, sizeof (on)); - if (ret == -1) { - gf_log ("socket", GF_LOG_WARNING, - "failed to set keep alive option on socket %d", fd); - goto err; - } + ret = setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, &on, sizeof(on)); + if (ret == -1) { + gf_log("socket", GF_LOG_WARNING, + "failed to set keep alive option on socket %d", fd); + goto err; + } - if (keepaliveintvl == GF_USE_DEFAULT_KEEPALIVE) - goto done; + if (keepaliveintvl == GF_USE_DEFAULT_KEEPALIVE) + goto done; #if !defined(GF_LINUX_HOST_OS) && !defined(__NetBSD__) #if defined(GF_SOLARIS_HOST_OS) || defined(__FreeBSD__) - ret = setsockopt (fd, SOL_SOCKET, SO_KEEPALIVE, &keepaliveintvl, - sizeof (keepaliveintvl)); + ret = setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, &keepaliveintvl, + sizeof(keepaliveintvl)); #else - ret = setsockopt (fd, IPPROTO_TCP, TCP_KEEPALIVE, &keepaliveintvl, - sizeof (keepaliveintvl)); + ret = setsockopt(fd, IPPROTO_TCP, TCP_KEEPALIVE, &keepaliveintvl, + sizeof(keepaliveintvl)); #endif - if (ret == -1) { - gf_log ("socket", GF_LOG_WARNING, - "failed to set keep alive interval on socket %d", fd); - goto err; - } + if (ret == -1) { + gf_log("socket", GF_LOG_WARNING, + "failed to set keep alive interval on socket %d", fd); + goto err; + } #else - if (family != AF_INET && family != AF_INET6) - goto done; + if (family != AF_INET && family != AF_INET6) + goto done; - ret = setsockopt (fd, IPPROTO_TCP, TCP_KEEPIDLE, &keepaliveidle, - sizeof (keepaliveidle)); - if (ret == -1) { - gf_log ("socket", GF_LOG_WARNING, - "failed to set keep idle %d on socket %d, %s", - keepaliveidle, fd, strerror(errno)); - goto err; - } - ret = setsockopt (fd, IPPROTO_TCP , TCP_KEEPINTVL, &keepaliveintvl, - sizeof (keepaliveintvl)); - if (ret == -1) { - gf_log ("socket", GF_LOG_WARNING, - "failed to set keep interval %d on socket %d, %s", - keepaliveintvl, fd, strerror(errno)); - goto err; - } + ret = setsockopt(fd, IPPROTO_TCP, TCP_KEEPIDLE, &keepaliveidle, + sizeof(keepaliveidle)); + if (ret == -1) { + gf_log("socket", GF_LOG_WARNING, + "failed to set keep idle %d on socket %d, %s", keepaliveidle, fd, + strerror(errno)); + goto err; + } + ret = setsockopt(fd, IPPROTO_TCP, TCP_KEEPINTVL, &keepaliveintvl, + sizeof(keepaliveintvl)); + if (ret == -1) { + gf_log("socket", GF_LOG_WARNING, + "failed to set keep interval %d on socket %d, %s", + keepaliveintvl, fd, strerror(errno)); + goto err; + } #if defined(TCP_USER_TIMEOUT) - if (timeout_ms < 0) - goto done; - ret = setsockopt (fd, IPPROTO_TCP , TCP_USER_TIMEOUT, &timeout_ms, - sizeof (timeout_ms)); - if (ret == -1) { - gf_log ("socket", GF_LOG_WARNING, "failed to set " - "TCP_USER_TIMEOUT %d on socket %d, %s", timeout_ms, fd, - strerror(errno)); - goto err; - } + if (timeout_ms < 0) + goto done; + ret = setsockopt(fd, IPPROTO_TCP, TCP_USER_TIMEOUT, &timeout_ms, + sizeof(timeout_ms)); + if (ret == -1) { + gf_log("socket", GF_LOG_WARNING, + "failed to set " + "TCP_USER_TIMEOUT %d on socket %d, %s", + timeout_ms, fd, strerror(errno)); + goto err; + } #endif #if defined(TCP_KEEPCNT) - ret = setsockopt (fd, IPPROTO_TCP, TCP_KEEPCNT, &keepalivecnt, - sizeof (keepalivecnt)); - if (ret == -1) { - gf_log ("socket", GF_LOG_WARNING, "failed to set " - "TCP_KEEPCNT %d on socket %d, %s", keepalivecnt, fd, - strerror(errno)); - goto err; - } + ret = setsockopt(fd, IPPROTO_TCP, TCP_KEEPCNT, &keepalivecnt, + sizeof(keepalivecnt)); + if (ret == -1) { + gf_log("socket", GF_LOG_WARNING, + "failed to set " + "TCP_KEEPCNT %d on socket %d, %s", + keepalivecnt, fd, strerror(errno)); + goto err; + } #endif #endif done: - gf_log (THIS->name, GF_LOG_TRACE, "Keep-alive enabled for socket: %d, " - "(idle: %d, interval: %d, max-probes: %d, timeout: %d)", - fd, keepaliveidle, keepaliveintvl, keepalivecnt, - timeout); + gf_log(THIS->name, GF_LOG_TRACE, + "Keep-alive enabled for socket: %d, " + "(idle: %d, interval: %d, max-probes: %d, timeout: %d)", + fd, keepaliveidle, keepaliveintvl, keepalivecnt, timeout); err: - return ret; + return ret; } - static int -__socket_connect_finish (int fd) +__socket_connect_finish(int fd) { - int ret = -1; - int optval = 0; - socklen_t optlen = sizeof (int); + int ret = -1; + int optval = 0; + socklen_t optlen = sizeof(int); - ret = getsockopt (fd, SOL_SOCKET, SO_ERROR, (void *)&optval, &optlen); + ret = getsockopt(fd, SOL_SOCKET, SO_ERROR, (void *)&optval, &optlen); - if (ret == 0 && optval) { - errno = optval; - ret = -1; - } + if (ret == 0 && optval) { + errno = optval; + ret = -1; + } - return ret; + return ret; } - static void -__socket_reset (rpc_transport_t *this) +__socket_reset(rpc_transport_t *this) { - socket_private_t *priv = NULL; - - GF_VALIDATE_OR_GOTO ("socket", this, out); - GF_VALIDATE_OR_GOTO ("socket", this->private, out); - - priv = this->private; - - /* TODO: use mem-pool on incoming data */ - - if (priv->incoming.iobref) { - iobref_unref (priv->incoming.iobref); - priv->incoming.iobref = NULL; - } - - if (priv->incoming.iobuf) { - iobuf_unref (priv->incoming.iobuf); - priv->incoming.iobuf = NULL; - } - - GF_FREE (priv->incoming.request_info); - - memset (&priv->incoming, 0, sizeof (priv->incoming)); - - event_unregister_close (this->ctx->event_pool, priv->sock, priv->idx); - - priv->sock = -1; - priv->idx = -1; - priv->connected = -1; - priv->ssl_connected = _gf_false; - priv->ssl_accepted = _gf_false; - priv->ssl_context_created = _gf_false; - - if (priv->ssl_private_key) { - GF_FREE (priv->ssl_private_key); - priv->ssl_private_key = NULL; - } - if (priv->ssl_own_cert) { - GF_FREE (priv->ssl_own_cert); - priv->ssl_own_cert = NULL; - } - if (priv->ssl_ca_list) { - GF_FREE (priv->ssl_ca_list); - priv->ssl_ca_list = NULL; - } + socket_private_t *priv = NULL; + + GF_VALIDATE_OR_GOTO("socket", this, out); + GF_VALIDATE_OR_GOTO("socket", this->private, out); + + priv = this->private; + + /* TODO: use mem-pool on incoming data */ + + if (priv->incoming.iobref) { + iobref_unref(priv->incoming.iobref); + priv->incoming.iobref = NULL; + } + + if (priv->incoming.iobuf) { + iobuf_unref(priv->incoming.iobuf); + priv->incoming.iobuf = NULL; + } + + GF_FREE(priv->incoming.request_info); + + memset(&priv->incoming, 0, sizeof(priv->incoming)); + + event_unregister_close(this->ctx->event_pool, priv->sock, priv->idx); + + priv->sock = -1; + priv->idx = -1; + priv->connected = -1; + priv->ssl_connected = _gf_false; + priv->ssl_accepted = _gf_false; + priv->ssl_context_created = _gf_false; + + if (priv->ssl_private_key) { + GF_FREE(priv->ssl_private_key); + priv->ssl_private_key = NULL; + } + if (priv->ssl_own_cert) { + GF_FREE(priv->ssl_own_cert); + priv->ssl_own_cert = NULL; + } + if (priv->ssl_ca_list) { + GF_FREE(priv->ssl_ca_list); + priv->ssl_ca_list = NULL; + } out: - return; + return; } - static void -socket_set_lastfrag (uint32_t *fragsize) { - (*fragsize) |= 0x80000000U; +socket_set_lastfrag(uint32_t *fragsize) +{ + (*fragsize) |= 0x80000000U; } - static void -socket_set_frag_header_size (uint32_t size, char *haddr) +socket_set_frag_header_size(uint32_t size, char *haddr) { - size = htonl (size); - memcpy (haddr, &size, sizeof (size)); + size = htonl(size); + memcpy(haddr, &size, sizeof(size)); } - static void -socket_set_last_frag_header_size (uint32_t size, char *haddr) +socket_set_last_frag_header_size(uint32_t size, char *haddr) { - socket_set_lastfrag (&size); - socket_set_frag_header_size (size, haddr); + socket_set_lastfrag(&size); + socket_set_frag_header_size(size, haddr); } static struct ioq * -__socket_ioq_new (rpc_transport_t *this, rpc_transport_msg_t *msg) +__socket_ioq_new(rpc_transport_t *this, rpc_transport_msg_t *msg) { - struct ioq *entry = NULL; - int count = 0; - uint32_t size = 0; + struct ioq *entry = NULL; + int count = 0; + uint32_t size = 0; - GF_VALIDATE_OR_GOTO ("socket", this, out); + GF_VALIDATE_OR_GOTO("socket", this, out); - /* TODO: use mem-pool */ - entry = GF_CALLOC (1, sizeof (*entry), gf_common_mt_ioq); - if (!entry) - return NULL; + /* TODO: use mem-pool */ + entry = GF_CALLOC(1, sizeof(*entry), gf_common_mt_ioq); + if (!entry) + return NULL; - count = msg->rpchdrcount + msg->proghdrcount + msg->progpayloadcount; + count = msg->rpchdrcount + msg->proghdrcount + msg->progpayloadcount; - GF_ASSERT (count <= (MAX_IOVEC - 1)); + GF_ASSERT(count <= (MAX_IOVEC - 1)); - size = iov_length (msg->rpchdr, msg->rpchdrcount) - + iov_length (msg->proghdr, msg->proghdrcount) - + iov_length (msg->progpayload, msg->progpayloadcount); + size = iov_length(msg->rpchdr, msg->rpchdrcount) + + iov_length(msg->proghdr, msg->proghdrcount) + + iov_length(msg->progpayload, msg->progpayloadcount); - if (size > RPC_MAX_FRAGMENT_SIZE) { - gf_log (this->name, GF_LOG_ERROR, - "msg size (%u) bigger than the maximum allowed size on " - "sockets (%u)", size, RPC_MAX_FRAGMENT_SIZE); - GF_FREE (entry); - return NULL; - } + if (size > RPC_MAX_FRAGMENT_SIZE) { + gf_log(this->name, GF_LOG_ERROR, + "msg size (%u) bigger than the maximum allowed size on " + "sockets (%u)", + size, RPC_MAX_FRAGMENT_SIZE); + GF_FREE(entry); + return NULL; + } - socket_set_last_frag_header_size (size, (char *)&entry->fraghdr); + socket_set_last_frag_header_size(size, (char *)&entry->fraghdr); - entry->vector[0].iov_base = (char *)&entry->fraghdr; - entry->vector[0].iov_len = sizeof (entry->fraghdr); - entry->count = 1; + entry->vector[0].iov_base = (char *)&entry->fraghdr; + entry->vector[0].iov_len = sizeof(entry->fraghdr); + entry->count = 1; - if (msg->rpchdr != NULL) { - memcpy (&entry->vector[1], msg->rpchdr, - sizeof (struct iovec) * msg->rpchdrcount); - entry->count += msg->rpchdrcount; - } + if (msg->rpchdr != NULL) { + memcpy(&entry->vector[1], msg->rpchdr, + sizeof(struct iovec) * msg->rpchdrcount); + entry->count += msg->rpchdrcount; + } - if (msg->proghdr != NULL) { - memcpy (&entry->vector[entry->count], msg->proghdr, - sizeof (struct iovec) * msg->proghdrcount); - entry->count += msg->proghdrcount; - } + if (msg->proghdr != NULL) { + memcpy(&entry->vector[entry->count], msg->proghdr, + sizeof(struct iovec) * msg->proghdrcount); + entry->count += msg->proghdrcount; + } - if (msg->progpayload != NULL) { - memcpy (&entry->vector[entry->count], msg->progpayload, - sizeof (struct iovec) * msg->progpayloadcount); - entry->count += msg->progpayloadcount; - } + if (msg->progpayload != NULL) { + memcpy(&entry->vector[entry->count], msg->progpayload, + sizeof(struct iovec) * msg->progpayloadcount); + entry->count += msg->progpayloadcount; + } - entry->pending_vector = entry->vector; - entry->pending_count = entry->count; + entry->pending_vector = entry->vector; + entry->pending_count = entry->count; - if (msg->iobref != NULL) - entry->iobref = iobref_ref (msg->iobref); + if (msg->iobref != NULL) + entry->iobref = iobref_ref(msg->iobref); - INIT_LIST_HEAD (&entry->list); + INIT_LIST_HEAD(&entry->list); out: - return entry; + return entry; } - static void -__socket_ioq_entry_free (struct ioq *entry) +__socket_ioq_entry_free(struct ioq *entry) { - GF_VALIDATE_OR_GOTO ("socket", entry, out); + GF_VALIDATE_OR_GOTO("socket", entry, out); - list_del_init (&entry->list); - if (entry->iobref) - iobref_unref (entry->iobref); + list_del_init(&entry->list); + if (entry->iobref) + iobref_unref(entry->iobref); - /* TODO: use mem-pool */ - GF_FREE (entry); + /* TODO: use mem-pool */ + GF_FREE(entry); out: - return; + return; } - static void -__socket_ioq_flush (rpc_transport_t *this) +__socket_ioq_flush(rpc_transport_t *this) { - socket_private_t *priv = NULL; - struct ioq *entry = NULL; + socket_private_t *priv = NULL; + struct ioq *entry = NULL; - GF_VALIDATE_OR_GOTO ("socket", this, out); - GF_VALIDATE_OR_GOTO ("socket", this->private, out); + GF_VALIDATE_OR_GOTO("socket", this, out); + GF_VALIDATE_OR_GOTO("socket", this->private, out); - priv = this->private; + priv = this->private; - while (!list_empty (&priv->ioq)) { - entry = priv->ioq_next; - __socket_ioq_entry_free (entry); - } + while (!list_empty(&priv->ioq)) { + entry = priv->ioq_next; + __socket_ioq_entry_free(entry); + } out: - return; + return; } - static int -__socket_ioq_churn_entry (rpc_transport_t *this, struct ioq *entry, int direct) +__socket_ioq_churn_entry(rpc_transport_t *this, struct ioq *entry, int direct) { - int ret = -1; + int ret = -1; - ret = __socket_writev (this, entry->pending_vector, - entry->pending_count, - &entry->pending_vector, - &entry->pending_count); + ret = __socket_writev(this, entry->pending_vector, entry->pending_count, + &entry->pending_vector, &entry->pending_count); - if (ret == 0) { - /* current entry was completely written */ - GF_ASSERT (entry->pending_count == 0); - __socket_ioq_entry_free (entry); - } + if (ret == 0) { + /* current entry was completely written */ + GF_ASSERT(entry->pending_count == 0); + __socket_ioq_entry_free(entry); + } - return ret; + return ret; } - static int -__socket_ioq_churn (rpc_transport_t *this) +__socket_ioq_churn(rpc_transport_t *this) { - socket_private_t *priv = NULL; - int ret = 0; - struct ioq *entry = NULL; + socket_private_t *priv = NULL; + int ret = 0; + struct ioq *entry = NULL; - GF_VALIDATE_OR_GOTO ("socket", this, out); - GF_VALIDATE_OR_GOTO ("socket", this->private, out); + GF_VALIDATE_OR_GOTO("socket", this, out); + GF_VALIDATE_OR_GOTO("socket", this->private, out); - priv = this->private; + priv = this->private; - while (!list_empty (&priv->ioq)) { - /* pick next entry */ - entry = priv->ioq_next; + while (!list_empty(&priv->ioq)) { + /* pick next entry */ + entry = priv->ioq_next; - ret = __socket_ioq_churn_entry (this, entry, 0); + ret = __socket_ioq_churn_entry(this, entry, 0); - if (ret != 0) - break; - } + if (ret != 0) + break; + } - if (list_empty (&priv->ioq)) { - /* all pending writes done, not interested in POLLOUT */ - priv->idx = event_select_on (this->ctx->event_pool, - priv->sock, priv->idx, -1, 0); - } + if (list_empty(&priv->ioq)) { + /* all pending writes done, not interested in POLLOUT */ + priv->idx = event_select_on(this->ctx->event_pool, priv->sock, + priv->idx, -1, 0); + } out: - return ret; + return ret; } - static gf_boolean_t -socket_event_poll_err (rpc_transport_t *this, int gen, int idx) +socket_event_poll_err(rpc_transport_t *this, int gen, int idx) { - socket_private_t *priv = NULL; - gf_boolean_t socket_closed = _gf_false; + socket_private_t *priv = NULL; + gf_boolean_t socket_closed = _gf_false; - GF_VALIDATE_OR_GOTO ("socket", this, out); - GF_VALIDATE_OR_GOTO ("socket", this->private, out); + GF_VALIDATE_OR_GOTO("socket", this, out); + GF_VALIDATE_OR_GOTO("socket", this->private, out); - priv = this->private; + priv = this->private; - pthread_mutex_lock (&priv->in_lock); - pthread_mutex_lock (&priv->out_lock); - { - if ((priv->gen == gen) && (priv->idx == idx) - && (priv->sock != -1)) { - __socket_ioq_flush (this); - __socket_reset (this); - socket_closed = _gf_true; - } + pthread_mutex_lock(&priv->in_lock); + pthread_mutex_lock(&priv->out_lock); + { + if ((priv->gen == gen) && (priv->idx == idx) && (priv->sock != -1)) { + __socket_ioq_flush(this); + __socket_reset(this); + socket_closed = _gf_true; } - pthread_mutex_unlock (&priv->out_lock); - pthread_mutex_unlock (&priv->in_lock); - - if (socket_closed) { - pthread_mutex_lock (&priv->notify.lock); - { - while (priv->notify.in_progress) - pthread_cond_wait (&priv->notify.cond, - &priv->notify.lock); - } - pthread_mutex_unlock (&priv->notify.lock); + } + pthread_mutex_unlock(&priv->out_lock); + pthread_mutex_unlock(&priv->in_lock); - rpc_transport_notify (this, RPC_TRANSPORT_DISCONNECT, this); + if (socket_closed) { + pthread_mutex_lock(&priv->notify.lock); + { + while (priv->notify.in_progress) + pthread_cond_wait(&priv->notify.cond, &priv->notify.lock); } + pthread_mutex_unlock(&priv->notify.lock); + + rpc_transport_notify(this, RPC_TRANSPORT_DISCONNECT, this); + } out: - return socket_closed; + return socket_closed; } - static int -socket_event_poll_out (rpc_transport_t *this) +socket_event_poll_out(rpc_transport_t *this) { - socket_private_t *priv = NULL; - int ret = -1; + socket_private_t *priv = NULL; + int ret = -1; - GF_VALIDATE_OR_GOTO ("socket", this, out); - GF_VALIDATE_OR_GOTO ("socket", this->private, out); + GF_VALIDATE_OR_GOTO("socket", this, out); + GF_VALIDATE_OR_GOTO("socket", this->private, out); - priv = this->private; + priv = this->private; - pthread_mutex_lock (&priv->out_lock); - { - if (priv->connected == 1) { - ret = __socket_ioq_churn (this); - - if (ret == -1) { - gf_log (this->name, GF_LOG_TRACE, - "__socket_ioq_churn returned -1; " - "disconnecting socket"); - __socket_disconnect (this); - } - } + pthread_mutex_lock(&priv->out_lock); + { + if (priv->connected == 1) { + ret = __socket_ioq_churn(this); + + if (ret == -1) { + gf_log(this->name, GF_LOG_TRACE, + "__socket_ioq_churn returned -1; " + "disconnecting socket"); + __socket_disconnect(this); + } } - pthread_mutex_unlock (&priv->out_lock); + } + pthread_mutex_unlock(&priv->out_lock); - if (ret == 0) - ret = rpc_transport_notify (this, RPC_TRANSPORT_MSG_SENT, NULL); + if (ret == 0) + ret = rpc_transport_notify(this, RPC_TRANSPORT_MSG_SENT, NULL); out: - return ret; + return ret; } - static int -__socket_read_simple_msg (rpc_transport_t *this) +__socket_read_simple_msg(rpc_transport_t *this) { - int ret = 0; - uint32_t remaining_size = 0; - size_t bytes_read = 0; - socket_private_t *priv = NULL; - struct gf_sock_incoming *in = NULL; - struct gf_sock_incoming_frag *frag = NULL; - - GF_VALIDATE_OR_GOTO ("socket", this, out); - GF_VALIDATE_OR_GOTO ("socket", this->private, out); + int ret = 0; + uint32_t remaining_size = 0; + size_t bytes_read = 0; + socket_private_t *priv = NULL; + struct gf_sock_incoming *in = NULL; + struct gf_sock_incoming_frag *frag = NULL; - priv = this->private; + GF_VALIDATE_OR_GOTO("socket", this, out); + GF_VALIDATE_OR_GOTO("socket", this->private, out); - in = &priv->incoming; - frag = &in->frag; + priv = this->private; - switch (frag->simple_state) { + in = &priv->incoming; + frag = &in->frag; + switch (frag->simple_state) { case SP_STATE_SIMPLE_MSG_INIT: - remaining_size = RPC_FRAGSIZE (in->fraghdr) - frag->bytes_read; + remaining_size = RPC_FRAGSIZE(in->fraghdr) - frag->bytes_read; - __socket_proto_init_pending (priv, remaining_size); + __socket_proto_init_pending(priv, remaining_size); - frag->simple_state = SP_STATE_READING_SIMPLE_MSG; + frag->simple_state = SP_STATE_READING_SIMPLE_MSG; - /* fall through */ + /* fall through */ case SP_STATE_READING_SIMPLE_MSG: - ret = 0; + ret = 0; - remaining_size = RPC_FRAGSIZE (in->fraghdr) - frag->bytes_read; + remaining_size = RPC_FRAGSIZE(in->fraghdr) - frag->bytes_read; - if (remaining_size > 0) { - ret = __socket_readv (this, - in->pending_vector, 1, - &in->pending_vector, - &in->pending_count, - &bytes_read); - } + if (remaining_size > 0) { + ret = __socket_readv(this, in->pending_vector, 1, + &in->pending_vector, &in->pending_count, + &bytes_read); + } - if (ret == -1) { - gf_log (this->name, GF_LOG_WARNING, - "reading from socket failed. Error (%s), " - "peer (%s)", strerror (errno), - this->peerinfo.identifier); - break; - } + if (ret == -1) { + gf_log(this->name, GF_LOG_WARNING, + "reading from socket failed. Error (%s), " + "peer (%s)", + strerror(errno), this->peerinfo.identifier); + break; + } - frag->bytes_read += bytes_read; - frag->fragcurrent += bytes_read; + frag->bytes_read += bytes_read; + frag->fragcurrent += bytes_read; - if (ret > 0) { - gf_log (this->name, GF_LOG_TRACE, - "partial read on non-blocking socket."); - break; - } + if (ret > 0) { + gf_log(this->name, GF_LOG_TRACE, + "partial read on non-blocking socket."); + break; + } - if (ret == 0) { - frag->simple_state = SP_STATE_SIMPLE_MSG_INIT; - } - } + if (ret == 0) { + frag->simple_state = SP_STATE_SIMPLE_MSG_INIT; + } + } out: - return ret; + return ret; } - static int -__socket_read_simple_request (rpc_transport_t *this) +__socket_read_simple_request(rpc_transport_t *this) { - return __socket_read_simple_msg (this); + return __socket_read_simple_msg(this); } - #define rpc_cred_addr(buf) (buf + RPC_MSGTYPE_SIZE + RPC_CALL_BODY_SIZE - 4) #define rpc_verf_addr(fragcurrent) (fragcurrent - 4) @@ -1464,1875 +1420,1810 @@ __socket_read_simple_request (rpc_transport_t *this) #define rpc_procnum_addr(buf) (buf + RPC_MSGTYPE_SIZE + 12) static int -__socket_read_vectored_request (rpc_transport_t *this, rpcsvc_vector_sizer vector_sizer) +__socket_read_vectored_request(rpc_transport_t *this, + rpcsvc_vector_sizer vector_sizer) { - socket_private_t *priv = NULL; - int ret = 0; - uint32_t credlen = 0, verflen = 0; - char *addr = NULL; - struct iobuf *iobuf = NULL; - uint32_t remaining_size = 0; - ssize_t readsize = 0; - size_t size = 0; - struct gf_sock_incoming *in = NULL; - struct gf_sock_incoming_frag *frag = NULL; - sp_rpcfrag_request_state_t *request = NULL; - - GF_VALIDATE_OR_GOTO ("socket", this, out); - GF_VALIDATE_OR_GOTO ("socket", this->private, out); - - priv = this->private; - - /* used to reduce the indirection */ - in = &priv->incoming; - frag = &in->frag; - request = &frag->call_body.request; - - switch (request->vector_state) { + socket_private_t *priv = NULL; + int ret = 0; + uint32_t credlen = 0, verflen = 0; + char *addr = NULL; + struct iobuf *iobuf = NULL; + uint32_t remaining_size = 0; + ssize_t readsize = 0; + size_t size = 0; + struct gf_sock_incoming *in = NULL; + struct gf_sock_incoming_frag *frag = NULL; + sp_rpcfrag_request_state_t *request = NULL; + + GF_VALIDATE_OR_GOTO("socket", this, out); + GF_VALIDATE_OR_GOTO("socket", this->private, out); + + priv = this->private; + + /* used to reduce the indirection */ + in = &priv->incoming; + frag = &in->frag; + request = &frag->call_body.request; + + switch (request->vector_state) { case SP_STATE_VECTORED_REQUEST_INIT: - request->vector_sizer_state = 0; + request->vector_sizer_state = 0; - addr = rpc_cred_addr (iobuf_ptr (in->iobuf)); + addr = rpc_cred_addr(iobuf_ptr(in->iobuf)); - /* also read verf flavour and verflen */ - credlen = ntoh32 (*((uint32_t *)addr)) - + RPC_AUTH_FLAVOUR_N_LENGTH_SIZE; + /* also read verf flavour and verflen */ + credlen = ntoh32(*((uint32_t *)addr)) + + RPC_AUTH_FLAVOUR_N_LENGTH_SIZE; - __socket_proto_init_pending (priv, credlen); + __socket_proto_init_pending(priv, credlen); - request->vector_state = SP_STATE_READING_CREDBYTES; + request->vector_state = SP_STATE_READING_CREDBYTES; - /* fall through */ + /* fall through */ case SP_STATE_READING_CREDBYTES: - __socket_proto_read (priv, ret); + __socket_proto_read(priv, ret); - request->vector_state = SP_STATE_READ_CREDBYTES; + request->vector_state = SP_STATE_READ_CREDBYTES; - /* fall through */ + /* fall through */ case SP_STATE_READ_CREDBYTES: - addr = rpc_verf_addr (frag->fragcurrent); - verflen = ntoh32 (*((uint32_t *)addr)); + addr = rpc_verf_addr(frag->fragcurrent); + verflen = ntoh32(*((uint32_t *)addr)); - if (verflen == 0) { - request->vector_state = SP_STATE_READ_VERFBYTES; - goto sp_state_read_verfbytes; - } - __socket_proto_init_pending (priv, verflen); + if (verflen == 0) { + request->vector_state = SP_STATE_READ_VERFBYTES; + goto sp_state_read_verfbytes; + } + __socket_proto_init_pending(priv, verflen); - request->vector_state = SP_STATE_READING_VERFBYTES; + request->vector_state = SP_STATE_READING_VERFBYTES; - /* fall through */ + /* fall through */ case SP_STATE_READING_VERFBYTES: - __socket_proto_read (priv, ret); + __socket_proto_read(priv, ret); - request->vector_state = SP_STATE_READ_VERFBYTES; + request->vector_state = SP_STATE_READ_VERFBYTES; - /* fall through */ + /* fall through */ case SP_STATE_READ_VERFBYTES: -sp_state_read_verfbytes: - /* set the base_addr 'persistently' across multiple calls - into the state machine */ - in->proghdr_base_addr = frag->fragcurrent; + sp_state_read_verfbytes: + /* set the base_addr 'persistently' across multiple calls + into the state machine */ + in->proghdr_base_addr = frag->fragcurrent; - request->vector_sizer_state = - vector_sizer (request->vector_sizer_state, - &readsize, in->proghdr_base_addr, - frag->fragcurrent); - __socket_proto_init_pending (priv, readsize); + request->vector_sizer_state = vector_sizer( + request->vector_sizer_state, &readsize, in->proghdr_base_addr, + frag->fragcurrent); + __socket_proto_init_pending(priv, readsize); - request->vector_state = SP_STATE_READING_PROGHDR; + request->vector_state = SP_STATE_READING_PROGHDR; - /* fall through */ + /* fall through */ case SP_STATE_READING_PROGHDR: - __socket_proto_read (priv, ret); + __socket_proto_read(priv, ret); - request->vector_state = SP_STATE_READ_PROGHDR; + request->vector_state = SP_STATE_READ_PROGHDR; - /* fall through */ + /* fall through */ case SP_STATE_READ_PROGHDR: -sp_state_read_proghdr: - request->vector_sizer_state = - vector_sizer (request->vector_sizer_state, - &readsize, in->proghdr_base_addr, - frag->fragcurrent); - if (readsize == 0) { - request->vector_state = SP_STATE_READ_PROGHDR_XDATA; - goto sp_state_read_proghdr_xdata; - } + sp_state_read_proghdr: + request->vector_sizer_state = vector_sizer( + request->vector_sizer_state, &readsize, in->proghdr_base_addr, + frag->fragcurrent); + if (readsize == 0) { + request->vector_state = SP_STATE_READ_PROGHDR_XDATA; + goto sp_state_read_proghdr_xdata; + } - __socket_proto_init_pending (priv, readsize); + __socket_proto_init_pending(priv, readsize); - request->vector_state = SP_STATE_READING_PROGHDR_XDATA; + request->vector_state = SP_STATE_READING_PROGHDR_XDATA; - /* fall through */ + /* fall through */ case SP_STATE_READING_PROGHDR_XDATA: - __socket_proto_read (priv, ret); + __socket_proto_read(priv, ret); - request->vector_state = SP_STATE_READ_PROGHDR; - /* check if the vector_sizer() has more to say */ - goto sp_state_read_proghdr; + request->vector_state = SP_STATE_READ_PROGHDR; + /* check if the vector_sizer() has more to say */ + goto sp_state_read_proghdr; case SP_STATE_READ_PROGHDR_XDATA: -sp_state_read_proghdr_xdata: - if (in->payload_vector.iov_base == NULL) { - - size = RPC_FRAGSIZE (in->fraghdr) - frag->bytes_read; - iobuf = iobuf_get2 (this->ctx->iobuf_pool, size); - if (!iobuf) { - ret = -1; - break; - } - - if (in->iobref == NULL) { - in->iobref = iobref_new (); - if (in->iobref == NULL) { - ret = -1; - iobuf_unref (iobuf); - break; - } - } + sp_state_read_proghdr_xdata: + if (in->payload_vector.iov_base == NULL) { + size = RPC_FRAGSIZE(in->fraghdr) - frag->bytes_read; + iobuf = iobuf_get2(this->ctx->iobuf_pool, size); + if (!iobuf) { + ret = -1; + break; + } + + if (in->iobref == NULL) { + in->iobref = iobref_new(); + if (in->iobref == NULL) { + ret = -1; + iobuf_unref(iobuf); + break; + } + } - iobref_add (in->iobref, iobuf); + iobref_add(in->iobref, iobuf); - in->payload_vector.iov_base = iobuf_ptr (iobuf); - frag->fragcurrent = iobuf_ptr (iobuf); + in->payload_vector.iov_base = iobuf_ptr(iobuf); + frag->fragcurrent = iobuf_ptr(iobuf); - iobuf_unref (iobuf); - } + iobuf_unref(iobuf); + } - request->vector_state = SP_STATE_READING_PROG; + request->vector_state = SP_STATE_READING_PROG; - /* fall through */ + /* fall through */ case SP_STATE_READING_PROG: - /* now read the remaining rpc msg into buffer pointed by - * fragcurrent - */ + /* now read the remaining rpc msg into buffer pointed by + * fragcurrent + */ - ret = __socket_read_simple_msg (this); + ret = __socket_read_simple_msg(this); - remaining_size = RPC_FRAGSIZE (in->fraghdr) - frag->bytes_read; + remaining_size = RPC_FRAGSIZE(in->fraghdr) - frag->bytes_read; - if ((ret == -1) || - ((ret == 0) && (remaining_size == 0) - && RPC_LASTFRAG (in->fraghdr))) { - request->vector_state = SP_STATE_VECTORED_REQUEST_INIT; - in->payload_vector.iov_len - = ((unsigned long)frag->fragcurrent - - (unsigned long)in->payload_vector.iov_base); - } - break; - } + if ((ret == -1) || ((ret == 0) && (remaining_size == 0) && + RPC_LASTFRAG(in->fraghdr))) { + request->vector_state = SP_STATE_VECTORED_REQUEST_INIT; + in->payload_vector.iov_len = ((unsigned long)frag->fragcurrent - + (unsigned long) + in->payload_vector.iov_base); + } + break; + } out: - return ret; + return ret; } static int -__socket_read_request (rpc_transport_t *this) +__socket_read_request(rpc_transport_t *this) { - socket_private_t *priv = NULL; - uint32_t prognum = 0, procnum = 0, progver = 0; - uint32_t remaining_size = 0; - int ret = -1; - char *buf = NULL; - rpcsvc_vector_sizer vector_sizer = NULL; - struct gf_sock_incoming *in = NULL; - struct gf_sock_incoming_frag *frag = NULL; - sp_rpcfrag_request_state_t *request = NULL; - - GF_VALIDATE_OR_GOTO ("socket", this, out); - GF_VALIDATE_OR_GOTO ("socket", this->private, out); - - priv = this->private; - - /* used to reduce the indirection */ - in = &priv->incoming; - frag = &in->frag; - request = &frag->call_body.request; - - switch (request->header_state) { - + socket_private_t *priv = NULL; + uint32_t prognum = 0, procnum = 0, progver = 0; + uint32_t remaining_size = 0; + int ret = -1; + char *buf = NULL; + rpcsvc_vector_sizer vector_sizer = NULL; + struct gf_sock_incoming *in = NULL; + struct gf_sock_incoming_frag *frag = NULL; + sp_rpcfrag_request_state_t *request = NULL; + + GF_VALIDATE_OR_GOTO("socket", this, out); + GF_VALIDATE_OR_GOTO("socket", this->private, out); + + priv = this->private; + + /* used to reduce the indirection */ + in = &priv->incoming; + frag = &in->frag; + request = &frag->call_body.request; + + switch (request->header_state) { case SP_STATE_REQUEST_HEADER_INIT: - __socket_proto_init_pending (priv, RPC_CALL_BODY_SIZE); + __socket_proto_init_pending(priv, RPC_CALL_BODY_SIZE); - request->header_state = SP_STATE_READING_RPCHDR1; + request->header_state = SP_STATE_READING_RPCHDR1; - /* fall through */ + /* fall through */ case SP_STATE_READING_RPCHDR1: - __socket_proto_read (priv, ret); + __socket_proto_read(priv, ret); - request->header_state = SP_STATE_READ_RPCHDR1; + request->header_state = SP_STATE_READ_RPCHDR1; - /* fall through */ + /* fall through */ case SP_STATE_READ_RPCHDR1: - buf = rpc_prognum_addr (iobuf_ptr (in->iobuf)); - prognum = ntoh32 (*((uint32_t *)buf)); + buf = rpc_prognum_addr(iobuf_ptr(in->iobuf)); + prognum = ntoh32(*((uint32_t *)buf)); - buf = rpc_progver_addr (iobuf_ptr (in->iobuf)); - progver = ntoh32 (*((uint32_t *)buf)); + buf = rpc_progver_addr(iobuf_ptr(in->iobuf)); + progver = ntoh32(*((uint32_t *)buf)); - buf = rpc_procnum_addr (iobuf_ptr (in->iobuf)); - procnum = ntoh32 (*((uint32_t *)buf)); + buf = rpc_procnum_addr(iobuf_ptr(in->iobuf)); + procnum = ntoh32(*((uint32_t *)buf)); - if (priv->is_server) { - /* this check is needed as rpcsvc and rpc-clnt - * actor structures are not same */ - vector_sizer = - rpcsvc_get_program_vector_sizer ((rpcsvc_t *)this->mydata, - prognum, progver, procnum); - } + if (priv->is_server) { + /* this check is needed as rpcsvc and rpc-clnt + * actor structures are not same */ + vector_sizer = rpcsvc_get_program_vector_sizer( + (rpcsvc_t *)this->mydata, prognum, progver, procnum); + } - if (vector_sizer) { - ret = __socket_read_vectored_request (this, vector_sizer); - } else { - ret = __socket_read_simple_request (this); - } + if (vector_sizer) { + ret = __socket_read_vectored_request(this, vector_sizer); + } else { + ret = __socket_read_simple_request(this); + } - remaining_size = RPC_FRAGSIZE (in->fraghdr) - frag->bytes_read; + remaining_size = RPC_FRAGSIZE(in->fraghdr) - frag->bytes_read; - if ((ret == -1) - || ((ret == 0) - && (remaining_size == 0) - && (RPC_LASTFRAG (in->fraghdr)))) { - request->header_state = SP_STATE_REQUEST_HEADER_INIT; - } + if ((ret == -1) || ((ret == 0) && (remaining_size == 0) && + (RPC_LASTFRAG(in->fraghdr)))) { + request->header_state = SP_STATE_REQUEST_HEADER_INIT; + } - break; - } + break; + } out: - return ret; + return ret; } - static int -__socket_read_accepted_successful_reply (rpc_transport_t *this) +__socket_read_accepted_successful_reply(rpc_transport_t *this) { - socket_private_t *priv = NULL; - int ret = 0; - struct iobuf *iobuf = NULL; - gfs3_read_rsp read_rsp = {0, }; - ssize_t size = 0; - ssize_t default_read_size = 0; - XDR xdr; - struct gf_sock_incoming *in = NULL; - struct gf_sock_incoming_frag *frag = NULL; - - GF_VALIDATE_OR_GOTO ("socket", this, out); - GF_VALIDATE_OR_GOTO ("socket", this->private, out); - - priv = this->private; - - /* used to reduce the indirection */ - in = &priv->incoming; - frag = &in->frag; - - switch (frag->call_body.reply.accepted_success_state) { - + socket_private_t *priv = NULL; + int ret = 0; + struct iobuf *iobuf = NULL; + gfs3_read_rsp read_rsp = { + 0, + }; + ssize_t size = 0; + ssize_t default_read_size = 0; + XDR xdr; + struct gf_sock_incoming *in = NULL; + struct gf_sock_incoming_frag *frag = NULL; + + GF_VALIDATE_OR_GOTO("socket", this, out); + GF_VALIDATE_OR_GOTO("socket", this->private, out); + + priv = this->private; + + /* used to reduce the indirection */ + in = &priv->incoming; + frag = &in->frag; + + switch (frag->call_body.reply.accepted_success_state) { case SP_STATE_ACCEPTED_SUCCESS_REPLY_INIT: - default_read_size = xdr_sizeof ((xdrproc_t) xdr_gfs3_read_rsp, - &read_rsp); + default_read_size = xdr_sizeof((xdrproc_t)xdr_gfs3_read_rsp, + &read_rsp); - /* We need to store the current base address because we will - * need it after a partial read. */ - in->proghdr_base_addr = frag->fragcurrent; + /* We need to store the current base address because we will + * need it after a partial read. */ + in->proghdr_base_addr = frag->fragcurrent; - __socket_proto_init_pending (priv, default_read_size); + __socket_proto_init_pending(priv, default_read_size); - frag->call_body.reply.accepted_success_state - = SP_STATE_READING_PROC_HEADER; + frag->call_body.reply + .accepted_success_state = SP_STATE_READING_PROC_HEADER; - /* fall through */ + /* fall through */ case SP_STATE_READING_PROC_HEADER: - __socket_proto_read (priv, ret); + __socket_proto_read(priv, ret); - /* there can be 'xdata' in read response, figure it out */ - default_read_size = frag->fragcurrent - in->proghdr_base_addr; - xdrmem_create (&xdr, in->proghdr_base_addr, default_read_size, - XDR_DECODE); + /* there can be 'xdata' in read response, figure it out */ + default_read_size = frag->fragcurrent - in->proghdr_base_addr; + xdrmem_create(&xdr, in->proghdr_base_addr, default_read_size, + XDR_DECODE); - /* This will fail if there is xdata sent from server, if not, - well and good, we don't need to worry about */ - xdr_gfs3_read_rsp (&xdr, &read_rsp); + /* This will fail if there is xdata sent from server, if not, + well and good, we don't need to worry about */ + xdr_gfs3_read_rsp(&xdr, &read_rsp); - free (read_rsp.xdata.xdata_val); + free(read_rsp.xdata.xdata_val); - /* need to round off to proper roof (%4), as XDR packing pads - the end of opaque object with '0' */ - size = roof (read_rsp.xdata.xdata_len, 4); + /* need to round off to proper roof (%4), as XDR packing pads + the end of opaque object with '0' */ + size = roof(read_rsp.xdata.xdata_len, 4); - if (!size) { - frag->call_body.reply.accepted_success_state - = SP_STATE_READ_PROC_OPAQUE; - goto read_proc_opaque; - } + if (!size) { + frag->call_body.reply + .accepted_success_state = SP_STATE_READ_PROC_OPAQUE; + goto read_proc_opaque; + } - __socket_proto_init_pending (priv, size); + __socket_proto_init_pending(priv, size); - frag->call_body.reply.accepted_success_state - = SP_STATE_READING_PROC_OPAQUE; - /* fall through */ + frag->call_body.reply + .accepted_success_state = SP_STATE_READING_PROC_OPAQUE; + /* fall through */ case SP_STATE_READING_PROC_OPAQUE: - __socket_proto_read (priv, ret); + __socket_proto_read(priv, ret); - frag->call_body.reply.accepted_success_state - = SP_STATE_READ_PROC_OPAQUE; - /* fall through */ + frag->call_body.reply + .accepted_success_state = SP_STATE_READ_PROC_OPAQUE; + /* fall through */ case SP_STATE_READ_PROC_OPAQUE: read_proc_opaque: - if (in->payload_vector.iov_base == NULL) { - - size = (RPC_FRAGSIZE (in->fraghdr) - frag->bytes_read); - - iobuf = iobuf_get2 (this->ctx->iobuf_pool, size); - if (iobuf == NULL) { - ret = -1; - goto out; - } + if (in->payload_vector.iov_base == NULL) { + size = (RPC_FRAGSIZE(in->fraghdr) - frag->bytes_read); - if (in->iobref == NULL) { - in->iobref = iobref_new (); - if (in->iobref == NULL) { - ret = -1; - iobuf_unref (iobuf); - goto out; - } - } + iobuf = iobuf_get2(this->ctx->iobuf_pool, size); + if (iobuf == NULL) { + ret = -1; + goto out; + } - ret = iobref_add (in->iobref, iobuf); - iobuf_unref (iobuf); - if (ret < 0) { - goto out; - } + if (in->iobref == NULL) { + in->iobref = iobref_new(); + if (in->iobref == NULL) { + ret = -1; + iobuf_unref(iobuf); + goto out; + } + } - in->payload_vector.iov_base = iobuf_ptr (iobuf); - in->payload_vector.iov_len = size; + ret = iobref_add(in->iobref, iobuf); + iobuf_unref(iobuf); + if (ret < 0) { + goto out; } - frag->fragcurrent = in->payload_vector.iov_base; + in->payload_vector.iov_base = iobuf_ptr(iobuf); + in->payload_vector.iov_len = size; + } - frag->call_body.reply.accepted_success_state - = SP_STATE_READ_PROC_HEADER; + frag->fragcurrent = in->payload_vector.iov_base; - /* fall through */ + frag->call_body.reply + .accepted_success_state = SP_STATE_READ_PROC_HEADER; + + /* fall through */ case SP_STATE_READ_PROC_HEADER: - /* now read the entire remaining msg into new iobuf */ - ret = __socket_read_simple_msg (this); - if ((ret == -1) - || ((ret == 0) && RPC_LASTFRAG (in->fraghdr))) { - frag->call_body.reply.accepted_success_state - = SP_STATE_ACCEPTED_SUCCESS_REPLY_INIT; - } + /* now read the entire remaining msg into new iobuf */ + ret = __socket_read_simple_msg(this); + if ((ret == -1) || ((ret == 0) && RPC_LASTFRAG(in->fraghdr))) { + frag->call_body.reply.accepted_success_state = + SP_STATE_ACCEPTED_SUCCESS_REPLY_INIT; + } - break; - } + break; + } out: - return ret; + return ret; } static int -__socket_read_accepted_successful_reply_v2 (rpc_transport_t *this) +__socket_read_accepted_successful_reply_v2(rpc_transport_t *this) { - socket_private_t *priv = NULL; - int ret = 0; - struct iobuf *iobuf = NULL; - gfx_read_rsp read_rsp = {0, }; - ssize_t size = 0; - ssize_t default_read_size = 0; - XDR xdr; - struct gf_sock_incoming *in = NULL; - struct gf_sock_incoming_frag *frag = NULL; - - GF_VALIDATE_OR_GOTO ("socket", this, out); - GF_VALIDATE_OR_GOTO ("socket", this->private, out); - - priv = this->private; - - /* used to reduce the indirection */ - in = &priv->incoming; - frag = &in->frag; - - switch (frag->call_body.reply.accepted_success_state) { - + socket_private_t *priv = NULL; + int ret = 0; + struct iobuf *iobuf = NULL; + gfx_read_rsp read_rsp = { + 0, + }; + ssize_t size = 0; + ssize_t default_read_size = 0; + XDR xdr; + struct gf_sock_incoming *in = NULL; + struct gf_sock_incoming_frag *frag = NULL; + + GF_VALIDATE_OR_GOTO("socket", this, out); + GF_VALIDATE_OR_GOTO("socket", this->private, out); + + priv = this->private; + + /* used to reduce the indirection */ + in = &priv->incoming; + frag = &in->frag; + + switch (frag->call_body.reply.accepted_success_state) { case SP_STATE_ACCEPTED_SUCCESS_REPLY_INIT: - default_read_size = xdr_sizeof ((xdrproc_t) xdr_gfx_read_rsp, - &read_rsp); + default_read_size = xdr_sizeof((xdrproc_t)xdr_gfx_read_rsp, + &read_rsp); - /* We need to store the current base address because we will - * need it after a partial read. */ - in->proghdr_base_addr = frag->fragcurrent; + /* We need to store the current base address because we will + * need it after a partial read. */ + in->proghdr_base_addr = frag->fragcurrent; - __socket_proto_init_pending (priv, default_read_size); + __socket_proto_init_pending(priv, default_read_size); - frag->call_body.reply.accepted_success_state - = SP_STATE_READING_PROC_HEADER; + frag->call_body.reply + .accepted_success_state = SP_STATE_READING_PROC_HEADER; - /* fall through */ + /* fall through */ case SP_STATE_READING_PROC_HEADER: - __socket_proto_read (priv, ret); + __socket_proto_read(priv, ret); - /* there can be 'xdata' in read response, figure it out */ - default_read_size = frag->fragcurrent - in->proghdr_base_addr; + /* there can be 'xdata' in read response, figure it out */ + default_read_size = frag->fragcurrent - in->proghdr_base_addr; - xdrmem_create (&xdr, in->proghdr_base_addr, default_read_size, - XDR_DECODE); + xdrmem_create(&xdr, in->proghdr_base_addr, default_read_size, + XDR_DECODE); - /* This will fail if there is xdata sent from server, if not, - well and good, we don't need to worry about */ - xdr_gfx_read_rsp (&xdr, &read_rsp); + /* This will fail if there is xdata sent from server, if not, + well and good, we don't need to worry about */ + xdr_gfx_read_rsp(&xdr, &read_rsp); - free (read_rsp.xdata.pairs.pairs_val); + free(read_rsp.xdata.pairs.pairs_val); - /* need to round off to proper roof (%4), as XDR packing pads - the end of opaque object with '0' */ - size = roof (read_rsp.xdata.xdr_size, 4); + /* need to round off to proper roof (%4), as XDR packing pads + the end of opaque object with '0' */ + size = roof(read_rsp.xdata.xdr_size, 4); - if (!size) { - frag->call_body.reply.accepted_success_state - = SP_STATE_READ_PROC_OPAQUE; - goto read_proc_opaque; - } + if (!size) { + frag->call_body.reply + .accepted_success_state = SP_STATE_READ_PROC_OPAQUE; + goto read_proc_opaque; + } - __socket_proto_init_pending (priv, size); + __socket_proto_init_pending(priv, size); - frag->call_body.reply.accepted_success_state - = SP_STATE_READING_PROC_OPAQUE; - /* fall through */ + frag->call_body.reply + .accepted_success_state = SP_STATE_READING_PROC_OPAQUE; + /* fall through */ case SP_STATE_READING_PROC_OPAQUE: - __socket_proto_read (priv, ret); + __socket_proto_read(priv, ret); - frag->call_body.reply.accepted_success_state - = SP_STATE_READ_PROC_OPAQUE; - /* fall through */ + frag->call_body.reply + .accepted_success_state = SP_STATE_READ_PROC_OPAQUE; + /* fall through */ case SP_STATE_READ_PROC_OPAQUE: read_proc_opaque: - if (in->payload_vector.iov_base == NULL) { - - size = (RPC_FRAGSIZE (in->fraghdr) - frag->bytes_read); + if (in->payload_vector.iov_base == NULL) { + size = (RPC_FRAGSIZE(in->fraghdr) - frag->bytes_read); - iobuf = iobuf_get2 (this->ctx->iobuf_pool, size); - if (iobuf == NULL) { - ret = -1; - goto out; - } - - if (in->iobref == NULL) { - in->iobref = iobref_new (); - if (in->iobref == NULL) { - ret = -1; - iobuf_unref (iobuf); - goto out; - } - } + iobuf = iobuf_get2(this->ctx->iobuf_pool, size); + if (iobuf == NULL) { + ret = -1; + goto out; + } - ret = iobref_add (in->iobref, iobuf); - iobuf_unref (iobuf); - if (ret < 0) { - goto out; - } + if (in->iobref == NULL) { + in->iobref = iobref_new(); + if (in->iobref == NULL) { + ret = -1; + iobuf_unref(iobuf); + goto out; + } + } - in->payload_vector.iov_base = iobuf_ptr (iobuf); - in->payload_vector.iov_len = size; + ret = iobref_add(in->iobref, iobuf); + iobuf_unref(iobuf); + if (ret < 0) { + goto out; } - frag->fragcurrent = in->payload_vector.iov_base; + in->payload_vector.iov_base = iobuf_ptr(iobuf); + in->payload_vector.iov_len = size; + } - frag->call_body.reply.accepted_success_state - = SP_STATE_READ_PROC_HEADER; + frag->fragcurrent = in->payload_vector.iov_base; - /* fall through */ + frag->call_body.reply + .accepted_success_state = SP_STATE_READ_PROC_HEADER; + + /* fall through */ case SP_STATE_READ_PROC_HEADER: - /* now read the entire remaining msg into new iobuf */ - ret = __socket_read_simple_msg (this); - if ((ret == -1) - || ((ret == 0) && RPC_LASTFRAG (in->fraghdr))) { - frag->call_body.reply.accepted_success_state - = SP_STATE_ACCEPTED_SUCCESS_REPLY_INIT; - } + /* now read the entire remaining msg into new iobuf */ + ret = __socket_read_simple_msg(this); + if ((ret == -1) || ((ret == 0) && RPC_LASTFRAG(in->fraghdr))) { + frag->call_body.reply.accepted_success_state = + SP_STATE_ACCEPTED_SUCCESS_REPLY_INIT; + } - break; - } + break; + } out: - return ret; + return ret; } #define rpc_reply_verflen_addr(fragcurrent) ((char *)fragcurrent - 4) #define rpc_reply_accept_status_addr(fragcurrent) ((char *)fragcurrent - 4) static int -__socket_read_accepted_reply (rpc_transport_t *this) +__socket_read_accepted_reply(rpc_transport_t *this) { - socket_private_t *priv = NULL; - int ret = -1; - char *buf = NULL; - uint32_t verflen = 0, len = 0; - uint32_t remaining_size = 0; - struct gf_sock_incoming *in = NULL; - struct gf_sock_incoming_frag *frag = NULL; - - GF_VALIDATE_OR_GOTO ("socket", this, out); - GF_VALIDATE_OR_GOTO ("socket", this->private, out); - - priv = this->private; - /* used to reduce the indirection */ - in = &priv->incoming; - frag = &in->frag; - - switch (frag->call_body.reply.accepted_state) { - + socket_private_t *priv = NULL; + int ret = -1; + char *buf = NULL; + uint32_t verflen = 0, len = 0; + uint32_t remaining_size = 0; + struct gf_sock_incoming *in = NULL; + struct gf_sock_incoming_frag *frag = NULL; + + GF_VALIDATE_OR_GOTO("socket", this, out); + GF_VALIDATE_OR_GOTO("socket", this->private, out); + + priv = this->private; + /* used to reduce the indirection */ + in = &priv->incoming; + frag = &in->frag; + + switch (frag->call_body.reply.accepted_state) { case SP_STATE_ACCEPTED_REPLY_INIT: - __socket_proto_init_pending (priv, - RPC_AUTH_FLAVOUR_N_LENGTH_SIZE); + __socket_proto_init_pending(priv, RPC_AUTH_FLAVOUR_N_LENGTH_SIZE); - frag->call_body.reply.accepted_state - = SP_STATE_READING_REPLY_VERFLEN; + frag->call_body.reply + .accepted_state = SP_STATE_READING_REPLY_VERFLEN; - /* fall through */ + /* fall through */ case SP_STATE_READING_REPLY_VERFLEN: - __socket_proto_read (priv, ret); + __socket_proto_read(priv, ret); - frag->call_body.reply.accepted_state - = SP_STATE_READ_REPLY_VERFLEN; + frag->call_body.reply.accepted_state = SP_STATE_READ_REPLY_VERFLEN; - /* fall through */ + /* fall through */ case SP_STATE_READ_REPLY_VERFLEN: - buf = rpc_reply_verflen_addr (frag->fragcurrent); + buf = rpc_reply_verflen_addr(frag->fragcurrent); - verflen = ntoh32 (*((uint32_t *) buf)); + verflen = ntoh32(*((uint32_t *)buf)); - /* also read accept status along with verf data */ - len = verflen + RPC_ACCEPT_STATUS_LEN; + /* also read accept status along with verf data */ + len = verflen + RPC_ACCEPT_STATUS_LEN; - __socket_proto_init_pending (priv, len); + __socket_proto_init_pending(priv, len); - frag->call_body.reply.accepted_state - = SP_STATE_READING_REPLY_VERFBYTES; + frag->call_body.reply + .accepted_state = SP_STATE_READING_REPLY_VERFBYTES; - /* fall through */ + /* fall through */ case SP_STATE_READING_REPLY_VERFBYTES: - __socket_proto_read (priv, ret); + __socket_proto_read(priv, ret); - frag->call_body.reply.accepted_state - = SP_STATE_READ_REPLY_VERFBYTES; + frag->call_body.reply + .accepted_state = SP_STATE_READ_REPLY_VERFBYTES; - buf = rpc_reply_accept_status_addr (frag->fragcurrent); + buf = rpc_reply_accept_status_addr(frag->fragcurrent); - frag->call_body.reply.accept_status - = ntoh32 (*(uint32_t *) buf); + frag->call_body.reply.accept_status = ntoh32(*(uint32_t *)buf); - /* fall through */ + /* fall through */ case SP_STATE_READ_REPLY_VERFBYTES: - if (frag->call_body.reply.accept_status - == SUCCESS) { - /* Need two different methods here for different protocols - Mainly because the exact XDR is used to calculate the - size of response */ - if ((in->request_info->procnum == GFS3_OP_READ) && - (in->request_info->prognum == GLUSTER_FOP_PROGRAM) && - (in->request_info->progver == GLUSTER_FOP_VERSION_v2)) { - ret = __socket_read_accepted_successful_reply_v2 (this); - } else { - ret = __socket_read_accepted_successful_reply (this); - } + if (frag->call_body.reply.accept_status == SUCCESS) { + /* Need two different methods here for different protocols + Mainly because the exact XDR is used to calculate the + size of response */ + if ((in->request_info->procnum == GFS3_OP_READ) && + (in->request_info->prognum == GLUSTER_FOP_PROGRAM) && + (in->request_info->progver == GLUSTER_FOP_VERSION_v2)) { + ret = __socket_read_accepted_successful_reply_v2(this); } else { - /* read entire remaining msg into buffer pointed to by - * fragcurrent - */ - ret = __socket_read_simple_msg (this); + ret = __socket_read_accepted_successful_reply(this); } + } else { + /* read entire remaining msg into buffer pointed to by + * fragcurrent + */ + ret = __socket_read_simple_msg(this); + } - remaining_size = RPC_FRAGSIZE (in->fraghdr) - - frag->bytes_read; + remaining_size = RPC_FRAGSIZE(in->fraghdr) - frag->bytes_read; - if ((ret == -1) - || ((ret == 0) && (remaining_size == 0) - && (RPC_LASTFRAG (in->fraghdr)))) { - frag->call_body.reply.accepted_state - = SP_STATE_ACCEPTED_REPLY_INIT; - } + if ((ret == -1) || ((ret == 0) && (remaining_size == 0) && + (RPC_LASTFRAG(in->fraghdr)))) { + frag->call_body.reply + .accepted_state = SP_STATE_ACCEPTED_REPLY_INIT; + } - break; - } + break; + } out: - return ret; + return ret; } - static int -__socket_read_denied_reply (rpc_transport_t *this) +__socket_read_denied_reply(rpc_transport_t *this) { - return __socket_read_simple_msg (this); + return __socket_read_simple_msg(this); } - #define rpc_reply_status_addr(fragcurrent) ((char *)fragcurrent - 4) - static int -__socket_read_vectored_reply (rpc_transport_t *this) +__socket_read_vectored_reply(rpc_transport_t *this) { - socket_private_t *priv = NULL; - int ret = 0; - char *buf = NULL; - uint32_t remaining_size = 0; - struct gf_sock_incoming *in = NULL; - struct gf_sock_incoming_frag *frag = NULL; + socket_private_t *priv = NULL; + int ret = 0; + char *buf = NULL; + uint32_t remaining_size = 0; + struct gf_sock_incoming *in = NULL; + struct gf_sock_incoming_frag *frag = NULL; - GF_VALIDATE_OR_GOTO ("socket", this, out); - GF_VALIDATE_OR_GOTO ("socket", this->private, out); + GF_VALIDATE_OR_GOTO("socket", this, out); + GF_VALIDATE_OR_GOTO("socket", this->private, out); - priv = this->private; - in = &priv->incoming; - frag = &in->frag; - - switch (frag->call_body.reply.status_state) { + priv = this->private; + in = &priv->incoming; + frag = &in->frag; + switch (frag->call_body.reply.status_state) { case SP_STATE_ACCEPTED_REPLY_INIT: - __socket_proto_init_pending (priv, RPC_REPLY_STATUS_SIZE); + __socket_proto_init_pending(priv, RPC_REPLY_STATUS_SIZE); - frag->call_body.reply.status_state - = SP_STATE_READING_REPLY_STATUS; + frag->call_body.reply.status_state = SP_STATE_READING_REPLY_STATUS; - /* fall through */ + /* fall through */ case SP_STATE_READING_REPLY_STATUS: - __socket_proto_read (priv, ret); + __socket_proto_read(priv, ret); - buf = rpc_reply_status_addr (frag->fragcurrent); + buf = rpc_reply_status_addr(frag->fragcurrent); - frag->call_body.reply.accept_status - = ntoh32 (*((uint32_t *) buf)); + frag->call_body.reply.accept_status = ntoh32(*((uint32_t *)buf)); - frag->call_body.reply.status_state - = SP_STATE_READ_REPLY_STATUS; + frag->call_body.reply.status_state = SP_STATE_READ_REPLY_STATUS; - /* fall through */ + /* fall through */ case SP_STATE_READ_REPLY_STATUS: - if (frag->call_body.reply.accept_status == MSG_ACCEPTED) { - ret = __socket_read_accepted_reply (this); - } else { - ret = __socket_read_denied_reply (this); - } - - remaining_size = RPC_FRAGSIZE (in->fraghdr) - frag->bytes_read; - - if ((ret == -1) - || ((ret == 0) && (remaining_size == 0) - && (RPC_LASTFRAG (in->fraghdr)))) { - frag->call_body.reply.status_state - = SP_STATE_VECTORED_REPLY_STATUS_INIT; - in->payload_vector.iov_len - = (unsigned long)frag->fragcurrent - - (unsigned long)in->payload_vector.iov_base; - } - break; - } + if (frag->call_body.reply.accept_status == MSG_ACCEPTED) { + ret = __socket_read_accepted_reply(this); + } else { + ret = __socket_read_denied_reply(this); + } + + remaining_size = RPC_FRAGSIZE(in->fraghdr) - frag->bytes_read; + + if ((ret == -1) || ((ret == 0) && (remaining_size == 0) && + (RPC_LASTFRAG(in->fraghdr)))) { + frag->call_body.reply + .status_state = SP_STATE_VECTORED_REPLY_STATUS_INIT; + in->payload_vector.iov_len = (unsigned long)frag->fragcurrent - + (unsigned long) + in->payload_vector.iov_base; + } + break; + } out: - return ret; + return ret; } - static int -__socket_read_simple_reply (rpc_transport_t *this) +__socket_read_simple_reply(rpc_transport_t *this) { - return __socket_read_simple_msg (this); + return __socket_read_simple_msg(this); } #define rpc_xid_addr(buf) (buf) static int -__socket_read_reply (rpc_transport_t *this) +__socket_read_reply(rpc_transport_t *this) { - socket_private_t *priv = NULL; - char *buf = NULL; - int32_t ret = -1; - rpc_request_info_t *request_info = NULL; - char map_xid = 0; - struct gf_sock_incoming *in = NULL; - struct gf_sock_incoming_frag *frag = NULL; - - GF_VALIDATE_OR_GOTO ("socket", this, out); - GF_VALIDATE_OR_GOTO ("socket", this->private, out); - - priv = this->private; - in = &priv->incoming; - frag = &in->frag; - - buf = rpc_xid_addr (iobuf_ptr (in->iobuf)); - + socket_private_t *priv = NULL; + char *buf = NULL; + int32_t ret = -1; + rpc_request_info_t *request_info = NULL; + char map_xid = 0; + struct gf_sock_incoming *in = NULL; + struct gf_sock_incoming_frag *frag = NULL; + + GF_VALIDATE_OR_GOTO("socket", this, out); + GF_VALIDATE_OR_GOTO("socket", this->private, out); + + priv = this->private; + in = &priv->incoming; + frag = &in->frag; + + buf = rpc_xid_addr(iobuf_ptr(in->iobuf)); + + if (in->request_info == NULL) { + in->request_info = GF_CALLOC(1, sizeof(*request_info), + gf_common_mt_rpc_trans_reqinfo_t); if (in->request_info == NULL) { - in->request_info = GF_CALLOC (1, sizeof (*request_info), - gf_common_mt_rpc_trans_reqinfo_t); - if (in->request_info == NULL) { - goto out; - } - - map_xid = 1; + goto out; } - request_info = in->request_info; - - if (map_xid) { - request_info->xid = ntoh32 (*((uint32_t *) buf)); + map_xid = 1; + } - /* release priv->lock, so as to avoid deadlock b/w conn->lock - * and priv->lock, since we are doing an upcall here. - */ - frag->state = SP_STATE_NOTIFYING_XID; - pthread_mutex_unlock (&priv->in_lock); - { - ret = rpc_transport_notify (this, - RPC_TRANSPORT_MAP_XID_REQUEST, - in->request_info); - } - pthread_mutex_lock (&priv->in_lock); + request_info = in->request_info; - /* Transition back to externally visible state. */ - frag->state = SP_STATE_READ_MSGTYPE; + if (map_xid) { + request_info->xid = ntoh32(*((uint32_t *)buf)); - if (ret == -1) { - gf_log (this->name, GF_LOG_WARNING, - "notify for event MAP_XID failed for %s", - this->peerinfo.identifier); - goto out; - } + /* release priv->lock, so as to avoid deadlock b/w conn->lock + * and priv->lock, since we are doing an upcall here. + */ + frag->state = SP_STATE_NOTIFYING_XID; + pthread_mutex_unlock(&priv->in_lock); + { + ret = rpc_transport_notify(this, RPC_TRANSPORT_MAP_XID_REQUEST, + in->request_info); } + pthread_mutex_lock(&priv->in_lock); - if ((request_info->prognum == GLUSTER_FOP_PROGRAM) - && (request_info->procnum == GF_FOP_READ)) { - if (map_xid && request_info->rsp.rsp_payload_count != 0) { - in->iobref = iobref_ref (request_info->rsp.rsp_iobref); - in->payload_vector = *request_info->rsp.rsp_payload; - } + /* Transition back to externally visible state. */ + frag->state = SP_STATE_READ_MSGTYPE; - ret = __socket_read_vectored_reply (this); - } else { - ret = __socket_read_simple_reply (this); + if (ret == -1) { + gf_log(this->name, GF_LOG_WARNING, + "notify for event MAP_XID failed for %s", + this->peerinfo.identifier); + goto out; } + } + + if ((request_info->prognum == GLUSTER_FOP_PROGRAM) && + (request_info->procnum == GF_FOP_READ)) { + if (map_xid && request_info->rsp.rsp_payload_count != 0) { + in->iobref = iobref_ref(request_info->rsp.rsp_iobref); + in->payload_vector = *request_info->rsp.rsp_payload; + } + + ret = __socket_read_vectored_reply(this); + } else { + ret = __socket_read_simple_reply(this); + } out: - return ret; + return ret; } - /* returns the number of bytes yet to be read in a fragment */ static int -__socket_read_frag (rpc_transport_t *this) +__socket_read_frag(rpc_transport_t *this) { - socket_private_t *priv = NULL; - int32_t ret = 0; - char *buf = NULL; - uint32_t remaining_size = 0; - struct gf_sock_incoming *in = NULL; - struct gf_sock_incoming_frag *frag = NULL; - - GF_VALIDATE_OR_GOTO ("socket", this, out); - GF_VALIDATE_OR_GOTO ("socket", this->private, out); - - priv = this->private; - /* used to reduce the indirection */ - in = &priv->incoming; - frag = &in->frag; - - switch (frag->state) { + socket_private_t *priv = NULL; + int32_t ret = 0; + char *buf = NULL; + uint32_t remaining_size = 0; + struct gf_sock_incoming *in = NULL; + struct gf_sock_incoming_frag *frag = NULL; + + GF_VALIDATE_OR_GOTO("socket", this, out); + GF_VALIDATE_OR_GOTO("socket", this->private, out); + + priv = this->private; + /* used to reduce the indirection */ + in = &priv->incoming; + frag = &in->frag; + + switch (frag->state) { case SP_STATE_NADA: - __socket_proto_init_pending (priv, RPC_MSGTYPE_SIZE); + __socket_proto_init_pending(priv, RPC_MSGTYPE_SIZE); - frag->state = SP_STATE_READING_MSGTYPE; + frag->state = SP_STATE_READING_MSGTYPE; - /* fall through */ + /* fall through */ case SP_STATE_READING_MSGTYPE: - __socket_proto_read (priv, ret); + __socket_proto_read(priv, ret); - frag->state = SP_STATE_READ_MSGTYPE; - /* fall through */ + frag->state = SP_STATE_READ_MSGTYPE; + /* fall through */ case SP_STATE_READ_MSGTYPE: - buf = rpc_msgtype_addr (iobuf_ptr (in->iobuf)); - in->msg_type = ntoh32 (*((uint32_t *)buf)); - - if (in->msg_type == CALL) { - ret = __socket_read_request (this); - } else if (in->msg_type == REPLY) { - ret = __socket_read_reply (this); - } else if (in->msg_type == (msg_type_t) GF_UNIVERSAL_ANSWER) { - gf_log ("rpc", GF_LOG_ERROR, - "older version of protocol/process trying to " - "connect from %s. use newer version on that node", - this->peerinfo.identifier); - } else { - gf_log ("rpc", GF_LOG_ERROR, - "wrong MSG-TYPE (%d) received from %s", - in->msg_type, - this->peerinfo.identifier); - ret = -1; - } + buf = rpc_msgtype_addr(iobuf_ptr(in->iobuf)); + in->msg_type = ntoh32(*((uint32_t *)buf)); + + if (in->msg_type == CALL) { + ret = __socket_read_request(this); + } else if (in->msg_type == REPLY) { + ret = __socket_read_reply(this); + } else if (in->msg_type == (msg_type_t)GF_UNIVERSAL_ANSWER) { + gf_log("rpc", GF_LOG_ERROR, + "older version of protocol/process trying to " + "connect from %s. use newer version on that node", + this->peerinfo.identifier); + } else { + gf_log("rpc", GF_LOG_ERROR, + "wrong MSG-TYPE (%d) received from %s", in->msg_type, + this->peerinfo.identifier); + ret = -1; + } - remaining_size = RPC_FRAGSIZE (in->fraghdr) - frag->bytes_read; + remaining_size = RPC_FRAGSIZE(in->fraghdr) - frag->bytes_read; - if ((ret == -1) - || ((ret == 0) && (remaining_size == 0) - && (RPC_LASTFRAG (in->fraghdr)))) { - /* frag->state = SP_STATE_NADA; */ - frag->state = SP_STATE_RPCFRAG_INIT; - } + if ((ret == -1) || ((ret == 0) && (remaining_size == 0) && + (RPC_LASTFRAG(in->fraghdr)))) { + /* frag->state = SP_STATE_NADA; */ + frag->state = SP_STATE_RPCFRAG_INIT; + } - break; + break; case SP_STATE_NOTIFYING_XID: - /* Another epoll thread is notifying higher layers - *of reply's xid. */ - errno = EAGAIN; - return -1; - break; - - } + /* Another epoll thread is notifying higher layers + *of reply's xid. */ + errno = EAGAIN; + return -1; + break; + } out: - return ret; + return ret; } - static void -__socket_reset_priv (socket_private_t *priv) +__socket_reset_priv(socket_private_t *priv) { - struct gf_sock_incoming *in = NULL; + struct gf_sock_incoming *in = NULL; - /* used to reduce the indirection */ - in = &priv->incoming; + /* used to reduce the indirection */ + in = &priv->incoming; - if (in->iobref) { - iobref_unref (in->iobref); - in->iobref = NULL; - } + if (in->iobref) { + iobref_unref(in->iobref); + in->iobref = NULL; + } - if (in->iobuf) { - iobuf_unref (in->iobuf); - in->iobuf = NULL; - } - - if (in->request_info != NULL) { - GF_FREE (in->request_info); - in->request_info = NULL; - } + if (in->iobuf) { + iobuf_unref(in->iobuf); + in->iobuf = NULL; + } - memset (&in->payload_vector, 0, - sizeof (in->payload_vector)); + if (in->request_info != NULL) { + GF_FREE(in->request_info); + in->request_info = NULL; + } + memset(&in->payload_vector, 0, sizeof(in->payload_vector)); } - static int -__socket_proto_state_machine (rpc_transport_t *this, - rpc_transport_pollin_t **pollin) +__socket_proto_state_machine(rpc_transport_t *this, + rpc_transport_pollin_t **pollin) { - int ret = -1; - socket_private_t *priv = NULL; - struct iobuf *iobuf = NULL; - struct iobref *iobref = NULL; - struct iovec vector[2]; - struct gf_sock_incoming *in = NULL; - struct gf_sock_incoming_frag *frag = NULL; - - GF_VALIDATE_OR_GOTO ("socket", this, out); - GF_VALIDATE_OR_GOTO ("socket", this->private, out); - - priv = this->private; - /* used to reduce the indirection */ - in = &priv->incoming; - frag = &in->frag; - - while (in->record_state != SP_STATE_COMPLETE) { - switch (in->record_state) { - - case SP_STATE_NADA: - in->total_bytes_read = 0; - in->payload_vector.iov_len = 0; - - in->pending_vector = in->vector; - in->pending_vector->iov_base = &in->fraghdr; - - in->pending_vector->iov_len = sizeof (in->fraghdr); - - in->record_state = SP_STATE_READING_FRAGHDR; - - /* fall through */ - - case SP_STATE_READING_FRAGHDR: - ret = __socket_readv (this, in->pending_vector, 1, - &in->pending_vector, - &in->pending_count, - NULL); - if (ret == -1) - goto out; - - if (ret > 0) { - gf_log (this->name, GF_LOG_TRACE, "partial " - "fragment header read"); - goto out; - } + int ret = -1; + socket_private_t *priv = NULL; + struct iobuf *iobuf = NULL; + struct iobref *iobref = NULL; + struct iovec vector[2]; + struct gf_sock_incoming *in = NULL; + struct gf_sock_incoming_frag *frag = NULL; - if (ret == 0) { - in->record_state = SP_STATE_READ_FRAGHDR; - } - /* fall through */ + GF_VALIDATE_OR_GOTO("socket", this, out); + GF_VALIDATE_OR_GOTO("socket", this->private, out); - case SP_STATE_READ_FRAGHDR: + priv = this->private; + /* used to reduce the indirection */ + in = &priv->incoming; + frag = &in->frag; - in->fraghdr = ntoh32 (in->fraghdr); - in->total_bytes_read += RPC_FRAGSIZE(in->fraghdr); + while (in->record_state != SP_STATE_COMPLETE) { + switch (in->record_state) { + case SP_STATE_NADA: + in->total_bytes_read = 0; + in->payload_vector.iov_len = 0; - if (in->total_bytes_read >= GF_UNIT_GB) { - ret = -ENOMEM; - goto out; - } + in->pending_vector = in->vector; + in->pending_vector->iov_base = &in->fraghdr; - iobuf = iobuf_get2 (this->ctx->iobuf_pool, - (in->total_bytes_read + - sizeof (in->fraghdr))); - if (!iobuf) { - ret = -ENOMEM; - goto out; - } + in->pending_vector->iov_len = sizeof(in->fraghdr); - if (in->iobuf == NULL) { - /* first fragment */ - frag->fragcurrent = iobuf_ptr (iobuf); - } else { - /* second or further fragment */ - memcpy(iobuf_ptr (iobuf), iobuf_ptr (in->iobuf), - in->total_bytes_read - RPC_FRAGSIZE(in->fraghdr)); - iobuf_unref (in->iobuf); - frag->fragcurrent = (char *) iobuf_ptr (iobuf) + - in->total_bytes_read - RPC_FRAGSIZE(in->fraghdr); - frag->pending_vector->iov_base = frag->fragcurrent; - in->pending_vector = frag->pending_vector; - } + in->record_state = SP_STATE_READING_FRAGHDR; - in->iobuf = iobuf; - in->iobuf_size = 0; - in->record_state = SP_STATE_READING_FRAG; - /* fall through */ + /* fall through */ - case SP_STATE_READING_FRAG: - ret = __socket_read_frag (this); + case SP_STATE_READING_FRAGHDR: + ret = __socket_readv(this, in->pending_vector, 1, + &in->pending_vector, &in->pending_count, + NULL); + if (ret == -1) + goto out; - if ((ret == -1) || - (frag->bytes_read != RPC_FRAGSIZE (in->fraghdr))) { - goto out; - } + if (ret > 0) { + gf_log(this->name, GF_LOG_TRACE, + "partial " + "fragment header read"); + goto out; + } - frag->bytes_read = 0; + if (ret == 0) { + in->record_state = SP_STATE_READ_FRAGHDR; + } + /* fall through */ - if (!RPC_LASTFRAG (in->fraghdr)) { - in->pending_vector = in->vector; - in->pending_vector->iov_base = &in->fraghdr; - in->pending_vector->iov_len = sizeof(in->fraghdr); - in->record_state = SP_STATE_READING_FRAGHDR; - break; - } + case SP_STATE_READ_FRAGHDR: + + in->fraghdr = ntoh32(in->fraghdr); + in->total_bytes_read += RPC_FRAGSIZE(in->fraghdr); + + if (in->total_bytes_read >= GF_UNIT_GB) { + ret = -ENOMEM; + goto out; + } + + iobuf = iobuf_get2( + this->ctx->iobuf_pool, + (in->total_bytes_read + sizeof(in->fraghdr))); + if (!iobuf) { + ret = -ENOMEM; + goto out; + } - /* we've read the entire rpc record, notify the - * upper layers. - */ - if (pollin != NULL) { - int count = 0; - in->iobuf_size = (in->total_bytes_read - - in->payload_vector.iov_len); - - memset (vector, 0, sizeof (vector)); - - if (in->iobref == NULL) { - in->iobref = iobref_new (); - if (in->iobref == NULL) { - ret = -1; - goto out; - } - } - - vector[count].iov_base = iobuf_ptr (in->iobuf); - vector[count].iov_len = in->iobuf_size; - - iobref = in->iobref; - - count++; - - if (in->payload_vector.iov_base != NULL) { - vector[count] = in->payload_vector; - count++; - } - - *pollin = rpc_transport_pollin_alloc (this, - vector, - count, - in->iobuf, - iobref, - in->request_info); - iobuf_unref (in->iobuf); - in->iobuf = NULL; - - if (*pollin == NULL) { - gf_log (this->name, GF_LOG_WARNING, - "transport pollin allocation failed"); - ret = -1; - goto out; - } - if (in->msg_type == REPLY) - (*pollin)->is_reply = 1; - - in->request_info = NULL; + if (in->iobuf == NULL) { + /* first fragment */ + frag->fragcurrent = iobuf_ptr(iobuf); + } else { + /* second or further fragment */ + memcpy(iobuf_ptr(iobuf), iobuf_ptr(in->iobuf), + in->total_bytes_read - RPC_FRAGSIZE(in->fraghdr)); + iobuf_unref(in->iobuf); + frag->fragcurrent = (char *)iobuf_ptr(iobuf) + + in->total_bytes_read - + RPC_FRAGSIZE(in->fraghdr); + frag->pending_vector->iov_base = frag->fragcurrent; + in->pending_vector = frag->pending_vector; + } + + in->iobuf = iobuf; + in->iobuf_size = 0; + in->record_state = SP_STATE_READING_FRAG; + /* fall through */ + + case SP_STATE_READING_FRAG: + ret = __socket_read_frag(this); + + if ((ret == -1) || + (frag->bytes_read != RPC_FRAGSIZE(in->fraghdr))) { + goto out; + } + + frag->bytes_read = 0; + + if (!RPC_LASTFRAG(in->fraghdr)) { + in->pending_vector = in->vector; + in->pending_vector->iov_base = &in->fraghdr; + in->pending_vector->iov_len = sizeof(in->fraghdr); + in->record_state = SP_STATE_READING_FRAGHDR; + break; + } + + /* we've read the entire rpc record, notify the + * upper layers. + */ + if (pollin != NULL) { + int count = 0; + in->iobuf_size = (in->total_bytes_read - + in->payload_vector.iov_len); + + memset(vector, 0, sizeof(vector)); + + if (in->iobref == NULL) { + in->iobref = iobref_new(); + if (in->iobref == NULL) { + ret = -1; + goto out; } - in->record_state = SP_STATE_COMPLETE; - break; + } - case SP_STATE_COMPLETE: - /* control should not reach here */ - gf_log (this->name, GF_LOG_WARNING, "control reached to " - "SP_STATE_COMPLETE, which should not have " - "happened"); - break; + vector[count].iov_base = iobuf_ptr(in->iobuf); + vector[count].iov_len = in->iobuf_size; + + iobref = in->iobref; + + count++; + + if (in->payload_vector.iov_base != NULL) { + vector[count] = in->payload_vector; + count++; + } + + *pollin = rpc_transport_pollin_alloc(this, vector, count, + in->iobuf, iobref, + in->request_info); + iobuf_unref(in->iobuf); + in->iobuf = NULL; + + if (*pollin == NULL) { + gf_log(this->name, GF_LOG_WARNING, + "transport pollin allocation failed"); + ret = -1; + goto out; + } + if (in->msg_type == REPLY) + (*pollin)->is_reply = 1; + + in->request_info = NULL; } - } + in->record_state = SP_STATE_COMPLETE; + break; - if (in->record_state == SP_STATE_COMPLETE) { - in->record_state = SP_STATE_NADA; - __socket_reset_priv (priv); + case SP_STATE_COMPLETE: + /* control should not reach here */ + gf_log(this->name, GF_LOG_WARNING, + "control reached to " + "SP_STATE_COMPLETE, which should not have " + "happened"); + break; } + } + + if (in->record_state == SP_STATE_COMPLETE) { + in->record_state = SP_STATE_NADA; + __socket_reset_priv(priv); + } out: - if ((ret == -1) && (errno == EAGAIN)) { - ret = 0; - } + if ((ret == -1) && (errno == EAGAIN)) { + ret = 0; + } - return ret; + return ret; } - static int -socket_proto_state_machine (rpc_transport_t *this, - rpc_transport_pollin_t **pollin) +socket_proto_state_machine(rpc_transport_t *this, + rpc_transport_pollin_t **pollin) { - socket_private_t *priv = NULL; - int ret = 0; + socket_private_t *priv = NULL; + int ret = 0; - GF_VALIDATE_OR_GOTO ("socket", this, out); - GF_VALIDATE_OR_GOTO ("socket", this->private, out); + GF_VALIDATE_OR_GOTO("socket", this, out); + GF_VALIDATE_OR_GOTO("socket", this->private, out); - priv = this->private; + priv = this->private; - pthread_mutex_lock (&priv->in_lock); - { - ret = __socket_proto_state_machine (this, pollin); - } - pthread_mutex_unlock (&priv->in_lock); + pthread_mutex_lock(&priv->in_lock); + { + ret = __socket_proto_state_machine(this, pollin); + } + pthread_mutex_unlock(&priv->in_lock); out: - return ret; + return ret; } - static int -socket_event_poll_in (rpc_transport_t *this, gf_boolean_t notify_handled) +socket_event_poll_in(rpc_transport_t *this, gf_boolean_t notify_handled) { - int ret = -1; - rpc_transport_pollin_t *pollin = NULL; - socket_private_t *priv = this->private; - glusterfs_ctx_t *ctx = NULL; + int ret = -1; + rpc_transport_pollin_t *pollin = NULL; + socket_private_t *priv = this->private; + glusterfs_ctx_t *ctx = NULL; - ctx = this->ctx; + ctx = this->ctx; - ret = socket_proto_state_machine (this, &pollin); + ret = socket_proto_state_machine(this, &pollin); - if (pollin) { - pthread_mutex_lock (&priv->notify.lock); - { - priv->notify.in_progress++; - } - pthread_mutex_unlock (&priv->notify.lock); + if (pollin) { + pthread_mutex_lock(&priv->notify.lock); + { + priv->notify.in_progress++; } + pthread_mutex_unlock(&priv->notify.lock); + } + if (notify_handled && (ret != -1)) + event_handled(ctx->event_pool, priv->sock, priv->idx, priv->gen); - if (notify_handled && (ret != -1)) - event_handled (ctx->event_pool, priv->sock, priv->idx, - priv->gen); - - if (pollin) { - ret = rpc_transport_notify (this, RPC_TRANSPORT_MSG_RECEIVED, - pollin); + if (pollin) { + ret = rpc_transport_notify(this, RPC_TRANSPORT_MSG_RECEIVED, pollin); - rpc_transport_pollin_destroy (pollin); + rpc_transport_pollin_destroy(pollin); - pthread_mutex_lock (&priv->notify.lock); - { - --priv->notify.in_progress; + pthread_mutex_lock(&priv->notify.lock); + { + --priv->notify.in_progress; - if (!priv->notify.in_progress) - pthread_cond_signal (&priv->notify.cond); - } - pthread_mutex_unlock (&priv->notify.lock); + if (!priv->notify.in_progress) + pthread_cond_signal(&priv->notify.cond); } + pthread_mutex_unlock(&priv->notify.lock); + } - return ret; + return ret; } - static int -socket_connect_finish (rpc_transport_t *this) +socket_connect_finish(rpc_transport_t *this) { - int ret = -1; - socket_private_t *priv = NULL; - rpc_transport_event_t event = 0; - char notify_rpc = 0; - - GF_VALIDATE_OR_GOTO ("socket", this, out); - GF_VALIDATE_OR_GOTO ("socket", this->private, out); + int ret = -1; + socket_private_t *priv = NULL; + rpc_transport_event_t event = 0; + char notify_rpc = 0; - priv = this->private; - - pthread_mutex_lock (&priv->in_lock); - pthread_mutex_lock (&priv->out_lock); - { - if (priv->connected != 0) - goto unlock; + GF_VALIDATE_OR_GOTO("socket", this, out); + GF_VALIDATE_OR_GOTO("socket", this->private, out); - get_transport_identifiers (this); + priv = this->private; - ret = __socket_connect_finish (priv->sock); + pthread_mutex_lock(&priv->in_lock); + pthread_mutex_lock(&priv->out_lock); + { + if (priv->connected != 0) + goto unlock; - if (ret == -1 && errno == EINPROGRESS) - ret = 1; + get_transport_identifiers(this); - if (ret == -1 && errno != EINPROGRESS) { - if (!priv->connect_finish_log) { - gf_log (this->name, GF_LOG_ERROR, - "connection to %s failed (%s); " - "disconnecting socket", - this->peerinfo.identifier, - strerror (errno)); - priv->connect_finish_log = 1; - } - __socket_disconnect (this); - goto unlock; - } + ret = __socket_connect_finish(priv->sock); - if (ret == 0) { - notify_rpc = 1; - - this->myinfo.sockaddr_len = - sizeof (this->myinfo.sockaddr); - - ret = getsockname (priv->sock, - SA (&this->myinfo.sockaddr), - &this->myinfo.sockaddr_len); - if (ret == -1) { - gf_log (this->name, GF_LOG_WARNING, - "getsockname on (%d) failed (%s) - " - "disconnecting socket", - priv->sock, strerror (errno)); - __socket_disconnect (this); - event = RPC_TRANSPORT_DISCONNECT; - goto unlock; - } + if (ret == -1 && errno == EINPROGRESS) + ret = 1; - priv->connected = 1; - priv->connect_finish_log = 0; - event = RPC_TRANSPORT_CONNECT; - } + if (ret == -1 && errno != EINPROGRESS) { + if (!priv->connect_finish_log) { + gf_log(this->name, GF_LOG_ERROR, + "connection to %s failed (%s); " + "disconnecting socket", + this->peerinfo.identifier, strerror(errno)); + priv->connect_finish_log = 1; + } + __socket_disconnect(this); + goto unlock; } + + if (ret == 0) { + notify_rpc = 1; + + this->myinfo.sockaddr_len = sizeof(this->myinfo.sockaddr); + + ret = getsockname(priv->sock, SA(&this->myinfo.sockaddr), + &this->myinfo.sockaddr_len); + if (ret == -1) { + gf_log(this->name, GF_LOG_WARNING, + "getsockname on (%d) failed (%s) - " + "disconnecting socket", + priv->sock, strerror(errno)); + __socket_disconnect(this); + event = RPC_TRANSPORT_DISCONNECT; + goto unlock; + } + + priv->connected = 1; + priv->connect_finish_log = 0; + event = RPC_TRANSPORT_CONNECT; + } + } unlock: - pthread_mutex_unlock (&priv->out_lock); - pthread_mutex_unlock (&priv->in_lock); + pthread_mutex_unlock(&priv->out_lock); + pthread_mutex_unlock(&priv->in_lock); - if (notify_rpc) { - rpc_transport_notify (this, event, this); - } + if (notify_rpc) { + rpc_transport_notify(this, event, this); + } out: - return ret; + return ret; } -static int socket_disconnect (rpc_transport_t *this, gf_boolean_t wait); +static int +socket_disconnect(rpc_transport_t *this, gf_boolean_t wait); /* socket_is_connected() is for use only in socket_event_handler() */ static inline gf_boolean_t -socket_is_connected (rpc_transport_t *this) +socket_is_connected(rpc_transport_t *this) { - socket_private_t *priv = NULL; + socket_private_t *priv = NULL; - priv = this->private; + priv = this->private; - if (priv->use_ssl) { - return priv->is_server ? priv->ssl_accepted : - priv->ssl_connected; - } else { - return priv->is_server ? priv->accepted : - priv->connected; - } + if (priv->use_ssl) { + return priv->is_server ? priv->ssl_accepted : priv->ssl_connected; + } else { + return priv->is_server ? priv->accepted : priv->connected; + } } static void -ssl_rearm_event_fd (rpc_transport_t *this) +ssl_rearm_event_fd(rpc_transport_t *this) { - socket_private_t *priv = NULL; - glusterfs_ctx_t *ctx = NULL; - int idx = -1; - int gen = -1; - int fd = -1; - - priv = this->private; - ctx = this->ctx; - - idx = priv->idx; - gen = priv->gen; - fd = priv->sock; - - if (priv->ssl_error_required == SSL_ERROR_WANT_READ) - event_select_on (ctx->event_pool, fd, idx, 1, -1); - if (priv->ssl_error_required == SSL_ERROR_WANT_WRITE) - event_select_on (ctx->event_pool, fd, idx, -1, 1); - event_handled (ctx->event_pool, fd, idx, gen); + socket_private_t *priv = NULL; + glusterfs_ctx_t *ctx = NULL; + int idx = -1; + int gen = -1; + int fd = -1; + + priv = this->private; + ctx = this->ctx; + + idx = priv->idx; + gen = priv->gen; + fd = priv->sock; + + if (priv->ssl_error_required == SSL_ERROR_WANT_READ) + event_select_on(ctx->event_pool, fd, idx, 1, -1); + if (priv->ssl_error_required == SSL_ERROR_WANT_WRITE) + event_select_on(ctx->event_pool, fd, idx, -1, 1); + event_handled(ctx->event_pool, fd, idx, gen); } static int -ssl_handle_server_connection_attempt (rpc_transport_t *this) +ssl_handle_server_connection_attempt(rpc_transport_t *this) { - socket_private_t *priv = NULL; - glusterfs_ctx_t *ctx = NULL; - int idx = -1; - int gen = -1; - int ret = -1; - int fd = -1; - - priv = this->private; - ctx = this->ctx; - - idx = priv->idx; - gen = priv->gen; - fd = priv->sock; - - if (!priv->ssl_context_created) { - ret = ssl_setup_connection_prefix (this); - if (ret < 0) { - gf_log (this->name, GF_LOG_TRACE, - "> ssl_setup_connection_prefix() failed!"); - ret = -1; - goto out; - } else { - priv->ssl_context_created = _gf_true; - } - } - ret = ssl_complete_connection (this); - if (ret == 0) { - /* nothing to do */ - event_select_on (ctx->event_pool, fd, idx, 1, 0); - event_handled (ctx->event_pool, fd, idx, gen); - ret = 1; + socket_private_t *priv = NULL; + glusterfs_ctx_t *ctx = NULL; + int idx = -1; + int gen = -1; + int ret = -1; + int fd = -1; + + priv = this->private; + ctx = this->ctx; + + idx = priv->idx; + gen = priv->gen; + fd = priv->sock; + + if (!priv->ssl_context_created) { + ret = ssl_setup_connection_prefix(this); + if (ret < 0) { + gf_log(this->name, GF_LOG_TRACE, + "> ssl_setup_connection_prefix() failed!"); + ret = -1; + goto out; } else { - if (errno == EAGAIN) { - ssl_rearm_event_fd (this); - ret = 1; - } else { - ret = -1; - gf_log (this->name, GF_LOG_TRACE, - "ssl_complete_connection returned error"); - } + priv->ssl_context_created = _gf_true; + } + } + ret = ssl_complete_connection(this); + if (ret == 0) { + /* nothing to do */ + event_select_on(ctx->event_pool, fd, idx, 1, 0); + event_handled(ctx->event_pool, fd, idx, gen); + ret = 1; + } else { + if (errno == EAGAIN) { + ssl_rearm_event_fd(this); + ret = 1; + } else { + ret = -1; + gf_log(this->name, GF_LOG_TRACE, + "ssl_complete_connection returned error"); } + } out: - return ret; + return ret; } static int -ssl_handle_client_connection_attempt (rpc_transport_t *this) +ssl_handle_client_connection_attempt(rpc_transport_t *this) { - socket_private_t *priv = NULL; - glusterfs_ctx_t *ctx = NULL; - int idx = -1; - int ret = -1; - int fd = -1; - - priv = this->private; - ctx = this->ctx; - - idx = priv->idx; - fd = priv->sock; - - /* SSL client */ - if (priv->connect_failed) { - gf_log (this->name, GF_LOG_TRACE, - ">>> disconnecting SSL socket"); - ret = socket_disconnect (this, _gf_false); - /* Force ret to be -1, as we are officially done with - this socket */ + socket_private_t *priv = NULL; + glusterfs_ctx_t *ctx = NULL; + int idx = -1; + int ret = -1; + int fd = -1; + + priv = this->private; + ctx = this->ctx; + + idx = priv->idx; + fd = priv->sock; + + /* SSL client */ + if (priv->connect_failed) { + gf_log(this->name, GF_LOG_TRACE, ">>> disconnecting SSL socket"); + ret = socket_disconnect(this, _gf_false); + /* Force ret to be -1, as we are officially done with + this socket */ + ret = -1; + } else { + if (!priv->ssl_context_created) { + ret = ssl_setup_connection_prefix(this); + if (ret < 0) { + gf_log(this->name, GF_LOG_TRACE, + "> ssl_setup_connection_prefix() " + "failed!"); ret = -1; + goto out; + } else { + priv->ssl_context_created = _gf_true; + } + } + ret = ssl_complete_connection(this); + if (ret == 0) { + ret = socket_connect_finish(this); + event_select_on(ctx->event_pool, fd, idx, 1, 0); + gf_log(this->name, GF_LOG_TRACE, ">>> completed client connect"); } else { - if (!priv->ssl_context_created) { - ret = ssl_setup_connection_prefix (this); - if (ret < 0) { - gf_log (this->name, GF_LOG_TRACE, - "> ssl_setup_connection_prefix() " - "failed!"); - ret = -1; - goto out; - } else { - priv->ssl_context_created = _gf_true; - } - } - ret = ssl_complete_connection (this); - if (ret == 0) { - ret = socket_connect_finish (this); - event_select_on (ctx->event_pool, fd, idx, 1, 0); - gf_log (this->name, GF_LOG_TRACE, - ">>> completed client connect"); - } else { - if (errno == EAGAIN) { - gf_log (this->name, GF_LOG_TRACE, - ">>> retrying client connect 2"); - ssl_rearm_event_fd (this); - ret = 1; - } else { - /* this is a connection failure */ - ret = socket_connect_finish (this); - gf_log (this->name, GF_LOG_TRACE, - "ssl_complete_connection " - "returned error"); - ret = -1; - } - } + if (errno == EAGAIN) { + gf_log(this->name, GF_LOG_TRACE, + ">>> retrying client connect 2"); + ssl_rearm_event_fd(this); + ret = 1; + } else { + /* this is a connection failure */ + ret = socket_connect_finish(this); + gf_log(this->name, GF_LOG_TRACE, + "ssl_complete_connection " + "returned error"); + ret = -1; + } } + } out: - return ret; + return ret; } static int -socket_handle_client_connection_attempt (rpc_transport_t *this) +socket_handle_client_connection_attempt(rpc_transport_t *this) { - socket_private_t *priv = NULL; - glusterfs_ctx_t *ctx = NULL; - int idx = -1; - int gen = -1; - int ret = -1; - int fd = -1; - - priv = this->private; - ctx = this->ctx; - - idx = priv->idx; - gen = priv->gen; - fd = priv->sock; - - /* non-SSL client */ - if (priv->connect_failed) { - /* connect failed with some other error than - EINPROGRESS or ENOENT, so nothing more to - do, fail reading/writing anything even if - poll_in or poll_out - is set - */ - gf_log ("transport", GF_LOG_DEBUG, - "connect failed with some other error " - "than EINPROGRESS or ENOENT, so " - "nothing more to do; disconnecting " - "socket"); - (void)socket_disconnect (this, _gf_false); - - /* Force ret to be -1, as we are officially - * done with this socket - */ - ret = -1; - } else { - ret = socket_connect_finish (this); - gf_log (this->name, GF_LOG_TRACE, - "socket_connect_finish() returned %d", - ret); - if (ret == 0 || ret == 1) { - /* we don't want to do any reads or - * writes on the connection yet in - * socket_event_handler, so just - * return 1 - */ - ret = 1; - event_handled (ctx->event_pool, fd, idx, gen); - } - } - return ret; + socket_private_t *priv = NULL; + glusterfs_ctx_t *ctx = NULL; + int idx = -1; + int gen = -1; + int ret = -1; + int fd = -1; + + priv = this->private; + ctx = this->ctx; + + idx = priv->idx; + gen = priv->gen; + fd = priv->sock; + + /* non-SSL client */ + if (priv->connect_failed) { + /* connect failed with some other error than + EINPROGRESS or ENOENT, so nothing more to + do, fail reading/writing anything even if + poll_in or poll_out + is set + */ + gf_log("transport", GF_LOG_DEBUG, + "connect failed with some other error " + "than EINPROGRESS or ENOENT, so " + "nothing more to do; disconnecting " + "socket"); + (void)socket_disconnect(this, _gf_false); + + /* Force ret to be -1, as we are officially + * done with this socket + */ + ret = -1; + } else { + ret = socket_connect_finish(this); + gf_log(this->name, GF_LOG_TRACE, "socket_connect_finish() returned %d", + ret); + if (ret == 0 || ret == 1) { + /* we don't want to do any reads or + * writes on the connection yet in + * socket_event_handler, so just + * return 1 + */ + ret = 1; + event_handled(ctx->event_pool, fd, idx, gen); + } + } + return ret; } static int -socket_complete_connection (rpc_transport_t *this) +socket_complete_connection(rpc_transport_t *this) { - socket_private_t *priv = NULL; - glusterfs_ctx_t *ctx = NULL; - int idx = -1; - int gen = -1; - int ret = -1; - int fd = -1; + socket_private_t *priv = NULL; + glusterfs_ctx_t *ctx = NULL; + int idx = -1; + int gen = -1; + int ret = -1; + int fd = -1; - priv = this->private; - ctx = this->ctx; + priv = this->private; + ctx = this->ctx; - idx = priv->idx; - gen = priv->gen; - fd = priv->sock; + idx = priv->idx; + gen = priv->gen; + fd = priv->sock; - if (priv->use_ssl) { - if (priv->is_server) { - ret = ssl_handle_server_connection_attempt (this); - } else { - ret = ssl_handle_client_connection_attempt (this); - } + if (priv->use_ssl) { + if (priv->is_server) { + ret = ssl_handle_server_connection_attempt(this); } else { - if (priv->is_server) { - /* non-SSL server: nothing much to do - * connection has already been accepted in - * socket_server_event_handler() - */ - priv->accepted = _gf_true; - event_handled (ctx->event_pool, fd, idx, gen); - ret = 1; - } else { - ret = socket_handle_client_connection_attempt (this); - } + ret = ssl_handle_client_connection_attempt(this); } - return ret; + } else { + if (priv->is_server) { + /* non-SSL server: nothing much to do + * connection has already been accepted in + * socket_server_event_handler() + */ + priv->accepted = _gf_true; + event_handled(ctx->event_pool, fd, idx, gen); + ret = 1; + } else { + ret = socket_handle_client_connection_attempt(this); + } + } + return ret; } /* reads rpc_requests during pollin */ static int -socket_event_handler (int fd, int idx, int gen, void *data, - int poll_in, int poll_out, int poll_err) +socket_event_handler(int fd, int idx, int gen, void *data, int poll_in, + int poll_out, int poll_err) { - rpc_transport_t *this = NULL; - socket_private_t *priv = NULL; - int ret = -1; - glusterfs_ctx_t *ctx = NULL; - gf_boolean_t socket_closed = _gf_false, notify_handled = _gf_false; + rpc_transport_t *this = NULL; + socket_private_t *priv = NULL; + int ret = -1; + glusterfs_ctx_t *ctx = NULL; + gf_boolean_t socket_closed = _gf_false, notify_handled = _gf_false; + this = data; - this = data; + GF_VALIDATE_OR_GOTO("socket", this, out); + GF_VALIDATE_OR_GOTO("socket", this->private, out); + GF_VALIDATE_OR_GOTO("socket", this->xl, out); - GF_VALIDATE_OR_GOTO ("socket", this, out); - GF_VALIDATE_OR_GOTO ("socket", this->private, out); - GF_VALIDATE_OR_GOTO ("socket", this->xl, out); + THIS = this->xl; + priv = this->private; + ctx = this->ctx; - THIS = this->xl; - priv = this->private; - ctx = this->ctx; + pthread_mutex_lock(&priv->in_lock); + pthread_mutex_lock(&priv->out_lock); + { + priv->idx = idx; + priv->gen = gen; + } + pthread_mutex_unlock(&priv->out_lock); + pthread_mutex_unlock(&priv->in_lock); + + gf_log(this->name, GF_LOG_TRACE, "%s (sock:%d) in:%d, out:%d, err:%d", + (priv->is_server ? "server" : "client"), priv->sock, poll_in, + poll_out, poll_err); + + if (!poll_err) { + if (!socket_is_connected(this)) { + gf_log(this->name, GF_LOG_TRACE, + "%s (sock:%d) socket is not connected, " + "completing connection", + (priv->is_server ? "server" : "client"), priv->sock); + + ret = socket_complete_connection(this); + + gf_log(this->name, GF_LOG_TRACE, + "(sock:%d) " + "socket_complete_connection() returned %d", + priv->sock, ret); + + if (ret > 0) { + gf_log(this->name, GF_LOG_TRACE, + "(sock:%d) returning to wait on socket", priv->sock); + return 0; + } + } else { + char *sock_type = (priv->is_server ? "Server" : "Client"); - pthread_mutex_lock (&priv->in_lock); - pthread_mutex_lock (&priv->out_lock); - { - priv->idx = idx; - priv->gen = gen; + gf_log(this->name, GF_LOG_TRACE, + "%s socket (%d) is already connected", sock_type, + priv->sock); + ret = 0; } - pthread_mutex_unlock (&priv->out_lock); - pthread_mutex_unlock (&priv->in_lock); - - gf_log (this->name, GF_LOG_TRACE, "%s (sock:%d) in:%d, out:%d, err:%d", - (priv->is_server ? "server" : "client"), - priv->sock, poll_in, poll_out, poll_err); - - if (!poll_err) { - if (!socket_is_connected (this)) { - gf_log (this->name, GF_LOG_TRACE, - "%s (sock:%d) socket is not connected, " - "completing connection", - (priv->is_server ? "server" : "client"), - priv->sock); - - ret = socket_complete_connection (this); - - gf_log (this->name, GF_LOG_TRACE, "(sock:%d) " - "socket_complete_connection() returned %d", - priv->sock, ret); - - if (ret > 0) { - gf_log (this->name, GF_LOG_TRACE, - "(sock:%d) returning to wait on socket", - priv->sock); - return 0; - } - } else { - char *sock_type = (priv->is_server ? "Server" : - "Client"); + } - gf_log (this->name, GF_LOG_TRACE, - "%s socket (%d) is already connected", - sock_type, priv->sock); - ret = 0; - } - } + if (!ret && poll_out) { + ret = socket_event_poll_out(this); + gf_log(this->name, GF_LOG_TRACE, + "(sock:%d) " + "socket_event_poll_out returned %d", + priv->sock, ret); + } - if (!ret && poll_out) { - ret = socket_event_poll_out (this); - gf_log (this->name, GF_LOG_TRACE, "(sock:%d) " - "socket_event_poll_out returned %d", priv->sock, ret); - } + if (!ret && poll_in) { + ret = socket_event_poll_in(this, !poll_err); + gf_log(this->name, GF_LOG_TRACE, + "(sock:%d) " + "socket_event_poll_in returned %d", + priv->sock, ret); + notify_handled = _gf_true; + } - if (!ret && poll_in) { - ret = socket_event_poll_in (this, !poll_err); - gf_log (this->name, GF_LOG_TRACE, "(sock:%d) " - "socket_event_poll_in returned %d", priv->sock, ret); - notify_handled = _gf_true; - } + if ((ret < 0) || poll_err) { + struct sockaddr *sa = SA(&this->peerinfo.sockaddr); - if ((ret < 0) || poll_err) { - struct sockaddr *sa = SA(&this->peerinfo.sockaddr); + if (priv->is_server && + SA(&this->myinfo.sockaddr)->sa_family == AF_UNIX) { + sa = SA(&this->myinfo.sockaddr); + } - if (priv->is_server && - SA(&this->myinfo.sockaddr)->sa_family == AF_UNIX) { - sa = SA(&this->myinfo.sockaddr); - } + socket_dump_info(sa, priv->is_server, priv->use_ssl, priv->sock, + this->name, "disconnecting from"); - socket_dump_info (sa, priv->is_server, priv->use_ssl, - priv->sock, this->name, - "disconnecting from"); + /* Logging has happened already in earlier cases */ + gf_log("transport", ((ret >= 0) ? GF_LOG_INFO : GF_LOG_DEBUG), + "EPOLLERR - disconnecting (sock:%d) (%s)", priv->sock, + (priv->use_ssl ? "SSL" : "non-SSL")); - /* Logging has happened already in earlier cases */ - gf_log ("transport", ((ret >= 0) ? GF_LOG_INFO : GF_LOG_DEBUG), - "EPOLLERR - disconnecting (sock:%d) (%s)", - priv->sock, (priv->use_ssl ? "SSL" : "non-SSL")); + socket_closed = socket_event_poll_err(this, gen, idx); - socket_closed = socket_event_poll_err (this, gen, idx); + if (socket_closed) + rpc_transport_unref(this); - if (socket_closed) - rpc_transport_unref (this); - - } else if (!notify_handled) { - event_handled (ctx->event_pool, fd, idx, gen); - } + } else if (!notify_handled) { + event_handled(ctx->event_pool, fd, idx, gen); + } out: - return ret; + return ret; } static int -socket_server_event_handler (int fd, int idx, int gen, void *data, - int poll_in, int poll_out, int poll_err) +socket_server_event_handler(int fd, int idx, int gen, void *data, int poll_in, + int poll_out, int poll_err) { - rpc_transport_t *this = NULL; - socket_private_t *priv = NULL; - int ret = 0; - int new_sock = -1; - rpc_transport_t *new_trans = NULL; - struct sockaddr_storage new_sockaddr = {0, }; - socklen_t addrlen = sizeof (new_sockaddr); - socket_private_t *new_priv = NULL; - glusterfs_ctx_t *ctx = NULL; - - this = data; - GF_VALIDATE_OR_GOTO ("socket", this, out); - GF_VALIDATE_OR_GOTO ("socket", this->private, out); - GF_VALIDATE_OR_GOTO ("socket", this->xl, out); - - THIS = this->xl; - priv = this->private; - ctx = this->ctx; - - /* NOTE: - * We have done away with the critical section in this function. since - * there's little that it helps with. There's no other code that - * attempts to unref the listener socket/transport from any other - * thread context while we are using it here. - */ - priv->idx = idx; - - if (poll_in) { - new_sock = accept (priv->sock, SA (&new_sockaddr), &addrlen); - - if (ctx) - event_handled (ctx->event_pool, fd, idx, gen); - - if (new_sock == -1) { - gf_log (this->name, GF_LOG_WARNING, - "accept on %d failed (%s)", - priv->sock, strerror (errno)); - goto out; - } - - if (priv->nodelay && (new_sockaddr.ss_family != AF_UNIX)) { - ret = __socket_nodelay (new_sock); - if (ret == -1) { - gf_log (this->name, GF_LOG_WARNING, - "setsockopt() failed for " - "NODELAY (%s)", - strerror (errno)); - } - } - - if (priv->keepalive && - new_sockaddr.ss_family != AF_UNIX) { - ret = __socket_keepalive (new_sock, - new_sockaddr.ss_family, - priv->keepaliveintvl, - priv->keepaliveidle, - priv->keepalivecnt, - priv->timeout); - if (ret == -1) - gf_log (this->name, GF_LOG_WARNING, - "Failed to set keep-alive: %s", - strerror (errno)); - } - - new_trans = GF_CALLOC (1, sizeof (*new_trans), - gf_common_mt_rpc_trans_t); - if (!new_trans) { - sys_close (new_sock); - goto out; - } - - ret = pthread_mutex_init(&new_trans->lock, NULL); - if (ret == -1) { - gf_log (this->name, GF_LOG_WARNING, - "pthread_mutex_init() failed: %s", - strerror (errno)); - sys_close (new_sock); - GF_FREE (new_trans); - goto out; - } - INIT_LIST_HEAD (&new_trans->list); - - new_trans->name = gf_strdup (this->name); - - memcpy (&new_trans->peerinfo.sockaddr, &new_sockaddr, addrlen); - new_trans->peerinfo.sockaddr_len = addrlen; - - new_trans->myinfo.sockaddr_len = sizeof (new_trans->myinfo.sockaddr); - - ret = getsockname (new_sock, SA (&new_trans->myinfo.sockaddr), - &new_trans->myinfo.sockaddr_len); - if (ret == -1) { - gf_log (this->name, GF_LOG_WARNING, - "getsockname on %d failed (%s)", - new_sock, strerror (errno)); - sys_close (new_sock); - GF_FREE (new_trans->name); - GF_FREE (new_trans); - goto out; - } + rpc_transport_t *this = NULL; + socket_private_t *priv = NULL; + int ret = 0; + int new_sock = -1; + rpc_transport_t *new_trans = NULL; + struct sockaddr_storage new_sockaddr = { + 0, + }; + socklen_t addrlen = sizeof(new_sockaddr); + socket_private_t *new_priv = NULL; + glusterfs_ctx_t *ctx = NULL; + + this = data; + GF_VALIDATE_OR_GOTO("socket", this, out); + GF_VALIDATE_OR_GOTO("socket", this->private, out); + GF_VALIDATE_OR_GOTO("socket", this->xl, out); + + THIS = this->xl; + priv = this->private; + ctx = this->ctx; + + /* NOTE: + * We have done away with the critical section in this function. since + * there's little that it helps with. There's no other code that + * attempts to unref the listener socket/transport from any other + * thread context while we are using it here. + */ + priv->idx = idx; + + if (poll_in) { + new_sock = accept(priv->sock, SA(&new_sockaddr), &addrlen); + + if (ctx) + event_handled(ctx->event_pool, fd, idx, gen); + + if (new_sock == -1) { + gf_log(this->name, GF_LOG_WARNING, "accept on %d failed (%s)", + priv->sock, strerror(errno)); + goto out; + } + + if (priv->nodelay && (new_sockaddr.ss_family != AF_UNIX)) { + ret = __socket_nodelay(new_sock); + if (ret == -1) { + gf_log(this->name, GF_LOG_WARNING, + "setsockopt() failed for " + "NODELAY (%s)", + strerror(errno)); + } + } + + if (priv->keepalive && new_sockaddr.ss_family != AF_UNIX) { + ret = __socket_keepalive(new_sock, new_sockaddr.ss_family, + priv->keepaliveintvl, priv->keepaliveidle, + priv->keepalivecnt, priv->timeout); + if (ret == -1) + gf_log(this->name, GF_LOG_WARNING, + "Failed to set keep-alive: %s", strerror(errno)); + } + + new_trans = GF_CALLOC(1, sizeof(*new_trans), gf_common_mt_rpc_trans_t); + if (!new_trans) { + sys_close(new_sock); + goto out; + } + + ret = pthread_mutex_init(&new_trans->lock, NULL); + if (ret == -1) { + gf_log(this->name, GF_LOG_WARNING, + "pthread_mutex_init() failed: %s", strerror(errno)); + sys_close(new_sock); + GF_FREE(new_trans); + goto out; + } + INIT_LIST_HEAD(&new_trans->list); - get_transport_identifiers (new_trans); - gf_log (this->name, GF_LOG_TRACE, "XXX server:%s, client:%s", - new_trans->myinfo.identifier, - new_trans->peerinfo.identifier); + new_trans->name = gf_strdup(this->name); - ret = socket_init(new_trans); - if (ret != 0) { - sys_close (new_sock); - GF_FREE (new_trans->name); - GF_FREE (new_trans); - goto out; - } - new_trans->ops = this->ops; - new_trans->init = this->init; - new_trans->fini = this->fini; - new_trans->ctx = ctx; - new_trans->xl = this->xl; - new_trans->mydata = this->mydata; - new_trans->notify = this->notify; - new_trans->listener = this; - new_priv = new_trans->private; - - if (new_sockaddr.ss_family == AF_UNIX) { - new_priv->use_ssl = _gf_false; - } else { - switch (priv->srvr_ssl) { - case MGMT_SSL_ALWAYS: - /* Glusterd with secure_mgmt. */ - new_priv->use_ssl = _gf_true; - break; - case MGMT_SSL_COPY_IO: - /* Glusterfsd. */ - new_priv->use_ssl = priv->ssl_enabled; - break; - default: - new_priv->use_ssl = _gf_false; - } - } + memcpy(&new_trans->peerinfo.sockaddr, &new_sockaddr, addrlen); + new_trans->peerinfo.sockaddr_len = addrlen; - new_priv->sock = new_sock; + new_trans->myinfo.sockaddr_len = sizeof(new_trans->myinfo.sockaddr); - new_priv->ssl_enabled = priv->ssl_enabled; - new_priv->ssl_ctx = priv->ssl_ctx; - new_priv->connected = 1; - new_priv->is_server = _gf_true; - - /* set O_NONBLOCK for plain text as well as ssl connections */ - if (!priv->bio) { - gf_log (this->name, GF_LOG_TRACE, - "### use non-blocking IO"); - ret = __socket_nonblock (new_sock); + ret = getsockname(new_sock, SA(&new_trans->myinfo.sockaddr), + &new_trans->myinfo.sockaddr_len); + if (ret == -1) { + gf_log(this->name, GF_LOG_WARNING, "getsockname on %d failed (%s)", + new_sock, strerror(errno)); + sys_close(new_sock); + GF_FREE(new_trans->name); + GF_FREE(new_trans); + goto out; + } + + get_transport_identifiers(new_trans); + gf_log(this->name, GF_LOG_TRACE, "XXX server:%s, client:%s", + new_trans->myinfo.identifier, new_trans->peerinfo.identifier); + + ret = socket_init(new_trans); + if (ret != 0) { + sys_close(new_sock); + GF_FREE(new_trans->name); + GF_FREE(new_trans); + goto out; + } + new_trans->ops = this->ops; + new_trans->init = this->init; + new_trans->fini = this->fini; + new_trans->ctx = ctx; + new_trans->xl = this->xl; + new_trans->mydata = this->mydata; + new_trans->notify = this->notify; + new_trans->listener = this; + new_priv = new_trans->private; + + if (new_sockaddr.ss_family == AF_UNIX) { + new_priv->use_ssl = _gf_false; + } else { + switch (priv->srvr_ssl) { + case MGMT_SSL_ALWAYS: + /* Glusterd with secure_mgmt. */ + new_priv->use_ssl = _gf_true; + break; + case MGMT_SSL_COPY_IO: + /* Glusterfsd. */ + new_priv->use_ssl = priv->ssl_enabled; + break; + default: + new_priv->use_ssl = _gf_false; + } + } + + new_priv->sock = new_sock; + + new_priv->ssl_enabled = priv->ssl_enabled; + new_priv->ssl_ctx = priv->ssl_ctx; + new_priv->connected = 1; + new_priv->is_server = _gf_true; + + /* set O_NONBLOCK for plain text as well as ssl connections */ + if (!priv->bio) { + gf_log(this->name, GF_LOG_TRACE, "### use non-blocking IO"); + ret = __socket_nonblock(new_sock); - if (ret == -1) { - gf_log (this->name, GF_LOG_WARNING, - "NBIO on %d failed (%s)", - new_sock, strerror (errno)); + if (ret == -1) { + gf_log(this->name, GF_LOG_WARNING, "NBIO on %d failed (%s)", + new_sock, strerror(errno)); - sys_close (new_sock); - GF_FREE (new_trans->name); - GF_FREE (new_trans); - goto out; - } - } - /* - * This is the first ref on the newly accepted - * transport. - */ - rpc_transport_ref (new_trans); - - { - /* Take a ref on the new_trans to avoid - * getting deleted when event_register() - * causes socket_event_handler() to race - * ahead of this path to eventually find - * a disconnect and unref the transport - */ - rpc_transport_ref (new_trans); - - /* Send a notification to RPCSVC layer - * to save the new_trans in its service - * list before we register the new_sock - * with epoll to begin receiving notifications - * for data handling. - */ - ret = rpc_transport_notify (this, RPC_TRANSPORT_ACCEPT, new_trans); - - if (ret != -1) { - new_priv->idx = - event_register (ctx->event_pool, - new_sock, - socket_event_handler, - new_trans, - 1, 0); - if (new_priv->idx == -1) { - ret = -1; - gf_log(this->name, GF_LOG_ERROR, - "failed to register the socket " - "with event"); - - /* event_register() could have failed for some - * reason, implying that the new_sock cannot be - * added to the epoll set. If we won't get any - * more notifications for new_sock from epoll, - * then we better remove the corresponding - * new_trans object from the RPCSVC service list. - * Since we've notified RPC service of new_trans - * before we attempted event_register(), we better - * unlink the new_trans from the RPCSVC service list - * to cleanup the stateby sending out a DISCONNECT - * notification. - */ - rpc_transport_notify (this, RPC_TRANSPORT_DISCONNECT, new_trans); - } - } + sys_close(new_sock); + GF_FREE(new_trans->name); + GF_FREE(new_trans); + goto out; + } + } + /* + * This is the first ref on the newly accepted + * transport. + */ + rpc_transport_ref(new_trans); - /* this rpc_transport_unref() is for managing race between - * 1. socket_server_event_handler and - * 2. socket_event_handler - * trying to add and remove new_trans from the rpcsvc - * service list - * now that we are done with the notifications, lets - * reduce the reference - */ - rpc_transport_unref (new_trans); - } + { + /* Take a ref on the new_trans to avoid + * getting deleted when event_register() + * causes socket_event_handler() to race + * ahead of this path to eventually find + * a disconnect and unref the transport + */ + rpc_transport_ref(new_trans); + + /* Send a notification to RPCSVC layer + * to save the new_trans in its service + * list before we register the new_sock + * with epoll to begin receiving notifications + * for data handling. + */ + ret = rpc_transport_notify(this, RPC_TRANSPORT_ACCEPT, new_trans); + + if (ret != -1) { + new_priv->idx = event_register(ctx->event_pool, new_sock, + socket_event_handler, new_trans, + 1, 0); + if (new_priv->idx == -1) { + ret = -1; + gf_log(this->name, GF_LOG_ERROR, + "failed to register the socket " + "with event"); + + /* event_register() could have failed for some + * reason, implying that the new_sock cannot be + * added to the epoll set. If we won't get any + * more notifications for new_sock from epoll, + * then we better remove the corresponding + * new_trans object from the RPCSVC service list. + * Since we've notified RPC service of new_trans + * before we attempted event_register(), we better + * unlink the new_trans from the RPCSVC service list + * to cleanup the stateby sending out a DISCONNECT + * notification. + */ + rpc_transport_notify(this, RPC_TRANSPORT_DISCONNECT, + new_trans); + } + } + + /* this rpc_transport_unref() is for managing race between + * 1. socket_server_event_handler and + * 2. socket_event_handler + * trying to add and remove new_trans from the rpcsvc + * service list + * now that we are done with the notifications, lets + * reduce the reference + */ + rpc_transport_unref(new_trans); + } - if (ret == -1) { - sys_close (new_sock); - /* this unref is to actually cause the destruction of - * the new_trans since we've failed at everything so far - */ - rpc_transport_unref (new_trans); - } + if (ret == -1) { + sys_close(new_sock); + /* this unref is to actually cause the destruction of + * the new_trans since we've failed at everything so far + */ + rpc_transport_unref(new_trans); } + } out: - return ret; + return ret; } - static int -socket_disconnect (rpc_transport_t *this, gf_boolean_t wait) +socket_disconnect(rpc_transport_t *this, gf_boolean_t wait) { - socket_private_t *priv = NULL; - int ret = -1; + socket_private_t *priv = NULL; + int ret = -1; - GF_VALIDATE_OR_GOTO ("socket", this, out); - GF_VALIDATE_OR_GOTO ("socket", this->private, out); + GF_VALIDATE_OR_GOTO("socket", this, out); + GF_VALIDATE_OR_GOTO("socket", this->private, out); - priv = this->private; + priv = this->private; - pthread_mutex_lock (&priv->in_lock); - pthread_mutex_lock (&priv->out_lock); - { - ret = __socket_disconnect (this); - } - pthread_mutex_unlock (&priv->out_lock); - pthread_mutex_unlock (&priv->in_lock); + pthread_mutex_lock(&priv->in_lock); + pthread_mutex_lock(&priv->out_lock); + { + ret = __socket_disconnect(this); + } + pthread_mutex_unlock(&priv->out_lock); + pthread_mutex_unlock(&priv->in_lock); out: - return ret; + return ret; } -void* -socket_connect_error_cbk (void *opaque) +void * +socket_connect_error_cbk(void *opaque) { - socket_connect_error_state_t *arg; + socket_connect_error_state_t *arg; - GF_ASSERT (opaque); + GF_ASSERT(opaque); - arg = opaque; - THIS = arg->this; + arg = opaque; + THIS = arg->this; - rpc_transport_notify (arg->trans, RPC_TRANSPORT_DISCONNECT, arg->trans); + rpc_transport_notify(arg->trans, RPC_TRANSPORT_DISCONNECT, arg->trans); - if (arg->refd) - rpc_transport_unref (arg->trans); + if (arg->refd) + rpc_transport_unref(arg->trans); - GF_FREE (opaque); - return NULL; + GF_FREE(opaque); + return NULL; } static void -socket_fix_ssl_opts (rpc_transport_t *this, socket_private_t *priv, - uint16_t port) +socket_fix_ssl_opts(rpc_transport_t *this, socket_private_t *priv, + uint16_t port) { - if (port == GF_DEFAULT_SOCKET_LISTEN_PORT) { - gf_log (this->name, GF_LOG_DEBUG, - "%s SSL for portmapper connection", - priv->mgmt_ssl ? "enabling" : "disabling"); - priv->use_ssl = priv->mgmt_ssl; - } else if (priv->ssl_enabled && !priv->use_ssl) { - gf_log(this->name, GF_LOG_DEBUG, - "re-enabling SSL for I/O connection"); - priv->use_ssl = _gf_true; - } + if (port == GF_DEFAULT_SOCKET_LISTEN_PORT) { + gf_log(this->name, GF_LOG_DEBUG, "%s SSL for portmapper connection", + priv->mgmt_ssl ? "enabling" : "disabling"); + priv->use_ssl = priv->mgmt_ssl; + } else if (priv->ssl_enabled && !priv->use_ssl) { + gf_log(this->name, GF_LOG_DEBUG, "re-enabling SSL for I/O connection"); + priv->use_ssl = _gf_true; + } } /* @@ -3343,1009 +3234,968 @@ socket_fix_ssl_opts (rpc_transport_t *this, socket_private_t *priv, * as well. */ static int -connect_loop (int sockfd, const struct sockaddr *addr, socklen_t addrlen) +connect_loop(int sockfd, const struct sockaddr *addr, socklen_t addrlen) { - int ret; - int connect_fails = 0; + int ret; + int connect_fails = 0; - for (;;) { - ret = connect (sockfd, addr, addrlen); - if (ret >= 0) { - break; - } - if ((errno != ENOENT) || (++connect_fails >= 5)) { - break; - } - sleep (1); + for (;;) { + ret = connect(sockfd, addr, addrlen); + if (ret >= 0) { + break; + } + if ((errno != ENOENT) || (++connect_fails >= 5)) { + break; } + sleep(1); + } - return ret; + return ret; } static int -socket_connect (rpc_transport_t *this, int port) +socket_connect(rpc_transport_t *this, int port) { - int ret = -1; - int th_ret = -1; - int sock = -1; - socket_private_t *priv = NULL; - socklen_t sockaddr_len = 0; - glusterfs_ctx_t *ctx = NULL; - sa_family_t sa_family = {0, }; - char *local_addr = NULL; - union gf_sock_union sock_union; - struct sockaddr_in *addr = NULL; - gf_boolean_t refd = _gf_false; - socket_connect_error_state_t *arg = NULL; - pthread_t th_id = {0, }; - gf_boolean_t ign_enoent = _gf_false; - gf_boolean_t connect_attempted = _gf_false; - - GF_VALIDATE_OR_GOTO ("socket", this, err); - GF_VALIDATE_OR_GOTO ("socket", this->private, err); - - priv = this->private; - ctx = this->ctx; - - if (!priv) { - gf_log_callingfn (this->name, GF_LOG_WARNING, - "connect() called on uninitialized transport"); - goto err; + int ret = -1; + int th_ret = -1; + int sock = -1; + socket_private_t *priv = NULL; + socklen_t sockaddr_len = 0; + glusterfs_ctx_t *ctx = NULL; + sa_family_t sa_family = { + 0, + }; + char *local_addr = NULL; + union gf_sock_union sock_union; + struct sockaddr_in *addr = NULL; + gf_boolean_t refd = _gf_false; + socket_connect_error_state_t *arg = NULL; + pthread_t th_id = { + 0, + }; + gf_boolean_t ign_enoent = _gf_false; + gf_boolean_t connect_attempted = _gf_false; + + GF_VALIDATE_OR_GOTO("socket", this, err); + GF_VALIDATE_OR_GOTO("socket", this->private, err); + + priv = this->private; + ctx = this->ctx; + + if (!priv) { + gf_log_callingfn(this->name, GF_LOG_WARNING, + "connect() called on uninitialized transport"); + goto err; + } + + pthread_mutex_lock(&priv->in_lock); + pthread_mutex_lock(&priv->out_lock); + { + if (priv->sock != -1) { + gf_log_callingfn(this->name, GF_LOG_TRACE, + "connect () called on transport " + "already connected"); + errno = EINPROGRESS; + ret = -1; + goto unlock; } - pthread_mutex_lock (&priv->in_lock); - pthread_mutex_lock (&priv->out_lock); - { - if (priv->sock != -1) { - gf_log_callingfn (this->name, GF_LOG_TRACE, - "connect () called on transport " - "already connected"); - errno = EINPROGRESS; - ret = -1; - goto unlock; - } - - gf_log (this->name, GF_LOG_TRACE, - "connecting %p, sock=%d", this, priv->sock); - - ret = socket_client_get_remote_sockaddr (this, &sock_union.sa, - &sockaddr_len, &sa_family); - if (ret == -1) { - /* logged inside client_get_remote_sockaddr */ - goto unlock; - } - - if (sa_family == AF_UNIX) { - priv->ssl_enabled = _gf_false; - priv->mgmt_ssl = _gf_false; - } else { - if (port > 0) { - sock_union.sin.sin_port = htons (port); - } - socket_fix_ssl_opts (this, priv, - ntohs(sock_union.sin.sin_port)); - } + gf_log(this->name, GF_LOG_TRACE, "connecting %p, sock=%d", this, + priv->sock); - memcpy (&this->peerinfo.sockaddr, &sock_union.storage, - sockaddr_len); - this->peerinfo.sockaddr_len = sockaddr_len; + ret = socket_client_get_remote_sockaddr(this, &sock_union.sa, + &sockaddr_len, &sa_family); + if (ret == -1) { + /* logged inside client_get_remote_sockaddr */ + goto unlock; + } - priv->sock = socket (sa_family, SOCK_STREAM, 0); - if (priv->sock == -1) { - gf_log (this->name, GF_LOG_ERROR, - "socket creation failed (%s)", - strerror (errno)); - ret = -1; - goto unlock; - } + if (sa_family == AF_UNIX) { + priv->ssl_enabled = _gf_false; + priv->mgmt_ssl = _gf_false; + } else { + if (port > 0) { + sock_union.sin.sin_port = htons(port); + } + socket_fix_ssl_opts(this, priv, ntohs(sock_union.sin.sin_port)); + } - /* Can't help if setting socket options fails. We can continue - * working nonetheless. - */ - if (priv->windowsize != 0) { - if (setsockopt (priv->sock, SOL_SOCKET, SO_RCVBUF, - &priv->windowsize, - sizeof (priv->windowsize)) < 0) { - gf_log (this->name, GF_LOG_ERROR, - "setting receive window " - "size failed: %d: %d: %s", - priv->sock, priv->windowsize, - strerror (errno)); - } + memcpy(&this->peerinfo.sockaddr, &sock_union.storage, sockaddr_len); + this->peerinfo.sockaddr_len = sockaddr_len; - if (setsockopt (priv->sock, SOL_SOCKET, SO_SNDBUF, - &priv->windowsize, - sizeof (priv->windowsize)) < 0) { - gf_log (this->name, GF_LOG_ERROR, - "setting send window size " - "failed: %d: %d: %s", - priv->sock, priv->windowsize, - strerror (errno)); - } - } + priv->sock = socket(sa_family, SOCK_STREAM, 0); + if (priv->sock == -1) { + gf_log(this->name, GF_LOG_ERROR, "socket creation failed (%s)", + strerror(errno)); + ret = -1; + goto unlock; + } - /* Make sure we are not vulnerable to someone setting - * net.ipv6.bindv6only to 1 so that gluster services are - * available over IPv4 & IPv6. - */ + /* Can't help if setting socket options fails. We can continue + * working nonetheless. + */ + if (priv->windowsize != 0) { + if (setsockopt(priv->sock, SOL_SOCKET, SO_RCVBUF, &priv->windowsize, + sizeof(priv->windowsize)) < 0) { + gf_log(this->name, GF_LOG_ERROR, + "setting receive window " + "size failed: %d: %d: %s", + priv->sock, priv->windowsize, strerror(errno)); + } + + if (setsockopt(priv->sock, SOL_SOCKET, SO_SNDBUF, &priv->windowsize, + sizeof(priv->windowsize)) < 0) { + gf_log(this->name, GF_LOG_ERROR, + "setting send window size " + "failed: %d: %d: %s", + priv->sock, priv->windowsize, strerror(errno)); + } + } + + /* Make sure we are not vulnerable to someone setting + * net.ipv6.bindv6only to 1 so that gluster services are + * available over IPv4 & IPv6. + */ #ifdef IPV6_DEFAULT - int disable_v6only = 0; - if (setsockopt (priv->sock, IPPROTO_IPV6, IPV6_V6ONLY, - (void *)&disable_v6only, - sizeof (disable_v6only)) < 0) { - gf_log (this->name, GF_LOG_WARNING, - "Error disabling sockopt IPV6_V6ONLY: \"%s\"", - strerror (errno)); - } + int disable_v6only = 0; + if (setsockopt(priv->sock, IPPROTO_IPV6, IPV6_V6ONLY, + (void *)&disable_v6only, sizeof(disable_v6only)) < 0) { + gf_log(this->name, GF_LOG_WARNING, + "Error disabling sockopt IPV6_V6ONLY: \"%s\"", + strerror(errno)); + } #endif - if (priv->nodelay && (sa_family != AF_UNIX)) { - ret = __socket_nodelay (priv->sock); + if (priv->nodelay && (sa_family != AF_UNIX)) { + ret = __socket_nodelay(priv->sock); - if (ret == -1) { - gf_log (this->name, GF_LOG_ERROR, - "NODELAY on %d failed (%s)", - priv->sock, strerror (errno)); - } - } - - if (priv->keepalive && sa_family != AF_UNIX) { - ret = __socket_keepalive (priv->sock, - sa_family, - priv->keepaliveintvl, - priv->keepaliveidle, - priv->keepalivecnt, - priv->timeout); - if (ret == -1) - gf_log (this->name, GF_LOG_ERROR, - "Failed to set keep-alive: %s", - strerror (errno)); - } - - SA (&this->myinfo.sockaddr)->sa_family = - SA (&this->peerinfo.sockaddr)->sa_family; - - /* If a source addr is explicitly specified, use it */ - ret = dict_get_str (this->options, - "transport.socket.source-addr", - &local_addr); - if (!ret && SA (&this->myinfo.sockaddr)->sa_family == AF_INET) { - addr = (struct sockaddr_in *)(&this->myinfo.sockaddr); - ret = inet_pton (AF_INET, local_addr, - &(addr->sin_addr.s_addr)); - } - - /* If client wants ENOENT to be ignored */ - ign_enoent = dict_get_str_boolean (this->options, - "transport.socket.ignore-enoent", - _gf_false); - - ret = client_bind (this, SA (&this->myinfo.sockaddr), - &this->myinfo.sockaddr_len, priv->sock); - if (ret == -1) { - gf_log (this->name, GF_LOG_WARNING, - "client bind failed: %s", strerror (errno)); - goto handler; - } - - /* make socket non-blocking for all types of sockets */ - if (!priv->bio) { - ret = __socket_nonblock (priv->sock); - if (ret == -1) { - gf_log (this->name, GF_LOG_ERROR, - "NBIO on %d failed (%s)", - priv->sock, strerror (errno)); - goto handler; - } else { - gf_log (this->name, GF_LOG_TRACE, - ">>> connect() with non-blocking IO for ALL"); - } - } - this->connect_failed = _gf_false; - priv->connect_failed = 0; - priv->connected = 0; - - socket_dump_info (SA(&this->peerinfo.sockaddr), priv->is_server, - priv->use_ssl, priv->sock, this->name, - "connecting to"); - - if (ign_enoent) { - ret = connect_loop (priv->sock, - SA (&this->peerinfo.sockaddr), - this->peerinfo.sockaddr_len); - } else { - ret = connect (priv->sock, - SA (&this->peerinfo.sockaddr), - this->peerinfo.sockaddr_len); - } - - connect_attempted = _gf_true; - - if (ret == -1 && errno == ENOENT && ign_enoent) { - gf_log (this->name, GF_LOG_WARNING, - "Ignore failed connection attempt on %s, (%s) ", - this->peerinfo.identifier, strerror (errno)); + if (ret == -1) { + gf_log(this->name, GF_LOG_ERROR, "NODELAY on %d failed (%s)", + priv->sock, strerror(errno)); + } + } - /* connect failed with some other error than EINPROGRESS - so, getsockopt (... SO_ERROR ...), will not catch any - errors and return them to us, we need to remember this - state, and take actions in socket_event_handler - appropriately */ - /* TBD: What about ENOENT, we will do getsockopt there - as well, so how is that exempt from such a problem? */ - priv->connect_failed = 1; - this->connect_failed = _gf_true; + if (priv->keepalive && sa_family != AF_UNIX) { + ret = __socket_keepalive(priv->sock, sa_family, + priv->keepaliveintvl, priv->keepaliveidle, + priv->keepalivecnt, priv->timeout); + if (ret == -1) + gf_log(this->name, GF_LOG_ERROR, "Failed to set keep-alive: %s", + strerror(errno)); + } - goto handler; - } + SA(&this->myinfo.sockaddr)->sa_family = SA(&this->peerinfo.sockaddr) + ->sa_family; - if (ret == -1 && ((errno != EINPROGRESS) && (errno != ENOENT))) { - /* For unix path based sockets, the socket path is - * cryptic (md5sum of path) and may not be useful for - * the user in debugging so log it in DEBUG - */ - gf_log (this->name, ((sa_family == AF_UNIX) ? - GF_LOG_DEBUG : GF_LOG_ERROR), - "connection attempt on %s failed, (%s)", - this->peerinfo.identifier, strerror (errno)); - - /* connect failed with some other error than EINPROGRESS - so, getsockopt (... SO_ERROR ...), will not catch any - errors and return them to us, we need to remember this - state, and take actions in socket_event_handler - appropriately */ - /* TBD: What about ENOENT, we will do getsockopt there - as well, so how is that exempt from such a problem? */ - priv->connect_failed = 1; - - goto handler; - } else { - /* reset connect_failed so that any previous attempts - state is not carried forward */ - priv->connect_failed = 0; - ret = 0; - } + /* If a source addr is explicitly specified, use it */ + ret = dict_get_str(this->options, "transport.socket.source-addr", + &local_addr); + if (!ret && SA(&this->myinfo.sockaddr)->sa_family == AF_INET) { + addr = (struct sockaddr_in *)(&this->myinfo.sockaddr); + ret = inet_pton(AF_INET, local_addr, &(addr->sin_addr.s_addr)); + } -handler: - if (ret < 0 && !connect_attempted) { - /* Ignore error from connect. epoll events - should be handled in the socket handler. shutdown(2) - will result in EPOLLERR, so cleanup is done in - socket_event_handler or socket_poller */ - shutdown (priv->sock, SHUT_RDWR); - gf_log (this->name, GF_LOG_TRACE, - "@@@ client shutdown(%d, SHUT_RDWR)", - priv->sock); - } + /* If client wants ENOENT to be ignored */ + ign_enoent = dict_get_str_boolean( + this->options, "transport.socket.ignore-enoent", _gf_false); - priv->connected = 0; - priv->is_server = _gf_false; - rpc_transport_ref (this); - refd = _gf_true; - - this->listener = this; - priv->idx = event_register (ctx->event_pool, priv->sock, - socket_event_handler, - this, 1, 1); - if (priv->idx == -1) { - gf_log ("", GF_LOG_WARNING, - "failed to register the event"); - sys_close (priv->sock); - priv->sock = -1; - ret = -1; - } - -unlock: - sock = priv->sock; + ret = client_bind(this, SA(&this->myinfo.sockaddr), + &this->myinfo.sockaddr_len, priv->sock); + if (ret == -1) { + gf_log(this->name, GF_LOG_WARNING, "client bind failed: %s", + strerror(errno)); + goto handler; } - pthread_mutex_unlock (&priv->out_lock); - pthread_mutex_unlock (&priv->in_lock); -err: - /* if sock != -1, then cleanup is done from the event handler */ - if (ret == -1 && sock == -1) { - /* Cleaup requires to send notification to upper layer which - intern holds the big_lock. There can be dead-lock situation - if big_lock is already held by the current thread. - So transfer the ownership to separate thread for cleanup. - */ - arg = GF_CALLOC (1, sizeof (*arg), - gf_sock_connect_error_state_t); - arg->this = THIS; - arg->trans = this; - arg->refd = refd; - th_ret = gf_thread_create_detached (&th_id, - socket_connect_error_cbk, - arg, "scleanup"); - if (th_ret) { - /* Error will be logged by gf_thread_create_attached */ - gf_log (this->name, GF_LOG_ERROR, "Thread creation " - "failed"); - GF_FREE (arg); - GF_ASSERT (0); - } - } + /* make socket non-blocking for all types of sockets */ + if (!priv->bio) { + ret = __socket_nonblock(priv->sock); + if (ret == -1) { + gf_log(this->name, GF_LOG_ERROR, "NBIO on %d failed (%s)", + priv->sock, strerror(errno)); + goto handler; + } else { + gf_log(this->name, GF_LOG_TRACE, + ">>> connect() with non-blocking IO for ALL"); + } + } + this->connect_failed = _gf_false; + priv->connect_failed = 0; + priv->connected = 0; + + socket_dump_info(SA(&this->peerinfo.sockaddr), priv->is_server, + priv->use_ssl, priv->sock, this->name, + "connecting to"); + + if (ign_enoent) { + ret = connect_loop(priv->sock, SA(&this->peerinfo.sockaddr), + this->peerinfo.sockaddr_len); + } else { + ret = connect(priv->sock, SA(&this->peerinfo.sockaddr), + this->peerinfo.sockaddr_len); + } + + connect_attempted = _gf_true; + + if (ret == -1 && errno == ENOENT && ign_enoent) { + gf_log(this->name, GF_LOG_WARNING, + "Ignore failed connection attempt on %s, (%s) ", + this->peerinfo.identifier, strerror(errno)); + + /* connect failed with some other error than EINPROGRESS + so, getsockopt (... SO_ERROR ...), will not catch any + errors and return them to us, we need to remember this + state, and take actions in socket_event_handler + appropriately */ + /* TBD: What about ENOENT, we will do getsockopt there + as well, so how is that exempt from such a problem? */ + priv->connect_failed = 1; + this->connect_failed = _gf_true; + + goto handler; + } + + if (ret == -1 && ((errno != EINPROGRESS) && (errno != ENOENT))) { + /* For unix path based sockets, the socket path is + * cryptic (md5sum of path) and may not be useful for + * the user in debugging so log it in DEBUG + */ + gf_log(this->name, + ((sa_family == AF_UNIX) ? GF_LOG_DEBUG : GF_LOG_ERROR), + "connection attempt on %s failed, (%s)", + this->peerinfo.identifier, strerror(errno)); + + /* connect failed with some other error than EINPROGRESS + so, getsockopt (... SO_ERROR ...), will not catch any + errors and return them to us, we need to remember this + state, and take actions in socket_event_handler + appropriately */ + /* TBD: What about ENOENT, we will do getsockopt there + as well, so how is that exempt from such a problem? */ + priv->connect_failed = 1; + + goto handler; + } else { + /* reset connect_failed so that any previous attempts + state is not carried forward */ + priv->connect_failed = 0; + ret = 0; + } + + handler: + if (ret < 0 && !connect_attempted) { + /* Ignore error from connect. epoll events + should be handled in the socket handler. shutdown(2) + will result in EPOLLERR, so cleanup is done in + socket_event_handler or socket_poller */ + shutdown(priv->sock, SHUT_RDWR); + gf_log(this->name, GF_LOG_TRACE, + "@@@ client shutdown(%d, SHUT_RDWR)", priv->sock); + } + + priv->connected = 0; + priv->is_server = _gf_false; + rpc_transport_ref(this); + refd = _gf_true; + + this->listener = this; + priv->idx = event_register(ctx->event_pool, priv->sock, + socket_event_handler, this, 1, 1); + if (priv->idx == -1) { + gf_log("", GF_LOG_WARNING, "failed to register the event"); + sys_close(priv->sock); + priv->sock = -1; + ret = -1; + } + + unlock: + sock = priv->sock; + } + pthread_mutex_unlock(&priv->out_lock); + pthread_mutex_unlock(&priv->in_lock); - return ret; +err: + /* if sock != -1, then cleanup is done from the event handler */ + if (ret == -1 && sock == -1) { + /* Cleaup requires to send notification to upper layer which + intern holds the big_lock. There can be dead-lock situation + if big_lock is already held by the current thread. + So transfer the ownership to separate thread for cleanup. + */ + arg = GF_CALLOC(1, sizeof(*arg), gf_sock_connect_error_state_t); + arg->this = THIS; + arg->trans = this; + arg->refd = refd; + th_ret = gf_thread_create_detached(&th_id, socket_connect_error_cbk, + arg, "scleanup"); + if (th_ret) { + /* Error will be logged by gf_thread_create_attached */ + gf_log(this->name, GF_LOG_ERROR, + "Thread creation " + "failed"); + GF_FREE(arg); + GF_ASSERT(0); + } + } + + return ret; } - static int -socket_listen (rpc_transport_t *this) +socket_listen(rpc_transport_t *this) { - socket_private_t * priv = NULL; - int ret = -1; - int sock = -1; - struct sockaddr_storage sockaddr; - socklen_t sockaddr_len = 0; - peer_info_t *myinfo = NULL; - glusterfs_ctx_t *ctx = NULL; - sa_family_t sa_family = {0, }; - - GF_VALIDATE_OR_GOTO ("socket", this, out); - GF_VALIDATE_OR_GOTO ("socket", this->private, out); - - priv = this->private; - myinfo = &this->myinfo; - ctx = this->ctx; - - pthread_mutex_lock (&priv->in_lock); - pthread_mutex_lock (&priv->out_lock); - { - sock = priv->sock; - } - pthread_mutex_unlock (&priv->out_lock); - pthread_mutex_unlock (&priv->in_lock); - - if (sock != -1) { - gf_log_callingfn (this->name, GF_LOG_DEBUG, - "already listening"); - return ret; - } - - ret = socket_server_get_local_sockaddr (this, SA (&sockaddr), - &sockaddr_len, &sa_family); - if (ret == -1) { - return ret; - } + socket_private_t *priv = NULL; + int ret = -1; + int sock = -1; + struct sockaddr_storage sockaddr; + socklen_t sockaddr_len = 0; + peer_info_t *myinfo = NULL; + glusterfs_ctx_t *ctx = NULL; + sa_family_t sa_family = { + 0, + }; + + GF_VALIDATE_OR_GOTO("socket", this, out); + GF_VALIDATE_OR_GOTO("socket", this->private, out); + + priv = this->private; + myinfo = &this->myinfo; + ctx = this->ctx; + + pthread_mutex_lock(&priv->in_lock); + pthread_mutex_lock(&priv->out_lock); + { + sock = priv->sock; + } + pthread_mutex_unlock(&priv->out_lock); + pthread_mutex_unlock(&priv->in_lock); - pthread_mutex_lock (&priv->in_lock); - pthread_mutex_lock (&priv->out_lock); - { - if (priv->sock != -1) { - gf_log (this->name, GF_LOG_DEBUG, - "already listening"); - goto unlock; - } + if (sock != -1) { + gf_log_callingfn(this->name, GF_LOG_DEBUG, "already listening"); + return ret; + } - memcpy (&myinfo->sockaddr, &sockaddr, sockaddr_len); - myinfo->sockaddr_len = sockaddr_len; + ret = socket_server_get_local_sockaddr(this, SA(&sockaddr), &sockaddr_len, + &sa_family); + if (ret == -1) { + return ret; + } - priv->sock = socket (sa_family, SOCK_STREAM, 0); + pthread_mutex_lock(&priv->in_lock); + pthread_mutex_lock(&priv->out_lock); + { + if (priv->sock != -1) { + gf_log(this->name, GF_LOG_DEBUG, "already listening"); + goto unlock; + } - if (priv->sock == -1) { - gf_log (this->name, GF_LOG_ERROR, - "socket creation failed (%s)", - strerror (errno)); - goto unlock; - } + memcpy(&myinfo->sockaddr, &sockaddr, sockaddr_len); + myinfo->sockaddr_len = sockaddr_len; - /* Can't help if setting socket options fails. We can continue - * working nonetheless. - */ - if (priv->windowsize != 0) { - if (setsockopt (priv->sock, SOL_SOCKET, SO_RCVBUF, - &priv->windowsize, - sizeof (priv->windowsize)) < 0) { - gf_log (this->name, GF_LOG_ERROR, - "setting receive window size " - "failed: %d: %d: %s", priv->sock, - priv->windowsize, - strerror (errno)); - } + priv->sock = socket(sa_family, SOCK_STREAM, 0); - if (setsockopt (priv->sock, SOL_SOCKET, SO_SNDBUF, - &priv->windowsize, - sizeof (priv->windowsize)) < 0) { - gf_log (this->name, GF_LOG_ERROR, - "setting send window size failed:" - " %d: %d: %s", priv->sock, - priv->windowsize, - strerror (errno)); - } - } + if (priv->sock == -1) { + gf_log(this->name, GF_LOG_ERROR, "socket creation failed (%s)", + strerror(errno)); + goto unlock; + } - if (priv->nodelay && (sa_family != AF_UNIX)) { - ret = __socket_nodelay (priv->sock); - if (ret == -1) { - gf_log (this->name, GF_LOG_ERROR, - "setsockopt() failed for NODELAY (%s)", - strerror (errno)); - } - } + /* Can't help if setting socket options fails. We can continue + * working nonetheless. + */ + if (priv->windowsize != 0) { + if (setsockopt(priv->sock, SOL_SOCKET, SO_RCVBUF, &priv->windowsize, + sizeof(priv->windowsize)) < 0) { + gf_log(this->name, GF_LOG_ERROR, + "setting receive window size " + "failed: %d: %d: %s", + priv->sock, priv->windowsize, strerror(errno)); + } + + if (setsockopt(priv->sock, SOL_SOCKET, SO_SNDBUF, &priv->windowsize, + sizeof(priv->windowsize)) < 0) { + gf_log(this->name, GF_LOG_ERROR, + "setting send window size failed:" + " %d: %d: %s", + priv->sock, priv->windowsize, strerror(errno)); + } + } + + if (priv->nodelay && (sa_family != AF_UNIX)) { + ret = __socket_nodelay(priv->sock); + if (ret == -1) { + gf_log(this->name, GF_LOG_ERROR, + "setsockopt() failed for NODELAY (%s)", strerror(errno)); + } + } - if (!priv->bio) { - ret = __socket_nonblock (priv->sock); + if (!priv->bio) { + ret = __socket_nonblock(priv->sock); - if (ret == -1) { - gf_log (this->name, GF_LOG_ERROR, - "NBIO on %d failed (%s)", - priv->sock, strerror (errno)); - sys_close (priv->sock); - priv->sock = -1; - goto unlock; - } - } + if (ret == -1) { + gf_log(this->name, GF_LOG_ERROR, "NBIO on %d failed (%s)", + priv->sock, strerror(errno)); + sys_close(priv->sock); + priv->sock = -1; + goto unlock; + } + } - ret = __socket_server_bind (this); + ret = __socket_server_bind(this); - if ((ret == -EADDRINUSE) || (ret == -1)) { - /* logged inside __socket_server_bind() */ - sys_close (priv->sock); - priv->sock = -1; - goto unlock; - } + if ((ret == -EADDRINUSE) || (ret == -1)) { + /* logged inside __socket_server_bind() */ + sys_close(priv->sock); + priv->sock = -1; + goto unlock; + } - socket_dump_info (SA(&this->myinfo.sockaddr), priv->is_server, - priv->use_ssl, priv->sock, this->name, - "listening on"); + socket_dump_info(SA(&this->myinfo.sockaddr), priv->is_server, + priv->use_ssl, priv->sock, this->name, "listening on"); - ret = listen (priv->sock, priv->backlog); + ret = listen(priv->sock, priv->backlog); - if (ret == -1) { - gf_log (this->name, GF_LOG_ERROR, - "could not set socket %d to listen mode (%s)", - priv->sock, strerror (errno)); - sys_close (priv->sock); - priv->sock = -1; - goto unlock; - } + if (ret == -1) { + gf_log(this->name, GF_LOG_ERROR, + "could not set socket %d to listen mode (%s)", priv->sock, + strerror(errno)); + sys_close(priv->sock); + priv->sock = -1; + goto unlock; + } - rpc_transport_ref (this); + rpc_transport_ref(this); - priv->idx = event_register (ctx->event_pool, priv->sock, - socket_server_event_handler, - this, 1, 0); + priv->idx = event_register(ctx->event_pool, priv->sock, + socket_server_event_handler, this, 1, 0); - if (priv->idx == -1) { - gf_log (this->name, GF_LOG_WARNING, - "could not register socket %d with events", - priv->sock); - ret = -1; - sys_close (priv->sock); - priv->sock = -1; - goto unlock; - } + if (priv->idx == -1) { + gf_log(this->name, GF_LOG_WARNING, + "could not register socket %d with events", priv->sock); + ret = -1; + sys_close(priv->sock); + priv->sock = -1; + goto unlock; } + } unlock: - pthread_mutex_unlock (&priv->out_lock); - pthread_mutex_unlock (&priv->in_lock); + pthread_mutex_unlock(&priv->out_lock); + pthread_mutex_unlock(&priv->in_lock); out: - return ret; + return ret; } static int32_t -socket_submit_outgoing_msg (rpc_transport_t *this, rpc_transport_msg_t *msg) +socket_submit_outgoing_msg(rpc_transport_t *this, rpc_transport_msg_t *msg) { - int ret = -1; - char need_poll_out = 0; - char need_append = 1; - struct ioq *entry = NULL; - glusterfs_ctx_t *ctx = NULL; - socket_private_t *priv = NULL; - - GF_VALIDATE_OR_GOTO ("socket", this, out); - GF_VALIDATE_OR_GOTO ("socket", this->private, out); - - priv = this->private; - ctx = this->ctx; - - pthread_mutex_lock (&priv->out_lock); - { - if (priv->connected != 1) { - if (!priv->submit_log && !priv->connect_finish_log) { - gf_log (this->name, GF_LOG_INFO, - "not connected (priv->connected = %d)", - priv->connected); - priv->submit_log = 1; - } - goto unlock; - } - - priv->submit_log = 0; - entry = __socket_ioq_new (this, msg); - if (!entry) - goto unlock; + int ret = -1; + char need_poll_out = 0; + char need_append = 1; + struct ioq *entry = NULL; + glusterfs_ctx_t *ctx = NULL; + socket_private_t *priv = NULL; + + GF_VALIDATE_OR_GOTO("socket", this, out); + GF_VALIDATE_OR_GOTO("socket", this->private, out); + + priv = this->private; + ctx = this->ctx; + + pthread_mutex_lock(&priv->out_lock); + { + if (priv->connected != 1) { + if (!priv->submit_log && !priv->connect_finish_log) { + gf_log(this->name, GF_LOG_INFO, + "not connected (priv->connected = %d)", priv->connected); + priv->submit_log = 1; + } + goto unlock; + } + + priv->submit_log = 0; + entry = __socket_ioq_new(this, msg); + if (!entry) + goto unlock; - if (list_empty (&priv->ioq)) { - ret = __socket_ioq_churn_entry (this, entry, 1); + if (list_empty(&priv->ioq)) { + ret = __socket_ioq_churn_entry(this, entry, 1); - if (ret == 0) { - need_append = 0; - } - if (ret > 0) { - need_poll_out = 1; - } - } + if (ret == 0) { + need_append = 0; + } + if (ret > 0) { + need_poll_out = 1; + } + } - if (need_append) { - list_add_tail (&entry->list, &priv->ioq); - ret = 0; - } - if (need_poll_out) { - /* first entry to wait. continue writing on POLLOUT */ - priv->idx = event_select_on (ctx->event_pool, - priv->sock, - priv->idx, -1, 1); - } + if (need_append) { + list_add_tail(&entry->list, &priv->ioq); + ret = 0; } + if (need_poll_out) { + /* first entry to wait. continue writing on POLLOUT */ + priv->idx = event_select_on(ctx->event_pool, priv->sock, priv->idx, + -1, 1); + } + } unlock: - pthread_mutex_unlock (&priv->out_lock); + pthread_mutex_unlock(&priv->out_lock); out: - return ret; + return ret; } static int32_t -socket_submit_request (rpc_transport_t *this, rpc_transport_req_t *req) +socket_submit_request(rpc_transport_t *this, rpc_transport_req_t *req) { - return socket_submit_outgoing_msg (this, &req->msg); + return socket_submit_outgoing_msg(this, &req->msg); } static int32_t -socket_submit_reply (rpc_transport_t *this, rpc_transport_reply_t *reply) +socket_submit_reply(rpc_transport_t *this, rpc_transport_reply_t *reply) { - return socket_submit_outgoing_msg (this, &reply->msg); + return socket_submit_outgoing_msg(this, &reply->msg); } static int32_t -socket_getpeername (rpc_transport_t *this, char *hostname, int hostlen) +socket_getpeername(rpc_transport_t *this, char *hostname, int hostlen) { - int32_t ret = -1; + int32_t ret = -1; - GF_VALIDATE_OR_GOTO ("socket", this, out); - GF_VALIDATE_OR_GOTO ("socket", hostname, out); + GF_VALIDATE_OR_GOTO("socket", this, out); + GF_VALIDATE_OR_GOTO("socket", hostname, out); - if (hostlen < (strlen (this->peerinfo.identifier) + 1)) { - goto out; - } + if (hostlen < (strlen(this->peerinfo.identifier) + 1)) { + goto out; + } - strcpy (hostname, this->peerinfo.identifier); - ret = 0; + strcpy(hostname, this->peerinfo.identifier); + ret = 0; out: - return ret; + return ret; } - static int32_t -socket_getpeeraddr (rpc_transport_t *this, char *peeraddr, int addrlen, - struct sockaddr_storage *sa, socklen_t salen) +socket_getpeeraddr(rpc_transport_t *this, char *peeraddr, int addrlen, + struct sockaddr_storage *sa, socklen_t salen) { - int32_t ret = -1; + int32_t ret = -1; - GF_VALIDATE_OR_GOTO ("socket", this, out); - GF_VALIDATE_OR_GOTO ("socket", sa, out); - ret = 0; + GF_VALIDATE_OR_GOTO("socket", this, out); + GF_VALIDATE_OR_GOTO("socket", sa, out); + ret = 0; - *sa = this->peerinfo.sockaddr; + *sa = this->peerinfo.sockaddr; - if (peeraddr != NULL) { - ret = socket_getpeername (this, peeraddr, addrlen); - } + if (peeraddr != NULL) { + ret = socket_getpeername(this, peeraddr, addrlen); + } out: - return ret; + return ret; } - static int32_t -socket_getmyname (rpc_transport_t *this, char *hostname, int hostlen) +socket_getmyname(rpc_transport_t *this, char *hostname, int hostlen) { - int32_t ret = -1; + int32_t ret = -1; - GF_VALIDATE_OR_GOTO ("socket", this, out); - GF_VALIDATE_OR_GOTO ("socket", hostname, out); + GF_VALIDATE_OR_GOTO("socket", this, out); + GF_VALIDATE_OR_GOTO("socket", hostname, out); - if (hostlen < (strlen (this->myinfo.identifier) + 1)) { - goto out; - } + if (hostlen < (strlen(this->myinfo.identifier) + 1)) { + goto out; + } - strcpy (hostname, this->myinfo.identifier); - ret = 0; + strcpy(hostname, this->myinfo.identifier); + ret = 0; out: - return ret; + return ret; } - static int32_t -socket_getmyaddr (rpc_transport_t *this, char *myaddr, int addrlen, - struct sockaddr_storage *sa, socklen_t salen) +socket_getmyaddr(rpc_transport_t *this, char *myaddr, int addrlen, + struct sockaddr_storage *sa, socklen_t salen) { - int32_t ret = 0; + int32_t ret = 0; - GF_VALIDATE_OR_GOTO ("socket", this, out); - GF_VALIDATE_OR_GOTO ("socket", sa, out); + GF_VALIDATE_OR_GOTO("socket", this, out); + GF_VALIDATE_OR_GOTO("socket", sa, out); - *sa = this->myinfo.sockaddr; + *sa = this->myinfo.sockaddr; - if (myaddr != NULL) { - ret = socket_getmyname (this, myaddr, addrlen); - } + if (myaddr != NULL) { + ret = socket_getmyname(this, myaddr, addrlen); + } out: - return ret; + return ret; } - static int -socket_throttle (rpc_transport_t *this, gf_boolean_t onoff) +socket_throttle(rpc_transport_t *this, gf_boolean_t onoff) { - socket_private_t *priv = NULL; - - priv = this->private; - - /* The way we implement throttling is by taking off - POLLIN event from the polled flags. This way we - never get called with the POLLIN event and therefore - will never read() any more data until throttling - is turned off. - */ - pthread_mutex_lock (&priv->in_lock); - pthread_mutex_lock (&priv->out_lock); - { - - /* Throttling is useless on a disconnected transport. In fact, - * it's dangerous since priv->idx and priv->sock are set to -1 - * on a disconnected transport, which breaks epoll's event to - * registered fd mapping. */ - - if (priv->connected == 1) - priv->idx = event_select_on (this->ctx->event_pool, - priv->sock, - priv->idx, (int) !onoff, - -1); - } - pthread_mutex_unlock (&priv->out_lock); - pthread_mutex_unlock (&priv->in_lock); - return 0; + socket_private_t *priv = NULL; + + priv = this->private; + + /* The way we implement throttling is by taking off + POLLIN event from the polled flags. This way we + never get called with the POLLIN event and therefore + will never read() any more data until throttling + is turned off. + */ + pthread_mutex_lock(&priv->in_lock); + pthread_mutex_lock(&priv->out_lock); + { + /* Throttling is useless on a disconnected transport. In fact, + * it's dangerous since priv->idx and priv->sock are set to -1 + * on a disconnected transport, which breaks epoll's event to + * registered fd mapping. */ + + if (priv->connected == 1) + priv->idx = event_select_on(this->ctx->event_pool, priv->sock, + priv->idx, (int)!onoff, -1); + } + pthread_mutex_unlock(&priv->out_lock); + pthread_mutex_unlock(&priv->in_lock); + return 0; } - struct rpc_transport_ops tops = { - .listen = socket_listen, - .connect = socket_connect, - .disconnect = socket_disconnect, - .submit_request = socket_submit_request, - .submit_reply = socket_submit_reply, - .get_peername = socket_getpeername, - .get_peeraddr = socket_getpeeraddr, - .get_myname = socket_getmyname, - .get_myaddr = socket_getmyaddr, - .throttle = socket_throttle, + .listen = socket_listen, + .connect = socket_connect, + .disconnect = socket_disconnect, + .submit_request = socket_submit_request, + .submit_reply = socket_submit_reply, + .get_peername = socket_getpeername, + .get_peeraddr = socket_getpeeraddr, + .get_myname = socket_getmyname, + .get_myaddr = socket_getmyaddr, + .throttle = socket_throttle, }; int -reconfigure (rpc_transport_t *this, dict_t *options) +reconfigure(rpc_transport_t *this, dict_t *options) { - socket_private_t *priv = NULL; - gf_boolean_t tmp_bool = _gf_false; - char *optstr = NULL; - int ret = 0; - uint32_t backlog = 0; - uint64_t windowsize = 0; - uint32_t timeout = 0; - int keepaliveidle = GF_KEEPALIVE_TIME; - int keepaliveintvl = GF_KEEPALIVE_INTERVAL; - int keepalivecnt = GF_KEEPALIVE_COUNT; - - GF_VALIDATE_OR_GOTO ("socket", this, out); - GF_VALIDATE_OR_GOTO ("socket", this->private, out); - - if (!this || !this->private) { - ret =-1; - goto out; - } - - priv = this->private; - - if (dict_get_str (options, "transport.socket.keepalive", - &optstr) == 0) { - if (gf_string2boolean (optstr, &tmp_bool) == -1) { - gf_log (this->name, GF_LOG_ERROR, - "'transport.socket.keepalive' takes only " - "boolean options, not taking any action"); - priv->keepalive = 1; - ret = -1; - goto out; - } - gf_log (this->name, GF_LOG_DEBUG, "Reconfigured transport.socket.keepalive"); - - priv->keepalive = tmp_bool; - } else - priv->keepalive = 1; - - if (dict_get_int32 (options, "transport.tcp-user-timeout", - &(priv->timeout)) != 0) - priv->timeout = timeout; - gf_log (this->name, GF_LOG_DEBUG, "Reconfigued " - "transport.tcp-user-timeout=%d", priv->timeout); - - if (dict_get_uint32 (options, "transport.listen-backlog", - &backlog) == 0) { - priv->backlog = backlog; - gf_log (this->name, GF_LOG_DEBUG, "Reconfigued " - "transport.listen-backlog=%d", priv->backlog); - } - - if (dict_get_int32 (options, "transport.socket.keepalive-time", - &(priv->keepaliveidle)) != 0) - priv->keepaliveidle = keepaliveidle; - gf_log (this->name, GF_LOG_DEBUG, "Reconfigued " - "transport.socket.keepalive-time=%d", priv->keepaliveidle); - - if (dict_get_int32 (options, - "transport.socket.keepalive-interval", - &(priv->keepaliveintvl)) != 0) - priv->keepaliveintvl = keepaliveintvl; - gf_log (this->name, GF_LOG_DEBUG, "Reconfigued " - "transport.socket.keepalive-interval=%d", priv->keepaliveintvl); - - if (dict_get_int32 (options, "transport.socket.keepalive-count", - &(priv->keepalivecnt)) != 0) - priv->keepalivecnt = keepalivecnt; - gf_log (this->name, GF_LOG_DEBUG, "Reconfigued " - "transport.socket.keepalive-count=%d", priv->keepalivecnt); - - optstr = NULL; - if (dict_get_str (options, "tcp-window-size", - &optstr) == 0) { - if (gf_string2uint64 (optstr, &windowsize) != 0) { - gf_log (this->name, GF_LOG_ERROR, - "invalid number format: %s", optstr); - goto out; - } - } - - priv->windowsize = (int)windowsize; - - if (dict_get (options, "non-blocking-io")) { - optstr = data_to_str (dict_get (options, - "non-blocking-io")); + socket_private_t *priv = NULL; + gf_boolean_t tmp_bool = _gf_false; + char *optstr = NULL; + int ret = 0; + uint32_t backlog = 0; + uint64_t windowsize = 0; + uint32_t timeout = 0; + int keepaliveidle = GF_KEEPALIVE_TIME; + int keepaliveintvl = GF_KEEPALIVE_INTERVAL; + int keepalivecnt = GF_KEEPALIVE_COUNT; + + GF_VALIDATE_OR_GOTO("socket", this, out); + GF_VALIDATE_OR_GOTO("socket", this->private, out); + + if (!this || !this->private) { + ret = -1; + goto out; + } + + priv = this->private; + + if (dict_get_str(options, "transport.socket.keepalive", &optstr) == 0) { + if (gf_string2boolean(optstr, &tmp_bool) == -1) { + gf_log(this->name, GF_LOG_ERROR, + "'transport.socket.keepalive' takes only " + "boolean options, not taking any action"); + priv->keepalive = 1; + ret = -1; + goto out; + } + gf_log(this->name, GF_LOG_DEBUG, + "Reconfigured transport.socket.keepalive"); + + priv->keepalive = tmp_bool; + } else + priv->keepalive = 1; - if (gf_string2boolean (optstr, &tmp_bool) == -1) { - gf_log (this->name, GF_LOG_ERROR, - "'non-blocking-io' takes only boolean options," - " not taking any action"); - tmp_bool = 1; - } + if (dict_get_int32(options, "transport.tcp-user-timeout", + &(priv->timeout)) != 0) + priv->timeout = timeout; + gf_log(this->name, GF_LOG_DEBUG, + "Reconfigued " + "transport.tcp-user-timeout=%d", + priv->timeout); - if (!tmp_bool) { - priv->bio = 1; - gf_log (this->name, GF_LOG_WARNING, - "disabling non-blocking IO"); - } - } - - if (!priv->bio) { - ret = __socket_nonblock (priv->sock); - if (ret == -1) { - gf_log (this->name, GF_LOG_WARNING, - "NBIO on %d failed (%s)", - priv->sock, strerror (errno)); - goto out; - } + if (dict_get_uint32(options, "transport.listen-backlog", &backlog) == 0) { + priv->backlog = backlog; + gf_log(this->name, GF_LOG_DEBUG, + "Reconfigued " + "transport.listen-backlog=%d", + priv->backlog); + } + + if (dict_get_int32(options, "transport.socket.keepalive-time", + &(priv->keepaliveidle)) != 0) + priv->keepaliveidle = keepaliveidle; + gf_log(this->name, GF_LOG_DEBUG, + "Reconfigued " + "transport.socket.keepalive-time=%d", + priv->keepaliveidle); + + if (dict_get_int32(options, "transport.socket.keepalive-interval", + &(priv->keepaliveintvl)) != 0) + priv->keepaliveintvl = keepaliveintvl; + gf_log(this->name, GF_LOG_DEBUG, + "Reconfigued " + "transport.socket.keepalive-interval=%d", + priv->keepaliveintvl); + + if (dict_get_int32(options, "transport.socket.keepalive-count", + &(priv->keepalivecnt)) != 0) + priv->keepalivecnt = keepalivecnt; + gf_log(this->name, GF_LOG_DEBUG, + "Reconfigued " + "transport.socket.keepalive-count=%d", + priv->keepalivecnt); + + optstr = NULL; + if (dict_get_str(options, "tcp-window-size", &optstr) == 0) { + if (gf_string2uint64(optstr, &windowsize) != 0) { + gf_log(this->name, GF_LOG_ERROR, "invalid number format: %s", + optstr); + goto out; + } + } + + priv->windowsize = (int)windowsize; + + if (dict_get(options, "non-blocking-io")) { + optstr = data_to_str(dict_get(options, "non-blocking-io")); + + if (gf_string2boolean(optstr, &tmp_bool) == -1) { + gf_log(this->name, GF_LOG_ERROR, + "'non-blocking-io' takes only boolean options," + " not taking any action"); + tmp_bool = 1; + } + + if (!tmp_bool) { + priv->bio = 1; + gf_log(this->name, GF_LOG_WARNING, "disabling non-blocking IO"); + } + } + + if (!priv->bio) { + ret = __socket_nonblock(priv->sock); + if (ret == -1) { + gf_log(this->name, GF_LOG_WARNING, "NBIO on %d failed (%s)", + priv->sock, strerror(errno)); + goto out; } + } - ret = 0; + ret = 0; out: - return ret; - + return ret; } #if OPENSSL_VERSION_NUMBER < 0x1010000f -static pthread_mutex_t *lock_array = NULL; +static pthread_mutex_t *lock_array = NULL; static void -locking_func (int mode, int type, const char *file, int line) +locking_func(int mode, int type, const char *file, int line) { - if (mode & CRYPTO_UNLOCK) { - pthread_mutex_unlock (&lock_array[type]); - } else { - pthread_mutex_lock (&lock_array[type]); - } + if (mode & CRYPTO_UNLOCK) { + pthread_mutex_unlock(&lock_array[type]); + } else { + pthread_mutex_lock(&lock_array[type]); + } } #if OPENSSL_VERSION_NUMBER >= 0x1000000f static void -threadid_func (CRYPTO_THREADID *id) +threadid_func(CRYPTO_THREADID *id) { - /* - * We're not supposed to know whether a pthread_t is a number or a - * pointer, but we definitely need an unsigned long. Even though it - * happens to be an unsigned long already on Linux, do the cast just in - * case that's not so on another platform. Note that this can still - * break if any platforms are left where a pointer is larger than an - * unsigned long. In that case there's not much we can do; hopefully - * anyone porting to such a platform will be aware enough to notice the - * compile warnings about truncating the pointer value. - */ - CRYPTO_THREADID_set_numeric (id, (unsigned long)pthread_self()); + /* + * We're not supposed to know whether a pthread_t is a number or a + * pointer, but we definitely need an unsigned long. Even though it + * happens to be an unsigned long already on Linux, do the cast just in + * case that's not so on another platform. Note that this can still + * break if any platforms are left where a pointer is larger than an + * unsigned long. In that case there's not much we can do; hopefully + * anyone porting to such a platform will be aware enough to notice the + * compile warnings about truncating the pointer value. + */ + CRYPTO_THREADID_set_numeric(id, (unsigned long)pthread_self()); } -#else /* older openssl */ +#else /* older openssl */ static unsigned long -legacy_threadid_func (void) +legacy_threadid_func(void) { - /* See comments above, it applies here too. */ - return (unsigned long)pthread_self(); + /* See comments above, it applies here too. */ + return (unsigned long)pthread_self(); } #endif /* OPENSSL_VERSION_NUMBER >= 0x1000000f */ #endif /* OPENSSL_VERSION_NUMBER < 0x1010000f */ static void -init_openssl_mt (void) +init_openssl_mt(void) { - static gf_boolean_t initialized = _gf_false; + static gf_boolean_t initialized = _gf_false; - if (initialized) { - /* this only needs to be initialized once GLOBALLY no - matter how many translators/sockets we end up with. */ - return; - } + if (initialized) { + /* this only needs to be initialized once GLOBALLY no + matter how many translators/sockets we end up with. */ + return; + } - SSL_library_init(); - SSL_load_error_strings(); + SSL_library_init(); + SSL_load_error_strings(); - initialized = _gf_true; + initialized = _gf_true; #if OPENSSL_VERSION_NUMBER < 0x1010000f - int num_locks = CRYPTO_num_locks(); - int i; - - lock_array = GF_CALLOC (num_locks, sizeof(pthread_mutex_t), - gf_sock_mt_lock_array); - if (lock_array) { - for (i = 0; i < num_locks; ++i) { - pthread_mutex_init (&lock_array[i], NULL); - } + int num_locks = CRYPTO_num_locks(); + int i; + + lock_array = GF_CALLOC(num_locks, sizeof(pthread_mutex_t), + gf_sock_mt_lock_array); + if (lock_array) { + for (i = 0; i < num_locks; ++i) { + pthread_mutex_init(&lock_array[i], NULL); + } #if OPENSSL_VERSION_NUMBER >= 0x1000000f - CRYPTO_THREADID_set_callback (threadid_func); + CRYPTO_THREADID_set_callback(threadid_func); #else /* older openssl */ - CRYPTO_set_id_callback (legacy_threadid_func); + CRYPTO_set_id_callback(legacy_threadid_func); #endif - CRYPTO_set_locking_callback (locking_func); - } + CRYPTO_set_locking_callback(locking_func); + } #endif } -static void __attribute__((destructor)) -fini_openssl_mt (void) +static void __attribute__((destructor)) fini_openssl_mt(void) { #if OPENSSL_VERSION_NUMBER < 0x1010000f - int i; + int i; - if (!lock_array) { - return; - } + if (!lock_array) { + return; + } - CRYPTO_set_locking_callback(NULL); + CRYPTO_set_locking_callback(NULL); #if OPENSSL_VERSION_NUMBER >= 0x1000000f - CRYPTO_THREADID_set_callback (NULL); + CRYPTO_THREADID_set_callback(NULL); #else /* older openssl */ - CRYPTO_set_id_callback (NULL); + CRYPTO_set_id_callback(NULL); #endif - for (i = 0; i < CRYPTO_num_locks(); ++i) { - pthread_mutex_destroy (&lock_array[i]); - } + for (i = 0; i < CRYPTO_num_locks(); ++i) { + pthread_mutex_destroy(&lock_array[i]); + } - GF_FREE (lock_array); - lock_array = NULL; + GF_FREE(lock_array); + lock_array = NULL; #endif - ERR_free_strings(); + ERR_free_strings(); } static int ssl_setup_connection_params(rpc_transport_t *this) { - socket_private_t *priv = NULL; - char *optstr = NULL; - static int session_id = 1; - int32_t cert_depth = DEFAULT_VERIFY_DEPTH; - char *cipher_list = DEFAULT_CIPHER_LIST; - char *dh_param = DEFAULT_DH_PARAM; - char *ec_curve = DEFAULT_EC_CURVE; - char *crl_path = NULL; - - priv = this->private; - - if (priv->ssl_ctx != NULL) { - gf_log (this->name, GF_LOG_TRACE, "found old SSL context!"); - return 0; - } - - priv->ssl_own_cert = DEFAULT_CERT_PATH; - if (dict_get_str(this->options, SSL_OWN_CERT_OPT, &optstr) == 0) { - if (!priv->ssl_enabled) { - gf_log(this->name, GF_LOG_WARNING, - "%s specified without %s (ignored)", - SSL_OWN_CERT_OPT, SSL_ENABLED_OPT); - } - priv->ssl_own_cert = optstr; - } - priv->ssl_own_cert = gf_strdup(priv->ssl_own_cert); - - priv->ssl_private_key = DEFAULT_KEY_PATH; - if (dict_get_str(this->options, SSL_PRIVATE_KEY_OPT, &optstr) == 0) { - if (!priv->ssl_enabled) { - gf_log(this->name, GF_LOG_WARNING, - "%s specified without %s (ignored)", - SSL_PRIVATE_KEY_OPT, SSL_ENABLED_OPT); - } - priv->ssl_private_key = optstr; - } - priv->ssl_private_key = gf_strdup(priv->ssl_private_key); - - priv->ssl_ca_list = DEFAULT_CA_PATH; - if (dict_get_str(this->options, SSL_CA_LIST_OPT, &optstr) == 0) { - if (!priv->ssl_enabled) { - gf_log(this->name, GF_LOG_WARNING, - "%s specified without %s (ignored)", - SSL_CA_LIST_OPT, SSL_ENABLED_OPT); - } - priv->ssl_ca_list = optstr; - } - priv->ssl_ca_list = gf_strdup(priv->ssl_ca_list); - - if (dict_get_str(this->options, SSL_CRL_PATH_OPT, &optstr) == 0) { - if (!priv->ssl_enabled) { - gf_log(this->name, GF_LOG_WARNING, - "%s specified without %s (ignored)", - SSL_CRL_PATH_OPT, SSL_ENABLED_OPT); - } - if (strcasecmp(optstr, "NULL") == 0) - crl_path = NULL; - else - crl_path = optstr; - } - - gf_log(this->name, priv->ssl_enabled ? GF_LOG_INFO: GF_LOG_DEBUG, - "SSL support on the I/O path is %s", - priv->ssl_enabled ? "ENABLED" : "NOT enabled"); - gf_log(this->name, priv->mgmt_ssl ? GF_LOG_INFO: GF_LOG_DEBUG, - "SSL support for glusterd is %s", - priv->mgmt_ssl ? "ENABLED" : "NOT enabled"); - - if (!priv->mgmt_ssl) { - if (!dict_get_int32 (this->options, SSL_CERT_DEPTH_OPT, &cert_depth)) { - gf_log (this->name, GF_LOG_INFO, - "using certificate depth %d", cert_depth); - } - } else { - cert_depth = this->ctx->ssl_cert_depth; - gf_log (this->name, GF_LOG_INFO, - "using certificate depth %d", cert_depth); - } - if (!dict_get_str (this->options, SSL_CIPHER_LIST_OPT, &cipher_list)) { - gf_log (this->name, GF_LOG_INFO, - "using cipher list %s", cipher_list); - } - if (!dict_get_str (this->options, SSL_DH_PARAM_OPT, &dh_param)) { - gf_log (this->name, GF_LOG_INFO, - "using DH parameters %s", dh_param); - } - if (!dict_get_str (this->options, SSL_EC_CURVE_OPT, &ec_curve)) { - gf_log (this->name, GF_LOG_INFO, - "using EC curve %s", ec_curve); - } - - if (priv->ssl_enabled || priv->mgmt_ssl) { - BIO *bio = NULL; + socket_private_t *priv = NULL; + char *optstr = NULL; + static int session_id = 1; + int32_t cert_depth = DEFAULT_VERIFY_DEPTH; + char *cipher_list = DEFAULT_CIPHER_LIST; + char *dh_param = DEFAULT_DH_PARAM; + char *ec_curve = DEFAULT_EC_CURVE; + char *crl_path = NULL; + + priv = this->private; + + if (priv->ssl_ctx != NULL) { + gf_log(this->name, GF_LOG_TRACE, "found old SSL context!"); + return 0; + } + + priv->ssl_own_cert = DEFAULT_CERT_PATH; + if (dict_get_str(this->options, SSL_OWN_CERT_OPT, &optstr) == 0) { + if (!priv->ssl_enabled) { + gf_log(this->name, GF_LOG_WARNING, + "%s specified without %s (ignored)", SSL_OWN_CERT_OPT, + SSL_ENABLED_OPT); + } + priv->ssl_own_cert = optstr; + } + priv->ssl_own_cert = gf_strdup(priv->ssl_own_cert); + + priv->ssl_private_key = DEFAULT_KEY_PATH; + if (dict_get_str(this->options, SSL_PRIVATE_KEY_OPT, &optstr) == 0) { + if (!priv->ssl_enabled) { + gf_log(this->name, GF_LOG_WARNING, + "%s specified without %s (ignored)", SSL_PRIVATE_KEY_OPT, + SSL_ENABLED_OPT); + } + priv->ssl_private_key = optstr; + } + priv->ssl_private_key = gf_strdup(priv->ssl_private_key); + + priv->ssl_ca_list = DEFAULT_CA_PATH; + if (dict_get_str(this->options, SSL_CA_LIST_OPT, &optstr) == 0) { + if (!priv->ssl_enabled) { + gf_log(this->name, GF_LOG_WARNING, + "%s specified without %s (ignored)", SSL_CA_LIST_OPT, + SSL_ENABLED_OPT); + } + priv->ssl_ca_list = optstr; + } + priv->ssl_ca_list = gf_strdup(priv->ssl_ca_list); + + if (dict_get_str(this->options, SSL_CRL_PATH_OPT, &optstr) == 0) { + if (!priv->ssl_enabled) { + gf_log(this->name, GF_LOG_WARNING, + "%s specified without %s (ignored)", SSL_CRL_PATH_OPT, + SSL_ENABLED_OPT); + } + if (strcasecmp(optstr, "NULL") == 0) + crl_path = NULL; + else + crl_path = optstr; + } + + gf_log(this->name, priv->ssl_enabled ? GF_LOG_INFO : GF_LOG_DEBUG, + "SSL support on the I/O path is %s", + priv->ssl_enabled ? "ENABLED" : "NOT enabled"); + gf_log(this->name, priv->mgmt_ssl ? GF_LOG_INFO : GF_LOG_DEBUG, + "SSL support for glusterd is %s", + priv->mgmt_ssl ? "ENABLED" : "NOT enabled"); + + if (!priv->mgmt_ssl) { + if (!dict_get_int32(this->options, SSL_CERT_DEPTH_OPT, &cert_depth)) { + gf_log(this->name, GF_LOG_INFO, "using certificate depth %d", + cert_depth); + } + } else { + cert_depth = this->ctx->ssl_cert_depth; + gf_log(this->name, GF_LOG_INFO, "using certificate depth %d", + cert_depth); + } + if (!dict_get_str(this->options, SSL_CIPHER_LIST_OPT, &cipher_list)) { + gf_log(this->name, GF_LOG_INFO, "using cipher list %s", cipher_list); + } + if (!dict_get_str(this->options, SSL_DH_PARAM_OPT, &dh_param)) { + gf_log(this->name, GF_LOG_INFO, "using DH parameters %s", dh_param); + } + if (!dict_get_str(this->options, SSL_EC_CURVE_OPT, &ec_curve)) { + gf_log(this->name, GF_LOG_INFO, "using EC curve %s", ec_curve); + } + + if (priv->ssl_enabled || priv->mgmt_ssl) { + BIO *bio = NULL; #if HAVE_TLS_METHOD - priv->ssl_meth = (SSL_METHOD *)TLS_method(); + priv->ssl_meth = (SSL_METHOD *)TLS_method(); #elif HAVE_TLSV1_2_METHOD - priv->ssl_meth = (SSL_METHOD *)TLSv1_2_method(); + priv->ssl_meth = (SSL_METHOD *)TLSv1_2_method(); #else /* * Nobody should use an OpenSSL so old it does not support TLS 1.2. @@ -4354,560 +4204,494 @@ ssl_setup_connection_params(rpc_transport_t *this) #ifndef USE_INSECURE_OPENSSL #error Old and insecure OpenSSL, use -DUSE_INSECURE_OPENSSL to use it anyway #endif - /* SSLv23_method uses highest available protocol */ - priv->ssl_meth = SSLv23_method(); + /* SSLv23_method uses highest available protocol */ + priv->ssl_meth = SSLv23_method(); #endif - priv->ssl_ctx = SSL_CTX_new(priv->ssl_meth); + priv->ssl_ctx = SSL_CTX_new(priv->ssl_meth); - SSL_CTX_set_options(priv->ssl_ctx, SSL_OP_NO_SSLv2); - SSL_CTX_set_options(priv->ssl_ctx, SSL_OP_NO_SSLv3); + SSL_CTX_set_options(priv->ssl_ctx, SSL_OP_NO_SSLv2); + SSL_CTX_set_options(priv->ssl_ctx, SSL_OP_NO_SSLv3); #ifdef SSL_OP_NO_TICKET - SSL_CTX_set_options(priv->ssl_ctx, SSL_OP_NO_TICKET); + SSL_CTX_set_options(priv->ssl_ctx, SSL_OP_NO_TICKET); #endif #ifdef SSL_OP_NO_COMPRESSION - SSL_CTX_set_options(priv->ssl_ctx, SSL_OP_NO_COMPRESSION); + SSL_CTX_set_options(priv->ssl_ctx, SSL_OP_NO_COMPRESSION); #endif - if ((bio = BIO_new_file(dh_param, "r")) == NULL) { - gf_log(this->name, GF_LOG_INFO, - "failed to open %s, " - "DH ciphers are disabled", dh_param); - } + if ((bio = BIO_new_file(dh_param, "r")) == NULL) { + gf_log(this->name, GF_LOG_INFO, + "failed to open %s, " + "DH ciphers are disabled", + dh_param); + } - if (bio != NULL) { + if (bio != NULL) { #ifdef HAVE_OPENSSL_DH_H - DH *dh; - unsigned long err; - - dh = PEM_read_bio_DHparams(bio, NULL, NULL, NULL); - BIO_free(bio); - if (dh != NULL) { - SSL_CTX_set_options(priv->ssl_ctx, - SSL_OP_SINGLE_DH_USE); - SSL_CTX_set_tmp_dh(priv->ssl_ctx, dh); - DH_free(dh); - } else { - err = ERR_get_error(); - gf_log(this->name, GF_LOG_ERROR, - "failed to read DH param from %s: %s " - "DH ciphers are disabled.", - dh_param, ERR_error_string(err, NULL)); - } -#else /* HAVE_OPENSSL_DH_H */ - BIO_free(bio); - gf_log(this->name, GF_LOG_ERROR, - "OpenSSL has no DH support"); + DH *dh; + unsigned long err; + + dh = PEM_read_bio_DHparams(bio, NULL, NULL, NULL); + BIO_free(bio); + if (dh != NULL) { + SSL_CTX_set_options(priv->ssl_ctx, SSL_OP_SINGLE_DH_USE); + SSL_CTX_set_tmp_dh(priv->ssl_ctx, dh); + DH_free(dh); + } else { + err = ERR_get_error(); + gf_log(this->name, GF_LOG_ERROR, + "failed to read DH param from %s: %s " + "DH ciphers are disabled.", + dh_param, ERR_error_string(err, NULL)); + } +#else /* HAVE_OPENSSL_DH_H */ + BIO_free(bio); + gf_log(this->name, GF_LOG_ERROR, "OpenSSL has no DH support"); #endif /* HAVE_OPENSSL_DH_H */ - } + } - if (ec_curve != NULL) { + if (ec_curve != NULL) { #ifdef HAVE_OPENSSL_ECDH_H - EC_KEY *ecdh = NULL; - int nid; - unsigned long err; - - nid = OBJ_sn2nid(ec_curve); - if (nid != 0) - ecdh = EC_KEY_new_by_curve_name(nid); - - if (ecdh != NULL) { - SSL_CTX_set_options(priv->ssl_ctx, - SSL_OP_SINGLE_ECDH_USE); - SSL_CTX_set_tmp_ecdh(priv->ssl_ctx, ecdh); - EC_KEY_free(ecdh); - } else { - err = ERR_get_error(); - gf_log(this->name, GF_LOG_ERROR, - "failed to load EC curve %s: %s. " - "ECDH ciphers are disabled.", - ec_curve, ERR_error_string(err, NULL)); - } -#else /* HAVE_OPENSSL_ECDH_H */ - gf_log(this->name, GF_LOG_ERROR, - "OpenSSL has no ECDH support"); + EC_KEY *ecdh = NULL; + int nid; + unsigned long err; + + nid = OBJ_sn2nid(ec_curve); + if (nid != 0) + ecdh = EC_KEY_new_by_curve_name(nid); + + if (ecdh != NULL) { + SSL_CTX_set_options(priv->ssl_ctx, SSL_OP_SINGLE_ECDH_USE); + SSL_CTX_set_tmp_ecdh(priv->ssl_ctx, ecdh); + EC_KEY_free(ecdh); + } else { + err = ERR_get_error(); + gf_log(this->name, GF_LOG_ERROR, + "failed to load EC curve %s: %s. " + "ECDH ciphers are disabled.", + ec_curve, ERR_error_string(err, NULL)); + } +#else /* HAVE_OPENSSL_ECDH_H */ + gf_log(this->name, GF_LOG_ERROR, "OpenSSL has no ECDH support"); #endif /* HAVE_OPENSSL_ECDH_H */ - } + } - /* This must be done after DH and ECDH setups */ - if (SSL_CTX_set_cipher_list(priv->ssl_ctx, cipher_list) == 0) { - gf_log(this->name, GF_LOG_ERROR, - "failed to find any valid ciphers"); - goto err; - } + /* This must be done after DH and ECDH setups */ + if (SSL_CTX_set_cipher_list(priv->ssl_ctx, cipher_list) == 0) { + gf_log(this->name, GF_LOG_ERROR, + "failed to find any valid ciphers"); + goto err; + } - SSL_CTX_set_options(priv->ssl_ctx, - SSL_OP_CIPHER_SERVER_PREFERENCE); + SSL_CTX_set_options(priv->ssl_ctx, SSL_OP_CIPHER_SERVER_PREFERENCE); - if (!SSL_CTX_use_certificate_chain_file(priv->ssl_ctx, - priv->ssl_own_cert)) { - gf_log(this->name, GF_LOG_ERROR, - "could not load our cert at %s", - priv->ssl_own_cert); - ssl_dump_error_stack(this->name); - goto err; - } + if (!SSL_CTX_use_certificate_chain_file(priv->ssl_ctx, + priv->ssl_own_cert)) { + gf_log(this->name, GF_LOG_ERROR, "could not load our cert at %s", + priv->ssl_own_cert); + ssl_dump_error_stack(this->name); + goto err; + } - if (!SSL_CTX_use_PrivateKey_file(priv->ssl_ctx, - priv->ssl_private_key, - SSL_FILETYPE_PEM)) { - gf_log(this->name, GF_LOG_ERROR, - "could not load private key at %s", - priv->ssl_private_key); - ssl_dump_error_stack(this->name); - goto err; - } + if (!SSL_CTX_use_PrivateKey_file(priv->ssl_ctx, priv->ssl_private_key, + SSL_FILETYPE_PEM)) { + gf_log(this->name, GF_LOG_ERROR, "could not load private key at %s", + priv->ssl_private_key); + ssl_dump_error_stack(this->name); + goto err; + } - if (!SSL_CTX_load_verify_locations(priv->ssl_ctx, - priv->ssl_ca_list, - crl_path)) { - gf_log(this->name, GF_LOG_ERROR, - "could not load CA list"); - goto err; - } + if (!SSL_CTX_load_verify_locations(priv->ssl_ctx, priv->ssl_ca_list, + crl_path)) { + gf_log(this->name, GF_LOG_ERROR, "could not load CA list"); + goto err; + } - SSL_CTX_set_verify_depth(priv->ssl_ctx, cert_depth); + SSL_CTX_set_verify_depth(priv->ssl_ctx, cert_depth); - if (crl_path) { + if (crl_path) { #ifdef X509_V_FLAG_CRL_CHECK_ALL - X509_STORE *x509store; + X509_STORE *x509store; - x509store = SSL_CTX_get_cert_store(priv->ssl_ctx); - X509_STORE_set_flags(x509store, - X509_V_FLAG_CRL_CHECK | - X509_V_FLAG_CRL_CHECK_ALL); + x509store = SSL_CTX_get_cert_store(priv->ssl_ctx); + X509_STORE_set_flags( + x509store, X509_V_FLAG_CRL_CHECK | X509_V_FLAG_CRL_CHECK_ALL); #else - gf_log(this->name, GF_LOG_ERROR, - "OpenSSL version does not support CRL"); + gf_log(this->name, GF_LOG_ERROR, + "OpenSSL version does not support CRL"); #endif - } + } - priv->ssl_session_id = session_id++; - SSL_CTX_set_session_id_context(priv->ssl_ctx, - (void *)&priv->ssl_session_id, - sizeof(priv->ssl_session_id)); + priv->ssl_session_id = session_id++; + SSL_CTX_set_session_id_context(priv->ssl_ctx, + (void *)&priv->ssl_session_id, + sizeof(priv->ssl_session_id)); - SSL_CTX_set_verify(priv->ssl_ctx, SSL_VERIFY_PEER, 0); + SSL_CTX_set_verify(priv->ssl_ctx, SSL_VERIFY_PEER, 0); - /* - * Since glusterfs shares the same settings for client-side - * and server-side of SSL, we need to ignore any certificate - * usage specification (SSL client vs SSL server), otherwise - * SSL connexions will fail with 'unsupported cerritifcate" - */ - SSL_CTX_set_purpose(priv->ssl_ctx, X509_PURPOSE_ANY); - } - return 0; + /* + * Since glusterfs shares the same settings for client-side + * and server-side of SSL, we need to ignore any certificate + * usage specification (SSL client vs SSL server), otherwise + * SSL connexions will fail with 'unsupported cerritifcate" + */ + SSL_CTX_set_purpose(priv->ssl_ctx, X509_PURPOSE_ANY); + } + return 0; err: - return -1; + return -1; } static int -socket_init (rpc_transport_t *this) +socket_init(rpc_transport_t *this) { - socket_private_t *priv = NULL; - gf_boolean_t tmp_bool = 0; - uint64_t windowsize = GF_DEFAULT_SOCKET_WINDOW_SIZE; - char *optstr = NULL; - uint32_t timeout = 0; - int keepaliveidle = GF_KEEPALIVE_TIME; - int keepaliveintvl = GF_KEEPALIVE_INTERVAL; - int keepalivecnt = GF_KEEPALIVE_COUNT; - uint32_t backlog = 0; - - - if (this->private) { - gf_log_callingfn (this->name, GF_LOG_ERROR, - "double init attempted"); - return -1; - } - - priv = GF_MALLOC (sizeof (*priv), gf_common_mt_socket_private_t); - if (!priv) { - return -1; - } - memset(priv, 0, sizeof(*priv)); - - this->private = priv; - pthread_mutex_init (&priv->in_lock, NULL); - pthread_mutex_init (&priv->out_lock, NULL); - pthread_mutex_init (&priv->cond_lock, NULL); - pthread_cond_init (&priv->cond, NULL); - - /*GF_REF_INIT (priv, socket_poller_mayday);*/ - - priv->sock = -1; - priv->idx = -1; - priv->connected = -1; - priv->nodelay = 1; - priv->bio = 0; - priv->ssl_accepted = _gf_false; - priv->ssl_connected = _gf_false; - priv->windowsize = GF_DEFAULT_SOCKET_WINDOW_SIZE; - INIT_LIST_HEAD (&priv->ioq); - pthread_mutex_init (&priv->notify.lock, NULL); - pthread_cond_init (&priv->notify.cond, NULL); - - /* All the below section needs 'this->options' to be present */ - if (!this->options) - goto out; - - if (dict_get (this->options, "non-blocking-io")) { - optstr = data_to_str (dict_get (this->options, - "non-blocking-io")); - - if (gf_string2boolean (optstr, &tmp_bool) == -1) { - gf_log (this->name, GF_LOG_ERROR, - "'non-blocking-io' takes only boolean options," - " not taking any action"); - tmp_bool = 1; - } - - if (!tmp_bool) { - priv->bio = 1; - gf_log (this->name, GF_LOG_WARNING, - "disabling non-blocking IO"); - } - } - - optstr = NULL; - - /* By default, we enable NODELAY */ - if (dict_get (this->options, "transport.socket.nodelay")) { - optstr = data_to_str (dict_get (this->options, - "transport.socket.nodelay")); - - if (gf_string2boolean (optstr, &tmp_bool) == -1) { - gf_log (this->name, GF_LOG_ERROR, - "'transport.socket.nodelay' takes only " - "boolean options, not taking any action"); - tmp_bool = 1; - } - if (!tmp_bool) { - priv->nodelay = 0; - gf_log (this->name, GF_LOG_DEBUG, - "disabling nodelay"); - } - } - - optstr = NULL; - if (dict_get_str (this->options, "tcp-window-size", - &optstr) == 0) { - if (gf_string2uint64 (optstr, &windowsize) != 0) { - gf_log (this->name, GF_LOG_ERROR, - "invalid number format: %s", optstr); - return -1; - } - } - - priv->windowsize = (int)windowsize; - - optstr = NULL; - /* Enable Keep-alive by default. */ - priv->keepalive = 1; - priv->keepaliveintvl = GF_KEEPALIVE_INTERVAL; - priv->keepaliveidle = GF_KEEPALIVE_TIME; - priv->keepalivecnt = GF_KEEPALIVE_COUNT; - if (dict_get_str (this->options, "transport.socket.keepalive", - &optstr) == 0) { - if (gf_string2boolean (optstr, &tmp_bool) == -1) { - gf_log (this->name, GF_LOG_ERROR, - "'transport.socket.keepalive' takes only " - "boolean options, not taking any action"); - tmp_bool = 1; - } - - if (!tmp_bool) - priv->keepalive = 0; - } - - if (dict_get_int32 (this->options, "transport.tcp-user-timeout", - &(priv->timeout)) != 0) - priv->timeout = timeout; - gf_log (this->name, GF_LOG_DEBUG, "Configued " - "transport.tcp-user-timeout=%d", priv->timeout); - - if (dict_get_int32 (this->options, - "transport.socket.keepalive-time", - &(priv->keepaliveidle)) != 0) { - priv->keepaliveidle = keepaliveidle; - } - - if (dict_get_int32 (this->options, - "transport.socket.keepalive-interval", - &(priv->keepaliveintvl)) != 0) { - priv->keepaliveintvl = keepaliveintvl; - } - - if (dict_get_int32 (this->options, "transport.socket.keepalive-count", - &(priv->keepalivecnt)) != 0) - priv->keepalivecnt = keepalivecnt; - gf_log (this->name, GF_LOG_DEBUG, "Reconfigued " - "transport.keepalivecnt=%d", keepalivecnt); - - if (dict_get_uint32 (this->options, - "transport.listen-backlog", - &backlog) != 0) { - backlog = GLUSTERFS_SOCKET_LISTEN_BACKLOG; - } - priv->backlog = backlog; - - optstr = NULL; - - /* Check if socket read failures are to be logged */ - priv->read_fail_log = 1; - if (dict_get (this->options, "transport.socket.read-fail-log")) { - optstr = data_to_str (dict_get (this->options, - "transport.socket.read-fail-log")); - if (gf_string2boolean (optstr, &tmp_bool) == -1) { - gf_log (this->name, GF_LOG_WARNING, - "'transport.socket.read-fail-log' takes only " - "boolean options; logging socket read fails"); - } else if (tmp_bool == _gf_false) { - priv->read_fail_log = 0; - } - } - - priv->windowsize = (int)windowsize; - - priv->ssl_enabled = _gf_false; - if (dict_get_str(this->options, SSL_ENABLED_OPT, &optstr) == 0) { - if (gf_string2boolean (optstr, &priv->ssl_enabled) != 0) { - gf_log (this->name, GF_LOG_ERROR, - "invalid value given for ssl-enabled boolean"); - } - } - priv->mgmt_ssl = this->ctx->secure_mgmt; - priv->srvr_ssl = this->ctx->secure_srvr; + socket_private_t *priv = NULL; + gf_boolean_t tmp_bool = 0; + uint64_t windowsize = GF_DEFAULT_SOCKET_WINDOW_SIZE; + char *optstr = NULL; + uint32_t timeout = 0; + int keepaliveidle = GF_KEEPALIVE_TIME; + int keepaliveintvl = GF_KEEPALIVE_INTERVAL; + int keepalivecnt = GF_KEEPALIVE_COUNT; + uint32_t backlog = 0; + + if (this->private) { + gf_log_callingfn(this->name, GF_LOG_ERROR, "double init attempted"); + return -1; + } - ssl_setup_connection_params(this); + priv = GF_MALLOC(sizeof(*priv), gf_common_mt_socket_private_t); + if (!priv) { + return -1; + } + memset(priv, 0, sizeof(*priv)); + + this->private = priv; + pthread_mutex_init(&priv->in_lock, NULL); + pthread_mutex_init(&priv->out_lock, NULL); + pthread_mutex_init(&priv->cond_lock, NULL); + pthread_cond_init(&priv->cond, NULL); + + /*GF_REF_INIT (priv, socket_poller_mayday);*/ + + priv->sock = -1; + priv->idx = -1; + priv->connected = -1; + priv->nodelay = 1; + priv->bio = 0; + priv->ssl_accepted = _gf_false; + priv->ssl_connected = _gf_false; + priv->windowsize = GF_DEFAULT_SOCKET_WINDOW_SIZE; + INIT_LIST_HEAD(&priv->ioq); + pthread_mutex_init(&priv->notify.lock, NULL); + pthread_cond_init(&priv->notify.cond, NULL); + + /* All the below section needs 'this->options' to be present */ + if (!this->options) + goto out; + + if (dict_get(this->options, "non-blocking-io")) { + optstr = data_to_str(dict_get(this->options, "non-blocking-io")); + + if (gf_string2boolean(optstr, &tmp_bool) == -1) { + gf_log(this->name, GF_LOG_ERROR, + "'non-blocking-io' takes only boolean options," + " not taking any action"); + tmp_bool = 1; + } + + if (!tmp_bool) { + priv->bio = 1; + gf_log(this->name, GF_LOG_WARNING, "disabling non-blocking IO"); + } + } + + optstr = NULL; + + /* By default, we enable NODELAY */ + if (dict_get(this->options, "transport.socket.nodelay")) { + optstr = data_to_str( + dict_get(this->options, "transport.socket.nodelay")); + + if (gf_string2boolean(optstr, &tmp_bool) == -1) { + gf_log(this->name, GF_LOG_ERROR, + "'transport.socket.nodelay' takes only " + "boolean options, not taking any action"); + tmp_bool = 1; + } + if (!tmp_bool) { + priv->nodelay = 0; + gf_log(this->name, GF_LOG_DEBUG, "disabling nodelay"); + } + } + + optstr = NULL; + if (dict_get_str(this->options, "tcp-window-size", &optstr) == 0) { + if (gf_string2uint64(optstr, &windowsize) != 0) { + gf_log(this->name, GF_LOG_ERROR, "invalid number format: %s", + optstr); + return -1; + } + } + + priv->windowsize = (int)windowsize; + + optstr = NULL; + /* Enable Keep-alive by default. */ + priv->keepalive = 1; + priv->keepaliveintvl = GF_KEEPALIVE_INTERVAL; + priv->keepaliveidle = GF_KEEPALIVE_TIME; + priv->keepalivecnt = GF_KEEPALIVE_COUNT; + if (dict_get_str(this->options, "transport.socket.keepalive", &optstr) == + 0) { + if (gf_string2boolean(optstr, &tmp_bool) == -1) { + gf_log(this->name, GF_LOG_ERROR, + "'transport.socket.keepalive' takes only " + "boolean options, not taking any action"); + tmp_bool = 1; + } + + if (!tmp_bool) + priv->keepalive = 0; + } + + if (dict_get_int32(this->options, "transport.tcp-user-timeout", + &(priv->timeout)) != 0) + priv->timeout = timeout; + gf_log(this->name, GF_LOG_DEBUG, + "Configued " + "transport.tcp-user-timeout=%d", + priv->timeout); + + if (dict_get_int32(this->options, "transport.socket.keepalive-time", + &(priv->keepaliveidle)) != 0) { + priv->keepaliveidle = keepaliveidle; + } + + if (dict_get_int32(this->options, "transport.socket.keepalive-interval", + &(priv->keepaliveintvl)) != 0) { + priv->keepaliveintvl = keepaliveintvl; + } + + if (dict_get_int32(this->options, "transport.socket.keepalive-count", + &(priv->keepalivecnt)) != 0) + priv->keepalivecnt = keepalivecnt; + gf_log(this->name, GF_LOG_DEBUG, + "Reconfigued " + "transport.keepalivecnt=%d", + keepalivecnt); + + if (dict_get_uint32(this->options, "transport.listen-backlog", &backlog) != + 0) { + backlog = GLUSTERFS_SOCKET_LISTEN_BACKLOG; + } + priv->backlog = backlog; + + optstr = NULL; + + /* Check if socket read failures are to be logged */ + priv->read_fail_log = 1; + if (dict_get(this->options, "transport.socket.read-fail-log")) { + optstr = data_to_str( + dict_get(this->options, "transport.socket.read-fail-log")); + if (gf_string2boolean(optstr, &tmp_bool) == -1) { + gf_log(this->name, GF_LOG_WARNING, + "'transport.socket.read-fail-log' takes only " + "boolean options; logging socket read fails"); + } else if (tmp_bool == _gf_false) { + priv->read_fail_log = 0; + } + } + + priv->windowsize = (int)windowsize; + + priv->ssl_enabled = _gf_false; + if (dict_get_str(this->options, SSL_ENABLED_OPT, &optstr) == 0) { + if (gf_string2boolean(optstr, &priv->ssl_enabled) != 0) { + gf_log(this->name, GF_LOG_ERROR, + "invalid value given for ssl-enabled boolean"); + } + } + priv->mgmt_ssl = this->ctx->secure_mgmt; + priv->srvr_ssl = this->ctx->secure_srvr; + + ssl_setup_connection_params(this); out: - this->private = priv; - return 0; + this->private = priv; + return 0; } - void -fini (rpc_transport_t *this) +fini(rpc_transport_t *this) { - socket_private_t *priv = NULL; - - if (!this) - return; - - priv = this->private; - if (priv) { - if (priv->sock != -1) { - pthread_mutex_lock (&priv->in_lock); - pthread_mutex_lock (&priv->out_lock); - { - __socket_ioq_flush (this); - __socket_reset (this); - } - pthread_mutex_unlock (&priv->out_lock); - pthread_mutex_unlock (&priv->in_lock); - } - gf_log (this->name, GF_LOG_TRACE, - "transport %p destroyed", this); - - pthread_mutex_destroy (&priv->in_lock); - pthread_mutex_destroy (&priv->out_lock); - pthread_mutex_destroy (&priv->cond_lock); - pthread_cond_destroy (&priv->cond); - if (priv->ssl_private_key) { - GF_FREE(priv->ssl_private_key); - } - if (priv->ssl_own_cert) { - GF_FREE(priv->ssl_own_cert); - } - if (priv->ssl_ca_list) { - GF_FREE(priv->ssl_ca_list); - } - GF_FREE (priv); + socket_private_t *priv = NULL; + + if (!this) + return; + + priv = this->private; + if (priv) { + if (priv->sock != -1) { + pthread_mutex_lock(&priv->in_lock); + pthread_mutex_lock(&priv->out_lock); + { + __socket_ioq_flush(this); + __socket_reset(this); + } + pthread_mutex_unlock(&priv->out_lock); + pthread_mutex_unlock(&priv->in_lock); + } + gf_log(this->name, GF_LOG_TRACE, "transport %p destroyed", this); + + pthread_mutex_destroy(&priv->in_lock); + pthread_mutex_destroy(&priv->out_lock); + pthread_mutex_destroy(&priv->cond_lock); + pthread_cond_destroy(&priv->cond); + if (priv->ssl_private_key) { + GF_FREE(priv->ssl_private_key); + } + if (priv->ssl_own_cert) { + GF_FREE(priv->ssl_own_cert); + } + if (priv->ssl_ca_list) { + GF_FREE(priv->ssl_ca_list); } + GF_FREE(priv); + } - this->private = NULL; + this->private = NULL; } int32_t -init (rpc_transport_t *this) +init(rpc_transport_t *this) { - int ret = -1; + int ret = -1; - init_openssl_mt(); + init_openssl_mt(); - ret = socket_init (this); + ret = socket_init(this); - if (ret == -1) { - gf_log (this->name, GF_LOG_DEBUG, "socket_init() failed"); - } + if (ret == -1) { + gf_log(this->name, GF_LOG_DEBUG, "socket_init() failed"); + } - return ret; + return ret; } struct volume_options options[] = { - { .key = {"remote-port", - "transport.remote-port", - "transport.socket.remote-port"}, - .type = GF_OPTION_TYPE_INT - }, - { .key = {"transport.socket.listen-port", "listen-port"}, - .type = GF_OPTION_TYPE_INT - }, - { .key = {"transport.socket.bind-address", "bind-address" }, - .type = GF_OPTION_TYPE_INTERNET_ADDRESS - }, - { .key = {"transport.socket.connect-path", "connect-path"}, - .type = GF_OPTION_TYPE_ANY - }, - { .key = {"transport.socket.bind-path", "bind-path"}, - .type = GF_OPTION_TYPE_ANY - }, - { .key = {"transport.socket.listen-path", "listen-path"}, - .type = GF_OPTION_TYPE_ANY - }, - { .key = {"transport.address-family", "address-family"}, - .value = {"inet", "inet6", "unix", "inet-sdp"}, - .op_version = {GD_OP_VERSION_3_7_4}, - .type = GF_OPTION_TYPE_STR - }, - { .key = {"non-blocking-io"}, - .type = GF_OPTION_TYPE_BOOL - }, - { .key = {"tcp-window-size"}, - .type = GF_OPTION_TYPE_SIZET, - .op_version = {1}, - .flags = OPT_FLAG_SETTABLE, - .description = "Option to set TCP SEND/RECV BUFFER SIZE", - .min = GF_MIN_SOCKET_WINDOW_SIZE, - .max = GF_MAX_SOCKET_WINDOW_SIZE - }, - { .key = {"transport.listen-backlog"}, - .type = GF_OPTION_TYPE_SIZET, - .op_version = {GD_OP_VERSION_3_11_1}, - .flags = OPT_FLAG_SETTABLE, - .description = "This option uses the value of backlog argument that " - "defines the maximum length to which the queue of " - "pending connections for socket fd may grow.", - .default_value = "1024", - }, - { .key = {"transport.tcp-user-timeout"}, - .type = GF_OPTION_TYPE_INT, - .op_version = {GD_OP_VERSION_3_10_2}, - .default_value = "0" - }, - { .key = {"transport.socket.nodelay"}, - .type = GF_OPTION_TYPE_BOOL, - .default_value = "1" - }, - { .key = {"transport.socket.lowlat"}, - .type = GF_OPTION_TYPE_BOOL - }, - { .key = {"transport.socket.keepalive"}, - .type = GF_OPTION_TYPE_BOOL, - .op_version = {1}, - .default_value = "1" - }, - { .key = {"transport.socket.keepalive-interval"}, - .type = GF_OPTION_TYPE_INT, - .op_version = {GD_OP_VERSION_3_10_2}, - .default_value = "2" - }, - { .key = {"transport.socket.keepalive-time"}, - .type = GF_OPTION_TYPE_INT, - .op_version = {GD_OP_VERSION_3_10_2}, - .default_value = "20" - }, - { .key = {"transport.socket.keepalive-count"}, - .type = GF_OPTION_TYPE_INT, - .op_version = {GD_OP_VERSION_3_10_2}, - .default_value = "9" - }, - { .key = {"transport.socket.read-fail-log"}, - .type = GF_OPTION_TYPE_BOOL - }, - { .key = {SSL_ENABLED_OPT}, - .type = GF_OPTION_TYPE_BOOL - }, - { .key = {SSL_OWN_CERT_OPT}, - .type = GF_OPTION_TYPE_STR - }, - { .key = {SSL_PRIVATE_KEY_OPT}, - .type = GF_OPTION_TYPE_STR - }, - { .key = {SSL_CA_LIST_OPT}, - .type = GF_OPTION_TYPE_STR - }, - { .key = {SSL_CERT_DEPTH_OPT}, - .type = GF_OPTION_TYPE_STR - }, - { .key = {SSL_CIPHER_LIST_OPT}, - .type = GF_OPTION_TYPE_STR - }, - { .key = {SSL_DH_PARAM_OPT}, - .type = GF_OPTION_TYPE_STR - }, - { .key = {SSL_EC_CURVE_OPT}, - .type = GF_OPTION_TYPE_STR - }, - { .key = {SSL_CRL_PATH_OPT}, - .type = GF_OPTION_TYPE_STR - }, - { .key = {OWN_THREAD_OPT}, - .type = GF_OPTION_TYPE_BOOL - }, - { .key = {"ssl-own-cert"}, - .op_version = {GD_OP_VERSION_3_7_4}, - .flags = OPT_FLAG_SETTABLE, - .type = GF_OPTION_TYPE_STR, - .description = "SSL certificate. Ignored if SSL is not enabled." - }, - { .key = {"ssl-private-key"}, - .op_version = {GD_OP_VERSION_3_7_4}, - .flags = OPT_FLAG_SETTABLE, - .type = GF_OPTION_TYPE_STR, - .description = "SSL private key. Ignored if SSL is not enabled." - }, - { .key = {"ssl-ca-list"}, - .op_version = {GD_OP_VERSION_3_7_4}, - .flags = OPT_FLAG_SETTABLE, - .type = GF_OPTION_TYPE_STR, - .description = "SSL CA list. Ignored if SSL is not enabled." - }, - { .key = {"ssl-cert-depth"}, - .type = GF_OPTION_TYPE_INT, - .op_version = {GD_OP_VERSION_3_6_0}, - .flags = OPT_FLAG_SETTABLE, - .description = "Maximum certificate-chain depth. If zero, the " - "peer's certificate itself must be in the local " - "certificate list. Otherwise, there may be up to N " - "signing certificates between the peer's and the " - "local list. Ignored if SSL is not enabled." - }, - { .key = {"ssl-cipher-list"}, - .type = GF_OPTION_TYPE_STR, - .op_version = {GD_OP_VERSION_3_6_0}, - .flags = OPT_FLAG_SETTABLE, - .description = "Allowed SSL ciphers. Ignored if SSL is not enabled." - }, - { .key = {"ssl-dh-param"}, - .type = GF_OPTION_TYPE_STR, - .op_version = {GD_OP_VERSION_3_7_4}, - .flags = OPT_FLAG_SETTABLE, - .description = "DH parameters file. Ignored if SSL is not enabled." - }, - { .key = {"ssl-ec-curve"}, - .type = GF_OPTION_TYPE_STR, - .op_version = {GD_OP_VERSION_3_7_4}, - .flags = OPT_FLAG_SETTABLE, - .description = "ECDH curve name. Ignored if SSL is not enabled." - }, - { .key = {"ssl-crl-path"}, - .type = GF_OPTION_TYPE_STR, - .op_version = {GD_OP_VERSION_3_7_4}, - .flags = OPT_FLAG_SETTABLE, - .description = "Path to directory containing CRL. " - "Ignored if SSL is not enabled." - }, - { .key = {NULL} } -}; + {.key = {"remote-port", "transport.remote-port", + "transport.socket.remote-port"}, + .type = GF_OPTION_TYPE_INT}, + {.key = {"transport.socket.listen-port", "listen-port"}, + .type = GF_OPTION_TYPE_INT}, + {.key = {"transport.socket.bind-address", "bind-address"}, + .type = GF_OPTION_TYPE_INTERNET_ADDRESS}, + {.key = {"transport.socket.connect-path", "connect-path"}, + .type = GF_OPTION_TYPE_ANY}, + {.key = {"transport.socket.bind-path", "bind-path"}, + .type = GF_OPTION_TYPE_ANY}, + {.key = {"transport.socket.listen-path", "listen-path"}, + .type = GF_OPTION_TYPE_ANY}, + {.key = {"transport.address-family", "address-family"}, + .value = {"inet", "inet6", "unix", "inet-sdp"}, + .op_version = {GD_OP_VERSION_3_7_4}, + .type = GF_OPTION_TYPE_STR}, + {.key = {"non-blocking-io"}, .type = GF_OPTION_TYPE_BOOL}, + {.key = {"tcp-window-size"}, + .type = GF_OPTION_TYPE_SIZET, + .op_version = {1}, + .flags = OPT_FLAG_SETTABLE, + .description = "Option to set TCP SEND/RECV BUFFER SIZE", + .min = GF_MIN_SOCKET_WINDOW_SIZE, + .max = GF_MAX_SOCKET_WINDOW_SIZE}, + { + .key = {"transport.listen-backlog"}, + .type = GF_OPTION_TYPE_SIZET, + .op_version = {GD_OP_VERSION_3_11_1}, + .flags = OPT_FLAG_SETTABLE, + .description = "This option uses the value of backlog argument that " + "defines the maximum length to which the queue of " + "pending connections for socket fd may grow.", + .default_value = "1024", + }, + {.key = {"transport.tcp-user-timeout"}, + .type = GF_OPTION_TYPE_INT, + .op_version = {GD_OP_VERSION_3_10_2}, + .default_value = "0"}, + {.key = {"transport.socket.nodelay"}, + .type = GF_OPTION_TYPE_BOOL, + .default_value = "1"}, + {.key = {"transport.socket.lowlat"}, .type = GF_OPTION_TYPE_BOOL}, + {.key = {"transport.socket.keepalive"}, + .type = GF_OPTION_TYPE_BOOL, + .op_version = {1}, + .default_value = "1"}, + {.key = {"transport.socket.keepalive-interval"}, + .type = GF_OPTION_TYPE_INT, + .op_version = {GD_OP_VERSION_3_10_2}, + .default_value = "2"}, + {.key = {"transport.socket.keepalive-time"}, + .type = GF_OPTION_TYPE_INT, + .op_version = {GD_OP_VERSION_3_10_2}, + .default_value = "20"}, + {.key = {"transport.socket.keepalive-count"}, + .type = GF_OPTION_TYPE_INT, + .op_version = {GD_OP_VERSION_3_10_2}, + .default_value = "9"}, + {.key = {"transport.socket.read-fail-log"}, .type = GF_OPTION_TYPE_BOOL}, + {.key = {SSL_ENABLED_OPT}, .type = GF_OPTION_TYPE_BOOL}, + {.key = {SSL_OWN_CERT_OPT}, .type = GF_OPTION_TYPE_STR}, + {.key = {SSL_PRIVATE_KEY_OPT}, .type = GF_OPTION_TYPE_STR}, + {.key = {SSL_CA_LIST_OPT}, .type = GF_OPTION_TYPE_STR}, + {.key = {SSL_CERT_DEPTH_OPT}, .type = GF_OPTION_TYPE_STR}, + {.key = {SSL_CIPHER_LIST_OPT}, .type = GF_OPTION_TYPE_STR}, + {.key = {SSL_DH_PARAM_OPT}, .type = GF_OPTION_TYPE_STR}, + {.key = {SSL_EC_CURVE_OPT}, .type = GF_OPTION_TYPE_STR}, + {.key = {SSL_CRL_PATH_OPT}, .type = GF_OPTION_TYPE_STR}, + {.key = {OWN_THREAD_OPT}, .type = GF_OPTION_TYPE_BOOL}, + {.key = {"ssl-own-cert"}, + .op_version = {GD_OP_VERSION_3_7_4}, + .flags = OPT_FLAG_SETTABLE, + .type = GF_OPTION_TYPE_STR, + .description = "SSL certificate. Ignored if SSL is not enabled."}, + {.key = {"ssl-private-key"}, + .op_version = {GD_OP_VERSION_3_7_4}, + .flags = OPT_FLAG_SETTABLE, + .type = GF_OPTION_TYPE_STR, + .description = "SSL private key. Ignored if SSL is not enabled."}, + {.key = {"ssl-ca-list"}, + .op_version = {GD_OP_VERSION_3_7_4}, + .flags = OPT_FLAG_SETTABLE, + .type = GF_OPTION_TYPE_STR, + .description = "SSL CA list. Ignored if SSL is not enabled."}, + {.key = {"ssl-cert-depth"}, + .type = GF_OPTION_TYPE_INT, + .op_version = {GD_OP_VERSION_3_6_0}, + .flags = OPT_FLAG_SETTABLE, + .description = "Maximum certificate-chain depth. If zero, the " + "peer's certificate itself must be in the local " + "certificate list. Otherwise, there may be up to N " + "signing certificates between the peer's and the " + "local list. Ignored if SSL is not enabled."}, + {.key = {"ssl-cipher-list"}, + .type = GF_OPTION_TYPE_STR, + .op_version = {GD_OP_VERSION_3_6_0}, + .flags = OPT_FLAG_SETTABLE, + .description = "Allowed SSL ciphers. Ignored if SSL is not enabled."}, + {.key = {"ssl-dh-param"}, + .type = GF_OPTION_TYPE_STR, + .op_version = {GD_OP_VERSION_3_7_4}, + .flags = OPT_FLAG_SETTABLE, + .description = "DH parameters file. Ignored if SSL is not enabled."}, + {.key = {"ssl-ec-curve"}, + .type = GF_OPTION_TYPE_STR, + .op_version = {GD_OP_VERSION_3_7_4}, + .flags = OPT_FLAG_SETTABLE, + .description = "ECDH curve name. Ignored if SSL is not enabled."}, + {.key = {"ssl-crl-path"}, + .type = GF_OPTION_TYPE_STR, + .op_version = {GD_OP_VERSION_3_7_4}, + .flags = OPT_FLAG_SETTABLE, + .description = "Path to directory containing CRL. " + "Ignored if SSL is not enabled."}, + {.key = {NULL}}}; diff --git a/rpc/xdr/src/msg-nfs3.c b/rpc/xdr/src/msg-nfs3.c index 040aced6a97..d14a731b62a 100644 --- a/rpc/xdr/src/msg-nfs3.c +++ b/rpc/xdr/src/msg-nfs3.c @@ -18,35 +18,34 @@ #include "xdr-generic.h" #include "xdr-common.h" - /* Decode the mount path from the network message in inmsg * into the memory referenced by outpath.iov_base. * The size allocated for outpath.iov_base is outpath.iov_len. * The size of the path extracted from the message is returned. */ ssize_t -xdr_to_mountpath (struct iovec outpath, struct iovec inmsg) +xdr_to_mountpath(struct iovec outpath, struct iovec inmsg) { - XDR xdr; - ssize_t ret = -1; - char *mntpath = NULL; + XDR xdr; + ssize_t ret = -1; + char *mntpath = NULL; - if ((!outpath.iov_base) || (!inmsg.iov_base)) - return -1; + if ((!outpath.iov_base) || (!inmsg.iov_base)) + return -1; - xdrmem_create (&xdr, inmsg.iov_base, (unsigned int)inmsg.iov_len, - XDR_DECODE); + xdrmem_create(&xdr, inmsg.iov_base, (unsigned int)inmsg.iov_len, + XDR_DECODE); - mntpath = outpath.iov_base; - if (!xdr_dirpath (&xdr, (dirpath *)&mntpath)) { - ret = -1; - goto ret; - } + mntpath = outpath.iov_base; + if (!xdr_dirpath(&xdr, (dirpath *)&mntpath)) { + ret = -1; + goto ret; + } - ret = xdr_decoded_length (xdr); + ret = xdr_decoded_length(xdr); ret: - return ret; + return ret; } /* Translate the mountres3 structure in res into XDR format into memory @@ -54,514 +53,429 @@ ret: * Returns the number of bytes used in encoding into XDR format. */ ssize_t -xdr_serialize_mountres3 (struct iovec outmsg, mountres3 *res) +xdr_serialize_mountres3(struct iovec outmsg, mountres3 *res) { - return xdr_serialize_generic (outmsg, (void *)res, - (xdrproc_t)xdr_mountres3); + return xdr_serialize_generic(outmsg, (void *)res, (xdrproc_t)xdr_mountres3); } - ssize_t -xdr_serialize_mountbody (struct iovec outmsg, mountbody *mb) +xdr_serialize_mountbody(struct iovec outmsg, mountbody *mb) { - return xdr_serialize_generic (outmsg, (void *)mb, - (xdrproc_t)xdr_mountbody); + return xdr_serialize_generic(outmsg, (void *)mb, (xdrproc_t)xdr_mountbody); } ssize_t -xdr_serialize_mountlist (struct iovec outmsg, mountlist *ml) +xdr_serialize_mountlist(struct iovec outmsg, mountlist *ml) { - return xdr_serialize_generic (outmsg, (void *)ml, - (xdrproc_t)xdr_mountlist); + return xdr_serialize_generic(outmsg, (void *)ml, (xdrproc_t)xdr_mountlist); } - ssize_t -xdr_serialize_mountstat3 (struct iovec outmsg, mountstat3 *m) +xdr_serialize_mountstat3(struct iovec outmsg, mountstat3 *m) { - return xdr_serialize_generic (outmsg, (void *)m, - (xdrproc_t)xdr_mountstat3); + return xdr_serialize_generic(outmsg, (void *)m, (xdrproc_t)xdr_mountstat3); } - ssize_t -xdr_to_getattr3args (struct iovec inmsg, getattr3args *ga) +xdr_to_getattr3args(struct iovec inmsg, getattr3args *ga) { - return xdr_to_generic (inmsg, (void *)ga, - (xdrproc_t)xdr_getattr3args); + return xdr_to_generic(inmsg, (void *)ga, (xdrproc_t)xdr_getattr3args); } - ssize_t -xdr_serialize_getattr3res (struct iovec outmsg, getattr3res *res) +xdr_serialize_getattr3res(struct iovec outmsg, getattr3res *res) { - return xdr_serialize_generic (outmsg, (void *)res, - (xdrproc_t)xdr_getattr3res); + return xdr_serialize_generic(outmsg, (void *)res, + (xdrproc_t)xdr_getattr3res); } - ssize_t -xdr_serialize_setattr3res (struct iovec outmsg, setattr3res *res) +xdr_serialize_setattr3res(struct iovec outmsg, setattr3res *res) { - return xdr_serialize_generic (outmsg, (void *)res, - (xdrproc_t)xdr_setattr3res); + return xdr_serialize_generic(outmsg, (void *)res, + (xdrproc_t)xdr_setattr3res); } - ssize_t -xdr_to_setattr3args (struct iovec inmsg, setattr3args *sa) +xdr_to_setattr3args(struct iovec inmsg, setattr3args *sa) { - return xdr_to_generic (inmsg, (void *)sa, - (xdrproc_t)xdr_setattr3args); + return xdr_to_generic(inmsg, (void *)sa, (xdrproc_t)xdr_setattr3args); } - ssize_t -xdr_serialize_lookup3res (struct iovec outmsg, lookup3res *res) +xdr_serialize_lookup3res(struct iovec outmsg, lookup3res *res) { - return xdr_serialize_generic (outmsg, (void *)res, - (xdrproc_t)xdr_lookup3res); + return xdr_serialize_generic(outmsg, (void *)res, + (xdrproc_t)xdr_lookup3res); } - ssize_t -xdr_to_lookup3args (struct iovec inmsg, lookup3args *la) +xdr_to_lookup3args(struct iovec inmsg, lookup3args *la) { - return xdr_to_generic (inmsg, (void *)la, - (xdrproc_t)xdr_lookup3args); + return xdr_to_generic(inmsg, (void *)la, (xdrproc_t)xdr_lookup3args); } - ssize_t -xdr_to_access3args (struct iovec inmsg, access3args *ac) +xdr_to_access3args(struct iovec inmsg, access3args *ac) { - return xdr_to_generic (inmsg,(void *)ac, - (xdrproc_t)xdr_access3args); + return xdr_to_generic(inmsg, (void *)ac, (xdrproc_t)xdr_access3args); } - ssize_t -xdr_serialize_access3res (struct iovec outmsg, access3res *res) +xdr_serialize_access3res(struct iovec outmsg, access3res *res) { - return xdr_serialize_generic (outmsg, (void *)res, - (xdrproc_t)xdr_access3res); + return xdr_serialize_generic(outmsg, (void *)res, + (xdrproc_t)xdr_access3res); } - ssize_t -xdr_to_readlink3args (struct iovec inmsg, readlink3args *ra) +xdr_to_readlink3args(struct iovec inmsg, readlink3args *ra) { - return xdr_to_generic (inmsg, (void *)ra, - (xdrproc_t)xdr_readlink3args); + return xdr_to_generic(inmsg, (void *)ra, (xdrproc_t)xdr_readlink3args); } - ssize_t -xdr_serialize_readlink3res (struct iovec outmsg, readlink3res *res) +xdr_serialize_readlink3res(struct iovec outmsg, readlink3res *res) { - return xdr_serialize_generic (outmsg, (void *)res, - (xdrproc_t)xdr_readlink3res); + return xdr_serialize_generic(outmsg, (void *)res, + (xdrproc_t)xdr_readlink3res); } - ssize_t -xdr_to_read3args (struct iovec inmsg, read3args *ra) +xdr_to_read3args(struct iovec inmsg, read3args *ra) { - return xdr_to_generic (inmsg, (void *)ra, (xdrproc_t)xdr_read3args); + return xdr_to_generic(inmsg, (void *)ra, (xdrproc_t)xdr_read3args); } - ssize_t -xdr_serialize_read3res (struct iovec outmsg, read3res *res) +xdr_serialize_read3res(struct iovec outmsg, read3res *res) { - return xdr_serialize_generic (outmsg, (void *)res, - (xdrproc_t)xdr_read3res); + return xdr_serialize_generic(outmsg, (void *)res, (xdrproc_t)xdr_read3res); } ssize_t -xdr_serialize_read3res_nocopy (struct iovec outmsg, read3res *res) +xdr_serialize_read3res_nocopy(struct iovec outmsg, read3res *res) { - return xdr_serialize_generic (outmsg, (void *)res, - (xdrproc_t)xdr_read3res_nocopy); + return xdr_serialize_generic(outmsg, (void *)res, + (xdrproc_t)xdr_read3res_nocopy); } - ssize_t -xdr_to_write3args (struct iovec inmsg, write3args *wa) +xdr_to_write3args(struct iovec inmsg, write3args *wa) { - return xdr_to_generic (inmsg, (void *)wa,(xdrproc_t)xdr_write3args); + return xdr_to_generic(inmsg, (void *)wa, (xdrproc_t)xdr_write3args); } - ssize_t -xdr_to_write3args_nocopy (struct iovec inmsg, write3args *wa, - struct iovec *payload) +xdr_to_write3args_nocopy(struct iovec inmsg, write3args *wa, + struct iovec *payload) { - return xdr_to_generic_payload (inmsg, (void *)wa, - (xdrproc_t)xdr_write3args, payload); + return xdr_to_generic_payload(inmsg, (void *)wa, (xdrproc_t)xdr_write3args, + payload); } - ssize_t -xdr_serialize_write3res (struct iovec outmsg, write3res *res) +xdr_serialize_write3res(struct iovec outmsg, write3res *res) { - return xdr_serialize_generic (outmsg, (void *)res, - (xdrproc_t)xdr_write3res); + return xdr_serialize_generic(outmsg, (void *)res, (xdrproc_t)xdr_write3res); } - ssize_t -xdr_to_create3args (struct iovec inmsg, create3args *ca) +xdr_to_create3args(struct iovec inmsg, create3args *ca) { - return xdr_to_generic (inmsg, (void *)ca, - (xdrproc_t)xdr_create3args); + return xdr_to_generic(inmsg, (void *)ca, (xdrproc_t)xdr_create3args); } - ssize_t -xdr_serialize_create3res (struct iovec outmsg, create3res *res) +xdr_serialize_create3res(struct iovec outmsg, create3res *res) { - return xdr_serialize_generic (outmsg, (void *)res, - (xdrproc_t)xdr_create3res); + return xdr_serialize_generic(outmsg, (void *)res, + (xdrproc_t)xdr_create3res); } - ssize_t -xdr_serialize_mkdir3res (struct iovec outmsg, mkdir3res *res) +xdr_serialize_mkdir3res(struct iovec outmsg, mkdir3res *res) { - return xdr_serialize_generic (outmsg, (void *)res, - (xdrproc_t)xdr_mkdir3res); + return xdr_serialize_generic(outmsg, (void *)res, (xdrproc_t)xdr_mkdir3res); } - ssize_t -xdr_to_mkdir3args (struct iovec inmsg, mkdir3args *ma) +xdr_to_mkdir3args(struct iovec inmsg, mkdir3args *ma) { - return xdr_to_generic (inmsg, (void *)ma, - (xdrproc_t)xdr_mkdir3args); + return xdr_to_generic(inmsg, (void *)ma, (xdrproc_t)xdr_mkdir3args); } - ssize_t -xdr_to_symlink3args (struct iovec inmsg, symlink3args *sa) +xdr_to_symlink3args(struct iovec inmsg, symlink3args *sa) { - return xdr_to_generic (inmsg, (void *)sa, - (xdrproc_t)xdr_symlink3args); + return xdr_to_generic(inmsg, (void *)sa, (xdrproc_t)xdr_symlink3args); } - ssize_t -xdr_serialize_symlink3res (struct iovec outmsg, symlink3res *res) +xdr_serialize_symlink3res(struct iovec outmsg, symlink3res *res) { - return xdr_serialize_generic (outmsg, (void *)res, - (xdrproc_t)xdr_symlink3res); + return xdr_serialize_generic(outmsg, (void *)res, + (xdrproc_t)xdr_symlink3res); } - ssize_t -xdr_to_mknod3args (struct iovec inmsg, mknod3args *ma) +xdr_to_mknod3args(struct iovec inmsg, mknod3args *ma) { - return xdr_to_generic (inmsg, (void *)ma, - (xdrproc_t)xdr_mknod3args); + return xdr_to_generic(inmsg, (void *)ma, (xdrproc_t)xdr_mknod3args); } - ssize_t -xdr_serialize_mknod3res (struct iovec outmsg, mknod3res *res) +xdr_serialize_mknod3res(struct iovec outmsg, mknod3res *res) { - return xdr_serialize_generic (outmsg, (void *)res, - (xdrproc_t)xdr_mknod3res); + return xdr_serialize_generic(outmsg, (void *)res, (xdrproc_t)xdr_mknod3res); } - ssize_t -xdr_to_remove3args (struct iovec inmsg, remove3args *ra) +xdr_to_remove3args(struct iovec inmsg, remove3args *ra) { - return xdr_to_generic (inmsg, (void *)ra, - (xdrproc_t)xdr_remove3args); + return xdr_to_generic(inmsg, (void *)ra, (xdrproc_t)xdr_remove3args); } - ssize_t -xdr_serialize_remove3res (struct iovec outmsg, remove3res *res) +xdr_serialize_remove3res(struct iovec outmsg, remove3res *res) { - return xdr_serialize_generic (outmsg, (void *)res, - (xdrproc_t)xdr_remove3res); + return xdr_serialize_generic(outmsg, (void *)res, + (xdrproc_t)xdr_remove3res); } - ssize_t -xdr_to_rmdir3args (struct iovec inmsg, rmdir3args *ra) +xdr_to_rmdir3args(struct iovec inmsg, rmdir3args *ra) { - return xdr_to_generic (inmsg, (void *)ra, - (xdrproc_t)xdr_rmdir3args); + return xdr_to_generic(inmsg, (void *)ra, (xdrproc_t)xdr_rmdir3args); } - ssize_t -xdr_serialize_rmdir3res (struct iovec outmsg, rmdir3res *res) +xdr_serialize_rmdir3res(struct iovec outmsg, rmdir3res *res) { - return xdr_serialize_generic (outmsg, (void *)res, - (xdrproc_t)xdr_rmdir3res); + return xdr_serialize_generic(outmsg, (void *)res, (xdrproc_t)xdr_rmdir3res); } - ssize_t -xdr_serialize_rename3res (struct iovec outmsg, rename3res *res) +xdr_serialize_rename3res(struct iovec outmsg, rename3res *res) { - return xdr_serialize_generic (outmsg, (void *)res, - (xdrproc_t)xdr_rename3res); + return xdr_serialize_generic(outmsg, (void *)res, + (xdrproc_t)xdr_rename3res); } - ssize_t -xdr_to_rename3args (struct iovec inmsg, rename3args *ra) +xdr_to_rename3args(struct iovec inmsg, rename3args *ra) { - return xdr_to_generic (inmsg, (void *)ra, - (xdrproc_t)xdr_rename3args); + return xdr_to_generic(inmsg, (void *)ra, (xdrproc_t)xdr_rename3args); } - ssize_t -xdr_serialize_link3res (struct iovec outmsg, link3res *li) +xdr_serialize_link3res(struct iovec outmsg, link3res *li) { - return xdr_serialize_generic (outmsg, (void *)li, - (xdrproc_t)xdr_link3res); + return xdr_serialize_generic(outmsg, (void *)li, (xdrproc_t)xdr_link3res); } - ssize_t -xdr_to_link3args (struct iovec inmsg, link3args *la) +xdr_to_link3args(struct iovec inmsg, link3args *la) { - return xdr_to_generic (inmsg, (void *)la, (xdrproc_t)xdr_link3args); + return xdr_to_generic(inmsg, (void *)la, (xdrproc_t)xdr_link3args); } - ssize_t -xdr_to_readdir3args (struct iovec inmsg, readdir3args *rd) +xdr_to_readdir3args(struct iovec inmsg, readdir3args *rd) { - return xdr_to_generic (inmsg, (void *)rd, - (xdrproc_t)xdr_readdir3args); + return xdr_to_generic(inmsg, (void *)rd, (xdrproc_t)xdr_readdir3args); } - ssize_t -xdr_serialize_readdir3res (struct iovec outmsg, readdir3res *res) +xdr_serialize_readdir3res(struct iovec outmsg, readdir3res *res) { - return xdr_serialize_generic (outmsg, (void *)res, - (xdrproc_t)xdr_readdir3res); + return xdr_serialize_generic(outmsg, (void *)res, + (xdrproc_t)xdr_readdir3res); } - ssize_t -xdr_to_readdirp3args (struct iovec inmsg, readdirp3args *rp) +xdr_to_readdirp3args(struct iovec inmsg, readdirp3args *rp) { - return xdr_to_generic (inmsg, (void *)rp, - (xdrproc_t)xdr_readdirp3args); + return xdr_to_generic(inmsg, (void *)rp, (xdrproc_t)xdr_readdirp3args); } - ssize_t -xdr_serialize_readdirp3res (struct iovec outmsg, readdirp3res *res) +xdr_serialize_readdirp3res(struct iovec outmsg, readdirp3res *res) { - return xdr_serialize_generic (outmsg, (void *)res, - (xdrproc_t)xdr_readdirp3res); + return xdr_serialize_generic(outmsg, (void *)res, + (xdrproc_t)xdr_readdirp3res); } - ssize_t -xdr_to_fsstat3args (struct iovec inmsg, fsstat3args *fa) +xdr_to_fsstat3args(struct iovec inmsg, fsstat3args *fa) { - return xdr_to_generic (inmsg, (void *)fa, - (xdrproc_t)xdr_fsstat3args); + return xdr_to_generic(inmsg, (void *)fa, (xdrproc_t)xdr_fsstat3args); } - ssize_t -xdr_serialize_fsstat3res (struct iovec outmsg, fsstat3res *res) +xdr_serialize_fsstat3res(struct iovec outmsg, fsstat3res *res) { - return xdr_serialize_generic (outmsg, (void *)res, - (xdrproc_t)xdr_fsstat3res); + return xdr_serialize_generic(outmsg, (void *)res, + (xdrproc_t)xdr_fsstat3res); } ssize_t -xdr_to_fsinfo3args (struct iovec inmsg, fsinfo3args *fi) +xdr_to_fsinfo3args(struct iovec inmsg, fsinfo3args *fi) { - return xdr_to_generic (inmsg, (void *)fi, - (xdrproc_t)xdr_fsinfo3args); + return xdr_to_generic(inmsg, (void *)fi, (xdrproc_t)xdr_fsinfo3args); } - ssize_t -xdr_serialize_fsinfo3res (struct iovec outmsg, fsinfo3res *res) +xdr_serialize_fsinfo3res(struct iovec outmsg, fsinfo3res *res) { - return xdr_serialize_generic (outmsg, (void *)res, - (xdrproc_t)xdr_fsinfo3res); + return xdr_serialize_generic(outmsg, (void *)res, + (xdrproc_t)xdr_fsinfo3res); } - ssize_t -xdr_to_pathconf3args (struct iovec inmsg, pathconf3args *pc) +xdr_to_pathconf3args(struct iovec inmsg, pathconf3args *pc) { - return xdr_to_generic (inmsg, (void *)pc, - (xdrproc_t)xdr_pathconf3args);} - + return xdr_to_generic(inmsg, (void *)pc, (xdrproc_t)xdr_pathconf3args); +} ssize_t -xdr_serialize_pathconf3res (struct iovec outmsg, pathconf3res *res) +xdr_serialize_pathconf3res(struct iovec outmsg, pathconf3res *res) { - return xdr_serialize_generic (outmsg, (void *)res, - (xdrproc_t)xdr_pathconf3res); + return xdr_serialize_generic(outmsg, (void *)res, + (xdrproc_t)xdr_pathconf3res); } - ssize_t -xdr_to_commit3args (struct iovec inmsg, commit3args *ca) +xdr_to_commit3args(struct iovec inmsg, commit3args *ca) { - return xdr_to_generic (inmsg, (void *)ca, - (xdrproc_t)xdr_commit3args); + return xdr_to_generic(inmsg, (void *)ca, (xdrproc_t)xdr_commit3args); } - ssize_t -xdr_serialize_commit3res (struct iovec outmsg, commit3res *res) +xdr_serialize_commit3res(struct iovec outmsg, commit3res *res) { - return xdr_serialize_generic (outmsg, (void *)res, - (xdrproc_t)xdr_commit3res); + return xdr_serialize_generic(outmsg, (void *)res, + (xdrproc_t)xdr_commit3res); } - ssize_t -xdr_serialize_exports (struct iovec outmsg, exports *elist) +xdr_serialize_exports(struct iovec outmsg, exports *elist) { - XDR xdr; - ssize_t ret = -1; + XDR xdr; + ssize_t ret = -1; - if ((!outmsg.iov_base) || (!elist)) - return -1; + if ((!outmsg.iov_base) || (!elist)) + return -1; - xdrmem_create (&xdr, outmsg.iov_base, (unsigned int)outmsg.iov_len, - XDR_ENCODE); + xdrmem_create(&xdr, outmsg.iov_base, (unsigned int)outmsg.iov_len, + XDR_ENCODE); - if (!xdr_exports (&xdr, elist)) - goto ret; + if (!xdr_exports(&xdr, elist)) + goto ret; - ret = xdr_decoded_length (xdr); + ret = xdr_decoded_length(xdr); ret: - return ret; + return ret; } - ssize_t -xdr_serialize_nfsstat3 (struct iovec outmsg, nfsstat3 *s) +xdr_serialize_nfsstat3(struct iovec outmsg, nfsstat3 *s) { - return xdr_serialize_generic (outmsg, (void *)s, - (xdrproc_t)xdr_nfsstat3); + return xdr_serialize_generic(outmsg, (void *)s, (xdrproc_t)xdr_nfsstat3); } ssize_t -xdr_to_nlm4_testargs (struct iovec inmsg, nlm4_testargs *args) +xdr_to_nlm4_testargs(struct iovec inmsg, nlm4_testargs *args) { - return xdr_to_generic (inmsg, (void*)args, - (xdrproc_t)xdr_nlm4_testargs); + return xdr_to_generic(inmsg, (void *)args, (xdrproc_t)xdr_nlm4_testargs); } ssize_t -xdr_serialize_nlm4_testres (struct iovec outmsg, nlm4_testres *res) +xdr_serialize_nlm4_testres(struct iovec outmsg, nlm4_testres *res) { - return xdr_serialize_generic (outmsg, (void*)res, - (xdrproc_t)xdr_nlm4_testres); + return xdr_serialize_generic(outmsg, (void *)res, + (xdrproc_t)xdr_nlm4_testres); } ssize_t -xdr_to_nlm4_lockargs (struct iovec inmsg, nlm4_lockargs *args) +xdr_to_nlm4_lockargs(struct iovec inmsg, nlm4_lockargs *args) { - return xdr_to_generic (inmsg, (void*)args, - (xdrproc_t)xdr_nlm4_lockargs); + return xdr_to_generic(inmsg, (void *)args, (xdrproc_t)xdr_nlm4_lockargs); } ssize_t -xdr_serialize_nlm4_res (struct iovec outmsg, nlm4_res *res) +xdr_serialize_nlm4_res(struct iovec outmsg, nlm4_res *res) { - return xdr_serialize_generic (outmsg, (void*)res, - (xdrproc_t)xdr_nlm4_res); + return xdr_serialize_generic(outmsg, (void *)res, (xdrproc_t)xdr_nlm4_res); } ssize_t -xdr_to_nlm4_cancelargs (struct iovec inmsg, nlm4_cancargs *args) +xdr_to_nlm4_cancelargs(struct iovec inmsg, nlm4_cancargs *args) { - return xdr_to_generic (inmsg, (void*)args, - (xdrproc_t)xdr_nlm4_cancargs); + return xdr_to_generic(inmsg, (void *)args, (xdrproc_t)xdr_nlm4_cancargs); } ssize_t -xdr_to_nlm4_unlockargs (struct iovec inmsg, nlm4_unlockargs *args) +xdr_to_nlm4_unlockargs(struct iovec inmsg, nlm4_unlockargs *args) { - return xdr_to_generic (inmsg, (void*)args, - (xdrproc_t)xdr_nlm4_unlockargs); + return xdr_to_generic(inmsg, (void *)args, (xdrproc_t)xdr_nlm4_unlockargs); } ssize_t -xdr_to_nlm4_shareargs (struct iovec inmsg, nlm4_shareargs *args) +xdr_to_nlm4_shareargs(struct iovec inmsg, nlm4_shareargs *args) { - return xdr_to_generic (inmsg, (void*)args, - (xdrproc_t)xdr_nlm4_shareargs); + return xdr_to_generic(inmsg, (void *)args, (xdrproc_t)xdr_nlm4_shareargs); } ssize_t -xdr_serialize_nlm4_shareres (struct iovec outmsg, nlm4_shareres *res) +xdr_serialize_nlm4_shareres(struct iovec outmsg, nlm4_shareres *res) { - return xdr_serialize_generic (outmsg, (void *)res, - (xdrproc_t)xdr_nlm4_shareres); + return xdr_serialize_generic(outmsg, (void *)res, + (xdrproc_t)xdr_nlm4_shareres); } ssize_t -xdr_serialize_nlm4_testargs (struct iovec outmsg, nlm4_testargs *args) +xdr_serialize_nlm4_testargs(struct iovec outmsg, nlm4_testargs *args) { - return xdr_serialize_generic (outmsg, (void*)args, - (xdrproc_t)xdr_nlm4_testargs); + return xdr_serialize_generic(outmsg, (void *)args, + (xdrproc_t)xdr_nlm4_testargs); } ssize_t -xdr_to_nlm4_res (struct iovec inmsg, nlm4_res *args) +xdr_to_nlm4_res(struct iovec inmsg, nlm4_res *args) { - return xdr_to_generic (inmsg, (void*)args, - (xdrproc_t)xdr_nlm4_res); + return xdr_to_generic(inmsg, (void *)args, (xdrproc_t)xdr_nlm4_res); } ssize_t -xdr_to_nlm4_freeallargs (struct iovec inmsg, nlm4_freeallargs *args) +xdr_to_nlm4_freeallargs(struct iovec inmsg, nlm4_freeallargs *args) { - return xdr_to_generic (inmsg, (void*)args, - (xdrproc_t)xdr_nlm4_freeallargs); + return xdr_to_generic(inmsg, (void *)args, (xdrproc_t)xdr_nlm4_freeallargs); } ssize_t -xdr_to_getaclargs (struct iovec inmsg, getaclargs *args) +xdr_to_getaclargs(struct iovec inmsg, getaclargs *args) { - return xdr_to_generic (inmsg, (void *) args, - (xdrproc_t)xdr_getaclargs); + return xdr_to_generic(inmsg, (void *)args, (xdrproc_t)xdr_getaclargs); } ssize_t -xdr_to_setaclargs (struct iovec inmsg, setaclargs *args) +xdr_to_setaclargs(struct iovec inmsg, setaclargs *args) { - return xdr_to_generic (inmsg, (void *) args, - (xdrproc_t)xdr_setaclargs); + return xdr_to_generic(inmsg, (void *)args, (xdrproc_t)xdr_setaclargs); } ssize_t -xdr_serialize_getaclreply (struct iovec inmsg, getaclreply *res) +xdr_serialize_getaclreply(struct iovec inmsg, getaclreply *res) { - return xdr_serialize_generic (inmsg, (void *) res, - (xdrproc_t)xdr_getaclreply); + return xdr_serialize_generic(inmsg, (void *)res, + (xdrproc_t)xdr_getaclreply); } ssize_t -xdr_serialize_setaclreply (struct iovec inmsg, setaclreply *res) +xdr_serialize_setaclreply(struct iovec inmsg, setaclreply *res) { - return xdr_serialize_generic (inmsg, (void *) res, - (xdrproc_t)xdr_setaclreply); + return xdr_serialize_generic(inmsg, (void *)res, + (xdrproc_t)xdr_setaclreply); } - diff --git a/rpc/xdr/src/xdr-generic.c b/rpc/xdr/src/xdr-generic.c index fd6fceb9425..20b54eb0a8a 100644 --- a/rpc/xdr/src/xdr-generic.c +++ b/rpc/xdr/src/xdr-generic.c @@ -8,118 +8,113 @@ cases as published by the Free Software Foundation. */ - #include "xdr-generic.h" - ssize_t -xdr_serialize_generic (struct iovec outmsg, void *res, xdrproc_t proc) +xdr_serialize_generic(struct iovec outmsg, void *res, xdrproc_t proc) { - ssize_t ret = -1; - XDR xdr; + ssize_t ret = -1; + XDR xdr; - if ((!outmsg.iov_base) || (!res) || (!proc)) - return -1; + if ((!outmsg.iov_base) || (!res) || (!proc)) + return -1; - xdrmem_create (&xdr, outmsg.iov_base, (unsigned int)outmsg.iov_len, - XDR_ENCODE); + xdrmem_create(&xdr, outmsg.iov_base, (unsigned int)outmsg.iov_len, + XDR_ENCODE); - if (!PROC(&xdr, res)) { - ret = -1; - goto ret; - } + if (!PROC(&xdr, res)) { + ret = -1; + goto ret; + } - ret = xdr_encoded_length (xdr); + ret = xdr_encoded_length(xdr); ret: - return ret; + return ret; } - ssize_t -xdr_to_generic (struct iovec inmsg, void *args, xdrproc_t proc) +xdr_to_generic(struct iovec inmsg, void *args, xdrproc_t proc) { - XDR xdr; - ssize_t ret = -1; + XDR xdr; + ssize_t ret = -1; - if ((!inmsg.iov_base) || (!args) || (!proc)) - return -1; + if ((!inmsg.iov_base) || (!args) || (!proc)) + return -1; - xdrmem_create (&xdr, inmsg.iov_base, (unsigned int)inmsg.iov_len, - XDR_DECODE); + xdrmem_create(&xdr, inmsg.iov_base, (unsigned int)inmsg.iov_len, + XDR_DECODE); - if (!PROC (&xdr, args)) { - ret = -1; - goto ret; - } + if (!PROC(&xdr, args)) { + ret = -1; + goto ret; + } - ret = xdr_decoded_length (xdr); + ret = xdr_decoded_length(xdr); ret: - return ret; + return ret; } - ssize_t -xdr_to_generic_payload (struct iovec inmsg, void *args, xdrproc_t proc, - struct iovec *pendingpayload) +xdr_to_generic_payload(struct iovec inmsg, void *args, xdrproc_t proc, + struct iovec *pendingpayload) { - XDR xdr; - ssize_t ret = -1; + XDR xdr; + ssize_t ret = -1; - if ((!inmsg.iov_base) || (!args) || (!proc)) - return -1; + if ((!inmsg.iov_base) || (!args) || (!proc)) + return -1; - xdrmem_create (&xdr, inmsg.iov_base, (unsigned int)inmsg.iov_len, - XDR_DECODE); + xdrmem_create(&xdr, inmsg.iov_base, (unsigned int)inmsg.iov_len, + XDR_DECODE); - if (!PROC (&xdr, args)) { - ret = -1; - goto ret; - } + if (!PROC(&xdr, args)) { + ret = -1; + goto ret; + } - ret = xdr_decoded_length (xdr); + ret = xdr_decoded_length(xdr); - if (pendingpayload) { - pendingpayload->iov_base = xdr_decoded_remaining_addr (xdr); - pendingpayload->iov_len = xdr_decoded_remaining_len (xdr); - } + if (pendingpayload) { + pendingpayload->iov_base = xdr_decoded_remaining_addr(xdr); + pendingpayload->iov_len = xdr_decoded_remaining_len(xdr); + } ret: - return ret; + return ret; } ssize_t -xdr_length_round_up (size_t len, size_t bufsize) +xdr_length_round_up(size_t len, size_t bufsize) { - int roundup = 0; + int roundup = 0; - roundup = len % XDR_BYTES_PER_UNIT; - if (roundup > 0) - roundup = XDR_BYTES_PER_UNIT - roundup; + roundup = len % XDR_BYTES_PER_UNIT; + if (roundup > 0) + roundup = XDR_BYTES_PER_UNIT - roundup; - if ((roundup > 0) && ((roundup + len) <= bufsize)) - len += roundup; + if ((roundup > 0) && ((roundup + len) <= bufsize)) + len += roundup; - return len; + return len; } int -xdr_bytes_round_up (struct iovec *vec, size_t bufsize) +xdr_bytes_round_up(struct iovec *vec, size_t bufsize) { - vec->iov_len = xdr_length_round_up (vec->iov_len, bufsize); - return 0; + vec->iov_len = xdr_length_round_up(vec->iov_len, bufsize); + return 0; } - void -xdr_vector_round_up (struct iovec *vec, int vcount, uint32_t count) +xdr_vector_round_up(struct iovec *vec, int vcount, uint32_t count) { - uint32_t round_count = 0; + uint32_t round_count = 0; - round_count = xdr_length_round_up (count, 1048576); - round_count -= count; - if (round_count == 0 || vcount <= 0) - return; + round_count = xdr_length_round_up(count, 1048576); + round_count -= count; + if (round_count == 0 || vcount <= 0) + return; - vec[vcount-1].iov_len += round_count; + vec[vcount - 1].iov_len += round_count; } diff --git a/rpc/xdr/src/xdr-nfs3.c b/rpc/xdr/src/xdr-nfs3.c index 01ccb236993..aca9a299b0e 100644 --- a/rpc/xdr/src/xdr-nfs3.c +++ b/rpc/xdr/src/xdr-nfs3.c @@ -27,1877 +27,1881 @@ #include "xdr-common.h" bool_t -xdr_uint64 (XDR *xdrs, uint64 *objp) +xdr_uint64(XDR *xdrs, uint64 *objp) { - if (!xdr_uint64_t (xdrs, objp)) - return FALSE; - return TRUE; + if (!xdr_uint64_t(xdrs, objp)) + return FALSE; + return TRUE; } bool_t -xdr_int64 (XDR *xdrs, int64 *objp) +xdr_int64(XDR *xdrs, int64 *objp) { - if (!xdr_int64_t (xdrs, objp)) - return FALSE; - return TRUE; + if (!xdr_int64_t(xdrs, objp)) + return FALSE; + return TRUE; } bool_t -xdr_uint32 (XDR *xdrs, uint32 *objp) +xdr_uint32(XDR *xdrs, uint32 *objp) { - if (!xdr_uint32_t (xdrs, objp)) - return FALSE; - return TRUE; + if (!xdr_uint32_t(xdrs, objp)) + return FALSE; + return TRUE; } bool_t -xdr_int32 (XDR *xdrs, int32 *objp) +xdr_int32(XDR *xdrs, int32 *objp) { - if (!xdr_int32_t (xdrs, objp)) - return FALSE; - return TRUE; + if (!xdr_int32_t(xdrs, objp)) + return FALSE; + return TRUE; } bool_t -xdr_filename3 (XDR *xdrs, filename3 *objp) +xdr_filename3(XDR *xdrs, filename3 *objp) { - if (!xdr_string (xdrs, objp, ~0)) - return FALSE; - return TRUE; + if (!xdr_string(xdrs, objp, ~0)) + return FALSE; + return TRUE; } bool_t -xdr_nfspath3 (XDR *xdrs, nfspath3 *objp) +xdr_nfspath3(XDR *xdrs, nfspath3 *objp) { - if (!xdr_string (xdrs, objp, ~0)) - return FALSE; - return TRUE; + if (!xdr_string(xdrs, objp, ~0)) + return FALSE; + return TRUE; } bool_t -xdr_fileid3 (XDR *xdrs, fileid3 *objp) +xdr_fileid3(XDR *xdrs, fileid3 *objp) { - if (!xdr_uint64 (xdrs, objp)) - return FALSE; - return TRUE; + if (!xdr_uint64(xdrs, objp)) + return FALSE; + return TRUE; } bool_t -xdr_cookie3 (XDR *xdrs, cookie3 *objp) +xdr_cookie3(XDR *xdrs, cookie3 *objp) { - if (!xdr_uint64 (xdrs, objp)) - return FALSE; - return TRUE; + if (!xdr_uint64(xdrs, objp)) + return FALSE; + return TRUE; } bool_t -xdr_cookieverf3 (XDR *xdrs, cookieverf3 objp) +xdr_cookieverf3(XDR *xdrs, cookieverf3 objp) { - if (!xdr_opaque (xdrs, objp, NFS3_COOKIEVERFSIZE)) - return FALSE; - return TRUE; + if (!xdr_opaque(xdrs, objp, NFS3_COOKIEVERFSIZE)) + return FALSE; + return TRUE; } bool_t -xdr_createverf3 (XDR *xdrs, createverf3 objp) +xdr_createverf3(XDR *xdrs, createverf3 objp) { - if (!xdr_opaque (xdrs, objp, NFS3_CREATEVERFSIZE)) - return FALSE; - return TRUE; + if (!xdr_opaque(xdrs, objp, NFS3_CREATEVERFSIZE)) + return FALSE; + return TRUE; } bool_t -xdr_writeverf3 (XDR *xdrs, writeverf3 objp) +xdr_writeverf3(XDR *xdrs, writeverf3 objp) { - if (!xdr_opaque (xdrs, objp, NFS3_WRITEVERFSIZE)) - return FALSE; - return TRUE; + if (!xdr_opaque(xdrs, objp, NFS3_WRITEVERFSIZE)) + return FALSE; + return TRUE; } bool_t -xdr_uid3 (XDR *xdrs, uid3 *objp) +xdr_uid3(XDR *xdrs, uid3 *objp) { - if (!xdr_uint32 (xdrs, objp)) - return FALSE; - return TRUE; + if (!xdr_uint32(xdrs, objp)) + return FALSE; + return TRUE; } bool_t -xdr_gid3 (XDR *xdrs, gid3 *objp) +xdr_gid3(XDR *xdrs, gid3 *objp) { - if (!xdr_uint32 (xdrs, objp)) - return FALSE; - return TRUE; + if (!xdr_uint32(xdrs, objp)) + return FALSE; + return TRUE; } bool_t -xdr_size3 (XDR *xdrs, size3 *objp) +xdr_size3(XDR *xdrs, size3 *objp) { - if (!xdr_uint64 (xdrs, objp)) - return FALSE; - return TRUE; + if (!xdr_uint64(xdrs, objp)) + return FALSE; + return TRUE; } bool_t -xdr_offset3 (XDR *xdrs, offset3 *objp) +xdr_offset3(XDR *xdrs, offset3 *objp) { - if (!xdr_uint64 (xdrs, objp)) - return FALSE; - return TRUE; + if (!xdr_uint64(xdrs, objp)) + return FALSE; + return TRUE; } bool_t -xdr_mode3 (XDR *xdrs, mode3 *objp) +xdr_mode3(XDR *xdrs, mode3 *objp) { - if (!xdr_uint32 (xdrs, objp)) - return FALSE; - return TRUE; + if (!xdr_uint32(xdrs, objp)) + return FALSE; + return TRUE; } bool_t -xdr_count3 (XDR *xdrs, count3 *objp) +xdr_count3(XDR *xdrs, count3 *objp) { - if (!xdr_uint32 (xdrs, objp)) - return FALSE; - return TRUE; + if (!xdr_uint32(xdrs, objp)) + return FALSE; + return TRUE; } bool_t -xdr_nfsstat3 (XDR *xdrs, nfsstat3 *objp) +xdr_nfsstat3(XDR *xdrs, nfsstat3 *objp) { - if (!xdr_enum (xdrs, (enum_t *) objp)) - return FALSE; - return TRUE; + if (!xdr_enum(xdrs, (enum_t *)objp)) + return FALSE; + return TRUE; } bool_t -xdr_ftype3 (XDR *xdrs, ftype3 *objp) +xdr_ftype3(XDR *xdrs, ftype3 *objp) { - if (!xdr_enum (xdrs, (enum_t *) objp)) - return FALSE; - return TRUE; + if (!xdr_enum(xdrs, (enum_t *)objp)) + return FALSE; + return TRUE; } bool_t -xdr_specdata3 (XDR *xdrs, specdata3 *objp) +xdr_specdata3(XDR *xdrs, specdata3 *objp) { - if (!xdr_uint32 (xdrs, &objp->specdata1)) - return FALSE; - if (!xdr_uint32 (xdrs, &objp->specdata2)) - return FALSE; - return TRUE; + if (!xdr_uint32(xdrs, &objp->specdata1)) + return FALSE; + if (!xdr_uint32(xdrs, &objp->specdata2)) + return FALSE; + return TRUE; } bool_t -xdr_nfs_fh3 (XDR *xdrs, nfs_fh3 *objp) +xdr_nfs_fh3(XDR *xdrs, nfs_fh3 *objp) { - if (!xdr_bytes (xdrs, (char **)&objp->data.data_val, (u_int *) &objp->data.data_len, NFS3_FHSIZE)) - return FALSE; - return TRUE; + if (!xdr_bytes(xdrs, (char **)&objp->data.data_val, + (u_int *)&objp->data.data_len, NFS3_FHSIZE)) + return FALSE; + return TRUE; } bool_t -xdr_nfstime3 (XDR *xdrs, nfstime3 *objp) +xdr_nfstime3(XDR *xdrs, nfstime3 *objp) { - if (!xdr_uint32 (xdrs, &objp->seconds)) - return FALSE; - if (!xdr_uint32 (xdrs, &objp->nseconds)) - return FALSE; - return TRUE; + if (!xdr_uint32(xdrs, &objp->seconds)) + return FALSE; + if (!xdr_uint32(xdrs, &objp->nseconds)) + return FALSE; + return TRUE; } bool_t -xdr_fattr3 (XDR *xdrs, fattr3 *objp) +xdr_fattr3(XDR *xdrs, fattr3 *objp) { - if (!xdr_ftype3 (xdrs, &objp->type)) - return FALSE; - if (!xdr_mode3 (xdrs, &objp->mode)) - return FALSE; - if (!xdr_uint32 (xdrs, &objp->nlink)) - return FALSE; - if (!xdr_uid3 (xdrs, &objp->uid)) - return FALSE; - if (!xdr_gid3 (xdrs, &objp->gid)) - return FALSE; - if (!xdr_size3 (xdrs, &objp->size)) - return FALSE; - if (!xdr_size3 (xdrs, &objp->used)) - return FALSE; - if (!xdr_specdata3 (xdrs, &objp->rdev)) - return FALSE; - if (!xdr_uint64 (xdrs, &objp->fsid)) - return FALSE; - if (!xdr_fileid3 (xdrs, &objp->fileid)) - return FALSE; - if (!xdr_nfstime3 (xdrs, &objp->atime)) - return FALSE; - if (!xdr_nfstime3 (xdrs, &objp->mtime)) - return FALSE; - if (!xdr_nfstime3 (xdrs, &objp->ctime)) - return FALSE; - return TRUE; + if (!xdr_ftype3(xdrs, &objp->type)) + return FALSE; + if (!xdr_mode3(xdrs, &objp->mode)) + return FALSE; + if (!xdr_uint32(xdrs, &objp->nlink)) + return FALSE; + if (!xdr_uid3(xdrs, &objp->uid)) + return FALSE; + if (!xdr_gid3(xdrs, &objp->gid)) + return FALSE; + if (!xdr_size3(xdrs, &objp->size)) + return FALSE; + if (!xdr_size3(xdrs, &objp->used)) + return FALSE; + if (!xdr_specdata3(xdrs, &objp->rdev)) + return FALSE; + if (!xdr_uint64(xdrs, &objp->fsid)) + return FALSE; + if (!xdr_fileid3(xdrs, &objp->fileid)) + return FALSE; + if (!xdr_nfstime3(xdrs, &objp->atime)) + return FALSE; + if (!xdr_nfstime3(xdrs, &objp->mtime)) + return FALSE; + if (!xdr_nfstime3(xdrs, &objp->ctime)) + return FALSE; + return TRUE; } bool_t -xdr_post_op_attr (XDR *xdrs, post_op_attr *objp) +xdr_post_op_attr(XDR *xdrs, post_op_attr *objp) { - if (!xdr_bool (xdrs, &objp->attributes_follow)) - return FALSE; - switch (objp->attributes_follow) { - case TRUE: - if (!xdr_fattr3 (xdrs, &objp->post_op_attr_u.attributes)) - return FALSE; - break; - case FALSE: - break; - default: - return FALSE; - } - return TRUE; + if (!xdr_bool(xdrs, &objp->attributes_follow)) + return FALSE; + switch (objp->attributes_follow) { + case TRUE: + if (!xdr_fattr3(xdrs, &objp->post_op_attr_u.attributes)) + return FALSE; + break; + case FALSE: + break; + default: + return FALSE; + } + return TRUE; } bool_t -xdr_wcc_attr (XDR *xdrs, wcc_attr *objp) +xdr_wcc_attr(XDR *xdrs, wcc_attr *objp) { - if (!xdr_size3 (xdrs, &objp->size)) - return FALSE; - if (!xdr_nfstime3 (xdrs, &objp->mtime)) - return FALSE; - if (!xdr_nfstime3 (xdrs, &objp->ctime)) - return FALSE; - return TRUE; + if (!xdr_size3(xdrs, &objp->size)) + return FALSE; + if (!xdr_nfstime3(xdrs, &objp->mtime)) + return FALSE; + if (!xdr_nfstime3(xdrs, &objp->ctime)) + return FALSE; + return TRUE; } bool_t -xdr_pre_op_attr (XDR *xdrs, pre_op_attr *objp) +xdr_pre_op_attr(XDR *xdrs, pre_op_attr *objp) { - if (!xdr_bool (xdrs, &objp->attributes_follow)) - return FALSE; - switch (objp->attributes_follow) { - case TRUE: - if (!xdr_wcc_attr (xdrs, &objp->pre_op_attr_u.attributes)) - return FALSE; - break; - case FALSE: - break; - default: - return FALSE; - } - return TRUE; + if (!xdr_bool(xdrs, &objp->attributes_follow)) + return FALSE; + switch (objp->attributes_follow) { + case TRUE: + if (!xdr_wcc_attr(xdrs, &objp->pre_op_attr_u.attributes)) + return FALSE; + break; + case FALSE: + break; + default: + return FALSE; + } + return TRUE; } bool_t -xdr_wcc_data (XDR *xdrs, wcc_data *objp) +xdr_wcc_data(XDR *xdrs, wcc_data *objp) { - if (!xdr_pre_op_attr (xdrs, &objp->before)) - return FALSE; - if (!xdr_post_op_attr (xdrs, &objp->after)) - return FALSE; - return TRUE; + if (!xdr_pre_op_attr(xdrs, &objp->before)) + return FALSE; + if (!xdr_post_op_attr(xdrs, &objp->after)) + return FALSE; + return TRUE; } bool_t -xdr_post_op_fh3 (XDR *xdrs, post_op_fh3 *objp) -{ - if (!xdr_bool (xdrs, &objp->handle_follows)) - return FALSE; - switch (objp->handle_follows) { - case TRUE: - if (!xdr_nfs_fh3 (xdrs, &objp->post_op_fh3_u.handle)) - return FALSE; - break; - case FALSE: - break; - default: - return FALSE; - } - return TRUE; -} - -bool_t -xdr_time_how (XDR *xdrs, time_how *objp) -{ - if (!xdr_enum (xdrs, (enum_t *) objp)) - return FALSE; - return TRUE; +xdr_post_op_fh3(XDR *xdrs, post_op_fh3 *objp) +{ + if (!xdr_bool(xdrs, &objp->handle_follows)) + return FALSE; + switch (objp->handle_follows) { + case TRUE: + if (!xdr_nfs_fh3(xdrs, &objp->post_op_fh3_u.handle)) + return FALSE; + break; + case FALSE: + break; + default: + return FALSE; + } + return TRUE; +} + +bool_t +xdr_time_how(XDR *xdrs, time_how *objp) +{ + if (!xdr_enum(xdrs, (enum_t *)objp)) + return FALSE; + return TRUE; } bool_t -xdr_set_mode3 (XDR *xdrs, set_mode3 *objp) +xdr_set_mode3(XDR *xdrs, set_mode3 *objp) { - if (!xdr_bool (xdrs, &objp->set_it)) - return FALSE; - switch (objp->set_it) { - case TRUE: - if (!xdr_mode3 (xdrs, &objp->set_mode3_u.mode)) - return FALSE; - break; - default: - break; - } - return TRUE; + if (!xdr_bool(xdrs, &objp->set_it)) + return FALSE; + switch (objp->set_it) { + case TRUE: + if (!xdr_mode3(xdrs, &objp->set_mode3_u.mode)) + return FALSE; + break; + default: + break; + } + return TRUE; } bool_t -xdr_set_uid3 (XDR *xdrs, set_uid3 *objp) +xdr_set_uid3(XDR *xdrs, set_uid3 *objp) { - if (!xdr_bool (xdrs, &objp->set_it)) - return FALSE; - switch (objp->set_it) { - case TRUE: - if (!xdr_uid3 (xdrs, &objp->set_uid3_u.uid)) - return FALSE; - break; - default: - break; - } - return TRUE; + if (!xdr_bool(xdrs, &objp->set_it)) + return FALSE; + switch (objp->set_it) { + case TRUE: + if (!xdr_uid3(xdrs, &objp->set_uid3_u.uid)) + return FALSE; + break; + default: + break; + } + return TRUE; } bool_t -xdr_set_gid3 (XDR *xdrs, set_gid3 *objp) +xdr_set_gid3(XDR *xdrs, set_gid3 *objp) { - if (!xdr_bool (xdrs, &objp->set_it)) - return FALSE; - switch (objp->set_it) { - case TRUE: - if (!xdr_gid3 (xdrs, &objp->set_gid3_u.gid)) - return FALSE; - break; - default: - break; - } - return TRUE; + if (!xdr_bool(xdrs, &objp->set_it)) + return FALSE; + switch (objp->set_it) { + case TRUE: + if (!xdr_gid3(xdrs, &objp->set_gid3_u.gid)) + return FALSE; + break; + default: + break; + } + return TRUE; } bool_t -xdr_set_size3 (XDR *xdrs, set_size3 *objp) +xdr_set_size3(XDR *xdrs, set_size3 *objp) { - if (!xdr_bool (xdrs, &objp->set_it)) - return FALSE; - switch (objp->set_it) { - case TRUE: - if (!xdr_size3 (xdrs, &objp->set_size3_u.size)) - return FALSE; - break; - default: - break; - } - return TRUE; + if (!xdr_bool(xdrs, &objp->set_it)) + return FALSE; + switch (objp->set_it) { + case TRUE: + if (!xdr_size3(xdrs, &objp->set_size3_u.size)) + return FALSE; + break; + default: + break; + } + return TRUE; } bool_t -xdr_set_atime (XDR *xdrs, set_atime *objp) +xdr_set_atime(XDR *xdrs, set_atime *objp) { - if (!xdr_time_how (xdrs, &objp->set_it)) - return FALSE; - switch (objp->set_it) { - case SET_TO_CLIENT_TIME: - if (!xdr_nfstime3 (xdrs, &objp->set_atime_u.atime)) - return FALSE; - break; - default: - break; - } - return TRUE; + if (!xdr_time_how(xdrs, &objp->set_it)) + return FALSE; + switch (objp->set_it) { + case SET_TO_CLIENT_TIME: + if (!xdr_nfstime3(xdrs, &objp->set_atime_u.atime)) + return FALSE; + break; + default: + break; + } + return TRUE; } bool_t -xdr_set_mtime (XDR *xdrs, set_mtime *objp) +xdr_set_mtime(XDR *xdrs, set_mtime *objp) { - if (!xdr_time_how (xdrs, &objp->set_it)) - return FALSE; - switch (objp->set_it) { - case SET_TO_CLIENT_TIME: - if (!xdr_nfstime3 (xdrs, &objp->set_mtime_u.mtime)) - return FALSE; - break; - default: - break; - } - return TRUE; + if (!xdr_time_how(xdrs, &objp->set_it)) + return FALSE; + switch (objp->set_it) { + case SET_TO_CLIENT_TIME: + if (!xdr_nfstime3(xdrs, &objp->set_mtime_u.mtime)) + return FALSE; + break; + default: + break; + } + return TRUE; } bool_t -xdr_sattr3 (XDR *xdrs, sattr3 *objp) +xdr_sattr3(XDR *xdrs, sattr3 *objp) { - if (!xdr_set_mode3 (xdrs, &objp->mode)) - return FALSE; - if (!xdr_set_uid3 (xdrs, &objp->uid)) - return FALSE; - if (!xdr_set_gid3 (xdrs, &objp->gid)) - return FALSE; - if (!xdr_set_size3 (xdrs, &objp->size)) - return FALSE; - if (!xdr_set_atime (xdrs, &objp->atime)) - return FALSE; - if (!xdr_set_mtime (xdrs, &objp->mtime)) - return FALSE; - return TRUE; + if (!xdr_set_mode3(xdrs, &objp->mode)) + return FALSE; + if (!xdr_set_uid3(xdrs, &objp->uid)) + return FALSE; + if (!xdr_set_gid3(xdrs, &objp->gid)) + return FALSE; + if (!xdr_set_size3(xdrs, &objp->size)) + return FALSE; + if (!xdr_set_atime(xdrs, &objp->atime)) + return FALSE; + if (!xdr_set_mtime(xdrs, &objp->mtime)) + return FALSE; + return TRUE; } bool_t -xdr_diropargs3 (XDR *xdrs, diropargs3 *objp) +xdr_diropargs3(XDR *xdrs, diropargs3 *objp) { - if (!xdr_nfs_fh3 (xdrs, &objp->dir)) - return FALSE; - if (!xdr_filename3 (xdrs, &objp->name)) - return FALSE; - return TRUE; + if (!xdr_nfs_fh3(xdrs, &objp->dir)) + return FALSE; + if (!xdr_filename3(xdrs, &objp->name)) + return FALSE; + return TRUE; } bool_t -xdr_getattr3args (XDR *xdrs, getattr3args *objp) +xdr_getattr3args(XDR *xdrs, getattr3args *objp) { - if (!xdr_nfs_fh3 (xdrs, &objp->object)) - return FALSE; - return TRUE; + if (!xdr_nfs_fh3(xdrs, &objp->object)) + return FALSE; + return TRUE; } bool_t -xdr_getattr3resok (XDR *xdrs, getattr3resok *objp) +xdr_getattr3resok(XDR *xdrs, getattr3resok *objp) { - if (!xdr_fattr3 (xdrs, &objp->obj_attributes)) - return FALSE; - return TRUE; + if (!xdr_fattr3(xdrs, &objp->obj_attributes)) + return FALSE; + return TRUE; } bool_t -xdr_getattr3res (XDR *xdrs, getattr3res *objp) +xdr_getattr3res(XDR *xdrs, getattr3res *objp) { - if (!xdr_nfsstat3 (xdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS3_OK: - if (!xdr_getattr3resok (xdrs, &objp->getattr3res_u.resok)) - return FALSE; - break; - default: - break; - } - return TRUE; + if (!xdr_nfsstat3(xdrs, &objp->status)) + return FALSE; + switch (objp->status) { + case NFS3_OK: + if (!xdr_getattr3resok(xdrs, &objp->getattr3res_u.resok)) + return FALSE; + break; + default: + break; + } + return TRUE; } bool_t -xdr_sattrguard3 (XDR *xdrs, sattrguard3 *objp) +xdr_sattrguard3(XDR *xdrs, sattrguard3 *objp) { - if (!xdr_bool (xdrs, &objp->check)) - return FALSE; - switch (objp->check) { - case TRUE: - if (!xdr_nfstime3 (xdrs, &objp->sattrguard3_u.obj_ctime)) - return FALSE; - break; - case FALSE: - break; - default: - return FALSE; - } - return TRUE; + if (!xdr_bool(xdrs, &objp->check)) + return FALSE; + switch (objp->check) { + case TRUE: + if (!xdr_nfstime3(xdrs, &objp->sattrguard3_u.obj_ctime)) + return FALSE; + break; + case FALSE: + break; + default: + return FALSE; + } + return TRUE; } bool_t -xdr_setattr3args (XDR *xdrs, setattr3args *objp) +xdr_setattr3args(XDR *xdrs, setattr3args *objp) { - if (!xdr_nfs_fh3 (xdrs, &objp->object)) - return FALSE; - if (!xdr_sattr3 (xdrs, &objp->new_attributes)) - return FALSE; - if (!xdr_sattrguard3 (xdrs, &objp->guard)) - return FALSE; - return TRUE; + if (!xdr_nfs_fh3(xdrs, &objp->object)) + return FALSE; + if (!xdr_sattr3(xdrs, &objp->new_attributes)) + return FALSE; + if (!xdr_sattrguard3(xdrs, &objp->guard)) + return FALSE; + return TRUE; } bool_t -xdr_setattr3resok (XDR *xdrs, setattr3resok *objp) +xdr_setattr3resok(XDR *xdrs, setattr3resok *objp) { - if (!xdr_wcc_data (xdrs, &objp->obj_wcc)) - return FALSE; - return TRUE; + if (!xdr_wcc_data(xdrs, &objp->obj_wcc)) + return FALSE; + return TRUE; } bool_t -xdr_setattr3resfail (XDR *xdrs, setattr3resfail *objp) +xdr_setattr3resfail(XDR *xdrs, setattr3resfail *objp) { - if (!xdr_wcc_data (xdrs, &objp->obj_wcc)) - return FALSE; - return TRUE; + if (!xdr_wcc_data(xdrs, &objp->obj_wcc)) + return FALSE; + return TRUE; } bool_t -xdr_setattr3res (XDR *xdrs, setattr3res *objp) +xdr_setattr3res(XDR *xdrs, setattr3res *objp) { - if (!xdr_nfsstat3 (xdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS3_OK: - if (!xdr_setattr3resok (xdrs, &objp->setattr3res_u.resok)) - return FALSE; - break; - default: - if (!xdr_setattr3resfail (xdrs, &objp->setattr3res_u.resfail)) - return FALSE; - break; - } - return TRUE; + if (!xdr_nfsstat3(xdrs, &objp->status)) + return FALSE; + switch (objp->status) { + case NFS3_OK: + if (!xdr_setattr3resok(xdrs, &objp->setattr3res_u.resok)) + return FALSE; + break; + default: + if (!xdr_setattr3resfail(xdrs, &objp->setattr3res_u.resfail)) + return FALSE; + break; + } + return TRUE; } bool_t -xdr_lookup3args (XDR *xdrs, lookup3args *objp) +xdr_lookup3args(XDR *xdrs, lookup3args *objp) { - if (!xdr_diropargs3 (xdrs, &objp->what)) - return FALSE; - return TRUE; + if (!xdr_diropargs3(xdrs, &objp->what)) + return FALSE; + return TRUE; } bool_t -xdr_lookup3resok (XDR *xdrs, lookup3resok *objp) +xdr_lookup3resok(XDR *xdrs, lookup3resok *objp) { - if (!xdr_nfs_fh3 (xdrs, &objp->object)) - return FALSE; - if (!xdr_post_op_attr (xdrs, &objp->obj_attributes)) - return FALSE; - if (!xdr_post_op_attr (xdrs, &objp->dir_attributes)) - return FALSE; - return TRUE; + if (!xdr_nfs_fh3(xdrs, &objp->object)) + return FALSE; + if (!xdr_post_op_attr(xdrs, &objp->obj_attributes)) + return FALSE; + if (!xdr_post_op_attr(xdrs, &objp->dir_attributes)) + return FALSE; + return TRUE; } bool_t -xdr_lookup3resfail (XDR *xdrs, lookup3resfail *objp) +xdr_lookup3resfail(XDR *xdrs, lookup3resfail *objp) { - if (!xdr_post_op_attr (xdrs, &objp->dir_attributes)) - return FALSE; - return TRUE; + if (!xdr_post_op_attr(xdrs, &objp->dir_attributes)) + return FALSE; + return TRUE; } bool_t -xdr_lookup3res (XDR *xdrs, lookup3res *objp) +xdr_lookup3res(XDR *xdrs, lookup3res *objp) { - if (!xdr_nfsstat3 (xdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS3_OK: - if (!xdr_lookup3resok (xdrs, &objp->lookup3res_u.resok)) - return FALSE; - break; - default: - if (!xdr_lookup3resfail (xdrs, &objp->lookup3res_u.resfail)) - return FALSE; - break; - } - return TRUE; + if (!xdr_nfsstat3(xdrs, &objp->status)) + return FALSE; + switch (objp->status) { + case NFS3_OK: + if (!xdr_lookup3resok(xdrs, &objp->lookup3res_u.resok)) + return FALSE; + break; + default: + if (!xdr_lookup3resfail(xdrs, &objp->lookup3res_u.resfail)) + return FALSE; + break; + } + return TRUE; } bool_t -xdr_access3args (XDR *xdrs, access3args *objp) +xdr_access3args(XDR *xdrs, access3args *objp) { - if (!xdr_nfs_fh3 (xdrs, &objp->object)) - return FALSE; - if (!xdr_uint32 (xdrs, &objp->access)) - return FALSE; - return TRUE; + if (!xdr_nfs_fh3(xdrs, &objp->object)) + return FALSE; + if (!xdr_uint32(xdrs, &objp->access)) + return FALSE; + return TRUE; } bool_t -xdr_access3resok (XDR *xdrs, access3resok *objp) +xdr_access3resok(XDR *xdrs, access3resok *objp) { - if (!xdr_post_op_attr (xdrs, &objp->obj_attributes)) - return FALSE; - if (!xdr_uint32 (xdrs, &objp->access)) - return FALSE; - return TRUE; + if (!xdr_post_op_attr(xdrs, &objp->obj_attributes)) + return FALSE; + if (!xdr_uint32(xdrs, &objp->access)) + return FALSE; + return TRUE; } bool_t -xdr_access3resfail (XDR *xdrs, access3resfail *objp) +xdr_access3resfail(XDR *xdrs, access3resfail *objp) { - if (!xdr_post_op_attr (xdrs, &objp->obj_attributes)) - return FALSE; - return TRUE; + if (!xdr_post_op_attr(xdrs, &objp->obj_attributes)) + return FALSE; + return TRUE; } bool_t -xdr_access3res (XDR *xdrs, access3res *objp) +xdr_access3res(XDR *xdrs, access3res *objp) { - if (!xdr_nfsstat3 (xdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS3_OK: - if (!xdr_access3resok (xdrs, &objp->access3res_u.resok)) - return FALSE; - break; - default: - if (!xdr_access3resfail (xdrs, &objp->access3res_u.resfail)) - return FALSE; - break; - } - return TRUE; + if (!xdr_nfsstat3(xdrs, &objp->status)) + return FALSE; + switch (objp->status) { + case NFS3_OK: + if (!xdr_access3resok(xdrs, &objp->access3res_u.resok)) + return FALSE; + break; + default: + if (!xdr_access3resfail(xdrs, &objp->access3res_u.resfail)) + return FALSE; + break; + } + return TRUE; } bool_t -xdr_readlink3args (XDR *xdrs, readlink3args *objp) +xdr_readlink3args(XDR *xdrs, readlink3args *objp) { - if (!xdr_nfs_fh3 (xdrs, &objp->symlink)) - return FALSE; - return TRUE; + if (!xdr_nfs_fh3(xdrs, &objp->symlink)) + return FALSE; + return TRUE; } bool_t -xdr_readlink3resok (XDR *xdrs, readlink3resok *objp) +xdr_readlink3resok(XDR *xdrs, readlink3resok *objp) { - if (!xdr_post_op_attr (xdrs, &objp->symlink_attributes)) - return FALSE; - if (!xdr_nfspath3 (xdrs, &objp->data)) - return FALSE; - return TRUE; + if (!xdr_post_op_attr(xdrs, &objp->symlink_attributes)) + return FALSE; + if (!xdr_nfspath3(xdrs, &objp->data)) + return FALSE; + return TRUE; } bool_t -xdr_readlink3resfail (XDR *xdrs, readlink3resfail *objp) +xdr_readlink3resfail(XDR *xdrs, readlink3resfail *objp) { - if (!xdr_post_op_attr (xdrs, &objp->symlink_attributes)) - return FALSE; - return TRUE; + if (!xdr_post_op_attr(xdrs, &objp->symlink_attributes)) + return FALSE; + return TRUE; } bool_t -xdr_readlink3res (XDR *xdrs, readlink3res *objp) +xdr_readlink3res(XDR *xdrs, readlink3res *objp) { - if (!xdr_nfsstat3 (xdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS3_OK: - if (!xdr_readlink3resok (xdrs, &objp->readlink3res_u.resok)) - return FALSE; - break; - default: - if (!xdr_readlink3resfail (xdrs, &objp->readlink3res_u.resfail)) - return FALSE; - break; - } - return TRUE; + if (!xdr_nfsstat3(xdrs, &objp->status)) + return FALSE; + switch (objp->status) { + case NFS3_OK: + if (!xdr_readlink3resok(xdrs, &objp->readlink3res_u.resok)) + return FALSE; + break; + default: + if (!xdr_readlink3resfail(xdrs, &objp->readlink3res_u.resfail)) + return FALSE; + break; + } + return TRUE; } bool_t -xdr_read3args (XDR *xdrs, read3args *objp) +xdr_read3args(XDR *xdrs, read3args *objp) { - if (!xdr_nfs_fh3 (xdrs, &objp->file)) - return FALSE; - if (!xdr_offset3 (xdrs, &objp->offset)) - return FALSE; - if (!xdr_count3 (xdrs, &objp->count)) - return FALSE; - return TRUE; + if (!xdr_nfs_fh3(xdrs, &objp->file)) + return FALSE; + if (!xdr_offset3(xdrs, &objp->offset)) + return FALSE; + if (!xdr_count3(xdrs, &objp->count)) + return FALSE; + return TRUE; } bool_t -xdr_read3resok_nocopy (XDR *xdrs, read3resok *objp) +xdr_read3resok_nocopy(XDR *xdrs, read3resok *objp) { - if (!xdr_post_op_attr (xdrs, &objp->file_attributes)) - return FALSE; - if (!xdr_count3 (xdrs, &objp->count)) - return FALSE; - if (!xdr_bool (xdrs, &objp->eof)) - return FALSE; - if (!xdr_u_int (xdrs, (u_int *) &objp->data.data_len)) - return FALSE; - return TRUE; + if (!xdr_post_op_attr(xdrs, &objp->file_attributes)) + return FALSE; + if (!xdr_count3(xdrs, &objp->count)) + return FALSE; + if (!xdr_bool(xdrs, &objp->eof)) + return FALSE; + if (!xdr_u_int(xdrs, (u_int *)&objp->data.data_len)) + return FALSE; + return TRUE; } - bool_t -xdr_read3resok (XDR *xdrs, read3resok *objp) +xdr_read3resok(XDR *xdrs, read3resok *objp) { - if (!xdr_post_op_attr (xdrs, &objp->file_attributes)) - return FALSE; - if (!xdr_count3 (xdrs, &objp->count)) - return FALSE; - if (!xdr_bool (xdrs, &objp->eof)) - return FALSE; - if (!xdr_bytes (xdrs, (char **)&objp->data.data_val, (u_int *) &objp->data.data_len, ~0)) - return FALSE; - return TRUE; + if (!xdr_post_op_attr(xdrs, &objp->file_attributes)) + return FALSE; + if (!xdr_count3(xdrs, &objp->count)) + return FALSE; + if (!xdr_bool(xdrs, &objp->eof)) + return FALSE; + if (!xdr_bytes(xdrs, (char **)&objp->data.data_val, + (u_int *)&objp->data.data_len, ~0)) + return FALSE; + return TRUE; } bool_t -xdr_read3resfail (XDR *xdrs, read3resfail *objp) +xdr_read3resfail(XDR *xdrs, read3resfail *objp) { - if (!xdr_post_op_attr (xdrs, &objp->file_attributes)) - return FALSE; - return TRUE; + if (!xdr_post_op_attr(xdrs, &objp->file_attributes)) + return FALSE; + return TRUE; } - bool_t -xdr_read3res_nocopy (XDR *xdrs, read3res *objp) +xdr_read3res_nocopy(XDR *xdrs, read3res *objp) { - if (!xdr_nfsstat3 (xdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS3_OK: - if (!xdr_read3resok_nocopy (xdrs, &objp->read3res_u.resok)) - return FALSE; - break; - default: - if (!xdr_read3resfail (xdrs, &objp->read3res_u.resfail)) - return FALSE; - break; - } - return TRUE; + if (!xdr_nfsstat3(xdrs, &objp->status)) + return FALSE; + switch (objp->status) { + case NFS3_OK: + if (!xdr_read3resok_nocopy(xdrs, &objp->read3res_u.resok)) + return FALSE; + break; + default: + if (!xdr_read3resfail(xdrs, &objp->read3res_u.resfail)) + return FALSE; + break; + } + return TRUE; } - bool_t -xdr_read3res (XDR *xdrs, read3res *objp) +xdr_read3res(XDR *xdrs, read3res *objp) { - if (!xdr_nfsstat3 (xdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS3_OK: - if (!xdr_read3resok (xdrs, &objp->read3res_u.resok)) - return FALSE; - break; - default: - if (!xdr_read3resfail (xdrs, &objp->read3res_u.resfail)) - return FALSE; - break; - } - return TRUE; + if (!xdr_nfsstat3(xdrs, &objp->status)) + return FALSE; + switch (objp->status) { + case NFS3_OK: + if (!xdr_read3resok(xdrs, &objp->read3res_u.resok)) + return FALSE; + break; + default: + if (!xdr_read3resfail(xdrs, &objp->read3res_u.resfail)) + return FALSE; + break; + } + return TRUE; } bool_t -xdr_stable_how (XDR *xdrs, stable_how *objp) +xdr_stable_how(XDR *xdrs, stable_how *objp) { - if (!xdr_enum (xdrs, (enum_t *) objp)) - return FALSE; - return TRUE; + if (!xdr_enum(xdrs, (enum_t *)objp)) + return FALSE; + return TRUE; } bool_t -xdr_write3args (XDR *xdrs, write3args *objp) +xdr_write3args(XDR *xdrs, write3args *objp) { - if (!xdr_nfs_fh3 (xdrs, &objp->file)) - return FALSE; - if (!xdr_offset3 (xdrs, &objp->offset)) - return FALSE; - if (!xdr_count3 (xdrs, &objp->count)) - return FALSE; - if (!xdr_stable_how (xdrs, &objp->stable)) - return FALSE; + if (!xdr_nfs_fh3(xdrs, &objp->file)) + return FALSE; + if (!xdr_offset3(xdrs, &objp->offset)) + return FALSE; + if (!xdr_count3(xdrs, &objp->count)) + return FALSE; + if (!xdr_stable_how(xdrs, &objp->stable)) + return FALSE; + + /* Added specifically to avoid copies from the xdr buffer into + * the write3args structure, which will also require an already + * allocated buffer. That is not optimal. + */ + if (!xdr_u_int(xdrs, (u_int *)&objp->data.data_len)) + return FALSE; - /* Added specifically to avoid copies from the xdr buffer into - * the write3args structure, which will also require an already - * allocated buffer. That is not optimal. - */ - if (!xdr_u_int (xdrs, (u_int *) &objp->data.data_len)) - return FALSE; + /* The remaining bytes in the xdr buffer are the bytes that need to be + * written. See how these bytes are extracted in the xdr_to_write3args + * code path. Be careful, while using the write3args structure, since + * only the data.data_len has been filled. The actual data is + * extracted in xdr_to_write3args path. + */ - /* The remaining bytes in the xdr buffer are the bytes that need to be - * written. See how these bytes are extracted in the xdr_to_write3args - * code path. Be careful, while using the write3args structure, since - * only the data.data_len has been filled. The actual data is - * extracted in xdr_to_write3args path. - */ + /* if (!xdr_bytes (xdrs, (char **)&objp->data.data_val, (u_int *) + &objp->data.data_len, ~0)) return FALSE; + */ + return TRUE; +} - /* if (!xdr_bytes (xdrs, (char **)&objp->data.data_val, (u_int *) &objp->data.data_len, ~0)) - return FALSE; - */ - return TRUE; +bool_t +xdr_write3resok(XDR *xdrs, write3resok *objp) +{ + if (!xdr_wcc_data(xdrs, &objp->file_wcc)) + return FALSE; + if (!xdr_count3(xdrs, &objp->count)) + return FALSE; + if (!xdr_stable_how(xdrs, &objp->committed)) + return FALSE; + if (!xdr_writeverf3(xdrs, objp->verf)) + return FALSE; + return TRUE; +} + +bool_t +xdr_write3resfail(XDR *xdrs, write3resfail *objp) +{ + if (!xdr_wcc_data(xdrs, &objp->file_wcc)) + return FALSE; + return TRUE; +} + +bool_t +xdr_write3res(XDR *xdrs, write3res *objp) +{ + if (!xdr_nfsstat3(xdrs, &objp->status)) + return FALSE; + switch (objp->status) { + case NFS3_OK: + if (!xdr_write3resok(xdrs, &objp->write3res_u.resok)) + return FALSE; + break; + default: + if (!xdr_write3resfail(xdrs, &objp->write3res_u.resfail)) + return FALSE; + break; + } + return TRUE; } bool_t -xdr_write3resok (XDR *xdrs, write3resok *objp) +xdr_createmode3(XDR *xdrs, createmode3 *objp) { - if (!xdr_wcc_data (xdrs, &objp->file_wcc)) - return FALSE; - if (!xdr_count3 (xdrs, &objp->count)) - return FALSE; - if (!xdr_stable_how (xdrs, &objp->committed)) - return FALSE; - if (!xdr_writeverf3 (xdrs, objp->verf)) - return FALSE; - return TRUE; + if (!xdr_enum(xdrs, (enum_t *)objp)) + return FALSE; + return TRUE; } bool_t -xdr_write3resfail (XDR *xdrs, write3resfail *objp) +xdr_createhow3(XDR *xdrs, createhow3 *objp) { - if (!xdr_wcc_data (xdrs, &objp->file_wcc)) - return FALSE; - return TRUE; + if (!xdr_createmode3(xdrs, &objp->mode)) + return FALSE; + switch (objp->mode) { + case UNCHECKED: + case GUARDED: + if (!xdr_sattr3(xdrs, &objp->createhow3_u.obj_attributes)) + return FALSE; + break; + case EXCLUSIVE: + if (!xdr_createverf3(xdrs, objp->createhow3_u.verf)) + return FALSE; + break; + default: + return FALSE; + } + return TRUE; } bool_t -xdr_write3res (XDR *xdrs, write3res *objp) +xdr_create3args(XDR *xdrs, create3args *objp) { - if (!xdr_nfsstat3 (xdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS3_OK: - if (!xdr_write3resok (xdrs, &objp->write3res_u.resok)) - return FALSE; - break; - default: - if (!xdr_write3resfail (xdrs, &objp->write3res_u.resfail)) - return FALSE; - break; - } - return TRUE; + if (!xdr_diropargs3(xdrs, &objp->where)) + return FALSE; + if (!xdr_createhow3(xdrs, &objp->how)) + return FALSE; + return TRUE; } bool_t -xdr_createmode3 (XDR *xdrs, createmode3 *objp) +xdr_create3resok(XDR *xdrs, create3resok *objp) { - if (!xdr_enum (xdrs, (enum_t *) objp)) - return FALSE; - return TRUE; + if (!xdr_post_op_fh3(xdrs, &objp->obj)) + return FALSE; + if (!xdr_post_op_attr(xdrs, &objp->obj_attributes)) + return FALSE; + if (!xdr_wcc_data(xdrs, &objp->dir_wcc)) + return FALSE; + return TRUE; } bool_t -xdr_createhow3 (XDR *xdrs, createhow3 *objp) +xdr_create3resfail(XDR *xdrs, create3resfail *objp) { - if (!xdr_createmode3 (xdrs, &objp->mode)) - return FALSE; - switch (objp->mode) { - case UNCHECKED: - case GUARDED: - if (!xdr_sattr3 (xdrs, &objp->createhow3_u.obj_attributes)) - return FALSE; - break; - case EXCLUSIVE: - if (!xdr_createverf3 (xdrs, objp->createhow3_u.verf)) - return FALSE; - break; - default: - return FALSE; - } - return TRUE; + if (!xdr_wcc_data(xdrs, &objp->dir_wcc)) + return FALSE; + return TRUE; } bool_t -xdr_create3args (XDR *xdrs, create3args *objp) +xdr_create3res(XDR *xdrs, create3res *objp) { - if (!xdr_diropargs3 (xdrs, &objp->where)) - return FALSE; - if (!xdr_createhow3 (xdrs, &objp->how)) - return FALSE; - return TRUE; + if (!xdr_nfsstat3(xdrs, &objp->status)) + return FALSE; + switch (objp->status) { + case NFS3_OK: + if (!xdr_create3resok(xdrs, &objp->create3res_u.resok)) + return FALSE; + break; + default: + if (!xdr_create3resfail(xdrs, &objp->create3res_u.resfail)) + return FALSE; + break; + } + return TRUE; } bool_t -xdr_create3resok (XDR *xdrs, create3resok *objp) +xdr_mkdir3args(XDR *xdrs, mkdir3args *objp) { - if (!xdr_post_op_fh3 (xdrs, &objp->obj)) - return FALSE; - if (!xdr_post_op_attr (xdrs, &objp->obj_attributes)) - return FALSE; - if (!xdr_wcc_data (xdrs, &objp->dir_wcc)) - return FALSE; - return TRUE; + if (!xdr_diropargs3(xdrs, &objp->where)) + return FALSE; + if (!xdr_sattr3(xdrs, &objp->attributes)) + return FALSE; + return TRUE; } bool_t -xdr_create3resfail (XDR *xdrs, create3resfail *objp) +xdr_mkdir3resok(XDR *xdrs, mkdir3resok *objp) { - if (!xdr_wcc_data (xdrs, &objp->dir_wcc)) - return FALSE; - return TRUE; + if (!xdr_post_op_fh3(xdrs, &objp->obj)) + return FALSE; + if (!xdr_post_op_attr(xdrs, &objp->obj_attributes)) + return FALSE; + if (!xdr_wcc_data(xdrs, &objp->dir_wcc)) + return FALSE; + return TRUE; } bool_t -xdr_create3res (XDR *xdrs, create3res *objp) +xdr_mkdir3resfail(XDR *xdrs, mkdir3resfail *objp) { - if (!xdr_nfsstat3 (xdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS3_OK: - if (!xdr_create3resok (xdrs, &objp->create3res_u.resok)) - return FALSE; - break; - default: - if (!xdr_create3resfail (xdrs, &objp->create3res_u.resfail)) - return FALSE; - break; - } - return TRUE; + if (!xdr_wcc_data(xdrs, &objp->dir_wcc)) + return FALSE; + return TRUE; } bool_t -xdr_mkdir3args (XDR *xdrs, mkdir3args *objp) +xdr_mkdir3res(XDR *xdrs, mkdir3res *objp) { - if (!xdr_diropargs3 (xdrs, &objp->where)) - return FALSE; - if (!xdr_sattr3 (xdrs, &objp->attributes)) - return FALSE; - return TRUE; + if (!xdr_nfsstat3(xdrs, &objp->status)) + return FALSE; + switch (objp->status) { + case NFS3_OK: + if (!xdr_mkdir3resok(xdrs, &objp->mkdir3res_u.resok)) + return FALSE; + break; + default: + if (!xdr_mkdir3resfail(xdrs, &objp->mkdir3res_u.resfail)) + return FALSE; + break; + } + return TRUE; } bool_t -xdr_mkdir3resok (XDR *xdrs, mkdir3resok *objp) +xdr_symlinkdata3(XDR *xdrs, symlinkdata3 *objp) { - if (!xdr_post_op_fh3 (xdrs, &objp->obj)) - return FALSE; - if (!xdr_post_op_attr (xdrs, &objp->obj_attributes)) - return FALSE; - if (!xdr_wcc_data (xdrs, &objp->dir_wcc)) - return FALSE; - return TRUE; + if (!xdr_sattr3(xdrs, &objp->symlink_attributes)) + return FALSE; + if (!xdr_nfspath3(xdrs, &objp->symlink_data)) + return FALSE; + return TRUE; } bool_t -xdr_mkdir3resfail (XDR *xdrs, mkdir3resfail *objp) +xdr_symlink3args(XDR *xdrs, symlink3args *objp) { - if (!xdr_wcc_data (xdrs, &objp->dir_wcc)) - return FALSE; - return TRUE; + if (!xdr_diropargs3(xdrs, &objp->where)) + return FALSE; + if (!xdr_symlinkdata3(xdrs, &objp->symlink)) + return FALSE; + return TRUE; } bool_t -xdr_mkdir3res (XDR *xdrs, mkdir3res *objp) +xdr_symlink3resok(XDR *xdrs, symlink3resok *objp) { - if (!xdr_nfsstat3 (xdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS3_OK: - if (!xdr_mkdir3resok (xdrs, &objp->mkdir3res_u.resok)) - return FALSE; - break; - default: - if (!xdr_mkdir3resfail (xdrs, &objp->mkdir3res_u.resfail)) - return FALSE; - break; - } - return TRUE; + if (!xdr_post_op_fh3(xdrs, &objp->obj)) + return FALSE; + if (!xdr_post_op_attr(xdrs, &objp->obj_attributes)) + return FALSE; + if (!xdr_wcc_data(xdrs, &objp->dir_wcc)) + return FALSE; + return TRUE; } bool_t -xdr_symlinkdata3 (XDR *xdrs, symlinkdata3 *objp) +xdr_symlink3resfail(XDR *xdrs, symlink3resfail *objp) { - if (!xdr_sattr3 (xdrs, &objp->symlink_attributes)) - return FALSE; - if (!xdr_nfspath3 (xdrs, &objp->symlink_data)) - return FALSE; - return TRUE; + if (!xdr_wcc_data(xdrs, &objp->dir_wcc)) + return FALSE; + return TRUE; } bool_t -xdr_symlink3args (XDR *xdrs, symlink3args *objp) +xdr_symlink3res(XDR *xdrs, symlink3res *objp) { - if (!xdr_diropargs3 (xdrs, &objp->where)) - return FALSE; - if (!xdr_symlinkdata3 (xdrs, &objp->symlink)) - return FALSE; - return TRUE; + if (!xdr_nfsstat3(xdrs, &objp->status)) + return FALSE; + switch (objp->status) { + case NFS3_OK: + if (!xdr_symlink3resok(xdrs, &objp->symlink3res_u.resok)) + return FALSE; + break; + default: + if (!xdr_symlink3resfail(xdrs, &objp->symlink3res_u.resfail)) + return FALSE; + break; + } + return TRUE; } bool_t -xdr_symlink3resok (XDR *xdrs, symlink3resok *objp) +xdr_devicedata3(XDR *xdrs, devicedata3 *objp) { - if (!xdr_post_op_fh3 (xdrs, &objp->obj)) - return FALSE; - if (!xdr_post_op_attr (xdrs, &objp->obj_attributes)) - return FALSE; - if (!xdr_wcc_data (xdrs, &objp->dir_wcc)) - return FALSE; - return TRUE; + if (!xdr_sattr3(xdrs, &objp->dev_attributes)) + return FALSE; + if (!xdr_specdata3(xdrs, &objp->spec)) + return FALSE; + return TRUE; } bool_t -xdr_symlink3resfail (XDR *xdrs, symlink3resfail *objp) +xdr_mknoddata3(XDR *xdrs, mknoddata3 *objp) { - if (!xdr_wcc_data (xdrs, &objp->dir_wcc)) - return FALSE; - return TRUE; + if (!xdr_ftype3(xdrs, &objp->type)) + return FALSE; + switch (objp->type) { + case NF3CHR: + case NF3BLK: + if (!xdr_devicedata3(xdrs, &objp->mknoddata3_u.device)) + return FALSE; + break; + case NF3SOCK: + case NF3FIFO: + if (!xdr_sattr3(xdrs, &objp->mknoddata3_u.pipe_attributes)) + return FALSE; + break; + default: + break; + } + return TRUE; } bool_t -xdr_symlink3res (XDR *xdrs, symlink3res *objp) +xdr_mknod3args(XDR *xdrs, mknod3args *objp) { - if (!xdr_nfsstat3 (xdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS3_OK: - if (!xdr_symlink3resok (xdrs, &objp->symlink3res_u.resok)) - return FALSE; - break; - default: - if (!xdr_symlink3resfail (xdrs, &objp->symlink3res_u.resfail)) - return FALSE; - break; - } - return TRUE; + if (!xdr_diropargs3(xdrs, &objp->where)) + return FALSE; + if (!xdr_mknoddata3(xdrs, &objp->what)) + return FALSE; + return TRUE; } bool_t -xdr_devicedata3 (XDR *xdrs, devicedata3 *objp) +xdr_mknod3resok(XDR *xdrs, mknod3resok *objp) { - if (!xdr_sattr3 (xdrs, &objp->dev_attributes)) - return FALSE; - if (!xdr_specdata3 (xdrs, &objp->spec)) - return FALSE; - return TRUE; + if (!xdr_post_op_fh3(xdrs, &objp->obj)) + return FALSE; + if (!xdr_post_op_attr(xdrs, &objp->obj_attributes)) + return FALSE; + if (!xdr_wcc_data(xdrs, &objp->dir_wcc)) + return FALSE; + return TRUE; } bool_t -xdr_mknoddata3 (XDR *xdrs, mknoddata3 *objp) +xdr_mknod3resfail(XDR *xdrs, mknod3resfail *objp) { - if (!xdr_ftype3 (xdrs, &objp->type)) - return FALSE; - switch (objp->type) { - case NF3CHR: - case NF3BLK: - if (!xdr_devicedata3 (xdrs, &objp->mknoddata3_u.device)) - return FALSE; - break; - case NF3SOCK: - case NF3FIFO: - if (!xdr_sattr3 (xdrs, &objp->mknoddata3_u.pipe_attributes)) - return FALSE; - break; - default: - break; - } - return TRUE; + if (!xdr_wcc_data(xdrs, &objp->dir_wcc)) + return FALSE; + return TRUE; } bool_t -xdr_mknod3args (XDR *xdrs, mknod3args *objp) +xdr_mknod3res(XDR *xdrs, mknod3res *objp) { - if (!xdr_diropargs3 (xdrs, &objp->where)) - return FALSE; - if (!xdr_mknoddata3 (xdrs, &objp->what)) - return FALSE; - return TRUE; + if (!xdr_nfsstat3(xdrs, &objp->status)) + return FALSE; + switch (objp->status) { + case NFS3_OK: + if (!xdr_mknod3resok(xdrs, &objp->mknod3res_u.resok)) + return FALSE; + break; + default: + if (!xdr_mknod3resfail(xdrs, &objp->mknod3res_u.resfail)) + return FALSE; + break; + } + return TRUE; } bool_t -xdr_mknod3resok (XDR *xdrs, mknod3resok *objp) +xdr_remove3args(XDR *xdrs, remove3args *objp) { - if (!xdr_post_op_fh3 (xdrs, &objp->obj)) - return FALSE; - if (!xdr_post_op_attr (xdrs, &objp->obj_attributes)) - return FALSE; - if (!xdr_wcc_data (xdrs, &objp->dir_wcc)) - return FALSE; - return TRUE; + if (!xdr_diropargs3(xdrs, &objp->object)) + return FALSE; + return TRUE; } bool_t -xdr_mknod3resfail (XDR *xdrs, mknod3resfail *objp) +xdr_remove3resok(XDR *xdrs, remove3resok *objp) { - if (!xdr_wcc_data (xdrs, &objp->dir_wcc)) - return FALSE; - return TRUE; + if (!xdr_wcc_data(xdrs, &objp->dir_wcc)) + return FALSE; + return TRUE; } bool_t -xdr_mknod3res (XDR *xdrs, mknod3res *objp) +xdr_remove3resfail(XDR *xdrs, remove3resfail *objp) { - if (!xdr_nfsstat3 (xdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS3_OK: - if (!xdr_mknod3resok (xdrs, &objp->mknod3res_u.resok)) - return FALSE; - break; - default: - if (!xdr_mknod3resfail (xdrs, &objp->mknod3res_u.resfail)) - return FALSE; - break; - } - return TRUE; + if (!xdr_wcc_data(xdrs, &objp->dir_wcc)) + return FALSE; + return TRUE; } bool_t -xdr_remove3args (XDR *xdrs, remove3args *objp) +xdr_remove3res(XDR *xdrs, remove3res *objp) { - if (!xdr_diropargs3 (xdrs, &objp->object)) - return FALSE; - return TRUE; + if (!xdr_nfsstat3(xdrs, &objp->status)) + return FALSE; + switch (objp->status) { + case NFS3_OK: + if (!xdr_remove3resok(xdrs, &objp->remove3res_u.resok)) + return FALSE; + break; + default: + if (!xdr_remove3resfail(xdrs, &objp->remove3res_u.resfail)) + return FALSE; + break; + } + return TRUE; } bool_t -xdr_remove3resok (XDR *xdrs, remove3resok *objp) +xdr_rmdir3args(XDR *xdrs, rmdir3args *objp) { - if (!xdr_wcc_data (xdrs, &objp->dir_wcc)) - return FALSE; - return TRUE; + if (!xdr_diropargs3(xdrs, &objp->object)) + return FALSE; + return TRUE; } bool_t -xdr_remove3resfail (XDR *xdrs, remove3resfail *objp) +xdr_rmdir3resok(XDR *xdrs, rmdir3resok *objp) { - if (!xdr_wcc_data (xdrs, &objp->dir_wcc)) - return FALSE; - return TRUE; + if (!xdr_wcc_data(xdrs, &objp->dir_wcc)) + return FALSE; + return TRUE; } bool_t -xdr_remove3res (XDR *xdrs, remove3res *objp) +xdr_rmdir3resfail(XDR *xdrs, rmdir3resfail *objp) { - if (!xdr_nfsstat3 (xdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS3_OK: - if (!xdr_remove3resok (xdrs, &objp->remove3res_u.resok)) - return FALSE; - break; - default: - if (!xdr_remove3resfail (xdrs, &objp->remove3res_u.resfail)) - return FALSE; - break; - } - return TRUE; + if (!xdr_wcc_data(xdrs, &objp->dir_wcc)) + return FALSE; + return TRUE; } bool_t -xdr_rmdir3args (XDR *xdrs, rmdir3args *objp) +xdr_rmdir3res(XDR *xdrs, rmdir3res *objp) { - if (!xdr_diropargs3 (xdrs, &objp->object)) - return FALSE; - return TRUE; + if (!xdr_nfsstat3(xdrs, &objp->status)) + return FALSE; + switch (objp->status) { + case NFS3_OK: + if (!xdr_rmdir3resok(xdrs, &objp->rmdir3res_u.resok)) + return FALSE; + break; + default: + if (!xdr_rmdir3resfail(xdrs, &objp->rmdir3res_u.resfail)) + return FALSE; + break; + } + return TRUE; } bool_t -xdr_rmdir3resok (XDR *xdrs, rmdir3resok *objp) +xdr_rename3args(XDR *xdrs, rename3args *objp) { - if (!xdr_wcc_data (xdrs, &objp->dir_wcc)) - return FALSE; - return TRUE; + if (!xdr_diropargs3(xdrs, &objp->from)) + return FALSE; + if (!xdr_diropargs3(xdrs, &objp->to)) + return FALSE; + return TRUE; } bool_t -xdr_rmdir3resfail (XDR *xdrs, rmdir3resfail *objp) +xdr_rename3resok(XDR *xdrs, rename3resok *objp) { - if (!xdr_wcc_data (xdrs, &objp->dir_wcc)) - return FALSE; - return TRUE; + if (!xdr_wcc_data(xdrs, &objp->fromdir_wcc)) + return FALSE; + if (!xdr_wcc_data(xdrs, &objp->todir_wcc)) + return FALSE; + return TRUE; } bool_t -xdr_rmdir3res (XDR *xdrs, rmdir3res *objp) +xdr_rename3resfail(XDR *xdrs, rename3resfail *objp) { - if (!xdr_nfsstat3 (xdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS3_OK: - if (!xdr_rmdir3resok (xdrs, &objp->rmdir3res_u.resok)) - return FALSE; - break; - default: - if (!xdr_rmdir3resfail (xdrs, &objp->rmdir3res_u.resfail)) - return FALSE; - break; - } - return TRUE; + if (!xdr_wcc_data(xdrs, &objp->fromdir_wcc)) + return FALSE; + if (!xdr_wcc_data(xdrs, &objp->todir_wcc)) + return FALSE; + return TRUE; } bool_t -xdr_rename3args (XDR *xdrs, rename3args *objp) +xdr_rename3res(XDR *xdrs, rename3res *objp) { - if (!xdr_diropargs3 (xdrs, &objp->from)) - return FALSE; - if (!xdr_diropargs3 (xdrs, &objp->to)) - return FALSE; - return TRUE; + if (!xdr_nfsstat3(xdrs, &objp->status)) + return FALSE; + switch (objp->status) { + case NFS3_OK: + if (!xdr_rename3resok(xdrs, &objp->rename3res_u.resok)) + return FALSE; + break; + default: + if (!xdr_rename3resfail(xdrs, &objp->rename3res_u.resfail)) + return FALSE; + break; + } + return TRUE; } bool_t -xdr_rename3resok (XDR *xdrs, rename3resok *objp) +xdr_link3args(XDR *xdrs, link3args *objp) { - if (!xdr_wcc_data (xdrs, &objp->fromdir_wcc)) - return FALSE; - if (!xdr_wcc_data (xdrs, &objp->todir_wcc)) - return FALSE; - return TRUE; + if (!xdr_nfs_fh3(xdrs, &objp->file)) + return FALSE; + if (!xdr_diropargs3(xdrs, &objp->link)) + return FALSE; + return TRUE; } bool_t -xdr_rename3resfail (XDR *xdrs, rename3resfail *objp) +xdr_link3resok(XDR *xdrs, link3resok *objp) { - if (!xdr_wcc_data (xdrs, &objp->fromdir_wcc)) - return FALSE; - if (!xdr_wcc_data (xdrs, &objp->todir_wcc)) - return FALSE; - return TRUE; + if (!xdr_post_op_attr(xdrs, &objp->file_attributes)) + return FALSE; + if (!xdr_wcc_data(xdrs, &objp->linkdir_wcc)) + return FALSE; + return TRUE; } bool_t -xdr_rename3res (XDR *xdrs, rename3res *objp) +xdr_link3resfail(XDR *xdrs, link3resfail *objp) { - if (!xdr_nfsstat3 (xdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS3_OK: - if (!xdr_rename3resok (xdrs, &objp->rename3res_u.resok)) - return FALSE; - break; - default: - if (!xdr_rename3resfail (xdrs, &objp->rename3res_u.resfail)) - return FALSE; - break; - } - return TRUE; + if (!xdr_post_op_attr(xdrs, &objp->file_attributes)) + return FALSE; + if (!xdr_wcc_data(xdrs, &objp->linkdir_wcc)) + return FALSE; + return TRUE; } bool_t -xdr_link3args (XDR *xdrs, link3args *objp) +xdr_link3res(XDR *xdrs, link3res *objp) { - if (!xdr_nfs_fh3 (xdrs, &objp->file)) - return FALSE; - if (!xdr_diropargs3 (xdrs, &objp->link)) - return FALSE; - return TRUE; + if (!xdr_nfsstat3(xdrs, &objp->status)) + return FALSE; + switch (objp->status) { + case NFS3_OK: + if (!xdr_link3resok(xdrs, &objp->link3res_u.resok)) + return FALSE; + break; + default: + if (!xdr_link3resfail(xdrs, &objp->link3res_u.resfail)) + return FALSE; + break; + } + return TRUE; } bool_t -xdr_link3resok (XDR *xdrs, link3resok *objp) +xdr_readdir3args(XDR *xdrs, readdir3args *objp) { - if (!xdr_post_op_attr (xdrs, &objp->file_attributes)) - return FALSE; - if (!xdr_wcc_data (xdrs, &objp->linkdir_wcc)) - return FALSE; - return TRUE; + if (!xdr_nfs_fh3(xdrs, &objp->dir)) + return FALSE; + if (!xdr_cookie3(xdrs, &objp->cookie)) + return FALSE; + if (!xdr_cookieverf3(xdrs, objp->cookieverf)) + return FALSE; + if (!xdr_count3(xdrs, &objp->count)) + return FALSE; + return TRUE; } bool_t -xdr_link3resfail (XDR *xdrs, link3resfail *objp) +xdr_entry3(XDR *xdrs, entry3 *objp) { - if (!xdr_post_op_attr (xdrs, &objp->file_attributes)) - return FALSE; - if (!xdr_wcc_data (xdrs, &objp->linkdir_wcc)) - return FALSE; - return TRUE; + if (!xdr_fileid3(xdrs, &objp->fileid)) + return FALSE; + if (!xdr_filename3(xdrs, &objp->name)) + return FALSE; + if (!xdr_cookie3(xdrs, &objp->cookie)) + return FALSE; + if (!xdr_pointer(xdrs, (char **)&objp->nextentry, sizeof(entry3), + (xdrproc_t)xdr_entry3)) + return FALSE; + return TRUE; } bool_t -xdr_link3res (XDR *xdrs, link3res *objp) +xdr_dirlist3(XDR *xdrs, dirlist3 *objp) { - if (!xdr_nfsstat3 (xdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS3_OK: - if (!xdr_link3resok (xdrs, &objp->link3res_u.resok)) - return FALSE; - break; - default: - if (!xdr_link3resfail (xdrs, &objp->link3res_u.resfail)) - return FALSE; - break; - } - return TRUE; + if (!xdr_pointer(xdrs, (char **)&objp->entries, sizeof(entry3), + (xdrproc_t)xdr_entry3)) + return FALSE; + if (!xdr_bool(xdrs, &objp->eof)) + return FALSE; + return TRUE; } bool_t -xdr_readdir3args (XDR *xdrs, readdir3args *objp) +xdr_readdir3resok(XDR *xdrs, readdir3resok *objp) { - if (!xdr_nfs_fh3 (xdrs, &objp->dir)) - return FALSE; - if (!xdr_cookie3 (xdrs, &objp->cookie)) - return FALSE; - if (!xdr_cookieverf3 (xdrs, objp->cookieverf)) - return FALSE; - if (!xdr_count3 (xdrs, &objp->count)) - return FALSE; - return TRUE; + if (!xdr_post_op_attr(xdrs, &objp->dir_attributes)) + return FALSE; + if (!xdr_cookieverf3(xdrs, objp->cookieverf)) + return FALSE; + if (!xdr_dirlist3(xdrs, &objp->reply)) + return FALSE; + return TRUE; } bool_t -xdr_entry3 (XDR *xdrs, entry3 *objp) +xdr_readdir3resfail(XDR *xdrs, readdir3resfail *objp) { - if (!xdr_fileid3 (xdrs, &objp->fileid)) - return FALSE; - if (!xdr_filename3 (xdrs, &objp->name)) - return FALSE; - if (!xdr_cookie3 (xdrs, &objp->cookie)) - return FALSE; - if (!xdr_pointer (xdrs, (char **)&objp->nextentry, sizeof (entry3), (xdrproc_t) xdr_entry3)) - return FALSE; - return TRUE; + if (!xdr_post_op_attr(xdrs, &objp->dir_attributes)) + return FALSE; + return TRUE; } bool_t -xdr_dirlist3 (XDR *xdrs, dirlist3 *objp) +xdr_readdir3res(XDR *xdrs, readdir3res *objp) { - if (!xdr_pointer (xdrs, (char **)&objp->entries, sizeof (entry3), (xdrproc_t) xdr_entry3)) - return FALSE; - if (!xdr_bool (xdrs, &objp->eof)) - return FALSE; - return TRUE; + if (!xdr_nfsstat3(xdrs, &objp->status)) + return FALSE; + switch (objp->status) { + case NFS3_OK: + if (!xdr_readdir3resok(xdrs, &objp->readdir3res_u.resok)) + return FALSE; + break; + default: + if (!xdr_readdir3resfail(xdrs, &objp->readdir3res_u.resfail)) + return FALSE; + break; + } + return TRUE; } bool_t -xdr_readdir3resok (XDR *xdrs, readdir3resok *objp) +xdr_readdirp3args(XDR *xdrs, readdirp3args *objp) { - if (!xdr_post_op_attr (xdrs, &objp->dir_attributes)) - return FALSE; - if (!xdr_cookieverf3 (xdrs, objp->cookieverf)) - return FALSE; - if (!xdr_dirlist3 (xdrs, &objp->reply)) - return FALSE; - return TRUE; + if (!xdr_nfs_fh3(xdrs, &objp->dir)) + return FALSE; + if (!xdr_cookie3(xdrs, &objp->cookie)) + return FALSE; + if (!xdr_cookieverf3(xdrs, objp->cookieverf)) + return FALSE; + if (!xdr_count3(xdrs, &objp->dircount)) + return FALSE; + if (!xdr_count3(xdrs, &objp->maxcount)) + return FALSE; + return TRUE; } bool_t -xdr_readdir3resfail (XDR *xdrs, readdir3resfail *objp) +xdr_entryp3(XDR *xdrs, entryp3 *objp) { - if (!xdr_post_op_attr (xdrs, &objp->dir_attributes)) - return FALSE; - return TRUE; + if (!xdr_fileid3(xdrs, &objp->fileid)) + return FALSE; + if (!xdr_filename3(xdrs, &objp->name)) + return FALSE; + if (!xdr_cookie3(xdrs, &objp->cookie)) + return FALSE; + if (!xdr_post_op_attr(xdrs, &objp->name_attributes)) + return FALSE; + if (!xdr_post_op_fh3(xdrs, &objp->name_handle)) + return FALSE; + if (!xdr_pointer(xdrs, (char **)&objp->nextentry, sizeof(entryp3), + (xdrproc_t)xdr_entryp3)) + return FALSE; + return TRUE; } bool_t -xdr_readdir3res (XDR *xdrs, readdir3res *objp) +xdr_dirlistp3(XDR *xdrs, dirlistp3 *objp) { - if (!xdr_nfsstat3 (xdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS3_OK: - if (!xdr_readdir3resok (xdrs, &objp->readdir3res_u.resok)) - return FALSE; - break; - default: - if (!xdr_readdir3resfail (xdrs, &objp->readdir3res_u.resfail)) - return FALSE; - break; - } - return TRUE; + if (!xdr_pointer(xdrs, (char **)&objp->entries, sizeof(entryp3), + (xdrproc_t)xdr_entryp3)) + return FALSE; + if (!xdr_bool(xdrs, &objp->eof)) + return FALSE; + return TRUE; } bool_t -xdr_readdirp3args (XDR *xdrs, readdirp3args *objp) +xdr_readdirp3resok(XDR *xdrs, readdirp3resok *objp) { - if (!xdr_nfs_fh3 (xdrs, &objp->dir)) - return FALSE; - if (!xdr_cookie3 (xdrs, &objp->cookie)) - return FALSE; - if (!xdr_cookieverf3 (xdrs, objp->cookieverf)) - return FALSE; - if (!xdr_count3 (xdrs, &objp->dircount)) - return FALSE; - if (!xdr_count3 (xdrs, &objp->maxcount)) - return FALSE; - return TRUE; + if (!xdr_post_op_attr(xdrs, &objp->dir_attributes)) + return FALSE; + if (!xdr_cookieverf3(xdrs, objp->cookieverf)) + return FALSE; + if (!xdr_dirlistp3(xdrs, &objp->reply)) + return FALSE; + return TRUE; } bool_t -xdr_entryp3 (XDR *xdrs, entryp3 *objp) +xdr_readdirp3resfail(XDR *xdrs, readdirp3resfail *objp) { - if (!xdr_fileid3 (xdrs, &objp->fileid)) - return FALSE; - if (!xdr_filename3 (xdrs, &objp->name)) - return FALSE; - if (!xdr_cookie3 (xdrs, &objp->cookie)) - return FALSE; - if (!xdr_post_op_attr (xdrs, &objp->name_attributes)) - return FALSE; - if (!xdr_post_op_fh3 (xdrs, &objp->name_handle)) - return FALSE; - if (!xdr_pointer (xdrs, (char **)&objp->nextentry, sizeof (entryp3), (xdrproc_t) xdr_entryp3)) - return FALSE; - return TRUE; + if (!xdr_post_op_attr(xdrs, &objp->dir_attributes)) + return FALSE; + return TRUE; } bool_t -xdr_dirlistp3 (XDR *xdrs, dirlistp3 *objp) +xdr_readdirp3res(XDR *xdrs, readdirp3res *objp) { - if (!xdr_pointer (xdrs, (char **)&objp->entries, sizeof (entryp3), (xdrproc_t) xdr_entryp3)) - return FALSE; - if (!xdr_bool (xdrs, &objp->eof)) - return FALSE; - return TRUE; + if (!xdr_nfsstat3(xdrs, &objp->status)) + return FALSE; + switch (objp->status) { + case NFS3_OK: + if (!xdr_readdirp3resok(xdrs, &objp->readdirp3res_u.resok)) + return FALSE; + break; + default: + if (!xdr_readdirp3resfail(xdrs, &objp->readdirp3res_u.resfail)) + return FALSE; + break; + } + return TRUE; } bool_t -xdr_readdirp3resok (XDR *xdrs, readdirp3resok *objp) +xdr_fsstat3args(XDR *xdrs, fsstat3args *objp) { - if (!xdr_post_op_attr (xdrs, &objp->dir_attributes)) - return FALSE; - if (!xdr_cookieverf3 (xdrs, objp->cookieverf)) - return FALSE; - if (!xdr_dirlistp3 (xdrs, &objp->reply)) - return FALSE; - return TRUE; + if (!xdr_nfs_fh3(xdrs, &objp->fsroot)) + return FALSE; + return TRUE; } bool_t -xdr_readdirp3resfail (XDR *xdrs, readdirp3resfail *objp) +xdr_fsstat3resok(XDR *xdrs, fsstat3resok *objp) { - if (!xdr_post_op_attr (xdrs, &objp->dir_attributes)) - return FALSE; - return TRUE; + if (!xdr_post_op_attr(xdrs, &objp->obj_attributes)) + return FALSE; + if (!xdr_size3(xdrs, &objp->tbytes)) + return FALSE; + if (!xdr_size3(xdrs, &objp->fbytes)) + return FALSE; + if (!xdr_size3(xdrs, &objp->abytes)) + return FALSE; + if (!xdr_size3(xdrs, &objp->tfiles)) + return FALSE; + if (!xdr_size3(xdrs, &objp->ffiles)) + return FALSE; + if (!xdr_size3(xdrs, &objp->afiles)) + return FALSE; + if (!xdr_uint32(xdrs, &objp->invarsec)) + return FALSE; + return TRUE; } bool_t -xdr_readdirp3res (XDR *xdrs, readdirp3res *objp) +xdr_fsstat3resfail(XDR *xdrs, fsstat3resfail *objp) { - if (!xdr_nfsstat3 (xdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS3_OK: - if (!xdr_readdirp3resok (xdrs, &objp->readdirp3res_u.resok)) - return FALSE; - break; - default: - if (!xdr_readdirp3resfail (xdrs, &objp->readdirp3res_u.resfail)) - return FALSE; - break; - } - return TRUE; + if (!xdr_post_op_attr(xdrs, &objp->obj_attributes)) + return FALSE; + return TRUE; } bool_t -xdr_fsstat3args (XDR *xdrs, fsstat3args *objp) +xdr_fsstat3res(XDR *xdrs, fsstat3res *objp) { - if (!xdr_nfs_fh3 (xdrs, &objp->fsroot)) - return FALSE; - return TRUE; + if (!xdr_nfsstat3(xdrs, &objp->status)) + return FALSE; + switch (objp->status) { + case NFS3_OK: + if (!xdr_fsstat3resok(xdrs, &objp->fsstat3res_u.resok)) + return FALSE; + break; + default: + if (!xdr_fsstat3resfail(xdrs, &objp->fsstat3res_u.resfail)) + return FALSE; + break; + } + return TRUE; } bool_t -xdr_fsstat3resok (XDR *xdrs, fsstat3resok *objp) +xdr_fsinfo3args(XDR *xdrs, fsinfo3args *objp) { - if (!xdr_post_op_attr (xdrs, &objp->obj_attributes)) - return FALSE; - if (!xdr_size3 (xdrs, &objp->tbytes)) - return FALSE; - if (!xdr_size3 (xdrs, &objp->fbytes)) - return FALSE; - if (!xdr_size3 (xdrs, &objp->abytes)) - return FALSE; - if (!xdr_size3 (xdrs, &objp->tfiles)) - return FALSE; - if (!xdr_size3 (xdrs, &objp->ffiles)) - return FALSE; - if (!xdr_size3 (xdrs, &objp->afiles)) - return FALSE; - if (!xdr_uint32 (xdrs, &objp->invarsec)) - return FALSE; - return TRUE; + if (!xdr_nfs_fh3(xdrs, &objp->fsroot)) + return FALSE; + return TRUE; } bool_t -xdr_fsstat3resfail (XDR *xdrs, fsstat3resfail *objp) +xdr_fsinfo3resok(XDR *xdrs, fsinfo3resok *objp) { - if (!xdr_post_op_attr (xdrs, &objp->obj_attributes)) - return FALSE; - return TRUE; + if (!xdr_post_op_attr(xdrs, &objp->obj_attributes)) + return FALSE; + if (!xdr_uint32(xdrs, &objp->rtmax)) + return FALSE; + if (!xdr_uint32(xdrs, &objp->rtpref)) + return FALSE; + if (!xdr_uint32(xdrs, &objp->rtmult)) + return FALSE; + if (!xdr_uint32(xdrs, &objp->wtmax)) + return FALSE; + if (!xdr_uint32(xdrs, &objp->wtpref)) + return FALSE; + if (!xdr_uint32(xdrs, &objp->wtmult)) + return FALSE; + if (!xdr_uint32(xdrs, &objp->dtpref)) + return FALSE; + if (!xdr_size3(xdrs, &objp->maxfilesize)) + return FALSE; + if (!xdr_nfstime3(xdrs, &objp->time_delta)) + return FALSE; + if (!xdr_uint32(xdrs, &objp->properties)) + return FALSE; + return TRUE; } bool_t -xdr_fsstat3res (XDR *xdrs, fsstat3res *objp) +xdr_fsinfo3resfail(XDR *xdrs, fsinfo3resfail *objp) { - if (!xdr_nfsstat3 (xdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS3_OK: - if (!xdr_fsstat3resok (xdrs, &objp->fsstat3res_u.resok)) - return FALSE; - break; - default: - if (!xdr_fsstat3resfail (xdrs, &objp->fsstat3res_u.resfail)) - return FALSE; - break; - } - return TRUE; + if (!xdr_post_op_attr(xdrs, &objp->obj_attributes)) + return FALSE; + return TRUE; } bool_t -xdr_fsinfo3args (XDR *xdrs, fsinfo3args *objp) +xdr_fsinfo3res(XDR *xdrs, fsinfo3res *objp) { - if (!xdr_nfs_fh3 (xdrs, &objp->fsroot)) - return FALSE; - return TRUE; + if (!xdr_nfsstat3(xdrs, &objp->status)) + return FALSE; + switch (objp->status) { + case NFS3_OK: + if (!xdr_fsinfo3resok(xdrs, &objp->fsinfo3res_u.resok)) + return FALSE; + break; + default: + if (!xdr_fsinfo3resfail(xdrs, &objp->fsinfo3res_u.resfail)) + return FALSE; + break; + } + return TRUE; +} + +bool_t +xdr_pathconf3args(XDR *xdrs, pathconf3args *objp) +{ + if (!xdr_nfs_fh3(xdrs, &objp->object)) + return FALSE; + return TRUE; } bool_t -xdr_fsinfo3resok (XDR *xdrs, fsinfo3resok *objp) +xdr_pathconf3resok(XDR *xdrs, pathconf3resok *objp) { - if (!xdr_post_op_attr (xdrs, &objp->obj_attributes)) - return FALSE; - if (!xdr_uint32 (xdrs, &objp->rtmax)) - return FALSE; - if (!xdr_uint32 (xdrs, &objp->rtpref)) - return FALSE; - if (!xdr_uint32 (xdrs, &objp->rtmult)) - return FALSE; - if (!xdr_uint32 (xdrs, &objp->wtmax)) - return FALSE; - if (!xdr_uint32 (xdrs, &objp->wtpref)) - return FALSE; - if (!xdr_uint32 (xdrs, &objp->wtmult)) - return FALSE; - if (!xdr_uint32 (xdrs, &objp->dtpref)) - return FALSE; - if (!xdr_size3 (xdrs, &objp->maxfilesize)) - return FALSE; - if (!xdr_nfstime3 (xdrs, &objp->time_delta)) - return FALSE; - if (!xdr_uint32 (xdrs, &objp->properties)) - return FALSE; - return TRUE; -} - -bool_t -xdr_fsinfo3resfail (XDR *xdrs, fsinfo3resfail *objp) -{ - if (!xdr_post_op_attr (xdrs, &objp->obj_attributes)) - return FALSE; - return TRUE; -} - -bool_t -xdr_fsinfo3res (XDR *xdrs, fsinfo3res *objp) -{ - if (!xdr_nfsstat3 (xdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS3_OK: - if (!xdr_fsinfo3resok (xdrs, &objp->fsinfo3res_u.resok)) - return FALSE; - break; - default: - if (!xdr_fsinfo3resfail (xdrs, &objp->fsinfo3res_u.resfail)) - return FALSE; - break; - } - return TRUE; -} - -bool_t -xdr_pathconf3args (XDR *xdrs, pathconf3args *objp) -{ - if (!xdr_nfs_fh3 (xdrs, &objp->object)) - return FALSE; - return TRUE; -} - -bool_t -xdr_pathconf3resok (XDR *xdrs, pathconf3resok *objp) -{ - register int32_t *buf; - - - if (xdrs->x_op == XDR_ENCODE) { - if (!xdr_post_op_attr (xdrs, &objp->obj_attributes)) - return FALSE; - if (!xdr_uint32 (xdrs, &objp->linkmax)) - return FALSE; - if (!xdr_uint32 (xdrs, &objp->name_max)) - return FALSE; - buf = XDR_INLINE (xdrs, 4 * BYTES_PER_XDR_UNIT); - if (buf == NULL) { - if (!xdr_bool (xdrs, &objp->no_trunc)) - return FALSE; - if (!xdr_bool (xdrs, &objp->chown_restricted)) - return FALSE; - if (!xdr_bool (xdrs, &objp->case_insensitive)) - return FALSE; - if (!xdr_bool (xdrs, &objp->case_preserving)) - return FALSE; - } else { - IXDR_PUT_BOOL(buf, objp->no_trunc); - IXDR_PUT_BOOL(buf, objp->chown_restricted); - IXDR_PUT_BOOL(buf, objp->case_insensitive); - IXDR_PUT_BOOL(buf, objp->case_preserving); - } - return TRUE; - } else if (xdrs->x_op == XDR_DECODE) { - if (!xdr_post_op_attr (xdrs, &objp->obj_attributes)) - return FALSE; - if (!xdr_uint32 (xdrs, &objp->linkmax)) - return FALSE; - if (!xdr_uint32 (xdrs, &objp->name_max)) - return FALSE; - buf = XDR_INLINE (xdrs, 4 * BYTES_PER_XDR_UNIT); - if (buf == NULL) { - if (!xdr_bool (xdrs, &objp->no_trunc)) - return FALSE; - if (!xdr_bool (xdrs, &objp->chown_restricted)) - return FALSE; - if (!xdr_bool (xdrs, &objp->case_insensitive)) - return FALSE; - if (!xdr_bool (xdrs, &objp->case_preserving)) - return FALSE; - } else { - objp->no_trunc = IXDR_GET_BOOL(buf); - objp->chown_restricted = IXDR_GET_BOOL(buf); - objp->case_insensitive = IXDR_GET_BOOL(buf); - objp->case_preserving = IXDR_GET_BOOL(buf); - } - return TRUE; - } + register int32_t *buf; + + if (xdrs->x_op == XDR_ENCODE) { + if (!xdr_post_op_attr(xdrs, &objp->obj_attributes)) + return FALSE; + if (!xdr_uint32(xdrs, &objp->linkmax)) + return FALSE; + if (!xdr_uint32(xdrs, &objp->name_max)) + return FALSE; + buf = XDR_INLINE(xdrs, 4 * BYTES_PER_XDR_UNIT); + if (buf == NULL) { + if (!xdr_bool(xdrs, &objp->no_trunc)) + return FALSE; + if (!xdr_bool(xdrs, &objp->chown_restricted)) + return FALSE; + if (!xdr_bool(xdrs, &objp->case_insensitive)) + return FALSE; + if (!xdr_bool(xdrs, &objp->case_preserving)) + return FALSE; + } else { + IXDR_PUT_BOOL(buf, objp->no_trunc); + IXDR_PUT_BOOL(buf, objp->chown_restricted); + IXDR_PUT_BOOL(buf, objp->case_insensitive); + IXDR_PUT_BOOL(buf, objp->case_preserving); + } + return TRUE; + } else if (xdrs->x_op == XDR_DECODE) { + if (!xdr_post_op_attr(xdrs, &objp->obj_attributes)) + return FALSE; + if (!xdr_uint32(xdrs, &objp->linkmax)) + return FALSE; + if (!xdr_uint32(xdrs, &objp->name_max)) + return FALSE; + buf = XDR_INLINE(xdrs, 4 * BYTES_PER_XDR_UNIT); + if (buf == NULL) { + if (!xdr_bool(xdrs, &objp->no_trunc)) + return FALSE; + if (!xdr_bool(xdrs, &objp->chown_restricted)) + return FALSE; + if (!xdr_bool(xdrs, &objp->case_insensitive)) + return FALSE; + if (!xdr_bool(xdrs, &objp->case_preserving)) + return FALSE; + } else { + objp->no_trunc = IXDR_GET_BOOL(buf); + objp->chown_restricted = IXDR_GET_BOOL(buf); + objp->case_insensitive = IXDR_GET_BOOL(buf); + objp->case_preserving = IXDR_GET_BOOL(buf); + } + return TRUE; + } - if (!xdr_post_op_attr (xdrs, &objp->obj_attributes)) - return FALSE; - if (!xdr_uint32 (xdrs, &objp->linkmax)) - return FALSE; - if (!xdr_uint32 (xdrs, &objp->name_max)) - return FALSE; - if (!xdr_bool (xdrs, &objp->no_trunc)) - return FALSE; - if (!xdr_bool (xdrs, &objp->chown_restricted)) - return FALSE; - if (!xdr_bool (xdrs, &objp->case_insensitive)) - return FALSE; - if (!xdr_bool (xdrs, &objp->case_preserving)) - return FALSE; - return TRUE; + if (!xdr_post_op_attr(xdrs, &objp->obj_attributes)) + return FALSE; + if (!xdr_uint32(xdrs, &objp->linkmax)) + return FALSE; + if (!xdr_uint32(xdrs, &objp->name_max)) + return FALSE; + if (!xdr_bool(xdrs, &objp->no_trunc)) + return FALSE; + if (!xdr_bool(xdrs, &objp->chown_restricted)) + return FALSE; + if (!xdr_bool(xdrs, &objp->case_insensitive)) + return FALSE; + if (!xdr_bool(xdrs, &objp->case_preserving)) + return FALSE; + return TRUE; } bool_t -xdr_pathconf3resfail (XDR *xdrs, pathconf3resfail *objp) +xdr_pathconf3resfail(XDR *xdrs, pathconf3resfail *objp) { - if (!xdr_post_op_attr (xdrs, &objp->obj_attributes)) - return FALSE; - return TRUE; + if (!xdr_post_op_attr(xdrs, &objp->obj_attributes)) + return FALSE; + return TRUE; } bool_t -xdr_pathconf3res (XDR *xdrs, pathconf3res *objp) +xdr_pathconf3res(XDR *xdrs, pathconf3res *objp) { - if (!xdr_nfsstat3 (xdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS3_OK: - if (!xdr_pathconf3resok (xdrs, &objp->pathconf3res_u.resok)) - return FALSE; - break; - default: - if (!xdr_pathconf3resfail (xdrs, &objp->pathconf3res_u.resfail)) - return FALSE; - break; - } - return TRUE; + if (!xdr_nfsstat3(xdrs, &objp->status)) + return FALSE; + switch (objp->status) { + case NFS3_OK: + if (!xdr_pathconf3resok(xdrs, &objp->pathconf3res_u.resok)) + return FALSE; + break; + default: + if (!xdr_pathconf3resfail(xdrs, &objp->pathconf3res_u.resfail)) + return FALSE; + break; + } + return TRUE; } bool_t -xdr_commit3args (XDR *xdrs, commit3args *objp) +xdr_commit3args(XDR *xdrs, commit3args *objp) { - if (!xdr_nfs_fh3 (xdrs, &objp->file)) - return FALSE; - if (!xdr_offset3 (xdrs, &objp->offset)) - return FALSE; - if (!xdr_count3 (xdrs, &objp->count)) - return FALSE; - return TRUE; + if (!xdr_nfs_fh3(xdrs, &objp->file)) + return FALSE; + if (!xdr_offset3(xdrs, &objp->offset)) + return FALSE; + if (!xdr_count3(xdrs, &objp->count)) + return FALSE; + return TRUE; } bool_t -xdr_commit3resok (XDR *xdrs, commit3resok *objp) +xdr_commit3resok(XDR *xdrs, commit3resok *objp) { - if (!xdr_wcc_data (xdrs, &objp->file_wcc)) - return FALSE; - if (!xdr_writeverf3 (xdrs, objp->verf)) - return FALSE; - return TRUE; + if (!xdr_wcc_data(xdrs, &objp->file_wcc)) + return FALSE; + if (!xdr_writeverf3(xdrs, objp->verf)) + return FALSE; + return TRUE; } bool_t -xdr_commit3resfail (XDR *xdrs, commit3resfail *objp) +xdr_commit3resfail(XDR *xdrs, commit3resfail *objp) { - if (!xdr_wcc_data (xdrs, &objp->file_wcc)) - return FALSE; - return TRUE; + if (!xdr_wcc_data(xdrs, &objp->file_wcc)) + return FALSE; + return TRUE; } bool_t -xdr_commit3res (XDR *xdrs, commit3res *objp) +xdr_commit3res(XDR *xdrs, commit3res *objp) { - if (!xdr_nfsstat3 (xdrs, &objp->status)) - return FALSE; - switch (objp->status) { - case NFS3_OK: - if (!xdr_commit3resok (xdrs, &objp->commit3res_u.resok)) - return FALSE; - break; - default: - if (!xdr_commit3resfail (xdrs, &objp->commit3res_u.resfail)) - return FALSE; - break; - } - return TRUE; + if (!xdr_nfsstat3(xdrs, &objp->status)) + return FALSE; + switch (objp->status) { + case NFS3_OK: + if (!xdr_commit3resok(xdrs, &objp->commit3res_u.resok)) + return FALSE; + break; + default: + if (!xdr_commit3resfail(xdrs, &objp->commit3res_u.resfail)) + return FALSE; + break; + } + return TRUE; } bool_t -xdr_fhandle3 (XDR *xdrs, fhandle3 *objp) +xdr_fhandle3(XDR *xdrs, fhandle3 *objp) { - if (!xdr_bytes (xdrs, (char **)&objp->fhandle3_val, (u_int *) &objp->fhandle3_len, FHSIZE3)) - return FALSE; - return TRUE; + if (!xdr_bytes(xdrs, (char **)&objp->fhandle3_val, + (u_int *)&objp->fhandle3_len, FHSIZE3)) + return FALSE; + return TRUE; } bool_t -xdr_dirpath (XDR *xdrs, dirpath *objp) +xdr_dirpath(XDR *xdrs, dirpath *objp) { - if (!xdr_string (xdrs, objp, MNTPATHLEN)) - return FALSE; - return TRUE; + if (!xdr_string(xdrs, objp, MNTPATHLEN)) + return FALSE; + return TRUE; } bool_t -xdr_name (XDR *xdrs, name *objp) +xdr_name(XDR *xdrs, name *objp) { - if (!xdr_string (xdrs, objp, MNTNAMLEN)) - return FALSE; - return TRUE; + if (!xdr_string(xdrs, objp, MNTNAMLEN)) + return FALSE; + return TRUE; } bool_t -xdr_mountstat3 (XDR *xdrs, mountstat3 *objp) +xdr_mountstat3(XDR *xdrs, mountstat3 *objp) { - if (!xdr_enum (xdrs, (enum_t *) objp)) - return FALSE; - return TRUE; + if (!xdr_enum(xdrs, (enum_t *)objp)) + return FALSE; + return TRUE; } bool_t -xdr_mountres3_ok (XDR *xdrs, mountres3_ok *objp) +xdr_mountres3_ok(XDR *xdrs, mountres3_ok *objp) { - if (!xdr_fhandle3 (xdrs, &objp->fhandle)) - return FALSE; - if (!xdr_array (xdrs, (char **)&objp->auth_flavors.auth_flavors_val, (u_int *) &objp->auth_flavors.auth_flavors_len, ~0, - sizeof (int), (xdrproc_t) xdr_int)) - return FALSE; - return TRUE; + if (!xdr_fhandle3(xdrs, &objp->fhandle)) + return FALSE; + if (!xdr_array(xdrs, (char **)&objp->auth_flavors.auth_flavors_val, + (u_int *)&objp->auth_flavors.auth_flavors_len, ~0, + sizeof(int), (xdrproc_t)xdr_int)) + return FALSE; + return TRUE; } bool_t -xdr_mountres3 (XDR *xdrs, mountres3 *objp) +xdr_mountres3(XDR *xdrs, mountres3 *objp) { - if (!xdr_mountstat3 (xdrs, &objp->fhs_status)) - return FALSE; - switch (objp->fhs_status) { - case MNT3_OK: - if (!xdr_mountres3_ok (xdrs, &objp->mountres3_u.mountinfo)) - return FALSE; - break; - default: - break; - } - return TRUE; + if (!xdr_mountstat3(xdrs, &objp->fhs_status)) + return FALSE; + switch (objp->fhs_status) { + case MNT3_OK: + if (!xdr_mountres3_ok(xdrs, &objp->mountres3_u.mountinfo)) + return FALSE; + break; + default: + break; + } + return TRUE; } bool_t -xdr_mountlist (XDR *xdrs, mountlist *objp) +xdr_mountlist(XDR *xdrs, mountlist *objp) { - if (!xdr_pointer (xdrs, (char **)objp, sizeof (struct mountbody), (xdrproc_t) xdr_mountbody)) - return FALSE; - return TRUE; + if (!xdr_pointer(xdrs, (char **)objp, sizeof(struct mountbody), + (xdrproc_t)xdr_mountbody)) + return FALSE; + return TRUE; } bool_t -xdr_mountbody (XDR *xdrs, mountbody *objp) +xdr_mountbody(XDR *xdrs, mountbody *objp) { - if (!xdr_name (xdrs, &objp->ml_hostname)) - return FALSE; - if (!xdr_dirpath (xdrs, &objp->ml_directory)) - return FALSE; - if (!xdr_mountlist (xdrs, &objp->ml_next)) - return FALSE; - return TRUE; + if (!xdr_name(xdrs, &objp->ml_hostname)) + return FALSE; + if (!xdr_dirpath(xdrs, &objp->ml_directory)) + return FALSE; + if (!xdr_mountlist(xdrs, &objp->ml_next)) + return FALSE; + return TRUE; } bool_t -xdr_groups (XDR *xdrs, groups *objp) +xdr_groups(XDR *xdrs, groups *objp) { - if (!xdr_pointer (xdrs, (char **)objp, sizeof (struct groupnode), (xdrproc_t) xdr_groupnode)) - return FALSE; - return TRUE; + if (!xdr_pointer(xdrs, (char **)objp, sizeof(struct groupnode), + (xdrproc_t)xdr_groupnode)) + return FALSE; + return TRUE; } bool_t -xdr_groupnode (XDR *xdrs, groupnode *objp) +xdr_groupnode(XDR *xdrs, groupnode *objp) { - if (!xdr_name (xdrs, &objp->gr_name)) - return FALSE; - if (!xdr_groups (xdrs, &objp->gr_next)) - return FALSE; - return TRUE; + if (!xdr_name(xdrs, &objp->gr_name)) + return FALSE; + if (!xdr_groups(xdrs, &objp->gr_next)) + return FALSE; + return TRUE; } bool_t -xdr_exports (XDR *xdrs, exports *objp) +xdr_exports(XDR *xdrs, exports *objp) { - if (!xdr_pointer (xdrs, (char **)objp, sizeof (struct exportnode), (xdrproc_t) xdr_exportnode)) - return FALSE; - return TRUE; + if (!xdr_pointer(xdrs, (char **)objp, sizeof(struct exportnode), + (xdrproc_t)xdr_exportnode)) + return FALSE; + return TRUE; } bool_t -xdr_exportnode (XDR *xdrs, exportnode *objp) +xdr_exportnode(XDR *xdrs, exportnode *objp) { - if (!xdr_dirpath (xdrs, &objp->ex_dir)) - return FALSE; - if (!xdr_groups (xdrs, &objp->ex_groups)) - return FALSE; - if (!xdr_exports (xdrs, &objp->ex_next)) - return FALSE; - return TRUE; + if (!xdr_dirpath(xdrs, &objp->ex_dir)) + return FALSE; + if (!xdr_groups(xdrs, &objp->ex_groups)) + return FALSE; + if (!xdr_exports(xdrs, &objp->ex_next)) + return FALSE; + return TRUE; } static void -xdr_free_groupnode (struct groupnode *group) +xdr_free_groupnode(struct groupnode *group) { - if (!group) - return; + if (!group) + return; - if (group->gr_next) - xdr_free_groupnode (group->gr_next); + if (group->gr_next) + xdr_free_groupnode(group->gr_next); - GF_FREE (group->gr_name); - GF_FREE (group); + GF_FREE(group->gr_name); + GF_FREE(group); } void -xdr_free_exports_list (struct exportnode *first) +xdr_free_exports_list(struct exportnode *first) { - struct exportnode *elist = NULL; + struct exportnode *elist = NULL; - if (!first) - return; + if (!first) + return; - while (first) { - elist = first->ex_next; - GF_FREE (first->ex_dir); + while (first) { + elist = first->ex_next; + GF_FREE(first->ex_dir); - xdr_free_groupnode (first->ex_groups); - - GF_FREE (first); - first = elist; - } + xdr_free_groupnode(first->ex_groups); + GF_FREE(first); + first = elist; + } } - void -xdr_free_mountlist (mountlist ml) +xdr_free_mountlist(mountlist ml) { - struct mountbody *next = NULL; + struct mountbody *next = NULL; - if (!ml) - return; + if (!ml) + return; - while (ml) { - GF_FREE (ml->ml_hostname); - GF_FREE (ml->ml_directory); - next = ml->ml_next; - GF_FREE (ml); - ml = next; - } + while (ml) { + GF_FREE(ml->ml_hostname); + GF_FREE(ml->ml_directory); + next = ml->ml_next; + GF_FREE(ml); + ml = next; + } - return; + return; } - /* Free statements are based on the way sunrpc xdr decoding * code performs memory allocations. */ void -xdr_free_write3args_nocopy (write3args *wa) +xdr_free_write3args_nocopy(write3args *wa) { - if (!wa) - return; + if (!wa) + return; - FREE (wa->file.data.data_val); + FREE(wa->file.data.data_val); } |