--- ./source/private_module/ostorvfs_34/acache.c	2018-07-03 11:15:08.000000000 +0800
+++ ./source/private_module/ostorvfs_34/acache.c.hotpatch	2018-07-03 16:21:26.000000000 +0800
@@ -23,9 +23,9 @@
     struct hlist_head head;
     rwlock_t lock;
 };
-
-
-
+struct ostorvfs_acachent_data{uint64_t a_pfsid; uint64_t a_pfid; uint64_t a_fsid; acachent_attr_t a_attr;uint32_t a_type;};
+int32_t ostorvfs_check_acachent_exsit(uint64_t pfsid, uint64_t pfid, const char *dname);
+int32_t ostorvfs_get_acachent_data(uint64_t pfsid, uint64_t pfid, const char* dname, struct ostorvfs_acachent_data *result);
 /***************************************************
      : ostorvfs_set_pim_buffer_pum
 : PIMֵ
@@ -961,7 +961,7 @@
 int32_t ostorvfs_insert_acachent(struct ostorvfs_acachent* node)
 {
     struct ostorvfs_bucket_head* head = NULL;
-    struct ostorvfs_acachent* ent = NULL;
+    int32_t rc = NAS_OK;
 
     
     if (unlikely(!node))
@@ -970,8 +970,8 @@
         return -EINVAL;
     }
 
-    ent = ostorvfs_find_acachent(node->a_pfsid, node->a_pfid, node->a_name);
-    if (likely(ent))
+    rc = ostorvfs_check_acachent_exsit(node->a_pfsid, node->a_pfid, node->a_name);
+    if (NAS_OK == rc)
     {
         NAS_DBG(MOD_NAS_PIM, LOG_DEBUG, "acachent exist in hash table pfsid:%llu, pfid:%llu, name:%s", node->a_pfsid, node->a_pfid, node->a_name);
         return -EEXIST;
@@ -1404,3 +1404,108 @@
 EXPORT_SYMBOL(ostorvfs_insert_parent_dir_acachent);
 #endif
 
+int32_t ostorvfs_get_acachent_data(uint64_t pfsid, uint64_t pfid, const char* dname, struct ostorvfs_acachent_data *result)
+{
+    struct ostorvfs_bucket_head *head = NULL;
+    struct ostorvfs_acachent *pos = NULL;
+    struct hlist_node *node = NULL;
+    int32_t rc = NAS_ERROR;
+
+    if (unlikely(!dname || (0 == strlen(dname))))
+    {
+        NAS_DBG(MOD_NAS_PIM, LOG_ERROR, "invalid paramter, dname.");
+        return NAS_ERROR;
+    }
+
+    head = ostorvfs_find_bucket(pfsid, pfid, dname);
+    if (unlikely(!head))
+    {
+        NAS_DBG(MOD_NAS_PIM, LOG_WARNING, 
+            "find bucket failed, pfsid:%llu, pfid:%llu, dname:%s",        
+            pfsid, pfid, dname);
+        return NAS_ERROR;
+    }
+
+   NAS_DBG(MOD_NAS_PIM, LOG_DEBUG, "find bucket success, pfsid:%llu, pfid:%llu, dname:%s.",        
+            pfsid, pfid, dname);
+    
+    read_lock(&head->lock);
+    hlist_for_each_entry(pos, node, &head->head, a_hash) 
+    {
+        rc = ostorvfs_compare_acachent(pos, pfsid, pfid, dname);
+        if (NAS_OK == rc)
+        {
+            result->a_pfsid = pos->a_pfsid;
+            result->a_pfid = pos->a_pfid;
+            result->a_fsid = pos->a_fsid;
+            result->a_type = pos->a_type;
+
+            result->a_attr.crtime = pos->a_attr->crtime;
+            result->a_attr.atime = pos->a_attr->atime;
+            result->a_attr.a_usid = pos->a_attr->a_usid;
+            result->a_attr.a_gsid = pos->a_attr->a_gsid;
+            result->a_attr.dosattr = pos->a_attr->dosattr;
+
+            result->a_attr.k_attr.ino = pos->a_attr->k_attr.ino;
+            result->a_attr.k_attr.dev = pos->a_attr->k_attr.dev;
+            result->a_attr.k_attr.mode = pos->a_attr->k_attr.mode;
+            result->a_attr.k_attr.nlink = pos->a_attr->k_attr.nlink;
+            result->a_attr.k_attr.uid = pos->a_attr->k_attr.uid;
+            result->a_attr.k_attr.gid = pos->a_attr->k_attr.gid;
+            result->a_attr.k_attr.rdev = pos->a_attr->k_attr.rdev;
+            result->a_attr.k_attr.size = pos->a_attr->k_attr.size;
+            result->a_attr.k_attr.atime = pos->a_attr->k_attr.atime;
+            result->a_attr.k_attr.mtime = pos->a_attr->k_attr.mtime;
+            result->a_attr.k_attr.ctime = pos->a_attr->k_attr.ctime;
+            result->a_attr.k_attr.blksize = pos->a_attr->k_attr.blksize;
+            result->a_attr.k_attr.blocks = pos->a_attr->k_attr.blocks;
+
+            NAS_DBG(MOD_NAS_PIM, LOG_DEBUG, "get acachent data success pfsid:%llu, pfid:%llu, name:%s", pfsid, pfid, dname);
+            break;
+        }
+    }
+    read_unlock(&head->lock);
+            
+    return rc;
+}
+
+int32_t ostorvfs_check_acachent_exsit(uint64_t pfsid, uint64_t pfid, const char *dname)
+{
+    struct ostorvfs_bucket_head *head = NULL;
+    struct ostorvfs_acachent *pos = NULL;
+    struct hlist_node *node = NULL;
+    int32_t rc = NAS_ERROR;
+
+    if (unlikely(!dname || (0 == strlen(dname))))
+    {
+        NAS_DBG(MOD_NAS_PIM, LOG_ERROR, "invalid paramter, dname.");
+        return NAS_ERROR;
+    }
+    
+    head = ostorvfs_find_bucket(pfsid, pfid, dname);
+    if (unlikely(!head))
+    {
+        NAS_DBG(MOD_NAS_PIM, LOG_WARNING, 
+            "find bucket failed, pfsid:%llu, pfid:%llu, dname:%s.",        
+            pfsid, pfid, dname);
+        return NAS_ERROR;
+    }
+
+   NAS_DBG(MOD_NAS_PIM, LOG_DEBUG, "find bucket success, pfsid:%llu, pfid:%llu, dname:%s.",        
+            pfsid, pfid, dname);
+
+    read_lock(&head->lock);
+    hlist_for_each_entry(pos, node, &head->head, a_hash) 
+    {
+        rc = ostorvfs_compare_acachent(pos, pfsid, pfid, dname);
+        if (NAS_OK == rc)
+        {
+            NAS_DBG(MOD_NAS_PIM, LOG_DEBUG, "acachent exsit pfsid:%llu, pfid:%llu, name:%s", pfsid, pfid, dname);
+            break;
+        }
+    }
+    read_unlock(&head->lock);
+
+    return rc;
+}
+
--- ./source/private_module/ostorvfs_34/inode.c	2018-07-03 11:15:08.000000000 +0800
+++ ./source/private_module/ostorvfs_34/inode.c.hotpatch	2018-07-03 19:24:16.000000000 +0800
@@ -37,7 +37,7 @@
 #define NAS_USID_GSID_XATTR_NAME "protocol.nas_usid_gsid" 
 
 #define NAS_XATTR_NAME "protocol.nas_xattr"
-
+struct ostorvfs_acachent_data{uint64_t a_pfsid; uint64_t a_pfid; uint64_t a_fsid; acachent_attr_t a_attr;uint32_t a_type;};
 typedef enum nas_xattr_tag
 {
     NAS_XATTR_DOSATTR,
@@ -59,12 +59,12 @@
     size_t read_pos;
     size_t write_pos;
 }pim_byte_buffer_t;
-
+extern int32_t ostorvfs_get_acachent_data(uint64_t pfsid, uint64_t pfid, const char* dname, struct ostorvfs_acachent_data *result);
 static int is_dosattr_valid(const nas_attr_t* nap)
 {
     return nap->na_dosattr != 0;
 }
-
+extern int32_t ostorvfs_check_acachent_exsit(uint64_t pfsid, uint64_t pfid, const char *dname);
 static size_t get_dosattr_len(const nas_attr_t* nap)
 {
     (void)nap;
@@ -3120,23 +3120,23 @@
 **************************************************************************/
 static int ostorvfs_revalid_nas_attr(struct dentry *dentry, nas_entry_t *nep)
 {
-    struct ostorvfs_acachent* cache_entry = NULL;
+    struct ostorvfs_acachent_data result = {0};
     struct dentry* parent = NULL;
     uint64_t pfsid = 0;
-
+    int32_t rc = NAS_OK;
     parent = dget_parent(dentry);
     pfsid = (uint64_t)parent->d_inode->i_private;
-    cache_entry = ostorvfs_find_acachent(pfsid, parent->d_inode->i_ino, (char*)dentry->d_name.name);
+    rc = ostorvfs_get_acachent_data(pfsid, parent->d_inode->i_ino, (char*)dentry->d_name.name, &result);
     dput(parent);
-    if (cache_entry != NULL && cache_entry->a_attr != NULL)
+    if (NAS_OK == rc)
     {
-        nep->ne_attr.na_uid = cache_entry->a_attr->k_attr.uid;
-        nep->ne_attr.na_gid = cache_entry->a_attr->k_attr.gid;
-        nep->ne_attr.na_usid = cache_entry->a_attr->a_usid;
-        nep->ne_attr.na_gsid = cache_entry->a_attr->a_gsid;
-        nep->ne_attr.na_atime = cache_entry->a_attr->atime;
-        nep->ne_attr.na_crtime = cache_entry->a_attr->crtime;
-        nep->ne_attr.na_dosattr = cache_entry->a_attr->dosattr;
+        nep->ne_attr.na_uid = result.a_attr.k_attr.uid;
+        nep->ne_attr.na_gid = result.a_attr.k_attr.gid;
+        nep->ne_attr.na_usid = result.a_attr.a_usid;
+        nep->ne_attr.na_gsid = result.a_attr.a_gsid;
+        nep->ne_attr.na_atime = result.a_attr.atime;
+        nep->ne_attr.na_crtime = result.a_attr.crtime;
+        nep->ne_attr.na_dosattr = result.a_attr.dosattr;
         return RETURN_OK;
     }
 
@@ -3982,7 +3982,7 @@
     uint64_t _snapfsid = 0xffffffffffffffff;
     nas_entry_t *parent = NULL;
     nas_entry_t *entry = NULL;
-    struct ostorvfs_acachent *snapentry = NULL;
+    struct ostorvfs_acachent_data result = {0};
     vfs_handle_t *handle = NULL;
     int32_t ret = 0;
     
@@ -3996,10 +3996,10 @@
         goto echo;
     }
 
