linux 内核目录项高速缓存 dentry cache 简介

柔情只为你懂 2021-07-28 14:57 668阅读 0赞

每个dentry对象都属于下列几种状态之一：

（1）未使用（unused）状态：该dentry对象的引用计数d\_count的值为0，但其d\_inode指针仍然指向相关的的索引节点。该目录项仍然包含有效的信息，只是当前没有人引用他。这种dentry对象在回收内存时可能会被释放。

（2）正在使用（inuse）状态：处于该状态下的dentry对象的引用计数d\_count大于0，且其d\_inode指向相关的inode对象。这种dentry对象不能被释放。

（3）负（negative）状态：与目录项相关的inode对象不复存在（相应的磁盘索引节点可能已经被删除），dentry对象的d\_inode指针为NULL。但这种dentry对象仍然保存在dcache中，以便后续对同一文件名的查找能够快速完成。这种dentry对象在回收内存时将首先被释放。

Linux为了提高目录项对象的处理效率，设计与实现了目录项高速缓存（dentry cache，简称dcache），它主要由两个数据结构组成：

1. 哈希链表dentry\_hashtable：dcache中的所有dentry对象都通过d\_hash指针域链到相应的dentry哈希链表中。

2. 未使用的dentry对象链表dentry\_unused：dcache中所有处于“unused”状态和“negative”状态的dentry对象都通过其d\_lru指针域链入dentry\_unused链表中。该链表也称为LRU链表。

目录项高速缓存dcache是索引节点缓存icache的主控器（master），也即dcache中的dentry对象控制着icache中的inode对象的生命期转换。无论何时，只要一个目录项对象存在于dcache中（非 negative状态），则相应的inode就将总是存在，因为inode的引用计数i\_count总是大于0。当dcache中的一个dentry被释放时，针对相应inode对象的iput()方法就会被调用。

struct dentry
    {
        atomic_t	  d_count;
        unsigned int  d_flags;/* protected by d_lock */
        spinlock_t	  d_lock;/* per dentry lock */
        struct inode *d_inode;/* Where the name belongs to - NULL is * negative */
    
        /*
            * The next three fields are touched by __d_lookup.  Place them here
            * so they all fit in a cache line.
            */
        struct hlist_node d_hash; /* lookup hash list */
        struct dentry *	  d_parent; /* parent directory */
        struct qstr		  d_name;//contain the name,length,hash value of this dentry
         
        struct list_head d_lru;/* LRU list */
    
        /*
            * d_child and d_rcu can share memory
            */
        union
        {
             struct list_head d_child; /* child of parent list */
              struct rcu_head d_rcu;
        }				 d_u;
        struct list_head d_subdirs; /* our children ,all the children are linked together*/
        struct list_head d_alias;
                                /* inode alias list ,list of all the dentry share the same inode*/
        unsigned long			  d_time;/* used by d_revalidate */
        struct dentry_operations *d_op;
        struct super_block *	  d_sb;
                                /* The root of the dentry tree */
        void *d_fsdata; /* fs-specific data */
    #ifdef CONFIG_PROFILING
        struct dcookie_struct *d_cookie; /* cookie, if any */
    #endif
        int			  d_mounted;
        unsigned char d_iname[DNAME_INLINE_LEN_MIN]; /* small names */
    };

1.1 分配接口

dcache在kmem\_cache\_alloc（）的基础上定义两个高层分配接口：d\_alloc()函数和d\_alloc\_root()函数，用来从dentry\_cache slab分配器缓存中为一般的目录项和根目录分配一个dentry对象。

Dentry本身是一个树形结构，d\_alloc和d\_alloc\_root用于build这棵树：

struct dentry *d_alloc(struct dentry * parent, const struct qstr *name)

函数d\_alloc\_root（）用来为fs的根目录（并不一定是系统全局文件系统的根“／”）分配dentry对象。它以根目录的inode对象指针为参数，如下所示：

