static void
GiveSystemInfo(void)
{
int rv;
char buf[4096];
rv = syssgi(SGI_SYSID, &buf[0]);
if (rv > 0) {
RNG_RandomUpdate(buf, MAXSYSIDSIZE);
}
#ifdef SGI_RDUBLK
rv = syssgi(SGI_RDUBLK, getpid(), &buf[0], sizeof(buf));
if (rv > 0) {
RNG_RandomUpdate(buf, sizeof(buf));
}
#endif /* SGI_RDUBLK */
rv = syssgi(SGI_INVENT, SGI_INV_READ, buf, sizeof(buf));
if (rv > 0) {
RNG_RandomUpdate(buf, sizeof(buf));
}
rv = sysinfo(SI_MACHINE, buf, sizeof(buf));
if (rv > 0) {
RNG_RandomUpdate(buf, rv);
}
rv = sysinfo(SI_RELEASE, buf, sizeof(buf));
if (rv > 0) {
RNG_RandomUpdate(buf, rv);
}
rv = sysinfo(SI_HW_SERIAL, buf, sizeof(buf));
if (rv > 0) {
RNG_RandomUpdate(buf, rv);
}
}
int
set_job(job *pjob, struct startjob_rtn *sjr)
{
extern char noglobid[];
char cvtbuf[20];
if (pjob->ji_globid == NULL ||
strcmp(pjob->ji_globid, noglobid) == 0) {
if (newarraysess() == -1) {
sprintf(log_buffer, "newarraysess failed %d", errno);
return (-2);
}
sjr->sj_ash = getash();
}
else {
if (sscanf(pjob->ji_globid, "%llx", &sjr->sj_ash) != 1) {
sprintf(log_buffer, "invalid global id %s",
pjob->ji_globid);
return (-2);
}
if (syssgi(SGI_JOINARRAYSESS, -1, &sjr->sj_ash) == -1) {
sprintf(log_buffer, "cannot set ash %llx err %d",
sjr->sj_ash, errno);
return (-2);
}
}
if (set_sgi_proj(pjob->ji_wattr[(int)JOB_ATR_euser].at_val.at_str,
&pjob->ji_wattr[(int)JOB_ATR_account]) < 0) {
(void)sprintf(log_buffer, "Invalid project id");
return (-3);
}
return (sjr->sj_session = setsid());
}
// Timer Method Definitions
Timer::Timer()
{
#if defined( IRIX ) || defined( IRIX64 )
// IRIX Timer Initialization
__psunsigned_t phys_addr, raddr;
int poffmask = getpagesize() - 1;
int counterSize = syssgi(SGI_CYCLECNTR_SIZE);
phys_addr = syssgi(SGI_QUERY_CYCLECNTR, &(cycleval));
if (phys_addr == ENODEV) {
Severe( "Sorry, this SGI doesn't support timers." );
}
raddr = phys_addr & ~poffmask;
fd = open("/dev/mmem", O_RDONLY);
if (counterSize == 64) {
iotimer_addr64 =
(volatile iotimer64_t *)mmap(0, poffmask, PROT_READ,
MAP_PRIVATE, fd, (off_t)raddr);
unmapLocation = (void *)iotimer_addr64;
unmapSize = poffmask;
iotimer_addr64 = (iotimer64_t *)((__psunsigned_t)iotimer_addr64 +
(phys_addr & poffmask));
}
else if (counterSize == 32) {
iotimer_addr32 = (volatile iotimer32_t *)mmap(0, poffmask, PROT_READ,
MAP_PRIVATE, fd,
(off_t)raddr);
unmapLocation = (void *)iotimer_addr32;
unmapSize = poffmask;
iotimer_addr32 = (iotimer32_t *)((__psunsigned_t)iotimer_addr32 +
(phys_addr & poffmask));
}
else {
Severe( "Fatal timer init error" );
}
#elif defined( WIN32 )
// Windows Timer Initialization
QueryPerformanceFrequency( &performance_frequency );
one_over_frequency = 1.0/((double)performance_frequency.QuadPart);
#endif
time0 = elapsed = 0;
running = 0;
}
/**
* @brief
* start_hammer() - Entry point for the unauthoized user hammer routine.
* This function fork()s a child, which then runs the hammer_loop() routine.
* The parent returns immediately. The child will exit when the hammer_loop is killed.
*
* @param[in] secs - time in secs for halting hammer_loop
*
* @return pid_t
* @retval -1 on error,
* @retval otherwise the pid of the hammer thread.
*/
pid_t
start_hammer(int secs)
{
char *id = "start_hammer";
pid_t pid, parent;
int rc;
parent = getpid(); /* PID that will parent the child */
/*
* Fork a new process that will watch for user processes that are not
* controlled by mom. These processes will be killed without mercy.
*/
pid = fork();
if (pid == -1) {
log_err(errno, id, "cannot fork hammer process.");
return -1;
}
/* If still in original process, return the child's PID to the caller. */
if (pid != 0)
return pid;
/* ======================================================================
* This is the child. Hammer loop starts here.
*/
#ifdef SGI_SETPSARGS
/*
* Change the psargs field of this process to a more useful string.
* This is a custom modification which is only cosmetic. Ignore any
* error or result codes.
*/
(void)syssgi(SGI_SETPSARGS, HAMMER_NAME, strlen(HAMMER_NAME));
#endif /* SGI_SETPSARGS */
/* Close un-necessary file descriptors inherited from main mom. */
(void)close_inherited();
if (secs)
sleep(secs); /* Sleep if requested, then start the hammer loop. */
rc = hammer_loop(mom_shared, parent); /* Run hammer loop. */
/*
* hammer_loop() should not return, except in exceptional circumstances.
* It normally calls exit() on its own.
*/
exit(rc);
/* NOTREACHED */
}
void
_u_sysclock_restart()
{
__psunsigned_t vbase, raddr, phys_addr;
unsigned int pico_per_clk;
int cycsz;
int fd;
int page;
int poffmask;
if (!_init_hw_clock_called)
return;
if (_rtc_clockaddr != NULL) {
page = getpagesize();
poffmask = page - 1;
phys_addr = syssgi(SGI_QUERY_CYCLECNTR, &pico_per_clk);
cycsz = syssgi(SGI_CYCLECNTR_SIZE);
raddr = phys_addr & ~poffmask;
fd = open("/dev/mmem", O_RDONLY);
vbase = (__psunsigned_t)_rtc_clockaddr & ~poffmask;
mmap((void *)vbase, page, PROT_READ,
MAP_PRIVATE | MAP_FIXED, fd, (off_t) raddr);
}
return;
}
int
main(
int argc,
char **argv)
{
#ifdef __sgi
xfs_fsop_geom_t geom;
char *uuid_str;
u_int status;
#endif
char *name;
int fd;
void *fshanp;
size_t fshlen;
char buffer[100];
if (argc != 2) {
fprintf(stderr, "usage: %s path\n", argv[0]);
exit(1);
}
Progname = argv[0];
(void)dm_init_service(&name);
if (dm_path_to_fshandle(argv[1], &fshanp, &fshlen) != 0) {
fprintf(stderr, "dm_path_to_fshandle failed, %s\n",
strerror(errno));
}
hantoa(fshanp, fshlen, buffer);
if ((fd = open(argv[1], O_RDONLY)) < 0) {
fprintf(stderr, "Open of %s failed, %s\n", argv[1],
strerror(errno));
exit(1);
}
#ifdef __sgi
syssgi(SGI_XFS_FSOPERATIONS, fd, XFS_FS_GEOMETRY, NULL, &geom);
uuid_to_string(&geom.uuid, &uuid_str, &status);
fprintf(stdout, "fshandle %s, uuid %s, %s\n",
buffer, uuid_str, argv[1]);
#endif
fprintf(stdout, "fshandle %s, %s\n",
buffer, argv[1]);
exit(0);
}
static size_t GetHighResClock(void *buf, size_t maxbuf)
{
unsigned phys_addr, raddr, cycleval;
static volatile unsigned *iotimer_addr = NULL;
static int tries = 0;
static int cntr_size;
int mfd;
long s0[2];
struct timeval tv;
#ifndef SGI_CYCLECNTR_SIZE
#define SGI_CYCLECNTR_SIZE 165 /* Size user needs to use to read CC */
#endif
if (iotimer_addr == NULL) {
if (tries++ > 1) {
/* Don't keep trying if it didn't work */
return 0;
}
/*
** For SGI machines we can use the cycle counter, if it has one,
** to generate some truly random numbers
*/
phys_addr = syssgi(SGI_QUERY_CYCLECNTR, &cycleval);
if (phys_addr) {
int pgsz = getpagesize();
int pgoffmask = pgsz - 1;
raddr = phys_addr & ~pgoffmask;
mfd = open("/dev/mmem", O_RDONLY);
if (mfd < 0) {
return 0;
}
iotimer_addr = (unsigned *)
mmap(0, pgoffmask, PROT_READ, MAP_PRIVATE, mfd, (int)raddr);
if (iotimer_addr == (void*)-1) {
close(mfd);
iotimer_addr = NULL;
return 0;
}
iotimer_addr = (unsigned*)
((__psint_t)iotimer_addr | (phys_addr & pgoffmask));
/*
* The file 'mfd' is purposefully not closed.
*/
cntr_size = syssgi(SGI_CYCLECNTR_SIZE);
if (cntr_size < 0) {
struct utsname utsinfo;
/*
* We must be executing on a 6.0 or earlier system, since the
* SGI_CYCLECNTR_SIZE call is not supported.
*
* The only pre-6.1 platforms with 64-bit counters are
* IP19 and IP21 (Challenge, PowerChallenge, Onyx).
*/
uname(&utsinfo);
if (!strncmp(utsinfo.machine, "IP19", 4) ||
!strncmp(utsinfo.machine, "IP21", 4))
cntr_size = 64;
else
cntr_size = 32;
}
cntr_size /= 8; /* Convert from bits to bytes */
}
}
s0[0] = *iotimer_addr;
if (cntr_size > 4)
s0[1] = *(iotimer_addr + 1);
memcpy(buf, (char *)&s0[0], cntr_size);
return CopyLowBits(buf, maxbuf, &s0, cntr_size);
}
void
GetNameInfo(void)
{
int i, found = false;
char *sp, *sp2;
time_t tloc;
struct hostent *hp;
struct sockaddr_in cin;
#ifdef AIX
char real_version[_SYS_NMLN];
#endif
#ifdef IRIX
char real_version[256]; /* see <sys/syssgi.h> */
#endif
#ifdef HAVE_SYSINFO
#ifdef SI_ARCHITECTURE
long sz;
#endif
#endif
Debug("GetNameInfo()\n");
g_vfqname[0] = g_vuqname[0] = '\0';
if (uname(&g_vsysname) == -1) {
perror("uname ");
FatalError("Uname couldn't get kernel name info!!\n");
}
#ifdef AIX
snprintf(real_version, _SYS_NMLN, "%.80s.%.80s",
g_vsysname.version, g_vsysname.release);
strncpy(g_vsysname.release, real_version, _SYS_NMLN);
#elif defined IRIX
/* This gets us something like `6.5.19m' rather than just `6.5'. */
syssgi (SGI_RELEASE_NAME, 256, real_version);
#endif
for (sp = g_vsysname.sysname; *sp != '\0'; sp++) {
*sp = ToLower(*sp);
}
for (sp = g_vsysname.machine; *sp != '\0'; sp++) {
*sp = ToLower(*sp);
}
for (i = 0; g_classattributes[i][0] != '\0'; i++) {
if (WildMatch(g_classattributes[i][0],
ToLowerStr(g_vsysname.sysname))) {
if (WildMatch(g_classattributes[i][1],
g_vsysname.machine)) {
if (WildMatch(g_classattributes[i][2],
g_vsysname.release)) {
if (g_underscore_classes) {
snprintf(g_vbuff, CF_BUFSIZE, "_%s", g_classtext[i]);
AddClassToHeap(g_vbuff);
} else {
AddClassToHeap(g_classtext[i]);
}
found = true;
g_vsystemhardclass = (enum classes) i;
break;
}
} else {
Debug2("Cfengine: I recognize %s but not %s\n",
g_vsysname.sysname, g_vsysname.machine);
continue;
}
}
}
if ((sp = malloc(strlen(g_vsysname.nodename)+1)) == NULL) {
FatalError("malloc failure in initialize()");
}
strcpy(sp, g_vsysname.nodename);
SetDomainName(sp);
/* Truncate fully qualified name */
for (sp2=sp; *sp2 != '\0'; sp2++) {
if (*sp2 == '.') {
*sp2 = '\0';
Debug("Truncating fully qualified hostname %s to %s\n",
g_vsysname.nodename,sp);
break;
}
}
g_vdefaultbinserver.name = sp;
AddClassToHeap(CanonifyName(sp));
if ((tloc = time((time_t *)NULL)) == -1) {
printf("Couldn't read system clock\n");
}
if (g_verbose || g_debug || g_d2 || g_d3) {
if (g_underscore_classes) {
snprintf(g_vbuff, CF_BUFSIZE, "_%s", g_classtext[i]);
} else {
snprintf(g_vbuff, CF_BUFSIZE, "%s", g_classtext[i]);
}
if (g_iscfengine) {
printf ("cfng: configuration agent (cfagent) - \n%s\n%s\n\n",
VERSION, g_copyright);
} else {
printf ("cfng: configuration server (cfservd) - \n%s\n%s\n\n",
VERSION, g_copyright);
}
printf ("------------------------------------------------------------------------\n\n");
printf ("Host name is: %s\n", g_vsysname.nodename);
printf ("Operating System Type is %s\n", g_vsysname.sysname);
printf ("Operating System Release is %s\n", g_vsysname.release);
printf ("Architecture = %s\n\n\n", g_vsysname.machine);
printf ("Using internal soft-class %s for host %s\n\n",
g_vbuff, g_classtext[g_vsystemhardclass]);
printf ("The time is now %s\n\n", ctime(&tloc));
printf ("------------------------------------------------------------------------\n\n");
}
sprintf(g_vbuff, "%d_bit", sizeof(long)*8);
AddClassToHeap(g_vbuff);
Verbose("Additional hard class defined as: %s\n", CanonifyName(g_vbuff));
snprintf(g_vbuff, CF_BUFSIZE, "%s_%s", g_vsysname.sysname,
g_vsysname.release);
AddClassToHeap(CanonifyName(g_vbuff));
#ifdef IRIX
/*
* Get something like `irix64_6_5_19m' defined as well as
* `irix64_6_5'. Just copying the latter into g_vsysname.release
* wouldn't be backwards-compatible.
*/
snprintf(g_vbuff, CF_BUFSIZE, "%s_%s", g_vsysname.sysname, real_version);
AddClassToHeap(CanonifyName(g_vbuff));
#endif
AddClassToHeap(CanonifyName(g_vsysname.machine));
Verbose("Additional hard class defined as: %s\n",CanonifyName(g_vbuff));
snprintf(g_vbuff, CF_BUFSIZE,"%s_%s", g_vsysname.sysname,
g_vsysname.machine);
AddClassToHeap(CanonifyName(g_vbuff));
Verbose("Additional hard class defined as: %s\n",CanonifyName(g_vbuff));
snprintf(g_vbuff, CF_BUFSIZE, "%s_%s_%s",
g_vsysname.sysname, g_vsysname.machine, g_vsysname.release);
AddClassToHeap(CanonifyName(g_vbuff));
Verbose("Additional hard class defined as: %s\n", CanonifyName(g_vbuff));
#ifdef HAVE_SYSINFO
#ifdef SI_ARCHITECTURE
sz = sysinfo(SI_ARCHITECTURE, g_vbuff, CF_BUFSIZE);
if (sz == -1) {
Verbose("cfagent internal: sysinfo returned -1\n");
} else {
AddClassToHeap(CanonifyName(g_vbuff));
Verbose("Additional hard class defined as: %s\n", g_vbuff);
}
#endif
#endif
snprintf(g_vbuff, CF_BUFSIZE, "%s_%s_%s_%s",
g_vsysname.sysname, g_vsysname.machine, g_vsysname.release,
g_vsysname.version);
if (strlen(g_vbuff) < CF_MAXVARSIZE-2) {
g_varch = strdup(CanonifyName(g_vbuff));
} else {
Verbose("cfagent internal: $(arch) overflows CF_MAXVARSIZE! Truncating\n");
g_varch = strdup(CanonifyName(g_vsysname.sysname));
}
snprintf(g_vbuff, CF_BUFSIZE, "%s_%s",
g_vsysname.sysname, g_vsysname.machine);
g_varch2 = strdup(CanonifyName(g_vbuff));
AddClassToHeap(g_varch);
Verbose("Additional hard class defined as: %s\n", g_varch);
if (! found) {
CfLog(cferror,"Cfengine: I don't understand "
"what architecture this is!","");
}
strcpy(g_vbuff, "compiled_on_");
strcat(g_vbuff, CanonifyName(AUTOCONF_SYSNAME));
AddClassToHeap(CanonifyName(g_vbuff));
Verbose("\nGNU autoconf class from compile time: %s\n\n", g_vbuff);
/* Get IP address from nameserver */
if ((hp = gethostbyname(g_vsysname.nodename)) == NULL) {
return;
} else {
memset(&cin, 0, sizeof(cin));
cin.sin_addr.s_addr = ((struct in_addr *)(hp->h_addr))->s_addr;
Verbose("Address given by nameserver: %s\n", inet_ntoa(cin.sin_addr));
strcpy(g_vipaddress, inet_ntoa(cin.sin_addr));
for (i=0; hp->h_aliases[i] != NULL; i++) {
Debug("Adding alias %s..\n", hp->h_aliases[i]);
AddClassToHeap(CanonifyName(hp->h_aliases[i]));
}
}
}
/*
* _init_hw_clock - initializes the exported clock variables.
*/
void
_init_hw_clock(void)
{
__psunsigned_t phys_addr, raddr;
int cycsz;
int fd;
int poffmask;
unsigned int pico_per_clk;
void *clockaddr;
if (_init_hw_clock_called != 0)
return;
_init_hw_clock_called = 1;
/* register event handlers for checkpoint and restart.
* These are available at 6.4.
*/
if (atcheckpoint && atrestart) {
if (atcheckpoint(_u_sysclock_checkpoint) < 0) {
/* checkpoint registration failed,
* returns -1, errno = error
*/
return;
}
if (atrestart(_u_sysclock_restart) < 0) {
/* restart registration failed,
* returns -1, errno = error
*/
return;
}
}
/*
* Assume gettimeofday granularity for now.
*/
_fast_cycles_per_sec = 1000000.;
_nowrap_cycles_per_sec = 1000000.;
poffmask = getpagesize() - 1;
phys_addr = syssgi(SGI_QUERY_CYCLECNTR, &pico_per_clk);
cycsz = syssgi(SGI_CYCLECNTR_SIZE);
raddr = phys_addr & ~poffmask;
fd = open("/dev/mmem", O_RDONLY);
if (fd < 0) {
/* could not open /dev/mmem !! */
return;
}
clockaddr = mmap(0, poffmask, PROT_READ, MAP_PRIVATE, fd, (off_t)raddr);
if ((void*)clockaddr == MAP_FAILED) {
/* no HW clock */
return;
}
clockaddr = (void *)((__psunsigned_t)clockaddr + (phys_addr&poffmask));
if (cycsz == 64) {
_rtc_clockaddr = (long long *)clockaddr;
_rtc_clockaddr32 = (int *)clockaddr + 1;
_nowrap_cycles_per_sec =
1.0 / ( (double)pico_per_clk * 1.0e-12 );
}
else { /* if (cycsz == 32) */
_rtc_clockaddr32 = (int *)clockaddr;
}
_fast_cycles_per_sec = 1.0 / ( (double)pico_per_clk * 1.0e-12 );
}
int
main(
int argc,
char **argv)
{
xfs_fsop_geom_t geom;
struct fsxattr fsx;
struct dioattr dio;
char *pathname;
u_int buflen;
char *buf;
ssize_t offset;
ssize_t count;
int fd;
int i;
if (prog = strrchr(argv[0], '/')) {
*prog++;
} else {
prog = argv[0];
}
if (argc != 2)
Usage();
pathname = argv[1];
/* Create the file. */
if ((fd = open(pathname, O_RDWR|O_CREAT|O_EXCL|O_DIRECT, 0600)) < 0) {
fprintf(stderr,"%s: Cannot open %s, %s\n", prog,
pathname, strerror(errno));
exit(1);
}
/* Determine the filesystem's realtime partition geometry. */
if (syssgi(SGI_XFS_FSOPERATIONS, fd, XFS_FS_GEOMETRY, NULL, &geom)) {
fprintf(stderr,"%s: syssgi(,XFS_FS_GEOMETRY) failed, %s\n",
prog, strerror(errno));
exit(1);
}
/* Make the file a realtime file. */
fsx.fsx_xflags = 1; /*XFS_XFLAG_REALTIME*/
fsx.fsx_extsize = 4 * geom.blocksize * geom.rtextsize;
if (fcntl(fd, F_FSSETXATTR, &fsx) < 0) {
fprintf(stderr,"%s: fcntl(,F_FSSETXATTR) failed, %s\n", prog,
strerror(errno));
exit(1);
}
/* Obtain the direct I/O parameters. */
if (fcntl(fd, F_DIOINFO, &dio) < 0) {
fprintf(stderr,"%s: fcntl(,F_DIOINFO) failed,%s\n",
prog, strerror(errno));
exit(1);
}
fprintf(stdout, "%s: file %s direct io requirements.\n", prog,
pathname);
fprintf(stdout, "%7d memory alignment.\n", dio.d_mem);
fprintf(stdout, "%7d minimum io size.\n", dio.d_miniosz);
fprintf(stdout, "%7d maximum io size.\n", dio.d_maxiosz);
if (fcntl(fd, F_FSGETXATTR, &fsx) < 0) {
fprintf(stderr,"%s: fcntl(,F_FSGETXATTR) failed, %s\n", prog,
strerror(errno));
exit(1);
}
fprintf(stdout, "%7d realtime extent size.\n", fsx.fsx_extsize);
/* Malloc and zero a buffer to use for writes. */
buflen = dio.d_miniosz;
if ((buf = memalign(dio.d_mem, buflen)) == NULL) {
fprintf(stderr,"%s: memalign(%d,%d) returned NULL\n",
prog, dio.d_mem, buflen);
exit(1);
}
memset(buf, '\0', buflen);
for (i = 0; i < 10; i += 2) {
offset = i * fsx.fsx_extsize;
if (lseek(fd, offset, SEEK_SET) < 0) {
fprintf(stderr, "seek to %d failed, %s\n", offset,
strerror(errno));
exit(1);
}
if ((count = write(fd, buf, buflen)) < 0) {
fprintf(stderr, "write of %d bytes failed at offset "
"%d, , %s\n", buflen, offset, strerror(errno));
exit(1);
}
if (count != buflen) {
fprintf(stderr, "expected to write %d bytes at offset "
"%d, actually wrote %d\n", buflen, offset,
count);
exit(1);
}
}
exit(0);
}
Elf32_Addr
elfmap(char *path, int infd, int opts) {
int numloadseg = 0, i;
Elf32_Ehdr *pEhdr;
Elf32_Phdr *pPhdr;
Elf32_Phdr *pPload=0, *ptr_first_text_page=0, *pPtemp;
em_environ e;
void *baseaddr;
long map_diff;
if (!infd && !path) {
error("No file specified.");
return( _EM_ERROR );
}
if (!infd) {
/* Open file */
DPRINTF("elfmap: opening file %s, opt = 0x%x\n", path, opts);
e.state = INITIAL_STATE;
if ((infd = open(path, O_RDONLY)) == -1) {
if (!(_EM_SILENT&opts)) perror("elfmap");
cleanup(&e, 0, 0);
return(_EM_ERROR);
}
}
e.state = FILE_OPEN;
e.infd = infd;
e.options = opts;
/* Read and verify Elf Header */
DPRINTF("elfmap: reading ELF header.\n");
pEhdr = getEhdr(&e);
if (e.state != EH_SUCCESS) {
cleanup(&e, pEhdr, 0);
return(_EM_ERROR);
}
/* Read program header */
DPRINTF("elfmap: reading program header\n");
pPhdr = getPhdr(pEhdr, &e);
if (e.state != PH_SUCCESS) {
error("Couldn't read Program header in %s.", path);
cleanup(&e, pEhdr, pPhdr);
return( _EM_ERROR );
}
#ifndef OLD_SYSCALL
if ((pPload = (Elf32_Phdr *)malloc(pEhdr->e_phnum * sizeof(Elf32_Phdr))) == NULL)
error ("elfmap: cannot malloc for pPload");
for (i = 0; i<pEhdr->e_phnum; i++) {
if (pPhdr[i].p_type == PT_LOAD) {
memcpy(&pPload[numloadseg], &pPhdr[i], sizeof(Elf32_Phdr));
numloadseg++;
}
}
if (numloadseg == 0) {
error("elfmap: no PT_LOAD segment found in %s.", path);
cleanup(&e, pEhdr, pPhdr);
return(_EM_ERROR);
}
baseaddr = (void *) syssgi(SGI_ELFMAP, e.infd, pPload, numloadseg);
if ((long)baseaddr < 0) {
error("elfmap: couldn't map file %s -- error code %d.", path, errno);
cleanup(&e, pEhdr, pPhdr);
return(_EM_ERROR);
}
/* success! */
/* Now we need to find the real ELF header. This is complicated by the
* fact that it ain't necessarily at the beginning of the first segment,
* but rather is at the beginning of the segment which starts at offset
* 0 in the file. If no such offset, punt.
*/
map_diff = (long) baseaddr - (long)pPload->p_vaddr;
pPtemp = pPload;
for (i = 0; i < numloadseg; i++) {
if ((ptr_first_text_page == 0) || (pPtemp->p_offset < ptr_first_text_page->p_offset)) {
if (pPtemp->p_flags & (PF_X)) /* text segment */
ptr_first_text_page = pPtemp;
}
pPtemp++;
}
baseaddr = (void *)((ptr_first_text_page->p_vaddr) +
map_diff - ptr_first_text_page->p_offset);
free(pPload);
#else
DPRINTF("elfmap: allocating isMapped array\n");
e.isMapped = (int *) calloc(pEhdr->e_phnum, sizeof(int));
if (e.isMapped == NULL) {
cleanup(&e, pEhdr, pPhdr);
return( _EM_ERROR );
}
e.state = ISMAP_ALLOC;
/* Map the segments */
DPRINTF("elfmap: mapping segments\n");
mapSegs(pEhdr, pPhdr, &e);
if (e.state != MAP_SUCCESS) {
baseaddr = (void *) _EM_ERROR;
} else {
baseaddr = e.retval;
}
#endif
cleanup(&e, pEhdr, pPhdr);
return((Elf32_Addr) baseaddr);
}
