Re: [Xenomai-help] rtdm_event_timedwait returns -EINTR

["Petr Cervenka" <grugh@domain.hid>]

[-- Attachment #1: Type: text/plain, Size: 2436 bytes --]

From: gilles.chanteperdrix@xenomai.org
>Petr Cervenka wrote:

>> I have found following problems / errors: 
>> -------------------------------------------------------------- 1)
>> rtdm_event_timedwait() in ioctl handler is not automatically
>> internally restarted (driver: rtdm, app. tasks: native)
>
>That is because rtdm_event_timedwait is not a syscall. It is a
>kernel-space call. Your job is to get ioctl to return -EINTR when
>rtdm_event_timedwait returns -EINTR, so that ioctl will be restarted in
>user-space.
>
>This is undocumented, because you should already know about that if you
>have done a little driver work under linux.
>

Finally I start to understand it. Sorry, but I wrote only couple of drivers. With 
knowledge of hardware but not linux.

>> 
>> 2) computer hangs, when I call in ioctl handler something like: do { 
>> res = rtdm_event_timedwait(&event, timeout, NULL); } while (res ==
>> -EINTR); this could have perhaps some relevance:
>> https://mail.gna.org/public/xenomai-help/2008-11/msg00025.html
>
>That is because you should return to user-space to get the signal handled.
>

So it is better to divide longer operation with device (for example initialization) 
into two ioctls. First one for registry settings and second one for waiting for 
ready state. Or am I wrong?

>> 
>> 3) rt_event_wait() in application is restarted always with the same
>> relative timeout. it could run forever.
>
>Yes, we know that, and we know a fix. But another fix is to use the new
>*_until calls.
>
>> 
>> problems with version 2.5-rc1: 
>> ----------------------------------------------- 1) function
>> rt_task_shadow always returns -EFAULT
>
>Could you provide us with a small example which has this problem ?
>

Example is in the attachment.

>> 
>> 2) when resizing window with latency test running, it prints out "Not
>> SIGSHADOW !". But it should be SIGSHADOW (in my opinion).
>
>"Not SIGSHADOW!" is printed when the SIGWINCH signal handler identifies
>a SIGWINCH not originating from Xenomai. And when you resize the window,
>a SIGWINCH is sent to the application which originates from the Linux
>kernel, not from Xenomai. So, the "Not SIGSHADOW!" is correct. However,
>it is essentially a debug message
>

Oh, it my fault. When I identified these signals as SIGWINCH, I automatically 
assumed that it's SIGHARDEN. I completely forgot to look at the basic mean 
of SIGWINCH signal. I feel little ashamed.

Petr


[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #2: main.cpp --]
[-- Type: text/x-c++src; name="main.cpp", Size: 1390 bytes --]

#include <sys/mman.h>
#include <native/task.h>
#include <native/event.h>
#include <native/timer.h>

#define MY_EVENT    0x00000001ll
#define MY_PRIORITY 99

static RT_TASK mainTask;

int main(int argc, char** argv) {
    const double ONE_SEC = 1e9;
    const RTIME timeout = (RTIME)(5 * ONE_SEC);
    RT_EVENT event;
    unsigned long mask;
    RTIME start, end;
    int res;

    mlockall(MCL_CURRENT | MCL_FUTURE);

    res = rt_task_shadow(&mainTask, "main_task", MY_PRIORITY, 0);
    if (res < 0) {
        printf("rt_task_shadow(): %d (%s)\n", res, strerror(-res));
    }

    res = rt_task_set_mode(0, T_PRIMARY, NULL);
    if (res < 0) {
        printf("rt_task_set_mode(): %d (%s)\n", res, strerror(-res));
    }

    res = rt_event_create(&event, NULL, 0, EV_PRIO);
    if (res < 0) {
        printf("rt_event_create(): %d (%s)\n", res, strerror(-res));
    }

    start = rt_timer_read();
    res = rt_event_wait(&event, MY_EVENT, &mask, EV_ALL, rt_timer_ns2ticks(timeout));
    end = rt_timer_read();
    
    if (res < 0 && res != -ETIMEDOUT) {
        printf("rt_event_wait(): %d (%s)\n", res, strerror(-res));
    }

    printf("time - measured %g s, wanted %g s\n", rt_timer_ticks2ns(end - start)/ONE_SEC, timeout/ONE_SEC);
    
    res = rt_event_delete(&event);
    if (res < 0) {
        printf("rt_event_delete(): %d (%s)\n", res, strerror(-res));
    }

    return 0;
}