1 /* Operating system support for run-time dynamic linker. Hurd version.
2 Copyright (C) 1995, 1996, 1997 Free Software Foundation, Inc.
3 This file is part of the GNU C Library.
5 The GNU C Library is free software; you can redistribute it and/or
6 modify it under the terms of the GNU Library General Public License as
7 published by the Free Software Foundation; either version 2 of the
8 License, or (at your option) any later version.
10 The GNU C Library is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 Library General Public License for more details.
15 You should have received a copy of the GNU Library General Public
16 License along with the GNU C Library; see the file COPYING.LIB. If not,
17 write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
18 Boston, MA 02111-1307, USA. */
29 #include <mach/mig_support.h>
30 #include "hurdstartup.h"
31 #include <mach/host_info.h>
32 #include <stdio-common/_itoa.h>
33 #include <hurd/auth.h>
34 #include <hurd/term.h>
39 #include "dl-machine.h"
41 extern void __mach_init (void);
44 extern char **_dl_argv;
45 extern char **_environ;
48 int __libc_enable_secure;
50 struct hurd_startup_data *_dl_hurd_data;
52 unsigned int __hurd_threadvar_max = _HURD_THREADVAR_MAX;
53 static unsigned long int threadvars[_HURD_THREADVAR_MAX];
54 unsigned long int __hurd_threadvar_stack_offset
55 = (unsigned long int) &threadvars;
56 unsigned long int __hurd_threadvar_stack_mask;
58 /* XXX loser kludge for vm_map kernel bug */
59 static vm_address_t fmha;
60 static vm_size_t fmhs;
61 static void unfmh(void){
62 __vm_deallocate(__mach_task_self(),fmha,fmhs);}
63 static void fmh(void) {
64 error_t err;int x;mach_port_t p;
65 vm_address_t a=0x08000000U,max=VM_MAX_ADDRESS;
66 while (!(err=__vm_region(__mach_task_self(),&a,&fmhs,&x,&x,&x,&x,&p,&x))){
67 __mach_port_deallocate(__mach_task_self(),p);
68 if (a+fmhs>=0x80000000U){
71 if (err) assert(err==KERN_NO_SPACE);
72 if (!fmha)fmhs=0;else{
74 err = __vm_map (__mach_task_self (),
75 &fmha, fmhs, 0, 0, MACH_PORT_NULL, 0, 1,
76 VM_PROT_NONE, VM_PROT_NONE, VM_INHERIT_COPY);
79 /* XXX loser kludge for vm_map kernel bug */
84 _dl_sysdep_start (void **start_argptr,
85 void (*dl_main) (const Elf32_Phdr *phdr, Elf32_Word phent,
86 Elf32_Addr *user_entry))
88 extern void _start ();
90 void go (int *argdata)
92 extern unsigned int _dl_skip_args; /* rtld.c */
95 /* Cache the information in various global variables. */
97 _dl_argv = 1 + (char **) argdata;
98 _environ = &_dl_argv[_dl_argc + 1];
99 for (p = _environ; *p++;); /* Skip environ pointers and terminator. */
101 if ((void *) p == _dl_argv[0])
103 static struct hurd_startup_data nodata;
104 _dl_hurd_data = &nodata;
105 nodata.user_entry = (vm_address_t) &_start;
108 _dl_hurd_data = (void *) p;
110 __libc_uid = __getuid ();
111 __libc_enable_secure = _dl_hurd_data->flags & EXEC_SECURE;
113 if (_dl_hurd_data->flags & EXEC_STACK_ARGS &&
114 _dl_hurd_data->user_entry == 0)
115 _dl_hurd_data->user_entry = (vm_address_t) &_start;
119 if (_dl_hurd_data->user_entry == (vm_address_t) &_start)
120 /* We were invoked as a command, not as the program interpreter.
121 The generic ld.so code supports this: it will parse the args
122 as "ld.so PROGRAM [ARGS...]". For booting the Hurd, we
123 support an additional special syntax:
124 ld.so [-LIBS...] PROGRAM [ARGS...]
125 Each LIBS word consists of "FILENAME=MEMOBJ";
126 for example "-/lib/libc.so=123" says that the contents of
127 /lib/libc.so are found in a memory object whose port name
128 in our task is 123. */
129 while (_dl_argc > 2 && _dl_argv[1][0] == '-' && _dl_argv[1][1] != '-')
131 char *lastslash, *memobjname, *p;
138 p = _dl_argv++[1] + 1;
140 memobjname = strchr (p, '=');
142 _dl_sysdep_fatal ("Bogus library spec: ", p, "\n", NULL);
143 *memobjname++ = '\0';
145 while (*memobjname != '\0')
146 memobj = (memobj * 10) + (*memobjname++ - '0');
148 /* Add a user reference on the memory object port, so we will
149 still have one after _dl_map_object_from_fd calls our
151 err = __mach_port_mod_refs (__mach_task_self (), memobj,
152 MACH_PORT_RIGHT_SEND, +1);
155 lastslash = strrchr (p, '/');
156 l = _dl_map_object_from_fd (lastslash ? lastslash + 1 : p,
159 /* Squirrel away the memory object port where it
160 can be retrieved by the program later. */
161 l->l_info[DT_NULL] = (void *) memobj;
164 /* Call elf/rtld.c's main program. It will set everything
165 up and leave us to transfer control to USER_ENTRY. */
166 (*dl_main) ((const Elf32_Phdr *) _dl_hurd_data->phdr,
167 _dl_hurd_data->phdrsz / sizeof (Elf32_Phdr),
168 &_dl_hurd_data->user_entry);
170 if (_dl_skip_args && _dl_argv[-_dl_skip_args] == (char *) p)
172 /* We are ignoring the first few arguments, but we have no Hurd
173 startup data. It is magical convention that ARGV[0] == P in
174 this case. The startup code in init-first.c will get confused
175 if this is not the case, so we must rearrange things to make
176 it so. Overwrite the original ARGV[0] at P with
177 ARGV[_dl_skip_args]. */
178 assert ((char *) p < _dl_argv[0]);
179 _dl_argv[0] = strcpy ((char *) p, _dl_argv[0]);
183 extern void _dl_start_user (void);
184 /* Unwind the stack to ARGDATA and simulate a return from _dl_start
185 to the RTLD_START code which will run the user's entry point. */
186 RETURN_TO (argdata, &_dl_start_user, _dl_hurd_data->user_entry);
190 /* Set up so we can do RPCs. */
193 /* Initialize frequently used global variable. */
194 _dl_pagesize = __getpagesize ();
198 /* See hurd/hurdstartup.c; this deals with getting information
199 from the exec server and slicing up the arguments.
200 Then it will call `go', above. */
201 _hurd_startup (start_argptr, &go);
208 _dl_sysdep_start_cleanup (void)
210 /* Deallocate the reply port and task port rights acquired by
211 __mach_init. We are done with them now, and the user will
212 reacquire them for himself when he wants them. */
213 __mig_dealloc_reply_port (MACH_PORT_NULL);
214 __mach_port_deallocate (__mach_task_self (), __mach_task_self_);
218 _dl_sysdep_fatal (const char *msg, ...)
225 size_t len = strlen (msg);
226 mach_msg_type_number_t nwrote;
229 if (__io_write (_hurd_init_dtable[2], msg, len, -1, &nwrote))
233 } while (nwrote > 0);
234 msg = va_arg (ap, const char *);
243 _dl_sysdep_error (const char *msg, ...)
250 size_t len = strlen (msg);
251 mach_msg_type_number_t nwrote;
254 if (__io_write (_hurd_init_dtable[2], msg, len, -1, &nwrote))
258 } while (nwrote > 0);
259 msg = va_arg (ap, const char *);
266 _dl_sysdep_message (const char *msg, ...)
273 size_t len = strlen (msg);
274 mach_msg_type_number_t nwrote;
277 if (__io_write (_hurd_init_dtable[1], msg, len, -1, &nwrote))
281 } while (nwrote > 0);
282 msg = va_arg (ap, const char *);
287 /* Minimal open/close/mmap implementation sufficient for initial loading of
288 shared libraries. These are weak definitions so that when the
289 dynamic linker re-relocates itself to be user-visible (for -ldl),
290 /* Minimal open/close/mmap implementation sufficient for initial loading of
291 shared libraries. These are weak definitions so that when the
292 dynamic linker re-relocates itself to be user-visible (for -ldl),
293 it will get the user's definition (i.e. usually libc's). */
295 /* Open FILE_NAME and return a read-mmappable port in MEMOBJ_RD for it, or
296 return an error. If STAT is non-zero, stat the file into that stat buffer. */
298 open_file (const char *file_name, int mode,
299 mach_port_t *memobj_rd, struct stat *stat)
301 enum retry_type doretry;
302 char retryname[1024]; /* XXX string_t LOSES! */
303 file_t startdir, newpt, fileport;
308 assert (mode == O_RDONLY);
310 startdir = _dl_hurd_data->portarray[file_name[0] == '/' ?
311 INIT_PORT_CRDIR : INIT_PORT_CWDIR];
313 while (file_name[0] == '/')
316 if (err = __dir_lookup (startdir, (char *)file_name, mode, 0,
317 &doretry, retryname, &fileport))
326 __mach_port_deallocate (__mach_task_self (), startdir);
332 case FS_RETRY_REAUTH:
334 mach_port_t ref = __mach_reply_port ();
335 err = __io_reauthenticate (fileport, ref, MACH_MSG_TYPE_MAKE_SEND);
337 err = __auth_user_authenticate
338 (_dl_hurd_data->portarray[INIT_PORT_AUTH],
339 ref, MACH_MSG_TYPE_MAKE_SEND,
341 __mach_port_destroy (__mach_task_self (), ref);
343 __mach_port_deallocate (__mach_task_self (), fileport);
349 case FS_RETRY_NORMAL:
351 if (nloops++ >= SYMLOOP_MAX)
355 /* An empty RETRYNAME indicates we have the final port. */
356 if (retryname[0] == '\0')
358 mach_port_t memobj_wr;
363 /* We have the file open. Now map it. */
366 err = __io_stat (fileport, stat);
368 err = __io_map (fileport, memobj_rd, &memobj_wr);
371 __mach_port_deallocate (__mach_task_self (), fileport);
375 if (memobj_wr != MACH_PORT_NULL)
376 __mach_port_deallocate (__mach_task_self (), memobj_wr);
383 file_name = retryname;
386 case FS_RETRY_MAGICAL:
387 switch (retryname[0])
390 startdir = _dl_hurd_data->portarray[INIT_PORT_CRDIR];
392 if (fileport != MACH_PORT_NULL)
393 __mach_port_deallocate (__mach_task_self (), fileport);
394 file_name = &retryname[1];
398 if (retryname[1] == 'd' && retryname[2] == '/' &&
399 isdigit (retryname[3]))
401 /* We can't use strtol for the decoding here
402 because it brings in hairy locale bloat. */
405 for (p = &retryname[3]; isdigit (*p); ++p)
406 fd = (fd * 10) + (*p - '0');
407 /* Check for excess text after the number. A slash is
408 valid; it ends the component. Anything else does not
409 name a numeric file descriptor. */
410 if (*p != '/' && *p != '\0')
412 if (fd < 0 || fd >= _dl_hurd_data->dtablesize ||
413 _dl_hurd_data->dtable[fd] == MACH_PORT_NULL)
414 /* If the name was a proper number, but the file
415 descriptor does not exist, we return EBADF instead
418 fileport = _dl_hurd_data->dtable[fd];
421 /* This descriptor is the file port we want. */
427 /* Do a normal retry on the remaining components. */
430 file_name = p + 1; /* Skip the slash. */
439 if (retryname[1] == 'a' && retryname[2] == 'c' &&
440 retryname[3] == 'h' && retryname[4] == 't' &&
441 retryname[5] == 'y' && retryname[6] == 'p' &&
445 struct host_basic_info hostinfo;
446 mach_msg_type_number_t hostinfocnt = HOST_BASIC_INFO_COUNT;
448 if (err = __host_info (__mach_host_self (), HOST_BASIC_INFO,
449 (natural_t *) &hostinfo,
452 if (hostinfocnt != HOST_BASIC_INFO_COUNT)
454 p = _itoa (hostinfo.cpu_subtype, &retryname[8], 10, 0);
456 p = _itoa (hostinfo.cpu_type, &retryname[8], 10, 0);
458 abort (); /* XXX write this right if this ever happens */
460 strcpy (retryname, p);
469 if (retryname[1] == 't' && retryname[2] == 'y')
470 switch (retryname[3])
472 error_t opentty (file_t *result)
476 err = __termctty_open_terminal
477 (_dl_hurd_data->portarray[INIT_PORT_CTTYID],
481 mach_port_t ref = __mach_reply_port ();
482 err = __io_reauthenticate
483 (unauth, ref, MACH_MSG_TYPE_MAKE_SEND);
485 err = __auth_user_authenticate
486 (_dl_hurd_data->portarray[INIT_PORT_AUTH],
487 ref, MACH_MSG_TYPE_MAKE_SEND,
489 __mach_port_deallocate (__mach_task_self (),
491 __mach_port_destroy (__mach_task_self (), ref);
497 if (err = opentty (&fileport))
502 if (err = opentty (&startdir))
505 strcpy (retryname, &retryname[4]);
524 err = __dir_lookup (startdir, (char *)file_name, mode, 0,
525 &doretry, retryname, &fileport);
530 __open (const char *file_name, int mode, ...)
532 mach_port_t memobj_rd;
533 error_t err = open_file (file_name, mode, &memobj_rd, 0);
535 return __hurd_fail (err);
537 return (int)memobj_rd;
543 if (fd != (int) MACH_PORT_NULL)
544 __mach_port_deallocate (__mach_task_self (), (mach_port_t) fd);
548 caddr_t weak_function
549 __mmap (caddr_t addr, size_t len, int prot, int flags, int fd, off_t offset)
553 vm_address_t mapaddr;
555 vmprot = VM_PROT_NONE;
556 if (prot & PROT_READ)
557 vmprot |= VM_PROT_READ;
558 if (prot & PROT_WRITE)
559 vmprot |= VM_PROT_WRITE;
560 if (prot & PROT_EXEC)
561 vmprot |= VM_PROT_EXECUTE;
563 mapaddr = (vm_address_t) addr;
564 err = __vm_map (__mach_task_self (),
565 &mapaddr, (vm_size_t) len, 0 /*ELF_MACHINE_USER_ADDRESS_MASK*/,
566 !(flags & MAP_FIXED),
567 (flags & MAP_ANON) ? MACH_PORT_NULL : (mach_port_t) fd,
568 (vm_offset_t) offset,
569 flags & (MAP_COPY|MAP_PRIVATE),
571 (flags & MAP_SHARED) ? VM_INHERIT_SHARE : VM_INHERIT_COPY);
572 if (err == KERN_NO_SPACE && (flags & MAP_FIXED))
576 _dl_sysdep_fatal (const char *msg, ...)
583 size_t len = strlen (msg);
584 mach_msg_type_number_t nwrote;
587 if (__io_write (_hurd_init_dtable[2], msg, len, -1, &nwrote))
591 } while (nwrote > 0);
592 msg = va_arg (ap, const char *);
601 _dl_sysdep_error (const char *msg, ...)
608 size_t len = strlen (msg);
609 mach_msg_type_number_t nwrote;
612 if (__io_write (_hurd_init_dtable[2], msg, len, -1, &nwrote))
616 } while (nwrote > 0);
617 msg = va_arg (ap, const char *);
624 _dl_sysdep_message (const char *msg, ...)
631 size_t len = strlen (msg);
632 mach_msg_type_number_t nwrote;
635 if (__io_write (_hurd_init_dtable[1], msg, len, -1, &nwrote))
639 } while (nwrote > 0);
640 msg = va_arg (ap, const char *);
644 /* XXX this is not atomic as it is in unix! */
645 /* The region is already allocated; deallocate it first. */
646 err = __vm_deallocate (__mach_task_self (), mapaddr, len);
648 err = __vm_map (__mach_task_self (),
649 &mapaddr, (vm_size_t) len, 0 /*ELF_MACHINE_USER_ADDRESS_MASK*/,
650 !(flags & MAP_FIXED),
651 (mach_port_t) fd, (vm_offset_t) offset,
652 flags & (MAP_COPY|MAP_PRIVATE),
655 ? VM_INHERIT_SHARE : VM_INHERIT_COPY);
658 return err ? (caddr_t) __hurd_fail (err) : (caddr_t) mapaddr;
664 __proc_mark_exit (_dl_hurd_data->portarray[INIT_PORT_PROC],
665 W_EXITCODE (status, 0), 0);
666 while (__task_terminate (__mach_task_self ()))
667 __mach_task_self_ = (__mach_task_self) ();
670 /* Read the whole contents of FILE into new mmap'd space with given
671 protections. The size of the file is returned in SIZE. */
674 _dl_sysdep_read_whole_file (const char *file, size_t *size, int prot)
677 mach_port_t memobj_rd;
679 error_t err = open_file (file, O_RDONLY, &memobj_rd, &stat);
683 /* Map a copy of the file contents. */
684 contents = __mmap (0, stat.st_size, prot, MAP_COPY, memobj_rd, 0);
685 if (contents == (void *)-1)
688 *size = stat.st_size;
690 __mach_port_deallocate (__mach_task_self (), memobj_rd);
701 /* This function is called by interruptible RPC stubs. For initial
702 dynamic linking, just use the normal mach_msg. Since this defn is
703 weak, the real defn in libc.so will override it if we are linked into
704 the user program (-ldl). */
706 error_t weak_function
707 _hurd_intr_rpc_mach_msg (mach_msg_header_t *msg,
708 mach_msg_option_t option,
709 mach_msg_size_t send_size,
710 mach_msg_size_t rcv_size,
711 mach_port_t rcv_name,
712 mach_msg_timeout_t timeout,
715 return __mach_msg (msg, option, send_size, rcv_size, rcv_name,
723 /* There is nothing to print. Hurd has no auxiliary vector. */