ospf_system.c

vxworks下ospf协议栈

    /* allow timer task to run */
    semGive (ospf.timer_task_sem_id);

    /* allow hello task to run */
    semGive (ospf.hello_task_sem_id);
    
    } 


/*****************************************************************************
*
* ospf_timer_task_entry_point - ospf timer task entry point
*
* This function creates and starts the OSPF watchdog.  It creates the OSPF 
* timer semaphore.  It then forever pends on the OSPF timer semaphore and
* calls ospf_router_timer() every time it gets the semaphore.
*
* RETURNS: ERROR is the watchdog timer could not be created or started or if 
* OSPF timer semaphore could not be created.
*
* NOMANUAL
*/

STATUS ospf_timer_task_entry_point ()
    {
    STATUS status;
     
    /* create watchdog timer to give timer semaphore once every second */
    ospf.watchdog = wdCreate();
    if (ospf.watchdog == NULL)
        {
        printf ("ospf_timer_task_entry_point: could not create OSPF \n");
        printf ("watchdog, exiting\n");
        return ERROR;
        }
    
    /* create the timer semaphore */
    ospf.timer_task_sem_id = semBCreate (0, SEM_EMPTY);
    if (ospf.timer_task_sem_id == NULL)
        {
        printf("ospf_timer_entry_point: could not create timer semaphore, ");
        printf("exiting\n");
        return ERROR;
        }

    /* set task initialization state to complete */
    ospf.ospf_tasks[OSPF_TASK_TIMER].task_state = OSPF_TASK_STATE_INIT_COMPLETE;

    /* take the startup synchronization semaphore */
    status = semTake (ospf_startup_sem_id, WAIT_FOREVER);
    
    if (status == ERROR)
        {
        printf("ospf_timer_entry_point: could not take startup ");
        printf("semaphore, exiting\n");
        return ERROR;
        }
    
    /* start the watch dog timer with 1 second granularity */
    status = wdStart (
        ospf.watchdog, 
        sysClkRateGet (), 
        (FUNCPTR) ospf_1sec_timer_isr, 
        0);

    if (status == ERROR)
        {
        printf("ospf_timer_entry_point: could not start watchdog timer, ");
        printf("exiting\n");
        return ERROR;
        }

    /*
     * Forever pend on the OSPF timer semaphore.  Every time when get the 
     * semahore, call ospf_router_timer().  The semaphore is given every 
     * second by the watchdog interupt routine ospf_1sec_timer_isr(). 
     */ 
    while (TRUE) 
        {
        semTake (ospf.timer_task_sem_id, WAIT_FOREVER);

        ospf_router_timer ();
        }
    }


/*****************************************************************************
*
* ospf_hello_timer_task_entry_point - OSPF hello timer task entry point
*
* This is the start function of OSPF timer task. 
* Pseudocode:
*   initialize 
*   synchronize with the other OSPF tasks having completed initialization  
*   start timer task activities: infinite loop waiting (semaphore pended) 
*       to execute timer activities when triggered from timer ISR
* 
* OSPFV3 timer initialization:
* Purpose = cause OSPFv3 timer function to run every second, but at task level 
* not at interrupt level (like if using rwos_dispatcher) and without continuous 
* processing even when idle. 
* This is achieved by making the OSPFv3 timer task pend on a sempahore
* ospfv3.timer_semaphore_id, which is given from a watchdog timer ISR 
* that runs precisely every second.
* This function ospfv3_create_tasks also creates the watchdog timer for
* the OSPFv3 timer task ospfv3.watchdog, which ISR does minimal processing: 
* just give a semaphore. OSPFV3 timer task pends on the semaphore while idle
* 
* Inifinite loop serving timer ISRs at task level
*/

void ospf_hello_timer_task_entry_point ()
    {
    /* create the timer semaphore */
    ospf.hello_task_sem_id = semBCreate (0, SEM_EMPTY);

    if (ospf.hello_task_sem_id == NULL)
        {
        printf ("ospf_hello_timer_task_entry_point: ERROR: ");
        printf ("Could not create hello timer semaphore, exiting\n");
        return;
        }

    /* set task initialization state to complete */
    ospf.ospf_tasks[OSPF_TASK_HELLO_TIMER].task_state = OSPF_TASK_STATE_INIT_COMPLETE;

    /* take the startup synchronization semaphore */
    semTake (ospf_startup_sem_id, WAIT_FOREVER);

    while (TRUE) 
        {
        /* 
         * Pend here instead of consuming CPU until watchdog timer interrupt 
         * gives semaphore 
         */
        semTake (ospf.hello_task_sem_id, WAIT_FOREVER);

        ospf_hello_timer ();
        }
    }


