예제 #1
0
파일: main.c 프로젝트: BreezeWu/okl4_3.0
static void
waiting_notify_thread(void *arg)
{
    L4_Word_t notifybits;
    L4_MsgTag_t tag;
    L4_Word_t mask;

    tag = L4_Receive(main_tid);
    notifybits = L4_Label(tag);
    L4_Set_NotifyMask(notifybits);
    L4_Accept(L4_NotifyMsgAcceptor);
    L4_LoadMR(0, 0);
    L4_Send(main_tid);
    tag = L4_WaitNotify(&mask);
    if (L4_IpcFailed(tag)) {
        FAILED();
        return;
    }

    L4_Set_Label(&tag, notifybits);
    L4_Set_MsgTag(tag);
    L4_Call(main_tid);

    while (1) { }
}
예제 #2
0
파일: mutex.c 프로젝트: BruceYi/okl4
static void
lock_mutex_thread(void)
{
    L4_MsgTag_t tag;
    L4_Word_t label;
    L4_Word_t res;

    tag = L4_Receive(main_thread);
    while (1) {
        label = L4_Label(tag);
        if (label == 0xa) {
            res = L4_Lock(m);
            fail_unless(res == 1, "L4_Lock() failed");
            L4_Unlock(m);
        }
        if (label == 0xb) {
            res = L4_TryLock(m);
            fail_unless(res == 0, "L4_TryLock() did not fail");
            fail_unless(L4_ErrorCode() == L4_ErrMutexBusy, "Wrong error code");
        }

        tag = L4_Call(main_thread);
    }

    L4_WaitForever();
}
예제 #3
0
static void
measure_effective_prio(L4_Word_t expect_prio)
{
    L4_Word_t label, prio;
    L4_ThreadId_t any_thread;
    L4_MsgTag_t tag;

    prio = 9;
    do {
        prio--;
        L4_Set_Priority(measure_thread, prio);
        tag = L4_Wait(&any_thread);
        label = L4_Label(tag);
    } while ((label != 0x1) && (prio > 1));
    _fail_unless(prio == expect_prio, __FILE__, __LINE__, "Wrong effective priority: %lu", prio);
}
예제 #4
0
static void
runnable_main_thread(void)
{
    L4_Word_t result, label;
    L4_MsgTag_t tag;

    label = 0;
    result = L4_Lock(mutex1);
    fail_unless(result == 1, "L4_Lock() failed");
    while (1) {
        if (label == 0x3) {
            L4_Unlock(mutex1);
        }
        tag = L4_Make_MsgTag(0x1, 0);
        L4_Set_MsgTag(tag);
        L4_Send(setup_thread);
        tag = L4_Receive(setup_thread);
        label = L4_Label(tag);
    }
}
예제 #5
0
파일: message_wait.c 프로젝트: BruceYi/okl4
int
okl4_message_wait(void *recv_buff, okl4_word_t recv_buff_size,
        okl4_word_t *recv_bytes, okl4_kcap_t *reply_cap)
{
    L4_MsgTag_t tag;
    L4_ThreadId_t from;
    okl4_word_t bytes_received;

    /* Ensure buffer is word-aligned. */
    assert((okl4_word_t)recv_buff % sizeof(okl4_word_t) == 0);

    /* Perform the wait. */
    L4_Set_NotifyMask(0);
    tag = L4_Wait(&from);
    if (!L4_IpcSucceeded(tag)) {
        return _okl4_message_errno(tag, L4_ErrorCode());
    }

    /* Determine the number of words received, which is in the label. */
    bytes_received = L4_Label(tag);

    /* Ensure that the number of bytes the message claims to contain is roughly
     * the same as the number of words we received. */
    assert(ROUND_UP(bytes_received, sizeof(okl4_word_t))
            == L4_UntypedWords(tag) * sizeof(okl4_word_t));

    /* Copy to the buffer. */
    _okl4_message_copy_mrs_to_buff(recv_buff,
            min(recv_buff_size, bytes_received));

    /* Give parameters back to the caller. */
    if (recv_bytes != NULL) {
        *recv_bytes = bytes_received;
    }
    if (reply_cap != NULL) {
        *reply_cap = from;
    }

    return OKL4_OK;
}
예제 #6
0
static void
sending_thread(void)
{
    L4_Word_t result;
    L4_MsgTag_t tag;

    if (L4_UserDefinedHandle()) {
        result = L4_Lock(mutex2);
        fail_unless(result == 1, "L4_Lock() failed");
    }
    L4_LoadMR(0, 0);
    L4_Send(main_thread);

    tag = L4_Receive(setup_thread);
    if (L4_Label(tag) == 0x3) {
        L4_Unlock(mutex2);
        L4_LoadMR(0, 0);
        L4_Send(main_thread);
    }
    L4_WaitForever();
    while(1) ;
}
예제 #7
0
파일: mutex.c 프로젝트: BruceYi/okl4
static void
create_delete_mutex_thread(void)
{
    L4_MsgTag_t tag;
    L4_Word_t label;
    L4_Word_t res;

    tag = L4_Receive(main_thread);
    label = L4_Label(tag);

    if (label == 0xc) {
        res = L4_CreateMutex(m);
        fail_unless(res == 0, "L4_CreateMutex() did not fail");
        fail_unless(L4_ErrorCode() == L4_ErrInvalidSpace, "Wrong error code on create");
    }
    if (label == 0xd) {
        res = L4_DeleteMutex(m);
        fail_unless(res == 0, "L4_DeleteMutex() did not fail");
        fail_unless(L4_ErrorCode() == L4_ErrInvalidSpace, "Wrong error code on delete");
    }

    L4_Call(main_thread);
    L4_WaitForever();
}
예제 #8
0
int
main(int argc, char **argv)
{
    struct okl4_libmutex rm;
    L4_ThreadId_t tid;
    int i, max_iteration, eg_num, server_on;
    L4_Word_t me;
    L4_MsgTag_t tag = L4_Niltag;

    /*** Initialisation ***/
    pi_main = thread_l4tid(env_thread(iguana_getenv("MAIN")));
    me = pi_main.raw;
    eg_num = max_iteration = server_on = 0;
    if (argc == 3) {
        eg_num = atoi(argv[0]);
        max_iteration = atoi(argv[1]);
        server_on = atoi(argv[2]);
    } else {
        printf("(%s 0x%lx) Error: Argument(s) missing!\n", test_name, me);
        return 1;
    }
    resource_mutex = &rm;
    okl4_libmutex_init(resource_mutex);
    high_prio_thread = medium1_prio_thread = medium2_prio_thread = medium3_prio_thread = low_prio_thread = L4_nilthread;

    high_prio_thread = thread_l4tid(env_thread(iguana_getenv("MIXED_PI_HIGH")));
    medium3_prio_thread = thread_l4tid(env_thread(iguana_getenv("MIXED_PI_INTERMEDIATE_2")));
    medium2_prio_thread = thread_l4tid(env_thread(iguana_getenv("MIXED_PI_MEDIUM")));
    medium1_prio_thread = thread_l4tid(env_thread(iguana_getenv("MIXED_PI_INTERMEDIATE_1")));
    low_prio_thread = thread_l4tid(env_thread(iguana_getenv("MIXED_PI_LOW")));

    // Tell other threads that it is safe to use libraries
    libs_ready = 1;

    if (!server_on)
        printf("Start %s test #%d(0x%lx)\n", test_name, eg_num, me);
    /*** Start test ***/
    scenario1 = 1;
    for (i = 0; i < 2 * max_iteration; i++) {
        // Wait for threads to be ready
        tag = L4_Wait(&tid);
        // If one thread had a problem while initialisation, then stop the test and notify
        // server that the test is dead.
        if (L4_Label(tag) == 0xdead) {
            rtos_init();
            test_died(test_name, eg_num);
            rtos_cleanup();
            return 1;
        }
        // Tell high prio thread to start the next iteration.
        L4_LoadMR(0, 0);
        tag = L4_Send(high_prio_thread);
        stop_spinning = 0;
        // Wait for the iteration to finish.
        L4_Receive(high_prio_thread);
        stop_spinning = 1;
        // If end of iterations for scenario1, then report results to RTOS server if server is on.
        if (i == (max_iteration - 1)) {
            if (server_on) {
                rtos_init();
                mixed_priority_inversion_results(eg_num, 1, max_iteration, cnt_h, cnt_m1, cnt_m2, cnt_l, cnt_i1, cnt_i2);
            } else 
                print_metrics(max_iteration);
            // Start scenario2
            cnt_h = cnt_m1 = cnt_m2 = cnt_l = cnt_i1 = cnt_i2 = 0;
            scenario1 = 0;
            scenario2 = 1;
        }
    }
    /*** Test finished ***/
    thread_delete(medium1_prio_thread);
    thread_delete(medium3_prio_thread);
    thread_delete(high_prio_thread);
    thread_delete(medium2_prio_thread);
    thread_delete(low_prio_thread);

    /* Clean up allocated mutexes. */
    okl4_libmutex_free(resource_mutex);

    // If RTOS server is on, report results to it.
    if (server_on) {
        mixed_priority_inversion_results(eg_num, 2, max_iteration, cnt_h, cnt_m1, cnt_m2, cnt_l, cnt_i1, cnt_i2);
        rtos_cleanup();
    } else {
        print_metrics(max_iteration);
        printf("%s test #%d(0x%lx) finished\n", test_name, eg_num, me);
    }

    return 0;
}
예제 #9
0
int
main(int argc, char **argv)
{
    int i, tmp, eg_num, nb_philosophers, nb_dinners, server_on;
    L4_ThreadId_t *philo_tids;
    L4_ThreadId_t tid, any_thread;
    L4_MsgTag_t tag = L4_Niltag;

    /*** Initialisation ***/
    dp_main = thread_l4tid(env_thread(iguana_getenv("MAIN")));
    eg_num = nb_philosophers = nb_dinners = server_on = 0;
    if (argc == 3) {
        eg_num = atoi(argv[0]);
        nb_philosophers = atoi(argv[1]);
        server_on = atoi(argv[2]);
    } else {
        printf("(%s 0x%lx) Error: Argument(s) missing!\n", test_name, dp_main.raw);
        return 1;
    }
    if (!server_on)
        printf("Start %s test #%d(0x%lx): %d philosophers\n", test_name, eg_num, dp_main.raw, nb_philosophers);
    chopstick = malloc((nb_philosophers + 1) * sizeof(okl4_libmutex_t));
    philo_tids = malloc(nb_philosophers * sizeof(L4_ThreadId_t));
    for (i = 0; i < nb_philosophers; i++) {
        chopstick[i] = malloc (sizeof(struct okl4_libmutex));
        okl4_libmutex_init(chopstick[i]);
    }
    chopstick[nb_philosophers] = NULL;
    // Tell other threads that it is safe to use libraries and mutexes
    libs_ready = 1;

    // Retrieve philosophers thread Ids and give them a go
    for (i = 0; i < nb_philosophers; i++) {
        L4_Wait(&tid);
        philo_tids[i] = tid;
    }

    /*** Start test ***/
    meal_served = 1;
    tmp = nb_philosophers;
    while (tmp) {
        tag = L4_Wait(&any_thread);
        for (i = 0; i < nb_philosophers; i++) {
            if (any_thread.raw == philo_tids[i].raw) {
                thread_delete(any_thread);
                tmp--;
                if (L4_Label(tag) == 0xfed) {
                    // Philosopher finished eating
                    nb_dinners++;
                }
                break;
            }
        }
    }

    /*** Test finished ***/
    free(philo_tids);
    for (i = 0; i < nb_philosophers; i++) {
        okl4_libmutex_free(chopstick[i]);
        free(chopstick[i]);
    }
    //free(*chopstick);
    // If RTOS server is on, report results to it.
    if (server_on) {
        rtos_init();
        dining_philosophers_results(eg_num, nb_philosophers, nb_dinners);
        rtos_cleanup();
    }
    else
        printf("%s test #%d(0x%lx) finished\n", test_name, eg_num, dp_main.raw);

    return 0;
}
예제 #10
0
파일: bench_ipc.c 프로젝트: hro424/okl4-sh
static void
pager (void)
{
    L4_ThreadId_t tid;
    L4_MsgTag_t tag;
    L4_Msg_t msg;
    int count = 0;

    for (;;) {
        tag = L4_Wait(&tid);

        for (;;) { 
            L4_Word_t faddr, fip;
            L4_MsgStore(tag, &msg);

            if (L4_Label(tag) == START_LABEL) {
                // Startup notification, start ping and pong thread
                void (*start_addr)(void);
                void (*pong_start_addr)(void);
                L4_Word_t *pong_stack_addr = pong_stack;
                if (pagertimer) {
                    start_addr = ping_thread_pager;
                } else if (pagertimer_simulated) {
                    start_addr = ping_thread_simulated;
                } else if (fass_buffer) {
                    start_addr = ping_thread_buffer;
                } else if (fault_test) {
                    count = 0;
                    start_addr = NULL;
                } else if (intra_close) {
                    start_addr = ping_thread_close;
                } else if (intra_open) {
                    start_addr = ping_thread_open;
                } else if (intra_rpc) {
                    start_addr = ping_thread_rpc_server;
                } else if (intra_ovh) {
                    start_addr = ping_thread_ovh;
                } else if (intra_async) {
                    start_addr = ping_thread_async;
                } else if (intra_async_ovh) {
                    start_addr = ping_thread_async_ovh;
                } else {
                    start_addr = ping_thread;
                }

                if (start_addr != NULL) {
                    /*printf("ping_start_addr: %lx ping_stack_addr: %lx\n",
                           START_ADDR (start_addr), (L4_Word_t) ping_stack);*/
                    send_startup_ipc (ping_tid,
                              START_ADDR(start_addr),
                              (L4_Word_t) ping_stack +
                              sizeof (ping_stack) - 32);
                    L4_ThreadSwitch(ping_tid);
                }

                if (fass_buffer) {
                    pong_start_addr = pong_thread_buffer;
                    pong_stack_addr = pong_stack_fass;
                } else if (fass) {
                    pong_start_addr = pong_thread_fass;
                    pong_stack_addr = pong_stack_fass;
                } else if (fault_test) {
                    pong_stack_addr = pong_stack_fass;
                    pong_start_addr = pong_thread_faulter;
                } else if (intra_close) {
                    pong_start_addr = pong_thread_close;
                } else if (intra_open) {
                    pong_start_addr = pong_thread_open;
                } else if (intra_rpc) {
                    pong_start_addr = pong_thread_close;
                } else if (intra_ovh) {
                    pong_start_addr = pong_thread_ovh;
                } else if (intra_async) {
                    pong_start_addr = pong_thread_async;
                } else if (intra_async_ovh) {
                    pong_start_addr = pong_thread_async_ovh;
                } else {
                    pong_start_addr = pong_thread;
                }

                if (!pagertimer) {
                    /*printf("pong_start_addr: %lx pong_stack_addr: %lx\n",
                           START_ADDR (pong_start_addr), (L4_Word_t) pong_stack_addr);*/
                    L4_Set_Priority(ping_tid, 100);
                    L4_Set_Priority(pong_tid, 99);
                    send_startup_ipc (pong_tid, 
                              START_ADDR (pong_start_addr),
                              (L4_Word_t) pong_stack_addr + sizeof (ping_stack) - 32);
                }
                break;
            }


            if (L4_UntypedWords (tag) != 2 ||
                !L4_IpcSucceeded (tag)) {
                printf ("pingpong: malformed pagefault IPC from %p (tag=%p)\n",
                    (void *) tid.raw, (void *) tag.raw);
                L4_KDB_Enter ("malformed pf");
                break;
            }

            faddr = L4_MsgWord(&msg, 0);
            fip   = L4_MsgWord (&msg, 1);
            L4_MsgClear(&msg);

            if (fault_test && (faddr == (uintptr_t) fault_area)) {
                if (count < num_iterations) {
                    count++;
                } else {
                    /* Tell master that we're finished */
                    L4_Set_MsgTag (L4_Niltag);
                    L4_Send (master_tid);
                    break;
                }
            } else {
                L4_MapItem_t map;
                L4_SpaceId_t space;
                L4_Word_t seg, offset, cache, rwx, size;
                int r;

                seg = get_seg(KBENCH_SPACE, faddr, &offset, &cache, &rwx);
                //if can not find mapping, must be page fault test,
                //just map any valid address, since fault address is dummy.
                if (seg == ~0UL)
                    seg = get_seg(KBENCH_SPACE, (L4_Word_t) fault_area,
                                  &offset, &cache, &rwx);

                if (tid.raw == ping_th.raw)
                    space = ping_space;
                else if (tid.raw == pong_th.raw)
                {
                    if (pong_space.raw != L4_nilspace.raw)
                        space = pong_space;
                    else //pong_space is not created, only ping_space is used.
                        space = ping_space;
                }
                else
                    space = KBENCH_SPACE;

                size = L4_GetMinPageBits();
                faddr &= ~((1ul << size)-1);
                offset &= ~((1ul << size)-1);

                L4_MapItem_Map(&map, seg, offset, faddr, size,
                               cache, rwx);
                r = L4_ProcessMapItem(space, map);
                assert(r == 1);
            }
            L4_MsgLoad(&msg);
            tag = L4_ReplyWait (tid, &tid);
        }
    }
}
예제 #11
0
파일: pager.c 프로젝트: gapry/aos-1
/*
 * Function invoked by roottask on pagefault
 */
