cmd911x.c

smsc911x 网卡驱动 This the users/programmers guide for the LAN911x Linux Driver The following sections

		commandData->IoctlData.dwSignature=SMSC911x_APP_SIGNATURE;
		commandData->IoctlData.dwCommand=COMMAND_GET_SIGNATURE;
		ioctl(commandData->hSockFD,SMSC911x_IOCTL,&(commandData->IfReq));
		if(commandData->IoctlData.dwSignature==SMSC911x_DRIVER_SIGNATURE) {
			return true;
		}
		printf("Failed to find 911x driver on %s\n",commandData->IfReq.ifr_name);
	} else {
		int ifNumber;
		for(ifNumber=0;ifNumber<8;ifNumber++) {
			sprintf(commandData->IfReq.ifr_name,"eth%d",ifNumber);
			commandData->IoctlData.dwSignature=SMSC911x_APP_SIGNATURE;
			commandData->IoctlData.dwCommand=COMMAND_GET_SIGNATURE;
			commandData->IfReq.ifr_data=(void *)&(commandData->IoctlData);
			ioctl(commandData->hSockFD,SMSC911x_IOCTL,&(commandData->IfReq));
			if(commandData->IoctlData.dwSignature==SMSC911x_DRIVER_SIGNATURE) {
				//printf("found 911x on %s\n",commandData->IfReq.ifr_name);
				return true;
			}
		}
		printf("Failed to find 911x driver on eth0 .. eth7\n");
	}
	printf("Either the driver has not been installed or there is\n");
	printf("a possible version mismatch between smsc911x.o and cmd911x\n");
	return false;
}

bool ReceiveULong(SOCKET sock,unsigned long * pDWord)
{
	bool result=false;
	unsigned long data=0;
	unsigned char ch=0;
	if(recv(sock,&ch,1,0)>0) {
		data=(unsigned long)ch;
		if(recv(sock,&ch,1,0)>0) {
			data|=(((unsigned long)ch)<<8);
			if(recv(sock,&ch,1,0)>0) {
				data|=(((unsigned long)ch)<<16);
				if(recv(sock,&ch,1,0)>0) {
					data|=(((unsigned long)ch)<<24);
					(*pDWord)=data;
					result=true;
				}
			}
		}
	}
	return result;
}

bool SendULong(SOCKET sock,unsigned long data) 
{
	bool result=false;
	unsigned char ch=(unsigned char)(data&0x000000FFUL);
	if(send(sock,&ch,1,0)==1) {
		ch=(unsigned char)((data>>8)&0x000000FFUL);
		if(send(sock,&ch,1,0)==1) {
			ch=(unsigned char)((data>>16)&0x000000FFUL);
			if(send(sock,&ch,1,0)==1) {
				ch=(unsigned char)((data>>24)&0x000000FFUL);
				if(send(sock,&ch,1,0)==1) {
					result=true;
				}
			}
		}
	}
	return result;
}

