/// Create page mappings
errval_t caps_copy_to_vnode(struct cte *dest_vnode_cte, cslot_t dest_slot,
struct cte *src_cte, uintptr_t flags,
uintptr_t offset, uintptr_t pte_count,
struct cte *mapping_cte)
{
struct capability *src_cap = &src_cte->cap;
struct capability *dest_cap = &dest_vnode_cte->cap;
assert(mapping_cte->cap.type == ObjType_Null);
mapping_handler_t handler_func = handler[dest_cap->type];
assert(handler_func != NULL);
errval_t err;
err = handler_func(dest_cap, dest_slot, src_cap, flags, offset, pte_count,
mapping_cte);
if (err_is_fail(err)) {
assert(mapping_cte->cap.type == ObjType_Null);
debug(SUBSYS_PAGING,
"caps_copy_to_vnode: handler func returned %"PRIuERRV"\n", err);
return err;
}
/* insert mapping cap into mdb */
err = mdb_insert(mapping_cte);
if (err_is_fail(err)) {
printk(LOG_ERR, "%s: mdb_insert: %"PRIuERRV"\n", __FUNCTION__, err);
}
TRACE_CAP_MSG("created", mapping_cte);
return err;
}
/**
* \brief Application task
*/
static void app_task(void)
{
void (*handler_func)(void)
= state_table[node_info.main_state].func_task;
if (handler_func) {
handler_func();
}
}
/*
* \brief Application task handling peer search
*/
void peer_search_initiator_task()
{
peer_search_initiator_state_t sub_state = (peer_search_initiator_state_t)node_info.sub_state;
void (*handler_func)(void) = peer_search_initiator_state_table[sub_state].peer_state_task;
if (handler_func)
{
handler_func();
}
}
/*
* \brief User call back function for finished ED Scan
*
* \param energy_level Measured energy level during ED Scan
*/
void tal_ed_end_cb(uint8_t energy_level)
{
void (*handler_func)(uint8_t energy_level);
handler_func = state_table[node_info.main_state].func_ed_end_cb;
if (handler_func) {
handler_func(energy_level);
}
}
// it will be called when an timer irq
// is raised
void timer_handler(struct regs *r)
{
timer_ticks++;
if (handler_func != 0 && (handler_msec_passed++ >= handler_counter))
{
handler_func();
}
//if(ticks%1000 == 0) puts("one second\n");
}
/// Create page mappings
errval_t caps_copy_to_vnode(struct cte *dest_vnode_cte, cslot_t dest_slot,
struct cte *src_cte, uintptr_t flags,
uintptr_t offset, uintptr_t pte_count)
{
assert(type_is_vnode(dest_vnode_cte->cap.type));
struct capability *src_cap = &src_cte->cap;
struct capability *dest_cap = &dest_vnode_cte->cap;
mapping_handler_t handler_func = handler[dest_cap->type];
assert(handler_func != NULL);
#if 0
genpaddr_t paddr = get_address(&src_cte->cap) + offset;
genvaddr_t vaddr;
compile_vaddr(dest_vnode_cte, dest_slot, &vaddr);
printf("mapping 0x%"PRIxGENPADDR" to 0x%"PRIxGENVADDR"\n", paddr, vaddr);
#endif
if (src_cte->mapping_info.pte) {
// this cap is already mapped
#if DIAGNOSTIC_ON_ERROR
printf("caps_copy_to_vnode: this copy is already mapped @pte 0x%lx (paddr = 0x%"PRIxGENPADDR")\n", src_cte->mapping_info.pte, get_address(src_cap));
#endif
#if RETURN_ON_ERROR
return SYS_ERR_VM_ALREADY_MAPPED;
#endif
}
cslot_t last_slot = dest_slot + pte_count;
if (last_slot > X86_64_PTABLE_SIZE) {
// requested map overlaps leaf page table
#if DIAGNOSTIC_ON_ERROR
printf("caps_copy_to_vnode: requested mapping spans multiple leaf page tables\n");
#endif
#if RETURN_ON_ERROR
return SYS_ERR_VM_RETRY_SINGLE;
#endif
}
errval_t r = handler_func(dest_cap, dest_slot, src_cap, flags, offset, pte_count);
if (err_is_fail(r)) {
printf("caps_copy_to_vnode: handler func returned %ld\n", r);
}
#if 0
else {
printf("mapping_info.pte = 0x%lx\n", src_cte->mapping_info.pte);
printf("mapping_info.offset = 0x%lx\n", src_cte->mapping_info.offset);
printf("mapping_info.pte_count = %zu\n", src_cte->mapping_info.pte_count);
}
#endif
return r;
}
/*
* \brief Function to exit peer search initiator exit state
*/
void peer_search_initiator_exit()
{
void (*handler_func)(void);
handler_func = peer_search_initiator_state_table[node_info.sub_state].peer_state_exit;
/* Exit the old sub state */
if (handler_func)
{
handler_func();
}
}
/*
* \brief Callback that is called if data has been received by trx
* peer search initiator state.
* \param frame Pointer to received frame
*/
void peer_search_initiator_rx_cb(frame_info_t *frame)
{
peer_search_initiator_state_t sub_state = (peer_search_initiator_state_t)node_info.sub_state;
void (*handler_func)(frame_info_t * frame);
handler_func = peer_search_initiator_state_table[sub_state].peer_state_rx_frame_cb;
if (handler_func)
{
handler_func(frame);
}
}
/*
* \brief Callback that is called once tx is done.
*
* \param status Status of the transmission procedure
* \param frame Pointer to the transmitted frame structure
*/
void peer_search_initiator_tx_done_cb(retval_t status, frame_info_t *frame)
{
peer_search_initiator_state_t sub_state = (peer_search_initiator_state_t)node_info.sub_state;
void (*handler_func)(retval_t status, frame_info_t * frame);
handler_func = peer_search_initiator_state_table[sub_state].peer_state_tx_frame_done_cb;
if (handler_func)
{
handler_func(status, frame);
}
}
/*
* \brief Callback that is called if data has been received by trx.
*
* \param frame Pointer to received frame
*/
void tal_rx_frame_cb(frame_info_t *frame)
{
void (*handler_func)(frame_info_t *frame);
handler_func = state_table[node_info.main_state].func_rx_frame_cb;
if (handler_func) {
handler_func(frame);
}
/* free buffer that was used for frame reception */
bmm_buffer_free((buffer_t *)(frame->buffer_header));
}
/// Create page mappings
errval_t caps_copy_to_vnode(struct cte *dest_vnode_cte, cslot_t dest_slot,
struct cte *src_cte, uintptr_t flags,
uintptr_t offset, uintptr_t pte_count,
struct cte *mapping_cte)
{
assert(type_is_vnode(dest_vnode_cte->cap.type));
assert(mapping_cte->cap.type == ObjType_Null);
struct capability *src_cap = &src_cte->cap;
struct capability *dest_cap = &dest_vnode_cte->cap;
mapping_handler_t handler_func = handler[dest_cap->type];
assert(handler_func != NULL);
cslot_t last_slot = dest_slot + pte_count;
// TODO: PAE
if (last_slot > X86_32_PTABLE_SIZE) {
// requested map overlaps leaf page table
debug(SUBSYS_CAPS,
"caps_copy_to_vnode: requested mapping spans multiple leaf page tables\n");
return SYS_ERR_VM_RETRY_SINGLE;
}
errval_t r = handler_func(dest_cap, dest_slot, src_cap, flags, offset,
pte_count, mapping_cte);
if (err_is_fail(r)) {
assert(mapping_cte->cap.type == ObjType_Null);
debug(SUBSYS_PAGING, "caps_copy_to_vnode: handler func returned %d\n", r);
return r;
}
/* insert mapping cap into mdb */
errval_t err = mdb_insert(mapping_cte);
if (err_is_fail(err)) {
printk(LOG_ERR, "%s: mdb_insert: %"PRIuERRV"\n", __FUNCTION__, err);
}
TRACE_CAP_MSG("created", mapping_cte);
return err;
}
/*
* \brief Callback that is called once tx is done.
*
* \param status Status of the transmission procedure
* \param frame Pointer to the transmitted frame structure
*/
void tal_tx_frame_done_cb(retval_t status, frame_info_t *frame)
{
void (*handler_func)(retval_t status, frame_info_t *frame);
/* some spurious transmissions call back or app changed its state
* so neglect this call back */
if (!node_info.transmitting) {
return;
}
/* After transmission is completed, allow next transmission.
* Locking to prevent multiple transmissions simultaneously */
node_info.transmitting = false;
handler_func = state_table[node_info.main_state].func_tx_frame_done_cb;
if (handler_func) {
handler_func(status, frame);
}
}
void parse_args(int argc,char **argv,void (*handler_func)(char *arg),int flags)
{
for (;argc--;argv++) {
if (**argv=='@') { /* read args from file */
char *arg_ptrs[MAX_ARGS];
int arg_count;
FILE *argfile;
int len;
char *p=ab_ptr,c;
if ((argfile=fopen(*argv+1,"rt"))==0) perror_exit(10,*argv+1);
if ((len=fread(ab_ptr,1,ARGBUF_SIZE-((int) (ab_ptr-arg_buf)),argfile))==ARGBUF_SIZE-(ab_ptr-arg_buf)) error_exit(20,"Argument buffer not big enough\n");
fclose(argfile);
ab_ptr[len++]=0; /* write terminating null */
/* remove comments */
while ((p=strchr(ab_ptr,';'))!=NULL) {
char *p2=strchr(p,'\n');
if (p2) { /* found cr */
strcpy(p,p2); /* copy over comment */
len = strlen(ab_ptr);
}
else { /* no cr, end of string */
*p=0;
len = (int) (p-ab_ptr);
}
}
ab_ptr[len]=0; /* write terminating null */
while (!ab_ptr[len-1]) len--; /* back up over terminating nulls */
p=ab_ptr;
for (arg_count=0;p<ab_ptr+len;) {
while (p<ab_ptr+len && ((c=*p)==' ' || c=='\t' || c=='\n')) p++;
if (p<ab_ptr+len) { /* found parm? */
arg_ptrs[arg_count++]=p;
if (arg_count>=MAX_ARGS) error_exit(10,"Too many args");
while (p<ab_ptr+len && !((c=*p)==' ' || c=='\t' || c=='\n')) p++;
*p++=0;
}
}
ab_ptr+=len;
parse_args(arg_count,arg_ptrs,handler_func,flags);
}
else
if (flags&PA_EXPAND && (**argv != '-')) {
struct find_t ffblk;
char drive[_MAX_DRIVE],dir[_MAX_DIR];
char filename[_MAX_DRIVE+_MAX_DIR+13],*nptr;
int done;
_splitpath(*argv,drive,dir,NULL,NULL); //get path
strcpy(filename,drive);
strcat(filename,dir);
nptr = filename + strlen(filename); //point at name part
done = _dos_findfirst(*argv,0,&ffblk);
if (done) handler_func(*argv);
else while (!done) {
strcpy(nptr,ffblk.name); //copy name after path
handler_func(filename);
done = _dos_findnext(&ffblk);
}
}
else
handler_func(*argv);
}
}
