[NaCl SDK] nacl_io: Remove unneeded glibc syscall entry points.

native_client_sdk/src/libraries/nacl_io/kernel_wrap_glibc.cc

 // Copyright (c) 2012 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.
 
 #include <sys/types.h>  // Include something that will define __GLIBC__.
 
 // The entire file is wrapped in this #if. We do this so this .cc file can be
 // compiled, even on a non-glibc build.
 #if defined(__native_client__) && defined(__GLIBC__)
 
@@ skipping 139 matching lines @@
   OP(sendmsg);                           \
   OP(sendto);                            \
   OP(recv);                              \
   OP(recvmsg);                           \
   OP(recvfrom);                          \
   OP(getpeername);                       \
   OP(getsockname);                       \
   OP(getsockopt);                        \
   OP(setsockopt);                        \
   OP(socketpair);                        \
-  OP(shutdown);
+  OP(shutdown);                          \
+                                         \
+  OP(access);                            \
+  OP(unlink);                            \
+  OP(fchdir);                            \
+  OP(fchmod);                            \
+  OP(fsync);                             \
+  OP(fdatasync);                         \
+  OP(lstat);                             \
+  OP(readlink);                          \
+  OP(utimes);
 
 // TODO(bradnelson): Add these as well.
 // OP(epoll_create);
 // OP(epoll_create1);
 // OP(epoll_ctl);
 // OP(epoll_pwait);
 // OP(ppoll);
 // OP(pselect);
