01 C语言使用链表实现队列（Queue、FIFO）模块

01 C语言使用链表实现队列（Queue、FIFO）模块

作者	将狼才鲸
创建日期	2023-03-08

• Gitee源码仓库地址：C语言使用链表实现队列（Queue、FIFO）模块

• Linux原生的队列KFIFO一次只能操作一个队列，操作变长元素时，判断队列里元素个数不容易，在复杂场景下使用不方便；消息队列msgbuf的实现又太复杂，所以自行实现FIFO队列（queue）。

---

• 运行结果：

jim@DESKTOP-SVP3BEM MINGW64 /d/1_git/many-repositories/26_队列_缓存 (develop)
$ make
gcc -o demo queue_test.c queue.cjim@DESKTOP-SVP3BEM MINGW64 /d/1_git/many-repositories/26_队列_缓存 (develop)
$ make run
./demoput:
0
1
2
3
4
5
6
7get:
0: 0
1: 1
2: 2
3: 3
4: 4
5: 5
6: 6
7: 7jim@DESKTOP-SVP3BEM MINGW64 /d/1_git/many-repositories/26_队列_缓存 (develop)

• 源码展示：

• Makefile:

default:gcc -o demo queue_test.c queue.c
run:./demo
clean:rm demo

• queue_test.c

#include "queue.h"
#include <string.h>	/* memcpy */
#include <stdio.h>	/* printf */#define BUFFER_COUNT		8	/* 缓存总个数 */
#define BUFFER_UNIT_SIZE	32	/* 单个缓存的最大长度 *//* 单个缓存元素 */
typedef struct _queue_buf {queue_t queue;char *buf;
} queue_buf_t;static char g_buf[BUFFER_COUNT][BUFFER_UNIT_SIZE];	/* 开辟的缓存空间 */
static queue_buf_t queue_buf[BUFFER_COUNT];	/* 所有缓存节点 */int main()
{int i;queue_entry_t queue_entry;	/* 整个缓存队列的入口 */queue_entry_init(&queue_entry);	/* 初始化队列入口 *//* 初始化，将所有缓存放到已释放队列中 */for (i = 0; i < BUFFER_COUNT; i++) {queue_init(&queue_buf[i].queue);	/* 初始化每个队列元素 */queue_buf[i].buf = g_buf[i];queue_buf[i].queue.queue_entry = &queue_entry;queue_free(&queue_buf[i].queue);	/* 将所有缓存加入到已释放队列 */}/* 读取所有空闲缓存，赋值后存到已使用队列中 */i = 0;printf("\nput:\n");while (1) {queue_t *pq = queue_alloc(&queue_entry);if (!pq)break;queue_buf_t *pqbuf = container_of(pq, queue_buf_t, queue);memcpy(pqbuf->buf, &i, sizeof(int));	/* 赋值，递增序列 */printf("%d\n", i);i++;queue_put(NULL, pq, QUEUE_USED);}/* 读取所有已使用缓存，将里面内容打印出来，然后用完后重新放回已释放队列 */i = 0;printf("\nget:\n");while (1) {queue_t *pq = queue_get(&queue_entry, QUEUE_USED);if (!pq)break;queue_buf_t *pqbuf = container_of(pq, queue_buf_t, queue);printf("%d: %d\n", i, *(int *)pqbuf->buf);	/* 打印值，看是不是递增序列 */i++;queue_free(pq);}return 0;
}

• queue.h

