ThreadStartDECwestGC.C

Go to the documentation of this file.

// Copyright (C) 2001, Compaq Computer Corporation

// This file is part of Vesta.

// Vesta is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.

// Vesta is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.

// You should have received a copy of the GNU Lesser General Public
// License along with Vesta; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

// Last modified on Sun May 22 21:41:14 EDT 2005 by ken@xorian.net
//      modified on Fri Aug 28 09:07:40 PDT 1998 by heydon

// A version of the "ThreadStart" interface to be linked with the
// DECwest garbage collector.

#include <signal.h>

#include "gc.h"
#include "Basics.H"
#include "ThreadStart.H"

void *Basics::ThreadStart_Callback(void *arg) throw ()
{
    void *res;
    /* Note: we can no longer use GC_THREAD_START/_END because they require
       non-portable pthread routines that Mike did not implement in his
       pthread library. Instead, we simulate their effects. For this to
       work, no forked thread should call pthread_exit() or be canceled. */
    // GC_THREAD_START
    gc_note_thread();

    // save arguments locally
    Basics::ForkArgs *forkArgs = (ForkArgs *)arg;

    // signal parent that child has started
    forkArgs->mu.lock();
    forkArgs->started = true;
    forkArgs->untilStarted.signal();
    forkArgs->mu.unlock();

    // ignore the PIPE signal
    signal(SIGPIPE, SIG_IGN);
    signal(SIGQUIT, SIG_DFL);
    signal(SIGABRT, SIG_DFL);
    signal(SIGSEGV, SIG_DFL);
    signal(SIGILL,  SIG_DFL);
    signal(SIGBUS,  SIG_DFL);

    // invoke the real procedure
    try {
        res = (*(forkArgs->proc))(forkArgs->arg);
    } catch (...) { gc_delete_thread_rec(0); throw; }
    // GC_THREAD_END
    gc_delete_thread_rec(0);

    return res;
}

void Basics::ThreadStart_WaitForChild(Basics::ForkArgs *forkArgs) throw ()
{
    forkArgs->mu.lock();
    while (!forkArgs->started) {
        forkArgs->untilStarted.wait(forkArgs->mu);
    }
    forkArgs->mu.unlock();
}

---