static void bfun(long t) { RT_MSGQ *smbx, **rmbx; int *msg, mtype, i, n; rmbx = rt_malloc(NTASKS*sizeof(int)); msg = rt_malloc((MAXSIZ + 1)*sizeof(int)); smbx = rt_named_msgq_init("SMSG", 0, 0); for (i = 0; i < NTASKS; i++) { char mname[6] = "RMBX"; mname[4] = i + '0'; mname[5] = 0; rmbx[i] = rt_named_msgq_init(mname, 0, 0); } rt_sem_wait_barrier(&barrier); while (end < NTASKS) { rt_msg_receive(smbx, msg, sizeof(int)*(MAXSIZ + 1), &mtype); n = 0; for (i = 1; i < MAXSIZ; i++) { n += msg[i]; } if (msg[MAXSIZ] != n) { rt_printk("SERVER RECEIVED AN UNKNOWN MSG.\n"); goto prem; } msg[1] = 0xFFFFFFFF; rt_msg_send(rmbx[msg[0]], msg, 2*sizeof(int), 1); } prem: rt_free(rmbx); rt_free(msg); rt_printk("SERVER TASK ENDS.\n"); }
int main(void) { RT_TASK *task; RTIME now; int cnt=0; // make main thread LXRT soft realtime task = rt_task_init_schmod(nam2num("MYTASK"), 9, 0, 0, SCHED_FIFO, 0xF); mlockall(MCL_CURRENT | MCL_FUTURE); // start realtime timer and scheduler //rt_set_oneshot_mode(); rt_set_periodic_mode(); start_rt_timer(0); now = rt_get_time() + 10*PERIOD; rt_task_make_periodic(task, now, PERIOD); printf("Init mutex and cond.\n"); mutex = rt_sem_init(nam2num("MUTEX"), 1); if (mutex==0) printf("Error init mutex\n"); cond = rt_cond_init(nam2num("CONDITION")); if (cond==0) printf("Error init cond\n"); thread0 = rt_thread_create(fun0, NULL, 10000); //thread1 = rt_thread_create(fun1, NULL, 20000); //rt_sleep(PERIOD); while (cnt < THRESHOLD) { rt_task_wait_period(); rt_printk("main: Hello World %d!\n",cnt); rt_sem_wait(mutex); //now the mutex should have value 0 if (instance_cnt==0) { rt_sem_signal(mutex); //now the mutex should have vaule 1 rt_printk("worker thread busy!\n"); } else { instance_cnt++; rt_cond_signal(cond); rt_sem_signal(mutex); //now the mutex should have vaule 1 rt_printk("signaling worker thread to start!\n"); } cnt++; } // wait for end of program printf("TYPE <ENTER> TO TERMINATE\n"); getchar(); // cleanup stop_rt_timer(); return 0; }
void send_msg(void *arg) { int ret; struct msghdr msg; struct iovec iov[2]; unsigned short msgsize = size; while(1) { iov[0].iov_base = &msgsize; iov[0].iov_len = sizeof(msgsize); iov[1].iov_base = buffer_out; iov[1].iov_len = size; memset(&msg, 0, sizeof(msg)); msg.msg_name = &dest_addr; msg.msg_namelen = sizeof(dest_addr); msg.msg_iov = iov; msg.msg_iovlen = 2; rt_printk("Sending message of %d+2 bytes\n", size); ret = rt_socket_sendmsg(sock, &msg, 0); if (ret != (int)(sizeof(msgsize) + size)) rt_printk(" rt_socket_sendmsg() = %d!\n", ret); rt_task_wait_period(); } }
static void sender(long nothing) { int diff = 0, warmup = 1000000000/WORKCYCLE; RTIME t, tb; struct sample { unsigned long cnt; RTIME tx, rx; } samp = { 0, 0, 0 }; rt_printk("RtnetTest: Transmitter task initialised\n"); tb = t = rt_get_real_time_ns(); while(!end) { slen = sprintf(buffer_out, "%lld", t); slen = rt_dev_sendto(sock, buffer_out, slen, 0, (struct sockaddr*)&tx_addr, sizeof(tx_addr)); if (slen < 0) { rt_printk("RtnetTest: Packet send failed! Errno %d\n", -slen); return; } rt_task_wait_period(); t = rt_get_real_time_ns(); if (!warmup) { diff = abs((int)(t - tb - WORKCYCLE)); samp.cnt++; tb = t; if (diff > samp.rx) samp.rx = diff; rt_mbx_send_if(mbx, &samp, sizeof(samp)); } else { tb = rt_get_real_time_ns(); warmup--; } } }
/*** * rt_unregister_rtnetdev: unregister a rtnet_device * @rtdev: the device */ int rt_unregister_rtnetdev(struct rtnet_device *rtdev) { struct net_device *d, **dp, *dev = dev_get_by_rtdev(rtdev); rt_printk("RTnet: rt_unregister_netdevice(%s)\n", dev->name); /* If device is running, close it first. */ if (dev->flags & IFF_UP) rtdev_close(rtdev); dev->deadbeaf = 1; /* And unlink it from device chain. */ for (dp = &dev_base; (d=*dp)!=NULL; dp=&d->next) { if (d==dev) { write_lock(&dev_base_lock); *dp = d->next; write_unlock(&dev_base_lock); break; } } if ( !d ) { rt_printk("RTnet: device %s/%p never was registered\n", dev->name, dev); return -ENODEV; } clear_bit(__LINK_STATE_PRESENT, &dev->state); if ( dev->uninit ) dev->uninit(dev); return 0; }
static void timer_tick(void) { 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 (run) { if (rt_waiting_return(tasknode, taskport)) { overuns++; } switch(run) { case 1: RT_sem_signal(tasknode, -taskport, rmt_sem); rt_printk("SEM SIGNAL %d\n", ++cnt); break; case 2: RT_task_resume(tasknode, -taskport, rmt_task); rt_printk("TASK RESUME %d\n", ++cnt); break; case 3: RT_send_if(tasknode, -taskport, rmt_task, run); rt_printk("TASK SEND %d\n", ++cnt); break; } } }
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"); }
/*** * rtskb_pool_release */ int rtskb_pool_release(void) { int err = 0; if ( rt_free_srq (dec_pool_srq)<0 ) { rt_printk("RTnet: deallocating 'dec_pool_srq=%d' failed.\n", dec_pool_srq); return dec_pool_srq; } if ( rt_free_srq (inc_pool_srq)<0 ) { rt_printk("RTnet: deallocating 'inc_pool_srq=%d' failed.\n", inc_pool_srq); return inc_pool_srq; } if ( rtskb_pool.qlen>0 ) { int i; for (i=rtskb_pool.qlen; i>0; i--) dispose_rtskb(__rtskb_dequeue(&rtskb_pool)); } if ( rtskb_data_cache && kmem_cache_destroy (rtskb_data_cache) ) { rt_printk("RTnet: deallocating 'rtskb_data_cache' failed.\n"); } if ( rtskb_cache && kmem_cache_destroy (rtskb_cache) ) { rt_printk("RTnet: deallocating 'rtnet_skb_cache' failed.\n"); } return err; }
void taskh_func(long tid) { RTIME time; unsigned int msg = 0, wait; rt_send(&taskm, msg); rt_send(&taskl, msg); while (1) { rt_receive(&taskm, &msg); time = rt_get_time_ns(); if (MUTEX_LOCK(&mutex) <= 1) { if ((wait = (int)(rt_get_time_ns() - time)) > 250000) { rt_printk("PRIORITY INVERSION, WAITED FOR %d us\n", wait/1000); } else { rt_printk("NO PRIORITY INVERSION, WAITED FOR %d us\n", wait/1000); } if (SemType) { MUTEX_LOCK(&mutex); MUTEX_LOCK(&mutex); rt_busy_sleep(100000); MUTEX_LOCK(&mutex); } rt_busy_sleep(100000); if (SemType) { rt_sem_signal(&mutex); rt_busy_sleep(100000); rt_sem_signal(&mutex); rt_sem_signal(&mutex); } rt_sem_signal(&mutex); } else { rt_task_suspend(0); } } }
/*** * rt_unregister_rtnetdev: unregister a rtnet_device * @rtdev: the device */ int rt_unregister_rtnetdev(struct rtnet_device *rtdev) { struct rtnet_device *d, **dp; unsigned long flags; rt_printk("RTnet: rt_unregister_netdevice(%s)\n", rtdev->name); /* If device is running, close it first. */ if (rtdev->flags & IFF_UP) rtdev_close(rtdev); hard_save_flags_and_cli(flags); write_lock(&rtnet_devices_lock); /* Unlink it from device chain. */ for (dp = &rtnet_devices; (d=*dp)!=NULL; dp=&d->next) { if (d==rtdev) { *dp = d->next; break; } } write_unlock(&rtnet_devices_lock); hard_restore_flags(flags); if ( !d ) { rt_printk("RTnet: device %s/%p never was registered\n", rtdev->name, rtdev); return -ENODEV; } clear_bit(__LINK_STATE_PRESENT, &rtdev->state); return 0; }
static void bfun(int t) { int smbx, *rmbx, *msg, mtype, i, n; rmbx = rt_malloc(NTASKS*sizeof(int)); msg = rt_malloc((MAXSIZ + 1)*sizeof(int)); smbx = rt_msgget(nam2num("SMSG"), 0); for (i = 0; i < NTASKS; i++) { char mname[6] = "RMBX"; mname[4] = i + '0'; mname[5] = 0; rmbx[i] = rt_msgget(nam2num(mname), 0); } rt_sem_wait_barrier(&barrier); while (end < NTASKS) { rt_msgrcv_nu(smbx, &mtype, msg, sizeof(int)*(MAXSIZ + 1), 1, 0); n = 0; for (i = 1; i < MAXSIZ; i++) { n += msg[i]; } if (msg[MAXSIZ] != n) { rt_printk("SERVER RECEIVED AN UNKNOWN MSG.\n"); goto prem; } msg[1] = 0xFFFFFFFF; rt_msgsnd_nu(rmbx[msg[0]], 1, msg, 2*sizeof(int), 0); } prem: rt_free(rmbx); rt_free(msg); rt_printk("SERVER TASK ENDS.\n"); }
static RTAI_SYSCALL_MODE int _comedi_get_krange(void *dev, unsigned int subdev, unsigned int chan, unsigned int range, comedi_krange *krange) { rt_printk("COMEDI GET KRANGE: dev = %p, subdev = %u, chan = %u, range = %u.\n", dev, subdev, chan, range); rt_printk("COMEDI GET KRANGE RETURNS %d, %d, %u.\n", RANGE_MIN, RANGE_MAX, RANGE_FLAGS); *krange = (comedi_krange){ RANGE_MIN, RANGE_MAX, RANGE_FLAGS}; return 0; }
RTAI_SYSCALL_MODE char *rt_comedi_get_driver_name(void *dev, char *name) { rt_printk("COMEDI GET DRIVER NAME: dev = %x.\n", dev); strncpy(name, DRIVER_NAME, COMEDI_NAMELEN); rt_printk("COMEDI GET DRIVER NAME RETURNS %s.\n", DRIVER_NAME); return name; }
/*** * 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); } } } } } }
int main(void) { int i, srq, count = 0, nextcount = 0, repeat; rt_thread_init(nam2num("MNTSK"), 100, 0, SCHED_FIFO, 0x1); rt_printk("\nTESTING THE SCHEDULER WITH SRQs [%d LOOPs].\n", LOOPS); repeat = 1000000000LL/((long long)DELAY*(long long)PRINT_FREQ); srq = rtai_open_srq(0xcacca); start_rt_timer(0); rt_grow_and_lock_stack(100000); #ifdef MAKE_HARD MAKE_HARD(); #endif for (i = 0; i < LOOPS; i++) { rtai_srq(srq, (unsigned long)nano2count(DELAY)); if (++count > nextcount) { nextcount += repeat; rt_printk(">>> %d.\n", nextcount); } } rt_make_soft_real_time(); stop_rt_timer(); rt_task_delete(NULL); rt_printk("END SCHEDULER TEST WITH SRQs.\n\n"); return 0; }
void __do_atexit( void ) { func_ptr *p = atexit_function_tab; rt_printk("__do_atexit START\n"); // we check if the pointer is NULL, this // can happen when a second C++ modules is loaded // and than unloaded. At unload time the second module // will call the atexit handlers and delete // the function table if( atexit_function_tab == 0 ){ rt_printk("atexit_function_tab == NULL\n"); return; } while(*p) { rt_printk("calling atexit function %p\n",p ); (*(p))(); p++; if( atexit_function_tab_len-- ) break; } vfree( atexit_function_tab ); atexit_function_tab_size = 0; atexit_function_tab_len = 0; atexit_function_tab = 0; rt_printk("__do_atexit END\n"); }
RTAI_SYSCALL_MODE char *rt_comedi_get_board_name(void *dev, char *name) { rt_printk("COMEDI GET BOARD NAME: dev = %p.\n", dev); strncpy(name, BOARD_NAME, COMEDI_NAMELEN); rt_printk("COMEDI GET BOARD NAME RETURNS %s.\n", BOARD_NAME); return name; }
int __init hello_init(void) { RTIME sampling; rt_printk(KERN_INFO "TESTE - *************************** INICIO *******************************\n"); rt_task_init(&Task_1, signalIchi, 0, 3000, 0, 0, NULL); rt_task_init(&Task_2, signalNi, 0, 3000, 0, 0, NULL); rt_task_init(&Task_3, signalSan, 0, 3000, 0, 0, NULL); sampling = start_rt_timer(nano2count(TICK)); rt_sem_init(&rMutex, 1); rt_task_make_periodic(&Task_1, rt_get_time() + sampling * 16, sampling * 16); rt_task_make_periodic(&Task_2, rt_get_time() + sampling * 18, sampling * 18); rt_task_make_periodic(&Task_3, rt_get_time() + sampling * 30, sampling * 30); rt_change_prio(&Task_1, 2); rt_change_prio(&Task_2, 1); rt_change_prio(&Task_3, 3); rt_printk(KERN_INFO "Init module function\n"); return 0; }
void __exit hello_clean(void) { rt_task_delete(&Task_1); rt_task_delete(&Task_2); rt_task_delete(&Task_3); rt_printk(KERN_INFO "Cleanup module function\n"); rt_printk(KERN_INFO "-----------------------\n"); }
static RTAI_SYSCALL_MODE int _comedi_data_read(void *dev, unsigned int subdev, unsigned int chan, unsigned int range, unsigned int aref, lsampl_t *data) { RTAI_COMEDI_LOCK(dev, subdev); rt_printk("COMEDI DATA READ: dev = %p, subdev = %u, chan = %u, range = %u, aref = %x.\n", dev, subdev, chan, range, aref); data[0] = 0xabcdea; rt_printk("COMEDI DATA READ RETURNS %x.\n", data[0]); RTAI_COMEDI_UNLOCK(dev, subdev); return 1; }
static RTAI_SYSCALL_MODE int _comedi_dio_bitfield(void *dev, unsigned int subdev, unsigned int write_mask, unsigned int *bits) { RTAI_COMEDI_LOCK(dev, subdev); rt_printk("COMEDI DIO BITFIELD: dev = %p, subdev = %u, write_mask = %x, bits = %x.\n", dev, subdev, write_mask, bits[0]); bits[0] |= 0xFFFFFFFF; rt_printk("COMEDI DIO BITFIELD RETURNS %x.\n", bits[0]); RTAI_COMEDI_UNLOCK(dev, subdev); return 1; }
static RTAI_SYSCALL_MODE int _comedi_dio_read(void *dev, unsigned int subdev, unsigned int chan, unsigned int *val) { RTAI_COMEDI_LOCK(dev, subdev); rt_printk("COMEDI DIO READ: dev = %p, subdev = %u, chan = %u.\n", dev, subdev, chan); val[0] = 0xFFFFFFFF; rt_printk("COMEDI DIO READ RETURNS %x.\n", val[0]); RTAI_COMEDI_UNLOCK(dev, subdev); return 1; }
void prh1(unsigned long data) { if (prtloops++ < LOOPS) { rt_printk("\nFIRED NEW PERIODIC: %3d, %lx", prtloops, data); } else { rt_printk("\n"); rt_remove_timer(&prt); } }
static void alloc_collector(struct rtskb *skb, struct rtsocket *sock) { int i; unsigned int flags; struct ip_collector *p_coll; struct iphdr *iph = skb->nh.iph; /* Find free collector */ for (i = 0; i < COLLECTOR_COUNT; i++) { p_coll = &collector[i]; flags = rt_spin_lock_irqsave(&p_coll->frags.lock); /* * This is a very simple version of a garbage collector. * Whenver the last access to any of the collectors is a while ago, * the collector will be freed... * Under normal conditions, it should never be necessary to collect * the garbage. * */ if (p_coll->in_use && (counter - p_coll->last_accessed > GARBAGE_COLLECT_LIMIT)) { kfree_rtskb(p_coll->frags.first); p_coll->in_use = 0; rt_printk("RTnet: IP fragmentation garbage collection " "(saddr:%x, daddr:%x)\n", p_coll->saddr, p_coll->daddr); } /* Collector (now) free? */ if (!p_coll->in_use) { p_coll->in_use = 1; p_coll->last_accessed = counter; p_coll->buf_size = skb->len; p_coll->frags.first = skb; p_coll->frags.last = skb; p_coll->saddr = iph->saddr; p_coll->daddr = iph->daddr; p_coll->id = iph->id; p_coll->protocol = iph->protocol; p_coll->sock = sock; rt_spin_unlock_irqrestore(flags, &p_coll->frags.lock); return; } rt_spin_unlock_irqrestore(flags, &p_coll->frags.lock); } rt_printk("RTnet: IP fragmentation - no collector available\n"); kfree_rtskb(skb); }
static RTAI_SYSCALL_MODE int _comedi_data_read_delayed(void *dev, unsigned int subdev, unsigned int chan, unsigned int range, unsigned int aref, lsampl_t *data, unsigned int nanosec) { RTAI_COMEDI_LOCK(dev, subdev); rt_printk("COMEDI DATA READ DELAYED: dev = %p, subdev = %u, chan = %u, range = %u, aref = %x, nanosec = %u.\n", dev, subdev, chan, range, aref, nanosec); rt_sleep(nano2count(nanosec)); data[0] = 0xcaccae; rt_printk("COMEDI DATA READ DELAYED RETURNS %x.\n", data[0]); RTAI_COMEDI_UNLOCK(dev, subdev); return 1; }
static RTAI_SYSCALL_MODE int _comedi_poll(void *dev, unsigned int subdev) { int retval; RTAI_COMEDI_LOCK(dev, subdev); rt_printk("COMEDI POLL: dev = %p, subdev = %u.\n", dev, subdev); retval = 33; rt_printk("COMEDI POLL RETURNS %d.\n", retval); RTAI_COMEDI_UNLOCK(dev, subdev); return retval; }
static RTAI_SYSCALL_MODE unsigned int _comedi_get_subdevice_flags(void *dev, unsigned int subdev) { int retval; RTAI_COMEDI_LOCK(dev, subdev); rt_printk("COMEDI GET SUBDEVICE FLAGS: dev = %p, subdev = %u.\n", dev, subdev); retval = 0x77777777; rt_printk("COMEDI GET SUBDEVICE FLAGS RETURNS %d.\n", retval); RTAI_COMEDI_UNLOCK(dev, subdev); return retval; }
static RTAI_SYSCALL_MODE int _comedi_get_buf_head_pos(void * dev, unsigned int subdev) { int retval; RTAI_COMEDI_LOCK(dev, subdev); rt_printk("COMEDI GET BUF HEAD POS: dev = %p, subdev = %u.\n", dev, subdev); retval = 123456789; rt_printk("COMEDI GET BUF HEAD POS RETURNS %d.\n", retval); RTAI_COMEDI_UNLOCK(dev, subdev); return retval; }
RTAI_SYSCALL_MODE long rt_comedi_command_data_write(void *dev, unsigned int subdev, long nchans, lsampl_t *data) { int i; RTAI_COMEDI_LOCK(dev, subdev); rt_printk("COMEDI COMMAND WRITE: dev = %p, subdev = %u, nchans = %u.\n", dev, subdev, nchans); for (i = 0; i < nchans; i++) { rt_printk("CHAN = %d, data = %x.\n", i, data[i]); } RTAI_COMEDI_UNLOCK(dev, subdev); return nchans; }
static RTAI_SYSCALL_MODE int _comedi_command(void *dev, comedi_cmd *cmdin) { int i; comedi_cmd cmd = *cmdin; RTAI_COMEDI_LOCK(dev, cmd.subdev); rt_printk("COMEDI COMMAND: subdev = %u, flgas = %u, start_src = %u, start_arg = %u, scan_begin_src = %u, scan_begin_arg = %u, convert_src = %u, convert_arg = %u, scan_end_src = %u, scan_end_arg = %u, stop_src = %u, stop_arg = %u, chanlist_len = %u.\n", cmd.subdev, cmd.flags, cmd.start_src, cmd.start_arg, cmd.scan_begin_src, cmd.scan_begin_arg, cmd.convert_src, cmd.convert_arg, cmd.scan_end_src, cmd.scan_end_arg, cmd.stop_src, cmd.stop_arg, cmd.chanlist_len); for (i = 0; i < cmd.chanlist_len; i++) { rt_printk("CHANLIST: # %d, val = %u.\n", i, cmd.chanlist[i]); } RTAI_COMEDI_UNLOCK(dev, cmd.subdev); return 0; }