text: Wolfgang Grandegger wrote: > Gilles Chanteperdrix wrote: >> On Dec 10, 2007 4:20 PM, Wolfgang Grandegger <[EMAIL PROTECTED]> wrote: >>> Gilles Chanteperdrix wrote: >>>> Wolfgang Grandegger wrote: >>>> > Gilles Chanteperdrix wrote: >>>> > > Gilles Chanteperdrix wrote: >>>> > > > Wolfgang Grandegger wrote: >>>> > > > > Hi Gilles, >>>> > > > > >>>> > > > > Gilles Chanteperdrix wrote: >>>> > > > > > On Dec 6, 2007 3:05 PM, Wolfgang Grandegger <[EMAIL >>>> PROTECTED]> wrote: >>>> > > > > >> Gilles Chanteperdrix wrote: >>>> > > > > >>> On Dec 6, 2007 2:28 PM, Gilles Chanteperdrix >>>> > > > > >>> <[EMAIL PROTECTED]> wrote: >>>> > > > > >>>> On Dec 6, 2007 2:24 PM, Wolfgang Grandegger <[EMAIL >>>> PROTECTED]> wrote: >>>> > > > > >>>>> Gilles Chanteperdrix wrote: >>>> > > > > >>>>>> On Dec 6, 2007 1:31 PM, Wolfgang Grandegger <[EMAIL >>>> PROTECTED]> wrote: >>>> > > > > >>>>>>> Hello, >>>> > > > > >>>>>>> >>>> > > > > >>>>>>> how do I cancel or delete a Xenomai POSIX thread >>>> running in primary >>>> > > > > >>>>>>> context from a higher priority thread? IIUC, >>>> pthread_kill() can only be >>>> > > > > >>>>>>> used in secondary context. I tried pthread_cancel(), >>>> but it only works >>>> > > > > >>>>>>> when hitting a cancelation point, e.g. >>>> pthread_testcancel(). Setting >>>> > > > > >>>>>>> pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS) did >>>> not help. Is >>>> > > > > >>>>>>> there a code snippet or even an example program showing >>>> how to cancel a >>>> > > > > >>>>>>> pthread in primary context? >>>> > > > > >>>>>> pthread_kill or pthread_cancel should result in sending >>>> a signal to >>>> > > > > >>>>>> the target thread, so should cause this thread to switch >>>> to secondary >>>> > > > > >>>>>> mode to handle it. If you want to wait for the target >>>> thread to be >>>> > > > > >>>>>> canceled, you should use pthread_cancel and pthread_join. >>>> > > > > >>>>> There is no way to cancel a pthread in primary mode from >>>> another pthread? >>>> > > > > >>>> No. You always need secondary mode to effectively delete a >>>> thread. The >>>> > > > > >>>> same goes for the native skin. >>>> > > > > >>> Ok. I understand what you mean. You want pthread_cancel not >>>> to leave >>>> > > > > >>> primary mode. This can easily be done by causing >>>> pthread_cancel to use >>>> > > > > >>> the kernel-space real-time pthread_cancel service. This >>>> should work >>>> > > > > >>> with no further modification. >>>> > > > > >> I want to cancel/delete a task running in primary mode, e.g. >>>> > > > > >> >>>> > > > > >> void* work_task(void* dummy) >>>> > > > > >> { >>>> > > > > >> int count = 0; >>>> > > > > >> while (1) >>>> > > > > >> count++; >>>> > > > > >> } >>>> > > > > >> >>>> > > > > >> from the outside (= another higher priority task). How can I >>>> use the >>>> > > > > >> kernel-space real-time pthread_cancel service? My POSIX app >>>> is runs in >>>> > > > > >> user-land. >>>> > > > > > >>>> > > > > > I was thinking about adding a pthread_cancel syscall that >>>> would have >>>> > > > > > triggered the kernel-space pthread_cancel. But this will not >>>> work: >>>> > > > > > user-space cleanup handlers would no longer get executed. >>>> However, >>>> > > > > > this can work for pthread_kill. Here is a patch which adds the >>>> > > > > > pthread_kill syscall. >>>> > > > > >>>> > > > > Great, thanks a lot. This seems to work but I'm now fiddling >>>> with proper >>>> > > > > cleanup and exit. I have attached my small test program. It >>>> behaves >>>> > > > > somehow strange, at least to me: >>>> > > > > >>>> > > > > - I see task period overruns when the low prio task is started. >>>> I >>>> > > > > suspect some switch to secondary mode in init_task(). >>>> > > > > >>>> > > > > - The program/system hangs after the listed messages: >>>> > > > > >>>> > > > > # ./kill_pthread >>>> > > > > Starting high_prio_task >>>> > > > > Killed low_prio task: count=3813129, overruns=0 >>>> > > > > >>>> > > > > Any idea what I'm doing wrong? >>>> > > > > >>>> > > > > This is with Linux 2.4.25 and Xenomai 2.3.x on a MPC5200 board. >>>> > > > >>>> > > > Your test runs fine with Xenomai trunk (on ARM). I will now try >>>> with >>>> > > > current state of the v2.3.x branch. >>>> > > >>>> > > Works with v2.3.x too. >>>> > >>>> > I re-activated my test PC running Linux 2.6.20.21. with Xenomai 2.3.x. >>>> > There the program runs fine _without_ your pthread_kill patch. For some >>>> > reason the low_prio_task() is running in secondary mode (do you know >>>> > why? Is there a function to check the mode?). I added >>>> > >>>> > struct sched_param param = { .sched_priority = LOW_PRIO }; >>>> > pthread_setschedparam(pthread_self(), SCHED_FIFO, ¶m); >>> After adding pthread_getschedparam() I realized, that policy was 1 and >>> prio 10 and not as expected 5. The corresponding attribute settings >>> before calling pthread_create have been ignored somehow. Am I doing >>> something wrong in task_init()? >>> >>>> > to the head of that function and then I get: >>>> > >>>> > ./kill_pthread >>>> > Starting high_prio_task >>>> > BUG: NMI Watchdog detected LOCKUP >>>> > Killed low_prio task: count=1588495996, overruns=0 >>>> > Exiting main >>>> > >>>> > I have attached the corresponding oops in case it's of interest. >>>> > Unfortunately, with your patch and adding the function >>>> > __real_pthread_kill() to wrappers.c, the behavior is the same. I'm going >>>> > to repeat the tests with Xenomai trunk tomorrow. >>>> >>>> The oops is due to the NMI watchdog calling some linux domain functions >>>> over Xenomai domain. You should probably use Xenomai watchdog instead. >>>> >>>> As for the reason why the watchdog triggers: are you sure you are >>>> running the kernel recompiled after having applied the patch? >>> Indeed, after a "make clean; make bzImage" of the kernel it behaves >>> differently. Wired, may be some dependency issue. >>> >>> # ./kill_pthread >>> Starting high_prio_task >>> low_prio_task: policy=1 prio=10 >>> Killed low_prio task: count=172709970, overruns=0 >>> >>> [1]+ Stopped ./kill_pthread >> What you are observing is probably a difference between linuxthreads >> and NPTL: with linuxthreads, SIGSTOP can be sent to a particular >> thread and will cause this thread only to stop. With NPTL, it seems >> that the effect of SIGSTOP is global, it affects the entire process. I >> will test tonight on my x86 box to see if I observe the same effect. > > Ah, the man page says: > > Note that pthread_kill() only causes the signal to be handled in the > context of the given thread; the signal action (termination or stop- > ping) affects the process as a whole.
  The attached test application using a more sophisticated signal handling works fine on my MPC5200-board running Linux 2.6.23 and Xenomai trunk. Going to try it tomorrow on my PC. Wolfgang.
  #include <stdio.h> #include <pthread.h> #include <signal.h> #include <sys/mman.h> static int count; static int goon = 1; static pthread_t id_low; static pthread_t id_high; #define LOW_PRIO 5 #define HIGH_PRIO 10 #undef WITH_PRINTF #undef WITH_SIGXCPU void init_task(int prio); void* low_prio_task(void* dummy) { struct sched_param param; int policy; pthread_getschedparam(pthread_self(), &policy, ¶m); printf("%s: policy=%d prio=%d\n", __FUNCTION__, policy, param.sched_priority); param.sched_priority = LOW_PRIO; pthread_setschedparam(pthread_self(), SCHED_FIFO, ¶m); while (goon) { #ifdef WITH_PRINTF pthread_set_mode_np(0, PTHREAD_PRIMARY); printf("%s %d\n", __FUNCTION__, count); #endif count++; } printf("Exiting %s, count=%d\n", __FUNCTION__, count); return 0; } void* high_prio_task(void* dummy) { struct timespec tstart = { .tv_sec = 0, .tv_nsec = 0}; #ifdef WITH_PRINTF struct timespec tperiod = { .tv_sec = 0, .tv_nsec = 10000000 }; #else struct timespec tperiod = { .tv_sec = 0, .tv_nsec = 1000000 }; #endif unsigned long overruns = 0; int tick = 0, step = 0, loop = 0, err; struct sched_param param = { .sched_priority = HIGH_PRIO }; printf("Starting %s\n", __FUNCTION__); pthread_setschedparam(pthread_self(), SCHED_FIFO, ¶m); #ifdef WITH_SIGXCPU pthread_set_mode_np(0, PTHREAD_WARNSW); #endif err = pthread_make_periodic_np(pthread_self(), &tstart, &tperiod); if (err) return (void *)err; while (1) { err = pthread_wait_np(&overruns); #if 0 if (err) { pthread_kill(id_low, SIGSTOP); printf("%s overruns=%lu, tick=%d, count=%d, err=%d\n", __FUNCTION__, overruns, tick, count, err); return 0; } #endif if (step == 0 && loop > 100) { loop = 0; step = 1; init_task(LOW_PRIO); } else if (step == 1 && loop > 500) { loop = 0; step = 2; //goon = 0; pthread_kill(id_low, SIGUSR1); printf("SIGUSER1 to id_low: count=%d, overruns=%lu\n", count, overruns); } else if (step == 2 && loop > 500) { loop = 0; step = 1; pthread_kill(id_low, SIGUSR2); printf("SIGUSER2 to id_low: count=%d, overruns=%lu\n", count, overruns); } tick++; loop++; } printf("Exiting %s\n", __FUNCTION__); return 0; } void init_task(int prio) { struct sched_param parm; pthread_attr_t attr; pthread_attr_init(&attr); if (prio == HIGH_PRIO) pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE); else pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED); pthread_attr_setschedpolicy(&attr, SCHED_FIFO); parm.sched_priority = prio; pthread_attr_setschedparam(&attr, &parm); if (prio == HIGH_PRIO) { pthread_create(&id_high, &attr, high_prio_task, NULL); pthread_set_name_np(id_high,"high_prio"); } else { pthread_create(&id_low, &attr, low_prio_task, NULL); pthread_set_name_np(id_low,"low_prio"); } } void catch_signal(int sig) { printf("Signal %d catched\n", sig); } #ifdef WITH_SIGXCPU void catch_switch(int sig) { void *bt[32]; int nentries; printf("Signal %d catched\n", sig); /* Dump a backtrace of the frame which caused the switch to secondary mode: */ nentries = backtrace(bt,sizeof(bt) / sizeof(bt[0])); backtrace_symbols_fd(bt,nentries,fileno(stdout)); } #endif static void suspend_signal_handler(int sig) { sigset_t signal_set; printf("suspend signal handler\n"); sigfillset (&signal_set); sigdelset (&signal_set, SIGUSR2); sigsuspend(&signal_set); return; } static void resume_signal_handler(int sig) { printf("resume signal handler\n"); return; } void init_signals(sigset_t *mask) { struct sigaction sigusr1, sigusr2; sigemptyset(mask); sigaddset(mask, SIGINT); sigaddset(mask, SIGTERM); sigaddset(mask, SIGHUP); sigaddset(mask, SIGALRM); pthread_sigmask(SIG_BLOCK, mask, NULL); /* * Install the signal handlers for suspend/resume. */ sigemptyset (&sigusr1.sa_mask); sigusr1.sa_flags = 0; sigusr1.sa_handler = suspend_signal_handler; sigaction(SIGUSR1, &sigusr1, NULL); sigemptyset (&sigusr2.sa_mask); sigusr2.sa_flags = 0; sigusr2.sa_handler = resume_signal_handler; sigaction(SIGUSR2, &sigusr2, NULL); } int main(int argc, char *argv[]) { sigset_t mask; int sig; mlockall(MCL_CURRENT|MCL_FUTURE); #ifdef WITH_SIGXCPU signal(SIGXCPU, catch_switch); #endif #if 0 signal(SIGTERM, catch_signal); signal(SIGINT, catch_signal); signal(SIGHUP, catch_signal); #else init_signals(&mask); #endif init_task(HIGH_PRIO); #if 0 pthread_join(id_high, NULL); #else sigwait(&mask, &sig); #endif printf("Exiting %s\n", __FUNCTION__); return 0; }
  _______________________________________________ Xenomai-core mailing list Xenomai-core@gna.org