fdtable.h

Go to the documentation of this file.

/*
 * Copyright (c) 2018 Linaro Limited
 * Copyright (c) 2025 Antmicro
 *
 * SPDX-License-Identifier: Apache-2.0
 */
#ifndef ZEPHYR_INCLUDE_SYS_FDTABLE_H_
#define ZEPHYR_INCLUDE_SYS_FDTABLE_H_
 
#include <stdarg.h>
#include <time.h>
 
/* FIXME: For native_posix ssize_t, off_t. */
#include <sys/types.h>
#include <zephyr/kernel.h>
#include <zephyr/sys/util.h>
 
#ifdef CONFIG_PICOLIBC
#define ZVFS_O_APPEND 0x0400
#define ZVFS_O_CREAT  0x0040
#define ZVFS_O_TRUNC  0x0200
#else
#define ZVFS_O_APPEND 0x0008
#define ZVFS_O_CREAT  0x0200
#define ZVFS_O_TRUNC  0x0400
#endif
 
#define ZVFS_O_RDONLY 00
#define ZVFS_O_WRONLY 01
#define ZVFS_O_RDWR   02
 
#define ZVFS_O_EXCL     0x0800
#define ZVFS_O_NONBLOCK 0x4000
 
#define ZVFS_F_DUPFD 0
#define ZVFS_F_GETFL 3
#define ZVFS_F_SETFL 4
 
/* File mode bits */
#define ZVFS_MODE_IFMT   0170000
#define ZVFS_MODE_UNSPEC 0000000
#define ZVFS_MODE_IFIFO  0010000
#define ZVFS_MODE_IFCHR  0020000
#define ZVFS_MODE_IMSGQ  0030000
#define ZVFS_MODE_IFDIR  0040000
#define ZVFS_MODE_IFSEM  0050000
#define ZVFS_MODE_IFBLK  0060000
#define ZVFS_MODE_IFSHM  0070000
#define ZVFS_MODE_IFREG  0100000
#define ZVFS_MODE_IFLNK  0120000
#define ZVFS_MODE_IFSOCK 0140000
 
#define ZVFS_POLLIN   BIT(0)
#define ZVFS_POLLPRI  BIT(1)
#define ZVFS_POLLOUT  BIT(2)
#define ZVFS_POLLERR  BIT(3)
#define ZVFS_POLLHUP  BIT(4)
#define ZVFS_POLLNVAL BIT(5)
 
/* FIXME: use k_off_t and k_ssize_t to avoid the POSIX->Zephyr->POSIX dependency cycle */
#ifdef CONFIG_NEWLIB_LIBC
#ifndef _OFF_T_DECLARED
typedef __off_t off_t;
#define _OFF_T_DECLARED
#endif
#ifndef _SSIZE_T_DECLARED
typedef _ssize_t ssize_t;
#define _SSIZE_T_DECLARED
#endif
#endif
 
#include <zephyr/fs/fs.h>
 
