ssp_ping.c

abstract rtos

    }
    
    
    if( aping_paras[0][0] & XPING_R_X )
    {
        
        msg.srcProcessorId = LOCAL_PROCESSOR_ID;
        msg.srcMpe = MPE_APING;
        msg.dstProcessorId = aping_paras[0][1];
        msg.dstMpe = MPE_APING;
        msg.msgPrio = MSG_PRIO_NORMAL;
        msg.ulSize  = sizeof(struct aping_s);
        msg.pvMsgBuf = (VOID*)apingp;

        apingp->prim = XPING_GO;
            
        aos_msg_send( &msg );
        return;
    }
    

    
    if( 255 == apingp->cli_index )
    {
        aos_task_create("pingtsk", 10240, TASK_PRIO_NORMAL, 
            AOS_TASK_NOPREEMPT, (VOID(*)(VOID *))aping_task, (VOID*)apingp, &task_id );
    }
    else
    {
        aping_task(apingp);
    }
}



VOID xping_go_handle( struct aping_s *apingp0 )
{
    U32   ulRet,aping_tid;

    struct aping_s *apingp;

    apingp = aos_msg_alloc( MPE_APING, sizeof(struct aping_s) );
    if( NULL == apingp )
    {
        return;
    }

    aos_memcpy( apingp, apingp0, sizeof(struct aping_s) );

    
    ulRet = aos_task_create("aping", 
                    8192,
                    TASK_PRIO_NORMAL,
                    AOS_TASK_NOPREEMPT,
                    (VOID(*)(VOID *))aping_task,
                    (VOID*)apingp,
                    &aping_tid );

    if( AOS_SUCC != ulRet )
    {
        apingp->prim  = XPING_BACK;
        apingp->delay = 0;
        apingp->xping_result = XPING_FAIL;

        xping_back(apingp);
    }
}

VOID aping_go_handle( struct aping_s *apingp )
{
    if( apingp->next_r >= apingp->total_r )
    {
        
        return;
    }
    
    if( apingp->next_r == (apingp->total_r-1) )
    {
        
        aping_back( apingp );
        return;
    }
    else
    {
        
        aping_go( apingp );
    }
}

VOID aping_back_handle( struct aping_s *apingp0 )
{
    struct msg_blk *mb;
    U32  i;
    struct aping_s *apingp;

    if( apingp0->next_r )
    {
        
        aping_back( apingp0 );
        return;
    }
    
    
    for( i = 0; i < APING_TASK_NUM; i++ )
    {
        if( U32_BUTT != ap_tsk[i].task_id
          && apingp0->ping_task == (U8)ap_tsk[i].task_id )
        {
            break;
        }
    }

    if( i >= APING_TASK_NUM )
    {
        return;
    }
    
    mb = msg_alloc();
    if( NULL == mb )
    {
        return;
    }

    apingp = aos_msg_alloc( MPE_APING, sizeof(struct aping_s) );
    if( NULL == apingp )
    {
        msg_free( mb );
        return;
    }

    aos_memcpy( apingp, apingp0, sizeof(struct aping_s) );


    mb->data = (U8*)apingp;
    msg_que_tail( &ap_tsk[i].q1, mb );
    aos_event_post( ap_tsk[i].task_id, APING_BACK_EVENT );
}