-    snapentry = ostorvfs_find_acachent(fsid, psnapfid, snapName);
-    if (likely(snapentry))
+    ret = ostorvfs_get_acachent_data(fsid, psnapfid, snapName, &result);
+    if (NAS_OK == ret)
     {
-        _snapfsid = snapentry->a_fsid;
+        _snapfsid = result.a_fsid;
         NAS_DBG(MOD_NAS_PIM, LOG_DEBUG, "readdir netlink: find snapfsid(%llu).", _snapfsid);
         ret = 0;
         goto echo;
@@ -4072,10 +4072,10 @@
 
         nas_free(component);
 
-        snapentry = ostorvfs_find_acachent(fsid, psnapfid, snapName);
-        if (likely(snapentry))
+        ret = ostorvfs_get_acachent_data(fsid, psnapfid, snapName, &result);
+        if (NAS_OK == ret)
         {
-            _snapfsid = snapentry->a_fsid;
+            _snapfsid = result.a_fsid;
             NAS_DBG(MOD_NAS_PIM, LOG_ERROR, "readdir netlink: find snapfsid(%llu).", _snapfsid);
             break;
         }
@@ -4301,8 +4301,8 @@
         return 0;
     }
 
-    acachent = ostorvfs_find_acachent(buf->pfsid, buf->pfid, (char *)name);
-    IF_THEN (NULL != acachent)
+    ret = ostorvfs_check_acachent_exsit(buf->pfsid, buf->pfid, (char *)name);
+    IF_THEN (NAS_OK == ret)
     {
         NAS_DBG(MOD_NAS_PIM, LOG_DEBUG, "readdir plus, find cache(%s) pfid(%lu)", name, buf->pfid);
         return 0;
@@ -4678,7 +4678,7 @@
     uint64_t fsid = 0;
     uint64_t psnapfid = 0;
     uint64_t fid = 0;
-    uint64_t snapfsid = 0;
+    //uint64_t snapfsid = 0;
     char *dir = NULL;
     char *snapName = NULL;
     char back_ok[] = "ok";
@@ -4721,36 +4721,36 @@
 
     NAS_DBG(MOD_NAS_PIM, LOG_DEBUG, "readdir netlink: fsid(%llu) psnapfid(%llu) fid(%llu) dir(%s) snapName(%s).", fsid, psnapfid, fid, dir, snapName);
 
-    NAS_TP_START(PIM_RDPLUS_WQ_311_1_1, &ret, RETURN_ERROR); 
-    ret = add_readdir_plus_request_to_wq(dir, snapName, fsid, psnapfid, fid);
-    NAS_TP_END;
-    if (likely(RETURN_OK == ret))
-    {
-        nas_free(dir);
-        nas_free(snapName);
-        (void)nas_kernel_send_ucast(MODULE_ID_PIM, arg->pid, arg->seq, (u8*)back_ok, (u32)(strlen(back_ok)));
-        return RETURN_OK;
-    }
+    
+    (void)add_readdir_plus_request_to_wq(dir, snapName, fsid, psnapfid, fid);
+    
+    //if (likely(RETURN_OK == ret))
+    
+    //nas_free(dir);
+    //nas_free(snapName);
+    (void)nas_kernel_send_ucast(MODULE_ID_PIM, arg->pid, arg->seq, (u8*)back_ok, (u32)(strlen(back_ok)));
+    //return RETURN_OK;
+
 
-    NAS_DBG(MOD_NAS_PIM, LOG_WARNING, "readdir netlink, sync readdirplus."); 
+    NAS_DBG(MOD_NAS_PIM, LOG_DEBUG, "readdir netlink, sync readdirplus."); 
 
     //ͨ·ȡfid,fsid,pid
-    ret = __ostorvfs_get_snapshot_fsid(dir, fsid, psnapfid, snapName, &snapfsid);
-    if (unlikely(ret))
-    {
-        NAS_DBG(MOD_NAS_PIM, LOG_ERROR, "readdir netlink: __ostorvfs_get_snapshot_fsid failed(%d).", ret);
-        nas_kernel_send_err_ucast(MODULE_ID_PIM, arg->pid, arg->seq, ret);
-    }
-    else
-    {
-        ostorvfs_readdir_plus(fsid, snapfsid, fid);
-        (void)nas_kernel_send_ucast(MODULE_ID_PIM, arg->pid, arg->seq, (u8*)back_ok, (u32)(strlen(back_ok)));
-    }
+    //ret = __ostorvfs_get_snapshot_fsid(dir, fsid, psnapfid, snapName, &snapfsid);
+    //if (unlikely(ret))
+    //{
+        NAS_DBG(MOD_NAS_PIM, LOG_DEBUG, "readdir netlink: __ostorvfs_get_snapshot_fsid failed(%d).", ret);
+    //   nas_kernel_send_err_ucast(MODULE_ID_PIM, arg->pid, arg->seq, ret);
+    //}
+    //else
+    //{
+    //    ostorvfs_readdir_plus(fsid, snapfsid, fid);
+    //    (void)nas_kernel_send_ucast(MODULE_ID_PIM, arg->pid, arg->seq, (u8*)back_ok, (u32)(strlen(back_ok)));
+    //}
     
     nas_free(dir);
     nas_free(snapName);
     
-    return ret;
+    return RETURN_OK;
 }
 
 