/******************************************************************************* \brief	队列（FIFO、Queue、缓存）的实现* \details	不能单独使用，不包含实际的缓存数据，需要和上层结构体结合在一起使用* \remarks Linux原生的队列kfifo一次只能操作一个队列，操作变长元素时，判断队列里*			元素个数不容易，在复杂场景下使用不方便；消息队列msgbuf的实现又太复杂，*			所以在这里自行实现FIFO队列（queue）模块* \author	将狼才鲸* \date	2023-03-08******************************************************************************/#ifndef _QUEUE_H_
#define _QUEUE_H_#include "list.h"
#include <stddef.h>	/* NULL */#if 0//defined(TARGET_LINUX32) || defined(TARGET_LINUX64)	\|| defined(_MSC_VER) || defined(WIN32) || defined(_WIN64)/* 如果在操作系统之中，需要上锁 */
#	include <pthread.h>typedef pthread_mutex_t queue_lock_t;
#	define queue_lock_init(lock)	pthread_mutex_init((lock), NULL)
#	define queue_lock(lock)			pthread_mutex_lock((lock))
#	define queue_unlock(lock)		pthread_mutex_unlock((lock))
#	define queue_lock_destroy(lock)	pthread_mutex_destroy((lock))
#else	/* OS *//* 如果是裸机，无需上锁 */typedef int queue_lock_t;
#	define queue_lock_init(lock)
#	define queue_lock(lock)
#	define queue_unlock(lock)
#	define queue_lock_destroy(lock)
#endif	/* OS */enum {QUEUE_USED,	/* 已使用的队列 */QUEUE_FREE,	/* 已释放的队列 */QUEUE_MEMBER_MAX
};/* 一个队列的入口 */
typedef struct _queue_entry {struct list_head lists[QUEUE_MEMBER_MAX];	/* 队列中的已使用链表和已释放链表 */queue_lock_t lock;
} queue_entry_t;/* 一个队列节点 */
typedef struct _queue {struct list_head node;	/* 队列里的一个缓存对应的节点 *//* 该节点所属的队列（因为可能会同时存在多个队列，节点也可以跨队列拷贝，所以每个队列元素自身携带队列入口） */queue_entry_t *queue_entry;
} queue_t;/*** \brief	初始化队列入口*/
extern void queue_entry_init(queue_entry_t *pqe);/*** \brief	销毁队列* \param	pqe:	queue_entry_t * 队列入口*/
#define queue_entry_destroy(pqe) queue_lock_destroy((pqe)->lock)/*** \brief	初始化一个队列中的元素*/
extern void queue_init(queue_t *pq);/*** \brief	将队列元素释放到其它队列或自己队列的已使用入口或已释放入口* \param	line:	QUEUE_USED or QUEUE_FREE*/
extern int queue_put(queue_entry_t *pqe, queue_t *pq, int line);/*** \brief	从队列入口的已使用入口或已释放入口获取一个队列元素* \param	line:	QUEUE_USED or QUEUE_FREE*/
extern queue_t *queue_get(queue_entry_t *pqe, int line);/*** \brief	从队列中申请一个可用的缓存* \param	pge:	queue_entry_t * 队列入口指针* \return	queue_t *:	获取的队列节点*/
#define queue_alloc(pqe)	queue_get((pqe), QUEUE_FREE)/*** \brief	用完后将缓存进行释放* \param	pg:	queue_t * 一个缓存节点指针* \return	错误码*/
#define queue_free(pq)	queue_put(NULL, (pq), QUEUE_FREE)/*** \brief	预览已使用或者已释放队列中的第一个元素* \details	该元素预览后不会被弹出* \param	line:	QUEUE_USED or QUEUE_FREE*/
extern queue_t *queue_peek(queue_entry_t *pqe, int line);/*** \brief	获取已使用或者已释放队列中剩余的元素个数* \param	line:	QUEUE_USED or QUEUE_FREE*/
extern int queue_count(queue_entry_t *pqe, int line);#endif /* _QUEUE_H_ */

• queue.c

