Linux链表操作

最新推荐文章于 2025-03-31 11:55:34 发布
最新推荐文章于 2025-03-31 11:55:34 发布
阅读量1.7k 收藏 7
点赞数 1
分类专栏： 嵌入式 Linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/zhaoyun_zzz/article/details/87196598
版权
本文详细介绍了Linux内核中链表的实现与操作，包括链表指针结构体的定义、链表的各种操作如插入、删除、替换和移动，以及链表的遍历方法。特别强调了Linux链表的独特之处，如不带数据域的链表结构和利用container_of宏进行数据结构定位。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

文章目录


新年开工第一篇，有点空闲翻博客，发现写过关于 container_of宏定义的博客之后，怎么能不写链表操作呢，岂不是断篇了？那就把链表操作的笔记呀搬上来吧。
自从学C语言时接触到链表后，直到再学Linux以前，一直以为链表就那样操作了，在结构体中定义指向结构体的指针，可以实现单向链表、双向链表、循环链表等，自从看到Linux的链表之后，就颠覆了我的认知，原来链表还可以这么搞；Linux的链表可以说做到了以不变应万变。
Linux内核定义的链表结构不带数据域，只需要两个指针完成链表的操作，当然要通过链表指针找到实际的数据结构，就需要借助 container_of宏了。

链表指针结构体

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

链表指针结构体内部只定义了两个指向结构体本身的指针；当需要用链表结构时，只需要在自定义结构体中定义一个链表类型的数据即可。

struct usbcamera_node
{
	struct list_head node;
	int channel;
	char id[32];
	int usb_port;
	//V4L2
	char devname[32];
	int fd;
	struct v4l2_format fmt;
	struct v4l2_streamparm parm;
	struct v4l2_requestbuffers req;
	struct buffer *buffers;
	int n_buffers;
	int poll_index[MAX_CHANNEL];
};

将struct list_head node定义为结构体的第一项成员，还有一个用处就是，可以将指向list_head指针，进行强制转换为自定义结构体的指针。
定义一个链表头结点并初始化

#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_HEAD定义时，已经初始化，也可是使用内联函数INIT_LIST_HEAD对链表进行初始化。

链表的插入

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_add_rcu(struct list_head * new,
		struct list_head * prev, struct list_head * next)
{
	new->next = next;
	new->prev = prev;
	asm volatile ("":::"memory");//smp_wmb();
	next->prev = new;
	prev->next = new;
}
static inline void list_add_rcu(struct list_head *new, struct list_head *head)
{
	__list_add_rcu(new, head, head->next);
}
static inline void list_add_tail_rcu(struct list_head *new,
					struct list_head *head)
{
	__list_add_rcu(new, head->prev, head);
}
  • __list_add、__list_add_rcu是实际的操作函数，不同之处在于RCU方式下的执行顺序不会被优化
  • list_add、list_add_rcu，用于将新节点添加到链表指定节点位置之后
  • list_add_tail、list_add_tail_rcu，用于将新节点添加到链表最后

链表的删除

#define LIST_POISON1  ((void *) 0x00100100)
#define LIST_POISON2  ((void *) 0x00200200)
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);
	entry->next = LIST_POISON1;
	entry->prev = LIST_POISON2;
}

static inline void list_del_rcu(struct list_head *entry)
{
	__list_del(entry->prev, entry->next);
	entry->prev = LIST_POISON2;
}

  • 从链表中删除一个节点，需要改变该节点前向节点的后向节点、后向结点的前向节点。最后设置该节点的前驱节点和后继结点指向LIST_POSITION1和LIST_POSITION2两个特殊值，这样设置是为了保证不在链表中的节点项不可访问，对LIST_POSITION1和LIST_POSITION2的访问都将引起页故障

  • entry->prev = LIST_POISON2; 给entry节点的prev指针赋值，此处没给next赋值，就是为了保证读线程的完整性，已经获取此条目地址的遍历程序不会中断，没有获取此条目的会获得新的next地址。这里也符合rcu理念，保证链表遍历完整性。

链表的替换

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 void list_replace_init(struct list_head *old,
					struct list_head *new)
{
	list_replace(old, new);
	INIT_LIST_HEAD(old);
}

/**
 * list_replace_rcu - replace old entry by new one
 * @old : the element to be replaced
 * @new : the new element to insert
 *
 * The @old entry will be replaced with the @new entry atomically.
 * Note: @old should not be empty.
 */
