[libc] Add support to compile some syscalls on 32 bit platform

[mikhail.ramalho]

Summary

This patch adds a bunch of ifdefs to handle the 32 bit versions of
some syscalls, which often only append a 64 to the name of the syscall
(with exception of SYS_lseek -> SYS_llseek and SYS_futex ->
SYS_futex_time64)

This patch also tries to handle cases where wait4 is not available
(as in riscv32): to implement wait, wait4 and waitpid when wait4 is
not available, we check for alternative wait calls and ultimately rely
on waitid to implement them all.

In riscv32, only waitid is available, so we need it to support this
platform.

[michaelrj]

libc/src/sys/wait/linux/wait.cpp

23

it might be set by the extra argument for this syscall, the man page mentions that the syscall is slightly different from the function. I've pasted the text below since I can't find it online:

The raw waitid() system call takes a fifth argument, of type struct rusage *.  If this argument  is  non-NULL,
then  it  is  used  to return resource usage information about the child, in the same manner as wait4(2).  See
getrusage(2) for details.

Even if it ends up not being relevant to this specific implementation, it'd probably still be good to put a NULL on the end of the syscall.

libc/src/sys/wait/linux/wait4.cpp

42

this list should include waitid

[mikhail.ramalho]

libc/src/sys/wait/linux/wait.cpp

23

Thanks! This actually simplifies the code!

[mikhail.ramalho]

Update waitid syscall

[mikhail.ramalho]

Added SYS_futex_time64 to syscall_numbers.h.inc

[mikhail.ramalho]

rebased

[mikhail.ramalho]

Added SYS_sched_rr_get_interval_time64 support to fix sched compilation in riscv32

[mikhail.ramalho]

ping

[michaelrj]

we should probably figure out what the appropriate waitpid errno values are before landing this. It's possible that the syscall returns them as negative numbers, but I haven't tested it yet.

libc/src/sched/linux/sched_rr_get_interval.cpp

32

should this return ret be here or should it instead fall down to the handling below?

also should ret be a long to match the other syscall above?

[sivachandra]

• Mostly LGTM but one suggestion: at all places where you added alternate paths to *64 syscalls, can you add commentary on when they will kick in and why they are to used?
• I will make another detailed pass over the wait* wrappers.

libc/src/__support/threads/linux/mutex.h

82

Can we add a constant, say FUTEX_SYSCALL_ID in https://github.com/llvm/llvm-project/blob/main/libc/src/__support/threads/linux/futex_word.h and avoid these widespread ifdefs?

[mikhail.ramalho]

• added siginfo_t dependency to wait.h
• added FUTEX_SYSCALL_ID
• changed SYS_sched_rr_get_interval_time64 to use struct __kernel_timespec instead of a long arr[2]
• improve wait* documentation

[mikhail.ramalho]

Apply clang-format to syscall_numbers.h.inc

[sivachandra]

libc/src/__support/File/linux_file.cpp

72 ↗

