/* public functions ========================================================= */ int speed_init(void) { if (running) { goto err_running; } if ((ostream = fopen("speed", "w")) == NULL) { goto err_ostream; } rt_intr_create(&intr, NULL, 81, 0); rt_intr_enable(&intr); rt_mutex_create(&mutex_instant, NULL); rt_mutex_create(&mutex_average, NULL); rt_queue_create(&queue, "irq81", QUEUE_SIZE, Q_UNLIMITED, Q_FIFO); rt_task_spawn(&task_soft, NULL, 0, 80, 0, task_soft_routine, NULL); rt_task_spawn(&task_hard, NULL, 0, 90, 0, task_hard_routine, NULL); instant = 0; average = 0; running = 1; return 0; err_ostream: err_running: return -1; }
int main(int argc, char * argv[]) { RT_TASK task; RTIME periode; int err; int fd; int zero = 0; fd = open("/dev/cpu_dma_latency", O_WRONLY); if (fd >= 0) { write(fd, & zero, sizeof(zero)); // ne pas fermer le fichier avant la fin du processus } if ((argc != 2) || (sscanf(argv[1], "%llu", & periode) != 1)) { fprintf(stderr, "usage: %s periode_en_us\n", argv[0]); exit(EXIT_FAILURE); } mlockall(MCL_CURRENT|MCL_FUTURE); rt_print_auto_init(1); if ((err = rt_task_spawn(& task, NULL, 0, 99, T_JOINABLE, fonction_periodique, & periode)) != 0) { fprintf(stderr, "rt_task_spaw: %s\n", strerror(-err)); exit(EXIT_FAILURE); } rt_task_join(& task); return 0; }
int main(int argc, char *argv[]) { int err, ret; printf("start\n"); // install signal handler signal(SIGTERM, clean_exit); signal(SIGINT, clean_exit); // start timer -> depricated in Xeno 2.2 /* ret = rt_timer_start(TM_ONESHOT); switch (ret) { case 0: printf("timer started\n"); break; case -EBUSY: printf("timer is running\n"); break; case -ENOSYS: printf("can't start timer\n"); return ret; } */ mlockall(MCL_CURRENT | MCL_FUTURE); err = rt_task_spawn(&test_task_ptr, "Timer", STACK_SIZE, STD_PRIO, 0, &testtask, NULL); if (err) { printf("error rt_task_spawn\n"); return 0; } // wait for signal & return of signal handler pause(); fflush(NULL); return 0; }
int main(void) { int err; int i; RT_TASK task[NB_TACHES]; char nom_tache[80]; mlockall(MCL_CURRENT|MCL_FUTURE); rt_print_auto_init(1); if ((err = rt_alarm_create(& alarme, "Ex01")) != 0) { fprintf(stderr, "rt_alarm_create(): %s\n", strerror(-err)); exit(EXIT_FAILURE); } for (i = 0; i < NB_TACHES-1; i++) { snprintf(nom_tache, 80, "Alarme-%d\n", i+1); if ((err = rt_task_spawn(& (task[i]), nom_tache, 0, 90-NB_TACHES + i, T_JOINABLE, fonction_thread, (void *) (i+1))) != 0) { fprintf(stderr, "rt_task_spawn: %s\n", strerror(-err)); exit(EXIT_FAILURE); } } if ((err = rt_alarm_start(& alarme, TM_NOW, 1000000000)) != 0) { fprintf(stderr, "rt_alarm_start: %s\n", strerror(-err)); exit(EXIT_FAILURE); } for (i = 0; i < NB_TACHES; i ++) rt_task_join(& task[i]); return 0; }
int main(int argc, char * argv[]) { RT_TASK task; RTIME period; int err; int fd; int zero = 0; fd = open("/dev/cpu_dma_latency", O_WRONLY); if (fd >= 0) { write(fd, &zero, sizeof(zero)); // don't close the file before process termination. } if ((argc != 2) || (sscanf(argv[1], "%llu", &period) != 1)) { fprintf(stderr, "usage: %s period_us\n", argv[0]); exit(EXIT_FAILURE); } mlockall(MCL_CURRENT|MCL_FUTURE); err = rt_task_spawn(& task, NULL, 0, 99, T_JOINABLE, periodic_task, & period); if (err != 0) { fprintf(stderr, "rt_task_spaw: %s\n", strerror(-err)); exit(EXIT_FAILURE); } rt_task_join(& task); return 0; }
int root_thread_init (void) { rt_timer_set_mode(1000000); /* Forc 1ms periodic tick. */ rt_task_spawn(&consumer_task, "ConsumerTask", CONSUMER_STACK_SIZE, CONSUMER_TASK_PRI, 0, &consumer, NULL); rt_task_spawn(&producer_task, "ProducerTask", PRODUCER_STACK_SIZE, PRODUCER_TASK_PRI, 0, &producer, NULL); return 0; }
int main(void) { int err; RT_TASK task, task2; mlockall(MCL_CURRENT|MCL_FUTURE); rt_print_auto_init(1); if (((err = rt_task_spawn( & task,"HELLO",0,99,T_JOINABLE,hello,NULL)) != 0 )) { fprintf(stderr, "rt_task_spawn : %s\n",strerror(-err)); exit(EXIT_FAILURE); } if (((err = rt_task_spawn( & task2,"HELLO2",0,98,T_JOINABLE,hello2,NULL)) != 0 )) { fprintf(stderr, "rt_task_spawn : %s\n",strerror(-err)); exit(EXIT_FAILURE); } rt_task_join( & task ); rt_task_join( & task2); return 0; }
int main(int argc, char* argv[]) { char str[10]; int err; rt_print_auto_init(1); mlockall(MCL_CURRENT|MCL_FUTURE); rt_printf("start task\n"); sprintf(str, "hello"); //rt_task_create(&demo_task, str, 0, 50, 0); //rt_task_start(&demo_task, &demo, 0); err = rt_task_spawn(&demo_task, str, TASK_STKSZ, TASK_PRIO, TASK_MODE, &demo, NULL); if(!err)rt_task_delete(&demo_task); printf("task finished\n"); return 0; }
int main(int argc, char *const argv[]) { int ret; traceobj_init(&trobj, argv[0], sizeof(tseq) / sizeof(int)); ret = rt_alarm_create(&alrm, "ALARM", alarm_handler, &alrm); traceobj_check(&trobj, ret, 0); ret = rt_task_spawn(&t_main, "main_task", 0, 50, 0, main_task, NULL); traceobj_check(&trobj, ret, 0); traceobj_mark(&trobj, 8); traceobj_join(&trobj); traceobj_verify(&trobj, tseq, sizeof(tseq) / sizeof(int)); exit(0); }
void loop(void *arg){ Matrix outputMatrix=empty_matrix(1,1); RT_TASK pwm_task; lpt_init(); rt_task_spawn(&pwm_task,NULL,0,gs->task_prio,0,&pwm,NULL); while (running) { read_inputs(); //outputMatrix=periodic_function(io.input_result,io.input_num); write_outputs(outputMatrix); } rt_task_delete(&pwm_task); lpt_close(); }
int main() { RT_TASK task; // bloque la memoire virtuelle pour ne pas avoir de swap mlockall(MCL_CURRENT|MCL_FUTURE); // rt_print_auto_init(1); // spawn : cree et lance la tache : equiv rt_task_create + rt_task_start if (rt_task_spawn(& task, NULL, 0, 99, T_JOINABLE, fonction_periodique, NULL) != 0) { fprintf(stderr, "Impossible de creer la tache\n"); exit(EXIT_FAILURE); } rt_task_join(& task); return 0; }
int cond_wait_until(cond_t *cond, mutex_t *mutex, unsigned long long date) { struct timespec ts = { .tv_sec = date / NS_PER_S, .tv_nsec = date % NS_PER_S, }; return -pthread_cond_timedwait(cond, mutex, &ts); } #define cond_destroy(cond) (-pthread_cond_destroy(cond)) int thread_msleep(unsigned ms) { struct timespec ts = { .tv_sec = (ms * NS_PER_MS) / NS_PER_S, .tv_nsec = (ms * NS_PER_MS) % NS_PER_S, }; return -nanosleep(&ts, NULL); } int thread_spawn(thread_t *thread, int prio, void *(*handler)(void *cookie), void *cookie) { struct sched_param param; pthread_attr_t tattr; int err; pthread_attr_init(&tattr); pthread_attr_setinheritsched(&tattr, PTHREAD_EXPLICIT_SCHED); pthread_attr_setschedpolicy(&tattr, SCHED_FIFO); param.sched_priority = prio; pthread_attr_setschedparam(&tattr, ¶m); pthread_attr_setdetachstate(&tattr, PTHREAD_CREATE_JOINABLE); pthread_attr_setstacksize(&tattr, xeno_stacksize(0)); err = pthread_create(thread, &tattr, handler, cookie); pthread_attr_destroy(&tattr); return -err; } #define thread_yield() sched_yield() #define thread_kill(thread, sig) (-__real_pthread_kill(thread, sig)) #define thread_self() pthread_self() #define thread_join(thread) (-pthread_join(thread, NULL)) #else /* __NATIVE_SKIN__ */ typedef RT_MUTEX mutex_t; typedef RT_TASK *thread_t; typedef RT_COND cond_t; #define timer_read() rt_timer_read() int __mutex_init(mutex_t *mutex, const char *name, int type, int pi) { if (type == PTHREAD_MUTEX_ERRORCHECK) return -EINVAL; (void)(pi); return -rt_mutex_create(mutex, name); } #define mutex_init(mutex, type, pi) __mutex_init(mutex, #mutex, type, pi) #define mutex_destroy(mutex) rt_mutex_delete(mutex) #define mutex_lock(mutex) rt_mutex_acquire(mutex, TM_INFINITE) #define mutex_unlock(mutex) rt_mutex_release(mutex) int __cond_init(cond_t *cond, const char *name, int absolute) { (void)(absolute); return rt_cond_create(cond, name); } #define cond_init(cond, absolute) __cond_init(cond, #cond, absolute) #define cond_signal(cond) rt_cond_signal(cond) #define cond_wait(cond, mutex, ns) rt_cond_wait(cond, mutex, (RTIME)ns) #define cond_wait_until(cond, mutex, ns) \ rt_cond_wait_until(cond, mutex, (RTIME)ns) #define cond_destroy(cond) rt_cond_delete(cond) #define thread_self() rt_task_self() #define thread_msleep(ms) rt_task_sleep((RTIME)ms * NS_PER_MS) int thread_spawn_inner(thread_t *thread, const char *name, int prio, void *(*handler)(void *), void *cookie) { thread_t tcb; int err; tcb = malloc(sizeof(*tcb)); if (!tcb) return -ENOSPC; err = rt_task_spawn(tcb, name, 0, prio, T_JOINABLE, (void (*)(void *))handler, cookie); if (!err) *thread = tcb; return err; }
INTERNAL_QUAL int rtos_task_create(RTOS_TASK* task, int priority, unsigned cpu_affinity, const char* name, int sched_type, size_t stack_size, void * (*start_routine)(void *), ThreadInterface* obj) { rtos_task_check_priority(&sched_type, &priority); XenoCookie* xcookie = (XenoCookie*)malloc( sizeof(XenoCookie) ); xcookie->data = obj; xcookie->wrapper = start_routine; if ( name == 0 || strlen(name) == 0) name = "XenoThread"; task->name = strncpy( (char*)malloc( (strlen(name)+1)*sizeof(char) ), name, strlen(name)+1 ); task->sched_type = sched_type; // User requested scheduler. int rv; unsigned int aff = 0; if ( cpu_affinity != 0 ) { // calculate affinity: for(unsigned i = 0; i < 8*sizeof(cpu_affinity); i++) { if(cpu_affinity & (1 << i)) { // RTHAL_NR_CPUS is defined in the kernel, not in user space. So we just limit up to 7, until Xenomai allows us to get the maximum. if ( i > 7 ) { const unsigned int all_cpus = ~0; if ( cpu_affinity != all_cpus ) // suppress this warning when ~0 is provided log(Warning) << "rtos_task_create: ignoring cpu_affinity for "<< name << " on CPU " << i << " since it's larger than RTHAL_NR_CPUS - 1 (="<< 7 <<")"<<endlog(); } else { aff |= T_CPU(i); } } } } if (stack_size == 0) { log(Debug) << "Raizing default stack size to 128kb for Xenomai threads in Orocos." <<endlog(); stack_size = 128000; } // task, name, stack, priority, mode, fun, arg // UGLY, how can I check in Xenomai that a name is in use before calling rt_task_spawn ??? rv = rt_task_spawn(&(task->xenotask), name, stack_size, priority, T_JOINABLE | (aff & T_CPUMASK), rtos_xeno_thread_wrapper, xcookie); if ( rv == -EEXIST ) { free( task->name ); task->name = strncpy( (char*)malloc( (strlen(name)+2)*sizeof(char) ), name, strlen(name)+1 ); task->name[ strlen(name) ] = '0'; task->name[ strlen(name)+1 ] = 0; while ( rv == -EEXIST && task->name[ strlen(name) ] != '9') { task->name[ strlen(name) ] += 1; rv = rt_task_spawn(&(task->xenotask), task->name, stack_size, priority, T_JOINABLE | (aff & T_CPUMASK), rtos_xeno_thread_wrapper, xcookie); } } if ( rv == -EEXIST ) { log(Warning) << name << ": an object with that name is already existing in Xenomai." << endlog(); rv = rt_task_spawn(&(task->xenotask), 0, stack_size, priority, T_JOINABLE | (aff & T_CPUMASK), rtos_xeno_thread_wrapper, xcookie); } if ( rv != 0) { log(Error) << name << " : CANNOT INIT Xeno TASK " << task->name <<" error code: "<< rv << endlog(); return rv; } rt_task_yield(); return 0; }
int main(int argc, char **argv) { printf("%s\n","Created Model"); int serversock, clientsock; size_t clientlen; struct sockaddr_in server_addr, client_addr, view_addr[2]; unsigned int port; unsigned int view_port; char *portNum; mlockall(MCL_CURRENT | MCL_FUTURE); signal(SIGKILL, cleanup); if(argc < 1){ usage(*argv); exit(0); } int c; while((c = getopt(argc, argv, "p:b:v:")) != -1){ switch(c){char data[1024]; case 'p': port = atoi(strdup(optarg)); break; case 'v': view_port = atoi(strdup(optarg)); break; /* many potential super fast speeds can be achieved */ case 'b': ballThreadSpeed = atoi(optarg) > 0 ? atoi(optarg) : BTHREAD_RATIO; break; default: usage(*argv); exit(0); break; } } mThreadPid = getpid(); initializePong(); /* if(rt_task_create(&ballThread, "ball_Thread" ,4096, 99, 0)) rt_err("rt_task_create()"); if(rt_task_create(&recvThread[0], "Recv_Thread", 4096, 99, T_JOINABLE)) rt_err("rt_task_create()"); if(rt_task_create(&recvThread[1], "Recv2_Thread", 4096, 99, T_JOINABLE)) rt_err("rt_task_create()"); */ /* task creation */ char temp_ball_Thread[1000]; char temp_Recv_Thread[1000]; char temp_Recv2_Thread[1000]; sprintf(temp_ball_Thread,"BallThread%d",port); sprintf(temp_Recv_Thread,"RecvThread%d",port); sprintf(temp_Recv2_Thread,"RecvThread2%d",port); if(rt_task_create(&ballThread, temp_ball_Thread ,4096, 99, 0)) rt_err("rt_task_create()"); if(rt_task_create(&recvThread[0], temp_Recv_Thread, 4096, 99, T_JOINABLE)) rt_err("rt_task_create()"); if(rt_task_create(&recvThread[1], temp_Recv2_Thread, 4096, 99, T_JOINABLE)) rt_err("rt_task_create()"); /* creation of mutexes for buffer */ unsigned int i = 0; for(; i < 3; i++){ char buf[8]; sprintf(buf, "Mutex %d %d", i, port); if(rt_mutex_create(&txMutex[i], buf)) rt_err("rt_mutex_create()"); } char temp_start_mutex[1000]; sprintf(temp_start_mutex,"AutoStartMutex%d",port); if(rt_mutex_create(&autoStart, temp_start_mutex)) rt_err("rt_mutex_create()"); i = 0; /* socket creation and structure initialization*/ if ((serversock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) errx(EXIT_FAILURE, "socket()", strerror(-errno)); int yes = 1; if(setsockopt(serversock,SOL_SOCKET,SO_REUSEADDR,&yes,sizeof(int)) == -1){ perror("Setsockopt"); exit(1); } server_addr.sin_family = AF_INET; server_addr.sin_addr.s_addr = htonl(INADDR_ANY); server_addr.sin_port = htons(port); /* server port */ if (bind(serversock, (struct sockaddr *) &server_addr, sizeof(server_addr)) < 0){ close(serversock); errx(EXIT_FAILURE, "bind():", strerror(errno)); } /* listens for Game Controller only*/ if (listen(serversock, 1) < 0) errx(EXIT_FAILURE, "listen():", strerror(-errno)); int viewSocket; if ((viewSocket = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) rt_err("socket()"); /* connection loop */ printf("Waiting for connections ...\n"); while(true){ char *currClient; clientlen = sizeof(struct sockaddr_in); clientsock = accept(serversock, (struct sockaddr *)&client_addr, (socklen_t *)&clientlen); currClient = (char *)inet_ntoa(client_addr.sin_addr); if(i > 1 || (i < 1 && !issuedStart)){ //game in play by force or 2 players close(clientsock); fprintf(stderr, "rejecting %s " "only 2 clients allowed!\n", currClient); continue; } //spawn the receive thread for simulator player_t players[2]; players[i].socket = clientsock; players[i].vsocket = viewSocket; players[i].addr = client_addr; if(rt_task_start(&recvThread[i], recv_data, (void *)&players[i])) rt_err("rt_task_start()"); i++; viewMode++; /* 1st player connected */ if(i == 1){ initSock = clientsock; /* spawn task to countdown */ if(rt_task_spawn(&alarmTask, "AutoStart", 4096, 99, 0, alarm_handler, (void *)viewSocket)) rt_err("rt_task_spawn()"); /* start the ball thread and it handles further movement */ if(rt_task_start(&ballThread, run,(void*)viewSocket)) rt_err("rt_task_start()"); printf("1 Player Connected ...\n"); /* now need to connect to the view */ memset(&view_addr[0], 0, sizeof(view_addr[0])); view_addr[0].sin_family = AF_INET; view_addr[0].sin_addr.s_addr = inet_addr(currClient); view_addr[0].sin_port = htons(view_port); /* Establish connection to view */ if (connect(viewSocket,(struct sockaddr *) &view_addr[0], sizeof(view_addr[0])) < 0) rt_err("connect()"); } /* the case when both players start before one-shot alarm */ if(i == 2){ /*Now need to connect the second view if there is one*/ if ((viewSocket2= socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) rt_err("socket()");/*2 View mode case*/ memset(&view_addr[1], 0, sizeof(view_addr[1])); view_addr[1].sin_family = AF_INET; view_addr[1].sin_addr.s_addr = inet_addr(currClient); view_addr[1].sin_port = htons(view_port); if (connect(viewSocket2,(struct sockaddr *) &view_addr[1], sizeof(view_addr[1])) < 0) rt_err("connect()2"); rt_mutex_acquire(&autoStart, TM_INFINITE); issuedStart = false; rt_mutex_release(&autoStart); rt_task_resume(&recvThread[0]); rt_task_resume(&recvThread[1]); } } //join on receive rt_task_join(&recvThread[0]); rt_task_join(&recvThread[1]); return 0; }
int main(int argc, char **argv) { int serversock, clientsock; size_t clientlen; struct sockaddr_in server_addr, client_addr, view_addr; unsigned int port = MODEL_DEFAULT_PORT; //models and view iff on same cpu char *ipAddress; mlockall(MCL_CURRENT | MCL_FUTURE); if(argc < 3){ usage(*argv); exit(0); } int c; while((c = getopt(argc, argv, "i:b:")) != -1){ switch(c){ case 'i': ipAddress = strdup(optarg); break; /* many potential super fast speeds can be achieved */ case 'b': ballThreadSpeed = atoi(optarg) > 0 ? atoi(optarg) : BTHREAD_RATIO; break; default: usage(*argv); exit(0); break; } } initializePong(); /* task creation */ if(rt_task_create(&ballThread, "BallThread", 4096, 99, 0)) rt_err("rt_task_create()"); if(rt_task_create(&recvThread[0], "RecvThread", 4096, 99, T_JOINABLE)) rt_err("rt_task_create()"); if(rt_task_create(&recvThread[1], "RecvThread1", 4096, 99, T_JOINABLE)) rt_err("rt_task_create()"); /* creation of mutexes for buffer */ unsigned int i = 0; for(; i < 3; i++){ char buf[8]; sprintf(buf, "Mutex %d", i); if(rt_mutex_create(&txMutex[i], buf)) rt_err("rt_mutex_create()"); } if(rt_mutex_create(&autoStart, "AutoStartMutex")) rt_err("rt_mutex_create()"); i = 0; /* socket creation and structure initialization*/ if ((serversock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) errx(EXIT_FAILURE, "socket()", strerror(-errno)); memset(&server_addr, 0, sizeof(server_addr)); server_addr.sin_family = AF_INET; /* Internet/IP */ server_addr.sin_addr.s_addr = htonl(INADDR_ANY); server_addr.sin_port = htons(port); /* server port */ if (bind(serversock, (struct sockaddr *) &server_addr, sizeof(server_addr)) < 0){ close(serversock); errx(EXIT_FAILURE, "bind():", strerror(errno)); } /* listens for Game Controller only*/ if (listen(serversock, 1) < 0) errx(EXIT_FAILURE, "listen():", strerror(-errno)); /* now need to connect to the view */ int viewSocket; if ((viewSocket = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) rt_err("socket()"); memset(&view_addr, 0, sizeof(view_addr)); view_addr.sin_family = AF_INET; view_addr.sin_addr.s_addr = inet_addr(ipAddress); view_addr.sin_port = htons(VIEW_DEFAULT_PORT); /* Establish connection to view */ if (connect(viewSocket, (struct sockaddr *) &view_addr, sizeof(view_addr)) < 0) rt_err("connect()"); /* connection loop */ printf("Waiting for connections ...\n"); while(true){ char *currClient; clientlen = sizeof(struct sockaddr_in); clientsock = accept(serversock, (struct sockaddr *)&client_addr, (socklen_t *)&clientlen); currClient = (char *)inet_ntoa(client_addr.sin_addr); if(i > 1 || (i < 1 && !issuedStart)){ //game in play by force or 2 players close(clientsock); fprintf(stderr, "rejecting %s " "only 2 clients allowed!\n", currClient); continue; } //spawn the receive thread for simulator player_t players[2]; players[i].socket = clientsock; players[i].vsocket = viewSocket; players[i].addr = client_addr; if(rt_task_start(&recvThread[i], recv_data, (void *)&players[i])) rt_err("rt_task_start()"); i++; /* 1st player connected */ if(i == 1){ initSock = clientsock; /* spawn task to countdown */ if(rt_task_spawn(&alarmTask, "AutoStart", 4096, 99, 0, alarm_handler, (void *)viewSocket)) rt_err("rt_task_spawn()"); /* start the ball thread and it handles further movement */ if(rt_task_start(&ballThread, run,(void*)viewSocket)) rt_err("rt_task_start()"); printf("1 Player Connected ...\n"); } /* the case when both players start before one-shot alarm */ if(i == 2){ rt_mutex_acquire(&autoStart, TM_INFINITE); issuedStart = false; rt_mutex_release(&autoStart); rt_task_resume(&recvThread[0]); rt_task_resume(&recvThread[1]); } } //join on receive rt_task_join(&recvThread[0]); rt_task_join(&recvThread[1]); return 0; }
int main(void) { unsigned long long before; RT_ALARM nalrm; RT_BUFFER nbuf; RT_COND ncond; RT_EVENT nevt; RT_HEAP nheap; RT_MUTEX nmtx; RT_PIPE npipe; RT_QUEUE nq; RT_SEM nsem; RT_TASK ntsk; int failed = 0; mlockall(MCL_CURRENT|MCL_FUTURE); rt_print_auto_init(1); rt_fprintf(stderr, "Checking for leaks in native skin services\n"); before = get_used(); check_native(rt_alarm_create(&nalrm, NULL)); check_native(rt_alarm_delete(&nalrm)); check_used("alarm", before, failed); before = get_used(); check_native(rt_buffer_create(&nbuf, NULL, 16384, B_PRIO)); check_native(rt_buffer_delete(&nbuf)); check_used("buffer", before, failed); before = get_used(); check_native(rt_cond_create(&ncond, NULL)); check_native(rt_cond_delete(&ncond)); check_used("cond", before, failed); before = get_used(); check_native(rt_event_create(&nevt, NULL, 0, EV_PRIO)); check_native(rt_event_delete(&nevt)); check_used("event", before, failed); before = get_used(); check_native(rt_heap_create(&nheap, "heap", 16384, H_PRIO | H_SHARED)); check_native(rt_heap_delete(&nheap)); check_used("heap", before, failed); before = get_used(); check_native(rt_mutex_create(&nmtx, NULL)); check_native(rt_mutex_delete(&nmtx)); check_used("mutex", before, failed); before = get_used(); check_native(rt_pipe_create(&npipe, NULL, P_MINOR_AUTO, 0)); check_native(rt_pipe_delete(&npipe)); check_used("pipe", before, failed); before = get_used(); check_native(rt_queue_create(&nq, "queue", 16384, Q_UNLIMITED, Q_PRIO)); check_native(rt_queue_delete(&nq)); check_used("queue", before, failed); before = get_used(); check_native(rt_sem_create(&nsem, NULL, 0, S_PRIO)); check_native(rt_sem_delete(&nsem)); check_used("sem", before, failed); before = get_used(); check_native(rt_task_spawn(&ntsk, NULL, 0, 1, T_JOINABLE, empty, NULL)); check_native(rt_task_join(&ntsk)); sleep(1); /* Leave some time for xnheap * deferred free */ check_used("task", before, failed); return failed ? EXIT_FAILURE : EXIT_SUCCESS; }
int main(int argc, char **argv) { char tempname[] = "/tmp/sigdebug-XXXXXX"; char buf[BUFSIZ], dev[BUFSIZ]; RT_TASK main_task, rt_task; long int start, trash, end; unsigned char *mayday, *p; struct sigaction sa; int old_wd_value; char r, w, x, s; int tmp_fd, d; FILE *maps; int err; rt_print_auto_init(1); if (argc < 2 || strcmp(argv[1], "--skip-watchdog") != 0) { wd = fopen("/sys/module/xeno_nucleus/parameters/" "watchdog_timeout", "w+"); if (!wd) { fprintf(stderr, "FAILURE: no watchdog available and " "--skip-watchdog not specified\n"); exit(EXIT_FAILURE); } err = fscanf(wd, "%d", &old_wd_value); check("get watchdog", err, 1); err = fprintf(wd, "2"); check("set watchdog", err, 1); fflush(wd); } maps = fopen("/proc/self/maps", "r"); if (maps == NULL) { perror("open /proc/self/maps"); exit(EXIT_FAILURE); } while (fgets(buf, sizeof(buf), maps)) { if (sscanf(buf, "%lx-%lx %c%c%c%c %lx %x:%x %d%s\n", &start, &end, &r, &w, &x, &s, &trash, &d, &d, &d, dev) == 11 && r == 'r' && x == 'x' && !strcmp(dev, "/dev/rtheap") && end - start == 4096) { printf("mayday page starting at 0x%lx [%s]\n" "mayday code:", start, dev); mayday = (unsigned char *)start; for (p = mayday; p < mayday + 32; p++) printf(" %.2x", *p); printf("\n"); } } fclose(maps); sigemptyset(&sa.sa_mask); sa.sa_sigaction = sigdebug_handler; sa.sa_flags = SA_SIGINFO; sigaction(SIGDEBUG, &sa, NULL); sa.sa_sigaction = dummy_handler; sigaction(SIGUSR1, &sa, NULL); printf("mlockall\n"); munlockall(); setup_checkdebug(SIGDEBUG_NOMLOCK); err = rt_task_shadow(&main_task, "main_task", 0, 0); check("rt_task_shadow", err, -EINTR); check_sigdebug_received("SIGDEBUG_NOMLOCK"); mlockall(MCL_CURRENT | MCL_FUTURE); errno = 0; tmp_fd = mkstemp(tempname); check_no_error("mkstemp", -errno); unlink(tempname); check_no_error("unlink", -errno); mem = mmap(NULL, 1, PROT_READ | PROT_WRITE, MAP_SHARED, tmp_fd, 0); check_no_error("mmap", -errno); err = write(tmp_fd, "X", 1); check("write", err, 1); err = rt_task_shadow(&main_task, "main_task", 0, 0); check_no_error("rt_task_shadow", err); err = rt_mutex_create(&prio_invert, "prio_invert"); check_no_error("rt_mutex_create", err); err = rt_mutex_acquire(&prio_invert, TM_INFINITE); check_no_error("rt_mutex_acquire", err); err = rt_sem_create(&send_signal, "send_signal", 0, S_PRIO); check_no_error("rt_sem_create", err); err = rt_task_spawn(&rt_task, "rt_task", 0, 1, T_WARNSW | T_JOINABLE, rt_task_body, NULL); check_no_error("rt_task_spawn", err); err = rt_sem_p(&send_signal, TM_INFINITE); check_no_error("rt_sem_signal", err); pthread_kill(rt_task_thread, SIGUSR1); rt_task_sleep(rt_timer_ns2ticks(20000000LL)); err = rt_mutex_release(&prio_invert); check_no_error("rt_mutex_release", err); err = rt_task_join(&rt_task); check_no_error("rt_task_join", err); err = rt_mutex_delete(&prio_invert); check_no_error("rt_mutex_delete", err); err = rt_sem_delete(&send_signal); check_no_error("rt_sem_delete", err); if (wd) { fprintf(wd, "%d", old_wd_value); fclose(wd); } fprintf(stderr, "Test OK\n"); return 0; }