struct dentry * d_alloc_root(struct inode * root_inode)
    {
        struct dentry *res = NULL;
    
        if (root_inode)
        {
            static const struct qstr name = { .name = "/", .len = 1 };
            res = d_alloc(NULL, &name);
            if (res)
            {
                res->d_sb = root_inode->i_sb;
    
                /*
                   将所分配的dentry对象的d_parent指针设置为指向自身。
                   NOTE！这一点是判断一个dentry对象是否是一个fs的根目录的唯一准则
                   （include／linux／dcache.h）：＃define IS_ROOT（x）（（x）＝＝（x）－>d_parent）
                 */
                res->d_parent = res;
                d_instantiate(res, root_inode);
            }
        }
    
        return res;
    }

函数d\_instantiate用于向dentry结构中填写inode信息，因此该函数会将一个dentry对象从negative状态转变为inuse状态。如下所示：

void d_instantiate(struct dentry *entry, struct inode * inode)
    {
        spin_lock(&dcache_lock);
    
        if (inode)
        {
            list_add(&entry->d_alias, &inode->i_dentry);
        }
    
        entry->d_inode = inode;
    
        spin_unlock(&dcache_lock);
    }

NOTE! 函数d\_instantiate（）假定在被调用之前，调用者已经增加了inode的引用计数。

struct dentry *d_alloc_name(struct dentry *parent, const char *name)
    {
        struct qstr q;
         
        q.name = name;
    
        q.len  = strlen(name);
        q.hash = full_name_hash(q.name, q.len);
        return d_alloc(parent, &q);
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3doYXRkYXk_size_16_color_FFFFFF_t_70][]

1.2 释放接口

目录项缓存dcache定义了两个高层释放接口：d\_free()函数和 dentry\_iput()函数。其中，d\_free函数用来将dcache中不使用的dentry对象释放回dentry\_cache slab分配器缓存；而dentry\_iput（）函数则用来释放一个dentry对象对一个inode对象的引用关联。

函数d\_free()首先调用dentry对象操作方法中的d\_release （）函数（如果定义了的话），通常在d\_release()函数中释放dentry->fsdata数据。然后，用dname\_external （）函数判断是否已经为目录项名字d\_name分配了内存，如果是，则调用kfree（）函数释放d\_name所占用的内存。接下来，调用 kmem\_cache\_free()函数释放这个dentry对象。最后，修改dcache统计信息中的dentry对象总数（减1）。其源码如下：

D\_free和\_\_d\_free主要用于Dentry内存释放

/*
        * no dcache_lock, please.  The caller must decrement dentry_stat.nr_dentry
        * inside dcache_lock.
        */
    static void d_free(struct dentry *dentry)
    {
        if (dentry->d_op && dentry->d_op->d_release)
        {
            dentry->d_op->d_release(dentry);//主要用于释放dentry->fsdata数据
        }
    
        /* if dentry was never inserted into hash, immediate free is OK */
        if (hlist_unhashed(&dentry->d_hash))
        {
            __d_free(dentry);
        }
        else
        {
            call_rcu(&dentry->d_u.d_rcu, d_callback);
        }
    }
    
    static void __d_free(struct dentry *dentry)
    {
        WARN_ON(!list_empty(&dentry->d_alias));
        if (dname_external(dentry))//判断是否为d_name分配了内存
        {
            kfree(dentry->d_name.name);
        }
    
        kmem_cache_free(dentry_cache, dentry);
    }

而dentry\_iput（）函数则主要用于在调用d\_free()函数释放一个 dentry对象之前，释放该dentry对象与相应inode对象的关联，从而将一个dentry对象转变为negative状态。主要包括如下几项任务：

（1）将这个dentry对象从相应inode对象的别名链表i\_dentry中摘除；

（2）解除自旋锁dcache\_lock；

（3）调用 dentry的操作方法d\_iput()函数（如果有的话），或者iput()方法。

该函数与d\_instantiate（）函数是相反的，如下：

