libglusterfs/inode: introduce new APIs for ctx handling

* inode_ctx_reset{0,1,2}() for reseting value1, value2, and both respectively
* inode_ctx_get0() - to get the first value only
* inode_ctx_set0() - to set the first value only
* inode_ctx_get1() - to get the second value only
* inode_ctx_set1() - to set the second value only

Change-Id: I4dfbdac81d6a3f4e5784e060c76edabb1692ce03
Signed-off-by: Amar Tumballi <amarts@redhat.com>
Reviewed-on: http://review.gluster.org/5890
Reviewed-by: Anand Avati <avati@redhat.com>
Tested-by: Anand Avati <avati@redhat.com>

2 files changed, 264 insertions, 20 deletions

diff --git a/libglusterfs/src/inode.c b/libglusterfs/src/inode.c
index add686fd208..15e0ccf788b 100644
--- a/libglusterfs/src/inode.c
+++ b/libglusterfs/src/inode.c
@@ -1493,6 +1493,18 @@ out:
         return ret;
 }
 
+int
+__inode_ctx_set0 (inode_t *inode, xlator_t *xlator, uint64_t *value1_p)
+{
+        return __inode_ctx_set2 (inode, xlator, value1_p, NULL);
+}
+
+int
+__inode_ctx_set1 (inode_t *inode, xlator_t *xlator, uint64_t *value2_p)
+{
+        return __inode_ctx_set2 (inode, xlator, NULL, value2_p);
+}
+
 
 int
 inode_ctx_set2 (inode_t *inode, xlator_t *xlator, uint64_t *value1_p,
@@ -1512,34 +1524,97 @@ inode_ctx_set2 (inode_t *inode, xlator_t *xlator, uint64_t *value1_p,
         return ret;
 }
 
+int
+inode_ctx_set1 (inode_t *inode, xlator_t *xlator, uint64_t *value2_p)
+{
+        int ret = 0;
+
+        if (!inode || !xlator)
+                return -1;
+
+        LOCK (&inode->lock);
+        {
+                ret = __inode_ctx_set1 (inode, xlator, value2_p);
+        }
+        UNLOCK (&inode->lock);
+
+        return ret;
+}
+int
+inode_ctx_set0 (inode_t *inode, xlator_t *xlator, uint64_t *value1_p)
+{
+        int ret = 0;
+
+        if (!inode || !xlator)
+                return -1;
+
+        LOCK (&inode->lock);
+        {
+                ret = __inode_ctx_set0 (inode, xlator, value1_p);
+        }
+        UNLOCK (&inode->lock);
+
+        return ret;
+}
+
 
 int
 __inode_ctx_get2 (inode_t *inode, xlator_t *xlator, uint64_t *value1,
                   uint64_t *value2)
 {
         int index = 0;
-        int ret = 0;
+        int ret = -1;
 
         if (!inode || !xlator)
-                return -1;
+                goto out;
 
         for (index = 0; index < inode->table->ctxcount; index++) {
                 if (inode->_ctx[index].xl_key == xlator)
                         break;
         }
 
-        if (index == inode->table->ctxcount) {
-                ret = -1;
+        if (index == inode->table->ctxcount)
                 goto out;
+
+        if (inode->_ctx[index].value1) {
+                if (value1)
+                        *value1 = inode->_ctx[index].value1;
+                ret = 0;
         }
+        if (inode->_ctx[index].value2) {
+                if (value2)
+                        *value2 = inode->_ctx[index].value2;
+                ret = 0;
+        }
+out:
+        return ret;
+}
 
-        if (value1)
-                *value1 = inode->_ctx[index].value1;
 
-        if (value2)
-                *value2 = inode->_ctx[index].value2;
 
-out:
+int
+__inode_ctx_get0 (inode_t *inode, xlator_t *xlator, uint64_t *value1)
+{
+        uint64_t tmp_value = 0;
+        int ret = 0;
+
+        ret =  __inode_ctx_get2 (inode, xlator, &tmp_value, NULL);
+        if (!ret)
+                *value1 = tmp_value;
+
+        return ret;
+}
+
+int
+__inode_ctx_get1 (inode_t *inode, xlator_t *xlator, uint64_t *value2)
+{
+        uint64_t tmp_value = 0;
+        int ret = 0;
+
+        ret =  __inode_ctx_get2 (inode, xlator, NULL, &tmp_value);
+        if (!ret)
+                *value2 = tmp_value;
+
         return ret;
 }
 
@@ -1562,6 +1637,40 @@ inode_ctx_get2 (inode_t *inode, xlator_t *xlator, uint64_t *value1,
         return ret;
 }
 
+int
+inode_ctx_get1 (inode_t *inode, xlator_t *xlator, uint64_t *value2)
+{
+        int ret = 0;
+
+        if (!inode || !xlator)
+                return -1;
+
+        LOCK (&inode->lock);
+        {
+                ret = __inode_ctx_get1 (inode, xlator, value2);
+        }
+        UNLOCK (&inode->lock);
+
+        return ret;
+}
+
+int
+inode_ctx_get0 (inode_t *inode, xlator_t *xlator, uint64_t *value1)
+{
+        int ret = 0;
+
+        if (!inode || !xlator)
+                return -1;
+
+        LOCK (&inode->lock);
+        {
+                ret = __inode_ctx_get0 (inode, xlator, value1);
+        }
+        UNLOCK (&inode->lock);
+
+        return ret;
+}
+
 
 int
 inode_ctx_del2 (inode_t *inode, xlator_t *xlator, uint64_t *value1,
@@ -1586,9 +1695,9 @@ inode_ctx_del2 (inode_t *inode, xlator_t *xlator, uint64_t *value1,
                         goto unlock;
                 }
 
-                if (value1)
+                if (inode->_ctx[index].value1 && value1)
                         *value1 = inode->_ctx[index].value1;
-                if (value2)
+                if (inode->_ctx[index].value2 && value2)
                         *value2 = inode->_ctx[index].value2;
 
                 inode->_ctx[index].key    = 0;
@@ -1601,6 +1710,97 @@ unlock:
         return ret;
 }
 
+/* function behavior:
+ - if value1 is set, value1 in ctx is reset to 0 with current value passed
+ back in value1 address.
+ - if value2 is set, value2 in ctx is reset to 0 with current value passed
+ back in value2 address.
+ - if both are set, both fields are reset.
+*/
+static int
+__inode_ctx_reset2 (inode_t *inode, xlator_t *xlator, uint64_t *value1,
+                    uint64_t *value2)
+{
+        int index = 0;
+        int ret = 0;
+
+        if (!inode || !xlator)
+                return -1;
+
+        LOCK (&inode->lock);
+        {
+                for (index = 0; index < inode->table->ctxcount;
+                     index++) {
+                        if (inode->_ctx[index].xl_key == xlator)
+                                break;
+                }
+
+                if (index == inode->table->ctxcount) {
+                        ret = -1;
+                        goto unlock;
+                }
+
+                if (inode->_ctx[index].value1 && value1) {
+                        *value1 = inode->_ctx[index].value1;
+                        inode->_ctx[index].value1 = 0;
+                }
+                if (inode->_ctx[index].value2 && value2) {
+                        *value2 = inode->_ctx[index].value2;
+                        inode->_ctx[index].value2 = 0;
+                }
+        }
+unlock:
+        UNLOCK (&inode->lock);
+
+        return ret;
+}
+
+int
+inode_ctx_reset2 (inode_t *inode, xlator_t *xlator, uint64_t *value1_p,
+                  uint64_t *value2_p)
+{
+        uint64_t tmp_value1 = 0;
+        uint64_t tmp_value2 = 0;
+        int ret = 0;
+
+        ret =  __inode_ctx_reset2 (inode, xlator, &tmp_value1, &tmp_value2);
+        if (!ret) {
+                if (value1_p)
+                        *value1_p = tmp_value1;
+                if (value2_p)
+                        *value2_p = tmp_value2;
+        }
+        return ret;
+}
+
+int
+inode_ctx_reset1 (inode_t *inode, xlator_t *xlator, uint64_t *value2_p)
+{
+        uint64_t tmp_value2 = 0;
+        int ret = 0;
+
+        ret = __inode_ctx_reset2 (inode, xlator, NULL, &tmp_value2);
+
+        if (!ret && value2_p)
+                *value2_p = tmp_value2;
+
+        return ret;
+
+}
+int
+inode_ctx_reset0 (inode_t *inode, xlator_t *xlator, uint64_t *value1_p)
+{
+        uint64_t tmp_value1 = 0;
+        int ret = 0;
+
+        ret = __inode_ctx_reset2 (inode, xlator, &tmp_value1, NULL);
+
+        if (!ret && value1_p)
+                *value1_p = tmp_value1;
+
+        return ret;
+}
+
 
 void
 inode_dump (inode_t *inode, char *prefix)
diff --git a/libglusterfs/src/inode.h b/libglusterfs/src/inode.h
index cf766a31bc6..a8897626545 100644
--- a/libglusterfs/src/inode.h
+++ b/libglusterfs/src/inode.h
@@ -73,10 +73,12 @@ struct _inode_ctx {
                 uint64_t    key;
                 xlator_t   *xl_key;
         };
+        /* if value1 is 0, then field is not set.. */
         union {
                 uint64_t    value1;
                 void       *ptr1;
         };
+        /* if value2 is 0, then field is not set.. */
         union {
                 uint64_t    value2;
                 void       *ptr2;
@@ -159,6 +161,11 @@ __inode_path (inode_t *inode, const char *name, char **bufp);
 inode_t *
 inode_from_path (inode_table_t *table, const char *path);
 
+inode_t *
+inode_resolve (inode_table_t *table, char *path);
+
+/* deal with inode ctx's both values */
+
 int
 inode_ctx_set2 (inode_t *inode, xlator_t *xlator, uint64_t *value1,
                 uint64_t *value2);
@@ -177,29 +184,66 @@ int
 inode_ctx_del2 (inode_t *inode, xlator_t *xlator, uint64_t *value1,
                 uint64_t *value2);
 
-inode_t *
-inode_resolve (inode_table_t *table, char *path);
+int
+inode_ctx_reset2 (inode_t *inode, xlator_t *xlator, uint64_t *value1,
+                  uint64_t *value2);
+
+/* deal with inode ctx's 1st value */
+
+int
+inode_ctx_set0 (inode_t *inode, xlator_t *xlator, uint64_t *value1);
+
+int
+__inode_ctx_set0 (inode_t *inode, xlator_t *xlator, uint64_t *value1);
+
+int
+inode_ctx_get0 (inode_t *inode, xlator_t *xlator, uint64_t *value1);
+int
+__inode_ctx_get0 (inode_t *inode, xlator_t *xlator, uint64_t *value1);
+
+int
+inode_ctx_reset0 (inode_t *inode, xlator_t *xlator, uint64_t *value1);
+
+/* deal with inode ctx's 2st value */
+
+int
+inode_ctx_set1 (inode_t *inode, xlator_t *xlator, uint64_t *value2);
+
+int
+__inode_ctx_set1 (inode_t *inode, xlator_t *xlator, uint64_t *value2);
+
+int
+inode_ctx_get1 (inode_t *inode, xlator_t *xlator, uint64_t *value2);
+int
+__inode_ctx_get1 (inode_t *inode, xlator_t *xlator, uint64_t *value2);
+
+int
+inode_ctx_reset1 (inode_t *inode, xlator_t *xlator, uint64_t *value2);
 
-#define __inode_ctx_set(i,x,v_p) __inode_ctx_set2(i,x,v_p,0)
-#define inode_ctx_set(i,x,v_p) inode_ctx_set2(i,x,v_p,0)
 
 static inline int
 __inode_ctx_put(inode_t *inode, xlator_t *this, uint64_t v)
 {
-        return __inode_ctx_set2 (inode, this, &v, 0);
+        return __inode_ctx_set0 (inode, this, &v);
 }
 
 static inline int
 inode_ctx_put(inode_t *inode, xlator_t *this, uint64_t v)
 {
-        return inode_ctx_set2(inode, this, &v, 0);
+        return inode_ctx_set0 (inode, this, &v);
 }
 
-#define __inode_ctx_get(i,x,v) __inode_ctx_get2(i,x,v,0)
-#define inode_ctx_get(i,x,v) inode_ctx_get2(i,x,v,0)
+#define __inode_ctx_set(i,x,v_p) __inode_ctx_set0(i,x,v_p)
 
-#define inode_ctx_del(i,x,v) inode_ctx_del2(i,x,v,0)
+#define inode_ctx_set(i,x,v_p) inode_ctx_set0(i,x,v_p)
 
+#define inode_ctx_reset(i,x,v) inode_ctx_reset0(i,x,v)
+
+#define __inode_ctx_get(i,x,v) __inode_ctx_get0(i,x,v)
+
+#define inode_ctx_get(i,x,v) inode_ctx_get0(i,x,v)
+
+#define inode_ctx_del(i,x,v) inode_ctx_del2(i,x,v,0)
 
 gf_boolean_t
 __is_root_gfid (uuid_t gfid);