Subversion Repositories shark

/*
 * Project: S.Ha.R.K.
 *
 * Coordinators:
 *   Giorgio Buttazzo    <giorgio@sssup.it>
 *   Paolo Gai           <pj@gandalf.sssup.it>
 *
 * Authors     :
 *   Paolo Gai           <pj@gandalf.sssup.it>
 *   Massimiliano Giorgi <massy@gandalf.sssup.it>
 *   Luca Abeni          <luca@gandalf.sssup.it>
 *   (see the web pages for full authors list)
 *
 * ReTiS Lab (Scuola Superiore S.Anna - Pisa - Italy)
 *
 * http://www.sssup.it
 * http://retis.sssup.it
 * http://shark.sssup.it
 */

/**
 ------------
 CVS :        $Id: pthread.h,v 1.2 2003-03-13 13:41:04 pj Exp $

 File:        $File$
 Revision:    $Revision: 1.2 $
 Last update: $Date: 2003-03-13 13:41:04 $
 ------------

 pthread.h

 the commented functions are not implemented yet...

**/

/*
 * Copyright (C) 2000 Paolo Gai
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 */

#ifndef __PTHREAD_H__
#define __PTHREAD_H__

#include <kernel/const.h>
#include <sys/types.h>
#include <signal.h>
#include <errno.h>
#include <kernel/func.h>
#include <arch/sys/cdefs.h>

__BEGIN_DECLS

void PTHREAD_register_module(LEVEL sched, RLEVEL pi, RLEVEL pc);

#define PTHREAD_CANCELED                TASK_CANCELED
#define PTHREAD_CANCEL_ASYNCHRONOUS     TASK_CANCEL_ASYNCHRONOUS
#define PTHREAD_CANCEL_DEFERRED         TASK_CANCEL_DEFERRED    
#define PTHREAD_CANCEL_DISABLE          TASK_CANCEL_DISABLE
#define PTHREAD_CANCEL_ENABLE           TASK_CANCEL_ENABLE
#define PTHREAD_COND_INITIALIZER  {NIL,NULL}
#define PTHREAD_CREATE_DETACHED     0
#define PTHREAD_CREATE_JOINABLE     1
#define PTHREAD_EXPLICIT_SCHED      0
#define PTHREAD_INHERIT_SCHED       1
#define PTHREAD_MUTEX_INITIALIZER {0,(void *)NULL}
#define PTHREAD_ONCE_INIT           0
#define PTHREAD_PRIO_INHERIT        1
#define PTHREAD_PRIO_NONE           0
#define PTHREAD_PRIO_PROTECT        2
// NRQ for PSE52 #define PTHREAD_PROCESS_PRIVATE
// NRQ for PSE52 #define PTHREAD_PROCESS_SHARED

/* there is no difference in PSE52!!! (only one process...) */
#define PTHREAD_SCOPE_PROCESS 0
#define PTHREAD_SCOPE_SYSTEM  0

// NRQ for PSE52 pthread_atfork
int pthread_attr_destroy(pthread_attr_t *attr);
int pthread_attr_getdetachstate(const pthread_attr_t *attr, int *detachstate);
int pthread_attr_getinheritsched(pthread_attr_t *attr, int *inheritsched);
int pthread_attr_getschedparam(const pthread_attr_t *attr, struct sched_param *param);
int pthread_attr_getschedpolicy(const pthread_attr_t *attr, int *policy);
int pthread_attr_getscope(const pthread_attr_t *attr, int *contentionscope);
int pthread_attr_getstackaddr(const pthread_attr_t *attr, void **stackaddr);
int pthread_attr_getstacksize(const pthread_attr_t *attr, size_t *stacksize);
int pthread_attr_init(pthread_attr_t *attr);
int pthread_attr_setdetachstate(pthread_attr_t *attr, int detachstate);
int pthread_attr_setinheritsched(pthread_attr_t *attr, int inheritsched);
int pthread_attr_setschedparam(pthread_attr_t *attr, const struct sched_param *param);
int pthread_attr_setschedpolicy(pthread_attr_t *attr, int policyt);
int pthread_attr_setscope(pthread_attr_t *attr, int *contentionscope);
int pthread_attr_setstackaddr(pthread_attr_t *attr, void *stackaddr);
int pthread_attr_setstacksize(pthread_attr_t *attr, size_t stacksize);
int pthread_cancel(pthread_t thread);
void pthread_cleanup_push(void (*routine)(void *), void *arg);
void pthread_cleanup_pop(int execute);
int pthread_cond_broadcast(pthread_cond_t *cond);
int pthread_cond_destroy(pthread_cond_t *cond);
int pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *attr);
int pthread_cond_signal(pthread_cond_t *cond);
int pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex,
                           const struct timespec *abstime);
