nptl/pthread_getattr_np.c

   1 /* Copyright (C) 2002-2016 Free Software Foundation, Inc.
   2    This file is part of the GNU C Library.
   3    Contributed by Ulrich Drepper <drepper@redhat.com>, 2002.
   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 #include <assert.h>
  20 #include <errno.h>
  21 #include <inttypes.h>
  22 #include <stdio.h>
  23 #include <stdio_ext.h>
  24 #include <stdlib.h>
  25 #include <string.h>
  26 #include <sys/resource.h>
  27 #include "pthreadP.h"
  28 #include <lowlevellock.h>
  29 #include <ldsodefs.h>
  30
  31
  32 int
  33 pthread_getattr_np (pthread_t thread_id, pthread_attr_t *attr)
  34 {
  35   struct pthread *thread = (struct pthread *) thread_id;
  36   struct pthread_attr *iattr = (struct pthread_attr *) attr;
  37   int ret = 0;
  38
  39   lll_lock (thread->lock, LLL_PRIVATE);
  40
  41   /* The thread library is responsible for keeping the values in the
  42      thread desriptor up-to-date in case the user changes them.  */
  43   memcpy (&iattr->schedparam, &thread->schedparam,
  44           sizeof (struct sched_param));
  45   iattr->schedpolicy = thread->schedpolicy;
  46
  47   /* Clear the flags work.  */
  48   iattr->flags = thread->flags;
  49
  50   /* The thread might be detached by now.  */
  51   if (IS_DETACHED (thread))
  52     iattr->flags |= ATTR_FLAG_DETACHSTATE;
  53
  54   /* This is the guardsize after adjusting it.  */
  55   iattr->guardsize = thread->reported_guardsize;
  56
  57   /* The sizes are subject to alignment.  */
  58   if (__glibc_likely (thread->stackblock != NULL))
  59     {
  60       iattr->stacksize = thread->stackblock_size;
  61 #if _STACK_GROWS_DOWN
  62       iattr->stackaddr = (char *) thread->stackblock + iattr->stacksize;
  63 #else
  64       iattr->stackaddr = (char *) thread->stackblock;
  65 #endif
  66     }
  67   else
  68     {
  69       /* No stack information available.  This must be for the initial
  70          thread.  Get the info in some magical way.  */
  71       assert (abs (thread->pid) == thread->tid);
  72
  73       /* Stack size limit.  */
  74       struct rlimit rl;
  75
  76       /* The safest way to get the top of the stack is to read
  77          /proc/self/maps and locate the line into which
  78          __libc_stack_end falls.  */
  79       FILE *fp = fopen ("/proc/self/maps", "rce");
  80       if (fp == NULL)
  81         ret = errno;
  82       /* We need the limit of the stack in any case.  */
  83       else
  84         {
  85           if (getrlimit (RLIMIT_STACK, &rl) != 0)
  86             ret = errno;
  87           else
  88             {
  89               /* We consider the main process stack to have ended with
  90                  the page containing __libc_stack_end.  There is stuff below
  91                  it in the stack too, like the program arguments, environment
  92                  variables and auxv info, but we ignore those pages when
  93                  returning size so that the output is consistent when the
  94                  stack is marked executable due to a loaded DSO requiring
  95                  it.  */
  96               void *stack_end = (void *) ((uintptr_t) __libc_stack_end
  97                                           & -(uintptr_t) GLRO(dl_pagesize));
  98 #if _STACK_GROWS_DOWN
  99               stack_end += GLRO(dl_pagesize);
 100 #endif
 101               /* We need no locking.  */
 102               __fsetlocking (fp, FSETLOCKING_BYCALLER);
 103
 104               /* Until we found an entry (which should always be the case)
 105                  mark the result as a failure.  */
 106               ret = ENOENT;
 107
 108               char *line = NULL;
 109               size_t linelen = 0;
 110 #if _STACK_GROWS_DOWN
 111               uintptr_t last_to = 0;
 112 #endif
 113
 114               while (! feof_unlocked (fp))
 115                 {
 116                   if (__getdelim (&line, &linelen, '\n', fp) <= 0)
 117                     break;
 118
 119                   uintptr_t from;
 120                   uintptr_t to;
 121                   if (sscanf (line, "%" SCNxPTR "-%" SCNxPTR, &from, &to) != 2)
 122                     continue;
 123                   if (from <= (uintptr_t) __libc_stack_end
 124                       && (uintptr_t) __libc_stack_end < to)
 125                     {
 126                       /* Found the entry.  Now we have the info we need.  */
 127                       iattr->stackaddr = stack_end;
 128                       iattr->stacksize =
 129                         rl.rlim_cur - (size_t) (to - (uintptr_t) stack_end);
 130
 131                       /* Cut it down to align it to page size since otherwise we
 132                          risk going beyond rlimit when the kernel rounds up the
 133                          stack extension request.  */
 134                       iattr->stacksize = (iattr->stacksize
 135                                           & -(intptr_t) GLRO(dl_pagesize));
 136 #if _STACK_GROWS_DOWN
 137                       /* The limit might be too high.  */
 138                       if ((size_t) iattr->stacksize
 139                           > (size_t) iattr->stackaddr - last_to)
 140                         iattr->stacksize = (size_t) iattr->stackaddr - last_to;
 141 #else
 142                       /* The limit might be too high.  */
 143                       if ((size_t) iattr->stacksize
 144                           > to - (size_t) iattr->stackaddr)
 145                         iattr->stacksize = to - (size_t) iattr->stackaddr;
 146 #endif
 147                       /* We succeed and no need to look further.  */
 148                       ret = 0;
 149                       break;
 150                     }
 151 #if _STACK_GROWS_DOWN
 152                   last_to = to;
 153 #endif
 154                 }
 155
 156               free (line);
 157             }
 158
 159           fclose (fp);
 160         }
 161     }
 162
 163   iattr->flags |= ATTR_FLAG_STACKADDR;
 164
 165   if (ret == 0)
 166     {
 167       size_t size = 16;
 168       cpu_set_t *cpuset = NULL;
 169
 170       do
 171         {
 172           size <<= 1;
 173
 174           void *newp = realloc (cpuset, size);
 175           if (newp == NULL)
 176             {
 177               ret = ENOMEM;
 178               break;
 179             }
 180           cpuset = (cpu_set_t *) newp;
 181
 182           ret = __pthread_getaffinity_np (thread_id, size, cpuset);
 183         }
 184       /* Pick some ridiculous upper limit.  Is 8 million CPUs enough?  */
 185       while (ret == EINVAL && size < 1024 * 1024);
 186
 187       if (ret == 0)
 188         {
 189           iattr->cpuset = cpuset;
 190           iattr->cpusetsize = size;
 191         }
 192       else
 193         {
 194           free (cpuset);
 195           if (ret == ENOSYS)
 196             {
 197               /* There is no such functionality.  */
 198               ret = 0;
 199               iattr->cpuset = NULL;
 200               iattr->cpusetsize = 0;
 201             }
 202         }
 203     }
 204
 205   lll_unlock (thread->lock, LLL_PRIVATE);
 206
 207   return ret;
 208 }