/*
        * Release the dentry's inode, using the filesystem
        * d_iput() operation if defined.
        */
    static void dentry_iput(struct dentry * dentry)//0401
    __releases(dentry->d_lock)
    __releases(dcache_lock)
    {
        struct inode *inode = dentry->d_inode;
    
        if (inode)
        {
            dentry->d_inode = NULL;
            list_del_init(&dentry->d_alias);
            spin_unlock(&dentry->d_lock);
            spin_unlock(&dcache_lock);
            if (!inode->i_nlink)
            {
                fsnotify_inoderemove(inode);
            }
    
            if (dentry->d_op && dentry->d_op->d_iput)
            {
                dentry->d_op->d_iput(dentry, inode);
            }
            else
            {
                iput(inode);
            }
        }
        else
        {
            spin_unlock(&dentry->d_lock);
            spin_unlock(&dcache_lock);
        }
    }

NOTE：

（1）如果定义了dentry方法d\_iput()，则dentry\_iput()通过调用d\_iput()方法来释放inode对象，否则就通过iput()来释放inode对象。

（2）dentry\_iput（）函数假定被调用时调用者已经持有了dcache\_lock锁。因此它在返回之前对该自旋锁进行解锁。

2 dcache数据结构

Linux通过在dentry\_cache slab分配器缓存上定义了各种dentry链表来有效地管理目录项对象，从而实现dcache机制。它们包括：

1. dentry对象的哈希链表dentry\_hashtable。

2. dentry对象的LRU链表dentry\_unused。

3. 每个索引节点对象的别名链表i\_dentry。每个非negative状态的dentry对象都通过d\_alias指针域链入其对应的inode对象的别名链表i\_dentry中。

4. 父目录dentry对象的子目录项（目录或文件）链表d\_subdirs。每个dentry对象都通过d\_child指针域链入其父目录dentry对象的子目录项链表d\_subdirs中。

2.1 哈希链表dentry\_hashtable

Dentry\_hashtable的初始化是在dcache\_init\_early或者dcache\_init中实现的：

static void __init dcache_init_early(void)
    {
        int loop;
    
        /* If hashes are distributed across NUMA nodes, defer
            * hash allocation until vmalloc space is available.
            */
        if (hashdist)
        {
            return;
        }
    
        dentry_hashtable =
            alloc_large_system_hash("Dentry cache",
                                    sizeof(struct hlist_head),
                                    dhash_entries,
                                    13,
                                    HASH_EARLY,
                                    &d_hash_shift,
                                    &d_hash_mask,
                                    0);
        for (loop = 0; loop < (1 << d_hash_shift); loop++)
        {
            INIT_HLIST_HEAD(&dentry_hashtable[loop]);
        }
    }
    
    static void __init dcache_init(void)
    {
        int loop;
    
        /*
            * A constructor could be added for stable state like the lists,
            * but it is probably not worth it because of the cache nature
            * of the dcache.
            */
        dentry_cache = KMEM_CACHE(dentry,
                                  SLAB_RECLAIM_ACCOUNT | SLAB_PANIC | SLAB_MEM_SPREAD);
        register_shrinker(&dcache_shrinker);
    
        /* Hash may have been set up in dcache_init_early */
        if (!hashdist)
        {
            return;
        }
    
        dentry_hashtable =
            alloc_large_system_hash("Dentry cache",
                                    sizeof(struct hlist_head),
                                    dhash_entries,
                                    13,
                                    0,
                                    &d_hash_shift,
                                    &d_hash_mask,
                                    0);
        for (loop = 0; loop < (1 << d_hash_shift); loop++)
        {
            INIT_HLIST_HEAD(&dentry_hashtable[loop]);
        }
    }

每一个dentry对象都通过其父目录dentry对象的指针和其文件名的哈希值hash来唯一地确定它所属的哈希链表的表头指针，这是通过d\_hash函数来完成的：