(On Diff #517369)

Can you point to some documentation about llseek on rv32?

libc/src/__support/threads/linux/futex_word.h

23

Quick googling tells me that SYS_futex_time64 is rv32 only construct. Can you add comment here saying that?

Also, WDYT doing it this way?

#if <rv32>
#ifndef SYS_futex_time64
#error "..."
#endif
constexpr auto FUTEX_SYSCALL_ID = SYS_futex_time64;
#else
constexpr auto FUTEX_SYSCALL_ID = SYS_futex;
#endif

libc/src/sched/linux/sched_rr_get_interval.cpp

31

ret > 0 ?

libc/src/sys/sendfile/linux/sendfile.cpp

26

Do you mean that the offset should be a pointer to a 64-bit value? If yes, can you add a static_assert here?

static_assert(sizeof(off_t) == 64);

libc/src/sys/wait/linux/wait4.cpp

20

Which one is required for rv32, SYS_waitpid or SYS_waitid?

25

Where is this getrusage coming from?

32

to

38

Why do we need this assert?

libc/src/sys/wait/linux/waitpid.cpp

18

Same question: can we limit to the exact SYS_wait* we want for rv32?

29

Why do we need this assert?

libc/src/unistd/linux/dup2.cpp

33

Can you add comments about how this 64 suffixed syscall number differs from the non-suffixed syscall?

libc/src/unistd/linux/ftruncate.cpp

25

Ditto.

libc/src/unistd/linux/truncate.cpp

25

Ditto.

[mikhail.ramalho]

• Added comments about sys_*64 syscalls
• Added assertion about offset size in sys_*64 syscalls
• Fixed wait4 implementation
• Rewrote wait and waitpid to use wait4

libc/src/__support/File/linux_file.cpp

72 ↗

(On Diff #517369)

You can find the llseek documentation here: https://man7.org/linux/man-pages/man3/lseek64.3.html

libc/src/__support/threads/linux/futex_word.h

23

AFAIK, SYS_futex_time64 is defined in every 32-bit arch that uses 64-bit time, e.g., in my armv7 machine:

$ clang -dM -E main1.c | grep futex
#define SYS_futex __NR_futex
#define SYS_futex_time64 __NR_futex_time64
#define __NR_futex (__NR_SYSCALL_BASE + 240)
#define __NR_futex_time64 (__NR_SYSCALL_BASE + 422)

The case for rv32 is that is only has SYS_futex_time64.

libc/src/sys/wait/linux/wait4.cpp

20

SYS_waitid

38

Fixed.

[mikhail.ramalho]

ping

[michaelrj]

libc/src/sys/wait/linux/wait.cpp

23

we generally don't allow calling public libc functions from other libc functions, so wait4 should be moved to a shared internal function. This allows platforms to include functions without having to deal with dependency chains. You can see how this is generally done with the string to integer functions that all include strtointeger, though in this case it probably doesn't need to go in __support.

libc/src/sys/wait/linux/wait4.cpp

20–22

We generally try to avoid setting errno in internal functions, so if you move wait4 to be an internal function you'll probably have to change its return type to ErrorOr<pid_t> and set errno after the call. This will be similar to how fseek works..

[sivachandra]

This is good to go after addressing @michaelrj's comments.

libc/src/sys/wait/linux/wait4.cpp

37

I think you should #include <signal.h> for CLD_* macros?

[mikhail.ramalho]

• Address comment about wait4 implementation
• Fix sched_getscheduler return value
• Fix sprintf test case for 32-bit systems

[mikhail.ramalho]

This PR is not done yet as I'm getting a weird error on the chmod test on rv32:

FAILED: projects/libc/test/src/sys/stat/CMakeFiles/libc.test.src.sys.stat.chmod_test /home/root/llvm-project/build/projects/libc/test/src/sys/stat/CMakeFiles/libc.test.src.sys.stat.chmod_test 
cd /home/root/llvm-project/build/projects/libc/test/src/sys/stat && /home/root/llvm-project/build/projects/libc/test/src/sys/stat/libc.test.src.sys.stat.chmod_test.__build__
[ RUN      ] LlvmLibcChmodTest.ChangeAndOpen
/home/root/llvm-project/libc/test/src/sys/stat/chmod_test.cpp:46: FAILURE
      Expected: __llvm_libc::open(TEST_FILE, 02000 | 01)
      Which is: 3
To be equal to: -1
      Which is: -1
/home/root/llvm-project/libc/test/src/sys/stat/chmod_test.cpp:47: FAILURE
          Expected: __llvm_libc::__llvmlibc_internal_errno
          Which is: 0
To be not equal to: 0
          Which is: 0

Apparently, I'm able to set the file as read-only but can also open it in write mode.

[mikhail.ramalho]

• Fixed ftruncate, truncate, pwrite and pread syscalls
• Rebased

[mikhail.ramalho]

Removed wrong ifdef

[mikhail.ramalho]

Changed wait4impl to return an ErrorOr object

[mikhail.ramalho]

folks, can I get another round of reviews on this patch? I've addressed all the comments.

[michaelrj]

LGTM with a minor nit

libc/test/src/sched/sched_rr_get_interval_test.cpp

32–33

nit: Generally I'd recommend using either long long or uint64_t for a larger type. long is only required to be at least 32 bits, and some systems (notably windows) use that size.

[gchatelet]

Hello Mikhail, it looks like https://reviews.llvm.org/D148371 broke the x86 linux build bots.
https://lab.llvm.org/buildbot/#/grid?tag=libc
https://lab.llvm.org/buildbot/#/builders/78/builds/55807/steps/4/logs/stdio

/home/sivachandra/libc-x86_64-debian/libc-x86_64-debian/llvm-project/libc/src/sched/linux/sched_rr_get_interval.cpp:15:10: fatal error: 'linux/time_types.h' file not found
#include <linux/time_types.h> // For __kernel_timespec.

Can you revert and reland when it's fixed? Thx!

[gchatelet]

Just saw https://github.com/llvm/llvm-project/commit/29dec352124a5fc1dcf03a640c2621496651ee90 which should fix it :)

libc/config/linux/api.td

 
 def SysStatAPI : PublicAPI<"sys/stat.h"> {
   let Types = ["mode_t", "dev_t", "ino_t", "nlink_t", "uid_t", "gid_t", "off_t",
                "struct timespec", "struct timeval", "blksize_t", "blkcnt_t",
                "struct stat"];
 }
 
 def SysWaitAPI : PublicAPI<"sys/wait.h"> {
-  let Types = ["pid_t", "struct rusage"];
+  let Types = ["pid_t", "struct rusage", "siginfo_t"];
 }
 
 def SysSendfileAPI : PublicAPI<"sys/sendfile.h"> {
   let Types = ["off_t", "size_t", "ssize_t"];
 }
 
 def SysTypesAPI : PublicAPI<"sys/types.h"> {
   let Types = ["blkcnt_t", "blksize_t", "clockid_t", "dev_t", "gid_t", "ino_t",

libc/config/linux/syscall_numbers.h.inc

 #ifdef __NR_clock_getres
 #define SYS_clock_getres __NR_clock_getres
 #endif
 
 #ifdef __NR_clock_gettime
 #define SYS_clock_gettime __NR_clock_gettime
 #endif
 
+#ifdef __NR_clock_gettime64
+#define SYS_clock_gettime64 __NR_clock_gettime64
+#endif
+
 #ifdef __NR_clock_nanosleep
 #define SYS_clock_nanosleep __NR_clock_nanosleep
 #endif
 
+#ifdef __NR_clock_nanosleep_time64
+#define SYS_clock_nanosleep_time64 __NR_clock_nanosleep_time64
+#endif
+
 #ifdef __NR_clock_settime
 #define SYS_clock_settime __NR_clock_settime
 #endif
 
 #ifdef __NR_clone
 #define SYS_clone __NR_clone
 #endif
 

 #ifdef __NR_ftruncate64
 #define SYS_ftruncate64 __NR_ftruncate64
 #endif
 
 #ifdef __NR_futex
 #define SYS_futex __NR_futex
 #endif
 
+#ifdef __NR_futex_time64
+#define SYS_futex_time64 __NR_futex_time64
+#endif
+
 #ifdef __NR_futimesat
 #define SYS_futimesat __NR_futimesat
 #endif
 
 #ifdef __NR_get_kernel_syms
 #define SYS_get_kernel_syms __NR_get_kernel_syms
 #endif
 

 #ifdef __NR_profil
 #define SYS_profil __NR_profil
 #endif
 
 #ifdef __NR_pselect6
 #define SYS_pselect6 __NR_pselect6
 #endif
 
+#ifdef __NR_pselect6_time64
+#define SYS_pselect6_time64 __NR_pselect6_time64
+#endif
+
 #ifdef __NR_ptrace
 #define SYS_ptrace __NR_ptrace
 #endif
 
 #ifdef __NR_putpmsg
 #define SYS_putpmsg __NR_putpmsg
 #endif
 

 #ifdef __NR_sched_getscheduler
 #define SYS_sched_getscheduler __NR_sched_getscheduler
 #endif
 
 #ifdef __NR_sched_rr_get_interval
 #define SYS_sched_rr_get_interval __NR_sched_rr_get_interval
 #endif
 
+#ifdef __NR_sched_rr_get_interval_time64
+#define SYS_sched_rr_get_interval_time64 __NR_sched_rr_get_interval_time64
+#endif
+
 #ifdef __NR_sched_set_affinity
 #define SYS_sched_set_affinity __NR_sched_set_affinity
 #endif
 
 #ifdef __NR_sched_setaffinity
 #define SYS_sched_setaffinity __NR_sched_setaffinity
 #endif
 

 
 #ifdef __NR_write
 #define SYS_write __NR_write
 #endif
 
 #ifdef __NR_writev
 #define SYS_writev __NR_writev
 #endif
-

libc/include/CMakeLists.txt

add_gen_header(
   sys_wait
   DEF_FILE sys/wait.h.def
   GEN_HDR sys/wait.h
   DEPENDS
     .llvm_libc_common_h
     .llvm-libc-macros.sys_wait_macros
     .llvm-libc-types.pid_t
     .llvm-libc-types.struct_rusage
+    .llvm-libc-types.siginfo_t
 )
 
 add_gen_header(
   termios
   DEF_FILE termios.h.def
   GEN_HDR termios.h
   DEPENDS
     .llvm_libc_common_h

libc/include/llvm-libc-macros/linux/signal-macros.h

 #else
 #error "Signal stack sizes not defined for your platform."
 #endif
 
 #define SIG_DFL ((__sighandler_t)0)
 #define SIG_IGN ((__sighandler_t)1)
 #define SIG_ERR ((__sighandler_t)-1)
 
+// SIGCHLD si_codes
+#define CLD_EXITED 1    // child has exited
+#define CLD_KILLED 2    // child was killed
+#define CLD_DUMPED 3    // child terminated abnormally
+#define CLD_TRAPPED 4   // traced child has trapped
+#define CLD_STOPPED 5   // child has stopped
+#define CLD_CONTINUED 6 // stopped child has continued
+
 #endif // __LLVM_LIBC_MACROS_LINUX_SIGNUM_MACROS_H

libc/include/llvm-libc-macros/linux/sys-wait-macros.h

 //===-- Definition of macros from sys/wait.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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef __LLVM_LIBC_MACROS_LINUX_SYS_WAIT_MACROS_H
 #define __LLVM_LIBC_MACROS_LINUX_SYS_WAIT_MACROS_H
 
 // Wait flags
 #define WNOHANG 1    // Do not block
 #define WUNTRACED 2  // Report is a child has stopped even if untraced
+#define WEXITED 4    // Report dead child
 #define WCONTINUED 8 // Report if a stopped child has been resumed by SIGCONT
+#define WSTOPPED WUNTRACED
 
 // Wait status info macros
-#define WTERMSIG(status) (((status)&0x7F))
-#define WIFEXITED(status) (WTERMSIG(status) == 0)
-#define WEXITSTATUS(status) (((status)&0xFF00) >> 8)
-#define WIFSIGNALED(status)                                                    \
-  ((WTERMSIG(status) < 0x7F) && (WTERMSIG(status) > 0))
+#define __WEXITSTATUS(status) (((status)&0xff00) >> 8)
+#define __WTERMSIG(status) ((status)&0x7f)
+#define __WIFEXITED(status) (__WTERMSIG(status) == 0)
+
+// Macros for constructing status values.
+#define __W_EXITCODE(ret, sig) ((ret) << 8 | (sig))
+#define __W_STOPCODE(sig) ((sig) << 8 | 0x7f)
+#define __W_CONTINUED 0xffff
+#define __WCOREFLAG 0x80
+
+#define WEXITSTATUS(status) __WEXITSTATUS(status)
+#define WTERMSIG(status) __WTERMSIG(status)
+#define WIFEXITED(status) __WIFEXITED(status)
+
+#define WCOREFLAG __WCOREFLAG
+#define W_EXITCODE(ret, sig) __W_EXITCODE(ret, sig)
+#define W_STOPCODE(sig) __W_STOPCODE(sig)
+
+// First argument to waitid:
+#define P_ALL 0
+#define P_PID 1
+#define P_PGID 2
+#define P_PIDFD 3
 
 #endif // __LLVM_LIBC_MACROS_LINUX_SYS_WAIT_MACROS_H

libc/spec/posix.td

HeaderSpec Time = HeaderSpec<
               [ArgSpec<StructTimeSpecPtr>, ArgSpec<StructTimeSpecPtr>]
           >,
       ]
   >;
 
   HeaderSpec SysWait = HeaderSpec<
     "sys/wait.h",
     [], // Macros
-    [PidT, StructRUsage],
+    [PidT, StructRUsage, SigInfoType],
     [], // Enumerations
     [
       FunctionSpec<
         "wait",
         RetValSpec<PidT>,
         [ArgSpec<IntPtr>]
       >,
       FunctionSpec<

libc/src/__support/File/linux/file.cpp

 }
 
 ErrorOr<long> seek_func(File *f, long offset, int whence) {
   auto *lf = reinterpret_cast<LinuxFile *>(f);
   long result;
 #ifdef SYS_lseek
   int ret = __llvm_libc::syscall_impl(SYS_lseek, lf->get_fd(), offset, whence);
   result = ret;
+#elif defined(SYS_llseek)
+  int ret = __llvm_libc::syscall_impl(SYS_llseek, lf->get_fd(),
+                                      (long)(((uint64_t)(offset)) >> 32),
+                                      (long)offset, &result, whence);
+  result = ret;
 #elif defined(SYS__llseek)
-  long result;
   int ret = __llvm_libc::syscall_impl(SYS__llseek, lf->get_fd(), offset >> 32,
                                       offset, &result, whence);
 #else
-#error "lseek and _llseek syscalls not available to perform a seek operation."
+#error "lseek, llseek and _llseek syscalls not available."
 #endif
 
   if (ret < 0)
     return Error(-ret);
 
   return result;
 }
 

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

int callonce(CallOnceFlag *flag, CallOnceCallback *func) {
   FutexWordType not_called = NOT_CALLED;
 
   // The call_once call can return only after the called function |func|
   // returns. So, we use futexes to synchronize calls with the same flag value.
   if (futex_word->compare_exchange_strong(not_called, START)) {
     func();
     auto status = futex_word->exchange(FINISH);
     if (status == WAITING) {
-      __llvm_libc::syscall_impl(SYS_futex, &futex_word->val, FUTEX_WAKE_PRIVATE,
+      __llvm_libc::syscall_impl(FUTEX_SYSCALL_ID, &futex_word->val,
+                                FUTEX_WAKE_PRIVATE,
                                 INT_MAX, // Wake all waiters.
                                 0, 0, 0);
     }
     return 0;
   }
 
   FutexWordType status = START;
   if (futex_word->compare_exchange_strong(status, WAITING) ||
       status == WAITING) {
     __llvm_libc::syscall_impl(
-        SYS_futex, &futex_word->val, FUTEX_WAIT_PRIVATE,
+        FUTEX_SYSCALL_ID, &futex_word->val, FUTEX_WAIT_PRIVATE,
         WAITING, // Block only if status is still |WAITING|.
         0, 0, 0);
   }
 
   return 0;
 }
 
 } // namespace __llvm_libc

libc/src/__support/threads/linux/futex_word.h

 //===--- Definition of a type for a futex word ------------------*- 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_SUPPORT_THREADS_LINUX_FUTEX_WORD_H
 #define LLVM_LIBC_SRC_SUPPORT_THREADS_LINUX_FUTEX_WORD_H
 
 #include <stdint.h>
+#include <sys/syscall.h>
 
 namespace __llvm_libc {
 
 // Futexes are 32 bits in size on all platforms, including 64-bit platforms.
 using FutexWordType = uint32_t;
 
+#if SYS_futex
+constexpr auto FUTEX_SYSCALL_ID = SYS_futex;
+#elif defined(SYS_futex_time64)
+constexpr auto FUTEX_SYSCALL_ID = SYS_futex_time64;
+#else
+#error "futex and futex_time64 syscalls not available."
+#endif
+
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_SUPPORT_THREADS_LINUX_FUTEX_WORD_H

libc/src/__support/threads/linux/mutex.h

while (true) {
       }
 
       switch (LockState(mutex_status)) {
       case LockState::Waiting:
         // If other threads are waiting already, then join them. Note that the
         // futex syscall will block if the futex data is still
         // `LockState::Waiting` (the 4th argument to the syscall function
         // below.)
-        __llvm_libc::syscall_impl(SYS_futex, &futex_word.val,
+        __llvm_libc::syscall_impl(FUTEX_SYSCALL_ID, &futex_word.val,
                                   FUTEX_WAIT_PRIVATE,
                                   FutexWordType(LockState::Waiting), 0, 0, 0);
         was_waiting = true;
         // Once woken up/unblocked, try everything all over.
         continue;
       case LockState::Locked:
         // Mutex has been locked by another thread so set the status to
         // LockState::Waiting.
         if (futex_word.compare_exchange_strong(
                 locked_status, FutexWordType(LockState::Waiting))) {
           // If we are able to set the futex data to `LockState::Waiting`, then
           // we will wait for the futex to be woken up. Note again that the
           // following syscall will block only if the futex data is still
           // `LockState::Waiting`.
-          __llvm_libc::syscall_impl(SYS_futex, &futex_word, FUTEX_WAIT_PRIVATE,
+          __llvm_libc::syscall_impl(FUTEX_SYSCALL_ID, &futex_word,
+                                    FUTEX_WAIT_PRIVATE,
                                     FutexWordType(LockState::Waiting), 0, 0, 0);
           was_waiting = true;
         }
         continue;
       case LockState::Free:
         // If it was LockState::Free, we shouldn't be here at all.
         return MutexError::BAD_LOCK_STATE;
       }
     }
   }
 
   MutexError unlock() {
     while (true) {
       FutexWordType mutex_status = FutexWordType(LockState::Waiting);
       if (futex_word.compare_exchange_strong(mutex_status,
                                              FutexWordType(LockState::Free))) {
         // If any thread is waiting to be woken up, then do it.
-        __llvm_libc::syscall_impl(SYS_futex, &futex_word, FUTEX_WAKE_PRIVATE, 1,
-                                  0, 0, 0);
+        __llvm_libc::syscall_impl(FUTEX_SYSCALL_ID, &futex_word,
+                                  FUTEX_WAKE_PRIVATE, 1, 0, 0, 0);
         return MutexError::NONE;
       }
 
       if (mutex_status == FutexWordType(LockState::Locked)) {
         // If nobody was waiting at this point, just free it.
         if (futex_word.compare_exchange_strong(mutex_status,
                                                FutexWordType(LockState::Free)))
           return MutexError::NONE;

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

#ifdef LIBC_TARGET_ARCH_IS_AARCH64
     // We set the frame pointer to be the same as the "sp" so that start args
     // can be sniffed out from start_thread.
 #ifdef __clang__
     // GCC does not currently implement __arm_wsr64/__arm_rsr64.
     __arm_wsr64("x29", __arm_rsr64("sp"));
 #else
     asm volatile("mov x29, sp");
 #endif
-#elif defined(LIBC_TARGET_ARCH_IS_RISCV64)
+#elif defined(LIBC_TARGET_ARCH_IS_ANY_RISCV)
     asm volatile("mv fp, sp");
 #endif
     start_thread();
   } else if (clone_result < 0) {
     cleanup_thread_resources(attrib);
     return -clone_result;
   }
 
void Thread::wait() {
   // The kernel should set the value at the clear tid address to zero.
   // If not, it is a spurious wake and we should continue to wait on
   // the futex.
   auto *clear_tid =
       reinterpret_cast<cpp::Atomic<FutexWordType> *>(attrib->platform_data);
   while (clear_tid->load() != 0) {
     // We cannot do a FUTEX_WAIT_PRIVATE here as the kernel does a
     // FUTEX_WAKE and not a FUTEX_WAKE_PRIVATE.
-    __llvm_libc::syscall_impl(SYS_futex, &clear_tid->val, FUTEX_WAIT,
+    __llvm_libc::syscall_impl(FUTEX_SYSCALL_ID, &clear_tid->val, FUTEX_WAIT,
                               CLEAR_TID_VALUE, nullptr);
   }
 }
 
 bool Thread::operator==(const Thread &thread) const {
   return attrib->tid == thread.attrib->tid;
 }
 

libc/src/sched/linux/sched_rr_get_interval.cpp

 //===-- Implementation of sched_rr_get_interval ---------------------------===//
 //
 // 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_rr_get_interval.h"
 
 #include "src/__support/OSUtil/syscall.h" // For internal syscall function.
 #include "src/__support/common.h"
 #include "src/errno/libc_errno.h"
 
+#include <linux/time_types.h> // For __kernel_timespec.
 #include <sys/syscall.h> // For syscall numbers.
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, sched_rr_get_interval,
                    (pid_t tid, struct timespec *tp)) {
+#ifdef SYS_sched_rr_get_interval
   long ret = __llvm_libc::syscall_impl(SYS_sched_rr_get_interval, tid, tp);
+#elif defined(SYS_sched_rr_get_interval_time64)
+  // The difference between the  and SYS_sched_rr_get_interval
+  // SYS_sched_rr_get_interval_time64 syscalls is the data type used for the
+  // time interval parameter: the latter takes a struct __kernel_timespec
+  long ret;
+  if (tp) {
+    struct __kernel_timespec ts32;
+    ret =
+        __llvm_libc::syscall_impl(SYS_sched_rr_get_interval_time64, tid, &ts32);
+    if (ret == 0) {
+      tp->tv_sec = ts32.tv_sec;
+      tp->tv_nsec = ts32.tv_nsec;
+    }
+  } else
+    // When tp is a nullptr, we still do the syscall to set ret and errno
+    ret = __llvm_libc::syscall_impl(SYS_sched_rr_get_interval_time64, tid,
+                                    nullptr);
+#else
+#error                                                                         \
+    "sched_rr_get_interval and sched_rr_get_interval_time64 syscalls not available."
+#endif
   if (ret < 0) {
     libc_errno = -ret;
     return -1;
   }
   return 0;
 }
 
 } // namespace __llvm_libc

libc/src/sys/select/linux/select.cpp

if ((TIME_MAX - timeout->tv_sec) < (timeout->tv_usec / 1000000)) {
       ts.tv_sec = TIME_MAX;
       ts.tv_nsec = 999999999;
     } else {
       ts.tv_sec = timeout->tv_sec + timeout->tv_usec / 1000000;
       ts.tv_nsec = timeout->tv_usec * 1000;
     }
   }
   pselect6_sigset_t pss{nullptr, sizeof(sigset_t)};
+#if SYS_pselect6
   long ret = __llvm_libc::syscall_impl(SYS_pselect6, nfds, read_set, write_set,
                                        error_set, &ts, &pss);
+#elif defined(SYS_pselect6_time64)
+  long ret = __llvm_libc::syscall_impl(SYS_pselect6_time64, nfds, read_set,
+                                       write_set, error_set, &ts, &pss);
+#else
+#error "SYS_pselect6 and SYS_pselect6_time64 syscalls not available."
+#endif
   if (ret < 0) {
     libc_errno = -ret;
     return -1;
   }
   return ret;
 }
 
 } // namespace __llvm_libc

libc/src/sys/sendfile/linux/sendfile.cpp

 #include "src/errno/libc_errno.h"
 #include <sys/sendfile.h>
 #include <sys/syscall.h> // For syscall numbers.
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(ssize_t, sendfile,
                    (int out_fd, int in_fd, off_t *offset, size_t count)) {
+#ifdef SYS_sendfile
   long ret =
       __llvm_libc::syscall_impl(SYS_sendfile, in_fd, out_fd, offset, count);
+#elif defined(SYS_sendfile64)
+  // Same as sendfile but can handle large offsets
+  static_assert(sizeof(off_t) == 8);
+  long ret =
+      __llvm_libc::syscall_impl(SYS_sendfile64, in_fd, out_fd, offset, count);
+#else
+#error "sendfile and sendfile64 syscalls not available."
+#endif
   if (ret < 0) {
     libc_errno = -ret;
     return -1;
   }
   return ret;
 }
 
 } // namespace __llvm_libc

libc/src/sys/wait/linux/wait.cpp

 //===-- Linux implementation of wait --------------------------------------===//
 //
 // 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/wait/wait.h"
-
-#include "src/__support/OSUtil/syscall.h" // For internal syscall function.
 #include "src/__support/common.h"
+#include "src/__support/libc_assert.h"
 
-#include "src/errno/libc_errno.h"
-#include <sys/syscall.h> // For syscall numbers.
-#include <sys/wait.h>
+#include "src/sys/wait/wait.h"
+#include "src/sys/wait/wait4Impl.h"
 
 namespace __llvm_libc {
 
-// The implementation of wait here is very minimal. We will add more
-// functionality and standard compliance in future.
-
 LLVM_LIBC_FUNCTION(pid_t, wait, (int *wait_status)) {
-  pid_t pid = __llvm_libc::syscall_impl(SYS_wait4, -1, wait_status, 0, 0);
-  if (pid < 0) {
-    // Error case, a child process was not created.
-    libc_errno = -pid;
+  auto result = internal::wait4impl(-1, wait_status, 0, 0);
+  if (!result.has_value()) {
+    libc_errno = result.error();
     return -1;
   }
-
-  return pid;
+  return result.value();
 }
 
 } // namespace __llvm_libc

libc/src/sys/wait/linux/wait4.cpp

 //===-- Linux implementation of wait4 -------------------------------------===//
 //
 // 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/wait/wait4.h"
-
-#include "src/__support/OSUtil/syscall.h" // For internal syscall function.
 #include "src/__support/common.h"
+#include "src/__support/libc_assert.h"
 
-#include "src/errno/libc_errno.h"
-#include <sys/syscall.h> // For syscall numbers.
-#include <sys/wait.h>
+#include "src/sys/wait/wait4.h"
+#include "src/sys/wait/wait4Impl.h"
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(pid_t, wait4,
                    (pid_t pid, int *wait_status, int options,
                     struct rusage *usage)) {
-  pid = __llvm_libc::syscall_impl(SYS_wait4, pid, wait_status, options, usage);
-  if (pid < 0) {
-    libc_errno = -pid;
+  auto result = internal::wait4impl(pid, wait_status, options, usage);
+  if (!result.has_value()) {
+    libc_errno = result.error();
     return -1;
   }
-  return pid;
+  return result.value();
 }
 
 } // namespace __llvm_libc

libc/src/sys/wait/linux/waitpid.cpp

 //===-- Linux implementation of waitpid -----------------------------------===//
 //
 // 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/wait/waitpid.h"
-
-#include "src/__support/OSUtil/syscall.h" // For internal syscall function.
 #include "src/__support/common.h"
+#include "src/__support/libc_assert.h"
 
-#include "src/errno/libc_errno.h"
-#include <sys/syscall.h> // For syscall numbers.
-#include <sys/wait.h>
+#include "src/sys/wait/wait4Impl.h"
+#include "src/sys/wait/waitpid.h"
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(pid_t, waitpid, (pid_t pid, int *wait_status, int options)) {
-  pid = __llvm_libc::syscall_impl(SYS_wait4, pid, wait_status, options, 0);
-  if (pid < 0) {
-    libc_errno = -pid;
+  auto result = internal::wait4impl(pid, wait_status, options, 0);
+  if (!result.has_value()) {
+    libc_errno = result.error();
     return -1;
   }
-  return pid;
+  return result.value();
 }
 
 } // namespace __llvm_libc

libc/src/sys/wait/wait4Impl.h

+//===-- String to integer conversion utils ----------------------*- 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_SYS_WAIT_WAIT4IMPL_H
+#define LLVM_LIBC_SRC_SYS_WAIT_WAIT4IMPL_H
+
+#include "src/__support/OSUtil/syscall.h" // For internal syscall function.
+#include "src/__support/common.h"
+#include "src/__support/error_or.h"
+#include "src/errno/libc_errno.h"
+
+#include <sys/signal.h>
+#include <sys/syscall.h> // For syscall numbers.
+#include <sys/wait.h>
+
+namespace __llvm_libc {
+namespace internal {
+
+// The implementation of wait here is very minimal. We will add more
+// functionality and standard compliance in future.
+
+LIBC_INLINE ErrorOr<pid_t> wait4impl(pid_t pid, int *wait_status, int options,
+                                     struct rusage *usage) {
+#if SYS_wait4
+  pid = __llvm_libc::syscall_impl(SYS_wait4, pid, wait_status, options, usage);
+#elif defined(SYS_waitid)
+  int idtype = P_PID;
+  if (pid == -1) {
+    idtype = P_ALL;
+  } else if (pid < -1) {
+    idtype = P_PGID;
+    pid *= -1;
+  } else if (pid == 0) {
+    idtype = P_PGID;
+  }
+
+  options |= WEXITED;
+
+  siginfo_t info;
+  pid =
+      __llvm_libc::syscall_impl(SYS_waitid, idtype, pid, &info, options, usage);
+  if (pid >= 0)
+    pid = info.si_pid;
+
+  if (wait_status) {
+    switch (info.si_code) {
+    case CLD_EXITED:
+      *wait_status = W_EXITCODE(info.si_status, 0);
+      break;
+    case CLD_DUMPED:
+      *wait_status = info.si_status | WCOREFLAG;
+      break;
+    case CLD_KILLED:
+      *wait_status = info.si_status;
+      break;
+    case CLD_TRAPPED:
+    case CLD_STOPPED:
+      *wait_status = W_STOPCODE(info.si_status);
+      break;
+    case CLD_CONTINUED:
+      *wait_status = __W_CONTINUED;
+      break;
+    default:
+      *wait_status = 0;
+      break;
+    }
+  }
+#else
+#error "wait4 and waitid syscalls not available."
+#endif
+  if (pid < 0)
+    return Error(-pid);
+  return pid;
+}
+
+} // namespace internal
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_SYS_WAIT_WAIT4IMPL_H

libc/src/threads/linux/CndVar.h

CndWaiter waiter;
           waitq_front = nullptr;
         else
           waitq_back->next = nullptr;
 
         return thrd_error;
       }
     }
 
-    __llvm_libc::syscall_impl(SYS_futex, &waiter.futex_word.val, FUTEX_WAIT,
-                              WS_Waiting, 0, 0, 0);
+    __llvm_libc::syscall_impl(FUTEX_SYSCALL_ID, &waiter.futex_word.val,
+                              FUTEX_WAIT, WS_Waiting, 0, 0, 0);
 
     // At this point, if locking |m| fails, we can simply return as the
     // queued up waiter would have been removed from the queue.
     auto err = m->lock();
     return err == MutexError::NONE ? thrd_success : thrd_error;
   }
 
   int notify_one() {
     // We don't use an RAII locker in this method as we want to unlock
     // |qmtx| and signal the waiter using a single FUTEX_WAKE_OP signal.
     qmtx.lock();
     if (waitq_front == nullptr) {
       qmtx.unlock();
       return thrd_success;
     }
 
     CndWaiter *first = waitq_front;
     waitq_front = waitq_front->next;
     if (waitq_front == nullptr)
       waitq_back = nullptr;
 
     qmtx.futex_word = FutexWordType(Mutex::LockState::Free);
 
     __llvm_libc::syscall_impl(
-        SYS_futex, &qmtx.futex_word.val, FUTEX_WAKE_OP, 1, 1,
+        FUTEX_SYSCALL_ID, &qmtx.futex_word.val, FUTEX_WAKE_OP, 1, 1,
         &first->futex_word.val,
         FUTEX_OP(FUTEX_OP_SET, WS_Signalled, FUTEX_OP_CMP_EQ, WS_Waiting));
     return thrd_success;
   }
 
   int broadcast() {
     MutexLock ml(&qmtx);
     uint32_t dummy_futex_word;
     CndWaiter *waiter = waitq_front;
     waitq_front = waitq_back = nullptr;
     while (waiter != nullptr) {
       // FUTEX_WAKE_OP is used instead of just FUTEX_WAKE as it allows us to
       // atomically update the waiter status to WS_Signalled before waking
       // up the waiter. A dummy location is used for the other futex of
       // FUTEX_WAKE_OP.
       __llvm_libc::syscall_impl(
-          SYS_futex, &dummy_futex_word, FUTEX_WAKE_OP, 1, 1,
+          FUTEX_SYSCALL_ID, &dummy_futex_word, FUTEX_WAKE_OP, 1, 1,
           &waiter->futex_word.val,
           FUTEX_OP(FUTEX_OP_SET, WS_Signalled, FUTEX_OP_CMP_EQ, WS_Waiting));
       waiter = waiter->next;
     }
     return thrd_success;
   }
 };
 
 static_assert(sizeof(CndVar) == sizeof(cnd_t),
               "Mismatch in the size of the "
               "internal representation of condition variable and the public "
               "cnd_t type.");
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_THREADS_LINUX_CNDVAR_H

