1995-05-11 01:02:23 +00:00
|
|
|
|
/* Operating system support for run-time dynamic linker. Hurd version.
|
|
|
|
|
Copyright (C) 1995 Free Software Foundation, Inc.
|
|
|
|
|
This file is part of the GNU C Library.
|
|
|
|
|
|
|
|
|
|
The GNU C Library is free software; you can redistribute it and/or
|
|
|
|
|
modify it under the terms of the GNU Library General Public License as
|
|
|
|
|
published by the Free Software Foundation; either version 2 of the
|
|
|
|
|
License, or (at your option) any later version.
|
|
|
|
|
|
|
|
|
|
The GNU C Library is distributed in the hope that it will be useful,
|
|
|
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
|
|
Library General Public License for more details.
|
|
|
|
|
|
|
|
|
|
You should have received a copy of the GNU Library General Public
|
|
|
|
|
License along with the GNU C Library; see the file COPYING.LIB. If
|
|
|
|
|
not, write to the Free Software Foundation, Inc., 675 Mass Ave,
|
|
|
|
|
Cambridge, MA 02139, USA. */
|
|
|
|
|
|
|
|
|
|
#include <hurd.h>
|
|
|
|
|
#include <link.h>
|
|
|
|
|
#include <unistd.h>
|
|
|
|
|
#include <fcntl.h>
|
|
|
|
|
#include <stdlib.h>
|
|
|
|
|
#include <sys/mman.h>
|
|
|
|
|
#include <sys/wait.h>
|
|
|
|
|
#include <assert.h>
|
|
|
|
|
#include <sysdep.h>
|
|
|
|
|
#include <mach/mig_support.h>
|
|
|
|
|
#include "hurdstartup.h"
|
|
|
|
|
#include <mach/host_info.h>
|
|
|
|
|
#include "../stdio/_itoa.h"
|
|
|
|
|
#include <hurd/auth.h>
|
|
|
|
|
#include <hurd/term.h>
|
|
|
|
|
#include <stdarg.h>
|
|
|
|
|
|
|
|
|
|
#include "dl-machine.h"
|
|
|
|
|
|
1995-05-31 13:23:14 +00:00
|
|
|
|
extern void __mach_init (void);
|
|
|
|
|
|
1995-05-11 01:02:23 +00:00
|
|
|
|
extern int _dl_argc;
|
|
|
|
|
extern char **_dl_argv;
|
|
|
|
|
extern char **_environ;
|
|
|
|
|
|
|
|
|
|
struct hurd_startup_data *_dl_hurd_data;
|
|
|
|
|
|
1995-06-08 09:00:23 +00:00
|
|
|
|
unsigned int __hurd_threadvar_max = _HURD_THREADVAR_MAX;
|
|
|
|
|
static unsigned long int threadvars[_HURD_THREADVAR_MAX];
|
|
|
|
|
unsigned long int __hurd_threadvar_stack_offset
|
|
|
|
|
= (unsigned long int) &threadvars;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* XXX loser kludge for vm_map kernel bug */
|
|
|
|
|
static vm_address_t fmha;
|
|
|
|
|
static vm_size_t fmhs;
|
|
|
|
|
static void unfmh(){
|
|
|
|
|
__vm_deallocate(__mach_task_self(),fmha,fmhs);}
|
|
|
|
|
static void fmh() {
|
|
|
|
|
error_t err;int x;mach_port_t p;
|
|
|
|
|
vm_address_t a=0x08000000U,max=VM_MAX_ADDRESS;
|
|
|
|
|
while (!(err=__vm_region(__mach_task_self(),&a,&fmhs,&x,&x,&x,&x,&p,&x))){
|
|
|
|
|
__mach_port_deallocate(__mach_task_self(),p);
|
|
|
|
|
if (a+fmhs>=0x80000000U){
|
1995-07-10 09:40:15 +00:00
|
|
|
|
max=a; break;}
|
1995-06-08 09:00:23 +00:00
|
|
|
|
fmha=a+=fmhs;}
|
|
|
|
|
if (err) assert(err==KERN_NO_SPACE);
|
1995-07-10 09:40:15 +00:00
|
|
|
|
if (!fmha)fmhs=0;else{
|
1995-06-08 09:00:23 +00:00
|
|
|
|
fmhs=max-fmha;
|
|
|
|
|
err = __vm_map (__mach_task_self (),
|
|
|
|
|
&fmha, fmhs, 0, 0, MACH_PORT_NULL, 0, 1,
|
|
|
|
|
VM_PROT_NONE, VM_PROT_NONE, VM_INHERIT_COPY);
|
1995-07-10 09:40:15 +00:00
|
|
|
|
assert_perror(err);}
|
1995-06-08 09:00:23 +00:00
|
|
|
|
}
|
|
|
|
|
/* XXX loser kludge for vm_map kernel bug */
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
1995-05-11 01:02:23 +00:00
|
|
|
|
Elf32_Addr
|
|
|
|
|
_dl_sysdep_start (void **start_argptr,
|
|
|
|
|
void (*dl_main) (const Elf32_Phdr *phdr, Elf32_Word phent,
|
|
|
|
|
Elf32_Addr *user_entry))
|
|
|
|
|
{
|
1995-09-30 21:18:30 +00:00
|
|
|
|
extern void _start ();
|
|
|
|
|
|
1995-05-11 01:02:23 +00:00
|
|
|
|
void go (int *argdata)
|
|
|
|
|
{
|
1995-09-30 21:18:30 +00:00
|
|
|
|
extern unsigned int _dl_skip_args; /* rtld.c */
|
1995-05-11 01:02:23 +00:00
|
|
|
|
char **p;
|
|
|
|
|
|
|
|
|
|
/* Cache the information in various global variables. */
|
1995-05-31 13:23:14 +00:00
|
|
|
|
_dl_argc = *argdata;
|
1995-09-30 21:18:30 +00:00
|
|
|
|
_dl_argv = 1 + (char **) argdata;
|
1995-05-11 01:02:23 +00:00
|
|
|
|
_environ = &_dl_argv[_dl_argc + 1];
|
1995-09-30 21:18:30 +00:00
|
|
|
|
for (p = _environ; *p++;); /* Skip environ pointers and terminator. */
|
|
|
|
|
|
|
|
|
|
if ((void *) p == _dl_argv[0])
|
|
|
|
|
{
|
|
|
|
|
static struct hurd_startup_data nodata;
|
|
|
|
|
_dl_hurd_data = &nodata;
|
|
|
|
|
nodata.user_entry = (vm_address_t) &_start;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
_dl_hurd_data = (void *) p;
|
1995-05-11 01:02:23 +00:00
|
|
|
|
|
|
|
|
|
_dl_secure = _dl_hurd_data->flags & EXEC_SECURE;
|
|
|
|
|
|
1995-06-08 09:00:23 +00:00
|
|
|
|
unfmh(); /* XXX */
|
1995-09-30 21:18:30 +00:00
|
|
|
|
|
|
|
|
|
if (_dl_hurd_data->user_entry == (vm_address_t) &_start)
|
|
|
|
|
/* We were invoked as a command, not as the program interpreter.
|
|
|
|
|
The generic ld.so code supports this: it will parse the args
|
|
|
|
|
as "ld.so PROGRAM [ARGS...]". For booting the Hurd, we
|
|
|
|
|
support an additional special syntax:
|
|
|
|
|
ld.so [-LIBS...] PROGRAM [ARGS...]
|
|
|
|
|
Each LIBS word consists of "FILENAME=MEMOBJ";
|
|
|
|
|
for example "-/lib/libc.so=123" says that the contents of
|
|
|
|
|
/lib/libc.so are found in a memory object whose port name
|
|
|
|
|
in our task is 123. */
|
1995-10-05 09:00:06 +00:00
|
|
|
|
while (_dl_argc > 2 && _dl_argv[1][0] == '-' && _dl_argv[1][1] != '-')
|
1995-09-30 21:18:30 +00:00
|
|
|
|
{
|
|
|
|
|
char *lastslash, *memobjname, *p;
|
|
|
|
|
struct link_map *l;
|
|
|
|
|
mach_port_t memobj;
|
|
|
|
|
error_t err;
|
|
|
|
|
|
|
|
|
|
++_dl_skip_args;
|
|
|
|
|
--_dl_argc;
|
|
|
|
|
p = _dl_argv++[1] + 1;
|
|
|
|
|
|
|
|
|
|
memobjname = strchr (p, '=');
|
|
|
|
|
if (! memobjname)
|
|
|
|
|
_dl_sysdep_fatal ("Bogus library spec: ", p, "\n", NULL);
|
|
|
|
|
*memobjname++ = '\0';
|
|
|
|
|
memobj = (mach_port_t) atoi (memobjname);
|
|
|
|
|
|
|
|
|
|
/* Add a user reference on the memory object port, so we will
|
|
|
|
|
still have one after _dl_map_object_from_fd calls our
|
|
|
|
|
`close'. */
|
|
|
|
|
err = __mach_port_mod_refs (__mach_task_self (), memobj,
|
|
|
|
|
MACH_PORT_RIGHT_SEND, +1);
|
|
|
|
|
assert_perror (err);
|
|
|
|
|
|
|
|
|
|
lastslash = strrchr (p, '/');
|
|
|
|
|
l = _dl_map_object_from_fd (lastslash ? lastslash + 1 : p,
|
|
|
|
|
memobj, strdup (p));
|
|
|
|
|
|
|
|
|
|
/* Squirrel away the memory object port where it
|
|
|
|
|
can be retrieved by the program later. */
|
|
|
|
|
l->l_info[DT_NULL] = (void *) memobj;
|
|
|
|
|
}
|
|
|
|
|
|
1995-05-11 01:02:23 +00:00
|
|
|
|
/* Call elf/rtld.c's main program. It will set everything
|
|
|
|
|
up and leave us to transfer control to USER_ENTRY. */
|
|
|
|
|
(*dl_main) ((const Elf32_Phdr *) _dl_hurd_data->phdr,
|
|
|
|
|
_dl_hurd_data->phdrsz / sizeof (Elf32_Phdr),
|
|
|
|
|
&_dl_hurd_data->user_entry);
|
|
|
|
|
|
1995-05-31 13:23:14 +00:00
|
|
|
|
/* Deallocate the reply port and task port rights acquired by
|
|
|
|
|
__mach_init. We are done with them now, and the user will
|
|
|
|
|
reacquire them for himself when he wants them. */
|
|
|
|
|
__mig_dealloc_reply_port (MACH_PORT_NULL);
|
|
|
|
|
__mach_port_deallocate (__mach_task_self (), __mach_task_self_);
|
|
|
|
|
|
1995-09-30 21:18:30 +00:00
|
|
|
|
if (_dl_skip_args && _dl_argv[-_dl_skip_args] == (char *) p)
|
|
|
|
|
{
|
|
|
|
|
/* We are ignoring the first few arguments, but we have no Hurd
|
|
|
|
|
startup data. It is magical convention that ARGV[0] == P in
|
|
|
|
|
this case. The startup code in init-first.c will get confused
|
|
|
|
|
if this is not the case, so we must rearrange things to make
|
|
|
|
|
it so. Overwrite the original ARGV[0] at P with
|
|
|
|
|
ARGV[_dl_skip_args]. */
|
|
|
|
|
assert ((char *) p < _dl_argv[0]);
|
|
|
|
|
_dl_argv[0] = strcpy ((char *) p, _dl_argv[0]);
|
|
|
|
|
}
|
|
|
|
|
|
1995-05-11 01:02:23 +00:00
|
|
|
|
{
|
|
|
|
|
extern void _dl_start_user (void);
|
|
|
|
|
/* Unwind the stack to ARGDATA and simulate a return from _dl_start
|
|
|
|
|
to the RTLD_START code which will run the user's entry point. */
|
|
|
|
|
RETURN_TO (argdata, &_dl_start_user, _dl_hurd_data->user_entry);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
1995-05-31 13:23:14 +00:00
|
|
|
|
/* Set up so we can do RPCs. */
|
|
|
|
|
__mach_init ();
|
|
|
|
|
|
1995-06-08 09:00:23 +00:00
|
|
|
|
fmh(); /* XXX */
|
|
|
|
|
|
1995-05-11 01:02:23 +00:00
|
|
|
|
/* See hurd/hurdstartup.c; this deals with getting information
|
|
|
|
|
from the exec server and slicing up the arguments.
|
|
|
|
|
Then it will call `go', above. */
|
|
|
|
|
_hurd_startup (start_argptr, &go);
|
|
|
|
|
|
|
|
|
|
LOSE;
|
1995-08-14 22:49:23 +00:00
|
|
|
|
abort ();
|
1995-05-11 01:02:23 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int
|
|
|
|
|
_dl_sysdep_open_zero_fill (void)
|
|
|
|
|
{
|
|
|
|
|
return (int) MACH_PORT_NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
_dl_sysdep_fatal (const char *msg, ...)
|
|
|
|
|
{
|
|
|
|
|
va_list ap;
|
|
|
|
|
|
|
|
|
|
va_start (ap, msg);
|
|
|
|
|
do
|
|
|
|
|
{
|
|
|
|
|
size_t len = strlen (msg);
|
|
|
|
|
mach_msg_type_number_t nwrote;
|
|
|
|
|
do
|
|
|
|
|
{
|
1995-08-14 22:49:23 +00:00
|
|
|
|
if (__io_write (_hurd_init_dtable[2], msg, len, -1, &nwrote))
|
1995-05-11 01:02:23 +00:00
|
|
|
|
break;
|
|
|
|
|
len -= nwrote;
|
|
|
|
|
msg += nwrote;
|
|
|
|
|
} while (nwrote > 0);
|
|
|
|
|
msg = va_arg (ap, const char *);
|
|
|
|
|
} while (msg);
|
|
|
|
|
va_end (ap);
|
|
|
|
|
|
|
|
|
|
_exit (127);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
1995-10-05 09:00:06 +00:00
|
|
|
|
void
|
|
|
|
|
_dl_sysdep_message (const char *msg, ...)
|
|
|
|
|
{
|
|
|
|
|
va_list ap;
|
|
|
|
|
|
|
|
|
|
va_start (ap, msg);
|
|
|
|
|
do
|
|
|
|
|
{
|
|
|
|
|
size_t len = strlen (msg);
|
|
|
|
|
mach_msg_type_number_t nwrote;
|
|
|
|
|
do
|
|
|
|
|
{
|
|
|
|
|
if (__io_write (_hurd_init_dtable[1], msg, len, -1, &nwrote))
|
|
|
|
|
break;
|
|
|
|
|
len -= nwrote;
|
|
|
|
|
msg += nwrote;
|
|
|
|
|
} while (nwrote > 0);
|
|
|
|
|
msg = va_arg (ap, const char *);
|
|
|
|
|
} while (msg);
|
|
|
|
|
va_end (ap);
|
|
|
|
|
}
|
|
|
|
|
|
1995-05-11 01:02:23 +00:00
|
|
|
|
/* Minimal open/close/mmap implementation sufficient for initial loading of
|
|
|
|
|
shared libraries. These are weak definitions so that when the
|
|
|
|
|
dynamic linker re-relocates itself to be user-visible (for -ldl),
|
|
|
|
|
it will get the user's definition (i.e. usually libc's). */
|
|
|
|
|
|
|
|
|
|
int
|
|
|
|
|
open (const char *file_name, int mode, ...)
|
|
|
|
|
{
|
|
|
|
|
enum retry_type doretry;
|
|
|
|
|
char retryname[1024]; /* XXX string_t LOSES! */
|
|
|
|
|
file_t startdir, newpt, fileport;
|
|
|
|
|
int dealloc_dir;
|
|
|
|
|
int nloops;
|
1995-10-09 07:06:29 +00:00
|
|
|
|
error_t err;
|
1995-05-11 01:02:23 +00:00
|
|
|
|
|
|
|
|
|
assert (mode == O_RDONLY);
|
|
|
|
|
|
|
|
|
|
startdir = _dl_hurd_data->portarray[file_name[0] == '/' ?
|
|
|
|
|
INIT_PORT_CRDIR : INIT_PORT_CWDIR];
|
|
|
|
|
|
|
|
|
|
while (file_name[0] == '/')
|
|
|
|
|
file_name++;
|
|
|
|
|
|
1995-10-09 07:06:29 +00:00
|
|
|
|
if (err = __dir_lookup (startdir, file_name, mode, 0,
|
|
|
|
|
&doretry, retryname, &fileport))
|
|
|
|
|
return __hurd_fail (err);
|
1995-05-11 01:02:23 +00:00
|
|
|
|
|
|
|
|
|
dealloc_dir = 0;
|
|
|
|
|
nloops = 0;
|
|
|
|
|
|
|
|
|
|
while (1)
|
|
|
|
|
{
|
|
|
|
|
if (dealloc_dir)
|
|
|
|
|
__mach_port_deallocate (__mach_task_self (), startdir);
|
1995-10-09 07:06:29 +00:00
|
|
|
|
if (err)
|
|
|
|
|
return __hurd_fail (err);
|
1995-05-11 01:02:23 +00:00
|
|
|
|
|
|
|
|
|
switch (doretry)
|
|
|
|
|
{
|
|
|
|
|
case FS_RETRY_REAUTH:
|
|
|
|
|
{
|
|
|
|
|
mach_port_t ref = __mach_reply_port ();
|
1995-10-09 07:06:29 +00:00
|
|
|
|
err = __io_reauthenticate (fileport, ref, MACH_MSG_TYPE_MAKE_SEND);
|
|
|
|
|
if (! err)
|
|
|
|
|
err = __auth_user_authenticate
|
1995-05-11 01:02:23 +00:00
|
|
|
|
(_dl_hurd_data->portarray[INIT_PORT_AUTH],
|
|
|
|
|
fileport,
|
|
|
|
|
ref, MACH_MSG_TYPE_MAKE_SEND,
|
|
|
|
|
&newpt);
|
|
|
|
|
__mach_port_destroy (__mach_task_self (), ref);
|
|
|
|
|
}
|
|
|
|
|
__mach_port_deallocate (__mach_task_self (), fileport);
|
1995-10-09 07:06:29 +00:00
|
|
|
|
if (err)
|
|
|
|
|
return __hurd_fail (err);
|
1995-05-11 01:02:23 +00:00
|
|
|
|
fileport = newpt;
|
|
|
|
|
/* Fall through. */
|
|
|
|
|
|
|
|
|
|
case FS_RETRY_NORMAL:
|
|
|
|
|
#ifdef SYMLOOP_MAX
|
|
|
|
|
if (nloops++ >= SYMLOOP_MAX)
|
1995-10-09 07:06:29 +00:00
|
|
|
|
return __hurd_fail (ELOOP);
|
1995-05-11 01:02:23 +00:00
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
/* An empty RETRYNAME indicates we have the final port. */
|
|
|
|
|
if (retryname[0] == '\0')
|
|
|
|
|
{
|
|
|
|
|
mach_port_t memobj_rd, memobj_wr;
|
|
|
|
|
|
|
|
|
|
dealloc_dir = 1;
|
|
|
|
|
|
|
|
|
|
opened:
|
|
|
|
|
/* We have the file open. Now map it. */
|
1995-10-09 07:06:29 +00:00
|
|
|
|
err = __io_map (fileport, &memobj_rd, &memobj_wr);
|
1995-05-11 01:02:23 +00:00
|
|
|
|
if (dealloc_dir)
|
|
|
|
|
__mach_port_deallocate (__mach_task_self (), fileport);
|
1995-10-09 07:06:29 +00:00
|
|
|
|
if (err)
|
|
|
|
|
return __hurd_fail (err);
|
1995-05-11 01:02:23 +00:00
|
|
|
|
if (memobj_wr != MACH_PORT_NULL)
|
|
|
|
|
__mach_port_deallocate (__mach_task_self (), memobj_wr);
|
|
|
|
|
|
|
|
|
|
return (int) memobj_rd;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
startdir = fileport;
|
|
|
|
|
dealloc_dir = 1;
|
|
|
|
|
file_name = retryname;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case FS_RETRY_MAGICAL:
|
|
|
|
|
switch (retryname[0])
|
|
|
|
|
{
|
|
|
|
|
case '/':
|
|
|
|
|
startdir = _dl_hurd_data->portarray[INIT_PORT_CRDIR];
|
|
|
|
|
dealloc_dir = 0;
|
|
|
|
|
if (fileport != MACH_PORT_NULL)
|
|
|
|
|
__mach_port_deallocate (__mach_task_self (), fileport);
|
|
|
|
|
file_name = &retryname[1];
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case 'f':
|
|
|
|
|
if (retryname[1] == 'd' && retryname[2] == '/')
|
|
|
|
|
{
|
|
|
|
|
int fd;
|
|
|
|
|
char *end;
|
1995-10-09 07:06:29 +00:00
|
|
|
|
err = 0;
|
1995-05-11 01:02:23 +00:00
|
|
|
|
fd = (int) strtol (retryname, &end, 10);
|
1995-10-09 07:06:29 +00:00
|
|
|
|
if (end == NULL || err || /* Malformed number. */
|
1995-05-11 01:02:23 +00:00
|
|
|
|
/* Check for excess text after the number. A slash
|
|
|
|
|
is valid; it ends the component. Anything else
|
|
|
|
|
does not name a numeric file descriptor. */
|
|
|
|
|
(*end != '/' && *end != '\0'))
|
1995-10-09 07:06:29 +00:00
|
|
|
|
return __hurd_fail (ENOENT);
|
1995-05-11 01:02:23 +00:00
|
|
|
|
if (fd < 0 || fd >= _dl_hurd_data->dtablesize ||
|
|
|
|
|
_dl_hurd_data->dtable[fd] == MACH_PORT_NULL)
|
1995-10-09 07:06:29 +00:00
|
|
|
|
/* If the name was a proper number, but the file
|
|
|
|
|
descriptor does not exist, we return EBADF instead
|
|
|
|
|
of ENOENT. */
|
|
|
|
|
return __hurd_fail (EBADF);
|
1995-05-11 01:02:23 +00:00
|
|
|
|
fileport = _dl_hurd_data->dtable[fd];
|
|
|
|
|
if (*end == '\0')
|
|
|
|
|
{
|
|
|
|
|
/* This descriptor is the file port we want. */
|
|
|
|
|
dealloc_dir = 0;
|
|
|
|
|
goto opened;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
/* Do a normal retry on the remaining components. */
|
|
|
|
|
startdir = fileport;
|
|
|
|
|
dealloc_dir = 1;
|
|
|
|
|
file_name = end + 1; /* Skip the slash. */
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
goto bad_magic;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case 'm':
|
|
|
|
|
if (retryname[1] == 'a' && retryname[2] == 'c' &&
|
|
|
|
|
retryname[3] == 'h' && retryname[4] == 't' &&
|
|
|
|
|
retryname[5] == 'y' && retryname[6] == 'p' &&
|
|
|
|
|
retryname[7] == 'e')
|
|
|
|
|
{
|
|
|
|
|
error_t err;
|
|
|
|
|
struct host_basic_info hostinfo;
|
|
|
|
|
mach_msg_type_number_t hostinfocnt = HOST_BASIC_INFO_COUNT;
|
|
|
|
|
char *p;
|
|
|
|
|
if (err = __host_info (__mach_host_self (), HOST_BASIC_INFO,
|
|
|
|
|
(natural_t *) &hostinfo,
|
|
|
|
|
&hostinfocnt))
|
|
|
|
|
return err;
|
|
|
|
|
if (hostinfocnt != HOST_BASIC_INFO_COUNT)
|
|
|
|
|
return EGRATUITOUS;
|
|
|
|
|
p = _itoa (hostinfo.cpu_subtype, &retryname[8], 10, 0);
|
|
|
|
|
*--p = '/';
|
|
|
|
|
p = _itoa (hostinfo.cpu_type, &retryname[8], 10, 0);
|
|
|
|
|
if (p < retryname)
|
|
|
|
|
abort (); /* XXX write this right if this ever happens */
|
|
|
|
|
if (p > retryname)
|
|
|
|
|
strcpy (retryname, p);
|
|
|
|
|
startdir = fileport;
|
|
|
|
|
dealloc_dir = 1;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
goto bad_magic;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case 't':
|
|
|
|
|
if (retryname[1] == 't' && retryname[2] == 'y')
|
|
|
|
|
switch (retryname[3])
|
|
|
|
|
{
|
|
|
|
|
error_t opentty (file_t *result)
|
|
|
|
|
{
|
|
|
|
|
error_t err;
|
|
|
|
|
file_t unauth;
|
|
|
|
|
err = __termctty_open_terminal
|
|
|
|
|
(_dl_hurd_data->portarray[INIT_PORT_CTTYID],
|
|
|
|
|
mode, &unauth);
|
|
|
|
|
if (! err)
|
|
|
|
|
{
|
|
|
|
|
mach_port_t ref = __mach_reply_port ();
|
1995-08-14 22:49:23 +00:00
|
|
|
|
err = __io_reauthenticate
|
1995-05-11 01:02:23 +00:00
|
|
|
|
(unauth, ref, MACH_MSG_TYPE_MAKE_SEND);
|
|
|
|
|
if (! err)
|
|
|
|
|
err = __auth_user_authenticate
|
|
|
|
|
(_dl_hurd_data->portarray[INIT_PORT_AUTH],
|
|
|
|
|
unauth,
|
|
|
|
|
ref, MACH_MSG_TYPE_MAKE_SEND,
|
|
|
|
|
result);
|
|
|
|
|
__mach_port_deallocate (__mach_task_self (),
|
|
|
|
|
unauth);
|
|
|
|
|
__mach_port_destroy (__mach_task_self (), ref);
|
|
|
|
|
}
|
|
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
case '\0':
|
1995-10-09 07:06:29 +00:00
|
|
|
|
if (err = opentty (&fileport))
|
|
|
|
|
return __hurd_fail (err);
|
1995-05-11 01:02:23 +00:00
|
|
|
|
dealloc_dir = 1;
|
|
|
|
|
goto opened;
|
|
|
|
|
case '/':
|
1995-10-09 07:06:29 +00:00
|
|
|
|
if (err = opentty (&startdir))
|
|
|
|
|
return __hurd_fail (err);
|
1995-05-11 01:02:23 +00:00
|
|
|
|
dealloc_dir = 1;
|
|
|
|
|
strcpy (retryname, &retryname[4]);
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
goto bad_magic;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
goto bad_magic;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
default:
|
|
|
|
|
bad_magic:
|
1995-10-09 07:06:29 +00:00
|
|
|
|
return __hurd_fail (EGRATUITOUS);
|
1995-05-11 01:02:23 +00:00
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
default:
|
1995-10-09 07:06:29 +00:00
|
|
|
|
return __hurd_fail (EGRATUITOUS);
|
1995-05-11 01:02:23 +00:00
|
|
|
|
}
|
|
|
|
|
|
1995-10-09 07:06:29 +00:00
|
|
|
|
err = __dir_lookup (startdir, file_name, mode, 0,
|
|
|
|
|
&doretry, retryname, &fileport);
|
1995-05-11 01:02:23 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int
|
|
|
|
|
close (int fd)
|
|
|
|
|
{
|
|
|
|
|
if (fd != (int) MACH_PORT_NULL)
|
|
|
|
|
__mach_port_deallocate (__mach_task_self (), (mach_port_t) fd);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
caddr_t
|
|
|
|
|
mmap (caddr_t addr, size_t len, int prot, int flags, int fd, off_t offset)
|
|
|
|
|
{
|
1995-10-09 07:06:29 +00:00
|
|
|
|
error_t err;
|
1995-05-11 01:02:23 +00:00
|
|
|
|
vm_prot_t vmprot;
|
|
|
|
|
vm_address_t mapaddr;
|
|
|
|
|
|
|
|
|
|
vmprot = VM_PROT_NONE;
|
|
|
|
|
if (prot & PROT_READ)
|
|
|
|
|
vmprot |= VM_PROT_READ;
|
|
|
|
|
if (prot & PROT_WRITE)
|
|
|
|
|
vmprot |= VM_PROT_WRITE;
|
|
|
|
|
if (prot & PROT_EXEC)
|
|
|
|
|
vmprot |= VM_PROT_EXECUTE;
|
|
|
|
|
|
|
|
|
|
mapaddr = (vm_address_t) addr;
|
1995-10-09 07:06:29 +00:00
|
|
|
|
err = __vm_map (__mach_task_self (),
|
|
|
|
|
&mapaddr, (vm_size_t) len, 0 /*ELF_MACHINE_USER_ADDRESS_MASK*/,
|
|
|
|
|
!(flags & MAP_FIXED),
|
|
|
|
|
(mach_port_t) fd, (vm_offset_t) offset,
|
|
|
|
|
flags & (MAP_COPY|MAP_PRIVATE),
|
|
|
|
|
vmprot, VM_PROT_ALL,
|
|
|
|
|
(flags & MAP_INHERIT) ? VM_INHERIT_COPY : VM_INHERIT_NONE);
|
|
|
|
|
return err ? (caddr_t) __hurd_fail (err) : (caddr_t) mapaddr;
|
1995-05-11 01:02:23 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
_exit (int status)
|
|
|
|
|
{
|
1995-08-14 22:49:23 +00:00
|
|
|
|
__proc_mark_exit (_dl_hurd_data->portarray[INIT_PORT_PROC],
|
|
|
|
|
W_EXITCODE (status, 0));
|
1995-05-11 01:02:23 +00:00
|
|
|
|
while (__task_terminate (__mach_task_self ()))
|
|
|
|
|
__mach_task_self_ = (__mach_task_self) ();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
weak_symbol (_exit)
|
|
|
|
|
weak_symbol (open)
|
|
|
|
|
weak_symbol (close)
|
|
|
|
|
weak_symbol (mmap)
|
|
|
|
|
|
|
|
|
|
/* Minimal `malloc' allocator for use while loading shared libraries.
|
|
|
|
|
Only small blocks are allocated, and none are ever freed. */
|
|
|
|
|
|
|
|
|
|
void *
|
|
|
|
|
malloc (size_t n)
|
|
|
|
|
{
|
|
|
|
|
static vm_address_t ptr, end;
|
|
|
|
|
void *block;
|
|
|
|
|
|
|
|
|
|
if (end == 0)
|
|
|
|
|
{
|
|
|
|
|
/* Consume any unused space in the last page of our data segment. */
|
|
|
|
|
extern char _end;
|
|
|
|
|
ptr = (vm_address_t) &_end;
|
|
|
|
|
end = round_page (ptr);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Make sure the allocation pointer is ideally aligned. */
|
|
|
|
|
ptr += sizeof (double) - 1;
|
|
|
|
|
ptr &= ~(sizeof (double) - 1);
|
|
|
|
|
|
|
|
|
|
if (ptr + n >= end)
|
|
|
|
|
{
|
|
|
|
|
/* Insufficient space left; allocate another page. */
|
|
|
|
|
vm_address_t page;
|
|
|
|
|
assert (n <= __vm_page_size);
|
|
|
|
|
__vm_allocate (__mach_task_self (), &page, __vm_page_size, 1);
|
|
|
|
|
if (page != end)
|
|
|
|
|
ptr = page;
|
|
|
|
|
end = page + __vm_page_size;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
block = (void *) ptr;
|
|
|
|
|
ptr += n;
|
|
|
|
|
return block;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
weak_symbol (malloc)
|
|
|
|
|
|
|
|
|
|
/* These should never be called. */
|
|
|
|
|
void *realloc (void *ptr, size_t n) { ptr += n; abort (); }
|
|
|
|
|
void free (void *ptr) { ptr = ptr; abort (); }
|
|
|
|
|
weak_symbol (realloc)
|
|
|
|
|
weak_symbol (free)
|
|
|
|
|
|
|
|
|
|
/* Avoid signal frobnication in setjmp/longjmp. */
|
|
|
|
|
|
|
|
|
|
int __sigjmp_save (sigjmp_buf env, int savemask)
|
|
|
|
|
{ env[0].__mask_was_saved = savemask; return 0; }
|
|
|
|
|
weak_symbol (__sigjmp_save)
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
longjmp (jmp_buf env, int val) { __longjmp (env[0].__jmpbuf, val); }
|
|
|
|
|
weak_symbol (longjmp)
|
|
|
|
|
|
|
|
|
|
|
1995-08-14 22:49:23 +00:00
|
|
|
|
/* This function is called by interruptible RPC stubs. For initial
|
|
|
|
|
dynamic linking, just use the normal mach_msg. Since this defn is
|
1995-05-11 01:02:23 +00:00
|
|
|
|
weak, the real defn in libc.so will override it if we are linked into
|
|
|
|
|
the user program (-ldl). */
|
1995-08-14 22:49:23 +00:00
|
|
|
|
|
|
|
|
|
error_t
|
|
|
|
|
_hurd_intr_rpc_mach_msg (mach_msg_header_t *msg,
|
|
|
|
|
mach_msg_option_t option,
|
|
|
|
|
mach_msg_size_t send_size,
|
|
|
|
|
mach_msg_size_t rcv_size,
|
|
|
|
|
mach_port_t rcv_name,
|
|
|
|
|
mach_msg_timeout_t timeout,
|
|
|
|
|
mach_port_t notify)
|
|
|
|
|
{
|
|
|
|
|
return __mach_msg (msg, option, send_size, rcv_size, rcv_name,
|
|
|
|
|
timeout, notify);
|
|
|
|
|
}
|
|
|
|
|
weak_symbol (_hurd_intr_rpc_mach_msg)
|