Skip to contentSkip to conversation

vfs: remove the unnecessrary code of fs/inode.c

PATCH In review Dong Fang 3 participants 6 messages Jul 1, 2013 – Jul 2, 2013 VFS

lore
Share & tools
lore

Dong Fang

author
#0 lore raw

PATCH 1/1 vfs: remove the unnecessrary code of fs/inode.c

These functions, such as find_inode_fast() and find_inode(), iget_lock() and iget5_lock(), insert_inode_locked() and insert_inode_locked4(), almost have the same code.

---
 fs/inode.c |  134 ++++++++++++------------------------------------------------
 1 files changed, 26 insertions(+), 108 deletions(-)
fs/inode.c +26 -108
index 00d5fc3..847eee9 100644
@@ -790,6 +790,22 @@ void prune_icache_sb(struct super_block *sb, int nr_to_scan)
 }
 
 static void __wait_on_freeing_inode(struct inode *inode);
+
+
+static int test_ino(struct inode *inode, void *data)
+{
+	unsigned long ino = *(unsigned long *) data;
+	return inode->i_ino == ino;
+}
+
+static int set_ino(struct inode *inode, void *data)
+{
+	inode->i_ino = *(unsigned long *) data;
+	return 0;
+}
+
+
+
 /*
  * Called with the inode lock held.
  */
@@ -829,28 +845,7 @@ repeat:
 static struct inode *find_inode_fast(struct super_block *sb,
 				struct hlist_head *head, unsigned long ino)
 {
-	struct inode *inode = NULL;
-
-repeat:
-	hlist_for_each_entry(inode, head, i_hash) {
-		spin_lock(&inode->i_lock);
-		if (inode->i_ino != ino) {
-			spin_unlock(&inode->i_lock);
-			continue;
-		}
-		if (inode->i_sb != sb) {
-			spin_unlock(&inode->i_lock);
-			continue;
-		}
-		if (inode->i_state & (I_FREEING|I_WILL_FREE)) {
-			__wait_on_freeing_inode(inode);
-			goto repeat;
-		}
-		__iget(inode);
-		spin_unlock(&inode->i_lock);
-		return inode;
-	}
-	return NULL;
+	return find_inode(sb, head, test_ino, (void *)&ino);
 }
 
 /*
@@ -1073,50 +1068,7 @@ EXPORT_SYMBOL(iget5_locked);
  */
 struct inode *iget_locked(struct super_block *sb, unsigned long ino)
 {
-	struct hlist_head *head = inode_hashtable + hash(sb, ino);
-	struct inode *inode;
-
-	spin_lock(&inode_hash_lock);
-	inode = find_inode_fast(sb, head, ino);
-	spin_unlock(&inode_hash_lock);
-	if (inode) {
-		wait_on_inode(inode);
-		return inode;
-	}
-
-	inode = alloc_inode(sb);
-	if (inode) {
-		struct inode *old;
-
-		spin_lock(&inode_hash_lock);
-		/* We released the lock, so.. */
-		old = find_inode_fast(sb, head, ino);
-		if (!old) {
-			inode->i_ino = ino;
-			spin_lock(&inode->i_lock);
-			inode->i_state = I_NEW;
-			hlist_add_head(&inode->i_hash, head);
-			spin_unlock(&inode->i_lock);
-			inode_sb_list_add(inode);
-			spin_unlock(&inode_hash_lock);
-
-			/* Return the locked inode with I_NEW set, the
-			 * caller is responsible for filling in the contents
-			 */
-			return inode;
-		}
-
-		/*
-		 * Uhhuh, somebody else created the same inode under
-		 * us. Use the old inode instead of the one we just
-		 * allocated.
-		 */
-		spin_unlock(&inode_hash_lock);
-		destroy_inode(inode);
-		inode = old;
-		wait_on_inode(inode);
-	}
-	return inode;
+	return iget5_locked(sb, ino, test_ino, set_ino, (void *)&ino);
 }
 EXPORT_SYMBOL(iget_locked);
 
@@ -1281,48 +1233,6 @@ struct inode *ilookup(struct super_block *sb, unsigned long ino)
 }
 EXPORT_SYMBOL(ilookup);
 
