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
);
280 _dl_sysdep_start_cleanup (void)
282 /* Deallocate the reply port and task port rights acquired by
283 __mach_init. We are done with them now, and the user will
284 reacquire them for himself when he wants them. */
285 __mig_dealloc_reply_port (MACH_PORT_NULL
);
286 __mach_port_deallocate (__mach_task_self (), __mach_host_self_
);
287 __mach_port_deallocate (__mach_task_self (), __mach_task_self_
);
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 Hurd I/O for it in *PORT, or return an
296 error. If STAT is non-zero, stat the file into that stat buffer. */
298 open_file (const char *file_name
, int flags
,
299 mach_port_t
*port
, struct stat64
*stat
)
301 enum retry_type doretry
;
302 char retryname
[1024]; /* XXX string_t LOSES! */
306 error_t
use_init_port (int which
, error_t (*operate
) (file_t
))
308 return (which
< _dl_hurd_data
->portarraysize
309 ? ((*operate
) (_dl_hurd_data
->portarray
[which
]))
312 file_t
get_dtable_port (int fd
)
314 if ((unsigned int) fd
< _dl_hurd_data
->dtablesize
315 && _dl_hurd_data
->dtable
[fd
] != MACH_PORT_NULL
)
317 __mach_port_mod_refs (__mach_task_self (), _dl_hurd_data
->dtable
[fd
],
318 MACH_PORT_RIGHT_SEND
, +1);
319 return _dl_hurd_data
->dtable
[fd
];
322 return MACH_PORT_NULL
;
325 assert (!(flags
& ~(O_READ
| O_CLOEXEC
)));
327 startdir
= _dl_hurd_data
->portarray
[file_name
[0] == '/' ?
328 INIT_PORT_CRDIR
: INIT_PORT_CWDIR
];
330 while (file_name
[0] == '/')
333 err
= __dir_lookup (startdir
, (char *)file_name
, O_RDONLY
, 0,
334 &doretry
, retryname
, port
);
337 err
= __hurd_file_name_lookup_retry (use_init_port
, get_dtable_port
,
338 __dir_lookup
, doretry
, retryname
,
342 err
= __io_stat (*port
, stat
);
344 __mach_port_deallocate (__mach_task_self (), *port
);
351 __open (const char *file_name
, int mode
, ...)
354 error_t err
= open_file (file_name
, mode
, &port
, 0);
356 return __hurd_fail (err
);
364 if (fd
!= (int) MACH_PORT_NULL
)
365 __mach_port_deallocate (__mach_task_self (), (mach_port_t
) fd
);
369 __ssize_t weak_function
370 __libc_read (int fd
, void *buf
, size_t nbytes
)
374 mach_msg_type_number_t nread
;
378 err
= __io_read ((mach_port_t
) fd
, &data
, &nread
, -1, nbytes
);
380 return __hurd_fail (err
);
384 memcpy (buf
, data
, nread
);
385 __vm_deallocate (__mach_task_self (), (vm_address_t
) data
, nread
);
390 libc_hidden_weak (__libc_read
)
392 __ssize_t weak_function
393 __libc_write (int fd
, const void *buf
, size_t nbytes
)
396 mach_msg_type_number_t nwrote
;
398 assert (fd
< _hurd_init_dtablesize
);
400 err
= __io_write (_hurd_init_dtable
[fd
], buf
, nbytes
, -1, &nwrote
);
402 return __hurd_fail (err
);
406 libc_hidden_weak (__libc_write
)
408 /* This is only used for printing messages (see dl-misc.c). */
409 __ssize_t weak_function
410 __writev (int fd
, const struct iovec
*iov
, int niov
)
412 if (fd
>= _hurd_init_dtablesize
)
420 for (i
= 0; i
< niov
; ++i
)
421 total
+= iov
[i
].iov_len
;
425 char buf
[total
], *bufp
= buf
;
427 mach_msg_type_number_t nwrote
;
429 for (i
= 0; i
< niov
; ++i
)
430 bufp
= (memcpy (bufp
, iov
[i
].iov_base
, iov
[i
].iov_len
)
433 err
= __io_write (_hurd_init_dtable
[fd
], buf
, total
, -1, &nwrote
);
435 return __hurd_fail (err
);
443 off64_t weak_function
444 __libc_lseek64 (int fd
, off64_t offset
, int whence
)
448 err
= __io_seek ((mach_port_t
) fd
, offset
, whence
, &offset
);
450 return __hurd_fail (err
);
456 __mmap (void *addr
, size_t len
, int prot
, int flags
, int fd
, off_t offset
)
460 vm_address_t mapaddr
;
461 mach_port_t memobj_rd
, memobj_wr
;
463 vmprot
= VM_PROT_NONE
;
464 if (prot
& PROT_READ
)
465 vmprot
|= VM_PROT_READ
;
466 if (prot
& PROT_WRITE
)
467 vmprot
|= VM_PROT_WRITE
;
468 if (prot
& PROT_EXEC
)
469 vmprot
|= VM_PROT_EXECUTE
;
471 if (flags
& MAP_ANON
)
472 memobj_rd
= MACH_PORT_NULL
;
475 assert (!(flags
& MAP_SHARED
));
476 err
= __io_map ((mach_port_t
) fd
, &memobj_rd
, &memobj_wr
);
478 return __hurd_fail (err
), MAP_FAILED
;
479 if (memobj_wr
!= MACH_PORT_NULL
)
480 __mach_port_deallocate (__mach_task_self (), memobj_wr
);
483 mapaddr
= (vm_address_t
) addr
;
484 err
= __vm_map (__mach_task_self (),
485 &mapaddr
, (vm_size_t
) len
, ELF_MACHINE_USER_ADDRESS_MASK
,
486 !(flags
& MAP_FIXED
),
488 (vm_offset_t
) offset
,
489 flags
& (MAP_COPY
|MAP_PRIVATE
),
491 (flags
& MAP_SHARED
) ? VM_INHERIT_SHARE
: VM_INHERIT_COPY
);
492 if (err
== KERN_NO_SPACE
&& (flags
& MAP_FIXED
))
494 /* XXX this is not atomic as it is in unix! */
495 /* The region is already allocated; deallocate it first. */
496 err
= __vm_deallocate (__mach_task_self (), mapaddr
, len
);
498 err
= __vm_map (__mach_task_self (),
499 &mapaddr
, (vm_size_t
) len
,
500 ELF_MACHINE_USER_ADDRESS_MASK
,
501 !(flags
& MAP_FIXED
),
502 memobj_rd
, (vm_offset_t
) offset
,
503 flags
& (MAP_COPY
|MAP_PRIVATE
),
506 ? VM_INHERIT_SHARE
: VM_INHERIT_COPY
);
509 if ((flags
& MAP_ANON
) == 0)
510 __mach_port_deallocate (__mach_task_self (), memobj_rd
);
513 return __hurd_fail (err
), MAP_FAILED
;
514 return (void *) mapaddr
;
518 __fxstat64 (int vers
, int fd
, struct stat64
*buf
)
522 assert (vers
== _STAT_VER
);
524 err
= __io_stat ((mach_port_t
) fd
, buf
);
526 return __hurd_fail (err
);
530 libc_hidden_def (__fxstat64
)
533 __xstat64 (int vers
, const char *file
, struct stat64
*buf
)
538 assert (vers
== _STAT_VER
);
540 err
= open_file (file
, 0, &port
, buf
);
542 return __hurd_fail (err
);
544 __mach_port_deallocate (__mach_task_self (), port
);
548 libc_hidden_def (__xstat64
)
550 /* This function is called by the dynamic linker (rtld.c) to check
551 whether debugging malloc is allowed even for SUID binaries. This
552 stub will always fail, which means that malloc-debugging is always
553 disabled for SUID binaries. */
555 __access (const char *file
, int type
)
567 if (__proc_getpids (_dl_hurd_data
->portarray
[INIT_PORT_PROC
],
568 &pid
, &ppid
, &orphaned
))
574 /* This is called only in some strange cases trying to guess a value
575 for $ORIGIN for the executable. The dynamic linker copes with
576 getcwd failing (dl-object.c), and it's too much hassle to include
577 the functionality here. (We could, it just requires duplicating or
578 reusing getcwd.c's code but using our special lookup function as in
582 __getcwd (char *buf
, size_t size
)
588 void weak_function attribute_hidden
591 __proc_mark_exit (_dl_hurd_data
->portarray
[INIT_PORT_PROC
],
592 W_EXITCODE (status
, 0), 0);
593 while (__task_terminate (__mach_task_self ()))
594 __mach_task_self_
= (__mach_task_self
) ();
596 /* We need this alias to satisfy references from libc_pic.a objects
597 that were affected by the libc_hidden_proto declaration for _exit. */
598 strong_alias (_exit
, __GI__exit
)
600 /* Try to get a machine dependent instruction which will make the
601 program crash. This is used in case everything else fails. */
602 #include <abort-instr.h>
603 #ifndef ABORT_INSTRUCTION
604 /* No such instruction is available. */
605 # define ABORT_INSTRUCTION
611 /* Try to abort using the system specific command. */
614 /* If the abort instruction failed, exit. */
617 /* If even this fails, make sure we never return. */
619 /* Try for ever and ever. */
623 /* We need this alias to satisfy references from libc_pic.a objects
624 that were affected by the libc_hidden_proto declaration for abort. */
625 strong_alias (abort
, __GI_abort
)
627 /* This function is called by interruptible RPC stubs. For initial
628 dynamic linking, just use the normal mach_msg. Since this defn is
629 weak, the real defn in libc.so will override it if we are linked into
630 the user program (-ldl). */
632 error_t weak_function
633 _hurd_intr_rpc_mach_msg (mach_msg_header_t
*msg
,
634 mach_msg_option_t option
,
635 mach_msg_size_t send_size
,
636 mach_msg_size_t rcv_size
,
637 mach_port_t rcv_name
,
638 mach_msg_timeout_t timeout
,
641 return __mach_msg (msg
, option
, send_size
, rcv_size
, rcv_name
,
649 /* There is nothing to print. Hurd has no auxiliary vector. */
654 _dl_init_first (int argc
, ...)
656 /* This no-op definition only gets used if libc is not linked in. */