A whole bunch of changes to make the fs_shell build (and work) under

Linux:
* Corrected use of error code. We consequently use the errors we
  defined to be compatible with BeOS and translate error code to and from
  the build platform where necessary.
* Consequently use the structs my_stat and my_dirent and the type
  fs_off_t when dealing with the guest FS. my_dirent had to be adjusted
  to be BeOS compatible.
  We wrap the platform fstat() now to translate the struct stat to the
  BeOS representation.
* Fixed a bug introduced with the last checkin: The fs_shell crashed after
  executing a command.
* Fixed printf() format warnings under Linux.


git-svn-id: file:///srv/svn/repos/haiku/trunk/current@11565 a95241bf-73f2-0310-859d-f6bbb57e9c96

src/tests/add-ons/kernel/file_systems/fs_shell/cache.c

@@ -112,7 +112,7 @@ read_phys_blocks(int fd, fs_off_t bnum, void *data, uint num_blocks, int bsize)
     if (ret == num_blocks * bsize)
         return 0;
     else
-        return EBADF;
+        return FS_EBADF;
 }
 
 size_t
@@ -150,7 +150,7 @@ write_phys_blocks(int fd, fs_off_t bnum, void *data, uint num_blocks, int bsize)
     if (ret == num_blocks * bsize)
         return 0;
     else
-        return EBADF;
+        return FS_EBADF;
 }
 
 //	#pragma mark -
@@ -164,7 +164,7 @@ init_hash_table(hash_table *ht)
 
     ht->table = (hash_ent **)calloc(ht->max, sizeof(hash_ent *));
     if (ht->table == NULL)
-        return ENOMEM;
+        return FS_ENOMEM;
 
     return 0;
 }
@@ -254,7 +254,7 @@ grow_hash_table(hash_table *ht)
 
     new_table = (hash_ent **)calloc(newsize, sizeof(hash_ent *));
     if (new_table == NULL)
-        return ENOMEM;
+        return FS_ENOMEM;
 
     for(i=0; i < omax; i++) {
         for(he=ht->table[i]; he; he=next) {
@@ -292,12 +292,12 @@ hash_insert(hash_table *ht, int dev, fs_off_t bnum, void *data)
 
     if (curr && curr->dev == dev && curr->bnum == bnum) {
         printf("entry %d:%Ld already in the hash table!\n", dev, bnum);
-        return EEXIST;
+        return FS_EEXIST;
     }
 
     he = new_hash_ent(dev, bnum, data);
     if (he == NULL)
-        return ENOMEM;
+        return FS_ENOMEM;
     
     he->next        = ht->table[hash];
     ht->table[hash] = he;
@@ -305,7 +305,7 @@ hash_insert(hash_table *ht, int dev, fs_off_t bnum, void *data)
     ht->num_elements++;
     if (ht->num_elements >= ((ht->max * 3) / 4)) {
         if (grow_hash_table(ht) != 0)
-            return ENOMEM;
+            return FS_ENOMEM;
     }
 
     return 0;
@@ -402,7 +402,7 @@ init_block_cache(int max_blocks, int flags)
     memset(&max_device_blocks, 0, sizeof(max_device_blocks));
 
     if (init_hash_table(&bc.ht) != 0)
-        return ENOMEM;
+        return FS_ENOMEM;
 
     bc.lock.s = iovec_lock.s = -1;
 
@@ -438,7 +438,7 @@ init_block_cache(int max_blocks, int flags)
 
     shutdown_hash_table(&bc.ht);
     memset((void *)&bc, 0, sizeof(bc));
-    return ENOMEM;
+    return FS_ENOMEM;
 }
 
 
@@ -908,7 +908,7 @@ flush_ents(cache_ent **ents, int n_ents)
     
     iov = get_iovec_array();
     if (iov == NULL)
-        return ENOMEM;
+        return FS_ENOMEM;
 
 restart:
     for(i=0; i < n_ents; i++) {
@@ -962,11 +962,11 @@ restart:
 
             for(idx=0; idx < iocnt; idx++)
                 printf("iov[%2d] = %p :: %ld\n", idx, iov[idx].iov_base,
-                       iov[idx].iov_len);
+                       (long)iov[idx].iov_len);
 
             printf("error %s writing blocks %Ld:%d (%d != %d)\n",
                    strerror(errno), start_bnum, iocnt, ret, iocnt*bsize);
-            ret = EINVAL;
+            ret = FS_EINVAL;
             break;
         }
         ret = 0;
@@ -1103,6 +1103,8 @@ int
 init_cache_for_device(int fd, fs_off_t max_blocks)
 {
     int ret = 0;
+
+printf("init_cache_for_device(%d, %lld)\n", fd, max_blocks);
     
     if (fd >= MAX_DEVICES)
         return -1;
@@ -1178,7 +1180,7 @@ set_blocks_info(int dev, fs_off_t *blocks, int nblocks,
         if (ce == NULL) {
             panic("*** set_block_info can't find bnum %ld!\n", blocks[i]);
             UNLOCK(bc.lock);
-            return ENOENT;   /* hopefully this doesn't happen... */
+            return FS_ENOENT;   /* hopefully this doesn't happen... */
         }
 
 
@@ -1186,7 +1188,7 @@ set_blocks_info(int dev, fs_off_t *blocks, int nblocks,
             UNLOCK(bc.lock);
             panic("** error1: looked up dev %d block %ld but found dev %d "
                     "bnum %ld\n", dev, blocks[i], ce->dev, ce->block_num);
-            return EBADF;
+            return FS_EBADF;
         }
 
         if (ce->lock == 0) {
@@ -1243,7 +1245,7 @@ set_blocks_info(int dev, fs_off_t *blocks, int nblocks,
         if (ce == NULL) {
             panic("*** set_block_info can't find bnum %Ld!\n", blocks[i]);
             UNLOCK(bc.lock);
-            return ENOENT;   /* hopefully this doesn't happen... */
+            return FS_ENOENT;   /* hopefully this doesn't happen... */
         }
 
         ce->flags &= ~(CE_DIRTY | CE_BUSY);
@@ -1436,7 +1438,9 @@ real_remove_cached_blocks(int dev, int allow_writes, cache_ent_list *cel)
 int
 remove_cached_device_blocks(int dev, int allow_writes)
 {
-    LOCK(bc.lock);
+printf("remove_cached_device_blocks(%d, %d)\n", dev, allow_writes);
+
+	LOCK(bc.lock);
 
     real_remove_cached_blocks(dev, allow_writes, &bc.normal);
     real_remove_cached_blocks(dev, allow_writes, &bc.locked);
@@ -1472,7 +1476,7 @@ flush_blocks(int dev, fs_off_t bnum, int nblocks)
             UNLOCK(bc.lock);
             panic("error2: looked up dev %d block %ld but found %d %ld\n",
                   dev, bnum, ce->dev, ce->block_num);
-            return EBADF;
+            return FS_EBADF;
         }
 
         if ((ce->flags & CE_DIRTY) == 0 && ce->clone == NULL)
@@ -1529,7 +1533,7 @@ mark_blocks_dirty(int dev, fs_off_t bnum, int nblocks)
         } else {     /* hmmm, that's odd, didn't find it */
             printf("** mark_blocks_diry couldn't find block %Ld (len %d)\n",
                    bnum, nblocks);
-            ret = ENOENT;
+            ret = FS_ENOENT;
             break;
         }
     }
@@ -1555,7 +1559,7 @@ release_block(int dev, fs_off_t bnum)
             panic("*** error3: looked up dev %d block %ld but found %d %ld\n",
                     dev, bnum, ce->dev, ce->block_num);
             UNLOCK(bc.lock);
-            return EBADF;
+            return FS_EBADF;
         }
 
         ce->lock--;
@@ -1698,7 +1702,7 @@ read_into_ents(int dev, fs_off_t bnum, cache_ent **ents, int num, int bsize)
         printf("read_into_ents: asked to read %d bytes but got %d\n",
                num*bsize, ret);
         printf("*** iov @ %p (num %d)\n", iov, num);
-        return EINVAL;
+        return FS_EINVAL;
     } else
         return 0;
 }
