pthread.h

Go to the documentation of this file.

/*
 * FreeRTOS POSIX V1.2.0
 * Copyright (C) 2020 Amazon.com, Inc. or its affiliates.  All Rights Reserved.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy of
 * this software and associated documentation files (the "Software"), to deal in
 * the Software without restriction, including without limitation the rights to
 * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
 * the Software, and to permit persons to whom the Software is furnished to do so,
 * subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
 * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
 * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
 * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 *
 * http://aws.amazon.com/freertos
 * http://www.FreeRTOS.org
 */

#ifndef _FREERTOS_POSIX_PTHREAD_H_
#define _FREERTOS_POSIX_PTHREAD_H_

/* FreeRTOS+POSIX includes. POSIX states that this header shall make symbols
 * defined in sched.h and time.h visible. */
#include "FreeRTOS_POSIX/sched.h"
#include "FreeRTOS_POSIX/time.h"

#define PTHREAD_CREATE_DETACHED    0       
#define PTHREAD_CREATE_JOINABLE    1       
#define PTHREAD_BARRIER_SERIAL_THREAD    ( -2 )

#ifndef PTHREAD_MUTEX_NORMAL
    #define PTHREAD_MUTEX_NORMAL        0                        
#endif
#ifndef PTHREAD_MUTEX_ERRORCHECK
    #define PTHREAD_MUTEX_ERRORCHECK    1                        
#endif
#ifndef PTHREAD_MUTEX_RECURSIVE
    #define PTHREAD_MUTEX_RECURSIVE     2                        
#endif
#ifndef PTHREAD_MUTEX_DEFAULT
    #define PTHREAD_MUTEX_DEFAULT       PTHREAD_MUTEX_NORMAL     
#endif

#if posixconfigENABLE_PTHREAD_COND_T == 1
    #define PTHREAD_COND_INITIALIZER    FREERTOS_POSIX_COND_INITIALIZER       
#endif

#if posixconfigENABLE_PTHREAD_MUTEX_T == 1
    #define PTHREAD_MUTEX_INITIALIZER    FREERTOS_POSIX_MUTEX_INITIALIZER 
#endif

int pthread_attr_destroy( pthread_attr_t * attr );

int pthread_attr_getdetachstate( const pthread_attr_t * attr,
                                 int * detachstate );

int pthread_attr_getschedparam( const pthread_attr_t * attr,
                                struct sched_param * param );

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_setschedparam( pthread_attr_t * attr,
                                const struct sched_param * param );

int pthread_attr_setschedpolicy( pthread_attr_t * attr,
                                 int policy );

int pthread_attr_setstacksize( pthread_attr_t * attr,
                               size_t stacksize );

int pthread_barrier_destroy( pthread_barrier_t * barrier );

int pthread_barrier_init( pthread_barrier_t * barrier,
                          const pthread_barrierattr_t * attr,
                          unsigned count );

int pthread_barrier_wait( pthread_barrier_t * barrier );

int pthread_create( pthread_t * thread,
                    const pthread_attr_t * attr,
                    void * ( *startroutine )( void * ),
                    void * arg );

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_equal( pthread_t t1,
                   pthread_t t2 );

void pthread_exit( void * value_ptr );

int pthread_getschedparam( pthread_t thread,
                           int * policy,
                           struct sched_param * param );

int pthread_join( pthread_t thread,
                  void ** retval );

int pthread_mutex_destroy( pthread_mutex_t * mutex );

int pthread_mutex_init( pthread_mutex_t * mutex,
                        const pthread_mutexattr_t * attr );

int pthread_mutex_lock( pthread_mutex_t * mutex );

int pthread_mutex_timedlock( pthread_mutex_t * mutex,
                             const struct timespec * abstime );

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_gettype( const pthread_mutexattr_t * attr,
                               int * type );

int pthread_mutexattr_init( pthread_mutexattr_t * attr );

int pthread_mutexattr_settype( pthread_mutexattr_t * attr,
                               int type );

pthread_t pthread_self( void );

int pthread_setschedparam( pthread_t thread,
                           int policy,
                           const struct sched_param * param );

#endif /* _FREERTOS_POSIX_PTHREAD_H_ */