libc/src/threads/linux/call_once.cpp

LLVM_LIBC_FUNCTION(void, call_once,
   //
   // What this means is that, the call_once call can return only after
   // the called function |func| returns. So, we use futexes to synchronize
   // calls with the same flag value.
   if (futex_word->compare_exchange_strong(not_called, START)) {
     func();
     auto status = futex_word->exchange(FINISH);
     if (status == WAITING) {
-      __llvm_libc::syscall_impl(SYS_futex, &futex_word->val, FUTEX_WAKE_PRIVATE,
+      __llvm_libc::syscall_impl(FUTEX_SYSCALL_ID, &futex_word->val,
+                                FUTEX_WAKE_PRIVATE,
                                 INT_MAX, // Wake all waiters.
                                 0, 0, 0);
     }
     return;
   }
 
   FutexWordType status = START;
   if (futex_word->compare_exchange_strong(status, WAITING) ||
       status == WAITING) {
     __llvm_libc::syscall_impl(
-        SYS_futex, &futex_word->val, FUTEX_WAIT_PRIVATE,
+        FUTEX_SYSCALL_ID, &futex_word->val, FUTEX_WAIT_PRIVATE,
         WAITING, // Block only if status is still |WAITING|.
         0, 0, 0);
   }
 }
 
 } // namespace __llvm_libc