int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex);
int pthread_condattr_destroy(pthread_condattr_t *attr);
// NRQ for PSE52 pthread_condattr_getpshared
int pthread_condattr_init(pthread_condattr_t *attr);
// NRQ for PSE52 pthread_condattr_setpshared
int pthread_create(pthread_t *thread, const pthread_attr_t *attr,
                   void *(*start_routine)(void *), void *arg);
int pthread_detach(pthread_t thread);
int pthread_equal(pthread_t t1, pthread_t t2);
void pthread_exit(void *value_ptr);
void *pthread_getspecific(pthread_key_t key);
int pthread_getschedparam(pthread_t thread, int *policy, struct sched_param *param);
int pthread_setschedparam(pthread_t thread, int policy, const struct sched_param *param);
int pthread_join(pthread_t thread, void **value_ptr);
int pthread_key_create(pthread_key_t *key, void (*destructor)(void *));
int pthread_key_delete(pthread_key_t key);
int pthread_kill(PID p, int signo);
int pthread_mutex_destroy(pthread_mutex_t *mutex);
int pthread_mutex_getprioceiling(const pthread_mutex_t *mutex, int *prioceiling);
int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr);
int pthread_mutex_lock(pthread_mutex_t *mutex);
int pthread_mutex_setprioceiling(pthread_mutex_t *mutex, int prioceiling, int *old_ceiling);
int pthread_mutex_trylock(pthread_mutex_t *mutex);
int pthread_mutex_unlock(pthread_mutex_t *mutex);
int pthread_mutexattr_destroy(pthread_mutexattr_t *attr);
int pthread_mutexattr_getprioceiling(const pthread_mutexattr_t *attr, int *prioceiling);
int pthread_mutexattr_getprotocol(const pthread_mutexattr_t *attr, int *protocol);
// NRQ for PSE52 pthread_mutexattr_getpshared
int pthread_mutexattr_init(pthread_mutexattr_t *attr);
int pthread_mutexattr_setprioceiling(pthread_mutexattr_t *attr, int prioceiling);
int pthread_mutexattr_setprotocol(pthread_mutexattr_t *attr, int protocol);
// NRQ for PSE52 pthread_mutexattr_setpshared
int pthread_once(pthread_once_t *once_control, void (*init_routine)(void));
pthread_t pthread_self(void);
int pthread_setcancelstate(int state, int *oldstate);
int pthread_setcanceltype(int type, int *oldtype);
int pthread_setspecific(pthread_key_t key, const void *value);
int pthread_sigmask(int how, const sigset_t *set, sigset_t *oset);
void pthread_testcancel(void);


/* Some of the pthread functions are implemented inline */

/*---------------------------------------------------------------------*/
/* 3.3.5 Examine and Change Blocked Signals                            */
/*---------------------------------------------------------------------*/
extern __inline__ int pthread_sigmask(int how, const sigset_t *set, sigset_t *oset)
{
  return task_sigmask(how,set,oset);
}

/*---------------------------------------------------------------------*/
/* 3.3.10 Send a signal to a thread                                    */
/*---------------------------------------------------------------------*/
extern __inline__ int pthread_kill(PID p, int signo)
{
  return task_signal(p,signo);
}

/*---------------------------------------------------------------------*/
/* 11.3.1 Mutex Initialization Attributes                              */
/*---------------------------------------------------------------------*/
extern __inline__ int pthread_mutexattr_init(pthread_mutexattr_t *attr)
{
  attr->protocol    = PTHREAD_PRIO_NONE;
  attr->prioceiling = sched_get_priority_min(SCHED_RR);

  return 0;
}

extern __inline__ int pthread_mutexattr_destroy(pthread_mutexattr_t *attr)
{
  // nothing!!!
  return 0;
}


/*---------------------------------------------------------------------*/
/* 11.3.2 Initializing and Destroying a Mutex                          */
/*---------------------------------------------------------------------*/

extern __inline__ int pthread_mutex_destroy(pthread_mutex_t *mutex)
{
  return mutex_destroy(mutex);
}


/*---------------------------------------------------------------------*/
/* 11.3.2 Locking and Unlocking a mutex                                */
/*---------------------------------------------------------------------*/

extern __inline__ int pthread_mutex_lock(pthread_mutex_t *mutex)
{
  return mutex_lock(mutex);
}

extern __inline__ int pthread_mutex_trylock(pthread_mutex_t *mutex)
{
  return mutex_trylock(mutex);
}

extern __inline__ int pthread_mutex_unlock(pthread_mutex_t *mutex)
{
  return mutex_unlock(mutex);
}

/*---------------------------------------------------------------------*/
/* 11.4.1 Condition Variable initialization Attributes                 */
/*---------------------------------------------------------------------*/

extern __inline__ int pthread_condattr_init(pthread_condattr_t *attr)
{
  return 0;
}

