内核链表

接口

  1. struct list_head {
  2.     struct list_head *next, *prev;
  3. };
  5. //初始化head链表
  6. LIST_HEAD_INIT(name);
  8. //定义并初始化head链表
  9. LIST_HEAR(name);
  11. //往head链表后插入新元素
  12. list_add(struct list_head *new, struct list_head *head);
  14. //往head链表尾部插入新元素
  15. list_add_tail(struct list_head *new, struct list_head *head);
  17. //从链表中删除元素
  18. list_del(struct list_head *entry);
  20. //删除元素并把元素初始化
  21. list_del_init(struct list_head *entry);
  23. //替换元素
  24. list_replace(struct list_head *old,struct list_head *new);
  26. //替换元素并初始化旧元素
  27. list_replace_init(struct list_head *old,struct list_head *new);
  29. //把元素从链表删除后，再把它添加到head链表后
  30. list_move(struct list_head *list, struct list_head *head);
  32. //把元素从链表删除后，再把它添加到head链表的尾部
  33. list_move_tail(struct list_head *list,struct list_head *head);
  35. //判断元素是否是head这个链表的的尾
  36. int list_is_last(const struct list_head *list,const struct list_head *head);
  38. //遍历head链表
  39.  list_for_each(pos, head);
  41. //从尾部往前遍历链表
  42. list_for_each_prev(pos, head);
  44. //使用安全的方式遍历链表,用于遍历的时候修改元素,防止断链,n为临时结构体指针
  45.  list_for_each_safe(pos, n, head);
  47. //使用安全的方式从尾部往前遍历链表
  48.  list_for_each_prev_safe(pos, n, head);
  50. //取得链表所在数据结构的整个结构
  51. list_entry(ptr, type, member);

链表例子

  1. #include <linux/kernel.h>
  2. #include <linux/module.h>
  3. #include <linux/init.h>
  4. #include <linux/slab.h>
  5. #include <linux/list.h>
  8. struct student
  9. {
  10.     char name[100];
  11.     int num;
  12.     struct list_head list;
  13. };
  15. struct student *pstudent;
  16. struct student *tmp_student;
  17. struct list_head student_list;
  18. struct list_head *pos;
  20. static int __init list_init(void)
  21. {
  22.     int i=0;
  23.     //初始化链表头
  24.     INIT_LIST_HEAD(&student_list);
  26.     for(i=0;i<5;i++){
  27.         pstudent = (struct student *)kmalloc(sizeof(struct student),GFP_KERNEL);
  28.         sprintf(pstudent->name,"student%d",i);
  29.         pstudent->num = i;
  30.         //将新元素添加在链表头后
  31.         //list_add(&pstudent->list,&student_list);
  32.         //将新元素添加在链表尾部
  33.         list_add_tail(&pstudent->list,&student_list);
  34.     }
  36.     //遍历链表
  37.     list_for_each(pos,&student_list){
  38.         //将链表转化链表所在整个数据结构
  39.         tmp_student = list_entry(pos,struct student,list);
  40.         printk("student name:%s,student num:%d\n",tmp_student->name,tmp_student->num);
  41.     }
  43.     return 0;
  44. }
  47. static void __exit list_exit(void)
  48. {
  49.     struct student *pos_tmp,*pos;
  50.     //使用安全的方式遍历链表
  51.     list_for_each_entry_safe(pos,pos_tmp,&student_list,list){
  52.         printk("remove student num: %d, student name:%s\n",pos->num,pos->name);
  53.         //删除链表
  54.         list_del(&(pos->list));
  55.         kfree(pos);
  56.     }
  57. }
  59. module_init(list_init);
  60. module_exit(list_exit);
  62. MODULE_LICENSE("GPL");
  63. MODULE_AUTHOR("Alex");
  64. MODULE_DESCRIPTION("ListModule");
  65. MODULE_ALIAS("List Module");

内核环形队列