libc/src/time/clock_gettime.cpp

 #include <sys/syscall.h> // For syscall numbers.
 #include <time.h>
 
 namespace __llvm_libc {
 
 // TODO(michaelrj): Move this into time/linux with the other syscalls.
 LLVM_LIBC_FUNCTION(int, clock_gettime,
                    (clockid_t clockid, struct timespec *tp)) {
+#if SYS_clock_gettime
   long ret_val =
       __llvm_libc::syscall_impl(SYS_clock_gettime, static_cast<long>(clockid),
                                 reinterpret_cast<long>(tp));
+#elif defined(SYS_clock_gettime64)
+  long ret_val =
+      __llvm_libc::syscall_impl(SYS_clock_gettime64, static_cast<long>(clockid),
+                                reinterpret_cast<long>(tp));
+#else
+#error "SYS_clock_gettime and SYS_clock_gettime64 syscalls not available."
+#endif
+
   // A negative return value indicates an error with the magnitude of the
   // value being the error code.
   if (ret_val < 0) {
     libc_errno = -ret_val;
     return -1;
   }
 
   return 0;
 }
 
 } // namespace __llvm_libc

libc/src/time/gettimeofday.cpp

 namespace __llvm_libc {
 
 // TODO(michaelrj): Move this into time/linux with the other syscalls.
 LLVM_LIBC_FUNCTION(int, gettimeofday,
                    (struct timeval * tv, [[maybe_unused]] void *unused)) {
   if (tv == nullptr)
     return 0;
   struct timespec tp;
+#if SYS_clock_gettime
   long ret_val = __llvm_libc::syscall_impl(SYS_clock_gettime,
                                            static_cast<long>(CLOCK_REALTIME),
                                            reinterpret_cast<long>(&tp));
+#elif defined(SYS_clock_gettime64)
+  long ret_val = __llvm_libc::syscall_impl(SYS_clock_gettime64,
+                                           static_cast<long>(CLOCK_REALTIME),
+                                           reinterpret_cast<long>(&tp));
+#else
+#error "SYS_clock_gettime and SYS_clock_gettime64 syscalls not available."
+#endif
   // A negative return value indicates an error with the magnitude of the
   // value being the error code.
   if (ret_val < 0) {
     libc_errno = -ret_val;
     return -1;
   }
   tv->tv_sec = tp.tv_sec;
   tv->tv_usec = tp.tv_nsec / 1000;
   return 0;
 }
 
 } // namespace __llvm_libc