@@ -1755,7 +1759,7 @@ cache_block_io(int dev, fs_off_t bnum, void *data, fs_off_t num_blocks, int bsiz
     if (data == NULL && dataptr == NULL) {
         printf("major butthead move: null data and dataptr! bnum %Ld:%Ld\n",
                 bnum, num_blocks);
-        return ENOMEM;
+        return FS_ENOMEM;
     }
         
     if (data == NULL) {
@@ -1775,7 +1779,7 @@ cache_block_io(int dev, fs_off_t bnum, void *data, fs_off_t num_blocks, int bsiz
 		debugger("Accessed blocks out of device range!");
 		//*(int *)0x3100 = 0xc0debabe;
 
-        return EINVAL;
+        return FS_EINVAL;
     }
 
     last_cache_access = system_time();
@@ -1793,7 +1797,7 @@ cache_block_io(int dev, fs_off_t bnum, void *data, fs_off_t num_blocks, int bsiz
             if (read_phys_blocks(dev, bnum, data, num_blocks, bsize) != 0) {
                 printf("cache read:read_phys_blocks failed (%s on blocks %Ld:%Ld)!\n",
                         strerror(errno), bnum, num_blocks);
-                return EINVAL;
+                return FS_EINVAL;
             }
 
             LOCK(bc.lock);
@@ -1835,7 +1839,7 @@ cache_block_io(int dev, fs_off_t bnum, void *data, fs_off_t num_blocks, int bsiz
                         panic("*** error5: looked up dev %d block %Ld but "
                                 "found %d %Ld\n", dev, tmp, ce->dev,
                                 ce->block_num);
-                        return EBADF;
+                        return FS_EBADF;
                     }
 
                     /* XXXdbg -- this isn't strictly necessary */
@@ -1854,11 +1858,11 @@ cache_block_io(int dev, fs_off_t bnum, void *data, fs_off_t num_blocks, int bsiz
             if (write_phys_blocks(dev, bnum, data, num_blocks, bsize) != 0) {
                 printf("cache write: write_phys_blocks failed (%s on blocks "
                        "%Ld:%Ld)!\n", strerror(errno), bnum, num_blocks);
-                return EINVAL;
+                return FS_EINVAL;
             }
         } else {
             printf("bad cache op %d (bnum %Ld nblocks %Ld)\n", op, bnum, num_blocks);
-            return EINVAL;
+            return FS_EINVAL;
         }
 
         return 0;
@@ -1874,7 +1878,7 @@ cache_block_io(int dev, fs_off_t bnum, void *data, fs_off_t num_blocks, int bsiz
                 UNLOCK(bc.lock);
                 panic("*** error6: looked up dev %d block %ld but found "
                         "%d %ld\n", dev, bnum, ce->dev, ce->block_num);
-                return EBADF;
+                return FS_EBADF;
             }
 
             if (bsize != ce->bsize) {
@@ -2097,7 +2101,7 @@ cache_block_io(int dev, fs_off_t bnum, void *data, fs_off_t num_blocks, int bsiz
                 if (ents[cur]->data == NULL) {
                     printf("cache: no memory for block (bsize %d)!\n",
                            bsize);
-                    err = ENOMEM;
+                    err = FS_ENOMEM;
                     break;
                 }
             }
@@ -2147,7 +2151,7 @@ cache_block_io(int dev, fs_off_t bnum, void *data, fs_off_t num_blocks, int bsiz
                     UNLOCK(bc.lock);
                 }
 
-                return ENOMEM;
+                return FS_ENOMEM;
             }
                 
 

src/tests/add-ons/kernel/file_systems/fs_shell/compat.h

@@ -20,11 +20,27 @@
 #ifndef _COMPAT_H
 #define _COMPAT_H
 
+#define _FS_INTERFACE_H
+	// don't include that file
 
+#ifndef __BEOS__
+#define _ERRORS_H
+	// don't include <Errors.h>, we use the platform <errno.h>
+#define dprintf build_platform_dprintf
+#include <stdio.h>
+#undef dprintf
+
+typedef struct dirent dirent_t;
+typedef struct iovec iovec;
+
+#endif
+
+
+#include <dirent.h>
 #include <stdlib.h>
 #include <stdarg.h>
 #include <errno.h>
-#include <memory.h>
+#include <stdlib.h>
 #include <string.h>
 #include <fcntl.h>
 #include <time.h>
@@ -36,8 +52,12 @@
 #include <iovec.h>           /* because we're boneheads sometimes */
 #else
 #include <sys/uio.h>
+#include <image.h>           /* for a few typedefs */
+#include <Drivers.h>         /* for various ioctl structs, etc */
 #endif
 
+#include "errors.h"
+
 
 /*
   By default (for portability reasons) the size of off_t's and ino_t's
@@ -76,7 +96,9 @@ typedef int my_gid_t;
 
 typedef struct my_dirent {
     my_dev_t        d_dev;
+    my_dev_t        d_pdev;
     my_ino_t        d_ino;
+    my_ino_t        d_pino;
     unsigned short  d_reclen;
     char            d_name[1];
 } my_dirent_t;
@@ -111,6 +133,21 @@ struct my_stat {
 };
 
 
+#define MY_S_ATTR_DIR          01000000000 /* attribute directory */
+#define MY_S_ATTR              02000000000 /* attribute */
+#define MY_S_INDEX_DIR         04000000000 /* index (or index directory) */
+#define MY_S_STR_INDEX         00100000000 /* string index */
+#define MY_S_INT_INDEX         00200000000 /* int32 index */
+#define MY_S_UINT_INDEX        00400000000 /* uint32 index */
+#define MY_S_LONG_LONG_INDEX   00010000000 /* int64 index */
+#define MY_S_ULONG_LONG_INDEX  00020000000 /* uint64 index */
+#define MY_S_FLOAT_INDEX       00040000000 /* float index */
+#define MY_S_DOUBLE_INDEX      00001000000 /* double index */
+#define MY_S_ALLOW_DUPS        00002000000 /* allow duplicate entries (currently unused) */
+
+#define MY_S_LINK_SELF_HEALING 00001000000 /* link will be updated if you move its target */
+#define MY_S_LINK_AUTO_DELETE  00002000000 /* link will be deleted if you delete its target */
+
 #define     MY_S_IFMT        00000170000 /* type of file */
 #define     MY_S_IFLNK       00000120000 /* symbolic link */
 #define     MY_S_IFREG       00000100000 /* regular */
@@ -147,7 +184,6 @@ struct my_stat {
 #define MY_S_IXOTH 00001     /* execute permission: other */
 
 
-
 #ifndef TRUE
 #define TRUE 1
 #endif
@@ -157,37 +193,11 @@ struct my_stat {
 #endif
 
 #ifndef __BEOS__
-typedef long               sem_id;
-typedef unsigned char      uchar;
-typedef short              int16;
-typedef unsigned short     uint16;
-typedef int                int32;
-typedef unsigned int       uint32;
-#define ulong unsigned long         /* make it a #define to avoid conflicts */
-typedef long long          int64;
-typedef unsigned long long uint64;
-typedef unsigned int       port_id;
-typedef int                bool;
-typedef int                image_id;
-typedef long long          bigtime_t;
-typedef long               thread_id;
-typedef long               status_t;
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-sem_id     create_sem(long count, const char *name);
-long       delete_sem(sem_id sem);
-long       acquire_sem(sem_id sem);
-long       acquire_sem_etc(sem_id sem, int count, int flags,
-                           bigtime_t microsecond_timeout);
-long       release_sem(sem_id sem);
-long       release_sem_etc(sem_id sem, long count, long flags);
-
-long       atomic_add(long *value, long addvalue);
-int        snooze(bigtime_t f);
-bigtime_t  system_time(void);
 ssize_t    read_pos(int fd, fs_off_t _pos, void *data,  size_t nbytes);
 ssize_t    write_pos(int fd, fs_off_t _pos, const void *data,  size_t nbytes);
 ssize_t    readv_pos(int fd, fs_off_t _pos, struct iovec *iov, int count);
@@ -197,7 +207,7 @@ ssize_t    writev_pos(int fd, fs_off_t _pos, struct iovec *iov,  int count);
 }
 #endif
 
-#endif /* __BEOS__ */
+#endif /* ! __BEOS__ */
 
 #ifdef __cplusplus
 extern "C" {

src/tests/add-ons/kernel/file_systems/fs_shell/external_commands.cpp

@@ -99,4 +99,20 @@ reply_to_external_command(int result)
 	}
 }
 
-#endif // __BEOS__
+#else // ! __BEOS__
+
+char *
+get_external_command(const char *prompt, char *input, int len)
+{
+	// TODO: Implement!
+	return 0;
+}
+
+
+void
+reply_to_external_command(int result)
+{
+	// TODO: Implement!
+}
+
+#endif // ! __BEOS__

src/tests/add-ons/kernel/file_systems/fs_shell/fsh.cpp

@@ -14,6 +14,8 @@
   dbg@be.com
 */
 
+#include "compat.h"
+
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -163,7 +165,7 @@ do_open(int argc, char **argv)
 
     cur_fd = sys_open(1, -1, name, O_RDWR, MY_S_IFREG, 0);
     if (cur_fd < 0) {
-        printf("error opening %s : %s (%d)\n", name, strerror(cur_fd), cur_fd);
+        printf("error opening %s : %s (%d)\n", name, fs_strerror(cur_fd), cur_fd);
     	return cur_fd;
     } else {
         printf("opened: %s\n", name);
@@ -188,7 +190,7 @@ do_make(int argc, char **argv)
 
     cur_fd = sys_open(1, -1, name, O_RDWR|O_CREAT, 0666, 0);
     if (cur_fd < 0) {
-        printf("error creating: %s: %s\n", name, strerror(cur_fd));
+        printf("error creating: %s: %s\n", name, fs_strerror(cur_fd));
         return cur_fd;
     }
 
@@ -212,7 +214,7 @@ do_mkdir(int argc, char **argv)
 
     err = sys_mkdir(1, -1, name, MY_S_IRWXU);
     if (err)
-        printf("mkdir of %s returned: %s (%d)\n", name, strerror(err), err);
+        printf("mkdir of %s returned: %s (%d)\n", name, fs_strerror(err), err);
 
 	return err;
 }
@@ -228,7 +230,7 @@ do_read_test(int argc, char **argv)
     
     if (cur_fd < 0) {
         printf("no file open! (open or create one with open or make)\n");
-        return EINVAL;
+        return FS_EINVAL;
     }
 
     if (argv[1] && isdigit(argv[1][0]))
@@ -236,8 +238,8 @@ do_read_test(int argc, char **argv)
 
     buff = (char*)malloc(len);
     if (buff == NULL) {
-        printf("no memory for write buffer of %lu bytes\n", len);
-        return ENOMEM;
+        printf("no memory for write buffer of %lu bytes\n", (unsigned long)len);
+        return FS_ENOMEM;
     }
 
     for (i = 0; (size_t)i < len; i++)
@@ -253,7 +255,7 @@ do_read_test(int argc, char **argv)
 	}
 
 	free(buff);
-	printf("read read %lu bytes and returned %d\n", len, err);
+	printf("read read %lu bytes and returned %d\n", (unsigned long)len, err);
 
 	return (err < 0 ? err : 0);
 }
@@ -268,7 +270,7 @@ do_write_test(int argc, char **argv)
     
     if (cur_fd < 0) {
         printf("no file open! (open or create one with open or make)\n");
-        return EINVAL;
+        return FS_EINVAL;
     }
 
     if (argv[1] && isdigit(argv[1][0]))
@@ -276,8 +278,8 @@ do_write_test(int argc, char **argv)
 
     buff = (char*)malloc(len);
     if (buff == NULL) {
-        printf("no memory for write buffer of %lu bytes\n", len);
-        return ENOMEM;
+        printf("no memory for write buffer of %lu bytes\n", (unsigned long)len);
+        return FS_ENOMEM;
     }
 
     for (i = 0; (size_t)i < len; i++)
@@ -286,7 +288,7 @@ do_write_test(int argc, char **argv)
     err = sys_write(1, cur_fd, buff, len);
     free(buff);
     
-    printf("write wrote %lu bytes and returned %d\n", len, err);
+    printf("write wrote %lu bytes and returned %d\n", (unsigned long)len, err);
 
 	return (err < 0 ? err : 0);
 }
@@ -302,7 +304,7 @@ do_write_stream(int argc, char **argv)
 
     if (cur_fd < 0) {
         printf("no file open! (open or create one with open or make)\n");
-        return EINVAL;
+        return FS_EINVAL;
     }
 
     if (argv[1] && isdigit(argv[1][0]))
@@ -313,7 +315,7 @@ do_write_stream(int argc, char **argv)
 
 	for (i = 0; (size_t)i < amount; i++) {
 		err = sys_write(1, cur_fd, buffer, length);
-		if (err < B_OK)
+		if (err < FS_OK)
 			break;
 	}
 
@@ -332,12 +334,12 @@ do_read_attr(int argc, char **argv)
 
     if (cur_fd < 0) {
         printf("no file open! (open or create one with open or make)\n");
-        return EINVAL;
+        return FS_EINVAL;
     }
 
 	if (argc < 2) {
         printf("usage: rdattr <attribute name> [bytes to write]\n");
-		return EINVAL;
+		return FS_EINVAL;
 	}
 
 	attribute = argv[1];
@@ -345,13 +347,13 @@ do_read_attr(int argc, char **argv)
         len = strtoul(argv[2], NULL, 0);
 	if (len < 0) {
 		printf("invalid length for write attribute!\n");
-		return EINVAL;
+		return FS_EINVAL;
 	}
 
     buffer = (char*)malloc(len);
     if (buffer == NULL) {
-        printf("no memory for write buffer of %lu bytes\n", len);
-        return ENOMEM;
+        printf("no memory for write buffer of %lu bytes\n", (unsigned long)len);
+        return FS_ENOMEM;
     }
 
 	for (i = 0; (size_t)i < len; i++)
@@ -363,7 +365,7 @@ do_read_attr(int argc, char **argv)
         hexdump(buffer, err < 512 ? err : 512);
 
     free(buffer);
-    printf("read read %lu bytes and returned %d (%s)\n", len, err, strerror(err));
+    printf("read read %lu bytes and returned %d (%s)\n", (unsigned long)len, err, fs_strerror(err));
 
 	return (err < 0 ? err : 0);
 }
@@ -378,12 +380,12 @@ do_write_attr(int argc, char **argv)
 
     if (cur_fd < 0) {
         printf("no file open! (open or create one with open or make)\n");
-        return EINVAL;
+        return FS_EINVAL;
     }
 
 	if (argc < 2) {
         printf("usage: wrattr <attribute name> [bytes to write]\n");
-		return EINVAL;
+		return FS_EINVAL;
 	}
 
 	attribute = argv[1];
@@ -391,13 +393,13 @@ do_write_attr(int argc, char **argv)
         len = strtoul(argv[2], NULL, 0);
 	if (len < 0) {
 		printf("invalid length for write attribute!\n");
-		return EINVAL;
+		return FS_EINVAL;
 	}
 
     buffer = (char*)malloc(len);
     if (buffer == NULL) {
-        printf("no memory for write buffer of %lu bytes\n", len);
-        return ENOMEM;
+        printf("no memory for write buffer of %lu bytes\n", (unsigned long)len);
+        return FS_ENOMEM;
     }
 
     for (i = 0; (size_t)i < len; i++)
@@ -406,7 +408,7 @@ do_write_attr(int argc, char **argv)
     err = sys_write_attr(1, cur_fd, attribute, 'CSTR', buffer, len, 0);
     free(buffer);
 
-    printf("write wrote %lu bytes and returned %d\n", len, err);
+    printf("write wrote %lu bytes and returned %d\n", (unsigned long)len, err);
 
 	return (err < 0 ? err : 0);
 }
@@ -419,12 +421,12 @@ do_remove_attr(int argc, char **argv)
 
     if (cur_fd < 0) {
         printf("no file open! (open or create one with open or make)\n");
-        return EINVAL;
+        return FS_EINVAL;
     }
 
 	if (argc < 2) {
         printf("usage: rmattr <attribute name>\n");
-		return EINVAL;
+		return FS_EINVAL;
 	}
 
     err = sys_remove_attr(1, cur_fd, argv[1]);
@@ -508,22 +510,24 @@ do_dir(int argc, char **argv)
 			continue;
 		}
 
-		tm = localtime(&st.st_mtime);
+		tm = localtime(&st.mtime);
 		strftime(time_buf, sizeof(time_buf), "%b %d %I:%M", tm);
 
-		mode_bits_to_str(st.st_mode, mode_str);
+		mode_bits_to_str(st.mode, mode_str);
 
-		printf("%12Ld %s %6d %6d %12Ld %s %s\n", st.st_ino, mode_str,
-			st.st_uid, st.st_gid, st.st_size, time_buf, dent->d_name);
+		printf("%12Ld %s %6d %6d %12Ld %s %s\n", st.ino, mode_str,
+			st.uid, st.gid, st.size, time_buf, dent->d_name);
 		count++;
 	}
 
 	if (err != 0)
 		printf("readdir failed on: %s\n", dent->d_name);
 
