Commit 23d9e60b authored by Ben Hutchings's avatar Ben Hutchings Committed by Jeff Garzik
Browse files

sfc: Cleaned up struct tso_state fields 



Squashed nested structures.

Renamed remaining_len to out_len, ifc.len to in_len, header_length to
header_len.

Moved ipv4_id into the group of output variables where it belongs.

Signed-off-by: default avatarBen Hutchings <bhutchings@solarflare.com>
Signed-off-by: default avatarJeff Garzik <jgarzik@redhat.com>
parent 28506563

drivers/net/sfc/tx.c

+75 −86
Original line number Diff line number Diff line
@@ -540,46 +540,37 @@ void efx_remove_tx_queue(struct efx_tx_queue *tx_queue) 


/**

 * struct tso_state - TSO state for an SKB

 * @remaining_len: Bytes of data we've yet to segment

 * @out_len: Remaining length in current segment

 * @seqnum: Current sequence number

 * @ipv4_id: Current IPv4 ID, host endian

 * @packet_space: Remaining space in current packet

 * @ifc: Input fragment cursor.

 *	Where we are in the current fragment of the incoming SKB.  These

 *	values get updated in place when we split a fragment over

 *	multiple packets.

 * @p: Parameters.

 *	These values are set once at the start of the TSO send and do

 *	not get changed as the routine progresses.

 * @dma_addr: DMA address of current position

 * @in_len: Remaining length in current SKB fragment

 * @unmap_len: Length of SKB fragment

 * @unmap_addr: DMA address of SKB fragment

 * @unmap_single: DMA single vs page mapping flag

 * @header_len: Number of bytes of header

 * @full_packet_size: Number of bytes to put in each outgoing segment

 *

 * The state used during segmentation.  It is put into this data structure

 * just to make it easy to pass into inline functions.

 */

struct tso_state {

	unsigned remaining_len;

	/* Output position */

	unsigned out_len;

	unsigned seqnum;

	unsigned ipv4_id;

	unsigned packet_space;



	struct {

		/* DMA address of current position */

	/* Input position */

	dma_addr_t dma_addr;

		/* Remaining length */

		unsigned int len;

		/* DMA address and length of the whole fragment */

		unsigned int unmap_len;

	unsigned in_len;

	unsigned unmap_len;

	dma_addr_t unmap_addr;

	bool unmap_single;

	} ifc;



	struct {

		/* The number of bytes of header */

		unsigned int header_length;



		/* The number of bytes to put in each outgoing segment. */

	unsigned header_len;

	int full_packet_size;



		/* Current IPv4 ID, host endian. */

		unsigned ipv4_id;

	} p;

};
@@ -840,35 +831,34 @@ static inline void tso_start(struct tso_state *st, const struct sk_buff *skb) 
	/* All ethernet/IP/TCP headers combined size is TCP header size

	 * plus offset of TCP header relative to start of packet.

	 */

	st->p.header_length = ((tcp_hdr(skb)->doff << 2u)

	st->header_len = ((tcp_hdr(skb)->doff << 2u)

			  + PTR_DIFF(tcp_hdr(skb), skb->data));

	st->p.full_packet_size = (st->p.header_length

				  + skb_shinfo(skb)->gso_size);

	st->full_packet_size = st->header_len + skb_shinfo(skb)->gso_size;



	st->p.ipv4_id = ntohs(ip_hdr(skb)->id);

	st->ipv4_id = ntohs(ip_hdr(skb)->id);

	st->seqnum = ntohl(tcp_hdr(skb)->seq);



	EFX_BUG_ON_PARANOID(tcp_hdr(skb)->urg);

	EFX_BUG_ON_PARANOID(tcp_hdr(skb)->syn);

	EFX_BUG_ON_PARANOID(tcp_hdr(skb)->rst);



	st->packet_space = st->p.full_packet_size;

	st->remaining_len = skb->len - st->p.header_length;

	st->ifc.unmap_len = 0;

	st->ifc.unmap_single = false;

	st->packet_space = st->full_packet_size;

	st->out_len = skb->len - st->header_len;

	st->unmap_len = 0;

	st->unmap_single = false;

}



static inline int tso_get_fragment(struct tso_state *st, struct efx_nic *efx,

				   skb_frag_t *frag)

