path: root/utility/rtos_compatibility_layers/posix/posix_signal_self_send_test.c

/***************************************************************************/
/* Copyright (c) 2024 Microsoft Corporation                                */
/* Copyright (c) 2026 Eclipse ThreadX contributors                         */
/*                                                                         */
/* This program and the accompanying materials are made available under    */
/* the terms of the MIT License which is available at                      */
/* https://opensource.org/licenses/MIT.                                    */
/*                                                                         */
/* SPDX-License-Identifier: MIT                                            */
/***************************************************************************/

/* Simple self-signaling test.  */

#include   "pthread.h"

#define     DEMO_STACK_SIZE         2048
#if 0
#define     MAX_MESSAGE_SIZE        50
#endif
#define     DEMO_BYTE_POOL_SIZE     9120


/* Define the POSIX pthread object control blocks ... */

pthread_t               pthread_0;

#if 0
pthread_t               pthread_1;
pthread_t               pthread_2;
pthread_t               pthread_3;
pthread_t               pthread_4;
pthread_t               pthread_5;
#endif

/* Define pthread attributes objects */


pthread_attr_t          ptattr0;
#if 0
pthread_attr_t          ptattr1;
pthread_attr_t          ptattr2;
pthread_attr_t          ptattr3;
pthread_attr_t          ptattr4;
pthread_attr_t          ptattr5;


/* Define the message queue attribute.  */

struct mq_attr          queue_atrr;

/* Define a queue descriptor.          */

mqd_t                   q_des;

/* Define a semaphore.                 */

sem_t                   *sem;

/* Define a mutex                     */

pthread_mutex_t         mutex1;

/* Define a mutex attributes object   */

pthread_mutexattr_t     mta1;
#endif

/* Define the counters used in this test application...  */

ULONG     pthread_0_counter;
ULONG     pthread_0_signal_counter;


#if 0
ULONG     pthread_1_counter;
ULONG     pthread_2_counter;
ULONG     pthread_3_counter;
ULONG     pthread_4_counter;
ULONG     pthread_5_counter;
ULONG     pthread_1_message_sent;
ULONG     pthread_2_message_received;
#endif

/* Define pthread function prototypes.  */

VOID    *pthread_0_entry(VOID *);


/* Define signal handlers.  */

VOID    pthread_0_signal_handler(int);


#if 0
VOID    *pthread_1_entry(VOID *);
VOID    *pthread_2_entry(VOID *);
VOID    *pthread_3_entry(VOID *);
VOID    *pthread_4_entry(VOID *);
VOID    *pthread_5_entry(VOID *);


/* Message to be sent.  */
CHAR *msg0 = "This is a test message";
#endif
ULONG free_memory[192*1024 / sizeof(ULONG)];

/* Define main entry point.  */

INT main()
{

    /* Enter the ThreadX kernel.  */
    tx_kernel_enter();
}


