man3/pthread_getattr_np.3

   1 .\" Copyright (c) 2008 Linux Foundation, written by Michael Kerrisk
   2 .\"     <mtk.manpages@gmail.com>
   3 .\"
   4 .\" SPDX-License-Identifier: Linux-man-pages-copyleft
   5 .\"
   6 .TH PTHREAD_GETATTR_NP 3 2021-03-22 "Linux" "Linux Programmer's Manual"
   7 .SH NAME
   8 pthread_getattr_np \- get attributes of created thread
   9 .SH LIBRARY
  10 POSIX threads library
  11 .RI ( libpthread ", " \-lpthread )
  12 .SH SYNOPSIS
  13 .nf
  14 .BR "#define _GNU_SOURCE" "             /* See feature_test_macros(7) */"
  15 .B #include <pthread.h>
  16 .PP
  17 .BI "int pthread_getattr_np(pthread_t " thread ", pthread_attr_t *" attr );
  18 .fi
  19 .SH DESCRIPTION
  20 The
  21 .BR pthread_getattr_np ()
  22 function initializes the thread attributes object referred to by
  23 .I attr
  24 so that it contains actual attribute values describing the running thread
  25 .IR thread .
  26 .PP
  27 The returned attribute values may differ from
  28 the corresponding attribute values passed in the
  29 .I attr
  30 object that was used to create the thread using
  31 .BR pthread_create (3).
  32 In particular, the following attributes may differ:
  33 .IP * 2
  34 the detach state, since a joinable thread may have detached itself
  35 after creation;
  36 .IP *
  37 the stack size,
  38 which the implementation may align to a suitable boundary.
  39 .IP *
  40 and the guard size,
  41 which the implementation may round upward to a multiple of the page size,
  42 or ignore (i.e., treat as 0),
  43 if the application is allocating its own stack.
  44 .PP
  45 Furthermore, if the stack address attribute was not set
  46 in the thread attributes object used to create the thread,
  47 then the returned thread attributes object will report the actual
  48 stack address that the implementation selected for the thread.
  49 .PP
  50 When the thread attributes object returned by
  51 .BR pthread_getattr_np ()
  52 is no longer required, it should be destroyed using
  53 .BR pthread_attr_destroy (3).
  54 .SH RETURN VALUE
  55 On success, this function returns 0;
  56 on error, it returns a nonzero error number.
  57 .SH ERRORS
  58 .TP
  59 .B ENOMEM
  60 .\" Can happen (but unlikely) while trying to allocate memory for cpuset
  61 Insufficient memory.
  62 .PP
  63 In addition, if
  64 .I thread
  65 refers to the main thread, then
  66 .BR pthread_getattr_np ()
  67 can fail because of errors from various underlying calls:
  68 .BR fopen (3),
  69 if
  70 .I /proc/self/maps
  71 can't be opened;
  72 and
  73 .BR getrlimit (2),
  74 if the
  75 .B RLIMIT_STACK
  76 resource limit is not supported.
  77 .SH VERSIONS
  78 This function is available in glibc since version 2.2.3.
  79 .SH ATTRIBUTES
  80 For an explanation of the terms used in this section, see
  81 .BR attributes (7).
  82 .ad l
  83 .nh
  84 .TS
  85 allbox;
  86 lbx lb lb
  87 l l l.
  88 Interface       Attribute       Value
  89 T{
  90 .BR pthread_getattr_np ()
  91 T}      Thread safety   MT-Safe
  92 .TE
  93 .hy
  94 .ad
  95 .sp 1
  96 .SH CONFORMING TO
  97 This function is a nonstandard GNU extension;
  98 hence the suffix "_np" (nonportable) in the name.
  99 .SH EXAMPLES
 100 The program below demonstrates the use of
 101 .BR pthread_getattr_np ().
 102 The program creates a thread that then uses
 103 .BR pthread_getattr_np ()
 104 to retrieve and display its guard size, stack address,
 105 and stack size attributes.
 106 Command-line arguments can be used to set these attributes
 107 to values other than the default when creating the thread.
 108 The shell sessions below demonstrate the use of the program.
 109 .PP
 110 In the first run, on an x86-32 system,
 111 a thread is created using default attributes:
 112 .PP
 113 .in +4n
 114 .EX
 115 .RB "$" " ulimit \-s" "      # No stack limit ==> default stack size is 2 MB"
 116 unlimited
 117 .RB "$" " ./a.out"
 118 Attributes of created thread:
 119         Guard size          = 4096 bytes
 120         Stack address       = 0x40196000 (EOS = 0x40397000)
 121         Stack size          = 0x201000 (2101248) bytes
 122 .EE
 123 .in
 124 .PP
 125 In the following run, we see that if a guard size is specified,
 126 it is rounded up to the next multiple of the system page size
 127 (4096 bytes on x86-32):
 128 .PP
 129 .in +4n
 130 .EX
 131 .RB "$" " ./a.out \-g 4097"
 132 Thread attributes object after initializations:
 133         Guard size          = 4097 bytes
 134         Stack address       = (nil)
 135         Stack size          = 0x0 (0) bytes
 136
 137 Attributes of created thread:
 138         Guard size          = 8192 bytes
 139         Stack address       = 0x40196000 (EOS = 0x40397000)
 140         Stack size          = 0x201000 (2101248) bytes
 141 .EE
 142 .in
 143 .\".in +4n
 144 .\".nf
 145 .\"$ ./a.out \-s 0x8000
 146 .\"Thread attributes object after initializations:
 147 .\"        Guard size          = 4096 bytes
 148 .\"        Stack address       = 0xffff8000 (EOS = (nil))
 149 .\"        Stack size          = 0x8000 (32768) bytes
 150 .\"
 151 .\"Attributes of created thread:
 152 .\"        Guard size          = 4096 bytes
 153 .\"        Stack address       = 0x4001e000 (EOS = 0x40026000)
 154 .\"        Stack size          = 0x8000 (32768) bytes
 155 .\".fi
 156 .\".in
 157 .PP
 158 In the last run, the program manually allocates a stack for the thread.
 159 In this case, the guard size attribute is ignored.
 160 .PP
 161 .in +4n
 162 .EX
 163 .RB "$" " ./a.out \-g 4096 \-s 0x8000 \-a"
 164 Allocated thread stack at 0x804d000
 165
 166 Thread attributes object after initializations:
 167         Guard size          = 4096 bytes
 168         Stack address       = 0x804d000 (EOS = 0x8055000)
 169         Stack size          = 0x8000 (32768) bytes
 170
 171 Attributes of created thread:
 172         Guard size          = 0 bytes
 173         Stack address       = 0x804d000 (EOS = 0x8055000)
 174         Stack size          = 0x8000 (32768) bytes
 175 .EE
 176 .in
 177 .SS Program source
 178 \&
 179 .EX
 180 #define _GNU_SOURCE     /* To get pthread_getattr_np() declaration */
 181 #include <pthread.h>
 182 #include <stdio.h>
 183 #include <stdlib.h>
 184 #include <unistd.h>
 185 #include <errno.h>
 186
 187 #define handle_error_en(en, msg) \e
 188         do { errno = en; perror(msg); exit(EXIT_FAILURE); } while (0)
 189
 190 static void
 191 display_stack_related_attributes(pthread_attr_t *attr, char *prefix)
 192 {
 193     int s;
 194     size_t stack_size, guard_size;
 195     void *stack_addr;
 196
 197     s = pthread_attr_getguardsize(attr, &guard_size);
 198     if (s != 0)
 199         handle_error_en(s, "pthread_attr_getguardsize");
 200     printf("%sGuard size          = %zu bytes\en", prefix, guard_size);
 201
 202     s = pthread_attr_getstack(attr, &stack_addr, &stack_size);
 203     if (s != 0)
 204         handle_error_en(s, "pthread_attr_getstack");
 205     printf("%sStack address       = %p", prefix, stack_addr);
 206     if (stack_size > 0)
 207         printf(" (EOS = %p)", (char *) stack_addr + stack_size);
 208     printf("\en");
 209     printf("%sStack size          = %#zx (%zu) bytes\en",
 210             prefix, stack_size, stack_size);
 211 }
 212
 213 static void
 214 display_thread_attributes(pthread_t thread, char *prefix)
 215 {
 216     int s;
 217     pthread_attr_t attr;
 218
 219     s = pthread_getattr_np(thread, &attr);
 220     if (s != 0)
 221         handle_error_en(s, "pthread_getattr_np");
 222
 223     display_stack_related_attributes(&attr, prefix);
 224
 225     s = pthread_attr_destroy(&attr);
 226     if (s != 0)
 227         handle_error_en(s, "pthread_attr_destroy");
 228 }
 229
 230 static void *           /* Start function for thread we create */
 231 thread_start(void *arg)
 232 {
 233     printf("Attributes of created thread:\en");
 234     display_thread_attributes(pthread_self(), "\et");
 235
 236     exit(EXIT_SUCCESS);         /* Terminate all threads */
 237 }
 238
 239 static void
 240 usage(char *pname, char *msg)
 241 {
 242     if (msg != NULL)
 243         fputs(msg, stderr);
 244     fprintf(stderr, "Usage: %s [\-s stack\-size [\-a]]"
 245             " [\-g guard\-size]\en", pname);
 246     fprintf(stderr, "\et\et\-a means program should allocate stack\en");
 247     exit(EXIT_FAILURE);
 248 }
 249
 250 static pthread_attr_t *   /* Get thread attributes from command line */
 251 get_thread_attributes_from_cl(int argc, char *argv[],
 252                               pthread_attr_t *attrp)
 253 {
 254     int s, opt, allocate_stack;
 255     size_t stack_size, guard_size;
 256     void *stack_addr;
 257     pthread_attr_t *ret_attrp = NULL;   /* Set to attrp if we initialize
 258                                            a thread attributes object */
 259     allocate_stack = 0;
 260     stack_size = \-1;
 261     guard_size = \-1;
 262
 263     while ((opt = getopt(argc, argv, "ag:s:")) != \-1) {
 264         switch (opt) {
 265         case \(aqa\(aq:   allocate_stack = 1;                     break;
 266         case \(aqg\(aq:   guard_size = strtoul(optarg, NULL, 0);  break;
 267         case \(aqs\(aq:   stack_size = strtoul(optarg, NULL, 0);  break;
 268         default:    usage(argv[0], NULL);
 269         }
 270     }
 271
 272     if (allocate_stack && stack_size == \-1)
 273         usage(argv[0], "Specifying \-a without \-s makes no sense\en");
 274
 275     if (argc > optind)
 276         usage(argv[0], "Extraneous command\-line arguments\en");
 277
 278     if (stack_size >= 0 || guard_size > 0) {
 279         ret_attrp = attrp;
 280
 281         s = pthread_attr_init(attrp);
 282         if (s != 0)
 283             handle_error_en(s, "pthread_attr_init");
 284     }
 285
 286     if (stack_size >= 0) {
 287         if (!allocate_stack) {
 288             s = pthread_attr_setstacksize(attrp, stack_size);
 289             if (s != 0)
 290                 handle_error_en(s, "pthread_attr_setstacksize");
 291         } else {
 292             s = posix_memalign(&stack_addr, sysconf(_SC_PAGESIZE),
 293                                stack_size);
 294             if (s != 0)
 295                 handle_error_en(s, "posix_memalign");
 296             printf("Allocated thread stack at %p\en\en", stack_addr);
 297
 298             s = pthread_attr_setstack(attrp, stack_addr, stack_size);
 299             if (s != 0)
 300                 handle_error_en(s, "pthread_attr_setstacksize");
 301         }
 302     }
 303
 304     if (guard_size >= 0) {
 305         s = pthread_attr_setguardsize(attrp, guard_size);
 306         if (s != 0)
 307             handle_error_en(s, "pthread_attr_setstacksize");
 308     }
 309
 310     return ret_attrp;
 311 }
 312
 313 int
 314 main(int argc, char *argv[])
 315 {
 316     int s;
 317     pthread_t thr;
 318     pthread_attr_t attr;
 319     pthread_attr_t *attrp = NULL;    /* Set to &attr if we initialize
 320                                         a thread attributes object */
 321
 322     attrp = get_thread_attributes_from_cl(argc, argv, &attr);
 323
 324     if (attrp != NULL) {
 325         printf("Thread attributes object after initializations:\en");
 326         display_stack_related_attributes(attrp, "\et");
 327         printf("\en");
 328     }
 329
 330     s = pthread_create(&thr, attrp, &thread_start, NULL);
 331     if (s != 0)
 332         handle_error_en(s, "pthread_create");
 333
 334     if (attrp != NULL) {
 335         s = pthread_attr_destroy(attrp);
 336         if (s != 0)
 337             handle_error_en(s, "pthread_attr_destroy");
 338     }
 339
 340     pause();    /* Terminates when other thread calls exit() */
 341 }
 342 .EE
 343 .SH SEE ALSO
 344 .ad l
 345 .nh
 346 .BR pthread_attr_getaffinity_np (3),
 347 .BR pthread_attr_getdetachstate (3),
 348 .BR pthread_attr_getguardsize (3),
 349 .BR pthread_attr_getinheritsched (3),
 350 .BR pthread_attr_getschedparam (3),
 351 .BR pthread_attr_getschedpolicy (3),
 352 .BR pthread_attr_getscope (3),
 353 .BR pthread_attr_getstack (3),
 354 .BR pthread_attr_getstackaddr (3),
 355 .BR pthread_attr_getstacksize (3),
 356 .BR pthread_attr_init (3),
 357 .BR pthread_create (3),
 358 .BR pthreads (7)