EmbeddedPkg: Extend NvVarStoreFormattedLib LIBRARY_CLASS

[mirror_edk2.git] / AppPkg / Applications / Python / Python-2.7.2 / Python / thread_beos.h

#include <kernel/OS.h>\r
#include <support/SupportDefs.h>\r
#include <errno.h>\r
\r
/* ----------------------------------------------------------------------\r
 * Fast locking mechanism described by Benoit Schillings (benoit@be.com)\r
 * in the Be Developer's Newsletter, Issue #26 (http://www.be.com/).\r
 */\r
typedef struct benaphore {\r
    sem_id _sem;\r
    int32  _atom;\r
} benaphore_t;\r
\r
static status_t benaphore_create( const char *name, benaphore_t *ben );\r
static status_t benaphore_destroy( benaphore_t *ben );\r
static status_t benaphore_lock( benaphore_t *ben );\r
static status_t benaphore_timedlock( benaphore_t *ben, bigtime_t micros );\r
static status_t benaphore_unlock( benaphore_t *ben );\r
\r
static status_t benaphore_create( const char *name, benaphore_t *ben )\r
{\r
    if( ben != NULL ) {\r
        ben->_atom = 0;\r
        ben->_sem = create_sem( 0, name );\r
\r
        if( ben->_sem < B_NO_ERROR ) {\r
            return B_BAD_SEM_ID;\r
        }\r
    } else {\r
        return EFAULT;\r
    }\r
\r
    return EOK;\r
}\r
\r
static status_t benaphore_destroy( benaphore_t *ben )\r
{\r
    if( ben->_sem >= B_NO_ERROR ) {\r
        status_t retval = benaphore_timedlock( ben, 0 );\r
\r
        if( retval == EOK || retval == EWOULDBLOCK ) {\r
            status_t del_retval = delete_sem( ben->_sem );\r
\r
            return del_retval;\r
        }\r
    }\r
\r
    return B_BAD_SEM_ID;\r
}\r
\r
static status_t benaphore_lock( benaphore_t *ben )\r
{\r
    int32 prev = atomic_add( &(ben->_atom), 1 );\r
\r
    if( prev > 0 ) {\r
        return acquire_sem( ben->_sem );\r
    }\r
\r
    return EOK;\r
}\r
\r
static status_t benaphore_timedlock( benaphore_t *ben, bigtime_t micros )\r
{\r
    int32 prev = atomic_add( &(ben->_atom), 1 );\r
\r
    if( prev > 0 ) {\r
        status_t retval = acquire_sem_etc( ben->_sem, 1, B_TIMEOUT, micros );\r
\r
        switch( retval ) {\r
        case B_WOULD_BLOCK:             /* Fall through... */\r
        case B_TIMED_OUT:\r
            return EWOULDBLOCK;\r
            break;\r
        case B_OK:\r
            return EOK;\r
            break;\r
        default:\r
            return retval;\r
            break;\r
        }\r
    }\r
\r
    return EOK;\r
}\r
\r
static status_t benaphore_unlock( benaphore_t *ben )\r
{\r
    int32 prev = atomic_add( &(ben->_atom), -1 );\r
\r
    if( prev > 1 ) {\r
        return release_sem( ben->_sem );\r
    }\r
\r
    return EOK;\r
}\r
\r
/* ----------------------------------------------------------------------\r
 * Initialization.\r
 */\r
static void PyThread__init_thread( void )\r
{\r
    /* Do nothing. */\r
    return;\r
}\r
\r
/* ----------------------------------------------------------------------\r
 * Thread support.\r
 *\r
 * Only ANSI C, renamed functions here; you can't use K&R on BeOS,\r
 * and there's no legacy thread module to support.\r
 */\r
