[ti8168 emac bug] Network package data be Overwrited or Corrupted

Hi,all:

     Here we found a bug while do network pressure test on ti816x evm.

We execute UDP server program in ubutu to receive network packages, run client program in Evm board to send packages.

meanwhile  use Wireshark to do packet capture. After a few minutes,the server program stop to indicate

network package data be Overwrited or Corrupted.

Do analyse based on Wireshark , compare the last two packages wo found that the last package anterior

62 bytes is be Overwrited by previous package.

We have try to merge the newest kernel patch from http://arago-project.org/git/projects/?p=linux-omap3.git;a=shortlog;h=refs/heads/ti81xx-master

but the bug still exists , maybe not be fixed.

how to reappearance:

Ver:DVRRDK_03.00.00.01

Step:

1、After kernel start, run init.sh and load.sh (increase chance of reappearance)

2、run server program  in your linux PC (forexample:ubuntu)

3、run client program in Evm board(Usage:./client server_ip server_port data_size(1-1024, suggest 30)

server:

gcc server.c -o server

client:

arm-none-linux-gnueabi-gcc client.c -o client

/*********************server.c********************************/

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <signal.h>

#define SERVER_PORT 8888
#define MAX_MSG_SIZE 1024
int sockfd;

void udps_respon(int sockfd)
{
    struct sockaddr_in addr;
    unsigned int addrlen;
    int count = 0, revalue;
    char msg[MAX_MSG_SIZE];
    int n;

    while(1)
    {
  printf("c=%d\n", count);
        addrlen = sizeof(addr);
        if((n = recvfrom(sockfd,msg, MAX_MSG_SIZE, 0, (struct sockaddr *)&addr,&addrlen)) < 0)
        {
                fprintf(stderr,"Recveive packahe error:%s",
                strerror(errno));
                continue;
        }
        msg[n] = '\0';
        fprintf(stdout,"r=%s\n", msg);
        revalue = atoi(msg);
        if (revalue != count)
        {
            printf("count=%d revalude=%d no equal!\n", count, revalue);
            break;
        }
        count++;
        sendto(sockfd,msg,n,0,(struct sockaddr *)&addr,addrlen);
    }
}

void signal_handler(int sig)
{
    close(sockfd);
    exit(0);
}

int main(void)
{
    struct sockaddr_in addr;
   
    signal(SIGINT, &signal_handler);

    sockfd = socket(AF_INET,SOCK_DGRAM,0);
    if(sockfd < 0)
    {
        fprintf(stderr,"Socket Error:%sn",strerror(errno));
        exit(1);
    }

    bzero(&addr,sizeof(struct sockaddr_in));
    addr.sin_family = AF_INET;
    addr.sin_addr.s_addr = htonl(INADDR_ANY);
    addr.sin_port = htons(SERVER_PORT);

    if(bind(sockfd,(struct sockaddr *)&addr, sizeof(struct sockaddr_in)) < 0)
    {
            fprintf(stderr,"Bind Error:%sn",strerror(errno));
            goto err;
    }

    udps_respon(sockfd);
err:
    close(sockfd);
    exit(1);
}

/********************************client.c***********************************************/

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <signal.h>

#define MAX_BUF_SIZE 1024
int sockfd, data_size;

void udpc_request(int sockfd,const struct sockaddr_in *addr,int len)
{
    char buffer[MAX_BUF_SIZE];
    int n;
    int ret;
    int count = 0;

    while(1)
    {
        printf("c=%d\n", count);
        memset(buffer, (char)count, data_size);
        sprintf(buffer, "%d", count);
        if ((ret = sendto(sockfd, buffer, data_size > strlen(buffer) ? data_size : strlen(buffer), 0, (struct sockaddr *)addr,len)) < 0)
        {
            printf("sendto err=%d-> %s\n", ret, strerror(ret) );
            break;
        }

        bzero(buffer,MAX_BUF_SIZE);
        n = recvfrom(sockfd,buffer,MAX_BUF_SIZE,0,NULL,NULL);
        if (n < 0)
        {
            fprintf(stderr,"recv err!\n\n");
            break;
        }
       
        buffer[n] = '\0';
        fprintf(stdout,"r=%s\n",buffer);
        count++;
    }
}

void signal_handler(int sig)
{
    close(sockfd);
    exit(0);
}

int main(int argc,char **argv)
{
    int port;
    struct sockaddr_in addr;
    struct sockaddr_in local;
   
    signal(SIGINT, &signal_handler);

    if(argc != 4)
 {
        fprintf(stderr,"Usage:%s server_ip server_port data_size(1-1024)\n",argv[0]);
        exit(1);
    }
    if((port = atoi(argv[2])) < 0) {
        fprintf(stderr,"Usage:%s server_ip server_port\n",argv[0]);
        exit(1);
    }

    sockfd = socket(AF_INET,SOCK_DGRAM,0);
    if(sockfd < 0)
 {
        fprintf(stderr,"Socket Error:%sn",strerror(errno));
        exit(1);
    }

    bzero(&local,sizeof(struct sockaddr_in));
    local.sin_family = AF_INET;
    local.sin_addr.s_addr = htonl(INADDR_ANY);
    local.sin_port = htons(9999);

    if(bind(sockfd,(struct sockaddr *)&local, sizeof(struct sockaddr_in)) < 0)
    {
            fprintf(stderr,"Bind Error:%sn",strerror(errno));
            goto err;
    }

    bzero(&addr,sizeof(struct sockaddr_in));
    addr.sin_family = AF_INET;
    addr.sin_port = htons(port);
    if(inet_aton(argv[1],&addr.sin_addr) < 0)
    {
        fprintf(stderr,"IP error:%sn",strerror(errno));
        goto err;
    }
 
 data_size = atoi(argv[3]);
 if(data_size <= 0 || data_size > MAX_BUF_SIZE)
 {
        fprintf(stderr,"Usage:%s server_ip server_port data_size(1-1024)\n",argv[0]);
        exit(1);
    }
    udpc_request(sockfd,&addr,sizeof(struct sockaddr_in));

err:
    close(sockfd);
    exit(0);
}

Look forward to your reply.

Thanks.