sysdeps/unix/sysv/linux/dl-sysdep.c

   1 /* Dynamic linker system dependencies for Linux.
   2    Copyright (C) 1995-2014 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 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.
   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    Lesser General Public License for more details.
  14
  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/>.  */
  18
  19 /* Linux needs some special initialization, but otherwise uses
  20    the generic dynamic linker system interface code.  */
  21
  22 #include <assert.h>
  23 #include <string.h>
  24 #include <fcntl.h>
  25 #include <unistd.h>
  26 #include <sys/utsname.h>
  27 #include <ldsodefs.h>
  28 #include <kernel-features.h>
  29
  30 #ifdef SHARED
  31 # define DL_SYSDEP_INIT frob_brk ()
  32
  33 static inline void
  34 frob_brk (void)
  35 {
  36   __brk (0);                    /* Initialize the break.  */
  37 }
  38
  39 # include <elf/dl-sysdep.c>
  40 #endif
  41
  42
  43 int
  44 attribute_hidden
  45 _dl_discover_osversion (void)
  46 {
  47 #if defined NEED_DL_SYSINFO_DSO && defined SHARED
  48   if (GLRO(dl_sysinfo_map) != NULL)
  49     {
  50       /* If the kernel-supplied DSO contains a note indicating the kernel's
  51          version, we don't need to call uname or parse any strings.  */
  52
  53       static const struct
  54       {
  55         ElfW(Nhdr) hdr;
  56         char vendor[8];
  57       } expected_note = { { sizeof "Linux", sizeof (ElfW(Word)), 0 }, "Linux" };
  58       const ElfW(Phdr) *const phdr = GLRO(dl_sysinfo_map)->l_phdr;
  59       const ElfW(Word) phnum = GLRO(dl_sysinfo_map)->l_phnum;
  60       for (uint_fast16_t i = 0; i < phnum; ++i)
  61         if (phdr[i].p_type == PT_NOTE)
  62           {
  63             const ElfW(Addr) start = (phdr[i].p_vaddr
  64                                       + GLRO(dl_sysinfo_map)->l_addr);
  65             const ElfW(Nhdr) *note = (const void *) start;
  66             while ((ElfW(Addr)) (note + 1) - start < phdr[i].p_memsz)
  67               {
  68                 if (!memcmp (note, &expected_note, sizeof expected_note))
  69                   return *(const ElfW(Word) *) ((const void *) note
  70                                                 + sizeof expected_note);
  71 #define ROUND(len) (((len) + sizeof note->n_type - 1) & -sizeof note->n_type)
  72                 note = ((const void *) (note + 1)
  73                         + ROUND (note->n_namesz) + ROUND (note->n_descsz));
  74 #undef ROUND
  75               }
  76           }
  77     }
  78 #endif
  79
  80   char bufmem[64];
  81   char *buf = bufmem;
  82   unsigned int version;
  83   int parts;
  84   char *cp;
  85   struct utsname uts;
  86
  87   /* Try the uname system call.  */
  88   if (__uname (&uts))
  89     {
  90       /* This was not successful.  Now try reading the /proc filesystem.  */
  91       int fd = __open ("/proc/sys/kernel/osrelease", O_RDONLY);
  92       if (fd < 0)
  93         return -1;
  94       ssize_t reslen = __read (fd, bufmem, sizeof (bufmem));
  95       __close (fd);
  96       if (reslen <= 0)
  97         /* This also didn't work.  We give up since we cannot
  98            make sure the library can actually work.  */
  99         return -1;
 100       buf[MIN (reslen, (ssize_t) sizeof (bufmem) - 1)] = '\0';
 101     }
 102   else
 103     buf = uts.release;
 104
 105   /* Now convert it into a number.  The string consists of at most
 106      three parts.  */
 107   version = 0;
 108   parts = 0;
 109   cp = buf;
 110   while ((*cp >= '0') && (*cp <= '9'))
 111     {
 112       unsigned int here = *cp++ - '0';
 113
 114       while ((*cp >= '0') && (*cp <= '9'))
 115         {
 116           here *= 10;
 117           here += *cp++ - '0';
 118         }
 119
 120       ++parts;
 121       version <<= 8;
 122       version |= here;
 123
 124       if (*cp++ != '.' || parts == 3)
 125         /* Another part following?  */
 126         break;
 127     }
 128
 129   if (parts < 3)
 130     version <<= 8 * (3 - parts);
 131
 132   return version;
 133 }
 134
 135 /* Mask every signal, returning the previous sigmask in OLD.  */
 136 void
 137 internal_function
 138 _dl_mask_all_signals (sigset_t *old)
 139 {
 140   int ret;
 141   sigset_t new;
 142
 143   sigfillset (&new);
 144
 145   /* This function serves as a replacement to pthread_sigmask, which
 146      isn't available from within the dynamic linker since it would require
 147      linking with libpthread. We duplicate some of the functionality here
 148      to avoid requiring libpthread.  This isn't quite identical to
 149      pthread_sigmask in that we do not mask internal signals used for
 150      cancellation and setxid handling. This disables asynchronous
 151      cancellation for the duration the signals are disabled, but it's a
 152      small window, and prevents any problems with the use of TLS variables
 153      in the signal handlers that would have executed.  */
 154
 155   /* It's very important we don't touch errno here, as that's TLS; since this
 156      gets called from get_tls_addr we might end up recursing.  */
 157
 158   INTERNAL_SYSCALL_DECL (err);
 159
 160   ret = INTERNAL_SYSCALL (rt_sigprocmask, err, 4, SIG_SETMASK, &new, old,
 161                           _NSIG / 8);
 162
 163   assert (ret == 0);
 164 }
 165
 166 /* Return sigmask to what it was before a call to _dl_mask_all_signals.  */
 167 void
 168 internal_function
 169 _dl_unmask_signals (sigset_t *old)
 170 {
 171   int ret;
 172   INTERNAL_SYSCALL_DECL (err);
 173
 174   ret = INTERNAL_SYSCALL (rt_sigprocmask, err, 4, SIG_SETMASK, old, NULL,
 175                           _NSIG / 8);
 176
 177   assert (ret == 0);
 178 }