int
channel_clear(void)
{
int cca;
int radio_was_off = 0;
PRINTF("CCA\n");
/* If the radio is locked by an underlying thread (because we are
being invoked through an interrupt), we preted that the coast is
clear (i.e., no packet is currently being transmitted by a
neighbor). */
if(locked) {
return 1;
}
GET_LOCK();
if(!receive_on) {
radio_was_off = 1;
cc2520_on();
}
/* Make sure that the radio really got turned on. */
if(!receive_on) {
RELEASE_LOCK();
if(radio_was_off) {
cc2520_off();
}
return 1;
}
cca = cc2520ll_channel_clear();
if(radio_was_off) {
cc2520_off();
}
RELEASE_LOCK();
return cca;
}
PRIVATE
void
ListFree( void * unit )
{
int done = FALSE;
LIST_UNIT * lu;
ALLOC_UNIT * t = NULL;
ALLOC_UNIT * tbl = NULL;
WAIT_FOR_LOCK( LIST_MUTEX );
for( t = GLOBAL_ALLOC_TABLE; t; t = (ALLOC_UNIT *)tbl -> prev )
tbl = t;
if( !tbl )
{
DBG(PF( "Error freeing list structure.\n" ));
RELEASE_LOCK( LIST_MUTEX );
return;
}
lu = (LIST_UNIT *)( (int) unit - sizeof( int ) );
if( lu -> check != ALLOC_USED_FLAG )
{
ERROR( "Free of a corrupt list node from allocation table." );
RELEASE_LOCK( LIST_MUTEX );
return;
}
do
{
if ( (unit >= tbl -> min) && (unit < tbl -> max) )
{
tbl -> avail++;
lu -> check = ALLOC_FREE_FLAG;
lu -> ptr_a = NULL;
lu -> ptr_b = NULL;
lu -> ptr_c = NULL;
done = TRUE;
break;
}
else
{
tbl = (ALLOC_UNIT *)tbl -> next;
}
} while( tbl && !done );
if ( !done )
ERROR( "Couldn't find list in allocation table\n" );
RELEASE_LOCK( LIST_MUTEX );
}
NET_API_STATUS
Parse(
IN DWORD argc,
IN LPTSTR argv[]
)
/*++
Routine Description :
Wrapper function of the real worker Parse2 function.
Arguments :
argc : argument count
argv : argument string array pointer.
Return Value :
return NO_ERROR if successfully parse parameter
ERROR_INVALID_PARAMETER, otherwise
--*/
{
NET_API_STATUS ApiStatus;
LPNET_CONFIG_HANDLE ConfigHandle;
// Get read-write lock for config data. (The lock is for the in-memory
// version of the data, which we're going to set.)
ACQUIRE_LOCK( ReplGlobalConfigLock );
// Open the config file (nt.cfg)
ApiStatus = NetpOpenConfigData(
& ConfigHandle,
NULL, // local machine
SECT_NT_REPLICATOR, // section name
TRUE); // read-only
if (ApiStatus != NO_ERROR) {
NetpKdPrint(( "[REPL] Parse() can't open config section.\n" ));
ReplFinish(
SERVICE_UIC_CODE(
SERVICE_UIC_SYSTEM,
ApiStatus),
NULL);
RELEASE_LOCK( ReplGlobalConfigLock );
return( ApiStatus );
}
ApiStatus = Parse2(argc, argv, ConfigHandle);
// close config file ..
(void) NetpCloseConfigData( ConfigHandle );
RELEASE_LOCK( ReplGlobalConfigLock );
return( ApiStatus );
}
static int32_t
rtp_sinker_consume(network_sinker *ns, proto_watch *pw,
int32_t stm_i, msg *m, uint32_t seq)
{
int32_t ret = -ENOMEM;
media_sinker *sinker = (media_sinker*)ns;
rtp_sinker *rs = (rtp_sinker*)ns;
media_sinker *ms = (media_sinker*)ns;
mem_block *mb;
network_client *nc = (network_client*)rs->interleaved;
if (rs->trans_mode == RTP_OVER_UDP)
{
BUG_ON(!pw);
proto_watch_ref(pw);
RELEASE_LOCK(sinker->lock);
msg_ref(m);
ret = proto_watch_write(pw, m, seq, 0);
proto_watch_unref(pw);
AQUIRE_LOCK(sinker->lock);
return ret;
}
mb = rtp_msg_to_interleaved_mb(m, ns->stms[stm_i].interleaved);
if (mb)
{
MEMBLOCK_SET_SEQ(mb, seq);
if (rs->trans_mode == RTP_OVER_TCP)
{
BUG_ON(!pw);
proto_watch_ref(pw);
RELEASE_LOCK(sinker->lock);
msg_ref(m);
ret = proto_watch_write_mb(pw, mb, 0);
proto_watch_unref(pw);
AQUIRE_LOCK(sinker->lock);
}
else
{
BUG_ON(!nc);
RELEASE_LOCK(ms->lock);
msg_ref(m);
ret = network_client_send_mb(nc, mb, 0);
AQUIRE_LOCK(ms->lock);
}
}
return ret;
}
static void
ldl_op_fuck(void *data, void *user_data)
{
int32_t err;
media_info msi;
tp_block *tb = (tp_block*)data;
ldl_src *ldl = (ldl_src*)tb->ls;
switch (tb->action)
{
case ACTION_PROBE:
media_info_init(&msi);
err = __ldl_src_probe(ldl, &tb->mrl, &msi);
media_src_fill_info((media_src*)ldl, &msi, err);
media_info_clear(&msi);
#ifdef DEVICE_INTERFACE_TEST
void ldl_interfaces_test(media_uri *mrl);
ldl_interfaces_test(&tb->mrl);
#endif
break;
case ACTION_OPEN:
AQUIRE_LOCK(ldl->ldl_lock);
err = __ldl_src_open(ldl, &tb->mrl);
RELEASE_LOCK(ldl->ldl_lock);
media_src_open_end((media_src*)ldl, err);
break;
case ACTION_PLAY:
AQUIRE_LOCK(ldl->ldl_lock);
__ldl_src_play(ldl);
RELEASE_LOCK(ldl->ldl_lock);
break;
case ACTION_CTRL:
AQUIRE_LOCK(ldl->ldl_lock);
__ldl_src_ctrl(ldl, 1, NULL);
RELEASE_LOCK(ldl->ldl_lock);
break;
case ACTION_CLOSE:
AQUIRE_LOCK(ldl->ldl_lock);
__ldl_src_kill(ldl);
RELEASE_LOCK(ldl->ldl_lock);
break;
default:
break;
}
media_src_unref((media_src*)ldl);
tr_free(tb, sizeof(*tb));
}
BOOLEAN SRVFASTCALL
SrvCheckAndReferenceEndpoint (
PENDPOINT Endpoint
)
/*++
Routine Description:
This function atomically verifies that an endpoint is active and
increments the reference count on the endpoint if it is.
Arguments:
Endpoint - Address of endpoint
Return Value:
BOOLEAN - Returns TRUE if the endpoint is active, FALSE otherwise.
--*/
{
PAGED_CODE( );
//
// Acquire the lock that guards the endpoint's state field.
//
ACQUIRE_LOCK( &SrvEndpointLock );
//
// If the endpoint is active, reference it and return TRUE.
//
if ( GET_BLOCK_STATE(Endpoint) == BlockStateActive ) {
SrvReferenceEndpoint( Endpoint );
RELEASE_LOCK( &SrvEndpointLock );
return TRUE;
}
//
// The endpoint isn't active. Return FALSE.
//
RELEASE_LOCK( &SrvEndpointLock );
return FALSE;
} // SrvCheckAndReferenceEndpoint
/*---------------------------------------------------------------------------*/
static int
send(const void *payload, unsigned short payload_len)
{
int res = 0;
GET_LOCK();
cc2520ll_prepare(payload, payload_len);
RELEASE_LOCK();
GET_LOCK();
res = cc2520ll_transmit();
RELEASE_LOCK();
return res;
}
/*---------------------------------------------------------------------------*/
static int
cc2520_prepare(const void *payload, unsigned short payload_len)
{
uint8_t total_len;
GET_LOCK();
PRINTF("cc2520: sending %d bytes\n", payload_len);
/*int i;
for(i = 0; i < payload_len;i++)
printf("%x",((uint8_t *) payload)[i]);
printf("\n");*/
RIMESTATS_ADD(lltx);
/* Wait for any previous transmission to finish. */
/* while(status() & BV(CC2520_TX_ACTIVE));*/
/* Write packet to TX FIFO. */
strobe(CC2520_INS_SFLUSHTX);
total_len = payload_len + FOOTER_LEN;
CC2520_WRITE_FIFO_BUF(&total_len, 1);
CC2520_WRITE_FIFO_BUF(payload, payload_len);
RELEASE_LOCK();
return 0;
}
/*---------------------------------------------------------------------------*/
int
cc2420_set_channel(int c)
{
uint16_t f;
GET_LOCK();
/*
* Subtract the base channel (11), multiply by 5, which is the
* channel spacing. 357 is 2405-2048 and 0x4000 is LOCK_THR = 1.
*/
channel = c;
f = 5 * (c - 11) + 357 + 0x4000;
/*
* Writing RAM requires crystal oscillator to be stable.
*/
BUSYWAIT_UNTIL((status() & (BV(CC2420_XOSC16M_STABLE))), RTIMER_SECOND / 10);
/* Wait for any transmission to end. */
BUSYWAIT_UNTIL(!(status() & BV(CC2420_TX_ACTIVE)), RTIMER_SECOND / 10);
setreg(CC2420_FSCTRL, f);
/* If we are in receive mode, we issue an SRXON command to ensure
that the VCO is calibrated. */
if(receive_on) {
strobe(CC2420_SRXON);
}
RELEASE_LOCK();
return 1;
}
/*---------------------------------------------------------------------------*/
static int
cc2420_prepare(const void *payload, unsigned short payload_len)
{
uint8_t total_len;
#if CC2420_CONF_CHECKSUM
uint16_t checksum;
#endif /* CC2420_CONF_CHECKSUM */
GET_LOCK();
PRINTF("cc2420: sending %d bytes\n", payload_len);
RIMESTATS_ADD(lltx);
/* Wait for any previous transmission to finish. */
/* while(status() & BV(CC2420_TX_ACTIVE));*/
/* Write packet to TX FIFO. */
strobe(CC2420_SFLUSHTX);
#if CC2420_CONF_CHECKSUM
checksum = crc16_data(payload, payload_len, 0);
#endif /* CC2420_CONF_CHECKSUM */
total_len = payload_len + AUX_LEN;
CC2420_WRITE_FIFO_BUF(&total_len, 1);
CC2420_WRITE_FIFO_BUF(payload, payload_len);
#if CC2420_CONF_CHECKSUM
CC2420_WRITE_FIFO_BUF(&checksum, CHECKSUM_LEN);
#endif /* CC2420_CONF_CHECKSUM */
RELEASE_LOCK();
return 0;
}
/* There may be at most one additional tick fired after a call to this */
void
stopTicker(void)
{
ACQUIRE_LOCK(&mutex);
stopped = 1;
RELEASE_LOCK(&mutex);
}
/*---------------------------------------------------------------------------*/
int
cc2520_rssi(void)
{
int rssi;
int radio_was_off = 0;
if(locked) {
return 0;
}
GET_LOCK();
if(!receive_on) {
radio_was_off = 1;
cc2520_on();
}
BUSYWAIT_UNTIL(status() & BV(CC2520_RSSI_VALID), RTIMER_SECOND / 100);
rssi = (int)((signed char)getreg(CC2520_RSSI));
if(radio_was_off) {
cc2520_off();
}
RELEASE_LOCK();
return rssi;
}
/*---------------------------------------------------------------------------*/
void
cc2520_set_pan_addr(unsigned pan,
unsigned addr,
const uint8_t *ieee_addr)
{
uint8_t tmp[2];
GET_LOCK();
/*
* Writing RAM requires crystal oscillator to be stable.
*/
BUSYWAIT_UNTIL(status() & (BV(CC2520_XOSC16M_STABLE)), RTIMER_SECOND / 10);
tmp[0] = pan & 0xff;
tmp[1] = pan >> 8;
CC2520_WRITE_RAM(&tmp, CC2520RAM_PANID, 2);
tmp[0] = addr & 0xff;
tmp[1] = addr >> 8;
CC2520_WRITE_RAM(&tmp, CC2520RAM_SHORTADDR, 2);
if(ieee_addr != NULL) {
int f;
uint8_t tmp_addr[8];
// LSB first, MSB last for 802.15.4 addresses in CC2520
for (f = 0; f < 8; f++) {
tmp_addr[7 - f] = ieee_addr[f];
}
CC2520_WRITE_RAM(tmp_addr, CC2520RAM_IEEEADDR, 8);
}
RELEASE_LOCK();
}
nat
freeTaskManager (void)
{
Task *task, *next;
nat tasksRunning = 0;
ACQUIRE_LOCK(&all_tasks_mutex);
for (task = all_tasks; task != NULL; task = next) {
next = task->all_next;
if (task->stopped) {
freeTask(task);
} else {
tasksRunning++;
}
}
debugTrace(DEBUG_sched, "freeing task manager, %d tasks still running",
tasksRunning);
all_tasks = NULL;
RELEASE_LOCK(&all_tasks_mutex);
#if defined(THREADED_RTS)
closeMutex(&all_tasks_mutex);
#if !defined(MYTASK_USE_TLV)
freeThreadLocalKey(¤tTaskKey);
#endif
#endif
tasksInitialized = 0;
return tasksRunning;
}
void traceCapEvent_ (Capability *cap,
EventTypeNum tag)
{
#ifdef DEBUG
if (RtsFlags.TraceFlags.tracing == TRACE_STDERR) {
ACQUIRE_LOCK(&trace_utx);
tracePreface();
switch (tag) {
case EVENT_CAP_CREATE: // (cap)
debugBelch("cap %d: initialised\n", cap->no);
break;
case EVENT_CAP_DELETE: // (cap)
debugBelch("cap %d: shutting down\n", cap->no);
break;
case EVENT_CAP_ENABLE: // (cap)
debugBelch("cap %d: enabling capability\n", cap->no);
break;
case EVENT_CAP_DISABLE: // (cap)
debugBelch("cap %d: disabling capability\n", cap->no);
break;
}
RELEASE_LOCK(&trace_utx);
} else
#endif
{
if (eventlog_enabled) {
postCapEvent(tag, (EventCapNo)cap->no);
}
}
}
static void traceGcEvent_stderr (Capability *cap, EventTypeNum tag)
{
ACQUIRE_LOCK(&trace_utx);
tracePreface();
switch (tag) {
case EVENT_REQUEST_SEQ_GC: // (cap)
debugBelch("cap %d: requesting sequential GC\n", cap->no);
break;
case EVENT_REQUEST_PAR_GC: // (cap)
debugBelch("cap %d: requesting parallel GC\n", cap->no);
break;
case EVENT_GC_START: // (cap)
debugBelch("cap %d: starting GC\n", cap->no);
break;
case EVENT_GC_END: // (cap)
debugBelch("cap %d: finished GC\n", cap->no);
break;
case EVENT_GC_IDLE: // (cap)
debugBelch("cap %d: GC idle\n", cap->no);
break;
case EVENT_GC_WORK: // (cap)
debugBelch("cap %d: GC working\n", cap->no);
break;
case EVENT_GC_DONE: // (cap)
debugBelch("cap %d: GC done\n", cap->no);
break;
default:
barf("traceGcEvent: unknown event tag %d", tag);
break;
}
RELEASE_LOCK(&trace_utx);
}
/*---------------------------------------------------------------------------*/
int
cc2520_off(void)
{
PRINTF("OFF\n");
/* Don't do anything if we are already turned off. */
if(receive_on == 0) {
//PRINTF("DONT CALL OFF WAS OFF\n");
return 1;
}
/* If we are called when the driver is locked, we indicate that the
radio should be turned off when the lock is unlocked. */
if(locked) {
/* PRINTF("Off when locked (%d)\n", locked);*/
lock_off = 1;
//PRINTF("DONT CALL OFF WAS LOCKED SCHEDULE OFF\n");
return 1;
}
GET_LOCK();
/* If we are currently receiving a packet (indicated by SFD == 1),
we don't actually switch the radio off now, but signal that the
driver should switch off the radio once the packet has been
received and processed, by setting the 'lock_off' variable. */
if(cc2520ll_rxtx_packet()) {
//PRINTF("DONT CALL OFF WAS LOCKED SCHEDULE OFF BUSY\n");
lock_off = 1;
} else {
//PRINTF("CALL OFF WAS ON\n");
off();
}
RELEASE_LOCK();
return 1;
}
/*
* Function: startSignalHandlers()
*
* Run the handlers associated with the stacked up console events. Console
* event delivery is blocked for the duration of this call.
*/
void startSignalHandlers(Capability *cap)
{
StgStablePtr handler;
if (console_handler < 0) {
return;
}
blockUserSignals();
ACQUIRE_LOCK(&sched_mutex);
handler = deRefStablePtr((StgStablePtr)console_handler);
while (stg_pending_events > 0) {
stg_pending_events--;
scheduleThread(cap,
createIOThread(cap,
RtsFlags.GcFlags.initialStkSize,
rts_apply(cap,
(StgClosure *)handler,
rts_mkInt(cap,
stg_pending_buf[stg_pending_events]))));
}
RELEASE_LOCK(&sched_mutex);
unblockUserSignals();
}
/*---------------------------------------------------------------------------*/
int
cc2520_off(void)
{
/* Don't do anything if we are already turned off. */
if(receive_on == 0) {
return 1;
}
/* If we are called when the driver is locked, we indicate that the
radio should be turned off when the lock is unlocked. */
if(locked) {
/* printf("Off when locked (%d)\n", locked);*/
lock_off = 1;
return 1;
}
GET_LOCK();
/* If we are currently receiving a packet (indicated by SFD == 1),
we don't actually switch the radio off now, but signal that the
driver should switch off the radio once the packet has been
received and processed, by setting the 'lock_off' variable. */
if(status() & BV(CC2520_TX_ACTIVE)) {
lock_off = 1;
} else {
off();
}
RELEASE_LOCK();
return 1;
}
PUBLIC
void
ListGlobalFree( void )
{
ALLOC_UNIT * table, *tblptr;
WAIT_FOR_LOCK( LIST_MUTEX );
if( !GLOBAL_ALLOC_TABLE )
return;
table = GLOBAL_ALLOC_TABLE;
while( table -> prev )
table = table -> prev;
for( ; table ; )
{
tblptr = table -> next;
#ifdef USE_SH_POOLS
MemFreePtr( table );
#else
MemFree( table );
#endif
table = tblptr;
}
GLOBAL_ALLOC_TABLE = NULL;
RELEASE_LOCK( LIST_MUTEX );
}
/*---------------------------------------------------------------------------*/
int
cc2520_set_channel(int c)
{
uint16_t f;
GET_LOCK();
/*
* Subtract the base channel (11), multiply by 5, which is the
* channel spacing. 357 is 2405-2048 and 0x4000 is LOCK_THR = 1.
*/
channel = c;
f = MIN_CHANNEL + ((channel - MIN_CHANNEL) * CHANNEL_SPACING);
/*
* Writing RAM requires crystal oscillator to be stable.
*/
BUSYWAIT_UNTIL((status() & (BV(CC2520_XOSC16M_STABLE))), RTIMER_SECOND / 10);
/* Wait for any transmission to end. */
BUSYWAIT_UNTIL(!(status() & BV(CC2520_TX_ACTIVE)), RTIMER_SECOND / 10);
/* Define radio channel (between 11 and 25) */
setreg(CC2520_FREQCTRL, f);
/* If we are in receive mode, we issue an SRXON command to ensure
that the VCO is calibrated. */
if(receive_on) {
strobe(CC2520_INS_SRXON);
}
RELEASE_LOCK();
return 1;
}
PUBLIC
void
ListValidate( void )
{
ALLOC_UNIT * tmp = NULL;
ALLOC_UNIT * table = NULL;
int i;
WAIT_FOR_LOCK( LIST_MUTEX );
if( !GLOBAL_ALLOC_TABLE )
return;
for( tmp = GLOBAL_ALLOC_TABLE; tmp; tmp = (ALLOC_UNIT *)table -> prev )
table = tmp;
for( tmp = table; tmp; tmp = tmp -> next )
for( i=0; i<ALLOC_UNITS; i++ )
if( (tmp -> unit[i].check != ALLOC_FREE_FLAG ) &&
(tmp -> unit[i].check != ALLOC_USED_FLAG ))
{
DBG(PF( "ERROR: Possible overwrite in lists." ));
DBG(PF( "Unit Address: %x index: %d\n", &tmp -> unit[i] ));
DBG(PF( "------------------------------------------\n" ));
DBG(PF( "node: %x\n", tmp -> unit[i].ptr_a ));
DBG(PF( "user: %x\n", tmp -> unit[i].ptr_b ));
DBG(PF( "next: %x\n", tmp -> unit[i].ptr_c ));
}
RELEASE_LOCK( LIST_MUTEX );
}
/*---------------------------------------------------------------------------*/
void
cc2520_set_txpower(uint8_t power)
{
GET_LOCK();
set_txpower(power);
RELEASE_LOCK();
}
static int32_t
rtp_sinker_consumable(network_sinker *ns, proto_watch *pw,
int32_t stm_i, uint32_t size)
{
int32_t err = -EINVAL;
media_sinker *sinker = (media_sinker*)ns;
rtp_sinker *rs = (rtp_sinker*)ns;
network_client *nc = (network_client*)rs->interleaved;
if (rs->trans_mode == RTP_OVER_RTSP && nc)
{ //@{Interleaved rtp mode}
client_ref((client*)nc);
RELEASE_LOCK(sinker->lock);
err = network_client_consumable(nc, size);
client_unref((client*)nc);
AQUIRE_LOCK(sinker->lock);
return err;
}
if (pw)
{
return proto_watch_writeable(pw, size);
}
return err;
}
/*---------------------------------------------------------------------------*/
void
cc2520_set_cca_threshold(int value)
{
GET_LOCK();
setreg(CC2520_CCACTRL0, value & 0xff);
RELEASE_LOCK();
}
void traceCapsetEvent_ (EventTypeNum tag,
CapsetID capset,
StgWord info)
{
#ifdef DEBUG
if (RtsFlags.TraceFlags.tracing == TRACE_STDERR) {
ACQUIRE_LOCK(&trace_utx);
tracePreface();
switch (tag) {
case EVENT_CAPSET_CREATE: // (capset, capset_type)
debugBelch("created capset %lu of type %d\n", (lnat)capset, (int)info);
break;
case EVENT_CAPSET_DELETE: // (capset)
debugBelch("deleted capset %lu\n", (lnat)capset);
break;
case EVENT_CAPSET_ASSIGN_CAP: // (capset, capno)
debugBelch("assigned cap %lu to capset %lu\n",
(lnat)info, (lnat)capset);
break;
case EVENT_CAPSET_REMOVE_CAP: // (capset, capno)
debugBelch("removed cap %lu from capset %lu\n",
(lnat)info, (lnat)capset);
break;
}
RELEASE_LOCK(&trace_utx);
} else
#endif
{
if (eventlog_enabled) {
postCapsetEvent(tag, capset, info);
}
}
}
PRIVATE
void *
ListAlloc( void )
{
LIST_UNIT * lu;
CREATE_LOCK( LIST_MUTEX );
WAIT_FOR_LOCK( LIST_MUTEX );
if( !GLOBAL_ALLOC_TABLE )
ListGlobalAlloc();
do
{
if ( ( GLOBAL_ALLOC_TABLE -> avail < ALLOC_SAFETY) ||
( GLOBAL_ALLOC_TABLE -> index > (ALLOC_UNITS - ALLOC_SAFETY)) )
ListGlobalPack();
lu = (LIST_UNIT *)(&GLOBAL_ALLOC_TABLE -> unit[ GLOBAL_ALLOC_TABLE -> index ]);
GLOBAL_ALLOC_TABLE -> index++;
} while( lu -> check != ALLOC_FREE_FLAG );
lu -> check = ALLOC_USED_FLAG;
GLOBAL_ALLOC_TABLE -> timer = TIME_COUNT;
GLOBAL_ALLOC_TABLE -> avail--;
RELEASE_LOCK( LIST_MUTEX );
return ( &lu -> ptr_a );
}
void sendMessage(Capability *from_cap, Capability *to_cap, Message *msg)
{
ACQUIRE_LOCK(&to_cap->lock);
#ifdef DEBUG
{
const StgInfoTable *i = msg->header.info;
if (i != &stg_MSG_THROWTO_info &&
i != &stg_MSG_BLACKHOLE_info &&
i != &stg_MSG_TRY_WAKEUP_info &&
i != &stg_IND_info && // can happen if a MSG_BLACKHOLE is revoked
i != &stg_WHITEHOLE_info) {
barf("sendMessage: %p", i);
}
}
#endif
msg->link = to_cap->inbox;
to_cap->inbox = msg;
recordClosureMutated(from_cap,(StgClosure*)msg);
if (to_cap->running_task == NULL) {
to_cap->running_task = myTask();
// precond for releaseCapability_()
releaseCapability_(to_cap,rtsFalse);
} else {
interruptCapability(to_cap);
}
RELEASE_LOCK(&to_cap->lock);
}
void
workerTaskStop (Task *task)
{
DEBUG_ONLY( OSThreadId id );
DEBUG_ONLY( id = osThreadId() );
ASSERT(task->id == id);
ASSERT(myTask() == task);
ACQUIRE_LOCK(&all_tasks_mutex);
if (task->all_prev) {
task->all_prev->all_next = task->all_next;
} else {
all_tasks = task->all_next;
}
if (task->all_next) {
task->all_next->all_prev = task->all_prev;
}
currentWorkerCount--;
RELEASE_LOCK(&all_tasks_mutex);
freeTask(task);
}
static __inline__ void
ldh_preread_frames(ldh_src *ldh)
{
AQUIRE_LOCK(ldh->ldh_lock);
__ldh_preread_frames(ldh);
RELEASE_LOCK(ldh->ldh_lock);
}
