Linux内核中常用的数据结构和算法
Linux内核代码中普遍使用了数据结构和算法，其中最常用的两个是链表和红黑树。
链表
Linux内核代码大宗使用了链表这种数据结构。链表是在解决数组不可动态扩展这个缺陷而爆发的一种数据结构。链表所包括的元素可以动态建设并插入和删除。链表的每个元素都是离散存放的，因此不需要占用一连的内存。链表通常由若干节点组成，每个节点的结构都是一样的，由有用数据区和指针区两部分组成。有用数据区用来存储有用数据信息，而指针区用来指向链表的前继节点或者后继节点。因此，链表就是使用指针将各个节点串联起来的一种存储结构。
（1）单向链表
单向链表的指针区只包括一个指向下一个节点的指针，因此会形成一个简单偏向的链表，如下代码所示。
struct list {
int data; /*有用数据*/
struct list *next; /*指向下一个元素的指针*/
};
登录后复制
如图所示，单向链表具有单向移动性，也就是只能会见目今的节点的后继节点，而无法会见目今节点的前继节点，因此在现实项目中运用得较量少。
单向链体现意图
（2）双向链表
如图所示，双向链表和单向链表的区别是指针区包括了两个指针，一个指向前继节点，另一个指向后继节点，如下代码所示。
struct list {
int data; /*有用数据*/
struct list *next; /*指向下一个元素的指针*/
struct list *prev; /*指向上一个元素的指针*/
};
登录后复制
双向链体现意图
（3）Linux内核链表实现
单向链表和双向链表在现实使用中有一些局限性，如数据区必需是牢靠数据，而现实需求是多种多样的。这种要领无法构建一套通用的链表，由于每个差别的数据区需要一套链表。为此，Linux内核把所有链表操作要领的配合部分提取出来，把差别的部分留给代码编程者自己行止置。Linux内核实现了一套纯链表的封装，链表节点数据结构只有指针区而没有数据区，另外还封装了州操作函数，如建设节点函数、插入节点函数、删除节点函数、遍历节点函数等。
Linux内核链表使用struct list_head数据结构来形貌。
<include/linux/types.h>
struct list_head {
struct list_head *next, *prev;
};
登录后复制
struct list_head数据结构不包括链表节点的数据区，通常是嵌入其他数据结构，如struct page数据结构中嵌入了一个lru链表节点，通常是把page数据结构挂入LRU链表。
<include/linux/mm_types.h>
struct page {
...
struct list_head lru;
...
}
登录后复制
链表头的初始化有两种要领，一种是静态初始化，另一种动态初始化。
把next和prev指针都初始化并指向自己，这样便初始化了一个带动节点的空链表。
<include/linux/list.h>
/*静态初始化*/
#define LIST_HEAD_INIT(name) { &(name), &(name) }
#define LIST_HEAD(name) \
struct list_head name = LIST_HEAD_INIT(name)
/*动态初始化*/
static inline void INIT_LIST_HEAD(struct list_head *list)
{
list->next = list;
list->prev = list;
}
登录后复制
添加节点到一个链表中，内核提供了几个接口函数，如list_add()是把一个节点添加到表头，list_add_tail()是插入表尾。
<include/linux/list.h> void list_add(struct list_head *new, struct list_head *head) list_add_tail(struct list_head *new, struct list_head *head)
登录后复制
遍历节点的接口函数。
#define list_for_each(pos, head) \ for (pos = (head)->next; pos != (head); pos = pos->next)
登录后复制
这个宏只是遍历一个一个节点的目今位置，那么怎样获取节点自己的数据结构呢？这里还需要使用list_entry()宏。
#define list_entry(ptr, type, member) \
container_of(ptr, type, member)
container_of()宏的界说在kernel.h头文件中。
#define container_of(ptr, type, member) ({ \
const typeof( ((type *)0)->member ) *__mptr = (ptr); \
(type *)( (char *)__mptr - offsetof(type,member) );})
#define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
登录后复制
其中offsetof()宏是通过把0地点转换为type类型的指针，然后去获取该结构体中member成员的指针，也就是获取了member在type结构体中的偏移量。最后用指针ptr减去offset，就获得type结构体的真实地点了。
下面是遍历链表的一个例子。
<drivers/block/osdblk.c>
static ssize_t class_osdblk_list(struct class *c,
struct class_attribute *attr,
char *data)
{
int n = 0;
struct list_head *tmp;
list_for_each(tmp, &osdblkdev_list) {
struct osdblk_device *osdev;
osdev = list_entry(tmp, struct osdblk_device, node);
n += sprintf(data+n, "%d %d %llu %llu %s\n",
osdev->id,
osdev->major,
osdev->obj.partition,
osdev->obj.id,
osdev->osd_path);
}
return n;
}
登录后复制
红黑树
红黑树（Red Black Tree）被普遍应用在内核的内存治理和历程调理中，用于将排序的元素组织到树中。红黑树被普遍应用在盘算机科学的各个领域中，它在速率和实现重漂后之间提供一个很好的平衡。
红黑树是具有以下特征的二叉树。
每个节点或红或黑。
每个叶节点是玄色的。
若是结点都是红色，那么两个子结点都是玄色。
从一个内部结点到叶结点的简朴路径上，对所有叶节点来说，玄色结点的数目都是相同的。
红黑树的一个优点是，所有主要的操作（例如插入、删除、搜索）都可以在O(log n)时间内完成，n为树中元素的数目。经典的算法教科书都会解说红黑树的实现，这里只是列出一个内核中使用红黑树的例子，供读者在现实的驱动和内核编程中参考。这个例子可以在内核代码的documentation/Rbtree.txt文件中找到。
#include <linux/init.h>
#include <linux/list.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/mm.h>
#include <linux/rbtree.h>
MODULE_AUTHOR("figo.zhang");
MODULE_DESCRIPTION(" ");
MODULE_LICENSE("GPL");
struct mytype {
struct rb_node node;
int key;
};
/*红黑树根节点*/
struct rb_root mytree = RB_ROOT;
/*凭证key来查找节点*/
struct mytype *my_search(struct rb_root *root, int new)
{
struct rb_node *node = root->rb_node;
while (node) {
struct mytype *data = container_of(node, struct mytype, node);
if (data->key > new)
node = node->rb_left;
else if (data->key < new)
node = node->rb_right;
else
return data;
}
return NULL;
}
/*插入一个元素到红黑树中*/
int my_insert(struct rb_root *root, struct mytype *data)
{
struct rb_node **new = &(root->rb_node), *parent=NULL;
/* 寻找可以添加新节点的地方 */
while (*new) {
struct mytype *this = container_of(*new, struct mytype, node);
parent = *new;
if (this->key > data->key)
new = &((*new)->rb_left);
else if (this->key < data->key) {
new = &((*new)->rb_right);
} else
return -1;
}
/* 添加一个新节点 */
rb_link_node(&data->node, parent, new);
rb_insert_color(&data->node, root);
return 0;
}
static int __init my_init(void)
{
int i;
struct mytype *data;
struct rb_node *node;
/*插入元素*/
for (i =0; i < 20; i+=2) {
data = kmalloc(sizeof(struct mytype), GFP_KERNEL);
data->key = i;
my_insert(&mytree, data);
}
/*遍历红黑树，打印所有节点的key值*/
for (node = rb_first(&mytree); node; node = rb_next(node))
printk("key=%d\n", rb_entry(node, struct mytype, node)->key);
return 0;
}
static void __exit my_exit(void)
{
struct mytype *data;
struct rb_node *node;
for (node = rb_first(&mytree); node; node = rb_next(node)) {
data = rb_entry(node, struct mytype, node);
if (data) {
rb_erase(&data->node, &mytree);
kfree(data);
}
}
}
module_init(my_init);
module_exit(my_exit);
登录后复制
mytree是红黑树的根节点，my_insert()实现插入一个元素到红黑树中，my_search()凭证key来查找节点。内核大宗使用红黑树，如虚拟地点空间VMA的治理。
无锁环形缓冲区
生产者和消耗者模子是盘算机编程中最常见的一种模子。生产者爆发数据，而消耗者消耗数据，如一个网络装备，硬件装备吸收网络包，然后应用程序读取网络包�；沸位撼迩鞘迪稚吆拖恼吣Ｗ拥木渌惴��；沸位撼迩ǔＳ幸桓龆林刚牒鸵桓鲂粗刚�。读指针指向环形缓冲区中可读的数据，写指针指向环形缓冲区可写的数据。通过移动读指针和写指针实现缓冲区数据的读取和写入。
在Linux内核中，KFIFO是接纳无锁环形缓冲区的实现。FIFO的全称是“First In First Out”，即先进先出的数据结构，它接纳环形缓冲区的要领来实现，并提供一个无界线的字节约效劳。接纳环形缓冲区的利益是，当一个数据元素被消耗之后，其余数据元素不需要移动其存储位置，从而镌汰复制，提高效率。
（1）建设KFIFO
在使用KFIFO之前需要举行初始化，这里有静态初始化和动态初始化两种方法。
<include/linux/kfifo.h> int kfifo_alloc(fifo, size, gfp_mask)
登录后复制
该函数建设并分派一个巨细为size的KFIFO环形缓冲区。第一个参数fifo是指向该环形缓冲区的struct kfifo数据结构；第二个参数size是指定缓冲区元素的数目；第三个参数gfp_mask体现分派KFIFO元素使用的分派掩码。
静态分派可以使用如下的宏。
#define DEFINE_KFIFO(fifo, type, size) #define INIT_KFIFO(fifo)
登录后复制
（2）入列
把数据写入KFIFO环形缓冲区可以使用kfifo_in()函数接口。
int kfifo_in(fifo, buf, n)
登录后复制
该函数把buf指针指向的n个数据复制到KFIFO环形缓冲区中。第一个参数fifo指的是KFIFO环形缓冲区；第二个参数buf指向要复制的数据的buffer；第三个数据是要复制数据元素的数目。
（3）出列
从KFIFO环形缓冲区中列出或者摘取数据可以使用kfifo_out()函数接口。
#define kfifo_out(fifo, buf, n)
登录后复制
该函数是从fifo指向的环形缓冲区中复制n个数据元素到buf指向的缓冲区中。若是KFIFO环形缓冲区的数据元素小于n个，那么复制出去的数据元素小于n个。
（4）获取缓冲区巨细
KFIFO提供了几个接口函数来盘问环形缓冲区的状态。
#define kfifo_size(fifo) #define kfifo_len(fifo) #define kfifo_is_empty(fifo) #define kfifo_is_full(fifo)
登录后复制
kfifo_size()用来获取环形缓冲区的巨细，也就是最大可以容纳几多个数据元素。kfifo_len()用来获取目今环形缓冲区中有几多个有用数据元素。kfifo_is_empty()判断环形缓冲区是否为空。kfifo_is_full()判断环形缓冲区是否为满。
（5）与用户空间数据交互
KFIFO还封装了两个函数与用户空间数据交互。
#define kfifo_from_user(fifo, from, len, copied) #define kfifo_to_user(fifo, to, len, copied)
登录后复制
kfifo_from_user()是把from指向的用户空间的len个数据元素复制到KFIFO中，最后一个参数copied体现乐成复制了几个数据元素。
kfifo_to_user()则相反，把KFIFO的数据元素复制到用户空间。这两个宏团结了copy_to_user()、copy_from_user()以及KFIFO的机制，给驱动开发者提供了利便。
以上就是Linux内核中常用的数据结构和算法的详细内容，更多请关注本网内其它相关文章！