#include "queue.h"
#include "util_errno.h"/*** \brief	初始化队列入口，这时候整个队列是空的*/
void queue_entry_init(queue_entry_t *pqe)
{if (!pqe)return;queue_lock_init(&(pqe->lock));queue_lock(&(pqe->lock));for (int i = 0; i < QUEUE_MEMBER_MAX; i++) {init_list_head(&(pqe->lists[i]));}queue_unlock(&(pqe->lock));
}/*** \brief	初始化一个队列中的元素*/
void queue_init(queue_t *pq)
{if (!pq)return;init_list_head(&(pq->node));pq->queue_entry = NULL;
}/*** \brief	将队列元素释放到其它队列或自己队列的已使用入口或已释放入口* \param	line:	QUEUE_USED or QUEUE_FREE*/
int queue_put(queue_entry_t *pqe, queue_t *pq, int line)
{list_head_t *node, *head;if (!pq || line >= QUEUE_MEMBER_MAX)return -EPERM;if (!pqe)pqe = pq->queue_entry;if (!pqe)return -EPERM;queue_lock(&(pqe->lock));node = &(pq->node);			/* 当前队列节点 */head = &(pqe->lists[line]);	/* 队列中要要获取或者释放的入口 */list_del_init(node);		/* 删除node原来的链表，并重新初始化node这个链表 */list_add_tail(node, head);	/* 加到链表尾，先入先出 */queue_unlock(&(pqe->lock));return 0;}/*** \brief	从队列入口的已使用入口或已释放入口获取一个队列元素* \param	line:	QUEUE_USED or QUEUE_FREE*/
queue_t *queue_get(queue_entry_t *pqe, int line)
{queue_t *pq;list_head_t *node, *head;if (!pqe || line >= QUEUE_MEMBER_MAX)return NULL;queue_lock(&(pqe->lock));head = &(pqe->lists[line]);	/* 队列中要要获取或者释放的入口 */pq = NULL;if (!list_empty_careful(head)) {pq = list_first_entry(head, queue_t, node);	/* 获取队列的第一个元素 */node = &(pq->node);list_del_init(node);	/* 销毁该元素 */}queue_unlock(&(pqe->lock));return pq;
}/*** \brief	预览已使用或者已释放队列中的第一个元素* \details	该元素预览后不会被弹出* \param	line:	QUEUE_USED or QUEUE_FREE*/
queue_t *queue_peek(queue_entry_t *pqe, int line)
{queue_t *pq;list_head_t *head;if (!pqe || line >= QUEUE_MEMBER_MAX)return NULL;queue_lock(&(pqe->lock));head = &(pqe->lists[line]);	/* 队列中要要获取或者释放的入口 */pq = NULL;if (!list_empty_careful(head)) {pq = list_first_entry(head, queue_t, node);	/* 获取队列的第一个元素 */}queue_unlock(&(pqe->lock));return pq;
}/*** \brief	获取已使用或者已释放队列中剩余的元素个数* \param	line:	QUEUE_USED or QUEUE_FREE*/
int queue_count(queue_entry_t *pqe, int line)
{int count = 0;list_head_t *node, *n, *head;if (!pqe || line >= QUEUE_MEMBER_MAX)return -EPERM;queue_lock(&(pqe->lock));head = &(pqe->lists[line]);	/* 队列中要要获取或者释放的入口 */if (!list_empty_careful(head)) {list_for_each_safe(node, n, head) {count++;}}queue_unlock(&(pqe->lock));return count;
}

• list.h

