Exemplo n.º 1
0
Arquivo: upro.c Projeto: H1d3r/UPro
void dump(upro_collector_context_t *context)
{
	int ret;
	int queue_id = context->queue_id;

	upro_collector_t *cc = &(collectors[context->id]); 
	assert(ps_init_handle(&(cc->handle)) == 0);

	struct ps_queue queue;
	queue.ifindex = context->ifindex;
	queue.qidx = queue_id;
	printf("[Collector %d] is attaching if:queue %d:%d ...\n", context->id, queue.ifindex, queue.qidx);
	assert(ps_attach_rx_device(&(cc->handle), &queue) == 0);

	struct ps_chunk chunk;
	assert(ps_alloc_chunk(&(cc->handle), &chunk) == 0);
	chunk.recv_blocking = 1;

	gettimeofday(&(cc->startime), NULL);
	
	for (;;) {
		chunk.cnt = config->io_batch_num;

		ret = ps_recv_chunk(&(cc->handle), &chunk);
		if (ret < 0) {
			if (errno == EINTR)
				continue;
			assert(0);
		}

		cc->total_packets += ret;
		cc->total_bytes += ret * 1370;
		continue;
	}
}
Exemplo n.º 2
0
/*----------------------------------------------------------------------------*/
void
psio_init_handle(struct mtcp_thread_context *ctxt)
{
	int i, ret;
	struct psio_private_context *ppc;
	struct timeval cur_ts;

	/* create and initialize private I/O module context */
	ctxt->io_private_context = calloc(1, sizeof(struct psio_private_context));
	if (ctxt->io_private_context == NULL) {
		TRACE_ERROR("Failed to initialize ctxt->io_private_context: "
			    "Can't allocate memory\n");
		exit(EXIT_FAILURE);
	}
	
	ppc = (struct psio_private_context *)ctxt->io_private_context;
	if (ps_init_handle(&ppc->handle)) {
		perror("ps_init_handle");
		TRACE_ERROR("Failed to initialize ps handle.\n");
		exit(EXIT_FAILURE);
	}

	/* create buffer for reading ingress batch of packet */
	if (ps_alloc_chunk(&ppc->handle, &ppc->chunk) != 0) {
		perror("ps_alloc_chunk");
		TRACE_ERROR("Failed to allocate ps_chunk\n");
		exit(EXIT_FAILURE);
	}

	/* create packet write chunk */
	for (i = 0; i < num_devices_attached; i++) {
		ret = ps_alloc_chunk_buf(&ppc->handle, i, ctxt->cpu, &ppc->w_chunk_buf[i]);
		if (ret != 0) {
			TRACE_ERROR("Failed to allocate ps_chunk_buf.\n");
			exit(EXIT_FAILURE);
		}
	}
	
	gettimeofday(&cur_ts, NULL);
	
	/* initialize PSIO parameters */
	ppc->chunk.recv_blocking = 0;
	ppc->event.timeout = PS_SELECT_TIMEOUT;
	ppc->event.qidx = ctxt->cpu;
	NID_ZERO(ppc->event.rx_nids);
	NID_ZERO(ppc->event.tx_nids);
	NID_ZERO(ppc->rx_avail);
	//NID_ZERO(ppc->tx_avail);

	for (i = 0; i < CONFIG.eths_num; i++) {
		ppc->last_tx_set[i] = cur_ts;
		NID_SET(i, ppc->tx_avail);
	}
}
Exemplo n.º 3
0
void dump()
{
	int ret;
	struct ps_chunk chunk;
    char flag = 0;
    struct ps_handle* handle = &handles[my_cpu];

	chunk.queue.ifindex = devices_attached[0];
	chunk.queue.qidx = my_cpu;
	ret = ps_alloc_chunk(handle, &chunk);
	if (ret != 0) {
		perror("ps_alloc_chunk");
		exit(1);
	}

	chunk.cnt = 128; /* no batching */
	chunk.recv_blocking = 1;


	for (;;) {
		int ret = ps_recv_chunk(handle, &chunk);

		if (ret < 0) {
			if (errno == EINTR){
                printf("dump errno == EINTR\n");
				continue;
            }

			if (!chunk.recv_blocking && errno == EWOULDBLOCK){
                printf("dump !chunk.recv_blocking && errno == EWOULDBLOCK\n");
				break;
            }

			assert(0);
		}
        if(ret > 0) {
            if(!flag) {
                flag = 1;
                gettimeofday(&start, NULL);
            }
            else 
                stat_signal(0);
            chunk.retcnt = ret;
            chunk.front = (chunk.front + ret) & (MAX_CHUNK_SIZE - 1);
        }

	}
}
Exemplo n.º 4
0
/* XXX - ignored at the moment (this is disabled by default) */
inline void 
InitWriteChunks(struct ps_handle* handle, struct ps_chunk *w_chunk) 
{
	int i, ret;
	for (i = 0; i < ETH_NUM; i++)
	{
		ret = ps_alloc_chunk(handle, &w_chunk[i]);
		if (ret != 0)
		{
			perror("ps_alloc_chunk");
			exit(1);
		}
		w_chunk[i].queue.ifindex = i;
		w_chunk[i].recv_blocking = 0;
		w_chunk[i].cnt = 0;
	}
}
Exemplo n.º 5
0
void echo()
{
	struct ps_handle *handle = &handles[my_cpu];
	struct ps_chunk chunk;

	int i;
	int working = 0;

	assert(ps_init_handle(handle) == 0);

	for (i = 0; i < num_devices_attached; i++) {
		struct ps_queue queue;
		if (devices[devices_attached[i]].num_rx_queues <= my_cpu)
			continue;

		if (devices[devices_attached[i]].num_tx_queues <= my_cpu) {
			printf("WARNING: xge%d has not enough TX queues!\n",
					devices_attached[i]);
			continue;
		}

		working = 1;
		queue.ifindex = devices_attached[i];
		queue.qidx = my_cpu;

		printf("attaching RX queue xge%d:%d to CPU%d\n", queue.ifindex, queue.qidx, my_cpu);
		assert(ps_attach_rx_device(handle, &queue) == 0);
	}

	if (!working)
		goto done;

	assert(ps_alloc_chunk(handle, &chunk) == 0);

	chunk.recv_blocking = 1;

	for (;;) {
		int ret;
		
		chunk.cnt = 64;
		ret = ps_recv_chunk(handle, &chunk);

		if (ret < 0) {
			if (errno == EINTR)
				continue;

			if (!chunk.recv_blocking && errno == EWOULDBLOCK)
				break;

			assert(0);
		}

		if (!sink) {
			chunk.cnt = ret;
			ret = ps_send_chunk(handle, &chunk);
			assert(ret >= 0);
		}
	}

done:
	ps_close_handle(handle);
}
Exemplo n.º 6
0
void send_packets(long packets,
                  int chunk_size,
                  int packet_size,
                  int num_flows)
{
    struct ps_handle *handle = &handles[my_cpu];
    struct ps_chunk chunk;
    char packet[MAX_FLOWS][MAX_PACKET_SIZE];
    int ret;

    int i, j;
    unsigned int next_flow[MAX_DEVICES];

    long sent = 0;
    uint64_t seed = 0;

    if (num_flows == 0)
        seed = time(NULL) + my_cpu;

    for (i = 0; i < num_flows; i++) {
        if (ip_version == 4)
            build_packet(packet[i], packet_size, &seed);
        else if (ip_version == 6)
            build_packet_v6(packet[i], packet_size, &seed);
    }

    assert(ps_init_handle(handle) == 0);

    for (i = 0; i < num_devices_registered; i++)
        next_flow[i] = 0;

    assert(ps_alloc_chunk(handle, &chunk) == 0);
    chunk.queue.qidx = my_cpu; /* CPU_i holds queue_i */

    assert(chunk.info);

    while (1) {
        int working = 0;

        for (i = 0; i < num_devices_registered; i++) {
            chunk.queue.ifindex = devices_registered[i];
            working = 1;

            for (j = 0; j < chunk_size; j++) {
                chunk.info[j].len = packet_size;
                chunk.info[j].offset = j * ALIGN(packet_size, 64);

                if (num_flows == 0) {
                    if (ip_version == 4) {
                        build_packet(chunk.buf + chunk.info[j].offset,
                                     packet_size, &seed);
                    } else {
                        build_packet_v6(chunk.buf + chunk.info[j].offset,
                                        packet_size, &seed);
                    }

                }
                else
                    memcpy_aligned(chunk.buf + chunk.info[j].offset,
                                   packet[(next_flow[i] + j) % num_flows],
                                   packet_size);
            }

            if (packets - sent < chunk_size)
                chunk.cnt = packets - sent;
            else
                chunk.cnt = chunk_size;

            ret = ps_send_chunk(handle, &chunk);
            assert(ret >= 0);

            update_stats(handle);
            sent += ret;

            if (packets <= sent)
                done();

            if (num_flows)
                next_flow[i] = (next_flow[i] + ret) % num_flows;
        }

        if (!working)
            break;
    }

    ps_close_handle(handle);
}
Exemplo n.º 7
0
Arquivo: rxdump.c Projeto: H1d3r/UPro
void dump()
{
	int ret;
	struct ps_chunk chunk;

	ret = ps_alloc_chunk(&handle, &chunk);
	if (ret != 0) {
		perror("ps_alloc_chunk");
		exit(1);
	}

	chunk.cnt = 128; /* no batching */
	chunk.recv_blocking = 1;

	gettimeofday(&startime, NULL);

	for (;;) {
		int ret = ps_recv_chunk(&handle, &chunk);
		//printf("%d pkts from queue %d\n", chunk.cnt, chunk.queue.qidx);

		if (ret < 0) {
			if (errno == EINTR)
				continue;

			if (!chunk.recv_blocking && errno == EWOULDBLOCK)
				break;

			assert(0);
		}

		if (ret > 0) {
			printf("%d ", ret);
		}

/*
		if (ret > 0) {
			struct ps_packet packet;

			printf("%s:%d ", 
					devices[chunk.queue.ifindex].name,
					chunk.queue.qidx);
			dump_packet(chunk.buf + chunk.info[0].offset, chunk.info[0].len);

			packet.arrived_ifindex = chunk.queue.ifindex;
			packet.len = chunk.info[0].len;
			packet.buf = chunk.buf + chunk.info[0].offset;

			assert(ps_slowpath_packet(&handle, &packet) == 0);
		}
		printf("--> %d\n", chunk.queue.qidx);
		chunk.cnt = 1;
*/
		//assert(chunk.cnt == 128);
		/*
		if (chunk.cnt != 128)
			printf("(%d)", chunk.cnt);
		int i, j=0;
		for (i = 0; i < chunk.cnt; i ++) {
			//assert(chunk.info[i].len != 0);
			if (chunk.info[i].len == 0) {
				printf("#%d", i);
				j = 1;
			}
			//else printf("0");
		}
		if (j == 1)
			printf("\n");
*/
	}
}
Exemplo n.º 8
0
int fire_worker_start(int queue_id)
{
	int ret, i, j, k, prot, send_ret;

	fire_worker_t *cc = &(workers[queue_id]); 
	assert(ps_init_handle(&(cc->server_handle)) == 0);
	assert(ps_init_handle(&(cc->client_handle)) == 0);

	struct ps_queue server_queue, client_queue;
	server_queue.ifindex = config->server_ifindex;
	server_queue.qidx = queue_id;
	client_queue.ifindex = config->client_ifindex;
	client_queue.qidx = queue_id;

	assert(ps_attach_rx_device(&(cc->server_handle), &server_queue) == 0);
	assert(ps_attach_rx_device(&(cc->client_handle), &client_queue) == 0);

	struct ps_chunk client_chunk, send_client_chunk, server_chunk, send_server_chunk;
	assert(ps_alloc_chunk(&(cc->client_handle), &client_chunk) == 0);
	assert(ps_alloc_chunk(&(cc->client_handle), &send_client_chunk) == 0);
	assert(ps_alloc_chunk(&(cc->server_handle), &server_chunk) == 0);
	assert(ps_alloc_chunk(&(cc->server_handle), &send_server_chunk) == 0);

	client_chunk.queue.ifindex = config->client_ifindex;
	client_chunk.queue.qidx = queue_id;
	send_client_chunk.queue.ifindex = config->client_ifindex;
	send_client_chunk.queue.qidx = queue_id;
	server_chunk.queue.ifindex = config->server_ifindex;
	server_chunk.queue.qidx = queue_id;
	send_server_chunk.queue.ifindex = config->server_ifindex;
	send_server_chunk.queue.qidx = queue_id;

	int num_pkt_to_client = 0, num_pkt_to_server = 0;
	int pret;

	gettimeofday(&(cc->startime), NULL);

#if defined(HIPAC_TCB)
	int hipac_cnt = 0;
#endif

	for (;;) {
		num_pkt_to_client = 0;
		num_pkt_to_server = 0;
		j = 0;
		k = 0;

		client_chunk.cnt = config->io_batch_num;
		client_chunk.recv_blocking = 0;

		ret = ps_recv_chunk(&(cc->client_handle), &client_chunk);
		if (ret <= 0) {
			/* Receive nothing from server, go to the start of the loop to process client again */
			goto process_server;
		}
		cc->total_packets += ret;

		int action;

		for (i = 0; i < ret; i ++) {
			prot = process_packet(client_chunk.buf + client_chunk.info[i].offset, client_chunk.info[i].len);
			switch (prot) {
				case TCP_SYN_SENT:
					action = HiPAC(client_chunk.buf + client_chunk.info[i].offset, client_chunk.info[i].len, l);
					if(action == FORWARD) {
						// first handshake packet
						// construct the response, and send back to client
						//fprint(INFO, "1) TCP_SYN_SENT\n");
						send_client_chunk.info[j].len = client_chunk.info[i].len;
						send_client_chunk.info[j].offset = j * PS_MAX_PACKET_SIZE;
						memcpy(send_client_chunk.buf + send_client_chunk.info[j].offset,
								client_chunk.buf + client_chunk.info[i].offset, client_chunk.info[i].len);
						form_syn_response(send_client_chunk.buf + send_client_chunk.info[j].offset,
								send_client_chunk.info[j].len);
						pret = process_packet(send_client_chunk.buf 
								+ send_client_chunk.info[j].offset, send_client_chunk.info[j].len);
#if 0
						if(pret != TCP_SYN_RECV){
							printf("pret is %d\n", pret);
							printf("client:\n");
							dmesg(client_chunk.buf + client_chunk.info[i].offset);
							printf("server:\n");
							dmesg(send_client_chunk.buf + send_client_chunk.info[j].offset);
							exit(0);
						}
#endif
						assert(pret == TCP_SYN_RECV);
						//fprint(INFO, "2) TCP_SYN_RECV\n");
						j ++;
					}
					else{ 
					//	hipac_cnt ++;
					//	if(hipac_cnt > 0) printf("hipac filter : %d\n", hipac_cnt);
						delete_tcp(client_chunk.buf + client_chunk.info[i].offset);
					}			
					break;

				case TCP_ESTABLISHED:
					// the 3rd handshake packet
					// do nothing and wait for client's real request
					//fprint(INFO, "3) TCP_ESTABLISHED\n");
					break;

				case -2:
					//fprint(INFO, "two buckets full\n");
					break;

				case -1:
					//fprint(INFO, "Error pkt, don't forward to server.\n");
					break;

				default:
					// normal packet, send to server
					//fprint(INFO, "4) Normal packet, send to server\n");
					send_server_chunk.info[k].len = client_chunk.info[i].len;
					send_server_chunk.info[k].offset = k * PS_MAX_PACKET_SIZE;
					memcpy(send_server_chunk.buf + send_server_chunk.info[k].offset,
							client_chunk.buf + client_chunk.info[i].offset, client_chunk.info[i].len);
					k ++;
					break;
			}

			cc->total_bytes += client_chunk.info[i].len; 

		}
	
		if (j > 0) {
			//fprint(INFO, "sending %d SYN/ACK packet to client, queue_id %d, ifindex %d\n", j, queue_id, config->client_ifindex);
			send_client_chunk.cnt = j;
			send_ret = ps_send_chunk(&(cc->client_handle), &send_client_chunk);
			if (send_ret < 0)
				fprint(ERROR, "send packet fail, ret = %d\n", send_ret);
		}

		if (k > 0) {
			//fprint(INFO, "sending %d packets of established connection to server, queue_id %d, ifindex %d\n", k, queue_id, config->server_ifindex);
			send_server_chunk.cnt = k;
			send_ret = ps_send_chunk(&(cc->server_handle), &send_server_chunk);
			if (send_ret < 0)
				fprint(ERROR, "send packet fail, ret = %d\n", send_ret);
		}
#if 0
		/* FIXME: cannot send all packets
		while (ret > 0) {
			chunk.cnt = ret;
			send_ret = ps_send_chunk(&(cc->handle), &send_chunk);
			if (send_ret < 0)
				fprint(ERROR, "send packet fail, ret = %d\n", send_ret);
			ret -= send_ret;
			//assert(ret >= 0);
		}*/
#endif

process_server:
		/*----------------------------------------------------------------------------------*/
		/* Now process server side packet*/
		server_chunk.cnt = config->io_batch_num;
		//server_chunk.recv_blocking = 0;	//modify at the frist time

		server_chunk.recv_blocking = 0;
		j = 0;

		ret = ps_recv_chunk(&(cc->server_handle), &server_chunk);
		if (ret <= 0) {
			if (errno == EINTR)
				continue;
			/* Receive nothing from server, go to the start of the loop to process client again */
			continue;
		}
		for (i = 0; i < ret; i ++) {
			prot = process_packet(server_chunk.buf + server_chunk.info[i].offset, server_chunk.info[i].len);
			if (prot == 0) {
				send_client_chunk.info[j].len = server_chunk.info[i].len;
				send_client_chunk.info[j].offset = j * PS_MAX_PACKET_SIZE;
				memcpy(send_client_chunk.buf + send_client_chunk.info[j].offset,
					server_chunk.buf + server_chunk.info[i].offset, server_chunk.info[i].len);
				j ++;
			} else {
				fprint(ERROR, "wrong packet from server\n");
			}
		}

		if (j > 0) {
			fprint(DEBUG, "sending packet, queue_id %d, num %d, index %d\n", queue_id, ret, config->client_ifindex);
			send_client_chunk.cnt = j;
			send_ret = ps_send_chunk(&(cc->client_handle), &send_client_chunk);
			if (send_ret < 0)
				fprint(ERROR, "send packet fail, ret = %d\n", send_ret);
		}
	}
	return 0;
}
Exemplo n.º 9
0
void echo()
{
	struct ps_handle *handle = &handles[my_cpu];
	struct ps_chunk chunk;

	int i;
	int working = 0;

	assert(ps_init_handle(handle) == 0);

	for (i = 0; i < num_devices_attached; i++) {
		struct ps_queue queue;
		if (devices[devices_attached[i]].num_rx_queues <= my_cpu)
			continue;

		if (devices[devices_attached[i]].num_tx_queues <= my_cpu) {
			printf("WARNING: xge%d has not enough TX queues!\n",
					devices_attached[i]);
			continue;
		}

		working = 1;
		queue.ifindex = devices_attached[i];
		queue.qidx = my_cpu;

		printf("attaching RX queue xge%d:%d to CPU%d\n", queue.ifindex, queue.qidx, my_cpu);
		assert(ps_attach_rx_device(handle, &queue) == 0);
	}

	if (!working)
		goto done;

	assert(ps_alloc_chunk(handle, &chunk) == 0);

	chunk.recv_blocking = 1;

	for (;;) {
		int ret, i, j;
		struct ethhdr *eth;

		chunk.cnt = 64;
		ret = ps_recv_chunk(handle, &chunk);

		if (ret < 0) {
			if (errno == EINTR)
				continue;

			if (!chunk.recv_blocking && errno == EWOULDBLOCK)
				break;

			assert(0);
		}

		if (!echo_as_is) {
			for (i = 0; i < ret; i++) {
				char tmp[6];
				bool drop = true;
				eth = (struct ethhdr *)chunk.buf + chunk.info[i].offset;

				if (!sink)
					for (j = 0; j < num_devices_attached; j++) {
						drop &= !(memcmp(devices[j].dev_addr, eth->h_dest, ETH_ALEN) == 0);
					}

				if (drop) {
					chunk.info[i].offset = -1;
				} else {
					memcpy(tmp, eth->h_dest, 6);
					memcpy(eth->h_dest, eth->h_source, 6);
					memcpy(eth->h_source, tmp, 6);
				}
			}
		}

		if (!sink) {
			chunk.cnt = ret;
			ret = ps_send_chunk(handle, &chunk);
			assert(ret >= 0);
		}
	}

done:
	ps_close_handle(handle);
}