-	printf("%ld files in directory!\n",count);
+	printf("%ld files in directory!\n", (long)count);
 
+printf("sys_closedir()...\n");
 	sys_closedir(1, dirfd);
+printf("sys_closedir() done\n");
 
 	return 0;	// not really correct, but anyway...
 }
@@ -537,7 +541,7 @@ do_ioctl(int argc, char **argv)
 
 	if (argc < 2) {
 		printf("ioctl: too few arguments\n");
-		return EINVAL;
+		return FS_EINVAL;
 	}
 
 	if ((fd = sys_open(1, -1, "/myfs/.", O_RDONLY, S_IFREG, 0)) < 0) {
@@ -563,12 +567,12 @@ do_fcntl(int argc, char **argv)
 
     if (cur_fd < 0) {
         printf("no file open! (open or create one with open or make)\n");
-        return EINVAL;
+        return FS_EINVAL;
     }
 
 	if (argc < 2) {
 		printf("fcntl: too few arguments\n");
-		return EINVAL;
+		return FS_EINVAL;
 	}
 
 	err = sys_ioctl(1, cur_fd, atoi(argv[1]), 0, 0);
@@ -627,7 +631,7 @@ do_rmall(int argc, char **argv)
     if (err != 0) {
         printf("readdir failed on: %s\n", dent->d_name);
     }
-	printf("%ld files removed!\n", count);
+	printf("%ld files removed!\n", (long)count);
 
     sys_closedir(1, dirfd);
 
@@ -645,12 +649,12 @@ do_trunc(int argc, char **argv)
     strcpy(fname, "/myfs/");
     if (argc < 3) {
         printf("usage: trunc fname newsize\n");
-        return EINVAL;
+        return FS_EINVAL;
     }
     strcat(fname, argv[1]);
     new_size = strtoul(argv[2], NULL, 0);
 
-    st.st_size = new_size;
+    st.size = new_size;
     err = sys_wstat(1, -1, fname, &st, WSTAT_SIZE, 0);
     if (err != 0) {
         printf("truncate to %d bytes failed for %s\n", new_size, fname);
@@ -668,13 +672,13 @@ do_seek(int argc, char **argv)
 
     if (cur_fd < 0) {
         printf("no file open! (open or create one with open or make)\n");
-        return EINVAL;
+        return FS_EINVAL;
     }
 
     
     if (argc < 2) {
         printf("usage: seek pos\n");
-        return EINVAL;
+        return FS_EINVAL;
     }
     pos = strtoul(&argv[1][0], NULL, 0);
 
@@ -698,14 +702,14 @@ do_rm(int argc, char **argv)
 
     if (argc < 2) {
         printf("rm: need a file name to remove\n");
-        return EINVAL;
+        return FS_EINVAL;
     }
 
     sprintf(name, "/myfs/%s", &argv[1][0]);
     
     err = sys_unlink(1, -1, name);
     if (err != 0) {
-        printf("error removing: %s: %s\n", name, strerror(err));
+        printf("error removing: %s: %s\n", name, fs_strerror(err));
     }
 
 	return err;
@@ -723,14 +727,14 @@ do_rmdir(int argc, char **argv)
 
     if (argc < 2) {
         printf("rm: need a file name to remove\n");
-        return EINVAL;
+        return FS_EINVAL;
     }
 
     sprintf(name, "/myfs/%s", &argv[1][0]);
     
     err = sys_rmdir(1, -1, name);
     if (err != 0) {
-        printf("rmdir: error removing: %s: %s\n", name, strerror(err));
+        printf("rmdir: error removing: %s: %s\n", name, fs_strerror(err));
     }
 
 	return err;
@@ -751,7 +755,7 @@ do_copy_to_myfs(char *host_file, char *bfile)
     fp = fopen(host_file, "rb");
     if (fp == NULL) {
         printf("can't open host file: %s\n", host_file);
-        return errno;
+        return from_platform_error(errno);
     }
         
     if ((bfd = sys_open(1, -1, myfs_name, O_RDWR|O_CREAT,
@@ -772,7 +776,7 @@ do_copy_to_myfs(char *host_file, char *bfile)
     }
 
     if (err < 0) {
-        printf("err == %d, amt == %ld\n", err, amt);
+        printf("err == %d, amt == %ld\n", err, (long)amt);
         perror("write error");
     }
 
@@ -797,7 +801,7 @@ do_copy_from_myfs(char *bfile, char *host_file)
     fp = fopen(host_file, "wb");
     if (fp == NULL) {
         printf("can't open host file: %s\n", host_file);
-        return errno;
+        return from_platform_error(errno);
     }
         
     if ((bfd = sys_open(1, -1, myfs_name, O_RDONLY, MY_S_IFREG, 0)) < 0) {
@@ -835,7 +839,7 @@ do_copy(int argc, char **argv)
 
     if (argc < 3) {
         printf("copy needs two arguments!\n");
-        return EINVAL;
+        return FS_EINVAL;
     }
     
     if (argv[1][0] == ':' && argv[2][0] != ':') {
@@ -848,7 +852,7 @@ do_copy(int argc, char **argv)
 
     printf("can't copy around inside of the file system (only in and out)\n");
 
-	return EINVAL;
+	return FS_EINVAL;
 }
 
 
@@ -868,7 +872,7 @@ copydir(char *fromPath,char *toPath)
 	from = opendir(fromPath);
 	if (from == NULL) {
 		printf("could not open %s\n", fromPath);
-		return B_ENTRY_NOT_FOUND;
+		return FS_ENTRY_NOT_FOUND;
 	}
 
 	myfs_name = (char*)malloc(1024);
@@ -876,7 +880,7 @@ copydir(char *fromPath,char *toPath)
 	buff = (char*)malloc(bufferSize);
 	if (myfs_name == NULL || from_name == NULL || buff == NULL) {
 		printf("out of memory\n");
-		return B_NO_MEMORY;
+		return FS_NO_MEMORY;
 	}
 
 	while ((dirent = readdir(from)) != NULL) {
@@ -901,10 +905,10 @@ copydir(char *fromPath,char *toPath)
 			strcat(path, "/");
 			strcat(path, dirent->d_name);
 
-			if ((err = sys_mkdir(1, -1, path, MY_S_IRWXU)) == B_OK)
+			if ((err = sys_mkdir(1, -1, path, MY_S_IRWXU)) == FS_OK)
 				copydir(from_name, path);
 			else
-				printf("Could not create directory %s: (%s)\n", path, strerror(err));
+				printf("Could not create directory %s: (%s)\n", path, fs_strerror(err));
 		} else {
 			fd = open(from_name, O_RDONLY);
 			if (fd < 0) {
@@ -936,15 +940,15 @@ copydir(char *fromPath,char *toPath)
 
 					bytesRead = fs_read_attr(fd, attr->d_name, attrInfo.type, 0, buff, size);
 					if (bytesRead < size) {
-						printf("could not read attribute %s: %s\n", attr->d_name, strerror(bytesRead));
+						printf("could not read attribute %s: %s\n", attr->d_name, fs_strerror(bytesRead));
 						continue;
 					}
 					buff[size] = '\0';
 
 				    err = sys_write_attr(1, bfd, attr->d_name, attrInfo.type, buff, size, 0);
-					if (err < B_OK) {
+					if (err < FS_OK) {
 						printf("write attr (\"%s\", type = %p, %p, %ld bytes) failed: %s\n",
-							attr->d_name, (void *)attrInfo.type, buff, size, strerror(err));
+							attr->d_name, (void *)attrInfo.type, buff, size, fs_strerror(err));
 						continue;
 					}
 				}
@@ -963,7 +967,7 @@ copydir(char *fromPath,char *toPath)
 			}
 
 			if (err < 0) {
-				printf("write error: err == %d, amt == %ld\n", err, amt);
+				printf("write error: err == %d, amt == %ld\n", err, (long)amt);
 			}
 
 			sys_close(1, bfd);
@@ -973,7 +977,7 @@ copydir(char *fromPath,char *toPath)
 	closedir(from);
 
 	free(myfs_name);  free(from_name);  free(buff);
-	return B_OK;
+	return FS_OK;
 }
 
 
@@ -984,7 +988,7 @@ do_copytest(int argc, char **argv)
 
 	if (argc > 2) {
 		printf("usage: copytest <path>");
-		return EINVAL;
+		return FS_EINVAL;
 	} else if (argc == 2)
 		fromPath = argv[1];
 	else
@@ -1060,7 +1064,7 @@ do_tracker(int argc, char **argv)
 {
 	static thread_id thread = -1;
 
-	if (thread < B_OK) {
+	if (thread < FS_OK) {
 		puts("starting tracker...");
 
 		thread = spawn_thread(tracker_loop, "tracker", B_NORMAL_PRIORITY, NULL);
@@ -1092,7 +1096,7 @@ stat_thread(void *data)
 	(void)data;
 
 	while (sRunStatTest) {
-		struct stat st;
+		struct my_stat st;
 		sys_rstat(1, -1, sStatTestFile, &st, 0);
 	}
 	return 0;
@@ -1157,7 +1161,7 @@ do_attrtest(int argc, char **argv)
 
     if (cur_fd < 0) {
         printf("no file open! (open or create one with open or make)\n");
-        return EINVAL;
+        return FS_EINVAL;
     }
     if (argc > 1 && isdigit(*argv[1]))
     	iterations = atol(argv[1]);
@@ -1165,7 +1169,7 @@ do_attrtest(int argc, char **argv)
     	maxSize = atol(argv[2]);
     if ((argc > 1 && !isdigit(*argv[1])) || (argc > 2 && !isdigit(*argv[2]))) {
     	printf("usage: attrs [number of iterations] [max attr size]\n");
-    	return EINVAL;
+    	return FS_EINVAL;
     }
 
 	buffer = (char*)malloc(1024);
@@ -1184,7 +1188,7 @@ do_attrtest(int argc, char **argv)
 
 		err = sys_write_attr(1, cur_fd, name, 'CSTR', buffer, length, 0);
 		if (err < length)
-			printf("error writing attribute: %s\n", strerror(err));
+			printf("error writing attribute: %s\n", fs_strerror(err));
 	}
 
 	free(buffer);
@@ -1204,7 +1208,7 @@ do_rename(int argc, char **argv)
 
     if (argc < 3) {
         printf("rename needs two arguments!\n");
-        return EINVAL;
+        return FS_EINVAL;
     }
     
     strcpy(oldname, "/myfs/");
@@ -1215,7 +1219,7 @@ do_rename(int argc, char **argv)
 
     err = sys_rename(1, -1, oldname, -1, newname);
     if (err)
-        printf("rename failed with err: %s\n", strerror(err));
+        printf("rename failed with err: %s\n", fs_strerror(err));
 
 	return err;
 }
@@ -1230,7 +1234,7 @@ do_symlink(int argc, char **argv)
 
 	if (argc < 3) {
 		printf("usage: symlink <source> <target>\n");
-		return EINVAL;
+		return FS_EINVAL;
 	}
 
 	source = argv[1];
@@ -1239,8 +1243,8 @@ do_symlink(int argc, char **argv)
 	strcpy(target + 6, argv[2]);
 
 	status = sys_symlink(1, source, -1, target);
-	if (status != B_OK)
-		printf("symlink failed with error: %s\n", strerror(status));
+	if (status != FS_OK)
+		printf("symlink failed with error: %s\n", fs_strerror(status));
 
 	return status;
 }
@@ -1254,7 +1258,7 @@ do_sync(int argc, char **argv)
     err = sys_sync();
     
     if (err)
-        printf("sync failed with err %s\n", strerror(err));
+        printf("sync failed with err %s\n", fs_strerror(err));
 
 	return err;
 }
@@ -1298,7 +1302,7 @@ do_stopquery(int argc, char **argv)
 
 	if (gQueryCookie == NULL) {
 		printf("no query running (use the 'startquery' command to start a query).\n");
-		return EINVAL;
+		return FS_EINVAL;
 	}
 
 	if (argc == 2)
@@ -1316,7 +1320,7 @@ do_stopquery(int argc, char **argv)
 
 		err = sys_close_query(true, -1, "/myfs/.", gQueryCookie[min]);
 		if (err < 0) {
-			printf("could not close query: %s\n", strerror(err));
+			printf("could not close query: %s\n", fs_strerror(err));
 			return err;
 		}
 		gQueryCookie[min] = NULL;
@@ -1340,18 +1344,18 @@ do_startquery(int argc, char **argv)
 	}
 	if (freeSlot == MAX_LIVE_QUERIES) {
 		printf("All query slots are used, stop some\n");
-		return EINVAL;
+		return FS_EINVAL;
 	}
 
 	if (argc != 2) {
 		printf("query string expected\n");
-		return EINVAL;
+		return FS_EINVAL;
 	}
 	query = argv[1];
 
 	err = sys_open_query(true, -1, "/myfs/.", query, B_LIVE_QUERY, freeSlot, freeSlot, &gQueryCookie[freeSlot]);
 	if (err < 0) {
-		printf("could not open query: %s\n", strerror(err));
+		printf("could not open query: %s\n", fs_strerror(err));
 		return err;
 	}
 
@@ -1366,7 +1370,7 @@ static int
 do_query(int argc, char **argv)
 {
 	char buffer[2048];
-	struct dirent *dent = (struct dirent *)buffer;
+	struct my_dirent *dent = (struct my_dirent *)buffer;
 	void *cookie;
 	char *query;
 	int max_err = 10;
@@ -1374,14 +1378,14 @@ do_query(int argc, char **argv)
 
 	if (argc != 2) {
 		printf("query string expected");
-		return EINVAL;
+		return FS_EINVAL;
 	}
 	query = argv[1];
 
 	err = sys_open_query(true, -1, "/myfs/.", query, 0, 42, 42, &cookie);
 	if (err < 0) {
-		printf("could not open query: %s\n", strerror(err));
-		return EINVAL;
+		printf("could not open query: %s\n", fs_strerror(err));
+		return FS_EINVAL;
 	}
 	
 	while (true) {
@@ -1402,7 +1406,7 @@ do_query(int argc, char **argv)
 
 	err = sys_close_query(true, -1, "/myfs/.", cookie);
 	if (err < 0) {
-		printf("could not close query: %s\n", strerror(err));
+		printf("could not close query: %s\n", fs_strerror(err));
 		return err;
 	}
 
@@ -1457,8 +1461,8 @@ do_cio(int argc, char **argv)
     gettimeofday(&end, NULL);
     SubTime(&end, &start, &result);
         
-    printf("read %ld bytes in %2ld.%.6ld seconds\n",
-           (MAX_ITER * NUM_READS * sizeof(buff)) / 1024,
+    printf("read %lu bytes in %2ld.%.6ld seconds\n",
+           (unsigned long)((MAX_ITER * NUM_READS * sizeof(buff)) / 1024),
            result.tv_sec, result.tv_usec);
 
 
@@ -1484,7 +1488,7 @@ mkfile(char *s, int sz)
 
 	buffer = (char*)malloc(16 * 1024);
 	if (buffer == NULL)
-		return ENOMEM;
+		return FS_ENOMEM;
 
     len = sz;
     if (sz) {
@@ -1544,8 +1548,8 @@ do_create(int argc, char **argv)
 
     sprintf(name, "/myfs/test");
     err = sys_mkdir(1, -1, name, MY_S_IRWXU);
-    if (err && err != EEXIST)
-        printf("mkdir of %s returned: %s (%d)\n", name, strerror(err), err);
+    if (err && err != FS_EEXIST)
+        printf("mkdir of %s returned: %s (%d)\n", name, fs_strerror(err), err);
 
     if (argc > 1)
         iter = strtoul(&argv[1][0], NULL, 0);
@@ -1700,16 +1704,20 @@ do_fsh(void)
 
         len = strlen(&argv[0][0]);
 
-	    for (cmd_entry **commands = fsh_commands; *commands; commands++) {
-		    cmd_entry *cmd = *commands;
+	    bool done = false;
+		for (cmd_entry **commands = fsh_commands;
+			 !done && *commands;
+			 commands++) {
+		    cmd = *commands;
 		    for (; cmd->name != NULL; cmd++) {
-	            if (strncmp(cmd->name, &argv[0][0], len) == 0) {
+				if (strncmp(cmd->name, &argv[0][0], len) == 0) {
 	                int result = cmd->func(argc, argv);
 	
 					if (!sInteractiveMode)
-						reply_to_external_command(result);
+						reply_to_external_command(to_platform_error(result));
 	
-	                break;
+					done = true;
+					break;
 	            }
 	        }
 	    }
@@ -1721,7 +1729,7 @@ do_fsh(void)
             break;
         }
 
-        if (cmd->name == NULL && argv[0][0] != '\0') {
+        if ((cmd == NULL || cmd->name == NULL) && argv[0][0] != '\0') {
             printf("command `%s' not understood\n", &argv[0][0]);
 
 			if (!sInteractiveMode)

src/tests/add-ons/kernel/file_systems/fs_shell/fsproto.h

@@ -6,12 +6,14 @@
 #ifndef _FSPROTO_H
 #define _FSPROTO_H
 
-#include <sys/dirent.h>
+#include "compat.h"
+
+#include <dirent.h>
 #include <sys/types.h>
 #include <sys/param.h>
 #include <sys/stat.h>
 #include <unistd.h>
-#include <iovec.h>
+#include <sys/uio.h>
 
 #include <OS.h>
 #include <NodeMonitor.h>
@@ -19,10 +21,9 @@
 #include <fs_info.h>
 #include <BeBuild.h>
 #include <Drivers.h>
-#include "compat.h"
 
-typedef dev_t		nspace_id;
-typedef ino_t		vnode_id;
+typedef my_dev_t		nspace_id;
+typedef my_ino_t		vnode_id;
 
 /*
  * PUBLIC PART OF THE FILE SYSTEM PROTOCOL
@@ -90,25 +91,25 @@ typedef int op_opendir(void *ns, void *node, void **cookie);
 typedef int	op_closedir(void *ns, void *node, void *cookie);
 typedef int	op_rewinddir(void *ns, void *node, void *cookie);
 typedef int	op_readdir(void *ns, void *node, void *cookie, long *num,
-					struct dirent *buf, size_t bufsize);
+					struct my_dirent *buf, size_t bufsize);
 
 typedef int	op_open(void *ns, void *node, int omode, void **cookie);
 typedef int	op_close(void *ns, void *node, void *cookie);
 typedef int op_free_cookie(void *ns, void *node, void *cookie);
-typedef int op_read(void *ns, void *node, void *cookie, off_t pos, void *buf,
+typedef int op_read(void *ns, void *node, void *cookie, fs_off_t pos, void *buf,
 					size_t *len);
-typedef int op_write(void *ns, void *node, void *cookie, off_t pos,
+typedef int op_write(void *ns, void *node, void *cookie, fs_off_t pos,
 					const void *buf, size_t *len);
-typedef int op_readv(void *ns, void *node, void *cookie, off_t pos, const iovec *vec,
+typedef int op_readv(void *ns, void *node, void *cookie, fs_off_t pos, const iovec *vec,
 					size_t count, size_t *len);
-typedef int op_writev(void *ns, void *node, void *cookie, off_t pos, const iovec *vec,
+typedef int op_writev(void *ns, void *node, void *cookie, fs_off_t pos, const iovec *vec,
 					size_t count, size_t *len);
 typedef int	op_ioctl(void *ns, void *node, void *cookie, int cmd, void *buf,
 					size_t len);
 typedef	int	op_setflags(void *ns, void *node, void *cookie, int flags);
 
-typedef int	op_rstat(void *ns, void *node, struct stat *);
-typedef int op_wstat(void *ns, void *node, struct stat *, long mask);
+typedef int	op_rstat(void *ns, void *node, struct my_stat *);
+typedef int op_wstat(void *ns, void *node, struct my_stat *, long mask);
 typedef int	op_fsync(void *ns, void *node);
 
 typedef int	op_select(void *ns, void *node, void *cookie, uint8 event,
@@ -129,7 +130,7 @@ typedef int	op_open_attrdir(void *ns, void *node, void **cookie);
 typedef int	op_close_attrdir(void *ns, void *node, void *cookie);
 typedef int	op_rewind_attrdir(void *ns, void *node, void *cookie);
 typedef int	op_read_attrdir(void *ns, void *node, void *cookie, long *num,
-					struct dirent *buf, size_t bufsize);
+					struct my_dirent *buf, size_t bufsize);
 typedef int	op_remove_attr(void *ns, void *node, const char *name);
 typedef	int	op_rename_attr(void *ns, void *node, const char *oldname,
 					const char *newname);
@@ -137,15 +138,15 @@ typedef int	op_stat_attr(void *ns, void *node, const char *name,
 					struct attr_info *buf);
 
 typedef int	op_write_attr(void *ns, void *node, const char *name, int type,
-					const void *buf, size_t *len, off_t pos);
+					const void *buf, size_t *len, fs_off_t pos);
 typedef int	op_read_attr(void *ns, void *node, const char *name, int type,
-					void *buf, size_t *len, off_t pos);
+					void *buf, size_t *len, fs_off_t pos);
 
 typedef int	op_open_indexdir(void *ns, void **cookie);
 typedef int	op_close_indexdir(void *ns, void *cookie);
 typedef int	op_rewind_indexdir(void *ns, void *cookie);
 typedef int	op_read_indexdir(void *ns, void *cookie, long *num,
-					struct dirent *buf, size_t bufsize);
+					struct my_dirent *buf, size_t bufsize);
 typedef int	op_create_index(void *ns, const char *name, int type, int flags);
 typedef int	op_remove_index(void *ns, const char *name);
 typedef	int	op_rename_index(void *ns, const char *oldname, 
@@ -156,7 +157,7 @@ typedef int	op_open_query(void *ns, const char *query, ulong flags,
 					port_id port, long token, void **cookie);
 typedef int	op_close_query(void *ns, void *cookie);
 typedef int	op_read_query(void *ns, void *cookie, long *num,
-					struct dirent *buf, size_t bufsize);
+					struct my_dirent *buf, size_t bufsize);
 
 typedef struct vnode_ops {
 	op_read_vnode			(*read_vnode);

src/tests/add-ons/kernel/file_systems/fs_shell/kernel.c

@@ -639,14 +639,14 @@ sys_chdir(bool kernel, int fd, const char *path)
         goto error1;
     op = vn->ns->fs->ops.rstat;
     if (!op) {
-        err = EINVAL;
+        err = FS_EINVAL;
         goto error2;
     }
     err = (*op)(vn->ns->data, vn->data, &st);
     if (err)
         goto error2;
-    if (!MY_S_ISDIR(st.st_mode)) {
-        err = ENOTDIR;
+    if (!MY_S_ISDIR(st.mode)) {
+        err = FS_ENOTDIR;
         goto error2;
     }
     io = get_cur_ioctx();
@@ -680,7 +680,7 @@ sys_access(bool kernel, int fd, const char *path, int mode)
         goto error1;
     op = vn->ns->fs->ops.access;
     if (!op) {
-        err = EINVAL;
+        err = FS_EINVAL;
         goto error2;
     }
     err = (*op)(vn->ns->data, vn->data, mode);
@@ -716,7 +716,7 @@ sys_symlink(bool kernel, const char *oldpath, int nfd, const char *newpath)
         goto error2;
     op = dvn->ns->fs->ops.symlink;
     if (!op) {
-        err = EINVAL;
+        err = FS_EINVAL;
         goto error3;
     }
     err = (*op)(dvn->ns->data, dvn->data, filename, buf);
@@ -753,7 +753,7 @@ sys_readlink(bool kernel, int fd, const char *path, char *buf, size_t bufsize)
         goto error1;
     op = vn->ns->fs->ops.readlink;
     if (!op) {
-        err = EINVAL;
+        err = FS_EINVAL;
         goto error2;
     }
     sz = bufsize;
@@ -787,7 +787,7 @@ sys_mkdir(bool kernel, int fd, const char *path, int perms)
         goto error1;
     op = dvn->ns->fs->ops.mkdir;
     if (!op) {
-        err = EINVAL;
+        err = FS_EINVAL;
         goto error2;
     }
     err = (*op)(dvn->ns->data, dvn->data, filename, perms);
@@ -825,7 +825,7 @@ sys_opendir(bool kernel, int fd, const char *path, bool coe)
         goto error1;
     op = vn->ns->fs->ops.opendir;
     if (!op) {
-        err = EINVAL;
+        err = FS_EINVAL;
         goto error2;
     }
     err = (*op)(vn->ns->data, vn->data, &cookie);
@@ -838,7 +838,7 @@ sys_opendir(bool kernel, int fd, const char *path, bool coe)
 
     f = (ofile *) calloc(sizeof(ofile), 1);
     if (!f) {
-        err = ENOMEM;
+        err = FS_ENOMEM;
         goto error3;
     }
 
@@ -850,7 +850,7 @@ sys_opendir(bool kernel, int fd, const char *path, bool coe)
 
     nfd = new_fd(kernel, -1, f, -1, coe);
     if (nfd < 0) {
-        err = EMFILE;
+        err = FS_EMFILE;
         goto error4;
     }
 
@@ -903,7 +903,7 @@ sys_readdir(bool kernel, int fd, struct my_dirent *buf, size_t bufsize,
 
     f = get_fd(kernel, fd, FD_DIR);
     if (!f) {
-        err = EBADF;
+        err = FS_EBADF;
         goto error1;
     }
     vn = f->vn;
@@ -913,7 +913,12 @@ sys_readdir(bool kernel, int fd, struct my_dirent *buf, size_t bufsize,
     if (err)
         goto error1;
 
-    /*
+		
+	// set d_pdev and d_pino
+	buf->d_pdev = vn->ns->nsid;
+	buf->d_pino = vn->vnid;
+    
+	/*
     patch the mount points and the root.
     */
 
@@ -929,7 +934,7 @@ sys_readdir(bool kernel, int fd, struct my_dirent *buf, size_t bufsize,
             if (err)
                 goto error2;
             LOCK(vnlock);
-            p->d_ino = st.st_ino;
+            p->d_ino = st.ino;
         }
         p = (struct my_dirent *) ((char *) p + p->d_reclen);
     }
@@ -958,7 +963,7 @@ sys_rewinddir(bool kernel, int fd)
 
     f = get_fd(kernel, fd, FD_DIR);
     if (!f)
-        return EBADF;
+        return FS_EBADF;
     vn = f->vn;
     err = (*vn->ns->fs->ops.rewinddir)(vn->ns->data, vn->data, f->cookie);
     put_fd(f);
@@ -991,7 +996,7 @@ sys_open(bool kernel, int fd, const char *path, int omode, int perms,
             goto errorA;
         opc = dvn->ns->fs->ops.create;
         if (!opc) {
-            err = EINVAL;
+            err = FS_EINVAL;
             goto errorB;
         }
         err = (*opc)(dvn->ns->data, dvn->data, filename, omode, perms, &vnid,
@@ -1009,7 +1014,7 @@ sys_open(bool kernel, int fd, const char *path, int omode, int perms,
             goto error1;
         opo = vn->ns->fs->ops.open;
         if (!opo) {
-            err = EINVAL;
+            err = FS_EINVAL;
             goto error2;
         }
         err = (*opo)(vn->ns->data, vn->data, omode, &cookie);
@@ -1023,7 +1028,7 @@ sys_open(bool kernel, int fd, const char *path, int omode, int perms,
 
     f = (ofile *) calloc(sizeof(ofile), 1);
     if (!f) {
-        err = ENOMEM;
+        err = FS_ENOMEM;
         goto error3;
     }
 
@@ -1037,7 +1042,7 @@ sys_open(bool kernel, int fd, const char *path, int omode, int perms,
 
     nfd = new_fd(kernel, -1, f, -1, coe);
     if (nfd < 0) {
-        err = EMFILE;
+        err = FS_EMFILE;
         goto error4;
     }
 
@@ -1088,7 +1093,7 @@ sys_open_entry_ref(bool kernel, nspace_id device, vnode_id parent, const char *n
 
 	opo = vn->ns->fs->ops.open;
 	if (!opo) {
-		err = EINVAL;
+		err = FS_EINVAL;
 		goto error1;
 	}
 	err = (*opo)(vn->ns->data, vn->data, openMode, &cookie);
@@ -1101,7 +1106,7 @@ sys_open_entry_ref(bool kernel, nspace_id device, vnode_id parent, const char *n
 
 	f = (ofile *)calloc(sizeof(ofile), 1);
     if (!f) {
-		err = ENOMEM;
+		err = FS_ENOMEM;
 		goto error2;
 	}
 
@@ -1115,7 +1120,7 @@ sys_open_entry_ref(bool kernel, nspace_id device, vnode_id parent, const char *n
 
 	nfd = new_fd(kernel, -1, f, -1, coe);
 	if (nfd < 0) {
-		err = EMFILE;
+		err = FS_EMFILE;
 		goto error3;
 	}
 
@@ -1161,7 +1166,7 @@ sys_lseek(bool kernel, int fd, fs_off_t pos, int whence)
     
     f = get_fd(kernel, fd, FD_FILE);
     if (!f) {
-        err = EBADF;
+        err = FS_EBADF;
         goto error1;
     }
     switch(whence) {
@@ -1175,13 +1180,13 @@ sys_lseek(bool kernel, int fd, fs_off_t pos, int whence)
             vn = f->vn;
             op = vn->ns->fs->ops.rstat;
             if (!op) {
-                err = EINVAL;
+                err = FS_EINVAL;
                 goto error2;
             }
             err = (*op)(vn->ns->data, vn->data, &st);
             if (err)
                 goto error2;
-            pos += st.st_size;
+            pos += st.size;
             f->pos = pos;
             break;
         }
@@ -1190,23 +1195,23 @@ sys_lseek(bool kernel, int fd, fs_off_t pos, int whence)
         vn = f->vn;
         op = vn->ns->fs->ops.rstat;
         if (!op) {
-            err = EINVAL;
+            err = FS_EINVAL;
             goto error2;
         }
         err = (*op)(vn->ns->data, vn->data, &st);
         if (err)
             goto error2;
-        pos += st.st_size;
+        pos += st.size;
         f->pos = pos;
         break;
     default:
         put_fd(f);
-        return EINVAL;
+        return FS_EINVAL;
     }
 
     if (f->pos < 0) {
         f->pos = 0;
-        err = EINVAL;
+        err = FS_EINVAL;
         goto error2;
     }
 
@@ -1237,11 +1242,11 @@ sys_read(bool kernel, int fd, void *buf, size_t len)
 
     f = get_fd(kernel, fd, FD_FILE);
     if (!f) {
-        err = EBADF;
+        err = FS_EBADF;
         goto error1;
     }
     if ((f->omode & OMODE_MASK) == O_WRONLY) {
-        err = EBADF;
+        err = FS_EBADF;
         goto error2;
     }
     vn = f->vn;
@@ -1283,11 +1288,11 @@ sys_write(bool kernel, int fd, void *buf, size_t len)
 
     f = get_fd(kernel, fd, FD_FILE);
     if (!f) {
-        err = EBADF;
+        err = FS_EBADF;
         goto error1;
     }
     if ((f->omode & OMODE_MASK) == O_RDONLY) {
-        err = EBADF;
+        err = FS_EBADF;
         goto error2;
     }
     vn = f->vn;
@@ -1324,7 +1329,7 @@ sys_read_attr(bool kernel, int fd, const char *name, int type, void *buffer, siz
 
     f = get_fd(kernel, fd, FD_FILE);
     if (!f) {
-        err = EBADF;
+        err = FS_EBADF;
         goto error1;
     }
 
@@ -1355,7 +1360,7 @@ sys_write_attr(bool kernel, int fd, const char *name,int type,void *buffer, size
 
     f = get_fd(kernel, fd, FD_FILE);
     if (!f) {
-        err = EBADF;
+        err = FS_EBADF;
         goto error1;
     }
 
@@ -1384,7 +1389,7 @@ sys_remove_attr(bool kernel, int fd, const char *name)
 
     f = get_fd(kernel, fd, FD_FILE);
     if (!f) {
-        err = EBADF;
+        err = FS_EBADF;
         goto error1;
     }
 
@@ -1418,7 +1423,7 @@ sys_ioctl(bool kernel, int fd, int cmd, void *arg, size_t sz)
 
     f = get_fd(kernel, fd, FD_FILE);
     if (!f) {
-        err = EBADF;
+        err = FS_EBADF;
         goto error1;
     }
     vn = f->vn;
@@ -1426,7 +1431,7 @@ sys_ioctl(bool kernel, int fd, int cmd, void *arg, size_t sz)
     if (op)
         err = (*op)(vn->ns->data, vn->data, f->cookie, cmd, arg, sz);
     else
-        err = EINVAL;
+        err = FS_EINVAL;
     if (err)
         goto error2;
 
@@ -1461,12 +1466,12 @@ sys_link(bool kernel, int ofd, const char *oldpath, int nfd,
         goto error2;
 
     if (vn->ns != dvn->ns) {
-        err = EXDEV;
+        err = FS_EXDEV;
         goto error3;
     }
     op = dvn->ns->fs->ops.link;
     if (!op) {
-        err = EINVAL;
+        err = FS_EINVAL;
         goto error3;
     }
     err = (*op)(dvn->ns->data, dvn->data, filename, vn->data);
@@ -1503,7 +1508,7 @@ sys_unlink(bool kernel, int fd, const char *path)
 
     op = dvn->ns->fs->ops.unlink;
     if (!op) {
-        err = EINVAL;
+        err = FS_EINVAL;
         goto error2;
     }
     err = (*op)(dvn->ns->data, dvn->data, filename);
@@ -1538,7 +1543,7 @@ sys_rmdir(bool kernel, int fd, const char *path)
 
     op = dvn->ns->fs->ops.rmdir;
     if (!op) {
-        err = EINVAL;
+        err = FS_EINVAL;
         goto error2;
     }
     err = (*op)(dvn->ns->data, dvn->data, filename);
@@ -1575,13 +1580,13 @@ sys_rename(bool kernel, int ofd, const char *oldpath,
         goto error2;
     
     if (odvn->ns != ndvn->ns) {
-        err = EXDEV;
+        err = FS_EXDEV;
         goto error2;
     }
 
     op = odvn->ns->fs->ops.rename;
     if (!op) {
-        err = EINVAL;
+        err = FS_EINVAL;
         goto error3;
     }
     err = (*op)(odvn->ns->data, odvn->data, oldname, ndvn->data, newname);
@@ -1619,7 +1624,7 @@ sys_rstat(bool kernel, int fd, const char *path, struct my_stat *st, bool eatlin
         goto error1;
     op = vn->ns->fs->ops.rstat;
     if (!op) {
-        err = EINVAL;
+        err = FS_EINVAL;
         goto error2;
     }
     err = (*op)(vn->ns->data, vn->data, st);
@@ -1652,7 +1657,7 @@ sys_wstat(bool kernel, int fd, const char *path, struct my_stat *st, long mask,
         goto error1;
     op = vn->ns->fs->ops.wstat;
     if (!op) {
-        err = EINVAL;
+        err = FS_EINVAL;
         goto error2;
     }
     err = (*op)(vn->ns->data, vn->data, st, mask);
@@ -1741,7 +1746,7 @@ add_nspace(nspace *ns, fsystem *fs, const char *fileSystem, dev_t dev, ino_t ino
 	if (fileSystem != NULL)
 		fs = inc_file_system(fileSystem);
 	if (!fs)
-		return ENODEV;
+		return FS_ENODEV;
 
 	for (i = 0; i < nns; i++, nxnsid++) {
 		if (!nstab[nxnsid % nns]) {
@@ -1753,7 +1758,7 @@ add_nspace(nspace *ns, fsystem *fs, const char *fileSystem, dev_t dev, ino_t ino
 	}
 	if (i == nns) {
 		dec_file_system(fs);
-		return EMFILE;
+		return FS_EMFILE;
 	}
 
 	nstab[ns->nsid % nns] = ns;
@@ -1772,7 +1777,7 @@ add_nspace(nspace *ns, fsystem *fs, const char *fileSystem, dev_t dev, ino_t ino
 		nshead->prev = ns;
 	nshead = ns;
 
-	return B_OK;
+	return FS_OK;
 }
 
 
@@ -1812,20 +1817,20 @@ sys_mount(bool kernel, const char *filesystem, int fd, const char *where,
     err = (*mount->ns->fs->ops.rstat)(mount->ns->data, mount->data, &mst);
     if (err)
         goto error2;
-    if (!MY_S_ISDIR(mst.st_mode)) {
-        err = ENOTDIR;
+    if (!MY_S_ISDIR(mst.mode)) {
+        err = FS_ENOTDIR;
         goto error2;
     }
 
     ns = (nspace *)malloc(sizeof(nspace));
     if (!ns) {
-        err = ENOMEM;
+        err = FS_ENOMEM;
         goto error2;
     }
 
     fs = inc_file_system(filesystem);
     if (!fs) {
-        err = ENODEV;
+        err = FS_ENODEV;
         goto error3;
     }
 
@@ -1837,7 +1842,7 @@ sys_mount(bool kernel, const char *filesystem, int fd, const char *where,
                 UNLOCK(vnlock);
 				printf("KERNEL: trying to mount %s twice (already mounted as %s)\n",
 					device, ans->fs->name);
-                err = ENODEV;
+                err = FS_ENODEV;
                 goto error4;
             }
     }
@@ -1846,7 +1851,7 @@ sys_mount(bool kernel, const char *filesystem, int fd, const char *where,
 
     UNLOCK(vnlock);
 
-	if (err != B_OK)
+	if (err != FS_OK)
 		goto error5;
 
     err = (*fs->ops.mount)(ns->nsid, device, flags, parms, len, &data, &vnid);
@@ -1858,7 +1863,7 @@ sys_mount(bool kernel, const char *filesystem, int fd, const char *where,
     ns->data = data;
     
     if ((mount == rootvn) || (mount->mounted)) {
-        err = EBUSY;
+        err = FS_EBUSY;
         goto error6;
     }
     mount->mounted = ns;
@@ -1907,7 +1912,7 @@ sys_unmount(bool kernel, int fd, const char *where)
     ns = root->ns;
     fs = ns->fs;
     if (ns->root != root) {
-        err = EINVAL;
+        err = FS_EINVAL;
         goto error2;
     }
 
@@ -1917,7 +1922,7 @@ sys_unmount(bool kernel, int fd, const char *where)
     */
 
     if (root == rootvn) {
-        err = EBUSY;
+        err = FS_EBUSY;
         goto error2;
     }
 
@@ -1929,7 +1934,7 @@ sys_unmount(bool kernel, int fd, const char *where)
 
     for(vn = ns->vnodes.head; vn; vn = vn->nspace.next)
         if (vn->busy || (vn->rcnt != 0)) {
-            err = EBUSY;
+            err = FS_EBUSY;
             goto error3;
         }
 
@@ -1973,11 +1978,11 @@ sys_open_query(bool kernel, int fd, const char *path, const char *query, ulong f
 	ns = root->ns;
 	fs = ns->fs;
 	if (ns->root != root)
-		return EINVAL;
+		return FS_EINVAL;
 
 	if (fs->ops.open_query == NULL) {
 		dec_vnode(root, FALSE);
-		return EPERM;
+		return FS_EPERM;
 	}
 	err = (*fs->ops.open_query)(ns->data, query, flags, port, token, cookie);
 	TRACE("sys_open_query() -- end: %d\n",err);
@@ -2002,11 +2007,11 @@ sys_close_query(bool kernel, int fd, const char *path, void *cookie)
     ns = root->ns;
     fs = ns->fs;
     if (ns->root != root)
-        return EINVAL;
+        return FS_EINVAL;
 
 	if (fs->ops.close_query == NULL) {
 		dec_vnode(root, FALSE);
-		return EPERM;
+		return FS_EPERM;
 	}
 	
 	err = (*fs->ops.close_query)(ns->data, cookie);
@@ -2019,7 +2024,7 @@ sys_close_query(bool kernel, int fd, const char *path, void *cookie)
 
 
 int
-sys_read_query(bool kernel, int fd, const char *path, void *cookie,struct dirent *dent,size_t bufferSize,long count)
+sys_read_query(bool kernel, int fd, const char *path, void *cookie,struct my_dirent *dent,size_t bufferSize,long count)
 {
 	int		err;
 	nspace	*ns;
@@ -2034,11 +2039,11 @@ sys_read_query(bool kernel, int fd, const char *path, void *cookie,struct dirent
     ns = root->ns;
     fs = ns->fs;
     if (ns->root != root)
-        return EINVAL;
+        return FS_EINVAL;
 
 	if (fs->ops.close_query == NULL) {
 		dec_vnode(root, FALSE);
-		return EPERM;
+		return FS_EPERM;
 	}
 
 	num = count;
@@ -2149,7 +2154,7 @@ parse_path_fd(bool kernel, int fd, char **pstart, int eatsymlink, vnode **vnp)
         if (fd >= 0) {
             f = get_fd(kernel, fd, FD_ALL);
             if (!f)
-                return EBADF;
+                return FS_EBADF;
             bvn = f->vn;
             inc_vnode(bvn);
             put_fd(f);
@@ -2279,14 +2284,14 @@ parse_path(vnode *bvn, char **pstart, char *path, int eatsymlink, vnode **vnp)
             iter++;
             if (iter > MAX_SYM_LINKS) {
                 dec_vnode(vn, FALSE);
-                err = ELOOP;
+                err = FS_ELOOP;
                 break;
             }
 
             p = cat_paths(newpath, np);
             if (!p) {
                 dec_vnode(vn, FALSE);
-                err = ENOMEM;
+                err = FS_ENOMEM;
                 break;
             }
             free_path(*pstart);
@@ -2356,7 +2361,7 @@ put_vnode(nspace_id nsid, vnode_id vnid)
     vn = lookup_vnode(nsid, vnid);
     if (!vn) {
         UNLOCK(vnlock);
-        return ENOENT;
+        return FS_ENOENT;
     }
     UNLOCK(vnlock);
     dec_vnode(vn, TRUE);
@@ -2410,7 +2415,7 @@ restart:
         if (!vn) {
             PANIC("OUT OF VNODE!!!\n");
             UNLOCK(vnlock);
-            return ENOMEM;
+            return FS_ENOMEM;
         }
         flush_vnode(vn, TRUE);
     }
@@ -2418,7 +2423,7 @@ restart:
     vn->ns = nsidtons(nsid);
     if (!vn->ns) {
         UNLOCK(vnlock);
-        return ENOENT;
+        return FS_ENOENT;
     }
     vn->vnid = vnid;
     vn->data = data;
@@ -2441,7 +2446,7 @@ remove_vnode(nspace_id nsid, vnode_id vnid)
     vn = lookup_vnode(nsid, vnid);
     if (!vn || (vn->rcnt == 0)) {
         UNLOCK(vnlock);
-        return ENOENT;
+        return FS_ENOENT;
     }
     vn->remove = TRUE;
     UNLOCK(vnlock);
@@ -2461,7 +2466,7 @@ unremove_vnode(nspace_id nsid, vnode_id vnid)
     vn = lookup_vnode(nsid, vnid);
     if (!vn || (vn->rcnt == 0)) {
         UNLOCK(vnlock);
-        return ENOENT;
+        return FS_ENOENT;
     }
     vn->remove = FALSE;
     UNLOCK(vnlock);
@@ -2482,7 +2487,7 @@ is_vnode_removed(nspace_id nsid, vnode_id vnid)
     vn = lookup_vnode(nsid, vnid);
     if (!vn) {
         UNLOCK(vnlock);
-        return ENOENT;
+        return FS_ENOENT;
     }
     res = vn->remove;
     UNLOCK(vnlock);
@@ -2563,7 +2568,7 @@ static int
 sort_vnode(vnode *vn)
 {
     if (!InsertSL(skiplist, vn))
-        return ENOMEM;
+        return FS_ENOMEM;
 
     vn->nspace.next = vn->ns->vnodes.head;
     vn->nspace.prev = NULL;
@@ -2671,7 +2676,7 @@ load_vnode(nspace_id nsid, vnode_id vnid, char r, vnode **vnp)
     if (vn->ns == NULL) {
         vn->ns = nsidtons(nsid);
         if (!vn->ns) {
-            err = ENOENT;
+            err = FS_ENOENT;
             goto error1;
         }
         vn->vnid = vnid;
@@ -2739,13 +2744,13 @@ new_path(const char *path, char **copy)
     }
     l = strlen(path);
     if (l == 0)
-        return ENOENT;
+        return FS_ENOENT;
     s = l;
     if (path[l-1] == '/')
         s++;
 
     if (l >= MAXPATHLEN)
-        return ENAMETOOLONG;
+        return FS_ENAMETOOLONG;
 
     q = path;
     while (*q != '\0') {
@@ -2755,12 +2760,12 @@ new_path(const char *path, char **copy)
         while ((*q != '/') && (*q != '\0'))
             q++;
         if (q - r >= FILE_NAME_LENGTH)
-            return ENAMETOOLONG;        
+            return FS_ENAMETOOLONG;
     }
 
     p = (char *) malloc(s+1);
     if (!p)
-        return ENOMEM;
+        return FS_ENOMEM;
 
     /* ### do real checking: MAXPATHLEN, max file name len, buffer address... */
 
@@ -2901,12 +2906,12 @@ new_fd(bool kernel, int nfd, ofile *f, int fd, bool coe)
 
     if (!f) {
         if ((fd < 0) || (fd >= num)) {
-            err = EBADF;
+            err = FS_EBADF;
             goto error1;
         }
         f = fds->fds[fd];
         if (!f) {
-            err = EBADF;
+            err = FS_EBADF;
             goto error1;
         }
     }
@@ -2916,7 +2921,7 @@ new_fd(bool kernel, int nfd, ofile *f, int fd, bool coe)
 
     if (nfd >= 0) {
         if (nfd >= num) {
-            err = EBADF;
+            err = FS_EBADF;
             goto error2;
         }
         of = fds->fds[nfd];
@@ -2946,7 +2951,7 @@ new_fd(bool kernel, int nfd, ofile *f, int fd, bool coe)
         if (!GETBIT(fds->alloc, i))
             goto found;
 
-    err = EMFILE;
+    err = FS_EMFILE;
     goto error2;
 
 found:
@@ -2989,7 +2994,7 @@ remove_fd(bool kernel, int fd, int type)
     }
     UNLOCK(fds->lock);
     if (f == NULL)
-        return EBADF;
+        return FS_EBADF;
 
     err = 0;
     cnt = atomic_add(&f->ocnt, -1);
@@ -3023,7 +3028,7 @@ get_coe(bool kernel, int fd, int type, bool *coe)
         }
     }
     UNLOCK(fds->lock);
-    return EBADF;
+    return FS_EBADF;
 }
 
 static int
@@ -3047,7 +3052,7 @@ set_coe(bool kernel, int fd, int type, bool coe)
         }
     }
     UNLOCK(fds->lock);
-    return EBADF;
+    return FS_EBADF;
 }
 
 static int
@@ -3071,7 +3076,7 @@ get_omode(bool kernel, int fd, int type, int *omode)
         }
     }
     UNLOCK(fds->lock);
-    return EBADF;
+    return FS_EBADF;
 }
 #endif
 
@@ -3152,7 +3157,7 @@ alloc_wd_fd(bool kernel, vnode *vn, bool coe, int *fdp)
 
     f = (ofile *) calloc(sizeof(ofile), 1);
     if (!f) {
-        err = ENOMEM;
+        err = FS_ENOMEM;
         goto error1;
     }
 
@@ -3163,7 +3168,7 @@ alloc_wd_fd(bool kernel, vnode *vn, bool coe, int *fdp)
 
     nfd = new_fd(kernel, -1, f, -1, coe);
     if (nfd < 0) {
-        err = EMFILE;
+        err = FS_EMFILE;
         goto error2;
     }
 
@@ -3388,7 +3393,7 @@ send_notification(port_id port, long token, ulong what, long op, nspace_id nsida
 
 	return write_port(gTrackerPort, what, &message, sizeof(message));
 #else
-	return B_OK;
+	return FS_OK;
 #endif
 }
 
@@ -3401,7 +3406,7 @@ notify_select_event(selectsync *sync, uint32 ref)
 status_t
 notify_select_event(selectsync *sync, uint32 ref, uint8 event)
 {
-	return B_UNSUPPORTED;
+	return FS_UNSUPPORTED;
 }
 #endif
 

src/tests/add-ons/kernel/file_systems/fs_shell/kprotos.h

@@ -1,11 +1,9 @@
 #ifndef KPROTOS_H
 #define KPROTOS_H
 
+#include "compat.h"
 #include "myfs.h"
 
-#define my_stat stat
-#define my_dirent dirent
-
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -55,7 +53,7 @@ ssize_t sys_remove_attr(bool kernel, int fd, const char *name);
 
 int sys_open_query(bool kernel, int fd, const char *path, const char *query, ulong flags, port_id port, ulong token, void **cookie);
 int sys_close_query(bool kernel, int fd, const char *path, void *cookie);
-int sys_read_query(bool kernel, int fd, const char *path, void *cookie,struct dirent *dent,size_t bufferSize,long num);
+int sys_read_query(bool kernel, int fd, const char *path, void *cookie, struct my_dirent *dent,size_t bufferSize,long num);
 
 struct nspace;
 struct fsystem;

src/tests/add-ons/kernel/file_systems/fs_shell/myfs.h

@@ -8,7 +8,7 @@
 extern "C" {
 #endif
 
-#include "compat.h"
+//#include "compat.h"
 
 #include "lock.h"
 #include "cache.h"

src/tests/add-ons/kernel/file_systems/fs_shell/rootfs.c

@@ -17,21 +17,18 @@
   Dominic Giampaolo
   dbg@be.com
 */
+#include "compat.h"
+
 #include <stdlib.h>
 #include <string.h>
 #include <fcntl.h>
 #include <time.h>
 
-#include "compat.h"
-
 #include "skiplist.h"
 #include "lock.h"
 
 #include "fsproto.h"
 
-#define my_dirent dirent
-#define my_stat stat
-
 typedef struct vnode vnode;
 typedef struct nspace nspace;
 typedef struct dirpos dirpos;
@@ -172,11 +169,11 @@ rootfs_walk(void *_ns, void *_base, const char *file, char **newpath,
     */
 
     if (!MY_S_ISDIR(base->mode)) {
-        err = ENOTDIR;
+        err = FS_ENOTDIR;
         goto exit;
     }
     if (base->removed) {
-        err = ENOENT;
+        err = FS_ENOENT;
         goto exit;
     }
 
@@ -219,7 +216,7 @@ rootfs_walk(void *_ns, void *_base, const char *file, char **newpath,
     */
 
     if (!vn) {
-        err = ENOENT;
+        err = FS_ENOENT;
         goto exit;
     }
 
@@ -287,7 +284,7 @@ rootfs_symlink(void *_ns, void *_dir, const char *name, const char *path)
 
     buf = (char *) malloc(strlen(path)+1);
     if (!buf) {
-        err = ENOMEM;
+        err = FS_ENOMEM;
         goto error1;
     }
     strcpy(buf, path);
@@ -322,7 +319,7 @@ rootfs_rename(void *_ns, void *_olddir, const char *oldname, void *_newdir,
 
     LOCK(ns->lock);
     if (!MY_S_ISDIR(olddir->mode) || !MY_S_ISDIR(newdir->mode)) {
-        err = ENOTDIR;
+        err = FS_ENOTDIR;
         goto error1;
     }
     
@@ -331,7 +328,7 @@ rootfs_rename(void *_ns, void *_olddir, const char *oldname, void *_newdir,
     */
 
     if (!strcmp(oldname, ".") || !strcmp(oldname, "..")) {
-        err = EPERM;
+        err = FS_EPERM;
         goto error1;
     }
 
@@ -342,7 +339,7 @@ rootfs_rename(void *_ns, void *_olddir, const char *oldname, void *_newdir,
         vn = vn->next;
     }
     if (!vn) {
-        err = ENOENT;
+        err = FS_ENOENT;
         goto error1;
     }
 
@@ -351,7 +348,7 @@ rootfs_rename(void *_ns, void *_olddir, const char *oldname, void *_newdir,
     */
 
     if (!strcmp(newname, ".") || !strcmp(newname, "..")) {
-        err = EPERM;
+        err = FS_EPERM;
         goto error1;
     }
 
@@ -377,7 +374,7 @@ rootfs_rename(void *_ns, void *_olddir, const char *oldname, void *_newdir,
     while (avn != ns->root) {
         avn = avn->parent;
         if (avn == olddir) {
-            err = EINVAL;
+            err = FS_EINVAL;
             goto error1;
         }
     }
@@ -385,7 +382,7 @@ rootfs_rename(void *_ns, void *_olddir, const char *oldname, void *_newdir,
     if (strlen(newname) > strlen(vn->name)) {
         p = (char *) realloc(vn->name, strlen(newname)+1);
         if (!p) {
-            err = ENOMEM;
+            err = FS_ENOMEM;
             goto error1;
         }
     } else
@@ -402,11 +399,11 @@ rootfs_rename(void *_ns, void *_olddir, const char *oldname, void *_newdir,
     */
 
         if (nvn == nvn->ns->root) {
-            err = EBUSY;
+            err = FS_EBUSY;
             goto error1;
         }
         if (MY_S_ISDIR(nvn->mode) && nvn->head) {
-            err = ENOTEMPTY;
+            err = FS_ENOTEMPTY;
             goto error1;
         }
 
@@ -554,7 +551,7 @@ rootfs_readlink(void *_ns, void *_node, char *buf, size_t *bufsize)
     node = (vnode *) _node;
 
     if (!MY_S_ISLNK(node->mode)) {
-        err = EINVAL;
+        err = FS_EINVAL;
         goto error1;
     }
     l = strlen(node->symlink);
@@ -581,16 +578,16 @@ rootfs_opendir(void *_ns, void *_node, void **cookie)
     node = (vnode *) _node;
 
     if (!MY_S_ISDIR(node->mode)) {
-        err = ENOTDIR;
+        err = FS_ENOTDIR;
         goto error1;
     }
     pos = (dirpos *) malloc(sizeof(dirpos));
     if (!pos) {
-        err = ENOMEM;
+        err = FS_ENOMEM;
         goto error1;
     }
     if (new_lock(&pos->lock, "rootdirlock") < 0) {
-        err = EINVAL;
+        err = FS_EINVAL;
         goto error2;
     }
     pos->pos = 0;
@@ -717,15 +714,15 @@ rootfs_rstat(void *_ns, void *_node, struct my_stat *st)
     node = (vnode *) _node;
 
     LOCK(ns->lock);
-    st->st_dev = ns->nsid;
-    st->st_ino = node->vnid;
-    st->st_mode = node->mode;
-    st->st_nlink = 1;
-    st->st_uid = node->uid;
-    st->st_gid = node->gid;
-    st->st_size = 0;
-    st->st_blksize = 0;
-    st->st_atime = st->st_ctime = st->st_mtime = node->mtime;
+    st->dev = ns->nsid;
+    st->ino = node->vnid;
+    st->mode = node->mode;
+    st->nlink = 1;
+    st->uid = node->uid;
+    st->gid = node->gid;
+    st->size = 0;
+    st->blksize = 0;
+    st->atime = st->ctime = st->mtime = node->mtime;
     UNLOCK(ns->lock);
     return 0;
 }
@@ -740,20 +737,20 @@ rootfs_wstat(void *_ns, void *_node, struct my_stat *st, long mask)
     node = (vnode *) _node;
 
     if (mask & WSTAT_SIZE)
-        return EINVAL;
+        return FS_EINVAL;
 
     LOCK(ns->lock);
 
     if (mask & WSTAT_MODE)
-        node->mode = (node->mode & MY_S_IFMT) | (st->st_mode & ~MY_S_IFMT);
+        node->mode = (node->mode & MY_S_IFMT) | (st->mode & ~MY_S_IFMT);
     if (mask & WSTAT_UID)
-        node->uid = st->st_uid;
+        node->uid = st->uid;
     if (mask & WSTAT_GID)
-        node->gid = st->st_gid;
+        node->gid = st->gid;
     if (mask & WSTAT_MTIME)
-        node->mtime = st->st_mtime;
+        node->mtime = st->mtime;
     if (mask & WSTAT_ATIME)
-        node->mtime = st->st_atime;
+        node->mtime = st->atime;
 
     UNLOCK(ns->lock);
     return 0;
@@ -769,19 +766,19 @@ rootfs_mount(nspace_id nsid, const char *device, ulong flags, void *parms,
     vnode_id        rvnid;
 
     if (device || parms || (len != 0)) {
-        err = EINVAL;
+        err = FS_EINVAL;
         goto error1;
     }
 
     ns = (nspace *) malloc(sizeof(nspace));
     if (!ns) {
-        err = ENOMEM;
+        err = FS_ENOMEM;
         goto error1;
     }
 
     root = (vnode *) malloc(sizeof(vnode));
     if (!root) {
-        err = ENOMEM;
+        err = FS_ENOMEM;
         goto error2;
     }
 
@@ -897,7 +894,7 @@ do_create(nspace *ns, vnode *dir, const char *name, mode_t mode, vnode **vnp)
     vnode_id    vnid;
 
     if (!MY_S_ISDIR(dir->mode)) {
-        err = ENOTDIR;
+        err = FS_ENOTDIR;
         goto error1;
     }
     
@@ -907,7 +904,7 @@ do_create(nspace *ns, vnode *dir, const char *name, mode_t mode, vnode **vnp)
     */
 
     if (dir->removed) {
-        err = ENOENT;
+        err = FS_ENOENT;
         goto error1;
     }
 
@@ -917,7 +914,7 @@ do_create(nspace *ns, vnode *dir, const char *name, mode_t mode, vnode **vnp)
     */
 
     if (!strcmp(name, ".") || !strcmp(name, "..")) {
-        err = EEXIST;
+        err = FS_EEXIST;
         goto error1;
     }
         
@@ -941,7 +938,7 @@ do_create(nspace *ns, vnode *dir, const char *name, mode_t mode, vnode **vnp)
     */
 
     if (vn) {
-        err = EEXIST;
+        err = FS_EEXIST;
         goto error1;
     }
 
@@ -954,7 +951,7 @@ do_create(nspace *ns, vnode *dir, const char *name, mode_t mode, vnode **vnp)
     vn = (vnode *) malloc(sizeof(vnode));
     buf = (char *) malloc(strlen(name)+1);
     if (!vn || !buf) {
-        err = ENOMEM;
+        err = FS_ENOMEM;
         goto error2;
     }
     strcpy(buf, name);
@@ -1015,7 +1012,7 @@ do_unlink(nspace *ns, vnode *dir, const char *name, bool isdir)
 
     LOCK(ns->lock);
     if (!MY_S_ISDIR(dir->mode)) {
-        err = ENOTDIR;
+        err = FS_ENOTDIR;
         goto error1;
     }
     
@@ -1024,7 +1021,7 @@ do_unlink(nspace *ns, vnode *dir, const char *name, bool isdir)
     */
 
     if (!strcmp(name, "..") || !strcmp(name, ".")) {
-        err = EINVAL;
+        err = FS_EINVAL;
         goto error1;
     }
         
@@ -1044,7 +1041,7 @@ do_unlink(nspace *ns, vnode *dir, const char *name, bool isdir)
     */
 
     if (!vn) {
-        err = ENOENT;
+        err = FS_ENOENT;
         goto error1;
     }
 
@@ -1053,12 +1050,12 @@ do_unlink(nspace *ns, vnode *dir, const char *name, bool isdir)
     */
 
     if (isdir && !(vn->mode & MY_S_IFDIR)) {
-        err = ENOTDIR;
+        err = FS_ENOTDIR;
         goto error1;
     }
 
     if (!isdir && (vn->mode & MY_S_IFDIR)) {
-        err = EISDIR;
+        err = FS_EISDIR;
         goto error1;
     }
         
@@ -1067,7 +1064,7 @@ do_unlink(nspace *ns, vnode *dir, const char *name, bool isdir)
     */
 
     if (vn == vn->ns->root) {
-        err = EBUSY;
+        err = FS_EBUSY;
         goto error1;
     }
 
@@ -1076,7 +1073,7 @@ do_unlink(nspace *ns, vnode *dir, const char *name, bool isdir)
     */
 
     if (MY_S_ISDIR(vn->mode) && vn->head) {
-        err = ENOTEMPTY;
+        err = FS_ENOTEMPTY;
         goto error1;
     }
 

src/tests/add-ons/kernel/file_systems/fs_shell/stub.c

@@ -12,18 +12,38 @@
   Dominic Giampaolo
   dbg@be.com
 */
+#include "compat.h"
+
+#include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 
+#include <fs_attr.h>
+#include <KernelExport.h>
+#include <OS.h>
+
 #include "myfs.h"
 
+
 #ifndef __BEOS__ 
 
-void
-unload_kernel_addon(aid)
+static void
+myfs_die(const char *format,...)
 {
+	va_list list;
+	va_start(list, format);
+	vfprintf(stderr, format, list);
+	va_end(list);
+	
+	exit(1);
 }
 
+
+//void
+//unload_kernel_addon(aid)
+//{
+//}
+
 sem_id
 create_sem(long count, const char *name)
 {
@@ -61,7 +81,7 @@ acquire_sem(sem_id sem)
 
 
 long
-acquire_sem_etc(sem_id sem, int count, int j1, bigtime_t j2)
+acquire_sem_etc(sem_id sem, int32 count, uint32 j1, bigtime_t j2)
 {
     int *ptr = (int *)sem;
 
@@ -86,7 +106,7 @@ release_sem(sem_id sem)
 }
 
 long
-release_sem_etc(sem_id sem, long count, long j1)
+release_sem_etc(sem_id sem, long count, uint32 j1)
 {
     int *ptr = (int *)sem;
 
@@ -97,7 +117,7 @@ release_sem_etc(sem_id sem, long count, long j1)
 
 
 long
-atomic_add(long *ptr, long val)
+atomic_add(vint32 *ptr, long val)
 {
     int old = *ptr;
 
@@ -106,11 +126,173 @@ atomic_add(long *ptr, long val)
     return old;
 }
 
-int
+status_t
 snooze(bigtime_t f)
 {
     sleep(1);
     return 1;
 }
 
-#endif  /* __BEOS__ */
+
+// #pragma mark -
+
+void
+debugger(const char *message)
+{
+	myfs_die("debugger() call: `%s'\n", message);
+}
+
+
+// #pragma mark -
+
+thread_id
+find_thread(const char *name)
+{
+	if (!name)
+		return 42;
+	
+	return FS_EINVAL;
+}
+
+
+thread_id
+spawn_thread(thread_func func, const char *name, int32 priority, void *data)
+{
+	fprintf(stderr, "spawn_thread() not supported on this platform.\n");
+	return FS_EINVAL;
+}
+
+
+status_t
+resume_thread(thread_id thread)
+{
+	fprintf(stderr, "resume_thread() not supported on this platform.\n");
+	return FS_EINVAL;
+}
+
+
+status_t
+wait_for_thread(thread_id thread, status_t *returnValue)
+{
+	fprintf(stderr, "wait_for_thread() not supported on this platform.\n");
+	return FS_EINVAL;
+}
+
+
+// #pragma mark -
+
+port_id
+create_port(int32 capacity, const char *name)
+{
+	fprintf(stderr, "create_port() not supported on this platform.\n");
+	return FS_EINVAL;
+}
+
+
+ssize_t
+read_port(port_id port, int32 *code, void *buffer, size_t bufferSize)
+{
+	fprintf(stderr, "read_port() not supported on this platform.\n");
+	return FS_EINVAL;
+}
+
+
+status_t
+write_port(port_id port, int32 code, const void *buffer, size_t bufferSize)
+{
+	fprintf(stderr, "write_port() not supported on this platform.\n");
+	return FS_EINVAL;
+}
+
+
+status_t
+delete_port(port_id port)
+{
+	fprintf(stderr, "delete_port() not supported on this platform.\n");
+	return FS_EINVAL;
+}
+
+
+// #pragma mark -
+
+ssize_t
+fs_read_attr(int fd, const char *attribute, uint32 type, off_t pos,
+	void *buffer, size_t readBytes)
+{
+	fprintf(stderr, "fs_read_attr() not supported on this platform.\n");
+	errno = FS_EINVAL;
+	return -1;
+}
+
+
+ssize_t
+fs_write_attr(int fd, const char *attribute, uint32 type, off_t pos,
+	const void *buffer, size_t readBytes)
+{
+	fprintf(stderr, "fs_write_attr() not supported on this platform.\n");
+	errno = FS_EINVAL;
+	return -1;
+}
+
+
+int
+fs_remove_attr(int fd, const char *attribute)
+{
+	fprintf(stderr, "fs_remove_attr() not supported on this platform.\n");
+	errno = FS_EINVAL;
+	return -1;
+}
+
+
+int
+fs_stat_attr(int fd, const char *attribute, struct attr_info *attrInfo)
+{
+	fprintf(stderr, "fs_stat_attr() not supported on this platform.\n");
+	errno = FS_EINVAL;
+	return -1;
+}
+
+
+DIR *
+fs_open_attr_dir(const char *path)
+{
+	fprintf(stderr, "fs_open_attr_dir() not supported on this platform.\n");
+	errno = FS_EINVAL;
+	return NULL;
+}
+
+
+DIR *
+fs_fopen_attr_dir(int fd)
+{
+	fprintf(stderr, "fs_fopen_attr_dir() not supported on this platform.\n");
+	errno = FS_EINVAL;
+	return NULL;
+}
+
+
+int
+fs_close_attr_dir(DIR *dir)
+{
+	fprintf(stderr, "fs_close_attr_dir() not supported on this platform.\n");
+	errno = FS_EINVAL;
+	return -1;
+}
+
+
+struct dirent *
+fs_read_attr_dir(DIR *dir)
+{
+	fprintf(stderr, "fs_read_attr_dir() not supported on this platform.\n");
+	errno = FS_EINVAL;
+	return NULL;
+}
+
+
+void
+fs_rewind_attr_dir(DIR *dir)
+{
+	fprintf(stderr, "fs_rewind_attr_dir() not supported on this platform.\n");
+}
+
+#endif  /* ! __BEOS__ */

src/tests/add-ons/kernel/file_systems/fs_shell/sysdep.c

@@ -13,12 +13,27 @@
   Dominic Giampaolo
   dbg@be.com
 */
+#include "compat.h"
+
 #include <stdio.h>
 #include <fcntl.h>
 #include <unistd.h>
 #include <sys/stat.h>
 
-#include "compat.h"
+
+// Let the FS think, we are the root user.
+uid_t
+geteuid()
+{
+	return 0;
+}
+
+
+gid_t
+getegid()
+{
+	return 0;
+}
 
 
 int
@@ -129,7 +144,7 @@ read_pos(int fd, fs_off_t _pos, void *data,  size_t nbytes)
     
     if (lseek(fd, pos, SEEK_SET) < 0) {
         perror("read lseek");
-        return EINVAL;
+        return FS_EINVAL;
     }
     
     ret = read(fd, data, nbytes);
@@ -150,7 +165,7 @@ write_pos(int fd, fs_off_t _pos, const void *data,  size_t nbytes)
     
     if (lseek(fd, pos, SEEK_SET) < 0) {
         perror("read lseek");
-        return EINVAL;
+        return FS_EINVAL;
     }
     
     ret = write(fd, data, nbytes);
@@ -186,7 +201,7 @@ readv_pos(int fd, fs_off_t _pos, struct iovec *iov, int count)
 
     if (lseek(fd, pos, SEEK_SET) < 0) {
         perror("read lseek");
-        return EINVAL;
+        return FS_EINVAL;
     }
 
     i = 0;
@@ -221,7 +236,7 @@ writev_pos(int fd, fs_off_t _pos, struct iovec *iov,  int count)
 
     if (lseek(fd, pos, SEEK_SET) < 0) {
         perror("read lseek");
-        return EINVAL;
+        return FS_EINVAL;
     }
 
     i = 0;
@@ -246,8 +261,129 @@ writev_pos(int fd, fs_off_t _pos, struct iovec *iov,  int count)
 }
 
 
+int fs_shell_fstat(int fd, struct my_stat *myst);
 
-#endif /* __BEOS__ */
+int
+fs_shell_fstat(int fd, struct my_stat *myst)
+{
+	struct stat st;
+	
+	if (!myst) {
+		errno = FS_EINVAL;
+		return -1;
+	}
+	
+	if (fstat(fd, &st) < 0) {
+		errno = from_platform_error(errno);
+		return -1;
+	}
+
+	// translate the stat structure
+    myst->dev = st.st_dev;
+    myst->ino = st.st_ino;
+    myst->nlink = st.st_nlink;
+    myst->uid = st.st_uid;
+    myst->gid = st.st_gid;
+    myst->size = st.st_size;
+    myst->blksize = st.st_blksize;
+    myst->atime = st.st_atime;
+    myst->mtime = st.st_mtime;
+    myst->ctime = st.st_ctime;
+    myst->crtime = st.st_ctime;
+
+	// translate st_mode
+	myst->mode = 0;
+
+	#define SET_ST_MODE_BIT(flag, myflag)	\
+		if (st.st_mode & flag)			\
+			myst->mode |= myflag;
+			
+	#ifndef S_ATTR_DIR
+		#define S_ATTR_DIR 0
+	#endif
+	#ifndef S_ATTR
+		#define S_ATTR 0
+	#endif
+	#ifndef S_INDEX_DIR
+		#define S_INDEX_DIR 0
+	#endif
+	#ifndef S_INT_INDEX
+		#define S_INT_INDEX 0
+	#endif
+	#ifndef S_UINT_INDEX
+		#define S_UINT_INDEX 0
+	#endif
+	#ifndef S_LONG_LONG_INDEX
+		#define S_LONG_LONG_INDEX 0
+	#endif
+	#ifndef S_ULONG_LONG_INDEX
+		#define S_ULONG_LONG_INDEX 0
+	#endif
+	#ifndef S_FLOAT_INDEX
+		#define S_FLOAT_INDEX 0
+	#endif
+	#ifndef S_DOUBLE_INDEX
+		#define S_DOUBLE_INDEX 0
+	#endif
+	#ifndef S_ALLOW_DUPS
+		#define S_ALLOW_DUPS 0
+	#endif
+	#ifndef S_LINK_SELF_HEALING
+		#define S_LINK_SELF_HEALING 0
+	#endif
+	#ifndef S_LINK_AUTO_DELETE
+		#define S_LINK_AUTO_DELETE 0
+	#endif
+
+	SET_ST_MODE_BIT(MY_S_ATTR_DIR, S_ATTR_DIR);
+	SET_ST_MODE_BIT(MY_S_ATTR, S_ATTR);
+	SET_ST_MODE_BIT(MY_S_INDEX_DIR, S_INDEX_DIR);
+	SET_ST_MODE_BIT(MY_S_INT_INDEX, S_INT_INDEX);
+	SET_ST_MODE_BIT(MY_S_UINT_INDEX, S_UINT_INDEX);
+	SET_ST_MODE_BIT(MY_S_LONG_LONG_INDEX, S_LONG_LONG_INDEX);
+	SET_ST_MODE_BIT(MY_S_ULONG_LONG_INDEX, S_ULONG_LONG_INDEX);
+	SET_ST_MODE_BIT(MY_S_FLOAT_INDEX, S_FLOAT_INDEX);
+	SET_ST_MODE_BIT(MY_S_DOUBLE_INDEX, S_DOUBLE_INDEX);
+	SET_ST_MODE_BIT(MY_S_ALLOW_DUPS, S_ALLOW_DUPS);
+	SET_ST_MODE_BIT(MY_S_LINK_SELF_HEALING, S_LINK_SELF_HEALING);
+	SET_ST_MODE_BIT(MY_S_LINK_AUTO_DELETE, S_LINK_AUTO_DELETE);
+
+	switch (st.st_mode & S_IFMT) {
+		case S_IFLNK:
+			myst->mode |= MY_S_IFLNK;
+			break;
+		case S_IFREG:
+			myst->mode |= MY_S_IFREG;
+			break;
+		case S_IFBLK:
+			myst->mode |= MY_S_IFBLK;
+			break;
+		case S_IFDIR:
+			myst->mode |= MY_S_IFDIR;
+			break;
+		case S_IFIFO:
+			myst->mode |= MY_S_IFIFO;
+			break;
+	}
+
+	SET_ST_MODE_BIT(MY_S_ISUID, S_ISUID);
+	SET_ST_MODE_BIT(MY_S_ISGID, S_ISGID);
+	SET_ST_MODE_BIT(MY_S_ISVTX, S_ISVTX);
+	SET_ST_MODE_BIT(MY_S_IRUSR, S_IRUSR);
+	SET_ST_MODE_BIT(MY_S_IWUSR, S_IWUSR);
+	SET_ST_MODE_BIT(MY_S_IXUSR, S_IXUSR);
+	SET_ST_MODE_BIT(MY_S_IRGRP, S_IRGRP);
+	SET_ST_MODE_BIT(MY_S_IWGRP, S_IWGRP);
+	SET_ST_MODE_BIT(MY_S_IXGRP, S_IXGRP);
+	SET_ST_MODE_BIT(MY_S_IROTH, S_IROTH);
+	SET_ST_MODE_BIT(MY_S_IWOTH, S_IWOTH);
+	SET_ST_MODE_BIT(MY_S_IXOTH, S_IXOTH);
+
+	return 0;
+}
+
+
+#endif /* ! __BEOS__ */
 
 
 #include <stdarg.h>

src/tests/add-ons/kernel/file_systems/fs_shell/tracker.cpp

@@ -26,7 +26,7 @@ tracker_query_file(dev_t device, ino_t parent, char *name)
 		return;
 	}
 
-	struct stat stat;
+	struct my_stat stat;
 	int status = sys_rstat(true, fd, NULL, &stat, 1);
 	if (status < 0) {
 		printf("tracker: could not stat file: %s\n", name);