VOID xping_back_handle( struct aping_s *apingp )
{
    S8   szFrom[128],szBuf[256],*str;
    U32  ping_mode;
    U32  send_cnt,lost_cnt,lost_percent;
    S32  l;
    
    szFrom[0] = 0;
    str = szFrom;
    
    if( apingp->total_r > 0 )
    {
        ping_mode = AOS_NTOHL( apingp->aping_r[0][0] );
        if( ping_mode & APING_R_EIA )
        {
            l = aos_sprintf( str, "[eia %u", AOS_NTOHL( apingp->aping_r[0][1] ) );
        }
        else if( ping_mode & APING_R_EIX )
        {
            l = aos_sprintf( str, "[eix" );
        }
        else
        {
            if( ping_mode & APING_R_IP_EX )
            {
                l = aos_sprintf( str, "[ip %A:%u", apingp->aping_r[0][1], AOS_HTONS(apingp->aping_p[0]) );
            }
            else
            {
                l = aos_sprintf( str, "[ip %A", apingp->aping_r[0][1] );
            }
        }
        str += l;
    }
    if( apingp->total_r > 1 )
    {
        ping_mode = AOS_NTOHL( apingp->aping_r[1][0] ); 
        if( ping_mode & APING_R_EIA )
        {
            l = aos_sprintf( str, " - eia %u", AOS_NTOHL( apingp->aping_r[1][1] ) );
        }
        else if( ping_mode & APING_R_EIX )
        {
            l = aos_sprintf( str, " - eix" );
        }
        else
        {
            if( ping_mode & APING_R_IP_EX )
            {
                l = aos_sprintf( str, " - ip %A:%u", apingp->aping_r[1][1], AOS_HTONS(apingp->aping_p[1]) );
            }
            else
            {
                l = aos_sprintf( str, " - ip %A", apingp->aping_r[1][1] );
            }
        }

        str += l;
    }
    if( apingp->total_r > 2 )
    {
        ping_mode = AOS_NTOHL( apingp->aping_r[2][0] ); 
        if( ping_mode & APING_R_EIA )
        {
            l = aos_sprintf( str, " - eia %u", AOS_NTOHL( apingp->aping_r[2][1] ) );
        }
        else if( ping_mode & APING_R_EIX )
        {
            l = aos_sprintf( str, " - eix" );
        }
        else
        {
            if( ping_mode & APING_R_IP_EX )
            {
                l = aos_sprintf( str, " - ip %A:%u", apingp->aping_r[2][1], AOS_HTONS(apingp->aping_p[2]) );
            }
            else
            {
                l = aos_sprintf( str, " - ip %A", apingp->aping_r[2][1] );
            }
        }

        str += l;
    }

    aos_sprintf( str, "]" );

    switch( apingp->xping_result )
    {
        case XPING_REPORT:
            aos_sprintf( szBuf, "\r\nXping-%s reply,seq=%u, time < %ums",
                szFrom, AOS_NTOHS(apingp->seq), AOS_NTOHL(apingp->delay) );
            aping_out_string( apingp, szBuf, 0 );
            break;
            
        case XPING_TIMEOUT:
            aos_sprintf( szBuf, "\r\nXping-%s timeout,seq=%u", szFrom, AOS_NTOHS(apingp->seq) );
            aping_out_string( apingp, szBuf, 0 );
            break;

        case XPING_END:
            send_cnt  = AOS_NTOHL(apingp->aping_b[0][0]);
            lost_cnt = AOS_NTOHL(apingp->aping_b[1][0]);
            lost_percent = send_cnt?lost_cnt*100/send_cnt:0;
            aos_sprintf( szBuf, "\r\n\r\n    Packet: Send = %u, Recv = %u, Lost = %u(%u%% loss)",
                AOS_NTOHL(apingp->aping_b[0][0]), AOS_NTOHL(apingp->aping_b[0][1]), AOS_NTOHL(apingp->aping_b[1][0]), lost_percent );
            aping_out_string( apingp, szBuf, 0 );

            aos_sprintf( szBuf, "\r\nRound trip: Minimum = %ums, Maximum = %ums, Average = %ums\r\n", 
                AOS_NTOHL(apingp->aping_b[1][1]), AOS_NTOHL(apingp->aping_b[2][0]), AOS_NTOHL(apingp->aping_b[2][1]) );
            aping_out_string( apingp, szBuf, 1 );
            break;
            
        case XPING_FAIL:
            aos_sprintf( szBuf, "\r\nXping failure\r\n"  );
            aping_out_string( apingp, szBuf, 1 );
            break;
            
        default:
            AOS_ASSERT(0);
            break;
    }
    
}

VOID aping_go( struct aping_s *apingp0 )
{
    MSG_S msg;
    U32 ping_mode, ping_val;

    struct aping_s *apingp;

    apingp = aos_msg_alloc( MPE_APING, sizeof(struct aping_s) );
    if( NULL == apingp )
    {
        return;
    }

    aos_memcpy( apingp, apingp0, sizeof(struct aping_s) );

    apingp->prim = APING_GO;
    apingp->next_r++;

    if( apingp->next_r > 2 )
    {
        return;
    }

    ping_mode = AOS_NTOHL( apingp->aping_r[apingp->next_r][0] );
    ping_val  = apingp->aping_r[apingp->next_r][1];

    if( ( ping_mode & APING_R_EIX )
     || ( ping_mode & APING_R_EIA ) )
    {
        msg.srcProcessorId = LOCAL_PROCESSOR_ID;
        msg.srcMpe = MPE_APING;
        msg.dstProcessorId = ping_mode & APING_R_EIA ? \
               AOS_NTOHL(ping_val) : EIG_MASTER_MPU_PROCESSOR_ID;
        msg.dstMpe = MPE_APING;
        msg.msgPrio = MSG_PRIO_NORMAL;
        msg.ulSize  = sizeof(struct aping_s);
        msg.pvMsgBuf = (VOID*)apingp;

        aos_msg_trysend( &msg );
        return;        
    }
    else if( ping_mode & APING_R_IP )
    {
        struct msg_blk *newmb;
        SOCKADDRIN_S sockaddr;

        aos_memset( &sockaddr, 0, sizeof(sockaddr) );

        sockaddr.sin_chLen              = sizeof( SOCKADDRIN_S );
        sockaddr.sin_chFamily           = AF_INET;
        if( ping_mode & APING_R_IP_EX )
        {
            sockaddr.sin_usPort = apingp->aping_p[apingp->next_r];
        }
        else
        {
            sockaddr.sin_usPort = AOS_HTONS(CONFIG_EIA_UDP_PORT + 1);
        }
        sockaddr.sin_stAddr.s_ulAddr    =  apingp->aping_r[apingp->next_r][1];

        newmb = msg_alloc();
        if( NULL == newmb )
        {
            aos_msg_free( apingp );
            return;
        }
        newmb->head    = mem_obj_head(apingp);
        newmb->truelen = mem_obj_size(apingp);
        newmb->end     = newmb->head + newmb->truelen;

        newmb->data = (U8*)apingp;
        newmb->len  = sizeof(struct aping_s);
        newmb->tail = newmb->data + newmb->len;
        
        lcm_rapid_send_to_eth_no_wrapper( (g_lcm_rel_udp_port + 1), newmb, (VOID*)&sockaddr );
        return;
    }        

    aos_msg_free( apingp );
}