static inline void list_replace_rcu(struct list_head *old,
				struct list_head *new)
{
	new->next = old->next;
	new->prev = old->prev;
	asm volatile ("":::"memory");//smp_wmb();
	new->next->prev = new;
	new->prev->next = new;
	old->prev = LIST_POISON2;
}
  • list_replace：用于替换新旧节点
  • list_replace_init：用于替换新旧节点，并初始化旧节点
  • list_replace_rcu：这里用rcu保护机制给新节点的prev与next赋值，保证新节点的完整性，防止某些编译器优化代码执行顺序，保证读线程获取的old节点地址要么是旧的，要么是已经赋好值得新指针。old->prev = LIST_POISON2，给old节点的prev赋值，保持next不变，防止已经获取其地址的读线程遍历中断，这也是rcu机制完整性思想。

链表的移动

/**
 * list_move - delete from one list and add as another's head
 * @list: the entry to move
 * @head: the head that will precede our entry
 */
static inline void list_move(struct list_head *list, struct list_head *head)
{
	__list_del(list->prev, list->next);
	list_add(list, head);
}

/**
 * list_move_tail - delete from one list and add as another's tail
 * @list: the entry to move
 * @head: the head that will follow our entry
 */
static inline void list_move_tail(struct list_head *list,
				  struct list_head *head)
{
	__list_del(list->prev, list->next);
	list_add_tail(list, head);
}
  • list_move：将节点移动到链表头部
  • list_move_tail：将节点移动到链表尾部

链表的遍历

/**
 * list_entry - get the struct for this entry
 * @ptr:	the &struct list_head pointer.
 * @type:	the type of the struct this is embedded in.
 * @member:	the name of the list_struct within the struct.
 */
#define list_entry(ptr, type, member) \
	container_of(ptr, type, member)

/**
 * list_first_entry - get the first element from a list
 * @ptr:	the list head to take the element from.
 * @type:	the type of the struct this is embedded in.
 * @member:	the name of the list_struct within the struct.
 *
 * Note, that list is expected to be not empty.
 */
#define list_first_entry(ptr, type, member) \
	list_entry((ptr)->next, type, member)

/**
 * list_for_each	-	iterate over a list
 * @pos:	the &struct list_head to use as a loop cursor.
 * @head:	the head for your list.
 */
#define list_for_each(pos, head) \
	for (pos = (head)->next; prefetch(pos->next), pos != (head); \
        	pos = pos->next)

/**
 * __list_for_each	-	iterate over a list
 * @pos:	the &struct list_head to use as a loop cursor.
 * @head:	the head for your list.
 *
 * This variant differs from list_for_each() in that it's the
 * simplest possible list iteration code, no prefetching is done.
 * Use this for code that knows the list to be very short (empty
 * or 1 entry) most of the time.
 */
#define __list_for_each(pos, head) \
	for (pos = (head)->next; pos != (head); pos = pos->next)

/**
 * list_for_each_prev	-	iterate over a list backwards
 * @pos:	the &struct list_head to use as a loop cursor.
 * @head:	the head for your list.
 */
#define list_for_each_prev(pos, head) \
	for (pos = (head)->prev; prefetch(pos->prev), pos != (head); \
        	pos = pos->prev)

/**
 * list_for_each_safe - iterate over a list safe against removal of list entry
 * @pos:	the &struct list_head to use as a loop cursor.
 * @n:		another &struct list_head to use as temporary storage
 * @head:	the head for your list.
 */
#define list_for_each_safe(pos, n, head) \
	for (pos = (head)->next, n = pos->next; pos != (head); \
		pos = n, n = pos->next)

/**
 * list_for_each_prev_safe - iterate over a list backwards safe against removal of list entry
 * @pos:        the &struct list_head to use as a loop cursor.
 * @n:          another &struct list_head to use as temporary storage
 * @head:       the head for your list.
 */
#define list_for_each_prev_safe(pos, n, head) \
        for (pos = (head)->prev, n = pos->prev; \
             pos != (head); \
             pos = n, n = pos->prev)

/**
 * list_for_each_entry	-	iterate over list of given type
 * @pos:	the type * to use as a loop cursor.
 * @head:	the head for your list.
 * @member:	the name of the list_struct within the struct.
 */
#define list_for_each_entry(pos, head, member)				\
	for (pos = list_entry((head)->next, typeof(*pos), member);	\
	     prefetch(pos->member.next), &pos->member != (head); 	\
	     pos = list_entry(pos->member.next, typeof(*pos), member))

/**
 * list_for_each_entry_reverse - iterate backwards over list of given type.
 * @pos:	the type * to use as a loop cursor.
 * @head:	the head for your list.
 * @member:	the name of the list_struct within the struct.
 */