int
pager(L4_ThreadId_t tid, L4_Msg_t *msgP)
{
    send = 1;
    // Get the faulting address
    L4_Word_t addr = L4_MsgWord(msgP, 0);
    L4_Word_t physicalAddress = 0;
    L4_Word_t permission = 0;
    L4_MsgTag_t tag;
    // Alignment
    addr = (addr / PAGESIZE)*PAGESIZE;
    tag = L4_MsgMsgTag(msgP);
    L4_Word_t access_type = L4_Label(tag) & 0x07;

    //printf("pager invoked addr=%lx by %lx %lx for access 0x%lx\n", addr,L4_ThreadNo(tid),tid.raw,access_type);

    // Construct fpage IPC message
    L4_Fpage_t targetFpage = L4_FpageLog2(addr, 12);
    
    if(VIRTUAL(addr)) 
    {
      if(addr >= BASE_CODE_SEGMENT_ADDRESS) {
	//Code segment
	int inPage = isInPage(tid,targetFpage);
	if(inPage == -1) {
	  //It should be in page table so this should not happen
	  printf("Panic !!! Cannot load the code segment");
	} else {
	  physicalAddress = new_low + inPage*PAGESIZE;
	  permission = L4_FullyAccessible;
	}
      } else {
	//Heap and stack
    	int inPage = isInPage(tid, targetFpage);
    	if (inPage == -1)
    	{
	  //We need to check if the page is in swap
	    inPage = isInSwap(tid,targetFpage);
	    mapAddress(tid, targetFpage,inPage);
	    //We dont need to map any addresses here as mapAddresses maps the addresses
	    return send;
    	} else {
    	    physicalAddress = new_low+inPage*PAGESIZE;
	    targetFpage = page_table[inPage].pageNo;
	    page_table[inPage].referenced = 1;
	    if(access_type & L4_Writable) {
	      //We now need to set the dirty bit and provide read write access
	      page_table[inPage].dirty = 1;
	      permission = L4_ReadWriteOnly;
	    } else {
	      permission = L4_Readable;
	    }
    	}
    	
      }
    } else {
        // we need to map physical addresses 1:1
        physicalAddress = addr;
        if(addr < new_low) {
	        // This is beyond the low memory range ie the page table
	        // and some other addresses which is below the low range
	        permission = L4_FullyAccessible;
        } else {
	        // This would be the code segment between the new_low and high
	        permission = L4_Readable;
        }
    } 
    
    L4_Set_Rights(&targetFpage,permission);
    L4_PhysDesc_t phys = L4_PhysDesc(physicalAddress, L4_DefaultMemory);

    if ( !L4_MapFpage(tid, targetFpage, phys) ) {
        sos_print_error(L4_ErrorCode());
        printf(" Can't map page at %lx\n", addr);
    }
    return send;
}
예제 #12
0
파일: main.c 프로젝트: BreezeWu/okl4_3.0
/*
 * Get current value, request timeout for different threads, check all notified
 * correctly.
 */
