[libc][NFC] Switch dirent, fcntl, inttypes and sched to use libc_errno.

[michaelrj]

need to update the tests as well.

[sivachandra]

Switch corresponding tests also over to use libc_errno.

libc/src/dirent/closedir.cpp

 //===-- Implementation of closedir ----------------------------------------===//
 //
 // 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 "closedir.h"
 
 #include "src/__support/File/dir.h"
 #include "src/__support/common.h"
+#include "src/errno/libc_errno.h"
 
 #include <dirent.h>
-#include <errno.h>
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, closedir, (::DIR * dir)) {
   auto *d = reinterpret_cast<__llvm_libc::Dir *>(dir);
   int retval = d->close();
   if (retval != 0) {
-    errno = retval;
+    libc_errno = retval;
     return -1;
   }
   return 0;
 }
 
 } // namespace __llvm_libc

libc/src/dirent/opendir.cpp

 //===-- Implementation of opendir -----------------------------------------===//
 //
 // 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 "opendir.h"
 
 #include "src/__support/File/dir.h"
 #include "src/__support/common.h"
+#include "src/errno/libc_errno.h"
 
 #include <dirent.h>
-#include <errno.h>
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(::DIR *, opendir, (const char *name)) {
   auto dir = Dir::open(name);
   if (!dir) {
-    errno = dir.error();
+    libc_errno = dir.error();
     return nullptr;
   }
   return reinterpret_cast<DIR *>(dir.value());
 }
 
 } // namespace __llvm_libc

libc/src/dirent/readdir.cpp

 //===-- Implementation of readdir -----------------------------------------===//
 //
 // 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 "readdir.h"
 
 #include "src/__support/File/dir.h"
 #include "src/__support/common.h"
+#include "src/errno/libc_errno.h"
 
 #include <dirent.h>
-#include <errno.h>
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(struct ::dirent *, readdir, (::DIR * dir)) {
   auto *d = reinterpret_cast<__llvm_libc::Dir *>(dir);
   auto dirent_val = d->read();
   if (!dirent_val) {
-    errno = dirent_val.error();
+    libc_errno = dirent_val.error();
     return nullptr;
   }
   return dirent_val;
 }
 
 } // namespace __llvm_libc

libc/src/fcntl/linux/CMakeLists.txt

 add_entrypoint_object(
   creat
   SRCS
     creat.cpp
   HDRS
     ../creat.h
   DEPENDS
-    libc.include.errno
     libc.include.fcntl
     libc.src.__support.OSUtil.osutil
     libc.src.errno.errno
 )
 
 add_entrypoint_object(
   open
   SRCS
     open.cpp
   HDRS
     ../open.h
   DEPENDS
-    libc.include.errno
     libc.include.fcntl
     libc.src.__support.OSUtil.osutil
     libc.src.errno.errno
 )
 
 add_entrypoint_object(
   openat
   SRCS
     openat.cpp
   HDRS
     ../openat.h
   DEPENDS
-    libc.include.errno
     libc.include.fcntl
     libc.src.__support.OSUtil.osutil
     libc.src.errno.errno
 )

libc/src/fcntl/linux/creat.cpp

 //===-- Implementation of creat -------------------------------------------===//
 //
 // 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/creat.h"
 
 #include "src/__support/OSUtil/syscall.h" // For internal syscall function.
 #include "src/__support/common.h"
+#include "src/errno/libc_errno.h"
 
-#include <errno.h>
 #include <fcntl.h>
 #include <sys/syscall.h> // For syscall numbers.
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, creat, (const char *path, int mode_flags)) {
 #ifdef SYS_open
   int fd = __llvm_libc::syscall_impl(SYS_open, path,
                                      O_CREAT | O_WRONLY | O_TRUNC, mode_flags);
 #else
   int fd = __llvm_libc::syscall_impl(SYS_openat, AT_FDCWD, path,
                                      O_CREAT | O_WRONLY | O_TRUNC, mode_flags);
 #endif
 
   if (fd > 0)
     return fd;
 
-  errno = -fd;
+  libc_errno = -fd;
   return -1;
 }
 
 } // namespace __llvm_libc

libc/src/fcntl/linux/open.cpp

 //===-- Implementation of open --------------------------------------------===//
 //
 // 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/open.h"
 
 #include "src/__support/OSUtil/syscall.h" // For internal syscall function.
 #include "src/__support/common.h"
+#include "src/errno/libc_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, open, (const char *path, int flags, ...)) {
   mode_t mode_flags = 0;
