int init_module(void)
{
int i;
DBG_PRINT_INIT;
if (rt_task_init(&start_task, start_task_code, 0, 10000, 10, 0, 0) != 0) {
printk("Could not start init task\n");
}
if (rt_mbx_init(&mbx_in, NUM_TASKS*8) || rt_mbx_init(&mbx_out, NUM_TASKS*8)) {
printk("could not create message queue\n");
return 1;
}
for (i = 0; i < NUM_TASKS; ++i) {
rt_sem_init(&sems[i], 0);
if (rt_task_init(&tasks[i], task_code, i, 3000, NUM_TASKS - i, 0, 0) != 0) {
printk("rt_task_ipc_init failed\n");
return 1;
}
}
#ifdef ONE_SHOT
rt_set_oneshot_mode();
#endif
start_rt_timer_ns(10000000);
checkt = rdtsc();
checkj = jiffies;
rt_task_resume(&start_task);
for (i = 0; i < NUM_TASKS; ++i) {
rt_task_resume(&tasks[i]);
}
return 0;
}
int init_module(void)
{
int i;
rt_sem_init(&barrier, NTASKS + 1);
smbx = rt_msgget(nam2num("SMSG"), 0x666 | IPC_CREAT);
for (i = 0; i < NTASKS; i++) {
char mname[6] = "RMBX";
mname[4] = i + '0';
mname[5] = 0;
rmbx[i] = rt_msgget(nam2num(mname), 0x666 | IPC_CREAT);
}
rt_set_oneshot_mode();
start_rt_timer(0);
rt_kthread_init(&bthread, bfun, 0, 0x8000, 1, 1, 0);
rt_task_resume(&bthread);
for (i = 0; i < NTASKS; i++) {
rt_kthread_init(&mthread[i], mfun, i, 0x8000, i + 2, 1, 0);
rt_task_resume(&mthread[i]);
}
return 0;
}
int init_module(void)
{
start_rt_timer(0);
rt_task_init(&rtai_sig_task, tsk_sig_fun, 0, STKSZ, 0, 0, 0);
rt_task_resume(&rtai_sig_task);
rt_task_init(&sig_task, sig_fun, 0, STKSZ, 0, 0, sighdl);
rt_task_resume(&sig_task);
return 0;
}
int init_module(void)
{
rt_bits_init(&bits, 0xFFFF0000);
rt_task_init(&task0, fun0, 0, STACK_SIZE, 0, 0, 0);
rt_task_init(&task1, fun1, 0, STACK_SIZE, 0, 0, 0);
rt_task_init(&task, fun, 0, STACK_SIZE, 0, 0, 0);
rt_set_oneshot_mode();
start_rt_timer(nano2count(SLEEP_TIME));
rt_task_resume(&task0);
rt_task_resume(&task1);
rt_task_resume(&task);
return 0;
}
static void sched_task(long t) {
int i, k;
unsigned long msg;
change = 0;
t = rdtsc();
for (i = 0; i < loops; i++) {
for (k = 0; k < ntasks; k++) {
rt_task_resume(thread + k);
}
}
t = rdtsc() - t;
rt_printk("\n\nFOR %d TASKS: ", ntasks);
rt_printk("TIME %d (ms), SUSP/RES SWITCHES %d, ", (int)llimd(t, 1000, CPU_FREQ), 2*ntasks*loops);
rt_printk("SWITCH TIME%s %d (ns)\n", use_fpu ? " (INCLUDING FULL FP SUPPORT)":"",
(int)llimd(llimd(t, 1000000000, CPU_FREQ), 1, 2*ntasks*loops));
change = 1;
for (k = 0; k < ntasks; k++) {
rt_task_resume(thread + k);
}
t = rdtsc();
for (i = 0; i < loops; i++) {
for (k = 0; k < ntasks; k++) {
rt_sem_signal(&sem);
}
}
t = rdtsc() - t;
rt_printk("\nFOR %d TASKS: ", ntasks);
rt_printk("TIME %d (ms), SEM SIG/WAIT SWITCHES %d, ", (int)llimd(t, 1000, CPU_FREQ), 2*ntasks*loops);
rt_printk("SWITCH TIME%s %d (ns)\n", use_fpu ? " (INCLUDING FULL FP SUPPORT)":"",
(int)llimd(llimd(t, 1000000000, CPU_FREQ), 1, 2*ntasks*loops));
change = 2;
for (k = 0; k < ntasks; k++) {
rt_sem_signal(&sem);
}
t = rdtsc();
for (i = 0; i < loops; i++) {
for (k = 0; k < ntasks; k++) {
rt_rpc(thread + k, 0, &msg);
}
}
t = rdtsc() - t;
rt_printk("\nFOR %d TASKS: ", ntasks);
rt_printk("TIME %d (ms), RPC/RCV-RET SWITCHES %d, ", (int)llimd(t, 1000, CPU_FREQ), 2*ntasks*loops);
rt_printk("SWITCH TIME%s %d (ns)\n\n", use_fpu ? " (INCLUDING FULL FP SUPPORT)":"",
(int)llimd(llimd(t, 1000000000, CPU_FREQ), 1, 2*ntasks*loops));
}
int init_module(void)
{
rt_typed_mbx_init(&smbx, 5, MBX_TYPE); //5
rt_typed_mbx_init(&rmbx[0], 1, MBX_TYPE); //1
rt_typed_mbx_init(&rmbx[1], 3, MBX_TYPE); //3
rt_task_init(&btask, bfun, 0, STACK_SIZE, 0, 0, 0);
rt_task_init(&mtask[0], mfun, 0, STACK_SIZE, 1, 0, 0);
rt_task_init(&mtask[1], mfun, 1, STACK_SIZE, 1, 0, 0);
rt_set_oneshot_mode();
start_rt_timer(nano2count(SLEEP_TIME));
rt_task_resume(&btask);
rt_task_resume(&mtask[0]);
rt_task_resume(&mtask[1]);
return 0;
}
int init_module(void)
{
RTIME tick_period;
int err;
printk("%s: Loading RX%d Test module...\n", test_name, rt_port);
err = rt_spopen(rt_port,
line_param[0], line_param[1], line_param[2],
line_param[3], line_param[4], line_param[5]);
if (err) return err;
/* Register error handler */
rt_spset_err_callback_fun(rt_port, error_handler);
/* Start RX message handler */
rt_task_init(&thread, rx_handler, 0, STACK_SIZE, 0, 0, 0);
rt_task_resume(&thread);
rt_set_oneshot_mode();
if (period) {
tick_period = start_rt_timer(nano2count(period));
rt_task_make_periodic(&thread, rt_get_time(), tick_period);
}
return 0;
}
static void rt_timer_tick(void)
{
cpu_used[NR_RT_CPUS]++;
if (passed++ < 5) {
t0 = rdtsc();
} else {
t = rdtsc();
if ((jit = t - t0 - imuldiv(rt_times.periodic_tick, CPU_FREQ, FREQ_8254)) < 0) {
jit = -jit;
}
if (jit > maxj) {
maxj = jit;
}
t0 = t;
}
rt_times.tick_time = rt_times.intr_time;
rt_times.intr_time = rt_times.tick_time + rt_times.periodic_tick;
rt_set_timer_delay(0);
if (rt_times.tick_time >= rt_times.linux_time) {
rt_times.linux_time += rt_times.linux_tick;
rt_pend_linux_irq(TIMER_8254_IRQ);
}
if (Mode) {
rt_sem_signal(&sem);
} else {
rt_task_resume(&thread);
}
}
static int __switches_init(void)
{
int i;
int e;
printk("\nWait for it ...\n");
rt_typed_sem_init(&sem, 1, SEM_TYPE);
rt_linux_use_fpu(1);
thread = (RT_TASK *)kmalloc(ntasks*sizeof(RT_TASK), GFP_KERNEL);
for (i = 0; i < ntasks; i++) {
#ifdef DISTRIBUTE
e = rt_task_init_cpuid(thread + i, pend_task, i, stack_size, 0, use_fpu, 0, i%2);
#else
e = rt_task_init_cpuid(thread + i, pend_task, i, stack_size, 0, use_fpu, 0, hard_cpu_id());
#endif
if (e < 0) {
task_init_has_failed:
rt_printk("switches: failed to initialize task %d, error=%d\n", i, e);
while (--i >= 0)
rt_task_delete(thread + i);
return -1;
}
}
e = rt_task_init_cpuid(&task, sched_task, i, stack_size, 1, use_fpu, 0, hard_cpu_id());
if (e < 0)
goto task_init_has_failed;
rt_task_resume(&task);
return 0;
}
/* ************************************************************************
* hard_xmit
*
* This function runs in linux kernel context and is executed whenever
* there is a frame to be sent out.
* ************************************************************************ */
static int rtnetproxy_xmit(struct sk_buff *skb, struct net_device *dev)
{
struct net_device_stats *stats = dev->priv;
if (write_to_ringbuffer(&ring_skb_kernel_rtnet, skb))
{
stats->tx_packets++;
stats->tx_bytes+=skb->len;
}
else
{
/* No space in the ringbuffer... */
printk("rtnetproxy_xmit - no space in queue\n");
dev_kfree_skb(skb); /* Free the standard skb. */
}
/* Signal rtnet that there are packets waiting to be processed...
* Resume the transmission thread (function rtnetproxy_transmit_thread)
* */
rt_task_resume(&rtnetproxy_thread);
/* Delete all "used" skbs that already have been processed... */
{
struct sk_buff *del_skb;
while ((del_skb = read_from_ringbuffer(&ring_skb_rtnet_kernel)) != 0)
{
dev_kfree_skb(del_skb); /* Free the standard skb. */
}
}
return 0;
}
RTAI_SYSCALL_MODE int rt_request_signal_(RT_TASK *sigtask, RT_TASK *task, long signal)
{
int retval;
if (signal >= 0 && sigtask && task) {
if (!task->rt_signals) {
if ((task->rt_signals = rt_malloc((MAXSIGNALS + MAX_PQUEUES)*sizeof(struct rt_signal_t)))) {
memset(task->rt_signals, 0, ((MAXSIGNALS + MAX_PQUEUES)*sizeof(struct rt_signal_t)));
task->pstate = 0;
} else {
retval = -ENOMEM;
goto ret;
}
}
RT_SIGNALS[signal].flags = (1 << SIGNAL_ENBIT);
sigtask->rt_signals = (void *)1;
RT_SIGNALS[signal].sigtask = sigtask;
retval = 0;
} else {
retval = -EINVAL;
}
ret:
task->retval = retval;
rt_task_resume(task);
return retval;
}
static int rt_timer_tick_ext(int irq, unsigned long data)
{
int ret = 1;
cpu_used[NR_RT_CPUS]++;
if (passed++ < 5) {
t0 = rdtsc();
} else {
t = rdtsc();
if ((jit = t - t0 - imuldiv(rt_times.periodic_tick, CPU_FREQ, FREQ_8254)) < 0) {
jit = -jit;
}
if (jit > maxj) {
maxj = jit;
}
t0 = t;
}
rt_times.tick_time = rt_times.intr_time;
rt_times.intr_time = rt_times.tick_time + rt_times.periodic_tick;
rt_set_timer_delay(0);
if (rt_times.tick_time >= rt_times.linux_time) {
rt_times.linux_time += rt_times.linux_tick;
rt_pend_linux_irq(TIMER_8254_IRQ);
ret = 0;
}
rt_sched_lock();
if (Mode) {
rt_sem_signal(&sem);
} else {
rt_task_resume(&thread);
}
rt_sched_unlock();
return ret;
}
int init_module(void)
{
comnode = ddn2nl(ComNode);
tasknode = ddn2nl(TaskNode);
rt_task_init(&thread, start_task_code, 0, 4000, 10, 0, 0);
rt_task_resume(&thread);
return 0;
}
int init_module(void)
{
start_rt_timer(0);
worst_lat = rt_shm_alloc(nam2num("WSTLAT"), sizeof(RTIME), USE_VMALLOC);
task = rt_named_task_init_cpuid("LOOPER", fun, 0, 100000, 0, 1, 0, 1);
rt_task_resume(task);
return 0;
}
static void rt_timers_manager(int dummy)
{
static unsigned long cr0;
RTIME now;
struct rt_tasklet_struct *tmr, *timer;
unsigned long flags;
int priority, used_fpu;
while (1) {
rt_sleep_until((timers_list.next)->firing_time);
now = timers_manager.resume_time + tuned.timers_tol[0];
// find all the timers to be fired, in priority order
while (1) {
used_fpu = 0;
tmr = timer = &timers_list;
priority = RT_LOWEST_PRIORITY;
flags = rt_spin_lock_irqsave(&timers_lock);
while ((tmr = tmr->next)->firing_time <= now) {
if (tmr->priority < priority) {
priority = (timer = tmr)->priority;
}
}
timers_manager.priority = priority;
rt_spin_unlock_irqrestore(flags, &timers_lock);
if (timer == &timers_list) {
break;
}
if (!timer->period) {
flags = rt_spin_lock_irqsave(&timers_lock);
(timer->next)->prev = timer->prev;
(timer->prev)->next = timer->next;
timer->next = timer->prev = timer;
rt_spin_unlock_irqrestore(flags, &timers_lock);
} else {
set_timer_firing_time(timer, timer->firing_time + timer->period);
}
if (!timer->task) {
if (!used_fpu && timer->uses_fpu) {
used_fpu = 1;
save_cr0_and_clts(cr0);
save_fpenv(timers_manager.fpu_reg);
}
timer->handler(timer->data);
} else {
rt_task_resume(timer->task);
}
}
if (used_fpu) {
restore_fpenv(timers_manager.fpu_reg);
restore_cr0(cr0);
}
// set next timers_manager priority according to the highest priority timer
asgn_min_prio();
// if no more timers in timers_struct remove timers_manager from tasks list
}
}
int init_module(void)
{
printk("Conditional semaphore test program.\n");
printk("Wait for all tasks to end, then type: ./rem.\n\n");
start_rt_timer(nano2count(TICK));
rt_cond_init(&cond);
rt_mutex_init(&mtx);
rt_task_init(&task1, task_func1, 0, RT_STACK, 0, 0, 0);
rt_task_init(&task2, task_func2, 0, RT_STACK, 1, 0, 0);
rt_task_init(&task3, task_func3, 0, RT_STACK, 2, 0, 0);
rt_task_init(&task4, task_func4, 0, RT_STACK, 3, 0, 0);
rt_task_resume(&task1);
rt_task_resume(&task2);
rt_task_resume(&task3);
rt_task_resume(&task4);
printk("Do not panic, wait 2 s, till task3 times out.\n\n");
return 0;
}
/* ************************************************************************
* This function runs in kernel mode.
* It is activated from rtnetproxy_recv whenever rtnet received a frame to
* be processed by rtnetproxy.
* ************************************************************************ */
static void rtnetproxy_rtai_srq(void)
{
struct rtskb *rtskb;
while ( (rtskb = read_from_ringbuffer(&ring_rtskb_rtnet_kernel)) != 0)
{
rtnetproxy_kernel_recv(rtskb);
/* Place "used" rtskb in backqueue... */
while (0 == write_to_ringbuffer(&ring_rtskb_kernel_rtnet, rtskb)) {
rt_task_resume(&rtnetproxy_thread);
}
}
/* Signal rtnet that there are "used" rtskbs waiting to be processed...
* Resume the rtnetproxy_thread to recycle "used" rtskbs
* */
rt_task_resume(&rtnetproxy_thread);
}
int init_module(void)
{
rt_task_init(&parent_task, parent_func, 0, STACK_SIZE, 0, 0, 0);
rt_set_oneshot_mode();
period = start_rt_timer((int) nano2count(TICK_PERIOD));
rt_set_runnable_on_cpus(&parent_task, RUN_ON_CPUS);
rt_task_resume(&parent_task);
return 0;
}
int init_module(void)
{
int i;
rt_set_oneshot_mode();
start_rt_timer(0);
rt_mbx_init(&mbx, 5);
for (i = 0; i < NUM_TASKS; i++) {
rt_task_init(&task[i], fun1, i, STACK_SIZE, 0, 0, 0);
rt_task_resume(&task[i]);
}
rt_task_init(&task[NUM_TASKS], fun2, NUM_TASKS, STACK_SIZE, 1, 0, 0);
rt_task_resume(&task[NUM_TASKS]);
while (atomic_read(&cleanup) < (NUM_TASKS + 1)) {
current->state = TASK_INTERRUPTIBLE;
schedule_timeout(HZ/10);
}
return 0;
}
int init_module(void)
{
rt_set_oneshot_mode();
start_rt_timer(0);
if (SemType) {
printk("USING A RESOURCE SEMAPHORE, AND WE HAVE ...\n");
rt_typed_sem_init(&mutex, 1, RES_SEM);
} else {
printk("USING A BINARY SEMAPHORE, AND WE HAVE ...\n");
rt_typed_sem_init(&mutex, 1, BIN_SEM | PRIO_Q);
}
rt_task_init_cpuid(&taskl, taskl_func, 0, RT_STACK, 1000, 0, 0, 0);
rt_task_init_cpuid(&taskm, taskm_func, 0, RT_STACK, 500, 0, 0, 0);
rt_task_init_cpuid(&taskh, taskh_func, 0, RT_STACK, 0, 0, 0, 0);
rt_task_resume(&taskl);
rt_task_resume(&taskm);
rt_task_resume(&taskh);
return 0;
}
int init_module(void)
{
hide = FALSE;
pause = FALSE;
rtf_create(Keyboard, 1000);
rtf_create_handler(Keyboard, keybrd_handler);
rtf_create(Screen, 10000);
rt_sem_init(&keybrd_sem, 0);
rt_task_init_cpuid(&read, ClockChrono_Read, 0, 2000, 0, 0, 0, READ_RUN_ON_CPU);
rt_task_init_cpuid(&chrono, ClockChrono_Chrono, 0, 2000, 0, 0, 0, CHRONO_RUN_ON_CPU);
rt_task_init_cpuid(&clock, ClockChrono_Clock, 0, 2000, 0, 0, 0, CLOCK_RUN_ON_CPU);
rt_task_init_cpuid(&write, ClockChrono_Write, 0, 2000, 0, 0, 0, WRITE_RUN_ON_CPU);
start_rt_apic_timers(apic_setup_data, 0);
rt_task_resume(&read);
rt_task_resume(&chrono);
rt_task_resume(&clock);
rt_task_resume(&write);
return 0;
}
int init_module(void)
{
tasknode = ddn2nl(TaskNode);
rt_mbx_init(&mbx, 1);
rt_register(nam2num("HDLMBX"), &mbx, IS_MBX, 0);
rt_task_init(&sup_task, sup_fun, 0, 2000, 1, 0, 0);
rt_task_resume(&sup_task);
rt_request_timer(timer_tick, imuldiv(PERIOD, FREQ_8254, 1000000000), 0);
return 0;
}
/* alarm_handler
** is triggered once 10s is passed to inform player
** wait time has expired - issue start
*/
void alarm_handler(void *arg)
{
int sock = *(int *)&arg;
int echolen;
/* start the countdown */
rt_task_set_periodic(NULL, TM_NOW, 8000000000ULL);
rt_task_wait_period(NULL);
if(!issuedStart)
rt_task_delete(NULL); //not need two players connected
rt_mutex_acquire(&autoStart, TM_INFINITE);
issuedStart = true;
rt_mutex_release(&autoStart);
AIMode = true;
printf("FORCED START client playing with AI!\n");
/* below we emulate the add, start */
addPong();
echolen = strlen(pongData[0]);
if(send(sock, pongData[0],echolen, 0) != echolen)
rt_err("send()");
echolen = strlen(pongData[1]);
if(send(sock, pongData[1],echolen, 0) != echolen)
rt_err("send()");
start();
echolen = strlen(gameData);
if(send(sock, gameData, echolen, 0) != echolen)
rt_err("send()");
echolen = strlen(ballData);
if(send(sock, ballData, echolen, 0) != echolen)
rt_err("send()");
if(rt_task_resume(&recvThread[0]))
rt_err("rt_task_resume()");
if(rt_task_resume(&ballThread))
rt_err("rt_task_resume()");
}
int main(int argc, char *argv[])
{
unsigned long msg;
int prio, bprio;
if (argc > 1) {
USE_RPC = atoi(argv[1]);
SNDBRCV = atoi(argv[2]);
HARDMAIN = atoi(argv[3]);
}
if (!(maintask = rt_task_init_schmod(0xcacca, 1, 0, 0, SCHED_FIFO, 0x1))) {
rt_printk("CANNOT INIT MAIN\n");
exit(1);
}
start_rt_timer(0);
rt_printk("MAIN INIT\n");
pthread_create(&thread, NULL, thread_fun, NULL);
mlockall(MCL_CURRENT | MCL_FUTURE);
if (HARDMAIN) {
rt_make_hard_real_time();
}
rt_get_priorities(maintask, &prio, &bprio);
rt_printk("TEST: %s, %s, %d\n", USE_RPC ? "WITH RPC" : "WITH SUSP/RESM", SNDBRCV ? "SEND BEFORE RECEIVE" : "RECEIVE BEFORE SEND", prio);
if (SNDBRCV) {
rt_sleep(nano2count(100000000));
}
rt_get_priorities(maintask, &prio, &bprio);
rt_printk("MAIN REC %d\n", prio);
if (USE_RPC) {
RT_TASK *task;
task = rt_receive(0, &msg);
rt_get_priorities(maintask, &prio, &bprio);
rt_printk("MAIN RET %d\n", prio);
rt_return(task, 0);
} else {
rt_receive(0, &msg);
rt_get_priorities(maintask, &prio, &bprio);
rt_printk("MAIN RES %d\n", prio);
rt_task_resume(funtask);
}
rt_get_priorities(maintask, &prio, &bprio);
rt_printk("MAIN DONE %d\n", prio);
stop_rt_timer();
rt_task_delete(maintask);
rt_printk("MAIN END\n");
return 0;
}
int main(void)
{
int pid;
char ch;
char k = 'k';
RT_TASK *mytask;
MBX *Keyboard;
menu();
pid = fork();
if (!pid) {
execl("./screen", "./screen", NULL);
}
sleep(1);
if (!(mytask = rt_task_init(nam2num("KBRTSK"), 10, 0, 0))) {
printf("CANNOT INIT KEYBOARD TASK\n");
exit(1);
}
if (!(Keyboard = rt_get_adr(nam2num("KEYBRD")))) {
printf("CANNOT FIND KEYBOARD MAILBOX\n");
exit(1);
}
if (rt_mbx_send(Keyboard, &k, 1) > 0 ) {
fprintf(stderr, "Can't send initial command to RT-task\n");
exit(1);
}
do {
ch = get_key();
if (ch == 'p' || ch == 'P') {
menu();
}
if (ch != 'f' && rt_mbx_send_if(Keyboard, &ch, 1) > 0 ) {
fprintf(stderr, "Can't send command to RT-task\n");
}
} while (ch != 'f');
ch = 'r';
rt_mbx_send(Keyboard, &ch, 1);
ch = 'c';
rt_mbx_send(Keyboard, &ch, 1);
ch = 'f';
rt_mbx_send(Keyboard, &ch, 1);
rt_task_resume(rt_get_adr(nam2num("MASTER")));
while (rt_get_adr(nam2num("MASTER"))) {
rt_sleep(nano2count(1000000));
}
kill(pid, SIGINT);
rt_task_delete(mytask);
stop_rt_timer();
exit(0);
}
RTAI_SYSCALL_MODE int rt_delete_tasklet(struct rt_tasklet_struct *tasklet)
{
int thread;
rt_remove_tasklet(tasklet);
tasklet->handler = 0;
rt_copy_to_user(tasklet->usptasklet, tasklet, sizeof(struct rt_usp_tasklet_struct));
rt_task_resume(tasklet->task);
thread = tasklet->thread;
rt_free(tasklet);
return thread;
}
RTAI_SYSCALL_MODE int rt_exec_tasklet(struct rt_tasklet_struct *tasklet)
{
if (tasklet && tasklet->next != tasklet && tasklet->prev != tasklet) {
if (!tasklet->task) {
tasklet->handler(tasklet->data);
} else {
rt_task_resume(tasklet->task);
}
return 0;
}
return -EINVAL;
}
int rt_request_signal(long signal, void (*sighdl)(long, RT_TASK *))
{
struct sigsuprt_t arg = { NULL, RT_CURRENT, signal, sighdl };
if (signal >= 0 && sighdl && (arg.sigtask = rt_malloc(sizeof(RT_TASK)))) {
if (!rt_task_init_cpuid(arg.sigtask, signal_suprt_fun, (long)&arg, SIGNAL_TASK_STACK_SIZE, arg.task->priority, 0, NULL, arg.task->runnable_on_cpus)) {
rt_task_resume(arg.sigtask);
rt_task_suspend(arg.task);
return arg.task->retval;
}
rt_free(arg.sigtask);
}
return -EINVAL;
}
/***
* rt_stack_mgr_init
*/
int rt_stack_mgr_init (struct rtnet_mgr *mgr)
{
int ret = 0;
if ( (ret=rt_mbx_init (&(mgr->mbx), sizeof(struct rtnet_msg))) )
return ret;
if ( (ret=rt_task_init(&(mgr->task), &do_stacktask, (int)mgr, 4096, RTNET_STACK_PRIORITY, 0, 0)) )
return ret;
if ( (ret=rt_task_resume(&(mgr->task))) )
return ret;
return (ret);
}
int init_module(void)
{
int i;
thread = (RT_TASK *)kmalloc(NTASKS*sizeof(RT_TASK), GFP_KERNEL);
rt_rwl_init(&rwl);
rt_set_oneshot_mode();
start_rt_timer(0);
for (i = 0; i < NTASKS; i++) {
extcnt[i] = 999999;
rt_task_init(&thread[i], fun, i + 1, STACK_SIZE, NTASKS - i, 0, 0);
rt_task_resume(&thread[i]);
}
return 0;
}