/* Define what the initial system looks like.  */
VOID tx_application_define(VOID *first_unused_memory)
{

    VOID* storage_ptr;


struct sched_param  param;

#if 0
queue_atrr.mq_maxmsg  = 124;
queue_atrr.mq_msgsize = MAX_MESSAGE_SIZE;
#endif

    /* Init POSIX Wrapper */
    storage_ptr = (VOID*) posix_initialize((VOID*)free_memory);

    /* Put system definition stuff in here, e.g. pthread creates and other assoerted
       create information. */

    /* Create pthread attributes.  */
    pthread_attr_init(&ptattr0);
#if 0
    pthread_attr_init(&ptattr1);
    pthread_attr_init(&ptattr2);
    pthread_attr_init(&ptattr3);
    pthread_attr_init(&ptattr4);
    pthread_attr_init(&ptattr5);
#endif

    /* Create a sched_param structure */
    memset(&param, 0, sizeof(param));

    /* Now create all pthreads , firstly modify respective ptheread
       attribute with desired priority and stack start address and then create the pthread */

    /* Create pthread 0.  */
    param.sched_priority = 10;
    pthread_attr_setschedparam(&ptattr0, &param);
    pthread_attr_setstackaddr(&ptattr0,  storage_ptr );
    storage_ptr = (int *) storage_ptr + DEMO_STACK_SIZE;
    pthread_create (&pthread_0, &ptattr0,pthread_0_entry,NULL);

#if 0
    /* Create pthread 1.  */
    param.sched_priority = 15;
    pthread_attr_setschedparam(&ptattr1, &param);
    pthread_attr_setstackaddr(&ptattr1, (VOID*) storage_ptr );
    storage_ptr = storage_ptr + DEMO_STACK_SIZE;
    pthread_create (&pthread_1, &ptattr1,pthread_1_entry,NULL);

    /* Create pthread 2.  */
    param.sched_priority = 20;
    pthread_attr_setschedparam(&ptattr2, &param);
    pthread_attr_setstackaddr(&ptattr2, (VOID*) storage_ptr );
    storage_ptr = storage_ptr + DEMO_STACK_SIZE;
    pthread_create (&pthread_2, &ptattr2,pthread_2_entry,NULL);

    /* Create pthread 3.  */
    param.sched_priority = 25;
    pthread_attr_setschedparam(&ptattr3, &param);
    pthread_attr_setstackaddr(&ptattr3, (VOID*) storage_ptr );
    storage_ptr = storage_ptr + DEMO_STACK_SIZE;
    pthread_create (&pthread_3, &ptattr3,pthread_3_entry,NULL);

    /* Create pthread 4.  */
    param.sched_priority = 30;
    pthread_attr_setschedparam(&ptattr4, &param);
    pthread_attr_setstackaddr(&ptattr4, (VOID*) storage_ptr );
    storage_ptr = storage_ptr + DEMO_STACK_SIZE;
    pthread_create (&pthread_4, &ptattr4,pthread_4_entry,NULL);

    /* Create pthread 5.  */
    param.sched_priority = 5;
    pthread_attr_setschedparam(&ptattr5, &param);
    pthread_attr_setstackaddr(&ptattr5, (VOID*) storage_ptr );
    storage_ptr = storage_ptr + DEMO_STACK_SIZE;
    pthread_create (&pthread_5, &ptattr5,pthread_5_entry,NULL);

    /* Create a Message queue.  */
    q_des = mq_open("Queue",O_CREAT|O_RDWR,0,&queue_atrr);

    /* Create a Semaphore.  */
    sem = sem_open("Sem0", O_CREAT | O_EXCL,0,1);

    /* Create a Mutex */
    pthread_mutex_init(&mutex1, NULL);
#endif

}

VOID    error_handler(void)
{

    while(1)
    {
    }
}



/* Define the signal handler.  */

VOID  pthread_0_signal_handler(int signo)
{

    /* Check for pthread self call not pthread 0. The signal handler should appear to be
       called from pthread 0.  */
    if (pthread_self() != pthread_0)
    {

        /* Call error handler.  */
        error_handler();
    }

    /* Check for proper signal.  */
    if (signo != 15)
    {

        /* Call error handler.  */
        error_handler();
    }

    /* Just increment the signal counter for this test.  */
    pthread_0_signal_counter++;
}



#if 1
/* Define the test pthreads */
INT pt0_status=0;
#endif

/* Self signal test.  */

VOID    *pthread_0_entry(VOID *pthread0_input)
{

//    struct timespec thread_0_sleep_time={0,0};

    /* Register the signal handler.  */
    pt0_status =  signal(15, pthread_0_signal_handler);

    /* Check for error.  */
    if (pt0_status)
        error_handler();

    /* This pthread simply sits in while-forever-sleep loop */
    while(1)
    {
        /* Increment the pthread counter.*/
        pthread_0_counter++;

        /* Raise the signal.  */
        pt0_status =  pthread_kill(pthread_0, 15);

        /* Check for errors.  */
        if ((pt0_status) || (pthread_0_counter != pthread_0_signal_counter))
    {
            error_handler();
        break;
    }

#if 0
        /* sleep for a while  */
        thread_0_sleep_time.tv_nsec =  999999999;
         thread_0_sleep_time.tv_sec =  4;
    pt0_status=nanosleep(&thread_0_sleep_time,0);
    if(pt0_status)
        break;
#endif

    }

#if 1
    return(&pt0_status);
#endif
}

