Renamed nuttapp to namedapp; add binfs to nammedapp/

git-svn-id: svn://svn.code.sf.net/p/nuttx/code/trunk@3429 42af7a65-404d-4744-a932-0658087f49c3

11 files changed, 834 insertions, 77 deletions

diff --git a/apps/ChangeLog.txt b/apps/ChangeLog.txt
index a6375554c..e0f8a3989 100755
--- a/apps/ChangeLog.txt
+++ b/apps/ChangeLog.txt
@@ -20,3 +20,7 @@
 	* Creation of auto-generated header files now occurs during the context
 	  build phase.
 	* Added sdcard insert and eject, nsh command '?' and some code remarks
+	* Renamed nuttapp to namedapp
+	* namedapp/binfs.c -- Create a tiny filesystem that can be used
+	  to show the internal named apps under /bin.
+
diff --git a/apps/Make.defs b/apps/Make.defs
index f459264c8..e8c1d0d6c 100755
--- a/apps/Make.defs
+++ b/apps/Make.defs
@@ -36,6 +36,6 @@
 
 define REGISTER
 	@echo "Register: $1"
-	@echo "{ .name = \"$1\", .priority = $2, .stacksize = $3, .main = $4 }," >> "$(APPDIR)/nuttapp/exec_nuttapp_list.h"
-	@echo "EXTERN int $4(int argc, char *argv[]);" >> "$(APPDIR)/nuttapp/exec_nuttapp_proto.h"
+	@echo "{ .name = \"$1\", .priority = $2, .stacksize = $3, .main = $4 }," >> "$(APPDIR)/namedapp/namedapp_list.h"
+	@echo "EXTERN int $4(int argc, char *argv[]);" >> "$(APPDIR)/namedapp/namedapp_proto.h"
 endef
diff --git a/apps/Makefile b/apps/Makefile
index 2735759c9..e4e51caa8 100644
--- a/apps/Makefile
+++ b/apps/Makefile
@@ -41,16 +41,16 @@ APPDIR = ${shell pwd}
 # Application Directories
 
 # SUBDIRS is the list of all directories containing Makefiles.  It is used
-# only for cleaning. nuttapp must always be the first in the list.
+# only for cleaning. namedapp must always be the first in the list.
 
-SUBDIRS = nuttapp nshlib netutils examples vsn
+SUBDIRS = namedapp nshlib netutils examples vsn
 
 # We use a non-existing .built_always to guarantee that Makefile always walks
-# into the sub-directories and asks for build.  NOTE that nuttapp is always
+# into the sub-directories and asks for build.  NOTE that namedapp is always
 # in the list of applications to be built
 
-BUILTIN_APPS_BUILT = nuttapp/.built_always
-BUILTIN_APPS_DIR = nuttapp
+BUILTIN_APPS_BUILT = namedapp/.built_always
+BUILTIN_APPS_DIR = namedapp
 
 # CONFIGURED_APPS is the list of all configured built-in directories/built action
 # It is created by the configured appconfig file (a copy of which appears in this
diff --git a/apps/README.txt b/apps/README.txt
index 7185d1371..e824c8a2a 100644
--- a/apps/README.txt
+++ b/apps/README.txt
@@ -6,8 +6,8 @@ This folder provides various applications found in sub-directories.
 Application entry points with their requirements are gathered together in 
 in two files:
 
-	- exec_nuttapp_proto.h	Entry points, prototype function
-	- exec_nuttapp_list.h	Application specific information and requirements
+	- namedapp/namedapp_proto.h	Entry points, prototype function
+	- namedapp/namedapp_list.h	Application specific information and requirements
 
 The build occurs in several phases as different build targets are executed:
 (1) contex, (2) depend, and (3) default (all). Application information is
@@ -15,7 +15,7 @@ collected during the make context build phase.
 
 To execute an application function:
 
-	exec_nuttapp() is defined in the nuttx/include/apps/apps.h 
+	exec_namedapp() is defined in the nuttx/include/apps/apps.h 
 	
 NuttShell provides transparent method of invoking the command, when the
 following option is enabled:
