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 uid_t __libc_uid;
  48 int __libc_enable_secure;
  49
  50 struct hurd_startup_data *_dl_hurd_data;
  51
  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;
  57
  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){
  69         max=a; break;}
  70       fmha=a+=fmhs;}
  71     if (err) assert(err==KERN_NO_SPACE);
  72     if (!fmha)fmhs=0;else{
  73     fmhs=max-fmha;
  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);
  77     assert_perror(err);}
  78   }
  79 /* XXX loser kludge for vm_map kernel bug */
  80
  81
  82
  83 Elf32_Addr
  84 _dl_sysdep_start (void **start_argptr,
  85                   void (*dl_main) (const Elf32_Phdr *phdr, Elf32_Word phent,
  86                                    Elf32_Addr *user_entry))
  87 {
  88   extern void _start ();
  89
  90   void go (int *argdata)
  91     {
  92       extern unsigned int _dl_skip_args; /* rtld.c */
  93       char **p;
  94
  95       /* Cache the information in various global variables.  */
  96       _dl_argc = *argdata;
  97       _dl_argv = 1 + (char **) argdata;
  98       _environ = &_dl_argv[_dl_argc + 1];
  99       for (p = _environ; *p++;); /* Skip environ pointers and terminator.  */
 100
 101       if ((void *) p == _dl_argv[0])
 102         {
 103           static struct hurd_startup_data nodata;
 104           _dl_hurd_data = &nodata;
 105           nodata.user_entry = (vm_address_t) &_start;
 106         }
 107       else
 108         _dl_hurd_data = (void *) p;
 109
 110       __libc_uid = __getuid ();
 111       __libc_enable_secure = _dl_hurd_data->flags & EXEC_SECURE;
 112
 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;
 116
 117 unfmh();                        /* XXX */
 118
 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] != '-')
 130           {
 131             char *lastslash, *memobjname, *p;
 132             struct link_map *l;
 133             mach_port_t memobj;
 134             error_t err;
 135
 136             ++_dl_skip_args;
 137             --_dl_argc;
 138             p = _dl_argv++[1] + 1;
 139
 140             memobjname = strchr (p, '=');
 141             if (! memobjname)
 142               _dl_sysdep_fatal ("Bogus library spec: ", p, "\n", NULL);
 143             *memobjname++ = '\0';
 144             memobj = 0;
 145             while (*memobjname != '\0')
 146               memobj = (memobj * 10) + (*memobjname++ - '0');
 147
 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
 150                `close'.  */
 151             err = __mach_port_mod_refs (__mach_task_self (), memobj,
 152                                         MACH_PORT_RIGHT_SEND, +1);
 153             assert_perror (err);
 154
 155             lastslash = strrchr (p, '/');
 156             l = _dl_map_object_from_fd (lastslash ? lastslash + 1 : p,
 157                                         memobj, strdup (p));
 158
 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;
 162           }
 163
 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);
 169
 170       if (_dl_skip_args && _dl_argv[-_dl_skip_args] == (char *) p)
 171         {
 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]);
 180         }
 181
 182       {
 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);
 187       }
 188     }
 189
 190   /* Set up so we can do RPCs.  */
 191   __mach_init ();
 192
 193   /* Initialize frequently used global variable.  */
 194   _dl_pagesize = __getpagesize ();
 195
 196 fmh();                          /* XXX */
 197
 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);
 202
 203   LOSE;
 204   abort ();
 205 }
 206
 207 void
 208 _dl_sysdep_start_cleanup (void)
 209 {
 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_);
 215 }
 216 \f
 217 void
 218 _dl_sysdep_fatal (const char *msg, ...)
 219 {
 220   va_list ap;
 221
 222   va_start (ap, msg);
 223   do
 224     {
 225       size_t len = strlen (msg);
 226       mach_msg_type_number_t nwrote;
 227       do
 228         {
 229           if (__io_write (_hurd_init_dtable[2], msg, len, -1, &nwrote))
 230             break;
 231           len -= nwrote;
 232           msg += nwrote;
 233         } while (nwrote > 0);
 234       msg = va_arg (ap, const char *);
 235     } while (msg);
 236   va_end (ap);
 237
 238   _exit (127);
 239 }
 240
 241
 242 void
 243 _dl_sysdep_error (const char *msg, ...)
 244 {
 245   va_list ap;
 246
 247   va_start (ap, msg);
 248   do
 249     {
 250       size_t len = strlen (msg);
 251       mach_msg_type_number_t nwrote;
 252       do
 253         {
 254           if (__io_write (_hurd_init_dtable[2], msg, len, -1, &nwrote))
 255             break;
 256           len -= nwrote;
 257           msg += nwrote;
 258         } while (nwrote > 0);
 259       msg = va_arg (ap, const char *);
 260     } while (msg);
 261   va_end (ap);
 262 }
 263
 264
 265 void
 266 _dl_sysdep_message (const char *msg, ...)
 267 {
 268   va_list ap;
 269
 270   va_start (ap, msg);
 271   do
 272     {
 273       size_t len = strlen (msg);
 274       mach_msg_type_number_t nwrote;
 275       do
 276         {
 277           if (__io_write (_hurd_init_dtable[1], msg, len, -1, &nwrote))
 278             break;
 279           len -= nwrote;
 280           msg += nwrote;
 281         } while (nwrote > 0);
 282       msg = va_arg (ap, const char *);
 283     } while (msg);
 284   va_end (ap);
 285 }
 286 \f
 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).  */
 294
 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.  */
 297 static error_t
 298 open_file (const char *file_name, int mode,
 299            mach_port_t *memobj_rd, struct stat *stat)
 300 {
 301   enum retry_type doretry;
 302   char retryname[1024];         /* XXX string_t LOSES! */
 303   file_t startdir, newpt, fileport;
 304   int dealloc_dir;
 305   int nloops;
 306   error_t err;
 307
 308   assert (mode == O_RDONLY);
 309
 310   startdir = _dl_hurd_data->portarray[file_name[0] == '/' ?
 311                                       INIT_PORT_CRDIR : INIT_PORT_CWDIR];
 312
 313   while (file_name[0] == '/')
 314     file_name++;
 315
 316   if (err = __dir_lookup (startdir, (char *)file_name, mode, 0,
 317                           &doretry, retryname, &fileport))
 318     return err;
 319
 320   dealloc_dir = 0;
 321   nloops = 0;
 322
 323   while (1)
 324     {
 325       if (dealloc_dir)
 326         __mach_port_deallocate (__mach_task_self (), startdir);
 327       if (err)
 328         return err;
 329
 330       switch (doretry)
 331         {
 332         case FS_RETRY_REAUTH:
 333           {
 334             mach_port_t ref = __mach_reply_port ();
 335             err = __io_reauthenticate (fileport, ref, MACH_MSG_TYPE_MAKE_SEND);
 336             if (! err)
 337               err = __auth_user_authenticate
 338                 (_dl_hurd_data->portarray[INIT_PORT_AUTH],
 339                  ref, MACH_MSG_TYPE_MAKE_SEND,
 340                  &newpt);
 341             __mach_port_destroy (__mach_task_self (), ref);
 342           }
 343           __mach_port_deallocate (__mach_task_self (), fileport);
 344           if (err)
 345             return err;
 346           fileport = newpt;
 347           /* Fall through.  */
 348
 349         case FS_RETRY_NORMAL:
 350 #ifdef SYMLOOP_MAX
 351           if (nloops++ >= SYMLOOP_MAX)
 352             return ELOOP;
 353 #endif
 354
 355           /* An empty RETRYNAME indicates we have the final port.  */
 356           if (retryname[0] == '\0')
 357             {
 358               mach_port_t memobj_wr;
 359
 360               dealloc_dir = 1;
 361
 362             opened:
 363               /* We have the file open.  Now map it.  */
 364
 365               if (stat)
 366                 err = __io_stat (fileport, stat);
 367               if (! err)
 368                 err = __io_map (fileport, memobj_rd, &memobj_wr);
 369
 370               if (dealloc_dir)
 371                 __mach_port_deallocate (__mach_task_self (), fileport);
 372               if (err)
 373                 return err;
 374
 375               if (memobj_wr != MACH_PORT_NULL)
 376                 __mach_port_deallocate (__mach_task_self (), memobj_wr);
 377
 378               return 0;
 379             }
 380
 381           startdir = fileport;
 382           dealloc_dir = 1;
 383           file_name = retryname;
 384           break;
 385
 386         case FS_RETRY_MAGICAL:
 387           switch (retryname[0])
 388             {
 389             case '/':
 390               startdir = _dl_hurd_data->portarray[INIT_PORT_CRDIR];
 391               dealloc_dir = 0;
 392               if (fileport != MACH_PORT_NULL)
 393                 __mach_port_deallocate (__mach_task_self (), fileport);
 394               file_name = &retryname[1];
 395               break;
 396
 397             case 'f':
 398               if (retryname[1] == 'd' && retryname[2] == '/' &&
 399                   isdigit (retryname[3]))
 400                 {
 401                   /* We can't use strtol for the decoding here
 402                      because it brings in hairy locale bloat.  */
 403                   char *p;
 404                   int fd = 0;
 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')
 411                     return ENOENT;
 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
 416                        of ENOENT.  */
 417                     return EBADF;
 418                   fileport = _dl_hurd_data->dtable[fd];
 419                   if (*p == '\0')
 420                     {
 421                       /* This descriptor is the file port we want.  */
 422                       dealloc_dir = 0;
 423                       goto opened;
 424                     }
 425                   else
 426                     {
 427                       /* Do a normal retry on the remaining components.  */
 428                       startdir = fileport;
 429                       dealloc_dir = 1;
 430                       file_name = p + 1; /* Skip the slash.  */
 431                       break;
 432                     }
 433                 }
 434               else
 435                 goto bad_magic;
 436               break;
 437
 438             case 'm':
 439               if (retryname[1] == 'a' && retryname[2] == 'c' &&
 440                   retryname[3] == 'h' && retryname[4] == 't' &&
 441                   retryname[5] == 'y' && retryname[6] == 'p' &&
 442                   retryname[7] == 'e')
 443                 {
 444                   error_t err;
 445                   struct host_basic_info hostinfo;
 446                   mach_msg_type_number_t hostinfocnt = HOST_BASIC_INFO_COUNT;
 447                   char *p;
 448                   if (err = __host_info (__mach_host_self (), HOST_BASIC_INFO,
 449                                          (natural_t *) &hostinfo,
 450                                          &hostinfocnt))
 451                     return err;
 452                   if (hostinfocnt != HOST_BASIC_INFO_COUNT)
 453                     return EGRATUITOUS;
 454                   p = _itoa (hostinfo.cpu_subtype, &retryname[8], 10, 0);
 455                   *--p = '/';
 456                   p = _itoa (hostinfo.cpu_type, &retryname[8], 10, 0);
 457                   if (p < retryname)
 458                     abort ();   /* XXX write this right if this ever happens */
 459                   if (p > retryname)
 460                     strcpy (retryname, p);
 461                   startdir = fileport;
 462                   dealloc_dir = 1;
 463                 }
 464               else
 465                 goto bad_magic;
 466               break;
 467
 468             case 't':
 469               if (retryname[1] == 't' && retryname[2] == 'y')
 470                 switch (retryname[3])
 471                   {
 472                     error_t opentty (file_t *result)
 473                       {
 474                         error_t err;
 475                         file_t unauth;
 476                         err = __termctty_open_terminal
 477                           (_dl_hurd_data->portarray[INIT_PORT_CTTYID],
 478                            mode, &unauth);
 479                         if (! err)
 480                           {
 481                             mach_port_t ref = __mach_reply_port ();
 482                             err = __io_reauthenticate
 483                               (unauth, ref, MACH_MSG_TYPE_MAKE_SEND);
 484                             if (! err)
 485                               err = __auth_user_authenticate
 486                                 (_dl_hurd_data->portarray[INIT_PORT_AUTH],
 487                                  ref, MACH_MSG_TYPE_MAKE_SEND,
 488                                  result);
 489                             __mach_port_deallocate (__mach_task_self (),
 490                                                     unauth);
 491                             __mach_port_destroy (__mach_task_self (), ref);
 492                           }
 493                         return err;
 494                       }
 495
 496                   case '\0':
 497                     if (err = opentty (&fileport))
 498                       return err;
 499                     dealloc_dir = 1;
 500                     goto opened;
 501                   case '/':
 502                     if (err = opentty (&startdir))
 503                       return err;
 504                     dealloc_dir = 1;
 505                     strcpy (retryname, &retryname[4]);
 506                     break;
 507                   default:
 508                     goto bad_magic;
 509                   }
 510               else
 511                 goto bad_magic;
 512               break;
 513
 514             default:
 515             bad_magic:
 516               return EGRATUITOUS;
 517             }
 518           break;
 519
 520         default:
 521           return EGRATUITOUS;
 522         }
 523
 524       err = __dir_lookup (startdir, (char *)file_name, mode, 0,
 525                           &doretry, retryname, &fileport);
 526     }
 527 }
 528
 529 int weak_function
 530 __open (const char *file_name, int mode, ...)
 531 {
 532   mach_port_t memobj_rd;
 533   error_t err = open_file (file_name, mode, &memobj_rd, 0);
 534   if (err)
 535     return __hurd_fail (err);
 536   else
 537     return (int)memobj_rd;
 538 }
 539
 540 int weak_function
 541 __close (int fd)
 542 {
 543   if (fd != (int) MACH_PORT_NULL)
 544     __mach_port_deallocate (__mach_task_self (), (mach_port_t) fd);
 545   return 0;
 546 }
 547
 548 caddr_t weak_function
 549 __mmap (caddr_t addr, size_t len, int prot, int flags, int fd, off_t offset)
 550 {
 551   error_t err;
 552   vm_prot_t vmprot;
 553   vm_address_t mapaddr;
 554
 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;
 562
 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),
 570                   vmprot, VM_PROT_ALL,
 571                   (flags & MAP_SHARED) ? VM_INHERIT_SHARE : VM_INHERIT_COPY);
 572   if (err == KERN_NO_SPACE && (flags & MAP_FIXED))
 573     {
 574
 575 void weak_function
 576 _dl_sysdep_fatal (const char *msg, ...)
 577 {
 578   va_list ap;
 579
 580   va_start (ap, msg);
 581   do
 582     {
 583       size_t len = strlen (msg);
 584       mach_msg_type_number_t nwrote;
 585       do
 586         {
 587           if (__io_write (_hurd_init_dtable[2], msg, len, -1, &nwrote))
 588             break;
 589           len -= nwrote;
 590           msg += nwrote;
 591         } while (nwrote > 0);
 592       msg = va_arg (ap, const char *);
 593     } while (msg);
 594   va_end (ap);
 595
 596   _exit (127);
 597 }
 598
 599
 600 void weak_function
 601 _dl_sysdep_error (const char *msg, ...)
 602 {
 603   va_list ap;
 604
 605   va_start (ap, msg);
 606   do
 607     {
 608       size_t len = strlen (msg);
 609       mach_msg_type_number_t nwrote;
 610       do
 611         {
 612           if (__io_write (_hurd_init_dtable[2], msg, len, -1, &nwrote))
 613             break;
 614           len -= nwrote;
 615           msg += nwrote;
 616         } while (nwrote > 0);
 617       msg = va_arg (ap, const char *);
 618     } while (msg);
 619   va_end (ap);
 620 }
 621
 622
 623 void weak_function
 624 _dl_sysdep_message (const char *msg, ...)
 625 {
 626   va_list ap;
 627
 628   va_start (ap, msg);
 629   do
 630     {
 631       size_t len = strlen (msg);
 632       mach_msg_type_number_t nwrote;
 633       do
 634         {
 635           if (__io_write (_hurd_init_dtable[1], msg, len, -1, &nwrote))
 636             break;
 637           len -= nwrote;
 638           msg += nwrote;
 639         } while (nwrote > 0);
 640       msg = va_arg (ap, const char *);
 641     } while (msg);
 642   va_end (ap);
 643 }
 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);
 647       if (! err)
 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),
 653                         vmprot, VM_PROT_ALL,
 654                         (flags & MAP_SHARED)
 655                         ? VM_INHERIT_SHARE : VM_INHERIT_COPY);
 656     }
 657
 658   return err ? (caddr_t) __hurd_fail (err) : (caddr_t) mapaddr;
 659 }
 660
 661 void weak_function
 662 _exit (int status)
 663 {
 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) ();
 668 }
 669 \f
 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.  */
 672 void *
 673 weak_function
 674 _dl_sysdep_read_whole_file (const char *file, size_t *size, int prot)
 675 {
 676   struct stat stat;
 677   mach_port_t memobj_rd;
 678   void *contents;
 679   error_t err = open_file (file, O_RDONLY, &memobj_rd, &stat);
 680
 681   if (! err)
 682     {
 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)
 686         contents = 0;
 687       else
 688         *size = stat.st_size;
 689
 690       __mach_port_deallocate (__mach_task_self (), memobj_rd);
 691     }
 692   else
 693     {
 694       __hurd_fail (err);
 695       contents = 0;
 696     }
 697
 698   return contents;
 699 }
 700 \f
 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).  */
 705
 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,
 713                          mach_port_t notify)
 714 {
 715   return __mach_msg (msg, option, send_size, rcv_size, rcv_name,
 716                      timeout, notify);
 717 }
 718
 719
 720 void
 721 _dl_show_auxv (void)
 722 {
 723   /* There is nothing to print.  Hurd has no auxiliary vector.  */
 724 }