接口

  1. //头文件
  2. #include <linux/kfifo.h>
  4. //创建队列  size必须是2的幂.
  5. //动态创建
  6. int kfifo_alloc(struct kfifo *fifo, unsigned int size, gfp_t gfp_mask);
  7. /* fifo:  指向kfifo的指针
  8.  * size:  动态创建的队列大小
  9.  * gfp_mask: GFP_KERNEL 无内存可用时可引起休眠.
  10.  */
  12. //使用自定义Buffer创建和初始化
  13. void kfifo_init(struct kfifo *fito, void *buffer, unsigned int size);
  15. //入队
  16. usinged int kfifo_in(struct kfifo *fifo, const void *from, unsigned int len);；
  17. /* 从from中复制len个字节的数据到fifo队列
  18.  * fifo:  指向kfifo的指针
  19.  * from:  源指针
  20.  * len：     复制长度
  21.  * 返回值： 返回已复制数据的长度
  22.  */
  24. //出队
  25. unsigned int kfifo_out(struct kfifo *fifo, void *to, unsigned int len);
  26. /* 从队列中复制最多len个字节的数据到to
  27.  * fifo:  指向kfifo的指针
  28.  * to: 指向目标buf
  29.  * len: 复制长度
  30.  * 返回值: 返回已复制数据的长度
  31.  */
  33. unsigned int kfifo_out_peek(struct kfifo *fifo, void *to, unsigned int len, unsigned offset);
  34. /* 从列表的offset位置开始获取len字节的数据, 队列数据内容不会被改变
  35.  * fifo:  指向kfifo的指针
  36.  * to: 指向目标buf
  37.  * len: 复制长度
  38.  * offset: 复制起始位置
  39.  */
  41. //获取队列大小
  42. static inline unsigned int kfifo_size(struct kfifo *fifo);
  43. /* 返回队列的空间总大小 */
  45. static inline unsigned int kfifo_len(struct kfifo *fifo);
  46. /* 返回队列中已入队字节数 */
  48. static inline unsigned int kfifo_avail(struct kfifo *fifo);
  49. /* 返回队列的可用空间的大小. */
  51. static inline int kfifo_is_empty(struct kfifo *fifo);
  52. /* 测试kfifo是否为空 */
  54. static inline int kfifo_is_full(struct kfifo *fifo);
  55. /* 测试kfifo是否已满 */
  57. //重置和销毁队列
  58. static inline void kfifo_reset(struct kfifo *fifo);
  59. /* 重置队列 */
  61. void kfifo_free(struct kfifo *fifo);
  62. /* 销毁用kfifo_alloc()创建的队列 */

队列例子

#include <linux/init.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/kfifo.h>


void prt_kfifo_size(struct kfifo *fifo)
{
    printk("kfifo size:%u bytes\n",kfifo_size(fifo));
    printk("kfifo len:%u bytes\n",kfifo_len(fifo));
    printk("kfifo avail:%u bytes\n",kfifo_avail(fifo));
}

static int kfifo_test_init(void)
{
    struct kfifo fifo;
    int ret;
    int i;
    int buf[1024];
    int nbytes;

    ret = kfifo_alloc(&fifo,1024,GFP_KERNEL);
    if (ret){
        printk("kfifo alloc fail\n");
        return ret;
    }

    for(i=0;i<32;i++){
        kfifo_in(&fifo,&i,sizeof(i));
    }

    prt_kfifo_size(&fifo);
    nbytes = kfifo_out_peek(&fifo,buf,1024);
    printk("peek:%d bytes\n",nbytes);
    for(i=0;i<nbytes/sizeof(int);i++){
        printk("%d\n",buf[i]);
    }
    printk("\n===== after peek =====\n");
    prt_kfifo_size(&fifo);

    nbytes = kfifo_out(&fifo,buf,sizeof(int));
    printk("out : %d bytes\n",nbytes);

    printk("\n===== after out ====\n");
    prt_kfifo_size(&fifo);

    return 0;

}

static void kfifo_test_exit(void)
{
    kfifo_free(&fifo);
}

module_init(kfifo_test_init);
module_exit(kfifo_test_exit);

MODULE_AUTHOR("Alex");
MODULE_LICENSE("GPL");