From 931015e336b407c157fc663daa0750fdf980bd04 Mon Sep 17 00:00:00 2001 From: John Ousterhout Date: Fri, 13 Dec 2024 10:20:18 -0800 Subject: [PATCH] Rename classes in homa_wire.h to have homa_ prefix --- homa_grant.c | 2 +- homa_impl.h | 2 +- homa_incoming.c | 28 ++++----- homa_offload.c | 21 ++++--- homa_outgoing.c | 58 +++++++++--------- homa_peer.c | 2 +- homa_plumbing.c | 48 +++++++-------- homa_rpc.c | 4 +- homa_rpc.h | 2 +- homa_timer.c | 4 +- homa_utils.c | 32 +++++----- homa_wire.h | 122 +++++++++++++++++++------------------- test/mock.c | 28 ++++----- test/mock.h | 59 +++++++++--------- test/unit_homa_grant.c | 4 +- test/unit_homa_incoming.c | 62 +++++++++---------- test/unit_homa_offload.c | 28 ++++----- test/unit_homa_outgoing.c | 26 ++++---- test/unit_homa_plumbing.c | 8 +-- test/unit_homa_rpc.c | 4 +- test/utils.c | 4 +- 21 files changed, 276 insertions(+), 272 deletions(-) diff --git a/homa_grant.c b/homa_grant.c index 71f40a0..5015fb2 100644 --- a/homa_grant.c +++ b/homa_grant.c @@ -222,7 +222,7 @@ void homa_grant_remove_rpc(struct homa_rpc *rpc) int homa_grant_send(struct homa_rpc *rpc, struct homa *homa) { int incoming, increment, available; - struct grant_header grant; + struct homa_grant_hdr grant; /* Compute how many additional bytes to grant. */ incoming = rpc->msgin.granted - (rpc->msgin.length diff --git a/homa_impl.h b/homa_impl.h index 956feb1..a57b508 100644 --- a/homa_impl.h +++ b/homa_impl.h @@ -943,7 +943,7 @@ static inline struct sk_buff **homa_next_skb(struct sk_buff *skb) * that should be replicated in each segment. The bytes after * this will be distributed among segments. */ -static inline void homa_set_doff(struct data_header *h, int size) +static inline void homa_set_doff(struct homa_data_hdr *h, int size) { h->common.doff = size << 2; } diff --git a/homa_incoming.c b/homa_incoming.c index 80b3bd6..53ce952 100644 --- a/homa_incoming.c +++ b/homa_incoming.c @@ -83,7 +83,7 @@ struct homa_gap *homa_gap_new(struct list_head *next, int start, int end) */ void homa_gap_retry(struct homa_rpc *rpc) { - struct resend_header resend; + struct homa_resend_hdr resend; struct homa_gap *gap; list_for_each_entry(gap, &rpc->msgin.gaps, links) { @@ -105,7 +105,7 @@ void homa_gap_retry(struct homa_rpc *rpc) */ void homa_add_packet(struct homa_rpc *rpc, struct sk_buff *skb) { - struct data_header *h = (struct data_header *)skb->data; + struct homa_data_hdr *h = (struct homa_data_hdr *)skb->data; struct homa_gap *gap, *dummy, *gap2; int start = ntohl(h->seg.offset); int length = homa_data_len(skb); @@ -273,7 +273,7 @@ int homa_copy_to_user(struct homa_rpc *rpc) /* Each iteration of this loop copies out one skb. */ for (i = 0; i < n; i++) { - struct data_header *h = (struct data_header *) + struct homa_data_hdr *h = (struct homa_data_hdr *) skbs[i]->data; int pkt_length = homa_data_len(skbs[i]); int offset = ntohl(h->seg.offset); @@ -365,7 +365,7 @@ void homa_dispatch_pkts(struct sk_buff *skb, struct homa *homa) #define MAX_ACKS 10 #endif /* __UNIT_TEST__ */ const struct in6_addr saddr = skb_canonical_ipv6_saddr(skb); - struct data_header *h = (struct data_header *)skb->data; + struct homa_data_hdr *h = (struct homa_data_hdr *)skb->data; __u64 id = homa_local_id(h->common.sender_id); int dport = ntohs(h->common.dport); @@ -403,7 +403,7 @@ void homa_dispatch_pkts(struct sk_buff *skb, struct homa *homa) /* Each iteration through the following loop processes one packet. */ for (; skb; skb = next) { - h = (struct data_header *)skb->data; + h = (struct homa_data_hdr *)skb->data; next = skb->next; /* Relinquish the RPC lock temporarily if it's needed @@ -560,7 +560,7 @@ void homa_dispatch_pkts(struct sk_buff *skb, struct homa *homa) */ void homa_data_pkt(struct sk_buff *skb, struct homa_rpc *rpc) { - struct data_header *h = (struct data_header *)skb->data; + struct homa_data_hdr *h = (struct homa_data_hdr *)skb->data; struct homa *homa = rpc->hsk->homa; tt_record4("incoming data packet, id %d, peer 0x%x, offset %d/%d", @@ -619,7 +619,7 @@ void homa_data_pkt(struct sk_buff *skb, struct homa_rpc *rpc) * packet. */ if (jiffies != rpc->peer->last_update_jiffies) { - struct cutoffs_header h2; + struct homa_cutoffs_hdr h2; int i; for (i = 0; i < HOMA_MAX_PRIORITIES; i++) { @@ -646,7 +646,7 @@ void homa_data_pkt(struct sk_buff *skb, struct homa_rpc *rpc) */ void homa_grant_pkt(struct sk_buff *skb, struct homa_rpc *rpc) { - struct grant_header *h = (struct grant_header *)skb->data; + struct homa_grant_hdr *h = (struct homa_grant_hdr *)skb->data; int new_offset = ntohl(h->offset); tt_record4("processing grant for id %llu, offset %d, priority %d, increment %d", @@ -680,11 +680,11 @@ void homa_grant_pkt(struct sk_buff *skb, struct homa_rpc *rpc) void homa_resend_pkt(struct sk_buff *skb, struct homa_rpc *rpc, struct homa_sock *hsk) { - struct resend_header *h = (struct resend_header *)skb->data; + struct homa_resend_hdr *h = (struct homa_resend_hdr *)skb->data; #ifndef __STRIP__ /* See strip.py */ const struct in6_addr saddr = skb_canonical_ipv6_saddr(skb); #endif /* See strip.py */ - struct busy_header busy; + struct homa_busy_hdr busy; if (!rpc) { tt_record4("resend request for unknown id %d, peer 0x%x:%d, offset %d; responding with UNKNOWN", @@ -783,7 +783,7 @@ void homa_unknown_pkt(struct sk_buff *skb, struct homa_rpc *rpc) */ void homa_cutoffs_pkt(struct sk_buff *skb, struct homa_sock *hsk) { - struct cutoffs_header *h = (struct cutoffs_header *)skb->data; + struct homa_cutoffs_hdr *h = (struct homa_cutoffs_hdr *)skb->data; const struct in6_addr saddr = skb_canonical_ipv6_saddr(skb); struct homa_peer *peer; int i; @@ -809,11 +809,11 @@ void homa_cutoffs_pkt(struct sk_buff *skb, struct homa_sock *hsk) void homa_need_ack_pkt(struct sk_buff *skb, struct homa_sock *hsk, struct homa_rpc *rpc) { - struct common_header *h = (struct common_header *)skb->data; + struct homa_common_hdr *h = (struct homa_common_hdr *)skb->data; const struct in6_addr saddr = skb_canonical_ipv6_saddr(skb); __u64 id = homa_local_id(h->sender_id); struct homa_peer *peer; - struct ack_header ack; + struct homa_ack_hdr ack; tt_record1("Received NEED_ACK for id %d", id); @@ -871,7 +871,7 @@ void homa_ack_pkt(struct sk_buff *skb, struct homa_sock *hsk, __releases(rpc->bucket_lock) { const struct in6_addr saddr = skb_canonical_ipv6_saddr(skb); - struct ack_header *h = (struct ack_header *)skb->data; + struct homa_ack_hdr *h = (struct homa_ack_hdr *)skb->data; int i, count; if (rpc) { diff --git a/homa_offload.c b/homa_offload.c index c824831..d80fabd 100644 --- a/homa_offload.c +++ b/homa_offload.c @@ -131,7 +131,7 @@ void homa_gro_unhook_tcp(void) struct sk_buff *homa_tcp_gro_receive(struct list_head *held_list, struct sk_buff *skb) { - struct common_header *h = (struct common_header *) + struct homa_common_hdr *h = (struct homa_common_hdr *) skb_transport_header(skb); // tt_record4("homa_tcp_gro_receive got type 0x%x, flags 0x%x, " @@ -231,8 +231,8 @@ struct sk_buff *homa_gso_segment(struct sk_buff *skb, /* This is needed to separate header info (which is replicated * in each segment) from data, which is divided among the segments. */ - __skb_pull(skb, sizeof(struct data_header) - - sizeof(struct seg_header)); + __skb_pull(skb, sizeof(struct homa_data_hdr) + - sizeof(struct homa_seg_hdr)); segs = skb_segment(skb, features); /* Set incrementing ids in each of the segments (mimics behavior @@ -284,8 +284,8 @@ struct sk_buff *homa_gro_receive(struct list_head *held_list, struct homa_offload_core *offload_core; struct homa *homa = global_homa; struct sk_buff *result = NULL; + struct homa_data_hdr *h_new; __u64 *softirq_ns_metric; - struct data_header *h_new; struct sk_buff *held_skb; __u64 now = sched_clock(); int priority; @@ -293,7 +293,7 @@ struct sk_buff *homa_gro_receive(struct list_head *held_list, __u32 hash; int busy; - h_new = (struct data_header *)skb_transport_header(skb); + h_new = (struct homa_data_hdr *)skb_transport_header(skb); offload_core = &per_cpu(homa_offload_core, raw_smp_processor_id()); busy = (now - offload_core->last_gro) < homa->gro_busy_ns; offload_core->last_active = now; @@ -328,7 +328,7 @@ struct sk_buff *homa_gro_receive(struct list_head *held_list, } else if (h_new->common.type == GRANT) { tt_record4("homa_gro_receive got grant from 0x%x id %llu, offset %d, priority %d", saddr, homa_local_id(h_new->common.sender_id), - ntohl(((struct grant_header *)h_new)->offset), + ntohl(((struct homa_grant_hdr *)h_new)->offset), priority); /* The following optimization handles grants here at NAPI * level, bypassing the SoftIRQ mechanism (and avoiding the @@ -476,7 +476,8 @@ void homa_gro_gen2(struct homa *homa, struct sk_buff *skb) * cores. See balance.txt for overall design information on load * balancing. */ - struct data_header *h = (struct data_header *)skb_transport_header(skb); + struct homa_data_hdr *h = + (struct homa_data_hdr *)skb_transport_header(skb); int this_core = raw_smp_processor_id(); struct homa_offload_core *offload_core; int candidate = this_core; @@ -532,7 +533,8 @@ void homa_gro_gen3(struct homa *homa, struct sk_buff *skb) /* See balance.txt for overall design information on the Gen3 * load balancer. */ - struct data_header *h = (struct data_header *)skb_transport_header(skb); + struct homa_data_hdr *h = + (struct homa_data_hdr *)skb_transport_header(skb); __u64 now, busy_time; int *candidates; int i, core; @@ -577,7 +579,8 @@ void homa_gro_gen3(struct homa *homa, struct sk_buff *skb) */ int homa_gro_complete(struct sk_buff *skb, int hoffset) { - struct data_header *h = (struct data_header *)skb_transport_header(skb); + struct homa_data_hdr *h = + (struct homa_data_hdr *)skb_transport_header(skb); struct homa *homa = global_homa; // tt_record4("homa_gro_complete type %d, id %d, offset %d, count %d", diff --git a/homa_outgoing.c b/homa_outgoing.c index 4d56bdd..f1174e2 100644 --- a/homa_outgoing.c +++ b/homa_outgoing.c @@ -34,10 +34,10 @@ void homa_message_out_init(struct homa_rpc *rpc, int length) /** * homa_fill_data_interleaved() - This function is invoked to fill in the * part of a data packet after the initial header, when GSO is being used - * but TCP hijacking is not. As result, seg_headers must be interleaved + * but TCP hijacking is not. As result, homa_seg_hdrs must be interleaved * with the data to provide the correct offset for each segment. * @rpc: RPC whose output message is being created. - * @skb: The packet being filled. The initial data_header was + * @skb: The packet being filled. The initial homa_data_hdr was * created and initialized by the caller and the * homa_skb_info has been filled in with the packet geometry. * @iter: Describes location(s) of (remaining) message data in user @@ -54,11 +54,11 @@ int homa_fill_data_interleaved(struct homa_rpc *rpc, struct sk_buff *skb, int err; /* Each iteration of the following loop adds info for one packet, - * which includes a seg_header followed by the data for that - * segment. The first seg_header was already added by the caller. + * which includes a homa_seg_hdr followed by the data for that + * segment. The first homa_seg_hdr was already added by the caller. */ while (1) { - struct seg_header seg; + struct homa_seg_hdr seg; if (bytes_left < seg_length) seg_length = bytes_left; @@ -104,7 +104,7 @@ struct sk_buff *homa_new_data_packet(struct homa_rpc *rpc, int length, int max_seg_data) { struct homa_skb_info *homa_info; - struct data_header *h; + struct homa_data_hdr *h; struct sk_buff *skb; int err, gso_size; __u64 segs; @@ -113,19 +113,19 @@ struct sk_buff *homa_new_data_packet(struct homa_rpc *rpc, do_div(segs, max_seg_data); /* Initialize the overall skb. */ - skb = homa_skb_new_tx(sizeof32(struct data_header)); + skb = homa_skb_new_tx(sizeof32(struct homa_data_hdr)); if (!skb) return ERR_PTR(-ENOMEM); /* Fill in the Homa header (which will be replicated in every * network packet by GSO). */ - h = (struct data_header *)skb_put(skb, sizeof(struct data_header)); + h = (struct homa_data_hdr *)skb_put(skb, sizeof(struct homa_data_hdr)); h->common.sport = htons(rpc->hsk->port); h->common.dport = htons(rpc->dport); h->common.sequence = htonl(offset); h->common.type = DATA; - homa_set_doff(h, sizeof(struct data_header)); + homa_set_doff(h, sizeof(struct homa_data_hdr)); h->common.flags = HOMA_TCP_FLAGS; h->common.checksum = 0; h->common.urgent = htons(HOMA_TCP_URGENT); @@ -140,17 +140,17 @@ struct sk_buff *homa_new_data_packet(struct homa_rpc *rpc, homa_info = homa_get_skb_info(skb); homa_info->next_skb = NULL; - homa_info->wire_bytes = length + segs * (sizeof(struct data_header) + homa_info->wire_bytes = length + segs * (sizeof(struct homa_data_hdr) + rpc->hsk->ip_header_length + HOMA_ETH_OVERHEAD); homa_info->data_bytes = length; homa_info->seg_length = max_seg_data; homa_info->offset = offset; if (segs > 1 && rpc->hsk->sock.sk_protocol != IPPROTO_TCP) { - homa_set_doff(h, sizeof(struct data_header) - - sizeof32(struct seg_header)); + homa_set_doff(h, sizeof(struct homa_data_hdr) - + sizeof32(struct homa_seg_hdr)); h->seg.offset = htonl(offset); - gso_size = max_seg_data + sizeof(struct seg_header); + gso_size = max_seg_data + sizeof(struct homa_seg_hdr); err = homa_fill_data_interleaved(rpc, skb, iter); } else { gso_size = max_seg_data; @@ -235,14 +235,14 @@ int homa_message_out_fill(struct homa_rpc *rpc, struct iov_iter *iter, int xmit) dst = homa_get_dst(rpc->peer, rpc->hsk); mtu = dst_mtu(dst); max_seg_data = mtu - rpc->hsk->ip_header_length - - sizeof(struct data_header); + - sizeof(struct homa_data_hdr); gso_size = dst->dev->gso_max_size; if (gso_size > rpc->hsk->homa->max_gso_size) gso_size = rpc->hsk->homa->max_gso_size; /* Round gso_size down to an even # of mtus. */ segs_per_gso = gso_size - rpc->hsk->ip_header_length - - sizeof(struct data_header); + - sizeof(struct homa_data_hdr); do_div(segs_per_gso, max_seg_data); if (segs_per_gso == 0) segs_per_gso = 1; @@ -324,7 +324,7 @@ int homa_message_out_fill(struct homa_rpc *rpc, struct iov_iter *iter, int xmit) * @length: Length of @contents (including the common header). * @rpc: The packet will go to the socket that handles the other end * of this RPC. Addressing info for the packet, including all of - * the fields of common_header except type, will be set from this. + * the fields of homa_common_hdr except type, will be set from this. * * Return: Either zero (for success), or a negative errno value if there * was a problem. @@ -332,7 +332,7 @@ int homa_message_out_fill(struct homa_rpc *rpc, struct iov_iter *iter, int xmit) int homa_xmit_control(enum homa_packet_type type, void *contents, size_t length, struct homa_rpc *rpc) { - struct common_header *h = contents; + struct homa_common_hdr *h = contents; h->type = type; h->sport = htons(rpc->hsk->port); @@ -362,7 +362,7 @@ int __homa_xmit_control(void *contents, size_t length, struct homa_peer *peer, #ifndef __STRIP__ /* See strip.py */ struct netdev_queue *txq; #endif /* See strip.py */ - struct common_header *h; + struct homa_common_hdr *h; struct dst_entry *dst; int result, priority; struct sk_buff *skb; @@ -449,9 +449,9 @@ int __homa_xmit_control(void *contents, size_t length, struct homa_peer *peer, */ void homa_xmit_unknown(struct sk_buff *skb, struct homa_sock *hsk) { - struct common_header *h = (struct common_header *)skb->data; + struct homa_common_hdr *h = (struct homa_common_hdr *)skb->data; struct in6_addr saddr = skb_canonical_ipv6_saddr(skb); - struct unknown_header unknown; + struct homa_unknown_hdr unknown; struct homa_peer *peer; if (hsk->homa->verbose) @@ -565,7 +565,7 @@ void __homa_xmit_data(struct sk_buff *skb, struct homa_rpc *rpc, int priority) /* Update info that may have changed since the message was initially * created. */ - ((struct data_header *)skb_transport_header(skb))->cutoff_version = + ((struct homa_data_hdr *)skb_transport_header(skb))->cutoff_version = rpc->peer->cutoff_version; dst = homa_get_dst(rpc->peer, rpc->hsk); @@ -575,7 +575,7 @@ void __homa_xmit_data(struct sk_buff *skb, struct homa_rpc *rpc, int priority) skb->ooo_okay = 1; skb->ip_summed = CHECKSUM_PARTIAL; skb->csum_start = skb_transport_header(skb) - skb->head; - skb->csum_offset = offsetof(struct common_header, checksum); + skb->csum_offset = offsetof(struct homa_common_hdr, checksum); if (rpc->hsk->inet.sk.sk_family == AF_INET6) { tt_record4("calling ip6_xmit: wire_bytes %d, peer 0x%x, id %d, offset %d", homa_get_skb_info(skb)->wire_bytes, @@ -628,7 +628,7 @@ void homa_resend_data(struct homa_rpc *rpc, int start, int end, */ for (skb = rpc->msgout.packets; skb; skb = homa_info->next_skb) { int seg_offset, offset, seg_length, data_left; - struct data_header *h; + struct homa_data_hdr *h; homa_info = homa_get_skb_info(skb); offset = homa_info->offset; @@ -638,13 +638,13 @@ void homa_resend_data(struct homa_rpc *rpc, int start, int end, continue; offset = homa_info->offset; - seg_offset = sizeof32(struct data_header); + seg_offset = sizeof32(struct homa_data_hdr); data_left = homa_info->data_bytes; if (skb_shinfo(skb)->gso_segs <= 1) { seg_length = data_left; } else { seg_length = homa_info->seg_length; - h = (struct data_header *)skb_transport_header(skb); + h = (struct homa_data_hdr *)skb_transport_header(skb); } for ( ; data_left > 0; data_left -= seg_length, offset += seg_length, @@ -662,8 +662,8 @@ void homa_resend_data(struct homa_rpc *rpc, int start, int end, continue; /* This segment must be retransmitted. */ - new_skb = homa_skb_new_tx(sizeof(struct data_header) - - sizeof(struct seg_header)); + new_skb = homa_skb_new_tx(sizeof(struct homa_data_hdr) + - sizeof(struct homa_seg_hdr)); if (unlikely(!new_skb)) { if (rpc->hsk->homa->verbose) pr_notice("%s couldn't allocate skb\n", @@ -672,7 +672,7 @@ void homa_resend_data(struct homa_rpc *rpc, int start, int end, goto resend_done; } h = __skb_put_data(new_skb, skb_transport_header(skb), - sizeof32(struct data_header)); + sizeof32(struct homa_data_hdr)); h->common.sequence = htonl(offset); h->seg.offset = htonl(offset); h->retransmit = 1; @@ -696,7 +696,7 @@ void homa_resend_data(struct homa_rpc *rpc, int start, int end, new_homa_info = homa_get_skb_info(new_skb); new_homa_info->wire_bytes = rpc->hsk->ip_header_length - + sizeof(struct data_header) + + sizeof(struct homa_data_hdr) + seg_length + HOMA_ETH_OVERHEAD; new_homa_info->data_bytes = seg_length; new_homa_info->seg_length = seg_length; diff --git a/homa_peer.c b/homa_peer.c index e1e7f16..b9c433d 100644 --- a/homa_peer.c +++ b/homa_peer.c @@ -383,7 +383,7 @@ void homa_peer_lock_slow(struct homa_peer *peer) void homa_peer_add_ack(struct homa_rpc *rpc) { struct homa_peer *peer = rpc->peer; - struct ack_header ack; + struct homa_ack_hdr ack; homa_peer_lock(peer); if (peer->num_acks < HOMA_MAX_ACKS_PER_PKT) { diff --git a/homa_plumbing.c b/homa_plumbing.c index 7f48ff6..93f1b45 100644 --- a/homa_plumbing.c +++ b/homa_plumbing.c @@ -496,15 +496,15 @@ static struct ctl_table homa_ctl_table[] = { /* Sizes of the headers for each Homa packet type, in bytes. */ static __u16 header_lengths[] = { - sizeof32(struct data_header), - sizeof32(struct grant_header), - sizeof32(struct resend_header), - sizeof32(struct unknown_header), - sizeof32(struct busy_header), - sizeof32(struct cutoffs_header), - sizeof32(struct freeze_header), - sizeof32(struct need_ack_header), - sizeof32(struct ack_header) + sizeof32(struct homa_data_hdr), + sizeof32(struct homa_grant_hdr), + sizeof32(struct homa_resend_hdr), + sizeof32(struct homa_unknown_hdr), + sizeof32(struct homa_busy_hdr), + sizeof32(struct homa_cutoffs_hdr), + sizeof32(struct homa_freeze_hdr), + sizeof32(struct homa_need_ack_hdr), + sizeof32(struct homa_ack_hdr) }; /* Used to remove sysctl values when the module is unloaded. */ @@ -523,11 +523,11 @@ int __init homa_load(void) pr_notice("Homa module loading\n"); #ifndef __STRIP__ /* See strip.py */ - pr_notice("Homa structure sizes: data_header %u, seg_header %u, ack %u, grant_header %u, peer %u, ip_hdr %u flowi %u ipv6_hdr %u, flowi6 %u tcp_sock %u homa_rpc %u sk_buff %u rcvmsg_control %u union sockaddr_in_union %u HOMA_MAX_BPAGES %u NR_CPUS %u nr_cpu_ids %u, MAX_NUMNODES %d\n", - sizeof32(struct data_header), - sizeof32(struct seg_header), + pr_notice("Homa structure sizes: homa_data_hdr %u, homa_seg_hdr %u, ack %u, homa_grant_hdr %u, peer %u, ip_hdr %u flowi %u ipv6_hdr %u, flowi6 %u tcp_sock %u homa_rpc %u sk_buff %u rcvmsg_control %u union sockaddr_in_union %u HOMA_MAX_BPAGES %u NR_CPUS %u nr_cpu_ids %u, MAX_NUMNODES %d\n", + sizeof32(struct homa_data_hdr), + sizeof32(struct homa_seg_hdr), sizeof32(struct homa_ack), - sizeof32(struct grant_header), + sizeof32(struct homa_grant_hdr), sizeof32(struct homa_peer), sizeof32(struct iphdr), sizeof32(struct flowi), @@ -1235,7 +1235,7 @@ int homa_softirq(struct sk_buff *skb) struct sk_buff *packets, *other_pkts, *next; struct sk_buff **prev_link, **other_link; struct homa *homa = global_homa; - struct common_header *h; + struct homa_common_hdr *h; int header_offset; int pull_length; __u64 start; @@ -1277,8 +1277,8 @@ int homa_softirq(struct sk_buff *skb) __skb_pull(skb, header_offset); /* Reject packets that are too short or have bogus types. */ - h = (struct common_header *)skb->data; - if (unlikely(skb->len < sizeof(struct common_header) || + h = (struct homa_common_hdr *)skb->data; + if (unlikely(skb->len < sizeof(struct homa_common_hdr) || h->type < DATA || h->type >= BOGUS || skb->len < header_lengths[h->type - DATA])) { const struct in6_addr saddr = @@ -1311,7 +1311,7 @@ int homa_softirq(struct sk_buff *skb) /* Process the packet now if it is a control packet or * if it contains an entire short message. */ - if (h->type != DATA || ntohl(((struct data_header *)h) + if (h->type != DATA || ntohl(((struct homa_data_hdr *)h) ->message_length) < 1400) { UNIT_LOG("; ", "homa_softirq shortcut type 0x%x", h->type); @@ -1335,7 +1335,7 @@ int homa_softirq(struct sk_buff *skb) */ while (packets) { struct in6_addr saddr, saddr2; - struct common_header *h2; + struct homa_common_hdr *h2; struct sk_buff *skb2; skb = packets; @@ -1343,10 +1343,10 @@ int homa_softirq(struct sk_buff *skb) saddr = skb_canonical_ipv6_saddr(skb); other_pkts = NULL; other_link = &other_pkts; - h = (struct common_header *)skb->data; + h = (struct homa_common_hdr *)skb->data; for (skb2 = skb->next; skb2; skb2 = next) { next = skb2->next; - h2 = (struct common_header *)skb2->data; + h2 = (struct homa_common_hdr *)skb2->data; if (h2->sender_id == h->sender_id) { saddr2 = skb_canonical_ipv6_saddr(skb2); if (ipv6_addr_equal(&saddr, &saddr2)) { @@ -1363,7 +1363,7 @@ int homa_softirq(struct sk_buff *skb) #ifdef __UNIT_TEST__ UNIT_LOG("; ", "id %lld, offsets", homa_local_id(h->sender_id)); for (skb2 = packets; skb2; skb2 = skb2->next) { - struct data_header *h3 = (struct data_header *) + struct homa_data_hdr *h3 = (struct homa_data_hdr *) skb2->data; UNIT_LOG("", " %d", ntohl(h3->seg.offset)); } @@ -1415,7 +1415,7 @@ int homa_err_handler_v4(struct sk_buff *skb, u32 info) iph = (struct iphdr *)(skb->data); daddr = ipv4_to_ipv6(iph->daddr); if (type == ICMP_DEST_UNREACH && code == ICMP_PORT_UNREACH) { - struct common_header *h = (struct common_header *)(skb->data + + struct homa_common_hdr *h = (struct homa_common_hdr *)(skb->data + iph->ihl * 4); port = ntohs(h->dport); @@ -1455,9 +1455,9 @@ int homa_err_handler_v6(struct sk_buff *skb, struct inet6_skb_parm *opt, int port = 0; if (type == ICMPV6_DEST_UNREACH && code == ICMPV6_PORT_UNREACH) { - const struct common_header *h; + const struct homa_common_hdr *h; - h = (struct common_header *)(skb->data + sizeof(*iph)); + h = (struct homa_common_hdr *)(skb->data + sizeof(*iph)); port = ntohs(h->dport); error = -ENOTCONN; } else if (type == ICMPV6_DEST_UNREACH && code == ICMPV6_ADDR_UNREACH) { diff --git a/homa_rpc.c b/homa_rpc.c index 04aa76b..0e1941f 100644 --- a/homa_rpc.c +++ b/homa_rpc.c @@ -108,7 +108,7 @@ struct homa_rpc *homa_rpc_new_client(struct homa_sock *hsk, */ struct homa_rpc *homa_rpc_new_server(struct homa_sock *hsk, const struct in6_addr *source, - struct data_header *h, int *created) + struct homa_data_hdr *h, int *created) __acquires(&srpc->bucket->lock) { __u64 id = homa_local_id(h->common.sender_id); @@ -660,7 +660,7 @@ void homa_rpc_log_active_tt(struct homa *homa, int freeze_count) if (!homa_protect_rpcs(hsk)) continue; list_for_each_entry_rcu(rpc, &hsk->active_rpcs, active_links) { - struct freeze_header freeze; + struct homa_freeze_hdr freeze; count++; homa_rpc_log_tt(rpc); diff --git a/homa_rpc.h b/homa_rpc.h index c6e5043..91aca52 100644 --- a/homa_rpc.h +++ b/homa_rpc.h @@ -432,7 +432,7 @@ struct homa_rpc struct homa_rpc *homa_rpc_new_server(struct homa_sock *hsk, const struct in6_addr *source, - struct data_header *h, int *created); + struct homa_data_hdr *h, int *created); int homa_rpc_reap(struct homa_sock *hsk, int count); char *homa_symbol_for_state(struct homa_rpc *rpc); int homa_validate_incoming(struct homa *homa, int verbose, diff --git a/homa_timer.c b/homa_timer.c index 41966f4..586c081 100644 --- a/homa_timer.c +++ b/homa_timer.c @@ -20,7 +20,7 @@ void homa_check_rpc(struct homa_rpc *rpc) { struct homa *homa = rpc->hsk->homa; - struct resend_header resend; + struct homa_resend_hdr resend; const char *us, *them; /* See if we need to request an ack for this RPC. */ @@ -32,7 +32,7 @@ void homa_check_rpc(struct homa_rpc *rpc) /* >= comparison that handles tick wrap-around. */ if ((rpc->done_timer_ticks + homa->request_ack_ticks - 1 - homa->timer_ticks) & 1 << 31) { - struct need_ack_header h; + struct homa_need_ack_hdr h; homa_xmit_control(NEED_ACK, &h, sizeof(h), rpc); tt_record4("Sent NEED_ACK for RPC id %d to peer 0x%x, port %d, ticks %d", diff --git a/homa_utils.c b/homa_utils.c index c51112f..7c6cc20 100644 --- a/homa_utils.c +++ b/homa_utils.c @@ -270,7 +270,7 @@ char *homa_print_ipv6_addr(const struct in6_addr *addr) */ char *homa_print_packet(struct sk_buff *skb, char *buffer, int buf_len) { - struct common_header *common; + struct homa_common_hdr *common; char header[HOMA_MAX_HEADER]; struct in6_addr saddr; int used = 0; @@ -282,7 +282,7 @@ char *homa_print_packet(struct sk_buff *skb, char *buffer, int buf_len) } homa_skb_get(skb, &header, 0, sizeof(header)); - common = (struct common_header *)header; + common = (struct homa_common_hdr *)header; saddr = skb_canonical_ipv6_saddr(skb); used = homa_snprintf(buffer, buf_len, used, "%s from %s:%u, dport %d, id %llu", @@ -293,7 +293,7 @@ char *homa_print_packet(struct sk_buff *skb, char *buffer, int buf_len) switch (common->type) { case DATA: { struct homa_skb_info *homa_info = homa_get_skb_info(skb); - struct data_header *h = (struct data_header *)header; + struct homa_data_hdr *h = (struct homa_data_hdr *)header; int data_left, i, seg_length, pos, offset; if (skb_shinfo(skb)->gso_segs == 0) { @@ -328,7 +328,7 @@ char *homa_print_packet(struct sk_buff *skb, char *buffer, int buf_len) used = homa_snprintf(buffer, buf_len, used, ", extra segs"); for (i = skb_shinfo(skb)->gso_segs - 1; i > 0; i--) { if (homa_info->seg_length < skb_shinfo(skb)->gso_size) { - struct seg_header seg; + struct homa_seg_hdr seg; homa_skb_get(skb, &seg, pos, sizeof(seg)); offset = ntohl(seg.offset); @@ -345,7 +345,7 @@ char *homa_print_packet(struct sk_buff *skb, char *buffer, int buf_len) break; } case GRANT: { - struct grant_header *h = (struct grant_header *)header; + struct homa_grant_hdr *h = (struct homa_grant_hdr *)header; char *resend = (h->resend_all) ? ", resend_all" : ""; used = homa_snprintf(buffer, buf_len, used, @@ -354,7 +354,7 @@ char *homa_print_packet(struct sk_buff *skb, char *buffer, int buf_len) break; } case RESEND: { - struct resend_header *h = (struct resend_header *)header; + struct homa_resend_hdr *h = (struct homa_resend_hdr *)header; used = homa_snprintf(buffer, buf_len, used, ", offset %d, length %d, resend_prio %u", @@ -369,7 +369,7 @@ char *homa_print_packet(struct sk_buff *skb, char *buffer, int buf_len) /* Nothing to add here. */ break; case CUTOFFS: { - struct cutoffs_header *h = (struct cutoffs_header *)header; + struct homa_cutoffs_hdr *h = (struct homa_cutoffs_hdr *)header; used = homa_snprintf(buffer, buf_len, used, ", cutoffs %d %d %d %d %d %d %d %d, version %u", @@ -391,7 +391,7 @@ char *homa_print_packet(struct sk_buff *skb, char *buffer, int buf_len) /* Nothing to add here. */ break; case ACK: { - struct ack_header *h = (struct ack_header *)header; + struct homa_ack_hdr *h = (struct homa_ack_hdr *)header; int i, count; count = ntohs(h->num_acks); @@ -422,14 +422,14 @@ char *homa_print_packet(struct sk_buff *skb, char *buffer, int buf_len) */ char *homa_print_packet_short(struct sk_buff *skb, char *buffer, int buf_len) { + struct homa_common_hdr *common; char header[HOMA_MAX_HEADER]; - struct common_header *common; - common = (struct common_header *)header; + common = (struct homa_common_hdr *)header; homa_skb_get(skb, header, 0, HOMA_MAX_HEADER); switch (common->type) { case DATA: { - struct data_header *h = (struct data_header *)header; + struct homa_data_hdr *h = (struct homa_data_hdr *)header; struct homa_skb_info *homa_info = homa_get_skb_info(skb); int data_left, used, i, seg_length, pos, offset; @@ -450,7 +450,7 @@ char *homa_print_packet_short(struct sk_buff *skb, char *buffer, int buf_len) seg_length, offset); for (i = skb_shinfo(skb)->gso_segs - 1; i > 0; i--) { if (homa_info->seg_length < skb_shinfo(skb)->gso_size) { - struct seg_header seg; + struct homa_seg_hdr seg; homa_skb_get(skb, &seg, pos, sizeof(seg)); offset = ntohl(seg.offset); @@ -467,7 +467,7 @@ char *homa_print_packet_short(struct sk_buff *skb, char *buffer, int buf_len) break; } case GRANT: { - struct grant_header *h = (struct grant_header *)header; + struct homa_grant_hdr *h = (struct homa_grant_hdr *)header; char *resend = h->resend_all ? " resend_all" : ""; snprintf(buffer, buf_len, "GRANT %d@%d%s", ntohl(h->offset), @@ -475,7 +475,7 @@ char *homa_print_packet_short(struct sk_buff *skb, char *buffer, int buf_len) break; } case RESEND: { - struct resend_header *h = (struct resend_header *)header; + struct homa_resend_hdr *h = (struct homa_resend_hdr *)header; snprintf(buffer, buf_len, "RESEND %d-%d@%d", ntohl(h->offset), ntohl(h->offset) + ntohl(h->length) - 1, @@ -515,7 +515,7 @@ char *homa_print_packet_short(struct sk_buff *skb, char *buffer, int buf_len) void homa_freeze_peers(struct homa *homa) { struct homa_socktab_scan scan; - struct freeze_header freeze; + struct homa_freeze_hdr freeze; struct homa_peer **peers; int num_peers, i, err; struct homa_sock *hsk; @@ -703,7 +703,7 @@ void homa_freeze(struct homa_rpc *rpc, enum homa_freeze_type type, char *format) return; rpc->hsk->homa->freeze_type = 0; if (!tt_frozen) { -// struct freeze_header freeze; +// struct homa_freeze_hdr freeze; int dummy; pr_notice("freezing in %s with freeze_type %d\n", __func__, diff --git a/homa_wire.h b/homa_wire.h index 7a122ef..f0d94c4 100644 --- a/homa_wire.h +++ b/homa_wire.h @@ -71,12 +71,12 @@ enum homa_packet_type { #define HOMA_MAX_PRIORITIES 8 /** - * struct common_header - Wire format for the first bytes in every Homa + * struct homa_common_hdr - Wire format for the first bytes in every Homa * packet. This must (mostly) match the format of a TCP header to enable * Homa packets to actually be transmitted as TCP packets (and thereby * take advantage of TSO and other features). */ -struct common_header { +struct homa_common_hdr { /** * @sport: Port on source machine from which packet was sent. * Must be in the same position as in a TCP header. @@ -108,7 +108,7 @@ struct common_header { /** * @doff: High order 4 bits holds the number of 4-byte chunks in a - * data_header (low-order bits unused). Used only for DATA packets; + * homa_data_hdr (low-order bits unused). Used only for DATA packets; * must be in the same position as the data offset in a TCP header. * Used by TSO to determine where the replicated header portion ends. */ @@ -174,8 +174,8 @@ struct homa_ack { __be16 server_port; } __packed; -/* struct data_header - Contains data for part or all of a Homa message. - * An incoming packet consists of a data_header followed by message data. +/* struct homa_data_hdr - Contains data for part or all of a Homa message. + * An incoming packet consists of a homa_data_hdr followed by message data. * An outgoing packet can have this simple format as well, or it can be * structured as a GSO packet. Homa supports two different formats for GSO * packets, depending on whether TCP hijacking is enabled: @@ -184,7 +184,7 @@ struct homa_ack { * * |-----------------------| |-----------------------| * | | | | - * | data_header | | data_header | + * | homa_data_hdr | | homa_data_hdr | * | | | | * |---------------------- | |-----------------------| * | | | | @@ -193,7 +193,7 @@ struct homa_ack { * | | | | * | | | | * |-----------------------| |-----------------------| - * | seg_header | | | + * | homa_seg_hdr | | | * |-----------------------| | | * | | | segment data | * | | | | @@ -201,7 +201,7 @@ struct homa_ack { * | | |-----------------------| * | | | | * |-----------------------| | | - * | seg_header | | segment data | + * | homa_seg_hdr | | segment data | * |-----------------------| | | * | | | | * | | |-----------------------| @@ -213,12 +213,12 @@ struct homa_ack { * With TCP hijacking, TSO will automatically adjust @common.sequence in * the segments, so that value can be used as the offset of the data within * the message. Without TCP hijacking, TSO will not adjust @common.sequence - * in the segments, so Homa sprinkles correct offsets (in seg_headers) - * throughout the segment data; TSO/GSO will include a different seg_header + * in the segments, so Homa sprinkles correct offsets (in homa_seg_hdrs) + * throughout the segment data; TSO/GSO will include a different homa_seg_hdr * in each generated packet. */ -struct seg_header { +struct homa_seg_hdr { /** * @offset: Offset within message of the first byte of data in * this segment. If this field is -1 it means that the packet was @@ -230,8 +230,8 @@ struct seg_header { __be32 offset; } __packed; -struct data_header { - struct common_header common; +struct homa_data_hdr { + struct homa_common_hdr common; /** @message_length: Total #bytes in the message. */ __be32 message_length; @@ -271,36 +271,36 @@ struct data_header { char pad[3]; /** @seg: First of possibly many segments. */ - struct seg_header seg; + struct homa_seg_hdr seg; } __packed; -_Static_assert(sizeof(struct data_header) <= HOMA_MAX_HEADER, - "data_header too large for HOMA_MAX_HEADER; must adjust HOMA_MAX_HEADER"); -_Static_assert(sizeof(struct data_header) >= HOMA_MIN_PKT_LENGTH, - "data_header too small: Homa doesn't currently have code to pad data packets"); -_Static_assert(((sizeof(struct data_header) - sizeof(struct seg_header)) & +_Static_assert(sizeof(struct homa_data_hdr) <= HOMA_MAX_HEADER, + "homa_data_hdr too large for HOMA_MAX_HEADER; must adjust HOMA_MAX_HEADER"); +_Static_assert(sizeof(struct homa_data_hdr) >= HOMA_MIN_PKT_LENGTH, + "homa_data_hdr too small: Homa doesn't currently have code to pad data packets"); +_Static_assert(((sizeof(struct homa_data_hdr) - sizeof(struct homa_seg_hdr)) & 0x3) == 0, - " data_header length not a multiple of 4 bytes (required for TCP/TSO compatibility"); + " homa_data_hdr length not a multiple of 4 bytes (required for TCP/TSO compatibility"); /** * homa_data_len() - Returns the total number of bytes in a DATA packet - * after the data_header. Note: if the packet is a GSO packet, the result + * after the homa_data_hdr. Note: if the packet is a GSO packet, the result * may include metadata as well as packet data. * @skb: Incoming data packet */ static inline int homa_data_len(struct sk_buff *skb) { return skb->len - skb_transport_offset(skb) - - sizeof(struct data_header); + sizeof(struct homa_data_hdr); } /** - * struct grant_header - Wire format for GRANT packets, which are sent by + * struct homa_grant_hdr - Wire format for GRANT packets, which are sent by * the receiver back to the sender to indicate that the sender may transmit * additional bytes in the message. */ -struct grant_header { +struct homa_grant_hdr { /** @common: Fields common to all packet types. */ - struct common_header common; + struct homa_common_hdr common; /** * @offset: Byte offset within the message. @@ -324,20 +324,20 @@ struct grant_header { */ __u8 resend_all; } __packed; -_Static_assert(sizeof(struct grant_header) <= HOMA_MAX_HEADER, - "grant_header too large for HOMA_MAX_HEADER; must adjust HOMA_MAX_HEADER"); +_Static_assert(sizeof(struct homa_grant_hdr) <= HOMA_MAX_HEADER, + "homa_grant_hdr too large for HOMA_MAX_HEADER; must adjust HOMA_MAX_HEADER"); /** - * struct resend_header - Wire format for RESEND packets. + * struct homa_resend_hdr - Wire format for RESEND packets. * * A RESEND is sent by the receiver when it believes that message data may * have been lost in transmission (or if it is concerned that the sender may * have crashed). The receiver should resend the specified portion of the * message, even if it already sent it previously. */ -struct resend_header { +struct homa_resend_hdr { /** @common: Fields common to all packet types. */ - struct common_header common; + struct homa_common_hdr common; /** * @offset: Offset within the message of the first byte of data that @@ -362,11 +362,11 @@ struct resend_header { */ __u8 priority; } __packed; -_Static_assert(sizeof(struct resend_header) <= HOMA_MAX_HEADER, - "resend_header too large for HOMA_MAX_HEADER; must adjust HOMA_MAX_HEADER"); +_Static_assert(sizeof(struct homa_resend_hdr) <= HOMA_MAX_HEADER, + "homa_resend_hdr too large for HOMA_MAX_HEADER; must adjust HOMA_MAX_HEADER"); /** - * struct unknown_header - Wire format for UNKNOWN packets. + * struct homa_unknown_hdr - Wire format for UNKNOWN packets. * * An UNKNOWN packet is sent by either server or client when it receives a * packet for an RPC that is unknown to it. When a client receives an @@ -374,12 +374,12 @@ _Static_assert(sizeof(struct resend_header) <= HOMA_MAX_HEADER, * when a server receives an UNKNOWN packet it will typically discard its * state for the RPC. */ -struct unknown_header { +struct homa_unknown_hdr { /** @common: Fields common to all packet types. */ - struct common_header common; + struct homa_common_hdr common; } __packed; -_Static_assert(sizeof(struct unknown_header) <= HOMA_MAX_HEADER, - "unknown_header too large for HOMA_MAX_HEADER; must adjust HOMA_MAX_HEADER"); +_Static_assert(sizeof(struct homa_unknown_hdr) <= HOMA_MAX_HEADER, + "homa_unknown_hdr too large for HOMA_MAX_HEADER; must adjust HOMA_MAX_HEADER"); /** * struct busy_header - Wire format for BUSY packets. @@ -387,22 +387,22 @@ _Static_assert(sizeof(struct unknown_header) <= HOMA_MAX_HEADER, * These packets tell the recipient that the sender is still alive (even if * it isn't sending data expected by the recipient). */ -struct busy_header { +struct homa_busy_hdr { /** @common: Fields common to all packet types. */ - struct common_header common; + struct homa_common_hdr common; } __packed; -_Static_assert(sizeof(struct busy_header) <= HOMA_MAX_HEADER, - "busy_header too large for HOMA_MAX_HEADER; must adjust HOMA_MAX_HEADER"); +_Static_assert(sizeof(struct homa_busy_hdr) <= HOMA_MAX_HEADER, + "homa_busy_hdr too large for HOMA_MAX_HEADER; must adjust HOMA_MAX_HEADER"); /** - * struct cutoffs_header - Wire format for CUTOFFS packets. + * struct homa_cutoffs_hdr - Wire format for CUTOFFS packets. * * These packets tell the recipient how to assign priorities to * unscheduled packets. */ -struct cutoffs_header { +struct homa_cutoffs_hdr { /** @common: Fields common to all packet types. */ - struct common_header common; + struct homa_common_hdr common; /** * @unsched_cutoffs: priorities to use for unscheduled packets @@ -418,45 +418,45 @@ struct cutoffs_header { */ __be16 cutoff_version; } __packed; -_Static_assert(sizeof(struct cutoffs_header) <= HOMA_MAX_HEADER, - "cutoffs_header too large for HOMA_MAX_HEADER; must adjust HOMA_MAX_HEADER"); +_Static_assert(sizeof(struct homa_cutoffs_hdr) <= HOMA_MAX_HEADER, + "homa_cutoffs_hdr too large for HOMA_MAX_HEADER; must adjust HOMA_MAX_HEADER"); /** - * struct freeze_header - Wire format for FREEZE packets. + * struct homa_freeze_hdr - Wire format for FREEZE packets. * * These packets tell the recipient to freeze its timetrace; used * for debugging. */ -struct freeze_header { +struct homa_freeze_hdr { /** @common: Fields common to all packet types. */ - struct common_header common; + struct homa_common_hdr common; } __packed; -_Static_assert(sizeof(struct freeze_header) <= HOMA_MAX_HEADER, - "freeze_header too large for HOMA_MAX_HEADER; must adjust HOMA_MAX_HEADER"); +_Static_assert(sizeof(struct homa_freeze_hdr) <= HOMA_MAX_HEADER, + "homa_freeze_hdr too large for HOMA_MAX_HEADER; must adjust HOMA_MAX_HEADER"); /** - * struct need_ack_header - Wire format for NEED_ACK packets. + * struct homa_need_ack_hdr - Wire format for NEED_ACK packets. * * These packets ask the recipient (a client) to return an ACK message if * the packet's RPC is no longer active. */ -struct need_ack_header { +struct homa_need_ack_hdr { /** @common: Fields common to all packet types. */ - struct common_header common; + struct homa_common_hdr common; } __packed; -_Static_assert(sizeof(struct need_ack_header) <= HOMA_MAX_HEADER, - "need_ack_header too large for HOMA_MAX_HEADER; must adjust HOMA_MAX_HEADER"); +_Static_assert(sizeof(struct homa_need_ack_hdr) <= HOMA_MAX_HEADER, + "homa_need_ack_hdr too large for HOMA_MAX_HEADER; must adjust HOMA_MAX_HEADER"); /** - * struct ack_header - Wire format for ACK packets. + * struct homa_ack_hdr - Wire format for ACK packets. * * These packets are sent from a client to a server to indicate that * a set of RPCs is no longer active on the client, so the server can * free any state it may have for them. */ -struct ack_header { +struct homa_ack_hdr { /** @common: Fields common to all packet types. */ - struct common_header common; + struct homa_common_hdr common; /** @num_acks: Number of (leading) elements in @acks that are valid. */ __be16 num_acks; @@ -465,8 +465,8 @@ struct ack_header { /** @acks: Info about RPCs that are no longer active. */ struct homa_ack acks[HOMA_MAX_ACKS_PER_PKT]; } __packed; -_Static_assert(sizeof(struct ack_header) <= HOMA_MAX_HEADER, - "ack_header too large for HOMA_MAX_HEADER; must adjust HOMA_MAX_HEADER"); +_Static_assert(sizeof(struct homa_ack_hdr) <= HOMA_MAX_HEADER, + "homa_ack_hdr too large for HOMA_MAX_HEADER; must adjust HOMA_MAX_HEADER"); /** * homa_local_id(): given an RPC identifier from an input packet (which diff --git a/test/mock.c b/test/mock.c index 3e43beb..39865a5 100644 --- a/test/mock.c +++ b/test/mock.c @@ -835,7 +835,7 @@ void mutex_unlock(struct mutex *lock) int netif_receive_skb(struct sk_buff *skb) { - struct data_header *h = (struct data_header *) + struct homa_data_hdr *h = (struct homa_data_hdr *) skb_transport_header(skb); unit_log_printf("; ", "netif_receive_skb, id %llu, offset %d", be64_to_cpu(h->common.sender_id), ntohl(h->seg.offset)); @@ -1084,7 +1084,7 @@ struct sk_buff *skb_segment(struct sk_buff *head_skb, netdev_features_t features) { struct sk_buff *skb1, *skb2; - struct data_header h; + struct homa_data_hdr h; int offset, length; /* Split the existing packet into two packets. */ @@ -1428,7 +1428,7 @@ void mock_set_ipv6(struct homa_sock *hsk) * Return: A packet buffer containing the information described above. * The caller owns this buffer and is responsible for freeing it. */ -struct sk_buff *mock_skb_new(struct in6_addr *saddr, struct common_header *h, +struct sk_buff *mock_skb_new(struct in6_addr *saddr, struct homa_common_hdr *h, int extra_bytes, int first_value) { int header_size, ip_size, data_size, shinfo_size; @@ -1438,34 +1438,34 @@ struct sk_buff *mock_skb_new(struct in6_addr *saddr, struct common_header *h, if (h) { switch (h->type) { case DATA: - header_size = sizeof(struct data_header); + header_size = sizeof(struct homa_data_hdr); break; case GRANT: - header_size = sizeof(struct grant_header); + header_size = sizeof(struct homa_grant_hdr); break; case RESEND: - header_size = sizeof(struct resend_header); + header_size = sizeof(struct homa_resend_hdr); break; case UNKNOWN: - header_size = sizeof(struct unknown_header); + header_size = sizeof(struct homa_unknown_hdr); break; case BUSY: - header_size = sizeof(struct busy_header); + header_size = sizeof(struct homa_busy_hdr); break; case CUTOFFS: - header_size = sizeof(struct cutoffs_header); + header_size = sizeof(struct homa_cutoffs_hdr); break; case FREEZE: - header_size = sizeof(struct freeze_header); + header_size = sizeof(struct homa_freeze_hdr); break; case NEED_ACK: - header_size = sizeof(struct need_ack_header); + header_size = sizeof(struct homa_need_ack_hdr); break; case ACK: - header_size = sizeof(struct ack_header); + header_size = sizeof(struct homa_ack_hdr); break; default: - header_size = sizeof(struct common_header); + header_size = sizeof(struct homa_common_hdr); break; } } else { @@ -1553,7 +1553,7 @@ void mock_sock_init(struct homa_sock *hsk, struct homa *homa, int port) homa_sock_bind(homa->port_map, hsk, port); hsk->inet.pinet6 = &hsk_pinfo; mock_mtu = UNIT_TEST_DATA_PER_PACKET + hsk->ip_header_length - + sizeof(struct data_header); + + sizeof(struct homa_data_hdr); mock_net_device.gso_max_size = mock_mtu; homa_pool_init(hsk, (void *) 0x1000000, 100*HOMA_BPAGE_SIZE); } diff --git a/test/mock.h b/test/mock.h index a83ee10..36b0375 100644 --- a/test/mock.h +++ b/test/mock.h @@ -44,34 +44,35 @@ extern int mock_vmalloc_errors; extern int mock_xmit_log_verbose; extern int mock_xmit_log_homa_info; -extern struct page * +struct page * mock_alloc_pages(gfp_t gfp, unsigned order); -extern int mock_check_error(int *errorMask); -extern void mock_clear_xmit_prios(void); -extern void mock_data_ready(struct sock *sk); -extern cycles_t mock_get_cycles(void); -extern unsigned int - mock_get_mtu(const struct dst_entry *dst); -extern void mock_get_page(struct page *page); -extern int mock_page_refs(struct page *page); -extern int mock_page_refs(struct page *page); -extern void mock_put_page(struct page *page); -extern void mock_rcu_read_lock(void); -extern void mock_rcu_read_unlock(void); -extern struct ctl_table_header * - mock_register_net_sysctl(struct net *net, - const char *path, struct ctl_table *table); -extern void mock_set_core(int num); -extern void mock_set_ipv6(struct homa_sock *hsk); -extern void mock_spin_lock(spinlock_t *lock); -extern void mock_spin_unlock(spinlock_t *lock); -extern int mock_skb_count(void); -extern struct sk_buff * - mock_skb_new(struct in6_addr *saddr, struct common_header *h, +int mock_check_error(int *errorMask); +void mock_clear_xmit_prios(void); +void mock_data_ready(struct sock *sk); +cycles_t mock_get_cycles(void); +unsigned int + mock_get_mtu(const struct dst_entry *dst); +void mock_get_page(struct page *page); +int mock_page_refs(struct page *page); +int mock_page_refs(struct page *page); +void mock_put_page(struct page *page); +void mock_rcu_read_lock(void); +void mock_rcu_read_unlock(void); +struct ctl_table_header * + mock_register_net_sysctl(struct net *net, + const char *path, + struct ctl_table *table); +void mock_set_core(int num); +void mock_set_ipv6(struct homa_sock *hsk); +void mock_spin_lock(spinlock_t *lock); +void mock_spin_unlock(spinlock_t *lock); +int mock_skb_count(void); +struct sk_buff * + mock_skb_new(struct in6_addr *saddr, struct homa_common_hdr *h, int extra_bytes, int first_value); -extern void mock_sock_destroy(struct homa_sock *hsk, - struct homa_socktab *socktab); -extern void mock_sock_init(struct homa_sock *hsk, struct homa *homa, - int port); -extern void mock_teardown(void); -extern void *mock_vmalloc(size_t size); +void mock_sock_destroy(struct homa_sock *hsk, + struct homa_socktab *socktab); +void mock_sock_init(struct homa_sock *hsk, struct homa *homa, + int port); +void mock_teardown(void); +void *mock_vmalloc(size_t size); diff --git a/test/unit_homa_grant.c b/test/unit_homa_grant.c index b26e2c0..c99fda4 100644 --- a/test/unit_homa_grant.c +++ b/test/unit_homa_grant.c @@ -45,7 +45,7 @@ FIXTURE(homa_grant) { union sockaddr_in_union server_addr; struct homa homa; struct homa_sock hsk; - struct data_header data; + struct homa_data_hdr data; int incoming_delta; }; FIXTURE_SETUP(homa_grant) @@ -78,7 +78,7 @@ FIXTURE_SETUP(homa_grant) self->server_addr.in6.sin6_family = self->hsk.inet.sk.sk_family; self->server_addr.in6.sin6_addr = self->server_ip[0]; self->server_addr.in6.sin6_port = htons(self->server_port); - self->data = (struct data_header){.common = { + self->data = (struct homa_data_hdr){.common = { .sport = htons(self->client_port), .dport = htons(self->server_port), .type = DATA, diff --git a/test/unit_homa_incoming.c b/test/unit_homa_incoming.c index 3d59f34..7df7145 100644 --- a/test/unit_homa_incoming.c +++ b/test/unit_homa_incoming.c @@ -130,7 +130,7 @@ FIXTURE(homa_incoming) { struct homa homa; struct homa_sock hsk; struct homa_sock hsk2; - struct data_header data; + struct homa_data_hdr data; struct homa_interest interest; }; FIXTURE_SETUP(homa_incoming) @@ -157,7 +157,7 @@ FIXTURE_SETUP(homa_incoming) self->server_addr.in6.sin6_family = self->hsk.inet.sk.sk_family; self->server_addr.in6.sin6_addr = self->server_ip[0]; self->server_addr.in6.sin6_port = htons(self->server_port); - self->data = (struct data_header){.common = { + self->data = (struct homa_data_hdr){.common = { .sport = htons(self->client_port), .dport = htons(self->server_port), .type = DATA, @@ -926,7 +926,7 @@ TEST_F(homa_incoming, homa_dispatch_pkts__non_data_packet_for_existing_server_rp struct homa_rpc *srpc = unit_server_rpc(&self->hsk2, UNIT_IN_SERVICE, self->client_ip, self->server_ip, self->client_port, self->server_id, 10000, 100); - struct resend_header resend = {.common = { + struct homa_resend_hdr resend = {.common = { .sport = htons(self->client_port), .dport = htons(self->server_port), .type = RESEND, @@ -951,7 +951,7 @@ TEST_F(homa_incoming, homa_dispatch_pkts__existing_client_rpc) EXPECT_EQ(10000, crpc->msgout.granted); unit_log_clear(); - struct grant_header h = {{.sport = htons(self->server_port), + struct homa_grant_hdr h = {{.sport = htons(self->server_port), .dport = htons(self->hsk.port), .sender_id = cpu_to_be64(self->server_id), .type = GRANT}, @@ -964,7 +964,7 @@ TEST_F(homa_incoming, homa_dispatch_pkts__existing_client_rpc) } TEST_F(homa_incoming, homa_dispatch_pkts__unknown_client_rpc) { - struct grant_header h = {{.sport = htons(self->server_port), + struct homa_grant_hdr h = {{.sport = htons(self->server_port), .dport = htons(self->hsk.port), .sender_id = cpu_to_be64(99991), .type = UNKNOWN}}; @@ -976,7 +976,7 @@ TEST_F(homa_incoming, homa_dispatch_pkts__unknown_client_rpc) } TEST_F(homa_incoming, homa_dispatch_pkts__unknown_server_rpc) { - struct resend_header h = {{.sport = htons(self->client_port), + struct homa_resend_hdr h = {{.sport = htons(self->client_port), .dport = htons(self->server_port), .sender_id = cpu_to_be64(99990), .type = GRANT}}; @@ -988,7 +988,7 @@ TEST_F(homa_incoming, homa_dispatch_pkts__unknown_server_rpc) } TEST_F(homa_incoming, homa_dispatch_pkts__cutoffs_for_unknown_client_rpc) { - struct cutoffs_header h = {{.sport = htons(self->server_port), + struct homa_cutoffs_hdr h = {{.sport = htons(self->server_port), .dport = htons(self->hsk.port), .sender_id = cpu_to_be64(99991), .type = CUTOFFS}, @@ -1009,7 +1009,7 @@ TEST_F(homa_incoming, homa_dispatch_pkts__cutoffs_for_unknown_client_rpc) } TEST_F(homa_incoming, homa_dispatch_pkts__resend_for_unknown_server_rpc) { - struct resend_header h = {{.sport = htons(self->client_port), + struct homa_resend_hdr h = {{.sport = htons(self->client_port), .dport = htons(self->hsk.port), .sender_id = cpu_to_be64(99990), .type = RESEND}, @@ -1024,7 +1024,7 @@ TEST_F(homa_incoming, homa_dispatch_pkts__reset_counters) struct homa_rpc *crpc = unit_client_rpc(&self->hsk, UNIT_OUTGOING, self->client_ip, self->server_ip, self->server_port, self->client_id, 20000, 1600); - struct grant_header h = {.common = {.sport = htons(self->server_port), + struct homa_grant_hdr h = {.common = {.sport = htons(self->server_port), .dport = htons(self->hsk.port), .sender_id = cpu_to_be64(self->server_id), .type = GRANT}, @@ -1059,7 +1059,7 @@ TEST_F(homa_incoming, homa_dispatch_pkts__unknown_type) EXPECT_EQ(10000, crpc->msgout.granted); unit_log_clear(); - struct common_header h = {.sport = htons(self->server_port), + struct homa_common_hdr h = {.sport = htons(self->server_port), .dport = htons(self->hsk.port), .sender_id = cpu_to_be64(self->server_id), .type = 99}; homa_dispatch_pkts(mock_skb_new(self->client_ip, &h, 0, 0), &self->homa); @@ -1331,7 +1331,7 @@ TEST_F(homa_incoming, homa_grant_pkt__basics) struct homa_rpc *srpc = unit_server_rpc(&self->hsk, UNIT_OUTGOING, self->client_ip, self->server_ip, self->client_port, self->server_id, 100, 20000); - struct grant_header h = {{.sport = htons(srpc->dport), + struct homa_grant_hdr h = {{.sport = htons(srpc->dport), .dport = htons(self->hsk.port), .sender_id = cpu_to_be64(self->client_id), .type = GRANT}, @@ -1373,7 +1373,7 @@ TEST_F(homa_incoming, homa_grant_pkt__reset) struct homa_rpc *srpc = unit_server_rpc(&self->hsk, UNIT_OUTGOING, self->client_ip, self->server_ip, self->client_port, self->server_id, 100, 20000); - struct grant_header h = {{.sport = htons(srpc->dport), + struct homa_grant_hdr h = {{.sport = htons(srpc->dport), .dport = htons(self->hsk.port), .sender_id = cpu_to_be64(self->client_id), .type = GRANT}, @@ -1405,7 +1405,7 @@ TEST_F(homa_incoming, homa_grant_pkt__grant_past_end_of_message) struct homa_rpc *crpc = unit_client_rpc(&self->hsk, UNIT_OUTGOING, self->client_ip, self->server_ip, self->server_port, self->client_id, 20000, 1600); - struct grant_header h = {{.sport = htons(self->server_port), + struct homa_grant_hdr h = {{.sport = htons(self->server_port), .dport = htons(self->hsk.port), .sender_id = cpu_to_be64(self->server_id), .type = GRANT}, @@ -1421,7 +1421,7 @@ TEST_F(homa_incoming, homa_grant_pkt__grant_past_end_of_message) TEST_F(homa_incoming, homa_resend_pkt__unknown_rpc) { - struct resend_header h = {{.sport = htons(self->client_port), + struct homa_resend_hdr h = {{.sport = htons(self->client_port), .dport = htons(self->server_port), .sender_id = cpu_to_be64(self->client_id), .type = RESEND}, @@ -1435,7 +1435,7 @@ TEST_F(homa_incoming, homa_resend_pkt__unknown_rpc) } TEST_F(homa_incoming, homa_resend_pkt__rpc_in_service_server_sends_busy) { - struct resend_header h = {{.sport = htons(self->client_port), + struct homa_resend_hdr h = {{.sport = htons(self->client_port), .dport = htons(self->server_port), .sender_id = cpu_to_be64(self->client_id), .type = RESEND}, @@ -1458,7 +1458,7 @@ TEST_F(homa_incoming, homa_resend_pkt__rpc_incoming_server_sends_busy) /* Entire msgin has not been received yet. But we have received * everything we have granted so far. */ - struct resend_header h = {{.sport = htons(self->client_port), + struct homa_resend_hdr h = {{.sport = htons(self->client_port), .dport = htons(self->server_port), .sender_id = cpu_to_be64(self->client_id), .type = RESEND}, @@ -1483,7 +1483,7 @@ TEST_F(homa_incoming, homa_resend_pkt__client_not_outgoing) /* Important to respond to resends even if client thinks the * server must already have received everything. */ - struct resend_header h = {{.sport = htons(self->server_port), + struct homa_resend_hdr h = {{.sport = htons(self->server_port), .dport = htons(self->hsk.port), .sender_id = cpu_to_be64(self->server_id), .type = RESEND}, @@ -1503,7 +1503,7 @@ TEST_F(homa_incoming, homa_resend_pkt__client_not_outgoing) } TEST_F(homa_incoming, homa_resend_pkt__send_busy_instead_of_data) { - struct resend_header h = {{.sport = htons(self->server_port), + struct homa_resend_hdr h = {{.sport = htons(self->server_port), .dport = htons(self->hsk.port), .sender_id = cpu_to_be64(self->server_id), .type = RESEND}, @@ -1523,7 +1523,7 @@ TEST_F(homa_incoming, homa_resend_pkt__send_busy_instead_of_data) } TEST_F(homa_incoming, homa_resend_pkt__client_send_data) { - struct resend_header h = {{.sport = htons(self->server_port), + struct homa_resend_hdr h = {{.sport = htons(self->server_port), .dport = htons(self->hsk.port), .sender_id = cpu_to_be64(self->server_id), .type = RESEND}, @@ -1546,7 +1546,7 @@ TEST_F(homa_incoming, homa_resend_pkt__client_send_data) } TEST_F(homa_incoming, homa_resend_pkt__server_send_data) { - struct resend_header h = {{.sport = htons(self->client_port), + struct homa_resend_hdr h = {{.sport = htons(self->client_port), .dport = htons(self->hsk.port), .sender_id = cpu_to_be64(self->client_id), .type = RESEND}, @@ -1571,7 +1571,7 @@ TEST_F(homa_incoming, homa_resend_pkt__server_send_data) TEST_F(homa_incoming, homa_unknown_pkt__client_resend_all) { - struct unknown_header h = {{.sport = htons(self->server_port), + struct homa_unknown_hdr h = {{.sport = htons(self->server_port), .dport = htons(self->hsk.port), .sender_id = cpu_to_be64(self->server_id), .type = UNKNOWN}}; @@ -1593,7 +1593,7 @@ TEST_F(homa_incoming, homa_unknown_pkt__client_resend_all) } TEST_F(homa_incoming, homa_unknown_pkt__client_resend_part) { - struct unknown_header h = {{.sport = htons(self->server_port), + struct homa_unknown_hdr h = {{.sport = htons(self->server_port), .dport = htons(self->hsk.port), .sender_id = cpu_to_be64(self->server_id), .type = UNKNOWN}}; @@ -1615,7 +1615,7 @@ TEST_F(homa_incoming, homa_unknown_pkt__client_resend_part) } TEST_F(homa_incoming, homa_unknown_pkt__free_server_rpc) { - struct unknown_header h = {{.sport = htons(self->client_port), + struct homa_unknown_hdr h = {{.sport = htons(self->client_port), .dport = htons(self->hsk2.port), .sender_id = cpu_to_be64(self->client_id), .type = UNKNOWN}}; @@ -1636,7 +1636,7 @@ TEST_F(homa_incoming, homa_cutoffs_pkt_basics) struct homa_rpc *crpc = unit_client_rpc(&self->hsk, UNIT_OUTGOING, self->client_ip, self->server_ip, self->server_port, self->client_id, 20000, 1600); - struct cutoffs_header h = {{.sport = htons(self->server_port), + struct homa_cutoffs_hdr h = {{.sport = htons(self->server_port), .dport = htons(self->hsk.port), .sender_id = cpu_to_be64(self->server_id), .type = CUTOFFS}, @@ -1656,7 +1656,7 @@ TEST_F(homa_incoming, homa_cutoffs_pkt_basics) } TEST_F(homa_incoming, homa_cutoffs__cant_find_peer) { - struct cutoffs_header h = {{.sport = htons(self->server_port), + struct homa_cutoffs_hdr h = {{.sport = htons(self->server_port), .dport = htons(self->hsk.port), .sender_id = cpu_to_be64(self->server_id), .type = CUTOFFS}, @@ -1680,7 +1680,7 @@ TEST_F(homa_incoming, homa_need_ack_pkt__rpc_response_fully_received) struct homa_rpc *crpc = unit_client_rpc(&self->hsk, UNIT_RCVD_MSG, self->client_ip, self->server_ip, self->server_port, self->client_id, 100, 3000); - struct need_ack_header h = {.common = { + struct homa_need_ack_hdr h = {.common = { .sport = htons(self->server_port), .dport = htons(self->hsk.port), .sender_id = cpu_to_be64(self->server_id), @@ -1701,7 +1701,7 @@ TEST_F(homa_incoming, homa_need_ack_pkt__rpc_response_not_fully_received) struct homa_rpc *crpc = unit_client_rpc(&self->hsk, UNIT_RCVD_ONE_PKT, self->client_ip, self->server_ip, self->server_port, self->client_id, 100, 3000); - struct need_ack_header h = {.common = { + struct homa_need_ack_hdr h = {.common = { .sport = htons(self->server_port), .dport = htons(self->hsk.port), .sender_id = cpu_to_be64(self->server_id), @@ -1721,7 +1721,7 @@ TEST_F(homa_incoming, homa_need_ack_pkt__rpc_not_incoming) struct homa_rpc *crpc = unit_client_rpc(&self->hsk, UNIT_OUTGOING, self->client_ip, self->server_ip, self->server_port, self->client_id, 100, 3000); - struct need_ack_header h = {.common = { + struct homa_need_ack_hdr h = {.common = { .sport = htons(self->server_port), .dport = htons(self->hsk.port), .sender_id = cpu_to_be64(self->server_id), @@ -1740,7 +1740,7 @@ TEST_F(homa_incoming, homa_need_ack_pkt__rpc_doesnt_exist) { struct homa_peer *peer = homa_peer_find(self->homa.peers, self->server_ip, &self->hsk.inet); - struct need_ack_header h = {.common = { + struct homa_need_ack_hdr h = {.common = { .sport = htons(self->server_port), .dport = htons(self->hsk.port), .sender_id = cpu_to_be64(self->server_id), @@ -1761,7 +1761,7 @@ TEST_F(homa_incoming, homa_ack_pkt__target_rpc_exists) struct homa_rpc *srpc = unit_server_rpc(&self->hsk2, UNIT_OUTGOING, self->client_ip, self->server_ip, self->client_port, self->server_id, 100, 5000); - struct ack_header h = {.common = { + struct homa_ack_hdr h = {.common = { .sport = htons(self->client_port), .dport = htons(self->hsk2.port), .sender_id = cpu_to_be64(self->client_id), @@ -1785,7 +1785,7 @@ TEST_F(homa_incoming, homa_ack_pkt__target_rpc_doesnt_exist) struct homa_rpc *srpc2 = unit_server_rpc(&self->hsk2, UNIT_OUTGOING, self->client_ip, self->server_ip, self->client_port, self->server_id+2, 100, 5000); - struct ack_header h = {.common = { + struct homa_ack_hdr h = {.common = { .sport = htons(self->client_port), .dport = htons(self->hsk2.port), .sender_id = cpu_to_be64(self->client_id + 10), diff --git a/test/unit_homa_offload.c b/test/unit_homa_offload.c index a1cdfaf..a745ac6 100644 --- a/test/unit_homa_offload.c +++ b/test/unit_homa_offload.c @@ -29,7 +29,7 @@ FIXTURE(homa_offload) struct homa homa; struct homa_sock hsk; struct in6_addr ip; - struct data_header header; + struct homa_data_hdr header; struct napi_struct napi; struct sk_buff *skb, *skb2; struct list_head empty_list; @@ -45,7 +45,7 @@ FIXTURE_SETUP(homa_offload) global_homa = &self->homa; mock_sock_init(&self->hsk, &self->homa, 99); self->ip = unit_get_in_addr("196.168.0.1"); - self->header = (struct data_header){.common = { + self->header = (struct homa_data_hdr){.common = { .sport = htons(40000), .dport = htons(99), .type = DATA, .flags = HOMA_TCP_FLAGS, @@ -130,13 +130,13 @@ TEST_F(homa_offload, homa_gro_hook_tcp) TEST_F(homa_offload, homa_tcp_gro_receive__pass_to_tcp) { - struct common_header *h; + struct homa_common_hdr *h; struct sk_buff *skb; homa_gro_hook_tcp(); self->header.seg.offset = htonl(6000); skb = mock_skb_new(&self->ip, &self->header.common, 1400, 0); - h = (struct common_header *) skb_transport_header(skb); + h = (struct homa_common_hdr *) skb_transport_header(skb); h->flags = 0; EXPECT_EQ(NULL, homa_tcp_gro_receive(&self->empty_list, skb)); EXPECT_STREQ("tcp_gro_receive", unit_log_get()); @@ -144,7 +144,7 @@ TEST_F(homa_offload, homa_tcp_gro_receive__pass_to_tcp) unit_log_clear(); skb = mock_skb_new(&self->ip, &self->header.common, 1400, 0); - h = (struct common_header *)skb_transport_header(skb); + h = (struct homa_common_hdr *)skb_transport_header(skb); h->urgent -= 1; EXPECT_EQ(NULL, homa_tcp_gro_receive(&self->empty_list, skb)); EXPECT_STREQ("tcp_gro_receive", unit_log_get()); @@ -153,7 +153,7 @@ TEST_F(homa_offload, homa_tcp_gro_receive__pass_to_tcp) } TEST_F(homa_offload, homa_tcp_gro_receive__pass_to_homa_ipv6) { - struct common_header *h; + struct homa_common_hdr *h; struct sk_buff *skb; mock_ipv6 = true; @@ -161,7 +161,7 @@ TEST_F(homa_offload, homa_tcp_gro_receive__pass_to_homa_ipv6) self->header.seg.offset = htonl(6000); skb = mock_skb_new(&self->ip, &self->header.common, 1400, 0); ip_hdr(skb)->protocol = IPPROTO_TCP; - h = (struct common_header *)skb_transport_header(skb); + h = (struct homa_common_hdr *)skb_transport_header(skb); h->flags = HOMA_TCP_FLAGS; h->urgent = htons(HOMA_TCP_URGENT); NAPI_GRO_CB(skb)->same_flow = 0; @@ -176,7 +176,7 @@ TEST_F(homa_offload, homa_tcp_gro_receive__pass_to_homa_ipv6) } TEST_F(homa_offload, homa_tcp_gro_receive__pass_to_homa_ipv4) { - struct common_header *h; + struct homa_common_hdr *h; struct sk_buff *skb; mock_ipv6 = false; @@ -184,7 +184,7 @@ TEST_F(homa_offload, homa_tcp_gro_receive__pass_to_homa_ipv4) self->header.seg.offset = htonl(6000); skb = mock_skb_new(&self->ip, &self->header.common, 1400, 0); ip_hdr(skb)->protocol = IPPROTO_TCP; - h = (struct common_header *)skb_transport_header(skb); + h = (struct homa_common_hdr *)skb_transport_header(skb); h->flags = HOMA_TCP_FLAGS; h->urgent = htons(HOMA_TCP_URGENT); NAPI_GRO_CB(skb)->same_flow = 0; @@ -222,7 +222,7 @@ TEST_F(homa_offload, homa_gso_segment_set_ip_ids) TEST_F(homa_offload, homa_gro_receive__update_offset_from_sequence) { struct sk_buff *skb, *skb2; - struct data_header *h; + struct homa_data_hdr *h; /* First call: copy offset from sequence number. */ self->header.common.sequence = htonl(6000); @@ -232,7 +232,7 @@ TEST_F(homa_offload, homa_gro_receive__update_offset_from_sequence) cur_offload_core->held_skb = NULL; cur_offload_core->held_bucket = 99; EXPECT_EQ(NULL, homa_gro_receive(&self->empty_list, skb)); - h = (struct data_header *) skb_transport_header(skb); + h = (struct homa_data_hdr *) skb_transport_header(skb); EXPECT_EQ(6000, htonl(h->seg.offset)); /* Second call: offset already valid. */ @@ -241,7 +241,7 @@ TEST_F(homa_offload, homa_gro_receive__update_offset_from_sequence) skb2 = mock_skb_new(&self->ip, &self->header.common, 1400, 0); NAPI_GRO_CB(skb2)->same_flow = 0; EXPECT_EQ(NULL, homa_gro_receive(&self->empty_list, skb2)); - h = (struct data_header *)skb_transport_header(skb2); + h = (struct homa_data_hdr *)skb_transport_header(skb2); EXPECT_EQ(5000, htonl(h->seg.offset)); kfree_skb(skb); @@ -257,7 +257,7 @@ TEST_F(homa_offload, homa_gro_receive__HOMA_GRO_SHORT_BYPASS) __u64 server_id = 1235; struct homa_rpc *srpc; int server_port = 99; - struct data_header h; + struct homa_data_hdr h; h.common.sport = htons(40000); h.common.dport = htons(server_port); @@ -318,11 +318,11 @@ TEST_F(homa_offload, homa_gro_receive__fast_grant_optimization) struct in6_addr client_ip = unit_get_in_addr("196.168.0.1"); struct in6_addr server_ip = unit_get_in_addr("1.2.3.4"); struct sk_buff *skb, *skb2, *skb3, *result; + struct homa_grant_hdr h; int client_port = 40000; __u64 client_id = 1234; __u64 server_id = 1235; struct homa_rpc *srpc; - struct grant_header h; srpc = unit_server_rpc(&self->hsk, UNIT_OUTGOING, &client_ip, &server_ip, client_port, server_id, 100, diff --git a/test/unit_homa_outgoing.c b/test/unit_homa_outgoing.c index 24477c6..a1c32b5 100644 --- a/test/unit_homa_outgoing.c +++ b/test/unit_homa_outgoing.c @@ -74,8 +74,8 @@ FIXTURE_TEARDOWN(homa_outgoing) TEST_F(homa_outgoing, set_priority__priority_mapping) { + struct homa_grant_hdr h; struct homa_rpc *srpc; - struct grant_header h; srpc = unit_server_rpc(&self->hsk, UNIT_RCVD_ONE_PKT, self->client_ip, self->server_ip, self->client_port, 1111, 10000, 10000); @@ -110,8 +110,8 @@ TEST_F(homa_outgoing, homa_fill_data_interleaved) EXPECT_STREQ("DATA from 0.0.0.0:40000, dport 99, id 2, message_length 10000, offset 10000, data_length 1500, incoming 10000, extra segs 1500@11500 1500@13000 500@14500", homa_print_packet(skb, buffer, sizeof(buffer))); - EXPECT_EQ(5000 + sizeof32(struct data_header) - + 3*sizeof32(struct seg_header), skb->len); + EXPECT_EQ(5000 + sizeof32(struct homa_data_hdr) + + 3*sizeof32(struct homa_seg_hdr), skb->len); kfree_skb(skb); } TEST_F(homa_outgoing, homa_fill_data_interleaved__error_copying_data) @@ -187,7 +187,7 @@ TEST_F(homa_outgoing, homa_new_data_packet__multiple_segments_homa_fill_data_int EXPECT_STREQ("DATA from 0.0.0.0:40000, dport 99, id 2, message_length 10000, offset 10000, data_length 1500, incoming 10000, extra segs 1500@11500 1500@13000 500@14500", homa_print_packet(skb, buffer, sizeof(buffer))); - EXPECT_EQ(4*(sizeof(struct data_header) + crpc->hsk->ip_header_length + EXPECT_EQ(4*(sizeof(struct homa_data_hdr) + crpc->hsk->ip_header_length + HOMA_ETH_OVERHEAD) + 5000, homa_get_skb_info(skb)->wire_bytes); EXPECT_EQ(5000, homa_get_skb_info(skb)->data_bytes); @@ -262,7 +262,7 @@ TEST_F(homa_outgoing, homa_new_data_packet__gso_information) skb = homa_new_data_packet(crpc, iter, 10000, 5000, 1500); EXPECT_EQ(4, skb_shinfo(skb)->gso_segs); - EXPECT_EQ(1500 + sizeof(struct seg_header), + EXPECT_EQ(1500 + sizeof(struct homa_seg_hdr), skb_shinfo(skb)->gso_size); EXPECT_EQ(SKB_GSO_TCPV6, skb_shinfo(skb)->gso_type); kfree_skb(skb); @@ -377,7 +377,7 @@ TEST_F(homa_outgoing, homa_message_out_fill__include_acks) { struct homa_rpc *crpc = homa_rpc_new_client(&self->hsk, &self->server_addr); - struct data_header h; + struct homa_data_hdr h; ASSERT_FALSE(crpc == NULL); crpc->peer->acks[0] = (struct homa_ack) { @@ -469,8 +469,8 @@ TEST_F(homa_outgoing, homa_message_out_fill__too_short_for_pipelining) TEST_F(homa_outgoing, homa_xmit_control__server_request) { + struct homa_grant_hdr h; struct homa_rpc *srpc; - struct grant_header h; homa_sock_bind(self->homa.port_map, &self->hsk, self->server_port); srpc = unit_server_rpc(&self->hsk, UNIT_RCVD_ONE_PKT, self->client_ip, @@ -491,8 +491,8 @@ TEST_F(homa_outgoing, homa_xmit_control__server_request) } TEST_F(homa_outgoing, homa_xmit_control__client_response) { + struct homa_grant_hdr h; struct homa_rpc *crpc; - struct grant_header h; crpc = unit_client_rpc(&self->hsk, UNIT_RCVD_ONE_PKT, self->client_ip, self->server_ip, self->server_port, self->client_id, @@ -512,8 +512,8 @@ TEST_F(homa_outgoing, homa_xmit_control__client_response) TEST_F(homa_outgoing, __homa_xmit_control__cant_alloc_skb) { + struct homa_grant_hdr h; struct homa_rpc *srpc; - struct grant_header h; srpc = unit_server_rpc(&self->hsk, UNIT_RCVD_ONE_PKT, self->client_ip, self->server_ip, self->client_port, 1111, 10000, 10000); @@ -533,7 +533,7 @@ TEST_F(homa_outgoing, __homa_xmit_control__cant_alloc_skb) TEST_F(homa_outgoing, __homa_xmit_control__pad_packet) { struct homa_rpc *srpc; - struct busy_header h; + struct homa_busy_hdr h; srpc = unit_server_rpc(&self->hsk, UNIT_RCVD_ONE_PKT, self->client_ip, self->server_ip, self->client_port, 1111, 10000, 10000); @@ -546,8 +546,8 @@ TEST_F(homa_outgoing, __homa_xmit_control__pad_packet) } TEST_F(homa_outgoing, __homa_xmit_control__ipv4_error) { + struct homa_grant_hdr h; struct homa_rpc *srpc; - struct grant_header h; // Make sure the test uses IPv4. mock_ipv6 = false; @@ -570,8 +570,8 @@ TEST_F(homa_outgoing, __homa_xmit_control__ipv4_error) } TEST_F(homa_outgoing, __homa_xmit_control__ipv6_error) { + struct homa_grant_hdr h; struct homa_rpc *srpc; - struct grant_header h; // Make sure the test uses IPv6. mock_ipv6 = true; @@ -595,7 +595,7 @@ TEST_F(homa_outgoing, __homa_xmit_control__ipv6_error) TEST_F(homa_outgoing, homa_xmit_unknown) { - struct grant_header h = {{.sport = htons(self->client_port), + struct homa_grant_hdr h = {{.sport = htons(self->client_port), .dport = htons(self->server_port), .sender_id = cpu_to_be64(99990), .type = GRANT}, diff --git a/test/unit_homa_plumbing.c b/test/unit_homa_plumbing.c index e57500d..0444ec5 100644 --- a/test/unit_homa_plumbing.c +++ b/test/unit_homa_plumbing.c @@ -32,7 +32,7 @@ FIXTURE(homa_plumbing) { struct homa_sock hsk; union sockaddr_in_union client_addr; union sockaddr_in_union server_addr; - struct data_header data; + struct homa_data_hdr data; int starting_skb_count; struct msghdr recvmsg_hdr; struct homa_recvmsg_args recvmsg_args; @@ -67,7 +67,7 @@ FIXTURE_SETUP(homa_plumbing) ipv6_to_ipv4(self->server_addr.in6.sin6_addr); } homa_sock_bind(self->homa.port_map, &self->hsk, self->server_port); - self->data = (struct data_header){.common = { + self->data = (struct homa_data_hdr){.common = { .sport = htons(self->client_port), .dport = htons(self->server_port), .type = DATA, @@ -828,7 +828,7 @@ TEST_F(homa_plumbing, homa_softirq__remove_extra_headers) TEST_F(homa_plumbing, homa_softirq__packet_too_short) { struct sk_buff *skb; - struct ack_header h; + struct homa_ack_hdr h; h.common.type = ACK; skb = mock_skb_new(self->client_ip, &h.common, 0, 0); @@ -876,7 +876,7 @@ TEST_F(homa_plumbing, homa_softirq__process_short_messages_first) } TEST_F(homa_plumbing, homa_softirq__process_control_first) { - struct common_header unknown = { + struct homa_common_hdr unknown = { .sport = htons(self->client_port), .dport = htons(self->server_port), .type = UNKNOWN, diff --git a/test/unit_homa_rpc.c b/test/unit_homa_rpc.c index c0497b7..d1d03fe 100644 --- a/test/unit_homa_rpc.c +++ b/test/unit_homa_rpc.c @@ -22,7 +22,7 @@ FIXTURE(homa_rpc) { struct homa homa; struct homa_sock hsk; union sockaddr_in_union server_addr; - struct data_header data; + struct homa_data_hdr data; struct homa_rpc *crpc; struct iovec iovec; struct iov_iter iter; @@ -40,7 +40,7 @@ FIXTURE_SETUP(homa_rpc) self->server_addr.in6.sin6_port = htons(self->server_port); homa_init(&self->homa); mock_sock_init(&self->hsk, &self->homa, 0); - self->data = (struct data_header){.common = { + self->data = (struct homa_data_hdr){.common = { .sport = htons(self->client_port), .dport = htons(self->server_port), .type = DATA, diff --git a/test/utils.c b/test/utils.c index c97b4ce..81d397b 100644 --- a/test/utils.c +++ b/test/utils.c @@ -58,7 +58,7 @@ struct homa_rpc *unit_client_rpc(struct homa_sock *hsk, return crpc; crpc->msgout.next_xmit_offset = crpc->msgout.length; - struct data_header h = { + struct homa_data_hdr h = { .common = { .sport = htons(server_port), .dport = htons(hsk->port), @@ -352,7 +352,7 @@ struct homa_rpc *unit_server_rpc(struct homa_sock *hsk, int req_length, int resp_length) { int bytes_received, created; - struct data_header h = { + struct homa_data_hdr h = { .common = { .sport = htons(client_port), .dport = htons(hsk->port),