/*************************************************************************//* *//* Copyright Mentor Graphics Corporation 2002 *//* All Rights Reserved. *//* *//* THIS WORK CONTAINS TRADE SECRET AND PROPRIETARY INFORMATION WHICH IS *//* THE PROPERTY OF MENTOR GRAPHICS CORPORATION OR ITS LICENSORS AND IS *//* SUBJECT TO LICENSE TERMS. *//* *//*************************************************************************//*************************************************************************//* *//* FILE NAME VERSION *//* *//* evf.c Nucleus PLUS 1.14 *//* *//* COMPONENT *//* *//* EV - Event Group Management *//* *//* DESCRIPTION *//* *//* This file contains routines to obtain facts about the Event *//* Group Management component. *//* *//* DATA STRUCTURES *//* *//* None *//* *//* FUNCTIONS *//* *//* EVF_Established_Event_Groups Number of created groups *//* EVF_Event_Group_Pointers Build event group pointer *//* list *//* EVF_Event_Group_Information Retrieve event group info *//* *//* DEPENDENCIES *//* *//* cs_extr.h Common Service functions *//* tc_extr.h Thread Control functions *//* ev_extr.h Event Group functions *//* hi_extr.h History functions *//* *//* HISTORY *//* *//* DATE REMARKS *//* *//* 03-01-1994 Initial version of event fact *//* service file, version 1.1 *//* *//* 03-18-1994 Verified version 1.1 *//* 04-17-1996 updated to version 1.2 *//* 11-18-1996 Protected Informational service *//* from NULL Control Block pointers *//* creating 1.2a. (SPR220) *//* 03-24-1998 Released version 1.3 *//* 03-26-1999 Released 1.11m (new release *//* numbering scheme) *//* 04-17-2002 Released version 1.13m *//* 11-07-2002 Released version 1.14 *//*************************************************************************/#define NU_SOURCE_FILE#include "cs_extr.h" /* Common service functions */#include "tc_extr.h" /* Thread control functions */#include "ev_extr.h" /* Event Group functions */#include "hi_extr.h" /* History functions *//* Define external inner-component global data references. */extern CS_NODE *EVD_Created_Event_Groups_List;extern UNSIGNED EVD_Total_Event_Groups;extern TC_PROTECT EVD_List_Protect;/*************************************************************************//* *//* FUNCTION *//* *//* EVF_Established_Event_Groups *//* *//* DESCRIPTION *//* *//* This function returns the current number of established *//* event groups. Event groups previously deleted are no longer *//* considered established. *//* *//* CALLED BY *//* *//* Application *//* *//* CALLS *//* *//* [TCT_Check_Stack] Stack checking function *//* *//* INPUTS *//* *//* None *//* *//* OUTPUTS *//* *//* EVD_Total_Event_Groups Number of established *//* event groups *//* *//* HISTORY *//* *//* DATE REMARKS *//* *//* 03-01-1993 Created initial version 1.0 *//* 04-19-1993 Verified version 1.0 *//* 03-01-1994 Modified function interface, *//* resulting in version 1.1 *//* *//* 03-18-1994 Verified version 1.1 *//* *//*************************************************************************/UNSIGNED EVF_Established_Event_Groups(VOID){#ifdef NU_ENABLE_STACK_CHECK /* Call stack checking function to check for an overflow condition. */ TCT_Check_Stack();#endif /* Return the number of established event groups. */ return(EVD_Total_Event_Groups);}/*************************************************************************//* *//* FUNCTION *//* *//* EVF_Event_Group_Pointers *//* *//* DESCRIPTION *//* *//* This function builds a list of event group pointers, starting at *//* the specified location. The number of event group pointers *//* placed in the list is equivalent to the total number of *//* event groups or the maximum number of pointers specified in the *//* call. *//* *//* CALLED BY *//* *//* Application *//* *//* CALLS *//* *//* [TCT_Check_Stack] Stack checking function *//* TCT_Protect Protect created list *//* TCT_Unprotect Release protection *//* *//* INPUTS *//* *//* pointer_list Pointer to the list area *//* maximum_pointers Maximum number of pointers *//* *//* OUTPUTS *//* *//* pointers Number of event groups placed*//* in the list *//* HISTORY *//* *//* DATE REMARKS *//* *//* 03-01-1993 Created initial version 1.0 *//* 04-19-1993 Verified version 1.0 *//* 08-09-1993 Corrected pointer retrieval *//* loop, resulting in version 1.0a *//* 08-09-1993 Verified version 1.0a *//* 03-01-1994 Modified function interface, *//* resulting in version 1.1 *//* *//* 03-18-1994 Verified version 1.1 *//* *//*************************************************************************/UNSIGNED EVF_Event_Group_Pointers(NU_EVENT_GROUP **pointer_list, UNSIGNED maximum_pointers){CS_NODE *node_ptr; /* Pointer to each GCB */UNSIGNED pointers; /* Number of pointers in list*/NU_SUPERV_USER_VARIABLES /* Switch to supervisor mode */ NU_SUPERVISOR_MODE();#ifdef NU_ENABLE_STACK_CHECK /* Call stack checking function to check for an overflow condition. */ TCT_Check_Stack();#endif /* Initialize the number of pointers returned. */ pointers = 0; /* Protect against access to the list of created event groups. */ TCT_Protect(&EVD_List_Protect); /* Loop until all event group pointers are in the list or until the maximum list size is reached. */ node_ptr = EVD_Created_Event_Groups_List; while ((node_ptr) && (pointers < maximum_pointers)) { /* Place the node into the destination list. */ *pointer_list++ = (NU_EVENT_GROUP *) node_ptr; /* Increment the pointers variable. */ pointers++; /* Position the node pointer to the next node. */ node_ptr = node_ptr -> cs_next; /* Determine if the pointer is at the head of the list. */ if (node_ptr == EVD_Created_Event_Groups_List) /* The list search is complete. */ node_ptr = NU_NULL; } /* Release protection against access to the list of created event groups. */ TCT_Unprotect(); /* Return to user mode */ NU_USER_MODE(); /* Return the number of pointers in the list. */ return(pointers);}/*************************************************************************//* *//* FUNCTION *//* *//* EVF_Event_Group_Information *//* *//* DESCRIPTION *//* *//* This function returns information about the specified event *//* group. However, if the supplied event group pointer is invalid, *//* the function simply returns an error status. *//* *//* CALLED BY *//* *//* Application *//* *//* CALLS *//* *//* [TCT_Check_Stack] Stack checking function *//* TCT_System_Protect Protect event group *//* TCT_Unprotect Release protection *//* *//* INPUTS *//* *//* event_group_ptr Pointer to the event group *//* name Destination for the name *//* event_flags Pointer to a variable to hold*//* the current event flags *//* tasks_waiting Destination for the tasks *//* waiting count *//* first_task Destination for the pointer *//* to the first task waiting *//* *//* OUTPUTS *//* *//* NU_SUCCESS If a valid event group *//* pointer is supplied *//* NU_INVALID_GROUP If event group pointer is *//* not valid *//* *//* HISTORY *//* *//* DATE REMARKS *//* *//* 03-01-1993 Created initial version 1.0 *//* 04-19-1993 Verified version 1.0 *//* 03-01-1994 Modified function interface, *//* resulting in version 1.1 *//* *//* 03-18-1994 Verified version 1.1 *//* 11-18-1996 Corrected SPR220. *//* *//*************************************************************************/STATUS EVF_Event_Group_Information(NU_EVENT_GROUP *event_group_ptr, CHAR *name, UNSIGNED *event_flags, UNSIGNED *tasks_waiting, NU_TASK **first_task){EV_GCB *event_group; /* Event control block ptr */INT i; /* Working integer variable */STATUS completion; /* Completion status */NU_SUPERV_USER_VARIABLES /* Switch to supervisor mode */ NU_SUPERVISOR_MODE(); /* Move input event group pointer into internal pointer. */ event_group = (EV_GCB *) event_group_ptr;#ifdef NU_ENABLE_STACK_CHECK /* Call stack checking function to check for an overflow condition. */ TCT_Check_Stack();#endif /* Determine if this event_group id is valid. */ if ((event_group != NU_NULL) && (event_group -> ev_id == EV_EVENT_ID)) { /* Setup protection of the event_group. */ TCT_System_Protect(); /* The event_group pointer is valid. Reflect this in the completion status and fill in the actual information. */ completion = NU_SUCCESS; /* Copy the event_group's name. */ for (i = 0; i < NU_MAX_NAME; i++) *name++ = event_group -> ev_name[i]; /* Return the current event flags. */ *event_flags = event_group -> ev_current_events; /* Retrieve the number of tasks waiting and the pointer to the first task waiting. */ *tasks_waiting = event_group -> ev_tasks_waiting; if (event_group -> ev_suspension_list) /* There is a task waiting. */ *first_task = (NU_TASK *) (event_group -> ev_suspension_list) -> ev_suspended_task; else /* There are no tasks waiting. */ *first_task = NU_NULL; /* Release protection of the event group. */ TCT_Unprotect(); } else /* Indicate that the event group pointer is invalid. */ completion = NU_INVALID_GROUP; /* Return to user mode */ NU_USER_MODE(); /* Return the appropriate completion status. */ return(completion);}