libc/src/time/linux/clock.cpp

 
 #include <sys/syscall.h> // For syscall numbers.
 #include <time.h>
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(clock_t, clock, ()) {
   struct timespec ts;
+#if SYS_clock_gettime
   long ret_val = __llvm_libc::syscall_impl(
       SYS_clock_gettime, CLOCK_PROCESS_CPUTIME_ID, reinterpret_cast<long>(&ts));
+#elif defined(SYS_clock_gettime64)
+  long ret_val =
+      __llvm_libc::syscall_impl(SYS_clock_gettime64, CLOCK_PROCESS_CPUTIME_ID,
+                                reinterpret_cast<long>(&ts));
+#else
+#error "SYS_clock_gettime and SYS_clock_gettime64 syscalls not available."
+#endif
   if (ret_val < 0) {
     libc_errno = -ret_val;
     return clock_t(-1);
   }
 
   // The above syscall gets the CPU time in seconds plus nanoseconds.
   // The standard requires that we return clock_t(-1) if we cannot represent
   // clocks as a clock_t value.

libc/src/time/linux/time.cpp

 #include <sys/syscall.h> // For syscall numbers.
 #include <time.h>
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(time_t, time, (time_t * tp)) {
   // TODO: Use the Linux VDSO to fetch the time and avoid the syscall.
   struct timespec ts;
+#if SYS_clock_gettime
   long ret_val = __llvm_libc::syscall_impl(SYS_clock_gettime, CLOCK_REALTIME,
                                            reinterpret_cast<long>(&ts));
+#elif defined(SYS_clock_gettime64)
+  long ret_val = __llvm_libc::syscall_impl(SYS_clock_gettime64, CLOCK_REALTIME,
+                                           reinterpret_cast<long>(&ts));
+#else
+#error "SYS_clock_gettime and SYS_clock_gettime64 syscalls not available."
+#endif
   if (ret_val < 0) {
     libc_errno = -ret_val;
     return -1;
   }
 
   if (tp != nullptr)
     *tp = time_t(ts.tv_sec);
   return time_t(ts.tv_sec);
 }
 
 } // namespace __llvm_libc