{

	st->ifc.unmap_addr = pci_map_page(efx->pci_dev, frag->page,

	st->unmap_addr = pci_map_page(efx->pci_dev, frag->page,

				      frag->page_offset, frag->size,

				      PCI_DMA_TODEVICE);

	if (likely(!pci_dma_mapping_error(efx->pci_dev, st->ifc.unmap_addr))) {

		st->ifc.unmap_single = false;

		st->ifc.unmap_len = frag->size;

		st->ifc.len = frag->size;

		st->ifc.dma_addr = st->ifc.unmap_addr;

	if (likely(!pci_dma_mapping_error(efx->pci_dev, st->unmap_addr))) {

		st->unmap_single = false;

		st->unmap_len = frag->size;

		st->in_len = frag->size;

		st->dma_addr = st->unmap_addr;

		return 0;

	}

	return -ENOMEM;
@@ -878,16 +868,16 @@ static inline int 
tso_get_head_fragment(struct tso_state *st, struct efx_nic *efx,

		      const struct sk_buff *skb)

{

	int hl = st->p.header_length;

	int hl = st->header_len;

	int len = skb_headlen(skb) - hl;



	st->ifc.unmap_addr = pci_map_single(efx->pci_dev, skb->data + hl,

	st->unmap_addr = pci_map_single(efx->pci_dev, skb->data + hl,

					len, PCI_DMA_TODEVICE);

	if (likely(!pci_dma_mapping_error(efx->pci_dev, st->ifc.unmap_addr))) {

		st->ifc.unmap_single = true;

		st->ifc.unmap_len = len;

		st->ifc.len = len;

		st->ifc.dma_addr = st->ifc.unmap_addr;

	if (likely(!pci_dma_mapping_error(efx->pci_dev, st->unmap_addr))) {

		st->unmap_single = true;

		st->unmap_len = len;

		st->in_len = len;

		st->dma_addr = st->unmap_addr;

		return 0;

	}

	return -ENOMEM;
@@ -911,38 +901,38 @@ static inline int tso_fill_packet_with_fragment(struct efx_tx_queue *tx_queue, 
	struct efx_tx_buffer *buffer;

	int n, end_of_packet, rc;



	if (st->ifc.len == 0)

	if (st->in_len == 0)

		return 0;

	if (st->packet_space == 0)

		return 0;



	EFX_BUG_ON_PARANOID(st->ifc.len <= 0);

	EFX_BUG_ON_PARANOID(st->in_len <= 0);

	EFX_BUG_ON_PARANOID(st->packet_space <= 0);



	n = min(st->ifc.len, st->packet_space);

	n = min(st->in_len, st->packet_space);



	st->packet_space -= n;

	st->remaining_len -= n;

	st->ifc.len -= n;

	st->out_len -= n;

	st->in_len -= n;



	rc = efx_tx_queue_insert(tx_queue, st->ifc.dma_addr, n, &buffer);

	rc = efx_tx_queue_insert(tx_queue, st->dma_addr, n, &buffer);

	if (likely(rc == 0)) {

		if (st->remaining_len == 0)

		if (st->out_len == 0)

			/* Transfer ownership of the skb */

			buffer->skb = skb;



		end_of_packet = st->remaining_len == 0 || st->packet_space == 0;

		end_of_packet = st->out_len == 0 || st->packet_space == 0;

		buffer->continuation = !end_of_packet;



		if (st->ifc.len == 0) {

		if (st->in_len == 0) {

			/* Transfer ownership of the pci mapping */

			buffer->unmap_len = st->ifc.unmap_len;

			buffer->unmap_single = st->ifc.unmap_single;

			st->ifc.unmap_len = 0;

			buffer->unmap_len = st->unmap_len;

			buffer->unmap_single = st->unmap_single;

			st->unmap_len = 0;

		}

	}



	st->ifc.dma_addr += n;

	st->dma_addr += n;

	return rc;

}
@@ -967,7 +957,7 @@ static inline int tso_start_new_packet(struct efx_tx_queue *tx_queue, 
	u8 *header;



	/* Allocate a DMA-mapped header buffer. */

	if (likely(TSOH_SIZE(st->p.header_length) <= TSOH_STD_SIZE)) {

	if (likely(TSOH_SIZE(st->header_len) <= TSOH_STD_SIZE)) {

		if (tx_queue->tso_headers_free == NULL) {

			if (efx_tsoh_block_alloc(tx_queue))

				return -1;
@@ -978,7 +968,7 @@ static inline int tso_start_new_packet(struct efx_tx_queue *tx_queue, 
		tsoh->unmap_len = 0;

	} else {

		tx_queue->tso_long_headers++;

		tsoh = efx_tsoh_heap_alloc(tx_queue, st->p.header_length);

		tsoh = efx_tsoh_heap_alloc(tx_queue, st->header_len);

		if (unlikely(!tsoh))

			return -1;

	}
@@ -988,33 +978,32 @@ static inline int tso_start_new_packet(struct efx_tx_queue *tx_queue, 
	tsoh_iph = (struct iphdr *)(header + SKB_IPV4_OFF(skb));



	/* Copy and update the headers. */

	memcpy(header, skb->data, st->p.header_length);

	memcpy(header, skb->data, st->header_len);



	tsoh_th->seq = htonl(st->seqnum);

	st->seqnum += skb_shinfo(skb)->gso_size;

	if (st->remaining_len > skb_shinfo(skb)->gso_size) {

	if (st->out_len > skb_shinfo(skb)->gso_size) {

		/* This packet will not finish the TSO burst. */

		ip_length = st->p.full_packet_size - ETH_HDR_LEN(skb);

		ip_length = st->full_packet_size - ETH_HDR_LEN(skb);

		tsoh_th->fin = 0;

		tsoh_th->psh = 0;

	} else {

		/* This packet will be the last in the TSO burst. */

		ip_length = (st->p.header_length - ETH_HDR_LEN(skb)

			     + st->remaining_len);

		ip_length = st->header_len - ETH_HDR_LEN(skb) + st->out_len;

		tsoh_th->fin = tcp_hdr(skb)->fin;

		tsoh_th->psh = tcp_hdr(skb)->psh;

	}

	tsoh_iph->tot_len = htons(ip_length);



	/* Linux leaves suitable gaps in the IP ID space for us to fill. */

	tsoh_iph->id = htons(st->p.ipv4_id);

	st->p.ipv4_id++;

	tsoh_iph->id = htons(st->ipv4_id);

	st->ipv4_id++;



	st->packet_space = skb_shinfo(skb)->gso_size;

	++tx_queue->tso_packets;



	/* Form a descriptor for this header. */

	efx_tso_put_header(tx_queue, tsoh, st->p.header_length);

	efx_tso_put_header(tx_queue, tsoh, st->header_len);



	return 0;

}
@@ -1048,7 +1037,7 @@ static int efx_enqueue_skb_tso(struct efx_tx_queue *tx_queue, 
	/* Assume that skb header area contains exactly the headers, and

	 * all payload is in the frag list.

	 */

	if (skb_headlen(skb) == state.p.header_length) {

	if (skb_headlen(skb) == state.header_len) {

		/* Grab the first payload fragment. */

		EFX_BUG_ON_PARANOID(skb_shinfo(skb)->nr_frags < 1);

		frag_i = 0;
@@ -1072,7 +1061,7 @@ static int efx_enqueue_skb_tso(struct efx_tx_queue *tx_queue, 
			goto stop;



		/* Move onto the next fragment? */

		if (state.ifc.len == 0) {

		if (state.in_len == 0) {

			if (++frag_i >= skb_shinfo(skb)->nr_frags)

				/* End of payload reached. */

				break;
@@ -1108,13 +1097,13 @@ static int efx_enqueue_skb_tso(struct efx_tx_queue *tx_queue, 


 unwind:

	/* Free the DMA mapping we were in the process of writing out */

	if (state.ifc.unmap_len) {

		if (state.ifc.unmap_single)

			pci_unmap_single(efx->pci_dev, state.ifc.unmap_addr,

					 state.ifc.unmap_len, PCI_DMA_TODEVICE);

	if (state.unmap_len) {

		if (state.unmap_single)

			pci_unmap_single(efx->pci_dev, state.unmap_addr,

					 state.unmap_len, PCI_DMA_TODEVICE);

		else

			pci_unmap_page(efx->pci_dev, state.ifc.unmap_addr,

				       state.ifc.unmap_len, PCI_DMA_TODEVICE);

			pci_unmap_page(efx->pci_dev, state.unmap_addr,

				       state.unmap_len, PCI_DMA_TODEVICE);

	}



	efx_enqueue_unwind(tx_queue);