#ifdef SYS_open
   int fd = __llvm_libc::syscall_impl(SYS_open, path, flags, mode_flags);
 #else
   int fd =
       __llvm_libc::syscall_impl(SYS_openat, AT_FDCWD, path, flags, mode_flags);
 #endif
   if (fd > 0)
     return fd;
 
-  errno = -fd;
+  libc_errno = -fd;
   return -1;
 }
 
 } // namespace __llvm_libc

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/libc_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_impl(SYS_openat, dfd, path, flags, mode_flags);
   if (fd > 0)
     return fd;
 
-  errno = -fd;
+  libc_errno = -fd;
   return -1;
 }
 
 } // namespace __llvm_libc

libc/src/inttypes/CMakeLists.txt

 add_entrypoint_object(
   strtoimax
   SRCS
     strtoimax.cpp
   HDRS
     strtoimax.h
   DEPENDS
     libc.src.__support.str_to_integer
+    libc.src.errno.errno
 )
 
 add_entrypoint_object(
   strtoumax
   SRCS
     strtoumax.cpp
   HDRS
     strtoumax.h
   DEPENDS
     libc.src.__support.str_to_integer
+    libc.src.errno.errno
 )
 
 add_entrypoint_object(
   imaxdiv
   SRCS
     imaxdiv.cpp
   HDRS
     imaxdiv.h

libc/src/inttypes/strtoimax.cpp

 //===-- Implementation of strtoimax ---------------------------------------===//
 //
 // 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/inttypes/strtoimax.h"
 #include "src/__support/common.h"
 #include "src/__support/str_to_integer.h"
+#include "src/errno/libc_errno.h"
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(intmax_t, strtoimax,
                    (const char *__restrict str, char **__restrict str_end,
                     int base)) {
   auto result = internal::strtointeger<intmax_t>(str, base);
   if (result.has_error())
-    errno = result.error;
+    libc_errno = result.error;
 
   if (str_end != nullptr)
     *str_end = const_cast<char *>(str + result.parsed_len);
 
   return result;
 }
 
 } // namespace __llvm_libc

libc/src/inttypes/strtoumax.cpp

 //===-- Implementation of strtoumax ---------------------------------------===//
 //
 // 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/inttypes/strtoumax.h"
 #include "src/__support/common.h"
 #include "src/__support/str_to_integer.h"
+#include "src/errno/libc_errno.h"
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(uintmax_t, strtoumax,
                    (const char *__restrict str, char **__restrict str_end,
                     int base)) {
   auto result = internal::strtointeger<uintmax_t>(str, base);
   if (result.has_error())
-    errno = result.error;
+    libc_errno = result.error;
 
   if (str_end != nullptr)
     *str_end = const_cast<char *>(str + result.parsed_len);
 
   return result;
 }
 
 } // namespace __llvm_libc

libc/src/sched/linux/CMakeLists.txt

 add_entrypoint_object(
   sched_getaffinity
   SRCS
     sched_getaffinity.cpp
   HDRS
     ../sched_getaffinity.h
   DEPENDS
-    libc.include.errno
     libc.include.sched
     libc.src.__support.OSUtil.osutil
     libc.src.errno.errno
 )
 
 add_entrypoint_object(
   sched_setaffinity
   SRCS
     sched_setaffinity.cpp
   HDRS
     ../sched_setaffinity.h
   DEPENDS
-    libc.include.errno
     libc.include.sched
     libc.src.__support.OSUtil.osutil
     libc.src.errno.errno
 )
 
 add_entrypoint_object(
   __sched_getcpucount
   SRCS
     sched_getcpucount.cpp
   HDRS
     ../sched_getcpucount.h
   DEPENDS
     libc.include.sched
 )

libc/src/sched/linux/sched_getaffinity.cpp

 //===-- Implementation of sched_getaffinity -------------------------------===//
 //
 // 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/sched/sched_getaffinity.h"
 
 #include "src/__support/OSUtil/syscall.h" // For internal syscall function.
 #include "src/__support/common.h"
+#include "src/errno/libc_errno.h"
 
