lkml.org 
[lkml]   [2002]   [Aug]   [15]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    /
    Date
    From
    SubjectRe: [patch] user-vm-unlock-2.5.31-A2
    Ingo Molnar wrote:
    > (there's no need to intercept anything - glibc *is* the only legitimate
    > code that might call the raw sys_execve() & sys_exit() system-calls.)

    This is very glibc-centred.

    I'm thinking of glibc (or other libc) + non-glibc (and non-pthreads)
    thread library, for a language's run-time environment.

    The less interception, and also signal wrappers (ugly things), that have
    to be written in the _application-specific thread library_, which still
    wishes to interface with unknown 3rd party libraries remember, the
    better.

    Linus Torvalds wrote:
    > On Tue, 13 Aug 2002, Ingo Molnar wrote:
    > > we dont really want any signal overhead, and we also dont want any extra
    > > context-switching to the 'master thread'. And there's no master thread
    > > anymore either.
    >
    > That still doesn't make it any les crap: because any thread that exits
    > without calling the "magic exit-flag interface" will then silently be
    > lost, with no information left around anywhere.

    also:
    > If the parent wants to get notified on child death, it should damn well
    > get notified on child death. Not "in case the child exists politely".

    Ingo, the reason I suggest a futex, and to store the exit status in it,
    is precisely because of the above by Linus... if a thread exits without
    calling "magic exit-flag interface" I would still like a parent thread
    to know about it. (This is for _non-glibc-threads_ applications). And
    I would like this while having the benefit of CLONE_DETACHED - because I
    want to use this for high performance threading but still be robust - so
    waitpid() is out.

    So - following Linus' note on CLONE_CLRTID - store the tid when the
    thread is created, store the exit status when the thread is destroyed,
    and after storing the exit status, call sys_futex(address, FUTEX_WAKE,
    1, 0) if the word value before storing was non-zero. The condition is
    to avoid the slowness of sys_futex when it's not required. It's
    probably most simple to use two consecutive words, for simplicity and to
    avoid needing an atomic store (which is slower on some architectures).

    This gives synchronous (FUTEX_WAIT), asynchronous (FUTEX_FD) and polling
    (just read memory) interfaces to a parent monitoring its child (or
    siblings monitoring each other). It gives access to the same
    information as waitpid(), but with the advantages of CLONE_DETACHED.

    All this for these few untested lines in the exit path :-)

    if (tsk->user_vm_lock) {
    long user_word;
    if (likely(!get_user(user_word, tsk->user_vm_lock))) {
    put_user(tsk->exit_code, tsk->user_vm_lock);
    wmb();
    if (user_word < 0)
    sys_futex (tsk->user_vm_lock, FUTEX_WAKE, -user_word, 0);
    }
    }

    -- Jamie
    -
    To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
    the body of a message to majordomo@vger.kernel.org
    More majordomo info at http://vger.kernel.org/majordomo-info.html
    Please read the FAQ at http://www.tux.org/lkml/

    \
     
     \ /
      Last update: 2005-03-22 13:28    [W:0.025 / U:1.392 seconds]
    ©2003-2016 Jasper Spaans. hosted at Digital OceanAdvertise on this site