void process_requests(PCOMMAND_DATA commandData)
{
	unsigned long requestCode=0;
	while(ReceiveULong(server_sock,&requestCode)) {
		switch(requestCode) {
		case COMMAND_GET_FLOW_PARAMS:
			commandData->IfReq.ifr_data=(void *)&(commandData->IoctlData);
			commandData->IoctlData.dwSignature=SMSC911x_APP_SIGNATURE;
			commandData->IoctlData.dwCommand=COMMAND_GET_FLOW_PARAMS;
			ioctl(commandData->hSockFD,
				SMSC911x_IOCTL,&(commandData->IfReq));
			if(commandData->IoctlData.dwSignature==SMSC911x_DRIVER_SIGNATURE) {
				SendULong(server_sock,1);//1==success
				SendULong(server_sock,commandData->IoctlData.Data[0]);//RxFlowMeasuredMaxThroughput
				SendULong(server_sock,commandData->IoctlData.Data[1]);//RxFlowMeasuredMaxPacketCount
				SendULong(server_sock,commandData->IoctlData.Data[2]);//RxFlowParameters.MaxThroughput
				SendULong(server_sock,commandData->IoctlData.Data[3]);//RxFlowParameters.MaxPacketCount
				SendULong(server_sock,commandData->IoctlData.Data[4]);//RxFlowParameters.PacketCost
				SendULong(server_sock,commandData->IoctlData.Data[5]);//RxFlowParameters.BurstPeriod
				SendULong(server_sock,commandData->IoctlData.Data[6]);//RxFlowMaxWorkLoad
				SendULong(server_sock,commandData->IoctlData.Data[7]);//INT_CFG.INT_DEAS
			} else {
				SendULong(server_sock,0);//0==failed
			}
			break;
		case COMMAND_SET_FLOW_PARAMS:
			{
				unsigned long data=0;
				commandData->IfReq.ifr_data=(void *)&(commandData->IoctlData);
				commandData->IoctlData.dwSignature=SMSC911x_APP_SIGNATURE;
				commandData->IoctlData.dwCommand=COMMAND_SET_FLOW_PARAMS;
				if(!ReceiveULong(server_sock,&data)) break;
				commandData->IoctlData.Data[0]=data;//RxFlowMeasuredMaxThroughput
				if(!ReceiveULong(server_sock,&data)) break;
				commandData->IoctlData.Data[1]=data;//RxFlowMeasuredMaxPacketCount
				if(!ReceiveULong(server_sock,&data)) break;
				commandData->IoctlData.Data[2]=data;//RxFlowParameters.MaxThroughput
				if(!ReceiveULong(server_sock,&data)) break;
				commandData->IoctlData.Data[3]=data;//RxFlowParameters.MaxPacketCount
				if(!ReceiveULong(server_sock,&data)) break;
				commandData->IoctlData.Data[4]=data;//RxFlowParameters.PacketCost
				if(!ReceiveULong(server_sock,&data)) break;
				commandData->IoctlData.Data[5]=data;//RxFlowParameters.BurstPeriod
				if(!ReceiveULong(server_sock,&data)) break;
				commandData->IoctlData.Data[6]=data;//RxFlowMaxWorkLoad
				if(!ReceiveULong(server_sock,&data)) break;
				commandData->IoctlData.Data[7]=data;//INT_CFG.INT_DEAS
				ioctl(commandData->hSockFD,
					SMSC911x_IOCTL,&(commandData->IfReq));
				if(commandData->IoctlData.dwSignature==SMSC911x_DRIVER_SIGNATURE) {
					SendULong(server_sock,1);//1==success
				} else {
					SendULong(server_sock,0);//0==failed
				}
			}
			break;
		default:
			printf("WARNING, unknown requestCode=0x%08lX\n",requestCode);
			break;
		}
	}
}

