[libc] Read and write errno via special getter and setter functions.

[sivachandra]

Summary

When built for tests, the setter and getter functions use an errno which
is different from the global, system libc errno. This way, the tests stay
hermetic with respect to the setting and testing of errno - there is no
mixup with the system libc's errno, even accidentally.

[sivachandra]

The updates in most of the files are mechanical. The main changes are in src/errno/errno.cpp and src/errno/llvmlibc_errno.h. I have only cleaned up enough to get a clean test run. After this lands, I will make another pass to cleanup everything.

[mcgrathr]

libc/src/errno/errno.cpp

15

IMHO this doesn't really belong in the same directory as the "real" errno, let alone the same file.

I don't understand why these variables aren't inside namespace __llvm_libc like other internal symbols.

libc/src/fcntl/linux/openat.cpp

13

I'm not at all clear on why this isn't in src/__support like other internal things.

[lntue]

libc/src/errno/errno.cpp

15

I agree, at least based on its name, some test util is a better place for it. Also, is the test_errno only used for some tests or for all the tests?

libc/src/errno/llvmlibc_errno.h

13

Do we have to worry that under the normal testing environments without LLVM_LIBC_PUBLIC_PACKAGING, their behavior might diverge due to the inclusion / missing of errno.h header?

[sivachandra]

libc/src/errno/errno.cpp

15

• About why they are not in the namespace __llvm_libc:

With respect to at least __llvmlibc_errno, it is the actual errno which gets used when LLVM libc is the only libc. In the public errno.h, we declare it as:

extern _Thread_local int __llvmlibc_errno;
#define errno __llvmlibc_errno

For C++ compilations, _Thread_local gets replaced with thread_local. Because we list __llvmlibc_errno directly in the public C header, we cannot declare it in a namespace.

• About why the "test" flavor belongs in the same directory as the real errno:

I don't think there is any technical blocker preventing us from moving this to __support as you have pointed out below. This patch only "extends" the current practices. I suppose it does not fit the way in which Fuchsia intends to use it? Moving this to __support would mean more work in CMake plumbing et al for a few reasons: We don't compile all object files twice, only the ones containing the entrypoints are compiled twice - once for internal consumption, and another time for prod packaging. My idea was to convert the target for this file to an entrypoint target in a follow up patch. If we are to move the test errno to a non-entrypoint target in __support, we will either have to do some special casing for the errno targets, or link in the test errno object file into all tests. The latter is much more straight forward to do compared to special casing errno in CMake.

• Is the test errno used for some tests or all tests?

After all usage sites are updated to use the getter and setter functions, all tests will use the test errno.

libc/src/errno/llvmlibc_errno.h

13

Without LLVM_LIBC_PUBLIC_PACKAGING, set_errno and get_errno refer to __llvmlibc_test_errno. So, presence or absence of errno.h has no impact. My understanding is that that is the desired behavior - when testing, we do not want a mixup with the system libc errno.

libc/src/fcntl/linux/openat.cpp

13

I have addressed this under the other comment.

[mcgrathr]

libc/src/errno/errno.cpp

15

I think the normal way to do this is to declare it inside the namespace but using extern "C". That way, it can be referred to by the scoped name as well. If you want to make the scoped name nicer rather than the __ name, then you can declare it using __asm__("__name") instead of using extern "C". In this case there's no real reason to care about the ergonomics of the variable name, since it is meant to be private to the accessor implementation anyway.

My comment about using __support was about the placement of the header file. I don't think any of the cmake issues about how many ways to compile which source files have direct bearing on where you place a header file. If we don't mind the COMDAT load, we could also just using an inline variable declaration in the header and not have any source file to define it at all. At least for the one used only in test mode, that doesn't seem like a problem to me.

libc/src/errno/llvmlibc_errno.h

13

Any libc implementation code that uses E* macros would normally have #include <errno.h> by general IWYU principles. IMHO the API of what headers each source file is required to #include to meet IWYU principles should not vary based on how the source is being compiled. So if the internal API is that implementation files use #include "src/errno/llvmlibc_errno.h" in order to implement/use the errno API, then that should consistently either provide the E* macros or not. Hence AFAICT it makes most sense to unconditionally #include <errno.h> here.

[sivachandra]

libc/src/errno/errno.cpp

