linux 目录缓冲,Linux文件系统(六)---三大缓冲区之 目录缓冲区dcache

在文件系统中，有三大缓冲为了提升效率：inode缓冲区、dentry缓冲区、块缓冲。

(内核：2.4.37)

为什么这个缓冲区会存在，不好意思，我说了废话，当然和前面一样的，为了提升效率，例如我们写一个.c的helloworld文件，简单的过程是编辑，编译，执行。。。那么这个过程都是需要找到所在的文件位置的，如果每次都从根开始找并且还有构造相应的目录项对象，是很费时的，所以将目录项一般也都是缓存起来的~~~

Ps：dentry结构

67structdentry {

68         atomic_t d_count;

69         unsigned intd_flags;

70         structinode  * d_inode;/* Where the name belongs to - NULL is negative */

71         structdentry * d_parent;/* parent directory */

72         structlist_head d_hash;/* lookup hash list */

73         structlist_head d_lru;/* d_count = 0 LRU list */

74         structlist_head d_child;/* child of parent list */

75         structlist_head d_subdirs;/* our children */

76         structlist_head d_alias;/* inode alias list */

77         intd_mounted;

78         structqstr d_name;

79         unsigned longd_time;/* used by d_revalidate */

80         structdentry_operations  *d_op;

81         structsuper_block * d_sb;/* The root of the dentry tree */

82         unsigned longd_vfs_flags;

83         void* d_fsdata;/* fs-specific data */

84         unsigned chard_iname[DNAME_INLINE_LEN];/* small names */

85 };

和前面的一样，这个也涉及到几个相应的链表来管理，那么看看/fs/dcache.c中哪些链表被定义了。

52staticstructlist_head *dentry_hashtable;

53 staticLIST_HEAD(dentry_unused);

哈希链表

：从中能够快速获取与给定的文件名和目录名对应的目录项对象。

“未使用”链表：所有未使用 目录项对象都存放在一个LRU的双向链表。LRU链表的首元素和尾元素的地址存放在变量dentry_unused中的next 域和prev域中。目录项对象的d_lru域包含的指针指向该链表中相邻目录的对象。

简单的看一下dcache初始化过程：

1181staticvoid__init dcache_init(unsignedlongmempages)