/*****************************************************************************
* 
* ospf_input_task_entry_point - ospf input task entry point
* 
* This is the start function of OSPF input task. 
* Pseudocode:
*   initialize 
*   synchronize with the other OSPF tasks having completed initialization  
*   start input task activities: infinite loop waiting (socket pended) 
*       to handle PDUs and interface events received via socket from router stack
*/

void ospf_input_task_entry_point ()
    {
    /* any initialization goes here */
    ospf.ospf_tasks[OSPF_TASK_INPUT].task_state = OSPF_TASK_STATE_INIT_COMPLETE;
    
    /* pend on startup semaphore */
    semTake (ospf_startup_sem_id, WAIT_FOREVER);
    
    /* now start actual function */
    ospf_vx_ip_receive_socket_input();
    } 

 
/*****************************************************************************
* ospf_create_tasks - create OSPF tasks
*
* This function creates all the OSPF tasks, synchronizes their startup 
* to the point where all of them have finished their initialization.  The 
* OSPF tasks are: timer, spf, input, rtm and mapi.
*
* MAPI task creation is a special case: it must be created before OSPF is 
* created.  This is an RFC requirement,  It must be able to configure an OSPF
* instance even if the OSPF instance is not yet created.
*
* RTM task creation is a special case: it must have identical behaviour 
* for all tasks using the routing table manager (RTM).  Therefore, it must use
* the task creation mechanism predefined for RTM tasks.  The OSPF RTM task is 
* spawned with protocol_rtm_run_instance() as entry point function, and with 
* ospf_export_route_from_rtm() as handler of route update messages and
* ospf_sysctl_input() as handler of interface state change messages.
*            
* OSPF task synchonization at startup:
*
* OSPF tasks synchronization at startup is achieved using a semaphore 
* ospf.startup_sem_id and shared memory ospf_tasks.task_state. 
*
* This function is called at init time from ospfInitialize().
*
* Task executing "ospfv3_create_tasks" creates all OSPF tasks with their 
* status: OSPFV3_TASK_STATE_CREATED. 
* Then it waits until all of the tasks have completed initialization and 
* transitioned to state OSPFV3_TASK_STATE_INIT_COMPLETE.
* When all tasks have transitioned to OSPFV3_TASK_STATE_INIT_COMPLETE, 
* this task unblocks all OSPF tasks synchronously by 
* flushing semaphore ospf_startup_sem_id
* 
* Every OSPF task created executes its initialization, then transitions 
* from state OSPFV3_TASK_STATE_CREATED 
* to state OSPFV3_TASK_STATE_INIT_COMPLETE
* and blocks on taking semaphore ospfv3.startup_sem_id.
*
* RETURNS: OK if successfull creation and synchronization of OSPF tasks
*/