15

I think the normal way to do this is to declare it inside the namespace but using extern "C". That way, it can be referred to by the scoped name as well. If you want to make the scoped name nicer rather than the __ name, then you can declare it using __asm__("__name") instead of using extern "C". In this case there's no real reason to care about the ergonomics of the variable name, since it is meant to be private to the accessor implementation anyway.

If the variable was actually referenced from internal code, declaring it in a namespace would have made sense. But, considering that the only way it is accessed is via the public errno macro, it seemed unnecessary to put it in a namespace and then declare it extern "C". If there is a reason why a namespace still makes sense, I can do it separately.

My comment about using __support was about the placement of the header file. I don't think any of the cmake issues about how many ways to compile which source files have direct bearing on where you place a header file. If we don't mind the COMDAT load, we could also just using an inline variable declaration in the header and not have any source file to define it at all. At least for the one used only in test mode, that doesn't seem like a problem to me.

Ah, we can put the header file anywhere - I don't think there is a problem. Before I make that change, I have another question: this patch declares the accessor functions inline. Is there a problem if they are not inline? Keeping them inline does not work everywhere as errno is accessed from places which are not compiled differently for tests. [That is why I said that in a follow up patch I would like to switch this over to an entrypoint target so that it gets compiled differently for tests.]

[mcgrathr]

libc/src/errno/errno.cpp

15

I think there is merit in the plain uniformity of always using namespaces consistently, that's all. The basic conventions of the internal API for sources don't need to change to satisfy special cases like different external linkage requirements.

Well, the scheme is kind of fundamentally incompatible with the idea of not compiling code differently for test and production, if you want to keep production optimal by inlining accesses that should be cheaper than a call in most cases. For Fuchsia's build, everything is compiled differently in the two cases for other reasons anyway so it's not a concern to inline the test-only version in one place and the prod version in the other. If you really want to avoid it, we can make things macro-parameterized in the header so that your common-to-test-and-prod mode doesn't inline but my test mode and my prod mode do.

OTOH, AIUI the code you compile in common is exactly *not* the public entrypoint code. There's a fair argument to be made that as errno is part of the public API, only the actual public entrypoint functions directly (or their local helpers implemented with them, not in shared places) should actually set errno in any fashion. So if we make sure that __support et al e.g. return errno values instead of setting the global--which is a generally better style for internal & new APIs anyway--then the errno accessor functions can be reserved for use in the code that *does* get compiled separately for test and prod.

Frankly I'm skeptical that not compiling things multiple times in multiple ways is going to remain an option forever. There's just too much different about the ways you really might want to compile code for test (e.g. heavy sanitizers) than for production uses. I'm no cmake wizard, but it doesn't seem likely very difficult to maintain in a well-controlled build like the still-nascent llvm-libc cmake.

libc/src/errno/CMakeLists.txt

-if (LLVM_LIBC_FULL_BUILD)
 add_object_library(
   errno
   SRCS
     errno.cpp
   HDRS
     llvmlibc_errno.h
 )
-else()
-add_object_library(
-  errno
-  SRCS
-    dummy_errno.cpp
-  HDRS
-    dummy_errno.h
-)
-endif()

libc/src/errno/errno.cpp

-//===-- Implementation of __errno_location --------------------------------===//
+//===-- Implementation of errno -------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
+// TODO: Conditionally exclude one of the errno's based on
+// LLVM_LIBC_PUBLIC_PACKAGING. We need both to exist now as all references to
+// errno have not been swtiched over to the setter and getter functions.
+
 thread_local int __llvmlibc_errno = 0;
+
+thread_local int __llvmlibc_test_errno = 0;

libc/src/errno/llvmlibc_errno.h

 //===-- Implementation header for errno -------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIBC_SRC_ERRNO_LLVMLIBC_ERRNO_H
 #define LLVM_LIBC_SRC_ERRNO_LLVMLIBC_ERRNO_H
 