1182 {

1183         structlist_head *d;

1184         unsigned longorder;

1185         unsigned intnr_hash;

1186         inti;

1187

1188         /*

1189          * A constructor could be added for stable state like the lists,

1190          * but it is probably not worth it because of the cache nature

1191          * of the dcache.

1192          * If fragmentation is too bad then the SLAB_HWCACHE_ALIGN

1193          * flag could be removed here, to hint to the allocator that

1194          * it should not try to get multiple page regions.

1195          */

1196         dentry_cache = kmem_cache_create("dentry_cache",

1197                                          sizeof(structdentry),

1198                                          0,

1199                                          SLAB_HWCACHE_ALIGN,

1200                                          NULL, NULL);

1201         if(!dentry_cache)

1202                 panic("Cannot create dentry cache");

1203

1204 #ifPAGE_SHIFT 

1205         mempages >>= (13 - PAGE_SHIFT);

1206 #endif

1207         mempages *= sizeof(structlist_head);

1208         for(order = 0; ((1UL <

1209                 ;

1210

1211         do{

1212                 unsigned longtmp;

1213

1214                 nr_hash = (1UL <

1215                         sizeof(structlist_head);

1216                 d_hash_mask = (nr_hash - 1);

1217

1218                 tmp = nr_hash;

1219                 d_hash_shift = 0;

1220                 while((tmp >>= 1UL) != 0UL)

1221                         d_hash_shift++;

1222

1223                 dentry_hashtable = (structlist_head *)

1224                         __get_free_pages(GFP_ATOMIC, order);

1225         } while(dentry_hashtable == NULL && --order >= 0);

1226

1227         printk(KERN_INFO "Dentry cache hash table entries: %d (order: %ld, %ld bytes)\n",

1228                         nr_hash, order, (PAGE_SIZE <

1229

1230         if(!dentry_hashtable)

1231                 panic("Failed to allocate dcache hash table\n");

1232

1233         d = dentry_hashtable;

1234         i = nr_hash;

1235         do{

1236                 INIT_LIST_HEAD(d);

1237                 d++;

1238                 i--;

1239         } while(i);

1240 }

上面代码就是相当于分配cache空间，并将hash表什么的都初始化了~~~

下面看一下怎么分配一个目录项对象，涉及函数d_alloc：

580/**

581  * d_alloc      -       allocate a dcache entry

582  * @parent: parent of entry to allocate

583  * @name: qstr of the name

584  *

585  * Allocates a dentry. It returns %NULL if there is insufficient memory

586  * available. On a success the dentry is returned. The name passed in is

587  * copied and the copy passed in may be reused after this call.

588  */

589

590 structdentry * d_alloc(structdentry * parent,conststructqstr *name)

591 {

592         char* str;

593         structdentry *dentry;

594

595         dentry = kmem_cache_alloc(dentry_cache, GFP_KERNEL);   /* 分配一个dentry空间 */

596         if(!dentry)

597                 returnNULL;

598

599         if(name->len > DNAME_INLINE_LEN-1) {

600                 str = kmalloc(NAME_ALLOC_LEN(name->len), GFP_KERNEL);

601                 if(!str) {

602                         kmem_cache_free(dentry_cache, dentry);

603                         returnNULL;

604                 }

605         } else

606                 str = dentry->d_iname;

607         /* 复制name */

608         memcpy(str, name->name, name->len);

609         str[name->len] = 0;

610         /* 下面根据dentr的字段进行赋值，具体的字段意义见：http://blog.csdn.net/shanshanpt/article/details/38943731 */

611         atomic_set(&dentry->d_count, 1);

612         dentry->d_vfs_flags = 0;

613         dentry->d_flags = 0;

614         dentry->d_inode = NULL;

615         dentry->d_parent = NULL;

616         dentry->d_sb = NULL;

617         dentry->d_name.name = str;

618         dentry->d_name.len = name->len;

619         dentry->d_name.hash = name->hash;

620         dentry->d_op = NULL;

621         dentry->d_fsdata = NULL;

622         dentry->d_mounted = 0;

623         INIT_LIST_HEAD(&dentry->d_hash);

624         INIT_LIST_HEAD(&dentry->d_lru);

625         INIT_LIST_HEAD(&dentry->d_subdirs);

626         INIT_LIST_HEAD(&dentry->d_alias);

627         if(parent) {

628                 dentry->d_parent = dget(parent);

629                 dentry->d_sb = parent->d_sb;

630         } else

631                 INIT_LIST_HEAD(&dentry->d_child);

632

633         spin_lock(&dcache_lock);

634         if(parent)

635                 list_add(&dentry->d_child, &parent->d_subdirs);

636         dentry_stat.nr_dentry++;

637         spin_unlock(&dcache_lock);

638

639         returndentry;

640 }

641

下面看看怎么去寻找一个目录，涉及函数d_lookup：

698/**

699  * d_lookup - search for a dentry

700  * @parent: parent dentry

701  * @name: qstr of name we wish to find

702  *

703  * Searches the children of the parent dentry for the name in question. If

704  * the dentry is found its reference count is incremented and the dentry

705  * is returned. The caller must use d_put to free the entry when it has

706  * finished using it. %NULL is returned on failure.

707  */

708

709 structdentry * d_lookup(structdentry * parent,structqstr * name)

710 {

711         unsigned intlen = name->len;

712         unsigned inthash = name->hash;

713         constunsignedchar*str = name->name;

714         structlist_head *head = d_hash(parent,hash);/* 通过hash值计算得到目录项缓冲区位置的head */

715         structlist_head *tmp;

716

717         spin_lock(&dcache_lock);

718         tmp = head->next;

719         for(;;) {/* 下面循环找到对应的dentry */

720                 structdentry * dentry = list_entry(tmp,structdentry, d_hash);

721                 if(tmp == head)

722                         break;

723                 tmp = tmp->next;

724                 if(dentry->d_name.hash != hash)

725                         continue;

726                 if(dentry->d_parent != parent)

727                         continue;

728                 if(parent->d_op && parent->d_op->d_compare) {

729                         if(parent->d_op->d_compare(parent, &dentry->d_name, name))

730                                 continue;

731                 } else{

732                         if(dentry->d_name.len != len)

733                                 continue;

734                         if(memcmp(dentry->d_name.name, str, len))

735                                 continue;

736                 }

737                 __dget_locked(dentry);

738                 dentry->d_vfs_flags |= DCACHE_REFERENCED;   /* 找到，那么添加引用就OK */

739                 spin_unlock(&dcache_lock);

740                 returndentry;/* 返回找到的dentry。里面有我们需要的信息例如inode */

741         }

742         spin_unlock(&dcache_lock);

743         returnNULL;

744 }

其他的代码暂时就不看了，以后总结。。。