diff --git a/apps/nuttapp/Makefile b/apps/namedapp/Makefile
index 9cdb4ff5d..6b3610e18 100644
--- a/apps/nuttapp/Makefile
+++ b/apps/namedapp/Makefile
@@ -42,7 +42,11 @@ include $(APPDIR)/Make.defs
 # Source and object files
 
 ASRCS		=
-CSRCS		= exec_nuttapp.c
+CSRCS		= namedapp.c exec_namedapp.c
+
+ifeq ($(CONFIG_APPS_BINDIR),y)
+CSRCS		+= binfs.c
+endif
 
 AOBJS		= $(ASRCS:.S=$(OBJEXT))
 COBJS		= $(CSRCS:.c=$(OBJEXT))
@@ -75,8 +79,8 @@ $(BIN):	$(OBJS)
 .built: $(BIN)
 
 .context:
-	@echo "/* List of application requirements, generated during make context. */" > exec_nuttapp_list.h
-	@echo "/* List of application entry points, generated during make context. */" > exec_nuttapp_proto.h
+	@echo "/* List of application requirements, generated during make context. */" > namedapp_list.h
+	@echo "/* List of application entry points, generated during make context. */" > namedapp_proto.h
 	@touch $@
 
 context: .context
@@ -93,8 +97,8 @@ clean:
 
 distclean: clean
 	@rm -f .context Make.dep .depend
-	@rm -f exec_nuttapp_list.h
-	@rm -f exec_nuttapp_proto.h
+	@rm -f namedapp_list.h
+	@rm -f namedapp_proto.h
 
 -include Make.dep
 
