1 files changed, 157 insertions, 74 deletions

diff --git a/target/linux/generic-2.6/files/fs/yaffs2/devextras.h b/target/linux/generic-2.6/files/fs/yaffs2/devextras.h
index 55c31219d3..fcf2690a56 100644
--- a/target/linux/generic-2.6/files/fs/yaffs2/devextras.h
+++ b/target/linux/generic-2.6/files/fs/yaffs2/devextras.h
@@ -14,117 +14,194 @@
  */
 
 /*
- * This file is just holds extra declarations of macros that would normally
- * be providesd in the Linux kernel. These macros have been written from
- * scratch but are functionally equivalent to the Linux ones.
+ * This file is just holds extra declarations used during development.
+ * Most of these are from kernel includes placed here so we can use them in
+ * applications.
  *
  */
 
 #ifndef __EXTRAS_H__
 #define __EXTRAS_H__
 
+#if defined WIN32
+#define __inline__ __inline
+#define new newHack
+#endif
+
+#if !(defined __KERNEL__) || (defined WIN32)
 
-#if !(defined __KERNEL__)
+/* User space defines */
 
-/* Definition of types */
 typedef unsigned char __u8;
 typedef unsigned short __u16;
 typedef unsigned __u32;
 
-#endif
-
 /*
- * This is a simple doubly linked list implementation that matches the 
- * way the Linux kernel doubly linked list implementation works.
+ * Simple doubly linked list implementation.
+ *
+ * Some of the internal functions ("__xxx") are useful when
+ * manipulating whole lists rather than single entries, as
+ * sometimes we already know the next/prev entries and we can
+ * generate better code by using them directly rather than
+ * using the generic single-entry routines.
  */
 
-struct ylist_head {
-	struct ylist_head *next; /* next in chain */
-	struct ylist_head *prev; /* previous in chain */
+#define prefetch(x) 1
+
+struct list_head {
+	struct list_head *next, *prev;
 };
 
+#define LIST_HEAD_INIT(name) { &(name), &(name) }
 
-/* Initialise a list head to an empty list */
-#define YINIT_LIST_HEAD(p) \
-do { \
- (p)->next = (p);\
- (p)->prev = (p); \
-} while(0)
+#define LIST_HEAD(name) \
+	struct list_head name = LIST_HEAD_INIT(name)
 
+#define INIT_LIST_HEAD(ptr) do { \
+	(ptr)->next = (ptr); (ptr)->prev = (ptr); \
+} while (0)
 
-/* Add an element to a list */
-static __inline__ void ylist_add(struct ylist_head *newEntry, 
-				 struct ylist_head *list)
+/*
+ * Insert a new entry between two known consecutive entries.
+ *
+ * This is only for internal list manipulation where we know
+ * the prev/next entries already!
+ */
+static __inline__ void __list_add(struct list_head *new,
+				  struct list_head *prev,
+				  struct list_head *next)
 {
-	struct ylist_head *listNext = list->next;
-	
-	list->next = newEntry;
-	newEntry->prev = list;
-	newEntry->next = listNext;
-	listNext->prev = newEntry;
-	
+	next->prev = new;
+	new->next = next;
+	new->prev = prev;
+	prev->next = new;
 }
 
-
-/* Take an element out of its current list, with or without
- * reinitialising the links.of the entry*/
-static __inline__ void ylist_del(struct ylist_head *entry)
+/**
+ * list_add - add a new entry
+ * @new: new entry to be added
+ * @head: list head to add it after
+ *
+ * Insert a new entry after the specified head.
+ * This is good for implementing stacks.
+ */
+static __inline__ void list_add(struct list_head *new, struct list_head *head)
 {
-	struct ylist_head *listNext = entry->next;
-	struct ylist_head *listPrev = entry->prev;
-	
-	listNext->prev = listPrev;
-	listPrev->next = listNext;
-	
+	__list_add(new, head, head->next);
 }
 
-static __inline__ void ylist_del_init(struct ylist_head *entry)
+/**
+ * list_add_tail - add a new entry
+ * @new: new entry to be added
+ * @head: list head to add it before
+ *
+ * Insert a new entry before the specified head.
+ * This is useful for implementing queues.
+ */
+static __inline__ void list_add_tail(struct list_head *new,
+				     struct list_head *head)
 {
-	ylist_del(entry);
-	entry->next = entry->prev = entry;
+	__list_add(new, head->prev, head);
 }
 
-
-/* Test if the list is empty */
-static __inline__ int ylist_empty(struct ylist_head *entry)
+/*
+ * Delete a list entry by making the prev/next entries
+ * point to each other.
+ *
+ * This is only for internal list manipulation where we know
+ * the prev/next entries already!
+ */
+static __inline__ void __list_del(struct list_head *prev,
+				  struct list_head *next)
 {
-	return (entry->next == entry);
+	next->prev = prev;
+	prev->next = next;
 }
 
