Added '-g' flag for GCC to all makefiles to ensure debugging information

is produced. This may change later.

Added the new directory 'lib' to the source tree which build lib.a, an
archive containing common library routines for both the kernel and
userspace code to use.

Added the file string.c to the lib directory (as well as the appropriate
headers in /include) which provides some basic functions from the
standard C string library.

Added a physical memory manager which is now located in memory.c. This
memory manager tracks free pages from 1MB-8MB with a simple table and
allocates memory in blocks of 4KB pages. Multiple pages can be allocated
in which they are returned as a linked list.

Added a 'page window' in memory.c which allows the temporary mapping of
a single page at a time into the current address space.

Moved all paging routines that were previously located in page.s over to
memory.c where they have been re-implemented as a mixture of C and
inline assembly.

Moved the primative userspace routines from usrspace.s over to the new
sched.c. The only remaining routine, usrcall is now located in asm.s as
'switch_to' which takes two arguments, pointers to the task structure
and task state structure of the new task which is being switched to.

Pages for userspace are now allocated dynamically. The user binary is
loaded in at 1GB upwards. The user stack is located at the end of the
4GB address space with the lower 1GB being reserved for the kernel.

Updated the link.ld file for the userspace binary to include the new
starting address 0x40000000 (1GB).

Renamed the symbols for the user binary blob to make them shorter.

1 files changed, 173 insertions, 0 deletions

diff --git a/lib/string.c b/lib/string.c
new file mode 100644
index 0000000..0e8fbeb
--- /dev/null
+++ b/lib/string.c
@@ -0,0 +1,173 @@
+#include <string.h>
+
+void* memchr(const void* s, int c, size_t n) {
+  unsigned char *p = (unsigned char*) s;
+  while(n--) {
+    if(*p != (unsigned char) c) {
+      p++;
+    } else {
+      return p;
+    }
+  }
+  return 0;
+}
+
+int memcmp(const void* s1, const void* s2, size_t n) {
+  const unsigned char* p1 = (const unsigned char*) s1;
+  const unsigned char* p2 = (const unsigned char*) s2;
+  while(n--) {
+    if(*p1 != *p2) {
+      return *p1 - *p2;
+    } else {
+      p1++, p2++;
+    }
+  }
+  return 0;
+}
+
+void* memcpy(void* dest, const void* src, size_t n) {
+  char *dp = (char*) dest;
+  const char *sp = (const char*) src;
+  while(n--) *dp++ = *sp++;
+  return dest;
+}
+
+void* memmove(void* dest, const void* src, size_t n) {
+  unsigned char tmp[n];
+  memcpy(tmp, src, n);
+  memcpy(dest, tmp, n);
+  return dest;
+}
+
+void* memset(void* s, int c, size_t n) {
+  unsigned char* p = (unsigned char*) s;
+  while(n--) *p++ = (unsigned char) c;
+  return s;
+}
+
+size_t strlen(const char* str) {
+  const char* s;
+  for(s = str; *s; ++s) {}
+  return (s - str);
+}
+
+char* strcat(char* dest, const char* src) {
+  size_t dest_len = strlen(dest);
+  size_t i;
+
+  for(i = 0; src[i] != '\0'; i++) {
+    dest[dest_len + i] = src[i];
+  }
+  dest[dest_len + i] = '\0';
+  return dest;
+}
+
+char* strncat(char* dest, const char* src, size_t n) {
+  size_t dest_len = strlen(dest);
+  size_t i;
+
+  for(i = 0; i < n && src[i] != '\0'; i++) {
+    dest[dest_len + i] = src[i];
+  }
+  dest[dest_len + i] = '\0';
+  return dest;
+}
+
+char* strchr(const char* s, int c) {
+  while(*s != (char) c) {
+    if(!*s++) return 0;
+  }
+  return (char*) s;
+}
+
+char* strrchr(char* s, int c) {
+  char* ret = 0;
+  do {
+    if(*s == (char) c) ret = s;
+  } while(*s++);
+  return ret;
+}
+
+int strcmp(const char* s1, const char* s2) {
+  while(*s1 && (*s1 == *s2)) s1++, s2++;
+  return *(const unsigned char*) s1 - *(const unsigned char*) s2;
+}
+
+int strncmp(const char* s1, const char* s2, size_t n) {
+  while(n--) {
+    if(*s1++ != *s2++) {
+      return *(unsigned char*) (s1 - 1) - *(unsigned char*) (s2 - 1);
+    }
+  }
+  return 0;
+}
+
+char* strcpy(char* dest, const char* src) {
+  char* ret = dest;
+  while(*dest++ = *src++);
+  return ret;
+}
+
+char* strncpy(char* dest, const char* src, size_t n) {
+  char* ret = dest;
+  do {
+    if(!n--) return ret;
+  } while (*dest++ = *src++);
+  while(n--) *dest++ = 0;
+  return ret;
+}
+
+size_t strcspn(const char* s1, const char* s2) {
+  size_t ret = 0;
+  while(*s1) {
+    if(strchr(s2, *s1)) {
+      return ret;
+    } else {
+      s1++, ret++;
+    }
+  }
+  return ret;
+}
+
+size_t strspn(const char* s1, const char* s2) {
+  size_t ret = 0;
+  while(*s1 && strchr(s2, *s1++)) ret++;
+  return ret;
+}
+
+char* strpbrk(const char* s1, const char* s2) {
+  while(*s1) {
+    if(strchr(s2, *s1++)) return (char*) --s1;
+  }
+  return 0;
+}
+
+char* strstr(const char* s1, const char* s2) {
+  size_t n = strlen(s2);
+  while(*s1) {
+    if(!memcmp(s1++, s2, n)) {
+      return (char*) (s1 - 1);
+    }
+  }
+  return 0;
+}
+
+char* strtok(char* str, const char* delim) {
+  static char* p = 0;
+  if(str) {
+    p = str;
+  } else if(!p) {
+    return 0;
+  }
+  str = p + strspn(p, delim);
+  p = str + strcspn(str, delim);
+  if(p == str) return p = 0;
+  p = *p ? *p = 0, p + 1 : 0;
+  return str;
+}
+
+size_t strxfrm(char* dest, const char* src, size_t n) {
+  size_t n2 = strlen(src);
+  if(n > n2) strcpy(dest, src);
+  return n2;
+}