diff --git a/apps/namedapp/binfs.c b/apps/namedapp/binfs.c
new file mode 100644
index 000000000..9d2e4a7ee
--- /dev/null
+++ b/apps/namedapp/binfs.c
@@ -0,0 +1,601 @@
+/****************************************************************************
+ * apps/namedapps/binfs.c
+ *
+ *   Copyright (C) 2011 Gregory Nutt. All rights reserved.
+ *   Author: Gregory Nutt <spudmonkey@racsa.co.cr>
+ *
+ * References: Linux/Documentation/filesystems/romfs.txt
+ *
+ * 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. Neither the name NuttX 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 COPYRIGHT HOLDERS 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
+ * COPYRIGHT OWNER 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.
+ *
+ ****************************************************************************/
+
+/****************************************************************************
+ * Included Files
+ ****************************************************************************/
+
+#include <nuttx/config.h>
+
+#include <sys/types.h>
+#include <sys/statfs.h>
+#include <sys/stat.h>
+
+#include <stdint.h>
+#include <stdbool.h>
+#include <stdlib.h>
+#include <string.h>
+#include <fcntl.h>
+#include <assert.h>
+#include <errno.h>
+#include <debug.h>
+
+#include <nuttx/fs.h>
+#include <nuttx/dirent.h>
+
+#include "namedapp.h"
+
+#if !defined(CONFIG_DISABLE_MOUNTPOINT) && defined(CONFIG_APPS_BINDIR)
+
+/****************************************************************************
+ * Private Types
+ ****************************************************************************/
+
+/* This structure represents the overall mountpoint state.  An instance of this
+ * structure is retained as inode private data on each mountpoint that is
+ * mounted with a fat32 filesystem.
+ */
+
+struct binfs_state_s
+{
+  sem_t    bm_sem;                  /* Used to assume thread-safe access */
+};
+
+/****************************************************************************
+ * Private Function Prototypes
+ ****************************************************************************/
+
+static void    binfs_semtake(struct binfs_state_s *bm);
+static inline void binfs_semgive(struct binfs_state_s *bm);
+static int     binfs_open(FAR struct file *filep, const char *relpath,
+                        int oflags, mode_t mode);
+static int     binfs_close(FAR struct file *filep);
+static ssize_t binfs_read(FAR struct file *filep, char *buffer, size_t buflen);
+static int     binfs_ioctl(FAR struct file *filep, int cmd, unsigned long arg);
+
+static int     binfs_opendir(struct inode *mountpt, const char *relpath,
+                             struct fs_dirent_s *dir);
+static int     binfs_readdir(struct inode *mountpt, struct fs_dirent_s *dir);
+static int     binfs_rewinddir(struct inode *mountpt, struct fs_dirent_s *dir);
+
+static int     binfs_bind(FAR struct inode *blkdriver, const void *data,
+                        void **handle);
+static int     binfs_unbind(void *handle, FAR struct inode **blkdriver);
+static int     binfs_statfs(struct inode *mountpt, struct statfs *buf);
+
+static int     binfs_stat(struct inode *mountpt, const char *relpath, struct stat *buf);
+
+/****************************************************************************
+ * Private Variables
+ ****************************************************************************/
+
+/****************************************************************************
+ * Public Variables
+ ****************************************************************************/
+
+/* See fs_mount.c -- this structure is explicitly externed there.
+ * We use the old-fashioned kind of initializers so that this will compile
+ * with any compiler.
+ */
+
+const struct mountpt_operations binfs_operations =
+{
+  binfs_open,        /* open */
+  binfs_close,       /* close */
+  binfs_read,        /* read */
+  NULL,              /* write */
+  NULL,              /* seek */
+  binfs_ioctl,       /* ioctl */
+  NULL,              /* sync */
+
+  binfs_opendir,     /* opendir */
+  NULL,              /* closedir */
+  binfs_readdir,     /* readdir */
+  binfs_rewinddir,   /* rewinddir */
+
+  binfs_bind,        /* bind */
+  binfs_unbind,      /* unbind */
+  binfs_statfs,      /* statfs */
+
+  NULL,              /* unlink */
+  NULL,              /* mkdir */
+  NULL,              /* rmdir */
+  NULL,              /* rename */
+  binfs_stat         /* stat */
+};
+
+/****************************************************************************
+ * Private Functions
+ ****************************************************************************/
+
+/****************************************************************************
+ * Name: binfs_semtake
+ ****************************************************************************/
+
+static void binfs_semtake(struct binfs_state_s *bm)
+{
+  /* Take the semaphore (perhaps waiting) */
+
+  while (sem_wait(&bm->bm_sem) != 0)
+    {
+      /* The only case that an error should occur here is if
+       * the wait was awakened by a signal.
+       */
+
+      ASSERT(*get_errno_ptr() == EINTR);
+    }
+}
+
+/****************************************************************************
+ * Name: binfs_semgive
+ ****************************************************************************/
+
+static inline void binfs_semgive(struct binfs_state_s *bm)
+{
+   sem_post(&bm->bm_sem);
+}
+
+/****************************************************************************
+ * Name: binfs_open
+ ****************************************************************************/
+
+static int binfs_open(FAR struct file *filep, const char *relpath,
+                    int oflags, mode_t mode)
+{
+  struct binfs_state_s *bm;
+  int                   ret = -ENOSYS;
+
+  fvdbg("Open '%s'\n", relpath);
+
+  /* Sanity checks */
+
+  DEBUGASSERT(filep->f_priv == NULL && filep->f_inode != NULL);
+
+  /* mountpoint private data from the inode reference from the file
+   * structure
+   */
+
+  bm = (struct binfs_state_s*)filep->f_inode->i_private;
+  DEBUGASSERT(bm != NULL);
+
+  /* BINFS is read-only.  Any attempt to open with any kind of write
+   * access is not permitted.
+   */
+
+  if ((oflags & O_WRONLY) != 0 || (oflags & O_RDONLY) == 0)
+    {
+      fdbg("Only O_RDONLY supported\n");
+      ret = -EACCES;
+    }
+
+  /* Save open-specific state in filep->f_priv */
+
+  /* Opening of elements within the pseudo-file system is not yet supported */
+
+  return ret;
+}
+
+/****************************************************************************
+ * Name: binfs_close
+ ****************************************************************************/
+
+static int binfs_close(FAR struct file *filep)
+{
+  struct binfs_state_s *bm;
+  int                   ret = -ENOSYS;
+
+  fvdbg("Closing\n");
+
+  /* Sanity checks */
+
+  DEBUGASSERT(filep->f_priv != NULL && filep->f_inode != NULL);
+
+  /* Recover the open file state from the struct file instance */
+  /* bf = filep->f_priv; */
+
+  /* Recover the file system state from the inode */
+
+  bm = filep->f_inode->i_private;
+  DEBUGASSERT(bm != NULL);
+
+  /* Free the open file state */
+  /* free(bf); */
+
+  filep->f_priv = NULL;
+
+  /* Since open() is not yet supported, neither is close(). */
+
+  return ret;
+}
+
+/****************************************************************************
+ * Name: binfs_read
+ ****************************************************************************/
+
+static ssize_t binfs_read(FAR struct file *filep, char *buffer, size_t buflen)
+{
+  struct binfs_state_s *bm;
+
+  fvdbg("Read %d bytes from offset %d\n", buflen, filep->f_pos);
+
+  /* Sanity checks */
+
+  DEBUGASSERT(filep->f_priv != NULL && filep->f_inode != NULL);
+
+  /* Recover the open file state data from the struct file instance */
+  /* bf = filep->f_priv; */
+
+  /* Recover the file system state from the inode */
+
+  bm = filep->f_inode->i_private;
+  DEBUGASSERT(bm != NULL);
+
+  /* Since open is not yet supported, neither is reading */
+
+  return -ENOSYS;
+}
+
+/****************************************************************************
+ * Name: binfs_ioctl
+ ****************************************************************************/
+
+static int binfs_ioctl(FAR struct file *filep, int cmd, unsigned long arg)
+{
+  struct binfs_state_s *bm;
+
+  fvdbg("cmd: %d arg: %08lx\n", cmd, arg);
+
+  /* Sanity checks */
+
+  DEBUGASSERT(filep->f_priv != NULL && filep->f_inode != NULL);
+
+  /* Recover the open file state from the struct file instance */
+  /* bf = filep->f_priv; */
+
+  /* Recover the file system state from the inode */
+
+  bm = filep->f_inode->i_private;
+  DEBUGASSERT(bm != NULL);
+
+  /* No ioctl commands yet supported */
+
+  return -ENOTTY;
+}
+
+/****************************************************************************
+ * Name: binfs_opendir
+ *
+ * Description:
+ *   Open a directory for read access
+ *
+ ****************************************************************************/
+
+static int binfs_opendir(struct inode *mountpt, const char *relpath,
+                         struct fs_dirent_s *dir)
+{
+  struct binfs_state_s   *bm;
+  int                     ret;
+
+  fvdbg("relpath: '%s'\n", relpath);
+
+  /* Sanity checks */
+
+  DEBUGASSERT(mountpt != NULL && mountpt->i_private != NULL);
+
+  /* Recover the file system state from the inode instance */
+
+  bm = mountpt->i_private;
+  binfs_semtake(bm);
+
+  /* The requested directory must be the volume-relative "root" directory */
+
+  if (relpath && relpath[0] != '\0')
+    {
+      ret = -ENOENT;
+      goto errout_with_semaphore;
+    }
+
+  /* Set the index to the first entry */
+
+  dir->u.binfs.fb_index = 0;
+  ret = OK;
+
+errout_with_semaphore:
+  binfs_semgive(bm);
+  return ret;
+}
+
+/****************************************************************************
+ * Name: binfs_readdir
+ *
+ * Description: Read the next directory entry
+ *
+ ****************************************************************************/
+
+static int binfs_readdir(struct inode *mountpt, struct fs_dirent_s *dir)
+{
+  struct binfs_state_s *bm;
+  unsigned int index;
+  int ret;
+
+  fvdbg("Entry\n");
+
+  /* Sanity checks */
+
+  DEBUGASSERT(mountpt != NULL && mountpt->i_private != NULL);
+
+  /* Recover the file system state from the inode instance */
+
+  bm = mountpt->i_private;
+  binfs_semtake(bm);
+
+  /* Have we reached the end of the directory */
+
+  index = dir->u.binfs.fb_index;
+  if (namedapps[index].name == NULL)
+    {
+      /* We signal the end of the directory by returning the
+       * special error -ENOENT
+       */
+
+      fdbg("End of directory\n");
+      ret = -ENOENT;
+    }
+  else
+    {
+      /* Save the filename and file type */
+
+      dir->fd_dir.d_type = DTYPE_FILE;
+      strncpy(dir->fd_dir.d_name, namedapps[index].name, NAME_MAX+1);
+
+      /* The application list is terminated by an entry with a NULL name.
+       * Therefore, there is at least one more entry in the list.
+       */
+
+      index++;
+
+      /* Set up the next directory entry offset.  NOTE that we could use the
+       * standard fr_curroffset instead of our own private fr_curroffset.
+       */
+
+      dir->u.binfs.fb_index      = index;
+      dir->u.romfs.fr_curroffset = index;
+      ret                        = OK;
+    }
+
+  binfs_semgive(bm);
+  return ret;
+}
+
+/****************************************************************************
+ * Name: binfs_rewindir
+ *
+ * Description: Reset directory read to the first entry
+ *
+ ****************************************************************************/
+
+static int binfs_rewinddir(struct inode *mountpt, struct fs_dirent_s *dir)
+{
+  struct binfs_state_s *bm;
+
+  fvdbg("Entry\n");
+
+  /* Sanity checks */
+
+  DEBUGASSERT(mountpt != NULL && mountpt->i_private != NULL);
+
+  /* Recover the file system state from the inode instance */
+
+  bm = mountpt->i_private;
+  binfs_semtake(bm);
+
+  dir->u.binfs.fb_index      = 0;
+  dir->u.romfs.fr_curroffset = 0;
+
+  binfs_semgive(bm);
+  return OK;
+}
+
+/****************************************************************************
+ * Name: binfs_bind
+ *
+ * Description: This implements a portion of the mount operation. This
+ *  function allocates and initializes the mountpoint private data and
+ *  binds the blockdriver inode to the filesystem private data.  The final
+ *  binding of the private data (containing the blockdriver) to the
+ *  mountpoint is performed by mount().
+ *
+ ****************************************************************************/
+
+static int binfs_bind(FAR struct inode *blkdriver, const void *data,
+                      void **handle)
+{
+  struct binfs_state_s *bm;
+
+  fvdbg("Entry\n");
+
+  /* Create an instance of the mountpt state structure */
+
+  bm = (struct binfs_state_s *)zalloc(sizeof(struct binfs_state_s));
+  if (!bm)
+    {
+      fdbg("Failed to allocate mountpoint structure\n");
+      return -ENOMEM;
+    }
+
+  /* Initialize the allocated mountpt state structure.  The filesystem is
+   * responsible for one reference ont the blkdriver inode and does not
+   * have to addref() here (but does have to release in ubind().
+   */
+
+  sem_init(&bm->bm_sem, 0, 1);     /* Initialize the semaphore that controls access */
+
+  /* Mounted! */
+
+  *handle = (void*)bm;
+  return OK;
+}
+
+/****************************************************************************
+ * Name: binfs_unbind
+ *
+ * Description: This implements the filesystem portion of the umount
+ *   operation.
+ *
+ ****************************************************************************/
+
+static int binfs_unbind(void *handle, FAR struct inode **blkdriver)
+{
+  struct binfs_state_s *bm = (struct binfs_state_s*)handle;
+
+  fvdbg("Entry\n");
+
+#ifdef CONFIG_DEBUG
+  if (!bm)
+    {
+      return -EINVAL;
+    }
+#endif
+
+  /* Check if there are sill any files opened on the filesystem. */
+
+  /* Release the mountpoint private data */
+
+  sem_destroy(&bm->bm_sem);
+  return OK;
+}
+
+/****************************************************************************
+ * Name: binfs_statfs
+ *
+ * Description: Return filesystem statistics
+ *
+ ****************************************************************************/
+
+static int binfs_statfs(struct inode *mountpt, struct statfs *buf)
+{
+  struct binfs_state_s *bm;
+
+  fvdbg("Entry\n");
+
+  /* Sanity checks */
+
+  DEBUGASSERT(mountpt && mountpt->i_private);
+
+  /* Get the mountpoint private data from the inode structure */
+
+  bm = mountpt->i_private;
+  binfs_semtake(bm);
+
+  /* Fill in the statfs info */
+
+  memset(buf, 0, sizeof(struct statfs));
+  buf->f_type    = BINFS_MAGIC;
+  buf->f_bsize   = 0;
+  buf->f_blocks  = 0;
+  buf->f_bfree   = 0;
+  buf->f_bavail  = 0;
+  buf->f_namelen = NAME_MAX;
+
+  binfs_semgive(bm);
+  return OK;
+}
+
+/****************************************************************************
+ * Name: binfs_stat
+ *
+ * Description: Return information about a file or directory
+ *
+ ****************************************************************************/
+
+static int binfs_stat(struct inode *mountpt, const char *relpath, struct stat *buf)
+{
+  struct binfs_state_s *bm;
+  int                   ret;
+
+  fvdbg("Entry\n");
+
+  /* Sanity checks */
+
+  DEBUGASSERT(mountpt && mountpt->i_private);
+
+  /* Get the mountpoint private data from the inode structure */
+
+  bm = mountpt->i_private;
+  binfs_semtake(bm);
+
+  /* The requested directory must be the volume-relative "root" directory */
+
+  if (relpath && relpath[0] != '\0')
+    {
+      /* It's a read-only directory name */
+
+      buf->st_mode = S_IFDIR|S_IROTH|S_IRGRP|S_IRUSR|S_IXOTH|S_IXGRP|S_IXUSR;
+    }
+  else
+    {
+      /* Check if there is a file with this name. */
+
+      if (namedapp_isavail(relpath) < 0)
+        {
+          ret = -ENOENT;
+          goto errout_with_semaphore;
+        }
+
+      /* It's a read-only file name */
+
+      buf->st_mode = S_IFREG|S_IROTH|S_IRGRP|S_IRUSR|S_IXOTH|S_IXGRP|S_IXUSR;
+    }
+
+  /* File/directory size, access block size */
+
+  buf->st_size      = 0;
+  buf->st_blksize   = 0;
+  buf->st_blocks    = 0;
+  ret               = OK;
+
+errout_with_semaphore:
+  binfs_semgive(bm);
+  return ret;
+}
+
+/****************************************************************************
+ * Public Functions
+ ****************************************************************************/
+
+#endif /* !CONFIG_DISABLE_MOUNTPOINT && CONFIG_APPS_BINDIR */
+
diff --git a/apps/nuttapp/exec_nuttapp.c b/apps/namedapp/exec_namedapp.c
index d688a0669..efd6549f8 100644
--- a/apps/nuttapp/exec_nuttapp.c
+++ b/apps/namedapp/exec_namedapp.c
@@ -1,5 +1,5 @@
 /****************************************************************************
- * drivers/sbin/exec_nuttapp.c
+ * apps/namedaps/exec_namedapp.c
  *
  *   Copyright (C) 2011 Uros Platise. All rights reserved.
  *   Author: Uros Platise <uros.platise@isotel.eu>
@@ -44,105 +44,79 @@
 #include <string.h>
 #include <errno.h>
 
+#include "namedapp.h"
 
 /****************************************************************************
  * Private Types
  ****************************************************************************/
 