#define list_for_each_entry_reverse(pos, head, member)			\
	for (pos = list_entry((head)->prev, typeof(*pos), member);	\
	     prefetch(pos->member.prev), &pos->member != (head); 	\
	     pos = list_entry(pos->member.prev, typeof(*pos), member))

/**
 * list_prepare_entry - prepare a pos entry for use in list_for_each_entry_continue()
 * @pos:	the type * to use as a start point
 * @head:	the head of the list
 * @member:	the name of the list_struct within the struct.
 *
 * Prepares a pos entry for use as a start point in list_for_each_entry_continue().
 */
#define list_prepare_entry(pos, head, member) \
	((pos) ? : list_entry(head, typeof(*pos), member))

/**
 * list_for_each_entry_continue - continue iteration over list of given type
 * @pos:	the type * to use as a loop cursor.
 * @head:	the head for your list.
 * @member:	the name of the list_struct within the struct.
 *
 * Continue to iterate over list of given type, continuing after
 * the current position.
 */
#define list_for_each_entry_continue(pos, head, member) 		\
	for (pos = list_entry(pos->member.next, typeof(*pos), member);	\
	     prefetch(pos->member.next), &pos->member != (head);	\
	     pos = list_entry(pos->member.next, typeof(*pos), member))

/**
 * list_for_each_entry_from - iterate over list of given type from the current point
 * @pos:	the type * to use as a loop cursor.
 * @head:	the head for your list.
 * @member:	the name of the list_struct within the struct.
 *
 * Iterate over list of given type, continuing from current position.
 */
#define list_for_each_entry_from(pos, head, member) 			\
	for (; prefetch(pos->member.next), &pos->member != (head);	\
	     pos = list_entry(pos->member.next, typeof(*pos), member))

/**
 * list_for_each_entry_safe - iterate over list of given type safe against removal of list entry
 * @pos:	the type * to use as a loop cursor.
 * @n:		another type * to use as temporary storage
 * @head:	the head for your list.
 * @member:	the name of the list_struct within the struct.
 */
#define list_for_each_entry_safe(pos, n, head, member)			\
	for (pos = list_entry((head)->next, typeof(*pos), member),	\
		n = list_entry(pos->member.next, typeof(*pos), member);	\
	     &pos->member != (head); 					\
	     pos = n, n = list_entry(n->member.next, typeof(*n), member))

/**
 * list_for_each_entry_safe_continue
 * @pos:	the type * to use as a loop cursor.
 * @n:		another type * to use as temporary storage
 * @head:	the head for your list.
 * @member:	the name of the list_struct within the struct.
 *
 * Iterate over list of given type, continuing after current point,
 * safe against removal of list entry.
 */
#define list_for_each_entry_safe_continue(pos, n, head, member) 		\
	for (pos = list_entry(pos->member.next, typeof(*pos), member), 		\
		n = list_entry(pos->member.next, typeof(*pos), member);		\
	     &pos->member != (head);						\
	     pos = n, n = list_entry(n->member.next, typeof(*n), member))

/**
 * list_for_each_entry_safe_from
 * @pos:	the type * to use as a loop cursor.
 * @n:		another type * to use as temporary storage
 * @head:	the head for your list.
 * @member:	the name of the list_struct within the struct.
 *
 * Iterate over list of given type from current point, safe against
 * removal of list entry.
 */
#define list_for_each_entry_safe_from(pos, n, head, member) 			\
	for (n = list_entry(pos->member.next, typeof(*pos), member);		\
	     &pos->member != (head);						\
	     pos = n, n = list_entry(n->member.next, typeof(*n), member))

/**
 * list_for_each_entry_safe_reverse
 * @pos:	the type * to use as a loop cursor.
 * @n:		another type * to use as temporary storage
 * @head:	the head for your list.
 * @member:	the name of the list_struct within the struct.
 *
 * Iterate backwards over list of given type, safe against removal
 * of list entry.
 */
#define list_for_each_entry_safe_reverse(pos, n, head, member)		\
	for (pos = list_entry((head)->prev, typeof(*pos), member),	\
		n = list_entry(pos->member.prev, typeof(*pos), member);	\
	     &pos->member != (head); 					\
	     pos = n, n = list_entry(n->member.prev, typeof(*n), member))

/**
 * list_for_each_rcu	-	iterate over an rcu-protected list
 * @pos:	the &struct list_head to use as a loop cursor.
 * @head:	the head for your list.
 *
 * This list-traversal primitive may safely run concurrently with
 * the _rcu list-mutation primitives such as list_add_rcu()
 * as long as the traversal is guarded by rcu_read_lock().
 */
#define list_for_each_rcu(pos, head) \
	for (pos = (head)->next; \
		prefetch(rcu_dereference(pos)->next), pos != (head); \
        	pos = pos->next)

