devextras.h
上传用户:wealth48
上传日期:2022-06-24
资源大小:1701k
文件大小:6k
源码类别:

uCOS

开发平台:

C/C++

  1. /*
  2.  * YAFFS: Yet another FFS. A NAND-flash specific file system. 
  3.  * devextras.h
  4.  *
  5.  * Copyright (C) 2002 Aleph One Ltd.
  6.  *   for Toby Churchill Ltd and Brightstar Engineering
  7.  *
  8.  * Created by Charles Manning <charles@aleph1.co.uk>
  9.  *
  10.  * This program is free software; you can redistribute it and/or modify
  11.  * it under the terms of the GNU Lesser General Public License version 2.1 as
  12.  * published by the Free Software Foundation.
  13.  *
  14.  * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL.
  15.  *
  16.  * This file is just holds extra declarations used during development.
  17.  * Most of these are from kernel includes placed here so we can use them in 
  18.  * applications.
  19.  *
  20.  * $Id: devextras.h,v 1.5 2002/09/27 20:50:50 charles Exp $
  21.  *
  22.  */
  23.  
  24. #ifndef __EXTRAS_H__
  25. #define __EXTRAS_H__
  26. #define __inline__ __inline
  27. typedef unsigned char   __u8;
  28. typedef unsigned short  __u16;
  29. typedef unsigned        __u32;
  30. /*
  31.  * Simple doubly linked list implementation.
  32.  *
  33.  * Some of the internal functions ("__xxx") are useful when
  34.  * manipulating whole lists rather than single entries, as
  35.  * sometimes we already know the next/prev entries and we can
  36.  * generate better code by using them directly rather than
  37.  * using the generic single-entry routines.
  38.  */
  39.  
  40.  #define prefetch(x) 1
  41.  
  42. struct list_head {
  43. struct list_head *next, *prev;
  44. };
  45. #define LIST_HEAD_INIT(name) { &(name), &(name) }
  46. #define LIST_HEAD(name) 
  47. struct list_head name = LIST_HEAD_INIT(name)
  48. #define INIT_LIST_HEAD(ptr) do { 
  49. (ptr)->next = (ptr); (ptr)->prev = (ptr); 
  50. } while (0)
  51. /*
  52.  * Insert a new entry between two known consecutive entries.
  53.  *
  54.  * This is only for internal list manipulation where we know
  55.  * the prev/next entries already!
  56.  */
  57. static __inline__ void __list_add(struct list_head * new,
  58. struct list_head * prev,
  59. struct list_head * next)
  60. {
  61. next->prev = new;
  62. new->next = next;
  63. new->prev = prev;
  64. prev->next = new;
  65. }
  66. /**
  67.  * list_add - add a new entry
  68.  * @new: new entry to be added
  69.  * @head: list head to add it after
  70.  *
  71.  * Insert a new entry after the specified head.
  72.  * This is good for implementing stacks.
  73.  */
  74. static __inline__ void list_add(struct list_head *new, struct list_head *head)
  75. {
  76. __list_add(new, head, head->next);
  77. }
  78. /**
  79.  * list_add_tail - add a new entry
  80.  * @new: new entry to be added
  81.  * @head: list head to add it before
  82.  *
  83.  * Insert a new entry before the specified head.
  84.  * This is useful for implementing queues.
  85.  */
  86. static __inline__ void list_add_tail(struct list_head *new, struct list_head *head)
  87. {
  88. __list_add(new, head->prev, head);
  89. }
  90. /*
  91.  * Delete a list entry by making the prev/next entries
  92.  * point to each other.
  93.  *
  94.  * This is only for internal list manipulation where we know
  95.  * the prev/next entries already!
  96.  */
  97. static __inline__ void __list_del(struct list_head * prev,
  98.   struct list_head * next)
  99. {
  100. next->prev = prev;
  101. prev->next = next;
  102. }
  103. /**
  104.  * list_del - deletes entry from list.
  105.  * @entry: the element to delete from the list.
  106.  * Note: list_empty on entry does not return true after this, the entry is in an undefined state.
  107.  */
  108. static __inline__ void list_del(struct list_head *entry)
  109. {
  110. __list_del(entry->prev, entry->next);
  111. }
  112. /**
  113.  * list_del_init - deletes entry from list and reinitialize it.
  114.  * @entry: the element to delete from the list.
  115.  */
  116. static __inline__ void list_del_init(struct list_head *entry)
  117. {
  118. __list_del(entry->prev, entry->next);
  119. INIT_LIST_HEAD(entry);
  120. }
  121. /**
  122.  * list_empty - tests whether a list is empty
  123.  * @head: the list to test.
  124.  */
  125. static __inline__ int list_empty(struct list_head *head)
  126. {
  127. return head->next == head;
  128. }
  129. /**
  130.  * list_splice - join two lists
  131.  * @list: the new list to add.
  132.  * @head: the place to add it in the first list.
  133.  */
  134. static __inline__ void list_splice(struct list_head *list, struct list_head *head)
  135. {
  136. struct list_head *first = list->next;
  137. if (first != list) {
  138. struct list_head *last = list->prev;
  139. struct list_head *at = head->next;
  140. first->prev = head;
  141. head->next = first;
  142. last->next = at;
  143. at->prev = last;
  144. }
  145. }
  146. /**
  147.  * list_entry - get the struct for this entry
  148.  * @ptr: the &struct list_head pointer.
  149.  * @type: the type of the struct this is embedded in.
  150.  * @member: the name of the list_struct within the struct.
  151.  */
  152. #define list_entry(ptr, type, member) 
  153. ((type *)((char *)(ptr)-(unsigned long)(&((type *)0)->member)))
  154. /**
  155.  * list_for_each - iterate over a list
  156.  * @pos: the &struct list_head to use as a loop counter.
  157.  * @head: the head for your list.
  158.  */
  159. #define list_for_each(pos, head) 
  160. for (pos = (head)->next, prefetch(pos->next); pos != (head); 
  161.          pos = pos->next, prefetch(pos->next))
  162. /**
  163.  * list_for_each_safe - iterate over a list safe against removal of list entry
  164.  * @pos: the &struct list_head to use as a loop counter.
  165.  * @n: another &struct list_head to use as temporary storage
  166.  * @head: the head for your list.
  167.  */
  168. #define list_for_each_safe(pos, n, head) 
  169. for (pos = (head)->next, n = pos->next; pos != (head); 
  170. pos = n, n = pos->next)
  171. /*
  172.  * File types
  173.  */
  174. #define DT_UNKNOWN 0
  175. #define DT_FIFO 1
  176. #define DT_CHR 2
  177. #define DT_DIR 4
  178. #define DT_BLK 6
  179. #define DT_REG 8
  180. #define DT_LNK 10
  181. #define DT_SOCK 12
  182. #define DT_WHT 14
  183. /*
  184.  * Attribute flags.  These should be or-ed together to figure out what
  185.  * has been changed!
  186.  */
  187. #define ATTR_MODE 1
  188. #define ATTR_UID 2
  189. #define ATTR_GID 4
  190. #define ATTR_SIZE 8
  191. #define ATTR_ATIME 16
  192. #define ATTR_MTIME 32
  193. #define ATTR_CTIME 64
  194. #define ATTR_ATIME_SET 128
  195. #define ATTR_MTIME_SET 256
  196. #define ATTR_FORCE 512 /* Not a change, but a change it */
  197. #define ATTR_ATTR_FLAG 1024
  198. struct iattr {
  199. unsigned int ia_valid;
  200. unsigned ia_mode;
  201. unsigned ia_uid;
  202. unsigned ia_gid;
  203. unsigned ia_size;
  204. unsigned ia_atime;
  205. unsigned ia_mtime;
  206. unsigned ia_ctime;
  207. unsigned int ia_attr_flags;
  208. };
  209. #endif