static void citp_fdinfo_do_handover(citp_fdinfo* fdi, int fdt_locked)
{
int rc;
citp_fdinfo* epoll_fdi = NULL;
int os_fd = fdi->fd;
#ifndef NDEBUG
/* Yuk: does for UDP too. */
volatile citp_fdinfo_p* p_fdip;
p_fdip = &citp_fdtable.table[fdi->fd].fdip;
ci_assert(fdip_is_busy(*p_fdip));
#endif
Log_V(ci_log("%s: fd=%d nonb_switch=%d", __FUNCTION__, fdi->fd,
fdi->on_rcz.handover_nonb_switch));
if( fdi->epoll_fd >= 0 ) {
epoll_fdi = citp_epoll_fdi_from_member(fdi, fdt_locked);
if( epoll_fdi->protocol->type == CITP_EPOLLB_FD )
citp_epollb_on_handover(epoll_fdi, fdi);
}
rc = fdtable_fd_move(fdi->fd, OO_IOC_TCP_HANDOVER);
if( rc == -EBUSY && fdi->epoll_fd >= 0 ) {
ci_assert(fdi_to_sock_fdi(fdi)->sock.s->b.sb_aflags &
CI_SB_AFLAG_MOVED_AWAY);
/* If this is our epoll, we can do full handover: we manually add os
* fd into the epoll set.
* Fixme: ensure we are not in _other_ epoll sets */
ci_bit_clear(&fdi_to_sock_fdi(fdi)->sock.s->b.sb_aflags,
CI_SB_AFLAG_MOVED_AWAY_IN_EPOLL_BIT);
rc = fdtable_fd_move(fdi->fd, OO_IOC_FILE_MOVED);
}
if( rc != 0 ) {
citp_fdinfo* new_fdi;
if( ! fdt_locked ) CITP_FDTABLE_LOCK();
new_fdi = citp_fdtable_probe_locked(fdi->fd, CI_TRUE, CI_TRUE);
citp_fdinfo_release_ref(new_fdi, 1);
if( ! fdt_locked ) CITP_FDTABLE_UNLOCK();
ci_assert_equal(citp_fdinfo_get_type(new_fdi), CITP_PASSTHROUGH_FD);
os_fd = fdi_to_alien_fdi(new_fdi)->os_socket;
}
if( fdi->on_rcz.handover_nonb_switch >= 0 ) {
int on_off = !! fdi->on_rcz.handover_nonb_switch;
int rc = ci_sys_ioctl(os_fd, FIONBIO, &on_off);
if( rc < 0 )
Log_E(ci_log("%s: ioctl failed on_off=%d", __FUNCTION__, on_off));
}
if( rc != 0 )
goto exit;
citp_fdtable_busy_clear(fdi->fd, fdip_passthru, fdt_locked);
exit:
citp_fdinfo_get_ops(fdi)->dtor(fdi, fdt_locked);
if( epoll_fdi != NULL && epoll_fdi->protocol->type == CITP_EPOLL_FD )
citp_epoll_on_handover(epoll_fdi, fdi, fdt_locked);
if( epoll_fdi != NULL )
citp_fdinfo_release_ref(epoll_fdi, fdt_locked);
citp_fdinfo_free(fdi);
}
void citp_oo_get_cpu_khz(ci_uint32* cpu_khz)
{
ef_driver_handle fd;
/* set up a constant value for the case everything goes wrong */
*cpu_khz = 1000;
if( ef_onload_driver_open(&fd, OO_STACK_DEV, 1) != 0 ) {
fprintf(stderr, "%s: Failed to open /dev/onload\n", __FUNCTION__);
ci_get_cpu_khz(cpu_khz);
return;
}
if( ci_sys_ioctl(fd, OO_IOC_GET_CPU_KHZ, cpu_khz) != 0 ) {
Log_E(log("%s: Failed to query cpu_khz", __FUNCTION__));
ci_get_cpu_khz(cpu_khz);
}
ef_onload_driver_close(fd);
}
int citp_fdtable_ctor()
{
struct rlimit rlim;
int rc;
Log_S(log("%s:", __FUNCTION__));
/* How big should our fdtable be by default? It's pretty arbitrary, but we have
* seen a few apps that use setrlimit to set the fdtable to 4096 entries on
* start-up (see bugs 3253 and 3373), so we choose that. (Note: we can't grow
* the table if the app later does setrlimit, and unused entries consume virtual
* space only, so it's worth allocating a table of reasonable sized.)
*/
citp_fdtable.size = 4096;
if( getrlimit(RLIMIT_NOFILE, &rlim) == 0 ) {
citp_fdtable.size = rlim.rlim_max;
if( CITP_OPTS.fdtable_size != 0 &&
CITP_OPTS.fdtable_size != rlim.rlim_max ) {
Log_S(ci_log("Set the limits for the number of opened files "
"to EF_FDTABLE_SIZE=%u value.",
CITP_OPTS.fdtable_size));
rlim.rlim_max = CITP_OPTS.fdtable_size;
if( rlim.rlim_cur > rlim.rlim_max )
rlim.rlim_cur = rlim.rlim_max;
if( ci_sys_setrlimit(RLIMIT_NOFILE, &rlim) == 0 )
citp_fdtable.size = rlim.rlim_max;
else {
/* Most probably, we've got EPERM */
ci_assert_lt(citp_fdtable.size, CITP_OPTS.fdtable_size);
ci_log("Can't set EF_FDTABLE_SIZE=%u; using %u",
CITP_OPTS.fdtable_size, citp_fdtable.size);
rlim.rlim_max = rlim.rlim_cur = citp_fdtable.size;
CI_TRY(ci_sys_setrlimit(RLIMIT_NOFILE, &rlim));
}
}
}
else
Log_S(ci_log("Assume EF_FDTABLE_SIZE=%u", citp_fdtable.size));
citp_fdtable.inited_count = 0;
citp_fdtable.table = ci_libc_malloc(sizeof (citp_fdtable_entry) *
citp_fdtable.size);
if( ! citp_fdtable.table ) {
Log_U(log("%s: failed to allocate fdtable (0x%x)", __FUNCTION__,
citp_fdtable.size));
return -1;
}
/* The whole table is not initialised at start-of-day, but is initialised
** on demand. citp_fdtable.inited_count counts the number of initialised
** entries.
*/
if( (rc = oo_rwlock_ctor(&citp_ul_lock)) != 0 ) {
Log_E(log("%s: oo_rwlock_ctor %d", __FUNCTION__, rc));
return -1;
}
/* Install SIGONLOAD handler */
{
struct sigaction sa;
memset(&sa, 0, sizeof(sa)); /* sa_flags and sa_mask = 0 */
sa.sa_handler = sighandler_do_nothing;
sigaction(SIGONLOAD, &sa, NULL);
}
return 0;
}
/* Find out what sort of thing [fd] is, and if it is a user-level socket
* then map in the user-level state.
*/
static citp_fdinfo * citp_fdtable_probe_locked(unsigned fd, int print_banner,
int fdip_is_already_busy)
{
citp_fdinfo* fdi = NULL;
struct stat64 st;
ci_ep_info_t info;
if( ! fdip_is_already_busy ) {
volatile citp_fdinfo_p* p_fdip;
citp_fdinfo_p fdip;
/* ?? We're repeating some effort already expended in lookup() here, but
** this keeps it cleaner. May optimise down the line when I understand
** what other code needs to call this.
*/
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_unknown(fdip) && ! fdip_is_normal(fdip) ) goto exit;
if( fdip_cas_fail(p_fdip, fdip, fdip_busy) ) goto again;
if( fdip_is_normal(fdip) ) {
fdi = fdip_to_fdi(fdip);
citp_fdinfo_ref(fdi);
citp_fdtable_busy_clear(fd, fdip, 1);
goto exit;
}
}
if( ci_sys_fstat64(fd, &st) != 0 ) {
/* fstat() failed. Must be a bad (closed) file descriptor, so
** leave this entry as unknown. Return citp_the_closed_fd to avoid the
** caller passing through to an fd that is created asynchronously.
*/
citp_fdtable_busy_clear(fd, fdip_unknown, 1);
fdi = &citp_the_closed_fd;
citp_fdinfo_ref(fdi);
goto exit;
}
/* oo_get_st_rdev() and oo_onloadfs_dev_t() open-and-close fd, so
* fdtable should be locked if strict mode requested. */
if( fdtable_strict() ) { CITP_FDTABLE_ASSERT_LOCKED(1); }
if( st.st_dev == oo_onloadfs_dev_t() ) {
/* Retrieve user-level endpoint info */
if( oo_ep_info(fd, &info) < 0 ) {
Log_V(log("%s: fd=%d type=%d unknown", __FUNCTION__,fd,info.fd_type));
citp_fdtable_busy_clear(fd, fdip_passthru, 1);
goto exit;
}
switch( info.fd_type ) {
case CI_PRIV_TYPE_TCP_EP:
case CI_PRIV_TYPE_UDP_EP:
case CI_PRIV_TYPE_PASSTHROUGH_EP:
case CI_PRIV_TYPE_ALIEN_EP:
#if CI_CFG_USERSPACE_PIPE
case CI_PRIV_TYPE_PIPE_READER:
case CI_PRIV_TYPE_PIPE_WRITER:
#endif
{
citp_fdinfo_p fdip;
Log_V(log("%s: fd=%d %s restore", __FUNCTION__, fd,
info.fd_type == CI_PRIV_TYPE_TCP_EP ? "TCP":
#if CI_CFG_USERSPACE_PIPE
info.fd_type != CI_PRIV_TYPE_UDP_EP ? "PIPE" :
#endif
"UDP"));
fdip = citp_fdtable_probe_restore(fd, &info, print_banner);
if( fdip_is_normal(fdip) )
fdi = fdip_to_fdi(fdip);
else
citp_fdtable_busy_clear(fd, fdip, 1);
goto exit;
}
case CI_PRIV_TYPE_NETIF:
/* This should never happen, because netif fds are close-on-exec.
** But let's leave this code here just in case my reasoning is bad.
*/
Log_U(log("%s: fd=%d NETIF reserved", __FUNCTION__, fd));
citp_fdtable_busy_clear(fd, fdip_reserved, 1);
fdi = &citp_the_reserved_fd;
citp_fdinfo_ref(fdi);
goto exit;
case CI_PRIV_TYPE_NONE:
/* This happens if a thread gets at an onload driver fd that has just
* been created, but not yet specialised. On Linux I think this
* means it will shortly be a new netif internal fd. (fds associated
* with sockets and pipes are never unspecialised).
*/
Log_V(log("%s: fd=%d TYPE_NONE", __FUNCTION__, fd));
citp_fdtable_busy_clear(fd, fdip_passthru, 1);
goto exit;
default:
CI_TEST(0);
break;
}
}
else if( ci_major(st.st_rdev) == ci_major(oo_get_st_rdev(OO_EPOLL_DEV)) ) {
citp_epollb_fdi *epi = CI_ALLOC_OBJ(citp_epollb_fdi);
if( ! epi ) {
Log_E(log("%s: out of memory (epoll_fdi)", __FUNCTION__));
citp_fdtable_busy_clear(fd, fdip_passthru, 1);
goto exit;
}
oo_epollb_ctor(epi);
fdi = &epi->fdinfo;
citp_fdinfo_init(fdi, &citp_epollb_protocol_impl);
citp_fdinfo_ref(fdi);
citp_fdtable_insert(fdi, fd, 1);
goto exit;
}
#ifndef NDEBUG
/* /dev/onload may be netif only; they are closed on fork or exec */
if( ci_major(st.st_rdev) == ci_major(oo_get_st_rdev(OO_STACK_DEV)) )
Log_U(log("%s: %d is /dev/onload", __FUNCTION__, fd));
#endif
/* Not one of ours, so pass-through. */
Log_V(log("%s: fd=%u non-efab", __FUNCTION__, fd));
citp_fdtable_busy_clear(fd, fdip_passthru, 1);
exit:
return fdi;
}
static citp_fdinfo_p
citp_fdtable_probe_restore(int fd, ci_ep_info_t * info, int print_banner)
{
citp_protocol_impl* proto = 0;
citp_fdinfo* fdi = 0;
ci_netif* ni;
int rc;
int c_sock_fdi = 1;
/* Must be holding the FD table writer lock */
CITP_FDTABLE_ASSERT_LOCKED(1);
ci_assert_nequal(info->resource_id, CI_ID_POOL_ID_NONE);
/* Will need to review this function if the following assert fires */
switch( info->fd_type ) {
case CI_PRIV_TYPE_TCP_EP: proto = &citp_tcp_protocol_impl; break;
case CI_PRIV_TYPE_UDP_EP: proto = &citp_udp_protocol_impl; break;
case CI_PRIV_TYPE_PASSTHROUGH_EP:
proto = &citp_passthrough_protocol_impl;
c_sock_fdi = 0;
break;
case CI_PRIV_TYPE_ALIEN_EP:
proto = NULL;
c_sock_fdi = 0;
break;
#if CI_CFG_USERSPACE_PIPE
case CI_PRIV_TYPE_PIPE_READER:
proto = &citp_pipe_read_protocol_impl;
c_sock_fdi = 0;
break;
case CI_PRIV_TYPE_PIPE_WRITER:
proto = &citp_pipe_write_protocol_impl;
c_sock_fdi = 0;
break;
#endif
default: ci_assert(0);
}
/* Attempt to find the user-level netif for this endpoint */
ni = citp_find_ul_netif(info->resource_id, 1);
if( ! ni ) {
ef_driver_handle netif_fd;
/* Not found, rebuild/restore the netif for this endpoint */
rc = citp_netif_recreate_probed(fd, &netif_fd, &ni);
if ( rc < 0 ) {
Log_E(log("%s: citp_netif_recreate_probed failed! (%d)",
__FUNCTION__, rc));
goto fail;
}
if( print_banner ) {
ci_log("Importing "ONLOAD_PRODUCT" "ONLOAD_VERSION" "ONLOAD_COPYRIGHT
" [%s]", ni->state->pretty_name);
}
}
else
citp_netif_add_ref(ni);
/* There is a race condition where the fd can have been created, but it has
* not yet been initialised, as we can't put a busy marker in the right place
* in the fdtable until we know what the fd is. In this case we don't want
* to probe this new info, so return the closed fd.
*/
if( SP_TO_WAITABLE(ni, info->sock_id)->sb_aflags & CI_SB_AFLAG_NOT_READY ) {
citp_fdtable_busy_clear(fd, fdip_unknown, 1);
fdi = &citp_the_closed_fd;
citp_fdinfo_ref(fdi);
return fdi_to_fdip(fdi);
}
if (c_sock_fdi) {
citp_sock_fdi* sock_fdi;
sock_fdi = CI_ALLOC_OBJ(citp_sock_fdi);
if( ! sock_fdi ) {
Log_E(log("%s: out of memory (sock_fdi)", __FUNCTION__));
goto fail;
}
fdi = &sock_fdi->fdinfo;
sock_fdi->sock.s = SP_TO_SOCK_CMN(ni, info->sock_id);
sock_fdi->sock.netif = ni;
}
else if( info->fd_type == CI_PRIV_TYPE_PASSTHROUGH_EP ) {
citp_waitable* w = SP_TO_WAITABLE(ni, info->sock_id);
citp_alien_fdi* alien_fdi;
if( ~w->sb_aflags & CI_SB_AFLAG_MOVED_AWAY_IN_EPOLL &&
fdtable_fd_move(fd, OO_IOC_FILE_MOVED) == 0 ) {
citp_netif_release_ref(ni, 1);
return fdip_passthru;
}
alien_fdi = CI_ALLOC_OBJ(citp_alien_fdi);
if( ! alien_fdi ) {
Log_E(log("%s: out of memory (alien_fdi)", __FUNCTION__));
goto fail;
}
fdi = &alien_fdi->fdinfo;
alien_fdi->netif = ni;
alien_fdi->ep = SP_TO_WAITABLE(ni, info->sock_id);
citp_passthrough_init(alien_fdi);
}
else if( info->fd_type == CI_PRIV_TYPE_ALIEN_EP ) {
citp_waitable* w = SP_TO_WAITABLE(ni, info->sock_id);
citp_sock_fdi* sock_fdi;
ci_netif* alien_ni;
sock_fdi = CI_ALLOC_OBJ(citp_sock_fdi);
if( ! sock_fdi ) {
Log_E(log("%s: out of memory (alien sock_fdi)", __FUNCTION__));
goto fail;
}
fdi = &sock_fdi->fdinfo;
rc = citp_netif_by_id(w->moved_to_stack_id, &alien_ni, 1);
if( rc != 0 ) {
goto fail;
}
sock_fdi->sock.s = SP_TO_SOCK_CMN(alien_ni, w->moved_to_sock_id);
sock_fdi->sock.netif = alien_ni;
citp_netif_release_ref(ni, 1);
/* Replace the file under this fd if possible */
if( ~w->sb_aflags & CI_SB_AFLAG_MOVED_AWAY_IN_EPOLL )
fdtable_fd_move(fd, OO_IOC_FILE_MOVED);
if( sock_fdi->sock.s->b.state & CI_TCP_STATE_TCP )
proto = &citp_tcp_protocol_impl;
else if( sock_fdi->sock.s->b.state == CI_TCP_STATE_UDP )
proto = &citp_udp_protocol_impl;
else {
CI_TEST(0);
}
}
#if CI_CFG_USERSPACE_PIPE
else {
citp_pipe_fdi* pipe_fdi;
pipe_fdi = CI_ALLOC_OBJ(citp_pipe_fdi);
if( ! pipe_fdi ) {
Log_E(log("%s: out of memory (pipe_fdi)", __FUNCTION__));
goto fail;
}
fdi = &pipe_fdi->fdinfo;
pipe_fdi->pipe = SP_TO_PIPE(ni, info->sock_id);
pipe_fdi->ni = ni;
}
#endif
citp_fdinfo_init(fdi, proto);
/* We're returning a reference to the caller. */
citp_fdinfo_ref(fdi);
citp_fdtable_insert(fdi, fd, 1);
return fdi_to_fdip(fdi);
fail:
if( ni ) citp_netif_release_ref(ni, 1);
return fdip_unknown;
}
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;
}