libc/src/time/nanosleep.cpp

 
 #include <sys/syscall.h> // For syscall numbers.
 
 namespace __llvm_libc {
 
 // TODO(michaelrj): Move this into time/linux with the other syscalls.
 LLVM_LIBC_FUNCTION(int, nanosleep,
                    (const struct timespec *req, struct timespec *rem)) {
+#if SYS_nanosleep
   int ret = __llvm_libc::syscall_impl(SYS_nanosleep, req, rem);
+#elif defined(SYS_clock_nanosleep_time64)
+  int ret = __llvm_libc::syscall_impl(SYS_clock_nanosleep_time64, req, rem);
+#else
+#error "SYS_nanosleep and SYS_clock_nanosleep_time64 syscalls not available."
+#endif
+
   if (ret < 0) {
     libc_errno = -ret;
     return -1;
   }
   return ret;
 }
 
 } // namespace __llvm_libc

libc/src/unistd/linux/dup2.cpp

#ifdef SYS_dup2
   // If dup2 syscall is available, we make use of directly.
   long ret = __llvm_libc::syscall_impl(SYS_dup2, oldfd, newfd);
 #elif defined(SYS_dup3)
   // If dup2 syscall is not available, we try using the dup3 syscall. However,
   // dup3 fails if oldfd is the same as newfd. So, we handle that case
   // separately before making the dup3 syscall.
   if (oldfd == newfd) {
     // Check if oldfd is actually a valid file descriptor.
+#if SYS_fcntl
     long ret = __llvm_libc::syscall_impl(SYS_fcntl, oldfd, F_GETFD);
+#elif defined(SYS_fcntl64)
+    // Same as fcntl but can handle large offsets
+    static_assert(sizeof(off_t) == 8);
+    long ret = __llvm_libc::syscall_impl(SYS_fcntl64, oldfd, F_GETFD);
+#else
+#error "SYS_fcntl and SYS_fcntl64 syscalls not available."
+#endif
     if (ret >= 0)
       return oldfd;
     libc_errno = -ret;
     return -1;
   }
   long ret = __llvm_libc::syscall_impl(SYS_dup3, oldfd, newfd, 0);
 #else
 #error "dup2 and dup3 syscalls not available."

