File: apr_threads.m4

package info (click to toggle)
apr 1.6.5-1
  • links: PTS, VCS
  • area: main
  • in suites: bullseye, buster, sid
  • size: 7,132 kB
  • sloc: ansic: 60,108; sh: 3,610; perl: 900; awk: 393; makefile: 366; python: 142
file content (283 lines) | stat: -rw-r--r-- 8,049 bytes parent folder | download | duplicates (9)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
dnl -------------------------------------------------------- -*- autoconf -*-
dnl Licensed to the Apache Software Foundation (ASF) under one or more
dnl contributor license agreements.  See the NOTICE file distributed with
dnl this work for additional information regarding copyright ownership.
dnl The ASF licenses this file to You under the Apache License, Version 2.0
dnl (the "License"); you may not use this file except in compliance with
dnl the License.  You may obtain a copy of the License at
dnl
dnl     http://www.apache.org/licenses/LICENSE-2.0
dnl
dnl Unless required by applicable law or agreed to in writing, software
dnl distributed under the License is distributed on an "AS IS" BASIS,
dnl WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
dnl See the License for the specific language governing permissions and
dnl limitations under the License.

dnl -----------------------------------------------------------------
dnl apr_threads.m4: APR's autoconf macros for testing thread support
dnl

dnl
dnl APR_CHECK_PTHREADS_H([ ACTION-IF-FOUND [, ACTION-IF-NOT-FOUND]])
dnl
dnl gcc issues warnings when parsing AIX 4.3.3's pthread.h
dnl which causes autoconf to incorrectly conclude that
dnl pthreads is not available.
dnl Turn off warnings if we're using gcc.
dnl
AC_DEFUN(APR_CHECK_PTHREADS_H, [
  if test "$GCC" = "yes"; then
    SAVE_FL="$CPPFLAGS"
    CPPFLAGS="$CPPFLAGS -w"
    AC_CHECK_HEADERS(pthread.h, [ $1 ] , [ $2 ] )
    CPPFLAGS="$SAVE_FL"
  else
    AC_CHECK_HEADERS(pthread.h, [ $1 ] , [ $2 ] )
  fi
])dnl


dnl
dnl APR_CHECK_PTHREAD_GETSPECIFIC_TWO_ARGS
dnl
AC_DEFUN(APR_CHECK_PTHREAD_GETSPECIFIC_TWO_ARGS, [
AC_CACHE_CHECK(whether pthread_getspecific takes two arguments, ac_cv_pthread_getspecific_two_args,[
AC_TRY_COMPILE([
#include <pthread.h>
],[
pthread_key_t key;
void *tmp;
pthread_getspecific(key,&tmp);
],[
    ac_cv_pthread_getspecific_two_args=yes
],[
    ac_cv_pthread_getspecific_two_args=no
])
])

if test "$ac_cv_pthread_getspecific_two_args" = "yes"; then
  AC_DEFINE(PTHREAD_GETSPECIFIC_TAKES_TWO_ARGS, 1, [Define if pthread_getspecific() has two args])
fi
])dnl


dnl
dnl APR_CHECK_PTHREAD_ATTR_GETDETACHSTATE_ONE_ARG
dnl
AC_DEFUN(APR_CHECK_PTHREAD_ATTR_GETDETACHSTATE_ONE_ARG, [
AC_CACHE_CHECK(whether pthread_attr_getdetachstate takes one argument, ac_cv_pthread_attr_getdetachstate_one_arg,[
AC_TRY_COMPILE([
#include <pthread.h>
],[
pthread_attr_t *attr;
pthread_attr_getdetachstate(attr);
],[
    ac_cv_pthread_attr_getdetachstate_one_arg=yes
],[
    ac_cv_pthread_attr_getdetachstate_one_arg=no
])
])

if test "$ac_cv_pthread_attr_getdetachstate_one_arg" = "yes"; then
  AC_DEFINE(PTHREAD_ATTR_GETDETACHSTATE_TAKES_ONE_ARG, 1, [Define if pthread_attr_getdetachstate() has one arg])
fi
])dnl


dnl
dnl APR_PTHREADS_TRY_RUN(actions-if-success)
dnl
dnl Try running a program which uses pthreads, executing the
dnl actions-if-success commands on success.
dnl
AC_DEFUN(APR_PTHREADS_TRY_RUN, [
AC_TRY_RUN( [
#include <pthread.h>
#include <stddef.h>

void *thread_routine(void *data) {
    return data;
}

int main() {
    pthread_t thd;
    pthread_mutexattr_t mattr;
    pthread_once_t once_init = PTHREAD_ONCE_INIT;
    int data = 1;
    pthread_mutexattr_init(&mattr);
    return pthread_create(&thd, NULL, thread_routine, &data);
} ], [apr_p_t_r=yes], [apr_p_t_r=no], [apr_p_t_r=no])

if test $apr_p_t_r = yes; then
  $1
fi

])dnl


