xlio.h

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES
 * Copyright (c) 2024-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 * SPDX-License-Identifier: GPL-2.0-only or BSD-2-Clause
 */
 
#ifndef XLIO_H
#define XLIO_H
 
#include <fcntl.h>
#include <poll.h>
#include <sched.h>
#include <signal.h>
#include <stdint.h>
#include <sys/epoll.h>
#include <sys/stat.h>
#include <sys/time.h>
 
#include "xlio_types.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
int xlio_socket(int __domain, int __type, int __protocol);
 
int xlio_close(int __fd);
 
int xlio_shutdown(int __fd, int __how);
 
int xlio_listen(int __fd, int backlog);
 
int xlio_accept(int __fd, struct sockaddr *__addr, socklen_t *__addrlen);
 
int xlio_accept4(int __fd, struct sockaddr *__addr, socklen_t *__addrlen, int __flags);
 
int xlio_bind(int __fd, const struct sockaddr *__addr, socklen_t __addrlen);
 
int xlio_connect(int __fd, const struct sockaddr *__to, socklen_t __tolen);
 
int xlio_setsockopt(int __fd, int __level, int __optname, __const void *__optval,
                    socklen_t __optlen);
 
int xlio_getsockopt(int __fd, int __level, int __optname, void *__optval, socklen_t *__optlen);
 
int xlio_fcntl(int __fd, int __cmd, ...);
 
int xlio_fcntl64(int __fd, int __cmd, ...);
 
int xlio_getsockname(int __fd, struct sockaddr *__name, socklen_t *__namelen);
 
int xlio_getpeername(int __fd, struct sockaddr *__name, socklen_t *__namelen);
 
ssize_t xlio_read(int __fd, void *__buf, size_t __nbytes);
 
ssize_t xlio_readv(int __fd, const struct iovec *iov, int iovcnt);
 
ssize_t xlio_recv(int __fd, void *__buf, size_t __nbytes, int __flags);
 
ssize_t xlio_recvmsg(int __fd, struct msghdr *__msg, int __flags);
 
struct mmsghdr;
 
int xlio_recvmmsg(int __fd, struct mmsghdr *__mmsghdr, unsigned int __vlen, int __flags,
                  const struct timespec *__timeout);
 
ssize_t xlio_recvfrom(int __fd, void *__buf, size_t __nbytes, int __flags, struct sockaddr *__from,
                      socklen_t *__fromlen);
 
ssize_t xlio_write(int __fd, __const void *__buf, size_t __nbytes);
 
ssize_t xlio_writev(int __fd, const struct iovec *iov, int iovcnt);
 
ssize_t xlio_send(int __fd, __const void *__buf, size_t __nbytes, int __flags);
 
ssize_t xlio_sendmsg(int __fd, __const struct msghdr *__msg, int __flags);
 
int xlio_sendmmsg(int __fd, struct mmsghdr *__mmsghdr, unsigned int __vlen, int __flags);
 
ssize_t xlio_sendto(int __fd, __const void *__buf, size_t __nbytes, int __flags,
                    const struct sockaddr *__to, socklen_t __tolen);
 
ssize_t xlio_sendfile(int out_fd, int in_fd, off_t *offset, size_t count);
 
ssize_t xlio_sendfile64(int out_fd, int in_fd, __off64_t *offset, size_t count);
 
int xlio_select(int __nfds, fd_set *__readfds, fd_set *__writefds, fd_set *__exceptfds,
                struct timeval *__timeout);
 
int xlio_pselect(int __nfds, fd_set *__readfds, fd_set *__writefds, fd_set *__errorfds,
                 const struct timespec *__timeout, const sigset_t *__sigmask);
int xlio_poll(struct pollfd *__fds, nfds_t __nfds, int __timeout);
 
int xlio_ppoll(struct pollfd *__fds, nfds_t __nfds, const struct timespec *__timeout,
               const sigset_t *__sigmask);
 
int xlio_epoll_create(int __size);
 
int xlio_epoll_create1(int __flags);
 
int xlio_epoll_ctl(int __epfd, int __op, int __fd, struct epoll_event *__event);
 
int xlio_epoll_wait(int __epfd, struct epoll_event *__events, int __maxevents, int __timeout);
 
int xlio_epoll_pwait(int __epfd, struct epoll_event *__events, int __maxevents, int __timeout,
                     const sigset_t *__sigmask);
int xlio_socketpair(int __domain, int __type, int __protocol, int __sv[2]);
 