void RunServer(PCOMMAND_DATA commandData,unsigned short portNumber)
{
    struct sockaddr *server;
	struct sockaddr_in server4;
	int sockaddr_len;
	struct sockaddr peeraddr;
	SOCKET server_control;
	int on=1;

	if(portNumber==0) {
		portNumber=DEFAULT_PORT_NUMBER;
	}

	server4.sin_port=htons(portNumber);
	server4.sin_addr.s_addr=INADDR_ANY;
	server4.sin_family=AF_INET;
	sockaddr_len=sizeof(struct sockaddr_in);
	server=(struct sockaddr *)&server4;

	printf("Starting server at port %d\n",portNumber);
	server_control = socket(server->sa_family,SOCK_STREAM,0);
	if(server_control==INVALID_SOCKET) 
	{
		printf("Error creating the socket\n");
		exit(1);
	}
	if(setsockopt(server_control,
		SOL_SOCKET,
		SO_REUSEADDR,
		(char *)&on,
		sizeof(on))==SOCKET_ERROR)
	{
		printf("Error: SO_REUSEADDR\n");
		exit(1);
	}
	if(bind(server_control,server,sockaddr_len)==SOCKET_ERROR)
	{
		printf("Error binding the socket\n");
		exit(1);
	}
	if(listen(server_control,5)==SOCKET_ERROR)
	{
		printf("Error listening\n");
		exit(1);
	}
	switch(fork()) {
	case -1:
		printf("Error on fork\n");
		exit(1);
	case 0:
		fclose(stdin);
		fclose(stderr);
		setsid();
		for(;;)
		{
			if((server_sock=accept(server_control,
					&peeraddr,
					&sockaddr_len)) == INVALID_SOCKET)
			{
				printf("Error accept failed\n");
				exit(1);
			}
			switch(fork()) {
			case -1:
				//something went wrong
				exit(1);
			case 0:
				//we are the child process
				close(server_control);
				process_requests(commandData);
				close(server_sock);
				exit(0);
				break;
			default:
				//we are the parent process
				close(server_sock);
				break;
			}
		}
		break;
	default:
		exit(0);
	}
}

bool ReceiveFlowParams(SOCKET sock,PFLOW_PARAMS flowParams) 
{
	bool result=false;
	if(SendULong(sock,COMMAND_GET_FLOW_PARAMS)) {
		unsigned long data=0;
		if(!ReceiveULong(sock,&data)) goto DONE;
		if(data) {
			if(!ReceiveULong(sock,&data)) goto DONE;
			flowParams->MeasuredMaxThroughput=data;
			if(!ReceiveULong(sock,&data)) goto DONE;
			flowParams->MeasuredMaxPacketCount=data;
			if(!ReceiveULong(sock,&data)) goto DONE;
			flowParams->MaxThroughput=data;
			if(!ReceiveULong(sock,&data)) goto DONE;
			flowParams->MaxPacketCount=data;
			if(!ReceiveULong(sock,&data)) goto DONE;
			flowParams->PacketCost=data;
			if(!ReceiveULong(sock,&data)) goto DONE;
			flowParams->BurstPeriod=data;
			if(!ReceiveULong(sock,&data)) goto DONE;
			flowParams->MaxWorkLoad=data;
			if(!ReceiveULong(sock,&data)) goto DONE;
			flowParams->IntDeas=data;
			result=true;
		}
	}
DONE:
	return result;
}

bool SendFlowParams(SOCKET sock,PFLOW_PARAMS flowParams)
{
	bool result=false;
	unsigned long timeout=100;
	unsigned long data=0;
AGAIN:
	SendULong(sock,COMMAND_SET_FLOW_PARAMS);
	SendULong(sock,flowParams->MeasuredMaxThroughput);
	SendULong(sock,flowParams->MeasuredMaxPacketCount);
	SendULong(sock,flowParams->MaxThroughput);
	SendULong(sock,flowParams->MaxPacketCount);
	SendULong(sock,flowParams->PacketCost);
	SendULong(sock,flowParams->BurstPeriod);
	SendULong(sock,flowParams->MaxWorkLoad);
	SendULong(sock,flowParams->IntDeas);
	if(ReceiveULong(sock,&data)) {
		if(data) {
			result=true;
		} else {
			//If flow control was active this command will fail
			//  therefore wait and try again later.
			if(timeout>0) {
				timeout--;
				sleep(5);
				goto AGAIN;
			}
		}
	}
	return result;
}

void DisplayFlowParams(PFLOW_PARAMS flowParams) 
{
	printf("Flow Control Parameters\n");
	printf("  MaxThroughput          = 0x%08lX\n",flowParams->MaxThroughput);
	printf("  MaxPacketCount         = 0x%08lX\n",flowParams->MaxPacketCount);
	printf("  PacketCost             = 0x%08lX\n",flowParams->PacketCost);
	printf("  BurstPeriod            = 0x%08lX\n",flowParams->BurstPeriod);
	printf("  IntDeas                = 0x%08lX\n",flowParams->IntDeas);
}

