1462 lines
34 KiB
C
1462 lines
34 KiB
C
/* $XFree86: xc/programs/Xserver/hw/xfree86/loader/loader.c,v 1.71 2003/11/06 18:38:13 tsi Exp $ */
|
|
|
|
/*
|
|
* Copyright 1995-1998 by Metro Link, Inc.
|
|
*
|
|
* Permission to use, copy, modify, distribute, and sell this software and its
|
|
* documentation for any purpose is hereby granted without fee, provided that
|
|
* the above copyright notice appear in all copies and that both that
|
|
* copyright notice and this permission notice appear in supporting
|
|
* documentation, and that the name of Metro Link, Inc. not be used in
|
|
* advertising or publicity pertaining to distribution of the software without
|
|
* specific, written prior permission. Metro Link, Inc. makes no
|
|
* representations about the suitability of this software for any purpose.
|
|
* It is provided "as is" without express or implied warranty.
|
|
*
|
|
* METRO LINK, INC. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
|
|
* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
|
|
* EVENT SHALL METRO LINK, INC. BE LIABLE FOR ANY SPECIAL, INDIRECT OR
|
|
* CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
|
|
* DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
|
|
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
|
|
* PERFORMANCE OF THIS SOFTWARE.
|
|
*/
|
|
/*
|
|
* Copyright (c) 1997-2003 by The XFree86 Project, Inc.
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a
|
|
* copy of this software and associated documentation files (the "Software"),
|
|
* to deal in the Software without restriction, including without limitation
|
|
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
|
* and/or sell copies of the Software, and to permit persons to whom the
|
|
* Software is furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in
|
|
* all copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
* THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
|
|
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
|
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
|
* OTHER DEALINGS IN THE SOFTWARE.
|
|
*
|
|
* Except as contained in this notice, the name of the copyright holder(s)
|
|
* and author(s) shall not be used in advertising or otherwise to promote
|
|
* the sale, use or other dealings in this Software without prior written
|
|
* authorization from the copyright holder(s) and author(s).
|
|
*/
|
|
|
|
#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 "ar.h"
|
|
#include "elf.h"
|
|
#include "coff.h"
|
|
|
|
#include "os.h"
|
|
#include "sym.h"
|
|
#include "loader.h"
|
|
#include "loaderProcs.h"
|
|
#include "xf86.h"
|
|
#include "xf86Priv.h"
|
|
|
|
#include "compiler.h"
|
|
|
|
extern LOOKUP miLookupTab[];
|
|
extern LOOKUP xfree86LookupTab[];
|
|
extern LOOKUP dixLookupTab[];
|
|
extern LOOKUP fontLookupTab[];
|
|
extern LOOKUP extLookupTab[];
|
|
|
|
/*
|
|
#define DEBUG
|
|
#define DEBUGAR
|
|
#define DEBUGLIST
|
|
#define DEBUGMEM
|
|
*/
|
|
|
|
int check_unresolved_sema = 0;
|
|
|
|
#if defined(Lynx) && defined(sun)
|
|
/* Cross build machine doesn;t have strerror() */
|
|
#define strerror(err) "strerror unsupported"
|
|
#endif
|
|
|
|
#ifdef __UNIXOS2__
|
|
void *os2ldcalloc(size_t, size_t);
|
|
#endif
|
|
|
|
#ifdef HANDLE_IN_HASH_ENTRY
|
|
/*
|
|
* handles are used to identify files that are loaded. Even archives
|
|
* are counted as a single file.
|
|
*/
|
|
#define MAX_HANDLE 256
|
|
#define HANDLE_FREE 0
|
|
#define HANDLE_USED 1
|
|
static char freeHandles[MAX_HANDLE];
|
|
static int refCount[MAX_HANDLE];
|
|
#endif
|
|
|
|
#if defined(__sparc__) && defined(__GNUC__) && !defined(__FreeBSD__)
|
|
# define SYMFUNCDOT(func) { "." #func, (funcptr)&__sparc_dot_ ## func },
|
|
# if !defined(__OpenBSD__)
|
|
# define SYMFUNCDOT89(func) { "." #func, (funcptr)&func ## _sparcv89 },
|
|
# define DEFFUNCDOT(func) \
|
|
extern void __sparc_dot_ ## func (void) __asm__ ("." #func); \
|
|
extern void func ## _sparcv89 (void);
|
|
# else
|
|
# define SYMFUNCDOT(func) { "." #func, (funcptr)&__sparc_dot_ ## func },
|
|
# define DEFFUNCDOT(func) \
|
|
extern void __sparc_dot_ ## func (void) __asm__ ("." #func);
|
|
#endif
|
|
DEFFUNCDOT(rem)
|
|
DEFFUNCDOT(urem)
|
|
DEFFUNCDOT(mul)
|
|
DEFFUNCDOT(umul)
|
|
DEFFUNCDOT(div)
|
|
DEFFUNCDOT(udiv)
|
|
#ifdef linux
|
|
static LOOKUP SparcV89LookupTab[] = {
|
|
SYMFUNCDOT89(rem)
|
|
SYMFUNCDOT89(urem)
|
|
SYMFUNCDOT89(mul)
|
|
SYMFUNCDOT89(umul)
|
|
SYMFUNCDOT89(div)
|
|
SYMFUNCDOT89(udiv)
|
|
{0, 0}
|
|
};
|
|
#endif
|
|
static LOOKUP SparcLookupTab[] = {
|
|
SYMFUNCDOT(rem)
|
|
SYMFUNCDOT(urem)
|
|
SYMFUNCDOT(mul)
|
|
SYMFUNCDOT(umul)
|
|
SYMFUNCDOT(div)
|
|
SYMFUNCDOT(udiv)
|
|
{0, 0}
|
|
};
|
|
|
|
#ifdef linux
|
|
#if defined(__GNUC__) && defined(__GLIBC__)
|
|
#define HWCAP_SPARC_MULDIV 8
|
|
extern unsigned long int _dl_hwcap;
|
|
#endif
|
|
|
|
static int
|
|
sparcUseHWMulDiv(void)
|
|
{
|
|
FILE *f;
|
|
char buffer[1024];
|
|
char *p;
|
|
|
|
#if defined(__GNUC__) && defined(__GLIBC__)
|
|
unsigned long *hwcap;
|
|
|
|
__asm(".weak _dl_hwcap");
|
|
|
|
hwcap = &_dl_hwcap;
|
|
__asm("": "=r"(hwcap):"0"(hwcap));
|
|
if (hwcap) {
|
|
if (*hwcap & HWCAP_SPARC_MULDIV)
|
|
return 1;
|
|
else
|
|
return 0;
|
|
}
|
|
#endif
|
|
f = fopen("/proc/cpuinfo", "r");
|
|
if (!f)
|
|
return 0;
|
|
while (fgets(buffer, 1024, f) != NULL) {
|
|
if (!strncmp(buffer, "type", 4)) {
|
|
p = strstr(buffer, "sun4");
|
|
if (p && (p[4] == 'u' || p[4] == 'd' || p[4] == 'm')) {
|
|
fclose(f);
|
|
return 1;
|
|
}
|
|
}
|
|
}
|
|
fclose(f);
|
|
return 0;
|
|
}
|
|
#endif
|
|
#endif
|
|
|
|
/*
|
|
* modules are used to identify compilation units (ie object modules).
|
|
* Archives contain multiple modules, each of which is treated seperately.
|
|
*/
|
|
static int moduleseq = 0;
|
|
|
|
/*
|
|
* GDB Interface
|
|
* =============
|
|
*
|
|
* Linked list of loaded modules - gdb will traverse this to determine
|
|
* whether it needs to add the symbols for the loaded module.
|
|
*/
|
|
LDRModulePtr ModList = 0;
|
|
|
|
/* Flag which gdb sets to let us know we're being debugged */
|
|
char DebuggerPresent = 0;
|
|
|
|
/* List of common symbols */
|
|
LDRCommonPtr ldrCommons;
|
|
int nCommons;
|
|
|
|
typedef struct {
|
|
int num;
|
|
const char **list;
|
|
} symlist;
|
|
|
|
/*
|
|
* List of symbols that may be referenced, and which are allowed to be
|
|
* unresolved providing that they don't appear on the "reqired" list.
|
|
*/
|
|
static symlist refList = { 0, NULL };
|
|
|
|
/* List of symbols that must not be unresolved */
|
|
static symlist reqList = { 0, NULL };
|
|
|
|
static int fatalReqSym = 0;
|
|
|
|
/* Prototypes for static functions. */
|
|
static int _GetModuleType(int, long);
|
|
static loaderPtr _LoaderListPush(void);
|
|
static loaderPtr _LoaderListPop(int);
|
|
/*ARGSUSED*/ static void
|
|
ARCHIVEResolveSymbols(void *unused)
|
|
{
|
|
}
|
|
/*ARGSUSED*/ static int
|
|
ARCHIVECheckForUnresolved(void *v)
|
|
{
|
|
return 0;
|
|
}
|
|
/*ARGSUSED*/ static char *
|
|
ARCHIVEAddressToSection(void *modptr, unsigned long address)
|
|
{
|
|
return NULL;
|
|
}
|
|
/*ARGSUSED*/ static void
|
|
ARCHIVEUnload(void *unused2)
|
|
{
|
|
}
|
|
|
|
/*
|
|
* Array containing entry points for different formats.
|
|
*/
|
|
|
|
static loader_funcs funcs[] = {
|
|
/* LD_ARCHIVE */
|
|
{ARCHIVELoadModule,
|
|
ARCHIVEResolveSymbols,
|
|
ARCHIVECheckForUnresolved,
|
|
ARCHIVEAddressToSection,
|
|
ARCHIVEUnload, {0, 0, 0, 0, 0}},
|
|
/* LD_ELFOBJECT */
|
|
{ELFLoadModule,
|
|
ELFResolveSymbols,
|
|
ELFCheckForUnresolved,
|
|
ELFAddressToSection,
|
|
ELFUnloadModule, {0, 0, 0, 0, 0}},
|
|
/* LD_COFFOBJECT */
|
|
{COFFLoadModule,
|
|
COFFResolveSymbols,
|
|
COFFCheckForUnresolved,
|
|
COFFAddressToSection,
|
|
COFFUnloadModule, {0, 0, 0, 0, 0}},
|
|
/* LD_XCOFFOBJECT */
|
|
{COFFLoadModule,
|
|
COFFResolveSymbols,
|
|
COFFCheckForUnresolved,
|
|
COFFAddressToSection,
|
|
COFFUnloadModule, {0, 0, 0, 0, 0}},
|
|
/* LD_AOUTOBJECT */
|
|
{AOUTLoadModule,
|
|
AOUTResolveSymbols,
|
|
AOUTCheckForUnresolved,
|
|
AOUTAddressToSection,
|
|
AOUTUnloadModule, {0, 0, 0, 0, 0}},
|
|
/* LD_AOUTDLOBJECT */
|
|
#ifdef DLOPEN_SUPPORT
|
|
{DLLoadModule,
|
|
DLResolveSymbols,
|
|
DLCheckForUnresolved,
|
|
ARCHIVEAddressToSection,
|
|
DLUnloadModule, {0, 0, 0, 0, 0}},
|
|
#else
|
|
{AOUTLoadModule,
|
|
AOUTResolveSymbols,
|
|
AOUTCheckForUnresolved,
|
|
AOUTAddressToSection,
|
|
AOUTUnloadModule, {0, 0, 0, 0, 0}},
|
|
#endif
|
|
/* LD_ELFDLOBJECT */
|
|
#ifdef DLOPEN_SUPPORT
|
|
{DLLoadModule,
|
|
DLResolveSymbols,
|
|
DLCheckForUnresolved,
|
|
ARCHIVEAddressToSection,
|
|
DLUnloadModule, {0, 0, 0, 0, 0}},
|
|
#else
|
|
{ELFLoadModule,
|
|
ELFResolveSymbols,
|
|
ELFCheckForUnresolved,
|
|
ELFAddressToSection,
|
|
ELFUnloadModule, {0, 0, 0, 0, 0}},
|
|
#endif
|
|
};
|
|
|
|
int numloaders = sizeof(funcs) / sizeof(loader_funcs);
|
|
|
|
void
|
|
LoaderInit(void)
|
|
{
|
|
const char *osname = NULL;
|
|
|
|
LoaderAddSymbols(-1, -1, miLookupTab);
|
|
LoaderAddSymbols(-1, -1, xfree86LookupTab);
|
|
LoaderAddSymbols(-1, -1, dixLookupTab);
|
|
LoaderAddSymbols(-1, -1, fontLookupTab);
|
|
LoaderAddSymbols(-1, -1, extLookupTab);
|
|
#if defined(__sparc__) && !defined(__FreeBSD__)
|
|
#ifdef linux
|
|
if (sparcUseHWMulDiv())
|
|
LoaderAddSymbols(-1, -1, SparcV89LookupTab);
|
|
else
|
|
#endif
|
|
LoaderAddSymbols(-1, -1, SparcLookupTab);
|
|
#endif
|
|
|
|
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));
|
|
xf86ErrorFVerb(2, "\t%s : %d.%d\n", ABI_CLASS_FONT,
|
|
GET_ABI_MAJOR(LoaderVersionInfo.fontVersion),
|
|
GET_ABI_MINOR(LoaderVersionInfo.fontVersion));
|
|
|
|
LoaderGetOS(&osname, NULL, NULL, NULL);
|
|
if (osname)
|
|
xf86MsgVerb(X_INFO, 2, "Loader running on %s\n", osname);
|
|
|
|
#if defined(linux) && \
|
|
(defined(__alpha__) || defined(__powerpc__) || defined(__ia64__) \
|
|
|| ( defined __amd64__ && ! defined UseMMAP && ! defined DoMMAPedMerge))
|
|
/*
|
|
* The glibc malloc uses mmap for large allocations anyway. This breaks
|
|
* some relocation types because the offset overflow. See loader.h for more
|
|
* details. We need to turn off this behavior here.
|
|
*/
|
|
mallopt(M_MMAP_MAX, 0);
|
|
#endif
|
|
}
|
|
|
|
/*
|
|
* Determine what type of object is being loaded.
|
|
* This function is responsible for restoring the offset.
|
|
* The fd and offset are used here so that when Archive processing
|
|
* is enabled, individual elements of an archive can be evaluated
|
|
* so the correct loader_funcs can be determined.
|
|
*/
|
|
static int
|
|
_GetModuleType(int fd, long offset)
|
|
{
|
|
unsigned char buf[256]; /* long enough for the largest magic type */
|
|
|
|
if (read(fd, buf, sizeof(buf)) < 0) {
|
|
return -1;
|
|
}
|
|
#ifdef DEBUG
|
|
ErrorF("Checking module type %10s\n", buf);
|
|
ErrorF("Checking module type %x %x %x %x\n", buf[0], buf[1], buf[2],
|
|
buf[3]);
|
|
#endif
|
|
|
|
lseek(fd, offset, SEEK_SET);
|
|
|
|
if (strncmp((char *)buf, ARMAG, SARMAG) == 0) {
|
|
return LD_ARCHIVE;
|
|
}
|
|
#if defined(AIAMAG)
|
|
/* LynxOS PPC style archives */
|
|
if (strncmp((char *)buf, AIAMAG, SAIAMAG) == 0) {
|
|
return LD_ARCHIVE;
|
|
}
|
|
#endif
|
|
|
|
if (strncmp((char *)buf, ELFMAG, SELFMAG) == 0) {
|
|
if (*((Elf32_Half *) (buf + ELFDLOFF)) == ELFDLMAG) {
|
|
return LD_ELFDLOBJECT;
|
|
} else {
|
|
return LD_ELFOBJECT;
|
|
}
|
|
}
|
|
|
|
if (buf[0] == 0x4c && buf[1] == 0x01) {
|
|
/* I386MAGIC */
|
|
return LD_COFFOBJECT;
|
|
}
|
|
if (buf[0] == 0x01 && buf[1] == 0xdf) {
|
|
/* XCOFFMAGIC */
|
|
return LD_COFFOBJECT;
|
|
}
|
|
if (buf[0] == 0x0d && buf[1] == 0x01) {
|
|
/* ZCOFFMAGIC (LynxOS) */
|
|
return LD_COFFOBJECT;
|
|
}
|
|
if (buf[0] == 0x00 && buf[1] == 0x86 && buf[2] == 0x01 && buf[3] == 0x07) {
|
|
/* AOUTMAGIC */
|
|
return LD_AOUTOBJECT;
|
|
}
|
|
if (buf[0] == 0x07 && buf[1] == 0x01
|
|
&& (buf[2] == 0x64 || buf[2] == 0x86)) {
|
|
/* AOUTMAGIC, (Linux OMAGIC, old impure format, also used by OS/2 */
|
|
return LD_AOUTOBJECT;
|
|
}
|
|
if (buf[0] == 0x07 && buf[1] == 0x01 && buf[2] == 0x00 && buf[3] == 0x00) {
|
|
/* AOUTMAGIC, BSDI */
|
|
return LD_AOUTOBJECT;
|
|
}
|
|
if ((buf[0] == 0xc0 && buf[1] == 0x86) || /* big endian form */
|
|
(buf[3] == 0xc0 && buf[2] == 0x86)) { /* little endian form */
|
|
/* i386 shared object */
|
|
return LD_AOUTDLOBJECT;
|
|
}
|
|
|
|
return LD_UNKNOWN;
|
|
}
|
|
|
|
static int offsetbias = 0; /* offset into archive */
|
|
|
|
/*
|
|
* _LoaderFileToMem() loads the contents of a file into memory using
|
|
* the most efficient method for a platform.
|
|
*/
|
|
void *
|
|
_LoaderFileToMem(int fd, unsigned long offset, int size, char *label)
|
|
{
|
|
#ifdef UseMMAP
|
|
unsigned long ret;
|
|
|
|
# ifdef MmapPageAlign
|
|
unsigned long pagesize;
|
|
unsigned long new_size;
|
|
unsigned long new_off;
|
|
unsigned long new_off_bias;
|
|
# endif
|
|
# define MMAP_PROT (PROT_READ|PROT_WRITE|PROT_EXEC)
|
|
|
|
# ifdef DEBUGMEM
|
|
ErrorF("_LoaderFileToMem(%d,%u(%u),%d,%s)", fd, offset, offsetbias, size,
|
|
label);
|
|
# endif
|
|
# ifdef MmapPageAlign
|
|
pagesize = getpagesize();
|
|
new_size = (size + pagesize - 1) / pagesize;
|
|
new_size *= pagesize;
|
|
new_off = (offset + offsetbias) / pagesize;
|
|
new_off *= pagesize;
|
|
new_off_bias = (offset + offsetbias) - new_off;
|
|
if ((new_off_bias + size) > new_size)
|
|
new_size += pagesize;
|
|
ret = (unsigned long)mmap(0, new_size, MMAP_PROT, MAP_PRIVATE
|
|
# ifdef __amd64__
|
|
| MAP_32BIT
|
|
# endif
|
|
, fd, new_off);
|
|
if (ret == -1)
|
|
FatalError("mmap() failed: %s\n", strerror(errno));
|
|
return (void *)(ret + new_off_bias);
|
|
# else
|
|
ret = (unsigned long)mmap(0, size, MMAP_PROT, MAP_PRIVATE
|
|
# ifdef __amd64__
|
|
| MAP_32BIT
|
|
# endif
|
|
, fd, offset + offsetbias);
|
|
if (ret == -1)
|
|
FatalError("mmap() failed: %s\n", strerror(errno));
|
|
return (void *)ret;
|
|
# endif
|
|
#else
|
|
char *ptr;
|
|
|
|
# ifdef DEBUGMEM
|
|
ErrorF("_LoaderFileToMem(%d,%u(%u),%d,%s)", fd, offset, offsetbias, size,
|
|
label);
|
|
# endif
|
|
|
|
if (size == 0) {
|
|
# ifdef DEBUGMEM
|
|
ErrorF("=NULL\n", ptr);
|
|
# endif
|
|
return NULL;
|
|
}
|
|
# ifndef __UNIXOS2__
|
|
if ((ptr = xf86loadercalloc(size, 1)) == NULL)
|
|
FatalError("_LoaderFileToMem() malloc failed\n");
|
|
# else
|
|
if ((ptr = os2ldcalloc(size, 1)) == NULL)
|
|
FatalError("_LoaderFileToMem() malloc failed\n");
|
|
# endif
|
|
# if defined(linux) && defined(__ia64__)
|
|
{
|
|
unsigned long page_size = getpagesize();
|
|
unsigned long round;
|
|
|
|
round = (unsigned long)ptr & (page_size - 1);
|
|
mprotect(ptr - round,
|
|
(size + round + page_size - 1) & ~(page_size - 1),
|
|
PROT_READ | PROT_WRITE | PROT_EXEC);
|
|
}
|
|
# endif
|
|
|
|
if (lseek(fd, offset + offsetbias, SEEK_SET) < 0)
|
|
FatalError("\n_LoaderFileToMem() lseek() failed: %s\n",
|
|
strerror(errno));
|
|
|
|
if (read(fd, ptr, size) != size)
|
|
FatalError("\n_LoaderFileToMem() read() failed: %s\n",
|
|
strerror(errno));
|
|
|
|
# if (defined(linux) || defined(__NetBSD__) || defined(__OpenBSD__)) \
|
|
&& defined(__powerpc__)
|
|
/*
|
|
* Keep the instruction cache in sync with changes in the
|
|
* main memory.
|
|
*/
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < size; i += 16)
|
|
ppc_flush_icache(ptr + i);
|
|
ppc_flush_icache(ptr + size - 1);
|
|
}
|
|
# endif
|
|
|
|
# ifdef DEBUGMEM
|
|
ErrorF("=%lx\n", ptr);
|
|
# endif
|
|
|
|
return (void *)ptr;
|
|
#endif
|
|
}
|
|
|
|
/*
|
|
* _LoaderFreeFileMem() free the memory in which a file was loaded.
|
|
*/
|
|
void
|
|
_LoaderFreeFileMem(void *addr, int size)
|
|
{
|
|
#if defined (UseMMAP) && defined (MmapPageAlign)
|
|
unsigned long pagesize = getpagesize();
|
|
memType i_addr = (memType) addr;
|
|
unsigned long new_size;
|
|
#endif
|
|
#ifdef DEBUGMEM
|
|
ErrorF("_LoaderFreeFileMem(%x,%d)\n", addr, size);
|
|
#endif
|
|
#ifdef UseMMAP
|
|
# if defined (MmapPageAlign)
|
|
i_addr /= pagesize;
|
|
i_addr *= pagesize;
|
|
new_size = (size + pagesize - 1) / pagesize;
|
|
new_size *= pagesize;
|
|
if (((memType) addr - i_addr + size) > new_size)
|
|
new_size += pagesize;
|
|
munmap((void *)i_addr, new_size);
|
|
# else
|
|
munmap((void *)addr, size);
|
|
# endif
|
|
#else
|
|
if (size == 0)
|
|
return;
|
|
|
|
xf86loaderfree(addr);
|
|
#endif
|
|
|
|
return;
|
|
}
|
|
|
|
int
|
|
_LoaderFileRead(int fd, unsigned int offset, void *buf, int size)
|
|
{
|
|
if (lseek(fd, offset + offsetbias, SEEK_SET) < 0)
|
|
FatalError("_LoaderFileRead() lseek() failed: %s\n", strerror(errno));
|
|
|
|
if (read(fd, buf, size) != size)
|
|
FatalError("_LoaderFileRead() read() failed: %s\n", strerror(errno));
|
|
|
|
return size;
|
|
}
|
|
|
|
static loaderPtr listHead = (loaderPtr) 0;
|
|
|
|
static loaderPtr
|
|
_LoaderListPush()
|
|
{
|
|
loaderPtr item = xf86loadercalloc(1, sizeof(struct _loader));
|
|
|
|
item->next = listHead;
|
|
listHead = item;
|
|
|
|
return item;
|
|
}
|
|
|
|
static loaderPtr
|
|
_LoaderListPop(int handle)
|
|
{
|
|
loaderPtr item = listHead;
|
|
loaderPtr *bptr = &listHead; /* pointer to previous node */
|
|
|
|
while (item) {
|
|
if (item->handle == handle) {
|
|
*bptr = item->next; /* remove this from the list */
|
|
return item;
|
|
}
|
|
bptr = &(item->next);
|
|
item = item->next;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* _LoaderHandleToName() will return the name of the first module with a
|
|
* given handle. This requires getting the last module on the LIFO with
|
|
* the given handle.
|
|
*/
|
|
char *
|
|
_LoaderHandleToName(int handle)
|
|
{
|
|
loaderPtr item = listHead;
|
|
loaderPtr aritem = NULL;
|
|
loaderPtr lastitem = NULL;
|
|
|
|
if (handle < 0) {
|
|
return "(built-in)";
|
|
}
|
|
while (item) {
|
|
if (item->handle == handle) {
|
|
if (strchr(item->name, ':') == NULL)
|
|
aritem = item;
|
|
else
|
|
lastitem = item;
|
|
}
|
|
item = item->next;
|
|
}
|
|
|
|
if (aritem)
|
|
return aritem->name;
|
|
|
|
if (lastitem)
|
|
return lastitem->name;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* _LoaderHandleToCanonicalName() will return the cname of the first module
|
|
* with a given handle. This requires getting the last module on the LIFO with
|
|
* the given handle.
|
|
*/
|
|
char *
|
|
_LoaderHandleToCanonicalName(int handle)
|
|
{
|
|
loaderPtr item = listHead;
|
|
loaderPtr lastitem = NULL;
|
|
|
|
if (handle < 0) {
|
|
return "(built-in)";
|
|
}
|
|
while (item) {
|
|
if (item->handle == handle) {
|
|
lastitem = item;
|
|
}
|
|
item = item->next;
|
|
}
|
|
|
|
if (lastitem)
|
|
return lastitem->cname;
|
|
|
|
return NULL;
|
|
}
|
|
|
|
/*
|
|
* _LoaderModuleToName() will return the name of the first module with a
|
|
* given handle. This requires getting the last module on the LIFO with
|
|
* the given handle.
|
|
*/
|
|
char *
|
|
_LoaderModuleToName(int module)
|
|
{
|
|
loaderPtr item = listHead;
|
|
loaderPtr aritem = NULL;
|
|
loaderPtr lastitem = NULL;
|
|
|
|
if (module < 0) {
|
|
return "(built-in)";
|
|
}
|
|
while (item) {
|
|
if (item->module == module) {
|
|
if (strchr(item->name, ':') == NULL)
|
|
aritem = item;
|
|
else
|
|
lastitem = item;
|
|
}
|
|
item = item->next;
|
|
}
|
|
|
|
if (aritem)
|
|
return aritem->name;
|
|
|
|
if (lastitem)
|
|
return lastitem->name;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* _LoaderAddressToSection() will return the name of the file & section
|
|
* that contains the given address.
|
|
*/
|
|
int
|
|
_LoaderAddressToSection(const unsigned long address, const char **module,
|
|
const char **section)
|
|
{
|
|
loaderPtr item = listHead;
|
|
|
|
while (item) {
|
|
if ((*section =
|
|
item->funcs->AddressToSection(item->private, address)) != NULL) {
|
|
*module = _LoaderModuleToName(item->module);
|
|
return 1;
|
|
}
|
|
item = item->next;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Add a list of symbols to the referenced list.
|
|
*/
|
|
|
|
static void
|
|
AppendSymbol(symlist * list, const char *sym)
|
|
{
|
|
list->list = xnfrealloc(list->list, (list->num + 1) * sizeof(char **));
|
|
list->list[list->num] = sym;
|
|
list->num++;
|
|
}
|
|
|
|
static void
|
|
AppendSymList(symlist * list, const char **syms)
|
|
{
|
|
while (*syms) {
|
|
AppendSymbol(list, *syms);
|
|
syms++;
|
|
}
|
|
}
|
|
|
|
static int
|
|
SymInList(symlist * list, char *sym)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < list->num; i++)
|
|
if (strcmp(list->list[i], sym) == 0)
|
|
return 1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
void
|
|
LoaderVRefSymbols(const char *sym0, va_list args)
|
|
{
|
|
const char *s;
|
|
|
|
if (sym0 == NULL)
|
|
return;
|
|
|
|
s = sym0;
|
|
do {
|
|
AppendSymbol(&refList, s);
|
|
s = va_arg(args, const char *);
|
|
} while (s != NULL);
|
|
}
|
|
|
|
void
|
|
LoaderRefSymbols(const char *sym0, ...)
|
|
{
|
|
va_list ap;
|
|
|
|
va_start(ap, sym0);
|
|
LoaderVRefSymbols(sym0, ap);
|
|
va_end(ap);
|
|
}
|
|
|
|
void
|
|
LoaderVRefSymLists(const char **list0, va_list args)
|
|
{
|
|
const char **l;
|
|
|
|
if (list0 == NULL)
|
|
return;
|
|
|
|
l = list0;
|
|
do {
|
|
AppendSymList(&refList, l);
|
|
l = va_arg(args, const char **);
|
|
} while (l != NULL);
|
|
}
|
|
|
|
void
|
|
LoaderRefSymLists(const char **list0, ...)
|
|
{
|
|
va_list ap;
|
|
|
|
va_start(ap, list0);
|
|
LoaderVRefSymLists(list0, ap);
|
|
va_end(ap);
|
|
}
|
|
|
|
void
|
|
LoaderVReqSymLists(const char **list0, va_list args)
|
|
{
|
|
const char **l;
|
|
|
|
if (list0 == NULL)
|
|
return;
|
|
|
|
l = list0;
|
|
do {
|
|
AppendSymList(&reqList, l);
|
|
l = va_arg(args, const char **);
|
|
} while (l != NULL);
|
|
}
|
|
|
|
void
|
|
LoaderReqSymLists(const char **list0, ...)
|
|
{
|
|
va_list ap;
|
|
|
|
va_start(ap, list0);
|
|
LoaderVReqSymLists(list0, ap);
|
|
va_end(ap);
|
|
}
|
|
|
|
void
|
|
LoaderVReqSymbols(const char *sym0, va_list args)
|
|
{
|
|
const char *s;
|
|
|
|
if (sym0 == NULL)
|
|
return;
|
|
|
|
s = sym0;
|
|
do {
|
|
AppendSymbol(&reqList, s);
|
|
s = va_arg(args, const char *);
|
|
} while (s != NULL);
|
|
}
|
|
|
|
void
|
|
LoaderReqSymbols(const char *sym0, ...)
|
|
{
|
|
va_list ap;
|
|
|
|
va_start(ap, sym0);
|
|
LoaderVReqSymbols(sym0, ap);
|
|
va_end(ap);
|
|
}
|
|
|
|
/*
|
|
* _LoaderHandleUnresolved() decides what to do with an unresolved
|
|
* symbol. Symbols that are not on the "referenced" or "required" lists
|
|
* get a warning if they are unresolved. Symbols that are on the "required"
|
|
* list generate a fatal error if they are unresolved.
|
|
*/
|
|
|
|
int
|
|
_LoaderHandleUnresolved(char *symbol, char *module)
|
|
{
|
|
int fatalsym = 0;
|
|
|
|
if (xf86ShowUnresolved && !fatalsym) {
|
|
if (SymInList(&reqList, symbol)) {
|
|
fatalReqSym = 1;
|
|
ErrorF("Required symbol %s from module %s is unresolved!\n",
|
|
symbol, module);
|
|
}
|
|
if (!SymInList(&refList, symbol)) {
|
|
ErrorF("Symbol %s from module %s is unresolved!\n",
|
|
symbol, module);
|
|
}
|
|
}
|
|
return (fatalsym);
|
|
}
|
|
|
|
/*
|
|
* Handle an archive.
|
|
*/
|
|
void *
|
|
ARCHIVELoadModule(loaderPtr modrec, int arfd, LOOKUP ** ppLookup)
|
|
{
|
|
loaderPtr tmp = NULL;
|
|
void *ret = NULL;
|
|
unsigned char magic[SARMAG];
|
|
struct ar_hdr hdr;
|
|
|
|
#if defined(__powerpc__) && defined(Lynx)
|
|
struct fl_hdr fhdr;
|
|
char name[255];
|
|
int namlen;
|
|
#endif
|
|
unsigned int size;
|
|
unsigned int offset;
|
|
int arnamesize, modnamesize;
|
|
char *slash, *longname;
|
|
char *nametable = NULL;
|
|
int nametablelen = 0;
|
|
LOOKUP *lookup_ret, *p;
|
|
LOOKUP *myLookup = NULL; /* Does realloc behave if ptr == 0? */
|
|
int modtype;
|
|
int i;
|
|
int numsyms = 0;
|
|
|
|
/* lookup_ret = xf86loadermalloc(sizeof (LOOKUP *)); */
|
|
|
|
arnamesize = strlen(modrec->name);
|
|
|
|
#if !(defined(__powerpc__) && defined(Lynx))
|
|
read(arfd, magic, SARMAG);
|
|
|
|
if (strncmp((const char *)magic, ARMAG, SARMAG) != 0) {
|
|
ErrorF("ARCHIVELoadModule: wrong magic!!\n");
|
|
return NULL;
|
|
}
|
|
#else
|
|
read(arfd, &fhdr, FL_HSZ);
|
|
|
|
if (strncmp(fhdr.fl_magic, AIAMAG, SAIAMAG) != 0) {
|
|
ErrorF("ARCHIVELoadModule: wrong magic!!\n");
|
|
return NULL;
|
|
}
|
|
#endif /* __powerpc__ && Lynx */
|
|
|
|
#ifdef DEBUGAR
|
|
ErrorF("Looking for archive members starting at offset %o\n", offset);
|
|
#endif
|
|
|
|
while (read(arfd, &hdr, sizeof(struct ar_hdr))) {
|
|
|
|
longname = NULL;
|
|
sscanf(hdr.ar_size, "%u", &size);
|
|
#if defined(__powerpc__) && defined(Lynx)
|
|
sscanf(hdr.ar_namlen, "%d", &namlen);
|
|
name[0] = hdr.ar_name[0];
|
|
name[1] = hdr.ar_name[1];
|
|
read(arfd, &name[2], namlen);
|
|
name[namlen] = '\0';
|
|
offset = lseek(arfd, 0, SEEK_CUR);
|
|
if (offset & 0x1) /* odd value */
|
|
offset = lseek(arfd, 1, SEEK_CUR); /* make it an even boundary */
|
|
#endif
|
|
offset = lseek(arfd, 0, SEEK_CUR);
|
|
|
|
/* Check for a Symbol Table */
|
|
if ((hdr.ar_name[0] == '/' && hdr.ar_name[1] == ' ') ||
|
|
#if defined(__powerpc__) && defined(Lynx)
|
|
namlen == 0 ||
|
|
#endif
|
|
strncmp(hdr.ar_name, "__.SYMDEF", 9) == 0) {
|
|
/* If the file name is NULL, then it is a symbol table */
|
|
#ifdef DEBUGAR
|
|
ErrorF("Symbol Table Member '%16.16s', size %d, offset %d\n",
|
|
hdr.ar_name, size, offset);
|
|
ErrorF("Symbol table size %d\n", size);
|
|
#endif
|
|
offset = lseek(arfd, offset + size, SEEK_SET);
|
|
if (offset & 0x1) /* odd value */
|
|
offset = lseek(arfd, 1, SEEK_CUR); /* make it an even boundary */
|
|
continue;
|
|
}
|
|
|
|
/* Check for a String Table */
|
|
if (hdr.ar_name[0] == '/' && hdr.ar_name[1] == '/') {
|
|
/* If the file name is '/', then it is a string table */
|
|
#ifdef DEBUGAR
|
|
ErrorF("String Table Member '%16.16s', size %d, offset %d\n",
|
|
hdr.ar_name, size, offset);
|
|
ErrorF("String table size %d\n", size);
|
|
#endif
|
|
nametablelen = size;
|
|
nametable = (char *)xf86loadermalloc(nametablelen);
|
|
read(arfd, nametable, size);
|
|
offset = lseek(arfd, 0, SEEK_CUR);
|
|
/* offset=lseek(arfd,offset+size,SEEK_SET); */
|
|
if (offset & 0x1) /* odd value */
|
|
offset = lseek(arfd, 1, SEEK_CUR); /* make it an even boundary */
|
|
continue;
|
|
}
|
|
|
|
if (hdr.ar_name[0] == '/') {
|
|
/* SYS V r4 style long member name */
|
|
int nameoffset = atol(&hdr.ar_name[1]);
|
|
char *membername;
|
|
|
|
if (!nametable) {
|
|
ErrorF("Missing string table whilst processing %s\n",
|
|
modrec->name);
|
|
offsetbias = 0;
|
|
return NULL;
|
|
}
|
|
if (nameoffset > nametablelen) {
|
|
ErrorF("Invalid string table offset (%s) whilst processing %s\n", hdr.ar_name, modrec->name);
|
|
offsetbias = 0;
|
|
xf86loaderfree(nametable);
|
|
return NULL;
|
|
}
|
|
membername = nametable + nameoffset;
|
|
slash = strchr(membername, '/');
|
|
if (slash)
|
|
*slash = '\0';
|
|
longname = xf86loadermalloc(arnamesize + strlen(membername) + 2);
|
|
strcpy(longname, modrec->name);
|
|
strcat(longname, ":");
|
|
strcat(longname, membername);
|
|
} else if (hdr.ar_name[0] == '#' && hdr.ar_name[1] == '1' &&
|
|
hdr.ar_name[2] == '/') {
|
|
/* BSD 4.4 style long member name */
|
|
if (sscanf(hdr.ar_name + 3, "%d", &modnamesize) != 1) {
|
|
ErrorF("Bad archive member %s\n", hdr.ar_name);
|
|
offsetbias = 0;
|
|
return NULL;
|
|
}
|
|
/* allocate space for fully qualified name */
|
|
longname = xf86loadermalloc(arnamesize + modnamesize + 2);
|
|
strcpy(longname, modrec->name);
|
|
strcat(longname, ":");
|
|
i = read(arfd, longname + modnamesize + 1, modnamesize);
|
|
if (i != modnamesize) {
|
|
ErrorF("Bad archive member %s\n", hdr.ar_name);
|
|
xf86loaderfree(longname);
|
|
offsetbias = 0;
|
|
return NULL;
|
|
}
|
|
longname[i] = '\0';
|
|
offset += i;
|
|
size -= i;
|
|
} else {
|
|
/* Regular archive member */
|
|
#ifdef DEBUGAR
|
|
ErrorF("Member '%16.16s', size %d, offset %x\n",
|
|
#if !(defined(__powerpc__) && defined(Lynx))
|
|
hdr.ar_name,
|
|
#else
|
|
name,
|
|
#endif
|
|
size, offset);
|
|
#endif
|
|
|
|
slash = strchr(hdr.ar_name, '/');
|
|
if (slash == NULL) {
|
|
/* BSD format without trailing slash */
|
|
slash = strchr(hdr.ar_name, ' ');
|
|
}
|
|
/* SM: Make sure we do not overwrite other parts of struct */
|
|
|
|
if ((slash - hdr.ar_name) > sizeof(hdr.ar_name))
|
|
slash = hdr.ar_name + sizeof(hdr.ar_name) - 1;
|
|
*slash = '\000';
|
|
}
|
|
if ((modtype = _GetModuleType(arfd, offset)) < 0) {
|
|
ErrorF("%s is an unrecognized module type\n", hdr.ar_name);
|
|
offsetbias = 0;
|
|
if (nametable)
|
|
xf86loaderfree(nametable);
|
|
return NULL;
|
|
}
|
|
|
|
tmp = _LoaderListPush();
|
|
|
|
tmp->handle = modrec->handle;
|
|
tmp->module = moduleseq++;
|
|
tmp->cname = xf86loadermalloc(strlen(modrec->cname) + 1);
|
|
strcpy(tmp->cname, modrec->cname);
|
|
tmp->funcs = &funcs[modtype];
|
|
if (longname == NULL) {
|
|
modnamesize = strlen(hdr.ar_name);
|
|
tmp->name =
|
|
(char *)xf86loadermalloc(arnamesize + modnamesize + 2);
|
|
strcpy(tmp->name, modrec->name);
|
|
strcat(tmp->name, ":");
|
|
strcat(tmp->name, hdr.ar_name);
|
|
|
|
} else {
|
|
tmp->name = longname;
|
|
}
|
|
offsetbias = offset;
|
|
|
|
if ((tmp->private = funcs[modtype].LoadModule(tmp, arfd, &lookup_ret))
|
|
== NULL) {
|
|
ErrorF("Failed to load %s\n", hdr.ar_name);
|
|
offsetbias = 0;
|
|
if (nametable)
|
|
xf86loaderfree(nametable);
|
|
return NULL;
|
|
}
|
|
|
|
offset = lseek(arfd, offset + size, SEEK_SET);
|
|
if (offset & 0x1) /* odd value */
|
|
lseek(arfd, 1, SEEK_CUR); /* make it an even boundary */
|
|
|
|
if (tmp->private == (void *)-1L) {
|
|
ErrorF("Skipping \"%s\": No symbols found\n", tmp->name);
|
|
continue;
|
|
} else
|
|
ret = tmp->private;
|
|
|
|
/* Add the lookup table returned from funcs.LoadModule to the
|
|
* one we're going to return.
|
|
*/
|
|
for (i = 0, p = lookup_ret; p && p->symName; i++, p++) ;
|
|
if (i) {
|
|
myLookup = xf86loaderrealloc(myLookup, (numsyms + i + 1)
|
|
* sizeof(LOOKUP));
|
|
if (!myLookup)
|
|
continue; /* Oh well! */
|
|
|
|
memcpy(&(myLookup[numsyms]), lookup_ret, i * sizeof(LOOKUP));
|
|
numsyms += i;
|
|
myLookup[numsyms].symName = 0;
|
|
}
|
|
xf86loaderfree(lookup_ret);
|
|
}
|
|
/* xf86loaderfree(lookup_ret); */
|
|
offsetbias = 0;
|
|
|
|
*ppLookup = myLookup;
|
|
if (nametable)
|
|
xf86loaderfree(nametable);
|
|
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
* Relocation list manipulation routines
|
|
*/
|
|
|
|
/*
|
|
* _LoaderGetRelocations() Return the list of outstanding relocations
|
|
*/
|
|
LoaderRelocPtr
|
|
_LoaderGetRelocations(void *mod)
|
|
{
|
|
loader_funcs *formatrec = (loader_funcs *) mod;
|
|
|
|
return &(formatrec->pRelocs);
|
|
}
|
|
|
|
/*
|
|
* Public Interface to the loader.
|
|
*/
|
|
|
|
int
|
|
LoaderOpen(const char *module, const char *cname, int handle,
|
|
int *errmaj, int *errmin, int *wasLoaded)
|
|
{
|
|
loaderPtr tmp;
|
|
int new_handle, modtype;
|
|
int fd;
|
|
LOOKUP *pLookup;
|
|
|
|
#if defined(DEBUG)
|
|
ErrorF("LoaderOpen(%s)\n", module);
|
|
#endif
|
|
|
|
/*
|
|
* Check to see if the module is already loaded.
|
|
* Only if we are loading it into an existing namespace.
|
|
* If it is to be loaded into a new namespace, don't check.
|
|
* Note: We only have one namespace.
|
|
*/
|
|
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;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* OK, it's a new one. Add it.
|
|
*/
|
|
xf86Msg(X_INFO, "Loading %s\n", module);
|
|
if (wasLoaded)
|
|
*wasLoaded = 0;
|
|
|
|
/*
|
|
* Find a free handle.
|
|
*/
|
|
new_handle = 1;
|
|
while (freeHandles[new_handle] && new_handle < MAX_HANDLE)
|
|
new_handle++;
|
|
|
|
if (new_handle == MAX_HANDLE) {
|
|
xf86Msg(X_ERROR, "Out of loader space\n"); /* XXX */
|
|
if (errmaj)
|
|
*errmaj = LDR_NOSPACE;
|
|
if (errmin)
|
|
*errmin = LDR_NOSPACE;
|
|
return -1;
|
|
}
|
|
|
|
freeHandles[new_handle] = HANDLE_USED;
|
|
refCount[new_handle] = 1;
|
|
|
|
if ((fd = open(module, O_RDONLY)) < 0) {
|
|
xf86Msg(X_ERROR, "Unable to open %s\n", module);
|
|
freeHandles[new_handle] = HANDLE_FREE;
|
|
if (errmaj)
|
|
*errmaj = LDR_NOMODOPEN;
|
|
if (errmin)
|
|
*errmin = errno;
|
|
return -1;
|
|
}
|
|
|
|
if ((modtype = _GetModuleType(fd, 0)) < 0) {
|
|
xf86Msg(X_ERROR, "%s is an unrecognized module type\n", module);
|
|
freeHandles[new_handle] = HANDLE_FREE;
|
|
if (errmaj)
|
|
*errmaj = LDR_UNKTYPE;
|
|
if (errmin)
|
|
*errmin = LDR_UNKTYPE;
|
|
return -1;
|
|
}
|
|
|
|
tmp = _LoaderListPush();
|
|
tmp->name = xf86loadermalloc(strlen(module) + 1);
|
|
strcpy(tmp->name, module);
|
|
tmp->cname = xf86loadermalloc(strlen(cname) + 1);
|
|
strcpy(tmp->cname, cname);
|
|
tmp->handle = new_handle;
|
|
tmp->module = moduleseq++;
|
|
tmp->funcs = &funcs[modtype];
|
|
|
|
if ((tmp->private = funcs[modtype].LoadModule(tmp, fd, &pLookup)) == 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;
|
|
}
|
|
|
|
if (tmp->private != (void *)-1L) {
|
|
LoaderAddSymbols(new_handle, tmp->module, pLookup);
|
|
xf86loaderfree(pLookup);
|
|
}
|
|
|
|
close(fd);
|
|
|
|
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;
|
|
}
|
|
|
|
void *
|
|
LoaderSymbol(const char *sym)
|
|
{
|
|
int i;
|
|
itemPtr item = NULL;
|
|
|
|
for (i = 0; i < numloaders; i++)
|
|
funcs[i].ResolveSymbols(&funcs[i]);
|
|
|
|
item = (itemPtr) LoaderHashFind(sym);
|
|
|
|
if (item)
|
|
return item->address;
|
|
else
|
|
#ifdef DLOPEN_SUPPORT
|
|
return (DLFindSymbol(sym));
|
|
#else
|
|
return NULL;
|
|
#endif
|
|
}
|
|
|
|
int
|
|
LoaderResolveSymbols(void)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < numloaders; i++)
|
|
funcs[i].ResolveSymbols(&funcs[i]);
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
LoaderCheckUnresolved(int delay_flag)
|
|
{
|
|
int i, ret = 0;
|
|
LoaderResolveOptions delayFlag = (LoaderResolveOptions)delay_flag;
|
|
|
|
LoaderResolveSymbols();
|
|
|
|
if (delayFlag == LD_RESOLV_NOW) {
|
|
if (check_unresolved_sema > 0)
|
|
check_unresolved_sema--;
|
|
else
|
|
xf86Msg(X_WARNING, "LoaderCheckUnresolved: not enough "
|
|
"MAGIC_DONT_CHECK_UNRESOLVED\n");
|
|
}
|
|
|
|
if (!check_unresolved_sema || delayFlag == LD_RESOLV_FORCE)
|
|
for (i = 0; i < numloaders; i++)
|
|
if (funcs[i].CheckForUnresolved(&funcs[i]))
|
|
ret = 1;
|
|
|
|
if (fatalReqSym)
|
|
FatalError("Some required symbols were unresolved\n");
|
|
|
|
return ret;
|
|
}
|
|
|
|
void xf86LoaderTrap(void);
|
|
|
|
void
|
|
xf86LoaderTrap(void)
|
|
{
|
|
}
|
|
|
|
void
|
|
LoaderDefaultFunc(void)
|
|
{
|
|
ErrorF("\n\n\tThis should not happen!\n"
|
|
"\tAn unresolved function was called!\n");
|
|
|
|
xf86LoaderTrap();
|
|
|
|
FatalError("\n");
|
|
}
|
|
|
|
int
|
|
LoaderUnload(int handle)
|
|
{
|
|
loaderRec fakeHead;
|
|
loaderPtr tmp = &fakeHead;
|
|
|
|
if (handle < 0 || handle > MAX_HANDLE)
|
|
return -1;
|
|
|
|
/*
|
|
* check the reference count, only free it if it goes to zero
|
|
*/
|
|
if (--refCount[handle])
|
|
return 0;
|
|
/*
|
|
* find the loaderRecs associated with this handle.
|
|
*/
|
|
|
|
while ((tmp = _LoaderListPop(handle)) != NULL) {
|
|
if (strchr(tmp->name, ':') == NULL) {
|
|
/* It is not a member of an archive */
|
|
xf86Msg(X_INFO, "Unloading %s\n", tmp->name);
|
|
}
|
|
tmp->funcs->LoaderUnload(tmp->private);
|
|
xf86loaderfree(tmp->name);
|
|
xf86loaderfree(tmp->cname);
|
|
xf86loaderfree(tmp);
|
|
}
|
|
|
|
freeHandles[handle] = HANDLE_FREE;
|
|
|
|
return 0;
|
|
}
|
|
|
|
void
|
|
LoaderDuplicateSymbol(const char *symbol, const int handle)
|
|
{
|
|
ErrorF("Duplicate symbol %s in %s\n", symbol,
|
|
listHead ? listHead->name : "(built-in)");
|
|
ErrorF("Also defined in %s\n", _LoaderHandleToName(handle));
|
|
FatalError("Module load failure\n");
|
|
}
|
|
|
|
/* GDB Sync function */
|
|
void
|
|
_loader_debug_state()
|
|
{
|
|
}
|
|
|
|
unsigned long LoaderOptions = 0;
|
|
|
|
void
|
|
LoaderResetOptions(void)
|
|
{
|
|
LoaderOptions = 0;
|
|
}
|
|
|
|
void
|
|
LoaderSetOptions(unsigned long opts)
|
|
{
|
|
LoaderOptions |= opts;
|
|
}
|
|
|
|
void
|
|
LoaderClearOptions(unsigned long opts)
|
|
{
|
|
LoaderOptions &= ~opts;
|
|
}
|