dnl
dnl APR_PTHREADS_CHECK()
dnl
dnl Try to find a way to enable POSIX threads.  Sets the 
dnl pthreads_working variable to "yes" on success.
dnl
AC_DEFUN([APR_PTHREADS_CHECK], [

AC_CACHE_CHECK([for CFLAGS needed for pthreads], [apr_cv_pthreads_cflags],
[apr_ptc_cflags=$CFLAGS
 for flag in none -kthread -pthread -pthreads -mt -mthreads -Kthread -threads; do 
    CFLAGS=$apr_ptc_cflags
    test "x$flag" != "xnone" && CFLAGS="$CFLAGS $flag"
    APR_PTHREADS_TRY_RUN([
      apr_cv_pthreads_cflags="$flag"
      break
    ])
 done
 CFLAGS=$apr_ptc_cflags
])

if test -n "$apr_cv_pthreads_cflags"; then
   pthreads_working=yes
   if test "x$apr_cv_pthreads_cflags" != "xnone"; then
     APR_ADDTO(CFLAGS,[$apr_cv_pthreads_cflags])
   fi
fi

# The CFLAGS may or may not be sufficient to ensure that libapr
# depends on the pthreads library: some versions of libtool
# drop -pthread when passed on the link line; some versions of
# gcc ignore -pthread when linking a shared object.  So always
# try and add the relevant library to LIBS too.

AC_CACHE_CHECK([for LIBS needed for pthreads], [apr_cv_pthreads_lib], [
  apr_ptc_libs=$LIBS
  for lib in -lpthread -lpthreads -lc_r; do
    LIBS="$apr_ptc_libs $lib"
    APR_PTHREADS_TRY_RUN([
      apr_cv_pthreads_lib=$lib
      break
    ])
  done
  LIBS=$apr_ptc_libs
])

if test -n "$apr_cv_pthreads_lib"; then
   pthreads_working=yes
   APR_ADDTO(LIBS,[$apr_cv_pthreads_lib])
fi

if test "$pthreads_working" = "yes"; then
  threads_result="POSIX Threads found"
else
  threads_result="POSIX Threads not found"
fi
])dnl

dnl
dnl APR_PTHREADS_CHECK_SAVE
dnl APR_PTHREADS_CHECK_RESTORE
dnl
dnl Save the global environment variables that might be modified during
dnl the checks for threading support so that they can restored if the
dnl result is not what the caller wanted.
dnl
AC_DEFUN(APR_PTHREADS_CHECK_SAVE, [
  apr_pthsv_CFLAGS="$CFLAGS"
  apr_pthsv_LIBS="$LIBS"
])dnl

AC_DEFUN(APR_PTHREADS_CHECK_RESTORE, [
  CFLAGS="$apr_pthsv_CFLAGS"
  LIBS="$apr_pthsv_LIBS"
])dnl

dnl
dnl APR_CHECK_SIGWAIT_ONE_ARG
dnl
AC_DEFUN([APR_CHECK_SIGWAIT_ONE_ARG], [
  AC_CACHE_CHECK(whether sigwait takes one argument,ac_cv_sigwait_one_arg,[
  AC_TRY_COMPILE([
#if defined(__NETBSD__) || defined(DARWIN)
    /* When using the unproven-pthreads package, we need to pull in this
     * header to get a prototype for sigwait().  Else things will fail later
     * on.  XXX Should probably be fixed in the unproven-pthreads package.
     * Darwin is declaring sigwait() in the wrong place as well.
     */
#include <pthread.h>
#endif
#include <signal.h>
],[
  sigset_t set;
 
  sigwait(&set);
],[
  ac_cv_sigwait_one_arg=yes
],[
  ac_cv_sigwait_one_arg=no
])])
  if test "$ac_cv_sigwait_one_arg" = "yes"; then
    AC_DEFINE(SIGWAIT_TAKES_ONE_ARG,1,[ ])
  fi
])

dnl Check for recursive mutex support (per SUSv3).
AC_DEFUN([APR_CHECK_PTHREAD_RECURSIVE_MUTEX], [
  AC_CACHE_CHECK([for recursive mutex support], [apr_cv_mutex_recursive],
[AC_TRY_RUN([#include <sys/types.h>
#include <pthread.h>
#include <stdlib.h>

int main() {
    pthread_mutexattr_t attr;
    pthread_mutex_t m;

    exit (pthread_mutexattr_init(&attr) 
          || pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE)
          || pthread_mutex_init(&m, &attr));
}], [apr_cv_mutex_recursive=yes], [apr_cv_mutex_recursive=no], 
[apr_cv_mutex_recursive=no])])

if test "$apr_cv_mutex_recursive" = "yes"; then
   AC_DEFINE([HAVE_PTHREAD_MUTEX_RECURSIVE], 1,
             [Define if recursive pthread mutexes are available])
fi
])

dnl Check for robust process-shared mutex support
AC_DEFUN([APR_CHECK_PTHREAD_ROBUST_SHARED_MUTEX], [
AC_CACHE_CHECK([for robust cross-process mutex support], 
[apr_cv_mutex_robust_shared],
[AC_TRY_RUN([
#include <sys/types.h>
#include <pthread.h>
#include <stdlib.h>

int main(int argc, char **argv)
{
    pthread_mutex_t mutex;
    pthread_mutexattr_t attr;

    if (pthread_mutexattr_init(&attr))
        exit(1);
    if (pthread_mutexattr_setpshared(&attr, PTHREAD_PROCESS_SHARED))
        exit(2);
    if (pthread_mutexattr_setrobust_np(&attr, PTHREAD_MUTEX_ROBUST_NP))
        exit(3);
    if (pthread_mutexattr_setprotocol(&attr, PTHREAD_PRIO_INHERIT))
        exit(4);
    if (pthread_mutex_init(&mutex, &attr))
        exit(5);
    if (pthread_mutexattr_destroy(&attr))
        exit(6);
    if (pthread_mutex_destroy(&mutex))
        exit(7);

    exit(0);
}], [apr_cv_mutex_robust_shared=yes], [apr_cv_mutex_robust_shared=no])])

if test "$apr_cv_mutex_robust_shared" = "yes"; then
   AC_DEFINE([HAVE_PTHREAD_MUTEX_ROBUST], 1,
             [Define if cross-process robust mutexes are available])
fi
])