static inline struct hlist_head *d_hash(struct dentry *parent, unsigned long hash)
    {
        hash += ((unsigned long) parent ^ GOLDEN_RATIO_PRIME) / L1_CACHE_BYTES;
        hash  = hash ^ ((hash ^ GOLDEN_RATIO_PRIME) >> D_HASHBITS);
        return dentry_hashtable + (hash & D_HASHMASK);
    }

每个目录项文件名的哈希值是通过full\_name\_hash()函数（定义在include/linux/dcache.h文件中）来计算的，如下所示：

/* Compute the hash for a name string. */
    static inline unsigned int full_name_hash(const unsigned char *name, unsigned int len)
    {
        unsigned long hash = init_name_hash();
    
        while (len--)
        {
            hash = partial_name_hash(*name++, hash);
        }
    
        return end_name_hash(hash);
    }

2.2 dentry对象的LRU链表

对于那些处于“未使用”状态的dentry对象来说，它们被再次访问的可能性很大。因此，不能将它们立即丢弃，而必须将它们在dcache中保留一段时间。为此，Linux通过LRU链表来有效地管理这些未使用的dentry对象。每一个处于unused状态下的dentry通过其d\_lru指针域链入系统全局的LRU链表，表头包含在super\_block::s\_dentry\_lru中。

从某种程度上讲，super\_block::s\_dentry\_lru链表就是处于inuse状态下的dentry对象的直接缓存。当一个dentry不再被使用时，它首先应被移到LRU链表中，而不是直接将其丢弃，因为该dentry对象很可能会再次被引用。

另一方面，由于super\_block::s\_dentry\_lru链表中的目录项对象是未使用的，因此当内存紧张时，应该将其中一些很长时间内未被使用的dentry对象释放掉，以缓解系统的压力。

2.3 dcache链表的保护锁

Linux在dcache.c文件中定义了自旋锁dcache\_lock，来实现对dcache链表的互斥访问。也即，任何一段想要访问任何一条dcache链表的代码段，都必须首先持有该自旋锁。其定义如下：

spinlock_t dcache_lock = SPIN_LOCK_UNLOCKED;

2.4 dcache统计信息

Linux在dcache.c文件中定义了全局变量dentry\_stat来表示dcache的统计信息，如下：

struct dentry_stat_t {
           int nr_dentry;
           int nr_unused;
           int age_limit;/* age in seconds */
           int want_pages;/* pages requested by system */
           int dummy[2];
    };
    extern struct dentry_stat_t dentry_stat;

3 dentry访问接口——dget／dput函数

要引用dcache中的任何一个dentry对象，都必须通过应用接口函数dget()或dget\_locked()来进行；然后在使用完这个dentry对象后，通过释放引用接口dput()函数来释放对它的引用。

3.1 引用接口

引用函数dget()仅仅简单地增加dentry对象的引用计数器，如下所示（dcache.h）：

static inline struct dentry *dget(struct dentry *dentry)
    {
        if (dentry)
        {
            /*这里可知，对于dentry引用计数为0的dentry决不能使用dget，而应使用dget_locked。
               因为：引用一个d_count＝0的dentry对象，将使该dentry对象从unused状态转变为inuse状态，
               该dentry状态也必须从LRU链表中脱离，而在操作dcache链表时是必须先持有自旋锁dcache_lock的。
               函数dget()并不对调用者由任何调用假设，
               相反，dget_locked()函数则假定调用者在调用它之前已经持有自旋锁dentry_lock。
             */
            BUG_ON(!atomic_read(&dentry->d_count));
            atomic_inc(&dentry->d_count);
        }
    
        return dentry;
    }
    
    /* This should be called _only_ with dcache_lock held */
    static inline struct dentry * __dget_locked(struct dentry *dentry)
    {
        atomic_inc(&dentry->d_count);
        dentry_lru_del_init(dentry);
        return dentry;
    }
    
    struct dentry * dget_locked(struct dentry *dentry)
    {
        return __dget_locked(dentry);
    }

3.2 释放接口dput