/******************************************************************************* \brief	双向链表（不直接包含数据）* \details	约定链表入口地址本身是尾(最后弹出)地址，head->next是头(最先弹出)地址；*			链表入口地址本身是无效的节点，即使弹出所有的节点，也只弹到入口之前*			的节点为止；*			一个双向链表实际上就是一个最简单的FIFO，就一个先进先出功能* \note	File format: UTF-8，中文编码：UTF-8；*			本链表不包含具体的数据，数据须在包含本链表成员的上层结构体中进行操作，*			也就是说本链表不能单独使用，必须和上层模块联用；*			本模块当前必须在gcc中才能编译通过，在msvc中不行，要想在Windows中使用*			需要去除typeof关键字，并在参数中增加一个变量；* \remarks	基于linux_6.1-rc4\scripts\kconfig\list.h，*			该源文件是从include\linux\list.h简化而来；*			Linux kernel源码中其它可供参考的链表还有：*			linux_6.1-rc4\scripts\kconfig\list.h  最好用*			linux_6.1-rc4\tools\usb\usbip\libsrc\list.h  可用*			linux_6.1-rc4\scripts\mod\list.h  可用*			linux_6.1-rc4\tools\firewire\list.h  另一种写法*			linux_6.1-rc4\tools\include\linux\list.h  太全*			linux_6.1-rc4\include\linux\list.h  最全* \author	中文注释：将狼才鲸* \date	2023-03-05******************************************************************************/#ifndef LIST_H
#define LIST_H#include <stddef.h>	/* offsetof size_t *//*** \brief	双向链表结构体*/
typedef struct list_head {struct list_head *next, *prev;
} list_head_t;/*** \brief	定义一个链表节点并赋初值，只是简化写法* \details	这个接口一般用不到，实际使用时会用init_list_head()* \param	name:	要定义的链表节点名*/
#define LIST_HEAD_INIT(name) { &(name), &(name) }
#define LIST_HEAD(name)	\struct list_head name = LIST_HEAD_INIT(name)/** 为链表的实际应用留下扩展接口 *//*** \brief	获取一个结构体中的某个成员相对于结构体首地址的偏移量* \details	用于操作链表上层的带有有效数据+链表成员的结构体* \remarks	在stddef.h中已有该宏定义函数* \param	TYPE:	上层结构体名称* \param	MEMBER:	结构体中要查找偏移量的成员，一般这个成员是链表结构体指针* \return	结构体成员相对于结构体首地址的偏移量*/
#undef offsetof
#define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)/*** \brief	从结构体中某一成员地址逆推出该结构体的首地址* \details	用于操作链表上层的带有有效数据+链表成员的结构体* \note	typeof是Linux GNU C(GCC)中扩展的关键字，从定义的变量名逆推出该变量的*			类型，如int a; typeof(a) b;中的第二句与int b;的效果相同；*			在Windows等其它编译器中编译会不通过；*			原始定义在include/linux/kernel.h中* \param	ptr:	需要逆推的上层结构体中的某个成员地址，一般是链表成员的地址* \param	type:	上层结构体的类型名，一般该类型是结构体* \param	member:	上层结构体中成员地址的名称，也就是a.b或a->b里面的这个b*/
#define container_of(ptr, type, member) ({					\const typeof( ((type *)0)->member ) *__mptr = (ptr);	\(type *)( (char *)__mptr - offsetof(type,member) );})/*** \brief	获取已嵌入链表结构体的上层结构体地址* \param	ptr:	上层结构体中的&struct list_head指针* \param	type:	嵌入了list_head成员的上层结构体类型名* \param	member:	上层结构体中list_head所属的名称*/
#define list_entry(ptr, type, member)	\container_of(ptr, type, member)/*** \brief	获取链表入口所在链表第一个元素对应的上层结构体地址* \note	调用前必须确保该链表非空* \param	ptr:	上层结构体中的&struct list_head指针，该指针是个链表入口* \param	type:	嵌入了list_head成员的上层结构体类型名* \param	member:	上层结构体中list_head所属的名称*/
#define list_first_entry(ptr, type, member) \list_entry((ptr)->next, type, member)/*** \brief	循环整个链表时的for(;x;x)语句（循环时不能删除当前链表节点）* \param	pos:	当前循环到的节点，是个临时变量* \param	head:	链表入口*/
#define list_for_each(pos, head)	\for (pos = (head)->next; pos != (head); pos = pos->next)/*** \brief	循环整个链表时的for(;x;x)语句（循环时可以删除当前链表节点）* \param	pos:	当前循环到的节点，是个临时变量* \param	n:		作为临时变量的节点* \param	head:	链表入口*/
#define list_for_each_safe(pos, n, head)					\for (pos = (head)->next, n = pos->next; pos != (head);	\pos = n, n = pos->next)/*** \brief	在上层结构体的基础上循环整个链表时的for(;x;x)语句（循环时不能删除当前链表节点）* \details	虽然是在上层带有效数据的结构体指针上进行循环，但是实际实现时*			是以其中的链表结构体作为依据* \param	pos:	要循环的上层结构体临时变量，该结构体中带有链表成员，*					pos值用作变量，本身不必预先赋值，但是循环时不能删除它* \param	head:	上层结构体中的list_head成员的地址* \param	member:	上层结构体中的list_head成员的名称* \note	head虽然是链表入口地址，但本身是尾(最后弹出)地址，head->next是头(最先弹出)地址；*/
#define list_for_each_entry(pos, head, member)					\for (pos = list_entry((head)->next, typeof(*pos), member);	\&pos->member != (head);								\pos = list_entry(pos->member.next, typeof(*pos), member))/*** \brief	在上层结构体的基础上循环整个链表时的for(;x;x)语句（支持循环时删除当前链表节点）* \details	虽然是在上层带有效数据的结构体指针上进行循环，但是实际实现时*			是以其中的链表结构体作为依据* \param	pos:	要循环的上层结构体临时变量，该结构体中带有链表成员，*					pos值用作变量，本身不必预先赋值，循环时可以删除它* \param	n:		上层结构体临时变量* \param	head:	上层结构体中的list_head成员的地址* \param	member:	上层结构体中的list_head成员的名称* \note	head虽然是链表入口地址，但本身是尾(最后弹出)地址，head->next是头(最先弹出)地址；*/
#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))/* 因为下面都是内联函数，所以无需放在.c中，放在.h中即可，编译时不会重复编译，而是会像宏定义一样内联展开*//** 私有函数 *//*** \brief	在链表序列中插入一个链表节点（已知要插入位置的之前和之后的节点）* \param	_new:	要插入的链表节点* \param	prev:	插入点前方的链表节点* \param	next:	插入点后方的链表节点*/
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;
}/*** \brief	在链表序列中删除一个链表节点（已知要删除位置的之前和之后的节点）* \param	prev:	删除点前方的链表节点* \param	next:	删除点后方的链表节点*/
static inline void __list_del(struct list_head *prev, struct list_head *next)
{next->prev = prev;prev->next = next;
}/*** \brief	在链表序列中删除一个链表入口节点* \param	entry:	要删除的链表节点*/
static inline void __list_del_entry(struct list_head *entry)
{__list_del(entry->prev, entry->next);
}/* 接口函数 *//*** \brief	初始化一个链表节点* \param	list:	要初始化的链表指针*/
static inline void init_list_head(struct list_head *list)
{list->next = list;list->prev = list;
}/*** \brief	在链表序列中删除一个链表入口节点，并重新初始化这个链表入口* \param	entry:	要删除的链表节点*/
static inline void list_del_init(struct list_head *entry)
{__list_del_entry(entry);init_list_head(entry);
}/*** \brief	判断链表是否为空* \param	head:	要判断的链表指针*/
static inline int list_empty(const struct list_head *head)
{return head->next == head;
}/*** \brief	判断链表是否为空（在多核CPU上较安全）* \param	head:	要判断的链表指针* \return	为空时返回真，不为空返回假*/
static inline int list_empty_careful(const struct list_head *head)
{struct list_head *next = head->next;return (next == head) && (next == head->prev);
}/*** \brief	将一个链表节点插入到一条链表的头部，先入后出* \param	new:	要插入的链表节点* \param	head:	要加入的那条链表的链表入口*					（链表入口所属的那个节点是链表尾，head->next是链表头）*/
static inline void list_add(struct list_head *new, struct list_head *head)
{__list_add(new, head, head->next);
}/*** \brief	将一个链表节点插入到链表尾，先入先出* \details	也就是更新了这条链表入口节点的前一个（入口并不是链表头）* \param	_new:	要插入的链表节点* \param	head:	要加入的那条链表的链表入口*					（链表入口所属的那个节点是链表尾，head->next是链表头）*/
static inline void list_add_tail(struct list_head *_new, struct list_head *head)
{__list_add(_new, head->prev, head);
}/* 用于让销毁的链表节点指向一个未使用地址 */
#define LIST_POISON	((void *)0x0)/*** \brief	将一个链表节点从它自己所属的这条链表中删除* \param	entry:	要删除的链表节点*/
static inline void list_del(struct list_head *entry)
{__list_del(entry->prev, entry->next);entry->next = (struct list_head *)LIST_POISON;entry->prev = (struct list_head *)LIST_POISON;
}#endif /* LIST_H */

