/* Called by the IPI handler after another CPU called smp_send_resched(). */
void sched_state_ipi(void)
{
/* If the IPI was slow, we might be in any state right now. The IPI is
* only meaningful if we are in SHOULD_SCHEDULE. */
if (is_in_sched_state(SHOULD_SCHEDULE)) {
/* Cause scheduler to be invoked.
* This will cause a transition to WILL_SCHEDULE. */
set_tsk_need_resched(current);
TRACE_STATE("IPI -> set_tsk_need_resched(%s/%d)\n",
current->comm, current->pid);
} else {
/* ignore */
TRACE_STATE("ignoring IPI in state %x (%s)\n",
get_sched_state(),
sched_state_name(get_sched_state()));
}
}
void CBtmsConnect::EnterL()
{
TRACE_STATE(_L("[BTMAC State] Connect"))
*StateRequest() = KRequestPending;
iSearchState = KSearchHandsfreeChannel;
TInt err = iBteng->RemoteProtocolChannelQuery(iSockAddr.BTAddr(), EBTProfileHFP);
if(err)
{
CompleteStateRequest(err);
}
}
// -----------------------------------------------------------------------------
// CBtsacListening::EnterL
// -----------------------------------------------------------------------------
//
void CBtsacListening::EnterL()
{
TRACE_STATE(_L("[BTSAC State] Listening"))
_LIT(KName, "CBtsacStateListening");
const TDesC& Name = KName;
Parent().iGavdp->RegisterObserver(this, Name);
Parent().ResetRemoteCache();
Parent().CleanSockets();
// RGavdp.Close (which is called from ResetGavdp method) should not be called from
// within a client's implementation of any MGavdpUser (upcall) method. Do self
// complete first then call ResetGavdp.
// Need for self completion is gavdp user up calls but we will do self complete every time
// when we enter into listening state.
DoSelfComplete(KErrNone);
}
/* Called by plugins to cause a CPU to reschedule. IMPORTANT: the caller must
* hold the lock that is used to serialize scheduling decisions. */
void litmus_reschedule(int cpu)
{
int picked_transition_ok = 0;
int scheduled_transition_ok = 0;
/* The (remote) CPU could be in any state. */
/* The critical states are TASK_PICKED and TASK_SCHEDULED, as the CPU
* is not aware of the need to reschedule at this point. */
/* is a context switch in progress? */
if (cpu_is_in_sched_state(cpu, TASK_PICKED))
picked_transition_ok = sched_state_transition_on(
cpu, TASK_PICKED, PICKED_WRONG_TASK);
if (!picked_transition_ok &&
cpu_is_in_sched_state(cpu, TASK_SCHEDULED)) {
/* We either raced with the end of the context switch, or the
* CPU was in TASK_SCHEDULED anyway. */
scheduled_transition_ok = sched_state_transition_on(
cpu, TASK_SCHEDULED, SHOULD_SCHEDULE);
}
/* If the CPU was in state TASK_SCHEDULED, then we need to cause the
* scheduler to be invoked. */
if (scheduled_transition_ok) {
if (smp_processor_id() == cpu)
set_tsk_need_resched(current);
else
smp_send_reschedule(cpu);
}
TRACE_STATE("%s picked-ok:%d sched-ok:%d\n",
__FUNCTION__,
picked_transition_ok,
scheduled_transition_ok);
}
/*----------------------------------------------------------------------------*/
int
mtcp_connect(mctx_t mctx, int sockid,
const struct sockaddr *addr, socklen_t addrlen)
{
mtcp_manager_t mtcp;
socket_map_t socket;
tcp_stream *cur_stream;
struct sockaddr_in *addr_in;
in_addr_t dip;
in_port_t dport;
int is_dyn_bound = FALSE;
int ret;
mtcp = GetMTCPManager(mctx);
if (!mtcp) {
return -1;
}
if (sockid < 0 || sockid >= CONFIG.max_concurrency) {
TRACE_API("Socket id %d out of range.\n", sockid);
errno = EBADF;
return -1;
}
if (mtcp->smap[sockid].socktype == MTCP_SOCK_UNUSED) {
TRACE_API("Invalid socket id: %d\n", sockid);
errno = EBADF;
return -1;
}
if (mtcp->smap[sockid].socktype != MTCP_SOCK_STREAM) {
TRACE_API("Not an end socket. id: %d\n", sockid);
errno = ENOTSOCK;
return -1;
}
if (!addr) {
TRACE_API("Socket %d: empty address!\n", sockid);
errno = EFAULT;
return -1;
}
/* we only allow bind() for AF_INET address */
if (addr->sa_family != AF_INET || addrlen < sizeof(struct sockaddr_in)) {
TRACE_API("Socket %d: invalid argument!\n", sockid);
errno = EAFNOSUPPORT;
return -1;
}
socket = &mtcp->smap[sockid];
if (socket->stream) {
TRACE_API("Socket %d: stream already exist!\n", sockid);
if (socket->stream->state >= TCP_ST_ESTABLISHED) {
errno = EISCONN;
} else {
errno = EALREADY;
}
return -1;
}
addr_in = (struct sockaddr_in *)addr;
dip = addr_in->sin_addr.s_addr;
dport = addr_in->sin_port;
/* address binding */
if ((socket->opts & MTCP_ADDR_BIND) &&
socket->saddr.sin_port != INPORT_ANY &&
socket->saddr.sin_addr.s_addr != INADDR_ANY) {
int rss_core;
uint8_t endian_check = (current_iomodule_func == &dpdk_module_func) ?
0 : 1;
rss_core = GetRSSCPUCore(socket->saddr.sin_addr.s_addr, dip,
socket->saddr.sin_port, dport, num_queues, endian_check);
if (rss_core != mctx->cpu) {
errno = EINVAL;
return -1;
}
} else {
if (mtcp->ap) {
ret = FetchAddress(mtcp->ap,
mctx->cpu, num_queues, addr_in, &socket->saddr);
} else {
ret = FetchAddress(ap,
mctx->cpu, num_queues, addr_in, &socket->saddr);
}
if (ret < 0) {
errno = EAGAIN;
return -1;
}
socket->opts |= MTCP_ADDR_BIND;
is_dyn_bound = TRUE;
}
cur_stream = CreateTCPStream(mtcp, socket, socket->socktype,
socket->saddr.sin_addr.s_addr, socket->saddr.sin_port, dip, dport);
if (!cur_stream) {
TRACE_ERROR("Socket %d: failed to create tcp_stream!\n", sockid);
errno = ENOMEM;
return -1;
}
if (is_dyn_bound)
cur_stream->is_bound_addr = TRUE;
cur_stream->sndvar->cwnd = 1;
cur_stream->sndvar->ssthresh = cur_stream->sndvar->mss * 10;
cur_stream->state = TCP_ST_SYN_SENT;
TRACE_STATE("Stream %d: TCP_ST_SYN_SENT\n", cur_stream->id);
SQ_LOCK(&mtcp->ctx->connect_lock);
ret = StreamEnqueue(mtcp->connectq, cur_stream);
SQ_UNLOCK(&mtcp->ctx->connect_lock);
mtcp->wakeup_flag = TRUE;
if (ret < 0) {
TRACE_ERROR("Socket %d: failed to enqueue to conenct queue!\n", sockid);
SQ_LOCK(&mtcp->ctx->destroyq_lock);
StreamEnqueue(mtcp->destroyq, cur_stream);
SQ_UNLOCK(&mtcp->ctx->destroyq_lock);
errno = EAGAIN;
return -1;
}
/* if nonblocking socket, return EINPROGRESS */
if (socket->opts & MTCP_NONBLOCK) {
errno = EINPROGRESS;
return -1;
} else {
while (1) {
if (!cur_stream) {
TRACE_ERROR("STREAM DESTROYED\n");
errno = ETIMEDOUT;
return -1;
}
if (cur_stream->state > TCP_ST_ESTABLISHED) {
TRACE_ERROR("Socket %d: weird state %s\n",
sockid, TCPStateToString(cur_stream));
// TODO: how to handle this?
errno = ENOSYS;
return -1;
}
if (cur_stream->state == TCP_ST_ESTABLISHED) {
break;
}
usleep(1000);
}
}
return 0;
}
