From 57f911a4372ec937a679177a0ce50e37c40563c6 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Axel=20D=C3=B6rfler?= <axeld@pinc-software.de>
Date: Mon, 21 Mar 2005 17:54:13 +0000
Subject: [PATCH] Moved kernel/apps to tests/kernel/boot_floppy, removed
 boot_floppy stuff from kernel/Jamfile. Actually kernel/apps is still there as
 Subversion doesn't let me commit it -- I'll remove that later.

git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@11940 a95241bf-73f2-0310-859d-f6bbb57e9c96
---
 src/kernel/Jamfile                            | 218 ------
 src/tests/kernel/boot_floppy/Jamfile          |  39 +
 .../kernel/boot_floppy/cache_control.cpp      |  58 ++
 src/tests/kernel/boot_floppy/cpuinfo/Jamfile  |  20 +
 .../kernel/boot_floppy/cpuinfo/cpuinfo.h      | 105 +++
 .../kernel/boot_floppy/cpuinfo/flag_arrays.c  | 178 +++++
 src/tests/kernel/boot_floppy/cpuinfo/main.c   | 663 ++++++++++++++++
 src/tests/kernel/boot_floppy/echo/Jamfile     |   3 +
 src/tests/kernel/boot_floppy/echo/main.c      |  79 ++
 src/tests/kernel/boot_floppy/envtest/Jamfile  |   3 +
 src/tests/kernel/boot_floppy/envtest/main.c   |  66 ++
 src/tests/kernel/boot_floppy/exec_test.c      |  52 ++
 src/tests/kernel/boot_floppy/false_main.c     |  13 +
 src/tests/kernel/boot_floppy/fibo_main.c      |  72 ++
 src/tests/kernel/boot_floppy/filetest/Jamfile |   3 +
 src/tests/kernel/boot_floppy/filetest/main.c  |  52 ++
 src/tests/kernel/boot_floppy/fork_test.c      |  33 +
 src/tests/kernel/boot_floppy/fortune/Jamfile  |   7 +
 src/tests/kernel/boot_floppy/fortune/fortunes |   9 +
 src/tests/kernel/boot_floppy/fortune/main.c   |  80 ++
 src/tests/kernel/boot_floppy/hostname/Jamfile |   3 +
 src/tests/kernel/boot_floppy/hostname/main.c  |  42 +
 src/tests/kernel/boot_floppy/init.c           |  52 ++
 src/tests/kernel/boot_floppy/ls/Jamfile       |   8 +
 src/tests/kernel/boot_floppy/ls/main.c        | 163 ++++
 src/tests/kernel/boot_floppy/monitor_test.c   |  44 ++
 src/tests/kernel/boot_floppy/on_exit_thread.c |  43 +
 src/tests/kernel/boot_floppy/pipe_test.c      |  97 +++
 src/tests/kernel/boot_floppy/ps/Jamfile       |   3 +
 src/tests/kernel/boot_floppy/ps/main.c        |  72 ++
 src/tests/kernel/boot_floppy/select_test.c    |  48 ++
 src/tests/kernel/boot_floppy/shell/Jamfile    |  12 +
 src/tests/kernel/boot_floppy/shell/args.c     |  80 ++
 src/tests/kernel/boot_floppy/shell/args.h     |  10 +
 src/tests/kernel/boot_floppy/shell/commands.c | 238 ++++++
 src/tests/kernel/boot_floppy/shell/commands.h |  22 +
 .../kernel/boot_floppy/shell/file_utils.c     | 129 +++
 .../kernel/boot_floppy/shell/file_utils.h     |  10 +
 src/tests/kernel/boot_floppy/shell/main.c     | 117 +++
 src/tests/kernel/boot_floppy/shell/parse.c    | 583 ++++++++++++++
 src/tests/kernel/boot_floppy/shell/parse.h    |  22 +
 src/tests/kernel/boot_floppy/shell/script.c   | 124 +++
 src/tests/kernel/boot_floppy/shell/script.h   |  27 +
 .../kernel/boot_floppy/shell/shell_defs.h     |  71 ++
 .../kernel/boot_floppy/shell/shell_history.c  |  69 ++
 .../kernel/boot_floppy/shell/shell_history.h  |  16 +
 .../kernel/boot_floppy/shell/shell_vars.c     | 372 +++++++++
 .../kernel/boot_floppy/shell/shell_vars.h     |  45 ++
 .../kernel/boot_floppy/shell/statements.c     | 741 ++++++++++++++++++
 .../kernel/boot_floppy/shell/statements.h     |  18 +
 src/tests/kernel/boot_floppy/sig_test.c       | 122 +++
 .../kernel/boot_floppy/sockettest/Jamfile     |   3 +
 .../kernel/boot_floppy/sockettest/main.c      |  57 ++
 src/tests/kernel/boot_floppy/symlink/Jamfile  |   3 +
 src/tests/kernel/boot_floppy/symlink/main.c   |  22 +
 src/tests/kernel/boot_floppy/testapp/Jamfile  |   3 +
 src/tests/kernel/boot_floppy/testapp/main.c   | 521 ++++++++++++
 .../kernel/boot_floppy/testdigit/Jamfile      |   3 +
 src/tests/kernel/boot_floppy/testdigit/main.c |  47 ++
 src/tests/kernel/boot_floppy/tests/Jamfile    |  45 ++
 .../kernel/boot_floppy/tests/fops_test.c      |  69 ++
 .../kernel/boot_floppy/tests/random_test.c    |  43 +
 .../kernel/boot_floppy/tests/thread_test.c    | 136 ++++
 src/tests/kernel/boot_floppy/tls_test.c       |  97 +++
 src/tests/kernel/boot_floppy/true_main.c      |  13 +
 src/tests/kernel/boot_floppy/uname/Jamfile    |   3 +
 src/tests/kernel/boot_floppy/uname/main.c     | 188 +++++
 67 files changed, 6191 insertions(+), 218 deletions(-)
 create mode 100644 src/tests/kernel/boot_floppy/Jamfile
 create mode 100644 src/tests/kernel/boot_floppy/cache_control.cpp
 create mode 100644 src/tests/kernel/boot_floppy/cpuinfo/Jamfile
 create mode 100644 src/tests/kernel/boot_floppy/cpuinfo/cpuinfo.h
 create mode 100644 src/tests/kernel/boot_floppy/cpuinfo/flag_arrays.c
 create mode 100644 src/tests/kernel/boot_floppy/cpuinfo/main.c
 create mode 100644 src/tests/kernel/boot_floppy/echo/Jamfile
 create mode 100644 src/tests/kernel/boot_floppy/echo/main.c
 create mode 100644 src/tests/kernel/boot_floppy/envtest/Jamfile
 create mode 100644 src/tests/kernel/boot_floppy/envtest/main.c
 create mode 100644 src/tests/kernel/boot_floppy/exec_test.c
 create mode 100644 src/tests/kernel/boot_floppy/false_main.c
 create mode 100644 src/tests/kernel/boot_floppy/fibo_main.c
 create mode 100644 src/tests/kernel/boot_floppy/filetest/Jamfile
 create mode 100644 src/tests/kernel/boot_floppy/filetest/main.c
 create mode 100644 src/tests/kernel/boot_floppy/fork_test.c
 create mode 100644 src/tests/kernel/boot_floppy/fortune/Jamfile
 create mode 100644 src/tests/kernel/boot_floppy/fortune/fortunes
 create mode 100644 src/tests/kernel/boot_floppy/fortune/main.c
 create mode 100644 src/tests/kernel/boot_floppy/hostname/Jamfile
 create mode 100644 src/tests/kernel/boot_floppy/hostname/main.c
 create mode 100644 src/tests/kernel/boot_floppy/init.c
 create mode 100644 src/tests/kernel/boot_floppy/ls/Jamfile
 create mode 100644 src/tests/kernel/boot_floppy/ls/main.c
 create mode 100644 src/tests/kernel/boot_floppy/monitor_test.c
 create mode 100644 src/tests/kernel/boot_floppy/on_exit_thread.c
 create mode 100644 src/tests/kernel/boot_floppy/pipe_test.c
 create mode 100644 src/tests/kernel/boot_floppy/ps/Jamfile
 create mode 100644 src/tests/kernel/boot_floppy/ps/main.c
 create mode 100644 src/tests/kernel/boot_floppy/select_test.c
 create mode 100644 src/tests/kernel/boot_floppy/shell/Jamfile
 create mode 100644 src/tests/kernel/boot_floppy/shell/args.c
 create mode 100644 src/tests/kernel/boot_floppy/shell/args.h
 create mode 100644 src/tests/kernel/boot_floppy/shell/commands.c
 create mode 100644 src/tests/kernel/boot_floppy/shell/commands.h
 create mode 100644 src/tests/kernel/boot_floppy/shell/file_utils.c
 create mode 100644 src/tests/kernel/boot_floppy/shell/file_utils.h
 create mode 100644 src/tests/kernel/boot_floppy/shell/main.c
 create mode 100644 src/tests/kernel/boot_floppy/shell/parse.c
 create mode 100644 src/tests/kernel/boot_floppy/shell/parse.h
 create mode 100644 src/tests/kernel/boot_floppy/shell/script.c
 create mode 100644 src/tests/kernel/boot_floppy/shell/script.h
 create mode 100644 src/tests/kernel/boot_floppy/shell/shell_defs.h
 create mode 100644 src/tests/kernel/boot_floppy/shell/shell_history.c
 create mode 100644 src/tests/kernel/boot_floppy/shell/shell_history.h
 create mode 100644 src/tests/kernel/boot_floppy/shell/shell_vars.c
 create mode 100644 src/tests/kernel/boot_floppy/shell/shell_vars.h
 create mode 100644 src/tests/kernel/boot_floppy/shell/statements.c
 create mode 100644 src/tests/kernel/boot_floppy/shell/statements.h
 create mode 100644 src/tests/kernel/boot_floppy/sig_test.c
 create mode 100644 src/tests/kernel/boot_floppy/sockettest/Jamfile
 create mode 100644 src/tests/kernel/boot_floppy/sockettest/main.c
 create mode 100644 src/tests/kernel/boot_floppy/symlink/Jamfile
 create mode 100644 src/tests/kernel/boot_floppy/symlink/main.c
 create mode 100644 src/tests/kernel/boot_floppy/testapp/Jamfile
 create mode 100644 src/tests/kernel/boot_floppy/testapp/main.c
 create mode 100644 src/tests/kernel/boot_floppy/testdigit/Jamfile
 create mode 100644 src/tests/kernel/boot_floppy/testdigit/main.c
 create mode 100644 src/tests/kernel/boot_floppy/tests/Jamfile
 create mode 100644 src/tests/kernel/boot_floppy/tests/fops_test.c
 create mode 100644 src/tests/kernel/boot_floppy/tests/random_test.c
 create mode 100644 src/tests/kernel/boot_floppy/tests/thread_test.c
 create mode 100644 src/tests/kernel/boot_floppy/tls_test.c
 create mode 100644 src/tests/kernel/boot_floppy/true_main.c
 create mode 100644 src/tests/kernel/boot_floppy/uname/Jamfile
 create mode 100644 src/tests/kernel/boot_floppy/uname/main.c

diff --git a/src/kernel/Jamfile b/src/kernel/Jamfile
index aaa8d9e828..305a656ae7 100644
--- a/src/kernel/Jamfile
+++ b/src/kernel/Jamfile
@@ -174,231 +174,13 @@ KernelLd libglue2.o :	# libglue2.o is used for executables
 	: no_gcc
 	;
 
-KernelLd init :
-	libglue2.o
-	<$(SOURCE_GRIST)!apps>init.o
-	libroot.so
-	: $(SUBDIR)/ldscripts/$(OBOS_ARCH)/app.ld
-	:
-	:
-	: beos/bin/init
-	;
-
-KernelLd kernel_false :
-	libglue2.o
-	<$(SOURCE_GRIST)!apps>false_main.o
-	libroot.so
-	: $(SUBDIR)/ldscripts/$(OBOS_ARCH)/app.ld
-	:
-	:
-	: beos/bin/false
-	;
-
-KernelLd kernel_true :
-	libglue2.o
-	<$(SOURCE_GRIST)!apps>true_main.o
-	libroot.so
-	: $(SUBDIR)/ldscripts/$(OBOS_ARCH)/app.ld
-	:
-	:
-	: beos/bin/true
-	;
-
-KernelLd fibo :
-	libglue2.o
-	<$(SOURCE_GRIST)!apps>fibo_main.o
-	libroot.so
-	: $(SUBDIR)/ldscripts/$(OBOS_ARCH)/app.ld
-	:
-	:
-	: beos/bin/fibo
-	;
-
-KernelLd sig_test :
-	libglue2.o
-	<$(SOURCE_GRIST)!apps>sig_test.o
-	libroot.so
-	: $(SUBDIR)/ldscripts/$(OBOS_ARCH)/app.ld
-	:
-	:
-	: beos/bin/sig_test
-	;
-
-KernelLd monitor_test :
-	libglue2.o
-	<$(SOURCE_GRIST)!apps>monitor_test.o
-	libroot.so
-	: $(SUBDIR)/ldscripts/$(OBOS_ARCH)/app.ld
-	:
-	:
-	: beos/bin/monitor_test
-	;
-
-KernelLd kernel_fortune :
-	libglue2.o
-	<$(SOURCE_GRIST)!apps!fortune>main.o
-	libroot.so
-	: $(SUBDIR)/ldscripts/$(OBOS_ARCH)/app.ld
-	:
-	:
-	: beos/bin/fortune
-	;
-
-KernelConfigSection beos/etc/fortunes : data : $(SUBDIR)/apps/fortune/fortunes ;
-
-KernelLd kernel_ls :
-	libglue2.o
-	<$(SOURCE_GRIST)!apps!ls>main.o
-	libroot.so
-	: $(SUBDIR)/ldscripts/$(OBOS_ARCH)/app.ld
-	:
-	:
-	: beos/bin/ls
-	;
-
-KernelLd symlink :
-	libglue2.o
-	<$(SOURCE_GRIST)!apps!symlink>main.o
-	libroot.so
-	: $(SUBDIR)/ldscripts/$(OBOS_ARCH)/app.ld
-	:
-	:
-	: beos/bin/symlink
-	;
-
-KernelLd <bootfloppy>consoled :
-	libglue2.o
-	<$(SOURCE_GRIST)!apps!consoled>consoled.o
-	libroot.so
-	: $(SUBDIR)/ldscripts/$(OBOS_ARCH)/app.ld
-	:
-	:
-	: beos/bin/consoled
-	;
-
-# Note: shell is a built in target, thus we need the grist.
-KernelLd obos_shell :
-	libglue2.o
-	<$(SOURCE_GRIST)!apps!shell>main.o
-	<$(SOURCE_GRIST)!apps!shell>args.o
-	<$(SOURCE_GRIST)!apps!shell>commands.o
-	<$(SOURCE_GRIST)!apps!shell>file_utils.o
-	<$(SOURCE_GRIST)!apps!shell>parse.o
-	<$(SOURCE_GRIST)!apps!shell>script.o
-	<$(SOURCE_GRIST)!apps!shell>shell_vars.o
-	<$(SOURCE_GRIST)!apps!shell>statements.o
-	<$(SOURCE_GRIST)!apps!shell>shell_history.o
-	libroot.so
-	: $(SUBDIR)/ldscripts/$(OBOS_ARCH)/app.ld
-	:
-	:
-	: beos/bin/sh
-	;
-
-KernelLd testapp :
-	libglue2.o
-	<$(SOURCE_GRIST)!apps!testapp>main.o
-	libroot.so
-	: $(SUBDIR)/ldscripts/$(OBOS_ARCH)/app.ld
-	:
-	:
-	: beos/bin/testapp
-	;
-
-KernelLd tls_test :
-	libglue2.o
-	<$(SOURCE_GRIST)!apps>tls_test.o
-	libroot.so
-	: $(SUBDIR)/ldscripts/$(OBOS_ARCH)/app.ld
-	:
-	:
-	: beos/bin/tls_test
-	;
-
-KernelLd pipe_test :
-	libglue2.o
-	<$(SOURCE_GRIST)!apps>pipe_test.o
-	libroot.so
-	: $(SUBDIR)/ldscripts/$(OBOS_ARCH)/app.ld
-	:
-	:
-	: beos/bin/pipe_test
-	;
-
-KernelLd fork_test :
-	libglue2.o
-	<$(SOURCE_GRIST)!apps>fork_test.o
-	libroot.so
-	: $(SUBDIR)/ldscripts/$(OBOS_ARCH)/app.ld
-	:
-	:
-	: beos/bin/fork_test
-	;
-
-KernelConfigSection drivers/dev/tty
-	: elf32
-	: $(OBOS_TOP)/distro/$(OBOS_ARCH).R1/beos/system/add-ons/kernel/drivers/dev/tty
-	;
-
-KernelConfigSection drivers/dev/console
-	: elf32
-	: $(OBOS_TOP)/distro/$(OBOS_ARCH).R1/beos/system/add-ons/kernel/drivers/dev/console
-	;
-
-KernelConfigSection addons/kernel/console/vga_text
-	: elf32
-	: $(OBOS_TOP)/distro/$(OBOS_ARCH).R1/beos/system/add-ons/kernel/console/vga_text
-	;
-
-KernelLd kernel_ps :
-	libglue2.o
-	<$(SOURCE_GRIST)!apps!ps>main.o
-	libroot.so
-	: $(SUBDIR)/ldscripts/$(OBOS_ARCH)/app.ld
-	:
-	:
-	: beos/bin/ps
-	; 
-
-KernelLd kernel_echo :
-	libglue2.o
-	<$(SOURCE_GRIST)!apps!echo>main.o
-	libroot.so
-	: $(SUBDIR)/ldscripts/$(OBOS_ARCH)/app.ld
-	:
-	:
-	: beos/bin/echo
-	; 
-
-KernelLd kernel_uname :
-	libglue2.o
-	<$(SOURCE_GRIST)!apps!uname>main.o
-	libroot.so
-	: $(SUBDIR)/ldscripts/$(OBOS_ARCH)/app.ld
-	:
-	:
-	: beos/bin/uname
-	;
 
 WriteKernelConfig $(OBOS_KERNEL_CONFIG) ;
-
 BuildKernel $(OBOS_KERNEL) : $(OBOS_KERNEL_CONFIG) ;
 
-KernelFloppyImage $(OBOS_FLOPPY) : $(OBOS_KERNEL) : $(SUBDIR)/boot/arch/$(OBOS_ARCH)/bootblock.bin ;
-
 Depends kernel.so : kernel ;
 	# kernel.so will be rebuilt with the kernel
 
-Depends $(OBOS_FLOPPY) : tty ;
-Depends $(OBOS_FLOPPY) : console ;
-Depends $(OBOS_FLOPPY) : vga_text ;
-
-Depends boot_floppy : $(OBOS_FLOPPY) ;
-NotFile boot_floppy ;
-Depends bootfloppy : $(OBOS_FLOPPY) ;
-NotFile bootfloppy ;
-
-SubInclude OBOS_TOP src kernel apps ;
 SubInclude OBOS_TOP src kernel boot ;
 SubInclude OBOS_TOP src kernel core ;
 SubInclude OBOS_TOP src kernel glue ;
