[libc][NFC] Standardize missing syscalls error messages.

[mikhail.ramalho]

Summary

This patch standardizes the error messages when a syscall is not
available to be in the format: "ABC and DEF syscalls are not available."

[sivachandra]

Thanks for the cleanup.

libc/src/__support/File/linux_file.cpp

constexpr long OPEN_MODE =
       S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH;
 
 #ifdef SYS_open
   int fd = __llvm_libc::syscall_impl(SYS_open, path, open_flags, OPEN_MODE);
 #elif defined(SYS_openat)
   int fd = __llvm_libc::syscall_impl(SYS_openat, AT_FDCWD, path, open_flags,
                                      OPEN_MODE);
 #else
-#error "SYS_open and SYS_openat syscalls not available to perform a file open."
+#error "open and openat syscalls not available."
 #endif
 
   if (fd < 0)
     return Error(-fd);
 
   uint8_t *buffer;
   {
     AllocChecker ac;

libc/src/__support/threads/linux/thread.cpp

 #include <stdint.h>
 #include <sys/mman.h>    // For PROT_* and MAP_* definitions.
 #include <sys/syscall.h> // For syscall numbers.
 
 namespace __llvm_libc {
 
 #ifdef SYS_mmap2
 static constexpr long MMAP_SYSCALL_NUMBER = SYS_mmap2;
-#elif SYS_mmap
+#elif defined(SYS_mmap)
 static constexpr long MMAP_SYSCALL_NUMBER = SYS_mmap;
 #else
-#error "SYS_mmap or SYS_mmap2 not available on the target platform"
+#error "mmap or mmap2 syscalls not available."
 #endif
 
 static constexpr size_t NAME_SIZE_MAX = 16; // Includes the null terminator
 static constexpr size_t DEFAULT_STACK_SIZE = (1 << 16); // 64KB
 static constexpr uint32_t CLEAR_TID_VALUE = 0xABCD1234;
 static constexpr unsigned CLONE_SYSCALL_FLAGS =
     CLONE_VM        // Share the memory space with the parent.
     | CLONE_FS      // Share the file system with the parent.

libc/src/spawn/linux/posix_spawn.cpp

pid_t fork() {
   // TODO: Use only the clone syscall and use a sperate small stack in the child
   // to avoid duplicating the complete stack from the parent. A new stack will
   // be created on exec anyway so duplicating the full stack is unnecessary.
 #ifdef SYS_fork
   return __llvm_libc::syscall_impl(SYS_fork);
 #elif defined(SYS_clone)
   return __llvm_libc::syscall_impl(SYS_clone, SIGCHLD, 0);
 #else
-#error "SYS_fork or SYS_clone not available."
+#error "fork or clone syscalls not available."
 #endif
 }
 
 cpp::optional<int> open(const char *path, int oflags, mode_t mode) {
 #ifdef SYS_open
   int fd = __llvm_libc::syscall_impl(SYS_open, path, oflags, mode);
 #else
   int fd = __llvm_libc::syscall_impl(SYS_openat, AT_FDCWD, path, oflags, mode);

 
 // We use dup3 if dup2 is not available, similar to our implementation of dup2
 bool dup2(int fd, int newfd) {
 #ifdef SYS_dup2
   long ret = __llvm_libc::syscall_impl(SYS_dup2, fd, newfd);
 #elif defined(SYS_dup3)
   long ret = __llvm_libc::syscall_impl(SYS_dup3, fd, newfd, 0);
 #else
-#error "SYS_dup2 and SYS_dup3 not available for the target."
+#error "dup2 and dup3 syscalls not available."
 #endif
   return ret < 0 ? false : true;
 }
 
 // All exits from child_process are error exits. So, we use a simple
 // exit implementation which exits with code 127.
 void exit() {
   for (;;) {

libc/src/sys/mman/linux/mmap.cpp

LLVM_LIBC_FUNCTION(void *, mmap,
 
   // EXEC_PAGESIZE is used for the page size. While this is OK for x86_64, it
   // might not be correct in general.
   // TODO: Use pagesize read from the ELF aux vector instead of EXEC_PAGESIZE.
 
 #ifdef SYS_mmap2
   offset /= EXEC_PAGESIZE;
   long syscall_number = SYS_mmap2;
-#elif SYS_mmap
+#elif defined(SYS_mmap)
   long syscall_number = SYS_mmap;
 #else
-#error "Target platform does not have SYS_mmap or SYS_mmap2 defined"
+#error "mmap or mmap2 syscalls not available."
 #endif
 
   long ret_val =
       __llvm_libc::syscall_impl(syscall_number, reinterpret_cast<long>(addr),
                                 size, prot, flags, fd, offset);
 
   // The mmap/mmap2 syscalls return negative values on error. These negative
   // values are actually the negative values of the error codes. So, fix them

libc/src/sys/stat/linux/chmod.cpp

 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, chmod, (const char *path, mode_t mode)) {
 #ifdef SYS_chmod
   long ret = __llvm_libc::syscall_impl(SYS_chmod, path, mode);
 #elif defined(SYS_fchmodat)
   long ret = __llvm_libc::syscall_impl(SYS_fchmodat, AT_FDCWD, path, mode);
 #else
-#error "chmod and chmodat syscalls not available."
+#error "chmod and fchmodat syscalls not available."
 #endif
 
   if (ret < 0) {
     libc_errno = -ret;
     return -1;
   }
   return 0;
 }
 
 } // namespace __llvm_libc

libc/src/sys/stat/linux/mkdirat.cpp

 #include <sys/syscall.h> // For syscall numbers.
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, mkdirat, (int dfd, const char *path, mode_t mode)) {
 #ifdef SYS_mkdirat
   long ret = __llvm_libc::syscall_impl(SYS_mkdirat, dfd, path, mode);
 #else
-#error "mkdirat syscalls not available."
+#error "mkdirat syscall not available."
 #endif
 
   if (ret < 0) {
     libc_errno = -ret;
     return -1;
   }
   return 0;
 }
 
 } // namespace __llvm_libc

libc/src/unistd/linux/access.cpp

 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, access, (const char *path, int mode)) {
 #ifdef SYS_access
   long ret = __llvm_libc::syscall_impl(SYS_access, path, mode);
 #elif defined(SYS_faccessat)
   long ret = __llvm_libc::syscall_impl(SYS_faccessat, AT_FDCWD, path, mode, 0);
 #else
-#error "access syscalls not available."
+#error "access and faccessat syscalls not available."
 #endif
 
   if (ret < 0) {
     libc_errno = -ret;
     return -1;
   }
   return 0;
 }
 
 } // namespace __llvm_libc