-/* Load builtin function prototypes */
-
-#undef EXTERN
-#if defined(__cplusplus)
-#define EXTERN extern "C"
-extern "C" {
-#else
-#define EXTERN extern
-#endif
-
-#include "exec_nuttapp_proto.h"
-
-static const struct nuttapp_s nuttapps[] = {
-# include "exec_nuttapp_list.h"
-  {.name=NULL}
-};
-
-#undef EXTERN
-#if defined(__cplusplus)
-}
-#endif
-
-
 /****************************************************************************
  * Private Function Prototypes
  ****************************************************************************/
 
-
 /****************************************************************************
  * Private Data
  ****************************************************************************/
 
-
 /****************************************************************************
  * Private Functions
  ****************************************************************************/
 
-
 /****************************************************************************
  * Public Functions
  ****************************************************************************/
 
-
-const char * nuttapp_getname(int index)
+const char *namedapp_getname(int index)
 {
-  if ( index < 0 || index >= (sizeof(nuttapps)/sizeof(struct nuttapp_s)) )
-	return NULL;
+  if (index < 0 || index >= number_namedapps())
+   {
+	 return NULL;
+   }
 	
-  return nuttapps[index].name;
+  return namedapps[index].name;
 }
  
-
-int nuttapp_isavail(FAR const char *appname)
+int namedapp_isavail(FAR const char *appname)
 {
   int i;
     
-  for (i=0; nuttapps[i].name; i++) 
-  {
-    if ( !strcmp(nuttapps[i].name, appname) ) 
-      return i;
-  }
-  
+  for (i = 0; namedapps[i].name; i++) 
+    {
+      if (!strcmp(namedapps[i].name, appname))
+        {
+          return i;
+        }
+    }
+
   errno = ENOENT;
   return -1;
 }
  
