ec_inode readmask

Author: sbk173

xlators/cluster/ec/src/ec-helpers.c

@@ -834,3 +834,12 @@ ec_is_metadata_fop (int32_t lock_kind, glusterfs_fop_t fop)
         }
         return _gf_false;
 }*/
+
+gf_boolean_t
+ec_is_readmask_xattr(dict_t *dict)
+{
+    if (dict && dict->count == 1 && strcmp(dict->members_list->key, EC_XATTR_READMASK) == 0){
+        return _gf_true;
+    }
+    return _gf_false;
+}

xlators/cluster/ec/src/ec-helpers.h

@@ -192,4 +192,7 @@ ec_filter_internal_xattrs(dict_t *xattr);
 int32_t
 ec_launch_replace_heal(ec_t *ec);
 
+gf_boolean_t
+ec_is_readmask_xattr(dict_t *dict);
+
 #endif /* __EC_HELPERS_H__ */

xlators/cluster/ec/src/ec-inode-read.c

@@ -1353,6 +1353,7 @@ ec_manager_readv(ec_fop_data_t *fop, int32_t state)
 {
     ec_cbk_data_t *cbk;
     ec_t *ec = fop->xl->private;
+    ec_inode_t* ctx = __ec_inode_get(fop->fd->inode, fop->xl);
 
     switch (state) {
         case EC_STATE_INIT:
@@ -1372,6 +1373,9 @@ ec_manager_readv(ec_fop_data_t *fop, int32_t state)
             return EC_STATE_DISPATCH;
 
         case EC_STATE_DISPATCH:
+            if (ctx && ctx->read_mask != 0) {
+                fop->mask &= ctx->read_mask;
+            }
             if (ec->read_mask) {
                 fop->mask &= ec->read_mask;
             }

xlators/cluster/ec/src/ec-types.h

@@ -187,6 +187,7 @@ struct _ec_inode {
     struct list_head heal;
     ec_stripe_list_t stripe_cache;
     uint64_t bad_version;
+    uintptr_t read_mask;
 };
 
 typedef int32_t (*fop_heal_cbk_t)(call_frame_t *, void *, xlator_t *, int32_t,

xlators/cluster/ec/src/ec.c

@@ -1321,12 +1321,78 @@ ec_gf_fsetattr(call_frame_t *frame, xlator_t *this, fd_t *fd,
     return 0;
 }
 
+int32_t
+ec_handle_readmask(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *dict,
+                   int32_t flags, dict_t *xdata)
+{
+    char *read_mask_str = NULL;
+    char *mask = NULL;
+    char *maskptr = NULL;
+    char *id_str = NULL;
+    char *saveptr = NULL;
+    data_t *dict_data = NULL;
+    ec_inode_t *ctx = NULL;
+    int id = 0;
+    int op_ret = -1;
+    int op_errno = ENOMEM;
+    uintptr_t read_mask = 0;
+
+    if (!ec_is_readmask_xattr(dict)){
+        return -1;
+    }
+
+    ctx = __ec_inode_get(loc->inode, this);
+    if(!ctx){
+        goto out;
+    }
+
+    int ret = dict_lookup(dict, EC_XATTR_READMASK, &dict_data);
+    if (ret != 0) {
+        op_ret = -1;
+        goto out;
+    }
+    read_mask_str = data_to_str(dict_data);
+    if (!read_mask_str) {
+        goto out;
+    }
+    mask = gf_strdup(read_mask_str);
+    if (!mask) {
+        goto out;
+    }
+    maskptr = mask;
+
+    for(;;){
+        id_str = strtok_r(maskptr, ":", &saveptr);
+        if (id_str == NULL)
+            break;
+        if(gf_string2int(id_str, &id)) {
+            goto out;
+        }
+
+        read_mask |= (1UL << id);
+        maskptr = NULL;
+    }
+
+    ctx->read_mask = read_mask;
+    op_ret = op_errno = 0;
+
+out:
+    if(mask){
+        GF_FREE(mask);
+    }
+    STACK_UNWIND_STRICT(setxattr, frame, op_ret, op_errno, xdata);
+    return 0;
+}
+
 int32_t
 ec_gf_setxattr(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *dict,
                int32_t flags, dict_t *xdata)
 {
     int error = 0;
 
+    if  (ec_handle_readmask(frame, this, loc, dict, flags, xdata) == 0)
+         return 0;
+    
     EC_INTERNAL_XATTR_OR_GOTO("", dict, error, out);
 
     ec_setxattr(frame, this, -1, EC_MINIMUM_MIN, default_setxattr_cbk, NULL,

xlators/cluster/ec/src/ec.h

@@ -20,6 +20,7 @@
 #define EC_XATTR_HEAL EC_XATTR_PREFIX "heal"
 #define EC_XATTR_HEAL_NEW EC_XATTR_PREFIX "heal-new"
 #define EC_XATTR_DIRTY EC_XATTR_PREFIX "dirty"
+#define EC_XATTR_READMASK EC_XATTR_PREFIX "readmask"
 #define EC_STRIPE_CACHE_MAX_SIZE 10
 #define EC_VERSION_SIZE 2
 #define EC_SHD_INODE_LRU_LIMIT 10