unsigned long ReadThroughput(char * fileName)
{
	unsigned long result=0;
	bool clearFlag=true;
	FILE * filePtr=NULL;
	filePtr=fopen(fileName,"r");
	if(filePtr!=NULL) {
		char ch=0;
		while(fread(&ch,1,1,filePtr)!=0) {
			switch(ch) {
			case '0':case '1':case '2':case '3':case '4':
			case '5':case '6':case '7':case '8':case '9':
				if(clearFlag) {
					result=0;
					clearFlag=false;
				}
				result*=10;
				result+=(unsigned long)(ch-'0');
				break;
			case '.':
				break;
			default:
				clearFlag=true;
				break;
			}
		}
		fclose(filePtr);
	} else {
		printf("ReadThroughput: unable to open file\n");
	}
	return result;
}

void RunTuner(const char *hostName,unsigned short portNum)
{
	SOCKET controlSocket=INVALID_SOCKET;
	struct sockaddr_in server;
    unsigned int addr;
	char command[128];
	char outputFile[]="npout.txt";
	FLOW_PARAMS flowParams;
	FLOW_PARAMS origParams;
	FLOW_PARAMS bestParams;
	unsigned long bestMeasurement=0;
	unsigned long currentSetting=0;
	unsigned long currentMeasurement=0;
	unsigned long tempLow=0;
	unsigned long tempHigh=0;
	int salen;
	memset((char *)&server,0,sizeof(server));

	if(portNum==0) {
		portNum=DEFAULT_PORT_NUMBER;
	}
	server.sin_port=htons(portNum);
	if((addr=inet_addr(hostName))==0xFFFFFFFFUL) {
		printf("Invalid: hostName==\"%s\"",hostName);
		printf("   must be in IP form\n");
		return;
	} else {
		server.sin_addr.s_addr=addr;
		server.sin_family=AF_INET;
	}
	salen=sizeof(server);

	controlSocket=socket(AF_INET,SOCK_STREAM,0);
	if(controlSocket==INVALID_SOCKET) {
		printf("error creating control socket\n");
		return;
	}
	if(connect(controlSocket,
		(struct sockaddr *)&server,
		salen) == INVALID_SOCKET)
	{
		printf("failed to connect to %s:%d\n",hostName,portNum);
		goto DONE;
	}

	if(!ReceiveFlowParams(controlSocket,&origParams)) goto FAILED;
	memcpy(&bestParams,&origParams,sizeof(FLOW_PARAMS));
	bestParams.MeasuredMaxThroughput=0;
	bestParams.MeasuredMaxPacketCount=0;
	bestParams.MaxThroughput=0;
	bestParams.MaxPacketCount=0;
	bestParams.BurstPeriod=100;
	bestParams.MaxWorkLoad=0;
	bestParams.IntDeas=0;
	memcpy(&flowParams,&bestParams,sizeof(FLOW_PARAMS));

	printf("Entire tuning process will take about one hour.\n");
	printf("TUNING IntDeas\n");
	sprintf(command,"./netperf -H%s > %s",hostName,outputFile);
	bestMeasurement=0;
	for(currentSetting=0;currentSetting<80;currentSetting++) {
		flowParams.IntDeas=currentSetting;
		if(!SendFlowParams(controlSocket,&flowParams)) {
			printf("Failed to send new setting: IntDeas=%ld\n",currentSetting);
			goto FAILED;
		}
		if(system(command)==0) {
			currentMeasurement=ReadThroughput(outputFile);
			if(currentMeasurement>bestMeasurement) {
				bestMeasurement=currentMeasurement;
				bestParams.IntDeas=currentSetting;
			}
		} else {
			printf("Failed system command: \"%s\"\n",command);
			goto FAILED;