#ifdef __cplusplus
extern "C" {
#endif

struct fd_op_vtable {
        union {
                ssize_t (*read)(void *obj, void *buf, size_t sz);
                ssize_t (*read_offs)(void *obj, void *buf, size_t sz, size_t offset);
        };
        union {
                ssize_t (*write)(void *obj, const void *buf, size_t sz);
                ssize_t (*write_offs)(void *obj, const void *buf, size_t sz, size_t offset);
        };
        union {
                int (*close)(void *obj);
                int (*close2)(void *obj, int fd);
        };
        int (*ioctl)(void *obj, unsigned int request, va_list args);
};

int zvfs_reserve_fd(void);

void zvfs_finalize_typed_fd(int fd, void *obj, const struct fd_op_vtable *vtable, uint32_t mode);

static inline void zvfs_finalize_fd(int fd, void *obj, const struct fd_op_vtable *vtable)
{
        zvfs_finalize_typed_fd(fd, obj, vtable, ZVFS_MODE_UNSPEC);
}

int zvfs_alloc_fd(void *obj, const struct fd_op_vtable *vtable);

void zvfs_free_fd(int fd);

void *zvfs_get_fd_obj(int fd, const struct fd_op_vtable *vtable, int err);

void *zvfs_get_fd_obj_and_vtable(int fd, const struct fd_op_vtable **vtable,
                              struct k_mutex **lock);

bool zvfs_get_obj_lock_and_cond(void *obj, const struct fd_op_vtable *vtable, struct k_mutex **lock,
                             struct k_condvar **cond);

static inline int zvfs_fdtable_call_ioctl(const struct fd_op_vtable *vtable, void *obj,
                                       unsigned long request, ...)
{
        va_list args;
        int res;
 
        va_start(args, request);
        res = vtable->ioctl(obj, request, args);
        va_end(args);
 
        return res;
}

struct zvfs_stat {
        off_t size;
        uint32_t mode;
};
 
struct zvfs_pollfd {
        int fd;
        short events;
        short revents;
};
 
__syscall int zvfs_poll(struct zvfs_pollfd *fds, int nfds, int poll_timeout);
 
struct zvfs_fd_set {
        uint32_t bitset[DIV_ROUND_UP(ZVFS_OPEN_SIZE, 32)];
};

#define ZVFS_FD_SETSIZE (sizeof(((struct zvfs_fd_set *)0)->bitset) * 8)
 
void ZVFS_FD_CLR(int fd, struct zvfs_fd_set *fdset);
int ZVFS_FD_ISSET(int fd, struct zvfs_fd_set *fdset);
void ZVFS_FD_SET(int fd, struct zvfs_fd_set *fdset);
void ZVFS_FD_ZERO(struct zvfs_fd_set *fdset);
 
__syscall int zvfs_select(int nfds, struct zvfs_fd_set *ZRESTRICT readfds,
                          struct zvfs_fd_set *ZRESTRICT writefds,
                          struct zvfs_fd_set *ZRESTRICT errorfds,
                          const struct timespec *ZRESTRICT timeout, const void *ZRESTRICT sigmask);

enum {
        /* Codes below 0x100 are reserved for fcntl() codes. */
        ZFD_IOCTL_FSYNC = 0x100,
        ZFD_IOCTL_LSEEK,
        ZFD_IOCTL_POLL_PREPARE,
        ZFD_IOCTL_POLL_UPDATE,
        ZFD_IOCTL_POLL_OFFLOAD,
        ZFD_IOCTL_SET_LOCK,
        ZFD_IOCTL_STAT,
        ZFD_IOCTL_TRUNCATE,
        ZFD_IOCTL_MMAP,
 
        /* Codes above 0x5400 and below 0x5500 are reserved for termios, FIO, etc */
        ZFD_IOCTL_FIONREAD = 0x541B,
        ZFD_IOCTL_FIONBIO = 0x5421,
};

int zvfs_open(const char *name, int flags, struct fd_op_vtable *vtable);

int zvfs_fstat(int fd, struct zvfs_stat *buf);

int zvfs_close(int fd);

ssize_t zvfs_read(int fd, void *buf, size_t sz, const size_t *from_offset);

ssize_t zvfs_write(int fd, const void *buf, size_t sz, const size_t *from_offset);
 
#ifdef CONFIG_ZVFS_DEFAULT_FILE_VMETHODS
int zvfs_ioctl_vmeth(void *obj, unsigned int request, va_list args);
int zvfs_close_vmeth(void *obj);
ssize_t zvfs_write_vmeth(void *obj, const void *buffer, size_t count);
ssize_t zvfs_read_vmeth(void *obj, void *buffer, size_t count);
#endif

int zvfs_unlink(const char *path);

int zvfs_rename(const char *old, const char *newp);
 
#ifdef __cplusplus
}
#endif
 
#include <zephyr/syscalls/fdtable.h>
 
#endif /* ZEPHYR_INCLUDE_SYS_FDTABLE_H_ */