Subversion Repositories openrisc_me

/*

 *  $Id: mutexinit.c,v 1.2 2001-09-27 11:59:17 chris Exp $

 */

#include <assert.h>

#include <errno.h>

#include <pthread.h>

#include <rtems/system.h>

#include <rtems/score/coremutex.h>

#include <rtems/score/watchdog.h>

#if defined(RTEMS_MULTIPROCESSING)

#include <rtems/score/mpci.h>

#endif

#include <rtems/posix/mutex.h>

#include <rtems/posix/priority.h>

#include <rtems/posix/time.h>

/*PAGE

 *

 *  11.3.2 Initializing and Destroying a Mutex, P1003.1c/Draft 10, p. 87

 *

 *  NOTE:  XXX Could be optimized so all the attribute error checking

 *             is not performed when attr is NULL.

 */

int pthread_mutex_init(

  pthread_mutex_t           *mutex,

  const pthread_mutexattr_t *attr

)

{

  POSIX_Mutex_Control          *the_mutex;

  CORE_mutex_Attributes        *the_mutex_attr;

  const pthread_mutexattr_t    *the_attr;

  CORE_mutex_Disciplines        the_discipline;

#if 0

  register POSIX_Mutex_Control *mutex_in_use;

  Objects_Locations             location;

#endif

  if ( attr ) the_attr = attr;

  else        the_attr = &_POSIX_Mutex_Default_attributes;

  /* Check for NULL mutex */

  if ( !mutex )

    return EINVAL;

  /*

   *  This code should eventually be removed.

   *

   *  Although the POSIX specification says:

   *

   *  "Attempting to initialize an already initialized mutex results

   *  in undefined behavior."

   *

   *  Trying to keep the caller from doing the create when *mutex

   *  is actually a valid ID causes grief.  All it takes is the wrong

   *  value in an uninitialized variable to make this fail.  As best

   *  I can tell, RTEMS was the only pthread implementation to choose

   *  this option for "undefined behavior" and doing so has created

   *  portability problems.  In particular, Rosimildo DaSilva

   *  <rdasilva@connecttel.com> saw seemingly random failures in the

   *  RTEMS port of omniORB2 when this code was enabled.

   *

   *  Joel Sherrill <joel@OARcorp.com>     14 May 1999

   */

#if 0

  /* avoid infinite recursion on call to this routine in _POSIX_Mutex_Get */

  if ( *mutex != PTHREAD_MUTEX_INITIALIZER ) {

    /* EBUSY if *mutex is a valid id */

    mutex_in_use = _POSIX_Mutex_Get( mutex, &location );

    switch ( location ) {

      case OBJECTS_REMOTE:

      case OBJECTS_ERROR:

        break;

      case OBJECTS_LOCAL:

        _Thread_Enable_dispatch();

        return EBUSY;

    }

  }

#endif

  if ( !the_attr->is_initialized )

    return EINVAL;

  /*

   *  XXX: Be careful about attributes when global!!!

   */

  assert( the_attr->process_shared == PTHREAD_PROCESS_PRIVATE );

#if defined(RTEMS_MULTIPROCESSING)

  if ( the_attr->process_shared == PTHREAD_PROCESS_SHARED )

    return POSIX_MP_NOT_IMPLEMENTED();

#endif

  /*

   *  Determine the discipline of the mutex

   */

  switch ( the_attr->protocol ) {

    case PTHREAD_PRIO_NONE:

      the_discipline = CORE_MUTEX_DISCIPLINES_FIFO;

      break;

    case PTHREAD_PRIO_INHERIT:

      the_discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT;

      break;

    case PTHREAD_PRIO_PROTECT:

      the_discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING;

      break;

    default:

      return EINVAL;

  }

  if ( !_POSIX_Priority_Is_valid( the_attr->prio_ceiling ) )

    return EINVAL;

  _Thread_Disable_dispatch();

  the_mutex = _POSIX_Mutex_Allocate();

  if ( !the_mutex ) {

    _Thread_Enable_dispatch();

    return EAGAIN;

  }

#if defined(RTEMS_MULTIPROCESSING)

  if ( the_attr->process_shared == PTHREAD_PROCESS_SHARED &&

       !( _Objects_MP_Allocate_and_open( &_POSIX_Mutex_Information, 0,

                            the_mutex->Object.id, FALSE ) ) ) {

    _POSIX_Mutex_Free( the_mutex );

    _Thread_Enable_dispatch();

    return EAGAIN;

  }

#endif

  the_mutex->process_shared = the_attr->process_shared;

  the_mutex_attr = &the_mutex->Mutex.Attributes;

  if ( the_attr->recursive )

    the_mutex_attr->lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES;

  else

    the_mutex_attr->lock_nesting_behavior = CORE_MUTEX_NESTING_IS_ERROR;

  the_mutex_attr->only_owner_release = TRUE;

  the_mutex_attr->priority_ceiling =

    _POSIX_Priority_To_core( the_attr->prio_ceiling );

  the_mutex_attr->discipline = the_discipline;

  /*

   *  Must be initialized to unlocked.

   */

  _CORE_mutex_Initialize(

    &the_mutex->Mutex,

    OBJECTS_POSIX_MUTEXES,

    the_mutex_attr,

    CORE_MUTEX_UNLOCKED,

    NULL                      /* proxy_extract_callout */

  );

  _Objects_Open( &_POSIX_Mutex_Information, &the_mutex->Object, 0 );

  *mutex = the_mutex->Object.id;

#if defined(RTEMS_MULTIPROCESSING)

  if ( the_attr->process_shared == PTHREAD_PROCESS_SHARED )

    _POSIX_Mutex_MP_Send_process_packet(

      POSIX_MUTEX_MP_ANNOUNCE_CREATE,

      the_mutex->Object.id,

      0,                         /* Name not used */

    );

#endif

  _Thread_Enable_dispatch();

  return 0;

}