-int insert_inode_locked(struct inode *inode)
-{
-	struct super_block *sb = inode->i_sb;
-	ino_t ino = inode->i_ino;
-	struct hlist_head *head = inode_hashtable + hash(sb, ino);
-
-	while (1) {
-		struct inode *old = NULL;
-		spin_lock(&inode_hash_lock);
-		hlist_for_each_entry(old, head, i_hash) {
-			if (old->i_ino != ino)
-				continue;
-			if (old->i_sb != sb)
-				continue;
-			spin_lock(&old->i_lock);
-			if (old->i_state & (I_FREEING|I_WILL_FREE)) {
-				spin_unlock(&old->i_lock);
-				continue;
-			}
-			break;
-		}
-		if (likely(!old)) {
-			spin_lock(&inode->i_lock);
-			inode->i_state |= I_NEW;
-			hlist_add_head(&inode->i_hash, head);
-			spin_unlock(&inode->i_lock);
-			spin_unlock(&inode_hash_lock);
-			return 0;
-		}
-		__iget(old);
-		spin_unlock(&old->i_lock);
-		spin_unlock(&inode_hash_lock);
-		wait_on_inode(old);
-		if (unlikely(!inode_unhashed(old))) {
-			iput(old);
-			return -EBUSY;
-		}
-		iput(old);
-	}
-}
-EXPORT_SYMBOL(insert_inode_locked);
-
 int insert_inode_locked4(struct inode *inode, unsigned long hashval,
 		int (*test)(struct inode *, void *), void *data)
 {
@@ -1366,6 +1276,14 @@ int insert_inode_locked4(struct inode *inode, unsigned long hashval,
 }
 EXPORT_SYMBOL(insert_inode_locked4);
 
+int insert_inode_locked(struct inode *inode)
+{
+	unsigned long ino = inode->i_ino;
+	return insert_inode_locked4(inode, ino, test_ino, (void *)&ino);
+}
+EXPORT_SYMBOL(insert_inode_locked);
+
+
 
 int generic_delete_inode(struct inode *inode)
 {
Signature · 1 line
1.7.1
Reviewed-by on v1 1/1
#1 lore raw
Quoted 3 lines · Dong Fang

These functions, such as find_inode_fast() and find_inode(), iget_lock() and iget5_lock(), insert_inode_locked() and insert_inode_locked4(), almost have the same code.

Maybe the title "[PATCH] vfs: remove the reduplicate code of fs/inode.c" is more suitable.

Quoted 2 lines

Thanks,
Gu

Quoted 9 lines
---
 fs/inode.c |  134 ++++++++++++------------------------------------------------
 1 files changed, 26 insertions(+), 108 deletions(-)
fs/inode.c +0 -0
index 00d5fc3..847eee9 100644

fs/inode.c void prune_icache_sb(struct super_block *sb, int nr_to_scan) · line 798

Quoted 9 lines
fs/inode.c +6 -0
@@ -790,6 +790,22 @@ void prune_icache_sb(struct super_block *sb, int nr_to_scan)
 }
 
 static void __wait_on_freeing_inode(struct inode *inode);
+
+
+static int test_ino(struct inode *inode, void *data)
+{
+	unsigned long ino = *(unsigned long *) data;
+	return inode->i_ino == ino;

Can be more concise:

	return inode->i_ino == *(unsigned long *) data;

,so does the new insert_inode_locked():

Quoted 145 lines
fs/inode.c +12 -108
+}
+
+static int set_ino(struct inode *inode, void *data)
+{
+	inode->i_ino = *(unsigned long *) data;
+	return 0;
+}
+
+
+
 /*
  * Called with the inode lock held.
  */
@@ -829,28 +845,7 @@ repeat:
 static struct inode *find_inode_fast(struct super_block *sb,
 				struct hlist_head *head, unsigned long ino)
 {
-	struct inode *inode = NULL;
-
-repeat:
-	hlist_for_each_entry(inode, head, i_hash) {
-		spin_lock(&inode->i_lock);
-		if (inode->i_ino != ino) {
-			spin_unlock(&inode->i_lock);
-			continue;
-		}
-		if (inode->i_sb != sb) {
-			spin_unlock(&inode->i_lock);
-			continue;
-		}
-		if (inode->i_state & (I_FREEING|I_WILL_FREE)) {
-			__wait_on_freeing_inode(inode);
-			goto repeat;
-		}
-		__iget(inode);
-		spin_unlock(&inode->i_lock);
-		return inode;
-	}
-	return NULL;
+	return find_inode(sb, head, test_ino, (void *)&ino);
 }
 
 /*
@@ -1073,50 +1068,7 @@ EXPORT_SYMBOL(iget5_locked);
  */
 struct inode *iget_locked(struct super_block *sb, unsigned long ino)
 {
-	struct hlist_head *head = inode_hashtable + hash(sb, ino);
-	struct inode *inode;
-
-	spin_lock(&inode_hash_lock);
-	inode = find_inode_fast(sb, head, ino);
-	spin_unlock(&inode_hash_lock);
-	if (inode) {
-		wait_on_inode(inode);
-		return inode;
-	}
-
-	inode = alloc_inode(sb);
-	if (inode) {
-		struct inode *old;
-
-		spin_lock(&inode_hash_lock);
-		/* We released the lock, so.. */
-		old = find_inode_fast(sb, head, ino);
-		if (!old) {
-			inode->i_ino = ino;
-			spin_lock(&inode->i_lock);
-			inode->i_state = I_NEW;
-			hlist_add_head(&inode->i_hash, head);
-			spin_unlock(&inode->i_lock);
-			inode_sb_list_add(inode);
-			spin_unlock(&inode_hash_lock);
-
-			/* Return the locked inode with I_NEW set, the
-			 * caller is responsible for filling in the contents
-			 */
-			return inode;
-		}
-
-		/*
-		 * Uhhuh, somebody else created the same inode under
-		 * us. Use the old inode instead of the one we just
-		 * allocated.
-		 */
-		spin_unlock(&inode_hash_lock);
-		destroy_inode(inode);
-		inode = old;
-		wait_on_inode(inode);
-	}
-	return inode;
+	return iget5_locked(sb, ino, test_ino, set_ino, (void *)&ino);
 }
 EXPORT_SYMBOL(iget_locked);
 
@@ -1281,48 +1233,6 @@ struct inode *ilookup(struct super_block *sb, unsigned long ino)
 }
 EXPORT_SYMBOL(ilookup);
 
