diff options
Diffstat (limited to 'libc-bottom-half/cloudlibc/src')
66 files changed, 2404 insertions, 0 deletions
diff --git a/libc-bottom-half/cloudlibc/src/common/clock.h b/libc-bottom-half/cloudlibc/src/common/clock.h new file mode 100644 index 0000000..58d40a1 --- /dev/null +++ b/libc-bottom-half/cloudlibc/src/common/clock.h @@ -0,0 +1,19 @@ +// Copyright (c) 2016 Nuxi, https://nuxi.nl/ +// +// SPDX-License-Identifier: BSD-2-Clause + +#ifndef COMMON_CLOCK_H +#define COMMON_CLOCK_H + +#include <wasi/api.h> + +// In this implementation we define clockid_t as a pointer type, so that +// we can implement them as full objects. Right now we only use those +// objects to store the raw ABI-level clock identifier, but in the +// future we can use this to provide support for pthread_getcpuclockid() +// and clock file descriptors. +struct __clockid { + __wasi_clockid_t id; +}; + +#endif diff --git a/libc-bottom-half/cloudlibc/src/common/limits.h b/libc-bottom-half/cloudlibc/src/common/limits.h new file mode 100644 index 0000000..67e2f07 --- /dev/null +++ b/libc-bottom-half/cloudlibc/src/common/limits.h @@ -0,0 +1,35 @@ +// Copyright (c) 2015 Nuxi, https://nuxi.nl/ +// +// SPDX-License-Identifier: BSD-2-Clause + +#ifndef COMMON_LIMITS_H +#define COMMON_LIMITS_H + +#include <limits.h> + +#define NUMERIC_MIN(t) \ + _Generic((t)0, char \ + : CHAR_MIN, signed char \ + : SCHAR_MIN, unsigned char : 0, short \ + : SHRT_MIN, unsigned short : 0, int \ + : INT_MIN, unsigned int : 0, long \ + : LONG_MIN, unsigned long : 0, long long \ + : LLONG_MIN, unsigned long long : 0, default \ + : (void)0) + +#define NUMERIC_MAX(t) \ + _Generic((t)0, char \ + : CHAR_MAX, signed char \ + : SCHAR_MAX, unsigned char \ + : UCHAR_MAX, short \ + : SHRT_MAX, unsigned short \ + : USHRT_MAX, int \ + : INT_MAX, unsigned int \ + : UINT_MAX, long \ + : LONG_MAX, unsigned long \ + : ULONG_MAX, long long \ + : LLONG_MAX, unsigned long long \ + : ULLONG_MAX, default \ + : (void)0) + +#endif diff --git a/libc-bottom-half/cloudlibc/src/common/time.h b/libc-bottom-half/cloudlibc/src/common/time.h new file mode 100644 index 0000000..08e2852 --- /dev/null +++ b/libc-bottom-half/cloudlibc/src/common/time.h @@ -0,0 +1,63 @@ +// Copyright (c) 2015-2016 Nuxi, https://nuxi.nl/ +// +// SPDX-License-Identifier: BSD-2-Clause + +#ifndef COMMON_TIME_H +#define COMMON_TIME_H + +#include <common/limits.h> + +#include <sys/time.h> + +#include <wasi/api.h> +#include <stdbool.h> +#include <time.h> + +#define NSEC_PER_SEC 1000000000 + +static inline bool timespec_to_timestamp_exact( + const struct timespec *timespec, __wasi_timestamp_t *timestamp) { + // Invalid nanoseconds field. + if (timespec->tv_nsec < 0 || timespec->tv_nsec >= NSEC_PER_SEC) + return false; + + // Timestamps before the Epoch are not supported. + if (timespec->tv_sec < 0) + return false; + + // Make sure our timestamp does not overflow. + return !__builtin_mul_overflow(timespec->tv_sec, NSEC_PER_SEC, timestamp) && + !__builtin_add_overflow(*timestamp, timespec->tv_nsec, timestamp); +} + +static inline bool timespec_to_timestamp_clamp( + const struct timespec *timespec, __wasi_timestamp_t *timestamp) { + // Invalid nanoseconds field. + if (timespec->tv_nsec < 0 || timespec->tv_nsec >= NSEC_PER_SEC) + return false; + + if (timespec->tv_sec < 0) { + // Timestamps before the Epoch are not supported. + *timestamp = 0; + } else if (__builtin_mul_overflow(timespec->tv_sec, NSEC_PER_SEC, timestamp) || + __builtin_add_overflow(*timestamp, timespec->tv_nsec, timestamp)) { + // Make sure our timestamp does not overflow. + *timestamp = NUMERIC_MAX(__wasi_timestamp_t); + } + return true; +} + +static inline struct timespec timestamp_to_timespec( + __wasi_timestamp_t timestamp) { + // Decompose timestamp into seconds and nanoseconds. + return (struct timespec){.tv_sec = timestamp / NSEC_PER_SEC, + .tv_nsec = timestamp % NSEC_PER_SEC}; +} + +static inline struct timeval timestamp_to_timeval( + __wasi_timestamp_t timestamp) { + struct timespec ts = timestamp_to_timespec(timestamp); + return (struct timeval){.tv_sec = ts.tv_sec, ts.tv_nsec / 1000}; +} + +#endif diff --git a/libc-bottom-half/cloudlibc/src/include/_/cdefs.h b/libc-bottom-half/cloudlibc/src/include/_/cdefs.h new file mode 100644 index 0000000..d9a6f54 --- /dev/null +++ b/libc-bottom-half/cloudlibc/src/include/_/cdefs.h @@ -0,0 +1,36 @@ +// Copyright (c) 2015-2017 Nuxi, https://nuxi.nl/ +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions +// are met: +// 1. Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// 2. Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the distribution. +// +// THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND +// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +// ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE +// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS +// OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) +// HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY +// OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF +// SUCH DAMAGE. + +#ifndef ___CDEFS_H_ +#define ___CDEFS_H_ + +// Compiler-independent annotations. + +#define __strong_reference(oldsym, newsym) \ + extern __typeof__(oldsym) newsym __attribute__((__alias__(#oldsym))) + +// Convenience macros. + +#define __arraycount(x) (sizeof(x) / sizeof((x)[0])) + +#endif diff --git a/libc-bottom-half/cloudlibc/src/libc/dirent/closedir.c b/libc-bottom-half/cloudlibc/src/libc/dirent/closedir.c new file mode 100644 index 0000000..3585737 --- /dev/null +++ b/libc-bottom-half/cloudlibc/src/libc/dirent/closedir.c @@ -0,0 +1,10 @@ +// Copyright (c) 2015 Nuxi, https://nuxi.nl/ +// +// SPDX-License-Identifier: BSD-2-Clause + +#include <dirent.h> +#include <unistd.h> + +int closedir(DIR *dirp) { + return close(fdclosedir(dirp)); +} diff --git a/libc-bottom-half/cloudlibc/src/libc/dirent/dirent_impl.h b/libc-bottom-half/cloudlibc/src/libc/dirent/dirent_impl.h new file mode 100644 index 0000000..642400a --- /dev/null +++ b/libc-bottom-half/cloudlibc/src/libc/dirent/dirent_impl.h @@ -0,0 +1,31 @@ +// Copyright (c) 2015-2016 Nuxi, https://nuxi.nl/ +// +// SPDX-License-Identifier: BSD-2-Clause + +#ifndef DIRENT_DIRENT_IMPL_H +#define DIRENT_DIRENT_IMPL_H + +#include <wasi/api.h> +#include <stddef.h> + +struct dirent; + +#define DIRENT_DEFAULT_BUFFER_SIZE 4096 + +struct _DIR { + // Directory file descriptor and cookie. + int fd; + __wasi_dircookie_t cookie; + + // Read buffer. + char *buffer; + size_t buffer_processed; + size_t buffer_size; + size_t buffer_used; + + // Object returned by readdir(). + struct dirent *dirent; + size_t dirent_size; +}; + +#endif diff --git a/libc-bottom-half/cloudlibc/src/libc/dirent/dirfd.c b/libc-bottom-half/cloudlibc/src/libc/dirent/dirfd.c new file mode 100644 index 0000000..033157a --- /dev/null +++ b/libc-bottom-half/cloudlibc/src/libc/dirent/dirfd.c @@ -0,0 +1,11 @@ +// Copyright (c) 2015 Nuxi, https://nuxi.nl/ +// +// SPDX-License-Identifier: BSD-2-Clause + +#include <dirent.h> + +#include "dirent_impl.h" + +int dirfd(DIR *dirp) { + return dirp->fd; +} diff --git a/libc-bottom-half/cloudlibc/src/libc/dirent/fdclosedir.c b/libc-bottom-half/cloudlibc/src/libc/dirent/fdclosedir.c new file mode 100644 index 0000000..cabe702 --- /dev/null +++ b/libc-bottom-half/cloudlibc/src/libc/dirent/fdclosedir.c @@ -0,0 +1,16 @@ +// Copyright (c) 2015 Nuxi, https://nuxi.nl/ +// +// SPDX-License-Identifier: BSD-2-Clause + +#include <dirent.h> +#include <stdlib.h> + +#include "dirent_impl.h" + +int fdclosedir(DIR *dirp) { + int fd = dirp->fd; + free(dirp->buffer); + free(dirp->dirent); + free(dirp); + return fd; +} diff --git a/libc-bottom-half/cloudlibc/src/libc/dirent/fdopendir.c b/libc-bottom-half/cloudlibc/src/libc/dirent/fdopendir.c new file mode 100644 index 0000000..4a2136a --- /dev/null +++ b/libc-bottom-half/cloudlibc/src/libc/dirent/fdopendir.c @@ -0,0 +1,44 @@ +// Copyright (c) 2015-2016 Nuxi, https://nuxi.nl/ +// +// SPDX-License-Identifier: BSD-2-Clause + +#include <wasi/api.h> +#include <dirent.h> +#include <errno.h> +#include <stdlib.h> + +#include "dirent_impl.h" + +DIR *fdopendir(int fd) { + // Allocate new directory object and read buffer. + DIR *dirp = malloc(sizeof(*dirp)); + if (dirp == NULL) + return NULL; + dirp->buffer = malloc(DIRENT_DEFAULT_BUFFER_SIZE); + if (dirp->buffer == NULL) { + free(dirp); + return NULL; + } + + // Ensure that this is really a directory by already loading the first + // chunk of data. + __wasi_errno_t error = + // TODO: Remove the cast on `dirp->buffer` once the witx is updated with char8 support. + __wasi_fd_readdir(fd, (uint8_t *)dirp->buffer, DIRENT_DEFAULT_BUFFER_SIZE, + __WASI_DIRCOOKIE_START, &dirp->buffer_used); + if (error != 0) { + free(dirp->buffer); + free(dirp); + errno = error; + return NULL; + } + + // Initialize other members. + dirp->fd = fd; + dirp->cookie = __WASI_DIRCOOKIE_START; + dirp->buffer_processed = 0; + dirp->buffer_size = DIRENT_DEFAULT_BUFFER_SIZE; + dirp->dirent = NULL; + dirp->dirent_size = 1; + return dirp; +} diff --git a/libc-bottom-half/cloudlibc/src/libc/dirent/opendirat.c b/libc-bottom-half/cloudlibc/src/libc/dirent/opendirat.c new file mode 100644 index 0000000..e6d1c2a --- /dev/null +++ b/libc-bottom-half/cloudlibc/src/libc/dirent/opendirat.c @@ -0,0 +1,23 @@ +// Copyright (c) 2015 Nuxi, https://nuxi.nl/ +// +// SPDX-License-Identifier: BSD-2-Clause + +#include <wasi/libc.h> +#include <wasi/libc-nocwd.h> +#include <dirent.h> +#include <fcntl.h> +#include <stddef.h> +#include <unistd.h> + +DIR *__wasilibc_nocwd_opendirat(int dir, const char *dirname) { + // Open directory. + int fd = __wasilibc_nocwd_openat_nomode(dir, dirname, O_RDONLY | O_NONBLOCK | O_DIRECTORY); + if (fd == -1) + return NULL; + + // Create directory handle. + DIR *result = fdopendir(fd); + if (result == NULL) + close(fd); + return result; +} diff --git a/libc-bottom-half/cloudlibc/src/libc/dirent/readdir.c b/libc-bottom-half/cloudlibc/src/libc/dirent/readdir.c new file mode 100644 index 0000000..bfd1921 --- /dev/null +++ b/libc-bottom-half/cloudlibc/src/libc/dirent/readdir.c @@ -0,0 +1,132 @@ +// Copyright (c) 2015-2017 Nuxi, https://nuxi.nl/ +// +// SPDX-License-Identifier: BSD-2-Clause + +#include <sys/stat.h> +#include <sys/types.h> +#include <unistd.h> +#include <fcntl.h> + +#include <assert.h> +#include <wasi/api.h> +#include <dirent.h> +#include <errno.h> +#include <stddef.h> +#include <stdlib.h> +#include <string.h> + +#include "dirent_impl.h" + +static_assert(DT_BLK == __WASI_FILETYPE_BLOCK_DEVICE, "Value mismatch"); +static_assert(DT_CHR == __WASI_FILETYPE_CHARACTER_DEVICE, "Value mismatch"); +static_assert(DT_DIR == __WASI_FILETYPE_DIRECTORY, "Value mismatch"); +static_assert(DT_FIFO == __WASI_FILETYPE_SOCKET_STREAM, "Value mismatch"); +static_assert(DT_LNK == __WASI_FILETYPE_SYMBOLIC_LINK, "Value mismatch"); +static_assert(DT_REG == __WASI_FILETYPE_REGULAR_FILE, "Value mismatch"); +static_assert(DT_UNKNOWN == __WASI_FILETYPE_UNKNOWN, "Value mismatch"); + +// Grows a buffer to be large enough to hold a certain amount of data. +#define GROW(buffer, buffer_size, target_size) \ + do { \ + if ((buffer_size) < (target_size)) { \ + size_t new_size = (buffer_size); \ + while (new_size < (target_size)) \ + new_size *= 2; \ + void *new_buffer = realloc(buffer, new_size); \ + if (new_buffer == NULL) \ + return NULL; \ + (buffer) = new_buffer; \ + (buffer_size) = new_size; \ + } \ + } while (0) + +struct dirent *readdir(DIR *dirp) { + for (;;) { + // Extract the next dirent header. + size_t buffer_left = dirp->buffer_used - dirp->buffer_processed; + if (buffer_left < sizeof(__wasi_dirent_t)) { + // End-of-file. + if (dirp->buffer_used < dirp->buffer_size) + return NULL; + goto read_entries; + } + __wasi_dirent_t entry; + memcpy(&entry, dirp->buffer + dirp->buffer_processed, sizeof(entry)); + + size_t entry_size = sizeof(__wasi_dirent_t) + entry.d_namlen; + if (entry.d_namlen == 0) { + // Invalid pathname length. Skip the entry. + dirp->buffer_processed += entry_size; + continue; + } + + // The entire entry must be present in buffer space. If not, read + // the entry another time. Ensure that the read buffer is large + // enough to fit at least this single entry. + if (buffer_left < entry_size) { + GROW(dirp->buffer, dirp->buffer_size, entry_size); + goto read_entries; + } + + // Skip entries having null bytes in the filename. + const char *name = dirp->buffer + dirp->buffer_processed + sizeof(entry); + if (memchr(name, '\0', entry.d_namlen) != NULL) { + dirp->buffer_processed += entry_size; + continue; + } + + // Return the next directory entry. Ensure that the dirent is large + // enough to fit the filename. + GROW(dirp->dirent, dirp->dirent_size, + offsetof(struct dirent, d_name) + entry.d_namlen + 1); + struct dirent *dirent = dirp->dirent; + dirent->d_type = entry.d_type; + memcpy(dirent->d_name, name, entry.d_namlen); + dirent->d_name[entry.d_namlen] = '\0'; + + // `fd_readdir` implementations may set the inode field to zero if the + // the inode number is unknown. In that case, do an `fstatat` to get the + // inode number. + off_t d_ino = entry.d_ino; + unsigned char d_type = entry.d_type; + if (d_ino == 0 && strcmp(dirent->d_name, "..") != 0) { + struct stat statbuf; + if (fstatat(dirp->fd, dirent->d_name, &statbuf, AT_SYMLINK_NOFOLLOW) != 0) { + if (errno == ENOENT) { + // The file disappeared before we could read it, so skip it. + dirp->buffer_processed += entry_size; + continue; + } + return NULL; + } + + // Fill in the inode. + d_ino = statbuf.st_ino; + + // In case someone raced with us and replaced the object with this name + // with another of a different type, update the type too. + d_type = __wasilibc_iftodt(statbuf.st_mode & S_IFMT); + } + dirent->d_ino = d_ino; + dirent->d_type = d_type; + + dirp->cookie = entry.d_next; + dirp->buffer_processed += entry_size; + return dirent; + + read_entries: + // Discard data currently stored in the input buffer. + dirp->buffer_used = dirp->buffer_processed = dirp->buffer_size; + + // Load more directory entries and continue. + __wasi_errno_t error = + // TODO: Remove the cast on `dirp->buffer` once the witx is updated with char8 support. + __wasi_fd_readdir(dirp->fd, (uint8_t *)dirp->buffer, dirp->buffer_size, + dirp->cookie, &dirp->buffer_used); + if (error != 0) { + errno = error; + return NULL; + } + dirp->buffer_processed = 0; + } +} diff --git a/libc-bottom-half/cloudlibc/src/libc/dirent/rewinddir.c b/libc-bottom-half/cloudlibc/src/libc/dirent/rewinddir.c new file mode 100644 index 0000000..8dd5882 --- /dev/null +++ b/libc-bottom-half/cloudlibc/src/libc/dirent/rewinddir.c @@ -0,0 +1,15 @@ +// Copyright (c) 2015-2016 Nuxi, https://nuxi.nl/ +// +// SPDX-License-Identifier: BSD-2-Clause + +#include <wasi/api.h> +#include <dirent.h> + +#include "dirent_impl.h" + +void rewinddir(DIR *dirp) { + // Update cookie. + dirp->cookie = __WASI_DIRCOOKIE_START; + // Mark entire buffer as processed to force a read of new data. + dirp->buffer_used = dirp->buffer_processed = dirp->buffer_size; +} diff --git a/libc-bottom-half/cloudlibc/src/libc/dirent/scandirat.c b/libc-bottom-half/cloudlibc/src/libc/dirent/scandirat.c new file mode 100644 index 0000000..079b3b3 --- /dev/null +++ b/libc-bottom-half/cloudlibc/src/libc/dirent/scandirat.c @@ -0,0 +1,168 @@ +// Copyright (c) 2015-2016 Nuxi, https://nuxi.nl/ +// +// SPDX-License-Identifier: BSD-2-Clause + +#include <wasi/api.h> +#include <wasi/libc.h> +#include <wasi/libc-nocwd.h> +#include <dirent.h> +#include <errno.h> +#include <fcntl.h> +#include <stdlib.h> +#include <string.h> +#include <unistd.h> +#include <sys/stat.h> + +#include "dirent_impl.h" + +static int sel_true(const struct dirent *de) { + return 1; +} + +int __wasilibc_nocwd_scandirat(int dirfd, const char *dir, struct dirent ***namelist, + int (*sel)(const struct dirent *), + int (*compar)(const struct dirent **, const struct dirent **)) { + struct stat statbuf; + + // Match all files if no select function is provided. + if (sel == NULL) + sel = sel_true; + + // Open the directory. + int fd = __wasilibc_nocwd_openat_nomode(dirfd, dir, O_RDONLY | O_NONBLOCK | O_DIRECTORY); + if (fd == -1) + return -1; + + // Allocate a read buffer for the directory entries. + size_t buffer_size = DIRENT_DEFAULT_BUFFER_SIZE; + char *buffer = malloc(buffer_size); + if (buffer == NULL) { + close(fd); + return -1; + } + size_t buffer_processed = buffer_size; + size_t buffer_used = buffer_size; + + // Space for the array to return to the caller. + struct dirent **dirents = NULL; + size_t dirents_size = 0; + size_t dirents_used = 0; + + __wasi_dircookie_t cookie = __WASI_DIRCOOKIE_START; + for (;;) { + // Extract the next dirent header. + size_t buffer_left = buffer_used - buffer_processed; + if (buffer_left < sizeof(__wasi_dirent_t)) { + // End-of-file. + if (buffer_used < buffer_size) + break; + goto read_entries; + } + __wasi_dirent_t entry; + memcpy(&entry, buffer + buffer_processed, sizeof(entry)); + + size_t entry_size = sizeof(__wasi_dirent_t) + entry.d_namlen; + if (entry.d_namlen == 0) { + // Invalid pathname length. Skip the entry. + buffer_processed += entry_size; + continue; + } + + // The entire entry must be present in buffer space. If not, read + // the entry another time. Ensure that the read buffer is large + // enough to fit at least this single entry. + if (buffer_left < entry_size) { + while (buffer_size < entry_size) + buffer_size *= 2; + char *new_buffer = realloc(buffer, buffer_size); + if (new_buffer == NULL) + goto bad; + buffer = new_buffer; + goto read_entries; + } + + // Skip entries having null bytes in the filename. + const char *name = buffer + buffer_processed + sizeof(entry); + buffer_processed += entry_size; + if (memchr(name, '\0', entry.d_namlen) != NULL) + continue; + + // Create the new directory entry. + struct dirent *dirent = + malloc(offsetof(struct dirent, d_name) + entry.d_namlen + 1); + if (dirent == NULL) + goto bad; + dirent->d_type = entry.d_type; + memcpy(dirent->d_name, name, entry.d_namlen); + dirent->d_name[entry.d_namlen] = '\0'; + + // `fd_readdir` implementations may set the inode field to zero if the + // the inode number is unknown. In that case, do an `fstatat` to get the + // inode number. + off_t d_ino = entry.d_ino; + unsigned char d_type = entry.d_type; + if (d_ino == 0) { + if (fstatat(fd, dirent->d_name, &statbuf, AT_SYMLINK_NOFOLLOW) != 0) { + return -1; + } + + // Fill in the inode. + d_ino = statbuf.st_ino; + + // In case someone raced with us and replaced the object with this name + // with another of a different type, update the type too. + d_type = __wasilibc_iftodt(statbuf.st_mode & S_IFMT); + } + dirent->d_ino = d_ino; + dirent->d_type = d_type; + + cookie = entry.d_next; + + if (sel(dirent)) { + // Add the entry to the results. + if (dirents_used == dirents_size) { + dirents_size = dirents_size < 8 ? 8 : dirents_size * 2; + struct dirent **new_dirents = + realloc(dirents, dirents_size * sizeof(*dirents)); + if (new_dirents == NULL) { + free(dirent); + goto bad; + } + dirents = new_dirents; + } + dirents[dirents_used++] = dirent; + } else { + // Discard the entry. + free(dirent); + } + continue; + + read_entries:; + // Load more directory entries and continue. + // TODO: Remove the cast on `buffer` once the witx is updated with char8 support. + __wasi_errno_t error = __wasi_fd_readdir(fd, (uint8_t *)buffer, buffer_size, + cookie, &buffer_used); + if (error != 0) { + errno = error; + goto bad; + } + buffer_processed = 0; + } + + // Sort results and return them. + free(buffer); + close(fd); + (qsort)(dirents, dirents_used, sizeof(*dirents), + (int (*)(const void *, const void *))compar); + *namelist = dirents; + return dirents_used; + +bad: + // Deallocate partially created results. + for (size_t i = 0; i < dirents_used; ++i) + free(dirents[i]); + free(dirents); + free(buffer); + close(fd); + return -1; +} diff --git a/libc-bottom-half/cloudlibc/src/libc/dirent/seekdir.c b/libc-bottom-half/cloudlibc/src/libc/dirent/seekdir.c new file mode 100644 index 0000000..a865d92 --- /dev/null +++ b/libc-bottom-half/cloudlibc/src/libc/dirent/seekdir.c @@ -0,0 +1,15 @@ +// Copyright (c) 2015 Nuxi, https://nuxi.nl/ +// +// SPDX-License-Identifier: BSD-2-Clause + +#include <dirent.h> + +#include "dirent_impl.h" + +void seekdir(DIR *dirp, long loc) { + // Update cookie. + dirp->cookie = (unsigned long)loc; + // Mark entire buffer as processed to force a read of new data. + // TODO(ed): We could prevent a read if the offset is in the buffer. + dirp->buffer_used = dirp->buffer_processed = dirp->buffer_size; +} diff --git a/libc-bottom-half/cloudlibc/src/libc/dirent/telldir.c b/libc-bottom-half/cloudlibc/src/libc/dirent/telldir.c new file mode 100644 index 0000000..05687ee --- /dev/null +++ b/libc-bottom-half/cloudlibc/src/libc/dirent/telldir.c @@ -0,0 +1,11 @@ +// Copyright (c) 2015 Nuxi, https://nuxi.nl/ +// +// SPDX-License-Identifier: BSD-2-Clause + +#include <dirent.h> + +#include "dirent_impl.h" + +long telldir(DIR *dirp) { + return dirp->cookie; +} diff --git a/libc-bottom-half/cloudlibc/src/libc/errno/errno.c b/libc-bottom-half/cloudlibc/src/libc/errno/errno.c new file mode 100644 index 0000000..d7a27f3 --- /dev/null +++ b/libc-bottom-half/cloudlibc/src/libc/errno/errno.c @@ -0,0 +1,87 @@ +// Copyright (c) 2015-2016 Nuxi, https://nuxi.nl/ +// +// SPDX-License-Identifier: BSD-2-Clause + +#include <assert.h> +#include <wasi/api.h> +#include <errno.h> +#include <threads.h> + +static_assert(E2BIG == __WASI_ERRNO_2BIG, "Value mismatch"); +static_assert(EACCES == __WASI_ERRNO_ACCES, "Value mismatch"); +static_assert(EADDRINUSE == __WASI_ERRNO_ADDRINUSE, "Value mismatch"); +static_assert(EADDRNOTAVAIL == __WASI_ERRNO_ADDRNOTAVAIL, "Value mismatch"); +static_assert(EAFNOSUPPORT == __WASI_ERRNO_AFNOSUPPORT, "Value mismatch"); +static_assert(EAGAIN == __WASI_ERRNO_AGAIN, "Value mismatch"); +static_assert(EALREADY == __WASI_ERRNO_ALREADY, "Value mismatch"); +static_assert(EBADF == __WASI_ERRNO_BADF, "Value mismatch"); +static_assert(EBADMSG == __WASI_ERRNO_BADMSG, "Value mismatch"); +static_assert(EBUSY == __WASI_ERRNO_BUSY, "Value mismatch"); +static_assert(ECANCELED == __WASI_ERRNO_CANCELED, "Value mismatch"); +static_assert(ECHILD == __WASI_ERRNO_CHILD, "Value mismatch"); +static_assert(ECONNABORTED == __WASI_ERRNO_CONNABORTED, "Value mismatch"); +static_assert(ECONNREFUSED == __WASI_ERRNO_CONNREFUSED, "Value mismatch"); +static_assert(ECONNRESET == __WASI_ERRNO_CONNRESET, "Value mismatch"); +static_assert(EDEADLK == __WASI_ERRNO_DEADLK, "Value mismatch"); +static_assert(EDESTADDRREQ == __WASI_ERRNO_DESTADDRREQ, "Value mismatch"); +static_assert(EDOM == __WASI_ERRNO_DOM, "Value mismatch"); +static_assert(EDQUOT == __WASI_ERRNO_DQUOT, "Value mismatch"); +static_assert(EEXIST == __WASI_ERRNO_EXIST, "Value mismatch"); +static_assert(EFAULT == __WASI_ERRNO_FAULT, "Value mismatch"); +static_assert(EFBIG == __WASI_ERRNO_FBIG, "Value mismatch"); +static_assert(EHOSTUNREACH == __WASI_ERRNO_HOSTUNREACH, "Value mismatch"); +static_assert(EIDRM == __WASI_ERRNO_IDRM, "Value mismatch"); +static_assert(EILSEQ == __WASI_ERRNO_ILSEQ, "Value mismatch"); +static_assert(EINPROGRESS == __WASI_ERRNO_INPROGRESS, "Value mismatch"); +static_assert(EINTR == __WASI_ERRNO_INTR, "Value mismatch"); +static_assert(EINVAL == __WASI_ERRNO_INVAL, "Value mismatch"); +static_assert(EIO == __WASI_ERRNO_IO, "Value mismatch"); +static_assert(EISCONN == __WASI_ERRNO_ISCONN, "Value mismatch"); +static_assert(EISDIR == __WASI_ERRNO_ISDIR, "Value mismatch"); +static_assert(ELOOP == __WASI_ERRNO_LOOP, "Value mismatch"); +static_assert(EMFILE == __WASI_ERRNO_MFILE, "Value mismatch"); +static_assert(EMLINK == __WASI_ERRNO_MLINK, "Value mismatch"); +static_assert(EMSGSIZE == __WASI_ERRNO_MSGSIZE, "Value mismatch"); +static_assert(EMULTIHOP == __WASI_ERRNO_MULTIHOP, "Value mismatch"); +static_assert(ENAMETOOLONG == __WASI_ERRNO_NAMETOOLONG, "Value mismatch"); +static_assert(ENETDOWN == __WASI_ERRNO_NETDOWN, "Value mismatch"); +static_assert(ENETRESET == __WASI_ERRNO_NETRESET, "Value mismatch"); +static_assert(ENETUNREACH == __WASI_ERRNO_NETUNREACH, "Value mismatch"); +static_assert(ENFILE == __WASI_ERRNO_NFILE, "Value mismatch"); +static_assert(ENOBUFS == __WASI_ERRNO_NOBUFS, "Value mismatch"); +static_assert(ENODEV == __WASI_ERRNO_NODEV, "Value mismatch"); +static_assert(ENOENT == __WASI_ERRNO_NOENT, "Value mismatch"); +static_assert(ENOEXEC == __WASI_ERRNO_NOEXEC, "Value mismatch"); +static_assert(ENOLCK == __WASI_ERRNO_NOLCK, "Value mismatch"); +static_assert(ENOLINK == __WASI_ERRNO_NOLINK, "Value mismatch"); +static_assert(ENOMEM == __WASI_ERRNO_NOMEM, "Value mismatch"); +static_assert(ENOMSG == __WASI_ERRNO_NOMSG, "Value mismatch"); +static_assert(ENOPROTOOPT == __WASI_ERRNO_NOPROTOOPT, "Value mismatch"); +static_assert(ENOSPC == __WASI_ERRNO_NOSPC, "Value mismatch"); +static_assert(ENOSYS == __WASI_ERRNO_NOSYS, "Value mismatch"); +static_assert(ENOTCAPABLE == __WASI_ERRNO_NOTCAPABLE, "Value mismatch"); +static_assert(ENOTCONN == __WASI_ERRNO_NOTCONN, "Value mismatch"); +static_assert(ENOTDIR == __WASI_ERRNO_NOTDIR, "Value mismatch"); +static_assert(ENOTEMPTY == __WASI_ERRNO_NOTEMPTY, "Value mismatch"); +static_assert(ENOTRECOVERABLE == __WASI_ERRNO_NOTRECOVERABLE, "Value mismatch"); +static_assert(ENOTSOCK == __WASI_ERRNO_NOTSOCK, "Value mismatch"); +static_assert(ENOTSUP == __WASI_ERRNO_NOTSUP, "Value mismatch"); +static_assert(ENOTTY == __WASI_ERRNO_NOTTY, "Value mismatch"); +static_assert(ENXIO == __WASI_ERRNO_NXIO, "Value mismatch"); +static_assert(EOVERFLOW == __WASI_ERRNO_OVERFLOW, "Value mismatch"); +static_assert(EOWNERDEAD == __WASI_ERRNO_OWNERDEAD, "Value mismatch"); +static_assert(EPERM == __WASI_ERRNO_PERM, "Value mismatch"); +static_assert(EPIPE == __WASI_ERRNO_PIPE, "Value mismatch"); +static_assert(EPROTO == __WASI_ERRNO_PROTO, "Value mismatch"); +static_assert(EPROTONOSUPPORT == __WASI_ERRNO_PROTONOSUPPORT, "Value mismatch"); +static_assert(EPROTOTYPE == __WASI_ERRNO_PROTOTYPE, "Value mismatch"); +static_assert(ERANGE == __WASI_ERRNO_RANGE, "Value mismatch"); +static_assert(EROFS == __WASI_ERRNO_ROFS, "Value mismatch"); +static_assert(ESPIPE == __WASI_ERRNO_SPIPE, "Value mismatch"); +static_assert(ESRCH == __WASI_ERRNO_SRCH, "Value mismatch"); +static_assert(ESTALE == __WASI_ERRNO_STALE, "Value mismatch"); +static_assert(ETIMEDOUT == __WASI_ERRNO_TIMEDOUT, "Value mismatch"); +static_assert(ETXTBSY == __WASI_ERRNO_TXTBSY, "Value mismatch"); +static_assert(EXDEV == __WASI_ERRNO_XDEV, "Value mismatch"); + +thread_local int errno = 0; diff --git a/libc-bottom-half/cloudlibc/src/libc/fcntl/fcntl.c b/libc-bottom-half/cloudlibc/src/libc/fcntl/fcntl.c new file mode 100644 index 0000000..5d4055d --- /dev/null +++ b/libc-bottom-half/cloudlibc/src/libc/fcntl/fcntl.c @@ -0,0 +1,62 @@ +// Copyright (c) 2015-2016 Nuxi, https://nuxi.nl/ +// +// SPDX-License-Identifier: BSD-2-Clause + +#include <wasi/api.h> +#include <errno.h> +#include <fcntl.h> +#include <stdarg.h> + +int fcntl(int fildes, int cmd, ...) { + switch (cmd) { + case F_GETFD: + // Act as if the close-on-exec flag is always set. + return FD_CLOEXEC; + case F_SETFD: + // The close-on-exec flag is ignored. + return 0; + case F_GETFL: { + // Obtain the flags and the rights of the descriptor. + __wasi_fdstat_t fds; + __wasi_errno_t error = __wasi_fd_fdstat_get(fildes, &fds); + if (error != 0) { + errno = error; + return -1; + } + + // Roughly approximate the access mode by converting the rights. + int oflags = fds.fs_flags; + if ((fds.fs_rights_base & + (__WASI_RIGHTS_FD_READ | __WASI_RIGHTS_FD_READDIR)) != 0) { + if ((fds.fs_rights_base & __WASI_RIGHTS_FD_WRITE) != 0) + oflags |= O_RDWR; + else + oflags |= O_RDONLY; + } else if ((fds.fs_rights_base & __WASI_RIGHTS_FD_WRITE) != 0) { + oflags |= O_WRONLY; + } else { + oflags |= O_SEARCH; + } + return oflags; + } + case F_SETFL: { + // Set new file descriptor flags. + va_list ap; + va_start(ap, cmd); + int flags = va_arg(ap, int); + va_end(ap); + + __wasi_fdflags_t fs_flags = flags & 0xfff; + __wasi_errno_t error = + __wasi_fd_fdstat_set_flags(fildes, fs_flags); + if (error != 0) { + errno = error; + return -1; + } + return 0; + } + default: + errno = EINVAL; + return -1; + } +} diff --git a/libc-bottom-half/cloudlibc/src/libc/fcntl/openat.c b/libc-bottom-half/cloudlibc/src/libc/fcntl/openat.c new file mode 100644 index 0000000..09cbbf8 --- /dev/null +++ b/libc-bottom-half/cloudlibc/src/libc/fcntl/openat.c @@ -0,0 +1,80 @@ +// Copyright (c) 2015-2016 Nuxi, https://nuxi.nl/ +// +// SPDX-License-Identifier: BSD-2-Clause + +#include <assert.h> +#include <wasi/api.h> +#include <wasi/libc.h> +#include <errno.h> +#include <fcntl.h> +#include <string.h> + +static_assert(O_APPEND == __WASI_FDFLAGS_APPEND, "Value mismatch"); +static_assert(O_DSYNC == __WASI_FDFLAGS_DSYNC, "Value mismatch"); +static_assert(O_NONBLOCK == __WASI_FDFLAGS_NONBLOCK, "Value mismatch"); +static_assert(O_RSYNC == __WASI_FDFLAGS_RSYNC, "Value mismatch"); +static_assert(O_SYNC == __WASI_FDFLAGS_SYNC, "Value mismatch"); + +static_assert(O_CREAT >> 12 == __WASI_OFLAGS_CREAT, "Value mismatch"); +static_assert(O_DIRECTORY >> 12 == __WASI_OFLAGS_DIRECTORY, "Value mismatch"); +static_assert(O_EXCL >> 12 == __WASI_OFLAGS_EXCL, "Value mismatch"); +static_assert(O_TRUNC >> 12 == __WASI_OFLAGS_TRUNC, "Value mismatch"); + +int __wasilibc_nocwd_openat_nomode(int fd, const char *path, int oflag) { + // Compute rights corresponding with the access modes provided. + // Attempt to obtain all rights, except the ones that contradict the + // access mode provided to openat(). + __wasi_rights_t max = + ~(__WASI_RIGHTS_FD_DATASYNC | __WASI_RIGHTS_FD_READ | + __WASI_RIGHTS_FD_WRITE | __WASI_RIGHTS_FD_ALLOCATE | + __WASI_RIGHTS_FD_READDIR | __WASI_RIGHTS_FD_FILESTAT_SET_SIZE); + switch (oflag & O_ACCMODE) { + case O_RDONLY: + case O_RDWR: + case O_WRONLY: + if ((oflag & O_RDONLY) != 0) { + max |= __WASI_RIGHTS_FD_READ | __WASI_RIGHTS_FD_READDIR; + } + if ((oflag & O_WRONLY) != 0) { + max |= __WASI_RIGHTS_FD_DATASYNC | __WASI_RIGHTS_FD_WRITE | + __WASI_RIGHTS_FD_ALLOCATE | + __WASI_RIGHTS_FD_FILESTAT_SET_SIZE; + } + break; + case O_EXEC: + break; + case O_SEARCH: + break; + default: + errno = EINVAL; + return -1; + } + + // Ensure that we can actually obtain the minimal rights needed. + __wasi_fdstat_t fsb_cur; + __wasi_errno_t error = __wasi_fd_fdstat_get(fd, &fsb_cur); + if (error != 0) { + errno = error; + return -1; + } + + // Path lookup properties. + __wasi_lookupflags_t lookup_flags = 0; + if ((oflag & O_NOFOLLOW) == 0) + lookup_flags |= __WASI_LOOKUPFLAGS_SYMLINK_FOLLOW; + + // Open file with appropriate rights. + __wasi_fdflags_t fs_flags = oflag & 0xfff; + __wasi_rights_t fs_rights_base = max & fsb_cur.fs_rights_inheriting; + __wasi_rights_t fs_rights_inheriting = fsb_cur.fs_rights_inheriting; + __wasi_fd_t newfd; + error = __wasi_path_open(fd, lookup_flags, path, + (oflag >> 12) & 0xfff, + fs_rights_base, fs_rights_inheriting, fs_flags, + &newfd); + if (error != 0) { + errno = error; + return -1; + } + return newfd; +} diff --git a/libc-bottom-half/cloudlibc/src/libc/fcntl/posix_fadvise.c b/libc-bottom-half/cloudlibc/src/libc/fcntl/posix_fadvise.c new file mode 100644 index 0000000..d683d39 --- /dev/null +++ b/libc-bottom-half/cloudlibc/src/libc/fcntl/posix_fadvise.c @@ -0,0 +1,24 @@ +// Copyright (c) 2015-2016 Nuxi, https://nuxi.nl/ +// +// SPDX-License-Identifier: BSD-2-Clause + +#include <assert.h> +#include <wasi/api.h> +#include <errno.h> +#include <fcntl.h> + +static_assert(POSIX_FADV_DONTNEED == __WASI_ADVICE_DONTNEED, + "Value mismatch"); +static_assert(POSIX_FADV_NOREUSE == __WASI_ADVICE_NOREUSE, "Value mismatch"); +static_assert(POSIX_FADV_NORMAL == __WASI_ADVICE_NORMAL, "Value mismatch"); +static_assert(POSIX_FADV_RANDOM == __WASI_ADVICE_RANDOM, "Value mismatch"); +static_assert(POSIX_FADV_SEQUENTIAL == __WASI_ADVICE_SEQUENTIAL, + "Value mismatch"); +static_assert(POSIX_FADV_WILLNEED == __WASI_ADVICE_WILLNEED, + "Value mismatch"); + +int posix_fadvise(int fd, off_t offset, off_t len, int advice) { + if (offset < 0 || len < 0) + return EINVAL; + return __wasi_fd_advise(fd, offset, len, advice); +} diff --git a/libc-bottom-half/cloudlibc/src/libc/fcntl/posix_fallocate.c b/libc-bottom-half/cloudlibc/src/libc/fcntl/posix_fallocate.c new file mode 100644 index 0000000..4b41c4b --- /dev/null +++ b/libc-bottom-half/cloudlibc/src/libc/fcntl/posix_fallocate.c @@ -0,0 +1,13 @@ +// Copyright (c) 2015-2016 Nuxi, https://nuxi.nl/ +// +// SPDX-License-Identifier: BSD-2-Clause + +#include <wasi/api.h> +#include <errno.h> +#include <fcntl.h> + +int posix_fallocate(int fd, off_t offset, off_t len) { + if (offset < 0 || len < 0) + return EINVAL; + return __wasi_fd_allocate(fd, offset, len); +} diff --git a/libc-bottom-half/cloudlibc/src/libc/poll/poll.c b/libc-bottom-half/cloudlibc/src/libc/poll/poll.c new file mode 100644 index 0000000..cde4e81 --- /dev/null +++ b/libc-bottom-half/cloudlibc/src/libc/poll/poll.c @@ -0,0 +1,129 @@ +// Copyright (c) 2015-2016 Nuxi, https://nuxi.nl/ +// +// SPDX-License-Identifier: BSD-2-Clause + +#include <wasi/api.h> +#include <errno.h> +#include <poll.h> +#include <stdbool.h> + +int poll(struct pollfd *fds, size_t nfds, int timeout) { + // Construct events for poll(). + size_t maxevents = 2 * nfds + 1; + __wasi_subscription_t subscriptions[maxevents]; + size_t nsubscriptions = 0; + for (size_t i = 0; i < nfds; ++i) { + struct pollfd *pollfd = &fds[i]; + if (pollfd->fd < 0) + continue; + bool created_events = false; + if ((pollfd->events & POLLRDNORM) != 0) { + __wasi_subscription_t *subscription = &subscriptions[nsubscriptions++]; + *subscription = (__wasi_subscription_t){ + .userdata = (uintptr_t)pollfd, + .u.tag = __WASI_EVENTTYPE_FD_READ, + .u.u.fd_read.file_descriptor = pollfd->fd, + }; + created_events = true; + } + if ((pollfd->events & POLLWRNORM) != 0) { + __wasi_subscription_t *subscription = &subscriptions[nsubscriptions++]; + *subscription = (__wasi_subscription_t){ + .userdata = (uintptr_t)pollfd, + .u.tag = __WASI_EVENTTYPE_FD_WRITE, + .u.u.fd_write.file_descriptor = pollfd->fd, + }; + created_events = true; + } + + // As entries are decomposed into separate read/write subscriptions, + // we cannot detect POLLERR, POLLHUP and POLLNVAL if POLLRDNORM and + // POLLWRNORM are not specified. Disallow this for now. + if (!created_events) { + errno = ENOSYS; + return -1; + } + } + + // Create extra event for the timeout. + if (timeout >= 0) { + __wasi_subscription_t *subscription = &subscriptions[nsubscriptions++]; + *subscription = (__wasi_subscription_t){ + .u.tag = __WASI_EVENTTYPE_CLOCK, + .u.u.clock.id = __WASI_CLOCKID_REALTIME, + .u.u.clock.timeout = (__wasi_timestamp_t)timeout * 1000000, + }; + } + + // Execute poll(). + size_t nevents; + __wasi_event_t events[nsubscriptions]; + __wasi_errno_t error = + __wasi_poll_oneoff(subscriptions, events, nsubscriptions, &nevents); + if (error != 0) { + // WASI's poll requires at least one subscription, or else it returns + // `EINVAL`. Since a `poll` with nothing to wait for is valid in POSIX, + // return `ENOTSUP` to indicate that we don't support that case. + // + // Wasm has no signal handling, so if none of the user-provided `pollfd` + // elements, nor the timeout, led us to producing even one subscription + // to wait for, there would be no way for the poll to wake up. WASI + // returns `EINVAL` in this case, but for users of `poll`, `ENOTSUP` is + // more likely to be understood. + if (nsubscriptions == 0) + errno = ENOTSUP; + else + errno = error; + return -1; + } + + // Clear revents fields. + for (size_t i = 0; i < nfds; ++i) { + struct pollfd *pollfd = &fds[i]; + pollfd->revents = 0; + } + + // Set revents fields. + for (size_t i = 0; i < nevents; ++i) { + const __wasi_event_t *event = &events[i]; + if (event->type == __WASI_EVENTTYPE_FD_READ || + event->type == __WASI_EVENTTYPE_FD_WRITE) { + struct pollfd *pollfd = (struct pollfd *)(uintptr_t)event->userdata; + if (event->error == __WASI_ERRNO_BADF) { + // Invalid file descriptor. + pollfd->revents |= POLLNVAL; + } else if (event->error == __WASI_ERRNO_PIPE) { + // Hangup on write side of pipe. + pollfd->revents |= POLLHUP; + } else if (event->error != 0) { + // Another error occurred. + pollfd->revents |= POLLERR; + } else { + // Data can be read or written. + if (event->type == __WASI_EVENTTYPE_FD_READ) { + pollfd->revents |= POLLRDNORM; + if (event->fd_readwrite.flags & __WASI_EVENTRWFLAGS_FD_READWRITE_HANGUP) { + pollfd->revents |= POLLHUP; + } + } else if (event->type == __WASI_EVENTTYPE_FD_WRITE) { + pollfd->revents |= POLLWRNORM; + if (event->fd_readwrite.flags & __WASI_EVENTRWFLAGS_FD_READWRITE_HANGUP) { + pollfd->revents |= POLLHUP; + } + } + } + } + } + + // Return the number of events with a non-zero revents value. + int retval = 0; + for (size_t i = 0; i < nfds; ++i) { + struct pollfd *pollfd = &fds[i]; + // POLLHUP contradicts with POLLWRNORM. + if ((pollfd->revents & POLLHUP) != 0) + pollfd->revents &= ~POLLWRNORM; + if (pollfd->revents != 0) + ++retval; + } + return retval; +} diff --git a/libc-bottom-half/cloudlibc/src/libc/sched/sched_yield.c b/libc-bottom-half/cloudlibc/src/libc/sched/sched_yield.c new file mode 100644 index 0000000..6100ea5 --- /dev/null +++ b/libc-bottom-half/cloudlibc/src/libc/sched/sched_yield.c @@ -0,0 +1,16 @@ +// Copyright (c) 2015-2016 Nuxi, https://nuxi.nl/ +// +// SPDX-License-Identifier: BSD-2-Clause + +#include <wasi/api.h> +#include <errno.h> +#include <sched.h> + +int sched_yield(void) { + __wasi_errno_t error = __wasi_sched_yield(); + if (error != 0) { + errno = error; + return -1; + } + return 0; +} diff --git a/libc-bottom-half/cloudlibc/src/libc/stdio/renameat.c b/libc-bottom-half/cloudlibc/src/libc/stdio/renameat.c new file mode 100644 index 0000000..c1706db --- /dev/null +++ b/libc-bottom-half/cloudlibc/src/libc/stdio/renameat.c @@ -0,0 +1,17 @@ +// Copyright (c) 2015-2016 Nuxi, https://nuxi.nl/ +// +// SPDX-License-Identifier: BSD-2-Clause + +#include <wasi/api.h> +#include <errno.h> +#include <stdio.h> +#include <string.h> + +int __wasilibc_nocwd_renameat(int oldfd, const char *old, int newfd, const char *new) { + __wasi_errno_t error = __wasi_path_rename(oldfd, old, newfd, new); + if (error != 0) { + errno = error; + return -1; + } + return 0; +} diff --git a/libc-bottom-half/cloudlibc/src/libc/stdlib/_Exit.c b/libc-bottom-half/cloudlibc/src/libc/stdlib/_Exit.c new file mode 100644 index 0000000..5e266f0 --- /dev/null +++ b/libc-bottom-half/cloudlibc/src/libc/stdlib/_Exit.c @@ -0,0 +1,14 @@ +// Copyright (c) 2015-2016 Nuxi, https://nuxi.nl/ +// +// SPDX-License-Identifier: BSD-2-Clause + +#include <wasi/api.h> +#include <_/cdefs.h> +#include <stdnoreturn.h> +#include <unistd.h> + +noreturn void _Exit(int status) { + __wasi_proc_exit(status); +} + +__strong_reference(_Exit, _exit); diff --git a/libc-bottom-half/cloudlibc/src/libc/sys/ioctl/ioctl.c b/libc-bottom-half/cloudlibc/src/libc/sys/ioctl/ioctl.c new file mode 100644 index 0000000..7d03cc6 --- /dev/null +++ b/libc-bottom-half/cloudlibc/src/libc/sys/ioctl/ioctl.c @@ -0,0 +1,88 @@ +// Copyright (c) 2015-2016 Nuxi, https://nuxi.nl/ +// +// SPDX-License-Identifier: BSD-2-Clause + +#include <sys/ioctl.h> + +#include <wasi/api.h> +#include <errno.h> +#include <stdarg.h> + +int ioctl(int fildes, int request, ...) { + switch (request) { + case FIONREAD: { + // Poll the file descriptor to determine how many bytes can be read. + __wasi_subscription_t subscriptions[2] = { + { + .u.tag = __WASI_EVENTTYPE_FD_READ, + .u.u.fd_read.file_descriptor = fildes, + }, + { + .u.tag = __WASI_EVENTTYPE_CLOCK, + .u.u.clock.id = __WASI_CLOCKID_MONOTONIC, + }, + }; + __wasi_event_t events[__arraycount(subscriptions)]; + size_t nevents; + __wasi_errno_t error = __wasi_poll_oneoff( + subscriptions, events, __arraycount(subscriptions), &nevents); + if (error != 0) { + errno = error; + return -1; + } + + // Location where result should be written. + va_list ap; + va_start(ap, request); + int *result = va_arg(ap, int *); + va_end(ap); + + // Extract number of bytes for reading from poll results. + for (size_t i = 0; i < nevents; ++i) { + __wasi_event_t *event = &events[i]; + if (event->error != 0) { + errno = event->error; + return -1; + } + if (event->type == __WASI_EVENTTYPE_FD_READ) { + *result = event->fd_readwrite.nbytes; + return 0; + } + } + + // No data available for reading. + *result = 0; + return 0; + } + case FIONBIO: { + // Obtain the current file descriptor flags. + __wasi_fdstat_t fds; + __wasi_errno_t error = __wasi_fd_fdstat_get(fildes, &fds); + if (error != 0) { + errno = error; + return -1; + } + + // Toggle the non-blocking flag based on the argument. + va_list ap; + va_start(ap, request); + if (*va_arg(ap, const int *) != 0) + fds.fs_flags |= __WASI_FDFLAGS_NONBLOCK; + else + fds.fs_flags &= ~__WASI_FDFLAGS_NONBLOCK; + va_end(ap); + + // Update the file descriptor flags. + error = __wasi_fd_fdstat_set_flags(fildes, fds.fs_flags); + if (error != 0) { + errno = error; + return -1; + } + return 0; + } + default: + // Invalid request. + errno = EINVAL; + return -1; + } +} diff --git a/libc-bottom-half/cloudlibc/src/libc/sys/select/pselect.c b/libc-bottom-half/cloudlibc/src/libc/sys/select/pselect.c new file mode 100644 index 0000000..fdc470e --- /dev/null +++ b/libc-bottom-half/cloudlibc/src/libc/sys/select/pselect.c @@ -0,0 +1,125 @@ +// Copyright (c) 2015-2016 Nuxi, https://nuxi.nl/ +// +// SPDX-License-Identifier: BSD-2-Clause + +#include <common/time.h> + +#include <sys/select.h> + +#include <wasi/api.h> +#include <errno.h> + +int pselect(int nfds, fd_set *restrict readfds, fd_set *restrict writefds, + fd_set *restrict errorfds, const struct timespec *restrict timeout, + const sigset_t *sigmask) { + // Negative file descriptor upperbound. + if (nfds < 0) { + errno = EINVAL; + return -1; + } + + // This implementation does not support polling for exceptional + // conditions, such as out-of-band data on TCP sockets. + if (errorfds != NULL && errorfds->__nfds > 0) { + errno = ENOSYS; + return -1; + } + + // Replace NULL pointers by the empty set. + fd_set empty; + FD_ZERO(&empty); + if (readfds == NULL) + readfds = ∅ + if (writefds == NULL) + writefds = ∅ + + // Determine the maximum number of events. + size_t maxevents = readfds->__nfds + writefds->__nfds + 1; + __wasi_subscription_t subscriptions[maxevents]; + size_t nsubscriptions = 0; + + // Convert the readfds set. + for (size_t i = 0; i < readfds->__nfds; ++i) { + int fd = readfds->__fds[i]; + if (fd < nfds) { + __wasi_subscription_t *subscription = &subscriptions[nsubscriptions++]; + *subscription = (__wasi_subscription_t){ + .userdata = fd, + .u.tag = __WASI_EVENTTYPE_FD_READ, + .u.u.fd_read.file_descriptor = fd, + }; + } + } + + // Convert the writefds set. + for (size_t i = 0; i < writefds->__nfds; ++i) { + int fd = writefds->__fds[i]; + if (fd < nfds) { + __wasi_subscription_t *subscription = &subscriptions[nsubscriptions++]; + *subscription = (__wasi_subscription_t){ + .userdata = fd, + .u.tag = __WASI_EVENTTYPE_FD_WRITE, + .u.u.fd_write.file_descriptor = fd, + }; + } + } + + // Create extra event for the timeout. + if (timeout != NULL) { + __wasi_subscription_t *subscription = &subscriptions[nsubscriptions++]; + *subscription = (__wasi_subscription_t){ + .u.tag = __WASI_EVENTTYPE_CLOCK, + .u.u.clock.id = __WASI_CLOCKID_REALTIME, + }; + if (!timespec_to_timestamp_clamp(timeout, &subscription->u.u.clock.timeout)) { + errno = EINVAL; + return -1; + } + } + + // Execute poll(). + size_t nevents; + __wasi_event_t events[nsubscriptions]; + __wasi_errno_t error = + __wasi_poll_oneoff(subscriptions, events, nsubscriptions, &nevents); + if (error != 0) { + // WASI's poll requires at least one subscription, or else it returns + // `EINVAL`. Since a `pselect` with nothing to wait for is valid in POSIX, + // return `ENOTSUP` to indicate that we don't support that case. + // + // Wasm has no signal handling, so if none of the user-provided `pollfd` + // elements, nor the timeout, led us to producing even one subscription + // to wait for, there would be no way for the poll to wake up. WASI + // returns `EINVAL` in this case, but for users of `poll`, `ENOTSUP` is + // more likely to be understood. + if (nsubscriptions == 0) + errno = ENOTSUP; + else + errno = error; + return -1; + } + + // Test for EBADF. + for (size_t i = 0; i < nevents; ++i) { + const __wasi_event_t *event = &events[i]; + if ((event->type == __WASI_EVENTTYPE_FD_READ || + event->type == __WASI_EVENTTYPE_FD_WRITE) && + event->error == __WASI_ERRNO_BADF) { + errno = EBADF; + return -1; + } + } + + // Clear and set entries in the result sets. + FD_ZERO(readfds); + FD_ZERO(writefds); + for (size_t i = 0; i < nevents; ++i) { + const __wasi_event_t *event = &events[i]; + if (event->type == __WASI_EVENTTYPE_FD_READ) { + readfds->__fds[readfds->__nfds++] = event->userdata; + } else if (event->type == __WASI_EVENTTYPE_FD_WRITE) { + writefds->__fds[writefds->__nfds++] = event->userdata; + } + } + return readfds->__nfds + writefds->__nfds; +} diff --git a/libc-bottom-half/cloudlibc/src/libc/sys/select/select.c b/libc-bottom-half/cloudlibc/src/libc/sys/select/select.c new file mode 100644 index 0000000..ebe5e8c --- /dev/null +++ b/libc-bottom-half/cloudlibc/src/libc/sys/select/select.c @@ -0,0 +1,25 @@ +// Copyright (c) 2015 Nuxi, https://nuxi.nl/ +// +// SPDX-License-Identifier: BSD-2-Clause + +#include <sys/select.h> + +#include <errno.h> +#include <stddef.h> + +int select(int nfds, fd_set *restrict readfds, fd_set *restrict writefds, + fd_set *restrict errorfds, struct timeval *restrict timeout) { + if (timeout != NULL) { + // Timeout specified. + if (timeout->tv_usec < 0 || timeout->tv_usec >= 1000000) { + errno = EINVAL; + return -1; + } + struct timespec ts = {.tv_sec = timeout->tv_sec, + .tv_nsec = (long)timeout->tv_usec * 1000}; + return pselect(nfds, readfds, writefds, errorfds, &ts, NULL); + } else { + // No timeout specified. + return pselect(nfds, readfds, writefds, errorfds, NULL, NULL); + } +} diff --git a/libc-bottom-half/cloudlibc/src/libc/sys/socket/getsockopt.c b/libc-bottom-half/cloudlibc/src/libc/sys/socket/getsockopt.c new file mode 100644 index 0000000..1fe41c4 --- /dev/null +++ b/libc-bottom-half/cloudlibc/src/libc/sys/socket/getsockopt.c @@ -0,0 +1,48 @@ +// Copyright (c) 2015-2016 Nuxi, https://nuxi.nl/ +// +// SPDX-License-Identifier: BSD-2-Clause + +#include <sys/socket.h> + +#include <wasi/api.h> +#include <errno.h> +#include <string.h> + +int getsockopt(int socket, int level, int option_name, + void *restrict option_value, socklen_t *restrict option_len) { + // Only support SOL_SOCKET options for now. + if (level != SOL_SOCKET) { + errno = ENOPROTOOPT; + return -1; + } + + int value; + switch (option_name) { + case SO_TYPE: { + // Return the type of the socket. This information can simply be + // obtained by looking at the file descriptor type. + __wasi_fdstat_t fsb; + if (__wasi_fd_fdstat_get(socket, &fsb) != 0) { + errno = EBADF; + return -1; + } + if (fsb.fs_filetype != __WASI_FILETYPE_SOCKET_DGRAM && + fsb.fs_filetype != __WASI_FILETYPE_SOCKET_STREAM) { + errno = ENOTSOCK; + return -1; + } + value = fsb.fs_filetype; + break; + } + default: { + errno = ENOPROTOOPT; + return -1; + } + } + + // Copy out integer value. + memcpy(option_value, &value, + *option_len < sizeof(int) ? *option_len : sizeof(int)); + *option_len = sizeof(int); + return 0; +} diff --git a/libc-bottom-half/cloudlibc/src/libc/sys/socket/recv.c b/libc-bottom-half/cloudlibc/src/libc/sys/socket/recv.c new file mode 100644 index 0000000..d35f889 --- /dev/null +++ b/libc-bottom-half/cloudlibc/src/libc/sys/socket/recv.c @@ -0,0 +1,40 @@ +// Copyright (c) 2015-2017 Nuxi, https://nuxi.nl/ +// +// SPDX-License-Identifier: BSD-2-Clause + +#include <sys/socket.h> + +#include <assert.h> +#include <wasi/api.h> +#include <errno.h> +#include <stdint.h> + +static_assert(MSG_PEEK == __WASI_RIFLAGS_RECV_PEEK, "Value mismatch"); +static_assert(MSG_WAITALL == __WASI_RIFLAGS_RECV_WAITALL, "Value mismatch"); + +ssize_t recv(int socket, void *restrict buffer, size_t length, int flags) { + // Validate flags. + if ((flags & ~(MSG_PEEK | MSG_WAITALL)) != 0) { + errno = EOPNOTSUPP; + return -1; + } + + // Prepare input parameters. + __wasi_iovec_t iov = {.buf = buffer, .buf_len = length}; + __wasi_iovec_t *ri_data = &iov; + size_t ri_data_len = 1; + __wasi_riflags_t ri_flags = flags; + + // Perform system call. + size_t ro_datalen; + __wasi_roflags_t ro_flags; + __wasi_errno_t error = __wasi_sock_recv(socket, + ri_data, ri_data_len, ri_flags, + &ro_datalen, + &ro_flags); + if (error != 0) { + errno = error; + return -1; + } + return ro_datalen; +} diff --git a/libc-bottom-half/cloudlibc/src/libc/sys/socket/send.c b/libc-bottom-half/cloudlibc/src/libc/sys/socket/send.c new file mode 100644 index 0000000..85a298a --- /dev/null +++ b/libc-bottom-half/cloudlibc/src/libc/sys/socket/send.c @@ -0,0 +1,32 @@ +// Copyright (c) 2015-2017 Nuxi, https://nuxi.nl/ +// +// SPDX-License-Identifier: BSD-2-Clause + +#include <sys/socket.h> + +#include <assert.h> +#include <wasi/api.h> +#include <errno.h> + +ssize_t send(int socket, const void *buffer, size_t length, int flags) { + // This implementation does not support any flags. + if (flags != 0) { + errno = EOPNOTSUPP; + return -1; + } + + // Prepare input parameters. + __wasi_ciovec_t iov = {.buf = buffer, .buf_len = length}; + __wasi_ciovec_t *si_data = &iov; + size_t si_data_len = 1; + __wasi_siflags_t si_flags = 0; + + // Perform system call. + size_t so_datalen; + __wasi_errno_t error = __wasi_sock_send(socket, si_data, si_data_len, si_flags, &so_datalen); + if (error != 0) { + errno = error; + return -1; + } + return so_datalen; +} diff --git a/libc-bottom-half/cloudlibc/src/libc/sys/socket/shutdown.c b/libc-bottom-half/cloudlibc/src/libc/sys/socket/shutdown.c new file mode 100644 index 0000000..261fcb8 --- /dev/null +++ b/libc-bottom-half/cloudlibc/src/libc/sys/socket/shutdown.c @@ -0,0 +1,27 @@ +// Copyright (c) 2015-2016 Nuxi, https://nuxi.nl/ +// +// SPDX-License-Identifier: BSD-2-Clause + +#include <sys/socket.h> + +#include <assert.h> +#include <wasi/api.h> +#include <errno.h> + +static_assert(SHUT_RD == __WASI_SDFLAGS_RD, "Value mismatch"); +static_assert(SHUT_WR == __WASI_SDFLAGS_WR, "Value mismatch"); + +int shutdown(int socket, int how) { + // Validate shutdown flags. + if (how != SHUT_RD && how != SHUT_WR && how != SHUT_RDWR) { + errno = EINVAL; + return -1; + } + + __wasi_errno_t error = __wasi_sock_shutdown(socket, how); + if (error != 0) { + errno = error; + return -1; + } + return error; +} diff --git a/libc-bottom-half/cloudlibc/src/libc/sys/socket/socket_impl.h b/libc-bottom-half/cloudlibc/src/libc/sys/socket/socket_impl.h new file mode 100644 index 0000000..7b1a366 --- /dev/null +++ b/libc-bottom-half/cloudlibc/src/libc/sys/socket/socket_impl.h @@ -0,0 +1,57 @@ +// Copyright (c) 2015-2017 Nuxi, https://nuxi.nl/ +// +// SPDX-License-Identifier: BSD-2-Clause + +#ifndef SYS_SOCKET_SOCKET_IMPL_H +#define SYS_SOCKET_SOCKET_IMPL_H + +#include <sys/socket.h> +#include <sys/un.h> + +#include <netinet/in.h> + +#include <assert.h> +#include <stdalign.h> +#include <stddef.h> +#include <stdint.h> + +static_assert(sizeof(struct sockaddr_storage) >= sizeof(struct sockaddr), + "struct sockaddr_storage too small"); +static_assert(alignof(struct sockaddr_storage) == alignof(struct sockaddr), + "struct sockaddr alignment incorrect"); +static_assert(sizeof(struct sockaddr_storage) >= sizeof(struct sockaddr_in), + "struct sockaddr_storage too small"); +static_assert(alignof(struct sockaddr_storage) == alignof(struct sockaddr_in), + "struct sockaddr_in alignment incorrect"); +static_assert(sizeof(struct sockaddr_storage) >= sizeof(struct sockaddr_in6), + "struct sockaddr_storage too small"); +static_assert(alignof(struct sockaddr_storage) == alignof(struct sockaddr_in6), + "struct sockaddr_in6 alignment incorrect"); +static_assert(sizeof(struct sockaddr_storage) >= sizeof(struct sockaddr_un), + "struct sockaddr_storage too small"); +static_assert(alignof(struct sockaddr_storage) == alignof(struct sockaddr_un), + "struct sockaddr_un alignment incorrect"); + +// Returns the control message header stored at a provided memory +// address, ensuring that it is stored within the ancillary data buffer +// of a message header. +static inline struct cmsghdr *CMSG_GET(const struct msghdr *mhdr, void *cmsg) { + // Safety belt: require that the returned object is properly aligned. + assert((uintptr_t)cmsg % alignof(struct cmsghdr) == 0 && + "Attempted to access unaligned control message header"); + + // Safety belt: the computed starting address of the control message + // header may only lie inside the ancillary data buffer, or right + // after it in case we've reached the end of the buffer. + const unsigned char *begin = mhdr->msg_control; + const unsigned char *end = begin + mhdr->msg_controllen; + assert((unsigned char *)cmsg >= begin && + (unsigned char *)cmsg < end + alignof(struct cmsghdr) && + "Computed object outside of buffer boundaries"); + + // Only return the control message header in case all of its fields + // lie within the ancillary data buffer. + return CMSG_DATA((struct cmsghdr *)cmsg) <= end ? cmsg : NULL; +} + +#endif diff --git a/libc-bottom-half/cloudlibc/src/libc/sys/stat/fstat.c b/libc-bottom-half/cloudlibc/src/libc/sys/stat/fstat.c new file mode 100644 index 0000000..b8ffdb5 --- /dev/null +++ b/libc-bottom-half/cloudlibc/src/libc/sys/stat/fstat.c @@ -0,0 +1,21 @@ +// Copyright (c) 2015-2016 Nuxi, https://nuxi.nl/ +// +// SPDX-License-Identifier: BSD-2-Clause + +#include <sys/stat.h> + +#include <wasi/api.h> +#include <errno.h> + +#include "stat_impl.h" + +int fstat(int fildes, struct stat *buf) { + __wasi_filestat_t internal_stat; + __wasi_errno_t error = __wasi_fd_filestat_get(fildes, &internal_stat); + if (error != 0) { + errno = error; + return -1; + } + to_public_stat(&internal_stat, buf); + return 0; +} diff --git a/libc-bottom-half/cloudlibc/src/libc/sys/stat/fstatat.c b/libc-bottom-half/cloudlibc/src/libc/sys/stat/fstatat.c new file mode 100644 index 0000000..25b29ac --- /dev/null +++ b/libc-bottom-half/cloudlibc/src/libc/sys/stat/fstatat.c @@ -0,0 +1,31 @@ +// Copyright (c) 2015-2016 Nuxi, https://nuxi.nl/ +// +// SPDX-License-Identifier: BSD-2-Clause + +#include <sys/stat.h> + +#include <wasi/api.h> +#include <errno.h> +#include <fcntl.h> +#include <string.h> + +#include "stat_impl.h" + +int __wasilibc_nocwd_fstatat(int fd, const char *restrict path, struct stat *restrict buf, + int flag) { + // Create lookup properties. + __wasi_lookupflags_t lookup_flags = 0; + if ((flag & AT_SYMLINK_NOFOLLOW) == 0) + lookup_flags |= __WASI_LOOKUPFLAGS_SYMLINK_FOLLOW; + + // Perform system call. + __wasi_filestat_t internal_stat; + __wasi_errno_t error = + __wasi_path_filestat_get(fd, lookup_flags, path, &internal_stat); + if (error != 0) { + errno = error; + return -1; + } + to_public_stat(&internal_stat, buf); + return 0; +} diff --git a/libc-bottom-half/cloudlibc/src/libc/sys/stat/futimens.c b/libc-bottom-half/cloudlibc/src/libc/sys/stat/futimens.c new file mode 100644 index 0000000..13357fc --- /dev/null +++ b/libc-bottom-half/cloudlibc/src/libc/sys/stat/futimens.c @@ -0,0 +1,29 @@ +// Copyright (c) 2015-2016 Nuxi, https://nuxi.nl/ +// +// SPDX-License-Identifier: BSD-2-Clause + +#include <sys/stat.h> + +#include <wasi/api.h> +#include <errno.h> + +#include "stat_impl.h" + +int futimens(int fd, const struct timespec *times) { + // Convert timestamps and extract NOW/OMIT flags. + __wasi_timestamp_t st_atim; + __wasi_timestamp_t st_mtim; + __wasi_fstflags_t flags; + if (!utimens_get_timestamps(times, &st_atim, &st_mtim, &flags)) { + errno = EINVAL; + return -1; + } + + // Perform system call. + __wasi_errno_t error = __wasi_fd_filestat_set_times(fd, st_atim, st_mtim, flags); + if (error != 0) { + errno = error; + return -1; + } + return 0; +} diff --git a/libc-bottom-half/cloudlibc/src/libc/sys/stat/mkdirat.c b/libc-bottom-half/cloudlibc/src/libc/sys/stat/mkdirat.c new file mode 100644 index 0000000..fd27d5e --- /dev/null +++ b/libc-bottom-half/cloudlibc/src/libc/sys/stat/mkdirat.c @@ -0,0 +1,18 @@ +// Copyright (c) 2015-2016 Nuxi, https://nuxi.nl/ +// +// SPDX-License-Identifier: BSD-2-Clause + +#include <sys/stat.h> + +#include <wasi/api.h> +#include <errno.h> +#include <string.h> + +int __wasilibc_nocwd_mkdirat_nomode(int fd, const char *path) { + __wasi_errno_t error = __wasi_path_create_directory(fd, path); + if (error != 0) { + errno = error; + return -1; + } + return 0; +} diff --git a/libc-bottom-half/cloudlibc/src/libc/sys/stat/stat_impl.h b/libc-bottom-half/cloudlibc/src/libc/sys/stat/stat_impl.h new file mode 100644 index 0000000..9726b51 --- /dev/null +++ b/libc-bottom-half/cloudlibc/src/libc/sys/stat/stat_impl.h @@ -0,0 +1,116 @@ +// Copyright (c) 2015-2017 Nuxi, https://nuxi.nl/ +// +// SPDX-License-Identifier: BSD-2-Clause + +#ifndef SYS_STAT_STAT_IMPL_H +#define SYS_STAT_STAT_IMPL_H + +#include <common/time.h> + +#include <sys/stat.h> + +#include <assert.h> +#include <wasi/api.h> +#include <stdbool.h> + +static_assert(S_ISBLK(S_IFBLK), "Value mismatch"); +static_assert(S_ISCHR(S_IFCHR), "Value mismatch"); +static_assert(S_ISDIR(S_IFDIR), "Value mismatch"); +static_assert(S_ISFIFO(S_IFIFO), "Value mismatch"); +static_assert(S_ISLNK(S_IFLNK), "Value mismatch"); +static_assert(S_ISREG(S_IFREG), "Value mismatch"); +static_assert(S_ISSOCK(S_IFSOCK), "Value mismatch"); + +static inline void to_public_stat(const __wasi_filestat_t *in, + struct stat *out) { + // Ensure that we don't truncate any values. + static_assert(sizeof(in->dev) == sizeof(out->st_dev), "Size mismatch"); + static_assert(sizeof(in->ino) == sizeof(out->st_ino), "Size mismatch"); + /* + * The non-standard __st_filetype field appears to only be used for shared + * memory, which we don't currently support. + */ + /* nlink_t is 64-bit on wasm32, following the x32 ABI. */ + static_assert(sizeof(in->nlink) <= sizeof(out->st_nlink), "Size shortfall"); + static_assert(sizeof(in->size) == sizeof(out->st_size), "Size mismatch"); + + *out = (struct stat){ + .st_dev = in->dev, + .st_ino = in->ino, + .st_nlink = in->nlink, + .st_size = in->size, + .st_atim = timestamp_to_timespec(in->atim), + .st_mtim = timestamp_to_timespec(in->mtim), + .st_ctim = timestamp_to_timespec(in->ctim), + }; + + // Convert file type to legacy types encoded in st_mode. + switch (in->filetype) { + case __WASI_FILETYPE_BLOCK_DEVICE: + out->st_mode |= S_IFBLK; + break; + case __WASI_FILETYPE_CHARACTER_DEVICE: + out->st_mode |= S_IFCHR; + break; + case __WASI_FILETYPE_DIRECTORY: + out->st_mode |= S_IFDIR; + break; + case __WASI_FILETYPE_REGULAR_FILE: + out->st_mode |= S_IFREG; + break; + case __WASI_FILETYPE_SOCKET_DGRAM: + case __WASI_FILETYPE_SOCKET_STREAM: + out->st_mode |= S_IFSOCK; + break; + case __WASI_FILETYPE_SYMBOLIC_LINK: + out->st_mode |= S_IFLNK; + break; + } +} + +static inline bool utimens_get_timestamps(const struct timespec *times, + __wasi_timestamp_t *st_atim, + __wasi_timestamp_t *st_mtim, + __wasi_fstflags_t *flags) { + if (times == NULL) { + // Update both timestamps. + *flags = __WASI_FSTFLAGS_ATIM_NOW | __WASI_FSTFLAGS_MTIM_NOW; + *st_atim = (__wasi_timestamp_t) { 0 }; + *st_mtim = (__wasi_timestamp_t) { 0 }; + } else { + // Set individual timestamps. + *flags = 0; + switch (times[0].tv_nsec) { + case UTIME_NOW: + *flags |= __WASI_FSTFLAGS_ATIM_NOW; + *st_atim = (__wasi_timestamp_t) { 0 }; + break; + case UTIME_OMIT: + *st_atim = (__wasi_timestamp_t) { 0 }; + break; + default: + *flags |= __WASI_FSTFLAGS_ATIM; + if (!timespec_to_timestamp_exact(×[0], st_atim)) + return false; + break; + } + + switch (times[1].tv_nsec) { + case UTIME_NOW: + *flags |= __WASI_FSTFLAGS_MTIM_NOW; + *st_mtim = (__wasi_timestamp_t) { 0 }; + break; + case UTIME_OMIT: + *st_mtim = (__wasi_timestamp_t) { 0 }; + break; + default: + *flags |= __WASI_FSTFLAGS_MTIM; + if (!timespec_to_timestamp_exact(×[1], st_mtim)) + return false; + break; + } + } + return true; +} + +#endif diff --git a/libc-bottom-half/cloudlibc/src/libc/sys/stat/utimensat.c b/libc-bottom-half/cloudlibc/src/libc/sys/stat/utimensat.c new file mode 100644 index 0000000..19508a1 --- /dev/null +++ b/libc-bottom-half/cloudlibc/src/libc/sys/stat/utimensat.c @@ -0,0 +1,38 @@ +// Copyright (c) 2015-2016 Nuxi, https://nuxi.nl/ +// +// SPDX-License-Identifier: BSD-2-Clause + +#include <sys/stat.h> + +#include <wasi/api.h> +#include <errno.h> +#include <fcntl.h> +#include <string.h> + +#include "stat_impl.h" + +int __wasilibc_nocwd_utimensat(int fd, const char *path, const struct timespec times[2], + int flag) { + // Convert timestamps and extract NOW/OMIT flags. + __wasi_timestamp_t st_atim; + __wasi_timestamp_t st_mtim; + __wasi_fstflags_t flags; + if (!utimens_get_timestamps(times, &st_atim, &st_mtim, &flags)) { + errno = EINVAL; + return -1; + } + + // Create lookup properties. + __wasi_lookupflags_t lookup_flags = 0; + if ((flag & AT_SYMLINK_NOFOLLOW) == 0) + lookup_flags |= __WASI_LOOKUPFLAGS_SYMLINK_FOLLOW; + + // Perform system call. + __wasi_errno_t error = + __wasi_path_filestat_set_times(fd, lookup_flags, path, st_atim, st_mtim, flags); + if (error != 0) { + errno = error; + return -1; + } + return 0; +} diff --git a/libc-bottom-half/cloudlibc/src/libc/sys/time/gettimeofday.c b/libc-bottom-half/cloudlibc/src/libc/sys/time/gettimeofday.c new file mode 100644 index 0000000..596bdff --- /dev/null +++ b/libc-bottom-half/cloudlibc/src/libc/sys/time/gettimeofday.c @@ -0,0 +1,18 @@ +// Copyright (c) 2015-2016 Nuxi, https://nuxi.nl/ +// +// SPDX-License-Identifier: BSD-2-Clause + +#include <common/time.h> + +#include <sys/time.h> + +#include <wasi/api.h> + +int gettimeofday(struct timeval *restrict tp, void *tz) { + if (tp != NULL) { + __wasi_timestamp_t ts = 0; + (void)__wasi_clock_time_get(__WASI_CLOCKID_REALTIME, 1000, &ts); + *tp = timestamp_to_timeval(ts); + } + return 0; +} diff --git a/libc-bottom-half/cloudlibc/src/libc/sys/uio/preadv.c b/libc-bottom-half/cloudlibc/src/libc/sys/uio/preadv.c new file mode 100644 index 0000000..36f882d --- /dev/null +++ b/libc-bottom-half/cloudlibc/src/libc/sys/uio/preadv.c @@ -0,0 +1,24 @@ +// Copyright (c) 2015-2016 Nuxi, https://nuxi.nl/ +// +// SPDX-License-Identifier: BSD-2-Clause + +#include <sys/types.h> +#include <sys/uio.h> + +#include <wasi/api.h> +#include <errno.h> + +ssize_t preadv(int fildes, const struct iovec *iov, int iovcnt, off_t offset) { + if (iovcnt < 0 || offset < 0) { + errno = EINVAL; + return -1; + } + size_t bytes_read; + __wasi_errno_t error = __wasi_fd_pread( + fildes, (const __wasi_iovec_t *)iov, iovcnt, offset, &bytes_read); + if (error != 0) { + errno = error; + return -1; + } + return bytes_read; +} diff --git a/libc-bottom-half/cloudlibc/src/libc/sys/uio/pwritev.c b/libc-bottom-half/cloudlibc/src/libc/sys/uio/pwritev.c new file mode 100644 index 0000000..d6f8851 --- /dev/null +++ b/libc-bottom-half/cloudlibc/src/libc/sys/uio/pwritev.c @@ -0,0 +1,24 @@ +// Copyright (c) 2015-2016 Nuxi, https://nuxi.nl/ +// +// SPDX-License-Identifier: BSD-2-Clause + +#include <sys/types.h> +#include <sys/uio.h> + +#include <wasi/api.h> +#include <errno.h> + +ssize_t pwritev(int fildes, const struct iovec *iov, int iovcnt, off_t offset) { + if (iovcnt < 0 || offset < 0) { + errno = EINVAL; + return -1; + } + size_t bytes_written; + __wasi_errno_t error = __wasi_fd_pwrite( + fildes, (const __wasi_ciovec_t *)iov, iovcnt, offset, &bytes_written); + if (error != 0) { + errno = error; + return -1; + } + return bytes_written; +} diff --git a/libc-bottom-half/cloudlibc/src/libc/sys/uio/readv.c b/libc-bottom-half/cloudlibc/src/libc/sys/uio/readv.c new file mode 100644 index 0000000..e3eaebe --- /dev/null +++ b/libc-bottom-half/cloudlibc/src/libc/sys/uio/readv.c @@ -0,0 +1,40 @@ +// Copyright (c) 2015-2016 Nuxi, https://nuxi.nl/ +// +// SPDX-License-Identifier: BSD-2-Clause + +#include <sys/uio.h> + +#include <assert.h> +#include <wasi/api.h> +#include <errno.h> +#include <stddef.h> + +static_assert(offsetof(struct iovec, iov_base) == + offsetof(__wasi_iovec_t, buf), + "Offset mismatch"); +static_assert(sizeof(((struct iovec *)0)->iov_base) == + sizeof(((__wasi_iovec_t *)0)->buf), + "Size mismatch"); +static_assert(offsetof(struct iovec, iov_len) == + offsetof(__wasi_iovec_t, buf_len), + "Offset mismatch"); +static_assert(sizeof(((struct iovec *)0)->iov_len) == + sizeof(((__wasi_iovec_t *)0)->buf_len), + "Size mismatch"); +static_assert(sizeof(struct iovec) == sizeof(__wasi_iovec_t), + "Size mismatch"); + +ssize_t readv(int fildes, const struct iovec *iov, int iovcnt) { + if (iovcnt < 0) { + errno = EINVAL; + return -1; + } + size_t bytes_read; + __wasi_errno_t error = __wasi_fd_read( + fildes, (const __wasi_iovec_t *)iov, iovcnt, &bytes_read); + if (error != 0) { + errno = error; + return -1; + } + return bytes_read; +} diff --git a/libc-bottom-half/cloudlibc/src/libc/sys/uio/writev.c b/libc-bottom-half/cloudlibc/src/libc/sys/uio/writev.c new file mode 100644 index 0000000..459b152 --- /dev/null +++ b/libc-bottom-half/cloudlibc/src/libc/sys/uio/writev.c @@ -0,0 +1,40 @@ +// Copyright (c) 2015-2016 Nuxi, https://nuxi.nl/ +// +// SPDX-License-Identifier: BSD-2-Clause + +#include <sys/uio.h> + +#include <assert.h> +#include <wasi/api.h> +#include <errno.h> +#include <stddef.h> + +static_assert(offsetof(struct iovec, iov_base) == + offsetof(__wasi_ciovec_t, buf), + "Offset mismatch"); +static_assert(sizeof(((struct iovec *)0)->iov_base) == + sizeof(((__wasi_ciovec_t *)0)->buf), + "Size mismatch"); +static_assert(offsetof(struct iovec, iov_len) == + offsetof(__wasi_ciovec_t, buf_len), + "Offset mismatch"); +static_assert(sizeof(((struct iovec *)0)->iov_len) == + sizeof(((__wasi_ciovec_t *)0)->buf_len), + "Size mismatch"); +static_assert(sizeof(struct iovec) == sizeof(__wasi_ciovec_t), + "Size mismatch"); + +ssize_t writev(int fildes, const struct iovec *iov, int iovcnt) { + if (iovcnt < 0) { + errno = EINVAL; + return -1; + } + size_t bytes_written; + __wasi_errno_t error = __wasi_fd_write( + fildes, (const __wasi_ciovec_t *)iov, iovcnt, &bytes_written); + if (error != 0) { + errno = error; + return -1; + } + return bytes_written; +} diff --git a/libc-bottom-half/cloudlibc/src/libc/time/CLOCK_MONOTONIC.c b/libc-bottom-half/cloudlibc/src/libc/time/CLOCK_MONOTONIC.c new file mode 100644 index 0000000..a4c4a62 --- /dev/null +++ b/libc-bottom-half/cloudlibc/src/libc/time/CLOCK_MONOTONIC.c @@ -0,0 +1,12 @@ +// Copyright (c) 2016 Nuxi, https://nuxi.nl/ +// +// SPDX-License-Identifier: BSD-2-Clause + +#include <common/clock.h> + +#include <wasi/api.h> +#include <time.h> + +const struct __clockid _CLOCK_MONOTONIC = { + .id = __WASI_CLOCKID_MONOTONIC, +}; diff --git a/libc-bottom-half/cloudlibc/src/libc/time/CLOCK_REALTIME.c b/libc-bottom-half/cloudlibc/src/libc/time/CLOCK_REALTIME.c new file mode 100644 index 0000000..9523754 --- /dev/null +++ b/libc-bottom-half/cloudlibc/src/libc/time/CLOCK_REALTIME.c @@ -0,0 +1,12 @@ +// Copyright (c) 2016 Nuxi, https://nuxi.nl/ +// +// SPDX-License-Identifier: BSD-2-Clause + +#include <common/clock.h> + +#include <wasi/api.h> +#include <time.h> + +const struct __clockid _CLOCK_REALTIME = { + .id = __WASI_CLOCKID_REALTIME, +}; diff --git a/libc-bottom-half/cloudlibc/src/libc/time/clock_getres.c b/libc-bottom-half/cloudlibc/src/libc/time/clock_getres.c new file mode 100644 index 0000000..8030d4b --- /dev/null +++ b/libc-bottom-half/cloudlibc/src/libc/time/clock_getres.c @@ -0,0 +1,21 @@ +// Copyright (c) 2015-2016 Nuxi, https://nuxi.nl/ +// +// SPDX-License-Identifier: BSD-2-Clause + +#include <common/clock.h> +#include <common/time.h> + +#include <wasi/api.h> +#include <errno.h> +#include <time.h> + +int clock_getres(clockid_t clock_id, struct timespec *res) { + __wasi_timestamp_t ts; + __wasi_errno_t error = __wasi_clock_res_get(clock_id->id, &ts); + if (error != 0) { + errno = error; + return -1; + } + *res = timestamp_to_timespec(ts); + return 0; +} diff --git a/libc-bottom-half/cloudlibc/src/libc/time/clock_gettime.c b/libc-bottom-half/cloudlibc/src/libc/time/clock_gettime.c new file mode 100644 index 0000000..c7e1a60 --- /dev/null +++ b/libc-bottom-half/cloudlibc/src/libc/time/clock_gettime.c @@ -0,0 +1,22 @@ +// Copyright (c) 2015-2016 Nuxi, https://nuxi.nl/ +// +// SPDX-License-Identifier: BSD-2-Clause + +#include <common/clock.h> +#include <common/time.h> + +#include <wasi/api.h> +#include <errno.h> +#include <time.h> + +int __clock_gettime(clockid_t clock_id, struct timespec *tp) { + __wasi_timestamp_t ts; + __wasi_errno_t error = __wasi_clock_time_get(clock_id->id, 1, &ts); + if (error != 0) { + errno = error; + return -1; + } + *tp = timestamp_to_timespec(ts); + return 0; +} +weak_alias(__clock_gettime, clock_gettime); diff --git a/libc-bottom-half/cloudlibc/src/libc/time/clock_nanosleep.c b/libc-bottom-half/cloudlibc/src/libc/time/clock_nanosleep.c new file mode 100644 index 0000000..d375056 --- /dev/null +++ b/libc-bottom-half/cloudlibc/src/libc/time/clock_nanosleep.c @@ -0,0 +1,37 @@ +// Copyright (c) 2015-2016 Nuxi, https://nuxi.nl/ +// +// SPDX-License-Identifier: BSD-2-Clause + +#include <common/clock.h> +#include <common/time.h> + +#include <assert.h> +#include <wasi/api.h> +#include <errno.h> +#include <time.h> + +static_assert(TIMER_ABSTIME == __WASI_SUBCLOCKFLAGS_SUBSCRIPTION_CLOCK_ABSTIME, + "Value mismatch"); + +int clock_nanosleep(clockid_t clock_id, int flags, const struct timespec *rqtp, + struct timespec *rmtp) { + if ((flags & ~TIMER_ABSTIME) != 0) + return EINVAL; + + // Prepare polling subscription. + __wasi_subscription_t sub = { + .u.tag = __WASI_EVENTTYPE_CLOCK, + .u.u.clock.id = clock_id->id, + .u.u.clock.flags = flags, + }; + if (!timespec_to_timestamp_clamp(rqtp, &sub.u.u.clock.timeout)) + return EINVAL; + + // Block until polling event is triggered. + size_t nevents; + __wasi_event_t ev; + __wasi_errno_t error = __wasi_poll_oneoff(&sub, &ev, 1, &nevents); + return error == 0 && ev.error == 0 ? 0 : ENOTSUP; +} + +weak_alias(clock_nanosleep, __clock_nanosleep); diff --git a/libc-bottom-half/cloudlibc/src/libc/time/nanosleep.c b/libc-bottom-half/cloudlibc/src/libc/time/nanosleep.c new file mode 100644 index 0000000..5f26c5c --- /dev/null +++ b/libc-bottom-half/cloudlibc/src/libc/time/nanosleep.c @@ -0,0 +1,15 @@ +// Copyright (c) 2015 Nuxi, https://nuxi.nl/ +// +// SPDX-License-Identifier: BSD-2-Clause + +#include <errno.h> +#include <time.h> + +int nanosleep(const struct timespec *rqtp, struct timespec *rem) { + int error = clock_nanosleep(CLOCK_REALTIME, 0, rqtp, rem); + if (error != 0) { + errno = error; + return -1; + } + return 0; +} diff --git a/libc-bottom-half/cloudlibc/src/libc/time/time.c b/libc-bottom-half/cloudlibc/src/libc/time/time.c new file mode 100644 index 0000000..52bc0e4 --- /dev/null +++ b/libc-bottom-half/cloudlibc/src/libc/time/time.c @@ -0,0 +1,16 @@ +// Copyright (c) 2015-2016 Nuxi, https://nuxi.nl/ +// +// SPDX-License-Identifier: BSD-2-Clause + +#include <common/time.h> + +#include <wasi/api.h> +#include <time.h> + +time_t time(time_t *tloc) { + __wasi_timestamp_t ts = 0; + (void)__wasi_clock_time_get(__WASI_CLOCKID_REALTIME, NSEC_PER_SEC, &ts); + if (tloc != NULL) + *tloc = ts / NSEC_PER_SEC; + return ts / NSEC_PER_SEC; +} diff --git a/libc-bottom-half/cloudlibc/src/libc/unistd/close.c b/libc-bottom-half/cloudlibc/src/libc/unistd/close.c new file mode 100644 index 0000000..2f5814b --- /dev/null +++ b/libc-bottom-half/cloudlibc/src/libc/unistd/close.c @@ -0,0 +1,16 @@ +// Copyright (c) 2015-2016 Nuxi, https://nuxi.nl/ +// +// SPDX-License-Identifier: BSD-2-Clause + +#include <wasi/api.h> +#include <errno.h> +#include <unistd.h> + +int close(int fildes) { + __wasi_errno_t error = __wasi_fd_close(fildes); + if (error != 0) { + errno = error; + return -1; + } + return 0; +} diff --git a/libc-bottom-half/cloudlibc/src/libc/unistd/faccessat.c b/libc-bottom-half/cloudlibc/src/libc/unistd/faccessat.c new file mode 100644 index 0000000..ffaef6e --- /dev/null +++ b/libc-bottom-half/cloudlibc/src/libc/unistd/faccessat.c @@ -0,0 +1,53 @@ +// Copyright (c) 2016 Nuxi, https://nuxi.nl/ +// +// SPDX-License-Identifier: BSD-2-Clause + +#include <wasi/api.h> +#include <errno.h> +#include <fcntl.h> +#include <string.h> +#include <unistd.h> + +int __wasilibc_nocwd_faccessat(int fd, const char *path, int amode, int flag) { + // Validate function parameters. + if ((amode & ~(F_OK | R_OK | W_OK | X_OK)) != 0 || + (flag & ~AT_EACCESS) != 0) { + errno = EINVAL; + return -1; + } + + // Check for target file existence and obtain the file type. + __wasi_lookupflags_t lookup_flags = __WASI_LOOKUPFLAGS_SYMLINK_FOLLOW; + __wasi_filestat_t file; + __wasi_errno_t error = + __wasi_path_filestat_get(fd, lookup_flags, path, &file); + if (error != 0) { + errno = error; + return -1; + } + + // Test whether the requested access rights are present on the + // directory file descriptor. + if (amode != 0) { + __wasi_fdstat_t directory; + error = __wasi_fd_fdstat_get(fd, &directory); + if (error != 0) { + errno = error; + return -1; + } + + __wasi_rights_t min = 0; + if ((amode & R_OK) != 0) + min |= file.filetype == __WASI_FILETYPE_DIRECTORY + ? __WASI_RIGHTS_FD_READDIR + : __WASI_RIGHTS_FD_READ; + if ((amode & W_OK) != 0) + min |= __WASI_RIGHTS_FD_WRITE; + + if ((min & directory.fs_rights_inheriting) != min) { + errno = EACCES; + return -1; + } + } + return 0; +} diff --git a/libc-bottom-half/cloudlibc/src/libc/unistd/fdatasync.c b/libc-bottom-half/cloudlibc/src/libc/unistd/fdatasync.c new file mode 100644 index 0000000..b821b06 --- /dev/null +++ b/libc-bottom-half/cloudlibc/src/libc/unistd/fdatasync.c @@ -0,0 +1,16 @@ +// Copyright (c) 2015-2016 Nuxi, https://nuxi.nl/ +// +// SPDX-License-Identifier: BSD-2-Clause + +#include <wasi/api.h> +#include <errno.h> +#include <unistd.h> + +int fdatasync(int fildes) { + __wasi_errno_t error = __wasi_fd_datasync(fildes); + if (error != 0) { + errno = error == ENOTCAPABLE ? EBADF : error; + return -1; + } + return 0; +} diff --git a/libc-bottom-half/cloudlibc/src/libc/unistd/fsync.c b/libc-bottom-half/cloudlibc/src/libc/unistd/fsync.c new file mode 100644 index 0000000..733e294 --- /dev/null +++ b/libc-bottom-half/cloudlibc/src/libc/unistd/fsync.c @@ -0,0 +1,16 @@ +// Copyright (c) 2015-2016 Nuxi, https://nuxi.nl/ +// +// SPDX-License-Identifier: BSD-2-Clause + +#include <wasi/api.h> +#include <errno.h> +#include <unistd.h> + +int fsync(int fildes) { + __wasi_errno_t error = __wasi_fd_sync(fildes); + if (error != 0) { + errno = error == ENOTCAPABLE ? EINVAL : error; + return -1; + } + return 0; +} diff --git a/libc-bottom-half/cloudlibc/src/libc/unistd/ftruncate.c b/libc-bottom-half/cloudlibc/src/libc/unistd/ftruncate.c new file mode 100644 index 0000000..7792597 --- /dev/null +++ b/libc-bottom-half/cloudlibc/src/libc/unistd/ftruncate.c @@ -0,0 +1,22 @@ +// Copyright (c) 2015-2016 Nuxi, https://nuxi.nl/ +// +// SPDX-License-Identifier: BSD-2-Clause + +#include <wasi/api.h> +#include <errno.h> +#include <unistd.h> + +int ftruncate(int fildes, off_t length) { + if (length < 0) { + errno = EINVAL; + return -1; + } + __wasi_filesize_t st_size = length; + __wasi_errno_t error = + __wasi_fd_filestat_set_size(fildes, st_size); + if (error != 0) { + errno = error; + return -1; + } + return 0; +} diff --git a/libc-bottom-half/cloudlibc/src/libc/unistd/linkat.c b/libc-bottom-half/cloudlibc/src/libc/unistd/linkat.c new file mode 100644 index 0000000..d57f562 --- /dev/null +++ b/libc-bottom-half/cloudlibc/src/libc/unistd/linkat.c @@ -0,0 +1,24 @@ +// Copyright (c) 2015-2016 Nuxi, https://nuxi.nl/ +// +// SPDX-License-Identifier: BSD-2-Clause + +#include <wasi/api.h> +#include <errno.h> +#include <fcntl.h> +#include <string.h> +#include <unistd.h> + +int __wasilibc_nocwd_linkat(int fd1, const char *path1, int fd2, const char *path2, int flag) { + // Create lookup properties. + __wasi_lookupflags_t lookup1_flags = 0; + if ((flag & AT_SYMLINK_FOLLOW) != 0) + lookup1_flags |= __WASI_LOOKUPFLAGS_SYMLINK_FOLLOW; + + // Perform system call. + __wasi_errno_t error = __wasi_path_link(fd1, lookup1_flags, path1, fd2, path2); + if (error != 0) { + errno = error; + return -1; + } + return 0; +} diff --git a/libc-bottom-half/cloudlibc/src/libc/unistd/lseek.c b/libc-bottom-half/cloudlibc/src/libc/unistd/lseek.c new file mode 100644 index 0000000..3e0429f --- /dev/null +++ b/libc-bottom-half/cloudlibc/src/libc/unistd/lseek.c @@ -0,0 +1,25 @@ +// Copyright (c) 2015-2016 Nuxi, https://nuxi.nl/ +// +// SPDX-License-Identifier: BSD-2-Clause + +#include <assert.h> +#include <wasi/api.h> +#include <errno.h> +#include <unistd.h> + +static_assert(SEEK_CUR == __WASI_WHENCE_CUR, "Value mismatch"); +static_assert(SEEK_END == __WASI_WHENCE_END, "Value mismatch"); +static_assert(SEEK_SET == __WASI_WHENCE_SET, "Value mismatch"); + +off_t __lseek(int fildes, off_t offset, int whence) { + __wasi_filesize_t new_offset; + __wasi_errno_t error = + __wasi_fd_seek(fildes, offset, whence, &new_offset); + if (error != 0) { + errno = error == ENOTCAPABLE ? ESPIPE : error; + return -1; + } + return new_offset; +} + +weak_alias(__lseek, lseek); diff --git a/libc-bottom-half/cloudlibc/src/libc/unistd/pread.c b/libc-bottom-half/cloudlibc/src/libc/unistd/pread.c new file mode 100644 index 0000000..c9944bc --- /dev/null +++ b/libc-bottom-half/cloudlibc/src/libc/unistd/pread.c @@ -0,0 +1,31 @@ +// Copyright (c) 2015-2016 Nuxi, https://nuxi.nl/ +// +// SPDX-License-Identifier: BSD-2-Clause + +#include <wasi/api.h> +#include <errno.h> +#include <unistd.h> + +ssize_t pread(int fildes, void *buf, size_t nbyte, off_t offset) { + if (offset < 0) { + errno = EINVAL; + return -1; + } + __wasi_iovec_t iov = {.buf = buf, .buf_len = nbyte}; + size_t bytes_read; + __wasi_errno_t error = + __wasi_fd_pread(fildes, &iov, 1, offset, &bytes_read); + if (error != 0) { + __wasi_fdstat_t fds; + if (error == ENOTCAPABLE && __wasi_fd_fdstat_get(fildes, &fds) == 0) { + // Determine why we got ENOTCAPABLE. + if ((fds.fs_rights_base & __WASI_RIGHTS_FD_READ) == 0) + error = EBADF; + else + error = ESPIPE; + } + errno = error; + return -1; + } + return bytes_read; +} diff --git a/libc-bottom-half/cloudlibc/src/libc/unistd/pwrite.c b/libc-bottom-half/cloudlibc/src/libc/unistd/pwrite.c new file mode 100644 index 0000000..f80bc40 --- /dev/null +++ b/libc-bottom-half/cloudlibc/src/libc/unistd/pwrite.c @@ -0,0 +1,31 @@ +// Copyright (c) 2015-2016 Nuxi, https://nuxi.nl/ +// +// SPDX-License-Identifier: BSD-2-Clause + +#include <wasi/api.h> +#include <errno.h> +#include <unistd.h> + +ssize_t pwrite(int fildes, const void *buf, size_t nbyte, off_t offset) { + if (offset < 0) { + errno = EINVAL; + return -1; + } + __wasi_ciovec_t iov = {.buf = buf, .buf_len = nbyte}; + size_t bytes_written; + __wasi_errno_t error = + __wasi_fd_pwrite(fildes, &iov, 1, offset, &bytes_written); + if (error != 0) { + __wasi_fdstat_t fds; + if (error == ENOTCAPABLE && __wasi_fd_fdstat_get(fildes, &fds) == 0) { + // Determine why we got ENOTCAPABLE. + if ((fds.fs_rights_base & __WASI_RIGHTS_FD_WRITE) == 0) + error = EBADF; + else + error = ESPIPE; + } + errno = error; + return -1; + } + return bytes_written; +} diff --git a/libc-bottom-half/cloudlibc/src/libc/unistd/read.c b/libc-bottom-half/cloudlibc/src/libc/unistd/read.c new file mode 100644 index 0000000..1582126 --- /dev/null +++ b/libc-bottom-half/cloudlibc/src/libc/unistd/read.c @@ -0,0 +1,18 @@ +// Copyright (c) 2015-2016 Nuxi, https://nuxi.nl/ +// +// SPDX-License-Identifier: BSD-2-Clause + +#include <wasi/api.h> +#include <errno.h> +#include <unistd.h> + +ssize_t read(int fildes, void *buf, size_t nbyte) { + __wasi_iovec_t iov = {.buf = buf, .buf_len = nbyte}; + size_t bytes_read; + __wasi_errno_t error = __wasi_fd_read(fildes, &iov, 1, &bytes_read); + if (error != 0) { + errno = error == ENOTCAPABLE ? EBADF : error; + return -1; + } + return bytes_read; +} diff --git a/libc-bottom-half/cloudlibc/src/libc/unistd/readlinkat.c b/libc-bottom-half/cloudlibc/src/libc/unistd/readlinkat.c new file mode 100644 index 0000000..7a3bce2 --- /dev/null +++ b/libc-bottom-half/cloudlibc/src/libc/unistd/readlinkat.c @@ -0,0 +1,21 @@ +// Copyright (c) 2015-2016 Nuxi, https://nuxi.nl/ +// +// SPDX-License-Identifier: BSD-2-Clause + +#include <wasi/api.h> +#include <errno.h> +#include <string.h> +#include <unistd.h> + +ssize_t __wasilibc_nocwd_readlinkat(int fd, const char *restrict path, char *restrict buf, + size_t bufsize) { + size_t bufused; + // TODO: Remove the cast on `buf` once the witx is updated with char8 support. + __wasi_errno_t error = __wasi_path_readlink(fd, path, + (uint8_t*)buf, bufsize, &bufused); + if (error != 0) { + errno = error; + return -1; + } + return bufused; +} diff --git a/libc-bottom-half/cloudlibc/src/libc/unistd/sleep.c b/libc-bottom-half/cloudlibc/src/libc/unistd/sleep.c new file mode 100644 index 0000000..970287b --- /dev/null +++ b/libc-bottom-half/cloudlibc/src/libc/unistd/sleep.c @@ -0,0 +1,13 @@ +// Copyright (c) 2015 Nuxi, https://nuxi.nl/ +// +// SPDX-License-Identifier: BSD-2-Clause + +#include <time.h> +#include <unistd.h> + +unsigned int sleep(unsigned int seconds) { + struct timespec ts = {.tv_sec = seconds, .tv_nsec = 0}; + if (clock_nanosleep(CLOCK_REALTIME, 0, &ts, NULL) != 0) + return seconds; + return 0; +} diff --git a/libc-bottom-half/cloudlibc/src/libc/unistd/symlinkat.c b/libc-bottom-half/cloudlibc/src/libc/unistd/symlinkat.c new file mode 100644 index 0000000..0aa38be --- /dev/null +++ b/libc-bottom-half/cloudlibc/src/libc/unistd/symlinkat.c @@ -0,0 +1,17 @@ +// Copyright (c) 2015-2016 Nuxi, https://nuxi.nl/ +// +// SPDX-License-Identifier: BSD-2-Clause + +#include <wasi/api.h> +#include <errno.h> +#include <string.h> +#include <unistd.h> + +int __wasilibc_nocwd_symlinkat(const char *path1, int fd, const char *path2) { + __wasi_errno_t error = __wasi_path_symlink(path1, fd, path2); + if (error != 0) { + errno = error; + return -1; + } + return 0; +} diff --git a/libc-bottom-half/cloudlibc/src/libc/unistd/unlinkat.c b/libc-bottom-half/cloudlibc/src/libc/unistd/unlinkat.c new file mode 100644 index 0000000..351bf92 --- /dev/null +++ b/libc-bottom-half/cloudlibc/src/libc/unistd/unlinkat.c @@ -0,0 +1,17 @@ +// Copyright (c) 2015-2016 Nuxi, https://nuxi.nl/ +// +// SPDX-License-Identifier: BSD-2-Clause + +#include <wasi/api.h> +#include <wasi/libc.h> +#include <errno.h> +#include <fcntl.h> +#include <string.h> +#include <unistd.h> + +int unlinkat(int fd, const char *path, int flag) { + if ((flag & AT_REMOVEDIR) != 0) { + return __wasilibc_rmdirat(fd, path); + } + return __wasilibc_unlinkat(fd, path); +} diff --git a/libc-bottom-half/cloudlibc/src/libc/unistd/usleep.c b/libc-bottom-half/cloudlibc/src/libc/unistd/usleep.c new file mode 100644 index 0000000..8005f17 --- /dev/null +++ b/libc-bottom-half/cloudlibc/src/libc/unistd/usleep.c @@ -0,0 +1,18 @@ +// Copyright (c) 2016 Nuxi, https://nuxi.nl/ +// +// SPDX-License-Identifier: BSD-2-Clause + +#include <errno.h> +#include <time.h> +#include <unistd.h> + +int usleep(useconds_t useconds) { + struct timespec ts = {.tv_sec = useconds / 1000000, + .tv_nsec = useconds % 1000000 * 1000}; + int error = clock_nanosleep(CLOCK_REALTIME, 0, &ts, NULL); + if (error != 0) { + errno = error; + return -1; + } + return 0; +} diff --git a/libc-bottom-half/cloudlibc/src/libc/unistd/write.c b/libc-bottom-half/cloudlibc/src/libc/unistd/write.c new file mode 100644 index 0000000..a6567e8 --- /dev/null +++ b/libc-bottom-half/cloudlibc/src/libc/unistd/write.c @@ -0,0 +1,19 @@ +// Copyright (c) 2015-2016 Nuxi, https://nuxi.nl/ +// +// SPDX-License-Identifier: BSD-2-Clause + +#include <wasi/api.h> +#include <errno.h> +#include <unistd.h> + +ssize_t write(int fildes, const void *buf, size_t nbyte) { + __wasi_ciovec_t iov = {.buf = buf, .buf_len = nbyte}; + size_t bytes_written; + __wasi_errno_t error = + __wasi_fd_write(fildes, &iov, 1, &bytes_written); + if (error != 0) { + errno = error == ENOTCAPABLE ? EBADF : error; + return -1; + } + return bytes_written; +} |