[PATCH] more dentry shrinkage

- d_vfs_flags can be removed - just use d_flags.  All modifications of
  dentry->d_flags are under dentry->d_lock.

On x86 this takes the internal string size up to 40 bytes.  The
internal/external ratio on my 1.5M files hits 96%.

diff --git a/fs/dcache.c b/fs/dcache.c
index 60feed2de9beea771a5c36d71c19cb32c4e80835..524e81c634d080ae62832f186824998e2e9fddd8 100644 (file)
--- a/fs/dcache.c
+++ b/fs/dcache.c
@@ -168,7 +168,7 @@ repeat:
        if (d_unhashed(dentry))
                goto kill_it;
        if (list_empty(&dentry->d_lru)) {
-               dentry->d_vfs_flags |= DCACHE_REFERENCED;
+               dentry->d_flags |= DCACHE_REFERENCED;
                list_add(&dentry->d_lru, &dentry_unused);
                dentry_stat.nr_unused++;
        }
@@ -401,8 +401,8 @@ static void prune_dcache(int count)
                        continue;
                }
                /* If the dentry was recently referenced, don't free it. */
-               if (dentry->d_vfs_flags & DCACHE_REFERENCED) {
-                       dentry->d_vfs_flags &= ~DCACHE_REFERENCED;
+               if (dentry->d_flags & DCACHE_REFERENCED) {
+                       dentry->d_flags &= ~DCACHE_REFERENCED;
                        list_add(&dentry->d_lru, &dentry_unused);
                        dentry_stat.nr_unused++;
                        spin_unlock(&dentry->d_lock);
@@ -707,9 +707,8 @@ struct dentry *d_alloc(struct dentry * parent, const struct qstr *name)
        dname[name->len] = 0;
 
        atomic_set(&dentry->d_count, 1);
-       dentry->d_vfs_flags = DCACHE_UNHASHED;
+       dentry->d_flags = DCACHE_UNHASHED;
        dentry->d_lock = SPIN_LOCK_UNLOCKED;
-       dentry->d_flags = 0;
        dentry->d_inode = NULL;
        dentry->d_parent = NULL;
        dentry->d_sb = NULL;
@@ -854,7 +853,7 @@ struct dentry * d_alloc_anon(struct inode *inode)
                        res->d_inode = inode;
                        res->d_bucket = d_hash(res, res->d_name.hash);
                        res->d_flags |= DCACHE_DISCONNECTED;
-                       res->d_vfs_flags &= ~DCACHE_UNHASHED;
+                       res->d_flags &= ~DCACHE_UNHASHED;
                        list_add(&res->d_alias, &inode->i_dentry);
                        hlist_add_head(&res->d_hash, &inode->i_sb->s_anon);
                        spin_unlock(&res->d_lock);
@@ -1117,9 +1116,10 @@ void d_delete(struct dentry * dentry)
 void d_rehash(struct dentry * entry)
 {
        struct hlist_head *list = d_hash(entry->d_parent, entry->d_name.hash);
+
        spin_lock(&dcache_lock);
        spin_lock(&entry->d_lock);
-       entry->d_vfs_flags &= ~DCACHE_UNHASHED;
+       entry->d_flags &= ~DCACHE_UNHASHED;
        spin_unlock(&entry->d_lock);
        entry->d_bucket = list;
        hlist_add_head_rcu(&entry->d_hash, list);
@@ -1217,14 +1217,14 @@ void d_move(struct dentry * dentry, struct dentry * target)
        }
 
        /* Move the dentry to the target hash queue, if on different bucket */
-       if (dentry->d_vfs_flags & DCACHE_UNHASHED)
+       if (dentry->d_flags & DCACHE_UNHASHED)
                goto already_unhashed;
        if (dentry->d_bucket != target->d_bucket) {
                hlist_del_rcu(&dentry->d_hash);
 already_unhashed:
                dentry->d_bucket = target->d_bucket;
                hlist_add_head_rcu(&dentry->d_hash, target->d_bucket);
-               dentry->d_vfs_flags &= ~DCACHE_UNHASHED;
+               dentry->d_flags &= ~DCACHE_UNHASHED;
        }
 
        /* Unhash the target: dput() will then get rid of it */

diff --git a/include/linux/dcache.h b/include/linux/dcache.h
index 7c812cd06eae3f3ca51fca7309bfc0f6cfcbc56f..2735683d6c44b165a5534574676b2c6fb5afed12 100644 (file)
--- a/include/linux/dcache.h
+++ b/include/linux/dcache.h
@@ -74,28 +74,28 @@ full_name_hash(const unsigned char *name, unsigned int len)
 }
 
 struct dcookie_struct;
- 
+
 struct dentry {
        atomic_t d_count;
+       unsigned int d_flags;           /* protected by d_lock */
        spinlock_t d_lock;              /* per dentry lock */
-       unsigned long d_vfs_flags;      /* moved here to be on same cacheline */
-       struct inode  * d_inode;        /* Where the name belongs to - NULL is negative */
+       struct inode *d_inode;          /* Where the name belongs to - NULL is
+                                        * negative */
        struct list_head d_lru;         /* LRU list */
        struct list_head d_child;       /* child of parent list */
        struct list_head d_subdirs;     /* our children */
        struct list_head d_alias;       /* inode alias list */
        unsigned long d_time;           /* used by d_revalidate */
-       struct dentry_operations  *d_op;
-       struct super_block * d_sb;      /* The root of the dentry tree */
-       unsigned int d_flags;
+       struct dentry_operations *d_op;
+       struct super_block *d_sb;       /* The root of the dentry tree */
        int d_mounted;
-       void * d_fsdata;                /* fs-specific data */
+       void *d_fsdata;                 /* fs-specific data */
        struct rcu_head d_rcu;
-       struct dcookie_struct * d_cookie; /* cookie, if any */
-       struct dentry * d_parent;       /* parent directory */
+       struct dcookie_struct *d_cookie; /* cookie, if any */
+       struct dentry *d_parent;        /* parent directory */
        struct qstr d_name;
        struct hlist_node d_hash;       /* lookup hash list */  
-       struct hlist_head * d_bucket;   /* lookup hash bucket */
+       struct hlist_head *d_bucket;    /* lookup hash bucket */
        unsigned char d_iname[0];       /* small names */
 };
 
@@ -168,8 +168,8 @@ extern spinlock_t dcache_lock;
 
 static inline void __d_drop(struct dentry *dentry)
 {
-       if (!(dentry->d_vfs_flags & DCACHE_UNHASHED)) {
-               dentry->d_vfs_flags |= DCACHE_UNHASHED;
+       if (!(dentry->d_flags & DCACHE_UNHASHED)) {
+               dentry->d_flags |= DCACHE_UNHASHED;
                hlist_del_rcu(&dentry->d_hash);
        }
 }
@@ -280,7 +280,7 @@ extern struct dentry * dget_locked(struct dentry *);
  
 static inline int d_unhashed(struct dentry *dentry)
 {
-       return (dentry->d_vfs_flags & DCACHE_UNHASHED);
+       return (dentry->d_flags & DCACHE_UNHASHED);
 }
 
 static inline struct dentry *dget_parent(struct dentry *dentry)