sysdeps/mach/hurd/dl-sysdep.c

   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.
   4
   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.
   9
  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.
  14
  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.  */
  19
  20 #include <hurd.h>
  21 #include <link.h>
  22 #include <unistd.h>
  23 #include <fcntl.h>
  24 #include <stdlib.h>
  25 #include <sys/mman.h>
  26 #include <sys/wait.h>
  27 #include <assert.h>
  28 #include <sysdep.h>
  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>
  35 #include <stdarg.h>
  36 #include <ctype.h>
  37 #include <sys/stat.h>
  38
  39 #include "dl-machine.h"
  40
  41 extern void __mach_init (void);
  42
  43 extern int _dl_argc;
  44 extern char **_dl_argv;
  45 extern char **_environ;
  46
  47 int __libc_enable_secure;
  48
  49 struct hurd_startup_data *_dl_hurd_data;
  50
  51 unsigned int __hurd_threadvar_max = _HURD_THREADVAR_MAX;
  52 static unsigned long int threadvars[_HURD_THREADVAR_MAX];
  53 unsigned long int __hurd_threadvar_stack_offset
  54   = (unsigned long int) &threadvars;
  55 unsigned long int __hurd_threadvar_stack_mask;
  56
  57 /* XXX loser kludge for vm_map kernel bug */
  58 static vm_address_t fmha;
  59 static vm_size_t fmhs;
  60 static void unfmh(void){
  61 __vm_deallocate(__mach_task_self(),fmha,fmhs);}
  62 static void fmh(void) {
  63     error_t err;int x;mach_port_t p;
  64     vm_address_t a=0x08000000U,max=VM_MAX_ADDRESS;
  65     while (!(err=__vm_region(__mach_task_self(),&a,&fmhs,&x,&x,&x,&x,&p,&x))){
  66       __mach_port_deallocate(__mach_task_self(),p);
  67       if (a+fmhs>=0x80000000U){
  68         max=a; break;}
  69       fmha=a+=fmhs;}
  70     if (err) assert(err==KERN_NO_SPACE);
  71     if (!fmha)fmhs=0;else{
  72     fmhs=max-fmha;
  73     err = __vm_map (__mach_task_self (),
  74                     &fmha, fmhs, 0, 0, MACH_PORT_NULL, 0, 1,
  75                     VM_PROT_NONE, VM_PROT_NONE, VM_INHERIT_COPY);
  76     assert_perror(err);}
  77   }
  78 /* XXX loser kludge for vm_map kernel bug */
  79
  80
  81
  82 Elf32_Addr
  83 _dl_sysdep_start (void **start_argptr,
  84                   void (*dl_main) (const Elf32_Phdr *phdr, Elf32_Word phent,
  85                                    Elf32_Addr *user_entry))
  86 {
  87   extern void _start ();
  88
  89   void go (int *argdata)
  90     {
  91       extern unsigned int _dl_skip_args; /* rtld.c */
  92       char **p;
  93
  94       /* Cache the information in various global variables.  */
  95       _dl_argc = *argdata;
  96       _dl_argv = 1 + (char **) argdata;
  97       _environ = &_dl_argv[_dl_argc + 1];
  98       for (p = _environ; *p++;); /* Skip environ pointers and terminator.  */
  99
 100       if ((void *) p == _dl_argv[0])
 101         {
 102           static struct hurd_startup_data nodata;
 103           _dl_hurd_data = &nodata;
 104           nodata.user_entry = (vm_address_t) &_start;
 105         }
 106       else
 107         _dl_hurd_data = (void *) p;
 108
 109       __libc_enable_secure = _dl_hurd_data->flags & EXEC_SECURE;
 110
 111       if (_dl_hurd_data->flags & EXEC_STACK_ARGS &&
 112           _dl_hurd_data->user_entry == 0)
 113         _dl_hurd_data->user_entry = (vm_address_t) &_start;
 114
 115 unfmh();                        /* XXX */
 116
 117       if (_dl_hurd_data->user_entry == (vm_address_t) &_start)
 118         /* We were invoked as a command, not as the program interpreter.
 119            The generic ld.so code supports this: it will parse the args
 120            as "ld.so PROGRAM [ARGS...]".  For booting the Hurd, we
 121            support an additional special syntax:
 122              ld.so [-LIBS...] PROGRAM [ARGS...]
 123            Each LIBS word consists of "FILENAME=MEMOBJ";
 124            for example "-/lib/libc.so=123" says that the contents of
 125            /lib/libc.so are found in a memory object whose port name
 126            in our task is 123.  */
 127         while (_dl_argc > 2 && _dl_argv[1][0] == '-' && _dl_argv[1][1] != '-')
 128           {
 129             char *lastslash, *memobjname, *p;
 130             struct link_map *l;
 131             mach_port_t memobj;
 132             error_t err;
 133
 134             ++_dl_skip_args;
 135             --_dl_argc;
 136             p = _dl_argv++[1] + 1;
 137
 138             memobjname = strchr (p, '=');
 139             if (! memobjname)
 140               _dl_sysdep_fatal ("Bogus library spec: ", p, "\n", NULL);
 141             *memobjname++ = '\0';
 142             memobj = 0;
 143             while (*memobjname != '\0')
 144               memobj = (memobj * 10) + (*memobjname++ - '0');
 145
 146             /* Add a user reference on the memory object port, so we will
 147                still have one after _dl_map_object_from_fd calls our
 148                `close'.  */
 149             err = __mach_port_mod_refs (__mach_task_self (), memobj,
 150                                         MACH_PORT_RIGHT_SEND, +1);
 151             assert_perror (err);
 152
 153             lastslash = strrchr (p, '/');
 154             l = _dl_map_object_from_fd (lastslash ? lastslash + 1 : p,
 155                                         memobj, strdup (p));
 156
 157             /* Squirrel away the memory object port where it
 158                can be retrieved by the program later.  */
 159             l->l_info[DT_NULL] = (void *) memobj;
 160           }
 161
 162       /* Call elf/rtld.c's main program.  It will set everything
 163          up and leave us to transfer control to USER_ENTRY.  */
 164       (*dl_main) ((const Elf32_Phdr *) _dl_hurd_data->phdr,
 165                   _dl_hurd_data->phdrsz / sizeof (Elf32_Phdr),
 166                   &_dl_hurd_data->user_entry);
 167
 168       if (_dl_skip_args && _dl_argv[-_dl_skip_args] == (char *) p)
 169         {
 170           /* We are ignoring the first few arguments, but we have no Hurd
 171              startup data.  It is magical convention that ARGV[0] == P in
 172              this case.  The startup code in init-first.c will get confused
 173              if this is not the case, so we must rearrange things to make
 174              it so.  Overwrite the original ARGV[0] at P with
 175              ARGV[_dl_skip_args].  */
 176           assert ((char *) p < _dl_argv[0]);
 177           _dl_argv[0] = strcpy ((char *) p, _dl_argv[0]);
 178         }
 179
 180       {
 181         extern void _dl_start_user (void);
 182         /* Unwind the stack to ARGDATA and simulate a return from _dl_start
 183            to the RTLD_START code which will run the user's entry point.  */
 184         RETURN_TO (argdata, &_dl_start_user, _dl_hurd_data->user_entry);
 185       }
 186     }
 187
 188   /* Set up so we can do RPCs.  */
 189   __mach_init ();
 190
 191   /* Initialize frequently used global variable.  */
 192   _dl_pagesize = __getpagesize ();
 193
 194 fmh();                          /* XXX */
 195
 196   /* See hurd/hurdstartup.c; this deals with getting information
 197      from the exec server and slicing up the arguments.
 198      Then it will call `go', above.  */
 199   _hurd_startup (start_argptr, &go);
 200
 201   LOSE;
 202   abort ();
 203 }
 204
 205 void
 206 _dl_sysdep_start_cleanup (void)
 207 {
 208   /* Deallocate the reply port and task port rights acquired by
 209      __mach_init.  We are done with them now, and the user will
 210      reacquire them for himself when he wants them.  */
 211   __mig_dealloc_reply_port (MACH_PORT_NULL);
 212   __mach_port_deallocate (__mach_task_self (), __mach_task_self_);
 213 }
 214 \f
 215 void
 216 _dl_sysdep_fatal (const char *msg, ...)
 217 {
 218   va_list ap;
 219
 220   va_start (ap, msg);
 221   do
 222     {
 223       size_t len = strlen (msg);
 224       mach_msg_type_number_t nwrote;
 225       do
 226         {
 227           if (__io_write (_hurd_init_dtable[2], msg, len, -1, &nwrote))
 228             break;
 229           len -= nwrote;
 230           msg += nwrote;
 231         } while (nwrote > 0);
 232       msg = va_arg (ap, const char *);
 233     } while (msg);
 234   va_end (ap);
 235
 236   _exit (127);
 237 }
 238
 239
 240 void
 241 _dl_sysdep_error (const char *msg, ...)
 242 {
 243   va_list ap;
 244
 245   va_start (ap, msg);
 246   do
 247     {
 248       size_t len = strlen (msg);
 249       mach_msg_type_number_t nwrote;
 250       do
 251         {
 252           if (__io_write (_hurd_init_dtable[2], msg, len, -1, &nwrote))
 253             break;
 254           len -= nwrote;
 255           msg += nwrote;
 256         } while (nwrote > 0);
 257       msg = va_arg (ap, const char *);
 258     } while (msg);
 259   va_end (ap);
 260 }
 261
 262
 263 void
 264 _dl_sysdep_message (const char *msg, ...)
 265 {
 266   va_list ap;
 267
 268   va_start (ap, msg);
 269   do
 270     {
 271       size_t len = strlen (msg);
 272       mach_msg_type_number_t nwrote;
 273       do
 274         {
 275           if (__io_write (_hurd_init_dtable[1], msg, len, -1, &nwrote))
 276             break;
 277           len -= nwrote;
 278           msg += nwrote;
 279         } while (nwrote > 0);
 280       msg = va_arg (ap, const char *);
 281     } while (msg);
 282   va_end (ap);
 283 }
 284 \f
 285  /* Minimal open/close/mmap implementation sufficient for initial loading of
 286     shared libraries.  These are weak definitions so that when the
 287     dynamic linker re-relocates itself to be user-visible (for -ldl),
 288 /* Minimal open/close/mmap implementation sufficient for initial loading of
 289    shared libraries.  These are weak definitions so that when the
 290    dynamic linker re-relocates itself to be user-visible (for -ldl),
 291    it will get the user's definition (i.e. usually libc's).  */
 292
 293 /* Open FILE_NAME and return a read-mmappable port in MEMOBJ_RD for it, or
 294    return an error.  If STAT is non-zero, stat the file into that stat buffer.  */
 295 static error_t
 296 open_file (const char *file_name, int mode,
 297            mach_port_t *memobj_rd, struct stat *stat)
 298 {
 299   enum retry_type doretry;
 300   char retryname[1024];         /* XXX string_t LOSES! */
 301   file_t startdir, newpt, fileport;
 302   int dealloc_dir;
 303   int nloops;
 304   error_t err;
 305
 306   assert (mode == O_RDONLY);
 307
 308   startdir = _dl_hurd_data->portarray[file_name[0] == '/' ?
 309                                       INIT_PORT_CRDIR : INIT_PORT_CWDIR];
 310
 311   while (file_name[0] == '/')
 312     file_name++;
 313
 314   if (err = __dir_lookup (startdir, (char *)file_name, mode, 0,
 315                           &doretry, retryname, &fileport))
 316     return err;
 317
 318   dealloc_dir = 0;
 319   nloops = 0;
 320
 321   while (1)
 322     {
 323       if (dealloc_dir)
 324         __mach_port_deallocate (__mach_task_self (), startdir);
 325       if (err)
 326         return err;
 327
 328       switch (doretry)
 329         {
 330         case FS_RETRY_REAUTH:
 331           {
 332             mach_port_t ref = __mach_reply_port ();
 333             err = __io_reauthenticate (fileport, ref, MACH_MSG_TYPE_MAKE_SEND);
 334             if (! err)
 335               err = __auth_user_authenticate
 336                 (_dl_hurd_data->portarray[INIT_PORT_AUTH],
 337                  ref, MACH_MSG_TYPE_MAKE_SEND,
 338                  &newpt);
 339             __mach_port_destroy (__mach_task_self (), ref);
 340           }
 341           __mach_port_deallocate (__mach_task_self (), fileport);
 342           if (err)
 343             return err;
 344           fileport = newpt;
 345           /* Fall through.  */
 346
 347         case FS_RETRY_NORMAL:
 348 #ifdef SYMLOOP_MAX
 349           if (nloops++ >= SYMLOOP_MAX)
 350             return ELOOP;
 351 #endif
 352
 353           /* An empty RETRYNAME indicates we have the final port.  */
 354           if (retryname[0] == '\0')
 355             {
 356               mach_port_t memobj_wr;
 357
 358               dealloc_dir = 1;
 359
 360             opened:
 361               /* We have the file open.  Now map it.  */
 362
 363               if (stat)
 364                 err = __io_stat (fileport, stat);
 365               if (! err)
 366                 err = __io_map (fileport, memobj_rd, &memobj_wr);
 367
 368               if (dealloc_dir)
 369                 __mach_port_deallocate (__mach_task_self (), fileport);
 370               if (err)
 371                 return err;
 372
 373               if (memobj_wr != MACH_PORT_NULL)
 374                 __mach_port_deallocate (__mach_task_self (), memobj_wr);
 375
 376               return 0;
 377             }
 378
 379           startdir = fileport;
 380           dealloc_dir = 1;
 381           file_name = retryname;
 382           break;
 383
 384         case FS_RETRY_MAGICAL:
 385           switch (retryname[0])
 386             {
 387             case '/':
 388               startdir = _dl_hurd_data->portarray[INIT_PORT_CRDIR];
 389               dealloc_dir = 0;
 390               if (fileport != MACH_PORT_NULL)
 391                 __mach_port_deallocate (__mach_task_self (), fileport);
 392               file_name = &retryname[1];
 393               break;
 394
 395             case 'f':
 396               if (retryname[1] == 'd' && retryname[2] == '/' &&
 397                   isdigit (retryname[3]))
 398                 {
 399                   /* We can't use strtol for the decoding here
 400                      because it brings in hairy locale bloat.  */
 401                   char *p;
 402                   int fd = 0;
 403                   for (p = &retryname[3]; isdigit (*p); ++p)
 404                     fd = (fd * 10) + (*p - '0');
 405                   /* Check for excess text after the number.  A slash is
 406                      valid; it ends the component.  Anything else does not
 407                      name a numeric file descriptor.  */
 408                   if (*p != '/' && *p != '\0')
 409                     return ENOENT;
 410                   if (fd < 0 || fd >= _dl_hurd_data->dtablesize ||
 411                       _dl_hurd_data->dtable[fd] == MACH_PORT_NULL)
 412                     /* If the name was a proper number, but the file
 413                        descriptor does not exist, we return EBADF instead
 414                        of ENOENT.  */
 415                     return EBADF;
 416                   fileport = _dl_hurd_data->dtable[fd];
 417                   if (*p == '\0')
 418                     {
 419                       /* This descriptor is the file port we want.  */
 420                       dealloc_dir = 0;
 421                       goto opened;
 422                     }
 423                   else
 424                     {
 425                       /* Do a normal retry on the remaining components.  */
 426                       startdir = fileport;
 427                       dealloc_dir = 1;
 428                       file_name = p + 1; /* Skip the slash.  */
 429                       break;
 430                     }
 431                 }
 432               else
 433                 goto bad_magic;
 434               break;
 435
 436             case 'm':
 437               if (retryname[1] == 'a' && retryname[2] == 'c' &&
 438                   retryname[3] == 'h' && retryname[4] == 't' &&
 439                   retryname[5] == 'y' && retryname[6] == 'p' &&
 440                   retryname[7] == 'e')
 441                 {
 442                   error_t err;
 443                   struct host_basic_info hostinfo;
 444                   mach_msg_type_number_t hostinfocnt = HOST_BASIC_INFO_COUNT;
 445                   char *p;
 446                   if (err = __host_info (__mach_host_self (), HOST_BASIC_INFO,
 447                                          (natural_t *) &hostinfo,
 448                                          &hostinfocnt))
 449                     return err;
 450                   if (hostinfocnt != HOST_BASIC_INFO_COUNT)
 451                     return EGRATUITOUS;
 452                   p = _itoa (hostinfo.cpu_subtype, &retryname[8], 10, 0);
 453                   *--p = '/';
 454                   p = _itoa (hostinfo.cpu_type, &retryname[8], 10, 0);
 455                   if (p < retryname)
 456                     abort ();   /* XXX write this right if this ever happens */
 457                   if (p > retryname)
 458                     strcpy (retryname, p);
 459                   startdir = fileport;
 460                   dealloc_dir = 1;
 461                 }
 462               else
 463                 goto bad_magic;
 464               break;
 465
 466             case 't':
 467               if (retryname[1] == 't' && retryname[2] == 'y')
 468                 switch (retryname[3])
 469                   {
 470                     error_t opentty (file_t *result)
 471                       {
 472                         error_t err;
 473                         file_t unauth;
 474                         err = __termctty_open_terminal
 475                           (_dl_hurd_data->portarray[INIT_PORT_CTTYID],
 476                            mode, &unauth);
 477                         if (! err)
 478                           {
 479                             mach_port_t ref = __mach_reply_port ();
 480                             err = __io_reauthenticate
 481                               (unauth, ref, MACH_MSG_TYPE_MAKE_SEND);
 482                             if (! err)
 483                               err = __auth_user_authenticate
 484                                 (_dl_hurd_data->portarray[INIT_PORT_AUTH],
 485                                  ref, MACH_MSG_TYPE_MAKE_SEND,
 486                                  result);
 487                             __mach_port_deallocate (__mach_task_self (),
 488                                                     unauth);
 489                             __mach_port_destroy (__mach_task_self (), ref);
 490                           }
 491                         return err;
 492                       }
 493
 494                   case '\0':
 495                     if (err = opentty (&fileport))
 496                       return err;
 497                     dealloc_dir = 1;
 498                     goto opened;
 499                   case '/':
 500                     if (err = opentty (&startdir))
 501                       return err;
 502                     dealloc_dir = 1;
 503                     strcpy (retryname, &retryname[4]);
 504                     break;
 505                   default:
 506                     goto bad_magic;
 507                   }
 508               else
 509                 goto bad_magic;
 510               break;
 511
 512             default:
 513             bad_magic:
 514               return EGRATUITOUS;
 515             }
 516           break;
 517
 518         default:
 519           return EGRATUITOUS;
 520         }
 521
 522       err = __dir_lookup (startdir, (char *)file_name, mode, 0,
 523                           &doretry, retryname, &fileport);
 524     }
 525 }
 526
 527 int weak_function
 528 __open (const char *file_name, int mode, ...)
 529 {
 530   mach_port_t memobj_rd;
 531   error_t err = open_file (file_name, mode, &memobj_rd, 0);
 532   if (err)
 533     return __hurd_fail (err);
 534   else
 535     return (int)memobj_rd;
 536 }
 537
 538 int weak_function
 539 __close (int fd)
 540 {
 541   if (fd != (int) MACH_PORT_NULL)
 542     __mach_port_deallocate (__mach_task_self (), (mach_port_t) fd);
 543   return 0;
 544 }
 545
 546 caddr_t weak_function
 547 __mmap (caddr_t addr, size_t len, int prot, int flags, int fd, off_t offset)
 548 {
 549   error_t err;
 550   vm_prot_t vmprot;
 551   vm_address_t mapaddr;
 552
 553   vmprot = VM_PROT_NONE;
 554   if (prot & PROT_READ)
 555     vmprot |= VM_PROT_READ;
 556   if (prot & PROT_WRITE)
 557     vmprot |= VM_PROT_WRITE;
 558   if (prot & PROT_EXEC)
 559     vmprot |= VM_PROT_EXECUTE;
 560
 561   mapaddr = (vm_address_t) addr;
 562   err = __vm_map (__mach_task_self (),
 563                   &mapaddr, (vm_size_t) len, 0 /*ELF_MACHINE_USER_ADDRESS_MASK*/,
 564                   !(flags & MAP_FIXED),
 565                   (flags & MAP_ANON) ? MACH_PORT_NULL : (mach_port_t) fd,
 566                   (vm_offset_t) offset,
 567                   flags & (MAP_COPY|MAP_PRIVATE),
 568                   vmprot, VM_PROT_ALL,
 569                   (flags & MAP_SHARED) ? VM_INHERIT_SHARE : VM_INHERIT_COPY);
 570   if (err == KERN_NO_SPACE && (flags & MAP_FIXED))
 571     {
 572
 573 void weak_function
 574 _dl_sysdep_fatal (const char *msg, ...)
 575 {
 576   va_list ap;
 577
 578   va_start (ap, msg);
 579   do
 580     {
 581       size_t len = strlen (msg);
 582       mach_msg_type_number_t nwrote;
 583       do
 584         {
 585           if (__io_write (_hurd_init_dtable[2], msg, len, -1, &nwrote))
 586             break;
 587           len -= nwrote;
 588           msg += nwrote;
 589         } while (nwrote > 0);
 590       msg = va_arg (ap, const char *);
 591     } while (msg);
 592   va_end (ap);
 593
 594   _exit (127);
 595 }
 596
 597
 598 void weak_function
 599 _dl_sysdep_error (const char *msg, ...)
 600 {
 601   va_list ap;
 602
 603   va_start (ap, msg);
 604   do
 605     {
 606       size_t len = strlen (msg);
 607       mach_msg_type_number_t nwrote;
 608       do
 609         {
 610           if (__io_write (_hurd_init_dtable[2], msg, len, -1, &nwrote))
 611             break;
 612           len -= nwrote;
 613           msg += nwrote;
 614         } while (nwrote > 0);
 615       msg = va_arg (ap, const char *);
 616     } while (msg);
 617   va_end (ap);
 618 }
 619
 620
 621 void weak_function
 622 _dl_sysdep_message (const char *msg, ...)
 623 {
 624   va_list ap;
 625
 626   va_start (ap, msg);
 627   do
 628     {
 629       size_t len = strlen (msg);
 630       mach_msg_type_number_t nwrote;
 631       do
 632         {
 633           if (__io_write (_hurd_init_dtable[1], msg, len, -1, &nwrote))
 634             break;
 635           len -= nwrote;
 636           msg += nwrote;
 637         } while (nwrote > 0);
 638       msg = va_arg (ap, const char *);
 639     } while (msg);
 640   va_end (ap);
 641 }
 642       /* XXX this is not atomic as it is in unix! */
 643       /* The region is already allocated; deallocate it first.  */
 644       err = __vm_deallocate (__mach_task_self (), mapaddr, len);
 645       if (! err)
 646         err = __vm_map (__mach_task_self (),
 647                         &mapaddr, (vm_size_t) len, 0 /*ELF_MACHINE_USER_ADDRESS_MASK*/,
 648                         !(flags & MAP_FIXED),
 649                         (mach_port_t) fd, (vm_offset_t) offset,
 650                         flags & (MAP_COPY|MAP_PRIVATE),
 651                         vmprot, VM_PROT_ALL,
 652                         (flags & MAP_SHARED)
 653                         ? VM_INHERIT_SHARE : VM_INHERIT_COPY);
 654     }
 655
 656   return err ? (caddr_t) __hurd_fail (err) : (caddr_t) mapaddr;
 657 }
 658
 659 void weak_function
 660 _exit (int status)
 661 {
 662   __proc_mark_exit (_dl_hurd_data->portarray[INIT_PORT_PROC],
 663                     W_EXITCODE (status, 0), 0);
 664   while (__task_terminate (__mach_task_self ()))
 665     __mach_task_self_ = (__mach_task_self) ();
 666 }
 667 \f
 668 /* Read the whole contents of FILE into new mmap'd space with given
 669    protections.  The size of the file is returned in SIZE.  */
 670 void *
 671 weak_function
 672 _dl_sysdep_read_whole_file (const char *file, size_t *size, int prot)
 673 {
 674   struct stat stat;
 675   mach_port_t memobj_rd;
 676   void *contents;
 677   error_t err = open_file (file, O_RDONLY, &memobj_rd, &stat);
 678
 679   if (! err)
 680     {
 681       /* Map a copy of the file contents.  */
 682       contents = __mmap (0, stat.st_size, prot, MAP_COPY, memobj_rd, 0);
 683       if (contents == (void *)-1)
 684         contents = 0;
 685       else
 686         *size = stat.st_size;
 687
 688       __mach_port_deallocate (__mach_task_self (), memobj_rd);
 689     }
 690   else
 691     {
 692       __hurd_fail (err);
 693       contents = 0;
 694     }
 695
 696   return contents;
 697 }
 698 \f
 699 /* This function is called by interruptible RPC stubs.  For initial
 700    dynamic linking, just use the normal mach_msg.  Since this defn is
 701    weak, the real defn in libc.so will override it if we are linked into
 702    the user program (-ldl).  */
 703
 704 error_t weak_function
 705 _hurd_intr_rpc_mach_msg (mach_msg_header_t *msg,
 706                          mach_msg_option_t option,
 707                          mach_msg_size_t send_size,
 708                          mach_msg_size_t rcv_size,
 709                          mach_port_t rcv_name,
 710                          mach_msg_timeout_t timeout,
 711                          mach_port_t notify)
 712 {
 713   return __mach_msg (msg, option, send_size, rcv_size, rcv_name,
 714                      timeout, notify);
 715 }
 716
 717
 718 void
 719 _dl_show_auxv (void)
 720 {
 721   /* There is nothing to print.  Hurd has no auxiliary vector.  */
 722 }