From b02afc6d008f9959db28244eb2b9dd3b9ef92393 Mon Sep 17 00:00:00 2001 From: Amar Tumballi Date: Tue, 17 Jan 2012 05:28:51 +0530 Subject: core: change lk-owner as a 1k buffer so, NLM can send the lk-owner field directly to the locks translators, while doing the same effort, also enabled sending maximum of 500 aux gid over protocol. Change-Id: I87c2514392748416f7ffe21d5154faad2e413969 Signed-off-by: Amar Tumballi BUG: 767229 Reviewed-on: http://review.gluster.com/779 Tested-by: Gluster Build System Reviewed-by: Anand Avati --- contrib/fuse-lib/misc.c | 2 +- extras/generate-xdr-files.sh | 2 +- libglusterfs/src/Makefile.am | 2 +- libglusterfs/src/common-utils.c | 21 +++ libglusterfs/src/common-utils.h | 3 + libglusterfs/src/globals.c | 44 +++++ libglusterfs/src/globals.h | 7 +- libglusterfs/src/glusterfs.h | 29 ++-- libglusterfs/src/lkowner.h | 92 ++++++++++ libglusterfs/src/stack.h | 9 +- rpc/rpc-lib/src/Makefile.am | 4 +- rpc/rpc-lib/src/auth-glusterfs.c | 216 +++++++++++++---------- rpc/rpc-lib/src/auth-null.c | 4 +- rpc/rpc-lib/src/auth-unix.c | 2 +- rpc/rpc-lib/src/rpc-clnt.c | 69 ++++---- rpc/rpc-lib/src/rpc-clnt.h | 9 +- rpc/rpc-lib/src/rpc-common.c | 141 --------------- rpc/rpc-lib/src/rpcsvc-auth.c | 20 ++- rpc/rpc-lib/src/rpcsvc.c | 4 +- rpc/rpc-lib/src/rpcsvc.h | 13 +- rpc/rpc-lib/src/xdr-common.h | 48 +---- rpc/rpc-lib/src/xdr-rpc.h | 9 +- rpc/rpc-transport/rdma/src/Makefile.am | 2 +- rpc/xdr/src/Makefile.am | 4 +- rpc/xdr/src/glusterfs3-xdr.c | 2 +- rpc/xdr/src/glusterfs3-xdr.h | 5 +- rpc/xdr/src/glusterfs3-xdr.x | 2 +- rpc/xdr/src/glusterfs3.h | 10 +- rpc/xdr/src/msg-nfs3.c | 78 --------- rpc/xdr/src/rpc-common-xdr.c | 232 +++++++++++++++++++++++++ rpc/xdr/src/rpc-common-xdr.h | 113 ++++++++++++ rpc/xdr/src/rpc-common-xdr.x | 39 +++++ xlators/cluster/afr/src/afr-lk-common.c | 27 +-- xlators/cluster/afr/src/afr-self-heal-data.c | 28 +-- xlators/cluster/afr/src/pump.c | 6 +- xlators/features/locks/src/common.c | 43 +++-- xlators/features/locks/src/common.h | 4 +- xlators/features/locks/src/entrylk.c | 31 ++-- xlators/features/locks/src/inodelk.c | 72 ++++---- xlators/features/locks/src/locks.h | 10 +- xlators/features/locks/src/posix.c | 93 +++++----- xlators/features/locks/src/reservelk.c | 20 +-- xlators/features/marker/src/marker-quota.c | 2 +- xlators/mgmt/glusterd/src/glusterd-handshake.c | 1 + xlators/mount/fuse/src/fuse-bridge.c | 4 +- xlators/mount/fuse/src/fuse-helpers.c | 8 +- xlators/nfs/server/src/nfs-fops.c | 5 +- xlators/nfs/server/src/nfs.h | 6 + xlators/protocol/client/src/client-handshake.c | 1 + xlators/protocol/client/src/client-lk.c | 35 ++-- xlators/protocol/client/src/client.h | 11 +- xlators/protocol/client/src/client3_1-fops.c | 8 +- xlators/protocol/server/src/server-helpers.c | 47 ++--- xlators/protocol/server/src/server-helpers.h | 4 +- xlators/protocol/server/src/server.h | 2 +- xlators/protocol/server/src/server3_1-fops.c | 20 ++- 56 files changed, 1043 insertions(+), 682 deletions(-) create mode 100644 libglusterfs/src/lkowner.h delete mode 100644 rpc/rpc-lib/src/rpc-common.c create mode 100644 rpc/xdr/src/rpc-common-xdr.c create mode 100644 rpc/xdr/src/rpc-common-xdr.h create mode 100644 rpc/xdr/src/rpc-common-xdr.x diff --git a/contrib/fuse-lib/misc.c b/contrib/fuse-lib/misc.c index 28a9284bf..0c41b1a19 100644 --- a/contrib/fuse-lib/misc.c +++ b/contrib/fuse-lib/misc.c @@ -50,5 +50,5 @@ convert_fuse_file_lock (struct fuse_file_lock *fl, struct gf_flock *flock, else flock->l_len = fl->end - fl->start + 1; flock->l_pid = fl->pid; - flock->l_owner = lk_owner; + set_lk_owner_from_uint64 (&flock->l_owner, lk_owner); } diff --git a/extras/generate-xdr-files.sh b/extras/generate-xdr-files.sh index d1c2f1368..e52321cd3 100755 --- a/extras/generate-xdr-files.sh +++ b/extras/generate-xdr-files.sh @@ -82,7 +82,7 @@ main () rpcgen -h -o $hfile $xfile; # the '#ifdef' part of file should be fixed - sed -i -e 's:\(.*\)-\(.*\)_H_RPCGEN:\1_\2_H_RPCGEN:g' $hfile; + sed -i -e 's/-/_/g' $hfile; echo "OK"; diff --git a/libglusterfs/src/Makefile.am b/libglusterfs/src/Makefile.am index 25de376aa..34543f622 100644 --- a/libglusterfs/src/Makefile.am +++ b/libglusterfs/src/Makefile.am @@ -37,7 +37,7 @@ noinst_HEADERS = common-utils.h defaults.h dict.h glusterfs.h hashfn.h \ rbthash.h iatt.h latency.h mem-types.h $(CONTRIBDIR)/uuid/uuidd.h \ $(CONTRIBDIR)/uuid/uuid.h $(CONTRIBDIR)/uuid/uuidP.h \ $(CONTRIB_BUILDDIR)/uuid/uuid_types.h syncop.h graph-utils.h trie.h run.h \ - options.h + options.h lkowner.h EXTRA_DIST = graph.l graph.y diff --git a/libglusterfs/src/common-utils.c b/libglusterfs/src/common-utils.c index b9f752b75..ce1e1f45b 100644 --- a/libglusterfs/src/common-utils.c +++ b/libglusterfs/src/common-utils.c @@ -40,6 +40,7 @@ #include #include #include +#include #include "logging.h" #include "common-utils.h" @@ -48,6 +49,7 @@ #include "stack.h" #include "globals.h" #include "md5.h" +#include "lkowner.h" #ifndef AI_ADDRCONFIG #define AI_ADDRCONFIG 0 @@ -1656,6 +1658,25 @@ uuid_utoa_r (uuid_t uuid, char *dst) return dst; } +/*Thread safe conversion function*/ +char * +lkowner_utoa (gf_lkowner_t *lkowner) +{ + char *lkowner_buffer = glusterfs_lkowner_buf_get(); + lkowner_unparse (lkowner, lkowner_buffer, GF_LKOWNER_BUF_SIZE); + return lkowner_buffer; +} + +/*Re-entrant conversion function*/ +char * +lkowner_utoa_r (gf_lkowner_t *lkowner, char *dst, int len) +{ + if(!dst) + return NULL; + lkowner_unparse (lkowner, dst, len); + return dst; +} + void _get_md5_str (char *out_str, size_t outlen, const uint8_t *input, int n) { diff --git a/libglusterfs/src/common-utils.h b/libglusterfs/src/common-utils.h index 4e7f981b3..d81da35c5 100644 --- a/libglusterfs/src/common-utils.h +++ b/libglusterfs/src/common-utils.h @@ -444,6 +444,9 @@ char valid_internet_address (char *address); char *uuid_utoa (uuid_t uuid); char *uuid_utoa_r (uuid_t uuid, char *dst); +char *lkowner_utoa (gf_lkowner_t *lkowner); +char *lkowner_utoa_r (gf_lkowner_t *lkowner, char *dst, int len); + void _get_md5_str (char *out_str, size_t outlen, const uint8_t *input, int n); void gf_array_insertionsort (void *a, int l, int r, size_t elem_size, diff --git a/libglusterfs/src/globals.c b/libglusterfs/src/globals.c index 57946f704..8b641123f 100644 --- a/libglusterfs/src/globals.c +++ b/libglusterfs/src/globals.c @@ -293,6 +293,43 @@ glusterfs_uuid_buf_get () return buf; } +/* LKOWNER_BUFFER */ + +static pthread_key_t lkowner_buf_key; +static char global_lkowner_buf[GF_LKOWNER_BUF_SIZE]; +void +glusterfs_lkowner_buf_destroy (void *ptr) +{ + if (ptr) + FREE (ptr); +} + +int +glusterfs_lkowner_buf_init () +{ + int ret = 0; + + ret = pthread_key_create (&lkowner_buf_key, + glusterfs_lkowner_buf_destroy); + return ret; +} + +char * +glusterfs_lkowner_buf_get () +{ + char *buf; + int ret = 0; + + buf = pthread_getspecific (lkowner_buf_key); + if(!buf) { + buf = MALLOC (GF_LKOWNER_BUF_SIZE); + ret = pthread_setspecific (lkowner_buf_key, (void *) buf); + if(ret) + buf = global_lkowner_buf; + } + return buf; +} + int glusterfs_globals_init () { @@ -323,6 +360,13 @@ glusterfs_globals_init () goto out; } + ret = glusterfs_lkowner_buf_init (); + if(ret) { + gf_log ("", GF_LOG_CRITICAL, + "ERROR: glusterfs lkowner buffer init failed"); + goto out; + } + gf_mem_acct_enable_set (); ret = synctask_init (); diff --git a/libglusterfs/src/globals.h b/libglusterfs/src/globals.h index 7003351ab..86e1f0324 100644 --- a/libglusterfs/src/globals.h +++ b/libglusterfs/src/globals.h @@ -22,12 +22,6 @@ #define GF_DEFAULT_BASE_PORT 24007 -/* This corresponds to the max 16 number of group IDs that are sent through an - * RPC request. Since NFS is the only one going to set this, we can be safe - * in keeping this size hardcoded. - */ -#define GF_REQUEST_MAXGROUPS 16 - #include "glusterfs.h" /* CTX */ @@ -52,6 +46,7 @@ int synctask_set (void *); /* uuid_buf */ char *glusterfs_uuid_buf_get(); +char *glusterfs_lkowner_buf_get(); /* init */ int glusterfs_globals_init (void); diff --git a/libglusterfs/src/glusterfs.h b/libglusterfs/src/glusterfs.h index 903d2324a..2f68ab741 100644 --- a/libglusterfs/src/glusterfs.h +++ b/libglusterfs/src/glusterfs.h @@ -45,7 +45,6 @@ #include "list.h" #include "logging.h" - #define GF_YES 1 #define GF_NO 0 @@ -114,6 +113,12 @@ /* TODO: Should we use PATH-MAX? On some systems it may save space */ #define ZR_PATH_MAX 4096 +/* GlusterFS's maximum supported Auxilary GIDs */ +/* TODO: Keeping it to 200, so that we can fit in 2KB buffer for auth data + * in RPC server code, if there is ever need for having more aux-gids, then + * we have to add aux-gid in payload of actors */ +#define GF_MAX_AUX_GROUPS 200 + /* NOTE: add members ONLY at the end (just before _MAXVALUE) */ typedef enum { GF_FOP_NULL = 0, @@ -177,15 +182,6 @@ typedef enum { GF_OP_TYPE_MAX, } gf_op_type_t; -struct gf_flock { - short l_type; - short l_whence; - off_t l_start; - off_t l_len; - pid_t l_pid; - uint64_t l_owner; -}; - /* NOTE: all the miscellaneous flags used by GlusterFS should be listed here */ typedef enum { GF_LK_GETLK = 0, @@ -385,6 +381,19 @@ typedef enum { GF_EVENT_MAXVAL, } glusterfs_event_t; +/* gf_lkowner_t is defined in lkowner.h */ +#include "lkowner.h" + +struct gf_flock { + short l_type; + short l_whence; + off_t l_start; + off_t l_len; + pid_t l_pid; + gf_lkowner_t l_owner; +}; + + extern char *glusterfs_strevent (glusterfs_event_t ev); #define GF_MUST_CHECK __attribute__((warn_unused_result)) diff --git a/libglusterfs/src/lkowner.h b/libglusterfs/src/lkowner.h new file mode 100644 index 000000000..5fee17b3d --- /dev/null +++ b/libglusterfs/src/lkowner.h @@ -0,0 +1,92 @@ +/* + Copyright (c) 2012 Red Hat + This file is part of GlusterFS. + + GlusterFS is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published + by the Free Software Foundation; either version 3 of the License, + or (at your option) any later version. + + GlusterFS is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see + . +*/ + +#ifndef _LK_OWNER_H +#define _LK_OWNER_H + +#ifndef _CONFIG_H +#define _CONFIG_H +#include "config.h" +#endif + +#define GF_MAX_LOCK_OWNER_LEN 1024 /* 1kB as per NLM */ + +/* 16strings-16strings-... */ +#define GF_LKOWNER_BUF_SIZE ((GF_MAX_LOCK_OWNER_LEN * 2) + \ + (GF_MAX_LOCK_OWNER_LEN / 8)) + +typedef struct gf_lkowner_ { + int len; + char data[GF_MAX_LOCK_OWNER_LEN]; +} gf_lkowner_t; + + +/* LKOWNER to string functions */ +static inline void +lkowner_unparse (gf_lkowner_t *lkowner, char *buf, int buf_len) +{ + int i = 0; + int j = 0; + + for (i = 0; i < lkowner->len; i++) { + if (i && !(i % 8)) { + buf[j] = '-'; + j++; + } + sprintf (&buf[j], "%02x", lkowner->data[i]); + j += 2; + if (j == buf_len) + break; + } + if (j < buf_len) + buf[j] = '\0'; +} + +static inline void +set_lk_owner_from_ptr (gf_lkowner_t *lkowner, void *data) +{ + int i = 0; + int j = 0; + + lkowner->len = sizeof (unsigned long); + for (i = 0, j = 0; i < lkowner->len; i++, j += 8) { + lkowner->data[i] = (char)((((unsigned long)data) >> j) & 0xff); + } +} + +static inline void +set_lk_owner_from_uint64 (gf_lkowner_t *lkowner, uint64_t data) +{ + int i = 0; + int j = 0; + + lkowner->len = 8; + for (i = 0, j = 0; i < lkowner->len; i++, j += 8) { + lkowner->data[i] = (char)((data >> j) & 0xff); + } +} + +/* Return true if the locks have the same owner */ +static inline int +is_same_lkowner (gf_lkowner_t *l1, gf_lkowner_t *l2) +{ + return ((l1->len == l2->len) && !memcmp(l1->data, l2->data, l1->len)); +} + +#endif /* _LK_OWNER_H */ diff --git a/libglusterfs/src/stack.h b/libglusterfs/src/stack.h index 546e2f968..a5689e096 100644 --- a/libglusterfs/src/stack.h +++ b/libglusterfs/src/stack.h @@ -44,6 +44,7 @@ typedef struct _call_pool_t call_pool_t; #include "list.h" #include "common-utils.h" #include "globals.h" +#include "lkowner.h" #define NFS_PID 1 #define LOW_PRIO_PROC_PID -1 @@ -106,9 +107,9 @@ struct _call_stack_t { uid_t uid; gid_t gid; pid_t pid; - uint32_t ngrps; - uint32_t groups[GF_REQUEST_MAXGROUPS]; - uint64_t lk_owner; + uint16_t ngrps; + uint32_t groups[GF_MAX_AUX_GROUPS]; + gf_lkowner_t lk_owner; call_frame_t frames; @@ -360,7 +361,7 @@ copy_frame (call_frame_t *frame) newstack->op = oldstack->op; newstack->type = oldstack->type; memcpy (newstack->groups, oldstack->groups, - sizeof (uint32_t) * GF_REQUEST_MAXGROUPS); + sizeof (gid_t) * GF_MAX_AUX_GROUPS); newstack->unique = oldstack->unique; newstack->frames.this = frame->this; diff --git a/rpc/rpc-lib/src/Makefile.am b/rpc/rpc-lib/src/Makefile.am index fcf091e9b..8b087301c 100644 --- a/rpc/rpc-lib/src/Makefile.am +++ b/rpc/rpc-lib/src/Makefile.am @@ -1,8 +1,8 @@ lib_LTLIBRARIES = libgfrpc.la libgfrpc_la_SOURCES = auth-unix.c rpcsvc-auth.c rpcsvc.c auth-null.c \ - rpc-transport.c xdr-rpc.c xdr-rpcclnt.c rpc-clnt.c auth-glusterfs.c \ - rpc-common.c + rpc-transport.c xdr-rpc.c xdr-rpcclnt.c rpc-clnt.c auth-glusterfs.c + libgfrpc_la_LIBADD = $(top_builddir)/libglusterfs/src/libglusterfs.la noinst_HEADERS = rpcsvc.h rpc-transport.h xdr-common.h xdr-rpc.h xdr-rpcclnt.h \ diff --git a/rpc/rpc-lib/src/auth-glusterfs.c b/rpc/rpc-lib/src/auth-glusterfs.c index 4faaddb9e..9996bfad4 100644 --- a/rpc/rpc-lib/src/auth-glusterfs.c +++ b/rpc/rpc-lib/src/auth-glusterfs.c @@ -29,94 +29,9 @@ #include "dict.h" #include "xdr-rpc.h" #include "xdr-common.h" +#include "rpc-common-xdr.h" -bool_t -xdr_auth_glusterfs_parms (XDR *xdrs, auth_glusterfs_parms *objp) -{ - register int32_t *buf; - - int i; - - if (xdrs->x_op == XDR_ENCODE) { - if (!xdr_u_quad_t (xdrs, &objp->lk_owner)) - return FALSE; - buf = XDR_INLINE (xdrs, (4 + 16 )* BYTES_PER_XDR_UNIT); - if (buf == NULL) { - if (!xdr_u_int (xdrs, &objp->pid)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->uid)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->gid)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->ngrps)) - return FALSE; - if (!xdr_vector (xdrs, (char *)objp->groups, 16, - sizeof (u_int), (xdrproc_t) xdr_u_int)) - return FALSE; - } else { - IXDR_PUT_U_LONG(buf, objp->pid); - IXDR_PUT_U_LONG(buf, objp->uid); - IXDR_PUT_U_LONG(buf, objp->gid); - IXDR_PUT_U_LONG(buf, objp->ngrps); - { - register u_int *genp; - - for (i = 0, genp = objp->groups; - i < 16; ++i) { - IXDR_PUT_U_LONG(buf, *genp++); - } - } - } - return TRUE; - } else if (xdrs->x_op == XDR_DECODE) { - if (!xdr_u_quad_t (xdrs, &objp->lk_owner)) - return FALSE; - buf = XDR_INLINE (xdrs, (4 + 16 )* BYTES_PER_XDR_UNIT); - if (buf == NULL) { - if (!xdr_u_int (xdrs, &objp->pid)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->uid)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->gid)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->ngrps)) - return FALSE; - if (!xdr_vector (xdrs, (char *)objp->groups, 16, - sizeof (u_int), (xdrproc_t) xdr_u_int)) - return FALSE; - } else { - objp->pid = IXDR_GET_U_LONG(buf); - objp->uid = IXDR_GET_U_LONG(buf); - objp->gid = IXDR_GET_U_LONG(buf); - objp->ngrps = IXDR_GET_U_LONG(buf); - { - register u_int *genp; - - for (i = 0, genp = objp->groups; - i < 16; ++i) { - *genp++ = IXDR_GET_U_LONG(buf); - } - } - } - return TRUE; - } - - if (!xdr_u_quad_t (xdrs, &objp->lk_owner)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->pid)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->uid)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->gid)) - return FALSE; - if (!xdr_u_int (xdrs, &objp->ngrps)) - return FALSE; - if (!xdr_vector (xdrs, (char *)objp->groups, 16, - sizeof (u_int), (xdrproc_t) xdr_u_int)) - return FALSE; - return TRUE; -} - +/* V1 */ ssize_t xdr_to_glusterfs_auth (char *buf, struct auth_glusterfs_parms *req) @@ -146,7 +61,7 @@ auth_glusterfs_request_init (rpcsvc_request_t *req, void *priv) { if (!req) return -1; - memset (req->verf.authdata, 0, RPCSVC_MAX_AUTH_BYTES); + memset (req->verf.authdata, 0, GF_MAX_AUTH_BYTES); req->verf.datalen = 0; req->verf.flavour = AUTH_NULL; @@ -155,9 +70,12 @@ auth_glusterfs_request_init (rpcsvc_request_t *req, void *priv) int auth_glusterfs_authenticate (rpcsvc_request_t *req, void *priv) { - int ret = RPCSVC_AUTH_REJECT; struct auth_glusterfs_parms au = {0,}; - int gidcount = 0; + + int ret = RPCSVC_AUTH_REJECT; + int gidcount = 0; + int j = 0; + int i = 0; if (!req) return ret; @@ -173,7 +91,11 @@ int auth_glusterfs_authenticate (rpcsvc_request_t *req, void *priv) req->pid = au.pid; req->uid = au.uid; req->gid = au.gid; - req->lk_owner = au.lk_owner; + 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) { @@ -187,8 +109,8 @@ int auth_glusterfs_authenticate (rpcsvc_request_t *req, void *priv) req->auxgids[gidcount] = au.groups[gidcount]; gf_log (GF_RPCSVC, GF_LOG_TRACE, "Auth Info: pid: %u, uid: %d" - ", gid: %d, owner: %"PRId64, - req->pid, req->uid, req->gid, req->lk_owner); + ", gid: %d, owner: %s", + req->pid, req->uid, req->gid, lkowner_utoa (&req->lk_owner)); ret = RPCSVC_AUTH_ACCEPT; err: return ret; @@ -213,3 +135,111 @@ rpcsvc_auth_glusterfs_init (rpcsvc_t *svc, dict_t *options) { return &rpcsvc_auth_glusterfs; } + +/* V2 */ + +ssize_t +xdr_to_glusterfs_auth_v2 (char *buf, struct auth_glusterfs_parms_v2 *req) +{ + XDR xdr; + ssize_t ret = -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; + } + + ret = (((size_t)(&xdr)->x_private) - ((size_t)(&xdr)->x_base)); +ret: + return ret; + +} +int +auth_glusterfs_v2_request_init (rpcsvc_request_t *req, void *priv) +{ + if (!req) + return -1; + memset (req->verf.authdata, 0, GF_MAX_AUTH_BYTES); + req->verf.datalen = 0; + req->verf.flavour = AUTH_NULL; + + return 0; +} + +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; + + 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; + + if (req->auxgidcount > GF_MAX_AUX_GROUPS) { + gf_log ("", GF_LOG_WARNING, + "more than max aux gids found (%d) , truncating it " + "to %d and continuing", au.groups.groups_len, + GF_MAX_AUX_GROUPS); + req->auxgidcount = GF_MAX_AUX_GROUPS; + } + + if (req->lk_owner.len > GF_MAX_LOCK_OWNER_LEN) { + gf_log ("", GF_LOG_WARNING, + "lkowner field > 1k, failing authentication"); + 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: + 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 +}; + + +rpcsvc_auth_t * +rpcsvc_auth_glusterfs_v2_init (rpcsvc_t *svc, dict_t *options) +{ + return &rpcsvc_auth_glusterfs_v2; +} diff --git a/rpc/rpc-lib/src/auth-null.c b/rpc/rpc-lib/src/auth-null.c index ee50ab669..aa6b4c1bd 100644 --- a/rpc/rpc-lib/src/auth-null.c +++ b/rpc/rpc-lib/src/auth-null.c @@ -34,10 +34,10 @@ auth_null_request_init (rpcsvc_request_t *req, void *priv) if (!req) return -1; - memset (req->cred.authdata, 0, RPCSVC_MAX_AUTH_BYTES); + memset (req->cred.authdata, 0, GF_MAX_AUTH_BYTES); req->cred.datalen = 0; - memset (req->verf.authdata, 0, RPCSVC_MAX_AUTH_BYTES); + memset (req->verf.authdata, 0, GF_MAX_AUTH_BYTES); req->verf.datalen = 0; return 0; diff --git a/rpc/rpc-lib/src/auth-unix.c b/rpc/rpc-lib/src/auth-unix.c index c48743db9..c3b58945a 100644 --- a/rpc/rpc-lib/src/auth-unix.c +++ b/rpc/rpc-lib/src/auth-unix.c @@ -35,7 +35,7 @@ auth_unix_request_init (rpcsvc_request_t *req, void *priv) { if (!req) return -1; - memset (req->verf.authdata, 0, RPCSVC_MAX_AUTH_BYTES); + memset (req->verf.authdata, 0, GF_MAX_AUTH_BYTES); req->verf.datalen = 0; req->verf.flavour = AUTH_NULL; diff --git a/rpc/rpc-lib/src/rpc-clnt.c b/rpc/rpc-lib/src/rpc-clnt.c index 43791dc57..e21aac755 100644 --- a/rpc/rpc-lib/src/rpc-clnt.c +++ b/rpc/rpc-lib/src/rpc-clnt.c @@ -32,6 +32,7 @@ #include "protocol-common.h" #include "mem-pool.h" #include "xdr-rpc.h" +#include "rpc-common-xdr.h" void rpc_clnt_reply_deinit (struct rpc_req *req, struct mem_pool *pool); @@ -1091,7 +1092,7 @@ rpc_clnt_register_notify (struct rpc_clnt *rpc, rpc_clnt_notify_t fn, } ssize_t -xdr_serialize_glusterfs_auth (char *dest, struct auth_glusterfs_parms *au) +xdr_serialize_glusterfs_auth (char *dest, struct auth_glusterfs_parms_v2 *au) { ssize_t ret = -1; XDR xdr; @@ -1099,10 +1100,9 @@ xdr_serialize_glusterfs_auth (char *dest, struct auth_glusterfs_parms *au) if ((!dest) || (!au)) return -1; - xdrmem_create (&xdr, dest, 1024, - XDR_ENCODE); + xdrmem_create (&xdr, dest, GF_MAX_AUTH_BYTES, XDR_ENCODE); - if (!xdr_auth_glusterfs_parms (&xdr, au)) { + if (!xdr_auth_glusterfs_parms_v2 (&xdr, au)) { gf_log (THIS->name, GF_LOG_WARNING, "failed to encode auth glusterfs elements"); ret = -1; @@ -1118,7 +1118,7 @@ ret: int rpc_clnt_fill_request (int prognum, int progver, int procnum, int payload, - uint64_t xid, struct auth_glusterfs_parms *au, + uint64_t xid, struct auth_glusterfs_parms_v2 *au, struct rpc_msg *request, char *auth_data) { int ret = -1; @@ -1146,7 +1146,7 @@ rpc_clnt_fill_request (int prognum, int progver, int procnum, int payload, goto out; } - request->rm_call.cb_cred.oa_flavor = AUTH_GLUSTERFS; + request->rm_call.cb_cred.oa_flavor = AUTH_GLUSTERFS_v2; request->rm_call.cb_cred.oa_base = auth_data; request->rm_call.cb_cred.oa_length = ret; @@ -1198,16 +1198,16 @@ out: struct iobuf * rpc_clnt_record_build_record (struct rpc_clnt *clnt, int prognum, int progver, int procnum, size_t payload, uint64_t xid, - struct auth_glusterfs_parms *au, + struct auth_glusterfs_parms_v2 *au, 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; - char auth_data[RPC_CLNT_MAX_AUTH_BYTES] = {0, }; + struct rpc_msg request = {0, }; + struct iobuf *request_iob = NULL; + char *record = NULL; + struct iovec recordhdr = {0, }; + size_t pagesize = 0; + int ret = -1; + char auth_data[GF_MAX_AUTH_BYTES] = {0, }; if ((!clnt) || (!recbuf) || (!au)) { goto out; @@ -1237,8 +1237,6 @@ rpc_clnt_record_build_record (struct rpc_clnt *clnt, int prognum, int progver, recordhdr = rpc_clnt_record_build_header (record, pagesize, &request, payload); - //GF_FREE (request.rm_call.cb_cred.oa_base); - if (!recordhdr.iov_base) { gf_log (clnt->conn.trans->name, GF_LOG_ERROR, "Failed to build record header"); @@ -1261,29 +1259,38 @@ rpc_clnt_record (struct rpc_clnt *clnt, call_frame_t *call_frame, rpc_clnt_prog_t *prog,int procnum, size_t payload_len, struct iovec *rpchdr, uint64_t callid) { - struct auth_glusterfs_parms au = {0, }; - struct iobuf *request_iob = NULL; + struct auth_glusterfs_parms_v2 au = {0, }; + struct iobuf *request_iob = NULL; + char owner[4] = {0,}; if (!prog || !rpchdr || !call_frame) { goto out; } - au.pid = call_frame->root->pid; - au.uid = call_frame->root->uid; - au.gid = call_frame->root->gid; - au.ngrps = call_frame->root->ngrps; - au.lk_owner = call_frame->root->lk_owner; - if (!au.lk_owner) - au.lk_owner = au.pid; + au.pid = call_frame->root->pid; + au.uid = call_frame->root->uid; + au.gid = call_frame->root->gid; + au.groups.groups_len = call_frame->root->ngrps; + au.lk_owner.lk_owner_len = call_frame->root->lk_owner.len; - gf_log (clnt->conn.trans->name, GF_LOG_TRACE, "Auth Info: pid: %u, uid: %d" - ", gid: %d, owner: %"PRId64, - au.pid, au.uid, au.gid, au.lk_owner); + if (au.groups.groups_len) + au.groups.groups_val = call_frame->root->groups; - memcpy (au.groups, call_frame->root->groups, sizeof (au.groups)); + if (call_frame->root->lk_owner.len) + au.lk_owner.lk_owner_val = call_frame->root->lk_owner.data; + else { + owner[0] = (char)(au.pid & 0xff); + owner[1] = (char)((au.pid >> 8) & 0xff); + owner[2] = (char)((au.pid >> 16) & 0xff); + owner[3] = (char)((au.pid >> 24) & 0xff); - //rpc_transport_get_myname (clnt->conn.trans, myname, UNIX_PATH_MAX); - //au.aup_machname = myname; + au.lk_owner.lk_owner_val = owner; + au.lk_owner.lk_owner_len = 4; + } + + gf_log (clnt->conn.trans->name, GF_LOG_TRACE, "Auth Info: pid: %u, uid: %d" + ", gid: %d, owner: %s", au.pid, au.uid, au.gid, + lkowner_utoa (&call_frame->root->lk_owner)); /* Assuming the client program would like to speak to the same version of * program on server. diff --git a/rpc/rpc-lib/src/rpc-clnt.h b/rpc/rpc-lib/src/rpc-clnt.h index e3b2ec3f1..7034da705 100644 --- a/rpc/rpc-lib/src/rpc-clnt.h +++ b/rpc/rpc-lib/src/rpc-clnt.h @@ -31,8 +31,6 @@ typedef enum { RPC_CLNT_MSG } rpc_clnt_event_t; -#define AUTH_GLUSTERFS 5 -#define RPC_CLNT_MAX_AUTH_BYTES 1024 #define SFRAME_GET_PROGNUM(sframe) (sframe->rpcreq->prog->prognum) #define SFRAME_GET_PROGVER(sframe) (sframe->rpcreq->prog->progver) @@ -121,11 +119,10 @@ typedef struct rpcclnt_cb_program { -#define RPC_MAX_AUTH_BYTES 400 typedef struct rpc_auth_data { - int flavour; - int datalen; - char authdata[RPC_MAX_AUTH_BYTES]; + int flavour; + int datalen; + char authdata[GF_MAX_AUTH_BYTES]; } rpc_auth_data_t; diff --git a/rpc/rpc-lib/src/rpc-common.c b/rpc/rpc-lib/src/rpc-common.c deleted file mode 100644 index ff8785c67..000000000 --- a/rpc/rpc-lib/src/rpc-common.c +++ /dev/null @@ -1,141 +0,0 @@ -/* - Copyright (c) 2010-2011 Gluster, Inc. - This file is part of GlusterFS. - - GlusterFS is free software; you can redistribute it and/or modify - it under the terms of the GNU General Public License as published - by the Free Software Foundation; either version 3 of the License, - or (at your option) any later version. - - GlusterFS is distributed in the hope that it will be useful, but - WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - General Public License for more details. - - You should have received a copy of the GNU General Public License - along with this program. If not, see - . -*/ - - -#include "logging.h" -#include "xdr-common.h" - -ssize_t -xdr_serialize_generic (struct iovec outmsg, void *res, xdrproc_t proc) -{ - ssize_t ret = -1; - XDR xdr; - - if ((!outmsg.iov_base) || (!res) || (!proc)) - return -1; - - xdrmem_create (&xdr, outmsg.iov_base, (unsigned int)outmsg.iov_len, - XDR_ENCODE); - - if (!proc (&xdr, res)) { - gf_log_callingfn ("xdr", GF_LOG_WARNING, - "XDR encoding failed"); - ret = -1; - goto ret; - } - - ret = xdr_encoded_length (xdr); - -ret: - return ret; -} - - -ssize_t -xdr_to_generic (struct iovec inmsg, void *args, xdrproc_t proc) -{ - XDR xdr; - ssize_t ret = -1; - - if ((!inmsg.iov_base) || (!args) || (!proc)) - return -1; - - xdrmem_create (&xdr, inmsg.iov_base, (unsigned int)inmsg.iov_len, - XDR_DECODE); - - if (!proc (&xdr, args)) { - gf_log_callingfn ("xdr", GF_LOG_WARNING, - "XDR decoding failed"); - ret = -1; - goto ret; - } - - ret = xdr_decoded_length (xdr); -ret: - return ret; -} - - -bool_t -xdr_gf_dump_req (XDR *xdrs, gf_dump_req *objp) -{ - if (!xdr_u_quad_t (xdrs, &objp->gfs_id)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gf_prog_detail (XDR *xdrs, gf_prog_detail *objp) -{ - if (!xdr_string (xdrs, &objp->progname, ~0)) - return FALSE; - if (!xdr_u_quad_t (xdrs, &objp->prognum)) - return FALSE; - if (!xdr_u_quad_t (xdrs, &objp->progver)) - return FALSE; - if (!xdr_pointer (xdrs, (char **)&objp->next, sizeof (gf_prog_detail), - (xdrproc_t) xdr_gf_prog_detail)) - return FALSE; - return TRUE; -} - -bool_t -xdr_gf_dump_rsp (XDR *xdrs, gf_dump_rsp *objp) -{ - if (!xdr_u_quad_t (xdrs, &objp->gfs_id)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_ret)) - return FALSE; - if (!xdr_int (xdrs, &objp->op_errno)) - return FALSE; - if (!xdr_pointer (xdrs, (char **)&objp->prog, sizeof (gf_prog_detail), - (xdrproc_t) xdr_gf_prog_detail)) - return FALSE; - return TRUE; -} - - -ssize_t -xdr_serialize_dump_rsp (struct iovec outmsg, void *rsp) -{ - return xdr_serialize_generic (outmsg, (void *)rsp, - (xdrproc_t)xdr_gf_dump_rsp); -} - -ssize_t -xdr_to_dump_req (struct iovec inmsg, void *args) -{ - return xdr_to_generic (inmsg, (void *)args, - (xdrproc_t)xdr_gf_dump_req); -} - - -ssize_t -xdr_from_dump_req (struct iovec outmsg, void *rsp) -{ - return xdr_serialize_generic (outmsg, (void *)rsp, - (xdrproc_t)xdr_gf_dump_req); -} - -ssize_t -xdr_to_dump_rsp (struct iovec inmsg, void *args) -{ - return xdr_to_generic (inmsg, (void *)args, - (xdrproc_t)xdr_gf_dump_rsp); -} diff --git a/rpc/rpc-lib/src/rpcsvc-auth.c b/rpc/rpc-lib/src/rpcsvc-auth.c index d62bd100b..930eabdda 100644 --- a/rpc/rpc-lib/src/rpcsvc-auth.c +++ b/rpc/rpc-lib/src/rpcsvc-auth.c @@ -29,6 +29,8 @@ rpcsvc_auth_unix_init (rpcsvc_t *svc, dict_t *options); extern rpcsvc_auth_t * 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); int rpcsvc_auth_add_initer (struct list_head *list, char *idfier, @@ -66,6 +68,16 @@ rpcsvc_auth_add_initers (rpcsvc_t *svc) 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-unix", (rpcsvc_auth_initer_t) rpcsvc_auth_unix_init); @@ -434,8 +446,12 @@ rpcsvc_auth_unix_auxgids (rpcsvc_request_t *req, int *arrlen) return NULL; /* In case of AUTH_NULL auxgids are not used */ - if ((req->cred.flavour != AUTH_UNIX) && - (req->cred.flavour != AUTH_GLUSTERFS)) { + switch (req->cred.flavour) { + case AUTH_UNIX: + case AUTH_GLUSTERFS: + case AUTH_GLUSTERFS_v2: + break; + default: gf_log ("rpc", GF_LOG_DEBUG, "auth type not unix or glusterfs"); return NULL; } diff --git a/rpc/rpc-lib/src/rpcsvc.c b/rpc/rpc-lib/src/rpcsvc.c index 5805f8a5c..e0fc29184 100644 --- a/rpc/rpc-lib/src/rpcsvc.c +++ b/rpc/rpc-lib/src/rpcsvc.c @@ -34,6 +34,8 @@ #include "iobuf.h" #include "globals.h" #include "xdr-common.h" +#include "xdr-generic.h" +#include "rpc-common-xdr.h" #include #include @@ -1687,7 +1689,7 @@ fail: iov.iov_base = rsp_buf; iov.iov_len = dump_rsp_len; - ret = xdr_serialize_dump_rsp (iov, &rsp); + ret = xdr_serialize_generic (iov, &rsp, (xdrproc_t)xdr_gf_dump_rsp); if (ret < 0) { if (req) req->rpc_err = GARBAGE_ARGS; diff --git a/rpc/rpc-lib/src/rpcsvc.h b/rpc/rpc-lib/src/rpcsvc.h index 83aa33f80..b15476704 100644 --- a/rpc/rpc-lib/src/rpcsvc.h +++ b/rpc/rpc-lib/src/rpcsvc.h @@ -43,10 +43,6 @@ #include #include "compat.h" -#ifndef NGRPS -#define NGRPS 16 -#endif /* !NGRPS */ - #ifndef MAX_IOVEC #define MAX_IOVEC 16 #endif @@ -115,8 +111,6 @@ #define AUTH_KERB 4 /* kerberos style */ #endif /* */ -#define AUTH_GLUSTERFS 5 - typedef struct rpcsvc_program rpcsvc_program_t; struct rpcsvc_notify_wrapper { @@ -143,11 +137,10 @@ struct rpcsvc_config { int max_block_size; }; -#define RPCSVC_MAX_AUTH_BYTES 400 typedef struct rpcsvc_auth_data { int flavour; int datalen; - char authdata[RPCSVC_MAX_AUTH_BYTES]; + char authdata[GF_MAX_AUTH_BYTES]; } rpcsvc_auth_data_t; #define rpcsvc_auth_flavour(au) ((au).flavour) @@ -184,13 +177,13 @@ struct rpcsvc_request { gid_t gid; pid_t pid; - uint64_t lk_owner; + gf_lkowner_t lk_owner; uint64_t gfs_id; /* Might want to move this to AUTH_UNIX specific state since this array * is not available for every authentication scheme. */ - gid_t auxgids[NGRPS]; + gid_t auxgids[GF_MAX_AUX_GROUPS]; int auxgidcount; diff --git a/rpc/rpc-lib/src/xdr-common.h b/rpc/rpc-lib/src/xdr-common.h index 8402a6222..d5198d20f 100644 --- a/rpc/rpc-lib/src/xdr-common.h +++ b/rpc/rpc-lib/src/xdr-common.h @@ -34,7 +34,6 @@ #include #endif /* __NetBSD__ */ - enum gf_dump_procnum { GF_DUMP_NULL, GF_DUMP_DUMP, @@ -44,6 +43,7 @@ enum gf_dump_procnum { #define GLUSTER_DUMP_PROGRAM 123451501 /* Completely random */ #define GLUSTER_DUMP_VERSION 1 +#define GF_MAX_AUTH_BYTES 2048 #if GF_DARWIN_HOST_OS #define xdr_u_quad_t xdr_u_int64_t @@ -67,52 +67,6 @@ enum gf_dump_procnum { #define xdr_uint32_t xdr_uint32_t #endif -struct auth_glusterfs_parms { - uint64_t lk_owner; - u_int pid; - u_int uid; - u_int gid; - u_int ngrps; - u_int groups[16]; -} __attribute__((packed)); -typedef struct auth_glusterfs_parms auth_glusterfs_parms; - -struct gf_dump_req { - uint64_t gfs_id; -} __attribute__((packed)); -typedef struct gf_dump_req gf_dump_req; - -struct gf_prog_detail { - char *progname; - uint64_t prognum; - uint64_t progver; - struct gf_prog_detail *next; -} __attribute__((packed)); -typedef struct gf_prog_detail gf_prog_detail; - -struct gf_dump_rsp { - uint64_t gfs_id; - int op_ret; - int op_errno; - struct gf_prog_detail *prog; -}__attribute__((packed)); -typedef struct gf_dump_rsp gf_dump_rsp; - -extern bool_t -xdr_auth_glusterfs_parms (XDR *xdrs, auth_glusterfs_parms *objp); -extern bool_t xdr_gf_dump_req (XDR *, gf_dump_req*); -extern bool_t xdr_gf_prog_detail (XDR *, gf_prog_detail*); -extern bool_t xdr_gf_dump_rsp (XDR *, gf_dump_rsp*); - -ssize_t -xdr_serialize_dump_rsp (struct iovec outmsg, void *rsp); -ssize_t -xdr_to_dump_req (struct iovec inmsg, void *args); -ssize_t -xdr_from_dump_req (struct iovec outmsg, void *rsp); -ssize_t -xdr_to_dump_rsp (struct iovec inmsg, void *args); - /* Returns the address of the byte that follows the * last byte used for decoding the previous xdr component. * E.g. once the RPC call for NFS has been decoded, the macro will return diff --git a/rpc/rpc-lib/src/xdr-rpc.h b/rpc/rpc-lib/src/xdr-rpc.h index 99ad88836..226f8e8b3 100644 --- a/rpc/rpc-lib/src/xdr-rpc.h +++ b/rpc/rpc-lib/src/xdr-rpc.h @@ -17,7 +17,7 @@ . */ -#ifndef _XDR_RPC_H +#ifndef _XDR_RPC_H_ #define _XDR_RPC_H_ #ifndef _CONFIG_H @@ -39,6 +39,13 @@ #include #include +#include "xdr-common.h" + +typedef enum { + AUTH_GLUSTERFS = 5, + AUTH_GLUSTERFS_v2 = 6, +} gf_rpc_authtype_t; + /* Converts a given network buffer from its XDR format to a structure * that contains everything an RPC call needs to work. */ diff --git a/rpc/rpc-transport/rdma/src/Makefile.am b/rpc/rpc-transport/rdma/src/Makefile.am index bc888b175..b4b940bca 100644 --- a/rpc/rpc-transport/rdma/src/Makefile.am +++ b/rpc/rpc-transport/rdma/src/Makefile.am @@ -15,6 +15,6 @@ noinst_HEADERS = rdma.h name.h AM_CFLAGS = -fPIC -D_FILE_OFFSET_BITS=64 -D_GNU_SOURCE -Wall -D$(GF_HOST_OS) \ -I$(top_srcdir)/libglusterfs/src -I$(top_srcdir)/rpc/rpc-lib/src/ \ - -I$(top_srcdir)/xlators/protocol/lib/src -shared -nostartfiles $(GF_CFLAGS) + -I$(top_srcdir)/rpc/xdr/src -shared -nostartfiles $(GF_CFLAGS) CLEANFILES = *~ diff --git a/rpc/xdr/src/Makefile.am b/rpc/xdr/src/Makefile.am index cabab3db6..57c193387 100644 --- a/rpc/xdr/src/Makefile.am +++ b/rpc/xdr/src/Makefile.am @@ -9,14 +9,14 @@ libgfxdr_la_CPPFLAGS = -D_FILE_OFFSET_BITS=64 -D__USE_FILE_OFFSET64 \ libgfxdr_la_LIBADD = $(top_builddir)/libglusterfs/src/libglusterfs.la \ $(top_builddir)/rpc/rpc-lib/src/libgfrpc.la -libgfxdr_la_SOURCES = xdr-generic.c \ +libgfxdr_la_SOURCES = xdr-generic.c rpc-common-xdr.c \ glusterfs3-xdr.c \ cli1-xdr.c \ glusterd1-xdr.c \ portmap-xdr.c \ xdr-nfs3.c msg-nfs3.c -noinst_HEADERS = xdr-generic.h \ +noinst_HEADERS = xdr-generic.h rpc-common-xdr.h \ glusterfs3-xdr.h glusterfs3.h \ cli1-xdr.h \ glusterd1-xdr.h \ diff --git a/rpc/xdr/src/glusterfs3-xdr.c b/rpc/xdr/src/glusterfs3-xdr.c index 64e504f46..62cff241d 100644 --- a/rpc/xdr/src/glusterfs3-xdr.c +++ b/rpc/xdr/src/glusterfs3-xdr.c @@ -80,7 +80,7 @@ xdr_gf_proto_flock (XDR *xdrs, gf_proto_flock *objp) return FALSE; if (!xdr_u_int (xdrs, &objp->pid)) return FALSE; - if (!xdr_u_quad_t (xdrs, &objp->owner)) + if (!xdr_bytes (xdrs, (char **)&objp->lk_owner.lk_owner_val, (u_int *) &objp->lk_owner.lk_owner_len, ~0)) return FALSE; return TRUE; } diff --git a/rpc/xdr/src/glusterfs3-xdr.h b/rpc/xdr/src/glusterfs3-xdr.h index 0c8af17d2..d9cf7926f 100644 --- a/rpc/xdr/src/glusterfs3-xdr.h +++ b/rpc/xdr/src/glusterfs3-xdr.h @@ -63,7 +63,10 @@ struct gf_proto_flock { u_quad_t start; u_quad_t len; u_int pid; - u_quad_t owner; + struct { + u_int lk_owner_len; + char *lk_owner_val; + } lk_owner; }; typedef struct gf_proto_flock gf_proto_flock; diff --git a/rpc/xdr/src/glusterfs3-xdr.x b/rpc/xdr/src/glusterfs3-xdr.x index 592f7ed70..131feff1b 100644 --- a/rpc/xdr/src/glusterfs3-xdr.x +++ b/rpc/xdr/src/glusterfs3-xdr.x @@ -19,7 +19,7 @@ struct gf_proto_flock { unsigned hyper start; unsigned hyper len; unsigned int pid; - unsigned hyper owner; + opaque lk_owner<>; } ; diff --git a/rpc/xdr/src/glusterfs3.h b/rpc/xdr/src/glusterfs3.h index ba64a0b45..82a9e2001 100644 --- a/rpc/xdr/src/glusterfs3.h +++ b/rpc/xdr/src/glusterfs3.h @@ -197,7 +197,11 @@ gf_proto_flock_to_flock (struct gf_proto_flock *gf_proto_flock, struct gf_flock gf_flock->l_start = gf_proto_flock->start; gf_flock->l_len = gf_proto_flock->len; gf_flock->l_pid = gf_proto_flock->pid; - gf_flock->l_owner = gf_proto_flock->owner; + gf_flock->l_owner.len = gf_proto_flock->lk_owner.lk_owner_len; + if (gf_flock->l_owner.len && + (gf_flock->l_owner.len < GF_MAX_LOCK_OWNER_LEN)) + memcpy (gf_flock->l_owner.data, gf_proto_flock->lk_owner.lk_owner_val, + gf_flock->l_owner.len); } @@ -212,7 +216,9 @@ gf_proto_flock_from_flock (struct gf_proto_flock *gf_proto_flock, struct gf_floc gf_proto_flock->start = (gf_flock->l_start); gf_proto_flock->len = (gf_flock->l_len); gf_proto_flock->pid = (gf_flock->l_pid); - gf_proto_flock->owner = (gf_flock->l_owner); + gf_proto_flock->lk_owner.lk_owner_len = gf_flock->l_owner.len; + if (gf_flock->l_owner.len) + gf_proto_flock->lk_owner.lk_owner_val = gf_flock->l_owner.data; } static inline void diff --git a/rpc/xdr/src/msg-nfs3.c b/rpc/xdr/src/msg-nfs3.c index d760d43b5..5fc92123c 100644 --- a/rpc/xdr/src/msg-nfs3.c +++ b/rpc/xdr/src/msg-nfs3.c @@ -63,84 +63,6 @@ ret: return ret; } -/* -ssize_t -xdr_serialize_generic (struct iovec outmsg, void *res, xdrproc_t proc) -{ - ssize_t ret = -1; - XDR xdr; - - if ((!outmsg.iov_base) || (!res) || (!proc)) - return -1; - - xdrmem_create (&xdr, outmsg.iov_base, (unsigned int)outmsg.iov_len, - XDR_ENCODE); - - if (!proc (&xdr, res)) { - ret = -1; - goto ret; - } - - ret = xdr_encoded_length (xdr); - -ret: - return ret; -} - - -ssize_t -xdr_to_generic (struct iovec inmsg, void *args, xdrproc_t proc) -{ - XDR xdr; - ssize_t ret = -1; - - if ((!inmsg.iov_base) || (!args) || (!proc)) - return -1; - - xdrmem_create (&xdr, inmsg.iov_base, (unsigned int)inmsg.iov_len, - XDR_DECODE); - - if (!proc (&xdr, args)) { - ret = -1; - goto ret; - } - - ret = xdr_decoded_length (xdr); -ret: - return ret; -} - - -ssize_t -xdr_to_generic_payload (struct iovec inmsg, void *args, xdrproc_t proc, - struct iovec *pendingpayload) -{ - XDR xdr; - ssize_t ret = -1; - - if ((!inmsg.iov_base) || (!args) || (!proc)) - return -1; - - xdrmem_create (&xdr, inmsg.iov_base, (unsigned int)inmsg.iov_len, - XDR_DECODE); - - if (!proc (&xdr, args)) { - ret = -1; - goto ret; - } - - ret = xdr_decoded_length (xdr); - - if (pendingpayload) { - pendingpayload->iov_base = xdr_decoded_remaining_addr (xdr); - pendingpayload->iov_len = xdr_decoded_remaining_len (xdr); - } - -ret: - return ret; -} -*/ - /* Translate the mountres3 structure in res into XDR format into memory * referenced by outmsg.iov_base. * Returns the number of bytes used in encoding into XDR format. diff --git a/rpc/xdr/src/rpc-common-xdr.c b/rpc/xdr/src/rpc-common-xdr.c new file mode 100644 index 000000000..14ddea715 --- /dev/null +++ b/rpc/xdr/src/rpc-common-xdr.c @@ -0,0 +1,232 @@ +/* + Copyright (c) 2007-2011 Gluster, Inc. + This file is part of GlusterFS. + + GlusterFS is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published + by the Free Software Foundation; either version 3 of the License, + or (at your option) any later version. + + GlusterFS is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see + . +*/ + +#include "xdr-common.h" +#include "compat.h" + +#if defined(__GNUC__) +#if __GNUC__ >= 4 +#pragma GCC diagnostic ignored "-Wunused-but-set-variable" +#endif +#endif + +/* + * Please do not edit this file. + * It was generated using rpcgen. + */ + +#include "rpc-common-xdr.h" + +bool_t +xdr_auth_glusterfs_parms_v2 (XDR *xdrs, auth_glusterfs_parms_v2 *objp) +{ + register int32_t *buf; + buf = NULL; + + + if (xdrs->x_op == XDR_ENCODE) { + buf = XDR_INLINE (xdrs, 3 * BYTES_PER_XDR_UNIT); + if (buf == NULL) { + if (!xdr_int (xdrs, &objp->pid)) + return FALSE; + if (!xdr_u_int (xdrs, &objp->uid)) + return FALSE; + if (!xdr_u_int (xdrs, &objp->gid)) + return FALSE; + + } else { + IXDR_PUT_LONG(buf, objp->pid); + IXDR_PUT_U_LONG(buf, objp->uid); + IXDR_PUT_U_LONG(buf, objp->gid); + } + if (!xdr_array (xdrs, (char **)&objp->groups.groups_val, (u_int *) &objp->groups.groups_len, ~0, + sizeof (u_int), (xdrproc_t) xdr_u_int)) + return FALSE; + if (!xdr_bytes (xdrs, (char **)&objp->lk_owner.lk_owner_val, (u_int *) &objp->lk_owner.lk_owner_len, ~0)) + return FALSE; + return TRUE; + } else if (xdrs->x_op == XDR_DECODE) { + buf = XDR_INLINE (xdrs, 3 * BYTES_PER_XDR_UNIT); + if (buf == NULL) { + if (!xdr_int (xdrs, &objp->pid)) + return FALSE; + if (!xdr_u_int (xdrs, &objp->uid)) + return FALSE; + if (!xdr_u_int (xdrs, &objp->gid)) + return FALSE; + + } else { + objp->pid = IXDR_GET_LONG(buf); + objp->uid = IXDR_GET_U_LONG(buf); + objp->gid = IXDR_GET_U_LONG(buf); + } + if (!xdr_array (xdrs, (char **)&objp->groups.groups_val, (u_int *) &objp->groups.groups_len, ~0, + sizeof (u_int), (xdrproc_t) xdr_u_int)) + return FALSE; + if (!xdr_bytes (xdrs, (char **)&objp->lk_owner.lk_owner_val, (u_int *) &objp->lk_owner.lk_owner_len, ~0)) + return FALSE; + return TRUE; + } + + if (!xdr_int (xdrs, &objp->pid)) + return FALSE; + if (!xdr_u_int (xdrs, &objp->uid)) + return FALSE; + if (!xdr_u_int (xdrs, &objp->gid)) + return FALSE; + if (!xdr_array (xdrs, (char **)&objp->groups.groups_val, (u_int *) &objp->groups.groups_len, ~0, + sizeof (u_int), (xdrproc_t) xdr_u_int)) + return FALSE; + if (!xdr_bytes (xdrs, (char **)&objp->lk_owner.lk_owner_val, (u_int *) &objp->lk_owner.lk_owner_len, ~0)) + return FALSE; + return TRUE; +} + +bool_t +xdr_auth_glusterfs_parms (XDR *xdrs, auth_glusterfs_parms *objp) +{ + register int32_t *buf; + int i; + buf = NULL; + + + if (xdrs->x_op == XDR_ENCODE) { + if (!xdr_u_quad_t (xdrs, &objp->lk_owner)) + return FALSE; + buf = XDR_INLINE (xdrs, (4 + 16 )* BYTES_PER_XDR_UNIT); + if (buf == NULL) { + if (!xdr_u_int (xdrs, &objp->pid)) + return FALSE; + if (!xdr_u_int (xdrs, &objp->uid)) + return FALSE; + if (!xdr_u_int (xdrs, &objp->gid)) + return FALSE; + if (!xdr_u_int (xdrs, &objp->ngrps)) + return FALSE; + if (!xdr_vector (xdrs, (char *)objp->groups, 16, + sizeof (u_int), (xdrproc_t) xdr_u_int)) + return FALSE; + } else { + IXDR_PUT_U_LONG(buf, objp->pid); + IXDR_PUT_U_LONG(buf, objp->uid); + IXDR_PUT_U_LONG(buf, objp->gid); + IXDR_PUT_U_LONG(buf, objp->ngrps); + { + register u_int *genp; + + for (i = 0, genp = objp->groups; + i < 16; ++i) { + IXDR_PUT_U_LONG(buf, *genp++); + } + } + } + return TRUE; + } else if (xdrs->x_op == XDR_DECODE) { + if (!xdr_u_quad_t (xdrs, &objp->lk_owner)) + return FALSE; + buf = XDR_INLINE (xdrs, (4 + 16 )* BYTES_PER_XDR_UNIT); + if (buf == NULL) { + if (!xdr_u_int (xdrs, &objp->pid)) + return FALSE; + if (!xdr_u_int (xdrs, &objp->uid)) + return FALSE; + if (!xdr_u_int (xdrs, &objp->gid)) + return FALSE; + if (!xdr_u_int (xdrs, &objp->ngrps)) + return FALSE; + if (!xdr_vector (xdrs, (char *)objp->groups, 16, + sizeof (u_int), (xdrproc_t) xdr_u_int)) + return FALSE; + } else { + objp->pid = IXDR_GET_U_LONG(buf); + objp->uid = IXDR_GET_U_LONG(buf); + objp->gid = IXDR_GET_U_LONG(buf); + objp->ngrps = IXDR_GET_U_LONG(buf); + { + register u_int *genp; + + for (i = 0, genp = objp->groups; + i < 16; ++i) { + *genp++ = IXDR_GET_U_LONG(buf); + } + } + } + return TRUE; + } + + if (!xdr_u_quad_t (xdrs, &objp->lk_owner)) + return FALSE; + if (!xdr_u_int (xdrs, &objp->pid)) + return FALSE; + if (!xdr_u_int (xdrs, &objp->uid)) + return FALSE; + if (!xdr_u_int (xdrs, &objp->gid)) + return FALSE; + if (!xdr_u_int (xdrs, &objp->ngrps)) + return FALSE; + if (!xdr_vector (xdrs, (char *)objp->groups, 16, + sizeof (u_int), (xdrproc_t) xdr_u_int)) + return FALSE; + return TRUE; +} + +bool_t +xdr_gf_dump_req (XDR *xdrs, gf_dump_req *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!xdr_u_quad_t (xdrs, &objp->gfs_id)) + return FALSE; + return TRUE; +} + +bool_t +xdr_gf_prog_detail (XDR *xdrs, gf_prog_detail *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!xdr_string (xdrs, &objp->progname, ~0)) + return FALSE; + if (!xdr_u_quad_t (xdrs, &objp->prognum)) + return FALSE; + if (!xdr_u_quad_t (xdrs, &objp->progver)) + return FALSE; + if (!xdr_pointer (xdrs, (char **)&objp->next, sizeof (gf_prog_detail), (xdrproc_t) xdr_gf_prog_detail)) + return FALSE; + return TRUE; +} + +bool_t +xdr_gf_dump_rsp (XDR *xdrs, gf_dump_rsp *objp) +{ + register int32_t *buf; + buf = NULL; + + if (!xdr_u_quad_t (xdrs, &objp->gfs_id)) + return FALSE; + if (!xdr_int (xdrs, &objp->op_ret)) + return FALSE; + if (!xdr_int (xdrs, &objp->op_errno)) + return FALSE; + if (!xdr_pointer (xdrs, (char **)&objp->prog, sizeof (gf_prog_detail), (xdrproc_t) xdr_gf_prog_detail)) + return FALSE; + return TRUE; +} diff --git a/rpc/xdr/src/rpc-common-xdr.h b/rpc/xdr/src/rpc-common-xdr.h new file mode 100644 index 000000000..66d9c3772 --- /dev/null +++ b/rpc/xdr/src/rpc-common-xdr.h @@ -0,0 +1,113 @@ +/* + Copyright (c) 2007-2011 Gluster, Inc. + This file is part of GlusterFS. + + GlusterFS is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published + by the Free Software Foundation; either version 3 of the License, + or (at your option) any later version. + + GlusterFS is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see + . +*/ + +#include "xdr-common.h" +#include "compat.h" + +#if defined(__GNUC__) +#if __GNUC__ >= 4 +#pragma GCC diagnostic ignored "-Wunused-but-set-variable" +#endif +#endif + +/* + * Please do not edit this file. + * It was generated using rpcgen. + */ + +#ifndef _RPC_COMMON_XDR_H_RPCGEN +#define _RPC_COMMON_XDR_H_RPCGEN + +#include + + +#ifdef __cplusplus +extern "C" { +#endif + + +struct auth_glusterfs_parms_v2 { + int pid; + u_int uid; + u_int gid; + struct { + u_int groups_len; + u_int *groups_val; + } groups; + struct { + u_int lk_owner_len; + char *lk_owner_val; + } lk_owner; +}; +typedef struct auth_glusterfs_parms_v2 auth_glusterfs_parms_v2; + +struct auth_glusterfs_parms { + u_quad_t lk_owner; + u_int pid; + u_int uid; + u_int gid; + u_int ngrps; + u_int groups[16]; +}; +typedef struct auth_glusterfs_parms auth_glusterfs_parms; + +struct gf_dump_req { + u_quad_t gfs_id; +}; +typedef struct gf_dump_req gf_dump_req; + +struct gf_prog_detail { + char *progname; + u_quad_t prognum; + u_quad_t progver; + struct gf_prog_detail *next; +}; +typedef struct gf_prog_detail gf_prog_detail; + +struct gf_dump_rsp { + u_quad_t gfs_id; + int op_ret; + int op_errno; + struct gf_prog_detail *prog; +}; +typedef struct gf_dump_rsp gf_dump_rsp; + +/* the xdr functions */ + +#if defined(__STDC__) || defined(__cplusplus) +extern bool_t xdr_auth_glusterfs_parms_v2 (XDR *, auth_glusterfs_parms_v2*); +extern bool_t xdr_auth_glusterfs_parms (XDR *, auth_glusterfs_parms*); +extern bool_t xdr_gf_dump_req (XDR *, gf_dump_req*); +extern bool_t xdr_gf_prog_detail (XDR *, gf_prog_detail*); +extern bool_t xdr_gf_dump_rsp (XDR *, gf_dump_rsp*); + +#else /* K&R C */ +extern bool_t xdr_auth_glusterfs_parms_v2 (); +extern bool_t xdr_auth_glusterfs_parms (); +extern bool_t xdr_gf_dump_req (); +extern bool_t xdr_gf_prog_detail (); +extern bool_t xdr_gf_dump_rsp (); + +#endif /* K&R C */ + +#ifdef __cplusplus +} +#endif + +#endif /* !_RPC_COMMON_XDR_H_RPCGEN */ diff --git a/rpc/xdr/src/rpc-common-xdr.x b/rpc/xdr/src/rpc-common-xdr.x new file mode 100644 index 000000000..ca28f38b5 --- /dev/null +++ b/rpc/xdr/src/rpc-common-xdr.x @@ -0,0 +1,39 @@ +/* This file has definition of few XDR structures which are + * not captured in any section specific file */ + +struct auth_glusterfs_parms_v2 { + int pid; + unsigned int uid; + unsigned int gid; + unsigned int groups<>; + opaque lk_owner<>; +}; + +struct auth_glusterfs_parms { + unsigned hyper lk_owner; + unsigned int pid; + unsigned int uid; + unsigned int gid; + unsigned int ngrps; + unsigned groups[16]; +}; + +struct gf_dump_req { + unsigned hyper gfs_id; +}; + + +struct gf_prog_detail { + string progname<>; + unsigned hyper prognum; + unsigned hyper progver; + struct gf_prog_detail *next; +}; + + +struct gf_dump_rsp { + unsigned hyper gfs_id; + int op_ret; + int op_errno; + struct gf_prog_detail *prog; +}; diff --git a/xlators/cluster/afr/src/afr-lk-common.c b/xlators/cluster/afr/src/afr-lk-common.c index 41fa8a30b..2fe134990 100644 --- a/xlators/cluster/afr/src/afr-lk-common.c +++ b/xlators/cluster/afr/src/afr-lk-common.c @@ -62,7 +62,8 @@ afr_set_lk_owner (call_frame_t *frame, xlator_t *this) gf_log (this->name, GF_LOG_TRACE, "Setting lk-owner=%llu", (unsigned long long) (unsigned long)frame->root); - frame->root->lk_owner = (uint64_t) (unsigned long)frame->root; + + set_lk_owner_from_ptr (&frame->root->lk_owner, frame->root); } static int @@ -115,7 +116,7 @@ internal_lock_count (call_frame_t *frame, xlator_t *this) static void afr_print_inodelk (char *str, int size, int cmd, - struct gf_flock *flock, uint64_t owner) + struct gf_flock *flock, gf_lkowner_t *owner) { char *cmd_str = NULL; char *type_str = NULL; @@ -163,11 +164,11 @@ afr_print_inodelk (char *str, int size, int cmd, } snprintf (str, size, "lock=INODELK, cmd=%s, type=%s, " - "start=%llu, len=%llu, pid=%llu, lk-owner=%llu", + "start=%llu, len=%llu, pid=%llu, lk-owner=%s", cmd_str, type_str, (unsigned long long) flock->l_start, (unsigned long long) flock->l_len, (unsigned long long) flock->l_pid, - (unsigned long long) owner); + lkowner_utoa (owner)); } @@ -183,11 +184,11 @@ afr_print_lockee (char *str, int size, loc_t *loc, fd_t *fd, void afr_print_entrylk (char *str, int size, const char *basename, - uint64_t owner) + gf_lkowner_t *owner) { - snprintf (str, size, "Basename=%s, lk-owner=%llu", + snprintf (str, size, "Basename=%s, lk-owner=%s", basename ? basename : "", - (unsigned long long)owner); + lkowner_utoa (owner)); } static void @@ -302,7 +303,7 @@ afr_trace_inodelk_in (call_frame_t *frame, afr_lock_call_type_t lock_call_type, return; } - afr_print_inodelk (lock, 256, cmd, flock, frame->root->lk_owner); + afr_print_inodelk (lock, 256, cmd, flock, &frame->root->lk_owner); afr_print_lockee (lockee, 256, &local->loc, local->fd, child_index); afr_set_lock_call_type (lock_call_type, lock_call_type_str, int_lock); @@ -339,7 +340,7 @@ afr_trace_entrylk_in (call_frame_t *frame, afr_lock_call_type_t lock_call_type, return; } - afr_print_entrylk (lock, 256, basename, frame->root->lk_owner); + afr_print_entrylk (lock, 256, basename, &frame->root->lk_owner); afr_print_lockee (lockee, 256, &local->loc, local->fd, child_index); afr_set_lock_call_type (lock_call_type, lock_call_type_str, int_lock); @@ -602,8 +603,8 @@ afr_unlock_inodelk (call_frame_t *frame, xlator_t *this) flock.l_type = F_UNLCK; gf_log (this->name, GF_LOG_DEBUG, "attempting data unlock range %"PRIu64 - " %"PRIu64" by %"PRIu64, flock.l_start, flock.l_len, - frame->root->lk_owner); + " %"PRIu64" by %s", flock.l_start, flock.l_len, + lkowner_utoa (&frame->root->lk_owner)); call_count = afr_locked_nodes_count (int_lock->inode_locked_nodes, priv->child_count); @@ -1422,8 +1423,8 @@ afr_nonblocking_inodelk (call_frame_t *frame, xlator_t *this) flock.l_type = int_lock->lk_flock.l_type; gf_log (this->name, GF_LOG_DEBUG, "attempting data lock range %"PRIu64 - " %"PRIu64" by %"PRIu64, flock.l_start, flock.l_len, - frame->root->lk_owner); + " %"PRIu64" by %s", flock.l_start, flock.l_len, + lkowner_utoa (&frame->root->lk_owner)); full_flock.l_type = int_lock->lk_flock.l_type; diff --git a/xlators/cluster/afr/src/afr-self-heal-data.c b/xlators/cluster/afr/src/afr-self-heal-data.c index 83920c081..c1c1d483e 100644 --- a/xlators/cluster/afr/src/afr-self-heal-data.c +++ b/xlators/cluster/afr/src/afr-self-heal-data.c @@ -395,8 +395,8 @@ afr_sh_data_erase_pending (call_frame_t *frame, xlator_t *this) afr_sh_pending_to_delta (priv, sh->xattr, sh->delta_matrix, sh->success, priv->child_count, AFR_DATA_TRANSACTION); - gf_log (this->name, GF_LOG_DEBUG, "Delta matrix for: %"PRIu64, - frame->root->lk_owner); + gf_log (this->name, GF_LOG_DEBUG, "Delta matrix for: %s", + lkowner_utoa (&frame->root->lk_owner)); afr_sh_print_pending_matrix (sh->delta_matrix, this); erase_xattr = GF_CALLOC (sizeof (*erase_xattr), priv->child_count, @@ -658,8 +658,9 @@ afr_sh_data_fix (call_frame_t *frame, xlator_t *this) sh = &local->self_heal; priv = this->private; - gf_log (this->name, GF_LOG_DEBUG, "Pending matrix for: %"PRIu64, - frame->root->lk_owner); + gf_log (this->name, GF_LOG_DEBUG, "Pending matrix for: %s", + lkowner_utoa (&frame->root->lk_owner)); + nsources = afr_build_sources (this, sh->xattr, sh->buf, sh->pending_matrix, sh->sources, sh->success_children, AFR_DATA_TRANSACTION, NULL, _gf_false); @@ -1131,14 +1132,16 @@ afr_sh_data_post_blocking_inodelk_cbk (call_frame_t *frame, xlator_t *this) if (int_lock->lock_op_ret < 0) { gf_log (this->name, GF_LOG_ERROR, "Blocking data inodelks " - "failed for %s. by %"PRIu64, - local->loc.path, frame->root->lk_owner); + "failed for %s. by %s", + local->loc.path, lkowner_utoa (&frame->root->lk_owner)); + sh->data_lock_failure_handler (frame, this); } else { gf_log (this->name, GF_LOG_DEBUG, "Blocking data inodelks " - "done for %s by %"PRIu64". Proceding to self-heal", - local->loc.path, frame->root->lk_owner); + "done for %s by %s. Proceding to self-heal", + local->loc.path, lkowner_utoa (&frame->root->lk_owner)); + sh->data_lock_success_handler (frame, this); } @@ -1158,15 +1161,16 @@ afr_sh_data_post_nonblocking_inodelk_cbk (call_frame_t *frame, xlator_t *this) if (int_lock->lock_op_ret < 0) { gf_log (this->name, GF_LOG_DEBUG, "Non Blocking data inodelks " - "failed for %s. by %"PRIu64, - local->loc.path, frame->root->lk_owner); + "failed for %s. by %s", + local->loc.path, lkowner_utoa (&frame->root->lk_owner)); + int_lock->lock_cbk = afr_sh_data_post_blocking_inodelk_cbk; afr_blocking_lock (frame, this); } else { gf_log (this->name, GF_LOG_DEBUG, "Non Blocking data inodelks " - "done for %s by %"PRIu64". Proceeding to self-heal", - local->loc.path, frame->root->lk_owner); + "done for %s by %s. Proceeding to self-heal", + local->loc.path, lkowner_utoa (&frame->root->lk_owner)); sh->data_lock_success_handler (frame, this); } diff --git a/xlators/cluster/afr/src/pump.c b/xlators/cluster/afr/src/pump.c index b92c50e85..73389009d 100644 --- a/xlators/cluster/afr/src/pump.c +++ b/xlators/cluster/afr/src/pump.c @@ -694,7 +694,7 @@ pump_start (call_frame_t *pump_frame, xlator_t *this) priv = this->private; pump_priv = priv->pump_private; - pump_frame->root->lk_owner = (uint64_t) (unsigned long)pump_frame->root; + afr_set_lk_owner (pump_frame, this); pump_pid = (uint64_t) (unsigned long)pump_frame->root; ret = synctask_new (pump_priv->env, pump_task, @@ -708,8 +708,8 @@ pump_start (call_frame_t *pump_frame, xlator_t *this) } gf_log (this->name, GF_LOG_DEBUG, - "setting pump as started lk_owner: %"PRIu64" %"PRIu64, - pump_frame->root->lk_owner, pump_pid); + "setting pump as started lk_owner: %s %"PRIu64, + lkowner_utoa (&pump_frame->root->lk_owner), pump_pid); priv->use_afr_in_pump = 1; out: diff --git a/xlators/features/locks/src/common.c b/xlators/features/locks/src/common.c index f6b9c3315..0bc7baa30 100644 --- a/xlators/features/locks/src/common.c +++ b/xlators/features/locks/src/common.c @@ -143,9 +143,9 @@ __pl_inode_is_empty (pl_inode_t *pl_inode) void pl_print_locker (char *str, int size, xlator_t *this, call_frame_t *frame) { - snprintf (str, size, "Pid=%llu, lk-owner=%llu, Transport=%p, Frame=%llu", + snprintf (str, size, "Pid=%llu, lk-owner=%s, Transport=%p, Frame=%llu", (unsigned long long) frame->root->pid, - (unsigned long long) frame->root->lk_owner, + lkowner_utoa (&frame->root->lk_owner), (void *)frame->root->trans, (unsigned long long) frame->root->unique); } @@ -187,7 +187,7 @@ pl_print_lockee (char *str, int size, fd_t *fd, loc_t *loc) void pl_print_lock (char *str, int size, int cmd, - struct gf_flock *flock, uint64_t owner) + struct gf_flock *flock, gf_lkowner_t *owner) { char *cmd_str = NULL; char *type_str = NULL; @@ -235,11 +235,11 @@ pl_print_lock (char *str, int size, int cmd, } snprintf (str, size, "lock=FCNTL, cmd=%s, type=%s, " - "start=%llu, len=%llu, pid=%llu, lk-owner=%llu", + "start=%llu, len=%llu, pid=%llu, lk-owner=%s", cmd_str, type_str, (unsigned long long) flock->l_start, (unsigned long long) flock->l_len, (unsigned long long) flock->l_pid, - (unsigned long long) owner); + lkowner_utoa (owner)); } @@ -262,7 +262,7 @@ pl_trace_in (xlator_t *this, call_frame_t *frame, fd_t *fd, loc_t *loc, if (domain) pl_print_inodelk (pl_lock, 256, cmd, flock, domain); else - pl_print_lock (pl_lock, 256, cmd, flock, frame->root->lk_owner); + pl_print_lock (pl_lock, 256, cmd, flock, &frame->root->lk_owner); gf_log (this->name, GF_LOG_INFO, "[REQUEST] Locker = {%s} Lockee = {%s} Lock = {%s}", @@ -312,7 +312,7 @@ pl_trace_out (xlator_t *this, call_frame_t *frame, fd_t *fd, loc_t *loc, if (domain) pl_print_inodelk (pl_lock, 256, cmd, flock, domain); else - pl_print_lock (pl_lock, 256, cmd, flock, frame->root->lk_owner); + pl_print_lock (pl_lock, 256, cmd, flock, &frame->root->lk_owner); pl_print_verdict (verdict, 32, op_ret, op_errno); @@ -342,7 +342,7 @@ pl_trace_block (xlator_t *this, call_frame_t *frame, fd_t *fd, loc_t *loc, if (domain) pl_print_inodelk (pl_lock, 256, cmd, flock, domain); else - pl_print_lock (pl_lock, 256, cmd, flock, frame->root->lk_owner); + pl_print_lock (pl_lock, 256, cmd, flock, &frame->root->lk_owner); gf_log (this->name, GF_LOG_INFO, "[BLOCKED] Locker = {%s} Lockee = {%s} Lock = {%s}", @@ -468,7 +468,7 @@ out: /* Create a new posix_lock_t */ posix_lock_t * new_posix_lock (struct gf_flock *flock, void *transport, pid_t client_pid, - uint64_t owner, fd_t *fd) + gf_lkowner_t *owner, fd_t *fd) { posix_lock_t *lock = NULL; @@ -494,7 +494,7 @@ new_posix_lock (struct gf_flock *flock, void *transport, pid_t client_pid, lock->fd_num = fd_to_fdnum (fd); lock->fd = fd; lock->client_pid = client_pid; - lock->owner = owner; + lock->owner = *owner; INIT_LIST_HEAD (&lock->list); @@ -569,8 +569,8 @@ int same_owner (posix_lock_t *l1, posix_lock_t *l2) { - return ((l1->owner == l2->owner) && - (l1->transport == l2->transport)); + return (is_same_lkowner (&l1->owner, &l2->owner) && + (l1->transport == l2->transport)); } @@ -889,10 +889,9 @@ __grant_blocked_locks (xlator_t *this, pl_inode_t *pl_inode, struct list_head *g posix_lock_to_flock (l, &conf->user_flock); gf_log (this->name, GF_LOG_TRACE, - "%s (pid=%d) lk-owner:%"PRIu64" %"PRId64" - %"PRId64" => Granted", + "%s (pid=%d) lk-owner:%s %"PRId64" - %"PRId64" => Granted", l->fl_type == F_UNLCK ? "Unlock" : "Lock", - l->client_pid, - l->owner, + l->client_pid, lkowner_utoa (&l->owner), l->user_flock.l_start, l->user_flock.l_len); @@ -958,7 +957,7 @@ pl_send_prelock_unlock (xlator_t *this, pl_inode_t *pl_inode, unlock_lock = new_posix_lock (&flock, old_lock->transport, - old_lock->client_pid, old_lock->owner, + old_lock->client_pid, &old_lock->owner, old_lock->fd); GF_VALIDATE_OR_GOTO (this->name, unlock_lock, out); ret = 0; @@ -1011,19 +1010,19 @@ pl_setlk (xlator_t *this, pl_inode_t *pl_inode, posix_lock_t *lock, if (__is_lock_grantable (pl_inode, lock)) { gf_log (this->name, GF_LOG_TRACE, - "%s (pid=%d) lk-owner:%"PRIu64" %"PRId64" - %"PRId64" => OK", + "%s (pid=%d) lk-owner:%s %"PRId64" - %"PRId64" => OK", lock->fl_type == F_UNLCK ? "Unlock" : "Lock", lock->client_pid, - lock->owner, + lkowner_utoa (&lock->owner), lock->user_flock.l_start, lock->user_flock.l_len); __insert_and_merge (pl_inode, lock); } else if (can_block) { gf_log (this->name, GF_LOG_TRACE, - "%s (pid=%d) lk-owner:%"PRIu64" %"PRId64" - %"PRId64" => Blocked", + "%s (pid=%d) lk-owner:%s %"PRId64" - %"PRId64" => Blocked", lock->fl_type == F_UNLCK ? "Unlock" : "Lock", lock->client_pid, - lock->owner, + lkowner_utoa (&lock->owner), lock->user_flock.l_start, lock->user_flock.l_len); lock->blocked = 1; @@ -1031,10 +1030,10 @@ pl_setlk (xlator_t *this, pl_inode_t *pl_inode, posix_lock_t *lock, ret = -1; } else { gf_log (this->name, GF_LOG_TRACE, - "%s (pid=%d) lk-owner:%"PRIu64" %"PRId64" - %"PRId64" => NOK", + "%s (pid=%d) lk-owner:%s %"PRId64" - %"PRId64" => NOK", lock->fl_type == F_UNLCK ? "Unlock" : "Lock", lock->client_pid, - lock->owner, + lkowner_utoa (&lock->owner), lock->user_flock.l_start, lock->user_flock.l_len); errno = EAGAIN; diff --git a/xlators/features/locks/src/common.h b/xlators/features/locks/src/common.h index d95e287cb..0c0dd22e7 100644 --- a/xlators/features/locks/src/common.h +++ b/xlators/features/locks/src/common.h @@ -20,10 +20,12 @@ #ifndef __COMMON_H__ #define __COMMON_H__ +#include "lkowner.h" + #define SET_FLOCK_PID(flock, lock) ((flock)->l_pid = lock->client_pid) posix_lock_t * new_posix_lock (struct gf_flock *flock, void *transport, pid_t client_pid, - uint64_t owner, fd_t *fd); + gf_lkowner_t *owner, fd_t *fd); pl_inode_t * pl_inode_get (xlator_t *this, inode_t *inode); diff --git a/xlators/features/locks/src/entrylk.c b/xlators/features/locks/src/entrylk.c index 886a30b0e..3e91b9d94 100644 --- a/xlators/features/locks/src/entrylk.c +++ b/xlators/features/locks/src/entrylk.c @@ -35,7 +35,8 @@ static pl_entry_lock_t * new_entrylk_lock (pl_inode_t *pinode, const char *basename, entrylk_type type, - void *trans, pid_t client_pid, uint64_t owner, const char *volume) + void *trans, pid_t client_pid, gf_lkowner_t *owner, + const char *volume) { pl_entry_lock_t *newlock = NULL; @@ -46,12 +47,12 @@ new_entrylk_lock (pl_inode_t *pinode, const char *basename, entrylk_type type, goto out; } - newlock->basename = basename ? gf_strdup (basename) : NULL; - newlock->type = type; - newlock->trans = trans; - newlock->volume = volume; - newlock->client_pid = client_pid; - newlock->owner = owner; + newlock->basename = basename ? gf_strdup (basename) : NULL; + newlock->type = type; + newlock->trans = trans; + newlock->volume = volume; + newlock->client_pid = client_pid; + newlock->owner = *owner; INIT_LIST_HEAD (&newlock->domain_list); INIT_LIST_HEAD (&newlock->blocked_locks); @@ -81,11 +82,11 @@ names_conflict (const char *n1, const char *n2) } -static int +static inline int __same_entrylk_owner (pl_entry_lock_t *l1, pl_entry_lock_t *l2) { - return ((l1->owner == l2->owner) && + return (is_same_lkowner (&l1->owner, &l2->owner) && (l1->trans == l2->trans)); } @@ -320,15 +321,13 @@ __lock_name (pl_inode_t *pinode, const char *basename, entrylk_type type, pl_entry_lock_t *conf = NULL; void *trans = NULL; pid_t client_pid = 0; - uint64_t owner = 0; - - int ret = -EINVAL; + int ret = -EINVAL; trans = frame->root->trans; client_pid = frame->root->pid; - owner = frame->root->lk_owner; - lock = new_entrylk_lock (pinode, basename, type, trans, client_pid, owner, dom->domain); + lock = new_entrylk_lock (pinode, basename, type, trans, client_pid, + &frame->root->lk_owner, dom->domain); if (!lock) { ret = -ENOMEM; goto out; @@ -601,7 +600,6 @@ pl_common_entrylk (call_frame_t *frame, xlator_t *this, const char *volume, inode_t *inode, const char *basename, entrylk_cmd cmd, entrylk_type type, loc_t *loc, fd_t *fd) { - uint64_t owner = 0; int32_t op_ret = -1; int32_t op_errno = 0; @@ -628,10 +626,9 @@ pl_common_entrylk (call_frame_t *frame, xlator_t *this, entrylk_trace_in (this, frame, volume, fd, loc, basename, cmd, type); - owner = frame->root->lk_owner; transport = frame->root->trans; - if (owner == 0) { + if (frame->root->lk_owner.len == 0) { /* this is a special case that means release all locks from this transport diff --git a/xlators/features/locks/src/inodelk.c b/xlators/features/locks/src/inodelk.c index 1db08e058..5785f1f8e 100644 --- a/xlators/features/locks/src/inodelk.c +++ b/xlators/features/locks/src/inodelk.c @@ -120,9 +120,10 @@ inodelk_overlap (pl_inode_lock_t *l1, pl_inode_lock_t *l2) } /* Returns true if the 2 inodelks have the same owner */ -static int same_inodelk_owner (pl_inode_lock_t *l1, pl_inode_lock_t *l2) +static inline int +same_inodelk_owner (pl_inode_lock_t *l1, pl_inode_lock_t *l2) { - return ((l1->owner == l2->owner) && + return (is_same_lkowner (&l1->owner, &l2->owner) && (l1->transport == l2->transport)); } @@ -212,10 +213,10 @@ __lock_inodelk (xlator_t *this, pl_inode_t *pl_inode, pl_inode_lock_t *lock, list_add_tail (&lock->blocked_locks, &dom->blocked_inodelks); gf_log (this->name, GF_LOG_TRACE, - "%s (pid=%d) lk-owner:%"PRIu64" %"PRId64" - %"PRId64" => Blocked", + "%s (pid=%d) lk-owner:%s %"PRId64" - %"PRId64" => Blocked", lock->fl_type == F_UNLCK ? "Unlock" : "Lock", lock->client_pid, - lock->owner, + lkowner_utoa (&lock->owner), lock->user_flock.l_start, lock->user_flock.l_len); @@ -234,10 +235,10 @@ __lock_inodelk (xlator_t *this, pl_inode_t *pl_inode, pl_inode_lock_t *lock, gf_log (this->name, GF_LOG_TRACE, "Lock is grantable, but blocking to prevent starvation"); gf_log (this->name, GF_LOG_TRACE, - "%s (pid=%d) (lk-owner=%"PRIu64") %"PRId64" - %"PRId64" => Blocked", + "%s (pid=%d) (lk-owner=%s) %"PRId64" - %"PRId64" => Blocked", lock->fl_type == F_UNLCK ? "Unlock" : "Lock", lock->client_pid, - lock->owner, + lkowner_utoa (&lock->owner), lock->user_flock.l_start, lock->user_flock.l_len); @@ -352,10 +353,10 @@ grant_blocked_inode_locks (xlator_t *this, pl_inode_t *pl_inode, pl_dom_list_t * list_for_each_entry_safe (lock, tmp, &granted, blocked_locks) { gf_log (this->name, GF_LOG_TRACE, - "%s (pid=%d) (lk-owner=%"PRIu64") %"PRId64" - %"PRId64" => Granted", + "%s (pid=%d) (lk-owner=%s) %"PRId64" - %"PRId64" => Granted", lock->fl_type == F_UNLCK ? "Unlock" : "Lock", lock->client_pid, - lock->owner, + lkowner_utoa (&lock->owner), lock->user_flock.l_start, lock->user_flock.l_len); @@ -405,8 +406,9 @@ release_inode_locks_of_transport (xlator_t *this, pl_dom_list_t *dom, gf_log (this->name, GF_LOG_DEBUG, "releasing blocking lock on %s held by " - "{transport=%p, pid=%"PRId64" lk-owner=%"PRIu64"}", - file, trans, (uint64_t) l->client_pid, l->owner); + "{transport=%p, pid=%"PRId64" lk-owner=%s}", + file, trans, (uint64_t) l->client_pid, + lkowner_utoa (&l->owner)); list_add (&l->blocked_locks, &released); if (path) { @@ -430,8 +432,9 @@ release_inode_locks_of_transport (xlator_t *this, pl_dom_list_t *dom, gf_log (this->name, GF_LOG_DEBUG, "releasing granted lock on %s held by " - "{transport=%p, pid=%"PRId64" lk-owner=%"PRIu64"}", - file, trans, (uint64_t) l->client_pid, l->owner); + "{transport=%p, pid=%"PRId64" lk-owner=%s}", + file, trans, (uint64_t) l->client_pid, + lkowner_utoa (&l->owner)); if (path) { GF_FREE (path); path = NULL; @@ -468,19 +471,19 @@ pl_inode_setlk (xlator_t *this, pl_inode_t *pl_inode, pl_inode_lock_t *lock, ret = __lock_inodelk (this, pl_inode, lock, can_block, dom); if (ret == 0) gf_log (this->name, GF_LOG_TRACE, - "%s (pid=%d) (lk-owner=%"PRIu64") %"PRId64" - %"PRId64" => OK", + "%s (pid=%d) (lk-owner=%s) %"PRId64" - %"PRId64" => OK", lock->fl_type == F_UNLCK ? "Unlock" : "Lock", lock->client_pid, - lock->owner, + lkowner_utoa (&lock->owner), lock->fl_start, lock->fl_end); if (ret == -EAGAIN) gf_log (this->name, GF_LOG_TRACE, - "%s (pid=%d) (lk-owner=%"PRIu64") %"PRId64" - %"PRId64" => NOK", + "%s (pid=%d) (lk-owner=%s) %"PRId64" - %"PRId64" => NOK", lock->fl_type == F_UNLCK ? "Unlock" : "Lock", lock->client_pid, - lock->owner, + lkowner_utoa (&lock->owner), lock->user_flock.l_start, lock->user_flock.l_len); @@ -510,7 +513,7 @@ out: /* Create a new inode_lock_t */ pl_inode_lock_t * new_inode_lock (struct gf_flock *flock, void *transport, pid_t client_pid, - uint64_t owner, const char *volume) + gf_lkowner_t *owner, const char *volume) { pl_inode_lock_t *lock = NULL; @@ -531,8 +534,8 @@ new_inode_lock (struct gf_flock *flock, void *transport, pid_t client_pid, lock->transport = transport; lock->client_pid = client_pid; - lock->owner = owner; lock->volume = volume; + lock->owner = *owner; INIT_LIST_HEAD (&lock->list); INIT_LIST_HEAD (&lock->blocked_locks); @@ -546,16 +549,15 @@ pl_common_inodelk (call_frame_t *frame, xlator_t *this, const char *volume, inode_t *inode, int32_t cmd, struct gf_flock *flock, loc_t *loc, fd_t *fd) { - int32_t op_ret = -1; - int32_t op_errno = 0; - int ret = -1; - int can_block = 0; - void * transport = NULL; - pid_t client_pid = -1; - uint64_t owner = -1; - pl_inode_t * pinode = NULL; - pl_inode_lock_t * reqlock = NULL; - pl_dom_list_t * dom = NULL; + int32_t op_ret = -1; + int32_t op_errno = 0; + int ret = -1; + int can_block = 0; + pid_t client_pid = -1; + void * transport = NULL; + pl_inode_t * pinode = NULL; + pl_inode_lock_t * reqlock = NULL; + pl_dom_list_t * dom = NULL; VALIDATE_OR_GOTO (frame, out); VALIDATE_OR_GOTO (inode, unwind); @@ -570,7 +572,6 @@ pl_common_inodelk (call_frame_t *frame, xlator_t *this, transport = frame->root->trans; client_pid = frame->root->pid; - owner = frame->root->lk_owner; pinode = pl_inode_get (this, inode); if (!pinode) { @@ -580,7 +581,7 @@ pl_common_inodelk (call_frame_t *frame, xlator_t *this, dom = get_domain (pinode, volume); - if (owner == 0) { + if (frame->root->lk_owner.len == 0) { /* special case: this means release all locks from this transport @@ -594,7 +595,8 @@ pl_common_inodelk (call_frame_t *frame, xlator_t *this, goto unwind; } - reqlock = new_inode_lock (flock, transport, client_pid, owner, volume); + reqlock = new_inode_lock (flock, transport, client_pid, + &frame->root->lk_owner, volume); if (!reqlock) { op_ret = -1; @@ -687,12 +689,12 @@ __get_inodelk_count (xlator_t *this, pl_inode_t *pl_inode) gf_log (this->name, GF_LOG_DEBUG, " XATTR DEBUG" - " domain: %s %s (pid=%d) (lk-owner=%"PRIu64") %"PRId64" - %"PRId64" " + " domain: %s %s (pid=%d) (lk-owner=%s) %"PRId64" - %"PRId64" " "state = Active", dom->domain, lock->fl_type == F_UNLCK ? "Unlock" : "Lock", lock->client_pid, - lock->owner, + lkowner_utoa (&lock->owner), lock->user_flock.l_start, lock->user_flock.l_len); @@ -703,12 +705,12 @@ __get_inodelk_count (xlator_t *this, pl_inode_t *pl_inode) gf_log (this->name, GF_LOG_DEBUG, " XATTR DEBUG" - " domain: %s %s (pid=%d) (lk-owner=%"PRIu64") %"PRId64" - %"PRId64" " + " domain: %s %s (pid=%d) (lk-owner=%s) %"PRId64" - %"PRId64" " "state = Blocked", dom->domain, lock->fl_type == F_UNLCK ? "Unlock" : "Lock", lock->client_pid, - lock->owner, + lkowner_utoa (&lock->owner), lock->user_flock.l_start, lock->user_flock.l_len); diff --git a/xlators/features/locks/src/locks.h b/xlators/features/locks/src/locks.h index 476b9a83c..0dcbdf979 100644 --- a/xlators/features/locks/src/locks.h +++ b/xlators/features/locks/src/locks.h @@ -30,6 +30,8 @@ #include "call-stub.h" #include "locks-mem-types.h" +#include "lkowner.h" + #define POSIX_LOCKS "posix-locks" struct __pl_fd; @@ -55,8 +57,8 @@ struct __posix_lock { across nodes */ void *transport; /* to identify client node */ + gf_lkowner_t owner; pid_t client_pid; /* pid of client process */ - uint64_t owner; /* lock owner from fuse */ }; typedef struct __posix_lock posix_lock_t; @@ -83,8 +85,8 @@ struct __pl_inode_lock { across nodes */ void *transport; /* to identify client node */ + gf_lkowner_t owner; pid_t client_pid; /* pid of client process */ - uint64_t owner; }; typedef struct __pl_inode_lock pl_inode_lock_t; @@ -120,9 +122,9 @@ struct __entry_lock { struct timeval blkd_time; /*time at which lock was queued into blkd list*/ struct timeval granted_time; /*time at which lock was queued into active list*/ - void *trans; + void *trans; + gf_lkowner_t owner; pid_t client_pid; /* pid of client process */ - uint64_t owner; }; typedef struct __entry_lock pl_entry_lock_t; diff --git a/xlators/features/locks/src/posix.c b/xlators/features/locks/src/posix.c index 59e2199fb..0914d16df 100644 --- a/xlators/features/locks/src/posix.c +++ b/xlators/features/locks/src/posix.c @@ -126,7 +126,7 @@ pl_truncate_cbk (call_frame_t *frame, void *cookie, xlator_t *this, static int truncate_allowed (pl_inode_t *pl_inode, void *transport, pid_t client_pid, - uint64_t owner, off_t offset) + gf_lkowner_t *owner, off_t offset) { posix_lock_t *l = NULL; posix_lock_t region = {.list = {0, }, }; @@ -136,7 +136,7 @@ truncate_allowed (pl_inode_t *pl_inode, region.fl_end = LLONG_MAX; region.transport = transport; region.client_pid = client_pid; - region.owner = owner; + region.owner = *owner; pthread_mutex_lock (&pl_inode->mutex); { @@ -192,7 +192,7 @@ truncate_stat_cbk (call_frame_t *frame, void *cookie, xlator_t *this, if (priv->mandatory && pl_inode->mandatory && !truncate_allowed (pl_inode, frame->root->trans, - frame->root->pid, frame->root->lk_owner, + frame->root->pid, &frame->root->lk_owner, local->offset)) { op_ret = -1; op_errno = EAGAIN; @@ -324,7 +324,7 @@ delete_locks_of_fd (xlator_t *this, pl_inode_t *pl_inode, fd_t *fd) static void __delete_locks_of_owner (pl_inode_t *pl_inode, - void *transport, uint64_t owner) + void *transport, gf_lkowner_t *owner) { posix_lock_t *tmp = NULL; posix_lock_t *l = NULL; @@ -332,14 +332,14 @@ __delete_locks_of_owner (pl_inode_t *pl_inode, /* TODO: what if it is a blocked lock with pending l->frame */ list_for_each_entry_safe (l, tmp, &pl_inode->ext_list, list) { - if ((l->transport == transport) - && (l->owner == owner)) { + if ((l->transport == transport) && + is_same_lkowner (&l->owner, owner)) { gf_log ("posix-locks", GF_LOG_TRACE, " Flushing lock" - "%s (pid=%d) (lk-owner=%"PRIu64") %"PRId64" - %"PRId64" state: %s", + "%s (pid=%d) (lk-owner=%s) %"PRId64" - %"PRId64" state: %s", l->fl_type == F_UNLCK ? "Unlock" : "Lock", l->client_pid, - l->owner, + lkowner_utoa (&l->owner), l->user_flock.l_start, l->user_flock.l_len, l->blocked == 1 ? "Blocked" : "Active"); @@ -408,10 +408,7 @@ int pl_flush (call_frame_t *frame, xlator_t *this, fd_t *fd) { - pl_inode_t *pl_inode = NULL; - uint64_t owner = -1; - - owner = frame->root->lk_owner; + pl_inode_t *pl_inode = NULL; pl_inode = pl_inode_get (this, fd->inode); @@ -423,7 +420,7 @@ pl_flush (call_frame_t *frame, xlator_t *this, pl_trace_flush (this, frame, fd); - if (owner == 0) { + if (frame->root->lk_owner.len == 0) { /* Handle special case when protocol/server sets lk-owner to zero. * This usually happens due to a client disconnection. Hence, free * all locks opened with this fd. @@ -437,7 +434,7 @@ pl_flush (call_frame_t *frame, xlator_t *this, pthread_mutex_lock (&pl_inode->mutex); { __delete_locks_of_owner (pl_inode, frame->root->trans, - owner); + &frame->root->lk_owner); } pthread_mutex_unlock (&pl_inode->mutex); @@ -805,7 +802,7 @@ lock_dup (posix_lock_t *lock) posix_lock_t *new_lock = NULL; new_lock = new_posix_lock (&lock->user_flock, lock->transport, - lock->client_pid, lock->owner, + lock->client_pid, &lock->owner, (fd_t *)lock->fd_num); return new_lock; } @@ -964,20 +961,18 @@ int pl_lk (call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t cmd, struct gf_flock *flock) { - void *transport = NULL; - pid_t client_pid = 0; - uint64_t owner = 0; - pl_inode_t *pl_inode = NULL; - int op_ret = 0; - int op_errno = 0; - int can_block = 0; - posix_lock_t *reqlock = NULL; - posix_lock_t *conf = NULL; - int ret = 0; + void *transport = NULL; + pid_t client_pid = 0; + pl_inode_t *pl_inode = NULL; + int op_ret = 0; + int op_errno = 0; + int can_block = 0; + posix_lock_t *reqlock = NULL; + posix_lock_t *conf = NULL; + int ret = 0; transport = frame->root->trans; client_pid = frame->root->pid; - owner = frame->root->lk_owner; if ((flock->l_start < 0) || (flock->l_len < 0)) { op_ret = -1; @@ -993,7 +988,7 @@ pl_lk (call_frame_t *frame, xlator_t *this, } reqlock = new_posix_lock (flock, transport, client_pid, - owner, fd); + &frame->root->lk_owner, fd); if (!reqlock) { op_ret = -1; @@ -1327,10 +1322,10 @@ __get_posixlk_count (xlator_t *this, pl_inode_t *pl_inode) gf_log (this->name, GF_LOG_DEBUG, " XATTR DEBUG" - "%s (pid=%d) (lk-owner=%"PRIu64") %"PRId64" - %"PRId64" state: %s", + "%s (pid=%d) (lk-owner=%s) %"PRId64" - %"PRId64" state: %s", lock->fl_type == F_UNLCK ? "Unlock" : "Lock", lock->client_pid, - lock->owner, + lkowner_utoa (&lock->owner), lock->user_flock.l_start, lock->user_flock.l_len, lock->blocked == 1 ? "Blocked" : "Active"); @@ -1504,7 +1499,7 @@ out: void pl_dump_lock (char *str, int size, struct gf_flock *flock, - uint64_t owner, void *trans, time_t *granted_time, + gf_lkowner_t *owner, void *trans, time_t *granted_time, time_t *blkd_time, gf_boolean_t active) { char *type_str = NULL; @@ -1526,30 +1521,32 @@ pl_dump_lock (char *str, int size, struct gf_flock *flock, if (active) { if (blkd_time && *blkd_time == 0) { - snprintf (str, size, "type=%s, start=%llu, len=%llu, pid=%llu, lk-owner=%llu, transport=%p, " - "granted at %s", + snprintf (str, size, "type=%s, start=%llu, len=%llu, " + "pid=%llu, lk-owner=%s, transport=%p, " + "granted at %s", type_str, (unsigned long long) flock->l_start, (unsigned long long) flock->l_len, (unsigned long long) flock->l_pid, - (unsigned long long) owner, + lkowner_utoa (owner), trans, ctime (granted_time)); } else { - snprintf (str, size, "type=%s, start=%llu, len=%llu, pid=%llu, lk-owner=%llu, transport=%p, " + snprintf (str, size, "type=%s, start=%llu, len=%llu, " + "pid=%llu, lk-owner=%s, transport=%p, " "blocked at %s, granted at %s", type_str, (unsigned long long) flock->l_start, (unsigned long long) flock->l_len, (unsigned long long) flock->l_pid, - (unsigned long long) owner, + lkowner_utoa (owner), trans, ctime (blkd_time), ctime (granted_time)); } } else { - snprintf (str, size, "type=%s, start=%llu, len=%llu, pid=%llu, lk-owner=%llu, transport=%p, " - "blocked at %s", + snprintf (str, size, "type=%s, start=%llu, len=%llu, pid=%llu, " + "lk-owner=%s, transport=%p, blocked at %s", type_str, (unsigned long long) flock->l_start, (unsigned long long) flock->l_len, (unsigned long long) flock->l_pid, - (unsigned long long) owner, + lkowner_utoa (owner), trans, ctime (blkd_time)); } @@ -1580,20 +1577,20 @@ __dump_entrylks (pl_inode_t *pl_inode) "xlator.feature.locks.lock-dump.domain.entrylk", "entrylk[%d](ACTIVE)", count ); if (lock->blkd_time.tv_sec == 0 && lock->blkd_time.tv_usec == 0) { - snprintf (tmp, 256," %s on %s pid = %llu, owner=%llu, transport=%p," + snprintf (tmp, 256," %s on %s pid = %llu, owner=%s, transport=%p," " granted at %s", lock->type == ENTRYLK_RDLCK ? "ENTRYLK_RDLCK" : "ENTRYLK_WRLCK", lock->basename, (unsigned long long) lock->client_pid, - (unsigned long long) lock->owner, lock->trans, + lkowner_utoa (&lock->owner), lock->trans, ctime (&lock->granted_time.tv_sec)); } else { - snprintf (tmp, 256," %s on %s pid = %llu, owner=%llu, transport=%p," + snprintf (tmp, 256," %s on %s pid = %llu, owner=%s, transport=%p," " blocked at %s, granted at %s", lock->type == ENTRYLK_RDLCK ? "ENTRYLK_RDLCK" : "ENTRYLK_WRLCK", lock->basename, (unsigned long long) lock->client_pid, - (unsigned long long) lock->owner, lock->trans, + lkowner_utoa (&lock->owner), lock->trans, ctime (&lock->blkd_time.tv_sec), ctime (&lock->granted_time.tv_sec)); } @@ -1608,12 +1605,12 @@ __dump_entrylks (pl_inode_t *pl_inode) gf_proc_dump_build_key(key, "xlator.feature.locks.lock-dump.domain.entrylk", "entrylk[%d](BLOCKED)", count ); - snprintf (tmp, 256," %s on %s pid = %llu, owner=%llu, transport=%p," + snprintf (tmp, 256," %s on %s pid = %llu, owner=%s, transport=%p," " blocked at %s", lock->type == ENTRYLK_RDLCK ? "ENTRYLK_RDLCK" : "ENTRYLK_WRLCK", lock->basename, (unsigned long long) lock->client_pid, - (unsigned long long) lock->owner, lock->trans, + lkowner_utoa (&lock->owner), lock->trans, ctime (&lock->blkd_time.tv_sec)); gf_proc_dump_write(key, tmp); @@ -1663,7 +1660,8 @@ __dump_inodelks (pl_inode_t *pl_inode) SET_FLOCK_PID (&lock->user_flock, lock); pl_dump_lock (tmp, 256, &lock->user_flock, - lock->owner, lock->transport, + &lock->owner, + lock->transport, &lock->granted_time.tv_sec, &lock->blkd_time.tv_sec, _gf_true); @@ -1679,7 +1677,8 @@ __dump_inodelks (pl_inode_t *pl_inode) "inodelk[%d](BLOCKED)",count ); SET_FLOCK_PID (&lock->user_flock, lock); pl_dump_lock (tmp, 256, &lock->user_flock, - lock->owner, lock->transport, + &lock->owner, + lock->transport, 0, &lock->blkd_time.tv_sec, _gf_false); gf_proc_dump_write(key, tmp); @@ -1720,7 +1719,7 @@ __dump_posixlks (pl_inode_t *pl_inode) count, lock->blocked ? "BLOCKED" : "ACTIVE"); pl_dump_lock (tmp, 256, &lock->user_flock, - lock->owner, lock->transport, + &lock->owner, lock->transport, &lock->granted_time.tv_sec, &lock->blkd_time.tv_sec, (lock->blocked)? _gf_false: _gf_true); gf_proc_dump_write(key, tmp); diff --git a/xlators/features/locks/src/reservelk.c b/xlators/features/locks/src/reservelk.c index 4aac1803d..7a75cdea1 100644 --- a/xlators/features/locks/src/reservelk.c +++ b/xlators/features/locks/src/reservelk.c @@ -81,10 +81,10 @@ out: return ret_lock; } -static int +static inline int __same_owner_reservelk (posix_lock_t *l1, posix_lock_t *l2) { - return ((l1->owner == l2->owner)); + return (is_same_lkowner (&l1->owner, &l2->owner)); } @@ -187,10 +187,10 @@ __lock_reservelk (xlator_t *this, pl_inode_t *pl_inode, posix_lock_t *lock, list_add_tail (&lock->list, &pl_inode->blocked_reservelks); gf_log (this->name, GF_LOG_TRACE, - "%s (pid=%d) lk-owner:%"PRIu64" %"PRId64" - %"PRId64" => Blocked", + "%s (pid=%d) lk-owner:%s %"PRId64" - %"PRId64" => Blocked", lock->fl_type == F_UNLCK ? "Unlock" : "Lock", lock->client_pid, - lock->owner, + lkowner_utoa (&lock->owner), lock->user_flock.l_start, lock->user_flock.l_len); @@ -292,10 +292,10 @@ grant_blocked_reserve_locks (xlator_t *this, pl_inode_t *pl_inode) list_for_each_entry_safe (lock, tmp, &granted, list) { gf_log (this->name, GF_LOG_TRACE, - "%s (pid=%d) (lk-owner=%"PRIu64") %"PRId64" - %"PRId64" => Granted", + "%s (pid=%d) (lk-owner=%s) %"PRId64" - %"PRId64" => Granted", lock->fl_type == F_UNLCK ? "Unlock" : "Lock", lock->client_pid, - lock->owner, + lkowner_utoa (&lock->owner), lock->user_flock.l_start, lock->user_flock.l_len); @@ -429,18 +429,18 @@ pl_reserve_setlk (xlator_t *this, pl_inode_t *pl_inode, posix_lock_t *lock, ret = __lock_reservelk (this, pl_inode, lock, can_block); if (ret < 0) gf_log (this->name, GF_LOG_TRACE, - "%s (pid=%d) (lk-owner=%"PRIu64") %"PRId64" - %"PRId64" => NOK", + "%s (pid=%d) (lk-owner=%s) %"PRId64" - %"PRId64" => NOK", lock->fl_type == F_UNLCK ? "Unlock" : "Lock", lock->client_pid, - lock->owner, + lkowner_utoa (&lock->owner), lock->user_flock.l_start, lock->user_flock.l_len); else gf_log (this->name, GF_LOG_TRACE, - "%s (pid=%d) (lk-owner=%"PRIu64") %"PRId64" - %"PRId64" => OK", + "%s (pid=%d) (lk-owner=%s) %"PRId64" - %"PRId64" => OK", lock->fl_type == F_UNLCK ? "Unlock" : "Lock", lock->client_pid, - lock->owner, + lkowner_utoa (&lock->owner), lock->fl_start, lock->fl_end); diff --git a/xlators/features/marker/src/marker-quota.c b/xlators/features/marker/src/marker-quota.c index 57e8470d6..227c4951b 100644 --- a/xlators/features/marker/src/marker-quota.c +++ b/xlators/features/marker/src/marker-quota.c @@ -152,7 +152,7 @@ mq_assign_lk_owner (xlator_t *this, call_frame_t *frame) } UNLOCK (&conf->lock); - frame->root->lk_owner = lk_owner; + set_lk_owner_from_uint64 (&frame->root->lk_owner, lk_owner); return; } diff --git a/xlators/mgmt/glusterd/src/glusterd-handshake.c b/xlators/mgmt/glusterd/src/glusterd-handshake.c index e514f8bc4..04e5fae7b 100644 --- a/xlators/mgmt/glusterd/src/glusterd-handshake.c +++ b/xlators/mgmt/glusterd/src/glusterd-handshake.c @@ -35,6 +35,7 @@ #include "glusterfs3.h" #include "protocol-common.h" #include "rpcsvc.h" +#include "rpc-common-xdr.h" extern struct rpc_clnt_program gd_peer_prog; extern struct rpc_clnt_program gd_mgmt_prog; diff --git a/xlators/mount/fuse/src/fuse-bridge.c b/xlators/mount/fuse/src/fuse-bridge.c index b8f53a1bc..7409488c1 100644 --- a/xlators/mount/fuse/src/fuse-bridge.c +++ b/xlators/mount/fuse/src/fuse-bridge.c @@ -3110,11 +3110,11 @@ fuse_setlk_cbk (call_frame_t *frame, void *cookie, xlator_t *this, } else if (op_errno == EAGAIN) { gf_log ("glusterfs-fuse", GF_LOG_DEBUG, "Returning EAGAIN Flock: " - "start=%llu, len=%llu, pid=%llu, lk-owner=%llu", + "start=%llu, len=%llu, pid=%llu, lk-owner=%s", (unsigned long long) lock->l_start, (unsigned long long) lock->l_len, (unsigned long long) lock->l_pid, - (unsigned long long) frame->root->lk_owner); + lkowner_utoa (&frame->root->lk_owner)); } else { gf_log ("glusterfs-fuse", GF_LOG_WARNING, diff --git a/xlators/mount/fuse/src/fuse-helpers.c b/xlators/mount/fuse/src/fuse-helpers.c index 9bf85f979..2070447fa 100644 --- a/xlators/mount/fuse/src/fuse-helpers.c +++ b/xlators/mount/fuse/src/fuse-helpers.c @@ -145,7 +145,7 @@ frame_fill_groups (call_frame_t *frame) { #if defined(GF_LINUX_HOST_OS) char filename[32]; - char line[128]; + char line[4096]; char *ptr = NULL; FILE *fp = NULL; int idx = 0; @@ -178,7 +178,7 @@ frame_fill_groups (call_frame_t *frame) if (!endptr || *endptr) break; frame->root->groups[idx++] = id; - if (idx == GF_REQUEST_MAXGROUPS) + if (idx == GF_MAX_AUX_GROUPS) break; } @@ -237,7 +237,6 @@ out: #endif /* GF_LINUX_HOST_OS */ } - call_frame_t * get_call_frame_for_req (fuse_state_t *state) { @@ -260,8 +259,9 @@ get_call_frame_for_req (fuse_state_t *state) frame->root->uid = finh->uid; frame->root->gid = finh->gid; frame->root->pid = finh->pid; - frame->root->lk_owner = state->lk_owner; frame->root->unique = finh->unique; + set_lk_owner_from_uint64 (&frame->root->lk_owner, + state->lk_owner); } frame_fill_groups (frame); diff --git a/xlators/nfs/server/src/nfs-fops.c b/xlators/nfs/server/src/nfs-fops.c index 428c82a8f..c6199d129 100644 --- a/xlators/nfs/server/src/nfs-fops.c +++ b/xlators/nfs/server/src/nfs-fops.c @@ -90,7 +90,7 @@ unsigned int cval = 1; int nfs_frame_getctr () { - int val = 0; + uint64_t val = 0; pthread_mutex_lock (&ctr); { @@ -132,7 +132,8 @@ nfs_create_frame (xlator_t *xl, nfs_user_t *nfu) gf_log (GF_NFS, GF_LOG_TRACE, "gid: %d", nfu->gids[x]); frame->root->groups[y] = nfu->gids[x]; } - frame->root->lk_owner = nfs_frame_getctr (); + + set_lk_owner_from_uint64 (&frame->root->lk_owner, nfs_frame_getctr ()); err: return frame; diff --git a/xlators/nfs/server/src/nfs.h b/xlators/nfs/server/src/nfs.h index a77e772a3..3113e32cc 100644 --- a/xlators/nfs/server/src/nfs.h +++ b/xlators/nfs/server/src/nfs.h @@ -45,6 +45,12 @@ #define GF_NFS_DVM_ON 1 #define GF_NFS_DVM_OFF 2 +/* This corresponds to the max 16 number of group IDs that are sent through an + * RPC request. Since NFS is the only one going to set this, we can be safe + * in keeping this size hardcoded. + */ +#define GF_REQUEST_MAXGROUPS 16 + /* Callback into a version-specific NFS protocol. * The return type is used by the nfs.c code to register the protocol. * with the RPC service. diff --git a/xlators/protocol/client/src/client-handshake.c b/xlators/protocol/client/src/client-handshake.c index 7bf95e912..85e10cb0b 100644 --- a/xlators/protocol/client/src/client-handshake.c +++ b/xlators/protocol/client/src/client-handshake.c @@ -31,6 +31,7 @@ #include "glusterfs3.h" #include "portmap-xdr.h" +#include "rpc-common-xdr.h" extern rpc_clnt_prog_t clnt3_1_fop_prog; extern rpc_clnt_prog_t clnt_pmap_prog; diff --git a/xlators/protocol/client/src/client-lk.c b/xlators/protocol/client/src/client-lk.c index 5334500a9..d08d2a413 100644 --- a/xlators/protocol/client/src/client-lk.c +++ b/xlators/protocol/client/src/client-lk.c @@ -20,6 +20,7 @@ #include "common-utils.h" #include "xlator.h" #include "client.h" +#include "lkowner.h" static void __insert_and_merge (clnt_fd_ctx_t *fdctx, client_posix_lock_t *lock); @@ -36,11 +37,11 @@ __dump_client_lock (client_posix_lock_t *lock) gf_log (this->name, GF_LOG_INFO, "{fd=%p}" - "{%s lk-owner:%"PRIu64" %"PRId64" - %"PRId64"}" + "{%s lk-owner:%s %"PRId64" - %"PRId64"}" "{start=%"PRId64" end=%"PRId64"}", lock->fd, lock->fl_type == F_WRLCK ? "Write-Lock" : "Read-Lock", - lock->owner, + lkowner_utoa (&lock->owner), lock->user_flock.l_start, lock->user_flock.l_len, lock->fl_start, @@ -133,12 +134,6 @@ add_locks (client_posix_lock_t *l1, client_posix_lock_t *l2) return sum; } -/* Return true if the locks have the same owner */ -static int -same_owner (client_posix_lock_t *l1, client_posix_lock_t *l2) -{ - return ((l1->owner == l2->owner)); -} /* Return true if the locks overlap, false otherwise */ static int @@ -285,11 +280,11 @@ __insert_and_merge (clnt_fd_ctx_t *fdctx, client_posix_lock_t *lock) if (!locks_overlap (conf, lock)) continue; - if (same_owner (conf, lock)) { + if (is_same_lkowner (&conf->owner, &lock->owner)) { if (conf->fl_type == lock->fl_type) { sum = add_locks (lock, conf); - sum->fd = lock->fd; + sum->fd = lock->fd; __delete_client_lock (conf); __destroy_client_lock (conf); @@ -301,8 +296,8 @@ __insert_and_merge (clnt_fd_ctx_t *fdctx, client_posix_lock_t *lock) } else { sum = add_locks (lock, conf); - sum->fd = conf->fd; - sum->owner = conf->owner; + sum->fd = conf->fd; + sum->owner = conf->owner; v = subtract_locks (sum, lock); @@ -365,7 +360,7 @@ destroy_client_lock (client_posix_lock_t *lock) } int32_t -delete_granted_locks_owner (fd_t *fd, uint64_t owner) +delete_granted_locks_owner (fd_t *fd, gf_lkowner_t *owner) { clnt_fd_ctx_t *fdctx = NULL; client_posix_lock_t *lock = NULL; @@ -389,7 +384,7 @@ delete_granted_locks_owner (fd_t *fd, uint64_t owner) pthread_mutex_lock (&fdctx->mutex); { list_for_each_entry_safe (lock, tmp, &fdctx->lock_list, list) { - if (lock->owner == owner) { + if (!is_same_lkowner (&lock->owner, owner)) { list_del_init (&lock->list); list_add_tail (&lock->list, &delete_list); count++; @@ -486,7 +481,7 @@ client_cmd_to_gf_cmd (int32_t cmd, int32_t *gf_cmd) } static client_posix_lock_t * -new_client_lock (struct gf_flock *flock, uint64_t owner, +new_client_lock (struct gf_flock *flock, gf_lkowner_t *owner, int32_t cmd, fd_t *fd) { client_posix_lock_t *new_lock = NULL; @@ -509,7 +504,8 @@ new_client_lock (struct gf_flock *flock, uint64_t owner, else new_lock->fl_end = flock->l_start + flock->l_len - 1; - new_lock->owner = owner; + new_lock->owner = *owner; + new_lock->cmd = cmd; /* Not really useful */ out: @@ -527,8 +523,8 @@ client_save_number_fds (clnt_conf_t *conf, int count) } int -client_add_lock_for_recovery (fd_t *fd, struct gf_flock *flock, uint64_t owner, - int32_t cmd) +client_add_lock_for_recovery (fd_t *fd, struct gf_flock *flock, + gf_lkowner_t *owner, int32_t cmd) { clnt_fd_ctx_t *fdctx = NULL; xlator_t *this = NULL; @@ -572,13 +568,13 @@ construct_reserve_unlock (struct gf_flock *lock, call_frame_t *frame, { GF_ASSERT (lock); GF_ASSERT (frame); - GF_ASSERT (frame->root->lk_owner); lock->l_type = F_UNLCK; lock->l_start = 0; lock->l_whence = SEEK_SET; lock->l_len = 0; /* Whole file */ lock->l_pid = (uint64_t)(unsigned long)frame->root; + lock->l_owner = client_lock->owner; frame->root->lk_owner = client_lock->owner; @@ -827,7 +823,6 @@ static int client_send_recovery_lock (call_frame_t *frame, xlator_t *this, client_posix_lock_t *lock) { - frame->root->lk_owner = lock->owner; /* Send all locks as F_SETLK to prevent the frame diff --git a/xlators/protocol/client/src/client.h b/xlators/protocol/client/src/client.h index 69830db9d..6d0b6491a 100644 --- a/xlators/protocol/client/src/client.h +++ b/xlators/protocol/client/src/client.h @@ -111,8 +111,7 @@ typedef struct _client_posix_lock { off_t fl_end; short fl_type; int32_t cmd; /* the cmd for the lock call */ - uint64_t owner; /* lock owner from fuse */ - + gf_lkowner_t owner; /* lock owner from fuse */ struct list_head list; /* reference used to add to the fdctx list of locks */ } client_posix_lock_t; @@ -126,7 +125,7 @@ typedef struct client_local { struct iobref *iobref; client_posix_lock_t *client_lock; - uint64_t owner; + gf_lkowner_t owner; int32_t cmd; struct list_head lock_list; pthread_mutex_t mutex; @@ -190,9 +189,9 @@ int unserialize_rsp_direntp (struct gfs3_readdirp_rsp *rsp, gf_dirent_t *entries int clnt_readdir_rsp_cleanup (gfs3_readdir_rsp *rsp); int clnt_readdirp_rsp_cleanup (gfs3_readdirp_rsp *rsp); int client_attempt_lock_recovery (xlator_t *this, clnt_fd_ctx_t *fdctx); -int32_t delete_granted_locks_owner (fd_t *fd, uint64_t owner); -int client_add_lock_for_recovery (fd_t *fd, struct gf_flock *flock, uint64_t owner, - int32_t cmd); +int32_t delete_granted_locks_owner (fd_t *fd, gf_lkowner_t *owner); +int client_add_lock_for_recovery (fd_t *fd, struct gf_flock *flock, + gf_lkowner_t *owner, int32_t cmd); uint64_t decrement_reopen_fd_count (xlator_t *this, clnt_conf_t *conf); int32_t delete_granted_locks_fd (clnt_fd_ctx_t *fdctx); int32_t client_cmd_to_gf_cmd (int32_t cmd, int32_t *gf_cmd); diff --git a/xlators/protocol/client/src/client3_1-fops.c b/xlators/protocol/client/src/client3_1-fops.c index 6300b264f..036e297de 100644 --- a/xlators/protocol/client/src/client3_1-fops.c +++ b/xlators/protocol/client/src/client3_1-fops.c @@ -725,10 +725,10 @@ client3_1_flush_cbk (struct rpc_req *req, struct iovec *iov, int count, if (rsp.op_ret >= 0) { /* Delete all saved locks of the owner issuing flush */ - ret = delete_granted_locks_owner (local->fd, local->owner); + ret = delete_granted_locks_owner (local->fd, &local->owner); gf_log (this->name, GF_LOG_TRACE, - "deleting locks of owner (%llu) returned %d", - (long long unsigned) local->owner, ret); + "deleting locks of owner (%s) returned %d", + lkowner_utoa (&local->owner), ret); } out: @@ -3655,7 +3655,7 @@ client3_1_flush (call_frame_t *frame, xlator_t *this, gfs3_flush_req req = {{0,},}; int64_t remote_fd = -1; clnt_conf_t *conf = NULL; - clnt_local_t *local = NULL; + clnt_local_t *local = NULL; int op_errno = ESTALE; int ret = 0; diff --git a/xlators/protocol/server/src/server-helpers.c b/xlators/protocol/server/src/server-helpers.c index f259a651f..43f60e0e2 100644 --- a/xlators/protocol/server/src/server-helpers.c +++ b/xlators/protocol/server/src/server-helpers.c @@ -39,7 +39,7 @@ server_decode_groups (call_frame_t *frame, rpcsvc_request_t *req) if (frame->root->ngrps == 0) return 0; - if (frame->root->ngrps > GF_REQUEST_MAXGROUPS) + if (frame->root->ngrps > GF_MAX_AUX_GROUPS) return -1; for (; i < frame->root->ngrps; ++i) @@ -134,7 +134,7 @@ free_state (server_state_t *state) int gf_add_locker (struct _lock_table *table, const char *volume, - loc_t *loc, fd_t *fd, pid_t pid, uint64_t owner, + loc_t *loc, fd_t *fd, pid_t pid, gf_lkowner_t *owner, glusterfs_fop_t type) { int32_t ret = -1; @@ -158,7 +158,7 @@ gf_add_locker (struct _lock_table *table, const char *volume, } new->pid = pid; - new->owner = owner; + new->owner = *owner; LOCK (&table->lock); { @@ -175,7 +175,8 @@ out: int gf_del_locker (struct _lock_table *table, const char *volume, - loc_t *loc, fd_t *fd, uint64_t owner, glusterfs_fop_t type) + loc_t *loc, fd_t *fd, gf_lkowner_t *owner, + glusterfs_fop_t type) { struct _locker *locker = NULL; struct _locker *tmp = NULL; @@ -197,17 +198,15 @@ gf_del_locker (struct _lock_table *table, const char *volume, } list_for_each_entry_safe (locker, tmp, head, lockers) { - if (locker->fd && fd && - (locker->fd == fd) && (locker->owner == owner) - && !strcmp (locker->volume, volume)) { + if (!is_same_lkowner (&locker->owner, owner) || + strcmp (locker->volume, volume)) + continue; + + if (locker->fd && fd && (locker->fd == fd)) list_move_tail (&locker->lockers, &del); - } else if (locker->loc.inode && - loc && - (locker->loc.inode == loc->inode) && - (locker->owner == owner) - && !strcmp (locker->volume, volume)) { + else if (locker->loc.inode && loc && + (locker->loc.inode == loc->inode)) list_move_tail (&locker->lockers, &del); - } } } UNLOCK (&table->lock); @@ -314,9 +313,9 @@ do_lock_table_cleanup (xlator_t *this, server_connection_t *conn, lock owner = 0 is a special case that tells posix-locks to release all locks from this transport */ - tmp_frame->root->pid = 0; - tmp_frame->root->lk_owner = 0; - tmp_frame->root->trans = conn; + tmp_frame->root->pid = 0; + tmp_frame->root->trans = conn; + memset (&tmp_frame->root->lk_owner, 0, sizeof (gf_lkowner_t)); if (locker->fd) { GF_ASSERT (locker->fd->inode); @@ -361,9 +360,9 @@ do_lock_table_cleanup (xlator_t *this, server_connection_t *conn, list_for_each_entry_safe (locker, tmp, &entrylk_lockers, lockers) { tmp_frame = copy_frame (frame); - tmp_frame->root->lk_owner = 0; - tmp_frame->root->pid = 0; - tmp_frame->root->trans = conn; + tmp_frame->root->pid = 0; + tmp_frame->root->trans = conn; + memset (&tmp_frame->root->lk_owner, 0, sizeof (gf_lkowner_t)); if (locker->fd) { GF_ASSERT (locker->fd->inode); @@ -480,7 +479,9 @@ do_fd_cleanup (xlator_t *this, server_connection_t *conn, call_frame_t *frame, tmp_frame->root->pid = 0; tmp_frame->root->trans = conn; - tmp_frame->root->lk_owner = 0; + memset (&tmp_frame->root->lk_owner, 0, + sizeof (gf_lkowner_t)); + STACK_WIND (tmp_frame, server_connection_cleanup_flush_cbk, bound_xl, bound_xl->fops->flush, fd); @@ -630,8 +631,9 @@ server_connection_destroy (xlator_t *this, server_connection_t *conn) lock_owner = 0 is a special case that tells posix-locks to release all locks from this transport */ - tmp_frame->root->lk_owner = 0; tmp_frame->root->trans = conn; + memset (&tmp_frame->root->lk_owner, 0, + sizeof (gf_lkowner_t)); if (locker->fd) { GF_ASSERT (locker->fd->inode); @@ -676,8 +678,9 @@ server_connection_destroy (xlator_t *this, server_connection_t *conn) list_for_each_entry_safe (locker, tmp, &entrylk_lockers, lockers) { tmp_frame = copy_frame (frame); - tmp_frame->root->lk_owner = 0; tmp_frame->root->trans = conn; + memset (&tmp_frame->root->lk_owner, 0, + sizeof (gf_lkowner_t)); if (locker->fd) { GF_ASSERT (locker->fd->inode); diff --git a/xlators/protocol/server/src/server-helpers.h b/xlators/protocol/server/src/server-helpers.h index ac1222ed1..844c98c27 100644 --- a/xlators/protocol/server/src/server-helpers.h +++ b/xlators/protocol/server/src/server-helpers.h @@ -52,14 +52,14 @@ gf_add_locker (struct _lock_table *table, const char *volume, loc_t *loc, fd_t *fd, pid_t pid, - uint64_t owner, + gf_lkowner_t *owner, glusterfs_fop_t type); int32_t gf_del_locker (struct _lock_table *table, const char *volume, loc_t *loc, fd_t *fd, - uint64_t owner, + gf_lkowner_t *owner, glusterfs_fop_t type); void diff --git a/xlators/protocol/server/src/server.h b/xlators/protocol/server/src/server.h index 6a37482f4..f26175217 100644 --- a/xlators/protocol/server/src/server.h +++ b/xlators/protocol/server/src/server.h @@ -39,7 +39,7 @@ struct _locker { char *volume; loc_t loc; fd_t *fd; - uint64_t owner; + gf_lkowner_t owner; pid_t pid; }; diff --git a/xlators/protocol/server/src/server3_1-fops.c b/xlators/protocol/server/src/server3_1-fops.c index b847d923c..c2ab3590e 100644 --- a/xlators/protocol/server/src/server3_1-fops.c +++ b/xlators/protocol/server/src/server3_1-fops.c @@ -247,12 +247,13 @@ server_inodelk_cbk (call_frame_t *frame, void *cookie, xlator_t *this, if (op_ret >= 0) { if (state->flock.l_type == F_UNLCK) gf_del_locker (conn->ltable, state->volume, - &state->loc, NULL, frame->root->lk_owner, + &state->loc, NULL, &frame->root->lk_owner, GF_FOP_INODELK); else gf_add_locker (conn->ltable, state->volume, &state->loc, NULL, frame->root->pid, - frame->root->lk_owner, GF_FOP_INODELK); + &frame->root->lk_owner, + GF_FOP_INODELK); } else if ((op_errno != ENOSYS) && (op_errno != EAGAIN)) { gf_log (this->name, GF_LOG_INFO, "%"PRId64": INODELK %s (%s) ==> %"PRId32" (%s)", @@ -289,12 +290,12 @@ server_finodelk_cbk (call_frame_t *frame, void *cookie, xlator_t *this, if (state->flock.l_type == F_UNLCK) gf_del_locker (conn->ltable, state->volume, NULL, state->fd, - frame->root->lk_owner, GF_FOP_INODELK); + &frame->root->lk_owner, GF_FOP_INODELK); else gf_add_locker (conn->ltable, state->volume, NULL, state->fd, frame->root->pid, - frame->root->lk_owner, GF_FOP_INODELK); + &frame->root->lk_owner, GF_FOP_INODELK); } else if ((op_errno != ENOSYS) && (op_errno != EAGAIN)) { gf_log (this->name, GF_LOG_INFO, "%"PRId64": FINODELK %"PRId64" (%s) ==> %"PRId32" (%s)", @@ -329,11 +330,13 @@ server_entrylk_cbk (call_frame_t *frame, void *cookie, xlator_t *this, if (op_ret >= 0) { if (state->cmd == ENTRYLK_UNLOCK) gf_del_locker (conn->ltable, state->volume, - &state->loc, NULL, frame->root->lk_owner, GF_FOP_ENTRYLK); + &state->loc, NULL, &frame->root->lk_owner, + GF_FOP_ENTRYLK); else gf_add_locker (conn->ltable, state->volume, &state->loc, NULL, frame->root->pid, - frame->root->lk_owner, GF_FOP_ENTRYLK); + &frame->root->lk_owner, + GF_FOP_ENTRYLK); } else if ((op_errno != ENOSYS) && (op_errno != EAGAIN)) { gf_log (this->name, GF_LOG_INFO, "%"PRId64": ENTRYLK %s (%s) ==> %"PRId32" (%s)", @@ -367,11 +370,12 @@ server_fentrylk_cbk (call_frame_t *frame, void *cookie, xlator_t *this, if (op_ret >= 0) { if (state->cmd == ENTRYLK_UNLOCK) gf_del_locker (conn->ltable, state->volume, - NULL, state->fd, frame->root->lk_owner, GF_FOP_ENTRYLK); + NULL, state->fd, &frame->root->lk_owner, + GF_FOP_ENTRYLK); else gf_add_locker (conn->ltable, state->volume, NULL, state->fd, frame->root->pid, - frame->root->lk_owner, GF_FOP_ENTRYLK); + &frame->root->lk_owner, GF_FOP_ENTRYLK); } else if ((op_errno != ENOSYS) && (op_errno != EAGAIN)) { gf_log (this->name, GF_LOG_INFO, "%"PRId64": FENTRYLK %"PRId64" (%s) " -- cgit