1dnl OpenLDAP Autoconf thread check 2dnl 3dnl This work is part of OpenLDAP Software <http://www.openldap.org/>. 4dnl 5dnl Copyright 1998-2010 The OpenLDAP Foundation. 6dnl All rights reserved. 7dnl 8dnl Redistribution and use in source and binary forms, with or without 9dnl modification, are permitted only as authorized by the OpenLDAP 10dnl Public License. 11dnl 12dnl A copy of this license is available in the file LICENSE-OPENLDAP in 13dnl this directory of the distribution or, alternatively, at 14dnl <http://www.OpenLDAP.org/license.html>. 15dnl 16dnl -------------------------------------------------------------------- 17 18dnl This file is a fragment of OpenLDAP's build/openldap.m4 and some 19dnl fragments of OpenLDAP's configure.ac . 20 21# OL_THREAD_CHECK([ACTION-IF-FOUND[, ACTION-IF-NOT-FOUND]]) 22 23AC_DEFUN([OL_THREAD_CHECK], [ 24AC_REQUIRE([AC_CANONICAL_HOST]) 25AC_LANG_SAVE 26AC_LANG([C]) 27OL_ARG_WITH(threads,[ --with-threads with threads], 28 auto, [auto nt posix mach pth lwp yes no manual] ) 29 30case "$ol_with_threads$host" in 31 auto*-*-solaris2.[[0-6]]) 32 dnl signals sometimes delivered to wrong thread with Solaris 2.6 33 ol_with_threads=no 34 ;; 35esac 36 37dnl AIX Thread requires we use cc_r or xlc_r. 38dnl But only do this IF AIX and CC is not set 39dnl and threads are auto|yes|posix. 40dnl 41dnl If we find cc_r|xlc_r, force pthreads and assume 42dnl pthread_create is in $LIBS (ie: don't bring in 43dnl any additional thread libraries) 44dnl If we do not find cc_r|xlc_r, disable threads 45 46ol_aix_threads=no 47case "$host" in 48*-*-aix*) dnl all AIX is not a good idea. 49 if test -z "$CC" ; then 50 case "$ol_with_threads" in 51 auto | yes | posix) ol_aix_threads=yes ;; 52 esac 53 fi 54;; 55esac 56 57if test $ol_aix_threads = yes ; then 58 if test -z "${CC}" ; then 59 AC_CHECK_PROGS(CC,cc_r xlc_r cc) 60 61 if test "$CC" = cc ; then 62 dnl no CC! don't allow --with-threads 63 if test $ol_with_threads != auto ; then 64 AC_MSG_ERROR([--with-threads requires cc_r (or other suitable compiler) on AIX]) 65 else 66 AC_MSG_WARN([disabling threads, no cc_r on AIX]) 67 fi 68 ol_with_threads=no 69 fi 70 fi 71 72 case ${CC} in cc_r | xlc_r) 73 ol_with_threads=posix 74 ol_cv_pthread_create=yes 75 ;; 76 esac 77fi 78 79dnl ---------------------------------------------------------------- 80dnl Threads? 81ol_link_threads=no 82dnl ol_with_yielding_select=${ol_with_yielding_select:-auto} 83OL_ARG_WITH(yielding_select,[ --with-yielding-select with yielding select], 84 auto, [auto yes no manual] ) 85 86case $ol_with_threads in auto | yes | nt) 87 88 OL_NT_THREADS 89 90 if test "$ol_cv_nt_threads" = yes ; then 91 ol_link_threads=nt 92 ol_with_threads=found 93 ol_with_yielding_select=yes 94 95 AC_DEFINE([HAVE_NT_SERVICE_MANAGER], [1], [if you have NT Service Manager]) 96 AC_DEFINE([HAVE_NT_EVENT_LOG], [1], [if you have NT Event Log]) 97 fi 98 99 if test $ol_with_threads = nt ; then 100 AC_MSG_ERROR([could not locate NT Threads]) 101 fi 102 ;; 103esac 104 105case $ol_with_threads in auto | yes | posix) 106 107 AC_CHECK_HEADERS(pthread.h) 108 109 if test $ac_cv_header_pthread_h = yes ; then 110 OL_POSIX_THREAD_VERSION 111 112 if test $ol_cv_pthread_version != 0 ; then 113 AC_DEFINE_UNQUOTED([HAVE_PTHREADS], [$ol_cv_pthread_version], 114 [define to pthreads API spec revision]) 115 else 116 AC_MSG_ERROR([unknown pthread version]) 117 fi 118 119 # consider threads found 120 ol_with_threads=found 121 122 OL_HEADER_LINUX_THREADS 123 OL_HEADER_GNU_PTH_PTHREAD_H 124 125 if test $ol_cv_header_gnu_pth_pthread_h = no ; then 126 AC_CHECK_HEADERS(sched.h) 127 fi 128 129 dnl Now the hard part, how to link? 130 dnl 131 dnl currently supported checks: 132 dnl 133 dnl Check for no flags 134 dnl pthread_create() in $LIBS 135 dnl 136 dnl Check special pthread (final) flags 137 dnl [skipped] pthread_create() with -mt (Solaris) [disabled] 138 dnl pthread_create() with -kthread (FreeBSD) 139 dnl pthread_create() with -pthread (FreeBSD/Digital Unix) 140 dnl pthread_create() with -pthreads (?) 141 dnl pthread_create() with -mthreads (AIX) 142 dnl pthread_create() with -thread (?) 143 dnl 144 dnl Check pthread (final) libraries 145 dnl pthread_mutex_unlock() in -lpthread -lmach -lexc -lc_r (OSF/1) 146 dnl pthread_mutex_lock() in -lpthread -lmach -lexc (OSF/1) 147 dnl [skipped] pthread_mutex_trylock() in -lpthread -lexc (OSF/1) 148 dnl pthread_join() -Wl,-woff,85 -lpthread (IRIX) 149 dnl pthread_create() in -lpthread (many) 150 dnl pthread_create() in -lc_r (FreeBSD) 151 dnl 152 dnl Check pthread (draft4) flags (depreciated) 153 dnl pthread_create() with -threads (OSF/1) 154 dnl 155 dnl Check pthread (draft4) libraries (depreciated) 156 dnl pthread_mutex_unlock() in -lpthreads -lmach -lexc -lc_r (OSF/1) 157 dnl pthread_mutex_lock() in -lpthreads -lmach -lexc (OSF/1) 158 dnl pthread_mutex_trylock() in -lpthreads -lexc (OSF/1) 159 dnl pthread_create() in -lpthreads (many) 160 dnl 161 162 dnl pthread_create in $LIBS 163 AC_CACHE_CHECK([for pthread_create in default libraries], 164 ol_cv_pthread_create,[ 165 AC_RUN_IFELSE([OL_PTHREAD_TEST_PROGRAM], 166 [ol_cv_pthread_create=yes], 167 [ol_cv_pthread_create=no], 168 [AC_TRY_LINK(OL_PTHREAD_TEST_INCLUDES,OL_PTHREAD_TEST_FUNCTION, 169 [ol_cv_pthread_create=yes], 170 [ol_cv_pthread_create=no])])]) 171 172 if test $ol_cv_pthread_create != no ; then 173 ol_link_threads=posix 174 ol_link_pthreads="" 175 fi 176 177dnl OL_PTHREAD_TRY([-mt], [ol_cv_pthread_mt]) 178 OL_PTHREAD_TRY([-kthread], [ol_cv_pthread_kthread]) 179 OL_PTHREAD_TRY([-pthread], [ol_cv_pthread_pthread]) 180 OL_PTHREAD_TRY([-pthreads], [ol_cv_pthread_pthreads]) 181 OL_PTHREAD_TRY([-mthreads], [ol_cv_pthread_mthreads]) 182 OL_PTHREAD_TRY([-thread], [ol_cv_pthread_thread]) 183 184 OL_PTHREAD_TRY([-lpthread -lmach -lexc -lc_r], 185 [ol_cv_pthread_lpthread_lmach_lexc_lc_r]) 186 OL_PTHREAD_TRY([-lpthread -lmach -lexc], 187 [ol_cv_pthread_lpthread_lmach_lexc]) 188dnl OL_PTHREAD_TRY([-lpthread -lexc], 189dnl [ol_cv_pthread_lpthread_lexc]) 190 191 OL_PTHREAD_TRY([-lpthread -Wl,-woff,85], 192 [ol_cv_pthread_lib_lpthread_woff]) 193 194 OL_PTHREAD_TRY([-lpthread], [ol_cv_pthread_lpthread]) 195 OL_PTHREAD_TRY([-lc_r], [ol_cv_pthread_lc_r]) 196 197 OL_PTHREAD_TRY([-threads], [ol_cv_pthread_threads]) 198 199 OL_PTHREAD_TRY([-lpthreads -lmach -lexc -lc_r], 200 [ol_cv_pthread_lpthreads_lmach_lexc_lc_r]) 201 OL_PTHREAD_TRY([-lpthreads -lmach -lexc], 202 [ol_cv_pthread_lpthreads_lmach_lexc]) 203 OL_PTHREAD_TRY([-lpthreads -lexc], 204 [ol_cv_pthread_lpthreads_lexc]) 205 206 OL_PTHREAD_TRY([-lpthreads],[ol_cv_pthread_lib_lpthreads]) 207 208AC_MSG_NOTICE([ol_link_threads: <$ol_link_threads> ol_link_pthreads <$ol_link_pthreads>]) 209 210 if test $ol_link_threads != no ; then 211 LTHREAD_LIBS="$LTHREAD_LIBS $ol_link_pthreads" 212 213 dnl save flags 214 save_CPPFLAGS="$CPPFLAGS" 215 save_LIBS="$LIBS" 216 LIBS="$LTHREAD_LIBS $LIBS" 217 218 dnl All POSIX Thread (final) implementations should have 219 dnl sched_yield instead of pthread yield. 220 dnl check for both, and thr_yield for Solaris 221 AC_CHECK_FUNCS(sched_yield pthread_yield thr_yield) 222 223 if test $ac_cv_func_sched_yield = no && 224 test $ac_cv_func_pthread_yield = no && 225 test $ac_cv_func_thr_yield = no ; then 226 dnl Digital UNIX has sched_yield() in -lrt 227 AC_CHECK_LIB(rt, sched_yield, 228 [LTHREAD_LIBS="$LTHREAD_LIBS -lrt" 229 AC_DEFINE([HAVE_SCHED_YIELD], [1], 230 [Define if you have the sched_yield function.]) 231 ac_cv_func_sched_yield=yes], 232 [ac_cv_func_sched_yield=no]) 233 fi 234 if test $ac_cv_func_sched_yield = no && 235 test $ac_cv_func_pthread_yield = no && 236 test "$ac_cv_func_thr_yield" = no ; then 237 AC_MSG_WARN([could not locate sched_yield() or pthread_yield()]) 238 fi 239 240 dnl Check functions for compatibility 241 AC_CHECK_FUNCS(pthread_kill) 242 243 dnl Check for pthread_rwlock_destroy with <pthread.h> 244 dnl as pthread_rwlock_t may not be defined. 245 AC_CACHE_CHECK([for pthread_rwlock_destroy with <pthread.h>], 246 [ol_cv_func_pthread_rwlock_destroy], [ 247 dnl save the flags 248 AC_LINK_IFELSE([AC_LANG_PROGRAM([[ 249#include <pthread.h> 250pthread_rwlock_t rwlock; 251]], [[pthread_rwlock_destroy(&rwlock);]])],[ol_cv_func_pthread_rwlock_destroy=yes],[ol_cv_func_pthread_rwlock_destroy=no]) 252 ]) 253 if test $ol_cv_func_pthread_rwlock_destroy = yes ; then 254 AC_DEFINE([HAVE_PTHREAD_RWLOCK_DESTROY], [1], 255 [define if you have pthread_rwlock_destroy function]) 256 fi 257 258 dnl Check for pthread_detach with <pthread.h> inclusion 259 dnl as it's symbol may have been mangled. 260 AC_CACHE_CHECK([for pthread_detach with <pthread.h>], 261 [ol_cv_func_pthread_detach], [ 262 dnl save the flags 263 AC_LINK_IFELSE([AC_LANG_PROGRAM([[ 264#include <pthread.h> 265#ifndef NULL 266#define NULL (void*)0 267#endif 268]], [[pthread_detach(NULL);]])],[ol_cv_func_pthread_detach=yes],[ol_cv_func_pthread_detach=no]) 269 ]) 270 271 if test $ol_cv_func_pthread_detach = no ; then 272 AC_MSG_ERROR([could not locate pthread_detach()]) 273 fi 274 275 AC_DEFINE([HAVE_PTHREAD_DETACH], [1], 276 [define if you have pthread_detach function]) 277 278 dnl Check for setconcurreny functions 279 AC_CHECK_FUNCS( \ 280 pthread_setconcurrency \ 281 pthread_getconcurrency \ 282 thr_setconcurrency \ 283 thr_getconcurrency \ 284 ) 285 286 OL_SYS_LINUX_THREADS 287 OL_LINUX_THREADS 288 289 if test $ol_cv_linux_threads = error; then 290 AC_MSG_ERROR([LinuxThreads header/library mismatch]); 291 fi 292 293 AC_CACHE_CHECK([if pthread_create() works], 294 ol_cv_pthread_create_works,[ 295 AC_RUN_IFELSE([OL_PTHREAD_TEST_PROGRAM], 296 [ol_cv_pthread_create_works=yes], 297 [ol_cv_pthread_create_works=no], 298 [dnl assume yes 299 ol_cv_pthread_create_works=yes])]) 300 301 if test $ol_cv_pthread_create_works = no ; then 302 AC_MSG_ERROR([pthread_create is not usable, check environment settings]) 303 fi 304 305 ol_replace_broken_yield=no 306dnl case "$host" in 307dnl *-*-linux*) 308dnl AC_CHECK_FUNCS(nanosleep) 309dnl ol_replace_broken_yield=yes 310dnl ;; 311dnl esac 312 313 if test $ol_replace_broken_yield = yes ; then 314 AC_DEFINE([REPLACE_BROKEN_YIELD], [1], 315 [define if sched_yield yields the entire process]) 316 fi 317 318 dnl Check if select causes an yield 319 if test x$ol_with_yielding_select = xauto ; then 320 AC_CACHE_CHECK([if select yields when using pthreads], 321 ol_cv_pthread_select_yields,[ 322 AC_RUN_IFELSE([AC_LANG_SOURCE([[ 323#include <sys/types.h> 324#include <sys/time.h> 325#include <unistd.h> 326#include <pthread.h> 327#ifndef NULL 328#define NULL (void*) 0 329#endif 330 331static int fildes[2]; 332 333static void *task(p) 334 void *p; 335{ 336 int i; 337 struct timeval tv; 338 339 fd_set rfds; 340 341 tv.tv_sec=10; 342 tv.tv_usec=0; 343 344 FD_ZERO(&rfds); 345 FD_SET(fildes[0], &rfds); 346 347 /* we're not interested in any fds */ 348 i = select(FD_SETSIZE, &rfds, NULL, NULL, &tv); 349 350 if(i < 0) { 351 perror("select"); 352 exit(10); 353 } 354 355 exit(0); /* if we exit here, the select blocked the whole process */ 356} 357 358int main(argc, argv) 359 int argc; 360 char **argv; 361{ 362 pthread_t t; 363 364 /* create a pipe to select */ 365 if(pipe(&fildes[0])) { 366 perror("select"); 367 exit(1); 368 } 369 370#ifdef HAVE_PTHREAD_SETCONCURRENCY 371 (void) pthread_setconcurrency(2); 372#else 373#ifdef HAVE_THR_SETCONCURRENCY 374 /* Set Solaris LWP concurrency to 2 */ 375 thr_setconcurrency(2); 376#endif 377#endif 378 379#if HAVE_PTHREADS < 6 380 pthread_create(&t, pthread_attr_default, task, NULL); 381#else 382 pthread_create(&t, NULL, task, NULL); 383#endif 384 385 /* make sure task runs first */ 386#ifdef HAVE_THR_YIELD 387 thr_yield(); 388#elif defined( HAVE_SCHED_YIELD ) 389 sched_yield(); 390#elif defined( HAVE_PTHREAD_YIELD ) 391 pthread_yield(); 392#endif 393 394 exit(2); 395}]])],[ol_cv_pthread_select_yields=no],[ol_cv_pthread_select_yields=yes],[ol_cv_pthread_select_yields=cross])]) 396 397 if test $ol_cv_pthread_select_yields = cross ; then 398 AC_MSG_ERROR([crossing compiling: use --with-yielding-select=yes|no|manual]) 399 fi 400 401 if test $ol_cv_pthread_select_yields = yes ; then 402 ol_with_yielding_select=yes 403 fi 404 fi 405 406 dnl restore flags 407 CPPFLAGS="$save_CPPFLAGS" 408 LIBS="$save_LIBS" 409 else 410 AC_MSG_ERROR([could not locate usable POSIX Threads]) 411 fi 412 fi 413 414 if test $ol_with_threads = posix ; then 415 AC_MSG_ERROR([could not locate POSIX Threads]) 416 fi 417 ;; 418esac 419 420case $ol_with_threads in auto | yes | mach) 421 422 dnl check for Mach CThreads 423 AC_CHECK_HEADERS(mach/cthreads.h cthreads.h) 424 if test $ac_cv_header_mach_cthreads_h = yes ; then 425 ol_with_threads=found 426 427 dnl check for cthreads support in current $LIBS 428 AC_CHECK_FUNC(cthread_fork,[ol_link_threads=yes]) 429 430 if test $ol_link_threads = no ; then 431 dnl try -all_load 432 dnl this test needs work 433 AC_CACHE_CHECK([for cthread_fork with -all_load], 434 [ol_cv_cthread_all_load], [ 435 dnl save the flags 436 save_LIBS="$LIBS" 437 LIBS="-all_load $LIBS" 438 AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include <mach/cthreads.h>]], [[ 439 cthread_fork((void *)0, (void *)0); 440 ]])],[ol_cv_cthread_all_load=yes],[ol_cv_cthread_all_load=no]) 441 dnl restore the LIBS 442 LIBS="$save_LIBS" 443 ]) 444 445 if test $ol_cv_cthread_all_load = yes ; then 446 LTHREAD_LIBS="$LTHREAD_LIBS -all_load" 447 ol_link_threads=mach 448 ol_with_threads=found 449 fi 450 fi 451 452 elif test $ac_cv_header_cthreads_h = yes ; then 453 dnl Hurd variant of Mach Cthreads 454 dnl uses <cthreads.h> and -lthreads 455 456 ol_with_threads=found 457 458 dnl save the flags 459 save_LIBS="$LIBS" 460 LIBS="$LIBS -lthreads" 461 AC_CHECK_FUNC(cthread_fork,[ol_link_threads=yes]) 462 LIBS="$save_LIBS" 463 464 if test $ol_link_threads = yes ; then 465 LTHREAD_LIBS="-lthreads" 466 ol_link_threads=mach 467 ol_with_threads=found 468 else 469 AC_MSG_ERROR([could not link with Mach CThreads]) 470 fi 471 472 elif test $ol_with_threads = mach ; then 473 AC_MSG_ERROR([could not locate Mach CThreads]) 474 fi 475 476 if test $ol_link_threads = mach ; then 477 AC_DEFINE([HAVE_MACH_CTHREADS], [1], 478 [define if you have Mach Cthreads]) 479 elif test $ol_with_threads = found ; then 480 AC_MSG_ERROR([could not link with Mach CThreads]) 481 fi 482 ;; 483esac 484 485case $ol_with_threads in auto | yes | pth) 486 487 AC_CHECK_HEADERS(pth.h) 488 489 if test $ac_cv_header_pth_h = yes ; then 490 AC_CHECK_LIB(pth, pth_version, [have_pth=yes], [have_pth=no]) 491 492 if test $have_pth = yes ; then 493 AC_DEFINE([HAVE_GNU_PTH], [1], [if you have GNU Pth]) 494 LTHREAD_LIBS="$LTHREAD_LIBS -lpth" 495 ol_link_threads=pth 496 ol_with_threads=found 497 498 if test x$ol_with_yielding_select = xauto ; then 499 ol_with_yielding_select=yes 500 fi 501 fi 502 fi 503 ;; 504esac 505 506case $ol_with_threads in auto | yes | lwp) 507 508 dnl check for SunOS5 LWP 509 AC_CHECK_HEADERS(thread.h synch.h) 510 if test $ac_cv_header_thread_h = yes && 511 test $ac_cv_header_synch_h = yes ; then 512 AC_CHECK_LIB(thread, thr_create, [have_thr=yes], [have_thr=no]) 513 514 if test $have_thr = yes ; then 515 AC_DEFINE([HAVE_THR], [1], 516 [if you have Solaris LWP (thr) package]) 517 LTHREAD_LIBS="$LTHREAD_LIBS -lthread" 518 ol_link_threads=thr 519 520 if test x$ol_with_yielding_select = xauto ; then 521 ol_with_yielding_select=yes 522 fi 523 524 dnl Check for setconcurrency functions 525 AC_CHECK_FUNCS( \ 526 thr_setconcurrency \ 527 thr_getconcurrency \ 528 ) 529 fi 530 fi 531 532 dnl check for SunOS4 LWP 533 AC_CHECK_HEADERS(lwp/lwp.h) 534 if test $ac_cv_header_lwp_lwp_h = yes ; then 535 AC_CHECK_LIB(lwp, lwp_create, [have_lwp=yes], [have_lwp=no]) 536 537 if test $have_lwp = yes ; then 538 AC_DEFINE([HAVE_LWP], [1], 539 [if you have SunOS LWP package]) 540 LTHREAD_LIBS="$LTHREAD_LIBS -llwp" 541 ol_link_threads=lwp 542 543 if test x$ol_with_yielding_select = xauto ; then 544 ol_with_yielding_select=no 545 fi 546 fi 547 fi 548 ;; 549esac 550 551if test $ol_with_yielding_select = yes ; then 552 AC_DEFINE([HAVE_YIELDING_SELECT], [1], 553 [define if select implicitly yields]) 554fi 555 556if test $ol_with_threads = manual ; then 557 dnl User thinks he can manually configure threads. 558 ol_link_threads=yes 559 560 AC_MSG_WARN([thread defines and link options must be set manually]) 561 562 AC_CHECK_HEADERS(pthread.h sched.h) 563 AC_CHECK_FUNCS(sched_yield pthread_yield) 564 OL_HEADER_LINUX_THREADS 565 566 AC_CHECK_HEADERS(mach/cthreads.h) 567 AC_CHECK_HEADERS(lwp/lwp.h) 568 AC_CHECK_HEADERS(thread.h synch.h) 569fi 570 571if test $ol_link_threads != no && test $ol_link_threads != nt ; then 572 dnl needed to get reentrant/threadsafe versions 573 dnl 574 AC_DEFINE([REENTRANT], [1], [enable thread safety]) 575 AC_DEFINE([_REENTRANT], [1], [enable thread safety]) 576 AC_DEFINE([THREAD_SAFE], [1], [enable thread safety]) 577 AC_DEFINE([_THREAD_SAFE], [1], [enable thread safety]) 578 AC_DEFINE([THREADSAFE], [1], [enable thread safety]) 579 AC_DEFINE([_THREADSAFE], [1], [enable thread safety]) 580 AC_DEFINE([_SGI_MP_SOURCE], [1], [enable thread safety]) 581 582 dnl The errno declaration may dependent upon _REENTRANT. 583 dnl If it does, we must link with thread support. 584 AC_CACHE_CHECK([for thread specific errno], 585 [ol_cv_errno_thread_specific], [ 586 AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include <errno.h>]], [[errno = 0;]])],[ol_cv_errno_thread_specific=yes],[ol_cv_errno_thread_specific=no]) 587 ]) 588 589 dnl The h_errno declaration may dependent upon _REENTRANT. 590 dnl If it does, we must link with thread support. 591 AC_CACHE_CHECK([for thread specific h_errno], 592 [ol_cv_h_errno_thread_specific], [ 593 AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include <netdb.h>]], [[h_errno = 0;]])],[ol_cv_h_errno_thread_specific=yes],[ol_cv_h_errno_thread_specific=no]) 594 ]) 595 596 if test $ol_cv_errno_thread_specific != yes || 597 test $ol_cv_h_errno_thread_specific != yes ; then 598 LIBS="$LTHREAD_LIBS $LIBS" 599 LTHREAD_LIBS="" 600 fi 601 602dnl When in thread environment, use 603dnl #if defined( HAVE_REENTRANT_FUNCTIONS ) || defined( HAVE_FUNC_R ) 604dnl func_r(...); 605dnl #else 606dnl # if defined( HAVE_THREADS ) 607dnl /* lock */ 608dnl # endif 609dnl func(...); 610dnl # if defined( HAVE_THREADS ) 611dnl /* unlock */ 612dnl # endif 613dnl #endif 614dnl 615dnl HAVE_REENTRANT_FUNCTIONS is derived from: 616dnl _POSIX_REENTRANT_FUNCTIONS 617dnl _POSIX_THREAD_SAFE_FUNCTIONS 618dnl _POSIX_THREADSAFE_FUNCTIONS 619dnl 620dnl and is currently defined in <ldap_pvt_thread.h> 621dnl 622dnl HAVE_THREADS is defined by <ldap_pvt_thread.h> iff -UNO_THREADS 623dnl 624dnl libldap/*.c should only include <ldap_pvt_thread.h> iff 625dnl LDAP_R_COMPILE is defined. ie: 626dnl #ifdef LDAP_R_COMPILE 627dnl # include <ldap_pvt_thread.h> 628dnl #endif 629dnl 630dnl LDAP_R_COMPILE is defined by libldap_r/Makefile.in 631dnl specifically for compiling the threadsafe version of 632dnl the ldap library (-lldap_r). 633dnl 634dnl dnl check for reentrant/threadsafe functions 635dnl dnl 636dnl dnl note: these should only be used when linking 637dnl dnl with $LTHREAD_LIBS 638dnl dnl 639dnl save_CPPFLAGS="$CPPFLAGS" 640dnl save_LIBS="$LIBS" 641dnl LIBS="$LTHREAD_LIBS $LIBS" 642dnl AC_CHECK_FUNCS( \ 643dnl gmtime_r \ 644dnl gethostbyaddr_r gethostbyname_r \ 645dnl feof_unlocked unlocked_feof \ 646dnl putc_unlocked unlocked_putc \ 647dnl flockfile ftrylockfile \ 648dnl ) 649dnl CPPFLAGS="$save_CPPFLAGS" 650dnl LIBS="$save_LIBS" 651fi 652 653if test $ol_link_threads = no ; then 654 if test $ol_with_threads = yes ; then 655 AC_MSG_ERROR([no suitable thread support]) 656 fi 657 658 if test $ol_with_threads = auto ; then 659 AC_MSG_WARN([no suitable thread support, disabling threads]) 660 ol_with_threads=no 661 fi 662 663 AC_DEFINE([NO_THREADS], [1], 664 [define if you have (or want) no threads]) 665 LTHREAD_LIBS="" 666 BUILD_THREAD=no 667else 668 BUILD_THREAD=yes 669fi 670 671if test $ol_link_threads != no ; then 672 AC_DEFINE([LDAP_API_FEATURE_X_OPENLDAP_THREAD_SAFE], [1], 673 [define to 1 if library is thread safe]) 674fi 675 676# Finally, execute ACTION-IF-FOUND/ACTION-IF-NOT-FOUND: 677case "$ol_with_threads" in 678 no) 679 ol_pthread_ok=no 680 $2 681 ;; 682 *) 683 ifelse([$1],,AC_DEFINE(HAVE_PTHREAD,1,[Define if you have POSIX threads libraries and header files.]),[$1]) 684 ;; 685esac 686 687AC_LANG_RESTORE 688 689AC_SUBST(BUILD_THREAD) 690AC_SUBST(LTHREAD_LIBS) 691 692]) 693