extern __inline__ int pthread_condattr_destroy(pthread_condattr_t *attr)
{
  return 0;
}

/*---------------------------------------------------------------------*/
/* 11.4.2 Initializing and Destroying Condition Variables              */
/*---------------------------------------------------------------------*/

extern __inline__ int pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *attr)
{
  return cond_init(cond);
}

extern __inline__ int pthread_cond_destroy(pthread_cond_t *cond)
{
  return cond_destroy(cond);
}

/*---------------------------------------------------------------------*/
/* 11.4.3 Broadcasting and Signaling a Condition                       */
/*---------------------------------------------------------------------*/

extern __inline__ int pthread_cond_broadcast(pthread_cond_t *cond)
{
  return cond_broadcast(cond);
}

extern __inline__ int pthread_cond_signal(pthread_cond_t *cond)
{
  return cond_signal(cond);
}

/*---------------------------------------------------------------------*/
/* 11.4.4 Waiting on a Condition                                       */
/*---------------------------------------------------------------------*/

extern __inline__ int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex)
{
  return cond_wait(cond, mutex);
}

extern __inline__ int pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex,
                           const struct timespec *abstime)
{
  return cond_timedwait(cond, mutex, abstime);
}


/*---------------------------------------------------------------------*/
/* 13.5.1 Thread Creation Scheduling Attributes                        */
/*---------------------------------------------------------------------*/
extern __inline__ int pthread_attr_getinheritsched(pthread_attr_t *attr, int *inheritsched)
{
  *inheritsched = attr->inheritsched;
  return 0;
}

extern __inline__ int pthread_attr_getschedparam(const pthread_attr_t *attr, struct sched_param *param)
{
  param->sched_priority = attr->schedparam.sched_priority;
  return 0;
}

extern __inline__ int pthread_attr_getschedpolicy(const pthread_attr_t *attr, int *policy)
{
  *policy = attr->schedpolicy;
  return 0;
}

extern __inline__ int pthread_attr_getscope(const pthread_attr_t *attr, int *contentionscope)
{
  *contentionscope = attr->contentionscope;
  return 0;
}

extern __inline__ int pthread_attr_setinheritsched(pthread_attr_t *attr, int inheritsched)
{
  if (inheritsched != PTHREAD_INHERIT_SCHED &&
      inheritsched != PTHREAD_EXPLICIT_SCHED   ) return (EINVAL);

  attr->inheritsched = inheritsched;
  return 0;
}

extern __inline__ int pthread_attr_setschedparam(pthread_attr_t *attr, const struct sched_param *param)
{
  // ehm... no controls :-)
  attr->schedparam = *param;
  return 0;
}

extern __inline__ int pthread_attr_setschedpolicy(pthread_attr_t *attr, int policy)
{
  if (policy != SCHED_RR && policy != SCHED_FIFO && policy != SCHED_OTHER)
    return (EINVAL);

  attr->schedpolicy = policy;
  return 0;
}

extern __inline__ int pthread_attr_setscope(pthread_attr_t *attr, int *contentionscope)
{
  if (contentionscope != PTHREAD_SCOPE_SYSTEM &&
      contentionscope != PTHREAD_SCOPE_PROCESS   ) return (EINVAL);

  attr->contentionscope = *contentionscope;
  return 0;
}

/*---------------------------------------------------------------------*/
/* 13.6.1 Mutex Initialization Scheduling Attributes                   */
/*---------------------------------------------------------------------*/

extern __inline__ int pthread_mutexattr_getprioceiling(const pthread_mutexattr_t *attr, int *prioceiling)
{
  *prioceiling = attr->prioceiling;
  return 0;
}

extern __inline__ int pthread_mutexattr_getprotocol(const pthread_mutexattr_t *attr, int *protocol)
{
  *protocol = attr->protocol;
  return 0;
}

extern __inline__ int pthread_mutexattr_setprioceiling(pthread_mutexattr_t *attr, int prioceiling)
{
  if (prioceiling < sched_get_priority_min(SCHED_RR) ||
      prioceiling > sched_get_priority_max(SCHED_RR)   ) {
    return EINVAL;
  }

  attr->prioceiling = prioceiling;
  return 0;
}

extern __inline__ int pthread_mutexattr_setprotocol(pthread_mutexattr_t *attr, int protocol)
{
  if (protocol != PTHREAD_PRIO_NONE &&
      protocol != PTHREAD_PRIO_INHERIT &&
      protocol != PTHREAD_PRIO_PROTECT) {
    return EINVAL;
  }

  attr->protocol = protocol;
  return 0;
}

/*---------------------------------------------------------------------*/
/* 16.2.1 Thread Creation attributes                                   */
/*---------------------------------------------------------------------*/

extern __inline__ int pthread_attr_destroy(pthread_attr_t *attr)
{
  // nothing!!!
  return 0;
}

