nptl/pthread_getattr_np.c

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