gfid: changes in inode management

- incorporate usage of uuid (gfid) as the key for finding inodes
- deprecate inode number/generation number based inode_get
- undo code specific to generation numbers (attic list etc.)

Signed-off-by: Anand V. Avati <avati@blackhole.gluster.com>
Signed-off-by: Anand V. Avati <avati@amp.gluster.com>
Signed-off-by: Vijay Bellur <vijay@dev.gluster.com>

BUG: 971 (dynamic volume management)
URL: http://bugs.gluster.com/cgi-bin/bugzilla3/show_bug.cgi?id=971

11 files changed, 82 insertions, 275 deletions

diff --git a/libglusterfs/src/inode.c b/libglusterfs/src/inode.c
index 67f4183b47b..45d151ef04b 100644
--- a/libglusterfs/src/inode.c
+++ b/libglusterfs/src/inode.c
@@ -73,34 +73,16 @@ hash_dentry (inode_t *parent, const char *name, int mod)
 
 
 static int
-hash_name (ino_t par, const char *name, int mod)
+hash_gfid (uuid_t uuid, int mod)
 {
-        int hash = 0;
         int ret = 0;
 
-        hash = *name;
-        if (hash) {
-                for (name += 1; *name != '\0'; name++) {
-                        hash = (hash << 5) - hash + *name;
-                }
-        }
-        ret = (hash + par) % mod;
+        ret = uuid[15] + (uuid[14] << 8);
 
         return ret;
 }
 
 
-static int
-hash_inode (ino_t ino, int mod)
-{
-        int hash = 0;
-
-        hash = ino % mod;
-
-        return hash;
-}
-
-
 static void
 __dentry_hash (dentry_t *dentry)
 {
@@ -173,12 +155,6 @@ __inode_unhash (inode_t *inode)
         if (!inode)
                 return;
 
-        if (!list_empty (&inode->hash)) {
-                if (inode->in_attic)
-                        inode->table->attic_size--;
-                inode->in_attic = 0;
-        }
-
         list_del_init (&inode->hash);
 }
 
@@ -203,56 +179,13 @@ __inode_hash (inode_t *inode)
                 return;
 
         table = inode->table;
-        hash = hash_inode (inode->ino, table->hashsize);
+        hash = hash_gfid (inode->gfid, 65536);
 
         list_del_init (&inode->hash);
         list_add (&inode->hash, &table->inode_hash[hash]);
 }
 
 
-static inode_t *
-__inode_search (inode_table_t *table, ino_t ino)
-{
-        int       hash = 0;
-        inode_t  *inode = NULL;
-        inode_t  *tmp = NULL;
-
-        if (!table)
-                return NULL;
-
-        hash = hash_inode (ino, table->hashsize);
-
-        list_for_each_entry (tmp, &table->inode_hash[hash], hash) {
-                if (tmp->ino == ino) {
-                        inode = tmp;
-                        break;
-                }
-        }
-
-        return inode;
-}
-
-
-static inode_t *
-__inode_search_attic (inode_table_t *table, ino_t ino, uint64_t gen)
-{
-        inode_t  *inode = NULL;
-        inode_t  *tmp = NULL;
-
-        if (!table)
-                return NULL;
-
-        list_for_each_entry (tmp, &table->attic, hash) {
-                if (tmp->ino == ino && tmp->generation == gen) {
-                        inode = tmp;
-                        break;
-                }
-        }
-
-        return inode;
-}
-
-
 static dentry_t *
 __dentry_search_for_inode (inode_t *inode, ino_t par, const char *name)
 {
@@ -273,47 +206,6 @@ __dentry_search_for_inode (inode_t *inode, ino_t par, const char *name)
 }
 
 