extern __inline__ int pthread_attr_getdetachstate(const pthread_attr_t *attr, int *detachstate)
{
  *detachstate = attr->detachstate;
  return 0;
}

extern __inline__ int pthread_attr_getstackaddr(const pthread_attr_t *attr, void **stackaddr)
{
  *stackaddr = attr->stackaddr;
  return 0;
}

extern __inline__ int pthread_attr_getstacksize(const pthread_attr_t *attr, size_t *stacksize)
{
  *stacksize = attr->stacksize;
  return 0;
}

extern __inline__ int pthread_attr_init(pthread_attr_t *attr)
{
  // note that the contention scope is not used, because the behaviour
  // is the same...
  attr->contentionscope           = PTHREAD_SCOPE_PROCESS;
  attr->inheritsched              = PTHREAD_EXPLICIT_SCHED;
  attr->schedpolicy               = SCHED_RR;
  attr->schedparam.sched_priority = sched_get_priority_min(SCHED_RR);
  attr->detachstate               = PTHREAD_CREATE_JOINABLE;

  attr->stacksize                 = STACK_SIZE;
  attr->stackaddr                 = NULL;

  return 0;
}

extern __inline__ int pthread_attr_setdetachstate(pthread_attr_t *attr, int detachstate)
{
  if (detachstate != PTHREAD_CREATE_JOINABLE &&
      detachstate != PTHREAD_CREATE_DETACHED   ) return (EINVAL);

  attr->detachstate = detachstate;
  return 0;
}

extern __inline__ int pthread_attr_setstackaddr(pthread_attr_t *attr, void *stackaddr)
{
  attr->stackaddr = stackaddr;
  return 0;
}

extern __inline__ int pthread_attr_setstacksize(pthread_attr_t *attr, size_t stacksize)
{
  if (stacksize < STACK_SIZE) return (EINVAL);

  attr->stacksize = stacksize;
  return 0;
}

/*---------------------------------------------------------------------*/
/* 16.2.3 Wait for thread termination                                  */
/*---------------------------------------------------------------------*/

extern __inline__ int pthread_join(pthread_t thread, void **value_ptr)
{
  return task_join(thread, value_ptr);
}

/*---------------------------------------------------------------------*/
/* 16.2.4 Detaching a thread                                           */
/*---------------------------------------------------------------------*/

extern __inline__ int pthread_detach(pthread_t thread)
{
  return task_unjoinable(thread);
}

/*---------------------------------------------------------------------*/
/* 16.2.5 Thread Termination                                           */
/*---------------------------------------------------------------------*/

extern __inline__ void pthread_exit(void *value_ptr)
{
  task_abort(value_ptr);
}

/*---------------------------------------------------------------------*/
/* 16.2.6 Get thread ID                                                */
/*---------------------------------------------------------------------*/

extern __inline__ pthread_t pthread_self(void)
{
  return exec_shadow;
}

/*---------------------------------------------------------------------*/
/* 16.2.7 Compare Threads ID                                           */
/*---------------------------------------------------------------------*/

extern __inline__ int pthread_equal(pthread_t t1, pthread_t t2)
{
  return t1 == t2;
}


/*---------------------------------------------------------------------*/
/* 17.1.1 Thread specific data key creation                            */
/*---------------------------------------------------------------------*/

extern __inline__ int pthread_key_create(pthread_key_t *key, void (*destructor)(void *))
{
  return task_key_create(key,destructor);
}

/*---------------------------------------------------------------------*/
/* 17.1.2 Thread Specific Data Management                              */
/*---------------------------------------------------------------------*/

extern __inline__ void *pthread_getspecific(pthread_key_t key)
{
  return task_getspecific(key);
}

extern __inline__ int pthread_setspecific(pthread_key_t key, const void *value)
{
  return task_setspecific(key,value);
}

/*---------------------------------------------------------------------*/
/* 17.1.3 Thread-Specific Data key deletion                            */
/*---------------------------------------------------------------------*/

extern __inline__ int pthread_key_delete(pthread_key_t key)
{
  return task_key_delete(key);
}

/*---------------------------------------------------------------------*/
/* 18.2.2 Setting Cancelability State                                  */
/*---------------------------------------------------------------------*/

extern __inline__ int pthread_setcancelstate(int state, int *oldstate)
{
  return task_setcancelstate(state, oldstate);
}

extern __inline__ int pthread_setcanceltype(int type, int *oldtype)
{
  return task_setcanceltype(type, oldtype);
}

extern __inline__ void pthread_testcancel(void)
{
  task_testcancel();
}

/*---------------------------------------------------------------------*/
/* 18.2.2 Setting Cancelability State                                  */
/*---------------------------------------------------------------------*/

#define pthread_cleanup_push task_cleanup_push
#define pthread_cleanup_pop  task_cleanup_pop

__END_DECLS

#endif