-// Internal code should use this and not use the errno macro from the
-// public header.
-extern thread_local int __llvmlibc_errno;
-#define llvmlibc_errno __llvmlibc_errno
+#ifdef LLVM_LIBC_PUBLIC_PACKAGING
+#include <errno.h>
+#define ACTIVE_ERRNO errno
+#else
+#define ACTIVE_ERRNO __llvmlibc_test_errno
+extern thread_local int __llvmlibc_test_errno;
+#endif // LLVM_LIBC_PUBLIC_PACKAGING
+
+namespace __llvm_libc {
+
+// Internal and test code should read and update errno using the following
+// functions. This way, we ensure that there is no mixup with the errno from
+// the system libc in unit tests.
+
+inline int get_errno() { return ACTIVE_ERRNO; }
+
+inline void set_errno(int err) { ACTIVE_ERRNO = err; }
+
+} // namespace __llvm_libc
+
+#undef ACTIVE_ERRNO
 
 #endif // LLVM_LIBC_SRC_ERRNO_LLVMLIBC_ERRNO_H

libc/src/fcntl/linux/openat.cpp

 //===-- Implementation of openat ------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "src/fcntl/openat.h"
 
 #include "src/__support/OSUtil/syscall.h" // For internal syscall function.
 #include "src/__support/common.h"
+#include "src/errno/llvmlibc_errno.h"
 
-#include <errno.h>
 #include <fcntl.h>
 #include <stdarg.h>
 #include <sys/syscall.h> // For syscall numbers.
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, openat, (int dfd, const char *path, int flags, ...)) {
   mode_t mode_flags = 0;
   // O_TMPFILE is a multi-bit flag so we test all bits by checking for equality
   // with O_TMPFILE
   if ((flags & O_CREAT) || (flags & O_TMPFILE) == O_TMPFILE) {
     va_list varargs;
     va_start(varargs, flags);
     mode_flags = va_arg(varargs, mode_t);
     va_end(varargs);
   }
 
   int fd = __llvm_libc::syscall(SYS_openat, dfd, path, flags, mode_flags);
   if (fd > 0)
     return fd;
 
-  errno = -fd;
+  __llvm_libc::set_errno(-fd);
   return -1;
 }
 
 } // namespace __llvm_libc

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

 //===---------- Linux implementation of the POSIX mmap function -----------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "src/sys/mman/mmap.h"
 
 #include "src/__support/OSUtil/syscall.h" // For internal syscall function.
 #include "src/__support/common.h"
+#include "src/errno/llvmlibc_errno.h"
 
-#include <errno.h>
 #include <linux/param.h> // For EXEC_PAGESIZE.
 #include <sys/syscall.h> // For syscall numbers.
 
 namespace __llvm_libc {
 
 // This function is currently linux only. It has to be refactored suitably if
 // mmap is to be supported on non-linux operating systems also.
 LLVM_LIBC_FUNCTION(void *, mmap,
#endif
   // up in case an error code is detected.
   //
   // A point to keep in mind for the fix up is that a negative return value
   // from the syscall can also be an error-free value returned by the syscall.
   // However, since a valid return address cannot be within the last page, a
   // return value corresponding to a location in the last page is an error
   // value.
   if (ret_val < 0 && ret_val > -EXEC_PAGESIZE) {
-    errno = -ret_val;
+    __llvm_libc::set_errno(-ret_val);
     return MAP_FAILED;
   }
 
   return reinterpret_cast<void *>(ret_val);
 }
 
 } // namespace __llvm_libc

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

 //===---------- Linux implementation of the POSIX munmap function ---------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "src/sys/mman/munmap.h"
 
 #include "src/__support/OSUtil/syscall.h" // For internal syscall function.
 #include "src/__support/common.h"
+#include "src/errno/llvmlibc_errno.h"
 
-#include <errno.h>
 #include <sys/syscall.h>          // For syscall numbers.
 
 namespace __llvm_libc {
 
 // This function is currently linux only. It has to be refactored suitably if
 // mmap is to be supported on non-linux operating systems also.
 LLVM_LIBC_FUNCTION(int, munmap, (void *addr, size_t size)) {
   long ret_val =
       __llvm_libc::syscall(SYS_munmap, reinterpret_cast<long>(addr), size);
 
   // A negative return value indicates an error with the magnitude of the
   // value being the error code.
   if (ret_val < 0) {
-    errno = -ret_val;
+    __llvm_libc::set_errno(-ret_val);
     return -1;
   }
 
   return 0;
 }
 
 } // namespace __llvm_libc

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

 //===-- Linux implementation of mkdir -------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "src/sys/stat/mkdir.h"
 
 #include "src/__support/OSUtil/syscall.h" // For internal syscall function.
 #include "src/__support/common.h"