-
-/* ylist_entry takes a pointer to a list entry and offsets it to that
- * we can find a pointer to the object it is embedded in.
+/**
+ * list_del - deletes entry from list.
+ * @entry: the element to delete from the list.
+ * Note: list_empty on entry does not return true after this, the entry is
+ * in an undefined state.
  */
- 
- 
-#define ylist_entry(entry, type, member) \
-	((type *)((char *)(entry)-(unsigned long)(&((type *)NULL)->member)))
-
+static __inline__ void list_del(struct list_head *entry)
+{
+	__list_del(entry->prev, entry->next);
+}
 
-/* ylist_for_each and list_for_each_safe  iterate over lists.
- * ylist_for_each_safe uses temporary storage to make the list delete safe
+/**
+ * list_del_init - deletes entry from list and reinitialize it.
+ * @entry: the element to delete from the list.
  */
+static __inline__ void list_del_init(struct list_head *entry)
+{
+	__list_del(entry->prev, entry->next);
+	INIT_LIST_HEAD(entry);
+}
 
-#define ylist_for_each(itervar, list) \
-	for (itervar = (list)->next; itervar != (list); itervar = itervar->next )
-
-#define ylist_for_each_safe(itervar,saveVar, list) \
-	for (itervar = (list)->next, saveVar = (list)->next->next; itervar != (list); \
-	 itervar = saveVar, saveVar = saveVar->next)
-
+/**
+ * list_empty - tests whether a list is empty
+ * @head: the list to test.
+ */
+static __inline__ int list_empty(struct list_head *head)
+{
+	return head->next == head;
+}
 
-#if !(defined __KERNEL__)
+/**
+ * list_splice - join two lists
+ * @list: the new list to add.
+ * @head: the place to add it in the first list.
+ */
+static __inline__ void list_splice(struct list_head *list,
+				   struct list_head *head)
+{
+	struct list_head *first = list->next;
 
+	if (first != list) {
+		struct list_head *last = list->prev;
+		struct list_head *at = head->next;
 
-#ifndef WIN32
-#include <sys/stat.h>
-#endif
+		first->prev = head;
+		head->next = first;
 
+		last->next = at;
+		at->prev = last;
+	}
+}
 
-#ifdef CONFIG_YAFFS_PROVIDE_DEFS
-/* File types */
+/**
+ * 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) \
+	((type *)((char *)(ptr)-(unsigned long)(&((type *)0)->member)))
 
+/**
+ * list_for_each	-	iterate over a list
+ * @pos:	the &struct list_head to use as a loop counter.
+ * @head:	the head for your list.
+ */
+#define list_for_each(pos, head) \
+	for (pos = (head)->next, prefetch(pos->next); pos != (head); \
+        	pos = pos->next, prefetch(pos->next))
+
+/**
+ * list_for_each_safe	-	iterate over a list safe against removal
+ *                              of list entry
+ * @pos:	the &struct list_head to use as a loop counter.
+ * @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)
 
+/*
+ * File types
+ */
 #define DT_UNKNOWN	0
 #define DT_FIFO		1
 #define DT_CHR		2
@@ -135,13 +212,13 @@ static __inline__ int ylist_empty(struct ylist_head *entry)
 #define DT_SOCK		12
 #define DT_WHT		14
 
-
 #ifndef WIN32
 #include <sys/stat.h>
 #endif
 
 /*
- * Attribute flags.
+ * Attribute flags.  These should be or-ed together to figure out what
+ * has been changed!
  */
 #define ATTR_MODE	1
 #define ATTR_UID	2
@@ -150,7 +227,10 @@ static __inline__ int ylist_empty(struct ylist_head *entry)
 #define ATTR_ATIME	16
 #define ATTR_MTIME	32
 #define ATTR_CTIME	64
-
+#define ATTR_ATIME_SET	128
+#define ATTR_MTIME_SET	256
+#define ATTR_FORCE	512	/* Not a change, but a change it */
+#define ATTR_ATTR_FLAG	1024
 
 struct iattr {
 	unsigned int ia_valid;
@@ -164,18 +244,21 @@ struct iattr {
 	unsigned int ia_attr_flags;
 };
 
-#endif
-
-
 #define KERN_DEBUG
 
 #else
 
+#ifndef WIN32
 #include <linux/types.h>
+#include <linux/list.h>
 #include <linux/fs.h>
 #include <linux/stat.h>
+#endif
 
 #endif
 
+#if defined WIN32
+#undef new
+#endif
 
 #endif