-dentry_t *
-dentry_search_for_inode (inode_t *inode, ino_t par, const char *name)
-{
-        dentry_t *dentry = NULL;
-
-        if (!inode || !name)
-                return NULL;
-
-        pthread_mutex_lock (&inode->table->lock);
-        {
-                dentry = __dentry_search_for_inode (inode, par, name);
-        }
-        pthread_mutex_unlock (&inode->table->lock);
-
-        return dentry;
-}
-
-
-static dentry_t *
-__dentry_search (inode_table_t *table, ino_t par, const char *name)
-{
-        int       hash = 0;
-        dentry_t *dentry = NULL;
-        dentry_t *tmp = NULL;
-
-        if (!table || !name)
-                return NULL;
-
-        hash = hash_name (par, name, table->hashsize);
-
-        list_for_each_entry (tmp, &table->name_hash[hash], hash) {
-                if (tmp->parent->ino == par && !strcmp (tmp->name, name)) {
-                        dentry = tmp;
-                        break;
-                }
-        }
-
-        return dentry;
-}
-
-
 static void
 __inode_destroy (inode_t *inode)
 {
@@ -616,35 +508,6 @@ __inode_forget (inode_t *inode, uint64_t nlookup)
 }
 
 
-inode_t *
-inode_search (inode_table_t *table, ino_t ino, const char *name)
-{
-        inode_t  *inode = NULL;
-        dentry_t *dentry = NULL;
-
-        if (!table)
-                return NULL;
-
-        pthread_mutex_lock (&table->lock);
-        {
-                if (!name) {
-                        inode = __inode_search (table, ino);
-                } else {
-                        dentry = __dentry_search (table, ino, name);
-
-                        if (dentry)
-                                inode = dentry->inode;
-                }
-
-                if (inode)
-                        __inode_ref (inode);
-        }
-        pthread_mutex_unlock (&table->lock);
-
-        return inode;
-}
-
-
 dentry_t *
 __dentry_grep (inode_table_t *table, inode_t *parent, const char *name)
 {
@@ -694,23 +557,46 @@ inode_grep (inode_table_t *table, inode_t *parent, const char *name)
 
 
 inode_t *
-__inode_get (inode_table_t *table, ino_t ino, uint64_t gen)
+inode_get (inode_table_t *table, ino_t ino, uint64_t gen)
+{
+        return NULL;
+}
+
+
+static int
+__is_root_gfid (uuid_t gfid)
+{
+        uuid_t  root;
+        int     ret;
+
+        memset (root, 0, 16);
+        root[15] = 1;
+
+        ret = uuid_compare (gfid, root);
+
+        return ret;
+}
+
+
+inode_t *
+__inode_find (inode_table_t *table, uuid_t gfid)
 {
         inode_t   *inode = NULL;
+        inode_t   *tmp = NULL;
+        int        hash = 0;
 
         if (!table)
-                return NULL;
-
-        if (ino == 1) {
-                inode = table->root;
                 goto out;
-        }
 
-        inode = __inode_search (table, ino);
+        if (__is_root_gfid (gfid) == 0)
+                return table->root;
+
+        hash = hash_gfid (gfid, 65536);
 
-        if (gen) {
-                if (!inode || inode->generation != gen) {
-                        inode = __inode_search_attic (table, ino, gen);
+        list_for_each_entry (tmp, &table->inode_hash[hash], hash) {
+                if (uuid_compare (tmp->gfid, gfid) == 0) {
+                        inode = tmp;
+                        break;
                 }
         }
 
@@ -720,7 +606,7 @@ out:
 
 
 inode_t *
-inode_get (inode_table_t *table, ino_t ino, uint64_t gen)
+inode_find (inode_table_t *table, uuid_t gfid)
 {
         inode_t   *inode = NULL;
 
@@ -729,7 +615,7 @@ inode_get (inode_table_t *table, ino_t ino, uint64_t gen)
 
         pthread_mutex_lock (&table->lock);
         {
-                inode = __inode_get (table, ino, gen);
+                inode = __inode_find (table, gfid);
                 if (inode)
                         __inode_ref (inode);
         }
@@ -739,36 +625,6 @@ inode_get (inode_table_t *table, ino_t ino, uint64_t gen)
 }
 
 
-static int
-__inode_atticize (inode_t *inode)
-{
-        inode_table_t *table = NULL;
-
-        if (!inode)
-                return -1;
-
-        table = inode->table;
-
-        __inode_unhash (inode);
-
-        list_add (&inode->hash, &table->attic);
-        inode->in_attic = 1;
-        table->attic_size++;
-
-        return 0;
-}
-
-
-uint64_t
-inode_gen_from_stat (struct iatt *iatt)
-{
-        if (!iatt)
-                return 0;
-
-        return (uint64_t) iatt->ia_gen;
-}
-
-
 static inode_t *
 __inode_link (inode_t *inode, inode_t *parent, const char *name,
               struct iatt *iatt)
@@ -779,7 +635,7 @@ __inode_link (inode_t *inode, inode_t *parent, const char *name,
         inode_table_t *table = NULL;
         inode_t       *link_inode = NULL;
 
-        if (!inode || !iatt)
+        if (!inode)
                 return NULL;
 
         table = inode->table;
@@ -788,31 +644,21 @@ __inode_link (inode_t *inode, inode_t *parent, const char *name,
 
         link_inode = inode;
 
-        if (iatt->ia_ino == 1 && inode != table->root) {
-                gf_log (table->name, GF_LOG_ERROR,
-                        "inode_link called with iatt->ia_ino = 1. "
-                        "inode=%"PRId64"/%"PRId64 "parent=%"PRId64"/%"PRId64
-                        " name=%s",
-                        inode ? inode->generation:0 , inode ? inode->ino:0,
-                        parent ? parent->generation:0 , parent ? parent->ino:0,
-                        name);
-                return link_inode;
-        }
-
         if (!__is_inode_hashed (inode)) {
+                if (!iatt)
+                        return NULL;
+
+                if (uuid_is_null (iatt->ia_gfid))
+                        return NULL;
+
+                uuid_copy (inode->gfid, iatt->ia_gfid);
                 inode->ino        = iatt->ia_ino;
                 inode->ia_type    = iatt->ia_type;
-                inode->generation = inode_gen_from_stat (iatt);
 
-                old_inode = __inode_search (table, inode->ino);
+                old_inode = __inode_find (table, inode->gfid);
 
                 if (old_inode) {
-                        if (old_inode->generation < inode->generation) {
-                                __inode_atticize (old_inode);
-                                __inode_hash (inode);
-                        } else {
-                                link_inode = old_inode;
-                        }
+                        link_inode = old_inode;
                 } else {
                         __inode_hash (inode);
                 }
@@ -842,7 +688,7 @@ inode_link (inode_t *inode, inode_t *parent, const char *name,
         inode_table_t *table = NULL;
         inode_t       *linked_inode = NULL;
 
-        if (!inode || !iatt)
+        if (!inode)
                 return NULL;
 
         table = inode->table;
@@ -1163,14 +1009,15 @@ inode_table_prune (inode_table_t *table)
 static void
 __inode_table_init_root (inode_table_t *table)
 {
-        inode_t *root = NULL;
-        struct iatt iatt = {0, };
+        inode_t     *root = NULL;
+        struct iatt  iatt = {0, };
 
         if (!table)
                 return;
 
         root = __inode_create (table);
 
+        iatt.ia_gfid[15] = 1;
         iatt.ia_ino = 1;
         iatt.ia_type = IA_IFDIR;
 
@@ -1210,7 +1057,7 @@ inode_table_new (size_t lru_limit, xlator_t *xl)
                 return NULL;
         }
 
-        new->inode_hash = (void *)GF_CALLOC (new->hashsize,
+        new->inode_hash = (void *)GF_CALLOC (65536,
                                              sizeof (struct list_head),
                                              gf_common_mt_list_head);
         if (!new->inode_hash) {
@@ -1234,19 +1081,18 @@ inode_table_new (size_t lru_limit, xlator_t *xl)
 		  GF_FREE (new);
 	 }
 
-        for (i=0; i<new->hashsize; i++) {
+        for (i = 0; i < 65536; i++) {
                 INIT_LIST_HEAD (&new->inode_hash[i]);
         }
 
 
-        for (i=0; i<new->hashsize; i++) {
+        for (i = 0; i < new->hashsize; i++) {
                 INIT_LIST_HEAD (&new->name_hash[i]);
         }
 
         INIT_LIST_HEAD (&new->active);
         INIT_LIST_HEAD (&new->lru);
         INIT_LIST_HEAD (&new->purge);
-        INIT_LIST_HEAD (&new->attic);
 
         ret = gf_asprintf (&new->name, "%s/inode", xl->name);
         if (-1 == ret) {
@@ -1509,6 +1355,7 @@ inode_dump (inode_t *inode, char *prefix)
         int             ret = -1;
         xlator_t        *xl = NULL;
         int             i = 0;
+        char            uuidbuf[256];
 
         if (!inode)
                 return;
@@ -1521,10 +1368,11 @@ inode_dump (inode_t *inode, char *prefix)
                 return;
         }
 
+        uuid_unparse (inode->gfid, uuidbuf);
+        gf_proc_dump_build_key(key, prefix, "gfid");
+        gf_proc_dump_write(key, "%s", uuidbuf);
         gf_proc_dump_build_key(key, prefix, "nlookup");
         gf_proc_dump_write(key, "%ld", inode->nlookup);
-        gf_proc_dump_build_key(key, prefix, "generation");
-        gf_proc_dump_write(key, "%ld", inode->generation);
         gf_proc_dump_build_key(key, prefix, "ref");
         gf_proc_dump_write(key, "%u", inode->ref);
         gf_proc_dump_build_key(key, prefix, "ino");
diff --git a/libglusterfs/src/inode.h b/libglusterfs/src/inode.h
index a0bb8f8b57d..71d53366946 100644
--- a/libglusterfs/src/inode.h
+++ b/libglusterfs/src/inode.h
@@ -60,13 +60,9 @@ struct _inode_table {
         struct list_head   purge;       /* list of inodes to be purged soon */
         uint32_t           purge_size;  /* count of inodes in purge list */
 
-        struct list_head   attic;       /* list of inodes which do not have the latest generation
-                                           number. inode_t's @hash is linked with @attic. It is
-                                           otherwise linked with @inode_hash */
-        uint32_t           attic_size;
         struct mem_pool   *inode_pool;  /* memory pool for inodes */
         struct mem_pool   *dentry_pool; /* memory pool for dentrys */
-	 struct mem_pool   *fd_mem_pool; /* memory pool for fd_t */
+        struct mem_pool   *fd_mem_pool; /* memory pool for fd_t */
 };
 
 
@@ -98,8 +94,6 @@ struct _inode {
         uuid_t               gfid;
         gf_lock_t            lock;
         uint64_t             nlookup;
-        uint64_t             generation;
-        uint32_t             in_attic;      /* whether @hash is linked with @inode_hash or @attic */
         uint32_t             ref;           /* reference count on this inode */
         ino_t                ino;           /* inode number in the storage (persistent) */
         ia_type_t            ia_type;       /* what kind of file */
@@ -119,9 +113,6 @@ inode_t *
 inode_new (inode_table_t *table);
 
 inode_t *
-inode_search (inode_table_t *table, ino_t ino, const char *name);
-
-inode_t *
 inode_link (inode_t *inode, inode_t *parent,
             const char *name, struct iatt *stbuf);
 
@@ -154,28 +145,28 @@ inode_grep (inode_table_t *table, inode_t *parent, const char *name);
 inode_t *
 inode_get (inode_table_t *table, ino_t ino, uint64_t gen);
 
+inode_t *
+inode_find (inode_table_t *table, uuid_t gfid);
+
 int
 inode_path (inode_t *inode, const char *name, char **bufp);
 
 inode_t *
 inode_from_path (inode_table_t *table, const char *path);
 
-dentry_t *
-dentry_search_for_inode (inode_t *inode, ino_t par, const char *name);
-
 int
 __inode_ctx_put (inode_t *inode, xlator_t *xlator, uint64_t value);
 
 int
 inode_ctx_put (inode_t *inode, xlator_t *xlator, uint64_t value);
 
-int 
+int
 __inode_ctx_get (inode_t *inode, xlator_t *xlator, uint64_t *value);
 
-int 
+int
 inode_ctx_get (inode_t *inode, xlator_t *xlator, uint64_t *value);
 
-int 
+int
 inode_ctx_del (inode_t *inode, xlator_t *xlator, uint64_t *value);
 
 int
diff --git a/xlators/cluster/afr/src/afr-common.c b/xlators/cluster/afr/src/afr-common.c
index 38e58ba9559..22bb4322edd 100644
--- a/xlators/cluster/afr/src/afr-common.c
+++ b/xlators/cluster/afr/src/afr-common.c
@@ -626,8 +626,6 @@ afr_lookup_done (call_frame_t *frame, xlator_t *this, struct iatt *lookup_buf)
                 if (local->cont.lookup.inode->ino) {
                         local->cont.lookup.buf.ia_ino =
                                 local->cont.lookup.inode->ino;
-                        local->cont.lookup.buf.ia_gen =
-                                local->cont.lookup.inode->generation;
                 }
         }
 
diff --git a/xlators/cluster/dht/src/dht-common.c b/xlators/cluster/dht/src/dht-common.c
index a1b48649417..cef73a9d681 100644
--- a/xlators/cluster/dht/src/dht-common.c
+++ b/xlators/cluster/dht/src/dht-common.c
@@ -289,7 +289,6 @@ dht_revalidate_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
 		
 		local->op_ret = 0;
 		local->stbuf.ia_ino = local->ia_ino;
-                local->stbuf.ia_gen = local->loc.inode->generation;
 
                 if (local->loc.parent)
                         local->postparent.ia_ino = local->loc.parent->ino;
diff --git a/xlators/mount/fuse/src/fuse-bridge.c b/xlators/mount/fuse/src/fuse-bridge.c
index aea0f88b0c1..97309194819 100644
--- a/xlators/mount/fuse/src/fuse-bridge.c
+++ b/xlators/mount/fuse/src/fuse-bridge.c
@@ -145,14 +145,6 @@ fuse_entry_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                                            state->loc.name, buf);
 
                 if (linked_inode != inode) {
-                        gf_log ("glusterfs-fuse", GF_LOG_WARNING,
-                                "%s(%s) inode (ptr=%p, ino=%"PRId64", "
-                                "gen=%"PRId64") found conflict (ptr=%p, "
-                                "ino=%"PRId64", gen=%"PRId64")",
-                                gf_fop_list[frame->root->op],
-                                state->loc.path, inode, inode->ino,
-                                inode->generation, linked_inode,
-                                linked_inode->ino, linked_inode->generation);
                 }
 
                 inode_lookup (linked_inode);
@@ -161,8 +153,6 @@ fuse_entry_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                 /* should we do linked_node or inode */
                 feo.nodeid = inode_to_fuse_nodeid (linked_inode);
 
-                feo.generation = linked_inode->generation;
-
                 inode_unref (linked_inode);
 
                 feo.entry_valid =
@@ -1445,14 +1435,6 @@ fuse_create_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                                            state->loc.name, buf);
 
                 if (linked_inode != inode) {
-                        gf_log ("glusterfs-fuse", GF_LOG_WARNING,
-                                "create(%s) inode (ptr=%p, ino=%"PRId64", "
-                                "gen=%"PRId64") found conflict (ptr=%p, "
-                                "ino=%"PRId64", gen=%"PRId64")",
-                                state->loc.path, inode, inode->ino,
-                                inode->generation, linked_inode,
-                                linked_inode->ino, linked_inode->generation);
-
                         /*
                            VERY racy code (if used anywhere else)
                            -- don't do this without understanding
@@ -1470,8 +1452,6 @@ fuse_create_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
 
                 feo.nodeid = inode_to_fuse_nodeid (linked_inode);
 
-                feo.generation = linked_inode->generation;
-
                 feo.entry_valid = calc_timeout_sec (priv->entry_timeout);
                 feo.entry_valid_nsec = calc_timeout_nsec (priv->entry_timeout);
                 feo.attr_valid = calc_timeout_sec (priv->attribute_timeout);
@@ -2933,6 +2913,7 @@ fuse_first_lookup (xlator_t *this)
         xlator_t                  *xl = NULL;
         dict_t                    *dict = NULL;
         struct fuse_first_lookup   stub;
+        uuid_t                     gfid;
 
         priv = this->private;
 
@@ -2954,6 +2935,10 @@ fuse_first_lookup (xlator_t *this)
 
         frame->local = &stub;
 
+        memset (gfid, 0, 16);
+        gfid[15] = 1;
+        
+
         STACK_WIND (frame, fuse_first_lookup_cbk, xl, xl->fops->lookup,
                     &loc, dict);
         dict_unref (dict);
diff --git a/xlators/nfs/server/src/mount3.c b/xlators/nfs/server/src/mount3.c
index 2a7a36c8f7e..c61cf0a488a 100644
--- a/xlators/nfs/server/src/mount3.c
+++ b/xlators/nfs/server/src/mount3.c
@@ -306,8 +306,8 @@ mnt3svc_mount_inode (rpcsvc_request_t *req, struct mount3_state *ms,
         ret = nfs_inode_loc_fill (exportinode, &exportloc);
         if (ret < 0) {
                 gf_log (GF_MNT, GF_LOG_ERROR, "Loc fill failed for export inode"
-                        ": ino %"PRIu64", gen: %"PRIu64", volume: %s",
-                        exportinode->ino, exportinode->generation, xl->name);
+                        ": ino %"PRIu64", volume: %s",
+                        exportinode->ino, xl->name);
                 goto err;
         }
 
@@ -446,7 +446,7 @@ __mnt3_resolve_export_subdir_comp (mnt3_resolve_t *mres)
                 goto err;
 
         parino = mres->resolveloc.inode->ino;
-        pargen = mres->resolveloc.inode->generation;
+
         /* Wipe the contents of the previous component */
         nfs_loc_wipe (&mres->resolveloc);
         ret = nfs_entry_loc_fill (mres->exp->vol->itable, parino, pargen,
diff --git a/xlators/nfs/server/src/nfs3-helpers.c b/xlators/nfs/server/src/nfs3-helpers.c
index c10954ab996..5a5a0b29df3 100644
--- a/xlators/nfs/server/src/nfs3-helpers.c
+++ b/xlators/nfs/server/src/nfs3-helpers.c
@@ -2580,7 +2580,6 @@ nfs3_fh_resolve_found_entry (nfs3_call_state_t *cs, gf_dirent_t *candidate)
                 return -EFAULT;
 
         dirino = cs->resolvedloc.inode->ino;
-        dirgen = cs->resolvedloc.inode->generation;
 
         nfs_loc_wipe (&cs->resolvedloc);
         ret = nfs_entry_loc_fill (cs->vol->itable, dirino, dirgen,
@@ -2644,7 +2643,6 @@ nfs3_fh_resolve_found_parent (nfs3_call_state_t *cs, gf_dirent_t *candidate)
                 return -EFAULT;
 
         dirino = cs->resolvedloc.inode->ino;
-        dirgen = cs->resolvedloc.inode->generation;
 
         nfs_loc_wipe (&cs->resolvedloc);
         ret = nfs_entry_loc_fill (cs->vol->itable, dirino, dirgen,
@@ -2862,7 +2860,6 @@ nfs3_fh_resolve_check_response (nfs3_call_state_t *cs, gf_dirent_t *candidate,
                 return ret;
 
         dirino = cs->resolvedloc.inode->ino;
-        dirgen = cs->resolvedloc.inode->generation;
 
         switch (response) {
 
diff --git a/xlators/protocol/legacy/server/src/server-protocol.c b/xlators/protocol/legacy/server/src/server-protocol.c
index 35d58ae99cd..56acc59b791 100644
--- a/xlators/protocol/legacy/server/src/server-protocol.c
+++ b/xlators/protocol/legacy/server/src/server-protocol.c
@@ -2068,13 +2068,6 @@ server_create_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                                          state->loc.name, stbuf);
 
                 if (link_inode != inode) {
-                        gf_log (this->name, GF_LOG_DEBUG,
-                                "create(%s) inode (ptr=%p, ino=%"PRId64", "
-                                "gen=%"PRId64") found conflict (ptr=%p, "
-                                "ino=%"PRId64", gen=%"PRId64")",
-                                state->loc.path, inode, inode->ino,
-                                inode->generation, link_inode,
-                                link_inode->ino, link_inode->generation);
 
                         /*
                            VERY racy code (if used anywhere else)
diff --git a/xlators/protocol/legacy/server/src/server-resolve.c b/xlators/protocol/legacy/server/src/server-resolve.c
index 63351fd34f0..f08ec1c060c 100644
--- a/xlators/protocol/legacy/server/src/server-resolve.c
+++ b/xlators/protocol/legacy/server/src/server-resolve.c
@@ -354,7 +354,8 @@ resolve_entry_simple (call_frame_t *frame)
                 goto out;
         }
 
-        if (parent->ino != 1 && parent->generation != resolve->gen) {
+//        if (parent->ino != 1 && parent->generation != resolve->gen) {
+        if (0) {
                 /* simple resolution is decisive - request was for a
                    stale handle */
                 resolve->op_ret   = -1;
@@ -468,7 +469,8 @@ resolve_inode_simple (call_frame_t *frame)
                 goto out;
         }
 
-        if (inode->ino != 1 && inode->generation != resolve->gen) {
+//        if (inode->ino != 1 && inode->generation != resolve->gen) {
+        if (0) {
                 resolve->op_ret      = -1;
                 resolve->op_errno    = ENOENT;
                 ret = -1;
diff --git a/xlators/protocol/server/src/server-resolve.c b/xlators/protocol/server/src/server-resolve.c
index ec955b1e872..eba34bdf768 100644
--- a/xlators/protocol/server/src/server-resolve.c
+++ b/xlators/protocol/server/src/server-resolve.c
@@ -349,7 +349,8 @@ resolve_entry_simple (call_frame_t *frame)
                 goto out;
         }
 
-        if (parent->ino != 1 && parent->generation != resolve->gen) {
+//        if (parent->ino != 1 && parent->generation != resolve->gen) {
+        if (0) {
                 /* simple resolution is decisive - request was for a
                    stale handle */
                 resolve->op_ret   = -1;
@@ -457,7 +458,8 @@ resolve_inode_simple (call_frame_t *frame)
                 goto out;
         }
 
-        if (inode->ino != 1 && inode->generation != resolve->gen) {
+//        if (inode->ino != 1 && inode->generation != resolve->gen) {
+        if (0) {
                 resolve->op_ret      = -1;
                 resolve->op_errno    = ENOENT;
                 ret = -1;
diff --git a/xlators/protocol/server/src/server3_1-fops.c b/xlators/protocol/server/src/server3_1-fops.c
index c73f3df15be..7748ef81324 100644
--- a/xlators/protocol/server/src/server3_1-fops.c
+++ b/xlators/protocol/server/src/server3_1-fops.c
@@ -1369,14 +1369,6 @@ server_create_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                                          state->loc.name, stbuf);
 
                 if (link_inode != inode) {
-                        gf_log (this->name, GF_LOG_DEBUG,
-                                "create(%s) inode (ptr=%p, ino=%"PRId64", "
-                                "gen=%"PRId64") found conflict (ptr=%p, "
-                                "ino=%"PRId64", gen=%"PRId64")",
-                                state->loc.path, inode, inode->ino,
-                                inode->generation, link_inode,
-                                link_inode->ino, link_inode->generation);
-
                         /*
                            VERY racy code (if used anywhere else)
                            -- don't do this without understanding