@@ -4966,8 +4966,8 @@
     struct dentry* dentry, struct dentry** d)
 {
     uint64_t fsid = 0;
-    struct ostorvfs_acachent* ent = NULL;
-    acachent_attr_t* attr = NULL;
+    struct ostorvfs_acachent_data result = {0};
+    int32_t rc = NAS_OK;
     struct inode* node = NULL;
 
     OSTORVFS_OP_CUR_STATICS_INFO ostorvfs_opstatics;
@@ -4981,9 +4981,9 @@
     NAS_DBG(MOD_NAS_PIM, LOG_DEBUG, 
             "begin find acachent pfsid:%llu, pfid:%llu, dentry->name:%s",
             fsid, dir->i_ino, (char *)dentry->d_name.name);
-    
-    ent = ostorvfs_find_acachent(fsid, dir->i_ino, (char *)dentry->d_name.name);
-    if (unlikely(!ent))
+
+    rc = ostorvfs_get_acachent_data(fsid, dir->i_ino, (char *)dentry->d_name.name, &result);
+    if (NAS_OK != rc)
     {
         ostorvfs_opstatics_action(&ostorvfs_opstatics, 
             OSTORVFS_STATIC_SWITCH_DONE_PIM_FAIL_FSA_INVALID, OSTORVFS_OP_LOOKUP_SNAPSHOT); 
@@ -4994,17 +4994,17 @@
     }
 
     //TODO:ҵ˻еĽڵ㣬ֱӸinodeϢ
-    attr = ent->a_attr;
-    if (unlikely(!attr))
-    {
-        ostorvfs_opstatics_action(&ostorvfs_opstatics, 
-            OSTORVFS_STATIC_SWITCH_DONE_PIM_FAIL_FSA_INVALID, OSTORVFS_OP_LOOKUP_SNAPSHOT); 
+    //attr = ent->a_attr;
+    //if (unlikely(!attr))
+    //{
+    //    ostorvfs_opstatics_action(&ostorvfs_opstatics, 
+    //        OSTORVFS_STATIC_SWITCH_DONE_PIM_FAIL_FSA_INVALID, OSTORVFS_OP_LOOKUP_SNAPSHOT); 
         NAS_DBG(MOD_NAS_PIM, LOG_DEBUG, 
             "null attr in acachent, "
-            "pfsid:%llu, pfid:%llu, dentry->name:%s",
-            fsid, dir->i_ino, (char *)dentry->d_name.name);
-        return 1;
-    }
+            "pfsid, pfid, dentry->name"
+            );
+    //    return 1;
+    //}
     node = new_inode(dentry->d_sb);
     if (unlikely(!node))
     {
@@ -5013,13 +5013,13 @@
         NAS_DBG(MOD_NAS_PIM, LOG_ERROR, "new inode failed");
         return 1;
     }