libc/src/unistd/linux/ftruncate.cpp

 //===-- Linux implementation of ftruncate ---------------------------------===//
 //
 // 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/ftruncate.h"
 
 #include "src/__support/OSUtil/syscall.h" // For internal syscall function.
 #include "src/__support/common.h"
 
 #include "src/errno/libc_errno.h"
+#include <stdint.h>      // For uint64_t.
 #include <sys/syscall.h> // For syscall numbers.
 #include <unistd.h>
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, ftruncate, (int fd, off_t len)) {
+#ifdef SYS_ftruncate
   int ret = __llvm_libc::syscall_impl(SYS_ftruncate, fd, len);
+#elif defined(SYS_ftruncate64)
+  // Same as ftruncate but can handle large offsets
+  static_assert(sizeof(off_t) == 8);
+  int ret = __llvm_libc::syscall_impl(SYS_ftruncate64, fd, (long)len,
+                                      (long)(((uint64_t)(len)) >> 32));
+#else
+#error "ftruncate and ftruncate64 syscalls not available."
+#endif
+
   if (ret < 0) {
     libc_errno = -ret;
     return -1;
   }
   return 0;
 }
 
 } // namespace __llvm_libc

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/errno/libc_errno.h"
 
 #include "src/__support/OSUtil/syscall.h" // For internal syscall function.
 #include "src/__support/common.h"
 