-#include <errno.h>
 #include <sched.h>
 #include <stdint.h>
 #include <sys/syscall.h> // For syscall numbers.
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, sched_getaffinity,
                    (pid_t tid, size_t cpuset_size, cpu_set_t *mask)) {
   long ret =
       __llvm_libc::syscall_impl(SYS_sched_getaffinity, tid, cpuset_size, mask);
   if (ret < 0) {
-    errno = -ret;
+    libc_errno = -ret;
     return -1;
   }
   if (size_t(ret) < cpuset_size) {
     // This means that only |ret| bytes in |mask| have been set. We will have to
     // zero out the remaining bytes.
     auto *mask_bytes = reinterpret_cast<uint8_t *>(mask);
     for (size_t i = size_t(ret); i < cpuset_size; ++i)
       mask_bytes[i] = 0;
   }
   return 0;
 }
 
 } // namespace __llvm_libc

libc/src/sched/linux/sched_setaffinity.cpp

 //===-- Implementation of sched_setaffinity -------------------------------===//
 //
 // 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/sched/sched_setaffinity.h"
 
 #include "src/__support/OSUtil/syscall.h" // For internal syscall function.
 #include "src/__support/common.h"
+#include "src/errno/libc_errno.h"
 
-#include <errno.h>
 #include <sched.h>
 #include <sys/syscall.h> // For syscall numbers.
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, sched_setaffinity,
                    (pid_t tid, size_t cpuset_size, const cpu_set_t *mask)) {
   long ret =
       __llvm_libc::syscall_impl(SYS_sched_setaffinity, tid, cpuset_size, mask);
   if (ret < 0) {
-    errno = -ret;
+    libc_errno = -ret;
     return -1;
   }
   return 0;
 }
 
 } // namespace __llvm_libc

libc/test/src/dirent/CMakeLists.txt

 add_subdirectory(testdata)
 add_libc_testsuite(libc_dirent_unittests)
 
 add_libc_unittest(
   dirent_test
   SUITE
     libc_dirent_unittests
   SRCS
     dirent_test.cpp
   DEPENDS
-    libc.include.dirent
     libc.src.__support.CPP.string_view
     libc.src.dirent.closedir
     libc.src.dirent.dirfd
     libc.src.dirent.opendir
     libc.src.dirent.readdir
+    libc.src.errno.errno
 )
 

libc/test/src/dirent/dirent_test.cpp

 //===-- Unittests for functions from POSIX dirent.h -----------------------===//
 //
 // 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/__support/CPP/string_view.h"
 #include "src/dirent/closedir.h"
 #include "src/dirent/dirfd.h"
 #include "src/dirent/opendir.h"
 #include "src/dirent/readdir.h"
+#include "src/errno/libc_errno.h"
 
 #include "test/UnitTest/Test.h"
 
 #include <dirent.h>
-#include <errno.h>
 
 using string_view = __llvm_libc::cpp::string_view;
 
 TEST(LlvmLibcDirentTest, SimpleOpenAndRead) {
   ::DIR *dir = __llvm_libc::opendir("testdata");
   ASSERT_TRUE(dir != nullptr);
   // The file descriptors 0, 1 and 2 are reserved for standard streams.
   // So, the file descriptor for the newly opened directory should be
if (string_view(&d->d_name[0]) == "file2.txt")
       file2 = d;
     if (string_view(&d->d_name[0]) == "dir1")
       dir1 = d;
     if (string_view(&d->d_name[0]) == "dir2")
       dir2 = d;
   }
 
   // Verify that we don't break out of the above loop in error.
-  ASSERT_EQ(errno, 0);
+  ASSERT_EQ(libc_errno, 0);
 
   ASSERT_TRUE(file1 != nullptr);
   ASSERT_TRUE(file2 != nullptr);
   ASSERT_TRUE(dir1 != nullptr);
   ASSERT_TRUE(dir2 != nullptr);
 
   ASSERT_EQ(__llvm_libc::closedir(dir), 0);
 }
 
 TEST(LlvmLibcDirentTest, OpenNonExistentDir) {
-  errno = 0;
+  libc_errno = 0;
   ::DIR *dir = __llvm_libc::opendir("___xyz123__.non_existent__");
   ASSERT_TRUE(dir == nullptr);
-  ASSERT_EQ(errno, ENOENT);
-  errno = 0;
+  ASSERT_EQ(libc_errno, ENOENT);
+  libc_errno = 0;
 }
 
 TEST(LlvmLibcDirentTest, OpenFile) {
-  errno = 0;
+  libc_errno = 0;
   ::DIR *dir = __llvm_libc::opendir("testdata/file1.txt");
   ASSERT_TRUE(dir == nullptr);
-  ASSERT_EQ(errno, ENOTDIR);
-  errno = 0;
+  ASSERT_EQ(libc_errno, ENOTDIR);
+  libc_errno = 0;
 }

