static int8_t handle_version_data( Message *msg )
{
msg_version_data_t *pkt = (msg_version_data_t *) msg->data;
if( st.net_state & SEND_DATA ) {
/*
* We have data to send
*/
if( pkt->version == st.version_data->version) {
st.data_count ++;
if( st.data_count >= OVERHEARD_K ) {
st.net_state &= ~SEND_DATA;
ker_timer_stop( KER_DFT_LOADER_PID, DATA_TID );
}
return SOS_OK;
}
}
if( pkt->version > st.version_data->version ) {
restartInterval( 0 );
ker_free(st.version_data);
st.version_data = (msg_version_data_t*) ker_msg_take_data(KER_DFT_LOADER_PID, msg);
process_version_data( st.version_data, msg->saddr );
}
return SOS_OK;
}
void* ker_sys_msg_take_data(Message *msg)
{
sos_pid_t my_id = ker_get_current_pid();
void *ret = ker_msg_take_data(my_id, msg);
if( ret != NULL ) {
return ret;
}
#ifndef SOS_TEST_SUITE
ker_mod_panic(my_id);
#endif
return NULL;
}
static int tr_send_data(Data *s, Message *msg)
{
void *hdr = ker_msg_take_data(42, msg);
int dup;
int my_id = s->fieldB;
if(hdr == 0) return -1;
if(s->fieldA == 0) {
if(my_id == 42) {
post_net(42,
42,
69,
msg->len,
msg->data,
0x04,
255);
// MEMORY LEAK HERE. The above call to post should be realeasing
// hdr rather than msg->data.
return 0;
} else {
ker_free(hdr);
return -1;
}
}
if(s->fieldA >= ((int*)hdr)[0] ) {
ker_free(hdr);
return -1;
}
if(my_id != 18) {
my_id += 4;
} else {
dup = 0;
}
if(dup == 0) {
post_net(42,
42,
69,
msg->len,
msg->data,
0x04,
s->fieldA);
return 0;
} else {
ker_free(hdr);
return -1;
}
}
static int8_t handle_request(Message *msg)
{
int8_t ret;
//! setup a periodic timer to send fragments
if(send_state.map == NULL) {
fetcher_bitmap_t *b = (fetcher_bitmap_t*) msg->data;
ret = set_num_funcs_in_send_state(b->key);
if( ret != SOS_OK ) {
// cannot find num funcs, give up
return SOS_OK;
}
ret = ker_timer_restart(KER_FETCHER_PID,
FETCHER_TRANSMIT_TID,
FETCHER_SENDING_FRAGMENT_INTERVAL);
if(ret == SOS_OK) {
send_state.map = (fetcher_bitmap_t*)ker_msg_take_data(KER_FETCHER_PID, msg);
send_state.dest = msg->saddr;
DEBUG_PID(KER_FETCHER_PID,"send_state.map = 0x%x send_state.dest = 0x%x\n", (int)send_state.map, send_state.dest);
} else {
return -ENOMEM;
}
} else {
fetcher_bitmap_t *map = (fetcher_bitmap_t*)msg->data;
//! XXX change to broadcast
//send_state.dest = BCAST_ADDRESS;
DEBUG_PID(KER_FETCHER_PID,"else send_state.dest = %x\n", send_state.dest);
//! merge wanted list
if((send_state.map->key == map->key)) {
uint8_t i;
for(i = 0; i < send_state.map->bitmap_size &&
i < map->bitmap_size; i++) {
send_state.map->bitmap[i] |= map->bitmap[i];
}
}
}
if( fst != NULL && (fst->map.key == send_state.map->key) ) {
//! send only those we have
uint8_t i;
for(i = 0; i < send_state.map->bitmap_size; i++ ) {
uint8_t tmp;
//! this is the fragment that has been requested but we dont have
tmp = send_state.map->bitmap[i] & fst->map.bitmap[i];
send_state.map->bitmap[i] &= ~tmp;
}
}
return SOS_OK;
}
static int8_t handle_data(Message *msg)
{
fetcher_fragment_t *f;
int8_t ret = -EINVAL;
fetcher_cam_t *cam;
f = (fetcher_fragment_t*)msg->data;
DEBUG_PID(KER_FETCHER_PID, "fetcher: get data, key = %d, frag_id = %d\n", f->key, f->frag_id);
//msg_print(msg);
if(f->key != fst->map.key) {
DEBUG_PID(KER_FETCHER_PID,"version mis-match\n");
return SOS_OK;
}
cam = (fetcher_cam_t *) ker_shm_get( KER_FETCHER_PID, f->key);
if( cam == NULL ) {
// XXX cannot find CAM...
// TODO: need to inform upper layer...
return -EINVAL;
}
if( (fst->map.bitmap[(f->frag_id) / 8] & (1 << ((f->frag_id) % 8))) == 0 ) {
// we already have the fragment...
return SOS_OK;
}
if((f->frag_id != 0) && ((fst->map.bitmap[0] & 0x01) != 0)
&& (cam->fetchtype == FETCHTYPE_MODULE)) {
// if the first fragment is not available, we drop the packet
return SOS_OK;
}
ret = ker_codemem_write(cam->cm, KER_FETCHER_PID,
f->fragment, FETCHER_FRAGMENT_SIZE,
(code_addr_t)FETCHER_FRAGMENT_SIZE * f->frag_id);
if(ret == SOS_SPLIT) {
send_state.fragr = (fetcher_fragment_t*) ker_msg_take_data(KER_FETCHER_PID, msg);
f = send_state.fragr;
} else if(ret != SOS_OK) {
//DEBUG("codemem_write failed\n");
return SOS_OK;
}
fst->map.bitmap[(f->frag_id) / 8] &= ~(1 << ((f->frag_id) % 8));
check_map_and_post();
return SOS_OK;
}
static int8_t rfid_msg_handler(void *state, Message *msg)
{
app_state_t *s = (app_state_t*)state;
switch (msg->type){
case MSG_INIT:
{
s->pid = msg->did;
s->state = 0;
DEBUG("Rfid Start\n");
sys_post(KER_UART_PID, MSG_RFID_COMMAND, sizeof(rfid_cmd), rfid_cmd, 0);
break;
}
case MSG_FINAL:
{
DEBUG("Rfid Stop\n");
break;
}
case MSG_RFID_RESPONSE:
{
uint8_t msg_len;
uint8_t *buff_to_send;
msg_len = msg->len;
buff_to_send = (uint8_t*)ker_msg_take_data(s->pid, msg);
if (buff_to_send != NULL){
sys_post_net(DFLT_APP_ID0, msg->type, msg_len, (void*)buff_to_send, SOS_MSG_RELEASE, BCAST_ADDRESS);
}
break;
}
default:
return -EINVAL;
}
return SOS_OK;
}
static int8_t handle_fetcher_done( Message *msg )
{
fetcher_state_t *f = (fetcher_state_t*) msg->data;
if( is_fetcher_succeed( f ) == true ) {
//mod_header_ptr p;
loader_cam_t *cam;
fetcher_commit(f, true);
st.blocked = 0;
restartInterval( 0 );
cam = ker_cam_lookup( f->map.key );
if( cam->fetcher.fetchtype == FETCHTYPE_DATA) {
uint8_t buf[2];
ker_codemem_read( cam->fetcher.cm, KER_DFT_LOADER_PID, buf, 2, 0);
post_short(buf[0], KER_DFT_LOADER_PID, MSG_LOADER_DATA_AVAILABLE,
buf[1], cam->fetcher.cm, 0);
DEBUG_PID(KER_DFT_LOADER_PID, "Data Ready\n" );
#ifdef LOADER_NET_EXPERIMENT
ker_led(LED_GREEN_TOGGLE);
#endif
} else {
uint8_t mcu_type;
#ifndef SOS_SIM
uint8_t plat_type;
#endif
mod_header_ptr p;
#ifdef MINIELF_LOADER
// Link and load the module here
melf_load_module(cam->fetcher.cm);
#endif//MINIELF_LOADER
// Get the address of the module header
p = ker_codemem_get_header_address( cam->fetcher.cm );
// get processor type and platform type
mcu_type = sos_read_header_byte(p,
offsetof( mod_header_t, processor_type ));
#ifdef SOS_SIM
if( (mcu_type == MCU_TYPE) )
// In simulation, we don't check for platform
#else
plat_type = sos_read_header_byte(p,
offsetof( mod_header_t, platform_type ));
if( (mcu_type == MCU_TYPE) &&
( plat_type == HW_TYPE || plat_type == PLATFORM_ANY) )
#endif
{
/*
* If MCU is matched, this means we are using the same
* instruction set.
* And if this module is for this *specific* platform or
* simply for all platform with the same MCU
*/
// mark module executable
ker_codemem_mark_executable( cam->fetcher.cm );
if (cam->version & 0x80) {
#ifdef SOS_SFI
#ifdef MINIELF_LOADER
sfi_modtable_register(cam->fetcher.cm);
if (SOS_OK == ker_verify_module(cam->fetcher.cm)){
sfi_modtable_flash(p);
ker_register_module(p);
}
else
sfi_exception(KER_VERIFY_FAIL_EXCEPTION);
#else
uint16_t init_offset, code_size, handler_addr;
uint32_t handler_byte_addr, module_start_byte_addr;
uint16_t handler_sfi_addr;
handler_sfi_addr = sos_read_header_ptr(p, offsetof(mod_header_t, module_handler));
handler_addr = sfi_modtable_get_real_addr(handler_sfi_addr);
handler_byte_addr = (handler_addr * 2);
module_start_byte_addr = (p * 2);
init_offset = (uint16_t)(handler_byte_addr - module_start_byte_addr);
code_size = cam->code_size * LOADER_SIZE_MULTIPLIER;
if (SOS_OK == ker_verify_module(cam->fetcher.cm, init_offset, code_size)){
sfi_modtable_flash(p);
ker_register_module(p);
}
else
sfi_exception(KER_VERIFY_FAIL_EXCEPTION);
#endif //MINIELF_LOADER
#else
ker_register_module(p);
#endif //SOS_SFI
}
}
}
process_version_data( st.version_data, st.recent_neighbor);
} else {
DEBUG_PID( KER_DFT_LOADER_PID, "Fetch failed!, request %d\n", st.recent_neighbor);
f = (fetcher_state_t*) ker_msg_take_data(KER_DFT_LOADER_PID, msg);
fetcher_restart( f, st.recent_neighbor );
}
return SOS_OK;
}