函数dput()用于释放对一个dentry对象的引用。该函数的核心就是将 dentry对象的引用计数d\_count减1。如果d\_count减1后还不为0，则dput直接返回即可；否则就将该dentry对象放到LRU链表中，或直接释放掉（在该dentry对象未链入哈希链表的情况下）。其源码如下：

/* This is dput
        *
        * This is complicated by the fact that we do not want to put
        * dentries that are no longer on any hash chain on the unused
        * list: we'd much rather just get rid of them immediately.
        *
        * However, that implies that we have to traverse the dentry
        * tree upwards to the parents which might _also_ now be
        * scheduled for deletion (it may have been only waiting for
        * its last child to go away).
        *
        * This tail recursion is done by hand as we don't want to depend
        * on the compiler to always get this right (gcc generally doesn't).
        * Real recursion would eat up our stack space.
        */
     
    
    /*
        * dput - release a dentry
        * @dentry: dentry to release
        *
        * Release a dentry. This will drop the usage count and if appropriate
        * call the dentry unlink method as well as removing it from the queues and
        * releasing its resources. If the parent dentries were scheduled for release
        * they too may now get deleted.
        *
        * no dcache lock, please.
        */
    void dput(struct dentry *dentry)//d_put函数有点麻烦
    {
        if (!dentry)
        {
            return;
        }
    
         
    repeat:
        if (atomic_read(&dentry->d_count) == 1)
        {
            might_sleep();
        }
    
        if (!atomic_dec_and_lock(&dentry->d_count, &dcache_lock))
        {
            return;
        }
    
         
        spin_lock(&dentry->d_lock);
        if (atomic_read(&dentry->d_count))
        {
            spin_unlock(&dentry->d_lock);
            spin_unlock(&dcache_lock);
            return;
        }
    
         
    
        /*
            * AV: ->d_delete() is _NOT_ allowed to block now.
            */
        if (dentry->d_op && dentry->d_op->d_delete)
        {
            if (dentry->d_op->d_delete(dentry))//返回值非0（执行出错）
            {
                goto unhash_it;
            }
        }
    
        /* Unreachable? Get rid of it */
        if (d_unhashed(dentry))//不在hash表中
        {
            goto kill_it;
        }
    
        if (list_empty(&dentry->d_lru))//在hash链表中，则将其移植到lru链表的首部
        {
            dentry->d_flags |= DCACHE_REFERENCED;
            dentry_lru_add(dentry);
                 
        }
    
        spin_unlock(&dentry->d_lock);
        spin_unlock(&dcache_lock);
        return;
         
    unhash_it:
        __d_drop(dentry);//unhash from the dentry hash
    kill_it:
    
        /* if dentry was on the d_lru list delete it from there */
        dentry_lru_del(dentry);//delete from the d_lru list
        dentry = d_kill(dentry);//kill the dentry and return the parent（如果dentry->d_parent指向自身，则代表fs的根目录，于是d_kill返回NULL）
        if (dentry)//对parent进行递归处理
        {
            goto repeat;
        }
    }
    
    /**
        * d_kill - kill dentry and return parent
        * @dentry: dentry to kill
        *
        * The dentry must already be unhashed and removed from the LRU.
        * If this is the root of the dentry tree, return NULL.
        */
    static struct dentry *d_kill(struct dentry *dentry)
    __releases(dentry->d_lock)
    __releases(dcache_lock)
    {
        struct dentry *parent;
    
         
        list_del(&dentry->d_u.d_child);//从parent的children list中删除
        dentry_stat.nr_dentry--; /* For d_free, below */
        /*drops the locks, at that point nobody can reach this dentry */
        dentry_iput(dentry);//release the dentry's inode
        if (IS_ROOT(dentry))//判断是否满足dentry->d_parent=dentry
        {
            parent = NULL;
        }
        else
        {
            parent = dentry->d_parent;
        }
    
        d_free(dentry);//释放占用的内存空间给dentry cache slab
        return parent;
    }

4 对哈希链表的操作

（1）向哈希链表中增加一个dentry对象