diff --git a/src/tests/kernel/boot_floppy/Jamfile b/src/tests/kernel/boot_floppy/Jamfile
new file mode 100644
index 0000000000..aaf64c0e83
--- /dev/null
+++ b/src/tests/kernel/boot_floppy/Jamfile
@@ -0,0 +1,39 @@
+SubDir OBOS_TOP src kernel apps ;
+
+KernelObjects
+	exec_test.c
+	false_main.c
+	fibo_main.c
+	fork_test.c
+	init.c
+	monitor_test.c
+	pipe_test.c
+	true_main.c
+	sig_test.c
+	select_test.c
+	tls_test.c
+	on_exit_thread.c
+	;
+
+UsePrivateHeaders kernel ;
+# UsePrivateHeaders [ FDirName kernel arch ] ;
+UsePrivateHeaders [ FDirName kernel arch $(OBOS_ARCH) ] ;
+UsePrivateHeaders [ FDirName kernel boot platform $(OBOS_BOOT_PLATFORM) ] ;
+
+if $(OBOS_ARCH) = x86 {
+	SubInclude OBOS_TOP src kernel apps cpuinfo ;
+}
+
+SubInclude OBOS_TOP src kernel apps echo ;
+SubInclude OBOS_TOP src kernel apps filetest ;
+SubInclude OBOS_TOP src kernel apps fortune ;
+SubInclude OBOS_TOP src kernel apps hostname ;
+SubInclude OBOS_TOP src kernel apps ls ;
+SubInclude OBOS_TOP src kernel apps symlink ;
+SubInclude OBOS_TOP src kernel apps ps ;
+SubInclude OBOS_TOP src kernel apps shell ;
+SubInclude OBOS_TOP src kernel apps envtest ;
+#SubInclude OBOS_TOP src kernel apps sockettest ;
+SubInclude OBOS_TOP src kernel apps testapp ;
+SubInclude OBOS_TOP src kernel apps tests ;
+SubInclude OBOS_TOP src kernel apps uname ;
diff --git a/src/tests/kernel/boot_floppy/cache_control.cpp b/src/tests/kernel/boot_floppy/cache_control.cpp
new file mode 100644
index 0000000000..a9118c9160
--- /dev/null
+++ b/src/tests/kernel/boot_floppy/cache_control.cpp
@@ -0,0 +1,58 @@
+/* 
+ * Copyright 2004, Axel Dörfler, axeld@pinc-software.de. All rights reserved.
+ * Distributed under the terms of the MIT License.
+ */
+
+
+#include <OS.h>
+#include <syscalls.h>
+#include <generic_syscall.h>
+
+#include <file_cache.h>
+
+#include <stdio.h>
+#include <string.h>
+
+
+extern const char *__progname;
+
+
+void
+usage()
+{
+	fprintf(stderr, "usage: %s [clear | unset | set <module-name>]\n", __progname);
+	exit(0);
+}
+
+
+int
+main(int argc, char **argv)
+{
+	uint32 version = 0;
+	status_t status = _kern_generic_syscall(CACHE_SYSCALLS, B_SYSCALL_INFO, &version, sizeof(version));
+	if (status != B_OK) {
+		fprintf(stderr, "%s: The cache syscalls are not available on this system.\n", __progname);
+		return 1;
+	}
+
+	if (argc < 2)
+		usage();
+
+	if (!strcmp(argv[1], "clear")) {
+		status = _kern_generic_syscall(CACHE_SYSCALLS, CACHE_CLEAR, NULL, 0);
+		if (status != B_OK)
+			fprintf(stderr, "%s: clearing the cache failed: %s\n", __progname, strerror(status));
+	} else if (!strcmp(argv[1], "unset")) {
+		status = _kern_generic_syscall(CACHE_SYSCALLS, CACHE_SET_MODULE, NULL, 0);
+		if (status != B_OK)
+			fprintf(stderr, "%s: unsetting the cache module failed: %s\n", __progname, strerror(status));
+	} else if (!strcmp(argv[1], "set") && argc > 2) {
+		status = _kern_generic_syscall(CACHE_SYSCALLS, CACHE_SET_MODULE, argv[2], strlen(argv[2]));
+		if (status != B_OK)
+			fprintf(stderr, "%s: setting the module failed: %s\n", __progname, strerror(status));
+	} else
+		usage();
+
+	return 0;
+}
+
diff --git a/src/tests/kernel/boot_floppy/cpuinfo/Jamfile b/src/tests/kernel/boot_floppy/cpuinfo/Jamfile
new file mode 100644
index 0000000000..7f32bc0e8c
--- /dev/null
+++ b/src/tests/kernel/boot_floppy/cpuinfo/Jamfile
@@ -0,0 +1,20 @@
+SubDir OBOS_TOP src kernel apps cpuinfo ;
+
+KernelObjects
+	<$(SOURCE_GRIST)>main.c
+	:
+	-fpic
+	;
+
+KernelLd cpuinfo :
+	libglue2.o
+	<$(SOURCE_GRIST)>main.o
+	libroot.so
+	:
+	$(OBOS_TOP)/src/kernel/ldscripts/$(OBOS_ARCH)/app.ld
+	:
+	:
+	:
+	bin/cpuinfo
+	;
+
diff --git a/src/tests/kernel/boot_floppy/cpuinfo/cpuinfo.h b/src/tests/kernel/boot_floppy/cpuinfo/cpuinfo.h
new file mode 100644
index 0000000000..7691cc6baa
--- /dev/null
+++ b/src/tests/kernel/boot_floppy/cpuinfo/cpuinfo.h
@@ -0,0 +1,105 @@
+
+// cache-type codes
+enum cache_types {
+	Unused,
+	Inst_TLB,
+	Data_TLB,
+	L1_Inst_Cache,
+	L1_Data_Cache,
+	L2_Cache,
+	L3_Cache,
+	No_L2_Or_L3,
+	Trace_Cache
+};
+
+
+// an entry in the TLB/Cache table
+typedef struct {
+	uint8  descriptor;
+	uint8  cache_type;
+	char   text[70];
+} tlbc_info;
+
+
+//
+// the global TLB/Cache table
+// technical reference:
+//    "Intel Processor Identification and the CPUID instruction"
+//    (ftp://ftp.intel.com/docs/24161821.pdf)
+//     Page 18
+
+static tlbc_info
+Intel_TLB_Cache_Table[] = {
+	{0x0,  0, ""},
+	{0x1,  Inst_TLB, "4KB pages, 4-way set associative, 32 entries"},
+	{0x2,  Inst_TLB, "4MB pages, fully associative, 2 entries"},
+	{0x50, Inst_TLB, "4KB, 2MB or 4MB pages, fully associative, 64 entries"},
+	{0x51, Inst_TLB, "4KB, 2MB or 4MB pages, fully associative, 128 entries"},
+	{0x52, Inst_TLB, "4KB, 2MB or 4MB pages, fully associative, 256 entries"},
+	
+	{0x3,  Data_TLB, "4KB pages, 4-way set associative, 64 entries"},
+	{0x4,  Data_TLB, "4MB pages, 4-way set associative, 8 entries"},
+	{0x5b, Data_TLB, "4KB or 4MB pages, fully associative, 64 entries"},
+	{0x5c, Data_TLB, "4KB or 4MB pages, fully associative, 128 entries"},
+	{0x5d, Data_TLB, "4KB or 4MB pages, fully associative, 256 entries"},
+	
+	{0x6,  L1_Inst_Cache, "8KB pages, 4-way set associative, 32 byte line size"},
+	{0x8,  L1_Inst_Cache, "16KB pages, 4-way set associative, 32 byte line size"},
+	
+	{0xa,  L1_Data_Cache, "8KB pages, 2-way set associative, 32 byte line size"},
+	{0xc,  L1_Data_Cache, "16KB pages, 4-way set associative, 32 byte line size"},
+	{0x66, L1_Data_Cache, "8KB pages, 4-way set associative, 64 byte line size"},
+	{0x67, L1_Data_Cache, "16KB pages, 4-way set associative, 64 byte line size"},
+	{0x68, L1_Data_Cache, "32KB pages, 4-way set associative, 64 byte line size"},
+	
+	{0x39, L2_Cache, "128KB pages, 4-way set associative, sectored, 64 byte line size"},
+	{0x3c, L2_Cache, "256KB pages, 4-way set associative, sectored, 64 byte line size"},
+	{0x41, L2_Cache, "128KB pages, 4-way set associative, 32 byte line size"},
+	{0x42, L2_Cache, "256KB pages, 4-way set associative, 32 byte line size"},
+	{0x43, L2_Cache, "512KB pages, 4-way set associative, 32 byte line size"},
+	{0x44, L2_Cache, "1MB pages, 4-way set associative, 32 byte line size"},
+	{0x45, L2_Cache, "2MB pages, 4-way set associative, 32 byte line size"},
+	{0x79, L2_Cache, "128KB pages, 8-way set associative, sectored, 64 byte line size"},
+	{0x7a, L2_Cache, "256KB pages, 8-way set associative, sectored, 64 byte line size"},
+	{0x7b, L2_Cache, "512KB pages, 8-way set associative, sectored, 64 byte line size"},
+	{0x7c, L2_Cache, "1MB pages, 8-way set associative, sectored, 64 byte line size"},
+	{0x82, L2_Cache, "256KB pages, 8-way set associative, 32 byte line size"},
+	{0x83, L2_Cache, "512KB pages, 8-way set associative, 32 byte line size"},
+	{0x84, L2_Cache, "1MB pages, 8-way set associative, 32 byte line size"},
+	{0x85, L2_Cache, "2MB pages, 8-way set associative, 32 byte line size"},
+	
+	{0x40, No_L2_Or_L3, "No 2nd-level cache, or if 2nd-level cache exists, no 3rd-level cache\n"},
+
+	{0x22, L3_Cache, "512KB pages, 4-way set associative, sectored, 64 byte line size"},
+	{0x23, L3_Cache, "1MB pages, 8-way set associative, sectored, 64 byte line size"},
+	{0x25, L3_Cache, "2MB pages, 8-way set associative, sectored, 64 byte line size"},
+	{0x29, L3_Cache, "4MB pages, 8-way set associative, sectored, 64 byte line size"},
+
+	{0x70, Trace_Cache, "Trace cache: 12K-uops, 8-way set associative\n"},
+	{0x71, Trace_Cache, "Trace cache: 16K-uops, 8-way set associative\n"},
+	{0x72, Trace_Cache, "Trace cache: 32K-uops, 8-way set associative\n"},
+};
+
+
+
+
+void AMD_identify (cpuid_info *);
+void AMD_features (cpuid_info *);
+void AMD_TLB_cache (cpuid_info *);
+void Cyrix_identify (cpuid_info *);
+void Cyrix_features (cpuid_info *);
+void Cyrix_TLB_cache (cpuid_info *);
+void Intel_identify (cpuid_info *);
+void Intel_features (cpuid_info *);
+void Intel_TLB_cache (cpuid_info *);
+
+const char *Intel_brand_string (int, int);
+void dump_regs (cpuid_info *, const char *, uint32, uint32);
+char getoption (char *);
+void insert (int *, int, int);
+void opt_identify (cpuid_info *, int);
+void opt_features (cpuid_info *, int);
+void opt_TLB_cache (cpuid_info *, int);
+void opt_dump_calls (cpuid_info *, uint32);
+void print_regs (cpuid_info *);
+void usage (void);
diff --git a/src/tests/kernel/boot_floppy/cpuinfo/flag_arrays.c b/src/tests/kernel/boot_floppy/cpuinfo/flag_arrays.c
new file mode 100644
index 0000000000..ff37c632a0
--- /dev/null
+++ b/src/tests/kernel/boot_floppy/cpuinfo/flag_arrays.c
@@ -0,0 +1,178 @@
+
+static char *Intel_feature_flags[32] = {
+	"FPU    Floating Point Unit",
+	"VME    Virtual 8086 Mode Enhancements",
+	"DE     Debugging Extensions",
+	"PSE    Page Size Extensions",
+	"TSC    Time Stamp Counter",
+	"MSR    Model Specific Registers",
+	"PAE    Physical Address Extension",
+	"MCE    Machine Check Exception",
+	"CX8    COMPXCHG8B Instruction",
+	"APIC   On-chip Advanced Programmable Interrupt Controller",
+	"10     Reserved",
+	"SEP    Fast System Call",
+	"MTRR   Memory Type Range Registers",
+	"PGE    PTE Global Flag",
+	"MCA    Machine Check Architecture",
+	"CMOV   Conditional Move and Compare Instructions",
+	"FGPAT  Page Attribute Table",
+	"PSE-36 36-bit Page Size Extension",
+	"PN     Processor Serial Number present and enabled",
+	"CLFSH  CFLUSH instruction",
+	"20     reserved",
+	"DS     Debug store",
+	"ACPI   Thermal Monitor and Clock Ctrl",
+	"MMX    MMX instruction set",
+	"FXSR   Fast FP/MMX Streaming SIMD Extensions save/restore",
+	"SSE    Streaming SIMD Extensions instruction set",
+	"SSE2   SSE2 extensions",
+	"SS     Self Snoop",
+	"HT     Hyper Threading",
+	"TM     Thermal monitor",
+	"30     reserved",
+	"31     reserved"
+};
+
+#if 0
+static char *AMD_feature_flags[32] = {
+	"Floating Point Unit",
+	"Virtual Mode Extensions",
+	"Debugging Extensions",
+	"Page Size Extensions",
+	"Time Stamp Counter (with RDTSC and CR4 disable bit)",
+	"Model Specific Registers with RDMSR & WRMSR",
+	"PAE - Page Address Extensions",
+	"Machine Check Exception",
+	"COMPXCHG8B Instruction",
+	"APIC",
+	"10 - Reserved",
+	"SYSCALL/SYSRET or SYSENTER/SYSEXIT instructions",
+	"MTRR - Memory Type Range Registers",
+	"Global paging extension",
+	"Machine Check Architecture",
+	"Conditional Move Instruction",
+	"PAT - Page Attribute Table",
+	"PSE-36 - Page Size Extensions",
+	"18 - reserved",
+	"19 - reserved",
+	"20 - reserved",
+	"21 - reserved",
+	"AMD MMX Instruction Extensions",
+	"MMX instructions",
+	"FXSAVE/FXRSTOR",
+	"25 - reserved",
+	"26 - reserved",
+	"27 - reserved",
+	"28 - reserved",
+	"29 - reserved",
+	"3DNow! Instruction Extensions",
+	"3DNow instructions"
+};
+
+
+static char *Cyrix_standard_feature_flags_5[32] = {
+	"FPU   Floating Point Unit",
+	"V86   Virtual Mode Extensions",
+	"Debug Extension",
+	"4MB Page Size",
+	"Time Stamp Counter",
+	"RDMSR/WRMSR (Model Specific Registers)",
+	"PAE",
+	"Machine Check Exception",
+	"COMPXCHG8B Instruction",
+	"APIC - On-chip Advanced Programmable Interrupt Controller",
+	"10 - Reserved",
+	"11 - Reserved",
+	"MTRR  Memory Type Range Registers",
+	"13 - reserved",
+	"Machine Check",
+	"CMOV  Conditional Move Instruction",
+	"16 - reserved",
+	"17 - reserved",
+	"18 - reserved",
+	"19 - reserved",
+	"20 - reserved",
+	"21 - reserved",
+	"22 - reserved",
+	"MMX instructions",
+	"24 - reserved",
+	"25 - reserved",
+	"26 - reserved",
+	"27 - reserved",
+	"28 - reserved",
+	"29 - reserved",
+	"30 - reserved"
+};
+
+
+static char *Cyrix_standard_feature_flags_not5[32] = {
+	"FPU   Floating Point Unit",
+	"V86   Virtual Mode Extensions",
+	"Debug Extension",
+	"4MB Page Size",
+	"Time Stamp Counter",
+	"RDMSR/WRMSR (Model Specific Registers)",
+	"PAE",
+	"Machine Check Exception",
+	"COMPXCHG8B Instruction",
+	"APIC - On-chip Advanced Programmable Interrupt Controller",
+	"10 - Reserved",
+	"11 - Reserved",
+	"MTRR  Memory Type Range Registers",
+	"Global Paging Extension",
+	"Machine Check",
+	"CMOV  Conditional Move Instruction",
+	"16 - reserved",
+	"17 - reserved",
+	"18 - reserved",
+	"19 - reserved",
+	"20 - reserved",
+	"21 - reserved",
+	"22 - reserved",
+	"MMX instructions",
+	"24 - reserved",
+	"25 - reserved",
+	"26 - reserved",
+	"27 - reserved",
+	"28 - reserved",
+	"29 - reserved",
+	"30 - reserved"
+};
+
+
+static char *Cyrix_extended_feature_flags[32] = {
+	"FPU   Floating Point Unit",
+	"V86   Virtual Mode Extensions",
+	"Debug Extension",
+	"Page Size Extensions",
+	"Time Stamp Counter",
+	"Cyrix MSR",
+	"PAE",
+	"MC Exception",
+	"COMPXCHG8B",
+	"APIC on chip",
+	"SYSCALL/SYSRET",
+	"11 - reserved",
+	"MTRR",
+	"Global bit",
+	"Machine Check",
+	"CMOV",
+	"FPU CMOV",
+	"17 - reserved",
+	"18 - reserved",
+	"19 - reserved",
+	"20 - reserved",
+	"21 - reserved",
+	"22 - reserved",
+	"MMX",
+	"Extended MMX",
+	"25 - reserved",
+	"26 - reserved",
+	"27 - reserved",
+	"28 - reserved",
+	"29 - reserved",
+	"30 - reserved",
+	"3DNow instructions"
+};
+#endif
diff --git a/src/tests/kernel/boot_floppy/cpuinfo/main.c b/src/tests/kernel/boot_floppy/cpuinfo/main.c
new file mode 100644
index 0000000000..27cfac32a9
--- /dev/null
+++ b/src/tests/kernel/boot_floppy/cpuinfo/main.c
@@ -0,0 +1,663 @@
+#include <OS.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "cpuinfo.h"
+#include "flag_arrays.c"
+
+
+
+extern char *__progname;
+static cpuid_info CPU_Data;
+
+
+void
+usage()
+{
+	printf("usage: %s [-option]\n\n"
+		"Prints information about your CPU.\n"
+		"  -i   CPU identification\n"
+		"  -f   supported processor features\n"
+		"  -t   TLB and cache info\n"
+		"  -d   dump registers from CPUID calls\n", __progname);
+
+	exit(0);
+}
+
+
+char
+getoption(char *optstr)
+{
+	if ((optstr[0] != '-')
+		|| (strlen(optstr) > 2)
+		|| (strchr("iftd", optstr[1]) == NULL))
+		// invalid option
+		usage();
+	
+	return optstr[1];
+}
+
+
+int
+main(int argc, char *argv[])
+{
+	// this program prints out everything you would ever want to know about
+	// your computer's processor, or your money back, in full (30 days, no hassle)
+	//
+	// technical reference:
+	//    "Intel Processor Identification and the CPUID Instruction"
+	//    (ftp://download.intel.com/design/Xeon/applnots/24161821.pdf)
+	
+	const char *no_support = "Sorry, your processor does not support this feature\n";
+	
+	char   option = 0;
+	int    vendor_tag;
+	uint32 max_level;
+	cpuid_info *info = &CPU_Data;
+	
+	if (argc == 2)
+		option = getoption(argv[1]);
+	else
+		usage();
+	
+	// get initial info (max_level and vendor_tag)
+	get_cpuid(info, 0, 0);
+	max_level  = info->eax_0.max_eax;
+	vendor_tag = info->regs.ebx;
+	
+	switch (option) {
+		case 'i':
+			printf("CPU identification:\n\n");
+			if (max_level < 1)
+				printf(no_support);
+			else
+				opt_identify(info, vendor_tag);
+			break;
+		
+		case 'f':
+			printf("Supported processor features:\n\n");
+			if (max_level < 1)
+				printf(no_support);
+			else
+				opt_features(info, vendor_tag);
+			break;
+		
+		case 't':
+			printf("TLB and cache information:\n\n");
+			if (max_level < 2)
+				printf(no_support);
+			else
+				opt_TLB_cache(info, vendor_tag);
+			break;
+		
+		case 'd':
+			printf("CPUID instruction call dump:\n\n");
+			opt_dump_calls(info, max_level);
+			break;
+	}
+
+	return 0;
+}
+
+
+void
+opt_identify(cpuid_info *info, int vendor_tag)
+{
+	// gosh, these CPU manufacturers have really outdone
+	// themselves on creating cutesy vendorID strings, no?
+	// (that was sarcasm, btw...)
+
+	char vendorID[12+1] = {0};
+
+	// the 'vendorid' field of the info struct is not null terminated,
+	// so it is copied into a properly terminated local string buffer
+	memcpy(vendorID, info->eax_0.vendor_id, 12);
+	printf("%12s '%s'\n", "Vendor ID:", vendorID);
+	
+	switch (vendor_tag) {
+		case 'uneG':  // "GenuineIntel"
+			Intel_identify(info);
+			break;
+
+		case 'htuA':  // "AuthenticAMD"
+			AMD_identify(info);
+			break;
+
+		case 'iryC':  // "CyrixInstead"
+			Cyrix_identify(info);
+			break;
+	}
+}
+
+
+void
+opt_features(cpuid_info *info, int vendor_tag)
+{
+	switch (vendor_tag) {
+		case 'uneG':  // "GenuineIntel"
+			Intel_features(info);
+			break;
+
+		case 'htuA':  // "AuthenticAMD"
+			AMD_features(info);
+			break;
+
+		case 'iryC':  // "CyrixInstead"
+			Cyrix_features(info);
+			break;
+	}
+}
+
+
+void
+opt_TLB_cache(cpuid_info *info, int vendor_tag)
+{	
+	switch (vendor_tag) {
+		case 'uneG':  // "GenuineIntel"
+			Intel_TLB_cache(info);
+			break;
+
+		case 'htuA':  // "AuthenticAMD"
+			AMD_TLB_cache(info);
+			break;
+
+		case 'iryC':  // "CyrixInstead"
+			Cyrix_TLB_cache(info);
+			break;
+	}
+}
+
+
+
+
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+// Intel specs
+
+void
+Intel_identify(cpuid_info *info)
+{
+	// the code for this function looks very boring and tedious
+	// (that's because it's very boring and tedious)
+	// but I think it's correct anyway (there's always that possibility!)
+	
+	int type, family, model, sig;
+	
+	get_cpuid(info, 1, 0);
+	type   = info->eax_1.type;
+	family = info->eax_1.family;
+	model  = info->eax_1.model;
+	
+	sig = info->regs.eax;
+	printf("%12s  0x%08X\n", "Signature:", sig);
+	
+	printf("%12s %2d '", "Type:", type);
+	if      (type == 0) printf("Original OEM");
+	else if (type == 1) printf("Overdrive");
+	else if (type == 2) printf("Dual-capable");
+	else if (type == 3) printf("Reserved");
+	printf("'\n");
+
+	printf("%12s %2d '", "Family:", family);
+	if      (family == 3)  printf("i386");
+	else if (family == 4)  printf("i486");
+	else if (family == 5)  printf("Pentium");
+	else if (family == 6)  printf("Pentium Pro");
+	else if (family == 15) printf("Pentium 4");
+	printf("'\n");
+	
+	if (family == 15) {
+		int efamily = (info->regs.eax >> 20) & 0xff;
+		printf("Extended family: %d\n", efamily);
+	}
+		
+	printf("%12s %2d '", "Model:", model);
+	switch (family) {
+	case 3:
+		break;
+	case 4:
+		if      (model == 0) printf("DX");
+		else if (model == 1) printf("DX");
+		else if (model == 2) printf("SX");
+		else if (model == 3) printf("487/DX2");
+		else if (model == 4) printf("SL");
+		else if (model == 5) printf("SX2");
+		else if (model == 7) printf("write-back enhanced DX2");
+		else if (model == 8) printf("DX4");			
+		break;
+	case 5:
+		if      (model == 1) printf("60/66");
+		else if (model == 2) printf("75-200");
+		else if (model == 3) printf("for 486 system");
+		else if (model == 4) printf("MMX");
+		break;
+	case 6:
+		if      (model == 1) printf("Pentium Pro");
+		else if (model == 3) printf("Pentium II Model 3");
+		else if (model == 5) printf("Pentium II Model 5/Xeon/Celeron");
+		else if (model == 6) printf("Celeron");
+		else if (model == 7) printf("Pentium III/Pentium III Xeon - external L2 cache");
+		else if (model == 8) printf("Pentium III/Pentium III Xeon - internal L2 cache");
+		break;
+	case 15:
+		break;
+	}
+	printf("'\n");
+	
+	if (model == 15) {
+		int emodel = (info->regs.eax >> 16) & 0xf;
+		printf("Extended model: %d\n", emodel);
+	}
+	
+	printf("%12s  0x%08lX\n", "Features:", info->eax_1.features);
+	
+	{
+		int id = info->regs.ebx & 0xff;
+		printf("%12s %2d '%s'\n", "Brand ID:", id, Intel_brand_string(id, sig));
+	}
+	
+	printf("%12s %2d\n", "Stepping:", info->eax_1.stepping);
+	printf("%12s %2d\n", "Reserved:", info->eax_1.reserved_0);
+	
+	get_cpuid(info, 0x80000000, 0);
+	if (info->regs.eax & 0x80000000) {
+		// extended feature/signature bits supported
+		if (info->regs.eax >= 0x80000004) {
+			uint32 i;
+
+			printf("\nExtended brand string:\n'");
+			for (i = 0x80000002; i <= 0x80000004; ++i) {
+				get_cpuid(info, i, 0);
+				print_regs(info);
+			}
+			printf("'\n");
+		}
+	}
+}
+
+
+const char *
+Intel_brand_string(int id, int processor_signature)
+{
+	int sig = processor_signature;
+	
+	switch (id) {
+	case 0x0: return "Unsupported";
+	case 0x1: return "Intel(R) Celeron(R) processor";
+	case 0x2: return "Intel(R) Pentium(R) III processor";
+	case 0x3: return (sig == 0x6B1) ? "Intel(R) Celeron(R) processor" : "Intel(R) Pentium(R) III Xeon(TM) processor";
+	case 0x4: return "Intel(R) Pentium(R) III processor";
+	case 0x5: return "";
+	case 0x6: return "Mobile Intel(R) Pentium(R) III Processor-M";
+	case 0x7: return "Mobile Intel(R) Celeron(R) processor";
+	case 0x8: return (sig >= 0xF13) ? "Intel(R) Genuine processor" : "Intel(R) Pentium(R) 4 processor";
+	case 0x9: return "Intel(R) Pentium(R) 4 processor";
+	case 0xA: return "Intel(R) Celeron(R) processor";
+	case 0xB: return (sig <  0xF13) ? "Intel(R) Xeon(TM) processor MP" : "Intel(R) Xeon(TM) processor";
+	case 0xC: return "Intel(R) Xeon(TM) processor MP";
+	case 0xD: return "";
+	case 0xE: return (sig <  0xF13) ? "Intel(R) Xeon(TM) processor" : "Mobile Intel(R) Pentium(R) 4 Processor-M";
+	case 0xF: return "Mobile Intel(R) Celeron(R) processor";
+	default:
+		return "";
+	}
+}
+
+
+void
+Intel_features(cpuid_info *info)
+{
+	// for each bit set in the features flag, print out the
+	// corresponding index in the flags array (too easy!)
+	
+	int i;
+	int fflags;
+	
+	get_cpuid(info, 1, 0);
+	fflags = info->eax_1.features;
+	
+	for (i = 0; i < 32; ++i)
+		if (fflags & (1<<i))
+			printf("   %s\n", Intel_feature_flags[i]);
+	
+	printf("\n");
+}
+
+
+void
+insert(int *a, int elem, int max_index)
+{
+	// inserts a new element into an ordered integer array
+	// using (what else) the trusty old binary search algorithm...
+	// assumes the array has sufficient space to do this
+	// (i.e. it's the caller's problem to check for bounds overflow)
+	
+	int i;
+	int lo = 0;
+	int hi = max_index;
+	int mid;
+
+	// find insert index (will end up in lo)
+	while (lo < hi) {
+		mid = (lo + hi) / 2;
+		if (elem < a[mid])
+			hi = mid;
+		else
+			lo = mid + 1;
+	}
+
+	// bump up the max index (to make room for the new element)
+	hi = max_index + 1;
+	
+	// move up all the items after the insert point by one
+	for (i = hi; i > lo; --i)
+		a[i] = a[i-1];
+	
+	// insert the new guy
+	a[lo] = elem;
+}
+
+
+void
+Intel_TLB_cache(cpuid_info *info)
+{
+	// displays technical info for the CPU's various instruction and data pipeline caches
+	// and the TLBs (Translation Lookaside Buffers).
+	//
+	// The method for extracting and displaying this info might be less than obvious,
+	// so here's an explanation:
+	//
+	// The TLB/Cache info is stored in a global table. Each entry is uniquely identified
+	// by a descriptor byte. Additionally, each entry is catagorized according to the
+	// cache type. A textual string contains the information to display.
+	//
+	// To retrieve the CPUs capabilities, the pass loop repeatedly (maybe) calls
+	// get_cpuid() which fills the registers. Each register is a 4-byte datum,
+	// capable of holding up to 4 descriptor bytes. The descriptor bytes are extracted
+	// (thru shifting and masking) and then inserted into a slot array. The slot array
+	// stores indexes into the table. Since descriptor bytes are not indexes themselves,
+	// an index array is created and used to convert them. The slot array is filled so
+	// as to keep the indexes in sorted order -- this guarantees than all entries for
+	// a particular cache type will display together.
+	//
+	// After the pass loop is finished, the slot array contains the indexes of all the
+	// table entries that apply to the host processor. Displaying the info is merely a matter
+	// of spinning thru the slot array and printing the text. The output, however, is organized
+	// by the cache types -- this technique *only* works because the TLB/Cache table has been
+	// carefully arranged in that order.
+	
+	#define BIT_31_MASK (1 << 31)
+	
+	uint32 pass, matches;       // counters
+	uint32 reg;                 // value of an individual register (eax, ebx, ecx, edx)
+	uint8  db;                  // descriptor byte
+	int    indexOf[256] = {0};  // converts descriptor bytes to table indexes
+	int    slot[256] = {0};     // indexes into the TLB/Cache table (for entries found)
+	
+	tlbc_info *tab = Intel_TLB_Cache_Table;
+	int   tabsize  = sizeof Intel_TLB_Cache_Table / sizeof(Intel_TLB_Cache_Table[0]);
+
+	// fill the index conversion array
+	int i = 0;
+	int n = 0;
+
+	while (n < tabsize)
+		indexOf[tab[n++].descriptor] = i++;
+
+	// pass loop: insert relevant table indexes into the slot array
+	i = 0;
+	for (pass = 0; ; ++pass) {
+		get_cpuid(info, 2, 0);
+		
+		// low byte of eax register holds maximum iterations
+		reg = info->regs.eax;
+		if (pass >= (reg & 0xff))
+			break;
+		
+		reg >>= 8; // skip low byte
+		for (; reg; reg >>= 8)
+			if ((db = (reg & 0xff)))
+				insert(slot, indexOf[db], i++);
+		
+		reg = info->regs.ebx;  // ebx
+		if ((reg & BIT_31_MASK) == 0)
+			for (; reg; reg >>= 8)
+				if ((db = (reg & 0xff)))
+					insert(slot, indexOf[db], i++);
+
+		reg = info->regs.ecx;  // ecx
+		if ((reg & BIT_31_MASK) == 0)
+			for (; reg; reg >>= 8)
+				if ((db = (reg & 0xff)))
+					insert(slot, indexOf[db], i++);
+
+		reg = info->regs.edx;  // edx
+		if ((reg & BIT_31_MASK) == 0)
+			for (; reg; reg >>= 8)
+				if ((db = (reg & 0xff)))
+					insert(slot, indexOf[db], i++);
+	}
+
+	// reset slot index for output loop
+	i = 0;
+	
+	// eeiuw! an icky macro (but it really does prevent much repetitive code)	
+	#define display_matching_entries(type_name,type_code) \
+		printf(type_name ":\n"); \
+		matches = 0; \
+		while (tab[n = slot[i]].cache_type == type_code) { \
+			printf("   %s\n", tab[n].text); \
+			++matches; \
+			++i; \
+		} \
+		if (matches == 0) \
+			printf("   None\n")
+	
+	// at long last... output the data
+	display_matching_entries("Instruction TLB", Inst_TLB);
+	display_matching_entries("Data TLB", Data_TLB);
+	display_matching_entries("L1 Instruction Cache", L1_Inst_Cache);
+	display_matching_entries("L1 Data Cache", L1_Data_Cache);
+	display_matching_entries("L2 Cache", L2_Cache);
+	
+	if (tab[slot[i]].cache_type == No_L2_Or_L3)
+		// no need to print the text on this one, just skip it
+		++i;
+	
+	display_matching_entries("L3 Cache", L3_Cache);
+	display_matching_entries("Trace Cache", Trace_Cache);
+}
+
+
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+// AMD specs
+
+// Brennan says: I'm just digging around and trying to find AMD documentation
+// on product signatures and CPU types...not easy to find. This is a dirty hack
+// until I can find proper docs...
+
+static const char *
+AMD_brand_string(int family, int model, int processor_signature)
+{
+	int sig = processor_signature;
+	
+	switch (family) {
+		//K5 and K6 models
+		case 0x5: 
+			if(model >= 0x0 && model <= 0x3) {
+				return "AMD K5";
+			}
+			else if(model == 0x8){
+				return "AMD K6-2";
+			}
+			else if(model == 0x9) {
+				return "AMD K6-III";
+			}
+			else {
+				return "AMD K6";
+			}
+		//Athlon and Duron models, very general
+		case 0x6:
+			//Hack.  I own one, so I know this is the processor signature!
+			if(sig == 1634) {
+				return "AMD Mobile Athlon";
+			}
+			else if(model == 0x1 || model == 0x2 || model == 0x4) {
+				return "AMD Athlon";
+			}
+			else if(model == 0x3 ||model == 0x7) {
+				return "AMD Duron";
+			}
+			else if(model == 0x6){
+				return "AMD Duron/AMD Athlon XP/AMD Athlon MP";
+			}
+		case 0xf: 
+			if(model == 0x5) {
+				return "AMD Athlon 64";
+			}
+			if(model == 0x6) {
+				return "AMD Opteron";
+			}
+			//This is the new 266FSB Duron model
+			else if(model == 0x8) {
+				return "AMD Duron (266 FSB)";
+			}
+		default:
+			return "Unknown AMD Processor";
+	}
+}
+
+
+void
+AMD_identify(cpuid_info *info)
+{
+	int type, family, model, sig;
+	const char *id_string;
+	
+	get_cpuid(info, 1, 0);
+	type   = info->eax_1.type;
+	family = info->eax_1.family;
+	model  = info->eax_1.model;
+	sig = info->regs.eax;
+	
+	id_string = AMD_brand_string(family, model, sig);
+	
+	printf("%s, Model: %d\n", id_string, model);
+	printf("Family: %d\n", family);
+	printf("Signature: %d\n", sig);
+	
+}
+
+
+void
+AMD_features(cpuid_info *info)
+{
+	printf("Sorry! Info about AMD CPU's not implemented yet :(\n");
+}
+
+
+void
+AMD_TLB_cache(cpuid_info *info)
+{
+	printf("Sorry! Info about AMD CPU's not implemented yet :(\n");
+}
+
+
+
+
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+// Cyrix specs
+
+
+void
+Cyrix_identify(cpuid_info *info)
+{
+	printf("Sorry! Info about Cyrix CPU's not implemented yet :(\n");
+}
+
+
+void
+Cyrix_features(cpuid_info *info)
+{
+	printf("Sorry! Info about Cyrix CPU's not implemented yet :(\n");
+}
+
+
+void
+Cyrix_TLB_cache(cpuid_info *info)
+{
+	printf("Sorry! Info about Cyrix CPU's not implemented yet :(\n");
+}
+
+
+
+
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+// dumps
+
+
+void
+opt_dump_calls(cpuid_info *info, uint32 max_level)
+{
+	// dumps the registers for standard (and if supported) extended
+	// calls to the CPUID instruction
+
+	uint32 max_extended;
+
+	dump_regs(info, "Standard Calls", 0, max_level);
+
+	get_cpuid(info, 0x80000000, 0);
+	max_extended = info->regs.eax;
+	
+	if (max_extended == 0)
+		printf("\nNo extended calls available for this CPU\n");
+	else
+		dump_regs(info, "Extended Calls", 0x80000000, max_extended);
+}
+
+
+void
+dump_regs(cpuid_info *info, const char *heading, uint32 min_level, uint32 max_level)
+{
+	// gosh, it's so perty (in a text-based output kind of way)
+	
+	uint32 i;
+	
+	printf("%s (max eax level = %lx)\n", heading, max_level);
+	printf("----------------------------------------------\n");
+	printf("  Input  |   Output\n");
+	printf("----------------------------------------------\n");
+	printf("  eax    |   eax      ebx      ecx      edx\n");
+
+	for (i = min_level; i <= max_level; ++i) {
+		get_cpuid(info, i, 0);
+		printf("%08lx | %08lx %08lx %08lx %08lx\n",
+		       i,
+		       info->regs.eax,
+		       info->regs.ebx,
+		       info->regs.ecx,
+		       info->regs.edx);
+	}
+	printf("\n");
+}
+
+
+void
+print_regs(cpuid_info *info)
+{
+	// this function either prints the contents of all the
+	// registers as a single character string, or it does
+	// something else entirely (you decide)
+	
+	int i;
+	char s[17] = {0};
+	
+	for (i = 0; i < 4; ++i)
+		s[i]    = info->regs.eax >> (8*i),
+		s[i+4]  = info->regs.ebx >> (8*i),
+		s[i+8]  = info->regs.ecx >> (8*i),
+		s[i+12] = info->regs.edx >> (8*i);
+	
+	printf("%s", s);
+}
+
diff --git a/src/tests/kernel/boot_floppy/echo/Jamfile b/src/tests/kernel/boot_floppy/echo/Jamfile
new file mode 100644
index 0000000000..8db262a729
--- /dev/null
+++ b/src/tests/kernel/boot_floppy/echo/Jamfile
@@ -0,0 +1,3 @@
+SubDir OBOS_TOP src kernel apps echo ;
+
+KernelObjects <$(SOURCE_GRIST)>main.c : -fpic -Wno-unused ;
diff --git a/src/tests/kernel/boot_floppy/echo/main.c b/src/tests/kernel/boot_floppy/echo/main.c
new file mode 100644
index 0000000000..257dbb953d
--- /dev/null
+++ b/src/tests/kernel/boot_floppy/echo/main.c
@@ -0,0 +1,79 @@
+/*
+ * Copyright (c) 1989, 1993
+ *	The Regents of the University of California.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *	This product includes software developed by the University of
+ *	California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+
+int
+main(int argc , char *argv[])
+{
+	int nflag;	/* if not set, output a trailing newline. */
+
+	/* This utility may NOT do getopt(3) option parsing. */
+	if (*++argv && !strcmp(*argv, "-n")) {
+		++argv;
+		nflag = 1;
+	} else
+		nflag = 0;
+
+	while (argv[0] != NULL) {
+
+		/*
+		 * If the next argument is NULL then this is this
+		 * the last argument, therefore we need to check
+		 * for a trailing \c.
+		 */
+		if (argv[1] == NULL) {
+			size_t len;
+			
+			len = strlen(argv[0]);
+			/* is there room for a '\c' and is there one? */
+			if (len >= 2 &&
+			    argv[0][len - 2] == '\\' &&
+			    argv[0][len - 1] == 'c') {
+				/* chop it and set the no-newline flag. */
+				argv[0][len - 2] = '\0';
+				nflag = 1;
+			}
+		}
+		(void)printf("%s", argv[0]);
+		if (*++argv)
+			putchar(' ');
+	}
+	if (!nflag)
+		putchar('\n');
+	return 0;
+}
diff --git a/src/tests/kernel/boot_floppy/envtest/Jamfile b/src/tests/kernel/boot_floppy/envtest/Jamfile
new file mode 100644
index 0000000000..9221a98e85
--- /dev/null
+++ b/src/tests/kernel/boot_floppy/envtest/Jamfile
@@ -0,0 +1,3 @@
+SubDir OBOS_TOP src kernel apps envtest ;
+
+KernelObjects <$(SOURCE_GRIST)>main.c : -fpic -Wno-unused ;
diff --git a/src/tests/kernel/boot_floppy/envtest/main.c b/src/tests/kernel/boot_floppy/envtest/main.c
new file mode 100644
index 0000000000..9b15cc5556
--- /dev/null
+++ b/src/tests/kernel/boot_floppy/envtest/main.c
@@ -0,0 +1,66 @@
+/*
+** Copyright 2003-2004, The Haiku Team. All rights reserved.
+** Distributed under the terms of the Haiku License.
+*/
+
+
+#include <image.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+
+int
+main(int argc, char **argv)
+{
+	int i;
+	thread_id pid;
+	status_t rc;
+	char temp[16];
+	char *var;
+	
+	printf("Setting some env vars...\n");
+	
+	if (setenv("TEST", "This is a test!", 0)) {
+		printf("setenv() error\n");
+		return -1;
+	}
+	if (setenv("HOME", "/boot", 1)) {
+		printf("setenv() error\n");
+		return -1;
+	}
+
+	printf("Getting VAR_1: ");
+	var = getenv("VAR_1");
+	if (var)
+		printf("found set to: \"%s\"\n", var);
+	else
+		printf("not found\n");
+
+	printf("List of env variables set:\n");
+	for (i = 0; environ[i]; i++)
+		printf("%s\n", environ[i]);
+
+	if (argc > 1) {
+		char buffer[16];
+		const char *_argv[] = { argv[0], buffer, NULL };
+		int val = atoi(argv[1]) - 1;
+		
+		sprintf(temp, "VAR_%d", val);
+		if (setenv(temp, "dummy", 0)) {
+			printf("setenv() error\n");
+			return -1;
+		}
+		
+		if (val > 0) {
+			printf("Spawning test (%d left)\n", val);
+			sprintf(buffer, "%d", val);
+			pid = load_image(2, _argv, (const char **)environ);
+			wait_for_thread(pid, &rc);
+		}
+	}
+	return 0;
+}
+
+
diff --git a/src/tests/kernel/boot_floppy/exec_test.c b/src/tests/kernel/boot_floppy/exec_test.c
new file mode 100644
index 0000000000..ce1409342b
--- /dev/null
+++ b/src/tests/kernel/boot_floppy/exec_test.c
@@ -0,0 +1,52 @@
+/* 
+** Copyright 2004, Axel Dörfler, axeld@pinc-software.de. All rights reserved.
+** Distributed under the terms of the Haiku License.
+*/
+
+
+#include <OS.h>
+
+#include <unistd.h>
+#include <stdio.h>
+#include <string.h>
+#include <errno.h>
+
+
+static void
+print_process_info(const char *text)
+{
+	puts(text);
+
+	printf("\tsession_id = %ld\n", getsid(0));
+	printf("\tgroup_id = %ld\n", getpgid(0));
+	printf("\tprocess_id = %ld\n", getpid());
+	printf("\tparent_id = %ld\n", getppid());
+}
+
+
+int
+main(int argc, char **argv)
+{
+	printf("exec_test: this is thread %ld\n", find_thread(NULL));
+
+	if (argc < 2) {
+		print_process_info("before exec():");
+		puts("going to execl()...");
+
+		execl("/bin/exec_test", "/bin/exec_test", "argument 1", NULL);
+		printf("execl() returned: %s\n", strerror(errno));
+	} else {
+		int i;
+
+		print_process_info("after exec():");
+		puts("got arguments:");
+		for (i = 0; i < argc; i++)
+			printf("%d: \"%s\"\n", i, argv[i]);
+
+		setsid();
+		print_process_info("after setsid():");
+	}
+
+	return 0;
+}
+
diff --git a/src/tests/kernel/boot_floppy/false_main.c b/src/tests/kernel/boot_floppy/false_main.c
new file mode 100644
index 0000000000..9128fb0be9
--- /dev/null
+++ b/src/tests/kernel/boot_floppy/false_main.c
@@ -0,0 +1,13 @@
+/*
+** Copyright 2002, Manuel J. Petit. All rights reserved.
+** Contains portions of:
+**
+**    /boot/bin/true, Copyright 2001 Travis K. Geiselbrecht
+**
+** Distributed under the terms of the NewOS License.
+*/
+int main(void)
+{
+	return 1;
+}
+
diff --git a/src/tests/kernel/boot_floppy/fibo_main.c b/src/tests/kernel/boot_floppy/fibo_main.c
new file mode 100644
index 0000000000..2fd4a70113
--- /dev/null
+++ b/src/tests/kernel/boot_floppy/fibo_main.c
@@ -0,0 +1,72 @@
+/*
+** Copyright 2002, Manuel J. Petit. All rights reserved.
+** Distributed under the terms of the NewOS License.
+*/
+
+
+#include <image.h>
+
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+
+static void
+usage(char const *app)
+{
+	printf("usage: %s [-s] ###\n", app);
+	exit(-1);
+}
+
+
+int
+main(int argc, char *argv[])
+{
+	int num = 0;
+	int silent = 0;
+	int result;
+
+	switch (argc) {
+		case 2:
+			num = atoi(argv[1]);
+			break;
+		case 3:
+			if (strcmp(argv[1], "-s") == 0) {
+				num = atoi(argv[2]);
+				silent = 1;
+			} else {
+				usage(argv[0]);
+			}
+			break;
+		default:
+			usage(argv[0]);
+			break;
+	}
+
+	if (num < 2) {
+		result = 1;
+	} else {
+		thread_id pid;
+		status_t retcode;
+		char buffer[64];
+		const char *aaargv[] = { "/boot/bin/fibo", "-s", buffer, NULL };
+		int  aaargc = 3;
+
+		sprintf(buffer, "%d", num-1);
+		pid = load_image(aaargc, aaargv, (const char **)environ);
+		wait_for_thread(pid, &retcode);
+		result = retcode;
+
+		sprintf(buffer, "%d", num-2);
+		pid = load_image(aaargc, aaargv, (const char **)environ);
+		wait_for_thread(pid, &retcode);
+		result += retcode;
+	}
+
+	if (silent) {
+		return result;
+	} else {
+		printf("%d\n", result);
+		return 0;
+	}
+}
diff --git a/src/tests/kernel/boot_floppy/filetest/Jamfile b/src/tests/kernel/boot_floppy/filetest/Jamfile
new file mode 100644
index 0000000000..d01295c6b4
--- /dev/null
+++ b/src/tests/kernel/boot_floppy/filetest/Jamfile
@@ -0,0 +1,3 @@
+SubDir OBOS_TOP src kernel apps filetest ;
+
+KernelObjects <$(SOURCE_GRIST)>main.c : -fpic -Wno-unused ;
diff --git a/src/tests/kernel/boot_floppy/filetest/main.c b/src/tests/kernel/boot_floppy/filetest/main.c
new file mode 100644
index 0000000000..497a941514
--- /dev/null
+++ b/src/tests/kernel/boot_floppy/filetest/main.c
@@ -0,0 +1,52 @@
+/*
+** Copyright 2001-2002, Travis Geiselbrecht. All rights reserved.
+** Distributed under the terms of the NewOS License.
+*/
+
+#include <string.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <sys/resource.h>
+#include <Errors.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <sys/ioctl.h>
+
+#define FORTUNES "/boot/etc/fortunes"
+
+int main(int argc, char **argv)
+{
+	int rc = 0, fd[3];
+	int cnt, i;
+	int on = 1;
+	
+	printf("File Test!!!\n");
+
+	for (i=0;i<3;i++) {
+		printf("%d : ", i + 1);
+		fd[i] = open(FORTUNES, O_RDONLY, 0);
+		printf("fd %d\n", fd[i]);
+	}
+	
+	printf("closing the 3 fd's\n");
+	for (i=0;i<3;i++) {
+		close(fd[i]);
+	}
+
+	printf("\nNow we have no open fd's so next socket should be 3\n");
+	fd[0] = open(FORTUNES, O_RDONLY, 0);
+	printf("new fd %d\n", fd[0]);
+	
+	printf("Trying ioctl to set non-blocking: ");
+	rc = ioctl(fd[0], FIONBIO, &on, sizeof(on));
+	if (rc == EINVAL) {
+		printf("OK\n");
+	} else {
+		printf("failed\n");
+		printf("error was %s\n", strerror(errno));
+	}
+	
+	close(fd[0]);
+	
+	return 0;
+}
diff --git a/src/tests/kernel/boot_floppy/fork_test.c b/src/tests/kernel/boot_floppy/fork_test.c
new file mode 100644
index 0000000000..4252cef5aa
--- /dev/null
+++ b/src/tests/kernel/boot_floppy/fork_test.c
@@ -0,0 +1,33 @@
+/* 
+** Copyright 2004, Axel Dörfler, axeld@pinc-software.de. All rights reserved.
+** Distributed under the terms of the Haiku License.
+*/
+
+
+#include <OS.h>
+
+#include <unistd.h>
+#include <sys/wait.h>
+#include <stdio.h>
+#include <string.h>
+#include <errno.h>
+
+
+int
+main(int argc, char **argv)
+{
+	pid_t child = fork();
+
+	if (child == 0) {
+		printf("CHILD: we're the child!\n");
+		snooze(500000);	// .5 sec
+		printf("CHILD: exit!\n");
+	} else if (child > 0) {
+		printf("PARENT: we're the parent, our child has pid %ld\n", child);
+		waitpid(-1, NULL, 0);
+	} else
+		fprintf(stderr, "fork() failed: %s\n", strerror(errno));
+
+	return 0;
+}
+
diff --git a/src/tests/kernel/boot_floppy/fortune/Jamfile b/src/tests/kernel/boot_floppy/fortune/Jamfile
new file mode 100644
index 0000000000..ca41fe0e4b
--- /dev/null
+++ b/src/tests/kernel/boot_floppy/fortune/Jamfile
@@ -0,0 +1,7 @@
+SubDir OBOS_TOP src kernel apps fortune ;
+
+KernelObjects
+	<$(SOURCE_GRIST)>main.c
+	:
+	-fpic
+	;
diff --git a/src/tests/kernel/boot_floppy/fortune/fortunes b/src/tests/kernel/boot_floppy/fortune/fortunes
new file mode 100644
index 0000000000..168166bd09
--- /dev/null
+++ b/src/tests/kernel/boot_floppy/fortune/fortunes
@@ -0,0 +1,9 @@
+#@#
+Magic is real... unless declared integer.
+#@#
+System is up and running.
+#@#
+Open source thesis that thousand of eyes looking thu the code
+increases software quality is completely wrong. The amount of
+bugs per line of code is an universal constant. The bazaar
+model only achieves a quick bug turnover.
diff --git a/src/tests/kernel/boot_floppy/fortune/main.c b/src/tests/kernel/boot_floppy/fortune/main.c
new file mode 100644
index 0000000000..64dd6ea9c8
--- /dev/null
+++ b/src/tests/kernel/boot_floppy/fortune/main.c
@@ -0,0 +1,80 @@
+/*
+** Copyright 2002-2004, The OpenBeOS Team. All rights reserved.
+** Distributed under the terms of the OpenBeOS License.
+*/
+
+#include <unistd.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <syscalls.h>
+#include <fcntl.h>
+#include <sys/stat.h>
+#include <errno.h>
+
+#define FORTUNES "/etc/fortunes"
+
+int
+main(void)
+{
+	int fd;
+	int rc;
+	char *buf;
+	unsigned i;
+	unsigned found;
+	struct stat stat;
+
+	fd = open(FORTUNES, O_RDONLY, 0);
+	if (fd < 0) {
+		printf("Couldn't open %s: %s\n", FORTUNES, strerror(errno));
+		return -1;
+	}
+
+	rc = fstat(fd, &stat);
+	if (rc < 0) {
+		printf("stat() failed: %s\n", strerror(errno));
+		return -1;
+	}
+
+	buf = malloc(stat.st_size + 1);
+	rc = read(fd, buf, stat.st_size);
+	if (rc < 0) {
+		printf("Could not read from fortune file: %s\n", strerror(errno));
+		return -1;
+	}
+
+	buf[stat.st_size] = 0;
+	close(fd);
+
+	found = 0;
+	for (i = 0; i < stat.st_size; i++) {
+		if (!strncmp(buf + i, "#@#", 3))
+			found += 1;
+	}
+
+	if (found > 0)
+		found = 1 + ((system_time() + 3) % found);
+	else {
+		printf("Out of cookies...\n");
+		return -1;
+	}
+
+	for (i = 0; i < stat.st_size; i++) {
+		if (!strncmp(buf + i, "#@#", 3))
+			found -= 1;
+
+		if (found == 0) {
+			unsigned j;
+
+			for (j = i + 1; j < stat.st_size; j++) {
+				if (!strncmp(buf + j, "#@#", 3))
+					buf[j] = 0;
+			}
+
+			printf("%s\n", buf + i + 3);
+			break;
+		}
+	}
+
+	return 0;
+}
diff --git a/src/tests/kernel/boot_floppy/hostname/Jamfile b/src/tests/kernel/boot_floppy/hostname/Jamfile
new file mode 100644
index 0000000000..d9e516d0c1
--- /dev/null
+++ b/src/tests/kernel/boot_floppy/hostname/Jamfile
@@ -0,0 +1,3 @@
+SubDir OBOS_TOP src kernel apps hostname ;
+
+KernelObjects <$(SOURCE_GRIST)>main.c : -fpic -Wno-unused ;
diff --git a/src/tests/kernel/boot_floppy/hostname/main.c b/src/tests/kernel/boot_floppy/hostname/main.c
new file mode 100644
index 0000000000..2630de5369
--- /dev/null
+++ b/src/tests/kernel/boot_floppy/hostname/main.c
@@ -0,0 +1,42 @@
+/* naive implementation of hostname
+ *
+ * This mainly serves as a testbed for sysctl, part of the kernel
+ * just added.
+ */
+
+#include <syscalls.h>
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+#include <sysctl.h>
+
+#define MAXHOSTNAMELEN  256 
+
+int main(int argc, char *argv[])
+{
+	char buffer[MAXHOSTNAMELEN];
+	size_t buflen = MAXHOSTNAMELEN;
+	int mib[2];
+	int rc = -1;
+	char *newname = NULL;
+	size_t newnamelen = 0;
+	
+	if (argc >= 2) {
+		newname = argv[1];
+		newnamelen = strlen(newname);
+	}
+	
+	buffer[0] = '\0';
+	mib[0] = CTL_KERN;
+	mib[1] = KERN_HOSTNAME;
+	
+	rc = sysctl(mib, 2, &buffer, &buflen, newname, newnamelen);
+	
+	if (rc == 0 && !newname) {
+		printf("%s\n", buffer);
+	}
+	
+	return 0;
+}
+
+
diff --git a/src/tests/kernel/boot_floppy/init.c b/src/tests/kernel/boot_floppy/init.c
new file mode 100644
index 0000000000..c45125820a
--- /dev/null
+++ b/src/tests/kernel/boot_floppy/init.c
@@ -0,0 +1,52 @@
+/*
+** Copyright 2001, Travis Geiselbrecht. All rights reserved.
+** Distributed under the terms of the NewOS License.
+*/
+
+
+#include <image.h>
+
+#include <unistd.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <fcntl.h>
+
+
+static void
+setup_io(void)
+{
+	int i;
+
+	for (i = 0; i< 256; i++) {
+		close(i);
+	}
+
+	open("/dev/keyboard", O_RDONLY, 0); /* stdin  */
+	open("/dev/console", O_WRONLY, 0); /* stdout */
+	open("/dev/console", O_WRONLY, 0); /* stderr */
+}
+
+
+int
+main(int argc, char **argv)
+{
+	setup_io();
+
+	printf("Welcome to Haiku!\r\n");
+
+	{
+		const char *args[] = {"consoled", NULL};
+		thread_id thread;
+
+		thread = load_image(1, args, (const char **)environ);
+		if (thread >= B_OK) {
+			status_t returnCode;
+			wait_for_thread(thread, &returnCode);
+		} else
+			printf("Failed to create a team for fortune.\n");
+	}
+
+	printf("init exiting\n");
+
+	return 0;
+}
diff --git a/src/tests/kernel/boot_floppy/ls/Jamfile b/src/tests/kernel/boot_floppy/ls/Jamfile
new file mode 100644
index 0000000000..f5ddbae634
--- /dev/null
+++ b/src/tests/kernel/boot_floppy/ls/Jamfile
@@ -0,0 +1,8 @@
+SubDir OBOS_TOP src kernel apps ls ;
+
+KernelObjects
+	<$(SOURCE_GRIST)>main.c
+	:
+	-fpic -Wno-unused
+	;
+
diff --git a/src/tests/kernel/boot_floppy/ls/main.c b/src/tests/kernel/boot_floppy/ls/main.c
new file mode 100644
index 0000000000..6ccf71377c
--- /dev/null
+++ b/src/tests/kernel/boot_floppy/ls/main.c
@@ -0,0 +1,163 @@
+/*
+** Copyright 2002, Travis Geiselbrecht. All rights reserved.
+** Distributed under the terms of the NewOS License.
+*/
+#include <syscalls.h>
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/stat.h>
+#include <dirent.h>
+#include <errno.h>
+
+extern char *__progname;
+
+void (*disp_func)(const char *, const char *, struct stat *) = NULL;
+static int show_all = 0;
+
+mode_t perms [9] = {
+	S_IRUSR,
+	S_IWUSR,
+	S_IXUSR,
+	S_IRGRP,
+	S_IWGRP,
+	S_IXGRP,
+	S_IROTH,
+	S_IWOTH,
+	S_IXOTH
+};
+	
+
+static void
+display_l(const char *path, const char *filename, struct stat *stat)
+{
+	char perm[11];
+	uint32 i;
+	memset(perm, '-', 10);
+	perm[10] = '\0';
+
+	for (i = 0; i < sizeof(perms) / sizeof(mode_t); i++) {
+		if (stat->st_mode & perms[i]) {
+			switch(i % 3) {
+				case 0:
+					perm[i + 1] = 'r';
+					break;
+				case 1:
+					perm[i+1] = 'w';
+					break;
+				case 2:
+					perm[i+1] = 'x';
+			}
+		}
+	}
+	if (S_ISDIR(stat->st_mode))
+		perm[0] = 'd';
+	else if (S_ISLNK(stat->st_mode))
+		perm[0] = 'l';
+	else if (S_ISCHR(stat->st_mode))
+		perm[0] = 'c';
+
+	printf("%10s %12lld %s" ,perm ,stat->st_size ,filename);
+
+	if (S_ISLNK(stat->st_mode)) {
+		char buffer[1024];
+		if (readlink(path, buffer, sizeof(buffer)) < 0)
+			strcpy(buffer, "???");
+		printf(" (-> %s)\n", buffer);
+	} else
+		putchar('\n');
+}
+
+
+static void
+display(const char *path, const char *filename, struct stat *stat)
+{
+	printf("%s\n", filename);
+}
+
+
+int
+main(int argc, char *argv[])
+{
+	int rc;
+	int rc2;
+	int count = 0;
+	struct stat st;
+	char *arg;
+	int ch;
+	uint64 totbytes = 0;
+	
+	disp_func = display;
+	
+	while ((ch = getopt(argc, argv, "al")) != -1) {
+		switch (ch) {
+			case 'a':
+				show_all = 1;
+				break;
+			case 'l':
+				disp_func = display_l;
+				break;
+		}
+	}
+	argc -= optind;
+	argv += optind;
+
+	if (*argv == NULL)
+		arg = ".";
+	else
+		arg = *argv;
+	
+	rc = stat(arg, &st);
+	if (rc < 0) {
+		printf("%s: %s: %s\n", __progname,
+		       arg, strerror(rc));
+		goto err_ls;
+	}
+
+	if (S_ISDIR(st.st_mode)) {
+		DIR *thedir = opendir(arg);
+		
+		if (!thedir) {
+			printf("ls: %s: %s\n", arg, strerror(errno));
+		} else {
+			if (show_all) {
+				/* process the '.' entry */
+				rc = stat(arg, &st);
+				if (rc == 0) {
+					(*disp_func)(arg, ".", &st);
+					totbytes += st.st_size;
+				}
+			}
+			
+			for(;;) {
+				char buf2[1024];
+				struct dirent *de = readdir(thedir);
+
+				if (!de)
+					break;
+
+				memset(buf2, 0, sizeof(buf2));
+				if (strcmp(arg, ".") != 0) {
+					strlcpy(buf2, arg, sizeof(buf2));
+					strlcat(buf2, "/", sizeof(buf2));
+				}
+				strlcat(buf2, de->d_name, sizeof(buf2));
+
+				rc2 = lstat(buf2, &st);
+				if (rc2 == 0) {
+					(*disp_func)(buf2, de->d_name, &st);
+					totbytes += st.st_size;
+				}
+				count++;
+			}
+			closedir(thedir);
+		}
+
+		printf("%lld bytes in %d files\n", totbytes, count);
+	} else {
+		(*disp_func)(arg, arg, &st);
+	}
+
+err_ls:
+	return 0;
+}
diff --git a/src/tests/kernel/boot_floppy/monitor_test.c b/src/tests/kernel/boot_floppy/monitor_test.c
new file mode 100644
index 0000000000..8e5f8bcfa2
--- /dev/null
+++ b/src/tests/kernel/boot_floppy/monitor_test.c
@@ -0,0 +1,44 @@
+/* tests node monitor functionality (very basic test!) */
+
+/* 
+** Copyright 2003-2004, Axel Dörfler, axeld@pinc-software.de. All rights reserved.
+** Distributed under the terms of the Haiku License.
+*/
+
+
+#include <OS.h>
+#include <NodeMonitor.h>
+#include <syscalls.h>
+
+#include <stdio.h>
+#include <unistd.h>
+#include <string.h>
+
+
+int
+main(int argc, char **argv)
+{
+	struct stat st;
+	if (stat("/", &st) < 0) {
+		fprintf(stderr, "Could not stat root!\n");
+		return -1;
+	}
+
+	printf("watch file: device = %ld, node = %Ld\n", st.st_dev, st.st_ino);
+
+	if (_kern_start_watching(st.st_dev, st.st_ino, B_WATCH_DIRECTORY, 1, 2) < B_OK) {
+		fprintf(stderr, "Could not start watching!\n");
+		return -1;
+	}
+
+	mkdir("/temp_test", 0755);
+	rmdir("/temp_test");
+
+	if (_kern_stop_watching(st.st_dev, st.st_ino, 0, 1, 2) < B_OK) {
+		fprintf(stderr, "Could not stop watching!\n");
+		return -1;
+	}
+
+	return 0;
+}
+
diff --git a/src/tests/kernel/boot_floppy/on_exit_thread.c b/src/tests/kernel/boot_floppy/on_exit_thread.c
new file mode 100644
index 0000000000..7ea9565512
--- /dev/null
+++ b/src/tests/kernel/boot_floppy/on_exit_thread.c
@@ -0,0 +1,43 @@
+#include <OS.h>
+#include <stdio.h>
+
+
+static void
+first(void *data)
+{
+	printf("first on_exit_thread(): %ld\n", (int32)data);
+}
+
+
+static void
+second(void *data)
+{
+	printf("second on_exit_thread(): %ld\n", (int32)data);
+}
+
+
+static int32
+thread(void *data)
+{
+	puts("Nurse Stimpy for the rescue!");
+	
+	on_exit_thread(first, (void *)11);
+	on_exit_thread(second, (void *)22);
+
+	return 0;
+}
+
+
+int
+main(int argc, char **argv)
+{
+	status_t status;
+	thread_id id;
+
+	on_exit_thread(first, (void *)666);
+	id = spawn_thread(thread, "mythread", B_NORMAL_PRIORITY, (void *)42);
+	resume_thread(id);
+
+	wait_for_thread(id, &status);
+	return 0;
+}
diff --git a/src/tests/kernel/boot_floppy/pipe_test.c b/src/tests/kernel/boot_floppy/pipe_test.c
new file mode 100644
index 0000000000..5947e59662
--- /dev/null
+++ b/src/tests/kernel/boot_floppy/pipe_test.c
@@ -0,0 +1,97 @@
+/* tests basic pipes functionality */
+
+/* 
+** Copyright 2003, Axel Dörfler, axeld@pinc-software.de. All rights reserved.
+** Distributed under the terms of the OpenBeOS License.
+*/
+
+
+#include <OS.h>
+
+#include <unistd.h>
+#include <stdio.h>
+#include <string.h>
+
+
+static int32
+reader_func(void *data)
+{
+	char buffer[1024];
+	int input = (int)data;
+	int bytes;
+
+	while ((bytes = read(input, buffer, sizeof(buffer) - 1)) > 0) {
+		buffer[bytes] = '\0';
+			// null-terminate, just in case
+		printf("reader: (%d) %s\n", bytes, buffer);
+
+		if (buffer[0] == '2') {
+			puts("reader: wait a second and let the writer lead (the pipe has to be buffered)");
+			snooze(1000000);
+		}
+		if (strstr(buffer, "QUIT"))
+			break;
+	}
+	puts("reader quits");
+
+	return 0;
+}
+
+
+static int32
+writer_func(void *data)
+{
+	int output = (int)data;
+	int i;
+
+	const char *strings[] = {
+		"1. If you read this ",
+		"2. the pipe implementation ",
+		"3. seems to work ",
+		"4. at least a bit ",
+		"5. QUIT",
+		NULL};
+
+	for (i = 0; strings[i] != NULL; i++) {
+		snooze(100000);
+			// make sure the reader is waiting for us...
+			// (needed by the current pipefs implementation :)
+
+		printf("writer: (%ld)\n", write(output, strings[i], strlen(strings[i])));
+	}
+	puts("writer quits");
+
+	return 0;
+}
+
+
+int
+main(int argc, char **argv)
+{
+	thread_id reader, writer;
+	int stream[2];
+	status_t returnCode;
+
+	if (pipe(stream) < 0) {
+		fprintf(stderr, "pipe creation failed!\n");
+		return -1;
+	}
+
+	reader = spawn_thread(reader_func, "Reader" , B_NORMAL_PRIORITY, (void *)stream[0]);
+	resume_thread(reader);
+
+	writer = spawn_thread(writer_func, "Writer" , B_NORMAL_PRIORITY, (void *)stream[1]);
+	resume_thread(writer);
+
+	puts("reader & writer started.");
+
+	// wait until they quit
+	wait_for_thread(reader, &returnCode);
+	wait_for_thread(writer, &returnCode);
+
+	close(stream[0]);
+	close(stream[1]);
+
+	return 0;
+}
+
diff --git a/src/tests/kernel/boot_floppy/ps/Jamfile b/src/tests/kernel/boot_floppy/ps/Jamfile
new file mode 100644
index 0000000000..263838b2af
--- /dev/null
+++ b/src/tests/kernel/boot_floppy/ps/Jamfile
@@ -0,0 +1,3 @@
+SubDir OBOS_TOP src kernel apps ps ;
+
+KernelObjects <$(SOURCE_GRIST)>main.c  ;
diff --git a/src/tests/kernel/boot_floppy/ps/main.c b/src/tests/kernel/boot_floppy/ps/main.c
new file mode 100644
index 0000000000..393bd83c21
--- /dev/null
+++ b/src/tests/kernel/boot_floppy/ps/main.c
@@ -0,0 +1,72 @@
+/*
+ * PS command
+ * Rewritten for OpenBeOS by Angelo Mottola, Aug 2002.
+ */
+
+#include <OS.h>
+#include <Errors.h>
+#include <syscalls.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+
+const char *state(thread_state state);
+
+
+const char *state(thread_state state)
+{
+	switch (state) {
+		case B_THREAD_RUNNING:
+			return "run";
+		case B_THREAD_READY:
+			return "rdy";
+		case B_THREAD_SUSPENDED:
+			return "sus";
+		case B_THREAD_WAITING:
+			return "sem";
+		case B_THREAD_ASLEEP:
+			return "zzz";
+		case B_THREAD_RECEIVING:
+			return "msg";
+		default:
+			return "???";
+	}
+}
+
+
+int main(int argc, char **argv)
+{
+	int32 thread_num;
+	int32 team_num = 0;
+	thread_info thread;
+	team_info team;
+	sem_info sem;
+	char sem_name[B_OS_NAME_LENGTH * 2];
+	char buffer[B_OS_NAME_LENGTH];
+	
+	printf("\n thread           name      state prio   user  kernel semaphore\n");
+	printf("-----------------------------------------------------------------------\n");
+	
+	while (get_next_team_info(&team_num, &team) == B_OK) {
+		printf("%s (team %ld) (uid %d) (gid %d)\n",
+			team.args, team.team, team.uid, team.gid);
+		thread_num = 0;
+		while (get_next_thread_info(team.team, &thread_num, &thread) == B_OK) {
+			sem_name[0] = '\0';
+			if (thread.state == B_THREAD_WAITING) {
+				if (get_sem_info(thread.sem, &sem) == B_OK) {
+					strcpy(sem_name, sem.name);
+					sprintf(buffer, "(%ld)", sem.sem);
+					strcat(sem_name, buffer);
+				}
+			}
+			printf(" %6ld %20s  %s %3ld %7d %7d %s\n",
+				thread.thread, thread.name, state(thread.state), thread.priority,
+				(int)thread.user_time, (int)thread.kernel_time, sem_name);
+		}
+	}
+	printf("\n");
+	
+	return 0;
+}
diff --git a/src/tests/kernel/boot_floppy/select_test.c b/src/tests/kernel/boot_floppy/select_test.c
new file mode 100644
index 0000000000..91588a5e03
--- /dev/null
+++ b/src/tests/kernel/boot_floppy/select_test.c
@@ -0,0 +1,48 @@
+/* tests basic select() and poll() functionality */
+
+/* 
+** Copyright 2002, Axel Dörfler, axeld@pinc-software.de. All rights reserved.
+** Distributed under the terms of the OpenBeOS License.
+*/
+
+
+#include <sys/select.h>
+#include <poll.h>
+
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+#include <fcntl.h>
+
+#define FILE_NAME "/boot"
+
+int
+main(int argc, char **argv)
+{
+	fd_set readSet;
+	struct pollfd pollfd;
+	int count;
+	int file = open(FILE_NAME, O_RDONLY);
+	if (file < 0) {
+		fprintf(stderr, "Could not open \"%s\": %s\n", FILE_NAME, strerror(file));
+		return -1;
+	}
+
+	FD_ZERO(&readSet);
+	FD_SET(file, &readSet);
+
+	puts("selecting...");
+	count = select(file + 1, &readSet, NULL, NULL, NULL);
+	printf("\tselect returned: %d (read set = %ld)\n", count, FD_ISSET(file, &readSet));
+
+	pollfd.fd = file;
+	pollfd.events = POLLOUT | POLLERR;
+
+	puts("polling...");
+	count = poll(&pollfd, 1, -1);
+	printf("\tpoll returned: %d (revents = 0x%x)\n", count, pollfd.revents);
+
+	close(file);
+	return 0;
+}
+
diff --git a/src/tests/kernel/boot_floppy/shell/Jamfile b/src/tests/kernel/boot_floppy/shell/Jamfile
new file mode 100644
index 0000000000..d7f4ec4aeb
--- /dev/null
+++ b/src/tests/kernel/boot_floppy/shell/Jamfile
@@ -0,0 +1,12 @@
+SubDir OBOS_TOP src kernel apps shell ;
+
+KernelObjects <$(SOURCE_GRIST)>main.c
+	<$(SOURCE_GRIST)>args.c
+	<$(SOURCE_GRIST)>commands.c
+	<$(SOURCE_GRIST)>file_utils.c
+	<$(SOURCE_GRIST)>parse.c
+	<$(SOURCE_GRIST)>script.c
+	<$(SOURCE_GRIST)>shell_vars.c
+	<$(SOURCE_GRIST)>statements.c
+	<$(SOURCE_GRIST)>shell_history.c
+	 : -fpic ;
diff --git a/src/tests/kernel/boot_floppy/shell/args.c b/src/tests/kernel/boot_floppy/shell/args.c
new file mode 100644
index 0000000000..31fc81181c
--- /dev/null
+++ b/src/tests/kernel/boot_floppy/shell/args.c
@@ -0,0 +1,80 @@
+//#include <types.h>
+#include <string.h>
+#include <ctype.h>
+#include <syscalls.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "args.h"
+#include "shell_defs.h"
+#include "shell_vars.h"
+
+bool af_exit_after_script;
+char *af_script_file_name;
+char *gCommandToExecute = NULL;
+
+static const char *kUsage =
+"Usage: shell [ -s ] [ -c <command> ] [ <script> ... ]\n";
+
+static
+void
+print_usage(bool error)
+{
+	fprintf((error ? stderr : stdout), kUsage);
+}
+
+
+void
+init_arguments(int argc,char **argv)
+{
+	int cnt = 1;
+	int shell_argc = 0;
+	char name[255];
+
+	af_exit_after_script = true;
+	af_script_file_name  = NULL;
+
+	while((cnt < argc) && (argv[cnt][0] == '-')){
+		const char *option = argv[cnt];
+		switch(option[1]){
+			case 's':	// setup script
+				if (option[2] == 0)
+					af_exit_after_script = false;
+				break;
+			case 'c':	// execute command
+				cnt++;
+				if (cnt >= argc) {
+					print_usage(true);
+					exit(1);
+				}
+				gCommandToExecute = argv[cnt];
+				// ignore further args
+				return;
+			case '-':
+				// ignore standard bash option
+				if (!strcmp(option, "--login"))
+					break;
+			default:
+				print_usage(true);
+				exit(1);
+		}
+		cnt++;
+	}
+
+	if(cnt < argc){
+
+		af_script_file_name = argv[cnt];
+		cnt++;
+
+		while(cnt < argc){
+
+			sprintf(name,NAME_PAR_PRFX,cnt-1);
+			shell_var_set_text(name,argv[cnt]);
+			shell_argc++;
+			cnt++;
+		}
+
+		shell_var_set_number(NAME_VAR_ARGC,shell_argc);
+
+	}
+}
diff --git a/src/tests/kernel/boot_floppy/shell/args.h b/src/tests/kernel/boot_floppy/shell/args.h
new file mode 100644
index 0000000000..23f811dc73
--- /dev/null
+++ b/src/tests/kernel/boot_floppy/shell/args.h
@@ -0,0 +1,10 @@
+#ifndef _args_h_
+#define _args_h_
+
+extern bool af_exit_after_script;
+extern char *af_script_file_name;
+extern char *gCommandToExecute;
+
+void init_arguments(int argc,char **argv);
+
+#endif
diff --git a/src/tests/kernel/boot_floppy/shell/commands.c b/src/tests/kernel/boot_floppy/shell/commands.c
new file mode 100644
index 0000000000..ee5abc20ac
--- /dev/null
+++ b/src/tests/kernel/boot_floppy/shell/commands.c
@@ -0,0 +1,238 @@
+/*
+** Copyright 2001, Travis Geiselbrecht. All rights reserved.
+** Distributed under the terms of the NewOS License.
+*/
+
+#include <syscalls.h>
+#include <image.h>
+
+#include <unistd.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+#include <errno.h>
+
+#include "commands.h"
+#include "file_utils.h"
+#include "shell_defs.h"
+
+struct command cmds[] = {
+	{"exec", &cmd_exec},
+	{"stat", &cmd_stat},
+	{"mkdir", &cmd_mkdir},
+	{"cat", &cmd_cat},
+	{"cd", &cmd_cd},
+	{"pwd", &cmd_pwd},
+	{"kill", &cmd_kill},
+	{"help", &cmd_help},
+	{NULL, NULL}
+};
+
+
+int
+cmd_exec(int argc, char *argv[])
+{
+	return cmd_create_proc(argc - 1,argv+1);
+}
+
+
+int
+cmd_create_proc(int argc, char *argv[])
+{
+	bool must_wait=true;
+	team_id pid;
+
+	int  arg_len;
+	char *tmp;
+	char filename[SCAN_SIZE+1];
+
+	if (argc < 1) {
+		printf("not enough args to exec\n");
+		return 0;
+	}
+
+	tmp = argv[argc - 1];
+
+	if (!find_file_in_path(argv[0], filename, SCAN_SIZE)) {
+		printf("can't find '%s' \n",argv[0]);
+		return 0;
+	}
+
+
+	// a hack to support the unix '&'
+	if(argc >= 1) {
+		arg_len = strlen(tmp);
+		if(arg_len > 0){
+			tmp += arg_len -1;
+			if(*tmp == '&'){
+				if(arg_len == 1){
+					argc --;
+				} else {
+					*tmp = 0;
+				}
+				must_wait = false;
+			}
+		}
+	}
+
+	pid = load_image(argc, (const char **)argv, (const char **)environ);
+	if (pid >= 0) {
+		if (must_wait)
+			wait_for_thread(pid, NULL);
+	} else {
+		printf("Error: cannot execute '%s'\n", filename);
+		return 0; // should be -1, but the shell would exit
+	}
+
+	return 0;
+}
+
+
+int
+cmd_mkdir(int argc, char *argv[])
+{
+	int rc;
+
+	if (argc < 2) {
+		printf("not enough arguments to mkdir\n");
+		return 0;
+	}
+
+	rc = _kern_create_dir(-1, argv[1], 0755);
+	if (rc < 0) {
+		printf("sys_mkdir() returned error: %s\n", strerror(rc));
+	} else {
+		printf("%s successfully created.\n", argv[1]);
+	}
+
+	return 0;
+}
+
+
+int
+cmd_cat(int argc, char *argv[])
+{
+	int rc;
+	int fd;
+	char buf[257];
+
+	if (argc < 2) {
+		printf("not enough arguments to cat\n");
+		return 0;
+	}
+
+	fd = open(argv[1], 0);
+	if (fd < 0) {
+		printf("cat: sys_open() returned error: %s!\n", strerror(fd));
+		goto done_cat;
+	}
+
+	for(;;) {
+		rc = read_pos(fd, -1, buf, sizeof(buf) - 1);
+		if (rc <= 0)
+			break;
+
+		buf[rc] = '\0';
+		printf("%s", buf);
+	}
+	close(fd);
+
+done_cat:
+	return 0;
+}
+
+
+int
+cmd_cd(int argc, char *argv[])
+{
+	int rc;
+
+	if (argc < 2) {
+		printf("not enough arguments to cd\n");
+		return 0;
+	}
+
+	rc = chdir(argv[1]);
+	if (rc < 0)
+		printf("cd: sys_setcwd() returned error: %s!\n", strerror(errno));
+
+	return 0;
+}
+
+
+int
+cmd_pwd(int argc, char *argv[])
+{
+	char buffer[B_PATH_NAME_LENGTH];
+
+	if (getcwd(buffer, sizeof(buffer)) == NULL) {
+		printf("cd: sys_getcwd() returned error: %s!\n", strerror(errno));
+		return 0;
+	}
+
+	printf("%s\n", buffer);
+
+	return 0;
+}
+
+
+int
+cmd_stat(int argc, char *argv[])
+{
+	int rc;
+	struct stat st;
+
+	if (argc < 2) {
+		printf("not enough arguments to stat\n");
+		return 0;
+	}
+
+	rc = stat(argv[1], &st);
+	if (rc >= 0) {
+		printf("stat of file '%s': \n", argv[1]);
+		printf("vnid 0x%x\n", (unsigned int)st.st_ino);
+		printf("type %d\n", st.st_type);
+		printf("size %d\n", (int)st.st_size);
+	} else
+		printf("stat failed for file '%s'\n", argv[1]);
+
+	return 0;
+}
+
+
+int
+cmd_kill(int argc, char *argv[])
+{
+	int rc;
+	
+	if (argc < 3) {
+		printf("not enough arguments to kill\n");
+		return 0;
+	}
+	rc = send_signal(atoi(argv[2]), atoi(argv[1]));
+	if (rc)
+		printf("kill failed\n");
+	return 0;
+}
+
+
+int
+cmd_help(int argc, char *argv[])
+{
+	printf("command list:\n\n");
+	printf("exit : quits this copy of the shell\n");
+	printf("exec <file> : load this file as a binary and run it\n");
+	printf("mkdir <path> : makes a directory at <path>\n");
+	printf("cd <path> : sets the current working directory at <path>\n");
+	printf("ls <path> : directory list of <path>. If no path given it lists the current dir\n");
+	printf("stat <file> : gives detailed file statistics of <file>\n");
+	printf("help : this command\n");
+	printf("cat <file> : dumps the file to stdout\n");
+	printf("mount <path> <device> <fsname> : tries to mount <device> at <path>\n");
+	printf("unmount <path> : tries to unmount at <path>\n");
+	printf("kill <sig> <tid> : sends signal <sig> to thread <tid>\n");
+
+	return 0;
+}
+
diff --git a/src/tests/kernel/boot_floppy/shell/commands.h b/src/tests/kernel/boot_floppy/shell/commands.h
new file mode 100644
index 0000000000..ebf9837530
--- /dev/null
+++ b/src/tests/kernel/boot_floppy/shell/commands.h
@@ -0,0 +1,22 @@
+#ifndef _COMMANDS_H
+#define _COMMANDS_H
+
+int cmd_exit(int argc, char *argv[]);
+int cmd_exec(int argc, char *argv[]);
+int cmd_stat(int argc, char *argv[]);
+int cmd_mkdir(int argc, char *argv[]);
+int cmd_cat(int argc, char *argv[]);
+int cmd_cd(int argc, char *argv[]);
+int cmd_pwd(int argc, char *argv[]);
+int cmd_kill(int argc, char *argv[]);
+int cmd_help(int argc, char *argv[]);
+int cmd_create_proc(int argc,char *argv[]);
+typedef int(cmd_handler_proc)(int argc,char *argv[]);
+
+struct command {
+	char *cmd_text;
+	cmd_handler_proc *cmd_handler;
+};
+
+extern struct command cmds[];
+#endif
diff --git a/src/tests/kernel/boot_floppy/shell/file_utils.c b/src/tests/kernel/boot_floppy/shell/file_utils.c
new file mode 100644
index 0000000000..42e7350fd5
--- /dev/null
+++ b/src/tests/kernel/boot_floppy/shell/file_utils.c
@@ -0,0 +1,129 @@
+#include <image.h>
+
+#include <string.h>
+#include <ctype.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <Errors.h>
+#include <fcntl.h>
+#include <unistd.h>
+
+#include "file_utils.h"
+#include "statements.h"
+#include "shell_defs.h"
+
+
+bool
+combine_path(const char *path1,const char *path2,char *out,unsigned int max_len)
+{
+	unsigned int cur_len = 0;
+
+	cur_len = strlen(path1);
+	if(cur_len > max_len) return false;
+	strcpy(out,path1);
+
+	if(*path1 != 0){
+		if(out[cur_len-1] != '/'){
+			if(cur_len >= max_len) return false;
+			out[cur_len] = '/';
+			out[cur_len+1] = 0;
+			cur_len++;
+		}
+	}
+	if (strlen(path2)+cur_len > max_len)
+		return false;
+
+	strcat(out,path2);
+	return true;
+}
+
+
+bool
+exists_file(const char *file_name)
+{
+	int handle = open(file_name, 0);
+	bool exists;
+	exists = (handle >= 0);
+	if (exists)
+		close(handle);
+
+	return exists;
+}
+
+
+bool
+find_file_in_path(const char *file_name, char *found_name, unsigned int max_size)
+{
+	char path[SCAN_SIZE + 1];
+	int cnt = 0;
+
+	if (strchr(file_name, '/') != NULL) {
+		strncpy(found_name,file_name,max_size);
+		found_name[max_size] = 0;
+		if (exists_file(found_name))
+			return true;
+		found_name[0] = 0;
+		return false;
+	}
+	while (get_path(cnt, path, SCAN_SIZE)) {
+		if (combine_path(path, file_name, found_name, max_size)) {
+			if (exists_file(found_name))
+				return true;
+		}
+		cnt++;
+	}
+	found_name[0] = 0;
+	return false;
+}
+
+
+int
+exec_file(int argc, char *argv[], status_t *retcode)
+{
+	char filename[255];
+	int pid;
+
+	if (!find_file_in_path(argv[0], filename, SCAN_SIZE))
+		return SHE_FILE_NOT_FOUND;
+
+	pid = load_image(argc, (const char **)argv, (const char **)environ);
+    if (pid < 0)
+    	return SHE_CANT_EXECUTE;
+
+	wait_for_thread(pid, retcode);
+
+	return SHE_NO_ERROR;
+}
+
+
+int
+read_file_in_buffer(const char *filename,char **buffer)
+{
+	struct stat stat;
+	int file_no;
+	int err;
+	int size;
+
+	*buffer = NULL;
+
+	file_no = open(filename, O_RDONLY);
+	if (file_no < 0)
+		return file_no;
+
+	err = fstat(file_no,&stat);
+	if (err < 0)
+		return err;
+
+	*buffer = malloc(stat.st_size + 1);
+	if (*buffer == NULL)
+		return ENOMEM;
+
+	size = read(file_no, *buffer, stat.st_size);
+
+	close(file_no);
+
+	if (size < 0)
+		free(*buffer);
+
+	return size;
+}
diff --git a/src/tests/kernel/boot_floppy/shell/file_utils.h b/src/tests/kernel/boot_floppy/shell/file_utils.h
new file mode 100644
index 0000000000..0a85d7c2c9
--- /dev/null
+++ b/src/tests/kernel/boot_floppy/shell/file_utils.h
@@ -0,0 +1,10 @@
+#ifndef _file_utils_h_
+#define _file_utils_h_
+
+bool combine_path(const char *path1,const char *path2,char *out,unsigned int max_len);
+bool exists_file(const char *file_name);
+bool find_file_in_path(const char *file_name,char *found_name,unsigned int max_size);
+int exec_file(int argc,char *argv[], status_t *retcode);
+int read_file_in_buffer(const char *filename,char **buffer);
+
+#endif
diff --git a/src/tests/kernel/boot_floppy/shell/main.c b/src/tests/kernel/boot_floppy/shell/main.c
new file mode 100644
index 0000000000..4ec0d1e5b8
--- /dev/null
+++ b/src/tests/kernel/boot_floppy/shell/main.c
@@ -0,0 +1,117 @@
+/*
+** Copyright 2001, Travis Geiselbrecht. All rights reserved.
+** Distributed under the terms of the NewOS License.
+*/
+
+#include <string.h>
+#include <ctype.h>
+#include <syscalls.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+#include "commands.h"
+#include "parse.h"
+#include "statements.h"
+#include "shell_defs.h"
+#include "shell_vars.h"
+#include "args.h"
+#include "shell_history.h"
+
+
+#define ECHO 0
+	// echoes input when unequal 0
+
+
+static int
+readline(char *buf, int len)
+{	
+	int  i = 0;
+	char ch;
+
+	while (true) {
+		ch = getchar();
+		
+		switch (ch) {
+		case 27:
+			// ESC -- used to display command history:
+			//   erase all characters on the current line,
+			//   then display the previously saved command
+#if ECHO
+			while (i--) {
+				printf("\b");
+			}
+#endif
+			
+			strcpy (buf, fetch_history_command());
+			i = printf("%s", buf);
+			break;
+		
+		case '\b':
+			// backspace:
+			//   erase the last character written
+			if (i > 0) {
+#if ECHO
+				printf("\b");
+#endif
+				--i;
+			}
+			break;
+
+		case '\n':
+			buf[i] = 0;
+			store_history_command(buf);
+#if ECHO
+			printf("\n");
+#endif
+			return i;
+
+		default:
+			buf[i] = ch;
+#if ECHO
+			printf("%c", ch);
+#endif
+			i++;
+		}
+	}
+}
+
+
+int
+main(int argc, char *argv[])
+{
+	char buf[1024];
+
+	init_vars();
+	init_statements();
+	init_arguments(argc, argv);
+
+	if (af_script_file_name) {
+		run_script(af_script_file_name);
+		if (af_exit_after_script)
+			exit(0);
+	}
+
+	if (gCommandToExecute) {
+		if (strlen(gCommandToExecute) > 0)
+			parse_string(gCommandToExecute);
+		exit(0);
+	}
+
+	printf("Welcome to the Haiku shell\n");
+
+	for (;;) {
+		int chars_read;
+
+		printf("$ ");
+
+		chars_read = readline(buf, sizeof(buf));
+ 		if (chars_read > 0)
+			parse_string(buf);
+	}
+
+	printf("shell exiting\n");
+	return 0;
+}
+
+
diff --git a/src/tests/kernel/boot_floppy/shell/parse.c b/src/tests/kernel/boot_floppy/shell/parse.c
new file mode 100644
index 0000000000..3be9977862
--- /dev/null
+++ b/src/tests/kernel/boot_floppy/shell/parse.c
@@ -0,0 +1,583 @@
+#include <string.h>
+#include <ctype.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+#include "parse.h"
+#include "commands.h"
+#include "shell_defs.h"
+#include "shell_vars.h"
+#include "script.h"
+
+
+
+struct token_info {
+	char *token;
+	int  code;
+};
+
+struct token_info tokens[] = {
+{"echo",SVO_ECHO},
+{"exec",SVO_EXEC},
+{"exit",SVO_EXIT},
+{"if",SVO_IF},
+{"goto",SVO_GOTO},
+{"number",SVO_NUMBER_CAST},
+{"string",SVO_STRING_CAST},
+{"+",SVO_ADD},
+{"-",SVO_SUB},
+{"*",SVO_MUL},
+{"/",SVO_DIV},
+{"=",SVO_LOAD},
+{"==",SVO_EQUAL},
+{"!=",SVO_NOT_EQUAL},
+{">",SVO_BIGGER},
+{">=",SVO_BIGGER_E},
+{"<",SVO_LESS},
+{"<=",SVO_LESS_E},
+{"$",SVO_DOLLAR},
+{",",SVO_COMMA},
+{"(",SVO_PARENL},
+{")",SVO_PARENR},
+{":",SVO_DOTDOT},
+{NULL,SVO_NONE}
+};
+
+
+static int token_to_id(const char *token)
+{
+	int cnt = 0;
+
+	while((tokens[cnt].token != NULL) && (strcmp(tokens[cnt].token,token) != 0))  cnt++;
+
+	return tokens[cnt].code;
+}
+
+char *id_to_token(int id)
+{
+	int cnt = 0;
+
+	switch (id) {
+		case SVO_IDENT		:return "ident";
+		case SVO_SQ_STRING	:
+		case SVO_DQ_STRING	:return "string";
+		case SVO_NUMBER		:return "number";
+		case SVO_END		:return "end";
+	}
+
+	while((tokens[cnt].token != NULL) && (tokens[cnt].code != id))  cnt++;
+
+	if(tokens[cnt].token != NULL){
+
+		return tokens[cnt].token;
+
+	} else {
+
+		return "unkown";
+
+	}
+}
+
+static bool  scan_string(scan_info *info,int max_len)
+{
+	const char **in=&(info->scanner);
+	char ch=**in;
+	char *scan=info->token;
+	int  len_cnt = max_len;
+	bool err = false;
+
+	(*in)++;
+
+	while((**in != 0) && (**in != ch)){
+
+		if(len_cnt > 0){
+
+			*scan = **in;
+			scan++;
+			len_cnt--;
+
+		}
+
+		(*in)++;
+
+	}
+
+	if(**in != 0) {
+		(*in)++;
+	} else {
+		info->scan_error = SHE_MISSING_QOUTE;
+		err = true;
+	}
+
+	*scan = 0;
+	return err;
+}
+
+
+int parse_line(const char *buf, char *argv[], int max_args, char *redirect_in, char *redirect_out)
+{
+	const char *scan=buf;
+	const char *type_char;
+	const char *start;
+	char out[SCAN_SIZE+1];
+	char tmp[SCAN_SIZE+1];
+	char *arg_tmp;
+	int arg_cnt = 0;
+	int len = 0;
+	bool replace;
+	bool param;
+	redirect_in[0] = 0;
+	redirect_out[0] = 0;
+
+	while (true) {
+		while ((*scan != 0) && (isspace(*scan))) scan++;
+
+		if (*scan == 0) break;
+
+		replace = true;
+		type_char = scan;
+		start = scan;
+		param = true;
+
+		switch(*type_char){
+		case '\'':
+			replace  = false;
+
+      case  '"':
+			scan++;
+			start++;
+			while((*scan != 0) && (*scan != *start)) scan++;
+			break;
+
+		case '>':
+		case '<':
+         start++;
+			while((*start != 0) && (isspace(*start))) start++;
+			scan = start;
+
+		default:
+
+			while((*scan != 0) && (!isspace(*scan))) scan++;
+
+		}
+
+		len = scan - start;
+		if(*scan != 0) scan++;
+        
+		if(replace){
+        
+				memcpy(tmp,start,len);
+				tmp[len]=0;
+				parse_vars_in_string(tmp,out,SCAN_SIZE);
+
+		} else {
+
+				memcpy(out,start,len);
+				out[len]=0;
+                
+		}
+
+		switch(*type_char){
+
+		case '>':
+			strcpy(redirect_out,out);
+			break;
+
+		case '<':
+			strcpy(redirect_in,out);
+			break;
+
+		default:
+			if(arg_cnt < max_args){
+
+				arg_tmp = shell_strdup(out);
+				if(arg_tmp != NULL) argv[arg_cnt++] = arg_tmp;
+
+			}
+
+		}
+	}
+
+	return arg_cnt;
+}
+
+
+static void scan_ident(const char **in,char *out,int max_len)
+{
+	char *scan = out;
+	int len_cnt = max_len;
+
+	while ((**in != 0) && (IS_IDENT_CHAR(**in))){
+		if(len_cnt > 0){
+			*scan = **in;
+			scan++;
+			len_cnt--;
+		}
+		(*in)++;
+	}
+	*scan = 0;
+}
+
+
+static void scan_number(const char **in,char *out,int max_len)
+{
+	char *scan = out;
+	int len_cnt = max_len;
+
+	while ( (**in != 0) && (isdigit(**in)) ){
+
+		if(len_cnt > 0){
+
+			*scan = **in;
+			scan++;
+			len_cnt--;
+
+		}
+
+		(*in)++;
+
+	}
+	*scan = 0;
+}
+
+
+static void scan_comp(const char **in,char *out,int max_len)
+{
+	int num_cnt = max_len;
+	char *out_scan = out;
+
+	*out_scan  = **in;
+	out_scan++;
+	(*in)++;
+	num_cnt--;
+
+	if(num_cnt > 0) {
+
+		if(**in == '='){
+
+			*out_scan = **in;
+			out_scan++;
+			(*in)++;
+			num_cnt--;
+
+		}
+	}
+	*out_scan = 0;
+}
+
+
+bool expect(scan_info *info,int check)
+{
+	if(info->sym_code == check){
+
+		scan(info);
+		return false;
+
+	} else {
+
+		return true;
+
+	}
+}
+
+
+bool scan_info_next_line(scan_info *info)
+{
+	if(info->current == NULL) return false;
+
+	info->current = info->current->next;
+
+	if(info->current == NULL) return false;
+
+	info->line_no++;
+
+	return set_scan_info_line(info);
+}
+
+
+bool scan_info_home(scan_info *info)
+{
+	info->current = info->data.list;
+	info->line_no = 1;
+	return set_scan_info_line(info);
+}
+
+
+int init_scan_info_by_file(const char *file_name,scan_info *info)
+{
+	int err = SHE_NO_ERROR;
+
+	err = read_text_file(file_name,&(info->data));
+
+	if(err != SHE_NO_ERROR) return err;
+
+	info->scanner    = NULL;
+	info->scan_error = SHE_NO_ERROR;
+
+	if(scan_info_home(info)) err  = SHE_SCAN_ERROR;
+
+	return err;
+
+}
+
+
+bool set_scan_info_line(scan_info *info)
+{
+
+	if(info->current == NULL) return true;
+
+	strcpy(info->input_line,info->current->text);
+	info->scanner = (info->input_line);
+	return scan(info);
+
+}
+
+// fetch next token
+//      **in  scan string
+//      *out  token
+//      return token type (STY_<> vars)
+
+
+void init_scan_info(const char*in,scan_info *info){
+
+	strncpy(info->input_line,in,SCAN_SIZE);
+
+	info->input_line[SCAN_SIZE] = 0;
+	info->scanner=(const char*)info->input_line;
+	info->scan_error = SHE_NO_ERROR;
+	info->current = NULL;
+	info->line_no = 1;
+
+	scan(info);
+
+}
+
+
+bool scan(scan_info *info)
+{
+	bool err = false;
+	int sym_code = SVO_NONE;
+	const char **in = &(info->scanner);
+	char tmp[SCAN_SIZE+1];
+
+	while((**in != 0) && (isspace(**in))) (*in)++;
+
+	if(isalpha(**in)){
+
+		scan_ident(in,info->token,SCAN_SIZE);
+
+		sym_code = token_to_id(info->token);
+		if(sym_code == SVO_NONE) sym_code = SVO_IDENT;
+
+	} else if(isdigit(**in)){
+
+		scan_number(in,info->token,SCAN_SIZE);
+		sym_code = SVO_NUMBER;
+	} else{
+		switch(**in){
+			case '#':
+				sym_code = SVO_END;
+				break;
+			case '>':
+			case '<':
+			case '=':
+			case '!':
+
+				scan_comp(in,info->token,SCAN_SIZE);
+				break;
+
+			case '"':
+
+				err = scan_string(info,SCAN_SIZE);
+
+				if(err != SHE_NO_ERROR){
+					parse_vars_in_string(info->token,tmp,SCAN_SIZE);
+					strncpy(info->token,tmp,SCAN_SIZE);
+					info->token[SCAN_SIZE] = 0;
+				}
+
+				sym_code = SVO_DQ_STRING;
+				break;
+			case '\'':
+
+				sym_code = SVO_SQ_STRING;
+				err =scan_string(info,SCAN_SIZE);
+				break;
+			case 0:
+
+				*(info->token) = 0;
+				sym_code = SVO_END;
+				break;
+			default:
+				info->token[0] = **in;
+				info->token[1] = 0;
+				(*in)++;
+				break;
+
+		}
+		if(sym_code == SVO_NONE) sym_code = token_to_id(info->token);
+
+	}
+
+	info->sym_code = sym_code;
+
+	return err;
+}
+
+void parse_vars_in_string(const char *string,char *out,int max_len)
+{
+	const char *scan= string;
+	char buf[SCAN_SIZE + 1];
+	char *dest;
+	char *out_scan = out;
+	shell_value *value;
+	int out_len = 0;
+	int len_cnt;
+	int out_max_len= max_len;
+	int can_move;
+	char *text;
+
+	while((*scan != 0) && (*scan != '\'') && (out_max_len > 0)){
+		if(*scan == '$'){
+			scan++;
+			dest = buf;
+			len_cnt = SCAN_SIZE;
+
+			while ((*scan != 0) && (IS_IDENT_CHAR(*scan)) &&(len_cnt > 0)){
+
+					*dest = *scan;
+					dest++;
+					scan++;
+					len_cnt--;
+
+			}
+
+			*dest = 0;
+			value = get_value_by_name(buf);
+
+			if(value != NULL){
+
+				text = shell_value_to_char(value);
+				can_move = strlen(text);
+
+				if(can_move > out_max_len) can_move = out_max_len;
+
+				memcpy(out_scan,text,can_move);
+				out_max_len -= can_move;
+				out_scan += can_move;
+
+				free(text);
+
+			}
+
+		} else{
+
+			*out_scan = *scan;
+			out_len++;
+			out_scan++;
+			scan ++;
+			out_max_len--;
+
+		}
+	}
+	*out_scan= 0;
+}
+
+
+static int
+launch(int (*cmd)(int, char **), int argc, char **argv, char *r_in, char *r_out)
+{
+	int saved_in;
+	int saved_out;
+	int new_in;
+	int new_out;
+	int retval= 0;
+	int err;
+
+	if (strcmp(r_in, "")!= 0) {
+		new_in = open(r_in, 0);
+		if (new_in < 0)
+			new_in = creat(r_in, 0644);
+	} else {
+		new_in = dup(0);
+	}
+	if (new_in < 0) {
+		err = new_in;
+		goto err_1;
+	}
+
+	if (strcmp(r_out, "")!= 0) {
+		new_out = open(r_out, 0);
+		if (new_out < 0)
+			new_out = creat(r_out, 0644);
+	} else {
+		new_out = dup(1);
+	}
+	if (new_out < 0) {
+		err = new_out;
+		goto err_2;
+	}
+
+	saved_in = dup(0);
+	saved_out= dup(1);
+
+	dup2(new_in, 0);
+	dup2(new_out, 1);
+	close(new_in);
+	close(new_out);
+
+	retval = cmd(argc, argv);
+
+	dup2(saved_in, 0);
+	dup2(saved_out, 1);
+	close(saved_in);
+	close(saved_out);
+
+	return 0;
+
+err_2:
+	close(new_in);
+err_1:
+	return err;
+}
+
+
+int shell_parse(const char *buf, int len)
+{
+	int i;
+//	bool found_command = false;
+	int  argc;
+	char *argv[64];
+	char redirect_in[256];
+	char redirect_out[256];
+	cmd_handler_proc *handler = NULL;
+	int cnt;
+	int err;
+
+	// search for the command
+	argc = parse_line(buf, argv, 64, redirect_in, redirect_out);
+
+	if(argc == 0) return 0;
+
+	handler = &cmd_create_proc;
+
+	for(i=0; cmds[i].cmd_handler != NULL; i++) {
+		if(strcmp(cmds[i].cmd_text,argv[0]) == 0){
+			handler = cmds[i].cmd_handler;
+			break;
+		}
+	}
+
+	err = launch(handler, argc, argv, redirect_in, redirect_out);
+
+	for(cnt = 0;cnt <argc;cnt++) free(argv[cnt]);
+
+	return err;
+}
+
+
+
+
+
diff --git a/src/tests/kernel/boot_floppy/shell/parse.h b/src/tests/kernel/boot_floppy/shell/parse.h
new file mode 100644
index 0000000000..9a8c13a9da
--- /dev/null
+++ b/src/tests/kernel/boot_floppy/shell/parse.h
@@ -0,0 +1,22 @@
+#ifndef _parse_h_
+#define _parse_h_
+#include "shell_defs.h"
+#define IS_IDENT_CHAR(c) isalnum(c) || (c == '_')
+
+
+
+
+int  shell_parse(const char *buf, int len);
+bool scan(scan_info *info);
+int init_scan_info_by_file(const char *file_name,scan_info *info);
+void init_scan_info(const char*in,scan_info *info);
+bool scan_info_home(scan_info *info);
+bool scan_info_next_line(scan_info *info);
+
+bool expect(scan_info *info,int check);
+void parse_vars_in_string(const char *string,char *out,int max_len);
+int  parse_line(const char *buf, char *argv[], int max_args, char *redirect_in, char *redirect_out);
+bool set_scan_info_line(scan_info *info);
+char *id_to_token(int id);
+
+#endif
diff --git a/src/tests/kernel/boot_floppy/shell/script.c b/src/tests/kernel/boot_floppy/shell/script.c
new file mode 100644
index 0000000000..f902a58308
--- /dev/null
+++ b/src/tests/kernel/boot_floppy/shell/script.c
@@ -0,0 +1,124 @@
+#include <syscalls.h>
+#include <stdio.h>
+#include <string.h>
+#include <ctype.h>
+#include <Errors.h>
+#include <stdlib.h>
+
+#include "statements.h"
+#include "file_utils.h"
+#include "shell_defs.h"
+#include "script.h"
+#include "parse.h"
+#include "statements.h"
+
+static int add_string_to_list(text_file *data,char *text)
+{
+	text_item *item;
+
+	item = malloc(sizeof(text_item));
+	if(item == NULL) return SHE_NO_MEMORY;
+
+	item->text = text;
+	item->next = NULL;
+
+	if(data->top != NULL) data->top->next = item;
+	if(data->list == NULL) data->list = item;
+
+	data->top = item;
+
+	return SHE_NO_ERROR;
+}
+
+void  free_text_file(text_file *data)
+{
+	text_item *current;
+	text_item *next;
+
+	current = data->list;
+
+	while(current != NULL){
+
+		next = current->next;
+		free(current);
+		current = next;
+
+	}
+
+	free(data->buffer);
+	data->buffer = NULL;
+	data->list   = NULL;
+	data->top    = NULL;
+}
+
+
+int  read_text_file(const char *filename,text_file *data)
+{
+	char *scan;
+	char *old;
+	int err;
+	int size;
+	char realfilename[256];
+
+	if( !find_file_in_path(filename,realfilename,SCAN_SIZE)){
+
+		printf("can't find '%s' \n",filename);
+		return SHE_FILE_NOT_FOUND;
+
+	}
+
+	size = read_file_in_buffer(realfilename,&(data->buffer));
+
+	if(size < 0) return size;
+
+	scan  = data->buffer;
+	data->top = NULL;
+	data->list = NULL;
+
+	while(size >0){
+
+		err = add_string_to_list(data, scan);
+		if(err <0) goto err;
+
+		old = scan;
+
+		while((size > 0) && (*scan != 10)) {
+			scan++;
+			size--;
+		}
+
+		*scan=0;
+		scan++;
+		size--;
+	}
+	return B_NO_ERROR;
+err:
+	printf("error\n");
+	free_text_file(data);
+	return err;
+}
+
+
+int run_script(const char *file_name)
+{
+	scan_info info;
+	int err = init_scan_info_by_file(file_name,&info);
+	if(err != SHE_NO_ERROR) return err;
+
+	while(info.current != NULL){
+
+		err = parse_info(&info);
+		if(err != SHE_NO_ERROR) break;
+
+		if(scan_info_next_line(&info)) {
+			err = SHE_SCAN_ERROR;
+			break;
+		}
+
+	}
+
+//err:
+	free_text_file(&(info.data));
+	return err;
+}
+
diff --git a/src/tests/kernel/boot_floppy/shell/script.h b/src/tests/kernel/boot_floppy/shell/script.h
new file mode 100644
index 0000000000..e4f1b8b20a
--- /dev/null
+++ b/src/tests/kernel/boot_floppy/shell/script.h
@@ -0,0 +1,27 @@
+#ifndef _script_h_
+
+#define _script_h_
+
+#include <ctype.h>
+
+struct _text_item{
+        struct _text_item *next;
+		char *text;
+};
+
+typedef struct _text_item text_item;
+
+
+struct _text_file{
+	char *buffer;
+	text_item *list;
+	text_item *top;
+};
+
+typedef struct _text_file text_file;
+
+
+int  read_text_file(const char *filename,text_file *data);
+void  free_text_file(text_file *data);
+int run_script(const char *file_name);
+#endif
diff --git a/src/tests/kernel/boot_floppy/shell/shell_defs.h b/src/tests/kernel/boot_floppy/shell/shell_defs.h
new file mode 100644
index 0000000000..f40947c450
--- /dev/null
+++ b/src/tests/kernel/boot_floppy/shell/shell_defs.h
@@ -0,0 +1,71 @@
+#ifndef _shell_defs_h_
+#define _shell_defs_h_
+
+#include <SupportDefs.h>
+#include "script.h"
+
+#define NAME_VAR_PATH  "path"
+#define NAME_VAR_ARGC  "argc"
+#define NAME_PAR_PRFX  "p%d"
+
+#define SVO_ADD			0
+#define SVO_SUB    		1
+#define SVO_MUL			2
+#define SVO_DIV			3
+#define SVO_BIGGER		4
+#define SVO_EQUAL			5
+#define SVO_LESS			6
+#define SVO_LESS_E  		7
+#define SVO_BIGGER_E  	8
+#define SVO_NOT_EQUAL 	9
+#define SVO_PARENL		10
+#define SVO_PARENR		11
+#define SVO_COMMA			12
+#define SVO_LOAD			13
+#define SVO_EXEC			14
+#define SVO_ECHO			15
+#define SVO_DOLLAR		16
+#define SVO_IDENT			17
+#define SVO_SQ_STRING   18
+#define SVO_DQ_STRING   19
+#define SVO_NUMBER		20
+#define SVO_CHAR			21
+#define SVO_END			22
+#define SVO_NONE			23
+#define SVO_EXIT			24
+#define SVO_IF				25
+#define SVO_DOTDOT		26
+#define SVO_GOTO			27
+#define SVO_NUMBER_CAST	28
+#define SVO_STRING_CAST	29
+#define SVO_MAX			30
+
+#define SHE_NO_ERROR    		0   		  // no error
+#define SHE_NO_MEMORY			SVO_MAX+2  // not enough memory
+#define SHE_PARSE_ERROR			SVO_MAX+3  // parse error
+#define SHE_FILE_NOT_FOUND		SVO_MAX+4
+#define SHE_CANT_EXECUTE		SVO_MAX+5
+#define SHE_INVALID_TYPE		SVO_MAX+6
+#define SHE_INVALID_NUMBER		SVO_MAX+7
+#define SHE_INVALID_OPERATION	SVO_MAX+8
+#define SHE_SCAN_ERROR			SVO_MAX+9
+#define SHE_MISSING_QOUTE		SVO_MAX+10
+#define SHE_LABEL_NOT_FOUND	SVO_MAX+11
+
+
+#define SCAN_SIZE  255		// size of output strings in parser
+
+struct _scan_info{
+	char input_line[SCAN_SIZE+1];
+	char token[SCAN_SIZE+1];
+	const char *scanner;
+	int sym_code;
+	int scan_error;
+	int line_no;
+	text_item *current;
+	text_file data;
+};
+
+typedef struct _scan_info scan_info;
+
+#endif
diff --git a/src/tests/kernel/boot_floppy/shell/shell_history.c b/src/tests/kernel/boot_floppy/shell/shell_history.c
new file mode 100644
index 0000000000..c3aae76388
--- /dev/null
+++ b/src/tests/kernel/boot_floppy/shell/shell_history.c
@@ -0,0 +1,69 @@
+#include <stdio.h>
+#include <string.h>
+
+#include "shell_history.h"
+
+
+
+static char Table[MAX_HISTORY_DEPTH][120]; // holds MAX_HISTORY_DEPTH slots
+                                           // each slot up to 120 chars long
+
+static int  NumEntries = 0;   // current number of filled entries in Table
+static int  Slot  = 0;        // index of next slot in Table to look at
+
+
+
+
+void store_history_command(char *cmd_string)
+{
+	// store the command string in the next available slot
+
+	char *next = Table[0];
+	int   i;
+	
+	// find the next empty slot (if there is one)
+	//
+	for (i = 0; i < MAX_HISTORY_DEPTH; ++i) {
+	
+		if (Slot == MAX_HISTORY_DEPTH)
+			// wrap around
+			Slot = 0;
+		
+		next = Table[Slot++];
+		if (*next == '\0')
+			// found empty slot
+			break;
+	}
+	
+	// copy in the command string
+	strcpy (next, cmd_string);
+	
+	
+	// update count
+	++NumEntries;
+	if (NumEntries > MAX_HISTORY_DEPTH)
+		NumEntries = MAX_HISTORY_DEPTH;
+}
+
+
+char *fetch_history_command(void)
+{
+	// fetch the previous command string
+	
+	char *prev = "";
+	int   i;
+	
+	for (i = 0; i < NumEntries; ++i) {
+		
+		if (Slot == 0)
+			// wrap around
+			Slot = NumEntries;
+		
+		prev = Table[--Slot];
+		if (*prev)
+			// found non-blank entry
+			break;
+	}
+	
+	return prev;
+}
diff --git a/src/tests/kernel/boot_floppy/shell/shell_history.h b/src/tests/kernel/boot_floppy/shell/shell_history.h
new file mode 100644
index 0000000000..820789a065
--- /dev/null
+++ b/src/tests/kernel/boot_floppy/shell/shell_history.h
@@ -0,0 +1,16 @@
+#ifndef _SHELL_HISTORY_H_
+#define _SHELL_HISTORY_H_
+
+
+// you can store up to this many commands in the history table
+
+#define MAX_HISTORY_DEPTH 20
+
+
+// the only two history operations:
+
+void  store_history_command(char *cmd_string);
+char *fetch_history_command(void);
+
+
+#endif
diff --git a/src/tests/kernel/boot_floppy/shell/shell_vars.c b/src/tests/kernel/boot_floppy/shell/shell_vars.c
new file mode 100644
index 0000000000..07285c4f76
--- /dev/null
+++ b/src/tests/kernel/boot_floppy/shell/shell_vars.c
@@ -0,0 +1,372 @@
+//#include <types.h>
+#include <string.h>
+#include <ctype.h>
+#include <syscalls.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "shell_vars.h"
+#include "statements.h"
+#include "shell_defs.h"
+
+
+struct _shell_var{
+	struct _shell_var *next;
+	char *name;
+	shell_value *value;
+}
+;
+
+typedef struct _shell_var shell_var;
+
+static shell_var *var_list;
+
+char *shell_strdup(const char *some_str)
+{
+	char *result;
+
+	result = malloc(strlen(some_str) + 1);
+
+	if(result != NULL){
+		strcpy(result,some_str);
+	}
+
+	return result;
+}
+
+bool string_to_long_int(const char *str,long int *out)
+{
+	const char *scanner = str;
+	bool do_neg = false;
+
+	*out = 0;
+
+	if(*scanner == '-'){
+		do_neg = true;
+		scanner++;
+	}
+
+	while ((*scanner != 0) && (isdigit(*scanner))){
+
+		(*out) = (*out)*10 + (*scanner)-48;
+		scanner++;
+
+	}
+
+   if(do_neg) *out = -(*out);
+
+	return (*scanner != 0);
+}
+
+void shell_value_free(shell_value *value)
+{
+	if(!value->isnumber) free(value->value.val_text);
+	free(value);
+}
+
+
+char *shell_value_to_char(shell_value *value)
+{
+	if(value->isnumber){
+		char tmp[255];
+		sprintf(tmp,"%ld",value->value.val_number);
+      return shell_strdup(tmp);
+	} else {
+		return shell_strdup(value->value.val_text);
+	}
+}
+
+int shell_value_to_number(shell_value *value,long int *number)
+{
+	if(value->isnumber){
+		*number = value->value.val_number;
+		return SHE_NO_ERROR;
+	} else {
+		return string_to_long_int(value->value.val_text,number);
+	}
+}
+
+int shell_value_get_text(shell_value * value,char **text){
+	if(value->isnumber) return SHE_INVALID_TYPE;
+	*text = value->value.val_text;
+	return SHE_NO_ERROR;
+}
+
+int shell_value_get_number(shell_value *value,long int *number)
+{
+	if(!value->isnumber) return SHE_INVALID_TYPE;
+	*number = value->value.val_number;
+	return SHE_NO_ERROR;
+}
+
+/* XXX - unused and static 
+static void shell_var_free(shell_var *var)
+{
+	shell_value_free(var->value);
+	free(var->name);
+	free(var);
+}
+*/
+
+shell_value *shell_value_init_number(long int value)
+{
+	shell_value *current;
+
+	current = malloc(sizeof(shell_value));
+	if(current == NULL) return NULL;
+
+	current->isnumber = true;
+	current->value.val_number = value;
+
+	return  current;
+}
+
+
+shell_value *shell_value_init_text(const char *value)
+{
+	shell_value *current;
+
+	current = malloc(sizeof(shell_value));
+	if(current == NULL) goto err;
+
+	current->value.val_text = shell_strdup(value);
+	if(current->value.val_text == NULL) goto err1;
+
+	current->isnumber = false;
+
+	return current;
+err1:
+	free(current);
+err:
+	return NULL;
+}
+
+
+int shell_value_set_text(shell_value *value,const char *new_value)
+{
+	char *val = shell_strdup(new_value);
+	if(val == NULL) return SHE_NO_MEMORY;
+
+	if(!value->isnumber) free(value->value.val_text);
+
+	value->value.val_text  = val;
+	value->isnumber = false;
+
+	return SHE_NO_ERROR;
+}
+
+int shell_value_set_number(shell_value *value,long int new_value)
+{
+	if(!value->isnumber) free(value->value.val_text);
+
+	value->value.val_number = new_value;
+	value->isnumber = true;
+
+	return SHE_NO_ERROR;
+}
+
+
+
+shell_value *shell_value_clone(shell_value *var)
+{
+	if(var->isnumber){
+		return shell_value_init_number(var->value.val_number);
+	} else {
+		return shell_value_init_text(var->value.val_text);
+	}
+}
+
+
+
+
+
+
+int shell_value_neg(shell_value *out)
+{
+	long int value;
+	int err;
+
+	err = shell_value_get_number(out,&value);
+	if(err != SHE_NO_ERROR) return err;
+
+	err = shell_value_set_number(out,-value);
+	return err;
+}
+
+
+// out = out .op. out
+
+int shell_value_do_operation(shell_value *out,const shell_value *other,int oper_type)
+{
+	long int i1;
+	long int i2;
+	long int i3;
+	int err;
+
+	if(out->isnumber != other->isnumber) return SHE_INVALID_TYPE;
+	if(out->isnumber){
+
+		i1 = out->value.val_number;
+		i2 = other->value.val_number;
+      printf("%ld %ld %d",i1,i2,oper_type);
+		switch(oper_type){
+			case SVO_ADD       : i3 = i1+i2    ;break;
+			case SVO_SUB       : i3 = i1-i2    ;break;
+			case SVO_MUL       : i3 = i1*i2    ;break;
+			case SVO_DIV       : i3 = i1/i2    ;break;
+			case SVO_BIGGER    : i3 = i1>i2    ;break;
+			case SVO_LESS      : i3 = i1<i2    ;break;
+			case SVO_EQUAL     : i3 = i1 == i2 ;break;
+			case SVO_BIGGER_E  : i3 = i1 >=i2  ;break;
+			case SVO_LESS_E    : i3 = i1 <= i2 ;break;
+			case SVO_NOT_EQUAL : i3 = i1 != i2  ;break;
+			default: return SHE_INVALID_OPERATION;
+		}
+
+	} else {
+
+		i1 = strcmp(out->value.val_text,other->value.val_text);
+
+		switch(oper_type){
+			case SVO_EQUAL	   : i3 = i1 == 0;break;
+			case SVO_BIGGER	: i3 = i1 > 0;break;
+			case SVO_LESS		: i3 = i1 < 0;break;
+			case SVO_BIGGER_E : i3 = i1 >= 0;break;
+			case SVO_LESS_E	: i3 = i1 <= 0;break;
+			case SVO_NOT_EQUAL: i3 = i1 != 0;break;
+			default : return SHE_INVALID_OPERATION;
+		}
+	}
+
+	err =  shell_value_set_number(out,i3);
+	return err;
+}
+
+
+//
+// init shell var
+//
+
+static shell_var *shell_var_init_value(const char *name,shell_value *value)
+{
+	shell_var *current;
+
+	current = malloc(sizeof(shell_var));
+	if(current == NULL) goto err;
+
+	current->name = shell_strdup(name);
+	if(current->name == NULL) goto err2;
+
+	current->value = value;
+
+	return current;
+
+	free(current->name);
+err2:
+	free(current);
+err:
+	return NULL;
+}
+
+
+
+
+//
+// Add shell variable
+//
+
+static int shell_var_add(const char *var_name,shell_value *value)
+{
+	shell_var *current;
+
+	current = shell_var_init_value(var_name,value);
+
+	current->next = var_list;
+	var_list = current;
+
+	return SHE_NO_ERROR;
+
+	free(current->name);
+
+	free(current);
+	return SHE_NO_MEMORY;
+}
+
+
+static  shell_var * find_shell_var_by_name(const char *name)
+{
+	shell_var *current;
+
+	current = var_list;
+
+	while((current != NULL) && (strcmp(current->name,name) != 0)) current = current->next;
+
+	return current;
+}
+
+
+
+
+
+static int shell_var_set(const char *var_name,shell_value *value)
+{
+	shell_var *current;
+
+	current = find_shell_var_by_name(var_name);
+
+	if(current == NULL){
+
+        return shell_var_add(var_name,value);
+
+	}
+
+	shell_value_free(current->value);
+	current->value = value;
+
+	return SHE_NO_ERROR;
+}
+
+int shell_var_set_number(const char *var_name,long int number)
+{
+	shell_value *value;
+
+	value = shell_value_init_number(number);
+	if(value == NULL) return SHE_NO_MEMORY;
+
+	return shell_var_set(var_name,value);
+}
+
+
+int shell_var_set_text(const char *var_name,const char *text)
+{
+	shell_value *value;
+
+	value = shell_value_init_text(text);
+	if(value == NULL) return SHE_NO_MEMORY;
+
+	return shell_var_set(var_name,value);
+}
+
+
+
+int set_shell_var_with_value(const char *var_name,shell_value *value)
+{
+	return shell_var_set(var_name,shell_value_clone(value));
+}
+
+shell_value *get_value_by_name(const char *name)
+{
+	shell_var *current;
+	shell_value *result = NULL;
+
+	current  = find_shell_var_by_name(name);
+
+	if(current != NULL) result = current->value;
+
+	return result;
+}
+
+
+void init_vars(void){
+	var_list = NULL;
+}
diff --git a/src/tests/kernel/boot_floppy/shell/shell_vars.h b/src/tests/kernel/boot_floppy/shell/shell_vars.h
new file mode 100644
index 0000000000..10f4479332
--- /dev/null
+++ b/src/tests/kernel/boot_floppy/shell/shell_vars.h
@@ -0,0 +1,45 @@
+#ifndef _shell_var_h_
+#define _shell_vars_h_
+
+//#include <types.h>
+
+struct _shell_value{
+	bool isnumber;
+   union{
+		char *val_text;
+		long int val_number;
+	} value;
+};
+
+typedef struct _shell_value shell_value;
+
+char *shell_strdup(const char *some_str);
+shell_value *get_value_by_name(const char *name);
+
+int shell_var_set_number(const char *var_name,long int number);
+int shell_var_set_text(const char *var_name,const char *text);
+
+int  set_shell_var_with_value(const char *var_name,shell_value *value);
+
+void init_vars(void);
+
+
+void shell_value_free(shell_value *value);
+int         shell_value_do_operation(shell_value *out,const shell_value *other,int oper_type);
+int         shell_value_neg(shell_value *out);
+char *shell_value_to_char(shell_value *value);
+shell_value *shell_value_init_number(long int value);
+shell_value *shell_value_init_text(const char *value);
+int shell_value_to_number(shell_value *value,long int *number);
+int shell_value_set_text(shell_value *value,const char *new_value);
+int shell_value_set_number(shell_value *value,long int new_value);
+int shell_value_get_number(shell_value *value,long int *number);
+int shell_value_get_text(shell_value * value,char **text);
+shell_value *shell_value_clone(shell_value *var);
+
+
+bool 		string_to_long_int(const char *str,long int *out);
+
+
+#endif
+
diff --git a/src/tests/kernel/boot_floppy/shell/statements.c b/src/tests/kernel/boot_floppy/shell/statements.c
new file mode 100644
index 0000000000..5d5317ef51
--- /dev/null
+++ b/src/tests/kernel/boot_floppy/shell/statements.c
@@ -0,0 +1,741 @@
+#include <string.h>
+#include <ctype.h>
+#include <syscalls.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "parse.h"
+#include "statements.h"
+#include "shell_vars.h"
+#include "shell_defs.h"
+#include "file_utils.h"
+
+static int parse_value(scan_info *info,shell_value **out);
+static int handle_exec(scan_info *info,shell_value **out);
+static int parse_rvl_expr(scan_info *info,shell_value **out);
+
+struct _oper_level{
+	int sym_code;
+	int level;
+
+};
+
+typedef struct _oper_level oper_level;
+
+#define MAX_LEVEL 3
+
+oper_level oper_levels[] = {
+	{SVO_EQUAL,3},
+	{SVO_LESS,3},
+	{SVO_LESS_E,3},
+	{SVO_BIGGER,3},
+	{SVO_BIGGER_E,3},
+	{SVO_NOT_EQUAL,3},
+	{SVO_ADD,2},
+	{SVO_SUB,2},
+	{SVO_MUL,1},
+	{SVO_DIV,1},
+	{0,-1}
+};
+
+
+static int
+get_oper_level(int oper)
+{
+	int cnt = 0;
+	while ((oper_levels[cnt].level != 0) && (oper_levels[cnt].sym_code != oper))
+		cnt++;
+
+	return oper_levels[cnt].level;
+}
+
+
+static int
+parse_neg(scan_info *info,shell_value **out)
+{
+	int err;
+	bool do_neg = false;
+
+	if (info->sym_code == SVO_SUB){
+		do_neg = true;
+		if (scan(info))
+			return SHE_SCAN_ERROR;
+	}
+
+	err = parse_value(info,out);
+	if (err != SHE_NO_ERROR)
+		return err;
+
+	if (do_neg) {
+		err = shell_value_neg(*out);
+		if (err != SHE_NO_ERROR) {
+			shell_value_free(*out);
+			*out = NULL;
+		}
+	}
+
+	return err;
+}
+
+
+static int
+parse_oper(scan_info *info,shell_value **out,int level)
+{
+	int err;
+	int oper_code;
+	shell_value *other;
+
+	if (level > 1)
+		err = parse_oper(info, out, level - 1);
+	else
+		err = parse_neg(info, out);
+
+	if (err != SHE_NO_ERROR)
+		return err;
+
+	oper_code = info->sym_code;
+
+	while (get_oper_level(info->sym_code) == level) {
+		if (scan(info)) {
+			err = SHE_SCAN_ERROR;
+			goto err;
+		}
+
+		if (level > 1)
+			err = parse_oper(info,&other,level - 1);
+		else
+			err = parse_neg(info,&other);
+
+		if (err != SHE_NO_ERROR)
+			goto err;
+
+		err = shell_value_do_operation(*out,other,oper_code);
+		if (err != SHE_NO_ERROR)
+			goto err_2;
+
+		shell_value_free(other);
+	}
+
+	return SHE_NO_ERROR;
+
+err_2:
+	shell_value_free(other);
+
+err:
+	shell_value_free(*out);
+	*out = NULL;
+	return err;
+
+}
+
+
+static int
+parse_expr(scan_info *info,shell_value **out)
+{
+	(*out) = NULL;
+	return parse_oper(info,out,MAX_LEVEL);
+}
+
+
+static int
+parse_cast(scan_info * info,shell_value **out)
+{
+	int err;
+	long int dummy;
+	char *text;
+	bool to_number = info->sym_code == SVO_NUMBER_CAST;
+
+	if (scan(info))
+		return SHE_SCAN_ERROR;
+
+	err = parse_rvl_expr(info,out);
+	if (err != SHE_NO_ERROR)
+		return err;
+
+	// place cast in shell_vars=>change type direct
+
+	if (to_number) {
+		err = shell_value_to_number(*out,&dummy);
+		if (err != SHE_NO_ERROR)
+			goto err;
+
+		err = shell_value_set_number(*out,dummy);
+		if (err != SHE_NO_ERROR)
+			goto err;
+	} else {
+		text = shell_value_to_char(*out);
+		err = shell_value_set_text(*out,text);
+
+		free(text);
+	}
+	return SHE_NO_ERROR;
+
+err:
+	shell_value_free(*out);
+	*out = NULL;
+	
+	return err;
+}
+
+
+static int
+parse_value(scan_info *info,shell_value **out)
+{
+	char buf2[SCAN_SIZE+1];
+	int err = SHE_NO_ERROR;
+	long int val;
+	shell_value *value;
+
+	*out = NULL;
+
+	switch (info->sym_code){
+		case SVO_DQ_STRING:
+			parse_vars_in_string(info->token,buf2,SCAN_SIZE);
+			*out = shell_value_init_text(buf2);
+			break;
+
+		case  SVO_NUMBER:
+			err = string_to_long_int(info->token,&val);
+			if(err == SHE_NO_ERROR) *out = shell_value_init_number(val);
+			break;
+
+		case  SVO_SQ_STRING:
+			*out = shell_value_init_text(info->token);
+			break;
+
+		case SVO_EXEC :
+			err = handle_exec(info,out);
+			break;
+
+		case SVO_NUMBER_CAST:
+		case SVO_STRING_CAST:
+			err = parse_cast(info,out);
+			break;
+
+		case SVO_PARENL:
+			err = parse_rvl_expr(info,out);
+			if (err)
+				return err;
+			break;
+
+		case SVO_DOLLAR:
+			if (scan(info))
+				return SHE_SCAN_ERROR;
+
+			if (info->sym_code == SVO_IDENT) {
+				value = get_value_by_name(info->token);
+				if (value != NULL)
+					 *out = shell_value_clone(value);
+				else
+					*out = shell_value_init_text("");
+			} else
+				err = SVO_IDENT;
+			break;
+
+		default:
+			return SHE_PARSE_ERROR;
+	}
+
+	if (err == SHE_NO_ERROR) {
+		if (scan(info)) {
+			if (*out != NULL)
+				shell_value_free(*out);
+			return SHE_SCAN_ERROR;
+		}
+
+		if (*out == NULL)
+			err = SHE_NO_MEMORY;
+	}
+
+	return err;
+}
+
+
+static int
+handle_exit(scan_info *info)
+{
+	long int exit_value = 0;
+	int err = SHE_NO_ERROR;
+	shell_value *expr;
+
+	if (info->sym_code == SVO_PARENL) {
+		if (scan(info))
+			return SHE_SCAN_ERROR;
+
+		err = parse_expr(info, &expr);
+		if (err != SHE_NO_ERROR)
+			return err;
+
+		if (!(expr->isnumber)) {
+			err = SHE_INVALID_TYPE;
+			goto err;
+		}
+
+		err = shell_value_get_number(expr, &exit_value);
+		if (err != SHE_NO_ERROR)
+			goto err;
+
+		if (expect(info, SVO_PARENR)) {
+			err = SVO_PARENR;
+			goto err;
+		}
+	}
+
+	exit(exit_value);
+
+err:
+	shell_value_free(expr);
+	return err;
+}
+
+
+static int
+parse_rvl_expr(scan_info *info,shell_value **out)
+{
+	int err = SHE_NO_ERROR;
+
+	*out = NULL;
+
+	if (expect(info, SVO_PARENL))
+		return SVO_PARENL;
+
+	err = parse_expr(info, out);
+	if (err != SHE_NO_ERROR)
+		return err;
+
+	if (expect(info, SVO_PARENR)) {
+		err = SVO_PARENR;
+		goto err;
+	}
+
+	return SHE_NO_ERROR;
+
+err:
+	shell_value_free(*out);
+	return err;
+}
+
+
+static int
+handle_if(scan_info *info)
+{
+	int err = SHE_NO_ERROR;
+	long int value;
+
+	shell_value *expr;
+
+	err = parse_rvl_expr(info,&expr);
+	if (err != SHE_NO_ERROR)
+		return err;
+
+	if (!expr->isnumber) {
+		err = SHE_INVALID_TYPE;
+		goto err;
+	}
+
+	err = shell_value_get_number(expr,&value);
+	if (err != SHE_NO_ERROR)
+		goto err;
+
+	if (value != 0)
+		err = parse_info(info);
+
+err:
+	shell_value_free(expr);
+	return err;
+}
+
+
+//
+// Parse exec function
+//
+
+static int
+handle_exec(scan_info *info,shell_value **out)
+{
+	shell_value *state;
+	int argc;
+	char *argv[64];
+	char redirect_in[SCAN_SIZE+1];
+	char redirect_out[SCAN_SIZE+1];
+	int err = SHE_NO_ERROR;
+	status_t retcode;
+	char *statement;
+
+	*out = NULL;
+
+	if (scan(info))
+		return SHE_SCAN_ERROR;
+
+	err = parse_rvl_expr(info, &state);
+	if (err != SHE_NO_ERROR)
+		return err;
+
+	err = shell_value_get_text(state, &statement);
+	if (err != SHE_NO_ERROR)
+		return err;
+
+	argc = parse_line(statement, argv, 64, redirect_in, redirect_out);
+	err = exec_file(argc, argv, &retcode);
+
+	if (err != SHE_NO_ERROR)
+		goto err;
+
+	*out = shell_value_init_number(retcode);
+
+err:
+	shell_value_free(state);
+	return err;
+}
+
+
+//
+// Parse load statement
+//
+
+static int
+handle_load(scan_info *info)
+{
+	char var_name[SCAN_SIZE+1];
+	shell_value *value;
+	int  err = SHE_NO_ERROR;
+
+	if(info->sym_code != SVO_IDENT) return SVO_IDENT;
+
+	strcpy(var_name,info->token);
+	if(scan(info)) return SHE_SCAN_ERROR;
+
+	if(expect(info,SVO_LOAD)) return SVO_LOAD;
+
+	err = parse_expr(info,&value);
+	if(err != SHE_NO_ERROR) return err;
+
+	set_shell_var_with_value(var_name,value);
+
+	shell_value_free(value);
+
+	return SHE_NO_ERROR;
+}
+
+
+//
+// Parse echo statement
+//
+
+static int handle_echo(scan_info *info)
+{
+	shell_value *value;
+	int err = SHE_NO_ERROR;
+	char *text;
+
+	while(info->sym_code != SVO_END){
+
+		err = parse_expr(info,&value);
+
+		if(err != SHE_NO_ERROR) return err;
+
+		text = shell_value_to_char(value);
+		printf("%s",text);
+		shell_value_free(value);
+		free(text);
+
+		if(info->sym_code == SVO_END) break;
+
+		if(expect(info,SVO_COMMA)) {
+			err = SHE_SCAN_ERROR;
+			break;
+		}
+
+	}
+
+	printf("\n");
+	return err;
+}
+
+
+//
+// Convert error code too string.
+//
+
+void ste_error_to_str(int error,char *descr)
+{
+
+	char *err_txt;
+	if(error < 0){
+		strcpy(descr,strerror(error));
+		return;
+	}
+	if(error <= SVO_MAX){
+        sprintf(descr,"'%s' expected",id_to_token(error));
+        return;
+	}
+	switch(error){
+		case SHE_NO_ERROR:
+				err_txt = "No error";
+				break;
+
+		case SHE_NO_MEMORY:
+				err_txt = "Not enough memory";
+				break;
+
+		case SHE_PARSE_ERROR:
+				err_txt = "Parse error";
+				break;
+
+		case SHE_FILE_NOT_FOUND:
+				err_txt = "File not found";
+				break;
+
+		case SHE_CANT_EXECUTE:
+				err_txt = "Can't execute";
+				break;
+
+		case SHE_INVALID_TYPE:
+				err_txt = "Invalid type";
+				break;
+
+		case SHE_INVALID_NUMBER:
+				err_txt = "Invalid number";
+				break;
+
+		case SHE_INVALID_OPERATION:
+				err_txt = "Invalid operation";
+				break;
+
+		case SHE_MISSING_QOUTE:
+				err_txt = "Missing Qoute";
+				break;
+
+		case SHE_LABEL_NOT_FOUND:
+				err_txt = "Label not found";
+				break;
+
+		default:
+				err_txt = "Unkown error";
+	}
+	strcpy(descr,err_txt);
+}
+
+// get an directory from path shell variable
+// no	   : number of path
+// name    : return buffer
+// max_len : max size of text in return buffer
+
+bool get_path(int no,char *name,int max_len)
+{
+	int cnt=no;
+	int len_cnt = max_len;
+	shell_value *var_value=get_value_by_name(NAME_VAR_PATH);
+	char *scan=name;
+	char *value;
+	int err;
+	if(var_value == NULL) return false;
+
+	err = shell_value_get_text(var_value,&value);
+	if(err != SHE_NO_ERROR) return false;
+
+	while((cnt > 0) && (*value != 0)){
+
+		while (*value != ':'){
+
+			if(*value == 0){
+				*name = 0;
+				 return false;
+			}
+			value++;
+
+		}
+		value++;
+		cnt --;
+	}
+
+	if(*value == 0) return false;
+
+	while((*value != 0) && (*value != ':') && (len_cnt > 0)){
+
+		*scan = *value;
+		scan ++;
+		value++;
+		len_cnt--;
+
+	}
+
+	*scan = 0;
+	return true;
+
+}
+
+
+static int handle_ident(scan_info *info,bool *is_label)
+{
+	char ch = *(info->scanner);
+	*is_label = false;
+
+	if(ch == ':'){
+		*is_label = true;
+		if(scan(info)) return SHE_SCAN_ERROR;
+		if(scan(info)) return SHE_SCAN_ERROR;
+		if(expect(info,SVO_END)) return SVO_END;
+	}
+
+	return SHE_NO_ERROR;
+
+}
+
+
+static int is_label_with_name(scan_info *info,char *check_label ,bool *is_label)
+{
+	char *begin = info->input_line;
+	char *scanner = begin;
+	*is_label = false;
+
+	if(*scanner == 0) return SHE_NO_ERROR;
+
+	scanner +=  strlen(scanner) -1;
+
+	while((scanner != begin)  && (isspace(*scanner))) scanner--;
+
+	if(*scanner == ':'){
+
+		if(info->sym_code != SVO_IDENT) return SVO_IDENT;
+
+		if(strcmp(check_label , info->token) == 0) *is_label = true;
+
+	}
+
+	return SHE_NO_ERROR;
+
+}
+
+
+static int scan_until_label(scan_info *info,char *label_name)
+{
+	int err;
+	bool is_label;
+
+	if(scan_info_home(info)) return SHE_SCAN_ERROR;
+	while(info->current != NULL){
+
+			err = is_label_with_name(info,label_name,&is_label);
+
+			if(is_label) return SHE_NO_ERROR;
+
+			if(scan_info_next_line(info)) return SHE_SCAN_ERROR;
+
+	}
+
+	return SHE_LABEL_NOT_FOUND;
+}
+
+static int handle_goto(scan_info *info)
+{
+	int err;
+
+	char label_name[SCAN_SIZE + 1];
+	if(scan(info)) return SHE_SCAN_ERROR;
+
+	if(info->sym_code != SVO_IDENT) return SVO_IDENT;
+
+	strcpy(label_name,info->token);
+
+	err = scan_until_label(info,label_name);
+
+	return err;
+}
+
+
+
+int parse_string(char *in)
+{
+	scan_info info;
+	init_scan_info(in,&info);
+	return parse_info(&info);
+}
+
+int parse_info(scan_info *info)
+{
+	char err_txt[255];
+	int err = SHE_NO_ERROR;
+	bool is_label;
+
+	switch(info->sym_code){
+
+		case SVO_DOLLAR :
+
+			if(scan(info)){
+
+				err = SHE_SCAN_ERROR;
+				break;
+
+			}
+			err = handle_load(info);
+			break;
+
+		case SVO_GOTO:
+
+			err = handle_goto(info);
+			break;
+
+		case SVO_IDENT:
+
+			err = handle_ident(info,&is_label);
+
+			if(!is_label){
+				err =  shell_parse(info->input_line,strlen(info->input_line));
+			}
+         break;
+         
+		case SVO_ECHO :
+			if(scan(info)){
+
+				err = SHE_SCAN_ERROR;
+				break;
+			}
+			err = handle_echo(info);
+			 	break;
+
+		case SVO_IF :
+
+			if(scan(info)){
+
+				err = SHE_SCAN_ERROR;
+
+			} else {
+
+				err = handle_if(info);
+
+			}
+         
+			break;
+
+		case SVO_EXIT :
+			if (scan(info))
+				err = SHE_SCAN_ERROR;
+			else
+				err = handle_exit(info);
+			break;
+
+		default:
+			return shell_parse(info->input_line, strlen(info->input_line));
+	}
+
+	if (err != SHE_NO_ERROR) {
+		if (err == SHE_SCAN_ERROR)
+			err = info->scan_error;
+		ste_error_to_str(err, err_txt);
+		printf("error :%d:%ld,  %d-%s \n", info->line_no,
+			info->scanner - info->input_line - strlen(info->token),
+			err, err_txt);
+	}
+	return err;
+}
+
+
+void
+init_statements(void)
+{
+	shell_var_set_text(NAME_VAR_PATH, ".:/:/boot:/boot/bin:/boot/beos/bin");
+}
+
+
+
diff --git a/src/tests/kernel/boot_floppy/shell/statements.h b/src/tests/kernel/boot_floppy/shell/statements.h
new file mode 100644
index 0000000000..03244b77f0
--- /dev/null
+++ b/src/tests/kernel/boot_floppy/shell/statements.h
@@ -0,0 +1,18 @@
+#ifndef __STATEMENTS_H_
+#define __STATEMENTS_H_
+
+//#include <types.h>
+#include "shell_defs.h"
+
+
+
+
+void init_statements(void);
+bool get_path(int no,char *name,int max_len);
+
+void ste_error_to_str(int error,char *descr);
+
+int parse_string(char *in);
+int parse_info(scan_info *info);
+
+#endif
diff --git a/src/tests/kernel/boot_floppy/sig_test.c b/src/tests/kernel/boot_floppy/sig_test.c
new file mode 100644
index 0000000000..4da429d159
--- /dev/null
+++ b/src/tests/kernel/boot_floppy/sig_test.c
@@ -0,0 +1,122 @@
+/*
+** Small test for signals handling
+*/
+
+
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <signal.h>
+#include <syscalls.h>
+
+
+typedef void (*beos_signal_func_ptr)(int, void *, struct vregs *);
+
+
+void sig_handler(int, void *data, struct vregs *regs);
+void alarm_handler(int, void *data, struct vregs *regs);
+void install_handler(int, beos_signal_func_ptr);
+int32 thread(void *);
+void usage(void);
+
+
+void
+sig_handler(int sig, void *data, struct vregs *regs)
+{
+	int i;
+	char buffer[10];
+	
+	memcpy(buffer, data, 10);
+	buffer[9] = '\0';
+	printf("sig_test (sig_handler): Received signal #%d...\n", sig);
+	printf("User data at %p (contents: \"%s\"), vregs at %p\n", data, buffer, regs);
+	printf("Counting for fun: ");
+	for (i=0; i<10; i++)
+		printf("%d ", i);
+	printf("\n");
+}
+
+
+void
+alarm_handler(int sig, void *data, struct vregs *regs)
+{
+	printf("Alarm!\n");
+}
+
+
+void
+install_handler(int sig, beos_signal_func_ptr handler)
+{
+	struct sigaction newa;
+	struct sigaction olda;
+
+	memset(&newa, 0, sizeof(newa));
+
+	newa.sa_handler = (__signal_func_ptr)handler;
+	newa.sa_flags = SA_NOMASK | SA_RESTART;
+	newa.sa_userdata = "test!";
+
+	if (sigaction(sig, &newa, &olda) < 0) {
+		printf("Failed installing handler for sig #%d!\n", sig);
+	}
+}
+
+
+int32
+thread(void *data)
+{
+	printf("Started snoozing thread...\n");
+	while (1) {
+		if (snooze(1000000000L) == B_INTERRUPTED)
+			printf("sig_test (thread): snooze was interrupted!\n");
+	}
+	return 0;
+}
+
+
+void
+usage()
+{
+	printf("usage: sig_test <mode>\n"
+		"where `mode' is one of:\n"
+		"\t1\tInstalls one handler for all signals and spawns 5 threads\n"
+		"\t2\tSame as 1 but does not spawn additional threads\n"
+		"\t3\tSets an alarm via set_alarm\n"
+		"\n");
+	exit(1);
+}
+
+
+int
+main(int argc, char **argv)
+{
+	int i;
+	
+	if (argc != 2)
+		usage();
+
+	switch (argv[1][0]) {
+		case '1':
+			printf("Spawning some threads...\n");
+			for (i=0; i<5; i++)
+				resume_thread(spawn_thread(thread, "sig_test aux thread", B_NORMAL_PRIORITY, NULL));
+		case '2':
+			printf("Installing signal handlers...\n");
+			for (i=1; i<=NSIG; i++)
+				install_handler(i, sig_handler);
+			break;
+		case '3':
+			install_handler(SIGALRM, alarm_handler);
+			set_alarm(5000000, B_PERIODIC_ALARM);
+			break;
+	}
+	printf("Done. Entering sleep mode...\n");
+	while (1) {
+		if (snooze(1000000000L) == B_INTERRUPTED)
+			// this never gets called as the syscall is always restarted
+			printf("sig_test (main): snooze was interrupted!\n");
+	}
+
+	return 0;
+}
+
diff --git a/src/tests/kernel/boot_floppy/sockettest/Jamfile b/src/tests/kernel/boot_floppy/sockettest/Jamfile
new file mode 100644
index 0000000000..3d05522c5d
--- /dev/null
+++ b/src/tests/kernel/boot_floppy/sockettest/Jamfile
@@ -0,0 +1,3 @@
+SubDir OBOS_TOP src kernel apps sockettest ;
+
+KernelObjects <$(SOURCE_GRIST)>main.c : -fpic -Wno-unused ;
diff --git a/src/tests/kernel/boot_floppy/sockettest/main.c b/src/tests/kernel/boot_floppy/sockettest/main.c
new file mode 100644
index 0000000000..526ce63159
--- /dev/null
+++ b/src/tests/kernel/boot_floppy/sockettest/main.c
@@ -0,0 +1,57 @@
+/*
+** Copyright 2001-2002, Travis Geiselbrecht. All rights reserved.
+** Distributed under the terms of the NewOS License.
+*/
+
+#include <string.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <sys/resource.h>
+#include <Errors.h>
+#include <errno.h>
+#include <sys/socket.h>
+#include <sys/ioctl.h>
+
+int main(int argc, char **argv)
+{
+	int rc = 0, fd[3];
+	int cnt, i;
+	int on = 1;
+	
+	printf("Socket Test!!!\n");
+	printf("This test doesn't do much but test that we can create a socket descriptor\n\n");
+
+	for (i=0;i<3;i++) {
+		printf("%d : ", i + 1);
+		fd[i] = socket(PF_INET, SOCK_DGRAM, 0);
+		printf("socket is fd %d\n", fd[i]);
+	
+		if (fd[i] > 0) {
+			rc = read(fd[i], NULL, 0);
+		
+			printf("    read on fd %d gave %d (expecting 0)\n", fd[i], rc);
+		}
+	}
+	
+	printf("closing the 3 fd's\n");
+	for (i=0;i<3;i++) {
+		close(fd[i]);
+	}
+
+	printf("\nNow we have no open fd's so next socket should be 3\n");
+	fd[0] = socket(PF_INET, SOCK_DGRAM, 0);
+	printf("new socket = fd %d\n", fd[0]);
+	
+	printf("trying ioctl to set non blocking: ");
+	rc = ioctl(fd[0], FIONBIO, &on, sizeof(on));
+	if (rc == 0) {
+		printf("OK\n");
+	} else {
+		printf("failed\n");
+		printf("Error was %s\n", strerror(errno));
+	}
+
+	close(fd[0]);
+		
+	return 0;
+}
diff --git a/src/tests/kernel/boot_floppy/symlink/Jamfile b/src/tests/kernel/boot_floppy/symlink/Jamfile
new file mode 100644
index 0000000000..05619634af
--- /dev/null
+++ b/src/tests/kernel/boot_floppy/symlink/Jamfile
@@ -0,0 +1,3 @@
+SubDir OBOS_TOP src kernel apps symlink ;
+
+KernelObjects <$(SOURCE_GRIST)>main.c : -fpic -Wno-unused ;
diff --git a/src/tests/kernel/boot_floppy/symlink/main.c b/src/tests/kernel/boot_floppy/symlink/main.c
new file mode 100644
index 0000000000..2eb67b36ac
--- /dev/null
+++ b/src/tests/kernel/boot_floppy/symlink/main.c
@@ -0,0 +1,22 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <string.h>
+#include <errno.h>
+
+
+int
+main(int argc, char **argv)
+{
+	if (argc < 3) {
+		fprintf(stderr, "usage: symlink <target> <link-name>\n");
+		return -1;
+	}
+	if (symlink(argv[2], argv[1]) < 0) {
+		fprintf(stderr, "symlink failed: %s\n", strerror(errno));
+		return -1;
+	}
+
+	return 0;
+}
+
diff --git a/src/tests/kernel/boot_floppy/testapp/Jamfile b/src/tests/kernel/boot_floppy/testapp/Jamfile
new file mode 100644
index 0000000000..fb59ed569d
--- /dev/null
+++ b/src/tests/kernel/boot_floppy/testapp/Jamfile
@@ -0,0 +1,3 @@
+SubDir OBOS_TOP src kernel apps testapp ;
+
+KernelObjects <$(SOURCE_GRIST)>main.c : -fpic -Wno-unused ;
diff --git a/src/tests/kernel/boot_floppy/testapp/main.c b/src/tests/kernel/boot_floppy/testapp/main.c
new file mode 100644
index 0000000000..ae63b4b61f
--- /dev/null
+++ b/src/tests/kernel/boot_floppy/testapp/main.c
@@ -0,0 +1,521 @@
+/*
+** Copyright 2001-2002, Travis Geiselbrecht. All rights reserved.
+** Distributed under the terms of the NewOS License.
+*/
+
+#include <string.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <syscalls.h>
+#include <sys/resource.h>
+#include <Errors.h>
+#include <OS.h>
+
+static void port_test(void);
+static int32 port_test_thread_func(void* arg);
+
+
+#if 0
+static int32
+test_thread(void *args)
+{
+	int i = (int)args;
+
+	snooze(1000000);
+	for(;;) {
+		printf("%c", 'a' + i);
+	}
+	return 0;
+}
+#endif
+
+
+static int32
+dummy_thread(void *args)
+{
+	return 1;
+}
+
+
+#if 0
+static int32
+cpu_eater_thread(void *args)
+{
+	for(;;)
+		;
+}
+#endif
+
+
+static int32
+fpu_cruncher_thread(void *args)
+{
+	double y = *(double *)args;
+	double z;
+
+	for(;;) {
+		z = y * 1.47;
+		y = z / 1.47;
+		if(y != *(double *)args)
+			printf("error: y %f\n", y);
+	}
+}
+
+int main(int argc, char **argv)
+{
+	int rc = 0;
+	int cnt;
+
+	printf("testapp\n");
+
+	for(cnt = 0; cnt< argc; cnt++) {
+		printf("arg %d = %s \n",cnt,argv[cnt]);
+	}
+
+	printf("my thread id is %ld\n", find_thread(NULL));
+#if 0
+	{
+		char c;
+		printf("enter something: ");
+
+		for(;;) {
+			c = getchar();
+			printf("%c", c);
+		}
+	}
+#endif
+#if 0
+	for(;;) {
+		snooze(100000);
+		printf("booyah!");
+	}
+
+	for(;;);
+#endif
+#if 0
+	printf("waiting 5 seconds\n");
+	snooze(5000000);
+#endif
+#if 0
+	fd = sys_open("/dev/net/rtl8139/0", "", STREAM_TYPE_DEVICE);
+	if(fd >= 0) {
+		for(;;) {
+			size_t len;
+			static char buf[] = {
+				0x00, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0x0F, 0x00, 0x0F, 0x00, 0x0F,
+				0x00, 0x08, 0x00, 0x45, 0x00, 0x00, 0x28, 0xF9, 0x55, 0x40, 0x00,
+				0x40, 0x06, 0xC0, 0x02, 0xC0, 0xA8, 0x00, 0x01, 0xC0, 0xA8, 0x00,
+				0x26, 0x00, 0x50, 0x0B, 0x5C, 0x81, 0xD6, 0xFA, 0x48, 0xBB, 0x17,
+				0x03, 0xC9, 0x50, 0x10, 0x7B, 0xB0, 0x6C, 0x00, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+			};
+			len = sizeof(buf);
+			sys_write(fd, buf, 0, &len);
+		}
+	}
+#endif
+#if 0
+	fd = sys_open("/dev/net/rtl8139/0", "", STREAM_TYPE_DEVICE);
+	if(fd >= 0) {
+		int foo = 0;
+		for(;;) {
+			size_t len;
+			char buf[1500];
+
+			len = sizeof(buf);
+			sys_read(fd, buf, 0, &len);
+			printf("%d read %d bytes\n", foo++, len);
+		}
+	}
+#endif
+
+// XXX dangerous! This overwrites the beginning of your hard drive
+#if 0
+	{
+		char buf[512];
+		size_t bytes_read;
+
+		printf("opening /dev/bus/ide/0/0/raw\n");
+		fd = sys_open("/dev/bus/ide/0/0/raw", "", STREAM_TYPE_DEVICE);
+		printf("fd = %d\n", fd);
+
+		bytes_read = 512;
+		rc = sys_read(fd, buf, 0, &bytes_read);
+		printf("rc = %d, bytes_read = %d\n", rc, bytes_read);
+
+		buf[0] = 'f';
+		buf[1] = 'o';
+		buf[2] = 'o';
+		buf[3] = '2';
+		buf[4] = 0;
+
+		bytes_read = 512;
+		rc = sys_write(fd, buf, 1024, &bytes_read);
+		printf("rc = %d, bytes_read = %d\n", rc, bytes_read);
+
+		sys_close(fd);
+	}
+#endif
+#if 0
+	{
+		thread_id tids[10];
+		int i;
+
+		for(i=0; i<10; i++) {
+			tids[i] = spawn_thread(&test_thread, "foo", B_NORMAL_PRIORITY, (void *)i);
+			resume_thread(tids[i]);
+		}
+
+		snooze(5000000);
+		sys_kill_team(sys_get_current_team_id());
+/*
+		sys_snooze(3000000);
+		for(i=0; i<10; i++) {
+			kill_thread(tids[i]);
+		}
+		printf("thread_is dead\n");
+		sys_snooze(5000000);
+*/
+	}
+#endif
+#if 0
+	{
+		for(;;)
+			sys_create_team("/bin/true", "true", 32);
+	}
+#endif
+#if 0
+	{
+		void *buf = (void *)0x60000000;
+		int fd;
+		int rc;
+		int len = 512;
+
+		fd = sys_open("/bin/testapp", "", STREAM_TYPE_FILE);
+
+		rc = sys_read(fd, buf, 0, &len);
+		printf("rc from read = 0x%x\n", rc);
+		sys_close(fd);
+	}
+#endif
+#if 0
+	{
+		char data;
+		int fd;
+
+		fd = sys_open("/dev/audio/pcbeep/1", STREAM_TYPE_DEVICE, 0);
+		if(fd >= 0) {
+			printf("writing to the speaker\n");
+			data = 3;
+			sys_write(fd, &data, 0, 1);
+			snooze(1000000);
+			data = 0;
+			sys_write(fd, &data, 0, 1);
+			sys_close(fd);
+		}
+	}
+#endif
+
+#if 1
+	{
+		port_test();
+	}
+#endif
+#if 0
+	{
+		int fd, bytes_read;
+		char buf[3];
+
+		fd = sys_open("/dev/ps2mouse", STREAM_TYPE_DEVICE, 0);
+		if(fd < 0) {
+			printf("failed to open device\n");
+			return -1;
+		}
+
+		bytes_read = sys_read(fd, buf, -1, 3);
+		if(bytes_read < 3) {
+			printf("failed to read device\n");
+			return -1;
+		}
+
+		printf("Status: %X\nDelta X: %d\nDelta Y: %d\n", buf[0], buf[1], buf[2]);
+	}
+#endif
+#if 0
+	{
+		int fd;
+		int buf[512/4];
+		int i, j;
+
+		fd = sys_open("/dev/disk/netblock/0/raw", STREAM_TYPE_DEVICE, 0);
+		if(fd < 0) {
+			printf("could not open netblock\n");
+			return -1;
+		}
+
+		sys_ioctl(fd, 90001, NULL, 0);
+
+		for(i=0; i<1*1024*1024; i += 512) {
+			for(j=0; j<512/4; j++)
+				buf[j] = i + j*4;
+			sys_write(fd, buf, -1, sizeof(buf));
+		}
+
+//		sys_read(fd, buf, 0, sizeof(buf));
+//		sys_write(fd, buf, 512, sizeof(buf));
+	}
+#endif
+#if 0
+
+#define NUM_FDS 150
+	{
+		int				fds[NUM_FDS], i;
+		struct rlimit	rl;
+
+		rc = getrlimit(RLIMIT_NOFILE, &rl);
+		if (rc < 0) {
+			printf("error in getrlimit\n");
+			return -1;
+		}
+
+		printf("RLIMIT_NOFILE = %lu\n", rl.rlim_cur);
+
+		for(i = 0; i < NUM_FDS; i++) {
+			fds[i] = open("/bin/testapp", 0);
+			if (fds[i] < 0) {
+				break;
+			}
+		}
+
+		printf("opened %d files\n", i);
+
+		rl.rlim_cur += 15;
+
+		printf("Setting RLIMIT_NOFILE to %lu\n", rl.rlim_cur);
+		rc = setrlimit(RLIMIT_NOFILE, &rl);
+		if (rc < 0) {
+			printf("error in setrlimit\n");
+			return -1;
+		}
+
+		rl.rlim_cur = 0;
+		rc = getrlimit(RLIMIT_NOFILE, &rl);
+		if (rc < 0) {
+			printf("error in getrlimit\n");
+			return -1;
+		}
+
+		printf("RLIMIT_NOFILE = %lu\n", rl.rlim_cur);
+
+		for(;i < NUM_FDS; i++) {
+			fds[i] = open("/bin/testapp", 0);
+			if (fds[i] < 0) {
+				break;
+			}
+		}
+
+		printf("opened a total of %d files\n", i);
+	}
+#endif
+#if 0
+	{
+		region_id rid;
+		void *ptr;
+
+		rid = sys_vm_map_file("netblock", &ptr, REGION_ADDR_ANY_ADDRESS, 16*1024, LOCK_RW,
+			REGION_NO_PRIVATE_MAP, "/dev/disk/netblock/0/raw", 0);
+		if(rid < 0) {
+			printf("error mmaping device\n");
+			return -1;
+		}
+
+		// play around with it
+		printf("mmaped device at %p\n", ptr);
+		printf("%d\n", *(int *)ptr);
+		printf("%d\n", *((int *)ptr + 1));
+		printf("%d\n", *((int *)ptr + 2));
+		printf("%d\n", *((int *)ptr + 3));
+	}
+#endif
+#if 1
+	{
+		int i;
+
+		printf("spawning %d copies of true\n", 100);
+
+		for(i=0; i<100; i++) {
+			const char *args[] = {"true", NULL};
+			thread_id id;
+			bigtime_t t;
+
+			printf("%d...", i);
+
+			t = system_time();
+
+			id = load_image(1, args, (const char **)environ);
+			if (id <= 0x2) {
+				printf("new team returned 0x%lx!\n", id);
+				return -1;
+			}
+			wait_for_thread(id, NULL);
+
+			printf("done (%Ld usecs)\n", system_time() - t);
+		}
+	}
+#endif
+#if 1
+	{
+		int i;
+
+		printf("spawning two cpu eaters\n");
+
+//		resume_thread(spawn_thread("cpu eater 1", &cpu_eater_thread, 0));
+//		resume_thread(spawn_thread(&cpu_eater_thread, "cpu eater 2", &cpu_eater_thread, 0));
+
+		printf("spawning %d threads\n", 100);
+
+		for (i = 0; i < 100; i++) {
+			thread_id id;
+			bigtime_t t;
+
+			printf("%d...", i);
+
+			t = system_time();
+
+			id = spawn_thread(&dummy_thread, "testthread", B_NORMAL_PRIORITY, NULL);
+			if (id > 0)
+				resume_thread(id);
+
+			wait_for_thread(id, NULL);
+
+			printf("done (%Ld usecs)\n", system_time() - t);
+		}
+	}
+#endif
+#if 1
+	{
+		thread_id id;
+		static double f[5] = { 2.43, 5.23, 342.34, 234123.2, 1.4 };
+
+		printf("spawning a few floating point crunchers (press key to continue)\n");
+
+		id = spawn_thread(&fpu_cruncher_thread, "fpu thread0", B_NORMAL_PRIORITY, &f[0]);
+		resume_thread(id);
+
+		id = spawn_thread(&fpu_cruncher_thread, "fpu thread1", B_NORMAL_PRIORITY, &f[1]);
+		resume_thread(id);
+
+		id = spawn_thread(&fpu_cruncher_thread, "fpu thread2", B_NORMAL_PRIORITY, &f[2]);
+		resume_thread(id);
+
+		id = spawn_thread(&fpu_cruncher_thread, "fpu thread3", B_NORMAL_PRIORITY, &f[3]);
+		resume_thread(id);
+
+		id = spawn_thread(&fpu_cruncher_thread, "fpu thread4", B_NORMAL_PRIORITY, &f[4]);
+		resume_thread(id);
+
+		getchar();
+		printf("passed the test\n");
+	}
+#endif
+
+	printf("exiting w/return code %d\n", rc);
+	return rc;
+}
+
+/*
+ * testcode ports
+ */
+
+port_id test_p1, test_p2, test_p3, test_p4;
+
+static void
+port_test(void)
+{
+	char testdata[5];
+	thread_id t;
+	int res;
+	int32 dummy;
+	int32 dummy2;
+
+	strcpy(testdata, "abcd");
+
+	printf("porttest: create_port()\n");
+	test_p1 = create_port(1,    "test port #1");
+	test_p2 = create_port(10,   "test port #2");
+	test_p3 = create_port(1024, "test port #3");
+	test_p4 = create_port(1024, "test port #4");
+
+	printf("porttest: find_port()\n");
+	printf("'test port #1' has id %ld (should be %ld)\n", find_port("test port #1"), test_p1);
+
+	printf("porttest: write_port() on 1, 2 and 3\n");
+	write_port(test_p1, 1, &testdata, sizeof(testdata));
+	write_port(test_p2, 666, &testdata, sizeof(testdata));
+	write_port(test_p3, 999, &testdata, sizeof(testdata));
+	printf("porttest: port_count(test_p1) = %ld\n", port_count(test_p1));
+
+	printf("porttest: write_port() on 1 with timeout of 1 sec (blocks 1 sec)\n");
+	write_port_etc(test_p1, 1, &testdata, sizeof(testdata), B_TIMEOUT, 1000000);
+	printf("porttest: write_port() on 2 with timeout of 1 sec (wont block)\n");
+	res = write_port_etc(test_p2, 777, &testdata, sizeof(testdata), B_TIMEOUT, 1000000);
+	printf("porttest: res=%d, %s\n", res, res == 0 ? "ok" : "BAD");
+
+	printf("porttest: read_port() on empty port 4 with timeout of 1 sec (blocks 1 sec)\n");
+	res = read_port_etc(test_p4, &dummy, &dummy2, sizeof(dummy2), B_TIMEOUT, 1000000);
+	printf("porttest: res=%d, %s\n", res, res == ETIMEDOUT ? "ok" : "BAD");
+
+	printf("porttest: spawning thread for port 1\n");
+	t = spawn_thread(port_test_thread_func, "port_test", B_NORMAL_PRIORITY, NULL);
+	// resume thread
+	resume_thread(t);
+
+	printf("porttest: write\n");
+	write_port(test_p1, 1, &testdata, sizeof(testdata));
+
+	// now we can write more (no blocking)
+	printf("porttest: write #2\n");
+	write_port(test_p1, 2, &testdata, sizeof(testdata));
+	printf("porttest: write #3\n");
+	write_port(test_p1, 3, &testdata, sizeof(testdata));
+
+	printf("porttest: waiting on spawned thread\n");
+	wait_for_thread(t, NULL);
+
+	printf("porttest: close p1\n");
+	close_port(test_p2);
+	printf("porttest: attempt write p1 after close\n");
+	res = write_port(test_p2, 4, &testdata, sizeof(testdata));
+	printf("porttest: write_port ret %s (should give Bad port id)\n", strerror(res));
+
+	printf("porttest: testing delete p2\n");
+	delete_port(test_p2);
+
+	printf("porttest: end test main thread\n");
+}
+
+
+static int32
+port_test_thread_func(void* arg)
+{
+	int32 msg_code;
+	int n;
+	char buf[5];
+
+	printf("porttest: port_test_thread_func()\n");
+
+	n = read_port(test_p1, &msg_code, &buf, 3);
+	printf("read_port #1 code %ld len %d buf %3s\n", msg_code, n, buf);
+	n = read_port(test_p1, &msg_code, &buf, 4);
+	printf("read_port #1 code %ld len %d buf %4s\n", msg_code, n, buf);
+	buf[4] = 'X';
+	n = read_port(test_p1, &msg_code, &buf, 5);
+	printf("read_port #1 code %ld len %d buf %5s\n", msg_code, n, buf);
+
+	printf("porttest: testing delete p1 from other thread\n");
+	delete_port(test_p1);
+	printf("porttest: end port_test_thread_func()\n");
+
+	return 0;
+}
+
diff --git a/src/tests/kernel/boot_floppy/testdigit/Jamfile b/src/tests/kernel/boot_floppy/testdigit/Jamfile
new file mode 100644
index 0000000000..f4111d01a2
--- /dev/null
+++ b/src/tests/kernel/boot_floppy/testdigit/Jamfile
@@ -0,0 +1,3 @@
+SubDir OBOS_TOP src kernel apps testdigit ;
+
+KernelObjects <$(SOURCE_GRIST)>main.c : -fpic -Wno-unused ;
diff --git a/src/tests/kernel/boot_floppy/testdigit/main.c b/src/tests/kernel/boot_floppy/testdigit/main.c
new file mode 100644
index 0000000000..344199b515
--- /dev/null
+++ b/src/tests/kernel/boot_floppy/testdigit/main.c
@@ -0,0 +1,47 @@
+/*
+** Copyright 2001-2002, Travis Geiselbrecht. All rights reserved.
+** Distributed under the terms of the NewOS License.
+*/
+
+#include <string.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <sys/resource.h>
+#include <Errors.h>
+#include <fcntl.h>
+
+#define DIGIT "/dev/misc/digit"
+
+int main(int argc, char **argv)
+{
+	int rc = 0, fd, i;
+	char buffer[128];
+	size_t len = 128;
+			
+	printf("Digit Test!!!\n");
+	printf("\nDigit was one of the example device drivers that Be\n"
+	       "provided, so this test basically justs runs a simple test\n"
+	       "to make sure it works with OpenBeOS.\n"
+	       "\nNB This is a simple test :)\n\n");
+
+	fd = open(DIGIT, O_RDONLY, 0);
+	if (fd < 0) {
+		printf("Failed at first hurdle :( Couldn't open the device!\n");
+		return -1;
+	}
+	
+	rc = read(fd, buffer, len);
+	printf("Read on device gave %d\n", rc);
+	for (i = 0; i < rc; i++) {
+		printf("%02x ", buffer[i]);
+		if ((i & 15) == 15)
+			printf("\n");
+	}
+	printf("\n");
+		
+	close(fd);
+	
+	printf("closed device.\n");
+
+	return 0;
+}
diff --git a/src/tests/kernel/boot_floppy/tests/Jamfile b/src/tests/kernel/boot_floppy/tests/Jamfile
new file mode 100644
index 0000000000..a9b1b02dcd
--- /dev/null
+++ b/src/tests/kernel/boot_floppy/tests/Jamfile
@@ -0,0 +1,45 @@
+SubDir OBOS_TOP src kernel apps tests ;
+
+KernelObjects 
+	<$(SOURCE_GRIST)>thread_test.c 
+	<$(SOURCE_GRIST)>fops_test.c
+	<$(SOURCE_GRIST)>random_test.c
+	: 
+	-fpic -Wno-unused 
+	;
+
+KernelLd thread_test :
+	libglue2.o
+	<$(SOURCE_GRIST)>thread_test.o
+	libroot.so
+	:
+	$(OBOS_TOP)/src/kernel/ldscripts/$(OBOS_ARCH)/app.ld
+	:
+	:
+	:
+	bin/thread_test
+	; 
+
+KernelLd fops_test :
+	libglue2.o
+	<$(SOURCE_GRIST)>fops_test.o
+	libroot.so
+	:
+	$(OBOS_TOP)/src/kernel/ldscripts/$(OBOS_ARCH)/app.ld
+	:
+	:
+	:
+	bin/fops_test
+	; 
+
+KernelLd random_test :
+	libglue2.o
+	<$(SOURCE_GRIST)>random_test.o
+	libroot.so
+	:
+	$(OBOS_TOP)/src/kernel/ldscripts/$(OBOS_ARCH)/app.ld
+	:
+	:
+	:
+	bin/random_test
+	; 
diff --git a/src/tests/kernel/boot_floppy/tests/fops_test.c b/src/tests/kernel/boot_floppy/tests/fops_test.c
new file mode 100644
index 0000000000..5791481f83
--- /dev/null
+++ b/src/tests/kernel/boot_floppy/tests/fops_test.c
@@ -0,0 +1,69 @@
+#include <string.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <syscalls.h>
+#include <sys/resource.h>
+#include <Errors.h>
+#include <errno.h>
+#include <OS.h>
+#include <stdlib.h>
+
+#define TEST_FILE "/boot/etc/fortunes"
+#define RD_LINES 5
+#define NEW_FORTUNE "The path has been shown - we are the ones who must walk it"
+
+
+static void
+read_file(FILE *f)
+{
+	char buffer[2048];
+	int lines = 0;
+
+	while ((fgets(buffer, sizeof(buffer), f)) != NULL) {
+		size_t bytes = strlen(buffer);
+
+		if (buffer[0] == '#')
+			continue;
+
+		if (buffer[bytes - 1] != '\n')
+			buffer[bytes - 1] = '\n';
+
+		fprintf(stdout, "%d: %s", ++lines, buffer);
+	}
+}
+
+
+int
+main(int argc, char **argv)
+{
+	FILE *f;
+	
+	f = fopen(TEST_FILE, "rw");
+	if (!f) {
+		printf("Failed to open %s :( [%s]\n", TEST_FILE,
+                       strerror(errno));
+		return -1;
+	}
+
+	read_file(f);
+	fputs("#@#\n", f);
+	fputs(NEW_FORTUNE, f);
+
+	fprintf(stdout, "File added to.\n");
+			
+	fclose(f);
+	printf("File opened and closed\n");
+
+	f = fopen(TEST_FILE, "r");
+	if (!f) {
+		printf("Failed to open %s :( [%s]\n", TEST_FILE,
+                       strerror(errno));
+		return -1;
+	}
+	
+	read_file(f);
+	fclose(f);	
+	printf("File opened and closed\n");
+	
+	return 0;
+}
diff --git a/src/tests/kernel/boot_floppy/tests/random_test.c b/src/tests/kernel/boot_floppy/tests/random_test.c
new file mode 100644
index 0000000000..9bc8465403
--- /dev/null
+++ b/src/tests/kernel/boot_floppy/tests/random_test.c
@@ -0,0 +1,43 @@
+#include <string.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <syscalls.h>
+#include <sys/resource.h>
+#include <Errors.h>
+#include <errno.h>
+#include <OS.h>
+#include <stdlib.h>
+#include <fcntl.h>
+
+#define RANDOM_DEVICE "/dev/urandom"
+#define RANDOM_CHECKS  5
+#define STR_LEN       16
+int main(int argc, char **argv)
+{
+	int fd;
+	char data[STR_LEN];
+	int rv, i, j;
+		
+	printf("/dev/urandom test\n"
+	       "=================\n\n");
+
+	fd = open(RANDOM_DEVICE, O_RDONLY);
+	if (fd < 0) {
+		printf("Failed to open %s\n", RANDOM_DEVICE);
+		return -1;
+	}
+	
+	for (i=0; i < RANDOM_CHECKS; i++) {
+		rv = read(fd, data, STR_LEN);
+		if (rv < STR_LEN)
+			break;
+		printf ("%d: ", i);
+		for (j=0; j < sizeof(data);j++) {
+			printf(" %02x ", (uint8)data[j]);
+		}
+		printf("\n");
+	}
+	close(fd);
+
+	return 0;
+}
diff --git a/src/tests/kernel/boot_floppy/tests/thread_test.c b/src/tests/kernel/boot_floppy/tests/thread_test.c
new file mode 100644
index 0000000000..869930d91c
--- /dev/null
+++ b/src/tests/kernel/boot_floppy/tests/thread_test.c
@@ -0,0 +1,136 @@
+/*
+** Copyright 2002-2004, The OpenBeOS Team. All rights reserved.
+** Distributed under the terms of the MIT License.
+*/
+
+
+#include <OS.h>
+
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+
+#define THREADS    5
+#define START_VAL  1
+
+struct the_test {
+	int   *current_val;
+	int    thread_mult;
+	sem_id the_lock;	
+};
+
+
+static int32
+counter_thread(void *data)
+{
+	struct the_test *tt = (struct the_test*)data;
+		
+	acquire_sem(tt->the_lock);
+	
+	*(tt->current_val) *= tt->thread_mult;
+	
+	release_sem(tt->the_lock);
+	
+	free(data);
+	return 0;
+}
+
+
+static int32
+priority_test(void *data)
+{
+	int i;
+	
+	for (i = 0; i < 6; i++) {
+		printf("%s: %d\n", (char *)data, i);
+//		sys_snooze(1000);
+	}
+	return 0;
+}
+
+
+static int32
+communication_test(void *data)
+{
+	int times = (int)data;
+	int i, code;
+	char buffer[1024];
+	thread_id sender;
+	
+	for (i = 0; i < times; i++) {
+		code = receive_data(&sender, (void *)buffer, sizeof(buffer));
+		printf(" -> received (%d): \"%s\"\n", code, buffer);
+	}
+	return 0;
+}
+
+
+int
+main(int argc, char **argv)
+{
+	thread_id t[THREADS];
+	sem_id lock;
+	int i;
+	int expected = START_VAL, current_val = START_VAL;
+	char *comm_test[] = {	"This is a test",
+							"of the send_data",
+							"and receive_data",
+							"syscalls implementation",
+							"for OpenBeOS"	};
+		
+	printf("OpenBeOS Thread Test - Simple\n"
+	       "=============================\n");
+
+	lock = create_sem(1, "test_lock");
+
+	for (i = 0; i < THREADS; i++) {		
+		struct the_test *my_test = (struct the_test*)malloc(sizeof(struct the_test));
+		my_test->the_lock = lock;
+		my_test->current_val = &current_val;
+		my_test->thread_mult = i + 1;
+
+		t[i] = spawn_thread(counter_thread, "counter", B_NORMAL_PRIORITY, my_test);
+		if (t[i] > 0) {
+			resume_thread(t[i]);
+			expected *= (i + 1);
+		}
+	}
+	
+	wait_for_thread(t[THREADS - 1], NULL);
+	
+	printf("Test value = %d vs expected of %d\n", current_val, expected);
+	
+	delete_sem(lock);
+	
+	t[0] = spawn_thread(priority_test, "thread0", 11, "thread0");
+	t[1] = spawn_thread(priority_test, "thread1", 12, "thread1");
+	t[2] = spawn_thread(priority_test, "thread2", 13, "thread2");
+	resume_thread(t[0]);
+	resume_thread(t[1]);
+	resume_thread(t[2]);
+	
+	printf("Snoozing...\n");
+	snooze(100000);
+	printf("Waiting for threads...");
+	wait_for_thread(t[0], NULL);
+	printf("1, ");
+	wait_for_thread(t[1], NULL);
+	printf("2, ");
+	wait_for_thread(t[2], NULL);
+
+	printf("3.\nDone. Spawning commthread...\n");
+	t[0] = spawn_thread(communication_test, "commthread", B_NORMAL_PRIORITY, (void *)5);
+	printf("Spawned. Starting communication...\n");
+	resume_thread(t[0]);
+	
+	for (i = 0; i < 5; i++) {
+		printf("sending");
+		send_data(t[0], i, comm_test[i], strlen(comm_test[i]) + 1);
+		// Give time to the commthread to display info
+		snooze(10000);
+	}
+	wait_for_thread(t[0], NULL);
+
+	return 0;
+}
diff --git a/src/tests/kernel/boot_floppy/tls_test.c b/src/tests/kernel/boot_floppy/tls_test.c
new file mode 100644
index 0000000000..a2f044165b
--- /dev/null
+++ b/src/tests/kernel/boot_floppy/tls_test.c
@@ -0,0 +1,97 @@
+/* tests TLS (thread locale storage) functionality */
+
+/* 
+** Copyright 2002, Axel Dörfler, axeld@pinc-software.de. All rights reserved.
+** Distributed under the terms of the OpenBeOS License.
+*/
+
+
+#include <OS.h>
+#include <TLS.h>
+
+#include <stdio.h>
+#include <string.h>
+
+
+sem_id gWait;
+int32 gSlot;
+
+
+#if __INTEL__
+static void *
+read_fs_register(void)
+{
+	void *fs;
+
+	asm("movl %%fs, %0" : "=r" (fs));
+	return fs;
+}
+#endif
+
+
+static int32
+thread1_func(void *data)
+{
+	printf("1. stack at %p, thread id = %ld\n", &data, find_thread(NULL));
+	printf("1. TLS address = %p\n", tls_address(gSlot));
+	tls_set(gSlot, (void *)"thread 1");
+	printf("1. TLS get = \"%s\" (should be \"thread 1\")\n", (char *)tls_get(gSlot));
+
+	acquire_sem(gWait);
+
+	printf("1. TLS get = \"%s\" (should be \"thread 1\")\n", (char *)tls_get(gSlot));
+
+	return 0;
+}
+
+
+static int32
+thread2_func(void *data)
+{
+	printf("2. stack at %p, thread id = %ld\n", &data, find_thread(NULL));
+	printf("2. TLS address = %p\n", tls_address(gSlot));
+	printf("2. TLS get = \"%s\" (should be NULL)\n", (char *)tls_get(gSlot));
+
+	acquire_sem(gWait);
+
+	printf("2. TLS get = \"%s\" (should be NULL)\n", (char *)tls_get(gSlot));
+
+	return 0;
+}
+
+
+int
+main(int argc, char **argv)
+{
+	thread_id thread1, thread2;
+	status_t returnCode;
+
+	gWait = create_sem(0, "waiter");
+	gSlot = tls_allocate();
+
+	printf("got slot %ld, stack at %p, thread id = %ld\n", gSlot, &thread1, find_thread(NULL));
+
+#if __INTEL__
+	printf("FS register is %p\n", read_fs_register());
+#endif
+	printf("TLS address in main = %p\n", tls_address(gSlot));
+
+	tls_set(gSlot, (void *)"main thread");
+
+	thread1 = spawn_thread(thread1_func, "Thread 1" , B_NORMAL_PRIORITY, NULL);
+	resume_thread(thread1);
+	thread2 = spawn_thread(thread2_func, "Thread 2" , B_NORMAL_PRIORITY, NULL);
+	resume_thread(thread2);
+
+	printf("TLS in main = \"%s\" (should be \"main thread\")\n", (char *)tls_get(gSlot));
+
+	// shut down
+	snooze(100000);
+	delete_sem(gWait);
+
+	wait_for_thread(thread1, &returnCode);
+	wait_for_thread(thread2, &returnCode);
+
+	return 0;
+}
+
diff --git a/src/tests/kernel/boot_floppy/true_main.c b/src/tests/kernel/boot_floppy/true_main.c
new file mode 100644
index 0000000000..9128fb0be9
--- /dev/null
+++ b/src/tests/kernel/boot_floppy/true_main.c
@@ -0,0 +1,13 @@
+/*
+** Copyright 2002, Manuel J. Petit. All rights reserved.
+** Contains portions of:
+**
+**    /boot/bin/true, Copyright 2001 Travis K. Geiselbrecht
+**
+** Distributed under the terms of the NewOS License.
+*/
+int main(void)
+{
+	return 1;
+}
+
diff --git a/src/tests/kernel/boot_floppy/uname/Jamfile b/src/tests/kernel/boot_floppy/uname/Jamfile
new file mode 100644
index 0000000000..cf8eec9ce8
--- /dev/null
+++ b/src/tests/kernel/boot_floppy/uname/Jamfile
@@ -0,0 +1,3 @@
+SubDir OBOS_TOP src kernel apps uname ;
+
+KernelObjects <$(SOURCE_GRIST)>main.c : -fpic -Wno-unused ;
diff --git a/src/tests/kernel/boot_floppy/uname/main.c b/src/tests/kernel/boot_floppy/uname/main.c
new file mode 100644
index 0000000000..696645f033
--- /dev/null
+++ b/src/tests/kernel/boot_floppy/uname/main.c
@@ -0,0 +1,188 @@
+/* Copyright (c) 1993
+ *	The Regents of the University of California.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *	This product includes software developed by the University of
+ *	California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <sys/types.h>
+
+//#include <sys/param.h>
+#include <sysctl.h>
+
+//#include <err.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <Errors.h>
+
+void usage(void);
+
+int
+main(int argc, char **argv)
+{
+
+#define	MFLAG	0x01
+#define	NFLAG	0x02
+#define	PFLAG	0x04
+#define	RFLAG	0x08
+#define	SFLAG	0x10
+#define	VFLAG	0x20
+	u_int flags;
+	int ch, mib[2];
+	size_t len, tlen;
+	char *p, buf[1024];
+	const char *prefix;
+
+	flags = 0;
+	while ((ch = getopt(argc, argv, "amnprsv")) != -1)
+		switch(ch) {
+		case 'a':
+			flags |= (MFLAG | NFLAG | RFLAG | SFLAG | VFLAG);
+			break;
+		case 'm':
+			flags |= MFLAG;
+			break;
+		case 'n':
+			flags |= NFLAG;
+			break;
+		case 'p':
+			flags |= PFLAG;
+			break;
+		case 'r':
+			flags |= RFLAG;
+			break;
+		case 's':
+			flags |= SFLAG;
+			break;
+		case 'v':
+			flags |= VFLAG;
+			break;
+		case '?':
+		default:
+			usage();
+		}
+
+	argc -= optind;
+	argv += optind;
+
+	if (argc)
+		usage();
+
+	if (!flags)
+		flags |= SFLAG;
+
+	prefix = "";
+
+	if (flags & SFLAG) {
+		mib[0] = CTL_KERN;
+		mib[1] = KERN_OSTYPE;
+		len = sizeof(buf);
+		if (sysctl(mib, 2, &buf, &len, NULL, 0) == -1) {
+		//	err(1, "sysctl");
+			printf("An error occured\n");
+			return -1;
+		}
+		(void)printf("%s%.*s", prefix, (int)len, buf);
+		prefix = " ";
+	}
+	if (flags & NFLAG) {
+		mib[0] = CTL_KERN;
+		mib[1] = KERN_HOSTNAME;
+		len = sizeof(buf);
+		if (sysctl(mib, 2, &buf, &len, NULL, 0) == -1) {
+		//	err(1, "sysctl");
+                        printf("An error occured\n");
+			return -1;
+                }		
+		(void)printf("%s%.*s", prefix, (int)len, buf);
+		prefix = " ";
+	}
+	if (flags & RFLAG) {
+		mib[0] = CTL_KERN;
+		mib[1] = KERN_OSRELEASE;
+		len = sizeof(buf);
+		if (sysctl(mib, 2, &buf, &len, NULL, 0) == -1) {
+		//	err(1, "sysctl");
+                        printf("An error occured\n");
+			return -1;
+                }
+		(void)printf("%s%.*s", prefix, (int)len, buf);
+		prefix = " ";
+	}
+	if (flags & VFLAG) {
+		mib[0] = CTL_KERN;
+		mib[1] = KERN_VERSION;
+		len = sizeof(buf);
+		if (sysctl(mib, 2, &buf, &len, NULL, 0) == -1){
+		//	err(1, "sysctl");
+			printf("An error occured\n");
+			return -1;
+		}
+		for (p = buf, tlen = len; tlen--; ++p)
+			if (*p == '\n' || *p == '\t')
+				*p = ' ';
+		(void)printf("%s%.*s", prefix, (int)len, buf);
+		prefix = " ";
+	}
+	if (flags & MFLAG) {
+		mib[0] = CTL_HW;
+		mib[1] = HW_MACHINE;
+		len = sizeof(buf);
+		if (sysctl(mib, 2, &buf, &len, NULL, 0) == -1) {
+		//	err(1, "sysctl");
+                        printf("An error occured\n");
+			return -1;
+                }
+		(void)printf("%s%.*s", prefix, (int)len, buf);
+		prefix = " ";
+	}
+	if (flags & PFLAG) {
+		mib[0] = CTL_HW;
+		mib[1] = HW_MODEL;
+		len = sizeof(buf);
+		if (sysctl(mib, 2, &buf, &len, NULL, 0) == -1) {
+		//	err(1, "sysctl");
+                        printf("An error occured\n");
+			return -1;
+                }
+		(void)printf("%s%.*s", prefix, (int)len, buf);
+		prefix = " ";
+	}
+	(void)printf("\n");
+	//exit (0);
+	return B_NO_ERROR;
+}
+
+void
+usage()
+{
+	(void)fprintf(stderr, "usage: uname [-amnprsv]\n");
+	//exit(1);
+}
+