int xlio_pipe(int __filedes[2]);
 
int xlio_open(__const char *__file, int __oflag, ...);
 
int xlio_creat(const char *__pathname, mode_t __mode);
 
int xlio_dup(int __fd);
 
int xlio_dup2(int __fd, int __fd2);
 
/*
 * Add a libxlio.conf rule to the top of the list.
 * This rule will not apply to existing sockets which already considered the conf rules.
 * (around connect/listen/send/recv ..)
 * @param config_line A char buffer with the exact format as defined in libxlio.conf, and should
 * end with '\0'.
 * @return 0 on success, or error code on failure.
 */
int xlio_add_conf_rule(const char *config_line);
 
/*
 * Create sockets on pthread tid as offloaded/not-offloaded.
 * This does not affect existing sockets.
 * Offloaded sockets are still subject to libxlio.conf rules.
 * @param offload 1 for offloaded, 0 for not-offloaded.
 * @return 0 on success, or error code on failure.
 */
int xlio_thread_offload(int offload, pthread_t tid);
 
/*
 * Dump fd statistics using the library logger.
 * @param fd to dump, 0 for all open fds.
 * @param log_level dumping level corresponding vlog_levels_t enum (vlogger.h).
 * @return 0 on success, or error code on failure.
 */
int xlio_dump_fd_stats(int fd, int log_level);
 
/*
 * Register a received packet notification callback.
 *
 * @param s Socket file descriptor.
 * @param callback Callback function.
 * @param context user contex for callback function.
 * @return 0 - success, -1 - error
 *
 * errno is set to: EINVAL - not offloaded socket
 */
int xlio_register_recv_callback(int s, xlio_recv_callback_t callback, void *context);
 
/* Forward declaration. */
struct ibv_pd;
 
int xlio_init_ex(const struct xlio_init_attr *attr);
 
int xlio_init(void);
 
int xlio_exit(void);
 // end of xlio_init group
 
int xlio_poll_group_create(const struct xlio_poll_group_attr *attr, xlio_poll_group_t *group_out);
 
int xlio_poll_group_destroy(xlio_poll_group_t group);
 
int xlio_poll_group_update(xlio_poll_group_t group, const struct xlio_poll_group_attr *attr);
 
void xlio_poll_group_poll(xlio_poll_group_t group);
 // end of xlio_poll_group group
 
int xlio_socket_create(const struct xlio_socket_attr *attr, xlio_socket_t *sock_out);
 
int xlio_socket_destroy(xlio_socket_t sock);
 
int xlio_socket_update(xlio_socket_t sock, unsigned flags, uintptr_t userdata_sq);
 
int xlio_socket_setsockopt(xlio_socket_t sock, int level, int optname, const void *optval,
                           socklen_t optlen);
 
int xlio_socket_getsockname(xlio_socket_t sock, struct sockaddr *addr, socklen_t *addrlen);
 
int xlio_socket_getpeername(xlio_socket_t sock, struct sockaddr *addr, socklen_t *addrlen);
 
int xlio_socket_bind(xlio_socket_t sock, const struct sockaddr *addr, socklen_t addrlen);
 
int xlio_socket_connect(xlio_socket_t sock, const struct sockaddr *to, socklen_t tolen);
 
int xlio_socket_listen(xlio_socket_t sock);
 
struct ibv_pd *xlio_socket_get_pd(xlio_socket_t sock);
 
int xlio_socket_detach_group(xlio_socket_t sock);
 
int xlio_socket_attach_group(xlio_socket_t sock, xlio_poll_group_t group);
 // end of xlio_socket group
 
int xlio_socket_send(xlio_socket_t sock, const void *data, size_t len,
                     const struct xlio_socket_send_attr *attr);
 
int xlio_socket_sendv(xlio_socket_t sock, const struct iovec *iov, unsigned iovcnt,
                      const struct xlio_socket_send_attr *attr);
 
void xlio_poll_group_flush(xlio_poll_group_t group);
 
void xlio_socket_flush(xlio_socket_t sock);
 // end of xlio_tx group
 
void xlio_socket_buf_free(xlio_socket_t sock, struct xlio_buf *buf);
 
void xlio_poll_group_buf_free(xlio_poll_group_t group, struct xlio_buf *buf);
 // end of xlio_rx group
 // end of xlio_ultra_api group
 
#ifdef __cplusplus
}
#endif
#endif /* XLIO_H */