libpthread/nptl/pthread_getattr_np.c

   1 /* Copyright (C) 2002, 2003, 2004, 2006, 2007 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 (
  34      pthread_t thread_id,
  35      pthread_attr_t *attr)
  36 {
  37   struct pthread *thread = (struct pthread *) thread_id;
  38   struct pthread_attr *iattr = (struct pthread_attr *) attr;
  39   int ret = 0;
  40
  41   lll_lock (thread->lock, LLL_PRIVATE);
  42
  43   /* The thread library is responsible for keeping the values in the
  44      thread desriptor up-to-date in case the user changes them.  */
  45   memcpy (&iattr->schedparam, &thread->schedparam,
  46           sizeof (struct sched_param));
  47   iattr->schedpolicy = thread->schedpolicy;
  48
  49   /* Clear the flags work.  */
  50   iattr->flags = thread->flags;
  51
  52   /* The thread might be detached by now.  */
  53   if (IS_DETACHED (thread))
  54     iattr->flags |= ATTR_FLAG_DETACHSTATE;
  55
  56   /* This is the guardsize after adjusting it.  */
  57   iattr->guardsize = thread->reported_guardsize;
  58
  59   /* The sizes are subject to alignment.  */
  60   if (__builtin_expect (thread->stackblock != NULL, 1))
  61     {
  62       iattr->stacksize = thread->stackblock_size;
  63       iattr->stackaddr = (char *) thread->stackblock + iattr->stacksize;
  64     }
  65   else
  66     {
  67       /* No stack information available.  This must be for the initial
  68          thread.  Get the info in some magical way.  */
  69
  70       /* Stack size limit.  */
  71       struct rlimit rl;
  72
  73       /* The safest way to get the top of the stack is to read
  74          /proc/self/maps and locate the line into which
  75          __libc_stack_end falls.  */
  76       FILE *fp = fopen ("/proc/self/maps", "rc");
  77       if (fp == NULL)
  78         ret = errno;
  79       /* We need the limit of the stack in any case.  */
  80       else
  81         {
  82           if (getrlimit (RLIMIT_STACK, &rl) != 0)
  83             ret = errno;
  84           else
  85             {
  86               /* We need no locking.  */
  87               __fsetlocking (fp, FSETLOCKING_BYCALLER);
  88
  89               /* Until we found an entry (which should always be the case)
  90                  mark the result as a failure.  */
  91               ret = ENOENT;
  92
  93               char *line = NULL;
  94               size_t linelen = 0;
  95               uintptr_t last_to = 0;
  96
  97               while (! feof_unlocked (fp))
  98                 {
  99                   if (getdelim (&line, &linelen, '\n', fp) <= 0)
 100                     break;
 101
 102                   uintptr_t from;
 103                   uintptr_t to;
 104                   if (sscanf (line, "%" SCNxPTR "-%" SCNxPTR, &from, &to) != 2)
 105                     continue;
 106                   if (from <= (uintptr_t) __libc_stack_end
 107                       && (uintptr_t) __libc_stack_end < to)
 108                     {
 109                       /* Found the entry.  Now we have the info we need.  */
 110                       iattr->stacksize = rl.rlim_cur;
 111                       iattr->stackaddr = (void *) to;
 112
 113                       /* The limit might be too high.  */
 114                       if ((size_t) iattr->stacksize
 115                           > (size_t) iattr->stackaddr - last_to)
 116                         iattr->stacksize = (size_t) iattr->stackaddr - last_to;
 117
 118                       /* We succeed and no need to look further.  */
 119                       ret = 0;
 120                       break;
 121                     }
 122                   last_to = to;
 123                 }
 124
 125               free (line);
 126             }
 127
 128           fclose (fp);
 129         }
 130     }
 131
 132   iattr->flags |= ATTR_FLAG_STACKADDR;
 133
 134   if (ret == 0)
 135     {
 136       size_t size = 16;
 137       cpu_set_t *cpuset = NULL;
 138
 139       do
 140         {
 141           size <<= 1;
 142
 143           void *newp = realloc (cpuset, size);
 144           if (newp == NULL)
 145             {
 146               ret = ENOMEM;
 147               break;
 148             }
 149           cpuset = (cpu_set_t *) newp;
 150
 151           ret = __pthread_getaffinity_np (thread_id, size, cpuset);
 152         }
 153       /* Pick some ridiculous upper limit.  Is 8 million CPUs enough?  */
 154       while (ret == EINVAL && size < 1024 * 1024);
 155
 156       if (ret == 0)
 157         {
 158           iattr->cpuset = cpuset;
 159           iattr->cpusetsize = size;
 160         }
 161       else
 162         {
 163           free (cpuset);
 164           if (ret == ENOSYS)
 165             {
 166               /* There is no such functionality.  */
 167               ret = 0;
 168               iattr->cpuset = NULL;
 169               iattr->cpusetsize = 0;
 170             }
 171         }
 172     }
 173
 174   lll_unlock (thread->lock, LLL_PRIVATE);
 175
 176   return ret;
 177 }