-    node->i_private = (void*)ent->a_fsid;
-    node->i_ino = ent->a_attr->k_attr.ino;
+    node->i_private = (void*)result.a_fsid;
+    node->i_ino = result.a_attr.k_attr.ino;
     node->i_sb = dentry->d_sb; 
-    ostorvfs_generic_fill_inodeattr(node, &attr->k_attr);
+    ostorvfs_generic_fill_inodeattr(node, &result.a_attr.k_attr);
     //TODO:
-    NAS_DBG(MOD_NAS_PIM, LOG_DEBUG, "__ostorvfs_lookup_under_snapshot, d_type:%d", ent->a_type);
-    ostorvfs_set_inode_mode_opt(node, (vtype_t)ent->a_type);
+    NAS_DBG(MOD_NAS_PIM, LOG_DEBUG, "__ostorvfs_lookup_under_snapshot, d_type:%d", result.a_type);
+    ostorvfs_set_inode_mode_opt(node, (vtype_t)result.a_type);
     
     *d = d_splice_alias(node, dentry);
 
--- ./source/private_module/ostorvfs_34/ostorvfs_init.c	2018-07-03 11:15:08.000000000 +0800
+++ ./source/private_module/ostorvfs_34/ostorvfs_init.c.hotpatch	2018-07-03 19:12:44.000000000 +0800
@@ -14,7 +14,7 @@
     unsigned long flags;
     struct delayed_work work;
 };