libc/test/src/fcntl/CMakeLists.txt

 add_libc_testsuite(libc_fcntl_unittests)
 
 add_subdirectory(testdata)
 
 add_libc_unittest(
   creat_test
   SUITE
     libc_fcntl_unittests
   SRCS
     creat_test.cpp
   DEPENDS
-    libc.include.errno
     libc.include.fcntl
+    libc.src.errno.errno
     libc.src.fcntl.creat
     libc.src.fcntl.open
     libc.src.unistd.close
     libc.test.errno_setter_matcher
 )
 
 add_libc_unittest(
   openat_test
   SUITE
     libc_fcntl_unittests
   SRCS
     openat_test.cpp
   DEPENDS
-    libc.include.errno
     libc.include.fcntl
+    libc.src.errno.errno
     libc.src.fcntl.open
     libc.src.fcntl.openat
     libc.src.unistd.close
     libc.src.unistd.read
     libc.test.errno_setter_matcher
 )

libc/test/src/fcntl/creat_test.cpp

 //===-- Unittest for creat ------------------------------------------------===//
 //
 // 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/libc_errno.h"
 #include "src/fcntl/creat.h"
 #include "src/fcntl/open.h"
 #include "src/unistd/close.h"
 #include "test/ErrnoSetterMatcher.h"
 #include "test/UnitTest/Test.h"
 #include "utils/testutils/FDReader.h"
 
-#include <errno.h>
-
 TEST(LlvmLibcCreatTest, CreatAndOpen) {
   using __llvm_libc::testing::ErrnoSetterMatcher::Succeeds;
   constexpr const char *TEST_FILE = "testdata/creat.test";
   int fd = __llvm_libc::creat(TEST_FILE, S_IRWXU);
-  ASSERT_EQ(errno, 0);
+  ASSERT_EQ(libc_errno, 0);
   ASSERT_GT(fd, 0);
   ASSERT_THAT(__llvm_libc::close(fd), Succeeds(0));
 
   fd = __llvm_libc::open(TEST_FILE, O_RDONLY);
-  ASSERT_EQ(errno, 0);
+  ASSERT_EQ(libc_errno, 0);
   ASSERT_GT(fd, 0);
   ASSERT_THAT(__llvm_libc::close(fd), Succeeds(0));
 
   // TODO: 'remove' the test file at the end.
 }

libc/test/src/fcntl/openat_test.cpp

 //===-- Unittests for 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/errno/libc_errno.h"
 #include "src/fcntl/open.h"
 #include "src/fcntl/openat.h"
 #include "src/unistd/close.h"
 #include "src/unistd/read.h"
 #include "test/ErrnoSetterMatcher.h"
 #include "test/UnitTest/Test.h"
 #include "utils/testutils/FDReader.h"
 
-#include <errno.h>
 #include <fcntl.h>
 
 TEST(LlvmLibcUniStd, OpenAndReadTest) {
   using __llvm_libc::testing::ErrnoSetterMatcher::Succeeds;
   constexpr const char *TEST_DIR = "testdata";
   constexpr const char *TEST_FILE = "openat.test";
   int dir_fd = __llvm_libc::open(TEST_DIR, O_DIRECTORY);
-  ASSERT_EQ(errno, 0);
+  ASSERT_EQ(libc_errno, 0);
   ASSERT_GT(dir_fd, 0);
   constexpr const char TEST_MSG[] = "openat test";
   constexpr int TEST_MSG_SIZE = sizeof(TEST_MSG) - 1;
 
   int read_fd = __llvm_libc::openat(dir_fd, TEST_FILE, O_RDONLY);
-  ASSERT_EQ(errno, 0);
+  ASSERT_EQ(libc_errno, 0);
   ASSERT_GT(read_fd, 0);
   char read_buf[TEST_MSG_SIZE];
   ASSERT_THAT(__llvm_libc::read(read_fd, read_buf, TEST_MSG_SIZE),
               Succeeds(TEST_MSG_SIZE));
   ASSERT_THAT(__llvm_libc::close(read_fd), Succeeds(0));
   ASSERT_THAT(__llvm_libc::close(dir_fd), Succeeds(0));
 }
 
 TEST(LlvmLibcUniStd, FailTest) {
   using __llvm_libc::testing::ErrnoSetterMatcher::Fails;
   EXPECT_THAT(__llvm_libc::openat(AT_FDCWD, "openat.test", O_RDONLY),
               Fails(ENOENT));
 }

