1 /* Operating system support for run-time dynamic linker. Hurd version.
2 Copyright (C) 1995-2017 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 Lesser General Public
7 License as published by the Free Software Foundation; either
8 version 2.1 of the 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 Lesser General Public License for more details.
15 You should have received a copy of the GNU Lesser General Public
16 License along with the GNU C Library; if not, see
17 <http://www.gnu.org/licenses/>. */
19 /* In the static library, this is all handled by dl-support.c
20 or by the vanilla definitions in the rest of the C library. */
33 #include <mach/mig_support.h>
34 #include "hurdstartup.h"
35 #include <hurd/lookup.h>
36 #include <hurd/auth.h>
37 #include <hurd/term.h>
44 #include <dl-machine.h>
45 #include <dl-procinfo.h>
47 #include <dl-tunables.h>
49 extern void __mach_init (void);
52 extern char **_dl_argv
;
53 extern char **_environ
;
55 int __libc_enable_secure
= 0;
56 rtld_hidden_data_def (__libc_enable_secure
)
57 int __libc_multiple_libcs
= 0; /* Defining this here avoids the inclusion
59 /* This variable contains the lowest stack address ever used. */
60 void *__libc_stack_end
= NULL
;
61 rtld_hidden_data_def(__libc_stack_end
)
64 hp_timing_t _dl_cpuclock_offset
;
68 struct hurd_startup_data
*_dl_hurd_data
;
70 /* This is used only within ld.so, via dl-minimal.c's __errno_location. */
72 int errno attribute_hidden
;
74 /* Defining these variables here avoids the inclusion of hurdsig.c. */
75 unsigned long int __hurd_sigthread_stack_base
;
76 unsigned long int __hurd_sigthread_stack_end
;
77 unsigned long int *__hurd_sigthread_variables
;
79 /* Defining these variables here avoids the inclusion of init-first.c.
80 We need to provide temporary storage for the per-thread variables
81 of the main user thread here, since it is used for storing the
82 `errno' variable. Note that this information is lost once we
83 relocate the dynamic linker. */
84 static unsigned long int threadvars
[_HURD_THREADVAR_MAX
];
85 unsigned long int __hurd_threadvar_stack_offset
86 = (unsigned long int) &threadvars
;
87 unsigned long int __hurd_threadvar_stack_mask
;
89 #define FMH defined(__i386__)
91 # define fmh() ((void)0)
92 # define unfmh() ((void)0)
94 /* XXX loser kludge for vm_map kernel bug */
95 #undef ELF_MACHINE_USER_ADDRESS_MASK
96 #define ELF_MACHINE_USER_ADDRESS_MASK 0
97 static vm_address_t fmha
;
98 static vm_size_t fmhs
;
99 static void unfmh(void){
100 __vm_deallocate(__mach_task_self(),fmha
,fmhs
);}
101 static void fmh(void) {
102 error_t err
;int x
;vm_offset_t o
;mach_port_t p
;
103 vm_address_t a
=0x08000000U
,max
=VM_MAX_ADDRESS
;
104 while (!(err
=__vm_region(__mach_task_self(),&a
,&fmhs
,&x
,&x
,&x
,&x
,&p
,&o
))){
105 __mach_port_deallocate(__mach_task_self(),p
);
106 if (a
+fmhs
>=0x80000000U
){
109 if (err
) assert(err
==KERN_NO_SPACE
);
110 if (!fmha
)fmhs
=0;else{
112 err
= __vm_map (__mach_task_self (),
113 &fmha
, fmhs
, 0, 0, MACH_PORT_NULL
, 0, 1,
114 VM_PROT_NONE
, VM_PROT_NONE
, VM_INHERIT_COPY
);
117 /* XXX loser kludge for vm_map kernel bug */
122 _dl_sysdep_start (void **start_argptr
,
123 void (*dl_main
) (const ElfW(Phdr
) *phdr
, ElfW(Word
) phent
,
124 ElfW(Addr
) *user_entry
,
127 void go (intptr_t *argdata
)
131 /* Cache the information in various global variables. */
133 _dl_argv
= 1 + (char **) argdata
;
134 _environ
= &_dl_argv
[_dl_argc
+ 1];
135 for (p
= _environ
; *p
++;); /* Skip environ pointers and terminator. */
137 if ((void *) p
== _dl_argv
[0])
139 static struct hurd_startup_data nodata
;
140 _dl_hurd_data
= &nodata
;
141 nodata
.user_entry
= (vm_address_t
) ENTRY_POINT
;
144 _dl_hurd_data
= (void *) p
;
146 __libc_enable_secure
= _dl_hurd_data
->flags
& EXEC_SECURE
;
148 __tunables_init (_environ
);
150 if (_dl_hurd_data
->flags
& EXEC_STACK_ARGS
&&
151 _dl_hurd_data
->user_entry
== 0)
152 _dl_hurd_data
->user_entry
= (vm_address_t
) ENTRY_POINT
;
156 #if 0 /* XXX make this work for real someday... */
157 if (_dl_hurd_data
->user_entry
== (vm_address_t
) ENTRY_POINT
)
158 /* We were invoked as a command, not as the program interpreter.
159 The generic ld.so code supports this: it will parse the args
160 as "ld.so PROGRAM [ARGS...]". For booting the Hurd, we
161 support an additional special syntax:
162 ld.so [-LIBS...] PROGRAM [ARGS...]
163 Each LIBS word consists of "FILENAME=MEMOBJ";
164 for example "-/lib/libc.so=123" says that the contents of
165 /lib/libc.so are found in a memory object whose port name
166 in our task is 123. */
167 while (_dl_argc
> 2 && _dl_argv
[1][0] == '-' && _dl_argv
[1][1] != '-')
169 char *lastslash
, *memobjname
, *p
;
176 p
= _dl_argv
++[1] + 1;
178 memobjname
= strchr (p
, '=');
180 _dl_sysdep_fatal ("Bogus library spec: ", p
, "\n", NULL
);
181 *memobjname
++ = '\0';
183 while (*memobjname
!= '\0')
184 memobj
= (memobj
* 10) + (*memobjname
++ - '0');
186 /* Add a user reference on the memory object port, so we will
187 still have one after _dl_map_object_from_fd calls our
189 err
= __mach_port_mod_refs (__mach_task_self (), memobj
,
190 MACH_PORT_RIGHT_SEND
, +1);
193 lastslash
= strrchr (p
, '/');
194 l
= _dl_map_object_from_fd (lastslash
? lastslash
+ 1 : p
, NULL
,
195 memobj
, strdup (p
), 0);
197 /* Squirrel away the memory object port where it
198 can be retrieved by the program later. */
199 l
->l_info
[DT_NULL
] = (void *) memobj
;
203 /* Call elf/rtld.c's main program. It will set everything
204 up and leave us to transfer control to USER_ENTRY. */
205 (*dl_main
) ((const ElfW(Phdr
) *) _dl_hurd_data
->phdr
,
206 _dl_hurd_data
->phdrsz
/ sizeof (ElfW(Phdr
)),
207 &_dl_hurd_data
->user_entry
, NULL
);
209 /* The call above might screw a few things up.
211 First of all, if _dl_skip_args is nonzero, we are ignoring
212 the first few arguments. However, if we have no Hurd startup
213 data, it is the magical convention that ARGV[0] == P. The
214 startup code in init-first.c will get confused if this is not
215 the case, so we must rearrange things to make it so. We'll
216 overwrite the origional ARGV[0] at P with ARGV[_dl_skip_args].
218 Secondly, if we need to be secure, it removes some dangerous
219 environment variables. If we have no Hurd startup date this
220 changes P (since that's the location after the terminating
221 NULL in the list of environment variables). We do the same
222 thing as in the first case but make sure we recalculate P.
223 If we do have Hurd startup data, we have to move the data
224 such that it starts just after the terminating NULL in the
227 We use memmove, since the locations might overlap. */
228 if (__libc_enable_secure
|| _dl_skip_args
)
232 for (newp
= _environ
; *newp
++;);
234 if (_dl_argv
[-_dl_skip_args
] == (char *) p
)
236 if ((char *) newp
!= _dl_argv
[0])
238 assert ((char *) newp
< _dl_argv
[0]);
239 _dl_argv
[0] = memmove ((char *) newp
, _dl_argv
[0],
240 strlen (_dl_argv
[0]) + 1);
245 if ((void *) newp
!= _dl_hurd_data
)
246 memmove (newp
, _dl_hurd_data
, sizeof (*_dl_hurd_data
));
251 extern void _dl_start_user (void);
252 /* Unwind the stack to ARGDATA and simulate a return from _dl_start
253 to the RTLD_START code which will run the user's entry point. */
254 RETURN_TO (argdata
, &_dl_start_user
, _dl_hurd_data
->user_entry
);
258 /* Set up so we can do RPCs. */
261 /* Initialize frequently used global variable. */
262 GLRO(dl_pagesize
) = __getpagesize ();
265 HP_TIMING_NOW (_dl_cpuclock_offset
);
270 /* See hurd/hurdstartup.c; this deals with getting information
271 from the exec server and slicing up the arguments.
272 Then it will call `go', above. */
273 _hurd_startup (start_argptr
, &go
);
281 _dl_sysdep_start_cleanup (void)
283 /* Deallocate the reply port and task port rights acquired by
284 __mach_init. We are done with them now, and the user will
285 reacquire them for himself when he wants them. */
286 __mig_dealloc_reply_port (MACH_PORT_NULL
);
287 __mach_port_deallocate (__mach_task_self (), __mach_host_self_
);
288 __mach_port_deallocate (__mach_task_self (), __mach_task_self_
);
291 /* Minimal open/close/mmap implementation sufficient for initial loading of
292 shared libraries. These are weak definitions so that when the
293 dynamic linker re-relocates itself to be user-visible (for -ldl),
294 it will get the user's definition (i.e. usually libc's). */
296 /* Open FILE_NAME and return a Hurd I/O for it in *PORT, or return an
297 error. If STAT is non-zero, stat the file into that stat buffer. */
299 open_file (const char *file_name
, int flags
,
300 mach_port_t
*port
, struct stat64
*stat
)
302 enum retry_type doretry
;
303 char retryname
[1024]; /* XXX string_t LOSES! */
307 error_t
use_init_port (int which
, error_t (*operate
) (file_t
))
309 return (which
< _dl_hurd_data
->portarraysize
310 ? ((*operate
) (_dl_hurd_data
->portarray
[which
]))
313 file_t
get_dtable_port (int fd
)
315 if ((unsigned int) fd
< _dl_hurd_data
->dtablesize
316 && _dl_hurd_data
->dtable
[fd
] != MACH_PORT_NULL
)
318 __mach_port_mod_refs (__mach_task_self (), _dl_hurd_data
->dtable
[fd
],
319 MACH_PORT_RIGHT_SEND
, +1);
320 return _dl_hurd_data
->dtable
[fd
];
323 return MACH_PORT_NULL
;
326 assert (!(flags
& ~(O_READ
| O_CLOEXEC
)));
328 startdir
= _dl_hurd_data
->portarray
[file_name
[0] == '/' ?
329 INIT_PORT_CRDIR
: INIT_PORT_CWDIR
];
331 while (file_name
[0] == '/')
334 err
= __dir_lookup (startdir
, (char *)file_name
, O_RDONLY
, 0,
335 &doretry
, retryname
, port
);
338 err
= __hurd_file_name_lookup_retry (use_init_port
, get_dtable_port
,
339 __dir_lookup
, doretry
, retryname
,
343 err
= __io_stat (*port
, stat
);
345 __mach_port_deallocate (__mach_task_self (), *port
);
352 __open (const char *file_name
, int mode
, ...)
355 error_t err
= open_file (file_name
, mode
, &port
, 0);
357 return __hurd_fail (err
);
365 if (fd
!= (int) MACH_PORT_NULL
)
366 __mach_port_deallocate (__mach_task_self (), (mach_port_t
) fd
);
370 __ssize_t weak_function
371 __libc_read (int fd
, void *buf
, size_t nbytes
)
375 mach_msg_type_number_t nread
;
379 err
= __io_read ((mach_port_t
) fd
, &data
, &nread
, -1, nbytes
);
381 return __hurd_fail (err
);
385 memcpy (buf
, data
, nread
);
386 __vm_deallocate (__mach_task_self (), (vm_address_t
) data
, nread
);
391 libc_hidden_weak (__libc_read
)
393 __ssize_t weak_function
394 __libc_write (int fd
, const void *buf
, size_t nbytes
)
397 mach_msg_type_number_t nwrote
;
399 assert (fd
< _hurd_init_dtablesize
);
401 err
= __io_write (_hurd_init_dtable
[fd
], buf
, nbytes
, -1, &nwrote
);
403 return __hurd_fail (err
);
407 libc_hidden_weak (__libc_write
)
409 /* This is only used for printing messages (see dl-misc.c). */
410 __ssize_t weak_function
411 __writev (int fd
, const struct iovec
*iov
, int niov
)
413 if (fd
>= _hurd_init_dtablesize
)
421 for (i
= 0; i
< niov
; ++i
)
422 total
+= iov
[i
].iov_len
;
426 char buf
[total
], *bufp
= buf
;
428 mach_msg_type_number_t nwrote
;
430 for (i
= 0; i
< niov
; ++i
)
431 bufp
= (memcpy (bufp
, iov
[i
].iov_base
, iov
[i
].iov_len
)
434 err
= __io_write (_hurd_init_dtable
[fd
], buf
, total
, -1, &nwrote
);
436 return __hurd_fail (err
);
444 off64_t weak_function
445 __libc_lseek64 (int fd
, off64_t offset
, int whence
)
449 err
= __io_seek ((mach_port_t
) fd
, offset
, whence
, &offset
);
451 return __hurd_fail (err
);
457 __mmap (void *addr
, size_t len
, int prot
, int flags
, int fd
, off_t offset
)
461 vm_address_t mapaddr
;
462 mach_port_t memobj_rd
, memobj_wr
;
464 vmprot
= VM_PROT_NONE
;
465 if (prot
& PROT_READ
)
466 vmprot
|= VM_PROT_READ
;
467 if (prot
& PROT_WRITE
)
468 vmprot
|= VM_PROT_WRITE
;
469 if (prot
& PROT_EXEC
)
470 vmprot
|= VM_PROT_EXECUTE
;
472 if (flags
& MAP_ANON
)
473 memobj_rd
= MACH_PORT_NULL
;
476 assert (!(flags
& MAP_SHARED
));
477 err
= __io_map ((mach_port_t
) fd
, &memobj_rd
, &memobj_wr
);
479 return __hurd_fail (err
), MAP_FAILED
;
480 if (memobj_wr
!= MACH_PORT_NULL
)
481 __mach_port_deallocate (__mach_task_self (), memobj_wr
);
484 mapaddr
= (vm_address_t
) addr
;
485 err
= __vm_map (__mach_task_self (),
486 &mapaddr
, (vm_size_t
) len
, ELF_MACHINE_USER_ADDRESS_MASK
,
487 !(flags
& MAP_FIXED
),
489 (vm_offset_t
) offset
,
490 flags
& (MAP_COPY
|MAP_PRIVATE
),
492 (flags
& MAP_SHARED
) ? VM_INHERIT_SHARE
: VM_INHERIT_COPY
);
493 if (err
== KERN_NO_SPACE
&& (flags
& MAP_FIXED
))
495 /* XXX this is not atomic as it is in unix! */
496 /* The region is already allocated; deallocate it first. */
497 err
= __vm_deallocate (__mach_task_self (), mapaddr
, len
);
499 err
= __vm_map (__mach_task_self (),
500 &mapaddr
, (vm_size_t
) len
,
501 ELF_MACHINE_USER_ADDRESS_MASK
,
502 !(flags
& MAP_FIXED
),
503 memobj_rd
, (vm_offset_t
) offset
,
504 flags
& (MAP_COPY
|MAP_PRIVATE
),
507 ? VM_INHERIT_SHARE
: VM_INHERIT_COPY
);
510 if ((flags
& MAP_ANON
) == 0)
511 __mach_port_deallocate (__mach_task_self (), memobj_rd
);
514 return __hurd_fail (err
), MAP_FAILED
;
515 return (void *) mapaddr
;
519 __fxstat64 (int vers
, int fd
, struct stat64
*buf
)
523 assert (vers
== _STAT_VER
);
525 err
= __io_stat ((mach_port_t
) fd
, buf
);
527 return __hurd_fail (err
);
531 libc_hidden_def (__fxstat64
)
534 __xstat64 (int vers
, const char *file
, struct stat64
*buf
)
539 assert (vers
== _STAT_VER
);
541 err
= open_file (file
, 0, &port
, buf
);
543 return __hurd_fail (err
);
545 __mach_port_deallocate (__mach_task_self (), port
);
549 libc_hidden_def (__xstat64
)
551 /* This function is called by the dynamic linker (rtld.c) to check
552 whether debugging malloc is allowed even for SUID binaries. This
553 stub will always fail, which means that malloc-debugging is always
554 disabled for SUID binaries. */
556 __access (const char *file
, int type
)
568 if (__proc_getpids (_dl_hurd_data
->portarray
[INIT_PORT_PROC
],
569 &pid
, &ppid
, &orphaned
))
575 /* This is called only in some strange cases trying to guess a value
576 for $ORIGIN for the executable. The dynamic linker copes with
577 getcwd failing (dl-object.c), and it's too much hassle to include
578 the functionality here. (We could, it just requires duplicating or
579 reusing getcwd.c's code but using our special lookup function as in
583 __getcwd (char *buf
, size_t size
)
589 void weak_function attribute_hidden
592 __proc_mark_exit (_dl_hurd_data
->portarray
[INIT_PORT_PROC
],
593 W_EXITCODE (status
, 0), 0);
594 while (__task_terminate (__mach_task_self ()))
595 __mach_task_self_
= (__mach_task_self
) ();
597 /* We need this alias to satisfy references from libc_pic.a objects
598 that were affected by the libc_hidden_proto declaration for _exit. */
599 strong_alias (_exit
, __GI__exit
)
601 /* Try to get a machine dependent instruction which will make the
602 program crash. This is used in case everything else fails. */
603 #include <abort-instr.h>
604 #ifndef ABORT_INSTRUCTION
605 /* No such instruction is available. */
606 # define ABORT_INSTRUCTION
612 /* Try to abort using the system specific command. */
615 /* If the abort instruction failed, exit. */
618 /* If even this fails, make sure we never return. */
620 /* Try for ever and ever. */
624 /* We need this alias to satisfy references from libc_pic.a objects
625 that were affected by the libc_hidden_proto declaration for abort. */
626 strong_alias (abort
, __GI_abort
)
628 /* This function is called by interruptible RPC stubs. For initial
629 dynamic linking, just use the normal mach_msg. Since this defn is
630 weak, the real defn in libc.so will override it if we are linked into
631 the user program (-ldl). */
633 error_t weak_function
634 _hurd_intr_rpc_mach_msg (mach_msg_header_t
*msg
,
635 mach_msg_option_t option
,
636 mach_msg_size_t send_size
,
637 mach_msg_size_t rcv_size
,
638 mach_port_t rcv_name
,
639 mach_msg_timeout_t timeout
,
642 return __mach_msg (msg
, option
, send_size
, rcv_size
, rcv_name
,
651 /* There is nothing to print. Hurd has no auxiliary vector. */
656 _dl_init_first (int argc
, ...)
658 /* This no-op definition only gets used if libc is not linked in. */