void __wrap_free(void *addr) {
if (EarlyMallocEnabled) {
early_free(addr);
}
enter_kernel();
__real_free(addr);
leave_kernel();
}
void *__wrap_malloc(size_t size) {
if (EarlyMallocEnabled) {
return early_malloc(size);
}
enter_kernel();
void *mem = __real_malloc(size);
leave_kernel();
return mem;
}
/**
* @brief The calling task terminates itself.
*/
void Task_Terminate()
{
uint8_t sreg;
sreg = SREG;
Disable_Interrupt();
kernel_request = TASK_TERMINATE;
enter_kernel();
SREG = sreg;
}
/**
* @brief The calling task gives up its share of the processor voluntarily.
*/
void Task_Next()
{
uint8_t volatile sreg;
sreg = SREG;
Disable_Interrupt();
kernel_request = TASK_NEXT;
enter_kernel();
SREG = sreg;
}
static int
elf64_exec(struct preloaded_file *fp)
{
struct file_metadata *md;
Elf_Ehdr *hdr;
struct ia64_pte pte;
struct bootinfo *bi;
if ((md = file_findmetadata(fp, MODINFOMD_ELFHDR)) == NULL)
return(EFTYPE); /* XXX actually EFUCKUP */
hdr = (Elf_Ehdr *)&(md->md_data);
/*
* Ugly hack, similar to linux. Dump the bootinfo into a
* special page reserved in the link map.
*/
bi = &bootinfo;
bzero(bi, sizeof(struct bootinfo));
bi_load(bi, fp);
/*
* Region 6 is direct mapped UC and region 7 is direct mapped
* WC. The details of this is controlled by the Alt {I,D}TLB
* handlers. Here we just make sure that they have the largest
* possible page size to minimise TLB usage.
*/
ia64_set_rr(IA64_RR_BASE(6), (6 << 8) | (28 << 2));
ia64_set_rr(IA64_RR_BASE(7), (7 << 8) | (28 << 2));
bzero(&pte, sizeof(pte));
pte.pte_p = 1;
pte.pte_ma = PTE_MA_WB;
pte.pte_a = 1;
pte.pte_d = 1;
pte.pte_pl = PTE_PL_KERN;
pte.pte_ar = PTE_AR_RWX;
pte.pte_ppn = 0;
__asm __volatile("mov cr.ifa=%0" :: "r"(IA64_RR_BASE(7)));
__asm __volatile("mov cr.itir=%0" :: "r"(28 << 2));
__asm __volatile("srlz.i;;");
__asm __volatile("itr.i itr[%0]=%1;;"
:: "r"(0), "r"(*(u_int64_t*)&pte));
__asm __volatile("srlz.i;;");
__asm __volatile("itr.d dtr[%0]=%1;;"
:: "r"(0), "r"(*(u_int64_t*)&pte));
__asm __volatile("srlz.i;;");
enter_kernel(fp->f_name, hdr->e_entry, bi);
}
static int
elf64_exec(struct preloaded_file *fp)
{
struct file_metadata *md;
Elf_Ehdr *hdr;
pt_entry_t pte;
uint64_t bi_addr;
md = file_findmetadata(fp, MODINFOMD_ELFHDR);
if (md == NULL)
return (EINVAL);
hdr = (Elf_Ehdr *)&(md->md_data);
bi_load(fp, &bi_addr);
printf("Entering %s at 0x%lx...\n", fp->f_name, hdr->e_entry);
ldr_enter(fp->f_name);
__asm __volatile("rsm psr.ic|psr.i;;");
__asm __volatile("srlz.i;;");
/*
* Region 6 is direct mapped UC and region 7 is direct mapped
* WC. The details of this is controlled by the Alt {I,D}TLB
* handlers. Here we just make sure that they have the largest
* possible page size to minimise TLB usage.
*/
ia64_set_rr(IA64_RR_BASE(6), (6 << 8) | (28 << 2));
ia64_set_rr(IA64_RR_BASE(7), (7 << 8) | (28 << 2));
pte = PTE_PRESENT | PTE_MA_WB | PTE_ACCESSED | PTE_DIRTY |
PTE_PL_KERN | PTE_AR_RWX | PTE_ED;
__asm __volatile("mov cr.ifa=%0" :: "r"(IA64_RR_BASE(7)));
__asm __volatile("mov cr.itir=%0" :: "r"(28 << 2));
__asm __volatile("ptr.i %0,%1" :: "r"(IA64_RR_BASE(7)), "r"(28<<2));
__asm __volatile("ptr.d %0,%1" :: "r"(IA64_RR_BASE(7)), "r"(28<<2));
__asm __volatile("srlz.i;;");
__asm __volatile("itr.i itr[%0]=%1;;" :: "r"(0), "r"(pte));
__asm __volatile("srlz.i;;");
__asm __volatile("itr.d dtr[%0]=%1;;" :: "r"(0), "r"(pte));
__asm __volatile("srlz.i;;");
enter_kernel(hdr->e_entry, bi_addr);
/* NOTREACHED */
return (0);
}
int8_t Task_Create_RR(void (*f)(void), int16_t arg) {
int retval;
uint8_t sreg;
sreg = SREG;
Disable_Interrupt();
kernel_request_create_args.f = (voidfuncvoid_ptr)f;
kernel_request_create_args.arg = arg;
kernel_request_create_args.level = RR;
kernel_request = TASK_CREATE;
enter_kernel();
retval = kernel_request_retval;
SREG = sreg;
return retval;
}
/**
* \param f a parameterless function to be created as a process instance
* \param arg an integer argument to be assigned to this process instance
* \param period its execution period in TICKs
* \param wcet its worst-case execution time in TICKs, must be less than "period"
* \param start its start time in TICKs
* \return 0 if not successful; otherwise non-zero.
* \sa Task_GetArg()
*
* A new process is created to execute the parameterless
* function \a f with an initial parameter \a arg, which is retrieved
* by a call to Task_GetArg(). If a new process cannot be
* created, 0 is returned; otherwise, it returns non-zero.
*
* \sa \ref policy
*/
int8_t Task_Create_Periodic(void(*f)(void), int16_t arg, uint16_t period, uint16_t wcet, uint16_t start) {
int retval;
uint8_t sreg;
sreg = SREG;
Disable_Interrupt();
kernel_request_create_args.f = (voidfuncvoid_ptr)f;
kernel_request_create_args.arg = arg;
kernel_request_create_args.level = (uint8_t)PERIODIC;
kernel_request_create_args.period = period;
kernel_request_create_args.wcet = wcet;
kernel_request_create_args.start = start;
kernel_request = TASK_CREATE;
enter_kernel();
retval = kernel_request_retval;
SREG = sreg;
return retval;
}
int main() {
struct memory_image image;
void *p;
printf("milestone 2 loader\n");
image_complete();
image_dump_stats();
write32(2, 0x48200010);
while(!(read32(0x48200014)&1));
if (image_find(IMG_LINUX, &image) != NULL)
{
printf("ARCH_NUBMBER[%d], KERNEL_DEST[%d]\n", ARCH_NUMBER, KERNEL_DEST);
enter_kernel(0, ARCH_NUMBER, atag_build(), KERNEL_DEST);
} else
{
critical_error(IMG_NOT_PROVIDED);
}
return 0;
}