#define __list_for_each_rcu(pos, head) \
	for (pos = (head)->next; \
		rcu_dereference(pos) != (head); \
        	pos = pos->next)

/**
 * list_for_each_safe_rcu
 * @pos:	the &struct list_head to use as a loop cursor.
 * @n:		another &struct list_head to use as temporary storage
 * @head:	the head for your list.
 *
 * Iterate over an rcu-protected list, safe against removal of list entry.
 *
 * This list-traversal primitive may safely run concurrently with
 * the _rcu list-mutation primitives such as list_add_rcu()
 * as long as the traversal is guarded by rcu_read_lock().
 */
#define list_for_each_safe_rcu(pos, n, head) \
	for (pos = (head)->next; \
		n = rcu_dereference(pos)->next, pos != (head); \
		pos = n)

/**
 * list_for_each_entry_rcu	-	iterate over rcu list of given type
 * @pos:	the type * to use as a loop cursor.
 * @head:	the head for your list.
 * @member:	the name of the list_struct within the struct.
 *
 * This list-traversal primitive may safely run concurrently with
 * the _rcu list-mutation primitives such as list_add_rcu()
 * as long as the traversal is guarded by rcu_read_lock().
 */
#define list_for_each_entry_rcu(pos, head, member) \
	for (pos = list_entry((head)->next, typeof(*pos), member); \
		prefetch(rcu_dereference(pos)->member.next), \
			&pos->member != (head); \
		pos = list_entry(pos->member.next, typeof(*pos), member))


/**
 * list_for_each_continue_rcu
 * @pos:	the &struct list_head to use as a loop cursor.
 * @head:	the head for your list.
 *
 * Iterate over an rcu-protected list, continuing after current point.
 *
 * This list-traversal primitive may safely run concurrently with
 * the _rcu list-mutation primitives such as list_add_rcu()
 * as long as the traversal is guarded by rcu_read_lock().
 */
#define list_for_each_continue_rcu(pos, head) \
	for ((pos) = (pos)->next; \
		prefetch(rcu_dereference((pos))->next), (pos) != (head); \
        	(pos) = (pos)->next)
  • 程序访问的变量如果都能在系统内存cache中则能提升性能，prefetch是内核中一个预热内存函数，这样下次遍历时就能高效命中内存cache，从而提升程序性能；上面的代码中遍历链表时下次访问的内存为pos->next，故在每次遍历时对pos->next进行预热，从而提升性能。
  • ptr：结构体成员list_head的指针
  • type：结构体数据类型
  • member：包含list_head结构体的成员member的名称
  • pos：指向当前结点的指针
  • head：指向双向链表头的指针
  • n：临时用来保存指向pos的下一个结点的指针
  • list_for_each()：此种编历时需要删除节点时，list_del(pos)将pos的前后指针指向undefined state，导致kernel panic，list_del_init(pos)将pos前后指针指向自身，导致死循环。
  • list_for_each_safe()：首先将pos的后指针缓存到n，处理一个流程后再赋回pos，避免了这种情况发生。因此之遍历链表不删除结点时，可以使用list_for_each()，而当由删除结点操作时，则要使用list_for_each_safe()。

好了链表的操作就写这么多了，未曾用到的就不写了。