-
+struct ostorvfs_acachent_data{uint64_t a_pfsid; uint64_t a_pfid; uint64_t a_fsid; acachent_attr_t a_attr;uint32_t a_type;};
 #define PREFETCH_MANAGER_DATA_FLAG 0x1
 struct prefetch_manager_data prefetch_manager;
 
@@ -34,7 +34,7 @@
 }readdir_plus_wq_info_t;
 
 readdir_plus_wq_info_t g_readdir_plus_wq_info;
-
+extern int32_t ostorvfs_check_acachent_exsit(uint64_t pfsid, uint64_t pfid, const char *dname);
 atomic_t g_used_io_concurrency;
 uint32_t g_total_io_concurrency = 0;
 /**************************************************************************
@@ -60,7 +60,7 @@
     uint64_t fsid = 0;
     struct dentry* parent = NULL;
     struct inode* dir = NULL;
-    struct ostorvfs_acachent* ent = NULL;
+    int32_t rc = NAS_OK;
 
     CHECK_NULL_POINTER(dentry, (-EINVAL));
 
@@ -83,8 +83,8 @@
     //֤߱εĺϷ
     fsid = (uint64_t)dir->i_private;
     
-    ent = ostorvfs_find_acachent(fsid, dir->i_ino, (char *)dentry->d_name.name);
-    if (unlikely(!ent))
+    rc = ostorvfs_check_acachent_exsit(fsid, dir->i_ino, (char *)dentry->d_name.name);
+    if (NAS_OK != rc)
     {
         NAS_DBG(MOD_NAS_PIM, LOG_DEBUG, 
             "check_ndmp_dentry_invalid, dentry not find, pfsid:%llu, pfid:%llu, dentry->name:%s",
@@ -660,7 +660,7 @@
     {
         *wq_idx = idx;
     }
-
+    if (atomic64_read(&(wq_info->work_queue[idx].task_in_queue)) >= 100) {return NULL;}
     return &wq_info->work_queue[idx];
 }
 
