--- a/packages/io/fileio/current/ChangeLog
+++ b/packages/io/fileio/current/ChangeLog
@@ -1,3 +1,14 @@
+2003-04-11  Jonathan Larmour  <jifl@eCosCentric.com>
+
+	* src/socket.cxx: Give nstab_lock mutex a priority. Also it's
+	local, so make static.
+	Change nstab and nstab_end to cyg_nstab and cyg_nstab_end for
+	cleaner namespace.
+	* include/sockio.h: nstab -> cyg_nstab.
+	* src/misc.cxx, src/dir.cxx, src/fio.h, src/file.cxx: Change
+	fstab, fstab_end, mtab, mtab_end, cdir_dir, cdir_mtab_entry to
+	have cyg_ prefix for cleaner namespace.
+
 2003-03-20  Gary Thomas  <gary@mlbassoc.com>
 
 	* src/devfs.cxx: Remove unnecessary checks for -EAGAIN (should

--- a/packages/io/fileio/current/src/dir.cxx
+++ b/packages/io/fileio/current/src/dir.cxx
@@ -98,8 +98,8 @@ extern DIR *opendir( const char *dirname
     int ret = 0;
     int fd;
     cyg_file *file;
-    cyg_mtab_entry *mte = cdir_mtab_entry;
-    cyg_dir dir = cdir_dir;
+    cyg_mtab_entry *mte = cyg_cdir_mtab_entry;
+    cyg_dir dir = cyg_cdir_dir;
     const char *name = dirname;
 
     fd = cyg_fd_alloc(1); // Never return fd 0

--- a/packages/io/fileio/current/src/file.cxx
+++ b/packages/io/fileio/current/src/file.cxx
@@ -114,7 +114,7 @@ static void update_cwd( cyg_mtab_entry *
 {
     char *p = cwd;
 
-    if( mte != cdir_mtab_entry || dir != cdir_dir )
+    if( mte != cyg_cdir_mtab_entry || dir != cyg_cdir_dir )
     {
         // Here, the path is relative to the root of the filesystem,
         // or in a totally new filesystem, initialize the cwd with the
@@ -193,8 +193,8 @@ static Cyg_Mutex getcwd_lock CYGBLD_ATTR
     int ret = 0;
     int fd;
     cyg_file *file;
-    cyg_mtab_entry *mte = cdir_mtab_entry;
-    cyg_dir dir = cdir_dir;
+    cyg_mtab_entry *mte = cyg_cdir_mtab_entry;
+    cyg_dir dir = cyg_cdir_dir;
     const char *name = path;
 
     // At least one of O_RDONLY, O_WRONLY, O_RDWR must be provided
@@ -261,8 +261,8 @@ static Cyg_Mutex getcwd_lock CYGBLD_ATTR
     FILEIO_ENTRY();
     
     int ret = 0;
-    cyg_mtab_entry *mte = cdir_mtab_entry;
-    cyg_dir dir = cdir_dir;
+    cyg_mtab_entry *mte = cyg_cdir_mtab_entry;
+    cyg_dir dir = cyg_cdir_dir;
     const char *name = path;
 
     ret = cyg_mtab_lookup( &dir, &name, &mte );
@@ -287,8 +287,8 @@ static Cyg_Mutex getcwd_lock CYGBLD_ATTR
     FILEIO_ENTRY();
     
     int ret = 0;
-    cyg_mtab_entry *mte = cdir_mtab_entry;
-    cyg_dir dir = cdir_dir;
+    cyg_mtab_entry *mte = cyg_cdir_mtab_entry;
+    cyg_dir dir = cyg_cdir_dir;
     const char *name = path;
 
     mode=mode;
@@ -315,8 +315,8 @@ static Cyg_Mutex getcwd_lock CYGBLD_ATTR
     FILEIO_ENTRY();
     
     int ret = 0;
-    cyg_mtab_entry *mte = cdir_mtab_entry;
-    cyg_dir dir = cdir_dir;
+    cyg_mtab_entry *mte = cyg_cdir_mtab_entry;
+    cyg_dir dir = cyg_cdir_dir;
     const char *name = path;
 
     ret = cyg_mtab_lookup( &dir, &name, &mte );
@@ -341,10 +341,10 @@ static Cyg_Mutex getcwd_lock CYGBLD_ATTR
     FILEIO_ENTRY();
     
     int ret = 0;
-    cyg_mtab_entry *mte1 = cdir_mtab_entry;
-    cyg_mtab_entry *mte2 = cdir_mtab_entry;
-    cyg_dir dir1 = cdir_dir;
-    cyg_dir dir2 = cdir_dir;
+    cyg_mtab_entry *mte1 = cyg_cdir_mtab_entry;
+    cyg_mtab_entry *mte2 = cyg_cdir_mtab_entry;
+    cyg_dir dir1 = cyg_cdir_dir;
+    cyg_dir dir2 = cyg_cdir_dir;
     const char *name1 = path1;
     const char *name2 = path2;
 
@@ -379,10 +379,10 @@ static Cyg_Mutex getcwd_lock CYGBLD_ATTR
     FILEIO_ENTRY();
     
     int ret = 0;
-    cyg_mtab_entry *mte1 = cdir_mtab_entry;
-    cyg_mtab_entry *mte2 = cdir_mtab_entry;
-    cyg_dir dir1 = cdir_dir;
-    cyg_dir dir2 = cdir_dir;
+    cyg_mtab_entry *mte1 = cyg_cdir_mtab_entry;
+    cyg_mtab_entry *mte2 = cyg_cdir_mtab_entry;
+    cyg_dir dir1 = cyg_cdir_dir;
+    cyg_dir dir2 = cyg_cdir_dir;
     const char *name1 = path1;
     const char *name2 = path2;
 
@@ -417,8 +417,8 @@ static Cyg_Mutex getcwd_lock CYGBLD_ATTR
     FILEIO_ENTRY();
     
     int ret = 0;
-    cyg_mtab_entry *mte = cdir_mtab_entry;
-    cyg_dir dir = cdir_dir;
+    cyg_mtab_entry *mte = cyg_cdir_mtab_entry;
+    cyg_dir dir = cyg_cdir_dir;
     cyg_dir newdir;
     const char *name = path;
 
@@ -440,24 +440,24 @@ static Cyg_Mutex getcwd_lock CYGBLD_ATTR
     update_cwd( mte, dir, name );
 #endif
     
-    if( cdir_mtab_entry != NULL && cdir_dir != CYG_DIR_NULL )
+    if( cyg_cdir_mtab_entry != NULL && cyg_cdir_dir != CYG_DIR_NULL )
     {
-        // Now detach from current cdir. We call the current directory's
+        // Now detach from current cyg_cdir. We call the current directory's
         // chdir routine with a NULL dir_out pointer.
 
-        LOCK_FS(cdir_mtab_entry);
+        LOCK_FS(cyg_cdir_mtab_entry);
 
-        ret = cdir_mtab_entry->fs->chdir( cdir_mtab_entry, cdir_dir, NULL, NULL );
+        ret = cyg_cdir_mtab_entry->fs->chdir( cyg_cdir_mtab_entry, cyg_cdir_dir, NULL, NULL );
     
-        UNLOCK_FS(cdir_mtab_entry);
+        UNLOCK_FS(cyg_cdir_mtab_entry);
 
         // We really shouldn't get an error here.
         if( 0 != ret )
             FILEIO_RETURN(ret);
     }
     
-    cdir_mtab_entry = mte;
-    cdir_dir = newdir;
+    cyg_cdir_mtab_entry = mte;
+    cyg_cdir_dir = newdir;
     
     FILEIO_RETURN(ENOERR);
 }
@@ -470,8 +470,8 @@ static Cyg_Mutex getcwd_lock CYGBLD_ATTR
     FILEIO_ENTRY();
     
     int ret = 0;
-    cyg_mtab_entry *mte = cdir_mtab_entry;
-    cyg_dir dir = cdir_dir;
+    cyg_mtab_entry *mte = cyg_cdir_mtab_entry;
+    cyg_dir dir = cyg_cdir_dir;
     const char *name = path;
 
     ret = cyg_mtab_lookup( &dir, &name, &mte );
@@ -496,8 +496,8 @@ static Cyg_Mutex getcwd_lock CYGBLD_ATTR
     FILEIO_ENTRY();
     
     int ret = 0;
-    cyg_mtab_entry *mte = cdir_mtab_entry;
-    cyg_dir dir = cdir_dir;
+    cyg_mtab_entry *mte = cyg_cdir_mtab_entry;
+    cyg_dir dir = cyg_cdir_dir;
     const char *name = path;
 
     ret = cyg_mtab_lookup( &dir, &name, &mte );
@@ -559,8 +559,8 @@ extern int 	access(const char *path, int
     FILEIO_ENTRY();
 
     int err = ENOERR;
-    cyg_mtab_entry *mte = cdir_mtab_entry;
-    cyg_dir dir = cdir_dir;
+    cyg_mtab_entry *mte = cyg_cdir_mtab_entry;
+    cyg_dir dir = cyg_cdir_dir;
     cyg_getcwd_info info;
 
     if( size == 0 )

--- a/packages/io/fileio/current/src/fio.h
+++ b/packages/io/fileio/current/src/fio.h
@@ -184,8 +184,8 @@ CYG_MACRO_END
 // Exports from misc.cxx
 
 // Current directory info
-__externC cyg_mtab_entry *cdir_mtab_entry;
-__externC cyg_dir cdir_dir;
+__externC cyg_mtab_entry *cyg_cdir_mtab_entry;
+__externC cyg_dir cyg_cdir_dir;
 
 __externC int cyg_mtab_lookup( cyg_dir *dir, const char **name, cyg_mtab_entry **mte);
 

--- a/packages/io/fileio/current/src/misc.cxx
+++ b/packages/io/fileio/current/src/misc.cxx
@@ -93,42 +93,42 @@ static void cyg_mtab_init();
 
 // This array contains entries for all filesystem that are installed in
 // the system.
-__externC cyg_fstab_entry fstab[];
-CYG_HAL_TABLE_BEGIN( fstab, fstab );
+__externC cyg_fstab_entry cyg_fstab[];
+CYG_HAL_TABLE_BEGIN( cyg_fstab, fstab );
 
 // end of filesystem table, set in linker script.
-__externC cyg_fstab_entry fstab_end;
-CYG_HAL_TABLE_END( fstab_end, fstab );
+__externC cyg_fstab_entry cyg_fstab_end;
+CYG_HAL_TABLE_END( cyg_fstab_end, fstab );
 
 #ifdef CYGPKG_KERNEL
 // Array of mutexes for locking the fstab entries
-Cyg_Mutex fstab_lock[CYGNUM_FILEIO_FSTAB_MAX] CYGBLD_ATTRIB_INIT_PRI(CYG_INIT_IO_FS);
+static Cyg_Mutex fstab_lock[CYGNUM_FILEIO_FSTAB_MAX] CYGBLD_ATTRIB_INIT_PRI(CYG_INIT_IO_FS);
 #endif
 
 // -------------------------------------------------------------------------
 // Mount table.
 
 // This array contains entries for all valid running filesystems.
-__externC cyg_mtab_entry mtab[];
-CYG_HAL_TABLE_BEGIN( mtab, mtab );
+__externC cyg_mtab_entry cyg_mtab[];
+CYG_HAL_TABLE_BEGIN( cyg_mtab, mtab );
 
 // Extra entries at end of mtab for dynamic mount points.
-cyg_mtab_entry mtab_extra[CYGNUM_FILEIO_MTAB_EXTRA] CYG_HAL_TABLE_EXTRA(mtab) = { { NULL } };
+cyg_mtab_entry cyg_mtab_extra[CYGNUM_FILEIO_MTAB_EXTRA] CYG_HAL_TABLE_EXTRA(mtab) = { { NULL } };
 
 // End of mount table, set in the linker script.
-__externC cyg_mtab_entry mtab_end;
-CYG_HAL_TABLE_END( mtab_end, mtab );
+__externC cyg_mtab_entry cyg_mtab_end;
+CYG_HAL_TABLE_END( cyg_mtab_end, mtab );
 
 #ifdef CYGPKG_KERNEL
 // Array of mutexes for locking the mtab entries
-Cyg_Mutex mtab_lock[CYGNUM_FILEIO_MTAB_MAX] CYGBLD_ATTRIB_INIT_PRI(CYG_INIT_IO_FS);
+static Cyg_Mutex mtab_lock[CYGNUM_FILEIO_MTAB_MAX] CYGBLD_ATTRIB_INIT_PRI(CYG_INIT_IO_FS);
 #endif
 
 //==========================================================================
 // Current directory
 
-cyg_mtab_entry *cdir_mtab_entry = NULL;
-cyg_dir cdir_dir = CYG_DIR_NULL;
+cyg_mtab_entry *cyg_cdir_mtab_entry = NULL;
+cyg_dir cyg_cdir_dir = CYG_DIR_NULL;
 
 //==========================================================================
 // Initialization object
@@ -157,7 +157,7 @@ static void cyg_mtab_init()
 {
     cyg_mtab_entry *m;
     
-    for( m = &mtab[0]; m != &mtab_end; m++ )
+    for( m = &cyg_mtab[0]; m != &cyg_mtab_end; m++ )
     {
         const char *fsname = m->fsname;
         cyg_fstab_entry *f;
@@ -167,13 +167,13 @@ static void cyg_mtab_init()
             continue;
         
         // stop if there are more than the configured maximum
-        if( m-&mtab[0] >= CYGNUM_FILEIO_MTAB_MAX )
+        if( m-&cyg_mtab[0] >= CYGNUM_FILEIO_MTAB_MAX )
             break;
         
-        for( f = &fstab[0]; f != &fstab_end; f++ )
+        for( f = &cyg_fstab[0]; f != &cyg_fstab_end; f++ )
         {
             // stop if there are more than the configured maximum
-            if( f-&fstab[0] >= CYGNUM_FILEIO_FSTAB_MAX )
+            if( f-&cyg_fstab[0] >= CYGNUM_FILEIO_FSTAB_MAX )
                 break;
             
             if( strcmp( fsname, f->name) == 0 )
@@ -241,7 +241,7 @@ static int matchlen( const char *s1, con
     }
 
     // Otherwise search the mount table.
-    for( m = &mtab[0]; m != &mtab_end; m++ )
+    for( m = &cyg_mtab[0]; m != &cyg_mtab_end; m++ )
     {
         if( m->name != NULL && m->valid )
         {
@@ -278,33 +278,33 @@ static int matchlen( const char *s1, con
     int result = ENOERR;
 
     // Search the mount table for an empty entry
-    for( m = &mtab[0]; m != &mtab_end; m++ )
+    for( m = &cyg_mtab[0]; m != &cyg_mtab_end; m++ )
     {
         // stop if there are more than the configured maximum
-        if( m-&mtab[0] >= CYGNUM_FILEIO_MTAB_MAX )
+        if( m-&cyg_mtab[0] >= CYGNUM_FILEIO_MTAB_MAX )
         {
-            m = &mtab_end;
+            m = &cyg_mtab_end;
             break;
         }
 
          if( m->name == NULL ) break;
     }
 
-    if( m == &mtab_end )
+    if( m == &cyg_mtab_end )
         FILEIO_RETURN(ENOMEM);
 
     // Now search the fstab for the filesystem implementation
-    for( f = &fstab[0]; f != &fstab_end; f++ )
+    for( f = &cyg_fstab[0]; f != &cyg_fstab_end; f++ )
     {
         // stop if there are more than the configured maximum
-        if( f-&fstab[0] >= CYGNUM_FILEIO_FSTAB_MAX )
+        if( f-&cyg_fstab[0] >= CYGNUM_FILEIO_FSTAB_MAX )
             break;
             
         if( strcmp( fsname, f->name) == 0 )
             break;
     }
 
-    if( f == &fstab_end )
+    if( f == &cyg_fstab_end )
         FILEIO_RETURN(ENODEV);
             
     // We have a match.
@@ -327,8 +327,8 @@ static int matchlen( const char *s1, con
 
     // Make sure that there is something to search (for open)
 
-    if (cdir_mtab_entry == (cyg_mtab_entry *)NULL) {
-        cdir_mtab_entry = m;
+    if (cyg_cdir_mtab_entry == (cyg_mtab_entry *)NULL) {
+        cyg_cdir_mtab_entry = m;
     }
 
     FILEIO_RETURN(result);
@@ -346,12 +346,12 @@ static int matchlen( const char *s1, con
     cyg_mtab_entry *m;
 
     // Search the mount table for a matching entry
-    for( m = &mtab[0]; m != &mtab_end; m++ )
+    for( m = &cyg_mtab[0]; m != &cyg_mtab_end; m++ )
     {
         // stop if there are more than the configured maximum
-        if( m-&mtab[0] >= CYGNUM_FILEIO_MTAB_MAX )
+        if( m-&cyg_mtab[0] >= CYGNUM_FILEIO_MTAB_MAX )
         {
-            m = &mtab_end;
+            m = &cyg_mtab_end;
             break;
         }
 
@@ -364,7 +364,7 @@ static int matchlen( const char *s1, con
          // Match device name too?
     }
 
-    if( m == &mtab_end )
+    if( m == &cyg_mtab_end )
         FILEIO_RETURN(EINVAL);
 
     // We have a match, call the umount function
@@ -388,13 +388,13 @@ void cyg_fs_lock( cyg_mtab_entry *mte, c
     CYG_ASSERT(mte != NULL, "Bad mount table entry");
 
     if( syncmode & CYG_SYNCMODE_FILE_FILESYSTEM ) {
-        CYG_ASSERT(mte->fs-&fstab[0] < CYGNUM_FILEIO_FSTAB_MAX, "Bad file system");
-        FILEIO_MUTEX_LOCK( fstab_lock[mte->fs-&fstab[0]] );
+        CYG_ASSERT(mte->fs-&cyg_fstab[0] < CYGNUM_FILEIO_FSTAB_MAX, "Bad file system");
+        FILEIO_MUTEX_LOCK( fstab_lock[mte->fs-&cyg_fstab[0]] );
     }
 
     if( syncmode & CYG_SYNCMODE_FILE_MOUNTPOINT ) {
-        CYG_ASSERT(mte-&mtab[0] < CYGNUM_FILEIO_MTAB_MAX, "Bad mount point");
-        FILEIO_MUTEX_LOCK( mtab_lock[mte-&mtab[0]] );
+        CYG_ASSERT(mte-&cyg_mtab[0] < CYGNUM_FILEIO_MTAB_MAX, "Bad mount point");
+        FILEIO_MUTEX_LOCK( mtab_lock[mte-&cyg_mtab[0]] );
     }
 }
 
@@ -403,13 +403,13 @@ void cyg_fs_unlock( cyg_mtab_entry *mte,
     CYG_ASSERT(mte != NULL, "Bad mount table entry");
 
     if( syncmode & CYG_SYNCMODE_FILE_FILESYSTEM ) {
-        CYG_ASSERT(mte->fs-&fstab[0] < CYGNUM_FILEIO_FSTAB_MAX, "Bad file system");
-        FILEIO_MUTEX_UNLOCK( fstab_lock[mte->fs-&fstab[0]] );
+        CYG_ASSERT(mte->fs-&cyg_fstab[0] < CYGNUM_FILEIO_FSTAB_MAX, "Bad file system");
+        FILEIO_MUTEX_UNLOCK( fstab_lock[mte->fs-&cyg_fstab[0]] );
     }
 
     if( syncmode & CYG_SYNCMODE_FILE_MOUNTPOINT ) {
-        CYG_ASSERT(mte-&mtab[0] < CYGNUM_FILEIO_MTAB_MAX, "Bad mount point");
-        FILEIO_MUTEX_UNLOCK( mtab_lock[mte-&mtab[0]] );
+        CYG_ASSERT(mte-&cyg_mtab[0] < CYGNUM_FILEIO_MTAB_MAX, "Bad mount point");
+        FILEIO_MUTEX_UNLOCK( mtab_lock[mte-&cyg_mtab[0]] );
     }
 }
 

--- a/packages/io/fileio/current/src/socket.cxx
+++ b/packages/io/fileio/current/src/socket.cxx
@@ -110,14 +110,14 @@ static void cyg_sock_unlock( cyg_file *f
 // Tables and local variables
 
 // Array of network stacks installed
-__externC cyg_nstab_entry nstab[];
-CYG_HAL_TABLE_BEGIN( nstab, nstab );
+__externC cyg_nstab_entry cyg_nstab[];
+CYG_HAL_TABLE_BEGIN( cyg_nstab, nstab );
 
 // End of array marker
-__externC cyg_nstab_entry nstab_end;
-CYG_HAL_TABLE_END( nstab_end, nstab );
+__externC cyg_nstab_entry cyg_nstab_end;
+CYG_HAL_TABLE_END( cyg_nstab_end, nstab );
 
-Cyg_Mutex nstab_lock[CYGNUM_FILEIO_NSTAB_MAX];
+static Cyg_Mutex nstab_lock[CYGNUM_FILEIO_NSTAB_MAX] CYGBLD_ATTRIB_INIT_PRI(CYG_INIT_IO_FS);
 
 //==========================================================================
 // Initialization
@@ -126,10 +126,10 @@ Cyg_Mutex nstab_lock[CYGNUM_FILEIO_NSTAB
 {
     cyg_nstab_entry *n;
 
-    for( n = &nstab[0]; n != &nstab_end; n++ )
+    for( n = &cyg_nstab[0]; n != &cyg_nstab_end; n++ )
     {
         // stop if there are more than the configured maximum
-        if( n-&nstab[0] >= CYGNUM_FILEIO_NSTAB_MAX )
+        if( n-&cyg_nstab[0] >= CYGNUM_FILEIO_NSTAB_MAX )
             break;
 
         if( n->init( n ) == 0 )
@@ -167,7 +167,7 @@ Cyg_Mutex nstab_lock[CYGNUM_FILEIO_NSTAB
 
     cyg_nstab_entry *n;
 
-    for( n = &nstab[0]; n != &nstab_end; n++ )
+    for( n = &cyg_nstab[0]; n != &cyg_nstab_end; n++ )
     {
         LOCK_NS( n );
         
@@ -697,7 +697,7 @@ static void cyg_ns_lock( cyg_nstab_entry
 {
     if( ns->syncmode & CYG_SYNCMODE_SOCK_NETSTACK )
     {
-        nstab_lock[ns-&nstab[0]].lock();
+        nstab_lock[ns-&cyg_nstab[0]].lock();
     }
 }
 
@@ -705,7 +705,7 @@ static void cyg_ns_unlock( cyg_nstab_ent
 {
     if( ns->syncmode & CYG_SYNCMODE_SOCK_NETSTACK )
     {
-        nstab_lock[ns-&nstab[0]].unlock();
+        nstab_lock[ns-&cyg_nstab[0]].unlock();
     }
 }
 
@@ -714,7 +714,7 @@ static void cyg_sock_lock( cyg_file *fp 
     cyg_nstab_entry *ns = (cyg_nstab_entry *)fp->f_mte;
 
     if( fp->f_syncmode & CYG_SYNCMODE_SOCK_NETSTACK )
-        nstab_lock[ns-&nstab[0]].lock();
+        nstab_lock[ns-&cyg_nstab[0]].lock();
 
     cyg_file_lock( fp, fp->f_syncmode>>CYG_SYNCMODE_SOCK_SHIFT);
 }
@@ -724,7 +724,7 @@ static void cyg_sock_unlock( cyg_file *f
     cyg_nstab_entry *ns = (cyg_nstab_entry *)fp->f_mte;
 
     if( fp->f_syncmode & CYG_SYNCMODE_SOCK_NETSTACK )
-        nstab_lock[ns-&nstab[0]].unlock();
+        nstab_lock[ns-&cyg_nstab[0]].unlock();
 
     cyg_file_unlock( fp, fp->f_syncmode>>CYG_SYNCMODE_SOCK_SHIFT);
 }