+#include <stdint.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_impl(SYS_lseek, fd, offset, whence);
   result = ret;
+#elif defined(SYS_llseek)
+  long ret = __llvm_libc::syscall_impl(SYS_llseek, fd,
+                                       (long)(((uint64_t)(offset)) >> 32),
+                                       (long)offset, &result, whence);
+  result = ret;
 #elif defined(SYS__llseek)
   long ret = __llvm_libc::syscall_impl(SYS__llseek, fd, offset >> 32, offset,
                                        &result, whence);
 #else
-#error "lseek and _llseek syscalls not available."
+#error "lseek, llseek and _llseek syscalls not available."
 #endif
 
   if (ret < 0) {
     libc_errno = -ret;
     return -1;
   }
   return result;
 }
 
 } // namespace __llvm_libc

libc/src/unistd/linux/pread.cpp

 //===-- Linux implementation of pread -------------------------------------===//
 //
 // 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/pread.h"
 
 #include "src/__support/OSUtil/syscall.h" // For internal syscall function.
 #include "src/__support/common.h"
 
 #include "src/errno/libc_errno.h"
+#include <stdint.h>      // For uint64_t.
 #include <sys/syscall.h> // For syscall numbers.
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(ssize_t, pread,
                    (int fd, void *buf, size_t count, off_t offset)) {
+#ifdef LIBC_TARGET_ARCH_IS_RISCV32
+  static_assert(sizeof(off_t) == 8);
+  long ret =
+      __llvm_libc::syscall_impl(SYS_pread64, fd, buf, count, (long)offset,
+                                (long)(((uint64_t)(offset)) >> 32));
+#else
   long ret = __llvm_libc::syscall_impl(SYS_pread64, fd, buf, count, offset);
+#endif
   if (ret < 0) {
     libc_errno = -ret;
     return -1;
   }
   return ret;
 }
 
 } // namespace __llvm_libc

libc/src/unistd/linux/pwrite.cpp

 //===-- Linux implementation of pwrite ------------------------------------===//
 //
 // 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/pwrite.h"
 
 #include "src/__support/OSUtil/syscall.h" // For internal syscall function.
 #include "src/__support/common.h"
 
 #include "src/errno/libc_errno.h"
+#include <stdint.h>      // For uint64_t.
 #include <sys/syscall.h> // For syscall numbers.
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(ssize_t, pwrite,
                    (int fd, const void *buf, size_t count, off_t offset)) {
+#ifdef LIBC_TARGET_ARCH_IS_RISCV32
+  static_assert(sizeof(off_t) == 8);
+  long ret =
+      __llvm_libc::syscall_impl(SYS_pwrite64, fd, buf, count, (long)offset,
+                                (long)(((uint64_t)(offset)) >> 32));
+#else
   long ret = __llvm_libc::syscall_impl(SYS_pwrite64, fd, buf, count, offset);
+#endif
   if (ret < 0) {
     libc_errno = -ret;
     return -1;
   }
   return ret;
 }
 
 } // namespace __llvm_libc

libc/src/unistd/linux/truncate.cpp

 //===-- Linux implementation of truncate ----------------------------------===//
 //
 // 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/truncate.h"
 
 #include "src/__support/OSUtil/syscall.h" // For internal syscall function.
 #include "src/__support/common.h"
 #include "src/errno/libc_errno.h"
 
+#include <stdint.h>      // For uint64_t.
 #include <sys/syscall.h> // For syscall numbers.
 #include <unistd.h>
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, truncate, (const char *path, off_t len)) {
+#ifdef SYS_truncate
   int ret = __llvm_libc::syscall_impl(SYS_truncate, path, len);
+#elif defined(SYS_truncate64)
+  // Same as truncate but can handle large offsets
+  static_assert(sizeof(off_t) == 8);
+  int ret = __llvm_libc::syscall_impl(SYS_truncate64, path, (long)len,
+                                      (long)(((uint64_t)(len)) >> 32));
+#else
+#error "truncate and truncate64 syscalls not available."
+#endif
   if (ret < 0) {
     libc_errno = -ret;
     return -1;
   }
   return 0;
 }
 
 } // namespace __llvm_libc

libc/test/src/sched/sched_rr_get_interval_test.cpp

auto SetSched = [&](int policy) {
     ASSERT_EQ(libc_errno, 0);
     struct sched_param param;
     param.sched_priority = min_priority;
     ASSERT_EQ(__llvm_libc::sched_setscheduler(0, policy, &param), 0);
     ASSERT_EQ(libc_errno, 0);
   };
 
   auto TimespecToNs = [](struct timespec t) {
-    return t.tv_sec * 1000UL * 1000UL * 1000UL + t.tv_nsec;
+    return static_cast<uint64_t>(t.tv_sec * 1000UL * 1000UL * 1000UL +
+                                 t.tv_nsec);
   };
 
   struct timespec ts;
 
   // We can only set SCHED_RR with CAP_SYS_ADMIN
   if (__llvm_libc::getuid() == 0)
     SetSched(SCHED_RR);
 
   int cur_policy = __llvm_libc::sched_getscheduler(0);
   ASSERT_GE(cur_policy, 0);
   ASSERT_EQ(libc_errno, 0);
 
   // We can actually run meaningful tests.
   if (cur_policy == SCHED_RR) {
     // Success
     ASSERT_EQ(__llvm_libc::sched_rr_get_interval(0, &ts), 0);
     ASSERT_EQ(libc_errno, 0);
 
     // Check that numbers make sense (liberal bound of 10ns - 30sec)
-    ASSERT_GT(TimespecToNs(ts), 10UL);
-    ASSERT_LT(TimespecToNs(ts), 30UL * 1000UL * 1000UL * 1000UL);
+    constexpr uint64_t tenNs = 10UL;
+    ASSERT_GT(TimespecToNs(ts), tenNs);
+    constexpr uint64_t thirstyS = 30UL * 1000UL * 1000UL * 1000UL;
+    ASSERT_LT(TimespecToNs(ts), thirstyS);
 
     // Null timespec
     ASSERT_EQ(__llvm_libc::sched_rr_get_interval(0, nullptr), -1);
     ASSERT_EQ(libc_errno, EFAULT);
     libc_errno = 0;
 
     // Negative pid
     ASSERT_EQ(__llvm_libc::sched_rr_get_interval(-1, &ts), -1);