-
-int exec_nuttapp(FAR const char *appname, FAR const char *argv[])
+int exec_namedapp(FAR const char *appname, FAR const char *argv[])
 {
   int i;
   
-  if ( (i = nuttapp_isavail(appname)) >= 0 )
-  {
+  if ((i = namedapp_isavail(appname)) >= 0)
+    {
 #ifndef CONFIG_CUSTOM_STACK
-    i = task_create(nuttapps[i].name, nuttapps[i].priority, 
-                      nuttapps[i].stacksize, nuttapps[i].main, 
-                      (argv) ? &argv[1] : (const char **)NULL);
+      i = task_create(namedapps[i].name, namedapps[i].priority, 
+                        namedapps[i].stacksize, namedapps[i].main, 
+                        (argv) ? &argv[1] : (const char **)NULL);
 #else
-    i = task_create(nuttapps[i].name, nuttapps[i].priority, nuttapps[i].main,
-                      (argv) ? &argv[1] : (const char **)NULL);
+      i = task_create(namedapps[i].name, namedapps[i].priority, namedapps[i].main,
+                        (argv) ? &argv[1] : (const char **)NULL);
 #endif
 
 #if CONFIG_RR_INTERVAL > 0
-    if (i > 0)
-    {
-      struct sched_param param;
+      if (i > 0)
+        {
+          struct sched_param param;
 	
-      sched_getparam(0, &param);
-	  sched_setscheduler(i, SCHED_RR, &param);
-	}
+          sched_getparam(0, &param);
+	      sched_setscheduler(i, SCHED_RR, &param);
+	    }
 #endif
-
-    return i;
-  }
+    }
   
   return i;
 }