static void
test02(void)
{
    uint32_t cur_value;
    L4_Word_t result, i;
    thread_ref_t thread1, thread2, thread3;
    L4_ThreadId_t tid1, tid2, tid3, any_thread;
    L4_Word_t notifybits1 = 0x1;
    L4_Word_t notifybits2 = 0x2;
    L4_Word_t notifybits3 = 0x3;
    L4_MsgTag_t tag;
    L4_Word_t label;    

    printf("%s: ", __func__);

    thread1 = thread_create_simple(waiting_notify_thread, NULL, 99);
    thread2 = thread_create_simple(waiting_notify_thread, NULL, 99);
    thread3 = thread_create_simple(waiting_notify_thread, NULL, 99);
    tid1 = thread_l4tid(thread1);
    tid2 = thread_l4tid(thread2);
    tid3 = thread_l4tid(thread3);
    tag = L4_Make_MsgTag(notifybits1, 0);
    L4_Set_MsgTag(tag);
    tag = L4_Call(tid1);
    tag = L4_Make_MsgTag(notifybits2, 0);
    L4_Set_MsgTag(tag);
    tag = L4_Call(tid2);
    tag = L4_Make_MsgTag(notifybits3, 0);
    L4_Set_MsgTag(tag);
    tag = L4_Call(tid3);

    result = counter_current_value(&cur_value);
    if (result == 0) {
        FAILED();
        return;
    }
    result = counter_request(cur_value + 10, tid1, notifybits1);
    if (result == 0) {
        FAILED();
        return;
    }
    result = counter_request(cur_value + 12, tid2, notifybits2);
    if (result == 0) {
        FAILED();
        return;
    }
    result = counter_request(cur_value + 14, tid3, notifybits3);
    if (result == 0) {
        FAILED();
        return;
    }

    for (i = 0; i < 3; i++) {
        tag = L4_Wait(&any_thread);
        label = L4_Label(tag);
        if (((i == 0) && (label != 0x1)) ||
            ((i == 1) && (label != 0x2)) ||
            ((i == 2) && (label != 0x3))) {
            thread_delete(tid1);
            thread_delete(tid2);
            thread_delete(tid3);
            FAILED();
            return;
        }
    }

    thread_delete(tid1);
    thread_delete(tid2);
    thread_delete(tid3);

    PASSED();
}