-//
 
 EXPAND_SYMBOL_LIST_OPERATION(DECLARE_REAL_PTR);
 
 int WRAP(chdir)(const char* pathname) {
-  RTN_ERRNO_IF(ki_chdir(pathname) < 0);
-  return 0;
+  ERRNO_RTN(ki_chdir(pathname));
 }
 
 int WRAP(close)(int fd) {
-  RTN_ERRNO_IF(ki_close(fd) < 0);
-  return 0;
+  ERRNO_RTN(ki_close(fd));
 }
 
 int WRAP(dup)(int fd, int* newfd) NOTHROW {
   *newfd = ki_dup(fd);
   RTN_ERRNO_IF(*newfd < 0);
   return 0;
 }
 
 int WRAP(dup2)(int fd, int newfd) NOTHROW {
-  RTN_ERRNO_IF(ki_dup2(fd, newfd) < 0);
-  return 0;
+  ERRNO_RTN(ki_dup2(fd, newfd));
 }
 
 void WRAP(exit)(int status) {
   ki_exit(status);
 }
 
 int WRAP(fstat)(int fd, struct nacl_abi_stat* nacl_buf) {
   struct stat buf;
   memset(&buf, 0, sizeof(struct stat));
   int res = ki_fstat(fd, &buf);
@@ skipping 111 matching lines @@
 
 int WRAP(stat)(const char* pathname, struct nacl_abi_stat* nacl_buf) {
   struct stat buf;
   memset(&buf, 0, sizeof(struct stat));
   int res = ki_stat(pathname, &buf);
   RTN_ERRNO_IF(res < 0);
   stat_to_nacl_stat(&buf, nacl_buf);
   return 0;
 }
 
+int WRAP(lstat)(const char* pathname, struct nacl_abi_stat* nacl_buf) {
+  struct stat buf;
+  memset(&buf, 0, sizeof(struct stat));
+  int res = ki_lstat(pathname, &buf);
+  RTN_ERRNO_IF(res < 0);
+  stat_to_nacl_stat(&buf, nacl_buf);
+  return 0;
+}
+
+int WRAP(readlink)(const char* pathname,
+                   char* buf,
+                   size_t count,
+                   size_t* nread) {
+  int rtn = ki_readlink(pathname, buf, count);
+  RTN_ERRNO_IF(rtn < 0);
+  *nread = rtn;
+  return 0;
+}
+
+int WRAP(utimes)(const char *filename, const struct timeval *times) {
+  ERRNO_RTN(ki_utimes(filename, times));
+}
+
+int WRAP(access)(const char* pathname, int amode) {
+  ERRNO_RTN(ki_access(pathname, amode));
+}
+
+int WRAP(unlink)(const char* pathname) {
+  ERRNO_RTN(ki_unlink(pathname));
+}
+
+int WRAP(fchdir)(int fd) {
+  ERRNO_RTN(ki_fchdir(fd));
+}
+
+int WRAP(fchmod)(int fd, mode_t mode) {
+  ERRNO_RTN(ki_fchmod(fd, mode));
+}
+
+int WRAP(fsync)(int fd) {
+  ERRNO_RTN(ki_fsync(fd));
+}
+
+int WRAP(fdatasync)(int fd) {
+  ERRNO_RTN(ki_fdatasync(fd));
+}
+
 int WRAP(write)(int fd, const void* buf, size_t count, size_t* nwrote) {
   ssize_t signed_nwrote = ki_write(fd, buf, count);
   *nwrote = static_cast<size_t>(signed_nwrote);
   RTN_ERRNO_IF(signed_nwrote < 0);
   return 0;
 }
 
 int WRAP(accept)(int sockfd,
                  struct sockaddr* addr,
                  socklen_t* addrlen,
                  int* sd) {
   *sd = ki_accept(sockfd, addr, addrlen);
   RTN_ERRNO_IF(*sd < 0);
   return 0;
 }
 
 int WRAP(bind)(int sockfd, const struct sockaddr* addr, socklen_t addrlen) {
-  RTN_ERRNO_IF(ki_bind(sockfd, addr, addrlen) < 0);
-  return 0;
+  ERRNO_RTN(ki_bind(sockfd, addr, addrlen));
 }
 
 int WRAP(connect)(int sockfd, const struct sockaddr* addr, socklen_t addrlen) {
-  RTN_ERRNO_IF(ki_connect(sockfd, addr, addrlen) < 0);
-  return 0;
+  ERRNO_RTN(ki_connect(sockfd, addr, addrlen));
 }
 
 int WRAP(getpeername)(int sockfd, struct sockaddr* addr, socklen_t* addrlen) {
-  RTN_ERRNO_IF(ki_getpeername(sockfd, addr, addrlen) < 0);
-  return 0;
+  ERRNO_RTN(ki_getpeername(sockfd, addr, addrlen));
 }
 
 int WRAP(getsockname)(int sockfd, struct sockaddr* addr, socklen_t* addrlen) {
-  RTN_ERRNO_IF(ki_getsockname(sockfd, addr, addrlen) < 0);
-  return 0;
+  ERRNO_RTN(ki_getsockname(sockfd, addr, addrlen));
 }
 
 int WRAP(getsockopt)(int sockfd,
                      int level,
                      int optname,
                      void* optval,
                      socklen_t* optlen) {
-  RTN_ERRNO_IF(ki_getsockopt(sockfd, level, optname, optval, optlen) < 0);
-  return 0;
+  ERRNO_RTN(ki_getsockopt(sockfd, level, optname, optval, optlen));
 }
 
 int WRAP(setsockopt)(int sockfd,
                      int level,
                      int optname,
                      const void* optval,
                      socklen_t optlen) {
-  RTN_ERRNO_IF(ki_setsockopt(sockfd, level, optname, optval, optlen) < 0);
-  return 0;
+  ERRNO_RTN(ki_setsockopt(sockfd, level, optname, optval, optlen));
 }
 
 int WRAP(listen)(int sockfd, int backlog) {
-  RTN_ERRNO_IF(ki_listen(sockfd, backlog) < 0);
-  return 0;
+  ERRNO_RTN(ki_listen(sockfd, backlog));
 }
 
 int WRAP(recv)(int sockfd, void* buf, size_t len, int flags, int* count) {
   ssize_t signed_nread = ki_recv(sockfd, buf, len, flags);
   *count = static_cast<int>(signed_nread);
   RTN_ERRNO_IF(signed_nread < 0);
   return 0;
 }
 
 int WRAP(recvfrom)(int sockfd,
@@ skipping 194 matching lines @@
   if (s_wrapped) {
     LOG_TRACE("kernel_wrap_uninit");
     EXPAND_SYMBOL_LIST_OPERATION(USE_REAL)
     s_wrapped = false;
   }
 }
 
 EXTERN_C_END
 
 #endif  // defined(__native_client__) && defined(__GLIBC__)