+2004-04-22 Gary V. Vaughan <gary@gnu.org>
+
+ According to Howard Chu <hyc@highlandsun.com>:
+ Applications should assume that the native dlopen is NOT
+ thread-safe, and take care of locking themselves. All application
+ calls into libltdl should thus be protected by the caller.
+
+ * libltdl/lt_mutex.c, libltdl/lt_mutex.h: Removed.
+ * libltdl/Makefile.am (pkginclude_HEADERS): Removed lt_mutex.h.
+ (libltdl_la_SOURCES): Removed lt_mutex.c and lt_mutex.h.
+ * libltdl/ltdl.h: Don't include lt_mutex.h.
+ * libltdl/lt__private.h (LT__MUTEX_GETERROR, LT__MUTEX_SETERROR)
+ (LT__MUTEX_SETERRORSTR): Renamed to...
+ (LT__GETERROR, LT__SETERROR, LT__SETERRORSTR): ...this. Changed
+ all callers.
+ (LT__MUTEX_LOCK, LT__MUTEX_UNLOCK, lt_dlmutex_lock)
+ (lt_dlmutex_unlock, lt_dlmutex_seterror, lt_dlmutex_geterror):
+ Removed. Changed all callers.
+ * doc/libtool.texi (Thread Saftey in libltdl):
+ * NEWS: Updated.
+
2004-04-19 Gary V. Vaughan <gary@gnu.org>
* m4/libtool.m4 (_LT_LANG_CXX_CONFIG): Detect Intel C++ compiler
* libltdl no longer loads shared libraries with global symbol resolution,
this caused problems when the symbols were intended to be overriden further
up the stack; it is also not recommended practice.
+* libltdl no longer tries to support multi-threaded programming with
+ lt_dlmutex_register(), which was unusable with POSIX threads anyway.
+ The symbols are deprecated but exported for backwards compatibility.
* libltdl no longer uses lt_dlmalloc, lt_dlrealloc and lt_dlfree. The symbols
are still exported for backwards compatibility.
* libltdl no longer supports pre-c89 compilers. Some of the pre89 portability
# Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
# 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
-timestamp='2003-10-20'
+timestamp='2004-01-05'
# This file is free software; you can redistribute it and/or modify it
# under the terms of the GNU General Public License as published by
*:QNX:*:4*)
echo i386-pc-qnx
exit 0 ;;
- NSR-[DGKLNPTVWY]:NONSTOP_KERNEL:*:*)
+ NSR-?:NONSTOP_KERNEL:*:*)
echo nsr-tandem-nsk${UNAME_RELEASE}
exit 0 ;;
*:NonStop-UX:*:*)
# Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
# 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
-timestamp='2003-11-20'
+timestamp='2004-01-05'
# This file is (in principle) common to ALL GNU software.
# The presence of a machine in this file suggests that SOME GNU software
amd64)
basic_machine=x86_64-pc
;;
+ amd64-*)
+ basic_machine=x86_64-`echo $basic_machine | sed 's/^[^-]*-//'`
+ ;;
amdahl)
basic_machine=580-amdahl
os=-sysv
@node Thread Saftey in libltdl
@section Using libtldl in a multi threaded environment
-Using the @code{lt_dlmutex_register()} function, and by providing some
-appropriate callback function definitions, libltdl can be used in a
-multi-threaded environment.
-
-@deftypefn {Type} void lt_dlmutex_lock (void)
-This is the type of a function pointer holding the address of a function
-which will be called at the start of parts of the libltdl implementation
-code which require a mutex lock.
-
-Because libltdl is inherantly recursive, it is important that the
-locking mechanism employed by these callback functions are reentrant, or
-else strange problems will occur.
-@end deftypefn
-
-@deftypefn {Type} void lt_dlmutex_unlock (void)
-The type of a matching unlock function.
-@end deftypefn
-
-@deftypefn {Type} void lt_dlmutex_seterror @w{(const char *@var{error});}
-Many of the functions in the libltdl @sc{api} have a special return
-value to indicate to the client that an error has occured. Normally (in
-single threaded applications) a string describing that error can be
-retrieved from internal storage with @code{lt_dlerror()}.
-
-A function of this type must be registered with the library in order for
-it to work in a multi-threaded context. The function should store any
-error message passed in thread local storage.
-@end deftypefn
-
-@deftypefn {Type} {const char *} lt_dlmutex_geterror (void)
-The type of a matching callback function to retrieve the last stored
-error message from thread local storage.
-
-When registered correctly this function will be used by
-@code{lt_dlerror())} from all threads to retrieve error messages for the
-client.
-@end deftypefn
-
-@deftypefn {Function} int lt_dlmutex_register (@w{lt_dlmutex_lock *@var{lock}}, @w{lt_dlmutex_unlock *@var{unlock}}, @w{lt_dlmutex_set_error *@var{seterror}}, @w{lt_dlmutex_geterror *@var{geterror})}
-Use this function to register one of each of function types described
-above in preparation for multi-threaded use of libltdl. All arguments
-must be valid non-@code{NULL} function addresses, or else all
-@code{NULL} to return to single threaded operation.
-@end deftypefn
-
+Libltdl provides a wrapper around whatever dynamic run-time object
+loading mechanisms are provided by the host system, many of which are
+themselves not thread safe. Consequently libltdl cannot itself be
+consistently thread safe.
+
+If you wish to use libltdl in a multithreaded environment, then you
+must mutex lock around libltdl calls, since they may in turn be calling
+non-thread-safe system calls on some target hosts.
+
+Some old releases of libtool provided a mutex locking API that was
+unusable with POSIX threads, so callers were forced to lock around all
+libltdl API calls anyway. That mutex locking API was next to useless,
+and is not present in current releases.
+
+Some future release of libtool may provide a new POSIX thread
+compliant mutex locking API.
@node User defined module data
@section Data associated with loaded modules
if INSTALL_LTDL
include_HEADERS = ltdl.h
-pkginclude_HEADERS = lt_system.h lt_error.h lt_mutex.h
+pkginclude_HEADERS = lt_system.h lt_error.h
lib_LTLIBRARIES = libltdl.la
endif
libltdl_la_SOURCES = ltdl.h ltdl.c \
loader-preopen.c \
- lt_error.h lt_error.c lt_mutex.h lt_mutex.c \
+ lt_error.h lt_error.c \
lt__private.h lt__alloc.h lt__alloc.c \
lt__glibc.h argz.h lt__dirent.h \
lt_system.h
if (dld_link (filename) != 0)
{
- LT__MUTEX_SETERROR (CANNOT_OPEN);
+ LT__SETERROR (CANNOT_OPEN);
FREE (module);
}
if (dld_unlink_by_file ((char*)(module), 1) != 0)
{
- LT__MUTEX_SETERROR (CANNOT_CLOSE);
+ LT__SETERROR (CANNOT_CLOSE);
++errors;
}
else
if (!address)
{
- LT__MUTEX_SETERROR (SYMBOL_NOT_FOUND);
+ LT__SETERROR (SYMBOL_NOT_FOUND);
}
return address;
# define DLERROR(arg) LT__STRERROR (arg)
#endif
-#define DL__MUTEX_SETERROR(errorcode) \
- LT__MUTEX_SETERRORSTR (DLERROR (errorcode))
+#define DL__SETERROR(errorcode) \
+ LT__SETERRORSTR (DLERROR (errorcode))
static lt_module
sys_dl_open (lt_user_data loader_data, const char *filename)
if (!module)
{
- DL__MUTEX_SETERROR (CANNOT_OPEN);
+ DL__SETERROR (CANNOT_OPEN);
}
return module;
if (dlclose (module) != 0)
{
- DL__MUTEX_SETERROR (CANNOT_CLOSE);
+ DL__SETERROR (CANNOT_CLOSE);
++errors;
}
if (!address)
{
- DL__MUTEX_SETERROR (SYMBOL_NOT_FOUND);
+ DL__SETERROR (SYMBOL_NOT_FOUND);
}
return address;
# define LT__MAGIC MH_CIGAM
#endif
-#define DYLD__MUTEX_SETERROR(errorcode) \
- LT__MUTEX_SETERRORSTR (lt__dylderror (errorcode))
+#define DYLD__SETERROR(errorcode) \
+ LT__SETERRORSTR (lt__dylderror (errorcode))
/* Return the dyld error string, or the passed in error string if none. */
static const char *
{
int errors = 0;
- LT__MUTEX_LOCK ();
-
if (! dyld_cannot_close)
{
if (!_dyld_present ())
}
}
- LT__MUTEX_UNLOCK ();
-
return errors;
}
if (!module)
{
- DYLD__MUTEX_SETERROR (LT_ERROR_CANNOT_OPEN);
+ DYLD__SETERROR (LT_ERROR_CANNOT_OPEN);
}
return module;
int flags = 0;
if (mh->magic == LT__MAGIC)
{
- DYLD__MUTEX_SETERROR(dyld_cannot_close);
+ DYLD__SETERROR(dyld_cannot_close);
++errors;
}
else
#endif
if (!NSUnLinkModule (module, flags))
{
- DYLD__MUTEX_SETERROR (LT_ERROR_CANNOT_CLOSE);
+ DYLD__SETERROR (LT_ERROR_CANNOT_CLOSE);
++errors;
}
}
if (!nssym)
{
- LT__MUTEX_SETERRORSTR (saveError);
+ LT__SETERRORSTR (saveError);
}
return nssym ? NSAddressOfSymbol (nssym) : 0;
if (image <= 0)
{
- LT__MUTEX_SETERROR (CANNOT_OPEN);
+ LT__SETERROR (CANNOT_OPEN);
image = 0;
}
if (unload_add_on ((image_id) module) != B_OK)
{
- LT__MUTEX_SETERROR (CANNOT_CLOSE);
+ LT__SETERROR (CANNOT_CLOSE);
++errors;
}
if (get_image_symbol (image, symbol, B_SYMBOL_TYPE_ANY, address) != B_OK)
{
- LT__MUTEX_SETERROR (SYMBOL_NOT_FOUND);
+ LT__SETERROR (SYMBOL_NOT_FOUND);
address = 0;
}
We check whether LoadLibrary is returning a handle to
an already loaded module, and simulate failure if we
find one. */
- LT__MUTEX_LOCK ();
cur = handles;
while (cur)
{
cur = cur->next;
}
- LT__MUTEX_UNLOCK ();
if (cur || !module)
{
- LT__MUTEX_SETERROR (CANNOT_OPEN);
+ LT__SETERROR (CANNOT_OPEN);
module = 0;
}
if (FreeLibrary(module) == 0)
{
- LT__MUTEX_SETERROR (CANNOT_CLOSE);
+ LT__SETERROR (CANNOT_CLOSE);
++errors;
}
if (!address)
{
- LT__MUTEX_SETERROR (SYMBOL_NOT_FOUND);
+ LT__SETERROR (SYMBOL_NOT_FOUND);
}
return address;
{
int errors = 0;
- LT__MUTEX_LOCK ();
-
preloaded_symbols = 0;
if (default_preloaded_symbols)
{
errors = lt_dlpreload (default_preloaded_symbols);
}
- LT__MUTEX_UNLOCK ();
-
return errors;
}
{
lt_dlsymlists_t *lists;
- LT__MUTEX_LOCK ();
-
lists = preloaded_symbols;
while (lists)
{
}
preloaded_symbols = 0;
- LT__MUTEX_UNLOCK ();
-
return 0;
}
lt_dlsymlists_t *lists;
int errors = 0;
- LT__MUTEX_LOCK ();
-
lists = preloaded_symbols;
while (lists)
{
}
done:
- LT__MUTEX_UNLOCK ();
return errors;
}
lt_dlsymlists_t *lists;
lt_module module = (lt_module) 0;
- LT__MUTEX_LOCK ();
lists = preloaded_symbols;
if (!lists)
{
- LT__MUTEX_SETERROR (NO_SYMBOLS);
+ LT__SETERROR (NO_SYMBOLS);
goto done;
}
lists = lists->next;
}
- LT__MUTEX_SETERROR (FILE_NOT_FOUND);
+ LT__SETERROR (FILE_NOT_FOUND);
done:
- LT__MUTEX_UNLOCK ();
return module;
}
++syms;
}
- LT__MUTEX_SETERROR (SYMBOL_NOT_FOUND);
+ LT__SETERROR (SYMBOL_NOT_FOUND);
return 0;
}
{
presym_free_symlists();
- LT__MUTEX_LOCK ();
if (default_preloaded_symbols)
{
errors = lt_dlpreload (default_preloaded_symbols);
}
- LT__MUTEX_UNLOCK ();
}
return errors;
int
lt_dlpreload_default (const lt_dlsymlist *preloaded)
{
- LT__MUTEX_LOCK ();
default_preloaded_symbols = preloaded;
- LT__MUTEX_UNLOCK ();
return 0;
}
if (!module)
{
- LT__MUTEX_SETERROR (CANNOT_OPEN);
+ LT__SETERROR (CANNOT_OPEN);
}
}
if (module && (shl_unload ((shl_t) (module)) != 0))
{
- LT__MUTEX_SETERROR (CANNOT_CLOSE);
+ LT__SETERROR (CANNOT_CLOSE);
++errors;
}
/* sys_shl_open should never return a NULL module handle */
if (module == (lt_module) 0)
{
- LT__MUTEX_SETERROR (INVALID_HANDLE);
+ LT__SETERROR (INVALID_HANDLE);
}
else if (!shl_findsym((shl_t*) &module, symbol, TYPE_UNDEFINED, &address))
{
if (!address)
{
- LT__MUTEX_SETERROR (SYMBOL_NOT_FOUND);
+ LT__SETERROR (SYMBOL_NOT_FOUND);
}
}
#define LT__STRERROR(name) lt__error_strings[LT_CONC(LT_ERROR_,name)]
+#define LT__GETERROR(lvalue) (lvalue) = lt__last_error;
+#define LT__SETERRORSTR(errormsg) lt__last_error = (errormsg)
+#define LT__SETERROR(errorcode) LT__SETERRORSTR(LT__STRERROR(errorcode))
-
-/* --- MUTEX LOCKING --- */
-
-/* Macros to make it easier to run the lock functions only if they have
- been registered. The reason for the complicated lock macro is to
- ensure that the stored error message from the last error is not
- accidentally erased if the current function doesn't generate an
- error of its own. */
-
-#define LT__MUTEX_LOCK() LT_STMT_START { \
- if (lt__mutex_lock_func) (*lt__mutex_lock_func)(); \
- } LT_STMT_END
-#define LT__MUTEX_UNLOCK() LT_STMT_START { \
- if (lt__mutex_unlock_func) (*lt__mutex_unlock_func)();\
- } LT_STMT_END
-#define LT__MUTEX_SETERRORSTR(errormsg) LT_STMT_START { \
- if (lt__mutex_seterror_func) \
- (*lt__mutex_seterror_func) (errormsg); \
- else lt__last_error = (errormsg); } LT_STMT_END
-#define LT__MUTEX_GETERROR(errormsg) LT_STMT_START { \
- if (lt__mutex_seterror_func) \
- (errormsg) = (*lt__mutex_geterror_func) (); \
- else (errormsg) = lt__last_error; } LT_STMT_END
-#define LT__MUTEX_SETERROR(errorcode) \
- LT__MUTEX_SETERRORSTR(LT__STRERROR(errorcode))
-
-/* The mutex functions stored here are global, and are necessarily the
- same for all threads that wish to share access to libltdl. */
-LT_SCOPE lt_dlmutex_lock *lt__mutex_lock_func;
-LT_SCOPE lt_dlmutex_unlock *lt__mutex_unlock_func;
-LT_SCOPE lt_dlmutex_seterror *lt__mutex_seterror_func;
-LT_SCOPE lt_dlmutex_geterror *lt__mutex_geterror_func;
LT_SCOPE const char *lt__last_error;
LT_END_C_DECLS
*/
#include "lt_error.h"
-#include "lt_mutex.h"
#include "lt__private.h"
+LT_GLOBAL_DATA const char *lt__last_error = 0;
+
static const char **user_error_strings = 0;
static int errorcount = LT_ERROR_MAX;
assert (diagnostic);
- LT__MUTEX_LOCK ();
-
errindex = errorcount - LT_ERROR_MAX;
temp = REALLOC (const char *, user_error_strings, 1 + errindex);
if (temp)
result = errorcount++;
}
- LT__MUTEX_UNLOCK ();
-
return result;
}
{
int errors = 0;
- LT__MUTEX_LOCK ();
-
if (errindex >= errorcount || errindex < 0)
{
/* Ack! Error setting the error message! */
- LT__MUTEX_SETERROR (INVALID_ERRORCODE);
+ LT__SETERROR (INVALID_ERRORCODE);
++errors;
}
else if (errindex < LT_ERROR_MAX)
{
/* No error setting the error message! */
- LT__MUTEX_SETERRORSTR (lt__error_strings[errindex]);
+ LT__SETERRORSTR (lt__error_strings[errindex]);
}
else
{
/* No error setting the error message! */
- LT__MUTEX_SETERRORSTR (user_error_strings[errindex - LT_ERROR_MAX]);
+ LT__SETERRORSTR (user_error_strings[errindex - LT_ERROR_MAX]);
}
- LT__MUTEX_UNLOCK ();
-
return errors;
}
LT_ERROR(INVALID_ERRORCODE, "invalid errorcode") \
LT_ERROR(SHUTDOWN, "library already shutdown") \
LT_ERROR(CLOSE_RESIDENT_MODULE, "can't close resident module") \
- LT_ERROR(INVALID_MUTEX_ARGS, "invalid mutex handler registration") \
+ LT_ERROR(INVALID_MUTEX_ARGS, "internal error (code withdrawn)") \
LT_ERROR(INVALID_POSITION, "invalid search path insert position")
/* Enumerate the symbolic error names. */
void
lt__alloc_die_callback (void)
{
- LT__MUTEX_SETERROR (NO_MEMORY);
+ LT__SETERROR (NO_MEMORY);
}
/* Initialize libltdl. */
{
int errors = 0;
- LT__MUTEX_LOCK ();
-
/* Initialize only at first call. */
if (++initialized == 1)
{
if (lt__presym_init (lt__presym.dlloader_data))
{
- LT__MUTEX_SETERROR (INIT_LOADER);
+ LT__SETERROR (INIT_LOADER);
++errors;
}
else if (errors != 0)
{
- LT__MUTEX_SETERROR (DLOPEN_NOT_SUPPORTED);
+ LT__SETERROR (DLOPEN_NOT_SUPPORTED);
++errors;
}
}
- LT__MUTEX_UNLOCK ();
-
return errors;
}
lt_dlloader *loader;
int errors = 0;
- LT__MUTEX_LOCK ();
loader = loaders;
if (!initialized)
{
- LT__MUTEX_SETERROR (SHUTDOWN);
+ LT__SETERROR (SHUTDOWN);
++errors;
goto done;
}
}
done:
- LT__MUTEX_UNLOCK ();
return errors;
}
const char *saved_error;
int errors = 0;
- LT__MUTEX_GETERROR (saved_error);
- LT__MUTEX_LOCK ();
+ LT__GETERROR (saved_error);
cur = handles;
loader = loaders;
file_not_found() can detect what happened.
if (access (filename, R_OK) != 0)
{
- LT__MUTEX_SETERROR (FILE_NOT_FOUND);
+ LT__SETERROR (FILE_NOT_FOUND);
++errors;
goto done;
} */
}
cur->loader = loader;
- LT__MUTEX_SETERRORSTR (saved_error);
+ LT__SETERRORSTR (saved_error);
done:
- LT__MUTEX_UNLOCK ();
-
return errors;
}
switch (error)
{
case ENOMEM:
- LT__MUTEX_SETERROR (NO_MEMORY);
+ LT__SETERROR (NO_MEMORY);
break;
default:
- LT__MUTEX_SETERROR (UNKNOWN);
+ LT__SETERROR (UNKNOWN);
break;
}
char *filename = 0;
char *canonical = 0;
- LT__MUTEX_LOCK ();
-
if (!search_path || !*search_path)
{
- LT__MUTEX_SETERROR (FILE_NOT_FOUND);
+ LT__SETERROR (FILE_NOT_FOUND);
goto cleanup;
}
FREE (canonical);
FREE (filename);
- LT__MUTEX_UNLOCK ();
-
return result;
}
}
++errors;
- LT__MUTEX_LOCK ();
if (user_search_path)
{
save_search_path = lt__strdup (user_search_path);
/* restore the old search path */
MEMREASSIGN (user_search_path, save_search_path);
- LT__MUTEX_UNLOCK ();
-
if (!depcount)
{
errors = 0;
assert (phandle);
assert (*phandle == 0);
- LT__MUTEX_GETERROR (saved_error);
+ LT__GETERROR (saved_error);
/* dlopen self? */
if (!filename)
{
const char *search_path;
- LT__MUTEX_LOCK ();
search_path = user_search_path;
if (search_path)
file = find_file (user_search_path, base_name, &dir);
- LT__MUTEX_UNLOCK ();
if (!file)
{
the status flag, and bail out. */
if (!file)
{
- LT__MUTEX_SETERROR (FILE_NOT_FOUND);
+ LT__SETERROR (FILE_NOT_FOUND);
++errors;
goto cleanup;
}
(*phandle)->info.ref_count = 1;
MEMREASSIGN ((*phandle)->info.name, name);
- LT__MUTEX_LOCK ();
(*phandle)->next = handles;
handles = *phandle;
- LT__MUTEX_UNLOCK ();
}
- LT__MUTEX_SETERRORSTR (saved_error);
+ LT__SETERRORSTR (saved_error);
cleanup:
FREE (dir);
{
const char *error = 0;
- LT__MUTEX_GETERROR (error);
+ LT__GETERROR (error);
if (error == LT__STRERROR (FILE_NOT_FOUND))
return 1;
/* Still here? Then we really did fail to locate any of the file
names we tried. */
- LT__MUTEX_SETERROR (FILE_NOT_FOUND);
+ LT__SETERROR (FILE_NOT_FOUND);
FREE (tmp);
return 0;
}
switch (error)
{
case ENOMEM:
- LT__MUTEX_SETERROR (NO_MEMORY);
+ LT__SETERROR (NO_MEMORY);
break;
default:
- LT__MUTEX_SETERROR (UNKNOWN);
+ LT__SETERROR (UNKNOWN);
break;
}
return 1;
lt_dlhandle cur, last;
int errors = 0;
- LT__MUTEX_LOCK ();
-
/* check whether the handle is valid */
last = cur = handles;
while (cur && handle != cur)
if (!cur)
{
- LT__MUTEX_SETERROR (INVALID_HANDLE);
+ LT__SETERROR (INVALID_HANDLE);
++errors;
goto done;
}
if (LT_DLIS_RESIDENT (handle))
{
- LT__MUTEX_SETERROR (CLOSE_RESIDENT_MODULE);
+ LT__SETERROR (CLOSE_RESIDENT_MODULE);
++errors;
}
done:
- LT__MUTEX_UNLOCK ();
-
return errors;
}
if (!handle)
{
- LT__MUTEX_SETERROR (INVALID_HANDLE);
+ LT__SETERROR (INVALID_HANDLE);
return 0;
}
if (!symbol)
{
- LT__MUTEX_SETERROR (SYMBOL_NOT_FOUND);
+ LT__SETERROR (SYMBOL_NOT_FOUND);
return 0;
}
sym = MALLOC (char, lensym + LT_SYMBOL_OVERHEAD + 1);
if (!sym)
{
- LT__MUTEX_SETERROR (BUFFER_OVERFLOW);
+ LT__SETERROR (BUFFER_OVERFLOW);
return 0;
}
}
{
const char *saved_error;
- LT__MUTEX_GETERROR (saved_error);
+ LT__GETERROR (saved_error);
/* this is a libtool module */
if (handle->loader->sym_prefix)
}
return address;
}
- LT__MUTEX_SETERRORSTR (saved_error);
+ LT__SETERRORSTR (saved_error);
}
/* otherwise try "symbol" */
{
const char *error;
- LT__MUTEX_GETERROR (error);
- LT__MUTEX_SETERRORSTR (0);
+ LT__GETERROR (error);
+ LT__SETERRORSTR (0);
return error ? error : NULL;
}
if (search_dir && *search_dir)
{
- LT__MUTEX_LOCK ();
if (lt_dlpath_insertdir (&user_search_path, 0, search_dir) != 0)
++errors;
- LT__MUTEX_UNLOCK ();
}
return errors;
if (before)
{
- LT__MUTEX_LOCK ();
if ((before < user_search_path)
|| (before >= user_search_path + LT_STRLEN (user_search_path)))
{
- LT__MUTEX_UNLOCK ();
- LT__MUTEX_SETERROR (INVALID_POSITION);
+ LT__SETERROR (INVALID_POSITION);
return 1;
}
- LT__MUTEX_UNLOCK ();
}
if (search_dir && *search_dir)
{
- LT__MUTEX_LOCK ();
if (lt_dlpath_insertdir (&user_search_path,
(char *) before, search_dir) != 0)
{
++errors;
}
- LT__MUTEX_UNLOCK ();
}
return errors;
{
int errors = 0;
- LT__MUTEX_LOCK ();
FREE (user_search_path);
- LT__MUTEX_UNLOCK ();
if (!search_path || !LT_STRLEN (search_path))
{
return errors;
}
- LT__MUTEX_LOCK ();
if (canonicalize_path (search_path, &user_search_path) != 0)
++errors;
- LT__MUTEX_UNLOCK ();
return errors;
}
{
const char *saved_path;
- LT__MUTEX_LOCK ();
saved_path = user_search_path;
- LT__MUTEX_UNLOCK ();
return saved_path;
}
if (!handle)
{
- LT__MUTEX_SETERROR (INVALID_HANDLE);
+ LT__SETERROR (INVALID_HANDLE);
++errors;
}
else
{
if (!handle)
{
- LT__MUTEX_SETERROR (INVALID_HANDLE);
+ LT__SETERROR (INVALID_HANDLE);
return -1;
}
{
if (!handle)
{
- LT__MUTEX_SETERROR (INVALID_HANDLE);
+ LT__SETERROR (INVALID_HANDLE);
return 0;
}
int errors = 0;
lt_dlhandle cur;
- LT__MUTEX_LOCK ();
-
cur = handles;
while (cur)
{
}
}
- LT__MUTEX_UNLOCK ();
-
return errors;
}
lt_dlcaller_register (void)
{
static lt_dlcaller_id last_caller_id = 0;
- int result;
-
- LT__MUTEX_LOCK ();
- result = ++last_caller_id;
- LT__MUTEX_UNLOCK ();
-
- return result;
+ return ++last_caller_id;
}
void *
void *stale = (void *) 0;
int i;
- /* This needs to be locked so that the caller data can be updated
- simultaneously by different threads. */
- LT__MUTEX_LOCK ();
-
if (handle->caller_data)
while (handle->caller_data[n_elements].key)
++n_elements;
handle->caller_data[i].data = data;
done:
- LT__MUTEX_UNLOCK ();
-
return stale;
}
{
void *result = (void *) 0;
- /* This needs to be locked so that the caller data isn't updated by
- another thread part way through this function. */
- LT__MUTEX_LOCK ();
-
/* Locate the index of the element with a matching KEY. */
{
int i;
}
}
- LT__MUTEX_UNLOCK ();
-
return result;
}
|| (dlloader->module_close == 0)
|| (dlloader->find_sym == 0))
{
- LT__MUTEX_SETERROR (INVALID_LOADER);
+ LT__SETERROR (INVALID_LOADER);
return 1;
}
node->find_sym = dlloader->find_sym;
node->dlloader_data = dlloader->dlloader_data;
- LT__MUTEX_LOCK ();
if (!loaders)
{
/* If there are no loaders, NODE becomes the list! */
if (ptr->next != place)
{
- LT__MUTEX_SETERROR (INVALID_LOADER);
+ LT__SETERROR (INVALID_LOADER);
++errors;
}
else
}
}
- LT__MUTEX_UNLOCK ();
-
return errors;
}
if (!place)
{
- LT__MUTEX_SETERROR (INVALID_LOADER);
+ LT__SETERROR (INVALID_LOADER);
return 1;
}
- LT__MUTEX_LOCK ();
-
/* Fail if there are any open modules which use this loader. */
for (handle = handles; handle; handle = handle->next)
{
if (handle->loader == place)
{
- LT__MUTEX_SETERROR (REMOVE_LOADER);
- ++errors;
- goto done;
+ LT__SETERROR (REMOVE_LOADER);
+ return ++errors;
}
}
FREE (place);
- done:
- LT__MUTEX_UNLOCK ();
-
return errors;
}
lt_dlloader *
lt_dlloader_next (lt_dlloader *place)
{
- lt_dlloader *next;
-
- LT__MUTEX_LOCK ();
- next = place ? place->next : loaders;
- LT__MUTEX_UNLOCK ();
-
- return next;
+ return place ? place->next : loaders;
}
const char *
if (place)
{
- LT__MUTEX_LOCK ();
name = place ? place->loader_name : 0;
- LT__MUTEX_UNLOCK ();
}
else
{
- LT__MUTEX_SETERROR (INVALID_LOADER);
+ LT__SETERROR (INVALID_LOADER);
}
return name;
if (place)
{
- LT__MUTEX_LOCK ();
data = place ? &(place->dlloader_data) : 0;
- LT__MUTEX_UNLOCK ();
}
else
{
- LT__MUTEX_SETERROR (INVALID_LOADER);
+ LT__SETERROR (INVALID_LOADER);
}
return data;
{
lt_dlloader *place = 0;
- LT__MUTEX_LOCK ();
for (place = loaders; place; place = place->next)
{
if (strcmp (place->loader_name, loader_name) == 0)
break;
}
}
- LT__MUTEX_UNLOCK ();
return place;
}
\f
-/* These pointers are part of the published interface to libltdl,
+/* These symbols are part of the published interface to libltdl,
although they are no longer used. */
LT_GLOBAL_DATA void *(*lt_dlmalloc) (size_t size) = 0;
LT_GLOBAL_DATA void *(*lt_dlrealloc) (void *ptr, size_t size) = 0;
LT_GLOBAL_DATA void (*lt_dlfree) (void *ptr) = 0;
+
+/*ARGSUSED*/
+int
+lt_dlmutex_register (lt_dlmutex_lock *lock, lt_dlmutex_unlock *unlock,
+ lt_dlmutex_seterror *seterror,
+ lt_dlmutex_geterror *geterror)
+{
+ static int warned = 0;
+
+ if (warned++ == 0)
+ {
+ fputs ("libltdl: WARNING: lt_dlmutex_register() is deprecated.\n"
+ "libltdl: WARNING: this version of libltdl is not thread safe.\n",
+ stderr);
+ }
+}
#include <libltdl/lt_system.h>
#include <libltdl/lt_error.h>
-#include <libltdl/lt_mutex.h>
LT_BEGIN_C_DECLS
\f
/* --- BINARY COMPATIBILITY WITH OLD LIBLTDL --- */
+typedef void lt_dlmutex_lock (void);
+typedef void lt_dlmutex_unlock (void);
+typedef void lt_dlmutex_seterror (const char *errmsg);
+typedef const char *lt_dlmutex_geterror (void);
+
LT_SCOPE void * (*lt_dlmalloc) (size_t size);
LT_SCOPE void * (*lt_dlrealloc) (void *ptr, size_t size);
LT_SCOPE void (*lt_dlfree) (void *ptr);
+
+LT_SCOPE int lt_dlmutex_register (lt_dlmutex_lock *lock,
+ lt_dlmutex_unlock *unlock,
+ lt_dlmutex_seterror *seterror,
+ lt_dlmutex_geterror *geterror);
+
# define lt_ptr void *
projects / thirdparty / libtool.git / commitdiff
