#ifdef HAVE_XORG_CONFIG_H
#include <xorg-config.h>
#endif
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#if defined(UseMMAP) || (defined(linux) && defined(__ia64__))
#include <sys/mman.h>
#endif
#include <unistd.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
#if defined(linux) && \
(defined(__alpha__) || defined(__powerpc__) || defined(__ia64__) \
|| defined(__amd64__))
#include <malloc.h>
#endif
#include <stdarg.h>
#include "os.h"
#include "loader.h"
#include "loaderProcs.h"
#include "xf86.h"
#include "xf86Priv.h"
#include "compiler.h"
#include "sym.h"
#define MAX_HANDLE 256
#define HANDLE_FREE 0
#define HANDLE_USED 1
static char freeHandles[MAX_HANDLE];
static int refCount[MAX_HANDLE];
static int moduleseq = 0;
static loaderPtr _LoaderListPush(void);
static loaderPtr _LoaderListPop(int);
void
LoaderInit(void)
{
const char *osname = NULL;
char *ld_bind_now = getenv("LD_BIND_NOW");
if (ld_bind_now && *ld_bind_now) {
xf86Msg(X_ERROR, "LD_BIND_NOW is set, dlloader will NOT work!\n");
}
xf86MsgVerb(X_INFO, 2, "Loader magic: %p\n", (void *)
((long)dixLookupTab ^ (long)extLookupTab
^ (long)miLookupTab ^ (long)xfree86LookupTab));
xf86MsgVerb(X_INFO, 2, "Module ABI versions:\n");
xf86ErrorFVerb(2, "\t%s: %d.%d\n", ABI_CLASS_ANSIC,
GET_ABI_MAJOR(LoaderVersionInfo.ansicVersion),
GET_ABI_MINOR(LoaderVersionInfo.ansicVersion));
xf86ErrorFVerb(2, "\t%s: %d.%d\n", ABI_CLASS_VIDEODRV,
GET_ABI_MAJOR(LoaderVersionInfo.videodrvVersion),
GET_ABI_MINOR(LoaderVersionInfo.videodrvVersion));
xf86ErrorFVerb(2, "\t%s : %d.%d\n", ABI_CLASS_XINPUT,
GET_ABI_MAJOR(LoaderVersionInfo.xinputVersion),
GET_ABI_MINOR(LoaderVersionInfo.xinputVersion));
xf86ErrorFVerb(2, "\t%s : %d.%d\n", ABI_CLASS_EXTENSION,
GET_ABI_MAJOR(LoaderVersionInfo.extensionVersion),
GET_ABI_MINOR(LoaderVersionInfo.extensionVersion));
LoaderGetOS(&osname, NULL, NULL, NULL);
if (osname)
xf86MsgVerb(X_INFO, 2, "Loader running on %s\n", osname);
#if defined(__UNIXWARE__) && !defined(__GNUC__)
{
int errmaj, errmin, wasLoaded;
char *xcrtpath = DEFAULT_MODULE_PATH "/libcrt.a";
char *uwcrtpath = "/usr/ccs/lib/libcrt.a";
char *path;
struct stat st;
if(stat(xcrtpath, &st) < 0)
path = uwcrtpath;
else
path = xcrtpath;
LoaderOpen (path, "libcrt", 0, &errmaj, &errmin, &wasLoaded);
}
#endif
}
static loaderPtr listHead = (loaderPtr) 0;
static loaderPtr
_LoaderListPush()
{
loaderPtr item = calloc(1, sizeof(struct _loader));
item->next = listHead;
listHead = item;
return item;
}
static loaderPtr
_LoaderListPop(int handle)
{
loaderPtr item = listHead;
loaderPtr *bptr = &listHead;
while (item) {
if (item->handle == handle) {
*bptr = item->next;
return item;
}
bptr = &(item->next);
item = item->next;
}
return 0;
}
_X_EXPORT void
LoaderRefSymbols(const char *sym0, ...)
{
}
_X_EXPORT void
LoaderRefSymLists(const char **list0, ...)
{
}
_X_EXPORT void
LoaderReqSymLists(const char **list0, ...)
{
}
_X_EXPORT void
LoaderReqSymbols(const char *sym0, ...)
{
}
int
LoaderOpen(const char *module, const char *cname, int handle,
int *errmaj, int *errmin, int *wasLoaded, int flags)
{
loaderPtr tmp;
int new_handle;
#if defined(DEBUG)
ErrorF("LoaderOpen(%s)\n", module);
#endif
if (handle >= 0) {
tmp = listHead;
while (tmp) {
#ifdef DEBUGLIST
ErrorF("strcmp(%x(%s),{%x} %x(%s))\n", module, module,
&(tmp->name), tmp->name, tmp->name);
#endif
if (!strcmp(module, tmp->name)) {
refCount[tmp->handle]++;
if (wasLoaded)
*wasLoaded = 1;
xf86MsgVerb(X_INFO, 2, "Reloading %s\n", module);
return tmp->handle;
}
tmp = tmp->next;
}
}
xf86Msg(X_INFO, "Loading %s\n", module);
if (wasLoaded)
*wasLoaded = 0;
new_handle = 1;
while (new_handle < MAX_HANDLE && freeHandles[new_handle])
new_handle++;
if (new_handle == MAX_HANDLE) {
xf86Msg(X_ERROR, "Out of loader space\n");
if (errmaj)
*errmaj = LDR_NOSPACE;
if (errmin)
*errmin = LDR_NOSPACE;
return -1;
}
freeHandles[new_handle] = HANDLE_USED;
refCount[new_handle] = 1;
tmp = _LoaderListPush();
tmp->name = malloc(strlen(module) + 1);
strcpy(tmp->name, module);
tmp->cname = malloc(strlen(cname) + 1);
strcpy(tmp->cname, cname);
tmp->handle = new_handle;
tmp->module = moduleseq++;
if ((tmp->private = DLLoadModule(tmp, flags)) == NULL) {
xf86Msg(X_ERROR, "Failed to load %s\n", module);
_LoaderListPop(new_handle);
freeHandles[new_handle] = HANDLE_FREE;
if (errmaj)
*errmaj = LDR_NOLOAD;
if (errmin)
*errmin = LDR_NOLOAD;
return -1;
}
return new_handle;
}
int
LoaderHandleOpen(int handle)
{
if (handle < 0 || handle >= MAX_HANDLE)
return -1;
if (freeHandles[handle] != HANDLE_USED)
return -1;
refCount[handle]++;
return handle;
}
_X_EXPORT void *
LoaderSymbol(const char *sym)
{
return (DLFindSymbol(sym));
}
_X_EXPORT int
LoaderCheckUnresolved(int delay_flag)
{
return 0;
}
int
LoaderUnload(int handle)
{
loaderRec fakeHead;
loaderPtr tmp = &fakeHead;
if (handle < 0 || handle >= MAX_HANDLE)
return -1;
if (--refCount[handle])
return 0;
while ((tmp = _LoaderListPop(handle)) != NULL) {
if (strchr(tmp->name, ':') == NULL) {
xf86Msg(X_INFO, "Unloading %s\n", tmp->name);
}
DLUnloadModule(tmp->private);
free(tmp->name);
free(tmp->cname);
free(tmp);
}
freeHandles[handle] = HANDLE_FREE;
return 0;
}
unsigned long LoaderOptions = 0;
void
LoaderSetOptions(unsigned long opts)
{
LoaderOptions |= opts;
}
_X_EXPORT Bool
LoaderShouldIgnoreABI(void)
{
return (LoaderOptions & LDR_OPT_ABI_MISMATCH_NONFATAL) != 0;
}
_X_EXPORT int
LoaderGetABIVersion(const char *abiclass)
{
struct {
const char *name;
int version;
} classes[] = {
{ ABI_CLASS_ANSIC, LoaderVersionInfo.ansicVersion },
{ ABI_CLASS_VIDEODRV, LoaderVersionInfo.videodrvVersion },
{ ABI_CLASS_XINPUT, LoaderVersionInfo.xinputVersion },
{ ABI_CLASS_EXTENSION, LoaderVersionInfo.extensionVersion },
{ ABI_CLASS_FONT, LoaderVersionInfo.fontVersion },
{ NULL, 0 }
};
int i;
for(i = 0; classes[i].name; i++) {
if(!strcmp(classes[i].name, abiclass)) {
return classes[i].version;
}
}
return 0;
}