\r
static int32 thread_count = 0;\r
\r
long PyThread_start_new_thread( void (*func)(void *), void *arg )\r
{\r
    status_t success = 0;\r
    thread_id tid;\r
    char name[B_OS_NAME_LENGTH];\r
    int32 this_thread;\r
\r
    dprintf(("PyThread_start_new_thread called\n"));\r
\r
    /* We are so very thread-safe... */\r
    this_thread = atomic_add( &thread_count, 1 );\r
    PyOS_snprintf(name, sizeof(name),\r
                  "python thread (%d)", this_thread );\r
\r
    tid = spawn_thread( (thread_func)func, name,\r
                        B_NORMAL_PRIORITY, arg );\r
    if( tid > B_NO_ERROR ) {\r
        success = resume_thread( tid );\r
    }\r
\r
    return ( success == B_NO_ERROR ? tid : -1 );\r
}\r
\r
long PyThread_get_thread_ident( void )\r
{\r
    /* Presumed to return the current thread's ID... */\r
    thread_id tid;\r
    tid = find_thread( NULL );\r
\r
    return ( tid != B_NAME_NOT_FOUND ? tid : -1 );\r
}\r
\r
void PyThread_exit_thread( void )\r
{\r
    int32 threads;\r
\r
    dprintf(("PyThread_exit_thread called\n"));\r
\r
    /* Thread-safe way to read a variable without a mutex: */\r
    threads = atomic_add( &thread_count, 0 );\r
\r
    if( threads == 0 ) {\r
        /* No threads around, so exit main(). */\r
        exit(0);\r
    } else {\r
        /* Oh, we're a thread, let's try to exit gracefully... */\r
        exit_thread( B_NO_ERROR );\r
    }\r
}\r
\r
/* ----------------------------------------------------------------------\r
 * Lock support.\r
 */\r
\r
static int32 lock_count = 0;\r
\r
PyThread_type_lock PyThread_allocate_lock( void )\r
{\r
    benaphore_t *lock;\r
    status_t retval;\r
    char name[B_OS_NAME_LENGTH];\r
    int32 this_lock;\r
\r
    dprintf(("PyThread_allocate_lock called\n"));\r
\r
    lock = (benaphore_t *)malloc( sizeof( benaphore_t ) );\r
    if( lock == NULL ) {\r
        /* TODO: that's bad, raise MemoryError */\r
        return (PyThread_type_lock)NULL;\r
    }\r
\r
    this_lock = atomic_add( &lock_count, 1 );\r
    PyOS_snprintf(name, sizeof(name), "python lock (%d)", this_lock);\r
\r
    retval = benaphore_create( name, lock );\r
    if( retval != EOK ) {\r
        /* TODO: that's bad, raise an exception */\r
        return (PyThread_type_lock)NULL;\r
    }\r
\r
    dprintf(("PyThread_allocate_lock() -> %p\n", lock));\r
    return (PyThread_type_lock) lock;\r
}\r
\r
void PyThread_free_lock( PyThread_type_lock lock )\r
{\r
    status_t retval;\r
\r
    dprintf(("PyThread_free_lock(%p) called\n", lock));\r
\r
    retval = benaphore_destroy( (benaphore_t *)lock );\r
    if( retval != EOK ) {\r
        /* TODO: that's bad, raise an exception */\r
        return;\r
    }\r
}\r
\r
int PyThread_acquire_lock( PyThread_type_lock lock, int waitflag )\r
{\r
    int success;\r
    status_t retval;\r
\r
    dprintf(("PyThread_acquire_lock(%p, %d) called\n", lock, waitflag));\r
\r
    if( waitflag ) {\r
        retval = benaphore_lock( (benaphore_t *)lock );\r
    } else {\r
        retval = benaphore_timedlock( (benaphore_t *)lock, 0 );\r
    }\r
\r
    if( retval == EOK ) {\r
        success = 1;\r
    } else {\r
        success = 0;\r
\r
        /* TODO: that's bad, raise an exception */\r
    }\r
\r
    dprintf(("PyThread_acquire_lock(%p, %d) -> %d\n", lock, waitflag, success));\r
    return success;\r
}\r
\r
void PyThread_release_lock( PyThread_type_lock lock )\r
{\r
    status_t retval;\r
\r
    dprintf(("PyThread_release_lock(%p) called\n", lock));\r
\r
    retval = benaphore_unlock( (benaphore_t *)lock );\r
    if( retval != EOK ) {\r
        /* TODO: that's bad, raise an exception */\r
        return;\r
    }\r
}\r