libc/src/unistd/linux/dup2.cpp

if (oldfd == newfd) {
     long ret = __llvm_libc::syscall_impl(SYS_fcntl, oldfd, F_GETFD);
     if (ret >= 0)
       return oldfd;
     libc_errno = -ret;
     return -1;
   }
   long ret = __llvm_libc::syscall_impl(SYS_dup3, oldfd, newfd, 0);
 #else
-#error "SYS_dup2 and SYS_dup3 not available for the target."
+#error "dup2 and dup3 syscalls not available."
 #endif
   if (ret < 0) {
     libc_errno = -ret;
     return -1;
   }
   return ret;
 }
 
 } // namespace __llvm_libc

libc/src/unistd/linux/fork.cpp

 
 LLVM_LIBC_FUNCTION(pid_t, fork, (void)) {
   invoke_prepare_callbacks();
 #ifdef SYS_fork
   pid_t ret = __llvm_libc::syscall_impl(SYS_fork);
 #elif defined(SYS_clone)
   pid_t ret = __llvm_libc::syscall_impl(SYS_clone, SIGCHLD, 0);
 #else
-#error "SYS_fork or SYS_clone not available."
+#error "fork and clone syscalls not available."
 #endif
   if (ret == 0) {
     // Return value is 0 in the child process.
     // The child is created with a single thread whose self object will be a
     // copy of parent process' thread which called fork. So, we have to fix up
     // the child process' self object with the new process' tid.
     self.attrib->tid = __llvm_libc::syscall_impl(SYS_gettid);
     invoke_child_callbacks();

libc/src/unistd/linux/link.cpp

 
 LLVM_LIBC_FUNCTION(int, link, (const char *path1, const char *path2)) {
 #ifdef SYS_link
   long ret = __llvm_libc::syscall_impl(SYS_link, path1, path2);
 #elif defined(SYS_linkat)
   long ret = __llvm_libc::syscall_impl(SYS_linkat, AT_FDCWD, path1, AT_FDCWD,
                                        path2, 0);
 #else
-#error "SYS_link or SYS_linkat not available."
+#error "link or linkat syscalls not available."
 #endif
   if (ret < 0) {
     libc_errno = -ret;
     return -1;
   }
   return ret;
 }
 
 } // namespace __llvm_libc

libc/src/unistd/linux/readlink.cpp

LLVM_LIBC_FUNCTION(ssize_t, readlink,
                    (const char *__restrict path, char *__restrict buf,
                     size_t bufsize)) {
 #ifdef SYS_readlink
   ssize_t ret = __llvm_libc::syscall_impl(SYS_readlink, path, buf, bufsize);
 #elif defined(SYS_readlinkat)
   ssize_t ret =
       __llvm_libc::syscall_impl(SYS_readlinkat, AT_FDCWD, path, buf, bufsize);
 #else
-#error "SYS_readlink or SYS_readlinkat not available."
+#error "readlink or readlinkat syscalls not available."
 #endif
   if (ret < 0) {
     libc_errno = -ret;
     return -1;
   }
   return ret;
 }
 
 } // namespace __llvm_libc