+#include "src/errno/llvmlibc_errno.h"
 
-#include <errno.h>
 #include <fcntl.h>
 #include <sys/stat.h>
 #include <sys/syscall.h> // For syscall numbers.
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, mkdir, (const char *path, mode_t mode)) {
 #ifdef SYS_mkdir
   long ret = __llvm_libc::syscall(SYS_mkdir, path, mode);
 #elif defined(SYS_mkdirat)
   long ret = __llvm_libc::syscall(SYS_mkdirat, AT_FDCWD, path, mode);
 #else
 #error "mkdir and mkdirat syscalls not available."
 #endif
 
   if (ret < 0) {
-    errno = -ret;
+    __llvm_libc::set_errno(-ret);
     return -1;
   }
   return 0;
 }
 
 } // namespace __llvm_libc

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

 //===-- Linux implementation of mkdirat -----------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "src/sys/stat/mkdirat.h"
 
 #include "src/__support/OSUtil/syscall.h" // For internal syscall function.
 #include "src/__support/common.h"
+#include "src/errno/llvmlibc_errno.h"
 
-#include <errno.h>
 #include <sys/stat.h>
 #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(SYS_mkdirat, dfd, path, mode);
 #else
 #error "mkdirat syscalls not available."
 #endif
 
   if (ret < 0) {
-    errno = -ret;
+    __llvm_libc::set_errno(-ret);
     return -1;
   }
   return 0;
 }
 
 } // namespace __llvm_libc

libc/src/time/time_utils.h

 };
 
 // Update the "tm" structure's year, month, etc. members from seconds.
 // "total_seconds" is the number of seconds since January 1st, 1970.
 extern int64_t update_from_seconds(int64_t total_seconds, struct tm *tm);
 
 // POSIX.1-2017 requires this.
 static inline time_t out_of_range() {
-  llvmlibc_errno = EOVERFLOW;
+  set_errno(EOVERFLOW);
   return static_cast<time_t>(-1);
 }
 
-static inline void invalid_value() { llvmlibc_errno = EINVAL; }
+static inline void invalid_value() { set_errno(EINVAL); }
 
 static inline char *asctime(const struct tm *timeptr, char *buffer,
                             size_t bufferLength) {
   if (timeptr == nullptr || buffer == nullptr) {
     invalid_value();
     return nullptr;
   }
   if (timeptr->tm_wday < 0 ||

libc/src/unistd/linux/lseek.cpp

 //===-- Linux implementation of lseek -------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "src/unistd/lseek.h"
 
 #include "src/__support/OSUtil/syscall.h" // For internal syscall function.
 #include "src/__support/common.h"
+#include "src/errno/llvmlibc_errno.h"
 
-#include <errno.h>
 #include <sys/syscall.h> // For syscall numbers.
 #include <unistd.h>
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(off_t, lseek, (int fd, off_t offset, int whence)) {
   off_t result;
 #ifdef SYS_lseek
   long ret = __llvm_libc::syscall(SYS_lseek, fd, offset, whence);
   result = ret;
 #elif defined(SYS__llseek)
   long ret = __llvm_libc::syscall(SYS__lseek, fd, offset >> 32, offset, &result,
                                   whence);
 #else
 #error "lseek and _llseek syscalls not available."
 #endif
 
   if (ret < 0) {
-    errno = -ret;
+    __llvm_libc::set_errno(-ret);
     return -1;
   }
   return result;
 }
 
 } // namespace __llvm_libc

libc/src/unistd/linux/read.cpp

 //===-- Linux implementation of read --------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "src/unistd/read.h"
 
 #include "src/__support/OSUtil/syscall.h" // For internal syscall function.
 #include "src/__support/common.h"
+#include "src/errno/llvmlibc_errno.h"
 
-#include <errno.h>
 #include <sys/syscall.h> // For syscall numbers.
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(ssize_t, read, (int fd, void *buf, size_t count)) {
   long ret = __llvm_libc::syscall(SYS_read, fd, buf, count);
   if (ret < 0) {
-    errno = -ret;
+    __llvm_libc::set_errno(-ret);
     return -1;
   }
   return ret;
 }
 
 } // namespace __llvm_libc

