void oo_os_sock_release(ci_netif* ni, oo_os_file fd)
{
int rc = ci_sys_close(fd);
oo_rwlock_unlock_read(&citp_dup2_lock);
if( rc != 0 )
LOG_E(ci_log("%s: [%d] ci_sys_close returned %d (errno=%d)",
__FUNCTION__, NI_ID(ni), rc, errno));
}
static void citp_setup_logging_change(void *new_log_fn)
{
if( ci_log_fn != new_log_fn && citp.log_fd >= 0) {
ci_sys_close(citp.log_fd);
citp.log_fd = -1;
}
ci_log_fn = new_log_fn;
}
static void citp_log_to_file(const char *s)
{
int fd;
ci_assert(!CITP_OPTS.log_via_ioctl);
fd = open(s, O_WRONLY | O_CREAT | O_TRUNC, S_IREAD | S_IWRITE);
if( fd >= 0 ) {
if( citp.log_fd >= 0 )
ci_sys_close(citp.log_fd);
citp.log_fd = fd;
}
}
/* Please do not add any logging here (else citp_log_fn() could recurse) */
ci_inline int oo_open(ci_fd_t* out, enum oo_device_type dev_type, int flags) {
ci_fd_t fp = ci_sys_open(oo_device_name[dev_type], O_RDWR | flags);
int rc;
if( fp < 0 ) return -errno;
if( dev_type == OO_STACK_DEV ) {
rc = oo_version_check_ul(fp);
if( rc < 0 ) {
ci_sys_close(fp);
return rc;
}
}
*out = fp;
return 0;
}
dev_t oo_onloadfs_dev_t(void)
{
static ci_uint32 onloadfs_dev_t = 0;
if( onloadfs_dev_t == 0 ) {
int fd;
if( ef_onload_driver_open(&fd, OO_STACK_DEV, 1) != 0 ) {
fprintf(stderr, "%s: Failed to open /dev/onload\n", __FUNCTION__);
return 0;
}
if( ci_sys_ioctl(fd, OO_IOC_GET_ONLOADFS_DEV, &onloadfs_dev_t) != 0 ) {
LOG_E(ci_log("%s: Failed to find onloadfs dev_t", __FUNCTION__));
}
ci_sys_close(fd);
}
return onloadfs_dev_t;
}
void citp_log_change_fd(void)
{
int newfd, prev;
/* We need to change logging fd, probably because someone wants to do a
** dup2() onto it.
**
** No need to set 'close-on-exec' (FD_CLOEXEC) again for the newfd as
** it will be copied by the dup().
*/
CITP_FDTABLE_LOCK();
prev = citp.log_fd;
newfd = oo_fcntl_dupfd_cloexec(prev, 3);
if( newfd >= 0 ) {
__citp_fdtable_reserve(newfd, 1);
citp.log_fd = newfd;
}
Log_S(log("%s: old=%d new=%d", __FUNCTION__, prev, newfd));
__citp_fdtable_reserve(prev, 0);
ci_sys_close(prev);
CITP_FDTABLE_UNLOCK();
}
int citp_ep_close(unsigned fd)
{
volatile citp_fdinfo_p* p_fdip;
citp_fdinfo_p fdip;
int rc, got_lock;
citp_fdinfo* fdi;
/* Do not touch shared fdtable when in vfork child. */
if( oo_per_thread_get()->in_vfork_child )
return ci_tcp_helper_close_no_trampoline(fd);
/* Interlock against other closes, against the fdtable being extended,
** and against select and poll.
*/
CITP_FDTABLE_LOCK();
got_lock = 1;
__citp_fdtable_extend(fd);
if( fd >= citp_fdtable.inited_count ) {
rc = ci_sys_close(fd);
goto done;
}
p_fdip = &citp_fdtable.table[fd].fdip;
again:
fdip = *p_fdip;
if( fdip_is_busy(fdip) ) fdip = citp_fdtable_busy_wait(fd, 1);
if( fdip_is_closing(fdip) | fdip_is_reserved(fdip) ) {
/* Concurrent close or attempt to close reserved. */
Log_V(ci_log("%s: fd=%d closing=%d reserved=%d", __FUNCTION__, fd,
fdip_is_closing(fdip), fdip_is_reserved(fdip)));
errno = EBADF;
rc = -1;
goto done;
}
#if CI_CFG_FD_CACHING
/* Need to check in case this sucker's cached */
if( fdip_is_unknown(fdip) ) {
fdi = citp_fdtable_probe_locked(fd, CI_FALSE, CI_FALSE);
if( fdi == &citp_the_closed_fd ) {
citp_fdinfo_release_ref(fdi, CI_TRUE);
errno = EBADF;
rc = -1;
goto done;
}
if( fdi )
citp_fdinfo_release_ref(fdi, CI_TRUE);
}
#endif
ci_assert(fdip_is_normal(fdip) | fdip_is_passthru(fdip) |
fdip_is_unknown(fdip));
/* Swap in the "closed" pseudo-fdinfo. This lets any other thread know
** that we're in the middle of closing this fd.
*/
if( fdip_cas_fail(p_fdip, fdip, fdip_closing) )
goto again;
if( fdip_is_normal(fdip) ) {
fdi = fdip_to_fdi(fdip);
CITP_FDTABLE_UNLOCK();
got_lock = 0;
if( fdi->is_special ) {
Log_V(ci_log("%s: fd=%d is_special, returning EBADF", __FUNCTION__, fd));
errno = EBADF;
rc = -1;
fdtable_swap(fd, fdip_closing, fdip, 0);
goto done;
}
Log_V(ci_log("%s: fd=%d u/l socket", __FUNCTION__, fd));
ci_assert_equal(fdi->fd, fd);
ci_assert_equal(fdi->on_ref_count_zero, FDI_ON_RCZ_NONE);
fdi->on_ref_count_zero = FDI_ON_RCZ_CLOSE;
if( fdi->epoll_fd >= 0 ) {
citp_fdinfo* epoll_fdi = citp_epoll_fdi_from_member(fdi, 0);
if( epoll_fdi ) {
if( epoll_fdi->protocol->type == CITP_EPOLL_FD )
citp_epoll_on_close(epoll_fdi, fdi, 0);
citp_fdinfo_release_ref(epoll_fdi, 0);
}
}
citp_fdinfo_release_ref(fdi, 0);
rc = 0;
}
else {
ci_assert(fdip_is_passthru(fdip) ||
fdip_is_unknown(fdip));
if( ! fdtable_strict() ) {
CITP_FDTABLE_UNLOCK();
got_lock = 0;
}
Log_V(ci_log("%s: fd=%d passthru=%d unknown=%d", __FUNCTION__, fd,
fdip_is_passthru(fdip), fdip_is_unknown(fdip)));
fdtable_swap(fd, fdip_closing, fdip_unknown, fdtable_strict());
rc = ci_tcp_helper_close_no_trampoline(fd);
}
done:
if( got_lock ) CITP_FDTABLE_UNLOCK();
FDTABLE_ASSERT_VALID();
return rc;
}
int citp_epoll_create(int size, int flags)
{
citp_fdinfo *fdi;
citp_epoll_fdi *epi;
struct citp_epoll_fd* ep;
int fd;
if( (epi = CI_ALLOC_OBJ(citp_epoll_fdi)) == NULL )
goto fail0;
if( (ep = CI_ALLOC_OBJ(struct citp_epoll_fd)) == NULL )
goto fail1;
fdi = &epi->fdinfo;
citp_fdinfo_init(fdi, &citp_epoll_protocol_impl);
/* Create the epoll fd. */
CITP_FDTABLE_LOCK();
if( (fd = ci_sys_epoll_create_compat(size, flags, 0)) < 0 )
goto fail2;
citp_fdtable_new_fd_set(fd, fdip_busy, TRUE);
/* Init epfd_os */
#ifdef O_CLOEXEC
ep->epfd_os = ci_sys_open(OO_EPOLL_DEV, O_RDWR | O_CLOEXEC);
#else
ep->epfd_os = ci_sys_open(OO_EPOLL_DEV, O_RDWR);
if( ep->epfd_os >= 0 )
ci_sys_fcntl(ep->epfd_os, F_SETFD, FD_CLOEXEC);
#endif
if( ep->epfd_os < 0 ) {
Log_E(ci_log("%s: ERROR: failed to open(%s) errno=%d",
__FUNCTION__, OO_EPOLL_DEV, errno));
goto fail3;
}
__citp_fdtable_reserve(ep->epfd_os, 1);
ep->shared = mmap(NULL, sizeof(*ep->shared), PROT_READ, MAP_SHARED,
ep->epfd_os, 0);
if( ep->shared == MAP_FAILED ) {
Log_E(ci_log("%s: ERROR: failed to mmap shared segment errno=%d",
__FUNCTION__, errno));
goto fail4;
}
__citp_fdtable_reserve(ep->shared->epfd, 1);
CITP_FDTABLE_UNLOCK();
epi->epoll = ep;
ep->size = size;
oo_wqlock_init(&ep->lock);
ep->not_mt_safe = ! CITP_OPTS.ul_epoll_mt_safe;
ci_dllist_init(&ep->oo_sockets);
ep->oo_sockets_n = 0;
ci_dllist_init(&ep->dead_sockets);
oo_atomic_set(&ep->refcount, 1);
ep->epfd_syncs_needed = 0;
ep->blocking = 0;
citp_fdtable_insert(fdi, fd, 0);
Log_POLL(ci_log("%s: fd=%d driver_fd=%d epfd=%d", __FUNCTION__,
fd, ep->epfd_os, (int) ep->shared->epfd));
return fd;
fail4:
__citp_fdtable_reserve(ep->epfd_os, 0);
ci_sys_close(ep->epfd_os);
fail3:
ci_sys_close(fd);
citp_fdtable_busy_clear(fd, fdip_unknown, 1);
fail2:
CITP_FDTABLE_UNLOCK();
CI_FREE_OBJ(ep);
fail1:
CI_FREE_OBJ(epi);
fail0:
return -1;
}
