diff --git a/examples/libc/SConscript b/examples/libc/SConscript
new file mode 100644
index 0000000000000000000000000000000000000000..af43df3ddb7b641be884112124dbd5eaf04da81d
--- /dev/null
+++ b/examples/libc/SConscript
@@ -0,0 +1,8 @@
+Import('env')
+
+src_local = Glob('*.c')
+
+# The set of source files associated with this SConscript file.
+obj = env.Object(src_local)
+
+Return('obj')
diff --git a/examples/libc/dirent.c b/examples/libc/dirent.c
new file mode 100644
index 0000000000000000000000000000000000000000..a763ecb0227eb93bdf312d3aa10447d1aa4d9643
--- /dev/null
+++ b/examples/libc/dirent.c
@@ -0,0 +1,56 @@
+/*
+ * dirent.c
+ *
+ *  Created on: 2010-11-17
+ *      Author: bernard
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <finsh.h>
+
+#include <dirent.h>
+int libc_dirent()
+{
+	DIR * dirp;
+	long int save3 = 0;
+	long int cur;
+	int i = 0;
+	int result = 0;
+	struct dirent *dp;
+
+	dirp = opendir("/");
+	for (dp = readdir(dirp); dp != NULL; dp = readdir(dirp))
+	{
+		/* save position 3 (after fourth entry) */
+		if (i++ == 3)
+			save3 = telldir(dirp);
+
+		printf("%s\n", dp->d_name);
+
+		/* stop at 400 (just to make sure dirp->__offset and dirp->__size are
+		 scrambled */
+		if (i == 400)
+			break;
+	}
+
+	printf("going back past 4-th entry...\n");
+
+	/* go back to saved entry */
+	seekdir(dirp, save3);
+
+	/* Check whether telldir equals to save3 now.  */
+	cur = telldir(dirp);
+	if (cur != save3)
+	{
+		printf("seekdir (d, %ld); telldir (d) == %ld\n", save3, cur);
+		result = 1;
+	}
+
+	/* print remaining files (3-last) */
+	for (dp = readdir(dirp); dp != NULL; dp = readdir(dirp))
+		printf("%s\n", dp->d_name);
+
+	closedir(dirp);
+	return result;
+}
+FINSH_FUNCTION_EXPORT(libc_dirent, dirent test for libc);
diff --git a/examples/libc/env.c b/examples/libc/env.c
new file mode 100644
index 0000000000000000000000000000000000000000..56f906774f52939b3032f7a19d0d21ba573735cd
--- /dev/null
+++ b/examples/libc/env.c
@@ -0,0 +1,18 @@
+/*
+ * env.c
+ *
+ *  Created on: 2010-11-17
+ *      Author: bernard
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <finsh.h>
+
+int libc_env()
+{
+	printf("PATH=%s\n", getenv("PATH"));
+	putenv("foo=bar");
+	printf("foo=%s\n", getenv("foo"));
+	return 0;
+}
+FINSH_FUNCTION_EXPORT(libc_env, get/set_env test);
diff --git a/examples/libc/ex1.c b/examples/libc/ex1.c
new file mode 100644
index 0000000000000000000000000000000000000000..2acbfc3a39cb66b060e4b1d21f414101eb72fa91
--- /dev/null
+++ b/examples/libc/ex1.c
@@ -0,0 +1,37 @@
+/* Creates two threads, one printing 10000 "a"s, the other printing
+   10000 "b"s.
+   Illustrates: thread creation, thread joining. */
+
+#include <stddef.h>
+#include <stdio.h>
+#include <unistd.h>
+#include "pthread.h"
+
+static void *process(void * arg)
+{
+	int i;
+	printf("Starting process %s\n", (char *)arg);
+	for (i = 0; i < 10000; i++)
+		write(1, (char *) arg, 1);
+	return NULL;
+}
+
+#define sucfail(r) (r != 0 ? "failed" : "succeeded")
+int libc_ex1(void)
+{
+	int pret, ret = 0;
+	pthread_t th_a, th_b;
+	void *retval;
+
+	ret += (pret = pthread_create(&th_a, NULL, process, (void *)"a"));
+	printf("create a %s %d\n", sucfail(pret), pret);
+	ret += (pret = pthread_create(&th_b, NULL, process, (void *)"b"));
+	printf("create b %s %d\n", sucfail(pret), pret);
+	ret += (pret = pthread_join(th_a, &retval));
+	printf("join a %s %d\n", sucfail(pret), pret);
+	ret += (pret = pthread_join(th_b, &retval));
+	printf("join b %s %d\n", sucfail(pret), pret);
+	return ret;
+}
+#include <finsh.h>
+FINSH_FUNCTION_EXPORT(libc_ex1, example 1 for libc);
diff --git a/examples/libc/ex2.c b/examples/libc/ex2.c
new file mode 100644
index 0000000000000000000000000000000000000000..925f4e1f233b423c97ea7e344ca8f3af37446aa5
--- /dev/null
+++ b/examples/libc/ex2.c
@@ -0,0 +1,114 @@
+/* The classic producer-consumer example.
+   Illustrates mutexes and conditions.
+   All integers between 0 and 9999 should be printed exactly twice,
+   once to the right of the arrow and once to the left. */
+
+#include <stdio.h>
+#include "pthread.h"
+
+#define BUFFER_SIZE 16
+
+/* Circular buffer of integers. */
+
+struct prodcons {
+  int buffer[BUFFER_SIZE];      /* the actual data */
+  pthread_mutex_t lock;         /* mutex ensuring exclusive access to buffer */
+  int readpos, writepos;        /* positions for reading and writing */
+  pthread_cond_t notempty;      /* signaled when buffer is not empty */
+  pthread_cond_t notfull;       /* signaled when buffer is not full */
+};
+
+/* Initialize a buffer */
+
+static void init(struct prodcons * b)
+{
+  pthread_mutex_init(&b->lock, NULL);
+  pthread_cond_init(&b->notempty, NULL);
+  pthread_cond_init(&b->notfull, NULL);
+  b->readpos = 0;
+  b->writepos = 0;
+}
+
+/* Store an integer in the buffer */
+static void put(struct prodcons * b, int data)
+{
+  pthread_mutex_lock(&b->lock);
+  /* Wait until buffer is not full */
+  while ((b->writepos + 1) % BUFFER_SIZE == b->readpos) {
+    pthread_cond_wait(&b->notfull, &b->lock);
+    /* pthread_cond_wait reacquired b->lock before returning */
+  }
+  /* Write the data and advance write pointer */
+  b->buffer[b->writepos] = data;
+  b->writepos++;
+  if (b->writepos >= BUFFER_SIZE) b->writepos = 0;
+  /* Signal that the buffer is now not empty */
+  pthread_cond_signal(&b->notempty);
+  pthread_mutex_unlock(&b->lock);
+}
+
+/* Read and remove an integer from the buffer */
+
+static int get(struct prodcons * b)
+{
+  int data;
+  pthread_mutex_lock(&b->lock);
+  /* Wait until buffer is not empty */
+  while (b->writepos == b->readpos) {
+    pthread_cond_wait(&b->notempty, &b->lock);
+  }
+  /* Read the data and advance read pointer */
+  data = b->buffer[b->readpos];
+  b->readpos++;
+  if (b->readpos >= BUFFER_SIZE) b->readpos = 0;
+  /* Signal that the buffer is now not full */
+  pthread_cond_signal(&b->notfull);
+  pthread_mutex_unlock(&b->lock);
+  return data;
+}
+
+/* A test program: one thread inserts integers from 1 to 10000,
+   the other reads them and prints them. */
+
+#define OVER (-1)
+
+struct prodcons buffer;
+
+static void * producer(void * data)
+{
+  int n;
+  for (n = 0; n < 10000; n++) {
+    printf("%d --->\n", n);
+    put(&buffer, n);
+  }
+  put(&buffer, OVER);
+  return NULL;
+}
+
+static void * consumer(void * data)
+{
+  int d;
+  while (1) {
+    d = get(&buffer);
+    if (d == OVER) break;
+    printf("---> %d\n", d);
+  }
+  return NULL;
+}
+
+int libc_ex2(void)
+{
+  pthread_t th_a, th_b;
+  void * retval;
+
+  init(&buffer);
+  /* Create the threads */
+  pthread_create(&th_a, NULL, producer, 0);
+  pthread_create(&th_b, NULL, consumer, 0);
+  /* Wait until producer and consumer finish. */
+  pthread_join(th_a, &retval);
+  pthread_join(th_b, &retval);
+  return 0;
+}
+#include <finsh.h>
+FINSH_FUNCTION_EXPORT(libc_ex2, example 2 for libc);
diff --git a/examples/libc/ex3.c b/examples/libc/ex3.c
new file mode 100644
index 0000000000000000000000000000000000000000..e4e3405d20a0d843d40bf2f25a56c772ec134626
--- /dev/null
+++ b/examples/libc/ex3.c
@@ -0,0 +1,154 @@
+/* Multi-thread searching.
+   Illustrates: thread cancellation, cleanup handlers. */
+
+#include <errno.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <sys/types.h>
+#include <pthread.h>
+
+/* Defines the number of searching threads */
+#define NUM_THREADS 5
+
+/* Function prototypes */
+void *search(void *);
+void print_it(void *);
+
+/* Global variables */
+pthread_t threads[NUM_THREADS];
+pthread_mutex_t lock;
+int tries;
+volatile int started;
+
+int libc_ex3()
+{
+  int i;
+  int pid;
+
+  /* create a number to search for */
+  pid = getpid();
+  printf("Searching for the number = %d...\n", pid);
+
+  /* Initialize the mutex lock */
+  pthread_mutex_init(&lock, NULL);
+
+  /* Create the searching threads */
+  for (started=0; started<NUM_THREADS; started++)
+    pthread_create(&threads[started], NULL, search, (void *)pid);
+
+  /* Wait for (join) all the searching threads */
+  for (i=0; i<NUM_THREADS; i++)
+    pthread_join(threads[i], NULL);
+
+  printf("It took %d tries to find the number.\n", tries);
+
+  /* Exit the program */
+  return 0;
+}
+#include <finsh.h>
+FINSH_FUNCTION_EXPORT(libc_ex3, example 5 for libc);
+
+/* This is the cleanup function that is called
+   when the threads are cancelled */
+
+void print_it(void *arg)
+{
+  int *try = (int *) arg;
+  pthread_t tid;
+
+  /* Get the calling thread's ID */
+  tid = pthread_self();
+
+  /* Print where the thread was in its search when it was cancelled */
+  printf("Thread %lx was canceled on its %d try.\n", tid, *try);
+}
+
+/* This is the search routine that is executed in each thread */
+
+void *search(void *arg)
+{
+  int num = (int) arg;
+  int i, j, ntries;
+  pthread_t tid;
+
+  /* get the calling thread ID */
+  tid = pthread_self();
+
+  /* use the thread ID to set the seed for the random number generator */
+  /* Since srand and rand are not thread-safe, serialize with lock */
+
+  /* Try to lock the mutex lock --
+     if locked, check to see if the thread has been cancelled
+     if not locked then continue */
+  while (pthread_mutex_trylock(&lock) == EBUSY)
+    pthread_testcancel();
+
+  srand((int)tid);
+  i = rand() & 0xFFFFFF;
+  pthread_mutex_unlock(&lock);
+  ntries = 0;
+
+  /* Set the cancellation parameters --
+     - Enable thread cancellation
+     - Defer the action of the cancellation */
+
+  pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
+  pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED, NULL);
+
+  while (started < NUM_THREADS)
+    sched_yield ();
+
+  /* Push the cleanup routine (print_it) onto the thread
+     cleanup stack.  This routine will be called when the
+     thread is cancelled.  Also note that the pthread_cleanup_push
+     call must have a matching pthread_cleanup_pop call.  The
+     push and pop calls MUST be at the same lexical level
+     within the code */
+
+  /* Pass address of `ntries' since the current value of `ntries' is not
+     the one we want to use in the cleanup function */
+
+  pthread_cleanup_push(print_it, (void *)&ntries);
+
+  /* Loop forever */
+  while (1) {
+    i = (i + 1) & 0xFFFFFF;
+    ntries++;
+
+    /* Does the random number match the target number? */
+    if (num == i) {
+      /* Try to lock the mutex lock --
+         if locked, check to see if the thread has been cancelled
+         if not locked then continue */
+      while (pthread_mutex_trylock(&lock) == EBUSY)
+        pthread_testcancel();
+
+      /* Set the global variable for the number of tries */
+      tries = ntries;
+      printf("Thread %lx found the number!\n", tid);
+
+      /* Cancel all the other threads */
+      for (j=0; j<NUM_THREADS; j++)
+        if (threads[j] != tid) pthread_cancel(threads[j]);
+
+      /* Break out of the while loop */
+      break;
+    }
+
+    /* Every 100 tries check to see if the thread has been cancelled. */
+    if (ntries % 100 == 0) {
+      pthread_testcancel();
+    }
+  }
+
+  /* The only way we can get here is when the thread breaks out
+     of the while loop.  In this case the thread that makes it here
+     has found the number we are looking for and does not need to run
+     the thread cleanup function.  This is why the pthread_cleanup_pop
+     function is called with a 0 argument; this will pop the cleanup
+     function off the stack without executing it */
+
+  pthread_cleanup_pop(0);
+  return((void *)0);
+}
diff --git a/examples/libc/ex4.c b/examples/libc/ex4.c
new file mode 100644
index 0000000000000000000000000000000000000000..eb7984037279811c90bd9a50f1aa20d85042d2d8
--- /dev/null
+++ b/examples/libc/ex4.c
@@ -0,0 +1,108 @@
+/* Making a library function that uses static variables thread-safe.
+   Illustrates: thread-specific data, pthread_once(). */
+
+#include <stddef.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <pthread.h>
+
+/* This is a typical example of a library function that uses
+   static variables to accumulate results between calls.
+   Here, it just returns the concatenation of all string arguments
+   that were given to it. */
+
+#if 0
+
+char * str_accumulate(char * s)
+{
+  static char accu[1024] = { 0 };
+  strcat(accu, s);
+  return accu;
+}
+
+#endif
+
+/* Of course, this cannot be used in a multi-threaded program
+   because all threads store "accu" at the same location.
+   So, we'll use thread-specific data to have a different "accu"
+   for each thread. */
+
+/* Key identifying the thread-specific data */
+static pthread_key_t str_key;
+/* "Once" variable ensuring that the key for str_alloc will be allocated
+   exactly once. */
+static pthread_once_t str_alloc_key_once = PTHREAD_ONCE_INIT;
+
+/* Forward functions */
+static void str_alloc_key(void);
+static void str_alloc_destroy_accu(void * accu);
+
+/* Thread-safe version of str_accumulate */
+
+char * str_accumulate(const char * s)
+{
+  char * accu;
+
+  /* Make sure the key is allocated */
+  pthread_once(&str_alloc_key_once, str_alloc_key);
+  /* Get the thread-specific data associated with the key */
+  accu = (char *) pthread_getspecific(str_key);
+  /* It's initially NULL, meaning that we must allocate the buffer first. */
+  if (accu == NULL) {
+    accu = malloc(1024);
+    if (accu == NULL) return NULL;
+    accu[0] = 0;
+    /* Store the buffer pointer in the thread-specific data. */
+    pthread_setspecific(str_key, (void *) accu);
+    printf("Thread %lx: allocating buffer at %p\n", pthread_self(), accu);
+  }
+  /* Now we can use accu just as in the non thread-safe code. */
+  strcat(accu, s);
+  return accu;
+}
+
+/* Function to allocate the key for str_alloc thread-specific data. */
+
+static void str_alloc_key(void)
+{
+  pthread_key_create(&str_key, str_alloc_destroy_accu);
+  printf("Thread %lx: allocated key %d\n", pthread_self(), str_key);
+}
+
+/* Function to free the buffer when the thread exits. */
+/* Called only when the thread-specific data is not NULL. */
+
+static void str_alloc_destroy_accu(void * accu)
+{
+  printf("Thread %lx: freeing buffer at %p\n", pthread_self(), accu);
+  free(accu);
+}
+
+/* Test program */
+
+static void *process(void * arg)
+{
+  char *res;
+  res = str_accumulate("Result of ");
+  res = str_accumulate((char *) arg);
+  res = str_accumulate(" thread");
+  printf("Thread %lx: \"%s\"\n", pthread_self(), res);
+  return NULL;
+}
+
+int libc_ex4()
+{
+  char * res;
+  pthread_t th1, th2;
+
+  // res = str_accumulate("Result of ");
+  pthread_create(&th1, NULL, process, (void *) "first");
+  pthread_create(&th2, NULL, process, (void *) "second");
+  // res = str_accumulate("initial thread");
+  printf("Thread %lx: \"%s\"\n", pthread_self(), res);
+  pthread_join(th1, NULL);
+  pthread_join(th2, NULL);
+}
+#include <finsh.h>
+FINSH_FUNCTION_EXPORT(libc_ex4, example 4 for libc);
diff --git a/examples/libc/ex5.c b/examples/libc/ex5.c
new file mode 100644
index 0000000000000000000000000000000000000000..aa94c34063d104b8c43b497d78ea6e59ea29e284
--- /dev/null
+++ b/examples/libc/ex5.c
@@ -0,0 +1,105 @@
+/* The classic producer-consumer example, implemented with semaphores.
+   All integers between 0 and 9999 should be printed exactly twice,
+   once to the right of the arrow and once to the left. */
+
+#include <stdio.h>
+#include "pthread.h"
+#include "semaphore.h"
+
+#define BUFFER_SIZE 16
+
+/* Circular buffer of integers. */
+
+struct prodcons {
+  int buffer[BUFFER_SIZE];      /* the actual data */
+  int readpos, writepos;        /* positions for reading and writing */
+  sem_t sem_read;               /* number of elements available for reading */
+  sem_t sem_write;              /* number of locations available for writing */
+};
+
+/* Initialize a buffer */
+
+void init(struct prodcons * b)
+{
+  sem_init(&b->sem_write, 0, BUFFER_SIZE - 1);
+  sem_init(&b->sem_read, 0, 0);
+  b->readpos = 0;
+  b->writepos = 0;
+}
+
+/* Store an integer in the buffer */
+
+void put(struct prodcons * b, int data)
+{
+  /* Wait until buffer is not full */
+  sem_wait(&b->sem_write);
+  /* Write the data and advance write pointer */
+  b->buffer[b->writepos] = data;
+  b->writepos++;
+  if (b->writepos >= BUFFER_SIZE) b->writepos = 0;
+  /* Signal that the buffer contains one more element for reading */
+  sem_post(&b->sem_read);
+}
+
+/* Read and remove an integer from the buffer */
+
+int get(struct prodcons * b)
+{
+  int data;
+  /* Wait until buffer is not empty */
+  sem_wait(&b->sem_read);
+  /* Read the data and advance read pointer */
+  data = b->buffer[b->readpos];
+  b->readpos++;
+  if (b->readpos >= BUFFER_SIZE) b->readpos = 0;
+  /* Signal that the buffer has now one more location for writing */
+  sem_post(&b->sem_write);
+  return data;
+}
+
+/* A test program: one thread inserts integers from 1 to 10000,
+   the other reads them and prints them. */
+
+#define OVER (-1)
+
+struct prodcons buffer;
+
+static void *producer(void * data)
+{
+  int n;
+  for (n = 0; n < 10000; n++) {
+    printf("%d --->\n", n);
+    put(&buffer, n);
+  }
+  put(&buffer, OVER);
+  return NULL;
+}
+
+static void *consumer(void * data)
+{
+  int d;
+  while (1) {
+    d = get(&buffer);
+    if (d == OVER) break;
+    printf("---> %d\n", d);
+  }
+  return NULL;
+}
+
+int libc_ex5(void)
+{
+  pthread_t th_a, th_b;
+  void * retval;
+
+  init(&buffer);
+  /* Create the threads */
+  pthread_create(&th_a, NULL, producer, 0);
+  pthread_create(&th_b, NULL, consumer, 0);
+  /* Wait until producer and consumer finish. */
+  pthread_join(th_a, &retval);
+  pthread_join(th_b, &retval);
+  return 0;
+}
+#include <finsh.h>
+FINSH_FUNCTION_EXPORT(libc_ex5, example 5 for libc);
+
diff --git a/examples/libc/ex6.c b/examples/libc/ex6.c
new file mode 100644
index 0000000000000000000000000000000000000000..dea6ead8cb1fdb8cf822bd7d131b9df058bd52d9
--- /dev/null
+++ b/examples/libc/ex6.c
@@ -0,0 +1,37 @@
+#include <errno.h>
+#include <stdio.h>
+#include <string.h>
+#include <pthread.h>
+#include <unistd.h>
+
+#define usleep rt_thread_sleep
+
+static void *test_thread(void *v_param) {
+	return NULL;
+}
+
+int libc_ex6(void) {
+	unsigned long count;
+
+	setvbuf(stdout, NULL, _IONBF, 0);
+
+	for (count = 0; count < 2000; ++count) {
+		pthread_t thread;
+		int status;
+
+		status = pthread_create(&thread, NULL, test_thread, NULL);
+		if (status != 0) {
+			printf("status = %d, count = %lu: %s\n", status, count, strerror(
+					errno));
+			return 1;
+		} else {
+			printf("count = %lu\n", count);
+		}
+		/* pthread_detach (thread); */
+		pthread_join(thread, NULL);
+		usleep(10);
+	}
+	return 0;
+}
+#include <finsh.h>
+FINSH_FUNCTION_EXPORT(libc_ex6, example 6 for libc);
diff --git a/examples/libc/ex7.c b/examples/libc/ex7.c
new file mode 100644
index 0000000000000000000000000000000000000000..859d18e7bdb8fed0cebb4e0ba36c4d9410d41ceb
--- /dev/null
+++ b/examples/libc/ex7.c
@@ -0,0 +1,101 @@
+/* ex7
+ *
+ * Test case that illustrates a timed wait on a condition variable.
+ */
+
+#include <errno.h>
+#include <stdio.h>
+#include <string.h>
+#include <pthread.h>
+#include <sys/time.h>
+#include <unistd.h>
+
+#define usleep rt_thread_sleep
+
+/* Our event variable using a condition variable contruct. */
+typedef struct {
+	pthread_mutex_t mutex;
+	pthread_cond_t cond;
+	int flag;
+} event_t;
+
+/* Global event to signal main thread the timeout of the child thread. */
+event_t main_event;
+
+static void *test_thread(void *ms_param) {
+	int status = 0;
+	event_t foo;
+	struct timespec time;
+	struct timeval now;
+	long ms = (long) ms_param;
+
+	/* initialize cond var */
+	pthread_cond_init(&foo.cond, NULL);
+	pthread_mutex_init(&foo.mutex, NULL);
+	foo.flag = 0;
+
+	/* set the time out value */
+	printf("waiting %ld ms ...\n", ms);
+	gettimeofday(&now, NULL);
+	time.tv_sec = now.tv_sec + ms / 1000 + (now.tv_usec + (ms % 1000) * 1000)
+			/ 1000000;
+	time.tv_nsec = ((now.tv_usec + (ms % 1000) * 1000) % 1000000) * 1000;
+
+	/* Just use this to test the time out. The cond var is never signaled. */
+	pthread_mutex_lock(&foo.mutex);
+	while (foo.flag == 0 && status != ETIMEDOUT) {
+		status = pthread_cond_timedwait(&foo.cond, &foo.mutex, &time);
+	}
+	pthread_mutex_unlock(&foo.mutex);
+
+	/* post the main event */
+	pthread_mutex_lock(&main_event.mutex);
+	main_event.flag = 1;
+	pthread_cond_signal(&main_event.cond);
+	pthread_mutex_unlock(&main_event.mutex);
+
+	/* that's it, bye */
+	return (void*) status;
+}
+
+int libc_ex7(void) {
+	unsigned long count;
+
+	setvbuf(stdout, NULL, _IONBF, 0);
+
+	/* initialize main event cond var */
+	pthread_cond_init(&main_event.cond, NULL);
+	pthread_mutex_init(&main_event.mutex, NULL);
+	main_event.flag = 0;
+
+	for (count = 0; count < 20; ++count) {
+		pthread_t thread;
+		int status;
+
+		/* pass down the milli-second timeout in the void* param */
+		status = pthread_create(&thread, NULL, test_thread, (void*) (count
+				* 100));
+		if (status != 0) {
+			printf("status = %d, count = %lu: %s\n", status, count, strerror(
+					errno));
+			return 1;
+		} else {
+
+			/* wait for the event posted by the child thread */
+			pthread_mutex_lock(&main_event.mutex);
+			while (main_event.flag == 0) {
+				pthread_cond_wait(&main_event.cond, &main_event.mutex);
+			}
+			main_event.flag = 0;
+			pthread_mutex_unlock(&main_event.mutex);
+
+			printf("count = %lu\n", count);
+		}
+
+		usleep(10);
+	}
+
+	return 0;
+}
+#include <finsh.h>
+FINSH_FUNCTION_EXPORT(libc_ex7, example 7 for libc);
diff --git a/examples/libc/file.c b/examples/libc/file.c
new file mode 100644
index 0000000000000000000000000000000000000000..94aa206ce97633c57d90cf996317115d660d84b5
--- /dev/null
+++ b/examples/libc/file.c
@@ -0,0 +1,516 @@
+/*
+ * fstat.c
+ *
+ *  Created on: 2010-11-17
+ *      Author: bernard
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <finsh.h>
+#include <errno.h>
+#include <sys/fcntl.h>
+#include <sys/stat.h>
+
+const char* text = "this is a test string\n";
+void libc_fstat()
+{
+	int fd;
+	struct stat s;
+
+	fd = open("/tmp/tt.txt", O_WRONLY | O_CREAT, 0);
+	if (fd < 0)
+	{
+		printf("open failed\n");
+		return;
+	}
+
+	write(fd, text, strlen(text) + 1);
+	printf("begin: %d\n", lseek(fd, 0, SEEK_SET));
+	printf("end: %d\n", lseek(fd, 0, SEEK_END));
+
+	printf("fstat result: %d\n", fstat(fd, &s));
+	close(fd);
+}
+FINSH_FUNCTION_EXPORT(libc_fstat, fstat test for libc);
+
+void libc_lseek()
+{
+	int fd;
+
+	fd = open("/tmp/tt.txt", O_WRONLY | O_CREAT, 0);
+	if (fd < 0)
+	{
+		printf("open failed\n");
+		return;
+	}
+
+	write(fd, text, strlen(text) + 1);
+	printf("begin: %d\n", lseek(fd, 0, SEEK_SET));
+	printf("end: %d\n", lseek(fd, 0, SEEK_END));
+	close(fd);
+}
+FINSH_FUNCTION_EXPORT(libc_lseek, lseek test for libc);
+
+void sleep(int tick)
+{
+	rt_thread_sleep(tick);
+}
+
+int libc_fseek(void)
+{
+	const char *tmpdir;
+	char *fname;
+	int fd;
+	FILE *fp;
+	const char outstr[] = "hello world!\n";
+	char strbuf[sizeof outstr];
+	char buf[200];
+	struct stat st1;
+	struct stat st2;
+	int result = 0;
+
+	tmpdir = getenv("TMPDIR");
+	if (tmpdir == NULL || tmpdir[0] == '\0')
+		tmpdir = "/tmp";
+
+	asprintf(&fname, "%s/tst-fseek.XXXXXX", tmpdir);
+	if (fname == NULL)
+	{
+		fprintf(stderr, "cannot generate name for temporary file: %s\n",
+				strerror(errno));
+		return 1;
+	}
+
+	/* Create a temporary file.   */
+	fd = mkstemp(fname);
+	if (fd == -1)
+	{
+		fprintf(stderr, "cannot open temporary file: %s\n", strerror(errno));
+		return 1;
+	}
+
+	fp = fdopen(fd, "w+");
+	if (fp == NULL)
+	{
+		fprintf(stderr, "cannot get FILE for temporary file: %s\n", strerror(
+				errno));
+		return 1;
+	}
+	setbuffer(fp, strbuf, sizeof(outstr) - 1);
+
+	if (fwrite(outstr, sizeof(outstr) - 1, 1, fp) != 1)
+	{
+		printf("%d: write error\n", __LINE__);
+		result = 1;
+		goto out;
+	}
+
+	/* The EOF flag must be reset.  */
+	if (fgetc(fp) != EOF)
+	{
+		printf("%d: managed to read at end of file\n", __LINE__);
+		result = 1;
+	}
+	else if (!feof(fp))
+	{
+		printf("%d: EOF flag not set\n", __LINE__);
+		result = 1;
+	}
+	if (fseek(fp, 0, SEEK_CUR) != 0)
+	{
+		printf("%d: fseek(fp, 0, SEEK_CUR) failed\n", __LINE__);
+		result = 1;
+	}
+	else if (feof(fp))
+	{
+		printf("%d: fseek() didn't reset EOF flag\n", __LINE__);
+		result = 1;
+	}
+
+	/* Do the same for fseeko().  */
+	if (fgetc(fp) != EOF)
+	{
+		printf("%d: managed to read at end of file\n", __LINE__);
+		result = 1;
+	}
+	else if (!feof(fp))
+	{
+		printf("%d: EOF flag not set\n", __LINE__);
+		result = 1;
+	}
+	if (fseeko(fp, 0, SEEK_CUR) != 0)
+	{
+		printf("%d: fseek(fp, 0, SEEK_CUR) failed\n", __LINE__);
+		result = 1;
+	}
+	else if (feof(fp))
+	{
+		printf("%d: fseek() didn't reset EOF flag\n", __LINE__);
+		result = 1;
+	}
+
+	/* Go back to the beginning of the file: absolute.  */
+	if (fseek(fp, 0, SEEK_SET) != 0)
+	{
+		printf("%d: fseek(fp, 0, SEEK_SET) failed\n", __LINE__);
+		result = 1;
+	}
+	else if (fflush(fp) != 0)
+	{
+		printf("%d: fflush() failed\n", __LINE__);
+		result = 1;
+	}
+	else if (lseek(fd, 0, SEEK_CUR) != 0)
+	{
+		int pos = lseek(fd, 0, SEEK_CUR);
+		printf("%d: lseek() returned different position, pos %d\n", __LINE__,
+				pos);
+		result = 1;
+	}
+	else if (fread(buf, sizeof(outstr) - 1, 1, fp) != 1)
+	{
+		printf("%d: fread() failed\n", __LINE__);
+		result = 1;
+	}
+	else if (memcmp(buf, outstr, sizeof(outstr) - 1) != 0)
+	{
+		printf("%d: content after fseek(,,SEEK_SET) wrong\n", __LINE__);
+		result = 1;
+	}
+
+	/* Now with fseeko.  */
+	if (fseeko(fp, 0, SEEK_SET) != 0)
+	{
+		printf("%d: fseeko(fp, 0, SEEK_SET) failed\n", __LINE__);
+		result = 1;
+	}
+	else if (fflush(fp) != 0)
+	{
+		printf("%d: fflush() failed\n", __LINE__);
+		result = 1;
+	}
+	else if (lseek(fd, 0, SEEK_CUR) != 0)
+	{
+		printf("%d: lseek() returned different position\n", __LINE__);
+		result = 1;
+	}
+	else if (fread(buf, sizeof(outstr) - 1, 1, fp) != 1)
+	{
+		printf("%d: fread() failed\n", __LINE__);
+		result = 1;
+	}
+	else if (memcmp(buf, outstr, sizeof(outstr) - 1) != 0)
+	{
+		printf("%d: content after fseeko(,,SEEK_SET) wrong\n", __LINE__);
+		result = 1;
+	}
+
+	/* Go back to the beginning of the file: relative.  */
+	if (fseek(fp, -((int) sizeof(outstr) - 1), SEEK_CUR) != 0)
+	{
+		printf("%d: fseek(fp, 0, SEEK_SET) failed\n", __LINE__);
+		result = 1;
+	}
+	else if (fflush(fp) != 0)
+	{
+		printf("%d: fflush() failed\n", __LINE__);
+		result = 1;
+	}
+	else if (lseek(fd, 0, SEEK_CUR) != 0)
+	{
+		printf("%d: lseek() returned different position\n", __LINE__);
+		result = 1;
+	}
+	else if (fread(buf, sizeof(outstr) - 1, 1, fp) != 1)
+	{
+		printf("%d: fread() failed\n", __LINE__);
+		result = 1;
+	}
+	else if (memcmp(buf, outstr, sizeof(outstr) - 1) != 0)
+	{
+		printf("%d: content after fseek(,,SEEK_SET) wrong\n", __LINE__);
+		result = 1;
+	}
+
+	/* Now with fseeko.  */
+	if (fseeko(fp, -((int) sizeof(outstr) - 1), SEEK_CUR) != 0)
+	{
+		printf("%d: fseeko(fp, 0, SEEK_SET) failed\n", __LINE__);
+		result = 1;
+	}
+	else if (fflush(fp) != 0)
+	{
+		printf("%d: fflush() failed\n", __LINE__);
+		result = 1;
+	}
+	else if (lseek(fd, 0, SEEK_CUR) != 0)
+	{
+		printf("%d: lseek() returned different position\n", __LINE__);
+		result = 1;
+	}
+	else if (fread(buf, sizeof(outstr) - 1, 1, fp) != 1)
+	{
+		printf("%d: fread() failed\n", __LINE__);
+		result = 1;
+	}
+	else if (memcmp(buf, outstr, sizeof(outstr) - 1) != 0)
+	{
+		printf("%d: content after fseeko(,,SEEK_SET) wrong\n", __LINE__);
+		result = 1;
+	}
+
+	/* Go back to the beginning of the file: from the end.  */
+	if (fseek(fp, -((int) sizeof(outstr) - 1), SEEK_END) != 0)
+	{
+		printf("%d: fseek(fp, 0, SEEK_SET) failed\n", __LINE__);
+		result = 1;
+	}
+	else if (fflush(fp) != 0)
+	{
+		printf("%d: fflush() failed\n", __LINE__);
+		result = 1;
+	}
+	else if (lseek(fd, 0, SEEK_CUR) != 0)
+	{
+		printf("%d: lseek() returned different position\n", __LINE__);
+		result = 1;
+	}
+	else if (fread(buf, sizeof(outstr) - 1, 1, fp) != 1)
+	{
+		printf("%d: fread() failed\n", __LINE__);
+		result = 1;
+	}
+	else if (memcmp(buf, outstr, sizeof(outstr) - 1) != 0)
+	{
+		printf("%d: content after fseek(,,SEEK_SET) wrong\n", __LINE__);
+		result = 1;
+	}
+
+	/* Now with fseeko.  */
+	if (fseeko(fp, -((int) sizeof(outstr) - 1), SEEK_END) != 0)
+	{
+		printf("%d: fseeko(fp, 0, SEEK_SET) failed\n", __LINE__);
+		result = 1;
+	}
+	else if (fflush(fp) != 0)
+	{
+		printf("%d: fflush() failed\n", __LINE__);
+		result = 1;
+	}
+	else if (lseek(fd, 0, SEEK_CUR) != 0)
+	{
+		printf("%d: lseek() returned different position\n", __LINE__);
+		result = 1;
+	}
+	else if (fread(buf, sizeof(outstr) - 1, 1, fp) != 1)
+	{
+		printf("%d: fread() failed\n", __LINE__);
+		result = 1;
+	}
+	else if (memcmp(buf, outstr, sizeof(outstr) - 1) != 0)
+	{
+		printf("%d: content after fseeko(,,SEEK_SET) wrong\n", __LINE__);
+		result = 1;
+	}
+
+	if (fwrite(outstr, sizeof(outstr) - 1, 1, fp) != 1)
+	{
+		printf("%d: write error 2\n", __LINE__);
+		result = 1;
+		goto out;
+	}
+
+	if (fwrite(outstr, sizeof(outstr) - 1, 1, fp) != 1)
+	{
+		printf("%d: write error 3\n", __LINE__);
+		result = 1;
+		goto out;
+	}
+
+	if (fwrite(outstr, sizeof(outstr) - 1, 1, fp) != 1)
+	{
+		printf("%d: write error 4\n", __LINE__);
+		result = 1;
+		goto out;
+	}
+
+	if (fwrite(outstr, sizeof(outstr) - 1, 1, fp) != 1)
+	{
+		printf("%d: write error 5\n", __LINE__);
+		result = 1;
+		goto out;
+	}
+
+	if (fputc('1', fp) == EOF || fputc('2', fp) == EOF)
+	{
+		printf("%d: cannot add characters at the end\n", __LINE__);
+		result = 1;
+		goto out;
+	}
+
+	/* Check the access time.  */
+	if (fstat(fd, &st1) < 0)
+	{
+		printf("%d: fstat64() before fseeko() failed\n\n", __LINE__);
+		result = 1;
+	}
+	else
+	{
+		sleep(1);
+
+		if (fseek(fp, -(2 + 2 * (sizeof(outstr) - 1)), SEEK_CUR) != 0)
+		{
+			printf("%d: fseek() after write characters failed\n", __LINE__);
+			result = 1;
+			goto out;
+		}
+		else
+		{
+
+			time_t t;
+			/* Make sure the timestamp actually can be different.  */
+			sleep(1);
+			t = time(NULL);
+
+			if (fstat(fd, &st2) < 0)
+			{
+				printf("%d: fstat64() after fseeko() failed\n\n", __LINE__);
+				result = 1;
+			}
+			if (st1.st_ctime >= t)
+			{
+				printf("%d: st_ctime not updated\n", __LINE__);
+				result = 1;
+			}
+			if (st1.st_mtime >= t)
+			{
+				printf("%d: st_mtime not updated\n", __LINE__);
+				result = 1;
+			}
+			if (st1.st_ctime >= st2.st_ctime)
+			{
+				printf("%d: st_ctime not changed\n", __LINE__);
+				result = 1;
+			}
+			if (st1.st_mtime >= st2.st_mtime)
+			{
+				printf("%d: st_mtime not changed\n", __LINE__);
+				result = 1;
+			}
+		}
+	}
+
+	if (fread(buf, 1, 2 + 2 * (sizeof(outstr) - 1), fp) != 2 + 2
+			* (sizeof(outstr) - 1))
+	{
+		printf("%d: reading 2 records plus bits failed\n", __LINE__);
+		result = 1;
+	}
+	else if (memcmp(buf, outstr, sizeof(outstr) - 1) != 0 || memcmp(
+			&buf[sizeof(outstr) - 1], outstr, sizeof(outstr) - 1) != 0 || buf[2
+			* (sizeof(outstr) - 1)] != '1' || buf[2 * (sizeof(outstr) - 1) + 1]
+			!= '2')
+	{
+		printf("%d: reading records failed\n", __LINE__);
+		result = 1;
+	}
+	else if (ungetc('9', fp) == EOF)
+	{
+		printf("%d: ungetc() failed\n", __LINE__);
+		result = 1;
+	}
+	else if (fseek(fp, -(2 + 2 * (sizeof(outstr) - 1)), SEEK_END) != 0)
+	{
+		printf("%d: fseek after ungetc failed\n", __LINE__);
+		result = 1;
+	}
+	else if (fread(buf, 1, 2 + 2 * (sizeof(outstr) - 1), fp) != 2 + 2
+			* (sizeof(outstr) - 1))
+	{
+		printf("%d: reading 2 records plus bits failed\n", __LINE__);
+		result = 1;
+	}
+	else if (memcmp(buf, outstr, sizeof(outstr) - 1) != 0 || memcmp(
+			&buf[sizeof(outstr) - 1], outstr, sizeof(outstr) - 1) != 0 || buf[2
+			* (sizeof(outstr) - 1)] != '1')
+	{
+		printf("%d: reading records for the second time failed\n", __LINE__);
+		result = 1;
+	}
+	else if (buf[2 * (sizeof(outstr) - 1) + 1] == '9')
+	{
+		printf("%d: unget character not ignored\n", __LINE__);
+		result = 1;
+	}
+	else if (buf[2 * (sizeof(outstr) - 1) + 1] != '2')
+	{
+		printf("%d: unget somehow changed character\n", __LINE__);
+		result = 1;
+	}
+
+	fclose(fp);
+
+	fp = fopen(fname, "r");
+	if (fp == NULL)
+	{
+		printf("%d: fopen() failed\n\n", __LINE__);
+		result = 1;
+	}
+	else if (fstat(fileno(fp), &st1) < 0)
+	{
+		printf("%d: fstat64() before fseeko() failed\n\n", __LINE__);
+		result = 1;
+	}
+	else if (fseeko(fp, 0, SEEK_END) != 0)
+	{
+		printf("%d: fseeko(fp, 0, SEEK_END) failed\n", __LINE__);
+		result = 1;
+	}
+	else if (ftello(fp) != st1.st_size)
+	{
+		printf("%d: fstat64 st_size %zd ftello %zd\n", __LINE__,
+				(size_t) st1.st_size, (size_t) ftello(fp));
+		result = 1;
+	}
+	else
+		printf("%d: SEEK_END works\n", __LINE__);
+	if (fp != NULL)
+		fclose(fp);
+
+	fp = fopen(fname, "r");
+	if (fp == NULL)
+	{
+		printf("%d: fopen() failed\n\n", __LINE__);
+		result = 1;
+	}
+	else if (fstat(fileno(fp), &st1) < 0)
+	{
+		printf("%d: fstat64() before fgetc() failed\n\n", __LINE__);
+		result = 1;
+	}
+	else if (fgetc(fp) == EOF)
+	{
+		printf("%d: fgetc() before fseeko() failed\n\n", __LINE__);
+		result = 1;
+	}
+	else if (fseeko(fp, 0, SEEK_END) != 0)
+	{
+		printf("%d: fseeko(fp, 0, SEEK_END) failed\n", __LINE__);
+		result = 1;
+	}
+	else if (ftello(fp) != st1.st_size)
+	{
+		printf("%d: fstat64 st_size %zd ftello %zd\n", __LINE__,
+				(size_t) st1.st_size, (size_t) ftello(fp));
+		result = 1;
+	}
+	else
+		printf("%d: SEEK_END works\n", __LINE__);
+	if (fp != NULL)
+		fclose(fp);
+
+	out: unlink(fname);
+
+	return result;
+}
+FINSH_FUNCTION_EXPORT(libc_fseek, lseek test for libc);
diff --git a/examples/libc/memory.c b/examples/libc/memory.c
new file mode 100644
index 0000000000000000000000000000000000000000..0a0bfecd8039d986638364224e56d556e896d917
--- /dev/null
+++ b/examples/libc/memory.c
@@ -0,0 +1,54 @@
+/*
+ * memory.c
+ *
+ *  Created on: 2010-11-17
+ *      Author: bernard
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <finsh.h>
+#include <errno.h>
+
+static int errors = 0;
+static void merror(const char *msg)
+{
+	++errors;
+	printf("Error: %s\n", msg);
+}
+
+int libc_mem(void)
+{
+	void *p;
+	int save;
+
+	errno = 0;
+
+	p = malloc(-1);
+	save = errno;
+
+	if (p != NULL)
+		merror("malloc (-1) succeeded.");
+
+	if (p == NULL && save != ENOMEM)
+		merror("errno is not set correctly");
+
+	p = malloc(10);
+	if (p == NULL)
+		merror("malloc (10) failed.");
+
+	/* realloc (p, 0) == free (p).  */
+	p = realloc(p, 0);
+	if (p != NULL)
+		merror("realloc (p, 0) failed.");
+
+	p = malloc(0);
+	if (p == NULL)
+		merror("malloc (0) failed.");
+
+	p = realloc(p, 0);
+	if (p != NULL)
+		merror("realloc (p, 0) failed.");
+
+	return errors != 0;
+}
+FINSH_FUNCTION_EXPORT(libc_mem, memory test for libc);
diff --git a/examples/libc/printf.c b/examples/libc/printf.c
new file mode 100644
index 0000000000000000000000000000000000000000..12435731b70a31bf6d13f87826b8559a99e48ef2
--- /dev/null
+++ b/examples/libc/printf.c
@@ -0,0 +1,200 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/fcntl.h>
+
+#include <finsh.h>
+
+char * format[] = {
+  "%",
+  "%0.",
+  "%.0",
+  "%+0.",
+  "%+.0",
+  "%.5",
+  "%+.5",
+  "%2.5",
+  "%22.5",
+  "%022.5",
+  "%#022.5",
+  "%-#022.5",
+  "%+#022.5",
+  "%-22.5",
+  "%+22.5",
+  "%--22.5",
+  "%++22.5",
+  "%+-22.5",
+  "%-+22.5",
+  "%-#022.5",
+  "%-#22.5",
+  "%-2.22",
+  "%+2.22",
+  "%-#02.22",
+  "%-#2.22",
+  "%-1.5",
+  "%1.5",
+  "%-#01.5",
+  "%-#1.5",
+  "%-#.5",
+  "%-#1.",
+  "%-#.",
+  NULL
+};
+
+
+static void
+intchk (const char *fmt)
+{
+  (void) printf("%15s :, \"", fmt);
+  (void) printf(fmt, 0);
+  (void) printf("\", \"");
+  (void) printf(fmt, 123);
+  (void) printf("\", \"");
+  (void) printf(fmt, -18);
+  (void) printf("\"\n");
+}
+
+static void
+fltchk (const char *fmt)
+{
+  (void) printf("%15s :, \"", fmt);
+  (void) printf(fmt, 0.0);
+  (void) printf("\", \"");
+  (void) printf(fmt, 123.0001);
+  (void) printf("\", \"");
+  (void) printf(fmt, -18.0002301);
+  (void) printf("\"\n");
+}
+
+
+int printf_test()
+{
+  char buf[256];
+  int i;
+
+  printf("%s\n\n", "# vim:syntax=off:");
+
+  /* integers */
+  for(i=0;format[i];i++) {
+    strcpy(buf, format[i]);
+    strcat(buf, "d");
+    intchk(buf);
+  }
+
+  /* floats */
+  for(i=0;format[i];i++) {
+    strcpy(buf, format[i]);
+    strcat(buf, "f");
+    fltchk(buf);
+  }
+  /* hexa */
+  for(i=0;format[i];i++) {
+    strcpy(buf, format[i]);
+    strcat(buf, "x");
+    intchk(buf);
+  }
+
+  printf("#%.4x %4x#\n", 4, 88);
+  printf("#%4x#\n",4);
+  printf("#%#22.8x#\n",1234567);
+
+  printf("#%+2i#\n",18);
+  printf("#%i#\n",18);
+  printf("#%llu#\n",4294967297ULL);
+  printf("#%#x#\n",44444);
+  printf("#%-8i#\n",33);
+  printf("#%i#\n",18);
+  printf("#%d#\n",18);
+  printf("#%u#\n",18);
+  printf("#%lu#\n",18);
+  printf("#%li#\n",18);
+  printf("#%-+#06d#\n", -123);
+  printf("#%-+#6d#\n", -123);
+  printf("#%+#06d#\n", -123);
+  printf("#%06d#\n", -123);
+  printf("#%+15s#\n","ABCDEF");
+  /* from ncurses make_keys */
+  printf("{ %4d, %-*.*s },\t/* %s */\n", 139, 16, 16, "KEY_A1", "key_a1");
+  printf("{ %4d, %-*.*s },\t/* %s */\n", 139, 16,  2, "KEY_A1", "key_a1");
+  printf("{ %4d, %-*.*s },\t/* %s */\n", 139,  2, 16, "KEY_A1", "key_a1");
+  printf("{ %4d, %-*.*s },\t/* %s */\n", 139, 16,  0, "KEY_A1", "key_a1");
+  printf("{ %4d, %-*.*s },\t/* %s */\n", 139,  0, 16, "KEY_A1", "key_a1");
+  printf("{ %4d, %-*.*s },\t/* %s */\n", 139,  0,  0, "KEY_A1", "key_a1");
+  printf("{ %4d, %*.*s },\t/* %s */\n", 139, 16, 16, "KEY_A1", "key_a1");
+  printf("{ %4d, %*.*s },\t/* %s */\n", 139, 16,  2, "KEY_A1", "key_a1");
+  printf("{ %4d, %*.*s },\t/* %s */\n", 139,  2, 16, "KEY_A1", "key_a1");
+  printf("{ %4d, %*.*s },\t/* %s */\n", 139, 16,  0, "KEY_A1", "key_a1");
+  printf("{ %4d, %*.*s },\t/* %s */\n", 139,  0, 16, "KEY_A1", "key_a1");
+  printf("{ %4d, %*.*s },\t/* %s */\n", 139,  0,  0, "KEY_A1", "key_a1");
+  printf("%*.*f\n",  0, 16, 0.0);
+  printf("%*.*f\n", 16, 16, 0.0);
+  printf("%*.*f\n",  2, 2,  -0.0);
+  printf("%*.*f\n", 20, 0,  -123.123);
+  printf("%*.*f\n", 10, 0,  +123.123);
+
+
+  i = printf("\"%s\"\n","A");
+  printf("%i\n", i);
+  /* from glibc's tst-printf.c */
+
+  {
+    char buf[20];
+    char buf2[512];
+    int i;
+
+    printf ("snprintf (\"%%30s\", \"foo\") == %d, \"%.*s\"\n",
+	    snprintf (buf, sizeof (buf), "%30s", "foo"), (int) sizeof (buf),
+	    buf);
+    memset(buf2,0,sizeof(buf));
+    i=snprintf(buf2, 256, "%.9999u", 10);
+    printf("%i %i\n",i,strlen(buf2));
+
+    printf ("snprintf (\"%%.999999u\", 10) == %d\n",
+    	    snprintf(buf2, sizeof(buf2), "%.999999u", 10));
+  }
+  return 0;
+}
+
+void libc_printf()
+{
+	printf("stdout test!!\n");
+	fprintf(stdout, "fprintf test!!\n");
+	fprintf(stderr, "fprintf test!!\n");
+	puts("puts test!!\n");
+
+	putc('1', stderr);
+	putc('2', stderr);
+	putc('\n', stderr);
+
+	printf_test();
+}
+FINSH_FUNCTION_EXPORT(libc_printf, printf test in libc);
+
+
+void libc_dprintf()
+{
+	int fd;
+
+	fd = open("/dev/console", O_WRONLY, 0);
+	if (fd >0)
+	{
+		dprintf(fd, "fd:%d printf test!!\n", fd);
+		close(fd);
+	}
+}
+FINSH_FUNCTION_EXPORT(libc_dprintf, dprintf test);
+
+
+void libc_fdopen()
+{
+	int fd;
+	FILE* fp;
+
+	fd = open("/dev/console", O_WRONLY, 0);
+	if (fd >0)
+	{
+		fp = fdopen(fd, "w");
+		fprintf(fp, "fdopen test, fd %d!!\n", fileno(fp));
+		fclose(fp);
+	}
+}
+FINSH_FUNCTION_EXPORT(libc_fdopen, fdopen test);
diff --git a/examples/libc/rand.c b/examples/libc/rand.c
new file mode 100644
index 0000000000000000000000000000000000000000..ca74353adcb8f121d4ccb65547a6efb6b8dccdae
--- /dev/null
+++ b/examples/libc/rand.c
@@ -0,0 +1,43 @@
+/*
+ * rand.c
+ *
+ *  Created on: 2010-11-17
+ *      Author: bernard
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <finsh.h>
+
+int libc_rand(void)
+{
+	int i1, i2;
+	int j1, j2;
+
+	/* The C standard says that "If rand is called before any calls to
+	 srand have been made, the same sequence shall be generated as
+	 when srand is first called with a seed value of 1." */
+	i1 = rand();
+	i2 = rand();
+	srand(1);
+	j1 = rand();
+	j2 = rand();
+	if (i1 < 0 || i2 < 0 || j1 < 0 || j2 < 0)
+	{
+		puts("Test FAILED!");
+	}
+	if (j1 == i1 && j2 == i2)
+	{
+		puts("Test succeeded.");
+		return 0;
+	}
+	else
+	{
+		if (j1 != i1)
+			printf("%d != %d\n", j1, i1);
+		if (j2 != i2)
+			printf("%d != %d\n", j2, i2);
+		puts("Test FAILED!");
+		return 1;
+	}
+}
+FINSH_FUNCTION_EXPORT(libc_rand, rand test for libc);
diff --git a/examples/libc/time.c b/examples/libc/time.c
new file mode 100644
index 0000000000000000000000000000000000000000..cbe5773ec0127ebf9578e834eb4ffe72fcc7e77a
--- /dev/null
+++ b/examples/libc/time.c
@@ -0,0 +1,24 @@
+/*
+ * time.c
+ *
+ *  Created on: 2010-11-17
+ *      Author: bernard
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <finsh.h>
+
+int speed()
+{
+	int i;
+	time_t t;
+
+	printf("%d\n", time(0));
+	for (i = 0; i < 10000000; ++i)
+		t = time(0);
+
+	printf("%d\n", time(0));
+	return 0;
+}
+FINSH_FUNCTION_EXPORT(speed, speed test);