/* Test program for the audio device. mmap()s the stuff, sets up a notif
* handler, and switches to multi_mode.
*
* Note: this has a lot of mhello-like MCP infrastructure. When Lithe is
* working, you won't need any of this. Just the mmap stuff and the notif
* handler. Stuff specific to the ethernet audio device is marked ETH_AUD. */
int main()
{
int retval;
int in_fd, out_fd;
/* ETHAUD mmap the input and output buffers */
in_fd = open("/dev/eth_audio_in", O_RDONLY);
out_fd = open("/dev/eth_audio_out", O_RDWR);
assert(in_fd != -1);
assert(out_fd != -1);
in_buf = mmap(0, PGSIZE, PROT_READ, 0, in_fd, 0);
if (in_buf == MAP_FAILED) {
int err = errno;
perror("Can't mmap the input buf:");
}
out_buf = mmap(0, PGSIZE, PROT_READ | PROT_WRITE, MAP_POPULATE, out_fd, 0);
if (out_buf == MAP_FAILED) {
int err = errno;
perror("Can't mmap the output buf:");
}
//strncpy(out_buf, "Nanwan loves you!\n", 19);
/* begin: stuff userspace needs to do before switching to multi-mode */
vcore_init();
/* ETHAUD Turn on Free apple pie (which is the network packet) */
enable_kevent(EV_FREE_APPLE_PIE, 0, EVENT_IPI);
/* Need to save this somewhere that you can find it again when restarting
* core0 */
core0_tls = get_tls_desc(0);
/* Need to save our floating point state somewhere (like in the
* user_thread_tcb so it can be restarted too */
/* end: stuff userspace needs to do before switching to multi-mode */
/* ETHAUD */
/* Switch into _M mode */
retval = vcore_request(1);
/* Stay alive for a minute (will take interrupts) */
udelay(60000000);
printf("Eth aud, finishing up!\n");
/* Need to do unmap it, due to some limitations in the kernel */
munmap(in_buf, PGSIZE);
munmap(out_buf, PGSIZE);
close(in_fd);
close(out_fd);
}
/**
* Initialize the vcores, including jumping into muticore mode.
**/
void vcore_startup()
{
/* Initilize the bootstrap code for using the vcores */
if (vcore_init())
printf("vcore_init() failed, we're f****d!\n");
assert(vcore_id() == 0);
/* Tell the kernel where and how we want to receive events. This is just an
* example of what to do to have a notification turned on. We're turning on
* USER_IPIs, posting events to vcore 0's vcpd, and telling the kernel to
* send to vcore 0. Note sys_self_notify will ignore the vcoreid pref.
* Also note that enable_kevent() is just an example, and you probably want
* to use parts of event.c to do what you want. */
enable_kevent(EV_USER_IPI, 0, EVENT_IPI);
/* Don't forget to enable notifs on vcore0. if you don't, the kernel will
* restart your _S with notifs disabled, which is a path to confusion. */
struct preempt_data *vcpd = &__procdata.vcore_preempt_data[0];
vcpd->notif_enabled = TRUE;
/* Grab a reference to the main_thread on the current stack (i.e.
* current_thread, since we know this has been set up for us properly by
* the fact that the constructor calls main_thread_init() before this
* function. We will need this reference below. */
thread_t *t = current_thread;
/* Change temporarily to vcore0s tls region so we can save the main_thread
* into its thread local current_thread variable. One minor issue is that
* vcore0's transition-TLS isn't TLS_INITed yet. Until it is (right before
* vcore_entry(), don't try and take the address of any of its TLS vars. */
extern void** vcore_thread_control_blocks;
set_tls_desc(vcore_thread_control_blocks[0], 0);
current_thread = t;
set_tls_desc(t->context->tls_desc, 0);
/* Jump into multi-core mode! */
/* The next line of code that will run is inside vcore_entry(). When this
* thread is resumed, it will continue directly after this call to
* vcore_request() */
vcore_request(1);
}
/* Do whatever init you want. Return a uthread representing thread0 (int
* main()) */
struct uthread *pth_init(void)
{
struct mcs_lock_qnode local_qn = {0};
/* Tell the kernel where and how we want to receive events. This is just an
* example of what to do to have a notification turned on. We're turning on
* USER_IPIs, posting events to vcore 0's vcpd, and telling the kernel to
* send to vcore 0. Note sys_self_notify will ignore the vcoreid pref.
* Also note that enable_kevent() is just an example, and you probably want
* to use parts of event.c to do what you want. */
enable_kevent(EV_USER_IPI, 0, EVENT_IPI);
/* Handle syscall events. Using small ev_qs, with no internal ev_mbox. */
ev_handlers[EV_SYSCALL] = pth_handle_syscall;
/* Set up the per-vcore structs to track outstanding syscalls */
sysc_mgmt = malloc(sizeof(struct sysc_mgmt) * max_vcores());
assert(sysc_mgmt);
for (int i = 0; i < max_vcores(); i++) {
/* Set up each of the per-vcore syscall event queues so that they point
* to the VCPD/default vcore mailbox (for now) Note you'll need the
* vcore to be online to get the events (for now). */
sysc_mgmt[i].ev_q.ev_mbox = &__procdata.vcore_preempt_data[i].ev_mbox;
sysc_mgmt[i].ev_q.ev_flags = EVENT_IPI; /* totally up to you */
sysc_mgmt[i].ev_q.ev_vcore = i;
/* Init the list and other data */
TAILQ_INIT(&sysc_mgmt[i].pending_syscs);
sysc_mgmt[i].handling_overflow = FALSE;
}
/* Create a pthread_tcb for the main thread */
pthread_t t = (pthread_t)calloc(1, sizeof(struct pthread_tcb));
assert(t);
t->id = get_next_pid();
assert(t->id == 0);
/* Put the new pthread on the active queue */
mcs_lock_notifsafe(&queue_lock, &local_qn);
threads_active++;
TAILQ_INSERT_TAIL(&active_queue, t, next);
mcs_unlock_notifsafe(&queue_lock, &local_qn);
return (struct uthread*)t;
}
/* to trick uthread_create() */
int main(int argc, char** argv)
{
uint32_t vcoreid;
int retval;
/* Initialize our barrier. */
mcs_barrier_init(&b, max_vcores());
/* vcore_context test */
assert(!in_vcore_context());
/* prep indirect ev_q. Note we grab a big one */
indirect_q = get_eventq(EV_MBOX_UCQ);
indirect_q->ev_flags = EVENT_IPI;
indirect_q->ev_vcore = 1; /* IPI core 1 */
indirect_q->ev_handler = 0;
printf("Registering %08p for event type %d\n", indirect_q,
EV_FREE_APPLE_PIE);
register_kevent_q(indirect_q, EV_FREE_APPLE_PIE);
/* handle events: just want to print out what we get. This is just a
* quick set of handlers, not a registration for a kevent. */
for (int i = 0; i < MAX_NR_EVENT; i++)
register_ev_handler(i, handle_generic, 0);
/* Want to use the default ev_ev (which we just overwrote) */
register_ev_handler(EV_EVENT, handle_ev_ev, 0);
/* vcore_lib_init() done in vcore_request() now. */
/* Set up event reception. For example, this will allow us to receive an
* event and IPI for USER_IPIs on vcore 0. Check event.c for more stuff.
* Note you don't have to register for USER_IPIs to receive ones you send
* yourself with sys_self_notify(). */
enable_kevent(EV_USER_IPI, 0, EVENT_IPI | EVENT_VCORE_PRIVATE);
/* Receive pending preemption events. (though there's no PP handler) */
struct event_queue *ev_q = get_eventq_vcpd(0, EVENT_VCORE_PRIVATE);
ev_q->ev_flags = EVENT_IPI | EVENT_VCORE_APPRO;
register_kevent_q(ev_q, EV_PREEMPT_PENDING);
/* We also receive preemption events, it is set up in uthread.c */
/* Inits a thread for us, though we won't use it. Just a hack to get into
* _M mode. Note this requests one vcore for us */
struct uthread dummy = {0};
uthread_2ls_init(&dummy, &ghetto_sched_ops);
uthread_mcp_init();
/* Reset the blockon to be the spinner... This is really shitty. Any
* blocking calls after we become an MCP and before this will fail. This is
* just mhello showing its warts due to trying to work outside uthread.c */
ros_syscall_blockon = __ros_syscall_spinon;
if ((vcoreid = vcore_id())) {
printf("Should never see me! (from vcore %d)\n", vcoreid);
} else { // core 0
temp = 0xdeadbeef;
printf("Hello from vcore %d with temp addr = %p and temp = %p\n",
vcoreid, &temp, temp);
printf("Multi-Goodbye, world, from PID: %d!\n", sys_getpid());
printf("Requesting %d vcores\n", max_vcores() - 1);
retval = vcore_request(max_vcores() - 1); /* since we already have 1 */
//retval = vcore_request(5);
printf("This is vcore0, right after vcore_request, retval=%d\n", retval);
/* vcore_context test */
assert(!in_vcore_context());
}
//#if 0
/* test notifying my vcore2 */
udelay(5000000);
printf("Vcore 0 self-notifying vcore 2 with notif 4!\n");
struct event_msg msg;
msg.ev_type = 4;
sys_self_notify(2, 4, &msg, TRUE);
udelay(5000000);
printf("Vcore 0 notifying itself with notif 6!\n");
msg.ev_type = 6;
sys_notify(sys_getpid(), 6, &msg);
udelay(1000000);
//#endif
/* test loop for restarting a uthread_ctx */
if (vcoreid == 0) {
int ctr = 0;
while(1) {
printf("Vcore %d Spinning (%d), temp = %08x!\n", vcoreid, ctr++, temp);
udelay(5000000);
//exit(0);
}
}
printf("Vcore %d Done!\n", vcoreid);
//mcs_barrier_wait(&b,vcore_id());
printf("All Cores Done!\n", vcoreid);
while(1); // manually kill from the monitor
/* since everyone should cleanup their uthreads, even if they don't plan on
* calling their code or want uthreads in the first place. <3 */
uthread_cleanup(&dummy);
return 0;
}
int main(int argc, char** argv)
{
uint32_t vcoreid;
int retval;
mcs_barrier_init(&b, max_vcores());
/* vcore_context test */
assert(!in_vcore_context());
/* prep indirect ev_q. Note we grab a big one */
indirect_q = get_big_event_q();
indirect_q->ev_flags = EVENT_IPI;
indirect_q->ev_vcore = 1; /* IPI core 1 */
indirect_q->ev_handler = 0;
printf("Registering %08p for event type %d\n", indirect_q,
EV_FREE_APPLE_PIE);
register_kevent_q(indirect_q, EV_FREE_APPLE_PIE);
/* handle events: just want to print out what we get. This is just a
* quick set of handlers, not a registration for a kevent. */
for (int i = 0; i < MAX_NR_EVENT; i++)
ev_handlers[i] = handle_generic;
/* Want to use the default ev_ev (which we just overwrote) */
ev_handlers[EV_EVENT] = handle_ev_ev;
/* vcore_init() done in vcore_request() now. */
/* Set up event reception. For example, this will allow us to receive an
* event and IPI for USER_IPIs on vcore 0. Check event.c for more stuff.
* Note you don't have to register for USER_IPIs to receive ones you send
* yourself with sys_self_notify(). */
enable_kevent(EV_USER_IPI, 0, EVENT_IPI);
/* Receive pending preemption events. Can also get a MSG if you want. */
struct event_queue *ev_q = get_event_q();
ev_q->ev_flags = EVENT_IPI | EVENT_NOMSG | EVENT_VCORE_APPRO;
register_kevent_q(ev_q, EV_PREEMPT_PENDING);
/* Makes a thread for us, though we won't use it. Just a hack to get into
* _M mode. Note this requests one vcore for us */
uthread_create(dummy, 0);
if ((vcoreid = vcore_id())) {
printf("Should never see me! (from vcore %d)\n", vcoreid);
} else { // core 0
temp = 0xdeadbeef;
printf("Hello from vcore %d with temp addr = %p and temp = %p\n",
vcoreid, &temp, temp);
printf("Multi-Goodbye, world, from PID: %d!\n", sys_getpid());
//retval = sys_resource_req(RES_CORES, 2, 0);
printf("Requesting %d vcores\n", max_vcores() - 1);
retval = vcore_request(max_vcores() - 1); /* since we already have 1 */
//retval = vcore_request(5);
printf("This is vcore0, right after vcore_request, retval=%d\n", retval);
/* vcore_context test */
assert(!in_vcore_context());
}
/* test notifying my vcore2 */
udelay(5000000);
printf("Vcore 0 self-notifying vcore 2 with notif 4!\n");
struct event_msg msg;
msg.ev_type = 4;
sys_self_notify(2, 4, &msg);
udelay(5000000);
printf("Vcore 0 notifying itself with notif 3!\n");
msg.ev_type = 3;
sys_notify(sys_getpid(), 3, &msg);
udelay(1000000);
/* test loop for restarting a notif_tf */
if (vcoreid == 0) {
int ctr = 0;
while(1) {
printf("Vcore %d Spinning (%d), temp = %08x!\n", vcoreid, ctr++, temp);
udelay(5000000);
//exit(0);
}
}
printf("Vcore %d Done!\n", vcoreid);
//mcs_barrier_wait(&b,vcore_id());
printf("All Cores Done!\n", vcoreid);
while(1); // manually kill from the monitor
return 0;
}