diff --git a/apps/namedapp/namedapp.c b/apps/namedapp/namedapp.c
new file mode 100644
index 000000000..96a2942d6
--- /dev/null
+++ b/apps/namedapp/namedapp.c
@@ -0,0 +1,96 @@
+/****************************************************************************
+ * apps/namedaps/namedapp.c
+ *
+ *   Copyright (C) 2011 Uros Platise. All rights reserved.
+ *   Copyright (C) 2011 Gregory Nutt. All rights reserved.
+ *   Authors: Uros Platise <uros.platise@isotel.eu>
+ *            Gregory Nutt <spudmonkey@racsa.co.cr>
+ *
+ * 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. Neither the name NuttX 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 COPYRIGHT HOLDERS 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
+ * COPYRIGHT OWNER 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.
+ *
+ ****************************************************************************/
+
+/****************************************************************************
+ * Included Files
+ ****************************************************************************/
+
+#include <nuttx/config.h>
+#include <apps/apps.h>
+
+/****************************************************************************
+ * Private Types
+ ****************************************************************************/
+
+/****************************************************************************
+ * Private Function Prototypes
+ ****************************************************************************/
+
+/****************************************************************************
+ * Public Data
+ ****************************************************************************/
+
+#undef EXTERN
+#if defined(__cplusplus)
+#define EXTERN extern "C"
+extern "C" {
+#else
+#define EXTERN extern
+#endif
+
+#include "namedapp_proto.h"
+
+const struct namedapp_s namedapps[] =
+{
+# include "namedapp_list.h"
+  {.name = NULL}
+};
+
+#undef EXTERN
+#if defined(__cplusplus)
+}
+#endif
+
+
+/****************************************************************************
+ * Private Data
+ ****************************************************************************/
+
+/****************************************************************************
+ * Private Functions
+ ****************************************************************************/
+
+/****************************************************************************
+ * Public Functions
+ ****************************************************************************/
+
+int number_namedapps(void)
+{
+  return sizeof(namedapps)/sizeof(struct namedapp_s) - 1;
+}
+
+
diff --git a/apps/namedapp/namedapp.h b/apps/namedapp/namedapp.h
new file mode 100644
index 000000000..88fa7f36a
--- /dev/null
+++ b/apps/namedapp/namedapp.h
@@ -0,0 +1,78 @@
+/****************************************************************************
+ * apps/namedaps/namedapp.h
+ *
+ *   Copyright (C) 2011 Uros Platise. All rights reserved.
+ *   Copyright (C) 2011 Gregory Nutt. All rights reserved.
+ *   Authors: Uros Platise <uros.platise@isotel.eu>
+ *            Gregory Nutt <spudmonkey@racsa.co.cr>
+ *
+ * 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. Neither the name NuttX 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 COPYRIGHT HOLDERS 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
+ * COPYRIGHT OWNER 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.
+ *
+ ****************************************************************************/
+
+#ifndef __APPS_NAMEDAPP_NAMEDAPP_H
+#define __APPS_NAMEDAPP_NAMEDAPP_H
+
+/****************************************************************************
+ * Included Files
+ ****************************************************************************/
+
+#include <nuttx/config.h>
+#include <apps/apps.h>
+
+/****************************************************************************
+ * Public Types
+ ****************************************************************************/
+
+/****************************************************************************
+ * Public Data
+ ****************************************************************************/
+
+#undef EXTERN
+#if defined(__cplusplus)
+#define EXTERN extern "C"
+extern "C" {
+#else
+#define EXTERN extern
+#endif
+
+EXTERN const struct namedapp_s namedapps[];
+
+/****************************************************************************
+ * Public Functions
+ ****************************************************************************/
+
+EXTERN int number_namedapps(void);
+
+#undef EXTERN
+#if defined(__cplusplus)
+}
+#endif
+
+#endif /* __APPS_NAMEDAPP_NAMEDAPP_H */
+
diff --git a/apps/nshlib/nsh_apps.c b/apps/nshlib/nsh_apps.c
index 7ebc1280e..a8f9eb9bf 100644
--- a/apps/nshlib/nsh_apps.c
+++ b/apps/nshlib/nsh_apps.c
@@ -93,7 +93,7 @@ int nsh_execapp(FAR struct nsh_vtbl_s *vtbl, FAR const char *cmd,
 
    /* Try to find command within pre-built application list. */
 
-   ret = exec_nuttapp(cmd, argv);
+   ret = exec_namedapp(cmd, argv);
    if (ret < 0)
      {
        int err = -errno;
@@ -102,7 +102,7 @@ int nsh_execapp(FAR struct nsh_vtbl_s *vtbl, FAR const char *cmd,
        /* On failure, list the set of available built-in commands */
 
        nsh_output(vtbl, "Builtin Apps: ");
-       for (i = 0; (name = nuttapp_getname(i)) != NULL; i++)
+       for (i = 0; (name = namedapp_getname(i)) != NULL; i++)
          {
            nsh_output(vtbl, "%s ", name);
          }
diff --git a/apps/nshlib/nsh_parse.c b/apps/nshlib/nsh_parse.c
index bf34df676..e93c624fa 100644
--- a/apps/nshlib/nsh_parse.c
+++ b/apps/nshlib/nsh_parse.c
@@ -1152,13 +1152,13 @@ int nsh_parse(FAR struct nsh_vtbl_s *vtbl, char *cmdline)
     }
 
   /* Handle the case where the command is executed in background.
-   * However is app is to be started as nuttapp new process will
+   * However is app is to be started as namedapp new process will
    * be created anyway, so skip this step. */
 
 #ifndef CONFIG_NSH_DISABLEBG
   if (vtbl->np.np_bg
 #ifdef CONFIG_NSH_BUILTIN_APPS
-      && nuttapp_isavail(argv[0]) < 0     
+      && namedapp_isavail(argv[0]) < 0     
 #endif
   )
     {