函数d\_rehash()实现这一功能，它首先通过d\_hash()函数找到这个dentry对象应该挂到哪一个哈希链表中，然后设置d\_hash指针。如下所示（dcache.c）：

void d_rehash(struct dentry * entry)
    {
         spin_lock(&dcache_lock);
         spin_lock(&entry->d_lock);
         _d_rehash(entry);
         spin_unlock(&entry->d_lock);
         spin_unlock(&dcache_lock);
    }
    
    static void _d_rehash(struct dentry * entry)
    {
         __d_rehash(entry, d_hash(entry->d_parent, entry->d_name.hash));
    }
    
    static void __d_rehash(struct dentry * entry, struct hlist_head *list)
    {
        entry->d_flags &= ~DCACHE_UNHASHED;
        hlist_add_head_rcu(&entry->d_hash, list);
    }
    
    static inline struct hlist_head *d_hash(struct dentry *parent, unsigned long hash)
    {
         hash += ((unsigned long) parent ^ GOLDEN_RATIO_PRIME) / L1_CACHE_BYTES;
         hash  = hash ^ ((hash ^ GOLDEN_RATIO_PRIME) >> D_HASHBITS);
         return dentry_hashtable + (hash & D_HASHMASK);
    }

（2）从哈希链表中摘除一个dentry对象

函数d\_drop（）实现这一点，如下所示（dcache.h）：

D\_drop，\_\_d\_drop主要将dentry从相应hash中摘除，VFS lookup将不会找到该dentry：

/**
        * d_drop - drop a dentry
        * @dentry: dentry to drop
        *
        * d_drop() unhashes the entry from the parent dentry hashes, so that it won't
        * be found through a VFS lookup any more. Note that this is different from
        * deleting the dentry - d_delete will try to mark the dentry negative if
        * possible, giving a successful _negative_ lookup, while d_drop will
        * just make the cache lookup fail.
        *
        * d_drop() is used mainly for stuff that wants to invalidate a dentry for some
        * reason (NFS timeouts or autofs deletes).
        *
        * __d_drop requires dentry->d_lock.
        */
    static inline void __d_drop(struct dentry *dentry)//0401
    {
        if (!(dentry->d_flags & DCACHE_UNHASHED))
        {
            dentry->d_flags |= DCACHE_UNHASHED;
            hlist_del_rcu(&dentry->d_hash);//hlist_del_rcu
        }
    }
    
    static inline void d_drop(struct dentry *dentry)//0401
    {
        spin_lock(&dcache_lock);
        spin_lock(&dentry->d_lock); 
              __d_drop(dentry);
        spin_unlock(&dentry->d_lock);
        spin_unlock(&dcache_lock);
    }

头文件dcache.h中还定义了一个函数d\_unhashed()，用来测试一个dentry对象是否没有链接在哈希链表中，如下：

static inline int d_unhashed(struct dentry *dentry)
    {
        return (dentry->d_flags & DCACHE_UNHASHED);
    }

5 对LRU链表的管理与操作

对LRU链表dentry\_unused的管理和维护主要体现在两点上：

（1）当哈希链表中的一个dentry对象从inuse状态转变为unused状态时，应该将他插入到LRU链表的首部，具体请参见dput()函数的实现。

（2）当系统内存紧张时，应该释放LRU链表中的一些dentry对象，且通常是释放LRU链表尾部的dentry对象（因为它们是最近最少使用的）。但是也可以根据指定条件释放LRU中特定的dentry对象，因此在这之前要做一个挑选过程，并由这一过程将所选中的dentry对象移到dentry\_unused链表的尾部。这一机制也称为dcache的压缩（shrink）机制。

下面将详细分析dcache的shrink机制实现。

5.1 prune\_one\_dentry()函数

该函数实现从LRU链表中释放一个指定的dentry对象。这是一个静态的内部函数，它通常被别的函数调用。NOTE! Prune\_one\_dentry()函数假定被调用之前，调用者已经将dentry对象从LRU链表中摘除，并且持有自旋锁dcache\_lock。因此，它所要做的事情就是：