linux下对链表的10种常用操作（C语言）
12-26
linux下对链表的10种常用操作（C语言），很实用
linux内核链表
东边日出，西边雨...
04-23 1381
今天在看流量控制的代码时，特别留意了一下list_head的结构，发现它只有指针域，没有数据域，觉得有点困惑，一般的链表节点都包括两部分：数据域和指针域。linux里为何能这么用呢？股沟一下，原来是这么回事。在Linux内核链表中，不是在链表结构中包含数据，而是在数据结构中包含链表节点。深入分析 Linux 内核链表
从0到1：解锁Linux内核链表的神秘面纱
最新发布
大雨淅淅的博客
03-31 659
单链表是链表家族中最为基础和简洁的成员。在单链表中，每个节点都包含两部分：数据域和指针域。数据域用于存储实际的数据，而指针域则存储着下一个节点的内存地址，就像接力赛中的接力棒传递，通过这个指针，我们可以从一个节点访问到下一个节点，从而遍历整个链表。不过，单链表有一个明显的限制，它只能从链表的头部开始，沿着指针的方向依次向后访问节点，无法反向回溯。比如我们要找单链表中倒数第二个节点，必须从第一个节点开始，一个一个向后遍历，直到找到目标节点。
linux 链表实例应用程序【转】
weixin_34226706的博客
07-07 130
转自：http://blog.youkuaiyun.com/echo_qiang/article/details/6233057 /********************************************************************* * * Filename: pfile.c * Version: 1...
linux基础之链表
cqxcool66的博客
08-16 552
前言 list在linux内核中使用非常频繁。 链表操作 定义双向链表结构体 struct list_head { struct list_head *prev; struct list_head *next; }; 初始化一个链表 static void INIT_LIST_HEAD(struct list_head *list) { list->next = list; list->prev = list; } 在前一个和后一个之间插入一个新的链表项 static void __
Linux主控 ——链表操作
weixin_51526796的博客
03-14 343
在Linux内核里，大量使用了链表操作，list_head设备管理、驱动管理、内存管理、等待队列、中断资源·list_head使用。
Linux内核链表使用方法
hinewcc的博客
07-07 1870
Linux内核链表使用方法介绍
graph_DFS.zip_C语言单向链表_linux 链表_链表_链表 linux
09-24
总的来说，"graph_DFS.zip"中的内容提供了关于C语言单向链表实现和链表在Linux环境下的操作实践，同时可能涵盖了如何使用链表表示图并进行深度优先搜索的知识点。这不仅有助于深化对数据结构的理解，还能提升在实际...
linux链表
qq_35018427的博客
06-29 667
、
linux下的C链表程序
05-09
面试前写的链表程序，比较简单，适合初学者了解链表的过程，大神别喷。 功能： 1.Add Records 2.Show Records 3.Search Records 4.Delete Records 5.Insert Records 6.Save 7.Exit 环境：linux ubuntu12.04 语言：C 清单： Start.c print.c print.h control.c control.h extern.h makfile 交流邮箱：shadowdestiny@163.com
LINUX下链表操作函数的源代码
Always look out for number one.
04-24 1461
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_
linux-链表及相关链表操作
tycfreak的博客
07-12 143
1.链表结构体 struct list_head{ struct list_head *next; stuct list_head *prev; } 2.list_entry找到链表所对应结构体指针 #define container_of(ptr, type, member)\ container_of(ptr, type, member) 3.链表初始化 INIT_LIST_HEAD() #define LIST_HEAD_INIT(name) { &(name), &(na
玩转C链表
weixin_30552811的博客
11-28 137
链表是C语言编程中常用的数据结构，比如我们要建一个整数链表，一般可能这么定义： struct int_node { int val; struct int_node *next; }; 为了实现链表的插入、删除、遍历等功能，另外要再实现一系列函数，比如： void insert_node(struct int_node **head,...
linux内核之链表操作解析
YuZhiHui_No1的专栏
08-03 1991
本文只是对linux内核中的链表进行分析。内核版本是linux-2.6.32.63。文件在：linux内核/linux-2.6.32.63/include/linux/list.h。本文对list.h文件进行简要分析，有必要的地方还会以图进行说明。 代码分析：
Linux 链表
BigElt的博客
08-01 825
Linux的链表一般是双向循环链表，并且链表的节点也只有链表的前驱指针 prev 和 后继指针next。可以发现 linux 里链表结构体只定义了指针段的前驱指针 prev 和 后继指针 next，没有数据段。也就是说，在 linux 中使用 list_head 所定义的链表节点只有前趋后继这两个指针，只做为链表串联时的对接机构，不存储实际数据。为了方便理解，我们暂且把这种链表节点叫做“虚节点”。其实在实际使用过程中，链表的完整构建包括虚节点和宿主结构体两个部分。
RK3399平台开发系列讲解（内核入门篇）1.27、Linux中链表的使用与解析
内核笔记
08-21 3685
想象一下，有一个驱动程序管理多个设备，假设有5个设备，需要在驱动程序中跟踪每个设备，这就需要链表。 链表实际上有两种类型。 单链表。 双链表。
Linux的链表
crazy_koala的博客
09-04 272
什么是链表？ 链表可以想象成就是一条锁链，每一个环上面都可以刻些信息在上面，有新的信息要记录就拿出新的一环把信息刻上去然后打开锁链一头加上去，要使用上面的某一环取下来即可。把这些信息串起来方便管理(排序、增减、查找) 该怎么实现链表？ 比如说把一个班的学生用链表的形式连接起来，可以是这样： 但是以上的将next指向下一个节点(直接指向下一个student)的设计方法用起来没什么毛病，但...
Linux内核双向链表操作详解
"这篇文档详细分析了Linux内核中的双向链表，包括list和hlist两种类型，并探讨了它们的定义、初始化、增删节点、遍历等操作。...理解并熟练掌握这些链表操作对于深入理解Linux内核的工作原理至关重要。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值