[NaCl SDK] nacl_io: Change default root filesystem type from passthroughfs to memfs

native_client_sdk/src/libraries/nacl_io/kernel_wrap_dummy.cc

 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // The Chromium build system defines __linux__ even for native client builds,
 // so guard against __native_client__ being defined as well.
 #if defined(WIN32) || (defined(__linux__) && !defined(__native_client__))
 
 #include <errno.h>
 
+#ifdef __linux__
+#include <dirent.h>
+#include <stddef.h>
+#include <string.h>
+#include <sys/syscall.h>
+#include <unistd.h>
+struct linux_dirent {
+  unsigned long  d_ino;     /* Inode number */
+  unsigned long  d_off;     /* Offset to next linux_dirent */
+  unsigned short d_reclen;  /* Length of this linux_dirent */
+  char           d_name[];  /* Filename (null-terminated) */
+};
+#endif
+
 #include "nacl_io/kernel_wrap.h"
 #include "nacl_io/kernel_wrap_real.h"
 
 // "real" functions, i.e. the unwrapped original functions. For Windows/Linux
 // host builds we don't wrap, so the real functions aren't accessible. In most
 // cases, we just fail.
 
 int _real_close(int fd) {
   return ENOSYS;
 }
 
 int _real_fstat(int fd, struct stat* buf) {
-  return 0;
+  return fstat(fd, buf);
 }
 
-int _real_getdents(int fd, void* nacl_buf, size_t nacl_count, size_t* nread) {
+int _real_getdents(int fd, void* in_buf, size_t in_count, size_t* nread) {
+#ifdef __linux__
+  int in_offset = 0;
+  // "buf" contains linux_dirent(s); "in_buf" contains dirent(s).
+  // dirents(s) are smaller than linux_dirent(s), so in_count bytes buffer
+  // is enough

[binji, 2015/01/07 19:14:59]

Will this do the right thing if you request one dirent, then? If I understand
the logic here correctly, it will make a syscall to read less than one
linux_dirent's size in bytes.

[Sam Clegg, 2015/01/08 12:59:07]

in_count is normally much bigger than the size of the struct itself to account
for the variable size of the d_name field.   The idea is to be conservative and
always read fewer elements than we can pack into in_buf (otherwise we'd have to
through away the extra onces).  Its true that if in_count is too small we might
not even be able to read a single one but this is true of the native syscall
too.   This code is essentially borrowed from kernel_wrap_glibc.cc were it seems
to work fine.

I did find a few issues though so I've largely re-written it.

+  char* buf = (char*)alloca(in_count);
+  int offset = 0;
+  int count;
+
+  count = syscall(SYS_getdents, fd, buf, in_count);
+  if (count < 0)
+    return errno;
+
+  while (offset < count) {
+    struct linux_dirent* d = (struct linux_dirent*)(buf + offset);
+    struct dirent* nacl_d = (struct dirent*)((char*)in_buf + in_offset);

[binji, 2015/01/07 19:14:59]

consistency between in_ and nacl_ prefixes?

[Sam Clegg, 2015/01/08 12:59:07]

Done.

+    nacl_d->d_ino = d->d_ino;
+    nacl_d->d_off = d->d_off;
+    nacl_d->d_reclen = d->d_reclen;
+    size_t d_name_len = d->d_reclen - offsetof(linux_dirent, d_name);
+    memcpy(nacl_d->d_name, d->d_name, d_name_len);
+
+    offset += d->d_reclen;
+    in_offset += nacl_d->d_reclen;
+  }
+
+  *nread = in_offset;
+  return 0;
+#else
   return ENOSYS;
+#endif
 }
 
 int _real_lseek(int fd, off_t offset, int whence, off_t* new_offset) {
   return ENOSYS;
 }
 
 int _real_mkdir(const char* pathname, mode_t mode) {
   return ENOSYS;
 }
 
 int _real_mmap(void** addr,
                size_t length,
                int prot,
                int flags,
                int fd,
                off_t offset) {
   return ENOSYS;
 }
 
 int _real_munmap(void* addr, size_t length) {
   return ENOSYS;
 }
 
 int _real_open(const char* pathname, int oflag, mode_t mode, int* newfd) {
-  return ENOSYS;
+  int fd = open(pathname, oflag, mode);
+  if (fd < 0)
+    return errno;
+
+  *newfd = fd;
+  return 0;
 }
 
 int _real_open_resource(const char* file, int* fd) {
   return ENOSYS;
 }
 
 int _real_read(int fd, void* buf, size_t count, size_t* nread) {
-  *nread = count;
+  int rtn = read(fd, buf, count);
+  if (rtn < 0)
+    return errno;
+
+  *nread = rtn;
   return 0;
 }
 
 int _real_rmdir(const char* pathname) {
   return ENOSYS;
 }
 
 int _real_write(int fd, const void* buf, size_t count, size_t* nwrote) {
   int rtn = write(fd, buf, count);
   if (rtn < 0)
-    return -1;
+    return errno;
 
   *nwrote = rtn;
   return 0;
 }
 
 void _real_exit(int status) {
   exit(status);
 }
 
 int _real_getcwd(char* pathname, size_t len) {
   return ENOSYS;
 }
 
 #endif
 
 // The Chromium build system defines __linux__ even for native client builds,
 // so guard against __native_client__ being defined as well.
 #if defined(__linux__) && !defined(__native_client__)
 
 void kernel_wrap_init() {
 }
 
 void kernel_wrap_uninit() {
 }
 
 #endif