libc/src/unistd/linux/symlink.cpp

 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, symlink, (const char *path1, const char *path2)) {
 #ifdef SYS_symlink
   long ret = __llvm_libc::syscall_impl(SYS_symlink, path1, path2);
 #elif defined(SYS_symlinkat)
   long ret = __llvm_libc::syscall_impl(SYS_symlinkat, path1, AT_FDCWD, path2);
 #else
-#error "SYS_symlink or SYS_symlinkat not available."
+#error "symlink or symlinkat syscalls not available."
 #endif
   if (ret < 0) {
     libc_errno = -ret;
     return -1;
   }
   return ret;
 }
 
 } // namespace __llvm_libc

libc/src/unistd/linux/unlink.cpp

 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, unlink, (const char *path)) {
 #ifdef SYS_unlink
   long ret = __llvm_libc::syscall_impl(SYS_unlink, path);
 #elif defined(SYS_unlinkat)
   long ret = __llvm_libc::syscall_impl(SYS_unlinkat, AT_FDCWD, path, 0);
 #else
-#error "Unlink syscalls not available."
+#error "unlink and unlinkat syscalls not available."
 #endif
 
   if (ret < 0) {
     libc_errno = -ret;
     return -1;
   }
   return 0;
 }
 
 } // namespace __llvm_libc

libc/src/unistd/linux/unlinkat.cpp

 #include <sys/syscall.h> // For syscall numbers.
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, unlinkat, (int dfd, const char *path, int flags)) {
 #ifdef SYS_unlinkat
   long ret = __llvm_libc::syscall_impl(SYS_unlinkat, dfd, path, flags);
 #else
-#error "unlinkat syscall not available."
+#error "unlinkat syscalls not available."
 #endif
 
   if (ret < 0) {
     libc_errno = -ret;
     return -1;
   }
   return 0;
 }
 
 } // namespace __llvm_libc

