From patchwork Fri Dec 29 14:58:39 2017 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Adhemerval Zanella Netto X-Patchwork-Id: 122939 Delivered-To: patch@linaro.org Received: by 10.140.22.227 with SMTP id 90csp4785323qgn; Fri, 29 Dec 2017 06:59:57 -0800 (PST) X-Google-Smtp-Source: ACJfBov05502GTKcxEr5kXHNjhX9aJ78mv5TVDvfQbvJGgHuGBaYVqz0MZ+1Umb8GjSS7NhQVJ42 X-Received: by 10.159.252.76 with SMTP id t12mr35765936plz.323.1514559597308; Fri, 29 Dec 2017 06:59:57 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1514559597; cv=none; d=google.com; s=arc-20160816; b=qnS1mUN3OYvHKazfJsbWsQMhM81luRcdatm9+sMq28IAEBawCzQTAwrC+gL6QzjQ+u CH8UlP9RwCZSgfPp8iFMP/Wrlg8lmteF+sWBbYxSftUkHamJtkKN74zIfluWNKDctlGe qhZUtS7fe/2N3OUft0ieQBV6o8DP2hKptm0A26xH9wVUngM+I4p65aoj+NzYOq40V3Nm Ckzykv407bkwb6M+GPr7T8jApXe1KO/TvvwbaIJwxssGrZpMw6qVXzE/TzKLQCuxeIZT 7zphnO1YhzlhPUVeJyuViLF04Ss0VYsIDOlJ77AC9K5DPxXQhhmPzI7Fa+manWCgj76m WtzQ== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=references:in-reply-to:message-id:date:subject:to:from:delivered-to :sender:list-help:list-post:list-archive:list-subscribe :list-unsubscribe:list-id:precedence:mailing-list:dkim-signature :domainkey-signature:arc-authentication-results; bh=54xvVui7I8adYoVNCsB5qy0xM3nrqsc7o0fCe6MBFCU=; b=wqSEEkbGqdfl33WjoKVNBvSRsC0LZCzjExXC7FsqGJOn1jKeLKJkqafvgg6BFp3g2S 9xxUWQYgT6tcooNzeUYGaloqExCp/EezxHn1y0ClYQTI4kRxG5/3FSbwXcPbV+REm7ZN 9MjYg2rkuQztwVI0nfU8egpdAdZ6CNyPSNWLFn+3vJlkHx1QPPF87J40y7L4zXq9rBag GPwl8HDBT9edMK3fapML1hjs7d4cDvWvUJ6e0GOEcPe/bHHgEfviw6dPZj0AYpbKbDoh LoUGfVOL9C0905eVXReRIbAxdH/p4jz8DGkVpiLWU+i8lBs1zHYPC3XAckwEMG6yxsqK g8AA== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@sourceware.org header.s=default header.b=Ew4QaD6s; spf=pass (google.com: domain of libc-alpha-return-88668-patch=linaro.org@sourceware.org designates 209.132.180.131 as permitted sender) smtp.mailfrom=libc-alpha-return-88668-patch=linaro.org@sourceware.org; dmarc=fail (p=NONE sp=NONE dis=NONE) header.from=linaro.org Return-Path: Received: from sourceware.org (server1.sourceware.org. [209.132.180.131]) by mx.google.com with ESMTPS id 64si23199957ply.698.2017.12.29.06.59.56 for (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Fri, 29 Dec 2017 06:59:57 -0800 (PST) Received-SPF: pass (google.com: domain of libc-alpha-return-88668-patch=linaro.org@sourceware.org designates 209.132.180.131 as permitted sender) client-ip=209.132.180.131; Authentication-Results: mx.google.com; dkim=pass header.i=@sourceware.org header.s=default header.b=Ew4QaD6s; spf=pass (google.com: domain of libc-alpha-return-88668-patch=linaro.org@sourceware.org designates 209.132.180.131 as permitted sender) smtp.mailfrom=libc-alpha-return-88668-patch=linaro.org@sourceware.org; dmarc=fail (p=NONE sp=NONE dis=NONE) header.from=linaro.org DomainKey-Signature: a=rsa-sha1; c=nofws; d=sourceware.org; h=list-id :list-unsubscribe:list-subscribe:list-archive:list-post :list-help:sender:from:to:subject:date:message-id:in-reply-to :references; q=dns; s=default; b=mkiMly9WFZno/9afZX9MaQmsRVsJesk Z1VwmSRXwOW+Zi1pbKuBRnlWiTsFYxK8j0oN7b1sW6HKerv4WRfzY+wDm7mOFJu7 fNksxqbtmqrkeSLBdYf3/IykZZ7HQrSUq2YcVxuPhb3wp0plKLZOkXu67Ry/CyJu yDOQaJEZmeDY= DKIM-Signature: v=1; a=rsa-sha1; c=relaxed; d=sourceware.org; h=list-id :list-unsubscribe:list-subscribe:list-archive:list-post :list-help:sender:from:to:subject:date:message-id:in-reply-to :references; s=default; bh=aA5wJOGBv23wXsohxvSIBAgbGao=; b=Ew4Qa D6sQvxIL9Er6BJmN8/PBdt7Qjf9TWUdcOgyqzQA6yBFZO2mT/kvdw6YL6t8MhcpD FlBr9HCQdmMFF44MynYbKL4fJZYhEamH1PyBhPpXDkATckkD7R5qk6ehpk2twUqa HPRc9rd3MobLovsat+dijqdcMBjHF+RgitjFaM= Received: (qmail 53635 invoked by alias); 29 Dec 2017 14:59:02 -0000 Mailing-List: contact libc-alpha-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: libc-alpha-owner@sourceware.org Delivered-To: mailing list libc-alpha@sourceware.org Received: (qmail 53530 invoked by uid 89); 29 Dec 2017 14:59:01 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-25.9 required=5.0 tests=AWL, BAYES_00, GIT_PATCH_0, GIT_PATCH_1, GIT_PATCH_2, GIT_PATCH_3, KAM_SHORT, RCVD_IN_DNSWL_NONE, SPF_PASS autolearn=ham version=3.3.2 spammy=wake, Wake, exceed, attributed X-HELO: mail-qk0-f179.google.com X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:subject:date:message-id:in-reply-to :references; bh=54xvVui7I8adYoVNCsB5qy0xM3nrqsc7o0fCe6MBFCU=; b=CV43waxsFpT+D2JSHHrhw/p4vXXGhVJ6udv/mUVMrrNLQY6W1Dnyx9VgQd1/HXGMXy Gn9JKNJdsBnL6L1ZF4ctn5soY0OCGGrh04aBYSi3S11pu4auxHK6+/1X+80HvBmcAXxi ctZJ5tDTy88apM7y6M6ccf0gfaxL4e57vWAZ5a63kTms4hz2dro3MCLyv+bUubKg+qI4 PB/FDir6aDXHVIBWdbIv15EeEvvHtgK0Qe3XfVSulzehSTbwmil6rd2Ix53Qjn3kkIrW yBWx4jmHUdwL4LtdwSD8GDpUXBDxeP1cNQcAqkvOeXSpTOnGEcrill1TKou+8sToXrmV YoFg== X-Gm-Message-State: AKGB3mLiniIcYuV4fqJs8pDOSdDLQVCqhrQ8Vb4PkbCc2Zzn4U9Ti4mG Yh79RtIi9+QzKfFI01ggP1JG6nW53Ik= X-Received: by 10.55.79.22 with SMTP id d22mr46565483qkb.247.1514559532069; Fri, 29 Dec 2017 06:58:52 -0800 (PST) From: Adhemerval Zanella To: libc-alpha@sourceware.org Subject: [PATCH 5/5] hppa: Remove unrequired nptl headers Date: Fri, 29 Dec 2017 12:58:39 -0200 Message-Id: <1514559519-13167-5-git-send-email-adhemerval.zanella@linaro.org> In-Reply-To: <1514559519-13167-1-git-send-email-adhemerval.zanella@linaro.org> References: <1514559519-13167-1-git-send-email-adhemerval.zanella@linaro.org> Now that both pthread_mutex_t and pthread_rwlock_t static initializer are parametrized in their own headers HPPA pthread.h is identical to generic nptl one. Checked on hppa-linux-gnu. * sysdeps/unix/sysv/linux/hppa/pthread.h: Remove file. * sysdeps/unix/sysv/linux/hppa/pthreadP.h: Likewise. Signed-off-by: Adhemerval Zanella --- ChangeLog | 3 + sysdeps/unix/sysv/linux/hppa/pthread.h | 1122 ------------------------------- sysdeps/unix/sysv/linux/hppa/pthreadP.h | 16 - 3 files changed, 3 insertions(+), 1138 deletions(-) delete mode 100644 sysdeps/unix/sysv/linux/hppa/pthread.h delete mode 100644 sysdeps/unix/sysv/linux/hppa/pthreadP.h -- 2.7.4 diff --git a/sysdeps/unix/sysv/linux/hppa/pthread.h b/sysdeps/unix/sysv/linux/hppa/pthread.h deleted file mode 100644 index c0a608c..0000000 --- a/sysdeps/unix/sysv/linux/hppa/pthread.h +++ /dev/null @@ -1,1122 +0,0 @@ -/* Copyright (C) 2002-2017 Free Software Foundation, Inc. - This file is part of the GNU C Library. - - The GNU C Library 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. - - The GNU C Library 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 the GNU C Library; if not, see - . */ - -#ifndef _PTHREAD_H -#define _PTHREAD_H 1 - -#include -#include -#include -#include - -#include -#include -#include -#include -#include - - -/* Detach state. */ -enum -{ - PTHREAD_CREATE_JOINABLE, -#define PTHREAD_CREATE_JOINABLE PTHREAD_CREATE_JOINABLE - PTHREAD_CREATE_DETACHED -#define PTHREAD_CREATE_DETACHED PTHREAD_CREATE_DETACHED -}; - - -/* Mutex types. */ -enum -{ - PTHREAD_MUTEX_TIMED_NP, - PTHREAD_MUTEX_RECURSIVE_NP, - PTHREAD_MUTEX_ERRORCHECK_NP, - PTHREAD_MUTEX_ADAPTIVE_NP -#if defined __USE_UNIX98 || defined __USE_XOPEN2K8 - , - PTHREAD_MUTEX_NORMAL = PTHREAD_MUTEX_TIMED_NP, - PTHREAD_MUTEX_RECURSIVE = PTHREAD_MUTEX_RECURSIVE_NP, - PTHREAD_MUTEX_ERRORCHECK = PTHREAD_MUTEX_ERRORCHECK_NP, - PTHREAD_MUTEX_DEFAULT = PTHREAD_MUTEX_NORMAL -#endif -#ifdef __USE_GNU - /* For compatibility. */ - , PTHREAD_MUTEX_FAST_NP = PTHREAD_MUTEX_TIMED_NP -#endif -}; - - -#ifdef __USE_XOPEN2K -/* Robust mutex or not flags. */ -enum -{ - PTHREAD_MUTEX_STALLED, - PTHREAD_MUTEX_STALLED_NP = PTHREAD_MUTEX_STALLED, - PTHREAD_MUTEX_ROBUST, - PTHREAD_MUTEX_ROBUST_NP = PTHREAD_MUTEX_ROBUST -}; -#endif - - -#if defined __USE_POSIX199506 || defined __USE_UNIX98 -/* Mutex protocols. */ -enum -{ - PTHREAD_PRIO_NONE, - PTHREAD_PRIO_INHERIT, - PTHREAD_PRIO_PROTECT -}; -#endif - - -#define PTHREAD_MUTEX_INITIALIZER \ - { { __PTHREAD_MUTEX_INITIALIZER (PTHREAD_MUTEX_DEFAULT) } } -#ifdef __USE_GNU -# define PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP \ - { { __PTHREAD_MUTEX_INITIALIZER (PTHREAD_MUTEX_RECURSIVE_NP) } } -# define PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP \ - { { __PTHREAD_MUTEX_INITIALIZER (PTHREAD_MUTEX_ERRORCHECK_NP) } } -# define PTHREAD_ADAPTIVE_MUTEX_INITIALIZER_NP \ - { { __PTHREAD_MUTEX_INITIALIZER (PTHREAD_MUTEX_ADAPTIVE_NP) } } -#endif - - -/* Read-write lock types. */ -#if defined __USE_UNIX98 || defined __USE_XOPEN2K -enum -{ - PTHREAD_RWLOCK_PREFER_READER_NP, - PTHREAD_RWLOCK_PREFER_WRITER_NP, - PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP, - PTHREAD_RWLOCK_DEFAULT_NP = PTHREAD_RWLOCK_PREFER_READER_NP -}; - - -/* Read-write lock initializers. */ -# define PTHREAD_RWLOCK_INITIALIZER \ - { { __PTHREAD_RWLOCK_INITIALIZER (PTHREAD_RWLOCK_DEFAULT_NP) } } -# ifdef __USE_GNU -# define PTHREAD_RWLOCK_WRITER_NONRECURSIVE_INITIALIZER_NP \ - { { __PTHREAD_RWLOCK_INITIALIZER (PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP) } } -# endif -#endif /* Unix98 or XOpen2K */ - - -/* Scheduler inheritance. */ -enum -{ - PTHREAD_INHERIT_SCHED, -#define PTHREAD_INHERIT_SCHED PTHREAD_INHERIT_SCHED - PTHREAD_EXPLICIT_SCHED -#define PTHREAD_EXPLICIT_SCHED PTHREAD_EXPLICIT_SCHED -}; - - -/* Scope handling. */ -enum -{ - PTHREAD_SCOPE_SYSTEM, -#define PTHREAD_SCOPE_SYSTEM PTHREAD_SCOPE_SYSTEM - PTHREAD_SCOPE_PROCESS -#define PTHREAD_SCOPE_PROCESS PTHREAD_SCOPE_PROCESS -}; - - -/* Process shared or private flag. */ -enum -{ - PTHREAD_PROCESS_PRIVATE, -#define PTHREAD_PROCESS_PRIVATE PTHREAD_PROCESS_PRIVATE - PTHREAD_PROCESS_SHARED -#define PTHREAD_PROCESS_SHARED PTHREAD_PROCESS_SHARED -}; - - -/* Conditional variable handling. */ -#define PTHREAD_COND_INITIALIZER { { {0}, {0}, {0, 0}, {0, 0}, 0, 0, {0, 0} } } - - -/* Cleanup buffers */ -struct _pthread_cleanup_buffer -{ - void (*__routine) (void *); /* Function to call. */ - void *__arg; /* Its argument. */ - int __canceltype; /* Saved cancellation type. */ - struct _pthread_cleanup_buffer *__prev; /* Chaining of cleanup functions. */ -}; - -/* Cancellation */ -enum -{ - PTHREAD_CANCEL_ENABLE, -#define PTHREAD_CANCEL_ENABLE PTHREAD_CANCEL_ENABLE - PTHREAD_CANCEL_DISABLE -#define PTHREAD_CANCEL_DISABLE PTHREAD_CANCEL_DISABLE -}; -enum -{ - PTHREAD_CANCEL_DEFERRED, -#define PTHREAD_CANCEL_DEFERRED PTHREAD_CANCEL_DEFERRED - PTHREAD_CANCEL_ASYNCHRONOUS -#define PTHREAD_CANCEL_ASYNCHRONOUS PTHREAD_CANCEL_ASYNCHRONOUS -}; -#define PTHREAD_CANCELED ((void *) -1) - - -/* Single execution handling. */ -#define PTHREAD_ONCE_INIT 0 - - -#ifdef __USE_XOPEN2K -/* Value returned by 'pthread_barrier_wait' for one of the threads after - the required number of threads have called this function. - -1 is distinct from 0 and all errno constants */ -# define PTHREAD_BARRIER_SERIAL_THREAD -1 -#endif - - -__BEGIN_DECLS - -/* Create a new thread, starting with execution of START-ROUTINE - getting passed ARG. Creation attributed come from ATTR. The new - handle is stored in *NEWTHREAD. */ -extern int pthread_create (pthread_t *__restrict __newthread, - const pthread_attr_t *__restrict __attr, - void *(*__start_routine) (void *), - void *__restrict __arg) __THROWNL __nonnull ((1, 3)); - -/* Terminate calling thread. - - The registered cleanup handlers are called via exception handling - so we cannot mark this function with __THROW.*/ -extern void pthread_exit (void *__retval) __attribute__ ((__noreturn__)); - -/* Make calling thread wait for termination of the thread TH. The - exit status of the thread is stored in *THREAD_RETURN, if THREAD_RETURN - is not NULL. - - This function is a cancellation point and therefore not marked with - __THROW. */ -extern int pthread_join (pthread_t __th, void **__thread_return); - -#ifdef __USE_GNU -/* Check whether thread TH has terminated. If yes return the status of - the thread in *THREAD_RETURN, if THREAD_RETURN is not NULL. */ -extern int pthread_tryjoin_np (pthread_t __th, void **__thread_return) __THROW; - -/* Make calling thread wait for termination of the thread TH, but only - until TIMEOUT. The exit status of the thread is stored in - *THREAD_RETURN, if THREAD_RETURN is not NULL. - - This function is a cancellation point and therefore not marked with - __THROW. */ -extern int pthread_timedjoin_np (pthread_t __th, void **__thread_return, - const struct timespec *__abstime); -#endif - -/* Indicate that the thread TH is never to be joined with PTHREAD_JOIN. - The resources of TH will therefore be freed immediately when it - terminates, instead of waiting for another thread to perform PTHREAD_JOIN - on it. */ -extern int pthread_detach (pthread_t __th) __THROW; - - -/* Obtain the identifier of the current thread. */ -extern pthread_t pthread_self (void) __THROW __attribute__ ((__const__)); - -/* Compare two thread identifiers. */ -extern int pthread_equal (pthread_t __thread1, pthread_t __thread2) - __THROW __attribute__ ((__const__)); - - -/* Thread attribute handling. */ - -/* Initialize thread attribute *ATTR with default attributes - (detachstate is PTHREAD_JOINABLE, scheduling policy is SCHED_OTHER, - no user-provided stack). */ -extern int pthread_attr_init (pthread_attr_t *__attr) __THROW __nonnull ((1)); - -/* Destroy thread attribute *ATTR. */ -extern int pthread_attr_destroy (pthread_attr_t *__attr) - __THROW __nonnull ((1)); - -/* Get detach state attribute. */ -extern int pthread_attr_getdetachstate (const pthread_attr_t *__attr, - int *__detachstate) - __THROW __nonnull ((1, 2)); - -/* Set detach state attribute. */ -extern int pthread_attr_setdetachstate (pthread_attr_t *__attr, - int __detachstate) - __THROW __nonnull ((1)); - - -/* Get the size of the guard area created for stack overflow protection. */ -extern int pthread_attr_getguardsize (const pthread_attr_t *__attr, - size_t *__guardsize) - __THROW __nonnull ((1, 2)); - -/* Set the size of the guard area created for stack overflow protection. */ -extern int pthread_attr_setguardsize (pthread_attr_t *__attr, - size_t __guardsize) - __THROW __nonnull ((1)); - - -/* Return in *PARAM the scheduling parameters of *ATTR. */ -extern int pthread_attr_getschedparam (const pthread_attr_t *__restrict __attr, - struct sched_param *__restrict __param) - __THROW __nonnull ((1, 2)); - -/* Set scheduling parameters (priority, etc) in *ATTR according to PARAM. */ -extern int pthread_attr_setschedparam (pthread_attr_t *__restrict __attr, - const struct sched_param *__restrict - __param) __THROW __nonnull ((1, 2)); - -/* Return in *POLICY the scheduling policy of *ATTR. */ -extern int pthread_attr_getschedpolicy (const pthread_attr_t *__restrict - __attr, int *__restrict __policy) - __THROW __nonnull ((1, 2)); - -/* Set scheduling policy in *ATTR according to POLICY. */ -extern int pthread_attr_setschedpolicy (pthread_attr_t *__attr, int __policy) - __THROW __nonnull ((1)); - -/* Return in *INHERIT the scheduling inheritance mode of *ATTR. */ -extern int pthread_attr_getinheritsched (const pthread_attr_t *__restrict - __attr, int *__restrict __inherit) - __THROW __nonnull ((1, 2)); - -/* Set scheduling inheritance mode in *ATTR according to INHERIT. */ -extern int pthread_attr_setinheritsched (pthread_attr_t *__attr, - int __inherit) - __THROW __nonnull ((1)); - - -/* Return in *SCOPE the scheduling contention scope of *ATTR. */ -extern int pthread_attr_getscope (const pthread_attr_t *__restrict __attr, - int *__restrict __scope) - __THROW __nonnull ((1, 2)); - -/* Set scheduling contention scope in *ATTR according to SCOPE. */ -extern int pthread_attr_setscope (pthread_attr_t *__attr, int __scope) - __THROW __nonnull ((1)); - -/* Return the previously set address for the stack. */ -extern int pthread_attr_getstackaddr (const pthread_attr_t *__restrict - __attr, void **__restrict __stackaddr) - __THROW __nonnull ((1, 2)) __attribute_deprecated__; - -/* Set the starting address of the stack of the thread to be created. - Depending on whether the stack grows up or down the value must either - be higher or lower than all the address in the memory block. The - minimal size of the block must be PTHREAD_STACK_MIN. */ -extern int pthread_attr_setstackaddr (pthread_attr_t *__attr, - void *__stackaddr) - __THROW __nonnull ((1)) __attribute_deprecated__; - -/* Return the currently used minimal stack size. */ -extern int pthread_attr_getstacksize (const pthread_attr_t *__restrict - __attr, size_t *__restrict __stacksize) - __THROW __nonnull ((1, 2)); - -/* Add information about the minimum stack size needed for the thread - to be started. This size must never be less than PTHREAD_STACK_MIN - and must also not exceed the system limits. */ -extern int pthread_attr_setstacksize (pthread_attr_t *__attr, - size_t __stacksize) - __THROW __nonnull ((1)); - -#ifdef __USE_XOPEN2K -/* Return the previously set address for the stack. */ -extern int pthread_attr_getstack (const pthread_attr_t *__restrict __attr, - void **__restrict __stackaddr, - size_t *__restrict __stacksize) - __THROW __nonnull ((1, 2, 3)); - -/* The following two interfaces are intended to replace the last two. They - require setting the address as well as the size since only setting the - address will make the implementation on some architectures impossible. */ -extern int pthread_attr_setstack (pthread_attr_t *__attr, void *__stackaddr, - size_t __stacksize) __THROW __nonnull ((1)); -#endif - -#ifdef __USE_GNU -/* Thread created with attribute ATTR will be limited to run only on - the processors represented in CPUSET. */ -extern int pthread_attr_setaffinity_np (pthread_attr_t *__attr, - size_t __cpusetsize, - const cpu_set_t *__cpuset) - __THROW __nonnull ((1, 3)); - -/* Get bit set in CPUSET representing the processors threads created with - ATTR can run on. */ -extern int pthread_attr_getaffinity_np (const pthread_attr_t *__attr, - size_t __cpusetsize, - cpu_set_t *__cpuset) - __THROW __nonnull ((1, 3)); - -/* Get the default attributes used by pthread_create in this process. */ -extern int pthread_getattr_default_np (pthread_attr_t *__attr) - __THROW __nonnull ((1)); - -/* Set the default attributes to be used by pthread_create in this - process. */ -extern int pthread_setattr_default_np (const pthread_attr_t *__attr) - __THROW __nonnull ((1)); - -/* Initialize thread attribute *ATTR with attributes corresponding to the - already running thread TH. It shall be called on uninitialized ATTR - and destroyed with pthread_attr_destroy when no longer needed. */ -extern int pthread_getattr_np (pthread_t __th, pthread_attr_t *__attr) - __THROW __nonnull ((2)); -#endif - - -/* Functions for scheduling control. */ - -/* Set the scheduling parameters for TARGET_THREAD according to POLICY - and *PARAM. */ -extern int pthread_setschedparam (pthread_t __target_thread, int __policy, - const struct sched_param *__param) - __THROW __nonnull ((3)); - -/* Return in *POLICY and *PARAM the scheduling parameters for TARGET_THREAD. */ -extern int pthread_getschedparam (pthread_t __target_thread, - int *__restrict __policy, - struct sched_param *__restrict __param) - __THROW __nonnull ((2, 3)); - -/* Set the scheduling priority for TARGET_THREAD. */ -extern int pthread_setschedprio (pthread_t __target_thread, int __prio) - __THROW; - - -#ifdef __USE_GNU -/* Get thread name visible in the kernel and its interfaces. */ -extern int pthread_getname_np (pthread_t __target_thread, char *__buf, - size_t __buflen) - __THROW __nonnull ((2)); - -/* Set thread name visible in the kernel and its interfaces. */ -extern int pthread_setname_np (pthread_t __target_thread, const char *__name) - __THROW __nonnull ((2)); -#endif - - -#ifdef __USE_UNIX98 -/* Determine level of concurrency. */ -extern int pthread_getconcurrency (void) __THROW; - -/* Set new concurrency level to LEVEL. */ -extern int pthread_setconcurrency (int __level) __THROW; -#endif - -#ifdef __USE_GNU -/* Yield the processor to another thread or process. - This function is similar to the POSIX `sched_yield' function but - might be differently implemented in the case of a m-on-n thread - implementation. */ -extern int pthread_yield (void) __THROW; - - -/* Limit specified thread TH to run only on the processors represented - in CPUSET. */ -extern int pthread_setaffinity_np (pthread_t __th, size_t __cpusetsize, - const cpu_set_t *__cpuset) - __THROW __nonnull ((3)); - -/* Get bit set in CPUSET representing the processors TH can run on. */ -extern int pthread_getaffinity_np (pthread_t __th, size_t __cpusetsize, - cpu_set_t *__cpuset) - __THROW __nonnull ((3)); -#endif - - -/* Functions for handling initialization. */ - -/* Guarantee that the initialization function INIT_ROUTINE will be called - only once, even if pthread_once is executed several times with the - same ONCE_CONTROL argument. ONCE_CONTROL must point to a static or - extern variable initialized to PTHREAD_ONCE_INIT. - - The initialization functions might throw exception which is why - this function is not marked with __THROW. */ -extern int pthread_once (pthread_once_t *__once_control, - void (*__init_routine) (void)) __nonnull ((1, 2)); - - -/* Functions for handling cancellation. - - Note that these functions are explicitly not marked to not throw an - exception in C++ code. If cancellation is implemented by unwinding - this is necessary to have the compiler generate the unwind information. */ - -/* Set cancelability state of current thread to STATE, returning old - state in *OLDSTATE if OLDSTATE is not NULL. */ -extern int pthread_setcancelstate (int __state, int *__oldstate); - -/* Set cancellation state of current thread to TYPE, returning the old - type in *OLDTYPE if OLDTYPE is not NULL. */ -extern int pthread_setcanceltype (int __type, int *__oldtype); - -/* Cancel THREAD immediately or at the next possibility. */ -extern int pthread_cancel (pthread_t __th); - -/* Test for pending cancellation for the current thread and terminate - the thread as per pthread_exit(PTHREAD_CANCELED) if it has been - cancelled. */ -extern void pthread_testcancel (void); - - -/* Cancellation handling with integration into exception handling. */ - -typedef struct -{ - struct __cancel_jmp_buf_tag __cancel_jmp_buf[1]; - void *__pad[4]; -} __pthread_unwind_buf_t __attribute__ ((__aligned__)); - -/* No special attributes by default. */ -#ifndef __cleanup_fct_attribute -# define __cleanup_fct_attribute -#endif - - -/* Structure to hold the cleanup handler information. */ -struct __pthread_cleanup_frame -{ - void (*__cancel_routine) (void *); - void *__cancel_arg; - int __do_it; - int __cancel_type; -}; - -#if defined __GNUC__ && defined __EXCEPTIONS -# ifdef __cplusplus -/* Class to handle cancellation handler invocation. */ -class __pthread_cleanup_class -{ - void (*__cancel_routine) (void *); - void *__cancel_arg; - int __do_it; - int __cancel_type; - - public: - __pthread_cleanup_class (void (*__fct) (void *), void *__arg) - : __cancel_routine (__fct), __cancel_arg (__arg), __do_it (1) { } - ~__pthread_cleanup_class () { if (__do_it) __cancel_routine (__cancel_arg); } - void __setdoit (int __newval) { __do_it = __newval; } - void __defer () { pthread_setcanceltype (PTHREAD_CANCEL_DEFERRED, - &__cancel_type); } - void __restore () const { pthread_setcanceltype (__cancel_type, 0); } -}; - -/* Install a cleanup handler: ROUTINE will be called with arguments ARG - when the thread is canceled or calls pthread_exit. ROUTINE will also - be called with arguments ARG when the matching pthread_cleanup_pop - is executed with non-zero EXECUTE argument. - - pthread_cleanup_push and pthread_cleanup_pop are macros and must always - be used in matching pairs at the same nesting level of braces. */ -# define pthread_cleanup_push(routine, arg) \ - do { \ - __pthread_cleanup_class __clframe (routine, arg) - -/* Remove a cleanup handler installed by the matching pthread_cleanup_push. - If EXECUTE is non-zero, the handler function is called. */ -# define pthread_cleanup_pop(execute) \ - __clframe.__setdoit (execute); \ - } while (0) - -# ifdef __USE_GNU -/* Install a cleanup handler as pthread_cleanup_push does, but also - saves the current cancellation type and sets it to deferred - cancellation. */ -# define pthread_cleanup_push_defer_np(routine, arg) \ - do { \ - __pthread_cleanup_class __clframe (routine, arg); \ - __clframe.__defer () - -/* Remove a cleanup handler as pthread_cleanup_pop does, but also - restores the cancellation type that was in effect when the matching - pthread_cleanup_push_defer was called. */ -# define pthread_cleanup_pop_restore_np(execute) \ - __clframe.__restore (); \ - __clframe.__setdoit (execute); \ - } while (0) -# endif -# else -/* Function called to call the cleanup handler. As an extern inline - function the compiler is free to decide inlining the change when - needed or fall back on the copy which must exist somewhere - else. */ -__extern_inline void -__pthread_cleanup_routine (struct __pthread_cleanup_frame *__frame) -{ - if (__frame->__do_it) - __frame->__cancel_routine (__frame->__cancel_arg); -} - -/* Install a cleanup handler: ROUTINE will be called with arguments ARG - when the thread is canceled or calls pthread_exit. ROUTINE will also - be called with arguments ARG when the matching pthread_cleanup_pop - is executed with non-zero EXECUTE argument. - - pthread_cleanup_push and pthread_cleanup_pop are macros and must always - be used in matching pairs at the same nesting level of braces. */ -# define pthread_cleanup_push(routine, arg) \ - do { \ - struct __pthread_cleanup_frame __clframe \ - __attribute__ ((__cleanup__ (__pthread_cleanup_routine))) \ - = { .__cancel_routine = (routine), .__cancel_arg = (arg), \ - .__do_it = 1 }; - -/* Remove a cleanup handler installed by the matching pthread_cleanup_push. - If EXECUTE is non-zero, the handler function is called. */ -# define pthread_cleanup_pop(execute) \ - __clframe.__do_it = (execute); \ - } while (0) - -# ifdef __USE_GNU -/* Install a cleanup handler as pthread_cleanup_push does, but also - saves the current cancellation type and sets it to deferred - cancellation. */ -# define pthread_cleanup_push_defer_np(routine, arg) \ - do { \ - struct __pthread_cleanup_frame __clframe \ - __attribute__ ((__cleanup__ (__pthread_cleanup_routine))) \ - = { .__cancel_routine = (routine), .__cancel_arg = (arg), \ - .__do_it = 1 }; \ - (void) pthread_setcanceltype (PTHREAD_CANCEL_DEFERRED, \ - &__clframe.__cancel_type) - -/* Remove a cleanup handler as pthread_cleanup_pop does, but also - restores the cancellation type that was in effect when the matching - pthread_cleanup_push_defer was called. */ -# define pthread_cleanup_pop_restore_np(execute) \ - (void) pthread_setcanceltype (__clframe.__cancel_type, NULL); \ - __clframe.__do_it = (execute); \ - } while (0) -# endif -# endif -#else -/* Install a cleanup handler: ROUTINE will be called with arguments ARG - when the thread is canceled or calls pthread_exit. ROUTINE will also - be called with arguments ARG when the matching pthread_cleanup_pop - is executed with non-zero EXECUTE argument. - - pthread_cleanup_push and pthread_cleanup_pop are macros and must always - be used in matching pairs at the same nesting level of braces. */ -# define pthread_cleanup_push(routine, arg) \ - do { \ - __pthread_unwind_buf_t __cancel_buf; \ - void (*__cancel_routine) (void *) = (routine); \ - void *__cancel_arg = (arg); \ - int __not_first_call = __sigsetjmp ((struct __jmp_buf_tag *) (void *) \ - __cancel_buf.__cancel_jmp_buf, 0); \ - if (__glibc_unlikely (__not_first_call)) \ - { \ - __cancel_routine (__cancel_arg); \ - __pthread_unwind_next (&__cancel_buf); \ - /* NOTREACHED */ \ - } \ - \ - __pthread_register_cancel (&__cancel_buf); \ - do { -extern void __pthread_register_cancel (__pthread_unwind_buf_t *__buf) - __cleanup_fct_attribute; - -/* Remove a cleanup handler installed by the matching pthread_cleanup_push. - If EXECUTE is non-zero, the handler function is called. */ -# define pthread_cleanup_pop(execute) \ - do { } while (0);/* Empty to allow label before pthread_cleanup_pop. */\ - } while (0); \ - __pthread_unregister_cancel (&__cancel_buf); \ - if (execute) \ - __cancel_routine (__cancel_arg); \ - } while (0) -extern void __pthread_unregister_cancel (__pthread_unwind_buf_t *__buf) - __cleanup_fct_attribute; - -# ifdef __USE_GNU -/* Install a cleanup handler as pthread_cleanup_push does, but also - saves the current cancellation type and sets it to deferred - cancellation. */ -# define pthread_cleanup_push_defer_np(routine, arg) \ - do { \ - __pthread_unwind_buf_t __cancel_buf; \ - void (*__cancel_routine) (void *) = (routine); \ - void *__cancel_arg = (arg); \ - int __not_first_call = __sigsetjmp ((struct __jmp_buf_tag *) (void *) \ - __cancel_buf.__cancel_jmp_buf, 0); \ - if (__glibc_unlikely (__not_first_call)) \ - { \ - __cancel_routine (__cancel_arg); \ - __pthread_unwind_next (&__cancel_buf); \ - /* NOTREACHED */ \ - } \ - \ - __pthread_register_cancel_defer (&__cancel_buf); \ - do { -extern void __pthread_register_cancel_defer (__pthread_unwind_buf_t *__buf) - __cleanup_fct_attribute; - -/* Remove a cleanup handler as pthread_cleanup_pop does, but also - restores the cancellation type that was in effect when the matching - pthread_cleanup_push_defer was called. */ -# define pthread_cleanup_pop_restore_np(execute) \ - do { } while (0);/* Empty to allow label before pthread_cleanup_pop. */\ - } while (0); \ - __pthread_unregister_cancel_restore (&__cancel_buf); \ - if (execute) \ - __cancel_routine (__cancel_arg); \ - } while (0) -extern void __pthread_unregister_cancel_restore (__pthread_unwind_buf_t *__buf) - __cleanup_fct_attribute; -# endif - -/* Internal interface to initiate cleanup. */ -extern void __pthread_unwind_next (__pthread_unwind_buf_t *__buf) - __cleanup_fct_attribute __attribute__ ((__noreturn__)) -# ifndef SHARED - __attribute__ ((__weak__)) -# endif - ; -#endif - -/* Function used in the macros. */ -struct __jmp_buf_tag; -extern int __sigsetjmp (struct __jmp_buf_tag *__env, int __savemask) __THROWNL; - - -/* Mutex handling. */ - -/* Initialize a mutex. */ -extern int pthread_mutex_init (pthread_mutex_t *__mutex, - const pthread_mutexattr_t *__mutexattr) - __THROW __nonnull ((1)); - -/* Destroy a mutex. */ -extern int pthread_mutex_destroy (pthread_mutex_t *__mutex) - __THROW __nonnull ((1)); - -/* Try locking a mutex. */ -extern int pthread_mutex_trylock (pthread_mutex_t *__mutex) - __THROWNL __nonnull ((1)); - -/* Lock a mutex. */ -extern int pthread_mutex_lock (pthread_mutex_t *__mutex) - __THROWNL __nonnull ((1)); - -#ifdef __USE_XOPEN2K -/* Wait until lock becomes available, or specified time passes. */ -extern int pthread_mutex_timedlock (pthread_mutex_t *__restrict __mutex, - const struct timespec *__restrict - __abstime) __THROWNL __nonnull ((1, 2)); -#endif - -/* Unlock a mutex. */ -extern int pthread_mutex_unlock (pthread_mutex_t *__mutex) - __THROWNL __nonnull ((1)); - - -/* Get the priority ceiling of MUTEX. */ -extern int pthread_mutex_getprioceiling (const pthread_mutex_t * - __restrict __mutex, - int *__restrict __prioceiling) - __THROW __nonnull ((1, 2)); - -/* Set the priority ceiling of MUTEX to PRIOCEILING, return old - priority ceiling value in *OLD_CEILING. */ -extern int pthread_mutex_setprioceiling (pthread_mutex_t *__restrict __mutex, - int __prioceiling, - int *__restrict __old_ceiling) - __THROW __nonnull ((1, 3)); - - -#ifdef __USE_XOPEN2K8 -/* Declare the state protected by MUTEX as consistent. */ -extern int pthread_mutex_consistent (pthread_mutex_t *__mutex) - __THROW __nonnull ((1)); -# ifdef __USE_GNU -extern int pthread_mutex_consistent_np (pthread_mutex_t *__mutex) - __THROW __nonnull ((1)); -# endif -#endif - - -/* Functions for handling mutex attributes. */ - -/* Initialize mutex attribute object ATTR with default attributes - (kind is PTHREAD_MUTEX_TIMED_NP). */ -extern int pthread_mutexattr_init (pthread_mutexattr_t *__attr) - __THROW __nonnull ((1)); - -/* Destroy mutex attribute object ATTR. */ -extern int pthread_mutexattr_destroy (pthread_mutexattr_t *__attr) - __THROW __nonnull ((1)); - -/* Get the process-shared flag of the mutex attribute ATTR. */ -extern int pthread_mutexattr_getpshared (const pthread_mutexattr_t * - __restrict __attr, - int *__restrict __pshared) - __THROW __nonnull ((1, 2)); - -/* Set the process-shared flag of the mutex attribute ATTR. */ -extern int pthread_mutexattr_setpshared (pthread_mutexattr_t *__attr, - int __pshared) - __THROW __nonnull ((1)); - -#if defined __USE_UNIX98 || defined __USE_XOPEN2K8 -/* Return in *KIND the mutex kind attribute in *ATTR. */ -extern int pthread_mutexattr_gettype (const pthread_mutexattr_t *__restrict - __attr, int *__restrict __kind) - __THROW __nonnull ((1, 2)); - -/* Set the mutex kind attribute in *ATTR to KIND (either PTHREAD_MUTEX_NORMAL, - PTHREAD_MUTEX_RECURSIVE, PTHREAD_MUTEX_ERRORCHECK, or - PTHREAD_MUTEX_DEFAULT). */ -extern int pthread_mutexattr_settype (pthread_mutexattr_t *__attr, int __kind) - __THROW __nonnull ((1)); -#endif - -/* Return in *PROTOCOL the mutex protocol attribute in *ATTR. */ -extern int pthread_mutexattr_getprotocol (const pthread_mutexattr_t * - __restrict __attr, - int *__restrict __protocol) - __THROW __nonnull ((1, 2)); - -/* Set the mutex protocol attribute in *ATTR to PROTOCOL (either - PTHREAD_PRIO_NONE, PTHREAD_PRIO_INHERIT, or PTHREAD_PRIO_PROTECT). */ -extern int pthread_mutexattr_setprotocol (pthread_mutexattr_t *__attr, - int __protocol) - __THROW __nonnull ((1)); - -/* Return in *PRIOCEILING the mutex prioceiling attribute in *ATTR. */ -extern int pthread_mutexattr_getprioceiling (const pthread_mutexattr_t * - __restrict __attr, - int *__restrict __prioceiling) - __THROW __nonnull ((1, 2)); - -/* Set the mutex prioceiling attribute in *ATTR to PRIOCEILING. */ -extern int pthread_mutexattr_setprioceiling (pthread_mutexattr_t *__attr, - int __prioceiling) - __THROW __nonnull ((1)); - -#ifdef __USE_XOPEN2K -/* Get the robustness flag of the mutex attribute ATTR. */ -extern int pthread_mutexattr_getrobust (const pthread_mutexattr_t *__attr, - int *__robustness) - __THROW __nonnull ((1, 2)); -# ifdef __USE_GNU -extern int pthread_mutexattr_getrobust_np (const pthread_mutexattr_t *__attr, - int *__robustness) - __THROW __nonnull ((1, 2)); -# endif - -/* Set the robustness flag of the mutex attribute ATTR. */ -extern int pthread_mutexattr_setrobust (pthread_mutexattr_t *__attr, - int __robustness) - __THROW __nonnull ((1)); -# ifdef __USE_GNU -extern int pthread_mutexattr_setrobust_np (pthread_mutexattr_t *__attr, - int __robustness) - __THROW __nonnull ((1)); -# endif -#endif - - -#if defined __USE_UNIX98 || defined __USE_XOPEN2K -/* Functions for handling read-write locks. */ - -/* Initialize read-write lock RWLOCK using attributes ATTR, or use - the default values if later is NULL. */ -extern int pthread_rwlock_init (pthread_rwlock_t *__restrict __rwlock, - const pthread_rwlockattr_t *__restrict - __attr) __THROW __nonnull ((1)); - -/* Destroy read-write lock RWLOCK. */ -extern int pthread_rwlock_destroy (pthread_rwlock_t *__rwlock) - __THROW __nonnull ((1)); - -/* Acquire read lock for RWLOCK. */ -extern int pthread_rwlock_rdlock (pthread_rwlock_t *__rwlock) - __THROWNL __nonnull ((1)); - -/* Try to acquire read lock for RWLOCK. */ -extern int pthread_rwlock_tryrdlock (pthread_rwlock_t *__rwlock) - __THROWNL __nonnull ((1)); - -# ifdef __USE_XOPEN2K -/* Try to acquire read lock for RWLOCK or return after specfied time. */ -extern int pthread_rwlock_timedrdlock (pthread_rwlock_t *__restrict __rwlock, - const struct timespec *__restrict - __abstime) __THROWNL __nonnull ((1, 2)); -# endif - -/* Acquire write lock for RWLOCK. */ -extern int pthread_rwlock_wrlock (pthread_rwlock_t *__rwlock) - __THROWNL __nonnull ((1)); - -/* Try to acquire write lock for RWLOCK. */ -extern int pthread_rwlock_trywrlock (pthread_rwlock_t *__rwlock) - __THROWNL __nonnull ((1)); - -# ifdef __USE_XOPEN2K -/* Try to acquire write lock for RWLOCK or return after specfied time. */ -extern int pthread_rwlock_timedwrlock (pthread_rwlock_t *__restrict __rwlock, - const struct timespec *__restrict - __abstime) __THROWNL __nonnull ((1, 2)); -# endif - -/* Unlock RWLOCK. */ -extern int pthread_rwlock_unlock (pthread_rwlock_t *__rwlock) - __THROWNL __nonnull ((1)); - - -/* Functions for handling read-write lock attributes. */ - -/* Initialize attribute object ATTR with default values. */ -extern int pthread_rwlockattr_init (pthread_rwlockattr_t *__attr) - __THROW __nonnull ((1)); - -/* Destroy attribute object ATTR. */ -extern int pthread_rwlockattr_destroy (pthread_rwlockattr_t *__attr) - __THROW __nonnull ((1)); - -/* Return current setting of process-shared attribute of ATTR in PSHARED. */ -extern int pthread_rwlockattr_getpshared (const pthread_rwlockattr_t * - __restrict __attr, - int *__restrict __pshared) - __THROW __nonnull ((1, 2)); - -/* Set process-shared attribute of ATTR to PSHARED. */ -extern int pthread_rwlockattr_setpshared (pthread_rwlockattr_t *__attr, - int __pshared) - __THROW __nonnull ((1)); - -/* Return current setting of reader/writer preference. */ -extern int pthread_rwlockattr_getkind_np (const pthread_rwlockattr_t * - __restrict __attr, - int *__restrict __pref) - __THROW __nonnull ((1, 2)); - -/* Set reader/write preference. */ -extern int pthread_rwlockattr_setkind_np (pthread_rwlockattr_t *__attr, - int __pref) __THROW __nonnull ((1)); -#endif - - -/* Functions for handling conditional variables. */ - -/* Initialize condition variable COND using attributes ATTR, or use - the default values if later is NULL. */ -extern int pthread_cond_init (pthread_cond_t *__restrict __cond, - const pthread_condattr_t *__restrict __cond_attr) - __THROW __nonnull ((1)); - -/* Destroy condition variable COND. */ -extern int pthread_cond_destroy (pthread_cond_t *__cond) - __THROW __nonnull ((1)); - -/* Wake up one thread waiting for condition variable COND. */ -extern int pthread_cond_signal (pthread_cond_t *__cond) - __THROWNL __nonnull ((1)); - -/* Wake up all threads waiting for condition variables COND. */ -extern int pthread_cond_broadcast (pthread_cond_t *__cond) - __THROWNL __nonnull ((1)); - -/* Wait for condition variable COND to be signaled or broadcast. - MUTEX is assumed to be locked before. - - This function is a cancellation point and therefore not marked with - __THROW. */ -extern int pthread_cond_wait (pthread_cond_t *__restrict __cond, - pthread_mutex_t *__restrict __mutex) - __nonnull ((1, 2)); - -/* Wait for condition variable COND to be signaled or broadcast until - ABSTIME. MUTEX is assumed to be locked before. ABSTIME is an - absolute time specification; zero is the beginning of the epoch - (00:00:00 GMT, January 1, 1970). - - This function is a cancellation point and therefore not marked with - __THROW. */ -extern int pthread_cond_timedwait (pthread_cond_t *__restrict __cond, - pthread_mutex_t *__restrict __mutex, - const struct timespec *__restrict __abstime) - __nonnull ((1, 2, 3)); - -/* Functions for handling condition variable attributes. */ - -/* Initialize condition variable attribute ATTR. */ -extern int pthread_condattr_init (pthread_condattr_t *__attr) - __THROW __nonnull ((1)); - -/* Destroy condition variable attribute ATTR. */ -extern int pthread_condattr_destroy (pthread_condattr_t *__attr) - __THROW __nonnull ((1)); - -/* Get the process-shared flag of the condition variable attribute ATTR. */ -extern int pthread_condattr_getpshared (const pthread_condattr_t * - __restrict __attr, - int *__restrict __pshared) - __THROW __nonnull ((1, 2)); - -/* Set the process-shared flag of the condition variable attribute ATTR. */ -extern int pthread_condattr_setpshared (pthread_condattr_t *__attr, - int __pshared) __THROW __nonnull ((1)); - -#ifdef __USE_XOPEN2K -/* Get the clock selected for the condition variable attribute ATTR. */ -extern int pthread_condattr_getclock (const pthread_condattr_t * - __restrict __attr, - __clockid_t *__restrict __clock_id) - __THROW __nonnull ((1, 2)); - -/* Set the clock selected for the condition variable attribute ATTR. */ -extern int pthread_condattr_setclock (pthread_condattr_t *__attr, - __clockid_t __clock_id) - __THROW __nonnull ((1)); -#endif - - -#ifdef __USE_XOPEN2K -/* Functions to handle spinlocks. */ - -/* Initialize the spinlock LOCK. If PSHARED is nonzero the spinlock can - be shared between different processes. */ -extern int pthread_spin_init (pthread_spinlock_t *__lock, int __pshared) - __THROW __nonnull ((1)); - -/* Destroy the spinlock LOCK. */ -extern int pthread_spin_destroy (pthread_spinlock_t *__lock) - __THROW __nonnull ((1)); - -/* Wait until spinlock LOCK is retrieved. */ -extern int pthread_spin_lock (pthread_spinlock_t *__lock) - __THROWNL __nonnull ((1)); - -/* Try to lock spinlock LOCK. */ -extern int pthread_spin_trylock (pthread_spinlock_t *__lock) - __THROWNL __nonnull ((1)); - -/* Release spinlock LOCK. */ -extern int pthread_spin_unlock (pthread_spinlock_t *__lock) - __THROWNL __nonnull ((1)); - - -/* Functions to handle barriers. */ - -/* Initialize BARRIER with the attributes in ATTR. The barrier is - opened when COUNT waiters arrived. */ -extern int pthread_barrier_init (pthread_barrier_t *__restrict __barrier, - const pthread_barrierattr_t *__restrict - __attr, unsigned int __count) - __THROW __nonnull ((1)); - -/* Destroy a previously dynamically initialized barrier BARRIER. */ -extern int pthread_barrier_destroy (pthread_barrier_t *__barrier) - __THROW __nonnull ((1)); - -/* Wait on barrier BARRIER. */ -extern int pthread_barrier_wait (pthread_barrier_t *__barrier) - __THROWNL __nonnull ((1)); - - -/* Initialize barrier attribute ATTR. */ -extern int pthread_barrierattr_init (pthread_barrierattr_t *__attr) - __THROW __nonnull ((1)); - -/* Destroy previously dynamically initialized barrier attribute ATTR. */ -extern int pthread_barrierattr_destroy (pthread_barrierattr_t *__attr) - __THROW __nonnull ((1)); - -/* Get the process-shared flag of the barrier attribute ATTR. */ -extern int pthread_barrierattr_getpshared (const pthread_barrierattr_t * - __restrict __attr, - int *__restrict __pshared) - __THROW __nonnull ((1, 2)); - -/* Set the process-shared flag of the barrier attribute ATTR. */ -extern int pthread_barrierattr_setpshared (pthread_barrierattr_t *__attr, - int __pshared) - __THROW __nonnull ((1)); -#endif - - -/* Functions for handling thread-specific data. */ - -/* Create a key value identifying a location in the thread-specific - data area. Each thread maintains a distinct thread-specific data - area. DESTR_FUNCTION, if non-NULL, is called with the value - associated to that key when the key is destroyed. - DESTR_FUNCTION is not called if the value associated is NULL when - the key is destroyed. */ -extern int pthread_key_create (pthread_key_t *__key, - void (*__destr_function) (void *)) - __THROW __nonnull ((1)); - -/* Destroy KEY. */ -extern int pthread_key_delete (pthread_key_t __key) __THROW; - -/* Return current value of the thread-specific data slot identified by KEY. */ -extern void *pthread_getspecific (pthread_key_t __key) __THROW; - -/* Store POINTER in the thread-specific data slot identified by KEY. */ -extern int pthread_setspecific (pthread_key_t __key, - const void *__pointer) __THROW ; - - -#ifdef __USE_XOPEN2K -/* Get ID of CPU-time clock for thread THREAD_ID. */ -extern int pthread_getcpuclockid (pthread_t __thread_id, - __clockid_t *__clock_id) - __THROW __nonnull ((2)); -#endif - - -/* Install handlers to be called when a new process is created with FORK. - The PREPARE handler is called in the parent process just before performing - FORK. The PARENT handler is called in the parent process just after FORK. - The CHILD handler is called in the child process. Each of the three - handlers can be NULL, meaning that no handler needs to be called at that - point. - PTHREAD_ATFORK can be called several times, in which case the PREPARE - handlers are called in LIFO order (last added with PTHREAD_ATFORK, - first called before FORK), and the PARENT and CHILD handlers are called - in FIFO (first added, first called). */ - -extern int pthread_atfork (void (*__prepare) (void), - void (*__parent) (void), - void (*__child) (void)) __THROW; - - -#ifdef __USE_EXTERN_INLINES -/* Optimizations. */ -__extern_inline int -__NTH (pthread_equal (pthread_t __thread1, pthread_t __thread2)) -{ - return __thread1 == __thread2; -} -#endif - -__END_DECLS - -#endif /* pthread.h */ diff --git a/sysdeps/unix/sysv/linux/hppa/pthreadP.h b/sysdeps/unix/sysv/linux/hppa/pthreadP.h deleted file mode 100644 index 744b5b0..0000000 --- a/sysdeps/unix/sysv/linux/hppa/pthreadP.h +++ /dev/null @@ -1,16 +0,0 @@ -#include_next -#ifndef _PTHREADP_H_HPPA_ -#define _PTHREADP_H_HPPA_ 1 - -/* Internal cond functions. */ -extern int __pthread_cond_broadcast_internal (pthread_cond_t *cond); -extern int __pthread_cond_destroy_internal (pthread_cond_t *cond); -extern int __pthread_cond_init_internal (pthread_cond_t *cond, - const pthread_condattr_t *cond_attr); -extern int __pthread_cond_signal_internal (pthread_cond_t *cond); -extern int __pthread_cond_timedwait_internal (pthread_cond_t *cond, - pthread_mutex_t *mutex, - const struct timespec *abstime); -extern int __pthread_cond_wait_internal (pthread_cond_t *cond, - pthread_mutex_t *mutex); -#endif