精华内容
下载资源
问答
  • linux内核链表使用

    千次阅读 2014-04-17 23:26:55
    内核有链表操作,非常简洁,一开始其实我是不愿意替换的,因为那时候工作进度紧,对内核链表使用不熟悉,怕出错,结果迫于老大压力,给替换为内核的链表了,替换完之后感觉真不错,于是乘胜追击,把链表操

           作为职场菜鸟,刚开始写驱动时,有地方需要使用双向循环链表,孤陋寡闻的我自己在结构体中弄了个*pre和*next指过来指过去,到最后虽然功能实现了,但是代码看起来好冗余,一不小心链表操作就会错误,一位大师告诉我,内核有链表操作,非常简洁,一开始其实我是不愿意替换的,因为那时候工作进度紧,对内核链表使用不熟悉,怕出错,结果迫于老大压力,给替换为内核的链表了,替换完之后感觉真不错,于是乘胜追击,把链表操作也移植到另外一个系统中继续使用了,本文简单介绍几个内核链表使用接口,承认确实没什么技术含量,但是也算是给大家共享一点经验吧

    比如我有个自己的结构体,里边有一个链表成员变量:

    struct my_demo{

             list_head entry;

              int a;

              int b;

             }demo;

    list_head    ctrl_head;

    1、初始化链表

              INIT_LIST_HEAD(&demo.entry);

              INIT_LIST_HEAD(&ctrl_head);

    2、插入到链表尾部

             list_add_tail(&demo.entry, &ctrl_head);

    3、插入到链表头部

             list_add(&demo.entry, &ctrl_head);

    4、遍历链表

           struct my_demo *pos;

           list_for_each_entry(pos,&ctrl_head, entry);

    5、遍历的同时需要删除节点

          struct my_demo *pos,*temp;

           list_for_each_entry_safe(pos,temp,&ctrl_head, entry);

         

          内核中还有其他很多操作,感兴趣的同学可以参考<linux/list.h>文件;需要注意的是,链表操作需要在互斥锁保护下进行,否则就会很容易出错,感兴趣的同学可以尝试一下不互斥情况下多个任务去操作,可以看一下什么效果。

     

    展开全文
  • Linux 内核链表使用举例

    千次阅读 2014-06-20 17:20:00
    链表数据结构的定义很简洁: struct list_head { struct list_head *next, *prev; }; list_head结构包含两个指向list_head结构的...在Linux内核链表中,不是在链表结构中包含数据,而是在数据结构中包含链表节点。
    链表数据结构的定义很简洁:
    

    struct list_head { 
        struct list_head *next, *prev;
    }; 

    list_head结构包含两个指向list_head结构的指针prev和next,该内核链表具备双链表功能,通常它都组织成双循环链表,这里的list_head没有数据域。在Linux内核链表中,不是在链表结构中包含数据,而是在数据结构中包含链表节点。下面是一个简单的内核模块的例子,包含了对链表进行插入、删除、遍历的一些函数:

    list.c:

    #include <linux/kernel.h>
    #include <linux/module.h>
    #include <linux/init.h>
    #include <linux/string.h>
    #include <linux/spinlock.h>
    #include <linux/list.h>
    
    typedef struct list_test_struct {
            int num;
            struct list_head list;
    }test;
    
    struct list_head head_list;
    rwlock_t list_lock = RW_LOCK_UNLOCKED;   //定义读写锁,操作前加锁,操作后解锁
    
    void creat_list(void)
    {
            test *s = NULL;
            int  i = 0;
            for (i = 0; i < 10; i++) 
            {
                    s = (test *)kmalloc(sizeof(test), GFP_ATOMIC);
                    if (!s) return ;
                    s->num = i;
                    write_lock(&list_lock);
                    list_add_tail(&(s->list), &head_list);   //添加节点
                    write_unlock(&list_lock);
            }
    }
    
    void del_data(void)
    {
            test *s;
            struct list_head *p;
    
            write_lock(&list_lock);
            list_for_each(p, &head_list)          //遍历链表
            {
                    s = list_entry(p, test, list);
                    if (s->num == 4) 
                    {
                            list_del(p);          //删除节点
                            write_unlock(&list_lock);
                            return ;
                    }
            }
            write_unlock(&list_lock);
    }
    
    void print_list(void)
    {
            test *s;
            struct list_head *p;
            read_lock(&list_lock);
            list_for_each(p, &head_list) 
            {
                    s = list_entry(p, test, list);
                    printk(KERN_INFO"%d\n", s->num);
            }
            read_unlock(&list_lock);
    }
    
    int list_test_init(void)
    {
            INIT_LIST_HEAD(&head_list);
            creat_list();
            print_list();
            del_data();
            print_list();
            return 0;
    }
    
    void list_test_exit(void)
    {
    	return;
    }
    
    MODULE_LICENSE("GPL");
    module_init(list_test_init);
    module_exit(list_test_exit);
    
    Makefile:

    obj-m	+= list.o
    
    KERN_DIR = /usr/src/linux-headers-2.6.32-33-generic
    
    all:
    	make -C $(KERN_DIR) M=`pwd` modules 
    
    clean:
    	make -C $(KERN_DIR) M=`pwd` modules clean
    	rm -rf modules.order

    make后生成module,获取超级用户权限后

    insmod list.ko

    然后输入命令:

    cat var/log/messages

    printk打印信息:

    Jun 20 16:26:01 wuwen-laptop kernel: [ 5490.274551] 0
    Jun 20 16:26:01 wuwen-laptop kernel: [ 5490.274553] 1
    Jun 20 16:26:01 wuwen-laptop kernel: [ 5490.274555] 2
    Jun 20 16:26:01 wuwen-laptop kernel: [ 5490.274555] 3
    Jun 20 16:26:01 wuwen-laptop kernel: [ 5490.274556] 4
    Jun 20 16:26:01 wuwen-laptop kernel: [ 5490.274557] 5
    Jun 20 16:26:01 wuwen-laptop kernel: [ 5490.274558] 6
    Jun 20 16:26:01 wuwen-laptop kernel: [ 5490.274559] 7
    Jun 20 16:26:01 wuwen-laptop kernel: [ 5490.274559] 8
    Jun 20 16:26:01 wuwen-laptop kernel: [ 5490.274560] 9
    Jun 20 16:26:01 wuwen-laptop kernel: [ 5490.274561] 0
    Jun 20 16:26:01 wuwen-laptop kernel: [ 5490.274562] 1
    Jun 20 16:26:01 wuwen-laptop kernel: [ 5490.274563] 2
    Jun 20 16:26:01 wuwen-laptop kernel: [ 5490.274564] 3
    Jun 20 16:26:01 wuwen-laptop kernel: [ 5490.274564] 5
    Jun 20 16:26:01 wuwen-laptop kernel: [ 5490.274565] 6
    Jun 20 16:26:01 wuwen-laptop kernel: [ 5490.274566] 7
    Jun 20 16:26:01 wuwen-laptop kernel: [ 5490.274567] 8
    Jun 20 16:26:01 wuwen-laptop kernel: [ 5490.274568] 9
    第二次输出发现节点4被删除,在这里实现:

           list_for_each(p, &head_list)          //遍历链表
           {
                    s = list_entry(p, test, list);
                    if (s->num == 4) 
                    {
                            list_del(p);          //删除节点
                            write_unlock(&list_lock);
                            return ;
                    }
            }

    展开全文
  • }然后当我们要创建一个链表的时候,我们使用linux内核提供的宏进行创建,比如我们要创建一个名为example_list的链表时,代码如下 LIST_HEAD(example_list);然后就向链表中添加元素,我们先声明一个链表结构体变量...

    首先我们定义一个我们要用的链表结构体

    struct list_user
    {
    struct list_head list;
    int data;
    }
    然后当我们要创建一个链表的时候,我们使用linux内核提供的宏进行创建,比如我们要创建一个名为example_list的链表时,代码如下

    LIST_HEAD(example_list);
    然后就向链表中添加元素,我们先声明一个链表结构体变量
    struct list_user list_user1;
    然后就可以利用linux内核提供的宏将这个节点添加到链表中
    list_add_tail(&list_user1.list,&example_list);

    展开全文
  • #ifndef _LIST_H #define _LIST_H struct list_head { struct list_head *next, *prev; }; #define LIST_HEAD_INIT(name) { &(name), &... struct list_head name = LIST_HEAD_INIT(name) ...
    #ifndef _LIST_H
    #define _LIST_H
    
    struct list_head {
    	struct list_head *next, *prev;
    };
    
    #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;
    }
    
    static inline void __list_add(struct list_head *new,
    			struct list_head *prev,
    			struct list_head *next)
    {
    	next->prev = new;
    	new->next = next;
    	new->prev = prev;
    	prev->next = new;
    }
    
    static inline void list_add(struct list_head *new, struct list_head *head)
    {
    	__list_add(new, head, head->next);
    }
    
    static inline void list_add_tail(struct list_head *new, struct list_head *head)
    {
    	__list_add(new, head->prev, head);
    }
    
    static inline void __list_del(struct list_head * prev, struct list_head * next)
    {
    	next->prev = prev;
    	prev->next = next;
    }
    
    static inline void list_del(struct list_head *entry)
    {
    	__list_del(entry->prev, entry->next);
    }
    
    static inline void __list_del_entry(struct list_head *entry)
    {
    	__list_del(entry->prev, entry->next);
    }
    
    static inline void list_del_init(struct list_head *entry)
    {
    	__list_del_entry(entry);
    	INIT_LIST_HEAD(entry);
    }
    
    static inline void list_replace(struct list_head *old,
    			struct list_head *new)
    {
    	new->next = old->next;
    	new->next->prev = new;
    	new->prev = old->prev;
    	new->prev->next = new;
    }
    
    static inline int list_empty(const struct list_head *head)
    {
    	return head->next == head;
    }
    
    #define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
    
    #define container_of(ptr, type, member) ({          \
    			const typeof( ((type *)0)->member ) *__mptr = (ptr);    \
    			(type *)( (char *)__mptr - offsetof(type,member) );})
    
    #define list_for_each(pos, head) \
    	for (pos = (head)->next; pos != (head); pos = pos->next)
    
    #define list_for_each_safe(pos, n, head) \
    	for (pos = (head)->next, n = pos->next; pos != (head); \
    				pos = n, n = pos->next)
    
    #define list_entry(ptr, type, member) \
    	container_of(ptr, type, member)
    
    #endif
    
    
    展开全文
  • linux内核链表

    2018-09-22 13:59:32
    博客详细讲解Linux内核链表,教你看懂Linux内核链表与普通链表有什么不一样
  • linux内核链表实现

    2018-12-28 11:21:26
    linux内核链表的实现,包括内核链表的定义,以及内核链表相关的操作
  • Linux内核链表

    2020-11-22 16:44:58
    链表都是第一个接触的内容,笔者也不列外,虽然自己实现过几种链表,但是在实际工作中,还是Linux内核的链表最为常用(同时笔者也建议大家使用内核链表,因为会了这个,其他的都会了),故总结一篇Linux内核链表的...
  • LINUX内核链表

    2017-07-18 13:03:09
    Linux 内核链表
  • 专题**-Linux内核链表

    2017-04-20 17:54:42
    测试模块-Linux内核链表使用范例链表简介链表是一种常用的数据结构,它通过指针将一系列数据节点连接成一条数据链。相对于数组,链表具有更好的动态性,建立链表时无需预先知道数据总量,可以随机分配空间,可以随机...
  • 本文讲解Linux内核链表实现的过程,说了链表的定义及初始化宏定义、插入操作和删除操作等内容,详细看下面
  • 博客详细讲解Linux内核链表,教你看懂Linux内核链表与普通链表有什么不一样,并且有测试代码
  • linux内核链表.pdf

    2021-08-26 14:51:52
    linux内核链表.pdf
  • Linux内核链表分析.pdf

    2021-09-06 12:37:30
    Linux内核链表分析.pdf
  • linux内核链表

    2018-12-12 20:48:07
    linux内核链表插入,排序函数库,库里面包含了一些宏。可以进行链表的插入,,删减。与一般链表不同的是,可以连接不同类型的数据。
  • Linux内核链表是Linux内核最经典的数据结构之一,Linux内核链表最大的优点就是节省内存,对链表的各项操作较快,实现的思路耳目一新,而且在Linux内核里频繁使用,比如:内存管理,进程调度等。 Linux内核链表是一个...
  • linux 内核 链表 list_head 使用方法.pdf
  • 剖析linux 内核 linux内核链表
  • linux内核源码中list.h拿出来, 增删与遍历部分写了详细注释, 关于链表合并, 没用过所以没写. 源码版本是2.6.32, 不过链表的源码改动应该不是很大. 我的邮箱2253238252@qq.com, 代码有什么不对的欢迎发邮件给我
  • linux内核链表list_head的原理与使用一般的链表Linux内核中的链表list_head主要的操作内核链表的使用Liunx内核链表的原理 一般的链表 一般的链表如下,它是将数据结构塞入链表,这样的话,每一种数据结构都需要重新...
  • 移植Linux内核链表

    2018-02-07 16:53:13
      Linux内核源码中的链表是一个双向循环链表,该链表的设计具有优秀的封装性和可扩展性。本文将从2.6.39版本内核的内核链表移植到Windows平台的visual studio2010环境中。链表的源码位于内核源码的include/linux/...
  • linux 内核链表的应用

    2015-10-20 09:46:23
    linux 内核链表学习
  • linux内核的链表结构和对内核链表的操作进行超详细讲解
  • Linux内核链表测试

    2013-11-11 10:28:17
    linux2.4.18版本源码 内核链表 用户态移植 vc6.0下测试

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 66,359
精华内容 26,543
关键字:

linux内核链表的使用

linux 订阅