libc/startup/linux/aarch64/start.cpp

 
 namespace __llvm_libc {
 
 #ifdef SYS_mmap2
 static constexpr long MMAP_SYSCALL_NUMBER = SYS_mmap2;
 #elif SYS_mmap
 static constexpr long MMAP_SYSCALL_NUMBER = SYS_mmap;
 #else
-#error "Target platform does not have SYS_mmap or SYS_mmap2 defined"
+#error "mmap and mmap2 syscalls not available."
 #endif
 
 AppProperties app;
 
 static ThreadAttributes main_thread_attrib;
 
 void init_tls(TLSDescriptor &tls_descriptor) {
   if (app.tls.size == 0) {

libc/startup/linux/riscv64/start.cpp

 
 namespace __llvm_libc {
 
 #ifdef SYS_mmap2
 static constexpr long MMAP_SYSCALL_NUMBER = SYS_mmap2;
 #elif SYS_mmap
 static constexpr long MMAP_SYSCALL_NUMBER = SYS_mmap;
 #else
-#error "Target platform does not have SYS_mmap or SYS_mmap2 defined"
+#error "mmap and mmap2 syscalls not available."
 #endif
 
 AppProperties app;
 
 static ThreadAttributes main_thread_attrib;
 
 void init_tls(TLSDescriptor &tls_descriptor) {
   if (app.tls.size == 0) {

libc/startup/linux/x86_64/start.cpp

 
 namespace __llvm_libc {
 
 #ifdef SYS_mmap2
 static constexpr long mmapSyscallNumber = SYS_mmap2;
 #elif SYS_mmap
 static constexpr long mmapSyscallNumber = SYS_mmap;
 #else
-#error "Target platform does not have SYS_mmap or SYS_mmap2 defined"
+#error "mmap and mmap2 syscalls not available."
 #endif
 
 AppProperties app;
 
 static ThreadAttributes main_thread_attrib;
 
 // TODO: The function is x86_64 specific. Move it to config/linux/app.h
 // and generalize it. Also, dynamic loading is not handled currently.

libc/test/src/unistd/syscall_test.cpp

TEST(LlvmLibcSyscallTest, SymlinkCreateDestroy) {
   constexpr const char LINK_VAL[] = "syscall_readlink_test_value";
   constexpr const char LINK[] = "testdata/syscall_readlink.test.link";
 
 #ifdef SYS_symlink
   ASSERT_GE(__llvm_libc::syscall(SYS_symlink, LINK_VAL, LINK), 0l);
 #elif defined(SYS_symlinkat)
   ASSERT_GE(__llvm_libc::syscall(SYS_symlinkat, LINK_VAL, AT_FDCWD, LINK), 0l);
 #else
-#error "Symlink syscalls not available."
+#error "symlink and symlinkat syscalls not available."
 #endif
   ASSERT_EQ(libc_errno, 0);
 
   char buf[sizeof(LINK_VAL)];
 
 #ifdef SYS_readlink
   ASSERT_GE(__llvm_libc::syscall(SYS_readlink, LINK, buf, sizeof(buf)), 0l);
 #elif defined(SYS_readlinkat)
   ASSERT_GE(
       __llvm_libc::syscall(SYS_readlinkat, AT_FDCWD, LINK, buf, sizeof(buf)),
       0l);
 #endif
   ASSERT_EQ(libc_errno, 0);
 
 #ifdef SYS_unlink
   ASSERT_GE(__llvm_libc::syscall(SYS_unlink, LINK), 0l);
 #elif defined(SYS_unlinkat)
   ASSERT_GE(__llvm_libc::syscall(SYS_unlinkat, AT_FDCWD, LINK, 0), 0l);
 #else
-#error "Unlink syscalls not available."
+#error "unlink and unlinkat syscalls not available."
 #endif
   ASSERT_EQ(libc_errno, 0);
 }
 
 TEST(LlvmLibcSyscallTest, FileReadWrite) {
   constexpr const char HELLO[] = "hello";
   constexpr int HELLO_SIZE = sizeof(HELLO);
 
   constexpr const char *TEST_FILE = "testdata/syscall_pread_pwrite.test";
 
 #ifdef SYS_open
   int fd =
       __llvm_libc::syscall(SYS_open, TEST_FILE, O_WRONLY | O_CREAT, S_IRWXU);
 #elif defined(SYS_openat)
   int fd = __llvm_libc::syscall(SYS_openat, AT_FDCWD, TEST_FILE,
                                 O_WRONLY | O_CREAT, S_IRWXU);
 #else
-#error "Open syscalls not available to available."
+#error "open and openat syscalls not available."
 #endif
   ASSERT_GT(fd, 0);
   ASSERT_EQ(libc_errno, 0);
 
   ASSERT_GE(__llvm_libc::syscall(SYS_pwrite64, fd, HELLO, HELLO_SIZE, 0), 0l);
   ASSERT_EQ(libc_errno, 0);
 
   ASSERT_GE(__llvm_libc::syscall(SYS_fsync, fd), 0l);

 
 #ifdef SYS_open
   int write_fd = __llvm_libc::syscall(SYS_open, TEST_FILE_PATH,
                                       O_WRONLY | O_CREAT, S_IRWXU);
 #elif defined(SYS_openat)
   int write_fd = __llvm_libc::syscall(SYS_openat, AT_FDCWD, TEST_FILE_PATH,
                                       O_WRONLY | O_CREAT, S_IRWXU);
 #else
-#error "Open syscalls not available to available."
+#error "open and openat syscalls not available."
 #endif
   ASSERT_GT(write_fd, 0);
   ASSERT_EQ(libc_errno, 0);
 
   ASSERT_GE(__llvm_libc::syscall(SYS_close, write_fd), 0l);
   ASSERT_EQ(libc_errno, 0);
 
 #ifdef SYS_open
   int dir_fd = __llvm_libc::syscall(SYS_open, TEST_DIR, O_DIRECTORY, 0);
 #elif defined(SYS_openat)
   int dir_fd =
       __llvm_libc::syscall(SYS_openat, AT_FDCWD, TEST_DIR, O_DIRECTORY, 0);
 #else
-#error "Open syscalls not available to available."
+#error "open and openat syscalls not available."
 #endif
   ASSERT_GT(dir_fd, 0);
   ASSERT_EQ(libc_errno, 0);
 
   ASSERT_GE(__llvm_libc::syscall(SYS_linkat, dir_fd, TEST_FILE, dir_fd,
                                  TEST_FILE_LINK, 0),
             0l);
   ASSERT_EQ(libc_errno, 0);
 #ifdef SYS_open
   int link_fd = __llvm_libc::syscall(SYS_open, TEST_FILE_LINK_PATH, O_PATH, 0);
 #elif defined(SYS_openat)
   int link_fd = __llvm_libc::syscall(SYS_openat, AT_FDCWD, TEST_FILE_LINK_PATH,
                                      O_PATH, 0);
 #else
-#error "Open syscalls not available to available."
+#error "open and openat syscalls not available."
 #endif
   ASSERT_GT(link_fd, 0);
   ASSERT_EQ(libc_errno, 0);
 
 #ifdef SYS_unlink
   ASSERT_GE(__llvm_libc::syscall(SYS_unlink, TEST_FILE_PATH), 0l);
 #elif defined(SYS_unlinkat)
   ASSERT_GE(__llvm_libc::syscall(SYS_unlinkat, AT_FDCWD, TEST_FILE_PATH, 0),
             0l);
 #else
-#error "Unlink syscalls not available."
+#error "unlink and unlinkat syscalls not available."
 #endif
   ASSERT_EQ(libc_errno, 0);
 
 #ifdef SYS_unlink
   ASSERT_GE(__llvm_libc::syscall(SYS_unlink, TEST_FILE_LINK_PATH), 0l);
 #elif defined(SYS_unlinkat)
   ASSERT_GE(
       __llvm_libc::syscall(SYS_unlinkat, AT_FDCWD, TEST_FILE_LINK_PATH, 0), 0l);
 #else
-#error "Unlink syscalls not available."
+#error "unlink and unlinkat syscalls not available."
 #endif
   ASSERT_EQ(libc_errno, 0);
 
   ASSERT_GE(__llvm_libc::syscall(SYS_close, dir_fd), 0l);
   ASSERT_EQ(libc_errno, 0);
 }