①将这个dentry对象从哈希链表中摘除；

②将这个dentry对象从其父目录对象的d\_subdirs链表中摘除；

③用 dentry\_iput()函数释放对相应inode对象的引用；

④用d\_free()释放这个dentry对象；

⑤对父目录dentry对象做一次 dput操作。

static void prune_one_dentry(struct dentry * dentry)

5.2 prune\_dcache()函数

该函数用于实现从LRU链表的尾部开始倒序释放指定个数的dentry对象。它从尾部开始扫描LRU链表，如果被扫描的dentry对象设置了DCACHE\_REFERENCED标志，则让其继续留在LRU链表中，否则就将其从LRU链表中摘除，然后调用prune\_one\_dentry()函数释放该dentry对象。

/*Shrink the dcache. This is done when we need more memory, or simply when we
         need to unmount something (at which point we need to unuse all dentries).*/
    static void prune_dcache(int count)
    {
        spin_lock(&dcache_lock);
        spin_lock(&sb_lock);
        list_for_each_entry(sb, &super_blocks, s_list)//针对每一个super_block
        {
            if (sb->s_nr_dentry_unused == 0)//# of dentries on lru
            {
                continue;
            }
    
            //。。。。。。
            __shrink_dcache_sb(sb, &w_count, DCACHE_REFERENCED);//针对当前sb执行
            //。。。。。。
             
            spin_unlock(&sb_lock);
            spin_unlock(&dcache_lock);
                    
        }
         
        /*Shrink the dentry LRU on a given superblock.*/
        static void __shrink_dcache_sb(struct super_block *sb, int *count, int flags)
        {
            //。。。。。。
            prune_one_dentry(dentry);/*Throw away a dentry - free the inode, dput the parent.  This requires that the LRU list has already been removed.*/
    
            //。。。。。。
        }
    }

上述两个函数prune\_one\_dentry()和prune\_dcache（）是dcache的shrink机制的实现基础。在此基础上，Linux实现了根据指定条件压缩dcache的高层接口函数：

①shink\_dcache\_sb()——根据指定的超级块对象，压缩dcache；

②shrink\_dcache\_parent()——根据指定的父目录dentry对象，压缩dcache；

③shrink\_dcache\_memory()——根据优先级压缩dcache。

5.3 shrink\_dcache\_sb()函数

该函数释放dcache的LRU链表中属于某个特定超级块对象的dentry对象。该函数的实现过程主要是两次遍历dentry\_unused链表：

①第一次遍历过程将属于指定超级块对象的dentry对象移到dentry\_unused链表的首部。

②第二次遍历则将属于指定超级块对象、且d\_count＝0的dentry对象释放掉（通过prune\_one\_dentry函数）。

void shrink_dcache_sb(struct super_block * sb)
    {
        __shrink_dcache_sb(sb, NULL, 0);//见5.2
    }

5.4 shrink\_dcache\_parent()函数

该函数释放LRU链表中属于给定父目录对象的子dentry对象。实现源码如下：

void shrink_dcache_parent(struct dentry * parent)
    {
        struct super_block *sb = parent->d_sb;
        int found;
    
        while ((found = select_parent(parent)) != 0)
        {
            __shrink_dcache_sb(sb, &found, 0);
        }
    }

可以看出，shrink\_dcache\_parent()函数首先通过调用 select\_parent()函数来从LRU链表中查找父目录parent的子目录对象，并将这些子dentry对象移到LRU链表的尾部，并返回所找到的子dentry对象的个数（这一步是为调用prune\_dcache()函数做准备的）；然后，调用prune\_dcache()函数将LRU链表尾部的子dentry对象释放掉。  
函数select\_parent()是在dcache.c中实现的内部函数，他根据给定的参数parent，在LRU链表中查找父目录parent的子目录对象，并将这些子dentry对象移到LRU链表的尾部，并返回所找到的子dentry对象的个数。