• util_errno.h

/******************************************************************************* \brief	错误码* \note	基于linux_6.1-rc4\include\uapi\asm-generic\errno-base.h*				linux_6.1-rc4\tools\arch\alpha\include\uapi\asm\errno.h*				linux_6.1-rc4\include\linux\errno.h* \author	中文注释：将狼才鲸* \date	2023-03-04******************************************************************************/#ifndef _UTIL_ERRNO_H_
#define _UTIL_ERRNO_H_/*********************************** 宏定义 ***********************************/
#define	EPERM		 1	/* 操作不允许 */
#define	ENOENT		 2	/* 没有此文件或目录 */
#define	ESRCH		 3	/* 进程不存在 */
#define	EINTR		 4	/* 系统调用被中断，Interrupted system call */#define	EIO			 5	/* 读写错误，I/O error */
#define	ENXIO		 6	/* 没有此设备或地址 */
#define	E2BIG		 7	/* 参数列表太长 */
#define	ENOEXEC		 8	/* 执行格式错误，Exec format error */
#define	EBADF		 9	/* 错误的文件号，Bad file number */
#define	ECHILD		10	/* 没有该子进程，No child processes */#define	ENOMEM		12	/* 内存不足，Out of memory */
#define	EACCES		13	/* 没有权限 */
#define	EFAULT		14	/* 非法地址，Bad address */
#define	ENOTBLK		15	/* 没有块设备，Block device required */
#define	EBUSY		16	/* 设备或资源忙，Device or resource busy */
#define	EEXIST		17	/* 文件已存在，File exists */
#define	EXDEV		18	/* 链接不在同一个设备，Cross-device link */
#define	ENODEV		19	/* 无此设备，No such device */
#define	ENOTDIR		20	/* 不是文件夹，Not a directory */
#define	EISDIR		21	/* 是文件夹，Is a directory */#define	EINVAL		22	/* 参数非法，Invalid argument */
#define	ENFILE		23	/* 文件表溢出，File table overflow */
#define	EMFILE		24	/* 文件打开太多，Too many open files */
#define	ENOTTY		25	/* 不是字符设备，Not a typewriter */
#define	ETXTBSY		26	/* 文本文件忙，Text file busy */
#define	EFBIG		27	/* 文件太大，File too large */
#define	ENOSPC		28	/* 设备空间不足，No space left on device */
#define	ESPIPE		29	/* 非法跳转，Illegal seek */
#define	EROFS		30	/* 文件系统只读，Read-only file system */
#define	EMLINK		31	/* 链接太多，Too many links */
#define	EPIPE		32	/* 管道损坏，Broken pipe */
#define	EDOM		33	/* 参数超出函数范围，Math argument out of domain of func */
#define	ERANGE		34	/* 结果不能表示，超出范围 */#define	EAGAIN		35	/* 请重试，Try again */
#define	EWOULDBLOCK	EAGAIN	/* 操作被阻塞，Operation would block */
#define	EINPROGRESS	36	/* 操作正在处理中，Operation now in progress */
#define	EALREADY	37	/* 操作已就绪，Operation already in progress */
#define	ENOTSOCK	38	/* Socket operation on non-socket */
#define	EDESTADDRREQ	39	/* 需要目的地址，Destination address required */
#define	EMSGSIZE	40	/* 消息太长，Message too long */
#define	EPROTOTYPE	41	/* 协议类型错误，Protocol wrong type for socket */
#define	ENOPROTOOPT	42	/* 协议不可用，Protocol not available */
#define	EPROTONOSUPPORT	43	/* 协议不支持，Protocol not supported */
#define	ESOCKTNOSUPPORT	44	/* Socket类型不支持，Socket type not supported */
#define	EOPNOTSUPP	45	/* 在该传输端点上操作不支持，Operation not supported on transport endpoint */
#define	EPFNOSUPPORT	46	/* 协议族不支持，Protocol family not supported */
#define	EAFNOSUPPORT	47	/* 地址族不支持，Address family not supported by protocol */
#define	EADDRINUSE	48	/* 地址已在使用，Address already in use */
#define	EADDRNOTAVAIL	49	/* 所请求的地址无法分配，Cannot assign requested address */
#define	ENETDOWN	50	/* 网络已断开，Network is down */
#define	ENETUNREACH	51	/* 网络无法访问，Network is unreachable */
#define	ENETRESET	52	/* 因为复位导致网络连接中断，Network dropped connection because of reset */
#define	ECONNABORTED	53	/* 连接中止，Software caused connection abort */
#define	ECONNRESET	54	/* 连接复位，Connection reset by peer */#define	ENOBUFS		55	/* 没有可用的缓存，No buffer space available */
#define	EISCONN		56	/* 传输端点已连接，Transport endpoint is already connected */
#define	ENOTCONN	57	/* 传输端点未连接，Transport endpoint is not connected */
#define	ESHUTDOWN	58	/* 传输端点关闭后无法发送，Cannot send after transport endpoint shutdown */
#define	ETOOMANYREFS	59	/* 引用太多无法拼接，Too many references: cannot splice */
#define	ETIMEDOUT	60	/* 连接超时，Connection timed out */
#define	ECONNREFUSED	61	/* 连接被拒绝，Connection refused */
#define	ELOOP		62	/* 符号连接冲突太多 */
#define	ENAMETOOLONG	63	/* 文件名太长，File name too long */
#define	EHOSTDOWN	64	/* 主机已关闭，Host is down */
#define	EHOSTUNREACH	65	/* 主机无路由，No route to host */
#define	ENOTEMPTY	66	/* 文件夹非空，Directory not empty */
#define	EUSERS		68	/* 用户太多，Too many users */#define	EDQUOT		69	/* 超出界限，Quota exceeded */
#define	ESTALE		70	/* 旧的文件句柄，Stale file handle */
#define	EREMOTE		71	/* 目标已移除，Object is remote */
#define	ENOLCK		77	/* 没有可用的锁，No record locks available */
#define	ENOSYS		78	/* 函数未实现 */
#define	ENOMSG		80	/* 没有所需类型的消息，No message of desired type */
#define	EIDRM		81	/* 标识符已删除，Identifier removed */
#define	ENOSR		82	/* 没有流资源，Out of streams resources */
#define	ETIME		83	/* 定时器超时，Timer expired */
#define	EBADMSG		84	/* 不是数据消息 */
#define	EPROTO		85	/* 协议错误，Protocol error */#define	ENODATA		86	/* 没有可用的数据，No data available */
#define	ENOSTR		87	/* 不是流设备，Device not a stream */
#define	ENOPKG		92	/* 包未安装，Package not installed */
#define	EILSEQ		116	/* 字节序列非法Illegal byte sequence */
#define	ECHRNG		88	/* 通道号超出范围，Channel number out of range */
#define	EL2NSYNC	89	/* 级别2未同步，Level 2 not synchronized */
#define	EL3HLT		90	/* 级别3中止，Level 3 halted */
#define	EL3RST		91	/* 级别3复位，Level 3 reset */
#define	ELNRNG		93	/* 链接号超出范围，Link number out of range */
#define	EUNATCH		94	/* 协议驱动未附加，Protocol driver not attached */
#define	ENOCSI		95	/* CSI结构不可用，No CSI structure available */
#define	EL2HLT		96	/* 级别2中止，Level 2 halted */
#define	EBADE		97	/* 无效的交换 */
#define	EBADR		98	/* 无效的请求描述符 */
#define	EXFULL		99	/* 交换已满，Exchange full */
#define	ENOANO		100	/* 没有正极，No anode */
#define	EBADRQC		101	/* 请求码无效，Invalid request code */
#define	EBADSLT		102	/* Invalid slot */
#define	EDEADLK		11	/* 将发生资源死锁，Resource deadlock would occur */
#define	EDEADLOCK	EDEADLK	/* 发生死锁 */
#define	EBFONT		104	/* 字库文件格式错误，Bad font file format */
#define	ENONET		105	/* 设备未联网，Machine is not on the network */
#define	ENOLINK		106	/* 链路已断，Link has been severed */
#define	EADV		107	/* 广播错误，Advertise error */
#define	ESRMNT		108	/* 挂载错误，Srmount error */
#define	ECOMM		109	/* 发送时通信错误，Communication error on send */
#define	EMULTIHOP	110	/* 尝试多跳，Multihop attempted */
#define	EDOTDOT		111	/* RFS specific error */#define	EOVERFLOW	112	/* 参数溢出，对于已定义的数据类型来说值太大 */
#define	ENOTUNIQ	113	/* 名称在网络上不唯一，Name not unique on network */
#define	EBADFD		114	/* 文件描述符处于非法状态，File descriptor in bad state */
#define	EREMCHG		115	/* 远端地址已改变，Remote address changed */
#define	EUCLEAN		117	/* 结构需要清理，Structure needs cleaning */
#define	ENOTNAM		118	/* 不是由XENIX命名的类型文件，Not a XENIX named type file */
#define	ENAVAIL		119	/* 没有可用的XENIX信号量，No XENIX semaphores available */
#define	EISNAM		120	/* 是一个已命名的文件，Is a named type file */
#define	EREMOTEIO	121	/* 远端读写错误，Remote I/O error */
#define	ELIBACC		122	/* 无法访问所需的共享库，Can not access a needed shared library */
#define	ELIBBAD		123	/* 访问的共享库已损坏，Accessing a corrupted shared library */
#define	ELIBSCN		124	/* a.out中的.lib部分已损坏，.lib section in a.out corrupted */
#define	ELIBMAX		125	/* 试图链接的共享库太多，Attempting to link in too many shared libraries */
#define	ELIBEXEC	126	/* 不能直接运行共享库，Cannot exec a shared library directly */#define	ERESTART	127	/* 应重新启动已中断的系统调用，Interrupted system call should be restarted */
#define	ESTRPIPE	128	/* 流管道错误，Streams pipe error */
#define ENOMEDIUM	129	/* 找不到介质，No medium found */
#define EMEDIUMTYPE	130	/* 错误的介质类型，Wrong medium type */#define	ECANCELED	131	/* 操作已取消，Operation Cancelled */
#define	ENOKEY		132	/* 所需键值不可用，Required key not available */
#define	EKEYEXPIRED	133	/* 密钥已过期，Key has expired */
#define	EKEYREVOKED	134	/* 密钥已吊销，Key has been revoked */
#define	EKEYREJECTED	135	/* 密钥被服务拒绝，Key was rejected by service */
#define	EOWNERDEAD	136	/* 拥有者已注销，Owner died */
#define	ENOTRECOVERABLE	137	/* 状态不可恢复，State not recoverable */
#define	ERFKILL		138	/* Operation not possible due to RF-kill */
#define EHWPOISON	139	/* 内存页硬件错误，Memory page has hardware error */
#define ERESTARTSYS	512	/* 系统重启 */
#define ERESTARTNOINTR	513	/* 无中断的系统重启 */
#define ERESTARTNOHAND	514	/* 无处理句柄的重启，restart if no handler.. */
#define ENOIOCTLCMD	515	/* 命令不存在，No ioctl command */
#define ERESTART_RESTARTBLOCK 516 /* 系统调用的重启，restart by calling sys_restart_syscall */
#define EPROBE_DEFER	517	/* 驱动需要重新探测，Driver requests probe retry */
#define EOPENSTALE	518	/* 打开时发现了一个旧入口，open found a stale dentry */#define ENOPARAM	519	/* 参数不支持，Parameter not supported */
#define EBADHANDLE	521	/* 非法的NFS文件句柄，Illegal NFS file handle */
#define ENOTSYNC	522	/* 更新同步不匹配，Update synchronization mismatch */
#define EBADCOOKIE	523	/* Cookie太陈旧，Cookie is stale */#define ENOTSUPP	524	/* 操作不支持，Operation is not supported */
#define ETOOSMALL	525	/* 缓存或请求太小，Buffer or request is too small */
#define ESERVERFAULT	526	/* 无法翻译，An untranslatable error occurred */
#define EBADTYPE	527	/* 服务器不支持的类型，Type not supported by server */
#define EJUKEBOX	528	/* 请求超时，Request initiated, but will not complete before timeout */
#define EIOCBQUEUED	529	/* io回调已推入队列，将得到完成标志，iocb queued, will get completion event */
#define ERECALLCONFLICT	530	/* 回调状态冲突，conflict with recalled state */
#define ENOGRACE	531	/* 拒绝取回NFS文件锁，NFS file lock reclaim refused */#endif /* _UTIL_ERRNO_H_ *//*********************************** 文件尾 ***********************************/