STATUS ospf_create_tasks ()
    {
    OSPF_TASKS  task;
    int delay;

    /* 
     * Create task creation semaphore, to synchronize startup of all OSPF tasks
     */
    ospf_startup_sem_id = semBCreate (
        SEM_Q_PRIORITY | SEM_Q_FIFO, SEM_EMPTY);

    if (ospf_startup_sem_id == NULL)
        {
        printf ("ospf_create_tasks: ERROR: ");
        printf ("Could not create startup semaphore, exiting\n");
        return ERROR;
        }

    /* create OSPF tasks */

    /* task configuration */
    ospf.ospf_tasks[OSPF_TASK_TIMER].task_priority   = OSPF_TIMER_TASK_PRIORITY;
    ospf.ospf_tasks[OSPF_TASK_TIMER].task_stack_size = OSPF_TIMER_TASK_STACK_SIZE;
    ospf.ospf_tasks[OSPF_TASK_TIMER].task_id         = 0;
    ospf.ospf_tasks[OSPF_TASK_TIMER].task_state      = OSPF_TASK_STATE_NOT_CREATED;
    ospf.ospf_tasks[OSPF_TASK_TIMER].task_start_func = (FUNCPTR) ospf_timer_task_entry_point;
    strncpy(ospf.ospf_tasks[OSPF_TASK_TIMER].task_name, "tOspfTimer", OSPF_TASK_NAME_SIZE);

    ospf.ospf_tasks[OSPF_TASK_HELLO_TIMER].task_priority   = OSPF_HELLO_TIMER_TASK_PRIORITY;
    ospf.ospf_tasks[OSPF_TASK_HELLO_TIMER].task_stack_size = OSPF_HELLO_TIMER_TASK_STACK_SIZE;
    ospf.ospf_tasks[OSPF_TASK_HELLO_TIMER].task_id         = 0;
    ospf.ospf_tasks[OSPF_TASK_HELLO_TIMER].task_state      = OSPF_TASK_STATE_NOT_CREATED;
    ospf.ospf_tasks[OSPF_TASK_HELLO_TIMER].task_start_func = (FUNCPTR) ospf_hello_timer_task_entry_point;
    strncpy(ospf.ospf_tasks[OSPF_TASK_HELLO_TIMER].task_name, "tOspfHello", OSPF_TASK_NAME_SIZE);

    ospf.ospf_tasks[OSPF_TASK_INPUT].task_priority   = OSPF_INPUT_TASK_PRIORITY;
    ospf.ospf_tasks[OSPF_TASK_INPUT].task_stack_size = OSPF_INPUT_TASK_STACK_SIZE;
    ospf.ospf_tasks[OSPF_TASK_INPUT].task_id         = 0;
    ospf.ospf_tasks[OSPF_TASK_INPUT].task_state      = OSPF_TASK_STATE_NOT_CREATED;
    ospf.ospf_tasks[OSPF_TASK_INPUT].task_start_func = (FUNCPTR) ospf_input_task_entry_point;
    strncpy(ospf.ospf_tasks[OSPF_TASK_INPUT].task_name, "tOspfInput", OSPF_TASK_NAME_SIZE);

    /* create all OSPF tasks */
    for (task = OSPF_TASK_TIMER; task < OSPF_NUM_TASKS; task++) 
        {
        if (task == OSPF_TASK_RTM) 
            {
            /* 
             * RTM task creation is special case, it must have identical 
             * behaviour for all tasks using RTM (OSPF is just one of them). 
             * Use the task creation predefined for RTM tasks. 
             * The OSPFv3 RTM task is spawned with
             * protocol_rtm_run_instance() as entry point function, also with
             * ospf_export_route_from_rtm() as handler of route update messages
             * and ospfv3_sysctl_input() as handler of interface state change 
             * messages 
             */

            if (ospf_register_with_rtm() != PASS)
                {
                return ERROR;
                }

            ospf.ospf_tasks[OSPF_TASK_RTM].task_state   = OSPF_TASK_STATE_INIT_COMPLETE;
            }
        else 
            {
            /* 
             * NOTE: task state must be set before taskSpawn().  Otherwise 
             * task state may get over-written.  This happens when 
             * ospf_create_tasks() is called from a low priority task, e.g.
             * tSnmpd.
             */
            ospf.ospf_tasks[task].task_state = OSPF_TASK_STATE_CREATED;
            
            ospf.ospf_tasks[task].task_id = taskSpawn (
                ospf.ospf_tasks[task].task_name,
                ospf.ospf_tasks[task].task_priority, 
                0,
                ospf.ospf_tasks[task].task_stack_size,
                ospf.ospf_tasks[task].task_start_func,
                0,0,0,0,0,0,0,0,0,0);
                
            if (ospf.ospf_tasks[task].task_id == ERROR)
                {
                printf (
                    "Could not create %s task.\n\r", 
                    ospf.ospf_tasks[task].task_name);
                return ERROR;
                }
            
            /* 
             * Give newly created tasks a chance to run - this is needed when
             * ospf_create_tasks() is called from a high priority task, e.g 
             * the shell task.
             */
            taskDelay (sysClkRateGet());
            }
        } /* for */

    /* 
     * Synchronization point: wait for all tasks to complete initialization.
     * Must yield processor though, as we are running in Shell task at 
     * priority 1 higher than all other OSPF tasks, they can not execute unless 
     * we suspend this shell task for a while. Up to 10 seconds, verify every 
     * second if the OSPF tasks have finished initialization 
     */

    for (delay = 0; delay < 10; delay++)
        {
        if ((ospf.ospf_tasks[OSPF_TASK_TIMER].task_state == OSPF_TASK_STATE_INIT_COMPLETE) &&
            (ospf.ospf_tasks[OSPF_TASK_HELLO_TIMER].task_state == OSPF_TASK_STATE_INIT_COMPLETE) && 
            (ospf.ospf_tasks[OSPF_TASK_INPUT].task_state == OSPF_TASK_STATE_INIT_COMPLETE) && 
            (ospf.ospf_tasks[OSPF_TASK_RTM].task_state   == OSPF_TASK_STATE_INIT_COMPLETE))
            {
            /* all OSPF tasks finished initialization, synch point achieved */
            semFlush (ospf_startup_sem_id);
            semDelete (ospf_startup_sem_id);
            return OK;
            }

        taskDelay (sysClkRateGet ());	/* wait 1 seconds */
        } /* while some OSPF tasks did not finish initialization */

    printf ("OSPF tasks did not initialize correctly\n");

    /* force protocol_enabled to true for ospfShutdown() to work properly */
    ospf.protocol_enabled = TRUE;
    
    /* clean up */
    ospfShutdown();