void
dgramtesttrigger(
void)
{
PState *ps = (PState *)dgramtestprotocol->state;
if ( x_server ) {
xError("Starting server");
evDetach(evSchedule(evAlloc(dgramtestprotocol->path), server, dgramtestprotocol, 0));
} else
if ( x_client ) {
d_area_s.prod = 0;
d_area_s.cons = 0;
#if MACH_KERNEL
(void)kmem_alloc(kernel_map, (vm_offset_t *)&d_area_s.addr, DUMP_AREA_SIZE);
#else /* MACH_KERNEL */
d_area_s.addr = (char *)pathAlloc(dgramtestprotocol->path, DUMP_AREA_SIZE);
#endif /* MACH_KERNEL */
if (!d_area_s.addr) {
xError("dgramtest: couldn't allocate dump area\n");
pathFree(ps);
return;
}
xError("Starting client");
evDetach(evSchedule(evAlloc(dgramtestprotocol->path), client, dgramtestprotocol, 0));
}
else
printf("Pls. assert either x_client or x_server\n");
}
Event
initSessionCollector(
Map m,
int interval,
void (*destructor)(XObj s),
Path p,
char *msg)
{
CollectInfo *c;
Event ev;
xTrace2(sessngc, 3,
"session garbage collector initialized for map %x (%s)",
m, msg ? msg : "");
if ( ! (c = pathAlloc(p, sizeof(CollectInfo))) ) {
return 0;
}
if ( ! (ev = evAlloc(p)) ) {
pathFree(c);
return 0;
}
c->map = m;
c->interval = interval;
c->destroy = destructor;
c->msg = msg ? msg : "";
evSchedule( ev, sessnCollect, c, c->interval );
return ev;
}
/*
* See description in arp_table.h
*/
ArpTbl
arpTableInit( Path p )
{
ArpTbl tbl;
ArpEnt *e;
int i;
Event ev;
if ( ! (tbl = (ArpEnt **)pathAlloc(p, ARP_TAB * sizeof(ArpEnt *))) ) {
return 0;
}
for (i=0; i < ARP_TAB; i++) {
if ( ! (tbl[i] = pathAlloc(p, sizeof(ArpEnt))) ) {
freeTbl(tbl);
return 0;
}
bzero((char *)tbl[i], sizeof(ArpEnt));
tbl[i]->status = ARP_FREE;
}
if ( ! (ev = evAlloc(p)) ) {
xTrace0(arpp, TR_ERRORS, "arpTableInit couldn't allocate event");
freeTbl(tbl);
return 0;
}
evSchedule(ev, ageTimer, tbl, 0);
return tbl;
}
/*
* bidctlTimer -- scan through the list of bidctlStates:
*
* send keepalive messages to peers of idle states
*/
void
bidctlTimer(
Event ev,
void *arg)
{
PState *ps = (PState *)arg;
xTrace0(bidctlp, TR_EVENTS, "bidctl timer runs");
mapForEach(ps->bsMap, clockTick, ps->bsMap);
evSchedule(ev, bidctlTimer, arg, BIDCTL_TIMER_INTERVAL);
}
Event
scheduleIpFragCollector( PState *ps, Path p )
{
Event ev;
if ( ! (ev = evAlloc(p)) ) {
return 0;
}
evSchedule(ev, ipFragCollect, ps, IP_GC_INTERVAL);
return ev;
}
static void
sessnCollect(
Event ev,
void *arg)
{
CollectInfo *c = (CollectInfo *)arg;
xTrace1(sessngc, 3, "session garbage collector (%s)", c->msg);
mapForEach(c->map, markIdle, c);
evSchedule( ev, sessnCollect, c, c->interval );
xTrace1(sessngc, 5, "%s sessn GC exits", c->msg);
}
static int
sendSWP(SwpState *state, Msg *frame)
{
struct sendQ_slot *slot;
hbuf[HLEN];
//wait for send window to open
semWait(&state->sendWindowNotFull);
state->hdr.SeqNum = ++state->LFS;
slot = &state->sendQ[state->hdr.SeqNum % SWS];
store_swp_hdr(state->hdr, hbuf);
msgAddHdr(frame, hbuf, HLEN);
msgSaveCopy(&slot->msg, frame);
slot->timeout = evSchedule(swpTimeout, slot, SWP_SEND_TIMEOUT);
return send(LINK, frame);
}
int
tryPush( XObj self, XObj sessn, int times, int length )
{
xkern_return_t xkr;
int i;
Msg_s savedMsg, request;
int c = 0;
PState *ps = (PState *)self->state;
#if MACH_KERNEL
tvalspec_t time_val_before, time_val_after;
#endif /* MACH_KERNEL */
xkr = msgConstructContig(&savedMsg, self->path,
(u_int)length,
TEST_STACK_SIZE);
if (xkr == XK_FAILURE) {
sprintf(errBuf, "Could not construct a msg of length %d\n",
length + TEST_STACK_SIZE);
Kabort(errBuf);
}
msgConstructContig(&request, self->path, 0, 0);
semInit(&ps->sema, 0);
ps->flushing = FALSE;
ps->partialcount = times - 1;
#if MACH_KERNEL
rtc_gettime(&ps->starttime);
rtc_gettime(&ps->partialtime);
#else
xGetTime(&ps->starttime);
#endif /* MACH_KERNEL */
for (i = 0; i < ps->groupsize; i++) {
msgAssign(&request, &savedMsg);
xkr = xPush(sessn, &request);
if( xkr == XK_FAILURE ) {
printf( "Dgram Push error %d\n" , xkr );
goto abort;
}
}
evSchedule(ps->evdgram, dgram_abort, self, 30000000);
semWait(&ps->sema);
evCancel(ps->evdgram);
abort:
msgDestroy(&savedMsg);
msgDestroy(&request);
return (times - ps->partialcount);
}
xkern_return_t
rt_init( XObj self, IPhost *defGw )
{
PState *ps = (PState *)self->state;
RouteTable *tbl = &ps->rtTbl;
Path path = self->path;
Event ev;
xTrace0(ipp, TR_GROSS_EVENTS, "IP rt_init()");
tbl->valid = TRUE;
tbl->defrt = 0;
tbl->arr = (route **)pathAlloc(path, ROUTETABLESIZE * sizeof(route *));
tbl->path = path;
if ( ! tbl->arr ) {
xTraceP0(self, TR_ERRORS, "allocation failure");
return XK_FAILURE;
}
bzero((char *)tbl->arr, ROUTETABLESIZE * sizeof(route *));
tbl->bpoolsize = BPSIZE;
if ( ! (ev = evAlloc(path)) ) {
pathFree(tbl->arr);
xTraceP0(self, TR_ERRORS, "allocation failure");
return XK_FAILURE;
}
if ( IP_EQUAL(*defGw, ipNull) ) {
xTrace0(ipp, TR_GROSS_EVENTS,
"IP routing -- default routing disabled");
} else {
if ( rt_add_def(ps, defGw) ) {
return XK_FAILURE;
}
}
evSchedule(ev, rt_timer, tbl, RTTABLEUPDATE * 1000);
xTrace0(ipp, TR_GROSS_EVENTS, "IP rt_init() done");
return XK_SUCCESS;
}
