Manpages - pthread_getattr_np.3

  #define _GNU_SOURCE     /* To get pthread_getattr_np() declaration */
  #include <pthread.h>
  #include <stdio.h>
  #include <stdlib.h>
  #include <unistd.h>
  #include <errno.h>

  #define handle_error_en(en, msg) \
          do { errno = en; perror(msg); exit(EXIT_FAILURE); } while (0)

  static void
  display_stack_related_attributes(pthread_attr_t *attr, char *prefix)
  {
      int s;
      size_t stack_size, guard_size;
      void *stack_addr;

      s = pthread_attr_getguardsize(attr, &guard_size);
      if (s != 0)
          handle_error_en(s, "pthread_attr_getguardsize");
      printf("%sGuard size          = %zu bytes\n", prefix, guard_size);

      s = pthread_attr_getstack(attr, &stack_addr, &stack_size);
      if (s != 0)
          handle_error_en(s, "pthread_attr_getstack");
      printf("%sStack address       = %p", prefix, stack_addr);
      if (stack_size > 0)
          printf(" (EOS = %p)", (char *) stack_addr + stack_size);
      printf("\n");
      printf("%sStack size          = %#zx (%zu) bytes\n",
              prefix, stack_size, stack_size);
  }

  static void
  display_thread_attributes(pthread_t thread, char *prefix)
  {
      int s;
      pthread_attr_t attr;

      s = pthread_getattr_np(thread, &attr);
      if (s != 0)
          handle_error_en(s, "pthread_getattr_np");

      display_stack_related_attributes(&attr, prefix);

      s = pthread_attr_destroy(&attr);
      if (s != 0)
          handle_error_en(s, "pthread_attr_destroy");
  }

  static void *           /* Start function for thread we create */
  thread_start(void *arg)
  {
      printf("Attributes of created thread:\n");
      display_thread_attributes(pthread_self(), "\t");

      exit(EXIT_SUCCESS);         /* Terminate all threads */
  }

  static void
  usage(char *pname, char *msg)
  {
      if (msg != NULL)
          fputs(msg, stderr);
      fprintf(stderr, "Usage: %s [-s stack-size [-a]]"
              " [-g guard-size]\n", pname);
      fprintf(stderr, "\t\t-a means program should allocate stack\n");
      exit(EXIT_FAILURE);
  }

  static pthread_attr_t *   /* Get thread attributes from command line */
  get_thread_attributes_from_cl(int argc, char *argv[],
                                pthread_attr_t *attrp)
  {
      int s, opt, allocate_stack;
      size_t stack_size, guard_size;
      void *stack_addr;
      pthread_attr_t *ret_attrp = NULL;   /* Set to attrp if we initialize
                                             a thread attributes object */
      allocate_stack = 0;
      stack_size = -1;
      guard_size = -1;

      while ((opt = getopt(argc, argv, "ag:s:")) != -1) {
          switch (opt) {
          case 'a':   allocate_stack = 1;                     break;
          case 'g':   guard_size = strtoul(optarg, NULL, 0);  break;
          case 's':   stack_size = strtoul(optarg, NULL, 0);  break;
          default:    usage(argv[0], NULL);
          }
      }

      if (allocate_stack && stack_size == -1)
          usage(argv[0], "Specifying -a without -s makes no sense\n");

      if (argc > optind)
          usage(argv[0], "Extraneous command-line arguments\n");

      if (stack_size >= 0 || guard_size > 0) {
          ret_attrp = attrp;

          s = pthread_attr_init(attrp);
          if (s != 0)
              handle_error_en(s, "pthread_attr_init");
      }

      if (stack_size >= 0) {
          if (!allocate_stack) {
              s = pthread_attr_setstacksize(attrp, stack_size);
              if (s != 0)
                  handle_error_en(s, "pthread_attr_setstacksize");
          } else {
              s = posix_memalign(&stack_addr, sysconf(_SC_PAGESIZE),
                                 stack_size);
              if (s != 0)
                  handle_error_en(s, "posix_memalign");
              printf("Allocated thread stack at %p\n\n", stack_addr);

              s = pthread_attr_setstack(attrp, stack_addr, stack_size);
              if (s != 0)
                  handle_error_en(s, "pthread_attr_setstacksize");
          }
      }

      if (guard_size >= 0) {
          s = pthread_attr_setguardsize(attrp, guard_size);
          if (s != 0)
              handle_error_en(s, "pthread_attr_setstacksize");
      }

      return ret_attrp;
  }

  int
  main(int argc, char *argv[])
  {
      int s;
      pthread_t thr;
      pthread_attr_t attr;
      pthread_attr_t *attrp = NULL;    /* Set to &attr if we initialize
                                          a thread attributes object */

      attrp = get_thread_attributes_from_cl(argc, argv, &attr);

      if (attrp != NULL) {
          printf("Thread attributes object after initializations:\n");
          display_stack_related_attributes(attrp, "\t");
          printf("\n");
      }

      s = pthread_create(&thr, attrp, &thread_start, NULL);
      if (s != 0)
          handle_error_en(s, "pthread_create");

      if (attrp != NULL) {
          s = pthread_attr_destroy(attrp);
          if (s != 0)
              handle_error_en(s, "pthread_attr_destroy");
      }

      pause();    /* Terminates when other thread calls exit() */
  }