/*file : test.c*/ 
/* main */

#include <stdio.h>
#include <limits.h>
#include <pthread.h>

void *func1 (void *p1)
{
   pthread_setcancelstate (PTHREAD_CANCEL_ENABLE,NULL);
   pthread_setcanceltype (PTHREAD_CANCEL_ASYNCHRONOUS,NULL);
   printf ("\n In Thread Function1 :) \n");
   sleep (3);
   pthread_exit (NULL);
}
int main (void)
{
  size_t size = PTHREAD_STACK_MIN + 0x444000;
  void *base = malloc (size );
  test_main (func1,base+PTHREAD_STACK_MIN,size-PTHREAD_STACK_MIN);
  sleep (10);
  //sleep (10);
//  free (base);
  getchar();
  return 0;
}

/* file : test_shared.c */
/* Library Function */
#include <stdio.h>
//#define __USE_XOPEN2K
//#define _XOPEN_SOURCE 600
#include <pthread.h>
#include <unistd.h>
#include <limits.h>
#include <sched.h>
#include <stdlib.h>

void CleanupHandler (void* pArg)
{
   printf ("\nI am In clean up handler \n");
   usleep (100);
}
void * a(void *);
void * func(void *p(void *))
{
   printf ("\n In Thread Function :) \n");
   pthread_cleanup_push(CleanupHandler,NULL);
   p (NULL);
   pthread_cleanup_pop(1);
   usleep (1000);
   sleep (2);
   pthread_exit (NULL);
  return NULL;
}
int test_main (void*fn(void*),void *stackbase,size_t size)
{
   pthread_attr_t tattr;
   pthread_t tid;
   int ret;
   struct sched_param stparam;
   void *stackbase1,*stackbase2;
   size_t size1,size2;
   int policy;

   /* initialized with default attributes */
   ret = pthread_attr_init(&tattr);
   if (ret != -1)
   {
#if 1
     printf ("\n Stack:size <%p:%d>\n",stackbase,size);
     /* setting the base address and size of the stack */
     stackbase2 = memset (stackbase,0,size);
     ret = pthread_attr_setstack(&tattr, stackbase,size);
     if (ret != -1)
     {
#endif
       if (pthread_attr_setschedpolicy (&tattr,SCHED_RR))
       {
          printf ("\n setschedpolicy failed\n");
          pthread_attr_destroy (&tattr);
          exit (0);
       }
       if (pthread_attr_getschedpolicy (&tattr,&policy))
       {
          printf ("\n getschedpolicy failed\n");
          pthread_attr_destroy (&tattr);
          exit (1);
       }
       printf ("\n Policy = <%s>\n",(policy==0)?"SCHED_NORMAL":(policy == 1)?"SCHED_FIFO":(policy == 2)?"SCEHD_RR":(policy==3)?"SCHED_OTHERS":"NONE");
       sched_getparam (0,&stparam);
       stparam.sched_priority = 99;
       pthread_attr_setschedparam (&tattr,&stparam);
//     pthread_attr_setdetachstate (&tattr,PTHREAD_CREATE_JOINABLE);
//     pthread_attr_setinheritsched (&tattr,PTHREAD_EXPLICIT_SCHED);

        /* address and size specified */
        ret = pthread_create(&tid, &tattr, func, (void*)fn);
        if (ret == -1)
        {
           printf ("\nThread Creation Failed\n");
           pthread_attr_destroy (&tattr);
           perror (NULL);
        }
        else
        {
           printf ("\n Thread Creation Passed\n");
           pthread_attr_getstack (&tattr, &stackbase1,&size1);
           printf ("\n Stack:size <%p:%d>\n",stackbase1,size1);
           sleep (2);
           sleep (1);
           printf ("\n AF Join \n");
           pthread_attr_destroy (&tattr);
        }
#if 1
     }
     else
     {
        printf ("\n Setstack failed\n");
     }
#endif
  }
  else
  {
     printf ("\n attrInit failed\n");
  }

  return 0;
}

gcc -fPIC -g -c -Wall test_shared.c
gcc -shared -Wl -o libtest_shared.so test_shared.o -lc

gcc -Wall -lpthread -L$PWD -ltest_shared -o test test.c

export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$PWD ; ./test

gcc -Wall -lpthread -o test1 test.c test_shared.c ; ./test1