5.5 shringk\_dcache\_memory()函数

当我们需要内存，但又不知道具体需要多少时，就可以调用这个函数来压缩dcache所占用的内存。该函数通常被kswapd守护进程所调用。

优先级参数priority值越大（优先级越低），表明对内存的需要就越不迫切。因此prune\_dcache（）函数释放的dentry对象个数就越少。

6 对dentry对象的VFS操作接口

VFS实现了几个对dcache中的dentry对象的操作函数，下面我们列举一些：

1. d\_invalidate()——使一个dcache中的dentry对象无效。该函数的核心就是要将指定的dentry对象从哈希链表中摘除。

2. d\_find\_alias()——为指定inode对象找到一个位于哈希链表中的、且在该索引节点的别名链表i\_dentry中的dentry对象。

3. d\_prune\_aliases()——释放指定inode对象的别名链表i\_dentry中未使用的dentry对象。

4. have\_submounts()——查看在参数parent指定的部分目录树中是否至少有一个安装点。

5. d\_lookup()——在参数parent指定的父目录中查找名字为name的目录项。

6. d\_validate()——验证一个dentry对象的有效性。

7. d\_delete()——删除一个dentry对象。实际上是将这个dentry对象转变为negative状态或unused状态。

8. d\_move()——移动一个dentry对象。

9. \_\_d\_path()——得到一个dentry对象的全路径名。

10. is\_subdir()——判断一个dentry对象是否是另一个dentry对象的子孙。

11. find\_inode\_number()——在父目录dir中，查找是否存在参数name指定的名字的目录项，并返回对应inode的索引节点。

7 小结

由于dentry是一种纯软件数据结构，不存在对应的磁盘数据。因此，与icache机制和buffer cache机制不同，dcache中没有如何同步一个dentry对象的机制。

/*
        * When a file is deleted, we have two options:
        * - turn this dentry into a negative dentry
        * - unhash this dentry and free it.
        *
        * Usually, we want to just turn this into
        * a negative dentry, but if anybody else is
        * currently using the dentry or the inode
        * we can't do that and we fall back on removing
        * it from the hash queues and waiting for
        * it to be deleted later when it has no users
        */
     
    
    /**
        * d_delete - delete a dentry
        * @dentry: The dentry to delete
        *
        * Turn the dentry into a negative dentry if possible, otherwise
        * remove it from the hash queues so it can be deleted later
        */
    void d_delete(struct dentry * dentry)//0401
    {
        int isdir = 0;
    
        /*
            * Are we the only user?
            */
        spin_lock(&dcache_lock);
        spin_lock(&dentry->d_lock);
        isdir = S_ISDIR(dentry->d_inode->i_mode);
        if (atomic_read(&dentry->d_count) == 1)//该情况下,turn the dentry into a negtive dentry
        {
            dentry_iput(dentry);//下面分析
            fsnotify_nameremove(dentry, isdir);
            return;
        }
    
        if (!d_unhashed(dentry))//others used the dentry or inode currently,so just unhash it and waiting for it to be deleted later when no users
        {
            __d_drop(dentry);
        }
    
        spin_unlock(&dentry->d_lock);
        spin_unlock(&dcache_lock); 
         
        fsnotify_nameremove(dentry, isdir);
    }

这里最后给出一个图，表明dentry 和mnt 所组成的一幅全景图，并且还是一个dentry下面安装多个文件系统的例子：体会下  
上面的这句话：  
/\*从一个dentry需找其父节点的时候,要知道mnt才能在这其中做出选择, 从follow\_dot\_dot我们能学到这个。。。\*/

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3doYXRkYXk_size_16_color_FFFFFF_t_70 1][]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3doYXRkYXk_size_16_color_FFFFFF_t_70]: /images/20210728/2d995eb171374ba9bf2fa98f584e7730.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3doYXRkYXk_size_16_color_FFFFFF_t_70 1]: /images/20210728/7bc7f4d9391642689245b5653a8e6f68.png