static void *logMsg_fun(void *args)
{
RT_TASK *buddy;
struct { int nch; FILE *fs; } type;
char msg[MAX_MSG_SIZE];
pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL);
if (!(buddy = rt_task_init_schmod(nam2num("LOGSRV"), 1, 0, 0, SCHED_FIFO, 0xFFFFFFFF))) {
printf("CANNOT INIT LOG MSG SERVER BUDDY TASK %p.\n", buddy);
return (void *)1;
}
rt_send(*(RT_TASK **)args, (unsigned int)buddy);
while (1) {
if (!rt_mbx_receive(logmbx, &type, sizeof(type)) && !rt_mbx_receive(logmbx, msg, type.nch)) {
if (type.fs) {
fprintf(type.fs, msg);
} else {
fprintf(stderr, msg);
fprintf(logfile, msg);
}
} else {
while(!rt_mbx_receive_wp(logmbx, msg, MAX_MSG_SIZE));
}
}
return (void *)0;
}
static void sup_fun(long none)
{
rt_printk("INTERRUPT MODULE STARTED\n");
while ((taskport = rt_request_port(tasknode)) <= 0);
rt_mbx_receive(&mbx, &run, sizeof(run));
rmt_task = RT_NET_ADR(taskport, run);
rt_mbx_receive(&mbx, &run, sizeof(run));
rmt_sem = RT_NET_ADR(taskport, run);
rt_mbx_receive(&mbx, &run, sizeof(run));
rt_mbx_receive(&mbx, &run, sizeof(run));
rt_release_port(tasknode, taskport);
rt_printk("ALL INTERRUPT MODULE FUNCTIONS TERMINATED\n");
}
/***
* do_stacktask
*/
static void do_stacktask(int mgr_id)
{
struct rtnet_msg msg;
struct rtnet_mgr *mgr = (struct rtnet_mgr *)mgr_id;
rt_printk("RTnet: stack-mgr started\n");
while(1) {
rt_mbx_receive(&(mgr->mbx), &msg, sizeof(struct rtnet_msg));
if ( (msg.rtdev) && (msg.msg_type==Rx_PACKET) ) {
while ( !rtskb_queue_empty(&msg.rtdev->rxqueue) ) {
struct rtskb *skb = rtskb_dequeue(&msg.rtdev->rxqueue);
if ( skb ) {
unsigned short hash = ntohs(skb->protocol) & (MAX_RT_PROTOCOLS-1);
struct rtpacket_type *pt = rt_packets[hash];
skb->nh.raw = skb->data;
if (pt) {
pt->handler (skb, skb->rtdev, pt);
} else {
rt_printk("RTnet: undefined Layer-3-Protokoll\n");
kfree_rtskb(skb);
}
}
}
}
}
}
static void bfun(long t)
{
unsigned long long msg;
unsigned long long name = 0xccccccccccccccccLL;
while (1) {
cpu_used[hard_cpu_id()]++;
msg = 0LL;
bstat = 'r';
rt_mbx_receive(&smbx, &msg, sizeof(msg));
if (msg == 0x1122334455667788LL) {
t = 0;
} else {
if (msg == 0x99aabbccddeeff00LL) {
t = 1;
} else {
rt_printk("SERVER RECEIVED AN UNKNOWN MSG: %x%x, STAT: %c %c %c.\n", ((int *)&msg)[1], ((int *)&msg)[0], mstat[0], mstat[1], bstat);
t = 0;
goto prem;
}
}
bstat = '0' + t;
rt_mbx_send(&rmbx[t], &name, sizeof(name));
}
prem:
premature = PREMATURE;
rt_printk("SERVER TASK ENDS PREMATURELY.\n");
}
void fun1(long t)
{
int msg;
if (t & 1) {
RT_PRINTK("TASK %d BLOCKS TIMED RECEIVING ON MBX\n", t);
RT_PRINTK("TASK %d UNBLOCKS RECEIVING ON MBX %d BYTES\n", t, rt_mbx_receive_timed(&mbx, &msg, sizeof(msg), 2000000000));
} else {
RT_PRINTK("TASK %d BLOCKS RECEIVING ON MBX\n", t);
RT_PRINTK("TASK %d UNBLOCKS RECEIVING ON MBX %d BYTES\n", t, rt_mbx_receive(&mbx, &msg, sizeof(msg)));
}
atomic_inc(&cleanup);
}
/*
* initialization task
*/
static void start_task_code(int notused)
{
int i;
char buf[9];
buf[8] = 0;
/* create the sync semaphore */
rt_sem_init(&sync_sem, 0);
/* create the priority-test semaphore */
rt_sem_init(&prio_sem, 0);
/* pass the semaphore to the first task */
rt_sem_signal(&sems[0]);
/* wait for each task to send the sync semaphore */
for (i = 0; i < NUM_TASKS; ++i) {
rt_sem_wait(&sync_sem);
}
rt_printk(sync_str);
/* post the priority-test semaphore -- the tasks should then run */
/* in priority order */
for (i = 0; i < NUM_TASKS; ++i) {
rt_sem_signal(&prio_sem);
}
rt_printk("\n");
for (i = 0; i < NUM_TASKS; ++i) {
rt_sem_wait(&sync_sem);
}
rt_printk(sync_str);
/* now, test message queues */
TAKE_PRINT;
rt_printk("testing message queues\n");
GIVE_PRINT;
for (i = 0; i < NUM_TASKS; ++i) {
if (rt_mbx_send(&mbx_in, strs[i], 8)) {
rt_printk("rt_mbx_send() failed\n");
}
}
for (i = 0; i < NUM_TASKS; ++i) {
rt_mbx_receive(&mbx_out, buf, 8);
TAKE_PRINT;
rt_printk("\nreceived from mbx_out: %s", buf);
GIVE_PRINT;
}
rt_printk("\n");
for (i = 0; i < NUM_TASKS; ++i) {
rt_sem_signal(&sync_sem);
}
TAKE_PRINT;
rt_printk("\ninit task complete\n");
GIVE_PRINT;
/* nothing more for this task to do */
}
/****
* Proxy txqueue wakeup manager.
*
* Waits blocking for a wakeup message in its mailbox and calls the rtdevice
* specific wakeup function (if one is registered) after a message arrived.
*/
void proxy_wakeup_manager_task (int mgr_id) {
struct rtnet_msg msg;
struct rtnet_mgr *mgr = (struct rtnet_mgr *)mgr_id;
rt_printk("RTnet: Proxy txqueue wakeup manager started. (%p)\n", rt_whoami());
while(1) {
rt_mbx_receive(&(mgr->mbx), &msg, sizeof(struct rtnet_msg));
if ((msg.msg_type==WAKEUP) && (msg.rtdev)) {
if (msg.rtdev->rt_wakeup_xmit) {
msg.rtdev->proxy_wakeup_xmit(msg.rtdev);
}
}
}
}
static void sup_fun(long none)
{
while (tasknode && (taskport = rt_request_hard_port(tasknode)) <= 0);
rt_mbx_receive(&mbx, &rmt_task, sizeof(rmt_task));
rt_mbx_receive(&mbx, &rmt_sem, sizeof(rmt_sem));
rt_mbx_receive(&mbx, &run, 1);
do {
rt_task_suspend(&sup_task);
switch(run) {
case 1: RT_sem_signal(tasknode, -taskport, rmt_sem);
break;
case 2:
RT_task_resume(tasknode, -taskport, rmt_task);
break;
case 3:
RT_send_if(tasknode, -taskport, rmt_task, run);
break;
}
} while (rt_mbx_receive_if(&mbx, &run, 1));
rt_release_port(tasknode, taskport);
rt_printk("ALL INTERRUPT MODULE FUNCTIONS TERMINATED\n");
}
int main(void)
{
RT_TASK *mytask;
MBX *Keyboard, *Screen;
unsigned int i;
char d = 'd';
char chain[12];
char displine[40] = "CLOCK-> 00:00:00 CHRONO-> 00:00:00";
signal(SIGINT, endme);
if (!(mytask = rt_task_init_schmod(nam2num("SCRTSK"), 20, 0, 0, SCHED_FIFO, 0xF))) {
printf("CANNOT INIT SCREEN TASK\n");
exit(1);
}
if (!(Keyboard = rt_get_adr(nam2num("KEYBRD")))) {
printf("CANNOT FIND KEYBOARD MAILBOX\n");
exit(1);
}
if (rt_mbx_send(Keyboard, &d, 1) > 0 ) {
fprintf(stderr, "Can't send initial command to RT-task\n");
exit(1);
}
if (!(Screen = rt_get_adr(nam2num("SCREEN")))) {
printf("CANNOT FIND SCREEN MAILBOX\n");
exit(1);
}
sleep(1);
printf("%s\n", displine);
while(1) {
if (rt_mbx_receive(Screen, chain, 12)) break;
if (chain[0] == 't') {
for (i = 0; i < 11; i++) {
displine[i+27] = chain[i+1];
}
} else if (chain[0] == 'h') {
for (i = 0; i < 8; i++) {
displine[i+8] = chain[i+1];
}
}
printf("%s\n", displine);
}
rt_task_delete(mytask);
return 0;
}
int main(void)
{
pthread_t thread;
unsigned int player, cnt;
unsigned long msg;
RT_TASK *mytask;
MBX *mbx;
char data[BUFSIZE];
signal(SIGINT, endme);
rt_allow_nonroot_hrt();
if ((player = open("../../../share/linux.au", O_RDONLY)) < 0) {
printf("ERROR OPENING SOUND FILE (linux.au)\n");
exit(1);
}
if (!(mytask = rt_task_init(nam2num("SNDMAS"), 2, 0, 0))) {
printf("CANNOT INIT MASTER TASK\n");
exit(1);
}
mlockall(MCL_CURRENT | MCL_FUTURE);
printf("\nINIT MASTER TASK %p\n\n(CTRL-C TO END EVERYTHING)\n", mytask);
mbx = rt_typed_named_mbx_init("SNDMBX", 2000, FIFO_Q);
rt_set_oneshot_mode();
start_rt_timer(0);
thread = rt_thread_create(intr_handler, NULL, 10000);
rt_mbx_receive(mbx, &data, 1);
while (!end) {
lseek(player, 0, SEEK_SET);
while(!end && (cnt = read(player, &data, BUFSIZE)) > 0) {
rt_mbx_send(mbx, data, cnt);
}
}
rt_rpc(rt_get_adr(nam2num("SOUND")), msg, &msg);
while (rt_get_adr(nam2num("SOUND"))) {
rt_sleep(nano2count(1000000));
}
rt_task_delete(mytask);
rt_mbx_delete(mbx);
stop_rt_timer();
close(player);
printf("\nEND MASTER TASK %p\n", mytask);
rt_thread_join(thread);
return 0;
}
/****
* Realtime txqueue wakeup manager.
*
* Waits blocking for a wakeup message in its mailbox and calls the rtdevice
* specific wakeup function (if one is registered) after a message arrived.
* After processing the realtime txqueue, a wakeup message is sent to the
* proxy wakeup manager.
*/
void rt_wakeup_manager_task (int mgr_id) {
struct rtnet_msg msg;
struct rtnet_mgr *mgr = (struct rtnet_mgr *)mgr_id;
rt_printk("RTnet: Realtime txqueue wakeup manager started. (%p)\n", rt_whoami());
while(1) {
rt_mbx_receive(&(mgr->mbx), &msg, sizeof(struct rtnet_msg));
if ((msg.msg_type==WAKEUP) && (msg.rtdev)) {
if (msg.rtdev->rt_wakeup_xmit) {
msg.rtdev->rt_wakeup_xmit(msg.rtdev);
}
}
// The next call should depend on the not yet specified returncode of rt_wakeup_xmit().
rt_mbx_send_if(&(proxy_wakeup_manager.mbx), &msg, sizeof (struct rtnet_msg));
}
}
static void task_code(int task_no)
{
int i, ret;
char buf[9];
buf[8] = 0;
for (i = 0; i < 5; ++i) {
rt_sem_wait(&sems[task_no]);
TAKE_PRINT;
rt_printk(strs[task_no]);
GIVE_PRINT;
if (task_no == NUM_TASKS-1) {
rt_printk("\n");
}
rt_sem_signal(&sems[(task_no + 1) % NUM_TASKS]);
}
rt_sem_signal(&sync_sem);
rt_sem_wait(&prio_sem);
TAKE_PRINT;
rt_printk(strs[task_no]);
GIVE_PRINT;
rt_sleep(nano2count(1000000000LL));
rt_sem_wait_timed(&prio_sem, nano2count((task_no + 1)*1000000000LL));
TAKE_PRINT;
rt_printk("sem timeout, task %d, %s\n", task_no, strs[task_no]);
GIVE_PRINT;
rt_sem_signal(&sync_sem);
/* message queue stuff */
if ((ret = rt_mbx_receive(&mbx_in, buf, 8)) != 0) {
rt_printk("rt_mbx_receive() failed with %d\n", ret);
}
TAKE_PRINT;
rt_printk("\nreceived by task %d ", task_no);
rt_printk(buf);
GIVE_PRINT;
rt_mbx_send(&mbx_out, strs[task_no], 8);
/* test receive timeout */
rt_sem_wait(&sync_sem);
if (rt_mbx_receive_timed(&mbx_in, buf, 8, nano2count((task_no + 1)*1000000000LL))) {
TAKE_PRINT;
rt_printk("mbx timeout, task %d, %s\n", task_no, strs[task_no]);
GIVE_PRINT;
}
rt_printk("\ntask %d complete\n", task_no);
}
int main(int argc,char *argv[])
{
MBX *mbx;
struct pollfd pollkb;
struct sample { long min, max, avrg, jitters[2]; } samp;
int n = 0;
setlinebuf(stdout);
pollkb.fd = 0;
pollkb.events = POLLIN;
signal(SIGHUP, endme);
signal(SIGINT, endme);
signal(SIGKILL, endme);
signal(SIGTERM, endme);
signal(SIGALRM, endme);
if (!rt_thread_init(nam2num("DSPLY"), 0, 0, SCHED_FIFO, 0xF)) {
printf("CANNOT INIT DISPLAY TASK\n");
exit(1);
}
if (!(mbx = rt_get_adr(nam2num("MBX")))) {
fprintf(stderr, "Error opening mbx in display\n");
exit(1);
}
printf("RTAI Testsuite - LXRT preempt (all data in nanoseconds)\n");
while (!end) {
if ((n++ % 21) == 0) {
printf("RTH|%12s|%12s|%12s|%12s|%12s\n", "lat min","lat avg","lat max","jit fast","jit slow");
}
rt_mbx_receive(mbx, &samp, sizeof(samp));
printf("RTD|%12ld|%12ld|%12ld|%12ld|%12ld\n", samp.min, samp.avrg, samp.max, samp.jitters[0], samp.jitters[1]);
fflush(stdout);
if (poll(&pollkb, 1, 1) > 0) {
getchar();
break;
}
}
return 0;
}
int main(void)
{
fd_set input;
struct timeval tv;
unsigned int msg, ch;
MBX *mbx;
struct sample { long long min; long long max; int index; double s; int ts; } samp;
tv.tv_sec = 0;
if (!(task = rt_task_init(nam2num("LATCHK"), 20, 0, 0))) {
printf("CANNOT INIT MASTER TASK\n");
exit(1);
}
if (!(mbx = rt_get_adr(nam2num("LATMBX")))) {
printf("CANNOT FIND MAILBOX\n");
exit(1);
}
while (1) {
rt_mbx_receive(mbx, &samp, sizeof(samp));
printf("*** min: %d, max: %d average: %d, dot %f ts %d (ent ends check, a/ent both) ***\n", (int) samp.min, (int) samp.max, samp.index, samp.s, samp.ts);
FD_ZERO(&input);
FD_SET(0, &input);
tv.tv_usec = 20000;
if (select(1, &input, NULL, NULL, &tv)) {
ch = getchar();
break;
}
}
if (ch == 'a') {
rt_rpc(rt_get_adr(nam2num("LATCAL")), msg, &msg);
}
rt_task_delete(task);
exit(0);
}