libc/src/unistd/linux/rmdir.cpp

 //===-- Linux implementation of rmdir -------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "src/unistd/rmdir.h"
 
 #include "src/__support/OSUtil/syscall.h" // For internal syscall function.
 #include "src/__support/common.h"
+#include "src/errno/llvmlibc_errno.h"
 
-#include <errno.h>
 #include <fcntl.h>
 #include <sys/syscall.h> // For syscall numbers.
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, rmdir, (const char *path)) {
 #ifdef SYS_rmdir
   long ret = __llvm_libc::syscall(SYS_rmdir, path);
 #elif defined(SYS_unlinkat)
   long ret = __llvm_libc::syscall(SYS_unlinkat, AT_FDCWD, path, AT_REMOVEDIR);
 #else
 #error "rmdir and unlinkat syscalls not available."
 #endif
 
   if (ret < 0) {
-    errno = -ret;
+    __llvm_libc::set_errno(-ret);
     return -1;
   }
   return 0;
 }
 
 } // namespace __llvm_libc

libc/src/unistd/linux/unlink.cpp

 //===-- Linux implementation of unlink ------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "src/unistd/unlink.h"
 
 #include "src/__support/OSUtil/syscall.h" // For internal syscall function.
 #include "src/__support/common.h"
+#include "src/errno/llvmlibc_errno.h"
 
-#include <errno.h>
 #include <fcntl.h>
 #include <sys/syscall.h> // For syscall numbers.
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, unlink, (const char *path)) {
 #ifdef SYS_unlink
   long ret = __llvm_libc::syscall(SYS_unlink, path);
 #elif defined(SYS_unlinkat)
   long ret = __llvm_libc::syscall(SYS_unlinkat, AT_FDCWD, path, 0);
 #else
 #error "Unlink syscalls not available."
 #endif
 
   if (ret < 0) {
-    errno = -ret;
+    __llvm_libc::set_errno(-ret);
     return -1;
   }
   return 0;
 }
 
 } // namespace __llvm_libc

libc/src/unistd/linux/unlinkat.cpp

 //===-- Linux implementation of unlinkat ----------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "src/unistd/unlinkat.h"
 
 #include "src/__support/OSUtil/syscall.h" // For internal syscall function.
 #include "src/__support/common.h"
+#include "src/errno/llvmlibc_errno.h"
 
-#include <errno.h>
 #include <fcntl.h>
 #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(SYS_unlinkat, dfd, path, flags);
 #else
 #error "unlinkat syscall not available."
 #endif
 
   if (ret < 0) {
-    errno = -ret;
+    __llvm_libc::set_errno(-ret);
     return -1;
   }
   return 0;
 }
 
 } // namespace __llvm_libc

libc/src/unistd/linux/write.cpp

 //===-- Linux implementation of write -------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "src/unistd/write.h"
 
 #include "src/__support/OSUtil/syscall.h" // For internal syscall function.
 #include "src/__support/common.h"
+#include <src/errno/llvmlibc_errno.h>
 
-#include <errno.h>
 #include <sys/syscall.h> // For syscall numbers.
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(ssize_t, write, (int fd, const void *buf, size_t count)) {
   long ret = __llvm_libc::syscall(SYS_write, fd, buf, count);
   if (ret < 0) {
-    errno = -ret;
+    __llvm_libc::set_errno(-ret);
     return -1;
   }
   return ret;
 }
 
 } // namespace __llvm_libc

libc/test/ErrnoSetterMatcher.h

 //===-- ErrnoSetterMatcher.h ------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIBC_TEST_ERRNOSETTERMATCHER_H
 #define LLVM_LIBC_TEST_ERRNOSETTERMATCHER_H
 
 #include "utils/UnitTest/Test.h"
 