libc/test/src/sched/CMakeLists.txt

 add_libc_testsuite(libc_sched_unittests)
 
 add_libc_unittest(
   affinity_test
   SUITE
     libc_sched_unittests
   SRCS
     affinity_test.cpp
   DEPENDS
-    libc.include.errno
     libc.include.sched
     libc.include.sys_syscall
     libc.src.__support.OSUtil.osutil
+    libc.src.errno.errno
     libc.src.sched.sched_getaffinity
     libc.src.sched.sched_setaffinity
     libc.test.errno_setter_matcher
 )
 
 add_libc_unittest(
   cpu_count_test
   SUITE
     libc_sched_unittests
   SRCS
     cpu_count_test.cpp
   DEPENDS
-    libc.include.errno
     libc.include.sched
     libc.include.sys_syscall
     libc.src.__support.OSUtil.osutil
+    libc.src.errno.errno
     libc.src.sched.sched_getaffinity
     libc.src.sched.__sched_getcpucount
     libc.test.errno_setter_matcher
 )

libc/test/src/sched/affinity_test.cpp

 //===-- Unittests for sched_getaffinity and sched_setaffinity -------------===//
 //
 // 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/__support/OSUtil/syscall.h"
+#include "src/errno/libc_errno.h"
 #include "src/sched/sched_getaffinity.h"
 #include "src/sched/sched_setaffinity.h"
 #include "test/ErrnoSetterMatcher.h"
 
-#include <errno.h>
 #include <sched.h>
 #include <sys/syscall.h>
 
 TEST(LlvmLibcSchedAffinityTest, SmokeTest) {
   cpu_set_t mask;
-  errno = 0;
+  libc_errno = 0;
   using __llvm_libc::testing::ErrnoSetterMatcher::Succeeds;
   pid_t tid = __llvm_libc::syscall_impl(SYS_gettid);
   ASSERT_GT(tid, pid_t(0));
   // We just get and set the same mask.
   ASSERT_THAT(__llvm_libc::sched_getaffinity(tid, sizeof(cpu_set_t), &mask),
               Succeeds(0));
   ASSERT_THAT(__llvm_libc::sched_setaffinity(tid, sizeof(cpu_set_t), &mask),
               Succeeds(0));
 }
 
 TEST(LlvmLibcSchedAffinityTest, BadMask) {
   using __llvm_libc::testing::ErrnoSetterMatcher::Fails;
   pid_t tid = __llvm_libc::syscall_impl(SYS_gettid);
 
-  errno = 0;
+  libc_errno = 0;
   ASSERT_THAT(__llvm_libc::sched_getaffinity(tid, sizeof(cpu_set_t), nullptr),
               Fails(EFAULT));
 
-  errno = 0;
+  libc_errno = 0;
   ASSERT_THAT(__llvm_libc::sched_setaffinity(tid, sizeof(cpu_set_t), nullptr),
               Fails(EFAULT));
 
-  errno = 0;
+  libc_errno = 0;
 }

libc/test/src/sched/cpu_count_test.cpp

 //===-- Unittests for sched_getaffinity and sched_setaffinity -------------===//
 //
 // 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/__support/OSUtil/syscall.h"
+#include "src/errno/libc_errno.h"
 #include "src/sched/sched_getaffinity.h"
 #include "src/sched/sched_getcpucount.h"
 #include "test/ErrnoSetterMatcher.h"
 
-#include <errno.h>
 #include <sched.h>
 #include <sys/syscall.h>
 
 TEST(LlvmLibcSchedAffinityTest, SmokeTest) {
   cpu_set_t mask;
-  errno = 0;
+  libc_errno = 0;
   using __llvm_libc::testing::ErrnoSetterMatcher::Succeeds;
   pid_t tid = __llvm_libc::syscall_impl(SYS_gettid);
   ASSERT_GT(tid, pid_t(0));
   ASSERT_THAT(__llvm_libc::sched_getaffinity(tid, sizeof(cpu_set_t), &mask),
               Succeeds(0));
 
   // CPU_COUNT is a macro, but it expands to an LLVM-libc internal function that
   // needs to be in the appropriate namespace for the test.
   int num_cpus = __llvm_libc::CPU_COUNT(&mask);
   ASSERT_GT(num_cpus, 0);
   ASSERT_LE(num_cpus, int(sizeof(cpu_set_t) * sizeof(unsigned long)));
 }