-int insert_inode_locked(struct inode *inode)
-{
-	struct super_block *sb = inode->i_sb;
-	ino_t ino = inode->i_ino;
-	struct hlist_head *head = inode_hashtable + hash(sb, ino);
-
-	while (1) {
-		struct inode *old = NULL;
-		spin_lock(&inode_hash_lock);
-		hlist_for_each_entry(old, head, i_hash) {
-			if (old->i_ino != ino)
-				continue;
-			if (old->i_sb != sb)
-				continue;
-			spin_lock(&old->i_lock);
-			if (old->i_state & (I_FREEING|I_WILL_FREE)) {
-				spin_unlock(&old->i_lock);
-				continue;
-			}
-			break;
-		}
-		if (likely(!old)) {
-			spin_lock(&inode->i_lock);
-			inode->i_state |= I_NEW;
-			hlist_add_head(&inode->i_hash, head);
-			spin_unlock(&inode->i_lock);
-			spin_unlock(&inode_hash_lock);
-			return 0;
-		}
-		__iget(old);
-		spin_unlock(&old->i_lock);
-		spin_unlock(&inode_hash_lock);
-		wait_on_inode(old);
-		if (unlikely(!inode_unhashed(old))) {
-			iput(old);
-			return -EBUSY;
-		}
-		iput(old);
-	}
-}
-EXPORT_SYMBOL(insert_inode_locked);
-
 int insert_inode_locked4(struct inode *inode, unsigned long hashval,
 		int (*test)(struct inode *, void *), void *data)
 {

fs/inode.c int insert_inode_locked4(struct inode *inode, unsigned long hashval, · line 1282

Quoted 7 lines
fs/inode.c +4 -0
@@ -1366,6 +1276,14 @@ int insert_inode_locked4(struct inode *inode, unsigned long hashval,
 }
 EXPORT_SYMBOL(insert_inode_locked4);
 
+int insert_inode_locked(struct inode *inode)
+{
+	unsigned long ino = inode->i_ino;
+	return insert_inode_locked4(inode, ino, test_ino, (void *)&ino);

return insert_inode_locked4(inode, inode->i_ino, test_ino, (void *)&ino);

Quoted 7 lines
fs/inode.c +4 -0
+}
+EXPORT_SYMBOL(insert_inode_locked);
+
+
 
 int generic_delete_inode(struct inode *inode)
 {
author
#2 lore raw
Quoted 9 lines · Gu Zheng
Quoted 3 lines · Dong Fang

These functions, such as find_inode_fast() and find_inode(), iget_lock() and iget5_lock(), insert_inode_locked() and insert_inode_locked4(), almost have the same code.

Maybe the title "[PATCH] vfs: remove the reduplicate code of fs/inode.c" is more suitable.

that's right, thanks for your advice

Quoted 198 lines
Quoted 2 lines

Thanks,
Gu

Quoted 9 lines
---
  fs/inode.c |  134 ++++++++++++------------------------------------------------
  1 files changed, 26 insertions(+), 108 deletions(-)
fs/inode.c +0 -0
index 00d5fc3..847eee9 100644

fs/inode.c void prune_icache_sb(struct super_block *sb, int nr_to_scan) · line 798

Quoted 9 lines
fs/inode.c +6 -0
@@ -790,6 +790,22 @@ void prune_icache_sb(struct super_block *sb, int nr_to_scan)
  }
 
  static void __wait_on_freeing_inode(struct inode *inode);
+
+
+static int test_ino(struct inode *inode, void *data)
+{
+	unsigned long ino = *(unsigned long *) data;
+	return inode->i_ino == ino;

Can be more concise:

	return inode->i_ino == *(unsigned long *) data;

,so does the new insert_inode_locked():

Quoted 145 lines
fs/inode.c +12 -108
+}
+
+static int set_ino(struct inode *inode, void *data)
+{
+	inode->i_ino = *(unsigned long *) data;
+	return 0;
+}
+
+
+
  /*
   * Called with the inode lock held.
   */
@@ -829,28 +845,7 @@ repeat:
  static struct inode *find_inode_fast(struct super_block *sb,
  				struct hlist_head *head, unsigned long ino)
  {
-	struct inode *inode = NULL;
-
-repeat:
-	hlist_for_each_entry(inode, head, i_hash) {
-		spin_lock(&inode->i_lock);
-		if (inode->i_ino != ino) {
-			spin_unlock(&inode->i_lock);
-			continue;
-		}
-		if (inode->i_sb != sb) {
-			spin_unlock(&inode->i_lock);
-			continue;
-		}
-		if (inode->i_state & (I_FREEING|I_WILL_FREE)) {
-			__wait_on_freeing_inode(inode);
-			goto repeat;
-		}
-		__iget(inode);
-		spin_unlock(&inode->i_lock);
-		return inode;
-	}
-	return NULL;
+	return find_inode(sb, head, test_ino, (void *)&ino);
  }
 
  /*
@@ -1073,50 +1068,7 @@ EXPORT_SYMBOL(iget5_locked);
   */
  struct inode *iget_locked(struct super_block *sb, unsigned long ino)
  {
-	struct hlist_head *head = inode_hashtable + hash(sb, ino);
-	struct inode *inode;
-
-	spin_lock(&inode_hash_lock);
-	inode = find_inode_fast(sb, head, ino);
-	spin_unlock(&inode_hash_lock);
-	if (inode) {
-		wait_on_inode(inode);
-		return inode;
-	}
-
-	inode = alloc_inode(sb);
-	if (inode) {
-		struct inode *old;
-
-		spin_lock(&inode_hash_lock);
-		/* We released the lock, so.. */
-		old = find_inode_fast(sb, head, ino);
-		if (!old) {
-			inode->i_ino = ino;
-			spin_lock(&inode->i_lock);
-			inode->i_state = I_NEW;
-			hlist_add_head(&inode->i_hash, head);
-			spin_unlock(&inode->i_lock);
-			inode_sb_list_add(inode);
-			spin_unlock(&inode_hash_lock);
-
-			/* Return the locked inode with I_NEW set, the
-			 * caller is responsible for filling in the contents
-			 */
-			return inode;
-		}
-
-		/*
-		 * Uhhuh, somebody else created the same inode under
-		 * us. Use the old inode instead of the one we just
-		 * allocated.
-		 */
-		spin_unlock(&inode_hash_lock);
-		destroy_inode(inode);
-		inode = old;
-		wait_on_inode(inode);
-	}
-	return inode;
+	return iget5_locked(sb, ino, test_ino, set_ino, (void *)&ino);
  }
  EXPORT_SYMBOL(iget_locked);
 
@@ -1281,48 +1233,6 @@ struct inode *ilookup(struct super_block *sb, unsigned long ino)
  }
  EXPORT_SYMBOL(ilookup);
 
-int insert_inode_locked(struct inode *inode)
-{
-	struct super_block *sb = inode->i_sb;
-	ino_t ino = inode->i_ino;
-	struct hlist_head *head = inode_hashtable + hash(sb, ino);
-
-	while (1) {
-		struct inode *old = NULL;
-		spin_lock(&inode_hash_lock);
-		hlist_for_each_entry(old, head, i_hash) {
-			if (old->i_ino != ino)
-				continue;
-			if (old->i_sb != sb)
-				continue;
-			spin_lock(&old->i_lock);
-			if (old->i_state & (I_FREEING|I_WILL_FREE)) {
-				spin_unlock(&old->i_lock);
-				continue;
-			}
-			break;
-		}
-		if (likely(!old)) {
-			spin_lock(&inode->i_lock);
-			inode->i_state |= I_NEW;
-			hlist_add_head(&inode->i_hash, head);
-			spin_unlock(&inode->i_lock);
-			spin_unlock(&inode_hash_lock);
-			return 0;
-		}
-		__iget(old);
-		spin_unlock(&old->i_lock);
-		spin_unlock(&inode_hash_lock);
-		wait_on_inode(old);
-		if (unlikely(!inode_unhashed(old))) {
-			iput(old);
-			return -EBUSY;
-		}
-		iput(old);
-	}
-}
-EXPORT_SYMBOL(insert_inode_locked);
-
  int insert_inode_locked4(struct inode *inode, unsigned long hashval,
  		int (*test)(struct inode *, void *), void *data)
  {

fs/inode.c int insert_inode_locked4(struct inode *inode, unsigned long hashval, · line 1282

Quoted 7 lines
fs/inode.c +4 -0
@@ -1366,6 +1276,14 @@ int insert_inode_locked4(struct inode *inode, unsigned long hashval,
  }
  EXPORT_SYMBOL(insert_inode_locked4);
 
+int insert_inode_locked(struct inode *inode)
+{
+	unsigned long ino = inode->i_ino;
+	return insert_inode_locked4(inode, ino, test_ino, (void *)&ino);

return insert_inode_locked4(inode, inode->i_ino, test_ino, (void *)&ino);

Quoted 7 lines
fs/inode.c +4 -0
+}
+EXPORT_SYMBOL(insert_inode_locked);
+
+
 
  int generic_delete_inode(struct inode *inode)
  {
maintainer
#3 lore raw
In reply to Dong Fang
Quoted 3 lines · Dong Fang

These functions, such as find_inode_fast() and find_inode(), iget_lock() and iget5_lock(), insert_inode_locked() and insert_inode_locked4(), almost have the same code.

NAK. These functions exist exactly because the variant with callbacks costs more. We walk the hash chain and for each inode on it your variant would result in
* call
* fetching ino from memory
* comparison (and storing result in general-purpose register)
* return
* checking that register and branch on the result of that check
What's more, the whole thing's not fun for branch predictor.

It is a hot enough path to warrant a special-cased variant; if we can't get away with that, we use the variants with callbacks, but on filesystems where ->i_ino is sufficient as search key we really want to avoid the overhead.

author
#4 lore raw
Quoted 15 lines · Al Viro
Quoted 3 lines · Dong Fang

These functions, such as find_inode_fast() and find_inode(), iget_lock() and iget5_lock(), insert_inode_locked() and insert_inode_locked4(), almost have the same code.

NAK. These functions exist exactly because the variant with callbacks costs more. We walk the hash chain and for each inode on it your variant would result in
* call
* fetching ino from memory
* comparison (and storing result in general-purpose register)
* return
* checking that register and branch on the result of that check
What's more, the whole thing's not fun for branch predictor.

Quoted 5 lines

It is a hot enough path to warrant a special-cased variant; if we can't get away with that, we use the variants with callbacks, but on filesystems where ->i_ino is sufficient as search key we really want to avoid the overhead.

that's right, i didn't think of it, but i think may be we can remove the deduplicate codes of iget_lock() and iget5_lock() function, right?

if ok, i will send a new patch later. :)

thx Viro.

author
#5 lore raw
Quoted 25 lines · Dong Fang
Quoted 17 lines · Al Viro
Quoted 5 lines · Dong Fang

These functions, such as find_inode_fast() and find_inode(), iget_lock() and
iget5_lock(), insert_inode_locked() and insert_inode_locked4(), almost have
the same code.

NAK. These functions exist exactly because the variant with callbacks costs more. We walk the hash chain and for each inode on it your variant would result in
* call
* fetching ino from memory
* comparison (and storing result in general-purpose register)
* return
* checking that register and branch on the result of that check
What's more, the whole thing's not fun for branch predictor.

Quoted 6 lines

It is a hot enough path to warrant a special-cased variant; if we can't get away with that, we use the variants with callbacks, but on filesystems
where ->i_ino is sufficient as search key we really want to avoid the overhead.

Quoted 6 lines

that's right, i didn't think of it, but i think may be we can remove the deduplicate codes of iget_lock() and iget5_lock() function, right?

if ok, i will send a new patch later. :)

thx Viro.

Viro, regard this :)