#if 0
INT    pt1_status=0;

VOID    *pthread_1_entry(VOID *pthread1_input)
{

    struct timespec thread_1_sleep_time={0,0};

    /* This thread simply sends a messages to a queue shared by pthread 2.  */
    while(1)
    {

        /* Increment the thread counter.  */
        pthread_1_counter++;
    /* Send message to queue 0.  */
        pt1_status = mq_send(q_des,msg0,strlen(msg0),3);

        /* check status.  */
        if(pt1_status)
           break;

        /* Increment the message sent.  */
        pthread_1_message_sent++;

     /* sleep for a while  */
        thread_1_sleep_time.tv_nsec = 200000000;
    nanosleep(&thread_1_sleep_time,0);
    }
    return(&pt1_status);
}


INT     pt2_status;

VOID    *pthread_2_entry(VOID *pthread2_input)
{

CHAR    msgr0[MAX_MESSAGE_SIZE];
ULONG   priority;
struct timespec thread_2_sleep_time={0,0};

    /* This pthread retrieves messages placed on the queue by pthread 1.  */
    while(1 )
    {
        /* Increment the thread counter.  */
        pthread_2_counter++;
        pt2_status = mq_receive(q_des,msgr0,MAX_MESSAGE_SIZE,&priority);

        if(pt2_status != 0)
           break;

        /* Otherwise, it is OK to increment the received message count.  */
        pthread_2_message_received++;
        /* sleep for a while  */
        thread_2_sleep_time.tv_nsec = 200000000;
    nanosleep(&thread_2_sleep_time,0);
    }
   return(&pt2_status);
}

INT    pt3_status;
VOID    *pthread_3_entry(VOID *pthread3_input)
{


struct timespec thread_3_sleep_time={0,0};


    /* This function compete for ownership of semaphore_0.  */
    while(1)
    {

        /* Increment the thread counter.  */
        pthread_3_counter++;
        /* Get the semaphore with suspension.  */
        pt3_status = sem_wait(sem);

        /* Check status.  */
        if (pt3_status)
          break;

        /* Sleep for a while to hold the semaphore.  */
        thread_3_sleep_time.tv_nsec = 200000000;
        nanosleep(&thread_3_sleep_time,0);

        /* Release the semaphore.  */
        pt3_status = sem_post(sem);

        /* Check status.  */
        if (pt3_status )
            break;
    }
    return(&pt3_status);
}

INT  pt4_status;

VOID    *pthread_4_entry(VOID *pthread4_input)
{

struct timespec thread_4_sleep_time={0,0};

    while(1)
    {

       /* Increment the thread counter.  */
       pthread_4_counter++;
       /* now lock the mutex */
       pt4_status = pthread_mutex_lock(&mutex1);
       if (pt4_status != OK)
       break;

       /* sleep for a while  */
       thread_4_sleep_time.tv_nsec = 200000000;
       nanosleep(&thread_4_sleep_time,0);

       pt4_status = pthread_mutex_unlock(&mutex1);
       if (pt4_status != OK)
       break;
    }
    return(&pt4_status);
}

INT     pt5_status;

VOID    *pthread_5_entry(VOID *pthread5_input)
{

struct timespec thread_5_sleep_time={0,0};

    while(1)
    {
        /* Increment the thread counter. */
        pthread_5_counter++;
        /* now lock the mutex */
        pt5_status = pthread_mutex_lock(&mutex1);
        if (pt5_status != OK)
            break;

        /* sleep for a while  */
        thread_5_sleep_time.tv_nsec = 20000000;
    nanosleep(&thread_5_sleep_time,0);
        pt5_status = pthread_mutex_unlock(&mutex1);
          if (pt5_status != OK)
          break;
    }
    return(&pt5_status);
}
#endif