VOID aping_back( struct aping_s *apingp0 )
{
    MSG_S msg;
    U32 ping_mode, cur_r, prev_val;
    struct aping_s *apingp;

    apingp = aos_msg_alloc( MPE_APING, sizeof(struct aping_s) );
    if( NULL == apingp )
    {
        return;
    }

    aos_memcpy( apingp, apingp0, sizeof(struct aping_s) );

    apingp->prim = APING_BACK;

    cur_r = apingp->next_r;
    ping_mode = AOS_NTOHL( apingp->aping_r[apingp->next_r][0] );

    apingp->next_r--;
    prev_val = apingp->aping_r[apingp->next_r][1];
    
    if( ( ping_mode & APING_R_EIX )
     || ( ping_mode & APING_R_EIA ) )
    {
        msg.srcProcessorId = LOCAL_PROCESSOR_ID;
        msg.srcMpe = MPE_APING;
        msg.dstProcessorId = ping_mode & APING_R_EIA ? \
               EIG_MASTER_MPU_PROCESSOR_ID : AOS_NTOHL(prev_val);
        msg.dstMpe = MPE_APING;
        msg.msgPrio = MSG_PRIO_NORMAL;
        msg.ulSize  = sizeof(struct aping_s);
        msg.pvMsgBuf = (VOID*)apingp;

        aos_msg_trysend( &msg );
        return;        
    }
    else if( ping_mode & APING_R_IP )
    {
        struct msg_blk *newmb;
        SOCKADDRIN_S sockaddr;
        U16          udp_port;

        aos_memset( &sockaddr, 0, sizeof(sockaddr) );
        udp_port = (U16)AOS_NTOHL(apingp->aping_b[cur_r][1]);

        sockaddr.sin_chLen              = sizeof( SOCKADDRIN_S );
        sockaddr.sin_chFamily           = AF_INET;
        sockaddr.sin_usPort             = AOS_HTONS(udp_port);
        sockaddr.sin_stAddr.s_ulAddr    = apingp->aping_b[cur_r][0];

        newmb = msg_alloc();
        if( NULL == newmb )
        {
            aos_msg_free( apingp );
            return;
        }
        newmb->head    = mem_obj_head(apingp);
        newmb->truelen = mem_obj_size(apingp);
        newmb->end     = newmb->head + newmb->truelen;

        newmb->data = (U8*)apingp;
        newmb->len  = sizeof(struct aping_s);
        newmb->tail = newmb->data + newmb->len;
        
        lcm_rapid_send_to_eth_no_wrapper( g_lcm_rel_udp_port + 1, newmb, (VOID*)&sockaddr );
        return;
    }        

    aos_msg_free( apingp );
}


VOID xping_back( struct aping_s *apingp )
{
    MSG_S msg;
    
    msg.srcProcessorId = LOCAL_PROCESSOR_ID;
    msg.srcMpe = MPE_APING;
    msg.dstProcessorId = EIG_MASTER_MPU_PROCESSOR_ID;
    msg.dstMpe = MPE_APING;
    msg.msgPrio = MSG_PRIO_NORMAL;
    msg.ulSize  = sizeof(struct aping_s);
    msg.pvMsgBuf = (VOID*)apingp;

    aos_msg_send( &msg );
    
}

VOID aping_task( struct aping_s *apingp0 )
{
    U32    hms, lms, delay;
    U32    aping_count, ping_mode;
    U16    aping_seq, seq;
    U32    ulEvent, ret;
    S8     szFrom[128],szBuf[256], *str;
    U32    i, is_aping;
    S32    l;

    U32    max_delay=0, min_delay=0, lost_cnt=0, delay_total=0;
    U32    back_cnt=0, send_cnt, lost_percent, average_delay;

    struct msg_blk *mb;
    struct aping_s *apingp=NULL, *xpingp=NULL;

    if( NULL == apingp0 )
    {
        return;
    }
    ping_mode = AOS_NTOHL( apingp0->aping_r[0][0] );
    if( ping_mode & XPING_R_X )
    {
        is_aping = 0;
    }
    else
    {
        is_aping = 1;
    }

    for( i = 0; i < APING_TASK_NUM; i++ )
    {
        if( U32_BUTT == ap_tsk[i].task_id )
        {
            break;
        }
    }

    if( i >= APING_TASK_NUM )
    {
        if( is_aping )
        {
            aos_sprintf( szBuf, "\r\nAping failure becase no task" );
            aping_out_string( apingp0, szBuf, 0 );
            aos_msg_free( apingp0 );
        }
        else
        {