-#include <errno.h>
+#include "src/errno/llvmlibc_errno.h"
 
 namespace __llvm_libc {
 namespace testing {
 
 namespace internal {
 
 extern "C" const char *strerror(int);
 
void explainError(testutils::StreamWrapper &OS) override {
     else
       OS << "Correct value " << ExpectedReturn
          << " was returned\nBut errno was unexpectely set to "
          << strerror(ActualErrno) << ".\n";
   }
 
   bool match(T Got) {
     ActualReturn = Got;
-    ActualErrno = errno;
-    errno = 0;
+    ActualErrno = __llvm_libc::get_errno();
+    __llvm_libc::set_errno(0);
     return Got == ExpectedReturn && ActualErrno == ExpectedErrno;
   }
 };
 
 } // namespace internal
 
 namespace ErrnoSetterMatcher {
 

libc/test/integration/loader/linux/tls_test.cpp

for (int i = 1; i < threadLocalDataSize; ++i)
     a[i] = i;
   for (int i = 1; i < threadLocalDataSize; ++i)
     ASSERT_TRUE(a[i] == i);
 
   // Call mmap with bad params so that an error value is
   // set in errno. Since errno is implemented using a thread
   // local var, this helps us test setting of errno and
   // reading it back.
-  ASSERT_TRUE(llvmlibc_errno == 0);
+  ASSERT_EQ(__llvm_libc::get_errno(), 0);
   void *addr = __llvm_libc::mmap(nullptr, 0, PROT_READ,
                                  MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
   ASSERT_TRUE(addr == MAP_FAILED);
-  ASSERT_TRUE(llvmlibc_errno == EINVAL);
+  ASSERT_EQ(__llvm_libc::get_errno(), EINVAL);
 
   return 0;
 }

libc/test/src/errno/errno_test.cpp

 //===-- Unittests for errno -----------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "src/errno/llvmlibc_errno.h"
 #include "utils/UnitTest/Test.h"
 
 TEST(LlvmLibcErrnoTest, Basic) {
+  ASSERT_EQ(0, __llvm_libc::get_errno());
   int test_val = 123;
-  llvmlibc_errno = test_val;
-  ASSERT_EQ(test_val, llvmlibc_errno);
+  __llvm_libc::set_errno(test_val);
+  ASSERT_EQ(test_val, __llvm_libc::get_errno());
 }

libc/test/src/time/asctime_r_test.cpp

__llvm_libc::tmhelper::testing::initialize_tm_data(
       tm_data, year, month, mday, hour, min, sec, wday, yday);
   return __llvm_libc::asctime_r(tm_data, buffer);
 }
 
 // asctime and asctime_r share the same code and thus didn't repeat all the
 // tests from asctime. Added couple of validation tests.
 TEST(LlvmLibcAsctimeR, Nullptr) {
   char *result;
+  __llvm_libc::set_errno(0);
   result = __llvm_libc::asctime_r(nullptr, nullptr);
-  ASSERT_EQ(EINVAL, llvmlibc_errno);
+  ASSERT_EQ(EINVAL, __llvm_libc::get_errno());
   ASSERT_STREQ(nullptr, result);
 
   char buffer[TimeConstants::ASCTIME_BUFFER_SIZE];
+  __llvm_libc::set_errno(0);
   result = __llvm_libc::asctime_r(nullptr, buffer);
-  ASSERT_EQ(EINVAL, llvmlibc_errno);
+  ASSERT_EQ(EINVAL, __llvm_libc::get_errno());
   ASSERT_STREQ(nullptr, result);
 
   struct tm tm_data;
+  __llvm_libc::set_errno(0);
   result = __llvm_libc::asctime_r(&tm_data, nullptr);
-  ASSERT_EQ(EINVAL, llvmlibc_errno);
+  ASSERT_EQ(EINVAL, __llvm_libc::get_errno());
   ASSERT_STREQ(nullptr, result);
 }
 
 TEST(LlvmLibcAsctimeR, ValidDate) {
   char buffer[TimeConstants::ASCTIME_BUFFER_SIZE];
   struct tm tm_data;
   char *result;
   // 1970-01-01 00:00:00. Test with a valid buffer size.

libc/test/src/time/asctime_test.cpp

static inline char *call_asctime(struct tm *tm_data, int year, int month,
   __llvm_libc::tmhelper::testing::initialize_tm_data(
       tm_data, year, month, mday, hour, min, sec, wday, yday);
   return __llvm_libc::asctime(tm_data);
 }
 
 TEST(LlvmLibcAsctime, Nullptr) {
   char *result;
   result = __llvm_libc::asctime(nullptr);
-  ASSERT_EQ(EINVAL, llvmlibc_errno);
+  ASSERT_EQ(EINVAL, __llvm_libc::get_errno());
   ASSERT_STREQ(nullptr, result);
 }
 
 // Weekdays are in the range 0 to 6. Test passing invalid value in wday.
 TEST(LlvmLibcAsctime, InvalidWday) {
   struct tm tm_data;
   char *result;
 
   // Test with wday = -1.
   result = call_asctime(&tm_data,
                         1970, // year
                         1,    // month
                         1,    // day
                         0,    // hr
                         0,    // min
                         0,    // sec
                         -1,   // wday
                         0);   // yday
-  ASSERT_EQ(EINVAL, llvmlibc_errno);
+  ASSERT_EQ(EINVAL, __llvm_libc::get_errno());
 
   // Test with wday = 7.
   result = call_asctime(&tm_data,
                         1970, // year
                         1,    // month
                         1,    // day
                         0,    // hr
                         0,    // min
                         0,    // sec
                         7,    // wday
                         0);   // yday
-  ASSERT_EQ(EINVAL, llvmlibc_errno);
+  ASSERT_EQ(EINVAL, __llvm_libc::get_errno());
 }
 
 // Months are from January to December. Test passing invalid value in month.
 TEST(LlvmLibcAsctime, InvalidMonth) {
   struct tm tm_data;
   char *result;
 
   // Test with month = 0.
   result = call_asctime(&tm_data,
                         1970, // year
                         0,    // month
                         1,    // day
                         0,    // hr
                         0,    // min
                         0,    // sec
                         4,    // wday
                         0);   // yday
-  ASSERT_EQ(EINVAL, llvmlibc_errno);
+  ASSERT_EQ(EINVAL, __llvm_libc::get_errno());
 
   // Test with month = 13.
   result = call_asctime(&tm_data,
                         1970, // year
                         13,   // month
                         1,    // day
                         0,    // hr
                         0,    // min
                         0,    // sec
                         4,    // wday
                         0);   // yday
-  ASSERT_EQ(EINVAL, llvmlibc_errno);
+  ASSERT_EQ(EINVAL, __llvm_libc::get_errno());
 }
 
 TEST(LlvmLibcAsctime, ValidWeekdays) {
   struct tm tm_data;
   char *result;
   // 1970-01-01 00:00:00.
   result = call_asctime(&tm_data,
                         1970, // year
result = call_asctime(&tm_data,
                         2147483647, // year
                         1,          // month
                         1,          // day
                         12,         // hr
                         50,         // min
                         50,         // sec
                         2,          // wday
                         50);        // yday
-  ASSERT_EQ(EOVERFLOW, llvmlibc_errno);
+  ASSERT_EQ(EOVERFLOW, __llvm_libc::get_errno());
   ASSERT_STREQ(nullptr, result);
 }

libc/test/src/time/gmtime_test.cpp

 using __llvm_libc::time_utils::TimeConstants;
 
 TEST(LlvmLibcGmTime, OutOfRange) {
   time_t seconds =
       1 + INT_MAX * static_cast<int64_t>(
                         TimeConstants::NUMBER_OF_SECONDS_IN_LEAP_YEAR);
   struct tm *tm_data = __llvm_libc::gmtime(&seconds);
   EXPECT_TRUE(tm_data == nullptr);
-  EXPECT_EQ(llvmlibc_errno, EOVERFLOW);
+  EXPECT_EQ(__llvm_libc::get_errno(), EOVERFLOW);
 
-  llvmlibc_errno = 0;
+  __llvm_libc::set_errno(0);
   seconds = INT_MIN * static_cast<int64_t>(
                           TimeConstants::NUMBER_OF_SECONDS_IN_LEAP_YEAR) -
             1;
   tm_data = __llvm_libc::gmtime(&seconds);
   EXPECT_TRUE(tm_data == nullptr);
-  EXPECT_EQ(llvmlibc_errno, EOVERFLOW);
+  EXPECT_EQ(__llvm_libc::get_errno(), EOVERFLOW);
 }
 
 TEST(LlvmLibcGmTime, InvalidSeconds) {
   time_t seconds = 0;
   struct tm *tm_data = nullptr;
   // -1 second from 1970-01-01 00:00:00 returns 1969-12-31 23:59:59.
   seconds = -1;
   tm_data = __llvm_libc::gmtime(&seconds);